diff --git a/.gitattributes b/.gitattributes index ce53f571c9161fcdec23318c15aca56fcd38b10e..27bf82c2abfc7cba01dbc7a99b7773c05e7b5455 100644 --- a/.gitattributes +++ b/.gitattributes @@ -790,3 +790,24 @@ preprints/Weighted-Dilation-Graphs-Smooth-Shifted-Primes-and-Totient-Fibers-Sept preprints/Weil-classes-and-Hodge-classes-on-abelian-powers-September-30-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text preprints/Witnessed-symmetric-choice-is-strictly-stronger-than-choiceless-polynomial-time-with-counting-September-24-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text preprints/Zero-Plane-Rigidity-for-Einstein-Four-Manifolds-October-4-2026/einstein-boundary.pdf filter=lfs diff=lfs merge=lfs -text +preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/exact-bsd-low-selmer-corank.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/main.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/manuscript.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/main.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/numerical-generalized-abundance.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf filter=lfs diff=lfs merge=lfs -text +preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/termination-generalized-lc-kahler-fourfolds.pdf filter=lfs diff=lfs merge=lfs -text +preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/main.pdf filter=lfs diff=lfs merge=lfs -text +preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/paper.pdf filter=lfs diff=lfs merge=lfs -text +preprints/The-p-adic-section-conjecture-October-6-2026/main.pdf filter=lfs diff=lfs merge=lfs -text diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ConnectedSupport.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ConnectedSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..1abff9dfb44fa3276005e36e395c7827950a1b72 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ConnectedSupport.lean @@ -0,0 +1,153 @@ +import OAI.Topology.ArtinGroups.Complexes.BlockClosed +import OAI.Topology.ArtinGroups.Complexes.HomDetector +import OAI.Topology.ArtinGroups.Complexes.DiagonalVertex +import OAI.Topology.ArtinGroups.Complexes.ColorBoundary +import OAI.Topology.ArtinGroups.Harmonic.FusionOrbitModel + +namespace OAI + +/-! +# Connected support of transported indecomposable projectives + +This proves the support-cut form of the connectedness assertion in +Proposition 2.7 of paper 082-03. The input is the dimension of the actual +endomorphism cohomology, rather than an assumed connectedness property. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable + +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + {I : Type*} [Fintype I] [DecidableEq I] + +private noncomputable def blockProjector (E : BasedComplex Q (K := K) I) (T : Set I) + (hT : BlockClosed Q E T) : Map Q E E := + (blockProjectionMap Q E T hT).comp Q (blockInclusionMap Q E T hT) + +omit [Fintype V] [DecidableEq A] in +private theorem blockProjector_diagonal (E : BasedComplex Q (K := K) I) + (T : Set I) (hT : BlockClosed Q E T) (i : I) : + diagonalVertex Q E i (blockProjector Q E T hT).matrix = if i ∈ T then 1 else 0 := by + change ((blockProjection Q E T * blockInclusion Q E T) i i).vertex _ = _ + by_cases hi : i ∈ T + · rw [Matrix.mul_apply, Finset.sum_eq_single (⟨i, hi⟩ : T)] + · simp [blockProjection, blockInclusion, projectiveIdentity, hi, vertexId_mul_self] + · intro j _ hji + have hne : i ≠ (j : I) := fun he => hji (Subtype.ext he.symm) + simp [blockProjection, projectiveIdentity, hne] + · simp + · have hz : (blockProjection Q E T * blockInclusion Q E T) i i = 0 := by + apply Finset.sum_eq_zero + intro j _ + have hne : i ≠ (j : I) := fun he => hi (he.symm ▸ j.property) + simp [blockProjection, projectiveIdentity, hne] + simp [hz, hi] + +omit [DecidableEq A] in +/-- A minimal complex with at most one-dimensional degree-zero +endomorphism cohomology cannot have two nonempty differential blocks. -/ +theorem no_proper_block (E : BasedComplex Q (K := K) I) (hE : E.IsMinimal Q) + (hd : homDimension Q E E 0 0 ≤ 1) (T : Set I) (hT : BlockClosed Q E T) + (i j : I) (hi : i ∈ T) (hj : j ∉ T) : False := by + have hf := map_mem_homCycles Q (blockProjector Q E T hT) + have hb := boundary_of_homDimension_le_one Q E E 0 0 hd + (diagonalVertex Q E j) (fun _ h => diagonalVertex_boundary Q E hE j 0 0 h) + (identity_mem_homCycles Q E) (by rw [diagonalVertex_identity]; exact one_ne_zero) + hf (by rw [blockProjector_diagonal]; simp [hj]) + have hz := diagonalVertex_boundary Q E hE i 0 0 hb + have he : diagonalVertex Q E i (blockProjector Q E T hT).matrix = 1 := by + rw [blockProjector_diagonal] + simp only [hi, ↓reduceIte] + rw [he] at hz + exact one_ne_zero hz + +omit [Fintype V] [DecidableEq A] [DecidableEq I] in +/-- Nonzero minimal differential entries either stay at one color or +follow an arrow of the quiver. This includes the token entries between +successive layers. -/ +theorem differential_same_or_arrow (E : BasedComplex Q (K := K) I) + (hE : E.IsMinimal Q) (i j : I) (hn : E.differential i j ≠ 0) : + (E.placement i).color = (E.placement j).color ∨ + ∃ a : A, Q.source a = (E.placement i).color ∧ + Q.target a = (E.placement j).color := by + by_cases hc : (E.placement i).color = (E.placement j).color + · exact Or.inl hc + right + by_contra ha + push Not at ha + apply hn + apply ReversibleQuiver.Zigzag.ext + · exact hE i j + · funext a + by_contra hnz + have hh := coordinates_corner Q (E.entries.1 i j) (E.entries.2 i j) + (p := .inr (.inl a)) hnz + exact ha a hh.1 hh.2 + · funext v + by_contra hnz + have hh := coordinates_corner Q (E.entries.1 i j) (E.entries.2 i j) + (p := .inr (.inr v)) hnz + exact hc (hh.1.symm.trans hh.2) + +omit [DecidableEq A] in +/-- If the support meets both a color set and its complement, it must +meet the exterior boundary of that set. This is the exact support fact +needed to find a boundary level below an isolated null layer. -/ +theorem support_meets_boundary (E : BasedComplex Q (K := K) I) (hE : E.IsMinimal Q) + (hd : homDimension Q E E 0 0 ≤ 1) (U : Set V) + (i j : I) (hi : (E.placement i).color ∈ U) (hj : (E.placement j).color ∉ U) : + ∃ k : I, (E.placement k).color ∈ colorBoundary Q U := by + by_contra hb + push Not at hb + apply no_proper_block Q E hE hd {k | (E.placement k).color ∈ U} _ i j hi hj + intro a b hn + rcases differential_same_or_arrow Q E hE a b hn with he | ⟨c, hs, ht⟩ + · change (E.placement a).color ∈ U ↔ (E.placement b).color ∈ U + rw [he] + · constructor + · intro ha + by_contra hnb + exact hb b ⟨hnb, c, hs ▸ ha, ht⟩ + · intro hbb + change (E.placement b).color ∈ U at hbb + by_contra hna + exact hb a ⟨hna, Q.reverse c, + by simpa only [Q.source_reverse, ht] using hbb, + by simpa only [Q.target_reverse] using hs⟩ + +section Fusion + +variable {E W : Type} [Fintype E] [DecidableEq E] [Fintype W] [DecidableEq W] + (m : E → ℕ) (d : W → W → FusionEdge E) (hd : ∀ s t, d s t = d t s) + (hdiag : ∀ s, d s s = .units 0) + +/-- The preceding support statement applies unconditionally to the +minimal representative of every transported projective in the fusion +packet action. -/ +theorem fusionOrbit_support_meets_boundary (w : List (W × Bool)) (s : W) + (L : FusionLabel m) (U : Set (FusionVertex (V := W) m)) + (i j : (fusionOrbitModel m d hd hdiag w s L).Index) + (hi : ((fusionOrbitModel m d hd hdiag w s L).complex.placement i).color ∈ U) + (hj : ((fusionOrbitModel m d hd hdiag w s L).complex.placement j).color ∉ U) : + ∃ k : (fusionOrbitModel m d hd hdiag w s L).Index, + ((fusionOrbitModel m d hd hdiag w s L).complex.placement k).color ∈ + colorBoundary (fusionQuiver m d hd) U := by + apply support_meets_boundary (fusionQuiver m d hd) _ + (fusionOrbitModel_minimal m d hd hdiag w s L) _ U i j hi hj + change homDimension (fusionQuiver m d hd) + (minimalClassModel (fusionQuiver m d hd) (fusionPacketOrbit m d hd hdiag w s L)).complex + (minimalClassModel (fusionQuiver m d hd) (fusionPacketOrbit m d hd hdiag w s L)).complex + 0 0 ≤ 1 + rw [minimalClassModel_homDimension, fusionOrbit_homDimension] + exact initial_homDimension_le_one (fusionQuiver m d hd) + (fusionQuiver_no_loops m d hd hdiag) (s, L) 0 0 + +end Fusion + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/Consequences.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/Consequences.lean new file mode 100644 index 0000000000000000000000000000000000000000..35bed1f70efda20e75935985057375e66fbb434e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/Consequences.lean @@ -0,0 +1,153 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.Basic + +namespace OAI + +/-! +# Consequences of the inside-parabolic intersection theorem + +These are the deductions in the introduction of paper 082-03. The premise +`InsideIntersectionProperty` is a **new result of that paper**, not a +published input and not an established instance. These deductions alone +do not constitute a formalization of its main intersection theorem. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +variable {S : Type*} (M : CoxeterMatrix S) + +/-- The inside-parabolic conclusion of §8. Its proof, for arbitrary +Artin matrices, must come from the relative stabilizer argument. -/ +def InsideIntersectionProperty : Prop := + ∀ (X Y : Set S) (g : Artin M), ∃ (Z : Set S) (c : Artin M), + Z ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + artinParabolic M Y ⊓ conjugate g (artinParabolic M X) = + conjugate c (artinParabolic M Z) + +theorem inside_conjugate (h : InsideIntersectionProperty M) + (Y : Set S) (g : Artin M) {P : Subgroup (Artin M)} (hP : IsParabolic M P) : + ∃ (Z : Set S) (c : Artin M), Z ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + conjugate g (artinParabolic M Y) ⊓ P = + conjugate (g * c) (artinParabolic M Z) := by + obtain ⟨X, a, rfl⟩ := hP + obtain ⟨Z, c, hZ, hc, he⟩ := h X Y (g⁻¹ * a) + refine ⟨Z, c, hZ, hc, ?_⟩ + have hh := congrArg (conjugate g) he + rw [conjugate_inf, ← conjugate_mul, ← conjugate_mul] at hh + simpa only [mul_inv_cancel_left] using hh + +/-- The exact pairwise statement of Theorem 1.1, deduced from its stronger +inside-parabolic form. The hypothesis still needs to be proved. -/ +theorem pairwise_of_inside (h : InsideIntersectionProperty M) + (X Y : Set S) (g a : Artin M) : + ∃ (Z : Set S) (k : Artin M), + conjugate g (artinParabolic M X) ⊓ conjugate a (artinParabolic M Y) = + conjugate k (artinParabolic M Z) := by + obtain ⟨Z, c, _, _, he⟩ := inside_conjugate M h X g + (show IsParabolic M (conjugate a (artinParabolic M Y)) from ⟨Y, a, rfl⟩) + exact ⟨Z, g * c, he⟩ + +theorem isParabolic_inf (h : InsideIntersectionProperty M) + {P Q : Subgroup (Artin M)} (hP : IsParabolic M P) (hQ : IsParabolic M Q) : + IsParabolic M (P ⊓ Q) := by + obtain ⟨X, g, rfl⟩ := hP + obtain ⟨Y, a, rfl⟩ := hQ + exact pairwise_of_inside M h X Y g a + +private theorem insert_intersection {G : Type*} [Group G] + [DecidableEq (Subgroup G)] + (P : Subgroup G) (F : Finset (Subgroup G)) : + sInf (↑(insert P F) : Set (Subgroup G)) = P ⊓ sInf (↑F : Set (Subgroup G)) := by + classical + rw [Finset.coe_insert, sInf_insert] + +variable [Finite S] + +/-- The descent uses the displayed type, so no separate theorem asserting +that parabolic rank is invariant under conjugation is required. -/ +private theorem finite_subfamily_aux (h : InsideIntersectionProperty M) + (F : Set (Subgroup (Artin M))) (hF : ∀ P ∈ F, IsParabolic M P) : + ∀ n : ℕ, ∀ (X : Set S), X.ncard = n → ∀ g : Artin M, + ∃ F₀ : Finset (Subgroup (Artin M)), + (↑F₀ : Set (Subgroup (Artin M))) ⊆ F ∧ F₀.card ≤ n ∧ + conjugate g (artinParabolic M X) ⊓ sInf F = + conjugate g (artinParabolic M X) ⊓ sInf (↑F₀ : Set (Subgroup (Artin M))) ∧ + IsParabolic M (conjugate g (artinParabolic M X) ⊓ sInf F) := by + classical + intro n + induction n using Nat.strong_induction_on with + | h n ih => + intro X hX g + let Q := conjugate g (artinParabolic M X) + by_cases hQ : Q ≤ sInf F + · refine ⟨∅, by simp, by simp, ?_, ?_⟩ + · simp only [Finset.coe_empty, sInf_empty, inf_top_eq] + exact inf_eq_left.mpr hQ + · change IsParabolic M (Q ⊓ sInf F) + rw [inf_eq_left.mpr hQ] + exact ⟨X, g, rfl⟩ + · obtain ⟨P, hPF, hQP⟩ : ∃ P ∈ F, ¬ Q ≤ P := by + by_contra hn + push Not at hn + exact hQ (le_sInf hn) + obtain ⟨Z, c, hZX, hc, he⟩ := inside_conjugate M h X g (hF P hPF) + have hne : Z ≠ X := by + intro hz + rw [hz, conjugate_mul, conjugate_eq_self hc] at he + exact hQP (inf_eq_left.mp he) + have hlt : Z.ncard < n := by + rw [← hX] + exact Set.ncard_lt_ncard (ssubset_of_subset_of_ne hZX hne) + obtain ⟨F₀, hF₀, hcard, hEq, hPar⟩ := ih Z.ncard hlt Z rfl (g * c) + refine ⟨insert P F₀, ?_, ?_, ?_, ?_⟩ + · intro A hA + rcases Finset.mem_insert.mp hA with rfl | hA + · exact hPF + · exact hF₀ hA + · have hi := Finset.card_insert_le P F₀ + omega + · rw [insert_intersection] + calc + Q ⊓ sInf F = (Q ⊓ P) ⊓ sInf F := by + rw [inf_assoc, inf_eq_right.mpr (sInf_le hPF)] + _ = conjugate (g * c) (artinParabolic M Z) ⊓ sInf F := by rw [he] + _ = conjugate (g * c) (artinParabolic M Z) ⊓ sInf (↑F₀ : Set _) := hEq + _ = Q ⊓ (P ⊓ sInf (↑F₀ : Set _)) := by rw [← he, inf_assoc] + · have heF : Q ⊓ sInf F = + conjugate (g * c) (artinParabolic M Z) ⊓ sInf F := by + rw [← he, inf_assoc, inf_eq_right.mpr (sInf_le hPF)] + rw [heF] + exact hPar + +/-- The full subfamily bound in Corollary 1.2, including the empty family. +This is conditional on the new inside-intersection theorem, explicitly. -/ +theorem arbitrary_intersections_of_inside (h : InsideIntersectionProperty M) + (F : Set (Subgroup (Artin M))) (hF : ∀ P ∈ F, IsParabolic M P) : + (∃ F₀ : Finset (Subgroup (Artin M)), + (↑F₀ : Set (Subgroup (Artin M))) ⊆ F ∧ F₀.card ≤ Nat.card S ∧ + sInf F = sInf (↑F₀ : Set (Subgroup (Artin M)))) ∧ + IsParabolic M (sInf F) := by + obtain ⟨F₀, hF₀, hcard, he, hp⟩ := + finite_subfamily_aux M h F hF (Set.univ : Set S).ncard Set.univ rfl 1 + simp only [standard_univ, conjugate_top, top_inf_eq, Set.ncard_univ] at he hp hcard + exact ⟨⟨F₀, hF₀, hcard, he⟩, hp⟩ + +/-- The unique smallest parabolic containing an arbitrary subset, rather +than merely a smallest parabolic containing a finite set. -/ +theorem parabolic_closure_of_inside (h : InsideIntersectionProperty M) + (E : Set (Artin M)) : + ∃! P : Subgroup (Artin M), IsParabolic M P ∧ E ⊆ P ∧ + ∀ Q : Subgroup (Artin M), IsParabolic M Q → E ⊆ Q → P ≤ Q := by + let F := {P : Subgroup (Artin M) | IsParabolic M P ∧ E ⊆ P} + have hp := (arbitrary_intersections_of_inside M h F (fun _ hP => hP.1)).2 + have he : E ⊆ (sInf F : Subgroup (Artin M)) := by + intro a ha + exact Subgroup.mem_sInf.mpr (fun P hP => hP.2 ha) + refine ⟨sInf F, ⟨hp, he, ?_⟩, ?_⟩ + · intro Q hQ hEQ + exact sInf_le ⟨hQ, hEQ⟩ + · intro Q hQ + exact le_antisymm (hQ.2.2 _ hp he) (sInf_le ⟨hQ.1, hQ.2.1⟩) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CosetContainment.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CosetContainment.lean new file mode 100644 index 0000000000000000000000000000000000000000..f3afe802eea790fe0dd653168320bafb3ac294b8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CosetContainment.lean @@ -0,0 +1,89 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.Basic +import OAI.Topology.ArtinGroups.Harmonic.Coset + +namespace OAI + +/-! +# Confining paths of parabolic cosets + +This is the coset argument in Proposition 6.9 of paper 082-03. A path +whose types stay in one set cannot escape its standard coset. The proof +uses actual subgroup cosets, including upward as well as downward edges. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +variable {S : Type*} (M : CoxeterMatrix S) + +/-- A smaller-type coset through a point of a larger-type coset is +contained in that larger coset. -/ +theorem rightCoset_subset_of_point {T D : Set S} (hTD : T ⊆ D) + {w z : Artin M} (hw : w ∈ rightCoset M D z) : + rightCoset M T w ⊆ rightCoset M D z := by + intro a ha + change a * w⁻¹ ∈ artinParabolic M T at ha + change w * z⁻¹ ∈ artinParabolic M D at hw + change a * z⁻¹ ∈ artinParabolic M D + have hh := (artinParabolic M D).mul_mem (standard_mono M hTD ha) hw + simpa only [mul_assoc, inv_mul_cancel_left] using hh + +/-- A represented parabolic coset can be recentered at each of its points. -/ +theorem deligne_coset_eq_at_point (P : Deligne M) (w : Artin M) (hw : w ∈ P.val.2) : + P.val.2 = rightCoset M P.val.1 w := by + obtain ⟨z, hz⟩ := P.property.2 + rw [hz] at hw ⊢ + ext a + change a * z⁻¹ ∈ artinParabolic M P.val.1 ↔ a * w⁻¹ ∈ artinParabolic M P.val.1 + have he : a * z⁻¹ = (a * w⁻¹) * (w * z⁻¹) := by group + rw [he] + exact (artinParabolic M P.val.1).mul_mem_cancel_right hw + +/-- Upward comparability preserves containment when the larger type is +still contained in the specified standard type. -/ +theorem deligne_upper_contained {P R : Deligne M} (hPR : P ≤ R) + (D : Set S) (z : Artin M) (hR : R.val.1 ⊆ D) + (hP : P.val.2 ⊆ rightCoset M D z) : R.val.2 ⊆ rightCoset M D z := by + obtain ⟨w, hw⟩ : P.val.2.Nonempty := by + obtain ⟨w, hw⟩ := P.property.2 + refine ⟨w, ?_⟩ + rw [hw] + change w * w⁻¹ ∈ artinParabolic M P.val.1 + simp + rw [deligne_coset_eq_at_point M R w (hPR.2 hw)] + exact rightCoset_subset_of_point M hR (hP hw) + +/-- Every coset on a finite comparability path with types in `D` stays +inside the starting `D`-coset. This is the path confinement used at a +minimum of the relative height. -/ +theorem deligne_path_contained (D : Set S) (z : Artin M) {P R : Deligne M} + (hP : P.val.2 ⊆ rightCoset M D z) + (path : Relation.ReflTransGen + (fun A B : Deligne M => A.val.1 ⊆ D ∧ B.val.1 ⊆ D ∧ (A ≤ B ∨ B ≤ A)) P R) : + R.val.2 ⊆ rightCoset M D z := by + induction path with + | refl => exact hP + | @tail A B path edge ih => + rcases edge.2.2 with hAB | hBA + · exact deligne_upper_contained M hAB D z edge.2.1 ih + · exact hBA.2.trans ih + +/-- If a confined path reaches the translate of its starting coset by +`r`, then `r` belongs to the corresponding conjugate standard subgroup. -/ +theorem conjugate_membership_of_coset_path (D : Set S) (z r : Artin M) + {P R : Deligne M} (hP : z ∈ P.val.2) (hPT : P.val.1 ⊆ D) + (hR : z * r ∈ R.val.2) + (path : Relation.ReflTransGen + (fun A B : Deligne M => A.val.1 ⊆ D ∧ B.val.1 ⊆ D ∧ (A ≤ B ∨ B ≤ A)) P R) : + r ∈ conjugate z⁻¹ (artinParabolic M D) := by + have hstart : P.val.2 ⊆ rightCoset M D z := by + rw [deligne_coset_eq_at_point M P z hP] + exact rightCoset_subset_of_point M hPT (by + change z * z⁻¹ ∈ artinParabolic M D + simp) + have hend := deligne_path_contained M D z hstart path hR + change (z * r) * z⁻¹ ∈ artinParabolic M D at hend + simpa only [mem_conjugate, inv_inv] using hend + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterChainMinimum.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterChainMinimum.lean new file mode 100644 index 0000000000000000000000000000000000000000..1656aed2bf207268fa895e0af19afb9d229cadeb --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterChainMinimum.lean @@ -0,0 +1,85 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.CoxeterChainRoots +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicMinimumStep + +namespace OAI + +/-! A noncommutation path starting outside a parabolic gives a minimal +Coxeter coset representative. -/ +namespace HarmonicArtin.ParabolicIntersections +open Geometric CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) +local notation "cs" => M.toCoxeterSystem + +lemma conjugate_simple_not_parabolic (X : Set S) (w : M.Group) (s t : S) (ht : t∉X) + (hr : representation cs w (Pi.single s 1) t≠0) : + w*(cs).simple s*w⁻¹∉parabolic cs X := by + intro hm + let x := representation cs w (Pi.single s 1) + have hn : simpleReflection M s (Pi.single s 1)=-(Pi.single s 1) := by + simp only [simpleReflection_apply,Matrix.mulVec_single,Matrix.col,Matrix.transpose_apply, + MulOpposite.op_one,one_smul,cartan_diag] + module + have he : representation cs (w*(cs).simple s*w⁻¹) x=-x := by + calc + representation cs (w*(cs).simple s*w⁻¹) x = + representation cs ((w*(cs).simple s*w⁻¹)*w) (Pi.single s 1) := by + exact (DFunLike.congr_fun (map_mul (representation cs) + (w*(cs).simple s*w⁻¹) w) (Pi.single s 1)).symm + _ = representation cs (w*(cs).simple s) (Pi.single s 1) := by + congr 2 + group + _ = representation cs w (simpleReflection M s (Pi.single s 1)) := by + rw [map_mul,LinearEquiv.mul_apply,representation_simple] + _ = -x := by rw [hn,map_neg] + have hx := parabolic_exterior M X ⟨_,hm⟩ x t ht + change representation cs (w*(cs).simple s*w⁻¹) x t=x t at hx + rw [he] at hx + change -x t=x t at hx + exact hr (by change x t=0; linarith) + +lemma minimum_append_chain (X : Set S) (u : List S) (s t : S) + (hmin : IsParabolicMinimum cs X ((cs).wordProd u)) + (hN : (u++[s]).Nodup) + (hC : (u++[s]).IsChain (fun a b => a≠b ∧ M a b≠2)) + (ht : t∈u++[s]) (htX : t∉X) : + IsParabolicMinimum cs X ((cs).wordProd (u++[s])) := by + rw [(cs).wordProd_append,(cs).wordProd_singleton] + rcases parabolic_minimum_step cs X _ hmin s with h|⟨j,hj,he⟩ + · exact h + · have hr := (root_along_chain M u s hN hC).2.1 t ht + apply False.elim + apply conjugate_simple_not_parabolic M X ((cs).wordProd u) s t htX (ne_of_gt hr) + have hh : (cs).wordProd u*(cs).simple s*((cs).wordProd u)⁻¹=(cs).simple j := by + rw [he,mul_inv_cancel_right] + rw [hh] + exact simple_mem_parabolic cs X hj + +/-- Every prefix of a simple noncommutation path starting outside `X` is +minimal in its left `X`-coset. -/ +theorem chain_word_minimum (X : Set S) (a : S) (ha : a∉X) (u : List S) + (hN : (a::u).Nodup) (hC : (a::u).IsChain (fun a b => a≠b ∧ M a b≠2)) : + IsParabolicMinimum cs X ((cs).wordProd (a::u)) := by + induction u using List.reverseRecOn with + | nil => + apply minimum_append_chain M X [] a a + · intro g _ + simp only [(cs).wordProd_nil,(cs).length_one] + exact Nat.zero_le _ + · exact hN + · exact hC + · simp only [List.nil_append,List.mem_singleton] + · exact ha + | append_singleton u s ih => + have hn : ((a::u)++[s]).Nodup := hN + have hc : ((a::u)++[s]).IsChain (fun a b => a≠b ∧ M a b≠2) := hC + apply minimum_append_chain M X (a::u) s a + · exact ih (List.nodup_append.mp hn).1 hc.left_of_append + · exact hn + · exact hc + · exact List.mem_append_left _ List.mem_cons_self + · exact ha + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterChainRoots.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterChainRoots.lean new file mode 100644 index 0000000000000000000000000000000000000000..6155488498669066633dfd9842ee6918b0c81138 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterChainRoots.lean @@ -0,0 +1,104 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.NormalParabolic +import OAI.Topology.ArtinGroups.Geometry.CartanOffNonpos + +namespace OAI + +/-! Positive roots carried along a simple path in the noncommutation graph. -/ +namespace HarmonicArtin.ParabolicIntersections +open Geometric CoxeterExchange +open scoped _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) + +lemma reflection_nonneg_of_zero (a : S) (x : S → ℝ) (hx : ∀ i, 0≤x i) (ha : x a=0) : + ∀ i, 0 ≤ simpleReflection M a x i := by + have hr : (cartan M *ᵥ x) a≤0 := by + apply Finset.sum_nonpos + intro j _ + by_cases hj : a=j + · subst j + rw [ha,mul_zero] + · exact mul_nonpos_of_nonpos_of_nonneg (cartan_off_nonpos M a j hj) (hx j) + intro i + rw [simpleReflection_apply] + by_cases hi : i=a + · subst i + simpa only [Pi.sub_apply,Pi.smul_apply,smul_eq_mul,Pi.single_eq_same,mul_one,ha,zero_sub] + using neg_nonneg.mpr hr + · simpa only [Pi.sub_apply,Pi.smul_apply,smul_eq_mul,Pi.single_eq_of_ne hi,mul_zero,sub_zero] + using hx i + +lemma reflection_pos_of_neighbor (a b : S) (hab : a≠b) (hm : M a b≠2) + (x : S → ℝ) (hx : ∀ i, 0≤x i) (ha : x a=0) (hb : 0 cartan M a j*x j) (g := fun _ => (0 : ℝ)) + (by + intro j _ + by_cases hj : a=j + · subst j + rw [ha,mul_zero] + · exact mul_nonpos_of_nonpos_of_nonneg (cartan_off_nonpos M a j hj) (hx j)) + ⟨b,Finset.mem_univ _,mul_neg_of_neg_of_pos hc hb⟩ + simpa only [Finset.sum_const_zero] using hsum + rw [simpleReflection_apply] + simpa only [Pi.sub_apply,Pi.smul_apply,smul_eq_mul,Pi.single_eq_same,mul_one,ha,zero_sub] + using neg_pos.mpr hrow + +/-- A word of distinct vertices along a noncommutation path carries the +last simple root to a nonnegative root positive at every vertex of the path. -/ +theorem root_along_chain (u : List S) (s : S) (hN : (u++[s]).Nodup) + (hC : (u++[s]).IsChain (fun a b => a≠b ∧ M a b≠2)) : + let x := representation M.toCoxeterSystem (M.toCoxeterSystem.wordProd u) (Pi.single s 1) + (∀ i, 0 ≤ x i) ∧ (∀ i∈u++[s], 0 < x i) ∧ (∀ i, i∉u++[s] → x i=0) := by + induction u with + | nil => + simp only [List.nil_append,CoxeterSystem.wordProd_nil,map_one] + change (∀ i, 0 ≤ (Pi.single s (1 : ℝ) : S → ℝ) i) ∧ + (∀ i∈[s], 0 < (Pi.single s (1 : ℝ) : S → ℝ) i) ∧ + (∀ i, i∉[s] → (Pi.single s (1 : ℝ) : S → ℝ) i=0) + refine ⟨?_,?_,?_⟩ + · intro i + by_cases hi : i=s <;> simp [hi] + · intro i hi + have hi' : i=s := List.mem_singleton.mp hi + subst i + simpa only [Pi.single_eq_same] using (zero_lt_one : (0 : ℝ)<1) + · intro i hi + exact Pi.single_eq_of_ne (by simpa only [List.mem_singleton] using hi) 1 + | cons a u ih => + obtain ⟨hna,hn⟩ := List.nodup_cons.mp hN + have hc : (u++[s]).IsChain (fun a b => a≠b ∧ M a b≠2) := hC.tail + obtain ⟨hx,hpos,hzero⟩ := ih hn hc + let x := representation M.toCoxeterSystem (M.toCoxeterSystem.wordProd u) (Pi.single s 1) + have hxa : x a=0 := hzero a hna + obtain ⟨b,hb,hab,hm⟩ : ∃ b∈u++[s], a≠b ∧ M a b≠2 := by + cases u with + | nil => exact ⟨s,by simp,(List.isChain_cons_cons.mp hC).1⟩ + | cons b u => exact ⟨b,by simp,(List.isChain_cons_cons.mp hC).1⟩ + have hpa := reflection_pos_of_neighbor M a b hab hm x hx hxa (hpos b hb) + simp only [List.cons_append,CoxeterSystem.wordProd_cons,map_mul,LinearEquiv.mul_apply, + representation_simple] + change (∀ i,0 ≤ simpleReflection M a x i) ∧ + (∀ i∈a::(u++[s]),0 < simpleReflection M a x i) ∧ + (∀ i,i∉a::(u++[s]) → simpleReflection M a x i=0) + refine ⟨reflection_nonneg_of_zero M a x hx hxa,?_,?_⟩ + · intro i hi + rcases List.mem_cons.mp hi with rfl|hi + · exact hpa + · have hia : i≠a := fun he => hna (he ▸ hi) + simpa only [simpleReflection_apply,Pi.sub_apply,Pi.smul_apply,smul_eq_mul, + Pi.single_eq_of_ne hia,mul_zero,sub_zero] using hpos i hi + · intro i hi + have hia : i≠a := fun he => hi (List.mem_cons.mpr (Or.inl he)) + have hiu : i∉u++[s] := fun hm => hi (List.mem_cons_of_mem a hm) + simpa only [simpleReflection_apply,Pi.sub_apply,Pi.smul_apply,smul_eq_mul, + Pi.single_eq_of_ne hia,mul_zero,sub_zero] using hzero i hiu + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterProjectionSupport.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterProjectionSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..2a12a04954fac5864eb83b5f50f0fd317689a51d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/CoxeterProjectionSupport.lean @@ -0,0 +1,77 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicCosetProjection + +namespace OAI + +/-! Parabolic projection preserves any standard subgroup containing its input. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S W : Type} [Group W] {M : CoxeterMatrix S} (cs : CoxeterSystem M W) + +private lemma component_one (X : Set S) : parabolicComponent cs X 1=1 := by + have hr : parabolicRep cs X 1=1 := parabolicRep_of_minimum cs X 1 (by + intro a _ + rw [cs.length_one] + exact Nat.zero_le _) + simp only [parabolicComponent,hr,inv_one,mul_one] + +lemma rep_mem_of_component_mem (X C : Set S) (w : W) + (hw : w∈parabolic cs C) (hc : parabolicComponent cs X w∈parabolic cs C) : + parabolicRep cs X w∈parabolic cs C := by + have he : parabolicRep cs X w=(parabolicComponent cs X w)⁻¹*w := by + exact (eq_inv_mul_iff_mul_eq).mpr (parabolicComponent_mul_rep cs X w) + rw [he] + exact (parabolic cs C).mul_mem ((parabolic cs C).inv_mem hc) hw + +lemma component_step_mem (X C : Set S) (w : W) (s : S) + (hw : w∈parabolic cs C) (hc : parabolicComponent cs X w∈parabolic cs C) (hs : s∈C) : + parabolicComponent cs X (w*cs.simple s)∈parabolic cs C := by + have hr := rep_mem_of_component_mem cs X C w hw hc + have hh : parabolicStepRatio cs X w s∈parabolic cs C := by + by_cases he : parabolicStepRatio cs X w s=1 + · rw [he] + exact Subgroup.one_mem _ + · rw [parabolicStepRatio_reflection cs X w s he] + exact (parabolic cs C).mul_mem + ((parabolic cs C).mul_mem hr (simple_mem_parabolic cs C hs)) + ((parabolic cs C).inv_mem hr) + have he : parabolicComponent cs X (w*cs.simple s)= + parabolicComponent cs X w*parabolicStepRatio cs X w s := by + unfold parabolicStepRatio + rw [mul_inv_cancel_left] + rw [he] + exact (parabolic cs C).mul_mem hc hh + +/-- The parabolic component of an element of `W_C` is again in `W_C`. -/ +theorem component_mem_of_mem (X C : Set S) (w : W) (hw : w∈parabolic cs C) : + parabolicComponent cs X w∈parabolic cs C := by + obtain ⟨u,hu,rfl⟩ := (mem_parabolic_iff_word cs C w).mp hw + induction u using List.reverseRecOn with + | nil => + rw [cs.wordProd_nil,component_one] + exact Subgroup.one_mem _ + | append_singleton u s ih => + have hu' : ∀ i∈u, i∈C := fun i hi => hu i (List.mem_append_left _ hi) + have hs : s∈C := hu s (List.mem_append_right _ (by simp)) + rw [cs.wordProd_append,cs.wordProd_singleton] + exact component_step_mem cs X C _ s (wordProd_mem_parabolic cs C u hu') + (ih hu' (wordProd_mem_parabolic cs C u hu')) hs + +/-- The canonical minimal representative also stays in `W_C`. -/ +theorem rep_mem_of_mem (X C : Set S) (w : W) (hw : w∈parabolic cs C) : + parabolicRep cs X w∈parabolic cs C := + rep_mem_of_component_mem cs X C w hw (component_mem_of_mem cs X C w hw) + +/-- A minimal left representative outside `W_C` cannot lie in `W_X W_C`. -/ +theorem minimum_not_product (X C : Set S) (w : W) (hmin : IsParabolicMinimum cs X w) + (hw : w∉parabolic cs C) (a b : W) (ha : a∈parabolic cs X) (hb : b∈parabolic cs C) : + w≠a*b := by + intro he + apply hw + have hr := rep_mem_of_mem cs X C b hb + rw [←parabolicRep_left_mul cs X a b ha,←he,parabolicRep_of_minimum cs X w hmin] at hr + exact hr + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsDefinitions.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsDefinitions.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e7b8034785844859827ba0fbc6e296c7197cf16 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsDefinitions.lean @@ -0,0 +1,91 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.Basic +import Mathlib.Topology.MetricSpace.Isometry + +namespace OAI + +/-! +# Acylindrical actions and visual splittings + +The definitions below spell out the metric content of acylindrical +hyperbolicity. Non-elementarity means that an orbit has three distinct +Gromov-boundary limit points, represented by Gromov sequences whose +pairwise mixed products are bounded. No dynamical assertion is built +into a definition of an Artin group. +-/ +namespace HarmonicArtin.ParabolicIntersections + +noncomputable def gromovProduct {X : Type} [MetricSpace X] (o x y : X) : ℝ := + (dist o x + dist o y - dist x y)/2 + +def IsGromovHyperbolic (X : Type) [MetricSpace X] : Prop := + ∃ δ : ℝ, 0 ≤ δ ∧ ∀ o x y z : X, + min (gromovProduct o x y) (gromovProduct o y z) ≤ gromovProduct o x z + δ + +def IsGeodesicMetric (X : Type) [MetricSpace X] : Prop := + ∀ x y : X, ∃ γ : Set.Icc (0 : ℝ) (dist x y) → X, + Isometry γ ∧ γ ⟨0,le_rfl,dist_nonneg⟩=x ∧ γ ⟨dist x y,dist_nonneg,le_rfl⟩=y + +def IsGromovSequence {X : Type} [MetricSpace X] (o : X) (u : ℕ → X) : Prop := + ∀ R : ℝ, ∃ N : ℕ, ∀ m, N ≤ m → ∀ n, N ≤ n → R ≤ gromovProduct o (u m) (u n) + +def IsAcylindrical (G X : Type) [Group G] [MetricSpace X] [MulAction G X] : Prop := + ∀ ε : ℝ, 0 < ε → ∃ R : ℝ, ∃ N : ℕ, ∀ x y : X, R ≤ dist x y → + {g : G | dist x (g • x) ≤ ε ∧ dist y (g • y) ≤ ε}.Finite ∧ + {g : G | dist x (g • x) ≤ ε ∧ dist y (g • y) ≤ ε}.ncard ≤ N + +def HasThreeOrbitLimitPoints (G X : Type) [Group G] [MetricSpace X] [MulAction G X] : Prop := + ∃ o : X, ∃ u : Fin 3 → ℕ → G, + (∀ i, IsGromovSequence o (fun n => u i n • o)) ∧ + ∀ i j, i ≠ j → ∃ B : ℝ, ∀ m n, gromovProduct o (u i m • o) (u j n • o) ≤ B + +/-- An isometric non-elementary acylindrical action on a geodesic +Gromov-hyperbolic metric space. -/ +def AcylindricallyHyperbolic (G : Type) [Group G] : Prop := + ∃ (X : Type) (metric : MetricSpace X) (action : MulAction G X), + @IsGeodesicMetric X metric ∧ @IsGromovHyperbolic X metric ∧ + (∀ g : G, @Isometry X X metric.toPseudoMetricSpace.toPseudoEMetricSpace metric.toPseudoMetricSpace.toPseudoEMetricSpace + (fun x => @SMul.smul G X action.toSMul g x)) ∧ + @IsAcylindrical G X _ metric action ∧ @HasThreeOrbitLimitPoints G X _ metric action + +def WeaklyMalnormal {G : Type} [Group G] (P : Subgroup G) : Prop := + ∃ g : G, (↑(P ⊓ conjugate g P) : Set G).Finite + +variable {S : Type} (M : CoxeterMatrix S) + +/-- No nontrivial partition has every cross label equal to two. -/ +def IsIrreducible : Prop := + ∀ Y : Set S, Y.Nonempty → Yᶜ.Nonempty → ∃ s ∈ Y, ∃ t ∉ Y, M s t ≠ 2 + +/-- The presentation-graph condition in CMMW Definition 2.4. The vertex +subgraphs are proper, cover every vertex, and omit no finite-label edge. -/ +def IsVisualSplit (Y Z : Set S) : Prop := + Y ∪ Z = Set.univ ∧ Y ⊂ Set.univ ∧ Z ⊂ Set.univ ∧ + ∀ s ∈ Y \ Z, ∀ t ∈ Z \ Y, M s t = 0 + +lemma infinite_pair_visual_split (s t : S) (hst : s ≠ t) (hlabel : M s t=0) : + IsVisualSplit M {s}ᶜ {t}ᶜ := by + refine ⟨?_,?_,?_,?_⟩ + · ext a + simp only [Set.mem_union,Set.mem_compl_iff,Set.mem_singleton_iff,Set.mem_univ,iff_true] + by_cases ha : a=s + · exact Or.inr (by simpa [ha] using hst) + · exact Or.inl ha + · apply Set.ssubset_univ_iff.mpr + intro h + have hs : s ∈ ({s}ᶜ : Set S) := h.symm ▸ Set.mem_univ s + simp at hs + · apply Set.ssubset_univ_iff.mpr + intro h + have ht : t ∈ ({t}ᶜ : Set S) := h.symm ▸ Set.mem_univ t + simp at ht + · intro a ha b hb + have hat : a=t := by simpa using ha.2 + have hbs : b=s := by simpa using hb.2 + subst a + subst b + rw [M.symmetric] + exact hlabel + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsEquivalence.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsEquivalence.lean new file mode 100644 index 0000000000000000000000000000000000000000..5e44c2b8c18dedb34e238d704d34b63edd54e1d4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsEquivalence.lean @@ -0,0 +1,43 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsDefinitions + +namespace OAI + +/-! Transport of the metric definition of acylindrical hyperbolicity. -/ +namespace HarmonicArtin.ParabolicIntersections +variable {G H : Type} [Group G] [Group H] + +/-- A group isomorphism transports the action, its uniform acylindricity +bounds, and all three distinct orbit limit points. -/ +theorem AcylindricallyHyperbolic.of_equiv (e : G ≃* H) (h : AcylindricallyHyperbolic H) : + AcylindricallyHyperbolic G := by + obtain ⟨X,d,a,hgeo,hhyp,hiso,hacyl,hlim⟩ := h + let : MetricSpace X := d + let : MulAction H X := a + let : MulAction G X := MulAction.compHom X e.toMonoidHom + refine ⟨X,d,inferInstance,hgeo,hhyp,fun g => hiso (e g),?_,?_⟩ + · intro ε hε + obtain ⟨R,N,hRN⟩ := hacyl ε hε + refine ⟨R,N,?_⟩ + intro x y hxy + obtain ⟨hfin,hcard⟩ := hRN x y hxy + let Q : Set H := {h | dist x (h • x)≤ε ∧ dist y (h • y)≤ε} + change (e ⁻¹' Q).Finite ∧ (e ⁻¹' Q).ncard≤N + refine ⟨hfin.preimage e.injective.injOn,?_⟩ + rw [Set.ncard_preimage_of_injective_subset_range e.injective + (by rw [e.surjective.range_eq]; exact Set.subset_univ _)] + exact hcard + · obtain ⟨o,u,hu,hB⟩ := hlim + refine ⟨o,fun i n => e.symm (u i n),?_,?_⟩ + · intro i + change IsGromovSequence o (fun n => e (e.symm (u i n)) • o) + simpa only [MulEquiv.apply_symm_apply] using hu i + · intro i j hij + obtain ⟨B,hB⟩ := hB i j hij + refine ⟨B,?_⟩ + intro m n + change gromovProduct o (e (e.symm (u i m)) • o) (e (e.symm (u j n)) • o)≤B + simpa only [MulEquiv.apply_symm_apply] using hB m n + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsMain.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsMain.lean new file mode 100644 index 0000000000000000000000000000000000000000..de70a0c65e681f93c1fd660bc414a468fc50aeeb --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsMain.lean @@ -0,0 +1,44 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ReducedDynamicsMain +import OAI.Topology.ArtinGroups.ParabolicIntersections.ProperParabolicMalnormal + +namespace OAI + +/-! +# Corollary 1.3 with only the general amalgam criterion remaining + +The Artin-specific statements of Charney--Martin--Morris-Wright, +Theorem 3.2 and Proposition 4.2, are proved in this development. +The only remaining published input is Minasyan--Osin (2015), Corollary 2.2, +for arbitrary amalgamated products. In particular the weak-malnormality +half of the corollary has no published hypotheses. +-/ +namespace HarmonicArtin.ParabolicIntersections +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- The sufficient case of CMMW Proposition 4.2, now proved locally. -/ +theorem proper_parabolic_criterion : PublishedProperParabolicCriterion M where + criterion hIrred Y Z hsplit _ P hP hne := by + let : Fact (IsVisualSplit M Y Z) := ⟨hsplit⟩ + exact proper_parabolic_weaklyMalnormal M Y Z hIrred P hP hne + +/-- The weak-malnormality assertion of paper 082-03, Corollary 1.3, +without any published input. -/ +theorem unconditional_nonclique_weaklyMalnormal + (hIrred : IsIrreducible M) (hInf : ∃ s t : S,s≠t ∧ M s t=0) + (P : Subgroup (Artin M)) (hP : IsParabolic M P) (hne : P≠⊤) : WeaklyMalnormal P := by + obtain ⟨s,t,hst,hm⟩ := hInf + let : Fact (IsVisualSplit M {s}ᶜ {t}ᶜ) := ⟨infinite_pair_visual_split M s t hst hm⟩ + exact proper_parabolic_weaklyMalnormal M {s}ᶜ {t}ᶜ hIrred P hP hne + +/-- Paper 082-03, Corollary 1.3, conditional only on the general published +amalgam theorem of Minasyan--Osin, with every Artin-specific input discharged. -/ +theorem nonclique_dynamics_of_amalgam + (hMO : PublishedAmalgamCriterion) + (hIrred : IsIrreducible M) (hInf : ∃ s t : S,s≠t ∧ M s t=0) : + AcylindricallyHyperbolic (Artin M) ∧ + ∀ P : Subgroup (Artin M),IsParabolic M P → P≠⊤ → WeaklyMalnormal P := + nonclique_dynamics_of_amalgam_and_proper M hMO (proper_parabolic_criterion M) hIrred hInf + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsUnconditional.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsUnconditional.lean new file mode 100644 index 0000000000000000000000000000000000000000..bed90374c83db19756d02d3e5fabfeb26d32088e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/DynamicsUnconditional.lean @@ -0,0 +1,32 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualAcylindrical +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsMain + +namespace OAI + +/-! +# Paper 082-03, Corollary 1.3, without published hypotheses + +For a finite-rank irreducible Artin group whose defining graph is not a +clique, the group is acylindrically hyperbolic and every proper parabolic +subgroup is weakly malnormal. The acylindrical action is constructed from +the genuine visual tree; the algebraic intersection theorem supplies a +segment with trivial stabilizer. All metric, boundary, and malnormality +arguments are proved in the imported development. +-/ +namespace HarmonicArtin.ParabolicIntersections +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- The full third main result of *Parabolic intersections in Artin groups*. -/ +theorem unconditional_nonclique_dynamics + (hIrred : IsIrreducible M) (hInf : ∃ s t : S,s≠t ∧ M s t=0) : + AcylindricallyHyperbolic (Artin M) ∧ + ∀ P : Subgroup (Artin M),IsParabolic M P → P≠⊤ → WeaklyMalnormal P := by + constructor + · obtain ⟨s,t,hst,hm⟩ := hInf + let : Fact (IsVisualSplit M {s}ᶜ {t}ᶜ) := ⟨infinite_pair_visual_split M s t hst hm⟩ + exact visual_acylindricallyHyperbolic M {s}ᶜ {t}ᶜ hIrred + · exact unconditional_nonclique_weaklyMalnormal M hIrred hInf + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/EmptyPlacement.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/EmptyPlacement.lean new file mode 100644 index 0000000000000000000000000000000000000000..b43a5905908d36540316bb37cfba2eca64fb2ddb --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/EmptyPlacement.lean @@ -0,0 +1,65 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.LayerErasure + +namespace OAI + +/-! The empty-placement lemma (Lemma 7.3 of paper 082-03). -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) [Fintype V] [Fintype A] + +/-- Exact vertex tests on a spherical interval force a gap after at most +`N` placements per occupied layer. Only the abstract published path +identity is assumed; the layer-removal argument is proved here. -/ +theorem empty_placement_of_mesh (U : Set V) (hmesh : MeshNilpotent Q U) : + ∃ N : ℕ, 0 < N ∧ ∀ (I : Type) [Fintype I] (E : BasedComplex Q (K := ℂ) I), + E.IsMinimal Q → ∀ l r d₁ d₂ : ℤ, d₁ ≤ d₂ → + (∀ i, d₁ ≤ (E.placement i).level ∧ (E.placement i).level ≤ d₂) → + (∀ i, l ≤ (E.placement i).cochain → (E.placement i).cochain ≤ r → + (E.placement i).color ∈ U) → + (∀ α ∈ U, ∀ c, l ≤ c → c ≤ r → ∀ d, + ScalarExactAt Q (E.testComplex Q α) α d c) → + ∀ i, l+N*(d₂-d₁+1) ≤ (E.placement i).cochain → + (E.placement i).cochain ≤ r → False := by + obtain ⟨N, hN, hwords⟩ := hmesh + refine ⟨N, hN, ?_⟩ + intro I _ E hE l r d₁ d₂ hdd hlevels hcolors hex + have herase : ∀ n : ℕ, ∀ i, l+(n:ℤ)*N ≤ (E.placement i).cochain → + (E.placement i).cochain ≤ r → d₂-(n:ℤ) < (E.placement i).level → False := by + intro n + induction n with + | zero => + intro i _ _ hi + have := (hlevels i).2 + simp only [Int.natCast_zero, sub_zero] at hi + omega + | succ n ih => + intro i hi hir hlev + by_cases htop : d₂-(n:ℤ) < (E.placement i).level + · apply ih i _ hir htop + have : (0 : ℤ) ≤ N := Int.natCast_nonneg N + push_cast at hi + nlinarith + · have heq : (E.placement i).level = d₂-(n:ℤ) := by + push_cast at hlev + omega + apply one_layer_erasure Q U N hwords E hE (l+(n:ℤ)*N) r (d₂-(n:ℤ)) + (fun j hj hjr => hcolors j (by have := Int.natCast_nonneg n; have := Int.natCast_nonneg N; nlinarith) hjr) + (fun α hα c hc hcr d => hex α hα c + (by have := Int.natCast_nonneg n; have := Int.natCast_nonneg N; nlinarith) hcr d) + (fun j hj hjr hhigh => ih j hj hjr hhigh) i heq _ hir + push_cast at hi + nlinarith + let n := (d₂-d₁+1).toNat + have hn : (n : ℤ) = d₂-d₁+1 := Int.toNat_of_nonneg (by omega) + intro i hi hir + apply herase n i _ hir _ + · rw [hn] + nlinarith + · rw [hn] + have := (hlevels i).1 + omega + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FixedFactor.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FixedFactor.lean new file mode 100644 index 0000000000000000000000000000000000000000..fe60728505292ffc8dc0d085ce458f276474a7d8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FixedFactor.lean @@ -0,0 +1,84 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.StabilizerDescent +import OAI.Topology.ArtinGroups.Coxeter.ParabolicProductMap + +namespace OAI + +/-! +# Removing an invisible factor + +The nonspherical branch of §8 of paper 082-03 splits off a standard +factor fixing the entire family. This module proves that step for the +actual subgroup lattice and group action. Pairwise label 2 is the precise +commutation hypothesis; no product decomposition is assumed. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +variable {G V : Type*} [Group G] [MulAction G V] + +/-- A subgroup centralized pointwise by an element is invariant under its +conjugation. -/ +theorem conjugate_eq_of_commute (P : Subgroup G) (g : G) + (hc : ∀ a ∈ P, Commute a g) : conjugate g P = P := by + apply le_antisymm + · intro a ha + rw [mem_conjugate] at ha + have hh := (hc (g⁻¹ * a * g) ha).eq + have he : g⁻¹ * a * g = a := by + calc + g⁻¹ * a * g = (g⁻¹ * a * g) * g * g⁻¹ := by group + _ = g * (g⁻¹ * a * g) * g⁻¹ := by rw [hh] + _ = a := by group + rwa [he] at ha + · intro a ha + rw [mem_conjugate] + have he : g⁻¹ * a * g = a := by + calc + g⁻¹ * a * g = g⁻¹ * (a * g) := by group + _ = g⁻¹ * (g * a) := by rw [(hc a ha).eq] + _ = a := by group + rwa [he] + +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + {W : Type*} [MulAction (Artin M) W] (v : W) + +omit [Fintype S] [LinearOrder S] in +/-- A fixed commuting standard factor splits off from the simultaneous +stabilizer. Surjectivity of the multiplication map suffices. -/ +theorem relativeStabilizer_fixed_factor (K T : Set S) (x : Artin M) + (hc : ∀ k ∈ K, ∀ t ∈ T, M k t = 2) + (hfix : ∀ k ∈ artinParabolic M K, k • (x • v) = x • v) : + relativeStabilizer M v (K ∪ T) x = + artinParabolic M K ⊔ relativeStabilizer M v T x := by + apply le_antisymm + · intro a ha + have hr : a ∈ (sourceParabolicProductMap M K T hc).range := by + rw [sourceParabolicProductMap_range] + exact ha.1 + obtain ⟨⟨k, t⟩, he⟩ := hr + change (k : Artin M) * t = a at he + have ht : (t : Artin M) • (x • v) = x • v := by + apply (smul_left_cancel_iff (k : Artin M)).mp + rw [hfix k k.property, ← mul_smul, he] + exact ha.2 + rw [← he] + exact Subgroup.mul_mem _ + ((show artinParabolic M K ≤ _ from le_sup_left) k.property) + ((show relativeStabilizer M v T x ≤ _ from le_sup_right) ⟨t.property, ht⟩) + · apply sup_le + · intro k hk + exact ⟨standard_mono M Set.subset_union_left hk, hfix k hk⟩ + · exact inf_le_inf (standard_mono M Set.subset_union_right) le_rfl + +omit [Fintype S] [LinearOrder S] in +/-- The fixed factor is normalized by the complementary standard factor, +as required by the rank induction. -/ +theorem standard_factor_normalized (K T : Set S) + (hc : ∀ k ∈ K, ∀ t ∈ T, M k t = 2) + (t : Artin M) (ht : t ∈ artinParabolic M T) : + conjugate t (artinParabolic M K) = artinParabolic M K := + conjugate_eq_of_commute _ t (fun k hk => sourceParabolics_commute M K T hc k t hk ht) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingGcd.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingGcd.lean new file mode 100644 index 0000000000000000000000000000000000000000..6df2b3ddb44dceb13cf93a2b253e11343709db0b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingGcd.lean @@ -0,0 +1,58 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.FoldingHead +import OAI.Topology.ArtinGroups.ParabolicIntersections.BraidRestriction + +namespace OAI + +/-! Discharge of the published common-left-atom folding input. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + (Y : Set S) (hY : IsSpherical M Y) +local notation "R" => restrictedMatrix M Y +local notation "N" => unfoldedMatrix M Y +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "f" => unfoldedInclusion M Y + +private lemma expanded_braid_prefix (u : List Y) (a : Y × FusionLabel m) + (r : List (FusionVertex (V:=S⊕Unit) m)) + (hu : PositiveBraidRel Q + (fusionExpandedWord m (u.map fun j : Y => (Sum.inl (j:S) : S⊕Unit))) (f a::r)) : + PositivePrefix N (positiveGenerator N a) (foldedPositiveHom M Y hY (wordPositive R u)) := by + let : Nonempty (Y × FusionLabel m) := ⟨a⟩ + rw [fusionExpandedWord_map] at hu + have hs : ∀ x ∈ (fusionExpandedWord m u).map f, x ∈ Set.range f := by + intro x hx + obtain ⟨b,_,rfl⟩ := List.mem_map.mp hx + exact ⟨b,rfl⟩ + have he := positiveBraidRel_restrict Q N f (unfoldedInclusion_injective M Y) + (unfolded_ordinaryMatrix M Y hY) hu hs + have hinv : ∀ x, Function.invFun f (f x)=x := + Function.leftInverse_invFun (unfoldedInclusion_injective M Y) + have hw : ((fusionExpandedWord m u).map f).map (Function.invFun f)=fusionExpandedWord m u := by + rw [List.map_map] + have hi : (Function.invFun f ∘ f)=id := funext hinv + rw [hi,List.map_id] + rw [hw,List.map_cons,hinv] at he + rw [foldedPositiveHom_word] + exact ⟨wordPositive N (r.map (Function.invFun f)),he⟩ + +/-- Castella's common-atom consequence, now proved for the particular +color folding rather than supplied as a hypothesis. -/ +theorem folding_gcd_input : PublishedFoldingGcd M Y hY where + common_atom := by + intro u v α r s hu hv + have hmem := (hu.mem_iff Q α).mpr (by simp) + rw [fusionExpandedWord_map] at hmem + obtain ⟨a,_,ha⟩ := List.mem_map.mp hmem + change f a=α at ha + subst α + exact ⟨a.1, + folded_atom_reflect M Y hY _ a (expanded_braid_prefix M Y hY u a r hu), + folded_atom_reflect M Y hY _ a (expanded_braid_prefix M Y hY v a s hv)⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingGcdInput.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingGcdInput.lean new file mode 100644 index 0000000000000000000000000000000000000000..245569eb0de229dbce302fe1198658f00c961ed5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingGcdInput.lean @@ -0,0 +1,57 @@ +import OAI.Topology.ArtinGroups.Harmonic.UnfoldedHom +import OAI.Topology.ArtinGroups.Harmonic.UnfoldedInclusion +import OAI.Topology.ArtinGroups.Harmonic.PositivePrefix +import OAI.Topology.ArtinGroups.Complexes.PositiveTopDivisor + +namespace OAI + +/-! +# Published gcd input for an admissible folding + +Castella, *Admissible submonoids of Artin--Tits monoids* (2008), +Proposition 41(2), states that an admissible folding preserves left and +right gcds. Source: https://arxiv.org/pdf/0804.0704, p. 15. +The field below is exactly its common-left-atom consequence: if two +expanded positive words have a common left atom, their original words +have a common left atom. The folding here is the color partition. +Its required Coxeter admissibility is already established by +`unfoldedHom_right_ascent` (constant ascent sign on every color). + +The field involves positive words and braid relations only. It contains +no tests, family action, height, stabilizer, or intersection assertion. +-/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +/-- The precise part of published gcd preservation needed below. The +sphericity proof is retained in the type to identify the admissible +finite-type folding to which the source theorem is applied. -/ +structure PublishedFoldingGcd (Y : Set S) (_hY : IsSpherical M Y) : Prop where + common_atom : ∀ (u v : List Y) (α : FusionVertex (V := S⊕Unit) m) + (r s : List (FusionVertex (V := S⊕Unit) m)), + PositiveBraidRel Q (fusionExpandedWord m (u.map fun j : Y => (Sum.inl (j:S) : S⊕Unit))) (α::r) → + PositiveBraidRel Q (fusionExpandedWord m (v.map fun j : Y => (Sum.inl (j:S) : S⊕Unit))) (α::s) → + ∃ i : Y, PositivePrefix (restrictedMatrix M Y) (positiveGenerator _ i) (wordPositive _ u) ∧ + PositivePrefix (restrictedMatrix M Y) (positiveGenerator _ i) (wordPositive _ v) + +/-- The Coxeter admissibility condition is proved, rather than included +as a categorical assumption: all vertices of a color have the same +right-ascent behavior on every element of the folded Coxeter group. -/ +theorem unfolded_color_admissible (Y : Set S) (hY : IsSpherical M Y) + (w : (restrictedMatrix M Y).Group) (i : Y) (L H : FusionLabel m) : + let N := (unfoldedMatrix M Y).toCoxeterSystem + N.length (unfoldedHom M Y hY w * N.simple (i,L)) = + N.length (unfoldedHom M Y hY w)+1 ↔ + N.length (unfoldedHom M Y hY w * N.simple (i,H)) = + N.length (unfoldedHom M Y hY w)+1 := by + exact (unfoldedHom_right_ascent M Y hY w (i,L)).trans + (unfoldedHom_right_ascent M Y hY w (i,H)).symm + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingHead.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingHead.lean new file mode 100644 index 0000000000000000000000000000000000000000..28e7e0c69916c5002e38bbb892dda62a7b33b021 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingHead.lean @@ -0,0 +1,103 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.FoldingSimpleGcd +import OAI.Topology.ArtinGroups.ParabolicIntersections.PositiveHeadProduct + +namespace OAI + +/-! Greedy heads, and hence left atoms, are preserved by folding. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + (Y : Set S) (hY : IsSpherical M Y) +local notation "R" => restrictedMatrix M Y +local notation "N" => unfoldedMatrix M Y +local notation "Φ" => foldedPositiveHom M Y hY +local notation "P" => positiveSimpleLift R + +omit [Fintype S] [LinearOrder S] in +private lemma positive_nil : wordPositive R [] = 1 := rfl + +omit [Fintype S] [LinearOrder S] in +private lemma positive_cons (i : Y) (w : List Y) : + wordPositive R (i::w)=positiveGenerator R i*wordPositive R w := rfl + +/-- The original and folded positive elements have corresponding greedy heads. -/ +theorem folded_positive_head (b : PositiveArtin R) : + ∃ h : (R).Group, + PositivePrefix R (P h) b ∧ + (∀ w, PositivePrefix R (P w) b → PositivePrefix R (P w) (P h)) ∧ + PositivePrefix N (Φ (P h)) (Φ b) ∧ + (∀ w, PositivePrefix N (positiveSimpleLift N w) (Φ b) → + PositivePrefix N (positiveSimpleLift N w) (Φ (P h))) := by + let : Finite (R).Group := restricted_finite M Y hY + let : Finite (N).Group := unfolded_finite M Y hY + let : LinearOrder (Y × FusionLabel (fusionLabelSize M)) := + LinearOrder.lift' (Fintype.equivFin _) (Fintype.equivFin _).injective + obtain ⟨z,hz⟩ := exists_longest (R).toCoxeterSystem + have hzN := unfolded_longest M Y hY z hz + have cancelR := spherical_positive_cancel_left M Y hY + have cancelN := finite_positive_cancel_left N + obtain ⟨word,rfl⟩ := positive_word_surjective R b + induction word with + | nil => + refine ⟨1,?_,?_,?_,?_⟩ + · simpa only [positiveSimpleLift_one,positive_nil] using positivePrefix_refl R 1 + · intro w hw + simpa only [positiveSimpleLift_one,positive_nil] using hw + · simp only [positiveSimpleLift_one,positive_nil,map_one] + exact positivePrefix_refl N 1 + · intro w hw + simpa only [positiveSimpleLift_one,positive_nil,map_one] using hw + | cons i word ih => + obtain ⟨h,hh,hhead,hhN,hheadN⟩ := ih + obtain ⟨g,hgc,hgh,hgreat⟩ := exists_greatest_common_simplePrefix R + (((R).toCoxeterSystem.simple i)⁻¹*z) h + obtain ⟨k,hk,hkb,hkhead⟩ := positive_head_product R cancelR z hz + ((R).toCoxeterSystem.simple i) h g (wordPositive R word) hh hhead hgc hgh hgreat + have hcN : PositivePrefix N + (positiveSimpleLift N (unfoldedHom M Y hY g)) + (positiveSimpleLift N ((unfoldedHom M Y hY ((R).toCoxeterSystem.simple i))⁻¹* + unfoldedHom M Y hY z)) := by + rw [←map_inv,←map_mul,←foldedPositiveHom_simpleLift,←foldedPositiveHom_simpleLift] + obtain ⟨r,hr⟩ := hgc + exact ⟨Φ r,by rw [hr,map_mul]⟩ + have hgN : PositivePrefix N (positiveSimpleLift N (unfoldedHom M Y hY g)) + (positiveSimpleLift N (unfoldedHom M Y hY h)) := by + rw [←foldedPositiveHom_simpleLift,←foldedPositiveHom_simpleLift] + obtain ⟨r,hr⟩ := hgh + exact ⟨Φ r,by rw [hr,map_mul]⟩ + have hgreatN := folded_simple_gcd M Y hY _ _ _ hgc hgh hgreat + simp only [foldedPositiveHom_simpleLift,map_mul,map_inv] at hgreatN + obtain ⟨kN,hkN,hkbN,hkheadN⟩ := positive_head_product N cancelN + (unfoldedHom M Y hY z) hzN + (unfoldedHom M Y hY ((R).toCoxeterSystem.simple i)) + (unfoldedHom M Y hY h) (unfoldedHom M Y hY g) (Φ (wordPositive R word)) + (by simpa only [foldedPositiveHom_simpleLift] using hhN) + (by simpa only [foldedPositiveHom_simpleLift] using hheadN) hcN hgN hgreatN + have heN : positiveSimpleLift N kN=Φ (P k) := by + rw [hkN,←foldedPositiveHom_simpleLift,←foldedPositiveHom_simpleLift,←map_mul,←hk] + refine ⟨k,?_,?_,?_,?_⟩ + · simpa only [positiveSimpleLift_simple,positive_cons] using hkb + · simpa only [positiveSimpleLift_simple,positive_cons] using hkhead + · rw [←heN] + simpa only [←foldedPositiveHom_simpleLift,positiveSimpleLift_simple,positive_cons,←map_mul] using hkbN + · intro w hw + rw [←heN] + apply hkheadN + simpa only [←foldedPositiveHom_simpleLift,positiveSimpleLift_simple,positive_cons,←map_mul] using hw + +/-- Every atom dividing an expanded positive word has its entire color as +a left divisor. This is the exact divisibility consequence needed downstream. -/ +theorem folded_atom_reflect (b : PositiveArtin R) + (α : Y × FusionLabel (fusionLabelSize M)) + (hα : PositivePrefix N (positiveGenerator N α) (Φ b)) : + PositivePrefix R (positiveGenerator R α.1) b := by + obtain ⟨h,hh,_,_,hhead⟩ := folded_positive_head M Y hY b + have hp : PositivePrefix N (positiveGenerator N α) (Φ (P h)) := by + simpa only [positiveSimpleLift_simple,positive_cons] using + hhead ((N).toCoxeterSystem.simple α) (by simpa only [positiveSimpleLift_simple,positive_cons] using hα) + exact positivePrefix_trans R ((folded_simple_atom_iff M Y hY h α).mp hp) hh + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingPositive.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingPositive.lean new file mode 100644 index 0000000000000000000000000000000000000000..2a63177bb28b6f1d4bab20671e2953ae729a95ee --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingPositive.lean @@ -0,0 +1,88 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.FoldingGcdInput +import OAI.Topology.ArtinGroups.Harmonic.UnfoldedColorOrthogonal +import OAI.Topology.ArtinGroups.Cancellation.SphericalPositiveCancelLeft + +namespace OAI + +/-! Positive-monoid folding and its action on simple elements. These are +proved from the Coxeter word theorem and the established folding geometry. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + (Y : Set S) (hY : IsSpherical M Y) +local notation "R" => restrictedMatrix M Y +local notation "N" => unfoldedMatrix M Y +local notation "m" => fusionLabelSize M + +private lemma folded_word_product (w : List Y) : + (w.map (fun i => wordPositive N (fusionExpandedWord m [i]))).prod = + wordPositive N (fusionExpandedWord m w) := by + induction w with + | nil => rfl + | cons i w ih => + rw [List.map_cons,List.prod_cons,ih] + simpa only [fusionExpandedWord, List.flatMap_cons, List.flatMap_nil, List.append_nil] using + (wordPositive_append N (fusionExpandedWord m [i]) (fusionExpandedWord m w)).symm + +include hY in +private lemma folded_positive_relations : + ∀ a b : FreeMonoid Y, positiveBraidRelations R a b → + FreeMonoid.lift (fun i => wordPositive N (fusionExpandedWord m [i])) a = + FreeMonoid.lift (fun i => wordPositive N (fusionExpandedWord m [i])) b := by + rintro a b ⟨i,j,rfl,rfl⟩ + simp only [FreeMonoid.lift_ofList,folded_word_product] + let : Finite (R).Group := restricted_finite M Y hY + obtain ⟨z,hz⟩ := exists_longest (R).toCoxeterSystem + apply wordPositive_eq_of_reduced N + · exact unfolded_reducedWord M Y hY _ (alternating_isReduced_of_longest R z hz i j) + · rw [(R).symmetric i j] + exact unfolded_reducedWord M Y hY _ (alternating_isReduced_of_longest R z hz j i) + · exact unfolded_word_eq M Y hY _ _ (altList_braid (R).toCoxeterSystem i j) + +noncomputable def foldedPositiveHom : PositiveArtin R →* PositiveArtin N := + PresentedMonoid.lift (fun i => wordPositive N (fusionExpandedWord m [i])) + (folded_positive_relations M Y hY) + +@[simp] lemma foldedPositiveHom_generator (i : Y) : + foldedPositiveHom M Y hY (positiveGenerator R i)= + wordPositive N (fusionExpandedWord m [i]) := rfl + +lemma foldedPositiveHom_word (w : List Y) : + foldedPositiveHom M Y hY (wordPositive R w)=wordPositive N (fusionExpandedWord m w) := by + unfold wordPositive + rw [map_list_prod] + simp only [List.map_map,Function.comp_def,foldedPositiveHom_generator] + exact folded_word_product M Y w + +lemma foldedPositiveHom_simpleLift (w : (R).Group) : + foldedPositiveHom M Y hY (positiveSimpleLift R w)= + positiveSimpleLift N (unfoldedHom M Y hY w) := by + change foldedPositiveHom M Y hY (wordPositive R (reducedExpression R w))=_ + rw [foldedPositiveHom_word] + have hu := unfolded_reducedWord M Y hY _ (reducedExpression_reduced R w) + have hw : (N).toCoxeterSystem.wordProd (fusionExpandedWord m (reducedExpression R w)) = + unfoldedHom M Y hY w := by + rw [← unfoldedHom_wordProd] + exact congrArg (unfoldedHom M Y hY) (wordCoxeter_reducedExpression R w) + rw [←hw] + exact (positiveSimpleLift_word N _ hu).symm + +/-- A left atom divides the folded simple element precisely when its +original color divides the original simple element. -/ +theorem folded_simple_atom_iff (w : (R).Group) (α : Y × FusionLabel m) : + PositivePrefix N (positiveGenerator N α) + (foldedPositiveHom M Y hY (positiveSimpleLift R w)) ↔ + PositivePrefix R (positiveGenerator R α.1) (positiveSimpleLift R w) := by + rw [foldedPositiveHom_simpleLift,←positiveSimpleLift_simple N α, + ←positiveSimpleLift_simple R α.1,positivePrefix_simple_iff,positivePrefix_simple_iff, + weakPrefix_simple_iff,weakPrefix_simple_iff] + have h := unfoldedHom_left_ascent M Y hY w α + have hn := (N).toCoxeterSystem.length_simple_mul (unfoldedHom M Y hY w) α + have hr := (R).toCoxeterSystem.length_simple_mul w α.1 + dsimp only at h + omega + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingSimpleGcd.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingSimpleGcd.lean new file mode 100644 index 0000000000000000000000000000000000000000..fbcf0abc8578adcefb4be614947515f5dcf0ff09 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/FoldingSimpleGcd.lean @@ -0,0 +1,93 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.FoldingPositive +import OAI.Topology.ArtinGroups.ParabolicIntersections.PositiveTransport + +namespace OAI + +/-! Folding preserves greatest common prefixes of simple elements. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + (Y : Set S) (hY : IsSpherical M Y) +local notation "R" => restrictedMatrix M Y +local notation "N" => unfoldedMatrix M Y +local notation "Φ" => foldedPositiveHom M Y hY +local notation "P" => positiveSimpleLift R + +private lemma folded_prefix {a b : PositiveArtin R} (h : PositivePrefix R a b) : + PositivePrefix N (Φ a) (Φ b) := by + obtain ⟨c,rfl⟩ := h + exact ⟨_,map_mul _ _ _⟩ + +/-- Greatest common prefixes of simples are preserved by the color folding. +The induction removes one complete color at a time. -/ +theorem folded_simple_gcd (u v g : (R).Group) + (hgu : PositivePrefix R (P g) (P u)) (hgv : PositivePrefix R (P g) (P v)) + (hg : ∀ e, PositivePrefix R e (P u) → PositivePrefix R e (P v) → PositivePrefix R e (P g)) : + ∀ e, PositivePrefix N e (Φ (P u)) → PositivePrefix N e (Φ (P v)) → + PositivePrefix N e (Φ (P g)) := by + let : Finite (N).Group := unfolded_finite M Y hY + let : LinearOrder (Y × FusionLabel (fusionLabelSize M)) := + LinearOrder.lift' (Fintype.equivFin _) (Fintype.equivFin _).injective + have cancelR := spherical_positive_cancel_left M Y hY + have cancelN := finite_positive_cancel_left N + induction u using (measure (fun u => (R).toCoxeterSystem.length u)).wf.induction + generalizing v g with + | h u ih => + intro e heu hev + obtain ⟨d,hdu,hdv,hd⟩ := exists_greatest_common_simplePrefix N + (unfoldedHom M Y hY u) (unfoldedHom M Y hY v) + simp only [←foldedPositiveHom_simpleLift] at hdu hdv hd + apply positivePrefix_trans N (hd e heu hev) + by_cases hd1 : positiveSimpleLift N d=1 + · rw [hd1] + exact positivePrefix_one N _ + obtain ⟨α,hα⟩ := exists_positive_first N hd1 + have hau := positivePrefix_trans N hα hdu + have hav := positivePrefix_trans N hα hdv + have hiu := (folded_simple_atom_iff M Y hY u α).mp hau + have hiv := (folded_simple_atom_iff M Y hY v α).mp hav + have hig := hg _ hiu hiv + obtain ⟨ur,hur⟩ := hiu + obtain ⟨vr,hvr⟩ := hiv + obtain ⟨gr,hgr⟩ := hig + have su := (positive_simple_factors R _ _ _ hur.symm).2 + have sv := (positive_simple_factors R _ _ _ hvr.symm).2 + have sg := (positive_simple_factors R _ _ _ hgr.symm).2 + have pgu : PositivePrefix R gr ur := + (positivePrefix_mul_left_iff R cancelR _ _ _).mp (by rwa [←hur,←hgr]) + have pgv : PositivePrefix R gr vr := + (positivePrefix_mul_left_iff R cancelR _ _ _).mp (by rwa [←hvr,←hgr]) + have pg : ∀ x, PositivePrefix R x ur → PositivePrefix R x vr → PositivePrefix R x gr := by + intro x hxu hxv + apply (positivePrefix_mul_left_iff R cancelR (positiveGenerator R α.1) x gr).mp + rw [←hgr] + apply hg + · rw [hur]; exact positivePrefix_mul_left R _ hxu + · rw [hvr]; exact positivePrefix_mul_left R _ hxv + have hcolor : PositivePrefix N (Φ (positiveGenerator R α.1)) (positiveSimpleLift N d) := + hd _ (folded_prefix M Y hY ⟨ur,hur⟩) (folded_prefix M Y hY ⟨vr,hvr⟩) + obtain ⟨dr,hdr⟩ := hcolor + have dru : PositivePrefix N dr (Φ ur) := + (positivePrefix_mul_left_iff N cancelN _ _ _).mp (by + simpa only [hur,map_mul,hdr] using hdu) + have drv : PositivePrefix N dr (Φ vr) := + (positivePrefix_mul_left_iff N cancelN _ _ _).mp (by + simpa only [hvr,map_mul,hdr] using hdv) + have hlt : (R).toCoxeterSystem.length (positiveToCoxeter R ur) < + (R).toCoxeterSystem.length u := by + have hdg := congrArg (positiveDegree R) hur + simp only [positiveDegree_simpleLift,positiveDegree_mul,positiveDegree_generator] at hdg + rw [su,positiveDegree_simpleLift] at hdg + omega + have hr := ih (positiveToCoxeter R ur) hlt (positiveToCoxeter R vr) + (positiveToCoxeter R gr) (by rwa [←sg,←su]) (by rwa [←sg,←sv]) + (by simpa only [←su,←sv,←sg] using pg) dr + (by rwa [←su]) (by rwa [←sv]) + rw [←sg] at hr + rw [hdr,hgr,map_mul] + exact positivePrefix_mul_left N _ hr + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GeneratorPowers.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GeneratorPowers.lean new file mode 100644 index 0000000000000000000000000000000000000000..28032d3e4c261ac57e3adbea88c71666bc0b927c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GeneratorPowers.lean @@ -0,0 +1,129 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.StandardEmbedding + +namespace OAI + +/-! Infinite cyclic generator subgroups and their intersections with standard +parabolics. The retraction argument supplies infinite branching in visual trees. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} (M : CoxeterMatrix S) + +private lemma exponent_alternating (s t : S) (n : ℕ) : + FreeGroup.lift (fun _ : S => Multiplicative.ofAdd (1 : ℤ)) (alternating s t n)= + Multiplicative.ofAdd (n : ℤ) := by + induction n generalizing s t with + | zero => rfl + | succ n ih => + rw [alternating,map_mul,FreeGroup.lift_apply_of,ih] + change Multiplicative.ofAdd (1+(n : ℤ))=Multiplicative.ofAdd (n+1 : ℤ) + congr 1 + omega + +private lemma exponent_relators : ∀ r∈braidRelators M, + FreeGroup.lift (fun _ : S => Multiplicative.ofAdd (1 : ℤ)) r=1 := by + rintro r ⟨⟨s,t⟩,rfl⟩ + rw [map_mul,map_inv,exponent_alternating,exponent_alternating,mul_inv_cancel] + +/-- The total exponent homomorphism for the Artin presentation. -/ +def artinExponent : Artin M →* Multiplicative ℤ := + PresentedGroup.toGroup (exponent_relators M) + +@[simp] lemma artinExponent_generator (s : S) : + artinExponent M (generator M s)=Multiplicative.ofAdd (1 : ℤ) := + PresentedGroup.toGroup.of _ + +lemma generator_zpow_eq_one_iff (s : S) (n : ℤ) : + generator M s ^ n=1 ↔ n=0 := by + constructor + · intro h + have he := congrArg (artinExponent M) h + simp only [map_zpow,map_one] at he + rw [artinExponent_generator] at he + simpa using congrArg Multiplicative.toAdd he + · rintro rfl + exact zpow_zero _ + +variable [Fintype S] (J : Set S) +local notation "cs" => M.toCoxeterSystem +local notation "R" => restrictedMatrix M J + +lemma parabolicStepLetter_one_outside (t : S) (ht : t∉J) : + parabolicStepLetter cs J 1 t=none := by + have hrep : parabolicRep cs J 1=1 := + parabolicRep_of_minimum cs J 1 (by intro a _; simp only [(cs).length_one]; omega) + have hcomp : parabolicComponent cs J 1=1 := by simp only [parabolicComponent,hrep,inv_one,mul_one] + cases hh : parabolicStepLetter cs J 1 t with + | none => rfl + | some s => + have he := parabolicStepLetter_conjugate cs J 1 t s hh + simp only [hcomp,MulAut.conj_apply,one_mul,inv_one,mul_one] at he + exact False.elim (ht ((simple_injective cs he) ▸ s.property)) + +lemma parabolicStepArtin_one_outside (t : S) (ht : t∉J) : + parabolicStepArtin M J 1 t=1 := by + simp only [parabolicStepArtin,parabolicStepLetter_one_outside M J t ht, + Option.toList_none,wordArtin,List.map_nil,List.prod_nil] + +/-- Every integral power of an outside generator has trivial parabolic read. -/ +lemma generator_power_retraction (t : S) (ht : t∉J) (n : ℤ) : + (MulOpposite.unop (parabolicRetractionAction M J (generator M t ^ n)) + (1,1)).2=1 := by + let f := parabolicStepPerm M J t + let B : Set (M.Group × Artin R) := {x | (x.1=1 ∨ x.1=(cs).simple t) ∧ x.2=1} + have hs := parabolicStepArtin_one_outside M J t ht + have hs' : parabolicStepArtin M J ((cs).simple t) t=1 := by + simpa only [one_mul] using (parabolicStepArtin_reverse M J 1 t).trans hs + have hf : ∀ x∈B, f x∈B := by + rintro ⟨w,a⟩ ⟨hw,ha⟩ + rcases hw with rfl|rfl + · refine ⟨Or.inr (one_mul _),?_⟩ + change a*parabolicStepArtin M J 1 t=1 + rwa [hs,mul_one] + · refine ⟨Or.inl ((cs).simple_mul_simple_self t),?_⟩ + change a*parabolicStepArtin M J ((cs).simple t) t=1 + rwa [hs',mul_one] + have hfi : ∀ x∈B, f.symm x∈B := by + rintro ⟨w,a⟩ ⟨hw,ha⟩ + rcases hw with rfl|rfl + · refine ⟨Or.inr (one_mul _),?_⟩ + change a*(parabolicStepArtin M J 1 t)⁻¹=1 + rwa [hs,inv_one,mul_one] + · refine ⟨Or.inl ((cs).simple_mul_simple_self t),?_⟩ + change a*(parabolicStepArtin M J ((cs).simple t) t)⁻¹=1 + rwa [hs',inv_one,mul_one] + have hall : ∀ n : ℤ, MulOpposite.unop (parabolicRetractionAction M J (generator M t ^ n)) (1,1)∈B := by + intro n + induction n using Int.induction_on with + | zero => + simp only [zpow_zero,map_one,MulOpposite.unop_one,Equiv.Perm.one_apply] + exact ⟨Or.inl rfl,rfl⟩ + | succ n ih => + rw [zpow_add_one,map_mul,MulOpposite.unop_mul,Equiv.Perm.mul_apply, + parabolicRetractionAction_generator,MulOpposite.unop_op] + exact hf _ ih + | pred n ih => + rw [zpow_sub_one,map_mul,map_inv,MulOpposite.unop_mul,Equiv.Perm.mul_apply, + parabolicRetractionAction_generator,MulOpposite.unop_inv,MulOpposite.unop_op] + exact hfi _ ih + exact (hall n).2 + +/-- A nonzero power of an omitted generator never lies in a standard parabolic. -/ +theorem generator_zpow_not_mem (t : S) (ht : t∉J) (n : ℤ) (hn : n≠0) : + generator M t ^ n∉artinParabolic M J := by + intro hm + obtain ⟨a,ha⟩ := (restrictedArtinHom_range M J ▸ hm) + have h := parabolicRetractionAction_standard M J a 1 + have he := generator_power_retraction M J t ht n + rw [←ha] at he + change (MulOpposite.unop (parabolicRetractionAction M J (restrictedArtinHom M J a)) + (parabolicState M J 1)).2=1 at he + rw [h] at he + change 1*a=1 at he + rw [one_mul] at he + have hh : generator M t ^ n=1 := by rw [←ha,he,map_one] + exact hn ((generator_zpow_eq_one_iff M t n).mp hh) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphMetric.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphMetric.lean new file mode 100644 index 0000000000000000000000000000000000000000..855883e9fcf4a8a8ca7beb7bf52462860972d08c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphMetric.lean @@ -0,0 +1,45 @@ +import Mathlib.Combinatorics.SimpleGraph.Acyclic +import Mathlib.Topology.MetricSpace.Isometry +import Mathlib.GroupTheory.GroupAction.Basic + +namespace OAI + +/-! The real-valued graph metric and the induced isometric action. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {V : Type} (H : SimpleGraph V) + +@[instance_reducible] +noncomputable def graphMetric (hH : H.Connected) : MetricSpace V where + dist x y := H.dist x y + dist_self x := by simp + dist_comm x y := by rw [H.dist_comm] + dist_triangle x y z := by exact_mod_cast hH.dist_triangle (u := x) (v := y) (w := z) + eq_of_dist_eq_zero h := hH.dist_eq_zero_iff.mp (Nat.cast_eq_zero.mp h) + +variable {G : Type} [Group G] [MulAction G V] + +lemma graph_action_dist (hH : H.Connected) + (hA : ∀ g : G,∀ ⦃x y : V⦄,H.Adj x y → H.Adj (g • x) (g • y)) + (g : G) (x y : V) : H.dist (g • x) (g • y)=H.dist x y := by + have hle (a : G) (u v : V) : H.dist (a • u) (a • v)≤H.dist u v := by + obtain ⟨p,hp⟩ := hH.exists_walk_length_eq_dist u v + let f : H →g H := ⟨(a • ·),fun h => hA a h⟩ + have h := H.dist_le (p.map f) + change H.dist (a • u) (a • v)≤(p.map f).length at h + simpa only [SimpleGraph.Walk.length_map,hp] using h + apply le_antisymm (hle g x y) + simpa only [inv_smul_smul] using hle g⁻¹ (g • x) (g • y) + +lemma graph_action_isometric (hH : H.Connected) + (hA : ∀ g : G,∀ ⦃x y : V⦄,H.Adj x y → H.Adj (g • x) (g • y)) (g : G) : + let _ := graphMetric H hH + Isometry (fun x : V => g • x) := by + let _ := graphMetric H hH + apply isometry_iff_dist_eq.mpr + intro x y + change (H.dist (g • x) (g • y) : ℝ)=(H.dist x y : ℝ) + exact_mod_cast graph_action_dist H hH hA g x y + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationAction.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationAction.lean new file mode 100644 index 0000000000000000000000000000000000000000..477921c3e68ebfebb26fe235e5483ed709f4a660 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationAction.lean @@ -0,0 +1,114 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphRealizationSpace +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeActionDefinitions + +namespace OAI + +/-! An action on a graph extends isometrically to its unit-interval realization. -/ +namespace HarmonicArtin.ParabolicIntersections.GraphRealization +open TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (H : SimpleGraph V) (hA : PreservesAdj (G := G) H) + +def actDart (g : G) (e : H.Dart) : H.Dart := ⟨(g • e.fst,g • e.snd),hA g e.adj⟩ + +lemma actDart_injective (g : G) : Function.Injective (actDart H hA g) := by + intro e f he + apply SimpleGraph.Dart.ext + apply Prod.ext + · exact (MulAction.toPerm g).injective (congrArg (fun d : H.Dart => d.fst) he) + · exact (MulAction.toPerm g).injective (congrArg (fun d : H.Dart => d.snd) he) + +def actPoint (g : G) : Point H → Point H + | .vertex v => .vertex (g • v) + | .edge e t => .edge (actDart H hA g e) t + +lemma actPoint_one (p : Point H) : actPoint H hA 1 p=p := by + cases p with + | vertex v => simp [actPoint] + | edge e t => + change Point.edge (actDart H hA 1 e) t=Point.edge e t + apply congrArg (fun d : H.Dart => Point.edge d t) + apply SimpleGraph.Dart.ext + simp [actDart,one_smul] + +lemma actPoint_mul (g h : G) (p : Point H) : + actPoint H hA (g*h) p=actPoint H hA g (actPoint H hA h p) := by + cases p with + | vertex v => simp [actPoint,mul_smul] + | edge e t => + change Point.edge (actDart H hA (g*h) e) t= + Point.edge (actDart H hA g (actDart H hA h e)) t + apply congrArg (fun d : H.Dart => Point.edge d t) + apply SimpleGraph.Dart.ext + simp [actDart,mul_smul] + +lemma anchor_act (g : G) (p : Point H) (i : Bool) : + anchor H (actPoint H hA g p) i=g • anchor H p i := by + cases p <;> cases i <;> rfl + +lemma weight_act (g : G) (p : Point H) (i : Bool) : + weight H (actPoint H hA g p) i=weight H p i := by + cases p <;> cases i <;> rfl + +lemma route_act (hH : H.Connected) (g : G) (p q : Point H) (i j : Bool) : + route H (actPoint H hA g p) (actPoint H hA g q) i j=route H p q i j := by + simp only [route,anchor_act,weight_act,graph_action_dist H hH hA] + +lemma distance_act (hH : H.Connected) (g : G) (p q : Point H) : + distance H (actPoint H hA g p) (actPoint H hA g q)=distance H p q := by + have hv (p q : Point H) : via H (actPoint H hA g p) (actPoint H hA g q)=via H p q := by + simp only [via,route_act H hA hH] + cases p with + | vertex x => cases q <;> exact hv _ _ + | edge e t => + cases q with + | vertex y => + change via H (actPoint H hA g (.edge e t)) (actPoint H hA g (.vertex y))=via H (.edge e t) (.vertex y) + exact hv _ _ + | edge f s => + have he : actDart H hA g e=actDart H hA g f ↔ e=f := (actDart_injective H hA g).eq_iff + simp only [actPoint,distance,he] + rw [←actPoint,←actPoint,hv] + +noncomputable def act (hH : H.Connected) (g : G) : Space H hH → Space H hH := by + let _ := premetric H hH + exact SeparationQuotient.map (actPoint H hA g) + +lemma act_embed (hH : H.Connected) (g : G) (p : Point H) : + act H hA hH g (embed H hH p)=embed H hH (actPoint H hA g p) := by + let _ := premetric H hH + have hi : Isometry (actPoint H hA g) := by + apply isometry_iff_dist_eq.mpr + exact distance_act H hA hH g + exact SeparationQuotient.map_mk hi.uniformContinuous p + +@[instance_reducible] +noncomputable def action (hH : H.Connected) : MulAction G (Space H hH) where + smul := act H hA hH + one_smul x := by + obtain ⟨p,rfl⟩ := embed_surjective H hH x + change act H hA hH 1 (embed H hH p)=embed H hH p + rw [act_embed,actPoint_one] + mul_smul g h x := by + obtain ⟨p,rfl⟩ := embed_surjective H hH x + change act H hA hH (g*h) (embed H hH p)=act H hA hH g (act H hA hH h (embed H hH p)) + rw [act_embed,act_embed,act_embed,actPoint_mul] + +lemma action_isometric (hH : H.Connected) (g : G) : + let _ := action H hA hH + Isometry (fun x : Space H hH => g • x) := by + let _ := action H hA hH + apply isometry_iff_dist_eq.mpr + intro x y + obtain ⟨p,rfl⟩ := embed_surjective H hH x + obtain ⟨q,rfl⟩ := embed_surjective H hH y + change dist (act H hA hH g (embed H hH p)) (act H hA hH g (embed H hH q))= _ + rw [act_embed,act_embed,dist_embed,dist_embed,distance_act H hA hH g] + +lemma act_vertex (hH : H.Connected) (g : G) (v : V) : + act H hA hH g (vertex H hH v)=vertex H hH (g • v) := act_embed H hA hH g (.vertex v) + +end HarmonicArtin.ParabolicIntersections.GraphRealization + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationAcylindrical.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationAcylindrical.lean new file mode 100644 index 0000000000000000000000000000000000000000..b7199d713102635d956ea36dbf4749fcab2eba49 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationAcylindrical.lean @@ -0,0 +1,59 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphRealizationAction +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphRealizationHyperbolic + +namespace OAI + +/-! Acylindricity passes from graph vertices to their unit-interval realization. -/ +namespace HarmonicArtin.ParabolicIntersections.GraphRealization +open TreeAction +variable {G V : Type} [Group G] [MulAction G V] +variable (H : SimpleGraph V) (hA : PreservesAdj (G := G) H) (hH : H.Connected) + +lemma vertex_displacement_le (g : G) (x : Space H hH) (v : V) + (hv : dist x (vertex H hH v) ≤ 1) (r : ℕ) : + let _ := action H hA hH + dist x (g • x) ≤ r → + (H.dist v (g • v) : ℝ) ≤ r+2 := by + let _ := action H hA hH + change dist x (g • x) ≤ (r : ℝ) → _ + intro hg + have h₁ := dist_triangle (vertex H hH v) x (g • vertex H hH v) + have h₂ := dist_triangle x (g • x) (g • vertex H hH v) + rw [dist_comm (vertex H hH v) x] at h₁ + rw [(action_isometric H hA hH g).dist_eq] at h₂ + have he : dist (vertex H hH v) (g • vertex H hH v)=(H.dist v (g • v) : ℝ) := by + change dist (vertex H hH v) (act H hA hH g (vertex H hH v))= _ + rw [act_vertex,dist_vertex] + rw [he] at h₁ + linarith + +theorem acylindricity_transfer (r R N : ℕ) + (hcount : ∀ v w : V,R ≤ H.dist v w → + {g : G | H.dist v (g • v) ≤ r+2 ∧ H.dist w (g • w) ≤ r+2}.Finite ∧ + {g : G | H.dist v (g • v) ≤ r+2 ∧ H.dist w (g • w) ≤ r+2}.ncard ≤ N) + (x y : Space H hH) (hxy : (R : ℝ)+2 ≤ dist x y) : + let _ := action H hA hH + {g : G | dist x (g • x) ≤ r ∧ dist y (g • y) ≤ r}.Finite ∧ + {g : G | dist x (g • x) ≤ r ∧ dist y (g • y) ≤ r}.ncard ≤ N := by + let _ := action H hA hH + obtain ⟨v,hv⟩ := exists_near_vertex H hH x + obtain ⟨w,hw⟩ := exists_near_vertex H hH y + have hdist : R ≤ H.dist v w := by + have h := (dist_change hv hw).1 + rw [dist_vertex] at h + have h' : (R : ℝ) ≤ H.dist v w := by linarith + exact_mod_cast h' + obtain ⟨hfin,hcard⟩ := hcount v w hdist + have hsub : {g : G | dist x (g • x) ≤ r ∧ dist y (g • y) ≤ r} ⊆ + {g : G | H.dist v (g • v) ≤ r+2 ∧ H.dist w (g • w) ≤ r+2} := by + intro g hg + constructor + · have h := vertex_displacement_le H hA hH g x v hv r hg.1 + exact_mod_cast h + · have h := vertex_displacement_le H hA hH g y w hw r hg.2 + exact_mod_cast h + exact ⟨hfin.subset hsub,(Set.ncard_le_ncard hsub hfin).trans hcard⟩ + +end HarmonicArtin.ParabolicIntersections.GraphRealization + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationDistance.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationDistance.lean new file mode 100644 index 0000000000000000000000000000000000000000..4f6bf481c97d0ecc8a3456c2e44db2bb025a9f6a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationDistance.lean @@ -0,0 +1,182 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphMetric +import Mathlib.Tactic.Linarith + +namespace OAI + +/-! The path distance on unit intervals attached to graph edges. -/ +namespace HarmonicArtin.ParabolicIntersections.GraphRealization +open TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} (H : SimpleGraph V) + +/-- Endpoints are retained at this stage and identified by the metric quotient. -/ +inductive Point where + | vertex : V → Point + | edge : H.Dart → Set.Icc (0 : ℝ) 1 → Point + +def anchor : Point H → Bool → V + | .vertex v, _ => v + | .edge e _, false => e.fst + | .edge e _, true => e.snd + +def weight : Point H → Bool → ℝ + | .vertex _, _ => 0 + | .edge _ t, false => t + | .edge _ t, true => 1-t + +noncomputable def route (p q : Point H) (i j : Bool) : ℝ := + weight H p i+(H.dist (anchor H p i) (anchor H q j) : ℝ)+weight H q j + +noncomputable def via (p q : Point H) : ℝ := + min (route H p q false false) (min (route H p q false true) + (min (route H p q true false) (route H p q true true))) + +noncomputable def distance : Point H → Point H → ℝ + | .edge e t, .edge f s => if e=f then min |(t : ℝ)-s| (via H (.edge e t) (.edge f s)) + else via H (.edge e t) (.edge f s) + | p,q => via H p q + +lemma weight_nonneg (p : Point H) (i : Bool) : 0 ≤ weight H p i := by + cases p with + | vertex v => rfl + | edge e t => cases i <;> simp only [weight] <;> linarith [t.property.1,t.property.2] + +lemma route_nonneg (p q : Point H) (i j : Bool) : 0 ≤ route H p q i j := by + exact add_nonneg (add_nonneg (weight_nonneg H p i) (Nat.cast_nonneg _)) (weight_nonneg H q j) + +lemma via_le_route (p q : Point H) (i j : Bool) : via H p q ≤ route H p q i j := by + cases i <;> cases j <;> simp only [via] <;> order + +lemma via_eq_route (p q : Point H) : ∃ i j, via H p q=route H p q i j := by + rcases min_choice (route H p q false false) + (min (route H p q false true) (min (route H p q true false) (route H p q true true))) with h|h + · exact ⟨false,false,h⟩ + · rcases min_choice (route H p q false true) + (min (route H p q true false) (route H p q true true)) with h'|h' + · exact ⟨false,true,h.trans h'⟩ + · rcases min_choice (route H p q true false) (route H p q true true) with h''|h'' + · exact ⟨true,false,h.trans (h'.trans h'')⟩ + · exact ⟨true,true,h.trans (h'.trans h'')⟩ + +lemma distance_le_via (p q : Point H) : distance H p q ≤ via H p q := by + cases p <;> cases q <;> simp only [distance] + all_goals first | exact le_rfl | (split_ifs <;> order) + +lemma distance_le_route (p q : Point H) (i j : Bool) : distance H p q ≤ route H p q i j := + (distance_le_via H p q).trans (via_le_route H p q i j) + +lemma distance_le_direct (e : H.Dart) (t s : Set.Icc (0 : ℝ) 1) : + distance H (.edge e t) (.edge e s) ≤ |(t : ℝ)-s| := by + simp [distance] + +lemma distance_cases (p q : Point H) : + (∃ e t s,p=.edge e t ∧ q=.edge e s ∧ distance H p q=|(t : ℝ)-s|) ∨ + ∃ i j,distance H p q=route H p q i j := by + cases p with + | vertex x => exact Or.inr (via_eq_route H _ _) + | edge e t => + cases q with + | vertex y => exact Or.inr (via_eq_route H _ _) + | edge f s => + by_cases he : e=f + · subst f + rcases min_choice |(t : ℝ)-s| (via H (.edge e t) (.edge e s)) with h|h + · exact Or.inl ⟨e,t,s,rfl,rfl,by simpa [distance] using h⟩ + · obtain ⟨i,j,hv⟩ := via_eq_route H (.edge e t) (.edge e s) + exact Or.inr ⟨i,j,by simpa [distance] using h.trans hv⟩ + · simpa only [distance,ite_eq_right he] using Or.inr (via_eq_route H (.edge e t) (.edge f s)) + +lemma distance_nonneg (p q : Point H) : 0 ≤ distance H p q := by + rcases distance_cases H p q with ⟨e,t,s,rfl,rfl,hd⟩|⟨i,j,hd⟩ + · rw [hd]; exact abs_nonneg _ + · rw [hd]; exact route_nonneg H p q i j + +lemma route_comm (p q : Point H) (i j : Bool) : route H p q i j=route H q p j i := by + unfold route + rw [H.dist_comm] + ring + +lemma distance_comm (p q : Point H) : distance H p q=distance H q p := by + have h (p q : Point H) : distance H p q ≤ distance H q p := by + rcases distance_cases H q p with ⟨e,t,s,rfl,rfl,hd⟩|⟨i,j,hd⟩ + · rw [hd,abs_sub_comm] + exact distance_le_direct H e s t + · rw [hd,route_comm] + exact distance_le_route H p q j i + exact le_antisymm (h p q) (h q p) + +lemma distance_self (p : Point H) : distance H p p=0 := by + apply le_antisymm _ (distance_nonneg H p p) + cases p with + | vertex v => simpa [route,anchor,weight] using distance_le_route H (.vertex v) (.vertex v) false false + | edge e t => simpa using distance_le_direct H e t t + +lemma anchor_bridge (p : Point H) (i j : Bool) : + (H.dist (anchor H p i) (anchor H p j) : ℝ) ≤ weight H p i+weight H p j := by + cases p with + | vertex v => simp [anchor,weight] + | edge e t => + have hd : H.dist e.fst e.snd=1 := H.dist_eq_one_iff_adj.mpr e.adj + have hd' : H.dist e.snd e.fst=1 := H.dist_eq_one_iff_adj.mpr e.adj.symm + cases i <;> cases j <;> simp only [anchor,weight,hd,hd',SimpleGraph.dist_self,Nat.cast_zero,Nat.cast_one] + all_goals linarith [t.property.1,t.property.2] + +lemma edge_weight_le (e : H.Dart) (t s : Set.Icc (0 : ℝ) 1) (i : Bool) : + weight H (.edge e t) i ≤ weight H (.edge e s) i+|(t : ℝ)-s| := by + cases i <;> simp only [weight] + · linarith [le_abs_self ((t : ℝ)-s)] + · linarith [neg_le_abs ((t : ℝ)-s)] + +lemma route_triangle (hH : H.Connected) (p q r : Point H) (i j k l : Bool) : + route H p r i l ≤ route H p q i j+route H q r k l := by + have h₁ := hH.dist_triangle (u := anchor H p i) (v := anchor H q j) (w := anchor H r l) + have h₂ := hH.dist_triangle (u := anchor H q j) (v := anchor H q k) (w := anchor H r l) + have h₁' : (H.dist (anchor H p i) (anchor H r l) : ℝ) ≤ + H.dist (anchor H p i) (anchor H q j)+H.dist (anchor H q j) (anchor H r l) := by exact_mod_cast h₁ + have h₂' : (H.dist (anchor H q j) (anchor H r l) : ℝ) ≤ + H.dist (anchor H q j) (anchor H q k)+H.dist (anchor H q k) (anchor H r l) := by exact_mod_cast h₂ + have hb := anchor_bridge H q j k + unfold route + linarith + +theorem distance_triangle (hH : H.Connected) (p q r : Point H) : + distance H p r ≤ distance H p q+distance H q r := by + rcases distance_cases H p q with ⟨e,t,s,hp,hq,hd⟩|⟨i,j,hd⟩ + · subst p; subst q + rcases distance_cases H (.edge e s) r with ⟨f,a,b,he,hr,hd'⟩|⟨i,j,hd'⟩ + · cases he + subst r + have ht := abs_sub_le (t : ℝ) s b + exact (distance_le_direct H e t b).trans (by rw [hd,hd']; exact ht) + · have hle := distance_le_route H (.edge e t) r i j + have hw := edge_weight_le H e t s i + rw [hd,hd'] + refine hle.trans ?_ + unfold route + have ha : anchor H (.edge e t) i=anchor H (.edge e s) i := by cases i <;> rfl + rw [ha] + linarith + · rcases distance_cases H q r with ⟨e,t,s,hq,hr,hd'⟩|⟨k,l,hd'⟩ + · subst q; subst r + have hle := distance_le_route H p (.edge e s) i j + have hw := edge_weight_le H e s t j + rw [hd,hd'] + refine hle.trans ?_ + unfold route + have ha : anchor H (.edge e s) j=anchor H (.edge e t) j := by cases j <;> rfl + rw [ha] + rw [abs_sub_comm (s : ℝ) t] at hw + linarith + · rw [hd,hd'] + exact (distance_le_route H p r i l).trans (route_triangle H hH p q r i j k l) + +@[instance_reducible] +noncomputable def premetric (hH : H.Connected) : PseudoMetricSpace (Point H) where + dist := distance H + dist_self := distance_self H + dist_comm := distance_comm H + dist_triangle := distance_triangle H hH + +end HarmonicArtin.ParabolicIntersections.GraphRealization + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationGeodesic.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationGeodesic.lean new file mode 100644 index 0000000000000000000000000000000000000000..198f7cd92ad775957902c9a0fbbae86244318bf5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationGeodesic.lean @@ -0,0 +1,82 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphRealizationSpace +import OAI.Topology.ArtinGroups.ParabolicIntersections.MetricUnitCurves +import Mathlib.Topology.MetricSpace.Lipschitz + +namespace OAI + +/-! Shortest paths in the unit-interval realization of a connected graph. -/ +namespace HarmonicArtin.ParabolicIntersections.GraphRealization +variable {V : Type} (H : SimpleGraph V) (hH : H.Connected) + +lemma arc_curve (e : H.Dart) (t s : Set.Icc (0 : ℝ) 1) : + HasCurve (arc H hH e t) (arc H hH e s) |(t : ℝ)-s| := by + let f : ℝ → Space H hH := fun r => arc H hH e (Set.projIcc 0 1 (by norm_num) r) + have hf (a b : ℝ) : dist (f a) (f b) ≤ |a-b| := by + rw [dist_arc] + simpa only [Subtype.dist_eq,Real.dist_eq,NNReal.coe_one,one_mul] using + (LipschitzWith.projIcc (by norm_num : (0 : ℝ) ≤ 1)).dist_le_mul a b + have ht : f t=arc H hH e t := by + simp only [f,Set.projIcc_val] + have hs : f s=arc H hH e s := by + simp only [f,Set.projIcc_val] + simpa only [ht,hs] using curve_subsegment f hf (t : ℝ) (s : ℝ) + +lemma curve_to_anchor (p : Point H) (i : Bool) : + HasCurve (embed H hH p) (vertex H hH (anchor H p i)) (weight H p i) := by + cases p with + | vertex v => exact curve_const _ + | edge e t => + cases i + · have h := arc_curve H hH e t ⟨0,by norm_num⟩ + change HasCurve (arc H hH e t) (vertex H hH e.fst) (t : ℝ) + simpa only [arc_zero,sub_zero,abs_of_nonneg t.property.1] using h + · have h := arc_curve H hH e t ⟨1,by norm_num⟩ + change HasCurve (arc H hH e t) (vertex H hH e.snd) (1-(t : ℝ)) + simpa only [arc_one,abs_of_nonpos (sub_nonpos.mpr t.property.2),neg_sub] using h + +lemma curve_of_adj {x y : V} (hxy : H.Adj x y) : + HasCurve (vertex H hH x) (vertex H hH y) 1 := by + let e : H.Dart := ⟨(x,y),hxy⟩ + have h := arc_curve H hH e ⟨0,by norm_num⟩ ⟨1,by norm_num⟩ + simpa only [arc_zero,arc_one,zero_sub,abs_neg,abs_one] using h + +lemma curve_of_walk {x y : V} (p : H.Walk x y) : + HasCurve (vertex H hH x) (vertex H hH y) (p.length : ℝ) := by + induction p with + | @nil x => simpa only [SimpleGraph.Walk.length_nil,Nat.cast_zero] using curve_const (vertex H hH x) + | @cons x z y hxz p ih => + have h := curve_concat (by norm_num : (0 : ℝ) ≤ 1) (Nat.cast_nonneg p.length) + (curve_of_adj H hH hxz) ih + simpa only [SimpleGraph.Walk.length_cons,Nat.cast_add,Nat.cast_one,add_comm] using h + +lemma curve_between_vertices (x y : V) : + HasCurve (vertex H hH x) (vertex H hH y) (H.dist x y : ℝ) := by + obtain ⟨p,hp⟩ := hH.exists_walk_length_eq_dist x y + simpa only [hp] using curve_of_walk H hH p + +lemma curve_via (p q : Point H) (i j : Bool) : + HasCurve (embed H hH p) (embed H hH q) (route H p q i j) := by + have hc := curve_concat (weight_nonneg H p i) + (Nat.cast_nonneg (H.dist (anchor H p i) (anchor H q j))) + (curve_to_anchor H hH p i) (curve_between_vertices H hH (anchor H p i) (anchor H q j)) + exact curve_concat (add_nonneg (weight_nonneg H p i) (Nat.cast_nonneg _)) + (weight_nonneg H q j) hc (curve_reverse (curve_to_anchor H hH q j)) + +theorem curve_between (x y : Space H hH) : HasCurve x y (dist x y) := by + obtain ⟨p,rfl⟩ := embed_surjective H hH x + obtain ⟨q,rfl⟩ := embed_surjective H hH y + rw [dist_embed] + rcases distance_cases H p q with ⟨e,t,s,rfl,rfl,hd⟩|⟨i,j,hd⟩ + · rw [hd] + exact arc_curve H hH e t s + · rw [hd] + exact curve_via H hH p q i j + +theorem realization_geodesic (x y : Space H hH) : + ∃ γ : Set.Icc (0 : ℝ) (dist x y) → Space H hH, Isometry γ ∧ + γ ⟨0,le_rfl,dist_nonneg⟩=x ∧ γ ⟨dist x y,dist_nonneg,le_rfl⟩=y := + curve_realizes_distance (curve_between H hH x y) + +end HarmonicArtin.ParabolicIntersections.GraphRealization + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationHyperbolic.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationHyperbolic.lean new file mode 100644 index 0000000000000000000000000000000000000000..5bf9e742bd72c16c44d9cb95a446229ee83c0a67 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationHyperbolic.lean @@ -0,0 +1,54 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphRealizationSpace +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutHyperbolic + +namespace OAI + +/-! Hyperbolicity passes from graph vertices to the unit-interval realization. -/ +namespace HarmonicArtin.ParabolicIntersections.GraphRealization +open TreeAction +variable {V : Type} (H : SimpleGraph V) (hH : H.Connected) + +noncomputable def product (o x y : Space H hH) : ℝ := (dist o x+dist o y-dist x y)/2 + +lemma dist_change {X : Type} [MetricSpace X] {x y x' y' : X} + (hx : dist x x' ≤ 1) (hy : dist y y' ≤ 1) : + dist x y ≤ dist x' y'+2 ∧ dist x' y' ≤ dist x y+2 := by + have h₁ := dist_triangle x x' y + have h₂ := dist_triangle x' y' y + have h₃ := dist_triangle x' x y' + have h₄ := dist_triangle x y y' + rw [dist_comm y' y] at h₂ + rw [dist_comm x' x] at h₃ + constructor <;> linarith + +lemma product_close {o x y : Space H hH} {a b c : V} + (ho : dist o (vertex H hH a) ≤ 1) (hx : dist x (vertex H hH b) ≤ 1) + (hy : dist y (vertex H hH c) ≤ 1) : + product H hH o x y ≤ graphProduct H a b c+3 ∧ + graphProduct H a b c ≤ product H hH o x y+3 := by + have h₁ := dist_change ho hx + have h₂ := dist_change ho hy + have h₃ := dist_change hx hy + rw [dist_vertex] at h₁ h₂ h₃ + unfold product graphProduct + constructor <;> linarith + +theorem realization_hyperbolic (δ : ℝ) + (hδ : ∀ o x y z,min (graphProduct H o x y) (graphProduct H o y z) ≤ graphProduct H o x z+δ) + (o x y z : Space H hH) : + min (product H hH o x y) (product H hH o y z) ≤ product H hH o x z+(δ+6) := by + obtain ⟨a,ha⟩ := exists_near_vertex H hH o + obtain ⟨b,hb⟩ := exists_near_vertex H hH x + obtain ⟨c,hc⟩ := exists_near_vertex H hH y + obtain ⟨d,hd⟩ := exists_near_vertex H hH z + have h₁ := product_close H hH ha hb hc + have h₂ := product_close H hH ha hc hd + have h₃ := product_close H hH ha hb hd + have hm := min_le_min h₁.1 h₂.1 + rw [min_add_add_right] at hm + have hh := hδ a b c d + linarith + +end HarmonicArtin.ParabolicIntersections.GraphRealization + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationSpace.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationSpace.lean new file mode 100644 index 0000000000000000000000000000000000000000..e4928d380fe582d52980691b64d04394ebe4d7d4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphRealizationSpace.lean @@ -0,0 +1,87 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphRealizationDistance + +namespace OAI + +/-! The metric realization of a connected graph by unit intervals. -/ +namespace HarmonicArtin.ParabolicIntersections.GraphRealization +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} (H : SimpleGraph V) + +lemma distance_vertices (x y : V) : distance H (.vertex x) (.vertex y)=(H.dist x y : ℝ) := by + simp [distance,via,route,anchor,weight] + +lemma distance_edge (e : H.Dart) (t s : Set.Icc (0 : ℝ) 1) : + distance H (.edge e t) (.edge e s)=|(t : ℝ)-s| := by + apply le_antisymm (distance_le_direct H e t s) + rcases distance_cases H (.edge e t) (.edge e s) with ⟨f,a,b,he,he',hd⟩|⟨i,j,hd⟩ + · cases he + cases he' + exact hd.ge + · rw [hd] + have hdist : H.dist e.fst e.snd=1 := H.dist_eq_one_iff_adj.mpr e.adj + have hdist' : H.dist e.snd e.fst=1 := H.dist_eq_one_iff_adj.mpr e.adj.symm + cases i <;> cases j <;> + simp only [route,anchor,weight,hdist,hdist',SimpleGraph.dist_self,Nat.cast_zero,Nat.cast_one] + all_goals apply abs_le.mpr; constructor <;> linarith [t.property.1,t.property.2,s.property.1,s.property.2] + +lemma weight_le_one (p : Point H) (i : Bool) : weight H p i ≤ 1 := by + cases p with + | vertex v => norm_num [weight] + | edge e t => cases i <;> simp only [weight] <;> linarith [t.property.1,t.property.2] + +lemma distance_anchor_le (p : Point H) (i : Bool) : + distance H p (.vertex (anchor H p i)) ≤ weight H p i := by + simpa [route,anchor,weight] using distance_le_route H p (.vertex (anchor H p i)) i false + +def Space (hH : H.Connected) := + @SeparationQuotient (Point H) (premetric H hH).toUniformSpace.toTopologicalSpace + +noncomputable instance spaceMetric (hH : H.Connected) : MetricSpace (Space H hH) := + @SeparationQuotient.instMetricSpace (Point H) (premetric H hH) + +noncomputable def embed (hH : H.Connected) : Point H → Space H hH := + @SeparationQuotient.mk (Point H) (premetric H hH).toUniformSpace.toTopologicalSpace + +lemma dist_embed (hH : H.Connected) (p q : Point H) : + dist (embed H hH p) (embed H hH q)=distance H p q := rfl + +lemma embed_surjective (hH : H.Connected) : Function.Surjective (embed H hH) := + @SeparationQuotient.surjective_mk (Point H) (premetric H hH).toUniformSpace.toTopologicalSpace + +noncomputable def vertex (hH : H.Connected) (v : V) : Space H hH := embed H hH (.vertex v) + +lemma dist_vertex (hH : H.Connected) (x y : V) : + dist (vertex H hH x) (vertex H hH y)=(H.dist x y : ℝ) := distance_vertices H x y + +lemma vertex_injective (hH : H.Connected) : Function.Injective (vertex H hH) := by + intro x y he + have hd : (H.dist x y : ℝ)=0 := by rw [←dist_vertex H hH,he,dist_self] + exact hH.dist_eq_zero_iff.mp (Nat.cast_eq_zero.mp hd) + +lemma exists_near_vertex (hH : H.Connected) (x : Space H hH) : + ∃ v,dist x (vertex H hH v) ≤ 1 := by + obtain ⟨p,rfl⟩ := embed_surjective H hH x + exact ⟨anchor H p false,(distance_anchor_le H p false).trans (weight_le_one H p false)⟩ + +noncomputable def arc (hH : H.Connected) (e : H.Dart) (t : Set.Icc (0 : ℝ) 1) : Space H hH := + embed H hH (.edge e t) + +lemma dist_arc (hH : H.Connected) (e : H.Dart) (t s : Set.Icc (0 : ℝ) 1) : + dist (arc H hH e t) (arc H hH e s)=|(t : ℝ)-s| := distance_edge H e t s + +lemma arc_zero (hH : H.Connected) (e : H.Dart) : + arc H hH e ⟨0,by norm_num⟩=vertex H hH e.fst := by + apply dist_eq_zero.mp + apply le_antisymm _ dist_nonneg + exact distance_anchor_le H (.edge e ⟨0,by norm_num⟩) false + +lemma arc_one (hH : H.Connected) (e : H.Dart) : + arc H hH e ⟨1,by norm_num⟩=vertex H hH e.snd := by + apply dist_eq_zero.mp + apply le_antisymm _ dist_nonneg + change distance H (.edge e ⟨1,by norm_num⟩) (.vertex e.snd) ≤ 0 + simpa only [anchor,weight,sub_self] using distance_anchor_le H (.edge e ⟨1,by norm_num⟩) true + +end HarmonicArtin.ParabolicIntersections.GraphRealization + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphWalkLevels.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphWalkLevels.lean new file mode 100644 index 0000000000000000000000000000000000000000..0239614530f0e67b11b415a02ae6c45bcfa20240 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/GraphWalkLevels.lean @@ -0,0 +1,26 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphMetric + +namespace OAI + +/-! Integer distance levels along a graph walk. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {V : Type} (H : SimpleGraph V) + +lemma walk_exists_dist_level (hH : H.Connected) (o : V) {x y : V} + (p : H.Walk x y) (k : ℕ) (hx : H.dist o x ≤ k) (hy : k ≤ H.dist o y) : + ∃ w∈p.support,H.dist o w=k := by + induction p with + | nil => exact ⟨_,by simp,Nat.le_antisymm hx hy⟩ + | @cons x z y hxz p ih => + by_cases he : H.dist o x=k + · exact ⟨x,by simp,he⟩ + · have hz : H.dist o z ≤ k := by + have ht := hH.dist_triangle (u := o) (v := x) (w := z) + have hd := H.dist_eq_one_iff_adj.mpr hxz + omega + obtain ⟨w,hw,hd⟩ := ih hz hy + exact ⟨w,by simp only [SimpleGraph.Walk.support_cons,List.mem_cons]; exact Or.inr hw,hd⟩ + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/IncomingSpanning.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/IncomingSpanning.lean new file mode 100644 index 0000000000000000000000000000000000000000..7a92ce3e44407a6ce272960cff162a7c870aba31 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/IncomingSpanning.lean @@ -0,0 +1,85 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TokenBoundary +import OAI.Topology.ArtinGroups.ParabolicIntersections.PathImages + +namespace OAI + +/-! Incoming spanning inside a cochain interval, used to force an empty placement. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) [Fintype V] [Fintype A] + {I : Type} [Fintype I] + +/-- If the next higher layer is absent, exactness expresses every basis +vector through incoming arrows in the same layer. Iterated path images +record this statement without losing possible linear cancellations. -/ +theorem incoming_spanning_step (E : BasedComplex Q (K := ℂ) I) (hE : E.IsMinimal Q) + (l r : ℤ) (i : {i | l ≤ (E.placement i).cochain ∧ (E.placement i).cochain ≤ r}) + (hil : l < (E.placement i).cochain) + (hex : ScalarExactAt Q (E.testComplex Q (E.placement i).color) + (E.placement i).color ((E.placement i).level+2) (E.placement i).cochain) + (hhigher : ∀ j, (E.placement j).cochain = (E.placement i).cochain-1 → + (E.placement i).level < (E.placement j).level → False) + (n : ℕ) + (hprev : ∀ j : {j | l ≤ (E.placement j).cochain ∧ (E.placement j).cochain ≤ r}, + (E.placement j).level = (E.placement i).level → + (E.placement j).cochain = (E.placement i).cochain-1 → + Pi.single j (1 : ℂ) ∈ pathImages (arrowMatrix Q (cochainInterval Q E l r)) n) : + Pi.single i (1 : ℂ) ∈ pathImages (arrowMatrix Q (cochainInterval Q E l r)) (n+1) := by + let J := {j | l ≤ (E.placement j).cochain ∧ (E.placement j).cochain ≤ r} + let B := arrowMatrix Q (cochainInterval Q E l r) + obtain ⟨y, hy, he⟩ := generator_token_boundary Q E hE i.val hex + let z (u : TestIndex Q E.placement (E.placement i).color) : J → ℂ := + fun j => y u * pathCoordinates Q (E.differential u.1 j.val) (Path.dual Q u.2.val) + have heq : (Pi.single i (1 : ℂ) : J → ℂ) = ∑ u, z u := by + funext j + rw [Finset.sum_apply] + change (Pi.single i (1 : ℂ) : J → ℂ) j = ∑ u, y u * _ + have h := he j.val + simpa only [Pi.single_apply, Subtype.val_inj] using h + rw [heq] + apply Submodule.sum_mem + intro u _ + by_cases hzero : y u = 0 + · have hz : z u = 0 := by + ext j + change y u * _ = 0 + rw [hzero, MulZeroClass.zero_mul] + rw [hz] + exact Submodule.zero_mem _ + obtain ⟨hdeg, hlev⟩ := hy u hzero + rcases hp : u.2.val with v | a | v + · have hlen : Path.length u.2.val = 0 := by rw [hp]; rfl + have hh : (E.placement i).level < (E.placement u.1).level := by omega + exact (hhigher u.1 hdeg hh).elim + · have hlen : Path.length u.2.val = 1 := by rw [hp]; rfl + have hu : l ≤ (E.placement u.1).cochain ∧ (E.placement u.1).cochain ≤ r := by + have hir := i.property.2 + constructor <;> omega + let j₀ : J := ⟨u.1, hu⟩ + have hj₀ : Pi.single j₀ (1 : ℂ) ∈ pathImages B n := hprev j₀ (by + change (E.placement u.1).level = (E.placement i).level + omega) hdeg + have hz : z u = y u • Matrix.vecMul (Pi.single j₀ (1 : ℂ)) (B (Q.reverse a)) := by + funext j + change y u * pathCoordinates Q (E.differential u.1 j.val) (Path.dual Q u.2.val) = _ + rw [hp] + change y u * (E.differential u.1 j.val).arrow (Q.reverse a) = _ + simp only [Pi.smul_apply, smul_eq_mul, Matrix.vecMul, dotProduct, Pi.single_apply, + ite_mul, _root_.one_mul, MulZeroClass.zero_mul, Finset.sum_ite_eq', Finset.mem_univ, ite_true] + rfl + rw [hz] + exact Submodule.smul_mem _ _ (pathImages_step B hj₀ (Q.reverse a)) + · have hz : z u = 0 := by + funext j + change y u * pathCoordinates Q (E.differential u.1 j.val) (Path.dual Q u.2.val) = 0 + rw [hp] + change y u * (E.differential u.1 j.val).vertex v = 0 + rw [hE u.1 j.val] + exact MulZeroClass.mul_zero _ + rw [hz] + exact Submodule.zero_mem _ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/InitialMinimum.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/InitialMinimum.lean new file mode 100644 index 0000000000000000000000000000000000000000..ef0b3b0c14a9afed874743872c2244d0c6fd5ea7 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/InitialMinimum.lean @@ -0,0 +1,111 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedInitialCounts +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeTranslation + +namespace OAI + +/-! The initial singleton is a minimum of the full relative harmonic height. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + +private lemma vector_eq_single_of_sum {ι : Type*} [Fintype ι] [DecidableEq ι] + (v : ι → ℝ) (o : ι) (hn : ∀ i, 0 ≤ v i) (ho : v o = 1) + (hs : ∑ i, v i = 1) : v = (Pi.single o (1:ℝ) : ι → ℝ) := by + have hnon (i : ι) : 0 ≤ v i - (Pi.single o (1:ℝ) : ι → ℝ) i := by + by_cases hi : i = o + · subst i + simp only [Pi.single_eq_same, ho, sub_self, le_refl] + · simpa only [Pi.single_eq_of_ne hi, sub_zero] using hn i + have hsum : ∑ i, (v i - (Pi.single o (1:ℝ) : ι → ℝ) i) = 0 := by + rw [Finset.sum_sub_distrib, hs] + simp + funext i + exact sub_eq_zero.mp ((Finset.sum_eq_zero_iff_of_nonneg (fun i _ => hnon i)).mp hsum i + (Finset.mem_univ i)) + +lemma initial_profile (cutoff : ℤ) (k : ℕ) : + pointedProfile M f (sourceCoset M ∅ (spherical_empty M) 1) cutoff k = + if cutoff+k = 0 then Pi.single (.inl f) 1 else 0 := by + ext i + change pointedCosetVector M f (sourceCoset M ∅ (spherical_empty M) 1) (cutoff+k) i = _ + rw [pointedCosetVector_empty, pointedMultiplicity_one] + by_cases hk : cutoff+k = 0 <;> simp [hk, Pi.single_apply] + +lemma pointedCosetVector_frame_of_relative (Y : Set S) (hf : f ∉ Y) + (P : RelativeVertex M Y 1) (k : ℤ) : + pointedCosetVector M f P.val k (.inl f) = if k = 0 then 1 else 0 := by + have hfP : (.inl f : S ⊕ Unit) ∉ Sum.inl '' P.val.val.1 := by + rintro ⟨i, hi, he⟩ + exact hf (Sum.inl.inj he ▸ P.property.1 hi) + have hz : sourceCosetRepresentative M P.val ∈ artinParabolic M Y := by + have h := P.property.2 (sourceCosetRepresentative_mem M P.val) + simpa only [rightCoset, Set.mem_ofPred_eq, inv_one, _root_.mul_one] using h + change pointedHarmonicAt M f P.val.val.1 _ k (.inl f) = _ + rw [pointedHarmonicAt_outside M f _ _ k _ hfP] + exact pointedMultiplicity_frame M Y f hf _ hz k + +lemma initial_block_le (U : Set (S ⊕ Unit)) (cutoff : ℤ) (Y : Set S) (hf : f ∉ Y) + (P : RelativeVertex M Y 1) (k : ℕ) : + relativeBlock M f U cutoff (sourceCoset M ∅ (spherical_empty M) 1) k ≤ + relativeBlock M f U cutoff P.val k := by + let P₀ := sourceCoset M ∅ (spherical_empty M) 1 + change relativeBlock M f U cutoff P₀ k ≤ relativeBlock M f U cutoff P.val k + have hmask₀ : relativeSignMask M f U cutoff P₀ k = 0 := by + funext i + simp only [relativeSignMask, P₀, sourceCoset, Set.image_empty, Set.notMem_empty, + ↓reduceIte, Pi.zero_apply] + by_cases hk : cutoff+k = 0 + · have hv₀ : pointedProfile M f P₀ cutoff k = Pi.single (.inl f) 1 := by + simpa only [hk, ite_true] using initial_profile M f cutoff k + have hs₀ : pointedCosetSum M f P₀ (cutoff+k) = 1 := by + change (∑ i, pointedProfile M f P₀ cutoff k i) = 1 + rw [hv₀] + simp + have hframe : pointedProfile M f P.val cutoff k (.inl f) = 1 := by + change pointedCosetVector M f P.val (cutoff+k) (.inl f) = 1 + rw [pointedCosetVector_frame_of_relative M f Y hf P, hk, ite_eq_left rfl] + have hs : 1 ≤ pointedCosetSum M f P.val (cutoff+k) := by + rw [←hframe] + exact pointedCosetVector_le_sum M f P.val (cutoff+k) (.inl f) + rcases lt_or_eq_of_le hs with hlt | heq + · have hh : pointedCosetSum M f P₀ (cutoff+k) < pointedCosetSum M f P.val (cutoff+k) := by + rw [hs₀] + exact hlt + exact (Prod.Lex.lt_iff.mpr (Or.inl hh)).le + · have hv : pointedProfile M f P.val cutoff k = Pi.single (.inl f) 1 := + vector_eq_single_of_sum _ _ (pointedCosetVector_nonneg M f P.val (cutoff+k)) hframe heq.symm + have hm : relativeSignMask M f U cutoff P.val k = 0 := by + funext i + unfold relativeSignMask + by_cases hi : ofLex i ∈ Sum.inl '' P.val.val.1 + · have hne : ofLex i ≠ (.inl f : S ⊕ Unit) := by + intro h + obtain ⟨j, hj, hjf⟩ := hi + exact hf (Sum.inl.inj (hjf.trans h) ▸ P.property.1 hj) + simp only [hi, ↓reduceIte, relativeSign, hv, Pi.single_eq_of_ne hne, + ↓reduceIte, Pi.zero_apply] + · simp only [hi, ↓reduceIte, Pi.zero_apply] + unfold relativeBlock + rw [hs₀, ←heq, hv₀, hv, hmask₀, hm] + · have hz : pointedProfile M f P₀ cutoff k = 0 := by + simpa only [hk, ite_false] using initial_profile M f cutoff k + rw [relativeBlock_of_vector_zero M f U cutoff P₀ k hz] + exact relativeZeroBlock_le M f U cutoff _ (Or.inr ⟨P.val,k,rfl⟩) + +/-- The minimum-height assertion in the proof of the initial stabilizer, +including the full vector and full sign mask. -/ +theorem initial_height_minimum (U : Set (S ⊕ Unit)) (cutoff : ℤ) (Y : Set S) (hf : f ∉ Y) + (P : RelativeVertex M Y 1) : + relativeHeight M f U cutoff (sourceCoset M ∅ (spherical_empty M) 1) ≤ + relativeHeight M f U cutoff P.val := by + apply Finsupp.toColex_monotone + intro k + have hb := initial_block_le M f U cutoff Y hf P k + change relativeBlockRank M f U cutoff _ ≤ relativeBlockRank M f U cutoff _ + rcases lt_or_eq_of_le hb with hb | hb + · exact (relativeBlockRank_strictMono M f U cutoff (Or.inr ⟨_,k,rfl⟩) hb).le + · rw [hb] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/LayerErasure.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/LayerErasure.lean new file mode 100644 index 0000000000000000000000000000000000000000..60b80fc717564444fed9d6fb70d923f3cdb2a593 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/LayerErasure.lean @@ -0,0 +1,61 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.IncomingSpanning + +namespace OAI + +/-! Nilpotent coefficient paths remove one layer on a shorter interval. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) [Fintype V] [Fintype A] + {I : Type} [Fintype I] + +theorem one_layer_erasure (U : Set V) (N : ℕ) + (hwords : ∀ w : List A, w.length = N → + (w.map (FreeAlgebra.ι ℂ)).prod ∈ TwoSidedIdeal.span (meshRelations Q U)) + (E : BasedComplex Q (K := ℂ) I) (hE : E.IsMinimal Q) + (l r q : ℤ) + (hcolors : ∀ i, l ≤ (E.placement i).cochain → (E.placement i).cochain ≤ r → + (E.placement i).color ∈ U) + (hex : ∀ α ∈ U, ∀ c, l ≤ c → c ≤ r → ∀ d, + ScalarExactAt Q (E.testComplex Q α) α d c) + (hhigher : ∀ i, l ≤ (E.placement i).cochain → (E.placement i).cochain ≤ r → + q < (E.placement i).level → False) : + ∀ i, (E.placement i).level = q → l+N ≤ (E.placement i).cochain → + (E.placement i).cochain ≤ r → False := by + let J := {i | l ≤ (E.placement i).cochain ∧ (E.placement i).cochain ≤ r} + let F := cochainInterval Q E l r + let B := arrowMatrix Q F + have hF : F.IsMinimal Q := restrict_minimal Q E hE _ _ + have hU : ∀ i, (F.placement i).color ∈ U := fun i => hcolors i i.property.1 i.property.2 + have hnil : ∀ w : List A, w.length = N → (w.map B).prod = 0 := by + intro w hw + exact mesh_word_evaluate Q B (arrowMatrix_outside Q F U hU) + (arrowMatrix_noncomposable Q F) (fun v _ => arrowMatrix_mesh Q F hF v) w (hwords w hw) + have hbound : ∀ n : ℕ, ∀ i : J, (E.placement i).level = q → + l+n ≤ (E.placement i).cochain → Pi.single i (1 : ℂ) ∈ pathImages B n := by + intro n + induction n with + | zero => exact fun i _ _ => mem_pathImages_zero B _ + | succ n ih => + intro i hi hp + apply incoming_spanning_step Q E hE l r i (by omega) + · exact hex _ (hU i) _ i.property.1 i.property.2 _ + · intro j hj hlev + apply hhigher j + · omega + · have := i.property.2; omega + · rwa [← hi] + · intro j hj hpj + apply ih j (hj.trans hi) + omega + intro i hi hp hr + let j : J := ⟨i, by constructor <;> omega⟩ + have hj := hbound N j hi hp + rw [pathImages_eq_bot B N hnil] at hj + have hz : (Pi.single j (1 : ℂ) : J → ℂ) = 0 := hj + have hc := congrFun hz j + exact one_ne_zero (by simpa only [Pi.single_eq_same, Pi.zero_apply] using hc) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/Main.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/Main.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e49808a1a06b4b94914193803d3ac8b82d0ec6c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/Main.lean @@ -0,0 +1,11 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ConditionalMain +import OAI.Topology.ArtinGroups.ParabolicIntersections.UnconditionalMain +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsUnconditional + +/-! +# All main results of paper 082-03 + +This entry point retains the conditional development and exports +unconditional parabolic intersections, arbitrary intersections, parabolic +closure, and the complete irreducible non-clique dynamics corollary. +-/ diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MainIntersection.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MainIntersection.lean new file mode 100644 index 0000000000000000000000000000000000000000..974ee68a1b80765f61fdb81896144345054ef30b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MainIntersection.lean @@ -0,0 +1,150 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.SphericalReduction +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeInvisibleFactor +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeInitialStabilizer +import OAI.Topology.ArtinGroups.ParabolicIntersections.RankReduction + +namespace OAI + +/-! +# The main intersection theorems of paper 082-03 + +The hypotheses are exactly the published inputs documented in +`MeshNilpotence`, `FoldingGcdInput`, `AcyclicTwistInput`, and +`RelativeInitialStabilizer`. All relative-height, positive-height, +stabilizer-containment and rank-induction arguments are proved in this +local development; none of those new assertions is a hypothesis here. +-/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- Only the published general mesh-algebra, admissible-folding and +acyclic-evaluation facts; see the individual definitions for exact sources. -/ +structure PublishedSphericalInputs : Prop where + mesh : ∀ Y : Set S, IsSpherical M Y → + MeshNilpotent (fusionQuiver (fusionLabelSize M) (coxeterFusionEdge M) + (coxeterFusionEdge_symm M)) (fusionColorRegion (fusionLabelSize M) (Sum.inl '' Y)) + folding : ∀ (Y : Set S) (hY : IsSpherical M Y), PublishedFoldingGcd M Y hY + acyclic : PublishedAcyclicTwist (fusionQuiver (fusionLabelSize M) + (coxeterFusionEdge M) (coxeterFusionEdge_symm M)) + +/-- Theorem 8.2 on the actual pointed family with an unoperated frame. -/ +theorem pointed_relative_stabilizers (hPub : PublishedSphericalInputs M) + (f : S) (Y : Set S) (hf : f ∉ Y) (x : Artin M) + (hx : x ∈ artinParabolic M {f}ᶜ) : + ∃ (R : Set S) (c : Artin M), R ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + relativeStabilizer M (pointedInitial M f) Y x = conjugate c⁻¹ (artinParabolic M R) := by + apply relativeStabilizers_of_reductions_on M (pointedInitial M f) {f}ᶜ _ Y + (by intro s hs hsf; exact hf (hsf ▸ hs)) x hx + intro D hD z hz + have hfD : f ∉ D := fun h => hD h rfl + by_cases hDs : IsSpherical M D + · exact spherical_reduction M f D hDs hfD (hPub.folding D hDs) + (hPub.mesh D hDs) hPub.acyclic z hz + · exact relative_nonspherical_reduction M f hfD hz hDs + +section Relative +local instance : LinearOrder (S⊕Unit) := Sum.Lex.linearOrder +variable (X : Set S) +local notation "N" => relativeMatrix M X + +omit [Fintype S] [LinearOrder S] in +private lemma relative_comap_standard (hEmb : VanDerLekRelativeEmbedding M X) (Y : Set S) : + (artinParabolic N (Sum.inl '' Y)).comap (relativeArtinHom M X) = artinParabolic M Y := by + rw [← relativeArtinHom_parabolic] + exact Subgroup.comap_map_eq_self_of_injective hEmb.injective _ + +omit [Fintype S] [LinearOrder S] in +private lemma relative_comap_conjugate (c : Artin M) (P : Subgroup (Artin N)) : + (conjugate (relativeArtinHom M X c) P).comap (relativeArtinHom M X) = + conjugate c (P.comap (relativeArtinHom M X)) := by + ext a + simp only [Subgroup.mem_comap,mem_conjugate,map_mul,map_inv] + +/-- The stronger inside-parabolic form, with its conjugator inside the +acting parabolic. This is the result used by the arbitrary-family theorem. -/ +theorem inside_intersection_at + (hEmb : VanDerLekRelativeEmbedding M X) (hPub : PublishedSphericalInputs N) + (Y : Set S) (g : Artin M) : + ∃ (R : Set S) (c : Artin M), R ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + artinParabolic M Y ⊓ conjugate g (artinParabolic M X) = + conjugate c (artinParabolic M R) := by + let F := relativeArtinHom M X + have hg : F g ∈ artinParabolic N {(.inr () : S⊕Unit)}ᶜ := by + apply standard_mono N (X := Set.range (Sum.inl : S → S⊕Unit)) + (by rintro a ⟨s,rfl⟩; simp) + rw [← Set.image_univ, ← relativeArtinHom_parabolic] + exact ⟨g,by rw [standard_univ]; trivial,rfl⟩ + obtain ⟨R,c,hR,hc,he⟩ := pointed_relative_stabilizers N hPub (.inr ()) (Sum.inl '' Y) + (by simp) (F g) hg + rw [← relativeArtinHom_parabolic M X Y] at hc + obtain ⟨b,hb,hbc⟩ := hc + let D : Set S := Sum.inl ⁻¹' R + have hD : D ⊆ Y := by + intro s hs + obtain ⟨t,ht,hte⟩ := hR hs + exact Sum.inl.inj hte ▸ ht + have hRD : R = Sum.inl '' D := by + ext a + constructor + · intro ha + obtain ⟨s,hs,rfl⟩ := hR ha + exact ⟨s,ha,rfl⟩ + · rintro ⟨s,hs,rfl⟩ + exact hs + have hleft : (relativeStabilizer N (pointedInitial N (.inr ())) (Sum.inl '' Y) (F g)).comap F = + relativeStabilizer M (relativeInitial M X) Y g := by + unfold relativeStabilizer + rw [Subgroup.comap_inf,relative_comap_standard M X hEmb Y] + rfl + have he' := congrArg (Subgroup.comap F) he + rw [hleft,hRD,←hbc,←map_inv,relative_comap_conjugate, + relative_comap_standard M X hEmb D] at he' + refine ⟨D,b⁻¹,hD,(artinParabolic M Y).inv_mem hb,?_⟩ + have hinit := relative_initial_stabilizer M X hEmb + have hconj := conjugate_stabilizer M (relativeInitial M X) g 1 + simp only [one_smul,_root_.mul_one,hinit] at hconj + simpa only [relativeStabilizer,←hconj] using he' +end Relative + +local instance : LinearOrder (S⊕Unit) := Sum.Lex.linearOrder + +/-- The entire inside-parabolic statement, conditional solely on published inputs. -/ +theorem inside_intersection + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hPub : ∀ X : Set S, PublishedSphericalInputs (relativeMatrix M X)) : + InsideIntersectionProperty M := fun X Y g => inside_intersection_at M X (hEmb X) (hPub X) Y g + +/-- Theorem 1.1, including arbitrary nonspherical types and infinite labels. -/ +theorem parabolic_intersections + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hPub : ∀ X : Set S, PublishedSphericalInputs (relativeMatrix M X)) + (X Y : Set S) (g h : Artin M) : + ∃ (Z : Set S) (k : Artin M), + conjugate g (artinParabolic M X) ⊓ conjugate h (artinParabolic M Y) = + conjugate k (artinParabolic M Z) := + pairwise_of_inside M (inside_intersection M hEmb hPub) X Y g h + +/-- Corollary 1.2: arbitrary intersections and the sharp rank subfamily bound. -/ +theorem arbitrary_parabolic_intersections + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hPub : ∀ X : Set S, PublishedSphericalInputs (relativeMatrix M X)) + (F : Set (Subgroup (Artin M))) (hF : ∀ P ∈ F, IsParabolic M P) : + (∃ F₀ : Finset (Subgroup (Artin M)), + (↑F₀ : Set (Subgroup (Artin M))) ⊆ F ∧ F₀.card ≤ Nat.card S ∧ + sInf F = sInf (↑F₀ : Set (Subgroup (Artin M)))) ∧ IsParabolic M (sInf F) := + arbitrary_intersections_of_inside M (inside_intersection M hEmb hPub) F hF + +/-- Corollary 1.2: every subset has a unique smallest parabolic closure. -/ +theorem parabolic_closure + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hPub : ∀ X : Set S, PublishedSphericalInputs (relativeMatrix M X)) + (E : Set (Artin M)) : + ∃! P : Subgroup (Artin M), IsParabolic M P ∧ E ⊆ P ∧ + ∀ Q : Subgroup (Artin M), IsParabolic M Q → E ⊆ Q → P ≤ Q := + parabolic_closure_of_inside M (inside_intersection M hEmb hPub) E + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshAdjacent.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshAdjacent.lean new file mode 100644 index 0000000000000000000000000000000000000000..5e726580eae30c97502b17f96853636c39202f50 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshAdjacent.lean @@ -0,0 +1,88 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshContraction + +namespace OAI + +/-! Adjacent contraction identities on the actual finite path spaces. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +lemma meshContraction_mul (μ : V → ℝ) (n : ℕ) (v : V) {R : Type} [Fintype R] + (B : Matrix (MeshPaths G (n+2) v) R ℂ) (p : MeshPaths G n v) (r : R) : + (meshContractionMatrix G μ n v * B) p r = + ∑ u : {u : V // G.Adj u v}, + (Real.sqrt (μ u/μ v) : ℂ) * B (meshInsertBacktrack G u p) r := by + change (∑ q, (∑ u : {u : V // G.Adj u v}, + if q=meshInsertBacktrack G u p then (Real.sqrt (μ u/μ v) : ℂ) else 0)*B q r)=_ + simp only [Finset.sum_mul,ite_mul,zero_mul] + rw [Finset.sum_comm] + simp + +lemma meshContraction_head (μ : V → ℝ) (n : ℕ) (v : V) + (p : MeshPaths G n v) (u : {u : V // G.Adj u v}) + (q : MeshPaths G (n+1) u.val) : + meshContractionMatrix G μ n v p ⟨u,q⟩ = + if q=⟨⟨v,u.property.symm⟩,p⟩ then (Real.sqrt (μ u/μ v) : ℂ) else 0 := by + change (∑ w : {w : V // G.Adj w v}, + if (⟨u,q⟩ : MeshPaths G (n+2) v)=meshInsertBacktrack G w p + then (Real.sqrt (μ w/μ v) : ℂ) else 0)=_ + rw [Finset.sum_eq_single u] + · by_cases hq : q=⟨⟨v,u.property.symm⟩,p⟩ + · subst q + simp only [meshInsertBacktrack,ite_true] + exact (ite_eq_left rfl).symm + · have hne : (⟨u,q⟩ : MeshPaths G (n+2) v)≠meshInsertBacktrack G u p := by + intro h + exact hq (eq_of_heq (Sigma.mk.inj_iff.mp h).2) + simp only [hne,hq,ite_false] + · intro w _ hwu + have hne : (⟨u,q⟩ : MeshPaths G (n+2) v)≠meshInsertBacktrack G w p := by + intro h + exact hwu (congrArg Sigma.fst h).symm + simp [hne] + · simp + +lemma meshContraction_return (μ : V → ℝ) (n : ℕ) (v : V) + (u : {u : V // G.Adj u v}) (p : MeshPaths G (n+1) v) + (r : MeshPaths G n u.val) : + meshContractionMatrix G μ n u.val r ⟨⟨v,u.property.symm⟩,p⟩ = + if p=⟨u,r⟩ then (Real.sqrt (μ v/μ u) : ℂ) else 0 := by + simpa only using meshContraction_head G μ n u.val r ⟨v,u.property.symm⟩ p + +omit [Fintype V] in +lemma mesh_sqrt_reciprocal (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (u v : V) : + (Real.sqrt (μ u/μ v) : ℂ)*(Real.sqrt (μ v/μ u) : ℂ)=1 := by + rw [←Complex.ofReal_mul,←Real.sqrt_mul (div_nonneg (hμ u).le (hμ v).le)] + have hratio : μ u/μ v*(μ v/μ u)=1 := by + field_simp [ne_of_gt (hμ u),ne_of_gt (hμ v)] + rw [hratio,Real.sqrt_one,Complex.ofReal_one] + +/-- Contracting after insertion at the preceding position is the identity. +The two weights are reciprocal positive square roots. -/ +theorem meshContraction_adjacent (μ : V → ℝ) (hμ : ∀ v, 0<μ v) + (n : ℕ) (v : V) : + meshContractionMatrix G μ (n+1) v * + meshExtendMatrix G (fun u => (meshContractionMatrix G μ n u).conjTranspose) v = + (1 : Matrix (MeshPaths G (n+1) v) (MeshPaths G (n+1) v) ℂ) := by + ext p r + rw [meshContraction_mul] + rw [Matrix.one_apply] + obtain ⟨u,r⟩ := r + let f (w : {w : V // G.Adj w v}) : MeshPaths G (n+2) w.val := + ⟨⟨v,w.property.symm⟩,p⟩ + change (∑ w : {w : V // G.Adj w v}, (Real.sqrt (μ w/μ v) : ℂ)* + Matrix.blockDiagonal' (fun z : {z : V // G.Adj z v} => + (meshContractionMatrix G μ n z.val).conjTranspose) + ⟨w,f w⟩ ⟨u,r⟩)=_ + rw [Finset.sum_eq_single u] + · rw [Matrix.blockDiagonal'_apply_eq,Matrix.conjTranspose_apply,meshContraction_return] + split_ifs with h + · rw [Complex.star_def,Complex.conj_ofReal,mesh_sqrt_reciprocal μ hμ] + · simp + · intro w _ hwu + rw [Matrix.blockDiagonal'_apply_ne _ _ _ hwu,mul_zero] + · simp + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshContraction.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshContraction.lean new file mode 100644 index 0000000000000000000000000000000000000000..74d1652cb04798eb476d43a80254b6c81f5c3393 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshContraction.lean @@ -0,0 +1,74 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshPathSpaces +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshInsertionMatrix + +namespace OAI + +/-! The path-space loop identity and extension functor. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +/-- Inserting and then contracting a final backtrack multiplies by the +Perron eigenvalue. This is proved for the actual path matrices. -/ +theorem meshContraction_loop (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (n : ℕ) (v : V) : + meshContractionMatrix G μ n v * (meshContractionMatrix G μ n v).conjTranspose = + (δ : ℂ) • (1 : Matrix (MeshPaths G n v) (MeshPaths G n v) ℂ) := by + have h := insertion_matrix_mul_conjTranspose + (fun up : {u : V // G.Adj u v} × MeshPaths G n v => meshInsertBacktrack G up.1 up.2) + (meshInsertBacktrack_injective G) (fun u => (Real.sqrt (μ u/μ v) : ℂ)) + have hweight : (∑ u : {u : V // G.Adj u v}, + (Real.sqrt (μ u/μ v) : ℂ)*star (Real.sqrt (μ u/μ v) : ℂ))=(δ : ℂ) := by + have hs : ∀ u : {u : V // G.Adj u v}, + (Real.sqrt (μ u/μ v) : ℂ)*star (Real.sqrt (μ u/μ v) : ℂ)=(μ u/μ v : ℝ) := by + intro u + rw [Complex.star_def,Complex.conj_ofReal,←Complex.ofReal_mul, + Real.mul_self_sqrt (div_nonneg (hμ u).le (hμ v).le)] + simp only [hs,←Complex.ofReal_sum] + congr 1 + rw [←Finset.sum_div,heigen,mul_div_cancel_right₀ _ (ne_of_gt (hμ v))] + rw [hweight] at h + exact h + +omit [Fintype V] in +lemma meshExtend_one (n : ℕ) (v : V) : + meshExtendMatrix G (fun u => (1 : Matrix (MeshPaths G n u) (MeshPaths G n u) ℂ)) v=1 := by + unfold meshExtendMatrix + change Matrix.blockDiagonal' + (1 : ∀ u : {u : V // G.Adj u v}, + Matrix (MeshPaths G n u.val) (MeshPaths G n u.val) ℂ) = _ + rw [Matrix.blockDiagonal'_one] + ext p q + simp only [Matrix.one_apply] + change (if p=q then (1 : ℂ) else 0) = + @ite ℂ (p=q) (Classical.propDecidable _) 1 0 + split_ifs <;> rfl + +lemma meshExtend_mul {k m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G k v) (MeshPaths G m v) ℂ) + (B : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) : + meshExtendMatrix G (fun u => A u*B u) v=meshExtendMatrix G A v*meshExtendMatrix G B v := + Matrix.blockDiagonal'_mul _ _ + +omit [Fintype V] in +lemma meshExtend_adjoint {m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) : + (meshExtendMatrix G A v).conjTranspose=meshExtendMatrix G (fun u => (A u).conjTranspose) v := + Matrix.blockDiagonal'_conjTranspose _ + +omit [Fintype V] in +lemma meshExtend_sub {m n : ℕ} + (A B : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) : + meshExtendMatrix G (fun u => A u-B u) v=meshExtendMatrix G A v-meshExtendMatrix G B v := + Matrix.blockDiagonal'_sub _ _ + +omit [Fintype V] in +lemma meshExtend_smul {m n : ℕ} (a : ℂ) + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) : + meshExtendMatrix G (fun u => a • A u) v=a • meshExtendMatrix G A v := + Matrix.blockDiagonal'_smul a (fun u : {u : V // G.Adj u v} => A u.val) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshGraphNilpotence.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshGraphNilpotence.lean new file mode 100644 index 0000000000000000000000000000000000000000..32d9ab1b99586a7b7b7d07b3445b583b2a15b119 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshGraphNilpotence.lean @@ -0,0 +1,124 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshGraphWeights +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshNormalization + +namespace OAI + +/-! Finite mesh path bounds, including disconnected positive Cartan graphs. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +open Matrix +variable {V R : Type} [Fintype V] (G : SimpleGraph V) [Ring R] [Algebra ℂ R] + +theorem connected_mesh_paths_vanish (hG : G.Connected) + (hcartan : ((2 : ℝ) • (1 : Matrix V V ℝ)-G.adjMatrix ℝ).PosDef) + (B : ∀ u v, G.Adj u v → R) + (hmesh : ∀ v, (∑ u : {u : V // G.Adj u v}, + B v u.val u.property.symm * B u.val v u.property)=0) : + ∃ N : ℕ, 0 exact hN + | succ k ih => + intro v p + change meshPathEvaluate G B (N+k) p.1.val p.2 * B p.1.val v p.1.property=0 + rw [ih (by omega),zero_mul] + +omit [Fintype V] in +def meshPathInComponent (C : G.ConnectedComponent) : + (n : ℕ) → (v : C) → MeshPaths G n v.val → MeshPaths C.toSimpleGraph n v + | 0, _, _ => PUnit.unit + | n+1, v, p => + let u : C := ⟨p.1.val,C.mem_supp_of_adj_mem_supp v.property p.1.property.symm⟩ + ⟨⟨u,p.1.property⟩,meshPathInComponent C n u p.2⟩ + +omit [Fintype V] [Algebra ℂ R] in +lemma meshPathInComponent_evaluate (C : G.ConnectedComponent) + (B : ∀ u v, G.Adj u v → R) : ∀ n v p, + meshPathEvaluate C.toSimpleGraph (fun u v h => B u.val v.val h) n v + (meshPathInComponent G C n v p)=meshPathEvaluate G B n v.val p := by + intro n + induction n with + | zero => intro v p; rfl + | succ n ih => + intro v p + dsimp only [meshPathInComponent,meshPathEvaluate] + rw [ih] + +omit [Fintype V] in +lemma mesh_component_cartan (C : G.ConnectedComponent) + (hcartan : ((2 : ℝ) • (1 : Matrix V V ℝ)-G.adjMatrix ℝ).PosDef) : + let _ : DecidableEq C := Classical.decEq C + ((2 : ℝ) • (1 : Matrix C C ℝ)-C.toSimpleGraph.adjMatrix ℝ).PosDef := by + let : DecidableEq C := Classical.decEq C + have h := hcartan.submatrix (e := ((↑) : C → V)) Subtype.val_injective + convert h using 1 + ext u v + by_cases huv : u=v + · subst v + simp [Matrix.submatrix_apply] + · have hval : u.val≠v.val := fun hh => huv (Subtype.ext hh) + simp [Matrix.submatrix_apply,SimpleGraph.adjMatrix_apply, + SimpleGraph.ConnectedComponent.toSimpleGraph,SimpleGraph.induce,huv,hval] + rfl + +omit [Fintype V] in +def meshComponentNeighborEquiv (C : G.ConnectedComponent) (v : C) : + {u : C // C.toSimpleGraph.Adj u v} ≃ {u : V // G.Adj u v.val} where + toFun u := ⟨u.val.val,u.property⟩ + invFun u := ⟨⟨u.val,C.mem_supp_of_adj_mem_supp v.property u.property.symm⟩,u.property⟩ + left_inv u := by apply Subtype.ext; apply Subtype.ext; rfl + right_inv u := by apply Subtype.ext; rfl + +/-- Every finite graph with positive definite Cartan form has a finite +all-plus mesh path bound, whether or not the graph is connected. -/ +theorem positive_cartan_mesh_paths_vanish + (hcartan : ((2 : ℝ) • (1 : Matrix V V ℝ)-G.adjMatrix ℝ).PosDef) + (B : ∀ u v, G.Adj u v → R) + (hmesh : ∀ v, (∑ u : {u : V // G.Adj u v}, + B v u.val u.property.symm * B u.val v u.property)=0) : + ∃ N : ℕ, 0 B u.val v.val h) N v p=0 := by + apply connected_mesh_paths_vanish C.toSimpleGraph C.connected_toSimpleGraph + (mesh_component_cartan G C hcartan) + intro v + calc + _ = ∑ u : {u : V // G.Adj u v.val}, B v.val u.val u.property.symm * + B u.val v.val u.property := by + apply Fintype.sum_equiv (meshComponentNeighborEquiv G C v) + intro u + rfl + _ = 0 := hmesh v.val + let n : G.ConnectedComponent → ℕ := fun C => (hC C).choose + have hn (C : G.ConnectedComponent) : ∀ v p, + meshPathEvaluate C.toSimpleGraph (fun u v h => B u.val v.val h) (n C) v p=0 := + (hC C).choose_spec.2 + let : Fintype G.ConnectedComponent := Fintype.ofFinite _ + let N := Finset.univ.sup n+1 + refine ⟨N,by dsimp [N]; omega,?_⟩ + intro v p + let C := G.connectedComponentMk v + have hv : v∈C := by exact (C.mem_supp_iff v).mpr rfl + have hbound : n C≤N := by + have hle := Finset.le_sup (f := n) (Finset.mem_univ C) + dsimp [N] + omega + have hz := meshPathEvaluate_longer C.toSimpleGraph (fun u v h => B u.val v.val h) + (n C) (hn C) N hbound ⟨v,hv⟩ (meshPathInComponent G C N ⟨v,hv⟩ p) + rwa [meshPathInComponent_evaluate] at hz + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshGraphWeights.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshGraphWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..60db6ea8cf07e18e08747c5fb150e2dc39e96b60 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshGraphWeights.lean @@ -0,0 +1,77 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshPerron + +namespace OAI + +/-! Positive mesh weights for a connected graph with positive Cartan form. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +open Matrix +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +lemma mesh_adjacency_sum (y : V → ℝ) (v : V) : + (G.adjMatrix ℝ *ᵥ y) v=∑ u : {u : V // G.Adj u v}, y u := by + rw [G.adjMatrix_mulVec_apply] + exact Finset.sum_subtype (G.neighborFinset v) (by intro u; simp [G.adj_comm]) y + +lemma mesh_connected_eigenvector_pos (hG : G.Connected) (d : ℝ) + (y : V → ℝ) (hy : y≠0) (hnonneg : ∀ v, 0≤y v) + (heigen : G.adjMatrix ℝ *ᵥ y=d • y) : ∀ v, 0 hnonneg w.val)).mp hs + ⟨v,hadj.symm⟩ (Finset.mem_univ _) + have hzero_path {u v : V} (p : G.Walk u v) : y u=0 → y v=0 := by + induction p with + | nil => exact id + | @cons a b c hab p ih => exact fun ha => ih (hzero_adj hab ha) + intro u + by_contra hpos + have hu : y u=0 := le_antisymm (le_of_not_gt hpos) (hnonneg u) + apply hy + funext v + exact hzero_path (hG.preconnected u v).some hu + +/-- Positive definiteness of `2I-B` gives exactly the spectral interval +needed by the essential-path argument, on each nontrivial component. -/ +theorem mesh_graph_positive_weights (hG : G.Connected) + (hedge : ∃ u v, G.Adj u v) + (hcartan : ((2 : ℝ) • (1 : Matrix V V ℝ)-G.adjMatrix ℝ).PosDef) : + ∃ (μ : V → ℝ) (d : ℝ), (∀ v, 0<μ v) ∧ 0 norm_num + obtain ⟨d,μ,hne,hnonneg,heigen⟩ := mesh_nonnegative_top_eigenvector (G.adjMatrix ℝ) hsym hentries + have hμ := mesh_connected_eigenvector_pos G hG d μ hne hnonneg heigen + have heq (v : V) : (∑ u : {u : V // G.Adj u v}, μ u)=d*μ v := by + have h := congrFun heigen v + simpa only [mesh_adjacency_sum,Pi.smul_apply,smul_eq_mul] using h + obtain ⟨u,v,huv⟩ := hedge + have hsum : 0<(∑ w : {w : V // G.Adj w v}, μ w) := by + exact Finset.sum_pos' (fun w _ => (hμ w).le) + ⟨⟨u,huv⟩,Finset.mem_univ _,hμ u⟩ + have hd : 0.1 + have hform := hcartan.dotProduct_mulVec_pos hne + simp only [star_trivial,sub_mulVec,smul_mulVec,one_mulVec,heigen, + dotProduct_sub,dotProduct_smul,smul_eq_mul] at hform + have hsq : 0≤μ ⬝ᵥ μ := Finset.sum_nonneg (fun i _ => mul_self_nonneg (μ i)) + have hd2 : d<2 := by + by_contra h + have hm : d*(μ ⬝ᵥ μ)≥2*(μ ⬝ᵥ μ) := mul_le_mul_of_nonneg_right (le_of_not_gt h) hsq + linarith + exact ⟨μ,d,hμ,hd,hd2,heq⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshInsertionMatrix.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshInsertionMatrix.lean new file mode 100644 index 0000000000000000000000000000000000000000..55bdca7b0b1a63362ddecf57a1f7e695602025de --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshInsertionMatrix.lean @@ -0,0 +1,46 @@ +import Mathlib + +namespace OAI + +/-! Orthogonality of weighted path insertions. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {I P Q : Type} [Fintype I] [Fintype P] [Fintype Q] + +omit [Fintype P] in +/-- Rows obtained by inserting disjoint labeled detours are orthogonal. -/ +theorem insertion_matrix_mul_conjTranspose (f : I × P → Q) + (hf : Function.Injective f) (a : I → ℂ) : + let C : Matrix P Q ℂ := fun p q => ∑ i, if q=f (i,p) then a i else 0 + C*C.conjTranspose = (∑ i, a i*star (a i)) • (1 : Matrix P P ℂ) := by + ext p r + change (∑ q : Q, (∑ i : I, if q=f (i,p) then a i else 0) * + star (∑ j : I, if q=f (j,r) then a j else 0)) = + (∑ i : I, a i*star (a i)) * (if p=r then 1 else 0) + simp only [star_sum,apply_ite star,star_zero,Finset.sum_mul,Finset.mul_sum] + rw [Finset.sum_comm] + trans ∑ i : I, ∑ j : I, if f (i,r)=f (j,p) then a j*star (a i) else 0 + · apply Finset.sum_congr rfl + intro i _ + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro j _ + simp only [ite_mul,zero_mul,mul_ite,mul_zero] + simp + · have he : ∀ i j : I, f (i,r)=f (j,p) ↔ i=j ∧ p=r := by + intro i j + constructor + · intro h + obtain ⟨hi,hr⟩ := Prod.mk.inj (hf h) + exact ⟨hi,hr.symm⟩ + · rintro ⟨rfl,rfl⟩ + rfl + simp only [he] + by_cases hpr : p=r + · subst r + simp + · simp [hpr] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshMain.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshMain.lean new file mode 100644 index 0000000000000000000000000000000000000000..fbcb07b6741285a7e785c4b828f733ed3835482a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshMain.lean @@ -0,0 +1,50 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ReducedInputsMain +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeEmbedding + +namespace OAI + +/-! Main results after discharging standard embeddings, acyclic twists, +and folding. Only mesh nilpotence and the dynamical criteria remain. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +local instance : LinearOrder (S⊕Unit) := Sum.Lex.linearOrder + +/-- Paper 082-03, Theorem 1.1, with all inputs except mesh nilpotence discharged. -/ +theorem parabolic_intersections_of_mesh + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (X Y : Set S) (g h : Artin M) : + ∃ (Z : Set S) (k : Artin M), + conjugate g (artinParabolic M X) ⊓ conjugate h (artinParabolic M Y) = + conjugate k (artinParabolic M Z) := + mesh_parabolic_intersections M (relative_embedding_input M) hMesh X Y g h + +/-- Paper 082-03, Corollary 1.2, arbitrary intersections. -/ +theorem arbitrary_intersections_of_mesh + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (F : Set (Subgroup (Artin M))) (hF : ∀ P ∈ F, IsParabolic M P) : + (∃ F₀ : Finset (Subgroup (Artin M)), + (↑F₀ : Set (Subgroup (Artin M))) ⊆ F ∧ F₀.card ≤ Nat.card S ∧ + sInf F = sInf (↑F₀ : Set (Subgroup (Artin M)))) ∧ IsParabolic M (sInf F) := + mesh_arbitrary_intersections M (relative_embedding_input M) hMesh F hF + +/-- Paper 082-03, Corollary 1.2, parabolic closure. -/ +theorem parabolic_closure_of_mesh + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (E : Set (Artin M)) : + ∃! P : Subgroup (Artin M), IsParabolic M P ∧ E ⊆ P ∧ + ∀ Q : Subgroup (Artin M), IsParabolic M Q → E ⊆ Q → P ≤ Q := + mesh_parabolic_closure M (relative_embedding_input M) hMesh E + +/-- Paper 082-03, Corollary 1.3, with only the mesh and dynamics inputs. -/ +theorem nonclique_dynamics_of_mesh + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (hVisual : PublishedVisualSplitting M) + (hIrred : IsIrreducible M) (hInf : ∃ s t : S, s ≠ t ∧ M s t=0) : + AcylindricallyHyperbolic (Artin M) ∧ + ∀ P : Subgroup (Artin M), IsParabolic M P → P ≠ ⊤ → WeaklyMalnormal P := + mesh_nonclique_dynamics M (relative_embedding_input M) hMesh hVisual hIrred hInf + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshMatrixAction.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshMatrixAction.lean new file mode 100644 index 0000000000000000000000000000000000000000..90ee091942dce8d7981d6a1e8474fbc8dbf7b3be --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshMatrixAction.lean @@ -0,0 +1,80 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshPathSpaces + +namespace OAI + +/-! Evaluating complex path matrices in an arbitrary complex module. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {I J K R : Type} [Fintype I] [Fintype J] [Fintype K] +variable [AddCommGroup R] [Module ℂ R] + +noncomputable def meshApply (A : Matrix I J ℂ) (f : I → R) (q : J) : R := + ∑ p, A p q • f p + +omit [Fintype J] [Fintype K] in +lemma meshApply_sub (A B : Matrix I J ℂ) (f : I → R) : + meshApply (A-B) f=meshApply A f-meshApply B f := by + funext q + simp only [meshApply,Matrix.sub_apply,sub_smul,Finset.sum_sub_distrib,Pi.sub_apply] + +omit [Fintype J] [Fintype K] in +lemma meshApply_smul (a : ℂ) (A : Matrix I J ℂ) (f : I → R) : + meshApply (a • A) f=a • meshApply A f := by + funext q + simp only [meshApply,Matrix.smul_apply,smul_eq_mul,mul_smul,Finset.smul_sum,Pi.smul_apply] + +omit [Fintype K] in +lemma meshApply_mul (A : Matrix I J ℂ) (B : Matrix J K ℂ) (f : I → R) : + meshApply (A*B) f=meshApply B (meshApply A f) := by + funext q + simp only [meshApply,Matrix.mul_apply,Finset.sum_smul,Finset.smul_sum,smul_smul] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro i _ + apply Finset.sum_congr rfl + intro p _ + rw [mul_comm] + +omit [Fintype J] [Fintype K] in +lemma meshApply_one (f : I → R) : meshApply (1 : Matrix I I ℂ) f=f := by + funext q + simp [meshApply,Matrix.one_apply] + +omit [Fintype J] [Fintype K] in +lemma meshApply_zero (f : I → R) : meshApply (0 : Matrix I J ℂ) f=0 := by + funext q + simp [meshApply] + +omit [Fintype J] [Fintype K] in +lemma meshApply_zero_right (A : Matrix I J ℂ) : meshApply A (0 : I → R)=0 := by + funext q + simp [meshApply] + +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +omit [Fintype I] [Fintype J] [Fintype K] in +/-- Extending a prefix matrix commutes with a linear last-edge operation. -/ +lemma meshApply_extend {m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) + (f : ∀ v, MeshPaths G m v → R) (v : V) + (L : ∀ _u : {u : V // G.Adj u v}, R →ₗ[ℂ] R) : + meshApply (meshExtendMatrix G A v) + (fun p : MeshPaths G (m+1) v => L p.1 (f p.1.val p.2)) = + fun q : MeshPaths G (n+1) v => L q.1 (meshApply (A q.1.val) (f q.1.val) q.2) := by + funext q + obtain ⟨u,q⟩ := q + change (∑ p : Σ w : {w : V // G.Adj w v}, MeshPaths G m w.val, + Matrix.blockDiagonal' (fun w : {w : V // G.Adj w v} => A w.val) p ⟨u,q⟩ • + L p.1 (f p.1.val p.2))=_ + rw [Fintype.sum_sigma] + rw [Finset.sum_eq_single u] + · simp only [Matrix.blockDiagonal'_apply_eq,meshApply,map_sum,map_smul] + · intro w _ hwu + apply Finset.sum_eq_zero + intro p _ + rw [Matrix.blockDiagonal'_apply_ne _ _ _ hwu,zero_smul] + · simp + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNaturality.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..3fa6c07b1133c314c19e3f319efd96ca717971d9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNaturality.lean @@ -0,0 +1,132 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshAdjacent + +namespace OAI + +/-! A prefix operator commutes with contraction of the final backtrack. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +lemma meshContraction_insert (μ : V → ℝ) (n : ℕ) (v : V) + (p q : MeshPaths G n v) (u : {u : V // G.Adj u v}) : + meshContractionMatrix G μ n v p (meshInsertBacktrack G u q)= + if q=p then (Real.sqrt (μ u/μ v) : ℂ) else 0 := by + calc + _ = @ite ℂ ((⟨⟨v,u.property.symm⟩,q⟩ : MeshPaths G (n+1) u.val)= + ⟨⟨v,u.property.symm⟩,p⟩) (Classical.propDecidable _) + (Real.sqrt (μ u/μ v) : ℂ) 0 := + meshContraction_head G μ n v p u ⟨⟨v,u.property.symm⟩,q⟩ + _ = _ := by + have he : (⟨⟨v,u.property.symm⟩,q⟩ : MeshPaths G (n+1) u.val)= + ⟨⟨v,u.property.symm⟩,p⟩ ↔ q=p := by + constructor + · intro h + exact eq_of_heq (Sigma.mk.inj_iff.mp h).2 + · rintro rfl + rfl + simp only [he] + +lemma meshContraction_no_return (μ : V → ℝ) (n : ℕ) (v : V) + (p : MeshPaths G n v) (u : {u : V // G.Adj u v}) + (w : {w : V // G.Adj w u.val}) (q : MeshPaths G n w.val) (hw : w.val≠v) : + meshContractionMatrix G μ n v p ⟨u,⟨w,q⟩⟩=0 := by + calc + _ = @ite ℂ ((⟨w,q⟩ : MeshPaths G (n+1) u.val)=⟨⟨v,u.property.symm⟩,p⟩) + (Classical.propDecidable _) (Real.sqrt (μ u/μ v) : ℂ) 0 := + meshContraction_head G μ n v p u ⟨w,q⟩ + _ = 0 := by + apply ite_eq_right + intro he + exact hw (congrArg (fun z => (Sigma.fst z).val) he) + +omit [Fintype V] in +lemma meshExtend_twice_insert {m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) + (p : MeshPaths G m v) (q : MeshPaths G n v) + (u w : {u : V // G.Adj u v}) : + meshExtendMatrix G (meshExtendMatrix G A) v + (meshInsertBacktrack G u p) (meshInsertBacktrack G w q)= + if u=w then A v p q else 0 := by + let lp : MeshPaths G (m+1) u.val := ⟨⟨v,u.property.symm⟩,p⟩ + let rp : MeshPaths G (n+1) w.val := ⟨⟨v,w.property.symm⟩,q⟩ + change Matrix.blockDiagonal' (fun z : {z : V // G.Adj z v} => + meshExtendMatrix G A z.val) ⟨u,lp⟩ ⟨w,rp⟩=_ + by_cases h : u=w + · subst w + rw [Matrix.blockDiagonal'_apply_eq,ite_eq_left rfl] + change Matrix.blockDiagonal' (fun z : {z : V // G.Adj z u.val} => A z.val) + ⟨⟨v,u.property.symm⟩,p⟩ ⟨⟨v,u.property.symm⟩,q⟩=_ + exact Matrix.blockDiagonal'_apply_eq _ _ _ _ + · rw [Matrix.blockDiagonal'_apply_ne _ _ _ h,ite_eq_right h] + +omit [Fintype V] in +lemma meshExtend_twice_no_return {m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) + (p : MeshPaths G m v) (u w : {u : V // G.Adj u v}) + (x : {x : V // G.Adj x w.val}) (q : MeshPaths G n x.val) (hx : x.val≠v) : + meshExtendMatrix G (meshExtendMatrix G A) v + (meshInsertBacktrack G u p) ⟨w,⟨x,q⟩⟩=0 := by + let lp : MeshPaths G (m+1) u.val := ⟨⟨v,u.property.symm⟩,p⟩ + let rp : MeshPaths G (n+1) w.val := ⟨x,q⟩ + change Matrix.blockDiagonal' (fun z : {z : V // G.Adj z v} => + meshExtendMatrix G A z.val) ⟨u,lp⟩ ⟨w,rp⟩=0 + by_cases h : u=w + · subst w + rw [Matrix.blockDiagonal'_apply_eq] + change Matrix.blockDiagonal' (fun z : {z : V // G.Adj z u.val} => A z.val) + ⟨⟨v,u.property.symm⟩,p⟩ ⟨x,q⟩=0 + apply Matrix.blockDiagonal'_apply_ne + intro he + exact hx (congrArg Subtype.val he).symm + · exact Matrix.blockDiagonal'_apply_ne _ _ _ h + +/-- No property of the prefix operator is needed: the final pair is +disjoint from it, so contraction is natural for every endpoint family. -/ +theorem meshContraction_naturality (μ : V → ℝ) {m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) : + meshContractionMatrix G μ m v * meshExtendMatrix G (meshExtendMatrix G A) v = + A v * meshContractionMatrix G μ n v := by + ext p r + rw [meshContraction_mul] + obtain ⟨u,w,q⟩ := r + by_cases hw : w.val=v + · have he : w=⟨v,u.property.symm⟩ := Subtype.ext hw + subst w + change (∑ x : {x : V // G.Adj x v}, (Real.sqrt (μ x/μ v) : ℂ)* + meshExtendMatrix G (meshExtendMatrix G A) v + (meshInsertBacktrack G x p) (meshInsertBacktrack G u q))=_ + simp only [meshExtend_twice_insert,mul_ite,mul_zero] + rw [Finset.sum_ite_eq'] + change _ = ∑ t : MeshPaths G n v, + A v p t * meshContractionMatrix G μ n v t (meshInsertBacktrack G u q) + simp only [meshContraction_insert,mul_ite,mul_zero] + simp [mul_comm] + · change (∑ x : {x : V // G.Adj x v}, (Real.sqrt (μ x/μ v) : ℂ)* + meshExtendMatrix G (meshExtendMatrix G A) v + (meshInsertBacktrack G x p) ⟨u,⟨w,q⟩⟩)=_ + simp only [meshExtend_twice_no_return G A v p _ u w q hw,mul_zero,Finset.sum_const_zero] + change 0 = ∑ t : MeshPaths G n v, + A v p t * meshContractionMatrix G μ n v t ⟨u,⟨w,q⟩⟩ + simp only [meshContraction_no_return G μ n v _ u w q hw,mul_zero,Finset.sum_const_zero] + +theorem meshContraction_adjacent_right (μ : V → ℝ) (hμ : ∀ v, 0<μ v) + (n : ℕ) (v : V) : + meshExtendMatrix G (meshContractionMatrix G μ n) v * + (meshContractionMatrix G μ (n+1) v).conjTranspose=1 := by + have h := congrArg Matrix.conjTranspose (meshContraction_adjacent G μ hμ n v) + simpa only [Matrix.conjTranspose_mul,meshExtend_adjoint, + Matrix.conjTranspose_conjTranspose,Matrix.conjTranspose_one] using h + +theorem meshContraction_naturality_adjoint (μ : V → ℝ) {m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) : + meshExtendMatrix G (meshExtendMatrix G A) v * + (meshContractionMatrix G μ n v).conjTranspose= + (meshContractionMatrix G μ m v).conjTranspose*A v := by + have h := congrArg Matrix.conjTranspose + (meshContraction_naturality G μ (fun v => (A v).conjTranspose) v) + simpa only [Matrix.conjTranspose_mul,meshExtend_adjoint, + Matrix.conjTranspose_conjTranspose] using h + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNilpotence.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNilpotence.lean new file mode 100644 index 0000000000000000000000000000000000000000..bfc60c17202b2075cc0cefb1089dd47410086c44 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNilpotence.lean @@ -0,0 +1,84 @@ +import Mathlib.Algebra.FreeAlgebra +import Mathlib.RingTheory.TwoSidedIdeal.Operations +import Mathlib.RingTheory.TwoSidedIdeal.Kernel +import OAI.Topology.ArtinGroups.Quivers.ReversibleQuiver + +namespace OAI + +/-! +# The published finite-Dynkin path input + +`MeshNilpotent` is the positive-degree nilpotence assertion for the +preprojective (mesh) algebra of an induced finite Dynkin graph. Its +relations are displayed explicitly, rather than asserted for a complex. +The standard finite-dimensionality input is Amiot, *On the structure of +triangulated categories with finitely many indecomposables*, Bull. Soc. +Math. France 135 (2007), Proposition 9.1; the essential-path formulation +is Coquereaux (2002), §§3.1–3.2, and Cooper (2007), Theorem 5.4.3 and +Proposition 5.6.10. On a bipartite Dynkin graph the usual signed mesh +relations have the same zero sets as the displayed all-plus relations. + +This module proves evaluation of the abstract relations. It does not +assume their vanishing for coefficient maps of the target paper's +complexes, nor assume any stabilizer or bounded-height conclusion. +-/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) [Fintype A] + +noncomputable def meshRelation (v : V) : FreeAlgebra ℂ A := + ∑ a, if Q.source a = v then FreeAlgebra.ι ℂ a * FreeAlgebra.ι ℂ (Q.reverse a) else 0 + +def meshRelations (U : Set V) : Set (FreeAlgebra ℂ A) := + {z | ∃ a, (Q.source a ∉ U ∨ Q.target a ∉ U) ∧ z = FreeAlgebra.ι ℂ a} ∪ + {z | ∃ a b, Q.target a ≠ Q.source b ∧ z = FreeAlgebra.ι ℂ a * FreeAlgebra.ι ℂ b} ∪ + {z | ∃ v ∈ U, z = meshRelation Q v} + +/-- Exact abstract algebra input: sufficiently long positive words lie +in the two-sided ideal generated by the mesh relations. -/ +def MeshNilpotent (U : Set V) : Prop := + ∃ N : ℕ, 0 < N ∧ ∀ w : List A, w.length = N → + (w.map (FreeAlgebra.ι ℂ)).prod ∈ TwoSidedIdeal.span (meshRelations Q U) + +/-- Evaluation of one abstract path identity into an arbitrary complex algebra. -/ +theorem mesh_word_evaluate {U : Set V} + {R : Type*} [Ring R] [Algebra ℂ R] (B : A → R) + (houtside : ∀ a, Q.source a ∉ U ∨ Q.target a ∉ U → B a = 0) + (hpath : ∀ a b, Q.target a ≠ Q.source b → B a * B b = 0) + (hmesh : ∀ v ∈ U, (∑ a, if Q.source a = v then B a * B (Q.reverse a) else 0) = 0) + (w : List A) (hw : (w.map (FreeAlgebra.ι ℂ)).prod ∈ + TwoSidedIdeal.span (meshRelations Q U)) : (w.map B).prod = 0 := by + let φ : FreeAlgebra ℂ A →ₐ[ℂ] R := FreeAlgebra.lift ℂ B + have hk : TwoSidedIdeal.span (meshRelations Q U) ≤ TwoSidedIdeal.ker φ.toRingHom := by + apply TwoSidedIdeal.span_le.mpr + intro z hz + change φ z = φ 0 + rw [map_zero] + rcases hz with (⟨a, ha, rfl⟩ | ⟨a, b, hab, rfl⟩) | ⟨v, hv, rfl⟩ + · simpa only [φ, FreeAlgebra.lift_ι_apply] using houtside a ha + · simpa only [map_mul, φ, FreeAlgebra.lift_ι_apply] using hpath a b hab + · simp only [meshRelation, map_sum] + convert hmesh v hv using 1 + apply Finset.sum_congr rfl + intro a _ + split_ifs + · simp only [map_mul, φ, FreeAlgebra.lift_ι_apply] + · exact map_zero φ + have he : φ (w.map (FreeAlgebra.ι ℂ)).prod = φ 0 := hk hw + rw [map_zero] at he + simpa only [map_list_prod, List.map_map, Function.comp_def, φ, FreeAlgebra.lift_ι_apply] using he + +/-- The nilpotence exponent depends only on the graph, not on the algebra +in which the paths are evaluated. -/ +theorem meshNilpotent_evaluate {U : Set V} (h : MeshNilpotent Q U) + {R : Type*} [Ring R] [Algebra ℂ R] (B : A → R) + (houtside : ∀ a, Q.source a ∉ U ∨ Q.target a ∉ U → B a = 0) + (hpath : ∀ a b, Q.target a ≠ Q.source b → B a * B b = 0) + (hmesh : ∀ v ∈ U, (∑ a, if Q.source a = v then B a * B (Q.reverse a) else 0) = 0) : + ∃ N : ℕ, 0 < N ∧ ∀ w : List A, w.length = N → (w.map B).prod = 0 := by + obtain ⟨N, hN, hwords⟩ := h + exact ⟨N, hN, fun w hw => mesh_word_evaluate Q B houtside hpath hmesh w (hwords w hw)⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNormalization.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..938f0cc120fb8467a229eac43fea487d4398a3b7 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshNormalization.lean @@ -0,0 +1,90 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshPathEvaluation + +namespace OAI + +/-! Passage from the weighted essential-path relations to all-plus meshes. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V R : Type} [Fintype V] (G : SimpleGraph V) [Ring R] [Algebra ℂ R] + +lemma mesh_normalization_weight (a b : ℝ) (ha : 0 1 + | n+1, v, p => meshPathScale μ n p.1.val p.2 * ((Real.sqrt (μ v))⁻¹ : ℂ) + +omit [Fintype V] in +lemma meshPathScale_ne_zero (μ : V → ℝ) (hμ : ∀ v, 0<μ v) : + ∀ n v p, meshPathScale G μ n v p≠0 := by + intro n + induction n with + | zero => intro v p; exact one_ne_zero + | succ n ih => + intro v p + change meshPathScale G μ n p.1.val p.2 * ((Real.sqrt (μ v))⁻¹ : ℂ)≠0 + apply mul_ne_zero (ih p.1.val p.2) + exact inv_ne_zero (Complex.ofReal_ne_zero.mpr (ne_of_gt (Real.sqrt_pos.mpr (hμ v)))) + +omit [Fintype V] in +lemma meshRescale_evaluate (μ : V → ℝ) (B : ∀ u v, G.Adj u v → R) : + ∀ n v p, meshPathEvaluate G (meshRescale G μ B) n v p= + meshPathScale G μ n v p • meshPathEvaluate G B n v p := by + intro n + induction n with + | zero => intro v p; exact (one_smul ℂ (1 : R)).symm + | succ n ih => + intro v p + change meshPathEvaluate G (meshRescale G μ B) n p.1.val p.2 * + (((Real.sqrt (μ v))⁻¹ : ℂ) • B p.1.val v p.1.property)=_ + rw [ih,smul_mul_assoc,mul_smul_comm,smul_smul] + rfl + +/-- Unweighted all-plus mesh relations suffice for the same finite path +bound. The rescaling factors are explicitly proved nonzero. -/ +theorem allPlus_mesh_paths_vanish (μ : V → ℝ) (hμ : ∀ v, 0<μ v) + (δ : ℝ) (hδ0 : 0<δ) (hδ2 : δ<2) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (B : ∀ u v, G.Adj u v → R) + (hmesh : ∀ v, (∑ u : {u : V // G.Adj u v}, + B v u.val u.property.symm * B u.val v u.property)=0) : + ∃ N : ℕ, 0 1 + | n+1, v, p => meshPathEvaluate B n p.1.val p.2 * B p.1.val v p.1.property + +omit [Fintype V] [Algebra ℂ R] in +lemma meshPathEvaluate_insert (B : ∀ u v, G.Adj u v → R) (n : ℕ) (v : V) + (u : {u : V // G.Adj u v}) (p : MeshPaths G n v) : + meshPathEvaluate G B (n+2) v (meshInsertBacktrack G u p)= + meshPathEvaluate G B n v p * B v u.val u.property.symm * B u.val v u.property := rfl + +lemma meshApply_contraction_adjoint (μ : V → ℝ) (n : ℕ) (v : V) + (f : MeshPaths G (n+2) v → R) (p : MeshPaths G n v) : + meshApply (meshContractionMatrix G μ n v).conjTranspose f p= + ∑ u : {u : V // G.Adj u v}, (Real.sqrt (μ u/μ v) : ℂ) • + f (meshInsertBacktrack G u p) := by + change (∑ q, star (∑ u : {u : V // G.Adj u v}, + if q=meshInsertBacktrack G u p then (Real.sqrt (μ u/μ v) : ℂ) else 0) • f q)=_ + simp only [star_sum,apply_ite star,star_zero,Complex.star_def,Complex.conj_ofReal, + Finset.sum_smul,ite_smul,zero_smul] + rw [Finset.sum_comm] + simp + +lemma meshPathEvaluate_contracts (μ : V → ℝ) (B : ∀ u v, G.Adj u v → R) + (hmesh : ∀ v, (∑ u : {u : V // G.Adj u v}, + (Real.sqrt (μ u/μ v) : ℂ) • (B v u.val u.property.symm * B u.val v u.property))=0) + (n : ℕ) (v : V) : + meshApply (meshContractionMatrix G μ n v).conjTranspose + (meshPathEvaluate G B (n+2) v)=0 := by + funext p + rw [meshApply_contraction_adjoint] + simp only [meshPathEvaluate_insert,Pi.zero_apply] + calc + _ = meshPathEvaluate G B n v p * + (∑ u : {u : V // G.Adj u v}, (Real.sqrt (μ u/μ v) : ℂ) • + (B v u.val u.property.symm * B u.val v u.property)) := by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro u _ + rw [mul_assoc,mul_smul_comm] + _ = 0 := by rw [hmesh,mul_zero] + +lemma meshPathEvaluate_extend (B : ∀ u v, G.Adj u v → R) {m n : ℕ} + (A : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) + (hA : ∀ v, meshApply (A v) (meshPathEvaluate G B m v)=meshPathEvaluate G B n v) + (v : V) : meshApply (meshExtendMatrix G A v) (meshPathEvaluate G B (m+1) v)= + meshPathEvaluate G B (n+1) v := by + let L (u : {u : V // G.Adj u v}) : R →ₗ[ℂ] R := { + toFun := fun x => x*B u.val v u.property + map_add' := fun x y => add_mul x y _ + map_smul' := fun a x => smul_mul_assoc a x _ } + change meshApply (meshExtendMatrix G A v) + (fun p => L p.1 (meshPathEvaluate G B m p.1.val p.2))=_ + rw [meshApply_extend] + funext q + rw [hA] + rfl + +/-- Every recursively defined projection acts as the identity after +evaluation in an algebra satisfying the weighted mesh relations. -/ +theorem meshPathEvaluate_projection (μ : V → ℝ) (δ : ℝ) + (B : ∀ u v, G.Adj u v → R) + (hmesh : ∀ v, (∑ u : {u : V // G.Adj u v}, + (Real.sqrt (μ u/μ v) : ℂ) • (B v u.val u.property.symm * B u.val v u.property))=0) : + ∀ n v, meshApply (meshProjection G μ δ n v) (meshPathEvaluate G B n v)= + meshPathEvaluate G B n v := by + intro n + induction n using Nat.twoStepInduction with + | zero => intro v; rw [meshProjection_zero,meshApply_one] + | one => intro v; rw [meshProjection_one,meshApply_one] + | more n _ ih => + intro v + let Q := meshExtendMatrix G (meshProjection G μ δ (n+1)) v + let C := meshContractionMatrix G μ n v + let f := meshPathEvaluate G B (n+2) v + have hQ : meshApply Q f=f := meshPathEvaluate_extend G B _ ih v + have hQstar : Q.conjTranspose=Q := by + simp only [Q,meshExtend_adjoint,meshProjection_selfAdjoint] + have hkill : meshApply (C*Q).conjTranspose f=0 := by + rw [Matrix.conjTranspose_mul,hQstar,meshApply_mul,hQ] + exact meshPathEvaluate_contracts G μ B hmesh n v + rw [meshProjection_step,meshApply_sub,meshApply_smul,meshApply_mul] + change meshApply Q f - _ • meshApply (C*Q) (meshApply (C*Q).conjTranspose f)=f + rw [hQ,hkill,meshApply_zero_right,smul_zero,sub_zero] + +/-- A single finite path length vanishes in every algebra satisfying the +weighted mesh relations. The proof uses the actual finite path matrices. -/ +theorem weighted_mesh_paths_vanish (μ : V → ℝ) (hμ : ∀ v, 0<μ v) + (δ : ℝ) (hδ0 : 0<δ) (hδ2 : δ<2) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (B : ∀ u v, G.Adj u v → R) + (hmesh : ∀ v, (∑ u : {u : V // G.Adj u v}, + (Real.sqrt (μ u/μ v) : ℂ) • (B v u.val u.property.symm * B u.val v u.property))=0) : + ∃ N : ℕ, 0 PUnit + | n+1, v => Σ u : {u : V // G.Adj u v}, MeshPaths n u.val + +noncomputable instance meshPathsFintype [Fintype V] (n : ℕ) (v : V) : Fintype (MeshPaths G n v) := by + induction n generalizing v with + | zero => change Fintype PUnit; infer_instance + | succ n ih => + change Fintype (Σ u : {u : V // G.Adj u v}, MeshPaths G n u.val) + let (u : V) : Fintype (MeshPaths G n u) := ih u + infer_instance + +/-- Attach the last two edges `v,u,v` to a path ending at `v`. -/ +def meshInsertBacktrack {n : ℕ} {v : V} (u : {u : V // G.Adj u v}) + (p : MeshPaths G n v) : MeshPaths G (n+2) v := + ⟨u,⟨⟨v,u.property.symm⟩,p⟩⟩ + +lemma meshInsertBacktrack_injective {n : ℕ} {v : V} : + Function.Injective (fun up : {u : V // G.Adj u v} × MeshPaths G n v => + meshInsertBacktrack G up.1 up.2) := by + rintro ⟨u,p⟩ ⟨w,q⟩ h + change (⟨u,⟨⟨v,u.property.symm⟩,p⟩⟩ : MeshPaths G (n+2) v)= + ⟨w,⟨⟨v,w.property.symm⟩,q⟩⟩ at h + obtain ⟨hu,hinner⟩ := Sigma.mk.inj_iff.mp h + cases hu + have hp := (Sigma.mk.inj_iff.mp (eq_of_heq hinner)).2 + exact Prod.ext rfl (eq_of_heq hp) + +variable [Fintype V] + +/-- The contraction coefficient is the positive square root used in the +essential-path representation of the mesh algebra. -/ +noncomputable def meshContractionMatrix (μ : V → ℝ) (n : ℕ) (v : V) : + Matrix (MeshPaths G n v) (MeshPaths G (n+2) v) ℂ := + fun p q => ∑ u : {u : V // G.Adj u v}, + if q=meshInsertBacktrack G u p then (Real.sqrt (μ u/μ v) : ℂ) else 0 + +/-- Extending a prefix operator by one edge, without changing that edge. -/ +noncomputable def meshExtendMatrix {m n : ℕ} + (T : ∀ v, Matrix (MeshPaths G m v) (MeshPaths G n v) ℂ) (v : V) : + Matrix (MeshPaths G (m+1) v) (MeshPaths G (n+1) v) ℂ := + Matrix.blockDiagonal' (fun u : {u : V // G.Adj u v} => T u.val) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshPerron.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshPerron.lean new file mode 100644 index 0000000000000000000000000000000000000000..de77a53722975d09574124c4728e95c37904d487 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshPerron.lean @@ -0,0 +1,63 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshSpectralUpper + +namespace OAI + +/-! Nonnegative top eigenvectors, without a Perron--Frobenius axiom. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +open scoped BigOperators +open Matrix +variable {V : Type} [Fintype V] + +lemma mesh_quadratic_abs_le (A : Matrix V V ℝ) (hA : ∀ i j, 0≤A i j) + (x : V → ℝ) : x ⬝ᵥ (A *ᵥ x) ≤ (fun i => |x i|) ⬝ᵥ (A *ᵥ fun i => |x i|) := by + simp only [dotProduct,mulVec,Finset.mul_sum] + apply Finset.sum_le_sum + intro i _ + apply Finset.sum_le_sum + intro j _ + have h := mul_le_mul_of_nonneg_left (le_abs_self (x i*x j)) (hA i j) + simpa only [abs_mul,mul_assoc,mul_left_comm,mul_comm] using h + +lemma mesh_abs_top_eigenvector (A : Matrix V V ℝ) (hA : ∀ i j, 0≤A i j) + (d : ℝ) (hupper : (d • (1 : Matrix V V ℝ)-A).PosSemidef) + (x : V → ℝ) (heigen : A *ᵥ x=d • x) : + A *ᵥ (fun i => |x i|)=d • (fun i => |x i|) := by + let y : V → ℝ := fun i => |x i| + have hsq : y ⬝ᵥ y=x ⬝ᵥ x := by + simp only [dotProduct,y,←sq,sq_abs] + have hq := mesh_quadratic_abs_le A hA x + have hx : x ⬝ᵥ (A *ᵥ x)=d*(x ⬝ᵥ x) := by + rw [heigen,dotProduct_smul,smul_eq_mul] + have he : y ⬝ᵥ ((d • (1 : Matrix V V ℝ)-A) *ᵥ y)=d*(y ⬝ᵥ y)-y ⬝ᵥ (A *ᵥ y) := by + rw [sub_mulVec,smul_mulVec,one_mulVec,dotProduct_sub,dotProduct_smul,smul_eq_mul] + have hnonneg := hupper.dotProduct_mulVec_nonneg y + simp only [star_trivial] at hnonneg + have hz : y ⬝ᵥ ((d • (1 : Matrix V V ℝ)-A) *ᵥ y)=0 := by + change x ⬝ᵥ (A *ᵥ x)≤y ⬝ᵥ (A *ᵥ y) at hq + rw [he,hsq] at hnonneg ⊢ + linarith + have hzero := hupper.dotProduct_mulVec_zero_iff.mp (by simpa only [star_trivial] using hz) + rw [sub_mulVec,smul_mulVec,one_mulVec] at hzero + exact (sub_eq_zero.mp hzero).symm + +theorem mesh_nonnegative_top_eigenvector [Nonempty V] (A : Matrix V V ℝ) + (hA : A.IsHermitian) (hpos : ∀ i j, 0≤A i j) : + ∃ (d : ℝ) (y : V → ℝ), y≠0 ∧ (∀ i, 0≤y i) ∧ A *ᵥ y=d • y := by + obtain ⟨j,_,hj⟩ := Finset.exists_max_image Finset.univ hA.eigenvalues Finset.univ_nonempty + let d := hA.eigenvalues j + let x : V → ℝ := fun i => hA.eigenvectorBasis j i + have hx : x≠0 := by + exact (WithLp.ofLp_eq_zero 2).ne.2 (hA.eigenvectorBasis.orthonormal.ne_zero j) + have hupper : (d • (1 : Matrix V V ℝ)-A).PosSemidef := + mesh_spectral_upper hA d (fun i => hj i (Finset.mem_univ i)) + refine ⟨d,fun i => |x i|,?_,fun i => abs_nonneg _,?_⟩ + · intro hz + apply hx + funext i + exact abs_eq_zero.mp (congrFun hz i) + · exact mesh_abs_top_eigenvector A hpos d hupper x (hA.mulVec_eigenvectorBasis j) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjection.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjection.lean new file mode 100644 index 0000000000000000000000000000000000000000..518afaf3238bf115c8bc76f58ff93c6e07dc0dcd --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjection.lean @@ -0,0 +1,167 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshNaturality +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshQuantum +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshTrace + +namespace OAI + +/-! Jones--Wenzl projections on the actual finite path spaces. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +/-- The correction formula removes precisely the final contraction from +the already projected prefix. Only positive-index quantum integers occur +as denominators before the cutoff. -/ +noncomputable def meshProjection (μ : V → ℝ) (δ : ℝ) : + (n : ℕ) → (v : V) → Matrix (MeshPaths G n v) (MeshPaths G n v) ℂ + | 0, _ => 1 + | 1, _ => 1 + | n+2, v => + let Q := meshExtendMatrix G (meshProjection μ δ (n+1)) v + let T := meshContractionMatrix G μ n v * Q + Q - (((meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹ : ℝ) : ℂ) • + (T.conjTranspose*T) + +lemma meshProjection_zero (μ : V → ℝ) (δ : ℝ) (v : V) : + meshProjection G μ δ 0 v=1 := rfl + +lemma meshProjection_one (μ : V → ℝ) (δ : ℝ) (v : V) : + meshProjection G μ δ 1 v=1 := rfl + +lemma meshProjection_step (μ : V → ℝ) (δ : ℝ) (n : ℕ) (v : V) : + meshProjection G μ δ (n+2) v = + let Q := meshExtendMatrix G (meshProjection G μ δ (n+1)) v + let T := meshContractionMatrix G μ n v*Q + Q - (((meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹ : ℝ) : ℂ) • + (T.conjTranspose*T) := rfl + +/-- Self-adjointness uses only the real coefficients in the recursion; +it holds even beyond the range in which the matrices are projections. -/ +theorem meshProjection_selfAdjoint (μ : V → ℝ) (δ : ℝ) : + ∀ n v, (meshProjection G μ δ n v).conjTranspose=meshProjection G μ δ n v := by + intro n + induction n using Nat.twoStepInduction with + | zero => intro v; rw [meshProjection_zero,Matrix.conjTranspose_one] + | one => intro v; rw [meshProjection_one,Matrix.conjTranspose_one] + | more n _ ih => + intro v + have hQ : (meshExtendMatrix G (meshProjection G μ δ (n+1)) v).conjTranspose= + meshExtendMatrix G (meshProjection G μ δ (n+1)) v := by + simp only [meshExtend_adjoint,ih] + rw [meshProjection_step,Matrix.conjTranspose_sub,Matrix.conjTranspose_smul, + Matrix.conjTranspose_mul,Matrix.conjTranspose_conjTranspose,hQ] + simp only [Complex.star_def,Complex.conj_ofReal] + +/-- One step of the actual recursion, once its scalar identity has been +established from the preceding path identities. -/ +theorem meshProjection_correct (μ : V → ℝ) (δ : ℝ) (n : ℕ) (v : V) + (hden : meshQuantum δ (n+2)/meshQuantum δ (n+1)≠0) + (hQstar : (meshExtendMatrix G (meshProjection G μ δ (n+1)) v).conjTranspose= + meshExtendMatrix G (meshProjection G μ δ (n+1)) v) + (hQsq : meshExtendMatrix G (meshProjection G μ δ (n+1)) v * + meshExtendMatrix G (meshProjection G μ δ (n+1)) v= + meshExtendMatrix G (meshProjection G μ δ (n+1)) v) + (hscalar : meshContractionMatrix G μ n v * + meshExtendMatrix G (meshProjection G μ δ (n+1)) v * + (meshContractionMatrix G μ n v).conjTranspose = + ((meshQuantum δ (n+2)/meshQuantum δ (n+1) : ℝ) : ℂ) • meshProjection G μ δ n v) + (himage : meshProjection G μ δ n v * (meshContractionMatrix G μ n v * + meshExtendMatrix G (meshProjection G μ δ (n+1)) v)= + meshContractionMatrix G μ n v * meshExtendMatrix G (meshProjection G μ δ (n+1)) v) : + (meshProjection G μ δ (n+2) v).conjTranspose=meshProjection G μ δ (n+2) v ∧ + meshProjection G μ δ (n+2) v * meshProjection G μ δ (n+2) v= + meshProjection G μ δ (n+2) v ∧ + meshProjection G μ δ (n+2) v * meshExtendMatrix G (meshProjection G μ δ (n+1)) v= + meshProjection G μ δ (n+2) v ∧ + meshContractionMatrix G μ n v * meshProjection G μ δ (n+2) v=0 ∧ + Matrix.trace (meshProjection G μ δ (n+2) v)= + Matrix.trace (meshExtendMatrix G (meshProjection G μ δ (n+1)) v)- + Matrix.trace (meshProjection G μ δ n v) := by + let Q := meshExtendMatrix G (meshProjection G μ δ (n+1)) v + let C := meshContractionMatrix G μ n v + change Q.conjTranspose=Q at hQstar + change Q*Q=Q at hQsq + have hTQ : (C*Q)*Q=C*Q := by rw [Matrix.mul_assoc,hQsq] + have hTT : (C*Q)*(C*Q).conjTranspose= + ((meshQuantum δ (n+2)/meshQuantum δ (n+1) : ℝ) : ℂ) • meshProjection G μ δ n v := by + rw [Matrix.conjTranspose_mul,hQstar,Matrix.mul_assoc,←Matrix.mul_assoc Q,hQsq, + ←Matrix.mul_assoc] + exact hscalar + obtain ⟨hstar,hsq,hnest,hkill,htrace⟩ := mesh_projection_correction Q (C*Q) + (meshProjection G μ δ n v) (meshQuantum δ (n+2)/meshQuantum δ (n+1)) + hden hQstar hQsq hTQ hTT himage + rw [meshProjection_step] + dsimp only + refine ⟨hstar,hsq,hnest,?_,htrace⟩ + have hleft : Q*(Q-(((meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹ : ℝ) : ℂ) • + ((C*Q).conjTranspose*(C*Q)))= + Q-(((meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹ : ℝ) : ℂ) • + ((C*Q).conjTranspose*(C*Q)) := by + have h := congrArg Matrix.conjTranspose hnest + rw [Matrix.conjTranspose_mul,hQstar,hstar] at h + exact h + change C*(Q-(((meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹ : ℝ) : ℂ) • + ((C*Q).conjTranspose*(C*Q)))=0 + rw [←hleft,←Matrix.mul_assoc] + exact hkill + +lemma meshProjection_extend_step (μ : V → ℝ) (δ : ℝ) (n : ℕ) (v : V) + (hstar : ∀ w, (meshProjection G μ δ (n+1) w).conjTranspose= + meshProjection G μ δ (n+1) w) : + let R := meshExtendMatrix G (meshExtendMatrix G (meshProjection G μ δ (n+1))) v + let D := meshExtendMatrix G (meshContractionMatrix G μ n) v + meshExtendMatrix G (meshProjection G μ δ (n+2)) v = + R-(((meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹ : ℝ) : ℂ) • + (R*D.conjTranspose*D*R) := by + dsimp only + have hRstar : (meshExtendMatrix G (meshExtendMatrix G + (meshProjection G μ δ (n+1))) v).conjTranspose= + meshExtendMatrix G (meshExtendMatrix G (meshProjection G μ δ (n+1))) v := by + simp only [meshExtend_adjoint,hstar] + rw [funext (meshProjection_step G μ δ n)] + simp only [meshExtend_sub,meshExtend_smul, + meshExtend_mul,←meshExtend_adjoint,Matrix.conjTranspose_mul] + rw [hRstar] + simp only [Matrix.mul_assoc] + +lemma meshProjection_scalar_zero (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) (v : V) : + meshContractionMatrix G μ 0 v * meshExtendMatrix G (meshProjection G μ δ 1) v * + (meshContractionMatrix G μ 0 v).conjTranspose = + ((meshQuantum δ 2/meshQuantum δ 1 : ℝ) : ℂ) • meshProjection G μ δ 0 v := by + have hPone : meshProjection G μ δ 1=fun v => + (1 : Matrix (MeshPaths G 1 v) (MeshPaths G 1 v) ℂ) := + funext (meshProjection_one G μ δ) + have hq : meshQuantum δ 2/meshQuantum δ 1=δ := by norm_num [meshQuantum] + rw [hq,meshProjection_zero,hPone,meshExtend_one,Matrix.mul_one] + exact meshContraction_loop G μ hμ δ heigen 0 v + +lemma meshProjection_scalar_succ (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (n : ℕ) (hq : meshQuantum δ (n+2)≠0) + (hstar : ∀ w, (meshProjection G μ δ (n+1) w).conjTranspose= + meshProjection G μ δ (n+1) w) + (hsq : ∀ w, meshProjection G μ δ (n+1) w * meshProjection G μ δ (n+1) w= + meshProjection G μ δ (n+1) w) (v : V) : + meshContractionMatrix G μ (n+1) v * + meshExtendMatrix G (meshProjection G μ δ (n+2)) v * + (meshContractionMatrix G μ (n+1) v).conjTranspose = + ((meshQuantum δ (n+3)/meshQuantum δ (n+2) : ℝ) : ℂ) • + meshProjection G μ δ (n+1) v := by + rw [meshProjection_extend_step G μ δ n v hstar] + have h := mesh_scalar_step (meshContractionMatrix G μ (n+1) v) + (meshExtendMatrix G (meshContractionMatrix G μ n) v) + (meshProjection G μ δ (n+1) v) + (meshExtendMatrix G (meshExtendMatrix G (meshProjection G μ δ (n+1))) v) + (δ : ℂ) (((meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹ : ℝ) : ℂ) + (hsq v) (meshContraction_naturality G μ (meshProjection G μ δ (n+1)) v) + (meshContraction_naturality_adjoint G μ (meshProjection G μ δ (n+1)) v) + (meshContraction_loop G μ hμ δ heigen (n+1) v) + (by simpa only [meshExtend_adjoint] using meshContraction_adjacent G μ hμ n v) + (meshContraction_adjacent_right G μ hμ n v) + rw [←Complex.ofReal_sub,meshQuantum_ratio_step δ n hq] at h + exact h + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionAlgebra.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionAlgebra.lean new file mode 100644 index 0000000000000000000000000000000000000000..ad9a5dbbdfee0ac7322baae6d1c215bc709ebe60 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionAlgebra.lean @@ -0,0 +1,93 @@ +import Mathlib + +namespace OAI + +/-! The finite-dimensional projection calculation in the mesh argument. -/ +namespace HarmonicArtin.ParabolicIntersections +open scoped ComplexOrder +attribute [local instance] Classical.decEq +variable {I J : Type} [Fintype I] [Fintype J] + +/-- The loop, adjacent, and prefix identities give the next scalar in +the projection recurrence. -/ +theorem mesh_scalar_step (C D : Matrix I J ℂ) (P : Matrix I I ℂ) + (R : Matrix J J ℂ) (delta a : ℂ) + (hPsq : P*P=P) (hCR : C*R=P*C) (hRC : R*C.conjTranspose=C.conjTranspose*P) + (hloop : C*C.conjTranspose=delta • (1 : Matrix I I ℂ)) + (hadj : C*D.conjTranspose=1) (hadj' : D*C.conjTranspose=1) : + C*(R-a • (R*D.conjTranspose*D*R))*C.conjTranspose=(delta-a) • P := by + have hfirst : C*R*C.conjTranspose=delta • P := by + rw [hCR,Matrix.mul_assoc,hloop,Matrix.mul_smul,Matrix.mul_one] + have hsecond : C*(R*D.conjTranspose*D*R)*C.conjTranspose=P := by + calc + _ = (C*R)*D.conjTranspose*D*(R*C.conjTranspose) := by simp only [Matrix.mul_assoc] + _ = (P*C)*D.conjTranspose*D*(C.conjTranspose*P) := by rw [hCR,hRC] + _ = P*(C*D.conjTranspose)*(D*C.conjTranspose)*P := by simp only [Matrix.mul_assoc] + _ = P := by rw [hadj,hadj',Matrix.mul_one,Matrix.mul_one,hPsq] + rw [Matrix.mul_sub,Matrix.sub_mul,Matrix.mul_smul,Matrix.smul_mul, + hfirst,hsecond,sub_smul] + +/-- Removing the scaled row-space projection imposes one more contraction. +All hypotheses here are matrix identities, proved for the path operators +in the mesh construction. -/ +theorem mesh_projection_correction (Q : Matrix I I ℂ) (T : Matrix J I ℂ) + (P : Matrix J J ℂ) (lam : ℝ) (hlam : lam≠0) + (hQstar : Q.conjTranspose=Q) (hQsq : Q*Q=Q) + (hTQ : T*Q=T) (hTT : T*T.conjTranspose=(lam : ℂ) • P) (hPT : P*T=T) : + let R := Q - ((lam⁻¹ : ℝ) : ℂ) • (T.conjTranspose*T) + R.conjTranspose=R ∧ R*R=R ∧ R*Q=R ∧ T*R=0 ∧ + Matrix.trace R=Matrix.trace Q-Matrix.trace P := by + let a : ℂ := (lam⁻¹ : ℝ) + let B : Matrix I I ℂ := a • (T.conjTranspose*T) + have ha : a*(lam : ℂ)=1 := by + dsimp [a] + rw [←Complex.ofReal_mul,inv_mul_cancel₀ hlam,Complex.ofReal_one] + have hQT : Q*T.conjTranspose=T.conjTranspose := by + have h := congrArg Matrix.conjTranspose hTQ + simpa only [Matrix.conjTranspose_mul,hQstar] using h + have hQB : Q*B=B := by + dsimp [B] + rw [Matrix.mul_smul,←Matrix.mul_assoc,hQT] + have hBQ : B*Q=B := by + dsimp [B] + rw [Matrix.smul_mul,Matrix.mul_assoc,hTQ] + have hBT : T*B=T := by + dsimp [B] + rw [Matrix.mul_smul,←Matrix.mul_assoc,hTT,Matrix.smul_mul,hPT,smul_smul,ha,one_smul] + have hBB : B*B=B := by + dsimp [B] + rw [Matrix.smul_mul,Matrix.mul_smul,Matrix.mul_assoc, + ←Matrix.mul_assoc T T.conjTranspose T,hTT,Matrix.smul_mul,hPT, + Matrix.mul_smul,smul_smul,smul_smul] + rw [mul_assoc,ha,mul_one] + have hBstar : B.conjTranspose=B := by + simp only [B,a,Matrix.conjTranspose_smul,Matrix.conjTranspose_mul, + Matrix.conjTranspose_conjTranspose,Complex.star_def,Complex.conj_ofReal] + have htrace : Matrix.trace B=Matrix.trace P := by + dsimp [B] + rw [Matrix.trace_smul,Matrix.trace_mul_comm,hTT,Matrix.trace_smul,smul_smul,ha,one_smul] + change (Q-B).conjTranspose=Q-B ∧ (Q-B)*(Q-B)=Q-B ∧ + (Q-B)*Q=Q-B ∧ T*(Q-B)=0 ∧ Matrix.trace (Q-B)=_ + refine ⟨?_,?_,?_,?_,?_⟩ + · rw [Matrix.conjTranspose_sub,hQstar,hBstar] + · rw [Matrix.sub_mul,Matrix.mul_sub,Matrix.mul_sub,hQsq,hQB,hBQ,hBB] + abel + · rw [Matrix.sub_mul,hQsq,hBQ] + · rw [Matrix.mul_sub,hTQ,hBT,sub_self] + · rw [Matrix.trace_sub,htrace] + +/-- A self-adjoint idempotent is positive, and trace zero forces it to +vanish. These are the positivity facts used at the scalar cutoff. -/ +theorem mesh_projection_trace (P : Matrix I I ℂ) + (hstar : P.conjTranspose=P) (hsq : P*P=P) : + 0≤(Matrix.trace P).re ∧ (Matrix.trace P=0 ↔ P=0) := by + have hpos : P.PosSemidef := by + have h := Matrix.posSemidef_conjTranspose_mul_self P + rwa [hstar,hsq] at h + have hz := Matrix.trace_conjTranspose_mul_self_eq_zero_iff (A := P) + rw [hstar,hsq] at hz + exact ⟨(Complex.nonneg_iff.mp hpos.trace_nonneg).1,hz⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionCutoff.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionCutoff.lean new file mode 100644 index 0000000000000000000000000000000000000000..722585b8afb7470c352a20949134a5efdab6d281 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionCutoff.lean @@ -0,0 +1,109 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshProjectionInduction + +namespace OAI + +/-! The actual path projections vanish at a finite quantum cutoff. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +lemma meshProjection_trace_zero (μ : V → ℝ) (δ : ℝ) : + meshWeightedTrace μ (meshProjection G μ δ 0)=∑ v, (μ v : ℂ) := by + simp only [meshWeightedTrace,meshProjection_zero,Matrix.trace_one] + simp only [MeshPaths,Fintype.card_punit,Nat.cast_one,mul_one] + +lemma meshProjection_trace_one (μ : V → ℝ) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) : + meshWeightedTrace μ (meshProjection G μ δ 1)=(δ : ℂ)*∑ v, (μ v : ℂ) := by + have hp : meshProjection G μ δ 1= + meshExtendMatrix G (meshProjection G μ δ 0) := by + funext v + rw [meshProjection_one,funext (meshProjection_zero G μ δ),meshExtend_one] + rw [hp,meshWeightedTrace_extend G μ δ heigen,meshProjection_trace_zero] + +lemma meshProjection_trace_step (μ : V → ℝ) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (n : ℕ) (h : MeshProjectionStage G μ δ (n+1)) : + meshWeightedTrace μ (meshProjection G μ δ (n+2))= + (δ : ℂ)*meshWeightedTrace μ (meshProjection G μ δ (n+1))- + meshWeightedTrace μ (meshProjection G μ δ n) := by + have ht (v : V) : Matrix.trace (meshProjection G μ δ (n+2) v)= + Matrix.trace (meshExtendMatrix G (meshProjection G μ δ (n+1)) v)- + Matrix.trace (meshProjection G μ δ n v) := by + have hh := h.trace_recurrence (by omega) v + rw [show n+1-1=n by omega] at hh + exact hh + calc + _ = meshWeightedTrace μ (meshExtendMatrix G (meshProjection G μ δ (n+1)))- + meshWeightedTrace μ (meshProjection G μ δ n) := by + simp only [meshWeightedTrace,←Finset.sum_sub_distrib] + apply Finset.sum_congr rfl + intro v _ + rw [ht,mul_sub] + _ = _ := by rw [meshWeightedTrace_extend G μ δ heigen] + +/-- The weighted trace is the quantum integer, without any graph +classification or assumption of mesh nilpotence. -/ +theorem meshProjection_weightedTrace (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (H : ℕ) (hpos : ∀ n, 0 < n → n < H → 0 < meshQuantum δ n) : + ∀ n, n + intro _ + simpa only [Nat.zero_add,meshQuantum_one,Complex.ofReal_one,one_mul] using + meshProjection_trace_zero G μ δ + | one => + intro _ + have hq : meshQuantum δ (1+1)=δ := by norm_num [meshQuantum] + rw [hq] + exact meshProjection_trace_one G μ δ heigen + | more n ih ih₁ => + intro hn + have hs := meshProjectionStage_before_cutoff G μ hμ δ heigen H hpos (n+1) hn + rw [meshProjection_trace_step G μ δ heigen n hs,ih₁ (by omega),ih (by omega)] + have hq : meshQuantum δ (n+2+1)=δ*meshQuantum δ (n+1+1)-meshQuantum δ (n+1) := + meshQuantum_step δ (n+1) + rw [hq,Complex.ofReal_sub,Complex.ofReal_mul] + ring + +/-- Some positive length has zero path projection. This is the finite +essential-path bound, proved from a positive adjacency eigenvector below 2. -/ +theorem meshProjection_eventually_zero (μ : V → ℝ) (hμ : ∀ v, 0<μ v) + (δ : ℝ) (hδ0 : 0<δ) (hδ2 : δ<2) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) : + ∃ N : ℕ, 0 (hμ v).le) + (meshProjection G μ δ N) hstar hsq + have hnonpos : (meshWeightedTrace μ (meshProjection G μ δ N)).re≤0 := by + rw [hw] + simp only [Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,zero_mul,sub_zero, + Complex.re_sum] + exact mul_nonpos_of_nonpos_of_nonneg hq (Finset.sum_nonneg (fun v _ => (hμ v).le)) + have him : (meshWeightedTrace μ (meshProjection G μ δ N)).im=0 := by + rw [hw] + simp + have hz : meshWeightedTrace μ (meshProjection G μ δ N)=0 := + Complex.ext (le_antisymm hnonpos hnonneg) him + exact ⟨N,hN,meshWeightedTrace_zero μ hμ (meshProjection G μ δ N) hstar hsq hz⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionInduction.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionInduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..e6ba10c2c76ba5131114e0bd60f22acb12e5e998 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshProjectionInduction.lean @@ -0,0 +1,106 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshProjection + +namespace OAI + +/-! The Jones--Wenzl induction before the first nonpositive quantum integer. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] (G : SimpleGraph V) + +structure MeshProjectionStage (μ : V → ℝ) (δ : ℝ) (n : ℕ) : Prop where + lower_star : ∀ v, (meshProjection G μ δ n v).conjTranspose=meshProjection G μ δ n v + lower_square : ∀ v, meshProjection G μ δ n v*meshProjection G μ δ n v=meshProjection G μ δ n v + upper_star : ∀ v, (meshProjection G μ δ (n+1) v).conjTranspose=meshProjection G μ δ (n+1) v + upper_square : ∀ v, meshProjection G μ δ (n+1) v*meshProjection G μ δ (n+1) v= + meshProjection G μ δ (n+1) v + nested : ∀ v, meshProjection G μ δ (n+1) v*meshExtendMatrix G (meshProjection G μ δ n) v= + meshProjection G μ δ (n+1) v + scalar : ∀ v, meshContractionMatrix G μ n v * + meshExtendMatrix G (meshProjection G μ δ (n+1)) v * + (meshContractionMatrix G μ n v).conjTranspose = + ((meshQuantum δ (n+2)/meshQuantum δ (n+1) : ℝ) : ℂ) • meshProjection G μ δ n v + trace_recurrence : n≠0 → ∀ v, Matrix.trace (meshProjection G μ δ (n+1) v)= + Matrix.trace (meshExtendMatrix G (meshProjection G μ δ n) v)- + Matrix.trace (meshProjection G μ δ (n-1) v) + +theorem meshProjectionStage_zero (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) : + MeshProjectionStage G μ δ 0 where + lower_star v := by simp only [meshProjection_zero,Matrix.conjTranspose_one] + lower_square v := by simp only [meshProjection_zero,Matrix.one_mul] + upper_star v := by + change (1 : Matrix (MeshPaths G 1 v) (MeshPaths G 1 v) ℂ).conjTranspose=1 + exact Matrix.conjTranspose_one + upper_square v := by + change (1 : Matrix (MeshPaths G 1 v) (MeshPaths G 1 v) ℂ)*1=1 + exact Matrix.one_mul 1 + nested v := by + rw [funext (meshProjection_zero G μ δ),meshExtend_one] + exact Matrix.mul_one _ + scalar := meshProjection_scalar_zero G μ hμ δ heigen + trace_recurrence hn := (hn rfl).elim + +theorem meshProjectionStage_succ (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (n : ℕ) (h : MeshProjectionStage G μ δ n) + (hq₁ : meshQuantum δ (n+1)≠0) (hq₂ : meshQuantum δ (n+2)≠0) : + MeshProjectionStage G μ δ (n+1) := by + have hQstar (v : V) : + (meshExtendMatrix G (meshProjection G μ δ (n+1)) v).conjTranspose= + meshExtendMatrix G (meshProjection G μ δ (n+1)) v := by + simp only [meshExtend_adjoint,h.upper_star] + have hQsq (v : V) : meshExtendMatrix G (meshProjection G μ δ (n+1)) v * + meshExtendMatrix G (meshProjection G μ δ (n+1)) v= + meshExtendMatrix G (meshProjection G μ δ (n+1)) v := by + rw [←meshExtend_mul] + simp only [h.upper_square] + have himage (v : V) : meshProjection G μ δ n v * + (meshContractionMatrix G μ n v * meshExtendMatrix G (meshProjection G μ δ (n+1)) v)= + meshContractionMatrix G μ n v * meshExtendMatrix G (meshProjection G μ δ (n+1)) v := by + let R := meshExtendMatrix G (meshExtendMatrix G (meshProjection G μ δ n)) v + let Q := meshExtendMatrix G (meshProjection G μ δ (n+1)) v + let C := meshContractionMatrix G μ n v + have hRstar : R.conjTranspose=R := by simp only [R,meshExtend_adjoint,h.lower_star] + have hQR : Q*R=Q := by + dsimp only [Q,R] + rw [←meshExtend_mul] + simp only [h.nested] + have hRQ : R*Q=Q := by + have hh := congrArg Matrix.conjTranspose hQR + rw [Matrix.conjTranspose_mul,hRstar,hQstar] at hh + exact hh + have hCR : C*R=meshProjection G μ δ n v*C := + meshContraction_naturality G μ (meshProjection G μ δ n) v + change meshProjection G μ δ n v*(C*Q)=C*Q + rw [←Matrix.mul_assoc,←hCR,Matrix.mul_assoc,hRQ] + have hnew (v : V) := meshProjection_correct G μ δ n v + (div_ne_zero hq₂ hq₁) (hQstar v) (hQsq v) (h.scalar v) (himage v) + exact { + lower_star := h.upper_star + lower_square := h.upper_square + upper_star := fun v => (hnew v).1 + upper_square := fun v => (hnew v).2.1 + nested := fun v => (hnew v).2.2.1 + scalar := meshProjection_scalar_succ G μ hμ δ heigen n hq₂ h.upper_star h.upper_square + trace_recurrence := fun _ v => by + rw [show n+1-1=n by omega] + exact (hnew v).2.2.2.2 } + +/-- Every stage strictly before the quantum cutoff is an actual +orthogonal projection, with the required nesting and scalar identity. -/ +theorem meshProjectionStage_before_cutoff (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + (H : ℕ) (hpos : ∀ n, 0 < n → n < H → 0 < meshQuantum δ n) : + ∀ n, n+1 intro _; exact meshProjectionStage_zero G μ hμ δ heigen + | succ n ih => + intro hn + apply meshProjectionStage_succ G μ hμ δ heigen n (ih (by omega)) + · exact ne_of_gt (hpos (n+1) (by omega) (by omega)) + · exact ne_of_gt (hpos (n+2) (by omega) (by omega)) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuantum.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuantum.lean new file mode 100644 index 0000000000000000000000000000000000000000..92c731d525f050177ba9ab4ae3f3feb597a03d6c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuantum.lean @@ -0,0 +1,129 @@ +import Mathlib + +namespace OAI + +/-! The finite positivity interval for the Jones--Wenzl scalar recurrence. -/ +namespace HarmonicArtin.ParabolicIntersections + +/-- Quantum integers as a real recurrence, with no trigonometric choices. -/ +noncomputable def meshQuantum (δ : ℝ) : ℕ → ℝ + | 0 => 0 + | 1 => 1 + | n+2 => δ*meshQuantum δ (n+1)-meshQuantum δ n + +@[simp] lemma meshQuantum_zero (δ : ℝ) : meshQuantum δ 0=0 := rfl +@[simp] lemma meshQuantum_one (δ : ℝ) : meshQuantum δ 1=1 := rfl +lemma meshQuantum_step (δ : ℝ) (n : ℕ) : + meshQuantum δ (n+2)=δ*meshQuantum δ (n+1)-meshQuantum δ n := rfl + +/-- For `δ<2`, the recurrence starting at `0,1` cannot remain strictly +positive. This discrete concavity proof avoids choosing an angle. -/ +theorem mesh_quantum_eventually_nonpositive (δ : ℝ) (hδ : δ<2) + (q : ℕ → ℝ) (hzero : q 0=0) (hone : q 1=1) + (hrec : ∀ n, q (n+2)=δ*q (n+1)-q n) : + ∃ n, 0 rw [hzero] + | succ n => exact (hpos _ (Nat.succ_pos n)).le + let d : ℕ → ℝ := fun n => q (n+1)-q n + have hd0 : d 0=1 := by simp only [d,hzero,hone]; norm_num + have hstep : ∀ n, d (n+1)=d n-(2-δ)*q (n+1) := by + intro n + dsimp [d] + rw [show n+1+1=n+2 by omega,hrec] + ring + have hanti : Antitone d := antitone_nat_of_succ_le (fun n => by + rw [hstep] + have := hnonneg (n+1) + nlinarith) + have hnegative : ∃ n, d n<0 := by + by_contra hneg + have hdpos : ∀ n, 0≤d n := by + intro n + by_contra hn + exact hneg ⟨n,lt_of_not_ge hn⟩ + have hmono : Monotone q := monotone_nat_of_le_succ (fun n => by + have := hdpos n + dsimp [d] at this + linarith) + have hqone : ∀ n, 1≤q (n+1) := by + intro n + simpa only [hone] using hmono (Nat.le_add_left 1 n) + have hbound : ∀ n, d n≤1-(n:ℝ)*(2-δ) := by + intro n + induction n with + | zero => simp only [Nat.cast_zero,zero_mul,sub_zero,hd0,le_refl] + | succ n ih => + rw [hstep,Nat.cast_succ] + have := hqone n + nlinarith + obtain ⟨n,hn⟩ := exists_nat_gt (1/(2-δ)) + have hden : 0<2-δ := by linarith + have hn' : 1<(n:ℝ)*(2-δ) := (div_lt_iff₀ hden).mp hn + have := hbound n + have := hdpos n + linarith + obtain ⟨n,hn⟩ := hnegative + have hlinear : ∀ k, q (n+k)≤q n+(k:ℝ)*d n := by + intro k + induction k with + | zero => simp + | succ k ih => + have hs := hanti (Nat.le_add_right n k) + have he : q (n+(k+1))=q (n+k)+d (n+k) := by dsimp [d]; simp only [Nat.add_assoc]; ring + rw [he,Nat.cast_succ] + linarith + obtain ⟨k,hk⟩ := exists_nat_gt (q n/(-d n)) + have hdneg : 0 < -d n := by linarith + have hk' : q n<(k:ℝ)*(-d n) := (div_lt_iff₀ hdneg).mp hk + have := hlinear k + have := hnonneg (n+k) + nlinarith + +/-- The first nonpositive scalar gives a finite cutoff, and all earlier +nonzero-index scalars are positive, as required by the projection recursion. -/ +theorem mesh_quantum_cutoff (δ : ℝ) (hδ0 : 0<δ) (hδ2 : δ<2) + (q : ℕ → ℝ) (hzero : q 0=0) (hone : q 1=1) + (hrec : ∀ n, q (n+2)=δ*q (n+1)-q n) : + ∃ h, 3≤h ∧ q h≤0 ∧ ∀ n, 0 hnot ⟨hn,hqn⟩) + have htwo : q 2=δ := by simpa only [zero_add,hzero,hone,mul_one,sub_zero] using hrec 0 + have hge : 3≤h := by + by_contra hlt + have he : h=1 ∨ h=2 := by omega + rcases he with he|he + · have := hh.2; rw [he,hone] at this; linarith + · have := hh.2; rw [he,htwo] at this; linarith + exact ⟨h,hge,hh.2,hp⟩ + +theorem meshQuantum_cutoff (δ : ℝ) (hδ0 : 0<δ) (hδ2 : δ<2) : + ∃ h, 3≤h ∧ meshQuantum δ h≤0 ∧ + ∀ n, 0 < n → n < h → 0 < meshQuantum δ n := + mesh_quantum_cutoff δ hδ0 hδ2 (meshQuantum δ) + (meshQuantum_zero δ) (meshQuantum_one δ) (meshQuantum_step δ) + +lemma meshQuantum_ratio_step (δ : ℝ) (n : ℕ) (h : meshQuantum δ (n+2)≠0) : + δ-(meshQuantum δ (n+2)/meshQuantum δ (n+1))⁻¹= + meshQuantum δ (n+3)/meshQuantum δ (n+2) := by + have hrec : meshQuantum δ (n+3)=δ*meshQuantum δ (n+2)-meshQuantum δ (n+1) := + meshQuantum_step δ (n+1) + rw [inv_div,hrec] + field_simp [h] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiver.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiver.lean new file mode 100644 index 0000000000000000000000000000000000000000..a612fb57bb16a3ccf7782f43ef9298fee33a6fe3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiver.lean @@ -0,0 +1,70 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshGraphNilpotence +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshNilpotence +import Mathlib.RingTheory.Congruence.Basic + +namespace OAI + +/-! The simple graph of a finite induced reversible quiver. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) (U : Set V) + +def QuiverSimpleOn : Prop := ∀ a b : A, Q.source a∈U → Q.target a∈U → + Q.source a=Q.source b → Q.target a=Q.target b → a=b + +def meshQuiverGraph (hloop : ∀ a, Q.source a≠Q.target a) : SimpleGraph U where + Adj u v := ∃ a, Q.source a=u.val ∧ Q.target a=v.val + symm := ⟨by + rintro u v ⟨a,hs,ht⟩ + exact ⟨Q.reverse a,(Q.source_reverse a).trans ht,(Q.target_reverse a).trans hs⟩⟩ + loopless := ⟨by + rintro u ⟨a,hs,ht⟩ + exact hloop a (hs.trans ht.symm)⟩ + +variable (hloop : ∀ a, Q.source a≠Q.target a) + +noncomputable def meshChosenArrow {u v : U} (h : (meshQuiverGraph Q U hloop).Adj u v) : A := + h.choose + +lemma meshChosenArrow_source {u v : U} (h : (meshQuiverGraph Q U hloop).Adj u v) : + Q.source (meshChosenArrow Q U hloop h)=u.val := h.choose_spec.1 + +lemma meshChosenArrow_target {u v : U} (h : (meshQuiverGraph Q U hloop).Adj u v) : + Q.target (meshChosenArrow Q U hloop h)=v.val := h.choose_spec.2 + +lemma meshChosenArrow_eq (hsimple : QuiverSimpleOn Q U) {u v : U} + (h : (meshQuiverGraph Q U hloop).Adj u v) (a : A) + (hs : Q.source a=u.val) (ht : Q.target a=v.val) : meshChosenArrow Q U hloop h=a := + hsimple _ a ((meshChosenArrow_source Q U hloop h).symm ▸ u.property) + ((meshChosenArrow_target Q U hloop h).symm ▸ v.property) + ((meshChosenArrow_source Q U hloop h).trans hs.symm) + ((meshChosenArrow_target Q U hloop h).trans ht.symm) + +lemma meshChosenArrow_reverse (hsimple : QuiverSimpleOn Q U) {u v : U} + (h : (meshQuiverGraph Q U hloop).Adj u v) : + meshChosenArrow Q U hloop h.symm=Q.reverse (meshChosenArrow Q U hloop h) := by + apply meshChosenArrow_eq Q U hloop hsimple + · rw [Q.source_reverse,meshChosenArrow_target] + · rw [Q.target_reverse,meshChosenArrow_source] + +noncomputable def meshQuiverNeighborEquiv (hsimple : QuiverSimpleOn Q U) (v : U) : + {u : U // (meshQuiverGraph Q U hloop).Adj u v} ≃ + {a : A // Q.source a=v.val ∧ Q.target a∈U} where + toFun u := ⟨meshChosenArrow Q U hloop u.property.symm, + meshChosenArrow_source Q U hloop u.property.symm, + (meshChosenArrow_target Q U hloop u.property.symm).symm ▸ u.val.property⟩ + invFun a := ⟨⟨Q.target a.val,a.property.2⟩, + ⟨Q.reverse a.val,Q.source_reverse a.val,(Q.target_reverse a.val).trans a.property.1⟩⟩ + left_inv u := by + apply Subtype.ext + apply Subtype.ext + exact meshChosenArrow_target Q U hloop u.property.symm + right_inv a := by + apply Subtype.ext + apply meshChosenArrow_eq Q U hloop hsimple + · exact a.property.1 + · rfl + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiverAlgebra.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiverAlgebra.lean new file mode 100644 index 0000000000000000000000000000000000000000..efe31ca14e64f4f1b0687f173c7ef59fc16b5a8f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiverAlgebra.lean @@ -0,0 +1,104 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshQuiverWords + +namespace OAI + +/-! Finite positive Cartan quivers satisfy the explicit mesh ideal bound. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A R : Type} [Fintype V] [Fintype A] + (Q : ReversibleQuiver V A) (U : Set V) + (hloop : ∀ a, Q.source a≠Q.target a) (hsimple : QuiverSimpleOn Q U) + [Ring R] [Algebra ℂ R] +noncomputable local instance (priority := 2000) meshRegionDecEq : DecidableEq U := Classical.decEq U +include hsimple + +omit [Algebra ℂ R] in +lemma meshArrowValues_relation (B : A → R) + (houtside : ∀ a, Q.source a∉U ∨ Q.target a∉U → B a=0) + (hmesh : ∀ v∈U, (∑ a, if Q.source a=v then B a*B (Q.reverse a) else 0)=0) + (v : U) : + (∑ u : {u : U // (meshQuiverGraph Q U hloop).Adj u v}, + meshArrowValues Q U hloop B v u.val u.property.symm * + meshArrowValues Q U hloop B u.val v u.property)=0 := by + let p : A → Prop := fun a => Q.source a=v.val ∧ Q.target a∈U + let f : A → R := fun a => if Q.source a=v.val then B a*B (Q.reverse a) else 0 + have hrest : (∑ a : {a : A // ¬p a}, f a)=0 := by + apply Finset.sum_eq_zero + intro a _ + by_cases hs : Q.source a=v.val + · have ht : Q.target a∉U := fun ht => a.property ⟨hs,ht⟩ + simp only [f,hs,ite_true,houtside a (Or.inr ht),zero_mul] + · simp only [f,hs,ite_false] + have hsum := Fintype.sum_subtype_add_sum_subtype p f + rw [hrest,add_zero] at hsum + calc + _ = ∑ a : {a : A // p a}, B a*B (Q.reverse a) := by + apply Fintype.sum_equiv (meshQuiverNeighborEquiv Q U hloop hsimple v) + intro u + change B (meshChosenArrow Q U hloop u.property.symm) * + B (meshChosenArrow Q U hloop u.property)= + B (meshChosenArrow Q U hloop u.property.symm) * + B (Q.reverse (meshChosenArrow Q U hloop u.property.symm)) + rw [←meshChosenArrow_reverse Q U hloop hsimple u.property.symm] + _ = ∑ a : {a : A // p a}, f a := by + apply Finset.sum_congr rfl + intro a _ + exact (ite_eq_left a.property.1).symm + _ = ∑ a, f a := hsum + _ = 0 := hmesh v.val v.property + +theorem quiver_mesh_words_vanish + (hcartan : ((2 : ℝ) • (1 : Matrix U U ℝ)-(meshQuiverGraph Q U hloop).adjMatrix ℝ).PosDef) + (B : A → R) + (houtside : ∀ a, Q.source a∉U ∨ Q.target a∉U → B a=0) + (hpath : ∀ a b, Q.target a≠Q.source b → B a*B b=0) + (hmesh : ∀ v∈U, (∑ a, if Q.source a=v then B a*B (Q.reverse a) else 0)=0) : + ∃ N : ℕ, 0 φ (FreeAlgebra.ι ℂ a) + have hmem (z : FreeAlgebra ℂ A) : z∈I ↔ φ z=0 := by + have hk : z∈TwoSidedIdeal.ker I.ringCon.mk' ↔ z∈I := by + rw [TwoSidedIdeal.ker_ringCon_mk'] + exact hk.symm.trans (TwoSidedIdeal.mem_ker I.ringCon.mk') + have houtside : ∀ a, Q.source a∉U ∨ Q.target a∉U → B a=0 := by + intro a ha + apply (hmem _).mp + exact TwoSidedIdeal.subset_span (Or.inl (Or.inl ⟨a,ha,rfl⟩)) + have hpath : ∀ a b, Q.target a≠Q.source b → B a*B b=0 := by + intro a b hab + change φ (FreeAlgebra.ι ℂ a)*φ (FreeAlgebra.ι ℂ b)=0 + rw [←map_mul] + apply (hmem _).mp + exact TwoSidedIdeal.subset_span (Or.inl (Or.inr ⟨a,b,hab,rfl⟩)) + have hmesh : ∀ v∈U, (∑ a, if Q.source a=v then B a*B (Q.reverse a) else 0)=0 := by + intro v hv + have hz : φ (meshRelation Q v)=0 := (hmem _).mp + (TwoSidedIdeal.subset_span (Or.inr ⟨v,hv,rfl⟩)) + simpa only [meshRelation,map_sum,apply_ite,map_mul,map_zero] using hz + obtain ⟨N,hN,hwords⟩ := quiver_mesh_words_vanish Q U hloop hsimple hcartan B houtside hpath hmesh + refine ⟨N,hN,?_⟩ + intro w hw + apply (hmem _).mpr + simpa only [B,map_list_prod,List.map_map,Function.comp_def] using hwords w hw + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiverWords.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiverWords.lean new file mode 100644 index 0000000000000000000000000000000000000000..c6cf9a16f1531189dbf93ff0edc8e03410364676 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshQuiverWords.lean @@ -0,0 +1,70 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshQuiver + +namespace OAI + +/-! Nonzero arrow words are actual paths in the induced simple graph. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A R : Type} (Q : ReversibleQuiver V A) (U : Set V) + (hloop : ∀ a, Q.source a≠Q.target a) (hsimple : QuiverSimpleOn Q U) + [Ring R] + +noncomputable def meshArrowValues (B : A → R) (u v : U) + (h : (meshQuiverGraph Q U hloop).Adj u v) : R := + B (meshChosenArrow Q U hloop h) + +include hsimple in +/-- The outside and noncomposable relations leave only genuine paths. +The last-vertex annihilation statement is maintained in the induction. -/ +theorem mesh_word_is_path (B : A → R) + (houtside : ∀ a, Q.source a∉U ∨ Q.target a∉U → B a=0) + (hpath : ∀ a b, Q.target a≠Q.source b → B a*B b=0) (w : List A) : + (w.map B).prod=0 ∨ w=[] ∨ + ∃ (v : U) (p : MeshPaths (meshQuiverGraph Q U hloop) w.length v), + meshPathEvaluate (meshQuiverGraph Q U hloop) (meshArrowValues Q U hloop B) + w.length v p=(w.map B).prod ∧ + ∀ a, Q.source a≠v.val → (w.map B).prod*B a=0 := by + induction w using List.reverseRecOn with + | nil => exact Or.inr (Or.inl rfl) + | append_singleton w a ih => + by_cases hz : ((w++[a]).map B).prod=0 + · exact Or.inl hz + have heq : ((w++[a]).map B).prod=(w.map B).prod*B a := by simp + have hBa : B a≠0 := by + intro ha + apply hz + rw [heq,ha,mul_zero] + have hSa : Q.source a∈U := by + by_contra h + exact hBa (houtside a (Or.inl h)) + have hTa : Q.target a∈U := by + by_contra h + exact hBa (houtside a (Or.inr h)) + let target : U := ⟨Q.target a,hTa⟩ + have hkill : ∀ b, Q.source b≠target.val → ((w++[a]).map B).prod*B b=0 := by + intro b hb + rw [heq,mul_assoc,hpath a b hb.symm,mul_zero] + right + right + rcases ih with hw | hw | ⟨v,p,hp,hv⟩ + · exact (hz (by rw [heq,hw,zero_mul])).elim + · subst w + let source : U := ⟨Q.source a,hSa⟩ + have edge : (meshQuiverGraph Q U hloop).Adj source target := ⟨a,rfl,rfl⟩ + refine ⟨target,⟨⟨source,edge⟩,PUnit.unit⟩,?_,hkill⟩ + simp only [List.nil_append,List.length_singleton,List.map_singleton,List.prod_singleton] + change 1*B (meshChosenArrow Q U hloop edge)=B a + rw [one_mul,meshChosenArrow_eq Q U hloop hsimple edge a rfl rfl] + · have hsource : Q.source a=v.val := by + by_contra h + exact hz (heq.trans (hv a h)) + have edge : (meshQuiverGraph Q U hloop).Adj v target := ⟨a,hsource,rfl⟩ + rw [List.length_append,List.length_singleton] + refine ⟨target,⟨⟨v,edge⟩,p⟩,?_,hkill⟩ + change meshPathEvaluate (meshQuiverGraph Q U hloop) (meshArrowValues Q U hloop B) + w.length v p * B (meshChosenArrow Q U hloop edge)=_ + rw [hp,meshChosenArrow_eq Q U hloop hsimple edge a hsource rfl,heq] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshSpectralUpper.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshSpectralUpper.lean new file mode 100644 index 0000000000000000000000000000000000000000..de09836211b1bfa70feeb9c6a6c4bd29ce23f804 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshSpectralUpper.lean @@ -0,0 +1,35 @@ +import Mathlib + +namespace OAI + +/-! A finite-dimensional spectral bound used to choose positive mesh weights. -/ +namespace HarmonicArtin.ParabolicIntersections +open Unitary +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] + +lemma mesh_spectral_upper {A : Matrix V V ℝ} (hA : A.IsHermitian) (d : ℝ) + (hbound : ∀ i, hA.eigenvalues i≤d) : + (d • (1 : Matrix V V ℝ)-A).PosSemidef := by + let U := hA.eigenvectorUnitary + let D := Matrix.diagonal hA.eigenvalues + have hspec : A=conjStarAlgAut ℝ _ U D := by + simpa [U,D] using hA.spectral_theorem + have hdiag : d • (1 : Matrix V V ℝ)-D=Matrix.diagonal (fun i => d-hA.eigenvalues i) := by + ext i j + by_cases hij : i=j + · subst j; simp [D] + · simp [D,hij] + have hd : (d • (1 : Matrix V V ℝ)-D).PosSemidef := by + rw [hdiag,Matrix.posSemidef_diagonal_iff] + intro i + exact sub_nonneg.mpr (hbound i) + have he : d • (1 : Matrix V V ℝ)-A= + conjStarAlgAut ℝ _ U (d • (1 : Matrix V V ℝ)-D) := by + rw [map_sub,map_smul,map_one,←hspec] + rw [he,conjStarAlgAut_apply] + exact hd.mul_mul_conjTranspose_same _ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshTrace.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshTrace.lean new file mode 100644 index 0000000000000000000000000000000000000000..741f2b9e34d75604de4701c6c9643cc39893315b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshTrace.lean @@ -0,0 +1,96 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshProjectionAlgebra +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshPathSpaces + +namespace OAI + +/-! Positive weighted traces detect vanishing of all endpoint projections. -/ +namespace HarmonicArtin.ParabolicIntersections +open scoped ComplexOrder +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} [Fintype V] + +noncomputable def meshWeightedTrace {D : V → Type} [∀ v, Fintype (D v)] + (μ : V → ℝ) (P : ∀ v, Matrix (D v) (D v) ℂ) : ℂ := + ∑ v, (μ v : ℂ)*Matrix.trace (P v) + +lemma meshWeightedTrace_nonneg {D : V → Type} [∀ v, Fintype (D v)] + (μ : V → ℝ) (hμ : ∀ v, 0≤μ v) (P : ∀ v, Matrix (D v) (D v) ℂ) + (hstar : ∀ v, (P v).conjTranspose=P v) (hsq : ∀ v, P v*P v=P v) : + 0≤(meshWeightedTrace μ P).re := by + simp only [meshWeightedTrace,Complex.re_sum,Complex.mul_re, + Complex.ofReal_re,Complex.ofReal_im,zero_mul,sub_zero] + exact Finset.sum_nonneg (fun v _ => mul_nonneg (hμ v) + (mesh_projection_trace (P v) (hstar v) (hsq v)).1) + +/-- Strict positivity of the vertex weights turns a zero weighted trace +of orthogonal projections into the vanishing of each projection. -/ +theorem meshWeightedTrace_zero {D : V → Type} [∀ v, Fintype (D v)] + (μ : V → ℝ) (hμ : ∀ v, 0<μ v) (P : ∀ v, Matrix (D v) (D v) ℂ) + (hstar : ∀ v, (P v).conjTranspose=P v) (hsq : ∀ v, P v*P v=P v) + (hz : meshWeightedTrace μ P=0) : ∀ v, P v=0 := by + have hpos : ∀ v, (P v).PosSemidef := by + intro v + have h := Matrix.posSemidef_conjTranspose_mul_self (P v) + rwa [hstar v,hsq v] at h + have ht : ∀ v, 0≤(Matrix.trace (P v)).re := fun v => + (Complex.nonneg_iff.mp (hpos v).trace_nonneg).1 + have hsum : (∑ v, μ v*(Matrix.trace (P v)).re)=0 := by + have h := congrArg Complex.re hz + simpa only [meshWeightedTrace,Complex.re_sum,Complex.mul_re, + Complex.ofReal_re,Complex.ofReal_im,zero_mul,sub_zero,Complex.zero_re] using h + have heach := Finset.sum_eq_zero_iff_of_nonneg + (fun v (_ : v∈Finset.univ) => mul_nonneg (hμ v).le (ht v)) + intro v + have hv : μ v*(Matrix.trace (P v)).re=0 := heach.mp hsum v (Finset.mem_univ v) + have hreal : (Matrix.trace (P v)).re=0 := + (mul_eq_zero.mp hv).resolve_left (ne_of_gt (hμ v)) + have himag : (Matrix.trace (P v)).im=0 := + (Complex.nonneg_iff.mp (hpos v).trace_nonneg).2.symm + have htrace : Matrix.trace (P v)=0 := Complex.ext hreal himag + exact (mesh_projection_trace (P v) (hstar v) (hsq v)).2.mp htrace + +variable (G : SimpleGraph V) + +lemma meshExtend_trace {n : ℕ} + (P : ∀ v, Matrix (MeshPaths G n v) (MeshPaths G n v) ℂ) (v : V) : + Matrix.trace (meshExtendMatrix G P v)= + ∑ u : {u : V // G.Adj u v}, Matrix.trace (P u.val) := by + exact Matrix.trace_blockDiagonal' _ + +/-- Reversal of an oriented edge exchanges the two endpoint sums. -/ +def meshEdgeFlip : (Σ v : V, {u : V // G.Adj u v}) ≃ + (Σ v : V, {u : V // G.Adj u v}) where + toFun p := ⟨p.2.val,⟨p.1,p.2.property.symm⟩⟩ + invFun p := ⟨p.2.val,⟨p.1,p.2.property.symm⟩⟩ + left_inv := by rintro ⟨v,⟨u,h⟩⟩; rfl + right_inv := by rintro ⟨v,⟨u,h⟩⟩; rfl + +/-- Extension multiplies the weighted trace by the Perron eigenvalue. -/ +lemma meshWeightedTrace_extend (μ : V → ℝ) (δ : ℝ) + (heigen : ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=δ*μ v) + {n : ℕ} (P : ∀ v, Matrix (MeshPaths G n v) (MeshPaths G n v) ℂ) : + meshWeightedTrace μ (meshExtendMatrix G P)= + (δ : ℂ)*meshWeightedTrace μ P := by + unfold meshWeightedTrace + simp_rw [meshExtend_trace] + conv_lhs => simp only [Finset.mul_sum] + rw [←Fintype.sum_sigma (fun p : Σ v : V, {u : V // G.Adj u v} => + (μ p.1 : ℂ)*Matrix.trace (P p.2.val))] + calc + (∑ p : Σ v : V, {u : V // G.Adj u v}, + (μ p.1 : ℂ)*Matrix.trace (P p.2.val)) = + ∑ p : Σ v : V, {u : V // G.Adj u v}, + (μ p.2.val : ℂ)*Matrix.trace (P p.1) := by + apply Fintype.sum_equiv (meshEdgeFlip G) + intro p + rfl + _ = ∑ v, (∑ u : {u : V // G.Adj u v}, (μ u : ℂ))*Matrix.trace (P v) := by + rw [Fintype.sum_sigma] + simp only [Finset.sum_mul] + _ = (δ : ℂ)*∑ v, (μ v : ℂ)*Matrix.trace (P v) := by + simp_rw [←Complex.ofReal_sum,heigen,Complex.ofReal_mul,mul_assoc] + rw [Finset.mul_sum] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MetricUnitCurves.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MetricUnitCurves.lean new file mode 100644 index 0000000000000000000000000000000000000000..2f73d0862212591dfb56391e65f7e6f20bab1982 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MetricUnitCurves.lean @@ -0,0 +1,101 @@ +import Mathlib.Topology.MetricSpace.Isometry +import Mathlib.Tactic.Linarith + +namespace OAI + +/-! Concatenation of unit-speed curves and realization of distance. -/ +namespace HarmonicArtin.ParabolicIntersections.GraphRealization +variable {X : Type} [MetricSpace X] + +def HasCurve (x y : X) (L : ℝ) : Prop := + ∃ f : ℝ → X,(∀ s t,dist (f s) (f t) ≤ |s-t|) ∧ f 0=x ∧ f L=y + +lemma curve_const (x : X) : HasCurve x x 0 := + ⟨fun _ => x,fun _ _ => by simp,rfl,rfl⟩ + +lemma curve_subsegment (f : ℝ → X) (hf : ∀ s t,dist (f s) (f t) ≤ |s-t|) + (a b : ℝ) : HasCurve (f a) (f b) |a-b| := by + by_cases hab : a ≤ b + · refine ⟨fun t => f (a+t),?_,by simp,?_⟩ + · intro s t + simpa only [add_sub_add_left_eq_sub] using hf (a+s) (a+t) + · apply congrArg f + rw [abs_of_nonpos (sub_nonpos.mpr hab)] + ring + · refine ⟨fun t => f (a-t),?_,by simp,?_⟩ + · intro s t + have he : (a-s)-(a-t)=t-s := by ring + simpa only [he,abs_sub_comm t s] using hf (a-s) (a-t) + · apply congrArg f + rw [abs_of_nonneg (sub_nonneg.mpr (le_of_not_ge hab))] + ring + +lemma curve_reverse {x y : X} {L : ℝ} (hc : HasCurve x y L) : HasCurve y x L := by + obtain ⟨f,hf,hx,hy⟩ := hc + refine ⟨fun t => f (L-t),?_,by simpa using hy,by simpa using hx⟩ + intro s t + have he : (L-s)-(L-t)=t-s := by ring + simpa only [he,abs_sub_comm t s] using hf (L-s) (L-t) + +lemma curve_concat {x y z : X} {L K : ℝ} (hL : 0 ≤ L) (hK : 0 ≤ K) + (hc : HasCurve x y L) (hd : HasCurve y z K) : HasCurve x z (L+K) := by + obtain ⟨f,hf,hx,hy⟩ := hc + obtain ⟨g,hg,hy',hz⟩ := hd + let F (t : ℝ) := if t ≤ L then f t else g (t-L) + have hbound (s t : ℝ) (hst : s ≤ t) : dist (F s) (F t) ≤ |s-t| := by + by_cases hs : s ≤ L <;> by_cases ht : t ≤ L + · simpa only [F,ite_eq_left hs,ite_eq_left ht] using hf s t + · have hm : dist (f s) (g (t-L)) ≤ dist (f s) (f L)+dist (g 0) (g (t-L)) := by + rw [hy,hy'] + exact dist_triangle (f s) y (g (t-L)) + have h₁ := hf s L + have h₂ := hg 0 (t-L) + rw [abs_of_nonpos (sub_nonpos.mpr hs)] at h₁ + rw [abs_of_nonpos (by linarith : 0-(t-L) ≤ 0)] at h₂ + simp only [F,ite_eq_left hs,ite_eq_right ht] + rw [abs_of_nonpos (sub_nonpos.mpr hst)] + linarith + · exact False.elim (hs (hst.trans ht)) + · have he : (s-L)-(t-L)=s-t := by ring + simpa only [F,ite_eq_right hs,ite_eq_right ht,he] using hg (s-L) (t-L) + refine ⟨F,?_,?_,?_⟩ + · intro s t + rcases le_total s t with h|h + · exact hbound s t h + · simpa only [dist_comm,abs_sub_comm] using hbound t s h + · simpa only [F,ite_eq_left hL] using hx + · by_cases hK' : K=0 + · subst K + have he : y=z := hy'.symm.trans hz + simpa only [add_zero,F,ite_eq_left le_rfl,he] using hy + · have hKpos : 0 < K := lt_of_le_of_ne hK (Ne.symm hK') + have hLK : ¬L+K ≤ L := by linarith + simpa only [F,ite_eq_right hLK,add_sub_cancel_left] using hz + +/-- A unit-speed curve whose length is the endpoint distance is a geodesic. -/ +lemma curve_realizes_distance {x y : X} (hc : HasCurve x y (dist x y)) : + ∃ γ : Set.Icc (0 : ℝ) (dist x y) → X, Isometry γ ∧ + γ ⟨0,le_rfl,dist_nonneg⟩=x ∧ γ ⟨dist x y,dist_nonneg,le_rfl⟩=y := by + obtain ⟨f,hf,hx,hy⟩ := hc + refine ⟨fun t => f t,?_,hx,hy⟩ + apply isometry_iff_dist_eq.mpr + intro a b + change dist (f a) (f b)=|(a : ℝ)-b| + apply le_antisymm (hf a b) + have lower (a b : Set.Icc (0 : ℝ) (dist x y)) (hab : (a : ℝ) ≤ b) : + |(a : ℝ)-b| ≤ dist (f a) (f b) := by + have h₁ := hf 0 a + have h₂ := hf b (dist x y) + rw [hx,abs_of_nonpos (by linarith [a.property.1] : 0-(a : ℝ) ≤ 0)] at h₁ + rw [hy,abs_of_nonpos (sub_nonpos.mpr b.property.2)] at h₂ + have h₃ := dist_triangle x (f a) y + have h₄ := dist_triangle (f a) (f b) y + rw [abs_of_nonpos (sub_nonpos.mpr hab)] + linarith + rcases le_total (a : ℝ) b with h|h + · exact lower a b h + · simpa only [dist_comm,abs_sub_comm] using lower b a h + +end HarmonicArtin.ParabolicIntersections.GraphRealization + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NonCliqueDynamics.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NonCliqueDynamics.lean new file mode 100644 index 0000000000000000000000000000000000000000..13dbb25ec03f597e7886a4334eb1a37afeb30c98 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NonCliqueDynamics.lean @@ -0,0 +1,53 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MainIntersection +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsDefinitions + +namespace OAI + +/-! +# Corollary 1.3 of paper 082-03 + +The published inputs are Charney--Martin--Morris-Wright, +*Acylindrical hyperbolicity for Artin groups with a visual splitting*, +Algebraic & Geometric Topology 26 (2026), 1507--1528, +Theorem 3.2 and Proposition 4.2; also arXiv:2404.11393, pp. 9, 14. +https://msp.org/agt/2026/26-4/agt-v26-n4-p08-p.pdf +https://arxiv.org/pdf/2404.11393 + +Their hypotheses concern the edge group of an actual visual splitting. +The required parabolic-intersection premise is proved by `parabolic_intersections`, +rather than postulated as part of these published inputs. +-/ +namespace HarmonicArtin.ParabolicIntersections +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- The exact two published implications used by the target corollary. -/ +structure PublishedVisualSplitting : Prop where + edge_criterion : IsIrreducible M → ∀ Y Z : Set S, IsVisualSplit M Y Z → + (∀ g h : Artin M, IsParabolic M + (conjugate g (artinParabolic M (Y ∩ Z)) ⊓ conjugate h (artinParabolic M (Y ∩ Z)))) → + AcylindricallyHyperbolic (Artin M) ∧ WeaklyMalnormal (artinParabolic M (Y ∩ Z)) + proper_criterion : IsIrreducible M → ∀ Y Z : Set S, IsVisualSplit M Y Z → + WeaklyMalnormal (artinParabolic M (Y ∩ Z)) → + ∀ P : Subgroup (Artin M), IsParabolic M P → P ≠ ⊤ → WeaklyMalnormal P + +local instance : LinearOrder (S⊕Unit) := Sum.Lex.linearOrder + +/-- Corollary 1.3 in full: acylindrical hyperbolicity and weak malnormality +of every proper parabolic for every irreducible non-clique Artin matrix. -/ +theorem nonclique_dynamics + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hPub : ∀ X : Set S, PublishedSphericalInputs (relativeMatrix M X)) + (hVisual : PublishedVisualSplitting M) + (hIrred : IsIrreducible M) (hInf : ∃ s t : S, s ≠ t ∧ M s t=0) : + AcylindricallyHyperbolic (Artin M) ∧ + ∀ P : Subgroup (Artin M), IsParabolic M P → P ≠ ⊤ → WeaklyMalnormal P := by + obtain ⟨s,t,hst,hlabel⟩ := hInf + have hsplit := infinite_pair_visual_split M s t hst hlabel + obtain ⟨hAH,hEdge⟩ := hVisual.edge_criterion hIrred {s}ᶜ {t}ᶜ hsplit (by + intro g h + exact parabolic_intersections M hEmb hPub _ _ g h) + exact ⟨hAH,hVisual.proper_criterion hIrred {s}ᶜ {t}ᶜ hsplit hEdge⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NoncommutingGraph.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NoncommutingGraph.lean new file mode 100644 index 0000000000000000000000000000000000000000..aace0daaab77aa084663119da3d51135e7346831 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NoncommutingGraph.lean @@ -0,0 +1,50 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsDefinitions +import Mathlib.Combinatorics.SimpleGraph.Acyclic + +namespace OAI + +/-! Irreducibility is connectedness of the noncommutation graph. -/ +namespace HarmonicArtin.ParabolicIntersections +variable {S : Type} (M : CoxeterMatrix S) + +def noncommutingGraph : SimpleGraph S where + Adj a b := a≠b ∧ M a b≠2 + symm := ⟨by + intro a b h + exact ⟨h.1.symm,fun he => h.2 ((M.symmetric a b).trans he)⟩⟩ + loopless := ⟨by intro a h; exact h.1 rfl⟩ + +lemma noncommuting_reachable (hIrred : IsIrreducible M) (s t : S) : + (noncommutingGraph M).Reachable s t := by + by_contra ht + let X : Set S := {v | (noncommutingGraph M).Reachable s v} + obtain ⟨a,ha,b,hb,hm⟩ := hIrred X ⟨s,SimpleGraph.Reachable.rfl⟩ ⟨t,ht⟩ + have hab : a≠b := fun he => hb (he ▸ ha) + exact hb (ha.trans (show (noncommutingGraph M).Adj a b from ⟨hab,hm⟩).reachable) + +/-- A list with a term outside a set has an initial segment whose last +term is the first outside term. -/ +lemma list_first_outside (C : Set S) (l : List S) (h : ∃ s∈l,s∉C) : + ∃ u s v, l=u++s::v ∧ (∀ t∈u,t∈C) ∧ s∉C := by + induction l with + | nil => simp at h + | cons a l ih => + by_cases ha : a∈C + · have hl : ∃ s∈l,s∉C := by + obtain ⟨s,hs,hsc⟩ := h + rcases List.mem_cons.mp hs with rfl|hs + · exact (hsc ha).elim + · exact ⟨s,hs,hsc⟩ + obtain ⟨u,s,v,he,hu,hs⟩ := ih hl + refine ⟨a::u,s,v,?_,?_,hs⟩ + · rw [he] + rfl + · intro t ht + rcases List.mem_cons.mp ht with rfl|ht + · exact ha + · exact hu t ht + · exact ⟨[],a,l,rfl,by simp,ha⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NormalParabolic.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NormalParabolic.lean new file mode 100644 index 0000000000000000000000000000000000000000..c380d826022fbf65b4ed1b1fc5adad9843e7e1e7 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NormalParabolic.lean @@ -0,0 +1,113 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsDefinitions +import OAI.Topology.ArtinGroups.Coxeter.ArtinCoxeter +import OAI.Topology.ArtinGroups.Geometry.CoordinateExtension + +namespace OAI + +/-! +# Normal parabolics in irreducible Artin groups + +This proves the sufficient case of Charney--Martin--Morris-Wright (2026), +Lemma 3.3, used in the visual-splitting argument. The obstruction is detected +in the actual Coxeter geometric representation, without any assumption on +positive-monoid embeddings. +-/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) + +omit [Fintype S] in +lemma artinCoxeter_mem_parabolic {X : Set S} {a : Artin M} + (ha : a ∈ artinParabolic M X) : + artinCoxeter M a ∈ coxeterParabolic M X := by + induction ha using Subgroup.closure_induction with + | mem x hx => + obtain ⟨s,hs,rfl⟩ := hx + rw [artinCoxeter_generator] + exact Subgroup.subset_closure ⟨s,hs,rfl⟩ + | one => rw [map_one]; exact Subgroup.one_mem _ + | mul x y hx hy ihx ihy => rw [map_mul]; exact Subgroup.mul_mem _ ihx ihy + | inv x hx ih => rw [map_inv]; exact Subgroup.inv_mem _ ih + +/-- The standard generators in a standard parabolic are exactly its type. -/ +lemma generator_mem_standard_iff (X : Set S) (t : S) : + generator M t ∈ artinParabolic M X ↔ t∈X := by + constructor + · intro h + by_contra ht + have he := parabolic_exterior M X ⟨_,artinCoxeter_mem_parabolic M h⟩ + (Pi.single t 1) t ht + change representation M.toCoxeterSystem (artinCoxeter M (generator M t)) + (Pi.single t 1) t=(Pi.single t 1 : S → ℝ) t at he + rw [artinCoxeter_generator,representation_simple,simpleReflection_apply] at he + simp only [Pi.sub_apply,Pi.smul_apply,smul_eq_mul,Pi.single_eq_same, + Matrix.mulVec_single,Matrix.col,Matrix.transpose_apply,MulOpposite.op_one, + one_smul,cartan_diag] at he + norm_num at he + · intro ht + exact Subgroup.subset_closure ⟨t,ht,rfl⟩ + +lemma standard_ne_top_of_ne_univ {X : Set S} (hX : X≠Set.univ) : + artinParabolic M X≠⊤ := by + intro he + apply hX + apply Set.eq_univ_of_forall + intro t + apply (generator_mem_standard_iff M X t).mp + rw [he] + trivial + +omit [Fintype S] in +lemma cartan_ne_zero_of_not_commuting (s t : S) (hst : s ≠ t) (hlabel : M s t ≠ 2) : + cartan M s t ≠ 0 := by + by_cases hz : M s t=0 + · simp [cartan,hst,hz] + · have hm : 3 ≤ M s t := by have := M.off_diagonal s t hst; omega + have hmr : (2 : ℝ) ht (he ▸ hs) + have hc := cartan_ne_zero_of_not_commuting M s t hst hlabel + have he := parabolic_exterior M X ⟨_,artinCoxeter_mem_parabolic M h⟩ + (Pi.single t 1) t ht + have hinv : (simpleReflection M t)⁻¹=simpleReflection M t := by + exact inv_eq_of_mul_eq_one_left (simpleReflection_squared M t) + simp only [map_mul,map_inv,artinCoxeter_generator,representation_simple,hinv, + LinearEquiv.mul_apply] at he + rw [simpleReflection_apply,simpleReflection_apply,simpleReflection_apply] at he + simp only [Pi.sub_apply,Pi.smul_apply,smul_eq_mul,Pi.single_eq_same, + Matrix.mulVec_sub,Matrix.mulVec_smul,Matrix.mulVec_single, + Matrix.col,Matrix.transpose_apply,MulOpposite.op_one,one_smul,cartan_diag, + Pi.single_eq_of_ne hst.symm] at he + rw [cartan_symm M t s] at he + nlinarith [sq_pos_of_ne_zero hc] + +/-- CMMW Lemma 3.3: in irreducible type a normal standard parabolic is +trivial or the whole Artin group. -/ +theorem normal_standard_parabolic (hIrred : IsIrreducible M) (X : Set S) + (hn : (artinParabolic M X).Normal) : X=∅ ∨ X=Set.univ := by + by_cases hx : X=∅ + · exact Or.inl hx + right + by_contra hu + have hx' : X.Nonempty := Set.nonempty_iff_ne_empty.mpr hx + have hu' : Xᶜ.Nonempty := Set.nonempty_compl.mpr hu + obtain ⟨s,hs,t,ht,hst⟩ := hIrred X hx' hu' + have hgen : generator M s ∈ artinParabolic M X := Subgroup.subset_closure ⟨s,hs,rfl⟩ + exact generator_conjugate_not_mem M hs ht hst (hn.conj_mem _ hgen _) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NormalizerAlgebra.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NormalizerAlgebra.lean new file mode 100644 index 0000000000000000000000000000000000000000..b650d46eb33a4fe0e867edfbd03366395032d6b9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NormalizerAlgebra.lean @@ -0,0 +1,40 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.Basic + +namespace OAI + +/-! Normalizing a subgroup can be tested outside any proper subgroup. -/ +namespace HarmonicArtin.ParabolicIntersections +variable {G : Type*} [Group G] + +lemma conjugate_eq_map (g : G) (P : Subgroup G) : + conjugate g P=P.map (MulAut.conj g).toMonoidHom := by + ext x + rw [mem_conjugate,Subgroup.mem_map_equiv] + rfl + +lemma mem_normalizer_iff_conjugate (g : G) (P : Subgroup G) : + g∈Subgroup.normalizer (P : Set G) ↔ conjugate g P=P := by + rw [Subgroup.mem_normalizer_iff_map_conj_eq] + change (P.map (MulAut.conj g).toMonoidHom=P) ↔ _ + rw [←conjugate_eq_map] + +lemma le_normalizer_of_outside (P K C : Subgroup G) + (ha : ∃ a : G, a∈K ∧ a∉C) + (hn : ∀ g : G, g∈K → g∉C → conjugate g P=P) : + K≤Subgroup.normalizer (P : Set G) := by + obtain ⟨a,ha,haC⟩ := ha + have haN := (mem_normalizer_iff_conjugate a P).mpr (hn a ha haC) + intro g hg + by_cases hgC : g∈C + · have hgaC : g*a∉C := by + intro h + exact haC (by simpa only [inv_mul_cancel_left] using C.mul_mem (C.inv_mem hgC) h) + have hgaN := (mem_normalizer_iff_conjugate (g*a) P).mpr (hn (g*a) (K.mul_mem hg ha) hgaC) + have h := (Subgroup.normalizer (P : Set G)).mul_mem hgaN + ((Subgroup.normalizer (P : Set G)).inv_mem haN) + simpa only [mul_inv_cancel_right] using h + · exact (mem_normalizer_iff_conjugate g P).mpr (hn g hg hgC) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NullBoundary.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NullBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ba3a9ccc5b4f3314bc1929732fb713bea3dbda5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/NullBoundary.lean @@ -0,0 +1,49 @@ +import OAI.Topology.ArtinGroups.Harmonic.Stage + +namespace OAI + +/-! +# The boundary form of the relative null-layer obstruction + +The old universal-frame argument used a boundary generator in degree zero +and therefore applied only above zero. In §5 of paper 082-03 the relative +frame can instead be joined to the isolated layer through a boundary +color at any lower integer degree. This is the saturation contradiction +at that degree. Establishing the occupied boundary for a relative family +is a separate support argument, not a published hypothesis. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable + +variable {S : Type} [Fintype S] [LinearOrder S] {M : CoxeterMatrix S} + +/-- Saturation kills every exterior boundary count below the isolated +layer. Thus a boundary count preserved throughout the permitted orbit +prevents the isolated null-layer configuration, at any integer height. -/ +theorem null_boundary_contradiction (D : IsolatedIterationData M) + (k : ℤ) (hk : k < D.q) (v : S ⊕ Unit) + (hv : v ∉ Sum.inl '' D.I) + (hinc : ∃ u ∈ Sum.inl '' D.I, + fusionFoldedCartan (fusionLabelSize M) (coxeterFusionEdge M) v u < 0) + (hoccupied : ∀ z, D.valid z → + 0 < fusionOrbitMultiplicity (fusionLabelSize M) (coxeterFusionEdge M) + (coxeterFusionEdge_symm M) (coxeterFusionEdge_diag M) + (fun e => le_trans (by norm_num) (fusionLabelSize_ge_four M e)) z D.s k v) + (z : List ((S ⊕ Unit) × Bool)) (hz : D.valid z) (hc : D.capped z) : False := by + obtain ⟨b, hb⟩ := finiteFamily_lowerBound + (fusionQuiver (fusionLabelSize M) (coxeterFusionEdge M) (coxeterFusionEdge_symm M)) + (fusionPacketOrbit (fusionLabelSize M) (coxeterFusionEdge M) + (coxeterFusionEdge_symm M) (coxeterFusionEdge_diag M) z D.s) + obtain ⟨z', hz', hc', _, hs⟩ := D.saturate z hz hc b k hk hb + have hzero := (D.separation z' hz' hc' k hs).1 v hv hinc + have hpositive := hoccupied z' hz' + rw [hzero] at hpositive + exact lt_irrefl 0 hpositive + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/OrbitEdgeGraph.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/OrbitEdgeGraph.lean new file mode 100644 index 0000000000000000000000000000000000000000..cfda80d792b897d4ef7e649d70a6fbc682782fc9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/OrbitEdgeGraph.lean @@ -0,0 +1,111 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeFixedPaths + +namespace OAI + +/-! The connected subtree generated by an orbit of one edge. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (P : Subgroup G) (u v : V) (hne : u≠v) + +def orbitEdgeGraph : SimpleGraph V where + Adj x y := ∃ p∈P, (x=p • u ∧ y=p • v) ∨ (x=p • v ∧ y=p • u) + symm := ⟨by + rintro x y ⟨p,hp,h⟩ + exact ⟨p,hp,h.elim (fun h => Or.inr ⟨h.2,h.1⟩) (fun h => Or.inl ⟨h.2,h.1⟩)⟩⟩ + loopless := ⟨by + rintro x ⟨p,_,h⟩ + rcases h with ⟨hu,hv⟩|⟨hv,hu⟩ + all_goals exact hne ((MulAction.toPerm p).injective (hu.symm.trans hv))⟩ + +lemma orbit_base_adj : (orbitEdgeGraph P u v hne).Adj u v := by + refine ⟨1,P.one_mem,Or.inl ?_⟩ + simp only [one_smul,and_self] + +def orbit_translate (p : G) (hp : p∈P) : + orbitEdgeGraph P u v hne →g orbitEdgeGraph P u v hne where + toFun := (p • ·) + map_rel' := by + rintro x y ⟨q,hq,hxy⟩ + refine ⟨p*q,P.mul_mem hp hq,?_⟩ + rcases hxy with ⟨rfl,rfl⟩|⟨rfl,rfl⟩ + · exact Or.inl ⟨(mul_smul p q u).symm,(mul_smul p q v).symm⟩ + · exact Or.inr ⟨(mul_smul p q v).symm,(mul_smul p q u).symm⟩ + +variable {P u v hne} + +lemma orbit_reachable_generator {A : Set G} (hP : P=Subgroup.closure A) + (hA : ∀ a∈A, a • u=u ∨ a • v=v) {g : G} (hg : g∈P) : + (orbitEdgeGraph P u v hne).Reachable u (g • u) := by + have hg' : g∈Subgroup.closure A := hP ▸ hg + clear hg + induction hg' using Subgroup.closure_induction with + | mem g hg => + rcases hA g hg with hu|hv + · rw [hu] + · have h := (orbit_base_adj P u v hne).reachable.map + (orbit_translate P u v hne g (hP.symm ▸ Subgroup.subset_closure hg)) + change (orbitEdgeGraph P u v hne).Reachable (g • u) (g • v) at h + rw [hv] at h + exact (orbit_base_adj P u v hne).reachable.trans h.symm + | one => + rw [one_smul] + | mul a b ha hb iha ihb => + have h := ihb.map (orbit_translate P u v hne a (hP.symm ▸ ha)) + change (orbitEdgeGraph P u v hne).Reachable (a • u) (a • (b • u)) at h + rw [←mul_smul] at h + exact iha.trans h + | inv a ha ih => + have h := ih.map (orbit_translate P u v hne a⁻¹ (P.inv_mem (hP.symm ▸ ha))) + change (orbitEdgeGraph P u v hne).Reachable (a⁻¹ • u) (a⁻¹ • (a • u)) at h + rw [inv_smul_smul] at h + exact h.symm + +def orbitVertices (P : Subgroup G) (u v : V) : Set V := + {w | ∃ p∈P, w=p • u ∨ w=p • v} + +lemma orbit_reachable {A : Set G} (hP : P=Subgroup.closure A) + (hA : ∀ a∈A, a • u=u ∨ a • v=v) {w : V} (hw : w∈orbitVertices P u v) : + (orbitEdgeGraph P u v hne).Reachable u w := by + obtain ⟨p,hp,rfl|rfl⟩ := hw + · exact orbit_reachable_generator hP hA hp + · have h := (orbit_base_adj P u v hne).reachable.map (orbit_translate P u v hne p hp) + exact (orbit_reachable_generator hP hA hp).trans h + +lemma orbit_adj_mem {x y : V} (h : (orbitEdgeGraph P u v hne).Adj x y) : + x∈orbitVertices P u v ∧ y∈orbitVertices P u v := by + obtain ⟨p,hp,h⟩ := h + rcases h with ⟨rfl,rfl⟩|⟨rfl,rfl⟩ + · exact ⟨⟨p,hp,Or.inl rfl⟩,⟨p,hp,Or.inr rfl⟩⟩ + · exact ⟨⟨p,hp,Or.inr rfl⟩,⟨p,hp,Or.inl rfl⟩⟩ + +lemma orbit_walk_support {x y : V} (p : (orbitEdgeGraph P u v hne).Walk x y) + (hx : x∈orbitVertices P u v) : ∀ w∈p.support,w∈orbitVertices P u v := by + induction p with + | nil => + intro w hw + simp only [SimpleGraph.Walk.support_nil,List.mem_singleton] at hw + subst w + exact hx + | @cons x y z h p ih => + intro w hw + rcases List.mem_cons.mp hw with rfl|hw + · exact hx + · exact ih (orbit_adj_mem h).2 w hw + +lemma orbit_graph_le (T : SimpleGraph V) (hA : PreservesAdj (G := G) T) + (huv : T.Adj u v) : orbitEdgeGraph P u v hne≤T := by + rintro x y ⟨p,_,h⟩ + rcases h with ⟨rfl,rfl⟩|⟨rfl,rfl⟩ + · exact hA p huv + · exact (hA p huv).symm + +lemma orbit_smul_mem {p : G} (hp : p∈P) {x : V} + (hx : x∈orbitVertices P u v) : p • x∈orbitVertices P u v := by + obtain ⟨q,hq,rfl|rfl⟩ := hx + · exact ⟨p*q,P.mul_mem hp hq,Or.inl (mul_smul p q u).symm⟩ + · exact ⟨p*q,P.mul_mem hp hq,Or.inr (mul_smul p q v).symm⟩ + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicCore.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicCore.lean new file mode 100644 index 0000000000000000000000000000000000000000..07411e8c6c662df9e7a22b0fda7cd1a860074bb7 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicCore.lean @@ -0,0 +1,72 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.UnconditionalMain +import OAI.Topology.ArtinGroups.ParabolicIntersections.NormalParabolic + +namespace OAI + +/-! The normal core of every proper parabolic in irreducible type is trivial. +The arbitrary-intersection theorem also supplies a finite list of conjugates +realizing this core. These are the algebraic inputs to the tree argument. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable + +variable {G : Type*} [Group G] + +lemma normalCore_eq_sInf_conjugates (P : Subgroup G) : + P.normalCore=sInf (Set.range (fun g : G => conjugate g P)) := by + rw [sInf_range] + ext x + simp only [Subgroup.mem_iInf,mem_conjugate] + change (∀ g : G, g*x*g⁻¹∈P) ↔ ∀ g : G, g⁻¹*x*g∈P + constructor <;> intro h g <;> simpa only [inv_inv] using h g⁻¹ + +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +omit [LinearOrder S] in +/-- The conjugate form of CMMW Lemma 3.3. -/ +theorem normal_parabolic (hIrred : IsIrreducible M) + (P : Subgroup (Artin M)) (hP : IsParabolic M P) (hn : P.Normal) : + P=⊥ ∨ P=⊤ := by + obtain ⟨X,g,rfl⟩ := hP + have hn' : (conjugate g⁻¹ (conjugate g (artinParabolic M X))).Normal := by + exact hn.comap (MulAut.conj (g⁻¹)⁻¹).toMonoidHom + rw [conjugate_inv_cancel] at hn' + rcases normal_standard_parabolic M hIrred X hn' with hx|hx + · left + simp [hx,artinParabolic] + · right + rw [hx,standard_univ,conjugate_top] + +/-- No nontrivial normal subgroup obtained as a parabolic can lie in a +proper parabolic of an irreducible Artin group. -/ +theorem parabolic_normalCore_eq_bot (hIrred : IsIrreducible M) + (P : Subgroup (Artin M)) (hP : IsParabolic M P) (hproper : P≠⊤) : + P.normalCore=⊥ := by + have hC : IsParabolic M P.normalCore := by + rw [normalCore_eq_sInf_conjugates] + apply (unconditional_arbitrary_intersections M _ ?_).2 + rintro Q ⟨g,rfl⟩ + exact isParabolic_conjugate M hP g + rcases normal_parabolic M hIrred P.normalCore hC inferInstance with h|h + · exact h + · exact False.elim (hproper (top_le_iff.mp (h ▸ P.normalCore_le))) + +/-- A bounded finite family of conjugates has trivial intersection. This is +used to find a finite subtree with trivial pointwise stabilizer. -/ +theorem finite_conjugates_inf_bot (hIrred : IsIrreducible M) + (P : Subgroup (Artin M)) (hP : IsParabolic M P) (hproper : P≠⊤) : + ∃ F : Finset (Subgroup (Artin M)), + (∀ Q∈F, ∃ g : Artin M, Q=conjugate g P) ∧ F.card≤Nat.card S ∧ + sInf (↑F : Set (Subgroup (Artin M)))=⊥ := by + obtain ⟨⟨F,hF,hcard,he⟩,_⟩ := unconditional_arbitrary_intersections M + (Set.range (fun g : Artin M => conjugate g P)) (by + rintro Q ⟨g,rfl⟩ + exact isParabolic_conjugate M hP g) + refine ⟨F,?_,hcard,?_⟩ + · intro Q hQ + obtain ⟨g,hg⟩ := hF hQ + exact ⟨g,hg.symm⟩ + · rw [←he,←normalCore_eq_sInf_conjugates,parabolic_normalCore_eq_bot M hIrred P hP hproper] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicCosetProjection.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicCosetProjection.lean new file mode 100644 index 0000000000000000000000000000000000000000..15280c4f74fdd99bd372c767760d07646cb9eea8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicCosetProjection.lean @@ -0,0 +1,131 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicMinimumStep + +namespace OAI + +/-! Canonical minimal coset representatives and their parabolic components. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S W : Type} [Group W] {M : CoxeterMatrix S} (cs : CoxeterSystem M W) + (J : Set S) + +private theorem exists_minimum_rep (w : W) : + ∃ v, IsParabolicMinimum cs J v ∧ ∃ a ∈ parabolic cs J, w=a*v := by + obtain ⟨a,v,ha,hv,hw,_⟩ := exists_parabolic_decomposition cs J w + exact ⟨v,hv,a,ha,hw⟩ + +noncomputable def parabolicRep (w : W) : W := + Classical.choose (exists_minimum_rep cs J w) + +lemma parabolicRep_min (w : W) : IsParabolicMinimum cs J (parabolicRep cs J w) := + (Classical.choose_spec (exists_minimum_rep cs J w)).1 + +noncomputable def parabolicComponent (w : W) : W := w*(parabolicRep cs J w)⁻¹ + +lemma parabolicComponent_mul_rep (w : W) : + parabolicComponent cs J w*parabolicRep cs J w=w := by + simp only [parabolicComponent,inv_mul_cancel_right] + +lemma parabolicComponent_mem (w : W) : parabolicComponent cs J w ∈ parabolic cs J := by + obtain ⟨a,ha,hw⟩ := (Classical.choose_spec (exists_minimum_rep cs J w)).2 + have he : w*(parabolicRep cs J w)⁻¹=a := + (congrArg (fun x => x*(parabolicRep cs J w)⁻¹) hw).trans (mul_inv_cancel_right _ _) + change w*(parabolicRep cs J w)⁻¹ ∈ parabolic cs J + exact he.symm ▸ ha + +lemma parabolicRep_eq_of_decomposition (w a v : W) (ha : a ∈ parabolic cs J) + (hv : IsParabolicMinimum cs J v) (hw : w=a*v) : parabolicRep cs J w=v := by + apply parabolic_minimum_unique cs J hv (parabolicRep_min cs J w) + refine ⟨(parabolicComponent cs J w)⁻¹*a, + (parabolic cs J).mul_mem ((parabolic cs J).inv_mem (parabolicComponent_mem cs J w)) ha,?_⟩ + have he := parabolicComponent_mul_rep cs J w + calc parabolicRep cs J w = (parabolicComponent cs J w)⁻¹*w := + (eq_inv_mul_iff_mul_eq).mpr he + _ = (parabolicComponent cs J w)⁻¹*(a*v) := congrArg _ hw + _ = _ := by group + +lemma parabolicRep_of_minimum (v : W) (hv : IsParabolicMinimum cs J v) : + parabolicRep cs J v=v := + parabolicRep_eq_of_decomposition cs J v 1 v (parabolic cs J).one_mem hv (one_mul v).symm + +lemma parabolicRep_left_mul (a w : W) (ha : a ∈ parabolic cs J) : + parabolicRep cs J (a*w)=parabolicRep cs J w := by + apply parabolicRep_eq_of_decomposition cs J (a*w) (a*parabolicComponent cs J w) + (parabolicRep cs J w) ((parabolic cs J).mul_mem ha (parabolicComponent_mem cs J w)) + (parabolicRep_min cs J w) + rw [mul_assoc,parabolicComponent_mul_rep] + +lemma parabolicComponent_left_mul (a w : W) (ha : a ∈ parabolic cs J) : + parabolicComponent cs J (a*w)=a*parabolicComponent cs J w := by + simp only [parabolicComponent,parabolicRep_left_mul cs J a w ha,mul_assoc] + +noncomputable def parabolicStepRatio (w : W) (s : S) : W := + (parabolicComponent cs J w)⁻¹*parabolicComponent cs J (w*cs.simple s) + +/-- The component changes by either no letter or a simple letter of `J`. -/ +theorem parabolicStepRatio_cases (w : W) (s : S) : + parabolicStepRatio cs J w s=1 ∨ + ∃ t : J, parabolicStepRatio cs J w s=cs.simple t := by + rcases parabolic_minimum_step cs J (parabolicRep cs J w) (parabolicRep_min cs J w) s + with hmin | ⟨t,ht,he⟩ + · left + have hr : parabolicRep cs J (w*cs.simple s)=parabolicRep cs J w*cs.simple s := by + apply parabolicRep_eq_of_decomposition cs J _ (parabolicComponent cs J w) _ + (parabolicComponent_mem cs J w) hmin + rw [←mul_assoc,parabolicComponent_mul_rep] + unfold parabolicStepRatio parabolicComponent + rw [hr,mul_inv_rev] + group + · right + have hr : parabolicRep cs J (w*cs.simple s)=parabolicRep cs J w := by + apply parabolicRep_eq_of_decomposition cs J _ + (parabolicComponent cs J w*cs.simple t) _ + ((parabolic cs J).mul_mem (parabolicComponent_mem cs J w) (simple_mem_parabolic cs J ht)) + (parabolicRep_min cs J w) + rw [mul_assoc,←he,←mul_assoc,parabolicComponent_mul_rep] + refine ⟨⟨t,ht⟩,?_⟩ + unfold parabolicStepRatio parabolicComponent + rw [hr] + conv_rhs => rw [show cs.simple t=(parabolicRep cs J w*cs.simple s)* + (parabolicRep cs J w)⁻¹ by rw [he,mul_inv_cancel_right]] + group + +lemma parabolicStepRatio_one_of_minimum (w : W) (s : S) + (hmin : IsParabolicMinimum cs J (parabolicRep cs J w*cs.simple s)) : + parabolicStepRatio cs J w s=1 := by + have hr : parabolicRep cs J (w*cs.simple s)=parabolicRep cs J w*cs.simple s := by + apply parabolicRep_eq_of_decomposition cs J _ (parabolicComponent cs J w) _ + (parabolicComponent_mem cs J w) hmin + rw [←mul_assoc,parabolicComponent_mul_rep] + unfold parabolicStepRatio parabolicComponent + rw [hr,mul_inv_rev] + group + +lemma parabolicStepRatio_reflection (w : W) (s : S) + (hne : parabolicStepRatio cs J w s ≠ 1) : + parabolicStepRatio cs J w s = + parabolicRep cs J w*cs.simple s*(parabolicRep cs J w)⁻¹ := by + rcases parabolic_minimum_step cs J (parabolicRep cs J w) (parabolicRep_min cs J w) s + with hmin | ⟨t,ht,he⟩ + · exact (hne (parabolicStepRatio_one_of_minimum cs J w s hmin)).elim + have hr : parabolicRep cs J (w*cs.simple s)=parabolicRep cs J w := by + apply parabolicRep_eq_of_decomposition cs J _ (parabolicComponent cs J w*cs.simple t) _ + ((parabolic cs J).mul_mem (parabolicComponent_mem cs J w) (simple_mem_parabolic cs J ht)) + (parabolicRep_min cs J w) + rw [mul_assoc,←he,←mul_assoc,parabolicComponent_mul_rep] + unfold parabolicStepRatio parabolicComponent + rw [hr] + group + +lemma parabolicStepRatio_reverse (w : W) (s : S) : + parabolicStepRatio cs J (w*cs.simple s) s=parabolicStepRatio cs J w s := by + have he : parabolicStepRatio cs J (w*cs.simple s) s=(parabolicStepRatio cs J w s)⁻¹ := by + simp only [parabolicStepRatio,cs.simple_mul_simple_cancel_right,mul_inv_rev,inv_inv] + rw [he] + rcases parabolicStepRatio_cases cs J w s with h | ⟨t,h⟩ + · rw [h,inv_one] + · rw [h,cs.inv_simple] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicMinimal.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicMinimal.lean new file mode 100644 index 0000000000000000000000000000000000000000..8626dbe8f69cfa8392cd7b6c7a95adf6ce57293d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicMinimal.lean @@ -0,0 +1,42 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.UnconditionalMain + +namespace OAI + +/-! Rank descent gives a minimal member of every nonempty family of parabolics. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- A nonempty family of parabolic subgroups has an inclusion-minimal member. +The argument follows the size of a displayed defining type and does not +assume that rank is conjugacy invariant. -/ +theorem exists_minimal_parabolic (F : Set (Subgroup (Artin M))) (hF : F.Nonempty) + (hpar : ∀ P∈F, IsParabolic M P) : + ∃ P∈F, ∀ Q∈F, Q≤P → Q=P := by + have hex : ∃ n : ℕ, ∃ (X : Set S) (g : Artin M), + conjugate g (artinParabolic M X)∈F ∧ X.ncard=n := by + obtain ⟨P,hP⟩ := hF + obtain ⟨X,g,rfl⟩ := hpar P hP + exact ⟨X.ncard,X,g,hP,rfl⟩ + obtain ⟨X,g,hX,hcard⟩ := Nat.find_spec hex + refine ⟨conjugate g (artinParabolic M X),hX,?_⟩ + intro Q hQ hle + by_contra hne + obtain ⟨Z,c,hZX,hc,he⟩ := inside_conjugate M (unconditional_inside_intersection M) + X g (hpar Q hQ) + rw [inf_eq_right.mpr hle] at he + have hZX' : Z≠X := by + intro h + rw [h,conjugate_mul,conjugate_eq_self hc] at he + exact hne he + have hlt : Z.ncard exact (ha1 (by simpa only [cs.wordProd_nil] using haeq.symm)).elim + | cons t l => + refine ⟨t,hl t (by simp),?_⟩ + have htail : ∀ i ∈ l, i ∈ J := fun i hi => hl i (List.mem_cons_of_mem t hi) + have htailp := wordProd_mem_parabolic cs J l htail + have he' : cs.simple t*w=cs.wordProd l*v := by + rw [he,←haeq,cs.wordProd_cons,←mul_assoc,cs.simple_mul_simple_cancel_left] + rw [he',length_mul_of_minimum cs J v hv _ htailp] + rw [←haeq,hr.eq] at hlen + have hredtail : cs.IsReduced l := by simpa only [List.drop_succ_cons,List.drop_zero] using hr.drop 1 + rw [hredtail.eq] + simp only [List.length_cons] at hlen + omega + +/-- Multiplying a minimal left-coset representative by one simple +reflection either remains minimal or crosses a wall of the parabolic. -/ +theorem parabolic_minimum_step (J : Set S) (v : W) + (hv : IsParabolicMinimum cs J v) (s : S) : + IsParabolicMinimum cs J (v*cs.simple s) ∨ + ∃ t ∈ J, v*cs.simple s=cs.simple t*v := by + by_cases hmin : IsParabolicMinimum cs J (v*cs.simple s) + · exact Or.inl hmin + right + obtain ⟨t,ht,hdes⟩ := exists_parabolic_left_descent cs J _ hmin + have htmin := hv (cs.simple t) (simple_mem_parabolic cs J ht) + have hright := cs.length_mul_simple v s + have hleft := cs.length_simple_mul (v*cs.simple s) t + have hascent : cs.length (v*cs.simple s)=cs.length v+1 := by + rcases hright with hr | hr + · exact hr + · have hbound := cs.length_mul_le (cs.simple t*(v*cs.simple s)) (cs.simple s) + have hs : cs.simple s*cs.simple s=1 := by + simpa only [mul_one] using cs.simple_mul_simple_cancel_left (w:=1) s + rw [mul_assoc,mul_assoc,hs,mul_one,cs.length_simple] at hbound + omega + obtain ⟨u,hu,he⟩ := cs.exists_isReduced v + have hured : cs.IsReduced (u++[s]) := by + change cs.length (cs.wordProd (u++[s]))=(u++[s]).length + rw [cs.wordProd_append,cs.wordProd_singleton,←he,List.length_append,List.length_singleton,hascent,he,hu.eq] + obtain ⟨j,hj,hdel⟩ := simple_exchange cs hured t (by + simpa only [cs.wordProd_append,cs.wordProd_singleton,←he] using hdes) + by_cases hju : j M.toCoxeterSystem + +lemma coxeter_simple_not_parabolic (C : Set S) (s : S) (hs : s∉C) : + (cs).simple s∉parabolic cs C := by + intro hm + have he := parabolic_exterior M C ⟨_,hm⟩ (Pi.single s 1) s hs + change representation cs ((cs).simple s) (Pi.single s 1) s=(Pi.single s 1 : S → ℝ) s at he + simp only [representation_simple,simpleReflection_apply,Pi.sub_apply,Pi.smul_apply, + smul_eq_mul,Pi.single_eq_same,Matrix.mulVec_single,Matrix.col,Matrix.transpose_apply, + MulOpposite.op_one,one_smul,cartan_diag] at he + norm_num at he + +/-- A noncommutation path supplies an explicit missing double coset. -/ +theorem coxeter_parabolic_product_proper (hIrred : IsIrreducible M) + (X C : Set S) (hX : X≠Set.univ) (hC : C≠Set.univ) : + ∃ w : M.Group, ∀ a∈parabolic cs X, ∀ b∈parabolic cs C, w≠a*b := by + obtain ⟨s,hs⟩ := Set.nonempty_compl.mpr hX + obtain ⟨t,ht⟩ := Set.nonempty_compl.mpr hC + obtain ⟨p,hp⟩ := (noncommuting_reachable M hIrred s t).exists_isPath + obtain ⟨u,d,v,he,hu,hd⟩ := list_first_outside C p.support ⟨t,p.end_mem_support,ht⟩ + have he' : p.support=(u++[d])++v := by + rw [he,List.append_assoc] + rfl + have hn : (u++[d]).Nodup := (List.nodup_append.mp (he' ▸ hp.support_nodup)).1 + have hc : (u++[d]).IsChain (fun a b => a≠b ∧ M a b≠2) := + (show ((u++[d])++v).IsChain (noncommutingGraph M).Adj from + he' ▸ p.isChain_adj_support).left_of_append + have hfirst : p.support.headD s=s := by cases p <;> rfl + have hh := congrArg (fun l : List S => l.headD s) he + rw [hfirst] at hh + have hhead : ∃ r, u++[d]=s::r := by + cases u with + | nil => + change s=d at hh + subst d + exact ⟨[],rfl⟩ + | cons a u => + change s=a at hh + subst a + exact ⟨u++[d],rfl⟩ + obtain ⟨r,hr⟩ := hhead + have hmin : IsParabolicMinimum cs X ((cs).wordProd (u++[d])) := by + rw [hr] at hn hc ⊢ + exact chain_word_minimum M X s hs r hn hc + have hw : (cs).wordProd (u++[d])∉parabolic cs C := by + intro hm + rw [(cs).wordProd_append,(cs).wordProd_singleton] at hm + have huC := wordProd_mem_parabolic cs C u hu + have hdC := (parabolic cs C).mul_mem ((parabolic cs C).inv_mem huC) hm + rw [inv_mul_cancel_left] at hdC + exact coxeter_simple_not_parabolic M C d hd hdC + exact ⟨_,fun a ha b hb => minimum_not_product cs X C _ hmin hw a b ha hb⟩ + +/-- The same proper-product statement for the actual Artin presentation. -/ +theorem artin_parabolic_product_proper (hIrred : IsIrreducible M) + (X C : Set S) (hX : X≠Set.univ) (hC : C≠Set.univ) : + ∃ g : Artin M, ∀ a∈artinParabolic M X, ∀ b∈artinParabolic M C, g≠a*b := by + obtain ⟨w,hw⟩ := coxeter_parabolic_product_proper M hIrred X C hX hC + refine ⟨positiveLift M w,?_⟩ + intro a ha b hb he + have hh := congrArg (artinCoxeter M) he + rw [artinCoxeter_positiveLift,map_mul] at hh + exact hw _ (artinCoxeter_mem_parabolic M ha) _ (artinCoxeter_mem_parabolic M hb) hh + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicRead.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicRead.lean new file mode 100644 index 0000000000000000000000000000000000000000..127f793b397f7ed96a99dc85c089bf18e12a76b4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicRead.lean @@ -0,0 +1,78 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicCosetProjection + +namespace OAI + +/-! Reading the parabolic letters crossed by a Coxeter gallery. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S W : Type} [Group W] {M : CoxeterMatrix S} (cs : CoxeterSystem M W) + (J : Set S) + +noncomputable def parabolicLetterValue : Option J → W + | none => 1 + | some t => cs.simple t + +noncomputable def parabolicLetter (r : W) : Option J := + Classical.epsilon (fun l => parabolicLetterValue cs J l=r) + +noncomputable def parabolicStepLetter (w : W) (s : S) : Option J := + parabolicLetter cs J (parabolicStepRatio cs J w s) + +lemma parabolicStepLetter_value (w : W) (s : S) : + parabolicLetterValue cs J (parabolicStepLetter cs J w s)=parabolicStepRatio cs J w s := by + unfold parabolicStepLetter parabolicLetter + refine Classical.epsilon_spec (p := fun l : Option J => + parabolicLetterValue cs J l=parabolicStepRatio cs J w s) ?_ + rcases parabolicStepRatio_cases cs J w s with h | ⟨t,h⟩ + · exact ⟨none,h.symm⟩ + · exact ⟨some t,h.symm⟩ + +lemma parabolicStepLetter_reverse (w : W) (s : S) : + parabolicStepLetter cs J (w*cs.simple s) s=parabolicStepLetter cs J w s := by + unfold parabolicStepLetter + rw [parabolicStepRatio_reverse] + +lemma parabolicStepLetter_conjugate (w : W) (s : S) (t : J) + (ht : parabolicStepLetter cs J w s=some t) : + MulAut.conj (parabolicComponent cs J w) (cs.simple t)=MulAut.conj w (cs.simple s) := by + have hr := parabolicStepLetter_value cs J w s + rw [ht] at hr + change cs.simple t=parabolicStepRatio cs J w s at hr + have hne : parabolicStepRatio cs J w s ≠ 1 := by + intro he + have hl := congrArg cs.length (hr.trans he) + rw [cs.length_simple,cs.length_one] at hl + omega + rw [parabolicStepRatio_reflection cs J w s hne] at hr + simp only [MulAut.conj_apply] + rw [hr] + have hw := parabolicComponent_mul_rep cs J w + calc _ = (parabolicComponent cs J w*parabolicRep cs J w)*cs.simple s* + (parabolicComponent cs J w*parabolicRep cs J w)⁻¹ := by group + _ = _ := by rw [hw] + +noncomputable def parabolicRead : W → List S → List J + | _, [] => [] + | w, s::u => (parabolicStepLetter cs J w s).toList ++ parabolicRead (w*cs.simple s) u + +lemma parabolicLetter_word (l : Option J) : + cs.wordProd (l.toList.map Subtype.val)=parabolicLetterValue cs J l := by + cases l <;> simp [parabolicLetterValue] + +/-- The read word records exactly the change in the parabolic component. -/ +theorem parabolicRead_product (w : W) (u : List S) : + cs.wordProd ((parabolicRead cs J w u).map Subtype.val) = + (parabolicComponent cs J w)⁻¹*parabolicComponent cs J (w*cs.wordProd u) := by + induction u generalizing w with + | nil => simp [parabolicRead] + | cons s u ih => + simp only [parabolicRead,List.map_append,cs.wordProd_append, + parabolicLetter_word,parabolicStepLetter_value,ih,cs.wordProd_cons] + unfold parabolicStepRatio + rw [mul_assoc w] + group + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicReadBraid.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicReadBraid.lean new file mode 100644 index 0000000000000000000000000000000000000000..8ab1805c5d47314631a748cfce57100478a6406e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicReadBraid.lean @@ -0,0 +1,43 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicReadReduced +import OAI.Topology.ArtinGroups.Harmonic.RestrictedArtinHom +import OAI.Topology.ArtinGroups.Coxeter.AltListReduced +import OAI.Topology.ArtinGroups.Coxeter.PositiveBraidRelations + +namespace OAI + +/-! The parabolic read respects braid relations by the reduced-word theorem. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (J : Set S) +local notation "cs" => M.toCoxeterSystem +local notation "R" => restrictedMatrix M J + +/-- Equal reduced galleries have equal positive reads in the parabolic. -/ +theorem parabolicRead_word_eq (w : M.Group) (u v : List S) + (hu : (cs).IsReduced u) (hv : (cs).IsReduced v) (he : (cs).wordProd u=(cs).wordProd v) : + wordArtin R (parabolicRead cs J w u)=wordArtin R (parabolicRead cs J w v) := by + suffices h : wordPositive R (parabolicRead cs J w u)=wordPositive R (parabolicRead cs J w v) by + simpa only [positiveToArtin_word] using congrArg (positiveToArtin R) h + apply wordPositive_eq_of_reduced R _ _ + ((restriction_reduced_iff M J _).mp (parabolicRead_reduced cs J w u hu)) + ((restriction_reduced_iff M J _).mp (parabolicRead_reduced cs J w v hv)) + apply restrictionHom_injective M J + change restrictionHom M J ((restrictedMatrix M J).toCoxeterSystem.wordProd (parabolicRead cs J w u)) = + restrictionHom M J ((restrictedMatrix M J).toCoxeterSystem.wordProd (parabolicRead cs J w v)) + rw [restriction_wordProd,restriction_wordProd,parabolicRead_product,parabolicRead_product,he] + +/-- The precise braid compatibility needed for the parabolic retraction. -/ +theorem parabolicRead_braid (w : M.Group) (i j : S) : + wordArtin R (parabolicRead cs J w (altList i j (M i j))) = + wordArtin R (parabolicRead cs J w (altList j i (M i j))) := by + by_cases hij : i=j + · subst j; rfl + apply parabolicRead_word_eq M J w + · exact altList_reduced cs i j hij _ (Or.inr le_rfl) + · exact altList_reduced cs j i (Ne.symm hij) _ (Or.inr (le_of_eq (M.symmetric i j))) + · exact altList_braid cs i j + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicReadReduced.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicReadReduced.lean new file mode 100644 index 0000000000000000000000000000000000000000..0b68cabaa449cad730a3ca18cdde27022783e9b1 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicReadReduced.lean @@ -0,0 +1,79 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicRead + +namespace OAI + +/-! A parabolic read of a reduced gallery is reduced. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S W : Type} [Group W] {M : CoxeterMatrix S} (cs : CoxeterSystem M W) + +private lemma conjugate_sequence (a b : W) (l : List W) : + (l.map (MulAut.conj b)).map (MulAut.conj a) = l.map (MulAut.conj (a*b)) := by + rw [List.map_map] + apply List.map_congr_left + intro x _ + simp only [Function.comp_apply,MulAut.conj_apply] + group + +/-- The converse to the usual no-repeated-inversion property. -/ +theorem reduced_of_nodup_inversions (u : List S) (hu : (cs.leftInvSeq u).Nodup) : + cs.IsReduced u := by + induction u with + | nil => simp [CoxeterSystem.IsReduced] + | cons s u ih => + change (cs.simple s :: (cs.leftInvSeq u).map (MulAut.conj (cs.simple s))).Nodup at hu + obtain ⟨hnot,htail⟩ := List.nodup_cons.mp hu + have hr := ih htail.of_map + rcases cs.length_simple_mul (cs.wordProd u) s with ha | hd + · change cs.length (cs.simple s*cs.wordProd u)=(s::u).length + rw [ha,hr.eq,List.length_cons] + · have hm := simple_mem_leftInvSeq_of_shorter cs hr s (by omega) + apply (hnot ?_).elim + exact List.mem_map.mpr ⟨cs.simple s,hm,by simp only [MulAut.conj_apply,mul_inv_cancel_right]⟩ + +/-- The read gallery crosses a subsequence of the original reflecting +walls; conjugating by the initial component identifies their labels. -/ +theorem parabolicRead_inversions (J : Set S) (w : W) (u : List S) : + ((cs.leftInvSeq ((parabolicRead cs J w u).map Subtype.val)).map + (MulAut.conj (parabolicComponent cs J w))).Sublist + ((cs.leftInvSeq u).map (MulAut.conj w)) := by + induction u generalizing w with + | nil => simp [parabolicRead] + | cons s u ih => + have hi := ih (w*cs.simple s) + cases hl : parabolicStepLetter cs J w s with + | none => + have hv := parabolicStepLetter_value cs J w s + rw [hl] at hv + change 1=(parabolicComponent cs J w)⁻¹*parabolicComponent cs J (w*cs.simple s) at hv + have hc : parabolicComponent cs J (w*cs.simple s)=parabolicComponent cs J w := + (inv_mul_eq_one.mp hv.symm).symm + rw [hc] at hi + simpa only [parabolicRead,hl,Option.toList_none,List.nil_append, + CoxeterSystem.leftInvSeq,List.map_cons,conjugate_sequence] using + List.Sublist.cons (MulAut.conj w (cs.simple s)) hi + | some t => + have hv := parabolicStepLetter_value cs J w s + rw [hl] at hv + change cs.simple t=(parabolicComponent cs J w)⁻¹*parabolicComponent cs J (w*cs.simple s) at hv + have hc : parabolicComponent cs J (w*cs.simple s)=parabolicComponent cs J w*cs.simple t := + ((eq_inv_mul_iff_mul_eq).mp hv).symm + rw [hc] at hi + have href := parabolicStepLetter_conjugate cs J w s t hl + simpa only [parabolicRead,hl,Option.toList_some,List.singleton_append,List.map_cons, + CoxeterSystem.leftInvSeq,conjugate_sequence,href] using + List.Sublist.cons_cons (MulAut.conj w (cs.simple s)) hi + +/-- Retraction to a standard parabolic preserves reducedness of galleries, +allowing letters which do not cross a parabolic wall to disappear. -/ +theorem parabolicRead_reduced (J : Set S) (w : W) (u : List S) (hu : cs.IsReduced u) : + cs.IsReduced ((parabolicRead cs J w u).map Subtype.val) := by + apply reduced_of_nodup_inversions cs + have h := (parabolicRead_inversions cs J w u).nodup + (hu.nodup_leftInvSeq.map (MulAut.conj w).injective) + exact h.of_map + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicRetractionAction.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicRetractionAction.lean new file mode 100644 index 0000000000000000000000000000000000000000..a0d268ba55b0ab136687079b5e5eb6f4cb913689 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ParabolicRetractionAction.lean @@ -0,0 +1,82 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicReadBraid +import OAI.Topology.ArtinGroups.Coxeter.AlternatingLiftProd + +namespace OAI + +/-! The parabolic gallery retraction as an action of the Artin presentation. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (J : Set S) +local notation "cs" => M.toCoxeterSystem +local notation "R" => restrictedMatrix M J +local notation "State" => M.Group × Artin R + +noncomputable def parabolicStepArtin (w : M.Group) (s : S) : Artin R := + wordArtin R (parabolicStepLetter cs J w s).toList + +omit [Fintype S] in +lemma parabolicStepArtin_reverse (w : M.Group) (s : S) : + parabolicStepArtin M J (w*(cs).simple s) s=parabolicStepArtin M J w s := by + unfold parabolicStepArtin + rw [parabolicStepLetter_reverse] + +noncomputable def parabolicStepPerm (s : S) : Equiv.Perm State where + toFun x := (x.1*(cs).simple s,x.2*parabolicStepArtin M J x.1 s) + invFun x := (x.1*(cs).simple s,x.2*(parabolicStepArtin M J x.1 s)⁻¹) + left_inv := by + rintro ⟨w,a⟩ + apply Prod.ext + · exact (cs).simple_mul_simple_cancel_right s + · change (a*parabolicStepArtin M J w s)*(parabolicStepArtin M J (w*(cs).simple s) s)⁻¹=a + rw [parabolicStepArtin_reverse,mul_inv_cancel_right] + right_inv := by + rintro ⟨w,a⟩ + apply Prod.ext + · exact (cs).simple_mul_simple_cancel_right s + · change (a*(parabolicStepArtin M J w s)⁻¹)*parabolicStepArtin M J (w*(cs).simple s) s=a + rw [parabolicStepArtin_reverse,inv_mul_cancel_right] + +noncomputable def parabolicWordPerm (u : List S) : (Equiv.Perm State)ᵐᵒᵖ := + (u.map fun s => MulOpposite.op (parabolicStepPerm M J s)).prod + +omit [Fintype S] in +/-- Using the opposite permutation group makes the word act in its written order. -/ +lemma parabolicWordPerm_apply (u : List S) (w : M.Group) (a : Artin R) : + MulOpposite.unop (parabolicWordPerm M J u) (w,a) = + (w*(cs).wordProd u,a*wordArtin R (parabolicRead cs J w u)) := by + induction u generalizing w a with + | nil => simp [parabolicWordPerm,parabolicRead,wordArtin] + | cons s u ih => + change MulOpposite.unop (parabolicWordPerm M J u) + (w*(cs).simple s,a*parabolicStepArtin M J w s)=_ + rw [ih] + simp only [(cs).wordProd_cons,parabolicRead,wordArtin_append,parabolicStepArtin,mul_assoc] + +lemma parabolicWordPerm_braid (i j : S) : + parabolicWordPerm M J (altList i j (M i j))= + parabolicWordPerm M J (altList j i (M i j)) := by + apply MulOpposite.unop_injective + apply Equiv.ext + rintro ⟨w,a⟩ + rw [parabolicWordPerm_apply,parabolicWordPerm_apply,altList_braid cs i j, + parabolicRead_braid M J w i j] + +private lemma parabolicPerm_relators : ∀ r ∈ braidRelators M, + FreeGroup.lift (fun s => MulOpposite.op (parabolicStepPerm M J s)) r=1 := by + rintro r ⟨⟨i,j⟩,rfl⟩ + rw [map_mul,map_inv] + apply mul_inv_eq_one.mpr + rw [alternating_lift_prod,alternating_lift_prod] + exact parabolicWordPerm_braid M J i j + +noncomputable def parabolicRetractionAction : Artin M →* (Equiv.Perm State)ᵐᵒᵖ := + PresentedGroup.toGroup (parabolicPerm_relators M J) + +lemma parabolicRetractionAction_generator (s : S) : + parabolicRetractionAction M J (generator M s)=MulOpposite.op (parabolicStepPerm M J s) := + PresentedGroup.toGroup.of _ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PathImages.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PathImages.lean new file mode 100644 index 0000000000000000000000000000000000000000..dd5b1ec92dcdfdb6fa82bcd17a0cdb0506438dc5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PathImages.lean @@ -0,0 +1,87 @@ +import Mathlib + +namespace OAI + +/-! Iterated images of the arrow coefficient maps. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {A I : Type} [Fintype I] [DecidableEq I] (B : A → Matrix I I ℂ) + +noncomputable def pathImages (n : ℕ) : Submodule ℂ (I → ℂ) := + Submodule.span ℂ {x | ∃ w : List A, w.length = n ∧ + ∃ y : I → ℂ, Matrix.vecMul y (w.map B).prod = x} + +lemma mem_pathImages_zero (x : I → ℂ) : x ∈ pathImages B 0 := by + apply Submodule.subset_span + exact ⟨[], rfl, x, Matrix.vecMul_one x⟩ + +lemma pathImages_step {n : ℕ} {x : I → ℂ} (hx : x ∈ pathImages B n) (a : A) : + Matrix.vecMul x (B a) ∈ pathImages B (n+1) := by + induction hx using Submodule.span_induction with + | mem x hx => + obtain ⟨w, hw, y, rfl⟩ := hx + apply Submodule.subset_span + refine ⟨w ++ [a], by simp only [List.length_append, List.length_singleton, hw], y, ?_⟩ + simp only [List.map_append, List.map_singleton, List.prod_append, List.prod_singleton, + Matrix.vecMul_vecMul] + | zero => + rw [Matrix.zero_vecMul] + exact Submodule.zero_mem _ + | add x y _ _ hx hy => + rw [Matrix.add_vecMul] + exact Submodule.add_mem _ hx hy + | smul c x _ hx => + rw [Matrix.smul_vecMul] + exact Submodule.smul_mem _ c hx + +lemma pathImages_eq_bot (n : ℕ) + (hz : ∀ w : List A, w.length = n → (w.map B).prod = 0) : pathImages B n = ⊥ := by + apply le_antisymm _ bot_le + apply Submodule.span_le.mpr + rintro x ⟨w, hw, y, rfl⟩ + rw [hz w hw, Matrix.vecMul_zero] + exact Submodule.zero_mem _ + +/-- An arbitrary supported vector belongs to a subspace as soon as all +its occupied coordinate vectors do. -/ +lemma supported_mem_of_single {P : Submodule ℂ (I → ℂ)} (x : I → ℂ) + (h : ∀ i, x i ≠ 0 → Pi.single i (1 : ℂ) ∈ P) : x ∈ P := by + have he : x = ∑ i : I, x i • Pi.single i (1 : ℂ) := by + funext j + simp only [Finset.sum_apply, Pi.smul_apply, smul_eq_mul, Pi.single_apply] + simp + rw [he] + apply Submodule.sum_mem + intro i _ + by_cases hi : x i = 0 + · rw [hi, zero_smul] + exact Submodule.zero_mem _ + · exact Submodule.smul_mem _ _ (h i hi) + +/-- Iterating incoming spanning equations lands in the image of paths of +length `n`. The lower bound on the placement prevents leaving the range +where the spanning equations hold. -/ +theorem incoming_spanning_pathImages (degree : I → ℤ) (lower : ℤ) + (hspan : ∀ i, lower < degree i → ∃ y : A → (I → ℂ), + (∀ a j, y a j ≠ 0 → degree j = degree i - 1) ∧ + (∃ t : Finset A, Pi.single i (1 : ℂ) = ∑ a ∈ t, Matrix.vecMul (y a) (B a))) : + ∀ n : ℕ, ∀ i, lower + n ≤ degree i → Pi.single i (1 : ℂ) ∈ pathImages B n := by + intro n + induction n with + | zero => exact fun i _ => mem_pathImages_zero B _ + | succ n ih => + intro i hi + obtain ⟨y, hy, t, he⟩ := hspan i (by omega) + rw [he] + apply Submodule.sum_mem + intro a _ + apply pathImages_step B + apply supported_mem_of_single + intro j hj + apply ih + have := hy a j hj + omega + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PeriodicBoundary.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PeriodicBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..0cec4b2fa2b4b48b6b73caf77fa59f0506be7a03 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PeriodicBoundary.lean @@ -0,0 +1,111 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.AvoidingBoundaryRays + +namespace OAI + +/-! A periodic free segment and a third direction give a non-elementary action. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +open GraphRealization +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (u v : V) + +lemma graphProduct_smul (H : SimpleGraph V) (hH : H.Connected) + (hB : PreservesAdj (G := G) H) (g : G) (x y z : V) : + graphProduct H (g • x) (g • y) (g • z)=graphProduct H x y z := by + simp only [graphProduct,graph_action_dist H hH hB] + +theorem periodic_three_limit_points (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + (hfree : pairStabilizer (G := G) u v=⊥) (hne : u≠v) (hnadj : ¬T.Adj u v) + (g : G) {x : V} (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) (a : G) + (hau : a • u∈p.support) (hav : a • v∈p.support) + (c : G) (hc : c • x=x) (hc₁ : c • p.snd≠p.snd) + (hc₂ : c • p.snd≠g⁻¹ • p.reverse.snd) : + let H := avoidingGraph (G := G) T u v + let hH := avoidingGraph_connected T u v hT hA hne hnadj + let hB := avoidingGraph_preservesAdj T u v hA + let _ := action H hB hH + HasThreeOrbitLimitPoints G (Space H hH) := by + let q := inverseSegment T hA g p + have hq : q.IsPath := inverseSegment_isPath T hA g p hp + have hqn : ¬q.Nil := inverseSegment_nonempty T hA g p hpn + have hqt : q.reverse.snd≠g⁻¹ • q.snd := inverseSegment_turn T hA g p hturn + have hqu : (g⁻¹*a) • u∈q.support := inverseSegment_mem T hA g a p hau + have hqv : (g⁻¹*a) • v∈q.support := inverseSegment_mem T hA g a p hav + have hback : q.snd≠p.snd := by + rw [inverseSegment_snd] + intro he + have hh := congrArg (fun w : V => g • w) he + rw [smul_inv_smul] at hh + exact hturn hh + let seq : Fin 3 → ℕ → G := ![fun n => g^n,fun n => (g⁻¹)^n,fun n => c*g^n] + let P : ∀ i n,T.Walk x (seq i n • x) := by + intro i + refine Fin.cases ?_ ?_ i + · intro n + exact periodicPath T hA g p n + · intro j + refine Fin.cases ?_ ?_ j + · intro n + exact periodicPath T hA g⁻¹ q n + · intro k + refine Fin.cases ?_ (fun z => Fin.elim0 z) k + intro n + exact (actPath T hA c (periodicPath T hA g p n)).copy hc (mul_smul c (g^n) x).symm + let d : Fin 3 → V := ![p.snd,q.snd,c • p.snd] + refine realization_three_rays T u v hT hA hne hnadj x seq P ?_ ?_ d ?_ ?_ ?_ + · intro i n + fin_cases i + · exact periodicPath_isPath T hA hT.isAcyclic g p hp hpn hturn n + · exact periodicPath_isPath T hA hT.isAcyclic g⁻¹ q hq hqn hqt n + · apply (SimpleGraph.Walk.isPath_copy _ _ _).mpr + exact (periodicPath_isPath T hA hT.isAcyclic g p hp hpn hturn n).map + (MulAction.toPerm c).injective + · intro i + fin_cases i + · change (periodicPath T hA g p 0).Nil + simp [periodicPath] + · change (periodicPath T hA g⁻¹ q 0).Nil + simp [periodicPath] + · change ((actPath T hA c (periodicPath T hA g p 0)).copy hc _).Nil + apply SimpleGraph.Walk.length_eq_zero_iff.mp + exact (actPath_copy_length T hA c (periodicPath T hA g p 0) hc _).trans + ((periodicPath_length T hA g p 0).trans (zero_mul _)) + · intro i j he + have hc₂' : c • p.snd≠q.snd := by simpa only [q,inverseSegment_snd] using hc₂ + fin_cases i <;> fin_cases j + · rfl + · exact False.elim (hback (show p.snd=q.snd from he).symm) + · exact False.elim (hc₁ (show p.snd=c • p.snd from he).symm) + · exact False.elim (hback (show q.snd=p.snd from he)) + · rfl + · exact False.elim (hc₂' (show q.snd=c • p.snd from he).symm) + · exact False.elim (hc₁ (show c • p.snd=p.snd from he)) + · exact False.elim (hc₂' (show c • p.snd=q.snd from he)) + · rfl + · intro i n hn + obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hn) + fin_cases i + · exact periodicPath_snd T hA g p hpn k + · exact periodicPath_snd T hA g⁻¹ q hqn k + · change ((actPath T hA c (periodicPath T hA g p (k+1))).copy hc _).snd=c • p.snd + exact (actPath_copy_snd T hA c (periodicPath T hA g p (k+1)) hc _).trans + (congrArg (fun w : V => c • w) (periodicPath_snd T hA g p hpn k)) + · intro i R + fin_cases i + · exact periodic_shortcut_gromov T hA hT u v hfree hne hnadj g p hp hpn hturn a hau hav R + · exact periodic_shortcut_gromov T hA hT u v hfree hne hnadj g⁻¹ q hq hqn hqt (g⁻¹*a) hqu hqv R + · obtain ⟨N,hN⟩ := periodic_shortcut_gromov T hA hT u v hfree hne hnadj g p hp hpn hturn a hau hav R + refine ⟨N,?_⟩ + intro m hm n hn + change R ≤ graphProduct (avoidingGraph (G := G) T u v) x ((c*g^m) • x) ((c*g^n) • x) + rw [mul_smul,mul_smul] + have he := graphProduct_smul _ (avoidingGraph_connected T u v hT hA hne hnadj) + (avoidingGraph_preservesAdj T u v hA) c x (g^m • x) (g^n • x) + rw [hc] at he + rw [he] + exact hN m hm n hn + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedBlockBoundary.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedBlockBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..7b435316d482f94c3e6c1e10e77e33cd08fb1e0f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedBlockBoundary.lean @@ -0,0 +1,43 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedTypeComponent +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetExteriorCap +import OAI.Topology.ArtinGroups.Harmonic.NeighborhoodProject + +namespace OAI + +/-! Boundary caps for commuting closed components at any integer cutoff. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) (cutoff:ℤ) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +lemma pointedBlock_boundary_cap (P:Deligne M) (B:Set S) (hB:B⊆P.val.1) + (hc:∀i∈B,∀j∈P.val.1\B,M i j=2) (q:ℕ) (hq:∀i∈B,relativePeak M f cutoff P i=q) + (x:Artin M) (hx:x∈P.val.2) : + ∀H,ClassCapOn Q (pointedFamily M f x H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M B))\Set.range (unfoldedInclusion M B)) (cutoff+q) := by + intro H + rw [classCapOn_iff_level_zero] + intro α hα k hk + have ha:α∈closedNeighborhood Q (fusionColorRegion m (Sum.inl '' B)):=by + simpa only [unfoldedInclusion_range] using hα.1 + have ho':α∉fusionColorRegion m (Sum.inl '' B):=by simpa only [unfoldedInclusion_range] using hα.2 + have ho:α.1∉Sum.inl '' B:=ho' + have hv:=sourceNeighborhood_project M (Sum.inl '' B) ha + have hout:=sourceBlock_boundary_outside M P B hB hc α.1 hv ho + have hnb:∃i∈B,framedCartan M (.inl i) α.1<0:=by + rcases hv with hv|⟨u,hu,huv⟩ + · exact (ho hv).elim + · obtain ⟨i,hi,rfl⟩:=hu + exact ⟨i,hi,by rwa [framedCartan_symm]⟩ + have hn : 0 ≤ k-cutoff := by omega + have he : cutoff+((k-cutoff).toNat:ℤ)=k := by rw [Int.toNat_of_nonneg hn];omega + have hz:=pointedBlock_above_boundary M f cutoff P B hB q hq α.1 hnb (k-cutoff).toNat (by omega) + change pointedCosetVector M f P (cutoff+(k-cutoff).toNat) α.1=0 at hz + rw [he,pointedCosetVector_open_at M f P x hx α.1 hout k] at hz + exact (pointedMultiplicity_zero_iff M f x k α.1).mp hz H α.2 + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedBoundaryZero.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedBoundaryZero.lean new file mode 100644 index 0000000000000000000000000000000000000000..ddea9da72ce9b606ee29f0b4c16389e172f9d4ed --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedBoundaryZero.lean @@ -0,0 +1,172 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.BoundaryWitness +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedMultiplicityZero +import OAI.Topology.ArtinGroups.Complexes.EmptyTestIndex + +namespace OAI + +/-! The all-level connected-support argument in the nonspherical case of §8. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable + +section Fusion +variable {E V : Type} [Fintype E] [DecidableEq E] [Fintype V] [DecidableEq V] + (m : E → ℕ) (d : V → V → FusionEdge E) (hd : ∀ s t, d s t = d t s) + (hdiag : ∀ s, d s s = .units 0) (hm : ∀ e, 2 ≤ m e) + +/-- An unoperated exterior frame and an empty boundary exclude every +interior generator, including generators below the harmonic cutoff. -/ +theorem orbit_boundary_zero_interior_zero (w : List (V × Bool)) (s : V) + (hw : ∀ a ∈ w, a.1 ≠ s) (U : Set V) (hs : s ∉ U) + (hz : ∀ k v, v ∉ U → (∃ u ∈ U, fusionFoldedCartan m d v u < 0) → + fusionOrbitMultiplicity m d hd hdiag hm w s k v = 0) : + ∀ k v, v ∈ U → fusionOrbitMultiplicity m d hd hdiag hm w s k v = 0 := by + intro k v hv + apply le_antisymm _ (fusionOrbitMultiplicity_nonneg m d hd hdiag hm w s k v) + by_contra hn + have hp : 0 < fusionOrbitMultiplicity m d hd hdiag hm w s k v := lt_of_not_ge hn + obtain ⟨L, i, hi, _⟩ := orbit_generator_of_positive m d hd hdiag hm w s v k hp + obtain ⟨j, hj, _⟩ := orbit_frame_generator m d hd hdiag w s hw L + obtain ⟨b, hb⟩ := fusionOrbit_support_meets_boundary m d hd hdiag w s L + (fusionColorRegion m U) i j (by change _ ∈ U; rwa [hi]) + (by change _ ∉ U; rw [congrArg Prod.fst hj]; exact hs) + let q := ((fusionOrbitModel m d hd hdiag w s L).complex.placement b).level + have he := fusionOrbit_boundary_absent m d hd hdiag hm w s q U (hz q) L ⟨b, rfl⟩ + exact he hb +end Fusion + +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "diag" => coxeterFusionEdge_diag M +local notation "Q" => fusionQuiver m d hd + +/-- Connectedness of the actual pointed family converts an all-level +exterior boundary vanishing statement to interior vanishing. -/ +theorem pointed_boundary_zero_interior_zero (x : Artin M) + (hx : x ∈ artinParabolic M {f}ᶜ) (K : Set S) (hf : f ∉ K) + (hz : ∀ k v, v ∉ Sum.inl '' K → + (∃ u ∈ Sum.inl '' K, framedCartan M v u < 0) → + pointedMultiplicity M f x k v = 0) : + ∀ k i, i ∈ K → pointedMultiplicity M f x k (.inl i) = 0 := by + obtain ⟨w, hw, rfl⟩ := artinParabolic_signed_word M {f}ᶜ x hx + have hC : fusionFoldedCartan m d = framedCartan M := by + convert fusionFoldedCartan_eq_framedCartan M using 1 + congr 1 + exact Subsingleton.elim _ _ + have hh := orbit_boundary_zero_interior_zero m d hd diag (fusionLabelSize_ge_two M) + (sourcePacketWord w) (.inl f) + (by + intro a ha he + obtain ⟨b, hb, rfl⟩ := List.mem_map.mp ha + exact hw b hb (Sum.inl.inj he)) (Sum.inl '' K) + (by rintro ⟨i, hi, he⟩; exact hf (Sum.inl.inj he ▸ hi)) + (by simpa only [hC, pointedMultiplicity_word] using hz) + intro k i hi + simpa only [pointedMultiplicity_word] using hh k (.inl i) ⟨i, hi, rfl⟩ + +/-- Termwise absence in a closed neighborhood makes its negative twists +identity maps on each member of the pointed family. -/ +theorem pointed_negativeTwist_of_zero (x : Artin M) (K : Set S) + (hz : ∀ k v, v ∈ Sum.inl '' K ∨ + (∃ u ∈ Sum.inl '' K, framedCartan M v u < 0) → + pointedMultiplicity M f x k v = 0) + (i : S) (hi : i ∈ K) (L H : FusionLabel m) : + classNegativeTwist Q (.inl i, L) (pointedFamily M f x H) = pointedFamily M f x H := by + let E := minimalClassModel Q (pointedFamily M f x H) + have hC : fusionFoldedCartan m d = framedCartan M := by + convert fusionFoldedCartan_eq_framedCartan M using 1 + congr 1 + exact Subsingleton.elim _ _ + have hE : ∀ a : E.Index, (E.complex.placement a).color ∉ + closedNeighborhood Q (fusionColorRegion m (Sum.inl '' K)) := by + intro a ha + let v := (E.complex.placement a).color.1 + let k := (E.complex.placement a).level + have hv : pointedMultiplicity M f x k v = 0 := by + rcases ha with ha | ⟨β, hβ, r, hr, he⟩ + · obtain ⟨j, hj, he⟩ := ha + have hv : v = .inl j := he.symm + rw [hv] + exact hz k (.inl j) (Or.inl ⟨j, hj, rfl⟩) + · obtain ⟨j, hj, hej⟩ := hβ + have hc := fusion_arrow_color_cartan_neg m d (fusionLabelSize_ge_two M) r + have ht : r.1.2.1 = v := congrArg Prod.fst he + have hs : r.1.1.1 = .inl j := (congrArg Prod.fst hr).trans hej.symm + by_cases hne : r.1.1.1 = r.1.2.1 + · have hv : v = .inl j := ht ▸ hne ▸ hs + rw [hv] + exact hz k (.inl j) (Or.inl ⟨j, hj, rfl⟩) + · have hneg := hc hne + rw [hs, ht, hC, framedCartan_symm] at hneg + exact hz k v (Or.inr ⟨.inl j, ⟨j, hj, rfl⟩, hneg⟩) + have hn := (pointedMultiplicity_zero_iff M f x k v).mp hv H + (E.complex.placement a).color.2 + rw [classLevelArray_minimal_apply] at hn + have hp : 0 < Nat.card {b : E.Index // (E.complex.placement b).color = + (E.complex.placement a).color ∧ (E.complex.placement b).level = k} := by + rw [Nat.card_eq_fintype_card, Fintype.card_pos_iff] + exact ⟨⟨a, rfl, rfl⟩⟩ + exact (ne_of_gt hp) hn + have h := classNegativeTwist_far Q E.complex (fusionColorRegion m (Sum.inl '' K)) + hE (.inl i, L) ⟨i, hi, rfl⟩ + have hm : classOfComplex Q E.complex = pointedFamily M f x H := + minimalClassModel_class Q _ + rw [hm] at h + exact h + +/-- Vanishing on a full closed neighborhood makes the standard subgroup +fix the actual family, with no restriction on the levels. -/ +theorem pointed_standard_fixes_of_closed_zero (x : Artin M) (K : Set S) + (hz : ∀ k v, v ∈ Sum.inl '' K ∨ + (∃ u ∈ Sum.inl '' K, framedCartan M v u < 0) → + pointedMultiplicity M f x k v = 0) + (g : Artin M) (hg : g ∈ artinParabolic M K) : + pointedFamily M f (g * x) = pointedFamily M f x := by + have hpos (i : S) (hi : i ∈ K) (L H : FusionLabel m) : + classPositiveTwist Q (.inl i, L) (pointedFamily M f x H) = + pointedFamily M f x H := by + let e := classTwistPerm Q (K := ℂ) (fusionQuiver_no_loops m d hd diag) (.inl i, L) + have hn := pointed_negativeTwist_of_zero M f x K hz i hi L H + calc + _ = e (e.symm (pointedFamily M f x H)) := congrArg e hn.symm + _ = _ := e.apply_symm_apply _ + have hgen (i : S) (hi : i ∈ K) (H : FusionLabel m) : + pointedAction M (generator M i) (pointedFamily M f x H) = + pointedFamily M f x H := by + rw [pointedAction_generator, fusionPacketPerm, ← classPacketPerm_toList] + have hlist (l : List (FusionLabel m)) : + (l.map (fun L => classTwistPerm Q (fusionQuiver_no_loops m d hd diag) + (.inl i, L))).prod (pointedFamily M f x H) = pointedFamily M f x H := by + induction l with + | nil => rfl + | cons L l ih => + change classPositiveTwist Q (.inl i, L) + ((l.map (fun J => classTwistPerm Q (fusionQuiver_no_loops m d hd diag) + (.inl i, J))).prod (pointedFamily M f x H)) = _ + rw [ih] + exact hpos i hi L H + exact hlist _ + have hall (H : FusionLabel m) : + pointedAction M g (pointedFamily M f x H) = pointedFamily M f x H := by + induction hg using Subgroup.closure_induction with + | mem g hg => + obtain ⟨i, hi, rfl⟩ := hg + exact hgen i hi H + | one => simp only [map_one, Equiv.Perm.one_apply] + | mul g h hg hh ihg ihh => + simp only [map_mul, Equiv.Perm.mul_apply, ihh, ihg] + | inv g hg ih => + rw [map_inv] + apply (pointedAction M g).injective + change (pointedAction M g) ((pointedAction M g).symm _) = _ + rw [Equiv.apply_symm_apply, ih] + funext H + change pointedAction M (g * x) (pointedInitial M f H) = _ + rw [map_mul, Equiv.Perm.mul_apply] + exact hall H + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidate.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidate.lean new file mode 100644 index 0000000000000000000000000000000000000000..5bd1a53066b3fb46221a1ef3b5bf15a6c6babfe8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidate.lean @@ -0,0 +1,86 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCandidateComparison +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.Harmonic.Candidate +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Harmonic +import OAI.Topology.ArtinGroups.Harmonic.ProbePositiveWordLeft + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag.BasedComplex _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "U" => fun J:Set S=>Set.range (unfoldedInclusion M J) + +structure PointedCandidate (T J:Set S) (z:Artin M) (q:ℤ) : Prop where + proper : J⊂T + cap : ∀H,ClassCapOn Q (pointedFamily M f z H) (closedNeighborhood Q (U T) \ U J) q + negative : ∀s∈T,s∉J→(framedCartan M *ᵥ pointedHarmonicAt M f J z q) (.inl s)<0 + representatives : ∀y∈rightCoset M J z, + (∀H,ClassCapOn Q (pointedFamily M f y H) (U T) q)→ + ∀j:J,pointedHarmonicAt M f J z q (.inl (j:S))≤ pointedMultiplicity M f y q (.inl (j:S)) + +lemma pointedCandidate_capped (T J:Set S) (hT:IsSpherical M T) (z:Artin M) (q:ℤ) + (X:PointedCandidate M f T J z q) : + ∃a∈artinParabolic M J, + PointedCappedCandidate M f T J (a*z) q (pointedHarmonicAt M f J z q) := by + have hJ:=source_spherical_mono M X.proper.subset hT + obtain ⟨a,ha,hcap⟩:=source_finiteFamily_cap_accessible M J hJ (pointedFamily M f z) q + (by intro H i hi; exact X.cap H i ⟨closedNeighborhood_mono Q + (unfoldedInclusion_range_mono M X.proper.subset) hi.1,hi.2⟩) + have hc:∀H,ClassCapOn Q (pointedFamily M f (a*z) H) (closedNeighborhood Q (U T)) q := by + intro H + dsimp only + rw [unfoldedInclusion_range M T] + apply source_cap_closed_of_cap_parts M T J X.proper.subset _ q + · rw [pointedFamily_mul]; exact hcap H + · rw [pointedFamily_mul] + apply sourceArtinAction_cap_exterior M J a ha _ _ (fun _ membership=>membership.2) q + simpa only [unfoldedInclusion_range M T,unfoldedInclusion_range M J] using X.cap H + have hC : fusionFoldedCartan m (coxeterFusionEdge M) = framedCartan M := by + convert fusionFoldedCartan_eq_framedCartan M using 1 + congr 1 + exact Subsingleton.elim _ _ + refine ⟨a,ha,X.proper.subset,hJ,hc,?_,?_,?_,?_⟩ + · intro j + rw [hC] + exact pointedHarmonicAt_harmonic M f J hJ z q ⟨.inl (j:S),⟨j,j.property,rfl⟩⟩ + · intro v hv + rw [pointedMultiplicity_exterior_ordered M f J a ha z v hv q,pointedHarmonicAt_outside M f J z q v hv] + · rw [hC] + exact X.negative + · intro b hb hbc j + apply X.representatives (b*(a*z)) _ hbc j + change b*(a*z)*z⁻¹∈artinParabolic M J + simpa only [mul_assoc,mul_inv_cancel,mul_one] using (artinParabolic M J).mul_mem hb ha + +theorem pointedCandidate_unique (T J J':Set S) (hT:IsSpherical M T) + (z h:Artin M) (hh:h∈artinParabolic M T) (q:ℤ) + (X:PointedCandidate M f T J z q) (Y:PointedCandidate M f T J' (h*z) q) : + J=J' ∧ rightCoset M J z=rightCoset M J' (h*z) := by + obtain ⟨a,ha,hX⟩:=pointedCandidate_capped M f T J hT z q X + obtain ⟨b,hb,hY⟩:=pointedCandidate_capped M f T J' hT (h*z) q Y + let k:=b*h*a⁻¹ + have hk:k∈artinParabolic M T := (artinParabolic M T).mul_mem + ((artinParabolic M T).mul_mem (artinParabolic_mono M Y.proper.subset hb) hh) + ((artinParabolic M T).inv_mem (artinParabolic_mono M X.proper.subset ha)) + have he:k*(a*z)=b*(h*z) := by dsimp [k]; group + have hY':PointedCappedCandidate M f T J' (k*(a*z)) q (pointedHarmonicAt M f J' (h*z) q) := by + rw [he]; exact hY + obtain ⟨_,hj,hkJ⟩:=pointedCandidate_comparison_parabolic M f T J J' hT (a*z) k hk q _ _ hX hY' + subst J' + have heh:h=b⁻¹*k*a := by dsimp [k]; group + have hhJ:h∈artinParabolic M J := by + rw [heh] + exact (artinParabolic M J).mul_mem ((artinParabolic M J).mul_mem + ((artinParabolic M J).inv_mem hb) hkJ) ha + exact ⟨rfl,(rightCoset_mul_eq M J h z hhJ).symm⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateBlock.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateBlock.lean new file mode 100644 index 0000000000000000000000000000000000000000..cea750dffa6efee94d8c9748dcb225ae452d95c3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateBlock.lean @@ -0,0 +1,86 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCandidateNumerical +import OAI.Topology.ArtinGroups.Harmonic.CandidateBlockNonpos +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.FoldedSphericalPos +import OAI.Topology.ArtinGroups.Harmonic.ProbeOrbitAbsent +import OAI.Topology.ArtinGroups.Complexes.LevelArrayBelow + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "R" => probeQuiver Q +local notation "bw" => sourceProbeAction M (K:=ℂ) +local notation "C" => fusionFoldedCartan m d + +lemma pointedCandidate_block_nonpos (T J:Set S) (z h:Artin M) + (hh:h∈artinParabolic M T) (q:ℤ) (p:S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (Y:PointedCappedCandidate M f T J (h*z) q p) + (s t:S) (hs:s∈T) (hsJ:s∉J) (ht:t∈T) (htJ:t∉J) + (L H:FusionLabel m) (b:Bool) (l:ℤ) (hl:l≤0) : + classLevelArray R (bw h⁻¹ (initialClass R (.inr ((.inl s,L),b)))) (.inl (.inl t,H),l)=0 := by + let α:FusionVertex (V:=S⊕Unit) m:=(.inl s,L) + let β:FusionVertex (V:=S⊕Unit) m:=(.inl t,H) + obtain ⟨a,ha,hcap,hlower,hsoc⟩:=pointedProbe_zero_saturation M f T J z h q p X hh + (fun H i hi=>Y.cap H i (Or.inl hi)) + (fun _:Unit=>α) (fun _=>⟨(⟨s,hs⟩,L),rfl⟩) (fun _=>b) + have haT:=artinParabolic_mono M X.subset ha + have hg:(h*a⁻¹)∈artinParabolic M T:= + (artinParabolic M T).mul_mem hh ((artinParabolic M T).inv_mem haT) + have hei:(h*a⁻¹)⁻¹=a*h⁻¹:=by simp only [_root_.mul_inv_rev,inv_inv] + have he:(h*a⁻¹)*(a*z)=h*z:=by simp only [_root_.mul_assoc,inv_mul_cancel_left] + have hβ:β∉Set.range (unfoldedInclusion M J):=by + rintro ⟨⟨j,_⟩,he⟩ + have hj:(j:S)=t:=Sum.inl.inj (congrArg Prod.fst he) + exact htJ (hj ▸ j.property) + rw [←sourceProbe_block_left M J a h⁻¹ ha α β hβ b l] + rcases lt_or_eq_of_le hl with hl|rfl + · exact classLevelArray_below R _ 0 l (hlower ()) hl (.inl β) + · have hu:=(X.move a ha hcap).probe_euler (h*a⁻¹) hg α b 0 (by rw [hei]; exact hsoc ()) + have hα:(Sum.inl s:S⊕Unit)∉Sum.inl '' J:=by + rintro ⟨j,hj,he⟩ + exact hsJ (Sum.inl.inj he ▸ hj) + dsimp only at hu + rw [ite_eq_left rfl,sub_zero,he,Y.exterior (.inl s) hα,hei] at hu + by_contra hz + have hn:0generatorVector R N (.inl γ)) ⬝ᵥ fusionFold m (C *ᵥ p)<0:=by + apply Finset.sum_neg' (fun γ _=>sourceProbe_core_term_nonpos M (K:=ℂ) T (a*h⁻¹) hg' α γ b 0 p X.cartan_nonpos) + exact ⟨β,Finset.mem_univ _,hterm⟩ + change _-(fun γ=>generatorVector R N (.inl γ)) ⬝ᵥ fusionFold m (C *ᵥ p)≤_ at hu + linarith + +theorem pointedCandidate_zero_block (T J J':Set S) (hT:IsSpherical M T) (z h:Artin M) + (hh:h∈artinParabolic M T) (q:ℤ) (p p':S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (Y:PointedCappedCandidate M f T J' (h*z) q p') : + p=p' ∧ J=J' ∧ ∀s∈T,s∉J→∀t∈T,t∉J→∀L H b l, + classLevelArray R (bw h (initialClass R (.inr ((.inl s,L),b)))) (.inl (.inl t,H),l)=0 := by + obtain ⟨rfl,rfl⟩:=pointedCandidate_numerical_unique M f T J J' hT z h hh q p p' X Y + refine ⟨rfl,rfl,?_⟩ + intro s hs hsJ t ht htJ L H b l + by_cases hl:l≤0 + · have hz:=pointedCandidate_block_nonpos M f T J (h*z) h⁻¹ ((artinParabolic M T).inv_mem hh) + q p Y (by simpa only [inv_mul_cancel_left] using X) s t hs hsJ ht htJ L H b l hl + simpa only [inv_inv] using hz + · rw [sourceProbe_level_dual M T h hh (.inl s,L) (.inl t,H) b l] + exact pointedCandidate_block_nonpos M f T J z h hh q p X Y t s ht htJ hs hsJ H L (!b) (-l) (by omega) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateCapped.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateCapped.lean new file mode 100644 index 0000000000000000000000000000000000000000..48e8492a60c3f48fd0828bda76583228bd7ca07f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateCapped.lean @@ -0,0 +1,45 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProbeRaiseLower +import OAI.Topology.ArtinGroups.Harmonic.CandidateCapped +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.ProbeRaiseLower + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "R" => probeQuiver Q +local notation "bw" => sourceProbeAction M (K:=ℂ) +local notation "C" => fusionFoldedCartan m d + +theorem pointedCandidate_le_capped (T J:Set S) (z h:Artin M) (q:ℤ) (p:S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (hh:h∈artinParabolic M T) + (hzh:∀H,ClassCapOn Q (pointedFamily M f (h*z) H) + (Set.range (unfoldedInclusion M T)) q) (s:S) (hs:s∈T) : + p (.inl s)≤ pointedMultiplicity M f (h*z) q (.inl s) := by + let L:=fusionZeroLabel m (fusionLabelSize_ge_two M) + let α:FusionVertex (V:=S⊕Unit) m:=(.inl s,L) + obtain ⟨a,ha,hcap,_,hsoc⟩:=pointedProbe_zero_saturation M f T J z h q p X hh hzh + (fun _:Unit=>α) (fun _=>⟨(⟨s,hs⟩,L),rfl⟩) (fun _=>false) + have haT:=artinParabolic_mono M X.subset ha + have hg:(h*a⁻¹)∈artinParabolic M T:= + (artinParabolic M T).mul_mem hh ((artinParabolic M T).inv_mem haT) + have hei:(h*a⁻¹)⁻¹=a*h⁻¹:=by simp only [_root_.mul_inv_rev,inv_inv] + have he:(h*a⁻¹)*(a*z)=h*z:=by simp only [_root_.mul_assoc,inv_mul_cancel_left] + have hu:=(X.move a ha hcap).probe_euler (h*a⁻¹) hg α false 0 (by rw [hei];exact hsoc ()) + have hn:=sourceProbe_core_dot_nonpos M (K:=ℂ) T (h*a⁻¹)⁻¹ + ((artinParabolic M T).inv_mem hg) α false 0 p X.cartan_nonpos + dsimp only at hu hn + rw [ite_eq_left rfl,sub_zero,he] at hu + have hw:fusionWeight m α.2*p α.1≤fusionWeight m α.2*pointedMultiplicity M f (h*z) q α.1:=by linarith + exact (mul_le_mul_iff_right₀ (fusionWeight_pos m (fusionLabelSize_ge_two M) L)).mp hw + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateComparison.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateComparison.lean new file mode 100644 index 0000000000000000000000000000000000000000..907701bc453cb84d0a3b44c9d5fb620557792d7b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateComparison.lean @@ -0,0 +1,30 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCandidateFixed +import OAI.Topology.ArtinGroups.Harmonic.ProbePositiveWordLeft +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.FiniteArtinPositiveLeft +import OAI.Topology.ArtinGroups.Harmonic.InitialProbe +import OAI.Topology.ArtinGroups.Harmonic.ProbeFixedDiagonal + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "R" => probeQuiver Q + +theorem pointedCandidate_comparison_parabolic (T J J':Set S) (hT:IsSpherical M T) + (z h:Artin M) (hh:h∈artinParabolic M T) (q:ℤ) (p p':S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (Y:PointedCappedCandidate M f T J' (h*z) q p') : + p=p' ∧ J=J' ∧ h∈artinParabolic M J := by + obtain ⟨hp,hj,hfix⟩:=pointedCandidate_fixed_probes M f T J J' hT z h hh q p p' X Y + exact ⟨hp,hj,sourceProbe_parabolic_detector M T J hT h hh hfix⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateFixed.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateFixed.lean new file mode 100644 index 0000000000000000000000000000000000000000..0393c4d04844e309373f3027f51b5c44e4588a70 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateFixed.lean @@ -0,0 +1,35 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCandidateBlock +import OAI.Topology.ArtinGroups.Harmonic.ProbeFixedDiagonal +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.CandidateBlockNonpos +import OAI.Topology.ArtinGroups.Complexes.ProbeFixedNoDiagonal +import OAI.Topology.ArtinGroups.Complexes.GeneratorArrayZeroLevel + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "R" => probeQuiver Q +local notation "bw" => sourceProbeAction M (K:=ℂ) + +theorem pointedCandidate_fixed_probes (T J J':Set S) (hT:IsSpherical M T) (z h:Artin M) + (hh:h∈artinParabolic M T) (q:ℤ) (p p':S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (Y:PointedCappedCandidate M f T J' (h*z) q p') : + p=p' ∧ J=J' ∧ ∀s∈T,s∉J→∀L b, + sourceProbeAction M (K:=ℂ) h (initialClass R (.inr ((.inl s,L),b)))= + initialClass R (.inr ((.inl s,L),b)) := by + obtain ⟨he,hj,hz⟩:=pointedCandidate_zero_block M f T J J' hT z h hh q p p' X Y + refine ⟨he,hj,?_⟩ + intro s hs hsJ L b + exact sourceProbe_fixed_of_diagonal M T h hh (.inl s,L) b (hz s hs hsJ s hs hsJ L L b) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateNumerical.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateNumerical.lean new file mode 100644 index 0000000000000000000000000000000000000000..13fedc4ea1b73375a25a675f994046fa3cdde4c1 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCandidateNumerical.lean @@ -0,0 +1,104 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCandidateCapped +import OAI.Topology.ArtinGroups.Harmonic.FoldedSphericalPos +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.CandidateCapped + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "C" => fusionFoldedCartan m d + +theorem pointedCandidate_numerical_unique (T J J':Set S) (hT:IsSpherical M T) + (z h:Artin M) (hh:h∈artinParabolic M T) (q:ℤ) (p p':S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (Y:PointedCappedCandidate M f T J' (h*z) q p') : + p=p' ∧ J=J' := by + have hforward:∀s∈T,s∉J'→p (.inl s)≤p' (.inl s):=by + intro s hs hj + have hv:(Sum.inl s:S⊕Unit)∉Sum.inl '' J':=by + rintro ⟨t,ht,he⟩ + exact hj (Sum.inl.inj he ▸ ht) + rw [←Y.exterior (.inl s) hv] + exact pointedCandidate_le_capped M f T J z h q p X hh + (fun H i hi=>Y.cap H i (Or.inl hi)) s hs + have hreverse:∀s∈T,s∉J→p' (.inl s)≤p (.inl s):=by + intro s hs hj + have hv:(Sum.inl s:S⊕Unit)∉Sum.inl '' J:=by + rintro ⟨t,ht,he⟩ + exact hj (Sum.inl.inj he ▸ ht) + have hm:=pointedCandidate_le_capped M f T J' (h*z) h⁻¹ q p' Y ((artinParabolic M T).inv_mem hh) + (by rw [inv_mul_cancel_left]; exact fun H i hi=>X.cap H i (Or.inl hi)) s hs + simpa only [inv_mul_cancel_left,X.exterior (.inl s) hv] using hm + have hext:∀v,v∉Sum.inl '' T→p v=p' v := by + intro v hv + have hvJ:v∉Sum.inl '' J:=fun ⟨s,hs,he⟩=>hv ⟨s,X.subset hs,he⟩ + have hvJ':v∉Sum.inl '' J':=fun ⟨s,hs,he⟩=>hv ⟨s,Y.subset hs,he⟩ + rw [←X.exterior v hvJ,←Y.exterior v hvJ',pointedMultiplicity_exterior_ordered M f T h hh z v hv q] + let f:=sourceRootInclusion T + let a:T→ℝ:=fun i=>-(C *ᵥ p) (f i) + let a':T→ℝ:=fun i=>-(C *ᵥ p') (f i) + have hf:Function.Injective f:=sourceRootInclusion_injective T + have he:rootExtension f ((p'-p)∘f)=p'-p:=rootExtension_restrict f hf (p'-p) (by + intro v hv + apply sub_eq_zero.mpr + apply (hext v ?_).symm + rintro ⟨s,hs,rfl⟩ + exact hv ⟨⟨s,hs⟩,rfl⟩) + have hrow:a'-a=-((C).submatrix f f *ᵥ ((p'∘f)-(p∘f))) := by + funext i + have hc:=rootExtension_mulVec C f ((p'-p)∘f) i + rw [he,mulVec_sub] at hc + change -(C *ᵥ p') (f i) - -(C *ᵥ p) (f i)= -(_) + change (C *ᵥ p') (f i)-(C *ᵥ p) (f i)=_ at hc + have hd:(p'∘f)-(p∘f)=(p'-p)∘f:=rfl + rw [hd,←hc] + ring + have hfor:0≤a' ⬝ᵥ ((p'∘f)-(p∘f)) := by + apply Finset.sum_nonneg + intro i hi + by_cases hj:(i:S)∈J' + · have hz:=Y.harmonic ⟨i,hj⟩ + change -(C *ᵥ p') (.inl (i:S)) * (p' (.inl (i:S))-p (.inl (i:S)))≥0 + rw [hz,neg_zero,MulZeroClass.zero_mul] + · exact mul_nonneg (neg_nonneg.mpr (Y.cartan_nonpos i i.property)) + (sub_nonneg.mpr (hforward i i.property hj)) + have hrev:0≤a ⬝ᵥ ((p∘f)-(p'∘f)) := by + apply Finset.sum_nonneg + intro i hi + by_cases hj:(i:S)∈J + · have hz:=X.harmonic ⟨i,hj⟩ + change -(C *ᵥ p) (.inl (i:S)) * (p (.inl (i:S))-p' (.inl (i:S)))≥0 + rw [hz,neg_zero,MulZeroClass.zero_mul] + · exact mul_nonneg (neg_nonneg.mpr (X.cartan_nonpos i i.property)) + (sub_nonneg.mpr (hreverse i i.property hj)) + have hp:=harmonic_two_point_equality ((C).submatrix f f) (source_folded_spherical_posDef M T hT) + (p∘f) (p'∘f) a a' hrow hfor hrev + have hep:p=p':=by + funext v + by_cases hv:v∈Sum.inl '' T + · obtain ⟨s,hs,rfl⟩:=hv + exact congrFun hp.1 ⟨s,hs⟩ + · exact hext v hv + refine ⟨hep,?_⟩ + apply Set.Subset.antisymm + · intro s hs + by_contra hj + have hn:=Y.negative s (X.subset hs) hj + rw [←hep,X.harmonic ⟨s,hs⟩] at hn + exact lt_irrefl _ hn + · intro s hs + by_contra hj + have hn:=X.negative s (Y.subset hs) hj + rw [hep,Y.harmonic ⟨s,hs⟩] at hn + exact lt_irrefl _ hn + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCap.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCap.lean new file mode 100644 index 0000000000000000000000000000000000000000..f81d009d94ed0ad54de4a848b1b862a1600bc11e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCap.lean @@ -0,0 +1,60 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.Harmonic.UnfoldedInclusionRangeMono +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.FrameFamilyWeightedLevel + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) + +lemma pointed_cap_closed_mono {J T:Set S} (h:J⊆T) (z:Artin M) (q:ℤ) + (hz:∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) : + ∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q := by + intro H i hi + exact hz H i (closedNeighborhood_mono Q (unfoldedInclusion_range_mono M h) hi) + +lemma pointed_cap_closed_extend (T J:Set S) (h:J⊆T) + (z a:Artin M) (ha:a∈artinParabolic M J) (q:ℤ) + (hz:∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) + (hza:∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q) : + ∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q := by + intro H + rw [unfoldedInclusion_range] + apply source_cap_closed_of_cap_parts M T J h _ q (hza H) + rw [pointedFamily_mul] + apply sourceArtinAction_cap_exterior M J a ha _ _ (fun α hα=>hα.2) q + intro i hi + apply hz H i + rw [unfoldedInclusion_range] + exact hi.1 + +lemma pointedMultiplicity_cap_zero (T:Set S) (z:Artin M) (q k:ℤ) (hq:q fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "R" => probeQuiver Q +local notation "bw" => sourceProbeAction M (K:=ℂ) + +theorem pointedProbe_cap_saturation {B:Type*} + (T J:Set S) (hJT:J⊆T) (hJ:IsSpherical M J) + (z h:Artin M) (hh:h∈artinParabolic M T) (q l:ℤ) (hl:l≤0) + (hz:∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) + (hzh:∀H,ClassCapOn Q (pointedFamily M f (h*z) H) + (Set.range (unfoldedInclusion M T)) q) + (α:B→FusionVertex (V:=S⊕Unit) m) (ha:∀r,α r∈Set.range (unfoldedInclusion M T)) + (b:B→Bool) + (hy:∀r,ClassLowerBound R l (bw h⁻¹ (initialClass R (.inr (α r,b r))))) : + ∃ a∈artinParabolic M J, + (∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) ∧ + (∀r,ClassLowerBound R l (bw (a*h⁻¹) (initialClass R (.inr (α r,b r))))) ∧ + ∀r (j:J) L c,classLayerSocleDimension R l (.inl (.inl j,L)) c + (bw (a*h⁻¹) (initialClass R (.inr (α r,b r))))=0 := by + let x:=fun r=>bw h⁻¹ (initialClass R (.inr (α r,b r))) + let P:List J→Prop:=fun w=>∀H,ClassCapOn Q + (pointedFamily M f (wordArtin M (w.map Subtype.val)*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q + have hP:P []:=by simpa only [P,List.map_nil,wordArtin,List.prod_nil,_root_.one_mul] using hz + have he (w:List J) (r:B) : probePositiveWord M J w (x r)= + bw (h*(wordArtin M (w.map Subtype.val))⁻¹)⁻¹ (initialClass R (.inr (α r,b r))) := by + simp only [probePositiveWord,x,mul_inv_rev,inv_inv,map_mul,Equiv.Perm.mul_apply] + have step:∀w,(restrictedMatrix M J).toCoxeterSystem.IsReduced w→P w→ + ∀j:J,(∃r L c,0 fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "R" => probeQuiver Q +local notation "bw" => sourceProbeAction M (K:=ℂ) +local notation "C" => fusionFoldedCartan m d + +structure PointedCappedCandidate (T J:Set S) (z:Artin M) (q:ℤ) (p:S⊕Unit→ℝ) : Prop where + subset : J⊆T + spherical : IsSpherical M J + cap : ∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q + harmonic : ∀j:J,(C *ᵥ p) (.inl (j:S))=0 + exterior : ∀v,v∉Sum.inl '' J→pointedMultiplicity M f z q v=p v + negative : ∀s∈T,s∉J→(C *ᵥ p) (.inl s)<0 + representatives : ∀a∈artinParabolic M J, + (∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (Set.range (unfoldedInclusion M T)) q)→ + ∀j:J,p (.inl (j:S))≤ pointedMultiplicity M f (a*z) q (.inl (j:S)) + +namespace PointedCappedCandidate +variable {M} {f:S} {T J:Set S} {z:Artin M} {q:ℤ} {p:S⊕Unit→ℝ} + +lemma cartan_nonpos (X:PointedCappedCandidate M f T J z q p) (s:S) (hs:s∈T) : + (C *ᵥ p) (.inl s)≤0 := by + by_cases hj:s∈J + · exact (X.harmonic ⟨s,hj⟩).le + · exact (X.negative s hs hj).le + +lemma move (X:PointedCappedCandidate M f T J z q p) (a:Artin M) (ha:a∈artinParabolic M J) + (hc:∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) : + PointedCappedCandidate M f T J (a*z) q p := by + refine ⟨X.subset,X.spherical,hc,X.harmonic,?_,X.negative,?_⟩ + · intro v hv + rw [pointedMultiplicity_exterior_ordered M f J a ha z v hv q] + exact X.exterior v hv + · intro b hb hcap j + have hh:=X.representatives (b*a) ((artinParabolic M J).mul_mem hb ha) + (by simpa only [_root_.mul_assoc] using hcap) j + simpa only [_root_.mul_assoc] using hh + +lemma local_representatives (X:PointedCappedCandidate M f T J z q p) + (a:Artin M) (ha:a∈artinParabolic M J) + (hc:∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q) : + ∀j:J,p (.inl (j:S))≤ pointedMultiplicity M f (a*z) q (.inl (j:S)) := by + apply X.representatives a ha + have hh:=pointed_cap_closed_extend M f T J X.subset z a ha q X.cap hc + exact fun H i hi=>hh H i (Or.inl hi) + +lemma probe_euler (X:PointedCappedCandidate M f T J z q p) + (g:Artin M) (hg:g∈artinParabolic M T) + (α:FusionVertex (V:=S⊕Unit) m) (b:Bool) (l:ℤ) + (hsoc:∀j:J,∀L c,classLayerSocleDimension R l (.inl (.inl j,L)) c + (bw g⁻¹ (initialClass R (.inr (α,b))))=0) : + let N:=((minimalClassModel R (bw g⁻¹ (initialClass R (.inr (α,b))))).complex.pureLayer R + (minimalClassModel_minimal R _) l); + (if l=0 then fusionWeight m α.2*p α.1 else 0)- + (fun β=>generatorVector R N (.inl β)) ⬝ᵥ fusionFold m (C *ᵥ p) ≤ + fusionWeight m α.2*pointedMultiplicity M f (g*z) (q-l) α.1 := by + apply pointedGroup_probe_euler M f J T X.spherical z g hg q p + (pointed_cap_closed_mono M f X.subset z q X.cap) X.harmonic X.exterior + X.local_representatives α b l + intro j L c + exact Submodule.finrank_eq_zero.mp (hsoc j L c) + +end PointedCappedCandidate +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetExteriorCap.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetExteriorCap.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e0387e26f0516f7be457a133afee3688694ee57 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetExteriorCap.lean @@ -0,0 +1,87 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedMultiplicityZero +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.CosetExteriorCap +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.ResidueAllowed +import OAI.Topology.ArtinGroups.Harmonic.MultiplicityZero + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +lemma pointedCoset_exterior_cap (P:Deligne M) (x z:Artin M) (hx:x∈P.val.2) (hz:z∈P.val.2) + (U:Set (FusionVertex (V:=S⊕Unit) m)) (hU:∀α∈U,α.1∉Sum.inl '' P.val.1) (q:ℤ) + (h:∀H,ClassCapOn Q (pointedFamily M f x H) U q) : + ∀H,ClassCapOn Q (pointedFamily M f z H) U q := by + have hg:z*x⁻¹∈artinParabolic M P.val.1 := by + rw [←sourceCoset_eq M P x hx] at hz + exact hz + have he:z=(z*x⁻¹)*x:=by group + intro H + rw [he,pointedFamily_mul] + exact sourceArtinAction_cap_exterior M P.val.1 _ hg _ U hU q (h H) + +lemma pointedCoset_exterior_multiplicity (P:Deligne M) (x z:Artin M) (hx:x∈P.val.2) (hz:z∈P.val.2) + (v:S⊕Unit) (hv:v∉Sum.inl '' P.val.1) (q:ℤ) : + pointedMultiplicity M f z q v=pointedMultiplicity M f x q v := by + have hg:z*x⁻¹∈artinParabolic M P.val.1 := by + rw [←sourceCoset_eq M P x hx] at hz + exact hz + have he:z=(z*x⁻¹)*x:=by group + rw [he] + exact pointedMultiplicity_exterior_ordered M f P.val.1 _ hg x v hv q + +lemma pointedCosetVector_open_at (P:Deligne M) (z:Artin M) (hz:z∈P.val.2) + (v:S⊕Unit) (hv:v∉Sum.inl '' P.val.1) (q:ℤ) : + pointedCosetVector M f P q v=pointedMultiplicity M f z q v := by + rw [pointedCosetVector_eq M f P z hz q] + exact pointedHarmonicAt_outside M f P.val.1 z q v hv + +lemma pointedResidue_exterior_cap {strict:Bool} {P X:Deligne M} {q:ℤ} + (h:PointedResidueAllowed M f strict P X q) (x z:Artin M) (hx:x∈P.val.2) (hz:z∈X.val.2) + (U:Set (FusionVertex (V:=S⊕Unit) m)) + (hE:∀H,ClassCapOn Q (pointedFamily M f x H) (U\fusionColorRegion m (Sum.inl '' P.val.1)) q) : + ∀H,ClassCapOn Q (pointedFamily M f z H) (U\fusionColorRegion m (Sum.inl '' X.val.1)) q := by + have hout:=pointedCoset_exterior_cap M f P x z hx (h.1.le.2 hz) + (U\fusionColorRegion m (Sum.inl '' P.val.1)) (fun α hα=>hα.2) q hE + intro H + rw [classCapOn_iff_level_zero] + intro α hα k hk + by_cases hp:α.1∈Sum.inl '' P.val.1 + · obtain ⟨i,hi,hei⟩:=hp + have hxi:i∉X.val.1:=fun hh=>hα.2 ⟨i,hh,hei⟩ + have hzero:= (h.2 i hi hxi).1 k hk + rw [pointedCosetVector_open_at M f X z hz _ (by + rintro ⟨j,hj,hh⟩;exact hxi ((Sum.inl_injective hh) ▸ hj))] at hzero + change classLevelArray Q (pointedFamily M f z H) ((α.1,α.2),k)=0 + rw [←hei] + exact (pointedMultiplicity_zero_iff M f z k _).mp hzero H α.2 + · exact (classCapOn_iff_level_zero Q _ _ _).mp (hout H) α ⟨hα.1,hp⟩ k hk + +omit [Fintype S] [LinearOrder S] in +/-- Frame avoidance persists throughout a coset whose type avoids the frame. -/ +lemma pointedCoset_avoids_frame (P : Deligne M) (x z : Artin M) + (hx : x ∈ P.val.2) (hz : z ∈ P.val.2) (I : Set S) + (hPI : P.val.1 ⊆ I) (hf : f ∉ I) (hxA : x ∈ artinParabolic M {f}ᶜ) : + z ∈ artinParabolic M {f}ᶜ := by + have hg : z*x⁻¹ ∈ artinParabolic M P.val.1 := by + rw [←sourceCoset_eq M P x hx] at hz + exact hz + have hsub : P.val.1 ⊆ {f}ᶜ := by + intro i hi he + exact hf (he ▸ hPI hi) + have hm := (artinParabolic M {f}ᶜ).mul_mem (artinParabolic_mono M hsub hg) hxA + simpa only [_root_.mul_assoc, inv_mul_cancel, _root_.mul_one] using hm + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetGeometry.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..ec26b55e4d5d8f63a070f8f682ab6272e74924c5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetGeometry.lean @@ -0,0 +1,47 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.Coset +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Candidate + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + +lemma pointedCosetVector_upper_outside {P R:Deligne M} (h:P≤R) (k:ℤ) (i:S⊕Unit) + (hi:i∉(Sum.inl:S→S⊕Unit) '' R.val.1) : + pointedCosetVector M f R k i=pointedCosetVector M f P k i := by + let x:=sourceCosetRepresentative M P + have hx:=sourceCosetRepresentative_mem M P + rw [pointedCosetVector_eq M f R x (h.2 hx),pointedCosetVector_eq M f P x hx, + pointedHarmonicAt_outside M f R.val.1 x k i hi, + pointedHarmonicAt_outside M f P.val.1 x k i (fun he=>hi (Set.image_mono h.1 he))] + +lemma pointedCosetVector_upper_harmonize {P R:Deligne M} (h:P≤R) (k:ℤ) : + pointedCosetVector M f R k=harmonicExtension (framedCartan M) + ((Sum.inl:S→S⊕Unit) '' R.val.1) (pointedCosetVector M f P k) := + harmonicExtension_unique _ _ (framed_spherical_posDef M R.val.1 R.property.1) _ _ + (pointedCosetVector_upper_outside M f h k) (pointedCosetVector_harmonic M f R k) + +theorem pointedCosetVector_upper_change {P R:Deligne M} (h:P≤R) (k:ℤ) : + (fun vertex : (Sum.inl:S→S⊕Unit) '' R.val.1 => + pointedCosetVector M f R k vertex-pointedCosetVector M f P k vertex) = + -(((framedCartan M).submatrix Subtype.val Subtype.val : + Matrix ((Sum.inl:S→S⊕Unit) '' R.val.1) ((Sum.inl:S→S⊕Unit) '' R.val.1) ℝ)⁻¹ *ᵥ + fun vertex : (Sum.inl:S→S⊕Unit) '' R.val.1 => + (framedCartan M *ᵥ pointedCosetVector M f P k) vertex) := by + convert harmonic_upper_change (framedCartan M) + ((Sum.inl:S→S⊕Unit) '' R.val.1) + (framed_spherical_posDef M R.val.1 R.property.1) + (pointedCosetVector M f P k) (pointedCosetVector M f R k) + (pointedCosetVector_upper_outside M f h k) (pointedCosetVector_harmonic M f R k) using 1 + congr! (postTransparency := .reducible) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetProduct.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetProduct.lean new file mode 100644 index 0000000000000000000000000000000000000000..e782f8b0d5557d28943106ba989ebc5842d0b9b3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedCosetProduct.lean @@ -0,0 +1,96 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetExteriorCap +import OAI.Topology.ArtinGroups.Harmonic.CartanCommutingZero + +namespace OAI + +/-! Pointed multiplicities on products of commuting standard cosets. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + +lemma pointedCosetVector_open (P:Deligne M) (i:S) (hi:i∉P.val.1) + (x:Artin M) (hx:x∈P.val.2) (k:ℤ) : + pointedCosetVector M f P k (.inl i) = pointedMultiplicity M f x k (.inl i) := + pointedCosetVector_open_at M f P x hx (.inl i) (by + rintro ⟨j,hj,he⟩; exact hi (Sum.inl.inj he ▸ hj)) k + +lemma pointedCosetVector_block (B C:Set S) (hT:IsSpherical M (B∪C)) + (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) (k:ℤ) (i:S) (hi:i∈B) : + pointedCosetVector M f (sourceCoset M B (source_spherical_mono M Set.subset_union_left hT) x) k (.inl i)= + pointedCosetVector M f (sourceCoset M (B∪C) hT x) k (.inl i) := by + let P:=sourceCoset M (B∪C) hT x + let R:=sourceCoset M B (source_spherical_mono M Set.subset_union_left hT) x + apply harmonic_block_eq (framedCartan M) (Sum.inl '' B) (Sum.inl '' C) + (framed_spherical_posDef M B (source_spherical_mono M Set.subset_union_left hT)) + (pointedCosetVector M f R k) (pointedCosetVector M f P k) + (pointedCosetVector_harmonic M f R k) + (fun j=>pointedCosetVector_harmonic M f P k ⟨j,Set.image_mono Set.subset_union_left j.property⟩) + ?_ ?_ (.inl i) ⟨i,hi,rfl⟩ + · rintro _ ⟨s,hs,rfl⟩ _ ⟨t,ht,rfl⟩ + exact sourceCartan_commuting_zero M s t (hc s hs t ht) + · intro j hjB hjC + rw [pointedCosetVector_open_at M f R x (rightCoset_self M B x) j hjB k, + pointedCosetVector_open_at M f P x (rightCoset_self M (B∪C) x) j (by + rintro ⟨s,hs,rfl⟩ + rcases hs with hs|hs + · exact hjB ⟨s,hs,rfl⟩ + · exact hjC ⟨s,hs,rfl⟩) k] + +lemma pointedCosetProduct_open_left (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) + (P:SourceCosetBelow M B (source_spherical_mono M Set.subset_union_left hT) x × + SourceCosetBelow M C (source_spherical_mono M Set.subset_union_right hT) x) + (i:S) (hi:i∈B) (ho:i∉P.1.val.val.1) (k:ℤ) : + pointedCosetVector M f (sourceCosetProductFun M B C hT x P).val k (.inl i)= + pointedCosetVector M f P.1.val k (.inl i) := by + let b:=sourceBelowOffset M B _ x P.1 + let c:=sourceBelowOffset M C _ x P.2 + have hnot:i∉(sourceCosetProductFun M B C hT x P).val.val.1:=by + rintro (h|h) + · exact ho h + · exact Set.disjoint_left.mp hd hi (P.2.property.1 h) + have hrep:(b:Artin M)*c*x∈(sourceCosetProductFun M B C hT x P).val.val.2:= + rightCoset_self M _ _ + have hr:(b:Artin M)*x∈P.1.val.val.2:=by + rw [show (b:Artin M)*x=sourceCosetRepresentative M P.1.val from sourceBelowOffset_rep M B _ x P.1] + exact sourceCosetRepresentative_mem M P.1.val + rw [pointedCosetVector_open M f _ i hnot _ hrep, + pointedCosetVector_open M f P.1.val i ho _ hr] + have he:((b:Artin M)*c)*x=(c:Artin M)*((b:Artin M)*x):=by + rw [(sourceParabolics_commute M B C hc b c b.property c.property).eq,_root_.mul_assoc] + rw [he] + apply pointedMultiplicity_exterior_ordered M f C c c.property + rintro ⟨s,hs,he⟩ + cases Sum.inl_injective he + exact Set.disjoint_left.mp hd hi hs + +lemma pointedCosetProduct_open_right (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (x:Artin M) + (P:SourceCosetBelow M B (source_spherical_mono M Set.subset_union_left hT) x × + SourceCosetBelow M C (source_spherical_mono M Set.subset_union_right hT) x) + (i:S) (hi:i∈C) (ho:i∉P.2.val.val.1) (k:ℤ) : + pointedCosetVector M f (sourceCosetProductFun M B C hT x P).val k (.inl i)= + pointedCosetVector M f P.2.val k (.inl i) := by + let b:=sourceBelowOffset M B _ x P.1 + let c:=sourceBelowOffset M C _ x P.2 + have hnot:i∉(sourceCosetProductFun M B C hT x P).val.val.1:=by + rintro (h|h) + · exact Set.disjoint_left.mp hd (P.1.property.1 h) hi + · exact ho h + have hrep:(b:Artin M)*c*x∈(sourceCosetProductFun M B C hT x P).val.val.2:= + rightCoset_self M _ _ + have hr:(c:Artin M)*x∈P.2.val.val.2:=by + rw [show (c:Artin M)*x=sourceCosetRepresentative M P.2.val from sourceBelowOffset_rep M C _ x P.2] + exact sourceCosetRepresentative_mem M P.2.val + rw [pointedCosetVector_open M f _ i hnot _ hrep, + pointedCosetVector_open M f P.2.val i ho _ hr,_root_.mul_assoc] + apply pointedMultiplicity_exterior_ordered M f B b b.property + rintro ⟨s,hs,he⟩ + cases Sum.inl_injective he + exact Set.disjoint_left.mp hd hs hi + + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedFamily.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..8de17c9db14b17e2a98a7804c9a990017b9f9f08 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedFamily.lean @@ -0,0 +1,99 @@ +import OAI.Topology.ArtinGroups.Harmonic.ArtinAction +import OAI.Topology.ArtinGroups.Harmonic.FusionQuiverSimpleEdge +import OAI.Topology.ArtinGroups.Complexes.ScalarExactNotZero + +namespace OAI + +/-! The existing categorical action with an arbitrary original color as frame. -/ + +namespace HarmonicArtin.ParabolicIntersections + +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable + +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "diag" => coxeterFusionEdge_diag M +local notation "Q" => fusionQuiver m d hd + +abbrev PointedLabel := FusionLabel m +abbrev PointedClass := FiniteHomotopyClass Q (K := ℂ) +abbrev PointedFamilySpace := PointedLabel M → PointedClass M + +noncomputable def pointedAction : Artin M →* Equiv.Perm (PointedClass M) := + sourceArtinAction M (K := ℂ) + +noncomputable def pointedInitial (f : S) : PointedFamilySpace M := + fun L => initialClass Q (.inl f, L) + +noncomputable def pointedFamily (f : S) (x : Artin M) : PointedFamilySpace M := + fun L => pointedAction M x (pointedInitial M f L) + +@[simp] theorem pointedAction_generator (s : S) : + pointedAction M (generator M s) = fusionPacketPerm m d hd diag (.inl s) := + sourceArtinAction_generator M s + +private theorem pointed_orthogonal (s f : S) (hsf : M s f = 2) + (L H : PointedLabel M) : OrthogonalVertices Q (.inl s, L) (.inl f, H) := by + have hne : s ≠ f := by + intro he + subst f + rw [M.diagonal] at hsf + norm_num at hsf + apply fusionQuiver_orthogonal + · intro he + exact hne (Sum.inl.inj (congrArg Prod.fst he)) + · simp only [coxeterFusionEdge, hne, ↓reduceDIte, hsf, + OfNat.ofNat_ne_zero, FusionEdge.multiplicity] + split <;> rfl + +/-- A color nonadjacent to the frame fixes each initial projective. -/ +theorem pointed_generator_fixes_initial (s f : S) (hsf : M s f = 2) + (L : PointedLabel M) : + pointedAction M (generator M s) (pointedInitial M f L) = pointedInitial M f L := by + rw [pointedAction_generator, fusionPacketPerm, ← classPacketPerm_toList] + have hlist (l : List (PointedLabel M)) : + (l.map (fun H => classTwistPerm Q (fusionQuiver_no_loops m d hd diag) + (.inl s, H))).prod (pointedInitial M f L) = pointedInitial M f L := by + induction l with + | nil => rfl + | cons H l ih => + change classPositiveTwist Q (.inl s, H) + ((l.map (fun J => classTwistPerm Q (fusionQuiver_no_loops m d hd diag) + (.inl s, J))).prod (pointedInitial M f L)) = _ + rw [ih] + exact classPositiveTwist_initial_orthogonal Q (pointed_orthogonal M s f hsf H L) + exact hlist _ + +/-- The whole standard subgroup of nonadjacent colors fixes the frame. -/ +theorem pointed_standard_fixes_initial (X : Set S) (f : S) + (hX : ∀ s ∈ X, M s f = 2) (g : Artin M) (hg : g ∈ artinParabolic M X) + (L : PointedLabel M) : + pointedAction M g (pointedInitial M f L) = pointedInitial M f L := by + induction hg using Subgroup.closure_induction with + | mem g hg => + obtain ⟨s, hs, rfl⟩ := hg + exact pointed_generator_fixes_initial M s f (hX s hs) L + | one => simp only [map_one, Equiv.Perm.one_apply] + | mul g h hg hh ihg ihh => + simp only [map_mul, Equiv.Perm.mul_apply, ihh, ihg] + | inv g hg ih => + rw [map_inv] + apply (pointedAction M g).injective + change (pointedAction M g) ((pointedAction M g).symm (pointedInitial M f L)) = _ + rw [Equiv.apply_symm_apply, ih] + +noncomputable instance pointedFamilyMulAction : MulAction (Artin M) (PointedFamilySpace M) where + smul g F := fun L => pointedAction M g (F L) + one_smul F := by + funext L + exact congrArg (fun p => p (F L)) (map_one (pointedAction M)) + mul_smul g h F := by + funext L + exact congrArg (fun p => p (F L)) (map_mul (pointedAction M) g h) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedGroupProbeEuler.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedGroupProbeEuler.lean new file mode 100644 index 0000000000000000000000000000000000000000..fccae39d18e8cf5a3a8d4f53fbb20a58de50d36e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedGroupProbeEuler.lean @@ -0,0 +1,73 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.Harmonic.GroupProbeEuler +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.FrameFamilyWeightedLevel +import OAI.Topology.ArtinGroups.Geometry.ConvexHullSupportedComp +import OAI.Topology.ArtinGroups.Geometry.ProbeConvexEuler +import OAI.Topology.ArtinGroups.Harmonic.ProbeActionLevelExterior + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open _root_.Matrix _root_.OAI.Matrix CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "hdiag" => coxeterFusionEdge_diag M +local notation "hm" => (fun e=>le_trans (by norm_num) (fusionLabelSize_ge_four M e)) +local notation "Q" => fusionQuiver m d hd +local notation "R" => probeQuiver Q +local notation "aw" => sourceArtinAction M (K:=ℂ) +local notation "bw" => sourceProbeAction M (K:=ℂ) +local notation "C" => fusionFoldedCartan m d + +theorem pointedGroup_probe_euler + (J T:Set S) (hJ:IsSpherical M J) (z g:Artin M) (hg:g∈artinParabolic M T) + (q:ℤ) (p:S⊕Unit→ℝ) + (hz:∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q) + (hp:∀j:J,(C *ᵥ p) (.inl (j:S))=0) + (hext:∀v,v∉Sum.inl '' J→pointedMultiplicity M f z q v=p v) + (huniv:∀a∈artinParabolic M J, + (∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q)→ + ∀j:J,p (.inl (j:S))≤ pointedMultiplicity M f (a*z) q (.inl (j:S))) + (α:FusionVertex (V:=S⊕Unit) m) (b:Bool) (l:ℤ) + (hsoc:∀j:J,∀L c,coefficientSocle R + ((minimalClassModel R (bw g⁻¹ (initialClass R (.inr (α,b))))).complex.pureLayer R + (minimalClassModel_minimal R _) l) (.inl (.inl (j:S),L)) c=⊥) : + let N:=((minimalClassModel R (bw g⁻¹ (initialClass R (.inr (α,b))))).complex.pureLayer R + (minimalClassModel_minimal R _) l); + (if l=0 then fusionWeight m α.2*p α.1 else 0)- + (fun β=>generatorVector R N (.inl β)) ⬝ᵥ fusionFold m (C *ᵥ p) ≤ + fusionWeight m α.2*pointedMultiplicity M f (g*z) (q-l) α.1 := by + obtain ⟨w,rfl⟩:=sourceSignedWord_surjective M z + have hc:=source_convex_subobjects_full M J hJ (sourcePacketWord w) (.inl f) q p + (by simpa only [pointedFamily_word] using hz) hp + (by simpa only [pointedMultiplicity_word] using hext) + (by + intro a ha hcap j + have family_eq : pointedFamily M f (a*sourceSignedWord M w)= + (fun L=>aw a (fusionPacketOrbit m d hd hdiag (sourcePacketWord w) (.inl f) L)) := by + funext label + rw [pointedFamily_mul,pointedFamily_word] + have translated_cap : ∀ label, + ClassCapOn Q (pointedFamily M f (a*sourceSignedWord M w) label) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q := by + simpa only [family_eq] using hcap + simpa only [pointedMultiplicity,family_eq] using huniv a ha translated_cap j) + have hh:=sourceProbe_convex_euler M J hJ (sourcePacketWord w) (.inl f) q p hc g α b l hsoc + have hcart:=sourceProbeOrbit_cartan M (K:=ℂ) T g⁻¹ ((artinParabolic M T).inv_mem hg) α b l p + dsimp only at hh hcart ⊢ + rw [hcart,neg_sub] at hh + have hw:=pointedFamily_weighted_level M f (g*sourceSignedWord M w) (q-l) α + simp only [pointedFamily_mul,pointedFamily_word] at hw + exact hh.trans_eq hw + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedInitialCounts.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedInitialCounts.lean new file mode 100644 index 0000000000000000000000000000000000000000..27ca69c44b6b15f05e2a436a012617cbeb1f7196 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedInitialCounts.lean @@ -0,0 +1,49 @@ +import OAI.Topology.ArtinGroups.Harmonic.Coset +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile + +namespace OAI + +/-! Exact counts and harmonic vectors at the initial pointed family. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +@[simp] lemma pointedFamily_one (L : FusionLabel m) : + pointedFamily M f 1 L = initialClass Q (.inl f,L) := by + simp only [pointedFamily, pointedAction, map_one, Equiv.Perm.one_apply, pointedInitial] + +lemma pointedMultiplicity_one (k : ℤ) (v : S ⊕ Unit) : + pointedMultiplicity M f 1 k v = if v = .inl f ∧ k = 0 then 1 else 0 := by + rw [pointedMultiplicity_sum] + simp only [pointedFamily_one, classLevelArray_initial, Prod.mk.injEq] + by_cases hv : v = .inl f + · subst v + by_cases hk : k = 0 + · subst k + simp only [true_and, and_true, Nat.cast_ite, Nat.cast_one, Nat.cast_zero, mul_ite, + _root_.mul_one, MulZeroClass.mul_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true] + exact div_self (ne_of_gt (fusionWeight_pos m (fusionLabelSize_ge_two M) _)) + · simp only [hk, and_false, ite_false, Nat.cast_zero, MulZeroClass.mul_zero, + Finset.sum_const_zero, zero_div] + · have hv' : (.inl f : S ⊕ Unit) ≠ v := Ne.symm hv + simp only [hv, hv', false_and, ite_false, Nat.cast_zero, MulZeroClass.mul_zero, + Finset.sum_const_zero, zero_div] + +lemma pointedHarmonicAt_empty (x : Artin M) (k : ℤ) : + pointedHarmonicAt M f ∅ x k = pointedMultiplicity M f x k := by + funext i + exact pointedHarmonicAt_outside M f ∅ x k i (by simp) + +lemma pointedCosetVector_empty (x : Artin M) (k : ℤ) : + pointedCosetVector M f (sourceCoset M ∅ (spherical_empty M) x) k = + pointedMultiplicity M f x k := by + rw [pointedCosetVector_eq M f _ x (rightCoset_self M ∅ x) k] + exact pointedHarmonicAt_empty M f x k + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedInitialStabilizer.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedInitialStabilizer.lean new file mode 100644 index 0000000000000000000000000000000000000000..c3eb6cd0eaf8a62fd7585d931b8f01bc9bad1d04 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedInitialStabilizer.lean @@ -0,0 +1,55 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeMinimumContainment +import OAI.Topology.ArtinGroups.ParabolicIntersections.InitialMinimum + +namespace OAI + +/-! The initial pointed-family stabilizer inside a frame-avoiding standard subgroup. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + +lemma initial_containing_subset (Y:Set S) (hf:f∉Y) : + relativeContainingType M f 0 Y (sourceCoset M ∅ (spherical_empty M) 1) ⊆ + {i | i∈Y ∧ M i f=2} := by + intro i hi + rcases hi with hi|hi + · exact (Set.notMem_empty i hi.1).elim + · refine ⟨hi.1,?_⟩ + by_contra hm + have hif:i≠f:=by rintro rfl;exact hf hi.1 + have hneg:=framedCartan_neg_of_label_ne_two M i f hif hm + apply hi.2 0 + right + refine ⟨.inl f,hneg,?_⟩ + rw [initial_profile] + norm_num + +/-- The only frame-avoiding words fixing the initial family are generated +by the colors that commute with the frame. -/ +theorem pointed_initial_stabilizer_le (Y:Set S) (hf:f∉Y) + (a:Artin M) (ha:a∈artinParabolic M Y) + (hfix:pointedFamily M f a=pointedFamily M f 1) : + a∈artinParabolic M {i | i∈Y ∧ M i f=2} := by + let U:Set (S⊕Unit):=Sum.inl '' Y + let P:RelativeVertex M Y 1:=relativeElement M Y 1 1 (rightCoset_self M Y 1) + have hmin:RelativeMinimum M f U 0 P:=initial_height_minimum M f U 0 Y hf + have hU:U⊆Set.range (Sum.inl:S→S⊕Unit):=by + rintro _ ⟨i,_,rfl⟩ + exact ⟨i,rfl⟩ + have hfU:(.inl f:S⊕Unit)∉U:=by + rintro ⟨i,hi,he⟩ + exact hf (Sum.inl.inj he ▸ hi) + have hm:=relative_minimum_stabilizer_containment M f U 0 + (fun i hi=>⟨i,hi,rfl⟩) hU hfU (artinParabolic M {f}ᶜ).one_mem P hmin a ha + (by simpa only [_root_.mul_one] using hfix) + have hz:sourceCosetRepresentative M P.val=1:=by + have h:=sourceCosetRepresentative_mem M P.val + change sourceCosetRepresentative M P.val∈rightCoset M ∅ 1 at h + rw [rightCoset_empty] at h + exact h + rw [hz,inv_one,_root_.mul_one,inv_one,conjugate_one] at hm + exact artinParabolic_mono M (initial_containing_subset M f Y hf) hm + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedMultiplicity.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedMultiplicity.lean new file mode 100644 index 0000000000000000000000000000000000000000..9f759f6a42447ab9635d2fec31374dc145ee6b87 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedMultiplicity.lean @@ -0,0 +1,105 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedFamily +import OAI.Topology.ArtinGroups.Harmonic.MultiplicitySum + +namespace OAI + +/-! Layer counts of the pointed categorical family, at every integer level. -/ + +namespace HarmonicArtin.ParabolicIntersections + +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable + +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "diag" => coxeterFusionEdge_diag M +local notation "hm" => fusionLabelSize_ge_two M +local notation "Q" => fusionQuiver m d hd + +noncomputable def pointedMultiplicity (f : S) (x : Artin M) (k : ℤ) (v : S ⊕ Unit) : ℝ := + fusionFamilyMultiplicity m d hd hm (pointedFamily M f x) k v + +lemma pointedMultiplicity_nonneg (f : S) (x : Artin M) (k : ℤ) (v : S ⊕ Unit) : + 0 ≤ pointedMultiplicity M f x k v := fusionFamilyMultiplicity_nonneg m d hd hm _ k v + +lemma pointedFamily_word (f : S) (w : List (S × Bool)) : + pointedFamily M f (sourceSignedWord M w) = + fusionPacketOrbit m d hd diag (sourcePacketWord w) (.inl f) := by + funext L + unfold pointedFamily pointedAction + rw [sourceArtinAction_signedWord] + rfl + +lemma pointedMultiplicity_sum (f : S) (x : Artin M) (k : ℤ) (v : S ⊕ Unit) : + pointedMultiplicity M f x k v = + (∑ L, fusionWeight m L * (classLevelArray Q (pointedFamily M f x L) + ((v, fusionZeroLabel m hm), k) : ℝ)) / fusionWeight m (fusionZeroLabel m hm) := by + unfold pointedMultiplicity fusionFamilyMultiplicity + simp only [classTotalVector_layer_apply] + +/-- Bounded count intervals contain only finitely many actual count values. -/ +lemma pointedMultiplicity_values_finite (f : S) (B : ℝ) : + {r : ℝ | r ≤ B ∧ ∃ x k v, r = pointedMultiplicity M f x k v}.Finite := by + have hh := finite_normalized_weighted_nat_sums (fusionWeight m) (fusionWeight_pos m hm) + (fusionWeight m (fusionZeroLabel m hm)) (fusionWeight_pos m hm _) B + apply hh.subset + rintro r ⟨hr, x, k, v, rfl⟩ + exact ⟨hr, ⟨fun L => classLevelArray Q (pointedFamily M f x L) + ((v, fusionZeroLabel m hm), k), pointedMultiplicity_sum M f x k v⟩⟩ + +lemma pointedMultiplicity_support_finite (f : S) (x : Artin M) : + {k : ℤ | pointedMultiplicity M f x k ≠ 0}.Finite := by + have hh := finiteFamily_level_support Q (pointedFamily M f x) + apply hh.subset + intro k hk + by_contra hn + apply hk + funext v + have hz (L : FusionLabel m) : classLevelArray Q (pointedFamily M f x L) + ((v, fusionZeroLabel m hm), k) = 0 := by + by_contra hne + exact hn ⟨L, _, hne⟩ + rw [pointedMultiplicity_sum] + simp only [hz, Nat.cast_zero, MulZeroClass.mul_zero, Finset.sum_const_zero, zero_div, Pi.zero_apply] + +/-- The relative family changes no count outside the operated standard subgroup. -/ +lemma pointedMultiplicity_exterior (J : Set S) (g : Artin M) + (hg : g ∈ artinParabolic M J) (f : S) (x : Artin M) + (v : S ⊕ Unit) (hv : v ∉ Sum.inl '' J) (k : ℤ) : + pointedMultiplicity M f (g * x) k v = pointedMultiplicity M f x k v := by + unfold pointedMultiplicity + have he : pointedFamily M f (g * x) = + fun L => sourceArtinAction M g (pointedFamily M f x L) := by + funext L + simp only [pointedFamily, pointedAction, map_mul, Equiv.Perm.mul_apply] + rw [he] + exact sourceArtinAction_multiplicity_exterior M J g hg _ v hv k + +/-- A frame color outside the operated type retains its unique level-zero count. -/ +lemma pointedMultiplicity_frame (J : Set S) (f : S) (hf : f ∉ J) + (x : Artin M) (hx : x ∈ artinParabolic M J) (k : ℤ) : + pointedMultiplicity M f x k (.inl f) = if k = 0 then 1 else 0 := by + obtain ⟨w, hw, rfl⟩ := artinParabolic_signed_word M J x hx + have hav : ∀ a ∈ sourcePacketWord w, a.1 ≠ (.inl f : S ⊕ Unit) := by + intro a ha + obtain ⟨b, hb, rfl⟩ := List.mem_map.mp ha + intro he + exact hf (Sum.inl.inj he ▸ hw b hb) + unfold pointedMultiplicity + rw [pointedFamily_word] + unfold fusionFamilyMultiplicity + simp_rw [classTotalVector_layer_apply, + fusionOrbit_frame_level m d hd diag _ _ _ _ _ hav] + by_cases hk : k = 0 + · subst k + simp only [and_true, Nat.cast_ite, Nat.cast_one, Nat.cast_zero, mul_ite, _root_.mul_one, + MulZeroClass.mul_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true] + exact div_self (ne_of_gt (fusionWeight_pos m hm _)) + · simp only [hk, and_false, ite_false, Nat.cast_zero, MulZeroClass.mul_zero, Finset.sum_const_zero, + zero_div] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedMultiplicityZero.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedMultiplicityZero.lean new file mode 100644 index 0000000000000000000000000000000000000000..ee7b2175ee1f460619fa046d6ae6aacd47239848 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedMultiplicityZero.lean @@ -0,0 +1,55 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.MultiplicityZero +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.FrameFamilyWeightedLevel + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +lemma pointedMultiplicity_zero_iff (z:Artin M) (q:ℤ) (v:S⊕Unit) : + pointedMultiplicity M f z q v=0 ↔ + ∀ H L,classLevelArray Q (pointedFamily M f z H) ((v,L),q)=0 := by + constructor + · intro hz H L + have he:=pointedFamily_weighted_level M f z q (v,L) + rw [hz,MulZeroClass.mul_zero] at he + have hnn:∀ H:FusionLabel m,0≤fusionWeight m H * + (classLevelArray Q (pointedFamily M f z H) ((v,L),q):ℝ) := by + intro H + exact mul_nonneg (fusionWeight_pos m (fusionLabelSize_ge_two M) H).le (Nat.cast_nonneg _) + have hh:= (Finset.sum_eq_zero_iff_of_nonneg (fun H _=>hnn H)).mp he H (Finset.mem_univ H) + have hz':(classLevelArray Q (pointedFamily M f z H) ((v,L),q):ℝ)=0 := + (mul_eq_zero.mp hh).resolve_left (ne_of_gt (fusionWeight_pos m (fusionLabelSize_ge_two M) H)) + exact_mod_cast hz' + · intro hz + let L:=fusionZeroLabel m (fusionLabelSize_ge_two M) + have he:=pointedFamily_weighted_level M f z q (v,L) + simp only [hz,Nat.cast_zero,MulZeroClass.mul_zero,Finset.sum_const_zero] at he + exact (mul_eq_zero.mp he.symm).resolve_left + (ne_of_gt (fusionWeight_pos m (fusionLabelSize_ge_two M) L)) + +lemma pointedNumericCap_iff (z:Artin M) (q:ℤ) (U:Set (S⊕Unit)) : + (∀v∈U,∀k:ℤ,q fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "diag" => coxeterFusionEdge_diag M +local notation "Q" => fusionQuiver m d hd +local notation "O" => fusionPacketOrbit m d hd diag + +/-- Proposition 5.1 of 082-03, expressed using the pointed group orbit. +The avoidance hypothesis is automatic in the relative enlarged diagram. -/ +theorem pointed_null_obstruction (I J : Set S) (hI : I.Nonempty) (hf : f ∉ I) + (hJI : J ⊆ I) (hJ : IsSpherical M J) (x : Artin M) + (hx : x ∈ artinParabolic M {f}ᶜ) (q : ℤ) + (c : S ⊕ Unit → ℝ) (hc : ∀ v, 0 ≤ c v) + (hcSupp : ∀ v, v ∉ Sum.inl '' I → c v = 0) + (hcPos : ∀ v, v ∈ Sum.inl '' I → 0 < c v) + (hcNull : ∀ v, v ∈ Sum.inl '' I → (framedCartan M *ᵥ c) v = 0) + (hE : ∀ L, ClassCapOn Q (pointedFamily M f x L) + (closedNeighborhood Q (fusionColorRegion m (Sum.inl '' I)) \ + fusionColorRegion m (Sum.inl '' J)) q) + (hdata : ∀ v, (v ∈ Sum.inl '' I ∧ v ∉ Sum.inl '' J) ∨ + (v ∉ Sum.inl '' I ∧ ∃ u ∈ Sum.inl '' I, framedCartan M v u < 0) → + pointedMultiplicity M f x q v = c v) + (huniv : ∀ g ∈ artinParabolic M J, + (∀ L, ClassCapOn Q (pointedFamily M f (g*x) L) + (closedNeighborhood Q (fusionColorRegion m (Sum.inl '' I))) q) → + ∀ j : J, c (.inl (j:S)) < pointedMultiplicity M f (g*x) q (.inl (j:S))) : False := by + obtain ⟨w, hw, rfl⟩ := artinParabolic_signed_word M {f}ᶜ x hx + have hC : fusionFoldedCartan m d = framedCartan M := by + convert fusionFoldedCartan_eq_framedCartan M using 1 + congr 1 + exact Subsingleton.elim _ _ + apply relative_null_layer M I J hI hJI hJ (sourcePacketWord w) (.inl f) + (by rintro ⟨i, hi, he⟩; exact hf (Sum.inl.inj he ▸ hi)) + (by + intro a ha he + obtain ⟨b, hb, rfl⟩ := List.mem_map.mp ha + exact hw b hb (Sum.inl.inj he)) q c hc hcSupp hcPos + (by simpa only [hC] using hcNull) + (by simpa only [pointedFamily_word] using hE) + (by simpa only [pointedMultiplicity_word, hC] using hdata) + intro g hg hcap j + have he : pointedFamily M f (g * sourceSignedWord M w) = + fun L => sourceArtinAction M g (O (sourcePacketWord w) (.inl f) L) := by + funext L + rw [pointedFamily_mul, pointedFamily_word] + have h := huniv g hg (by simpa only [he] using hcap) j + simpa only [pointedMultiplicity, he] using h + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedNullPatch.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedNullPatch.lean new file mode 100644 index 0000000000000000000000000000000000000000..e9447e36db3feed35754fb9cdfe980e7448c28df --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedNullPatch.lean @@ -0,0 +1,101 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedNullObstruction +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetExteriorCap +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.CosetVectorNullPatch +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.ResidueAllowed +import OAI.Topology.ArtinGroups.Harmonic.FoldedCartan +import OAI.Topology.ArtinGroups.Harmonic.MultiplicityZero + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +lemma pointedCosetVector_of_null_patch (P:Deligne M) (x:Artin M) (hx:x∈P.val.2) + (I:Set S) (hPI:P.val.1⊆I) (q:ℤ) (c:S⊕Unit→ℝ) + (hcNull:∀v,v∈Sum.inl '' I→(framedCartan M *ᵥ c) v=0) + (hdata:∀v,(v∈Sum.inl '' I ∧ v∉Sum.inl '' P.val.1) ∨ + (v∉Sum.inl '' I ∧ ∃u∈Sum.inl '' I,framedCartan M v u<0)→ + pointedMultiplicity M f x q v=c v) (i:S) (hi:i∈P.val.1) : + pointedCosetVector M f P q (.inl i)=c (.inl i) := by + let p:S⊕Unit→ℝ:=fun v=>if v∈Sum.inl '' P.val.1 then c v else pointedMultiplicity M f x q v + have hp:p=pointedHarmonicAt M f P.val.1 x q := by + apply harmonicExtension_unique _ _ (framed_spherical_posDef M _ P.property.1) + · intro v hv + exact ite_eq_right hv + · intro j + exact null_patch (framedCartan_symm M) (framedCartan_off M) + (Sum.inl '' I) (Sum.inl '' P.val.1) (Set.image_mono hPI) c + (pointedMultiplicity M f x q) hcNull hdata j j.property + rw [pointedCosetVector_eq M f P x hx q,←hp] + exact ite_eq_left ⟨i,hi,rfl⟩ + +theorem pointedClosedResidue_nonempty (P:Deligne M) (x:Artin M) (hx:x∈P.val.2) (hxA:x∈artinParabolic M {f}ᶜ) + (I:Set S) (hI:I.Nonempty) (hf:f∉I) (hPI:P.val.1⊆I) (q:ℤ) + (c:S⊕Unit→ℝ) (hc:∀v,0≤c v) (hcSupp:∀v,v∉Sum.inl '' I→c v=0) + (hcPos:∀v,v∈Sum.inl '' I→0A.val.1) he + have hmem:(j:S)∈T:=by rw [he'];exact j.property + exact hmem.2 rfl + have hrz:z∈R.val.2:=rightCoset_self M T z + have hvec(k:ℤ)(i:S)(hi:i∉T):pointedCosetVector M f R k (.inl i)=pointedMultiplicity M f z k (.inl i) := by + rw [pointedCosetVector_eq M f R z hrz k] + exact pointedHarmonicAt_outside M f T z k _ (by + rintro ⟨a,ha,he⟩;exact hi ((Sum.inl_injective he) ▸ ha)) + apply hempty + refine ⟨R,hrlt,?_⟩ + intro i hi hnT + have hei:i=(j:S) := by + by_contra hne + exact hnT ⟨hi,hne⟩ + subst i + refine ⟨?_,?_⟩ + · intro k hk + rw [hvec k j hnT,pointedMultiplicity_zero_iff] + intro H L + exact (classCapOn_iff_level_zero Q _ _ _).mp (hcap H) ((.inl (j:S)),L) + (mem_closedNeighborhood Q ⟨j,hPI j.property,rfl⟩) k hk + · change pointedCosetVector M f R q (.inl (j:S))≤ pointedCosetVector M f P q (.inl (j:S)) + rw [hvec q j hnT,pointedCosetVector_of_null_patch M f P x hx I hPI q c hcNull hdata j j.property] + exact hj + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedProbeCap.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedProbeCap.lean new file mode 100644 index 0000000000000000000000000000000000000000..98e188d20eb304d7c80f7404600d8012a772b8ce --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedProbeCap.lean @@ -0,0 +1,68 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedTop +import OAI.Topology.ArtinGroups.Harmonic.FrameFamilyCapTop +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.PacketTwistRaisedGenerator2 +import OAI.Topology.ArtinGroups.Harmonic.MapPacket +import OAI.Topology.ArtinGroups.Harmonic.ProbePacketExterior +import OAI.Topology.ArtinGroups.Harmonic.FrameFamilyTopProportional +import OAI.Topology.ArtinGroups.Functors.TopZeroProbeSocle + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open ReversibleQuiver.ProbeEmbedding + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "hn" => fusionQuiver_no_loops m d (coxeterFusionEdge_symm M) (coxeterFusionEdge_diag M) +local notation "R" => probeQuiver Q +local notation "aw" => sourceArtinAction M (K:=ℂ) +local notation "bw" => sourceProbeAction M (K:=ℂ) + +lemma pointedFamily_cap_of_top_zero (T:Set S) (z:Artin M) (q:ℤ) + (hz:∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) + (j:S) (hj:j∈T) + (ht:∀H L c,classLayerTopDimension Q q (.inl j,L) c (pointedFamily M f z H)=0) : + ∀H,ClassCapOn Q (pointedFamily M f (generator M j*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q := by + intro H + rw [pointedFamily_mul,sourceArtinAction_generator] + exact classPacketPerm_local_cap_of_top_zero Q hn (fun L:FusionLabel m=>(.inl j,L)) + (fusionColor_orthogonal m d (coxeterFusionEdge_symm M) (coxeterFusionEdge_diag M) (.inl j)) + _ _ (hz H) (fun L=>⟨(⟨j,hj⟩,L),rfl⟩) (ht H) + +theorem pointedProbe_socle_cap_move (T J:Set S) (hJT:J⊆T) + (z h:Artin M) (hh:h∈artinParabolic M T) (q l:ℤ) (hl:l≤0) + (hz:∀H,ClassCapOn Q (pointedFamily M f z H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) + (hzh:∀H,ClassCapOn Q (pointedFamily M f (h*z) H) + (Set.range (unfoldedInclusion M T)) q) + (α:FusionVertex (V:=S⊕Unit) m) (ha:α∈Set.range (unfoldedInclusion M T)) (b:Bool) + (hy:ClassLowerBound R l (bw h⁻¹ (initialClass R (.inr (α,b))))) + (j:S) (hj:j∈J) (L:FusionLabel m) (c:ℤ) + (hs:0Or.inl ha) + · exact sourceProbeOrbit_support M T h⁻¹ ((artinParabolic M T).inv_mem hh) α b + · intro n v hnv + rw [sourceProbeAction_hom_reading,← pointedFamily_mul] + apply classGeneratorArray_zero_of_cap Q _ _ q (hzh H) _ ha + change q fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) +local notation "R" => probeQuiver Q +local notation "bw" => sourceProbeAction M (K:=ℂ) +local notation "C" => fusionFoldedCartan m d + +lemma pointedProbe_raise_lower (T J:Set S) (z g:Artin M) (q l:ℤ) (p:S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (hg:g∈artinParabolic M T) (hl:l<0) + (hgz:∀H,ClassCapOn Q (pointedFamily M f (g*z) H) + (Set.range (unfoldedInclusion M T)) q) + (α:FusionVertex (V:=S⊕Unit) m) (ha:α∈Set.range (unfoldedInclusion M T)) (b:Bool) + (hy:ClassLowerBound R l (bw g⁻¹ (initialClass R (.inr (α,b))))) + (hsoc:∀j:J,∀L c,classLayerSocleDimension R l (.inl (.inl j,L)) c + (bw g⁻¹ (initialClass R (.inr (α,b))))=0) : + ClassLowerBound R (l+1) (bw g⁻¹ (initialClass R (.inr (α,b)))) := by + obtain ⟨⟨s,L⟩,rfl⟩:=ha + have hu:=X.probe_euler g hg (.inl (s:S),L) b l hsoc + dsimp only at hu + have hzero:=pointedMultiplicity_cap_zero M f T (g*z) q (q-l) (by omega) hgz s s.property + rw [hzero,MulZeroClass.mul_zero,ite_eq_right (ne_of_lt hl),zero_sub] at hu + intro i + have hge:=hy i + have hne:((minimalClassModel R (bw g⁻¹ (initialClass R (.inr ((Sum.inl (s:S),L),b))))).complex.placement i).level≠l := by + intro he + have hn:=sourceProbe_core_dot_neg_of_nonempty M (K:=ℂ) T J g⁻¹ + ((artinParabolic M T).inv_mem hg) (.inl (s:S),L) b l (ne_of_lt hl) p + X.cartan_nonpos X.negative (fun j H c=>Submodule.finrank_eq_zero.mp (hsoc j H c)) ⟨⟨i,he⟩⟩ + dsimp only at hn hu + linarith + change l≤((minimalClassModel R (bw g⁻¹ (initialClass R (.inr ((Sum.inl (s:S),L),b))))).complex.placement i).level at hge + change l+1≤((minimalClassModel R (bw g⁻¹ (initialClass R (.inr ((Sum.inl (s:S),L),b))))).complex.placement i).level + omega + +theorem pointedProbe_zero_saturation {B:Type*} [Finite B] + (T J:Set S) (z h:Artin M) (q:ℤ) (p:S⊕Unit→ℝ) + (X:PointedCappedCandidate M f T J z q p) (hh:h∈artinParabolic M T) + (hzh:∀H,ClassCapOn Q (pointedFamily M f (h*z) H) + (Set.range (unfoldedInclusion M T)) q) + (α:B→FusionVertex (V:=S⊕Unit) m) (ha:∀r,α r∈Set.range (unfoldedInclusion M T)) + (b:B→Bool) : + ∃ a∈artinParabolic M J, + (∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) ∧ + (∀r,ClassLowerBound R 0 (bw (a*h⁻¹) (initialClass R (.inr (α r,b r))))) ∧ + ∀r (j:J) L c,classLayerSocleDimension R 0 (.inl (.inl j,L)) c + (bw (a*h⁻¹) (initialClass R (.inr (α r,b r))))=0 := by + have aux:∀n:ℕ,∀z h:Artin M,PointedCappedCandidate M f T J z q p→ + h∈artinParabolic M T→ + (∀H,ClassCapOn Q (pointedFamily M f (h*z) H) (Set.range (unfoldedInclusion M T)) q)→ + (∀r,ClassLowerBound R (-(n:ℤ)) (bw h⁻¹ (initialClass R (.inr (α r,b r)))))→ + ∃ a∈artinParabolic M J, + (∀H,ClassCapOn Q (pointedFamily M f (a*z) H) + (closedNeighborhood Q (Set.range (unfoldedInclusion M T))) q) ∧ + (∀r,ClassLowerBound R 0 (bw (a*h⁻¹) (initialClass R (.inr (α r,b r))))) ∧ + ∀r (j:J) L c,classLayerSocleDimension R 0 (.inl (.inl j,L)) c + (bw (a*h⁻¹) (initialClass R (.inr (α r,b r))))=0 := by + intro n + induction n with + | zero => + intro z h X hh hc hy + apply pointedProbe_cap_saturation M f T J X.subset X.spherical z h hh q 0 (by omega) + X.cap hc α ha b + simpa only [Nat.cast_zero,neg_zero] using hy + | succ n ih => + intro z h X hh hc hy + obtain ⟨a,haJ,hcap,hlower,hsoc⟩:=pointedProbe_cap_saturation M f T J X.subset X.spherical z h hh q + (-((n+1:ℕ):ℤ)) (by omega) X.cap hc α ha b hy + have haT:=artinParabolic_mono M X.subset haJ + have hhT:(h*a⁻¹)∈artinParabolic M T:= + (artinParabolic M T).mul_mem hh ((artinParabolic M T).inv_mem haT) + have he:(h*a⁻¹)*(a*z)=h*z:=by simp only [_root_.mul_assoc,inv_mul_cancel_left] + have hei:(h*a⁻¹)⁻¹=a*h⁻¹:=by simp only [_root_.mul_inv_rev,inv_inv] + have hraise:∀r,ClassLowerBound R (-(n:ℤ)) + (bw (h*a⁻¹)⁻¹ (initialClass R (.inr (α r,b r)))) := by + intro r + have hr:=pointedProbe_raise_lower M f T J (a*z) (h*a⁻¹) q (-((n+1:ℕ):ℤ)) p (X.move a haJ hcap) + hhT (by omega) (by rw [he]; exact hc) (α r) (ha r) (b r) + (by rw [hei]; exact hlower r) (by rw [hei]; exact hsoc r) + convert hr using 1 + omega + obtain ⟨a',ha',hcap',hlower',hsoc'⟩:=ih (a*z) (h*a⁻¹) (X.move a haJ hcap) hhT + (by rw [he];exact hc) hraise + refine ⟨a'*a,(artinParabolic M J).mul_mem ha' haJ,?_,?_,?_⟩ + · simpa only [_root_.mul_assoc] using hcap' + · simpa only [hei,_root_.mul_assoc] using hlower' + · simpa only [hei,_root_.mul_assoc] using hsoc' + obtain ⟨l,hl⟩:=finiteFamily_lowerBound R (fun r=>bw h⁻¹ (initialClass R (.inr (α r,b r)))) + apply aux (-l).toNat z h X hh hzh + intro r i + have hh:=hl r i + have hn:Int.ofNat (-l).toNat≥-l:=Int.self_le_toNat (-l) + omega + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedProfile.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedProfile.lean new file mode 100644 index 0000000000000000000000000000000000000000..732fd77c8344d10878377bcb637eb7ffa6f2b48e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedProfile.lean @@ -0,0 +1,115 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedMultiplicity +import OAI.Topology.ArtinGroups.Harmonic.CosetSum + +namespace OAI + +/-! Harmonic profiles on actual parabolic cosets for a relative frame. -/ + +namespace HarmonicArtin.ParabolicIntersections + +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + +noncomputable def pointedHarmonicAt (T : Set S) (x : Artin M) (k : ℤ) : S ⊕ Unit → ℝ := + harmonicExtension (framedCartan M) (Sum.inl '' T) (pointedMultiplicity M f x k) + +lemma pointedHarmonicAt_outside (T : Set S) (x : Artin M) (k : ℤ) (i : S ⊕ Unit) + (hi : i ∉ Sum.inl '' T) : + pointedHarmonicAt M f T x k i = pointedMultiplicity M f x k i := + harmonicExtension_outside _ _ _ hi + +lemma pointedHarmonicAt_nonneg (T : Set S) (hT : IsSpherical M T) (x : Artin M) (k : ℤ) : + ∀ i, 0 ≤ pointedHarmonicAt M f T x k i := + harmonicExtension_nonneg _ _ (framed_spherical_posDef M T hT) + (framedCartan_off M) _ (pointedMultiplicity_nonneg M f x k) + +lemma pointedHarmonicAt_harmonic (T : Set S) (hT : IsSpherical M T) + (x : Artin M) (k : ℤ) (i : (Sum.inl : S → S ⊕ Unit) '' T) : + (framedCartan M *ᵥ pointedHarmonicAt M f T x k) i = 0 := + harmonicExtension_harmonic _ _ (framed_spherical_posDef M T hT) _ i + +lemma pointedHarmonicAt_invariant (T : Set S) (g x : Artin M) + (hg : g ∈ artinParabolic M T) (k : ℤ) : + pointedHarmonicAt M f T (g * x) k = pointedHarmonicAt M f T x k := by + apply harmonicExtension_congr_exterior + intro i hi + exact pointedMultiplicity_exterior M T g hg f x i hi k + +lemma pointedHarmonicAt_of_mem (T : Set S) (x y : Artin M) + (hy : y ∈ rightCoset M T x) (k : ℤ) : + pointedHarmonicAt M f T y k = pointedHarmonicAt M f T x k := by + have hh := pointedHarmonicAt_invariant M f T (y * x⁻¹) x hy k + simpa only [mul_assoc, inv_mul_cancel, mul_one] using hh + +noncomputable def pointedCosetVector (P : Deligne M) (k : ℤ) : S ⊕ Unit → ℝ := + pointedHarmonicAt M f P.val.1 (sourceCosetRepresentative M P) k + +lemma pointedCosetVector_eq (P : Deligne M) (x : Artin M) (hx : x ∈ P.val.2) (k : ℤ) : + pointedCosetVector M f P k = pointedHarmonicAt M f P.val.1 x k := by + rw [sourceCosetRepresentative_spec] at hx + exact (pointedHarmonicAt_of_mem M f P.val.1 _ x hx k).symm + +lemma pointedCosetVector_nonneg (P : Deligne M) (k : ℤ) : + ∀ i, 0 ≤ pointedCosetVector M f P k i := + pointedHarmonicAt_nonneg M f P.val.1 P.property.1 _ k + +lemma pointedCosetVector_harmonic (P : Deligne M) (k : ℤ) (i : (Sum.inl : S → S ⊕ Unit) '' P.val.1) : + (framedCartan M *ᵥ pointedCosetVector M f P k) i = 0 := + pointedHarmonicAt_harmonic M f P.val.1 P.property.1 _ k i + +lemma pointedCosetVector_support_finite (P : Deligne M) : + {k : ℤ | pointedCosetVector M f P k ≠ 0}.Finite := by + apply (pointedMultiplicity_support_finite M f (sourceCosetRepresentative M P)).subset + intro k hk + by_contra hn + apply hk + have hz : pointedMultiplicity M f (sourceCosetRepresentative M P) k = 0 := not_not.mp hn + change harmonicExtension _ _ _ = 0 + rw [hz, harmonicExtension_zero] + +noncomputable def pointedCosetSum (P : Deligne M) (k : ℤ) : ℝ := + ∑ i, pointedCosetVector M f P k i + +lemma pointedCosetVector_le_sum (P : Deligne M) (k : ℤ) (i : S ⊕ Unit) : + pointedCosetVector M f P k i ≤ pointedCosetSum M f P k := + Finset.single_le_sum (fun j _ => pointedCosetVector_nonneg M f P k j) (Finset.mem_univ i) + +lemma pointedCosetVector_bounded_finite (B : ℝ) : + {p : S ⊕ Unit → ℝ | ∃ P : Deligne M, ∃ k : ℤ, + pointedCosetSum M f P k ≤ B ∧ p = pointedCosetVector M f P k}.Finite := by + let A : Set ℝ := {0} ∪ {r : ℝ | r ≤ B ∧ ∃ x k v, r = pointedMultiplicity M f x k v} + have hA : A.Finite := (Set.finite_singleton 0).union (pointedMultiplicity_values_finite M f B) + apply (finite_harmonic_images (framedCartan M) A hA).subset + rintro p ⟨P, k, hB, rfl⟩ + let T : Set (S ⊕ Unit) := Sum.inl '' P.val.1 + let v : S ⊕ Unit → ℝ := fun i => if i ∈ T then 0 else pointedCosetVector M f P k i + refine ⟨T, v, ?_, ?_⟩ + · intro i + by_cases hi : i ∈ T + · exact Or.inl (by simp only [v, hi, ↓reduceIte, Set.mem_singleton_iff]) + · right + dsimp only [v] + simp only [hi, ↓reduceIte] + refine ⟨(pointedCosetVector_le_sum M f P k i).trans hB, ?_⟩ + exact ⟨sourceCosetRepresentative M P, k, i, + pointedHarmonicAt_outside M f P.val.1 _ k i hi⟩ + · change harmonicExtension (framedCartan M) T _ = harmonicExtension (framedCartan M) T v + apply harmonicExtension_congr_exterior + intro i hi + simp only [v, hi, ↓reduceIte] + exact (pointedHarmonicAt_outside M f P.val.1 _ k i hi).symm + +/-- Shift the fixed integer cutoff to zero while retaining every recorded level. -/ +noncomputable def pointedProfile (P : Deligne M) (cutoff : ℤ) : ℕ →₀ (S ⊕ Unit → ℝ) := + Finsupp.ofSupportFinite (fun k => pointedCosetVector M f P (cutoff + k)) + ((pointedCosetVector_support_finite M f P).preimage (by + intro a _ b _ he + exact Int.ofNat_inj.mp (add_left_cancel he))) + +@[simp] lemma pointedProfile_apply (P : Deligne M) (cutoff : ℤ) (k : ℕ) : + pointedProfile M f P cutoff k = pointedCosetVector M f P (cutoff + k) := rfl + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueActive.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueActive.lean new file mode 100644 index 0000000000000000000000000000000000000000..8bac77acb5f03dfd0497b4691c6722bd16706b8d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueActive.lean @@ -0,0 +1,188 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetGeometry +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.ResidueActive +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.NerveOrderMap +import OAI.Topology.ArtinGroups.Harmonic.HarmonicUpperAntitone +import OAI.Topology.ArtinGroups.Harmonic.ResidueAllowed + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix Simplicial CategoryTheory + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + +lemma pointedCosetVector_upper_antitone_int {X R:Deligne M} (h:X≤R) (q:ℤ) + (hr:∀i∈R.val.1,i∉X.val.1→0≤(framedCartan M *ᵥ pointedCosetVector M f X q) (.inl i)) : + pointedCosetVector M f R q≤ pointedCosetVector M f X q := by + apply harmonic_upper_antitone (framedCartan M) (framedCartan_off M) + ((Sum.inl:S→S⊕Unit) '' R.val.1) (framed_spherical_posDef M R.val.1 R.property.1) + (pointedCosetVector M f X q) (pointedCosetVector M f R q) + (pointedCosetVector_upper_outside M f h q) (pointedCosetVector_harmonic M f R q) + rintro ⟨_,⟨i,hi,rfl⟩⟩ + by_cases ht:i∈X.val.1 + · rw [pointedCosetVector_harmonic M f X q ⟨.inl i,⟨i,ht,rfl⟩⟩] + · exact hr i hi ht + +lemma pointedCosetVector_upper_monotone_int {X R:Deligne M} (h:X≤R) (q:ℤ) + (hr:∀i∈R.val.1,i∉X.val.1→(framedCartan M *ᵥ pointedCosetVector M f X q) (.inl i)≤0) : + pointedCosetVector M f X q≤ pointedCosetVector M f R q := by + apply harmonic_upper_monotone (framedCartan M) (framedCartan_off M) + ((Sum.inl:S→S⊕Unit) '' R.val.1) (framed_spherical_posDef M R.val.1 R.property.1) + (pointedCosetVector M f X q) (pointedCosetVector M f R q) + (pointedCosetVector_upper_outside M f h q) (pointedCosetVector_harmonic M f R q) + rintro ⟨_,⟨i,hi,rfl⟩⟩ + by_cases ht:i∈X.val.1 + · rw [pointedCosetVector_harmonic M f X q ⟨.inl i,⟨i,ht,rfl⟩⟩] + · exact hr i hi ht + +lemma pointedResidueHeight_lt_of_ne {P Q R:Deligne M} {q:ℤ} (hQ:Q≤P) (hR:R≤P) + (h:pointedCosetVector M f Q q≤ pointedCosetVector M f R q) + (hn:pointedCosetVector M f Q q≠pointedCosetVector M f R q) : + pointedResidueHeight M f P Q qhe ⟨i,hi,hl⟩)) + · exact (pointedCosetVector_upper_outside M f hQ q v hv).symm.trans + (pointedCosetVector_upper_outside M f hR q v hv) + +def pointedResidueActive (P X:Deligne M) (q:ℤ) : Set S := + {i | i∈P.val.1 ∧ i∉X.val.1 ∧ 0≤(framedCartan M *ᵥ pointedCosetVector M f X q) (.inl i)} + +lemma pointedResidueActive_misses {P X:Deligne M} {q:ℤ} (hx:X≤P) + (hh:pointedResidueHeight M f P X q<0) : + ∃i∈P.val.1,i∉X.val.1 ∧ i∉pointedResidueActive M f P X q := by + by_contra hn + have hv:pointedCosetVector M f P q≤ pointedCosetVector M f X q:=by + apply pointedCosetVector_upper_antitone_int M f hx q + intro i hi hxi + by_contra hr + exact hn ⟨i,hi,hxi,fun hd=>hr hd.2.2⟩ + have hnon:0≤ pointedResidueHeight M f P X q:= + Finset.sum_nonneg (fun i _=>sub_nonneg.mpr (hv (.inl i))) + exact (not_lt_of_ge hnon) hh + +abbrev PointedResidueEarlierUpper (P X:Deligne M) (q:ℤ) := + {R:Deligne M // Xhn ⟨i,hi,hp.1 hi,hxi,hh⟩) + have hv:=pointedCosetVector_upper_monotone_int M f hr.le q (fun i hi hx=>(hnrow i hi hx).le) + have hne:pointedCosetVector M f X q≠pointedCosetVector M f R q:=by + intro he + obtain ⟨i,hi,hxi⟩:=Set.exists_of_ssubset (deligne_lt_type M hr) + have hh:=hnrow i hi hxi + rw [he,pointedCosetVector_harmonic M f R q ⟨.inl i,⟨i,hi,rfl⟩⟩] at hh + exact lt_irrefl _ hh + exact (not_lt_of_ge hh) (pointedResidueHeight_lt_of_ne M f (hr.le.trans hp) hp hv hne) + +lemma pointedResidueUpper_active {P X R:Deligne M} {q:ℤ} (hr:X≤R) + (ha:∀i∈R.val.1,i∉X.val.1→i∈pointedResidueActive M f P X q) : + pointedResidueHeight M f P R q≤ pointedResidueHeight M f P X q := + pointedResidueHeight_mono M f (pointedCosetVector_upper_antitone_int M f hr q (fun i hi hn=>(ha i hi hn).2.2)) + +noncomputable def pointedResidueUpperTop (P X:Deligne M) (q:ℤ) (hx:X≤P) : Deligne M := + sourceCoset M (X.val.1 ∪ pointedResidueActive M f P X q) + (source_spherical_mono M (show X.val.1 ∪ pointedResidueActive M f P X q⊆P.val.1 from + fun _ hi=>hi.elim (fun h=>hx.1 h) (fun h=>h.1)) P.property.1) + (sourceCosetRepresentative M X) + +noncomputable def pointedResidueUpperClip (P X R:Deligne M) (q:ℤ) : Deligne M := + sourceCoset M (R.val.1 ∩ (X.val.1 ∪ pointedResidueActive M f P X q)) + (source_spherical_mono M Set.inter_subset_left R.property.1) (sourceCosetRepresentative M X) + +lemma pointedResidueUpperClip_le {P X R:Deligne M} {q:ℤ} (h:X≤R) : + pointedResidueUpperClip M f P X R q≤R := by + calc + pointedResidueUpperClip M f P X R q≤ sourceCoset M R.val.1 R.property.1 (sourceCosetRepresentative M X):= + sourceCoset_le M Set.inter_subset_left _ + _=R:=sourceCoset_eq M R _ (h.2 (sourceCosetRepresentative_mem M X)) + +lemma le_pointedResidueUpperClip {P X R:Deligne M} {q:ℤ} (h:X≤R) : + X≤ pointedResidueUpperClip M f P X R q := by + calc + X=sourceCoset M X.val.1 X.property.1 (sourceCosetRepresentative M X):= + (sourceCoset_eq M X _ (sourceCosetRepresentative_mem M X)).symm + _≤ pointedResidueUpperClip M f P X R q:=sourceCoset_le M (show X.val.1⊆R.val.1 ∩ (X.val.1 ∪ pointedResidueActive M f P X q) from + fun i hi=>⟨h.1 hi,Or.inl hi⟩) _ + +lemma pointedResidueUpperTop_mem {P X:Deligne M} {q:ℤ} (hx:X≤P) + (hh:pointedResidueHeight M f P X q<0) (hd:(pointedResidueActive M f P X q).Nonempty) : + Xhi.elim (fun h=>hx.1 h) (fun h=>h.1)) _ + _=P:=sourceCoset_eq M P _ (hx.2 (sourceCosetRepresentative_mem M X)) + refine ⟨lt_of_le_of_ne hl ?_,lt_of_le_of_ne hp ?_,pointedResidueUpper_active M f hl (fun _ hi hn=>hi.resolve_left hn)⟩ + · intro he + obtain ⟨i,hi⟩:=hd + have ht:=congrArg (fun K:Deligne M=>K.val.1) he + have hiTop:i∈(pointedResidueUpperTop M f P X q hx).val.1:=Or.inr hi + rw [←ht] at hiTop + exact hi.2.1 hiTop + · intro he + obtain ⟨i,hi,hxOut,hdOut⟩:=pointedResidueActive_misses M f hx hh + have ht:=congrArg (fun K:Deligne M=>K.val.1) he + have hiTop:i∈(pointedResidueUpperTop M f P X q hx).val.1:=by rw [ht];exact hi + exact hiTop.elim hxOut hdOut + +lemma pointedResidueUpperClip_mem {P X R:Deligne M} {q:ℤ} + (h: Xhi.2.resolve_left hn)⟩ + intro he + obtain ⟨i,hi,hd⟩:=pointedResidueUpper_meets M f h.1 h.2.1.le h.2.2 + have ht:=congrArg (fun K:Deligne M=>K.val.1) he + have hm:i∈(pointedResidueUpperClip M f P X R q).val.1:=⟨hi,Or.inr hd⟩ + rw [←ht] at hm + exact hd.2.1 hm + +noncomputable def pointedResidueUpperRetraction (P X:Deligne M) (q:ℤ) : + PointedResidueEarlierUpper M f P X q →o PointedResidueEarlierUpper M f P X q where + toFun R:=⟨pointedResidueUpperClip M f P X R q,pointedResidueUpperClip_mem M f R.property⟩ + monotone':=by + intro Y Z h + change pointedResidueUpperClip M f P X Y q≤ pointedResidueUpperClip M f P X Z q + exact sourceCoset_le M (show Y.val.val.1 ∩ (X.val.1 ∪ pointedResidueActive M f P X q)⊆ + Z.val.val.1 ∩ (X.val.1 ∪ pointedResidueActive M f P X q) from fun _ hi=>⟨h.1 hi.1,hi.2⟩) _ + +theorem pointedResidueEarlierUpper_contractible {P X:Deligne M} {q:ℤ} (hx:X≤P) + (hh:pointedResidueHeight M f P X q<0) (h:Nonempty (PointedResidueEarlierUpper M f P X q)) : + ContractibleSpace |CategoryTheory.nerve (PointedResidueEarlierUpper M f P X q)| := by + let R:=Classical.choice h + obtain ⟨i,_,hi⟩:=pointedResidueUpper_meets M f R.property.1 R.property.2.1.le R.property.2.2 + let c:PointedResidueEarlierUpper M f P X q:=⟨pointedResidueUpperTop M f P X q hx, + pointedResidueUpperTop_mem M f hx hh ⟨i,hi⟩⟩ + exact nerve_contractible_of_order_clip (pointedResidueUpperRetraction M f P X q) c + (by intro R; change pointedResidueUpperClip M f P X R q≤R.val + exact pointedResidueUpperClip_le M f R.property.1.le) + (fun R=>show pointedResidueUpperClip M f P X R q≤ pointedResidueUpperTop M f P X q hx from + sourceCoset_le M Set.inter_subset_right _) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueActiveEmpty.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueActiveEmpty.lean new file mode 100644 index 0000000000000000000000000000000000000000..d499692a83cb5193bc22ae1266c0142754d51e5d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueActiveEmpty.lean @@ -0,0 +1,95 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetExteriorCap +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueSingleOpen +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueActive +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCandidate +import OAI.Topology.ArtinGroups.Harmonic.ResidueActiveEmpty +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.ResidueSingleOpen +import OAI.Topology.ArtinGroups.Harmonic.ResidueActive + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "U" => fun J:Set S=>Set.range (unfoldedInclusion M J) + +lemma pointedResidue_pointed_active_empty {P X:Deligne M} {q:ℤ} (hx:X≤P) + (hh:pointedResidueHeight M f P X q<0) + (hu:¬Nonempty (PointedResidueEarlierUpper M f P X q)) : + pointedResidueActive M f P X q=∅ := by + apply Set.eq_empty_iff_forall_notMem.mpr + intro i hi + apply hu + exact ⟨pointedResidueUpperTop M f P X q hx,pointedResidueUpperTop_mem M f hx hh ⟨i,hi⟩⟩ + +lemma pointedResidue_pointed_candidate {strict:Bool} {P X:Deligne M} {q:ℤ} + (hX:PointedResidueAllowed M f strict P X q) (x:Artin M) (hx:x∈P.val.2) + (hboundary:∀H,ClassCapOn Q (pointedFamily M f x H) + (closedNeighborhood Q (U P.val.1)\U P.val.1) q) + (hh:pointedResidueHeight M f P X q<0) + (hu:¬Nonempty (PointedResidueEarlierUpper M f P X q)) + (hl:¬Nonempty (PointedResidue M f true X q)) : + PointedCandidate M f P.val.1 X.val.1 (sourceCosetRepresentative M X) q := by + have ha:=pointedResidue_pointed_active_empty M f hX.1.le hh hu + let z:=sourceCosetRepresentative M X + have hz:=sourceCosetRepresentative_mem M X + refine ⟨deligne_lt_type M hX.1,?_,?_,?_⟩ + · have he:=pointedResidue_exterior_cap M f hX x z hx hz (closedNeighborhood Q (U P.val.1)) + (by simpa only [←unfoldedInclusion_range] using hboundary) + simpa only [←unfoldedInclusion_range] using he + · intro i hi hn + change (framedCartan M *ᵥ pointedCosetVector M f X q) (.inl i)<0 + by_contra hr + have hm:i∈pointedResidueActive M f P X q:=⟨hi,hn,le_of_not_gt hr⟩ + rw [ha] at hm + exact hm + · intro y hy hcap j + have hy':y∈X.val.2:=by rw [sourceCosetRepresentative_spec];exact hy + change pointedCosetVector M f X q (.inl (j:S))≤ pointedMultiplicity M f y q (.inl (j:S)) + by_contra hn + apply hl + apply pointedResidue_single_open M f X y hy' q j j.property + · intro k hk + exact pointedMultiplicity_cap_zero M f P.val.1 y q k hk hcap j (hX.1.le.1 j.property) + · exact lt_of_not_ge hn + +theorem pointedResidue_negative_pointeds_unique {strict:Bool} {P X Y:Deligne M} {q:ℤ} + (hX:PointedResidueAllowed M f strict P X q) (hY:PointedResidueAllowed M f strict P Y q) + (x:Artin M) (hx:x∈P.val.2) + (hboundary:∀H,ClassCapOn Q (pointedFamily M f x H) + (closedNeighborhood Q (U P.val.1)\U P.val.1) q) + (hhX:pointedResidueHeight M f P X q<0) (hhY:pointedResidueHeight M f P Y q<0) + (huX:¬Nonempty (PointedResidueEarlierUpper M f P X q)) + (huY:¬Nonempty (PointedResidueEarlierUpper M f P Y q)) + (hlX:¬Nonempty (PointedResidue M f true X q)) + (hlY:¬Nonempty (PointedResidue M f true Y q)) : X=Y := by + let z:=sourceCosetRepresentative M X + let w:=sourceCosetRepresentative M Y + let g:=w*z⁻¹ + have hz:z∈P.val.2:=hX.1.le.2 (sourceCosetRepresentative_mem M X) + have hw:w∈P.val.2:=hY.1.le.2 (sourceCosetRepresentative_mem M Y) + have hg:g∈artinParabolic M P.val.1:=by + rw [←sourceCoset_eq M P z hz] at hw + exact hw + have he:g*z=w:=by dsimp [g];group + have hcX:=pointedResidue_pointed_candidate M f hX x hx hboundary hhX huX hlX + have hcY:=pointedResidue_pointed_candidate M f hY x hx hboundary hhY huY hlY + obtain ⟨ht,hc⟩:=pointedCandidate_unique M f P.val.1 X.val.1 Y.val.1 P.property.1 z g hg q hcX + (by simpa only [he] using hcY) + apply Subtype.ext + apply Prod.ext ht + rw [sourceCosetRepresentative_spec,sourceCosetRepresentative_spec] + simpa only [he] using hc + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueAllowed.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueAllowed.lean new file mode 100644 index 0000000000000000000000000000000000000000..eb5260e71035adad0d53615f04d1ef5a0bca1bc7 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueAllowed.lean @@ -0,0 +1,104 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetGeometry +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.ResidueAllowed +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Coset + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + +def PointedResidueAllowed (strict:Bool) (P Q:Deligne M) (q:ℤ) : Prop := + Q

pointedCosetVector_harmonic M f P k ⟨i,Set.image_mono h.1 i.property⟩) + intro i hi + by_cases hp:i∈(Sum.inl:S→S⊕Unit) '' P.val.1 + · obtain ⟨j,hj,rfl⟩:=hp + exact ho j hj (fun hq=>hi ⟨j,hq,rfl⟩) + · exact (pointedCosetVector_upper_outside M f h k i hp).symm.le + +lemma pointedCosetVector_lower_compare_int_rev {P Q:Deligne M} (h:Q≤P) (k:ℤ) + (ho:∀i∈P.val.1,i∉Q.val.1→pointedCosetVector M f P k (.inl i)≤ pointedCosetVector M f Q k (.inl i)) : + pointedCosetVector M f P k≤ pointedCosetVector M f Q k := by + apply harmonic_boundary_comparison (framedCartan M) ((Sum.inl:S→S⊕Unit) '' Q.val.1) + (framed_spherical_posDef M Q.val.1 Q.property.1) (framedCartan_off M) + (pointedCosetVector M f P k) (pointedCosetVector M f Q k) + (fun i=>pointedCosetVector_harmonic M f P k ⟨i,Set.image_mono h.1 i.property⟩) + (pointedCosetVector_harmonic M f Q k) + intro i hi + by_cases hp:i∈(Sum.inl:S→S⊕Unit) '' P.val.1 + · obtain ⟨j,hj,rfl⟩:=hp + exact ho j hj (fun hq=>hi ⟨j,hq,rfl⟩) + · exact (pointedCosetVector_upper_outside M f h k i hp).le + +lemma pointedResidueAllowed_le {strict:Bool} {P Q:Deligne M} {q:ℤ} + (h:PointedResidueAllowed M f strict P Q q) : pointedCosetVector M f Q q≤ pointedCosetVector M f P q := by + apply pointedCosetVector_lower_compare_int M f h.1.le q + intro i hi hn + have hh:=(h.2 i hi hn).2 + cases strict with + | false => exact hh + | true => exact hh.le + +lemma pointedResidueHeight_nonpos {strict:Bool} {P Q:Deligne M} {q:ℤ} + (h:PointedResidueAllowed M f strict P Q q) : pointedResidueHeight M f P Q q≤0 := by + exact Finset.sum_nonpos (fun i _=>sub_nonpos.mpr (pointedResidueAllowed_le M f h (.inl i))) + +lemma pointedResidueHeight_strict {P Q:Deligne M} {q:ℤ} + (h:PointedResidueAllowed M f true P Q q) : pointedResidueHeight M f P Q q<0 := by + have ht:=deligne_lt_type M h.1 + obtain ⟨i,hi,hn⟩:=Set.exists_of_ssubset ht + apply Finset.sum_neg' (fun i _=>sub_nonpos.mpr (pointedResidueAllowed_le M f h (.inl i))) + exact ⟨i,Set.mem_toFinset.mpr hi,sub_neg.mpr (by simpa only [↓reduceIte] using (h.2 i hi hn).2)⟩ + +lemma pointedResidueHeight_mono {P Q R:Deligne M} {q:ℤ} + (h:pointedCosetVector M f Q q≤ pointedCosetVector M f R q) : + pointedResidueHeight M f P Q q≤ pointedResidueHeight M f P R q := + Finset.sum_le_sum (fun i _=>sub_le_sub_right (h (.inl i)) _) + +lemma pointedResidueHeight_lt {P Q R:Deligne M} {q:ℤ} + (h:pointedCosetVector M f Q q≤ pointedCosetVector M f R q) + (hn:∃i∈P.val.1,pointedCosetVector M f Q q (.inl i)sub_le_sub_right (h (.inl i)) _) + obtain ⟨i,hi,hl⟩:=hn + exact ⟨i,Set.mem_toFinset.mpr hi,sub_lt_sub_right hl _⟩ + +lemma pointedResidueAllowed_upper {strict:Bool} {P Q R:Deligne M} {q:ℤ} + (h:PointedResidueAllowed M f strict P Q q) (hr:Q≤R) (hp:Rhn (hr.1 hh) + have he(d:ℤ):pointedCosetVector M f R d (.inl i)=pointedCosetVector M f Q d (.inl i):= + pointedCosetVector_upper_outside M f hr d _ (by + rintro ⟨j,hj,hh⟩;exact hn ((Sum.inl_injective hh) ▸ hj)) + simp only [he] + exact h.2 i hi hq + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueEarlierLower.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueEarlierLower.lean new file mode 100644 index 0000000000000000000000000000000000000000..755ecd38cd753c602ca74b32556157177800b39e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueEarlierLower.lean @@ -0,0 +1,155 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetGeometry +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.ResidueEarlierLower +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.NerveOrderRetractionEquiv +import OAI.Topology.ArtinGroups.Harmonic.ResidueAllowed + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open Simplicial CategoryTheory + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + +lemma pointedResidueAllowed_trans {strict:Bool} {P Q R:Deligne M} {q:ℤ} + (hQ:PointedResidueAllowed M f strict P Q q) (hR:PointedResidueAllowed M f true Q R q) : + PointedResidueAllowed M f strict P R q := by + refine ⟨hR.1.trans hQ.1,?_⟩ + intro i hi hn + by_cases hq:i∈Q.val.1 + · have hr:=hR.2 i hq hn + have hl:pointedCosetVector M f R q (.inl i) exact hl.le + | true => exact hl + · have he(d:ℤ):pointedCosetVector M f Q d (.inl i)=pointedCosetVector M f R d (.inl i):= + pointedCosetVector_upper_outside M f hR.1.le d _ (by + rintro ⟨j,hj,hh⟩;exact hq ((Sum.inl_injective hh) ▸ hj)) + simpa only [he] using hQ.2 i hi hq + +lemma pointedResidue_strict_height_drop {P Q R:Deligne M} {q:ℤ} + (hQ:Q≤P) (hR:PointedResidueAllowed M f true Q R q) : + pointedResidueHeight M f P R qhn ⟨i,hi,hnY,hl⟩) + exact (not_lt_of_ge (pointedResidueHeight_mono M f hc)) hh + +lemma pointedResidueNegative_shared {X Y Z:Deligne M} {q:ℤ} (h:Y≤Z) (i:S) (hi:i∉Z.val.1) : + i∈pointedResidueNegative M f X Y q ↔ i∈pointedResidueNegative M f X Z q := by + have hy:i∉Y.val.1:=fun hh=>hi (h.1 hh) + have he:=pointedCosetVector_upper_outside M f h q (.inl i) (by + rintro ⟨j,hj,hh⟩;exact hi ((Sum.inl_injective hh) ▸ hj)) + simp only [pointedResidueNegative,Set.mem_ofPred_eq,hy,hi,not_false_eq_true,true_and,he] + +noncomputable def pointedResidueClose (X Y:Deligne M) (q:ℤ) : Deligne M := + sourceCoset M (X.val.1 \ pointedResidueNegative M f X Y q) + (source_spherical_mono M Set.sdiff_subset X.property.1) (sourceCosetRepresentative M Y) + +lemma le_pointedResidueClose {X Y:Deligne M} {q:ℤ} (h:Y≤X) : Y≤ pointedResidueClose M f X Y q := by + calc + Y=sourceCoset M Y.val.1 Y.property.1 (sourceCosetRepresentative M Y):= + (sourceCoset_eq M Y _ (sourceCosetRepresentative_mem M Y)).symm + _≤ pointedResidueClose M f X Y q:=sourceCoset_le M (show Y.val.1⊆X.val.1 \ pointedResidueNegative M f X Y q from + fun i hi=>⟨h.1 hi,fun hn=>hn.2.1 hi⟩) _ + +lemma pointedResidueClose_le {X Y:Deligne M} {q:ℤ} (h:Y≤X) : pointedResidueClose M f X Y q≤X := by + calc + pointedResidueClose M f X Y q≤ sourceCoset M X.val.1 X.property.1 (sourceCosetRepresentative M Y):= + sourceCoset_le M Set.sdiff_subset _ + _=X:=sourceCoset_eq M X _ (h.2 (sourceCosetRepresentative_mem M Y)) + +lemma pointedResidueClose_strict {strict:Bool} {P X Y:Deligne M} {q:ℤ} + (hy:PointedResidueAllowed M f strict P Y q) (hx:X≤P) (hyx:Y≤X) + (hh:pointedResidueHeight M f P Y qK.val.1) he + have hm:i∈(pointedResidueClose M f X Y q).val.1:=by rw [ht]; exact hi.1 + exact hm.2 hi + · intro i hi hn + have hc: i∈pointedResidueNegative M f X Y q:=by + by_contra hnot + exact hn ⟨hi,hnot⟩ + have he(d:ℤ):pointedCosetVector M f (pointedResidueClose M f X Y q) d (.inl i)=pointedCosetVector M f Y d (.inl i):= + pointedCosetVector_upper_outside M f (le_pointedResidueClose M f hyx) d _ (by + rintro ⟨j,hj,hh⟩;exact hn ((Sum.inl_injective hh) ▸ hj)) + simp only [↓reduceIte,he] + exact ⟨(hy.2 i (hx.1 hi) hc.2.1).1,hc.2.2⟩ + +lemma pointedResidueClose_monotone {X Y Z:Deligne M} {q:ℤ} (h:Y≤Z) (hz:Z≤X) : + pointedResidueClose M f X Y q≤ pointedResidueClose M f X Z q := by + have ht:X.val.1 \ pointedResidueNegative M f X Y q⊆X.val.1 \ pointedResidueNegative M f X Z q:=by + intro i hi + refine ⟨hi.1,?_⟩ + intro hh + exact hi.2 ((pointedResidueNegative_shared M f h i hh.2.1).mpr hh) + calc + pointedResidueClose M f X Y q≤ sourceCoset M (pointedResidueClose M f X Z q).val.1 + (pointedResidueClose M f X Z q).property.1 (sourceCosetRepresentative M Y):=sourceCoset_le M ht _ + _=pointedResidueClose M f X Z q:=sourceCoset_eq M _ _ + ((le_pointedResidueClose M f hz).2 (h.2 (sourceCosetRepresentative_mem M Y))) + +lemma pointedResidueClose_eq {X Y:Deligne M} {q:ℤ} + (h:PointedResidueAllowed M f true X Y q) : pointedResidueClose M f X Y q=Y := by + symm + apply deligne_eq_of_le_type_eq M (le_pointedResidueClose M f h.1.le) + ext i + change i∈Y.val.1 ↔ i∈X.val.1 ∧ ¬i∈pointedResidueNegative M f X Y q + constructor + · intro hi + exact ⟨h.1.le.1 hi,fun hn=>hn.2.1 hi⟩ + · rintro ⟨hi,hn⟩ + by_contra hy + exact hn ⟨hi,hy,by simpa only [↓reduceIte] using (h.2 i hi hy).2⟩ + +noncomputable def pointedResidueLowerInclusion {strict:Bool} {P X:Deligne M} {q:ℤ} + (hX:PointedResidueAllowed M f strict P X q) : + PointedResidue M f true X q →o PointedResidueEarlierLower M f strict P X q where + toFun Y:=⟨Y.val,pointedResidueAllowed_trans M f hX Y.property,Y.property.1, + pointedResidue_strict_height_drop M f hX.1.le Y.property⟩ + monotone':=fun _ _ h=>h + +noncomputable def pointedResidueLowerProjection {strict:Bool} {P X:Deligne M} {q:ℤ} + (hX:PointedResidueAllowed M f strict P X q) : + PointedResidueEarlierLower M f strict P X q →o PointedResidue M f true X q where + toFun Y:=⟨pointedResidueClose M f X Y q,pointedResidueClose_strict M f Y.property.1 hX.1.le + Y.property.2.1.le Y.property.2.2⟩ + monotone':=fun _ Z h=>pointedResidueClose_monotone M f h Z.property.2.1.le + +noncomputable def pointedResidueLowerEquiv {strict:Bool} {P X:Deligne M} {q:ℤ} + (hX:PointedResidueAllowed M f strict P X q) : + ContinuousMap.HomotopyEquiv |CategoryTheory.nerve (PointedResidueEarlierLower M f strict P X q)| + |CategoryTheory.nerve (PointedResidue M f true X q)| := + nerveOrderRetractionEquiv (pointedResidueLowerProjection M f hX) (pointedResidueLowerInclusion M f hX) + (by apply OrderHom.ext; funext Y; apply Subtype.ext; exact pointedResidueClose_eq M f Y.property) + (fun Y=>le_pointedResidueClose M f Y.property.2.1.le) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueEarlierLowerIso.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueEarlierLowerIso.lean new file mode 100644 index 0000000000000000000000000000000000000000..a5f075309098fa63c2e4ce6538609e02b4f83b7c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueEarlierLowerIso.lean @@ -0,0 +1,100 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetExteriorCap +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueActive +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueEarlierLower +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueRank +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.ResidueEarlierLowerIso +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightEarlierLower +import OAI.Topology.ArtinGroups.Harmonic.ResidueEarlierLower +import OAI.Topology.ArtinGroups.Harmonic.ResidueActive +import OAI.Topology.ArtinGroups.Harmonic.ResidueRank + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "U" => fun J:Set S=>Set.range (unfoldedInclusion M J) + +lemma pointedResidueEarlier_total (strict:Bool) (P:Deligne M) (q:ℤ) + (X Y:PointedResidue M f strict P q) (h:X≠Y) : + PointedResidueEarlier M f strict P q X Y ∨ PointedResidueEarlier M f strict P q Y X := by + exact lt_or_gt_of_ne (fun he=>h (pointedResidueKey_injective M f strict P q he)) + +noncomputable def pointedResidueEarlierLowerIso {strict:Bool} {P:Deligne M} {q:ℤ} + (X:PointedResidue M f strict P q) (hh:pointedResidueHeight M f P X q<0) : + WeightEarlierLower (PointedResidueEarlier M f strict P q) X ≃o + PointedResidueEarlierLower M f strict P X q where + toFun Y:=⟨Y.val.val,Y.val.property,Y.property.2, + (pointedResidueEarlier_lower_negative M f X Y.val Y.property.2 hh).mp Y.property.1⟩ + invFun Y:=⟨⟨Y.val,Y.property.1⟩, + (pointedResidueEarlier_lower_negative M f X ⟨Y.val,Y.property.1⟩ Y.property.2.1 hh).mpr Y.property.2.2, + Y.property.2.1⟩ + left_inv _:=rfl + right_inv _:=rfl + map_rel_iff':=by intros;rfl + +noncomputable def pointedResidueEarlierUpperIso {strict:Bool} {P:Deligne M} {q:ℤ} + (X:PointedResidue M f strict P q) (hh:pointedResidueHeight M f P X q<0) : + WeightEarlierUpper (PointedResidueEarlier M f strict P q) X ≃o + PointedResidueEarlierUpper M f P X q where + toFun Y:=⟨Y.val.val,Y.property.2,Y.val.property.1, + (pointedResidueEarlier_upper_negative M f X Y.val Y.property.2 hh).mp Y.property.1⟩ + invFun Y:=⟨⟨Y.val,pointedResidueAllowed_upper M f X.property Y.property.1.le Y.property.2.1⟩, + (pointedResidueEarlier_upper_negative M f X _ Y.property.1 hh).mpr Y.property.2.2,Y.property.1⟩ + left_inv _:=rfl + right_inv _:=rfl + map_rel_iff':=by intros;rfl + +lemma pointedResidue_lower_boundary {strict:Bool} {P X:Deligne M} {q:ℤ} + (hX:PointedResidueAllowed M f strict P X q) (x:Artin M) (hx:x∈P.val.2) + (hb:∀H,ClassCapOn Q (pointedFamily M f x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) : + ∀H,ClassCapOn Q (pointedFamily M f (sourceCosetRepresentative M X) H) + (closedNeighborhood Q (U X.val.1)\U X.val.1) q := by + have h':=pointedResidue_exterior_cap M f hX x (sourceCosetRepresentative M X) hx + (sourceCosetRepresentative_mem M X) (closedNeighborhood Q (U P.val.1)) + (by simpa only [←unfoldedInclusion_range] using hb) + intro H + apply ClassCapOn.mono Q (h' H) + intro α hα + refine ⟨closedNeighborhood_mono Q (unfoldedInclusion_range_mono M hX.1.le.1) hα.1,?_⟩ + simpa only [←unfoldedInclusion_range] using hα.2 + +lemma pointedResidue_upper_weights_contractible {strict:Bool} {P:Deligne M} {q:ℤ} + (X:PointedResidue M f strict P q) (hh:pointedResidueHeight M f P X q<0) + (hn:Nonempty (WeightEarlierUpper (PointedResidueEarlier M f strict P q) X)) : + ContractibleSpace (OrderWeights (WeightEarlierUpper (PointedResidueEarlier M f strict P q) X)) := by + let e:=pointedResidueEarlierUpperIso M f X hh + have hc:=pointedResidueEarlierUpper_contractible M f X.property.1.le hh (hn.map e) + have hw:ContractibleSpace (OrderWeights (PointedResidueEarlierUpper M f P X q)):= + nerveWeightsHomeomorph.contractibleSpace_iff.mp hc + exact (weightHomeomorph e).contractibleSpace_iff.mpr hw + +lemma pointedResidue_emptyLink_upper {strict:Bool} {P:Deligne M} {q:ℤ} + (X:PointedResidue M f strict P q) (hh:pointedResidueHeight M f P X q<0) + (hn:¬Nonempty (WeightEarlierLink (PointedResidueEarlier M f strict P q) X)) : + ¬Nonempty (PointedResidueEarlierUpper M f P X q) := by + intro h + obtain ⟨Y⟩:=h.map (pointedResidueEarlierUpperIso M f X hh).symm + exact hn ⟨Y.val,Y.property.1,Or.inr Y.property.2.le⟩ + +lemma pointedResidue_emptyLink_lower {strict:Bool} {P:Deligne M} {q:ℤ} + (X:PointedResidue M f strict P q) (hh:pointedResidueHeight M f P X q<0) + (hn:¬Nonempty (WeightEarlierLink (PointedResidueEarlier M f strict P q) X)) : + ¬Nonempty (PointedResidue M f true X q) := by + intro h + obtain ⟨Y⟩:=h.map (pointedResidueLowerInclusion M f X.property) + let Z:=(pointedResidueEarlierLowerIso M f X hh).symm Y + exact hn ⟨Z.val,Z.property.1,Or.inl Z.property.2.le⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueHeightZero.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueHeightZero.lean new file mode 100644 index 0000000000000000000000000000000000000000..b3128a9483af9a961d459983fe7125e3391971ed --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueHeightZero.lean @@ -0,0 +1,104 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetGeometry +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetExteriorCap +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedNullPatch +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Harmonic.ResidueHeightZeroVector +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.CosetVectorNullPatch +import OAI.Topology.ArtinGroups.Harmonic.CosetExteriorCap + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +lemma pointedResidueHeight_zero_vector {strict:Bool} {P X:Deligne M} {q:ℤ} + (hx:PointedResidueAllowed M f strict P X q) (hh:pointedResidueHeight M f P X q=0) : + pointedCosetVector M f X q=pointedCosetVector M f P q := by + have hn:=pointedResidueAllowed_le M f hx + funext v + by_cases hp:v∈Sum.inl '' P.val.1 + · obtain ⟨i,hi,rfl⟩:=hp + have hz:pointedCosetVector M f X q (.inl i)-pointedCosetVector M f P q (.inl i)=0 := + (Finset.sum_eq_zero_iff_of_nonpos (fun j _=>sub_nonpos.mpr (hn (.inl j)))).mp hh i (Set.mem_toFinset.mpr hi) + exact sub_eq_zero.mp hz + · exact (pointedCosetVector_upper_outside M f hx.1.le q v hp).symm + +lemma pointedResidueAllowed_closed_trans {P X Y:Deligne M} {q:ℤ} + (hX:PointedResidueAllowed M f false P X q) (hY:PointedResidueAllowed M f false X Y q) : + PointedResidueAllowed M f false P Y q := by + refine ⟨hY.1.trans hX.1,?_⟩ + intro i hi hni + by_cases hxi:i∈X.val.1 + · have hv:=pointedResidueAllowed_le M f hX (.inl i) + exact ⟨(hY.2 i hxi hni).1,(hY.2 i hxi hni).2.trans hv⟩ + · have he(k:ℤ):pointedCosetVector M f Y k (.inl i)=pointedCosetVector M f X k (.inl i):= + (pointedCosetVector_upper_outside M f hY.1.le k _ (by + rintro ⟨j,hj,hh⟩;exact hxi ((Sum.inl_injective hh) ▸ hj))).symm + simpa only [he] using hX.2 i hi hxi + +lemma pointedResidue_zero_lower_iff {P X Y:Deligne M} {q:ℤ} + (hx:PointedResidueAllowed M f false P X q) (hh:pointedResidueHeight M f P X q=0) (hy:YpointedResidueHeight M f P X q)).Finite := by + let A: Set (S⊕Unit→ℝ):={v | ∃X:Deligne M,∃k:ℤ,pointedCosetSum M f X k≤ pointedCosetSum M f P q ∧ v=pointedCosetVector M f X k} + have hA:A.Finite:=pointedCosetVector_bounded_finite M f _ + apply (hA.image (fun v:S⊕Unit→ℝ=>∑i∈P.val.1.toFinset,(v (.inl i)-pointedCosetVector M f P q (.inl i)))).subset + rintro h ⟨X,rfl⟩ + refine ⟨pointedCosetVector M f X q,⟨X,q,?_,rfl⟩,rfl⟩ + exact Finset.sum_le_sum (fun i _=>pointedResidueAllowed_le M f X.property i) + +noncomputable def pointedResidueRank (strict:Bool) (P:Deligne M) (q:ℤ) (h:ℝ) : ℕ := + {a:ℝ | a∈Set.range (fun X:PointedResidue M f strict P q=>pointedResidueHeight M f P X q) ∧ apointedResidueHeight M f P X q)) (hab:ah.1)) + refine ⟨fun _ h=>⟨h.1,h.2.trans hab⟩,?_⟩ + intro h + exact (h ⟨ha,hab⟩).2.false + +lemma pointedResidueRank_lt_iff (strict:Bool) (P:Deligne M) (q:ℤ) + (X Y:PointedResidue M f strict P q) : + pointedResidueRank M f strict P q (pointedResidueHeight M f P X q)< + pointedResidueRank M f strict P q (pointedResidueHeight M f P Y q) ↔ + pointedResidueHeight M f P X q(ofLex (ofLex z).2).2) h + +theorem pointedResidueEarlier_wellFounded (strict:Bool) (P:Deligne M) (q:ℤ) : + WellFounded (PointedResidueEarlier M f strict P q) := + InvImage.wf (pointedResidueKey M f strict P q) wellFounded_lt + +lemma pointedResidueEarlier_iff (strict:Bool) (P:Deligne M) (q:ℤ) + (X Y:PointedResidue M f strict P q) : + PointedResidueEarlier M f strict P q X Y ↔ + pointedResidueHeight M f P X qA.val.1) he + have hm:j∈T:=by rw [he'];exact hj + exact hm.2 rfl + have hrz:z∈R.val.2:=rightCoset_self M T z + refine ⟨R,hrlt,?_⟩ + intro i hi hn + have hei:i=j := by + by_contra hne + exact hn ⟨hi,hne⟩ + subst i + have hvec(k:ℤ):pointedCosetVector M f R k (.inl j)=pointedMultiplicity M f z k (.inl j):= + pointedCosetVector_open_at M f R z hrz _ (by + rintro ⟨i,hi,he⟩;exact hn ((Sum.inl_injective he) ▸ hi)) k + simpa only [hvec] using And.intro hcap hbound + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueZeroLower.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueZeroLower.lean new file mode 100644 index 0000000000000000000000000000000000000000..cf5b3bdb8657b2b5d440fcbd24af567188c59b39 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedResidueZeroLower.lean @@ -0,0 +1,65 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedStrictResidue +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueHeightZero +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.DeligneRankBound + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open Simplicial CategoryTheory +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "U" => fun J:Set S=>Set.range (unfoldedInclusion M J) + +lemma pointedResidue_lower_weights_contractible {strict:Bool} {P:Deligne M} {q:ℤ} + (X:PointedResidue M f strict P q) (hh:pointedResidueHeight M f P X q<0) + (x:Artin M) (hx:x∈P.val.2) + (hb:∀H,ClassCapOn Q (pointedFamily M f x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) + (hX:Nonempty (WeightEarlierLower (PointedResidueEarlier M f strict P q) X)) : + ContractibleSpace (OrderWeights (WeightEarlierLower (PointedResidueEarlier M f strict P q) X)) := by + let e:=pointedResidueEarlierLowerIso M f X hh + have hsmall:Nonempty (PointedResidue M f true X q):= + (hX.map e).map (pointedResidueLowerProjection M f X.property) + have :=pointedStrictResidue_contractible M f X q (sourceCosetRepresentative M X) + (sourceCosetRepresentative_mem M X) (pointedResidue_lower_boundary M f X.property x hx hb) hsmall + have hc:= (pointedResidueLowerEquiv M f X.property).contractibleSpace + exact (weightHomeomorph e).contractibleSpace_iff.mpr + (nerveWeightsHomeomorph.contractibleSpace_iff.mp hc) + +noncomputable def pointedResidueZeroLowerIso {P:Deligne M} {q:ℤ} + (X:PointedResidue M f false P q) (hh:pointedResidueHeight M f P X q=0) : + WeightEarlierLower (PointedResidueEarlier M f false P q) X ≃o PointedResidue M f false X q where + toFun Y:=⟨Y.val.val,(pointedResidue_zero_lower_iff M f X.property hh Y.property.2).mp Y.val.property⟩ + invFun Y:=⟨⟨Y.val,pointedResidueAllowed_closed_trans M f X.property Y.property⟩, + pointedResidueEarlier_lower_zero M f X _ Y.property.1 hh,Y.property.1⟩ + left_inv _:=rfl + right_inv _:=rfl + map_rel_iff':=by intros;rfl + +lemma pointedResidueZeroUpper_empty {P:Deligne M} {q:ℤ} + (X:PointedResidue M f false P q) (hh:pointedResidueHeight M f P X q=0) : + ¬Nonempty (WeightEarlierUpper (PointedResidueEarlier M f false P q) X) := by + rintro ⟨Y⟩ + exact pointedResidueEarlier_upper_zero M f X Y.val Y.property.2 hh Y.property.1 + +lemma pointedResidue_special_boundary {P:Deligne M} {q:ℤ} + (I:Set S) (hPI:P.val.1⊆I) (x:Artin M) + (hE:∀H,ClassCapOn Q (pointedFamily M f x H) + (closedNeighborhood Q (fusionColorRegion m (Sum.inl '' I)) \fusionColorRegion m (Sum.inl '' P.val.1)) q) : + ∀H,ClassCapOn Q (pointedFamily M f x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q := by + intro H + apply ClassCapOn.mono Q (hE H) + intro α hα + refine ⟨closedNeighborhood_mono Q ?_ hα.1,?_⟩ + · change Set.range (unfoldedInclusion M P.val.1) ⊆ _ + rw [unfoldedInclusion_range] + exact fun _ h=>(Set.image_mono hPI) h + · simpa only [←unfoldedInclusion_range] using hα.2 + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedRows.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..cfc03459f184b51fa04a74d8534bf498edf601a8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedRows.lean @@ -0,0 +1,31 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetGeometry +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.PositiveComponent +import OAI.Topology.ArtinGroups.Harmonic.Coset +import OAI.Topology.ArtinGroups.Harmonic.CosetProfile + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + +lemma pointedCosetVector_eq_of_upper_rows {P R:Deligne M} (h:P≤R) (k:ℤ) + (hr:∀i∈R.val.1,i∉P.val.1→(framedCartan M *ᵥ pointedCosetVector M f P k) (.inl i)=0) : + pointedCosetVector M f R k=pointedCosetVector M f P k := by + rw [pointedCosetVector_upper_harmonize M f h k] + symm + apply harmonicExtension_unique (framedCartan M) + ((Sum.inl:S→S⊕Unit) '' R.val.1) (framed_spherical_posDef M R.val.1 R.property.1) + (pointedCosetVector M f P k) (pointedCosetVector M f P k) + · intro _ _; rfl + · rintro ⟨_,⟨i,hi,rfl⟩⟩ + by_cases ht:i∈P.val.1 + · exact pointedCosetVector_harmonic M f P k ⟨.inl i,⟨i,ht,rfl⟩⟩ + · exact hr i hi ht + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedSpecialResidue.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedSpecialResidue.lean new file mode 100644 index 0000000000000000000000000000000000000000..4a57f043b32e0f4b84b15340b8637958850422a1 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedSpecialResidue.lean @@ -0,0 +1,91 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueZeroLower +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedStrictResidue +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueHeightZero +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.ResidueZeroLowerIso + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open Simplicial CategoryTheory _root_.Matrix _root_.OAI.Matrix +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +private theorem pointedSpecialResidue_rank (n:ℕ) : ∀(P:Deligne M),P.val.1.ncard=n → + ∀(x:Artin M),x∈P.val.2 → x∈artinParabolic M {f}ᶜ → + ∀(I:Set S),I.Nonempty → f∉I → P.val.1⊆I → ∀(q:ℤ), + ∀(c:S⊕Unit→ℝ),(∀v,0≤c v) → (∀v,v∉Sum.inl '' I→c v=0) → + (∀v,v∈Sum.inl '' I→0 + intro P hn x hx hxA I hI hf hPI q c hc hcSupp hcPos hcNull hE hdata + let r:=PointedResidueEarlier M f false P q + have hb:=pointedResidue_special_boundary M f I hPI x hE + have hzcont:∀(X:PointedResidue M f false P q),pointedResidueHeight M f P X q=0 → + ContractibleSpace (OrderWeights (PointedResidue M f false X q)):=by + intro X hh + have hrank:X.val.val.1.ncardX.val.val.1.ncard) (Fintype.card S) + (fun X=>sourceDeligne_rank_bound M X) (by intro X Y h;exact sourceDeligne_rank_strictMono M h) + ?_ ?_ ?_ (pointedClosedResidue_nonempty M f P x hx hxA I hI hf hPI q c hc hcSupp hcPos hcNull hE hdata) + · intro X hX + rcases lt_or_eq_of_le (pointedResidueHeight_nonpos M f X.property) with hh|hh + · exact pointedResidue_lower_weights_contractible M f X hh x hx hb hX + · exact (weightHomeomorph (pointedResidueZeroLowerIso M f X hh)).contractibleSpace_iff.mpr (hzcont X hh) + · intro X hX + rcases lt_or_eq_of_le (pointedResidueHeight_nonpos M f X.property) with hh|hh + · exact pointedResidue_upper_weights_contractible M f X hh hX + · exact False.elim (pointedResidueZeroUpper_empty M f X hh hX) + · intro X Y hX hY + have hhX:=hneg X hX + have hhY:=hneg Y hY + apply Subtype.ext + exact pointedResidue_negative_pointeds_unique M f X.property Y.property x hx hb hhX hhY + (pointedResidue_emptyLink_upper M f X hhX hX) (pointedResidue_emptyLink_upper M f Y hhY hY) + (pointedResidue_emptyLink_lower M f X hhX hX) (pointedResidue_emptyLink_lower M f Y hhY hY) + +theorem pointedSpecialResidue_contractible (P:Deligne M) (x:Artin M) (hx:x∈P.val.2) (hxA:x∈artinParabolic M {f}ᶜ) + (I:Set S) (hI:I.Nonempty) (hf:f∉I) (hPI:P.val.1⊆I) (q:ℤ) + (c:S⊕Unit→ℝ) (hc:∀v,0≤c v) (hcSupp:∀v,v∉Sum.inl '' I→c v=0) + (hcPos:∀v,v∈Sum.inl '' I→0 fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "diag" => coxeterFusionEdge_diag M +local notation "Q" => fusionQuiver m d hd + +/-- Every member is the transport of one indecomposable projective. -/ +lemma pointed_endomorphism_dimension_le_one (z : Artin M) + (hz : z ∈ artinParabolic M {f}ᶜ) (L : PointedLabel M) : + classHomDimension Q 0 0 (pointedFamily M f z L) (pointedFamily M f z L) ≤ 1 := by + obtain ⟨u, _, rfl⟩ := artinParabolic_signed_word M {f}ᶜ z hz + rw [pointedFamily_word] + rw [fusionOrbit_homDimension m d hd diag] + exact initial_homDimension_le_one Q (fusionQuiver_no_loops m d hd diag) (.inl f,L) 0 0 + +/-- An unoperated frame supplies a nonzero exterior generator in each +member, including when its cochain position is not explicitly chosen. -/ +lemma pointed_exterior_generator (Y : Set S) (hf : f ∉ Y) (z : Artin M) + (hz : z ∈ artinParabolic M {f}ᶜ) (L : PointedLabel M) : + ∃ p : GeneratorPlacement (FusionVertex (V := S⊕Unit) m), + p.color ∉ fusionColorRegion m (Sum.inl '' Y) ∧ + 0 < classGeneratorArray Q (pointedFamily M f z L) p := by + obtain ⟨u, hu, rfl⟩ := artinParabolic_signed_word M {f}ᶜ z hz + rw [pointedFamily_word] + obtain ⟨j, hj, _⟩ := orbit_frame_generator m d hd diag (sourcePacketWord u) (.inl f) + (by + intro a ha he + obtain ⟨b, hb, rfl⟩ := List.mem_map.mp ha + exact hu b hb (Sum.inl.inj he)) L + refine ⟨(fusionOrbitModel m d hd diag (sourcePacketWord u) (.inl f) L).complex.placement j, + ?_, (generatorArray_positive_iff Q _ _).mpr ⟨j, rfl⟩⟩ + change ((fusionOrbitModel m d hd diag (sourcePacketWord u) (.inl f) L).complex.placement j).color.1 + ∉ Sum.inl '' Y + rw [congrArg Prod.fst hj] + rintro ⟨s, hs, he⟩ + exact hf (Sum.inl.inj he ▸ hs) + +/-- Proposition 7.4, with the actual Artin action and complete passes +through the original colors. The mesh hypothesis is the abstract +published finite-Dynkin path input; no categorical obstruction is assumed. -/ +theorem pointed_no_bounded_complete_positive_chain (Y : Set S) (hf : f ∉ Y) + (hmesh : MeshNilpotent Q (fusionColorRegion m (Sum.inl '' Y))) + (z : ℕ → Artin M) (u : ℕ → List S) + (hz : z 0 ∈ artinParabolic M {f}ᶜ) + (hstep : ∀ n, z (n+1) = wordArtin M (u n) * z n) + (hu : ∀ n s, s ∈ u n ↔ s ∈ Y) + (L : PointedLabel M) + (hnonzero : ¬ ∀ α ∈ fusionColorRegion m (Sum.inl '' Y), ∀ l c, + ClassTestExact Q α l c (pointedFamily M f (z 0) L)) + (t : ℤ) (ht : ∀ n, ClassTestUpper Q (pointedFamily M f (z n) L) + (fusionColorRegion m (Sum.inl '' Y)) t) : False := by + apply no_bounded_complete_positive_chain Q (fusionQuiver_no_loops m d hd diag) + (fusionColorRegion m (Sum.inl '' Y)) hmesh + (fun n => pointedFamily M f (z n) L) + (fun n => fusionExpandedWord m ((u n).map (Sum.inl : S → S⊕Unit))) + · intro n + rw [hstep n] + change pointedAction M (wordArtin M (u n)*z n) (pointedInitial M f L) = _ + rw [map_mul, Equiv.Perm.mul_apply] + exact sourceArtinAction_positiveWord M (u n) _ + · intro n α + simp only [fusionExpandedWord, List.mem_flatMap, List.mem_map, + Finset.mem_toList, Finset.mem_univ, true_and] + constructor + · rintro ⟨v, ⟨s, hs, rfl⟩, H, rfl⟩ + exact ⟨s, (hu n s).mp hs, rfl⟩ + · rintro ⟨s, hs, he⟩ + refine ⟨.inl s, ⟨s, (hu n s).mpr hs, rfl⟩, α.2, ?_⟩ + exact Prod.ext he rfl + · exact pointed_endomorphism_dimension_le_one M f (z 0) hz L + · exact pointed_exterior_generator M f Y hf (z 0) hz L + · exact hnonzero + · exact ht + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedStrictResidue.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedStrictResidue.lean new file mode 100644 index 0000000000000000000000000000000000000000..96065800662bc3493f246487a0c1c27f0dd9ef39 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedStrictResidue.lean @@ -0,0 +1,86 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueEarlierLower +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueRank +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueEarlierLowerIso +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueActiveEmpty +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCap +import OAI.Topology.ArtinGroups.Realizations.DeligneRankBound +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.OrderWeightsContractibleUnique +import OAI.Topology.ArtinGroups.Harmonic.ResidueActiveEmpty +import OAI.Topology.ArtinGroups.Harmonic.ResidueEarlierLowerIso + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open Simplicial CategoryTheory +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "U" => fun J:Set S=>Set.range (unfoldedInclusion M J) + +private theorem pointedStrictResidue_rank (n:ℕ) : ∀(P:Deligne M),P.val.1.ncard=n → + ∀(q:ℤ) (x:Artin M),x∈P.val.2 → + (∀H,ClassCapOn Q (pointedFamily M f x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) → + Nonempty (PointedResidue M f true P q) → + ContractibleSpace (OrderWeights (PointedResidue M f true P q)) := by + induction n using Nat.strong_induction_on with + | h n ih => + intro P hn q x hx hb hne + let r:=PointedResidueEarlier M f true P q + have hl:∀X:PointedResidue M f true P q,Nonempty (WeightEarlierLower r X) → + ContractibleSpace (OrderWeights (WeightEarlierLower r X)):=by + intro X hX + have hh:=pointedResidueHeight_strict M f X.property + let e:=pointedResidueEarlierLowerIso M f X hh + have hsmall:Nonempty (PointedResidue M f true X q):= + (hX.map e).map (pointedResidueLowerProjection M f X.property) + have hrank:X.val.val.1.ncardX.val.val.1.ncard) (Fintype.card S) + (fun X=>sourceDeligne_rank_bound M X) (by intro X Y h;exact sourceDeligne_rank_strictMono M h) + hl (fun X hX=>pointedResidue_upper_weights_contractible M f X (pointedResidueHeight_strict M f X.property) hX) + ?_ hne + intro X Y hX hY + apply Subtype.ext + have hhX:=pointedResidueHeight_strict M f X.property + have hhY:=pointedResidueHeight_strict M f Y.property + exact pointedResidue_negative_pointeds_unique M f X.property Y.property x hx hb hhX hhY + (pointedResidue_emptyLink_upper M f X hhX hX) (pointedResidue_emptyLink_upper M f Y hhY hY) + (pointedResidue_emptyLink_lower M f X hhX hX) (pointedResidue_emptyLink_lower M f Y hhY hY) + +theorem pointedStrictResidue_contractible (P:Deligne M) (q:ℤ) (x:Artin M) (hx:x∈P.val.2) + (hb:∀H,ClassCapOn Q (pointedFamily M f x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) + (hne:Nonempty (PointedResidue M f true P q)) : + ContractibleSpace |CategoryTheory.nerve (PointedResidue M f true P q)| := + nerveWeightsHomeomorph.contractibleSpace_iff.mpr + (pointedStrictResidue_rank M f P.val.1.ncard P rfl q x hx hb hne) + +theorem pointedStrictResidue_empty_or_contractible (P:Deligne M) (q:ℤ) (x:Artin M) (hx:x∈P.val.2) + (hb:∀H,ClassCapOn Q (pointedFamily M f x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) : + IsEmpty (PointedResidue M f true P q) ∨ + ContractibleSpace |CategoryTheory.nerve (PointedResidue M f true P q)| := by + by_cases h:Nonempty (PointedResidue M f true P q) + · exact Or.inr (pointedStrictResidue_contractible M f P q x hx hb h) + · exact Or.inl (not_nonempty_iff.mp h) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedTop.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedTop.lean new file mode 100644 index 0000000000000000000000000000000000000000..cbee41c4970a6a27e77ff0ae95b1b5985bbaf044 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedTop.lean @@ -0,0 +1,40 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.Harmonic.FrameFamilyTopProportional +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.FusionProfilePositiveEvery +import OAI.Topology.ArtinGroups.Harmonic.FrameFamily + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "Q" => fusionQuiver m d (coxeterFusionEdge_symm M) + +lemma pointedFamily_top_proportional (x:Artin M) (s:S⊕Unit) (q c:ℤ) : + ∃ a:ℝ,0≤a ∧ ∀ L,(∑ H,fusionWeight m H* + (classLayerTopDimension Q q (s,L) c (pointedFamily M f x H):ℝ))=a*fusionWeight m L := by + obtain ⟨w,rfl⟩:=sourceSignedWord_surjective M x + rw [pointedFamily_word] + exact fusionPacketOrbit_top_proportional m d (coxeterFusionEdge_symm M) + (coxeterFusionEdge_diag M) (fusionLabelSize_ge_two M) (sourcePacketWord w) (.inl f) s q c + +lemma pointedFamily_top_zero_of_label (x:Artin M) (s:S⊕Unit) (q:ℤ) + (L₀:FusionLabel m) + (hz:∀ H c,classLayerTopDimension Q q (s,L₀) c (pointedFamily M f x H)=0) : + ∀ H L c,classLayerTopDimension Q q (s,L) c (pointedFamily M f x H)=0 := by + intro H L c + apply Nat.eq_zero_of_not_pos + intro hp + obtain ⟨H',hp'⟩:=fusion_profile_positive_every_label m (fusionLabelSize_ge_two M) + (fun H L=>classLayerTopDimension Q q (s,L) c (pointedFamily M f x H)) + (pointedFamily_top_proportional M f x s q c) hp L₀ + exact hp'.ne' (hz H' c) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedTypeComponent.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedTypeComponent.lean new file mode 100644 index 0000000000000000000000000000000000000000..7330fdfdc4aa45e975605f8c24c68d35dcc20f81 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PointedTypeComponent.lean @@ -0,0 +1,125 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativePeaks +import OAI.Topology.ArtinGroups.Harmonic.TypeComponent + +namespace OAI + +/-! Peaks and signs on connected components of a spherical closed type. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +lemma pointedProfile_positive_neighbor (P:Deligne M) (k:ℕ) (i:S) (hi:i∈P.val.1) + (j:S ⊕ Unit) (hij:framedCartan M (.inl i) j<0) + (hj:0 F.sup id) he + +lemma pointedTypeComponent_peak (P:Deligne M) (i:S) (hi:i∈P.val.1) + (j:S) (hj:j∈sourceTypeComponent M P i hi) : + relativePeak M f cutoff P j = relativePeak M f cutoff P i := by + obtain ⟨hj,h⟩ := hj + have hgen : ∀ a:P.val.1, Relation.ReflTransGen + (fun a b:P.val.1 => framedCartan M (.inl a.val) (.inl b.val)<0) ⟨i,hi⟩ a → + relativePeak M f cutoff P a = relativePeak M f cutoff P i := by + intro a ha + induction ha with + | refl => rfl + | @tail b c _ hbc ih => + exact (relativePeak_neighbor M f cutoff P c b c.property b.property + (by rwa [framedCartan_symm])).trans ih + exact hgen ⟨j,hj⟩ h + +lemma pointedTypeComponent_positive (P:Deligne M) (i:S) (hi:i∈P.val.1) (k:ℕ) + (hp:0 framedCartan M (.inl a.val) (.inl b.val)<0) ⟨i,hi⟩ a → + 0 exact hp + | @tail b c _ hbc ih => + exact pointedProfile_positive_neighbor M f cutoff P k c c.property (.inl b) + (by rwa [framedCartan_symm]) ih + exact hgen ⟨j,hj⟩ h + +lemma pointedTypeComponent_positiveComponent (P:Deligne M) (i:S) (hi:i∈P.val.1) (k:ℕ) + (hp:0 framedCartan M (.inl a.val) (.inl b.val)<0) ⟨i,hi⟩ a → + (.inl a.val:S ⊕ Unit) ∈ sourcePositiveComponent M (pointedProfile M f P cutoff k) (.inl i) := by + intro a ha + induction ha with + | refl => exact .refl + | @tail b c hb hbc ih => + exact ih.tail ⟨pointedTypeComponent_positive M f cutoff P i hi k hp b ⟨b.property,hb⟩, + hbc,pointedTypeComponent_positive M f cutoff P i hi k hp c ⟨c.property,hb.tail hbc⟩⟩ + exact hgen ⟨j,hj⟩ h + +omit [LinearOrder S] in +lemma relativePositiveSign_component_iff (p:ℕ →₀ (S ⊕ Unit → ℝ)) (k:ℕ) (i:S ⊕ Unit) + (hp:0

fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "diag" => coxeterFusionEdge_diag M +local notation "hm" => fusionLabelSize_ge_two M +local notation "Q" => fusionQuiver m d hd + +lemma pointedFamily_mul (g x : Artin M) (L : FusionLabel m) : + pointedFamily M f (g*x) L = sourceArtinAction M g (pointedFamily M f x L) := by + simp only [pointedFamily, pointedAction, map_mul, Equiv.Perm.mul_apply] + +lemma pointedMultiplicity_word (w : List (S × Bool)) (k : ℤ) : + pointedMultiplicity M f (sourceSignedWord M w) k = + fusionOrbitMultiplicity m d hd diag hm (sourcePacketWord w) (.inl f) k := by + unfold pointedMultiplicity + rw [pointedFamily_word, fusionFamilyMultiplicity_orbit] + +lemma pointedFamily_weighted_level (z : Artin M) (q : ℤ) + (α : FusionVertex (V := S ⊕ Unit) m) : + (∑ H, fusionWeight m H * (classLevelArray Q (pointedFamily M f z H) (α,q) : ℝ)) = + fusionWeight m α.2 * pointedMultiplicity M f z q α.1 := by + obtain ⟨w,rfl⟩ := sourceSignedWord_surjective M z + rw [pointedMultiplicity_word, pointedFamily_word] + have h := congrFun (fusionOrbitWeightedVector_eq m d hd diag hm (sourcePacketWord w) (.inl f) q) α + simpa only [fusionOrbitWeightedVector, Finset.sum_apply, Pi.smul_apply, smul_eq_mul, + fusionOrbitLayer_generator, fusionFold] using h + +lemma pointedMultiplicity_exterior_ordered (J : Set S) (g : Artin M) + (hg : g ∈ artinParabolic M J) (x : Artin M) (v : S ⊕ Unit) + (hv : v ∉ Sum.inl '' J) (k : ℤ) : + pointedMultiplicity M f (g*x) k v = pointedMultiplicity M f x k v := + pointedMultiplicity_exterior M J g hg f x v hv k + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveHeadProduct.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveHeadProduct.lean new file mode 100644 index 0000000000000000000000000000000000000000..d695c9c692983c50e770fff5fd0271028f11038f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveHeadProduct.lean @@ -0,0 +1,67 @@ +import OAI.Topology.ArtinGroups.Harmonic.PositivePrefixMulLeft +import OAI.Topology.ArtinGroups.Harmonic.PositiveDegreeSublevelFinite + +namespace OAI + +/-! The greedy head of a product with a simple left factor. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) + +/-- If `h` is the greatest simple prefix of `b`, the greatest simple prefix +of `a*b` is `a*g`, where `g` is the gcd of the complement of `a` and `h`. +This is the local normal-form step used in folding. -/ +theorem positive_head_product + (cancel : ∀ a b c : PositiveArtin M, a*b=a*c → b=c) + (z : M.Group) (hz : ∀ w, M.toCoxeterSystem.length w ≤ M.toCoxeterSystem.length z) + (a h g : M.Group) (b : PositiveArtin M) + (hh : PositivePrefix M (positiveSimpleLift M h) b) + (hhead : ∀ w, PositivePrefix M (positiveSimpleLift M w) b → + PositivePrefix M (positiveSimpleLift M w) (positiveSimpleLift M h)) + (hgc : PositivePrefix M (positiveSimpleLift M g) (positiveSimpleLift M (a⁻¹*z))) + (hgh : PositivePrefix M (positiveSimpleLift M g) (positiveSimpleLift M h)) + (hgreat : ∀ e, PositivePrefix M e (positiveSimpleLift M (a⁻¹*z)) → + PositivePrefix M e (positiveSimpleLift M h) → PositivePrefix M e (positiveSimpleLift M g)) : + ∃ k : M.Group, positiveSimpleLift M k=positiveSimpleLift M a*positiveSimpleLift M g ∧ + PositivePrefix M (positiveSimpleLift M k) (positiveSimpleLift M a*b) ∧ + ∀ w, PositivePrefix M (positiveSimpleLift M w) (positiveSimpleLift M a*b) → + PositivePrefix M (positiveSimpleLift M w) (positiveSimpleLift M k) := by + have complement := positiveSimpleLift_left_complement M z hz a + have hag : PositivePrefix M (positiveSimpleLift M a*positiveSimpleLift M g) + (positiveSimpleLift M z) := by + rw [←complement] + exact positivePrefix_mul_left M _ hgc + have hsimple := positivePrefix_of_simple_eq M hag rfl + refine ⟨positiveToCoxeter M (positiveSimpleLift M a*positiveSimpleLift M g), + hsimple.symm, ?_, ?_⟩ + · rw [←hsimple] + exact positivePrefix_mul_left M _ (positivePrefix_trans M hgh hh) + · intro w hw + rw [←hsimple] + have haZ : PositivePrefix M (positiveSimpleLift M a) (positiveSimpleLift M z) := + ⟨_, complement.symm⟩ + have hwZ : PositivePrefix M (positiveSimpleLift M w) (positiveSimpleLift M z) := + ⟨_, (positiveSimpleLift_left_complement M z hz w).symm⟩ + obtain ⟨c,hac,hwc,hc⟩ := positive_lcm_of_common_multiple M + (positive_greatest_common_left_divisor M cancel z hz) _ _ ⟨_,haZ,hwZ⟩ + have hcZ := hc _ haZ hwZ + have hcab := hc _ ⟨b,rfl⟩ hw + obtain ⟨e,he⟩ := hac + have hcSimple := positivePrefix_of_simple_eq M hcZ rfl + have heSimple := (positive_simple_factors M _ _ _ (he.symm.trans hcSimple)).2 + have heB : PositivePrefix M e b := + (positivePrefix_mul_left_iff M cancel _ _ _).mp (by rwa [←he]) + have heC : PositivePrefix M e (positiveSimpleLift M (a⁻¹*z)) := + (positivePrefix_mul_left_iff M cancel _ _ _).mp (by simpa only [←complement,he] using hcZ) + have heH : PositivePrefix M e (positiveSimpleLift M h) := by + rw [heSimple] at heB ⊢ + exact hhead _ heB + have heg := hgreat e heC heH + apply positivePrefix_trans M hwc + rw [he] + exact positivePrefix_mul_left M _ heg + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveSupport.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..fdc1cb71fabbd923ace78942600c3d69c2bf12a6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveSupport.lean @@ -0,0 +1,94 @@ +import OAI.Topology.ArtinGroups.Harmonic.PositiveDegreeHom + +namespace OAI + +/-! Support of an element of the actual positive Artin monoid. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable + +@[ext] structure SupportValue (S : Type) where + carrier : Set S + +instance {S : Type} : CommMonoid (SupportValue S) where + mul a b := ⟨a.carrier ∪ b.carrier⟩ + one := ⟨∅⟩ + mul_assoc a b c := by ext s; exact or_assoc + one_mul a := by ext s; change (False ∨ s ∈ a.carrier) ↔ s ∈ a.carrier; tauto + mul_one a := by ext s; change (s ∈ a.carrier ∨ False) ↔ s ∈ a.carrier; tauto + mul_comm a b := by ext s; exact or_comm + +private lemma supportValue_word {S : Type} (w : List S) (s : S) : + s ∈ ((w.map (fun t => (⟨{t}⟩ : SupportValue S))).prod).carrier ↔ s ∈ w := by + induction w with + | nil => change False ↔ s ∈ ([] : List S); simp + | cons t w ih => + change (s=t ∨ s ∈ ((w.map (fun t => (⟨{t}⟩ : SupportValue S))).prod).carrier) ↔ _ + rw [ih, List.mem_cons] + +private lemma altList_support {S : Type} (i j s : S) (n : ℕ) (hn : 2 ≤ n) : + s ∈ altList i j n ↔ s=i ∨ s=j := by + constructor + · exact mem_altList i j n s + · intro h + obtain ⟨k, rfl⟩ : ∃ k, n=k+2 := ⟨n-2, by omega⟩ + simp only [altList_succ, List.mem_cons] + exact h.elim Or.inl (fun hs => Or.inr (Or.inl hs)) + +variable {S : Type} (M : CoxeterMatrix S) + +private lemma support_relations : ∀ a b : FreeMonoid S, positiveBraidRelations M a b → + FreeMonoid.lift (fun s => (⟨{s}⟩ : SupportValue S)) a = + FreeMonoid.lift (fun s => (⟨{s}⟩ : SupportValue S)) b := by + rintro a b ⟨i,j,rfl,rfl⟩ + simp only [FreeMonoid.lift_ofList] + ext s + rw [supportValue_word, supportValue_word] + by_cases hij : i=j + · rw [hij] + by_cases hn : M i j=0 + · simp only [hn, altList_zero] + · have hge : 2 ≤ M i j := by have := M.off_diagonal i j hij; omega + rw [altList_support i j s _ hge, altList_support j i s _ hge, or_comm] + +noncomputable def positiveSupportHom : PositiveArtin M →* SupportValue S := + PresentedMonoid.lift (fun s => ⟨{s}⟩) (support_relations M) + +noncomputable def positiveSupport (a : PositiveArtin M) : Set S := + (positiveSupportHom M a).carrier + +@[simp] lemma positiveSupport_one : positiveSupport M 1 = ∅ := by + unfold positiveSupport + rw [map_one] + rfl + +@[simp] lemma positiveSupport_generator (s : S) : + positiveSupport M (positiveGenerator M s) = {s} := rfl + +@[simp] lemma positiveSupport_mul (a b : PositiveArtin M) : + positiveSupport M (a*b) = positiveSupport M a ∪ positiveSupport M b := by + unfold positiveSupport + rw [map_mul] + rfl + +@[simp] lemma positiveSupport_word (w : List S) : + positiveSupport M (wordPositive M w) = {s | s ∈ w} := by + ext s + induction w with + | nil => simp only [wordPositive, List.map_nil, List.prod_nil, positiveSupport_one, + Set.mem_empty_iff_false, Set.mem_ofPred_eq, List.not_mem_nil] + | cons t w ih => + change s ∈ positiveSupport M (positiveGenerator M t*wordPositive M w) ↔ _ + rw [positiveSupport_mul, Set.mem_union, positiveSupport_generator, Set.mem_singleton_iff, ih] + exact List.mem_cons.symm + +/-- Support inclusion gives a word using only the specified colors. -/ +theorem positiveSupport_word_exists (a : PositiveArtin M) (J : Set S) + (ha : positiveSupport M a ⊆ J) : + ∃ w : List S, wordPositive M w=a ∧ ∀ s ∈ w, s ∈ J := by + obtain ⟨w, rfl⟩ := positive_word_surjective M a + exact ⟨w, rfl, fun s hs => ha ((positiveSupport_word M w).symm ▸ hs)⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveTransport.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveTransport.lean new file mode 100644 index 0000000000000000000000000000000000000000..f9c622fcdedaa2ba0a8e24d0e3fb5a0dc931e7b3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/PositiveTransport.lean @@ -0,0 +1,77 @@ +import OAI.Topology.ArtinGroups.Cancellation.SphericalPositiveCancelLeft + +namespace OAI + +/-! Relabeling positive Artin monoids and finite-type cancellation. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable + +private lemma altList_map {S T : Type} (f : S → T) (i j : S) (n : ℕ) : + (altList i j n).map f = altList (f i) (f j) n := by + induction n generalizing i j with + | zero => rfl + | succ n ih => simp only [altList_succ, List.map_cons, ih] + +variable {S T : Type} (M : CoxeterMatrix S) (N : CoxeterMatrix T) + (f : S → T) (hf : ∀ i j, N (f i) (f j)=M i j) + +include hf in +private lemma positiveMap_relations : + ∀ a b : FreeMonoid S, positiveBraidRelations M a b → + FreeMonoid.lift (fun s => positiveGenerator N (f s)) a = + FreeMonoid.lift (fun s => positiveGenerator N (f s)) b := by + rintro a b ⟨i,j,rfl,rfl⟩ + simp only [FreeMonoid.lift_ofList] + have h := wordPositive_braid N (f i) (f j) + rw [hf] at h + have hm : wordPositive N ((altList i j (M i j)).map f) = + wordPositive N ((altList j i (M i j)).map f) := by + simpa only [altList_map] using h + simpa only [wordPositive,List.map_map,Function.comp_def] using hm + +noncomputable def positiveMap : PositiveArtin M →* PositiveArtin N := + PresentedMonoid.lift (fun s => positiveGenerator N (f s)) (positiveMap_relations M N f hf) + +@[simp] lemma positiveMap_generator (i : S) : + positiveMap M N f hf (positiveGenerator M i)=positiveGenerator N (f i) := rfl + +lemma positiveMap_word (w : List S) : + positiveMap M N f hf (wordPositive M w)=wordPositive N (w.map f) := by + simp only [wordPositive,map_list_prod,List.map_map,Function.comp_def,positiveMap_generator] + +lemma positiveMap_prefix {a b : PositiveArtin M} (h : PositivePrefix M a b) : + PositivePrefix N (positiveMap M N f hf a) (positiveMap M N f hf b) := by + obtain ⟨c,rfl⟩ := h + exact ⟨_,map_mul _ _ _⟩ + +/-- Cancellation in a finite Coxeter type, without an artificial subtype +of generators in the statement. -/ +theorem finite_positive_cancel_left [Fintype S] [LinearOrder S] [Finite M.Group] + (a b c : PositiveArtin M) (h : a*b=a*c) : b=c := by + let R := restrictedMatrix M Set.univ + let f : S → (Set.univ : Set S) := fun s => ⟨s,Set.mem_univ s⟩ + let up := positiveMap M R f (fun _ _ => rfl) + let down := positiveMap R M Subtype.val (fun _ _ => rfl) + have inverse : ∀ x, down (up x)=x := by + intro x + obtain ⟨w,rfl⟩ := positive_word_surjective M x + calc + down (up (wordPositive M w)) = down (wordPositive R (w.map f)) := + congrArg down (positiveMap_word M R f (fun _ _ => rfl) w) + _ = wordPositive M ((w.map f).map Subtype.val) := + positiveMap_word R M Subtype.val (fun _ _ => rfl) (w.map f) + _ = wordPositive M w := by + rw [List.map_map] + change wordPositive M (w.map id)=wordPositive M w + rw [List.map_id] + have hs : IsSpherical M Set.univ := by + change Finite (coxeterParabolic M Set.univ) + infer_instance + have he : up b=up c := spherical_positive_cancel_left M Set.univ hs (up a) (up b) (up c) + (by simpa only [←map_mul] using congrArg up h) + simpa only [inverse] using congrArg down he + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ProperParabolicMalnormal.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ProperParabolicMalnormal.lean new file mode 100644 index 0000000000000000000000000000000000000000..e4cb7a9907f9421abed50f6dd8729ce0b1f6ea7c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ProperParabolicMalnormal.lean @@ -0,0 +1,78 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeBridge +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeInvariantTranslate +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualParabolicSubtree +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualEdgeTransitive +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualFactorMalnormal + +namespace OAI + +/-! +# Weak malnormality of all proper parabolics + +This proves the implication needed from Charney--Martin--Morris-Wright, +*Acylindrical hyperbolicity for Artin groups with a visual splitting*, +Algebraic & Geometric Topology 26 (2026), Proposition 4.2, for the present +Artin groups. A proper parabolic preserves a proper convex subtree. Two +translates can be placed at the ends of a segment with trivial stabilizer. +Their common stabilizer fixes that segment, hence is trivial. +-/ +namespace HarmonicArtin.ParabolicIntersections +open TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance properParabolicAction : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out +include hSplit + +/-- The two conjugates have trivial intersection; this is stronger than +finiteness in the published weak-malnormality criterion. -/ +theorem standard_parabolic_trivial_conjugates (hIrred : IsIrreducible M) + (X : Set S) (hX : X≠Set.univ) : + ∃ a b : Artin M, + conjugate a (artinParabolic M X) ⊓ conjugate b (artinParabolic M X)=⊥ := by + let U := parabolicSubtree M Y Z X + have hU : PathClosed (visualGraph M Y Z) U := parabolicSubtree_pathClosed M Y Z X + obtain ⟨x,y,hxy,hx,hy⟩ := parabolicSubtree_boundary M Y Z hIrred X hX + obtain ⟨u,v,huv,hu,hv,hpair⟩ := visual_trivial_pair_distinct_type M Y Z hIrred x.1 + obtain ⟨p,hp⟩ := (visualGraph_isTree M Y Z).connected.exists_isPath u v + have hpn : ¬p.Nil := SimpleGraph.Walk.not_nil_of_ne huv + have hprn : ¬p.reverse.Nil := SimpleGraph.Walk.not_nil_of_ne huv.symm + obtain ⟨a,hax,hay⟩ := visual_oriented_edge_transitive M Y Z hxy + (p.adj_snd hpn) hu.symm + obtain ⟨b,hbx,hby⟩ := visual_oriented_edge_transitive M Y Z hxy + (p.reverse.adj_snd hprn) hv.symm + refine ⟨a,b,?_⟩ + apply le_antisymm _ bot_le + intro g hg + have haU : u∈(a • ·) '' U := ⟨x,hx,hax⟩ + have hbU : v∈(b • ·) '' U := ⟨x,hx,hbx⟩ + have hpa : p.snd∉(a • ·) '' U := not_mem_image_of_smul_eq hy hay + have hpb : p.reverse.snd∉(b • ·) '' U := not_mem_image_of_smul_eq hy hby + have hfix := fixes_bridge (visualGraph M Y Z) (visualGraph_isTree M Y Z) + (visual_preservesAdj M Y Z) + (pathClosed_smul _ (visual_preservesAdj M Y Z) hU a) + (pathClosed_smul _ (visual_preservesAdj M Y Z) hU b) + haU hbU p hp hpa hpb g + (fun w hw => conjugate_preserves_image (artinParabolic M X) U + (fun q hq z hz => parabolicSubtree_invariant M Y Z X hq hz) a hg.1 hw) + (fun w hw => conjugate_preserves_image (artinParabolic M X) U + (fun q hq z hz => parabolicSubtree_invariant M Y Z X hq hz) b hg.2 hw) + have hgpair : g∈pairStabilizer (G := Artin M) u v := hfix + rwa [hpair] at hgpair + +/-- Every proper parabolic of an irreducible visually split Artin group +is weakly malnormal, with no published hypotheses. -/ +theorem proper_parabolic_weaklyMalnormal (hIrred : IsIrreducible M) + (P : Subgroup (Artin M)) (hP : IsParabolic M P) (hne : P≠⊤) : WeaklyMalnormal P := by + obtain ⟨X,g,rfl⟩ := hP + have hX : X≠Set.univ := by + intro he + apply hne + rw [he,standard_univ,conjugate_top] + obtain ⟨a,b,hab⟩ := standard_parabolic_trivial_conjugates M Y Z hIrred X hX + exact (weaklyMalnormal_of_conjugates_inf_bot _ a b hab).conjugate_subgroup g + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ProperPositiveSupport.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ProperPositiveSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..65aa3443129cea9ed5d7cac370ed9543c6089da9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ProperPositiveSupport.lean @@ -0,0 +1,67 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PositiveSupport + +namespace OAI + +/-! The finite-family argument in Lemma 7.6 of paper 082-03. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) + +/-- Common positive extensions preserving a bound, together with the +absence of infinitely many complete passes, give one common proper +support for all permitted continuations of a suitable endpoint. -/ +theorem proper_positive_support + (cancel : ∀ a b c : PositiveArtin M, a*c=b*c → a=b) + (P : PositiveArtin M → Prop) (hOne : P 1) + (hcommon : ∀ F : Finset (PositiveArtin M), (∀ a ∈ F, P a) → + ∃ c, P c ∧ ∀ a ∈ F, ∃ q, c=q*a) + (hchain : ∀ a b : ℕ → PositiveArtin M, a 0=1 → (∀ n, P (a n)) → + (∀ n, a (n+1)=b n*a n) → (∀ n, positiveSupport M (b n)=Set.univ) → False) : + ∃ p, P p ∧ ∃ J : Set S, J ⊂ Set.univ ∧ + ∀ b, P (b*p) → positiveSupport M b ⊆ J := by + let U (p : PositiveArtin M) : Set S := {s | ∃ b, P (b*p) ∧ s ∈ positiveSupport M b} + by_contra hgoal + have hall (p : PositiveArtin M) (hp : P p) : U p=Set.univ := by + by_contra he + apply hgoal + refine ⟨p, hp, U p, lt_of_le_of_ne (Set.subset_univ _) he, ?_⟩ + exact fun b hb s hs => ⟨b, hb, hs⟩ + have hstep (p : PositiveArtin M) (hp : P p) : + ∃ c b, P c ∧ c=b*p ∧ positiveSupport M b=Set.univ := by + have hcover (s : S) : ∃ b, P (b*p) ∧ s ∈ positiveSupport M b := by + have hs : s ∈ U p := by rw [hall p hp]; trivial + exact hs + let b : S → PositiveArtin M := fun s => (hcover s).choose + have hb (s : S) : P (b s*p) ∧ s ∈ positiveSupport M (b s) := (hcover s).choose_spec + let F : Finset (PositiveArtin M) := insert p (Finset.univ.image (fun s => b s*p)) + obtain ⟨c, hc, hF⟩ := hcommon F (by + intro a ha + rcases Finset.mem_insert.mp ha with rfl | ha + · exact hp + · obtain ⟨s, _, rfl⟩ := Finset.mem_image.mp ha + exact (hb s).1) + obtain ⟨q, hq⟩ := hF p (Finset.mem_insert_self _ _) + refine ⟨c, q, hc, hq, Set.eq_univ_of_forall ?_⟩ + intro s + obtain ⟨d, hd⟩ := hF (b s*p) (Finset.mem_insert_of_mem + (Finset.mem_image.mpr ⟨s, Finset.mem_univ s, rfl⟩)) + have he : q=d*b s := cancel q (d*b s) p (hq.symm.trans (hd.trans (mul_assoc _ _ _).symm)) + rw [he, positiveSupport_mul] + exact Or.inr (hb s).2 + let next (p : {p : PositiveArtin M // P p}) : PositiveArtin M × PositiveArtin M := + ((hstep p.val p.property).choose, (hstep p.val p.property).choose_spec.choose) + have hnext (p : {p : PositiveArtin M // P p}) : P (next p).1 ∧ + (next p).1=(next p).2*p.val ∧ positiveSupport M (next p).2=Set.univ := + (hstep p.val p.property).choose_spec.choose_spec + let a : ℕ → {p : PositiveArtin M // P p} := + fun n => Nat.rec ⟨1,hOne⟩ (fun _ p => ⟨(next p).1, (hnext p).1⟩) n + apply hchain (fun n => (a n).val) (fun n => (next (a n)).2) rfl + (fun n => (a n).property) + · intro n + exact (hnext (a n)).2.1 + · intro n + exact (hnext (a n)).2.2 + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RankReduction.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RankReduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..4cff756e9caaf1ff2f8d7ef04f6d617c7834244c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RankReduction.lean @@ -0,0 +1,46 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.StabilizerDescent + +namespace OAI + +/-! Rank descent restricted to the subgroup of colors avoiding the frame. -/ +namespace HarmonicArtin.ParabolicIntersections +variable {S : Type*} [Finite S] (M : CoxeterMatrix S) +variable {V : Type*} [MulAction (Artin M) V] (v : V) + +/-- The induction keeps the transported point inside the prescribed orbit. +This permits the extra frame color in the relative diagram to remain fixed. -/ +theorem relativeStabilizers_of_reductions_on (U : Set S) + (hred : ∀ Y : Set S, Y ⊆ U → ∀ x : Artin M, x ∈ artinParabolic M U → + ReductionAt M v Y x) + (Y : Set S) (hYU : Y ⊆ U) (x : Artin M) (hx : x ∈ artinParabolic M U) : + ∃ (R : Set S) (c : Artin M), R ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + relativeStabilizer M v Y x = conjugate c⁻¹ (artinParabolic M R) := by + suffices h : ∀ n : ℕ, ∀ Y : Set S, Y.ncard = n → Y ⊆ U → + ∀ x : Artin M, x ∈ artinParabolic M U → + ∃ (R : Set S) (c : Artin M), R ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + relativeStabilizer M v Y x = conjugate c⁻¹ (artinParabolic M R) from h _ Y rfl hYU x hx + intro n + induction n using Nat.strong_induction_on with + | h n ih => + intro Y hY hYU x hx + rcases hred Y hYU x hx with hfixed | ⟨D,b,hD,hb,hcontain⟩ | ⟨T,K,hT,hK,hnorm,hsplit⟩ + · refine ⟨Y,1,Set.Subset.rfl,(artinParabolic M Y).one_mem,?_⟩ + simpa using hfixed + · have hlt : D.ncard < n := hY ▸ Set.ncard_lt_ncard hD + obtain ⟨R,c,hRD,hc,he⟩ := ih _ hlt D rfl (hD.subset.trans hYU) (b*x) + ((artinParabolic M U).mul_mem (standard_mono M hYU hb) hx) + have hconj := relativeStabilizer_conjugation M v Y D b x hD.subset hb hcontain + have heq := congrArg (conjugate b⁻¹) (hconj.trans he) + refine ⟨R,c*b,hRD.trans hD.subset, + (artinParabolic M Y).mul_mem (standard_mono M hD.subset hc) hb,?_⟩ + simpa only [← conjugate_mul,inv_mul_cancel,conjugate_one,mul_inv_rev] using heq + · have hlt : T.ncard < n := hY ▸ Set.ncard_lt_ncard hT + obtain ⟨R,c,hRT,hc,he⟩ := ih _ hlt T rfl (hT.subset.trans hYU) x hx + have hn := hnorm c⁻¹ ((artinParabolic M T).inv_mem hc) + refine ⟨K ∪ R,c,Set.union_subset hK (hRT.trans hT.subset), + standard_mono M hT.subset hc,?_⟩ + rw [hsplit,he,standard_union,conjugate_sup,hn] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedDynamicsMain.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedDynamicsMain.lean new file mode 100644 index 0000000000000000000000000000000000000000..223659b9851aec5fe5c1afb1596425587cf5baf3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedDynamicsMain.lean @@ -0,0 +1,85 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualAmalgamProperties +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsEquivalence + +namespace OAI + +/-! +# The remaining published geometric inputs + +The Artin-specific edge-intersection argument of CMMW Theorem 3.2 is now +proved locally. The following statements isolate the still-undischarged +inputs: the general amalgam criterion (Minasyan--Osin, *Acylindrical +hyperbolicity of groups acting on trees*, 2015, Corollary 2.2; stated as +CMMW 2026, Theorem 3.1), and CMMW 2026, Proposition 4.2. + +The first is stated for an arbitrary group explicitly isomorphic to a +nontrivial amalgam. The second transfers weak malnormality from the edge +group to all proper parabolics. Neither assumes the parabolic intersection +theorem or its new argument. The local proofs supply the actual amalgam, +injectivity, proper inclusions, exclusion of virtually cyclic groups, and +weak malnormality of the edge group. + +Sources: https://arxiv.org/abs/1310.6289 +https://msp.org/agt/2026/26-4/agt-v26-n4-p08-p.pdf +-/ +namespace HarmonicArtin.ParabolicIntersections + +/-- Minasyan--Osin's general nontrivial-amalgam criterion, with the +virtually cyclic alternative explicitly excluded. -/ +structure PublishedAmalgamCriterion : Prop where + criterion : ∀ (G : Type) [Group G] (A : Bool → Type) [∀ b, Group (A b)] + (C : Type) [Group C] (φ : ∀ b, C →* A b) (e : G ≃* Monoid.PushoutI φ), + (∀ b, Function.Injective (φ b)) → (∀ b, (φ b).range≠⊤) → + ¬Group.IsVirtuallyCyclic G → + WeaklyMalnormal ((Monoid.PushoutI.base φ).range.comap e.toMonoidHom) → + AcylindricallyHyperbolic G + +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- CMMW (2026), Proposition 4.2, stated separately from its edge criterion. -/ +structure PublishedProperParabolicCriterion : Prop where + criterion : IsIrreducible M → ∀ Y Z : Set S, IsVisualSplit M Y Z → + WeaklyMalnormal (artinParabolic M (Y∩Z)) → + ∀ P : Subgroup (Artin M), IsParabolic M P → P≠⊤ → WeaklyMalnormal P + +/-- Every hypothesis in the general amalgam criterion is supplied by +unconditional theorems for the actual Artin visual splitting. -/ +theorem visual_acylindricallyHyperbolic_of_amalgam (hMO : PublishedAmalgamCriterion) + (hIrred : IsIrreducible M) (Y Z : Set S) (hsplit : IsVisualSplit M Y Z) : + AcylindricallyHyperbolic (Artin M) := by + let : Fact (IsVisualSplit M Y Z) := ⟨hsplit⟩ + apply hMO.criterion (Artin M) (fun b => artinParabolic M (visualSide Y Z b)) + (artinParabolic M (Y∩Z)) (visualEdgeInclusion M Y Z) + (visualArtinEquiv M Y Z hsplit) + · intro b + exact Subgroup.inclusion_injective _ + · exact visual_edge_inclusion_proper M Y Z + · exact visual_not_virtuallyCyclic M Y Z + · change WeaklyMalnormal ((Monoid.PushoutI.base (visualEdgeInclusion M Y Z)).range.comap + (visualFromArtin M Y Z hsplit)) + rw [visual_edge_comap] + exact visual_edge_weaklyMalnormal M Y Z hIrred + +/-- Reconstruction of the original published input after discharging its +Artin-specific edge criterion. -/ +theorem visualSplitting_of_amalgam_and_proper (hMO : PublishedAmalgamCriterion) + (hProper : PublishedProperParabolicCriterion M) : PublishedVisualSplitting M where + edge_criterion hIrred Y Z hsplit _ := by + let : Fact (IsVisualSplit M Y Z) := ⟨hsplit⟩ + exact ⟨visual_acylindricallyHyperbolic_of_amalgam M hMO hIrred Y Z hsplit, + visual_edge_weaklyMalnormal M Y Z hIrred⟩ + proper_criterion := hProper.criterion + +/-- Paper 082-03, Corollary 1.3, with all algebraic and Artin-specific edge +arguments discharged. Only the two identified geometric inputs remain. -/ +theorem nonclique_dynamics_of_amalgam_and_proper (hMO : PublishedAmalgamCriterion) + (hProper : PublishedProperParabolicCriterion M) + (hIrred : IsIrreducible M) (hInf : ∃ s t : S, s≠t ∧ M s t=0) : + AcylindricallyHyperbolic (Artin M) ∧ + ∀ P : Subgroup (Artin M), IsParabolic M P → P≠⊤ → WeaklyMalnormal P := + nonclique_dynamics_of_visual_splitting M + (visualSplitting_of_amalgam_and_proper M hMO hProper) hIrred hInf + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedInputsMain.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedInputsMain.lean new file mode 100644 index 0000000000000000000000000000000000000000..927f65fb533efc6b6a95e6e0e0cfabc2a5c998a8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedInputsMain.lean @@ -0,0 +1,66 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ConditionalMain +import OAI.Topology.ArtinGroups.ParabolicIntersections.FoldingGcd + +namespace OAI + +/-! Main results after discharging the acyclic-twist and folding inputs. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- The remaining finite-type input is positive-degree mesh nilpotence. -/ +def PublishedMeshInput : Prop := + ∀ Y : Set S, IsSpherical M Y → + MeshNilpotent (fusionQuiver (fusionLabelSize M) (coxeterFusionEdge M) + (coxeterFusionEdge_symm M)) (fusionColorRegion (fusionLabelSize M) (Sum.inl '' Y)) + +theorem PublishedMeshInput.withAlgebra (h : PublishedMeshInput M) : + PublishedSphericalAlgebraInputs M where + mesh := h + folding := folding_gcd_input M + +local instance : LinearOrder (S⊕Unit) := Sum.Lex.linearOrder + +/-- Theorem 1.1 with both the acyclic and folding inputs discharged. -/ +theorem mesh_parabolic_intersections + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (X Y : Set S) (g h : Artin M) : + ∃ (Z : Set S) (k : Artin M), + conjugate g (artinParabolic M X) ⊓ conjugate h (artinParabolic M Y) = + conjugate k (artinParabolic M Z) := + main_parabolic_intersections M hEmb (fun X => (hMesh X).withAlgebra _) X Y g h + +/-- Corollary 1.2: every intersection is parabolic and is already a finite +intersection of at most the rank many members. -/ +theorem mesh_arbitrary_intersections + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (F : Set (Subgroup (Artin M))) (hF : ∀ P ∈ F, IsParabolic M P) : + (∃ F₀ : Finset (Subgroup (Artin M)), + (↑F₀ : Set (Subgroup (Artin M))) ⊆ F ∧ F₀.card ≤ Nat.card S ∧ + sInf F = sInf (↑F₀ : Set (Subgroup (Artin M)))) ∧ IsParabolic M (sInf F) := + main_arbitrary_intersections M hEmb (fun X => (hMesh X).withAlgebra _) F hF + +/-- Corollary 1.2: every subset has a unique smallest containing parabolic. -/ +theorem mesh_parabolic_closure + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (E : Set (Artin M)) : + ∃! P : Subgroup (Artin M), IsParabolic M P ∧ E ⊆ P ∧ + ∀ Q : Subgroup (Artin M), IsParabolic M Q → E ⊆ Q → P ≤ Q := + main_parabolic_closure M hEmb (fun X => (hMesh X).withAlgebra _) E + +/-- Corollary 1.3 with both categorical inputs discharged. -/ +theorem mesh_nonclique_dynamics + (hEmb : ∀ X : Set S, VanDerLekRelativeEmbedding M X) + (hMesh : ∀ X : Set S, PublishedMeshInput (relativeMatrix M X)) + (hVisual : PublishedVisualSplitting M) + (hIrred : IsIrreducible M) (hInf : ∃ s t : S, s ≠ t ∧ M s t=0) : + AcylindricallyHyperbolic (Artin M) ∧ + ∀ P : Subgroup (Artin M), IsParabolic M P → P ≠ ⊤ → WeaklyMalnormal P := + main_nonclique_dynamics M hEmb (fun X => (hMesh X).withAlgebra _) hVisual hIrred hInf + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedPositiveExtension.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedPositiveExtension.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce235868b832a690452dcc9ed9b812d10e56ace5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/ReducedPositiveExtension.lean @@ -0,0 +1,50 @@ +import OAI.Topology.ArtinGroups.Cancellation.SphericalPositiveCancelMonoid +import OAI.Topology.ArtinGroups.Harmonic.PositivePrefix + +namespace OAI + +/-! Cancelling common atoms in a spherical common left extension. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +omit [LinearOrder S] in +/-- The finite-type fraction theorem gives a common positive extension +whose two positive factors have no common left atom. Choosing the least +sum of positive lengths proves termination of the cancellation process. -/ +theorem spherical_reduced_positive_extension (Y : Set S) (hY : IsSpherical M Y) + (a b : Artin (restrictedMatrix M Y)) : + ∃ p q : PositiveArtin (restrictedMatrix M Y), + positiveToArtin _ p*a=positiveToArtin _ q*b ∧ + ∀ s : Y, ¬ (PositivePrefix _ (positiveGenerator _ s) p ∧ + PositivePrefix _ (positiveGenerator _ s) q) := by + let N := restrictedMatrix M Y + let f := positiveToArtin N + obtain ⟨p,q,hpq⟩ := (spherical_positive_monoid_fractions M Y hY (a*b⁻¹)).2 + have he : f p*a=f q*b := by + have h := congrArg (fun g : Artin N => f p*g*b) hpq + change f p*(a*b⁻¹)*b=f p*((f p)⁻¹*f q)*b at h + simpa only [mul_assoc, inv_mul_cancel_left, inv_mul_cancel_right, inv_mul_cancel, + mul_one, mul_inv_cancel_left] using h + let P (n : ℕ) := ∃ p q : PositiveArtin N, + f p*a=f q*b ∧ positiveDegree N p+positiveDegree N q=n + have hex : ∃ n, P n := ⟨_,p,q,he,rfl⟩ + obtain ⟨p,q,hpq,hlen⟩ := Nat.find_spec hex + refine ⟨p,q,hpq,?_⟩ + intro s hcommon + obtain ⟨p',hp'⟩ := hcommon.1 + obtain ⟨q',hq'⟩ := hcommon.2 + have heq : f p'*a=f q'*b := by + rw [hp',hq',map_mul,map_mul,mul_assoc,mul_assoc] at hpq + exact mul_left_cancel hpq + have hlt : positiveDegree N p'+positiveDegree N q' by rw [framedCartan_diag]; norm_num) U + (pointedProfile M f P cutoff) + (fun k i => pointedCosetVector_nonneg M f P (cutoff+k) i) + T (framed_spherical_posDef M P.val.1 P.property.1) + · intro k i hi + exact pointedCosetVector_harmonic M f P (cutoff+k) ⟨i,hi⟩ + · rintro i ⟨j,hj,rfl⟩ + exact hYU j (hj.elim (fun h => hPY h) (fun h => h.1)) + · rintro i ⟨j,(hj|hj),rfl⟩ + · exact Or.inl ⟨j,hj,rfl⟩ + · exact Or.inr hj.2.2 + let g : K → L := fun i => ⟨.inl (i:S),⟨i,i.property,rfl⟩⟩ + have hg : Function.Injective g := by + intro i j h + exact Subtype.ext (Sum.inl.inj (congrArg Subtype.val h)) + apply Geometric.spherical_of_cartan_posDef M K + convert hL.submatrix hg using 1 + ext i j + rfl + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeAllEligible.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeAllEligible.lean new file mode 100644 index 0000000000000000000000000000000000000000..d144f3e83377a1e24118566d83839156f6fc67ac --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeAllEligible.lean @@ -0,0 +1,41 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeLowerRetraction +import OAI.Topology.ArtinGroups.Realizations.NerveOrderRetractionEquiv + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open Simplicial CategoryTheory +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +abbrev RelativeAllEligibleLower (P:Deligne M) := + {Q:Deligne M // Q

h + +noncomputable def relativeAllEligibleProjection (P:Deligne M) : + RelativeDescendingLower M f U cutoff P →o RelativeAllEligibleLower M f U cutoff P where + toFun Q:=⟨relativeLowerClose M f U cutoff P Q,(relativeLowerClose_mem M f U cutoff Q.property.1 Q.property.2).1, + relativeLowerClose_all_eligible M f U cutoff Q.property.1.le⟩ + monotone':=fun _ R h=>relativeLowerClose_monotone M f U cutoff h R.property.1.le + +lemma relativeAllEligible_retract (P:Deligne M) : + (relativeAllEligibleProjection M f U cutoff P).comp (relativeAllEligibleInclusion M f U cutoff P)=OrderHom.id := by + apply OrderHom.ext + funext Q + apply Subtype.ext + exact relativeLowerClose_eq_of_all M f U cutoff Q.property.2 Q.property.1.le + +noncomputable def relativeEarlierLower_equiv_allEligible (P:Deligne M) : + ContinuousMap.HomotopyEquiv |nerve (RelativeDescendingLower M f U cutoff P)| |nerve (RelativeAllEligibleLower M f U cutoff P)| := + nerveOrderRetractionEquiv (relativeAllEligibleProjection M f U cutoff P) (relativeAllEligibleInclusion M f U cutoff P) + (relativeAllEligible_retract M f U cutoff P) (le_relativeLowerRetraction M f U cutoff P) + + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeDescending.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeDescending.lean new file mode 100644 index 0000000000000000000000000000000000000000..9457a3823b258ddf26ec0b9c6cc33a155dd77c7e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeDescending.lean @@ -0,0 +1,53 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeLowerConnected +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeUpperConnected + +namespace OAI + +/-! Combining upper and lower descending neighborhoods. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +lemma relativePathWithin_mono {V:Type} {adj:V→V→Prop} {p q:V→Prop} + (hpq:∀v,p v→q v) {a b:V} (h:PathWithin adj p a b) : PathWithin adj q a b := by + induction h with + | refl => exact .refl + | tail _ he ih => exact ih.tail ⟨hpq _ he.1,hpq _ he.2.1,he.2.2⟩ + +lemma relativePathWithin_single {V:Type} {adj:V→V→Prop} {p:V→Prop} + {a b:V} (ha:p a) (hb:p b) (h:adj a b) : PathWithin adj p a b := + Relation.ReflTransGen.single ⟨ha,hb,h⟩ + +omit [Fintype S] [LinearOrder S] in +lemma relative_vertex_avoids_frame {Y:Set S} {x:Artin M} + (hf:f∉Y) (hx:x∈artinParabolic M {f}ᶜ) (P:RelativeVertex M Y x) : + sourceCosetRepresentative M P.val∈artinParabolic M {f}ᶜ := by + have hg:=P.property.2 (sourceCosetRepresentative_mem M P.val) + have hY:Y⊆({f}ᶜ:Set S):=fun i hi he=>hf (he ▸ hi) + have hm:=(artinParabolic M {f}ᶜ).mul_mem (artinParabolic_mono M hY hg) hx + simpa only [_root_.mul_assoc,inv_mul_cancel,_root_.mul_one] using hm + +theorem relative_descending_connected {Y:Set S} {x:Artin M} (P:RelativeVertex M Y x) + (hYU:∀i∈Y,(.inl i:S⊕Unit)∈U) + (hU:U⊆Set.range (Sum.inl:S→S⊕Unit)) (hf:(.inl f:S⊕Unit)∉U) + (hxA:sourceCosetRepresentative M P.val∈artinParabolic M {f}ᶜ) + (A B:RelativeVertex M Y x) + (hA:relativeAdjacent M P A) (ha:relativeHeight M f U cutoff A.valrelativeHeight M f U cutoff V.val rcases hB with hB|hB + · exact relativePathWithin_mono (fun _ h=>h.2) + (relative_descending_upper_connected M f U cutoff Y x P hYU A B + ⟨lt_of_le_of_ne hA hneA,ha⟩ ⟨lt_of_le_of_ne hB hneB,hb⟩) + · exact relativePathWithin_single ha hb (Or.inr (hB.trans hA)) + · exact relativePathWithin_single ha hb (Or.inl (hA.trans hB)) + · exact relativePathWithin_mono (fun _ h=>h.2) + (relative_descending_lower_connected M f U cutoff P hU hf hxA A B + ⟨lt_of_le_of_ne hA (Ne.symm hneA),ha⟩ ⟨lt_of_le_of_ne hB (Ne.symm hneB),hb⟩) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeDiagram.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeDiagram.lean new file mode 100644 index 0000000000000000000000000000000000000000..0a3af20c6243c61662640352f0d6185fb5f870c9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeDiagram.lean @@ -0,0 +1,99 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.Basic + +namespace OAI + +/-! +# The relative diagram in §2.1 of paper 082-03 + +Adjoin the color `f`, with label 2 to the chosen standard type `X` and +label 3 to its complement. The existing fusion construction subsequently +adjoins the universal auxiliary color `o`. The map on Artin presentations +is constructed directly; no parabolic embedding theorem is assumed here. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +attribute [local instance] Classical.propDecidable + +variable {S : Type*} (M : CoxeterMatrix S) (X : Set S) + +noncomputable def relativeMatrix : CoxeterMatrix (S ⊕ Unit) := by + classical + exact { + M := fun a b => match a, b with + | .inl s, .inl t => M s t + | .inl s, .inr _ => if s ∈ X then 2 else 3 + | .inr _, .inl s => if s ∈ X then 2 else 3 + | .inr _, .inr _ => 1 + isSymm := by + apply Matrix.ext + intro a b + cases a <;> cases b <;> dsimp [Matrix.transpose] + exact M.symmetric _ _ + diagonal := by intro a; cases a <;> simp + off_diagonal := by + intro a b h + cases a with + | inl s => + cases b with + | inl t => exact M.off_diagonal s t (fun e => h (congrArg Sum.inl e)) + | inr u => dsimp; split_ifs <;> norm_num + | inr u => + cases b with + | inl t => dsimp; split_ifs <;> norm_num + | inr v => exact (h (by cases u; cases v; rfl)).elim } + +@[simp] theorem relativeMatrix_original (s t : S) : + relativeMatrix M X (.inl s) (.inl t) = M s t := rfl + +@[simp] theorem relativeMatrix_frame (s : S) : + relativeMatrix M X (.inl s) (.inr ()) = if s ∈ X then 2 else 3 := by + classical + rfl + +private theorem alternating_lift_inclusion (s t : S) (n : ℕ) : + FreeGroup.lift (fun s => generator (relativeMatrix M X) (.inl s)) + (alternating s t n) = + FreeGroup.lift (generator (relativeMatrix M X)) + (alternating (.inl s) (.inl t) n) := by + induction n generalizing s t with + | zero => simp [alternating] + | succ n ih => simp only [alternating, map_mul, FreeGroup.lift_apply_of, ih] + +private theorem relative_relators : ∀ r ∈ braidRelators M, + FreeGroup.lift (fun s => generator (relativeMatrix M X) (.inl s)) r = 1 := by + rintro r ⟨⟨s, t⟩, rfl⟩ + rw [map_mul, map_inv, alternating_lift_inclusion, alternating_lift_inclusion] + change FreeGroup.lift (PresentedGroup.of (rels := braidRelators (relativeMatrix M X))) + (alternating (.inl s) (.inl t) (M s t)) * + (FreeGroup.lift (PresentedGroup.of (rels := braidRelators (relativeMatrix M X))) + (alternating (.inl t) (.inl s) (M s t)))⁻¹ = 1 + rw [← map_inv, ← map_mul] + have hl : FreeGroup.lift (PresentedGroup.of (rels := braidRelators (relativeMatrix M X))) = + PresentedGroup.mk (braidRelators (relativeMatrix M X)) := by + apply FreeGroup.ext_hom + intro s + rfl + rw [hl] + exact PresentedGroup.one_of_mem ⟨(.inl s, .inl t), rfl⟩ + +/-- The canonical homomorphism into the Artin group of the relative diagram. -/ +noncomputable def relativeArtinHom : Artin M →* Artin (relativeMatrix M X) := + PresentedGroup.toGroup (relative_relators M X) + +@[simp] theorem relativeArtinHom_generator (s : S) : + relativeArtinHom M X (generator M s) = + generator (relativeMatrix M X) (.inl s) := + PresentedGroup.toGroup.of _ + +/-- Standard parabolics map onto the corresponding standard parabolics +of the extended diagram. Injectivity is not needed for this identity. -/ +theorem relativeArtinHom_parabolic (Y : Set S) : + (artinParabolic M Y).map (relativeArtinHom M X) = + artinParabolic (relativeMatrix M X) (Sum.inl '' Y) := by + simp only [artinParabolic, MonoidHom.map_closure, Set.image_image, + relativeArtinHom_generator] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligible.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligible.lean new file mode 100644 index 0000000000000000000000000000000000000000..efb3c92fdba1f17ed6efc4d72eb6670918b0a9b0 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligible.lean @@ -0,0 +1,121 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeLowerBasics + +namespace OAI + +/-! The eligible opened colors in a descending lower face. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +def RelativeEligible (P Q:Deligne M) (i:S) : Prop := + i∈P.val.1 ∧ i∉Q.val.1 ∧ + (∀d:ℕ,relativePeak M f cutoff P ih'.2 h) + have he:sourceCoset M (B∪C) hT x=P:=by + simpa only [hBC] using sourceCoset_eq M P x hx + have hh:=relativeEligibleProduct_contractible M f U cutoff P B C hT hd hc x h + rw [he] at hh + exact (weightHomeomorph (relativeEligiblePuncture M f U cutoff P)).contractibleSpace_iff.mp hh + +lemma relativeBlock_eligible_nonempty (P:Deligne M) (B:Set S) (hB:B⊆P.val.1) + (hc:∀s∈B,∀t∈P.val.1\B,M s t=2) (x:Artin M) (hx:x∈P.val.2) + (V:RelativeAllEligibleLower M f U cutoff P) (i:S) (hi:i∈B) (ho:i∉V.val.val.1) : + Nonempty {A:RelativeEligibleWithin M f U cutoff P + (sourceCoset M B (source_spherical_mono M hB P.property.1) x) //A≠⊤} := by + let C:=P.val.1\B + have hBC:B∪C=P.val.1:=Set.union_sdiff_cancel hB + have hT:IsSpherical M (B∪C):=by rw [hBC];exact P.property.1 + have hd:Disjoint B C:=Set.disjoint_left.mpr (fun _ h h'=>h'.2 h) + have he:sourceCoset M (B∪C) hT x=P:=by simpa only [hBC] using sourceCoset_eq M P x hx + let W:RelativeEligibleWithin M f U cutoff P (sourceCoset M (B∪C) hT x):= + ⟨V.val,by rw [he];exact ⟨V.property.1.le,V.property.2⟩⟩ + exact relativeEligible_left_nonempty M f U cutoff P B C hT hd hc x W i hi ho + +lemma pointedBlock_vector (P:Deligne M) (B:Set S) (hB:B⊆P.val.1) + (hc:∀s∈B,∀t∈P.val.1\B,M s t=2) (x:Artin M) (hx:x∈P.val.2) (q:ℤ) : + ∀i∈B,pointedCosetVector M f (sourceCoset M B (source_spherical_mono M hB P.property.1) x) q (.inl i)= + pointedCosetVector M f P q (.inl i) := by + have hBC:B∪(P.val.1\B)=P.val.1:=Set.union_sdiff_cancel hB + have hT:IsSpherical M (B∪(P.val.1\B)):=by rw [hBC];exact P.property.1 + have he:sourceCoset M (B∪(P.val.1\B)) hT x=P:=by simpa only [hBC] using sourceCoset_eq M P x hx + intro i hi + simpa only [he] using pointedCosetVector_block M f B (P.val.1\B) hT hc x q i hi + + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligibleFactor.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligibleFactor.lean new file mode 100644 index 0000000000000000000000000000000000000000..7c3520579e2885b6b2e80189cc6f2d4cef9e65dd --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligibleFactor.lean @@ -0,0 +1,91 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeEligibleWithin +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueAllowed +import OAI.Topology.ArtinGroups.Realizations.DeligneRankBound +import OAI.Topology.ArtinGroups.Harmonic.BinaryProductBoundary + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +lemma relativeEligible_factor_iff (P R V:Deligne M) (hRP:R.val.1⊆P.val.1) + (q:ℕ) (strict:Bool) (hp:∀i∈R.val.1,relativePeak M f cutoff P i=q) + (hs:∀i∈R.val.1,relativeSign M U (pointedProfile M f P cutoff) q (.inl i)=if strict then -1 else 1) + (hv:∀i∈R.val.1,pointedProfile M f R cutoff q (.inl i)=pointedProfile M f P cutoff q (.inl i)) + (i:S) (hi:i∈R.val.1) (ho:i∉V.val.1) : + RelativeEligible M f U cutoff P V i ↔ + (∀d:ℤ,cutoff+(q:ℤ) simp only [Bool.false_eq_true,↓reduceIte,Int.reduceNeg,Int.reduceEq,not_false_eq_true,true_and,and_true, + and_false,or_false] + constructor + · rintro ⟨ha,hb⟩ + exact ⟨ha,hb.elim le_of_lt le_of_eq⟩ + · rintro ⟨ha,hb⟩ + exact ⟨ha,lt_or_eq_of_le hb⟩ + +noncomputable def relativeEligibleFactor (P R:Deligne M) (hRP:R.val.1⊆P.val.1) + (q:ℕ) (strict:Bool) (hp:∀i∈R.val.1,relativePeak M f cutoff P i=q) + (hs:∀i∈R.val.1,relativeSign M U (pointedProfile M f P cutoff) q (.inl i)=if strict then -1 else 1) + (hv:∀i∈R.val.1,pointedProfile M f R cutoff q (.inl i)=pointedProfile M f P cutoff q (.inl i)) : + {V:RelativeEligibleWithin M f U cutoff P R // V≠⊤} ≃o PointedResidue M f strict R (cutoff+q) where + toFun V:=⟨V.val.val,lt_of_le_of_ne V.val.property.1 (fun he=>V.property (Subtype.ext he)), + fun i hi ho=>(relativeEligible_factor_iff M f U cutoff P R V.val.val hRP q strict hp hs hv i hi ho).mp + (V.val.property.2 i hi ho)⟩ + invFun V:=⟨⟨V.val,V.property.1.le,fun i hi ho=> + (relativeEligible_factor_iff M f U cutoff P R V.val hRP q strict hp hs hv i hi ho).mpr (V.property.2 i hi ho)⟩, + fun he=>V.property.1.ne (congrArg Subtype.val he)⟩ + left_inv _:=rfl + right_inv _:=rfl + map_rel_iff':=by intros;rfl + +noncomputable def relativeEligibleProductPuncture (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) : + BinaryProductBoundary + (RelativeEligibleWithin M f U cutoff Ref (sourceCoset M B (source_spherical_mono M Set.subset_union_left hT) x)) + (RelativeEligibleWithin M f U cutoff Ref (sourceCoset M C (source_spherical_mono M Set.subset_union_right hT) x)) ≃o + {V:RelativeEligibleWithin M f U cutoff Ref (sourceCoset M (B∪C) hT x) //V≠⊤} := + { toFun:=fun V=>⟨relativeEligibleProduct M f U cutoff Ref B C hT hd hc x V.val,by + intro he + exact V.property ((relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).injective + (he.trans (relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).map_top.symm))⟩ + invFun:=fun V=>⟨(relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).symm V.val,by + intro he + apply V.property + rw [←(relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).apply_symm_apply V.val,he, + (relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).map_top]⟩ + left_inv:=fun V=>Subtype.ext ((relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).symm_apply_apply V.val) + right_inv:=fun V=>Subtype.ext ((relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).apply_symm_apply V.val) + map_rel_iff':=by intros;exact (relativeEligibleProduct M f U cutoff Ref B C hT hd hc x).map_rel_iff } + +theorem relativeEligibleProduct_contractible (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) + (h:ContractibleSpace (OrderWeights + {V:RelativeEligibleWithin M f U cutoff Ref (sourceCoset M B (source_spherical_mono M Set.subset_union_left hT) x) //V≠⊤})) : + ContractibleSpace (OrderWeights {V:RelativeEligibleWithin M f U cutoff Ref (sourceCoset M (B∪C) hT x) //V≠⊤}) := by + let e:=relativeEligibleProductPuncture M f U cutoff Ref B C hT hd hc x + apply (weightHomeomorph e).contractibleSpace_iff.mp + apply binaryProductBoundary_contractible (fun V=>(e V).val.val.val.1.ncard) (Fintype.card S) + (fun V=>sourceDeligne_rank_bound M (e V).val.val) ?_ h + intro V W hVW + exact sourceDeligne_rank_strictMono M (e.strictMono hVW) + + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligibleWithin.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligibleWithin.lean new file mode 100644 index 0000000000000000000000000000000000000000..ffa743e81c39ccdde13d50161df509d2c2f224a9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEligibleWithin.lean @@ -0,0 +1,148 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeAllEligible +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetProduct + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open Simplicial CategoryTheory +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +abbrev RelativeEligibleWithin (P R:Deligne M) := + {Q:Deligne M // Q≤R ∧ ∀i∈R.val.1,i∉Q.val.1→RelativeEligible M f U cutoff P Q i} + +instance relativeEligibleWithinTop (P R:Deligne M) : OrderTop (RelativeEligibleWithin M f U cutoff P R) where + top:=⟨R,le_rfl,fun _ h hn=>(hn h).elim⟩ + le_top:=fun Q=>Q.property.1 + +lemma relativeEligibleProduct_left (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) + (A:SourceCosetBelow M B (source_spherical_mono M Set.subset_union_left hT) x × + SourceCosetBelow M C (source_spherical_mono M Set.subset_union_right hT) x) + (i:S) (hi:i∈B) : + RelativeEligible M f U cutoff Ref (sourceCosetProductFun M B C hT x A).val i ↔ RelativeEligible M f U cutoff Ref A.1.val i := by + have hn:i∉(sourceCosetProductFun M B C hT x A).val.val.1 ↔i∉A.1.val.val.1:=by + constructor + · exact fun h h'=>h (Or.inl h') + · intro h + rintro (h'|h') + · exact h h' + · exact Set.disjoint_left.mp hd hi (A.2.property.1 h') + by_cases ho:i∉A.1.val.val.1 + · have he (k:ℕ) : pointedProfile M f (sourceCosetProductFun M B C hT x A).val cutoff k (.inl i) = + pointedProfile M f A.1.val cutoff k (.inl i) := + pointedCosetProduct_open_left M f B C hT hd hc x A i hi ho (cutoff+k) + simp only [RelativeEligible,hn,he] + · constructor + · intro h;exact (ho (hn.mp h.2.1)).elim + · intro h;exact (ho h.2.1).elim + +lemma relativeEligibleProduct_right (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (x:Artin M) + (A:SourceCosetBelow M B (source_spherical_mono M Set.subset_union_left hT) x × + SourceCosetBelow M C (source_spherical_mono M Set.subset_union_right hT) x) + (i:S) (hi:i∈C) : + RelativeEligible M f U cutoff Ref (sourceCosetProductFun M B C hT x A).val i ↔ RelativeEligible M f U cutoff Ref A.2.val i := by + have hn:i∉(sourceCosetProductFun M B C hT x A).val.val.1 ↔i∉A.2.val.val.1:=by + constructor + · exact fun h h'=>h (Or.inr h') + · intro h + rintro (h'|h') + · exact Set.disjoint_left.mp hd (A.1.property.1 h') hi + · exact h h' + by_cases ho:i∉A.2.val.val.1 + · have he (k:ℕ) : pointedProfile M f (sourceCosetProductFun M B C hT x A).val cutoff k (.inl i) = + pointedProfile M f A.2.val cutoff k (.inl i) := + pointedCosetProduct_open_right M f B C hT hd x A i hi ho (cutoff+k) + simp only [RelativeEligible,hn,he] + · constructor + · intro h;exact (ho (hn.mp h.2.1)).elim + · intro h;exact (ho h.2.1).elim + +lemma relativeEligibleProduct_condition (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) + (A:SourceCosetBelow M B (source_spherical_mono M Set.subset_union_left hT) x × + SourceCosetBelow M C (source_spherical_mono M Set.subset_union_right hT) x) : + (∀i∈B∪C,i∉(sourceCosetProductFun M B C hT x A).val.val.1→ + RelativeEligible M f U cutoff Ref (sourceCosetProductFun M B C hT x A).val i) ↔ + (∀i∈B,i∉A.1.val.val.1→RelativeEligible M f U cutoff Ref A.1.val i) ∧ + (∀i∈C,i∉A.2.val.val.1→RelativeEligible M f U cutoff Ref A.2.val i) := by + constructor + · intro h + constructor + · intro i hi ho + apply (relativeEligibleProduct_left M f U cutoff Ref B C hT hd hc x A i hi).mp + apply h i (Or.inl hi) + rintro (ha|ha) + · exact ho ha + · exact Set.disjoint_left.mp hd hi (A.2.property.1 ha) + · intro i hi ho + apply (relativeEligibleProduct_right M f U cutoff Ref B C hT hd x A i hi).mp + apply h i (Or.inr hi) + rintro (ha|ha) + · exact Set.disjoint_left.mp hd (A.1.property.1 ha) hi + · exact ho ha + · rintro ⟨h,h'⟩ i (hi|hi) ho + · exact (relativeEligibleProduct_left M f U cutoff Ref B C hT hd hc x A i hi).mpr + (h i hi (fun hh=>ho (Or.inl hh))) + · exact (relativeEligibleProduct_right M f U cutoff Ref B C hT hd x A i hi).mpr + (h' i hi (fun hh=>ho (Or.inr hh))) + +noncomputable def relativeEligibleProductFun (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) + (A:RelativeEligibleWithin M f U cutoff Ref (sourceCoset M B (source_spherical_mono M Set.subset_union_left hT) x) × + RelativeEligibleWithin M f U cutoff Ref (sourceCoset M C (source_spherical_mono M Set.subset_union_right hT) x)) : + RelativeEligibleWithin M f U cutoff Ref (sourceCoset M (B∪C) hT x) := by + let a:SourceCosetBelow M B (source_spherical_mono M Set.subset_union_left hT) x:=⟨A.1.val,A.1.property.1⟩ + let b:SourceCosetBelow M C (source_spherical_mono M Set.subset_union_right hT) x:=⟨A.2.val,A.2.property.1⟩ + let p:=sourceCosetProductFun M B C hT x (a,b) + exact ⟨p.val,p.property,(relativeEligibleProduct_condition M f U cutoff Ref B C hT hd hc x (a,b)).mpr + ⟨A.1.property.2,A.2.property.2⟩⟩ + +lemma relativeEligibleProductFun_le_iff (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) + (A D:RelativeEligibleWithin M f U cutoff Ref (sourceCoset M B (source_spherical_mono M Set.subset_union_left hT) x) × + RelativeEligibleWithin M f U cutoff Ref (sourceCoset M C (source_spherical_mono M Set.subset_union_right hT) x)) : + relativeEligibleProductFun M f U cutoff Ref B C hT hd hc x A ≤ relativeEligibleProductFun M f U cutoff Ref B C hT hd hc x D ↔ A≤D := + sourceCosetProductFun_le_iff M B C hT hd hc x + (⟨A.1.val,A.1.property.1⟩,⟨A.2.val,A.2.property.1⟩) + (⟨D.1.val,D.1.property.1⟩,⟨D.2.val,D.2.property.1⟩) + +lemma relativeEligibleProductFun_surjective (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) : + Function.Surjective (relativeEligibleProductFun M f U cutoff Ref B C hT hd hc x) := by + intro D + obtain ⟨⟨a,b⟩,he⟩:=sourceCosetProductFun_surjective M B C hT hd hc x ⟨D.val,D.property.1⟩ + have hprop:∀i∈B∪C,i∉(sourceCosetProductFun M B C hT x (a,b)).val.val.1→ + RelativeEligible M f U cutoff Ref (sourceCosetProductFun M B C hT x (a,b)).val i:=by + rw [he] + exact D.property.2 + have hh:=(relativeEligibleProduct_condition M f U cutoff Ref B C hT hd hc x (a,b)).mp hprop + refine ⟨(⟨a.val,a.property,hh.1⟩,⟨b.val,b.property,hh.2⟩),?_⟩ + apply Subtype.ext + change (sourceCosetProductFun M B C hT x (a,b)).val=D.val + exact congrArg Subtype.val he + +noncomputable def relativeEligibleProduct (Ref:Deligne M) (B C:Set S) (hT:IsSpherical M (B∪C)) + (hd:Disjoint B C) (hc:∀s∈B,∀t∈C,M s t=2) (x:Artin M) : + (RelativeEligibleWithin M f U cutoff Ref (sourceCoset M B (source_spherical_mono M Set.subset_union_left hT) x) × + RelativeEligibleWithin M f U cutoff Ref (sourceCoset M C (source_spherical_mono M Set.subset_union_right hT) x)) ≃o + RelativeEligibleWithin M f U cutoff Ref (sourceCoset M (B∪C) hT x) := + OrderIso.ofSurjective + (OrderEmbedding.ofMapLEIff (relativeEligibleProductFun M f U cutoff Ref B C hT hd hc x) + (relativeEligibleProductFun_le_iff M f U cutoff Ref B C hT hd hc x)) + (relativeEligibleProductFun_surjective M f U cutoff Ref B C hT hd hc x) + +noncomputable def relativeEligiblePuncture (P:Deligne M) : + {Q:RelativeEligibleWithin M f U cutoff P P //Q≠⊤} ≃o RelativeAllEligibleLower M f U cutoff P where + toFun Q:=⟨Q.val.val,lt_of_le_of_ne Q.val.property.1 (fun he=>Q.property (Subtype.ext he)),Q.val.property.2⟩ + invFun Q:=⟨⟨Q.val,Q.property.1.le,Q.property.2⟩,by intro he;exact Q.property.1.ne (congrArg Subtype.val he)⟩ + left_inv _:=rfl + right_inv _:=rfl + map_rel_iff':=Iff.rfl + + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEmbedding.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..0b794bc6a1534c389041e6025114836783d24e81 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeEmbedding.lean @@ -0,0 +1,43 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.StandardEmbedding +import OAI.Topology.ArtinGroups.ParabolicIntersections.ArtinRelabel +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeInitialStabilizer + +namespace OAI + +/-! Discharge of the one-color standard embedding input. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (X : Set S) + +omit [LinearOrder S] in +/-- The relative extension includes the original Artin presentation injectively. -/ +theorem relative_embedding_input : VanDerLekRelativeEmbedding M X := by + let N := relativeMatrix M X + let T : Set (S⊕Unit) := Set.range Sum.inl + let e : S ≃ T := Equiv.ofInjective (Sum.inl : S → S⊕Unit) Sum.inl_injective + let R := restrictedMatrix N T + have hu : ∀ i j : S, R (e i) (e j)=M i j := fun _ _ => rfl + have hd : ∀ i j : T, M (e.symm i) (e.symm j)=R i j := by + intro i j + have hi : Sum.inl (e.symm i)=i.val := congrArg Subtype.val (e.apply_symm_apply i) + have hj : Sum.inl (e.symm j)=j.val := congrArg Subtype.val (e.apply_symm_apply j) + change M (e.symm i) (e.symm j)=N i.val j.val + rw [←hi,←hj] + rfl + let up := artinMap M R e hu + have hup : Function.Injective up := (artinMap_leftInverse M R e hu e.symm hd e.left_inv).injective + have hfactor : (restrictedArtinHom N T).comp up=relativeArtinHom M X := by + apply PresentedGroup.ext + intro s + change restrictedArtinHom N T (artinMap M R e hu (generator M s)) = + relativeArtinHom M X (generator M s) + rw [artinMap_generator,restrictedArtinHom_generator,relativeArtinHom_generator] + rfl + refine ⟨?_⟩ + rw [←hfactor] + exact (standardArtinEmbedding N T).comp hup + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeFamily.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..19547dc4f8b4c0fc3e89a53fbefad406f5436a73 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeFamily.lean @@ -0,0 +1,78 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeDiagram +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedFamily + +namespace OAI + +/-! +# The relative categorical family of paper 082-03 + +The family consists of actual bounded-projective homotopy classes in the +extended diagram. Its initial color is the new relative color `f`; the +auxiliary universal color is the one already adjoined by the fusion model. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (X : Set S) +local instance : LinearOrder (S ⊕ Unit) := Sum.Lex.linearOrder +local notation "N" => relativeMatrix M X + +abbrev RelativeLabel := PointedLabel N +abbrev RelativeClass := PointedClass N +abbrev RelativeFamilySpace := PointedFamilySpace N + +noncomputable def relativeAction : Artin M →* Equiv.Perm (RelativeClass M X) := + (pointedAction N).comp (relativeArtinHom M X) + +noncomputable def relativeInitial : RelativeFamilySpace M X := pointedInitial N (.inr ()) + +noncomputable def relativeFamily (x : Artin M) : RelativeFamilySpace M X := + fun L => relativeAction M X x (relativeInitial M X L) + +@[simp] theorem relativeFamily_one : relativeFamily M X 1 = relativeInitial M X := by + funext L + simp [relativeFamily] + +theorem relativeFamily_mul (g x : Artin M) (L : RelativeLabel M X) : + relativeFamily M X (g * x) L = relativeAction M X g (relativeFamily M X x L) := by + simp only [relativeFamily, map_mul, Equiv.Perm.mul_apply] + +/-- The easy inclusion in Proposition 8.3. -/ +theorem relative_generator_fixes_initial (s : S) (hs : s ∈ X) (L : RelativeLabel M X) : + relativeAction M X (generator M s) (relativeInitial M X L) = relativeInitial M X L := by + change pointedAction N (relativeArtinHom M X (generator M s)) + (pointedInitial N (.inr ()) L) = _ + rw [relativeArtinHom_generator] + exact pointed_generator_fixes_initial N (.inl s) (.inr ()) (by simp [hs]) L + +/-- Verified containment of the standard subgroup in the actual initial stabilizer. -/ +theorem standard_fixes_relativeInitial (g : Artin M) (hg : g ∈ artinParabolic M X) + (L : RelativeLabel M X) : + relativeAction M X g (relativeInitial M X L) = relativeInitial M X L := by + apply pointed_standard_fixes_initial N (Sum.inl '' X) (.inr ()) + · rintro _ ⟨s, hs, rfl⟩ + simp [hs] + · rw [← relativeArtinHom_parabolic] + exact ⟨g, hg, rfl⟩ + +noncomputable instance relativeFamilyMulAction : MulAction (Artin M) (RelativeFamilySpace M X) where + smul g F := fun L => relativeAction M X g (F L) + one_smul F := by + funext L + exact congrArg (fun p => p (F L)) (map_one (relativeAction M X)) + mul_smul g h F := by + funext L + exact congrArg (fun p => p (F L)) (map_mul (relativeAction M X) g h) + +@[simp] theorem relativeFamily_eq_smul (x : Artin M) : + relativeFamily M X x = x • relativeInitial M X := rfl + +theorem standard_le_relative_stabilizer : + artinParabolic M X ≤ MulAction.stabilizer (Artin M) (relativeInitial M X) := by + intro g hg + apply funext + exact standard_fixes_relativeInitial M X g hg + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeHeight.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeHeight.lean new file mode 100644 index 0000000000000000000000000000000000000000..369b38d347da7731c17f95c3547ff519f5395205 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeHeight.lean @@ -0,0 +1,166 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedProfile +import OAI.Topology.ArtinGroups.ParabolicIntersections.ActiveColors + +namespace OAI + +/-! +# The relative harmonic height + +The finite-support, highest-level-first height of §6.2 of paper 082-03. +The last coordinate is the full closed-type sign mask. The cutoff is an +arbitrary integer; null signs can occur at the cutoff itself. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + (U : Set (S ⊕ Unit)) (cutoff : ℤ) + +noncomputable def relativeSign (p : ℕ →₀ (S ⊕ Unit → ℝ)) (k : ℕ) (i : S ⊕ Unit) : ℤ := + if p k i = 0 then 0 else if relativePositiveSign (framedCartan M) U p k i then 1 else -1 + +noncomputable def relativeSignMask (P : Deligne M) (k : ℕ) (i : Lex (S ⊕ Unit)) : ℤ := + if ofLex i ∈ Sum.inl '' P.val.1 then + relativeSign M U (pointedProfile M f P cutoff) k (ofLex i) else 0 + +abbrev RelativeBlock (S : Type) := + Lex (ℝ × Lex (Lex (Lex (S ⊕ Unit) → ℝ) × Lex (Lex (S ⊕ Unit) → ℤ))) + +noncomputable def relativeBlock (P : Deligne M) (k : ℕ) : RelativeBlock S := + toLex (pointedCosetSum M f P (cutoff + k), + toLex (toLex (pointedProfile M f P cutoff k), toLex (relativeSignMask M f U cutoff P k))) + +def relativeZeroBlock : RelativeBlock S := toLex (0, toLex (toLex 0, toLex 0)) + +def RelativeBlockOccurs (b : RelativeBlock S) : Prop := + b = relativeZeroBlock (S := S) ∨ ∃ P : Deligne M, ∃ k : ℕ, b = relativeBlock M f U cutoff P k + +lemma relativeSignMask_bounds (P : Deligne M) (k : ℕ) (i : Lex (S ⊕ Unit)) : + relativeSignMask M f U cutoff P k i ∈ Set.Icc (-1 : ℤ) 1 := by + unfold relativeSignMask relativeSign + split_ifs <;> norm_num + +lemma relativeBlock_of_vector_zero (P : Deligne M) (k : ℕ) + (hz : pointedProfile M f P cutoff k = 0) : + relativeBlock M f U cutoff P k = relativeZeroBlock (S := S) := by + have hmask : relativeSignMask M f U cutoff P k = 0 := by + funext i + simp only [relativeSignMask, relativeSign, hz, Pi.zero_apply, ↓reduceIte, ite_self] + have hsum : pointedCosetSum M f P (cutoff + k) = 0 := by + change (∑ i, pointedProfile M f P cutoff k i) = 0 + simp only [hz, Pi.zero_apply, Finset.sum_const_zero] + simp only [relativeBlock, relativeZeroBlock, hz, hmask, hsum] + rfl + +lemma relativeZeroBlock_le (b : RelativeBlock S) (hb : RelativeBlockOccurs M f U cutoff b) : + relativeZeroBlock (S := S) ≤ b := by + rcases hb with rfl | ⟨P, k, rfl⟩ + · exact le_rfl + by_cases hz : pointedProfile M f P cutoff k = 0 + · rw [relativeBlock_of_vector_zero M f U cutoff P k hz] + · have hex : ∃ i, pointedProfile M f P cutoff k i ≠ 0 := by + by_contra hn + apply hz + funext i + exact not_not.mp (fun hi => hn ⟨i, hi⟩) + obtain ⟨i, hi⟩ := hex + have hp : 0 < pointedCosetSum M f P (cutoff + k) := + (lt_of_le_of_ne (pointedCosetVector_nonneg M f P (cutoff + k) i) (Ne.symm hi)).trans_le + (pointedCosetVector_le_sum M f P (cutoff + k) i) + exact (Prod.Lex.lt_iff.mpr (Or.inl hp)).le + +lemma relativeBlock_bounded_finite (B : ℝ) : + {b : RelativeBlock S | RelativeBlockOccurs M f U cutoff b ∧ (ofLex b).1 ≤ B}.Finite := by + let A := {p : S ⊕ Unit → ℝ | ∃ P : Deligne M, ∃ k : ℤ, + pointedCosetSum M f P k ≤ B ∧ p = pointedCosetVector M f P k} + let Z := {z : Lex (S ⊕ Unit) → ℤ | ∀ i, z i ∈ Set.Icc (-1 : ℤ) 1} + have hA : A.Finite := pointedCosetVector_bounded_finite M f B + have hZ : Z.Finite := Set.Finite.pi' (fun _ => Set.finite_Icc _ _) + let bfun : (S ⊕ Unit → ℝ) × (Lex (S ⊕ Unit) → ℤ) → RelativeBlock S := + fun v => toLex (∑ i, v.1 i, toLex (toLex v.1, toLex v.2)) + apply ((hA.prod hZ).image bfun |>.insert (relativeZeroBlock (S := S))).subset + rintro b ⟨(rfl | ⟨P, k, rfl⟩), hb⟩ + · exact Set.mem_insert _ _ + · apply Set.mem_insert_of_mem + refine ⟨(pointedCosetVector M f P (cutoff + k), relativeSignMask M f U cutoff P k), + ⟨⟨P, cutoff + k, hb, rfl⟩, fun i => relativeSignMask_bounds M f U cutoff P k i⟩, rfl⟩ + +lemma relativeBlock_predecessors_finite (b : RelativeBlock S) : + {a : RelativeBlock S | RelativeBlockOccurs M f U cutoff a ∧ a < b}.Finite := by + apply (relativeBlock_bounded_finite M f U cutoff (ofLex b).1).subset + intro a ha + exact ⟨ha.1, Prod.Lex.monotone_fst_ofLex ha.2.le⟩ + +noncomputable def relativeBlockRank (b : RelativeBlock S) : ℕ := + {a : RelativeBlock S | RelativeBlockOccurs M f U cutoff a ∧ a < b}.ncard + +lemma relativeBlockRank_strictMono {b c : RelativeBlock S} + (hb : RelativeBlockOccurs M f U cutoff b) (hbc : b < c) : + relativeBlockRank M f U cutoff b < relativeBlockRank M f U cutoff c := by + apply Set.ncard_lt_ncard _ (relativeBlock_predecessors_finite M f U cutoff c) + refine ⟨fun a ha => ⟨ha.1, ha.2.trans hbc⟩, ?_⟩ + intro h + exact (h ⟨hb, hbc⟩).2.false + +lemma relativeBlockRank_eq_iff {b c : RelativeBlock S} + (hb : RelativeBlockOccurs M f U cutoff b) (hc : RelativeBlockOccurs M f U cutoff c) : + relativeBlockRank M f U cutoff b = relativeBlockRank M f U cutoff c ↔ b = c := by + constructor + · intro he + rcases lt_trichotomy b c with h | h | h + · have := relativeBlockRank_strictMono M f U cutoff hb h + omega + · exact h + · have := relativeBlockRank_strictMono M f U cutoff hc h + omega + · exact congrArg _ + +lemma relativeBlockRank_lt_iff {b c : RelativeBlock S} + (hb : RelativeBlockOccurs M f U cutoff b) (hc : RelativeBlockOccurs M f U cutoff c) : + relativeBlockRank M f U cutoff b < relativeBlockRank M f U cutoff c ↔ b < c := by + constructor + · intro h + by_contra hn + rcases lt_or_eq_of_le (le_of_not_gt hn) with he | rfl + · exact Nat.lt_asymm h (relativeBlockRank_strictMono M f U cutoff hc he) + · exact h.false + · exact relativeBlockRank_strictMono M f U cutoff hb + +@[simp] lemma relativeBlockRank_zero : + relativeBlockRank M f U cutoff (relativeZeroBlock (S := S)) = 0 := by + have he : {a : RelativeBlock S | RelativeBlockOccurs M f U cutoff a ∧ + a < relativeZeroBlock (S := S)} = ∅ := by + ext a + simp only [Set.mem_ofPred_eq, Set.mem_empty_iff_false, iff_false, not_and] + intro ha + exact not_lt_of_ge (relativeZeroBlock_le M f U cutoff a ha) + simp only [relativeBlockRank, he, Set.ncard_empty] + +lemma relativeBlockRank_support_finite (P : Deligne M) : + {k : ℕ | relativeBlockRank M f U cutoff (relativeBlock M f U cutoff P k) ≠ 0}.Finite := by + apply (pointedProfile M f P cutoff).hasFiniteSupport.subset + intro k hk + change pointedProfile M f P cutoff k ≠ 0 + intro hz + apply hk + rw [relativeBlock_of_vector_zero M f U cutoff P k hz, relativeBlockRank_zero] + +noncomputable def relativeHeight (P : Deligne M) : Colex (ℕ →₀ ℕ) := + toColex (Finsupp.ofSupportFinite + (fun k => relativeBlockRank M f U cutoff (relativeBlock M f U cutoff P k)) + (relativeBlockRank_support_finite M f U cutoff P)) + +lemma relativeHeight_eq_blocks {P R : Deligne M} + (he : relativeHeight M f U cutoff P = relativeHeight M f U cutoff R) (k : ℕ) : + relativeBlock M f U cutoff P k = relativeBlock M f U cutoff R k := by + apply (relativeBlockRank_eq_iff M f U cutoff (Or.inr ⟨P, k, rfl⟩) (Or.inr ⟨R, k, rfl⟩)).mp + exact congrArg (fun h : Colex (ℕ →₀ ℕ) => ofColex h k) he + +theorem relativeHeight_wellFounded : + WellFounded (fun P R : Deligne M => relativeHeight M f U cutoff P < relativeHeight M f U cutoff R) := + InvImage.wf (relativeHeight M f U cutoff) wellFounded_lt + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeInitialStabilizer.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeInitialStabilizer.lean new file mode 100644 index 0000000000000000000000000000000000000000..bbb343771220436e784f2ce4e4d5eb0df962b6b8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeInitialStabilizer.lean @@ -0,0 +1,60 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedInitialStabilizer +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeFamily + +namespace OAI + +/-! +# The initial stabilizer in the relative diagram + +The sole input below is the unrestricted standard-parabolic embedding theorem: +van der Lek, *The Homotopy Type of Complex Hyperplane Complements* (1983), +Chapter II, §4, Theorem 4.13(i). See also Charney–Paris, *Convexity of parabolic +subgroups in Artin groups* (2014), §1, p. 2, https://arxiv.org/abs/1401.7634. +The exact case needed is injectivity of the canonical inclusion from the +original Artin presentation into the presentation with one additional color. +The categorical stabilizer identity is proved below, not assumed. +-/ +namespace HarmonicArtin.ParabolicIntersections +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (X:Set S) +local instance : LinearOrder (S⊕Unit) := Sum.Lex.linearOrder +local notation "N" => relativeMatrix M X +attribute [local instance] Classical.decEq Classical.propDecidable + +structure VanDerLekRelativeEmbedding : Prop where + injective : Function.Injective (relativeArtinHom M X) + +omit [Fintype S] [LinearOrder S] in +lemma relativeFrame_commuting_type : + {i:S⊕Unit | i∈Set.range (Sum.inl:S→S⊕Unit) ∧ N i (.inr ())=2} = Sum.inl '' X := by + ext i + cases i with + | inl s => + by_cases hs:s∈X <;> simp [relativeMatrix_frame,hs] + | inr u => simp + +/-- Proposition 8.3, conditional only on the published embedding input. -/ +theorem relative_initial_stabilizer (hEmb:VanDerLekRelativeEmbedding M X) : + MulAction.stabilizer (Artin M) (relativeInitial M X) = artinParabolic M X := by + apply le_antisymm + · intro a ha + have hfix:pointedFamily N (.inr ()) (relativeArtinHom M X a)=pointedFamily N (.inr ()) 1 := by + change a • relativeInitial M X=relativeInitial M X at ha + funext L + have h:=congrFun ha L + change pointedAction N (relativeArtinHom M X a) (pointedInitial N (.inr ()) L)=_ at h + simpa only [pointedFamily,map_one,Equiv.Perm.one_apply,relativeInitial] using h + have hmap:relativeArtinHom M X a∈artinParabolic N (Set.range (Sum.inl:S→S⊕Unit)):=by + have he:=relativeArtinHom_parabolic M X Set.univ + simp only [Set.image_univ] at he + rw [←he] + exact ⟨a,by rw [standard_univ];trivial,rfl⟩ + have hm:=pointed_initial_stabilizer_le N (.inr ()) (Set.range (Sum.inl:S→S⊕Unit)) + (by simp) (relativeArtinHom M X a) hmap hfix + rw [relativeFrame_commuting_type M X,←relativeArtinHom_parabolic M X X] at hm + obtain ⟨b,hb,he⟩:=hm + exact hEmb.injective he ▸ hb + · exact standard_le_relative_stabilizer M X + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeInvisibleFactor.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeInvisibleFactor.lean new file mode 100644 index 0000000000000000000000000000000000000000..0a2831b74e6b500b2089a293bbf7286419dfd01c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeInvisibleFactor.lean @@ -0,0 +1,143 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedBoundaryZero +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeMinimumContainment +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeTieLower +import OAI.Topology.ArtinGroups.ParabolicIntersections.FixedFactor + +namespace OAI + +/-! Removing the all-level invisible factor in the nonspherical case of §8. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + +/-- Every exterior count below the cutoff is zero. The cutoff is chosen +from the actual finite family, independently of the harmonic minimum. -/ +def ExteriorCutoff (Y : Set S) (x : Artin M) (cutoff : ℤ) : Prop := + ∀ k, k < cutoff → ∀ v, v ∉ Sum.inl '' Y → pointedMultiplicity M f x k v = 0 + +lemma exteriorCutoff_exists (Y : Set S) (x : Artin M) : + ∃ cutoff : ℤ, cutoff ≤ 0 ∧ ExteriorCutoff M f Y x cutoff := by + obtain ⟨b, hb⟩ := (pointedMultiplicity_support_finite M f x).bddBelow + refine ⟨min b 0, min_le_right _ _, ?_⟩ + intro k hk v _ + have hz : pointedMultiplicity M f x k = 0 := by + by_contra hn + have := hb hn + have := min_le_left b (0 : ℤ) + omega + exact congrFun hz v + +lemma relative_profile_exterior {Y : Set S} {x : Artin M} + (P : RelativeVertex M Y x) (cutoff : ℤ) (k : ℕ) (v : S ⊕ Unit) + (hv : v ∉ Sum.inl '' Y) : + pointedProfile M f P.val cutoff k v = pointedMultiplicity M f x (cutoff + k) v := by + let z := sourceCosetRepresentative M P.val + have hz : z ∈ rightCoset M Y x := P.property.2 (sourceCosetRepresentative_mem M P.val) + have hvP : v ∉ Sum.inl '' P.val.val.1 := fun h => hv (Set.image_mono P.property.1 h) + change pointedCosetVector M f P.val (cutoff+k) v = _ + rw [pointedCosetVector_eq M f P.val z (sourceCosetRepresentative_mem M P.val), + pointedHarmonicAt_outside M f _ _ _ _ hvP] + have he := pointedMultiplicity_exterior M Y (z*x⁻¹) hz f x v hv (cutoff+k) + simpa only [_root_.mul_assoc, inv_mul_cancel, _root_.mul_one] using he + +/-- If the containing type is the whole acting type, every exterior +neighbor of the invisible set is absent at every level. -/ +lemma relative_invisible_boundary_zero {Y : Set S} {x : Artin M} + (P : RelativeVertex M Y x) (cutoff : ℤ) (hcut : ExteriorCutoff M f Y x cutoff) + (hfull : relativeContainingType M f cutoff Y P.val = Y) : + ∀ k v, v ∉ Sum.inl '' relativeInvisible M f cutoff Y P.val → + (∃ u ∈ Sum.inl '' relativeInvisible M f cutoff Y P.val, framedCartan M v u < 0) → + pointedMultiplicity M f x k v = 0 := by + intro k v hv hn + obtain ⟨u, hu, hvi⟩ := hn + obtain ⟨i, hi, hei⟩ := hu + rw [← hei] at hvi + have hvY : v ∉ Sum.inl '' Y := by + rintro ⟨j, hj, rfl⟩ + have hjD : j ∈ relativeContainingType M f cutoff Y P.val := hfull.symm ▸ hj + rcases hjD with hjV | hjK + · rw [framedCartan_symm] at hvi + exact relativeVisible_nonadjacent M f cutoff Y P.val P.property.1 i j hi hjV hvi + · exact hv ⟨j, hjK, rfl⟩ + by_cases hk : k < cutoff + · exact hcut k hk v hvY + · let n := (k-cutoff).toNat + have he : cutoff + (n : ℤ) = k := by + dsimp only [n] + rw [Int.toNat_of_nonneg (by omega)] + omega + have hz : pointedProfile M f P.val cutoff n v = 0 := by + apply le_antisymm _ (pointedCosetVector_nonneg M f P.val (cutoff+n) v) + by_contra hn + have hp : 0 < pointedProfile M f P.val cutoff n v := lt_of_not_ge hn + apply hi.2 n + exact Or.inr ⟨v, by rwa [framedCartan_symm], hp⟩ + rwa [relative_profile_exterior M f P cutoff n v hvY, he] at hz + +/-- The entire invisible factor fixes the family, even below the cutoff. +This is the additional step after Proposition 6.9 in the proof of Theorem 8.2. -/ +theorem relative_invisible_factor_fixes {Y : Set S} {x : Artin M} + (hf : f ∉ Y) (hx : x ∈ artinParabolic M {f}ᶜ) + (P : RelativeVertex M Y x) (cutoff : ℤ) (hcut : ExteriorCutoff M f Y x cutoff) + (hfull : relativeContainingType M f cutoff Y P.val = Y) + (g : Artin M) (hg : g ∈ artinParabolic M (relativeInvisible M f cutoff Y P.val)) : + pointedFamily M f (g*x) = pointedFamily M f x := by + let K := relativeInvisible M f cutoff Y P.val + have hKf : f ∉ K := fun h => hf h.1 + have hbound := relative_invisible_boundary_zero M f P cutoff hcut hfull + have hint := pointed_boundary_zero_interior_zero M f x hx K hKf hbound + apply pointed_standard_fixes_of_closed_zero M f x K _ g hg + intro k v hv + rcases hv with hv | hn + · obtain ⟨i, hi, rfl⟩ := hv + exact hint k i hi + · by_cases hvK : v ∈ Sum.inl '' K + · obtain ⟨i, hi, rfl⟩ := hvK + exact hint k i hi + · exact hbound k v hvK hn + +/-- The nonspherical case is reduced to a proper containing type or to a +proper spherical visible factor; no new containment is assumed. -/ +theorem relative_nonspherical_reduction {Y : Set S} {x : Artin M} + (hf : f ∉ Y) (hx : x ∈ artinParabolic M {f}ᶜ) (hY : ¬IsSpherical M Y) : + ReductionAt M (pointedInitial M f) Y x := by + obtain ⟨cutoff, _, hcut⟩ := exteriorCutoff_exists M f Y x + let U := (Sum.inl : S → S ⊕ Unit) '' Y + obtain ⟨P, hP⟩ := relative_minimum_exists M f U cutoff (Y := Y) (x := x) + let D := relativeContainingType M f cutoff Y P.val + have hDY : D ⊆ Y := relative_containing_subset M f cutoff P + by_cases hD : D = Y + · let T := relativeVisible M f cutoff Y P.val + let K := relativeInvisible M f cutoff Y P.val + have hT : T ⊆ Y := fun _ hi => P.property.1 hi.1 + have hTs : IsSpherical M T := source_spherical_mono M Set.sdiff_subset P.val.property.1 + have hTproper : T ⊂ Y := lt_of_le_of_ne hT (by intro he; exact hY (he ▸ hTs)) + have hK : K ⊆ Y := fun _ hi => hi.1 + have hc : ∀ k ∈ K, ∀ t ∈ T, M k t = 2 := by + intro k hk t ht + rw [M.symmetric] + exact relativeVisible_commutes M f cutoff Y P.val P.property.1 t ht k hk + apply ReductionAt.split T K hTproper hK + · exact standard_factor_normalized M K T hc + · have he := relativeStabilizer_fixed_factor M (pointedInitial M f) K T x hc + (fun g hg => by + have h := relative_invisible_factor_fixes M f hf hx P cutoff hcut hD g hg + rw [← mul_smul] + exact h) + have hKT : K ∪ T = Y := (Set.union_comm K T).trans hD + rwa [hKT] at he + · apply ReductionAt.smaller D (sourceCosetRepresentative M P.val*x⁻¹) + (lt_of_le_of_ne hDY hD) + (P.property.2 (sourceCosetRepresentative_mem M P.val)) + intro a ha + exact relative_minimum_stabilizer_containment M f U cutoff + (fun i hi => ⟨i, hi, rfl⟩) (fun _ ⟨i, _, he⟩ => ⟨i, he⟩) + (by rintro ⟨i, hi, he⟩; exact hf (Sum.inl.inj he ▸ hi)) hx P hP a ha.1 (by + have h := ha.2 + change a • (x • pointedInitial M f) = x • pointedInitial M f at h + rw [← mul_smul] at h + exact h) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerBasics.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerBasics.lean new file mode 100644 index 0000000000000000000000000000000000000000..1b49de4a80696e1952bd5157b86d67d287fefc98 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerBasics.lean @@ -0,0 +1,104 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativePeaks +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeUpperComparison + +namespace OAI + +/-! The highest changed level on a lower edge, including invisible opened colors. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +lemma relativeLowerLevel_attained (P Q:Deligne M) + (hsome : ∃ i ∈ P.val.1, i ∉ Q.val.1 ∧ ∃ k, + 0 < pointedProfile M f P cutoff k (.inl i) ∨ + 0 < pointedProfile M f Q cutoff k (.inl i)) : + ∃ i ∈ P.val.1, i ∉ Q.val.1 ∧ + (0 < pointedProfile M f P cutoff (relativeLowerLevel M f cutoff P Q) (.inl i) ∨ + 0 < pointedProfile M f Q cutoff (relativeLowerLevel M f cutoff P Q) (.inl i)) := by + by_cases hz : relativeLowerLevel M f cutoff P Q = 0 + · obtain ⟨i,hi,hq,k,hk⟩ := hsome + have hb := relativePeak_le_lowerLevel M f cutoff P Q i hi hq + have hk0 : k = 0 := by + rcases hk with hk|hk + · exact Nat.eq_zero_of_le_zero (hz ▸ (relativePeak_bound M f cutoff P i k (ne_of_gt hk)).trans hb.1) + · exact Nat.eq_zero_of_le_zero (hz ▸ (relativePeak_bound M f cutoff Q i k (ne_of_gt hk)).trans hb.2) + exact ⟨i,hi,hq,by simpa only [hz,hk0] using hk⟩ + · obtain ⟨j,hj,hq,_⟩ := hsome + have hn : (P.val.1.toFinset \ Q.val.1.toFinset).Nonempty := ⟨j,by simp [hj,hq]⟩ + obtain ⟨i,hi,he⟩ := Finset.exists_mem_eq_sup _ hn + (fun i => max (relativePeak M f cutoff P i) (relativePeak M f cutoff Q i)) + have hip : i ∈ P.val.1 := Set.mem_toFinset.mp (Finset.mem_sdiff.mp hi).1 + have hiq : i ∉ Q.val.1 := fun hh => (Finset.mem_sdiff.mp hi).2 (Set.mem_toFinset.mpr hh) + refine ⟨i,hip,hiq,?_⟩ + change relativeLowerLevel M f cutoff P Q = _ at he + by_cases hle : relativePeak M f cutoff Q i ≤ relativePeak M f cutoff P i + · have hh := he.trans (max_eq_left hle) + have hp : 0 < relativePeak M f cutoff P i := Nat.pos_of_ne_zero (fun hh0 => hz (hh.trans hh0)) + rw [hh] + exact Or.inl (lt_of_le_of_ne (pointedCosetVector_nonneg M f P _ _) + (Ne.symm (relativePeak_nonzero_of_pos M f cutoff P i hp))) + · have hh := he.trans (max_eq_right (lt_of_not_ge hle).le) + have hp : 0 < relativePeak M f cutoff Q i := Nat.pos_of_ne_zero (fun hh0 => hz (hh.trans hh0)) + rw [hh] + exact Or.inr (lt_of_le_of_ne (pointedCosetVector_nonneg M f Q _ _) + (Ne.symm (relativePeak_nonzero_of_pos M f cutoff Q i hp))) + +lemma relativeBlock_eq_above_lower {P Q:Deligne M} (h:Q≤P) {k:ℕ} + (hk:relativeLowerLevel M f cutoff P Q relativeProfile_eq_above_lower M f cutoff h (hk.trans_le hd)) i + have hm : relativeSignMask M f U cutoff Q k = relativeSignMask M f U cutoff P k := by + funext i + unfold relativeSignMask + by_cases hq : ofLex i ∈ Sum.inl '' Q.val.1 + · simp only [hq,Set.image_mono h.1 hq,↓reduceIte,hs] + · by_cases hp : ofLex i ∈ Sum.inl '' P.val.1 + · obtain ⟨j,hj,he⟩ := hp + have hjq : j ∉ Q.val.1 := fun hh => hq ⟨j,hh,he⟩ + have hz := relativePeak_above M f cutoff P j + ((relativePeak_le_lowerLevel M f cutoff P Q j hj hjq).1.trans_lt hk) + have hsign : relativeSign M U (pointedProfile M f P cutoff) k (.inl j) = 0 := by + simp only [relativeSign,hz,↓reduceIte] + simp only [hs,←he,hsign,ite_self] + · simp only [hq,hp,↓reduceIte] + unfold relativeBlock + have hsum : pointedCosetSum M f Q (cutoff+k) = pointedCosetSum M f P (cutoff+k) := + congrArg (fun v:S ⊕ Unit → ℝ => ∑ i,v i) hv + rw [hsum,hv,hm] + +lemma relativeHeight_eq_of_opened_zero {P Q:Deligne M} (h:Q≤P) + (hz : ∀ i ∈ P.val.1, i ∉ Q.val.1 → ∀ k, + pointedProfile M f P cutoff k (.inl i) = 0 ∧ pointedProfile M f Q cutoff k (.inl i) = 0) : + relativeHeight M f U cutoff Q = relativeHeight M f U cutoff P := by + have hv (k:ℕ) : pointedProfile M f Q cutoff k = pointedProfile M f P cutoff k := + relativeProfile_eq_of_lower_open M f cutoff h k (fun i hi hq => (hz i hi hq k).2.trans (hz i hi hq k).1.symm) + apply relativeHeight_eq_of_blocks M f U cutoff + intro k + have hs (i:S ⊕ Unit) := relativeSign_congr_above M U _ _ k (fun d _ => hv d) i + have hm : relativeSignMask M f U cutoff Q k = relativeSignMask M f U cutoff P k := by + funext i + unfold relativeSignMask + rw [hs] + by_cases hq : ofLex i ∈ Sum.inl '' Q.val.1 + · simp only [hq,Set.image_mono h.1 hq,↓reduceIte] + · by_cases hp : ofLex i ∈ Sum.inl '' P.val.1 + · obtain ⟨j,hj,he⟩ := hp + have hjq : j ∉ Q.val.1 := fun hh => hq ⟨j,hh,he⟩ + have hsign : relativeSign M U (pointedProfile M f P cutoff) k (.inl j) = 0 := by + simp only [relativeSign,(hz j hj hjq k).1,↓reduceIte] + simp only [←he,hsign,ite_self] + · simp only [hq,hp,↓reduceIte] + unfold relativeBlock + have hsum : pointedCosetSum M f Q (cutoff+k) = pointedCosetSum M f P (cutoff+k) := + congrArg (fun v:S ⊕ Unit → ℝ => ∑ i,v i) (hv k) + rw [hsum,hv,hm] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerComparison.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerComparison.lean new file mode 100644 index 0000000000000000000000000000000000000000..c3574a7e81e1efddd08a0c470f7880df74d2969f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerComparison.lean @@ -0,0 +1,107 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeEligible + +namespace OAI + +/-! Strict lower-neighbor comparisons for the relative height. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +lemma relativeMasks_ne_of_open_sign {P Q:Deligne M} (i:S) (hi:i∈P.val.1) (hq:i∉Q.val.1) + (k:ℕ) (hs : relativeSign M U (pointedProfile M f P cutoff) k (.inl i) ≠ 0) : + relativeSignMask M f U cutoff Q k ≠ relativeSignMask M f U cutoff P k := by + intro heq + have hP : (.inl i:S ⊕ Unit) ∈ Sum.inl '' P.val.1 := ⟨i,hi,rfl⟩ + have hQ : (.inl i:S ⊕ Unit) ∉ Sum.inl '' Q.val.1 := by + rintro ⟨j,hj,he⟩ + exact hq (Sum.inl.inj he ▸ hj) + have hz := congrFun heq (toLex (.inl i)) + simp only [relativeSignMask,ofLex_toLex,hP,hQ,↓reduceIte] at hz + exact hs hz.symm + +lemma relativeLower_ineligible_le {P Q:Deligne M} (h:Q (relativeBlock_eq_above_lower M f U cutoff h.le hd).symm,?_⟩ + let H := relativeLowerLevel M f cutoff P Q + by_cases hv : pointedProfile M f Q cutoff H = pointedProfile M f P cutoff H + · have hsEq := relativeSign_eq_at_lower_tie M f U cutoff h.le hv + have hs (i:S) (hi:i∈P.val.1) (hq:i∉Q.val.1) : + relativeSign M U (pointedProfile M f P cutoff) H (.inl i) ≤ 0 := by + by_cases hz : pointedProfile M f P cutoff H (.inl i) = 0 + · simp only [relativeSign,hz,↓reduceIte,le_refl] + · have hp := lt_of_le_of_ne (pointedCosetVector_nonneg M f P (cutoff+H) (.inl i)) (Ne.symm hz) + have he : relativePeak M f cutoff P i = H := le_antisymm + (relativePeak_le_lowerLevel M f cutoff P Q i hi hq).1 + (relativePeak_bound M f cutoff P i H hz) + rw [relative_ineligible_tie_sign M f U cutoff i hi hq (ha i hi hq) he hv hp] + norm_num + have hm := relative_mask_upper_nonpos M f U cutoff h.le H + (fun i => (hsEq i).symm) (fun i hi hq => by rw [hsEq]; exact hs i hi hq) + obtain ⟨i,hi,hq,he,hp⟩ := relativeLowerLevel_prescribed_at_tie M f cutoff hsome hv + have hsign := relative_ineligible_tie_sign M f U cutoff i hi hq (ha i hi hq) he hv hp + have hn := relativeMasks_ne_of_open_sign M f U cutoff i hi hq H (by rw [hsign]; norm_num) + exact relativeBlock_lt_of_mask M f U cutoff hv.symm (lt_of_le_of_ne hm (Ne.symm hn)) + · exact Prod.Lex.lt_iff.mpr (Or.inl (harmonic_sum_lt_of_lt _ _ + (relativeProfile_lower_comparison M f cutoff h.le H (relative_ineligible_top_ge M f U cutoff ha)) + (Ne.symm hv))) + · have hz : ∀ i ∈ P.val.1, i ∉ Q.val.1 → ∀ k, + pointedProfile M f P cutoff k (.inl i) = 0 ∧ pointedProfile M f Q cutoff k (.inl i) = 0 := by + intro i hi hq k + constructor + · exact le_antisymm (le_of_not_gt (fun hp => hsome ⟨i,hi,hq,k,Or.inl hp⟩)) + (pointedCosetVector_nonneg M f P _ _) + · exact le_antisymm (le_of_not_gt (fun hp => hsome ⟨i,hi,hq,k,Or.inr hp⟩)) + (pointedCosetVector_nonneg M f Q _ _) + exact (relativeHeight_eq_of_opened_zero M f U cutoff h.le hz).symm.le + +/-- A descending lower face opens at least one eligible color. -/ +theorem relativeLower_descending_has_eligible {P Q:Deligne M} (h:Q hn ⟨i,hi⟩))) he + +/-- Opening only eligible colors strictly decreases height. -/ +theorem relativeLower_eligible_descending {P Q:Deligne M} (h:Q relativeBlock_eq_above_lower M f U cutoff h.le hd,?_⟩ + let H := relativeLowerLevel M f cutoff P Q + by_cases hv : pointedProfile M f Q cutoff H = pointedProfile M f P cutoff H + · have hsEq := relativeSign_eq_at_lower_tie M f U cutoff h.le hv + have hs (i:S) (hi:i∈P.val.1) (hq:i∉Q.val.1) : + 0 ≤ relativeSign M U (pointedProfile M f P cutoff) H (.inl i) := by + rcases eq_or_lt_of_le (relativePeak_le_lowerLevel M f cutoff P Q i hi hq).1 with he|he + · rw [relative_eligible_tie_sign M f U cutoff i (ha i hi hq) he hv] + norm_num + · have hz : pointedProfile M f P cutoff H (.inl i) = 0 := relativePeak_above M f cutoff P i he + simp only [relativeSign,hz,↓reduceIte,le_refl] + have hm := relative_mask_upper_nonneg M f U cutoff h.le H + (fun i => (hsEq i).symm) (fun i hi hq => by rw [hsEq]; exact hs i hi hq) + obtain ⟨i,hi,hq,he,_⟩ := relativeLowerLevel_prescribed_at_tie M f cutoff hsome hv + have hsign := relative_eligible_tie_sign M f U cutoff i (ha i hi hq) he hv + have hn := relativeMasks_ne_of_open_sign M f U cutoff i hi hq H (by rw [hsign]; norm_num) + exact relativeBlock_lt_of_mask M f U cutoff hv (lt_of_le_of_ne hm hn) + · exact Prod.Lex.lt_iff.mpr (Or.inl (harmonic_sum_lt_of_lt _ _ + (relativeProfile_lower_comparison_rev M f cutoff h.le H (relative_eligible_top_le M f U cutoff ha)) hv)) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerConnected.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerConnected.lean new file mode 100644 index 0000000000000000000000000000000000000000..43f738305be15c74c9bcd1a3e4528a11ba8e0565 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerConnected.lean @@ -0,0 +1,70 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeLowerContractible +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativePoset +import OAI.Topology.ArtinGroups.ParabolicIntersections.ConnectedMinima +import OAI.Topology.ArtinGroups.Realizations.WeightColor + +namespace OAI + +/-! Comparability paths in the descending lower neighborhood. -/ +namespace HarmonicArtin.ParabolicIntersections +open CategoryTheory Simplicial +attribute [local instance] Classical.decEq Classical.propDecidable + +lemma orderWeights_comparability_connected {V:Type} [PartialOrder V] + (h:ContractibleSpace (OrderWeights V)) (a b:V) : + Relation.ReflTransGen (fun x y:V => x≤y ∨ y≤x) a b := by + let s : Setoid V := + { r := Relation.ReflTransGen (fun x y:V => x≤y ∨ y≤x) + iseqv := + { refl := fun _ => .refl + symm := by + intro x y hp + induction hp with + | refl => exact .refl + | @tail z w hp edge ih => + exact (Relation.ReflTransGen.single (r:=fun x y:V => x≤y ∨ y≤x) + (edge.elim Or.inr Or.inl)).trans ih + trans := fun h₁ h₂ => h₁.trans h₂ } } + have he : Quotient.mk s a = Quotient.mk s b := + orderWeights_colors_eq h (Quotient.mk s) + (fun x y hxy => Quotient.sound (Relation.ReflTransGen.single (r:=fun x y:V => x≤y ∨ y≤x) + (Or.inl hxy))) a b + exact Quotient.exact he + +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +theorem relativeDescendingLower_contractible (P:Deligne M) + (hU:U⊆Set.range (Sum.inl:S→S⊕Unit)) (hf:(.inl f:S⊕Unit)∉U) + (hxA:sourceCosetRepresentative M P∈artinParabolic M {f}ᶜ) + (hne:Nonempty (RelativeDescendingLower M f U cutoff P)) : + ContractibleSpace (OrderWeights (RelativeDescendingLower M f U cutoff P)) := by + have he:=relativeEarlierLower_equiv_allEligible M f U cutoff P + have hc:ContractibleSpace |nerve (RelativeAllEligibleLower M f U cutoff P)|:= + nerveWeightsHomeomorph.contractibleSpace_iff.mpr + (relativeAllEligibleLower_contractible M f U cutoff P hU hf hxA + (Nonempty.map (relativeAllEligibleProjection M f U cutoff P) hne)) + exact nerveWeightsHomeomorph.contractibleSpace_iff.mp (he.contractibleSpace_iff.mpr hc) + +def RelativeStrictLower {Y:Set S} {x:Artin M} (P R:RelativeVertex M Y x) : Prop := + R

+ ⟨a.property,b.property,hab.elim Or.inl Or.inr⟩) A B hp + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerContractible.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerContractible.lean new file mode 100644 index 0000000000000000000000000000000000000000..655157e27d5bb8412c28d822f33a456144b34c78 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeLowerContractible.lean @@ -0,0 +1,116 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeEligibleBlocks +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeNullBlockData +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedSpecialResidue + +namespace OAI + +/-! Contractibility of nonempty descending lower neighborhoods of the relative height. -/ +namespace HarmonicArtin.ParabolicIntersections +open scoped _root_.Matrix _root_.OAI.Matrix +open CategoryTheory Simplicial ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +lemma relativeNegativeBlock_contractible (P:Deligne M) (i:S) (hi:i∈P.val.1) + (hp:0 hf (hn.1 h) + have hc:∀s∈B,∀t∈P.val.1\B,M s t=2:=by + intro s hs t ht + exact pointedPositiveBlock_commutes M f cutoff P q (.inl i) hp s t hs.1 hs.2 ht.1 + (fun h=>ht.2 ⟨ht.1,h⟩) + have hpeak:∀j∈B,relativePeak M f cutoff P j=q:=fun j hj=> + relativeNullSign_peak M f U cutoff P q (.inl i) hp hn j hj.1 hj.2 + have hsg:∀j∈B,relativeSign M U (pointedProfile M f P cutoff) q (.inl j)=if false then -1 else 1:= + fun j hj=>relativeNullSign_sign M f U cutoff P q (.inl i) hp hn (.inl j) hj.2 + let x:=sourceCosetRepresentative M P + have hx:=sourceCosetRepresentative_mem M P + let R:=sourceCoset M B (source_spherical_mono M hB P.property.1) x + let c:=relativeNullPatch M f cutoff P q (.inl i) + have hI:Sum.inl '' I=sourcePositiveComponent M (pointedProfile M f P cutoff q) (.inl i):= + relativeNullSign_image M f U cutoff P q (.inl i) hn hU + have hcSupp:∀v,v∉Sum.inl '' I→c v=0:=by + intro v hv + rw [hI] at hv + exact ite_eq_right hv + have hcPos:∀v,v∈Sum.inl '' I→0hi (h.1 hh) + have he(k:ℕ):pointedProfile M f Q cutoff k (.inl i)=pointedProfile M f R cutoff k (.inl i):= + (pointedCosetVector_upper_outside M f h (cutoff+k) (.inl i) (by + rintro ⟨j,hj,hh⟩; exact hi ((Sum.inl_injective hh) ▸ hj))).symm + simp only [RelativeEligible,he,hq,hi,not_false_eq_true,true_and] + +noncomputable def relativeLowerClose (P Q:Deligne M) : Deligne M := + sourceCoset M (P.val.1 \ relativeEligibleSet M f U cutoff P Q) + (source_spherical_mono M Set.sdiff_subset P.property.1) (sourceCosetRepresentative M Q) + +lemma le_relativeLowerClose {P Q:Deligne M} (h:Q≤P) : Q≤ relativeLowerClose M f U cutoff P Q := by + have he:=sourceCoset_eq M Q _ (sourceCosetRepresentative_mem M Q) + nth_rw 1 [←he] + exact sourceCoset_le M (show Q.val.1⊆P.val.1 \ relativeEligibleSet M f U cutoff P Q from + fun i hi=>⟨h.1 hi,fun he=>he.2.1 hi⟩) _ + +lemma relativeLowerClose_le {P Q:Deligne M} (h:Q≤P) : relativeLowerClose M f U cutoff P Q≤P := by + have he:=sourceCoset_eq M P _ (h.2 (sourceCosetRepresentative_mem M Q)) + calc + relativeLowerClose M f U cutoff P Q≤ sourceCoset M P.val.1 P.property.1 (sourceCosetRepresentative M Q):= + sourceCoset_le M Set.sdiff_subset _ + _=P:=he + +lemma relativeLowerClose_all_eligible {P Q:Deligne M} (h:Q≤P) : + ∀i∈P.val.1,i∉(relativeLowerClose M f U cutoff P Q).val.1→RelativeEligible M f U cutoff P (relativeLowerClose M f U cutoff P Q) i := by + intro i hi hn + have hh:RelativeEligible M f U cutoff P Q i:=by + by_contra he + exact hn ⟨hi,he⟩ + exact (relativeEligible_shared M f U cutoff (le_relativeLowerClose M f U cutoff h) i hn).mp hh + +lemma relativeLowerClose_mem {P Q:Deligne M} (h:QK.val.1) hh + have hm:i∈(relativeLowerClose M f U cutoff P Q).val.1:=by rw [ht]; exact hi.1 + exact hm.2 hi + exact ⟨hl,relativeLower_eligible_descending M f U cutoff hl (relativeLowerClose_all_eligible M f U cutoff h.le)⟩ + +lemma relativeLowerClose_monotone {P Q R:Deligne M} (h:Q≤R) (hr:R≤P) : + relativeLowerClose M f U cutoff P Q≤ relativeLowerClose M f U cutoff P R := by + have ht:P.val.1 \ relativeEligibleSet M f U cutoff P Q⊆P.val.1 \ relativeEligibleSet M f U cutoff P R:=by + intro i hi + refine ⟨hi.1,?_⟩ + intro hh + exact hi.2 ((relativeEligible_shared M f U cutoff h i hh.2.1).mpr hh) + have hx:(sourceCosetRepresentative M Q)∈(relativeLowerClose M f U cutoff P R).val.2:= + (le_relativeLowerClose M f U cutoff hr).2 (h.2 (sourceCosetRepresentative_mem M Q)) + have he:=sourceCoset_eq M (relativeLowerClose M f U cutoff P R) _ hx + rw [←he] + exact sourceCoset_le M ht _ + +noncomputable def relativeLowerRetraction (P:Deligne M) : + RelativeDescendingLower M f U cutoff P →o RelativeDescendingLower M f U cutoff P where + toFun Q:=⟨relativeLowerClose M f U cutoff P Q,relativeLowerClose_mem M f U cutoff Q.property.1 Q.property.2⟩ + monotone':=fun _ R h=>relativeLowerClose_monotone M f U cutoff h R.property.1.le + +lemma le_relativeLowerRetraction (P:Deligne M) (Q:RelativeDescendingLower M f U cutoff P) : + Q≤ relativeLowerRetraction M f U cutoff P Q := le_relativeLowerClose M f U cutoff Q.property.1.le + +lemma relativeLowerClose_eq_of_all {P Q:Deligne M} + (he:∀i∈P.val.1,i∉Q.val.1→RelativeEligible M f U cutoff P Q i) (h:Q≤P) : relativeLowerClose M f U cutoff P Q=Q := by + symm + apply deligne_eq_of_le_type_eq M (le_relativeLowerClose M f U cutoff h) + ext i + change i∈Q.val.1 ↔ i∈P.val.1 ∧ ¬RelativeEligible M f U cutoff P Q i + constructor + · intro hi + exact ⟨h.1 hi,fun hh=>hh.2.1 hi⟩ + · rintro ⟨hi,hn⟩ + by_contra hq + exact hn (he i hi hq) + +lemma relativeLowerRetraction_idem (P:Deligne M) (Q:RelativeDescendingLower M f U cutoff P) : + relativeLowerRetraction M f U cutoff P (relativeLowerRetraction M f U cutoff P Q)=relativeLowerRetraction M f U cutoff P Q := by + apply Subtype.ext + exact relativeLowerClose_eq_of_all M f U cutoff (relativeLowerClose_all_eligible M f U cutoff Q.property.1.le) + (relativeLowerClose_le M f U cutoff Q.property.1.le) + + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeMinimumContainment.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeMinimumContainment.lean new file mode 100644 index 0000000000000000000000000000000000000000..0323d6e18a6347780e4a2d46799ca2b774822f9b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeMinimumContainment.lean @@ -0,0 +1,96 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeTiedDescent +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeTranslation + +namespace OAI + +/-! Confinement of the actual categorical stabilizer from a harmonic minimum. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) {Y:Set S} {x:Artin M} + +def RelativeMinimum (P:RelativeVertex M Y x) : Prop := + ∀ V:RelativeVertex M Y x,relativeHeight M f U cutoff P.val≤relativeHeight M f U cutoff V.val + +noncomputable def relativeContainingType (Y:Set S) (P:Deligne M) : Set S := + relativeVisible M f cutoff Y P ∪ relativeInvisible M f cutoff Y P + +lemma relative_type_subset_containing (Y:Set S) (P:Deligne M) : + P.val.1⊆relativeContainingType M f cutoff Y P := by + intro i hi + by_cases hn:i∈relativeInvisible M f cutoff Y P + · exact Or.inr hn + · exact Or.inl ⟨hi,hn⟩ + +lemma relative_containing_subset (P:RelativeVertex M Y x) : + relativeContainingType M f cutoff Y P.val⊆Y := + fun _ hi=>hi.elim (fun h=>P.property.1 h.1) (fun h=>h.1) + +theorem relative_minimum_exists : ∃ P:RelativeVertex M Y x,RelativeMinimum M f U cutoff P := by + let P₀:=relativeElement M Y x x (rightCoset_self M Y x) + obtain ⟨h,⟨P,rfl⟩,hmin⟩:=wellFounded_lt.has_min + (Set.range (fun V:RelativeVertex M Y x=>relativeHeight M f U cutoff V.val)) + ⟨relativeHeight M f U cutoff P₀.val,P₀,rfl⟩ + exact ⟨P,fun V=>le_of_not_gt (hmin _ ⟨V,rfl⟩)⟩ + +lemma relative_minimum_path_confined {P Q:RelativeVertex M Y x} + (path:PathWithin (relativeAdjacent M) (RelativeMinimum M f U cutoff) P Q) : + relativeVisible M f cutoff Y Q.val=relativeVisible M f cutoff Y P.val ∧ + relativeInvisible M f cutoff Y Q.val=relativeInvisible M f cutoff Y P.val ∧ + Relation.ReflTransGen (fun A B:Deligne M=> + A.val.1⊆relativeContainingType M f cutoff Y P.val ∧ + B.val.1⊆relativeContainingType M f cutoff Y P.val ∧ (A≤B ∨ B≤A)) P.val Q.val := by + induction path with + | refl => exact ⟨rfl,rfl,.refl⟩ + | @tail A B path he ih => + have ht:relativeHeight M f U cutoff A.val=relativeHeight M f U cutoff B.val:= + le_antisymm (he.1 B) (he.2.1 A) + have hI:=relativeInvisible_eq_of_height_eq M f U cutoff Y ht + have hV:relativeVisible M f cutoff Y A.val=relativeVisible M f cutoff Y B.val:=by + rcases he.2.2 with hAB|hBA + · exact relativeVisible_eq_of_tie M f U cutoff Y hAB B.property.1 ht + · exact (relativeVisible_eq_of_tie M f U cutoff Y hBA A.property.1 ht.symm).symm + have hBV:=hV.symm.trans ih.1 + have hBI:=hI.symm.trans ih.2.1 + have hA:A.val.val.1⊆relativeContainingType M f cutoff Y P.val:=by + have h:=relative_type_subset_containing M f cutoff Y A.val + simpa only [relativeContainingType,ih.1,ih.2.1] using h + have hB:B.val.val.1⊆relativeContainingType M f cutoff Y P.val:=by + have h:=relative_type_subset_containing M f cutoff Y B.val + simpa only [relativeContainingType,hBV,hBI] using h + exact ⟨hBV,hBI,ih.2.2.tail ⟨hA,hB,he.2.2⟩⟩ + +/-- Proposition 6.9: the stabilizer lies in the conjugate standard subgroup +specified by the visible and invisible colors at a minimum. -/ +theorem relative_minimum_stabilizer_containment + (hYU:∀i∈Y,(.inl i:S⊕Unit)∈U) + (hU:U⊆Set.range (Sum.inl:S→S⊕Unit)) (hf:(.inl f:S⊕Unit)∉U) + (hx:x∈artinParabolic M {f}ᶜ) (P:RelativeVertex M Y x) + (hP:RelativeMinimum M f U cutoff P) + (a:Artin M) (ha:a∈artinParabolic M Y) + (hfix:pointedFamily M f (a*x)=pointedFamily M f x) : + a∈conjugate (sourceCosetRepresentative M P.val*x⁻¹)⁻¹ + (artinParabolic M (relativeContainingType M f cutoff Y P.val)) := by + let R:=relativeTranslate M Y x a ha P + have he:relativeHeight M f U cutoff R.val=relativeHeight M f U cutoff P.val:= + relativeHeight_translate_fixed M f U cutoff x a hfix P.val + have hR:RelativeMinimum M f U cutoff R:=fun V=>he.trans_le (hP V) + have hp:=relative_minimum_path M f U cutoff hYU hU hf hx P R hP hR + have hconf:=(relative_minimum_path_confined M f U cutoff hp).2.2 + let z:=sourceCosetRepresentative M P.val + let r:=x⁻¹*a*x + have hz:z*r∈R.val.val.2:=by + change z*r∈(deligneRightTranslate M P.val r).val.2 + apply (mem_deligneRightTranslate M P.val r (z*r)).mpr + simpa only [_root_.mul_assoc,mul_inv_cancel,_root_.mul_one] using sourceCosetRepresentative_mem M P.val + have hm:=conjugate_membership_of_coset_path M (relativeContainingType M f cutoff Y P.val) + z r (sourceCosetRepresentative_mem M P.val) + (relative_type_subset_containing M f cutoff Y P.val) hz hconf + rw [mem_conjugate,inv_inv] at hm ⊢ + convert hm using 1 + dsimp only [z,r] + group + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeNullBlockData.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeNullBlockData.lean new file mode 100644 index 0000000000000000000000000000000000000000..74aa334c8122dffb88f9e9c491c204d0469c627e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeNullBlockData.lean @@ -0,0 +1,191 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedBlockBoundary +import OAI.Topology.ArtinGroups.Harmonic.NullPatch2 + +namespace OAI + +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +omit [LinearOrder S] in +def RelativeNullData (p:ℕ →₀ (S ⊕ Unit → ℝ)) (q:ℕ) (i:S ⊕ Unit) : Prop := + sourcePositiveComponent M (p q) i ⊆ U ∧ + (∀ j ∈ sourcePositiveComponent M (p q) i, (framedCartan M *ᵥ p q) j=0) ∧ + ∀ j ∈ sourceClosedRegion M (sourcePositiveComponent M (p q) i), ∀ d, q pointedCosetVector_nonneg M f P (cutoff+q) v) i hi u hu + ⟨v,hv,by rwa [framedCartan_symm]⟩,MulZeroClass.mul_zero] + · have he:framedCartan M v u=0:=le_antisymm (framedCartan_off M v u + (by rintro rfl;exact hu hv)) (le_of_not_gt hh) + rw [he,MulZeroClass.zero_mul] + · exact hn.2.1 v hv + +lemma relativePositive_exterior (P:Deligne M) (q:ℕ) (i:S⊕Unit) + (hi:0 fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "diag" => coxeterFusionEdge_diag M +local notation "hm" => (fun e => le_trans (by norm_num) (fusionLabelSize_ge_four M e)) +local notation "Q" => fusionQuiver m d hd +local notation "O" => fusionPacketOrbit m d hd diag +local notation "μ" => fusionOrbitMultiplicity m d hd diag hm +local notation "C" => fusionFoldedCartan m d +local notation "aw" => sourceArtinAction M (K := ℂ) + +/-- Relative null-layer obstruction, with no restriction on the sign of +`q`. All the inputs concern concrete layer counts and spherical caps. -/ +theorem relative_null_layer (I J : Set S) (hI : I.Nonempty) + (hJI : J ⊆ I) (hJ : IsSpherical M J) + (z₀ : List ((S ⊕ Unit) × Bool)) (s : S ⊕ Unit) + (hs : s ∉ Sum.inl '' I) (hw : ∀ a ∈ z₀, a.1 ≠ s) (q : ℤ) + (c : S ⊕ Unit → ℝ) (hc : ∀ v, 0 ≤ c v) + (hcSupp : ∀ v, v ∉ Sum.inl '' I → c v = 0) + (hcPos : ∀ v, v ∈ Sum.inl '' I → 0 < c v) + (hcNull : ∀ v, v ∈ Sum.inl '' I → (C *ᵥ c) v = 0) + (hE : ∀ L, ClassCapOn Q (O z₀ s L) + (closedNeighborhood Q (fusionColorRegion m (Sum.inl '' I)) \ + fusionColorRegion m (Sum.inl '' J)) q) + (hdata : ∀ v, (v ∈ Sum.inl '' I ∧ v ∉ Sum.inl '' J) ∨ + (v ∉ Sum.inl '' I ∧ ∃ u ∈ Sum.inl '' I, C v u < 0) → μ z₀ s q v = c v) + (huniv : ∀ g ∈ artinParabolic M J, + (∀ L, ClassCapOn Q (aw g (O z₀ s L)) + (closedNeighborhood Q (fusionColorRegion m (Sum.inl '' I))) q) → + ∀ j : J, c (.inl (j : S)) < fusionFamilyMultiplicity m d hd hm + (fun L => aw g (O z₀ s L)) q (.inl (j : S))) : False := by + have hstrict : ∀ g ∈ artinParabolic M J, + (∀ L, ClassCapOn Q (aw g (O z₀ s L)) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q) → + ∀ j : J, c (.inl (j : S)) < fusionFamilyMultiplicity m d hd hm + (fun L => aw g (O z₀ s L)) q (.inl (j : S)) := by + intro g hg hcap + apply huniv g hg + intro L + apply source_cap_closed_of_cap_parts M I J hJI _ q (hcap L) + exact sourceArtinAction_cap_exterior M J g hg (O z₀ s L) _ + (fun _ h => h.2) q (hE L) + let D := isolatedDataOfCoset M I J hJI hJ z₀ s q c hc hcSupp hcPos hcNull hdata hstrict + obtain ⟨zcap, hzcap, hcap⟩ := sourceCosetOrbit_exists_cap M I J hJI hJ z₀ s q hE + obtain ⟨g, hg, hge⟩ := hzcap + obtain ⟨w, hwt, hwe⟩ := artinParabolic_signed_word M J g hg + let z := sourcePacketWord w ++ z₀ + have he (L : FusionLabel m) : O z s L = O zcap s L := by + rw [hge L, ← hwe] + exact sourcePacketOrbit_signedPrepend M w z₀ s L + have hz : D.valid z := by + refine ⟨g, hg, fun L => ?_⟩ + exact (he L).trans (hge L) + have hcz' (L : FusionLabel m) : ClassCapOn Q (O z s L) + (closedNeighborhood Q (fusionColorRegion m (Sum.inl '' I))) q := by + rw [he L] + exact hcap L + have hcz : D.capped z := hcz' + have hwz : ∀ a ∈ z, a.1 ≠ s := by + intro a ha + rcases List.mem_append.mp ha with ha | ha + · obtain ⟨b, hb, rfl⟩ := List.mem_map.mp ha + intro heq + exact hs ⟨b.1, hJI (hwt b hb), heq⟩ + · exact hw a ha + obtain ⟨i, hi⟩ := hI + have hipos : 0 < μ z s q (.inl i) := by + have hci := hcPos (.inl i) ⟨i, hi, rfl⟩ + by_cases hij : i ∈ J + · have h := D.strict z hz 1 (artinParabolic M J).one_mem + (by intro L; simpa only [map_one, Equiv.Perm.one_apply] using D.capJ z hcz L) ⟨i, hij⟩ + simp only [map_one, Equiv.Perm.one_apply, fusionFamilyMultiplicity_orbit] at h + exact lt_trans hci h + · have hiq := D.data z hz (.inl i) (Or.inl ⟨⟨i, hi, rfl⟩, by + rintro ⟨j, hj, hej⟩; exact hij (Sum.inl.inj hej ▸ hj)⟩) + change μ z s q (.inl i) = c (.inl i) at hiq + rw [hiq] + exact hci + obtain ⟨L, b, hb, _⟩ := orbit_generator_of_positive m d hd diag hm z s (.inl i) q hipos + have hbin : ((fusionOrbitModel m d hd diag z s L).complex.placement b).color.1 ∈ + Sum.inl '' I := hb.symm ▸ ⟨i, hi, rfl⟩ + obtain ⟨k, v, hk, hv, hinc, hp⟩ := orbit_boundary_below m d hd diag hm z s hwz + (Sum.inl '' I) hs q L b hbin + (fun H => ClassCapOn.mono Q (hcz' H) (by + rintro α ⟨_, a, ha, ht⟩ + exact Or.inr ⟨(Q).source a, ha, a, rfl, ht⟩)) + (by + intro v hv hinc + have hh := D.data z hz v (Or.inr ⟨hv, hinc⟩) + change μ z s q v = c v at hh + exact hh.trans (hcSupp v hv)) + have hvJ : v ∉ Sum.inl '' J := fun h => hv (Set.image_mono hJI h) + apply null_boundary_contradiction D k hk v hv hinc _ z hz hcz + intro z' hz' + have heq : μ z' s k v = μ z s k v := by + rw [sourceCosetOrbit_multiplicity_exterior M J z₀ s z' hz' v hvJ k, + sourceCosetOrbit_multiplicity_exterior M J z₀ s z hz v hvJ k] + change 0 < μ z' s k v + rw [heq] + exact hp + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativePeaks.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativePeaks.lean new file mode 100644 index 0000000000000000000000000000000000000000..a8ea701572c4cdb4873c743bc33e38f97aa99d3d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativePeaks.lean @@ -0,0 +1,125 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeUpperBasics + +namespace OAI + +/-! Last occupied levels and lower-edge harmonic comparisons for the pointed family. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) (cutoff:ℤ) + +noncomputable def relativePeakSupport (P:Deligne M) (i:S) : Finset ℕ := + (pointedProfile M f P cutoff).support.filter (fun k=>pointedProfile M f P cutoff k (.inl i)≠0) + +noncomputable def relativePeak (P:Deligne M) (i:S) : ℕ := + (relativePeakSupport M f cutoff P i).sup id + +lemma relativePeakSupport_mem (P:Deligne M) (i:S) (k:ℕ) : + k∈relativePeakSupport M f cutoff P i ↔ pointedProfile M f P cutoff k (.inl i)≠0 := by + unfold relativePeakSupport + rw [Finset.mem_filter, Finsupp.mem_support_iff] + constructor + · exact And.right + · intro h + exact ⟨fun he=>h (congrFun he (.inl i)),h⟩ + +lemma relativePeak_bound (P:Deligne M) (i:S) (k:ℕ) + (h:pointedProfile M f P cutoff k (.inl i)≠0) : k≤ relativePeak M f cutoff P i := + Finset.le_sup (f:=id) ((relativePeakSupport_mem M f cutoff P i k).mpr h) + +lemma relativePeak_above (P:Deligne M) (i:S) {k:ℕ} (h:relativePeak M f cutoff P imax (relativePeak M f cutoff P i) (relativePeak M f cutoff Q i)) + +lemma relativePeak_le_lowerLevel (P Q:Deligne M) (i:S) (hi:i∈P.val.1) (hq:i∉Q.val.1) : + relativePeak M f cutoff P i≤ relativeLowerLevel M f cutoff P Q ∧ relativePeak M f cutoff Q i≤ relativeLowerLevel M f cutoff P Q := by + have hh:=Finset.le_sup (f:=fun i=>max (relativePeak M f cutoff P i) (relativePeak M f cutoff Q i)) + (show i∈P.val.1.toFinset \ Q.val.1.toFinset by simp [hi,hq]) + exact ⟨(le_max_left _ _).trans hh,(le_max_right _ _).trans hh⟩ + +lemma relativeProfile_eq_of_lower_open {P Q:Deligne M} (h:Q≤P) (k:ℕ) + (ho:∀i∈P.val.1,i∉Q.val.1→pointedProfile M f Q cutoff k (.inl i)=pointedProfile M f P cutoff k (.inl i)) : + pointedProfile M f Q cutoff k=pointedProfile M f P cutoff k := by + have hext(i:S⊕Unit)(hi:i∉(Sum.inl:S→S⊕Unit) '' Q.val.1): + pointedProfile M f Q cutoff k i=pointedProfile M f P cutoff k i:=by + by_cases hp:i∈(Sum.inl:S→S⊕Unit) '' P.val.1 + · obtain ⟨j,hj,rfl⟩:=hp + exact ho j hj (fun hq=>hi ⟨j,hq,rfl⟩) + · exact (pointedCosetVector_upper_outside M f h (cutoff+k) i hp).symm + have hq:=harmonicExtension_unique (framedCartan M) ((Sum.inl:S→S⊕Unit) '' Q.val.1) + (framed_spherical_posDef M Q.val.1 Q.property.1) (pointedProfile M f P cutoff k) + (pointedProfile M f Q cutoff k) hext (pointedCosetVector_harmonic M f Q (cutoff+k)) + have hp:=harmonicExtension_unique (framedCartan M) ((Sum.inl:S→S⊕Unit) '' Q.val.1) + (framed_spherical_posDef M Q.val.1 Q.property.1) (pointedProfile M f P cutoff k) + (pointedProfile M f P cutoff k) (fun _ _=>rfl) + (fun i=>pointedCosetVector_harmonic M f P (cutoff+k) ⟨i,Set.image_mono h.1 i.property⟩) + exact hq.trans hp.symm + +lemma relativeProfile_lower_comparison {P Q:Deligne M} (h:Q≤P) (k:ℕ) + (ho:∀i∈P.val.1,i∉Q.val.1→pointedProfile M f P cutoff k (.inl i)≤ pointedProfile M f Q cutoff k (.inl i)) : + pointedProfile M f P cutoff k≤ pointedProfile M f Q cutoff k := by + apply harmonic_boundary_comparison (framedCartan M) ((Sum.inl:S→S⊕Unit) '' Q.val.1) + (framed_spherical_posDef M Q.val.1 Q.property.1) (framedCartan_off M) + (pointedProfile M f P cutoff k) (pointedProfile M f Q cutoff k) + (fun i=>pointedCosetVector_harmonic M f P (cutoff+k) ⟨i,Set.image_mono h.1 i.property⟩) + (pointedCosetVector_harmonic M f Q (cutoff+k)) + intro i hi + by_cases hp:i∈(Sum.inl:S→S⊕Unit) '' P.val.1 + · obtain ⟨j,hj,rfl⟩:=hp + exact ho j hj (fun hq=>hi ⟨j,hq,rfl⟩) + · exact (pointedCosetVector_upper_outside M f h (cutoff+k) i hp).le + +lemma relativeProfile_lower_comparison_rev {P Q:Deligne M} (h:Q≤P) (k:ℕ) + (ho:∀i∈P.val.1,i∉Q.val.1→pointedProfile M f Q cutoff k (.inl i)≤ pointedProfile M f P cutoff k (.inl i)) : + pointedProfile M f Q cutoff k≤ pointedProfile M f P cutoff k := by + apply harmonic_boundary_comparison (framedCartan M) ((Sum.inl:S→S⊕Unit) '' Q.val.1) + (framed_spherical_posDef M Q.val.1 Q.property.1) (framedCartan_off M) + (pointedProfile M f Q cutoff k) (pointedProfile M f P cutoff k) + (pointedCosetVector_harmonic M f Q (cutoff+k)) + (fun i=>pointedCosetVector_harmonic M f P (cutoff+k) ⟨i,Set.image_mono h.1 i.property⟩) + intro i hi + by_cases hp:i∈(Sum.inl:S→S⊕Unit) '' P.val.1 + · obtain ⟨j,hj,rfl⟩:=hp + exact ho j hj (fun hq=>hi ⟨j,hq,rfl⟩) + · exact (pointedCosetVector_upper_outside M f h (cutoff+k) i hp).symm.le + +lemma relativeProfile_eq_above_lower {P Q:Deligne M} (h:Q≤P) {k:ℕ} + (hk:relativeLowerLevel M f cutoff P Q exact .refl + | @tail A B h edge ih => + exact (Relation.ReflTransGen.single (r := relativeAdjacent M) (edge.elim Or.inr Or.inl)).trans ih + +lemma relative_generator_step (Y : Set S) (x z : Artin M) + (hz : z ∈ rightCoset M Y x) (s : S) (hs : s ∈ Y) : + RelativePath M (relativeElement M Y x z hz) + (relativeElement M Y x (generator M s*z) (by + change (generator M s*z)*x⁻¹ ∈ artinParabolic M Y + rw [_root_.mul_assoc] + exact (artinParabolic M Y).mul_mem (Subgroup.subset_closure ⟨s,hs,rfl⟩) hz)) := by + have hg : generator M s*z ∈ rightCoset M Y x := by + change (generator M s*z)*x⁻¹ ∈ artinParabolic M Y + rw [_root_.mul_assoc] + exact (artinParabolic M Y).mul_mem (Subgroup.subset_closure ⟨s,hs,rfl⟩) hz + let R := relativeVertex M Y {s} (spherical_singleton M s) + (Set.singleton_subset_iff.mpr hs) x z hz + have hzr : z ∈ R.val.val.2 := rightCoset_self M {s} z + have hgr : generator M s*z ∈ R.val.val.2 := by + change (generator M s*z)*z⁻¹ ∈ artinParabolic M {s} + simp only [_root_.mul_assoc, mul_inv_cancel, _root_.mul_one] + exact Subgroup.subset_closure ⟨s,rfl,rfl⟩ + exact (Relation.ReflTransGen.single (r := relativeAdjacent M) (Or.inl (relativeElement_le M Y x R z hzr))).tail + (Or.inr (relativeElement_le M Y x R _ hgr)) + +/-- Left multiplication by a word in the ambient standard subgroup gives +an explicit comparability path through rank-one cosets. -/ +lemma relative_element_connected (Y : Set S) (x g : Artin M) + (hg : g ∈ artinParabolic M Y) : + RelativePath M (relativeElement M Y x x (rightCoset_self M Y x)) + (relativeElement M Y x (g*x) (by + change (g*x)*x⁻¹ ∈ artinParabolic M Y + simpa only [_root_.mul_assoc, mul_inv_cancel, _root_.mul_one] using hg)) := by + induction hg using Subgroup.closure_induction_left with + | one => simpa only [_root_.one_mul] using (Relation.ReflTransGen.refl + (a := relativeElement M Y x x (rightCoset_self M Y x))) + | mul_left a ha g hg ih => + obtain ⟨s, hs, rfl⟩ := ha + have h := relative_generator_step M Y x (g*x) (by + change (g*x)*x⁻¹ ∈ artinParabolic M Y + simpa only [_root_.mul_assoc, mul_inv_cancel, _root_.mul_one] using (show g ∈ artinParabolic M Y from hg)) s hs + simpa only [_root_.mul_assoc] using ih.trans h + | inv_mul_cancel a ha g hg ih => + obtain ⟨s, hs, rfl⟩ := ha + have hg' : (generator M s)⁻¹*g ∈ artinParabolic M Y := + (artinParabolic M Y).mul_mem + ((artinParabolic M Y).inv_mem (Subgroup.subset_closure ⟨s,hs,rfl⟩)) hg + have h := relative_generator_step M Y x (((generator M s)⁻¹*g)*x) (by + change (((generator M s)⁻¹*g)*x)*x⁻¹ ∈ artinParabolic M Y + simpa only [_root_.mul_assoc, mul_inv_cancel, _root_.mul_one] using hg') s hs + have he : generator M s * (((generator M s)⁻¹*g)*x) = g*x := by group + simp only [he] at h + exact ih.trans (relativePath_symm M h) + +/-- The relative spherical-coset poset is connected, without assuming that +its ambient type is spherical. -/ +theorem relative_poset_connected (Y : Set S) (x : Artin M) + (P R : RelativeVertex M Y x) : RelativePath M P R := by + have base (P : RelativeVertex M Y x) : + RelativePath M (relativeElement M Y x x (rightCoset_self M Y x)) P := by + let z := sourceCosetRepresentative M P.val + have hz : z ∈ P.val.val.2 := sourceCosetRepresentative_mem M P.val + have hzx : z ∈ rightCoset M Y x := P.property.2 hz + have h := relative_element_connected M Y x (z*x⁻¹) hzx + have he : (z*x⁻¹)*x = z := by group + simp only [he] at h + exact h.tail (Or.inl (relativeElement_le M Y x P z hz)) + exact (relativePath_symm M (base P)).trans (base R) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTieLower.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTieLower.lean new file mode 100644 index 0000000000000000000000000000000000000000..dd207bbe0eb170f91b35f92386ef17204645b705 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTieLower.lean @@ -0,0 +1,133 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeLowerRetraction +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeTies +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedTypeComponent +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedCosetProduct + +namespace OAI + +/-! Transferring an eligible opening across a tied inclusion. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) + +lemma relativeProfiles_eq_of_tie {P Q:Deligne M} + (he:relativeHeight M f U cutoff P=relativeHeight M f U cutoff Q) : + pointedProfile M f P cutoff=pointedProfile M f Q cutoff := + Finsupp.ext (relativeHeight_eq_profiles M f U cutoff he) + +lemma relativePeak_eq_of_tie {P Q:Deligne M} + (he:relativeHeight M f U cutoff P=relativeHeight M f U cutoff Q) (i:S) : + relativePeak M f cutoff P i=relativePeak M f cutoff Q i := by + unfold relativePeak relativePeakSupport + rw [relativeProfiles_eq_of_tie M f U cutoff he] + +lemma relativeEligible_visible {P R:Deligne M} (Y:Set S) (_hP:P.val.1⊆Y) + {i:S} (hi:RelativeEligible M f U cutoff P R i) : + i∈relativeVisible M f cutoff Y P := by + refine ⟨hi.1,?_⟩ + intro hn + exact hn.2 (relativePeak M f cutoff P i) (Or.inl (relativeEligible_positive M f U cutoff hi)) + +lemma relativeVisible_commutes (Y:Set S) (P:Deligne M) (hP:P.val.1⊆Y) + (i:S) (hi:i∈relativeVisible M f cutoff Y P) (j:S) + (hj:j∈relativeInvisible M f cutoff Y P) : M i j=2 := by + by_contra hn + have hij:i≠j:=by rintro rfl;exact hi.2 hj + have hc:=framedCartan_neg_of_label_ne_two M i j hij hn + rw [framedCartan_symm] at hc + exact relativeVisible_nonadjacent M f cutoff Y P hP j i hj hi hc + +lemma relativeEligible_single_open (P R:Deligne M) (i:S) + (hi:RelativeEligible M f U cutoff P R i) (z:Artin M) (hz:z∈P.val.2) + (he:∀k:ℕ,pointedMultiplicity M f z (cutoff+k) (.inl i)=pointedProfile M f R cutoff k (.inl i)) : + ∃ Q:Deligne M,Q

hh.2 rfl + have hlt:Q + relativeVisible_commutes M f cutoff Y Q hQ s hs t ht.2 + have hiB:i∈B:=relativeEligible_visible M f U cutoff Y hQ hi + have hiP:i∈P.val.1:=by + have he:=relativeVisible_eq_of_tie M f U cutoff Y hPQ hQ htie + have hm:i∈relativeVisible M f cutoff Y P:=he ▸ hiB + exact hm.1 + let z:=sourceCosetRepresentative M P + let w:=sourceCosetRepresentative M R + have hz:z∈Q.val.2:=hPQ.2 (sourceCosetRepresentative_mem M P) + have hw:w∈Q.val.2:=hR.le.2 (sourceCosetRepresentative_mem M R) + have hg:w*z⁻¹∈artinParabolic M (B∪C):=by + rw [hBC] + rw [←sourceCoset_eq M Q z hz] at hw + exact hw + rw [←sourceParabolicProductMap_range M B C hc] at hg + obtain ⟨⟨b,c⟩,hbc⟩:=hg + have hmul:(b:Artin M)*c=w*z⁻¹:=hbc + have hew:w=(c:Artin M)*((b:Artin M)*z):=by + rw [←_root_.mul_assoc,←(sourceParabolics_commute M B C hc b c b.property c.property).eq,hmul] + group + have hbP:(b:Artin M)∈artinParabolic M P.val.1:=by + apply artinParabolic_mono M _ b.property + intro j hj + have he:=relativeVisible_eq_of_tie M f U cutoff Y hPQ hQ htie + exact (show j∈relativeVisible M f cutoff Y P from he ▸ hj).1 + have hbz:(b:Artin M)*z∈P.val.2:=by + rw [←sourceCoset_eq M P z (sourceCosetRepresentative_mem M P)] + change ((b:Artin M)*z)*z⁻¹∈artinParabolic M P.val.1 + simpa only [_root_.mul_assoc,mul_inv_cancel,_root_.mul_one] using hbP + have hiC:(.inl i:S⊕Unit)∉Sum.inl '' C:=by + rintro ⟨j,hj,hji⟩ + cases Sum.inl.inj hji + exact hiB.2 hj.2 + have heprof:=relativeProfiles_eq_of_tie M f U cutoff htie + have hielig:RelativeEligible M f U cutoff P R i:=by + refine ⟨hiP,hi.2.1,?_,?_⟩ + · simpa only [relativePeak_eq_of_tie M f U cutoff htie] using hi.2.2.1 + · simpa only [relativePeak_eq_of_tie M f U cutoff htie,heprof] using hi.2.2.2 + apply relativeEligible_single_open M f U cutoff P R i hielig ((b:Artin M)*z) hbz + intro k + have hv:=pointedCosetVector_open M f R i hi.2.1 w (sourceCosetRepresentative_mem M R) (cutoff+k) + change _=pointedCosetVector M f R (cutoff+k) (.inl i) + rw [hv,hew,pointedMultiplicity_exterior_ordered M f C c c.property _ _ hiC] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTiedDescent.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTiedDescent.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e87bdd5b7094e7b7ee246229572f2b81c229383 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTiedDescent.lean @@ -0,0 +1,108 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeDescending +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeTieLower + +namespace OAI + +/-! Compatibility of descending neighborhoods across equal-height inclusions. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) (f:S) + (U:Set (S ⊕ Unit)) (cutoff:ℤ) {Y:Set S} {x:Artin M} + +lemma relativeTie_active_common {P Q:RelativeVertex M Y x} (hPQ:P≤Q) + (he:relativeHeight M f U cutoff P.val=relativeHeight M f U cutoff Q.val) + (hYU:∀i∈Y,(.inl i:S⊕Unit)∈U) + (i:S) (hi:i∈Y) (hn:i∉P.val.val.1) (ha:relativeColorActive M f U cutoff P.val i) : + ∃ V:RelativeVertex M Y x, relativeAdjacent M P V ∧ relativeAdjacent M Q V ∧ + relativeHeight M f U cutoff V.valhn (hPQ.1 hiP)) hactP + · obtain ⟨V,hVP,hVh⟩:=relativeTie_lower_nonempty M f U cutoff Y hPQ Q.property.1 he A.val + (lt_of_le_of_ne hAQ (Ne.symm hne)) ha + let W:RelativeVertex M Y x:=⟨V,hVP.le.1.trans P.property.1,hVP.le.2.trans P.property.2⟩ + exact ⟨W,Or.inr hVP.le,Or.inr (hVP.le.trans hPQ),hVh⟩ + +lemma relativeTie_common_from_smaller {P Q:RelativeVertex M Y x} (hPQ:P≤Q) + (he:relativeHeight M f U cutoff P.val=relativeHeight M f U cutoff Q.val) + (hYU:∀i∈Y,(.inl i:S⊕Unit)∈U) + (A:RelativeVertex M Y x) (hA:relativeAdjacent M P A) + (ha:relativeHeight M f U cutoff A.valrelativeHeight M f U cutoff P.val) where + symmetric := fun h=>h.elim Or.inr Or.inl + descending := fun P A B hA ha hB hb=> + relative_descending_connected M f U cutoff P hYU hU hf + (relative_vertex_avoids_frame M f (fun hi=>hf (hYU f hi)) hx P) A B hA ha hB hb + tied := by + intro P Q hPQ he A hA ha + rcases hPQ with hPQ|hQP + · obtain ⟨V,hPV,hQV,hV⟩:=relativeTie_common_from_smaller M f U cutoff hPQ he hYU A hA ha + exact ⟨V,hQV,hV.trans_eq he, + relative_descending_connected M f U cutoff P hYU hU hf + (relative_vertex_avoids_frame M f (fun hi=>hf (hYU f hi)) hx P) A V hA ha hPV hV⟩ + · obtain ⟨V,hQV,hPV,hV⟩:=relativeTie_common_from_larger M f U cutoff hQP he.symm hYU A hA ha + have hVP:relativeHeight M f U cutoff V.valhf (hYU f hi)) hx P) A V hA ha hPV hVP⟩ + +theorem relative_minimum_path + (hYU:∀i∈Y,(.inl i:S⊕Unit)∈U) + (hU:U⊆Set.range (Sum.inl:S→S⊕Unit)) (hf:(.inl f:S⊕Unit)∉U) + (hx:x∈artinParabolic M {f}ᶜ) + (P Q:RelativeVertex M Y x) + (hP:∀V:RelativeVertex M Y x,relativeHeight M f U cutoff P.val≤relativeHeight M f U cutoff V.val) + (hQ:∀V:RelativeVertex M Y x,relativeHeight M f U cutoff Q.val≤relativeHeight M f U cutoff V.val) : + PathWithin (relativeAdjacent M) + (fun P=>∀V:RelativeVertex M Y x,relativeHeight M f U cutoff P.val≤relativeHeight M f U cutoff V.val) P Q := + minimum_path _ _ (relative_localDescent M f U cutoff hYU hU hf hx) wellFounded_lt hP hQ + (relative_poset_connected M Y x P Q) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTies.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTies.lean new file mode 100644 index 0000000000000000000000000000000000000000..c68a19238cde93d96d63ebaac17245b403c00458 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTies.lean @@ -0,0 +1,124 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeHeight + +namespace OAI + +/-! Visible and invisible sets along tied comparable vertices, §6.5 of paper 082-03. -/ + +namespace HarmonicArtin.ParabolicIntersections + +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + (U : Set (S ⊕ Unit)) (cutoff : ℤ) + +omit [LinearOrder S] in +lemma relativeSign_eq_zero_iff (p : ℕ →₀ (S ⊕ Unit → ℝ)) (k : ℕ) (i : S ⊕ Unit) : + relativeSign M U p k i = 0 ↔ p k i = 0 := by + unfold relativeSign + split_ifs <;> simp_all + +lemma relativeHeight_eq_profiles {P R : Deligne M} + (he : relativeHeight M f U cutoff P = relativeHeight M f U cutoff R) (k : ℕ) : + pointedProfile M f P cutoff k = pointedProfile M f R cutoff k := by + have hb := relativeHeight_eq_blocks M f U cutoff he k + have hv := congrArg (fun b : RelativeBlock S => (ofLex (ofLex b).2).1) hb + exact congrArg ofLex hv + +lemma relativeHeight_eq_masks {P R : Deligne M} + (he : relativeHeight M f U cutoff P = relativeHeight M f U cutoff R) (k : ℕ) : + relativeSignMask M f U cutoff P k = relativeSignMask M f U cutoff R k := by + have hb := relativeHeight_eq_blocks M f U cutoff he k + have hv := congrArg (fun b : RelativeBlock S => (ofLex (ofLex b).2).2) hb + exact congrArg ofLex hv + +/-- Absence of recorded incidence, restricted to the group currently acting. -/ +def relativeInvisible (Y : Set S) (P : Deligne M) : Set S := + {i | i ∈ Y ∧ ∀ k, ¬levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i)} + +def relativeVisible (Y : Set S) (P : Deligne M) : Set S := + P.val.1 \ relativeInvisible M f cutoff Y P + +lemma relativeInvisible_eq_of_height_eq (Y : Set S) {P R : Deligne M} + (he : relativeHeight M f U cutoff P = relativeHeight M f U cutoff R) : + relativeInvisible M f cutoff Y P = relativeInvisible M f cutoff Y R := by + ext i + constructor + · rintro ⟨hi, hh⟩ + refine ⟨hi, fun k => ?_⟩ + unfold levelIncident at * + rw [← relativeHeight_eq_profiles M f U cutoff he k] + exact hh k + · rintro ⟨hi, hh⟩ + refine ⟨hi, fun k => ?_⟩ + unfold levelIncident at * + rw [relativeHeight_eq_profiles M f U cutoff he k] + exact hh k + +/-- Each new closed color at a tied upper vertex has no recorded incidence. -/ +lemma tied_new_color_invisible (Y : Set S) {P R : Deligne M} + (hR : R.val.1 ⊆ Y) + (he : relativeHeight M f U cutoff P = relativeHeight M f U cutoff R) + (i : S) (hi : i ∈ R.val.1) (hn : i ∉ P.val.1) : + i ∈ relativeInvisible M f cutoff Y R := by + refine ⟨hR hi, ?_⟩ + intro k hinc + have hm := congrFun (relativeHeight_eq_masks M f U cutoff he k) (toLex (.inl i)) + have hp : (.inl i : S ⊕ Unit) ∉ Sum.inl '' P.val.1 := by + rintro ⟨j, hj, heq⟩ + exact hn (Sum.inl.inj heq ▸ hj) + have hr : (.inl i : S ⊕ Unit) ∈ Sum.inl '' R.val.1 := ⟨i, hi, rfl⟩ + simp only [relativeSignMask, ofLex_toLex, hp, hr, ↓reduceIte] at hm + have hz : pointedProfile M f R cutoff k (.inl i) = 0 := + (relativeSign_eq_zero_iff M U _ k _).mp hm.symm + rcases hinc with hpos | ⟨j, hij, hj⟩ + · exact (ne_of_gt hpos) hz + · have hrow : (framedCartan M *ᵥ pointedProfile M f R cutoff k) (.inl i) = 0 := + pointedCosetVector_harmonic M f R (cutoff + k) ⟨.inl i, hr⟩ + have hpos := harmonic_positive_neighbor_at (framedCartan M) (framedCartan_off M) + _ (pointedCosetVector_nonneg M f R (cutoff + k)) (le_of_eq hrow.symm) hij hj + exact (ne_of_gt hpos) hz + +/-- The visible closed set is constant across a tied comparability edge. -/ +lemma relativeVisible_eq_of_tie (Y : Set S) {P R : Deligne M} (hPR : P ≤ R) + (hR : R.val.1 ⊆ Y) + (he : relativeHeight M f U cutoff P = relativeHeight M f U cutoff R) : + relativeVisible M f cutoff Y P = relativeVisible M f cutoff Y R := by + have hK := relativeInvisible_eq_of_height_eq M f U cutoff Y he + ext i + constructor + · rintro ⟨hi, hn⟩ + exact ⟨hPR.1 hi, by rwa [← hK]⟩ + · rintro ⟨hi, hn⟩ + have hp : i ∈ P.val.1 := by + by_contra hp + exact hn (tied_new_color_invisible M f U cutoff Y hR he i hi hp) + exact ⟨hp, by rwa [hK]⟩ + +/-- A visible closed color is positive at some recorded level. -/ +lemma relativeVisible_positive (Y : Set S) (P : Deligne M) (hP : P.val.1 ⊆ Y) + (i : S) (hi : i ∈ relativeVisible M f cutoff Y P) : + ∃ k, 0 < pointedProfile M f P cutoff k (.inl i) := by + have hex : ∃ k, levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i) := by + by_contra hh + exact hi.2 ⟨hP hi.1, fun k hk => hh ⟨k, hk⟩⟩ + obtain ⟨k, hk⟩ := hex + refine ⟨k, ?_⟩ + rcases hk with hp | ⟨j, hij, hj⟩ + · exact hp + · have hrow : (framedCartan M *ᵥ pointedProfile M f P cutoff k) (.inl i) = 0 := + pointedCosetVector_harmonic M f P (cutoff + k) ⟨.inl i, ⟨i, hi.1, rfl⟩⟩ + exact harmonic_positive_neighbor_at (framedCartan M) (framedCartan_off M) _ + (pointedCosetVector_nonneg M f P (cutoff + k)) (le_of_eq hrow.symm) hij hj + +/-- Visible closed colors cannot be adjacent to any invisible color. -/ +lemma relativeVisible_nonadjacent (Y : Set S) (P : Deligne M) (hP : P.val.1 ⊆ Y) + (i j : S) (hi : i ∈ relativeInvisible M f cutoff Y P) + (hj : j ∈ relativeVisible M f cutoff Y P) : + ¬framedCartan M (.inl i) (.inl j) < 0 := by + intro hij + obtain ⟨k, hk⟩ := relativeVisible_positive M f cutoff Y P hP j hj + exact hi.2 k (Or.inr ⟨.inl j, hij, hk⟩) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTranslation.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTranslation.lean new file mode 100644 index 0000000000000000000000000000000000000000..4c58960c4579830f8a48ac08e43c40063e3e1b37 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeTranslation.lean @@ -0,0 +1,113 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedWeighted +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativePoset +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeTies + +namespace OAI + +/-! Right translation of the relative coset poset by a transported stabilizer. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +noncomputable def deligneRightTranslate (P : Deligne M) (r : Artin M) : Deligne M := + sourceCoset M P.val.1 P.property.1 (sourceCosetRepresentative M P*r) + +omit [Fintype S] [LinearOrder S] in +@[simp] lemma deligneRightTranslate_type (P : Deligne M) (r : Artin M) : + (deligneRightTranslate M P r).val.1 = P.val.1 := rfl + +omit [Fintype S] [LinearOrder S] in +lemma mem_deligneRightTranslate (P : Deligne M) (r z : Artin M) : + z ∈ (deligneRightTranslate M P r).val.2 ↔ z*r⁻¹ ∈ P.val.2 := by + rw [sourceCosetRepresentative_spec M P] + change z*(sourceCosetRepresentative M P*r)⁻¹ ∈ artinParabolic M P.val.1 ↔ + (z*r⁻¹)*(sourceCosetRepresentative M P)⁻¹ ∈ artinParabolic M P.val.1 + simp only [mul_inv_rev, _root_.mul_assoc] + +omit [Fintype S] [LinearOrder S] in +lemma deligneRightTranslate_mono (r : Artin M) : Monotone (fun P => deligneRightTranslate M P r) := by + intro P R h + refine ⟨h.1, ?_⟩ + intro z hz + exact (mem_deligneRightTranslate M R r z).mpr (h.2 ((mem_deligneRightTranslate M P r z).mp hz)) + +omit [Fintype S] [LinearOrder S] in +lemma deligneRightTranslate_inv (P : Deligne M) (r : Artin M) : + deligneRightTranslate M (deligneRightTranslate M P r) r⁻¹ = P := by + apply Subtype.ext + apply Prod.ext + · rfl + · ext z + simp only [mem_deligneRightTranslate, inv_inv, _root_.mul_assoc, mul_inv_cancel, _root_.mul_one] + +lemma pointedFamily_transport_fixed (f : S) (x a : Artin M) + (ha : pointedFamily M f (a*x) = pointedFamily M f x) (z : Artin M) : + pointedFamily M f (z*(x⁻¹*a*x)) = pointedFamily M f z := by + have h1 : z*(x⁻¹*a*x) = (z*x⁻¹)*(a*x) := by group + have h2 : (z*x⁻¹)*x = z := by group + funext L + rw [h1, pointedFamily_mul, congrFun ha L, ←pointedFamily_mul, h2] + +lemma pointedCosetVector_translate_fixed (f : S) (x a : Artin M) + (ha : pointedFamily M f (a*x) = pointedFamily M f x) (P : Deligne M) (k : ℤ) : + pointedCosetVector M f (deligneRightTranslate M P (x⁻¹*a*x)) k = + pointedCosetVector M f P k := by + let z := sourceCosetRepresentative M P + have hz : z*(x⁻¹*a*x) ∈ (deligneRightTranslate M P (x⁻¹*a*x)).val.2 := + rightCoset_self M _ _ + rw [pointedCosetVector_eq M f _ _ hz k] + change pointedHarmonicAt M f P.val.1 (z*(x⁻¹*a*x)) k = pointedHarmonicAt M f P.val.1 z k + unfold pointedHarmonicAt + congr 1 + unfold pointedMultiplicity + rw [pointedFamily_transport_fixed M f x a ha z] + +lemma relativeHeight_congr (f : S) (U : Set (S ⊕ Unit)) (cutoff : ℤ) + (P R : Deligne M) (ht : P.val.1 = R.val.1) + (hv : ∀ k, pointedCosetVector M f P k = pointedCosetVector M f R k) : + relativeHeight M f U cutoff P = relativeHeight M f U cutoff R := by + have hp : pointedProfile M f P cutoff = pointedProfile M f R cutoff := by + ext k i + exact congrFun (hv (cutoff+k)) i + have hm (k : ℕ) : relativeSignMask M f U cutoff P k = relativeSignMask M f U cutoff R k := by + unfold relativeSignMask + rw [ht, hp] + have hb (k : ℕ) : relativeBlock M f U cutoff P k = relativeBlock M f U cutoff R k := by + unfold relativeBlock pointedCosetSum + rw [hv, hp, hm] + apply congrArg toColex + ext k + change relativeBlockRank M f U cutoff (relativeBlock M f U cutoff P k) = + relativeBlockRank M f U cutoff (relativeBlock M f U cutoff R k) + rw [hb] + +/-- A transported stabilizer preserves the complete relative height, +including every sign-mask coordinate. -/ +lemma relativeHeight_translate_fixed (f : S) (U : Set (S ⊕ Unit)) (cutoff : ℤ) + (x a : Artin M) (ha : pointedFamily M f (a*x) = pointedFamily M f x) (P : Deligne M) : + relativeHeight M f U cutoff (deligneRightTranslate M P (x⁻¹*a*x)) = + relativeHeight M f U cutoff P := + relativeHeight_congr M f U cutoff _ _ rfl (pointedCosetVector_translate_fixed M f x a ha P) + +omit [Fintype S] [LinearOrder S] in +lemma deligneRightTranslate_relative (Y : Set S) (x a : Artin M) + (ha : a ∈ artinParabolic M Y) (P : RelativeVertex M Y x) : + (deligneRightTranslate M P.val (x⁻¹*a*x)).val.1 ⊆ Y ∧ + (deligneRightTranslate M P.val (x⁻¹*a*x)).val.2 ⊆ rightCoset M Y x := by + refine ⟨P.property.1, ?_⟩ + apply rightCoset_subset_of_point M P.property.1 + let z := sourceCosetRepresentative M P.val + have hz : z*x⁻¹ ∈ artinParabolic M Y := + P.property.2 (sourceCosetRepresentative_mem M P.val) + have he : (z*(x⁻¹*a*x))*x⁻¹ = (z*x⁻¹)*a := by group + change (z*(x⁻¹*a*x))*x⁻¹ ∈ artinParabolic M Y + rw [he] + exact (artinParabolic M Y).mul_mem hz ha + +noncomputable def relativeTranslate (Y : Set S) (x a : Artin M) + (ha : a ∈ artinParabolic M Y) (P : RelativeVertex M Y x) : RelativeVertex M Y x := + ⟨deligneRightTranslate M P.val (x⁻¹*a*x), deligneRightTranslate_relative M Y x a ha P⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperBasics.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperBasics.lean new file mode 100644 index 0000000000000000000000000000000000000000..a066a25c337ac24c1f9649b73334af027507b3cf --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperBasics.lean @@ -0,0 +1,110 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeActive +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedRows +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedResidueActive + +namespace OAI + +/-! Highest-incidence comparisons for upper edges of the relative filtration. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + (U : Set (S ⊕ Unit)) (cutoff : ℤ) + +omit [LinearOrder S] in +lemma relativeSign_congr_above (p r : ℕ →₀ (S ⊕ Unit → ℝ)) (k : ℕ) + (he : ∀ d, k ≤ d → p d = r d) (i : S ⊕ Unit) : + relativeSign M U p k i = relativeSign M U r k i := by + have hk := he k le_rfl + have hs : relativePositiveSign (framedCartan M) U p k i ↔ + relativePositiveSign (framedCartan M) U r k i := by + unfold relativePositiveSign + simp only [hk] + constructor + · rintro ⟨I, hi, hU, hc, hr, hh⟩ + exact ⟨I, hi, hU, hc, hr, fun d hd j hj => by rw [←he d hd.le]; exact hh d hd j hj⟩ + · rintro ⟨I, hi, hU, hc, hr, hh⟩ + exact ⟨I, hi, hU, hc, hr, fun d hd j hj => by rw [he d hd.le]; exact hh d hd j hj⟩ + simp only [relativeSign, hk, hs] + +lemma relativeHeight_lt_iff (P R : Deligne M) : + relativeHeight M f U cutoff P < relativeHeight M f U cutoff R ↔ + ∃ k, (∀ d, k < d → relativeBlock M f U cutoff P d = relativeBlock M f U cutoff R d) ∧ + relativeBlock M f U cutoff P k < relativeBlock M f U cutoff R k := by + rw [Finsupp.Colex.lt_iff] + constructor + · rintro ⟨k, hk, hlt⟩ + refine ⟨k, fun d hd => ?_, (relativeBlockRank_lt_iff M f U cutoff + (Or.inr ⟨P,k,rfl⟩) (Or.inr ⟨R,k,rfl⟩)).mp hlt⟩ + exact (relativeBlockRank_eq_iff M f U cutoff (Or.inr ⟨P,d,rfl⟩) + (Or.inr ⟨R,d,rfl⟩)).mp (hk d hd) + · rintro ⟨k, hk, hlt⟩ + exact ⟨k, fun d hd => congrArg (relativeBlockRank M f U cutoff) (hk d hd), + (relativeBlockRank_lt_iff M f U cutoff (Or.inr ⟨P,k,rfl⟩) + (Or.inr ⟨R,k,rfl⟩)).mpr hlt⟩ + +noncomputable def relativeIncidence (P : Deligne M) (i : S) : ℕ := + incidenceLevel (framedCartan M) (pointedProfile M f P cutoff) (.inl i) + +lemma relative_no_incidence {P : Deligne M} {k : ℕ} {i : S} + (hn : ¬levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i)) : + pointedProfile M f P cutoff k (.inl i) = 0 ∧ + (framedCartan M *ᵥ pointedProfile M f P cutoff k) (.inl i) = 0 ∧ + relativeSign M U (pointedProfile M f P cutoff) k (.inl i) = 0 := by + have hz : pointedProfile M f P cutoff k (.inl i) = 0 := le_antisymm + (le_of_not_gt (fun h => hn (Or.inl h))) (pointedCosetVector_nonneg M f P _ _) + refine ⟨hz, no_incidence_row_zero (framedCartan M) (framedCartan_off M) _ + (fun k i => pointedCosetVector_nonneg M f P (cutoff+k) i) hn, ?_⟩ + simp only [relativeSign, hz, ↓reduceIte] + +lemma relative_above_incidence {P : Deligne M} {k : ℕ} {i : S} + (h : relativeIncidence M f cutoff P i < k) : + ¬levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i) := + fun hi => (not_le_of_gt h) (levelIncident_le _ _ hi) + +noncomputable def relativeUpperLevel (P R : Deligne M) : ℕ := + (R.val.1.toFinset \ P.val.1.toFinset).sup (relativeIncidence M f cutoff P) + +lemma relativeIncidence_le_upperLevel (P R : Deligne M) (i : S) + (hi : i ∈ R.val.1) (ht : i ∉ P.val.1) : + relativeIncidence M f cutoff P i ≤ relativeUpperLevel M f cutoff P R := + Finset.le_sup (f := relativeIncidence M f cutoff P) (by simp [hi, ht]) + +lemma relativeProfile_eq_above_upper {P R : Deligne M} (h : P ≤ R) {k : ℕ} + (hk : relativeUpperLevel M f cutoff P R < k) : + pointedProfile M f R cutoff k = pointedProfile M f P cutoff k := by + apply pointedCosetVector_eq_of_upper_rows M f h (cutoff+k) + intro i hi ht + exact (relative_no_incidence M f ∅ cutoff (relative_above_incidence M f cutoff + ((relativeIncidence_le_upperLevel M f cutoff P R i hi ht).trans_lt hk))).2.1 + +lemma relativeBlock_eq_above_upper {P R : Deligne M} (h : P ≤ R) {k : ℕ} + (hk : relativeUpperLevel M f cutoff P R < k) : + relativeBlock M f U cutoff R k = relativeBlock M f U cutoff P k := by + have hv := relativeProfile_eq_above_upper M f cutoff h hk + have hs (i : S ⊕ Unit) : + relativeSign M U (pointedProfile M f R cutoff) k i = + relativeSign M U (pointedProfile M f P cutoff) k i := + relativeSign_congr_above M U _ _ k + (fun d hd => relativeProfile_eq_above_upper M f cutoff h (hk.trans_le hd)) i + have hm : relativeSignMask M f U cutoff R k = relativeSignMask M f U cutoff P k := by + funext i + unfold relativeSignMask + by_cases hp : ofLex i ∈ Sum.inl '' P.val.1 + · have hr := Set.image_mono h.1 hp + simp only [hp, hr, ↓reduceIte, hs] + · by_cases hr : ofLex i ∈ Sum.inl '' R.val.1 + · obtain ⟨j, hj, he⟩ := hr + have hjp : j ∉ P.val.1 := fun h => hp ⟨j,h,he⟩ + have hz := (relative_no_incidence M f U cutoff (relative_above_incidence M f cutoff + ((relativeIncidence_le_upperLevel M f cutoff P R j hj hjp).trans_lt hk))).2.2 + simp only [hs, ←he, hz, ite_self] + · simp only [hp, hr, ↓reduceIte] + unfold relativeBlock + have hsum : pointedCosetSum M f R (cutoff+k) = pointedCosetSum M f P (cutoff+k) := + congrArg (fun v : S ⊕ Unit → ℝ => ∑ i, v i) hv + rw [hsum, hv, hm] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperComparison.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperComparison.lean new file mode 100644 index 0000000000000000000000000000000000000000..05c52ae1c1a43dc6fc2374d67aff190cde22dfda --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperComparison.lean @@ -0,0 +1,159 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeUpperSigns + +namespace OAI + +/-! Strict upper-neighbor comparisons for the relative height. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + (U : Set (S ⊕ Unit)) (cutoff : ℤ) + +lemma relativeHeight_eq_of_blocks {P R : Deligne M} + (he : ∀ k, relativeBlock M f U cutoff P k = relativeBlock M f U cutoff R k) : + relativeHeight M f U cutoff P = relativeHeight M f U cutoff R := by + apply congrArg toColex + ext k + change relativeBlockRank M f U cutoff _ = relativeBlockRank M f U cutoff _ + rw [he] + +lemma relativeHeight_eq_of_new_invisible {P R : Deligne M} (h : P ≤ R) + (hn : ∀ i ∈ R.val.1, i ∉ P.val.1 → ∀ k, + ¬levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i)) : + relativeHeight M f U cutoff R = relativeHeight M f U cutoff P := by + have hv (k : ℕ) : pointedProfile M f R cutoff k = pointedProfile M f P cutoff k := by + apply pointedCosetVector_eq_of_upper_rows M f h (cutoff+k) + intro i hi ht + exact (relative_no_incidence M f U cutoff (hn i hi ht k)).2.1 + have hs (k : ℕ) (i : S ⊕ Unit) := relativeSign_congr_above M U + (pointedProfile M f R cutoff) (pointedProfile M f P cutoff) k (fun d _ => hv d) i + apply relativeHeight_eq_of_blocks M f U cutoff + intro k + have hm : relativeSignMask M f U cutoff R k = relativeSignMask M f U cutoff P k := by + funext i + unfold relativeSignMask + rw [hs] + by_cases hp : ofLex i ∈ Sum.inl '' P.val.1 + · simp only [hp, Set.image_mono h.1 hp, ↓reduceIte] + · by_cases hr : ofLex i ∈ Sum.inl '' R.val.1 + · obtain ⟨j,hj,he⟩ := hr + have hjp : j ∉ P.val.1 := fun hh => hp ⟨j,hh,he⟩ + have hz := (relative_no_incidence M f U cutoff (hn j hj hjp k)).2.2 + simp only [←he, hz, ite_self] + · simp only [hp, hr, ↓reduceIte] + unfold relativeBlock + have hsum : pointedCosetSum M f R (cutoff+k) = pointedCosetSum M f P (cutoff+k) := + congrArg (fun v : S ⊕ Unit → ℝ => ∑ i, v i) (hv k) + rw [hsum, hv, hm] + +lemma relativeUpper_inactive_le {P R : Deligne M} (h : P < R) + (ha : ∀ i ∈ R.val.1, i ∉ P.val.1 → ¬relativeColorActive M f U cutoff P i) : + relativeHeight M f U cutoff P ≤ relativeHeight M f U cutoff R := by + by_cases hsome : ∃ i ∈ R.val.1, i ∉ P.val.1 ∧ ∃ k, + levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i) + · apply le_of_lt + apply (relativeHeight_lt_iff M f U cutoff P R).mpr + refine ⟨relativeUpperLevel M f cutoff P R, + fun d hd => (relativeBlock_eq_above_upper M f U cutoff h.le hd).symm, ?_⟩ + let H := relativeUpperLevel M f cutoff P R + by_cases hv : pointedProfile M f R cutoff H = pointedProfile M f P cutoff H + · have hr (i : S) (hi : i ∈ R.val.1) : + (framedCartan M *ᵥ pointedProfile M f P cutoff H) (.inl i) = 0 := by + rw [←hv] + exact pointedCosetVector_harmonic M f R (cutoff+H) ⟨.inl i,⟨i,hi,rfl⟩⟩ + have hs (i : S) (hi : i ∈ R.val.1) (ht : i ∉ P.val.1) : + 0 ≤ relativeSign M U (pointedProfile M f P cutoff) H (.inl i) := by + by_cases hn : levelIncident (framedCartan M) (pointedProfile M f P cutoff) H (.inl i) + · have he : H = relativeIncidence M f cutoff P i := le_antisymm + (levelIncident_le _ _ hn) (relativeIncidence_le_upperLevel M f cutoff P R i hi ht) + rw [relative_inactive_sign M f U cutoff P i H (ha i hi ht) he hn (hr i hi)] + norm_num + · rw [(relative_no_incidence M f U cutoff hn).2.2] + have hsEq := relative_sign_upper_tie M f U cutoff h.le hv + have hm := relative_mask_upper_nonneg M f U cutoff h.le H hsEq hs + have hne : relativeSignMask M f U cutoff P H ≠ relativeSignMask M f U cutoff R H := by + intro heq + obtain ⟨i,hi,ht,hin⟩ := relativeUpperLevel_incident M f cutoff P R hsome + have hiP : (.inl i : S ⊕ Unit) ∉ Sum.inl '' P.val.1 := by + rintro ⟨j,hj,he⟩ + exact ht (Sum.inl.inj he ▸ hj) + have hiR : (.inl i : S ⊕ Unit) ∈ Sum.inl '' R.val.1 := ⟨i,hi,rfl⟩ + have he : H = relativeIncidence M f cutoff P i := le_antisymm + (levelIncident_le _ _ hin) (relativeIncidence_le_upperLevel M f cutoff P R i hi ht) + have hz := congrFun heq (toLex (.inl i)) + simp only [relativeSignMask, ofLex_toLex, hiP, hiR, ↓reduceIte] at hz + have hsi : relativeSign M U (pointedProfile M f R cutoff) H (.inl i) = + relativeSign M U (pointedProfile M f P cutoff) H (.inl i) := hsEq _ + rw [hsi, relative_inactive_sign M f U cutoff P i H (ha i hi ht) he hin (hr i hi)] at hz + norm_num at hz + exact relativeBlock_lt_of_mask M f U cutoff hv.symm (lt_of_le_of_ne hm hne) + · have hle := pointedCosetVector_upper_monotone_int M f h.le (cutoff+H) + (relative_upper_inactive_rows M f U cutoff P R ha) + exact Prod.Lex.lt_iff.mpr (Or.inl (harmonic_sum_lt_of_lt _ _ hle (Ne.symm hv))) + · have hn : ∀ i ∈ R.val.1, i ∉ P.val.1 → ∀ k, + ¬levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i) := by + intro i hi ht k hin + exact hsome ⟨i,hi,ht,k,hin⟩ + exact (relativeHeight_eq_of_new_invisible M f U cutoff h.le hn).symm.le + +/-- Every descending upper neighbor adds an active color. -/ +theorem relativeUpper_descending_has_active {P R : Deligne M} (h : P < R) + (he : relativeHeight M f U cutoff R < relativeHeight M f U cutoff P) : + ∃ i ∈ R.val.1, i ∉ P.val.1 ∧ relativeColorActive M f U cutoff P i := by + by_contra hn + have hle := relativeUpper_inactive_le M f U cutoff h + (fun i hi ht ha => hn ⟨i,hi,ht,ha⟩) + exact (not_lt_of_ge hle) he + +/-- Closing a nonempty set of active colors strictly decreases the height. -/ +theorem relativeUpper_active_descending {P R : Deligne M} (h : P < R) + (ha : ∀ i ∈ R.val.1, i ∉ P.val.1 → relativeColorActive M f U cutoff P i) : + relativeHeight M f U cutoff R < relativeHeight M f U cutoff P := by + apply (relativeHeight_lt_iff M f U cutoff R P).mpr + refine ⟨relativeUpperLevel M f cutoff P R, + fun d hd => relativeBlock_eq_above_upper M f U cutoff h.le hd, ?_⟩ + let H := relativeUpperLevel M f cutoff P R + by_cases hv : pointedProfile M f R cutoff H = pointedProfile M f P cutoff H + · have hr (i : S) (hi : i ∈ R.val.1) : + (framedCartan M *ᵥ pointedProfile M f P cutoff H) (.inl i) = 0 := by + rw [←hv] + exact pointedCosetVector_harmonic M f R (cutoff+H) ⟨.inl i,⟨i,hi,rfl⟩⟩ + have hs (i : S) (hi : i ∈ R.val.1) (ht : i ∉ P.val.1) : + relativeSign M U (pointedProfile M f P cutoff) H (.inl i) ≤ 0 := by + rcases eq_or_lt_of_le (relativeIncidence_le_upperLevel M f cutoff P R i hi ht) with he | he + · have hh := relative_active_sign M f U cutoff P i (ha i hi ht) (by rw [he]; exact hr i hi) + rw [he] at hh + rw [hh] + norm_num + · rw [(relative_no_incidence M f U cutoff (relative_above_incidence M f cutoff he)).2.2] + have hsEq := relative_sign_upper_tie M f U cutoff h.le hv + have hm := relative_mask_upper_nonpos M f U cutoff h.le H hsEq hs + have hsome : ∃ i ∈ R.val.1, i ∉ P.val.1 ∧ ∃ k, + levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i) := by + obtain ⟨i,hi,ht⟩ := Set.exists_of_ssubset (deligne_lt_type M h) + exact ⟨i,hi,ht,relativeIncidence M f cutoff P i,relative_active_incident M f U cutoff P i (ha i hi ht)⟩ + have hne : relativeSignMask M f U cutoff R H ≠ relativeSignMask M f U cutoff P H := by + intro heq + obtain ⟨i,hi,ht,hin⟩ := relativeUpperLevel_incident M f cutoff P R hsome + have hiP : (.inl i : S ⊕ Unit) ∉ Sum.inl '' P.val.1 := by + rintro ⟨j,hj,he⟩ + exact ht (Sum.inl.inj he ▸ hj) + have hiR : (.inl i : S ⊕ Unit) ∈ Sum.inl '' R.val.1 := ⟨i,hi,rfl⟩ + have he : relativeIncidence M f cutoff P i = H := le_antisymm + (relativeIncidence_le_upperLevel M f cutoff P R i hi ht) (levelIncident_le _ _ hin) + have hsign := relative_active_sign M f U cutoff P i (ha i hi ht) (by rw [he]; exact hr i hi) + rw [he] at hsign + have hz := congrFun heq (toLex (.inl i)) + simp only [relativeSignMask, ofLex_toLex, hiP, hiR, ↓reduceIte] at hz + have hsi : relativeSign M U (pointedProfile M f R cutoff) H (.inl i) = + relativeSign M U (pointedProfile M f P cutoff) H (.inl i) := hsEq _ + rw [hsi, hsign] at hz + norm_num at hz + exact relativeBlock_lt_of_mask M f U cutoff hv (lt_of_le_of_ne hm hne) + · have hle := pointedCosetVector_upper_antitone_int M f h.le (cutoff+H) + (relative_upper_active_rows M f U cutoff P R ha) + exact Prod.Lex.lt_iff.mpr (Or.inl (harmonic_sum_lt_of_lt _ _ hle hv)) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperConnected.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperConnected.lean new file mode 100644 index 0000000000000000000000000000000000000000..3d4e90e50ded131d324949e4a6e24ebf4d0f3984 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperConnected.lean @@ -0,0 +1,115 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeUpperComparison +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativePoset +import OAI.Topology.ArtinGroups.ParabolicIntersections.ConnectedMinima + +namespace OAI + +/-! Connected descending upper neighborhoods, using their common active-color extension. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + (U : Set (S ⊕ Unit)) (cutoff : ℤ) (Y : Set S) (x : Artin M) + +noncomputable def relativeUpperTop (P : RelativeVertex M Y x) + (hYU : ∀ i ∈ Y, (.inl i : S ⊕ Unit) ∈ U) : RelativeVertex M Y x := + relativeVertex M Y (P.val.val.1 ∪ relativeActiveSet M f U cutoff Y P.val) + (relativeActiveSet_spherical M f U cutoff Y P.val P.property.1 hYU) + (fun _ hi => hi.elim (fun h => P.property.1 h) (fun h => h.1)) + x (sourceCosetRepresentative M P.val) (P.property.2 (sourceCosetRepresentative_mem M P.val)) + +noncomputable def relativeUpperClip (P R : RelativeVertex M Y x) : RelativeVertex M Y x := + relativeVertex M Y (R.val.val.1 ∩ (P.val.val.1 ∪ relativeActiveSet M f U cutoff Y P.val)) + (source_spherical_mono M Set.inter_subset_left R.val.property.1) + (fun _ hi => R.property.1 hi.1) + x (sourceCosetRepresentative M P.val) (P.property.2 (sourceCosetRepresentative_mem M P.val)) + +lemma relative_le_upperClip {P R : RelativeVertex M Y x} (h : P ≤ R) : + P ≤ relativeUpperClip M f U cutoff Y x P R := by + change P.val ≤ (relativeUpperClip M f U cutoff Y x P R).val + change P.val ≤ sourceCoset M _ (source_spherical_mono M Set.inter_subset_left R.val.property.1) _ + nth_rw 1 [←sourceCoset_eq M P.val _ (sourceCosetRepresentative_mem M P.val)] + exact sourceCoset_le M (show P.val.val.1 ⊆ R.val.val.1 ∩ + (P.val.val.1 ∪ relativeActiveSet M f U cutoff Y P.val) from + fun _ hi => ⟨h.1 hi, Or.inl hi⟩) _ + +lemma relative_upperClip_le {P R : RelativeVertex M Y x} (h : P ≤ R) : + relativeUpperClip M f U cutoff Y x P R ≤ R := by + change sourceCoset M _ (source_spherical_mono M Set.inter_subset_left R.val.property.1) _ ≤ R.val + rw [←sourceCoset_eq M R.val _ (h.2 (sourceCosetRepresentative_mem M P.val))] + exact sourceCoset_le M Set.inter_subset_left _ + +lemma relative_upperClip_le_top (P R : RelativeVertex M Y x) + (hYU : ∀ i ∈ Y, (.inl i : S ⊕ Unit) ∈ U) : + relativeUpperClip M f U cutoff Y x P R ≤ relativeUpperTop M f U cutoff Y x P hYU := by + exact sourceCoset_le M (hT := source_spherical_mono M Set.inter_subset_left R.val.property.1) + (hU := relativeActiveSet_spherical M f U cutoff Y P.val P.property.1 hYU) Set.inter_subset_right _ + +def RelativeDescendingUpper (P R : RelativeVertex M Y x) : Prop := + P < R ∧ relativeHeight M f U cutoff R.val < relativeHeight M f U cutoff P.val + +lemma relative_upperClip_descending {P R : RelativeVertex M Y x} + (h : RelativeDescendingUpper M f U cutoff Y x P R) : + RelativeDescendingUpper M f U cutoff Y x P (relativeUpperClip M f U cutoff Y x P R) := by + obtain ⟨i,hi,ht,ha⟩ := relativeUpper_descending_has_active M f U cutoff h.1 h.2 + have hl : P < relativeUpperClip M f U cutoff Y x P R := by + apply lt_of_le_of_ne (relative_le_upperClip M f U cutoff Y x h.1.le) + intro he + have hiC : i ∈ (relativeUpperClip M f U cutoff Y x P R).val.val.1 := + ⟨hi, Or.inr ⟨R.property.1 hi,ht,ha⟩⟩ + rw [←he] at hiC + exact ht hiC + refine ⟨hl, relativeUpper_active_descending M f U cutoff hl ?_⟩ + intro j hj hn + exact (hj.2.resolve_left hn).2.2 + +lemma relative_upperTop_descending (P : RelativeVertex M Y x) + (hYU : ∀ i ∈ Y, (.inl i : S ⊕ Unit) ∈ U) + (ha : (relativeActiveSet M f U cutoff Y P.val).Nonempty) : + RelativeDescendingUpper M f U cutoff Y x P (relativeUpperTop M f U cutoff Y x P hYU) := by + have hp : P ≤ relativeUpperTop M f U cutoff Y x P hYU := by + change P.val ≤ sourceCoset M _ + (relativeActiveSet_spherical M f U cutoff Y P.val P.property.1 hYU) _ + nth_rw 1 [←sourceCoset_eq M P.val _ (sourceCosetRepresentative_mem M P.val)] + exact sourceCoset_le M Set.subset_union_left _ + have hl : P < relativeUpperTop M f U cutoff Y x P hYU := by + apply lt_of_le_of_ne hp + intro he + obtain ⟨i,hi⟩ := ha + have hm : i ∈ (relativeUpperTop M f U cutoff Y x P hYU).val.val.1 := Or.inr hi + rw [←he] at hm + exact hi.2.1 hm + exact ⟨hl,relativeUpper_active_descending M f U cutoff hl (fun _ hi hn => (hi.resolve_left hn).2.2)⟩ + +private lemma within_symm {V : Type*} {adj : V → V → Prop} {p : V → Prop} + (hs : ∀ a b, adj a b → adj b a) {a b : V} (h : PathWithin adj p a b) : + PathWithin adj p b a := by + induction h with + | refl => exact .refl + | @tail c d h he ih => + exact (Relation.ReflTransGen.single (r := fun u v => p u ∧ p v ∧ adj u v) + ⟨he.2.1, he.1, hs c d he.2.2⟩).trans ih + +/-- Descending upper neighbors are connected through descending upper neighbors. -/ +theorem relative_descending_upper_connected (P : RelativeVertex M Y x) + (hYU : ∀ i ∈ Y, (.inl i : S ⊕ Unit) ∈ U) + (R Q : RelativeVertex M Y x) + (hR : RelativeDescendingUpper M f U cutoff Y x P R) + (hQ : RelativeDescendingUpper M f U cutoff Y x P Q) : + PathWithin (relativeAdjacent M) (RelativeDescendingUpper M f U cutoff Y x P) R Q := by + obtain ⟨i,hi,ht,ha⟩ := relativeUpper_descending_has_active M f U cutoff hR.1 hR.2 + have hTop := relative_upperTop_descending M f U cutoff Y x P hYU + ⟨i,R.property.1 hi,ht,ha⟩ + have pathToTop (V : RelativeVertex M Y x) (hV : RelativeDescendingUpper M f U cutoff Y x P V) : + PathWithin (relativeAdjacent M) (RelativeDescendingUpper M f U cutoff Y x P) + V (relativeUpperTop M f U cutoff Y x P hYU) := by + have hC := relative_upperClip_descending M f U cutoff Y x hV + exact (Relation.ReflTransGen.single (r := fun a b => + RelativeDescendingUpper M f U cutoff Y x P a ∧ + RelativeDescendingUpper M f U cutoff Y x P b ∧ relativeAdjacent M a b) + ⟨hV,hC,Or.inr (relative_upperClip_le M f U cutoff Y x hV.1.le)⟩).tail + ⟨hC,hTop,Or.inl (relative_upperClip_le_top M f U cutoff Y x P V hYU)⟩ + exact (pathToTop R hR).trans (within_symm (fun _ _ h => h.elim Or.inr Or.inl) (pathToTop Q hQ)) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperSigns.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperSigns.lean new file mode 100644 index 0000000000000000000000000000000000000000..37cc124e7aa034cebb2f4e563aae3d685ad49e2b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/RelativeUpperSigns.lean @@ -0,0 +1,180 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.RelativeUpperBasics + +namespace OAI + +/-! Active-color rows and full sign masks at an upper comparison level. -/ +namespace HarmonicArtin.ParabolicIntersections +open _root_.Matrix _root_.OAI.Matrix +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) + (U : Set (S ⊕ Unit)) (cutoff : ℤ) + +def relativeColorActive (P : Deligne M) (i : S) : Prop := + relativeActive (framedCartan M) U (pointedProfile M f P cutoff) (.inl i) + +lemma relative_active_incident (P : Deligne M) (i : S) + (ha : relativeColorActive M f U cutoff P i) : + levelIncident (framedCartan M) (pointedProfile M f P cutoff) + (relativeIncidence M f cutoff P i) (.inl i) := by + by_contra hn + have hz := relative_no_incidence M f U cutoff hn + rcases ha with hp | ⟨_,hp,_⟩ + · exact (ne_of_gt hp) hz.2.1 + · exact (ne_of_gt hp) hz.1 + +lemma relative_active_sign (P : Deligne M) (i : S) + (ha : relativeColorActive M f U cutoff P i) + (hr : (framedCartan M *ᵥ pointedProfile M f P cutoff + (relativeIncidence M f cutoff P i)) (.inl i) = 0) : + relativeSign M U (pointedProfile M f P cutoff) (relativeIncidence M f cutoff P i) (.inl i) = -1 := by + change 0 < (framedCartan M *ᵥ pointedProfile M f P cutoff (relativeIncidence M f cutoff P i)) (.inl i) ∨ + (framedCartan M *ᵥ pointedProfile M f P cutoff (relativeIncidence M f cutoff P i)) (.inl i) = 0 ∧ + 0 < pointedProfile M f P cutoff (relativeIncidence M f cutoff P i) (.inl i) ∧ + ¬relativePositiveSign (framedCartan M) U (pointedProfile M f P cutoff) + (relativeIncidence M f cutoff P i) (.inl i) at ha + rcases ha with hp | ⟨_,hp,hn⟩ + · exact ((ne_of_gt hp) hr).elim + · change 0 < pointedProfile M f P cutoff (relativeIncidence M f cutoff P i) (.inl i) at hp + change ¬relativePositiveSign (framedCartan M) U (pointedProfile M f P cutoff) + (relativeIncidence M f cutoff P i) (.inl i) at hn + simp only [relativeSign, ne_of_gt hp, hn, ↓reduceIte] + +lemma relative_inactive_sign (P : Deligne M) (i : S) (k : ℕ) + (ha : ¬relativeColorActive M f U cutoff P i) + (hk : k = relativeIncidence M f cutoff P i) + (hi : levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i)) + (hr : (framedCartan M *ᵥ pointedProfile M f P cutoff k) (.inl i) = 0) : + relativeSign M U (pointedProfile M f P cutoff) k (.inl i) = 1 := by + have hp : 0 < pointedProfile M f P cutoff k (.inl i) := by + rcases hi with hp | ⟨j,hij,hj⟩ + · exact hp + · exact harmonic_positive_neighbor_at (framedCartan M) (framedCartan_off M) _ + (pointedCosetVector_nonneg M f P (cutoff+k)) (le_of_eq hr.symm) hij hj + have hs : relativePositiveSign (framedCartan M) U (pointedProfile M f P cutoff) k (.inl i) := by + by_contra hn + apply ha + change relativeActive (framedCartan M) U (pointedProfile M f P cutoff) (.inl i) + change 0 < (framedCartan M *ᵥ pointedProfile M f P cutoff (relativeIncidence M f cutoff P i)) (.inl i) ∨ + (framedCartan M *ᵥ pointedProfile M f P cutoff (relativeIncidence M f cutoff P i)) (.inl i) = 0 ∧ + 0 < pointedProfile M f P cutoff (relativeIncidence M f cutoff P i) (.inl i) ∧ + ¬relativePositiveSign (framedCartan M) U (pointedProfile M f P cutoff) + (relativeIncidence M f cutoff P i) (.inl i) + rw [←hk] + exact Or.inr ⟨hr,hp,hn⟩ + simp only [relativeSign, ne_of_gt hp, hs, ↓reduceIte] + +lemma relative_upper_inactive_rows (P R : Deligne M) + (ha : ∀ i ∈ R.val.1, i ∉ P.val.1 → ¬relativeColorActive M f U cutoff P i) + (i : S) (hi : i ∈ R.val.1) (ht : i ∉ P.val.1) : + (framedCartan M *ᵥ pointedProfile M f P cutoff (relativeUpperLevel M f cutoff P R)) (.inl i) ≤ 0 := by + rcases eq_or_lt_of_le (relativeIncidence_le_upperLevel M f cutoff P R i hi ht) with he | he + · have hn : ¬0 < (framedCartan M *ᵥ pointedProfile M f P cutoff + (relativeIncidence M f cutoff P i)) (.inl i) := fun hp => ha i hi ht (Or.inl hp) + rw [←he] + exact le_of_not_gt hn + · rw [(relative_no_incidence M f U cutoff (relative_above_incidence M f cutoff he)).2.1] + +lemma relative_upper_active_rows (P R : Deligne M) + (ha : ∀ i ∈ R.val.1, i ∉ P.val.1 → relativeColorActive M f U cutoff P i) + (i : S) (hi : i ∈ R.val.1) (ht : i ∉ P.val.1) : + 0 ≤ (framedCartan M *ᵥ pointedProfile M f P cutoff (relativeUpperLevel M f cutoff P R)) (.inl i) := by + rcases eq_or_lt_of_le (relativeIncidence_le_upperLevel M f cutoff P R i hi ht) with he | he + · have hh := ha i hi ht + have hrow : 0 ≤ (framedCartan M *ᵥ pointedProfile M f P cutoff + (relativeIncidence M f cutoff P i)) (.inl i) := by + rcases hh with hp | ⟨hz, _⟩ + · exact hp.le + · exact hz.ge + simpa only [he] using hrow + · rw [(relative_no_incidence M f U cutoff (relative_above_incidence M f cutoff he)).2.1] + +lemma relativeUpperLevel_incident (P R : Deligne M) + (hsome : ∃ i ∈ R.val.1, i ∉ P.val.1 ∧ ∃ k, + levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl i)) : + ∃ i ∈ R.val.1, i ∉ P.val.1 ∧ + levelIncident (framedCartan M) (pointedProfile M f P cutoff) + (relativeUpperLevel M f cutoff P R) (.inl i) := by + by_cases hk : relativeUpperLevel M f cutoff P R = 0 + · obtain ⟨i,hi,ht,k,hki⟩ := hsome + have hle := (levelIncident_le _ _ hki).trans (relativeIncidence_le_upperLevel M f cutoff P R i hi ht) + have he : k = relativeUpperLevel M f cutoff P R := by omega + exact ⟨i,hi,ht,he ▸ hki⟩ + · obtain ⟨i,hi,ht,k,hki⟩ := hsome + obtain ⟨j,hj,he⟩ := Finset.exists_mem_eq_sup + (R.val.1.toFinset \ P.val.1.toFinset) ⟨i,by simp [hi,ht]⟩ (relativeIncidence M f cutoff P) + have hjR : j ∈ R.val.1 := Set.mem_toFinset.mp (Finset.mem_sdiff.mp hj).1 + have hjP : j ∉ P.val.1 := fun h => (Finset.mem_sdiff.mp hj).2 (Set.mem_toFinset.mpr h) + refine ⟨j,hjR,hjP,?_⟩ + have hex : ∃ k, levelIncident (framedCartan M) (pointedProfile M f P cutoff) k (.inl j) := by + by_contra hn + have hempty : incidenceIndices (framedCartan M) (pointedProfile M f P cutoff) (.inl j) = ∅ := by + apply Finset.eq_empty_iff_forall_notMem.mpr + intro d hd + exact hn ⟨d,(Finset.mem_filter.mp hd).2⟩ + have hz : relativeIncidence M f cutoff P j = 0 := by + simp only [relativeIncidence, incidenceLevel, hempty, Finset.sup_empty, bot_eq_zero] + exact hk (he.trans hz) + rw [show relativeUpperLevel M f cutoff P R = relativeIncidence M f cutoff P j from he] + exact incidenceLevel_incident _ _ _ hex + +lemma relative_sign_upper_tie {P R : Deligne M} (h : P ≤ R) + (hv : pointedProfile M f R cutoff (relativeUpperLevel M f cutoff P R) = + pointedProfile M f P cutoff (relativeUpperLevel M f cutoff P R)) (i : S ⊕ Unit) : + relativeSign M U (pointedProfile M f R cutoff) (relativeUpperLevel M f cutoff P R) i = + relativeSign M U (pointedProfile M f P cutoff) (relativeUpperLevel M f cutoff P R) i := by + apply relativeSign_congr_above M U + intro d hd + rcases eq_or_lt_of_le hd with rfl | hd + · exact hv + · exact relativeProfile_eq_above_upper M f cutoff h hd + +lemma relative_mask_upper_nonneg {P R : Deligne M} (h : P ≤ R) (k : ℕ) + (hs : ∀ i, relativeSign M U (pointedProfile M f R cutoff) k i = + relativeSign M U (pointedProfile M f P cutoff) k i) + (hn : ∀ i ∈ R.val.1, i ∉ P.val.1 → + 0 ≤ relativeSign M U (pointedProfile M f P cutoff) k (.inl i)) : + relativeSignMask M f U cutoff P k ≤ relativeSignMask M f U cutoff R k := by + intro i + unfold relativeSignMask + rw [hs] + by_cases hp : ofLex i ∈ Sum.inl '' P.val.1 + · simp only [hp, Set.image_mono h.1 hp, ↓reduceIte, le_refl] + · by_cases hr : ofLex i ∈ Sum.inl '' R.val.1 + · obtain ⟨j,hj,he⟩ := hr + have hnp : j ∉ P.val.1 := fun hh => hp ⟨j,hh,he⟩ + simp only [hp, show ofLex i ∈ Sum.inl '' R.val.1 from ⟨j,hj,he⟩, ↓reduceIte] + rw [←he] + exact hn j hj hnp + · simp only [hp, hr, ↓reduceIte, le_refl] + +lemma relative_mask_upper_nonpos {P R : Deligne M} (h : P ≤ R) (k : ℕ) + (hs : ∀ i, relativeSign M U (pointedProfile M f R cutoff) k i = + relativeSign M U (pointedProfile M f P cutoff) k i) + (hn : ∀ i ∈ R.val.1, i ∉ P.val.1 → + relativeSign M U (pointedProfile M f P cutoff) k (.inl i) ≤ 0) : + relativeSignMask M f U cutoff R k ≤ relativeSignMask M f U cutoff P k := by + intro i + unfold relativeSignMask + rw [hs] + by_cases hp : ofLex i ∈ Sum.inl '' P.val.1 + · simp only [hp, Set.image_mono h.1 hp, ↓reduceIte, le_refl] + · by_cases hr : ofLex i ∈ Sum.inl '' R.val.1 + · obtain ⟨j,hj,he⟩ := hr + have hnp : j ∉ P.val.1 := fun hh => hp ⟨j,hh,he⟩ + simp only [hp, show ofLex i ∈ Sum.inl '' R.val.1 from ⟨j,hj,he⟩, ↓reduceIte] + rw [←he] + exact hn j hj hnp + · simp only [hp, hr, ↓reduceIte, le_refl] + +lemma relativeBlock_lt_of_mask {P R : Deligne M} {k : ℕ} + (hv : pointedProfile M f P cutoff k = pointedProfile M f R cutoff k) + (hm : relativeSignMask M f U cutoff P k < relativeSignMask M f U cutoff R k) : + relativeBlock M f U cutoff P k < relativeBlock M f U cutoff R k := by + unfold relativeBlock + apply Prod.Lex.lt_iff.mpr + refine Or.inr ⟨congrArg (fun v : S ⊕ Unit → ℝ => ∑ i, v i) hv, ?_⟩ + exact Prod.Lex.lt_iff.mpr (Or.inr ⟨congrArg toLex hv, Pi.toLex_strictMono hm⟩) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalCochain.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalCochain.lean new file mode 100644 index 0000000000000000000000000000000000000000..891b00962f730a52c321e2889f6ad856953a5410 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalCochain.lean @@ -0,0 +1,93 @@ +import OAI.Topology.ArtinGroups.Complexes.PositiveWordActionTest +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedFamily + +namespace OAI + +/-! The ordinary cochain bound in Lemma 7.2 of paper 082-03. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} {K : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +/-- Unlike `ClassTestUpper`, this bounds ordinary cochain degree, uniformly +in total degree. -/ +def ClassTestCochainUpper (x : FiniteHomotopyClass Q (K := K)) (U : Set V) (m : ℤ) : Prop := + ∀ α ∈ U, ∀ l c : ℤ, m < c → ClassTestExact Q α l c x + +lemma classTestCochainUpper_mono (x : FiniteHomotopyClass Q (K := K)) (U : Set V) + {m n : ℤ} (hmn : m ≤ n) (h : ClassTestCochainUpper Q x U m) : + ClassTestCochainUpper Q x U n := + fun α hα l c hc => h α hα l c (hmn.trans_lt hc) + +lemma classTestCochainUpper_positive (hn : ∀ a, Q.source a ≠ Q.target a) + (x : FiniteHomotopyClass Q (K := K)) (U : Set V) (α : V) (hα : α ∈ U) + (m : ℤ) (h : ClassTestCochainUpper Q x U m) : + ClassTestCochainUpper Q (classPositiveTwist Q α x) U m := by + intro β hβ l c hc + by_cases he : β = α + · subst β + apply (classTestExact_positive_self Q hn x α l c).mpr + exact h α hα (l-1) (c+1) (by omega) + · exact classTestExact_positive_other Q x α β he l c + (h α hα l (c+1) (by omega)) (h β hβ l c hc) + +lemma positiveWord_cochain_bounds (hn : ∀ a, Q.source a ≠ Q.target a) + (w : List V) (x : FiniteHomotopyClass Q (K := K)) (U : Set V) + (hw : ∀ α ∈ w, α ∈ U) (m : ℤ) (h : ClassTestCochainUpper Q x U m) : + ClassTestCochainUpper Q (positiveWordAction Q w x) U m ∧ + ∀ α ∈ w, ∀ l c : ℤ, m-1 < c → + ClassTestExact Q α l c (positiveWordAction Q w x) := by + induction w with + | nil => exact ⟨h, fun _ hα => (List.not_mem_nil hα).elim⟩ + | cons α w ih => + obtain ⟨hbound, himproved⟩ := ih (fun β hβ => hw β (List.mem_cons_of_mem α hβ)) + refine ⟨classTestCochainUpper_positive Q hn _ U α (hw α (by simp)) m hbound, ?_⟩ + intro β hβ l c hc + change ClassTestExact Q β l c (classPositiveTwist Q α (positiveWordAction Q w x)) + by_cases he : β = α + · subst β + apply (classTestExact_positive_self Q hn _ α l c).mpr + exact hbound α (hw α (by simp)) (l-1) (c+1) (by omega) + · apply classTestExact_positive_other Q _ α β he l c + · exact hbound α (hw α (by simp)) l (c+1) (by omega) + · exact himproved β ((List.mem_cons.mp hβ).resolve_left he) l c hc + +/-- A pass containing every operated vertex lowers the ordinary cochain +bound by one. This is proved from the actual twist test formulas. -/ +theorem positiveWord_complete_cochain_drop (hn : ∀ a, Q.source a ≠ Q.target a) + (w : List V) (x : FiniteHomotopyClass Q (K := K)) (U : Set V) + (hw : ∀ α, α ∈ w ↔ α ∈ U) (m : ℤ) (h : ClassTestCochainUpper Q x U m) : + ClassTestCochainUpper Q (positiveWordAction Q w x) U (m-1) := by + have hh := (positiveWord_cochain_bounds Q hn w x U (fun α hα => (hw α).mp hα) m h).2 + exact fun α hα => hh α ((hw α).mpr hα) + +omit [Fintype V] [DecidableEq A] in +lemma scalarExact_of_absent_cochain {I : Type} [Fintype I] [DecidableEq I] + (E : BasedComplex Q (K := K) I) (α : V) (l c : ℤ) + (h : ∀ i, (E.placement i).cochain ≠ c) : ScalarExactAt Q E α l c := by + intro x hx _ + have hz : x = 0 := by + funext i + exact hx i (fun hi => h i hi.2) + refine ⟨0, fun _ _ => rfl, ?_⟩ + rw [Matrix.zero_vecMul, hz] + +/-- Every bounded family admits an ordinary cochain upper bound. -/ +theorem classTestCochainUpper_exists (x : FiniteHomotopyClass Q (K := K)) (U : Set V) : + ∃ m : ℤ, ClassTestCochainUpper Q x U m := by + induction x using Quotient.inductionOn with + | _ E => + obtain ⟨m, hm⟩ := Finite.bddAbove_range (fun i : E.Index => (E.complex.placement i).cochain) + refine ⟨m, ?_⟩ + intro α _ l c hc + change ScalarExactAt Q (E.complex.testComplex Q α) α l c + apply scalarExact_of_absent_cochain Q + intro i hi + have hle := hm (Set.mem_range_self i.1) + change (E.complex.placement i.1).cochain = c at hi + omega + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalCommonExtension.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalCommonExtension.lean new file mode 100644 index 0000000000000000000000000000000000000000..db620292e1fe4f07ef34aa1ee6030547f83b19e5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalCommonExtension.lean @@ -0,0 +1,101 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ReducedPositiveExtension +import OAI.Topology.ArtinGroups.ParabolicIntersections.FoldingGcdInput +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedFamily +import OAI.Topology.ArtinGroups.Harmonic.ArtinActionWordArtin + +namespace OAI + +/-! Common positive extensions with the actual total test-height bound. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "hn" => fusionQuiver_no_loops m (coxeterFusionEdge M) + (coxeterFusionEdge_symm M) (coxeterFusionEdge_diag M) + +noncomputable def restrictedPointedFamily (Y : Set S) (x : Artin M) + (a : Artin (restrictedMatrix M Y)) : PointedFamilySpace M := + pointedFamily M f (restrictedArtinHom M Y a*x) + +lemma restrictedPointedFamily_word (Y : Set S) (x : Artin M) + (u : List Y) (a : Artin (restrictedMatrix M Y)) (L : PointedLabel M) : + restrictedPointedFamily M f Y x (positiveToArtin _ (wordPositive _ u)*a) L = + positiveWordAction Q + (fusionExpandedWord m (u.map fun j : Y => (Sum.inl (j:S) : S⊕Unit))) + (restrictedPointedFamily M f Y x a L) := by + unfold restrictedPointedFamily pointedFamily + rw [positiveToArtin_word, map_mul (restrictedArtinHom M Y), + restrictedArtinHom_word, _root_.mul_assoc] + rw [map_mul, Equiv.Perm.mul_apply] + simpa only [pointedAction, List.map_map, Function.comp_def] using + sourceArtinAction_positiveWord M (u.map Subtype.val) + (pointedAction M (restrictedArtinHom M Y a*x) (pointedInitial M f L)) + +private lemma testUpper_eventually (x : FiniteHomotopyClass Q (K := ℂ)) + (U : Set (FusionVertex (V := S⊕Unit) m)) (t : ℤ) : + ∃ n : ℕ, ClassTestUpper Q x U (t+n) := by + obtain ⟨b,hb⟩ := Finite.bddAbove_range (fun i : (minimalClassModel Q x).Index => + ((minimalClassModel Q x).complex.placement i).level) + have h := classTestUpper_of_generator_cap Q x b (fun i => hb (Set.mem_range_self i)) U + refine ⟨(b+2-t).toNat, ?_⟩ + intro α hα l hl c + apply h α hα l _ c + have : b+2-t ≤ ((b+2-t).toNat : ℤ) := by omega + omega + +/-- Lemma 7.5: a common positive left extension preserves a common bound +on the total test heights. Only published admissible-folding gcd +preservation is assumed; the top-test argument is proved here. -/ +theorem spherical_common_extension (Y : Set S) (hY : IsSpherical M Y) + (hGcd : PublishedFoldingGcd M Y hY) (x : Artin M) + (a b : Artin (restrictedMatrix M Y)) (t : ℤ) + (ha : ∀ L, ClassTestUpper Q (restrictedPointedFamily M f Y x a L) + (Set.range (unfoldedInclusion M Y)) t) + (hb : ∀ L, ClassTestUpper Q (restrictedPointedFamily M f Y x b L) + (Set.range (unfoldedInclusion M Y)) t) : + ∃ p q : PositiveArtin (restrictedMatrix M Y), + positiveToArtin _ p*a=positiveToArtin _ q*b ∧ + ∀ L, ClassTestUpper Q + (restrictedPointedFamily M f Y x (positiveToArtin _ p*a) L) + (Set.range (unfoldedInclusion M Y)) t := by + obtain ⟨p,q,he,hdisjoint⟩ := spherical_reduced_positive_extension M Y hY a b + refine ⟨p,q,he,?_⟩ + intro L + by_contra hbad + obtain ⟨u,rfl⟩ := positive_word_surjective _ p + obtain ⟨v,rfl⟩ := positive_word_surjective _ q + let z := restrictedPointedFamily M f Y x (positiveToArtin _ (wordPositive _ u)*a) L + let U := Set.range (unfoldedInclusion M Y) + obtain ⟨l,hl,hcap,α,hα,c,hnot⟩ := exists_top_test Q z U t + (testUpper_eventually M z U t) hbad + have hletters (w : List Y) : ∀ β ∈ fusionExpandedWord m + (w.map fun j : Y => (Sum.inl (j:S) : S⊕Unit)), β ∈ U := by + intro β hβ + have h : β.1 ∈ w.map (fun j : Y => (Sum.inl (j:S) : S⊕Unit)) := + fusionExpandedWord_mem m _ β hβ + obtain ⟨i,_,hi⟩ := List.mem_map.mp h + exact ⟨(i,β.2), Prod.ext hi rfl⟩ + have hzU : z=positiveWordAction Q + (fusionExpandedWord m (u.map fun j : Y => (Sum.inl (j:S) : S⊕Unit))) + (restrictedPointedFamily M f Y x a L) := restrictedPointedFamily_word M f Y x u a L + have hzV : z=positiveWordAction Q + (fusionExpandedWord m (v.map fun j : Y => (Sum.inl (j:S) : S⊕Unit))) + (restrictedPointedFamily M f Y x b L) := by + change restrictedPointedFamily M f Y x (positiveToArtin _ (wordPositive _ u)*a) L = _ + rw [he] + exact restrictedPointedFamily_word M f Y x v b L + obtain ⟨r,hr⟩ := positive_top_divisor Q hn U (unfolded_full_simply_laced M Y hY) + (restrictedPointedFamily M f Y x a L) t (ha L) _ (hletters u) α hα l hl + (hzU ▸ hcap) c (hzU ▸ hnot) + obtain ⟨s,hs⟩ := positive_top_divisor Q hn U (unfolded_full_simply_laced M Y hY) + (restrictedPointedFamily M f Y x b L) t (hb L) _ (hletters v) α hα l hl + (hzV ▸ hcap) c (hzV ▸ hnot) + obtain ⟨i,hi⟩ := hGcd.common_atom u v α r s hr hs + exact hdisjoint i hi + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalGap.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalGap.lean new file mode 100644 index 0000000000000000000000000000000000000000..da5ca831520e424de99f7eda8a996849ea2b5a2a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalGap.lean @@ -0,0 +1,88 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.EmptyPlacement +import OAI.Topology.ArtinGroups.ParabolicIntersections.SphericalCochain +import OAI.Topology.ArtinGroups.ParabolicIntersections.ConnectedSupport + +namespace OAI + +/-! The gap contradiction in Proposition 7.4 of paper 082-03. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) [Fintype V] [Fintype A] + {I : Type} [Fintype I] + +/-- A missing cochain placement separates every generator below it from +all generators above it. The actual endomorphism dimension rules out +such a separation for a transported indecomposable projective. -/ +lemma no_cochain_gap (E : BasedComplex Q (K := ℂ) I) (hE : E.IsMinimal Q) + (hd : homDimension Q E E 0 0 ≤ 1) (r : ℤ) + (hgap : ∀ i, (E.placement i).cochain ≠ r) + (i j : I) (hi : (E.placement i).cochain < r) + (hj : r < (E.placement j).cochain) : False := by + apply no_proper_block Q E hE hd {k | (E.placement k).cochain < r} _ i j hi (not_lt.mpr hj.le) + intro a b hab + have hc : (E.placement b).cochain = (E.placement a).cochain+1 := by + by_contra hn + exact hab ((E.degree a b).1 hn) + change (E.placement a).cochain < r ↔ (E.placement b).cochain < r + have ha := hgap a + have hb := hgap b + omega + +/-- Once the cochain tests have moved below the fixed exterior and the +path bound forces a gap, all tests vanish. This is the contradiction +used in the bounded-positive-height argument. -/ +theorem tests_exact_of_empty_gap (U : Set V) (E : BasedComplex Q (K := ℂ) I) + (hE : E.IsMinimal Q) (hd : homDimension Q E E 0 0 ≤ 1) + (l r : ℤ) (hlr : l ≤ r) + (hgap : ∀ i, (E.placement i).cochain ≠ r) + (j : I) (hj : r < (E.placement j).cochain) + (hex : ∀ α ∈ U, ∀ d c, l ≤ c → ScalarExactAt Q (E.testComplex Q α) α d c) : + ∀ α ∈ U, ∀ d c, ScalarExactAt Q (E.testComplex Q α) α d c := by + intro α hα d c + by_cases hc : l ≤ c + · exact hex α hα d c hc + · apply scalarExact_of_absent_cochain Q + intro i hi + change (E.placement i.1).cochain = c at hi + exact (no_cochain_gap Q E hE hd r hgap i.1 j (by omega) hj).elim + +/-- The quantitative form of Proposition 7.4: with fixed generator-level +bounds and a fixed exterior lower placement, nonzero tests cannot all +move arbitrarily far down in cochain degree. -/ +theorem cochain_lower_obstruction_of_mesh (U : Set V) (hmesh : MeshNilpotent Q U) : + ∃ N : ℕ, 0 < N ∧ ∀ (I : Type) [Fintype I] (E : BasedComplex Q (K := ℂ) I), + E.IsMinimal Q → homDimension Q E E 0 0 ≤ 1 → + ∀ d₁ d₂ p : ℤ, d₁ ≤ d₂ → + (∀ i, d₁ ≤ (E.placement i).level ∧ (E.placement i).level ≤ d₂) → + (∀ i, (E.placement i).color ∉ U → p ≤ (E.placement i).cochain) → + (∃ j, p ≤ (E.placement j).cochain) → + (∀ α ∈ U, ∀ d c, p-1-N*(d₂-d₁+1) ≤ c → + ScalarExactAt Q (E.testComplex Q α) α d c) → + ∀ α ∈ U, ∀ d c, ScalarExactAt Q (E.testComplex Q α) α d c := by + obtain ⟨N, hN, hgap⟩ := empty_placement_of_mesh Q U hmesh + refine ⟨N, hN, ?_⟩ + intro J _ E hE hd d₁ d₂ p hdd hlevels hout hj hex + let r := p-1 + let l := r-N*(d₂-d₁+1) + have hNl : (0 : ℤ) ≤ N*(d₂-d₁+1) := mul_nonneg (Int.natCast_nonneg N) (by omega) + have hlr : l ≤ r := by dsimp only [l]; omega + have hempty : ∀ i, (E.placement i).cochain ≠ r := by + intro i hi + apply hgap J E hE l r d₁ d₂ hdd hlevels + (fun k hk hkr => by + by_contra hn + have := hout k hn + dsimp only [r] at hkr + omega) + (fun α hα c hc _ d => hex α hα d c hc) i + · dsimp only [l] at * + omega + · omega + obtain ⟨j, hj⟩ := hj + apply tests_exact_of_empty_gap Q U E hE hd l r hlr hempty j (by dsimp only [r]; omega) + exact hex + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalMesh.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalMesh.lean new file mode 100644 index 0000000000000000000000000000000000000000..e66827b59599563f78e18e6e91816c8ce174d15a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalMesh.lean @@ -0,0 +1,113 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshQuiverAlgebra +import OAI.Topology.ArtinGroups.Harmonic.UnfoldedInclusionRange +import OAI.Topology.ArtinGroups.Harmonic.SphericalFoldedMatrix + +namespace OAI + +/-! Discharging the finite spherical mesh input for the actual fusion quiver. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "U" => (fun Y : Set S => fusionColorRegion (V := S⊕Unit) m (Sum.inl '' Y)) + +noncomputable def sphericalRegionEquiv (Y : Set S) : + (Y × FusionLabel m) ≃ U Y := + (Equiv.ofInjective (unfoldedInclusion M Y) (unfoldedInclusion_injective M Y)).trans + (Set.equivOfEq (unfoldedInclusion_range M Y)) + +omit [Fintype S] in +lemma sphericalRegionEquiv_val (Y : Set S) (a : Y × FusionLabel m) : + (sphericalRegionEquiv M Y a).val=unfoldedInclusion M Y a := rfl + +omit [Fintype S] in +lemma sphericalRegionEquiv_symm_val (Y : Set S) (u : U Y) : + unfoldedInclusion M Y ((sphericalRegionEquiv M Y).symm u)=u.val := by + exact congrArg Subtype.val ((sphericalRegionEquiv M Y).apply_symm_apply u) + +lemma spherical_mesh_simple (Y : Set S) (hY : IsSpherical M Y) : QuiverSimpleOn Q (U Y) := by + rintro ⟨⟨s,t⟩,i⟩ ⟨⟨s',t'⟩,j⟩ hs ht he₁ he₂ + change s=s' at he₁ + change t=t' at he₂ + subst s' + subst t' + change s∈U Y at hs + change t∈U Y at ht + obtain ⟨a,ha⟩ : ∃ a : Y × FusionLabel m, unfoldedInclusion M Y a=s := by + change s∈Set.range (unfoldedInclusion M Y) + rw [unfoldedInclusion_range M Y] + exact hs + obtain ⟨b,hb⟩ : ∃ b : Y × FusionLabel m, unfoldedInclusion M Y b=t := by + change t∈Set.range (unfoldedInclusion M Y) + rw [unfoldedInclusion_range M Y] + exact ht + have hmult : (coxeterFusionEdge M s.1 t.1).multiplicity m s.2 t.2≤1 := by + rw [←ha,←hb] + exact spherical_fusion_multiplicity_le_one M Y hY a.1 b.1 a.2 b.2 + have hi := i.isLt + have hj := j.isLt + change i.val<(coxeterFusionEdge M s.1 t.1).multiplicity m s.2 t.2 at hi + change j.val<(coxeterFusionEdge M s.1 t.1).multiplicity m s.2 t.2 at hj + congr 1 + apply Fin.ext + omega + +lemma fusion_mesh_arrow_exists (u v : FusionVertex (V := S⊕Unit) m) : + (∃ a, (Q).source a=u ∧ (Q).target a=v) ↔ + 0<(coxeterFusionEdge M u.1 v.1).multiplicity m u.2 v.2 := by + constructor + · rintro ⟨⟨⟨s,t⟩,i⟩,hs,ht⟩ + change s=u at hs + change t=v at ht + subst s + subst t + exact lt_of_le_of_lt (Nat.zero_le i.val) i.isLt + · intro h + exact ⟨⟨(u,v),⟨0,h⟩⟩,rfl,rfl⟩ + +theorem spherical_mesh_cartan (Y : Set S) (hY : IsSpherical M Y) : + let _ : DecidableEq (U Y) := Classical.decEq _ + ((2 : ℝ) • (1 : Matrix (U Y) (U Y) ℝ)- + (meshQuiverGraph Q (U Y) (fusionQuiver_no_loops _ _ _ (coxeterFusionEdge_diag M))).adjMatrix ℝ).PosDef := by + let : DecidableEq (U Y) := Classical.decEq _ + let e := sphericalRegionEquiv M Y + have hp := (spherical_unfolded_posDef M Y hY).submatrix e.symm.injective + convert hp using 1 + ext u v + let a := e.symm u + let b := e.symm v + have hu : unfoldedInclusion M Y a=u.val := sphericalRegionEquiv_symm_val M Y u + have hv : unfoldedInclusion M Y b=v.val := sphericalRegionEquiv_symm_val M Y v + have hadj : (meshQuiverGraph Q (U Y) + (fusionQuiver_no_loops _ _ _ (coxeterFusionEdge_diag M))).Adj u v ↔ + 0<(coxeterFusionEdge M (.inl a.1) (.inl b.1)).multiplicity m a.2 b.2 := by + change (∃ c, (Q).source c=u.val ∧ (Q).target c=v.val) ↔ _ + rw [←hu,←hv,fusion_mesh_arrow_exists] + have hn := spherical_fusion_multiplicity_le_one M Y hY a.1 b.1 a.2 b.2 + change ((2 : ℝ) • (1 : Matrix (U Y) (U Y) ℝ)- + (meshQuiverGraph Q (U Y) (fusionQuiver_no_loops _ _ _ (coxeterFusionEdge_diag M))).adjMatrix ℝ) u v= + fusionUnfoldedCartan m (fun i j : Y => coxeterFusionEdge M (.inl i) (.inl j)) a b + by_cases huv : u=v + · subst v + change ((2 : ℝ) • (1 : Matrix (U Y) (U Y) ℝ)- + (meshQuiverGraph Q (U Y) (fusionQuiver_no_loops _ _ _ (coxeterFusionEdge_diag M))).adjMatrix ℝ) u u= + fusionUnfoldedCartan m (fun i j : Y => coxeterFusionEdge M (.inl i) (.inl j)) a a + simp [fusionUnfoldedCartan,coxeterFusionEdge_diag,FusionEdge.multiplicity] + · have hab : a≠b := fun h => huv (e.symm.injective h) + have hm : (coxeterFusionEdge M (.inl a.1) (.inl b.1)).multiplicity m a.2 b.2=0 ∨ + (coxeterFusionEdge M (.inl a.1) (.inl b.1)).multiplicity m a.2 b.2=1 := by omega + rcases hm with hm|hm <;> + simp [SimpleGraph.adjMatrix_apply,hadj,hm,huv, + fusionUnfoldedCartan,hab] + +/-- The finite-Dynkin mesh nilpotence input for every spherical set of +colors, proved for the precise ambient fusion-quiver relations. -/ +theorem spherical_mesh_nilpotent (Y : Set S) (hY : IsSpherical M Y) : MeshNilpotent Q (U Y) := by + apply meshNilpotent_of_positive_cartan Q (U Y) + (fusionQuiver_no_loops _ _ _ (coxeterFusionEdge_diag M)) (spherical_mesh_simple M Y hY) + exact spherical_mesh_cartan M Y hY + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalNoChain.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalNoChain.lean new file mode 100644 index 0000000000000000000000000000000000000000..8b40a055a70837a382c0cb13097c129af4cfbde3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalNoChain.lean @@ -0,0 +1,177 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.SphericalGap +import OAI.Topology.ArtinGroups.Complexes.PositiveWordLowerBound +import OAI.Topology.ArtinGroups.Complexes.InverseWordAction + +namespace OAI + +/-! Bounded total height forbids infinitely many complete positive passes. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) [Fintype V] [Fintype A] + [DecidableEq V] [DecidableEq A] + +lemma positiveWord_generator_exterior (w : List V) (x : FiniteHomotopyClass Q (K := ℂ)) + (U : Set V) (hw : ∀ v ∈ w, v ∈ U) (p : GeneratorPlacement V) (hp : p.color ∉ U) : + classGeneratorArray Q (positiveWordAction Q w x) p = classGeneratorArray Q x p := by + induction w with + | nil => rfl + | cons v w ih => + change classGeneratorArray Q (classPositiveTwist Q v (positiveWordAction Q w x)) p = _ + rw [classPositiveTwist_exterior Q _ v p (fun he => hp (he ▸ hw v (by simp)))] + exact ih (fun a ha => hw a (List.mem_cons_of_mem v ha)) + +lemma classPositiveTwist_outside_placement (x : FiniteHomotopyClass Q (K := ℂ)) + (U : Set V) (v : V) (hv : v ∈ U) (P : GeneratorPlacement V → Prop) + (h : ∀ i, ((minimalClassModel Q x).complex.placement i).color ∉ U → + P ((minimalClassModel Q x).complex.placement i)) : + ∀ i, ((minimalClassModel Q (classPositiveTwist Q v x)).complex.placement i).color ∉ U → + P ((minimalClassModel Q (classPositiveTwist Q v x)).complex.placement i) := by + let E := minimalClassModel Q x + let F := E.complex.positiveTwist Q v + have hx : classOfComplex Q F = classPositiveTwist Q v x := by + change classPositiveTwist Q v (classOfComplex Q E.complex) = _ + exact congrArg (classPositiveTwist Q v) (minimalClassModel_class Q x) + rw [← hx] + apply minimal_bound_transport Q F _ (minimalClassModel_minimal Q _) + (minimalClassModelEquivalence Q F).symm (fun p => p.color ∉ U → P p) + intro i hi + rcases i with i | i + · exact (hi hv).elim + · exact h i hi + +lemma positiveWord_outside_placement (w : List V) (x : FiniteHomotopyClass Q (K := ℂ)) + (U : Set V) (hw : ∀ v ∈ w, v ∈ U) (P : GeneratorPlacement V → Prop) + (h : ∀ i, ((minimalClassModel Q x).complex.placement i).color ∉ U → + P ((minimalClassModel Q x).complex.placement i)) : + ∀ i, ((minimalClassModel Q (positiveWordAction Q w x)).complex.placement i).color ∉ U → + P ((minimalClassModel Q (positiveWordAction Q w x)).complex.placement i) := by + induction w with + | nil => exact h + | cons v w ih => + exact classPositiveTwist_outside_placement Q _ U v (hw v (by simp)) P + (ih (fun a ha => hw a (List.mem_cons_of_mem v ha))) + +lemma positiveWord_allTests_reflect (hn : ∀ a, Q.source a ≠ Q.target a) + (w : List V) (x : FiniteHomotopyClass Q (K := ℂ)) (U : Set V) + (hw : ∀ v ∈ w, v ∈ U) + (h : ∀ α ∈ U, ∀ l c, ClassTestExact Q α l c (positiveWordAction Q w x)) : + ∀ α ∈ U, ∀ l c, ClassTestExact Q α l c x := by + have href : ∀ t, ClassTestUpper Q (positiveWordAction Q w x) U t → + ClassTestUpper Q x U t := by + clear h + intro t + induction w with + | nil => exact id + | cons v w ih => + intro ht + exact ih (fun a ha => hw a (List.mem_cons_of_mem v ha)) + (classPositiveTwist_testUpper_reflect Q hn _ U v (hw v (by simp)) ht) + intro α hα l c + exact href (l-1) (fun β hβ k _ d => h β hβ k d) α hα l (by omega) c + +omit [Fintype V] [DecidableEq A] in +lemma generatorArray_positive_iff (x : FiniteHomotopyClass Q (K := ℂ)) + (p : GeneratorPlacement V) : + 0 < classGeneratorArray Q x p ↔ ∃ i : (minimalClassModel Q x).Index, + (minimalClassModel Q x).complex.placement i = p := by + have he := congrArg (fun a => a p) + (classGeneratorArray_of_minimal Q (minimalClassModel Q x) (minimalClassModel_minimal Q x)) + rw [minimalClassModel_class Q x] at he + rw [he, generatorArray_apply] + change 0 < Nat.card {i : (minimalClassModel Q x).Index // + (minimalClassModel Q x).complex.placement i = p} ↔ _ + rw [Nat.card_eq_fintype_card, Fintype.card_pos_iff] + exact nonempty_subtype + +/-- Proposition 7.4 for actual positive vertex operations. The only +published input is the abstract mesh-algebra path identity. -/ +theorem no_bounded_complete_positive_chain (hn : ∀ a, Q.source a ≠ Q.target a) + (U : Set V) (hmesh : MeshNilpotent Q U) + (x : ℕ → FiniteHomotopyClass Q (K := ℂ)) (w : ℕ → List V) + (hstep : ∀ n, x (n+1) = positiveWordAction Q (w n) (x n)) + (hw : ∀ n v, v ∈ w n ↔ v ∈ U) + (hdim : classHomDimension Q 0 0 (x 0) (x 0) ≤ 1) + (hframe : ∃ p : GeneratorPlacement V, p.color ∉ U ∧ 0 < classGeneratorArray Q (x 0) p) + (hnonzero : ¬ ∀ α ∈ U, ∀ l c, ClassTestExact Q α l c (x 0)) + (t : ℤ) (ht : ∀ n, ClassTestUpper Q (x n) U t) : False := by + cases Subsingleton.elim (inferInstance : DecidableEq V) (Classical.decEq V) + cases Subsingleton.elim (inferInstance : DecidableEq A) (Classical.decEq A) + obtain ⟨frame, hframeU, hframe⟩ := hframe + obtain ⟨d₁, hd₁⟩ := Finite.bddBelow_range + (fun i : (minimalClassModel Q (x 0)).Index => + ((minimalClassModel Q (x 0)).complex.placement i).level) + obtain ⟨b, hb⟩ := Finite.bddAbove_range + (fun i : (minimalClassModel Q (x 0)).Index => + ((minimalClassModel Q (x 0)).complex.placement i).level) + obtain ⟨p, hp⟩ := Finite.bddBelow_range + (fun i : (minimalClassModel Q (x 0)).Index => + ((minimalClassModel Q (x 0)).complex.placement i).cochain) + obtain ⟨m, hm⟩ := classTestCochainUpper_exists Q (x 0) U + let d₂ := max b (t-2) + have hstate : ∀ n, + ClassLowerBound Q d₁ (x n) ∧ ClassOutsideCap Q (x n) U d₂ ∧ + (∀ i, ((minimalClassModel Q (x n)).complex.placement i).color ∉ U → + p ≤ ((minimalClassModel Q (x n)).complex.placement i).cochain) ∧ + classGeneratorArray Q (x n) frame = classGeneratorArray Q (x 0) frame ∧ + classHomDimension Q 0 0 (x n) (x n) ≤ 1 ∧ + ClassTestCochainUpper Q (x n) U (m-n) ∧ + ¬ (∀ α ∈ U, ∀ l c, ClassTestExact Q α l c (x n)) := by + intro n + induction n with + | zero => + refine ⟨fun i => hd₁ (Set.mem_range_self i), + fun i _ => (hb (Set.mem_range_self i)).trans (le_max_left _ _), + fun i _ => hp (Set.mem_range_self i), rfl, hdim, ?_, hnonzero⟩ + simpa only [Int.natCast_zero, sub_zero] using hm + | succ n ih => + rw [hstep n] + refine ⟨positiveWord_lower_bound Q _ _ ih.1, + positiveWord_outside_cap Q _ _ U d₂ (fun a ha => (hw n a).mp ha) ih.2.1, + positiveWord_outside_placement Q _ _ U (fun a ha => (hw n a).mp ha) + (fun q => p ≤ q.cochain) ih.2.2.1, + (positiveWord_generator_exterior Q _ _ U (fun a ha => (hw n a).mp ha) + frame hframeU).trans ih.2.2.2.1, ?_, ?_, ?_⟩ + · rw [positiveWord_homDimension Q hn] + exact ih.2.2.2.2.1 + · have hh := positiveWord_complete_cochain_drop Q hn (w n) (x n) U (hw n) + (m-n) ih.2.2.2.2.2.1 + convert hh using 1 + push_cast + ring + · intro h + exact ih.2.2.2.2.2.2 (positiveWord_allTests_reflect Q hn _ _ U + (fun a ha => (hw n a).mp ha) h) + have hupper (n : ℕ) : ClassUpperBound Q d₂ (x n) := by + apply classUpperBound_of_test_and_outside Q _ U d₂ _ (hstate n).2.1 + intro α hα l hl c + exact ht n α hα l (by have := le_max_right b (t-2); dsimp only [d₂] at hl; omega) c + obtain ⟨j₀, hj₀⟩ := (generatorArray_positive_iff Q (x 0) frame).mp hframe + have hdd : d₁ ≤ d₂ := (hstate 0).1 j₀ |>.trans (hupper 0 j₀) + obtain ⟨N, _, hbound⟩ := cochain_lower_obstruction_of_mesh Q U hmesh + let l := p-1-N*(d₂-d₁+1) + let n := (m-l+1).toNat + have hn : m-(n:ℤ) < l := by + dsimp only [n] + have : m-l+1 ≤ ((m-l+1).toNat : ℤ) := by omega + omega + have hs := hstate n + apply hs.2.2.2.2.2.2 + rw [← minimalClassModel_class Q (x n)] + apply hbound _ (minimalClassModel Q (x n)).complex (minimalClassModel_minimal Q (x n)) + (by rw [minimalClassModel_homDimension]; exact hs.2.2.2.2.1) d₁ d₂ p hdd + (fun i => ⟨hs.1 i, hupper n i⟩) hs.2.2.1 + · obtain ⟨j, hj⟩ := (generatorArray_positive_iff Q (x n) frame).mp + (by rw [hs.2.2.2.1]; exact hframe) + refine ⟨j, ?_⟩ + have hext : p ≤ frame.cochain := by + rw [← hj₀] + exact hp (Set.mem_range_self j₀) + rwa [hj] + · intro α hα d c hc + have hh := hs.2.2.2.2.2.1 α hα d c (by change l ≤ c at hc; omega) + rwa [← minimalClassModel_class Q (x n)] at hh + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalProperSupport.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalProperSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..c4781685e1273ca683181075ebaa55ea6265779c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalProperSupport.lean @@ -0,0 +1,91 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.SphericalCommonExtension +import OAI.Topology.ArtinGroups.ParabolicIntersections.PointedSphericalNoChain +import OAI.Topology.ArtinGroups.ParabolicIntersections.ProperPositiveSupport +import OAI.Topology.ArtinGroups.Harmonic.UnfoldedInclusionRange + +namespace OAI + +/-! One proper support controls every bounded-height positive continuation. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +/-- Lemma 7.6 for the actual pointed family. Both conditional inputs +concern published positive-monoid or mesh-algebra results. -/ +theorem spherical_proper_positive_support (Y : Set S) (hY : IsSpherical M Y) + (hf : f ∉ Y) (hGcd : PublishedFoldingGcd M Y hY) + (hmesh : MeshNilpotent Q (fusionColorRegion m (Sum.inl '' Y))) + (x : Artin M) (hx : x ∈ artinParabolic M {f}ᶜ) (t : ℤ) + (ht : ∀ L, ClassTestUpper Q (pointedFamily M f x L) + (Set.range (unfoldedInclusion M Y)) t) + (hnonzero : ∃ L, ¬ ∀ α ∈ Set.range (unfoldedInclusion M Y), ∀ l c, + ClassTestExact Q α l c (pointedFamily M f x L)) : + ∃ p : PositiveArtin (restrictedMatrix M Y), + (∀ L, ClassTestUpper Q (restrictedPointedFamily M f Y x (positiveToArtin _ p) L) + (Set.range (unfoldedInclusion M Y)) t) ∧ + ∃ J : Set Y, J ⊂ Set.univ ∧ ∀ b : PositiveArtin (restrictedMatrix M Y), + (∀ L, ClassTestUpper Q + (restrictedPointedFamily M f Y x (positiveToArtin _ (b*p)) L) + (Set.range (unfoldedInclusion M Y)) t) → positiveSupport _ b ⊆ J := by + let N := restrictedMatrix M Y + let fpos := positiveToArtin N + let P : PositiveArtin N → Prop := fun p => ∀ L, + ClassTestUpper Q (restrictedPointedFamily M f Y x (fpos p) L) + (Set.range (unfoldedInclusion M Y)) t + have hOne : P 1 := by + simpa only [P, fpos, map_one, restrictedPointedFamily, _root_.one_mul] using ht + have hpair (a b : PositiveArtin N) (ha : P a) (hb : P b) : + ∃ c, P c ∧ (∃ p, c=p*a) ∧ ∃ q, c=q*b := by + obtain ⟨p,q,he,hcap⟩ := spherical_common_extension M f Y hY hGcd x (fpos a) (fpos b) t ha hb + refine ⟨p*a, ?_, ⟨p,rfl⟩, q, ?_⟩ + · simpa only [P, fpos, map_mul] using hcap + · apply spherical_positiveToArtin_injective M Y hY + simpa only [fpos,map_mul] using he + have hcommon (F : Finset (PositiveArtin N)) (hF : ∀ a ∈ F, P a) : + ∃ c, P c ∧ ∀ a ∈ F, ∃ q, c=q*a := by + induction F using Finset.induction_on with + | empty => exact ⟨1,hOne,by simp⟩ + | @insert a F ha ih => + obtain ⟨c,hc,hca⟩ := ih (fun b hb => hF b (Finset.mem_insert_of_mem hb)) + obtain ⟨d,hd,⟨r,hr⟩,s,hs⟩ := hpair c a hc (hF a (Finset.mem_insert_self _ _)) + refine ⟨d,hd,?_⟩ + intro b hb + rcases Finset.mem_insert.mp hb with rfl | hb + · exact ⟨s,hs⟩ + · obtain ⟨q,hq⟩ := hca b hb + exact ⟨r*q,by rw [hr,hq,_root_.mul_assoc]⟩ + apply proper_positive_support N + (fun a b c h => spherical_positiveToArtin_injective M Y hY (by + apply mul_right_cancel (b := fpos c) + simpa only [map_mul] using congrArg fpos h)) P hOne hcommon + intro a b ha hPa hab hsupp + let u (n : ℕ) : List Y := (positive_word_surjective N (b n)).choose + have hu (n : ℕ) : wordPositive N (u n)=b n := (positive_word_surjective N (b n)).choose_spec + let z (n : ℕ) := restrictedArtinHom M Y (fpos (a n))*x + have hz0 : z 0=x := by simp only [z,ha,map_one,_root_.one_mul] + obtain ⟨L,hL⟩ := hnonzero + apply pointed_no_bounded_complete_positive_chain M f Y hf hmesh z + (fun n => (u n).map Subtype.val) (hz0.symm ▸ hx) + · intro n + dsimp only [z] + rw [hab n,map_mul,map_mul,←hu n,positiveToArtin_word,restrictedArtinHom_word,_root_.mul_assoc] + · intro n s + constructor + · intro hs + obtain ⟨i,_,rfl⟩ := List.mem_map.mp hs + exact i.property + · intro hs + refine List.mem_map.mpr ⟨⟨s,hs⟩,?_,rfl⟩ + have hi : (⟨s,hs⟩ : Y) ∈ positiveSupport N (b n) := by rw [hsupp n]; trivial + rwa [←hu n,positiveSupport_word] at hi + · simpa only [hz0,←unfoldedInclusion_range M Y] using hL + · intro n + simpa only [z,restrictedPointedFamily,unfoldedInclusion_range M Y] using hPa n L + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalReduction.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalReduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..efa655ac6408da167afb63f414a7cd77b781acbd --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/SphericalReduction.lean @@ -0,0 +1,137 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.SphericalProperSupport +import OAI.Topology.ArtinGroups.ParabolicIntersections.AcyclicTwistInput +import OAI.Topology.ArtinGroups.ParabolicIntersections.StabilizerDescent + +namespace OAI + +/-! The spherical stabilizer containment, Proposition 7.7 of paper 082-03. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (f : S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) + +lemma pointed_testUpper_exists (Y : Set S) (x : Artin M) : + ∃ t : ℤ, ∀ L, ClassTestUpper Q (pointedFamily M f x L) + (Set.range (unfoldedInclusion M Y)) t := by + have heach (L : PointedLabel M) : ∃ t : ℤ, + ClassTestUpper Q (pointedFamily M f x L) (Set.range (unfoldedInclusion M Y)) t := by + obtain ⟨b,hb⟩ := Finite.bddAbove_range (fun i : (minimalClassModel Q (pointedFamily M f x L)).Index => + ((minimalClassModel Q (pointedFamily M f x L)).complex.placement i).level) + exact ⟨b+2, classTestUpper_of_generator_cap Q _ b + (fun i => hb (Set.mem_range_self i)) _⟩ + choose b hb using heach + obtain ⟨t,ht⟩ := Finite.bddAbove_range b + refine ⟨t,?_⟩ + intro L α hα l hl c + exact hb L α hα l (lt_of_le_of_lt (ht (Set.mem_range_self L)) hl) c + +omit [Fintype S] [LinearOrder S] in +/-- Support in a subtype becomes the corresponding ambient standard subgroup. -/ +lemma positiveSupport_ambient_mem (Y : Set S) (J : Set Y) + (a : PositiveArtin (restrictedMatrix M Y)) + (ha : positiveSupport _ a ⊆ J) : + restrictedArtinHom M Y (positiveToArtin _ a) ∈ + artinParabolic M (Subtype.val '' J) := by + obtain ⟨w,rfl,hw⟩ := positiveSupport_word_exists _ a J ha + rw [positiveToArtin_word, restrictedArtinHom_word] + apply wordArtin_mem_parabolic + intro s hs + obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hs + exact ⟨i,hw i hi,rfl⟩ + +/-- The spherical case of the local rank reduction. The positive-height +argument, including its proper-support and containment steps, is proved +here. Only the indicated published categorical and monoid inputs remain. -/ +theorem spherical_reduction (Y : Set S) (hY : IsSpherical M Y) + (hf : f ∉ Y) (hGcd : PublishedFoldingGcd M Y hY) + (hmesh : MeshNilpotent Q (fusionColorRegion m (Sum.inl '' Y))) + (hAcyclic : PublishedAcyclicTwist Q) + (x : Artin M) (hx : x ∈ artinParabolic M {f}ᶜ) : + ReductionAt M (pointedInitial M f) Y x := by + rcases Classical.em (∀ L : PointedLabel M, ∀ α ∈ Set.range (unfoldedInclusion M Y), + ∀ l c : ℤ, ClassTestExact Q α l c (pointedFamily M f x L)) with hExact | hExact + · apply ReductionAt.fixed + apply le_antisymm inf_le_left + intro g hg + have hfix := pointed_standard_fixes_of_acyclic_tests M f hAcyclic Y x hExact g hg + change pointedFamily M f (g*x) = pointedFamily M f x at hfix + refine ⟨hg,?_⟩ + change (fun L => pointedAction M g (pointedAction M x (pointedInitial M f L))) = + (fun L => pointedAction M x (pointedInitial M f L)) + funext L + simpa only [pointedFamily,map_mul,Equiv.Perm.mul_apply] using congrFun hfix L + have hnonzero : ∃ L, ¬ ∀ α ∈ Set.range (unfoldedInclusion M Y), ∀ l c, + ClassTestExact Q α l c (pointedFamily M f x L) := by + exact not_forall.mp hExact + obtain ⟨t,ht⟩ := pointed_testUpper_exists M f Y x + obtain ⟨p,hp,J,hJ,hcont⟩ := + spherical_proper_positive_support M f Y hY hf hGcd hmesh x hx t ht hnonzero + let N := restrictedMatrix M Y + let fp := positiveToArtin N + let F := restrictedArtinHom M Y + let D : Set S := Subtype.val '' J + let bp := F (fp p) + have hDY : D ⊂ Y := by + refine lt_of_le_of_ne (by rintro s ⟨i,_,rfl⟩; exact i.property) ?_ + intro he + apply hJ.ne + apply Set.eq_univ_of_forall + intro i + have hi : (i:S) ∈ D := he.symm ▸ i.property + obtain ⟨j,hj,hji⟩ := hi + exact Subtype.val_injective hji ▸ hj + have hbp : bp ∈ artinParabolic M Y := by + rw [← restrictedArtinHom_range M Y] + exact ⟨fp p,rfl⟩ + apply ReductionAt.smaller D bp hDY hbp + intro g hg + have hfix : pointedFamily M f (g*x)=pointedFamily M f x := by + have hh := hg.2 + change (fun L => pointedAction M g (pointedAction M x (pointedInitial M f L))) = + (fun L => pointedAction M x (pointedInitial M f L)) at hh + funext L + simpa only [pointedFamily,map_mul,Equiv.Perm.mul_apply] using congrFun hh L + have hgY := hg.1 + rw [← restrictedArtinHom_range M Y] at hgY + obtain ⟨a,ha⟩ := hgY + have hright (z : Artin N) : + restrictedPointedFamily M f Y x (z*a)=restrictedPointedFamily M f Y x z := by + funext L + unfold restrictedPointedFamily pointedFamily + rw [map_mul F,ha,_root_.mul_assoc,map_mul (pointedAction M),Equiv.Perm.mul_apply, + map_mul (pointedAction M),Equiv.Perm.mul_apply] + simpa only [pointedFamily,map_mul,Equiv.Perm.mul_apply] using + congrArg (pointedAction M (F z)) (congrFun hfix L) + obtain ⟨r,s,he,hcap⟩ := spherical_common_extension M f Y hY hGcd x (fp p) (fp p*a) t hp + (by simpa only [hright] using hp) + have hrJ : positiveSupport N r ⊆ J := hcont r (by simpa only [map_mul] using hcap) + have hsJ : positiveSupport N s ⊆ J := by + apply hcont s + intro L + have hh := hcap L + rw [he, ← _root_.mul_assoc, hright] at hh + simpa only [map_mul] using hh + have hr := positiveSupport_ambient_mem M Y J r hrJ + have hs := positiveSupport_ambient_mem M Y J s hsJ + have heG := congrArg F he + simp only [map_mul] at heG + have ha' : F a=g := ha + rw [ha'] at heG + rw [mem_conjugate,inv_inv] + have hrewrite : bp*g*bp⁻¹=(F (fp s))⁻¹*F (fp r) := by + dsimp only [bp] + apply (mul_left_cancel_iff (a := F (fp s))).mp + calc + F (fp s) * (F (fp p)*g*(F (fp p))⁻¹) = + (F (fp s)*(F (fp p)*g))*(F (fp p))⁻¹ := by group + _ = (F (fp r)*F (fp p))*(F (fp p))⁻¹ := by rw [← heG] + _ = F (fp s)*((F (fp s))⁻¹*F (fp r)) := by group + rw [hrewrite] + exact (artinParabolic M D).mul_mem ((artinParabolic M D).inv_mem hs) hr + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/StabilizerDescent.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/StabilizerDescent.lean new file mode 100644 index 0000000000000000000000000000000000000000..22763865f975eaf905681fa970b9a724a1c114ce --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/StabilizerDescent.lean @@ -0,0 +1,119 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.Consequences + +namespace OAI + +/-! +# The rank induction in §8 of paper 082-03 + +The finite-rank induction is proved here for an actual group action. +`ReductionAt` records the three alternatives that the paper obtains from +its new relative-height arguments. It is deliberately not called a +published input: constructing these alternatives for the categorical +action is still required before this module implies the main theorem. +-/ + +namespace HarmonicArtin.ParabolicIntersections + +variable {S : Type*} (M : CoxeterMatrix S) +variable {V : Type*} [MulAction (Artin M) V] (v : V) + +/-- Stabilizer of the transported family, restricted to a standard subgroup. +For a family of homotopy classes, take `V` to be the product of the classes. -/ +def relativeStabilizer (Y : Set S) (x : Artin M) : Subgroup (Artin M) := + artinParabolic M Y ⊓ MulAction.stabilizer (Artin M) (x • v) + +@[simp] theorem mem_relativeStabilizer (Y : Set S) (x a : Artin M) : + a ∈ relativeStabilizer M v Y x ↔ + a ∈ artinParabolic M Y ∧ a • (x • v) = x • v := Iff.rfl + +theorem conjugate_stabilizer (b x : Artin M) : + conjugate b (MulAction.stabilizer (Artin M) (x • v)) = + MulAction.stabilizer (Artin M) ((b * x) • v) := by + ext a + rw [mem_conjugate, MulAction.mem_stabilizer_iff, MulAction.mem_stabilizer_iff] + rw [← smul_left_cancel_iff b] + simp only [← mul_smul, mul_assoc, mul_inv_cancel_left] + +/-- Lemma 8.1: a containing smaller parabolic removes the ambient +intersection after conjugation. -/ +theorem relativeStabilizer_conjugation (Y D : Set S) (b x : Artin M) + (hD : D ⊆ Y) (hb : b ∈ artinParabolic M Y) + (hcontain : relativeStabilizer M v Y x ≤ conjugate b⁻¹ (artinParabolic M D)) : + conjugate b (relativeStabilizer M v Y x) = relativeStabilizer M v D (b * x) := by + have hsmall : conjugate b (relativeStabilizer M v Y x) ≤ artinParabolic M D := by + have h := conjugate_mono b hcontain + simpa [← conjugate_mul] using h + have hlarge : artinParabolic M D ≤ artinParabolic M Y := standard_mono M hD + have he : conjugate b (relativeStabilizer M v Y x) = + artinParabolic M Y ⊓ MulAction.stabilizer (Artin M) ((b * x) • v) := by + rw [relativeStabilizer, conjugate_inf, conjugate_eq_self hb, conjugate_stabilizer] + apply le_antisymm + · exact le_inf hsmall (he.le.trans inf_le_right) + · rw [he] + exact inf_le_inf hlarge le_rfl + +/-- The alternatives furnished by the spherical positive-height reduction +and the nonspherical harmonic-minimum reduction. The split case expresses +the invisible direct factor, including its normalization property. -/ +inductive ReductionAt (Y : Set S) (x : Artin M) : Prop + | fixed : relativeStabilizer M v Y x = artinParabolic M Y → ReductionAt Y x + | smaller (D : Set S) (b : Artin M) : + D ⊂ Y → b ∈ artinParabolic M Y → + relativeStabilizer M v Y x ≤ conjugate b⁻¹ (artinParabolic M D) → ReductionAt Y x + | split (T K : Set S) : + T ⊂ Y → K ⊆ Y → + (∀ c ∈ artinParabolic M T, conjugate c (artinParabolic M K) = artinParabolic M K) → + relativeStabilizer M v Y x = artinParabolic M K ⊔ relativeStabilizer M v T x → + ReductionAt Y x + +variable [Finite S] + +/-- Theorem 8.2's rank induction. The genuinely new local alternatives are +an explicit premise, so this is not advertised as the completed theorem. -/ +theorem relativeStabilizers_of_reductions + (hred : ∀ (Y : Set S) (x : Artin M), ReductionAt M v Y x) + (Y : Set S) (x : Artin M) : + ∃ (R : Set S) (c : Artin M), R ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + relativeStabilizer M v Y x = conjugate c⁻¹ (artinParabolic M R) := by + suffices h : ∀ n : ℕ, ∀ Y : Set S, Y.ncard = n → ∀ x : Artin M, + ∃ (R : Set S) (c : Artin M), R ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + relativeStabilizer M v Y x = conjugate c⁻¹ (artinParabolic M R) from h _ Y rfl x + intro n + induction n using Nat.strong_induction_on with + | h n ih => + intro Y hY x + rcases hred Y x with hfixed | ⟨D, b, hD, hb, hcontain⟩ | ⟨T, K, hT, hK, hnorm, hsplit⟩ + · refine ⟨Y, 1, Set.Subset.rfl, (artinParabolic M Y).one_mem, ?_⟩ + simpa using hfixed + · have hlt : D.ncard < n := hY ▸ Set.ncard_lt_ncard hD + obtain ⟨R, c, hRD, hc, he⟩ := ih _ hlt D rfl (b * x) + have hconj := relativeStabilizer_conjugation M v Y D b x hD.subset hb hcontain + have heq := congrArg (conjugate b⁻¹) (hconj.trans he) + refine ⟨R, c * b, hRD.trans hD.subset, + (artinParabolic M Y).mul_mem (standard_mono M hD.subset hc) hb, ?_⟩ + simpa only [← conjugate_mul, inv_mul_cancel, conjugate_one, mul_inv_rev] using heq + · have hlt : T.ncard < n := hY ▸ Set.ncard_lt_ncard hT + obtain ⟨R, c, hRT, hc, he⟩ := ih _ hlt T rfl x + have hn := hnorm c⁻¹ ((artinParabolic M T).inv_mem hc) + refine ⟨K ∪ R, c, Set.union_subset hK (hRT.trans hT.subset), + standard_mono M hT.subset hc, ?_⟩ + rw [hsplit, he, standard_union, conjugate_sup, hn] + +/-- Once the relative categorical action has its initial stabilizer and +local reductions, its stabilizer induction gives the inside intersection. +Neither of those new categorical assertions is installed as an axiom. -/ +theorem inside_at_of_action_reductions (X Y : Set S) (g : Artin M) + (hinit : MulAction.stabilizer (Artin M) v = artinParabolic M X) + (hred : ∀ (D : Set S) (x : Artin M), ReductionAt M v D x) : + ∃ (R : Set S) (c : Artin M), R ⊆ Y ∧ c ∈ artinParabolic M Y ∧ + artinParabolic M Y ⊓ conjugate g (artinParabolic M X) = + conjugate c (artinParabolic M R) := by + obtain ⟨R, c, hR, hc, he⟩ := relativeStabilizers_of_reductions M v hred Y g + refine ⟨R, c⁻¹, hR, (artinParabolic M Y).inv_mem hc, ?_⟩ + have hg := conjugate_stabilizer M v g 1 + simp only [one_smul, mul_one, hinit] at hg + simpa only [relativeStabilizer, ← hg] using he + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/StandardEmbedding.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/StandardEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..8acb26e173756365bbc4db013bfbbbe4f52fb66c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/StandardEmbedding.lean @@ -0,0 +1,91 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicRetractionAction +import OAI.Topology.ArtinGroups.Coxeter.ArtinCoxeter + +namespace OAI + +/-! Injectivity of every finite-rank standard Artin parabolic. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange Geometric +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (J : Set S) +local notation "cs" => M.toCoxeterSystem +local notation "R" => restrictedMatrix M J + +omit [Fintype S] in +private lemma component_of_parabolic (w : M.Group) (hw : w ∈ parabolic cs J) : + parabolicComponent cs J w=w := by + have hmin : IsParabolicMinimum cs J (1 : M.Group) := by + intro a _ + simp only [(cs).length_one,mul_one] + exact Nat.zero_le _ + have hr : parabolicRep cs J w=1 := + parabolicRep_eq_of_decomposition cs J w w 1 hw hmin (mul_one w).symm + simp only [parabolicComponent,hr,inv_one,mul_one] + +lemma parabolicStepLetter_standard (w : M.Group) (hw : w ∈ parabolic cs J) (s : J) : + parabolicStepLetter cs J w s=some s := by + have hws : w*(cs).simple s ∈ parabolic cs J := + (parabolic cs J).mul_mem hw (simple_mem_parabolic cs J s.property) + have hv := parabolicStepLetter_value cs J w s + unfold parabolicStepRatio at hv + rw [component_of_parabolic M J w hw,component_of_parabolic M J _ hws,inv_mul_cancel_left] at hv + cases hl : parabolicStepLetter cs J w s with + | none => + rw [hl] at hv + change 1=(cs).simple s at hv + have hh := congrArg (cs).length hv + rw [(cs).length_one,(cs).length_simple] at hh + omega + | some t => + rw [hl] at hv + have he : t=s := Subtype.ext (simple_injective cs hv) + exact congrArg some he + +noncomputable def parabolicState (a : Artin R) : M.Group × Artin R := + (restrictionHom M J (artinCoxeter R a),a) + +/-- On the standard parabolic, the gallery action is its right regular action. -/ +theorem parabolicRetractionAction_standard (g a : Artin R) : + MulOpposite.unop (parabolicRetractionAction M J (restrictedArtinHom M J g)) + (parabolicState M J a)=parabolicState M J (a*g) := by + let f := (parabolicRetractionAction M J).comp (restrictedArtinHom M J) + have hg : g ∈ Subgroup.closure (Set.range (generator R)) := by + rw [show Subgroup.closure (Set.range (generator R))=⊤ from + PresentedGroup.closure_range_of (braidRelators R)] + trivial + change MulOpposite.unop (f g) (parabolicState M J a)=_ + induction hg using Subgroup.closure_induction generalizing a with + | mem x hx => + obtain ⟨s,rfl⟩ := hx + have hw : restrictionHom M J (artinCoxeter R a) ∈ parabolic cs J := + restrictionHom_mem_parabolic M J _ + simp only [f,MonoidHom.comp_apply,restrictedArtinHom_generator, + parabolicRetractionAction_generator] + change (restrictionHom M J (artinCoxeter R a)*(cs).simple s, + a*parabolicStepArtin M J (restrictionHom M J (artinCoxeter R a)) s)=_ + rw [parabolicStepArtin,parabolicStepLetter_standard M J _ hw] + simp only [Option.toList_some,wordArtin,List.map_cons,List.map_nil,List.prod_cons,List.prod_nil,mul_one, + parabolicState,map_mul,artinCoxeter_generator,restrictionHom_simple] + | one => simp only [map_one,MulOpposite.unop_one,Equiv.Perm.one_apply,mul_one] + | mul x y hx hy ihx ihy => + rw [map_mul,MulOpposite.unop_mul] + change MulOpposite.unop (f y) (MulOpposite.unop (f x) (parabolicState M J a))=_ + rw [ihx,ihy,mul_assoc] + | inv x hx ih => + rw [map_inv,MulOpposite.unop_inv] + change (MulOpposite.unop (f x)).symm (parabolicState M J a)=_ + apply (MulOpposite.unop (f x)).injective + simp only [Equiv.apply_symm_apply,ih,inv_mul_cancel_right] + +/-- Van der Lek's standard-parabolic injectivity theorem in finite rank, +proved from the Coxeter retraction and the Artin braid presentation. -/ +theorem standardArtinEmbedding : Function.Injective (restrictedArtinHom M J) := by + apply (injective_iff_map_eq_one _).mpr + intro g hg + have ha := parabolicRetractionAction_standard M J g 1 + rw [hg,map_one,MulOpposite.unop_one,Equiv.Perm.one_apply,one_mul] at ha + exact (congrArg Prod.snd ha).symm + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TokenBoundary.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TokenBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..c18a769f1730a03834aafde54b0b7cdfa6f2d674 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TokenBoundary.lean @@ -0,0 +1,95 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.CoefficientPaths +import OAI.Topology.ArtinGroups.Quivers.TokenTestVector +import OAI.Topology.ArtinGroups.Complexes.GeneratorTokenTest + +namespace OAI + +/-! Exact vertex tests express a generator through incoming coefficients. -/ +namespace HarmonicArtin.ParabolicIntersections +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V A : Type} (Q : ReversibleQuiver V A) [Fintype V] [Fintype A] + {I : Type} [Fintype I] + +/-- A boundary for the token of a generator, retaining the precise source +level and cochain support. This is the first step of Lemma 7.3. -/ +theorem generator_token_boundary (E : BasedComplex Q (K := ℂ) I) (hE : E.IsMinimal Q) + (i : I) (hex : ScalarExactAt Q (E.testComplex Q (E.placement i).color) + (E.placement i).color ((E.placement i).level + 2) (E.placement i).cochain) : + ∃ y : TestIndex Q E.placement (E.placement i).color → ℂ, + (∀ u, y u ≠ 0 → (E.placement u.1).cochain = (E.placement i).cochain - 1 ∧ + (E.placement u.1).level + Path.length u.2.val = (E.placement i).level + 1) ∧ + ∀ j : I, (Pi.single i (1 : ℂ) : I → ℂ) j = + ∑ u, y u * pathCoordinates Q (E.differential u.1 j) (Path.dual Q u.2.val) := by + let α := (E.placement i).color + let T := E.testComplex Q α + let t := generatorTokenTest Q E i + let x : TestIndex Q E.placement α → ℂ := Pi.single t 1 + have hxs : ScalarSupported Q T ((E.placement i).level+2) (E.placement i).cochain x := by + intro u hu + apply Pi.single_eq_of_ne + intro he + subst u + apply hu + constructor + · change (E.placement i).cochain + ((E.placement i).internal + 2) = + (E.placement i).cochain + (E.placement i).internal + 2 + omega + · rfl + have hxd : Matrix.vecMul x (T.differential.map (vertexHom Q α)) = 0 := by + rw [testComplex_vertex_differential Q E α] + funext u + change (∑ v, x v * testMatrix Q E.placement E.placement α E.differential v u) = 0 + rw [Finset.sum_eq_single t] + · exact mul_eq_zero.mpr (Or.inr (test_token_row_zero Q E hE α t u rfl)) + · intro v _ hv + rw [show x v = 0 from Pi.single_eq_of_ne hv _, MulZeroClass.zero_mul] + · simp + obtain ⟨y, hy, hd⟩ := hex x hxs hxd + refine ⟨y, ?_, ?_⟩ + · intro u hu + have hh := not_not.mp (fun h => hu (hy u h)) + change (E.placement u.1).cochain + ((E.placement u.1).internal + Path.length u.2.val) = + (E.placement i).level+2-1 ∧ + (E.placement u.1).cochain = (E.placement i).cochain-1 at hh + exact ⟨hh.2, by dsimp only [GeneratorPlacement.level] at *; omega⟩ + · intro j + by_cases hj : (E.placement j).color = α + · let s : TestIndex Q E.placement α := ⟨j, .inr (.inr α), rfl, hj.symm⟩ + have hh := congrFun hd s + rw [testComplex_vertex_differential Q E α] at hh + have he : x s = (Pi.single i (1 : ℂ) : I → ℂ) j := by + dsimp only [x] + by_cases hji : j = i + · subst j + have hs : s = t := by rfl + rw [hs] + simp only [Pi.single_eq_same] + · rw [Pi.single_eq_of_ne hji] + apply Pi.single_eq_of_ne + intro he + exact hji (congrArg (fun z : TestIndex Q E.placement α => z.1) he) + rw [he] at hh + rw [← hh] + apply Finset.sum_congr rfl + intro u _ + congr 1 + change (pathBasis Q u.2.val * E.differential u.1 j).token α = _ + exact token_path_mul Q u.2 _ + · have hji : j ≠ i := fun he => hj (by subst j; rfl) + rw [Pi.single_eq_of_ne hji] + symm + apply Finset.sum_eq_zero + intro u _ + have hz : pathCoordinates Q (E.differential u.1 j) (Path.dual Q u.2.val) = 0 := by + by_contra hn + have hc := coordinates_corner Q (E.entries.1 u.1 j) (E.entries.2 u.1 j) hn + have ht : ReversibleQuiver.Path.target Q (Path.dual Q u.2.val) = α := by + rw [Path.target_dual] + exact u.2.property.1 + exact hj (hc.2.symm.trans ht) + rw [hz, MulZeroClass.mul_zero] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeActionDefinitions.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeActionDefinitions.lean new file mode 100644 index 0000000000000000000000000000000000000000..c9e864ac8745b11dc632b1698a09a2a4e242b956 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeActionDefinitions.lean @@ -0,0 +1,25 @@ +import Mathlib.Combinatorics.SimpleGraph.Acyclic +import Mathlib.GroupTheory.GroupAction.Basic + +namespace OAI + +/-! Basic data for actions on simplicial trees. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) + +def PreservesAdj : Prop := ∀ g : G, ∀ {u v : V}, T.Adj u v → T.Adj (g • u) (g • v) + +def translate (hA : PreservesAdj (G := G) T) (g : G) : T →g T := + ⟨(g • ·),hA g⟩ + +def pairStabilizer (u v : V) : Subgroup G := + MulAction.stabilizer G u ⊓ MulAction.stabilizer G v + +/-- A set contains the unique path between any two of its vertices. -/ +def PathClosed (T : SimpleGraph V) (U : Set V) : Prop := + ∀ ⦃u v⦄, u∈U → v∈U → ∀ p : T.Walk u v, p.IsPath → ∀ w∈p.support,w∈U + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeAvoidingGraph.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeAvoidingGraph.lean new file mode 100644 index 0000000000000000000000000000000000000000..f349fd51b44922659b41a04e43873969c5e8783c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeAvoidingGraph.lean @@ -0,0 +1,93 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeSegmentOccurrences +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeConvexSupport +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutMetric + +namespace OAI + +/-! +# Coning off paths that avoid a fixed orbit of segments + +The vertices remain those of the original tree. A new edge joins the +endpoints of a path containing no translate of the chosen segment. +-/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (u v : V) + +def avoidingGraph : SimpleGraph V where + Adj x y := x≠y ∧ ∀ p : T.Walk x y,p.IsPath → ¬ContainsSegment (G := G) u v T p + symm := ⟨by + intro x y h + refine ⟨h.1.symm,?_⟩ + intro p hp + have hn := h.2 p.reverse hp.reverse + simpa only [ContainsSegment,segmentOccurrences_reverse] using hn⟩ + loopless := ⟨by intro x h; exact h.1 rfl⟩ + +lemma avoidingGraph_subpath (hT : T.IsAcyclic) {x y a b : V} + (p : T.Walk x y) (hn : ¬ContainsSegment (G := G) u v T p) + (ha : a∈p.support) (hb : b∈p.support) (hab : a≠b) : + (avoidingGraph (G := G) T u v).Adj a b := by + refine ⟨hab,?_⟩ + intro q hq hbad + obtain ⟨g,hgu,hgv⟩ := hbad + have hc := walk_support_pathClosed T hT p ha hb q hq + exact hn ⟨g,hc _ hgu,hc _ hgv⟩ + +lemma avoidingGraph_preservesAdj (hA : PreservesAdj (G := G) T) : + PreservesAdj (G := G) (avoidingGraph (G := G) T u v) := by + intro g x y hxy + refine ⟨fun he => hxy.1 ((MulAction.toPerm g).injective he),?_⟩ + intro p hp hbad + let q := (p.map (translate T hA g⁻¹)).copy (inv_smul_smul g x) (inv_smul_smul g y) + have hq : q.IsPath := by + apply (SimpleGraph.Walk.isPath_copy _ _ _).mpr + exact hp.map (MulAction.toPerm g⁻¹).injective + apply hxy.2 q hq + obtain ⟨a,ha⟩ := hbad + refine ⟨g⁻¹*a,?_⟩ + have hm := (segmentOccurrences_map u v T hA p g⁻¹ (g⁻¹*a)).mpr ?_ + · change (g⁻¹*a) • u∈q.support ∧ (g⁻¹*a) • v∈q.support + have hsup : q.support=(p.map (translate T hA g⁻¹)).support := + SimpleGraph.Walk.support_copy _ _ _ + rw [hsup] + exact hm + · simpa only [inv_inv,mul_inv_cancel_left] using ha + +/-- If the chosen segment has at least two edges, every original edge +remains an edge after coning. -/ +lemma le_avoidingGraph (hT : T.IsAcyclic) (hA : PreservesAdj (G := G) T) + (hne : u≠v) (hnadj : ¬T.Adj u v) : T≤avoidingGraph (G := G) T u v := by + intro x y hxy + refine ⟨hxy.ne,?_⟩ + intro p hp hbad + have he : p=hxy.toWalk := + congrArg Subtype.val (hT.subsingleton_path x y |>.elim ⟨p,hp⟩ ⟨_,.of_adj hxy⟩) + obtain ⟨g,hgu,hgv⟩ := hbad + rw [he] at hgu hgv + simp only [SimpleGraph.Walk.support_cons,SimpleGraph.Walk.support_nil, + List.mem_cons,List.not_mem_nil,or_false] at hgu hgv + have hadj : T.Adj (g • u) (g • v) := by + rcases hgu with hx|hy <;> rcases hgv with hx'|hy' + · exact False.elim (hne ((MulAction.toPerm g).injective (hx.trans hx'.symm))) + · rw [hx,hy'] + exact hxy + · rw [hy,hx'] + exact hxy.symm + · exact False.elim (hne ((MulAction.toPerm g).injective (hy.trans hy'.symm))) + have h := hA g⁻¹ hadj + simp only [inv_smul_smul] at h + exact hnadj h + +lemma avoidingGraph_pathSaturated (hT : T.IsAcyclic) : + PathSaturated T (avoidingGraph (G := G) T u v) := by + intro x y hxy p hp a ha b hb hab + exact avoidingGraph_subpath T u v hT p (hxy.2 p hp) ha hb hab + +lemma avoidingGraph_connected (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + (hne : u≠v) (hnadj : ¬T.Adj u v) : (avoidingGraph (G := G) T u v).Connected := + hT.connected.mono (le_avoidingGraph T u v hT.isAcyclic hA hne hnadj) + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBallCount.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBallCount.lean new file mode 100644 index 0000000000000000000000000000000000000000..c1c8c87ff81b595b63f3267caf9e577c277c6aa9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBallCount.lean @@ -0,0 +1,65 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePathMetric +import Mathlib.Data.Set.Card +import Mathlib.Order.Interval.Finset.Nat + +namespace OAI + +/-! Uniformly bounded intersections of a tree path with a metric ball. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} (T : SimpleGraph V) + +lemma path_prefix_dist (hT : T.IsAcyclic) {x y : V} + (p : T.Walk x y) (hp : p.IsPath) (i : ℕ) (hi : i≤p.length) : + T.dist x (p.getVert i)=i := by + have he := path_length_eq_dist T hT (p.take i) (hp.take i) + rw [SimpleGraph.Walk.take_length,Nat.min_eq_left hi] at he + exact he.symm + +lemma path_index_dist (hT : T.IsAcyclic) {x y w : V} + (p : T.Walk x y) (hp : p.IsPath) (hw : w∈p.support) : + T.dist x w=p.support.idxOf w := by + have hi : p.support.idxOf w≤p.length := by + have h := List.idxOf_lt_length_of_mem hw + rw [SimpleGraph.Walk.length_support] at h + omega + have he := path_prefix_dist T hT p hp _ hi + rwa [SimpleGraph.Walk.getVert_support_idxOf p hw] at he + +/-- Even in a tree of infinite valence, a radius-`L` ball meets a simple +path in at most `2L+1` vertices. -/ +theorem path_ball_ncard (hT : T.IsTree) {x y b : V} + (p : T.Walk x y) (hp : p.IsPath) (hb : b∈p.support) (L : ℕ) : + {w | w∈p.support ∧ T.dist b w≤L}.ncard≤2*L+1 := by + let i := p.support.idxOf b + let C := Finset.Icc (i-L) (i+L) + have hsubset : {w | w∈p.support ∧ T.dist b w≤L} ⊆ + (↑(C.image p.getVert) : Set V) := by + intro w hw + let j := p.support.idxOf w + have hdw : T.dist x w=j := path_index_dist T hT.isAcyclic p hp hw.1 + have hdb : T.dist x b=i := path_index_dist T hT.isAcyclic p hp hb + have hbw : T.dist b w≤L := hw.2 + have hj : j ≤ i+L := by + have h := hT.connected.dist_triangle (u := x) (v := b) (w := w) + rw [hdw,hdb] at h + omega + have hi : i ≤ j+L := by + have h := hT.connected.dist_triangle (u := x) (v := w) (w := b) + rw [hdw,hdb,T.dist_comm (u := w) (v := b)] at h + omega + apply Finset.mem_image.mpr + refine ⟨j,?_,SimpleGraph.Walk.getVert_support_idxOf p hw.1⟩ + exact Finset.mem_Icc.mpr ⟨by omega,hj⟩ + calc + {w | w∈p.support ∧ T.dist b w≤L}.ncard ≤ (C.image p.getVert).card := by + exact_mod_cast Set.ncard_le_ncard hsubset (Finset.finite_toSet _) + _ ≤ C.card := Finset.card_image_le + _ ≤ 2*L+1 := by + dsimp only [C] + rw [Nat.card_Icc] + omega + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBoundaryRays.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBoundaryRays.lean new file mode 100644 index 0000000000000000000000000000000000000000..dd8e81347caa38696f51de23da16a3a221f046f6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBoundaryRays.lean @@ -0,0 +1,80 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeTranslationSegment +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutMetric +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutHyperbolic + +namespace OAI + +/-! Distinct directions of tree rays determine distinct shortcut-boundary points. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {G V : Type} [Group G] [MulAction G V] +variable (T H : SimpleGraph V) + +lemma separated_graphProduct (hT : T.IsTree) (hH : H.Connected) (hS : PathSaturated T H) + {x a b : V} (p : T.Walk x a) (q : T.Walk x b) (hp : p.IsPath) (hq : q.IsPath) + (hsep : p.Nil ∨ q.Nil ∨ p.snd≠q.snd) : graphProduct H x a b ≤ 1/2 := by + rcases hsep with hn|hn|hne + · cases hn + unfold graphProduct + rw [SimpleGraph.dist_self] + simp + · cases hn + unfold graphProduct + rw [SimpleGraph.dist_self,H.dist_comm (u := a) (v := x)] + simp + · have hpq := reverse_append_isPath T hT.isAcyclic p q hp hq hne + have hx : x∈(p.reverse.append q).support := + SimpleGraph.Walk.support_subset_support_append_right _ _ q.start_mem_support + have h := shortcut_dist_split T H hT hH hS (p.reverse.append q) hpq hx + rw [H.dist_comm (u := a) (v := x)] at h + have h' : (H.dist x a : ℝ)+H.dist x b ≤ H.dist a b+1 := by exact_mod_cast h + unfold graphProduct + linarith + +variable (hA : PreservesAdj (G := G) T) + +def inverseSegment (g : G) {x : V} (p : T.Walk x (g • x)) : T.Walk x (g⁻¹ • x) := + (actPath T hA g⁻¹ p.reverse).copy (by simp) rfl + +lemma inverseSegment_isPath (g : G) {x : V} (p : T.Walk x (g • x)) (hp : p.IsPath) : + (inverseSegment T hA g p).IsPath := + (SimpleGraph.Walk.isPath_copy _ _ _).mpr (hp.reverse.map (MulAction.toPerm g⁻¹).injective) + +lemma inverseSegment_snd (g : G) {x : V} (p : T.Walk x (g • x)) : + (inverseSegment T hA g p).snd=g⁻¹ • p.reverse.snd := + actPath_copy_snd T hA g⁻¹ p.reverse _ rfl + +lemma inverseSegment_reverse_snd (g : G) {x : V} (p : T.Walk x (g • x)) : + (inverseSegment T hA g p).reverse.snd=g⁻¹ • p.snd := by + simpa only [inverseSegment,SimpleGraph.Walk.reverse_reverse] using + actPath_copy_reverse_snd T hA g⁻¹ p.reverse (by simp) rfl + +lemma inverseSegment_nonempty (g : G) {x : V} (p : T.Walk x (g • x)) (hpn : ¬p.Nil) : + ¬(inverseSegment T hA g p).Nil := by + intro hn + have hl := hn.length_eq_zero + simp only [inverseSegment,SimpleGraph.Walk.length_copy,SimpleGraph.Walk.length_map, + SimpleGraph.Walk.length_reverse] at hl + exact hpn (SimpleGraph.Walk.length_eq_zero_iff.mp hl) + +lemma inverseSegment_turn (g : G) {x : V} (p : T.Walk x (g • x)) + (hturn : p.reverse.snd≠g • p.snd) : + (inverseSegment T hA g p).reverse.snd≠g⁻¹ • (inverseSegment T hA g p).snd := by + rw [inverseSegment_reverse_snd,inverseSegment_snd] + intro he + have h₁ := congrArg (fun w : V => g • w) he + simp only [smul_inv_smul] at h₁ + have h₂ := congrArg (fun w : V => g • w) h₁ + simp only [smul_inv_smul] at h₂ + exact hturn h₂.symm + +lemma inverseSegment_mem (g a : G) {x w : V} (p : T.Walk x (g • x)) + (hw : a • w∈p.support) : (g⁻¹*a) • w∈(inverseSegment T hA g p).support := by + simp only [inverseSegment,SimpleGraph.Walk.support_copy,SimpleGraph.Walk.support_map] + apply List.mem_map.mpr + refine ⟨a • w,?_,?_⟩ + · simpa only [SimpleGraph.Walk.support_reverse,List.mem_reverse] using hw + · exact (mul_smul g⁻¹ a w).symm + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBranch.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBranch.lean new file mode 100644 index 0000000000000000000000000000000000000000..b8e298c3dd5d2c4cf660237e8dbfb5cb814a54b2 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBranch.lean @@ -0,0 +1,75 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeFixedPaths + +namespace OAI + +/-! Reflecting a segment at an endpoint and extending it along a new edge. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (hT : T.IsAcyclic) (hA : PreservesAdj (G := G) T) +include hT hA + +lemma moved_first_vertex_ne_endpoint {u v : V} (p : T.Walk v u) (hp : p.IsPath) + (g : G) (hg : g • v=v) (hw : g • p.snd≠p.snd) : g • u≠u := by + intro hu + exact hw (fixes_path T hT hA p hp g hg hu 1) + +/-- Reflecting a path across its initial vertex intersects its endpoint +stabilizer with a conjugate, and still gives an endpoint stabilizer. -/ +theorem reflected_pair (u v : V) (p : T.Walk v u) (hp : p.IsPath) + (g : G) (hg : g • v=v) (hw : g • p.snd≠p.snd) : + pairStabilizer (G := G) u (g • u)=pairStabilizer (G := G) u v ⊓ + conjugate g (pairStabilizer (G := G) u v) := by + let q := (p.map (translate T hA g)).copy hg rfl + have hq : q.IsPath := by + apply (SimpleGraph.Walk.isPath_copy _ _ _).mpr + exact hp.map (MulAction.toPerm g).injective + have hs : p.snd≠q.snd := by + change p.getVert 1≠q.getVert 1 + have hqv : q.getVert 1=g • p.getVert 1 := by + calc + q.getVert 1 = (p.map (translate T hA g)).getVert 1 := + SimpleGraph.Walk.getVert_copy _ 1 hg rfl + _ = g • p.getVert 1 := SimpleGraph.Walk.getVert_map _ _ 1 + rw [hqv] + exact hw.symm + have hr := reverse_append_isPath T hT p q hp hq hs + have hv : v∈(p.reverse.append q).support := by + rw [SimpleGraph.Walk.support_append_eq_support_dropLast_append] + exact List.mem_append_right _ q.start_mem_support + have hfix := pairStabilizer_le_at_path T hT hA (p.reverse.append q) hr hv + rw [←pairStabilizer_smul,hg] + apply le_antisymm + · intro a ha + exact ⟨⟨ha.1,hfix ha⟩,ha.2,hfix ha⟩ + · intro a ha + exact ⟨ha.1.1,ha.2.1⟩ + +omit hA in +/-- An edge leaving the initial direction of a path extends the path. -/ +lemma reverse_concat_isPath {u v w : V} (p : T.Walk v u) (hp : p.IsPath) + (hadj : T.Adj v w) (hw : w≠p.snd) : (p.reverse.concat hadj).IsPath := by + apply hp.reverse.concat + · intro hm + have hm' : w∈p.support := by simpa only [SimpleGraph.Walk.support_reverse,List.mem_reverse] using hm + exact hw (hT.eq_snd_of_adj_start hp hadj hm') + +/-- If the old stabilizer fixes the added vertex, extension preserves it. -/ +theorem extended_pair (u v w : V) (p : T.Walk v u) (hp : p.IsPath) + (hadj : T.Adj v w) (hw : w≠p.snd) + (hfix : pairStabilizer (G := G) u v≤MulAction.stabilizer G w) : + pairStabilizer (G := G) u w=pairStabilizer (G := G) u v := by + have hr := reverse_concat_isPath T hT p hp hadj hw + have hv : v∈(p.reverse.concat hadj).support := by + rw [SimpleGraph.Walk.support_concat] + exact List.mem_append_left _ p.reverse.end_mem_support + have hfix' := pairStabilizer_le_at_path T hT hA _ hr hv + apply le_antisymm + · intro a ha + exact ⟨ha.1,hfix' ha⟩ + · intro a ha + exact ⟨ha.1,hfix ha⟩ + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBranchingHyperbolic.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBranchingHyperbolic.lean new file mode 100644 index 0000000000000000000000000000000000000000..4f9943ea98898cc61af23b9a8951b53e96dd2902 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBranchingHyperbolic.lean @@ -0,0 +1,68 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.PeriodicBoundary + +namespace OAI + +/-! The sufficient tree-action case of the published amalgam criterion, proved directly. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +open GraphRealization +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) + +lemma zpow_orbit_moves {a : G} {x : V} + (ha : Function.Injective (fun n : ℤ => a^n • x)) : a • x≠x := by + intro he + have h : (1 : ℤ)=0 := ha (by simpa only [zpow_one,zpow_zero,one_smul] using he) + norm_num at h + +lemma zpow_third_direction {a : G} {x y z : V} (hx : a • x=x) + (ha : Function.Injective (fun n : ℤ => a^n • y)) : + ∃ c : G,c • x=x ∧ c • y≠y ∧ c • y≠z := by + have ha₁ : a • y≠y := zpow_orbit_moves ha + by_cases haz : a • y=z + · have ha₂ : a^2 • y≠y := by + intro he + have h : (2 : ℤ)=0 := ha (by simpa using he) + norm_num at h + have ha₂₁ : a^2 • y≠a • y := by + intro he + have h : (2 : ℤ)=1 := ha (by simpa using he) + norm_num at h + refine ⟨a^2,?_,ha₂,?_⟩ + · rw [pow_two,mul_smul,hx,hx] + · exact fun he => ha₂₁ (he.trans haz.symm) + · exact ⟨a,hx,ha₁,haz⟩ + +/-- A free segment and infinite branching provide an explicit +non-elementary acylindrical action on a geodesic hyperbolic space. -/ +theorem acylindricallyHyperbolic_of_free_segment + (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + (hbranch : ∀ x y : V,T.Adj x y → + ∃ a : G,a • x=x ∧ Function.Injective (fun n : ℤ => a^n • y)) + (u v : V) (hne : u≠v) (hnadj : ¬T.Adj u v) + (hfree : pairStabilizer (G := G) u v=⊥) : AcylindricallyHyperbolic G := by + obtain ⟨p,hp⟩ := hT.connected.exists_isPath u v + have hpn : ¬p.Nil := fun h => hne (hp.nil_iff_eq.mp h) + have hprn : ¬p.reverse.Nil := by + intro h + have hl := h.length_eq_zero + rw [SimpleGraph.Walk.length_reverse] at hl + exact hpn (SimpleGraph.Walk.length_eq_zero_iff.mp hl) + obtain ⟨a,ha,ha'⟩ := hbranch u p.snd (p.adj_snd hpn) + obtain ⟨b,hb,hb'⟩ := hbranch v p.reverse.snd (p.reverse.adj_snd hprn) + obtain ⟨q,hq,hqn,hqt,hqu,hqv⟩ := translation_segment T hA hT.isAcyclic p hp hpn + a b ha hb (zpow_orbit_moves ha') (zpow_orbit_moves hb') + obtain ⟨c,hc,hc'⟩ := hbranch u q.snd (q.adj_snd hqn) + obtain ⟨d,hd,hd₁,hd₂⟩ := zpow_third_direction (z := (a*b)⁻¹ • q.reverse.snd) hc hc' + let H := avoidingGraph (G := G) T u v + have hH := avoidingGraph_connected T u v hT hA hne hnadj + have hB := avoidingGraph_preservesAdj T u v hA + let X := Space H hH + let _ := action H hB hH + obtain ⟨hgeo,hhyp,hiso,hacyl⟩ := avoiding_realization_geometry T u v hT hA hfree hne hnadj + have hlim : HasThreeOrbitLimitPoints G X := + periodic_three_limit_points T u v hT hA hfree hne hnadj (a*b) q hq hqn hqt a hqu hqv d hd hd₁ hd₂ + exact ⟨X,inferInstance,action H hB hH,hgeo,hhyp,hiso,hacyl,hlim⟩ + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBridge.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBridge.lean new file mode 100644 index 0000000000000000000000000000000000000000..2b5fa0214b54af82f8c9e48e3878d1c88dc239d8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeBridge.lean @@ -0,0 +1,61 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeConvex + +namespace OAI + +/-! A group preserving both sides of a bridge fixes its endpoints. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) + +lemma snd_append_of_not_nil {u v w : V} (p : T.Walk u v) (q : T.Walk v w) + (hp : ¬p.Nil) : (p.append q).snd=p.snd := by + cases p with + | nil => exact (hp .nil).elim + | cons h p => simp only [SimpleGraph.Walk.cons_append,SimpleGraph.Walk.snd_cons] + +/-- The endpoint-exit condition identifies a bridge between two convex sets. +Comparing its length with a translated path forces both endpoints to be fixed. -/ +theorem fixes_bridge (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + {U W : Set V} (hU : PathClosed T U) (hW : PathClosed T W) + {u v : V} (hu : u∈U) (hv : v∈W) (p : T.Walk u v) (hp : p.IsPath) + (hpu : p.snd∉U) (hpv : p.reverse.snd∉W) + (g : G) (hgU : ∀ x∈U,g • x∈U) (hgW : ∀ x∈W,g • x∈W) : + g • u=u ∧ g • v=v := by + obtain ⟨q,hq⟩ := hT.connected.exists_isPath u (g • u) + obtain ⟨r,hr⟩ := hT.connected.exists_isPath v (g • v) + have hqs : q.snd∈U := hU hu (hgU u hu) q hq _ (q.getVert_mem_support 1) + have hrs : r.snd∈W := hW hv (hgW v hv) r hr _ (r.getVert_mem_support 1) + have hqp : (q.reverse.append p).IsPath := + reverse_append_isPath T hT.isAcyclic q p hq hp (fun he => hpu (he ▸ hqs)) + have hn : ¬p.reverse.Nil := by + intro hn + have hnil : p.Nil := by + apply SimpleGraph.Walk.length_eq_zero_iff.mp + simpa only [SimpleGraph.Walk.length_reverse] using hn.length_eq_zero + have hs : p.snd=u := by + cases hnil + exact SimpleGraph.Walk.getVert_nil u + exact hpu (hs.symm ▸ hu) + have hs : (q.reverse.append p).reverse.snd=p.reverse.snd := by + rw [SimpleGraph.Walk.reverse_append,SimpleGraph.Walk.reverse_reverse] + exact snd_append_of_not_nil T p.reverse q hn + have hfull : ((q.reverse.append p).append r).IsPath := by + have h := reverse_append_isPath T hT.isAcyclic (q.reverse.append p).reverse r + hqp.reverse hr (fun he => hpv (hs ▸ he.symm ▸ hrs)) + simpa only [SimpleGraph.Walk.reverse_reverse] using h + have he : (q.reverse.append p).append r=p.map (translate T hA g) := + congrArg Subtype.val (hT.isAcyclic.subsingleton_path (g • u) (g • v) |>.elim + ⟨_,hfull⟩ ⟨_,hp.map (MulAction.toPerm g).injective⟩) + have hl := congrArg SimpleGraph.Walk.length he + simp only [SimpleGraph.Walk.length_append,SimpleGraph.Walk.length_reverse] at hl + have hm := SimpleGraph.Walk.length_map (translate T hA g) p + have hl' : q.length+p.length+r.length=p.length := hl.trans hm + have hq0 : q.length=0 := by omega + have hr0 : r.length=0 := by omega + exact ⟨(SimpleGraph.Walk.eq_of_length_eq_zero hq0).symm, + (SimpleGraph.Walk.eq_of_length_eq_zero hr0).symm⟩ + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeConvex.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeConvex.lean new file mode 100644 index 0000000000000000000000000000000000000000..fbe81edff5b98c066fc200f06abc80addcfa31f5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeConvex.lean @@ -0,0 +1,54 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.OrbitEdgeGraph + +namespace OAI + +/-! Convex vertex sets and boundary edges in a simplicial tree. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] + +lemma orbit_pathClosed (T : SimpleGraph V) (hT : T.IsAcyclic) + (hA : PreservesAdj (G := G) T) (P : Subgroup G) (u v : V) (huv : T.Adj u v) + {A : Set G} (hP : P=Subgroup.closure A) + (hgen : ∀ a∈A,a • u=u ∨ a • v=v) : PathClosed T (orbitVertices P u v) := by + intro x y hx hy p hp w hw + have hr := (orbit_reachable (hne := huv.ne) hP hgen hx).symm.trans + (orbit_reachable (hne := huv.ne) hP hgen hy) + obtain ⟨q,hq⟩ := hr.exists_isPath + have hle := orbit_graph_le (P := P) (hne := huv.ne) T hA huv + have hqm : (q.mapLe hle).IsPath := hq.map Function.injective_id + have he : q.mapLe hle=p := + congrArg Subtype.val (hT.subsingleton_path x y |>.elim ⟨_,hqm⟩ ⟨p,hp⟩) + have hwq : w∈q.support := by + rw [←SimpleGraph.Walk.support_mapLe_eq_support hle q,he] + exact hw + exact orbit_walk_support q hx w hwq + +lemma pathClosed_smul (T : SimpleGraph V) (hA : PreservesAdj (G := G) T) + {U : Set V} (hU : PathClosed T U) (g : G) : PathClosed T ((g • ·) '' U) := by + intro x y hx hy p hp w hw + have hx' : g⁻¹ • x∈U := by + obtain ⟨a,ha,rfl⟩ := hx + simpa only [inv_smul_smul] using ha + have hy' : g⁻¹ • y∈U := by + obtain ⟨a,ha,rfl⟩ := hy + simpa only [inv_smul_smul] using ha + have hm : g⁻¹ • w∈(p.map (translate T hA g⁻¹)).support := by + rw [SimpleGraph.Walk.support_map] + exact List.mem_map.mpr ⟨w,hw,rfl⟩ + have hmem := hU hx' hy' _ (hp.map (MulAction.toPerm g⁻¹).injective) _ hm + exact ⟨g⁻¹ • w,hmem,smul_inv_smul g w⟩ + +lemma exists_boundary_edge (T : SimpleGraph V) {U : Set V} {u v : V} + (hu : u∈U) (hv : v∉U) (p : T.Walk u v) : + ∃ x y,T.Adj x y ∧ x∈U ∧ y∉U := by + induction p with + | nil => exact (hv hu).elim + | @cons u w v h p ih => + by_cases hw : w∈U + · exact ih hw hv + · exact ⟨u,w,h,hu,hw⟩ + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeConvexSupport.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeConvexSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..78bcf0f0b12b5626861827545504b425df14c106 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeConvexSupport.lean @@ -0,0 +1,28 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeActionDefinitions + +namespace OAI + +/-! Convexity of connected subgraphs, including the support of any walk. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {V : Type} (T : SimpleGraph V) + +lemma connected_subgraph_pathClosed (hT : T.IsAcyclic) (H : T.Subgraph) + (hH : H.Connected) : PathClosed T H.verts := by + intro x y hx hy p hp w hw + obtain ⟨q,hq⟩ := (hH ⟨x,hx⟩ ⟨y,hy⟩).exists_isPath + have hqm : (q.map H.hom).IsPath := hq.map H.hom_injective + have he : q.map H.hom=p := + congrArg Subtype.val (hT.subsingleton_path x y |>.elim ⟨_,hqm⟩ ⟨p,hp⟩) + have hw' : w∈(q.map H.hom).support := he.symm ▸ hw + rw [SimpleGraph.Walk.support_map] at hw' + obtain ⟨z,_,hz⟩ := List.mem_map.mp hw' + exact hz ▸ z.property + +lemma walk_support_pathClosed (hT : T.IsAcyclic) {x y : V} (p : T.Walk x y) : + PathClosed T {w | w∈p.support} := by + rw [←p.verts_toSubgraph] + exact connected_subgraph_pathClosed T hT p.toSubgraph p.toSubgraph_connected + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeFixedPaths.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeFixedPaths.lean new file mode 100644 index 0000000000000000000000000000000000000000..2f6e08361ff62a171fb3783fd184a8f89b7ef200 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeFixedPaths.lean @@ -0,0 +1,56 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.Basic +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePaths +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeActionDefinitions + +namespace OAI + +/-! Fixed paths and branching for group actions on simplicial trees. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) + +lemma stabilizer_smul (g : G) (v : V) : + MulAction.stabilizer G (g • v)=conjugate g (MulAction.stabilizer G v) := by + ext a + rw [mem_conjugate,MulAction.mem_stabilizer_iff,MulAction.mem_stabilizer_iff, + ←smul_left_cancel_iff g⁻¹] + simp only [smul_smul,inv_mul_cancel,one_smul,mul_assoc] + +lemma pairStabilizer_smul (g : G) (u v : V) : + pairStabilizer (G := G) (g • u) (g • v)=conjugate g (pairStabilizer (G := G) u v) := by + rw [pairStabilizer,stabilizer_smul,stabilizer_smul,←conjugate_inf] + rfl + +/-- An element fixing the endpoints of a tree path fixes each vertex of it. -/ +theorem fixes_path (hT : T.IsAcyclic) (hA : PreservesAdj (G := G) T) + {u v : V} (p : T.Walk u v) (hp : p.IsPath) (g : G) + (hu : g • u=u) (hv : g • v=v) (n : ℕ) : g • p.getVert n=p.getVert n := by + let q := (p.map (translate T hA g)).copy hu hv + have hq : q.IsPath := by + apply (SimpleGraph.Walk.isPath_copy _ _ _).mpr + exact hp.map (MulAction.toPerm g).injective + have he : q=p := congrArg Subtype.val (hT.subsingleton_path u v |>.elim ⟨q,hq⟩ ⟨p,hp⟩) + have hh := congrArg (fun r : T.Walk u v => r.getVert n) he + calc + g • p.getVert n = (p.map (translate T hA g)).getVert n := + (SimpleGraph.Walk.getVert_map (translate T hA g) p n).symm + _ = q.getVert n := (SimpleGraph.Walk.getVert_copy _ n hu hv).symm + _ = p.getVert n := hh + +theorem fixes_path_support (hT : T.IsAcyclic) (hA : PreservesAdj (G := G) T) + {u v : V} (p : T.Walk u v) (hp : p.IsPath) (g : G) + (hu : g • u=u) (hv : g • v=v) {w : V} (hw : w∈p.support) : g • w=w := by + have h := fixes_path T hT hA p hp g hu hv (p.support.idxOf w) + simpa only [SimpleGraph.Walk.getVert_support_idxOf _ hw] using h + +/-- Endpoint stabilizers also fix all intermediate vertices. -/ +lemma pairStabilizer_le_at_path (hT : T.IsAcyclic) (hA : PreservesAdj (G := G) T) + {u v : V} (p : T.Walk u v) (hp : p.IsPath) {w : V} (hw : w∈p.support) : + pairStabilizer (G := G) u v≤MulAction.stabilizer G w := by + intro g hg + exact fixes_path_support T hT hA p hp g hg.1 hg.2 hw + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeInteriorImage.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeInteriorImage.lean new file mode 100644 index 0000000000000000000000000000000000000000..4a9b1c9678796b51ba06fddda9f5a3b096f09bbb --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeInteriorImage.lean @@ -0,0 +1,40 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutMetric +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeActionDefinitions +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphMetric + +namespace OAI + +/-! Small endpoint displacement preserves the interior of a tree path. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {G V : Type} [Group G] [MulAction G V] +variable (T H : SimpleGraph V) + +lemma image_mem_of_deep (hT : T.IsTree) (hH : H.Connected) + (hS : PathSaturated T H) (hA : PreservesAdj (G := G) T) + (hB : PreservesAdj (G := G) H) {x y w : V} (p : T.Walk x y) (hp : p.IsPath) + (hw : w∈p.support) (r : ℕ) (hx : r+1 < H.dist x w) (hy : r+1 < H.dist y w) + (g : G) (hgx : H.dist x (g • x) ≤ r) (hgy : H.dist y (g • y) ≤ r) : + g • w∈p.support := by + obtain ⟨a,ha⟩ := hT.connected.exists_isPath (g • x) x + obtain ⟨b,hb⟩ := hT.connected.exists_isPath y (g • y) + let q := p.map (translate T hA g) + have hq : q.IsPath := hp.map (MulAction.toPerm g).injective + have hgw : g • w∈q.support := by + rw [SimpleGraph.Walk.support_map] + exact List.mem_map.mpr ⟨w,hw,rfl⟩ + have hm := path_support_subset_walk T hT.isAcyclic q hq ((a.append p).append b) hgw + rcases (SimpleGraph.Walk.mem_support_append_iff (a.append p) b).mp hm with hm|hm + · rcases (SimpleGraph.Walk.mem_support_append_iff a p).mp hm with hm|hm + · have h := shortcut_dist_split T H hT hH hS a ha hm + rw [graph_action_dist H hH hB g x w, + H.dist_comm (u := g • x) (v := x)] at h + omega + · exact hm + · have h := shortcut_dist_split T H hT hH hS b hb hm + rw [H.dist_comm (u := g • w) (v := g • y), + graph_action_dist H hH hB g y w] at h + omega + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeInvariantTranslate.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeInvariantTranslate.lean new file mode 100644 index 0000000000000000000000000000000000000000..025c750459728d7c0b829519e271b43cc59cd49d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeInvariantTranslate.lean @@ -0,0 +1,25 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeConvex + +namespace OAI + +/-! Equivariance of invariant vertex sets under subgroup conjugation. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {G V : Type} [Group G] [MulAction G V] + +lemma conjugate_preserves_image (P : Subgroup G) (U : Set V) + (hU : ∀ p∈P,∀ x∈U,p • x∈U) (a : G) + {g : G} (hg : g∈conjugate a P) {y : V} (hy : y∈(a • ·) '' U) : + g • y∈(a • ·) '' U := by + obtain ⟨x,hx,rfl⟩ := hy + refine ⟨(a⁻¹*g*a) • x,hU _ ((mem_conjugate a P g).mp hg) _ hx,?_⟩ + simp only [smul_smul,mul_assoc,mul_inv_cancel_left] + +lemma not_mem_image_of_smul_eq {U : Set V} {a : G} {x y : V} + (hx : x∉U) (he : a • x=y) : y∉(a • ·) '' U := by + rintro ⟨z,hz,h⟩ + have heq : z=x := (MulAction.toPerm a).injective (h.trans he.symm) + exact hx (heq ▸ hz) + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeMinimalNormal.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeMinimalNormal.lean new file mode 100644 index 0000000000000000000000000000000000000000..22f89d4d4f1da798d732474f184c914ccda1ca0f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeMinimalNormal.lean @@ -0,0 +1,58 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeMinimalPair + +namespace OAI + +/-! A minimal segment stabilizer in a branching tree action is normal when +adjacent vertex stabilizers generate the acting group. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (hT : T.IsAcyclic) (hA : PreservesAdj (G := G) T) +include hT hA + +theorem minimal_pair_normal (u v : V) (hne : u≠v) + (hmin : ∀ a b : V, a≠b → pairStabilizer (G := G) a b≤pairStabilizer (G := G) u v → + pairStabilizer (G := G) a b=pairStabilizer (G := G) u v) + (p : T.Walk v u) (hp : p.IsPath) + (hbranch : ∀ v w : V, T.Adj v w → ∃ a : G, a • v=v ∧ a • w≠w) + (hgen : ∀ v w : V, T.Adj v w → + MulAction.stabilizer G v ⊔ MulAction.stabilizer G w=⊤) : + (pairStabilizer (G := G) u v).Normal := by + let P := pairStabilizer (G := G) u v + have hnV := minimal_pair_endpoint T hT hA u v hne hmin p hp (hbranch v) + have hpnot : ¬p.Nil := fun h => hne (hp.nil_iff_eq.mp h).symm + obtain ⟨a,ha,haw⟩ := hbranch v p.snd (p.adj_snd hpnot) + have haN : conjugate a P=P := (mem_normalizer_iff_conjugate a P).mp (hnV ha) + have hadj : T.Adj v (a • p.snd) := by + have h := hA a (p.adj_snd hpnot) + rwa [ha] at h + have hfix : P≤MulAction.stabilizer G (a • p.snd) := by + rw [stabilizer_smul,←haN] + apply conjugate_mono + exact pairStabilizer_le_at_path T hT hA p.reverse hp.reverse + (by simpa only [SimpleGraph.Walk.support_reverse,List.mem_reverse] + using p.getVert_mem_support 1) + have he : pairStabilizer (G := G) u (a • p.snd)=P := + extended_pair T hT hA u v (a • p.snd) p hp hadj haw hfix + have hne' : u≠a • p.snd := by + intro hu + have hmem : a • p.snd∈p.support := hu ▸ p.end_mem_support + exact haw (hT.eq_snd_of_adj_start hp hadj hmem) + have hmin' : ∀ x y : V, x≠y → + pairStabilizer (G := G) x y≤pairStabilizer (G := G) u (a • p.snd) → + pairStabilizer (G := G) x y=pairStabilizer (G := G) u (a • p.snd) := by + intro x y hxy hle + rw [he] at hle ⊢ + exact hmin x y hxy hle + have hpath := reverse_concat_isPath T hT p hp hadj haw + have hnW := minimal_pair_endpoint T hT hA u (a • p.snd) hne' hmin' + (p.reverse.concat hadj).reverse hpath.reverse (hbranch (a • p.snd)) + rw [he] at hnW + apply Subgroup.normalizer_eq_top_iff.mp + apply top_le_iff.mp + rw [←hgen v (a • p.snd) hadj] + exact sup_le hnV hnW + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeMinimalPair.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeMinimalPair.lean new file mode 100644 index 0000000000000000000000000000000000000000..dcae766b0f73fc08b90d5eff6469cde19b2978b6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeMinimalPair.lean @@ -0,0 +1,48 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeBranch +import OAI.Topology.ArtinGroups.ParabolicIntersections.NormalizerAlgebra + +namespace OAI + +/-! A minimal segment stabilizer is normalized by its endpoint stabilizers. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (hT : T.IsAcyclic) (hA : PreservesAdj (G := G) T) +include hT hA + +theorem minimal_pair_endpoint (u v : V) (hne : u≠v) + (hmin : ∀ a b : V, a≠b → pairStabilizer (G := G) a b≤pairStabilizer (G := G) u v → + pairStabilizer (G := G) a b=pairStabilizer (G := G) u v) + (p : T.Walk v u) (hp : p.IsPath) + (hbranch : ∀ w : V, T.Adj v w → ∃ a : G, a • v=v ∧ a • w≠w) : + MulAction.stabilizer G v≤Subgroup.normalizer (pairStabilizer (G := G) u v : Set G) := by + let P := pairStabilizer (G := G) u v + let C := MulAction.stabilizer G v ⊓ MulAction.stabilizer G p.snd + have hpnot : ¬p.Nil := fun h => hne (hp.nil_iff_eq.mp h).symm + obtain ⟨a,ha,haw⟩ := hbranch p.snd (p.adj_snd hpnot) + have haC : a∉C := fun h => haw h.2 + apply le_normalizer_of_outside P (MulAction.stabilizer G v) C ⟨a,ha,haC⟩ + have hle (g : G) (hg : g • v=v) (hw : g • p.snd≠p.snd) : P≤conjugate g P := by + have hne' : u≠g • u := (moved_first_vertex_ne_endpoint T hT hA p hp g hg hw).symm + have he := reflected_pair T hT hA u v p hp g hg hw + have hm := hmin u (g • u) hne' (by rw [he]; exact inf_le_left) + rw [he] at hm + have hi : P ⊓ conjugate g P≤conjugate g P := inf_le_right + rwa [hm] at hi + intro g hg hgC + have hw : g • p.snd≠p.snd := fun h => hgC ⟨hg,h⟩ + have hgi : g⁻¹ • v=v := by + have hh := congrArg (fun x : V => g⁻¹ • x) hg + simpa only [inv_smul_smul] using hh.symm + have hwi : g⁻¹ • p.snd≠p.snd := by + intro h + have hh := congrArg (fun x : V => g • x) h + exact hw (by simpa only [smul_inv_smul] using hh.symm) + apply le_antisymm + · have h := conjugate_mono g (hle g⁻¹ hgi hwi) + simpa only [←conjugate_mul,mul_inv_cancel,conjugate_one] using h + · exact hle g hg hw + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePathMetric.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePathMetric.lean new file mode 100644 index 0000000000000000000000000000000000000000..4f9503836a78394be161a219c51c2d20065b96be --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePathMetric.lean @@ -0,0 +1,40 @@ +import Mathlib.Combinatorics.SimpleGraph.Acyclic + +namespace OAI + +/-! Distance and path-support facts used by the tree acylindrification. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {V : Type} (T : SimpleGraph V) + +lemma path_length_eq_dist (hT : T.IsAcyclic) {x y : V} + (p : T.Walk x y) (hp : p.IsPath) : p.length=T.dist x y := by + obtain ⟨q,hq,hl⟩ := p.reachable.exists_path_of_dist + have he : p=q := congrArg Subtype.val + (hT.subsingleton_path x y |>.elim ⟨p,hp⟩ ⟨q,hq⟩) + rw [he] + exact hl + +lemma path_metric_additive (hT : T.IsAcyclic) {x y w : V} + (p : T.Walk x y) (hp : p.IsPath) (hw : w∈p.support) : + T.dist x y=T.dist x w+T.dist w y := by + obtain ⟨q,r,hq,hr,he⟩ := hp.mem_support_iff_exists_append.mp hw + rw [←path_length_eq_dist T hT p hp,he,SimpleGraph.Walk.length_append, + path_length_eq_dist T hT q hq,path_length_eq_dist T hT r hr] + +lemma path_support_subset_walk (hT : T.IsAcyclic) {x y : V} + (p : T.Walk x y) (hp : p.IsPath) (q : T.Walk x y) : p.support⊆q.support := by + classical + have he : p=(q.toPath : T.Walk x y) := congrArg Subtype.val + (hT.subsingleton_path x y |>.elim ⟨p,hp⟩ q.toPath) + rw [he] + exact q.support_toPath_subset_support + +lemma path_support_subset_append (hT : T.IsAcyclic) {x y z : V} + (p : T.Walk x z) (hp : p.IsPath) (q : T.Walk x y) (r : T.Walk y z) + {w : V} (hw : w∈p.support) : w∈q.support ∨ w∈r.support := by + have h := path_support_subset_walk T hT p hp (q.append r) hw + exact (SimpleGraph.Walk.mem_support_append_iff q r).mp h + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePaths.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePaths.lean new file mode 100644 index 0000000000000000000000000000000000000000..81ce93fef1a1bd7f0f28d247b75fa3b4819aab9f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePaths.lean @@ -0,0 +1,38 @@ +import Mathlib.Combinatorics.SimpleGraph.Acyclic + +namespace OAI + +/-! Elementary path geometry in a simplicial tree. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} (T : SimpleGraph V) + +/-- Paths starting in different directions meet only at their initial vertex. -/ +theorem common_support_eq_start (hT : T.IsAcyclic) {u v w x : V} + (p : T.Walk u v) (q : T.Walk u w) (hp : p.IsPath) (hq : q.IsPath) + (hs : p.snd≠q.snd) (hxp : x∈p.support) (hxq : x∈q.support) : x=u := by + by_contra hxu + have he : p.takeUntil x hxp=q.takeUntil x hxq := + congrArg Subtype.val (hT.subsingleton_path u x |>.elim + ⟨_,hp.takeUntil hxp⟩ ⟨_,hq.takeUntil hxq⟩) + have hh := congrArg (fun r : T.Walk u x => r.snd) he + rw [SimpleGraph.Walk.snd_takeUntil hxu,SimpleGraph.Walk.snd_takeUntil hxu] at hh + exact hs hh + +/-- Two paths in different directions form a single longer path. -/ +theorem reverse_append_isPath (hT : T.IsAcyclic) {u v w : V} + (p : T.Walk u v) (q : T.Walk u w) (hp : p.IsPath) (hq : q.IsPath) + (hs : p.snd≠q.snd) : (p.reverse.append q).IsPath := by + apply SimpleGraph.Walk.IsPath.mk' + rw [SimpleGraph.Walk.support_append_eq_support_dropLast_append] + apply List.Nodup.append (hp.reverse.support_nodup.sublist (List.dropLast_sublist _)) hq.support_nodup + intro x hxp hxq + have hxp' : x∈p.support := by + simpa only [SimpleGraph.Walk.support_reverse,List.mem_reverse] using List.dropLast_subset _ hxp + have he := common_support_eq_start T hT p q hp hq hs hxp' hxq + have hn := hp.reverse.support_nodup.rel_dropLast_getLast hxp + exact hn (by simpa only [SimpleGraph.Walk.getLast_support] using he) + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePeriodicGrowth.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePeriodicGrowth.lean new file mode 100644 index 0000000000000000000000000000000000000000..69381ec260ead210db5cc9d840f453748d336b2a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePeriodicGrowth.lean @@ -0,0 +1,107 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePeriodicPaths +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeSegmentCount +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutHyperbolic + +namespace OAI + +/-! Periodic translates of a free segment give boundary points of the shortcut graph. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (hA : PreservesAdj (G := G) T) +include hA + +lemma periodic_powers_injective (hT : T.IsAcyclic) (g : G) {x : V} + (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) : Function.Injective (fun n : ℕ => g^n) := by + intro m n he + have hd := congrArg (fun a : G => T.dist x (a • x)) he + rw [periodic_orbit_distance T hA hT g p hp hpn hturn m, + periodic_orbit_distance T hA hT g p hp hpn hturn n] at hd + have hpos : 0 < p.length := Nat.pos_of_ne_zero (fun hz => hpn (SimpleGraph.Walk.length_eq_zero_iff.mp hz)) + exact Nat.mul_right_cancel hpos hd + +theorem periodic_occurrences (hT : T.IsAcyclic) (g : G) {x u v : V} + (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) + (hfree : pairStabilizer (G := G) u v=⊥) (a : G) + (hau : a • u∈p.support) (hav : a • v∈p.support) (n : ℕ) : + n ≤ (segmentOccurrences (G := G) u v T (periodicPath T hA g p n)).ncard := by + let f (k : Fin n) : G := g^k.val*a + have hmem (k : Fin n) : f k∈segmentOccurrences (G := G) u v T (periodicPath T hA g p n) := by + constructor + · change (g^k.val*a) • u∈_ + rw [mul_smul] + exact periodicPath_translate_mem_of_lt T hA g p hau k.val n k.isLt + · change (g^k.val*a) • v∈_ + rw [mul_smul] + exact periodicPath_translate_mem_of_lt T hA g p hav k.val n k.isLt + have hinj : Function.Injective f := by + intro i j he + apply Fin.ext + exact periodic_powers_injective T hA hT g p hp hpn hturn (mul_right_cancel he) + have hc := Set.ncard_le_ncard_of_injOn (s := Set.univ) f (fun k _ => hmem k) hinj.injOn + (segmentOccurrences_finite hfree T (periodicPath T hA g p n)) + simpa only [Set.ncard_univ,Nat.card_fin] using hc + +theorem periodic_shortcut_growth (hT : T.IsTree) (u v : V) + (hfree : pairStabilizer (G := G) u v=⊥) (hne : u≠v) (hnadj : ¬T.Adj u v) + (g : G) {x : V} (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) (a : G) + (hau : a • u∈p.support) (hav : a • v∈p.support) (n : ℕ) : + n ≤ (avoidingGraph (G := G) T u v).dist x (g^n • x)*(2*T.dist u v+1)^2 := by + exact (periodic_occurrences T hA hT.isAcyclic g p hp hpn hturn hfree a hau hav n).trans + (segmentOccurrences_bound_dist T u v hT hA hfree hne hnadj (periodicPath T hA g p n) + (periodicPath_isPath T hA hT.isAcyclic g p hp hpn hturn n)) + +theorem periodic_shortcut_escape (hT : T.IsTree) (u v : V) + (hfree : pairStabilizer (G := G) u v=⊥) (hne : u≠v) (hnadj : ¬T.Adj u v) + (g : G) {x : V} (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) (a : G) + (hau : a • u∈p.support) (hav : a • v∈p.support) (R : ℝ) : + ∃ N : ℕ,∀ n,N ≤ n → R ≤ ((avoidingGraph (G := G) T u v).dist x (g^n • x) : ℝ) := by + let C := (2*T.dist u v+1)^2 + refine ⟨Nat.ceil (R*C),?_⟩ + intro n hn + have hc : (0 : ℝ) < C := by dsimp only [C]; positivity + have h₁ : R*C ≤ (n : ℝ) := (Nat.le_ceil _).trans (by exact_mod_cast hn) + have h₂ : (n : ℝ) ≤ ((avoidingGraph (G := G) T u v).dist x (g^n • x) : ℝ)*C := by + exact_mod_cast periodic_shortcut_growth T hA hT u v hfree hne hnadj g p hp hpn hturn a hau hav n + exact (mul_le_mul_iff_left₀ hc).mp (by simpa only [mul_comm] using h₁.trans h₂) + +theorem periodic_shortcut_gromov (hT : T.IsTree) (u v : V) + (hfree : pairStabilizer (G := G) u v=⊥) (hne : u≠v) (hnadj : ¬T.Adj u v) + (g : G) {x : V} (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) (a : G) + (hau : a • u∈p.support) (hav : a • v∈p.support) (R : ℝ) : + ∃ N : ℕ,∀ m,N ≤ m → ∀ n,N ≤ n → + R ≤ graphProduct (avoidingGraph (G := G) T u v) x (g^m • x) (g^n • x) := by + let H := avoidingGraph (G := G) T u v + have hH := avoidingGraph_connected T u v hT hA hne hnadj + have hS := avoidingGraph_pathSaturated (G := G) T u v hT.isAcyclic + obtain ⟨N,hN⟩ := periodic_shortcut_escape T hA hT u v hfree hne hnadj g p hp hpn hturn a hau hav (R+1) + refine ⟨N,?_⟩ + have hordered (m n : ℕ) (hm : N ≤ m) (hmn : m ≤ n) : + R ≤ graphProduct H x (g^m • x) (g^n • x) := by + have h := shortcut_dist_split T H hT hH hS (periodicPath T hA g p n) + (periodicPath_isPath T hA hT.isAcyclic g p hp hpn hturn n) + (periodicPath_vertex_mem T hA g p m n hmn) + have h' : (H.dist x (g^m • x) : ℝ)+H.dist (g^m • x) (g^n • x) ≤ H.dist x (g^n • x)+1 := by + exact_mod_cast h + have hd := hN m hm + change R+1 ≤ (H.dist x (g^m • x) : ℝ) at hd + unfold graphProduct + linarith + intro m hm n hn + rcases le_total m n with h|h + · exact hordered m n hm h + · have he : graphProduct H x (g^m • x) (g^n • x)=graphProduct H x (g^n • x) (g^m • x) := by + unfold graphProduct + rw [H.dist_comm (u := g^m • x) (v := g^n • x)] + ring + rw [he] + exact hordered n m hn h + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePeriodicPaths.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePeriodicPaths.lean new file mode 100644 index 0000000000000000000000000000000000000000..4f9d36b828c19c235f865da35ab184e68ef99c8b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreePeriodicPaths.lean @@ -0,0 +1,148 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePaths +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeActionDefinitions +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePathMetric + +namespace OAI + +/-! Iterating a tree segment without backtracking produces an actual translation axis. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (hA : PreservesAdj (G := G) T) + +private abbrev shiftHom (g : G) : T →g T := ⟨(g • ·),hA g⟩ + +def periodicPath (g : G) {x : V} (p : T.Walk x (g • x)) : + (n : ℕ) → T.Walk x (g^n • x) + | 0 => (.nil : T.Walk x x).copy rfl (by simp) + | n+1 => ((periodicPath g p n).append (p.map (shiftHom T hA (g^n)))).copy rfl + (by change g^n • (g • x)=g^(n+1) • x; rw [←mul_smul,←pow_succ]) + +lemma periodicPath_length (g : G) {x : V} (p : T.Walk x (g • x)) (n : ℕ) : + (periodicPath T hA g p n).length=n*p.length := by + induction n with + | zero => simp [periodicPath] + | succ n ih => + simp only [periodicPath,SimpleGraph.Walk.length_copy] + calc + _ = (periodicPath T hA g p n).length+(p.map (shiftHom T hA (g^n))).length := + SimpleGraph.Walk.length_append _ _ + _ = (n+1)*p.length := by rw [ih,SimpleGraph.Walk.length_map,Nat.add_mul,one_mul] + +private lemma first_append_nonempty {x y z : V} (p : T.Walk x y) (q : T.Walk y z) + (hp : ¬p.Nil) : (p.append q).snd=p.snd := by + cases p with + | nil => exact (hp .nil).elim + | cons h p => simp only [SimpleGraph.Walk.cons_append,SimpleGraph.Walk.snd_cons] + +lemma periodicPath_reverse_snd (g : G) {x : V} (p : T.Walk x (g • x)) + (hp : ¬p.Nil) (n : ℕ) : + (periodicPath T hA g p (n+1)).reverse.snd=g^n • p.reverse.snd := by + unfold periodicPath + rw [SimpleGraph.Walk.reverse_copy] + simp only [SimpleGraph.Walk.getVert_copy] + rw [SimpleGraph.Walk.reverse_append (periodicPath T hA g p n) (p.map (shiftHom T hA (g^n)))] + change ((p.map (shiftHom T hA (g^n))).reverse.append + (periodicPath T hA g p n).reverse).snd= _ + rw [first_append_nonempty T _ _ (by + intro hn + have hl := hn.length_eq_zero + simp only [SimpleGraph.Walk.length_reverse,SimpleGraph.Walk.length_map] at hl + exact hp (SimpleGraph.Walk.length_eq_zero_iff.mp hl))] + rw [SimpleGraph.Walk.reverse_map] + exact SimpleGraph.Walk.getVert_map _ _ 1 + +private lemma nil_copy_append {x y z : V} (h : x=y) (q : T.Walk y z) : + ((.nil : T.Walk x x).copy rfl h).append q=q.copy h.symm rfl := by + subst y + rfl + +theorem periodicPath_isPath (hT : T.IsAcyclic) (g : G) {x : V} + (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) (n : ℕ) : + (periodicPath T hA g p n).IsPath := by + induction n with + | zero => simp [periodicPath] + | succ n ih => + apply (SimpleGraph.Walk.isPath_copy _ _ _).mpr + have hmap : (p.map (shiftHom T hA (g^n))).IsPath := hp.map (MulAction.toPerm (g^n)).injective + by_cases hn : n=0 + · subst n + simp only [periodicPath,nil_copy_append] + exact (SimpleGraph.Walk.isPath_copy _ _ _).mpr hmap + · obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn + have hne : (periodicPath T hA g p (k+1)).reverse.snd≠ + (p.map (shiftHom T hA (g^(k+1)))).snd := by + rw [periodicPath_reverse_snd T hA g p hpn k] + change g^k • p.reverse.snd ≠ (p.map (shiftHom T hA (g^(k+1)))).getVert 1 + rw [SimpleGraph.Walk.getVert_map] + change g^k • p.reverse.snd ≠ g^(k+1) • p.snd + rw [pow_succ,mul_smul] + exact fun he => hturn ((MulAction.toPerm (g^k)).injective he) + have h := reverse_append_isPath T hT + (periodicPath T hA g p (k+1)).reverse (p.map (shiftHom T hA (g^(k+1)))) + ih.reverse hmap hne + simpa only [SimpleGraph.Walk.reverse_reverse] using h + +include hA in +theorem periodic_orbit_distance (hT : T.IsAcyclic) (g : G) {x : V} + (p : T.Walk x (g • x)) (hp : p.IsPath) (hpn : ¬p.Nil) + (hturn : p.reverse.snd≠g • p.snd) (n : ℕ) : + T.dist x (g^n • x)=n*p.length := by + rw [←path_length_eq_dist T hT _ (periodicPath_isPath T hA hT g p hp hpn hturn n), + periodicPath_length] + +lemma periodicPath_support_step (g : G) {x : V} (p : T.Walk x (g • x)) (n : ℕ) : + (periodicPath T hA g p n).support ⊆ (periodicPath T hA g p (n+1)).support := by + simp only [periodicPath,SimpleGraph.Walk.support_copy] + exact SimpleGraph.Walk.support_subset_support_append_left _ _ + +lemma periodicPath_translate_mem (g : G) {x w : V} (p : T.Walk x (g • x)) + (hw : w∈p.support) (n : ℕ) : + g^n • w∈(periodicPath T hA g p (n+1)).support := by + simp only [periodicPath,SimpleGraph.Walk.support_copy] + apply SimpleGraph.Walk.support_subset_support_append_right + rw [SimpleGraph.Walk.support_map] + exact List.mem_map.mpr ⟨w,hw,rfl⟩ + +lemma periodicPath_translate_mem_of_lt (g : G) {x w : V} (p : T.Walk x (g • x)) + (hw : w∈p.support) (k n : ℕ) (hkn : k < n) : + g^k • w∈(periodicPath T hA g p n).support := by + induction n with + | zero => omega + | succ n ih => + by_cases hk : k < n + · exact periodicPath_support_step T hA g p n (ih hk) + · have he : k=n := by omega + subst k + exact periodicPath_translate_mem T hA g p hw n + +lemma periodicPath_vertex_mem (g : G) {x : V} (p : T.Walk x (g • x)) + (k n : ℕ) (hkn : k ≤ n) : g^k • x∈(periodicPath T hA g p n).support := by + rcases lt_or_eq_of_le hkn with h|h + · exact periodicPath_translate_mem_of_lt T hA g p p.start_mem_support k n h + · subst k + exact (periodicPath T hA g p n).end_mem_support + +lemma periodicPath_snd (g : G) {x : V} (p : T.Walk x (g • x)) + (hpn : ¬p.Nil) (n : ℕ) : (periodicPath T hA g p (n+1)).snd=p.snd := by + induction n with + | zero => + change (periodicPath T hA g p (0+1)).getVert 1=p.getVert 1 + simp only [periodicPath,nil_copy_append,SimpleGraph.Walk.getVert_copy, + SimpleGraph.Walk.getVert_map,pow_zero] + exact one_smul G (p.getVert 1) + | succ n ih => + change (periodicPath T hA g p (n+1+1)).getVert 1=p.snd + rw [periodicPath,SimpleGraph.Walk.getVert_copy] + have hn : ¬(periodicPath T hA g p (n+1)).Nil := by + intro hn + have hl := hn.length_eq_zero + rw [periodicPath_length] at hl + have hpos : 0 < p.length := Nat.pos_of_ne_zero (fun he => hpn (SimpleGraph.Walk.length_eq_zero_iff.mp he)) + exact (Nat.mul_pos (Nat.succ_pos n) hpos).ne' hl + exact (first_append_nonempty T _ _ hn).trans ih + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentBallCount.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentBallCount.lean new file mode 100644 index 0000000000000000000000000000000000000000..c5db4c56f6b827e19e48c23cb4fab437f94cd09d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentBallCount.lean @@ -0,0 +1,38 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeSegmentOccurrences +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeBallCount + +namespace OAI + +/-! Uniform counts for translates of a free segment near a path vertex. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (u v : V) + +def localSegmentOccurrences {x y : V} (p : T.Walk x y) (b : V) (L : ℕ) : Set G := + {g | (g • u∈p.support ∧ T.dist b (g • u)≤L) ∧ + (g • v∈p.support ∧ T.dist b (g • v)≤L)} + +/-- The bound is independent of the path length and of vertex valences. -/ +theorem localSegmentOccurrences_bound (hT : T.IsTree) + (hfree : pairStabilizer (G := G) u v=⊥) + {x y b : V} (p : T.Walk x y) (hp : p.IsPath) (hb : b∈p.support) (L : ℕ) : + (localSegmentOccurrences (G := G) T u v p b L).Finite ∧ + (localSegmentOccurrences (G := G) T u v p b L).ncard≤(2*L+1)^2 := by + let B : Set V := {w | w∈p.support ∧ T.dist b w≤L} + have hB : B.Finite := p.support.finite_toSet.subset (fun _ hw => hw.1) + have hcard : B.ncard≤2*L+1 := path_ball_ncard T hT p hp hb L + have hpair := pair_orbit_injective hfree + have hfin : (localSegmentOccurrences (G := G) T u v p b L).Finite := + (hB.prod hB).preimage hpair.injOn + refine ⟨hfin,?_⟩ + calc + (localSegmentOccurrences (G := G) T u v p b L).ncard ≤ (B×ˢB).ncard := + Set.ncard_le_ncard_of_injOn (fun g : G => (g • u,g • v)) + (fun _ hg => hg) hpair.injOn (hB.prod hB) + _ = B.ncard*B.ncard := Set.ncard_prod + _ ≤ (2*L+1)*(2*L+1) := Nat.mul_le_mul hcard hcard + _ = (2*L+1)^2 := (pow_two _).symm + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentCount.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentCount.lean new file mode 100644 index 0000000000000000000000000000000000000000..b991fefbbdb0c06966ca1b2f0ecf98571390d721 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentCount.lean @@ -0,0 +1,125 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeSegmentBallCount +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeSeparatedPaths +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeTripod +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeAvoidingGraph +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphMetric + +namespace OAI + +/-! Uniform counts of free segment translates along shortcut paths. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (u v : V) + +lemma segmentOccurrences_branches (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + {b x y : V} (s : T.Walk b x) (t : T.Walk b y) + (hs : s.IsPath) (ht : t.IsPath) + (hc : ∀ w∈s.support,w∈t.support → w=b) : + segmentOccurrences (G := G) u v T (s.reverse.append t) ⊆ + segmentOccurrences u v T s ∪ segmentOccurrences u v T t ∪ + localSegmentOccurrences T u v (s.reverse.append t) b (T.dist u v) := by + intro g hg + have hgu := (SimpleGraph.Walk.mem_support_append_iff s.reverse t).mp hg.1 + have hgv := (SimpleGraph.Walk.mem_support_append_iff s.reverse t).mp hg.2 + simp only [SimpleGraph.Walk.support_reverse,List.mem_reverse] at hgu hgv + have hd := graph_action_dist T hT.connected hA g u v + rcases hgu with hgu|hgu <;> rcases hgv with hgv|hgv + · exact Or.inl (Or.inl ⟨hgu,hgv⟩) + · right + have he := dist_sum_of_branches T hT.isAcyclic s t hs ht hc hgu hgv + exact ⟨⟨hg.1,by omega⟩,⟨hg.2,by omega⟩⟩ + · right + have he := dist_sum_of_branches T hT.isAcyclic s t hs ht hc hgv hgu + rw [T.dist_comm (u := g • v) (v := g • u)] at he + exact ⟨⟨hg.1,by omega⟩,⟨hg.2,by omega⟩⟩ + · exact Or.inl (Or.inr ⟨hgu,hgv⟩) + +lemma branch_support_common (hT : T.IsAcyclic) {b x y : V} + (s : T.Walk b x) (t : T.Walk b y) (hs : s.IsPath) (ht : t.IsPath) + (hd : s.Nil ∨ t.Nil ∨ s.snd≠t.snd) : + ∀ w∈s.support,w∈t.support → w=b := by + intro w hw hw' + rcases hd with hn|hn|hne + · cases hn + simpa only [SimpleGraph.Walk.support_nil,List.mem_singleton] using hw + · cases hn + simpa only [SimpleGraph.Walk.support_nil,List.mem_singleton] using hw' + · exact common_support_eq_start T hT s t hs ht hne hw hw' + +/-- A shortcut walk of length `n` crosses at most `n (2L+1)^2` +translates of a free length-`L` segment, independently of vertex valences. -/ +theorem segmentOccurrences_bound (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + (hfree : pairStabilizer (G := G) u v=⊥) (hne : u≠v) + {x y : V} (q : (avoidingGraph (G := G) T u v).Walk x y) + (p : T.Walk x y) (hp : p.IsPath) : + (segmentOccurrences (G := G) u v T p).ncard ≤ q.length*(2*T.dist u v+1)^2 := by + induction q with + | @nil x => + have he : p=.nil := congrArg Subtype.val + (hT.isAcyclic.subsingleton_path _ _ |>.elim ⟨p,hp⟩ ⟨.nil,by simp⟩) + rw [he] + have hempty : segmentOccurrences (G := G) u v T (.nil : T.Walk x x)=∅ := by + apply Set.eq_empty_iff_forall_notMem.mpr + intro g hg + have hgu : g • u=x := by simpa only [SimpleGraph.Walk.support_nil,List.mem_singleton] using hg.1 + have hgv : g • v=x := by simpa only [SimpleGraph.Walk.support_nil,List.mem_singleton] using hg.2 + exact hne ((MulAction.toPerm g).injective (hgu.trans hgv.symm)) + rw [hempty] + simp + | @cons x z y hxz q ih => + obtain ⟨r,hr⟩ := hT.connected.exists_isPath x z + obtain ⟨w,hw⟩ := hT.connected.exists_isPath z y + obtain ⟨b,a,s,t,hrs,hwt,hd⟩ := walk_common_prefix T r.reverse w + have hs : s.IsPath := (hrs ▸ hr.reverse).of_append_right + have ht : t.IsPath := (hwt ▸ hw).of_append_right + have hc := branch_support_common T hT.isAcyclic s t hs ht hd + have hst := reverse_append_of_common T s t hs ht hc + have he : p=s.reverse.append t := congrArg Subtype.val + (hT.isAcyclic.subsingleton_path _ _ |>.elim ⟨p,hp⟩ ⟨_,hst⟩) + have hno : ¬ContainsSegment (G := G) u v T r := hxz.2 r hr + have hsub : segmentOccurrences (G := G) u v T p ⊆ + segmentOccurrences u v T w ∪ localSegmentOccurrences T u v p b (T.dist u v) := by + intro g hg + rw [he] at hg + rcases segmentOccurrences_branches T u v hT hA s t hs ht hc hg with (hgs|hgt)|hgl + · exfalso + apply hno + have hsr : s.support⊆r.reverse.support := by + rw [hrs] + exact SimpleGraph.Walk.support_subset_support_append_right a s + refine ⟨g,?_,?_⟩ + · simpa only [SimpleGraph.Walk.support_reverse,List.mem_reverse] using hsr hgs.1 + · simpa only [SimpleGraph.Walk.support_reverse,List.mem_reverse] using hsr hgs.2 + · left + have htw : t.support⊆w.support := by + rw [hwt] + exact SimpleGraph.Walk.support_subset_support_append_right a t + exact ⟨htw hgt.1,htw hgt.2⟩ + · exact Or.inr (he ▸ hgl) + have hb : b∈p.support := by + rw [he] + exact SimpleGraph.Walk.support_subset_support_append_right s.reverse t t.start_mem_support + have hlocal := localSegmentOccurrences_bound T u v hT hfree p hp hb (T.dist u v) + have hn := ih w hw + calc + (segmentOccurrences (G := G) u v T p).ncard ≤ + (segmentOccurrences u v T w ∪ localSegmentOccurrences T u v p b (T.dist u v)).ncard := + Set.ncard_le_ncard hsub ((segmentOccurrences_finite hfree T w).union hlocal.1) + _ ≤ (segmentOccurrences (G := G) u v T w).ncard+ + (localSegmentOccurrences T u v p b (T.dist u v)).ncard := Set.ncard_union_le _ _ + _ ≤ q.length*(2*T.dist u v+1)^2+(2*T.dist u v+1)^2 := Nat.add_le_add hn hlocal.2 + _ = (q.cons hxz).length*(2*T.dist u v+1)^2 := by + simp only [SimpleGraph.Walk.length_cons,Nat.add_mul,one_mul] + +theorem segmentOccurrences_bound_dist (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + (hfree : pairStabilizer (G := G) u v=⊥) (hne : u≠v) (hnadj : ¬T.Adj u v) + {x y : V} (p : T.Walk x y) (hp : p.IsPath) : + (segmentOccurrences (G := G) u v T p).ncard ≤ + (avoidingGraph (G := G) T u v).dist x y*(2*T.dist u v+1)^2 := by + obtain ⟨q,hq⟩ := (avoidingGraph_connected T u v hT hA hne hnadj).exists_walk_length_eq_dist x y + simpa only [hq] using segmentOccurrences_bound T u v hT hA hfree hne q p hp + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentOccurrences.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentOccurrences.lean new file mode 100644 index 0000000000000000000000000000000000000000..beb08e7f551065ef335b743144df89e30ba604e7 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSegmentOccurrences.lean @@ -0,0 +1,84 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeActionDefinitions + +namespace OAI + +/-! +# Finite translates of a segment inside a finite path + +This is the finite-pattern input for constructing an acylindrical graph +from a tree action. The segment is in the actual tree and its pointwise +stabilizer is trivial; its occurrences are group elements, not formal labels. +-/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {G V : Type} [Group G] [MulAction G V] + +lemma pair_orbit_injective {u v : V} (h : pairStabilizer (G := G) u v=⊥) : + Function.Injective (fun g : G => (g • u,g • v)) := by + intro a b hab + have hu : a • u=b • u := congrArg Prod.fst hab + have hv : a • v=b • v := congrArg Prod.snd hab + have hm : b⁻¹*a∈pairStabilizer (G := G) u v := by + constructor + · change (b⁻¹*a) • u=u + rw [mul_smul,hu,inv_smul_smul] + · change (b⁻¹*a) • v=v + rw [mul_smul,hv,inv_smul_smul] + rw [h,Subgroup.mem_bot] at hm + exact (inv_mul_eq_one.mp hm).symm + +/-- Group translates whose two endpoints occur in a specified finite path. -/ +def segmentOccurrences (u v : V) (T : SimpleGraph V) {x y : V} (p : T.Walk x y) : Set G := + {g | g • u∈p.support ∧ g • v∈p.support} + +lemma segmentOccurrences_finite {u v : V} (h : pairStabilizer (G := G) u v=⊥) + (T : SimpleGraph V) {x y : V} (p : T.Walk x y) : + (segmentOccurrences (G := G) u v T p).Finite := by + let A : Set V := {w | w∈p.support} + have hA : A.Finite := p.support.finite_toSet + have hprod : (A×ˢA).Finite := hA.prod hA + exact hprod.preimage (pair_orbit_injective h).injOn + +/-- A path contains a translate of the fixed segment. In a tree the +endpoint condition also puts the entire translated segment in the path. -/ +def ContainsSegment (u v : V) (T : SimpleGraph V) {x y : V} (p : T.Walk x y) : Prop := + (segmentOccurrences (G := G) u v T p).Nonempty + + +lemma segmentOccurrences_reverse (u v : V) (T : SimpleGraph V) {x y : V} (p : T.Walk x y) : + segmentOccurrences (G := G) u v T p.reverse=segmentOccurrences u v T p := by + ext g + simp only [segmentOccurrences,Set.mem_ofPred_eq,SimpleGraph.Walk.support_reverse,List.mem_reverse] + +lemma segmentOccurrences_subpath (u v : V) (T : SimpleGraph V) {x y a b : V} + (p : T.Walk x y) (q : T.Walk a b) (hq : q.support.Sublist p.support) : + segmentOccurrences (G := G) u v T q⊆segmentOccurrences u v T p := by + intro g hg + exact ⟨hq.subset hg.1,hq.subset hg.2⟩ + +lemma smul_mem_mapped_support (T : SimpleGraph V) (hA : PreservesAdj (G := G) T) + {x y w : V} (p : T.Walk x y) (g h : G) : + h • w∈(p.map (translate T hA g)).support ↔ (g⁻¹*h) • w∈p.support := by + rw [SimpleGraph.Walk.support_map] + constructor + · intro hm + obtain ⟨z,hz,he⟩ := List.mem_map.mp hm + change g • z=h • w at he + have hzw : z=(g⁻¹*h) • w := by + have hh := congrArg (fun t : V => g⁻¹ • t) he + simpa only [←mul_smul,inv_mul_cancel,one_smul] using hh + exact hzw ▸ hz + · intro hh + refine List.mem_map.mpr ⟨(g⁻¹*h) • w,hh,?_⟩ + change g • ((g⁻¹*h) • w)=h • w + rw [←mul_smul,mul_inv_cancel_left] + +lemma segmentOccurrences_map (u v : V) (T : SimpleGraph V) + (hA : PreservesAdj (G := G) T) {x y : V} (p : T.Walk x y) (g h : G) : + h∈segmentOccurrences (G := G) u v T (p.map (translate T hA g)) ↔ + g⁻¹*h∈segmentOccurrences u v T p := by + exact and_congr (smul_mem_mapped_support T hA p g h) + (smul_mem_mapped_support T hA p g h) + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSeparatedPaths.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSeparatedPaths.lean new file mode 100644 index 0000000000000000000000000000000000000000..c4bab54b35aa77edf76d41c8276a45eff60187a7 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeSeparatedPaths.lean @@ -0,0 +1,44 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePaths +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePathMetric + +namespace OAI + +/-! Distances between different branches of a tree. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} (T : SimpleGraph V) + +lemma reverse_append_of_common {b x y : V} (s : T.Walk b x) (t : T.Walk b y) + (hs : s.IsPath) (ht : t.IsPath) + (hc : ∀ w∈s.support,w∈t.support → w=b) : (s.reverse.append t).IsPath := by + apply SimpleGraph.Walk.IsPath.mk' + rw [SimpleGraph.Walk.support_append_eq_support_dropLast_append] + apply List.Nodup.append (hs.reverse.support_nodup.sublist (List.dropLast_sublist _)) ht.support_nodup + intro w hw ht' + have hs' : w∈s.support := by + simpa only [SimpleGraph.Walk.support_reverse,List.mem_reverse] using List.dropLast_subset _ hw + have he := hc w hs' ht' + have hn := hs.reverse.support_nodup.rel_dropLast_getLast hw + exact hn (by simpa only [SimpleGraph.Walk.getLast_support] using he) + +lemma dist_sum_of_branches (hT : T.IsAcyclic) {b x y a c : V} + (s : T.Walk b x) (t : T.Walk b y) (hs : s.IsPath) (ht : t.IsPath) + (hc : ∀ w∈s.support,w∈t.support → w=b) + (ha : a∈s.support) (hc' : c∈t.support) : + T.dist b a+T.dist b c=T.dist a c := by + let p := s.takeUntil a ha + let q := t.takeUntil c hc' + have hp : p.IsPath := hs.takeUntil ha + have hq : q.IsPath := ht.takeUntil hc' + have hpq : (p.reverse.append q).IsPath := + reverse_append_of_common T p q hp hq (fun w hw hw' => + hc w (s.support_takeUntil_subset_support ha hw) (t.support_takeUntil_subset_support hc' hw')) + have hb : b∈(p.reverse.append q).support := + SimpleGraph.Walk.support_subset_support_append_right _ _ q.start_mem_support + have he := path_metric_additive T hT _ hpq hb + rw [T.dist_comm (u := a) (v := b)] at he + exact he.symm + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutAcylindrical.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutAcylindrical.lean new file mode 100644 index 0000000000000000000000000000000000000000..996b0b614ea7c748b411008c2f216b860bdb9457 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutAcylindrical.lean @@ -0,0 +1,63 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeSegmentCount +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutPosition +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeInteriorImage + +namespace OAI + +/-! Uniform acylindricity of the graph obtained by coning off segment-free paths. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (u v : V) + +/-- The constants depend only on displacement and on the chosen free +segment, even when the original tree has infinite-valence vertices. -/ +theorem avoidingGraph_acylindrical_count (hT : T.IsTree) + (hA : PreservesAdj (G := G) T) (hfree : pairStabilizer (G := G) u v=⊥) + (hne : u≠v) (hnadj : ¬T.Adj u v) (r : ℕ) (x y : V) + (hxy : 2*r+10 ≤ (avoidingGraph (G := G) T u v).dist x y) : + {g : G | (avoidingGraph (G := G) T u v).dist x (g • x) ≤ r ∧ + (avoidingGraph (G := G) T u v).dist y (g • y) ≤ r}.Finite ∧ + {g : G | (avoidingGraph (G := G) T u v).dist x (g • x) ≤ r ∧ + (avoidingGraph (G := G) T u v).dist y (g • y) ≤ r}.ncard ≤ + (2*r+10)*(2*T.dist u v+1)^2 := by + let H := avoidingGraph (G := G) T u v + have hH : H.Connected := avoidingGraph_connected T u v hT hA hne hnadj + have hS : PathSaturated T H := avoidingGraph_pathSaturated T u v hT.isAcyclic + have hB : PreservesAdj (G := G) H := avoidingGraph_preservesAdj T u v hA + obtain ⟨p,hp⟩ := hT.connected.exists_isPath x y + obtain ⟨a,ha⟩ := exists_interior_segment T u v hT hA hne hnadj p hp r hxy + obtain ⟨b,hb,hdb⟩ := tree_walk_level T u v hT hA hne hnadj p (2*r+10) hxy + let q := p.takeUntil b hb + have hq : q.IsPath := hp.takeUntil hb + let A : Set G := {g | H.dist x (g • x) ≤ r ∧ H.dist y (g • y) ≤ r} + let B := segmentOccurrences (G := G) u v T q + have hmap : ∀ g∈A,g*a∈B := by + intro g hg + have hm (w : V) (hw : w∈({u,v} : Set V)) : (g*a) • w∈q.support := by + obtain ⟨hmem,hleft,hright,hupper⟩ := ha w hw + have himage : g • (a • w)∈p.support := + image_mem_of_deep T H hT hH hS hA hB p hp hmem r hleft hright g hg.1 hg.2 + have hdist : H.dist x (g • (a • w)) ≤ 2*r+8 := by + have htri := hH.dist_triangle (u := x) (v := g • x) (w := g • (a • w)) + rw [graph_action_dist H hH hB g x (a • w)] at htri + have hgx : H.dist x (g • x) ≤ r := hg.1 + change H.dist x (a • w) ≤ r+8 at hupper + omega + rw [mul_smul] + exact bounded_vertices_in_prefix T H hT hH hS p hp hb himage (2*r+8) + (by simpa only [Nat.add_assoc] using hdb) hdist + exact ⟨hm u (by simp),hm v (by simp)⟩ + have hinj : Function.Injective (fun g : G => g*a) := fun _ _ h => mul_right_cancel h + have hfinB : B.Finite := segmentOccurrences_finite hfree T q + have hfinA : A.Finite := (hfinB.preimage hinj.injOn).subset hmap + refine ⟨hfinA,?_⟩ + calc + A.ncard ≤ B.ncard := Set.ncard_le_ncard_of_injOn (fun g : G => g*a) hmap hinj.injOn hfinB + _ ≤ H.dist x b*(2*T.dist u v+1)^2 := + segmentOccurrences_bound_dist T u v hT hA hfree hne hnadj q hq + _ = (2*r+10)*(2*T.dist u v+1)^2 := by rw [hdb] + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutHyperbolic.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutHyperbolic.lean new file mode 100644 index 0000000000000000000000000000000000000000..7b537ddec342c3b258afd1589f1c1ae92ceed85d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutHyperbolic.lean @@ -0,0 +1,86 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeTripod +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeShortcutMetric +import Mathlib.Tactic.Linarith +import Mathlib.Basic.Real.Basic + +namespace OAI + +/-! Gromov hyperbolicity of a tree with convex shortcuts. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} (T H : SimpleGraph V) + +noncomputable def graphProduct (o x y : V) : ℝ := + ((H.dist o x : ℝ)+H.dist o y-H.dist x y)/2 + +lemma graphProduct_branch_bounds (hT : T.IsTree) (hH : H.Connected) + (hS : PathSaturated T H) {o x y b : V} + (p : T.Walk o x) (q : T.Walk o y) (r : T.Walk x y) + (hp : p.IsPath) (hq : q.IsPath) (hr : r.IsPath) + (hbp : b∈p.support) (hbq : b∈q.support) (hbr : b∈r.support) : + (H.dist o b : ℝ)-1≤graphProduct H o x y ∧ + graphProduct H o x y≤H.dist o b+1 := by + have h1 : (H.dist o b : ℝ)+H.dist b x≤H.dist o x+1 := by + exact_mod_cast shortcut_dist_split T H hT hH hS p hp hbp + have h2 : (H.dist o b : ℝ)+H.dist b y≤H.dist o y+1 := by + exact_mod_cast shortcut_dist_split T H hT hH hS q hq hbq + have h3 : (H.dist b x : ℝ)+H.dist b y≤H.dist x y+1 := by + have h := shortcut_dist_split T H hT hH hS r hr hbr + rw [H.dist_comm (u := x) (v := b)] at h + exact_mod_cast h + have t1 : (H.dist o x : ℝ)≤H.dist o b+H.dist b x := by + exact_mod_cast hH.dist_triangle (u := o) (v := b) (w := x) + have t2 : (H.dist o y : ℝ)≤H.dist o b+H.dist b y := by + exact_mod_cast hH.dist_triangle (u := o) (v := b) (w := y) + have t3 : (H.dist x y : ℝ)≤H.dist b x+H.dist b y := by + have h := hH.dist_triangle (u := x) (v := b) (w := y) + rw [H.dist_comm (u := x) (v := b)] at h + exact_mod_cast h + unfold graphProduct + constructor <;> linarith + +/-- Convex shortcuts preserve hyperbolicity, with a uniform constant. -/ +theorem shortcut_graph_hyperbolic (hT : T.IsTree) (hH : H.Connected) + (hS : PathSaturated T H) (o x y z : V) : + min (graphProduct H o x y) (graphProduct H o y z)≤graphProduct H o x z+3 := by + obtain ⟨p,hp⟩ := hT.connected.exists_isPath o x + obtain ⟨q,hq⟩ := hT.connected.exists_isPath o y + obtain ⟨r,hr⟩ := hT.connected.exists_isPath o z + obtain ⟨pxy,hxy⟩ := hT.connected.exists_isPath x y + obtain ⟨pyz,hyz⟩ := hT.connected.exists_isPath y z + obtain ⟨pxz,hxz⟩ := hT.connected.exists_isPath x z + obtain ⟨a,hap,haq,haxy,_⟩ := tree_branchpoint T hT.isAcyclic p q pxy hp hq hxy + obtain ⟨b,hbq,hbr,hbyz,_⟩ := tree_branchpoint T hT.isAcyclic q r pyz hq hr hyz + obtain ⟨c,hcp,hcr,hcxz,hcmax⟩ := tree_branchpoint T hT.isAcyclic p r pxz hp hr hxz + have hga := graphProduct_branch_bounds T H hT hH hS p q pxy hp hq hxy hap haq haxy + have hgb := graphProduct_branch_bounds T H hT hH hS q r pyz hq hr hyz hbq hbr hbyz + have hgc := graphProduct_branch_bounds T H hT hH hS p r pxz hp hr hxz hcp hcr hcxz + rcases prefixes_comparable T q haq hbq with hab|hba + · have he : q.takeUntil b hbq=r.takeUntil b hbr := congrArg Subtype.val + (hT.isAcyclic.subsingleton_path o b |>.elim + ⟨_,hq.takeUntil hbq⟩ ⟨_,hr.takeUntil hbr⟩) + have har : a∈r.support := r.support_takeUntil_subset_support hbr (he ▸ hab) + have hac := hcmax a hap har + have hd := shortcut_dist_split T H hT hH hS (p.takeUntil c hcp) (hp.takeUntil hcp) hac + have hd' : (H.dist o a : ℝ)≤H.dist o c+1 := by + have hn : H.dist o a≤H.dist o c+1 := by omega + exact_mod_cast hn + calc + min (graphProduct H o x y) (graphProduct H o y z)≤graphProduct H o x y := min_le_left _ _ + _ ≤ graphProduct H o x z+3 := by linarith [hga.2,hgc.1] + · have he : q.takeUntil a haq=p.takeUntil a hap := congrArg Subtype.val + (hT.isAcyclic.subsingleton_path o a |>.elim + ⟨_,hq.takeUntil haq⟩ ⟨_,hp.takeUntil hap⟩) + have hbp : b∈p.support := p.support_takeUntil_subset_support hap (he ▸ hba) + have hbc := hcmax b hbp hbr + have hd := shortcut_dist_split T H hT hH hS (p.takeUntil c hcp) (hp.takeUntil hcp) hbc + have hd' : (H.dist o b : ℝ)≤H.dist o c+1 := by + have hn : H.dist o b≤H.dist o c+1 := by omega + exact_mod_cast hn + calc + min (graphProduct H o x y) (graphProduct H o y z)≤graphProduct H o y z := min_le_right _ _ + _ ≤ graphProduct H o x z+3 := by linarith [hgb.2,hgc.1] + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutMetric.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutMetric.lean new file mode 100644 index 0000000000000000000000000000000000000000..b4f779ce9f21ff6ea78a9af7ac5d8ff3a0389bc5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutMetric.lean @@ -0,0 +1,70 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePathMetric + +namespace OAI + +/-! Tree paths are approximate geodesics in a graph with convex shortcuts. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +variable {V : Type} (T H : SimpleGraph V) + +/-- Every path shortcut includes all shorter shortcuts along the same tree path. -/ +def PathSaturated : Prop := ∀ ⦃x y⦄, H.Adj x y → + ∀ p : T.Walk x y,p.IsPath → ∀ a∈p.support,∀ b∈p.support,a≠b → H.Adj a b + +lemma shortcut_adj_split (hS : PathSaturated T H) {x y w : V} + (hxy : H.Adj x y) (p : T.Walk x y) (hp : p.IsPath) (hw : w∈p.support) : + ∃ (q : H.Walk x w) (r : H.Walk w y),q.length≤1 ∧ r.length≤1 := by + have hx : ∃ q : H.Walk x w,q.length≤1 := by + by_cases he : x=w + · subst w + exact ⟨.nil,by simp⟩ + · exact ⟨(hS hxy p hp x p.start_mem_support w hw he).toWalk,by simp⟩ + have hy : ∃ r : H.Walk w y,r.length≤1 := by + by_cases he : w=y + · subst w + exact ⟨.nil,by simp⟩ + · exact ⟨(hS hxy p hp w hw y p.end_mem_support he).toWalk,by simp⟩ + obtain ⟨q,hq⟩ := hx + obtain ⟨r,hr⟩ := hy + exact ⟨q,r,hq,hr⟩ + +lemma shortcut_path_split (hT : T.IsTree) (hS : PathSaturated T H) + {x y : V} (q : H.Walk x y) (p : T.Walk x y) (hp : p.IsPath) + {w : V} (hw : w∈p.support) : + ∃ (a : H.Walk x w) (b : H.Walk w y),a.length+b.length≤q.length+1 := by + induction q with + | nil => + have he : p=.nil := congrArg Subtype.val + (hT.isAcyclic.subsingleton_path _ _ |>.elim ⟨p,hp⟩ ⟨.nil,by simp⟩) + rw [he] at hw + simp only [SimpleGraph.Walk.support_nil,List.mem_singleton] at hw + subst w + exact ⟨.nil,.nil,by simp⟩ + | @cons x z y hxz q ih => + obtain ⟨r,hr⟩ := hT.connected.exists_isPath x z + obtain ⟨s,hs⟩ := hT.connected.exists_isPath z y + rcases path_support_subset_append T hT.isAcyclic p hp r s hw with hw|hw + · obtain ⟨a,b,ha,hb⟩ := shortcut_adj_split T H hS hxz r hr hw + refine ⟨a,b.append q,?_⟩ + simp only [SimpleGraph.Walk.length_append,SimpleGraph.Walk.length_cons] + omega + · obtain ⟨a,b,hab⟩ := ih s hs hw + refine ⟨a.cons hxz,b,?_⟩ + simp only [SimpleGraph.Walk.length_cons] + omega + +/-- A tree-path point splits distance in the shortcut graph up to one edge. -/ +theorem shortcut_dist_split (hT : T.IsTree) (hH : H.Connected) + (hS : PathSaturated T H) {x y w : V} + (p : T.Walk x y) (hp : p.IsPath) (hw : w∈p.support) : + H.dist x w+H.dist w y≤H.dist x y+1 := by + obtain ⟨q,hq⟩ := hH.exists_walk_length_eq_dist x y + obtain ⟨a,b,hab⟩ := shortcut_path_split T H hT hS q p hp hw + calc + H.dist x w+H.dist w y ≤ a.length+b.length := + Nat.add_le_add (H.dist_le a) (H.dist_le b) + _ ≤ q.length+1 := hab + _ = H.dist x y+1 := by rw [hq] + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutPosition.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutPosition.lean new file mode 100644 index 0000000000000000000000000000000000000000..8598aeff31b8af26b54c4da870e540ed4f6dfaa6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeShortcutPosition.lean @@ -0,0 +1,90 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeAvoidingGraph +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeTripod +import OAI.Topology.ArtinGroups.ParabolicIntersections.GraphWalkLevels + +namespace OAI + +/-! Interior segments and prefixes in the shortcut metric. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (u v : V) + +lemma tree_walk_level (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + (hne : u≠v) (hnadj : ¬T.Adj u v) {x y : V} + (p : T.Walk x y) (k : ℕ) (hk : k ≤ (avoidingGraph (G := G) T u v).dist x y) : + ∃ w∈p.support,(avoidingGraph (G := G) T u v).dist x w=k := by + let H := avoidingGraph (G := G) T u v + have hH := avoidingGraph_connected T u v hT hA hne hnadj + have hle := le_avoidingGraph T u v hT.isAcyclic hA hne hnadj + obtain ⟨w,hw,hd⟩ := walk_exists_dist_level H hH x (p.mapLe hle) k (by simp) hk + exact ⟨w,by simpa only [SimpleGraph.Walk.support_mapLe_eq_support] using hw,hd⟩ + +/-- A long shortcut path contains a translate of the fixed segment +well inside both ends, and at bounded distance from its first end. -/ +theorem exists_interior_segment (hT : T.IsTree) (hA : PreservesAdj (G := G) T) + (hne : u≠v) (hnadj : ¬T.Adj u v) {x y : V} + (p : T.Walk x y) (hp : p.IsPath) (r : ℕ) + (hxy : 2*r+10 ≤ (avoidingGraph (G := G) T u v).dist x y) : + ∃ g : G, ∀ w∈({u,v} : Set V), g • w∈p.support ∧ + r+1 < (avoidingGraph (G := G) T u v).dist x (g • w) ∧ + r+1 < (avoidingGraph (G := G) T u v).dist y (g • w) ∧ + (avoidingGraph (G := G) T u v).dist x (g • w) ≤ r+8 := by + let H := avoidingGraph (G := G) T u v + have hH := avoidingGraph_connected T u v hT hA hne hnadj + have hS := avoidingGraph_pathSaturated (G := G) T u v hT.isAcyclic + obtain ⟨a,ha,hda⟩ := tree_walk_level T u v hT hA hne hnadj p (r+5) (by omega) + have hay : 2 ≤ H.dist a y := by + have hh := hH.dist_triangle (u := x) (v := a) (w := y) + change H.dist x a=r+5 at hda + change 2*r+10 ≤ H.dist x y at hxy + dsimp only [H] at * + omega + let s := p.dropUntil a ha + have hs : s.IsPath := hp.dropUntil ha + obtain ⟨b,hb,hdb⟩ := tree_walk_level T u v hT hA hne hnadj s 2 hay + let t := s.takeUntil b hb + have ht : t.IsPath := hs.takeUntil hb + have hseg : ContainsSegment (G := G) u v T t := by + by_contra hn + have hab : a≠b := by + intro he + subst b + simp at hdb + have hadj := avoidingGraph_subpath T u v hT.isAcyclic t hn + t.start_mem_support t.end_mem_support hab + have hd := H.dist_eq_one_iff_adj.mpr hadj + change H.dist a b=2 at hdb + omega + obtain ⟨g,hgu,hgv⟩ := hseg + refine ⟨g,?_⟩ + intro w hw + have hgw : g • w∈t.support := by + rcases Set.mem_insert_iff.mp hw with he|he + · exact he ▸ hgu + · exact Set.mem_singleton_iff.mp he ▸ hgv + have hdist := shortcut_dist_split T H hT hH hS t ht hgw + change H.dist a b=2 at hdb + have hnear : H.dist a (g • w) ≤ 3 := by omega + have hmem : g • w∈p.support := + p.support_dropUntil_subset_support ha (s.support_takeUntil_subset_support hb hgw) + have hx := hH.dist_triangle (u := x) (v := g • w) (w := a) + have hy := hH.dist_triangle (u := x) (v := a) (w := g • w) + have hz := hH.dist_triangle (u := x) (v := g • w) (w := y) + rw [H.dist_comm (u := g • w) (v := a)] at hx + rw [H.dist_comm (u := g • w) (v := y)] at hz + refine ⟨hmem,?_,?_,?_⟩ <;> dsimp only [H] at * <;> omega + +lemma bounded_vertices_in_prefix (H : SimpleGraph V) (hT : T.IsTree) + (hH : H.Connected) (hS : PathSaturated T H) {x y b w : V} + (p : T.Walk x y) (hp : p.IsPath) (hb : b∈p.support) (hw : w∈p.support) + (K : ℕ) (hdb : H.dist x b=K+2) (hdw : H.dist x w ≤ K) : + w∈(p.takeUntil b hb).support := by + rcases prefixes_comparable T p hw hb with h|h + · exact h + · have hh := shortcut_dist_split T H hT hH hS (p.takeUntil w hw) (hp.takeUntil hw) h + omega + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeTranslationSegment.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeTranslationSegment.lean new file mode 100644 index 0000000000000000000000000000000000000000..651ce5bf7ec58c8bcb48a5ea0ed55a39f36bcb10 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeTranslationSegment.lean @@ -0,0 +1,87 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePeriodicPaths + +namespace OAI + +/-! Reflecting a segment at both ends constructs a tree translation. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {G V : Type} [Group G] [MulAction G V] +variable (T : SimpleGraph V) (hA : PreservesAdj (G := G) T) + +abbrev actPath (g : G) {x y : V} (p : T.Walk x y) : T.Walk (g • x) (g • y) := + p.map ⟨(g • ·),hA g⟩ + +lemma actPath_copy_length (g : G) {x y x' y' : V} (p : T.Walk x y) + (hx : g • x=x') (hy : g • y=y') : + ((actPath T hA g p).copy hx hy).length=p.length := + (SimpleGraph.Walk.length_copy _ _ _).trans (SimpleGraph.Walk.length_map _ _) + +lemma actPath_copy_snd (g : G) {x y x' y' : V} (p : T.Walk x y) + (hx : g • x=x') (hy : g • y=y') : + ((actPath T hA g p).copy hx hy).snd=g • p.snd := by + change ((actPath T hA g p).copy hx hy).getVert 1=g • p.getVert 1 + rw [SimpleGraph.Walk.getVert_copy,SimpleGraph.Walk.getVert_map] + rfl + +lemma actPath_copy_reverse_snd (g : G) {x y x' y' : V} (p : T.Walk x y) + (hx : g • x=x') (hy : g • y=y') : + ((actPath T hA g p).copy hx hy).reverse.snd=g • p.reverse.snd := by + change ((actPath T hA g p).copy hx hy).reverse.getVert 1=g • p.reverse.getVert 1 + rw [SimpleGraph.Walk.reverse_copy,SimpleGraph.Walk.getVert_copy,SimpleGraph.Walk.reverse_map, + SimpleGraph.Walk.getVert_map] + rfl + +lemma append_first {x y z : V} (p : T.Walk x y) (q : T.Walk y z) + (hp : ¬p.Nil) : (p.append q).snd=p.snd := by + cases p with + | nil => exact (hp .nil).elim + | cons h p => simp only [SimpleGraph.Walk.cons_append,SimpleGraph.Walk.snd_cons] + +include hA in +theorem translation_segment (hT : T.IsAcyclic) {u v : V} + (p : T.Walk u v) (hp : p.IsPath) (hpn : ¬p.Nil) + (a b : G) (ha : a • u=u) (hb : b • v=v) + (ha' : a • p.snd≠p.snd) (hb' : b • p.reverse.snd≠p.reverse.snd) : + ∃ q : T.Walk u ((a*b) • u), q.IsPath ∧ ¬q.Nil ∧ + q.reverse.snd≠(a*b) • q.snd ∧ a • u∈q.support ∧ a • v∈q.support := by + let l := (actPath T hA a p).copy ha rfl + let r := (actPath T hA (a*b) p.reverse).copy (by rw [mul_smul,hb]) rfl + have hl : l.IsPath := (SimpleGraph.Walk.isPath_copy _ _ _).mpr (hp.map (MulAction.toPerm a).injective) + have hr : r.IsPath := (SimpleGraph.Walk.isPath_copy _ _ _).mpr (hp.reverse.map (MulAction.toPerm (a*b)).injective) + have hlenl : l.length=p.length := by simp only [l,SimpleGraph.Walk.length_copy,SimpleGraph.Walk.length_map] + have hlenr : r.length=p.length := by simp only [r,SimpleGraph.Walk.length_copy,SimpleGraph.Walk.length_map,SimpleGraph.Walk.length_reverse] + have hn : 0 < p.length := Nat.pos_of_ne_zero (fun he => hpn (SimpleGraph.Walk.length_eq_zero_iff.mp he)) + have hln : ¬l.Nil := fun h => (by have he := h.length_eq_zero; omega) + have hrn : ¬r.reverse.Nil := by + intro h + have he := h.length_eq_zero + rw [SimpleGraph.Walk.length_reverse,hlenr] at he + omega + have hls : l.snd=a • p.snd := actPath_copy_snd T hA a p ha rfl + have hlrs : l.reverse.snd=a • p.reverse.snd := actPath_copy_reverse_snd T hA a p ha rfl + have hrs : r.snd=(a*b) • p.reverse.snd := + actPath_copy_snd T hA (a*b) p.reverse _ rfl + have hrrs : r.reverse.snd=(a*b) • p.snd := by + simpa only [SimpleGraph.Walk.reverse_reverse] using + actPath_copy_reverse_snd T hA (a*b) p.reverse (by rw [mul_smul,hb]) rfl + have hsep : l.reverse.snd≠r.snd := by + rw [hlrs,hrs,mul_smul] + exact fun he => hb' ((MulAction.toPerm a).injective he).symm + have hq : (l.append r).IsPath := by + have h := reverse_append_isPath T hT l.reverse r hl.reverse hr hsep + simpa only [SimpleGraph.Walk.reverse_reverse] using h + refine ⟨l.append r,hq,?_,?_,?_,?_⟩ + · intro h + have he := h.length_eq_zero + rw [SimpleGraph.Walk.length_append,hlenl,hlenr] at he + omega + · rw [SimpleGraph.Walk.reverse_append,append_first T r.reverse l.reverse hrn, + append_first T l r hln,hls,hrrs] + exact fun he => ha' ((MulAction.toPerm (a*b)).injective he).symm + · rw [ha] + exact (l.append r).start_mem_support + · exact SimpleGraph.Walk.support_subset_support_append_left l r l.end_mem_support + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeTripod.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeTripod.lean new file mode 100644 index 0000000000000000000000000000000000000000..598eff4972574f23cfaf1246d4fea55fefefb8aa --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/TreeTripod.lean @@ -0,0 +1,127 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePaths +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreePathMetric + +namespace OAI + +/-! Common prefixes and tripods for paths in a tree. -/ +namespace HarmonicArtin.ParabolicIntersections.TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {V : Type} (T : SimpleGraph V) + +lemma walk_common_prefix {x y z : V} (p : T.Walk x y) (q : T.Walk x z) : + ∃ b, ∃ (r : T.Walk x b) (s : T.Walk b y) (t : T.Walk b z), + p=r.append s ∧ q=r.append t ∧ (s.Nil ∨ t.Nil ∨ s.snd≠t.snd) := by + classical + induction p generalizing z with + | nil => exact ⟨_,.nil,.nil,q,by simp,by simp,Or.inl .nil⟩ + | @cons x v y h p ih => + cases q with + | nil => exact ⟨x,.nil,p.cons h,.nil,by simp,by simp,Or.inr (Or.inl .nil)⟩ + | @cons _ w z h' q => + by_cases he : v=w + · subst w + obtain ⟨b,r,s,t,hp,hq,hd⟩ := ih q + refine ⟨b,r.cons h,s,t,?_,?_,hd⟩ + · rw [hp] + rfl + · rw [hq] + rfl + · refine ⟨x,.nil,p.cons h,q.cons h',by simp,by simp,Or.inr (Or.inr ?_)⟩ + simpa only [SimpleGraph.Walk.snd_cons] using he + +lemma tree_tripod (hT : T.IsAcyclic) {x y z : V} + (p : T.Walk x y) (q : T.Walk x z) (r : T.Walk y z) + (hp : p.IsPath) (hq : q.IsPath) (hr : r.IsPath) : + ∃ b,b∈p.support ∧ b∈q.support ∧ b∈r.support := by + obtain ⟨b,a,s,t,hp',hq',hd⟩ := walk_common_prefix T p q + have hs : s.IsPath := (hp' ▸ hp).of_append_right + have ht : t.IsPath := (hq' ▸ hq).of_append_right + have hst : (s.reverse.append t).IsPath := by + rcases hd with hn|hn|hne + · cases hn + simpa using ht + · cases hn + simpa using hs.reverse + · exact reverse_append_isPath T hT s t hs ht hne + have he : r=s.reverse.append t := congrArg Subtype.val + (hT.subsingleton_path y z |>.elim ⟨r,hr⟩ ⟨_,hst⟩) + refine ⟨b,?_,?_,?_⟩ + · rw [hp'] + exact SimpleGraph.Walk.support_subset_support_append_right a s s.start_mem_support + · rw [hq'] + exact SimpleGraph.Walk.support_subset_support_append_right a t t.start_mem_support + · rw [he] + exact SimpleGraph.Walk.support_subset_support_append_right s.reverse t t.start_mem_support + +lemma prefixes_comparable {x y a b : V} (p : T.Walk x y) + (ha : a∈p.support) (hb : b∈p.support) : + a∈(p.takeUntil b hb).support ∨ b∈(p.takeUntil a ha).support := by + classical + rcases le_total (p.takeUntil a ha).length (p.takeUntil b hb).length with h|h + · left + have he : (p.takeUntil b hb).getVert (p.takeUntil a ha).length=a := by + rw [p.getVert_takeUntil hb h,p.getVert_length_takeUntil ha] + exact he ▸ (p.takeUntil b hb).getVert_mem_support _ + · right + have he : (p.takeUntil a ha).getVert (p.takeUntil b hb).length=b := by + rw [p.getVert_takeUntil ha h,p.getVert_length_takeUntil hb] + exact he ▸ (p.takeUntil a ha).getVert_mem_support _ + +lemma common_support_in_prefix (hT : T.IsAcyclic) {x b y z w : V} + (a : T.Walk x b) (s : T.Walk b y) (t : T.Walk b z) + (hs : s.IsPath) (ht : t.IsPath) (hd : s.Nil ∨ t.Nil ∨ s.snd≠t.snd) + (hw : w∈(a.append s).support) (hw' : w∈(a.append t).support) : + w∈a.support := by + rcases hd with hn|hn|hne + · cases hn + simpa only [SimpleGraph.Walk.append_nil] using hw + · cases hn + simpa only [SimpleGraph.Walk.append_nil] using hw' + · by_contra hwa + have hws := ((SimpleGraph.Walk.mem_support_append_iff a s).mp hw).resolve_left hwa + have hwt := ((SimpleGraph.Walk.mem_support_append_iff a t).mp hw').resolve_left hwa + have he := common_support_eq_start T hT s t hs ht hne hws hwt + exact hwa (he.symm ▸ a.end_mem_support) + +/-- The common prefix contains every common vertex of the two paths. -/ +lemma tree_branchpoint (hT : T.IsAcyclic) {x y z : V} + (p : T.Walk x y) (q : T.Walk x z) (r : T.Walk y z) + (hp : p.IsPath) (hq : q.IsPath) (hr : r.IsPath) : + ∃ b, ∃ hbp : b∈p.support, + b∈q.support ∧ b∈r.support ∧ + ∀ w∈p.support,w∈q.support → w∈(p.takeUntil b hbp).support := by + classical + obtain ⟨b,a,s,t,hp',hq',hd⟩ := walk_common_prefix T p q + have ha : a.IsPath := (hp' ▸ hp).of_append_left + have hs : s.IsPath := (hp' ▸ hp).of_append_right + have ht : t.IsPath := (hq' ▸ hq).of_append_right + have hbp : b∈p.support := by + rw [hp'] + exact SimpleGraph.Walk.support_subset_support_append_left a s a.end_mem_support + have hbq : b∈q.support := by + rw [hq'] + exact SimpleGraph.Walk.support_subset_support_append_left a t a.end_mem_support + have hst : (s.reverse.append t).IsPath := by + rcases hd with hn|hn|hne + · cases hn + simpa using ht + · cases hn + simpa using hs.reverse + · exact reverse_append_isPath T hT s t hs ht hne + have he : r=s.reverse.append t := congrArg Subtype.val + (hT.subsingleton_path y z |>.elim ⟨r,hr⟩ ⟨_,hst⟩) + have hbr : b∈r.support := by + rw [he] + exact SimpleGraph.Walk.support_subset_support_append_right s.reverse t t.start_mem_support + refine ⟨b,hbp,hbq,hbr,?_⟩ + have htake : p.takeUntil b hbp=a := congrArg Subtype.val + (hT.subsingleton_path x b |>.elim ⟨_,hp.takeUntil hbp⟩ ⟨a,ha⟩) + intro w hwp hwq + rw [htake] + apply common_support_in_prefix T hT a s t hs ht hd + · rwa [←hp'] + · rwa [←hq'] + +end HarmonicArtin.ParabolicIntersections.TreeAction + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/UnconditionalMain.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/UnconditionalMain.lean new file mode 100644 index 0000000000000000000000000000000000000000..5156d8edfcc55176a8ce8350d67fd3288c8ef5dc --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/UnconditionalMain.lean @@ -0,0 +1,64 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshMain +import OAI.Topology.ArtinGroups.ParabolicIntersections.SphericalMesh + +namespace OAI + +/-! +# Unconditional parabolic intersections and closure + +The spherical mesh input is proved by weighted path contractions and finite +Jones--Wenzl projections. Together with the proved standard embeddings, +folding, and acyclic evaluation, this discharges every input to Theorem 1.1 +and Corollary 1.2 of paper 082-03. The dynamical corollary below still names +its separate published geometric input explicitly. +-/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +/-- The full spherical mesh input, without hypotheses from the literature. -/ +theorem spherical_mesh_input : PublishedMeshInput M := + fun Y hY => spherical_mesh_nilpotent M Y hY + +local instance : LinearOrder (S⊕Unit) := Sum.Lex.linearOrder + +/-- The stronger inside-parabolic form used in the rank arguments. -/ +theorem unconditional_inside_intersection : InsideIntersectionProperty M := + inside_intersection M (relative_embedding_input M) + (fun X => ((spherical_mesh_input (relativeMatrix M X)).withAlgebra _).withAcyclic _) + +/-- Paper 082-03, Theorem 1.1, with every published input discharged. -/ +theorem unconditional_parabolic_intersections + (X Y : Set S) (g h : Artin M) : + ∃ (Z : Set S) (k : Artin M), + conjugate g (artinParabolic M X) ⊓ conjugate h (artinParabolic M Y) = + conjugate k (artinParabolic M Z) := + parabolic_intersections_of_mesh M (fun X => spherical_mesh_input (relativeMatrix M X)) X Y g h + +/-- Paper 082-03, Corollary 1.2: arbitrary intersections and the rank bound. -/ +theorem unconditional_arbitrary_intersections + (F : Set (Subgroup (Artin M))) (hF : ∀ P ∈ F, IsParabolic M P) : + (∃ F₀ : Finset (Subgroup (Artin M)), + (↑F₀ : Set (Subgroup (Artin M))) ⊆ F ∧ F₀.card ≤ Nat.card S ∧ + sInf F = sInf (↑F₀ : Set (Subgroup (Artin M)))) ∧ IsParabolic M (sInf F) := + arbitrary_intersections_of_mesh M (fun X => spherical_mesh_input (relativeMatrix M X)) F hF + +/-- Paper 082-03, Corollary 1.2: the unique smallest containing parabolic. -/ +theorem unconditional_parabolic_closure (E : Set (Artin M)) : + ∃! P : Subgroup (Artin M), IsParabolic M P ∧ E ⊆ P ∧ + ∀ Q : Subgroup (Artin M), IsParabolic M Q → E ⊆ Q → P ≤ Q := + parabolic_closure_of_mesh M (fun X => spherical_mesh_input (relativeMatrix M X)) E + +/-- Paper 082-03, Corollary 1.3, conditional only on the geometric criteria +of Charney--Martin--Morris-Wright, Theorem 3.2 and Proposition 4.2. -/ +theorem nonclique_dynamics_of_visual_splitting + (hVisual : PublishedVisualSplitting M) + (hIrred : IsIrreducible M) (hInf : ∃ s t : S, s ≠ t ∧ M s t=0) : + AcylindricallyHyperbolic (Artin M) ∧ + ∀ P : Subgroup (Artin M), IsParabolic M P → P ≠ ⊤ → WeaklyMalnormal P := + nonclique_dynamics_of_mesh M (fun X => spherical_mesh_input (relativeMatrix M X)) + hVisual hIrred hInf + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAcylindrical.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAcylindrical.lean new file mode 100644 index 0000000000000000000000000000000000000000..58e8c55e723af5b325caf75b18abf3655bef3e93 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAcylindrical.lean @@ -0,0 +1,35 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeBranchingHyperbolic +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualInfiniteBranching + +namespace OAI + +/-! +# An unconditional acylindrical action for the Artin visual splitting + +The sufficient Artin case of Minasyan--Osin (2015), Corollary 2.2, +is proved here by constructing a geodesic hyperbolic realization of the +shortcut graph, a uniform acylindricity bound, and three distinct orbit +limit points. No instance of the published amalgam criterion is assumed. +-/ +namespace HarmonicArtin.ParabolicIntersections +open TreeAction +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance visualAcylindricalAction : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +include hSplit in +theorem visual_acylindricallyHyperbolic (hIrred : IsIrreducible M) : + AcylindricallyHyperbolic (Artin M) := by + obtain ⟨u,v,hne,hu,hv,hfree⟩ := visual_trivial_pair_distinct_type M Y Z hIrred false + apply acylindricallyHyperbolic_of_free_segment (visualGraph M Y Z) + (visualGraph_isTree M Y Z) (visual_preservesAdj M Y Z) ?_ u v hne ?_ hfree + · intro x y hxy + obtain ⟨a,ha,hinj⟩ := visual_infinite_branching M Y Z hxy + exact ⟨a,ha,hinj⟩ + · intro h + exact h.1 (hu.trans hv.symm) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAmalgam.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAmalgam.lean new file mode 100644 index 0000000000000000000000000000000000000000..50785af9ff0ffb31837d52e79f39506d59c4d940 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAmalgam.lean @@ -0,0 +1,173 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsDefinitions +import OAI.Topology.ArtinGroups.Harmonic.RestrictedArtinHom +import Mathlib.GroupTheory.PushoutI +import OAI.Topology.ArtinGroups.Coxeter.AlternatingLiftProd + +namespace OAI + +/-! The actual amalgamated-product presentation of a visual splitting. +The factors and edge group are the standard subgroups of the given Artin +group, and the inverse homomorphism is constructed from its braid relators. -/ +namespace HarmonicArtin.ParabolicIntersections +open CoxeterExchange +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} (M : CoxeterMatrix S) (Y Z : Set S) + +def visualSide : Bool → Set S + | false => Y + | true => Z + +noncomputable def visualEdgeInclusion (b : Bool) : + artinParabolic M (Y∩Z) →* artinParabolic M (visualSide Y Z b) := + Subgroup.inclusion (standard_mono M (by cases b <;> simp [visualSide])) + +abbrev VisualAmalgam := Monoid.PushoutI (visualEdgeInclusion M Y Z) + +noncomputable def visualToArtin : VisualAmalgam M Y Z →* Artin M := + Monoid.PushoutI.lift (fun b => (artinParabolic M (visualSide Y Z b)).subtype) + (artinParabolic M (Y∩Z)).subtype (by intro b; rfl) + +lemma visualSplit_cover (hsplit : IsVisualSplit M Y Z) (s : S) : s∈Y ∨ s∈Z := by + change s∈Y∪Z + rw [hsplit.1] + trivial + +lemma visualSplit_finite_edge (hsplit : IsVisualSplit M Y Z) (s t : S) + (hm : M s t≠0) : ∃ b, s∈visualSide Y Z b ∧ t∈visualSide Y Z b := by + by_cases hsY : s∈Y + · by_cases htY : t∈Y + · exact ⟨false,hsY,htY⟩ + · have htZ := (visualSplit_cover M Y Z hsplit t).resolve_left htY + by_cases hsZ : s∈Z + · exact ⟨true,hsZ,htZ⟩ + · exact False.elim (hm (hsplit.2.2.2 s ⟨hsY,hsZ⟩ t ⟨htZ,htY⟩)) + · have hsZ := (visualSplit_cover M Y Z hsplit s).resolve_left hsY + by_cases htZ : t∈Z + · exact ⟨true,hsZ,htZ⟩ + · have htY := (visualSplit_cover M Y Z hsplit t).resolve_right htZ + exact False.elim (hm ((M.symmetric s t).trans + (hsplit.2.2.2 t ⟨htY,htZ⟩ s ⟨hsZ,hsY⟩))) + +noncomputable def visualGenerator (hsplit : IsVisualSplit M Y Z) (s : S) : VisualAmalgam M Y Z := + if hs : s∈Y then Monoid.PushoutI.of false + ⟨generator M s,Subgroup.subset_closure ⟨s,hs,rfl⟩⟩ + else Monoid.PushoutI.of true + ⟨generator M s,Subgroup.subset_closure + ⟨s,(visualSplit_cover M Y Z hsplit s).resolve_left hs,rfl⟩⟩ + +lemma visualGenerator_eq (hsplit : IsVisualSplit M Y Z) (b : Bool) (s : S) + (hs : s∈visualSide Y Z b) : + visualGenerator M Y Z hsplit s=Monoid.PushoutI.of b + ⟨generator M s,Subgroup.subset_closure ⟨s,hs,rfl⟩⟩ := by + cases b with + | false => simp [visualGenerator,show s∈Y from hs] + | true => + by_cases hy : s∈Y + · let x : artinParabolic M (Y∩Z) := + ⟨generator M s,Subgroup.subset_closure ⟨s,⟨hy,hs⟩,rfl⟩⟩ + rw [visualGenerator,dite_eq_left hy] + exact (Monoid.PushoutI.of_apply_eq_base (visualEdgeInclusion M Y Z) false x).trans + (Monoid.PushoutI.of_apply_eq_base (visualEdgeInclusion M Y Z) true x).symm + · simp [visualGenerator,hy] + +lemma visualWord (hsplit : IsVisualSplit M Y Z) (b : Bool) (w : List S) + (hw : ∀ s∈w, s∈visualSide Y Z b) : + (w.map (visualGenerator M Y Z hsplit)).prod=Monoid.PushoutI.of b + ⟨wordArtin M w,wordArtin_mem_parabolic M _ w hw⟩ := by + induction w with + | nil => exact (MonoidHom.map_one _).symm + | cons s w ih => + simp only [List.map_cons,List.prod_cons] + rw [visualGenerator_eq M Y Z hsplit b s (hw s (by simp)), + ih (fun t ht => hw t (List.mem_cons_of_mem s ht)),←map_mul] + congr 1 + +lemma visual_relators (hsplit : IsVisualSplit M Y Z) : ∀ r∈braidRelators M, + FreeGroup.lift (visualGenerator M Y Z hsplit) r=1 := by + rintro r ⟨⟨s,t⟩,rfl⟩ + by_cases hm : M s t=0 + · simp [hm,alternating] + · obtain ⟨b,hs,ht⟩ := visualSplit_finite_edge M Y Z hsplit s t hm + have hw : ∀ i∈altList s t (M s t), i∈visualSide Y Z b := by + intro i hi + rcases (show i=s ∨ i=t by simpa using mem_altList s t _ i hi) with rfl|rfl + · exact hs + · exact ht + have hw' : ∀ i∈altList t s (M s t), i∈visualSide Y Z b := by + intro i hi + rcases (show i=t ∨ i=s by simpa using mem_altList t s _ i hi) with rfl|rfl + · exact ht + · exact hs + rw [map_mul,map_inv,alternating_lift_prod,alternating_lift_prod, + visualWord M Y Z hsplit b _ hw,visualWord M Y Z hsplit b _ hw'] + apply mul_inv_eq_one.mpr + congr 1 + apply Subtype.ext + exact wordArtin_braid M s t + +noncomputable def visualFromArtin (hsplit : IsVisualSplit M Y Z) : Artin M →* VisualAmalgam M Y Z := + PresentedGroup.toGroup (visual_relators M Y Z hsplit) + +@[simp] lemma visualFromArtin_generator (hsplit : IsVisualSplit M Y Z) (s : S) : + visualFromArtin M Y Z hsplit (generator M s)=visualGenerator M Y Z hsplit s := + PresentedGroup.toGroup.of _ + +@[simp] lemma visualToArtin_generator (hsplit : IsVisualSplit M Y Z) (s : S) : + visualToArtin M Y Z (visualGenerator M Y Z hsplit s)=generator M s := by + unfold visualGenerator + split <;> exact Monoid.PushoutI.lift_of _ _ _ _ + +lemma visualToArtin_from (hsplit : IsVisualSplit M Y Z) (a : Artin M) : + visualToArtin M Y Z (visualFromArtin M Y Z hsplit a)=a := by + have h : (visualToArtin M Y Z).comp (visualFromArtin M Y Z hsplit)=MonoidHom.id _ := by + apply PresentedGroup.ext + intro s + simp only [MonoidHom.comp_apply,MonoidHom.id_apply] + exact (congrArg (visualToArtin M Y Z) (visualFromArtin_generator M Y Z hsplit s)).trans + (visualToArtin_generator M Y Z hsplit s) + exact DFunLike.congr_fun h a + +lemma visualFromArtin_factor (hsplit : IsVisualSplit M Y Z) (b : Bool) + (a : artinParabolic M (visualSide Y Z b)) : + visualFromArtin M Y Z hsplit a=Monoid.PushoutI.of b a := by + obtain ⟨a,ha⟩ := a + induction ha using Subgroup.closure_induction with + | mem x hx => + obtain ⟨s,hs,rfl⟩ := hx + rw [visualFromArtin_generator] + exact visualGenerator_eq M Y Z hsplit b s hs + | one => + change visualFromArtin M Y Z hsplit 1=Monoid.PushoutI.of b (1 : artinParabolic M (visualSide Y Z b)) + rw [map_one,map_one] + | mul x y hx hy ihx ihy => + change visualFromArtin M Y Z hsplit (x*y)=_ + rw [map_mul,ihx,ihy,←map_mul] + rfl + | inv x hx ih => + change visualFromArtin M Y Z hsplit x⁻¹=_ + rw [map_inv,ih,←map_inv] + rfl + +lemma visualFromArtin_to (hsplit : IsVisualSplit M Y Z) (a : VisualAmalgam M Y Z) : + visualFromArtin M Y Z hsplit (visualToArtin M Y Z a)=a := by + have h : (visualFromArtin M Y Z hsplit).comp (visualToArtin M Y Z)=MonoidHom.id _ := by + apply Monoid.PushoutI.hom_ext_nonempty + intro b + ext a + simp only [MonoidHom.comp_apply,MonoidHom.id_apply,visualToArtin] + exact visualFromArtin_factor M Y Z hsplit b a + exact DFunLike.congr_fun h a + +/-- The visual splitting is an isomorphism with the genuine injective +amalgamated free product of the two standard subgroups. -/ +noncomputable def visualArtinEquiv (hsplit : IsVisualSplit M Y Z) : + Artin M ≃* VisualAmalgam M Y Z where + toFun := visualFromArtin M Y Z hsplit + invFun := visualToArtin M Y Z + left_inv := visualToArtin_from M Y Z hsplit + right_inv := visualFromArtin_to M Y Z hsplit + map_mul' := map_mul _ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAmalgamProperties.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAmalgamProperties.lean new file mode 100644 index 0000000000000000000000000000000000000000..3c449269ca2ab5c93aea504a978aa25aa76c6393 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualAmalgamProperties.lean @@ -0,0 +1,60 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualNonVirtuallyCyclic + +namespace OAI + +/-! The nondegeneracy and edge-identification hypotheses of the published +amalgam criterion, verified for the actual Artin visual splitting. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +include hSplit + +omit [Fintype S] in +lemma visual_edge_comap : + (Monoid.PushoutI.base (visualEdgeInclusion M Y Z)).range.comap + (visualFromArtin M Y Z hSplit.out)=artinParabolic M (Y∩Z) := by + ext a + constructor + · rintro ⟨c,hc⟩ + have he := congrArg (visualToArtin M Y Z) hc + rw [visualToArtin_from] at he + have hc' : visualToArtin M Y Z (Monoid.PushoutI.base (visualEdgeInclusion M Y Z) c)=c.val := by + rw [←Monoid.PushoutI.of_apply_eq_base (visualEdgeInclusion M Y Z) false c] + exact Monoid.PushoutI.lift_of _ _ _ _ + rw [hc'] at he + exact he ▸ c.property + · intro ha + refine ⟨⟨a,ha⟩,?_⟩ + rw [←Monoid.PushoutI.of_apply_eq_base (visualEdgeInclusion M Y Z) false ⟨a,ha⟩] + exact (visualFromArtin_factor M Y Z hSplit.out false + ⟨a,standard_mono M Set.inter_subset_left ha⟩).symm + +lemma visual_edge_inclusion_proper (b : Bool) : + (visualEdgeInclusion M Y Z b).range≠⊤ := by + have hproper : visualSide Y Z (!b)≠Set.univ := by + cases b + · exact (Set.ssubset_iff_subset_ne.mp hSplit.out.2.2.1).2 + · exact (Set.ssubset_iff_subset_ne.mp hSplit.out.2.1).2 + obtain ⟨s,hs⟩ := Set.nonempty_compl.mpr hproper + have hside : s∈visualSide Y Z b := by + cases b + · exact (hSplit.out.1.symm ▸ Set.mem_univ s : s∈Y∪Z).resolve_right hs + · exact (hSplit.out.1.symm ▸ Set.mem_univ s : s∈Y∪Z).resolve_left hs + let a : artinParabolic M (visualSide Y Z b) := + ⟨generator M s,(generator_mem_standard_iff M _ _).mpr hside⟩ + intro he + have ha : a∈(visualEdgeInclusion M Y Z b).range := he ▸ Subgroup.mem_top a + obtain ⟨c,hc⟩ := ha + have hc' : generator M s∈artinParabolic M (Y∩Z) := by + change a.val∈artinParabolic M (Y∩Z) + rw [←congrArg Subtype.val hc] + exact c.property + have hs' := (generator_mem_standard_iff M (Y∩Z) s).mp hc' + cases b + · exact hs hs'.2 + · exact hs hs'.1 + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualEdgeMalnormal.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualEdgeMalnormal.lean new file mode 100644 index 0000000000000000000000000000000000000000..185add068878f3622b7666329f707cbae08359e1 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualEdgeMalnormal.lean @@ -0,0 +1,39 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualTrivialSegment +import OAI.Topology.ArtinGroups.ParabolicIntersections.WeakMalnormalAlgebra + +namespace OAI + +/-! The weak malnormality assertion for the edge group in CMMW Theorem 3.2, +with its published hypotheses discharged for arbitrary Artin matrices. -/ +namespace HarmonicArtin.ParabolicIntersections +open TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +/-- The edge group of every visual splitting of an irreducible Artin group +is weakly malnormal. -/ +theorem visual_edge_weaklyMalnormal (hIrred : IsIrreducible M) : + WeaklyMalnormal (artinParabolic M (Y∩Z)) := by + obtain ⟨u,v,_,huv⟩ := visual_exists_trivial_pair M Y Z hIrred + obtain ⟨b,g,hg⟩ := visual_vertex_exists M Y Z u + obtain ⟨c,h,hh⟩ := visual_vertex_exists M Y Z v + have hsub (b : Bool) : Y∩Z⊆visualSide Y Z b := by + cases b + · exact Set.inter_subset_left + · exact Set.inter_subset_right + have hu : conjugate g (artinParabolic M (Y∩Z))≤MulAction.stabilizer (Artin M) u := by + rw [hg,visual_vertex_stabilizer] + exact conjugate_mono g (standard_mono M (hsub b)) + have hv : conjugate h (artinParabolic M (Y∩Z))≤MulAction.stabilizer (Artin M) v := by + rw [hh,visual_vertex_stabilizer] + exact conjugate_mono h (standard_mono M (hsub c)) + apply weaklyMalnormal_of_conjugates_inf_bot _ g h + apply le_bot_iff.mp + exact huv ▸ inf_le_inf hu hv + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualEdgeTransitive.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualEdgeTransitive.lean new file mode 100644 index 0000000000000000000000000000000000000000..21a953879aef1076506f04d25cd54a159d773fa5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualEdgeTransitive.lean @@ -0,0 +1,29 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualTree + +namespace OAI + +/-! Transitivity on oriented edges of the visual Bass--Serre tree. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance visualEdgeTransitiveAction : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +lemma visual_oriented_edge_transitive {x y u v : VisualVertex M Y Z} + (hxy : (visualGraph M Y Z).Adj x y) (huv : (visualGraph M Y Z).Adj u v) + (hx : x.1=u.1) : ∃ a : Artin M,a • x=u ∧ a • y=v := by + obtain ⟨k,hxk,hyk⟩ := visual_adj_representatives M Y Z hxy + obtain ⟨g,hug,hvg⟩ := visual_adj_representatives M Y Z huv + have hy : y.1=v.1 := by + have h : ∀ a b c d : Bool,a≠b → c≠d → a=c → b=d := by decide + exact h _ _ _ _ hxy.1 huv.1 hx + refine ⟨g*k⁻¹,?_,?_⟩ + · rw [hxk,visual_smul_vertex,mul_assoc,inv_mul_cancel,mul_one,hx] + exact hug.symm + · rw [hyk,visual_smul_vertex,mul_assoc,inv_mul_cancel,mul_one,hy] + exact hvg.symm + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualFactorMalnormal.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualFactorMalnormal.lean new file mode 100644 index 0000000000000000000000000000000000000000..41bf0608b3bb74bd8e8aa9c6ab5890ccf84454c3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualFactorMalnormal.lean @@ -0,0 +1,82 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualEdgeMalnormal + +namespace OAI + +/-! Weak malnormality for the vertex factors, and hence their parabolics. -/ +namespace HarmonicArtin.ParabolicIntersections +open TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +omit [LinearOrder S] in +private lemma trivial_pair_endpoint_type (u v : VisualVertex M Y Z) (hne : u≠v) + (he : pairStabilizer (G := Artin M) u v=⊥) (b : Bool) : + ∃ w : VisualVertex M Y Z, u≠w ∧ w.1=b ∧ pairStabilizer (G := Artin M) u w=⊥ := by + by_cases hv : v.1=b + · exact ⟨v,hne,hv,he⟩ + obtain ⟨p,hp⟩ := (visualGraph_isTree M Y Z).connected.exists_isPath v u + have hpnot : ¬p.Nil := fun h => hne (hp.nil_iff_eq.mp h).symm + obtain ⟨a,ha,haw⟩ := visual_branching M Y Z v p.snd (p.adj_snd hpnot) + have hadj : (visualGraph M Y Z).Adj v (a • p.snd) := by + have h := visual_preservesAdj M Y Z a (p.adj_snd hpnot) + rwa [ha] at h + have hn : u≠a • p.snd := by + intro hu + have hmem : a • p.snd∈p.support := hu ▸ p.end_mem_support + exact haw ((visualGraph_isTree M Y Z).isAcyclic.eq_snd_of_adj_start hp hadj hmem) + refine ⟨a • p.snd,hn,?_,?_⟩ + · have hne' := hadj.1 + cases hb : b <;> cases hv' : v.1 <;> cases hw : (a • p.snd).1 <;> + simp_all only [Bool.false_eq_true,Bool.true_eq_false,not_false_eq_true,not_true_eq_false] + · rw [extended_pair (visualGraph M Y Z) (visualGraph_isTree M Y Z).isAcyclic + (visual_preservesAdj M Y Z) u v (a • p.snd) p hp hadj haw] + · exact he + · rw [he] + exact bot_le + +/-- A nondegenerate segment with trivial stabilizer in either vertex orbit. -/ +lemma visual_trivial_pair_distinct_type (hIrred : IsIrreducible M) (b : Bool) : + ∃ u v : VisualVertex M Y Z, u≠v ∧ u.1=b ∧ v.1=b ∧ + pairStabilizer (G := Artin M) u v=⊥ := by + obtain ⟨u,v,hne,he⟩ := visual_exists_trivial_pair M Y Z hIrred + obtain ⟨w,hnw,hw,hew⟩ := trivial_pair_endpoint_type M Y Z u v hne he b + have he' : pairStabilizer (G := Artin M) w u=⊥ := by + simpa only [pairStabilizer,inf_comm] using hew + obtain ⟨x,hnx,hx,hex⟩ := trivial_pair_endpoint_type M Y Z w u hnw.symm he' b + exact ⟨w,x,hnx,hw,hx,hex⟩ + +/-- Both endpoints may be taken in either vertex orbit. -/ +lemma visual_trivial_pair_type (hIrred : IsIrreducible M) (b : Bool) : + ∃ u v : VisualVertex M Y Z, u.1=b ∧ v.1=b ∧ + pairStabilizer (G := Artin M) u v=⊥ := by + obtain ⟨u,v,hne,he⟩ := visual_exists_trivial_pair M Y Z hIrred + obtain ⟨w,hnw,hw,hew⟩ := trivial_pair_endpoint_type M Y Z u v hne he b + have he' : pairStabilizer (G := Artin M) w u=⊥ := by + simpa only [pairStabilizer,inf_comm] using hew + obtain ⟨x,_,hx,hex⟩ := trivial_pair_endpoint_type M Y Z w u hnw.symm he' b + exact ⟨w,x,hw,hx,hex⟩ + +/-- Each vertex factor of a visual splitting is weakly malnormal. -/ +theorem visual_factor_weaklyMalnormal (hIrred : IsIrreducible M) (b : Bool) : + WeaklyMalnormal (artinParabolic M (visualSide Y Z b)) := by + obtain ⟨u,v,hu,hv,he⟩ := visual_trivial_pair_type M Y Z hIrred b + obtain ⟨i,g,hg⟩ := visual_vertex_exists M Y Z u + obtain ⟨j,h,hh⟩ := visual_vertex_exists M Y Z v + have hi : i=b := by simpa only [hg,visualVertex,AmalgamTree.vertex] using hu + have hj : j=b := by simpa only [hh,visualVertex,AmalgamTree.vertex] using hv + change MulAction.stabilizer (Artin M) u ⊓ MulAction.stabilizer (Artin M) v=⊥ at he + rw [hg,hh,visual_vertex_stabilizer,visual_vertex_stabilizer,hi,hj] at he + exact weaklyMalnormal_of_conjugates_inf_bot _ g h he + +/-- Any parabolic lying in a vertex factor inherits its weak malnormality. -/ +theorem visual_subgroup_weaklyMalnormal (hIrred : IsIrreducible M) + (b : Bool) (P : Subgroup (Artin M)) (hP : P≤artinParabolic M (visualSide Y Z b)) : + WeaklyMalnormal P := + (visual_factor_weaklyMalnormal M Y Z hIrred b).mono hP + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualInfiniteBranching.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualInfiniteBranching.lean new file mode 100644 index 0000000000000000000000000000000000000000..0924dd039442f2b235a32e992da7a229793ddfad --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualInfiniteBranching.lean @@ -0,0 +1,64 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualFactorMalnormal +import OAI.Topology.ArtinGroups.ParabolicIntersections.GeneratorPowers + +namespace OAI + +/-! Infinite branching for the genuine visual tree. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable + +private lemma injective_zpow_orbit {G V : Type} [Group G] [MulAction G V] + (a : G) (v : V) (ha : ∀ n : ℤ, n≠0 → a^n∉MulAction.stabilizer G v) : + Function.Injective (fun n : ℤ => a^n • v) := by + intro m n he + change a^m • v=a^n • v at he + by_contra hmn + have hn : -m+n≠0 := by omega + apply ha (-m+n) hn + change a^(-m+n) • v=v + rw [zpow_add,mul_smul,←he,zpow_neg,inv_smul_smul] + +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +/-- Every oriented edge belongs to an infinite orbit under the stabilizer +of its initial vertex. In particular, the visual tree is not a line. -/ +theorem visual_infinite_branching {u v : VisualVertex M Y Z} + (h : (visualGraph M Y Z).Adj u v) : + ∃ a : Artin M, a∈MulAction.stabilizer (Artin M) u ∧ + Function.Injective (fun n : ℤ => a^n • v) := by + obtain ⟨g,hu,hv⟩ := visual_adj_representatives M Y Z h + have hside : visualSide Y Z v.1≠Set.univ := by + cases v.1 + · exact (Set.ssubset_iff_subset_ne.mp hSplit.out.2.1).2 + · exact (Set.ssubset_iff_subset_ne.mp hSplit.out.2.2.1).2 + obtain ⟨t,ht⟩ := Set.nonempty_compl.mpr hside + have hgen : generator M t∈artinParabolic M (visualSide Y Z u.1) := by + apply (generator_mem_standard_iff M _ _).mpr + have hcover : visualSide Y Z u.1 ∪ visualSide Y Z v.1=Set.univ := by + have hne := h.1 + cases hu' : u.1 <;> cases hv' : v.1 + · exact False.elim (hne (hu'.trans hv'.symm)) + · exact hSplit.out.1 + · exact Set.union_comm Y Z ▸ hSplit.out.1 + · exact False.elim (hne (hu'.trans hv'.symm)) + exact (hcover.symm ▸ Set.mem_univ t : t∈visualSide Y Z u.1 ∪ visualSide Y Z v.1).resolve_right ht + let a := g*generator M t*g⁻¹ + have hapow (n : ℤ) : a^n=g*(generator M t)^n*g⁻¹ := by + exact (map_zpow (MulAut.conj g).toMonoidHom (generator M t) n).symm + refine ⟨a,?_,injective_zpow_orbit a v ?_⟩ + · rw [hu,visual_vertex_stabilizer,mem_conjugate] + have he : g⁻¹*a*g=generator M t := by dsimp only [a]; group + rw [he] + exact hgen + · intro n hn hm + rw [hv,visual_vertex_stabilizer,mem_conjugate,hapow] at hm + have he : g⁻¹*(g*generator M t^n*g⁻¹)*g=generator M t^n := by group + rw [he] at hm + exact generator_zpow_not_mem M (visualSide Y Z v.1) t ht n hn hm + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualNonVirtuallyCyclic.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualNonVirtuallyCyclic.lean new file mode 100644 index 0000000000000000000000000000000000000000..75c7b0871c94f5c4c25d7ce99d07f689ae865cf4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualNonVirtuallyCyclic.lean @@ -0,0 +1,75 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualInfiniteBranching +import OAI.Topology.ArtinGroups.ParabolicIntersections.AmalgamNoncommuting +import Mathlib.GroupTheory.SpecificGroups.VirtuallyCyclic + +namespace OAI + +/-! Visual Artin splittings are not virtually cyclic. Powers of generators +on opposite sides give nontrivial reduced commutators. This verifies the +exception exclusion in the Minasyan--Osin amalgam criterion. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] + +omit [Fintype S] hSplit in +private lemma visual_factor_not_base (i : Bool) + (a : artinParabolic M (visualSide Y Z i)) (ha : a.val∉artinParabolic M (Y∩Z)) : + a∉(visualEdgeInclusion M Y Z i).range := by + rintro ⟨c,hc⟩ + apply ha + rw [←congrArg Subtype.val hc] + exact c.property + +include hSplit + +lemma visual_opposite_powers_not_commute (s : S) (hs : s ∈ Y \ Z) + (t : S) (ht : t ∈ Z \ Y) (m n : ℕ) (hm : 0 < m) (hn : 0 < n) : + generator M s^m * generator M t^n ≠ generator M t^n * generator M s^m := by + let a : artinParabolic M Y := ⟨generator M s^m, + (artinParabolic M Y).pow_mem ((generator_mem_standard_iff M Y s).mpr hs.1) m⟩ + let b : artinParabolic M Z := ⟨generator M t^n, + (artinParabolic M Z).pow_mem ((generator_mem_standard_iff M Z t).mpr ht.1) n⟩ + have ha : a∉(visualEdgeInclusion M Y Z false).range := by + apply visual_factor_not_base M Y Z false a + simpa only [a,zpow_natCast] using + generator_zpow_not_mem M (Y∩Z) s (fun h => hs.2 h.2) (m : ℤ) (by omega) + have hb : b∉(visualEdgeInclusion M Y Z true).range := by + apply visual_factor_not_base M Y Z true b + simpa only [b,zpow_natCast] using + generator_zpow_not_mem M (Y∩Z) t (fun h => ht.2 h.1) (n : ℤ) (by omega) + have hh := AmalgamTree.factor_commutator_ne_one (visualEdgeInclusion M Y Z) + (fun _ => Subgroup.inclusion_injective _) a b ha hb + intro he + have hc : generator M s^m * generator M t^n * + (generator M s^m)⁻¹ * (generator M t^n)⁻¹=1 := by + rw [he] + group + have hc' := congrArg (visualFromArtin M Y Z hSplit.out) hc + simp only [map_mul,map_inv,map_one] at hc' + rw [show generator M s^m=a.val from rfl, + show generator M t^n=b.val from rfl, + visualFromArtin_factor M Y Z hSplit.out false a, + visualFromArtin_factor M Y Z hSplit.out true b] at hc' + exact hh hc' + +/-- A visual Artin splitting never gives the virtually cyclic exception. -/ +theorem visual_not_virtuallyCyclic : ¬Group.IsVirtuallyCyclic (Artin M) := by + intro hVC + let : Group.IsVirtuallyCyclic (Artin M) := hVC + obtain ⟨C,hC,hindex⟩ := Group.IsVirtuallyCyclic.exists_isCyclic_and_finiteIndex (Artin M) + let : IsCyclic C := hC + let : CommGroup C := IsCyclic.commGroup + let : C.FiniteIndex := hindex + obtain ⟨s,hs⟩ := Set.nonempty_compl.mpr (Set.ssubset_iff_subset_ne.mp hSplit.out.2.2.1).2 + obtain ⟨t,ht⟩ := Set.nonempty_compl.mpr (Set.ssubset_iff_subset_ne.mp hSplit.out.2.1).2 + have hsY : s∈Y := (hSplit.out.1.symm ▸ Set.mem_univ s : s∈Y∪Z).resolve_right hs + have htZ : t∈Z := (hSplit.out.1.symm ▸ Set.mem_univ t : t∈Y∪Z).resolve_left ht + obtain ⟨m,hm,_,hmC⟩ := C.exists_pow_mem_of_index_ne_zero Subgroup.FiniteIndex.index_ne_zero (generator M s) + obtain ⟨n,hn,_,hnC⟩ := C.exists_pow_mem_of_index_ne_zero Subgroup.FiniteIndex.index_ne_zero (generator M t) + apply visual_opposite_powers_not_commute M Y Z s ⟨hsY,hs⟩ t ⟨htZ,ht⟩ m n hm hn + exact congrArg Subtype.val (mul_comm (⟨generator M s^m,hmC⟩ : C) ⟨generator M t^n,hnC⟩) + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualParabolicSubtree.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualParabolicSubtree.lean new file mode 100644 index 0000000000000000000000000000000000000000..5a050bd5bceccd7448a51d389593a70605d35687 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualParabolicSubtree.lean @@ -0,0 +1,79 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeConvex +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicProductProper +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualTreeProperties + +namespace OAI + +/-! Every proper standard parabolic preserves a proper convex subtree. -/ +namespace HarmonicArtin.ParabolicIntersections +open TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance visualParabolicSubtreeAction : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +noncomputable def parabolicSubtree (X : Set S) : Set (VisualVertex M Y Z) := + orbitVertices (artinParabolic M X) (visualVertex M Y Z hSplit.out false 1) + (visualVertex M Y Z hSplit.out true 1) + +omit [Fintype S] in +lemma parabolicSubtree_generators (X : Set S) : + ∀ a∈generator M '' X, + a • visualVertex M Y Z hSplit.out false 1=visualVertex M Y Z hSplit.out false 1 ∨ + a • visualVertex M Y Z hSplit.out true 1=visualVertex M Y Z hSplit.out true 1 := by + rintro a ⟨s,_,rfl⟩ + have hs : s∈Y ∪ Z := hSplit.out.1.symm ▸ Set.mem_univ s + rcases hs with hs|hs + · left + apply (MulAction.mem_stabilizer_iff).mp + rw [visual_vertex_stabilizer,conjugate_one] + exact Subgroup.subset_closure ⟨s,hs,rfl⟩ + · right + apply (MulAction.mem_stabilizer_iff).mp + rw [visual_vertex_stabilizer,conjugate_one] + exact Subgroup.subset_closure ⟨s,hs,rfl⟩ + +omit [Fintype S] in +lemma parabolicSubtree_pathClosed (X : Set S) : + PathClosed (visualGraph M Y Z) (parabolicSubtree M Y Z X) := + orbit_pathClosed (visualGraph M Y Z) (visualGraph_isTree M Y Z).isAcyclic + (visual_preservesAdj M Y Z) _ _ _ (visual_vertex_adj M Y Z 1) rfl + (parabolicSubtree_generators M Y Z X) + +omit [Fintype S] in +lemma parabolicSubtree_invariant (X : Set S) {p : Artin M} (hp : p∈artinParabolic M X) + {w : VisualVertex M Y Z} (hw : w∈parabolicSubtree M Y Z X) : + p • w∈parabolicSubtree M Y Z X := orbit_smul_mem hp hw + +lemma parabolicSubtree_proper (hIrred : IsIrreducible M) (X : Set S) + (hX : X≠Set.univ) : ∃ w : VisualVertex M Y Z,w∉parabolicSubtree M Y Z X := by + obtain ⟨g,hg⟩ := artin_parabolic_product_proper M hIrred X Y hX + (Set.ssubset_iff_subset_ne.mp hSplit.out.2.1).2 + refine ⟨visualVertex M Y Z hSplit.out false g,?_⟩ + rintro ⟨p,hp,he|he⟩ + · have heq : g • visualVertex M Y Z hSplit.out false 1= + p • visualVertex M Y Z hSplit.out false 1 := by + simpa only [visual_smul_vertex,mul_one] using he + have ha : p⁻¹*g∈MulAction.stabilizer (Artin M) (visualVertex M Y Z hSplit.out false 1) := by + change (p⁻¹*g) • visualVertex M Y Z hSplit.out false 1=_ + rw [mul_smul,heq,inv_smul_smul] + rw [visual_vertex_stabilizer,conjugate_one] at ha + exact hg p hp (p⁻¹*g) ha (by group) + · have h := congrArg (fun w : VisualVertex M Y Z => w.1) he + exact Bool.false_ne_true h + +lemma parabolicSubtree_boundary (hIrred : IsIrreducible M) (X : Set S) + (hX : X≠Set.univ) : ∃ u v : VisualVertex M Y Z, + (visualGraph M Y Z).Adj u v ∧ u∈parabolicSubtree M Y Z X ∧ + v∉parabolicSubtree M Y Z X := by + obtain ⟨w,hw⟩ := parabolicSubtree_proper M Y Z hIrred X hX + let u := visualVertex M Y Z hSplit.out false 1 + have hu : u∈parabolicSubtree M Y Z X := + ⟨1,Subgroup.one_mem _,Or.inl (one_smul _ _).symm⟩ + obtain ⟨p,_⟩ := (visualGraph_isTree M Y Z).connected.exists_isPath u w + exact exists_boundary_edge (visualGraph M Y Z) hu hw p + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTree.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTree.lean new file mode 100644 index 0000000000000000000000000000000000000000..075877e415ecce8cc81d24e028e3cb256cc03c11 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTree.lean @@ -0,0 +1,117 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualAmalgam +import OAI.Topology.ArtinGroups.ParabolicIntersections.AmalgamAcyclic + +namespace OAI + +/-! The Bass--Serre tree and stabilizers of an actual visual Artin splitting. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} (M : CoxeterMatrix S) (Y Z : Set S) +local notation "φ" => visualEdgeInclusion M Y Z + +abbrev VisualVertex := AmalgamTree.Vertex φ +noncomputable abbrev visualGraph := AmalgamTree.graph φ + +noncomputable abbrev visualAction (hsplit : IsVisualSplit M Y Z) : + MulAction (Artin M) (VisualVertex M Y Z) := + MulAction.compHom _ (visualFromArtin M Y Z hsplit) + +noncomputable def visualVertex (hsplit : IsVisualSplit M Y Z) (b : Bool) (g : Artin M) : VisualVertex M Y Z := + AmalgamTree.vertex φ b (visualFromArtin M Y Z hsplit g) + +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +@[simp] lemma visual_smul_vertex (g h : Artin M) (b : Bool) : + g • visualVertex M Y Z hSplit.out b h=visualVertex M Y Z hSplit.out b (g*h) := by + change AmalgamTree.vertex φ b (visualFromArtin M Y Z hSplit.out g*visualFromArtin M Y Z hSplit.out h)=_ + rw [←map_mul] + rfl + +lemma visual_factor_comap (b : Bool) : + (AmalgamTree.Factor φ b).comap (visualFromArtin M Y Z hSplit.out)= + artinParabolic M (visualSide Y Z b) := by + ext a + constructor + · rintro ⟨x,hx⟩ + have h := congrArg (visualToArtin M Y Z) hx + rw [visualToArtin_from] at h + have hx' : visualToArtin M Y Z (Monoid.PushoutI.of b x)=x.val := + Monoid.PushoutI.lift_of _ _ _ _ + rw [hx'] at h + exact h ▸ x.property + · intro ha + exact ⟨⟨a,ha⟩,(visualFromArtin_factor M Y Z hSplit.out b ⟨a,ha⟩).symm⟩ + +lemma conjugate_comap_hom {A B : Type*} [Group A] [Group B] + (f : A →* B) (g : A) (P : Subgroup B) : + (conjugate (f g) P).comap f=conjugate g (P.comap f) := by + ext a + simp only [Subgroup.mem_comap,mem_conjugate,map_mul,map_inv] + +lemma visual_vertex_stabilizer (b : Bool) (g : Artin M) : + MulAction.stabilizer (Artin M) (visualVertex M Y Z hSplit.out b g)= + conjugate g (artinParabolic M (visualSide Y Z b)) := by + change (MulAction.stabilizer (VisualAmalgam M Y Z) + (AmalgamTree.vertex φ b (visualFromArtin M Y Z hSplit.out g))).comap + (visualFromArtin M Y Z hSplit.out)=_ + rw [AmalgamTree.vertex_stabilizer,conjugate_comap_hom,visual_factor_comap] + +omit hSplit in +lemma visualGraph_isTree : (visualGraph M Y Z).IsTree := by + apply AmalgamTree.isTree + intro b + exact Subgroup.inclusion_injective _ + +lemma visual_vertex_exists (v : VisualVertex M Y Z) : + ∃ b g, v=visualVertex M Y Z hSplit.out b g := by + obtain ⟨b,v⟩ := v + obtain ⟨g,rfl⟩ := Quotient.exists_rep v + refine ⟨b,visualToArtin M Y Z g,?_⟩ + unfold visualVertex + rw [visualFromArtin_to] + rfl + +lemma visual_vertex_isParabolic (v : VisualVertex M Y Z) : + IsParabolic M (MulAction.stabilizer (Artin M) v) := by + obtain ⟨b,g,rfl⟩ := visual_vertex_exists M Y Z v + rw [visual_vertex_stabilizer] + exact ⟨_,g,rfl⟩ + +lemma visual_vertex_adj (g : Artin M) : + (visualGraph M Y Z).Adj (visualVertex M Y Z hSplit.out false g) + (visualVertex M Y Z hSplit.out true g) := AmalgamTree.vertex_adj φ _ + +lemma visual_adj_representatives {u v : VisualVertex M Y Z} + (h : (visualGraph M Y Z).Adj u v) : + ∃ g : Artin M, u=visualVertex M Y Z hSplit.out u.1 g ∧ + v=visualVertex M Y Z hSplit.out v.1 g := by + obtain ⟨g,hu,hv⟩ := AmalgamTree.adj_representatives φ h + refine ⟨visualToArtin M Y Z g,?_,?_⟩ <;> + unfold visualVertex <;> rw [visualFromArtin_to] <;> assumption + +/-- The stabilizers of the endpoints of every edge generate the whole group. -/ +lemma visual_adj_stabilizers_generate {u v : VisualVertex M Y Z} + (h : (visualGraph M Y Z).Adj u v) : + MulAction.stabilizer (Artin M) u ⊔ MulAction.stabilizer (Artin M) v=⊤ := by + obtain ⟨g,hu,hv⟩ := visual_adj_representatives M Y Z h + rw [hu,hv,visual_vertex_stabilizer,visual_vertex_stabilizer,←conjugate_sup] + have hne : u.1≠v.1 := h.1 + have hsides : visualSide Y Z u.1 ∪ visualSide Y Z v.1=Set.univ := by + by_cases hu' : u.1=false + · have hv' : v.1=true := Bool.eq_true_of_not_eq_false (fun hf => hne (hu'.trans hf.symm)) + rw [hu',hv'] + exact hSplit.out.1 + · have hu'' : u.1=true := Bool.eq_true_of_not_eq_false hu' + have hv' : v.1=false := Bool.eq_false_of_not_eq_true (fun hf => hne (hu''.trans hf.symm)) + rw [hu'',hv',Set.union_comm] + exact hSplit.out.1 + have he : artinParabolic M (visualSide Y Z u.1) ⊔ + artinParabolic M (visualSide Y Z v.1)=⊤ := by + rw [←standard_union,hsides,standard_univ] + rw [he,conjugate_top] + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTreeProperties.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTreeProperties.lean new file mode 100644 index 0000000000000000000000000000000000000000..99f0354829f2825cf978870a22d763dd169ac5c3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTreeProperties.lean @@ -0,0 +1,46 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualTree +import OAI.Topology.ArtinGroups.ParabolicIntersections.NormalParabolic +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeFixedPaths + +namespace OAI + +/-! Proper stabilizers and branching in the visual Bass--Serre tree. -/ +namespace HarmonicArtin.ParabolicIntersections +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +omit [Fintype S] in +lemma visual_preservesAdj : TreeAction.PreservesAdj (G := Artin M) (visualGraph M Y Z) := by + intro g u v h + exact (AmalgamTree.translate (visualEdgeInclusion M Y Z) + (visualFromArtin M Y Z hSplit.out g)).map_adj h + +lemma visual_vertex_proper (v : VisualVertex M Y Z) : + MulAction.stabilizer (Artin M) v≠⊤ := by + obtain ⟨b,g,rfl⟩ := visual_vertex_exists M Y Z v + rw [visual_vertex_stabilizer] + intro he + have he' := congrArg (conjugate g⁻¹) he + rw [conjugate_inv_cancel,conjugate_top] at he' + apply standard_ne_top_of_ne_univ M _ he' + cases b + · exact (Set.ssubset_iff_subset_ne.mp hSplit.out.2.1).2 + · exact (Set.ssubset_iff_subset_ne.mp hSplit.out.2.2.1).2 + +/-- Every direction at every vertex can be moved by its stabilizer. -/ +lemma visual_branching (v w : VisualVertex M Y Z) (h : (visualGraph M Y Z).Adj v w) : + ∃ a : Artin M, a • v=v ∧ a • w≠w := by + have hn : ¬MulAction.stabilizer (Artin M) v≤MulAction.stabilizer (Artin M) w := by + intro hle + apply visual_vertex_proper M Y Z w + have he := visual_adj_stabilizers_generate M Y Z h + rwa [sup_eq_right.mpr hle] at he + obtain ⟨a,ha,hna⟩ := SetLike.not_le_iff_exists.mp hn + exact ⟨a,ha,hna⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTrivialSegment.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTrivialSegment.lean new file mode 100644 index 0000000000000000000000000000000000000000..0ba2b303afb5bb2e01ced6e12b0f6209ea8e6a4f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/VisualTrivialSegment.lean @@ -0,0 +1,58 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.VisualTreeProperties +import OAI.Topology.ArtinGroups.ParabolicIntersections.TreeMinimalNormal +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicMinimal +import OAI.Topology.ArtinGroups.ParabolicIntersections.ParabolicCore + +namespace OAI + +/-! The visual tree has a segment with trivial pointwise stabilizer. +This proves the segment step in CMMW (2026), Theorem 3.2, using the +unconditional parabolic intersection theorem and rank descent. -/ +namespace HarmonicArtin.ParabolicIntersections +open TreeAction +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) (Y Z : Set S) +variable [hSplit : Fact (IsVisualSplit M Y Z)] +noncomputable local instance : MulAction (Artin M) (VisualVertex M Y Z) := + visualAction M Y Z hSplit.out + +lemma visual_pair_isParabolic (u v : VisualVertex M Y Z) : + IsParabolic M (pairStabilizer (G := Artin M) u v) := by + obtain ⟨X,g,hg⟩ := visual_vertex_isParabolic M Y Z u + obtain ⟨X',g',hg'⟩ := visual_vertex_isParabolic M Y Z v + change IsParabolic M (MulAction.stabilizer (Artin M) u ⊓ MulAction.stabilizer (Artin M) v) + rw [hg,hg'] + exact unconditional_parabolic_intersections M X X' g g' + +/-- A finite segment of the genuine Bass--Serre tree has trivial stabilizer. -/ +theorem visual_exists_trivial_pair (hIrred : IsIrreducible M) : + ∃ u v : VisualVertex M Y Z, u≠v ∧ pairStabilizer (G := Artin M) u v=⊥ := by + let F : Set (Subgroup (Artin M)) := + {P | ∃ u v : VisualVertex M Y Z, u≠v ∧ P=pairStabilizer (G := Artin M) u v} + have hF : F.Nonempty := by + let u := visualVertex M Y Z hSplit.out false 1 + let v := visualVertex M Y Z hSplit.out true 1 + exact ⟨pairStabilizer (G := Artin M) u v,u,v, + (visual_vertex_adj M Y Z 1).ne,rfl⟩ + obtain ⟨P,hP,hmin⟩ := exists_minimal_parabolic M F hF (by + rintro P ⟨u,v,_,rfl⟩ + exact visual_pair_isParabolic M Y Z u v) + obtain ⟨u,v,hne,rfl⟩ := hP + have hmin' : ∀ a b : VisualVertex M Y Z, a≠b → + pairStabilizer (G := Artin M) a b≤pairStabilizer (G := Artin M) u v → + pairStabilizer (G := Artin M) a b=pairStabilizer (G := Artin M) u v := by + intro a b hab hle + exact hmin _ ⟨a,b,hab,rfl⟩ hle + obtain ⟨p,hp⟩ := (visualGraph_isTree M Y Z).connected.exists_isPath v u + have hn := minimal_pair_normal (visualGraph M Y Z) (visualGraph_isTree M Y Z).isAcyclic + (visual_preservesAdj M Y Z) u v hne hmin' p hp + (visual_branching M Y Z) (fun _ _ h => visual_adj_stabilizers_generate M Y Z h) + have hproper : pairStabilizer (G := Artin M) u v≠⊤ := by + intro he + apply visual_vertex_proper M Y Z u + exact top_le_iff.mp (he ▸ (inf_le_left : pairStabilizer (G := Artin M) u v≤_)) + exact ⟨u,v,hne,(normal_parabolic M hIrred _ (visual_pair_isParabolic M Y Z u v) hn).resolve_right hproper⟩ + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/WeakMalnormalAlgebra.lean b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/WeakMalnormalAlgebra.lean new file mode 100644 index 0000000000000000000000000000000000000000..8027d7f9c17ab11a7e90e9cc6e0c939ee78c9031 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/ParabolicIntersections/WeakMalnormalAlgebra.lean @@ -0,0 +1,39 @@ +import OAI.Topology.ArtinGroups.ParabolicIntersections.DynamicsDefinitions + +namespace OAI + +/-! Conjugation and subgroup facts about weak malnormality. -/ +namespace HarmonicArtin.ParabolicIntersections +variable {G : Type} [Group G] + +lemma weaklyMalnormal_of_conjugates_inf_bot (P : Subgroup G) (g h : G) + (he : conjugate g P ⊓ conjugate h P=⊥) : WeaklyMalnormal P := by + have he' := congrArg (conjugate g⁻¹) he + rw [conjugate_inf,conjugate_inv_cancel,←conjugate_mul,conjugate_bot] at he' + refine ⟨g⁻¹*h,?_⟩ + rw [he'] + exact Set.finite_singleton 1 + +lemma WeaklyMalnormal.mono {P Q : Subgroup G} (hQ : WeaklyMalnormal Q) (hle : P≤Q) : + WeaklyMalnormal P := by + obtain ⟨g,hg⟩ := hQ + exact ⟨g,hg.subset (inf_le_inf hle (conjugate_mono g hle))⟩ + +lemma WeaklyMalnormal.conjugate_subgroup {P : Subgroup G} (hP : WeaklyMalnormal P) (g : G) : + WeaklyMalnormal (conjugate g P) := by + obtain ⟨h,hh⟩ := hP + refine ⟨g*h*g⁻¹,?_⟩ + have he : conjugate g P ⊓ conjugate (g*h*g⁻¹) (conjugate g P)= + conjugate g (P ⊓ conjugate h P) := by + rw [conjugate_inf,←conjugate_mul,←conjugate_mul] + group + rw [he] + have him := hh.image (fun x : G => g*x*g⁻¹) + apply him.subset + intro x hx + refine ⟨g⁻¹*x*g,(mem_conjugate _ _ _).mp hx,?_⟩ + group + +end HarmonicArtin.ParabolicIntersections + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ClosedNeighborhood.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ClosedNeighborhood.lean new file mode 100644 index 0000000000000000000000000000000000000000..3e3a164e896f520ec462468db68afddd10501e59 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ClosedNeighborhood.lean @@ -0,0 +1,94 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.InverseWordAction + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver +universe u +variable {V A : Type u} (Q : ReversibleQuiver V A) + +def closedNeighborhood (U : Set V) : Set V := + {β | β∈U ∨ ∃ α∈U, ∃ a : A,Q.source a=α ∧ Q.target a=β} + +lemma mem_closedNeighborhood {U : Set V} {α : V} (hα : α∈U) : + α∈Q.closedNeighborhood U := Or.inl hα + +lemma corner_target_mem_neighborhood {U : Set V} {α β : V} (hα : α∈U) + (p : Zigzag.CornerPath Q α β) : β∈Q.closedNeighborhood U := by + rcases p with ⟨x,hs,ht⟩ + rcases x with v|a|v + · exact Or.inl (by simp only [Path.source, Path.target] at hs ht; exact ht ▸ hs.symm ▸ hα) + · exact Or.inr ⟨α,hα,a,hs,ht⟩ + · exact Or.inl (by simp only [Path.source, Path.target] at hs ht; exact ht ▸ hs.symm ▸ hα) + +namespace Zigzag.BasedComplex +open Matrix +open scoped BigOperators + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {K : Type*} [Field K] [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +def ClassCapOn (x : FiniteHomotopyClass Q (K:=K)) (U : Set V) (q : ℤ) : Prop := + ∀ i,((minimalClassModel Q x).complex.placement i).color∈U → + ((minimalClassModel Q x).complex.placement i).level≤q + +omit [Fintype V] [DecidableEq A] in +lemma ClassCapOn.mono {x : FiniteHomotopyClass Q (K:=K)} {U T : Set V} {q : ℤ} + (h : ClassCapOn Q x U q) (hT : T⊆U) : ClassCapOn Q x T q := fun i hi=>h i (hT hi) + +omit [Fintype V] [DecidableEq A] in +lemma classCapOn_of_upper (x : FiniteHomotopyClass Q (K:=K)) (U : Set V) (q : ℤ) + (h : ClassUpperBound Q q x) : ClassCapOn Q x U q := fun i _=>h i + +lemma reducedNegativeAmplitudeTwist_cap {I : Type u} [Fintype I] [DecidableEq I] + (E : BasedComplex Q (K:=K) I) (U : Set V) (q : ℤ) + (hcap : ∀ i,(E.placement i).color∈Q.closedNeighborhood U → (E.placement i).level≤q) + (α : V) (hα : α∈U) : + ∀ k,((reducedNegativeAmplitudeTwist Q E α).placement k).color∈Q.closedNeighborhood U → + ((reducedNegativeAmplitudeTwist Q E α).placement k).level≤q := by + intro k hk + rw [reducedNegativeAmplitudeTwist_placement] at hk ⊢ + rcases k with p|i + · have hi:=hcap p.val.1 (Q.corner_target_mem_neighborhood hα p.val.2) + have hp:=Path.length_cases p.val.2.val + have hn:=p.property + dsimp only [GeneratorPlacement.level] at hi ⊢ + rcases hp with hp|hp|hp <;> omega + · exact hcap i.val hk + +theorem classNegativeTwist_capOn (x : FiniteHomotopyClass Q (K:=K)) + (U : Set V) (q : ℤ) (hcap : ClassCapOn Q x (Q.closedNeighborhood U) q) + (α : V) (hα : α∈U) : + ClassCapOn Q (classNegativeTwist Q α x) (Q.closedNeighborhood U) q := by + let E:=minimalClassModel Q x + let y:=classNegativeTwist Q α x + let F:=minimalClassModel Q y + have he : classOfComplex Q (E.complex.negativeTwist Q α)=classOfComplex Q F.complex := by + change classNegativeTwist Q α (classOfComplex Q E.complex)=classOfComplex Q F.complex + have hx : classOfComplex Q E.complex=x := minimalClassModel_class Q x + have hy : classOfComplex Q F.complex=y := minimalClassModel_class Q y + rw [hx,hy] + obtain ⟨e⟩:=Quotient.exact he + have reduction : HomotopyEquivalence Q (E.complex.negativeTwist Q α) + (reducedNegativeAmplitudeTwist Q E.complex α) := by + convert negativeAmplitudeTwistReduction Q E.complex α using 1 + exact minimal_bound_transport Q (reducedNegativeAmplitudeTwist Q E.complex α) F.complex + (minimalClassModel_minimal Q y) + ((reduction.symm Q).trans Q e) + (fun p=>p.color∈Q.closedNeighborhood U → p.level≤q) + (reducedNegativeAmplitudeTwist_cap Q E.complex U q hcap α hα) + +lemma inverseWord_capOn (w : List V) (x : FiniteHomotopyClass Q (K:=K)) + (U : Set V) (q : ℤ) (hcap : ClassCapOn Q x (Q.closedNeighborhood U) q) + (hw : ∀ α∈w,α∈U) : + ClassCapOn Q (inverseWordAction Q w x) (Q.closedNeighborhood U) q := by + induction w generalizing x with + | nil => exact hcap + | cons α w ih => + exact ih _ (classNegativeTwist_capOn Q x U q hcap α (hw α (by simp))) + (fun β hβ=>hw β (by simp [hβ])) + +end Zigzag.BasedComplex +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/CoefficientMatrix.lean b/lean/OAI/Topology/ArtinGroups/Quivers/CoefficientMatrix.lean new file mode 100644 index 0000000000000000000000000000000000000000..179e71f746ba6bc16abbeaac9915ba07871e2c7d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/CoefficientMatrix.lean @@ -0,0 +1,66 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.PathZero + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype A] [DecidableEq V] +variable {I J : Type*} [Fintype I] [Fintype J] + +def CoefficientMatrix (f : Matrix I J (Q.Zigzag K)) : Prop := + ∀ i j, (f i j).arrow = 0 ∧ (f i j).token = 0 + +omit [Fintype I] [Fintype J] in +lemma matrixZero_eq_self {f : Matrix I J (Q.Zigzag K)} (hf : CoefficientMatrix Q f) : + matrixZero Q f = f := by + apply Matrix.ext + intro i j + apply ext + · rfl + · exact (hf i j).1.symm + · exact (hf i j).2.symm + +omit [Fintype I] [Fintype J] in +lemma matrixZero_linear {f : Matrix I J (Q.Zigzag K)} (hf : LinearMatrix Q f) : + matrixZero Q f = 0 := matrixZero_eq_zero Q fun i j => (hf i j).1 + +namespace BasedComplex + +lemma matrixZero_homDifferential (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n : ℤ) (f : Matrix I J (Q.Zigzag K)) : + matrixZero Q (homDifferential Q E F n f) = 0 := by + change matrixZero Q (E.differential * f - cochainSign (K := K) n • (f * F.differential)) = 0 + rw [map_sub, map_smul, matrixZero_mul, matrixZero_mul, + matrixZero_eq_zero Q hE, matrixZero_eq_zero Q hF, + Matrix.zero_mul, Matrix.mul_zero, smul_zero, sub_zero] + +lemma matrixZero_boundary (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n v : ℤ) {f : Matrix I J (Q.Zigzag K)} (hf : f ∈ homBoundaries Q E F n v) : + matrixZero Q f = 0 := by + obtain ⟨g, _, rfl⟩ := hf + exact matrixZero_homDifferential Q E F hE hF (n-1) g + +lemma coefficient_eq_zero_of_same_differential [Fintype V] + (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) + (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) (n v : ℤ) + (hd : homDimension Q E F n v = 0) + {f g : Matrix I J (Q.Zigzag K)} + (hf : f ∈ homSpace Q E F n v) (hg : g ∈ homSpace Q E F n v) + (h₀ : CoefficientMatrix Q f) (h₁ : LinearMatrix Q g) + (he : homDifferential Q E F n f = homDifferential Q E F n g) : f = 0 := by + have hc : f - g ∈ homCycles Q E F n v := by + refine ⟨Submodule.sub_mem _ hf hg, ?_⟩ + change homDifferential Q E F n (f - g) = 0 + rw [map_sub, he, sub_self] + have hb := boundary_of_homDimension_zero Q E F n v hd hc + have hz := matrixZero_boundary Q E F hE hF n v hb + rw [map_sub, matrixZero_eq_self Q h₀, matrixZero_linear Q h₁, sub_zero] at hz + exact hz + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/CornerPath.lean b/lean/OAI/Topology/ArtinGroups/Quivers/CornerPath.lean new file mode 100644 index 0000000000000000000000000000000000000000..17e43b9e15e754421e3e8cceffd76c2d79491df4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/CornerPath.lean @@ -0,0 +1,84 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.Path + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver + +namespace Zigzag + +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +abbrev CornerPath (s t : V) := {p : Path V A // Path.source Q p = s ∧ Path.target Q p = t} + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_zero (p : Path V A) : pathCoordinates Q (0 : Q.Zigzag K) p = 0 := by + rcases p with v | a | v <;> rfl + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_add (x y : Q.Zigzag K) (p : Path V A) : + pathCoordinates Q (x + y) p = pathCoordinates Q x p + pathCoordinates Q y p := by + rcases p with v | a | v <;> rfl + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_smul (r : K) (x : Q.Zigzag K) (p : Path V A) : + pathCoordinates Q (r • x) p = r * pathCoordinates Q x p := by + rcases p with v | a | v <;> rfl + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_sum {B : Type*} (T : Finset B) (f : B → Q.Zigzag K) (p : Path V A) : + pathCoordinates Q (∑ b ∈ T, f b) p = ∑ b ∈ T, pathCoordinates Q (f b) p := by + classical + induction T using Finset.induction_on with + | empty => simp [coordinates_zero] + | @insert b T hb ih => simp [Finset.sum_insert hb, coordinates_add, ih] + +omit [DecidableEq A] in +lemma sum_cornerPath {s t : V} (x : Q.Zigzag K) + (hl : vertexId Q s * x = x) (hr : x * vertexId Q t = x) : + ∑ p : CornerPath Q s t, pathCoordinates Q x p.val • pathBasis Q p.val = x := by + classical + conv_rhs => rw [← sum_pathBasis Q x] + apply Fintype.sum_of_injective (fun p : CornerPath Q s t => p.val) Subtype.val_injective + · intro p hp + have hz : pathCoordinates Q x p = 0 := by + by_contra h + have hc := coordinates_corner Q hl hr h + exact hp ⟨⟨p, hc⟩, rfl⟩ + rw [hz, zero_smul] + · intro p + rfl + +lemma cornerPath_left {s t : V} (p : CornerPath Q s t) : + vertexId Q s * pathBasis Q (K := K) p.val = pathBasis Q p.val := by + simpa only [p.property.1] using pathBasis_left Q (K := K) p.val + +lemma cornerPath_right {s t : V} (p : CornerPath Q s t) : + pathBasis Q (K := K) p.val * vertexId Q t = pathBasis Q p.val := by + simpa only [p.property.2] using pathBasis_right Q (K := K) p.val + +omit [DecidableEq A] in +lemma sum_cornerPath_mul {s t : V} (x y : Q.Zigzag K) + (hl : vertexId Q s * x = x) (hr : x * vertexId Q t = x) : + ∑ p : CornerPath Q s t, pathCoordinates Q x p.val • (pathBasis Q p.val * y) = x * y := by + conv_rhs => rw [← sum_cornerPath Q x hl hr] + rw [Finset.sum_mul] + apply Finset.sum_congr rfl + intro p _ + exact (smul_mul Q _ _ _).symm + +omit [DecidableEq A] in +lemma coordinates_mul_expansion {s t : V} (x y : Q.Zigzag K) + (hl : vertexId Q s * x = x) (hr : x * vertexId Q t = x) (r : Path V A) : + ∑ p : CornerPath Q s t, pathCoordinates Q x p.val * + pathCoordinates Q (pathBasis Q p.val * y) r = pathCoordinates Q (x * y) r := by + rw [← sum_cornerPath_mul Q x y hl hr, coordinates_sum] + apply Finset.sum_congr rfl + intro p _ + exact (coordinates_smul Q _ _ _).symm + +end Zigzag +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/CornerScalar.lean b/lean/OAI/Topology/ArtinGroups/Quivers/CornerScalar.lean new file mode 100644 index 0000000000000000000000000000000000000000..5094fd0d5ac47edec6d8041c2e2846ee42ddfc46 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/CornerScalar.lean @@ -0,0 +1,101 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.GeneratorPlacement + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype A] [DecidableEq V] + +lemma corner_scalar {v : V} {x : Q.Zigzag K} + (hx : vertexId Q v * x = x) (h0 : Homogeneous Q 0 x) : + x = x.vertex v • vertexId Q v := by + apply Zigzag.ext + · ext w + by_cases hw : w = v + · subst w + simp + · have he := congrArg (fun z : Q.Zigzag K => z.vertex w) hx + change (vertexId Q v).vertex w * x.vertex w = x.vertex w at he + rw [vertexId_eval, ite_eq_right hw, MulZeroClass.zero_mul] at he + simpa [vertexId_eval, hw] using he.symm + · change x.arrow = x.vertex v • (0 : A → K) + rw [smul_zero] + exact h0.2.1 (by decide) + · change x.token = x.vertex v • (0 : V → K) + rw [smul_zero] + exact h0.2.2 (by decide) + +variable {I J : Type*} + +lemma degree_vertex_support {p : I → GeneratorPlacement V} + {q : J → GeneratorPlacement V} {M : Matrix I J (Q.Zigzag K)} + {n v : ℤ} (hc : ProjectiveEntries Q p q M) (hd : MapDegree Q p q n v M) + (i : I) (j : J) (w : V) (hne : (M i j).vertex w ≠ 0) : + (p i).color = w ∧ (q j).color = w ∧ + (q j).cochain = (p i).cochain + n ∧ + (q j).internal = (p i).internal + v := by + have hleft := congrArg (fun x : Q.Zigzag K => x.vertex w) (hc.1 i j) + have hright := congrArg (fun x : Q.Zigzag K => x.vertex w) (hc.2 i j) + have hpv : (p i).color = w := by + by_contra h + have hh : w ≠ (p i).color := Ne.symm h + change (vertexId Q (p i).color).vertex w * (M i j).vertex w = (M i j).vertex w at hleft + rw [vertexId_eval, ite_eq_right hh, MulZeroClass.zero_mul] at hleft + exact hne hleft.symm + have hqv : (q j).color = w := by + by_contra h + have hh : w ≠ (q j).color := Ne.symm h + change (M i j).vertex w * (vertexId Q (q j).color).vertex w = (M i j).vertex w at hright + rw [vertexId_eval, ite_eq_right hh, MulZeroClass.mul_zero] at hright + exact hne hright.symm + have hcq : (q j).cochain = (p i).cochain + n := by + by_contra h + have hz := (hd i j).1 h + exact hne (by simp [hz]) + have hiq : (q j).internal = (p i).internal + v := by + by_contra h + have hh : v + (p i).internal - (q j).internal ≠ 0 := by omega + have hz := (hd i j).2.1 hh + exact hne (by rw [hz]; rfl) + exact ⟨hpv, hqv, hcq, hiq⟩ + +namespace BasedComplex + +variable [Fintype I] + +lemma differential_diagonal_zero (E : BasedComplex Q (K := K) I) (i : I) : + E.differential i i = 0 := + (E.degree i i).1 (by omega) + +theorem exists_pivot_of_not_minimal (E : BasedComplex Q (K := K) I) + (hE : ¬E.IsMinimal Q) : + ∃ i j : I, ∃ a : K, i ≠ j ∧ a ≠ 0 ∧ + (E.placement j).color = (E.placement i).color ∧ + (E.placement j).cochain = (E.placement i).cochain + 1 ∧ + (E.placement j).internal = (E.placement i).internal ∧ + E.differential i j = a • vertexId Q (E.placement i).color := by + classical + change ¬∀ i j, (E.differential i j).vertex = 0 at hE + push Not at hE + obtain ⟨i, j, hij⟩ := hE + have hv : ∃ w, (E.differential i j).vertex w ≠ 0 := by + by_contra h + push Not at h + exact hij (funext h) + obtain ⟨w, hw⟩ := hv + obtain ⟨hi, hj, hc, hu⟩ := degree_vertex_support Q E.entries E.degree i j w hw + have hu' : (E.placement j).internal = (E.placement i).internal := by omega + refine ⟨i, j, (E.differential i j).vertex w, ?_, hw, hj.trans hi.symm, hc, hu', ?_⟩ + · intro he + subst j + omega + · have hdeg : Homogeneous Q 0 (E.differential i j) := by + simpa only [zero_add, hu', sub_self] using (E.degree i j).2 + simpa only [hi] using corner_scalar Q (E.entries.1 i j) hdeg + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/CotestPlacement.lean b/lean/OAI/Topology/ArtinGroups/Quivers/CotestPlacement.lean new file mode 100644 index 0000000000000000000000000000000000000000..9746b19b92910aefdc9f054705eb576ed844413b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/CotestPlacement.lean @@ -0,0 +1,135 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.TestPlacement +import OAI.Topology.ArtinGroups.Quivers.Dual + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +def cotestPlacement (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + TestIndex Q p α → HarmonicArtin.GeneratorPlacement V := + fun u => ⟨α, (p u.1).cochain, (p u.1).internal + Path.length u.2.val - 2⟩ + +lemma cotestMatrix_degree {p : I → HarmonicArtin.GeneratorPlacement V} + {q : J → HarmonicArtin.GeneratorPlacement V} (α : V) + {n v : ℤ} {M : Matrix I J (Q.Zigzag K)} (hM : MapDegree Q p q n v M) : + MapDegree Q (cotestPlacement Q p α) (cotestPlacement Q q α) n v + (scalarCornerMatrix Q α (testMatrix Q p q α M)) := by + intro a b + have he := testMatrix_degree Q α hM a b + constructor + · exact he.1 + · convert he.2 using 1 + dsimp [cotestPlacement, testPlacement] + ring + +noncomputable def coevaluationMatrix (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + Matrix I (TestIndex Q p α) (Q.Zigzag K) := by + classical + exact fun i u => if i = u.1 then pathBasis Q (Path.dual Q u.2.val) else 0 + +lemma coevaluation_entries (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + ProjectiveEntries Q p (cotestPlacement Q p α) + (coevaluationMatrix Q p α (K := K)) := by + classical + constructor + · intro i u + dsimp only [coevaluationMatrix] + split_ifs with h + · subst i + exact cornerPath_left Q ((cornerDual Q α (p u.1).color) u.2) + · exact MulZeroClass.mul_zero _ + · intro i u + dsimp only [coevaluationMatrix, cotestPlacement] + split_ifs + · exact cornerPath_right Q ((cornerDual Q α (p u.1).color) u.2) + · exact MulZeroClass.zero_mul _ + +lemma coevaluation_degree (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + MapDegree Q p (cotestPlacement Q p α) 0 0 + (coevaluationMatrix Q p α (K := K)) := by + classical + intro i u + by_cases hi : i = u.1 + · subst i + have hev : coevaluationMatrix Q p α (K := K) u.1 u = + pathBasis Q (Path.dual Q u.2.val) := ite_eq_left rfl + rw [hev] + constructor + · intro h + exact (h (by simp [cotestPlacement])).elim + · convert pathBasis_homogeneous Q (K := K) (Path.dual Q u.2.val) using 1 + dsimp [cotestPlacement] + rw [Path.length_dual] + omega + · have hev : coevaluationMatrix Q p α (K := K) i u = 0 := ite_eq_right hi + rw [hev] + exact ⟨fun _ => rfl, homogeneous_zero Q _⟩ + +omit [DecidableEq A] in +lemma mul_coevaluation [Fintype J] + (q : J → HarmonicArtin.GeneratorPlacement V) (α : V) + (M : Matrix I J (Q.Zigzag K)) (i : I) (u : TestIndex Q q α) : + (M * coevaluationMatrix Q q α (K := K)) i u = + M i u.1 * pathBasis Q (Path.dual Q u.2.val) := by + classical + rw [Matrix.mul_apply] + simp only [coevaluationMatrix, mul_ite, MulZeroClass.mul_zero] + simp + +lemma coevaluation_testMatrix [Fintype I] + (p : I → HarmonicArtin.GeneratorPlacement V) + (q : J → HarmonicArtin.GeneratorPlacement V) (α : V) + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) + (i : I) (u : TestIndex Q q α) : + (coevaluationMatrix Q p α (K := K) * scalarCornerMatrix Q α (testMatrix Q p q α M)) i u = + M i u.1 * pathBasis Q (Path.dual Q u.2.val) := by + classical + simp only [Matrix.mul_apply, Fintype.sum_sigma, coevaluationMatrix, scalarCornerMatrix, + testMatrix, ite_mul, MulZeroClass.zero_mul] + rw [Finset.sum_eq_single i] + · simp only [ite_true, mul_smul] + have hright (p' : CornerPath Q α (p i).color) : + pathBasis Q (K := K) (Path.dual Q p'.val) * vertexId Q α = + pathBasis Q (Path.dual Q p'.val) := + cornerPath_right Q ((cornerDual Q α (p i).color) p') + simp only [hright] + exact dual_right_action Q (M i u.1) (hM.1 i u.1) u.2 + · intro b _ hbi + apply Finset.sum_eq_zero + intro c _ + exact ite_eq_right (Ne.symm hbi) + · simp + +namespace BasedComplex + +variable [Fintype I] + +noncomputable def cotestComplex (E : BasedComplex Q (K := K) I) (α : V) : + BasedComplex Q (K := K) (TestIndex Q E.placement α) where + placement := cotestPlacement Q E.placement α + differential := scalarCornerMatrix Q α (testMatrix Q E.placement E.placement α E.differential) + entries := scalarCornerMatrix_entries Q α _ _ (fun _ => rfl) (fun _ => rfl) _ + degree := cotestMatrix_degree Q α E.degree + square_zero := by + rw [scalarCornerMatrix_mul, testMatrix_mul Q α _ E.entries, E.square_zero, + testMatrix_zero, scalarCornerMatrix_zero] + +noncomputable def coevaluation (E : BasedComplex Q (K := K) I) (α : V) : + Map Q E (E.cotestComplex Q α) where + matrix := coevaluationMatrix Q E.placement α + entries := coevaluation_entries Q _ α + degree := coevaluation_degree Q _ α + commute := by + apply Matrix.ext + intro i u + exact (mul_coevaluation Q _ α E.differential i u).trans + (coevaluation_testMatrix Q _ _ α E.entries i u).symm + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/Dual.lean b/lean/OAI/Topology/ArtinGroups/Quivers/Dual.lean new file mode 100644 index 0000000000000000000000000000000000000000..2cd3c26d35cb0028b6ef21068c6506f1dc3f337d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/Dual.lean @@ -0,0 +1,92 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.CornerPath + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver + +namespace Path + +variable {V A : Type*} (Q : ReversibleQuiver V A) + +def dual : Path V A → Path V A + | .inl v => .inr (.inr v) + | .inr (.inl a) => .inr (.inl (Q.reverse a)) + | .inr (.inr v) => .inl v + +@[simp] lemma dual_dual (p : Path V A) : dual Q (dual Q p) = p := by + rcases p with v | a | v <;> simp [dual] + +@[simp] lemma source_dual (p : Path V A) : source Q (dual Q p) = target Q p := by + rcases p with v | a | v + · rfl + · exact Q.source_reverse a + · rfl + +@[simp] lemma target_dual (p : Path V A) : target Q (dual Q p) = source Q p := by + rcases p with v | a | v + · rfl + · exact Q.target_reverse a + · rfl + +lemma length_dual (p : Path V A) : length (dual Q p) = 2 - length p := by + rcases p with v | a | v <;> rfl + +end Path + +namespace Zigzag + +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +def cornerDual (s t : V) : CornerPath Q s t ≃ CornerPath Q t s where + toFun p := ⟨Path.dual Q p.val, by simpa only [Path.source_dual, Path.target_dual] using p.property.symm⟩ + invFun p := ⟨Path.dual Q p.val, by simpa only [Path.source_dual, Path.target_dual] using p.property.symm⟩ + left_inv p := by apply Subtype.ext; exact Path.dual_dual Q p.val + right_inv p := by apply Subtype.ext; exact Path.dual_dual Q p.val + +lemma coordinates_trace (x : Q.Zigzag K) (p : Path V A) : + pathCoordinates Q x p = trace Q (x * pathBasis Q (Path.dual Q p)) := by + rcases p with v | a | v + · simp only [Path.dual, pathBasis_token, trace_mul_tokenBasis, pathCoordinates_vertex] + · simp only [Path.dual, pathBasis_arrow, trace_mul_arrowBasis, pathCoordinates_arrow] + · rw [Path.dual, pathBasis_vertex] + exact (trace_mul_vertexBasis Q x v).symm + +omit [DecidableEq A] in +lemma sum_dual_cornerPath {s t : V} (x : Q.Zigzag K) + (hl : vertexId Q t * x = x) (hr : x * vertexId Q s = x) : + ∑ p : CornerPath Q s t, pathCoordinates Q x (Path.dual Q p.val) • + pathBasis Q (Path.dual Q p.val) = x := by + classical + calc + _ = ∑ p : CornerPath Q t s, pathCoordinates Q x p.val • pathBasis Q p.val := by + apply Fintype.sum_equiv (cornerDual Q s t) + intro p + rfl + _ = x := sum_cornerPath Q x hl hr + +lemma dual_right_action {s t α : V} (x : Q.Zigzag K) + (hl : vertexId Q s * x = x) + (q : CornerPath Q α t) : + ∑ p : CornerPath Q α s, pathCoordinates Q (pathBasis Q p.val * x) q.val • + pathBasis Q (Path.dual Q p.val) = x * pathBasis Q (Path.dual Q q.val) := by + have hl' : vertexId Q s * (x * pathBasis Q (Path.dual Q q.val)) = + x * pathBasis Q (Path.dual Q q.val) := by + rw [← _root_.mul_assoc, hl] + have hr' : (x * pathBasis Q (Path.dual Q q.val)) * vertexId Q α = + x * pathBasis Q (Path.dual Q q.val) := by + rw [_root_.mul_assoc] + exact congrArg (fun z => x * z) (cornerPath_right Q ((cornerDual Q α t) q)) + conv_rhs => rw [← sum_dual_cornerPath Q _ hl' hr'] + apply Finset.sum_congr rfl + intro p _ + congr 1 + rw [coordinates_trace, coordinates_trace, Path.dual_dual] + rw [trace_mul_comm Q (x * pathBasis Q (Path.dual Q q.val)) (pathBasis Q p.val)] + exact congrArg (trace Q) (_root_.mul_assoc _ _ _) + +end Zigzag +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/EdgeContraction.lean b/lean/OAI/Topology/ArtinGroups/Quivers/EdgeContraction.lean new file mode 100644 index 0000000000000000000000000000000000000000..9935bc3f0d15f4193184d61ff800635aebcf3613 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/EdgeContraction.lean @@ -0,0 +1,103 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.InverseTwistDifferential +import OAI.Topology.ArtinGroups.Coxeter.BraidCoreIndex + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + [Fintype I] [DecidableEq I] + +noncomputable def edgeContraction (p : I → GeneratorPlacement V) + {α β : V} (e : SimpleEdge Q α β) : + Matrix (TestIndex Q p β) (TestIndex Q p α) K := + fun u v => if u.1 = v.1 then + pathCoordinates Q (arrowBasis Q e.arrow * pathBasis Q u.2.val) v.2.val else 0 + +namespace BasedComplex + +noncomputable def braidCoreDifferential (E : BasedComplex Q (K := K) I) + {α β : V} (e : SimpleEdge Q α β) : + Matrix (BraidCoreIndex Q E α β) (BraidCoreIndex Q E α β) (Q.Zigzag K) + | .inl u, .inl v => scalarCornerMatrix Q α (testMatrix Q E.placement E.placement β E.differential) u v + | .inr (.inl u), .inr (.inl v) => scalarCornerMatrix Q β (testMatrix Q E.placement E.placement α E.differential) u v + | .inr (.inr (.inl u)), .inr (.inr (.inl v)) => -testTransform Q E.placement E.placement α E.differential u v + | .inr (.inr (.inr (.inl u))), .inr (.inr (.inr (.inl v))) => -testTransform Q E.placement E.placement β E.differential u v + | .inl u, .inr (.inr (.inl v)) => -scalarCornerMatrix Q α (edgeContraction Q E.placement e) u v + | .inl u, .inr (.inr (.inr (.inl v))) => if u = v then arrowBasis Q e.arrow else 0 + | .inr (.inl u), .inr (.inr (.inl v)) => if u = v then arrowBasis Q (e.reverse Q).arrow else 0 + | .inr (.inl u), .inr (.inr (.inr (.inl v))) => -scalarCornerMatrix Q β (edgeContraction Q E.placement (e.reverse Q)) u v + | .inr (.inr (.inl u)), .inr (.inr (.inr (.inr j))) => evaluationMatrix Q E.placement α u j + | .inr (.inr (.inr (.inl u))), .inr (.inr (.inr (.inr j))) => evaluationMatrix Q E.placement β u j + | .inr (.inr (.inr (.inr i))), .inr (.inr (.inr (.inr j))) => E.differential i j + | _, _ => 0 + +noncomputable def braidRawCoreDifferential (E : BasedComplex Q (K := K) I) + {α β : V} (e : SimpleEdge Q α β) : + Matrix (BraidCoreIndex Q E α β) (BraidCoreIndex Q E α β) (Q.Zigzag K) + | .inr (.inl _), .inr (.inr (.inl _)) => 0 + | i, j => braidCoreDifferential Q E e i j + +lemma arrowBasis_right_vertex (a : A) : + arrowBasis Q (K := K) a * vertexId Q (Q.target a) = arrowBasis Q a := by + simpa only [Path.target, pathBasis_arrow] using + pathBasis_right Q (K := K) (.inr (.inl a)) + +lemma arrowBasis_coordinates_self (a : A) : + pathCoordinates Q (arrowBasis Q (K := K) a) (.inr (.inl a)) = 1 := by + rw [← pathBasis_arrow, pathBasis_coordinates, ite_eq_left rfl] + +lemma simpleEdge_arrow_right {α β : V} (e : SimpleEdge Q α β) : + arrowBasis Q (K := K) e.arrow * vertexId Q β = arrowBasis Q e.arrow := by + simpa only [e.target] using arrowBasis_right_vertex Q (K := K) e.arrow + +lemma normalizedBraidTwist_core (hn : ∀ a, Q.source a ≠ Q.target a) + (E : BasedComplex Q (K := K) I) {α β : V} (e : SimpleEdge Q α β) + (i j : BraidCoreIndex Q E α β) : + (normalizedBraidTwist Q hn E e).differential + (.inr (.inr (.inr (.inr i)))) (.inr (.inr (.inr (.inr j)))) = + braidRawCoreDifferential Q E e i j := by + rcases i with u | u | u | u | i <;> rcases j with v | v | v | v | j + all_goals simp only [normalizedBraidTwist, reindex, Matrix.submatrix_apply, + braidTwistIndexEquiv, Equiv.coe_fn_mk, positiveTwist_differential, + Matrix.fromBlocks, Matrix.of_apply, Sum.elim_inl, Sum.elim_inr, + Matrix.zero_apply, Matrix.neg_apply, testTransform, scalarCornerMatrix, testMatrix, + braidRawCoreDifferential, braidCoreDifferential, + MulZeroClass.mul_zero, coordinates_zero, zero_smul, neg_zero, + SimpleEdge.corner_val, pathBasis_arrow] + all_goals try simp only [_root_.mul_neg, mul_smul, map_neg, Pi.neg_apply, + coordinates_smul, neg_smul, neg_neg, simpleEdge_arrow_right Q e, + simpleEdge_arrow_right Q (e.reverse Q), + arrowBasis_coordinates_self, _root_.mul_one] + all_goals try simp only [evaluationMatrix, edgeContraction, + Sum.inr.injEq, Sum.inl.injEq, Sum.inr_ne_inl, Sum.inl_ne_inr, ↓reduceIte, + SimpleEdge.corner_val, pathBasis_arrow] + all_goals try (refine @ite_cond_congr _ _ _ ?_ ?_ _ _ rfl) + · split_ifs with h + · have hx := congrArg (fun x : TestIndex Q (E.positiveTwist Q α).placement β => x.1) h + cases hx + · rfl + · split_ifs <;> simp only [MulZeroClass.mul_zero, coordinates_zero] + · rcases u with ⟨i, p⟩ + rcases v with ⟨j, q⟩ + refine @ite_cond_congr _ _ _ ?_ ?_ _ _ ?_ + apply propext + constructor + · intro h + have hi := congrArg (fun x : TestIndex Q (E.positiveTwist Q α).placement β => x.1) h + have hij : i = j := Sum.inr.inj hi + subst j + have hpq : p = q := by cases h; rfl + cases hpq + rfl + · intro h + cases h + rfl + · split_ifs <;> simp only [MulZeroClass.mul_zero, coordinates_zero] + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ExtArrow.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ExtArrow.lean new file mode 100644 index 0000000000000000000000000000000000000000..18ec0461052d1be4d5db362cfc96ce5d4e6bd0c2 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ExtArrow.lean @@ -0,0 +1,22 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.SimpleEdge + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag.SimpleEdge + +variable {V A : Type*} (Q : ReversibleQuiver V A) {α β : V} + +lemma ext_arrow {e f : SimpleEdge Q α β} (h : e.arrow = f.arrow) : e = f := by + cases e + cases f + cases h + rfl + +@[simp] lemma reverse_reverse (e : SimpleEdge Q α β) : (e.reverse Q).reverse Q = e := by + apply ext_arrow Q + exact Q.reverse_reverse e.arrow + +end HarmonicArtin.ReversibleQuiver.Zigzag.SimpleEdge + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/Iso.lean b/lean/OAI/Topology/ArtinGroups/Quivers/Iso.lean new file mode 100644 index 0000000000000000000000000000000000000000..473f7ee209f0cf821d84fce7374d668f4ec8f387 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/Iso.lean @@ -0,0 +1,116 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.GeneratorPlacement + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver + +variable {V A W B : Type*} (Q : ReversibleQuiver V A) (R : ReversibleQuiver W B) + +structure Iso where + vertex : V ≃ W + arrow : A ≃ B + source : ∀ a, R.source (arrow a) = vertex (Q.source a) + target : ∀ a, R.target (arrow a) = vertex (Q.target a) + reverse : ∀ a, R.reverse (arrow a) = arrow (Q.reverse a) + +namespace Iso +variable {Q R} (e : Iso Q R) + +@[simp] lemma source_symm (b:B) : Q.source (e.arrow.symm b) = e.vertex.symm (R.source b) := by + apply e.vertex.injective + simpa only [Equiv.apply_symm_apply] using (e.source (e.arrow.symm b)).symm + +@[simp] lemma target_symm (b:B) : Q.target (e.arrow.symm b) = e.vertex.symm (R.target b) := by + apply e.vertex.injective + simpa only [Equiv.apply_symm_apply] using (e.target (e.arrow.symm b)).symm + +@[simp] lemma reverse_symm (b:B) : Q.reverse (e.arrow.symm b) = e.arrow.symm (R.reverse b) := by + apply e.arrow.injective + simpa only [Equiv.apply_symm_apply] using (e.reverse (e.arrow.symm b)).symm + +def refl (Q : ReversibleQuiver V A) : Iso Q Q where + vertex := Equiv.refl V + arrow := Equiv.refl A + source _ := rfl + target _ := rfl + reverse _ := rfl + +def symm : Iso R Q where + vertex := e.vertex.symm + arrow := e.arrow.symm + source := e.source_symm + target := e.target_symm + reverse := e.reverse_symm + +def trans {X C : Type*} {U : ReversibleQuiver X C} (f : Iso R U) : Iso Q U where + vertex := e.vertex.trans f.vertex + arrow := e.arrow.trans f.arrow + source a := by dsimp; rw [f.source,e.source] + target a := by dsimp; rw [f.target,e.target] + reverse a := by dsimp; rw [f.reverse,e.reverse] + +variable {K : Type*} [Field K] [Fintype A] [Fintype B] [DecidableEq V] [DecidableEq W] + +noncomputable def zigzagLinear : Q.Zigzag K ≃ₗ[K] R.Zigzag K where + toFun x := (x.vertex ∘ e.vertex.symm, x.arrow ∘ e.arrow.symm, x.token ∘ e.vertex.symm) + invFun x := (x.vertex ∘ e.vertex, x.arrow ∘ e.arrow, x.token ∘ e.vertex) + left_inv x := by apply Zigzag.ext <;> ext y <;> simp [Function.comp_def,Zigzag.vertex,Zigzag.arrow,Zigzag.token] + right_inv x := by apply Zigzag.ext <;> ext y <;> simp [Function.comp_def,Zigzag.vertex,Zigzag.arrow,Zigzag.token] + map_add' _ _ := rfl + map_smul' _ _ := rfl + +@[simp] lemma zigzagLinear_vertex (x : Q.Zigzag K) (v : W) : + (e.zigzagLinear x).vertex v = x.vertex (e.vertex.symm v) := rfl +@[simp] lemma zigzagLinear_arrow (x : Q.Zigzag K) (b : B) : + (e.zigzagLinear x).arrow b = x.arrow (e.arrow.symm b) := rfl +@[simp] lemma zigzagLinear_token (x : Q.Zigzag K) (v : W) : + (e.zigzagLinear x).token v = x.token (e.vertex.symm v) := rfl + +lemma zigzagLinear_one : e.zigzagLinear (1 : Q.Zigzag K) = 1 := rfl + +lemma zigzagLinear_mul (x y : Q.Zigzag K) : + e.zigzagLinear (x*y) = e.zigzagLinear x * e.zigzagLinear y := by + apply Zigzag.ext + · rfl + · ext b + simp only [zigzagLinear_arrow,Zigzag.arrow_mul,leftScale,rightScale, + Pi.add_apply,zigzagLinear_vertex,e.source_symm,e.target_symm] + · ext v + simp only [zigzagLinear_token,Zigzag.token_mul,Pi.add_apply,Pi.mul_apply, + zigzagLinear_vertex,backtrack] + congr 1 + rw [← e.arrow.sum_comp] + apply Finset.sum_congr rfl + intro a _ + simp only [e.source,zigzagLinear_arrow,e.reverse,Equiv.symm_apply_apply] + have hh : e.vertex (Q.source a)=v ↔ Q.source a=e.vertex.symm v := + e.vertex.eq_symm_apply.symm + simp only [hh] + +noncomputable def zigzag : Q.Zigzag K ≃+* R.Zigzag K where + toEquiv := e.zigzagLinear.toEquiv + map_mul' := e.zigzagLinear_mul + map_add' := e.zigzagLinear.map_add + +lemma zigzag_vertexId (v:V) : e.zigzagLinear (Zigzag.vertexId Q (K := K) v) = + Zigzag.vertexId R (e.vertex v) := by + apply Zigzag.ext + · ext w + simp only [zigzagLinear_vertex,Zigzag.vertexId_eval] + congr 1 + exact propext e.vertex.symm_apply_eq + · rfl + · rfl + +lemma zigzag_homogeneous {d : ℤ} {x : Q.Zigzag K} (h : Zigzag.Homogeneous Q d x) : + Zigzag.Homogeneous R d (e.zigzagLinear x) := by + refine ⟨?_,?_,?_⟩ + · intro hd; ext v; simp only [zigzagLinear_vertex,h.1 hd,Pi.zero_apply] + · intro hd; ext b; simp only [zigzagLinear_arrow,h.2.1 hd,Pi.zero_apply] + · intro hd; ext v; simp only [zigzagLinear_token,h.2.2 hd,Pi.zero_apply] + +end Iso +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/LengthCases.lean b/lean/OAI/Topology/ArtinGroups/Quivers/LengthCases.lean new file mode 100644 index 0000000000000000000000000000000000000000..ec659230aaf786da7537c61821115deed1719a42 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/LengthCases.lean @@ -0,0 +1,18 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.Path + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Path + +variable {V A : Type*} + +lemma length_cases (p : Path V A) : p.length = 0 ∨ p.length = 1 ∨ p.length = 2 := by + rcases p with v | a | v + · exact Or.inl rfl + · exact Or.inr (Or.inl rfl) + · exact Or.inr (Or.inr rfl) + +end HarmonicArtin.ReversibleQuiver.Path + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/Level.lean b/lean/OAI/Topology/ArtinGroups/Quivers/Level.lean new file mode 100644 index 0000000000000000000000000000000000000000..5d34b94159b8554641abde9bb11f50f1f9ae4105 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/Level.lean @@ -0,0 +1,164 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.Reduction +import OAI.Topology.ArtinGroups.Harmonic.Level + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J L : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype A] [DecidableEq V] + +lemma mapDegree_level_bound {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} + {M : Matrix I J (Q.Zigzag K)} {n v : ℤ} (h : MapDegree Q p q n v M) + {i : I} {j : J} (hne : M i j ≠ 0) : + (q j).level ≤ (p i).level + n + v := by + have hc : (q j).cochain = (p i).cochain + n := by + by_contra hc + exact hne ((h i j).1 hc) + have ha := homogeneous_nonzero_degree Q (h i j).2 hne + dsimp only [GeneratorPlacement.level] + omega + +def atLevel (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (M : Matrix I J (Q.Zigzag K)) (d : ℤ) : + Matrix {i // (p i).level = d} {j // (q j).level = d} (Q.Zigzag K) := + fun i j => M i.val j.val + +lemma atLevel_mul [Fintype J] + (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (r : L → GeneratorPlacement V) (M : Matrix I J (Q.Zigzag K)) + (N : Matrix J L (Q.Zigzag K)) (d : ℤ) + [Fintype {j // (q j).level = d}] + (hM : ∀ i j, M i j ≠ 0 → (q j).level ≤ (p i).level) + (hN : ∀ j k, N j k ≠ 0 → (r k).level ≤ (q j).level) : + atLevel Q p r (M * N) d = atLevel Q p q M d * atLevel Q q r N d := by + classical + apply Matrix.ext + intro i k + change (∑ j, M i.val j * N j k.val) = + ∑ j : {j // (q j).level = d}, M i.val j.val * N j.val k.val + symm + apply Fintype.sum_of_injective (Subtype.val : {j // (q j).level = d} → J) + Subtype.val_injective + · intro j hj + by_cases h₁ : M i.val j = 0 + · rw [h₁] + exact MulZeroClass.zero_mul _ + by_cases h₂ : N j k.val = 0 + · rw [h₂] + exact MulZeroClass.mul_zero _ + have hle := hM i.val j h₁ + have hge := hN j k.val h₂ + have hq : (q j).level = d := by + rw [i.property] at hle + rw [k.property] at hge + exact le_antisymm hle hge + exact (hj ⟨⟨j, hq⟩, rfl⟩).elim + · intro j + rfl + +lemma atLevel_add (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (M N : Matrix I J (Q.Zigzag K)) (d : ℤ) : + atLevel Q p q (M + N) d = atLevel Q p q M d + atLevel Q p q N d := rfl + +lemma atLevel_zero (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (d : ℤ) : atLevel Q p q (0 : Matrix I J (Q.Zigzag K)) d = 0 := rfl + +lemma atLevel_identity [DecidableEq I] (p : I → GeneratorPlacement V) (d : ℤ) : + atLevel Q p p (projectiveIdentity Q (K := K) p) d = + projectiveIdentity Q (fun i : {i // (p i).level = d} => p i.val) := by + apply Matrix.ext + intro i j + change (if i.val = j.val then vertexId Q (p i.val).color else 0) = + (if i = j then vertexId Q (p i.val).color else 0) + simp only [Subtype.val_inj] + +lemma atLevel_degree_neg (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (M : Matrix I J (Q.Zigzag K)) (d : ℤ) (hM : MapDegree Q p q (-1) 0 M) : + atLevel Q p q M d = 0 := by + apply Matrix.ext + intro i j + change M i.val j.val = 0 + by_contra hne + have h := mapDegree_level_bound Q hM hne + rw [i.property, j.property] at h + omega + +namespace BasedComplex + +variable [Fintype I] [Fintype J] [Fintype L] + +lemma map_level_bound {E : BasedComplex Q (K := K) I} {F : BasedComplex Q (K := K) J} + (f : Map Q E F) (i : I) (j : J) (h : f.matrix i j ≠ 0) : + (F.placement j).level ≤ (E.placement i).level := by + simpa only [add_zero] using mapDegree_level_bound Q f.degree h + +lemma minimal_differential_level_bound (E : BasedComplex Q (K := K) I) + (hE : E.IsMinimal Q) (i j : I) (h : E.differential i j ≠ 0) : + (E.placement j).level ≤ (E.placement i).level := by + have h := E.differential_level Q hE h + omega + +noncomputable def Map.pureLayer {E : BasedComplex Q (K := K) I} + {F : BasedComplex Q (K := K) J} (f : Map Q E F) + (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) (d : ℤ) : + Map Q (E.pureLayer Q hE d) (F.pureLayer Q hF d) where + matrix := atLevel Q E.placement F.placement f.matrix d + entries := ⟨fun i j => f.entries.1 i.val j.val, fun i j => f.entries.2 i.val j.val⟩ + degree := fun i j => f.degree i.val j.val + commute := by + change atLevel Q E.placement E.placement E.differential d * + atLevel Q E.placement F.placement f.matrix d = + atLevel Q E.placement F.placement f.matrix d * + atLevel Q F.placement F.placement F.differential d + rw [← atLevel_mul Q _ _ _ _ _ d (E.minimal_differential_level_bound Q hE) + (map_level_bound Q f), ← atLevel_mul Q _ _ _ _ _ d (map_level_bound Q f) + (F.minimal_differential_level_bound Q hF), f.commute] + +structure ChainIsomorphism [DecidableEq I] [DecidableEq J] + (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) where + forward : Map Q E F + backward : Map Q F E + sourceEquation : forward.matrix * backward.matrix = projectiveIdentity Q E.placement + targetEquation : backward.matrix * forward.matrix = projectiveIdentity Q F.placement + +lemma atLevel_homotopy_boundary (E : BasedComplex Q (K := K) I) (hE : E.IsMinimal Q) + (H : Matrix I I (Q.Zigzag K)) (hH : MapDegree Q E.placement E.placement (-1) 0 H) + (d : ℤ) : atLevel Q E.placement E.placement + (E.differential * H + H * E.differential) d = 0 := by + classical + have hbound (i j : I) (h : H i j ≠ 0) : + (E.placement j).level ≤ (E.placement i).level := by + have hb := mapDegree_level_bound Q hH h + omega + rw [atLevel_add, atLevel_mul Q _ _ _ _ _ d + (E.minimal_differential_level_bound Q hE) hbound, + atLevel_mul Q _ _ _ _ _ d hbound (E.minimal_differential_level_bound Q hE), + atLevel_degree_neg Q _ _ _ _ hH, Matrix.zero_mul, Matrix.mul_zero, add_zero] + +noncomputable def HomotopyEquivalence.pureLayer [DecidableEq I] [DecidableEq J] + {E : BasedComplex Q (K := K) I} {F : BasedComplex Q (K := K) J} + (h : HomotopyEquivalence Q E F) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) (d : ℤ) : + ChainIsomorphism Q (E.pureLayer Q hE d) (F.pureLayer Q hF d) where + forward := h.forward.pureLayer Q hE hF d + backward := h.backward.pureLayer Q hF hE d + sourceEquation := by + change atLevel Q _ _ h.forward.matrix d * atLevel Q _ _ h.backward.matrix d = _ + rw [← atLevel_mul Q _ _ _ _ _ d (map_level_bound Q h.forward) + (map_level_bound Q h.backward), h.sourceEquation, atLevel_add, + E.atLevel_homotopy_boundary Q hE h.sourceHomotopy h.sourceDegree, + add_zero, atLevel_identity] + rfl + targetEquation := by + change atLevel Q _ _ h.backward.matrix d * atLevel Q _ _ h.forward.matrix d = _ + rw [← atLevel_mul Q _ _ _ _ _ d (map_level_bound Q h.backward) + (map_level_bound Q h.forward), h.targetEquation, atLevel_add, + F.atLevel_homotopy_boundary Q hF h.targetHomotopy h.targetDegree, + add_zero, atLevel_identity] + rfl + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/LinearMatrix.lean b/lean/OAI/Topology/ArtinGroups/Quivers/LinearMatrix.lean new file mode 100644 index 0000000000000000000000000000000000000000..9cacac0569dfc6a8b61b946ab0db9381eaa51dc2 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/LinearMatrix.lean @@ -0,0 +1,86 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.HomDetector +import OAI.Topology.ArtinGroups.Complexes.DiagonalVertex + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] +variable {I J : Type*} [Fintype I] [Fintype J] + +def LinearMatrix (f : Matrix I J (Q.Zigzag K)) : Prop := + ∀ i j, (f i j).vertex = 0 ∧ (f i j).token = 0 + +namespace BasedComplex +lemma supertrace_linear (E : BasedComplex Q (K := K) I) + {f : Matrix I I (Q.Zigzag K)} (hf : LinearMatrix Q f) : supertrace Q E f = 0 := by + change (∑ i, cochainSign (K := K) (E.placement i).cochain * trace Q (f i i)) = 0 + apply Finset.sum_eq_zero + intro i _ + have ht : trace Q (f i i) = 0 := by + change (∑ α, (f i i).token α) = 0 + rw [(hf i i).2] + simp only [Pi.zero_apply, Finset.sum_const_zero] + rw [ht, MulZeroClass.mul_zero] + +lemma cochainSign_ne_zero (n : ℤ) : cochainSign (K := K) n ≠ 0 := by + intro h + have hh := cochainSign_mul_self (K := K) n + rw [h, MulZeroClass.zero_mul] at hh + exact zero_ne_one hh + +variable [DecidableEq I] + +lemma linear_selfCycle_boundary_zero (E : BasedComplex Q (K := K) I) + (hE : E.IsMinimal Q) (i : I) (hd : homDimension Q E E 0 0 ≤ 1) + {f : Matrix I I (Q.Zigzag K)} (hf : f ∈ homCycles Q E E 0 0) + (hlin : LinearMatrix Q f) : f ∈ homBoundaries Q E E 0 0 := by + apply boundary_of_homDimension_le_one Q E E 0 0 hd (diagonalVertex Q E i) + (fun _ h => diagonalVertex_boundary Q E hE i 0 0 h) (identity_mem_homCycles Q E) + · rw [diagonalVertex_identity] + exact one_ne_zero + · exact hf + · exact congrFun (hlin i i).1 (E.placement i).color + +lemma linear_selfCycle_boundary_two (E : BasedComplex Q (K := K) I) + (hE : E.IsMinimal Q) (i : I) (hd : homDimension Q E E 0 2 ≤ 1) + {f : Matrix I I (Q.Zigzag K)} (hf : f ∈ homCycles Q E E 0 2) + (hlin : LinearMatrix Q f) : f ∈ homBoundaries Q E E 0 2 := by + apply boundary_of_homDimension_le_one Q E E 0 2 hd (supertrace Q E) + (by rintro _ ⟨g, _, rfl⟩; exact supertrace_boundary Q E g) + (diagonalToken_mem_homCycles Q E hE i) + · rw [supertrace_diagonalToken] + exact cochainSign_ne_zero _ + · exact hf + · exact supertrace_linear Q E hlin + +lemma linear_selfCycle_boundary (E : BasedComplex Q (K := K) I) (hE : E.IsMinimal Q) + (hcap : ∀ n v, homDimension Q E E n v ≤ 1) + (hsupp : ∀ n v, n ≠ 0 ∨ (v ≠ 0 ∧ v ≠ 2) → homDimension Q E E n v = 0) + (n v : ℤ) {f : Matrix I I (Q.Zigzag K)} (hf : f ∈ homCycles Q E E n v) + (hlin : LinearMatrix Q f) : f ∈ homBoundaries Q E E n v := by + by_cases hI : Nonempty I + · let i : I := Classical.choice hI + by_cases hn : n = 0 + · subst n + by_cases hv₀ : v = 0 + · subst v + exact linear_selfCycle_boundary_zero Q E hE i (hcap 0 0) hf hlin + · by_cases hv₂ : v = 2 + · subst v + exact linear_selfCycle_boundary_two Q E hE i (hcap 0 2) hf hlin + · exact boundary_of_homDimension_zero Q E E 0 v + (hsupp 0 v (Or.inr ⟨hv₀, hv₂⟩)) hf + · exact boundary_of_homDimension_zero Q E E n v (hsupp n v (Or.inl hn)) hf + · have hz : f = 0 := by + apply Matrix.ext + intro i _ + exact (hI ⟨i⟩).elim + rw [hz] + exact Submodule.zero_mem _ + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/OffDiagonalVertexZero.lean b/lean/OAI/Topology/ArtinGroups/Quivers/OffDiagonalVertexZero.lean new file mode 100644 index 0000000000000000000000000000000000000000..438be5891adc23a178ce6a96e885902dbeb88d34 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/OffDiagonalVertexZero.lean @@ -0,0 +1,80 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.InitialProjective +import OAI.Topology.ArtinGroups.Complexes.HomStep +import OAI.Topology.ArtinGroups.Complexes.HomPath + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype A] [DecidableEq V] + +lemma offDiagonal_vertex_zero {s t:V} {x:Q.Zigzag K} + (hl:vertexId Q s*x=x) (hr:x*vertexId Q t=x) (hst:s≠t) : x.vertex=0 := by + funext v + by_contra hv + have h:=coordinates_corner Q hl hr (p:=.inl v) hv + exact hst (h.1.symm.trans h.2) + +lemma offDiagonal_token_zero {s t:V} {x:Q.Zigzag K} + (hl:vertexId Q s*x=x) (hr:x*vertexId Q t=x) (hst:s≠t) : x.token=0 := by + funext v + by_contra hv + have h:=coordinates_corner Q hl hr (p:=.inr (.inr v)) hv + exact hst (h.1.symm.trans h.2) + +lemma offDiagonal_radical_mul_zero {s t u:V} {x y:Q.Zigzag K} + (hl:vertexId Q s*x=x) (hr:x*vertexId Q t=x) (hst:s≠t) + (hy:y.vertex=0) (hyr:y*vertexId Q u=y) (hsu:s≠u) : x*y=0 := by + have hv:=offDiagonal_vertex_zero Q hl hr hst + have ht: (x*y).token=0 := offDiagonal_token_zero Q + (by rw [← mul_assoc,hl]) (by rw [mul_assoc,hyr]) hsu + apply Zigzag.ext + · simp only [vertex_mul,hv,MulZeroClass.zero_mul,vertex_zero] + · ext a + simp only [arrow_mul,hv,hy,leftScale,rightScale,Pi.add_apply,Pi.zero_apply, + MulZeroClass.zero_mul,MulZeroClass.mul_zero,add_zero,arrow_zero] + · exact ht + +namespace BasedComplex +variable {I:Type*} [Fintype I] + +lemma absentProjective_homDifferential_zero (E:BasedComplex Q (K:=K) I) + (hE:E.IsMinimal Q) (α:V) (ha:∀i,(E.placement i).color≠α) + (n v:ℤ) {f:Matrix PUnit.{1} I (Q.Zigzag K)} + (hf:f∈homSpace Q ((initialProjective Q α : BasedComplex Q (K:=K) PUnit.{1})) E n v) : + homDifferential Q ((initialProjective Q α : BasedComplex Q (K:=K) PUnit.{1})) E n f=0 := by + have hm:f*E.differential=0 := by + apply Matrix.ext + intro i k + change (∑j,f i j*E.differential j k)=0 + apply Finset.sum_eq_zero + intro j _ + exact offDiagonal_radical_mul_zero Q (hf.1.1 i j) (hf.1.2 i j) + (Ne.symm (ha j)) (hE j k) (E.entries.2 j k) (Ne.symm (ha k)) + change (0:Matrix PUnit.{1} PUnit.{1} (Q.Zigzag K))*f-cochainSign (K:=K) n • (f*E.differential)=0 + rw [hm,Matrix.zero_mul,smul_zero,sub_zero] + +lemma absentProjective_homBoundaries_bot (E:BasedComplex Q (K:=K) I) + (hE:E.IsMinimal Q) (α:V) (ha:∀i,(E.placement i).color≠α) (n v:ℤ) : + homBoundaries Q ((initialProjective Q α : BasedComplex Q (K:=K) PUnit.{1})) E n v=⊥ := by + apply le_antisymm _ bot_le + rintro x ⟨f,hf,rfl⟩ + exact absentProjective_homDifferential_zero Q E hE α ha (n-1) v hf + +variable [Fintype V] [DecidableEq A] + +lemma absentProjective_homDimension (E:BasedComplex Q (K:=K) I) + (hE:E.IsMinimal Q) (α:V) (ha:∀i,(E.placement i).color≠α) (n v:ℤ) : + homDimension Q ((initialProjective Q α : BasedComplex Q (K:=K) PUnit.{1})) E n v= + Nat.card (HomPath Q ((initialProjective Q α : BasedComplex Q (K:=K) PUnit.{1})) E n v) := by + have h:=hom_exact_dimension Q ((initialProjective Q α : BasedComplex Q (K:=K) PUnit.{1})) E n v + rw [absentProjective_homBoundaries_bot Q E hE α ha, + absentProjective_homBoundaries_bot Q E hE α ha,finrank_bot, + add_zero,add_zero,homSpace_finrank] at h + exact h + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/OrthogonalVertices.lean b/lean/OAI/Topology/ArtinGroups/Quivers/OrthogonalVertices.lean new file mode 100644 index 0000000000000000000000000000000000000000..3dc3d18fd023eb0f3a90ed537b917b829fc9c7e6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/OrthogonalVertices.lean @@ -0,0 +1,126 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.InverseTwistDifferential + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A : Type*} (Q : ReversibleQuiver V A) + +def OrthogonalVertices (α β : V) : Prop := + α ≠ β ∧ ∀ a, Q.source a = α → Q.target a ≠ β + +lemma OrthogonalVertices.symm {α β : V} (h : OrthogonalVertices Q α β) : + OrthogonalVertices Q β α := by + refine ⟨h.1.symm, ?_⟩ + intro a hs ht + exact h.2 (Q.reverse a) ((Q.source_reverse a).trans ht) + ((Q.target_reverse a).trans hs) + +lemma no_corner_of_orthogonal {α β : V} (h : OrthogonalVertices Q α β) + (p : CornerPath Q α β) : False := by + rcases p with ⟨v | a | v, hs, ht⟩ + · exact h.1 (hs.symm.trans ht) + · exact h.2 a hs ht + · exact h.1 (hs.symm.trans ht) + +namespace BasedComplex + +variable {K I J : Type*} [Field K] [Fintype V] [Fintype A] + [DecidableEq V] [DecidableEq A] [Fintype I] [Fintype J] + +omit [Fintype V] [DecidableEq A] in +@[ext] lemma ext_placement_differential + {E F : BasedComplex Q (K := K) I} (hp : E.placement = F.placement) + (hd : E.differential = F.differential) : E = F := by + cases E + cases F + cases hp + cases hd + rfl + +variable [DecidableEq I] [DecidableEq J] + +noncomputable def HomotopyEquivalence.symm + {E : BasedComplex Q (K := K) I} {F : BasedComplex Q (K := K) J} + (h : HomotopyEquivalence Q E F) : HomotopyEquivalence Q F E where + forward := h.backward + backward := h.forward + sourceHomotopy := h.targetHomotopy + targetHomotopy := h.sourceHomotopy + sourceEntries := h.targetEntries + targetEntries := h.sourceEntries + sourceDegree := h.targetDegree + targetDegree := h.sourceDegree + sourceEquation := h.targetEquation + targetEquation := h.sourceEquation + +abbrev CommuteTwistIndex (E : BasedComplex Q (K := K) I) (α β : V) := + TestIndex Q E.placement α ⊕ TestIndex Q E.placement β ⊕ I + +noncomputable def commuteTwistIndexEquiv (E : BasedComplex Q (K := K) I) + {α β : V} (h : OrthogonalVertices Q α β) : + CommuteTwistIndex Q E α β ≃ + (TestIndex Q (E.positiveTwist Q β).placement α ⊕ (TestIndex Q E.placement β ⊕ I)) where + toFun + | .inl u => .inl ⟨.inr u.1, u.2⟩ + | .inr u => .inr u + invFun + | .inl ⟨.inl _, p⟩ => (no_corner_of_orthogonal Q h p).elim + | .inl ⟨.inr i, p⟩ => .inl ⟨i, p⟩ + | .inr u => .inr u + left_inv u := by + rcases u with u | u <;> rfl + right_inv u := by + rcases u with ⟨u | i, p⟩ | u + · exact (no_corner_of_orthogonal Q h p).elim + · rfl + · rfl + +noncomputable def normalizedCommuteTwist (E : BasedComplex Q (K := K) I) + {α β : V} (h : OrthogonalVertices Q α β) : + BasedComplex Q (K := K) (CommuteTwistIndex Q E α β) := + ((E.positiveTwist Q β).positiveTwist Q α).reindex Q (commuteTwistIndexEquiv Q E h) + +def commuteTwistPlacement (E : BasedComplex Q (K := K) I) (α β : V) : + CommuteTwistIndex Q E α β → GeneratorPlacement V + | .inl u => ⟨α, (E.placement u.1).cochain - 1, + (E.placement u.1).internal + Path.length u.2.val⟩ + | .inr (.inl u) => ⟨β, (E.placement u.1).cochain - 1, + (E.placement u.1).internal + Path.length u.2.val⟩ + | .inr (.inr i) => E.placement i + +omit [DecidableEq I] in +lemma normalizedCommuteTwist_placement (E : BasedComplex Q (K := K) I) + {α β : V} (h : OrthogonalVertices Q α β) : + (normalizedCommuteTwist Q E h).placement = commuteTwistPlacement Q E α β := by + funext u + rcases u with u | u | i <;> rfl + +noncomputable def commuteTwistDifferential (E : BasedComplex Q (K := K) I) (α β : V) : + Matrix (CommuteTwistIndex Q E α β) (CommuteTwistIndex Q E α β) (Q.Zigzag K) + | .inl u, .inl v => -testTransform Q E.placement E.placement α E.differential u v + | .inr (.inl u), .inr (.inl v) => -testTransform Q E.placement E.placement β E.differential u v + | .inl u, .inr (.inr j) => evaluationMatrix Q E.placement α u j + | .inr (.inl u), .inr (.inr j) => evaluationMatrix Q E.placement β u j + | .inr (.inr i), .inr (.inr j) => E.differential i j + | _, _ => 0 + +omit [DecidableEq I] in +lemma normalizedCommuteTwist_differential (E : BasedComplex Q (K := K) I) + {α β : V} (h : OrthogonalVertices Q α β) : + (normalizedCommuteTwist Q E h).differential = commuteTwistDifferential Q E α β := by + apply Matrix.ext + intro i j + rcases i with u | u | i <;> rcases j with v | v | j + all_goals simp only [normalizedCommuteTwist, reindex, Matrix.submatrix_apply, + commuteTwistIndexEquiv, Equiv.coe_fn_mk, positiveTwist_differential, + Matrix.fromBlocks, commuteTwistDifferential, Matrix.neg_apply, Matrix.of_apply, + Matrix.zero_apply, Sum.elim_inl, Sum.elim_inr, testTransform, scalarCornerMatrix, testMatrix, + evaluationMatrix, Sum.inr_ne_inl, Sum.inr.injEq, ↓reduceIte] + refine @ite_cond_congr _ _ _ ?_ ?_ _ _ (Sum.inr.injEq _ _) + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/PacketIndex.lean b/lean/OAI/Topology/ArtinGroups/Quivers/PacketIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..9ed7e81ba8b83b8dde0c45078d1b069e5881ea02 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/PacketIndex.lean @@ -0,0 +1,107 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.TestPlacement +import OAI.Topology.ArtinGroups.Complexes.ConePlacement + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K I J : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + [Fintype I] [Fintype J] [DecidableEq J] + +abbrev PacketIndex (p : I → GeneratorPlacement V) (v : J → V) := + (a : J) × TestIndex Q p (v a) + +def packetPlacement (p : I → GeneratorPlacement V) (v : J → V) : + PacketIndex Q p v → GeneratorPlacement V := + fun x => testPlacement Q p (v x.1) x.2 + +noncomputable def packetDifferential (p : I → GeneratorPlacement V) (v : J → V) + (M : Matrix I I (Zigzag Q K)) : + Matrix (PacketIndex Q p v) (PacketIndex Q p v) (Zigzag Q K) := + Matrix.blockDiagonal' (fun a => scalarCornerMatrix Q (v a) (testMatrix Q p p (v a) M)) + +omit [DecidableEq A] [Fintype I] [Fintype J] in +lemma packet_entries (p : I → GeneratorPlacement V) (v : J → V) + (M : Matrix I I (Zigzag Q K)) : + ProjectiveEntries Q (packetPlacement Q p v) (packetPlacement Q p v) + (packetDifferential Q p v M) := by + constructor + · rintro ⟨a,x⟩ ⟨b,y⟩ + by_cases h : a=b + · subst b + rw [packetDifferential,Matrix.blockDiagonal'_apply_eq] + exact (scalarCornerMatrix_entries Q (v a) (testPlacement Q p (v a)) (testPlacement Q p (v a)) (fun _ => rfl) (fun _ => rfl) _).1 x y + · rw [packetDifferential,Matrix.blockDiagonal'_apply_ne _ _ _ h,mul_zero] + · rintro ⟨a,x⟩ ⟨b,y⟩ + by_cases h : a=b + · subst b + rw [packetDifferential,Matrix.blockDiagonal'_apply_eq] + exact (scalarCornerMatrix_entries Q (v a) (testPlacement Q p (v a)) (testPlacement Q p (v a)) (fun _ => rfl) (fun _ => rfl) _).2 x y + · rw [packetDifferential,Matrix.blockDiagonal'_apply_ne _ _ _ h,zero_mul] + +omit [Fintype I] [Fintype J] in +lemma packet_degree (p : I → GeneratorPlacement V) (v : J → V) + (M : Matrix I I (Zigzag Q K)) (hM : MapDegree Q p p 1 0 M) : + MapDegree Q (packetPlacement Q p v) (packetPlacement Q p v) 1 0 + (packetDifferential Q p v M) := by + rintro ⟨a,x⟩ ⟨b,y⟩ + by_cases h : a=b + · subst b + rw [packetDifferential,Matrix.blockDiagonal'_apply_eq] + exact testMatrix_degree Q (v a) hM x y + · rw [packetDifferential,Matrix.blockDiagonal'_apply_ne _ _ _ h] + exact ⟨fun _ => rfl,homogeneous_zero Q _⟩ + +namespace BasedComplex + +noncomputable def packetTest (E : BasedComplex Q (K := K) I) (v : J → V) : + BasedComplex Q (K := K) (PacketIndex Q E.placement v) where + placement := packetPlacement Q E.placement v + differential := packetDifferential Q E.placement v E.differential + entries := packet_entries Q E.placement v E.differential + degree := packet_degree Q E.placement v E.differential E.degree + square_zero := by + simp only [packetDifferential,← Matrix.blockDiagonal'_mul] + have h : (fun a => scalarCornerMatrix Q (v a) (testMatrix Q E.placement E.placement (v a) E.differential) * + scalarCornerMatrix Q (v a) (testMatrix Q E.placement E.placement (v a) E.differential)) = 0 := by + funext a + exact (E.testComplex Q (v a)).square_zero + rw [h,Matrix.blockDiagonal'_zero] + +noncomputable def packetEvaluationMatrix (E : BasedComplex Q (K := K) I) (v : J → V) : + Matrix (PacketIndex Q E.placement v) I (Zigzag Q K) := + fun x i => evaluationMatrix Q E.placement (v x.1) x.2 i + +lemma packetEvaluation_commute (E : BasedComplex Q (K := K) I) (v : J → V) : + (E.packetTest Q v).differential * E.packetEvaluationMatrix Q v = + E.packetEvaluationMatrix Q v * E.differential := by + apply Matrix.ext + rintro ⟨a,x⟩ i + change (∑ y, packetDifferential Q E.placement v E.differential ⟨a,x⟩ y * + packetEvaluationMatrix Q E v y i) = _ + rw [Fintype.sum_sigma,Finset.sum_eq_single a] + · simp only [packetDifferential,Matrix.blockDiagonal'_apply_eq,packetEvaluationMatrix] + exact congrFun (congrFun (E.evaluation Q (v a)).commute x) i + · intro b hb hba + apply Finset.sum_eq_zero + intro y hy + rw [packetDifferential,Matrix.blockDiagonal'_apply_ne _ _ _ (Ne.symm hba),zero_mul] + · simp + +noncomputable def packetEvaluation (E : BasedComplex Q (K := K) I) (v : J → V) : + Map Q (E.packetTest Q v) E where + matrix := E.packetEvaluationMatrix Q v + entries := ⟨fun x i => (evaluation_entries Q E.placement (v x.1)).1 x.2 i, + fun x i => (evaluation_entries Q E.placement (v x.1)).2 x.2 i⟩ + degree := fun x i => evaluation_degree Q E.placement (v x.1) x.2 i + commute := E.packetEvaluation_commute Q v + +noncomputable def packetTwist (E : BasedComplex Q (K := K) I) (v : J → V) : + BasedComplex Q (K := K) (PacketIndex Q E.placement v ⊕ I) := + (E.packetEvaluation Q v).cone Q + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/Path.lean b/lean/OAI/Topology/ArtinGroups/Quivers/Path.lean new file mode 100644 index 0000000000000000000000000000000000000000..5fc7f854a421355cebcb7ce63d3c1e8dcbcd8032 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/Path.lean @@ -0,0 +1,194 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.SmulMul + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver + +abbrev Path (V A : Type*) := V ⊕ A ⊕ V + +namespace Path + +variable {V A : Type*} (Q : ReversibleQuiver V A) + +def source : Path V A → V + | .inl v => v + | .inr (.inl a) => Q.source a + | .inr (.inr v) => v + +def target : Path V A → V + | .inl v => v + | .inr (.inl a) => Q.target a + | .inr (.inr v) => v + +def length : Path V A → ℤ + | .inl _ => 0 + | .inr (.inl _) => 1 + | .inr (.inr _) => 2 + +end Path + +namespace Zigzag + +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + +local instance pathModule : Module K (Q.Zigzag K) := + inferInstanceAs (Module K ((V → K) × (A → K) × (V → K))) + +def pathCoordinates : Q.Zigzag K ≃ₗ[K] (Path V A → K) where + toFun x := Sum.elim x.vertex (Sum.elim x.arrow x.token) + invFun f := (fun v => f (.inl v), (fun a => f (.inr (.inl a))), + fun v => f (.inr (.inr v))) + left_inv x := by rfl + right_inv f := by funext p; rcases p with v | a | v <;> rfl + map_add' x y := by funext p; rcases p with v | a | v <;> rfl + map_smul' r x := by funext p; rcases p with v | a | v <;> rfl + +@[simp] lemma pathCoordinates_vertex (x : Q.Zigzag K) (v : V) : + pathCoordinates Q x (.inl v) = x.vertex v := rfl +@[simp] lemma pathCoordinates_arrow (x : Q.Zigzag K) (a : A) : + pathCoordinates Q x (.inr (.inl a)) = x.arrow a := rfl +@[simp] lemma pathCoordinates_token (x : Q.Zigzag K) (v : V) : + pathCoordinates Q x (.inr (.inr v)) = x.token v := rfl + +variable [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +noncomputable def pathBasis : Module.Basis (Path V A) K (Q.Zigzag K) := + Module.Basis.ofEquivFun (pathCoordinates Q) + +omit [DecidableEq A] in +lemma pathBasis_repr (x : Q.Zigzag K) (p : Path V A) : + (pathBasis Q).repr x p = pathCoordinates Q x p := rfl + +lemma pathBasis_coordinates (p q : Path V A) : + pathCoordinates Q (pathBasis Q (K := K) p) q = if p = q then 1 else 0 := by + exact (pathBasis Q).repr_self_apply p q + +omit [DecidableEq A] in +lemma sum_pathBasis (x : Q.Zigzag K) : + ∑ p, pathCoordinates Q x p • pathBasis Q p = x := (pathBasis Q).sum_repr x + +lemma pathBasis_vertex (v : V) : pathBasis Q (K := K) (.inl v) = vertexId Q v := by + apply (pathCoordinates Q).injective + funext p + rw [pathBasis_coordinates] + rcases p with w | a | w + all_goals simp only [pathCoordinates_vertex, pathCoordinates_arrow, pathCoordinates_token] + all_goals simp [vertexId, vertex, arrow, token, Pi.single_apply, eq_comm] + +lemma pathBasis_arrow (a : A) : pathBasis Q (K := K) (.inr (.inl a)) = arrowBasis Q a := by + apply (pathCoordinates Q).injective + funext p + rw [pathBasis_coordinates] + rcases p with w | b | w + all_goals simp only [pathCoordinates_vertex, pathCoordinates_arrow, pathCoordinates_token] + all_goals simp [arrowBasis, vertex, arrow, token, Pi.single_apply, eq_comm] + +lemma pathBasis_token (v : V) : pathBasis Q (K := K) (.inr (.inr v)) = tokenBasis Q v := by + apply (pathCoordinates Q).injective + funext p + rw [pathBasis_coordinates] + rcases p with w | a | w + all_goals simp only [pathCoordinates_vertex, pathCoordinates_arrow, pathCoordinates_token] + all_goals simp [tokenBasis, vertex, arrow, token, Pi.single_apply, eq_comm] + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_vertexId_left (v : V) (x : Q.Zigzag K) (p : Path V A) : + pathCoordinates Q (vertexId Q v * x) p = + if Path.source Q p = v then pathCoordinates Q x p else 0 := by + rcases p with w | a | w + · simp [Path.source, Pi.single_apply] + rfl + · simp [Path.source, leftScale, rightScale, Pi.single_apply] + rfl + · simp [Path.source, Pi.single_apply] + rfl + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_vertexId_right (v : V) (x : Q.Zigzag K) (p : Path V A) : + pathCoordinates Q (x * vertexId Q v) p = + if Path.target Q p = v then pathCoordinates Q x p else 0 := by + rcases p with w | a | w + · simp [Path.target, Pi.single_apply] + rfl + · simp [Path.target, leftScale, rightScale, Pi.single_apply] + rfl + · simp [Path.target, Pi.single_apply] + rfl + +lemma pathBasis_left (p : Path V A) : + vertexId Q (Path.source Q p) * pathBasis Q (K := K) p = pathBasis Q p := by + apply (pathCoordinates Q).injective + funext q + rw [coordinates_vertexId_left, pathBasis_coordinates] + by_cases h : p = q + · subst q + simp + · simp [h] + +lemma pathBasis_right (p : Path V A) : + pathBasis Q (K := K) p * vertexId Q (Path.target Q p) = pathBasis Q p := by + apply (pathCoordinates Q).injective + funext q + rw [coordinates_vertexId_right, pathBasis_coordinates] + by_cases h : p = q + · subst q + simp + · simp [h] + +omit [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] in +lemma coordinates_homogeneous (a : ℤ) (x : Q.Zigzag K) : + Homogeneous Q a x ↔ ∀ p, Path.length p ≠ a → pathCoordinates Q x p = 0 := by + constructor + · intro h p hp + rcases p with v | b | v + · exact congrFun (h.1 (Ne.symm hp)) v + · exact congrFun (h.2.1 (Ne.symm hp)) b + · exact congrFun (h.2.2 (Ne.symm hp)) v + · intro h + constructor + · intro ha + funext v + exact h (.inl v) (Ne.symm ha) + constructor + · intro ha + funext b + exact h (.inr (.inl b)) (Ne.symm ha) + · intro ha + funext v + exact h (.inr (.inr v)) (Ne.symm ha) + +lemma pathBasis_homogeneous (p : Path V A) : + Homogeneous Q (Path.length p) (pathBasis Q (K := K) p) := by + rw [coordinates_homogeneous] + intro q hq + rw [pathBasis_coordinates, ite_eq_right] + intro hp + exact hq (congrArg Path.length hp.symm) + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_corner {s t : V} {x : Q.Zigzag K} + (hl : vertexId Q s * x = x) (hr : x * vertexId Q t = x) + {p : Path V A} (hp : pathCoordinates Q x p ≠ 0) : + Path.source Q p = s ∧ Path.target Q p = t := by + constructor + · by_contra h + have he := congrArg (fun z => pathCoordinates Q z p) hl + rw [coordinates_vertexId_left, ite_eq_right h] at he + exact hp he.symm + · by_contra h + have he := congrArg (fun z => pathCoordinates Q z p) hr + rw [coordinates_vertexId_right, ite_eq_right h] at he + exact hp he.symm + +omit [Fintype V] [DecidableEq A] in +lemma coordinates_mul_degree {a b : ℤ} {x y : Q.Zigzag K} + (hx : Homogeneous Q a x) (hy : Homogeneous Q b y) {p : Path V A} + (hp : pathCoordinates Q (x * y) p ≠ 0) : Path.length p = a + b := by + by_contra h + exact hp ((coordinates_homogeneous Q (a + b) (x * y)).mp (homogeneous_mul Q hx hy) p h) + +end Zigzag +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/PathTwo.lean b/lean/OAI/Topology/ArtinGroups/Quivers/PathTwo.lean new file mode 100644 index 0000000000000000000000000000000000000000..fe52301e9bfcbe5afbc7648fec52a6d85aa18583 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/PathTwo.lean @@ -0,0 +1,146 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.ExtendLayer +import OAI.Topology.ArtinGroups.Quivers.CoefficientMatrix + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype A] [DecidableEq V] + +def pathTwo : Q.Zigzag K →ₗ[K] Q.Zigzag K where + toFun x := (0, 0, x.token) + map_add' _ _ := by + apply ext + · change (0 : V → K) = 0 + 0 + rw [add_zero] + · change (0 : A → K) = 0 + 0 + rw [add_zero] + · rfl + map_smul' r x := by + apply ext + · change (0 : V → K) = r • 0 + rw [smul_zero] + · change (0 : A → K) = r • 0 + rw [smul_zero] + · rfl + +lemma path_decomposition (x : Q.Zigzag K) : + pathZero Q x + pathOne Q x + pathTwo Q x = x := by + apply ext + · change x.vertex + 0 + 0 = x.vertex + simp only [add_zero] + · change (0 : A → K) + x.arrow + 0 = x.arrow + simp only [zero_add, add_zero] + · change (0 : V → K) + 0 + x.token = x.token + simp only [zero_add] + +lemma pathTwo_mul_positive (x : Q.Zigzag K) {y : Q.Zigzag K} (hy : y.vertex = 0) : + pathTwo Q x * y = 0 := tokenOnly_mul_positive Q rfl rfl hy + +lemma positive_mul_pathTwo {x : Q.Zigzag K} (hx : x.vertex = 0) (y : Q.Zigzag K) : + x * pathTwo Q y = 0 := positive_mul_tokenOnly Q hx rfl rfl + +variable {I J L : Type*} + +def matrixTwo : Matrix I J (Q.Zigzag K) →ₗ[K] Matrix I J (Q.Zigzag K) where + toFun f i j := pathTwo Q (f i j) + map_add' f g := by apply Matrix.ext; intro i j; exact map_add _ _ _ + map_smul' r f := by apply Matrix.ext; intro i j; exact (pathTwo Q).map_smul' r (f i j) + +lemma matrix_decomposition (f : Matrix I J (Q.Zigzag K)) : + matrixZero Q f + matrixOne Q f + matrixTwo Q f = f := by + apply Matrix.ext + intro i j + exact path_decomposition Q (f i j) + +lemma positive_matrix_decomposition {f : Matrix I J (Q.Zigzag K)} (hf : PositiveMatrix Q f) : + matrixOne Q f + matrixTwo Q f = f := by + have h := matrix_decomposition Q f + rw [matrixZero_eq_zero Q hf, zero_add] at h + exact h + +lemma matrixTwo_mul_positive [Fintype J] + (f : Matrix I J (Q.Zigzag K)) {g : Matrix J L (Q.Zigzag K)} + (hg : PositiveMatrix Q g) : matrixTwo Q f * g = 0 := by + apply Matrix.ext + intro i j + rw [Matrix.mul_apply] + exact Finset.sum_eq_zero fun t _ => pathTwo_mul_positive Q _ (hg t j) + +lemma positive_mul_matrixTwo [Fintype J] + {f : Matrix I J (Q.Zigzag K)} (hf : PositiveMatrix Q f) + (g : Matrix J L (Q.Zigzag K)) : f * matrixTwo Q g = 0 := by + apply Matrix.ext + intro i j + rw [Matrix.mul_apply] + exact Finset.sum_eq_zero fun t _ => positive_mul_pathTwo Q (hf i t) _ + +namespace BasedComplex +variable [Fintype I] [Fintype J] + +noncomputable def linearHomDifferential (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (n : ℤ) : + Matrix I J (Q.Zigzag K) →ₗ[K] Matrix I J (Q.Zigzag K) where + toFun f := matrixOne Q E.differential * f - + cochainSign (K := K) n • (f * matrixOne Q F.differential) + map_add' f g := by + simp only [Matrix.mul_add, Matrix.add_mul, smul_add] + abel + map_smul' r f := by + simp only [Matrix.mul_smul, Matrix.smul_mul, smul_sub, RingHom.id_apply] + rw [smul_comm] + +noncomputable def tokenHomDifferential (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (n : ℤ) : + Matrix I J (Q.Zigzag K) →ₗ[K] Matrix I J (Q.Zigzag K) := + homDifferential Q E F n - linearHomDifferential Q E F n + +lemma tokenHomDifferential_apply (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n : ℤ) (f : Matrix I J (Q.Zigzag K)) : + tokenHomDifferential Q E F n f = matrixTwo Q E.differential * f - + cochainSign (K := K) n • (f * matrixTwo Q F.differential) := by + change (E.differential * f - cochainSign (K := K) n • (f * F.differential)) - + (matrixOne Q E.differential * f - cochainSign (K := K) n • (f * matrixOne Q F.differential)) = _ + conv_lhs => + arg 1 + rw [← positive_matrix_decomposition Q hE, ← positive_matrix_decomposition Q hF] + simp only [Matrix.add_mul, Matrix.mul_add, smul_add] + abel + +lemma tokenHomDifferential_positive (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n : ℤ) {f : Matrix I J (Q.Zigzag K)} (hf : PositiveMatrix Q f) : + tokenHomDifferential Q E F n f = 0 := by + rw [tokenHomDifferential_apply Q E F hE hF, + matrixTwo_mul_positive Q _ hf, positive_mul_matrixTwo Q hf, smul_zero, sub_zero] + +lemma homDifferential_eq_linear_add_token (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (n : ℤ) (f : Matrix I J (Q.Zigzag K)) : + homDifferential Q E F n f = + linearHomDifferential Q E F n f + tokenHomDifferential Q E F n f := by + change homDifferential Q E F n f = linearHomDifferential Q E F n f + + (homDifferential Q E F n f - linearHomDifferential Q E F n f) + abel + +lemma secondary_kernel_zero [Fintype V] + (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) + (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) (n v : ℤ) + (hd : homDimension Q E F n v = 0) + {f g : Matrix I J (Q.Zigzag K)} + (hf : f ∈ homSpace Q E F n v) (hg : g ∈ homSpace Q E F n v) + (h₀ : CoefficientMatrix Q f) (h₁ : LinearMatrix Q g) + (hcycle : linearHomDifferential Q E F n f = 0) + (hboundary : tokenHomDifferential Q E F n f = linearHomDifferential Q E F n g) : + f = 0 := by + apply coefficient_eq_zero_of_same_differential Q E F hE hF n v hd hf hg h₀ h₁ + rw [homDifferential_eq_linear_add_token Q E F n f, + homDifferential_eq_linear_add_token Q E F n g, + hcycle, zero_add, hboundary, + tokenHomDifferential_positive Q E F hE hF n (fun i j => (h₁ i j).1), add_zero] + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/PathTwoSelf.lean b/lean/OAI/Topology/ArtinGroups/Quivers/PathTwoSelf.lean new file mode 100644 index 0000000000000000000000000000000000000000..b0729ee0999fc6d6d0dda38f2164ca78a50fc4e6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/PathTwoSelf.lean @@ -0,0 +1,126 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.PathTwo + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype A] [DecidableEq V] + +lemma pathTwo_eq_self {x : Q.Zigzag K} (h₀ : x.vertex = 0) (h₁ : x.arrow = 0) : + pathTwo Q x = x := by + apply ext + · exact h₀.symm + · exact h₁.symm + · rfl + +lemma pathTwo_eq_zero {x : Q.Zigzag K} (h : x.token = 0) : pathTwo Q x = 0 := by + apply ext + · rfl + · rfl + · exact h + +lemma pathTwo_mul_linear_left {x : Q.Zigzag K} (h₀ : x.vertex = 0) (h₂ : x.token = 0) + (y : Q.Zigzag K) : pathTwo Q (x * y) = x * pathOne Q y := by + apply ext + · change (0 : V → K) = (x * pathOne Q y).vertex + rw [vertex_mul, h₀, MulZeroClass.zero_mul] + · change (0 : A → K) = (x * pathOne Q y).arrow + rw [arrow_mul, h₀] + ext a + change (0 : K) = 0 * y.arrow a + x.arrow a * 0 + simp only [MulZeroClass.mul_zero, MulZeroClass.zero_mul, zero_add] + · change (x * y).token = (x * pathOne Q y).token + rw [token_mul, token_mul, h₀, h₂] + simp only [MulZeroClass.zero_mul, zero_add] + rfl + +lemma pathTwo_mul_linear_right (x : Q.Zigzag K) {y : Q.Zigzag K} + (h₀ : y.vertex = 0) (h₂ : y.token = 0) : pathTwo Q (x * y) = pathOne Q x * y := by + apply ext + · change (0 : V → K) = (pathOne Q x * y).vertex + rw [vertex_mul, h₀, MulZeroClass.mul_zero] + · change (0 : A → K) = (pathOne Q x * y).arrow + rw [arrow_mul, h₀] + ext a + change (0 : K) = 0 * y.arrow a + x.arrow a * 0 + simp only [MulZeroClass.mul_zero, MulZeroClass.zero_mul, zero_add] + · change (x * y).token = (pathOne Q x * y).token + rw [token_mul, token_mul, h₀, h₂] + simp only [MulZeroClass.mul_zero, zero_add] + rfl + +variable {I J L : Type*} + +lemma matrixOne_entries {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} + {f : Matrix I J (Q.Zigzag K)} (hf : ProjectiveEntries Q p q f) : + ProjectiveEntries Q p q (matrixOne Q f) := by + constructor + · intro i j + have h := congrArg (pathOne Q) (hf.1 i j) + rw [pathOne_mul, pathZero_vertexId, pathOne_vertexId, + MulZeroClass.zero_mul, add_zero] at h + exact h + · intro i j + have h := congrArg (pathOne Q) (hf.2 i j) + rw [pathOne_mul, pathZero_vertexId, pathOne_vertexId, + MulZeroClass.mul_zero, zero_add] at h + exact h + +lemma matrixOne_degree {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} + {n v : ℤ} {f : Matrix I J (Q.Zigzag K)} (hf : MapDegree Q p q n v f) : + MapDegree Q p q n v (matrixOne Q f) := by + intro i j + constructor + · intro h + change pathOne Q (f i j) = 0 + rw [(hf i j).1 h, map_zero] + · exact ⟨fun _ => rfl, (hf i j).2.2.1, fun _ => rfl⟩ + +lemma matrixTwo_mul_linear_left [Fintype J] + {f : Matrix I J (Q.Zigzag K)} (hf : LinearMatrix Q f) + (g : Matrix J L (Q.Zigzag K)) : + matrixTwo Q (f * g) = f * matrixOne Q g := by + apply Matrix.ext + intro i k + change pathTwo Q (∑ j, f i j * g j k) = ∑ j, f i j * pathOne Q (g j k) + rw [map_sum] + exact Finset.sum_congr rfl fun j _ => pathTwo_mul_linear_left Q (hf i j).1 (hf i j).2 _ + +lemma matrixTwo_mul_linear_right [Fintype J] + (f : Matrix I J (Q.Zigzag K)) {g : Matrix J L (Q.Zigzag K)} (hg : LinearMatrix Q g) : + matrixTwo Q (f * g) = matrixOne Q f * g := by + apply Matrix.ext + intro i k + change pathTwo Q (∑ j, f i j * g j k) = ∑ j, pathOne Q (f i j) * g j k + rw [map_sum] + exact Finset.sum_congr rfl fun j _ => pathTwo_mul_linear_right Q _ (hg j k).1 (hg j k).2 + +namespace BasedComplex +variable [Fintype I] [Fintype J] + +lemma token_boundary_primitive (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : LinearMatrix Q E.differential) + (hF : LinearMatrix Q F.differential) (n v : ℤ) + {f : Matrix I J (Q.Zigzag K)} + (h₂ : ∀ i j, (f i j).vertex = 0 ∧ (f i j).arrow = 0) + (hf : f ∈ homBoundaries Q E F n v) : + ∃ g ∈ homSpace Q E F (n-1) v, LinearMatrix Q g ∧ + homDifferential Q E F (n-1) g = f := by + obtain ⟨g, hg, rfl⟩ := hf + refine ⟨matrixOne Q g, ⟨matrixOne_entries Q hg.1, matrixOne_degree Q hg.2⟩, + fun _ _ => ⟨rfl, rfl⟩, ?_⟩ + have hfix : matrixTwo Q (homDifferential Q E F (n-1) g) = homDifferential Q E F (n-1) g := by + apply Matrix.ext + intro i j + exact pathTwo_eq_self Q (h₂ i j).1 (h₂ i j).2 + rw [← hfix] + change E.differential * matrixOne Q g - + cochainSign (K := K) (n-1) • (matrixOne Q g * F.differential) = + matrixTwo Q (E.differential * g - cochainSign (K := K) (n-1) • (g * F.differential)) + rw [map_sub, map_smul, matrixTwo_mul_linear_left Q hE, matrixTwo_mul_linear_right Q _ hF] + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/PathZero.lean b/lean/OAI/Topology/ArtinGroups/Quivers/PathZero.lean new file mode 100644 index 0000000000000000000000000000000000000000..6e18a546fee37cc86445f2ea78483e3dab244a7f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/PathZero.lean @@ -0,0 +1,197 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.LinearMatrix + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype A] [DecidableEq V] + +def pathZero : Q.Zigzag K →ₗ[K] Q.Zigzag K where + toFun x := (x.vertex, 0, 0) + map_add' x y := by + apply ext + · rfl + · change (0 : A → K) = 0 + 0 + rw [add_zero] + · change (0 : V → K) = 0 + 0 + rw [add_zero] + map_smul' r x := by + apply ext + · rfl + · change (0 : A → K) = r • 0 + rw [smul_zero] + · change (0 : V → K) = r • 0 + rw [smul_zero] + +def pathOne : Q.Zigzag K →ₗ[K] Q.Zigzag K where + toFun x := (0, x.arrow, 0) + map_add' x y := by + apply ext + · change (0 : V → K) = 0 + 0 + rw [add_zero] + · rfl + · change (0 : V → K) = 0 + 0 + rw [add_zero] + map_smul' r x := by + apply ext + · change (0 : V → K) = r • 0 + rw [smul_zero] + · rfl + · change (0 : V → K) = r • 0 + rw [smul_zero] + +lemma pathZero_mul (x y : Q.Zigzag K) : + pathZero Q (x * y) = pathZero Q x * pathZero Q y := by + apply ext + · change (x * y).vertex = (pathZero Q x * pathZero Q y).vertex + rw [vertex_mul, vertex_mul] + rfl + · change (0 : A → K) = (pathZero Q x * pathZero Q y).arrow + rw [arrow_mul] + change (0 : A → K) = Q.leftScale x.vertex 0 + Q.rightScale 0 y.vertex + ext a + simp [leftScale, rightScale] + · change (0 : V → K) = (pathZero Q x * pathZero Q y).token + rw [token_mul] + change (0 : V → K) = x.vertex * 0 + 0 * y.vertex + Q.backtrack 0 0 + simp + +lemma pathOne_mul (x y : Q.Zigzag K) : + pathOne Q (x * y) = pathZero Q x * pathOne Q y + pathOne Q x * pathZero Q y := by + apply ext + · change (0 : V → K) = (pathZero Q x * pathOne Q y).vertex + + (pathOne Q x * pathZero Q y).vertex + rw [vertex_mul, vertex_mul] + change (0 : V → K) = x.vertex * 0 + 0 * y.vertex + simp + · change (x * y).arrow = (pathZero Q x * pathOne Q y).arrow + + (pathOne Q x * pathZero Q y).arrow + rw [arrow_mul, arrow_mul, arrow_mul] + change Q.leftScale x.vertex y.arrow + Q.rightScale x.arrow y.vertex = + (Q.leftScale x.vertex y.arrow + Q.rightScale 0 0) + + (Q.leftScale 0 0 + Q.rightScale x.arrow y.vertex) + ext a + simp [leftScale, rightScale] + · change (0 : V → K) = (pathZero Q x * pathOne Q y).token + + (pathOne Q x * pathZero Q y).token + rw [token_mul, token_mul] + change (0 : V → K) = (x.vertex * 0 + 0 * 0 + Q.backtrack 0 y.arrow) + + (0 * 0 + 0 * y.vertex + Q.backtrack x.arrow 0) + simp + +lemma pathZero_vertexId (α : V) : pathZero Q (vertexId Q (K := K) α) = vertexId Q α := rfl +lemma pathOne_vertexId (α : V) : pathOne Q (vertexId Q (K := K) α) = 0 := rfl + +lemma pathZero_eq_zero {x : Q.Zigzag K} (h : x.vertex = 0) : pathZero Q x = 0 := by + apply ext + · exact h + · rfl + · rfl + +lemma pathOne_eq_self {x : Q.Zigzag K} (h₀ : x.vertex = 0) (h₂ : x.token = 0) : + pathOne Q x = x := by + apply ext + · exact h₀.symm + · rfl + · exact h₂.symm + +variable {I J L : Type*} + +def matrixZero : Matrix I J (Q.Zigzag K) →ₗ[K] Matrix I J (Q.Zigzag K) where + toFun f i j := pathZero Q (f i j) + map_add' f g := by apply Matrix.ext; intro i j; exact map_add _ _ _ + map_smul' r f := by apply Matrix.ext; intro i j; exact (pathZero Q).map_smul' r (f i j) + +def matrixOne : Matrix I J (Q.Zigzag K) →ₗ[K] Matrix I J (Q.Zigzag K) where + toFun f i j := pathOne Q (f i j) + map_add' f g := by apply Matrix.ext; intro i j; exact map_add _ _ _ + map_smul' r f := by apply Matrix.ext; intro i j; exact (pathOne Q).map_smul' r (f i j) + +lemma matrixZero_eq_zero {f : Matrix I J (Q.Zigzag K)} (hf : PositiveMatrix Q f) : + matrixZero Q f = 0 := by + apply Matrix.ext + intro i j + exact pathZero_eq_zero Q (hf i j) + +lemma matrixOne_eq_self {f : Matrix I J (Q.Zigzag K)} (hf : LinearMatrix Q f) : + matrixOne Q f = f := by + apply Matrix.ext + intro i j + exact pathOne_eq_self Q (hf i j).1 (hf i j).2 + +lemma matrixZero_mul [Fintype J] (f : Matrix I J (Q.Zigzag K)) + (g : Matrix J L (Q.Zigzag K)) : + matrixZero Q (f * g) = matrixZero Q f * matrixZero Q g := by + apply Matrix.ext + intro i k + change pathZero Q (∑ j, f i j * g j k) = ∑ j, pathZero Q (f i j) * pathZero Q (g j k) + rw [map_sum] + exact Finset.sum_congr rfl fun j _ => pathZero_mul Q _ _ + +lemma matrixOne_mul [Fintype J] (f : Matrix I J (Q.Zigzag K)) + (g : Matrix J L (Q.Zigzag K)) : + matrixOne Q (f * g) = matrixZero Q f * matrixOne Q g + matrixOne Q f * matrixZero Q g := by + apply Matrix.ext + intro i k + change pathOne Q (∑ j, f i j * g j k) = + (∑ j, pathZero Q (f i j) * pathOne Q (g j k)) + + ∑ j, pathOne Q (f i j) * pathZero Q (g j k) + rw [map_sum, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun j _ => pathOne_mul Q _ _ + +lemma matrixZero_entries {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} + {f : Matrix I J (Q.Zigzag K)} (hf : ProjectiveEntries Q p q f) : + ProjectiveEntries Q p q (matrixZero Q f) := by + constructor + · intro i j + have h := congrArg (pathZero Q) (hf.1 i j) + rw [pathZero_mul, pathZero_vertexId] at h + exact h + · intro i j + have h := congrArg (pathZero Q) (hf.2 i j) + rw [pathZero_mul, pathZero_vertexId] at h + exact h + +lemma matrixZero_degree {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} + {n v : ℤ} {f : Matrix I J (Q.Zigzag K)} (hf : MapDegree Q p q n v f) : + MapDegree Q p q n v (matrixZero Q f) := by + intro i j + constructor + · intro h + change pathZero Q (f i j) = 0 + rw [(hf i j).1 h, map_zero] + · exact ⟨(hf i j).2.1, fun _ => rfl, fun _ => rfl⟩ + +namespace BasedComplex +variable [Fintype I] [Fintype J] + +lemma matrixOne_homDifferential (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n : ℤ) (g : Matrix I J (Q.Zigzag K)) : + matrixOne Q (homDifferential Q E F n g) = + matrixOne Q E.differential * matrixZero Q g - + cochainSign (K := K) n • (matrixZero Q g * matrixOne Q F.differential) := by + change matrixOne Q (E.differential * g - cochainSign (K := K) n • (g * F.differential)) = _ + rw [map_sub, map_smul, matrixOne_mul, matrixOne_mul, + matrixZero_eq_zero Q hE, matrixZero_eq_zero Q hF, Matrix.zero_mul, Matrix.mul_zero, + zero_add, add_zero] + +lemma linear_boundary_primitive (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n v : ℤ) {f : Matrix I J (Q.Zigzag K)} (hlin : LinearMatrix Q f) + (hf : f ∈ homBoundaries Q E F n v) : + ∃ g ∈ homSpace Q E F (n - 1) v, + (∀ i j, (g i j).arrow = 0 ∧ (g i j).token = 0) ∧ + matrixOne Q E.differential * g - cochainSign (K := K) (n - 1) • + (g * matrixOne Q F.differential) = f := by + obtain ⟨g, hg, rfl⟩ := hf + refine ⟨matrixZero Q g, ⟨matrixZero_entries Q hg.1, matrixZero_degree Q hg.2⟩, + fun _ _ => ⟨rfl, rfl⟩, ?_⟩ + rw [← matrixOne_homDifferential Q E F hE hF] + exact matrixOne_eq_self Q hlin + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ProbeCartanCore.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeCartanCore.lean new file mode 100644 index 0000000000000000000000000000000000000000..147a8e2fc686773f6ba4068cd49320c3e2a79cbb --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeCartanCore.lean @@ -0,0 +1,84 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.GeneratorVector +import OAI.Topology.ArtinGroups.Quivers.ProbeVertex + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver +open Zigzag Zigzag.BasedComplex Matrix + +variable {V A:Type*} (Q:ReversibleQuiver V A) [Fintype V] +attribute [local instance] Classical.decEq Classical.propDecidable +local notation "R" => probeQuiver Q + +omit [Fintype V] in +lemma probeCartan_core (α β:V) : unfoldedCartan R (.inl α) (.inl β)=unfoldedCartan Q α β := by + unfold unfoldedCartan + simp only [Sum.inl.injEq] + congr 2 + apply Nat.card_congr + refine { + toFun:=?_ + invFun:=fun a=>⟨.inl a.val,congrArg Sum.inl a.property.1,congrArg Sum.inl a.property.2⟩ + left_inv:=?_ + right_inv:=?_ } + · rintro ⟨a,ha⟩ + cases a with + | inl a=>exact ⟨a,Sum.inl.inj ha.1,Sum.inl.inj ha.2⟩ + | inr p=> + rcases p with ⟨v,b,c⟩ + cases c + · exact False.elim (Sum.inr_ne_inl ha.2) + · exact False.elim (Sum.inr_ne_inl ha.1) + · rintro ⟨a,ha⟩ + cases a with + | inl a=>rfl + | inr p=> + rcases p with ⟨v,b,c⟩ + cases c + · exact False.elim (Sum.inr_ne_inl ha.2) + · exact False.elim (Sum.inr_ne_inl ha.1) + · intro a; rfl + +omit [Fintype V] in +lemma probeCartan_leaf_core (α β:V) (b:Bool) : + unfoldedCartan R (.inr (α,b)) (.inl β)=if α=β then -1 else 0 := by + unfold unfoldedCartan + simp only [Sum.inr_ne_inl,ite_false,zero_sub] + have he : {a:ProbeArrow V A // (probeQuiver Q).source a=.inr (α,b) ∧ (probeQuiver Q).target a=.inl β} ≃ + {u:Unit // α=β} := { + toFun:=fun a=>⟨(),by + have hs:=(probe_source_iff Q α b a.val).mp a.property.1 + have ht:=a.property.2 + rw [hs] at ht + exact Sum.inl.inj ht⟩ + invFun:=fun a=>⟨.inr (α,b,true),rfl,congrArg Sum.inl a.property⟩ + left_inv:=by intro a; apply Subtype.ext; exact ((probe_source_iff Q α b a.val).mp a.property.1).symm + right_inv:=by intro a; apply Subtype.ext; exact Subsingleton.elim _ _ } + rw [Nat.card_congr he] + by_cases h:α=β + · simp [h] + · simp [h] + +lemma probeCartan_mul_core (p:V→ℝ) (α:V) : + (unfoldedCartan R *ᵥ Sum.elim p (fun _=>0)) (.inl α)=(unfoldedCartan Q *ᵥ p) α := by + simp only [mulVec,dotProduct,Fintype.sum_sum_type,Sum.elim_inl,Sum.elim_inr, + MulZeroClass.mul_zero,Finset.sum_const_zero,add_zero,probeCartan_core] + +lemma probeCartan_mul_leaf (p:V→ℝ) (α:V) (b:Bool) : + (unfoldedCartan R *ᵥ Sum.elim p (fun _=>0)) (.inr (α,b))= -p α := by + simp only [mulVec,dotProduct,Fintype.sum_sum_type,Sum.elim_inl,Sum.elim_inr, + MulZeroClass.mul_zero,Finset.sum_const_zero,add_zero,probeCartan_leaf_core] + simp + +lemma probeCartan_pairing (n:ProbeVertex V→ℝ) (p:V→ℝ) : + n ⬝ᵥ (unfoldedCartan R *ᵥ Sum.elim p (fun _=>0))= + (fun α=>n (.inl α)) ⬝ᵥ (unfoldedCartan Q *ᵥ p)- + ∑ α,∑ b:Bool,n (.inr (α,b))*p α := by + simp only [dotProduct,Fintype.sum_sum_type,probeCartan_mul_core] + conv_lhs => rhs; arg 2; ext a; rw [probeCartan_mul_leaf] + simp only [mul_neg,Finset.sum_neg_distrib,Fintype.sum_prod_type,sub_eq_add_neg] + +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ProbeLeaf.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeLeaf.lean new file mode 100644 index 0000000000000000000000000000000000000000..14c25b0464abfc5f8f468d05776cc68545e22ee6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeLeaf.lean @@ -0,0 +1,97 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.GeneratorArray2 +import OAI.Topology.ArtinGroups.Complexes.Initial +import OAI.Topology.ArtinGroups.Quivers.ProbeVertex + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver +variable {V A:Type} (Q:ReversibleQuiver V A) + +lemma probe_source_leaf {a:ProbeArrow V A} {α:V} {b:Bool} + (h:(probeQuiver Q).source a=.inr (α,b)) : (probeQuiver Q).target a=.inl α := by + rcases a with a|⟨v,c,d⟩ + · exact (Sum.inl_ne_inr h).elim + · cases d + · exact (Sum.inl_ne_inr h).elim + · have he:(v,c)=(α,b):=Sum.inr.inj h + cases he + rfl + +lemma probe_target_leaf {a:ProbeArrow V A} {α:V} {b:Bool} + (h:(probeQuiver Q).target a=.inr (α,b)) : (probeQuiver Q).source a=.inl α := by + have hh:=probe_source_leaf Q (a:=(probeQuiver Q).reverse a) (by rw [source_reverse]; exact h) + rwa [target_reverse] at hh + +namespace Zigzag.BasedComplex +variable {K I:Type*} [Field K] [Fintype V] [Fintype A] [Fintype I] +attribute [local instance] Classical.decEq Classical.propDecidable +local notation "R" => probeQuiver Q + +lemma probe_differential_row_zero (E:BasedComplex R (K:=K) I) (α:V) (b:Bool) + (hc:∀j,(E.placement j).color≠.inl α) + (hf:∀j,(E.placement j).color=.inr (α,b)→(E.placement j).cochain=0) + (i:I) (hi:(E.placement i).color=.inr (α,b)) (j:I) : E.differential i j=0 := by + apply (pathCoordinates R).injective + funext p + rw [coordinates_zero] + by_contra hp + have hs:=coordinates_corner R (E.entries.1 i j) (E.entries.2 i j) hp + have hdeg:(E.placement j).cochain=(E.placement i).cochain+1 := by + by_contra h + exact hp (by rw [(E.degree i j).1 h,coordinates_zero]) + rcases p with v|a|v + · have hj:(E.placement j).color=.inr (α,b):=hs.2.symm.trans (hs.1.trans hi) + have hh:=hf j hj + have hh':=hf i hi + omega + · have hh:=probe_source_leaf Q (hs.1.trans hi) + exact hc j (hs.2.symm.trans hh) + · have hj:(E.placement j).color=.inr (α,b):=hs.2.symm.trans (hs.1.trans hi) + have hh:=hf j hj + have hh':=hf i hi + omega + +lemma probe_differential_col_zero (E:BasedComplex R (K:=K) I) (α:V) (b:Bool) + (hc:∀j,(E.placement j).color≠.inl α) + (hf:∀j,(E.placement j).color=.inr (α,b)→(E.placement j).cochain=0) + (i:I) (hi:(E.placement i).color=.inr (α,b)) (j:I) : E.differential j i=0 := by + apply (pathCoordinates R).injective + funext p + rw [coordinates_zero] + by_contra hp + have hs:=coordinates_corner R (E.entries.1 j i) (E.entries.2 j i) hp + have hdeg:(E.placement i).cochain=(E.placement j).cochain+1 := by + by_contra h + exact hp (by rw [(E.degree j i).1 h,coordinates_zero]) + rcases p with v|a|v + · have hj:(E.placement j).color=.inr (α,b):=hs.1.symm.trans (hs.2.trans hi) + have hh:=hf j hj + have hh':=hf i hi + omega + · have hh:=probe_target_leaf Q (hs.2.trans hi) + exact hc j (hs.1.symm.trans hh) + · have hj:(E.placement j).color=.inr (α,b):=hs.1.symm.trans (hs.2.trans hi) + have hh:=hf j hj + have hh':=hf i hi + omega + +lemma classGeneratorArray_initial (α:ProbeVertex V) (p:GeneratorPlacement (ProbeVertex V)) : + classGeneratorArray R (initialClass R (K:=K) α) p=if p=⟨α,0,0⟩ then 1 else 0 := by + rw [initialClass,classGeneratorArray_of_minimal R _ (show (initialProjective R α).IsMinimal R from + fun i j=>rfl)] + change (initialProjective R α).generatorArray R p=_ + rw [generatorArray] + simp only [initialProjective,Finset.univ_unique,Finset.sum_singleton,Finsupp.single_apply,eq_comm] + +lemma generatorArray_placement_pos (E:BasedComplex R (K:=K) I) (i:I) : + 0 probeQuiver Q +variable [DecidableEq (ProbeVertex V)] [DecidableEq (ProbeArrow V A)] + +omit [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + [DecidableEq (ProbeVertex V)] [DecidableEq (ProbeArrow V A)] in +lemma probe_orthogonal {α β:V} (h:OrthogonalVertices Q α β) : + OrthogonalVertices R (.inl α) (.inl β) := by + refine ⟨fun hh=>h.1 (Sum.inl.inj hh),?_⟩ + rintro (a|⟨v,b,dir⟩) hs ht + · exact h.2 a (Sum.inl.inj hs) (Sum.inl.inj ht) + · cases dir <;> simp [probeQuiver] at hs ht + +def probe_simpleEdge {α β:V} (e:SimpleEdge Q α β) : + SimpleEdge R (.inl α) (.inl β) where + arrow:=.inl e.arrow + source:=congrArg Sum.inl e.source + target:=congrArg Sum.inl e.target + distinct:=fun h=>e.distinct (Sum.inl.inj h) + unique:=by + rintro (a|⟨v,b,dir⟩) hs ht + · exact congrArg Sum.inl (e.unique a (Sum.inl.inj hs) (Sum.inl.inj ht)) + · cases dir <;> simp [probeQuiver] at hs ht + +variable (hn:∀a,Q.source a≠Q.target a) +omit [DecidableEq A] in +lemma probe_core_braid (α β:V) : + ((altList α β (ordinaryCoxeterMatrix Q α β)).map + (fun v=>classTwistPerm R (K:=K) (probeQuiver_no_loops Q hn) (.inl v))).prod= + ((altList β α (ordinaryCoxeterMatrix Q α β)).map + (fun v=>classTwistPerm R (K:=K) (probeQuiver_no_loops Q hn) (.inl v))).prod := by + by_cases he:α=β + · subst β; rfl + by_cases ho:OrthogonalVertices Q α β + · rw [ordinaryCoxeterMatrix_orthogonal Q ho] + simpa only [altList_succ,altList_zero,List.map_cons,List.map_nil,List.prod_cons,List.prod_nil, + _root_.mul_one] using classTwistPerm_orthogonal R (K:=K) + (probeQuiver_no_loops Q hn) (probe_orthogonal Q ho) + by_cases ha:Nonempty (SimpleEdge Q α β) + · obtain ⟨e⟩:=ha + rw [ordinaryCoxeterMatrix_adjacent Q e] + simpa only [altList_succ,altList_zero,List.map_cons,List.map_nil,List.prod_cons,List.prod_nil, + _root_.mul_one,_root_.mul_assoc] using classTwistPerm_adjacent R (K:=K) + (probeQuiver_no_loops Q hn) (probe_simpleEdge Q e) + · have hz:ordinaryCoxeterMatrix Q α β=0:=by simp [ordinaryCoxeterMatrix,he,ho,ha] + rw [hz]; rfl +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ProbeSwapIso.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeSwapIso.lean new file mode 100644 index 0000000000000000000000000000000000000000..20fb7ebfe0c63a6aee8f9581e2e4faeeca88951f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeSwapIso.lean @@ -0,0 +1,157 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.MinimalModel +import OAI.Topology.ArtinGroups.Functors.ComplexInitial +import OAI.Topology.ArtinGroups.Functors.ComplexPureLayer +import OAI.Topology.ArtinGroups.Harmonic.FinsuppMapDomainFiber +import OAI.Topology.ArtinGroups.Complexes.PacketPermExterior +import OAI.Topology.ArtinGroups.Quivers.ProbeVertex + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver +variable {V A:Type} (Q:ReversibleQuiver V A) +attribute [local instance] Classical.decEq Classical.propDecidable + +def probeSwapIso : Iso (probeQuiver Q) (probeQuiver Q) where + vertex := + { toFun := Sum.map id (fun p => (p.1,!p.2)) + invFun := Sum.map id (fun p => (p.1,!p.2)) + left_inv := by rintro (v|⟨v,b⟩) <;> simp + right_inv := by rintro (v|⟨v,b⟩) <;> simp } + arrow := + { toFun := Sum.map id (fun p => (p.1,!p.2.1,p.2.2)) + invFun := Sum.map id (fun p => (p.1,!p.2.1,p.2.2)) + left_inv := by rintro (a|⟨v,b,d⟩) <;> simp + right_inv := by rintro (a|⟨v,b,d⟩) <;> simp } + source := by + rintro (a|⟨v,b,d⟩) + · rfl + · cases d <;> rfl + target := by + rintro (a|⟨v,b,d⟩) + · rfl + · cases d <;> rfl + reverse := by + rintro (a|⟨v,b,d⟩) <;> rfl + +namespace Zigzag.BasedComplex +variable {K:Type*} [Field K] [Fintype V] [Fintype A] +local notation "R" => probeQuiver Q +variable (hn:∀a,Q.source a≠Q.target a) +local notation "hnR" => probeQuiver_no_loops Q hn + +noncomputable def probeSignedPerm (a:V×Bool) : Equiv.Perm (FiniteHomotopyClass R (K:=K)) := + if a.2 then classTwistPerm R hnR (.inl a.1) else (classTwistPerm R hnR (.inl a.1)).symm + +noncomputable def probeWordPerm : List (V×Bool) → Equiv.Perm (FiniteHomotopyClass R (K:=K)) + | [] => 1 + | a::w => probeSignedPerm Q hn a * probeWordPerm w + +noncomputable def probeOrbit (w:List (V×Bool)) (α:V) (b:Bool) : FiniteHomotopyClass R (K:=K) := + probeWordPerm Q hn w (initialClass R (.inr (α,b))) + +lemma probeSignedPerm_homDimension (a:V×Bool) (x y:FiniteHomotopyClass R (K:=K)) (n v:ℤ) : + classHomDimension R n v (probeSignedPerm Q hn a x) (probeSignedPerm Q hn a y)= + classHomDimension R n v x y := by + unfold probeSignedPerm + split_ifs + · exact classPositiveTwist_homDimension R hnR _ n v x y + · exact classNegativeTwist_homDimension R hnR _ n v x y + +lemma probeWordPerm_homDimension (w:List (V×Bool)) (x y:FiniteHomotopyClass R (K:=K)) (n v:ℤ) : + classHomDimension R n v (probeWordPerm Q hn w x) (probeWordPerm Q hn w y)= + classHomDimension R n v x y := by + induction w with + | nil => rfl + | cons a w ih => + change classHomDimension R n v (probeSignedPerm Q hn a _) (probeSignedPerm Q hn a _)=_ + rw [probeSignedPerm_homDimension,ih] + +lemma probeSignedPerm_exterior (a:V×Bool) (x:FiniteHomotopyClass R (K:=K)) + (p:GeneratorPlacement (ProbeVertex V)) (v:V) (b:Bool) (hp:p.color=.inr (v,b)) : + classGeneratorArray R (probeSignedPerm Q hn a x) p=classGeneratorArray R x p := by + have h:Sum.inl a.1≠p.color:=by rw [hp]; exact Sum.inl_ne_inr + unfold probeSignedPerm + split_ifs + · exact classPositiveTwist_exterior R x _ p h + · exact classNegativeTwist_exterior R x _ p h + +lemma probeWordPerm_exterior (w:List (V×Bool)) (x:FiniteHomotopyClass R (K:=K)) + (p:GeneratorPlacement (ProbeVertex V)) (v:V) (b:Bool) (hp:p.color=.inr (v,b)) : + classGeneratorArray R (probeWordPerm Q hn w x) p=classGeneratorArray R x p := by + induction w with + | nil => rfl + | cons a w ih => + change classGeneratorArray R (probeSignedPerm Q hn a _) p=_ + rw [probeSignedPerm_exterior Q hn a _ p v b hp,ih] + +lemma probeWordPerm_exterior_level (w:List (V×Bool)) (x:FiniteHomotopyClass R (K:=K)) + (v:V) (b:Bool) (d:ℤ) : + classLevelArray R (probeWordPerm Q hn w x) (.inr (v,b),d)=classLevelArray R x (.inr (v,b),d) := by + apply finsupp_mapDomain_fiber + intro p hp + exact probeWordPerm_exterior Q hn w x p v b (congrArg Prod.fst hp) + +lemma probeOrbit_exterior (w:List (V×Bool)) (α β:V) (b c:Bool) (d:ℤ) : + classLevelArray R (probeOrbit Q (K:=K) hn w α b) (.inr (β,c),d)= + if α=β ∧ b=c ∧ d=0 then 1 else 0 := by + rw [probeOrbit,probeWordPerm_exterior_level,classLevelArray_initial] + simp only [Sum.inr.injEq,Prod.mk.injEq,and_assoc] + +lemma probeOrbit_absent (w:List (V×Bool)) (α β:V) (b c:Bool) (hbc:b≠c) : + ∀i,((minimalClassModel R (probeOrbit Q (K:=K) hn w α b)).complex.placement i).color≠.inr (β,c) := by + intro i hi + let E:=minimalClassModel R (probeOrbit Q (K:=K) hn w α b) + let d:ℤ:=(E.complex.placement i).level + have hz:classLevelArray R (probeOrbit Q (K:=K) hn w α b) (.inr (β,c),d)=0:=by + rw [probeOrbit_exterior] + simp only [hbc,and_false,false_and,ite_false] + rw [← minimalClassModel_class R (probeOrbit Q (K:=K) hn w α b), + classLevelArray_of_minimal R _ (minimalClassModel_minimal R _),levelArray_apply] at hz + have hh:Nonempty {j:E.Index | (E.complex.placement j).color=.inr (β,c) ∧ + (E.complex.placement j).level=d}:=⟨⟨i,hi,rfl⟩⟩ + have hp:=Nat.card_pos (α:={j:E.Index | (E.complex.placement j).color=.inr (β,c) ∧ + (E.complex.placement j).level=d}) + have :0 rfl + | cons a w ih => + change (probeSwapIso Q).classMap (probeSignedPerm Q hn a _)=probeSignedPerm Q hn a _ + rw [probeSignedPerm_swap,ih] + +lemma probeOrbit_swap (w:List (V×Bool)) (α:V) (b:Bool) : + (probeSwapIso Q).classMap (probeOrbit Q (K:=K) hn w α b)=probeOrbit Q (K:=K) hn w α (!b) := by + rw [probeOrbit,probeWordPerm_swap,Iso.classMap_initial] + rfl + +lemma probeOrbit_level_swap (w:List (V×Bool)) (α β:V) (b:Bool) (d:ℤ) : + classLevelArray R (probeOrbit Q (K:=K) hn w α (!b)) (.inl β,d)= + classLevelArray R (probeOrbit Q (K:=K) hn w α b) (.inl β,d) := by + rw [← probeOrbit_swap] + exact (probeSwapIso Q).classMap_levelArray _ (.inl β) d + +end Zigzag.BasedComplex +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ProbeVertex.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeVertex.lean new file mode 100644 index 0000000000000000000000000000000000000000..0cfa8ea6508359a2e570cd965fc9c5fff51a0991 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ProbeVertex.lean @@ -0,0 +1,123 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.OffDiagonalVertexZero + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver +variable {V A:Type*} (Q:ReversibleQuiver V A) +attribute [local instance] Classical.decEq Classical.propDecidable + +abbrev ProbeVertex (V:Type*) := V⊕(V×Bool) +abbrev ProbeArrow (V A:Type*) := A⊕(V×Bool×Bool) + +def probeQuiver : ReversibleQuiver (ProbeVertex V) (ProbeArrow V A) where + source + | .inl a => .inl (Q.source a) + | .inr (v,b,dir) => if dir then .inr (v,b) else .inl v + target + | .inl a => .inl (Q.target a) + | .inr (v,b,dir) => if dir then .inl v else .inr (v,b) + reverse := + { toFun := fun a => match a with + | .inl a => .inl (Q.reverse a) + | .inr (v,b,dir) => .inr (v,b,!dir) + invFun := fun a => match a with + | .inl a => .inl (Q.reverse a) + | .inr (v,b,dir) => .inr (v,b,!dir) + left_inv := by + rintro (a|⟨v,b,dir⟩) + · simp only [Q.reverse_reverse] + · simp + right_inv := by + rintro (a|⟨v,b,dir⟩) + · simp only [Q.reverse_reverse] + · simp } + reverse_reverse := by + rintro (a|⟨v,b,dir⟩) + · simp only [Equiv.coe_fn_mk,Q.reverse_reverse] + · simp + source_reverse := by + rintro (a|⟨v,b,dir⟩) + · simp only [Equiv.coe_fn_mk,Q.source_reverse] + · cases dir <;> rfl + target_reverse := by + rintro (a|⟨v,b,dir⟩) + · simp only [Equiv.coe_fn_mk,Q.target_reverse] + · cases dir <;> rfl + +lemma probeQuiver_no_loops (hn:∀a,Q.source a≠Q.target a) : + ∀a,(probeQuiver Q).source a≠(probeQuiver Q).target a := by + rintro (a|⟨v,b,dir⟩) + · exact fun h=>hn a (Sum.inl.inj h) + · cases dir <;> simp [probeQuiver] + +lemma probe_source_iff (v:V) (b:Bool) (a:ProbeArrow V A) : + (probeQuiver Q).source a=.inr (v,b) ↔ a=.inr (v,b,true) := by + cases a with + | inl a => simp [probeQuiver] + | inr a => rcases a with ⟨w,c,dir⟩; cases dir <;> simp [probeQuiver] + +lemma probe_target_iff (v:V) (b:Bool) (a:ProbeArrow V A) : + (probeQuiver Q).target a=.inr (v,b) ↔ a=.inr (v,b,false) := by + cases a with + | inl a => simp [probeQuiver] + | inr a => rcases a with ⟨w,c,dir⟩; cases dir <;> simp [probeQuiver] + +namespace Zigzag.BasedComplex +variable {K I:Type*} [Field K] [Fintype V] [Fintype A] [Fintype I] +local notation "R" => probeQuiver Q + +abbrev probeCoefficient (E:BasedComplex R (K:=K) I) (α:V) (n v:ℤ) := + {j:I // (E.placement j).color=.inl α ∧ (E.placement j).cochain=n ∧ + (E.placement j).internal=v-1} + +lemma probeHomPath_arrow (E:BasedComplex R (K:=K) I) (α:V) (b:Bool) + (ha:∀i,(E.placement i).color≠.inr (α,b)) (n v:ℤ) + (t:HomPath R ((initialProjective R (.inr (α,b)) : BasedComplex R (K:=K) PUnit.{1})) E n v) : + t.val.2.2=.inr (.inl (.inr (α,b,true))) := by + rcases t with ⟨⟨i,j,p⟩,hs,ht,hc,hd⟩ + cases p with + | inl w => exact False.elim (ha j (ht.symm.trans hs)) + | inr p => cases p with + | inl a => + exact congrArg (fun a:ProbeArrow V A=>Sum.inr (Sum.inl a)) + ((probe_source_iff Q α b a).mp hs) + | inr w => exact False.elim (ha j (ht.symm.trans hs)) + +noncomputable def probeHomPathEquiv (E:BasedComplex R (K:=K) I) (α:V) (b:Bool) + (ha:∀i,(E.placement i).color≠.inr (α,b)) (n v:ℤ) : + HomPath R ((initialProjective R (.inr (α,b)) : BasedComplex R (K:=K) PUnit.{1})) E n v ≃ probeCoefficient Q E α n v where + toFun t := ⟨t.val.2.1,by + have hp:=probeHomPath_arrow Q E α b ha n v t + have ht:=t.property.2.1 + have hc:=t.property.2.2.1 + have hd:=t.property.2.2.2 + rw [hp] at ht hd + change Sum.inl α=(E.placement t.val.2.1).color at ht + change (E.placement t.val.2.1).cochain=0+n at hc + change (1:ℤ)=v+0-(E.placement t.val.2.1).internal at hd + exact ⟨ht.symm,by omega,by omega⟩⟩ + invFun j := ⟨(PUnit.unit,j.val,.inr (.inl (.inr (α,b,true)))),by + refine ⟨rfl,j.property.1.symm,?_,?_⟩ + · change (E.placement j.val).cochain=0+n + rw [j.property.2.1,zero_add] + · change (1:ℤ)=v+0-(E.placement j.val).internal + rw [j.property.2.2]; omega⟩ + left_inv t := by + apply Subtype.ext + apply Prod.ext + · exact Subsingleton.elim _ _ + · exact Prod.ext rfl (probeHomPath_arrow Q E α b ha n v t).symm + right_inv _ := rfl + +lemma probeHomDimension (E:BasedComplex R (K:=K) I) (hE:E.IsMinimal R) + (α:V) (b:Bool) (ha:∀i,(E.placement i).color≠.inr (α,b)) (n v:ℤ) : + homDimension R ((initialProjective R (.inr (α,b)) : BasedComplex R (K:=K) PUnit.{1})) E n v= + Nat.card (probeCoefficient Q E α n v) := by + rw [absentProjective_homDimension R E hE _ ha] + exact Nat.card_congr (probeHomPathEquiv Q E α b ha n v) + +end Zigzag.BasedComplex +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/Reduction.lean b/lean/OAI/Topology/ArtinGroups/Quivers/Reduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..56f9d21f2dae605503344a8e6a6d1b4ce4fda121 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/Reduction.lean @@ -0,0 +1,117 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.GeneratorPlacement + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J L : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype A] [DecidableEq V] + +def reductionAt (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (M : Matrix I J (Q.Zigzag K)) (a : GeneratorPlacement V) : + Matrix {i // p i = a} {j // q j = a} K := + fun i j => (M i.1 j.1).vertex a.color + +lemma reductionAt_add (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (M N : Matrix I J (Q.Zigzag K)) (a : GeneratorPlacement V) : + reductionAt Q p q (M + N) a = reductionAt Q p q M a + reductionAt Q p q N a := rfl + +omit [Fintype A] [DecidableEq V] in +lemma reductionAt_positive (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (M : Matrix I J (Q.Zigzag K)) (a : GeneratorPlacement V) (hM : PositiveMatrix Q M) : + reductionAt Q p q M a = 0 := by + funext i j + change (M i.1 j.1).vertex a.color = 0 + rw [hM i.1 j.1] + rfl + +lemma reductionAt_identity [DecidableEq I] (p : I → GeneratorPlacement V) + (a : GeneratorPlacement V) : + reductionAt Q p p (projectiveIdentity Q (K := K) p) a = 1 := by + classical + apply Matrix.ext + intro i j + by_cases h : i = j + · subst j + simp [reductionAt, projectiveIdentity, i.property] + · have h' : (i : I) ≠ (j : I) := fun he => h (Subtype.ext he) + simp [reductionAt, projectiveIdentity, h, h'] + +lemma reductionAt_mul [Fintype J] + (p : I → GeneratorPlacement V) (q : J → GeneratorPlacement V) + (r : L → GeneratorPlacement V) (M : Matrix I J (Q.Zigzag K)) + (N : Matrix J L (Q.Zigzag K)) (a : GeneratorPlacement V) + (hc : ProjectiveEntries Q p q M) (hd : MapDegree Q p q 0 0 M) : + reductionAt Q p r (M * N) a = + reductionAt Q p q M a * reductionAt Q q r N a := by + classical + apply Matrix.ext + intro i l + change (vertexHom Q (K := K) a.color) ((M * N) i.1 l.1) = _ + simp only [Matrix.mul_apply, map_sum, map_mul] + apply Finset.sum_congr_set {j | q j = a} + · intro j hj + rfl + · intro j hj + have hz : (M i.1 j).vertex a.color = 0 := by + by_contra hn + have hs := (reduction_support Q hc hd i.1 j a.color hn).1 + exact hj (hs.symm.trans i.property) + change (M i.1 j).vertex a.color * (N j l.1).vertex a.color = 0 + rw [hz] + exact MulZeroClass.zero_mul _ + +namespace BasedComplex + +variable [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J] + +structure HomotopyEquivalence (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) where + forward : Map Q E F + backward : Map Q F E + sourceHomotopy : Matrix I I (Q.Zigzag K) + targetHomotopy : Matrix J J (Q.Zigzag K) + sourceEntries : ProjectiveEntries Q E.placement E.placement sourceHomotopy + targetEntries : ProjectiveEntries Q F.placement F.placement targetHomotopy + sourceDegree : MapDegree Q E.placement E.placement (-1) 0 sourceHomotopy + targetDegree : MapDegree Q F.placement F.placement (-1) 0 targetHomotopy + sourceEquation : forward.matrix * backward.matrix = projectiveIdentity Q E.placement + + (E.differential * sourceHomotopy + sourceHomotopy * E.differential) + targetEquation : backward.matrix * forward.matrix = projectiveIdentity Q F.placement + + (F.differential * targetHomotopy + targetHomotopy * F.differential) + +theorem multiplicity_eq_of_minimal_homotopyEquivalence + (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) + (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (h : HomotopyEquivalence Q E F) (a : GeneratorPlacement V) : + E.multiplicity Q a = F.multiplicity Q a := by + classical + let f := reductionAt Q E.placement F.placement h.forward.matrix a + let g := reductionAt Q F.placement E.placement h.backward.matrix a + have hfg : f * g = 1 := by + dsimp only [f, g] + rw [← reductionAt_mul Q _ _ _ _ _ a h.forward.entries h.forward.degree, + h.sourceEquation, reductionAt_add, reductionAt_identity, + reductionAt_positive Q _ _ _ a] + · exact add_zero _ + · exact positiveMatrix_add Q + (positiveMatrix_mul_right Q hE h.sourceHomotopy) + (positiveMatrix_mul_left Q h.sourceHomotopy hE) + have hgf : g * f = 1 := by + dsimp only [f, g] + rw [← reductionAt_mul Q _ _ _ _ _ a h.backward.entries h.backward.degree, + h.targetEquation, reductionAt_add, reductionAt_identity, + reductionAt_positive Q _ _ _ a] + · exact add_zero _ + · exact positiveMatrix_add Q + (positiveMatrix_mul_right Q hF h.targetHomotopy) + (positiveMatrix_mul_left Q h.targetHomotopy hF) + have hd := (Matrix.toLinearEquivRight'OfInv hfg hgf).finrank_eq + simpa only [multiplicity, Module.finrank_pi, Module.finrank_self, Finset.sum_const, + Finset.card_univ, smul_eq_mul, mul_one, Nat.card_eq_fintype_card] using hd.symm + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ReversibleQuiver.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ReversibleQuiver.lean new file mode 100644 index 0000000000000000000000000000000000000000..9f1ec702f0d20f91483e9be7993f8d7b219560b6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ReversibleQuiver.lean @@ -0,0 +1,350 @@ +import Mathlib + +namespace OAI + +namespace HarmonicArtin + +structure ReversibleQuiver (V A : Type*) where + source : A → V + target : A → V + reverse : A ≃ A + reverse_reverse : ∀ a, reverse (reverse a) = a + source_reverse : ∀ a, source (reverse a) = target a + target_reverse : ∀ a, target (reverse a) = source a + +namespace ReversibleQuiver + +variable {V A K : Type*} (Q : ReversibleQuiver V A) + +@[simp] theorem reverse_reverse_apply (a : A) : Q.reverse (Q.reverse a) = a := + Q.reverse_reverse a + +def Zigzag (_Q : ReversibleQuiver V A) (K : Type*) := (V → K) × (A → K) × (V → K) + +namespace Zigzag + +variable {Q} + +instance [AddCommGroup K] : AddCommGroup (Q.Zigzag K) := + inferInstanceAs (AddCommGroup ((V → K) × (A → K) × (V → K))) + +instance [CommRing K] : Module K (Q.Zigzag K) := + inferInstanceAs (Module K ((V → K) × (A → K) × (V → K))) + +def vertex (x : Q.Zigzag K) : V → K := x.1 +def arrow (x : Q.Zigzag K) : A → K := x.2.1 +def token (x : Q.Zigzag K) : V → K := x.2.2 + +@[ext] theorem ext {x y : Q.Zigzag K} (h₀ : x.vertex = y.vertex) + (h₁ : x.arrow = y.arrow) (h₂ : x.token = y.token) : x = y := + Prod.ext h₀ (Prod.ext h₁ h₂) + +@[simp] theorem vertex_add [AddCommGroup K] (x y : Q.Zigzag K) : + (x + y).vertex = x.vertex + y.vertex := rfl +@[simp] theorem arrow_add [AddCommGroup K] (x y : Q.Zigzag K) : + (x + y).arrow = x.arrow + y.arrow := rfl +@[simp] theorem token_add [AddCommGroup K] (x y : Q.Zigzag K) : + (x + y).token = x.token + y.token := rfl +@[simp] theorem vertex_smul [CommRing K] (c : K) (x : Q.Zigzag K) : + (c • x).vertex = c • x.vertex := rfl +@[simp] theorem arrow_smul [CommRing K] (c : K) (x : Q.Zigzag K) : + (c • x).arrow = c • x.arrow := rfl +@[simp] theorem token_smul [CommRing K] (c : K) (x : Q.Zigzag K) : + (c • x).token = c • x.token := rfl +@[simp] theorem vertex_zero [AddCommGroup K] : (0 : Q.Zigzag K).vertex = 0 := rfl +@[simp] theorem arrow_zero [AddCommGroup K] : (0 : Q.Zigzag K).arrow = 0 := rfl +@[simp] theorem token_zero [AddCommGroup K] : (0 : Q.Zigzag K).token = 0 := rfl + +end Zigzag + +section Multiplication + +variable [CommRing K] [Fintype A] [DecidableEq V] + +def leftScale (v : V → K) (a : A → K) : A → K := fun e => v (Q.source e) * a e + +def rightScale (a : A → K) (v : V → K) : A → K := fun e => a e * v (Q.target e) + +def backtrack (a b : A → K) : V → K := + fun i => ∑ e, if Q.source e = i then a e * b (Q.reverse e) else 0 + +@[simp] theorem backtrack_add_left (a b c : A → K) : + Q.backtrack (a + b) c = Q.backtrack a c + Q.backtrack b c := by + ext i + simp only [backtrack, Pi.add_apply, add_mul] + rw [← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun e _ => by split_ifs <;> simp + +@[simp] theorem backtrack_add_right (a b c : A → K) : + Q.backtrack a (b + c) = Q.backtrack a b + Q.backtrack a c := by + ext i + simp only [backtrack, Pi.add_apply, mul_add] + rw [← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun e _ => by split_ifs <;> simp + +@[simp] theorem backtrack_zero_left (a : A → K) : Q.backtrack 0 a = 0 := by + ext i + simp [backtrack] + +@[simp] theorem backtrack_zero_right (a : A → K) : Q.backtrack a 0 = 0 := by + ext i + simp [backtrack] + +theorem backtrack_leftScale (v : V → K) (a b : A → K) : + Q.backtrack (Q.leftScale v a) b = v * Q.backtrack a b := by + ext i + simp only [backtrack, leftScale, Pi.mul_apply, Finset.mul_sum] + apply Finset.sum_congr rfl + intro e _ + split_ifs with he + · simp [he, mul_assoc] + · simp + +theorem backtrack_rightScale (v : V → K) (a b : A → K) : + Q.backtrack a (Q.rightScale b v) = Q.backtrack a b * v := by + ext i + simp only [backtrack, rightScale, Pi.mul_apply, Finset.sum_mul, Q.target_reverse] + apply Finset.sum_congr rfl + intro e _ + split_ifs with he + · simp [he, mul_assoc] + · simp + +theorem backtrack_balance (v : V → K) (a b : A → K) : + Q.backtrack (Q.rightScale a v) b = Q.backtrack a (Q.leftScale v b) := by + ext i + simp only [backtrack, rightScale, leftScale, Q.source_reverse, mul_assoc] + +namespace Zigzag + +instance : Mul (Q.Zigzag K) where + mul x y := (x.vertex * y.vertex, + Q.leftScale x.vertex y.arrow + Q.rightScale x.arrow y.vertex, + x.vertex * y.token + x.token * y.vertex + Q.backtrack x.arrow y.arrow) + +instance : One (Q.Zigzag K) := ⟨(1, 0, 0)⟩ + +@[simp] theorem vertex_mul (x y : Q.Zigzag K) : + (x * y).vertex = x.vertex * y.vertex := rfl +@[simp] theorem arrow_mul (x y : Q.Zigzag K) : + (x * y).arrow = Q.leftScale x.vertex y.arrow + Q.rightScale x.arrow y.vertex := rfl +@[simp] theorem token_mul (x y : Q.Zigzag K) : + (x * y).token = x.vertex * y.token + x.token * y.vertex + Q.backtrack x.arrow y.arrow := rfl +omit [Fintype A] [DecidableEq V] in +@[simp] theorem vertex_one : (1 : Q.Zigzag K).vertex = 1 := rfl +omit [Fintype A] [DecidableEq V] in +@[simp] theorem arrow_one : (1 : Q.Zigzag K).arrow = 0 := rfl +omit [Fintype A] [DecidableEq V] in +@[simp] theorem token_one : (1 : Q.Zigzag K).token = 0 := rfl + +theorem mul_assoc (x y z : Q.Zigzag K) : (x * y) * z = x * (y * z) := by + apply ext + · simp only [vertex_mul, _root_.mul_assoc] + · ext e + simp only [arrow_mul, vertex_mul, leftScale, rightScale, Pi.add_apply, Pi.mul_apply] + ring + · simp only [token_mul, vertex_mul, arrow_mul, Q.backtrack_add_left, + Q.backtrack_add_right, Q.backtrack_leftScale, Q.backtrack_rightScale, + Q.backtrack_balance] + ring + +theorem one_mul (x : Q.Zigzag K) : 1 * x = x := by + apply ext + · simp + · ext e + simp [leftScale, rightScale] + · simp + +theorem mul_one (x : Q.Zigzag K) : x * 1 = x := by + apply ext + · simp + · ext e + simp [leftScale, rightScale] + · simp + +theorem mul_add (x y z : Q.Zigzag K) : x * (y + z) = x * y + x * z := by + apply ext + · simp [_root_.mul_add] + · ext e + simp only [arrow_mul, vertex_add, arrow_add, leftScale, rightScale, Pi.add_apply] + ring + · simp only [token_mul, vertex_add, arrow_add, token_add, Q.backtrack_add_right] + ring + +theorem add_mul (x y z : Q.Zigzag K) : (x + y) * z = x * z + y * z := by + apply ext + · simp [_root_.add_mul] + · ext e + simp only [arrow_mul, vertex_add, arrow_add, leftScale, rightScale, Pi.add_apply] + ring + · simp only [token_mul, vertex_add, arrow_add, token_add, Q.backtrack_add_left] + ring + +theorem zero_mul (x : Q.Zigzag K) : 0 * x = 0 := by + apply ext + · simp + · ext e + simp [leftScale, rightScale] + · simp + +theorem mul_zero (x : Q.Zigzag K) : x * 0 = 0 := by + apply ext + · simp + · ext e + simp [leftScale, rightScale] + · simp + +instance : Ring (Q.Zigzag K) where + mul_assoc := mul_assoc Q + one_mul := one_mul Q + mul_one := mul_one Q + left_distrib := mul_add Q + right_distrib := add_mul Q + zero_mul := zero_mul Q + mul_zero := mul_zero Q + +section Trace + +variable [Fintype V] + +def trace (x : Q.Zigzag K) : K := ∑ i, x.token i + +@[simp] theorem trace_add (x y : Q.Zigzag K) : + trace Q (x + y) = trace Q x + trace Q y := by + simp only [trace, token_add, Pi.add_apply, Finset.sum_add_distrib] + +@[simp] theorem trace_zero : trace Q (0 : Q.Zigzag K) = 0 := by + simp only [trace, token_zero, Pi.zero_apply, Finset.sum_const_zero] + +theorem sum_backtrack (a b : A → K) : + ∑ i, Q.backtrack a b i = ∑ e, a e * b (Q.reverse e) := by + simp only [backtrack] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro e _ + simp + +theorem trace_mul_expression (x y : Q.Zigzag K) : + trace Q (x * y) = (∑ i, (x.vertex i * y.token i + x.token i * y.vertex i)) + + ∑ e, x.arrow e * y.arrow (Q.reverse e) := by + simp only [trace, token_mul, Pi.add_apply, Pi.mul_apply, Finset.sum_add_distrib, + sum_backtrack] + +theorem trace_mul_comm (x y : Q.Zigzag K) : trace Q (x * y) = trace Q (y * x) := by + rw [trace_mul_expression, trace_mul_expression] + congr 1 + · apply Finset.sum_congr rfl + intro i _ + ring + · apply Fintype.sum_equiv Q.reverse + intro e + simp [_root_.mul_comm] + +def vertexBasis (i : V) : Q.Zigzag K := (Pi.single i 1, 0, 0) + +def tokenBasis (i : V) : Q.Zigzag K := (0, 0, Pi.single i 1) + +def arrowBasis [DecidableEq A] (e : A) : Q.Zigzag K := (0, Pi.single e 1, 0) + +@[simp] theorem trace_mul_tokenBasis (x : Q.Zigzag K) (i : V) : + trace Q (x * tokenBasis Q i) = x.vertex i := by + rw [trace_mul_expression] + simp [tokenBasis, vertex, token, arrow, Pi.single_apply] + +@[simp] theorem trace_mul_vertexBasis (x : Q.Zigzag K) (i : V) : + trace Q (x * vertexBasis Q i) = x.token i := by + rw [trace_mul_expression] + simp [vertexBasis, vertex, token, arrow, Pi.single_apply] + +@[simp] theorem trace_mul_arrowBasis [DecidableEq A] (x : Q.Zigzag K) (e : A) : + trace Q (x * arrowBasis Q (Q.reverse e)) = x.arrow e := by + rw [trace_mul_expression] + simp [arrowBasis, vertex, token, arrow, Pi.single_apply] + +theorem trace_nondegenerate_left (x : Q.Zigzag K) + (hx : ∀ y : Q.Zigzag K, trace Q (x * y) = 0) : x = 0 := by + classical + apply ext + · funext i + simpa using hx (tokenBasis Q i) + · funext e + simpa using hx (arrowBasis Q (Q.reverse e)) + · funext i + simpa using hx (vertexBasis Q i) + +theorem trace_nondegenerate_right (x : Q.Zigzag K) + (hx : ∀ y : Q.Zigzag K, trace Q (y * x) = 0) : x = 0 := by + apply trace_nondegenerate_left Q x + intro y + rw [trace_mul_comm] + exact hx y + +theorem trace_smul_mul (c : K) (x y : Q.Zigzag K) : + trace Q ((c • x) * y) = c * trace Q (x * y) := by + rw [trace_mul_expression, trace_mul_expression] + simp only [vertex_smul, arrow_smul, token_smul, Pi.smul_apply, smul_eq_mul, + _root_.mul_assoc, ← _root_.mul_add, ← Finset.mul_sum] + +theorem trace_mul_smul (c : K) (x y : Q.Zigzag K) : + trace Q (x * (c • y)) = c * trace Q (x * y) := by + rw [trace_mul_comm, trace_smul_mul, trace_mul_comm Q y x] + +def tracePairing : LinearMap.BilinForm K (Q.Zigzag K) where + toFun x := + { toFun y := trace Q (x * y) + map_add' := fun y z => by rw [mul_add, trace_add] + map_smul' := fun c y => by simpa using trace_mul_smul Q c x y } + map_add' x y := by + ext z + exact (congrArg (trace Q) (add_mul Q x y z)).trans (trace_add Q _ _) + map_smul' c x := by + ext y + simpa using trace_smul_mul Q c x y + +@[simp] theorem tracePairing_apply (x y : Q.Zigzag K) : + tracePairing Q x y = trace Q (x * y) := rfl + +theorem tracePairing_symmetric : (tracePairing (K := K) Q).IsSymm := + ⟨trace_mul_comm Q⟩ + +theorem tracePairing_nondegenerate : (tracePairing (K := K) Q).Nondegenerate := by + exact ⟨trace_nondegenerate_left Q, trace_nondegenerate_right Q⟩ + +theorem annihilate_positive_iff (x : Q.Zigzag K) : + (∀ y : Q.Zigzag K, y.vertex = 0 → x * y = 0) ↔ x.vertex = 0 ∧ x.arrow = 0 := by + classical + constructor + · intro hx + constructor + · funext i + have h := congrArg (trace Q) (hx (tokenBasis Q i) rfl) + simpa using h + · funext e + have h := congrArg (trace Q) (hx (arrowBasis Q (Q.reverse e)) rfl) + simpa using h + · rintro ⟨h₀, h₁⟩ y hy + apply ext + · simp [h₀] + · ext e + simp [h₀, h₁, hy, leftScale, rightScale] + · simp [h₀, h₁, hy] + +end Trace + +theorem positive_triple_mul (x y z : Q.Zigzag K) + (hx : x.vertex = 0) (hy : y.vertex = 0) (hz : z.vertex = 0) : x * y * z = 0 := by + have harrow : (x * y).arrow = 0 := by + ext e + simp [hx, hy, leftScale, rightScale] + apply ext + · simp [hx] + · ext e + simp [hx, hz, harrow, leftScale, rightScale] + · simp [hx, hz, harrow] + +end Zigzag +end Multiplication +end ReversibleQuiver +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/ScalarCornerMatrixDegree.lean b/lean/OAI/Topology/ArtinGroups/Quivers/ScalarCornerMatrixDegree.lean new file mode 100644 index 0000000000000000000000000000000000000000..54d52d242e5ec8835af6424c2e2629d306c6cc78 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/ScalarCornerMatrixDegree.lean @@ -0,0 +1,44 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Cancellation.ScalarPivot +import OAI.Topology.ArtinGroups.Quivers.TestIndex + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V B K T R : Type*} (Q : ReversibleQuiver V B) [Field K] + [Fintype B] [DecidableEq V] +lemma scalarCornerMatrix_degree (α : V) (p : T → GeneratorPlacement V) + (q : R → GeneratorPlacement V) (M : Matrix T R K) (n v : ℤ) + (hc : ∀ i j, M i j ≠ 0 → (q j).cochain = (p i).cochain+n) + (hi : ∀ i j, M i j ≠ 0 → (q j).internal = (p i).internal+v) : + MapDegree Q p q n v (scalarCornerMatrix Q α M) := by + intro i j + constructor + · intro h + have hz : M i j=0 := by + by_contra hn + exact h (hc i j hn) + change M i j • vertexId Q α = 0 + rw [hz,zero_smul] + · by_cases hz : M i j=0 + · change Homogeneous Q _ (M i j • vertexId Q α) + rw [hz,zero_smul] + exact homogeneous_zero Q _ + · have he : v+(p i).internal-(q j).internal=0 := by rw [hi i j hz]; omega + rw [he] + exact homogeneous_smul Q (homogeneous_vertexId Q α) _ + +lemma scalarCornerMatrix_identity [DecidableEq T] (α : V) + (p : T → GeneratorPlacement V) (hp : ∀ i, (p i).color=α) : + scalarCornerMatrix Q α (1 : Matrix T T K) = projectiveIdentity Q p := by + apply Matrix.ext + intro i j + by_cases h : i=j + · subst j + simp only [scalarCornerMatrix,Matrix.one_apply_eq,one_smul,projectiveIdentity, + Matrix.diagonal_apply,ite_true,hp] + · simp only [scalarCornerMatrix,Matrix.one_apply_ne h,zero_smul,projectiveIdentity, + Matrix.diagonal_apply,ite_eq_right h] +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/SelfCornerEquiv.lean b/lean/OAI/Topology/ArtinGroups/Quivers/SelfCornerEquiv.lean new file mode 100644 index 0000000000000000000000000000000000000000..7413a8f67031b8f881a474c68364b745e6487916 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/SelfCornerEquiv.lean @@ -0,0 +1,115 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.CotestPlacement + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I : Type*} (Q : ReversibleQuiver V A) + +def selfCornerEquiv (hn : ∀ a, Q.source a ≠ Q.target a) (α : V) : + Bool ≃ CornerPath Q α α where + toFun b := if b then ⟨.inr (.inr α), rfl, rfl⟩ else ⟨.inl α, rfl, rfl⟩ + invFun p := match p.val with + | .inl _ => false + | .inr (.inl _) => false + | .inr (.inr _) => true + left_inv b := by cases b <;> rfl + right_inv p := by + rcases p with ⟨v | a | v, hs, ht⟩ + · apply Subtype.ext + change Sum.inl α = Sum.inl v + exact congrArg Sum.inl hs.symm + · exact (hn a (hs.trans ht.symm)).elim + · apply Subtype.ext + change Sum.inr (Sum.inr α) = Sum.inr (Sum.inr v) + exact congrArg (fun x => Sum.inr (Sum.inr x)) hs.symm + +@[simp] lemma selfCornerEquiv_false (hn : ∀ a, Q.source a ≠ Q.target a) (α : V) : + ((selfCornerEquiv Q hn α) false).val = .inl α := rfl +@[simp] lemma selfCornerEquiv_true (hn : ∀ a, Q.source a ≠ Q.target a) (α : V) : + ((selfCornerEquiv Q hn α) true).val = .inr (.inr α) := rfl + +variable [Field K] [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +lemma diagonal_corner_decomposition (hn : ∀ a, Q.source a ≠ Q.target a) + (α : V) (x : Q.Zigzag K) (hl : vertexId Q α * x = x) + (hr : x * vertexId Q α = x) : + x = x.vertex α • vertexId Q α + x.token α • tokenBasis Q α := by + calc + x = ∑ p : CornerPath Q α α, pathCoordinates Q x p.val • pathBasis Q p.val := + (sum_cornerPath Q x hl hr).symm + _ = ∑ b : Bool, pathCoordinates Q x ((selfCornerEquiv Q hn α) b).val • + pathBasis Q ((selfCornerEquiv Q hn α) b).val := + (Equiv.sum_comp (selfCornerEquiv Q hn α) _).symm + _ = _ := by simpa only [Fintype.sum_bool, selfCornerEquiv_false, selfCornerEquiv_true, + pathCoordinates_vertex, pathCoordinates_token, pathBasis_vertex, pathBasis_token] + using add_comm (x.token α • tokenBasis Q α) (x.vertex α • vertexId Q α) + +lemma cornerPath_basis_dual_token {α β : V} (u v : CornerPath Q α β) : + (pathBasis Q (K := K) u.val * pathBasis Q (Path.dual Q v.val)).token α = + if u = v then 1 else 0 := by + have hl : vertexId Q α * (pathBasis Q (K := K) u.val * + pathBasis Q (Path.dual Q v.val)) = + pathBasis Q u.val * pathBasis Q (Path.dual Q v.val) := by + rw [← _root_.mul_assoc, cornerPath_left] + have hc := coordinates_vertexId_left Q α + (pathBasis Q (K := K) u.val * pathBasis Q (Path.dual Q v.val)) + have ht : trace Q (pathBasis Q (K := K) u.val * pathBasis Q (Path.dual Q v.val)) = + (pathBasis Q (K := K) u.val * pathBasis Q (Path.dual Q v.val)).token α := by + unfold trace + apply Finset.sum_eq_single α + · intro β _ hb + have he := hc (.inr (.inr β)) + rw [hl] at he + simpa [Path.source, hb] using he + · simp + rw [← ht, ← coordinates_trace, pathBasis_coordinates] + simp only [Subtype.ext_iff] + +noncomputable def unitContraction (p : I → GeneratorPlacement V) (α : V) : + Matrix (TestIndex Q p α) (TestIndex Q p α) (Q.Zigzag K) := by + classical + exact fun u v => if u.1 = v.1 then + (pathBasis Q (K := K) u.2.val * pathBasis Q (Path.dual Q v.2.val)).vertex α • + vertexId Q α else 0 + +noncomputable def testToken [DecidableEq I] (p : I → GeneratorPlacement V) (α : V) : + Matrix (TestIndex Q p α) (TestIndex Q p α) (Q.Zigzag K) := + Matrix.diagonal (fun _ => tokenBasis Q α) + +lemma evaluation_coevaluation [Fintype I] [DecidableEq I] + (hn : ∀ a, Q.source a ≠ Q.target a) (p : I → GeneratorPlacement V) (α : V) : + evaluationMatrix Q p α (K := K) * coevaluationMatrix Q p α (K := K) = + unitContraction Q p α + testToken Q p α := by + apply Matrix.ext + intro u v + rw [evaluation_mul] + dsimp only [coevaluationMatrix] + by_cases hi : u.1 = v.1 + · rcases u with ⟨i, u⟩ + rcases v with ⟨j, v⟩ + dsimp only at hi + subst j + rw [ite_eq_left rfl] + have hl : vertexId Q α * (pathBasis Q (K := K) u.val * pathBasis Q (Path.dual Q v.val)) = + pathBasis Q u.val * pathBasis Q (Path.dual Q v.val) := by + rw [← _root_.mul_assoc, cornerPath_left] + have hr : (pathBasis Q (K := K) u.val * pathBasis Q (Path.dual Q v.val)) * vertexId Q α = + pathBasis Q u.val * pathBasis Q (Path.dual Q v.val) := by + rw [_root_.mul_assoc] + exact congrArg (fun z => pathBasis Q (K := K) u.val * z) + (cornerPath_right Q (K := K) ((cornerDual Q α (p i).color) v)) + rw [diagonal_corner_decomposition Q hn α _ hl hr, cornerPath_basis_dual_token] + simp only [Matrix.add_apply, unitContraction, testToken, Matrix.diagonal_apply, ite_true] + by_cases hp : u = v + · subst v + simp + · simp [hp] + · have huv : u ≠ v := fun h => hi (congrArg Sigma.fst h) + simp only [ite_eq_right hi, MulZeroClass.mul_zero, unitContraction, testToken, + Matrix.add_apply, Matrix.diagonal_apply, ite_eq_right huv, add_zero] + +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/SignDiagonal.lean b/lean/OAI/Topology/ArtinGroups/Quivers/SignDiagonal.lean new file mode 100644 index 0000000000000000000000000000000000000000..2abedcd96bfd3750ba77709b1480dcacaf04dd25 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/SignDiagonal.lean @@ -0,0 +1,108 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.SmulMul +import OAI.Topology.ArtinGroups.Quivers.Level + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +universe u +open Matrix + +variable {V A:Type u} {K:Type*} (Q:ReversibleQuiver V A) + [Field K] [Fintype A] [DecidableEq V] + {I J:Type u} [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J] + +noncomputable def signDiagonal (p:I→GeneratorPlacement V) (ε:I→Bool) : Matrix I I (Q.Zigzag K) := + Matrix.diagonal (fun i=>if ε i then -vertexId Q (p i).color else vertexId Q (p i).color) + +omit [Fintype I] in +lemma signDiagonal_entries (p:I→GeneratorPlacement V) (ε:I→Bool) : + ProjectiveEntries Q p p (signDiagonal Q (K:=K) p ε) := by + constructor <;> intro i j <;> by_cases h:i=j + · subst j + simp only [signDiagonal,Matrix.diagonal_apply_eq] + split_ifs <;> simp only [mul_neg,vertexId_mul_self] + · simp only [signDiagonal,Matrix.diagonal_apply_ne _ h,mul_zero] + · subst j + simp only [signDiagonal,Matrix.diagonal_apply_eq] + split_ifs <;> simp only [neg_mul,vertexId_mul_self] + · simp only [signDiagonal,Matrix.diagonal_apply_ne _ h,zero_mul] + +omit [Fintype I] in +lemma signDiagonal_degree (p:I→GeneratorPlacement V) (ε:I→Bool) : + MapDegree Q p p 0 0 (signDiagonal Q (K:=K) p ε) := by + intro i j + by_cases h:i=j + · subst j + simp only [signDiagonal,Matrix.diagonal_apply_eq] + split_ifs + · simpa only [Matrix.neg_apply,projectiveIdentity,Matrix.diagonal_apply_eq] using + (mapDegree_neg Q (mapDegree_identity Q (K:=K) (p:=p)) i i) + · simpa only [projectiveIdentity,Matrix.diagonal_apply_eq] using + (mapDegree_identity Q (K:=K) (p:=p) i i) + · simp only [signDiagonal,Matrix.diagonal_apply_ne _ h] + constructor + · intro; trivial + · exact homogeneous_zero Q _ + +lemma signDiagonal_square (p:I→GeneratorPlacement V) (ε:I→Bool) : + signDiagonal Q (K:=K) p ε*signDiagonal Q p ε=projectiveIdentity Q p := by + rw [signDiagonal,Matrix.diagonal_mul_diagonal] + congr 1 + funext i + split_ifs <;> simp only [neg_mul_neg,vertexId_mul_self] + +omit [Fintype J] [DecidableEq J] in +lemma signDiagonal_mul {p:I→GeneratorPlacement V} {q:J→GeneratorPlacement V} + (ε:I→Bool) (M:Matrix I J (Q.Zigzag K)) (hM:ProjectiveEntries Q p q M) (i:I) (j:J) : + (signDiagonal Q (K:=K) p ε * M) i j=if ε i then -M i j else M i j := by + rw [signDiagonal,Matrix.diagonal_mul] + split_ifs <;> simp only [neg_mul,hM.1] + +omit [Fintype I] [DecidableEq I] in +lemma mul_signDiagonal {p:I→GeneratorPlacement V} {q:J→GeneratorPlacement V} + (ε:J→Bool) (M:Matrix I J (Q.Zigzag K)) (hM:ProjectiveEntries Q p q M) (i:I) (j:J) : + (M * signDiagonal Q (K:=K) q ε) i j=if ε j then -M i j else M i j := by + rw [signDiagonal,Matrix.mul_diagonal] + split_ifs <;> simp only [mul_neg,hM.2] + +namespace BasedComplex +noncomputable def signChainIsomorphism (E F:BasedComplex Q (K:=K) I) (ε:I→Bool) + (hp:F.placement=E.placement) + (hd:∀ i j,(if ε j then -E.differential i j else E.differential i j)= + (if ε i then -F.differential i j else F.differential i j)) : + ChainIsomorphism Q E F := by + let s:=signDiagonal Q (K:=K) E.placement ε + have he:ProjectiveEntries Q E.placement F.placement s := by + rw [hp]; exact signDiagonal_entries Q _ _ + have hdeg:MapDegree Q E.placement F.placement 0 0 s := by + rw [hp]; exact signDiagonal_degree Q _ _ + let f:Map Q E F:=⟨s,he,hdeg,by + apply Matrix.ext + intro i j + have hF:ProjectiveEntries Q E.placement F.placement F.differential := by + rw [← hp]; exact F.entries + exact (mul_signDiagonal Q ε E.differential E.entries i j).trans + ((hd i j).trans (signDiagonal_mul Q ε F.differential hF i j).symm)⟩ + have hg:ProjectiveEntries Q F.placement E.placement s := by + rw [hp]; exact signDiagonal_entries Q _ _ + have hgd:MapDegree Q F.placement E.placement 0 0 s := by + rw [hp]; exact signDiagonal_degree Q _ _ + have hs:f.matrix*s=projectiveIdentity Q E.placement := signDiagonal_square Q _ _ + have ht:s*f.matrix=projectiveIdentity Q F.placement := by + rw [hp]; exact signDiagonal_square Q _ _ + refine ⟨f,⟨s,hg,hgd,?_⟩,hs,ht⟩ + calc + F.differential*s=(projectiveIdentity Q F.placement*F.differential)*s := by + exact congrArg (fun matrix=>matrix*s) (projectiveIdentity_mul Q F.entries).symm + _=((s*f.matrix)*F.differential)*s := by rw [ht] + _=(s*(f.matrix*F.differential))*s := by simp only [Matrix.mul_assoc] + _=(s*(E.differential*f.matrix))*s := by rw [f.commute] + _=(s*E.differential)*(f.matrix*s) := by simp only [Matrix.mul_assoc] + _=(s*E.differential)*projectiveIdentity Q E.placement := by rw [hs] + _=s*E.differential := mul_projectiveIdentity Q (projectiveEntries_mul Q hg E.entries) + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/SimpleEdge.lean b/lean/OAI/Topology/ArtinGroups/Quivers/SimpleEdge.lean new file mode 100644 index 0000000000000000000000000000000000000000..bb49e3a79e2ecb4136cea33cc8f7110d5bb62ef4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/SimpleEdge.lean @@ -0,0 +1,48 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.CornerPath + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A : Type*} (Q : ReversibleQuiver V A) + +structure SimpleEdge (α β : V) where + arrow : A + source : Q.source arrow = α + target : Q.target arrow = β + distinct : α ≠ β + unique : ∀ a, Q.source a = α → Q.target a = β → a = arrow + +namespace SimpleEdge + +variable {α β : V} (e : SimpleEdge Q α β) + +def reverse : SimpleEdge Q β α where + arrow := Q.reverse e.arrow + source := (Q.source_reverse _).trans e.target + target := (Q.target_reverse _).trans e.source + distinct := e.distinct.symm + unique a hs ht := by + have h := e.unique (Q.reverse a) ((Q.source_reverse _).trans ht) + ((Q.target_reverse _).trans hs) + have h' := congrArg Q.reverse h + simpa only [Q.reverse_reverse] using h' + +def corner : CornerPath Q α β := ⟨.inr (.inl e.arrow), e.source, e.target⟩ + +lemma corner_unique (p : CornerPath Q α β) : p = e.corner Q := by + rcases p with ⟨v | a | v, hs, ht⟩ + · exact (e.distinct (hs.symm.trans ht)).elim + · apply Subtype.ext + change Sum.inr (Sum.inl a) = Sum.inr (Sum.inl e.arrow) + exact congrArg (fun a => Sum.inr (Sum.inl a)) (e.unique a hs ht) + · exact (e.distinct (hs.symm.trans ht)).elim + +@[simp] lemma corner_val : (e.corner Q).val = .inr (.inl e.arrow) := rfl +@[simp] lemma reverse_arrow : (e.reverse Q).arrow = Q.reverse e.arrow := rfl + +end SimpleEdge +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/SmulMul.lean b/lean/OAI/Topology/ArtinGroups/Quivers/SmulMul.lean new file mode 100644 index 0000000000000000000000000000000000000000..b5d52649937710ab6f007198f5d1700e1c004d88 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/SmulMul.lean @@ -0,0 +1,221 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Level + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype A] [DecidableEq V] + +theorem smul_mul (a : K) (x y : Q.Zigzag K) : + (a • x) * y = a • (x * y) := by + apply Zigzag.ext + · ext v + simp only [vertex_mul, vertex_smul, Pi.mul_apply, Pi.smul_apply, smul_eq_mul] + ring + · ext e + simp only [arrow_mul, arrow_smul, vertex_smul, leftScale, rightScale, + Pi.add_apply, Pi.smul_apply, smul_eq_mul] + ring + · ext v + simp only [token_mul, token_smul, vertex_smul, arrow_smul, backtrack, + Pi.mul_apply, Pi.smul_apply, Pi.add_apply, smul_eq_mul, _root_.mul_add] + congr 1 + · ring + · rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro e _ + split_ifs <;> ring + +theorem mul_smul (a : K) (x y : Q.Zigzag K) : + x * (a • y) = a • (x * y) := by + apply Zigzag.ext + · ext v + simp only [vertex_mul, vertex_smul, Pi.mul_apply, Pi.smul_apply, smul_eq_mul] + ring + · ext e + simp only [arrow_mul, arrow_smul, vertex_smul, leftScale, rightScale, + Pi.add_apply, Pi.smul_apply, smul_eq_mul] + ring + · ext v + simp only [token_mul, token_smul, vertex_smul, arrow_smul, backtrack, + Pi.mul_apply, Pi.smul_apply, Pi.add_apply, smul_eq_mul, _root_.mul_add] + congr 1 + · ring + · rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro e _ + split_ifs <;> ring + +instance : Algebra K (Q.Zigzag K) := + Algebra.ofModule (smul_mul Q) (mul_smul Q) + +lemma homogeneous_zero (a : ℤ) : Homogeneous Q a (0 : Q.Zigzag K) := + ⟨fun _ => rfl, fun _ => rfl, fun _ => rfl⟩ + +lemma homogeneous_add {a : ℤ} {x y : Q.Zigzag K} + (hx : Homogeneous Q a x) (hy : Homogeneous Q a y) : + Homogeneous Q a (x + y) := by + exact ⟨fun h => by simp [hx.1 h, hy.1 h], + fun h => by simp [hx.2.1 h, hy.2.1 h], + fun h => by simp [hx.2.2 h, hy.2.2 h]⟩ + +omit [Fintype A] [DecidableEq V] in +lemma homogeneous_neg {a : ℤ} {x : Q.Zigzag K} + (hx : Homogeneous Q a x) : Homogeneous Q a (-x) := by + exact ⟨fun h => by change -x.vertex = 0; simp [hx.1 h], + fun h => by change -x.arrow = 0; simp [hx.2.1 h], + fun h => by change -x.token = 0; simp [hx.2.2 h]⟩ + +lemma homogeneous_sum {T : Type*} (t : Finset T) {a : ℤ} + {f : T → Q.Zigzag K} (h : ∀ i ∈ t, Homogeneous Q a (f i)) : + Homogeneous Q a (∑ i ∈ t, f i) := by + classical + induction t using Finset.induction_on with + | empty => simpa only [Finset.sum_empty] using homogeneous_zero Q a + | @insert i t hi iht => + rw [Finset.sum_insert hi] + exact homogeneous_add Q (h i (Finset.mem_insert_self _ _)) + (iht fun j hj => h j (Finset.mem_insert_of_mem hj)) + +lemma homogeneous_mul {a b : ℤ} {x y : Q.Zigzag K} + (hx : Homogeneous Q a x) (hy : Homogeneous Q b y) : + Homogeneous Q (a + b) (x * y) := by + by_cases hx0 : x = 0 + · subst x + rw [MulZeroClass.zero_mul] + exact homogeneous_zero Q _ + by_cases hy0 : y = 0 + · subst y + rw [MulZeroClass.mul_zero] + exact homogeneous_zero Q _ + rcases homogeneous_nonzero_degree Q hx hx0 with ha | ha | ha <;> + rcases homogeneous_nonzero_degree Q hy hy0 with hb | hb | hb <;> + subst a <;> subst b <;> + simp_all [Homogeneous] + all_goals + ext e + simp [leftScale, rightScale] + +variable {I J L : Type*} {p : I → GeneratorPlacement V} + {q : J → GeneratorPlacement V} {r : L → GeneratorPlacement V} + +lemma projectiveEntries_zero : + ProjectiveEntries Q p q (0 : Matrix I J (Q.Zigzag K)) := by + constructor <;> intro i j <;> simp + +lemma projectiveEntries_add {M N : Matrix I J (Q.Zigzag K)} + (hM : ProjectiveEntries Q p q M) (hN : ProjectiveEntries Q p q N) : + ProjectiveEntries Q p q (M + N) := by + constructor + · intro i j + change vertexId Q _ * (M i j + N i j) = _ + rw [_root_.mul_add, hM.1, hN.1] + rfl + · intro i j + change (M i j + N i j) * vertexId Q _ = _ + rw [_root_.add_mul, hM.2, hN.2] + rfl + +lemma projectiveEntries_neg {M : Matrix I J (Q.Zigzag K)} + (hM : ProjectiveEntries Q p q M) : ProjectiveEntries Q p q (-M) := by + constructor + · intro i j + change vertexId Q _ * (-M i j) = _ + rw [mul_neg, hM.1] + rfl + · intro i j + change (-M i j) * vertexId Q _ = _ + rw [neg_mul, hM.2] + rfl + +lemma projectiveEntries_mul [Fintype J] + {M : Matrix I J (Q.Zigzag K)} {N : Matrix J L (Q.Zigzag K)} + (hM : ProjectiveEntries Q p q M) (hN : ProjectiveEntries Q q r N) : + ProjectiveEntries Q p r (M * N) := by + constructor + · intro i k + simp only [Matrix.mul_apply, Finset.mul_sum, ← _root_.mul_assoc, hM.1] + · intro i k + simp only [Matrix.mul_apply, Finset.sum_mul, _root_.mul_assoc, hN.2] + +lemma projectiveEntries_identity [DecidableEq I] : + ProjectiveEntries Q p p (projectiveIdentity Q (K := K) p) := by + constructor <;> intro i j <;> by_cases h : i = j + all_goals simp [projectiveIdentity, h, vertexId_mul_self] + +lemma projectiveIdentity_mul [Fintype I] [DecidableEq I] + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) : + projectiveIdentity Q p * M = M := by + apply Matrix.ext + intro i j + exact (Matrix.diagonal_mul (fun i => vertexId Q (K := K) (p i).color) M i j).trans + (hM.1 i j) + +lemma mul_projectiveIdentity [Fintype J] [DecidableEq J] + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) : + M * projectiveIdentity Q q = M := by + apply Matrix.ext + intro i j + exact (Matrix.mul_diagonal (fun j => vertexId Q (K := K) (q j).color) M i j).trans + (hM.2 i j) + +lemma mapDegree_zero (n v : ℤ) : + MapDegree Q p q n v (0 : Matrix I J (Q.Zigzag K)) := + fun _ _ => ⟨fun _ => rfl, homogeneous_zero Q _⟩ + +lemma mapDegree_add {n v : ℤ} {M N : Matrix I J (Q.Zigzag K)} + (hM : MapDegree Q p q n v M) (hN : MapDegree Q p q n v N) : + MapDegree Q p q n v (M + N) := by + intro i j + exact ⟨fun h => by simp [(hM i j).1 h, (hN i j).1 h], + homogeneous_add Q (hM i j).2 (hN i j).2⟩ + +lemma mapDegree_neg {n v : ℤ} {M : Matrix I J (Q.Zigzag K)} + (hM : MapDegree Q p q n v M) : MapDegree Q p q n v (-M) := by + intro i j + exact ⟨fun h => by simp [(hM i j).1 h], homogeneous_neg Q (hM i j).2⟩ + +lemma mapDegree_mul [Fintype J] {n v m w : ℤ} + {M : Matrix I J (Q.Zigzag K)} {N : Matrix J L (Q.Zigzag K)} + (hM : MapDegree Q p q n v M) (hN : MapDegree Q q r m w N) : + MapDegree Q p r (n + m) (v + w) (M * N) := by + intro i k + constructor + · intro h + simp only [Matrix.mul_apply] + apply Finset.sum_eq_zero + intro j _ + by_cases hc : (q j).cochain = (p i).cochain + n + · have he : (r k).cochain ≠ (q j).cochain + m := by omega + rw [(hN j k).1 he, MulZeroClass.mul_zero] + · rw [(hM i j).1 hc, MulZeroClass.zero_mul] + · rw [Matrix.mul_apply] + apply homogeneous_sum Q + intro j _ + convert homogeneous_mul Q (hM i j).2 (hN j k).2 using 1 + ring + +omit [Fintype A] in +lemma homogeneous_vertexId (v : V) : Homogeneous Q 0 (vertexId Q (K := K) v) := + ⟨fun h => (h rfl).elim, fun _ => rfl, fun _ => rfl⟩ + +lemma mapDegree_identity [DecidableEq I] : + MapDegree Q p p 0 0 (projectiveIdentity Q (K := K) p) := by + intro i j + by_cases h : i = j + · subst j + constructor + · intro hn + exact (hn (by omega)).elim + · simpa only [projectiveIdentity, Matrix.diagonal_apply_eq, zero_add, sub_self] + using homogeneous_vertexId Q (K := K) (p i).color + · have hz : projectiveIdentity Q (K := K) p i j = 0 := + Matrix.diagonal_apply_ne _ h + rw [hz] + exact ⟨fun _ => rfl, homogeneous_zero Q _⟩ + +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/StringArrow.lean b/lean/OAI/Topology/ArtinGroups/Quivers/StringArrow.lean new file mode 100644 index 0000000000000000000000000000000000000000..359e9402eb46a9a2db30681321d299053a45e7e0 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/StringArrow.lean @@ -0,0 +1,317 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Crossing +import OAI.Topology.ArtinGroups.Quivers.VertexIdMulPath + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver + +variable {V B J K : Type*} (Q : ReversibleQuiver V B) + +abbrev StringArrow (step : B → Bool) (N : J → J → Prop) := + {p : B × J × J // if step p.1 then N p.2.1 p.2.2 else p.2.1 = p.2.2} + +namespace StringArrow +variable {N : J → J → Prop} {step : B → Bool} + +def base (p : StringArrow step N) : B := p.1.1 +def left (p : StringArrow step N) : J := p.1.2.1 +def right (p : StringArrow step N) : J := p.1.2.2 + +@[ext] lemma ext {p q : StringArrow step N} + (hb : p.base=q.base) (hl : p.left=q.left) (hr : p.right=q.right) : p=q := by + apply Subtype.ext + exact Prod.ext hb (Prod.ext hl hr) + +end StringArrow + +variable (step : B → Bool) (hstep : ∀ b, step (Q.reverse b) = step b) + (N : J → J → Prop) (hN : ∀ ⦃first second⦄, N first second → N second first) + +def stringQuiver : ReversibleQuiver (V × J) (StringArrow step N) where + source p := (Q.source p.base,p.left) + target p := (Q.target p.base,p.right) + reverse := + { toFun p := ⟨(Q.reverse p.base,p.right,p.left),by + have hp := p.property + change (if step p.base then N p.left p.right else p.left=p.right) at hp + change (if step (Q.reverse p.base) then N p.right p.left else p.right=p.left) + rw [hstep] + cases hs : step p.base <;> simp only [hs, Bool.false_eq_true, ↓reduceIte] at * + · exact hp.symm + · exact hN hp⟩ + invFun p := ⟨(Q.reverse p.base,p.right,p.left),by + have hp := p.property + change (if step p.base then N p.left p.right else p.left=p.right) at hp + change (if step (Q.reverse p.base) then N p.right p.left else p.right=p.left) + rw [hstep] + cases hs : step p.base <;> simp only [hs, Bool.false_eq_true, ↓reduceIte] at * + · exact hp.symm + · exact hN hp⟩ + left_inv p := by apply StringArrow.ext <;> simp [StringArrow.base,StringArrow.left,StringArrow.right] + right_inv p := by apply StringArrow.ext <;> simp [StringArrow.base,StringArrow.left,StringArrow.right] } + reverse_reverse p := by + apply StringArrow.ext + · exact Q.reverse_reverse p.base + · rfl + · rfl + source_reverse p := Prod.ext (Q.source_reverse p.base) rfl + target_reverse p := Prod.ext (Q.target_reverse p.base) rfl + +abbrev StringIndex := {p : (V × J) × J // N p.1.2 p.2} + +namespace StringIndex +variable {N} +def old (i : StringIndex (V := V) N) : V × J := i.1.1 +def label (i : StringIndex (V := V) N) : J := i.1.2 +def new (i : StringIndex (V := V) N) : V × J := (i.old.1,i.label) +@[ext] lemma ext {i j : StringIndex (V := V) N} + (ho : i.old=j.old) (hl : i.label=j.label) : i=j := Subtype.ext (Prod.ext ho hl) +end StringIndex + +namespace StringFunctor + +variable [Fintype V] [Fintype B] [Fintype J] + [DecidableEq V] [DecidableEq B] [DecidableEq J] [DecidableRel N] [Field K] + +local notation "U" => Q.stringQuiver step hstep N hN +local notation "I" => StringIndex (V := V) N + +def coefficient (orient : B → Bool) (μ : J → K) (A : K) + (p : StringArrow step N) (c d : J) : K := + if step p.base then GraphConnection.crossing μ A p.left p.right c d + else if c=d then (if orient p.base then μ c / μ p.left else 1) else 0 + +noncomputable def unitImage (a : V × J) : Matrix I I (Zigzag U K) := + fun i j => if i=j ∧ i.old=a then Zigzag.vertexId U i.new else 0 + +noncomputable def tokenImage (μ : J → K) (a : V × J) : Matrix I I (Zigzag U K) := + fun i j => if i=j ∧ i.old=a then (μ i.label / μ a.2) • Zigzag.tokenBasis U i.new else 0 + +noncomputable def arrowImage (orient : B → Bool) (μ : J → K) (A : K) + (p : StringArrow step N) : Matrix I I (Zigzag U K) := + fun i j => if i.old=(U).source p ∧ j.old=(U).target p then + if h : (if step p.base then N i.label j.label else i.label=j.label) then + coefficient step N orient μ A p i.label j.label • + Zigzag.arrowBasis U (⟨(p.base,i.label,j.label),h⟩ : StringArrow step N) + else 0 + else 0 + +omit [DecidableEq B] in +lemma unitImage_mul (a : V × J) (M : Matrix I I (Zigzag U K)) + (hM : ∀ i j, Zigzag.vertexId U i.new * M i j = M i j) (i j : I) : + (unitImage (K := K) Q step hstep N hN a * M) i j = if i.old=a then M i j else 0 := by + rw [Matrix.mul_apply,Finset.sum_eq_single i] + · simp only [unitImage,true_and] + by_cases hi : i.old=a <;> simp [hi,hM] + · intro k hk hki + simp [unitImage,Ne.symm hki] + · simp + +omit [DecidableEq B] in +lemma mul_unitImage (a : V × J) (M : Matrix I I (Zigzag U K)) + (hM : ∀ i j, M i j * Zigzag.vertexId U j.new = M i j) (i j : I) : + (M * unitImage (K := K) Q step hstep N hN a) i j = if j.old=a then M i j else 0 := by + rw [Matrix.mul_apply,Finset.sum_eq_single j] + · simp only [unitImage,true_and] + by_cases hi : j.old=a <;> simp [hi,hM] + · intro k hk hkj + simp [unitImage,hkj] + · simp + +lemma arrowImage_left (orient : B → Bool) (μ : J → K) (A : K) + (p : StringArrow step N) (i j : I) : + Zigzag.vertexId U i.new * arrowImage Q step hstep N hN orient μ A p i j = + arrowImage Q step hstep N hN orient μ A p i j := by + unfold arrowImage + by_cases h : i.old=(U).source p ∧ j.old=(U).target p + swap + · rw [ite_eq_right h,mul_zero] + rw [ite_eq_left h] + by_cases h' : (if step p.base then N i.label j.label else i.label=j.label) + swap + · rw [dite_eq_right h',mul_zero] + rw [dite_eq_left h'] + rw [Algebra.mul_smul_comm] + congr 1 + let r : StringArrow step N := ⟨(p.base,i.label,j.label),h'⟩ + have hr : (U).source r=i.new := by + apply Prod.ext + · exact (congrArg Prod.fst h.1).symm + · rfl + change Zigzag.vertexId U i.new * Zigzag.arrowBasis U r = _ + rw [← hr, ← Zigzag.pathBasis_arrow] + exact Zigzag.pathBasis_left U (.inr (.inl r)) + +lemma arrowImage_right (orient : B → Bool) (μ : J → K) (A : K) + (p : StringArrow step N) (i j : I) : + arrowImage Q step hstep N hN orient μ A p i j * Zigzag.vertexId U j.new = + arrowImage Q step hstep N hN orient μ A p i j := by + unfold arrowImage + by_cases h : i.old=(U).source p ∧ j.old=(U).target p + swap + · rw [ite_eq_right h,zero_mul] + rw [ite_eq_left h] + by_cases h' : (if step p.base then N i.label j.label else i.label=j.label) + swap + · rw [dite_eq_right h',zero_mul] + rw [dite_eq_left h'] + rw [smul_mul_assoc] + congr 1 + let r : StringArrow step N := ⟨(p.base,i.label,j.label),h'⟩ + have hr : (U).target r=j.new := by + apply Prod.ext + · exact (congrArg Prod.fst h.2).symm + · rfl + change Zigzag.arrowBasis U r * Zigzag.vertexId U j.new = _ + rw [← hr, ← Zigzag.pathBasis_arrow] + exact Zigzag.pathBasis_right U (.inr (.inl r)) + +lemma unitImage_arrowImage (orient : B → Bool) (μ : J → K) (A : K) + (a : V × J) (p : StringArrow step N) : + unitImage Q step hstep N hN a * arrowImage Q step hstep N hN orient μ A p = + if (U).source p=a then arrowImage Q step hstep N hN orient μ A p else 0 := by + apply Matrix.ext + intro i j + rw [unitImage_mul Q step hstep N hN _ _ (arrowImage_left Q step hstep N hN _ _ _ _) i j] + by_cases ha : (U).source p=a + · rw [ite_eq_left ha] + by_cases hi : i.old=a + · rw [ite_eq_left hi] + · rw [ite_eq_right hi] + simp only [arrowImage] + rw [ite_eq_right (fun h => hi (h.1.trans ha))] + · rw [ite_eq_right ha] + by_cases hi : i.old=a + · rw [ite_eq_left hi] + simp only [arrowImage] + rw [ite_eq_right (fun h => ha (h.1.symm.trans hi))] + rfl + · simp only [ite_eq_right hi,Matrix.zero_apply] + +lemma arrowImage_unitImage (orient : B → Bool) (μ : J → K) (A : K) + (a : V × J) (p : StringArrow step N) : + arrowImage Q step hstep N hN orient μ A p * unitImage Q step hstep N hN a = + if (U).target p=a then arrowImage Q step hstep N hN orient μ A p else 0 := by + apply Matrix.ext + intro i j + rw [mul_unitImage Q step hstep N hN _ _ (arrowImage_right Q step hstep N hN _ _ _ _) i j] + by_cases ha : (U).target p=a + · rw [ite_eq_left ha] + by_cases hj : j.old=a + · rw [ite_eq_left hj] + · rw [ite_eq_right hj] + simp only [arrowImage] + rw [ite_eq_right (fun h => hj (h.2.trans ha))] + · rw [ite_eq_right ha] + by_cases hj : j.old=a + · rw [ite_eq_left hj] + simp only [arrowImage] + rw [ite_eq_right (fun h => ha (h.2.symm.trans hj))] + rfl + · simp only [ite_eq_right hj,Matrix.zero_apply] + +def liftIndex (a : V × J) (c : {c : J // N a.2 c}) : I := ⟨(a,c),c.property⟩ + +lemma sum_over {R : Type*} [AddCommMonoid R] (a : V × J) (f : I → R) : + (∑ i : I, if i.old=a then f i else 0) = ∑ c : {c : J // N a.2 c}, f (liftIndex N a c) := by + symm + apply Fintype.sum_of_injective (liftIndex N a) + · intro c d h + apply Subtype.ext + exact congrArg StringIndex.label h + · intro i hi + have hv : i.old ≠ a := by + intro h + apply hi + refine ⟨⟨i.label,?_⟩,?_⟩ + · rw [← h] + exact i.property + · apply StringIndex.ext + · exact h.symm + · rfl + exact ite_eq_right hv + · intro c + simp [liftIndex,StringIndex.old] + +omit [Fintype V] [Fintype B] [Fintype J] + [DecidableEq V] [DecidableEq B] [DecidableEq J] [DecidableRel N] in +@[simp] lemma reverse_base (p : StringArrow step N) : + StringArrow.base ((U).reverse p) = Q.reverse p.base := rfl +omit [Fintype V] [Fintype B] [Fintype J] + [DecidableEq V] [DecidableEq B] [DecidableEq J] [DecidableRel N] in +@[simp] lemma reverse_left (p : StringArrow step N) : + StringArrow.left ((U).reverse p) = p.right := rfl +omit [Fintype V] [Fintype B] [Fintype J] + [DecidableEq V] [DecidableEq B] [DecidableEq J] [DecidableRel N] in +@[simp] lemma reverse_right (p : StringArrow step N) : + StringArrow.right ((U).reverse p) = p.left := rfl + +omit [Fintype V] [Fintype B] [Fintype J] + [DecidableEq V] [DecidableEq B] [DecidableEq J] [DecidableRel N] in +lemma reverse_eq_iff (p q : StringArrow step N) : + (U).reverse p=q ↔ Q.reverse p.base=q.base ∧ p.right=q.left ∧ p.left=q.right := by + constructor + · intro h + exact ⟨congrArg StringArrow.base h,congrArg StringArrow.left h,congrArg StringArrow.right h⟩ + · rintro ⟨h₁,h₂,h₃⟩ + exact StringArrow.ext h₁ h₂ h₃ + +omit [Fintype V] in +lemma arrowImage_eq_zero_left (orient : B → Bool) (μ : J → K) (A : K) + (p : StringArrow step N) (i j : I) (h : i.old ≠ (U).source p) : + arrowImage Q step hstep N hN orient μ A p i j = 0 := by + exact ite_eq_right (fun h' => h h'.1) + +omit [Fintype V] in +lemma arrowImage_eq_zero_right (orient : B → Bool) (μ : J → K) (A : K) + (p : StringArrow step N) (i j : I) (h : j.old ≠ (U).target p) : + arrowImage Q step hstep N hN orient μ A p i j = 0 := by + exact ite_eq_right (fun h' => h h'.2) + +omit [Fintype V] in +lemma arrowImage_entry_mul_of_not_reverse (orient : B → Bool) (μ : J → K) (A : K) + (p q : StringArrow step N) (i j k : I) + (h : Q.reverse p.base ≠ q.base ∨ i.label ≠ k.label) : + arrowImage Q step hstep N hN orient μ A p i j * + arrowImage Q step hstep N hN orient μ A q j k = 0 := by + unfold arrowImage + by_cases hp : i.old=(U).source p ∧ j.old=(U).target p + swap + · rw [ite_eq_right hp,zero_mul] + rw [ite_eq_left hp] + by_cases hq : j.old=(U).source q ∧ k.old=(U).target q + swap + · rw [ite_eq_right hq,mul_zero] + rw [ite_eq_left hq] + by_cases hp' : (if step p.base then N i.label j.label else i.label=j.label) + swap + · rw [dite_eq_right hp',zero_mul] + rw [dite_eq_left hp'] + by_cases hq' : (if step q.base then N j.label k.label else j.label=k.label) + swap + · rw [dite_eq_right hq',mul_zero] + rw [dite_eq_left hq',smul_mul_assoc,Algebra.mul_smul_comm,Zigzag.arrowBasis_mul_arrowBasis] + have hr : (U).reverse (⟨(p.base,i.label,j.label),hp'⟩ : StringArrow step N) ≠ + ⟨(q.base,j.label,k.label),hq'⟩ := by + intro hh + rcases (reverse_eq_iff Q step hstep N hN _ _).1 hh with ⟨hb,_,hl⟩ + rcases h with h | h + · exact h hb + · exact h hl + rw [ite_eq_right hr,smul_zero,smul_zero] + +lemma arrowImage_mul_of_not_reverse_base (orient : B → Bool) (μ : J → K) (A : K) + (p q : StringArrow step N) (h : Q.reverse p.base ≠ q.base) : + arrowImage Q step hstep N hN orient μ A p * + arrowImage Q step hstep N hN orient μ A q = 0 := by + apply Matrix.ext + intro i k + rw [Matrix.mul_apply] + exact Finset.sum_eq_zero (fun j _ => arrowImage_entry_mul_of_not_reverse + Q step hstep N hN orient μ A p q i j k (Or.inl h)) + +end StringFunctor +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/TestIndex.lean b/lean/OAI/Topology/ArtinGroups/Quivers/TestIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..ef20e98e93b3017fe92138140eaa4c58189685ae --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/TestIndex.lean @@ -0,0 +1,86 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.CornerPath + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J L : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +abbrev TestIndex (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) := + (i : I) × CornerPath Q α (p i).color + +noncomputable def testMatrix (p : I → HarmonicArtin.GeneratorPlacement V) + (q : J → HarmonicArtin.GeneratorPlacement V) (α : V) + (M : Matrix I J (Q.Zigzag K)) : Matrix (TestIndex Q p α) (TestIndex Q q α) K := + fun u v => pathCoordinates Q (pathBasis Q u.2.val * M u.1 v.1) v.2.val + +omit [DecidableEq A] in +lemma testMatrix_zero (p : I → HarmonicArtin.GeneratorPlacement V) + (q : J → HarmonicArtin.GeneratorPlacement V) (α : V) : + testMatrix Q p q α (0 : Matrix I J (Q.Zigzag K)) = 0 := by + apply Matrix.ext + intro u v + exact (congrArg (fun x => pathCoordinates Q x v.2.val) + (MulZeroClass.mul_zero (pathBasis Q u.2.val))).trans (coordinates_zero Q v.2.val) + +lemma testMatrix_mul [Fintype J] + {p : I → HarmonicArtin.GeneratorPlacement V} + {q : J → HarmonicArtin.GeneratorPlacement V} + {r : L → HarmonicArtin.GeneratorPlacement V} (α : V) + {M : Matrix I J (Q.Zigzag K)} (N : Matrix J L (Q.Zigzag K)) + (hM : ProjectiveEntries Q p q M) : + testMatrix Q p q α M * testMatrix Q q r α N = testMatrix Q p r α (M * N) := by + apply Matrix.ext + intro u v + simp only [Matrix.mul_apply, Fintype.sum_sigma, testMatrix] + rw [Finset.mul_sum, coordinates_sum] + apply Finset.sum_congr rfl + intro j _ + have hl : vertexId Q α * (pathBasis Q u.2.val * M u.1 j) = + pathBasis Q u.2.val * M u.1 j := by + rw [← _root_.mul_assoc, cornerPath_left Q u.2] + have hr : (pathBasis Q u.2.val * M u.1 j) * vertexId Q (q j).color = + pathBasis Q u.2.val * M u.1 j := by + rw [_root_.mul_assoc, hM.2 u.1 j] + exact (coordinates_mul_expansion Q _ (N j v.1) hl hr v.2.val).trans + (congrArg (fun x => pathCoordinates Q x v.2.val) (_root_.mul_assoc _ _ _)) + +def scalarCornerMatrix (α : V) (M : Matrix I J K) : Matrix I J (Q.Zigzag K) := + fun i j => M i j • vertexId Q α + +omit [Fintype V] [DecidableEq A] in +lemma scalarCornerMatrix_zero (α : V) : + scalarCornerMatrix Q α (0 : Matrix I J K) = 0 := by + apply Matrix.ext + intro i j + exact zero_smul _ _ + +omit [Fintype V] [DecidableEq A] in +lemma scalarCornerMatrix_mul [Fintype J] (α : V) (M : Matrix I J K) (N : Matrix J L K) : + scalarCornerMatrix Q α M * scalarCornerMatrix Q α N = + scalarCornerMatrix Q α (M * N) := by + apply Matrix.ext + intro i k + simp only [Matrix.mul_apply, scalarCornerMatrix, smul_mul, mul_smul, vertexId_mul_self, + smul_smul, Finset.sum_smul, mul_comm] + +omit [Fintype V] [DecidableEq A] in +lemma scalarCornerMatrix_entries (α : V) + (p : I → HarmonicArtin.GeneratorPlacement V) (q : J → HarmonicArtin.GeneratorPlacement V) + (hp : ∀ i, (p i).color = α) (hq : ∀ j, (q j).color = α) (M : Matrix I J K) : + ProjectiveEntries Q p q (scalarCornerMatrix Q α M) := by + constructor + · intro i j + change vertexId Q (p i).color * (M i j • vertexId Q α) = _ + rw [hp i, mul_smul, vertexId_mul_self] + rfl + · intro i j + change (M i j • vertexId Q α) * vertexId Q (q j).color = _ + rw [hq j, smul_mul, vertexId_mul_self] + rfl + +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/TestPlacement.lean b/lean/OAI/Topology/ArtinGroups/Quivers/TestPlacement.lean new file mode 100644 index 0000000000000000000000000000000000000000..f8d75918ef573b557670a671a1bb2b03fb14dd65 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/TestPlacement.lean @@ -0,0 +1,138 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Cancellation.ScalarPivot +import OAI.Topology.ArtinGroups.Quivers.TestIndex + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +def testPlacement (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + TestIndex Q p α → HarmonicArtin.GeneratorPlacement V := + fun u => ⟨α, (p u.1).cochain, (p u.1).internal + Path.length u.2.val⟩ + +lemma testMatrix_degree {p : I → HarmonicArtin.GeneratorPlacement V} + {q : J → HarmonicArtin.GeneratorPlacement V} (α : V) + {n v : ℤ} {M : Matrix I J (Q.Zigzag K)} (hM : MapDegree Q p q n v M) : + MapDegree Q (testPlacement Q p α) (testPlacement Q q α) n v + (scalarCornerMatrix Q α (testMatrix Q p q α M)) := by + intro a b + constructor + · intro hc + change (pathCoordinates Q (pathBasis Q a.2.val * M a.1 b.1) b.2.val) • vertexId Q α = 0 + rw [(hM a.1 b.1).1 hc, MulZeroClass.mul_zero, coordinates_zero, zero_smul] + · change Homogeneous Q (v + ((p a.1).internal + Path.length a.2.val) - + ((q b.1).internal + Path.length b.2.val)) + ((pathCoordinates Q (pathBasis Q a.2.val * M a.1 b.1) b.2.val) • vertexId Q α) + by_cases hz : pathCoordinates Q (pathBasis Q a.2.val * M a.1 b.1) b.2.val = 0 + · rw [hz, zero_smul] + exact homogeneous_zero Q _ + · have he := coordinates_mul_degree Q (pathBasis_homogeneous Q a.2.val) + (hM a.1 b.1).2 hz + have hd : v + ((p a.1).internal + Path.length a.2.val) - + ((q b.1).internal + Path.length b.2.val) = 0 := by omega + rw [hd] + exact homogeneous_smul Q (homogeneous_vertexId Q α) _ + +noncomputable def evaluationMatrix (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + Matrix (TestIndex Q p α) I (Q.Zigzag K) := by + classical + exact fun u i => if u.1 = i then pathBasis Q u.2.val else 0 + +lemma evaluation_entries (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + ProjectiveEntries Q (testPlacement Q p α) p (evaluationMatrix Q p α (K := K)) := by + classical + constructor + · intro u i + dsimp only [evaluationMatrix, testPlacement] + split_ifs + · exact cornerPath_left Q u.2 + · exact MulZeroClass.mul_zero _ + · intro u i + dsimp only [evaluationMatrix] + split_ifs with h + · subst i + exact cornerPath_right Q u.2 + · exact MulZeroClass.zero_mul _ + +lemma evaluation_degree (p : I → HarmonicArtin.GeneratorPlacement V) (α : V) : + MapDegree Q (testPlacement Q p α) p 0 0 (evaluationMatrix Q p α (K := K)) := by + classical + intro u i + by_cases hi : u.1 = i + · subst i + have hev : evaluationMatrix Q p α (K := K) u u.1 = pathBasis Q u.2.val := ite_eq_left rfl + rw [hev] + constructor + · intro h + exact (h (by simp [testPlacement])).elim + · convert pathBasis_homogeneous Q (K := K) u.2.val using 1 + dsimp [testPlacement] + omega + · have hev : evaluationMatrix Q p α (K := K) u i = 0 := ite_eq_right hi + rw [hev] + exact ⟨fun _ => rfl, homogeneous_zero Q _⟩ + +omit [DecidableEq A] in +lemma evaluation_mul [Fintype I] + (p : I → HarmonicArtin.GeneratorPlacement V) + (α : V) + (M : Matrix I J (Q.Zigzag K)) (u : TestIndex Q p α) (j : J) : + (evaluationMatrix Q p α (K := K) * M) u j = pathBasis Q u.2.val * M u.1 j := by + classical + rw [Matrix.mul_apply] + simp only [evaluationMatrix, ite_mul, MulZeroClass.zero_mul] + simp + +lemma testMatrix_evaluation [Fintype J] + (p : I → HarmonicArtin.GeneratorPlacement V) + (q : J → HarmonicArtin.GeneratorPlacement V) (α : V) + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) + (u : TestIndex Q p α) (j : J) : + (scalarCornerMatrix Q α (testMatrix Q p q α M) * evaluationMatrix Q q α (K := K)) u j = + pathBasis Q u.2.val * M u.1 j := by + classical + simp only [Matrix.mul_apply, Fintype.sum_sigma, evaluationMatrix, scalarCornerMatrix, + testMatrix, mul_ite, MulZeroClass.mul_zero] + rw [Finset.sum_eq_single j] + · simp only [smul_mul, cornerPath_left] + apply sum_cornerPath Q + · rw [← _root_.mul_assoc, cornerPath_left] + · rw [_root_.mul_assoc, hM.2 u.1 j] + · intro b _ hbj + apply Finset.sum_eq_zero + intro c _ + exact ite_eq_right hbj + · simp + +namespace BasedComplex + +variable [Fintype I] + +noncomputable def testComplex (E : BasedComplex Q (K := K) I) (α : V) : + BasedComplex Q (K := K) (TestIndex Q E.placement α) where + placement := testPlacement Q E.placement α + differential := scalarCornerMatrix Q α (testMatrix Q E.placement E.placement α E.differential) + entries := scalarCornerMatrix_entries Q α _ _ (fun _ => rfl) (fun _ => rfl) _ + degree := testMatrix_degree Q α E.degree + square_zero := by + rw [scalarCornerMatrix_mul, testMatrix_mul Q α _ E.entries, E.square_zero, + testMatrix_zero, scalarCornerMatrix_zero] + +noncomputable def evaluation (E : BasedComplex Q (K := K) I) (α : V) : + Map Q (E.testComplex Q α) E where + matrix := evaluationMatrix Q E.placement α + entries := evaluation_entries Q _ α + degree := evaluation_degree Q _ α + commute := by + apply Matrix.ext + intro u i + exact (testMatrix_evaluation Q _ _ α E.entries u i).trans + (evaluation_mul Q _ α E.differential u i).symm + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/TestTransform.lean b/lean/OAI/Topology/ArtinGroups/Quivers/TestTransform.lean new file mode 100644 index 0000000000000000000000000000000000000000..0968eb3c2f08ddd45702ef30a480b34cc89ac1dc --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/TestTransform.lean @@ -0,0 +1,122 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.CotestPlacement + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J L : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + +noncomputable def testTransform (p : I → GeneratorPlacement V) + (q : J → GeneratorPlacement V) (α : V) (M : Matrix I J (Q.Zigzag K)) : + Matrix (TestIndex Q p α) (TestIndex Q q α) (Q.Zigzag K) := + scalarCornerMatrix Q α (testMatrix Q p q α M) + +lemma testTransform_mul [Fintype J] {p : I → GeneratorPlacement V} + {q : J → GeneratorPlacement V} {r : L → GeneratorPlacement V} (α : V) + {M : Matrix I J (Q.Zigzag K)} (N : Matrix J L (Q.Zigzag K)) + (hM : ProjectiveEntries Q p q M) : + testTransform Q p q α M * testTransform Q q r α N = + testTransform Q p r α (M * N) := by + unfold testTransform + rw [scalarCornerMatrix_mul, testMatrix_mul Q α N hM] + +omit [DecidableEq A] in +lemma testTransform_zero (p : I → GeneratorPlacement V) + (q : J → GeneratorPlacement V) (α : V) : + testTransform Q p q α (0 : Matrix I J (Q.Zigzag K)) = 0 := by + unfold testTransform + rw [testMatrix_zero, scalarCornerMatrix_zero] + +omit [DecidableEq A] in +lemma testTransform_add (p : I → GeneratorPlacement V) + (q : J → GeneratorPlacement V) (α : V) (M N : Matrix I J (Q.Zigzag K)) : + testTransform Q p q α (M + N) = testTransform Q p q α M + + testTransform Q p q α N := by + apply Matrix.ext + intro i j + simp only [testTransform, scalarCornerMatrix, testMatrix, Matrix.add_apply, + _root_.mul_add, coordinates_add, add_smul] + +omit [DecidableEq A] in +lemma testTransform_neg (p : I → GeneratorPlacement V) + (q : J → GeneratorPlacement V) (α : V) (M : Matrix I J (Q.Zigzag K)) : + testTransform Q p q α (-M) = -testTransform Q p q α M := by + apply Matrix.ext + intro i j + simp only [testTransform, scalarCornerMatrix, testMatrix, Matrix.neg_apply, + _root_.mul_neg, map_neg, Pi.neg_apply, neg_smul] + +lemma testTransform_identity [DecidableEq I] (p : I → GeneratorPlacement V) (α : V) : + testTransform Q p p α (projectiveIdentity Q p (K := K)) = + projectiveIdentity Q (testPlacement Q p α) := by + classical + apply Matrix.ext + intro u v + change pathCoordinates Q (pathBasis Q u.2.val * + (if u.1 = v.1 then vertexId Q (p u.1).color else 0)) v.2.val • vertexId Q α = + if u = v then vertexId Q α else 0 + by_cases hi : u.1 = v.1 + · rcases u with ⟨i, u⟩ + rcases v with ⟨j, v⟩ + dsimp only at hi + subst j + dsimp only + simp only [ite_true, cornerPath_right, pathBasis_coordinates] + by_cases hp : u = v + · subst v + simp + · have hv : u.val ≠ v.val := fun h => hp (Subtype.ext h) + simp [hp, hv] + · simp only [ite_eq_right hi, MulZeroClass.mul_zero, coordinates_zero, zero_smul] + have huv : u ≠ v := fun h => hi (congrArg Sigma.fst h) + exact (ite_eq_right huv).symm + +lemma evaluation_natural [Fintype I] [Fintype J] + {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} (α : V) + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) : + testTransform Q p q α M * evaluationMatrix Q q α (K := K) = + evaluationMatrix Q p α (K := K) * M := by + apply Matrix.ext + intro u j + exact (testMatrix_evaluation Q p q α hM u j).trans (evaluation_mul Q p α M u j).symm + +lemma coevaluation_natural [Fintype I] [Fintype J] + {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} (α : V) + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) : + coevaluationMatrix Q p α (K := K) * testTransform Q p q α M = + M * coevaluationMatrix Q q α (K := K) := by + apply Matrix.ext + intro i u + exact (coevaluation_testMatrix Q p q α hM i u).trans (mul_coevaluation Q q α M i u).symm + +namespace BasedComplex.Map + +variable [Fintype I] [Fintype J] + {E : BasedComplex Q (K := K) I} {F : BasedComplex Q (K := K) J} + +noncomputable def test (f : Map Q E F) (α : V) : + Map Q (E.testComplex Q α) (F.testComplex Q α) where + matrix := testTransform Q E.placement F.placement α f.matrix + entries := scalarCornerMatrix_entries Q α _ _ (fun _ => rfl) (fun _ => rfl) _ + degree := testMatrix_degree Q α f.degree + commute := by + change testTransform Q _ _ α E.differential * _ = + _ * testTransform Q _ _ α F.differential + rw [testTransform_mul Q α _ E.entries, testTransform_mul Q α _ f.entries, f.commute] + +noncomputable def cotest (f : Map Q E F) (α : V) : + Map Q (E.cotestComplex Q α) (F.cotestComplex Q α) where + matrix := testTransform Q E.placement F.placement α f.matrix + entries := scalarCornerMatrix_entries Q α _ _ (fun _ => rfl) (fun _ => rfl) _ + degree := cotestMatrix_degree Q α f.degree + commute := by + change testTransform Q _ _ α E.differential * _ = + _ * testTransform Q _ _ α F.differential + rw [testTransform_mul Q α _ E.entries, testTransform_mul Q α _ f.entries, f.commute] + +end BasedComplex.Map +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/TokenTestVector.lean b/lean/OAI/Topology/ArtinGroups/Quivers/TokenTestVector.lean new file mode 100644 index 0000000000000000000000000000000000000000..430611e8d97acd7a50edaa8918e45223aecbdd4d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/TokenTestVector.lean @@ -0,0 +1,217 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.CornerPath +import OAI.Topology.ArtinGroups.Complexes.CoefficientTopDual +import OAI.Topology.ArtinGroups.Diagrams.SupportedKernel + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K I : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] [Fintype I] + +omit [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] in +lemma corner_length_two {α β : V} (p : CornerPath Q α β) (h : Path.length p.val=2) : + p.val = Sum.inr (Sum.inr α) := by + rcases p with ⟨p,hs,ht⟩ + rcases p with v|a|v + · norm_num [Path.length] at h + · norm_num [Path.length] at h + · exact congrArg (fun v => Sum.inr (Sum.inr v)) hs + +lemma token_coordinates (α : V) (p : Path V A) : + pathCoordinates Q (tokenBasis Q (K := K) α) p = if Sum.inr (Sum.inr α)=p then 1 else 0 := by + rw [← pathBasis_token,pathBasis_coordinates] + +noncomputable def tokenTestVector (p : I → GeneratorPlacement V) (α : V) : + (I → K) →ₗ[K] (TestIndex Q p α → K) where + toFun x i := x i.1 * pathCoordinates Q (tokenBasis Q α) i.2.val + map_add' x y := by funext i; exact _root_.add_mul _ _ _ + map_smul' r x := by funext i; exact _root_.mul_assoc _ _ _ + +noncomputable def sumTokenTest (p : I → GeneratorPlacement V) (α : V) : + (TestIndex Q p α → K) →ₗ[K] (I → K) where + toFun x i := ∑ z : CornerPath Q α (p i).color, x ⟨i,z⟩ + map_add' x y := by funext i; exact Finset.sum_add_distrib + map_smul' r x := by funext i; exact (Finset.mul_sum _ _ _).symm + +omit [Fintype I] [DecidableEq A] in +lemma sumTokenTest_support (p : I → GeneratorPlacement V) (α : V) (c : ℤ) + (x : TestIndex Q p α → K) + (hx : ∀ i, ¬ ((p i.1).cochain=c ∧ Path.length i.2.val=2) → x i=0) : + ∀ i, (p i).color ≠ α ∨ (p i).cochain ≠ c → sumTokenTest Q p α x i=0 := by + intro i hi + apply Finset.sum_eq_zero + intro z hz + apply hx + rintro ⟨hc,hl⟩ + rcases hi with hi|hi + · apply hi + have he := corner_length_two Q z hl + have ht := z.property.2 + rw [he] at ht + exact ht.symm + · exact hi hc + +omit [Fintype I] in +lemma tokenTestVector_sum (p : I → GeneratorPlacement V) (α : V) (c : ℤ) + (x : TestIndex Q p α → K) + (hx : ∀ i, ¬ ((p i.1).cochain=c ∧ Path.length i.2.val=2) → x i=0) : + tokenTestVector Q p α (sumTokenTest Q p α x) = x := by + funext i + change (∑ z : CornerPath Q α (p i.1).color, x ⟨i.1,z⟩) * + pathCoordinates Q (tokenBasis Q α) i.2.val = x i + by_cases hl : Path.length i.2.val=2 + · have he := corner_length_two Q i.2 hl + rw [token_coordinates,ite_eq_left he.symm,_root_.mul_one] + apply Finset.sum_eq_single i.2 + · intro z hz hzi + apply hx + rintro ⟨hc,hzlen⟩ + apply hzi + apply Subtype.ext + exact (corner_length_two Q z hzlen).trans he.symm + · simp + · rw [hx i (fun h => hl h.2)] + rw [token_coordinates,ite_eq_right (fun he => hl (by rw [← he]; rfl)),MulZeroClass.mul_zero] + +omit [Fintype I] in +lemma sumTokenTest_unit (p : I → GeneratorPlacement V) (α : V) + (x : I → K) (hx : ∀ i, (p i).color≠α → x i=0) : + sumTokenTest Q p α (tokenTestVector Q p α x)=x := by + funext i + by_cases hi : (p i).color=α + · let z : CornerPath Q α (p i).color := ⟨Sum.inr (Sum.inr α),rfl,hi.symm⟩ + change (∑ w : CornerPath Q α (p i).color, x i * pathCoordinates Q (tokenBasis Q α) w.val)=x i + rw [Finset.sum_eq_single z] + · rw [token_coordinates,ite_eq_left rfl,_root_.mul_one] + · intro w hw hwz + rw [token_coordinates,ite_eq_right (fun he => hwz (Subtype.ext he.symm)),MulZeroClass.mul_zero] + · simp + · change (∑ w : CornerPath Q α (p i).color, x i * pathCoordinates Q (tokenBasis Q α) w.val)=x i + rw [hx i hi] + simp + +omit [DecidableEq A] in +lemma trace_left_corner {α : V} (x : Zigzag Q K) (hx : vertexId Q α * x=x) : + trace Q x=x.token α := by + unfold trace + apply Finset.sum_eq_single α + · intro β hβ hβα + have hh := coordinates_vertexId_left Q α x (Sum.inr (Sum.inr β)) + rw [hx] at hh + simpa [Path.source,pathCoordinates_token,hβα,Ne.symm hβα] using hh + · simp + +lemma token_path_mul {α β : V} (p : CornerPath Q α β) (x : Zigzag Q K) : + (pathBasis Q p.val*x).token α=pathCoordinates Q x (Path.dual Q p.val) := by + rw [coordinates_trace,Path.dual_dual,trace_mul_comm] + symm + apply trace_left_corner + rw [← _root_.mul_assoc,cornerPath_left] + +lemma tokenTestVector_differential (E : BasedComplex Q (K := K) I) (α:V) + (x : I → K) (hx : ∀ i, (E.placement i).color≠α → x i=0) + (i : TestIndex Q E.placement α) : + Matrix.vecMul (tokenTestVector Q E.placement α x) + (testMatrix Q E.placement E.placement α E.differential).transpose i = + ∑ j, x j * pathCoordinates Q (E.differential i.1 j) (Path.dual Q i.2.val) := by + change (∑ z : TestIndex Q E.placement α, x z.1 * pathCoordinates Q (tokenBasis Q α) z.2.val * + pathCoordinates Q (pathBasis Q i.2.val * E.differential i.1 z.1) z.2.val)=_ + rw [Fintype.sum_sigma] + apply Finset.sum_congr rfl + intro j hj + by_cases hc : (E.placement j).color=α + · let z : CornerPath Q α (E.placement j).color := ⟨Sum.inr (Sum.inr α),rfl,hc.symm⟩ + rw [Finset.sum_eq_single z] + · rw [token_coordinates,ite_eq_left rfl,_root_.mul_one] + change x j * (pathBasis Q i.2.val * E.differential i.1 j).token α = _ + rw [token_path_mul] + · intro w hw hwz + rw [token_coordinates,ite_eq_right (fun he => hwz (Subtype.ext he.symm)), + MulZeroClass.mul_zero,MulZeroClass.zero_mul] + · simp + · simp only [hx j hc,MulZeroClass.zero_mul,Finset.sum_const_zero] + +namespace BasedComplex + +noncomputable def topTestCycles (E : BasedComplex Q (K := K) I) (α:V) (c:ℤ) := + ScalarCycles.supportedKernel (testMatrix Q E.placement E.placement α E.differential).transpose + (fun i => (E.placement i.1).cochain=c ∧ Path.length i.2.val=2) + +lemma tokenTestVector_top (E : BasedComplex Q (K := K) I) {l : ℤ} + (hE : ∀ i, (E.placement i).level=l) (α:V) (c:ℤ) + {x : I → K} (hx : x ∈ coefficientTopDual Q E α c) : + tokenTestVector Q E.placement α x ∈ topTestCycles Q E α c := by + constructor + · intro i hi + change x i.1 * pathCoordinates Q (tokenBasis Q α) i.2.val=0 + by_cases hc : (E.placement i.1).cochain=c + · have hl : Path.length i.2.val≠2 := fun h => hi ⟨hc,h⟩ + rw [token_coordinates,ite_eq_right (fun he => hl (by rw [← he]; rfl)),MulZeroClass.mul_zero] + · rw [hx.1 i.1 (Or.inr hc),MulZeroClass.zero_mul] + · funext i + rw [tokenTestVector_differential Q E α x (fun i h => hx.1 i (Or.inl h))] + rcases i with ⟨i,⟨p,hs,ht⟩⟩ + rcases p with v|a|v + · apply Finset.sum_eq_zero + intro j hj + change x j * (E.differential i j).token v=0 + rw [(pure_differential_linear Q E hE i j).2] + simp + · simpa only [Path.dual,pathCoordinates_arrow,mul_comm,Pi.zero_apply] using hx.2 i (Q.reverse a) + · apply Finset.sum_eq_zero + intro j hj + change x j * (E.differential i j).vertex v=0 + rw [(pure_differential_linear Q E hE i j).1] + simp + +lemma sumTokenTest_top (E : BasedComplex Q (K := K) I) (α:V) (c:ℤ) + {x : TestIndex Q E.placement α → K} (hx : x ∈ topTestCycles Q E α c) : + sumTokenTest Q E.placement α x ∈ coefficientTopDual Q E α c := by + have hs := sumTokenTest_support Q E.placement α c x hx.1 + constructor + · exact hs + · intro i a + by_cases ha : Q.target a=α + · by_cases ht : Q.source a=(E.placement i).color + · let z : TestIndex Q E.placement α := ⟨i,Sum.inr (Sum.inl (Q.reverse a)), + (Q.source_reverse a).trans ha,(Q.target_reverse a).trans ht⟩ + have hh := tokenTestVector_differential Q E α (sumTokenTest Q E.placement α x) + (fun j h => hs j (Or.inl h)) z + rw [tokenTestVector_sum Q E.placement α c x hx.1,hx.2] at hh + simpa only [z,Path.dual,Q.reverse_reverse,pathCoordinates_arrow,mul_comm,Pi.zero_apply] using hh.symm + · apply Finset.sum_eq_zero + intro j hj + have hz : (E.differential i j).arrow a=0 := by + by_contra hn + exact ht (coordinates_corner Q (p := Sum.inr (Sum.inl a)) + (E.entries.1 i j) (E.entries.2 i j) hn).1 + rw [hz,MulZeroClass.zero_mul] + · apply Finset.sum_eq_zero + intro j hj + by_cases hjc : (E.placement j).color=α + · have hz : (E.differential i j).arrow a=0 := by + by_contra hn + exact ha ((coordinates_corner Q (p := Sum.inr (Sum.inl a)) + (E.entries.1 i j) (E.entries.2 i j) hn).2.trans hjc) + rw [hz,MulZeroClass.zero_mul] + · rw [hs j (Or.inl hjc),MulZeroClass.mul_zero] + +noncomputable def coefficientTopTestEquiv (E : BasedComplex Q (K := K) I) {l : ℤ} + (hE : ∀ i, (E.placement i).level=l) (α:V) (c:ℤ) : + coefficientTopDual Q E α c ≃ₗ[K] topTestCycles Q E α c where + toFun x := ⟨tokenTestVector Q E.placement α x.val,tokenTestVector_top Q E hE α c x.property⟩ + invFun y := ⟨sumTokenTest Q E.placement α y.val,sumTokenTest_top Q E α c y.property⟩ + left_inv x := by + apply Subtype.ext + exact sumTokenTest_unit Q E.placement α x.val (fun i h => x.property.1 i (Or.inl h)) + right_inv y := by + apply Subtype.ext + exact tokenTestVector_sum Q E.placement α c y.val y.property.1 + map_add' x y := by apply Subtype.ext; exact map_add _ _ _ + map_smul' r x := by apply Subtype.ext; exact map_smul _ _ _ + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/TraceLinear.lean b/lean/OAI/Topology/ArtinGroups/Quivers/TraceLinear.lean new file mode 100644 index 0000000000000000000000000000000000000000..f9087977617e52076ef5318740f9c7eb66d753c1 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/TraceLinear.lean @@ -0,0 +1,100 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.HomSpace + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] + +lemma trace_smul (r : K) (x : Q.Zigzag K) : trace Q (r • x) = r * trace Q x := by + simp only [trace, token_smul, Pi.smul_apply, smul_eq_mul, Finset.mul_sum] + +def traceLinear : Q.Zigzag K →ₗ[K] K where + toFun := trace Q + map_add' := trace_add Q + map_smul' := by intro r x; exact trace_smul Q r x + +namespace BasedComplex +variable [Fintype I] [Fintype J] + +noncomputable def homCycles (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) + (n v : ℤ) : Submodule K (Matrix I J (Q.Zigzag K)) := + homSpace Q E F n v ⊓ LinearMap.ker (homDifferential Q E F n) + +noncomputable def homBoundaries (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) + (n v : ℤ) : Submodule K (Matrix I J (Q.Zigzag K)) := + (homSpace Q E F (n - 1) v).map (homDifferential Q E F (n - 1)) + +omit [Fintype V] in +lemma homBoundaries_le_homCycles (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (n v : ℤ) : + homBoundaries Q E F n v ≤ homCycles Q E F n v := by + rintro _ ⟨f, hf, rfl⟩ + constructor + · change homDifferential Q E F (n - 1) f ∈ homSpace Q E F n v + have hd := homDifferential_mem Q E F (n - 1) v hf + rw [sub_add_cancel] at hd + exact hd + · change homDifferential Q E F n (homDifferential Q E F (n - 1) f) = 0 + simpa only [sub_add_cancel] using homDifferential_square_zero Q E F (n - 1) f + +abbrev homCohomology (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) + (n v : ℤ) := + homCycles Q E F n v ⧸ + (homBoundaries Q E F n v).comap (homCycles Q E F n v).subtype + +noncomputable def supertrace (E : BasedComplex Q (K := K) I) : + Matrix I I (Q.Zigzag K) →ₗ[K] K where + toFun f := ∑ i, cochainSign (K := K) (E.placement i).cochain * trace Q (f i i) + map_add' f g := by + simp only [Matrix.add_apply, trace_add, _root_.mul_add, Finset.sum_add_distrib] + map_smul' r f := by + simp only [Matrix.smul_apply, smul_eq_mul, RingHom.id_apply, trace_smul, Finset.mul_sum] + apply Finset.sum_congr rfl + intro i _ + ring + +lemma supertrace_mul (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) {n v : ℤ} + {f : Matrix I J (Q.Zigzag K)} (hf : MapDegree Q E.placement F.placement n v f) + (g : Matrix J I (Q.Zigzag K)) : + supertrace Q F (g * f) = cochainSign (K := K) n * supertrace Q E (f * g) := by + change (∑ j, cochainSign (K := K) _ * traceLinear Q (∑ i, g j i * f i j)) = + cochainSign (K := K) n * ∑ i, cochainSign (K := K) _ * traceLinear Q (∑ j, f i j * g j i) + simp only [map_sum, Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro i _ + apply Finset.sum_congr rfl + intro j _ + by_cases hc : (F.placement j).cochain = (E.placement i).cochain + n + · change cochainSign (K := K) _ * trace Q (g j i * f i j) = + cochainSign (K := K) n * (cochainSign (K := K) _ * trace Q (f i j * g j i)) + rw [hc, cochainSign_add, trace_mul_comm Q (g j i)] + ring + · rw [(hf i j).1 hc, MulZeroClass.mul_zero, MulZeroClass.zero_mul, + map_zero, MulZeroClass.mul_zero, MulZeroClass.mul_zero] + exact (MulZeroClass.mul_zero _).symm + +lemma supertrace_boundary (E : BasedComplex Q (K := K) I) + (h : Matrix I I (Q.Zigzag K)) : + supertrace Q E (homDifferential Q E E (-1) h) = 0 := by + have hs : cochainSign (K := K) (-1) = -1 := by norm_num [cochainSign] + have hp : cochainSign (K := K) 1 = -1 := by norm_num [cochainSign] + change supertrace Q E (E.differential * h - cochainSign (K := K) (-1) • (h * E.differential)) = 0 + have hcyc := supertrace_mul Q E E E.degree h + rw [hp] at hcyc + calc + _ = supertrace Q E (E.differential * h) - + cochainSign (K := K) (-1) * supertrace Q E (h * E.differential) := by + exact (supertrace Q E).map_sub _ _ |>.trans + (congrArg (fun z => supertrace Q E (E.differential * h) - z) + ((supertrace Q E).map_smul_of_tower (cochainSign (K := K) (-1)) (h * E.differential))) + _ = 0 := by rw [hs, hcyc]; ring + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/UnitTestVector.lean b/lean/OAI/Topology/ArtinGroups/Quivers/UnitTestVector.lean new file mode 100644 index 0000000000000000000000000000000000000000..5f3fe4df9d1e7c040c5366fc0bbf94f40a6e6569 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/UnitTestVector.lean @@ -0,0 +1,185 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.CornerPath +import OAI.Topology.ArtinGroups.Complexes.CoefficientTopDual +import OAI.Topology.ArtinGroups.Diagrams.SupportedKernel + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K I : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] [Fintype I] + +omit [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] in +lemma corner_length_zero {α β : V} (p : CornerPath Q α β) (h : Path.length p.val=0) : + p.val = Sum.inl α := by + rcases p with ⟨p,hs,ht⟩ + rcases p with v|a|v + · exact congrArg Sum.inl hs + · norm_num [Path.length] at h + · norm_num [Path.length] at h + +lemma vertex_coordinates (α : V) (p : Path V A) : + pathCoordinates Q (vertexId Q (K := K) α) p = if Sum.inl α=p then 1 else 0 := by + rw [← pathBasis_vertex,pathBasis_coordinates] + +noncomputable def unitTestVector (p : I → GeneratorPlacement V) (α : V) : + (I → K) →ₗ[K] (TestIndex Q p α → K) where + toFun x i := x i.1 * pathCoordinates Q (vertexId Q α) i.2.val + map_add' x y := by funext i; exact _root_.add_mul _ _ _ + map_smul' r x := by funext i; exact _root_.mul_assoc _ _ _ + +noncomputable def sumUnitTest (p : I → GeneratorPlacement V) (α : V) : + (TestIndex Q p α → K) →ₗ[K] (I → K) where + toFun x i := ∑ z : CornerPath Q α (p i).color, x ⟨i,z⟩ + map_add' x y := by funext i; exact Finset.sum_add_distrib + map_smul' r x := by funext i; exact (Finset.mul_sum _ _ _).symm + +omit [Fintype I] [DecidableEq A] in +lemma sumUnitTest_support (p : I → GeneratorPlacement V) (α : V) (c : ℤ) + (x : TestIndex Q p α → K) + (hx : ∀ i, ¬ ((p i.1).cochain=c ∧ Path.length i.2.val=0) → x i=0) : + ∀ i, (p i).color ≠ α ∨ (p i).cochain ≠ c → sumUnitTest Q p α x i=0 := by + intro i hi + apply Finset.sum_eq_zero + intro z hz + apply hx + rintro ⟨hc,hl⟩ + rcases hi with hi|hi + · apply hi + have he := corner_length_zero Q z hl + have ht := z.property.2 + rw [he] at ht + exact ht.symm + · exact hi hc + +omit [Fintype I] in +lemma unitTestVector_sum (p : I → GeneratorPlacement V) (α : V) (c : ℤ) + (x : TestIndex Q p α → K) + (hx : ∀ i, ¬ ((p i.1).cochain=c ∧ Path.length i.2.val=0) → x i=0) : + unitTestVector Q p α (sumUnitTest Q p α x) = x := by + funext i + change (∑ z : CornerPath Q α (p i.1).color, x ⟨i.1,z⟩) * + pathCoordinates Q (vertexId Q α) i.2.val = x i + by_cases hl : Path.length i.2.val=0 + · have he := corner_length_zero Q i.2 hl + rw [vertex_coordinates,ite_eq_left he.symm,_root_.mul_one] + apply Finset.sum_eq_single i.2 + · intro z hz hzi + apply hx + rintro ⟨hc,hzlen⟩ + apply hzi + apply Subtype.ext + exact (corner_length_zero Q z hzlen).trans he.symm + · simp + · rw [hx i (fun h => hl h.2)] + rw [vertex_coordinates,ite_eq_right (fun he => hl (by rw [← he]; rfl)),MulZeroClass.mul_zero] + +omit [Fintype I] in +lemma sumUnitTest_unit (p : I → GeneratorPlacement V) (α : V) + (x : I → K) (hx : ∀ i, (p i).color≠α → x i=0) : + sumUnitTest Q p α (unitTestVector Q p α x)=x := by + funext i + by_cases hi : (p i).color=α + · let z : CornerPath Q α (p i).color := ⟨Sum.inl α,rfl,hi.symm⟩ + change (∑ w : CornerPath Q α (p i).color, x i * pathCoordinates Q (vertexId Q α) w.val)=x i + rw [Finset.sum_eq_single z] + · rw [vertex_coordinates,ite_eq_left rfl,_root_.mul_one] + · intro w hw hwz + rw [vertex_coordinates,ite_eq_right (fun he => hwz (Subtype.ext he.symm)),MulZeroClass.mul_zero] + · simp + · change (∑ w : CornerPath Q α (p i).color, x i * pathCoordinates Q (vertexId Q α) w.val)=x i + rw [hx i hi] + simp + +omit [DecidableEq A] in +lemma unitTestVector_differential (E : BasedComplex Q (K := K) I) (α:V) + (x : I → K) (hx : ∀ i, (E.placement i).color≠α → x i=0) + (j : TestIndex Q E.placement α) : + Matrix.vecMul (unitTestVector Q E.placement α x) + (testMatrix Q E.placement E.placement α E.differential) j = + ∑ i, x i * pathCoordinates Q (E.differential i j.1) j.2.val := by + change (∑ z : TestIndex Q E.placement α, x z.1 * pathCoordinates Q (vertexId Q α) z.2.val * + pathCoordinates Q (pathBasis Q z.2.val * E.differential z.1 j.1) j.2.val)=_ + rw [Fintype.sum_sigma] + apply Finset.sum_congr rfl + intro i hi + by_cases hc : (E.placement i).color=α + · simp only [_root_.mul_assoc,← Finset.mul_sum] + rw [coordinates_mul_expansion Q (vertexId Q α) (E.differential i j.1) + (vertexId_mul_self Q α) (by rw [hc]; exact vertexId_mul_self Q α)] + have heq := E.entries.1 i j.1 + rw [hc] at heq + rw [heq] + · simp only [hx i hc,MulZeroClass.zero_mul,Finset.sum_const_zero] + +namespace BasedComplex + +noncomputable def socleTestCycles (E : BasedComplex Q (K := K) I) (α:V) (c:ℤ) := + ScalarCycles.supportedKernel (testMatrix Q E.placement E.placement α E.differential) + (fun i => (E.placement i.1).cochain=c ∧ Path.length i.2.val=0) + +lemma unitTestVector_socle (E : BasedComplex Q (K := K) I) {l : ℤ} + (hE : ∀ i, (E.placement i).level=l) (α:V) (c:ℤ) + {x : I → K} (hx : x ∈ coefficientSocle Q E α c) : + unitTestVector Q E.placement α x ∈ socleTestCycles Q E α c := by + constructor + · intro i hi + change x i.1 * pathCoordinates Q (vertexId Q α) i.2.val=0 + by_cases hc : (E.placement i.1).cochain=c + · have hl : Path.length i.2.val≠0 := fun h => hi ⟨hc,h⟩ + rw [vertex_coordinates,ite_eq_right (fun he => hl (by rw [← he]; rfl)),MulZeroClass.mul_zero] + · rw [hx.1 i.1 (Or.inr hc),MulZeroClass.zero_mul] + · funext j + rw [unitTestVector_differential Q E α x (fun i h => hx.1 i (Or.inl h))] + rcases j with ⟨j,⟨p,hs,ht⟩⟩ + rcases p with v|a|v + · apply Finset.sum_eq_zero + intro i hi + change x i * (E.differential i j).vertex v=0 + rw [(pure_differential_linear Q E hE i j).1] + simp + · exact hx.2 j a hs + · apply Finset.sum_eq_zero + intro i hi + change x i * (E.differential i j).token v=0 + rw [(pure_differential_linear Q E hE i j).2] + simp + +lemma sumUnitTest_socle (E : BasedComplex Q (K := K) I) (α:V) (c:ℤ) + {x : TestIndex Q E.placement α → K} (hx : x ∈ socleTestCycles Q E α c) : + sumUnitTest Q E.placement α x ∈ coefficientSocle Q E α c := by + have hs := sumUnitTest_support Q E.placement α c x hx.1 + constructor + · exact hs + · intro j a ha + by_cases ht : Q.target a=(E.placement j).color + · let z : TestIndex Q E.placement α := ⟨j,Sum.inr (Sum.inl a),ha,ht⟩ + have hh := unitTestVector_differential Q E α (sumUnitTest Q E.placement α x) + (fun i h => hs i (Or.inl h)) z + rw [unitTestVector_sum Q E.placement α c x hx.1,hx.2] at hh + exact hh.symm + · apply Finset.sum_eq_zero + intro i hi + have hz : (E.differential i j).arrow a=0 := by + by_contra hn + exact ht (coordinates_corner Q (p := Sum.inr (Sum.inl a)) (E.entries.1 i j) (E.entries.2 i j) hn).2 + rw [hz,MulZeroClass.mul_zero] + +noncomputable def coefficientSocleTestEquiv (E : BasedComplex Q (K := K) I) {l : ℤ} + (hE : ∀ i, (E.placement i).level=l) (α:V) (c:ℤ) : + coefficientSocle Q E α c ≃ₗ[K] socleTestCycles Q E α c where + toFun x := ⟨unitTestVector Q E.placement α x.val,unitTestVector_socle Q E hE α c x.property⟩ + invFun y := ⟨sumUnitTest Q E.placement α y.val,sumUnitTest_socle Q E α c y.property⟩ + left_inv x := by + apply Subtype.ext + exact sumUnitTest_unit Q E.placement α x.val (fun i h => x.property.1 i (Or.inl h)) + right_inv y := by + apply Subtype.ext + exact unitTestVector_sum Q E.placement α c y.val y.property.1 + map_add' x y := by apply Subtype.ext; exact map_add _ _ _ + map_smul' r x := by apply Subtype.ext; exact map_smul _ _ _ + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/VertexHom.lean b/lean/OAI/Topology/ArtinGroups/Quivers/VertexHom.lean new file mode 100644 index 0000000000000000000000000000000000000000..6a0244a7274f3d138f7037252e05217745bb5534 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/VertexHom.lean @@ -0,0 +1,98 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.ReversibleQuiver + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver +namespace Zigzag + +variable {V A K : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype A] [DecidableEq V] + +def vertexHom (v : V) : Q.Zigzag K →+* K where + toFun x := x.vertex v + map_one' := rfl + map_mul' _ _ := rfl + map_zero' := rfl + map_add' _ _ := rfl + +def vertexId (v : V) : Q.Zigzag K := (Pi.single v 1, 0, 0) + +omit [Fintype A] in +@[simp] theorem vertex_vertexId (v : V) : + (vertexId Q v).vertex = Pi.single v (1 : K) := rfl +omit [Fintype A] in +@[simp] theorem arrow_vertexId (v : V) : + (vertexId Q (K := K) v).arrow = 0 := rfl +omit [Fintype A] in +@[simp] theorem token_vertexId (v : V) : + (vertexId Q (K := K) v).token = 0 := rfl + +@[simp] theorem vertexId_mul_self (v : V) : + vertexId Q (K := K) v * vertexId Q v = vertexId Q v := by + apply Zigzag.ext + · ext w + by_cases h : w = v <;> simp [h] + · ext a + simp [arrow_mul, leftScale, rightScale] + · ext w + simp [token_mul] + +variable {I J L N : Type*} [Fintype I] [Fintype J] [Fintype L] + +def PositiveMatrix (M : Matrix I J (Q.Zigzag K)) : Prop := + ∀ i j, (M i j).vertex = 0 + +omit [Fintype I] [Fintype J] in +lemma positiveMatrix_add {M N : Matrix I J (Q.Zigzag K)} + (hM : PositiveMatrix Q M) (hN : PositiveMatrix Q N) : + PositiveMatrix Q (M + N) := by + intro i j + simp [hM i j, hN i j] + +omit [Fintype I] [Fintype L] in +lemma positiveMatrix_mul_left (M : Matrix I J (Q.Zigzag K)) + {N : Matrix J L (Q.Zigzag K)} (hN : PositiveMatrix Q N) : + PositiveMatrix Q (M * N) := by + intro i l + funext v + change (vertexHom Q (K := K) v) ((M * N) i l) = 0 + simp only [Matrix.mul_apply, map_sum, map_mul] + apply Finset.sum_eq_zero + intro j _ + change (M i j).vertex v * (N j l).vertex v = 0 + simp [hN j l] + +omit [Fintype I] [Fintype L] in +lemma positiveMatrix_mul_right {M : Matrix I J (Q.Zigzag K)} + (hM : PositiveMatrix Q M) (N : Matrix J L (Q.Zigzag K)) : + PositiveMatrix Q (M * N) := by + intro i l + funext v + change (vertexHom Q (K := K) v) ((M * N) i l) = 0 + simp only [Matrix.mul_apply, map_sum, map_mul] + apply Finset.sum_eq_zero + intro j _ + change (M i j).vertex v * (N j l).vertex v = 0 + simp [hM i j] + +omit [Fintype I] in + +lemma positiveMatrix_triple + (M : Matrix I J (Q.Zigzag K)) (N' : Matrix J L (Q.Zigzag K)) + (P : Matrix L N (Q.Zigzag K)) (hM : PositiveMatrix Q M) + (hN : PositiveMatrix Q N') (hP : PositiveMatrix Q P) : + M * N' * P = 0 := by + apply Matrix.ext + intro i n + simp only [Matrix.mul_apply, Finset.sum_mul, Matrix.zero_apply] + apply Finset.sum_eq_zero + intro l _ + apply Finset.sum_eq_zero + intro j _ + exact positive_triple_mul Q (M i j) (N' j l) (P l n) (hM i j) (hN j l) (hP l n) + +end Zigzag +end HarmonicArtin.ReversibleQuiver + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/VertexIdMulPath.lean b/lean/OAI/Topology/ArtinGroups/Quivers/VertexIdMulPath.lean new file mode 100644 index 0000000000000000000000000000000000000000..0fbedac6e86ab1d6b840125f9a11379a86861655 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/VertexIdMulPath.lean @@ -0,0 +1,81 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Coxeter.BraidCoreFirstTarget + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V B K : Type*} (Q : ReversibleQuiver V B) + [Field K] [Fintype V] [Fintype B] [DecidableEq V] [DecidableEq B] + +lemma vertexId_mul_pathBasis (v : V) (p : Path V B) : + vertexId Q v * pathBasis Q (K := K) p = + if Path.source Q p = v then pathBasis Q p else 0 := by + apply (pathCoordinates Q).injective + funext q + rw [coordinates_vertexId_left] + by_cases h : Path.source Q p=v + · rw [ite_eq_left h] + by_cases hpq : p=q + · subst q; rw [ite_eq_left h] + · simp [pathBasis_coordinates,hpq] + · rw [ite_eq_right h, map_zero] + by_cases hpq : p=q + · subst q; simp [h] + · simp [pathBasis_coordinates,hpq] + +lemma pathBasis_mul_vertexId (v : V) (p : Path V B) : + pathBasis Q (K := K) p * vertexId Q v = + if Path.target Q p = v then pathBasis Q p else 0 := by + apply (pathCoordinates Q).injective + funext q + rw [coordinates_vertexId_right] + by_cases h : Path.target Q p=v + · rw [ite_eq_left h] + by_cases hpq : p=q + · subst q; rw [ite_eq_left h] + · simp [pathBasis_coordinates,hpq] + · rw [ite_eq_right h, map_zero] + by_cases hpq : p=q + · subst q; simp [h] + · simp [pathBasis_coordinates,hpq] + +omit [Fintype V] in +lemma arrowBasis_mul_arrowBasis (a b : B) : + arrowBasis Q (K := K) a * arrowBasis Q b = + if Q.reverse a = b then tokenBasis Q (Q.source a) else 0 := by + by_cases hr : Q.reverse a=b + · subst b + rw [ite_eq_left rfl] + exact BasedComplex.arrowBasis_reverse Q a + · rw [ite_eq_right hr] + apply Zigzag.ext + · rw [vertex_mul, vertex_zero] + funext v + simp [arrowBasis,vertex] + · rw [arrow_mul, arrow_zero] + funext e + simp [arrowBasis,vertex,arrow,leftScale,rightScale] + · rw [token_mul, token_zero] + funext v + simp only [arrowBasis,vertex,arrow,token, + Pi.add_apply,Pi.mul_apply,Pi.zero_apply] + simp only [backtrack,Pi.single_apply] + rw [Finset.sum_eq_single a] + · simp [hr] + · intro e he hea + simp [hea] + · simp + +omit [DecidableEq B] in +lemma map_mul_of_pathBasis {R : Type*} [Ring R] [Algebra K R] + (f : Q.Zigzag K →ₗ[K] R) + (hf : ∀ p q, f (pathBasis Q p * pathBasis Q q)=f (pathBasis Q p)*f (pathBasis Q q)) + (x y : Q.Zigzag K) : f (x*y)=f x*f y := by + conv_lhs => rw [← sum_pathBasis Q x, ← sum_pathBasis Q y] + conv_rhs => rw [← sum_pathBasis Q x, ← sum_pathBasis Q y] + simp only [Finset.sum_mul,Finset.mul_sum,smul_mul_assoc, + map_sum,map_smul,hf,Algebra.mul_smul_comm] + +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/VertexLinear.lean b/lean/OAI/Topology/ArtinGroups/Quivers/VertexLinear.lean new file mode 100644 index 0000000000000000000000000000000000000000..4bbbe15bc5bc0b5eb33ae886d7500620564666f1 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/VertexLinear.lean @@ -0,0 +1,115 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.PathTwoSelf + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag +variable {V A K : Type*} (Q : ReversibleQuiver V A) [Field K] + [Fintype A] [DecidableEq V] +variable {I J L : Type*} + +def vertexLinear : Q.Zigzag K →ₗ[K] (V → K) where + toFun := vertex + map_add' _ _ := rfl + map_smul' _ _ := rfl + +def arrowLinear : Q.Zigzag K →ₗ[K] (A → K) where + toFun := arrow + map_add' _ _ := rfl + map_smul' _ _ := rfl + +lemma vertex_sum {T : Type*} (s : Finset T) (f : T → Q.Zigzag K) : + (∑ t ∈ s, f t).vertex = ∑ t ∈ s, (f t).vertex := + map_sum (vertexLinear Q) f s + +lemma arrow_sum {T : Type*} (s : Finset T) (f : T → Q.Zigzag K) : + (∑ t ∈ s, f t).arrow = ∑ t ∈ s, (f t).arrow := + map_sum (arrowLinear Q) f s + +def TokenMatrix (f : Matrix I J (Q.Zigzag K)) : Prop := + ∀ i j, (f i j).vertex = 0 ∧ (f i j).arrow = 0 + +lemma matrixTwo_eq_self {f : Matrix I J (Q.Zigzag K)} (hf : TokenMatrix Q f) : + matrixTwo Q f = f := by + apply Matrix.ext + intro i j + exact pathTwo_eq_self Q (hf i j).1 (hf i j).2 + +lemma tokenMatrix_sub {f g : Matrix I J (Q.Zigzag K)} + (hf : TokenMatrix Q f) (hg : TokenMatrix Q g) : TokenMatrix Q (f-g) := by + intro i j + constructor + · change (f i j).vertex - (g i j).vertex = 0 + rw [(hf i j).1, (hg i j).1, sub_zero] + · change (f i j).arrow - (g i j).arrow = 0 + rw [(hf i j).2, (hg i j).2, sub_zero] + +lemma tokenMatrix_smul (r : K) {f : Matrix I J (Q.Zigzag K)} + (hf : TokenMatrix Q f) : TokenMatrix Q (r • f) := by + intro i j + constructor + · change r • (f i j).vertex = 0 + rw [(hf i j).1, smul_zero] + · change r • (f i j).arrow = 0 + rw [(hf i j).2, smul_zero] + +lemma tokenMatrix_matrixTwo_mul [Fintype J] + (f : Matrix I J (Q.Zigzag K)) (g : Matrix J L (Q.Zigzag K)) : + TokenMatrix Q (matrixTwo Q f * g) := by + intro i k + constructor + · rw [Matrix.mul_apply, vertex_sum] + apply Finset.sum_eq_zero + intro j _ + rw [vertex_mul] + exact MulZeroClass.zero_mul _ + · rw [Matrix.mul_apply, arrow_sum] + apply Finset.sum_eq_zero + intro j _ + rw [arrow_mul] + ext a + change (0 : K) * (g j k).arrow a + 0 * (g j k).vertex (Q.target a) = 0 + simp only [MulZeroClass.zero_mul, add_zero] + +lemma tokenMatrix_mul_matrixTwo [Fintype J] + (f : Matrix I J (Q.Zigzag K)) (g : Matrix J L (Q.Zigzag K)) : + TokenMatrix Q (f * matrixTwo Q g) := by + intro i k + constructor + · rw [Matrix.mul_apply, vertex_sum] + apply Finset.sum_eq_zero + intro j _ + rw [vertex_mul] + exact MulZeroClass.mul_zero _ + · rw [Matrix.mul_apply, arrow_sum] + apply Finset.sum_eq_zero + intro j _ + rw [arrow_mul] + ext a + change (f i j).vertex (Q.source a) * (0 : K) + (f i j).arrow a * 0 = 0 + simp only [MulZeroClass.mul_zero, add_zero] + +namespace BasedComplex +variable [Fintype I] [Fintype J] + +lemma tokenHomDifferential_tokenMatrix (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n : ℤ) (f : Matrix I J (Q.Zigzag K)) : + TokenMatrix Q (tokenHomDifferential Q E F n f) := by + rw [tokenHomDifferential_apply Q E F hE hF] + exact tokenMatrix_sub Q (tokenMatrix_matrixTwo_mul Q _ _) + (tokenMatrix_smul Q _ (tokenMatrix_mul_matrixTwo Q _ _)) + +lemma homDifferential_tokenMatrix (E : BasedComplex Q (K := K) I) + (F : BasedComplex Q (K := K) J) (hE : E.IsMinimal Q) (hF : F.IsMinimal Q) + (n : ℤ) {f : Matrix I J (Q.Zigzag K)} (hf : TokenMatrix Q f) : + homDifferential Q E F n f = 0 := by + rw [← matrixTwo_eq_self Q hf] + change E.differential * matrixTwo Q f - cochainSign (K := K) n • + (matrixTwo Q f * F.differential) = 0 + rw [positive_mul_matrixTwo Q hE, matrixTwo_mul_positive Q _ hF, smul_zero, sub_zero] + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Quivers/VertexMinimal.lean b/lean/OAI/Topology/ArtinGroups/Quivers/VertexMinimal.lean new file mode 100644 index 0000000000000000000000000000000000000000..cb83fccab5d3dc61c73cb9343c8e71999d63bbc1 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Quivers/VertexMinimal.lean @@ -0,0 +1,102 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.Reduction +import OAI.Topology.ArtinGroups.Complexes.CoconePlacement + +namespace OAI + +namespace HarmonicArtin.ReversibleQuiver.Zigzag + +variable {V A K I J L : Type*} (Q : ReversibleQuiver V A) + [Field K] [Fintype A] [DecidableEq V] + +def VertexMinimal [Fintype I] (E : BasedComplex Q (K := K) I) (v : V) : Prop := + ∀ i j, (E.differential i j).vertex v = 0 + +lemma vertexEntries_zero_left {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) + (i : I) (j : J) {v : V} (hv : (p i).color ≠ v) : (M i j).vertex v = 0 := by + have h := congrArg (fun x : Q.Zigzag K => x.vertex v) (hM.1 i j) + change (vertexId Q (p i).color).vertex v * (M i j).vertex v = (M i j).vertex v at h + rw [vertexId_eval, ite_eq_right (Ne.symm hv), MulZeroClass.zero_mul] at h + exact h.symm + +lemma vertexEntries_zero_right {p : I → GeneratorPlacement V} {q : J → GeneratorPlacement V} + {M : Matrix I J (Q.Zigzag K)} (hM : ProjectiveEntries Q p q M) + (i : I) (j : J) {v : V} (hv : (q j).color ≠ v) : (M i j).vertex v = 0 := by + have h := congrArg (fun x : Q.Zigzag K => x.vertex v) (hM.2 i j) + change (M i j).vertex v * (vertexId Q (q j).color).vertex v = (M i j).vertex v at h + rw [vertexId_eval, ite_eq_right (Ne.symm hv), MulZeroClass.mul_zero] at h + exact h.symm + +lemma reductionAt_vertex_boundary [Fintype I] + (E : BasedComplex Q (K := K) I) (H : Matrix I I (Q.Zigzag K)) + (a : GeneratorPlacement V) (hE : VertexMinimal Q E a.color) : + reductionAt Q E.placement E.placement (E.differential * H + H * E.differential) a = 0 := by + apply Matrix.ext + intro i j + change (vertexHom Q (K := K) a.color) + ((E.differential * H + H * E.differential) i.val j.val) = 0 + simp only [Matrix.add_apply, Matrix.mul_apply, map_add, map_sum, map_mul] + change (∑ k, (E.differential i.val k).vertex a.color * (H k j.val).vertex a.color) + + (∑ k, (H i.val k).vertex a.color * (E.differential k j.val).vertex a.color) = 0 + have hz (i j : I) : (E.differential i j).vertex a.color = 0 := hE i j + simp only [hz, MulZeroClass.zero_mul, MulZeroClass.mul_zero, Finset.sum_const_zero, add_zero] + +namespace BasedComplex + +variable [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J] + +theorem multiplicity_eq_of_vertex_homotopyEquivalence + (E : BasedComplex Q (K := K) I) (F : BasedComplex Q (K := K) J) + (h : HomotopyEquivalence Q E F) (a : GeneratorPlacement V) + (hE : VertexMinimal Q E a.color) (hF : VertexMinimal Q F a.color) : + E.multiplicity Q a = F.multiplicity Q a := by + classical + let f := reductionAt Q E.placement F.placement h.forward.matrix a + let g := reductionAt Q F.placement E.placement h.backward.matrix a + have hfg : f * g = 1 := by + dsimp only [f, g] + rw [← reductionAt_mul Q _ _ _ _ _ a h.forward.entries h.forward.degree, + h.sourceEquation, reductionAt_add, reductionAt_identity, + reductionAt_vertex_boundary Q E _ a hE, add_zero] + have hgf : g * f = 1 := by + dsimp only [f, g] + rw [← reductionAt_mul Q _ _ _ _ _ a h.backward.entries h.backward.degree, + h.targetEquation, reductionAt_add, reductionAt_identity, + reductionAt_vertex_boundary Q F _ a hF, add_zero] + have hd := (Matrix.toLinearEquivRight'OfInv hfg hgf).finrank_eq + simpa only [multiplicity, Module.finrank_pi, Module.finrank_self, Finset.sum_const, + Finset.card_univ, smul_eq_mul, mul_one, Nat.card_eq_fintype_card] using hd.symm + +variable [Fintype V] [DecidableEq A] + +omit [Fintype J] [DecidableEq J] [DecidableEq I] in +lemma positiveTwist_vertexMinimal (E : BasedComplex Q (K := K) I) + (hE : E.IsMinimal Q) (α β : V) (hαβ : α ≠ β) : + VertexMinimal Q (E.positiveTwist Q α) β := by + intro i j + rcases i with i | i + · exact vertexEntries_zero_left Q (E.positiveTwist Q α).entries (.inl i) j hαβ + · rcases j with j | j + · exact vertexEntries_zero_right Q (E.positiveTwist Q α).entries (.inr i) (.inl j) hαβ + · change (E.differential i j).vertex β = 0 + rw [hE i j] + rfl + +omit [Fintype J] [DecidableEq J] [DecidableEq I] in +lemma negativeTwist_vertexMinimal (E : BasedComplex Q (K := K) I) + (hE : E.IsMinimal Q) (α β : V) (hαβ : α ≠ β) : + VertexMinimal Q (E.negativeTwist Q α) β := by + intro i j + rcases i with i | i + · rcases j with j | j + · change (E.differential i j).vertex β = 0 + rw [hE i j] + rfl + · exact vertexEntries_zero_right Q (E.negativeTwist Q α).entries (.inl i) (.inr j) hαβ + · exact vertexEntries_zero_left Q (E.negativeTwist Q α).entries (.inr i) j hαβ + +end BasedComplex +end HarmonicArtin.ReversibleQuiver.Zigzag + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/AffineWeightMax.lean b/lean/OAI/Topology/ArtinGroups/Realizations/AffineWeightMax.lean new file mode 100644 index 0000000000000000000000000000000000000000..26c1f96d55dbc91bbda23a467522233b048c235f --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/AffineWeightMax.lean @@ -0,0 +1,105 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightAffineValue + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {P E : Type*} [PartialOrder P] [Fintype P] [AddCommGroup E] [Module ℝ E] +variable (z : P → E) (f : P → E →ₗ[ℝ] ℝ) (b : P → ℝ) + (hle : ∀ p q,f q (z p) ≤ b q) (heq : ∀ p q,f q (z p) = b q ↔ p ≤ q) +include hle heq + +lemma affine_weight_max_eq (x : OrderWeights P) : + f (weightMax x) (weightAffineValue z x) = b (weightMax x) := by + apply (weightAffineValue_eq_iff z x _ _ (fun p => hle p _)).mpr + intro p hp + exact (heq p _).mpr (le_weightMax x p hp) + +lemma affine_weight_max_unique (x y : OrderWeights P) + (h : weightAffineValue z x = weightAffineValue z y) : weightMax x = weightMax y := by + apply le_antisymm + · have hh := affine_weight_max_eq z f b hle heq y + rw [←h] at hh + have H := (weightAffineValue_eq_iff z x _ _ (fun p => hle p _)).mp hh + exact (heq _ _).mp (H _ (weightMax_mem x)) + · have hh := affine_weight_max_eq z f b hle heq x + rw [h] at hh + have H := (weightAffineValue_eq_iff z y _ _ (fun p => hle p _)).mp hh + exact (heq _ _).mp (H _ (weightMax_mem y)) + +omit heq in +lemma affine_weight_split_bound (y : OrderWeights P) (c d : P) : + f d (weightAffineValue z y) ≤ (1-y.weights c)*b d+y.weights c*f d (z c) := by + by_cases hc : y.weights c = 1 + · rw [weight_eq_vertex_of_one y c hc,weightAffineValue_vertex] + simp only [weightVertex,Finsupp.single_eq_same] + linarith + · have hc' : y.weights c < 1 := lt_of_le_of_ne (weight_le_one y c) hc + have hh := weightAffineValue_le z (weightDelete c y hc') (f d) (b d) (fun p => hle p d) + rw [weightAffineValue_delete z y c hc',map_add,map_smul,map_smul] + simp only [smul_eq_mul] + exact add_le_add (mul_le_mul_of_nonneg_left hh (sub_nonneg.mpr (weight_le_one y c))) le_rfl + +lemma affine_weight_max_coefficient_le (x y : OrderWeights P) + (h : weightAffineValue z x = weightAffineValue z y) : + y.weights (weightMax x) ≤ x.weights (weightMax x) := by + let c := weightMax x + by_cases hc : x.weights c = 1 + · rw [hc]; exact weight_le_one y c + have hc' : x.weights c < 1 := lt_of_le_of_ne (weight_le_one x c) hc + let x' := weightDelete c x hc' + let d := weightMax x' + have hd : d ∈ x.weights.support.erase c := weightDelete_support c x hc' (weightMax_mem x') + have hdc : d < c := lt_of_le_of_ne (le_weightMax x d (Finset.mem_erase.mp hd).2) + (Finset.mem_erase.mp hd).1 + have hstrict : f d (z c) < b d := lt_of_le_of_ne (hle c d) + (fun H => (not_le_of_gt hdc) ((heq c d).mp H)) + have hex : f d (weightAffineValue z x) = (1-x.weights c)*b d+x.weights c*f d (z c) := by + rw [weightAffineValue_delete z x c hc',map_add,map_smul,map_smul] + change (1-x.weights c)*f d (weightAffineValue z x') + x.weights c*f d (z c) = _ + rw [affine_weight_max_eq z f b hle heq x'] + have hey := affine_weight_split_bound z f b hle y c d + rw [←h,hex] at hey + nlinarith + +theorem weightAffineValue_injective : Function.Injective (weightAffineValue z) := by + have H : ∀ n : ℕ, ∀ x : OrderWeights P, x.weights.support.card = n → + ∀ y : OrderWeights P, weightAffineValue z x = weightAffineValue z y → x = y := by + intro n + induction n using Nat.strong_induction_on with + | h n ih => + intro x hn y hxy + let c := weightMax x + have hm : weightMax y = c := (affine_weight_max_unique z f b hle heq x y hxy).symm + have hcoeff : x.weights c = y.weights c := le_antisymm + (by simpa only [hm] using affine_weight_max_coefficient_le z f b hle heq y x hxy.symm) + (affine_weight_max_coefficient_le z f b hle heq x y hxy) + by_cases hc : x.weights c = 1 + · exact (weight_eq_vertex_of_one x c hc).trans (weight_eq_vertex_of_one y c (hcoeff ▸ hc)).symm + have hx : x.weights c < 1 := lt_of_le_of_ne (weight_le_one x c) hc + have hy : y.weights c < 1 := hcoeff ▸ hx + have hnon : 1-x.weights c ≠ 0 := ne_of_gt (sub_pos.mpr hx) + have hdel : weightAffineValue z (weightDelete c x hx) = weightAffineValue z (weightDelete c y hy) := by + rw [weightAffineValue_delete z x c hx,weightAffineValue_delete z y c hy,←hcoeff] at hxy + exact smul_right_injective _ hnon (add_right_cancel hxy) + have hcard : (weightDelete c x hx).weights.support.card < n := by + rw [←hn] + exact lt_of_le_of_lt (Finset.card_le_card (weightDelete_support c x hx)) + (Finset.card_erase_lt_of_mem (weightMax_mem x)) + have hw := ih _ hcard (weightDelete c x hx) rfl (weightDelete c y hy) hdel + apply OrderWeights.ext + ext p + by_cases hp : p = c + · subst p; exact hcoeff + · have hv := congrArg (fun w : OrderWeights P => w.weights p) hw + rw [weightDelete_apply,weightDelete_apply,ite_eq_right hp,ite_eq_right hp,←hcoeff] at hv + exact mul_left_cancel₀ (inv_ne_zero hnon) hv + intro x y h + exact H _ x rfl y h + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/CellDeligne.lean b/lean/OAI/Topology/ArtinGroups/Realizations/CellDeligne.lean new file mode 100644 index 0000000000000000000000000000000000000000..01923991cef1066b9c5ae82c4fca454ba63848d5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/CellDeligne.lean @@ -0,0 +1,105 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.CosetVertex +import OAI.Topology.ArtinGroups.Harmonic.ReducedExpression +import OAI.Topology.ArtinGroups.Coxeter.InverseParabolicMinimum + +namespace OAI + +namespace HarmonicArtin +universe v +variable {S : Type v} + +lemma coxeterParabolic_mono (M : CoxeterMatrix S) {J K : Set S} (h : J ⊆ K) : + coxeterParabolic M J ≤ coxeterParabolic M K := Subgroup.closure_mono (Set.image_mono h) + +lemma wordCoxeter_append (M : CoxeterMatrix S) (u v : List S) : + wordCoxeter M (u++v)=wordCoxeter M u*wordCoxeter M v := by + simp only [wordCoxeter,List.map_append,List.prod_append] + +lemma wordCoxeter_mem_parabolic (M : CoxeterMatrix S) (J : Set S) (u : List S) + (hu : ∀ i ∈ u, i ∈ J) : wordCoxeter M u ∈ coxeterParabolic M J := + CoxeterExchange.wordProd_mem_parabolic M.toCoxeterSystem J u hu + +lemma liftedFace_refl (M : CoxeterMatrix S) (a : LiftedCell M) : LiftedFace M a a := by + refine ⟨Set.Subset.rfl, [], by simp, ?_, ?_, ?_⟩ + · simp [wordCoxeter] + · intro v + simp only [wordCoxeter,List.map_nil,List.prod_nil,M.toCoxeterSystem.length_one] + exact Nat.zero_le _ + · simp [wordArtin] + +lemma liftedFace_trans (M : CoxeterMatrix S) {a b c : LiftedCell M} + (hab : LiftedFace M a b) (hbc : LiftedFace M b c) : LiftedFace M a c := by + obtain ⟨hAB,u,hu,hur,humin,ha⟩ := hab + obtain ⟨hBC,v,hv,hvr,hvmin,hb⟩ := hbc + have huB := wordCoxeter_mem_parabolic M b.2.1 u hu + have hvadd : ∀ w ∈ coxeterParabolic M b.2.1, + M.toCoxeterSystem.length (wordCoxeter M v*w) = + M.toCoxeterSystem.length (wordCoxeter M v)+M.toCoxeterSystem.length w := by + intro w hw + exact CoxeterExchange.length_mul_of_right_minimum M.toCoxeterSystem b.2.1 + (wordCoxeter M v) (fun x hx => hvmin ⟨x,hx⟩) w hw + refine ⟨hAB.trans hBC,v++u,?_,?_,?_,?_⟩ + · intro i hi + rcases List.mem_append.mp hi with hi | hi + · exact hv i hi + · exact hBC (hu i hi) + · rw [wordCoxeter_append,hvadd _ huB,hvr,hur,List.length_append] + · intro w + have hwB : (w : M.Group) ∈ coxeterParabolic M b.2.1 := coxeterParabolic_mono M hAB w.property + rw [wordCoxeter_append,mul_assoc,hvadd _ huB, + hvadd _ ((coxeterParabolic M b.2.1).mul_mem huB hwB)] + exact Nat.add_le_add_left (humin w) _ + · rw [ha,hb,wordArtin_append,mul_assoc] + +lemma liftedFace_antisymm (M : CoxeterMatrix S) {a b : LiftedCell M} + (hab : LiftedFace M a b) (hba : LiftedFace M b a) : a=b := by + obtain ⟨hAB,u,hu,hur,humin,ha⟩ := hab + have htype : a.2.1=b.2.1 := hAB.antisymm hba.1 + have humem : wordCoxeter M u ∈ coxeterParabolic M a.2.1 := by + rw [htype] + exact wordCoxeter_mem_parabolic M b.2.1 u hu + have hh := humin ⟨(wordCoxeter M u)⁻¹,(coxeterParabolic M a.2.1).inv_mem humem⟩ + simp only [mul_inv_cancel,M.toCoxeterSystem.length_one] at hh + have hulen : u.length=0 := by omega + have hunil := List.eq_nil_of_length_eq_zero hulen + rw [hunil] at ha + simp only [wordArtin,List.map_nil,List.prod_nil,mul_one] at ha + exact Prod.ext ha (Subtype.ext htype) + +lemma lifted_le_iff_face (M : CoxeterMatrix S) (a b : LiftedCell M) : + a ≤ b ↔ LiftedFace M a b := by + constructor + · intro h + induction h with + | refl => exact liftedFace_refl M _ + | tail h hstep ih => exact liftedFace_trans M ih hstep + · exact Relation.ReflTransGen.single + +lemma lifted_le_antisymm (M : CoxeterMatrix S) {a b : LiftedCell M} + (hab : a ≤ b) (hba : b ≤ a) : a=b := + liftedFace_antisymm M ((lifted_le_iff_face M a b).mp hab) ((lifted_le_iff_face M b a).mp hba) + +def cellToDeligne (M : CoxeterMatrix S) (a : LiftedCell M) : Deligne M := + ⟨(a.2.1,rightCoset M a.2.1 a.1⁻¹),a.2.property,⟨a.1⁻¹,rfl⟩⟩ + +lemma cellToDeligne_monotone (M : CoxeterMatrix S) : Monotone (cellToDeligne M) := by + intro a b hab + obtain ⟨hAB,u,hu,hur,humin,ha⟩ := (lifted_le_iff_face M a b).mp hab + change a.2.1 ⊆ b.2.1 ∧ rightCoset M a.2.1 a.1⁻¹ ⊆ rightCoset M b.2.1 b.1⁻¹ + refine ⟨hAB,?_⟩ + intro g hg + change g*(a.1⁻¹)⁻¹ ∈ artinParabolic M a.2.1 at hg + change g*(b.1⁻¹)⁻¹ ∈ artinParabolic M b.2.1 + simp only [inv_inv] at hg ⊢ + have hmem := artinParabolic_mono M hAB hg + have huA := wordArtin_mem_parabolic M b.2.1 u hu + have hprod := (artinParabolic M b.2.1).mul_mem hmem ((artinParabolic M b.2.1).inv_mem huA) + simpa only [ha,mul_assoc,mul_inv_cancel,mul_one] using hprod + +def cellToDeligneOrderHom (M : CoxeterMatrix S) : LiftedCell M →o Deligne M := + ⟨cellToDeligne M,cellToDeligne_monotone M⟩ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/CellIndex.lean b/lean/OAI/Topology/ArtinGroups/Realizations/CellIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..06d78aa07b6f45462e781672e1b6f4f85968436b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/CellIndex.lean @@ -0,0 +1,118 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Characteristic + +namespace OAI + +namespace HarmonicArtin +open Topology Set Metric Geometric CoxeterExchange + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [DecidableEq S] (M : CoxeterMatrix S) + +abbrev SourceCellIndex (n : ℕ) := {T : SphericalType M // T.val.ncard=n} + +lemma sourceCell_ball_pair {n : ℕ} (i : SourceCellIndex M n) : + ∃ h : (i.val.val → ℝ) ≃ₜ (Fin n → ℝ), + h '' interior (permutahedron (restrictedMatrix M i.val.val)) = ball 0 1 ∧ + h '' permutahedron (restrictedMatrix M i.val.val) = closedBall 0 1 ∧ + h '' frontier (permutahedron (restrictedMatrix M i.val.val)) = sphere 0 1 := by + obtain ⟨h,hi,hc,hf⟩ := permutahedron_ball_pair (restrictedMatrix M i.val.val) + let e : i.val.val ≃ Fin n := Fintype.equivFinOfCardEq + ((Set.fintypeCard_eq_ncard i.val.val).trans i.property) + let j : (i.val.val → ℝ) ≃ᵢ (Fin n → ℝ) := IsometryEquiv.piCongrLeft' (Y := fun _ : i.val.val => ℝ) e + have hz : j 0=0 := by + ext k + change (0 : i.val.val → ℝ) (e.symm k)=0 + rfl + refine ⟨h.trans j.toHomeomorph,?_,?_,?_⟩ + · change (fun x => j (h x)) '' _ = _ + rw [←Set.image_image (⇑j) (⇑h),hi,j.image_ball,hz] + · change (fun x => j (h x)) '' _ = _ + rw [←Set.image_image (⇑j) (⇑h),hc,j.image_closedBall,hz] + · change (fun x => j (h x)) '' _ = _ + rw [←Set.image_image (⇑j) (⇑h),hf,j.image_sphere,hz] + +noncomputable def sourceCellCoordinates {n : ℕ} (i : SourceCellIndex M n) : + (i.val.val → ℝ) ≃ₜ (Fin n → ℝ) := (sourceCell_ball_pair M i).choose + +lemma sourceCellCoordinates_spec {n : ℕ} (i : SourceCellIndex M n) : + sourceCellCoordinates M i '' interior (permutahedron (restrictedMatrix M i.val.val)) = ball 0 1 ∧ + sourceCellCoordinates M i '' permutahedron (restrictedMatrix M i.val.val) = closedBall 0 1 ∧ + sourceCellCoordinates M i '' frontier (permutahedron (restrictedMatrix M i.val.val)) = sphere 0 1 := + (sourceCell_ball_pair M i).choose_spec + +noncomputable def sourceCellBallHomeomorph {n : ℕ} (i : SourceCellIndex M n) : + SourceModelCell M i.val ≃ₜ closedBall (0 : Fin n → ℝ) 1 := + (sourceCellCoordinates M i).sets (by + rw [←(sourceCellCoordinates_spec M i).2.1, + Set.preimage_image_eq _ (sourceCellCoordinates M i).injective]) + +lemma sourceCellBallHomeomorph_apply {n : ℕ} (i : SourceCellIndex M n) + (x : SourceModelCell M i.val) : + (sourceCellBallHomeomorph M i x).val=sourceCellCoordinates M i x.val := rfl + +lemma sourceCellBallHomeomorph_interior_iff {n : ℕ} (i : SourceCellIndex M n) + (x : SourceModelCell M i.val) : + x.val ∈ interior (permutahedron (restrictedMatrix M i.val.val)) ↔ + (sourceCellBallHomeomorph M i x).val ∈ ball 0 1 := by + rw [sourceCellBallHomeomorph_apply,←(sourceCellCoordinates_spec M i).1] + exact ((sourceCellCoordinates M i).injective.mem_set_image).symm + +lemma sourceCellBallHomeomorph_frontier_iff {n : ℕ} (i : SourceCellIndex M n) + (x : SourceModelCell M i.val) : + x.val ∈ frontier (permutahedron (restrictedMatrix M i.val.val)) ↔ + (sourceCellBallHomeomorph M i x).val ∈ sphere 0 1 := by + rw [sourceCellBallHomeomorph_apply,←(sourceCellCoordinates_spec M i).2.2] + exact ((sourceCellCoordinates M i).injective.mem_set_image).symm + +noncomputable def sourceCellTotal {n : ℕ} (i : SourceCellIndex M n) (x : Fin n → ℝ) : + SourceSalvetti M := + if hx : x ∈ closedBall 0 1 then + sourceCharacteristic M i.val ((sourceCellBallHomeomorph M i).symm ⟨x,hx⟩) + else sourceCharacteristic M i.val ((sourceCellBallHomeomorph M i).symm ⟨0,by simp⟩) + +lemma sourceCellTotal_closedBall {n : ℕ} (i : SourceCellIndex M n) (x : Fin n → ℝ) + (hx : x ∈ closedBall 0 1) : sourceCellTotal M i x = + sourceCharacteristic M i.val ((sourceCellBallHomeomorph M i).symm ⟨x,hx⟩) := by + simp only [sourceCellTotal,dite_eq_left hx] + +lemma sourceCellTotal_continuousOn {n : ℕ} (i : SourceCellIndex M n) : + ContinuousOn (sourceCellTotal M i) (closedBall 0 1) := by + rw [continuousOn_iff_continuous_domRestrict] + have he : (closedBall 0 1).domRestrict (sourceCellTotal M i)= + sourceCharacteristic M i.val ∘ (sourceCellBallHomeomorph M i).symm := by + funext x + exact sourceCellTotal_closedBall M i x.val x.property + rw [he] + exact (sourceCharacteristic M i.val).continuous.comp (sourceCellBallHomeomorph M i).symm.continuous + +lemma sourceCellTotal_image_closedBall {n : ℕ} (i : SourceCellIndex M n) : + sourceCellTotal M i '' closedBall 0 1=Set.range (sourceCharacteristic M i.val) := by + ext q + constructor + · rintro ⟨x,hx,rfl⟩ + exact ⟨_,(sourceCellTotal_closedBall M i x hx).symm⟩ + · rintro ⟨x,rfl⟩ + refine ⟨(sourceCellBallHomeomorph M i x).val,(sourceCellBallHomeomorph M i x).property,?_⟩ + rw [sourceCellTotal_closedBall M i _ (sourceCellBallHomeomorph M i x).property] + exact congrArg (sourceCharacteristic M i.val) ((sourceCellBallHomeomorph M i).symm_apply_apply x) + +lemma sourceCellTotal_image_ball {n : ℕ} (i : SourceCellIndex M n) : + sourceCellTotal M i '' ball 0 1=sourceOpenCell M i.val := by + ext q + constructor + · rintro ⟨x,hx,rfl⟩ + let y := (sourceCellBallHomeomorph M i).symm ⟨x,ball_subset_closedBall hx⟩ + have hy : y.val ∈ interior (permutahedron (restrictedMatrix M i.val.val)) := by + apply (sourceCellBallHomeomorph_interior_iff M i y).mpr + simpa only [y,Homeomorph.apply_symm_apply] using hx + exact ⟨⟨y,hy⟩,(sourceCellTotal_closedBall M i x (ball_subset_closedBall hx)).symm⟩ + · rintro ⟨x,rfl⟩ + refine ⟨(sourceCellBallHomeomorph M i x.val).val, + (sourceCellBallHomeomorph_interior_iff M i x.val).mp x.property,?_⟩ + rw [sourceCellTotal_closedBall M i _ (sourceCellBallHomeomorph M i x.val).property] + exact congrArg (sourceCharacteristic M i.val) ((sourceCellBallHomeomorph M i).symm_apply_apply x.val) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/CellIndexTypeInjective.lean b/lean/OAI/Topology/ArtinGroups/Realizations/CellIndexTypeInjective.lean new file mode 100644 index 0000000000000000000000000000000000000000..c302fbd77baa8541bb5a431c80d3b7bfcdcc3039 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/CellIndexTypeInjective.lean @@ -0,0 +1,81 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.CellInteriorChart + +namespace OAI + +namespace HarmonicArtin +open Topology Set Metric Geometric CoxeterExchange + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [DecidableEq S] (M : CoxeterMatrix S) + +omit [Fintype S] [DecidableEq S] in +lemma sourceCellIndex_type_injective : + Function.Injective (fun i : Σ n,SourceCellIndex M n => i.2.val) := by + rintro ⟨n,⟨T,hT⟩⟩ ⟨m,⟨R,hR⟩⟩ he + change T=R at he + subst R + cases hT + cases hR + rfl + +noncomputable instance sourceCWComplex : CWComplex (Set.univ : Set (SourceSalvetti M)) where + cell := SourceCellIndex M + map _ i := sourceCellPartial M i + source_eq _ i := sourceCellPartial_source M i + continuousOn _ i := sourceCellTotal_continuousOn M i + continuousOn_symm _ i := sourceCellPartial_continuousOn_symm M i + pairwiseDisjoint' := by + intro i _ j _ hij + change Disjoint ((sourceCellPartial M i.2) '' ball 0 1) ((sourceCellPartial M j.2) '' ball 0 1) + rw [sourceCellPartial_image_ball,sourceCellPartial_image_ball] + exact sourceOpenCell_disjoint M (fun h => hij (sourceCellIndex_type_injective M h)) + mapsTo' := by + intro n i + refine ⟨fun m => Finset.univ,?_⟩ + intro x hx + obtain ⟨m,hm,j,hj⟩ := sourceCellPartial_boundary M i x hx + simp only [Set.mem_iUnion] + exact ⟨m,hm,j,Finset.mem_univ j,hj⟩ + closed' := by + intro A _ hA + apply (sourceCharacteristic_weak M A).mpr + intro T + let i : SourceCellIndex M T.val.ncard := ⟨T,rfl⟩ + have h := (hA _ i).preimage (sourceCharacteristic M T).continuous + rw [sourceCellPartial_image_closedBall] at h + have hr : (sourceCharacteristic M T) ⁻¹' Set.range (sourceCharacteristic M T)=Set.univ := + Set.eq_univ_of_forall (fun x => ⟨x,rfl⟩) + change IsClosed ((sourceCharacteristic M T) ⁻¹' (A ∩ Set.range (sourceCharacteristic M T))) at h + simpa only [Set.preimage_inter,hr,Set.inter_univ] using h + union' := by + apply Set.eq_univ_of_forall + intro q + obtain ⟨T,x,hx⟩ := sourceOpenCell_cover M q + refine Set.mem_iUnion.mpr ⟨T.val.ncard,Set.mem_iUnion.mpr ⟨⟨T,rfl⟩,?_⟩⟩ + rw [sourceCellPartial_image_closedBall] + exact ⟨x.val,hx⟩ + +instance sourceCWFiniteType : CWComplex.FiniteType (Set.univ : Set (SourceSalvetti M)) where + finite_cell n := inferInstanceAs (Finite (SourceCellIndex M n)) + +instance sourceCWFiniteDimensional : CWComplex.FiniteDimensional (Set.univ : Set (SourceSalvetti M)) where + eventually_isEmpty_cell := by + apply Filter.eventually_atTop.mpr + refine ⟨Fintype.card S+1,fun n hn => ?_⟩ + change IsEmpty (SourceCellIndex M n) + refine ⟨fun i => ?_⟩ + have hc : i.val.val.ncard ≤ Fintype.card S := by simpa only [Nat.card_eq_fintype_card] using Set.ncard_le_card i.val.val + have hi := i.property + omega + +instance sourceCWFinite : CWComplex.Finite (Set.univ : Set (SourceSalvetti M)) := + CWComplex.finite_of_finiteDimensional_finiteType _ + +theorem sourceCW_openCell {n : ℕ} (i : SourceCellIndex M n) : + CWComplex.openCell (C := (Set.univ : Set (SourceSalvetti M))) n i=sourceOpenCell M i.val := + sourceCellPartial_image_ball M i + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/CellInteriorChart.lean b/lean/OAI/Topology/ArtinGroups/Realizations/CellInteriorChart.lean new file mode 100644 index 0000000000000000000000000000000000000000..25d708f54d2bac826e747d0d94f6191c97580214 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/CellInteriorChart.lean @@ -0,0 +1,91 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.CharacteristicSaturatedInterior +import OAI.Topology.ArtinGroups.Realizations.CellIndex +import OAI.Topology.ArtinGroups.Realizations.PartialEquivContinuousSymm + +namespace OAI + +namespace HarmonicArtin +open Topology Set Metric Geometric CoxeterExchange + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [DecidableEq S] (M : CoxeterMatrix S) + +noncomputable def sourceCellInteriorChart {n : ℕ} (i : SourceCellIndex M n) : + ball (0 : Fin n → ℝ) 1 ≃ₜ SourceModelInterior M i.val where + toFun x := ⟨(sourceCellBallHomeomorph M i).symm ⟨x.val,ball_subset_closedBall x.property⟩, + (sourceCellBallHomeomorph_interior_iff M i _).mpr (by + simpa only [Homeomorph.apply_symm_apply] using x.property)⟩ + invFun y := ⟨(sourceCellBallHomeomorph M i y.val).val, + (sourceCellBallHomeomorph_interior_iff M i y.val).mp y.property⟩ + left_inv x := by + apply Subtype.ext + exact congrArg (fun z : closedBall (0 : Fin n → ℝ) 1 => z.val) ((sourceCellBallHomeomorph M i).apply_symm_apply + ⟨x.val,ball_subset_closedBall x.property⟩) + right_inv y := by + apply Subtype.ext + exact (sourceCellBallHomeomorph M i).symm_apply_apply y.val + continuous_toFun := (((sourceCellBallHomeomorph M i).symm.continuous.comp + (continuous_subtype_val.subtype_mk _)).subtype_mk _) + continuous_invFun := ((continuous_subtype_val.comp + ((sourceCellBallHomeomorph M i).continuous.comp continuous_subtype_val)).subtype_mk _) + +lemma sourceCellTotal_restrict_ball {n : ℕ} (i : SourceCellIndex M n) : + (ball 0 1).domRestrict (sourceCellTotal M i)= + (fun x : SourceModelInterior M i.val => sourceCharacteristic M i.val x.val) ∘ + sourceCellInteriorChart M i := by + funext x + exact sourceCellTotal_closedBall M i x.val (ball_subset_closedBall x.property) + +lemma sourceCellTotal_embedding_ball {n : ℕ} (i : SourceCellIndex M n) : + IsEmbedding ((ball 0 1).domRestrict (sourceCellTotal M i)) := by + rw [sourceCellTotal_restrict_ball] + exact (sourceCharacteristic_interior_embedding M i.val).comp + (sourceCellInteriorChart M i).isEmbedding + +lemma sourceCellTotal_injOn_ball {n : ℕ} (i : SourceCellIndex M n) : + Set.InjOn (sourceCellTotal M i) (ball 0 1) := by + intro x hx y hy hxy + have h := (sourceCellTotal_embedding_ball M i).injective + (a₁ := ⟨x,hx⟩) (a₂ := ⟨y,hy⟩) hxy + exact congrArg Subtype.val h + +noncomputable def sourceCellPartial {n : ℕ} (i : SourceCellIndex M n) : + PartialEquiv (Fin n → ℝ) (SourceSalvetti M) := + (sourceCellTotal_injOn_ball M i).toPartialEquiv (sourceCellTotal M i) (ball 0 1) + +lemma sourceCellPartial_source {n : ℕ} (i : SourceCellIndex M n) : + (sourceCellPartial M i).source=ball 0 1 := rfl + +lemma sourceCellPartial_apply {n : ℕ} (i : SourceCellIndex M n) (x : Fin n → ℝ) : + sourceCellPartial M i x=sourceCellTotal M i x := rfl + +lemma sourceCellPartial_continuousOn_symm {n : ℕ} (i : SourceCellIndex M n) : + ContinuousOn (sourceCellPartial M i).symm (sourceCellPartial M i).target := + partialEquiv_continuousOn_symm _ (sourceCellTotal_embedding_ball M i) + +lemma sourceCellPartial_image_closedBall {n : ℕ} (i : SourceCellIndex M n) : + sourceCellPartial M i '' closedBall 0 1=Set.range (sourceCharacteristic M i.val) := + sourceCellTotal_image_closedBall M i + +lemma sourceCellPartial_image_ball {n : ℕ} (i : SourceCellIndex M n) : + sourceCellPartial M i '' ball 0 1=sourceOpenCell M i.val := + sourceCellTotal_image_ball M i + +lemma sourceCellPartial_boundary {n : ℕ} (i : SourceCellIndex M n) + (x : Fin n → ℝ) (hx : x ∈ sphere 0 1) : + ∃ m : ℕ, m + (salvettiDeckProjection_quotientCovering M).continuous.comp (sourceCellMap M (1,T)).continuous) + +lemma sourceCellMap_normal (a : LiftedCell M) (x : SourceModelCell M a.2) : + sourceCellMap M a x=a.1 • sourceCellMap M (1,a.2) x := by + have h := sourceCellMap_deck M a.1 (1,a.2) x + change sourceCellMap M (a.1*1,a.2) x=a.1 • sourceCellMap M (1,a.2) x at h + rw [_root_.mul_one] at h + exact h + +lemma sourceUnionMap_lifted (a : LiftedCell M) (x : SourceModelCell M a.2) : + sourceUnionMap M ⟨a.2,x⟩=salvettiDeckProjection M (sourceCellMap M a x) := by + rw [sourceCellMap_normal] + exact ((salvettiDeckProjection_quotientCovering M).map_smul a.1).symm + +lemma sourceGluing_face_le {T : SphericalType M} {a : LiftedCell M} (h : a ≤ (1,T)) + (x : SourceModelCell M a.2) : + SourceGluingRelation M ⟨a.2,x⟩ ⟨T,sourceModelFaceMap M h x⟩ := by + rcases h.eq_or_lt with he|hl + · subst a + rw [sourceModelFaceMap_self] + exact Relation.EqvGen.refl _ + · exact Relation.EqvGen.rel _ _ (SourceFaceIdentification.face (M := M) T a hl x) + +lemma sourceUnionMap_rel (x y : SourceCellUnion M) (h : SourceGluingRelation M x y) : + sourceUnionMap M x=sourceUnionMap M y := by + induction h with + | rel x y h => + cases h with + | face T a h z => + rw [sourceUnionMap_lifted M a z] + change salvettiDeckProjection M (sourceCellMap M a z)= + salvettiDeckProjection M (sourceCellMap M (1,T) (sourceModelFaceMap M h.le z)) + rw [sourceModelFaceMap_included] + | refl => rfl + | symm _ _ _ ih => exact ih.symm + | trans _ _ _ _ _ ih ih' => exact ih.trans ih' + +lemma sourceUnionMap_kernel (x y : SourceCellUnion M) + (h : sourceUnionMap M x=sourceUnionMap M y) : SourceGluingRelation M x y := by + rcases x with ⟨T,x⟩ + rcases y with ⟨R,y⟩ + obtain ⟨g,hg⟩ := (salvettiDeckProjection_quotientCovering M).apply_eq_iff_mem_orbit.mp h + let w := sourceCellMap M (1,R) y + let b := weightMax w + have hb : b ≤ ((1,R) : LiftedCell M) := sourceCellMap_support M (1,R) y b (weightMax_mem w) + obtain ⟨z,hz⟩ := sourceCellMap_range M b w (le_weightMax w) + have hy : sourceModelFaceMap M hb z=y := by + apply sourceCellMap_injective M (1,R) + exact (sourceModelFaceMap_included M hb z).trans hz + let c : LiftedCell M := (g*b.1,b.2) + have hw : c ∈ (sourceCellMap M (1,T) x).weights.support := by + rw [←hg,Finsupp.mem_support_iff] + change (g • w).weights (liftedDeck M g b) ≠ 0 + rw [liftedWeights_smul_apply] + exact Finsupp.mem_support_iff.mp (weightMax_mem w) + have hc : c ≤ ((1,T) : LiftedCell M) := sourceCellMap_support M (1,T) x c hw + have hx : sourceModelFaceMap M hc z=x := by + apply sourceCellMap_injective M (1,T) + calc + _ = sourceCellMap M c z := sourceModelFaceMap_included M hc z + _ = g • sourceCellMap M b z := sourceCellMap_deck M g b z + _ = g • w := congrArg (g • ·) hz + _ = _ := hg + have hR := sourceGluing_face_le M hb z + have hT := sourceGluing_face_le M hc z + rw [hy] at hR + rw [hx] at hT + exact Relation.EqvGen.trans _ _ _ (Relation.EqvGen.symm _ _ hT) hR + +lemma sourceUnionMap_surjective : Function.Surjective (sourceUnionMap M) := by + intro q + obtain ⟨w,rfl⟩ := (salvettiDeckProjection_quotientCovering M).surjective q + obtain ⟨x,hx⟩ := sourceCellMap_range M (weightMax w) w (le_weightMax w) + refine ⟨⟨(weightMax w).2,x⟩,?_⟩ + rw [sourceUnionMap_lifted,hx] + +lemma sourceUnionMap_quotient : IsQuotientMap (sourceUnionMap M) := by + rw [isQuotientMap_iff_isClosed] + refine ⟨sourceUnionMap_surjective M,fun A => ⟨fun h => h.preimage (sourceUnionMap M).continuous,?_⟩⟩ + intro h + apply (salvettiDeckProjection_quotientCovering M).toIsQuotientMap.1.isClosed_preimage.mp + apply weightPrincipalProjection_quotient.1.isClosed_preimage.mp + rw [isClosed_sigma_iff] + intro a + have hc := (isClosed_sigma_iff.mp h a.2).preimage (liftedModelHomeomorph M a).symm.continuous + have he : ∀ z : OrderWeights (Set.Iic a), + sourceUnionMap M ⟨a.2,(liftedModelHomeomorph M a).symm z⟩= + salvettiDeckProjection M (weightMap (weightInclusion (Set.Iic a)) z) := by + intro z + rw [sourceUnionMap_lifted] + change salvettiDeckProjection M (weightMap _ ((liftedModelHomeomorph M a) + ((liftedModelHomeomorph M a).symm z)))=_ + rw [Homeomorph.apply_symm_apply] + simpa only [Set.preimage_preimage,Function.comp_def,he,weightPrincipalProjection] using hc + +noncomputable def sourceSalvettiToDeck : C(SourceSalvetti M,SalvettiDeckQuotient M) where + toFun := Quotient.lift (sourceUnionMap M) (sourceUnionMap_rel M) + continuous_toFun := (sourceUnionMap M).continuous.quotient_lift (sourceUnionMap_rel M) + +lemma sourceSalvettiToDeck_bijective : Function.Bijective (sourceSalvettiToDeck M) := by + constructor + · intro x y h + induction x using Quotient.inductionOn with + | h x => + induction y using Quotient.inductionOn with + | h y => exact Quotient.sound (sourceUnionMap_kernel M x y h) + · intro y + obtain ⟨x,hx⟩ := sourceUnionMap_surjective M y + exact ⟨Quotient.mk _ x,hx⟩ + +lemma sourceSalvettiToDeck_quotient : IsQuotientMap (sourceSalvettiToDeck M) := + IsQuotientMap.of_comp continuous_quotient_mk' (sourceSalvettiToDeck M).continuous + (sourceUnionMap_quotient M) + +noncomputable def sourceSalvettiHomeomorph : SourceSalvetti M ≃ₜ SalvettiDeckQuotient M := by + let e := Equiv.ofBijective (sourceSalvettiToDeck M) (sourceSalvettiToDeck_bijective M) + refine { toEquiv := e,continuous_toFun := (sourceSalvettiToDeck M).continuous,continuous_invFun := ?_ } + rw [(sourceSalvettiToDeck_quotient M).continuous_iff] + have he : e.symm ∘ sourceSalvettiToDeck M=id := funext e.symm_apply_apply + change Continuous (e.symm ∘ sourceSalvettiToDeck M) + rw [he] + exact continuous_id + +noncomputable def sourceUniversalProjection : OrderWeights (LiftedCell M) → SourceSalvetti M := + (sourceSalvettiHomeomorph M).symm ∘ salvettiDeckProjection M + +theorem sourceUniversalProjection_quotientCovering : + IsQuotientCoveringMap (sourceUniversalProjection M) (Artin M) := + (salvettiDeckProjection_quotientCovering M).homeomorph_comp (sourceSalvettiHomeomorph M).symm + +theorem source_full_cover_contractible : + IsCoveringMap (sourceUniversalProjection M) ∧ ContractibleSpace (OrderWeights (LiftedCell M)) := + ⟨(sourceUniversalProjection_quotientCovering M).isCoveringMap,liftedWeights_contractible M⟩ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/ConeWeights.lean b/lean/OAI/Topology/ArtinGroups/Realizations/ConeWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..0bc6a8238ef21584b8828254a57018fe898d1645 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/ConeWeights.lean @@ -0,0 +1,138 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightCarrier +import OAI.Topology.ArtinGroups.Harmonic.FiniteChainEnum + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators unitInterval +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u v +variable {P:Type u} {Q:Type v} [PartialOrder P] [PartialOrder Q] + +lemma orderWeights_prod_continuous {Z Y:Type*} [TopologicalSpace Z] [LocallyCompactSpace Z] + [TopologicalSpace Y] (f:Z×OrderWeights P→Y) + (hc:∀(n:SimplexCategory) (x:(nerve P).obj (op n)), + Continuous (fun p:Z×Convexity.StdSimplex ℝ (Fin (n.len+1))=>f (p.1,orderWeightsOfChain (nerveChain x) p.2))) : + Continuous f := by + have ht (w:OrderWeights P):Continuous (fun t=>f (t,w)):=by + have h:Continuous (fun t=>f (t,orderWeightsOfChain (weightChain w) (weightSimplex w))):= + (hc ⦋weightDim w⦌ (nerveOfChain (weightChain w))).comp (continuous_id.prodMk continuous_const) + simpa only [orderWeightsOfChain_canonical] using h + let F:OrderWeights P→C(Z,Y):=fun w=>⟨fun t=>f (t,w),ht w⟩ + have hF:Continuous F:=by + rw [orderWeights_continuous_iff] + intro n x + apply ContinuousMap.continuous_of_continuous_uncurry + exact (hc n x).comp continuous_swap + exact (ContinuousMap.continuous_uncurry_of_continuous ⟨F,hF⟩).comp continuous_swap + +noncomputable def coneWeights (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) + (t:I) (w:OrderWeights Q) : OrderWeights P where + weights:=(σ t).val • (weightMap f w).weights + Finsupp.single v t.val + nonneg p:=by + change 0≤ (σ t).val * (weightMap f w).weights p + (Finsupp.single v t.val) p + apply add_nonneg (mul_nonneg (σ t).property.1 ((weightMap f w).nonneg p)) + simp only [Finsupp.single_apply] + split_ifs; exacts [t.property.1,le_rfl] + total:=by + rw [Finsupp.sum_add_index (by intros;rfl) (by intros;rfl), + Finsupp.sum_single_index (by rfl),Finsupp.sum_smul_index (by intros;rfl)] + change (∑p∈(weightMap f w).weights.support,(σ t).val * (weightMap f w).weights p)+t.val=1 + rw [←Finset.mul_sum] + change (σ t).val * ((weightMap f w).weights.sum (fun _ a=>a))+t.val=1 + rw [(weightMap f w).total] + change (1-t.val)*1+t.val=1 + ring + chain:=by + intro a ha b hb + have hl {p:P} (h:p∈((σ t).val • (weightMap f w).weights + Finsupp.single v t.val).support) : + p∈(weightMap f w).weights.support ∨ p=v:=by + rcases Finset.mem_union.mp (Finsupp.support_add h) with h|h + · exact Or.inl (Finsupp.support_smul h) + · exact Or.inr (Finset.mem_singleton.mp (Finsupp.support_single_subset h)) + rcases hl ha with hpa|hpa + · rcases hl hb with hpb|hpb + · exact (weightMap f w).chain _ hpa _ hpb + · subst b + obtain ⟨q,_,rfl⟩:=Finset.mem_image.mp (Finsupp.mapDomain_support hpa) + exact hv q + · subst a + rcases hl hb with hpb|hpb + · obtain ⟨q,_,rfl⟩:=Finset.mem_image.mp (Finsupp.mapDomain_support hpb) + exact (hv q).symm + · subst b + exact Or.inl le_rfl + +lemma coneWeights_apply (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) + (t:I) (w:OrderWeights Q) (p:P) : + (coneWeights f v hv t w).weights p=(1-t.val)*(weightMap f w).weights p+if v=p then t.val else 0 := by + simp [coneWeights,Finsupp.single_apply,unitInterval.symm] + +lemma coneWeights_zero (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) (w:OrderWeights Q) : + coneWeights f v hv 0 w=weightMap f w := by + apply OrderWeights.ext + change (σ (0:I)).val • (weightMap f w).weights+Finsupp.single v (0:ℝ)=_ + simp + +lemma coneWeights_one (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) (w w':OrderWeights Q) : + coneWeights f v hv 1 w=coneWeights f v hv 1 w' := by + apply OrderWeights.ext + change (σ (1:I)).val • (weightMap f w).weights+Finsupp.single v (1:ℝ)=_ + simp [coneWeights] + +lemma coneWeights_support (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) (t:I) (w:OrderWeights Q) : + (coneWeights f v hv t w).weights.support⊆insert v (w.weights.support.image f) := by + intro p hp + rcases Finset.mem_union.mp (Finsupp.support_add hp) with h|h + · exact Finset.mem_insert_of_mem (Finsupp.mapDomain_support (Finsupp.support_smul h)) + · exact Finset.mem_insert.mpr (Or.inl (Finset.mem_singleton.mp (Finsupp.support_single_subset h))) + +lemma coneWeights_continuous (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) : + Continuous (fun p:I×OrderWeights Q=>coneWeights f v hv p.1 p.2) := by + apply orderWeights_prod_continuous + intro n x + let C:Finset P:=insert v (Finset.univ.image (f.comp (nerveChain x))) + have hC:IsChain (·≤·) (↑C:Set P):=by + intro a ha b hb _ + change a∈insert v (Finset.univ.image (f.comp (nerveChain x))) at ha + change b∈insert v (Finset.univ.image (f.comp (nerveChain x))) at hb + rcases Finset.mem_insert.mp ha with hpa|hpa + · subst a + rcases Finset.mem_insert.mp hb with hpb|hpb + · subst b;exact Or.inl le_rfl + · obtain ⟨j,_,rfl⟩:=Finset.mem_image.mp hpb + exact (hv (nerveChain x j)).symm + · rcases Finset.mem_insert.mp hb with hpb|hpb + · subst b + obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp hpa + exact hv (nerveChain x i) + · obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp hpa + obtain ⟨j,_,rfl⟩:=Finset.mem_image.mp hpb + exact (le_total i j).imp (fun h=>(f.comp (nerveChain x)).monotone h) (fun h=>(f.comp (nerveChain x)).monotone h) + + apply continuous_of_finite_chain_carrier _ C hC (Finset.insert_nonempty _ _) + · intro p a ha + have hs:=coneWeights_support f v hv p.1 (orderWeightsOfChain (nerveChain x) p.2) ha + rcases Finset.mem_insert.mp hs with rfl|hs + · exact Finset.mem_insert_self _ _ + · obtain ⟨q,hq,rfl⟩:=Finset.mem_image.mp hs + obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp (chainWeights_support _ _ hq) + exact Finset.mem_insert_of_mem (Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩) + · intro q + simp_rw [coneWeights_apply,weightMap_chain] + apply Continuous.add + · exact (continuous_const.sub (continuous_subtype_val.comp continuous_fst)).mul + ((weightEval_continuous q).comp ((chainWeightsChart_continuous _).comp continuous_snd)) + · split_ifs + · exact continuous_subtype_val.comp continuous_fst + · exact continuous_const + +noncomputable def coneWeightsContinuous (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) : + C(I×OrderWeights Q,OrderWeights P) :=⟨_,coneWeights_continuous f v hv⟩ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/ContractionPoint.lean b/lean/OAI/Topology/ArtinGroups/Realizations/ContractionPoint.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce40aacf81d91e26a14561da2ec0cc14f89e6c46 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/ContractionPoint.lean @@ -0,0 +1,87 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Initial + +namespace OAI + +namespace HarmonicArtin +open scoped unitInterval + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +noncomputable def contractionToPoint {X:Type*} [TopologicalSpace X] + (a:X) (H:ContinuousMap.Homotopy (ContinuousMap.id X) (ContinuousMap.const X a)) (b:X) : + ContinuousMap.Homotopy (ContinuousMap.id X) (ContinuousMap.const X b) := + H.trans { + toFun p:=H (σ p.1,b) + continuous_toFun:=H.continuous.comp ((unitInterval.continuous_symm.comp continuous_fst).prodMk continuous_const) + map_zero_left:=by intro x;rw [unitInterval.symm_zero,H.apply_one];rfl + map_one_left:=by intro x;rw [unitInterval.symm_one,H.apply_zero];rfl } + +theorem orderWeights_contractible_of_piece (r:P→P→Prop) (wf:WellFounded r) + (htotal:∀x y,x≠y → r x y ∨ r y x) (c:P) (a0:WeightContractionPiece r c) + (hl:∀v,v∉a0.carrier → ContractibleSpace (OrderWeights (WeightEarlierLink r v))) : + ContractibleSpace (OrderWeights P) := by + let X:Type u:={a:WeightContractionPiece r c // a0.Extends a} + let R:X→X→Prop:=fun a b=>a.val.Extends b.val + let : Nonempty X := ⟨a0,WeightContractionPiece.extends_refl a0⟩ + have hbound:∀C:Set X,IsChain R C→C.Nonempty→∃ub:X,∀a∈C,R a ub:=by + intro C hc hn + let D:Set (WeightContractionPiece r c):=Subtype.val '' C + have hd:IsChain WeightContractionPiece.Extends D:=by + rintro a ⟨a,ha,rfl⟩ b ⟨b,hb,rfl⟩ hne + exact hc ha hb (fun he=>hne (congrArg Subtype.val he)) + have hdn:D.Nonempty:=hn.image Subtype.val + let u:=WeightContractionPiece.union D hd hdn + have h0:a0.Extends u:=by + obtain ⟨a,ha⟩:=hn + exact WeightContractionPiece.extends_trans a.property + (WeightContractionPiece.extends_union D hd hdn ⟨a,ha,rfl⟩) + refine ⟨⟨u,h0⟩,?_⟩ + intro a ha + exact WeightContractionPiece.extends_union D hd hdn ⟨a,ha,rfl⟩ + obtain ⟨a,ha⟩:=exists_maximal_of_nonempty_chains_bounded (r:=R) hbound + (fun hab hbd=>WeightContractionPiece.extends_trans hab hbd) + have hfull:∀x,x∈a.val.carrier:=by + by_contra hn + obtain ⟨v,hv,heA⟩:=WeightContractionPiece.missing_minimal wf htotal a.val (not_forall.mp hn) + have hv0:v∉a0.carrier:=fun he=>hv (a.property.choose he) + let b:=WeightContractionPiece.successor wf a.val v hv heA (hl v hv0) + have hab:a.val.Extends b:=WeightContractionPiece.extends_successor wf a.val v hv heA (hl v hv0) + let z:X:=⟨b,WeightContractionPiece.extends_trans a.property hab⟩ + have hback:=ha z hab + exact hv (hback.choose (Set.mem_insert v a.val.carrier)) + let e:a.val.carrier≃oP:={ + toFun:=Subtype.val + invFun:=fun x=>⟨x,hfull x⟩ + left_inv:=fun _=>rfl + right_inv:=fun _=>rfl + map_rel_iff':=by intros;rfl } + exact (contractible_iff_id_nullhomotopic _).mpr + ⟨weightHomeomorph e (weightVertex ⟨c,a.val.root_mem⟩), + ⟨transportContraction (weightHomeomorph e) _ a.val.hom⟩⟩ + +theorem orderWeights_contractible_of_initial (r:P→P→Prop) (wf:WellFounded r) + (htotal:∀x y,x≠y → r x y ∨ r y x) (A:Set P) + (hdown:∀{x y},x∈A → r y x → y∈A) + (hA:ContractibleSpace (OrderWeights A)) + (hl:∀v,v∉A → ContractibleSpace (OrderWeights (WeightEarlierLink r v))) : + ContractibleSpace (OrderWeights P) := by + obtain ⟨a,⟨H⟩⟩:=@id_nullhomotopic _ _ hA + obtain ⟨v,hv⟩:=a.support_nonempty + let c:P:=v.val + + let H':ContinuousMap.Homotopy (ContinuousMap.id (OrderWeights A)) + (ContinuousMap.const _ (weightVertex v)):= + contractionToPoint a H (weightVertex v) + let a0:WeightContractionPiece r c:={ + carrier:=A + root_mem:=v.property + down:=hdown + hom:=H' } + exact orderWeights_contractible_of_piece r wf htotal c a0 hl + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/DeligneRankBound.lean b/lean/OAI/Topology/ArtinGroups/Realizations/DeligneRankBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..2c8cd323c01df5e262aeda2a66944e034feacd42 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/DeligneRankBound.lean @@ -0,0 +1,85 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.OrderWeightsContractibleUnique +import OAI.Topology.ArtinGroups.Harmonic.ResidueActiveEmpty +import OAI.Topology.ArtinGroups.Harmonic.ResidueEarlierLowerIso + +namespace OAI + +namespace HarmonicArtin +open Simplicial CategoryTheory +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) +local notation "m" => fusionLabelSize M +local notation "Q" => fusionQuiver m (coxeterFusionEdge M) (coxeterFusionEdge_symm M) +local notation "U" => fun J:Set S=>Set.range (unfoldedInclusion M J) + +omit [LinearOrder S] in +lemma sourceDeligne_rank_bound (X:Deligne M) : X.val.1.ncard≤Fintype.card S := by + simpa only [Nat.card_eq_fintype_card] using Set.ncard_le_card X.val.1 +omit [LinearOrder S] in +lemma sourceDeligne_rank_strictMono : StrictMono (fun X:Deligne M=>X.val.1.ncard) := by + intro X Y h + exact Set.ncard_lt_ncard (deligne_lt_type M h) (Set.toFinite _) + +private theorem strictResidue_rank (n:ℕ) : ∀(P:Deligne M),P.val.1.ncard=n → + ∀(q:ℤ) (x:Artin M),x∈P.val.2 → + (∀H,ClassCapOn Q (sourceFrameFamily M x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) → + Nonempty (SourceResidue M true P q) → + ContractibleSpace (OrderWeights (SourceResidue M true P q)) := by + induction n using Nat.strong_induction_on with + | h n ih => + intro P hn q x hx hb hne + let r:=SourceResidueEarlier M true P q + have hl:∀X:SourceResidue M true P q,Nonempty (WeightEarlierLower r X) → + ContractibleSpace (OrderWeights (WeightEarlierLower r X)):=by + intro X hX + have hh:=sourceResidueHeight_strict M X.property + let e:=sourceResidueEarlierLowerIso M X hh + have hsmall:Nonempty (SourceResidue M true X q):= + (hX.map e).map (sourceResidueLowerProjection M X.property) + have hrank:X.val.val.1.ncardX.val.val.1.ncard) (Fintype.card S) + (fun X=>sourceDeligne_rank_bound M X) (by intro X Y h;exact sourceDeligne_rank_strictMono M h) + hl (fun X hX=>sourceResidue_upper_weights_contractible M X (sourceResidueHeight_strict M X.property) hX) + ?_ hne + intro X Y hX hY + apply Subtype.ext + have hhX:=sourceResidueHeight_strict M X.property + have hhY:=sourceResidueHeight_strict M Y.property + exact sourceResidue_negative_sources_unique M X.property Y.property x hx hb hhX hhY + (sourceResidue_emptyLink_upper M X hhX hX) (sourceResidue_emptyLink_upper M Y hhY hY) + (sourceResidue_emptyLink_lower M X hhX hX) (sourceResidue_emptyLink_lower M Y hhY hY) + +theorem sourceStrictResidue_contractible (P:Deligne M) (q:ℤ) (x:Artin M) (hx:x∈P.val.2) + (hb:∀H,ClassCapOn Q (sourceFrameFamily M x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) + (hne:Nonempty (SourceResidue M true P q)) : + ContractibleSpace |CategoryTheory.nerve (SourceResidue M true P q)| := + nerveWeightsHomeomorph.contractibleSpace_iff.mpr + (strictResidue_rank M P.val.1.ncard P rfl q x hx hb hne) + +theorem sourceStrictResidue_empty_or_contractible (P:Deligne M) (q:ℤ) (x:Artin M) (hx:x∈P.val.2) + (hb:∀H,ClassCapOn Q (sourceFrameFamily M x H) (closedNeighborhood Q (U P.val.1)\U P.val.1) q) : + IsEmpty (SourceResidue M true P q) ∨ + ContractibleSpace |CategoryTheory.nerve (SourceResidue M true P q)| := by + by_cases h:Nonempty (SourceResidue M true P q) + · exact Or.inr (sourceStrictResidue_contractible M P q x hx hb h) + · exact Or.inl (not_nonempty_iff.mp h) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/DirectedCoverSequence.lean b/lean/OAI/Topology/ArtinGroups/Realizations/DirectedCoverSequence.lean new file mode 100644 index 0000000000000000000000000000000000000000..7f0d52e03c9f7560d2bfafd14a22a0416a15c4dd --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/DirectedCoverSequence.lean @@ -0,0 +1,73 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.Earlier + +namespace OAI + +namespace HarmonicArtin +attribute [local instance] Classical.decEq Classical.propDecidable +variable {P I : Type} [PartialOrder P] [Countable I] [Nonempty I] + +omit [PartialOrder P] in +lemma directed_cover_sequence (A : I → Set P) + (hd : ∀ i j, ∃ k, A i ⊆ A k ∧ A j ⊆ A k) : + ∃ c : ℕ → I, Monotone (fun n => A (c n)) ∧ ∀ i, ∃ n, A i ⊆ A (c n) := by + obtain ⟨e,he⟩ := exists_surjective_nat I + let upper : I → I → I := fun i j => (hd i j).choose + have hu : ∀ i j, A i ⊆ A (upper i j) ∧ A j ⊆ A (upper i j) := + fun i j => (hd i j).choose_spec + let c : ℕ → I := Nat.rec (e 0) (fun n i => upper i (e (n+1))) + have hc0 : c 0 = e 0 := rfl + have hcs : ∀ n, c (n+1) = upper (c n) (e (n+1)) := fun _ => rfl + have hcm : Monotone (fun n => A (c n)) := by + apply monotone_nat_of_le_succ + intro n + rw [hcs n] + exact (hu _ _).1 + refine ⟨c,hcm,?_⟩ + intro i + obtain ⟨n,rfl⟩ := he i + refine ⟨n,?_⟩ + cases n with + | zero => rw [hc0] + | succ n => rw [hcs n]; exact (hu _ _).2 + +theorem orderWeights_contractible_of_countable_directed_cover + (A : I → Set P) (hd : ∀ i j, ∃ k, A i ⊆ A k ∧ A j ⊆ A k) + (hc : ∀ p, ∃ i, p ∈ A i) + (hdown : ∀ i {p q}, p ≤ q → q ∈ A i → p ∈ A i) + (hA : ∀ i, ContractibleSpace (OrderWeights (A i))) + (k : P → ℕ) (N : ℕ) (hk : ∀ p, k p ≤ N) (hkm : StrictMono k) : + ContractibleSpace (OrderWeights P) := by + obtain ⟨c,hcm,hcf⟩ := directed_cover_sequence A hd + let B : ℕ → Set P := fun n => A (c n) + have hB : ∀ p, ∃ n, p ∈ B n := by + intro p + obtain ⟨i,hi⟩ := hc p + obtain ⟨n,hn⟩ := hcf i + exact ⟨n,hn hi⟩ + let f : P →o ℕ := { + toFun := fun p => Nat.find (hB p) + monotone' := by + intro p q hpq + apply Nat.find_min' + exact hdown _ hpq (Nat.find_spec (hB q)) } + have hf : ∀ p n, f p ≤ n ↔ p ∈ B n := by + intro p n + constructor + · intro h + exact hcm h (Nat.find_spec (hB p)) + · intro h + exact Nat.find_min' (hB p) h + apply orderWeights_contractible_of_natural_preimages f k N hk hkm + intro n + let e : {p : P // f p ≤ n} ≃o B n := { + toFun := fun p => ⟨p.val,(hf p.val n).mp p.property⟩ + invFun := fun p => ⟨p.val,(hf p.val n).mpr p.property⟩ + left_inv := fun _ => rfl + right_inv := fun _ => rfl + map_rel_iff' := by intros; rfl } + exact (weightHomeomorph e).contractibleSpace_iff.mpr (hA (c n)) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/EarlierUpperContractible.lean b/lean/OAI/Topology/ArtinGroups/Realizations/EarlierUpperContractible.lean new file mode 100644 index 0000000000000000000000000000000000000000..7954a6f9c61297b8c01f891634380c14f2058eef --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/EarlierUpperContractible.lean @@ -0,0 +1,23 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.NerveOrderMap +import OAI.Topology.ArtinGroups.Harmonic.EarlierUpper + +namespace OAI + +namespace HarmonicArtin +open Simplicial CategoryTheory + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) + +theorem sourceEarlierUpper_contractible (P:Deligne M) + (h:Nonempty (SourceEarlierUpper M P)) : + ContractibleSpace |nerve (SourceEarlierUpper M P)| := by + have ha:=(sourceEarlierUpper_nonempty_iff M P).mp h + exact nerve_contractible_of_order_clip (sourceUpperRetraction M P) + (sourceUpperCenter M P ha) (sourceUpperRetraction_le M P) + (sourceUpperRetraction_le_center M P ha) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/FiniteWeightedNatSums.lean b/lean/OAI/Topology/ArtinGroups/Realizations/FiniteWeightedNatSums.lean new file mode 100644 index 0000000000000000000000000000000000000000..55c2a3a5abf68005d5dbce7402bb46bde3446ff2 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/FiniteWeightedNatSums.lean @@ -0,0 +1,44 @@ +import Mathlib + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators + +theorem finite_weighted_nat_sums {ι:Type*} [Fintype ι] + (w:ι→ℝ) (hw:∀ i,0exists_nat_gt (B / w i) + have hfinite : {n:ι→ℕ | ∀ i,n i≤N i}.Finite := by + exact (Set.finite_Iic N) + apply (hfinite.image (fun n:ι→ℕ=>∑ i,w i*(n i:ℝ))).subset + rintro x ⟨hB,n,rfl⟩ + refine ⟨n,?_,rfl⟩ + intro i + have hs:w i*(n i:ℝ)≤∑ j,w j*(n j:ℝ) := + Finset.single_le_sum (fun j _=>mul_nonneg (hw j).le (Nat.cast_nonneg _)) (Finset.mem_univ i) + have hn:(n i:ℝ)≤B/w i := (le_div_iff₀ (hw i)).mpr (by simpa [mul_comm] using hs.trans hB) + exact_mod_cast (hn.trans (hN i).le) + +theorem finite_normalized_weighted_nat_sums {ι:Type*} [Fintype ι] + (w:ι→ℝ) (hw:∀ i,0w i/a) (fun i=>div_pos (hw i) ha) B + convert h using 1 + ext x + simp only [Set.mem_ofPred_eq] + apply and_congr_right + intro hx + apply exists_congr + intro n + have he : (∑ i,w i*(n i:ℝ))/a=∑ i,w i/a*(n i:ℝ) := by + rw [Finset.sum_div] + apply Finset.sum_congr rfl + intro i hi + ring + rw [he] + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/FiniteWeightsCompact.lean b/lean/OAI/Topology/ArtinGroups/Realizations/FiniteWeightsCompact.lean new file mode 100644 index 0000000000000000000000000000000000000000..a336886c8ece7f87c3343e742896e7b568b672db --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/FiniteWeightsCompact.lean @@ -0,0 +1,76 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightHomeomorph + +namespace OAI + +namespace HarmonicArtin +open Topology +open scoped unitInterval + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u v +variable {P : Type u} [PartialOrder P] + +noncomputable instance finiteWeightsCompact [Finite P] : CompactSpace (OrderWeights P) := by + let _ := Fintype.ofFinite P + let C := {c : Finset P // IsChain (· ≤ ·) (↑c : Set P) ∧ c.Nonempty} + let f := fun c : C => orderWeightsOfChain (finiteChainOrder c.val c.property.1 c.property.2) + have cover : (Set.univ : Set (OrderWeights P)) = ⋃ c : C, Set.range (f c) := by + apply Set.Subset.antisymm + · intro w _ + let c : C := ⟨w.weights.support, (fun p hp q hq _ => w.chain p hp q hq),w.support_nonempty⟩ + apply Set.mem_iUnion.mpr + refine ⟨c,carrierSimplex c.val c.property.1 c.property.2 w (Finset.Subset.refl _),?_⟩ + exact carrierSimplex_reconstruct c.val c.property.1 c.property.2 w _ + · exact Set.subset_univ _ + apply isCompact_univ_iff.mp + rw [cover] + exact isCompact_iUnion fun c => isCompact_range (chainWeightsChart_continuous _) + +lemma weightFiniteInclusion_closedEmbedding (A : Set P) (hA : A.Finite) : + IsClosedEmbedding (weightMap (weightInclusion A)) := by + let : Finite A := hA.to_subtype + exact (weightMap_continuous _).isClosedEmbedding + (weightMap_injective _ Subtype.val_injective) + +lemma weightRestrict_continuous_finite {X : Type v} [TopologicalSpace X] + (A : Set P) (hA : A.Finite) (f : C(X,OrderWeights P)) + (hf : ∀ x, ∀ p ∈ (f x).weights.support, p ∈ A) : + Continuous (fun x => weightRestrict A (f x) (hf x)) := by + apply (weightFiniteInclusion_closedEmbedding A hA).isEmbedding.isInducing.continuous_iff.mpr + exact f.continuous.congr fun x => (weightRestrict_map A (f x) (hf x)).symm + +theorem compact_map_finite_carrier {X : Type v} [TopologicalSpace X] [CompactSpace X] + (f : C(X,OrderWeights P)) : + ∃ (A : Set P) (_ : A.Finite) (g : C(X,OrderWeights A)), + (weightMapContinuous (weightInclusion A)).comp g = f := by + let A := weightCarrier (Set.range f) + have hA : A.Finite := weightCarrier_finite_of_isCompact (isCompact_range f.continuous) + have hf : ∀ x, ∀ p ∈ (f x).weights.support, p ∈ A := by + intro x p hp + exact ⟨f x,⟨x,rfl⟩,hp⟩ + let g : C(X,OrderWeights A) := + ⟨fun x => weightRestrict A (f x) (hf x),weightRestrict_continuous_finite A hA f hf⟩ + refine ⟨A,hA,g,?_⟩ + apply ContinuousMap.ext + intro x + exact weightRestrict_map A (f x) (hf x) + +theorem compact_map_factors_cover {X : Type v} [TopologicalSpace X] [CompactSpace X] + {ι : Type*} (B : ι → Set P) + (hB : ∀ A : Set P, A.Finite → ∃ i, A ⊆ B i) + (f : C(X,OrderWeights P)) : + ∃ i, ∃ g : C(X,OrderWeights (B i)), + (weightMapContinuous (weightInclusion (B i))).comp g = f := by + obtain ⟨A,hA,g,hg⟩ := compact_map_finite_carrier f + obtain ⟨i,hi⟩ := hB A hA + refine ⟨i,(weightMapContinuous (weightSubset A (B i) hi)).comp g,?_⟩ + apply ContinuousMap.ext + intro x + change weightMap (weightInclusion (B i)) (weightMap (weightSubset A (B i) hi) (g x)) = f x + rw [weightMap_comp] + exact congrArg (fun h : C(X,OrderWeights P) => h x) hg + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/FrameFamilyWeightedLevel.lean b/lean/OAI/Topology/ArtinGroups/Realizations/FrameFamilyWeightedLevel.lean new file mode 100644 index 0000000000000000000000000000000000000000..ad3e5ad508a3665bb36bee0ef30e26da1ec138f6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/FrameFamilyWeightedLevel.lean @@ -0,0 +1,30 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.FrameFamily + +namespace OAI + +namespace HarmonicArtin +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "hdiag" => coxeterFusionEdge_diag M +local notation "hm" => fusionLabelSize_ge_two M +local notation "Q" => fusionQuiver m d hd + +lemma sourceFrameFamily_weighted_level (z:Artin M) (q:ℤ) + (α:FusionVertex (V:=S⊕Unit) m) : + (∑H,fusionWeight m H*(classLevelArray Q (sourceFrameFamily M z H) (α,q):ℝ))= + fusionWeight m α.2*sourceMultiplicity M z q α.1 := by + obtain ⟨w,rfl⟩:=sourceSignedWord_surjective M z + rw [sourceMultiplicity_word,sourceFrameFamily_word] + have h:=congrFun (fusionOrbitWeightedVector_eq m d hd hdiag hm (sourcePacketWord w) (.inr ()) q) α + simpa only [fusionOrbitWeightedVector,Finset.sum_apply,Pi.smul_apply,smul_eq_mul, + fusionOrbitLayer_generator,fusionFold,sourcePacketMultiplicity] using h + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/FullSphericalCell.lean b/lean/OAI/Topology/ArtinGroups/Realizations/FullSphericalCell.lean new file mode 100644 index 0000000000000000000000000000000000000000..4b53567bace1dd38b6f81c6696b37cd4ca7cf0ae --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/FullSphericalCell.lean @@ -0,0 +1,61 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.PositiveLiftedCell + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] (M : CoxeterMatrix S) + +omit [Fintype S] in +lemma right_minimum_of_longest_additive (R : Set S) (q : M.Group) + (hq : IsParabolicLongest M R q) (w : M.Group) + (hw : M.toCoxeterSystem.length (w*q) = + M.toCoxeterSystem.length w + M.toCoxeterSystem.length q) : + ∀ v : coxeterParabolic M R, + M.toCoxeterSystem.length w ≤ M.toCoxeterSystem.length (w*v) := by + intro v + have hv : v.val⁻¹*q ∈ coxeterParabolic M R := + (coxeterParabolic M R).mul_mem ((coxeterParabolic M R).inv_mem v.property) hq.1 + have hb := hq.2 _ hv + have hl := M.toCoxeterSystem.length_mul_le (w*v.val) (v.val⁻¹*q) + have he : w*v.val*(v.val⁻¹*q) = w*q := by group + rw [he,hw] at hl + omega + +noncomputable def fullSphericalCell [Finite M.Group] : LiftedCell M := + (1,⟨Set.univ,show Finite (coxeterParabolic M Set.univ) from inferInstance⟩) + +theorem positiveCell_face_full_of_top_prefix [Finite M.Group] + (a : PositiveLiftedCell M) + (h : PositivePrefix M (positiveCellTop M a) + (positiveSimpleLift M (sphericalLongest M (fullSphericalCell M).2))) : + LiftedFace M (positiveCellToLifted M a) (fullSphericalCell M) := by + have ht : positiveCellTop M a = positiveSimpleLift M (positiveToCoxeter M (positiveCellTop M a)) := + positivePrefix_of_simple_eq M h rfl + have ha : a.1 = positiveSimpleLift M (positiveToCoxeter M a.1) := + (positive_simple_factors M a.1 (positiveSimpleLift M (sphericalLongest M a.2)) + (positiveToCoxeter M (positiveCellTop M a)) ht).1 + have hlen : M.toCoxeterSystem.length + (positiveToCoxeter M a.1 * sphericalLongest M a.2) = + M.toCoxeterSystem.length (positiveToCoxeter M a.1) + + M.toCoxeterSystem.length (sphericalLongest M a.2) := by + have hd := congrArg (positiveDegree M) ht + simp only [positiveCellTop,map_mul,positiveToCoxeter_simpleLift, + positiveDegree_mul,positiveDegree_simpleLift] at hd + rw [ha,positiveDegree_simpleLift] at hd + simpa only [positiveToCoxeter_simpleLift] using hd.symm + let w := reducedExpression M (positiveToCoxeter M a.1) + have hr := reducedExpression_reduced M (positiveToCoxeter M a.1) + have he := wordCoxeter_reducedExpression M (positiveToCoxeter M a.1) + refine ⟨Set.subset_univ _,w,(by intros; trivial),hr,?_,?_⟩ + · rw [he] + exact right_minimum_of_longest_additive M a.2.val _ (sphericalLongest_spec M a.2) _ hlen + · change positiveToArtin M a.1 = 1 * wordArtin M w + rw [one_mul,ha,positiveToArtin_simpleLift,←he,positiveLift_word M w hr] + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/FusionWeightSplit.lean b/lean/OAI/Topology/ArtinGroups/Realizations/FusionWeightSplit.lean new file mode 100644 index 0000000000000000000000000000000000000000..bc66e0a4d72fd6a4bc46a1c4cb956fe4083afb1b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/FusionWeightSplit.lean @@ -0,0 +1,107 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.FusionRest + +namespace OAI + +namespace HarmonicArtin +attribute [local instance] Classical.propDecidable +variable {E:Type} [Fintype E] [DecidableEq E] (m:E → ℕ) + +lemma fusionWeight_split (e:E) (L:FusionLabel m) : + fusionWeight m L = stringWeight (m e) (L e) * + fusionWeight (fun f:FusionRest e=>m f) (restLabel m e L) := + Fintype.prod_eq_mul_prod_subtype_ne (fun f=>stringWeight (m f) (L f)) e + +lemma fusionWeight_join (e:E) (r:FusionLabel (fun f:FusionRest e=>m f)) (j:StringLabel (m e)) : + fusionWeight m ((labelSplit m e).symm (r,j)) = + stringWeight (m e) j * fusionWeight (fun f:FusionRest e=>m f) r := by + rw [fusionWeight_split m e] + have h := (labelSplit m e).apply_symm_apply (r,j) + change (restLabel m e ((labelSplit m e).symm (r,j)),((labelSplit m e).symm (r,j)) e)=(r,j) at h + have h₁ := congrArg Prod.fst h + have h₂ := congrArg Prod.snd h + dsimp only at h₁ h₂ + rw [h₁,h₂] + +lemma finitePi_update_constant {α:E → Type*} {B:Type*} (f:((i:E) → α i) → B) + (hf:∀ x i a,f (Function.update x i a)=f x) (x y:(i:E) → α i) : f x=f y := by + have hh (s:Finset E) : ∀ x y:(i:E) → α i, (∀ i,i ∉ s → x i=y i) → f x=f y := by + induction s using Finset.induction_on with + | empty => + intro x y h + exact congrArg f (funext fun i=>h i (Finset.notMem_empty i)) + | @insert i s hi ih => + intro x y h + calc + f x = f (Function.update x i (y i)) := (hf x i (y i)).symm + _ = f y := ih _ _ (by + intro j hj + by_cases he:j=i + · subst j; exact Function.update_self _ _ _ + · rw [Function.update_of_ne he] + exact h j (by simp [he,hj])) + exact hh Finset.univ x y (by simp) + +lemma fusion_slice_proportional (hm:∀ e,2 ≤ m e) (f:FusionLabel m → ℝ) + (hf:∀ L,0≤f L) + (hs:∀ e (r:FusionLabel (fun g:FusionRest e=>m g)), ∃ c:ℝ, ∀ j, + f ((labelSplit m e).symm (r,j))=c*stringWeight (m e) j) : + ∃ c:ℝ, 0≤c ∧ ∀ L,f L=c*fusionWeight m L := by + let L₀ : FusionLabel m := fun e=>⟨0,by have := hm e; omega⟩ + let g (L:FusionLabel m) := f L / fusionWeight m L + have hg (L:FusionLabel m) (i:E) (j:StringLabel (m i)) : g (Function.update L i j)=g L := by + let r := restLabel m i L + obtain ⟨c,hc⟩ := hs i r + have he (a:StringLabel (m i)) : + g ((labelSplit m i).symm (r,a)) = c / fusionWeight (fun t:FusionRest i=>m t) r := by + dsimp [g] + rw [hc,fusionWeight_join] + have hw := ne_of_gt (stringWeight_pos (hm i) a) + have hr := ne_of_gt (fusionWeight_pos (fun t:FusionRest i=>m t) (fun t=>hm t) r) + field_simp + have hx : (labelSplit m i).symm (r,L i)=L := (labelSplit m i).symm_apply_apply L + have hy : (labelSplit m i).symm (r,j)=Function.update L i j := by + apply (labelSplit m i).injective + rw [Equiv.apply_symm_apply] + apply Prod.ext + · funext t + exact (Function.update_of_ne t.property _ _).symm + · change j = Function.update L i j i + exact (Function.update_self i j L).symm + exact (congrArg g hy.symm).trans ((he j).trans ((he (L i)).symm.trans (congrArg g hx))) + refine ⟨g L₀,div_nonneg (hf L₀) (le_of_lt (fusionWeight_pos m hm L₀)),fun L=>?_⟩ + have h := finitePi_update_constant (E:=E) g hg L L₀ + dsimp [g] at h ⊢ + exact (div_eq_iff (ne_of_gt (fusionWeight_pos m hm L))).mp h + +lemma fusion_weighted_matrix_proportional (hm:∀ e,2 ≤ m e) + (B:FusionLabel m → FusionLabel m → ℕ) + (hB:∀ e (r t:FusionLabel (fun g:FusionRest e=>m g)), ∃ c:ℝ, ∀ j, + (∑ i, stringWeight (m e) i * + (B ((labelSplit m e).symm (t,i)) ((labelSplit m e).symm (r,j)):ℝ))= + c*stringWeight (m e) j) : + ∃ c:ℝ,0≤c ∧ ∀ L, + (∑ H,fusionWeight m H*(B H L:ℝ))=c*fusionWeight m L := by + apply fusion_slice_proportional m hm (fun L=>∑ H,fusionWeight m H*(B H L:ℝ)) + · intro L + exact Finset.sum_nonneg fun H _=>mul_nonneg (le_of_lt (fusionWeight_pos m hm H)) (Nat.cast_nonneg _) + · intro e r + choose c hc using hB e r + refine ⟨∑ t,fusionWeight (fun g:FusionRest e=>m g) t*c t,fun j=>?_⟩ + rw [← (labelSplit m e).symm.sum_comp] + rw [Fintype.sum_prod_type] + simp_rw [fusionWeight_join] + calc + _ = ∑ t,fusionWeight (fun g:FusionRest e=>m g) t * + (∑ i,stringWeight (m e) i * (B ((labelSplit m e).symm (t,i)) ((labelSplit m e).symm (r,j)):ℝ)) := by + apply Finset.sum_congr rfl + intro t _ + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro i _ + ring + _ = _ := by simp_rw [hc]; rw [Finset.sum_mul]; apply Finset.sum_congr rfl; intro t _; ring + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/FusionWeightedHom.lean b/lean/OAI/Topology/ArtinGroups/Realizations/FusionWeightedHom.lean new file mode 100644 index 0000000000000000000000000000000000000000..eb4a4c1a291d21108805e9925fb9b11d4f72709a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/FusionWeightedHom.lean @@ -0,0 +1,80 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.FusionOrbitModel +import OAI.Topology.ArtinGroups.Complexes.HomDimensionRetract + +namespace OAI + +namespace HarmonicArtin +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq +attribute [local instance] Classical.propDecidable +variable {E V:Type} [Fintype E] [DecidableEq E] [Fintype V] [DecidableEq V] + (m:E → ℕ) (d:V → V → FusionEdge E) (hd:∀ s t,d s t=d t s) + (hdiag:∀ s,d s s=.units 0) +local notation "Q" => fusionQuiver m d hd +local notation "Y" => fusionOrbitLayer m d hd hdiag +local notation "O" => fusionOrbitModel m d hd hdiag + +theorem fusionOrbit_summand_secondary_bound (w:List (V × Bool)) (s:V) + (L H:FusionLabel m) {T:Type*} [Fintype T] (M:BasedComplex Q (K:=ℂ) T) + (U:Set (FusionVertex (V:=V) m)) (q k:ℤ) + (hM:∀ i,(M.placement i).level=q) (hU:∀ i,(M.placement i).color∈U) + (ι:Map Q M (Y w s L q)) (π:Map Q (Y w s L q) M) + (hret:ι.matrix*π.matrix=projectiveIdentity Q M.placement) + (hcap:(O w s L).complex.CappedOn Q U q) (hk:kfusionOrbitModel_negative_homDimension m d hd hdiag w s s L H n v (by omega)) + +theorem fusionOrbit_summand_middle (w:List (V × Bool)) (s:V) + (L H:FusionLabel m) {T:Type*} [Fintype T] (M:BasedComplex Q (K:=ℂ) T) + (q k:ℤ) (ι:Map Q M (Y w s L q)) (π:Map Q (Y w s L q) M) + (hret:ι.matrix*π.matrix=projectiveIdentity Q M.placement) : + totalHomDimension Q M (Y w s H k) (k-q+1)=0 := by + apply Nat.eq_zero_of_le_zero + have h:=totalHomDimension_retract_source Q M (Y w s L q) (Y w s H k) ι π hret (k-q+1) + rwa [fusionOrbitLayer_middle] at h + +noncomputable def fusionWeightedHom {T R:FusionLabel m → Type*} + [∀ L,Fintype (T L)] [∀ H,Fintype (R H)] + (P:∀ L,BasedComplex Q (K:=ℂ) (T L)) (F:∀ H,BasedComplex Q (K:=ℂ) (R H)) (t:ℤ) : ℝ := + ∑ L,∑ H,fusionWeight m L*fusionWeight m H*(totalHomDimension Q (P L) (F H) t:ℝ) + +lemma fusionWeightedHom_nonneg (hm:∀ e,2 ≤ m e) {T R:FusionLabel m → Type*} + [∀ L,Fintype (T L)] [∀ H,Fintype (R H)] + (P:∀ L,BasedComplex Q (K:=ℂ) (T L)) (F:∀ H,BasedComplex Q (K:=ℂ) (R H)) (t:ℤ) : + 0≤fusionWeightedHom m d hd P F t := by + apply Finset.sum_nonneg + intro L _ + apply Finset.sum_nonneg + intro H _ + exact mul_nonneg (mul_pos (fusionWeight_pos m hm L) (fusionWeight_pos m hm H)).le (Nat.cast_nonneg _) + +theorem fusionOrbit_weighted_secondary_bound (hm:∀ e,2 ≤ m e) + (w:List (V × Bool)) (s:V) {T:FusionLabel m → Type*} [∀ L,Fintype (T L)] + (M:∀ L,BasedComplex Q (K:=ℂ) (T L)) (U:Set (FusionVertex (V:=V) m)) (q k:ℤ) + (hM:∀ L i,((M L).placement i).level=q) (hU:∀ L i,((M L).placement i).color∈U) + (ι:∀ L,Map Q (M L) (Y w s L q)) (π:∀ L,Map Q (Y w s L q) (M L)) + (hret:∀ L,(ι L).matrix*(π L).matrix=projectiveIdentity Q (M L).placement) + (hcap:∀ L,(O w s L).complex.CappedOn Q U q) (hk:kY w s H k) (k-q) ≤ + fusionWeightedHom m d hd (fun H=>Y w s H (k-1)) M (q-k+1) := by + unfold fusionWeightedHom + rw [Finset.sum_comm (f:=fun H L=>fusionWeight m H*fusionWeight m L* + (totalHomDimension Q (Y w s H (k-1)) (M L) (q-k+1):ℝ))] + apply Finset.sum_le_sum + intro L _ + apply Finset.sum_le_sum + intro H _ + rw [mul_comm (fusionWeight m H) (fusionWeight m L)] + apply mul_le_mul_of_nonneg_left _ (mul_pos (fusionWeight_pos m hm L) (fusionWeight_pos m hm H)).le + exact_mod_cast fusionOrbit_summand_secondary_bound m d hd hdiag w s L H (M L) U q k + (hM L) (hU L) (ι L) (π L) (hret L) (hcap L) hk + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/LiftedFaceChart.lean b/lean/OAI/Topology/ArtinGroups/Realizations/LiftedFaceChart.lean new file mode 100644 index 0000000000000000000000000000000000000000..e4c10b302c92219fd2b4fcccf300764efc545b7c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/LiftedFaceChart.lean @@ -0,0 +1,95 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.PrincipalOrderIso + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric Topology + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [DecidableEq S] (M : CoxeterMatrix S) + +noncomputable def liftedFaceChart (a : LiftedCell M) : + CoxeterCellFace (restrictedMatrix M a.2.val) ≃o Set.Iic a := + (sourceCellFaceIso M a.2).trans (sourcePrincipalDeck M a) + +noncomputable def liftedFaceEmbedding (a : LiftedCell M) : + CoxeterCellFace (restrictedMatrix M a.2.val) →o LiftedCell M := + (weightInclusion (Set.Iic a)).comp + (liftedFaceChart M a : CoxeterCellFace (restrictedMatrix M a.2.val) →o Set.Iic a) + +lemma liftedFaceEmbedding_source (a : LiftedCell M) + (c : CoxeterCellFace (restrictedMatrix M a.2.val)) : + (liftedFaceEmbedding M a c).1=a.1*positiveLift M (restrictionHom M a.2.val c.val.1) := rfl + +lemma liftedFaceEmbedding_type (a : LiftedCell M) + (c : CoxeterCellFace (restrictedMatrix M a.2.val)) : + (liftedFaceEmbedding M a c).2.val=Subtype.val '' c.val.2 := rfl + +noncomputable def geometricFaceInclusion {a b : LiftedCell M} (h : a ≤ b) : + CoxeterCellFace (restrictedMatrix M a.2.val) →o CoxeterCellFace (restrictedMatrix M b.2.val) := + ((liftedFaceChart M b).symm : Set.Iic b →o CoxeterCellFace (restrictedMatrix M b.2.val)).comp + ((weightSubset (Set.Iic a) (Set.Iic b) (fun _ hx => hx.trans h)).comp + (liftedFaceChart M a : CoxeterCellFace (restrictedMatrix M a.2.val) →o Set.Iic a)) + +lemma geometricFaceInclusion_embeds {a b : LiftedCell M} (h : a ≤ b) + (c : CoxeterCellFace (restrictedMatrix M a.2.val)) : + liftedFaceEmbedding M b (geometricFaceInclusion M h c)=liftedFaceEmbedding M a c := by + exact congrArg Subtype.val ((liftedFaceChart M b).apply_symm_apply + (⟨(liftedFaceChart M a c).val,(liftedFaceChart M a c).property.trans h⟩ : Set.Iic b)) + +lemma geometricFaceInclusion_injective {a b : LiftedCell M} (h : a ≤ b) : + Function.Injective (geometricFaceInclusion M h) := by + intro c d he + apply (liftedFaceChart M a).injective + apply Subtype.val_injective + change liftedFaceEmbedding M a c=liftedFaceEmbedding M a d + rw [←geometricFaceInclusion_embeds M h c,←geometricFaceInclusion_embeds M h d,he] + +lemma geometricFaceInclusion_labels {a b : LiftedCell M} (h : a ≤ b) + (c : CoxeterCellFace (restrictedMatrix M a.2.val)) : + artinCoxeter M b.1 * restrictionHom M b.2.val (geometricFaceInclusion M h c).val.1 = + artinCoxeter M a.1 * restrictionHom M a.2.val c.val.1 ∧ + Subtype.val '' (geometricFaceInclusion M h c).val.2 = Subtype.val '' c.val.2 := by + have he := geometricFaceInclusion_embeds M h c + refine ⟨?_,congrArg (fun p : LiftedCell M => p.2.val) he⟩ + have hs := congrArg (fun p : LiftedCell M => artinCoxeter M p.1) he + simp only [liftedFaceEmbedding_source,map_mul,artinCoxeter_positiveLift] at hs + exact hs + +lemma sourceCellMap_barycentric (a : LiftedCell M) + (w : OrderWeights (CoxeterCellFace (restrictedMatrix M a.2.val))) : + sourceCellMap M a (permutahedronBarycentricHomeomorph (restrictedMatrix M a.2.val) w)= + weightMap (liftedFaceEmbedding M a) w := by + simp only [sourceCellMap,ContinuousMap.comp_apply,ContinuousMap.coe_mk, + liftedModelHomeomorph,sourceModelHomeomorph,Homeomorph.trans_apply, + Homeomorph.symm_apply_apply] + change weightMap (weightInclusion (Set.Iic a)) + (weightMap (sourcePrincipalDeck M a : Set.Iic ((1,a.2) : LiftedCell M) →o Set.Iic a) + (weightMap (sourceCellFaceIso M a.2 : + CoxeterCellFace (restrictedMatrix M a.2.val) →o Set.Iic ((1,a.2) : LiftedCell M)) w))=_ + rw [weightMap_comp,weightMap_comp] + rfl + +lemma sourceModelFaceMap_barycentric {a b : LiftedCell M} (h : a ≤ b) + (w : OrderWeights (CoxeterCellFace (restrictedMatrix M a.2.val))) : + sourceModelFaceMap M h (permutahedronBarycentricHomeomorph (restrictedMatrix M a.2.val) w)= + permutahedronBarycentricHomeomorph (restrictedMatrix M b.2.val) + (weightMap (geometricFaceInclusion M h) w) := by + apply sourceCellMap_injective M b + rw [sourceModelFaceMap_included,sourceCellMap_barycentric,sourceCellMap_barycentric,weightMap_comp] + congr 1 + apply OrderHom.ext + funext c + exact (geometricFaceInclusion_embeds M h c).symm + +lemma sourceModelFaceMap_affine {a b : LiftedCell M} (h : a ≤ b) + (w : OrderWeights (CoxeterCellFace (restrictedMatrix M a.2.val))) : + (sourceModelFaceMap M h (permutahedronBarycentricHomeomorph (restrictedMatrix M a.2.val) w)).val = + weightAffineValue (fun c => faceCenter (restrictedMatrix M b.2.val) (geometricFaceInclusion M h c)) w := by + rw [sourceModelFaceMap_barycentric,permutahedronBarycentricHomeomorph_apply] + exact Finsupp.linearCombination_mapDomain _ _ _ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/LiftedWeightStar.lean b/lean/OAI/Topology/ArtinGroups/Realizations/LiftedWeightStar.lean new file mode 100644 index 0000000000000000000000000000000000000000..8dc2681f73569175cb034566ec35e8f10719cd4a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/LiftedWeightStar.lean @@ -0,0 +1,91 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.CellUnion + +namespace OAI + +namespace HarmonicArtin +open Topology Set Filter CoxeterExchange + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [DecidableEq S] (M : CoxeterMatrix S) + +omit [DecidableEq S] in +lemma liftedDeck_incident_finite (a b : LiftedCell M) : + {g : Artin M | liftedDeck M g a ≤ b ∨ b ≤ liftedDeck M g a}.Finite := by + apply (((lifted_closed_cell_finite M b).image (fun c => c.1*a.1⁻¹)).union + ((lifted_closed_cell_finite M a).image (fun c => b.1*c.1⁻¹))).subset + intro g hg + rcases hg with hab|hba + · exact Or.inl ⟨liftedDeck M g a,hab,by change g*a.1*a.1⁻¹=g; simp [mul_assoc]⟩ + · refine Or.inr ⟨liftedDeck M g⁻¹ b,?_,?_⟩ + · have h := (liftedDeck M g).symm.monotone hba + rw [OrderIso.symm_apply_apply] at h + exact h + · change b.1*(g⁻¹*b.1)⁻¹=g + simp [mul_inv_rev] + +noncomputable def liftedWeightStar (a : LiftedCell M) : Set (OrderWeights (LiftedCell M)) := + {x | 0 < x.weights a} + +omit [Fintype S] [DecidableEq S] in +lemma liftedWeightStar_open (a : LiftedCell M) : IsOpen (liftedWeightStar M a) := + isOpen_lt continuous_const (weightEval_continuous a) + +omit [DecidableEq S] in +lemma liftedWeightStar_finite_translates (a b : LiftedCell M) : + {g : Artin M | ((g • ·) '' liftedWeightStar M a ∩ liftedWeightStar M b).Nonempty}.Finite := by + apply (liftedDeck_incident_finite M a b).subset + rintro g ⟨y,⟨x,hx,rfl⟩,hy⟩ + have ha : liftedDeck M g a ∈ (g • x).weights.support := by + rw [Finsupp.mem_support_iff,liftedWeights_smul_apply] + exact ne_of_gt hx + have hb : b ∈ (g • x).weights.support := Finsupp.mem_support_iff.mpr (ne_of_gt hy) + exact (g • x).chain _ ha _ hb + +instance sourceDeckT2 : T2Space (SalvettiDeckQuotient M) := by + change T2Space (Quotient (MulAction.orbitRel (Artin M) (OrderWeights (LiftedCell M)))) + rw [t2Space_iff_nhds] + let := MulAction.orbitRel (Artin M) (OrderWeights (LiftedCell M)) + let f : OrderWeights (LiftedCell M) → Quotient + (MulAction.orbitRel (Artin M) (OrderWeights (LiftedCell M))) := Quotient.mk' + have fop : IsOpenMap f := isOpenMap_quotient_mk'_mul + rintro ⟨x⟩ ⟨y⟩ (hxy : f x ≠ f y) + have hgxy : ∀ g : Artin M,g • x ≠ y := by + intro element equality + exact hxy.symm (Quotient.sound ⟨element,equality⟩) + obtain ⟨a,ha⟩ := x.support_nonempty + obtain ⟨b,hb⟩ := y.support_nonempty + let U := liftedWeightStar M a + let V := liftedWeightStar M b + have hU : U ∈ 𝓝 x := (liftedWeightStar_open M a).mem_nhds + (lt_of_le_of_ne (x.nonneg a) (Ne.symm (Finsupp.mem_support_iff.mp ha))) + have hV : V ∈ 𝓝 y := (liftedWeightStar_open M b).mem_nhds + (lt_of_le_of_ne (y.nonneg b) (Ne.symm (Finsupp.mem_support_iff.mp hb))) + let K := {g : Artin M | ((g • ·) '' U ∩ V).Nonempty} + have hK : K.Finite := liftedWeightStar_finite_translates M a b + choose u v hu hv huv using fun g => t2_separation_nhds (hgxy g) + let U' := (⋂ g ∈ K,(g • ·) ⁻¹' u g) ∩ U + let V' := (⋂ g ∈ K,v g) ∩ V + have hU' : f '' U' ∈ 𝓝 (f x) := by + apply fop.image_mem_nhds + refine inter_mem ((biInter_mem hK).mpr (fun g _ => ?_)) hU + exact (continuous_const_smul g).continuousAt (hu g) + have hV' : f '' V' ∈ 𝓝 (f y) := + fop.image_mem_nhds (inter_mem ((biInter_mem hK).mpr (fun g _ => hv g)) hV) + refine ⟨f '' U',hU',f '' V',hV',MulAction.disjoint_image_image_iff.mpr ?_⟩ + rintro z ⟨hz,hzU⟩ g ⟨hgz,hgzV⟩ + have hg : g ∈ K := ⟨g • z,mem_image_of_mem _ hzU,hgzV⟩ + exact (huv g).le_bot ⟨mem_iInter₂.mp hz g hg,mem_iInter₂.mp hgz g hg⟩ + +instance sourceSalvettiT2 : T2Space (SourceSalvetti M) := + (sourceSalvettiHomeomorph M).isEmbedding.t2Space + +instance sourceModelCompact (T : SphericalType M) : CompactSpace (SourceModelCell M T) := + isCompact_iff_compactSpace.mp (Geometric.permutahedron_compact (restrictedMatrix M T.val)) + +instance sourceSalvettiCompact : CompactSpace (SourceSalvetti M) := + Quotient.compactSpace + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/ModelFaceHomeomorph.lean b/lean/OAI/Topology/ArtinGroups/Realizations/ModelFaceHomeomorph.lean new file mode 100644 index 0000000000000000000000000000000000000000..782019ccda7b2e20490966b31986c632f8282dee --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/ModelFaceHomeomorph.lean @@ -0,0 +1,127 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Geometry.StrictLinearBoundInterior +import OAI.Topology.ArtinGroups.Realizations.LiftedFaceChart + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric Topology + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [DecidableEq S] (M : CoxeterMatrix S) + +lemma liftedFaceEmbedding_injective (a : LiftedCell M) : + Function.Injective (liftedFaceEmbedding M a) := + Subtype.val_injective.comp (liftedFaceChart M a).injective + +lemma liftedFaceEmbedding_le_iff (a : LiftedCell M) + (c d : CoxeterCellFace (restrictedMatrix M a.2.val)) : + liftedFaceEmbedding M a c ≤ liftedFaceEmbedding M a d ↔ c ≤ d := + (liftedFaceChart M a).le_iff_le + +lemma liftedFaceEmbedding_le (a : LiftedCell M) + (c : CoxeterCellFace (restrictedMatrix M a.2.val)) : + liftedFaceEmbedding M a c ≤ a := (liftedFaceChart M a c).property + +lemma liftedFaceEmbedding_full (a : LiftedCell M) : + liftedFaceEmbedding M a (fullCoxeterFace (restrictedMatrix M a.2.val))=a := by + apply le_antisymm (liftedFaceChart M a _).property + have h := (liftedFaceChart M a).monotone + (face_le_full (restrictedMatrix M a.2.val) ((liftedFaceChart M a).symm ⟨a,le_refl a⟩)) + rw [OrderIso.apply_symm_apply] at h + exact h + +lemma liftedFaceEmbedding_one (T : SphericalType M) + (c : CoxeterCellFace (restrictedMatrix M T.val)) : + liftedFaceEmbedding M (1,T) c=sourceFaceLifted M T c := by + exact Prod.ext (one_mul _) rfl + +lemma sourceCellMap_face_iff (a : LiftedCell M) (x : SourceModelCell M a.2) + (c : CoxeterCellFace (restrictedMatrix M a.2.val)) : + x.val ∈ facePolytope (restrictedMatrix M a.2.val) c ↔ + ∀ p ∈ (sourceCellMap M a x).weights.support,p ≤ liftedFaceEmbedding M a c := by + let : DecidableEq (LiftedCell M) := Classical.decEq _ + obtain ⟨w,rfl⟩ := (permutahedronBarycentricHomeomorph (restrictedMatrix M a.2.val)).surjective x + rw [permutahedronBarycentricHomeomorph_apply,barycentric_point_face_iff, + sourceCellMap_barycentric,weightMap_support_embedding _ (liftedFaceEmbedding_injective M a)] + constructor + · intro hw p hp + obtain ⟨d,hd,rfl⟩ := Finset.mem_image.mp hp + exact (liftedFaceEmbedding M a).monotone (hw d hd) + · intro hw d hd + exact (liftedFaceEmbedding_le_iff M a d c).mp (hw _ (Finset.mem_image.mpr ⟨d,hd,rfl⟩)) + +lemma sourceModelFaceMap_range (b : LiftedCell M) + (c : CoxeterCellFace (restrictedMatrix M b.2.val)) (z : SourceModelCell M b.2) : + z.val ∈ facePolytope (restrictedMatrix M b.2.val) c ↔ + ∃ x,sourceModelFaceMap M (liftedFaceEmbedding_le M b c) x=z := by + rw [sourceCellMap_face_iff] + constructor + · intro hz + obtain ⟨x,hx⟩ := sourceCellMap_range M (liftedFaceEmbedding M b c) (sourceCellMap M b z) hz + refine ⟨x,sourceCellMap_injective M b ?_⟩ + exact (sourceModelFaceMap_included M (liftedFaceEmbedding_le M b c) x).trans hx + · rintro ⟨x,rfl⟩ + rw [sourceModelFaceMap_included] + exact sourceCellMap_support M _ x + +lemma sourceModelFaceMap_injective {a b : LiftedCell M} (h : a ≤ b) : + Function.Injective (sourceModelFaceMap M h) := by + intro x y he + apply sourceCellMap_injective M a + rw [←sourceModelFaceMap_included M h,←sourceModelFaceMap_included M h,he] + +noncomputable def sourceModelFaceHomeomorph (b : LiftedCell M) + (c : CoxeterCellFace (restrictedMatrix M b.2.val)) : + SourceModelCell M (liftedFaceEmbedding M b c).2 ≃ₜ + {z : SourceModelCell M b.2 // z.val ∈ facePolytope (restrictedMatrix M b.2.val) c} := by + letI : CompactSpace (SourceModelCell M (liftedFaceEmbedding M b c).2) := + isCompact_iff_compactSpace.mp (permutahedron_compact (restrictedMatrix M (liftedFaceEmbedding M b c).2.val)) + let f : SourceModelCell M (liftedFaceEmbedding M b c).2 → + {z : SourceModelCell M b.2 // z.val ∈ facePolytope (restrictedMatrix M b.2.val) c} := fun x => + ⟨sourceModelFaceMap M (liftedFaceEmbedding_le M b c) x, + (sourceModelFaceMap_range M b c _).mpr ⟨x,rfl⟩⟩ + have hf : Function.Bijective f := by + constructor + · exact fun x y h => sourceModelFaceMap_injective M _ (congrArg Subtype.val h) + · intro z + obtain ⟨x,hx⟩ := (sourceModelFaceMap_range M b c z.val).mp z.property + exact ⟨x,Subtype.ext hx⟩ + exact (show Continuous (Equiv.ofBijective f hf) from + (sourceModelFaceMap M (liftedFaceEmbedding_le M b c)).continuous.subtype_mk _).homeoOfEquivCompactToT2 + +lemma sourceCellMap_frontier_iff (a : LiftedCell M) (x : SourceModelCell M a.2) : + x.val ∈ frontier (permutahedron (restrictedMatrix M a.2.val)) ↔ + weightMax (sourceCellMap M a x) ≠ a := by + rw [permutahedron_frontier_faces] + constructor + · rintro ⟨c,hc,hx⟩ he + have hm := (sourceCellMap_face_iff M a x c).mp hx _ (weightMax_mem (sourceCellMap M a x)) + rw [he] at hm + have hh := (liftedFaceEmbedding_full M a).trans_le hm + exact hc.not_ge ((liftedFaceEmbedding_le_iff M a _ _).mp hh) + · intro hn + let d : Set.Iic a := ⟨weightMax (sourceCellMap M a x), + sourceCellMap_support M a x _ (weightMax_mem (sourceCellMap M a x))⟩ + let c := (liftedFaceChart M a).symm d + have he : liftedFaceEmbedding M a c=weightMax (sourceCellMap M a x) := + congrArg Subtype.val ((liftedFaceChart M a).apply_symm_apply d) + refine ⟨c,lt_of_le_of_ne (face_le_full _ c) ?_,(sourceCellMap_face_iff M a x c).mpr ?_⟩ + · intro h + have hh := congrArg (liftedFaceEmbedding M a) h + rw [he,liftedFaceEmbedding_full] at hh + exact hn hh + · rw [he] + exact le_weightMax _ + +lemma sourceCellMap_interior_iff (a : LiftedCell M) (x : SourceModelCell M a.2) : + x.val ∈ interior (permutahedron (restrictedMatrix M a.2.val)) ↔ + weightMax (sourceCellMap M a x)=a := by + have hc := (permutahedron_compact (restrictedMatrix M a.2.val)).isClosed + have hf := sourceCellMap_frontier_iff M a x + rw [frontier, hc.closure_eq,Set.mem_sdiff,and_iff_right x.property] at hf + exact not_iff_not.mp hf + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/MulBlockDiagonal'Entry.lean b/lean/OAI/Topology/ArtinGroups/Realizations/MulBlockDiagonal'Entry.lean new file mode 100644 index 0000000000000000000000000000000000000000..16338b3e3d8f8bae328f32db821f4ade02de7aa8 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/MulBlockDiagonal'Entry.lean @@ -0,0 +1,32 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.ReversibleQuiver + +namespace OAI + +namespace Matrix +open scoped _root_.Matrix +variable {R T X : Type*} [Semiring R] [Fintype T] [DecidableEq T] + {B C : T → Type*} [∀ i, Fintype (B i)] +lemma mul_blockDiagonal'_entry (M : Matrix X (Sigma B) R) + (S : (i:T) → Matrix (B i) (C i) R) (x:X) (j:T) (y:C j) : + (M * _root_.Matrix.blockDiagonal' S) x ⟨j,y⟩ = ∑ z, M x ⟨j,z⟩ * S j z y := by + rw [_root_.Matrix.mul_apply,Fintype.sum_sigma,Finset.sum_eq_single j] + · simp only [_root_.Matrix.blockDiagonal'_apply_eq] + · intro i hi hij + apply Finset.sum_eq_zero + intro z hz + rw [_root_.Matrix.blockDiagonal'_apply_ne _ _ _ hij,mul_zero] + · simp +lemma blockDiagonal'_mul_entry (S : (i:T) → Matrix (C i) (B i) R) + (M : Matrix (Sigma B) X R) (i:T) (x:C i) (y:X) : + (_root_.Matrix.blockDiagonal' S * M) ⟨i,x⟩ y = ∑ z, S i x z * M ⟨i,z⟩ y := by + rw [_root_.Matrix.mul_apply,Fintype.sum_sigma,Finset.sum_eq_single i] + · simp only [_root_.Matrix.blockDiagonal'_apply_eq] + · intro j hj hji + apply Finset.sum_eq_zero + intro z hz + rw [_root_.Matrix.blockDiagonal'_apply_ne _ _ _ (Ne.symm hji),zero_mul] + · simp +end Matrix + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/NegativeBlockContractible.lean b/lean/OAI/Topology/ArtinGroups/Realizations/NegativeBlockContractible.lean new file mode 100644 index 0000000000000000000000000000000000000000..02f9fe8806f2be0a217df5c1303f4245dac6c4c0 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/NegativeBlockContractible.lean @@ -0,0 +1,102 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.SpecialResidueRank +import OAI.Topology.ArtinGroups.Harmonic.NullPatch2 +import OAI.Topology.ArtinGroups.Harmonic.EligibleLeftNonempty + +namespace OAI + +namespace HarmonicArtin +open scoped _root_.Matrix _root_.OAI.Matrix +open CategoryTheory Simplicial ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) + +lemma sourceNegativeBlock_contractible (P:Deligne M) (i:S) (hi:i∈P.val.1) + (hs:sourceCosetSign M P (sourcePeak M P i) (.inl i)= -1) + (V:SourceAllEligibleLower M P) (ho:i∉V.val.val.1) : + ContractibleSpace (OrderWeights (SourceAllEligibleLower M P)) := by + let B:=sourceTypeComponent M P i hi + have hB:B⊆P.val.1:=sourceTypeComponent_subset M P i hi + have hc:∀s∈B,∀t∈P.val.1\B,M s t=2:=sourceTypeComponent_commutes M P i hi + let q:=sourcePeak M P i + have hp:∀j∈B,sourcePeak M P j=q:=sourceTypeComponent_peak M P i hi + let x:=sourceCosetRepresentative M P + have hx:=sourceCosetRepresentative_mem M P + let R:=sourceCoset M B (source_spherical_mono M hB P.property.1) x + have hsg:∀j∈B,sourceCosetSign M P q (.inl j)=if true then -1 else 1:=by + intro j hj + exact (sourceTypeComponent_sign M P i hi j hj).trans hs + let e:=sourceEligibleFactor M P R hB q true hp hsg (sourceBlock_vector M P B hB hc x hx q) + have hn:=sourceBlock_eligible_nonempty M P B hB hc x hx V i (sourceTypeComponent_self M P i hi) ho + have hr:ContractibleSpace (OrderWeights (SourceResidue M true R q)):= + nerveWeightsHomeomorph.contractibleSpace_iff.mp + (sourceStrictResidue_contractible M R q x (rightCoset_self M B x) + (sourceBlock_boundary_cap M P B hB hc q hp x hx) (Nonempty.map e hn)) + exact sourceBlock_allEligible_contractible M P B hB hc x hx + ((weightHomeomorph e).contractibleSpace_iff.mpr hr) + +lemma sourcePositiveBlock_contractible (P:Deligne M) (q:ℕ) (i:S) (_hi:i∈P.val.1) + (hp:0sourceCosetVector M P d) q (.inl i)) : + ContractibleSpace (OrderWeights (SourceAllEligibleLower M P)) := by + let I:Set S:={j | (.inl j:S⊕Unit)∈sourcePositiveComponent M (sourceCosetVector M P q) (.inl i)} + let B:=P.val.1∩I + have hB:B⊆P.val.1:=Set.inter_subset_left + have hiI:i∈I:=Relation.ReflTransGen.refl + have hc:∀s∈B,∀t∈P.val.1\B,M s t=2:=by + intro s hs t ht + exact sourcePositiveBlock_commutes M P q (.inl i) hp s t hs.1 hs.2 ht.1 + (fun h=>ht.2 ⟨ht.1,h⟩) + have hpeak:∀j∈B,sourcePeak M P j=q:=fun j hj=>sourceNullSign_peak M P q (.inl i) hp hn j hj.1 hj.2 + have hsg:∀j∈B,sourceCosetSign M P q (.inl j)=if false then -1 else 1:=fun j hj=> + sourceNullSign_sign M P q (.inl i) hp hn (.inl j) hj.2 + let x:=sourceCosetRepresentative M P + have hx:=sourceCosetRepresentative_mem M P + let R:=sourceCoset M B (source_spherical_mono M hB P.property.1) x + let c:=sourceNullPatch M P q (.inl i) + have hI:Sum.inl '' I=sourcePositiveComponent M (sourceCosetVector M P q) (.inl i):= + sourceNullSign_image M P q (.inl i) hn + have hcSupp:∀v,v∉Sum.inl '' I→c v=0:=by + intro v hv + rw [hI] at hv + exact ite_eq_right hv + have hcPos:∀v,v∈Sum.inl '' I→0sourceCosetVector M P d) q (.inl i) + · exact sourcePositiveBlock_contractible M P q i hi (sourcePeak_positive M P i hi) hn + · have hs:sourceCosetSign M P q (.inl i)= -1:=by + change sourceSignAt M _ q (.inl i)= -1 + rw [sourceSignAt,ite_eq_right (ne_of_gt (sourcePeak_positive M P i hi)),ite_eq_right hn] + exact sourceNegativeBlock_contractible M P i hi hs V ho + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/NerveChain.lean b/lean/OAI/Topology/ArtinGroups/Realizations/NerveChain.lean new file mode 100644 index 0000000000000000000000000000000000000000..fc9b8424e80a027a041459501d0701f337fa7c0a --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/NerveChain.lean @@ -0,0 +1,127 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.RealizeSimplex +import OAI.Topology.ArtinGroups.Realizations.WeightDim +import OAI.Topology.ArtinGroups.Harmonic.SimplexSupport + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators +open Simplicial CategoryTheory Opposite Convexity + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +noncomputable def nerveOfChain {n:ℕ} (x:Fin (n+1) →o P) : (nerve P).obj (op ⦋n⦌) := x.toFunctor + +noncomputable def nerveWeightsSimplex {n:SimplexCategory} (x:(nerve P).obj (op n)) : + C(StdSimplex ℝ (Fin (n.len+1)),OrderWeights P) := + ⟨fun z=>orderWeightsOfChain (nerveChain x) z,orderWeightsChart_continuous x⟩ + +noncomputable def nerveWeightsMap : nerve P⟶TopCat.toSSet.obj (TopCat.of (OrderWeights P)) where + app n:=↾fun x=>(TopCat.toSSetObjEquiv _ n).symm (nerveWeightsSimplex x) + naturality {n m} a:=by + apply ConcreteCategory.hom_ext + intro x + apply (TopCat.toSSetObjEquiv _ m).injective + ext z : 1 + apply OrderWeights.ext + exact chainWeights_natural (nerveChain x) a.unop.toOrderHom z + +noncomputable def nerveToWeights : C(|nerve P|,OrderWeights P) := + ((sSetTopAdj.homEquiv _ _).symm nerveWeightsMap).hom + +lemma nerveToWeights_simplex {n:SimplexCategory} (x:(nerve P).obj (op n)) + (z:StdSimplex ℝ (Fin (n.len+1))) : + nerveToWeights (realizeSimplex (nerve P) x z)=orderWeightsOfChain (nerveChain x) z := by + have he:(sSetTopAdj.homEquiv _ _) (TopCat.ofHom (nerveToWeights (P:=P)))=nerveWeightsMap:= + (sSetTopAdj.homEquiv _ _).apply_symm_apply _ + rw [Adjunction.homEquiv_unit] at he + have hh:=ConcreteCategory.congr_hom (congrArg (fun f:nerve P ⟶ TopCat.toSSet.obj (TopCat.of (OrderWeights P))=>f.app (op n)) he) x + have ht:=congrArg (fun f=>(TopCat.toSSetObjEquiv _ (op n)) f z) hh + exact ht + +noncomputable def weightsToNerve (w:OrderWeights P) : |nerve P| := + realizeSimplex (nerve P) (n:=⦋weightDim w⦌) (nerveOfChain (weightChain w)) (weightSimplex w) + +lemma nerveToWeights_weightsToNerve (w:OrderWeights P) : + nerveToWeights (weightsToNerve w)=w := by + unfold weightsToNerve + rw [nerveToWeights_simplex (n:=⦋weightDim w⦌)] + exact orderWeightsOfChain_canonical w + +noncomputable def supportedWeightMap {n:ℕ} (x:Fin (n+1)→o P) + (z:StdSimplex ℝ (Fin (n+1))) : + Fin (simplexSupportDim z+1) →o Fin (weightDim (orderWeightsOfChain x z)+1) := + { toFun:=fun i=>(weightEnum (orderWeightsOfChain x z)).symm + ⟨x (simplexSupportInclusion z i),chainWeights_support_positive x z (simplexSupportEnum z i).property⟩ + monotone':=fun _ _ h=>(weightEnum (orderWeightsOfChain x z)).symm.monotone + (x.monotone ((simplexSupportInclusion z).monotone h)) } + +lemma supportedWeightMap_chain {n:ℕ} (x:Fin (n+1)→o P) + (z:StdSimplex ℝ (Fin (n+1))) : + (weightChain (orderWeightsOfChain x z)).comp (supportedWeightMap x z)= + x.comp (simplexSupportInclusion z) := by + apply DFunLike.ext + intro i + change ((weightEnum (orderWeightsOfChain x z)) ((weightEnum (orderWeightsOfChain x z)).symm _)).val=_ + exact congrArg Subtype.val ((weightEnum (orderWeightsOfChain x z)).apply_symm_apply _) + +lemma supportedWeightMap_simplex {n:ℕ} (x:Fin (n+1)→o P) + (z:StdSimplex ℝ (Fin (n+1))) : + StdSimplex.map (supportedWeightMap x z) (simplexSupported z)= + weightSimplex (orderWeightsOfChain x z) := by + apply chainWeights_coordinates_injective _ (weightChain_injective _) + rw [← chainWeights_natural,supportedWeightMap_chain,chainWeights_natural,simplexSupported_map] + exact congrArg OrderWeights.weights (orderWeightsOfChain_canonical (orderWeightsOfChain x z)).symm + +lemma weightsToNerve_simplex {n:SimplexCategory} (x:(nerve P).obj (op n)) + (z:StdSimplex ℝ (Fin (n.len+1))) : + weightsToNerve (orderWeightsOfChain (nerveChain x) z)=realizeSimplex (nerve P) x z := by + let a:⦋simplexSupportDim z⦌⟶n:=SimplexCategory.mkHom (simplexSupportInclusion z) + let b:⦋simplexSupportDim z⦌⟶⦋weightDim (orderWeightsOfChain (nerveChain x) z)⦌:= + SimplexCategory.mkHom (supportedWeightMap (nerveChain x) z) + have he:(nerve P).map b.op (nerveOfChain (weightChain (orderWeightsOfChain (nerveChain x) z)))= + (nerve P).map a.op x:=by + apply nerve.ext_of_isThin + funext i + exact DFunLike.congr_fun (supportedWeightMap_chain (nerveChain x) z) i + have h₁:=realizeSimplex_natural (nerve P) b + (nerveOfChain (weightChain (orderWeightsOfChain (nerveChain x) z))) (simplexSupported z) + have h₂:=realizeSimplex_natural (nerve P) a x (simplexSupported z) + change _=realizeSimplex (nerve P) x (StdSimplex.map (simplexSupportInclusion z) (simplexSupported z)) at h₂ + rw [simplexSupported_map] at h₂ + have hb:StdSimplex.map b.toOrderHom (simplexSupported z)=weightSimplex (orderWeightsOfChain (nerveChain x) z):= + supportedWeightMap_simplex (nerveChain x) z + rw [he,hb] at h₁ + exact h₁.symm.trans h₂ + +lemma weightsToNerve_continuous : Continuous (weightsToNerve (P:=P)) := by + rw [orderWeights_continuous_iff] + intro n x + simp_rw [weightsToNerve_simplex] + exact (realizeSimplex (nerve P) x).continuous + +noncomputable def nerveWeightsHomeomorph : |nerve P| ≃ₜ OrderWeights P := by + have he:ContinuousMap.comp ⟨weightsToNerve,weightsToNerve_continuous⟩ nerveToWeights=ContinuousMap.id |nerve P|:=by + have ht:TopCat.ofHom (ContinuousMap.comp ⟨weightsToNerve,weightsToNerve_continuous⟩ nerveToWeights)=𝟙 |nerve P|:=by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_unit,Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + change weightsToNerve (nerveToWeights (realizeSimplex (nerve P) x z))=realizeSimplex (nerve P) x z + rw [nerveToWeights_simplex,weightsToNerve_simplex] + exact congrArg TopCat.Hom.hom ht + exact { + toFun:=nerveToWeights + invFun:=weightsToNerve + left_inv:=fun x=>ContinuousMap.congr_fun he x + right_inv:=nerveToWeights_weightsToNerve + continuous_toFun:=nerveToWeights.continuous + continuous_invFun:=weightsToNerve_continuous } + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/NerveOrderMap.lean b/lean/OAI/Topology/ArtinGroups/Realizations/NerveOrderMap.lean new file mode 100644 index 0000000000000000000000000000000000000000..908928092e53d56915f7577459508fd9a004098d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/NerveOrderMap.lean @@ -0,0 +1,127 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.PrismSimplexZero + +namespace OAI + +namespace HarmonicArtin +universe u +open scoped unitInterval +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable + +noncomputable def nerveOrderMap {P Q:Type u} [Preorder P] [Preorder Q] (f:P→oQ) : + C(|nerve P|,|nerve Q|) := (SSet.toTop.map (nerveMap f.toFunctor)).hom + +noncomputable def nervePrismMap {P Q:Type u} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) : nerve P⟶TopCat.toSSet.obj (TopCat.of C(I,|nerve Q|)) where + app n:=↾fun x=>(TopCat.toSSetObjEquiv _ n).symm (nervePrismSimplex f g h x) + naturality {n m} a:=by + apply ConcreteCategory.hom_ext + intro x + apply (TopCat.toSSetObjEquiv _ m).injective + ext z t + exact nervePrismSimplex_natural f g h a.unop x z t + +noncomputable def nervePrismReal {P Q:Type u} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) : C(|nerve P|,C(I,|nerve Q|)) := + ((sSetTopAdj.homEquiv _ _).symm (nervePrismMap f g h)).hom + +noncomputable def nervePathEvaluate (Q:Type u) [Preorder Q] (t:I) : + TopCat.of C(I,|nerve Q|)⟶|nerve Q| := + TopCat.ofHom ⟨fun f=>f t,continuous_eval_const t⟩ + +lemma nervePrismReal_zero {P Q:Type u} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) : + TopCat.ofHom (nervePrismReal f g h)≫nervePathEvaluate Q 0= + SSet.toTop.map (nerveMap g.toFunctor) := by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_naturality_right] + simp only [nervePrismReal,TopCat.ofHom_hom,Equiv.apply_symm_apply] + rw [Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + change nervePrismSimplex f g h x z 0= + SSet.toTop.map (nerveMap g.toFunctor) (realizeSimplex (nerve P) x z) + rw [nervePrismSimplex_zero,realizeSimplex_map] + +lemma nervePrismReal_one {P Q:Type u} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) : + TopCat.ofHom (nervePrismReal f g h)≫nervePathEvaluate Q 1= + SSet.toTop.map (nerveMap f.toFunctor) := by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_naturality_right] + simp only [nervePrismReal,TopCat.ofHom_hom,Equiv.apply_symm_apply] + rw [Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + change nervePrismSimplex f g h x z 1= + SSet.toTop.map (nerveMap f.toFunctor) (realizeSimplex (nerve P) x z) + rw [nervePrismSimplex_one,realizeSimplex_map] + +noncomputable def nerveOrderComparisonHomotopy {P Q:Type u} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) : + ContinuousMap.Homotopy (nerveOrderMap f) (nerveOrderMap g) := + (show ContinuousMap.Homotopy (nerveOrderMap g) (nerveOrderMap f) from { + toFun:=fun p=>nervePrismReal f g h p.2 p.1 + continuous_toFun:=(nervePrismReal f g h).uncurry.continuous.comp continuous_swap + map_zero_left:=fun p=>ConcreteCategory.congr_hom (nervePrismReal_zero f g h) p + map_one_left:=fun p=>ConcreteCategory.congr_hom (nervePrismReal_one f g h) p }).symm + +lemma nerveOrderMap_id (P:Type u) [Preorder P] : + nerveOrderMap (OrderHom.id (α:=P))=ContinuousMap.id |nerve P| := by + have he:nerveMap (OrderHom.id (α:=P)).toFunctor=𝟙 (nerve P):=by + ext n x + rfl + change (SSet.toTop.map _).hom=_ + rw [he,CategoryTheory.Functor.map_id] + rfl + +noncomputable def nerveVertex (Q:Type u) [Preorder Q] (c:Q) : |nerve Q| := + realizeSimplex (nerve Q) (ComposableArrows.mk₀ c) (Convexity.StdSimplex.single 0) + +lemma simplex_zero_unique (z:Convexity.StdSimplex ℝ (Fin 1)) : + z=Convexity.StdSimplex.single 0 := + Subsingleton.elim _ _ + +lemma realizeSimplex_const {P Q:Type u} [Preorder P] [Preorder Q] (c:Q) + {n:SimplexCategory} (x:(nerve P).obj (op n)) + (z:Convexity.StdSimplex ℝ (Fin (n.len+1))) : + realizeSimplex (nerve Q) ((nerveMap (OrderHom.const P c).toFunctor).app (op n) x) z=nerveVertex Q c := by + let a:n⟶⦋0⦌:=SimplexCategory.mkHom (OrderHom.const _ 0) + have he:(nerve Q).map a.op (ComposableArrows.mk₀ c)= + (nerveMap (OrderHom.const P c).toFunctor).app (op n) x:=by + apply nerve.ext_of_isThin + rfl + have hh:=realizeSimplex_natural (nerve Q) a (ComposableArrows.mk₀ c) z + rw [he] at hh + exact hh.trans (congrArg (realizeSimplex (nerve Q) (ComposableArrows.mk₀ c)) + (simplex_zero_unique (Convexity.StdSimplex.map a.toOrderHom z))) + +lemma nerveOrderMap_const {P Q:Type u} [Preorder P] [Preorder Q] (c:Q) : + nerveOrderMap (OrderHom.const P c)=ContinuousMap.const _ (nerveVertex Q c) := by + have he:SSet.toTop.map (nerveMap (OrderHom.const P c).toFunctor)=TopCat.const (X:=|nerve P|) (nerveVertex Q c):=by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_unit,Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + change SSet.toTop.map (nerveMap (OrderHom.const P c).toFunctor) (realizeSimplex (nerve P) x z)=nerveVertex Q c + rw [realizeSimplex_map,realizeSimplex_const] + exact congrArg TopCat.Hom.hom he + +theorem nerve_contractible_of_order_clip {P:Type u} [Preorder P] + (e:P→o P) (c:P) (he:∀p,e p≤p) (hc:∀p,e p≤c) : ContractibleSpace |nerve P| := by + apply (contractible_iff_id_nullhomotopic _).mpr + refine ⟨nerveVertex P c,?_⟩ + have hh:ContinuousMap.Homotopic (nerveOrderMap (OrderHom.id (α:=P))) + (nerveOrderMap (OrderHom.const P c)):= + ⟨(nerveOrderComparisonHomotopy e (OrderHom.id (α:=P)) he).symm.trans + (nerveOrderComparisonHomotopy e (OrderHom.const P c) hc)⟩ + simpa only [nerveOrderMap_id,nerveOrderMap_const] using hh + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/NerveOrderRetractionEquiv.lean b/lean/OAI/Topology/ArtinGroups/Realizations/NerveOrderRetractionEquiv.lean new file mode 100644 index 0000000000000000000000000000000000000000..30896dd9ab92c02d792d769e7065b30c23ee5c6b --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/NerveOrderRetractionEquiv.lean @@ -0,0 +1,33 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Functors.Index +import OAI.Topology.ArtinGroups.Realizations.NerveOrderMap + +namespace OAI + +namespace HarmonicArtin +universe u +open Simplicial CategoryTheory Opposite + +lemma nerveOrderMap_comp {P Q R:Type u} [Preorder P] [Preorder Q] [Preorder R] + (f:P→oQ) (g:Q→oR) : nerveOrderMap (g.comp f)=(nerveOrderMap g).comp (nerveOrderMap f) := by + have he:nerveMap (g.comp f).toFunctor=nerveMap f.toFunctor≫nerveMap g.toFunctor:=by + ext n x + rfl + change (SSet.toTop.map _).hom=_ + rw [he,CategoryTheory.Functor.map_comp] + rfl + +noncomputable def nerveOrderRetractionEquiv {P Q:Type u} [Preorder P] [Preorder Q] + (r:P→oQ) (i:Q→oP) (hr:r.comp i=OrderHom.id) (hi:∀p,p≤ i (r p)) : + ContinuousMap.HomotopyEquiv |nerve P| |nerve Q| where + toFun:=nerveOrderMap r + invFun:=nerveOrderMap i + left_inv:=by + rw [←nerveOrderMap_comp,←nerveOrderMap_id P] + exact ⟨(nerveOrderComparisonHomotopy (OrderHom.id (α:=P)) (i.comp r) hi).symm⟩ + right_inv:=by + rw [←nerveOrderMap_comp,hr,nerveOrderMap_id] + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/NervePrismPatch.lean b/lean/OAI/Topology/ArtinGroups/Realizations/NervePrismPatch.lean new file mode 100644 index 0000000000000000000000000000000000000000..2622a0377585b1b8a5b37f70eaaec5d2a19e2592 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/NervePrismPatch.lean @@ -0,0 +1,71 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.RealizeSimplex +import OAI.Topology.ArtinGroups.Harmonic.PrismGrid +import OAI.Topology.ArtinGroups.Harmonic.PrismFlag + +namespace OAI + +namespace HarmonicArtin +open scoped unitInterval +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable + +lemma prismMarginals_natural {n m:SimplexCategory} (u:n⟶m) (k:Fin (n.len+1)) + (w:Convexity.StdSimplex ℝ (Fin (n.len+2))) : + prismMarginals (u.toOrderHom k) (Convexity.StdSimplex.map (prismOrdinal u k).toOrderHom w)= + (Convexity.StdSimplex.map u.toOrderHom (prismMarginals k w).1,(prismMarginals k w).2) := by + apply Prod.ext + · change Convexity.StdSimplex.map (u.toOrderHom k).predAbove + (Convexity.StdSimplex.map (prismOrdinal u k).toOrderHom w)= + Convexity.StdSimplex.map u.toOrderHom (Convexity.StdSimplex.map k.predAbove w) + rw [←Convexity.StdSimplex.map_comp,←Convexity.StdSimplex.map_comp] + congr 1 + funext i + exact congrArg Prod.fst (prismGrid_natural u k i) + · apply Subtype.ext + change (Convexity.StdSimplex.map (prismFlag (u.toOrderHom k)) + (Convexity.StdSimplex.map (prismOrdinal u k).toOrderHom w)).weights 0= + (Convexity.StdSimplex.map (prismFlag k) w).weights 0 + rw [←Convexity.StdSimplex.map_comp] + have he:prismFlag (u.toOrderHom k)∘(prismOrdinal u k).toOrderHom=prismFlag k:=by + funext i + exact congrArg Prod.snd (prismGrid_natural u k i) + rw [he] + +lemma prismCell_natural {n m:SimplexCategory} (u:n⟶m) (k:Fin (n.len+1)) + (p:Convexity.StdSimplex ℝ (Fin (n.len+1))×I) (hp:p∈PrismCell k) : + (Convexity.StdSimplex.map u.toOrderHom p.1,p.2)∈PrismCell (u.toOrderHom k) := by + have hm:=prismMarginals_natural u k (prismSimplex k p) + rw [prismMarginals_simplex k p hp] at hm + rw [←hm] + exact prismMarginals_cell _ _ + +lemma map_prismSimplex {n m:SimplexCategory} (u:n⟶m) (k:Fin (n.len+1)) + (p:Convexity.StdSimplex ℝ (Fin (n.len+1))×I) (hp:p∈PrismCell k) : + Convexity.StdSimplex.map (prismOrdinal u k).toOrderHom (prismSimplex k p)= + prismSimplex (u.toOrderHom k) (Convexity.StdSimplex.map u.toOrderHom p.1,p.2) := by + have hm:=prismMarginals_natural u k (prismSimplex k p) + rw [prismMarginals_simplex k p hp] at hm + rw [←hm] + exact (prismSimplex_marginals _ _).symm + +noncomputable def nervePrismPatch {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→o Q) (h:∀p,f p≤g p) {n:SimplexCategory} + (x:(nerve P).obj (op n)) (k:Fin (n.len+1)) : + C(Convexity.StdSimplex ℝ (Fin (n.len+1))×I,|nerve Q|) := + (realizeSimplex (nerve Q) (nervePrism f g h x k)).comp (prismSimplex k) + +lemma nervePrismPatch_natural {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→o Q) (h:∀p,f p≤g p) {n m:SimplexCategory} (u:n⟶m) + (x:(nerve P).obj (op m)) (k:Fin (n.len+1)) + (p:Convexity.StdSimplex ℝ (Fin (n.len+1))×I) (hp:p∈PrismCell k) : + nervePrismPatch f g h ((nerve P).map u.op x) k p= + nervePrismPatch f g h x (u.toOrderHom k) (Convexity.StdSimplex.map u.toOrderHom p.1,p.2) := by + change realizeSimplex _ (nervePrism f g h ((nerve P).map u.op x) k) (prismSimplex k p)=_ + rw [nervePrism_natural,realizeSimplex_natural,map_prismSimplex _ _ _ hp] + rfl + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/NervePrismValue.lean b/lean/OAI/Topology/ArtinGroups/Realizations/NervePrismValue.lean new file mode 100644 index 0000000000000000000000000000000000000000..9cfe6d38ca0fe2e93dfb8aa7d04458a17bb7791e --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/NervePrismValue.lean @@ -0,0 +1,109 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.NervePrismPatch +import OAI.Topology.ArtinGroups.Harmonic.PredAboveSuccSucc + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators unitInterval +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable + +lemma prismPrefix_mono {n:ℕ} (z:Convexity.StdSimplex ℝ (Fin (n+1))) {k l:Fin (n+1)} (hkl:k≤l) : + prismPrefix z k≤prismPrefix z l := + Finset.sum_le_sum_of_subset_of_nonneg (Finset.Iio_subset_Iio hkl) (fun index _ _=>z.weights_nonneg index) + +lemma prismRight_mono {n:ℕ} (z:Convexity.StdSimplex ℝ (Fin (n+1))) {k l:Fin (n+1)} (hkl:k≤l) : + prismPrefix z k+z.weights k≤prismPrefix z l+z.weights l := by + rw [prismPrefix_add,prismPrefix_add] + exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.Iic_subset_Iic.mpr hkl) (fun index _ _=>z.weights_nonneg index) + +lemma prismCell_between {n:ℕ} (p:Convexity.StdSimplex ℝ (Fin (n+1))×I) {k j l:Fin (n+1)} + (hk:p∈PrismCell k) (hl:p∈PrismCell l) (hkj:k≤j) (hjl:j≤l) : p∈PrismCell j := + ⟨(prismPrefix_mono p.1 hjl).trans hl.1,hk.2.trans (prismRight_mono p.1 hkj)⟩ + +lemma nervePrismPatch_adjacent {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) {n:SimplexCategory} (x:(nerve P).obj (op n)) + (k l:Fin (n.len+1)) (hkl:l.val=k.val+1) + (p:Convexity.StdSimplex ℝ (Fin (n.len+1))×I) (hk:p∈PrismCell k) (hl:p∈PrismCell l) : + nervePrismPatch f g h x k p=nervePrismPatch f g h x l p := by + have hp:p.2.val=prismPrefix p.1 k+p.1.weights k:=by + have hh:=hl.1 + rw [prismPrefix_step p.1 k l hkl] at hh + exact le_antisymm hk.2 hh + change realizeSimplex _ (nervePrism f g h x k) (prismSimplex k p)= + realizeSimplex _ (nervePrism f g h x l) (prismSimplex l p) + rw [prismSimplex_face_right k p hp,prismSimplex_face_adjacent k l hkl p hp] + have h₁:=realizeSimplex_natural (nerve Q) (SimplexCategory.δ k.succ) (nervePrism f g h x k) p.1 + have h₂:=realizeSimplex_natural (nerve Q) (SimplexCategory.δ k.succ) (nervePrism f g h x l) p.1 + rw [nervePrism_face_adjacent f g h x k l hkl] at h₂ + exact h₁.symm.trans h₂ + +lemma nervePrismPatch_agree {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) {n:SimplexCategory} (x:(nerve P).obj (op n)) + (k l:Fin (n.len+1)) (p:Convexity.StdSimplex ℝ (Fin (n.len+1))×I) + (hk:p∈PrismCell k) (hl:p∈PrismCell l) : + nervePrismPatch f g h x k p=nervePrismPatch f g h x l p := by + have aux:∀l:Fin (n.len+1),∀k≤l,p∈PrismCell k→p∈PrismCell l→ + nervePrismPatch f g h x k p=nervePrismPatch f g h x l p:=by + intro l + induction l using Fin.induction with + | zero => + intro k hkl _ _ + have he:k=0:=le_antisymm hkl (Fin.zero_le _) + rw [he] + | succ j ih => + intro k hkl hk hl + by_cases hh:k≤j.castSucc + · have hc:p∈PrismCell j.castSucc:=prismCell_between p hk hl hh (by + simp only [Fin.le_iff_val_le_val,Fin.val_castSucc,Fin.val_succ]; omega) + exact (ih k hh hk hc).trans (nervePrismPatch_adjacent f g h x j.castSucc j.succ + (by simp only [Fin.val_succ,Fin.val_castSucc]) p hc hl) + · have he:k=j.succ:=by + apply Fin.ext + simp only [Fin.le_iff_val_le_val,Fin.val_succ,Fin.val_castSucc] at hh hkl ⊢ + omega + rw [he] + rcases le_total k l with hkl|hlk + · exact aux l k hkl hk hl + · exact (aux k l hlk hl hk).symm + +noncomputable def nervePrismValue {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) {n:SimplexCategory} (x:(nerve P).obj (op n)) + (p:Convexity.StdSimplex ℝ (Fin (n.len+1))×I) : |nerve Q| := + nervePrismPatch f g h x (prismCell_cover p).choose p + +lemma nervePrismValue_eq {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) {n:SimplexCategory} (x:(nerve P).obj (op n)) + (k:Fin (n.len+1)) (p:Convexity.StdSimplex ℝ (Fin (n.len+1))×I) (hp:p∈PrismCell k) : + nervePrismValue f g h x p=nervePrismPatch f g h x k p := + nervePrismPatch_agree f g h x _ _ p (prismCell_cover p).choose_spec hp + +noncomputable def nervePrismSimplex {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) {n:SimplexCategory} (x:(nerve P).obj (op n)) : + C(Convexity.StdSimplex ℝ (Fin (n.len+1)),C(I,|nerve Q|)) := + (⟨nervePrismValue f g h x,by + apply (locallyFinite_of_finite (fun k:Fin (n.len+1)=>PrismCell k)).continuous + · exact Set.iUnion_eq_univ_iff.mpr prismCell_cover + · exact prismCell_closed + · intro k + apply (nervePrismPatch f g h x k).continuous.continuousOn.congr + intro p hp + exact nervePrismValue_eq f g h x k p hp⟩ : C(Convexity.StdSimplex ℝ (Fin (n.len+1))×I,|nerve Q|)).curry + +lemma nervePrismSimplex_natural {P Q:Type*} [Preorder P] [Preorder Q] + (f g:P→oQ) (h:∀p,f p≤g p) {n m:SimplexCategory} (u:n⟶m) + (x:(nerve P).obj (op m)) (z:Convexity.StdSimplex ℝ (Fin (n.len+1))) (t:I) : + nervePrismSimplex f g h ((nerve P).map u.op x) z t= + nervePrismSimplex f g h x (Convexity.StdSimplex.map u.toOrderHom z) t := by + obtain ⟨k,hk⟩:=prismCell_cover (z,t) + change nervePrismValue f g h ((nerve P).map u.op x) (z,t)= + nervePrismValue f g h x (Convexity.StdSimplex.map u.toOrderHom z,t) + rw [nervePrismValue_eq f g h _ k _ hk, + nervePrismValue_eq f g h x _ _ (prismCell_natural u k _ hk)] + exact nervePrismPatch_natural f g h u x k (z,t) hk + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/NoncriticalPositiveCell.lean b/lean/OAI/Topology/ArtinGroups/Realizations/NoncriticalPositiveCell.lean new file mode 100644 index 0000000000000000000000000000000000000000..58d8e03f57dc98e1ab80608831f9b8ff08b7defc --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/NoncriticalPositiveCell.lean @@ -0,0 +1,177 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.TopBlockMatchingKey +import OAI.Topology.ArtinGroups.Realizations.PositiveLiftedCell + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type*} [Fintype S] [LinearOrder S] (M:CoxeterMatrix S) +variable (z:M.Group) (hz:∀w,M.toCoxeterSystem.length w≤M.toCoxeterSystem.length z) +variable (inj:Function.Injective (positiveToArtin M)) + +include inj in +omit [LinearOrder S] in +lemma positiveCell_same_top_type_unique (a b:PositiveLiftedCell M) + (ht:a.2=b.2) (hb:positiveCellTop M a=positiveCellTop M b) : a=b := by + apply Prod.ext ?_ ht + apply inj + have hp:=congrArg (positiveToArtin M) hb + simp only [positiveCellTop,map_mul,positiveToArtin_simpleLift,ht] at hp + exact mul_right_cancel hp + +include z hz inj in +omit [LinearOrder S] in +theorem positiveCell_realize_top (b:PositiveArtin M) (T:SphericalType M) + (hT:T.val⊆PositiveDescentSet M b) : + ∃a:PositiveLiftedCell M,a.2=T ∧ positiveCellTop M a=b := by + have cancel:∀a d e:PositiveArtin M,a*d=a*e→d=e:=by + intro a d e h + apply inj + exact mul_left_cancel (by simpa only [map_mul] using congrArg (positiveToArtin M) h) + obtain ⟨hD,q,hq,p,hp⟩:=positive_descent_fundamental M z hz cancel b + let r:=q*(sphericalLongest M T)⁻¹ + have hm:(sphericalLongest M T)⁻¹∈coxeterParabolic M (PositiveDescentSet M b):= + coxeterParabolic_mono M hT ((coxeterParabolic M T.val).inv_mem (sphericalLongest_spec M T).1) + have hl:=parabolic_longest_length_mul M _ q hq (sphericalLongest M T)⁻¹ hm + rw [M.toCoxeterSystem.length_inv] at hl + have he:r*sphericalLongest M T=q:=by dsimp [r];group + have hl':M.toCoxeterSystem.length (r*sphericalLongest M T)= + M.toCoxeterSystem.length r+M.toCoxeterSystem.length (sphericalLongest M T):=by rw [he];exact hl.symm + have hprod:=positiveSimpleLift_mul M r (sphericalLongest M T) hl' + rw [he] at hprod + refine ⟨(p*positiveSimpleLift M r,T),rfl,?_⟩ + change (p*positiveSimpleLift M r)*positiveSimpleLift M (sphericalLongest M T)=b + rw [hp,hprod,mul_assoc] + +abbrev NoncriticalPositiveCell := {a:PositiveLiftedCell M // positiveCellTop M a≠1} + +noncomputable def matchingLetter (a:NoncriticalPositiveCell M) : S := + firstPositiveDescent M z hz (positiveCellTop M a.val) a.property + +noncomputable def matchingOtherType (a:NoncriticalPositiveCell M) : Set S := + if matchingLetter M z hz a∈a.val.2.val then a.val.2.val\{matchingLetter M z hz a} + else insert (matchingLetter M z hz a) a.val.2.val + +lemma matchingOtherType_subset (a:NoncriticalPositiveCell M) : + matchingOtherType M z hz a⊆PositiveDescentSet M (positiveCellTop M a.val) := by + have hT:a.val.2.val⊆PositiveDescentSet M (positiveCellTop M a.val):= + type_subset_positiveDescentSet M _ _ (sphericalLongest_spec M a.val.2) a.val.1 + have hs:matchingLetter M z hz a∈PositiveDescentSet M (positiveCellTop M a.val):= + firstPositiveDescent_mem M z hz _ _ + unfold matchingOtherType + split_ifs + · exact Set.Subset.trans Set.sdiff_subset hT + · exact Set.insert_subset hs hT + +include inj in +lemma matchingOtherType_spherical (a:NoncriticalPositiveCell M) : + IsSpherical M (matchingOtherType M z hz a) := by + have cancel:∀a d e:PositiveArtin M,a*d=a*e→d=e:=by + intro a d e h + apply inj + exact mul_left_cancel (by simpa only [map_mul] using congrArg (positiveToArtin M) h) + exact spherical_type_mono M (matchingOtherType_subset M z hz a) + (positive_descent_fundamental M z hz cancel (positiveCellTop M a.val)).1 + +noncomputable def positiveMatch (a:NoncriticalPositiveCell M) : NoncriticalPositiveCell M := + let T:SphericalType M:=⟨matchingOtherType M z hz a,matchingOtherType_spherical M z hz inj a⟩ + let h:=positiveCell_realize_top M z hz inj (positiveCellTop M a.val) T (matchingOtherType_subset M z hz a) + ⟨h.choose,fun he=>a.property (h.choose_spec.2.symm.trans he)⟩ + +lemma positiveMatch_top (a:NoncriticalPositiveCell M) : + positiveCellTop M (positiveMatch M z hz inj a).val=positiveCellTop M a.val := by + exact (positiveCell_realize_top M z hz inj (positiveCellTop M a.val) + ⟨matchingOtherType M z hz a,matchingOtherType_spherical M z hz inj a⟩ + (matchingOtherType_subset M z hz a)).choose_spec.2 + +lemma positiveMatch_type (a:NoncriticalPositiveCell M) : + (positiveMatch M z hz inj a).val.2.val=matchingOtherType M z hz a := by + exact congrArg Subtype.val (positiveCell_realize_top M z hz inj (positiveCellTop M a.val) + ⟨matchingOtherType M z hz a,matchingOtherType_spherical M z hz inj a⟩ + (matchingOtherType_subset M z hz a)).choose_spec.1 + +lemma positiveMatch_letter (a:NoncriticalPositiveCell M) : + matchingLetter M z hz (positiveMatch M z hz inj a)=matchingLetter M z hz a := by + simp only [matchingLetter,positiveMatch_top] + +theorem positiveMatch_involutive : Function.Involutive (positiveMatch M z hz inj) := by + intro a + apply Subtype.ext + apply positiveCell_same_top_type_unique M inj + · apply Subtype.ext + rw [positiveMatch_type] + simp only [matchingOtherType,positiveMatch_letter,positiveMatch_type] + by_cases hs:matchingLetter M z hz a∈a.val.2.val + · simp only [hs,ite_eq_left,Set.mem_sdiff,Set.mem_singleton_iff,not_true_eq_false,and_false,ite_false] + rw [Set.insert_sdiff_singleton, Set.insert_eq_of_mem hs] + · simp only [hs,ite_false,Set.mem_insert_iff,true_or,ite_eq_left] + ext x + by_cases he : x = matchingLetter M z hz a + · subst x + simp [hs] + · simp [he] + · exact (positiveMatch_top M z hz inj (positiveMatch M z hz inj a)).trans (positiveMatch_top M z hz inj a) + +theorem positiveMatch_ne (a:NoncriticalPositiveCell M) : positiveMatch M z hz inj a≠a := by + intro he + have ht:=positiveMatch_type M z hz inj a + rw [he] at ht + have hm:matchingLetter M z hz a∈a.val.2.val ↔ matchingLetter M z hz a∈matchingOtherType M z hz a:=by rw [ht] + simp only [matchingOtherType] at hm + split_ifs at hm with hs + · simp [hs] at hm + · simp [hs] at hm + +theorem positiveMatch_incident (a:NoncriticalPositiveCell M) : + positiveCellToLifted M a.val < positiveCellToLifted M (positiveMatch M z hz inj a).val ∨ + positiveCellToLifted M (positiveMatch M z hz inj a).val < positiveCellToLifted M a.val := by + have hne:positiveCellToLifted M a.val ≠ positiveCellToLifted M (positiveMatch M z hz inj a).val := by + intro he + apply positiveMatch_ne M z hz inj a + apply Subtype.ext + apply Prod.ext + · apply inj + exact (congrArg Prod.fst he).symm + · exact (congrArg Prod.snd he).symm + have hcell:∀c:PositiveLiftedCell M,positiveCellToLifted M c= + cellWithTop M (positiveToArtin M (positiveCellTop M c)) c.2:=by + intro c + rw [positiveCellTop_toArtin] + exact (cellWithTop_topVertex M (positiveCellToLifted M c)).symm + have hAB:a.val.2.val⊆(positiveMatch M z hz inj a).val.2.val ∨ + (positiveMatch M z hz inj a).val.2.val⊆a.val.2.val:=by + rw [positiveMatch_type] + unfold matchingOtherType + split_ifs + · exact Or.inr Set.sdiff_subset + · exact Or.inl (Set.subset_insert _ _) + rcases hAB with hab|hba + · left + apply lt_of_le_of_ne ?_ hne + rw [hcell _,hcell _,positiveMatch_top] + exact cellWithTop_mono M _ hab + · right + apply lt_of_le_of_ne ?_ hne.symm + rw [hcell _,hcell _,positiveMatch_top] + exact cellWithTop_mono M _ hba + +theorem spherical_positive_matching {A:Type} [Fintype A] [LinearOrder A] + (N:CoxeterMatrix A) (T:Set A) (hT:IsSpherical N T) : + ∃ f:NoncriticalPositiveCell (restrictedMatrix N T) → NoncriticalPositiveCell (restrictedMatrix N T), + Function.Involutive f ∧ ∀a, f a≠a ∧ + (positiveCellToLifted (restrictedMatrix N T) a.val < positiveCellToLifted (restrictedMatrix N T) (f a).val ∨ + positiveCellToLifted (restrictedMatrix N T) (f a).val < positiveCellToLifted (restrictedMatrix N T) a.val) := by + let : Finite (restrictedMatrix N T).Group:=restricted_finite N T hT + obtain ⟨z,hz⟩:=exists_longest (restrictedMatrix N T).toCoxeterSystem + let inj:=spherical_positiveToArtin_injective N T hT + exact ⟨positiveMatch (restrictedMatrix N T) z hz inj, + positiveMatch_involutive (restrictedMatrix N T) z hz inj, + fun a=>⟨positiveMatch_ne (restrictedMatrix N T) z hz inj a, + positiveMatch_incident (restrictedMatrix N T) z hz inj a⟩⟩ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeights.lean b/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..0ebabf084ea23dc9eeab20a4ced1cacbfc1a9ee5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeights.lean @@ -0,0 +1,105 @@ +import Mathlib + +namespace OAI + +namespace HarmonicArtin +open Simplicial CategoryTheory Opposite Convexity +open scoped BigOperators + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +structure OrderWeights (P:Type u) [PartialOrder P] where + weights:P→₀ℝ + nonneg:∀p,0≤weights p + total:weights.sum (fun _ a=>a)=1 + chain:∀p∈weights.support,∀q∈weights.support,p≤q ∨ q≤p + +@[ext] lemma OrderWeights.ext {x y:OrderWeights P} (h:x.weights=y.weights) : x=y := by + cases x;cases y;cases h;rfl + +lemma OrderWeights.support_nonempty (x:OrderWeights P) : x.weights.support.Nonempty := by + by_contra hn + have he:x.weights=0:=Finsupp.support_eq_empty.mp (Finset.not_nonempty_iff_eq_empty.mp hn) + have ht:=x.total + rw [he,Finsupp.sum_zero_index] at ht + norm_num at ht + +noncomputable def chainWeights {n:ℕ} (x:Fin (n+1)→o P) (z:StdSimplex ℝ (Fin (n+1))) : P→₀ℝ := + ∑i,Finsupp.single (x i) (z.weights i) + +lemma chainWeights_apply {n:ℕ} (x:Fin (n+1)→o P) (z:StdSimplex ℝ (Fin (n+1))) (p:P) : + chainWeights x z p=∑i,if x i=p then z.weights i else 0 := by + simp only [chainWeights,Finsupp.finsetSum_apply,Finsupp.single_apply] + +lemma chainWeights_nonneg {n:ℕ} (x:Fin (n+1)→o P) (z:StdSimplex ℝ (Fin (n+1))) (p:P) : + 0≤chainWeights x z p := by + rw [chainWeights_apply] + exact Finset.sum_nonneg (fun i _=>by split_ifs; exacts [z.nonneg i,le_rfl]) + +lemma chainWeights_total {n:ℕ} (x:Fin (n+1)→o P) (z:StdSimplex ℝ (Fin (n+1))) : + (chainWeights x z).sum (fun _ a=>a)=1 := by + rw [chainWeights,← Finsupp.sum_finsetSum_index (by intros;rfl) (by intros;rfl)] + simpa only [Finsupp.sum_single_index (h:=fun (_:P) (a:ℝ)=>a) (by rfl)] using z.total_of_fintype + +lemma chainWeights_support {n:ℕ} (x:Fin (n+1)→o P) (z:StdSimplex ℝ (Fin (n+1))) : + (chainWeights x z).support⊆Finset.univ.image x := by + apply Finset.Subset.trans Finsupp.support_finsetSum + intro p hp + obtain ⟨i,_,hi⟩:=Finset.mem_biUnion.mp hp + have he:p=x i:=Finset.mem_singleton.mp (Finsupp.support_single_subset hi) + exact Finset.mem_image.mpr ⟨i,Finset.mem_univ _,he.symm⟩ + +noncomputable def orderWeightsOfChain {n:ℕ} (x:Fin (n+1)→o P) (z:StdSimplex ℝ (Fin (n+1))) : OrderWeights P where + weights:=chainWeights x z + nonneg:=chainWeights_nonneg x z + total:=chainWeights_total x z + chain:=by + intro p hp q hq + obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp (chainWeights_support x z hp) + obtain ⟨j,_,rfl⟩:=Finset.mem_image.mp (chainWeights_support x z hq) + exact (le_total i j).imp (fun h=>x.monotone h) (fun h=>x.monotone h) + +noncomputable def nerveChain {n:SimplexCategory} (x:(nerve P).obj (op n)) : Fin (n.len+1)→o P where + toFun:=x.obj + monotone':=by intro i j h;exact leOfHom (x.map (homOfLE h)) + +noncomputable def orderWeightsChart : (Σn:SimplexCategory,((nerve P).obj (op n)) × StdSimplex ℝ (Fin (n.len+1)))→OrderWeights P := + fun p=>orderWeightsOfChain (nerveChain p.2.1) p.2.2 + +noncomputable instance : TopologicalSpace (OrderWeights P) := by + letI (n:SimplexCategory):TopologicalSpace ((nerve P).obj (op n)):=⊥ + exact TopologicalSpace.coinduced orderWeightsChart inferInstance + +lemma orderWeightsChart_continuous {n:SimplexCategory} (x:(nerve P).obj (op n)) : + Continuous (fun z:StdSimplex ℝ (Fin (n.len+1))=>orderWeightsOfChain (nerveChain x) z) := by + let (n:SimplexCategory):TopologicalSpace ((nerve P).obj (op n)):=⊥ + have hc : Continuous (orderWeightsChart (P:=P)) := continuous_coinduced_rng + exact hc.comp ((continuous_sigmaMk (i:=n)).comp (continuous_const.prodMk continuous_id)) + +lemma orderWeights_continuous_iff {Y:Type*} [TopologicalSpace Y] (f:OrderWeights P→Y) : + Continuous f ↔ ∀(n:SimplexCategory) (x:(nerve P).obj (op n)), + Continuous (fun z:StdSimplex ℝ (Fin (n.len+1))=>f (orderWeightsOfChain (nerveChain x) z)) := by + let (n:SimplexCategory):TopologicalSpace ((nerve P).obj (op n)):=⊥ + let (n:SimplexCategory):DiscreteTopology ((nerve P).obj (op n)):=⟨rfl⟩ + rw [continuous_coinduced_dom,continuous_sigma_iff] + constructor + · intro h n x + exact (h n).comp (continuous_const.prodMk continuous_id) + · intro h n + exact continuous_prod_of_discrete_left.mpr (h n) + +lemma chainWeights_natural {n m:ℕ} (x:Fin (m+1)→o P) (a:Fin (n+1)→o Fin (m+1)) + (z:StdSimplex ℝ (Fin (n+1))) : + chainWeights (x.comp a) z=chainWeights x (StdSimplex.map a z) := by + have chainWeights_eq {dimension : ℕ} (chain : Fin (dimension+1) →o P) + (simplex : StdSimplex ℝ (Fin (dimension+1))) : + chainWeights chain simplex = simplex.weights.mapDomain chain := by + simp [chainWeights, Finsupp.mapDomain, Finsupp.sum_fintype] + rw [chainWeights_eq, chainWeights_eq] + exact Finsupp.mapDomain_comp (v := z.weights) (f := a) (g := x) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeightsContractibleLower.lean b/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeightsContractibleLower.lean new file mode 100644 index 0000000000000000000000000000000000000000..f3dc478e2ecd71d0114393ba733c22d082191c33 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeightsContractibleLower.lean @@ -0,0 +1,45 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightEarlierLower + +namespace OAI + +namespace HarmonicArtin +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +theorem orderWeights_contractible_of_lower_fibers (A:Set P) (k:P→ℕ) (N:ℕ) + (hk:∀x,k x≤N) (hm:StrictMono k) (hA:ContractibleSpace (OrderWeights A)) + (hf:∀v,v∉A → ContractibleSpace (OrderWeights {x:P // x∈A ∧ xN-k x + let r:=WeightJoinEarlier A d + have hw:=weightJoinEarlier_wf A d + apply orderWeights_contractible_of_initial r hw (weightJoinEarlier_total A d) A + (weightJoinEarlier_initial A d) hA + intro v hv + have he:∀x,x⟨x.val,(he x.val x.property.2).mp x.property.1,x.property.2⟩ + invFun:=fun x=>⟨x.val,(he x.val x.property.2).mpr x.property.1,x.property.2⟩ + left_inv:=fun _=>rfl + right_inv:=fun _=>rfl + map_rel_iff':=by intros;rfl } + exact weightLink_contractible_of_lower r (fun x=>hw.irrefl.irrefl x) v k N hk hm + ((weightHomeomorph e).contractibleSpace_iff.mpr (hf v hv)) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeightsContractibleLower2.lean b/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeightsContractibleLower2.lean new file mode 100644 index 0000000000000000000000000000000000000000..c1ef289c797d7c90dcb398a33a3770f296c925d6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/OrderWeightsContractibleLower2.lean @@ -0,0 +1,34 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.OrderMappingCylinder +import OAI.Topology.ArtinGroups.Realizations.WeightInsertRetract + +namespace OAI + +namespace HarmonicArtin +universe u +variable {P Q:Type u} [PartialOrder P] [PartialOrder Q] + +theorem orderWeights_contractible_of_lower_preimages (f:P→oQ) + (k:P→ℕ) (l:Q→ℕ) (N L:ℕ) (hk:∀p,k p≤N) (hl:∀q,l q≤L) + (hkm:StrictMono k) (hlm:StrictMono l) (hQ:ContractibleSpace (OrderWeights Q)) + (hf:∀q,ContractibleSpace (OrderWeights {p:P // f p≤q})) : + ContractibleSpace (OrderWeights P) := by + let R:=OrderMappingCylinder f + have hR:ContractibleSpace (OrderWeights R):=OrderMappingCylinder.weights_contractible f hQ + have hF:∀v:R,v∉OrderMappingCylinder.old f → + ContractibleSpace (OrderWeights {x:R // x∈OrderMappingCylinder.old f ∧ xhc x (Set.mem_univ x) + have hcL:¬Nonempty (WeightEarlierLink r c):=by + rintro ⟨x,hx,_⟩ + exact hc' x hx + apply orderWeights_contractible_of_earlier_links r wf htotal c hc' + intro v hv + have hn:Nonempty (WeightEarlierLink r v):=by + by_contra hn + exact hv (hs v c hn hcL) + rcases weightLink_nonempty_parts r (fun x=>wf.irrefl.irrefl x) v hn with h|h + · exact weightLink_contractible_of_lower r (fun x=>wf.irrefl.irrefl x) v k N hk hmono (hl v h) + · exact weightLink_contractible_of_upper r (fun x=>wf.irrefl.irrefl x) v k N hk hmono (hu v h) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/PartialEquivContinuousSymm.lean b/lean/OAI/Topology/ArtinGroups/Realizations/PartialEquivContinuousSymm.lean new file mode 100644 index 0000000000000000000000000000000000000000..972904a78621fe3389d1de1aba889021264cc0ca --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/PartialEquivContinuousSymm.lean @@ -0,0 +1,24 @@ +import Mathlib + +namespace OAI + +namespace HarmonicArtin +open Topology Set + +lemma partialEquiv_continuousOn_symm {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] + (e : PartialEquiv X Y) (he : IsEmbedding (e.source.domRestrict e)) : + ContinuousOn e.symm e.target := by + let g : e.target → e.source := fun y => ⟨e.symm y,e.map_target y.property⟩ + have hg : Continuous g := by + apply he.continuous_iff.mpr + have h : (e.source.domRestrict e) ∘ g=Subtype.val := by + funext y + exact e.right_inv y.property + rw [h] + exact continuous_subtype_val + rw [continuousOn_iff_continuous_domRestrict] + exact continuous_subtype_val.comp hg + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/PositiveCellPoset.lean b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveCellPoset.lean new file mode 100644 index 0000000000000000000000000000000000000000..29332963e3ec80cda77623884db1781b33336c81 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveCellPoset.lean @@ -0,0 +1,124 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.PositiveRootCell +import OAI.Topology.ArtinGroups.Harmonic.PositiveRegion + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] (M : CoxeterMatrix S) + +omit [Fintype S] in +lemma positiveCellToLifted_injective (inj : Function.Injective (positiveToArtin M)) : + Function.Injective (positiveCellToLifted M) := by + intro a b h + exact Prod.ext (inj (congrArg (fun c : LiftedCell M => c.1) h)) + (congrArg (fun c : LiftedCell M => c.2) h) + +@[reducible] def PositiveCellPoset (_inj : Function.Injective (positiveToArtin M)) := PositiveLiftedCell M + +instance (inj : Function.Injective (positiveToArtin M)) : PartialOrder (PositiveCellPoset M inj) := + PartialOrder.lift (positiveCellToLifted M) (positiveCellToLifted_injective M inj) + +omit [Fintype S] in +lemma positiveCellPoset_le_iff (inj : Function.Injective (positiveToArtin M)) + (a b : PositiveCellPoset M inj) : a ≤ b ↔ positiveCellToLifted M a ≤ positiveCellToLifted M b := Iff.rfl + +noncomputable def positiveCellRegionIso (inj : Function.Injective (positiveToArtin M)) : + PositiveCellPoset M inj ≃o PositiveRegion M 1 where + toFun a := ⟨positiveCellToLifted M a, a.1, by simp [positiveCellToLifted]⟩ + invFun a := (a.property.choose,a.val.2) + left_inv a := by + apply Prod.ext + · apply inj + simpa only [positiveCellToLifted,one_mul] using + (Exists.choose_spec (show ∃ p, (positiveCellToLifted M a).1 = 1*positiveToArtin M p from + ⟨a.1,by simp [positiveCellToLifted]⟩)).symm + · rfl + right_inv a := by + apply Subtype.ext + exact Prod.ext (by simpa only [positiveCellToLifted,one_mul] using a.property.choose_spec.symm) rfl + map_rel_iff' := by intros; rfl + +omit [Fintype S] in +lemma topBlockMatchingKey_cases {s : S} {A B : Finset S} (hAB : A ⊂ B) : + topBlockMatchingKey s A < topBlockMatchingKey s B ∨ + (s ∉ A ∧ B = insert s A ∧ topBlockMatchingKey s B < topBlockMatchingKey s A) := by + have hsub : A.erase s ⊆ B.erase s := Finset.erase_subset_erase s hAB.1 + by_cases he : A.erase s = B.erase s + · have hsB : s ∈ B := by + by_contra hsB + have hsA : s ∉ A := fun h => hsB (hAB.1 h) + rw [Finset.erase_eq_of_notMem hsA,Finset.erase_eq_of_notMem hsB] at he + exact hAB.2 he.symm.subset + have hsA : s ∉ A := by + intro hsA + have he' := congrArg (insert s) he + rw [Finset.insert_erase hsA,Finset.insert_erase hsB] at he' + exact hAB.2 he'.symm.subset + have he' : B = insert s A := by + rw [←Finset.insert_erase hsB,←he,Finset.erase_eq_of_notMem hsA] + exact Or.inr ⟨hsA,he',topBlockStep_key (Or.inl ⟨hsA,he'⟩)⟩ + · have hc : (A.erase s).card < (B.erase s).card := + Finset.card_lt_card (Finset.ssubset_iff_subset_ne.mpr ⟨hsub,he⟩) + left + unfold topBlockMatchingKey + split_ifs <;> omega + +variable [LinearOrder S] +variable (z : M.Group) (hz : ∀ w, M.toCoxeterSystem.length w ≤ M.toCoxeterSystem.length z) +variable (inj : Function.Injective (positiveToArtin M)) + +def PositiveEarlier (a b : PositiveCellPoset M inj) : Prop := + Prod.Lex (· < ·) (Prod.Lex (· < ·) WellOrderingRel) + (positiveDegree M (positiveCellTop M a),(positiveMatchingTypeKey M z hz a,a)) + (positiveDegree M (positiveCellTop M b),(positiveMatchingTypeKey M z hz b,b)) + +lemma positiveEarlier_iff (a b : PositiveCellPoset M inj) : + PositiveEarlier M z hz inj a b ↔ + positiveDegree M (positiveCellTop M a) < positiveDegree M (positiveCellTop M b) ∨ + positiveDegree M (positiveCellTop M a) = positiveDegree M (positiveCellTop M b) ∧ + (positiveMatchingTypeKey M z hz a < positiveMatchingTypeKey M z hz b ∨ + positiveMatchingTypeKey M z hz a = positiveMatchingTypeKey M z hz b ∧ WellOrderingRel a b) := by + simp only [PositiveEarlier,Prod.lex_iff] + +lemma positiveEarlier_wf : WellFounded (PositiveEarlier M z hz inj) := + InvImage.wf (fun a : PositiveCellPoset M inj => + (positiveDegree M (positiveCellTop M a),(positiveMatchingTypeKey M z hz a,a))) + (wellFounded_lt.prod_lex (wellFounded_lt.prod_lex WellOrderingRel.isWellOrder.wf)) + +lemma positiveEarlier_total (a b : PositiveCellPoset M inj) (hne : a ≠ b) : + PositiveEarlier M z hz inj a b ∨ PositiveEarlier M z hz inj b a := by + rw [positiveEarlier_iff,positiveEarlier_iff] + rcases lt_trichotomy (positiveDegree M (positiveCellTop M a)) + (positiveDegree M (positiveCellTop M b)) with h|he|h + · exact Or.inl (Or.inl h) + · rcases lt_trichotomy (positiveMatchingTypeKey M z hz a) + (positiveMatchingTypeKey M z hz b) with h|he'|h + · exact Or.inl (Or.inr ⟨he,Or.inl h⟩) + · rcases trichotomous_of WellOrderingRel a b with h|hab|h + · exact Or.inl (Or.inr ⟨he,Or.inr ⟨he',h⟩⟩) + · exact (hne hab).elim + · exact Or.inr (Or.inr ⟨he.symm,Or.inr ⟨he'.symm,h⟩⟩) + · exact Or.inr (Or.inr ⟨he.symm,Or.inl h⟩) + · exact Or.inr (Or.inl h) + +lemma positiveEarlier_root (a : PositiveCellPoset M inj) : + ¬PositiveEarlier M z hz inj a (positiveRootCell M) := by + intro h + have hr := (positiveCellTop_eq_one_iff M (positiveRootCell M)).mpr rfl + have hd : positiveDegree M (positiveCellTop M (positiveRootCell M)) = 0 := by + rw [hr,positiveDegree_one] + have ha : a = positiveRootCell M := by + apply (positiveCellTop_eq_one_iff M a).mp + apply (positiveDegree_zero_iff M _).mp + rw [positiveEarlier_iff,hd] at h + omega + subst a + exact (positiveEarlier_wf M z hz inj).irrefl.irrefl _ h + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/PositiveCellPoset2.lean b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveCellPoset2.lean new file mode 100644 index 0000000000000000000000000000000000000000..0503e2884f37b430fe964e73d845d7b16414a340 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveCellPoset2.lean @@ -0,0 +1,117 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.LiftedDeck +import OAI.Topology.ArtinGroups.Realizations.PositiveCellPoset + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +variable (z : M.Group) (hz : ∀ w, M.toCoxeterSystem.length w ≤ M.toCoxeterSystem.length z) +variable (inj : Function.Injective (positiveToArtin M)) + +omit [Fintype S] [LinearOrder S] in +lemma positiveCellPoset_lt_iff (a b : PositiveCellPoset M inj) : + a < b ↔ positiveCellToLifted M a < positiveCellToLifted M b := Iff.rfl + +lemma positiveEarlier_of_top_lt (a b : PositiveCellPoset M inj) + (h : positiveDegree M (positiveCellTop M a) < positiveDegree M (positiveCellTop M b)) : + PositiveEarlier M z hz inj a b := + (positiveEarlier_iff M z hz inj a b).mpr (Or.inl h) + +lemma positiveEarlier_of_key_lt (a b : PositiveCellPoset M inj) + (he : positiveCellTop M a = positiveCellTop M b) + (h : positiveMatchingTypeKey M z hz a < positiveMatchingTypeKey M z hz b) : + PositiveEarlier M z hz inj a b := + (positiveEarlier_iff M z hz inj a b).mpr + (Or.inr ⟨congrArg (positiveDegree M) he,Or.inl h⟩) + +lemma positive_lt_orientation (a b : PositiveCellPoset M inj) (hab : a < b) : + PositiveEarlier M z hz inj a b ∨ + ∃ ha : positiveCellTop M a ≠ 1, + matchingLetter M z hz ⟨a,ha⟩ ∉ a.2.val ∧ + (positiveMatch M z hz inj ⟨a,ha⟩).val = b ∧ + PositiveEarlier M z hz inj b a := by + by_cases he : positiveCellTop M a = positiveCellTop M b + · have ha : positiveCellTop M a ≠ 1 := by + intro h + have ha' := (positiveCellTop_eq_one_iff M a).mp h + have hb' := (positiveCellTop_eq_one_iff M b).mp (he.symm.trans h) + exact hab.ne (ha'.trans hb'.symm) + have hb : positiveCellTop M b ≠ 1 := fun h => ha (he.trans h) + let s := matchingLetter M z hz ⟨a,ha⟩ + have ht : a.2.val.toFinset ⊂ b.2.val.toFinset := by + refine Finset.ssubset_iff_subset_ne.mpr ⟨?_,?_⟩ + · intro t ht + exact Set.mem_toFinset.mpr ((lifted_lt_type M hab).subset (Set.mem_toFinset.mp ht)) + · intro heq + have htype : a.2.val = b.2.val := by + ext t + simpa only [Set.mem_toFinset] using (congrArg (fun F : Finset S => t ∈ F) heq).to_iff + exact hab.ne (positiveCellToLifted_injective M inj + (lifted_eq_of_le_type_eq M hab.le htype)) + have hkA : positiveMatchingTypeKey M z hz a = topBlockMatchingKey s a.2.val.toFinset := by + simp only [positiveMatchingTypeKey,dite_eq_right ha,s,matchingLetter] + have hkB : positiveMatchingTypeKey M z hz b = topBlockMatchingKey s b.2.val.toFinset := by + simp only [positiveMatchingTypeKey,dite_eq_right hb,s,matchingLetter,he] + rcases topBlockMatchingKey_cases (s:=s) ht with hkey | ⟨hs,hT,hkey⟩ + · exact Or.inl (positiveEarlier_of_key_lt M z hz inj a b he (by rwa [hkA,hkB])) + · have hs' : s ∉ a.2.val := fun h => hs (Set.mem_toFinset.mpr h) + have hmatch : (positiveMatch M z hz inj ⟨a,ha⟩).val = b := by + apply positiveCell_same_top_type_unique M inj + · apply Subtype.ext + rw [positiveMatch_type,matchingOtherType,ite_eq_right hs'] + ext t + have hh := congrArg (fun F : Finset S => t ∈ F) hT + simpa only [Finset.mem_insert,Set.mem_toFinset,Set.mem_insert_iff] using hh.symm.to_iff + · exact (positiveMatch_top M z hz inj ⟨a,ha⟩).trans he + exact Or.inr ⟨ha,hs',hmatch, + positiveEarlier_of_key_lt M z hz inj b a he.symm (by rwa [hkA,hkB])⟩ + · exact Or.inl (positiveEarlier_of_top_lt M z hz inj a b + (positiveCellTop_degree_strict M inj a b hab.le he)) + +lemma positiveMatch_below_or_above (a : NoncriticalPositiveCell M) : + ((matchingLetter M z hz a ∉ a.val.2.val) ∧ + positiveCellToLifted M a.val < positiveCellToLifted M (positiveMatch M z hz inj a).val) ∨ + ((matchingLetter M z hz a ∈ a.val.2.val) ∧ + positiveCellToLifted M (positiveMatch M z hz inj a).val < positiveCellToLifted M a.val) := by + have hinc := positiveMatch_incident M z hz inj a + by_cases hs : matchingLetter M z hz a ∈ a.val.2.val + · right; refine ⟨hs,?_⟩ + rcases hinc with h|h + · have hsub := ((lifted_le_iff_face M _ _).mp h.le).1 + have hm := hsub hs + change matchingLetter M z hz a ∈ (positiveMatch M z hz inj a).val.2.val at hm + rw [positiveMatch_type,matchingOtherType,ite_eq_left hs] at hm + exact (hm.2 (Set.mem_singleton _)).elim + · exact h + · left; refine ⟨hs,?_⟩ + rcases hinc with h|h + · exact h + · have hsub := ((lifted_le_iff_face M _ _).mp h.le).1 + exact (hs (hsub (by + change matchingLetter M z hz a ∈ (positiveMatch M z hz inj a).val.2.val + rw [positiveMatch_type,matchingOtherType,ite_eq_right hs] + exact Set.mem_insert _ _))).elim + +lemma positiveMatch_before (a : NoncriticalPositiveCell M) + (hs : matchingLetter M z hz a ∉ a.val.2.val) : + PositiveEarlier M z hz inj (positiveMatch M z hz inj a).val a.val := by + apply positiveEarlier_of_key_lt M z hz inj _ _ (positiveMatch_top M z hz inj a) + simp only [positiveMatchingTypeKey,dite_eq_right a.property,positiveMatch_top] + apply topBlockStep_key (Or.inl ⟨?_,?_⟩) + · exact fun h => hs (Set.mem_toFinset.mp h) + · ext t + simp only [Set.mem_toFinset,Finset.mem_insert] + rw [positiveMatch_type,matchingOtherType,ite_eq_right hs] + rfl + +lemma positiveEarlier_asymm {a b : PositiveCellPoset M inj} + (h : PositiveEarlier M z hz inj a b) : ¬ PositiveEarlier M z hz inj b a := + (positiveEarlier_wf M z hz inj).asymmetric _ _ h + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/PositiveFullCell.lean b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveFullCell.lean new file mode 100644 index 0000000000000000000000000000000000000000..0167f27abc7ceabda545dbf61c629f75318d96ab --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveFullCell.lean @@ -0,0 +1,115 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.FullSphericalCell +import OAI.Topology.ArtinGroups.Harmonic.PositiveEarlierLinkUpper + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type*} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +variable (z : M.Group) (hz : ∀ w, M.toCoxeterSystem.length w ≤ M.toCoxeterSystem.length z) +variable (inj : Function.Injective (positiveToArtin M)) + +lemma positiveMatch_coatom (a : NoncriticalPositiveCell M) + (hs : matchingLetter M z hz a ∈ a.val.2.val) (b : PositiveCellPoset M inj) + (hdb : positiveCellToLifted M (positiveMatch M z hz inj a).val ≤ positiveCellToLifted M b) + (hba : positiveCellToLifted M b < positiveCellToLifted M a.val) : + b = (positiveMatch M z hz inj a).val := by + by_contra hne + have hlt : positiveCellToLifted M (positiveMatch M z hz inj a).val < positiveCellToLifted M b := + lt_of_le_of_ne hdb (fun he => hne (positiveCellToLifted_injective M inj he).symm) + have h1 := lifted_rank_strict M hlt + have h2 := lifted_rank_strict M hba + change (positiveMatch M z hz inj a).val.2.val.ncard < b.2.val.ncard at h1 + change b.2.val.ncard < a.val.2.val.ncard at h2 + rw [positiveMatch_type,matchingOtherType,ite_eq_left hs] at h1 + have hc := Set.ncard_sdiff_singleton_add_one hs (Set.toFinite a.val.2.val) + omega + +variable [Finite M.Group] + +noncomputable def positiveFullCell : PositiveLiftedCell M := (1,(fullSphericalCell M).2) + +omit [Fintype S] [LinearOrder S] in +lemma positiveFullCell_lifted : positiveCellToLifted M (positiveFullCell M) = fullSphericalCell M := by + exact Prod.ext (map_one (positiveToArtin M)) rfl + +omit [LinearOrder S] in +lemma positiveFullCell_top : positiveCellTop M (positiveFullCell M) = + positiveSimpleLift M (sphericalLongest M (fullSphericalCell M).2) := by + exact one_mul _ + +omit [LinearOrder S] in +lemma positiveFullCell_noncritical (s : S) : positiveCellTop M (positiveFullCell M) ≠ 1 := by + intro h + have he := (positiveCellTop_eq_one_iff M _).mp h + have ht := congrArg (fun a : PositiveLiftedCell M => a.2.val) he + change (Set.univ : Set S) = ∅ at ht + exact Set.notMem_empty s (ht ▸ Set.mem_univ s) + +lemma positiveMatch_face_full (a : NoncriticalPositiveCell M) + (h : positiveCellToLifted M a.val ≤ fullSphericalCell M) : + positiveCellToLifted M (positiveMatch M z hz inj a).val ≤ fullSphericalCell M := by + apply (lifted_le_iff_face M _ _).mpr + apply positiveCell_face_full_of_top_prefix + rw [positiveMatch_top,←positiveFullCell_top] + apply positiveCellTop_prefix_of_face M inj + rw [positiveFullCell_lifted] + exact (lifted_le_iff_face M _ _).mp h + +lemma positiveFullBoundary_down (hc : positiveCellTop M (positiveFullCell M) ≠ 1) + {a b : PositiveCellPoset M inj} (hab : a ≤ b) + (hb : positiveCellToLifted M b < fullSphericalCell M ∧ + b ≠ (positiveMatch M z hz inj ⟨positiveFullCell M,hc⟩).val) : + positiveCellToLifted M a < fullSphericalCell M ∧ + a ≠ (positiveMatch M z hz inj ⟨positiveFullCell M,hc⟩).val := by + change positiveCellToLifted M a ≤ positiveCellToLifted M b at hab + refine ⟨hab.trans_lt hb.1,?_⟩ + intro he + apply hb.2 + apply positiveMatch_coatom M z hz inj ⟨positiveFullCell M,hc⟩ (Set.mem_univ _) b + · simpa only [he] using hab + · simpa only [positiveFullCell_lifted] using hb.1 + +lemma positiveFullBoundary_match (hc : positiveCellTop M (positiveFullCell M) ≠ 1) + (a : NoncriticalPositiveCell M) + (ha : positiveCellToLifted M a.val < fullSphericalCell M ∧ + a.val ≠ (positiveMatch M z hz inj ⟨positiveFullCell M,hc⟩).val) : + positiveCellToLifted M (positiveMatch M z hz inj a).val < fullSphericalCell M ∧ + (positiveMatch M z hz inj a).val ≠ (positiveMatch M z hz inj ⟨positiveFullCell M,hc⟩).val := by + have hle := positiveMatch_face_full M z hz inj a ha.1.le + refine ⟨lt_of_le_of_ne hle ?_,?_⟩ + · intro he + have hm : (positiveMatch M z hz inj a).val = positiveFullCell M := + positiveCellToLifted_injective M inj (he.trans (positiveFullCell_lifted M).symm) + exact ha.2 (positiveMatch_symm_value M z hz inj a ⟨positiveFullCell M,hc⟩ hm).symm + · intro he + have hh := congrArg (positiveMatch M z hz inj) (Subtype.ext he) + rw [positiveMatch_involutive,positiveMatch_involutive] at hh + have hh' := congrArg (fun a : NoncriticalPositiveCell M => positiveCellToLifted M a.val) hh + rw [positiveFullCell_lifted] at hh' + exact ha.1.ne hh' + +lemma positiveFullBoundary_root (hc : positiveCellTop M (positiveFullCell M) ≠ 1) : + positiveCellToLifted M (positiveRootCell M) < fullSphericalCell M ∧ + positiveRootCell M ≠ (positiveMatch M z hz inj ⟨positiveFullCell M,hc⟩).val := by + have hr : positiveCellTop M (positiveRootCell M) = 1 := (positiveCellTop_eq_one_iff M _).mpr rfl + have hle : positiveCellToLifted M (positiveRootCell M) ≤ fullSphericalCell M := by + apply (lifted_le_iff_face M _ _).mpr + apply positiveCell_face_full_of_top_prefix + rw [hr] + exact ⟨_,(one_mul _).symm⟩ + refine ⟨lt_of_le_of_ne hle ?_,?_⟩ + · intro he + have hh := positiveCellToLifted_injective M inj (he.trans (positiveFullCell_lifted M).symm) + exact hc (by rw [←hh,hr]) + · intro he + have hh := positiveMatch_top M z hz inj ⟨positiveFullCell M,hc⟩ + rw [←he,hr] at hh + exact hc hh.symm + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/PositiveLiftedCell.lean b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveLiftedCell.lean new file mode 100644 index 0000000000000000000000000000000000000000..b70536da338985735a0c1b84ce87b87b8c446942 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveLiftedCell.lean @@ -0,0 +1,84 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.SphericalLongest + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type*} [Fintype S] (M:CoxeterMatrix S) + +lemma positiveSimpleLift_prefix_longest (T:Set S) (q:M.Group) (hq:IsParabolicLongest M T q) + (w:M.Group) (hw:w∈coxeterParabolic M T) : + PositivePrefix M (positiveSimpleLift M w) (positiveSimpleLift M q) := by + have hh:=parabolic_longest_length_mul M T q hq w hw + have he:M.toCoxeterSystem.length (w⁻¹*q)=M.toCoxeterSystem.length (q*w):=by + have h:=M.toCoxeterSystem.length_inv (q*w) + rw [mul_inv_rev,parabolic_longest_inverse M T q hq] at h + exact h + refine ⟨positiveSimpleLift M (w⁻¹*q),?_⟩ + have hlen:M.toCoxeterSystem.length (w*(w⁻¹*q))= + M.toCoxeterSystem.length w+M.toCoxeterSystem.length (w⁻¹*q):=by + rw [mul_inv_cancel_left,he] + omega + simpa only [mul_inv_cancel_left] using positiveSimpleLift_mul M w (w⁻¹*q) hlen + +abbrev PositiveLiftedCell := PositiveArtin M × SphericalType M + +def positiveCellToLifted (a:PositiveLiftedCell M) : LiftedCell M := + (positiveToArtin M a.1,a.2) + +noncomputable def positiveCellTop (a:PositiveLiftedCell M) : PositiveArtin M := + a.1*positiveSimpleLift M (sphericalLongest M a.2) + +lemma positiveCellTop_toArtin (a:PositiveLiftedCell M) : + positiveToArtin M (positiveCellTop M a)=liftedTopVertex M (positiveCellToLifted M a) := by + simp only [positiveCellTop,map_mul,positiveToArtin_simpleLift,liftedTopVertex,positiveCellToLifted] + +theorem positiveCellTop_prefix_of_face + (inj:Function.Injective (positiveToArtin M)) (a b:PositiveLiftedCell M) + (h:LiftedFace M (positiveCellToLifted M a) (positiveCellToLifted M b)) : + PositivePrefix M (positiveCellTop M a) (positiveCellTop M b) := by + obtain ⟨hAB,u,hu,hr,hmin,he⟩:=h + have hr':M.toCoxeterSystem.IsReduced u:=hr + have ha:a.1=b.1*wordPositive M u:=by + apply inj + simpa only [map_mul,positiveToArtin_word,positiveCellToLifted] using he + let v:=wordCoxeter M u*sphericalLongest M a.2 + have hlen:M.toCoxeterSystem.length v=M.toCoxeterSystem.length (wordCoxeter M u)+ + M.toCoxeterSystem.length (sphericalLongest M a.2):=by + apply length_mul_of_right_minimum M.toCoxeterSystem a.2.val (wordCoxeter M u) + · intro x hx + exact hmin ⟨x,hx⟩ + · exact (sphericalLongest_spec M a.2).1 + have hv:v∈coxeterParabolic M b.2.val:=(coxeterParabolic M b.2.val).mul_mem + (wordCoxeter_mem_parabolic M _ u hu) + (coxeterParabolic_mono M hAB (sphericalLongest_spec M a.2).1) + obtain ⟨r,heq⟩:=positiveSimpleLift_prefix_longest M _ _ (sphericalLongest_spec M b.2) v hv + have hu':wordPositive M u=positiveSimpleLift M (wordCoxeter M u):=(positiveSimpleLift_word M u hr').symm + have ha':positiveCellTop M a=b.1*positiveSimpleLift M v:=by + change a.1*positiveSimpleLift M (sphericalLongest M a.2)=_ + rw [ha,hu',mul_assoc,←positiveSimpleLift_mul M _ _ hlen] + refine ⟨r,?_⟩ + change b.1*positiveSimpleLift M (sphericalLongest M b.2)=_ + rw [ha',heq,mul_assoc] + +lemma positiveCellTop_degree_mono + (inj:Function.Injective (positiveToArtin M)) (a b:PositiveLiftedCell M) + (h:positiveCellToLifted M a≤positiveCellToLifted M b) : + positiveDegree M (positiveCellTop M a)≤positiveDegree M (positiveCellTop M b) := + positivePrefix_degree M (positiveCellTop_prefix_of_face M inj a b ((lifted_le_iff_face M _ _).mp h)) + +lemma positiveCellTop_degree_strict + (inj:Function.Injective (positiveToArtin M)) (a b:PositiveLiftedCell M) + (h:positiveCellToLifted M a≤positiveCellToLifted M b) + (hne:positiveCellTop M a≠positiveCellTop M b) : + positiveDegree M (positiveCellTop M a)hne (positivePrefix_eq_of_degree M hp he)) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/PositiveRootCell.lean b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveRootCell.lean new file mode 100644 index 0000000000000000000000000000000000000000..b7a985286d8c0e45ddcd0a8fc4737247b2e14fb0 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/PositiveRootCell.lean @@ -0,0 +1,65 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.PositiveMatchingTypeKey +import OAI.Topology.ArtinGroups.Realizations.NoncriticalPositiveCell + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type*} [Fintype S] (M:CoxeterMatrix S) + +omit [Fintype S] in +lemma positiveDescentSet_one : PositiveDescentSet M 1=∅ := by + apply Set.eq_empty_iff_forall_notMem.mpr + intro s hs + obtain ⟨p,hp⟩:=hs + have h:=congrArg (positiveDegree M) hp + simp only [positiveDegree_one,positiveDegree_mul,positiveDegree_generator] at h + omega + +noncomputable def positiveRootCell : PositiveLiftedCell M := + (1,⟨∅,spherical_empty M⟩) + +lemma positiveCellTop_eq_one_iff (a:PositiveLiftedCell M) : + positiveCellTop M a=1 ↔ a=positiveRootCell M := by + constructor + · intro h + have ht:=type_subset_positiveDescentSet M _ _ (sphericalLongest_spec M a.2) a.1 + change a.2.val⊆PositiveDescentSet M (positiveCellTop M a) at ht + rw [h,positiveDescentSet_one] at ht + have htype:a.2.val=∅:=Set.subset_empty_iff.mp ht + have hd:=congrArg (positiveDegree M) h + simp only [positiveCellTop,positiveDegree_mul,positiveDegree_one] at hd + apply Prod.ext + · exact (positiveDegree_zero_iff M a.1).mp (by omega) + · exact Subtype.ext htype + · rintro rfl + have hq: sphericalLongest M (positiveRootCell M).2=1 := by + have h:=(sphericalLongest_spec M (positiveRootCell M).2).1 + simpa [positiveRootCell,coxeterParabolic] using h + change 1*positiveSimpleLift M (sphericalLongest M (positiveRootCell M).2)=1 + rw [one_mul,hq] + apply (positiveDegree_zero_iff M _).mp + simp only [positiveDegree_simpleLift,M.toCoxeterSystem.length_one] + +variable [LinearOrder S] (z:M.Group) + (hz:∀w,M.toCoxeterSystem.length w≤M.toCoxeterSystem.length z) + (inj:Function.Injective (positiveToArtin M)) + +lemma positiveMatch_gradient (a:NoncriticalPositiveCell M) + (hs:matchingLetter M z hz a ∉ a.val.2.val) : + PositiveGradientStep M z hz a.val (positiveMatch M z hz inj a).val := by + right + refine ⟨a.property,positiveMatch_top M z hz inj a,Or.inl ⟨?_,?_⟩⟩ + · exact fun h=>hs (Set.mem_toFinset.mp h) + · have ht:=positiveMatch_type M z hz inj a + rw [matchingOtherType,ite_eq_right hs] at ht + ext s + simp only [Set.mem_toFinset,Finset.mem_insert,ht,Set.mem_insert_iff] + rfl + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/QuotientFinrankKer.lean b/lean/OAI/Topology/ArtinGroups/Realizations/QuotientFinrankKer.lean new file mode 100644 index 0000000000000000000000000000000000000000..489044cf02d09a7ca19e3ce50b71d262843b4298 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/QuotientFinrankKer.lean @@ -0,0 +1,166 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.CornerScalar +import OAI.Topology.ArtinGroups.Complexes.TermwiseSplitInjection + +namespace OAI + +namespace HarmonicArtin + +lemma quotient_finrank_le_of_ker_le {K U W:Type*} [Field K] + [AddCommGroup U] [Module K U] [Module.Finite K U] + [AddCommGroup W] [Module K W] [Module.Finite K W] + (B:Submodule K U) (f:U→ₗ[K]W) (h:LinearMap.ker f≤B) : + Module.finrank K (U ⧸ B)≤Module.finrank K W := by + have hq:=B.finrank_quotient_add_finrank + have hr:=f.finrank_range_add_finrank_ker + have hk:=Submodule.finrank_mono h + have hi:=Submodule.finrank_le (LinearMap.range f) + omega + +namespace ReversibleQuiver.Zigzag.BasedComplex +variable {V A K I J I' J':Type*} (Q:ReversibleQuiver V A) + [Field K] [Fintype V] [Fintype A] [DecidableEq V] [DecidableEq A] + [Fintype I] [Fintype J] [Fintype I'] [Fintype J'] + +omit [DecidableEq A] in +lemma homDimension_le_of_cycle_map + (E:BasedComplex Q (K:=K) I) (F:BasedComplex Q (K:=K) J) + (E':BasedComplex Q (K:=K) I') (F':BasedComplex Q (K:=K) J') (n v:ℤ) + (T:homCycles Q E F n v→ₗ[K]homCycles Q E' F' n v) + (hr:∀ f:homCycles Q E F n v, + (T f).val∈homBoundaries Q E' F' n v→f.val∈homBoundaries Q E F n v) : + homDimension Q E F n v≤homDimension Q E' F' n v := by + let B:Submodule K (homCycles Q E F n v):= + (homBoundaries Q E F n v).comap (homCycles Q E F n v).subtype + let B':Submodule K (homCycles Q E' F' n v):= + (homBoundaries Q E' F' n v).comap (homCycles Q E' F' n v).subtype + apply quotient_finrank_le_of_ker_le B (B'.mkQ.comp T) + intro f hf + exact hr f ((Submodule.Quotient.mk_eq_zero B').mp hf) + +omit [DecidableEq A] in +theorem middleLayer_homDimension_le + (E:BasedComplex Q (K:=K) I) (F:BasedComplex Q (K:=K) J) + (hE:E.IsMinimal Q) (hF:F.IsMinimal Q) (l k n v:ℤ) (h:n+v=k-l+1) : + homDimension Q (E.pureLayer Q hE l) (F.pureLayer Q hF k) n v≤homDimension Q E F n v := by + let T:homCycles Q (E.pureLayer Q hE l) (F.pureLayer Q hF k) n v→ₗ[K] + homCycles Q E F n v := + (extendLayer Q E F l k).restrict (fun f hf=> + extendLayer_cycle Q E F hE hF l k n v hf + (pure_homSpace_linear Q _ _ (fun i=>i.property) (fun j=>j.property) h hf.1)) + apply homDimension_le_of_cycle_map Q _ _ E F n v T + intro f hf + exact layer_boundary_of_extended_boundary Q E F hE hF l k n v + (pure_homSpace_linear Q _ _ (fun i=>i.property) (fun j=>j.property) h f.property.1) hf + +omit [Fintype V] [DecidableEq A] in +lemma homSpace_positive_of_vertexLevelBound + (E:BasedComplex Q (K:=K) I) (F:BasedComplex Q (K:=K) J) (r n v:ℤ) + (hb:∀i j,(E.placement i).color=(F.placement j).color→ + (F.placement j).level-(E.placement i).level≤r) (h:r + ⟨extendLayer_homSpace Q E F hE hF l k n v hf.1, + homDifferential_token_zero Q E F hE hF n + (TokenMatrix.extendLayer Q E F l k + (pure_homSpace_token Q _ _ (fun i=>i.property) (fun j=>j.property) h hf.1))⟩) + apply homDimension_le_of_cycle_map Q _ _ E F n v T + intro f hf + exact tokenLayer_boundary_of_extended_boundary Q E F hE hF l k n v h hb hf + +omit [DecidableEq A] in +lemma middleLayer_totalHomDimension_le + (E:BasedComplex Q (K:=K) I) (F:BasedComplex Q (K:=K) J) + (hE:E.IsMinimal Q) (hF:F.IsMinimal Q) (l k:ℤ) : + totalHomDimension Q (E.pureLayer Q hE l) (F.pureLayer Q hF k) (k-l+1)≤ + totalHomDimension Q E F (k-l+1) := by + classical + let M:=E.pureLayer Q hE l + let N:=F.pureLayer Q hF k + let D:=homInternalSupport Q M N ∪ homInternalSupport Q E F + rw [totalHomDimension_eq_sum_of_subset Q M N (k-l+1) D Finset.subset_union_left, + totalHomDimension_eq_sum_of_subset Q E F (k-l+1) D Finset.subset_union_right] + exact Finset.sum_le_sum (fun v _=>middleLayer_homDimension_le Q E F hE hF l k _ v (by omega)) + +omit [DecidableEq A] in +lemma tokenLayer_totalHomDimension_le + (E:BasedComplex Q (K:=K) I) (F:BasedComplex Q (K:=K) J) + (hE:E.IsMinimal Q) (hF:F.IsMinimal Q) (l k:ℤ) + (hb:∀i j,(E.placement i).color=(F.placement j).color→ + (F.placement j).level-(E.placement i).level≤k-l) : + totalHomDimension Q (E.pureLayer Q hE l) (F.pureLayer Q hF k) (k-l+2)≤ + totalHomDimension Q E F (k-l+2) := by + classical + let M:=E.pureLayer Q hE l + let N:=F.pureLayer Q hF k + let D:=homInternalSupport Q M N ∪ homInternalSupport Q E F + rw [totalHomDimension_eq_sum_of_subset Q M N (k-l+2) D Finset.subset_union_left, + totalHomDimension_eq_sum_of_subset Q E F (k-l+2) D Finset.subset_union_right] + exact Finset.sum_le_sum (fun v _=>tokenLayer_homDimension_le Q E F hE hF l k _ v (by omega) hb) + +end ReversibleQuiver.Zigzag.BasedComplex +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/RealizeSimplex.lean b/lean/OAI/Topology/ArtinGroups/Realizations/RealizeSimplex.lean new file mode 100644 index 0000000000000000000000000000000000000000..9a723bb0744dcb0ec5e1d03f8ba555f0d6208ab5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/RealizeSimplex.lean @@ -0,0 +1,410 @@ +import Mathlib + +namespace OAI + +section TopologyDependencies +open CategoryTheory Opposite Simplicial +open scoped unitInterval + +namespace HarmonicArtin +universe u + +noncomputable def realizeSimplex (X : SSet.{u}) {n : SimplexCategory} + (x : X.obj (op n)) : C(Convexity.StdSimplex ℝ (Fin (n.len + 1)), |X|) := + TopCat.toSSetObjEquiv _ _ ((sSetTopAdj.unit.app X).app (op n) x) + +lemma realizeSimplex_natural (X : SSet.{u}) {n m : SimplexCategory} + (f : n ⟶ m) (x : X.obj (op m)) (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) : + realizeSimplex X (X.map f.op x) z = + realizeSimplex X x (Convexity.StdSimplex.map f.toOrderHom z) := by + have h := ConcreteCategory.congr_hom ((sSetTopAdj.unit.app X).naturality f.op) x + change (sSetTopAdj.unit.app X).app (op n) (X.map f.op x) = + (TopCat.toSSet.obj |X|).map f.op ((sSetTopAdj.unit.app X).app (op m) x) at h + unfold realizeSimplex + rw [h] + exact TopCat.toSSetObjEquiv_naturality_apply f _ z + +def prependOrdinal {n m : SimplexCategory} (f : n ⟶ m) : + ⦋n.len + 1⦌ ⟶ ⦋m.len + 1⦌ := + SimplexCategory.mkHom { + toFun := Fin.cons 0 (fun i => (f.toOrderHom i).succ) + monotone' := by + intro a b hab + induction a using Fin.cases with + | zero => exact Fin.zero_le _ + | succ a => + induction b using Fin.cases with + | zero => simp at hab + | succ b => + exact Fin.succ_le_succ_iff.mpr + (f.toOrderHom.monotone (Fin.succ_le_succ_iff.mp hab)) } + +@[simp] lemma prependOrdinal_zero {n m : SimplexCategory} (f : n ⟶ m) : + (prependOrdinal f).toOrderHom 0 = 0 := rfl +@[simp] lemma prependOrdinal_succ {n m : SimplexCategory} (f : n ⟶ m) + (i : Fin (n.len + 1)) : + (prependOrdinal f).toOrderHom i.succ = (f.toOrderHom i).succ := rfl + +noncomputable def coneSimplex (n : ℕ) : + C(Convexity.StdSimplex ℝ (Fin (n + 1)) × I, Convexity.StdSimplex ℝ (Fin (n + 2))) where + toFun point := Convexity.convexCombPair point.2.val (1 - point.2.val) + point.2.property.1 (sub_nonneg.mpr point.2.property.2) (add_sub_cancel _ _) + (Convexity.StdSimplex.single 0) (Convexity.StdSimplex.map Fin.succ point.1) + continuous_toFun := by + rw [(Convexity.StdSimplex.isEmbedding_toFun_comp_weights ℝ _).continuous_iff] + refine continuous_pi (fun index => ?_) + simp only [Function.comp_apply, Convexity.StdSimplex.weights_convexCombPair, + Finsupp.coe_add, Finsupp.coe_smul, Pi.add_apply, Pi.smul_apply, smul_eq_mul] + exact ((continuous_subtype_val.comp continuous_snd).mul continuous_const).add + ((continuous_const.sub (continuous_subtype_val.comp continuous_snd)).mul + ((Convexity.StdSimplex.continuous_weights_apply ℝ index).comp + ((Convexity.StdSimplex.continuous_map ℝ Fin.succ).comp continuous_fst))) + +@[simp] lemma coneSimplex_zero (n : ℕ) (z : Convexity.StdSimplex ℝ (Fin (n + 1))) : + coneSimplex n (z, 0) = Convexity.StdSimplex.map Fin.succ z := by + ext i + simp [coneSimplex] + +@[simp] lemma coneSimplex_one (n : ℕ) (z : Convexity.StdSimplex ℝ (Fin (n + 1))) : + coneSimplex n (z, 1) = Convexity.StdSimplex.single 0 := by + ext i + simp [coneSimplex] + +lemma map_coneSimplex {n m : SimplexCategory} (f : n ⟶ m) + (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) (t : I) : + Convexity.StdSimplex.map (prependOrdinal f).toOrderHom (coneSimplex n.len (z, t)) = + coneSimplex m.len (Convexity.StdSimplex.map f.toOrderHom z, t) := by + have hs : Convexity.StdSimplex.map (prependOrdinal f).toOrderHom (Convexity.StdSimplex.map Fin.succ z) = + Convexity.StdSimplex.map Fin.succ (Convexity.StdSimplex.map f.toOrderHom z) := by + rw [← Convexity.StdSimplex.map_comp, ← Convexity.StdSimplex.map_comp] + rfl + dsimp only [coneSimplex, ContinuousMap.coe_mk] + rw [(Convexity.StdSimplex.isAffineMap_map ℝ _).map_convexCombPair, + Convexity.StdSimplex.map_single, hs] + rfl + +variable (P : Type u) [Preorder P] [OrderBot P] + +def prependNerve {n : SimplexCategory} (x : (nerve P).obj (op n)) : + (nerve P).obj (op ⦋n.len + 1⦌) := + x.precomp (homOfLE bot_le) + +lemma prependNerve_natural {n m : SimplexCategory} (f : n ⟶ m) + (x : (nerve P).obj (op m)) : + prependNerve P ((nerve P).map f.op x) = + (nerve P).map (prependOrdinal f).op (prependNerve P x) := by + apply nerve.ext_of_isThin + funext i + induction i using Fin.cases with + | zero => rfl + | succ i => rfl + +lemma prependNerve_face {n : SimplexCategory} (x : (nerve P).obj (op n)) : + (nerve P).map (SimplexCategory.δ (0 : Fin (n.len + 2))).op (prependNerve P x) = x := by + apply nerve.ext_of_isThin + funext i + rfl + +noncomputable def nerveConeSimplex {n : SimplexCategory} (x : (nerve P).obj (op n)) : + C(Convexity.StdSimplex ℝ (Fin (n.len + 1)), C(I, |nerve P|)) := + ((realizeSimplex (nerve P) (prependNerve P x)).comp (coneSimplex n.len)).curry + +lemma nerveConeSimplex_natural {n m : SimplexCategory} (f : n ⟶ m) + (x : (nerve P).obj (op m)) (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) (t : I) : + nerveConeSimplex P ((nerve P).map f.op x) z t = + nerveConeSimplex P x (Convexity.StdSimplex.map f.toOrderHom z) t := by + change realizeSimplex (nerve P) (prependNerve P ((nerve P).map f.op x)) + (coneSimplex n.len (z, t)) = + realizeSimplex (nerve P) (prependNerve P x) + (coneSimplex m.len (Convexity.StdSimplex.map f.toOrderHom z, t)) + rw [prependNerve_natural, realizeSimplex_natural, map_coneSimplex] + +@[simp] lemma nerveConeSimplex_zero {n : SimplexCategory} + (x : (nerve P).obj (op n)) (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) : + nerveConeSimplex P x z 0 = realizeSimplex (nerve P) x z := by + change realizeSimplex (nerve P) (prependNerve P x) (coneSimplex n.len (z, 0)) = _ + rw [coneSimplex_zero] + have h := realizeSimplex_natural (nerve P) + (SimplexCategory.δ (0 : Fin (n.len + 2))) (prependNerve P x) z + rw [prependNerve_face] at h + exact h.symm + +noncomputable def nerveBotPoint : |nerve P| := + realizeSimplex (nerve P) (ComposableArrows.mk₀ (⊥ : P)) (Convexity.StdSimplex.single 0) + +@[simp] lemma nerveConeSimplex_one {n : SimplexCategory} + (x : (nerve P).obj (op n)) (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) : + nerveConeSimplex P x z 1 = nerveBotPoint P := by + change realizeSimplex (nerve P) (prependNerve P x) (coneSimplex n.len (z, 1)) = _ + rw [coneSimplex_one] + let f : ⦋0⦌ ⟶ ⦋n.len + 1⦌ := SimplexCategory.mkHom (OrderHom.const _ 0) + have hf : (nerve P).map f.op (prependNerve P x) = ComposableArrows.mk₀ (⊥ : P) := by + apply nerve.ext_of_isThin + rfl + have h := realizeSimplex_natural (nerve P) f (prependNerve P x) (Convexity.StdSimplex.single 0) + rw [hf, Convexity.StdSimplex.map_single] at h + exact h.symm + +noncomputable def nerveConeMap : + nerve P ⟶ TopCat.toSSet.obj (TopCat.of C(I, |nerve P|)) where + app n := ↾fun x => (TopCat.toSSetObjEquiv _ n).symm (nerveConeSimplex P x) + naturality {n m} f := by + apply ConcreteCategory.hom_ext + intro x + apply (TopCat.toSSetObjEquiv _ m).injective + ext z t + exact nerveConeSimplex_natural P f.unop x z t + +noncomputable def nerveCone : C(|nerve P|, C(I, |nerve P|)) := + ((sSetTopAdj.homEquiv _ _).symm (nerveConeMap P)).hom + +noncomputable def pathEvaluate (t : I) : TopCat.of C(I, |nerve P|) ⟶ |nerve P| := + TopCat.ofHom ⟨fun f => f t, continuous_eval_const t⟩ + +lemma nerveCone_zero : + (TopCat.ofHom (nerveCone P)) ≫ pathEvaluate P 0 = 𝟙 |nerve P| := by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_naturality_right] + simp only [nerveCone, TopCat.ofHom_hom, Equiv.apply_symm_apply] + rw [Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + exact nerveConeSimplex_zero P x z + +lemma nerveCone_one : + (TopCat.ofHom (nerveCone P)) ≫ pathEvaluate P 1 = TopCat.const (nerveBotPoint P) := by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_naturality_right] + simp only [nerveCone, TopCat.ofHom_hom, Equiv.apply_symm_apply] + rw [Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + exact nerveConeSimplex_one P x z + +theorem nerve_orderBot_contractible : ContractibleSpace |nerve P| := by + apply (contractible_iff_id_nullhomotopic _).mpr + refine ⟨nerveBotPoint P, ⟨{ + toFun := fun p => nerveCone P p.2 p.1 + continuous_toFun := ?_ + map_zero_left := ?_ + map_one_left := ?_ }⟩⟩ + · exact (nerveCone P).uncurry.continuous.comp continuous_swap + · intro x + exact ConcreteCategory.congr_hom (nerveCone_zero P) x + · intro x + exact ConcreteCategory.congr_hom (nerveCone_one P) x + +section TopCone +variable (Q : Type u) [Preorder Q] [OrderTop Q] + +def appendOrdinal {n m : SimplexCategory} (f : n ⟶ m) : + ⦋n.len + 1⦌ ⟶ ⦋m.len + 1⦌ := + SimplexCategory.mkHom { + toFun := Fin.snoc (fun i => (f.toOrderHom i).castSucc) (Fin.last (m.len + 1)) + monotone' := by + intro a b hab + induction b using Fin.lastCases with + | last => + simp only [Fin.snoc_last] + exact Fin.le_last _ + | cast b => + induction a using Fin.lastCases with + | last => exact False.elim ((not_le_of_gt (Fin.castSucc_lt_last b)) hab) + | cast a => + simpa only [Fin.snoc_castSucc] using Fin.castSucc_le_castSucc_iff.mpr + (f.toOrderHom.monotone (Fin.castSucc_le_castSucc_iff.mp hab)) } + +@[simp] lemma appendOrdinal_last {n m : SimplexCategory} (f : n ⟶ m) : + (appendOrdinal f).toOrderHom (Fin.last (n.len + 1)) = Fin.last (m.len + 1) := by + change (Fin.snoc (α := fun _ : Fin (n.len + 2) => Fin (m.len + 2)) + (fun j => (f.toOrderHom j).castSucc) (Fin.last (m.len + 1))) (Fin.last (n.len + 1)) = _ + exact Fin.snoc_last _ _ +@[simp] lemma appendOrdinal_castSucc {n m : SimplexCategory} (f : n ⟶ m) + (i : Fin (n.len + 1)) : + (appendOrdinal f).toOrderHom i.castSucc = (f.toOrderHom i).castSucc := by + change (Fin.snoc (α := fun _ : Fin (n.len + 2) => Fin (m.len + 2)) + (fun j => (f.toOrderHom j).castSucc) (Fin.last (m.len + 1))) i.castSucc = _ + exact Fin.snoc_castSucc _ _ _ + +noncomputable def topConeSimplex (n : ℕ) : + C(Convexity.StdSimplex ℝ (Fin (n + 1)) × I, Convexity.StdSimplex ℝ (Fin (n + 2))) where + toFun point := Convexity.convexCombPair point.2.val (1 - point.2.val) + point.2.property.1 (sub_nonneg.mpr point.2.property.2) (add_sub_cancel _ _) + (Convexity.StdSimplex.single (Fin.last (n + 1))) + (Convexity.StdSimplex.map Fin.castSucc point.1) + continuous_toFun := by + rw [(Convexity.StdSimplex.isEmbedding_toFun_comp_weights ℝ _).continuous_iff] + refine continuous_pi (fun index => ?_) + simp only [Function.comp_apply, Convexity.StdSimplex.weights_convexCombPair, + Finsupp.coe_add, Finsupp.coe_smul, Pi.add_apply, Pi.smul_apply, smul_eq_mul] + exact ((continuous_subtype_val.comp continuous_snd).mul continuous_const).add + ((continuous_const.sub (continuous_subtype_val.comp continuous_snd)).mul + ((Convexity.StdSimplex.continuous_weights_apply ℝ index).comp + ((Convexity.StdSimplex.continuous_map ℝ Fin.castSucc).comp continuous_fst))) + +@[simp] lemma topConeSimplex_zero (n : ℕ) (z : Convexity.StdSimplex ℝ (Fin (n + 1))) : + topConeSimplex n (z, 0) = Convexity.StdSimplex.map Fin.castSucc z := by + ext i + simp [topConeSimplex] + +@[simp] lemma topConeSimplex_one (n : ℕ) (z : Convexity.StdSimplex ℝ (Fin (n + 1))) : + topConeSimplex n (z, 1) = Convexity.StdSimplex.single (Fin.last (n + 1)) := by + ext i + simp [topConeSimplex] + +lemma map_topConeSimplex {n m : SimplexCategory} (f : n ⟶ m) + (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) (t : I) : + Convexity.StdSimplex.map (appendOrdinal f).toOrderHom (topConeSimplex n.len (z, t)) = + topConeSimplex m.len (Convexity.StdSimplex.map f.toOrderHom z, t) := by + have hs : Convexity.StdSimplex.map (appendOrdinal f).toOrderHom (Convexity.StdSimplex.map Fin.castSucc z) = + Convexity.StdSimplex.map Fin.castSucc (Convexity.StdSimplex.map f.toOrderHom z) := by + rw [← Convexity.StdSimplex.map_comp, ← Convexity.StdSimplex.map_comp] + congr 1 + funext i + exact appendOrdinal_castSucc f i + dsimp only [topConeSimplex, ContinuousMap.coe_mk] + rw [(Convexity.StdSimplex.isAffineMap_map ℝ _).map_convexCombPair, + Convexity.StdSimplex.map_single, hs, appendOrdinal_last] + +def appendNerve {n : SimplexCategory} (x : (nerve Q).obj (op n)) : + (nerve Q).obj (op ⦋n.len + 1⦌) := + (show Monotone (Fin.snoc x.obj (⊤ : Q)) from by + intro a b hab + induction b using Fin.lastCases with + | last => simp only [Fin.snoc_last, le_top] + | cast b => + induction a using Fin.lastCases with + | last => exact False.elim ((not_le_of_gt (Fin.castSucc_lt_last b)) hab) + | cast a => + simpa using (leOfHom (x.map (homOfLE (Fin.castSucc_le_castSucc_iff.mp hab))))).functor + +lemma appendNerve_natural {n m : SimplexCategory} (f : n ⟶ m) + (x : (nerve Q).obj (op m)) : + appendNerve Q ((nerve Q).map f.op x) = + (nerve Q).map (appendOrdinal f).op (appendNerve Q x) := by + apply nerve.ext_of_isThin + funext i + induction i using Fin.lastCases with + | last => + change (Fin.snoc (α := fun _ : Fin (n.len + 2) => Q) _ ⊤) (Fin.last _) = + (Fin.snoc (α := fun _ : Fin (m.len + 2) => Q) x.obj ⊤) + ((appendOrdinal f).toOrderHom (Fin.last _)) + simp only [appendOrdinal_last, Fin.snoc_last] + | cast i => + change (Fin.snoc (α := fun _ : Fin (n.len + 2) => Q) _ ⊤) i.castSucc = + (Fin.snoc (α := fun _ : Fin (m.len + 2) => Q) x.obj ⊤) + ((appendOrdinal f).toOrderHom i.castSucc) + simp only [appendOrdinal_castSucc, Fin.snoc_castSucc] + rfl + +lemma appendNerve_face {n : SimplexCategory} (x : (nerve Q).obj (op n)) : + (nerve Q).map (SimplexCategory.δ (Fin.last (n.len + 1))).op (appendNerve Q x) = x := by + apply nerve.ext_of_isThin + funext i + change (Fin.snoc (α := fun _ : Fin (n.len + 2) => Q) x.obj ⊤) + ((Fin.last (n.len + 1)).succAbove i) = x.obj i + simp only [Fin.succAbove_last, Fin.snoc_castSucc] + +noncomputable def nerveTopConeSimplex {n : SimplexCategory} (x : (nerve Q).obj (op n)) : + C(Convexity.StdSimplex ℝ (Fin (n.len + 1)), C(I, |nerve Q|)) := + ((realizeSimplex (nerve Q) (appendNerve Q x)).comp (topConeSimplex n.len)).curry + +lemma nerveTopConeSimplex_natural {n m : SimplexCategory} (f : n ⟶ m) + (x : (nerve Q).obj (op m)) (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) (t : I) : + nerveTopConeSimplex Q ((nerve Q).map f.op x) z t = + nerveTopConeSimplex Q x (Convexity.StdSimplex.map f.toOrderHom z) t := by + change realizeSimplex (nerve Q) (appendNerve Q ((nerve Q).map f.op x)) + (topConeSimplex n.len (z, t)) = + realizeSimplex (nerve Q) (appendNerve Q x) + (topConeSimplex m.len (Convexity.StdSimplex.map f.toOrderHom z, t)) + rw [appendNerve_natural, realizeSimplex_natural, map_topConeSimplex] + +@[simp] lemma nerveTopConeSimplex_zero {n : SimplexCategory} + (x : (nerve Q).obj (op n)) (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) : + nerveTopConeSimplex Q x z 0 = realizeSimplex (nerve Q) x z := by + change realizeSimplex (nerve Q) (appendNerve Q x) (topConeSimplex n.len (z, 0)) = _ + rw [topConeSimplex_zero] + have h := realizeSimplex_natural (nerve Q) + (SimplexCategory.δ (Fin.last (n.len + 1))) (appendNerve Q x) z + rw [appendNerve_face] at h + change realizeSimplex (nerve Q) x z = + realizeSimplex (nerve Q) (appendNerve Q x) + (Convexity.StdSimplex.map (Fin.last (n.len + 1)).succAbove z) at h + rw [Fin.succAbove_last] at h + exact h.symm + +noncomputable def nerveTopPoint : |nerve Q| := + realizeSimplex (nerve Q) (ComposableArrows.mk₀ (⊤ : Q)) (Convexity.StdSimplex.single 0) + +@[simp] lemma nerveTopConeSimplex_one {n : SimplexCategory} + (x : (nerve Q).obj (op n)) (z : Convexity.StdSimplex ℝ (Fin (n.len + 1))) : + nerveTopConeSimplex Q x z 1 = nerveTopPoint Q := by + change realizeSimplex (nerve Q) (appendNerve Q x) (topConeSimplex n.len (z, 1)) = _ + rw [topConeSimplex_one] + let f : ⦋0⦌ ⟶ ⦋n.len + 1⦌ := SimplexCategory.mkHom (OrderHom.const _ (Fin.last (n.len + 1))) + have hf : (nerve Q).map f.op (appendNerve Q x) = ComposableArrows.mk₀ (⊤ : Q) := by + apply nerve.ext_of_isThin + funext i + change (Fin.snoc (α := fun _ : Fin (n.len + 2) => Q) x.obj ⊤) + (Fin.last (n.len + 1)) = ⊤ + exact Fin.snoc_last _ _ + have h := realizeSimplex_natural (nerve Q) f (appendNerve Q x) (Convexity.StdSimplex.single 0) + rw [hf, Convexity.StdSimplex.map_single] at h + exact h.symm + +noncomputable def nerveTopConeMap : + nerve Q ⟶ TopCat.toSSet.obj (TopCat.of C(I, |nerve Q|)) where + app n := ↾fun x => (TopCat.toSSetObjEquiv _ n).symm (nerveTopConeSimplex Q x) + naturality {n m} f := by + apply ConcreteCategory.hom_ext + intro x + apply (TopCat.toSSetObjEquiv _ m).injective + ext z t + exact nerveTopConeSimplex_natural Q f.unop x z t + +noncomputable def nerveTopCone : C(|nerve Q|, C(I, |nerve Q|)) := + ((sSetTopAdj.homEquiv _ _).symm (nerveTopConeMap Q)).hom + +lemma nerveTopCone_zero : + (TopCat.ofHom (nerveTopCone Q)) ≫ pathEvaluate Q 0 = 𝟙 |nerve Q| := by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_naturality_right] + simp only [nerveTopCone, TopCat.ofHom_hom, Equiv.apply_symm_apply] + rw [Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + exact nerveTopConeSimplex_zero Q x z + +lemma nerveTopCone_one : + (TopCat.ofHom (nerveTopCone Q)) ≫ pathEvaluate Q 1 = TopCat.const (nerveTopPoint Q) := by + apply (sSetTopAdj.homEquiv _ _).injective + rw [Adjunction.homEquiv_naturality_right] + simp only [nerveTopCone, TopCat.ofHom_hom, Equiv.apply_symm_apply] + rw [Adjunction.homEquiv_unit] + ext n x + apply (TopCat.toSSetObjEquiv _ n).injective + ext z + exact nerveTopConeSimplex_one Q x z + +theorem nerve_orderTop_contractible : ContractibleSpace |nerve Q| := by + apply (contractible_iff_id_nullhomotopic _).mpr + refine ⟨nerveTopPoint Q, ⟨{ + toFun := fun p => nerveTopCone Q p.2 p.1 + continuous_toFun := ?_ + map_zero_left := ?_ + map_one_left := ?_ }⟩⟩ + · exact (nerveTopCone Q).uncurry.continuous.comp continuous_swap + · intro x + exact ConcreteCategory.congr_hom (nerveTopCone_zero Q) x + · intro x + exact ConcreteCategory.congr_hom (nerveTopCone_one Q) x + +end TopCone +end HarmonicArtin + +end TopologyDependencies + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedCellEmbedding.lean b/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedCellEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..81d8c4a27dc5734cc2deff0d6a107c61773788fa --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedCellEmbedding.lean @@ -0,0 +1,73 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.FullSphericalCell +import OAI.Topology.ArtinGroups.Harmonic.PuncturedBoundaryIso + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) +variable (T : Set S) (hT : IsSpherical M T) + +noncomputable def restrictedCellEmbedding (g : Artin M) : + LiftedCell (restrictedMatrix M T) ↪o LiftedCell M where + toFun a := liftedDeck M g (restrictedLiftedCell M T hT a).val + inj' := by + intro a b h + apply restrictedLiftedCell_injective M T hT + exact Subtype.ext ((liftedDeck M g).injective h) + map_rel_iff' := by + intro a b + change liftedDeck M g (restrictedLiftedCell M T hT a).val ≤ + liftedDeck M g (restrictedLiftedCell M T hT b).val ↔ a ≤ b + rw [(liftedDeck M g).le_iff_le,lifted_le_iff_face,lifted_le_iff_face] + exact restrictedLiftedCell_face_iff M T hT a b + +lemma restrictedCellEmbedding_full [Finite (restrictedMatrix M T).Group] (g : Artin M) : + restrictedCellEmbedding M T hT g (fullSphericalCell (restrictedMatrix M T)) = (g,⟨T,hT⟩) := by + apply Prod.ext + · change g * restrictedArtinHom M T 1 = g + rw [map_one,mul_one] + · apply Subtype.ext + change Subtype.val '' (Set.univ : Set T) = T + ext s + simp only [Set.mem_image,Set.mem_univ,true_and,Subtype.exists,exists_prop,exists_eq_right] + +lemma restrictedCellEmbedding_full_preimage [Finite (restrictedMatrix M T).Group] + (g : Artin M) (b : LiftedCell M) + (hb : b ≤ restrictedCellEmbedding M T hT g (fullSphericalCell (restrictedMatrix M T))) : + ∃ a, restrictedCellEmbedding M T hT g a = b := by + rw [restrictedCellEmbedding_full] at hb + obtain ⟨hst,w,hw,_,_,he⟩ := (lifted_le_iff_face M _ _).mp hb + have hp : g⁻¹*b.1 ∈ artinParabolic M T := by + rw [he,inv_mul_cancel_left] + exact wordArtin_mem_parabolic M T w hw + let v : SphericalLiftedFiber M T := ⟨liftedDeck M g⁻¹ b,hst,hp⟩ + refine ⟨(restrictedLiftedFiberIso M T hT).symm v,?_⟩ + change liftedDeck M g ((restrictedLiftedFiberIso M T hT) ((restrictedLiftedFiberIso M T hT).symm v)).val = b + rw [OrderIso.apply_symm_apply] + apply Prod.ext + · exact mul_inv_cancel_left g b.1 + · rfl + +lemma restrictedCellEmbedding_top (g : Artin M) (a : LiftedCell (restrictedMatrix M T)) : + liftedTopVertex M (restrictedCellEmbedding M T hT g a) = + g * restrictedArtinHom M T (liftedTopVertex (restrictedMatrix M T) a) := by + change (g * restrictedArtinHom M T a.1) * positiveLift M + (sphericalLongest M ⟨Subtype.val '' a.2.val, _⟩) = + g * restrictedArtinHom M T (a.1 * positiveLift (restrictedMatrix M T) (sphericalLongest (restrictedMatrix M T) a.2)) + rw [←restriction_sphericalLongest M T hT a.2,map_mul,restrictedArtinHom_positiveLift,mul_assoc] + +omit [LinearOrder S] in +lemma lifted_same_top_type_unique (a b : LiftedCell M) + (ht : a.2 = b.2) (hb : liftedTopVertex M a = liftedTopVertex M b) : a = b := by + apply Prod.ext ?_ ht + dsimp only [liftedTopVertex] at hb + rw [ht] at hb + exact mul_right_cancel hb + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedLiftedCell.lean b/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedLiftedCell.lean new file mode 100644 index 0000000000000000000000000000000000000000..22a52e05db91f3db5461f6833b0481b302f2f8ce --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedLiftedCell.lean @@ -0,0 +1,140 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.LiftedDeck +import OAI.Topology.ArtinGroups.Harmonic.RestrictedArtinHomSpherical +import OAI.Topology.ArtinGroups.Harmonic.TopBlockMatchingKey + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +omit [Fintype S] [LinearOrder S] in +lemma restriction_parabolic_map (T : Set S) (R : Set T) : + (coxeterParabolic (restrictedMatrix M T) R).map (restrictionHom M T) = + coxeterParabolic M (Subtype.val '' R) := by + rw [coxeterParabolic, MonoidHom.map_closure, Set.image_image] + congr 1 + ext x + simp only [Set.mem_image] + constructor + · rintro ⟨s, hs, rfl⟩ + exact ⟨(s:S), ⟨s,hs,rfl⟩, restrictionHom_simple M T s |>.symm⟩ + · rintro ⟨s, ⟨t,ht,rfl⟩, rfl⟩ + exact ⟨t,ht,restrictionHom_simple M T t⟩ + +omit [Fintype S] [LinearOrder S] in +lemma restriction_wordCoxeter (T : Set S) (w : List T) : + restrictionHom M T (wordCoxeter (restrictedMatrix M T) w) = + wordCoxeter M (w.map Subtype.val) := + restriction_wordProd M T w + +noncomputable def restrictedLiftedCell (T : Set S) (hT : IsSpherical M T) + (a : LiftedCell (restrictedMatrix M T)) : SphericalLiftedFiber M T := + ⟨(restrictedArtinHom M T a.1, ⟨Subtype.val '' a.2.val, + spherical_type_mono M (by rintro _ ⟨s,_,rfl⟩; exact s.property) hT⟩), + (by rintro _ ⟨s,_,rfl⟩; exact s.property), + (by rw [←restrictedArtinHom_range M T]; exact ⟨a.1,rfl⟩)⟩ + +lemma restrictedLiftedCell_injective (T : Set S) (hT : IsSpherical M T) : + Function.Injective (restrictedLiftedCell M T hT) := by + intro a b h + apply Prod.ext + · apply restrictedArtinHom_spherical_injective M T hT + exact congrArg (fun c : SphericalLiftedFiber M T => c.val.1) h + · apply Subtype.ext + have he : Subtype.val '' a.2.val = Subtype.val '' b.2.val := + congrArg (fun c : SphericalLiftedFiber M T => c.val.2.val) h + exact Set.image_injective.mpr Subtype.val_injective he + +omit [LinearOrder S] in +lemma restrictedLiftedCell_surjective (T : Set S) (hT : IsSpherical M T) : + Function.Surjective (restrictedLiftedCell M T hT) := by + intro a + have ha : a.val.1 ∈ (restrictedArtinHom M T).range := by + simpa only [restrictedArtinHom_range] using a.property.2 + obtain ⟨g,hg⟩ := ha + let R : Set T := Subtype.val ⁻¹' a.val.2.val + let : Finite (restrictedMatrix M T).Group := restricted_finite M T hT + have hR : IsSpherical (restrictedMatrix M T) R := + show Finite (coxeterParabolic (restrictedMatrix M T) R) from inferInstance + refine ⟨(g,⟨R,hR⟩),?_⟩ + apply Subtype.ext + apply Prod.ext hg + apply Subtype.ext + change Subtype.val '' R = a.val.2.val + ext s + constructor + · rintro ⟨t,ht,rfl⟩; exact ht + · intro hs + exact ⟨⟨s,a.property.1 hs⟩,hs,rfl⟩ + +lemma restrictedLiftedCell_face_iff (T : Set S) (hT : IsSpherical M T) + (a b : LiftedCell (restrictedMatrix M T)) : + LiftedFace M (restrictedLiftedCell M T hT a).val + (restrictedLiftedCell M T hT b).val ↔ LiftedFace (restrictedMatrix M T) a b := by + constructor + · rintro ⟨hAB,w,hw,hr,hm,he⟩ + have hwt : ∀ s ∈ w, s ∈ T := by + intro s hs + obtain ⟨t,_,ht⟩ := hw s hs + exact ht ▸ t.property + let v : List T := w.attach.map fun s => ⟨s.val,hwt s.val s.property⟩ + have hv : v.map Subtype.val = w := by + simp [v,List.map_map,Function.comp_def] + have hr' : (restrictedMatrix M T).toCoxeterSystem.length + (wordCoxeter (restrictedMatrix M T) v) = v.length := by + rw [←restriction_length M T, restriction_wordCoxeter, hv] + simpa [v] using hr + refine ⟨?_,v,?_,hr',?_,?_⟩ + · intro s hs + obtain ⟨t,ht,he⟩ := hAB ⟨s,hs,rfl⟩ + exact (Subtype.val_injective he) ▸ ht + · intro s hs + have hsw : (s:S) ∈ w := hv ▸ List.mem_map_of_mem hs + obtain ⟨t,ht,he⟩ := hw s hsw + exact (Subtype.val_injective he) ▸ ht + · intro q + have hq : restrictionHom M T q.val ∈ coxeterParabolic M (Subtype.val '' a.2.val) := by + rw [←restriction_parabolic_map M T a.2.val] + exact ⟨q.val,q.property,rfl⟩ + have hh := hm ⟨restrictionHom M T q.val,hq⟩ + rw [←hv,←restriction_wordCoxeter,←map_mul,restriction_length,restriction_length] at hh + exact hh + · apply restrictedArtinHom_spherical_injective M T hT + rw [map_mul,restrictedArtinHom_word,hv] + exact he + · rintro ⟨hAB,v,hv,hr,hm,he⟩ + refine ⟨Set.image_mono hAB,v.map Subtype.val,?_,?_,?_,?_⟩ + · intro s hs + obtain ⟨t,ht,rfl⟩ := List.mem_map.mp hs + exact ⟨t,hv t ht,rfl⟩ + · rw [←restriction_wordCoxeter,restriction_length,List.length_map] + exact hr + · intro q + have hq := q.property + change q.val ∈ coxeterParabolic M (Subtype.val '' a.2.val) at hq + rw [←restriction_parabolic_map M T a.2.val] at hq + obtain ⟨r,hrq,heq⟩ := hq + have hh := hm ⟨r,hrq⟩ + rw [←restriction_length M T,←restriction_length M T] at hh + rw [map_mul,restriction_wordCoxeter,heq] at hh + exact hh + · change restrictedArtinHom M T a.1 = restrictedArtinHom M T b.1 * _ + rw [he,map_mul,restrictedArtinHom_word] + +noncomputable def restrictedLiftedFiberIso (T : Set S) (hT : IsSpherical M T) : + LiftedCell (restrictedMatrix M T) ≃o SphericalLiftedFiber M T where + toEquiv := Equiv.ofBijective (restrictedLiftedCell M T hT) + ⟨restrictedLiftedCell_injective M T hT,restrictedLiftedCell_surjective M T hT⟩ + map_rel_iff' := by + intro a b + change (restrictedLiftedCell M T hT a).val ≤ (restrictedLiftedCell M T hT b).val ↔ a ≤ b + rw [lifted_le_iff_face,lifted_le_iff_face] + exact restrictedLiftedCell_face_iff M T hT a b + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedLiftedContractible.lean b/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedLiftedContractible.lean new file mode 100644 index 0000000000000000000000000000000000000000..849d4f68b3efb37945b136690e4ff42d3b29cab4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/RestrictedLiftedContractible.lean @@ -0,0 +1,42 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Harmonic.TypedRightCoset +import OAI.Topology.ArtinGroups.Harmonic.PositiveUpperBoundaryRank +import OAI.Topology.ArtinGroups.Realizations.DirectedCoverSequence +import OAI.Topology.ArtinGroups.Harmonic.PositiveRegionDeckIso + +namespace OAI + +namespace HarmonicArtin +open CoxeterExchange Geometric + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S : Type} [Fintype S] [LinearOrder S] (M : CoxeterMatrix S) + +theorem restricted_lifted_contractible (T : Set S) (hT : IsSpherical M T) : + ContractibleSpace (OrderWeights (LiftedCell (restrictedMatrix M T))) := by + let N := restrictedMatrix M T + let : Finite N.Group := restricted_finite M T hT + let : Countable (Artin N) := + Function.Surjective.countable (PresentedGroup.mk_surjective (braidRelators N)) + obtain ⟨z,hz⟩ := exists_longest N.toCoxeterSystem + let inj := spherical_positiveToArtin_injective M T hT + have hpos : ContractibleSpace (OrderWeights (PositiveRegion N 1)) := + (weightHomeomorph (positiveCellRegionIso N inj)).contractibleSpace_iff.mp + (positiveCellPoset_contractible N z hz inj) + apply orderWeights_contractible_of_countable_directed_cover (PositiveRegion N) + (spherical_positiveRegions_directed M T hT) (fun a => ⟨a.1,1,by simp⟩) + (positiveRegion_face_closed N) + (fun g => (weightHomeomorph (positiveRegionDeckIso N g)).contractibleSpace_iff.mp hpos) + (fun a => a.2.val.ncard) (Nat.card T) (lifted_rank_bound N) (lifted_rank_strict N) + +theorem sphericalLiftedFiber_contractible (T : Set S) (hT : IsSpherical M T) : + ContractibleSpace (OrderWeights (SphericalLiftedFiber M T)) := + (weightHomeomorph (restrictedLiftedFiberIso M T hT)).contractibleSpace_iff.mp + (restricted_lifted_contractible M T hT) + +theorem source_salvetti_cover_contractible : ContractibleSpace (SalvettiCover M) := + salvetti_cover_contractible_of_spherical_fibers M (sphericalLiftedFiber_contractible M) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/SalvettiCoverContractible.lean b/lean/OAI/Topology/ArtinGroups/Realizations/SalvettiCoverContractible.lean new file mode 100644 index 0000000000000000000000000000000000000000..36b349355bf6c14ccd05db19b27132e1422c93d6 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/SalvettiCoverContractible.lean @@ -0,0 +1,21 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.RestrictedLiftedContractible +import OAI.Topology.ArtinGroups.Harmonic.SphericalTypeReindex + +namespace OAI + +namespace HarmonicArtin +universe u +variable {S : Type u} + +theorem salvetti_cover_contractible [Finite S] (M : CoxeterMatrix S) : ContractibleSpace (SalvettiCover M) := by + let := Fintype.ofFinite S + let e := Fintype.equivFin S + have hc : ContractibleSpace (OrderWeights (LiftedCell (M.reindex e))) := + nerveWeightsHomeomorph.contractibleSpace_iff.mp (source_salvetti_cover_contractible (M.reindex e)) + exact nerveWeightsHomeomorph.contractibleSpace_iff.mpr + ((weightHomeomorph (liftedReindex M e)).contractibleSpace_iff.mpr hc) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/SalvettiProjection.lean b/lean/OAI/Topology/ArtinGroups/Realizations/SalvettiProjection.lean new file mode 100644 index 0000000000000000000000000000000000000000..5ca0ebc2d1a10a70aa3263207169a907bebdd3eb --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/SalvettiProjection.lean @@ -0,0 +1,43 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.CellUnion + +namespace OAI + +namespace HarmonicArtin +open Topology + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {S : Type u} [Fintype S] [DecidableEq S] (M : CoxeterMatrix S) + +noncomputable def sourceSalvettiProjection : SalvettiCover M → SourceSalvetti M := + sourceUniversalProjection M ∘ nerveWeightsHomeomorph + +theorem sourceSalvettiProjection_covering : IsCoveringMap (sourceSalvettiProjection M) := + (sourceUniversalProjection_quotientCovering M).isCoveringMap.comp_homeomorph + nerveWeightsHomeomorph + +theorem sourceSalvettiProjection_surjective : Function.Surjective (sourceSalvettiProjection M) := + (sourceUniversalProjection_quotientCovering M).surjective.comp + nerveWeightsHomeomorph.surjective + +theorem sourceSalvettiProjection_universal : + IsCoveringMap (sourceSalvettiProjection M) ∧ + Function.Surjective (sourceSalvettiProjection M) ∧ + SimplyConnectedSpace (SalvettiCover M) ∧ + ContractibleSpace (SalvettiCover M) := by + let := salvetti_cover_contractible M + exact ⟨sourceSalvettiProjection_covering M,sourceSalvettiProjection_surjective M, + inferInstance,salvetti_cover_contractible M⟩ + +noncomputable def sourceFundamentalGroupEquiv (x : SourceSalvetti M) : + FundamentalGroup (SourceSalvetti M) x ≃* Artin M := by + letI := liftedWeights_contractible M + let p := sourceUniversalProjection_quotientCovering M + let e : (sourceUniversalProjection M) ⁻¹' {x} := + ⟨(p.surjective x).choose,(p.surjective x).choose_spec⟩ + exact (p.fundamentalGroupEquiv e).trans (MulEquiv.inv' (Artin M)).symm + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightAffineValue.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightAffineValue.lean new file mode 100644 index 0000000000000000000000000000000000000000..9141d686a32a87820d8cb15126c39fe36a0566bf --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightAffineValue.lean @@ -0,0 +1,98 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.ReversibleQuiver +import OAI.Topology.ArtinGroups.Realizations.WeightInclusion + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {P E : Type*} [PartialOrder P] [AddCommGroup E] [Module ℝ E] + +noncomputable def weightAffineValue (z : P → E) (w : OrderWeights P) : E := + Finsupp.linearCombination ℝ z w.weights + +lemma weightAffineValue_sum (z : P → E) (w : OrderWeights P) : + weightAffineValue z w = ∑ p ∈ w.weights.support, w.weights p • z p := rfl + +lemma weightAffineValue_fintype [Fintype P] (z : P → E) (w : OrderWeights P) : + weightAffineValue z w = ∑ p, w.weights p • z p := + w.weights.sum_fintype _ (fun p => zero_smul ℝ (z p)) + +lemma OrderWeights.total_fintype [Fintype P] (w : OrderWeights P) : ∑ p,w.weights p = 1 := by + rw [←w.total] + exact (w.weights.sum_fintype (fun _ a => a) (fun _ => rfl)).symm + +lemma weightAffineValue_vertex (z : P → E) (p : P) : weightAffineValue z (weightVertex p) = z p := by + simp [weightAffineValue,weightVertex,Finsupp.linearCombination_single] + +lemma weightAffineValue_delete (z : P → E) (w : OrderWeights P) (p : P) (hp : w.weights p < 1) : + weightAffineValue z w = (1-w.weights p) • weightAffineValue z (weightDelete p w hp) + + w.weights p • z p := by + have hn : 1-w.weights p ≠ 0 := ne_of_gt (sub_pos.mpr hp) + change Finsupp.linearCombination ℝ z w.weights = + (1-w.weights p) • Finsupp.linearCombination ℝ z ((1-w.weights p)⁻¹ • w.weights.erase p) + _ + rw [map_smul,smul_smul,mul_inv_cancel₀ hn,one_smul] + rw [←Finsupp.linearCombination_single,←map_add,add_comm,Finsupp.single_add_erase] + +lemma weightAffineValue_continuous [Fintype P] [TopologicalSpace E] [IsTopologicalAddGroup E] + [ContinuousSMul ℝ E] (z : P → E) : Continuous (weightAffineValue z) := by + rw [show weightAffineValue z = fun w => ∑ p,w.weights p • z p from funext (weightAffineValue_fintype z)] + exact continuous_finsetSum _ (fun p _ => (weightEval_continuous p).smul continuous_const) + +lemma weightAffineValue_mem (z : P → E) (w : OrderWeights P) (K : Set E) + (hK : Convex ℝ K) (hz : ∀ p ∈ w.weights.support,z p ∈ K) : + weightAffineValue z w ∈ K := + hK.sum_mem (fun p _ => w.nonneg p) w.total hz + +lemma weightAffineValue_map [Fintype P] (z : P → E) (w : OrderWeights P) (f : E →ₗ[ℝ] ℝ) : + f (weightAffineValue z w) = ∑ p, w.weights p * f (z p) := by + rw [weightAffineValue_fintype,map_sum] + simp only [map_smul,smul_eq_mul] + +lemma weightAffineValue_le [Fintype P] (z : P → E) (w : OrderWeights P) (f : E →ₗ[ℝ] ℝ) + (b : ℝ) (hb : ∀ p,f (z p) ≤ b) : f (weightAffineValue z w) ≤ b := by + rw [weightAffineValue_map] + calc + ∑ p,w.weights p * f (z p) ≤ ∑ p,w.weights p * b := + Finset.sum_le_sum (fun p _ => mul_le_mul_of_nonneg_left (hb p) (w.nonneg p)) + _ = b := by rw [←Finset.sum_mul,w.total_fintype,one_mul] + +lemma weightAffineValue_eq_iff [Fintype P] (z : P → E) (w : OrderWeights P) (f : E →ₗ[ℝ] ℝ) + (b : ℝ) (hb : ∀ p,f (z p) ≤ b) : + f (weightAffineValue z w) = b ↔ ∀ p ∈ w.weights.support, f (z p) = b := by + rw [weightAffineValue_map] + have hsum : b = ∑ p,w.weights p * b := by rw [←Finset.sum_mul,w.total_fintype,one_mul] + conv_lhs => rhs; rw [hsum] + rw [Finset.sum_eq_sum_iff_of_le (fun p _ => mul_le_mul_of_nonneg_left (hb p) (w.nonneg p))] + constructor + · intro h p hp + exact mul_left_cancel₀ (Finsupp.mem_support_iff.mp hp) (h p (Finset.mem_univ _)) + · intro h p _ + by_cases hp : p ∈ w.weights.support + · rw [h p hp] + · simp only [Finsupp.notMem_support_iff.mp hp,zero_mul] + +noncomputable def weightMax (w : OrderWeights P) : P := weightChain w (Fin.last (weightDim w)) + +lemma weightMax_mem (w : OrderWeights P) : weightMax w ∈ w.weights.support := + (weightEnum w (Fin.last (weightDim w))).property + +lemma le_weightMax (w : OrderWeights P) (p : P) (hp : p ∈ w.weights.support) : p ≤ weightMax w := by + have he : weightChain w ((weightEnum w).symm ⟨p,hp⟩) = p := + congrArg Subtype.val ((weightEnum w).apply_symm_apply ⟨p,hp⟩) + rw [←he] + exact (weightChain w).monotone (Fin.le_last _) + +lemma weightAffineValue_cone {Q : Type*} [PartialOrder Q] (z : P → E) + (f : Q →o P) (c : P) (hc : ∀q,f q ≤ c ∨ c ≤ f q) (t : unitInterval) (w : OrderWeights Q) : + weightAffineValue z (coneWeights f c hc t w) = + (1-t.val) • weightAffineValue z (weightMap f w) + t.val • z c := by + change Finsupp.linearCombination ℝ z (_+_) = _ + rw [map_add,map_smul,Finsupp.linearCombination_single] + rfl + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightAttach.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightAttach.lean new file mode 100644 index 0000000000000000000000000000000000000000..e55c60dc33bb6a4e719c6ef5807fbacc84656eae --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightAttach.lean @@ -0,0 +1,120 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightLinearLinkInverse +import OAI.Topology.ArtinGroups.Harmonic.ConeAttachmentRel + +namespace OAI + +namespace HarmonicArtin +open scoped unitInterval + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] (v:P) + +noncomputable def weightAttach : C(ConeAttachment (weightLinkMap v),OrderWeights P) where + toFun:=Quot.lift (Sum.elim (weightOldMap v) (weightConeMap v)) (by + intro a b h + cases h with + | base x => exact weightConeMap_zero v x + | apex x y => exact (weightConeMap_one v x).trans (weightConeMap_one v y).symm) + continuous_toFun:=continuous_quot_lift _ (continuous_sum_dom.mpr ⟨(weightOldMap v).continuous,(weightConeMap v).continuous⟩) + +lemma weightAttach_old (w:OrderWeights (WeightOld v)) : + weightAttach v (coneAttachmentOld (weightLinkMap v) w)=weightOldMap v w :=rfl +lemma weightAttach_cone (p:I×OrderWeights (WeightLink v)) : + weightAttach v (coneAttachmentCone (weightLinkMap v) p)=weightConeMap v p :=rfl + +lemma weightAttach_surjective (c:OrderWeights (WeightLink v)) : Function.Surjective (weightAttach v) := by + intro w + obtain ⟨p,hp⟩:=weightParts_surjective v c w + exact ⟨Quot.mk _ p,hp⟩ + +lemma weightAttach_injective : Function.Injective (weightAttach v) := by + intro a b + induction a using Quot.inductionOn with + | h a => + induction b using Quot.inductionOn with + | h b => + cases a with + | inl a => + cases b with + | inl b => + intro h + have hab:a=b:=weightMap_injective (weightOldIncl v) Subtype.val_injective h + subst b;rfl + | inr b => + intro h + have ht:b.1=0:=Subtype.ext (by + have he:=congrArg (fun w:OrderWeights P=>w.weights v) h + change (weightOldMap v a).weights v=(weightConeMap v b).weights v at he + rw [weightOldMap_at,weightConeMap_at] at he + exact he.symm) + obtain ⟨t,b⟩:=b + dsimp only at ht + subst t + change weightOldMap v a=weightConeMap v (0,b) at h + rw [weightConeMap_zero] at h + have ha:a=weightLinkMap v b:=weightMap_injective (weightOldIncl v) Subtype.val_injective h + subst a + exact (coneAttachment_base (weightLinkMap v) b).symm + | inr a => + cases b with + | inl b => + intro h + have ht:a.1=0:=Subtype.ext (by + have he:=congrArg (fun w:OrderWeights P=>w.weights v) h + change (weightConeMap v a).weights v=(weightOldMap v b).weights v at he + rw [weightOldMap_at,weightConeMap_at] at he + exact he) + obtain ⟨t,a⟩:=a + dsimp only at ht + subst t + change weightConeMap v (0,a)=weightOldMap v b at h + rw [weightConeMap_zero] at h + have hb:weightLinkMap v a=b:=weightMap_injective (weightOldIncl v) Subtype.val_injective h + subst b + exact coneAttachment_base (weightLinkMap v) a + | inr b => + intro h + obtain ⟨t,a⟩:=a + obtain ⟨s,b⟩:=b + obtain ⟨he,hh⟩:=weightConeMap_eq_cone h + subst s + rcases hh with ht|hab + · subst t + exact coneAttachment_apex (weightLinkMap v) a b + · subst b;rfl + +noncomputable def weightAttachEquiv (c:OrderWeights (WeightLink v)) : + ConeAttachment (weightLinkMap v) ≃ OrderWeights P := + Equiv.ofBijective (weightAttach v) ⟨weightAttach_injective v,weightAttach_surjective v c⟩ + +lemma weightAttachEquiv_symm_old (c:OrderWeights (WeightLink v)) (w:OrderWeights (WeightOld v)) : + (weightAttachEquiv v c).symm (weightOldMap v w)=coneAttachmentOld (weightLinkMap v) w := by + apply (weightAttachEquiv v c).symm_apply_eq.mpr + rfl + +lemma weightAttachEquiv_symm_cone (c:OrderWeights (WeightLink v)) (p:I×OrderWeights (WeightLink v)) : + (weightAttachEquiv v c).symm (weightConeMap v p)=coneAttachmentCone (weightLinkMap v) p := by + apply (weightAttachEquiv v c).symm_apply_eq.mpr + rfl + +noncomputable def weightAttachHomeomorph (c:OrderWeights (WeightLink v)) : + ConeAttachment (weightLinkMap v) ≃ₜ OrderWeights P where + toEquiv:=weightAttachEquiv v c + continuous_toFun:=(weightAttach v).continuous + continuous_invFun:=by + change Continuous (weightAttachEquiv v c).symm + apply continuous_of_weightParts v + · have he:(weightAttachEquiv v c).symm ∘ weightOldMap v=coneAttachmentOld (weightLinkMap v):=by + funext w;exact weightAttachEquiv_symm_old v c w + rw [he] + exact (coneAttachmentOld (weightLinkMap v)).continuous + · have he:(weightAttachEquiv v c).symm ∘ weightConeMap v=coneAttachmentCone (weightLinkMap v):=by + funext w;exact weightAttachEquiv_symm_cone v c w + rw [he] + exact (coneAttachmentCone (weightLinkMap v)).continuous + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightCarrier.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightCarrier.lean new file mode 100644 index 0000000000000000000000000000000000000000..4bb9eb45399b783534f85abb6780f8a7b84021a4 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightCarrier.lean @@ -0,0 +1,115 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.OrderWeights + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators +open Simplicial CategoryTheory Opposite Convexity + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +lemma weightEval_continuous (p:P) : Continuous (fun w:OrderWeights P=>w.weights p) := by + rw [orderWeights_continuous_iff] + intro n x + change Continuous (fun z:StdSimplex ℝ (Fin (n.len+1))=>chainWeights (nerveChain x) z p) + simp_rw [chainWeights_apply] + apply continuous_finsetSum + intro i _ + by_cases h:nerveChain x i=p + · simp only [h,ite_eq_left] + exact StdSimplex.continuous_weights_apply ℝ i + · simp only [h] + exact continuous_const + +noncomputable instance : T2Space (OrderWeights P) := + T2Space.of_injective_continuous + (f:=fun w:OrderWeights P=>fun p=>w.weights p) + (by intro x y h;apply OrderWeights.ext;exact DFunLike.ext' h) + (continuous_pi weightEval_continuous) + +lemma isClosed_prod_discrete_left {X Y:Type*} [TopologicalSpace X] [DiscreteTopology X] + [TopologicalSpace Y] {A:Set (X×Y)} (h:∀x,IsClosed {y | (x,y)∈A}) : IsClosed A := by + have he:Aᶜ=⋃x:X,({x}:Set X) ×ˢ {y | (x,y)∉A}:=by + ext ⟨x,y⟩ + simp + rw [← isOpen_compl_iff,he] + exact isOpen_iUnion (fun x=>(isOpen_discrete _).prod (h x).isOpen_compl) + +lemma orderWeights_isClosed_iff (A:Set (OrderWeights P)) : + IsClosed A ↔ ∀(n:SimplexCategory) (x:(nerve P).obj (op n)), + IsClosed ((fun z:StdSimplex ℝ (Fin (n.len+1))=>orderWeightsOfChain (nerveChain x) z) ⁻¹' A) := by + let (n:SimplexCategory):TopologicalSpace ((nerve P).obj (op n)):=⊥ + let (n:SimplexCategory):DiscreteTopology ((nerve P).obj (op n)):=⟨rfl⟩ + change @IsClosed _ (TopologicalSpace.coinduced orderWeightsChart inferInstance) A ↔ _ + rw [isClosed_coinduced,isClosed_sigma_iff] + constructor + · intro h n x + exact (h n).preimage (continuous_const.prodMk continuous_id) + · intro h n + exact isClosed_prod_discrete_left (h n) + +def weightCarrier (K:Set (OrderWeights P)) : Set P := + {p | ∃w∈K,p∈w.weights.support} + +lemma weightCarrier_finite_of_finite {K:Set (OrderWeights P)} (hK:K.Finite) : + (weightCarrier K).Finite := by + have he:weightCarrier K=⋃w∈K,(↑w.weights.support:Set P):=by ext p;simp [weightCarrier] + rw [he] + exact hK.biUnion (fun w _=>w.weights.support.finite_toSet) + +theorem weightCarrier_finite_of_isCompact {K:Set (OrderWeights P)} (hK:IsCompact K) : + (weightCarrier K).Finite := by + by_contra hn + let U:=weightCarrier K + have hi:U.Infinite:=hn + choose f hf using (fun p:U=>p.property) + let E:Set (OrderWeights P):=Set.range f + have hEK:E⊆K:=by rintro w ⟨p,rfl⟩;exact (hf p).1 + have hEf:∀(n:SimplexCategory) (x:(nerve P).obj (op n)), + (E∩Set.range (fun z:StdSimplex ℝ (Fin (n.len+1))=>orderWeightsOfChain (nerveChain x) z)).Finite:=by + intro n x + let B:Finset P:=Finset.univ.image (nerveChain x) + have hB:(Subtype.val ⁻¹' (↑B : Set P) : Set U).Finite:= + B.finite_toSet.preimage Subtype.val_injective.injOn + apply (hB.image f).subset + rintro w ⟨⟨p,rfl⟩,⟨z,hz⟩⟩ + refine ⟨p,?_,rfl⟩ + have hp:p.val∈(chainWeights (nerveChain x) z).support:=by + change p.val∈(orderWeightsOfChain (nerveChain x) z).weights.support + have he : orderWeightsOfChain (nerveChain x) z = f p := hz + rw [he] + exact (hf p).2 + exact chainWeights_support _ _ hp + have hclosed:∀A:Set (OrderWeights P),A⊆E→IsClosed A:=by + intro A hAE + rw [orderWeights_isClosed_iff] + intro n x + let g:=fun z:StdSimplex ℝ (Fin (n.len+1))=>orderWeightsOfChain (nerveChain x) z + have hfin:(A∩Set.range g).Finite:=(hEf n x).subset (fun _ h=>⟨hAE h.1,h.2⟩) + have he:g⁻¹'A=g⁻¹'(A∩Set.range g):=by ext z;simp + rw [he] + exact hfin.isClosed.preimage (orderWeightsChart_continuous x) + have hEc:IsCompact E:=hK.of_isClosed_subset (hclosed E (fun _ h=>h)) hEK + have hdis:DiscreteTopology E:=by + rw [discreteTopology_iff_forall_isClosed] + intro A + have ha:IsClosed (Subtype.val '' A):=hclosed _ (by rintro w ⟨p,_,rfl⟩;exact p.property) + have he:A=Subtype.val ⁻¹' (Subtype.val '' A):=by + exact (Set.preimage_image_eq A Subtype.val_injective).symm + rw [he] + exact ha.preimage continuous_subtype_val + have :DiscreteTopology E:=hdis + have :CompactSpace E:=isCompact_iff_compactSpace.mp hEc + have :Finite E:=finite_of_compact_of_discrete + have hE:E.Finite:=Set.toFinite E + apply hi + apply (weightCarrier_finite_of_finite hE).subset + intro p hp + exact ⟨f ⟨p,hp⟩,⟨⟨p,hp⟩,rfl⟩,(hf ⟨p,hp⟩).2⟩ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightChainCover.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightChainCover.lean new file mode 100644 index 0000000000000000000000000000000000000000..0bbc13cf8c43bfefbaa456f213f7e282c8a90b4d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightChainCover.lean @@ -0,0 +1,75 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightInclusion + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators unitInterval +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u v w z +variable {P:Type u} [PartialOrder P] {J:Type v} (A:J→Set P) + {Z:Type w} [TopologicalSpace Z] [LocallyCompactSpace Z] + {Y:Type z} [TopologicalSpace Y] + +def WeightChainCover : Prop := + ∀(n:ℕ) (a:Fin (n+1)→oP),∃i:J,∀q,a q∈A i + +lemma weightChainCover_rep (hA:WeightChainCover A) (w:OrderWeights P) : + ∃i:J,∃z:OrderWeights (A i),weightMap (weightInclusion (A i)) z=w := by + obtain ⟨i,hi⟩:=hA (weightDim w) (weightChain w) + have hs:∀p∈w.weights.support,p∈A i:=by + intro p hp + let q:Fin (weightDim w+1):=(weightEnum w).symm ⟨p,hp⟩ + have he:weightChain w q=p:=congrArg Subtype.val ((weightEnum w).apply_symm_apply ⟨p,hp⟩) + exact he ▸ hi q + exact ⟨i,weightRestrict (A i) w hs,weightRestrict_map _ w hs⟩ + +noncomputable def weightGlueIndex (hA:WeightChainCover A) (w:OrderWeights P) : J := + (weightChainCover_rep A hA w).choose +noncomputable def weightGlueRep (hA:WeightChainCover A) (w:OrderWeights P) : OrderWeights (A (weightGlueIndex A hA w)) := + (weightChainCover_rep A hA w).choose_spec.choose +lemma weightGlueRep_map (hA:WeightChainCover A) (w:OrderWeights P) : + weightMap (weightInclusion _) (weightGlueRep A hA w)=w := + (weightChainCover_rep A hA w).choose_spec.choose_spec + +variable (F:∀i:J,C(Z×OrderWeights (A i),Y)) + +def WeightCompatible : Prop := + ∀(i j:J) (wi:OrderWeights (A i)) (wj:OrderWeights (A j)), + weightMap (weightInclusion (A i)) wi=weightMap (weightInclusion (A j)) wj → + ∀t:Z,F i (t,wi)=F j (t,wj) + +noncomputable def weightGlueValue (hA:WeightChainCover A) (p:Z×OrderWeights P) : Y := + F (weightGlueIndex A hA p.2) (p.1,weightGlueRep A hA p.2) + +omit [LocallyCompactSpace Z] in +lemma weightGlueValue_on (hA:WeightChainCover A) (hF:WeightCompatible A F) + (i:J) (p:Z×OrderWeights (A i)) : + weightGlueValue A F hA (p.1,weightMap (weightInclusion (A i)) p.2)=F i p := by + exact hF _ _ _ _ (weightGlueRep_map A hA _) _ + +lemma weightGlueValue_continuous (hA:WeightChainCover A) (hF:WeightCompatible A F) : + Continuous (weightGlueValue A F hA) := by + apply orderWeights_prod_continuous + intro n x + obtain ⟨i,hi⟩:=hA n.len (nerveChain x) + let a:Fin (n.len+1)→o A i:=⟨fun q=>⟨nerveChain x q,hi q⟩,fun _ _ h=>(nerveChain x).monotone h⟩ + have he (z:Convexity.StdSimplex ℝ (Fin (n.len+1))) : + weightMap (weightInclusion (A i)) (orderWeightsOfChain a z)=orderWeightsOfChain (nerveChain x) z := by + rw [weightMap_chain] + rfl + have hc:Continuous (fun p:Z×Convexity.StdSimplex ℝ (Fin (n.len+1))=>F i (p.1,orderWeightsOfChain a p.2)):= + (F i).continuous.comp (continuous_fst.prodMk ((chainWeightsChart_continuous a).comp continuous_snd)) + apply hc.congr + intro p + rw [←he] + exact (weightGlueValue_on A F hA hF i (p.1,orderWeightsOfChain a p.2)).symm + +noncomputable def weightGlue (hA:WeightChainCover A) (hF:WeightCompatible A F) : C(Z×OrderWeights P,Y) := + ⟨weightGlueValue A F hA,weightGlueValue_continuous A F hA hF⟩ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightColor.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightColor.lean new file mode 100644 index 0000000000000000000000000000000000000000..bd29387f2b4024d1e0fd5a629ab80022ba4b0e6c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightColor.lean @@ -0,0 +1,121 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.OrderWeightsContractibleUnique + +namespace OAI + +namespace HarmonicArtin +open CategoryTheory + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u v +variable {P:Type u} [PartialOrder P] + +noncomputable def weightColor {A:Type v} (f:P→A) (w:OrderWeights P) : A := + f (Classical.choose w.support_nonempty) + +lemma weightColor_eq {A:Type v} (f:P→A) (hf:∀x y,x≤y → f x=f y) + (w:OrderWeights P) (p:P) (hp:p∈w.weights.support) : weightColor f w=f p := by + rcases w.chain (Classical.choose w.support_nonempty) (Classical.choose_spec w.support_nonempty) p hp with h|h + · exact hf _ _ h + · exact (hf _ _ h).symm + +lemma weightColor_continuous {A:Type v} [TopologicalSpace A] (f:P→A) + (hf:∀x y,x≤y → f x=f y) : Continuous (weightColor f) := by + rw [orderWeights_continuous_iff] + intro n x + have he: (fun z=>weightColor f (orderWeightsOfChain (nerveChain x) z))= + (fun _ : Convexity.StdSimplex ℝ (Fin (n.len+1))=>f (nerveChain x 0)) := by + funext z + let w:=orderWeightsOfChain (nerveChain x) z + have hp:Classical.choose w.support_nonempty∈(chainWeights (nerveChain x) z).support:=Classical.choose_spec w.support_nonempty + obtain ⟨j,_,hj⟩:=Finset.mem_image.mp (chainWeights_support (nerveChain x) z hp) + change f (Classical.choose w.support_nonempty)=_ + rw [←hj] + exact (hf _ _ ((nerveChain x).monotone (Fin.zero_le j))).symm + rw [he] + exact continuous_const + +lemma weightColor_vertex {A:Type v} (f:P→A) (hf:∀x y,x≤y → f x=f y) (p:P) : + weightColor f (weightVertex p)=f p := by + apply weightColor_eq f hf + simp [weightVertex] + +lemma orderWeights_colors_eq {A:Type v} (h:ContractibleSpace (OrderWeights P)) + (f:P→A) (hf:∀x y,x≤y → f x=f y) (x y:P) : f x=f y := by + let _ := h + let : TopologicalSpace A := ⊥ + let : DiscreteTopology A := ⟨rfl⟩ + have he:=PreconnectedSpace.constant (inferInstance:PreconnectedSpace (OrderWeights P)) + (weightColor_continuous f hf) (x:=weightVertex x) (y:=weightVertex y) + simpa only [weightColor_vertex f hf] using he + +variable (r:P→P→Prop) (wf:WellFounded r) + +noncomputable def weightSource : P→P := + wf.fix (fun v f=>if h:Nonempty (WeightEarlierLink r v) then + f (Classical.choice h).val (Classical.choice h).property.1 else v) + +lemma weightSource_eq (v:P) : weightSource r wf v= + if h:Nonempty (WeightEarlierLink r v) then + weightSource r wf (Classical.choice h).val else v := by + rw [weightSource,WellFounded.fix_eq] + +lemma weightSource_of_empty (v:P) (h:¬Nonempty (WeightEarlierLink r v)) : + weightSource r wf v=v := by rw [weightSource_eq,dite_eq_right h] + +lemma weightSource_near (htotal:∀x y,x≠y → r x y ∨ r y x) + (hl:∀v,Nonempty (WeightEarlierLink r v) → + ContractibleSpace (OrderWeights (WeightEarlierLink r v))) : + ∀v x,r x v → (x≤v ∨ v≤x) → weightSource r wf x=weightSource r wf v := by + intro v + induction v using wf.induction with + | h v ih => + intro x hx hcomp + have hn:Nonempty (WeightEarlierLink r v):=⟨⟨x,hx,hcomp⟩⟩ + have hcolor:∀a b:WeightEarlierLink r v,a≤b → + weightSource r wf a.val=weightSource r wf b.val:=by + intro a b hab + by_cases he:a.val=b.val + · rw [he] + · rcases htotal a b he with h|h + · exact ih b b.property.1 a h (Or.inl hab) + · exact (ih a a.property.1 b h (Or.inr hab)).symm + rw [weightSource_eq r wf v,dite_eq_left hn] + exact orderWeights_colors_eq (hl v hn) (fun a=>weightSource r wf a.val) hcolor + ⟨x,hx,hcomp⟩ (Classical.choice hn) + +lemma weightSource_comparable (htotal:∀x y,x≠y → r x y ∨ r y x) + (hl:∀v,Nonempty (WeightEarlierLink r v) → + ContractibleSpace (OrderWeights (WeightEarlierLink r v))) + (x y:P) (h:x≤y) : weightSource r wf x=weightSource r wf y := by + by_cases he:x=y + · rw [he] + · rcases htotal x y he with he|he + · exact weightSource_near r wf htotal hl y x he (Or.inl h) + · exact (weightSource_near r wf htotal hl x y he (Or.inr h)).symm + +include wf in + +theorem orderWeights_contractible_connected [CategoryTheory.IsConnected P] + (htotal:∀x y,x≠y → r x y ∨ r y x) + (k:P→ℕ) (N:ℕ) (hk:∀x,k x≤N) (hmono:StrictMono k) + (hl:∀v,Nonempty (WeightEarlierLower r v) → + ContractibleSpace (OrderWeights (WeightEarlierLower r v))) + (hu:∀v,Nonempty (WeightEarlierUpper r v) → + ContractibleSpace (OrderWeights (WeightEarlierUpper r v))) : + ContractibleSpace (OrderWeights P) := by + have hlink:∀v,Nonempty (WeightEarlierLink r v) → + ContractibleSpace (OrderWeights (WeightEarlierLink r v)):=by + intro v hv + rcases weightLink_nonempty_parts r (fun x=>wf.irrefl.irrefl x) v hv with h|h + · exact weightLink_contractible_of_lower r (fun x=>wf.irrefl.irrefl x) v k N hk hmono (hl v h) + · exact weightLink_contractible_of_upper r (fun x=>wf.irrefl.irrefl x) v k N hk hmono (hu v h) + apply orderWeights_contractible_unique_source r wf htotal k N hk hmono hl hu ?_ inferInstance + intro x y hx hy + have he:=CategoryTheory.constant_of_preserves_morphisms (weightSource r wf) + (fun a b hab=>weightSource_comparable r wf htotal hlink a b (leOfHom hab)) x y + simpa only [weightSource_of_empty r wf x hx,weightSource_of_empty r wf y hy] using he + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightDim.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightDim.lean new file mode 100644 index 0000000000000000000000000000000000000000..640084cad7fd84a2926dbfb91bcfb1af05f8e6c2 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightDim.lean @@ -0,0 +1,85 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.OrderWeights + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators +open Simplicial CategoryTheory Opposite Convexity + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +noncomputable instance orderWeightSupportLinearOrder (w:OrderWeights P) : + LinearOrder {p // p∈w.weights.support} := + IsChain.linearOrder (show IsChain (·<·) (↑w.weights.support:Set P) from + fun left hleft right hright hne => (w.chain left hleft right hright).imp + (fun hle => lt_of_le_of_ne hle hne) (fun hle => lt_of_le_of_ne hle hne.symm)) + +noncomputable def weightDim (w:OrderWeights P) : ℕ := w.weights.support.card-1 + +lemma weightDim_succ (w:OrderWeights P) : weightDim w+1=w.weights.support.card := by + have :=w.support_nonempty.card_pos + unfold weightDim + omega + +noncomputable def weightEnum (w:OrderWeights P) : + Fin (weightDim w+1) ≃o {p // p∈w.weights.support} := + Fintype.orderIsoFinOfCardEq _ (by rw [Fintype.card_coe,weightDim_succ]) + +noncomputable def weightChain (w:OrderWeights P) : Fin (weightDim w+1) →o P where + toFun:=fun i=>(weightEnum w i).val + monotone':=fun _ _ h=>(weightEnum w).monotone h + +lemma weightChain_injective (w:OrderWeights P) : Function.Injective (weightChain w) := + Subtype.val_injective.comp (weightEnum w).injective + +noncomputable def weightSimplex (w:OrderWeights P) : StdSimplex ℝ (Fin (weightDim w+1)) := + ⟨Finsupp.equivFunOnFinite.symm (fun coordinate=>w.weights (weightChain w coordinate)), + fun coordinate=>w.nonneg _,by + have he:=Equiv.sum_comp (weightEnum w).toEquiv (fun p=>w.weights p.val) + rw [Finsupp.sum_fintype _ _ (by simp)] + change (∑i,w.weights (weightChain w i))=1 + rw [show (∑i,w.weights (weightChain w i))=∑p:w.weights.support,w.weights p.val from he] + rw [Finset.sum_coe_sort] + exact w.total⟩ + +lemma chainWeights_injective_apply {n:ℕ} (x:Fin (n+1)→o P) + (hx:Function.Injective x) (z:StdSimplex ℝ (Fin (n+1))) (i:Fin (n+1)) : + chainWeights x z (x i)=z.weights i := by + rw [chainWeights_apply,Finset.sum_eq_single i] + · simp + · intro j _ hj + simp [hx.ne hj] + · simp + +lemma orderWeightsOfChain_canonical (w:OrderWeights P) : + orderWeightsOfChain (weightChain w) (weightSimplex w)=w := by + apply OrderWeights.ext + ext p + by_cases hp:p∈w.weights.support + · obtain ⟨i,hi⟩:∃i,weightChain w i=p:=by + exact ⟨(weightEnum w).symm ⟨p,hp⟩,congrArg Subtype.val ((weightEnum w).apply_symm_apply _)⟩ + rw [← hi] + exact chainWeights_injective_apply _ (weightChain_injective w) _ i + · change chainWeights _ _ p=w.weights p + rw [Finsupp.notMem_support_iff.mp hp,chainWeights_apply] + apply Finset.sum_eq_zero + intro i _ + have hn:weightChain w i≠p:=by + intro he + exact hp (he ▸ (weightEnum w i).property) + simp [hn] + +lemma chainWeights_coordinates_injective {n:ℕ} (x:Fin (n+1)→o P) + (hx:Function.Injective x) {z z':StdSimplex ℝ (Fin (n+1))} + (h:chainWeights x z=chainWeights x z') : z=z' := by + apply StdSimplex.ext + ext coordinate + have he:=congrArg (fun weights:P→₀ℝ=>weights (x coordinate)) h + simpa only [chainWeights_injective_apply x hx] using he + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightDual.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightDual.lean new file mode 100644 index 0000000000000000000000000000000000000000..75fb9499fcec0ddbcb6f7a5d27c847f542e13070 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightDual.lean @@ -0,0 +1,49 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightCarrier +import OAI.Topology.ArtinGroups.Harmonic.FiniteChainEnum + +namespace OAI + +namespace HarmonicArtin +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +noncomputable def weightDual (w:OrderWeights P) : OrderWeights Pᵒᵈ where + weights:=w.weights + nonneg:=w.nonneg + total:=w.total + chain:=by + intro a ha b hb + exact (w.chain a ha b hb).symm + +lemma weightDual_continuous : Continuous (weightDual (P:=P)) := by + rw [orderWeights_continuous_iff] + intro n x + let c:=nerveChain x + let C:Finset Pᵒᵈ:=Finset.univ.image c + have hc:IsChain (·≤·) (↑C:Set Pᵒᵈ):=by + rintro a ha b hb hn + obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp ha + obtain ⟨j,_,rfl⟩:=Finset.mem_image.mp hb + exact (le_total i j).symm.imp (fun h=>c.monotone h) (fun h=>c.monotone h) + have hne:C.Nonempty:=Finset.Nonempty.image Finset.univ_nonempty _ + apply continuous_of_finite_chain_carrier _ C hc hne + · intro z + exact chainWeights_support c z + · intro p + exact (weightEval_continuous (P:=P) p).comp (chainWeightsChart_continuous c) + +noncomputable def weightDualHomeomorph : OrderWeights P≃ₜOrderWeights Pᵒᵈ where + toFun:=weightDual + invFun:=weightDual + left_inv _:=rfl + right_inv _:=rfl + continuous_toFun:=weightDual_continuous + continuous_invFun:=weightDual_continuous + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightEarlierLower.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightEarlierLower.lean new file mode 100644 index 0000000000000000000000000000000000000000..a239be2a8921b500ba8a9a9bb40fa284d206e2f3 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightEarlierLower.lean @@ -0,0 +1,99 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightJoinKey +import OAI.Topology.ArtinGroups.Realizations.WeightDual + +namespace OAI + +namespace HarmonicArtin +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +abbrev WeightEarlierLower (r:P→P→Prop) (v:P) := {x:P // r x v ∧ xN-k x.val) + (fun x _=>by omega) ?_ (weightLink_lower_cross r hirr v) hA + intro x y hx hy hxy + have hlt:k x.valk x.val) + (fun x _=>Nat.lt_succ_of_le (hk x.val)) + (by intro x y _ _ hxy;exact hmono hxy) (weightLink_lower_cross r hirr v) hB + +lemma weightLink_nonempty_parts (r:P→P→Prop) (hirr:∀x,¬r x x) (v:P) + (h:Nonempty (WeightEarlierLink r v)) : + Nonempty (WeightEarlierLower r v) ∨ Nonempty (WeightEarlierUpper r v) := by + obtain ⟨x,hx,hcmp⟩:=h + have hne:x≠v:=by intro he;exact hirr v (he ▸ hx) + exact hcmp.elim (fun h=>Or.inl ⟨x,hx,lt_of_le_of_ne h hne⟩) + (fun h=>Or.inr ⟨x,hx,lt_of_le_of_ne h hne.symm⟩) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightHomeomorph.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightHomeomorph.lean new file mode 100644 index 0000000000000000000000000000000000000000..70f7c1bf4b79504be814c07478b2796fb108629c --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightHomeomorph.lean @@ -0,0 +1,95 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightInclusion + +namespace OAI + +namespace HarmonicArtin +open scoped unitInterval + +universe u v +variable {P:Type u} {Q:Type v} [PartialOrder P] [PartialOrder Q] + +noncomputable def weightHomeomorph (e:P≃oQ) : OrderWeights P≃ₜOrderWeights Q where + toFun:=weightMap (e : P→oQ) + invFun:=weightMap (e.symm : Q→oP) + left_inv w:=by + rw [weightMap_comp] + have he:(e.symm : Q→oP).comp (e : P→oQ)=OrderHom.id:=by ext p;exact e.symm_apply_apply p + rw [he,weightMap_id] + right_inv w:=by + rw [weightMap_comp] + have he:(e : P→oQ).comp (e.symm : Q→oP)=OrderHom.id:=by ext p;exact e.apply_symm_apply p + rw [he,weightMap_id] + continuous_toFun:=weightMap_continuous _ + continuous_invFun:=weightMap_continuous _ + +lemma weightMap_vertex (f:P→oQ) (p:P) : weightMap f (weightVertex p)=weightVertex (f p) := by + apply OrderWeights.ext + exact Finsupp.mapDomain_single + +noncomputable def weightSubset (A B:Set P) (h:A⊆B) : A→oB := + ⟨fun p=>⟨p.val,h p.property⟩,fun _ _ he=>he⟩ + +lemma weightSubset_comp (A B C:Set P) (h:A⊆B) (k:B⊆C) : + (weightSubset B C k).comp (weightSubset A B h)=weightSubset A C (h.trans k) :=rfl +lemma weightSubset_incl (A B:Set P) (h:A⊆B) : + (weightInclusion B).comp (weightSubset A B h)=weightInclusion A :=rfl + +lemma weightSubset_self (A:Set P) (h:A⊆A) : weightSubset A A h=OrderHom.id :=by ext p;rfl + +noncomputable def transportContraction {X Y:Type*} [TopologicalSpace X] [TopologicalSpace Y] + (e:X≃ₜY) (c:X) (H:ContinuousMap.Homotopy (ContinuousMap.id X) (ContinuousMap.const X c)) : + ContinuousMap.Homotopy (ContinuousMap.id Y) (ContinuousMap.const Y (e c)) where + toFun p:=e (H (p.1,e.symm p.2)) + continuous_toFun:=e.continuous.comp (H.continuous.comp + (continuous_fst.prodMk (e.symm.continuous.comp continuous_snd))) + map_zero_left x:=by rw [H.apply_zero];exact e.apply_symm_apply x + map_one_left x:=by rw [H.apply_one];rfl + +variable (r:P→P→Prop) (c:P) + +structure WeightContractionPiece where + carrier:Set P + root_mem:c∈carrier + down:∀{x y},x∈carrier → r y x → y∈carrier + hom:ContinuousMap.Homotopy (ContinuousMap.id (OrderWeights carrier)) + (ContinuousMap.const _ (weightVertex ⟨c,root_mem⟩)) + +namespace WeightContractionPiece +variable {r c} +noncomputable def inclusion (a:WeightContractionPiece r c) :=weightInclusion a.carrier + +def Extends (a b:WeightContractionPiece r c) : Prop := + ∃h:a.carrier⊆b.carrier,∀t:I,∀w:OrderWeights a.carrier, + weightMap a.inclusion (a.hom (t,w))= + weightMap b.inclusion (b.hom (t,weightMap (weightSubset _ _ h) w)) + +lemma extends_refl (a:WeightContractionPiece r c) : a.Extends a := by + refine ⟨Set.Subset.rfl,?_⟩ + intro t w + rw [weightSubset_self,weightMap_id] + +lemma extends_trans {a b d:WeightContractionPiece r c} (h:a.Extends b) (k:b.Extends d) : a.Extends d := by + obtain ⟨h,hh⟩:=h + obtain ⟨k,hk⟩:=k + refine ⟨h.trans k,?_⟩ + intro t w + rw [hh,hk,weightMap_comp] + rfl + +lemma extends_compare {a b:WeightContractionPiece r c} (h:a.Extends b) + (w:OrderWeights a.carrier) (z:OrderWeights b.carrier) + (he:weightMap a.inclusion w=weightMap b.inclusion z) (t:I) : + weightMap a.inclusion (a.hom (t,w))=weightMap b.inclusion (b.hom (t,z)) := by + obtain ⟨h,hh⟩:=h + rw [hh] + have hz:weightMap (weightSubset _ _ h) w=z:=by + apply weightMap_injective b.inclusion Subtype.val_injective + rw [weightMap_comp] + exact he + rw [hz] + +end WeightContractionPiece +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightInclusion.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..08dd77cb6482f83a14740b9c2980fbfa8c516de5 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightInclusion.lean @@ -0,0 +1,129 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.ConeWeights + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators unitInterval +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +noncomputable def weightInclusion (A:Set P) : A→oP :=⟨Subtype.val,fun _ _ h=>h⟩ + +noncomputable def weightRestrict (A:Set P) (w:OrderWeights P) (hw:∀p∈w.weights.support,p∈A) : OrderWeights A where + weights:=w.weights.subtypeDomain (·∈A) + nonneg p:=w.nonneg p.val + total:=by + exact (Finsupp.sum_subtypeDomain_index (h := fun (_:P) (a:ℝ)=>a) hw).trans w.total + chain:=by + intro p hp q hq + apply w.chain p.val _ q.val _ + · rw [Finsupp.mem_support_iff] at hp ⊢ + exact hp + · rw [Finsupp.mem_support_iff] at hq ⊢ + exact hq + +lemma weightRestrict_apply (A:Set P) (w:OrderWeights P) (hw:∀p∈w.weights.support,p∈A) (p:A) : + (weightRestrict A w hw).weights p=w.weights p.val :=rfl + +lemma weightRestrict_map (A:Set P) (w:OrderWeights P) (hw:∀p∈w.weights.support,p∈A) : + weightMap (weightInclusion A) (weightRestrict A w hw)=w := by + apply OrderWeights.ext + ext p + by_cases hp:p∈A + · exact weightMap_apply_embedding (weightInclusion A) Subtype.val_injective _ ⟨p,hp⟩ + · have h₁:p∉(weightMap (weightInclusion A) (weightRestrict A w hw)).weights.support:=by + rw [weightMap_support_embedding _ Subtype.val_injective] + rintro hx + obtain ⟨q,_,he⟩:=Finset.mem_image.mp hx + exact hp (he ▸ q.property) + have h₂:p∉w.weights.support:=fun h=>hp (hw _ h) + exact (Finsupp.notMem_support_iff.mp h₁).trans (Finsupp.notMem_support_iff.mp h₂).symm + +lemma weight_le_one (w:OrderWeights P) (p:P) : w.weights p≤1 := by + by_cases hp:p∈w.weights.support + · rw [←w.total] + exact Finset.single_le_sum (fun q _=>w.nonneg q) hp + · rw [Finsupp.notMem_support_iff.mp hp] + norm_num + +noncomputable def weightTime (v:P) (w:OrderWeights P) : I :=⟨w.weights v,w.nonneg v,weight_le_one w v⟩ + +noncomputable def weightVertex (v:P) : OrderWeights P where + weights:=Finsupp.single v 1 + nonneg p:=by simp only [Finsupp.single_apply];split_ifs <;> norm_num + total:=by simp + chain:=by + intro p hp q hq + have hpv:p=v:=Finset.mem_singleton.mp (Finsupp.support_single_subset hp) + have hqv:q=v:=Finset.mem_singleton.mp (Finsupp.support_single_subset hq) + subst p;subst q;exact Or.inl le_rfl + +lemma coneWeights_one_vertex {Q:Type*} [PartialOrder Q] (f:Q→oP) (v:P) (hv:∀q,f q≤v ∨ v≤f q) + (w:OrderWeights Q) : coneWeights f v hv 1 w=weightVertex v := by + apply OrderWeights.ext + simp [coneWeights,weightVertex] + +lemma weight_eq_vertex_of_one (w:OrderWeights P) (v:P) (hv:w.weights v=1) : w=weightVertex v := by + have hvS:v∈w.weights.support:=Finsupp.mem_support_iff.mpr (hv ▸ one_ne_zero) + have hsum:∑p∈w.weights.support.erase v,w.weights p=0:=by + have ht:=w.total + change (∑p∈w.weights.support,w.weights p)=1 at ht + rw [←Finset.add_sum_erase _ _ hvS,hv] at ht + linarith + apply OrderWeights.ext + ext p + by_cases hp:p=v + · subst p;simp [weightVertex,hv] + · have he:w.weights p=0:=by + by_cases hps:p∈w.weights.support + · have hm:p∈w.weights.support.erase v:=Finset.mem_erase.mpr ⟨hp,hps⟩ + have hl:=Finset.single_le_sum (fun q _=>w.nonneg q) hm + rw [hsum] at hl + exact le_antisymm hl (w.nonneg p) + · exact Finsupp.notMem_support_iff.mp hps + simp [weightVertex,he,Ne.symm hp] + +noncomputable def weightDelete (v:P) (w:OrderWeights P) (hv:w.weights v<1) : OrderWeights P where + weights:=(1-w.weights v)⁻¹ • w.weights.erase v + nonneg p:=by + change 0≤ (1-w.weights v)⁻¹ * (w.weights.erase v) p + apply mul_nonneg (inv_nonneg.mpr (sub_nonneg.mpr hv.le)) + by_cases hp:p=v + · subst p;simp + · rw [Finsupp.erase_ne hp] + exact w.nonneg p + total:=by + rw [Finsupp.sum_smul_index (by intros;rfl)] + change (∑p∈(w.weights.erase v).support,(1-w.weights v)⁻¹*(w.weights.erase v) p)=1 + rw [←Finset.mul_sum] + have he:(w.weights.erase v).sum (fun _ a=>a)=1-w.weights v:=by + have hh:=congrArg (fun z:P→₀ℝ=>z.sum (fun _ a=>a)) (Finsupp.single_add_erase v w.weights) + rw [Finsupp.sum_add_index (by intros;rfl) (by intros;rfl),Finsupp.sum_single_index (by rfl),w.total] at hh + linarith + change (1-w.weights v)⁻¹*((w.weights.erase v).sum (fun _ a=>a))=1 + rw [he,inv_mul_cancel₀ (ne_of_gt (sub_pos.mpr hv))] + chain:=by + intro p hp q hq + apply w.chain p _ q _ + · have ht:=Finsupp.support_smul hp + rw [Finsupp.support_erase] at ht + exact (Finset.mem_erase.mp ht).2 + · have ht:=Finsupp.support_smul hq + rw [Finsupp.support_erase] at ht + exact (Finset.mem_erase.mp ht).2 + +lemma weightDelete_apply (v:P) (w:OrderWeights P) (hv:w.weights v<1) (p:P) : + (weightDelete v w hv).weights p=(1-w.weights v)⁻¹*(if p=v then 0 else w.weights p) := by + simp only [weightDelete,Finsupp.smul_apply,smul_eq_mul,Finsupp.erase_apply] + +lemma weightDelete_support (v:P) (w:OrderWeights P) (hv:w.weights v<1) : + (weightDelete v w hv).weights.support⊆w.weights.support.erase v := by + exact Finsupp.support_smul.trans (by rw [Finsupp.support_erase]) + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightInsertRetract.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightInsertRetract.lean new file mode 100644 index 0000000000000000000000000000000000000000..0db035a44c91375f98f238895330875f797a71a9 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightInsertRetract.lean @@ -0,0 +1,173 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightEarlierLower +import OAI.Topology.ArtinGroups.Realizations.WeightRetractionPiece + +namespace OAI + +namespace HarmonicArtin +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +noncomputable def weightInsertRetract (A:Set P) (v:P) (hv:v∉A) + (hc:ContractibleSpace (OrderWeights (WeightLink (⟨v,Set.mem_insert v A⟩:↥(insert v A))))) : + C(OrderWeights ↥(insert v A),OrderWeights A) := + let c:=Classical.choose (@id_nullhomotopic _ _ hc) + let H:=Classical.choice (Classical.choose_spec (@id_nullhomotopic _ _ hc)) + (show C(_,_) from ⟨(weightHomeomorph (insertOldIso A v hv)).symm, + (weightHomeomorph (insertOldIso A v hv)).symm.continuous⟩).comp (weightVertexRetract _ c H) + +lemma weightInsertRetract_old (A:Set P) (v:P) (hv:v∉A) + (hc:ContractibleSpace (OrderWeights (WeightLink (⟨v,Set.mem_insert v A⟩:↥(insert v A))))) + (w:OrderWeights A) : + weightInsertRetract A v hv hc (weightMap (weightSubset A (insert v A) (Set.subset_insert v A)) w)=w := by + let e:=weightHomeomorph (insertOldIso A v hv) + have he:weightMap (weightSubset A (insert v A) (Set.subset_insert v A)) w= + weightOldMap (⟨v,Set.mem_insert v A⟩:↥(insert v A)) (e w):=by + change _=weightMap (weightOldIncl _) (weightMap (OrderHom.ofClass (insertOldIso A v hv)) w) + rw [weightMap_comp,insertOldIso_incl] + rw [he] + change e.symm (weightVertexRetract _ _ _ (weightOldMap _ (e w)))=w + rw [weightVertexRetract_old,e.symm_apply_apply] + +namespace WeightRetractionPiece +variable {r:P→P→Prop} {A:Set P} + +noncomputable def initial (hA:∀{x y},x∈A → r y x → y∈A) : WeightRetractionPiece r A where + carrier:=A + base:=Set.Subset.rfl + down:=hA + map:=ContinuousMap.id _ + retract:=by intro w; rw [weightSubset_self,weightMap_id];rfl + +variable (wf:WellFounded r) (htotal:∀x y,x≠y → r x y ∨ r y x) + +include wf htotal in +lemma missing_minimal (a:WeightRetractionPiece r A) (ha:∃x,x∉a.carrier) : + ∃v,v∉a.carrier ∧ ∀x,x∈a.carrier↔r x v := by + obtain ⟨v,hv,hm⟩:=wf.has_min a.carrierᶜ ha + refine ⟨v,hv,?_⟩ + intro x + constructor + · intro hx + have hne:x≠v:=by intro he;exact hv (he ▸ hx) + rcases htotal x v hne with h|h + · exact h + · exact (hv (a.down hx h)).elim + · intro h + by_contra hn + exact hm x hn h + +variable (a:WeightRetractionPiece r A) (v:P) (hv:v∉a.carrier) + (heA:∀x,x∈a.carrier↔r x v) + (hlink:ContractibleSpace (OrderWeights (WeightEarlierLink r v))) + +include wf heA hlink in +theorem insertLinkContractible : + ContractibleSpace (OrderWeights (WeightLink (⟨v,Set.mem_insert v a.carrier⟩:↥(insert v a.carrier)))) := + (weightHomeomorph (insertLinkIso r (fun x=>wf.irrefl.irrefl x) a.carrier v heA)).contractibleSpace_iff.mpr hlink + +noncomputable def successor : WeightRetractionPiece r A where + carrier:=insert v a.carrier + base:=a.base.trans (Set.subset_insert v a.carrier) + down:=by + intro x y hx hy + rcases Set.mem_insert_iff.mp hx with hx|hx + · subst x + exact Set.mem_insert_of_mem v ((heA y).mpr hy) + · exact Set.mem_insert_of_mem v (a.down hx hy) + map:=a.map.comp (weightInsertRetract a.carrier v hv (insertLinkContractible wf a v heA hlink)) + retract:=by + intro w + have he:weightSubset A (insert v a.carrier) (a.base.trans (Set.subset_insert v a.carrier))= + (weightSubset a.carrier (insert v a.carrier) (Set.subset_insert v a.carrier)).comp + (weightSubset A a.carrier a.base):=rfl + rw [he,← weightMap_comp] + change a.map (weightInsertRetract _ _ _ _ (weightMap _ (weightMap _ w)))=w + rw [weightInsertRetract_old,a.retract] + +lemma extends_successor : a.Extends (successor wf a v hv heA hlink) := by + refine ⟨Set.subset_insert v a.carrier,?_⟩ + intro w + change a.map (weightInsertRetract _ _ _ _ (weightMap _ w))=a.map w + exact congrArg a.map (weightInsertRetract_old a.carrier v hv + (insertLinkContractible wf a v heA hlink) w) + +end WeightRetractionPiece + +theorem orderWeights_retract_of_initial (r:P→P→Prop) (wf:WellFounded r) + (htotal:∀x y,x≠y → r x y ∨ r y x) (A:Set P) + (hdown:∀{x y},x∈A → r y x → y∈A) + (hl:∀v,v∉A → ContractibleSpace (OrderWeights (WeightEarlierLink r v))) : + ∃f:C(OrderWeights P,OrderWeights A),∀w:OrderWeights A,f (weightMap (weightInclusion A) w)=w := by + let :Nonempty (WeightRetractionPiece r A):=⟨WeightRetractionPiece.initial hdown⟩ + obtain ⟨a,ha⟩:=exists_maximal_of_nonempty_chains_bounded + (r:=@WeightRetractionPiece.Extends P _ r A) + (fun C hc hn=>⟨WeightRetractionPiece.union C hc hn, + fun a ha=>WeightRetractionPiece.extends_union C hc hn ha⟩) + WeightRetractionPiece.extends_trans + have hfull:∀x,x∈a.carrier:=by + by_contra hn + obtain ⟨v,hv,heA⟩:=WeightRetractionPiece.missing_minimal wf htotal a (not_forall.mp hn) + have hvA:v∉A:=fun h=>hv (a.base h) + have hnext:=WeightRetractionPiece.extends_successor wf a v hv heA (hl v hvA) + have hback:=ha _ hnext + exact hv (hback.choose (Set.mem_insert v a.carrier)) + let e:a.carrier≃oP:={ + toFun:=Subtype.val + invFun:=fun x=>⟨x,hfull x⟩ + left_inv:=fun _=>rfl + right_inv:=fun _=>rfl + map_rel_iff':=by intros;rfl } + refine ⟨a.map.comp ⟨(weightHomeomorph e).symm,(weightHomeomorph e).symm.continuous⟩,?_⟩ + intro w + change a.map (weightMap (e.symm:P→o a.carrier) (weightMap (weightInclusion A) w))=w + rw [weightMap_comp] + exact a.retract w + +theorem orderWeights_retract_of_lower_fibers (A:Set P) (k:P→ℕ) (N:ℕ) + (hk:∀x,k x≤N) (hm:StrictMono k) + (hf:∀v,v∉A → ContractibleSpace (OrderWeights {x:P // x∈A ∧ xN-k x + let r:=WeightJoinEarlier A d + have hw:=weightJoinEarlier_wf A d + apply orderWeights_retract_of_initial r hw (weightJoinEarlier_total A d) A + (weightJoinEarlier_initial A d) + intro v hv + have he:∀x,x⟨x.val,(he x.val x.property.2).mp x.property.1,x.property.2⟩ + invFun:=fun x=>⟨x.val,(he x.val x.property.2).mpr x.property.1,x.property.2⟩ + left_inv:=fun _=>rfl + right_inv:=fun _=>rfl + map_rel_iff':=by intros;rfl } + exact weightLink_contractible_of_lower r (fun x=>hw.irrefl.irrefl x) v k N hk hm + ((weightHomeomorph e).contractibleSpace_iff.mpr (hf v hv)) + +lemma contractible_of_continuous_retract {X Y:Type*} [TopologicalSpace X] [TopologicalSpace Y] + (i:C(X,Y)) (r:C(Y,X)) (hr:∀x,r (i x)=x) (h:ContractibleSpace Y) : ContractibleSpace X := by + obtain ⟨y,⟨H⟩⟩:=@id_nullhomotopic _ _ h + apply (contractible_iff_id_nullhomotopic _).mpr + refine ⟨r y,⟨?_⟩⟩ + exact { + toFun:=fun p=>r (H (p.1,i p.2)) + continuous_toFun:=r.continuous.comp (H.continuous.comp (continuous_fst.prodMk (i.continuous.comp continuous_snd))) + map_zero_left:=fun x=>by rw [H.apply_zero];exact hr x + map_one_left:=fun x=>by rw [H.apply_one];rfl } + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightJoinKey.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightJoinKey.lean new file mode 100644 index 0000000000000000000000000000000000000000..07527cc38d3d33d2dddea3b5fc4db029813b3caa --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightJoinKey.lean @@ -0,0 +1,99 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.ContractionPoint + +namespace OAI + +namespace HarmonicArtin +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +noncomputable def weightJoinKey (A:Set P) (d:P→ℕ) (x:P) : ℕ := + if x∈A then 0 else d x+1 + +def WeightJoinEarlier (A:Set P) (d:P→ℕ) (x y:P) : Prop := + Prod.Lex (·<·) WellOrderingRel (weightJoinKey A d x,x) (weightJoinKey A d y,y) + +omit [PartialOrder P] in +lemma weightJoinEarlier_wf (A:Set P) (d:P→ℕ) : WellFounded (WeightJoinEarlier A d) := + InvImage.wf (fun x=>(weightJoinKey A d x,x)) + (wellFounded_lt.prod_lex WellOrderingRel.isWellOrder.wf) + +omit [PartialOrder P] in +lemma weightJoinEarlier_iff (A:Set P) (d:P→ℕ) (x y:P) : + WeightJoinEarlier A d x y ↔ weightJoinKey A d x + intro P inst A d hb hd hcross hA + let r:=WeightJoinEarlier A d + apply orderWeights_contractible_of_initial r (weightJoinEarlier_wf A d) + (weightJoinEarlier_total A d) A (weightJoinEarlier_initial A d) hA + intro v hv + let L:=WeightEarlierLink r v + let A':Set L:={x | x.val∈A} + have hne (x:L) : x.val≠v := by + intro he + have hr:=x.property.1 + rw [he] at hr + exact (weightJoinEarlier_wf A d).irrefl.irrefl v hr + have hupper (x:L) (hx:x∉A') : v⟨⟨a.val,weightJoinEarlier_old A d a.property hv, + Or.inl (hcross a.property hv)⟩,a.property⟩ + invFun:=fun a=>⟨a.val.val,a.property⟩ + left_inv:=fun _=>rfl + right_inv:=fun _=>rfl + map_rel_iff':=by intros;rfl } + have hA':ContractibleSpace (OrderWeights A'):= + (weightHomeomorph e).contractibleSpace_iff.mp hA + exact ih (d v) (hb v hv) A' (fun x:L=>d x.val) + (fun x hx=>hd hv hx (hupper x hx)) + (by intro x y hx hy hxy;exact hd hx hy hxy) + (by intro a b ha hb;exact hcross ha hb) hA' + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightLinearLinkInverse.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightLinearLinkInverse.lean new file mode 100644 index 0000000000000000000000000000000000000000..8f1fdd1d84138ab51c173d6c3790d5d63faf0195 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightLinearLinkInverse.lean @@ -0,0 +1,141 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightOld + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators unitInterval +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u v + +lemma weightMap_cone {P Q R:Type*} [PartialOrder P] [PartialOrder Q] [PartialOrder R] + (f:Q→oP) (g:P→oR) (v:P) (hv:∀q,f q≤v ∨ v≤f q) (t:I) (w:OrderWeights Q) : + weightMap g (coneWeights f v hv t w)= + coneWeights (g.comp f) (g v) (fun q=>(hv q).imp (fun h=>g.monotone h) (fun h=>g.monotone h)) t w := by + apply OrderWeights.ext + change Finsupp.mapDomain g ((σ t).val • (weightMap f w).weights+Finsupp.single v t.val)=_ + rw [Finsupp.mapDomain_add,Finsupp.mapDomain_smul,Finsupp.mapDomain_single] + congr 1 + exact congrArg (fun z:OrderWeights R=>(σ t).val • z.weights) (weightMap_comp f g w) + +lemma weight_support_singleton {P:Type*} [PartialOrder P] (w:OrderWeights P) (v:P) + (hs:w.weights.support⊆{v}) : w=weightVertex v := by + have he:=Finsupp.support_subset_singleton.mp hs + have ht:=w.total + rw [he,Finsupp.sum_single_index (by rfl)] at ht + apply weight_eq_vertex_of_one w v ht + +noncomputable def weightLinearLinkInverse {P:Type*} [LinearOrder P] (v:P) : WeightOld v→o WeightLink v := + ⟨fun p=>⟨p.val,p.property,le_total p.val v⟩,fun _ _ h=>h⟩ + +lemma weightLinearLinkMap_surjective {P:Type*} [LinearOrder P] (v:P) : + Function.Surjective (weightLinkMap v) := by + intro w + refine ⟨weightMap (weightLinearLinkInverse v) w,?_⟩ + change weightMap (weightLinkOld v) (weightMap (weightLinearLinkInverse v) w)=w + rw [weightMap_comp] + exact weightMap_id w + +lemma weightLinearCone_surjective {P:Type*} [LinearOrder P] (v:P) (c:OrderWeights (WeightLink v)) : + Function.Surjective (weightConeMap v) := by + intro w + obtain ⟨z,hz⟩:=weightParts_surjective v c w + rcases z with z|z + · obtain ⟨l,hl⟩:=weightLinearLinkMap_surjective v z + refine ⟨(0,l),?_⟩ + rw [weightConeMap_zero,hl] + exact hz + · exact ⟨z,hz⟩ + +lemma weightLinearCone_quotient {P:Type*} [LinearOrder P] [Fintype P] + (v:P) (c:OrderWeights (WeightLink v)) : Topology.IsQuotientMap (weightConeMap v) := + Topology.IsQuotientMap.of_surjective_continuous (weightLinearCone_surjective v c) (weightConeMap v).continuous + +noncomputable def weightLinkEmbedding {P Q:Type*} [PartialOrder P] [PartialOrder Q] + (j:Q↪oP) (v:Q) : WeightLink v→o WeightLink (j v) where + toFun p:=⟨j p.val,fun h=>p.property.1 (j.injective h), + p.property.2.imp (fun h=>j.monotone h) (fun h=>j.monotone h)⟩ + monotone':=fun _ _ h=>j.monotone h + +lemma weightCone_embedding {P Q:Type*} [PartialOrder P] [PartialOrder Q] + (j:Q↪oP) (v:Q) (p:I×OrderWeights (WeightLink v)) : + weightMap ⟨j,j.monotone⟩ (weightConeMap v p)= + weightConeMap (j v) (p.1,weightMap (weightLinkEmbedding j v) p.2) := by + let jo:Q→oP:=⟨j,j.monotone⟩ + change weightMap jo (coneWeights (weightLinkIncl v) v (fun q=>q.property.2) p.1 p.2)= + coneWeights (weightLinkIncl (j v)) (j v) (fun q=>q.property.2) p.1 (weightMap (weightLinkEmbedding j v) p.2) + rw [weightMap_cone] + apply OrderWeights.ext + change (σ p.1).val • (weightMap (jo.comp (weightLinkIncl v)) p.2).weights+_= _ + have he:weightMap (jo.comp (weightLinkIncl v)) p.2= + weightMap (weightLinkIncl (j v)) (weightMap (weightLinkEmbedding j v) p.2):= + (weightMap_comp (weightLinkEmbedding j v) (weightLinkIncl (j v)) p.2).symm + rw [he] + rfl + +lemma continuous_comp_weightEmbedding {P Q Y:Type*} [PartialOrder P] [LinearOrder Q] + [Fintype Q] [TopologicalSpace Y] (j:Q↪oP) (v:Q) (c:OrderWeights (WeightLink v)) + (f:OrderWeights P→Y) (hCone:Continuous (f ∘ weightConeMap (j v))) : + Continuous (f ∘ weightMap ⟨j,j.monotone⟩) := by + apply (weightLinearCone_quotient v c).continuous_iff.mpr + have hp:Continuous (fun p:I×OrderWeights (WeightLink v)=> + (p.1,weightMap (weightLinkEmbedding j v) p.2)):= + continuous_fst.prodMk ((weightMap_continuous (weightLinkEmbedding j v)).comp continuous_snd) + exact (hCone.comp hp).congr (fun p=>congrArg f (weightCone_embedding j v p).symm) + +theorem continuous_of_weightParts {P:Type u} [PartialOrder P] {Y:Type v} [TopologicalSpace Y] + (v:P) (f:OrderWeights P→Y) + (hOld:Continuous (f ∘ weightOldMap v)) + (hCone:Continuous (f ∘ weightConeMap v)) : Continuous f := by + rw [orderWeights_continuous_iff] + intro n x + let a:Fin (n.len+1)→o P:=nerveChain x + let C:Finset P:=Finset.univ.image a + have hC:IsChain (·<·) (↑C:Set P):=by + intro p hp q hq hne + obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp hp + obtain ⟨j,_,rfl⟩:=Finset.mem_image.mp hq + exact (le_total i j).imp (fun hle=>lt_of_le_of_ne (a.monotone hle) hne) + (fun hle=>lt_of_le_of_ne (a.monotone hle) hne.symm) + have ha (i:Fin (n.len+1)):a i∈C:=Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩ + by_cases hv:v∈C + · by_cases hn:(C.erase v).Nonempty + · let _ := IsChain.linearOrder hC + let rv:C:=⟨v,hv⟩ + let j:C→oP:=⟨Subtype.val,fun _ _ h=>h⟩ + let aC:Fin (n.len+1)→o C:=⟨fun i=>⟨a i,ha i⟩,fun _ _ h=>a.monotone h⟩ + obtain ⟨b,hb⟩:=hn + let c:WeightLink rv:=⟨⟨b,(Finset.mem_erase.mp hb).2⟩, + (by intro h;exact (Finset.mem_erase.mp hb).1 (congrArg Subtype.val h)),le_total _ _⟩ + let je:C↪oP:=OrderEmbedding.subtype (·∈C) + have hf:Continuous (f ∘ weightMap j):= + continuous_comp_weightEmbedding je rv (weightVertex c) f hCone + have hh:=hf.comp (chainWeightsChart_continuous aC) + change Continuous (fun z=>f (weightMap j (orderWeightsOfChain aC z))) at hh + simp_rw [weightMap_chain] at hh + have hj:j.comp aC=nerveChain x:=by ext i;rfl + rw [hj] at hh + exact hh + · have hs:C⊆{v}:=by + intro p hp + by_contra hh + have hpv:p≠v:=by simpa only [Finset.mem_singleton] using hh + exact hn ⟨p,Finset.mem_erase.mpr ⟨hpv,hp⟩⟩ + have he (z:Convexity.StdSimplex ℝ (Fin (n.len+1))) : orderWeightsOfChain a z=weightVertex v:= + weight_support_singleton _ _ ((chainWeights_support a z).trans hs) + simp_rw [show nerveChain x=a from rfl,he] + exact continuous_const + · let aO:Fin (n.len+1)→o WeightOld v:= + ⟨fun i=>⟨a i,(by intro h;exact hv (h ▸ ha i))⟩,fun _ _ h=>a.monotone h⟩ + have hh:=hOld.comp (chainWeightsChart_continuous aO) + change Continuous (fun z=>f (weightMap (weightOldIncl v) (orderWeightsOfChain aO z))) at hh + simp_rw [weightMap_chain] at hh + have hj:(weightOldIncl v).comp aO=nerveChain x:=by ext i;rfl + rw [hj] at hh + exact hh + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightMap.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightMap.lean new file mode 100644 index 0000000000000000000000000000000000000000..c1272ab917f4579220a0bbfaabefa06260db9b6d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightMap.lean @@ -0,0 +1,79 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.NerveChain + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators +open Simplicial CategoryTheory Opposite + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u v +variable {P:Type u} {Q:Type v} [PartialOrder P] [PartialOrder Q] + +noncomputable def weightMap (f:P→oQ) (w:OrderWeights P) : OrderWeights Q where + weights:=w.weights.mapDomain f + nonneg q:=by + unfold Finsupp.mapDomain + rw [Finsupp.sum_apply] + exact Finset.sum_nonneg (fun p _=>by + simp only [Finsupp.single_apply] + split_ifs; exacts [w.nonneg p,le_rfl]) + total:=by + rw [Finsupp.sum_mapDomain_index (by intros;rfl) (by intros;rfl)] + exact w.total + chain:=by + intro p hp q hq + obtain ⟨a,ha,rfl⟩:=Finset.mem_image.mp (Finsupp.mapDomain_support hp) + obtain ⟨b,hb,rfl⟩:=Finset.mem_image.mp (Finsupp.mapDomain_support hq) + exact (w.chain a ha b hb).imp (fun h=>f.monotone h) (fun h=>f.monotone h) + +lemma weightMap_chain {n:ℕ} (f:P→oQ) (x:Fin (n+1)→o P) + (z:Convexity.StdSimplex ℝ (Fin (n+1))) : + weightMap f (orderWeightsOfChain x z)=orderWeightsOfChain (f.comp x) z := by + apply OrderWeights.ext + change Finsupp.mapDomain f (chainWeights x z)=chainWeights (f.comp x) z + simp only [chainWeights,Finsupp.mapDomain_finsetSum,Finsupp.mapDomain_single] + rfl + +lemma chainWeightsChart_continuous {n:ℕ} (x:Fin (n+1)→oP) : + Continuous (orderWeightsOfChain x) := + orderWeightsChart_continuous (nerveOfChain x) + +lemma weightMap_continuous (f:P→o Q) : Continuous (weightMap f) := by + rw [orderWeights_continuous_iff] + intro n x + simp_rw [weightMap_chain] + exact chainWeightsChart_continuous _ + +noncomputable def weightMapContinuous (f:P→oQ) : C(OrderWeights P,OrderWeights Q) := + ⟨weightMap f,weightMap_continuous f⟩ + +lemma weightMap_id (w:OrderWeights P) : weightMap OrderHom.id w=w := by + apply OrderWeights.ext + exact Finsupp.mapDomain_id + +lemma weightMap_comp {R:Type*} [PartialOrder R] (f:P→oQ) (g:Q→oR) (w:OrderWeights P) : + weightMap g (weightMap f w)=weightMap (g.comp f) w := by + apply OrderWeights.ext + exact Finsupp.mapDomain_comp.symm + +lemma weightMap_injective (f:P→oQ) (hf:Function.Injective f) : Function.Injective (weightMap f) := by + intro x y h + apply OrderWeights.ext + have he:=congrArg OrderWeights.weights h + change x.weights.mapDomain f=y.weights.mapDomain f at he + exact Finsupp.mapDomain_injective hf he + +lemma weightMap_apply_embedding (f:P→oQ) (hf:Function.Injective f) (w:OrderWeights P) (p:P) : + (weightMap f w).weights (f p)=w.weights p := by + change (w.weights.mapDomain f) (f p)=_ + exact Finsupp.mapDomain_apply_of_injective hf _ _ + +lemma weightMap_support_embedding (f:P→oQ) (hf:Function.Injective f) (w:OrderWeights P) : + (weightMap f w).weights.support=w.weights.support.image f := + Finsupp.mapDomain_support_of_injective hf w.weights + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightMapCover.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightMapCover.lean new file mode 100644 index 0000000000000000000000000000000000000000..a1b81697199754f5f9e2cb8a55ae7f13e83ada53 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightMapCover.lean @@ -0,0 +1,68 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.ConeWeights + +namespace OAI + +namespace HarmonicArtin +open scoped unitInterval +open Simplicial + +universe u v w z +variable {P:Type u} [PartialOrder P] {J:Type v} {Q:J→Type u} [∀j,PartialOrder (Q j)] + (f:∀j,Q j→oP) {Z:Type w} [TopologicalSpace Z] [LocallyCompactSpace Z] + {Y:Type z} [TopologicalSpace Y] + +def WeightMapCover : Prop := + ∀(n:ℕ) (a:Fin (n+1)→oP),∃i:J,∃b:Fin (n+1)→o Q i,(f i).comp b=a + +lemma weightMapCover_rep (hf:WeightMapCover f) (w:OrderWeights P) : + ∃i:J,∃z:OrderWeights (Q i),weightMap (f i) z=w := by + obtain ⟨i,b,hb⟩:=hf (weightDim w) (weightChain w) + refine ⟨i,orderWeightsOfChain b (weightSimplex w),?_⟩ + rw [weightMap_chain,hb] + exact orderWeightsOfChain_canonical w + +noncomputable def weightMapGlueIndex (hf:WeightMapCover f) (w:OrderWeights P) : J := + (weightMapCover_rep f hf w).choose +noncomputable def weightMapGlueRep (hf:WeightMapCover f) (w:OrderWeights P) : OrderWeights (Q (weightMapGlueIndex f hf w)) := + (weightMapCover_rep f hf w).choose_spec.choose +lemma weightMapGlueRep_map (hf:WeightMapCover f) (w:OrderWeights P) : + weightMap (f _) (weightMapGlueRep f hf w)=w := + (weightMapCover_rep f hf w).choose_spec.choose_spec + +variable (F:∀i:J,C(Z×OrderWeights (Q i),Y)) + +def WeightMapCompatible : Prop := + ∀(i j:J) (wi:OrderWeights (Q i)) (wj:OrderWeights (Q j)), + weightMap (f i) wi=weightMap (f j) wj → ∀t:Z,F i (t,wi)=F j (t,wj) + +noncomputable def weightMapGlueValue (hf:WeightMapCover f) (p:Z×OrderWeights P) : Y := + F (weightMapGlueIndex f hf p.2) (p.1,weightMapGlueRep f hf p.2) + +omit [LocallyCompactSpace Z] in +lemma weightMapGlueValue_on (hf:WeightMapCover f) (hF:WeightMapCompatible f F) + (i:J) (p:Z×OrderWeights (Q i)) : + weightMapGlueValue f F hf (p.1,weightMap (f i) p.2)=F i p := by + exact hF _ _ _ _ (weightMapGlueRep_map f hf _) _ + +lemma weightMapGlueValue_continuous (hf:WeightMapCover f) (hF:WeightMapCompatible f F) : + Continuous (weightMapGlueValue f F hf) := by + apply orderWeights_prod_continuous + intro n x + obtain ⟨i,b,hb⟩:=hf n.len (nerveChain x) + have he (z:Convexity.StdSimplex ℝ (Fin (n.len+1))) : + weightMap (f i) (orderWeightsOfChain b z)=orderWeightsOfChain (nerveChain x) z := by + rw [weightMap_chain,hb] + have hc:Continuous (fun p:Z×Convexity.StdSimplex ℝ (Fin (n.len+1))=>F i (p.1,orderWeightsOfChain b p.2)):= + (F i).continuous.comp (continuous_fst.prodMk ((chainWeightsChart_continuous b).comp continuous_snd)) + apply hc.congr + intro p + rw [←he] + exact (weightMapGlueValue_on f F hf hF i (p.1,orderWeightsOfChain b p.2)).symm + +noncomputable def weightMapGlue (hf:WeightMapCover f) (hF:WeightMapCompatible f F) : C(Z×OrderWeights P,Y) := + ⟨weightMapGlueValue f F hf,weightMapGlueValue_continuous f F hf hF⟩ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightOld.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightOld.lean new file mode 100644 index 0000000000000000000000000000000000000000..f60dc43ea8f00696d834107b1fb0b48fa28c5632 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightOld.lean @@ -0,0 +1,123 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Quivers.ReversibleQuiver +import OAI.Topology.ArtinGroups.Realizations.WeightInclusion + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators unitInterval + +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] + +abbrev WeightOld (v:P) := {p:P // p≠v} +abbrev WeightLink (v:P) := {p:P // p≠v ∧ (p≤v ∨ v≤p)} +noncomputable abbrev weightOldIncl (v:P) : WeightOld v→o P :=⟨Subtype.val,fun _ _ h=>h⟩ +noncomputable abbrev weightLinkIncl (v:P) : WeightLink v→o P :=⟨Subtype.val,fun _ _ h=>h⟩ +noncomputable abbrev weightLinkOld (v:P) : WeightLink v→o WeightOld v :=⟨fun p=>⟨p.val,p.property.1⟩,fun _ _ h=>h⟩ +noncomputable def weightOldMap (v:P) : C(OrderWeights (WeightOld v),OrderWeights P) := + ⟨weightMap (weightOldIncl v),weightMap_continuous _⟩ +noncomputable def weightLinkMap (v:P) : C(OrderWeights (WeightLink v),OrderWeights (WeightOld v)) := + ⟨weightMap (weightLinkOld v),weightMap_continuous _⟩ +noncomputable def weightConeMap (v:P) : C(I×OrderWeights (WeightLink v),OrderWeights P) := + coneWeightsContinuous (weightLinkIncl v) v (fun p=>p.property.2) + +lemma weightMap_zero_of_not_range {Q:Type*} [PartialOrder Q] (f:Q→oP) (w:OrderWeights Q) (p:P) + (hp:p∉Set.range f) : (weightMap f w).weights p=0 := by + apply Finsupp.notMem_support_iff.mp + intro h + obtain ⟨q,_,he⟩:=Finset.mem_image.mp (Finsupp.mapDomain_support h) + exact hp ⟨q,he⟩ + +lemma weightOldMap_at (v:P) (w:OrderWeights (WeightOld v)) : (weightOldMap v w).weights v=0 := by + apply weightMap_zero_of_not_range + rintro ⟨p,hp⟩ + exact p.property hp + +lemma weightConeMap_at (v:P) (p:I×OrderWeights (WeightLink v)) : + (weightConeMap v p).weights v=p.1.val := by + rw [show weightConeMap v p=coneWeights (weightLinkIncl v) v (fun p=>p.property.2) p.1 p.2 from rfl, + coneWeights_apply] + have hz:(weightMap (weightLinkIncl v) p.2).weights v=0:=by + apply weightMap_zero_of_not_range + rintro ⟨q,hq⟩ + exact q.property.1 hq + rw [hz,ite_eq_left rfl,mul_zero,zero_add] + +lemma weightConeMap_zero (v:P) (w:OrderWeights (WeightLink v)) : + weightConeMap v (0,w)=weightOldMap v (weightLinkMap v w) := by + rw [show weightConeMap v (0,w)=coneWeights (weightLinkIncl v) v (fun p=>p.property.2) 0 w from rfl, + coneWeights_zero] + exact (weightMap_comp (weightLinkOld v) (weightOldIncl v) w).symm + +lemma weightConeMap_one (v:P) (w:OrderWeights (WeightLink v)) : + weightConeMap v (1,w)=weightVertex v := coneWeights_one_vertex (weightLinkIncl v) v (fun q=>q.property.2) w + +lemma weightConeMap_eq_cone {v:P} {t s:I} {w z:OrderWeights (WeightLink v)} + (h:weightConeMap v (t,w)=weightConeMap v (s,z)) : t=s ∧ (t=1 ∨ w=z) := by + have ht:t=s:=Subtype.ext (by simpa only [weightConeMap_at] using congrArg (fun a:OrderWeights P=>a.weights v) h) + subst s + refine ⟨rfl,?_⟩ + by_cases he:t=1 + · exact Or.inl he + right + apply OrderWeights.ext + ext p + have hs:=congrArg (fun a:OrderWeights P=>a.weights p.val) h + change (coneWeights (weightLinkIncl v) v (fun q=>q.property.2) t w).weights p.val= + (coneWeights (weightLinkIncl v) v (fun q=>q.property.2) t z).weights p.val at hs + simp only [coneWeights_apply,ite_eq_right (Ne.symm p.property.1),add_zero] at hs + have hw:(weightMap (weightLinkIncl v) w).weights p.val=w.weights p:= + weightMap_apply_embedding (weightLinkIncl v) Subtype.val_injective w p + have hz:(weightMap (weightLinkIncl v) z).weights p.val=z.weights p:= + weightMap_apply_embedding (weightLinkIncl v) Subtype.val_injective z p + rw [hw,hz] at hs + exact mul_left_cancel₀ (sub_ne_zero.mpr (fun h=>he (Subtype.ext h.symm))) hs + +lemma weightOld_surjective_zero {v:P} (w:OrderWeights P) (hv:w.weights v=0) : + ∃z:OrderWeights (WeightOld v),weightOldMap v z=w := by + have hs:∀p∈w.weights.support,p≠v:=by + intro p hp he;subst p + exact Finsupp.mem_support_iff.mp hp hv + exact ⟨weightRestrict {p | p≠v} w hs,weightRestrict_map _ w hs⟩ + +lemma weightDelete_link {v:P} (w:OrderWeights P) (ht:w.weights v<1) (hp:0q.property.2) (weightTime v w) _).weights p=w.weights p + rw [coneWeights_apply] + have he:weightMap (weightLinkIncl v) + (weightRestrict {p | p≠v ∧ (p≤v ∨ v≤p)} (weightDelete v w ht) (weightDelete_link w ht hp))= + weightDelete v w ht:=weightRestrict_map _ _ _ + rw [he,weightDelete_apply] + change (1-w.weights v)*((1-w.weights v)⁻¹*(if p=v then 0 else w.weights p))+ + (if v=p then w.weights v else 0)=w.weights p + by_cases he:p=v + · subst p;simp + · rw [ite_eq_right he,ite_eq_right (Ne.symm he),←mul_assoc,mul_inv_cancel₀ (ne_of_gt (sub_pos.mpr ht)),one_mul,add_zero] + +lemma weightParts_surjective (v:P) (c:OrderWeights (WeightLink v)) : + Function.Surjective (Sum.elim (weightOldMap v) (weightConeMap v)) := by + intro w + by_cases hz:w.weights v=0 + · obtain ⟨z,rfl⟩:=weightOld_surjective_zero w hz + exact ⟨.inl z,rfl⟩ + by_cases ho:w.weights v=1 + · exact ⟨.inr (1,c),(weightConeMap_one v c).trans (weight_eq_vertex_of_one w v ho).symm⟩ + have ht:w.weights v<1:=lt_of_le_of_ne (weight_le_one w v) ho + have hp:0 weightMap (weightInclusion (Set.Iic x.1)) x.2 + +lemma weightPrincipalProjection_continuous : Continuous (weightPrincipalProjection (P := P)) := by + apply continuous_sigma_iff.mpr + intro p + exact weightMap_continuous (weightInclusion (Set.Iic p)) + +lemma weightPrincipalProjection_surjective : Function.Surjective (weightPrincipalProjection (P := P)) := by + intro w + exact ⟨⟨weightMax w,weightRestrict (Set.Iic (weightMax w)) w (le_weightMax w)⟩, + weightRestrict_map _ w (le_weightMax w)⟩ + +theorem weightPrincipalProjection_quotient : IsQuotientMap (weightPrincipalProjection (P := P)) := by + rw [isQuotientMap_iff_isClosed] + refine ⟨weightPrincipalProjection_surjective,fun A => ⟨fun h => h.preimage weightPrincipalProjection_continuous,?_⟩⟩ + intro h + rw [orderWeights_isClosed_iff] + intro n x + let c := nerveChain x + let a := c (Fin.last n.len) + let d : Fin (n.len+1) →o Set.Iic a := + ⟨fun i => ⟨c i,c.monotone (Fin.le_last i)⟩,fun _ _ h => c.monotone h⟩ + have hc : Continuous (fun z : Convexity.StdSimplex ℝ (Fin (n.len+1)) => + (⟨a,orderWeightsOfChain d z⟩ : Σ p : P,OrderWeights (Set.Iic p))) := + (continuous_sigmaMk (i := a)).comp (chainWeightsChart_continuous d) + have he : ∀ z,weightPrincipalProjection (⟨a,orderWeightsOfChain d z⟩ : Σp,OrderWeights (Set.Iic p)) = + orderWeightsOfChain (nerveChain x) z := by + intro z + exact weightMap_chain (weightInclusion (Set.Iic a)) d z + simpa only [Set.preimage_preimage,Function.comp_def,he] using h.preimage hc + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightRetractionPiece.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightRetractionPiece.lean new file mode 100644 index 0000000000000000000000000000000000000000..7a68d35b0da2c86ecb7f97b28f47835f3de16250 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightRetractionPiece.lean @@ -0,0 +1,138 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightHomeomorph +import OAI.Topology.ArtinGroups.Realizations.WeightMapCover + +namespace OAI + +namespace HarmonicArtin +attribute [local instance] Classical.decEq Classical.propDecidable +universe u +variable {P:Type u} [PartialOrder P] (r:P→P→Prop) (A:Set P) + +structure WeightRetractionPiece where + carrier:Set P + base:A⊆carrier + down:∀{x y},x∈carrier → r y x → y∈carrier + map:C(OrderWeights carrier,OrderWeights A) + retract:∀w:OrderWeights A,map (weightMap (weightSubset A carrier base) w)=w + +namespace WeightRetractionPiece +variable {r A} + +def Extends (a b:WeightRetractionPiece r A) : Prop := + ∃h:a.carrier⊆b.carrier,∀w:OrderWeights a.carrier, + b.map (weightMap (weightSubset _ _ h) w)=a.map w + +lemma extends_refl (a:WeightRetractionPiece r A) : a.Extends a := by + refine ⟨Set.Subset.rfl,?_⟩ + intro w + rw [weightSubset_self,weightMap_id] + +lemma extends_trans {a b c:WeightRetractionPiece r A} (h:a.Extends b) (k:b.Extends c) : a.Extends c := by + obtain ⟨h,hh⟩:=h + obtain ⟨k,hk⟩:=k + refine ⟨h.trans k,?_⟩ + intro w + rw [← weightSubset_comp _ _ _ h k,← weightMap_comp,hk,hh] + +instance : Std.Refl (@Extends P _ r A):=⟨extends_refl⟩ + +lemma extends_compare {a b:WeightRetractionPiece r A} (h:a.Extends b) + (w:OrderWeights a.carrier) (z:OrderWeights b.carrier) + (he:weightMap (weightInclusion a.carrier) w=weightMap (weightInclusion b.carrier) z) : + a.map w=b.map z := by + obtain ⟨h,hh⟩:=h + have hz:weightMap (weightSubset _ _ h) w=z:=by + apply weightMap_injective (weightInclusion b.carrier) Subtype.val_injective + rw [weightMap_comp] + exact he + rw [←hh,hz] + +variable (C:Set (WeightRetractionPiece r A)) (hc:IsChain Extends C) (hne:C.Nonempty) + +def unionCarrier : Set P :={x | ∃a∈C,x∈a.carrier} +lemma subset_union {a:WeightRetractionPiece r A} (ha:a∈C) : a.carrier⊆unionCarrier C := + fun _ hx=>⟨a,ha,hx⟩ + +include hc hne in +lemma union_finset_cover (s:Finset P) (hs:∀x∈s,x∈unionCarrier C) : + ∃a∈C,∀x∈s,x∈a.carrier := by + induction s using Finset.induction_on with + | empty=>obtain ⟨a,ha⟩:=hne;exact ⟨a,ha,by simp⟩ + | @insert x s hx ih=> + obtain ⟨a,ha,hac⟩:=ih (fun y hy=>hs y (Finset.mem_insert_of_mem hy)) + obtain ⟨b,hb,hxb⟩:=hs x (Finset.mem_insert_self x s) + rcases hc.total ha hb with hab|hba + · refine ⟨b,hb,?_⟩ + intro y hy + rcases Finset.mem_insert.mp hy with rfl|hy + · exact hxb + · exact hab.choose (hac y hy) + · refine ⟨a,ha,?_⟩ + intro y hy + rcases Finset.mem_insert.mp hy with rfl|hy + · exact hba.choose hxb + · exact hac y hy + +noncomputable def unionIncl (a:C) : a.val.carrier→o unionCarrier C := + weightSubset _ _ (subset_union C a.property) + +include hc hne in +lemma union_map_cover : WeightMapCover (unionIncl C) := by + intro n a + obtain ⟨b,hb,hcover⟩:=union_finset_cover C hc hne + (Finset.univ.image (fun i=> (a i).val)) (by + intro x hx + obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp hx + exact (a i).property) + let d:Fin (n+1)→o b.carrier:=⟨fun i=>⟨(a i).val,hcover _ (Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩)⟩, + fun _ _ h=>a.monotone h⟩ + exact ⟨⟨b,hb⟩,d,by ext i;rfl⟩ + +noncomputable def unionLocal (a:C) : C(Unit×OrderWeights a.val.carrier,OrderWeights A) := + a.val.map.comp ContinuousMap.snd + +include hc in +lemma union_compatible : WeightMapCompatible (unionIncl C) (unionLocal C) := by + intro a b w z he t + have hW:weightMap (weightInclusion a.val.carrier) w=weightMap (weightInclusion b.val.carrier) z:=by + have hh:=congrArg (weightMap (weightInclusion (unionCarrier C))) he + rw [weightMap_comp,weightMap_comp] at hh + exact hh + rcases hc.total a.property b.property with hab|hba + · exact extends_compare hab w z hW + · exact (extends_compare hba z w hW.symm).symm + +noncomputable def unionMap : C(OrderWeights (unionCarrier C),OrderWeights A) := + (weightMapGlue (unionIncl C) (unionLocal C) (union_map_cover C hc hne) (union_compatible C hc)).comp + ⟨fun w=>((),w),continuous_const.prodMk continuous_id⟩ + +lemma unionMap_on (a:C) (w:OrderWeights a.val.carrier) : + unionMap C hc hne (weightMap (unionIncl C a) w)=a.val.map w := + weightMapGlueValue_on (unionIncl C) (unionLocal C) (union_map_cover C hc hne) (union_compatible C hc) a ((),w) + +noncomputable def union : WeightRetractionPiece r A where + carrier:=unionCarrier C + base:=by + obtain ⟨a,ha⟩:=hne + exact fun x hx=>⟨a,ha,a.base hx⟩ + down:=by + intro x y hx h + obtain ⟨a,ha,hx⟩:=hx + exact ⟨a,ha,a.down hx h⟩ + map:=unionMap C hc hne + retract:=by + intro w + obtain ⟨a,ha⟩:=hne + have he:weightSubset A (unionCarrier C) (fun x hx=>⟨a,ha,a.base hx⟩)= + (unionIncl C ⟨a,ha⟩).comp (weightSubset A a.carrier a.base):=rfl + rw [he,← weightMap_comp] + exact (unionMap_on C hc (show C.Nonempty from ⟨a,ha⟩) ⟨a,ha⟩ _).trans (a.retract w) + +lemma extends_union {a:WeightRetractionPiece r A} (ha:a∈C) : a.Extends (union C hc hne) := + ⟨subset_union C ha,fun w=>unionMap_on C hc hne ⟨a,ha⟩ w⟩ + +end WeightRetractionPiece +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightUpperCone.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightUpperCone.lean new file mode 100644 index 0000000000000000000000000000000000000000..d9862bb271b7cf3c0735357a63afd1b30bc38432 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightUpperCone.lean @@ -0,0 +1,129 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Geometry.OrbitHalfspace +import OAI.Topology.ArtinGroups.Realizations.AffineWeightMax +import OAI.Topology.ArtinGroups.Realizations.FiniteWeightsCompact + +namespace OAI + +namespace HarmonicArtin +open scoped BigOperators unitInterval + +attribute [local instance] Classical.decEq Classical.propDecidable + +noncomputable def weightUpperCone {P : Type*} [PartialOrder P] (c : P) (w : OrderWeights P) + (hc : ∀ p ∈ w.weights.support,p ≤ c) (t : unitInterval) : OrderWeights P := + coneWeights (weightInclusion (Set.Iic c)) c (fun q => Or.inl q.property) t + (weightRestrict (Set.Iic c) w (fun p hp => hc p hp)) + +lemma weightUpperCone_support {P : Type*} [PartialOrder P] (c : P) (w : OrderWeights P) + (hc : ∀ p ∈ w.weights.support,p ≤ c) (t : unitInterval) : + ∀ p ∈ (weightUpperCone c w hc t).weights.support,p ≤ c := by + intro p hp + rcases Finset.mem_insert.mp (coneWeights_support _ _ _ _ _ hp) with hp|hp + · exact hp ▸ le_rfl + · obtain ⟨q,hq,rfl⟩ := Finset.mem_image.mp hp + exact q.property + +lemma weightUpperCone_value {P E : Type*} [PartialOrder P] [AddCommGroup E] [Module ℝ E] + (z : P → E) (c : P) (w : OrderWeights P) (hc : ∀ p ∈ w.weights.support,p ≤ c) + (t : unitInterval) : weightAffineValue z (weightUpperCone c w hc t) = + (1-t.val) • weightAffineValue z w + t.val • z c := by + unfold weightUpperCone + rw [weightAffineValue_cone] + have h := weightRestrict_map (Set.Iic c) w (fun p hp => hc p hp) + exact congrArg (fun v => (1-t.val) • weightAffineValue z v + t.val • z c) h + +namespace Geometric +open CoxeterExchange _root_.Matrix _root_.OAI.Matrix + +variable {S : Type*} (M : CoxeterMatrix S) [Fintype S] [DecidableEq S] [Finite M.Group] + +noncomputable def fullCoxeterFace : CoxeterCellFace M := + ⟨(1,Set.univ),fun v _ => by simp only [M.toCoxeterSystem.length_one]; exact Nat.zero_le _⟩ + +omit [Fintype S] [DecidableEq S] [Finite M.Group] in +lemma fullCoxeterFace_vertices : (fullCoxeterFace M).vertexSet = Set.univ := by + ext w + simp only [Set.mem_univ,iff_true] + change 1⁻¹*w ∈ coxeterParabolic M Set.univ + rw [inv_one,one_mul] + obtain ⟨u,hu,rfl⟩ := M.toCoxeterSystem.exists_isReduced w + exact (mem_parabolic_iff_reduced_word M.toCoxeterSystem Set.univ _).mpr + ⟨u,by intros; trivial,hu,rfl⟩ + +lemma fullCoxeterFace_polytope : facePolytope M (fullCoxeterFace M) = permutahedron M := by + rw [facePolytope,fullCoxeterFace_vertices,Set.image_univ] + rfl + +omit [Finite M.Group] in +lemma face_le_full (c : CoxeterCellFace M) : c ≤ fullCoxeterFace M := by + rw [CoxeterCellFace.le_iff_vertices,fullCoxeterFace_vertices] + exact Set.subset_univ _ + +theorem face_barycentric_surjective (c : CoxeterCellFace M) (x : S → ℝ) + (hx : x ∈ facePolytope M c) : + ∃ w : OrderWeights (CoxeterCellFace M), + (∀ p ∈ w.weights.support,p ≤ c) ∧ weightAffineValue (faceCenter M) w = x := by + induction c using (wellFounded_lt (α := CoxeterCellFace M)).induction generalizing x with + | h c ih => + by_cases he : x = faceCenter M c + · refine ⟨weightVertex c,?_,?_⟩ + · intro p hp + have hp' : p = c := Finset.mem_singleton.mp (Finsupp.support_single_subset hp) + exact hp' ▸ le_rfl + · rw [weightAffineValue_vertex,he] + · obtain ⟨d,y,t,hd,hy,ht,ht1,hx⟩ := face_boundary_step M c x hx he + obtain ⟨w,hw,hval⟩ := ih d hd y hy + have hc : ∀ p ∈ w.weights.support,p ≤ c := fun p hp => (hw p hp).trans hd.le + let u : unitInterval := ⟨1-t,by linarith,by linarith⟩ + refine ⟨weightUpperCone c w hc u,weightUpperCone_support c w hc u,?_⟩ + rw [weightUpperCone_value,hval] + change (1-(1-t)) • y+(1-t) • faceCenter M c=x + rw [sub_sub_cancel,add_comm,←hx] + +lemma barycentric_point_mem (w : OrderWeights (CoxeterCellFace M)) : + weightAffineValue (faceCenter M) w ∈ permutahedron M := by + apply weightAffineValue_mem _ w _ (convex_convexHull ℝ _) + intro p _ + exact (facePolytope_eq_level M p ▸ faceCenter_mem M p).1 + +noncomputable def permutahedronBarycentric : OrderWeights (CoxeterCellFace M) → permutahedron M := + fun w => ⟨weightAffineValue (faceCenter M) w,barycentric_point_mem M w⟩ + +lemma permutahedronBarycentric_continuous : Continuous (permutahedronBarycentric M) := by + let := Fintype.ofFinite (CoxeterCellFace M) + exact (weightAffineValue_continuous (faceCenter M)).subtype_mk _ + +lemma permutahedronBarycentric_bijective : Function.Bijective (permutahedronBarycentric M) := by + let := Fintype.ofFinite (CoxeterCellFace M) + constructor + · intro x y h + exact weightAffineValue_injective (faceCenter M) (faceCovector M) (faceLevel M) + (faceCenter_covector_le M) (faceCenter_covector_eq_iff M) (congrArg Subtype.val h) + · intro x + obtain ⟨w,_,hw⟩ := face_barycentric_surjective M (fullCoxeterFace M) x.val + ((fullCoxeterFace_polytope M).symm ▸ x.property) + exact ⟨w,Subtype.ext hw⟩ + +noncomputable def permutahedronBarycentricHomeomorph : + OrderWeights (CoxeterCellFace M) ≃ₜ permutahedron M := + (show Continuous (Equiv.ofBijective (permutahedronBarycentric M) + (permutahedronBarycentric_bijective M)) from permutahedronBarycentric_continuous M).homeoOfEquivCompactToT2 + +lemma permutahedronBarycentricHomeomorph_apply (w : OrderWeights (CoxeterCellFace M)) : + (permutahedronBarycentricHomeomorph M w).val = weightAffineValue (faceCenter M) w := rfl + +lemma barycentric_point_face_iff (w : OrderWeights (CoxeterCellFace M)) (c : CoxeterCellFace M) : + weightAffineValue (faceCenter M) w ∈ facePolytope M c ↔ ∀ p ∈ w.weights.support,p ≤ c := by + let := Fintype.ofFinite (CoxeterCellFace M) + rw [facePolytope_eq_level] + change (weightAffineValue (faceCenter M) w ∈ permutahedron M ∧ + faceCovector M c (weightAffineValue (faceCenter M) w) = faceLevel M c) ↔ _ + rw [and_iff_right (barycentric_point_mem M w)] + rw [weightAffineValue_eq_iff _ _ _ _ (fun p => faceCenter_covector_le M p c)] + simp only [faceCenter_covector_eq_iff] + +end Geometric +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightVertexRetract.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightVertexRetract.lean new file mode 100644 index 0000000000000000000000000000000000000000..800435c804eb88535b11b2fd7316152205c07f08 --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightVertexRetract.lean @@ -0,0 +1,94 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Realizations.WeightAttach +import OAI.Topology.ArtinGroups.Harmonic.LateDelay + +namespace OAI + +namespace HarmonicArtin +open scoped unitInterval + +universe u +variable {P:Type u} [PartialOrder P] (v:P) + (c:OrderWeights (WeightLink v)) + (H:ContinuousMap.Homotopy (ContinuousMap.id _) (ContinuousMap.const _ c)) + +noncomputable def weightVertexRetract : C(OrderWeights P,OrderWeights (WeightOld v)) := + (coneAttachmentRetract (weightLinkMap v) c H).comp ⟨(weightAttachHomeomorph v c).symm,(weightAttachHomeomorph v c).symm.continuous⟩ + +lemma weightVertexRetract_old (w:OrderWeights (WeightOld v)) : + weightVertexRetract v c H (weightOldMap v w)=w := by + change coneAttachmentRetract _ c H ((weightAttachEquiv v c).symm (weightOldMap v w))=w + rw [weightAttachEquiv_symm_old] + rfl + +noncomputable def weightVertexDeformation : + ContinuousMap.HomotopyRel (ContinuousMap.id (OrderWeights P)) + ((weightOldMap v).comp (weightVertexRetract v c H)) (Set.range (weightOldMap v)) where + toFun p:=weightAttach v (coneAttachmentDeformation (weightLinkMap v) c H + (p.1,(weightAttachHomeomorph v c).symm p.2)) + continuous_toFun:=(weightAttach v).continuous.comp + ((coneAttachmentDeformation (weightLinkMap v) c H).continuous.comp + (continuous_fst.prodMk ((weightAttachHomeomorph v c).symm.continuous.comp continuous_snd))) + map_zero_left:=by + intro w + rw [(coneAttachmentDeformation (weightLinkMap v) c H).apply_zero] + exact (weightAttachHomeomorph v c).apply_symm_apply w + map_one_left:=by + intro w + rw [(coneAttachmentDeformation (weightLinkMap v) c H).apply_one] + rfl + prop' t w hw:=by + obtain ⟨a,rfl⟩:=hw + change weightAttach v (coneAttachmentDeformation (weightLinkMap v) c H + (t,(weightAttachEquiv v c).symm (weightOldMap v a)))=_ + rw [weightAttachEquiv_symm_old] + rw [(coneAttachmentDeformation (weightLinkMap v) c H).eq_fst t ⟨a,rfl⟩] + rfl + +noncomputable def weightVertexDelay (v:P) : C(OrderWeights P,I) where + toFun w:=⟨w.weights v/2,by + constructor + · exact div_nonneg (w.nonneg v) (by norm_num) + · have hh:=weight_le_one w v;linarith⟩ + continuous_toFun:=by + apply Continuous.subtype_mk + exact (weightEval_continuous v).div_const 2 + +lemma weightVertexDelay_lt (w:OrderWeights P) : weightVertexDelay v w<1 := by + change w.weights v/2<1 + have hh:=weight_le_one w v + linarith + +lemma weightVertexDelay_zero (w:OrderWeights P) : + weightVertexDelay v w=0↔w∈Set.range (weightOldMap v) := by + constructor + · intro h + have hz:w.weights v=0:=by + have he:=congrArg Subtype.val h + change w.weights v/2=0 at he + linarith + exact weightOld_surjective_zero w hz + · rintro ⟨w,rfl⟩ + apply Subtype.ext + change (weightOldMap v w).weights v/2=0 + rw [weightOldMap_at,zero_div] + +variable (a:OrderWeights (WeightOld v)) + (K:ContinuousMap.Homotopy (ContinuousMap.id _) (ContinuousMap.const _ a)) + +noncomputable def weightExtendContraction : + ContinuousMap.Homotopy (ContinuousMap.id (OrderWeights P)) + (ContinuousMap.const _ (weightOldMap v a)) := + extendContraction (weightOldMap v) (weightVertexRetract v c H) + (weightVertexDeformation v c H) (weightVertexDelay v) + (weightVertexDelay_lt v) (weightVertexDelay_zero v) a K + +lemma weightExtendContraction_old (t:I) (w:OrderWeights (WeightOld v)) : + weightExtendContraction v c H a K (t,weightOldMap v w)=weightOldMap v (K (t,w)) := + extendContraction_old (weightOldMap v) (weightVertexRetract v c H) + (weightVertexRetract_old v c H) (weightVertexDeformation v c H) + (weightVertexDelay v) (weightVertexDelay_lt v) (weightVertexDelay_zero v) a K t w + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/ArtinGroups/Realizations/WeightedCounts.lean b/lean/OAI/Topology/ArtinGroups/Realizations/WeightedCounts.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e1539829e9849706462000dcd6935d6cc8c3f4d --- /dev/null +++ b/lean/OAI/Topology/ArtinGroups/Realizations/WeightedCounts.lean @@ -0,0 +1,102 @@ +import Mathlib +import OAI.Topology.ArtinGroups.Complexes.PacketPermPreservesOpen +import OAI.Topology.ArtinGroups.Harmonic.FusionPacketLayerExterior +import OAI.Topology.ArtinGroups.Harmonic.IsolatedIterationData +import OAI.Topology.ArtinGroups.Harmonic.IntegerUpward + +namespace OAI + +namespace HarmonicArtin +open ReversibleQuiver ReversibleQuiver.Zigzag ReversibleQuiver.Zigzag.BasedComplex +open _root_.Matrix _root_.OAI.Matrix +open scoped BigOperators + +attribute [local instance] Classical.decEq Classical.propDecidable +variable {S:Type} [Fintype S] [LinearOrder S] {M:CoxeterMatrix S} +local notation "m" => fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "hdiag" => coxeterFusionEdge_diag M +local notation "hm" => (fun e=>le_trans (by norm_num) (fusionLabelSize_ge_four M e)) +local notation "Q" => fusionQuiver m d hd +local notation "O" => fusionPacketOrbit m d hd hdiag +local notation "μ" => fusionOrbitMultiplicity m d hd hdiag hm +local notation "T" => fusionPacketPerm m d hd hdiag (K:=ℂ) +local notation "hn" => fusionQuiver_no_loops m d hd hdiag + +namespace IsolatedIterationData +variable (D:IsolatedIterationData M) + +lemma weighted_counts (z:List ((S⊕Unit)×Bool)) (k:ℤ) : + (∑ H,fusionWeight m H • classTotalVector Q (classLayer Q k (O z D.s H)))= + fusionFold m (μ z D.s k) := by + rw [← fusionOrbitWeightedVector_class] + exact fusionOrbitWeightedVector_eq m d hd hdiag hm z D.s k + +lemma unshifted (z:List ((S⊕Unit)×Bool)) (j:D.J) (k:ℤ) + (ht:∀ H L c,classLayerTopDimension Q (k-1) (.inl j,L) c (O z D.s H)=0) : + ∀ H,classLayer Q k (O ((.inl j,true)::z) D.s H)= + classLayer Q k (T (.inl j) (classLayer Q k (O z D.s H))) := by + intro H + exact classPacketPerm_unshifted_layer Q hn (fun L=>(Sum.inl (j:S),L)) + (fusionColor_orthogonal m d hd hdiag (.inl j)) (O z D.s H) k (ht H) + +lemma openSocle_unshifted (z:List ((S⊕Unit)×Bool)) (j:D.J) (k:ℤ) + (ht:∀ H L c,classLayerTopDimension Q (k-1) (.inl j,L) c (O z D.s H)=0) + (hs:D.openSocle z k) : D.openSocle ((.inl j,true)::z) k := by + intro H α hα c + rw [classLayerSocleDimension_congr_layer Q k (D.unshifted z j k ht H) α c] + apply classPacketPerm_preserves_open_socle Q hn (fun L=>(Sum.inl (j:S),L)) + (fusionColor_orthogonal m d hd hdiag (.inl j)) D.operated + (fun L=>⟨j,j.property,rfl⟩) (classLayer Q k (O z D.s H)) + (classLayer_lowerBound Q (O z D.s H) k) _ α hα c + intro β hβ r + rw [classLayerSocleDimension_layer] + exact hs H β hβ r + +theorem upward (z:List ((S⊕Unit)×Bool)) (hz:D.valid z) (hc:D.capped z) + (j:D.J) (b t:ℤ) (hb:∀ H,ClassLowerBound Q b (O z D.s H)) + (hp:∀ k,k + (∀ H L c,classLayerTopDimension Q k (.inl j,L) c (O z D.s H)=0) ∧ D.openSocle z' k + have hP:∀ k,kclassLayerTopDimension_below Q (O z D.s H) b k (hb H) hk _ c, + D.socle_below z' b k hb' hk⟩ + · intro k _ hkt hprev + have hs':D.openSocle z' k:=D.openSocle_unshifted z j k hprev.1 (hp k hkt) + have hr:=(D.separation z hz hc k (hp k hkt)).2.1 + have hr':=(D.separation z' hz' hc' k hs').2.1 + have htop:=fusionPacket_zero_rows_force_top m d hd hdiag hm (.inl j) k + (O z D.s) hprev.1 (μ z D.s k) (μ z' D.s k) + (D.weighted_counts z k) (D.weighted_counts z' k) + (hr (.inl j) ⟨j,j.property,rfl⟩) (hr' (.inl j) ⟨j,j.property,rfl⟩) + exact ⟨htop.2,hs'⟩ + exact ⟨fun k hk=>(hP k hk).2,fun k hk=>(hP k hk).1, + D.unshifted z j t (hP (t-1) (by omega)).1⟩ + +theorem stage_move (z:List ((S⊕Unit)×Bool)) (hz:D.valid z) (hc:D.capped z) + (j:D.J) (b t:ℤ) (ht:t fusionLabelSize M +local notation "d" => coxeterFusionEdge M +local notation "hd" => coxeterFusionEdge_symm M +local notation "hdiag" => coxeterFusionEdge_diag M +local notation "hm" => (fun e=>le_trans (by norm_num) (fusionLabelSize_ge_four M e)) +local notation "Q" => fusionQuiver m d hd +local notation "O" => fusionPacketOrbit m d hd hdiag +local notation "C" => canonicalFusionLow m d hd hdiag (K:=ℂ) +local notation "μ" => fusionOrbitMultiplicity m d hd hdiag hm +local notation "σ" => canonicalFusionMultiplicity m d hd hdiag hm + +theorem source_weighted_reflected_high (J:Set S) (hJ:IsSpherical M J) + (u:List J) (hu:(restrictedMatrix M J).toCoxeterSystem.IsReduced u) + (z:List ((S⊕Unit)×Bool)) (s:S⊕Unit) (q:ℤ) + (hcap:∀ L,ClassCapOn Q (O z s L) + (closedNeighborhood Q (Set.range (unfoldedInclusion M J))) q) : + μ (negativePrepend (u.map fun j:J=>(Sum.inl (j:S):S⊕Unit)) z) s q= + rowReflectWord (fusionFoldedCartan m d) (u.map fun j:J=>(Sum.inl (j:S):S⊕Unit)).reverse + (μ z s q-σ (u.map fun j:J=>(Sum.inl (j:S):S⊕Unit)) z s q) := by + let w:=u.map fun j:J=>(Sum.inl (j:S):S⊕Unit) + let A:=fun L=>classTotalVector Q (classLayer Q q (O z s L)) + let B:=fun L=>classTotalVector Q (C w q (classLayer Q q (O z s L))) + have hp:∀ L,ClassLowerBound Q q (C w q (classLayer Q q (O z s L))) ∧ + ClassUpperBound Q q (C w q (classLayer Q q (O z s L))) := by + intro label + exact sourceCanonicalLow_pure M J hJ u hu q _ + (classLowerBound_of_representative Q _ (fun index => le_of_eq index.property.symm)) + (classUpperBound_of_representative Q _ (fun index => le_of_eq index.property)) + have hA:(∑ L,fusionWeight m L • A L)=fusionFold m (μ z s q) := by + rw [← fusionOrbitWeightedVector_class,fusionOrbitWeightedVector_eq m d hd hdiag hm] + have hB:(∑ L,fusionWeight m L • B L)=fusionFold m (σ w z s q) := + canonicalFusionMultiplicity_fold m d hd hdiag hm w z s q hp + apply fusionFold_injective m hm + calc + fusionFold m (μ (negativePrepend w z) s q)= + ∑ L,fusionWeight m L • classTotalVector Q + (classLayer Q q (inverseWordAction Q (fusionExpandedWord m w) (O z s L))) := by + rw [← fusionOrbitWeightedVector_eq m d hd hdiag hm,fusionOrbitWeightedVector_class] + simp only [fusionPacketOrbit_negativePrepend] + congr 3 + funext L + congr 9 + exact Subsingleton.elim _ _ + _ = ∑ L,fusionWeight m L • rowReflectWord (unfoldedCartan Q) + (fusionExpandedWord m w).reverse (A L-B L) := by + apply Finset.sum_congr rfl + intro L _ + congr 1 + exact source_capped_reflected_high M J hJ u hu q (O z s L) (hcap L) + _ = rowReflectWord (unfoldedCartan Q) (fusionExpandedWord m w).reverse + ((∑ L,fusionWeight m L • A L)-(∑ L,fusionWeight m L • B L)) := by + rw [← Finset.sum_sub_distrib,rowReflectWord_sum] + apply Finset.sum_congr rfl + intro L _ + rw [← smul_sub,rowReflectWord_smul] + _ = fusionFold m (rowReflectWord (fusionFoldedCartan m d) w.reverse (μ z s q-σ w z s q)) := by + rw [hA,hB,← fusionFold_sub,fusionQuiver_cartan] + exact fusion_reverse_word_intertwining m hm d hdiag w _ + +end HarmonicArtin + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/AlgebraicRoe.lean b/lean/OAI/Topology/CoarseAssembly/AlgebraicRoe.lean new file mode 100644 index 0000000000000000000000000000000000000000..b3fa82e199d51334566dd0933b0f8d84c1242024 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/AlgebraicRoe.lean @@ -0,0 +1,95 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RoeCalculus +import OAI.Topology.CoarseAssembly.LocallyCompactAlgebra + +namespace OAI + +/-! # The algebra of locally compact finite-propagation operators -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.instContinuousStarOperator + +omit [CompleteSpace H] in +theorem PropagationLE.add {T S : Operator X H} {r s : ℝ} + (hT : PropagationLE r T) (hS : PropagationLE s S) : + PropagationLE (max r s) (T + S) := by + intro x y hxy + rw [entry_add, hT x y (lt_of_le_of_lt (le_max_left _ _) hxy), + hS x y (lt_of_le_of_lt (le_max_right _ _) hxy), add_zero] + +omit [CompleteSpace H] in +theorem PropagationLE.smul {T : Operator X H} {r : ℝ} + (hT : PropagationLE r T) (z : ℂ) : PropagationLE r (z • T) := by + intro x y hxy + rw [entry_smul, hT x y hxy, smul_zero] + +theorem Generator.zero : Generator (0 : Operator X H) := by + refine ⟨⟨0, le_rfl, fun x y _ => entry_zero x y⟩, ?_, ?_⟩ + · intro x y + rw [entry_zero] + exact isCompactOperator_zero + · rw [star_zero (Operator X H)] + intro x y + rw [entry_zero] + exact isCompactOperator_zero + +theorem Generator.add {T S : Operator X H} (hT : Generator T) (hS : Generator S) : + Generator (T + S) := by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + obtain ⟨⟨s, hs, hq⟩, hd, hds⟩ := hS + refine ⟨⟨max r s, le_trans hr (le_max_left _ _), hp.add hq⟩, ?_, ?_⟩ + · intro x y + rw [entry_add] + exact (hc x y).add (hd x y) + · rw [star_add T S] + intro x y + rw [entry_add] + exact (hcs x y).add (hds x y) + +theorem Generator.smul {T : Operator X H} (hT : Generator T) (z : ℂ) : Generator (z • T) := by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + refine ⟨⟨r, hr, hp.smul z⟩, ?_, ?_⟩ + · intro x y + rw [entry_smul] + exact (hc x y).smul z + · rw [star_smul] + intro x y + rw [entry_smul] + exact (hcs x y).smul (star z) + +theorem Generator.star {T : Operator X H} (hT : Generator T) : Generator (star T) := by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + exact ⟨⟨r, hr, hp.star⟩, hcs, by simpa only [star_star] using hc⟩ + +theorem Generator.mul (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T S : Operator X H} (hT : Generator T) (hS : Generator S) : Generator (T * S) := by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + obtain ⟨⟨s, hs, hq⟩, hd, hds⟩ := hS + exact ⟨⟨r + s, add_nonneg hr hs, hp.mul finiteBalls hq⟩, + hc.mul_left finiteBalls hq, by + rw [star_mul] + exact hds.mul_left finiteBalls hp.star⟩ + +theorem roe_eq_closure_algebraic + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) : + algebra (X := X) (H := H) = (algebraicRoe (H := H) finiteBalls).topologicalClosure := by + have he : NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T} = + algebraicRoe (H := H) finiteBalls := by + apply le_antisymm + · exact NonUnitalStarAlgebra.adjoin_le (fun _ h => h) + · intro T hT + exact NonUnitalStarAlgebra.subset_adjoin ℂ _ hT + unfold algebra + rw [he] + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/AmpleRipsFamily.lean b/lean/OAI/Topology/CoarseAssembly/AmpleRipsFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..d6138958886cc4e3531010d4990a05ecd50b531d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/AmpleRipsFamily.lean @@ -0,0 +1,52 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsLocalization +import OAI.Topology.CoarseAssembly.SeparableEmbedding +import OAI.Topology.CoarseAssembly.CoefficientIsometry +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary + +namespace OAI + +/-! # Spatial representatives for finite-Rips families on the fixed ample module + +The source Hilbert spaces may vary with the component. Each is embedded +isometrically into ℓ²(ℕ, ℂ), and the operator is extended by the identity. +The compact square defects give one whole-union boundary class. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + +theorem ampleRipsOperator_norm_le (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : ‖ampleRipsOperator r c hπ‖ ≤ ‖c.operator‖ + 4 := by + exact (coefficientExtension_norm_le _ _).trans + (by linarith [ripsSpatialOperator_norm_le r c hπ]) + +theorem ampleRipsOperator_selfAdjoint (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + IsSelfAdjoint (ampleRipsOperator r c hπ) := + coefficientExtension_selfAdjoint _ _ (ripsSpatialOperator_selfAdjoint r c hπ hF) + +theorem ampleRipsOperator_propagation (r : ℝ) (hr : 0 ≤ r) + (c : OddCycle C(Point X r, ℂ)) (hπ : c.representation 1 = 1) : + PropagationLE (r + r) (ampleRipsOperator r c hπ) := + coefficientExtension_propagation _ (add_nonneg hr hr) (ripsSpatialOperator_propagation r hr c hπ) + +theorem ampleRipsOperator_square_compact (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + IsCompactOperator (ampleRipsOperator r c hπ * ampleRipsOperator r c hπ - + (1 : Operator X (lp (fun _ : ℕ => ℂ) 2))) := + coefficientExtension_square_compact _ _ (ripsSpatialOperator_square_compact r c hπ hF) + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/AnalyticFamilyIndex.lean b/lean/OAI/Topology/CoarseAssembly/AnalyticFamilyIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..3d51d627784c7044d44ff17e438a6784756a2d2d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/AnalyticFamilyIndex.lean @@ -0,0 +1,81 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RegularizedRipsRelations + +namespace OAI + +/-! # A whole-union index on the actual analytic K-homology domain + +Restriction homomorphisms into a family of finite Rips function algebras +are explicit parameters. The map descends through every relation of the +original Fredholm-module group, without a countable-additivity assumption. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} {A : Type} [NonUnitalCStarAlgebra A] + +theorem analyticFamilyIndexFree_relation (o : ∀ i, Q i) (hr : 0 ≤ r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (η : ∀ i, C(Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] A) + {z : FreeAbelianGroup (OddCycle A)} (hz : CycleRelation A z) : + analyticFamilyIndexFree o hr χ η z = 0 := by + let := separatedMetric o + cases hz with + | degenerate c h => + simpa only [analyticFamilyIndexFree, FreeAbelianGroup.lift_apply_of] using + regularizedFamily_degenerate (fun i => c.precomp (η i)) + (fun i => h.precomp (η i)) χ o hr + | unitary c d h => + simp only [analyticFamilyIndexFree, map_sub, FreeAbelianGroup.lift_apply_of] + exact sub_eq_zero.mpr (regularizedFamily_unitary _ _ (fun i => h.precomp (η i)) χ o hr) + | directSum c d e h => + simp only [analyticFamilyIndexFree, map_sub, map_add, FreeAbelianGroup.lift_apply_of] + exact sub_eq_zero.mpr (regularizedFamily_directSum _ _ _ (fun i => h.precomp (η i)) χ o hr) + | homotopy h => + simp only [analyticFamilyIndexFree, map_sub, FreeAbelianGroup.lift_apply_of] + exact sub_eq_zero.mpr (regularizedFamily_homotopy (fun i => h.precomp (η i)) χ o hr) + +theorem analyticFamilyIndex_eq_lift (o : ∀ i, Q i) (hr : 0 ≤ r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (η : ∀ i, C(Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] A) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + analyticFamilyIndex o hr χ η = + QuotientAddGroup.lift (relations A) (analyticFamilyIndexFree o hr χ η) + ((AddSubgroup.closure_le _).2 (fun _ hz => analyticFamilyIndexFree_relation o hr χ η hz)) := by + classical + let := separatedMetric o + let : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + dsimp only [analyticFamilyIndex] + split_ifs with h + · rfl + · exact (h ((AddSubgroup.closure_le _).2 + (fun _ hz => analyticFamilyIndexFree_relation o hr χ η hz))).elim + +@[simp] theorem analyticFamilyIndex_class (o : ∀ i, Q i) (hr : 0 ≤ r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (η : ∀ i, C(Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] A) (c : OddCycle A) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + analyticFamilyIndex o hr χ η (cycleClass A c) = + (regularizedFamily (fun i => c.precomp (η i)) χ).boundary o hr := + by + let := separatedMetric o + let : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + have h := DFunLike.congr_fun (analyticFamilyIndex_eq_lift o hr χ η) (cycleClass A c) + exact h.trans (FreeAbelianGroup.lift_apply_of _ _) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/AnalyticKHomology.lean b/lean/OAI/Topology/CoarseAssembly/AnalyticKHomology.lean new file mode 100644 index 0000000000000000000000000000000000000000..b3e17a9c0428590ffad1909d50175338089eb177 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/AnalyticKHomology.lean @@ -0,0 +1,89 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.FredholmModule + +namespace OAI + +/-! +# The odd Fredholm-module group + +The group is formed from actual analytic cycles, modulo degeneracy, unitary +equivalence, orthogonal direct sum and norm homotopy. Pullback of star +representations descends to this quotient. This gives the analytic domain +needed for the subsequent geometric construction; no assembly or nonzero +class is postulated here. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u + +variable (A : Type u) [NonUnitalCStarAlgebra A] + +variable {A} + +theorem relation_zero {z : FreeAbelianGroup (OddCycle A)} (hz : CycleRelation A z) : + (QuotientAddGroup.mk z : OddK A) = 0 := + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz) + +theorem degenerate_zero (c : OddCycle A) (hc : c.Degenerate) : cycleClass A c = 0 := + relation_zero (.degenerate c hc) + +theorem unitary_eq (c d : OddCycle A) (h : c.UnitaryEquivalent d) : + cycleClass A c = cycleClass A d := by + have hz := relation_zero (.unitary c d h) + exact sub_eq_zero.mp (by simpa only [cycleClass, OddK, QuotientAddGroup.mk_sub] using hz) + +theorem directSum_eq (c d e : OddCycle A) (h : c.IsDirectSum d e) : + cycleClass A e = cycleClass A c + cycleClass A d := by + have hz := relation_zero (.directSum c d e h) + exact sub_eq_zero.mp (by simpa only [cycleClass, OddK, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using hz) + +theorem homotopy_eq (h : OddHomotopy A) : + cycleClass A (h.eval start) = cycleClass A (h.eval finish) := by + have hz := relation_zero (.homotopy h) + exact sub_eq_zero.mp (by simpa only [cycleClass, OddK, QuotientAddGroup.mk_sub] using hz) + +variable {B C : Type u} [NonUnitalCStarAlgebra B] [NonUnitalCStarAlgebra C] + +theorem precompFree_relation (φ : B →⋆ₙₐ[ℂ] A) + {z : FreeAbelianGroup (OddCycle A)} (hz : CycleRelation A z) : + precompFree φ z = 0 := by + cases hz with + | degenerate c h => + simpa [precompFree] using degenerate_zero (c.precomp φ) (h.precomp φ) + | unitary c d h => + simpa [precompFree] using sub_eq_zero.mpr + (unitary_eq (c.precomp φ) (d.precomp φ) (h.precomp φ)) + | directSum c d e h => + simpa [precompFree] using sub_eq_zero.mpr + (directSum_eq (c.precomp φ) (d.precomp φ) (e.precomp φ) (h.precomp φ)) + | homotopy h => + simpa [precompFree] using sub_eq_zero.mpr (homotopy_eq (h.precomp φ)) + +@[simp] theorem precomp_cycleClass (φ : B →⋆ₙₐ[ℂ] A) (c : OddCycle A) : + precomp φ (cycleClass A c) = cycleClass B (c.precomp φ) := by + exact FreeAbelianGroup.lift_apply_of _ _ + +theorem hom_ext {D : Type*} [AddCommGroup D] (f g : OddK A →+ D) + (h : ∀ c, f (cycleClass A c) = g (cycleClass A c)) : f = g := by + apply QuotientAddGroup.addMonoidHom_ext + exact FreeAbelianGroup.lift_ext _ _ h + +@[simp] theorem precomp_id : precomp (NonUnitalStarAlgHom.id ℂ A) = AddMonoidHom.id (OddK A) := by + apply hom_ext + intro c + simp + +theorem precomp_comp (φ : B →⋆ₙₐ[ℂ] A) (ψ : C →⋆ₙₐ[ℂ] B) : + precomp (φ.comp ψ) = (precomp ψ).comp (precomp φ) := by + apply hom_ext + intro c + simp + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Assembly.lean b/lean/OAI/Topology/CoarseAssembly/Assembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..08adbe77efaab4c86ecbb6135d410feae7378724 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Assembly.lean @@ -0,0 +1,78 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsRealization +import OAI.Topology.CoarseAssembly.NonUnitalK1 +import OAI.Topology.CoarseAssembly.RoeTransfer + +namespace OAI + +/-! +# Compatible analytic indices and their coarsening limit + +The scale-index homomorphisms and their compatibility are the precise +published input from Willett--Yu, *Higher Index Theory*, §§5.1, 6.7, 7.1--7.2 +(with errata 30--31). Their source is the Fredholm-module group of the actual +C₀ algebra; their target is the topological K₁ of the actual nonunital algebra. +The induced coarse map is constructed here by the universal property of the +direct limit. No geometric detection, filling or transfer conclusion is part +of this input. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u v + +namespace CoarseningMorphism + +variable {C D : Coarsening.{u}} + +theorem pushforward_compatible (f : CoarseningMorphism C D) (r s : ℕ) (h : r ≤ s) : + (pushforward (f.atScale s)).comp (C.map r s h) = + (D.map r s h).comp (pushforward (f.atScale r)) := by + change (pushforward (f.atScale s)).comp (pushforward (C.inclusion r s h)) = + (pushforward (D.inclusion r s h)).comp (pushforward (f.atScale r)) + rw [← pushforward_comp, ← pushforward_comp, f.compatible] + +def homologyMap (f : CoarseningMorphism C D) : C.Homology →+ D.Homology := + AddCommGroup.DirectLimit.map (fun r => pushforward (f.atScale r)) + f.pushforward_compatible + +@[simp] theorem homologyMap_of (f : CoarseningMorphism C D) (r : ℕ) + (a : LocallyFiniteK1 (C.space r)) : + f.homologyMap (C.of r a) = D.of r (pushforward (f.atScale r) a) := + AddCommGroup.DirectLimit.map_apply_of _ _ _ + +end CoarseningMorphism + +namespace CompatibleIndexFamily + +variable {C D : Coarsening.{u}} {A B : Type v} +variable [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B] + +@[simp] theorem assembly_of (I : CompatibleIndexFamily C A) (r : ℕ) + (a : LocallyFiniteK1 (C.space r)) : I.assembly (C.of r a) = I.atScale r a := + AddCommGroup.DirectLimit.lift_of _ _ _ _ _ + +/-- Scale-level analytic naturality passes to the actual coarsening limit. -/ +theorem assembly_natural (I : CompatibleIndexFamily C A) (J : CompatibleIndexFamily D B) + (f : CoarseningMorphism C D) (φ : A →⋆ₙₐ[ℂ] B) + (hnat : ∀ r, (J.atScale r).comp (pushforward (f.atScale r)) = + (OperatorKTheory.map φ).comp (I.atScale r)) : + J.assembly.comp f.homologyMap = (OperatorKTheory.map φ).comp I.assembly := by + apply AddCommGroup.DirectLimit.hom_ext + intro r + apply AddMonoidHom.ext + intro a + change J.assembly (f.homologyMap (C.of r a)) = + OperatorKTheory.map φ (I.assembly (C.of r a)) + simp only [CoarseningMorphism.homologyMap_of, assembly_of] + exact DFunLike.congr_fun (hnat r) a + +end CompatibleIndexFamily + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Averaging.lean b/lean/OAI/Topology/CoarseAssembly/Averaging.lean new file mode 100644 index 0000000000000000000000000000000000000000..a4e650fc78ffcbc5928bcbb18ec90088f52e34a2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Averaging.lean @@ -0,0 +1,152 @@ +import OAI.Topology.CoarseAssembly.FiniteFiberMaps +import Mathlib.Analysis.CStarAlgebra.ContinuousLinearMap +import OAI.Topology.CoarseAssembly.CongruenceMaps + +namespace OAI + +/-! # The actual finite-quotient averaging operators + +Normalized left translations and their lazy average act on the spatial +fiber Hilbert spaces. They are contractions fixing the constant subspace. +The strict norm bound off constants is kept as the precise published +Kazhdan-gap input, rather than assuming any Roe transfer conclusion. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +variable (Q : Type*) [Fintype Q] [Nonempty Q] + +def constantProjection : lp (fun _ : Q => H) 2 →L[ℂ] lp (fun _ : Q => H) 2 := + (fiberConstantIsometry Q).toContinuousLinearMap.comp + (fiberConstantIsometry Q).toContinuousLinearMap.adjoint + +theorem constantProjection_idempotent : + constantProjection (H := H) Q * constantProjection Q = constantProjection Q := by + ext x + simp [constantProjection] + +theorem constantProjection_norm_le : ‖constantProjection (H := H) Q‖ ≤ 1 := by + apply (ContinuousLinearMap.opNorm_comp_le _ _).trans + rw [LinearIsometryEquiv.norm_map] + have h := (fiberConstantIsometry (H := H) Q).norm_toContinuousLinearMap_le + nlinarith [norm_nonneg (fiberConstantIsometry (H := H) Q).toContinuousLinearMap] + +variable [Group Q] + +def leftTranslation (g : Q) : lp (fun _ : Q => H) 2 ≃ₗᵢ[ℂ] lp (fun _ : Q => H) 2 := + reindexFiber (Equiv.mulLeft g) + +omit [CompleteSpace H] [Nonempty Q] in +theorem leftTranslation_constant (g : Q) (h : H) : + leftTranslation Q g (fiberConstant Q h) = fiberConstant Q h := + reindexFiber_constant _ _ + +theorem leftTranslation_projection (g : Q) : + (leftTranslation (H := H) Q g).toLinearIsometry.toContinuousLinearMap * + constantProjection Q = constantProjection Q := by + apply ContinuousLinearMap.ext + intro x + change leftTranslation (H := H) Q g (fiberConstant (H := H) Q _) = + fiberConstant (H := H) Q _ + exact leftTranslation_constant (H := H) Q g _ + +theorem projection_leftTranslation (g : Q) : + constantProjection (H := H) Q * + (leftTranslation Q g).toLinearIsometry.toContinuousLinearMap = constantProjection Q := by + have he : (leftTranslation (H := H) Q g).toLinearIsometry.toContinuousLinearMap.adjoint = + (leftTranslation Q g⁻¹).toLinearIsometry.toContinuousLinearMap := by + apply ContinuousLinearMap.ext + intro x + apply ext_inner_right ℂ + intro y + rw [ContinuousLinearMap.adjoint_inner_left] + have hi := (leftTranslation (H := H) Q g).inner_map_map + ((leftTranslation Q g⁻¹) x) y + have hx : leftTranslation Q g (leftTranslation Q g⁻¹ x) = x := by + apply lp.ext + funext q + simp [leftTranslation, reindexFiber_apply] + rw [hx] at hi + exact hi + have hs := congrArg star (leftTranslation_projection (H := H) Q g⁻¹) + simpa only [star_mul, ContinuousLinearMap.star_eq_adjoint, constantProjection, + ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.adjoint_adjoint, ← he] using hs + +variable (S : Finset ArithmeticGroup) + +def meanTranslation (k : ℕ) : + lp (fun _ : Quotient k => H) 2 →L[ℂ] lp (fun _ : Quotient k => H) 2 := + ((S.card : ℂ)⁻¹) • ∑ s ∈ S, (leftTranslation (Quotient k) (reduce k s)).toLinearIsometry.toContinuousLinearMap + +def lazyAverage (k : ℕ) : + lp (fun _ : Quotient k => H) 2 →L[ℂ] lp (fun _ : Quotient k => H) 2 := + (1 / 2 : ℂ) • (1 + meanTranslation S k) + +theorem meanTranslation_norm_le (k : ℕ) : ‖meanTranslation (H := H) S k‖ ≤ 1 := by + have hsum : ‖∑ s ∈ S, + (leftTranslation (H := H) (Quotient k) (reduce k s)).toLinearIsometry.toContinuousLinearMap‖ ≤ + (S.card : ℝ) := by + apply (norm_sum_le S (fun s => + (leftTranslation (H := H) (Quotient k) (reduce k s)).toLinearIsometry.toContinuousLinearMap)).trans + calc + _ ≤ ∑ _s ∈ S, (1 : ℝ) := Finset.sum_le_sum (fun s _ => + (leftTranslation (H := H) (Quotient k) (reduce k s)).toLinearIsometry.norm_toContinuousLinearMap_le) + _ = _ := by simp + by_cases hS : S.card = 0 + · change ‖(((S.card : ℂ)⁻¹) • _)‖ ≤ (1 : ℝ) + simp only [hS, Nat.cast_zero, inv_zero, zero_smul, norm_zero] + exact (zero_le_one : (0 : ℝ) ≤ 1) + · have hpos : (0 : ℝ) < S.card := by exact_mod_cast Nat.pos_of_ne_zero hS + change ‖((S.card : ℂ)⁻¹) • (∑ s ∈ S, + (leftTranslation (H := H) (Quotient k) (reduce k s)).toLinearIsometry.toContinuousLinearMap)‖ ≤ 1 + rw [norm_smul, norm_inv, Complex.norm_natCast] + exact (mul_le_mul_of_nonneg_left hsum (inv_nonneg.mpr hpos.le)).trans_eq + (inv_mul_cancel₀ (ne_of_gt hpos)) + +theorem lazyAverage_norm_le (k : ℕ) : ‖lazyAverage (H := H) S k‖ ≤ 1 := by + have h := norm_add_le (1 : lp (fun _ : Quotient k => H) 2 →L[ℂ] _) (meanTranslation (H := H) S k) + have hi : ‖(1 : lp (fun _ : Quotient k => H) 2 →L[ℂ] _)‖ ≤ 1 := + ContinuousLinearMap.norm_id_le + have hm := meanTranslation_norm_le (H := H) S k + change ‖(1 / 2 : ℂ) • (1 + meanTranslation (H := H) S k)‖ ≤ 1 + rw [norm_smul] + norm_num only [norm_div, norm_one, Complex.norm_ofNat] + linarith + +theorem lazyAverage_projection (hS : S.Nonempty) (k : ℕ) : + lazyAverage (H := H) S k * constantProjection (H := H) (Quotient k) = + constantProjection (H := H) (Quotient k) := by + have hcard : (S.card : ℂ) ≠ 0 := by exact_mod_cast hS.card_pos.ne' + have hm : meanTranslation (H := H) S k * constantProjection (H := H) (Quotient k) = + constantProjection (H := H) (Quotient k) := by + simp only [meanTranslation, smul_mul_assoc, Finset.sum_mul, leftTranslation_projection, + Finset.sum_const, ← Nat.cast_smul_eq_nsmul ℂ] + rw [← mul_smul, inv_mul_cancel₀ hcard, one_smul] + rw [lazyAverage, smul_mul_assoc, add_mul, one_mul, hm] + rw [← two_smul ℂ, smul_smul] + norm_num + +theorem projection_lazyAverage (hS : S.Nonempty) (k : ℕ) : + constantProjection (H := H) (Quotient k) * lazyAverage S k = + constantProjection (Quotient k) := by + have hcard : (S.card : ℂ) ≠ 0 := by exact_mod_cast hS.card_pos.ne' + have hm : constantProjection (H := H) (Quotient k) * meanTranslation S k = + constantProjection (Quotient k) := by + simp only [meanTranslation, mul_smul_comm, Finset.mul_sum, projection_leftTranslation, + Finset.sum_const, ← Nat.cast_smul_eq_nsmul ℂ] + rw [← mul_smul, inv_mul_cancel₀ hcard, one_smul] + rw [lazyAverage, mul_smul_comm, mul_add, mul_one, hm] + rw [← two_smul ℂ, smul_smul] + norm_num + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/AveragingEnergy.lean b/lean/OAI/Topology/CoarseAssembly/AveragingEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..08510e46daa9e49813e72c5808326e3932fad071 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/AveragingEnergy.lean @@ -0,0 +1,142 @@ +import OAI.Topology.CoarseAssembly.SpatialAveraging + +namespace OAI + +/-! # Energy estimate for the actual lazy averages -/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def translationEnergy (S : Finset ArithmeticGroup) (k : ℕ) + (x : lp (fun _ : Quotient k => H) 2) : ℝ := + ∑ s ∈ S, ‖leftTranslation (Quotient k) (reduce k s) x - x‖ ^ 2 + +omit [CompleteSpace H] in +theorem translationEnergy_nonneg (S : Finset ArithmeticGroup) (k : ℕ) + (x : lp (fun _ : Quotient k => H) 2) : 0 ≤ translationEnergy S k x := + Finset.sum_nonneg (fun _ _ => sq_nonneg _) + +omit [CompleteSpace H] in +theorem translation_real_inner (k : ℕ) (s : ArithmeticGroup) + (x : lp (fun _ : Quotient k => H) 2) : + (inner ℂ x (leftTranslation (Quotient k) (reduce k s) x)).re = + ‖x‖ ^ 2 - ‖leftTranslation (Quotient k) (reduce k s) x - x‖ ^ 2 / 2 := by + have h := norm_sub_sq (𝕜 := ℂ) (leftTranslation (Quotient k) (reduce k s) x) x + rw [(leftTranslation (Quotient k) (reduce k s)).norm_map, inner_re_symm] at h + change ‖leftTranslation (Quotient k) (reduce k s) x - x‖ ^ 2 = + ‖x‖ ^ 2 - 2 * (inner ℂ x (leftTranslation (Quotient k) (reduce k s) x)).re + ‖x‖ ^ 2 at h + linarith + +omit [CompleteSpace H] in +theorem meanTranslation_real_inner (S : Finset ArithmeticGroup) (hS : S.Nonempty) + (k : ℕ) (x : lp (fun _ : Quotient k => H) 2) : + (inner ℂ x (meanTranslation S k x)).re = + ‖x‖ ^ 2 - translationEnergy S k x / (2 * S.card) := by + have hcard : (S.card : ℝ) ≠ 0 := by exact_mod_cast hS.card_pos.ne' + have hm : meanTranslation S k x = (S.card : ℂ)⁻¹ • + ∑ s ∈ S, leftTranslation (Quotient k) (reduce k s) x := by + simp only [meanTranslation, smul_apply, sum_apply] + rfl + rw [hm, inner_smul_right] + have hc : (S.card : ℂ)⁻¹ = ((S.card : ℝ)⁻¹ : ℂ) := by simp + rw [hc] + simp only [← Complex.ofReal_inv] + simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero, + inner_sum, Complex.re_sum, translation_real_inner, Finset.sum_sub_distrib, + Finset.sum_const, nsmul_eq_mul, ← Finset.sum_div] + unfold translationEnergy + field_simp + +/-- Laziness turns the displacement-energy bound into a norm-square loss. -/ +theorem lazyAverage_norm_sq_le (S : Finset ArithmeticGroup) (hS : S.Nonempty) + (k : ℕ) (x : lp (fun _ : Quotient k => H) 2) : + ‖lazyAverage S k x‖ ^ 2 ≤ + ‖x‖ ^ 2 - translationEnergy S k x / (4 * S.card) := by + have hm : ‖meanTranslation S k x‖ ≤ ‖x‖ := + (ContinuousLinearMap.le_opNorm _ _).trans + (mul_le_of_le_one_left (norm_nonneg _) (meanTranslation_norm_le S k)) + have he := meanTranslation_real_inner S hS k x + have ha : lazyAverage S k x = (1 / 2 : ℂ) • (x + meanTranslation S k x) := rfl + rw [ha, norm_smul, mul_pow, norm_add_sq (𝕜 := ℂ)] + norm_num only [norm_div, norm_one, Complex.norm_ofNat] + have hdiv : translationEnergy S k x / (4 * S.card) = + (translationEnergy S k x / (2 * S.card)) / 2 := by ring + rw [hdiv] + change ‖meanTranslation S k x‖ ≤ ‖x‖ at hm + change RCLike.re (inner ℂ x (meanTranslation S k x)) = + ‖x‖ ^ 2 - translationEnergy S k x / (2 * S.card) at he + nlinarith [norm_nonneg (meanTranslation S k x), norm_nonneg x] + +variable (Q : Type*) [Fintype Q] [Nonempty Q] + +theorem constantProjection_complement_zero (x : lp (fun _ : Q => H) 2) : + constantProjection Q (x - constantProjection Q x) = 0 := by + rw [map_sub] + have h := DFunLike.congr_fun (constantProjection_idempotent (H := H) Q) x + change constantProjection Q (constantProjection Q x) = constantProjection Q x at h + rw [h, sub_self] + +theorem constantProjection_complement_norm_le (x : lp (fun _ : Q => H) 2) : + ‖x - constantProjection Q x‖ ≤ ‖x‖ := by + let U := (fiberConstantIsometry (H := H) Q).toContinuousLinearMap + have hi : inner ℂ x (constantProjection Q x) = inner ℂ (U.adjoint x) (U.adjoint x) := by + exact (ContinuousLinearMap.adjoint_inner_left U (U.adjoint x) x).symm + have hn : ‖constantProjection Q x‖ = ‖U.adjoint x‖ := + (fiberConstantIsometry (H := H) Q).norm_map (U.adjoint x) + have hs := norm_sub_sq (𝕜 := ℂ) x (constantProjection Q x) + change ‖x - constantProjection Q x‖ ^ 2 = + ‖x‖ ^ 2 - 2 * (inner ℂ x (constantProjection Q x)).re + ‖constantProjection Q x‖ ^ 2 at hs + have hr : (inner ℂ (U.adjoint x) (U.adjoint x)).re = ‖U.adjoint x‖ ^ 2 := + (norm_sq_eq_re_inner (𝕜 := ℂ) (U.adjoint x)).symm + rw [hi, hn, hr] at hs + nlinarith [norm_nonneg (x - constantProjection Q x), norm_nonneg x, + sq_nonneg ‖U.adjoint x‖] + +/-- A uniform energy estimate off the constants implies the precise norm +contraction used by the spatial transfer. -/ +theorem uniformAveragingGap_of_energy (S : Finset ArithmeticGroup) (hS : S.Nonempty) + (ε : ℝ) (hε : 0 < ε) (hεcard : ε ≤ 4 * S.card) + (henergy : ∀ (k : ℕ) (x : lp (fun _ : Quotient k => H) 2), + constantProjection (Quotient k) x = 0 → + ε * ‖x‖ ^ 2 ≤ translationEnergy S k x) : UniformAveragingGap S H := by + have hd : 0 < (4 : ℝ) * S.card := mul_pos (by norm_num) (by exact_mod_cast hS.card_pos) + have hdv : 0 < ε / (4 * S.card) := div_pos hε hd + have hn : 0 ≤ 1 - ε / (4 * S.card) := sub_nonneg.mpr ((div_le_one hd).2 hεcard) + let c := Real.sqrt (1 - ε / (4 * S.card)) + have hc : 0 ≤ c := Real.sqrt_nonneg _ + have hcs : c ^ 2 = 1 - ε / (4 * S.card) := Real.sq_sqrt hn + have hclt : c < 1 := by nlinarith + have hb (k : ℕ) (x : lp (fun _ : Quotient k => H) 2) + (hx : constantProjection (Quotient k) x = 0) : ‖lazyAverage S k x‖ ≤ c * ‖x‖ := by + have hl := lazyAverage_norm_sq_le S hS k x + have he := div_le_div_of_nonneg_right (henergy k x hx) hd.le + have heq : ε * ‖x‖ ^ 2 / (4 * S.card) = (ε / (4 * S.card)) * ‖x‖ ^ 2 := by ring + rw [heq] at he + apply (sq_le_sq₀ (norm_nonneg _) (mul_nonneg hc (norm_nonneg _))).1 + rw [mul_pow, hcs] + nlinarith + refine ⟨c, hc, hclt, ?_⟩ + intro k + apply ContinuousLinearMap.opNorm_le_bound _ hc + intro x + let y := x - constantProjection (Quotient k) x + have hy : constantProjection (Quotient k) y = 0 := constantProjection_complement_zero _ x + have hm := DFunLike.congr_fun (lazyAverage_projection (H := H) S hS k) x + change lazyAverage S k (constantProjection (Quotient k) x) = constantProjection (Quotient k) x at hm + have heq : (lazyAverage (H := H) S k - constantProjection (H := H) (Quotient k)) x = lazyAverage S k y := by + change lazyAverage S k x - constantProjection (Quotient k) x = + lazyAverage S k (x - constantProjection (Quotient k) x) + rw [map_sub, hm] + rw [heq] + exact (hb k y hy).trans (mul_le_mul_of_nonneg_left (constantProjection_complement_norm_le _ x) hc) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/AveragingPropagation.lean b/lean/OAI/Topology/CoarseAssembly/AveragingPropagation.lean new file mode 100644 index 0000000000000000000000000000000000000000..786684a1374646070e7d9b7ae0f61a5c8ca0375b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/AveragingPropagation.lean @@ -0,0 +1,160 @@ +import OAI.Topology.CoarseAssembly.SpatialAveraging + +namespace OAI + +/-! # Finite propagation of the averaging powers + +The left regular generators move at most one graph edge. The global lazy +average therefore has propagation one, and its powers have the expected +linear propagation bound on the actual separated union. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence DiscreteRoe + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [CompleteSpace H] in +private theorem translation_single_zero {Q : Type*} [Fintype Q] [Group Q] + [DecidableEq Q] (g q r : Q) (hqr : q ≠ g * r) (v : H) : + leftTranslation Q g (lp.single 2 r v) q = 0 := by + change lp.single (E := fun _ : Q => H) 2 r v (g⁻¹ * q) = 0 + apply lp.single_apply_ne + intro he + apply hqr + calc + q = g * (g⁻¹ * q) := by group + _ = g * r := by rw [he] + +omit [CompleteSpace H] in +private theorem lazyAverage_single_zero (S : Finset ArithmeticGroup) (k : ℕ) + (q r : Quotient k) (hqr : q ≠ r) + (hm : ∀ s ∈ S, q ≠ reduce k s * r) (v : H) : + lazyAverage S k (lp.single 2 r v) q = 0 := by + classical + simp only [lazyAverage, meanTranslation, smul_apply, + add_apply, one_apply_eq_self, + sum_apply, lp.coeFn_smul, lp.coeFn_add, lp.coeFn_sum, + Pi.smul_apply, Pi.add_apply, Finset.sum_apply] + change (1 / 2 : ℂ) • + ((lp.single (E := fun _ : Quotient k => H) 2 r v) q + (S.card : ℂ)⁻¹ • + ∑ s ∈ S, leftTranslation (H := H) (Quotient k) (reduce k s) + (lp.single 2 r v) q) = 0 + rw [lp.single_apply_ne (E := fun _ : Quotient k => H) 2 r v hqr] + have hz : ∑ s ∈ S, leftTranslation (H := H) (Quotient k) (reduce k s) + (lp.single 2 r v) q = 0 := Finset.sum_eq_zero (fun s hs => + translation_single_zero (reduce k s) q r (hm s hs) v) + rw [hz] + simp + +private theorem leftMove_distance (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} (u : Disc j) (q : Quotient (discDepth j u)) + (s : ArithmeticGroup) (hs : s ∈ S) : + @dist VertexUnion (vertexUnionMetric S t).toDist + ⟨⟨j, u⟩, reduce (discDepth j u) s * q⟩ ⟨⟨j, u⟩, q⟩ ≤ 1 := by + rw [vertexUnion_dist_same S t] + by_cases he : reduce (discDepth j u) s * q = q + · simp [he] + · have ha : (fiberedGraph S t j).Adj ⟨u, q⟩ ⟨u, reduce (discDepth j u) s * q⟩ := by + refine ⟨?_, s, ?_, Or.inl rfl, ?_⟩ + · intro h + have hc : HEq q (reduce (discDepth j u) s * q) := (Sigma.mk.inj h).2 + exact he (eq_of_heq hc).symm + · simp [symmetricMoves, hs] + · intro m hq hr + simp [fiberCoordinate, fiberCharge, latticeCharge_self, map_mul, quotientMap_reduce] + have hd := SimpleGraph.dist_le ha.toWalk + simp only [SimpleGraph.Walk.length_cons, SimpleGraph.Walk.length_nil, zero_add] at hd + rw [SimpleGraph.dist_comm] + exact_mod_cast hd + +def spatialLazyAverage (S : Finset ArithmeticGroup) : Operator VertexUnion H := + flattenOperator (Q := BaseFiber) (blockOperator + (fun u : BaseUnion => lazyAverage (H := H) S (discDepth u.1 u.2)) + 1 zero_le_one (fun _ => lazyAverage_norm_le S _)) + +theorem spatialLazyAverage_propagation (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + letI : MetricSpace VertexUnion := vertexUnionMetric S t + PropagationLE 1 (spatialLazyAverage (H := H) S) := by + let : MetricSpace VertexUnion := vertexUnionMetric S t + intro x y hdist + apply ContinuousLinearMap.ext + intro v + rcases x with ⟨u, q⟩ + rcases y with ⟨w, r⟩ + change spatialLazyAverage S (lp.single 2 ⟨w, r⟩ v) ⟨u, q⟩ = 0 + by_cases huw : u = w + · subst w + change lazyAverage S (discDepth u.1 u.2) + (rowVector (lp.single 2 ⟨u, r⟩ v) u) q = 0 + rw [rowVector_single_same] + apply lazyAverage_single_zero + · intro he + subst q + simp only [dist_self] at hdist + exact (not_lt_of_ge (by norm_num : (0 : ℝ) ≤ 1)) hdist + · intro s hs he + subst q + exact (not_lt_of_ge (leftMove_distance S t u.2 r s hs)) hdist + · change lazyAverage S (discDepth u.1 u.2) + (rowVector (lp.single 2 ⟨w, r⟩ v) u) q = 0 + rw [rowVector_single_ne huw, map_zero] + rfl + +theorem spatialAveragingPower_eq_pow (S : Finset ArithmeticGroup) (n : ℕ) : + spatialAveragingPower (H := H) S n = spatialLazyAverage S ^ (n + 1) := by + let M := fun u : BaseUnion => lazyAverage (H := H) S (discDepth u.1 u.2) + let A := fun n => blockOperator (fun u : BaseUnion => M u ^ (n + 1)) + 1 zero_le_one (fiberAveragingPower_norm (H := H) S n) + let B := blockOperator M 1 zero_le_one + (fun u : BaseUnion => lazyAverage_norm_le (H := H) S (discDepth u.1 u.2)) + induction n with + | zero => rfl + | succ n ih => + have he : A (n + 1) = A n * B := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext u + change (M u ^ (n + 1 + 1)) (x u) = (M u ^ (n + 1)) (M u (x u)) + rw [pow_succ] + rfl + change flattenOperator (Q := BaseFiber) (A (n + 1)) = _ + rw [he, flattenOperator_mul] + change spatialAveragingPower S n * spatialLazyAverage S = _ + rw [ih, ← pow_succ] + +theorem spatialAveragingPower_propagation (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + letI : MetricSpace VertexUnion := vertexUnionMetric S t + ∀ n, PropagationLE (n + 1 : ℕ) (spatialAveragingPower (H := H) S n) := by + let : MetricSpace VertexUnion := vertexUnionMetric S t + have hfinite := (vertexUnion_uniform_balls S t).finite_closedBall + have hM := spatialLazyAverage_propagation (H := H) S t + intro n + rw [spatialAveragingPower_eq_pow] + induction n with + | zero => simpa only [zero_add, pow_one, Nat.cast_one] using hM + | succ n ih => + have hp := PropagationLE.mul hfinite ih hM + simpa only [pow_succ, Nat.cast_add, Nat.cast_one] using hp + +/-- The concrete spatial transfer now requires only the published uniform +Kazhdan-gap specialization for these actual averages. -/ +theorem concrete_transfer_of_gap (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + (hS : S.Nonempty) (hgap : UniformAveragingGap S H) : + letI : MetricSpace VertexUnion := vertexUnionMetric S t + MapsToRoe (fiberEmbedding (H := H) BaseFiber) := by + let : MetricSpace VertexUnion := vertexUnionMetric S t + apply concrete_transfer_of_approximation S t (spatialAveragingPower S) + (spatialAveragingPower_tendsto S hS hgap) + intro n + exact ⟨(n + 1 : ℕ), by positivity, spatialAveragingPower_propagation S t n⟩ + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BilateralShift.lean b/lean/OAI/Topology/CoarseAssembly/BilateralShift.lean new file mode 100644 index 0000000000000000000000000000000000000000..89efe9c54db24eacd752a0a1579e598f6274b58b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BilateralShift.lean @@ -0,0 +1,76 @@ +import OAI.Topology.CoarseAssembly.HilbertSum +import OAI.Topology.CoarseAssembly.FredholmModule + +namespace OAI + +/-! # The separable Hilbert space and bilateral shift for the circle cycle -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open TopologicalSpace + +abbrev CircleSequence := lp (fun _ : ℤ => ℂ) 2 + +instance circleSequence_secondCountable : SecondCountableTopology CircleSequence := by + let b : HilbertBasis ℤ ℂ CircleSequence := default + have hs := ((Set.countable_range b).isSeparable.span (R := ℂ)).closure + change TopologicalSpace.IsSeparable + ((Submodule.span ℂ (Set.range b)).topologicalClosure : Set CircleSequence) at hs + rw [b.dense_span] at hs + have : SeparableSpace CircleSequence := TopologicalSpace.isSeparable_univ_iff.mp hs + infer_instance + +abbrev circleSequenceSpace : HilbertSpace where + Carrier := CircleSequence + normed := inferInstance + inner := inferInstance + complete := inferInstance + secondCountable := inferInstance + +/-- Reindex square-summable integer sequences by a permutation. -/ +def reindexSequence (e : ℤ ≃ ℤ) (x : CircleSequence) : CircleSequence := + ⟨fun n => x (e.symm n), by + apply memℓp_gen + simp only [ENNReal.toReal_ofNat, Real.rpow_two] + exact e.symm.summable_iff.mpr (CoarseAssembly.l2_summable_sq x)⟩ + +theorem reindexSequence_norm (e : ℤ ≃ ℤ) (x : CircleSequence) : ‖reindexSequence e x‖ = ‖x‖ := by + have he : ‖reindexSequence e x‖ ^ 2 = ‖x‖ ^ 2 := by + rw [CoarseAssembly.l2_norm_sq, CoarseAssembly.l2_norm_sq] + exact e.symm.tsum_eq (fun n => ‖x n‖ ^ 2) + nlinarith [norm_nonneg x, norm_nonneg (reindexSequence e x)] + +def reindexSequenceEquiv (e : ℤ ≃ ℤ) : CircleSequence ≃ₗᵢ[ℂ] CircleSequence where + toFun := reindexSequence e + invFun := reindexSequence e.symm + left_inv x := by apply lp.ext; funext n; simp [reindexSequence] + right_inv x := by apply lp.ext; funext n; simp [reindexSequence] + map_add' _ _ := rfl + map_smul' _ _ := rfl + norm_map' := reindexSequence_norm e + +/-- The shift sends the basis vector at `n` to the basis vector at `n+1`. -/ +def bilateralShiftEquiv : CircleSequence ≃ₗᵢ[ℂ] CircleSequence := + reindexSequenceEquiv (Equiv.addRight 1) + +def bilateralShift : End circleSequenceSpace := (bilateralShiftEquiv : CircleSequence →L[ℂ] CircleSequence) + +@[simp] theorem bilateralShift_apply (x : CircleSequence) (n : ℤ) : + bilateralShift x n = x (n - 1) := rfl + +theorem bilateralShift_unitary : star bilateralShift * bilateralShift = 1 ∧ + bilateralShift * star bilateralShift = 1 := by + have hs : star bilateralShift = (bilateralShiftEquiv.symm : CircleSequence →L[ℂ] CircleSequence) := + bilateralShiftEquiv.adjoint_eq_symm + rw [hs] + constructor <;> apply ContinuousLinearMap.ext <;> intro x + · exact bilateralShiftEquiv.symm_apply_apply x + · exact bilateralShiftEquiv.apply_symm_apply x + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BinaryCycle.lean b/lean/OAI/Topology/CoarseAssembly/BinaryCycle.lean new file mode 100644 index 0000000000000000000000000000000000000000..a6ffdf7a5511896cfc5c1f386a96ceddfc18661a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BinaryCycle.lean @@ -0,0 +1,62 @@ +import OAI.Topology.CoarseAssembly.BinaryHilbertSum +import OAI.Topology.CoarseAssembly.AnalyticKHomology + +namespace OAI + +/-! # Actual direct sums of odd Fredholm modules -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u + +variable {A : Type u} [NonUnitalCStarAlgebra A] + +def OddCycle.binarySum (c d : OddCycle A) : OddCycle A where + space := binaryHilbertSpace c.space d.space + representation := (binaryBlockHom c.space d.space).toNonUnitalStarAlgHom.comp + (c.representation.prod d.representation) + operator := binaryBlock c.space d.space c.operator d.operator + commutator_compact a := by + change IsCompactOperator + (binaryBlock c.space d.space c.operator d.operator * + binaryBlock c.space d.space (c.representation a) (d.representation a) - + binaryBlock c.space d.space (c.representation a) (d.representation a) * + binaryBlock c.space d.space c.operator d.operator) + rw [← binaryBlock_mul, ← binaryBlock_mul, ← binaryBlock_sub] + exact binaryBlock_compact _ _ (c.commutator_compact a) (d.commutator_compact a) + square_compact a := by + change IsCompactOperator + ((binaryBlock c.space d.space c.operator d.operator * + binaryBlock c.space d.space c.operator d.operator - 1) * + binaryBlock c.space d.space (c.representation a) (d.representation a) : + End (binaryHilbertSpace c.space d.space)) + rw [← binaryBlock_mul, ← binaryBlock_one c.space d.space, ← binaryBlock_sub, + ← binaryBlock_mul] + exact binaryBlock_compact _ _ (c.square_compact a) (d.square_compact a) + adjoint_compact a := by + change IsCompactOperator + ((star (binaryBlock c.space d.space c.operator d.operator) - + binaryBlock c.space d.space c.operator d.operator) * + binaryBlock c.space d.space (c.representation a) (d.representation a)) + rw [← binaryBlock_star, ← binaryBlock_sub, ← binaryBlock_mul] + exact binaryBlock_compact _ _ (c.adjoint_compact a) (d.adjoint_compact a) + +def OddCycle.binarySum_decomposition (c d : OddCycle A) : c.IsDirectSum d (c.binarySum d) where + left := binaryLeft c.space d.space + right := binaryRight c.space d.space + orthogonal := binaryLeft_right c.space d.space + exhaustive := binary_exhaustive c.space d.space + representation_eq _ := rfl + operator_eq := rfl + +theorem binarySum_class (c d : OddCycle A) : + cycleClass A (c.binarySum d) = cycleClass A c + cycleClass A d := + directSum_eq c d _ (c.binarySum_decomposition d) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BinaryHilbertSum.lean b/lean/OAI/Topology/CoarseAssembly/BinaryHilbertSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..3245831b30eb8f961e5aad993c14939441bb787e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BinaryHilbertSum.lean @@ -0,0 +1,148 @@ +import OAI.Topology.CoarseAssembly.FredholmModule +import Mathlib.Analysis.InnerProductSpace.ProdL2 + +namespace OAI + +/-! # Concrete binary sums of the Hilbert spaces of analytic cycles -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u + +abbrev binaryHilbertSpace (H K : HilbertSpace.{u}) : HilbertSpace.{u} where + Carrier := WithLp 2 (H × K) + normed := inferInstance + inner := inferInstance + complete := inferInstance + secondCountable := inferInstance + +variable (H K : HilbertSpace.{u}) + +def binaryLeft : H →ₗᵢ[ℂ] binaryHilbertSpace H K where + toFun x := WithLp.toLp 2 (x, 0) + map_add' _ _ := by simp [← WithLp.toLp_add] + map_smul' _ _ := by simp [← WithLp.toLp_smul] + norm_map' x := WithLp.norm_toLp_fst 2 H K x + +def binaryRight : K →ₗᵢ[ℂ] binaryHilbertSpace H K where + toFun x := WithLp.toLp 2 (0, x) + map_add' _ _ := by simp [← WithLp.toLp_add] + map_smul' _ _ := by simp [← WithLp.toLp_smul] + norm_map' x := WithLp.norm_toLp_snd 2 H K x + +@[simp] theorem binaryLeft_adjoint : + (binaryLeft H K).toContinuousLinearMap.adjoint = WithLp.fstL 2 ℂ H K := by + apply ContinuousLinearMap.ext + intro x + apply ext_inner_left ℂ + intro y + rw [ContinuousLinearMap.adjoint_inner_right] + simp [binaryLeft, WithLp.prod_inner_apply] + +@[simp] theorem binaryRight_adjoint : + (binaryRight H K).toContinuousLinearMap.adjoint = WithLp.sndL 2 ℂ H K := by + apply ContinuousLinearMap.ext + intro x + apply ext_inner_left ℂ + intro y + rw [ContinuousLinearMap.adjoint_inner_right] + simp [binaryRight, WithLp.prod_inner_apply] + +theorem binaryLeft_right : + (binaryLeft H K).toContinuousLinearMap.adjoint ∘L + (binaryRight H K).toContinuousLinearMap = 0 := by + rw [binaryLeft_adjoint] + ext x + simp [binaryRight] + +theorem binary_exhaustive : + (binaryLeft H K).toContinuousLinearMap.comp (binaryLeft H K).toContinuousLinearMap.adjoint + + (binaryRight H K).toContinuousLinearMap.comp (binaryRight H K).toContinuousLinearMap.adjoint = 1 := by + rw [binaryLeft_adjoint, binaryRight_adjoint] + apply ContinuousLinearMap.ext + intro x + apply (WithLp.ofLp_injective 2) + simp [binaryLeft, binaryRight] + rfl + +/-- Block diagonal operators, on the actual Hilbert sum. -/ +def binaryBlock (T : End H) (S : End K) : End (binaryHilbertSpace H K) := + operatorConjugation (binaryLeft H K) T + operatorConjugation (binaryRight H K) S + +@[simp] theorem binaryBlock_apply (T : End H) (S : End K) + (x : binaryHilbertSpace H K) : + binaryBlock H K T S x = WithLp.toLp 2 (T x.fst, S x.snd) := by + unfold binaryBlock operatorConjugation + rw [binaryLeft_adjoint, binaryRight_adjoint] + apply (WithLp.ofLp_injective 2) + simp [binaryLeft, binaryRight] + +theorem binaryBlock_add (T T' : End H) (S S' : End K) : + binaryBlock H K (T + T') (S + S') = binaryBlock H K T S + binaryBlock H K T' S' := by + ext x + rw [add_apply, binaryBlock_apply H K, binaryBlock_apply H K, + binaryBlock_apply H K] + rfl + +theorem binaryBlock_sub (T T' : End H) (S S' : End K) : + binaryBlock H K (T - T') (S - S') = binaryBlock H K T S - binaryBlock H K T' S' := by + ext x + rw [sub_apply, binaryBlock_apply H K, binaryBlock_apply H K, + binaryBlock_apply H K] + rfl + +theorem binaryBlock_mul (T T' : End H) (S S' : End K) : + binaryBlock H K (T * T') (S * S') = binaryBlock H K T S * binaryBlock H K T' S' := by + ext x + change binaryBlock H K (T * T') (S * S') x = + binaryBlock H K T S (binaryBlock H K T' S' x) + rw [binaryBlock_apply H K, binaryBlock_apply H K, binaryBlock_apply H K] + rfl + +@[simp] theorem binaryBlock_one : binaryBlock H K 1 1 = 1 := by + ext x + rw [binaryBlock_apply H K] + rfl + +@[simp] theorem binaryBlock_zero : binaryBlock H K 0 0 = 0 := by + ext x + rw [binaryBlock_apply H K] + rfl + +theorem binaryBlock_star (T : End H) (S : End K) : + binaryBlock H K (star T) (star S) = star (binaryBlock H K T S) := by + simp only [binaryBlock, star_add, ← operatorConjugation_star] + +theorem binaryBlock_smul (z : ℂ) (T : End H) (S : End K) : + binaryBlock H K (z • T) (z • S) = z • binaryBlock H K T S := by + ext x + rw [smul_apply, binaryBlock_apply H K, binaryBlock_apply H K] + rfl + +def binaryBlockHom : (End H × End K) →⋆ₐ[ℂ] End (binaryHilbertSpace H K) where + toFun p := binaryBlock H K p.1 p.2 + map_zero' := binaryBlock_zero H K + map_one' := binaryBlock_one H K + map_add' p q := binaryBlock_add H K p.1 q.1 p.2 q.2 + map_mul' p q := binaryBlock_mul H K p.1 q.1 p.2 q.2 + map_star' p := binaryBlock_star H K p.1 p.2 + commutes' z := by + simp only [Algebra.algebraMap_eq_smul_one] + exact (binaryBlock_smul H K z 1 1).trans (by rw [binaryBlock_one]) + +theorem binaryBlock_compact {T : End H} {S : End K} + (hT : IsCompactOperator T) (hS : IsCompactOperator S) : + IsCompactOperator (binaryBlock H K T S) := by + unfold binaryBlock operatorConjugation + exact ((hT.clm_comp (binaryLeft H K).toContinuousLinearMap).comp_clm + (binaryLeft H K).toContinuousLinearMap.adjoint).add + ((hS.clm_comp (binaryRight H K).toContinuousLinearMap).comp_clm + (binaryRight H K).toContinuousLinearMap.adjoint) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BlockIsometryRelations.lean b/lean/OAI/Topology/CoarseAssembly/BlockIsometryRelations.lean new file mode 100644 index 0000000000000000000000000000000000000000..98339243b7ccecd10f2a46eff52bc47b7d450156 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BlockIsometryRelations.lean @@ -0,0 +1,75 @@ +import OAI.Topology.CoarseAssembly.ProjectionBlocks +import OAI.Topology.CoarseAssembly.CoefficientDecomposition + +namespace OAI + +/-! # Reducing decompositions and intertwiners on bounded Hilbert sums -/ + +noncomputable section + +namespace CoarseAssembly + +variable {I : Type*} {E F G : I → Type*} + [∀ i, NormedAddCommGroup (E i)] [∀ i, InnerProductSpace ℂ (E i)] [∀ i, CompleteSpace (E i)] + [∀ i, NormedAddCommGroup (F i)] [∀ i, InnerProductSpace ℂ (F i)] [∀ i, CompleteSpace (F i)] + [∀ i, NormedAddCommGroup (G i)] [∀ i, InnerProductSpace ℂ (G i)] [∀ i, CompleteSpace (G i)] + +theorem blockIsometry_adjoint_coordinate (V : ∀ i, E i →ₗᵢ[ℂ] G i) (v : lp G 2) (i : I) : + (blockIsometry V).toContinuousLinearMap.adjoint v i = + (V i).toContinuousLinearMap.adjoint (v i) := by + rw [blockIsometry_toCLM, blockOperator_adjoint] + rfl + +omit [∀ i, CompleteSpace (F i)] in +theorem blockIsometry_orthogonal (V : ∀ i, E i →ₗᵢ[ℂ] G i) (W : ∀ i, F i →ₗᵢ[ℂ] G i) + (hVW : ∀ i, (V i).toContinuousLinearMap.adjoint.comp (W i).toContinuousLinearMap = 0) : + (blockIsometry V).toContinuousLinearMap.adjoint.comp (blockIsometry W).toContinuousLinearMap = 0 := by + ext v i + change (blockIsometry V).toContinuousLinearMap.adjoint (blockIsometry W v) i = 0 + rw [blockIsometry_adjoint_coordinate, blockIsometry_apply] + exact DFunLike.congr_fun (hVW i) (v i) + +theorem blockIsometry_exhaustive (V : ∀ i, E i →ₗᵢ[ℂ] G i) (W : ∀ i, F i →ₗᵢ[ℂ] G i) + (hex : ∀ i, (V i).toContinuousLinearMap.comp (V i).toContinuousLinearMap.adjoint + + (W i).toContinuousLinearMap.comp (W i).toContinuousLinearMap.adjoint = 1) : + (blockIsometry V).toContinuousLinearMap.comp (blockIsometry V).toContinuousLinearMap.adjoint + + (blockIsometry W).toContinuousLinearMap.comp (blockIsometry W).toContinuousLinearMap.adjoint = 1 := by + ext v i + change blockIsometry V ((blockIsometry V).toContinuousLinearMap.adjoint v) i + + blockIsometry W ((blockIsometry W).toContinuousLinearMap.adjoint v) i = v i + rw [blockIsometry_apply, blockIsometry_apply, + blockIsometry_adjoint_coordinate, blockIsometry_adjoint_coordinate] + exact DFunLike.congr_fun (hex i) (v i) + +omit [∀ i, CompleteSpace (E i)] [∀ i, CompleteSpace (G i)] in +theorem blockOperator_intertwines (V : ∀ i, E i →ₗᵢ[ℂ] G i) + (A : ∀ i, E i →L[ℂ] E i) (B : ∀ i, G i →L[ℂ] G i) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (hV : ∀ i, (B i).comp (V i).toContinuousLinearMap = (V i).toContinuousLinearMap.comp (A i)) : + (blockOperator B D hD hB).comp (blockIsometry V).toContinuousLinearMap = + (blockIsometry V).toContinuousLinearMap.comp (blockOperator A C hC hA) := by + ext v i + exact DFunLike.congr_fun (hV i) (v i) + +theorem blockOperator_decomposition + (V : ∀ i, E i →ₗᵢ[ℂ] G i) (W : ∀ i, F i →ₗᵢ[ℂ] G i) + (hex : ∀ i, (V i).toContinuousLinearMap.comp (V i).toContinuousLinearMap.adjoint + + (W i).toContinuousLinearMap.comp (W i).toContinuousLinearMap.adjoint = 1) + (A : ∀ i, E i →L[ℂ] E i) (B : ∀ i, F i →L[ℂ] F i) (T : ∀ i, G i →L[ℂ] G i) + (C D K : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) (hK : 0 ≤ K) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) (hT : ∀ i, ‖T i‖ ≤ K) + (hV : ∀ i, (T i).comp (V i).toContinuousLinearMap = (V i).toContinuousLinearMap.comp (A i)) + (hW : ∀ i, (T i).comp (W i).toContinuousLinearMap = (W i).toContinuousLinearMap.comp (B i)) : + blockOperator T K hK hT = + operatorConjugation (blockIsometry V) (blockOperator A C hC hA) + + operatorConjugation (blockIsometry W) (blockOperator B D hD hB) := + orthogonal_isometries_decompose _ _ (blockIsometry_exhaustive V W hex) _ _ _ + (blockOperator_intertwines V A T C K hC hK hA hT hV) + (blockOperator_intertwines W B T D K hD hK hB hT hW) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BlockOperators.lean b/lean/OAI/Topology/CoarseAssembly/BlockOperators.lean new file mode 100644 index 0000000000000000000000000000000000000000..0a6fe30a0e9aeb067f5532409f4710972b938f48 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BlockOperators.lean @@ -0,0 +1,116 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Analysis.InnerProductSpace.PiL2 +import Mathlib.Analysis.InnerProductSpace.Adjoint +import Mathlib.Analysis.Normed.Lp.lpSpace +import Mathlib.Analysis.SpecificLimits.Basic + +namespace OAI + +/-! # Uniform block operators on Hilbert sums + +The averaging operators used in the transfer act separately on finite +fibers. A uniform norm bound, rather than finiteness of the set of fibers, +makes their direct sum a bounded operator. The resulting operator admits the uniform approximation needed for the +fiber projection. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Filter +open scoped Topology + +variable {ι : Type*} {E F : ι → Type*} +variable [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace ℂ (E i)] +variable [∀ i, NormedAddCommGroup (F i)] [∀ i, NormedSpace ℂ (F i)] + +theorem blockLinear_norm_le (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (x : lp E 2) : + ‖blockLinear A C hC hA x‖ ≤ C * ‖x‖ := by + calc + _ ≤ ‖C • lp.toNorm x‖ := by + apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0) + intro i + change ‖A i (x i)‖ ≤ ‖C * ‖x i‖‖ + rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg hC (norm_nonneg _))] + exact (A i).le_opNorm (x i) |>.trans + (mul_le_mul_of_nonneg_right (hA i) (norm_nonneg _)) + _ = C * ‖x‖ := by rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg hC, lp.norm_toNorm] + +@[simp] theorem blockOperator_apply (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (x : lp E 2) (i : ι) : + blockOperator A C hC hA x i = A i (x i) := rfl + +theorem blockOperator_norm_le (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) : ‖blockOperator A C hC hA‖ ≤ C := + ContinuousLinearMap.opNorm_le_bound _ hC (blockLinear_norm_le A C hC hA) + +@[simp] theorem blockIsometry_apply (V : ∀ i, E i →ₗᵢ[ℂ] F i) (x : lp E 2) (i : ι) : + blockIsometry V x i = V i (x i) := rfl + +/-- Uniform fiberwise norm error bounds the operator error on the whole +Hilbert sum. This is the norm estimate for the amplified Kazhdan projection. -/ +theorem blockOperator_dist_le (A B : ∀ i, E i →L[ℂ] F i) + (C D ε : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) (hε : 0 ≤ ε) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (hAB : ∀ i, ‖A i - B i‖ ≤ ε) : + ‖blockOperator A C hC hA - blockOperator B D hD hB‖ ≤ ε := by + have heq : blockOperator A C hC hA - blockOperator B D hD hB = + blockOperator (fun i => A i - B i) ε hε hAB := by + ext x i + rfl + rw [heq] + exact blockOperator_norm_le _ _ _ _ + +theorem power_mul_fixed {R : Type*} [Monoid R] (M P : R) (hMP : M * P = P) (n : ℕ) : + M ^ n * P = P := by + induction n with + | zero => simp + | succ n ih => rw [pow_succ, mul_assoc, hMP, ih] + +/-- Removing a fixed projection converts averaging powers into powers on +its complementary subspace. This identity needs no spectral theorem. -/ +theorem projection_error_power {R : Type*} [Ring R] (M P : R) + (hPP : P * P = P) (hMP : M * P = P) (hPM : P * M = P) (n : ℕ) : + (M - P) ^ (n + 1) = M ^ (n + 1) - P := by + induction n with + | zero => simp + | succ n ih => + rw [pow_succ (M - P), ih, mul_sub, sub_mul, sub_mul, + power_mul_fixed M P hMP, hPM, hPP, sub_self, sub_zero, ← pow_succ] + +theorem averaging_power_norm_le (M : ∀ i, E i →L[ℂ] E i) + (hM : ∀ i, ‖M i‖ ≤ 1) (n : ℕ) (i : ι) : ‖M i ^ (n + 1)‖ ≤ 1 := by + calc + _ ≤ ‖M i‖ ^ (n + 1) := norm_pow_le' _ (Nat.succ_pos n) + _ ≤ 1 ^ (n + 1) := by gcongr; exact hM i + _ = 1 := one_pow _ + +/-- The uniform spectral-gap consequence needed by the transfer. The +published input is the strict contraction bound on `M i - P i`; norm +convergence of the direct sum is proved here. -/ +theorem averaging_blocks_tendsto (M P : ∀ i, E i →L[ℂ] E i) + (c : ℝ) (hc : 0 ≤ c) (hc1 : c < 1) + (hM : ∀ i, ‖M i‖ ≤ 1) (hP : ∀ i, ‖P i‖ ≤ 1) + (hPP : ∀ i, P i * P i = P i) (hMP : ∀ i, M i * P i = P i) + (hPM : ∀ i, P i * M i = P i) (hgap : ∀ i, ‖M i - P i‖ ≤ c) : + Tendsto + (fun n : ℕ => blockOperator (fun i => M i ^ (n + 1)) 1 (by norm_num) + (averaging_power_norm_le M hM n)) + atTop (nhds (blockOperator P 1 (by norm_num) hP)) := by + apply tendsto_iff_norm_sub_tendsto_zero.mpr + apply squeeze_zero (fun n => norm_nonneg _) (fun n => ?_) + (show Tendsto (fun n : ℕ => c ^ (n + 1)) atTop (nhds 0) by + simpa only [pow_succ, zero_mul] using + (tendsto_pow_atTop_nhds_zero_of_lt_one hc hc1).mul_const c) + apply blockOperator_dist_le _ _ _ _ _ _ _ (pow_nonneg hc _) _ hP + intro i + rw [← projection_error_power _ _ (hPP i) (hMP i) (hPM i)] + exact (norm_pow_le' _ (Nat.succ_pos n)).trans (by gcongr; exact hgap i) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BlockSumDecomposition.lean b/lean/OAI/Topology/CoarseAssembly/BlockSumDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..35d3a6677f21b4207cbe711cae31f889263e6067 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BlockSumDecomposition.lean @@ -0,0 +1,66 @@ +import OAI.Topology.CoarseAssembly.SummandComplement +import OAI.Topology.CoarseAssembly.ProjectionBlocks + +namespace OAI + +/-! # Splitting a block operator into one summand and its complement -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable (H : ℕ → HilbertSpace) (K : ∀ j, End (H j)) +variable (C : ℝ) (hC : 0 ≤ C) (hK : ∀ j, ‖K j‖ ≤ C) + +theorem blockOperator_single (j : ℕ) (x : H j) : + CoarseAssembly.blockOperator K C hC hK (summandIsometry H j x) = + summandIsometry H j (K j x) := by + apply lp.ext + funext k + change K k (lp.single (E := fun k => H k) 2 j x k) = + lp.single (E := fun k => H k) 2 j (K j x) k + by_cases hk : j = k + · subst k + simp + · simp [Pi.single_eq_of_ne (Ne.symm hk)] + +def complementBlockOperator (j : ℕ) : End (complementHilbertSpace H j) := + (complementIsometry H j).toContinuousLinearMap.adjoint.comp + ((CoarseAssembly.blockOperator K C hC hK).comp + (complementIsometry H j).toContinuousLinearMap) + +theorem complementBlockOperator_coe (j : ℕ) (x : complementHilbertSpace H j) : + (complementBlockOperator H K C hC hK j x : countableHilbertSpace H) = + CoarseAssembly.blockOperator K C hC hK (x : countableHilbertSpace H) := by + unfold complementBlockOperator + rw [complementIsometry_adjoint] + change (complementProjection H j + (CoarseAssembly.blockOperator K C hC hK (x : countableHilbertSpace H)) : + countableHilbertSpace H) = _ + rw [complementProjection_coe] + have hx : (x : countableHilbertSpace H) j = 0 := x.property + change CoarseAssembly.blockOperator K C hC hK (x : countableHilbertSpace H) - + summandIsometry H j (K j ((x : countableHilbertSpace H) j)) = _ + rw [hx, map_zero, map_zero, sub_zero] + +theorem blockOperator_decomposition (j : ℕ) : + CoarseAssembly.blockOperator K C hC hK = + operatorConjugation (summandIsometry H j) (K j) + + operatorConjugation (complementIsometry H j) + (complementBlockOperator H K C hC hK j) := by + apply ContinuousLinearMap.ext + intro x + unfold operatorConjugation + rw [summandIsometry_adjoint, complementIsometry_adjoint] + change CoarseAssembly.blockOperator K C hC hK x = + summandIsometry H j (K j (x j)) + + (complementBlockOperator H K C hC hK j (complementProjection H j x) : + countableHilbertSpace H) + rw [complementBlockOperator_coe, complementProjection_coe, map_sub, blockOperator_single] + abel + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryAssemblyMaps.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryAssemblyMaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..6c5f5f66d2e0b96f3eb00957a4ac48e55342f1dd --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryAssemblyMaps.lean @@ -0,0 +1,104 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.BoundaryGeometry +import OAI.Topology.CoarseAssembly.KazhdanInput +import OAI.Topology.CoarseAssembly.BoundaryIndex + +namespace OAI + +/-! # The actual boundary assembly diagram + +All three Roe maps below are constructed spatial homomorphisms on the +ordinary reduced locally compact Roe algebras. The transfer factorization +is proved before the two published assembly naturality equations are used. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Analytic DiscreteRoe + +attribute [local instance] OAI.CoarseAssembly.boundaryAssemblyMetric1 + +local instance boundaryAssemblyMetric2 : MetricSpace BoundaryVertex := boundaryMetric elementaryMoves chosenHolonomyUnit +local instance boundaryAssemblyMetric3 : PseudoMetricSpace BoundaryVertex := + (boundaryMetric elementaryMoves chosenHolonomyUnit).toPseudoMetricSpace + +def BoundaryRoe : Type := algebra (X := BoundaryVertex) (H := AmpleSpace) +def BaseRoe : Type := algebra (X := BaseUnion) (H := AmpleSpace) +instance : NonUnitalCStarAlgebra BoundaryRoe := + inferInstanceAs (NonUnitalCStarAlgebra (algebra (X := BoundaryVertex) (H := AmpleSpace))) +instance : NonUnitalCStarAlgebra BaseRoe := + inferInstanceAs (NonUnitalCStarAlgebra (algebra (X := BaseUnion) (H := AmpleSpace))) +def boundaryBaseCoarsening : CoarseningMorphism (Rips.coarsening BoundaryVertex) + (Rips.coarsening BaseUnion) := + Rips.embeddingCoarsening boundaryToBase + (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit) + +def boundaryTotalCoarsening : CoarseningMorphism (Rips.coarsening BoundaryVertex) + (Rips.coarsening VertexUnion) := + Rips.embeddingCoarsening boundaryToVertex + (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit) + +def boundaryBaseRoeHom : BoundaryRoe →⋆ₙₐ[ℂ] BaseRoe := + inclusionHom (X := BoundaryVertex) (Y := BaseUnion) (H := AmpleSpace) + boundaryToBase (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit) + +def boundaryTotalRoeHom : BoundaryRoe →⋆ₙₐ[ℂ] TotalRoe := + inclusionHom (X := BoundaryVertex) (Y := VertexUnion) (H := AmpleSpace) + boundaryToVertex (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit) + +def transferRoeHom (hgap : PublishedKazhdanInput) : BaseRoe →⋆ₙₐ[ℂ] TotalRoe := + conjugationHom (D := BaseUnion) (X := VertexUnion) (H := AmpleSpace) + (fiberEmbedding (H := AmpleSpace) BaseFiber) (roe_transfer_of_published_gap hgap) + +theorem transferRoeHom_boundary (hgap : PublishedKazhdanInput) : + (transferRoeHom hgap).comp boundaryBaseRoeHom = boundaryTotalRoeHom := by + apply DFunLike.ext + intro T + apply Subtype.ext + change operatorConjugation (fiberEmbedding (H := AmpleSpace) BaseFiber) + (operatorConjugation (boundaryBaseIsometry (H := AmpleSpace)) T.1) = + operatorConjugation (boundaryVertexIsometry (H := AmpleSpace)) T.1 + exact boundary_operator_factorization (H := AmpleSpace) T.1 + +theorem transferK1_boundary (hgap : PublishedKazhdanInput) : + (OperatorKTheory.map (transferRoeHom hgap)).comp (OperatorKTheory.map boundaryBaseRoeHom) = + OperatorKTheory.map boundaryTotalRoeHom := by + exact (OperatorKTheory.map_comp boundaryBaseRoeHom (transferRoeHom hgap)).symm.trans + (congrArg OperatorKTheory.map (transferRoeHom_boundary hgap)) + +/-- The exact published index/naturality specializations used here: +Willett--Yu, *Higher Index Theory* (2020), §§5.1, 6.7, 7.1--7.2, +with errata 30--31. The objects and both geometric/Roe maps are fixed above. +There is no transfer-naturality premise. -/ +structure PublishedBoundaryAssemblyInput where + boundary : CompatibleIndexFamily (Rips.coarsening BoundaryVertex) BoundaryRoe + base : CompatibleIndexFamily (Rips.coarsening BaseUnion) BaseRoe + total : CompatibleIndexFamily (Rips.coarsening VertexUnion) TotalRoe + natural_base : ∀ r, (base.atScale r).comp (pushforward (boundaryBaseCoarsening.atScale r)) = + (OperatorKTheory.map boundaryBaseRoeHom).comp (boundary.atScale r) + natural_total : ∀ r, (total.atScale r).comp (pushforward (boundaryTotalCoarsening.atScale r)) = + (OperatorKTheory.map boundaryTotalRoeHom).comp (boundary.atScale r) + +/-- Vanishing in the base annihilates the included boundary index by the +proved spatial transfer. Filling is a geometric premise, not a published input. -/ +theorem boundary_assembly_zero (input : PublishedBoundaryAssemblyInput) + (hgap : PublishedKazhdanInput) (β : Rips.KX1 BoundaryVertex) + (hfilled : boundaryBaseCoarsening.homologyMap β = 0) : + input.total.assembly (boundaryTotalCoarsening.homologyMap β) = 0 := by + exact boundary_index_zero boundaryBaseCoarsening.homologyMap + boundaryTotalCoarsening.homologyMap input.boundary.assembly input.base.assembly + input.total.assembly (OperatorKTheory.map boundaryBaseRoeHom) + (OperatorKTheory.map boundaryTotalRoeHom) (OperatorKTheory.map (transferRoeHom hgap)) + (input.boundary.assembly_natural input.base boundaryBaseCoarsening + boundaryBaseRoeHom input.natural_base) + (input.boundary.assembly_natural input.total boundaryTotalCoarsening + boundaryTotalRoeHom input.natural_total) + (transferK1_boundary hgap) β hfilled + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryComponents.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryComponents.lean new file mode 100644 index 0000000000000000000000000000000000000000..634f79953bda3a1e1efb2b2545879557f2e1b5f2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryComponents.lean @@ -0,0 +1,82 @@ +import OAI.Topology.CoarseAssembly.BoundaryWalks +import OAI.Topology.CoarseAssembly.RipsFamilyMap + +namespace OAI + +/-! # Compact boundary components in the actual boundary metric + +The disjoint family of finite boundary vertex sets is isometric to the +depth-zero subtype used for the spatial boundary maps. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips + +@[instance_reducible] def boundaryComponentMetric (S : Finset ArithmeticGroup) + (t : ℤ_[2]ˣ) (j : ℕ) : MetricSpace (BoundaryComponent j) := + MetricSpace.induced (boundaryFiberEmbedding j) (boundaryFiberEmbedding j).injective + (componentMetric S t j) + +@[instance_reducible] def boundaryComponentsMetric (S : Finset ArithmeticGroup) + (t : ℤ_[2]ˣ) : MetricSpace (Sigma BoundaryComponent) := by + letI := boundaryComponentMetric S t + exact separatedMetric boundaryRoot + +def boundaryReindex : Sigma BoundaryComponent ≃ BoundaryVertex where + toFun b := ⟨⟨b.1, b.2.val⟩, b.2.property⟩ + invFun b := ⟨b.val.1, ⟨b.val.2, b.property⟩⟩ + left_inv _ := rfl + right_inv _ := rfl + +theorem boundaryReindex_dist (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + (x y : Sigma BoundaryComponent) : + @dist BoundaryVertex (boundaryMetric S t).toDist (boundaryReindex x) (boundaryReindex y) = + @dist (Sigma BoundaryComponent) (boundaryComponentsMetric S t).toDist x y := by + let := componentMetric S t + let := boundaryComponentMetric S t + rcases x with ⟨i, u⟩ + rcases y with ⟨j, v⟩ + change separatedDist fiberBoundaryBase + ⟨i, boundaryFiberEmbedding i u⟩ ⟨j, boundaryFiberEmbedding j v⟩ = + separatedDist boundaryRoot ⟨i, u⟩ ⟨j, v⟩ + by_cases hij : i = j + · subst j + simp only [separatedDist_same] + rfl + · rw [separatedDist_different fiberBoundaryBase hij, separatedDist_different boundaryRoot hij] + rfl + +theorem boundaryEdgeBound (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) {j : ℕ} + (x y : BoundaryComponent j) (h : (boundaryGraph j).Adj x y) : + @dist (BoundaryComponent j) (boundaryComponentMetric S t j).toDist x y ≤ 1 := by + change @dist _ (componentMetric S t j).toDist + (boundaryFiberEmbedding j x) (boundaryFiberEmbedding j y) ≤ 1 + rw [componentMetric_eq] + change ((fiberedGraph S t j).dist (boundaryFiberEmbedding j x) (boundaryFiberEmbedding j y) : ℝ) ≤ 1 + exact_mod_cast (show (fiberedGraph S t j).dist (boundaryFiberEmbedding j x) + (boundaryFiberEmbedding j y) ≤ 1 by + simpa using (fiberedGraph S t j).dist_le (boundaryFiber_adj S t h).toWalk) + +def boundaryFamilyMap (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) (r : ℝ) + (γ : ∀ j, C(WindingCircle, + @Point (BoundaryComponent j) (boundaryComponentMetric S t j).toPseudoMetricSpace r)) : + CocompactMap (Sigma (fun _ : ℕ => WindingCircle)) + (@Point BoundaryVertex (boundaryMetric S t).toPseudoMetricSpace r) := by + let := boundaryComponentMetric S t + let : ∀ j, PseudoMetricSpace (BoundaryComponent j) := + fun j => (boundaryComponentMetric S t j).toPseudoMetricSpace + let := boundaryComponentsMetric S t + let := boundaryMetric S t + let : PseudoMetricSpace BoundaryVertex := (boundaryMetric S t).toPseudoMetricSpace + exact (embeddingMap boundaryReindex.toEmbedding + (fun x y => (boundaryReindex_dist S t x y).le) r).comp + (ripsFamilyMap boundaryRoot r γ) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryConclusion.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryConclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..49ebe476f7c92998db64af787fae3f86ae1e240a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryConclusion.lean @@ -0,0 +1,114 @@ +import OAI.Topology.CoarseAssembly.BoundaryAssemblyMaps +import OAI.Topology.CoarseAssembly.BoundaryLoopMaps +import OAI.Topology.CoarseAssembly.ProperGeometry + +namespace OAI + +/-! # The boundary class in the reduced coarse assembly kernel + +The filling and detector refer to the same explicitly parametrized family. +Those maps combine with the two stated published assembly naturality +equations. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance boundaryConclusionMetric1 (j : ℕ) : MetricSpace (BoundaryComponent j) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit j +local instance boundaryConclusionMetric2 (j : ℕ) : PseudoMetricSpace (BoundaryComponent j) := + (boundaryComponentMetric elementaryMoves chosenHolonomyUnit j).toPseudoMetricSpace +local instance boundaryConclusionMetric3 : MetricSpace BoundaryVertex := boundaryMetric elementaryMoves chosenHolonomyUnit +local instance boundaryConclusionMetric4 : PseudoMetricSpace BoundaryVertex := + (boundaryMetric elementaryMoves chosenHolonomyUnit).toPseudoMetricSpace +local instance boundaryConclusionMetric5 (j : ℕ) : MetricSpace (FiberVertex j) := + componentMetric elementaryMoves chosenHolonomyUnit j +local instance boundaryConclusionMetric6 : MetricSpace FiberedUnion := componentUnionMetric elementaryMoves chosenHolonomyUnit +local instance boundaryConclusionMetric7 : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnit + +def counterexampleClass (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : KX1 VertexUnion := + boundaryTotalCoarsening.homologyMap (boundaryLoopClass input hadd) + +theorem boundaryLoopClass_base_zero (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (homotopy : PublishedCompactHomotopyInput) (hfill : CountableAdditivityInput FilledDisc) : + boundaryBaseCoarsening.homologyMap (boundaryLoopClass input hadd) = 0 := by + change (embeddingCoarsening boundaryToBase + (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit)).homologyMap + (classAt 1 1 (by norm_num) (boundaryLoopStage input hadd)) = 0 + rw [embedding_classAt, boundaryLoopStage_base_zero input hadd homotopy hfill, classAt_zero] + +theorem counterexampleClass_image (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : + totalToFiberCoarsening.homologyMap (counterexampleClass input hadd) = + concreteFiberClass input hadd := by + change (embeddingCoarsening totalToFiber.toEmbedding + (fun x y => (totalToFiber_dist x y).le)).homologyMap + ((embeddingCoarsening boundaryToVertex + (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit)).homologyMap + (classAt 1 1 (by norm_num) (boundaryLoopStage input hadd))) = _ + rw [embedding_classAt, embedding_classAt] + have hs : pushforward (embeddingMap totalToFiber.toEmbedding + (fun x y => (totalToFiber_dist x y).le) 1) + (pushforward (embeddingMap boundaryToVertex + (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit) 1) + (boundaryLoopStage input hadd)) = realFiberStage input hadd 1 le_rfl := by + have hp := congrArg pushforward boundaryFamily_toFiber + have hv := DFunLike.congr_fun hp (boundaryCircleFamily input hadd) + simpa only [pushforward_comp, AddMonoidHom.comp_apply, boundaryLoopStage, + realFiberStage, fiberLoopsOne] using hv + rw [hs] + apply congrArg ((coarsening FiberedUnion).of 1) + exact realFiberStage_cast input hadd 1 le_rfl 1 le_rfl (by norm_num) + +theorem counterexampleClass_infinite_order (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) (n : ℤ) (hn : n ≠ 0) : + n • counterexampleClass input hadd ≠ 0 := by + intro hz + have h := congrArg totalToFiberCoarsening.homologyMap hz + rw [map_zsmul, map_zero, counterexampleClass_image] at h + exact concreteFiberClass_infinite_order input hadd n hn h + +theorem counterexampleClass_index_zero (circle : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (homotopy : PublishedCompactHomotopyInput) (hfill : CountableAdditivityInput FilledDisc) + (index : PublishedBoundaryAssemblyInput) (hgap : PublishedKazhdanInput) : + index.total.assembly (counterexampleClass circle hadd) = 0 := + boundary_assembly_zero index hgap (boundaryLoopClass circle hadd) + (boundaryLoopClass_base_zero circle hadd homotopy hfill) + +/-- The manuscript's bounded-geometry rational counterexample, conditional +only on the precisely cited published analytic inputs. -/ +theorem bounded_geometry_counterexample (circle : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (homotopy : PublishedCompactHomotopyInput) (hfill : CountableAdditivityInput FilledDisc) + (index : PublishedBoundaryAssemblyInput) (hgap : PublishedKazhdanInput) : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ index.total.assembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective index.total.assembly ∧ + ¬ Function.Injective (index.total.assembly.toIntLinearMap.lTensor ℚ) := by + refine ⟨vertexUnion_proper elementaryMoves chosenHolonomyUnit, + vertexUnion_uniform_balls elementaryMoves chosenHolonomyUnit, + vertexUnion_separated elementaryMoves chosenHolonomyUnit, + counterexampleClass circle hadd, counterexampleClass_infinite_order circle hadd, + counterexampleClass_index_zero circle hadd homotopy hfill index hgap, ?_, ?_, ?_⟩ + · exact rationalization_ne_zero _ (counterexampleClass_infinite_order circle hadd) + · exact (kernel_obstructs_injectivity index.total.assembly _ + (counterexampleClass_infinite_order circle hadd) + (counterexampleClass_index_zero circle hadd homotopy hfill index hgap)).1 + · exact (kernel_obstructs_injectivity index.total.assembly _ + (counterexampleClass_infinite_order circle hadd) + (counterexampleClass_index_zero circle hadd homotopy hfill index hgap)).2 + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryEmbedding.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..3eaee2092ce07c8eedb7d205ae3834b26fd98f18 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryEmbedding.lean @@ -0,0 +1,73 @@ +import OAI.Topology.CoarseAssembly.InclusionModule +import OAI.Topology.CoarseAssembly.ConcreteSpaces + +namespace OAI + +/-! # The exact spatial boundary factorization + +Boundary fibers have depth zero and are singletons. The normalized fiber +embedding therefore agrees exactly with the coordinate inclusion there, +which proves the operator factorization needed by assembly naturality. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +def BoundaryVertex := {u : BaseUnion // discDepth u.1 u.2 = 0} + +noncomputable instance boundaryVertexDecidableEq : DecidableEq BoundaryVertex := Classical.decEq _ + +def boundaryToBase : BoundaryVertex ↪ BaseUnion := ⟨Subtype.val, Subtype.val_injective⟩ + +def boundaryToVertex : BoundaryVertex ↪ VertexUnion where + toFun b := ⟨b.val, 1⟩ + inj' := by + intro b c h + apply Subtype.ext + exact congrArg Sigma.fst h + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def boundaryBaseIsometry : lp (fun _ : BoundaryVertex => H) 2 →ₗᵢ[ℂ] + lp (fun _ : BaseUnion => H) 2 := inclusionIsometry boundaryToBase + +def boundaryVertexIsometry : lp (fun _ : BoundaryVertex => H) 2 →ₗᵢ[ℂ] + lp (fun _ : VertexUnion => H) 2 := inclusionIsometry boundaryToVertex + +omit [CompleteSpace H] in +theorem fiberEmbedding_boundary : + (fiberEmbedding (H := H) BaseFiber).comp boundaryBaseIsometry = boundaryVertexIsometry := by + classical + have he : (fiberEmbedding (H := H) BaseFiber).toContinuousLinearMap.comp + (boundaryBaseIsometry.toContinuousLinearMap) = + boundaryVertexIsometry.toContinuousLinearMap := by + apply lp.ext_continuousLinearMap (by norm_num : (2 : ENNReal) ≠ ⊤) + intro b + apply ContinuousLinearMap.ext + intro h + change fiberEmbedding BaseFiber (inclusionIsometry boundaryToBase (lp.single 2 b h)) = + inclusionIsometry boundaryToVertex (lp.single 2 b h) + rw [inclusionIsometry_single, inclusionIsometry_single] + have : Subsingleton (BaseFiber b.val) := by + change Subsingleton (Quotient (discDepth b.val.1 b.val.2)) + rw [b.property] + infer_instance + exact fiberEmbedding_singleton BaseFiber b.val 1 h + apply DFunLike.ext + intro x + exact DFunLike.congr_fun he x + +theorem boundary_operator_factorization + (T : lp (fun _ : BoundaryVertex => H) 2 →L[ℂ] lp (fun _ : BoundaryVertex => H) 2) : + operatorConjugation (fiberEmbedding BaseFiber) (operatorConjugation boundaryBaseIsometry T) = + operatorConjugation boundaryVertexIsometry T := by + rw [operatorConjugation_comp, fiberEmbedding_boundary] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryGeometry.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..70e60b25f9eeb656e9584ac0e8c57c91c87c0bf5 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryGeometry.lean @@ -0,0 +1,84 @@ +import OAI.Topology.CoarseAssembly.BoundaryEmbedding +import OAI.Topology.CoarseAssembly.FilledWalks +import OAI.Topology.CoarseAssembly.RipsProperEmbedding +import OAI.Topology.CoarseAssembly.RoeInclusion + +namespace OAI + +/-! # The concrete proper boundary inclusions + +The boundary is the depth-zero vertex subset with the induced metric from +the total graph family. Its projection to the base is nonexpanding. These +are the actual two vertex inclusions used for assembly naturality. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic DiscreteRoe + +private theorem walk_image_dist_le {V Z : Type*} (G : SimpleGraph V) + [PseudoMetricSpace Z] (f : V → Z) + (hedge : ∀ x y, G.Adj x y → dist (f x) (f y) ≤ 1) + {x y : V} (p : G.Walk x y) : dist (f x) (f y) ≤ (p.length : ℝ) := by + induction p with + | nil => simp + | @cons x y z h p ih => + calc + dist (f x) (f z) ≤ dist (f x) (f y) + dist (f y) (f z) := dist_triangle _ _ _ + _ ≤ 1 + (p.length : ℝ) := add_le_add (hedge x y h) ih + _ = ((SimpleGraph.Walk.cons h p).length : ℝ) := by simp; ring + +theorem fiberProjection_nonexpanding (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + (j : ℕ) (x y : FiberVertex j) : + dist x.1 y.1 ≤ @dist _ (componentMetric S t j).toDist x y := by + obtain ⟨p, hp⟩ := (fiberedGraph_connected S t j).exists_walk_length_eq_dist x y + rw [componentMetric_eq] + change dist x.1 y.1 ≤ ((fiberedGraph S t j).dist x y : ℝ) + rw [← hp] + apply walk_image_dist_le (fiberedGraph S t j) (fun z => z.1) + intro u v h + obtain ⟨s, hs, hp, _⟩ := h.2 + rcases hp with hsame | ⟨hadj, _⟩ + · simp [hsame] + · exact discEdgeBound u.1 v.1 hadj + +theorem vertexProjection_nonexpanding (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + (x y : VertexUnion) : + dist x.1 y.1 ≤ @dist _ (vertexUnionMetric S t).toDist x y := by + let := componentMetric S t + rcases x with ⟨⟨i, u⟩, q⟩ + rcases y with ⟨⟨j, v⟩, z⟩ + change separatedDist discBoundaryBase ⟨i, u⟩ ⟨j, v⟩ ≤ + separatedDist fiberBoundaryBase ⟨i, ⟨u, q⟩⟩ ⟨j, ⟨v, z⟩⟩ + by_cases hij : i = j + · subst j + simp only [separatedDist_same] + exact fiberProjection_nonexpanding S t i ⟨u, q⟩ ⟨v, z⟩ + · rw [separatedDist_different discBoundaryBase hij, + separatedDist_different fiberBoundaryBase hij] + exact add_le_add + (add_le_add (fiberProjection_nonexpanding S t i ⟨u, q⟩ (fiberBoundaryBase i)) le_rfl) + (fiberProjection_nonexpanding S t j (fiberBoundaryBase j) ⟨v, z⟩) + +@[instance_reducible] def boundaryMetric (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + MetricSpace BoundaryVertex := by + exact MetricSpace.induced boundaryToVertex boundaryToVertex.injective (vertexUnionMetric S t) + +theorem boundaryToVertex_nonexpanding (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + ∀ x y, @dist VertexUnion (vertexUnionMetric S t).toDist + (boundaryToVertex x) (boundaryToVertex y) ≤ + @dist BoundaryVertex (boundaryMetric S t).toDist x y := + fun _ _ => le_rfl + +theorem boundaryToBase_nonexpanding (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + ∀ x y, dist (boundaryToBase x) (boundaryToBase y) ≤ + @dist BoundaryVertex (boundaryMetric S t).toDist x y := + fun x y => vertexProjection_nonexpanding S t (boundaryToVertex x) (boundaryToVertex y) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryIndex.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..c7a7859e8316ec08a71107a39c55afd3939596e5 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryIndex.lean @@ -0,0 +1,51 @@ +import Mathlib.Algebra.Group.Hom.Basic + +namespace OAI + +/-! +# The boundary index diagram + +The algebraic final calculation in §6 of the coarse Novikov manuscript. +This is a diagram lemma, not a definition or construction of coarse assembly. +The two naturality equations are the precise consequences of Willett--Yu, +*Higher Index Theory*, §§5.1, 6.7, 7.1--7.2 used in that calculation. +The geometric filling and operator factorization remain separate obligations. +-/ + +namespace CoarseAssembly + +variable {HB HD HX KB KD KX : Type*} +variable [AddCommGroup HB] [AddCommGroup HD] [AddCommGroup HX] +variable [AddCommGroup KB] [AddCommGroup KD] [AddCommGroup KX] + +/-- Naturality and an actual factorization through a filling annihilate the +index of the included boundary. `filled` is the conclusion of the geometric +filling argument, and `factor` is induced by the proved operator identity +`V E = I`. Neither is being declared to be a published input. -/ +theorem boundary_index_zero + (e : HB →+ HD) (i : HB →+ HX) + (μB : HB →+ KB) (μD : HD →+ KD) (μX : HX →+ KX) + (eRoe : KB →+ KD) (iRoe : KB →+ KX) (transfer : KD →+ KX) + (natural_e : μD.comp e = eRoe.comp μB) + (natural_i : μX.comp i = iRoe.comp μB) + (factor : transfer.comp eRoe = iRoe) + (β : HB) (filled : e β = 0) : μX (i β) = 0 := by + calc + μX (i β) = iRoe (μB β) := DFunLike.congr_fun natural_i β + _ = transfer (eRoe (μB β)) := (DFunLike.congr_fun factor (μB β)).symm + _ = transfer (μD (e β)) := congrArg transfer (DFunLike.congr_fun natural_e β).symm + _ = 0 := by rw [filled, map_zero, map_zero] + +/-- A filling through a group which is zero makes every boundary class vanish. +In the manuscript the middle group is locally finite K-homology of the +countable union of compact discs, using Blackadar Theorem 19.7.1, +Proposition 17.9.1, and §19.8.3. -/ +theorem boundary_filling_zero {HW : Type*} [AddCommGroup HW] [Subsingleton HW] + (boundary : HB →+ HW) (inclusion : HW →+ HD) (β : HB) : + (inclusion.comp boundary) β = 0 := by + have h : boundary β = 0 := Subsingleton.elim _ _ + simp [h] + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryLoopMaps.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryLoopMaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..7c8fda189c4367a109b9dfdc50e617b613daa847 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryLoopMaps.lean @@ -0,0 +1,184 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.BoundaryComponents +import OAI.Topology.CoarseAssembly.HexagonSides +import OAI.Topology.CoarseAssembly.RipsMapCalculus +import OAI.Topology.CoarseAssembly.FamilyFilling +import OAI.Topology.CoarseAssembly.FiberedPersistence +import OAI.Topology.CoarseAssembly.KazhdanInput +import OAI.Topology.CoarseAssembly.ConcretePersistence +import OAI.Topology.CoarseAssembly.RipsRealClass + +namespace OAI + +/-! # The same boundary family maps to the filled base and detected total space + +The source class is defined on the actual boundary Rips complex. Its base +image is identified with the previously constructed filled loop family. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance boundaryLoopMetric1 (j : ℕ) : MetricSpace (BoundaryComponent j) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit j +local instance boundaryLoopMetric2 (j : ℕ) : PseudoMetricSpace (BoundaryComponent j) := + (boundaryComponentMetric elementaryMoves chosenHolonomyUnit j).toPseudoMetricSpace +local instance boundaryLoopMetric3 : MetricSpace (Sigma BoundaryComponent) := + boundaryComponentsMetric elementaryMoves chosenHolonomyUnit +local instance boundaryLoopMetric4 : MetricSpace BoundaryVertex := boundaryMetric elementaryMoves chosenHolonomyUnit +local instance boundaryLoopMetric5 : PseudoMetricSpace BoundaryVertex := + (boundaryMetric elementaryMoves chosenHolonomyUnit).toPseudoMetricSpace +local instance boundaryLoopMetric6 (j : ℕ) : MetricSpace (FiberVertex j) := + componentMetric elementaryMoves chosenHolonomyUnit j +attribute [local instance] OAI.CoarseAssembly.boundaryLoopMetric7 + +attribute [local instance] OAI.CoarseAssembly.boundaryLoopMetric8 + +theorem totalToFiber_dist (x y : VertexUnion) : dist (totalToFiber x) (totalToFiber y) = dist x y := rfl + +def boundaryLoops (j : ℕ) : C(WindingCircle, Point (BoundaryComponent j) 1) := + loopCircle (walkPath (by norm_num) (boundaryEdgeBound elementaryMoves chosenHolonomyUnit) + (hexagonalWalk j)) + +def boundaryLoopStage (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : LocallyFiniteK1 (Point BoundaryVertex 1) := + pushforward (boundaryFamilyMap elementaryMoves chosenHolonomyUnit 1 boundaryLoops) + (boundaryCircleFamily input hadd) + +def boundaryLoopClass (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : KX1 BoundaryVertex := + classAt 1 1 (by norm_num) (boundaryLoopStage input hadd) + +def boundaryComponentToBase (j : ℕ) : BoundaryComponent j ↪ Disc j := + ⟨Subtype.val, Subtype.val_injective⟩ + +theorem boundaryComponentToBase_nonexpanding (j : ℕ) (x y : BoundaryComponent j) : + dist (boundaryComponentToBase j x) (boundaryComponentToBase j y) ≤ dist x y := + fiberProjection_nonexpanding elementaryMoves chosenHolonomyUnit j + (boundaryFiberEmbedding j x) (boundaryFiberEmbedding j y) + +def concreteBaseWalk (j : ℕ) : + (discGraph j).Walk (discBoundaryBase j) (discBoundaryBase j) := + (hexagonalWalk j).map (boundaryBaseHom j) + +theorem boundaryLoop_base (j : ℕ) (z : WindingCircle) : + mapPoint (boundaryComponentToBase j) (boundaryComponentToBase_nonexpanding j) + (boundaryLoops j z) = baseBoundaryLoops discBoundaryBase concreteBaseWalk j z := by + exact mapPoint_loopCircle (boundaryComponentToBase j) (boundaryComponentToBase_nonexpanding j) + (fun _ _ h => h) (by norm_num) (boundaryEdgeBound elementaryMoves chosenHolonomyUnit) + discEdgeBound (hexagonalWalk j) z + +theorem boundaryFamily_toBase : + (embeddingMap boundaryToBase + (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit) 1).comp + (boundaryFamilyMap elementaryMoves chosenHolonomyUnit 1 boundaryLoops) = + ripsFamilyMap discBoundaryBase 1 (baseBoundaryLoops discBoundaryBase concreteBaseWalk) := by + apply CocompactMap.ext + rintro ⟨j, z⟩ + change mapPoint boundaryToBase (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit) + (mapPoint boundaryReindex.toEmbedding + (fun x y => (boundaryReindex_dist elementaryMoves chosenHolonomyUnit x y).le) + (mapPoint (separatedComponent j) + (fun x y => ((separatedComponent_isometry boundaryRoot j).dist_eq x y).le) + (boundaryLoops j z))) = + mapPoint (separatedComponent j) + (fun x y => ((separatedComponent_isometry discBoundaryBase j).dist_eq x y).le) + (baseBoundaryLoops discBoundaryBase concreteBaseWalk j z) + rw [← boundaryLoop_base j z] + apply Point.ext + simp only [mapPoint_weight] + simp only [← Finsupp.embDomain_trans_apply] + have he : ((separatedComponent j).trans boundaryReindex.toEmbedding).trans boundaryToBase = + (boundaryComponentToBase j).trans (separatedComponent j) := by + apply Function.Embedding.ext + intro x + rfl + rw [he] + +theorem boundaryLoopStage_base_zero (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (homotopy : PublishedCompactHomotopyInput) (hfill : CountableAdditivityInput FilledDisc) : + pushforward (embeddingMap boundaryToBase + (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit) 1) + (boundaryLoopStage input hadd) = 0 := by + change pushforward _ (pushforward _ (boundaryCircleFamily input hadd)) = 0 + rw [← AddMonoidHom.comp_apply, ← pushforward_comp, boundaryFamily_toBase] + exact baseBoundaryFamily_zero discBoundaryBase concreteBaseWalk homotopy hfill _ + +def realFiberLoops (r : ℝ) (hr : 1 ≤ r) (j : ℕ) : + C(WindingCircle, Point (FiberVertex j) r) := by + exact loopCircle (walkPath (le_trans (by norm_num) hr) + (fun x y h => by + have he := graphEdgeBound (fiberedGraph_connected elementaryMoves chosenHolonomyUnit j) + 1 le_rfl x y h + have he' : dist x y ≤ 1 := by simpa only [Nat.cast_one] using he + exact he'.trans hr) + (hexagonalBoundaryWalks.fiberWalk elementaryMoves chosenHolonomyUnit j)) + +def fiberLoopsOne := realFiberLoops 1 le_rfl + +def realFiberStage (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) (r : ℝ) (hr : 1 ≤ r) : + LocallyFiniteK1 (Point FiberedUnion r) := + pushforward (ripsFamilyMap fiberBoundaryBase r (realFiberLoops r hr)) + (boundaryCircleFamily input hadd) + +theorem realFiberStage_cast (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) (n : ℕ) (hn : 1 ≤ n) + (r : ℝ) (hr : 1 ≤ r) (h : r = (n : ℝ)) : + (h ▸ realFiberStage input hadd r hr) = + fiberedBoundaryStage elementaryMoves + (hexagonalBoundaryWalks.fiberWalk elementaryMoves chosenHolonomyUnit) input hadd n hn := by + subst r + rfl + +theorem boundaryLoop_fiber (j : ℕ) (z : WindingCircle) : + mapPoint (boundaryFiberEmbedding j) (fun _ _ => le_rfl) (boundaryLoops j z) = + fiberLoopsOne j z := by + have h := mapPoint_loopCircle (boundaryFiberEmbedding j) (fun _ _ => le_rfl) + (fun _ _ h => boundaryFiber_adj elementaryMoves chosenHolonomyUnit h) (by norm_num) + (boundaryEdgeBound elementaryMoves chosenHolonomyUnit) + (fun x y h => by + have he := graphEdgeBound (fiberedGraph_connected elementaryMoves chosenHolonomyUnit j) + 1 le_rfl x y h + simpa only [Nat.cast_one] using he) + (hexagonalWalk j) z + exact h + +theorem boundaryFamily_toFiber : + (embeddingMap totalToFiber.toEmbedding (fun x y => (totalToFiber_dist x y).le) 1).comp + ((embeddingMap boundaryToVertex + (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit) 1).comp + (boundaryFamilyMap elementaryMoves chosenHolonomyUnit 1 boundaryLoops)) = + ripsFamilyMap fiberBoundaryBase 1 fiberLoopsOne := by + apply CocompactMap.ext + rintro ⟨j, z⟩ + change mapPoint totalToFiber.toEmbedding (fun x y => (totalToFiber_dist x y).le) + (mapPoint boundaryToVertex (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit) + (mapPoint boundaryReindex.toEmbedding + (fun x y => (boundaryReindex_dist elementaryMoves chosenHolonomyUnit x y).le) + (mapPoint (separatedComponent j) + (fun x y => ((separatedComponent_isometry boundaryRoot j).dist_eq x y).le) + (boundaryLoops j z)))) = + mapPoint (separatedComponent j) + (fun x y => ((separatedComponent_isometry fiberBoundaryBase j).dist_eq x y).le) + (fiberLoopsOne j z) + rw [← boundaryLoop_fiber j z] + apply Point.ext + simp only [mapPoint_weight] + simp only [← Finsupp.embDomain_trans_apply] + have he : (((separatedComponent j).trans boundaryReindex.toEmbedding).trans boundaryToVertex).trans + totalToFiber.toEmbedding = (boundaryFiberEmbedding j).trans (separatedComponent j) := by + apply Function.Embedding.ext + intro x + rfl + rw [he] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryRoePerturbation.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryRoePerturbation.lean new file mode 100644 index 0000000000000000000000000000000000000000..53d4ef453f2c65c5582acfaa82736583b7d529e2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryRoePerturbation.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.MultiplierBoundaryHomotopy + +namespace OAI + +/-! # Roe perturbations do not change the analytic boundary class -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance roePerturbationScalarTower : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance roePerturbationScalarComm : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp +local instance roePerturbationContinuousStar : ContinuousStar (Operator X H) := ⟨operator_star_continuous⟩ + +theorem multiplierBoundaryClass_roePerturbation + (F G : multiplierAlgebra (X := X) (H := H)) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hGd : G.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hGF : G.val - F.val ∈ algebra (X := X) (H := H)) : + multiplierBoundaryClass F hF hFd = multiplierBoundaryClass G hG hGd := by + let L : Interval → multiplierAlgebra (X := X) (H := H) := + fun t => F + (t.val : ℂ) • (G - F) + have hL : ∀ t, IsSelfAdjoint (L t) := by + intro t + change star (F + (t.val : ℂ) • (G - F)) = F + (t.val : ℂ) • (G - F) + simp only [star_add, star_smul, star_sub, hF.star_eq, hG.star_eq, + Complex.star_def, Complex.conj_ofReal] + have hLd : ∀ t, (L t).val ^ 2 - 1 ∈ algebra (X := X) (H := H) := by + intro t + let K : Operator X H := (t.val : ℂ) • (G.val - F.val) + have hK : K ∈ algebra (X := X) (H := H) := (algebra (X := X) (H := H)).smul_mem _ hGF + have hm := F.property ⟨K, hK⟩ + have he : (L t).val ^ 2 - 1 = (F.val ^ 2 - 1) + F.val * K + K * F.val + K * K := by + change (F.val + K) ^ 2 - 1 = _ + noncomm_ring + rw [he] + exact add_mem (add_mem (add_mem hFd hm.1) hm.2) (mul_mem hK hK) + have hc : Continuous L := by + exact continuous_const.add ((Complex.continuous_ofReal.comp continuous_subtype_val).smul + continuous_const) + have h0 : L start = F := by simp [L, start] + have h1 : L finish = G := by simp [L, finish] + have h := multiplierBoundaryClass_homotopy L hL hLd hc + simpa only [h0, h1] using h + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundaryWalks.lean b/lean/OAI/Topology/CoarseAssembly/BoundaryWalks.lean new file mode 100644 index 0000000000000000000000000000000000000000..70fa3de8679b589dc36ea59113004531ad8a2391 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundaryWalks.lean @@ -0,0 +1,98 @@ +import OAI.Topology.CoarseAssembly.BoundaryGeometry +import Mathlib.Combinatorics.SimpleGraph.Walk.Maps + +namespace OAI + +/-! # Boundary walks and their canonical lifts + +Depth-zero fibers are singletons, so every edge of the actual boundary +subgraph has its unique lift. The walk construction and charge comparison +here leave only the explicit hexagonal boundary walk to be supplied. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +def BoundaryComponent (j : ℕ) := {u : Disc j // discDepth j u = 0} + +noncomputable instance (j : ℕ) : Fintype (BoundaryComponent j) := + inferInstanceAs (Fintype {u : Disc j // discDepth j u = 0}) + +def boundaryGraph (j : ℕ) : SimpleGraph (BoundaryComponent j) := + (discGraph j).induce {u | discDepth j u = 0} + +def boundaryRoot (j : ℕ) : BoundaryComponent j := ⟨discBoundaryBase j, discBoundaryBase_depth j⟩ + +def boundaryFiberEmbedding (j : ℕ) : BoundaryComponent j ↪ FiberVertex j where + toFun u := ⟨u.val, 1⟩ + inj' _ _ h := Subtype.ext (congrArg Sigma.fst h) + +theorem boundaryFiber_adj (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) {j : ℕ} + {u v : BoundaryComponent j} (h : (boundaryGraph j).Adj u v) : + (fiberedGraph S t j).Adj (boundaryFiberEmbedding j u) (boundaryFiberEmbedding j v) := by + refine ⟨?_, 1, one_mem_symmetricMoves S, Or.inr ⟨h, rfl⟩, ?_⟩ + · intro he + have huv := (boundaryFiberEmbedding j).injective he + exact h.2.2.2 (congrArg (fun w : BoundaryComponent j => w.val.val) huv) + · intro l hl _ + have hl0 : l = 0 := by + change l ≤ discDepth j u.val at hl + rw [u.property] at hl + omega + subst l + exact Subsingleton.elim _ _ + +def boundaryFiberHom (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) (j : ℕ) : + boundaryGraph j →g fiberedGraph S t j where + toFun := boundaryFiberEmbedding j + map_rel' := boundaryFiber_adj S t + +def boundaryBaseHom (j : ℕ) : boundaryGraph j →g discGraph j := + (SimpleGraph.Embedding.induce _).toHom + +theorem walkCharge_map {X Y : Type*} {G : SimpleGraph X} {H : SimpleGraph Y} + (f : G →g H) (a : Y → Y → ℤ) {u v : X} (p : G.Walk u v) : + walkCharge a (p.map f) = walkCharge (fun x y => a (f x) (f y)) p := by + induction p with + | nil => rfl + | cons h p ih => simp only [SimpleGraph.Walk.map_cons, walkCharge_cons, ih] + +theorem walkCharge_copy {X : Type*} {G : SimpleGraph X} (a : X → X → ℤ) + {u v u' v' : X} (p : G.Walk u v) (hu : u = u') (hv : v = v') : + walkCharge a (p.copy hu hv) = walkCharge a p := by + subst u' v' + rfl + +theorem boundary_walk_charge (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) {j : ℕ} + {u v : BoundaryComponent j} (p : (boundaryGraph j).Walk u v) : + walkCharge fiberCharge (p.map (boundaryFiberHom S t j)) = + walkCharge (fun x y : Disc j => latticeCharge x.val y.val) (p.map (boundaryBaseHom j)) := by + rw [walkCharge_map, walkCharge_map] + rfl + +/-- Geometric data still to be constructed from the six sides of the +hexagon. These are own-paper obligations, not a published-input interface. -/ +structure HexagonalBoundaryWalks where + walk : ∀ j, (boundaryGraph j).Walk (boundaryRoot j) (boundaryRoot j) + charge_one : ∀ j, 2 ≤ j → + walkCharge (fun x y : Disc j => latticeCharge x.val y.val) + ((walk j).map (boundaryBaseHom j)) = 1 + +def HexagonalBoundaryWalks.fiberWalk (w : HexagonalBoundaryWalks) + (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) (j : ℕ) : + (fiberedGraph S t j).Walk (fiberBoundaryBase j) (fiberBoundaryBase j) := + (w.walk j).map (boundaryFiberHom S t j) + +theorem HexagonalBoundaryWalks.fiber_charge_one (w : HexagonalBoundaryWalks) + (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) (j : ℕ) (hj : 2 ≤ j) : + walkCharge fiberCharge (w.fiberWalk S t j) = 1 := by + exact (boundary_walk_charge S t (w.walk j)).trans (w.charge_one j hj) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedCycleTransform.lean b/lean/OAI/Topology/CoarseAssembly/BoundedCycleTransform.lean new file mode 100644 index 0000000000000000000000000000000000000000..f31df787ab83b75c3e056a620b48c571221a7f51 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedCycleTransform.lean @@ -0,0 +1,55 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.BoundedTransformCompact + +namespace OAI + +/-! # Rational normalization of unital self-adjoint cycles and homotopies -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem OddCycle.boundedTransform_compact (c : OddCycle A) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : + IsCompactOperator (boundedTransform c.operator hs - c.operator : End c.space) := by + apply boundedTransform_sub_compact + simpa only [hπ, mul_one] using c.square_compact 1 + +theorem OddCycle.boundedTransform_star_compact (c : OddCycle A) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : + IsCompactOperator (star (boundedTransform c.operator hs - c.operator) : End c.space) := by + rw [((boundedTransform_selfAdjoint c.operator hs).sub hs).star_eq] + exact c.boundedTransform_compact hπ hs + +theorem OddCycle.bounded_class (c : OddCycle A) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : + cycleClass A (c.bounded hπ hs) = cycleClass A c := by + have he : c.bounded hπ hs = c.compactPerturb _ (c.boundedTransform_compact hπ hs) + (c.boundedTransform_star_compact hπ hs) := by + simp only [bounded, compactPerturb, add_sub_cancel] + rw [he] + exact compactPerturb_class _ _ _ _ + +def OddHomotopy.bounded (h : OddHomotopy A) + (hπ : ∀ t, h.representation t 1 = 1) (hs : ∀ t, IsSelfAdjoint (h.operator t)) : + OddHomotopy A where + space := h.space + representation := h.representation + operator t := boundedTransform (h.operator t) (hs t) + continuous_representation := h.continuous_representation + continuous_operator := continuous_boundedTransform h.operator hs h.continuous_operator + commutator_compact t a := ((h.eval t).bounded (hπ t) (hs t)).commutator_compact a + square_compact t a := ((h.eval t).bounded (hπ t) (hs t)).square_compact a + adjoint_compact t a := ((h.eval t).bounded (hπ t) (hs t)).adjoint_compact a + +@[simp] theorem OddHomotopy.bounded_eval (h : OddHomotopy A) + (hπ : ∀ t, h.representation t 1 = 1) (hs : ∀ t, IsSelfAdjoint (h.operator t)) (t : Interval) : + (h.bounded hπ hs).eval t = (h.eval t).bounded (hπ t) (hs t) := rfl + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedFamilyHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/BoundedFamilyHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..f981c71d427646fc93898c81b33f33680a3af04f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedFamilyHomotopy.lean @@ -0,0 +1,77 @@ +import OAI.Topology.CoarseAssembly.ControlledRipsCycles +import OAI.Topology.CoarseAssembly.SampledHomotopyDecomposition +import OAI.Topology.CoarseAssembly.SampledRipsEstimates + +namespace OAI + +/-! # Bounded analytic homotopies without uniform continuity assumptions -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable (Q : ℕ → Type) [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] (r : ℝ) + +structure BoundedFamilyHomotopy where + homotopy : ∀ i, OddHomotopy C(Point (Q i) r, ℂ) + unital : ∀ t i, (homotopy i).representation t 1 = 1 + selfAdjoint : ∀ t i, IsSelfAdjoint ((homotopy i).operator t) + bound : ℝ + one_le_bound : 1 ≤ bound + norm_le : ∀ t i, ‖(homotopy i).operator t‖ ≤ bound + +variable {Q r} + +namespace BoundedFamilyHomotopy + +def eval (h : BoundedFamilyHomotopy Q r) (τ : ℕ → Interval) : ControlledCycleFamily Q r where + cycle i := (h.homotopy i).eval (τ i) + unital i := h.unital (τ i) i + selfAdjoint i := h.selfAdjoint (τ i) i + bound := h.bound + bound_nonneg := zero_le_one.trans h.one_le_bound + norm_le i := h.norm_le (τ i) i + +def sample (h : BoundedFamilyHomotopy Q r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (N : ℕ → ℕ) (τ : ℕ → ℕ → Interval) : ControlledCycleFamily Q r where + cycle i := sampledFiniteSum (h.homotopy i) (χ i) (N i) (τ i) h.bound h.one_le_bound + (fun t => h.norm_le t i) + unital i := sampledFiniteSum_unital _ _ _ _ _ _ _ (fun t => h.unital t i) + selfAdjoint i := sampledFiniteSum_selfAdjoint _ _ _ _ _ _ _ (fun t => h.selfAdjoint t i) + bound := h.bound + bound_nonneg := zero_le_one.trans h.one_le_bound + norm_le _ := sampledFiniteSum_norm_le _ _ _ _ _ _ _ + +theorem sample_head_tail_boundary (h : BoundedFamilyHomotopy Q r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (o : ∀ i, Q i) (hr : 0 ≤ r) (N : ℕ → ℕ) (τ : ℕ → ℕ → Interval) : + (h.sample χ (fun i => N i + 1) τ).boundary o hr = + (h.eval (fun i => τ i 0)).boundary o hr + + (h.sample χ N (fun i j => τ i (j + 1))).boundary o hr := by + let := separatedMetric o + exact ampleRipsFamilyBoundary_directSum o r hr _ _ _ + (fun i => sampledFiniteSum_head_tail (h.homotopy i) (χ i) (N i) (τ i) + h.bound h.one_le_bound (fun t => h.norm_le t i)) + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +theorem sample_rotate_boundary (h : BoundedFamilyHomotopy Q r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (o : ∀ i, Q i) (hr : 0 ≤ r) (N : ℕ → ℕ) (τ : ℕ → ℕ → Interval) : + (h.sample χ (fun i => N i + 1) (fun i => lastEndpointFirst (N i) (τ i))).boundary o hr = + (h.sample χ (fun i => N i + 1) (fun i j => τ i (j + 1))).boundary o hr := by + let := separatedMetric o + exact ampleRipsFamilyBoundary_unitary o r hr _ _ + (fun i => sampledFiniteSum_rotate (h.homotopy i) (χ i) (N i) (τ i) + h.bound h.one_le_bound (fun t => h.norm_le t i)) _ _ _ _ _ _ _ _ _ _ + +end BoundedFamilyHomotopy + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedFamilySubdivision.lean b/lean/OAI/Topology/CoarseAssembly/BoundedFamilySubdivision.lean new file mode 100644 index 0000000000000000000000000000000000000000..8bf66b12f0603bd2f98bf7757029a4621078114b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedFamilySubdivision.lean @@ -0,0 +1,108 @@ +import OAI.Topology.CoarseAssembly.BoundedFamilyHomotopy +import OAI.Topology.CoarseAssembly.HomotopySubdivision +import OAI.Topology.CoarseAssembly.ControlledBoundaryNearby + +namespace OAI + +/-! # Component-dependent subdivisions with uniformly close sampled Roe operators -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +namespace BoundedFamilyHomotopy + +def samplingTolerance (h : BoundedFamilyHomotopy Q r) (i : ℕ) : ℝ := + 1 / (8 * (1 + (4 * h.bound + 2) * Fintype.card (Q i))) + +omit [∀ i, DecidableEq (Q i)] in +theorem samplingTolerance_pos (h : BoundedFamilyHomotopy Q r) (i : ℕ) : + 0 < h.samplingTolerance i := by + have hb : 0 ≤ h.bound := zero_le_one.trans h.one_le_bound + unfold samplingTolerance + positivity + +omit [∀ i, DecidableEq (Q i)] in +theorem samplingTolerance_estimate (h : BoundedFamilyHomotopy Q r) (i : ℕ) : + h.samplingTolerance i + (4 * h.bound + 2) * + ((Fintype.card (Q i) : ℝ) * h.samplingTolerance i) = 1 / 8 := by + have hb : 0 ≤ h.bound := zero_le_one.trans h.one_le_bound + have hd : 0 < 1 + (4 * h.bound + 2) * (Fintype.card (Q i) : ℝ) := by positivity + unfold samplingTolerance + field_simp + +omit [∀ i, DecidableEq (Q i)] in +theorem exists_small_subdivision (h : BoundedFamilyHomotopy Q r) : + ∃ (N : ℕ → ℕ) (τ : ℕ → ℕ → Interval), + (∀ i, τ i 0 = start) ∧ (∀ i, τ i (N i + 1) = finish) ∧ + ∀ i j, j < N i + 1 → + ‖(h.homotopy i).operator (τ i (j + 1)) - (h.homotopy i).operator (τ i j)‖ ≤ + h.samplingTolerance i ∧ + ∀ x, ‖(h.homotopy i).representation (τ i (j + 1)) (sqrtCoordinate r x) - + (h.homotopy i).representation (τ i j) (sqrtCoordinate r x)‖ ≤ h.samplingTolerance i := by + choose K hK hstep using fun i => exists_rips_homotopy_subdivision r (h.homotopy i) + (h.samplingTolerance i) (h.samplingTolerance_pos i) + refine ⟨(fun i => K i - 1), (fun i => intervalGrid (K i) (hK i)), ?_, ?_, ?_⟩ + · intro i + exact intervalGrid_start _ _ + · intro i + have hk := hK i + have hi : K i - 1 + 1 = K i := by omega + dsimp only + rw [hi] + exact intervalGrid_finish _ _ + · intro i j hj + apply hstep i j + dsimp only at hj + have hk := hK i + omega + +structure SmallSubdivision (h : BoundedFamilyHomotopy Q r) where + count : ℕ → ℕ + time : ℕ → ℕ → Interval + at_start : ∀ i, time i 0 = start + at_finish : ∀ i, time i (count i + 1) = finish + step : ∀ i j, j < count i + 1 → + ‖(h.homotopy i).operator (time i (j + 1)) - (h.homotopy i).operator (time i j)‖ ≤ + h.samplingTolerance i ∧ + ∀ x, ‖(h.homotopy i).representation (time i (j + 1)) (sqrtCoordinate r x) - + (h.homotopy i).representation (time i j) (sqrtCoordinate r x)‖ ≤ h.samplingTolerance i + +def smallSubdivision (h : BoundedFamilyHomotopy Q r) : SmallSubdivision h := by + let N := Classical.choose h.exists_small_subdivision + have hN := Classical.choose_spec h.exists_small_subdivision + let τ := Classical.choose hN + have ht := Classical.choose_spec hN + exact ⟨N, τ, ht.1, ht.2.1, ht.2.2⟩ + +theorem sampled_boundary_eq (h : BoundedFamilyHomotopy Q r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (o : ∀ i, Q i) (hr : 0 ≤ r) (N : ℕ → ℕ) (τ : ℕ → ℕ → Interval) + (hstep : ∀ i j, j < N i + 1 → + ‖(h.homotopy i).operator (τ i (j + 1)) - (h.homotopy i).operator (τ i j)‖ ≤ + h.samplingTolerance i ∧ + ∀ x, ‖(h.homotopy i).representation (τ i (j + 1)) (sqrtCoordinate r x) - + (h.homotopy i).representation (τ i j) (sqrtCoordinate r x)‖ ≤ h.samplingTolerance i) : + (h.sample χ (fun i => N i + 1) τ).boundary o hr = + (h.sample χ (fun i => N i + 1) (fun i j => τ i (j + 1))).boundary o hr := by + apply ControlledCycleFamily.boundary_eq_of_ample_nearby _ _ o hr (1 / 8) + (by norm_num) (by norm_num) + intro i + exact (sampledFiniteSum_ample_sub_norm_le r (h.homotopy i) (χ i) (N i + 1) + (fun j => τ i (j + 1)) (τ i) h.bound h.one_le_bound (fun t => h.norm_le t i) + (fun t => h.unital t i) (h.samplingTolerance i) (h.samplingTolerance_pos i).le + (fun j hj => (hstep i j hj).1) (fun x j hj => (hstep i j hj).2 x)).trans + (h.samplingTolerance_estimate i).le + +end BoundedFamilyHomotopy + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedGeometry.lean b/lean/OAI/Topology/CoarseAssembly/BoundedGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..219eecdd8f48d386e8c02b2c96bcc4ccf5b623dc --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedGeometry.lean @@ -0,0 +1,95 @@ +import Mathlib.Combinatorics.SimpleGraph.Metric +import Mathlib.Data.Finset.Union +import Mathlib.Data.Set.Card +import Mathlib.Algebra.Order.BigOperators.Group.Finset +import Mathlib.Tactic.Positivity +import Mathlib.Tactic.Ring + +namespace OAI + +/-! +# Uniformly bounded degree gives uniformly finite graph balls + +The elementary bounded-geometry argument used in §3 of the coarse Novikov +manuscript. Finite neighbor lists are supplied for an arbitrary graph; no +finiteness assumption is made about the whole vertex set. The bound +`(degreeBound + 1)^radius` is sufficient for the application. +-/ + +namespace CoarseAssembly + +variable {V : Type*} [DecidableEq V] + +/-- A finite over-approximation of vertices reached in at most `r` edges. -/ +def walkBall (neighbors : V → Finset V) (x : V) : ℕ → Finset V + | 0 => {x} + | r + 1 => walkBall neighbors x r ∪ (walkBall neighbors x r).biUnion neighbors + +@[simp] theorem mem_walkBall_zero (neighbors : V → Finset V) (x y : V) : + y ∈ walkBall neighbors x 0 ↔ y = x := by simp [walkBall] + +theorem walkBall_mono_step (neighbors : V → Finset V) (x : V) (r : ℕ) : + walkBall neighbors x r ⊆ walkBall neighbors x (r + 1) := + Finset.subset_union_left + +theorem walkBall_mono (neighbors : V → Finset V) (x : V) {r s : ℕ} (h : r ≤ s) : + walkBall neighbors x r ⊆ walkBall neighbors x s := by + induction h with + | refl => exact Finset.Subset.refl _ + | @step s h ih => exact ih.trans (walkBall_mono_step neighbors x s) + +/-- A uniform degree bound bounds every finite combinatorial ball. -/ +theorem card_walkBall_le (neighbors : V → Finset V) (d : ℕ) + (hd : ∀ v, (neighbors v).card ≤ d) (x : V) (r : ℕ) : + (walkBall neighbors x r).card ≤ (d + 1) ^ r := by + induction r with + | zero => simp [walkBall] + | succ r ih => + calc + (walkBall neighbors x (r + 1)).card ≤ + (walkBall neighbors x r).card + ((walkBall neighbors x r).biUnion neighbors).card := + Finset.card_union_le _ _ + _ ≤ (walkBall neighbors x r).card + (walkBall neighbors x r).card * d := by + exact Nat.add_le_add_left + (Finset.card_biUnion_le_card_mul _ _ _ (fun v _ => hd v)) _ + _ = (d + 1) * (walkBall neighbors x r).card := by ring + _ ≤ (d + 1) * (d + 1) ^ r := Nat.mul_le_mul_left _ ih + _ = (d + 1) ^ (r + 1) := by rw [pow_succ, Nat.mul_comm] + +variable {G : SimpleGraph V} + +/-- Each walk endpoint belongs to the finite ball of its length. -/ +theorem endpoint_mem_walkBall (neighbors : V → Finset V) + (hN : ∀ u v, G.Adj u v → v ∈ neighbors u) {x y : V} (p : G.Walk x y) : + y ∈ walkBall neighbors x p.length := by + induction p using SimpleGraph.Walk.concatRec with + | Hnil => simp [walkBall] + | @Hconcat x y z p h ih => + rw [SimpleGraph.Walk.length_concat] + exact Finset.mem_union_right _ (Finset.mem_biUnion.mpr ⟨y, ih, hN y z h⟩) + +/-- Closed graph balls are finite, uniformly in the center. -/ +theorem finite_edist_ball (neighbors : V → Finset V) + (hN : ∀ u v, G.Adj u v → v ∈ neighbors u) (x : V) (r : ℕ) : + {y | G.edist x y ≤ (r : ℕ∞)}.Finite := by + apply (walkBall neighbors x r).finite_toSet.subset + intro y hy + obtain ⟨p, hp⟩ := G.exists_walk_of_edist_ne_top (ne_of_lt (lt_of_le_of_lt hy (by simp))) + have hlen : p.length ≤ r := by exact_mod_cast hp.trans_le hy + exact walkBall_mono neighbors x hlen (endpoint_mem_walkBall neighbors hN p) + +/-- An explicit cardinal bound independent of the center. -/ +theorem ncard_edist_ball_le (neighbors : V → Finset V) (d : ℕ) + (hN : ∀ u v, G.Adj u v → v ∈ neighbors u) + (hd : ∀ v, (neighbors v).card ≤ d) (x : V) (r : ℕ) : + Set.ncard {y | G.edist x y ≤ (r : ℕ∞)} ≤ (d + 1) ^ r := by + apply le_trans (Set.ncard_le_ncard ?_ (walkBall neighbors x r).finite_toSet) + (by simpa using card_walkBall_le neighbors d hd x r) + intro y hy + obtain ⟨p, hp⟩ := G.exists_walk_of_edist_ne_top (ne_of_lt (lt_of_le_of_lt hy (by simp))) + have hlen : p.length ≤ r := by exact_mod_cast hp.trans_le hy + exact walkBall_mono neighbors x hlen (endpoint_mem_walkBall neighbors hN p) + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedRipsTransform.lean b/lean/OAI/Topology/CoarseAssembly/BoundedRipsTransform.lean new file mode 100644 index 0000000000000000000000000000000000000000..7b08bde65bca1bb87cfb1d851ff2e217d3fe0d40 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedRipsTransform.lean @@ -0,0 +1,50 @@ +import OAI.Topology.CoarseAssembly.BoundedCycleTransform +import OAI.Topology.CoarseAssembly.ControlledRipsCycles +import OAI.Topology.CoarseAssembly.RipsFamilyCompactPerturbation + +namespace OAI + +/-! # Normalizing a bounded Rips cycle family preserves its actual Roe boundary -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + +theorem ampleRipsOperator_bounded_sub_compact (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : + IsCompactOperator (ampleRipsOperator r (c.bounded hπ hs) hπ - ampleRipsOperator r c hπ) := by + change IsCompactOperator + (isometricExtension (coefficientIsometry (ampleIsometry c.space)) + (localizedSpatialOperator (representedSqrt r c) (representedSqrt_partition r c hπ) + (boundedTransform c.operator hs)) - + isometricExtension (coefficientIsometry (ampleIsometry c.space)) + (localizedSpatialOperator (representedSqrt r c) (representedSqrt_partition r c hπ) c.operator)) + apply isometricExtension_sub_compact + exact localizedSpatialOperator_sub_compact _ _ _ _ (c.boundedTransform_compact hπ hs) + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +def ControlledCycleFamily.bounded (c : ControlledCycleFamily Q r) : ControlledCycleFamily Q r where + cycle i := (c.cycle i).bounded (c.unital i) (c.selfAdjoint i) + unital := c.unital + selfAdjoint _ := boundedTransform_selfAdjoint _ _ + bound := 1 + bound_nonneg := zero_le_one + norm_le _ := boundedTransform_norm_le _ _ + +theorem ControlledCycleFamily.bounded_boundary (c : ControlledCycleFamily Q r) + (o : ∀ i, Q i) (hr : 0 ≤ r) : c.bounded.boundary o hr = c.boundary o hr := by + let := separatedMetric o + exact ampleRipsFamilyBoundary_eq_of_compact o r hr _ _ _ _ _ _ _ _ _ _ _ _ + (fun i => ampleRipsOperator_bounded_sub_compact r (c.cycle i) (c.unital i) (c.selfAdjoint i)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedTransform.lean b/lean/OAI/Topology/CoarseAssembly/BoundedTransform.lean new file mode 100644 index 0000000000000000000000000000000000000000..286c1bd49970485936581652f4df82fc6946dfe4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedTransform.lean @@ -0,0 +1,48 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CayleyContinuity +import OAI.Topology.CoarseAssembly.CayleyNormControl +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation +import Mathlib.Tactic.Module + +namespace OAI + +/-! # A continuous bounded transform of self-adjoint Fredholm operators + +The imaginary part of the Cayley transform is the rational function +`2x / (1 + x²)`. It is contractive and varies continuously even when the +original family has no uniform norm bound. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +theorem boundedTransform_selfAdjoint (F : A) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (boundedTransform F hF) := by + change star (boundedTransform F hF) = boundedTransform F hF + simp only [boundedTransform, star_smul, star_sub, star_star, Complex.star_def, + map_div₀, Complex.conj_I, map_ofNat, neg_div, neg_smul] + module + +theorem boundedTransform_norm_le (F : A) (hF : IsSelfAdjoint F) : + ‖boundedTransform F hF‖ ≤ 1 := by + nontriviality A + unfold boundedTransform + rw [norm_smul, norm_div, Complex.norm_I, Complex.norm_ofNat] + have hn := norm_sub_le (cayleyUnitary F hF : A) (star (cayleyUnitary F hF : A)) + rw [norm_star, CStarRing.norm_coe_unitary] at hn + nlinarith + +theorem continuous_boundedTransform {T : Type*} [TopologicalSpace T] + (F : T → A) (hF : ∀ t, IsSelfAdjoint (F t)) (hc : Continuous F) : + Continuous (fun t => boundedTransform (F t) (hF t)) := by + have hu := continuous_cayleyUnitary F hF hc + exact continuous_const.smul (hu.sub hu.star) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedTransformCompact.lean b/lean/OAI/Topology/CoarseAssembly/BoundedTransformCompact.lean new file mode 100644 index 0000000000000000000000000000000000000000..6ab619d908b34eb78b777cf747bb8c1f8deb6d1a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedTransformCompact.lean @@ -0,0 +1,98 @@ +import OAI.Topology.CoarseAssembly.BoundedTransform + +namespace OAI + +/-! # The bounded transform changes a unital Fredholm operator compactly -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +theorem cayleyDenominator_normSquare (F : A) (hF : IsSelfAdjoint F) : + (cayleyDenominator F hF : A) * star (cayleyDenominator F hF : A) = F * F + 1 := by + rw [cayleyDenominator_star, cayleyDenominator_val] + have hi : algebraMap ℂ A Complex.I * algebraMap ℂ A Complex.I = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hc := Algebra.commutes (R := ℂ) (A := A) Complex.I F + noncomm_ring [hc, hi] + +theorem cayleyUnitary_mul_normSquare (F : A) (hF : IsSelfAdjoint F) : + (cayleyUnitary F hF : A) * + ((cayleyDenominator F hF : A) * star (cayleyDenominator F hF : A)) = + star (cayleyDenominator F hF : A) * star (cayleyDenominator F hF : A) := by + rw [cayleyUnitary_val] + calc + _ = star (cayleyDenominator F hF : A) * + (((↑(cayleyDenominator F hF)⁻¹ : A) * (cayleyDenominator F hF : A)) * + star (cayleyDenominator F hF : A)) := by noncomm_ring + _ = _ := by rw [Units.inv_mul, one_mul] + +theorem star_cayleyUnitary_mul_normSquare (F : A) (hF : IsSelfAdjoint F) : + star (cayleyUnitary F hF : A) * + ((cayleyDenominator F hF : A) * star (cayleyDenominator F hF : A)) = + (cayleyDenominator F hF : A) * (cayleyDenominator F hF : A) := by + let b := cayleyDenominator F hF + have hc : Commute (b : A) (star (b : A)) := (cayleyDenominator_normal F hF).symm + rw [cayleyUnitary_val, star_mul, star_star, ← Units.coe_star_inv] + change ((↑(star b)⁻¹ : A) * (b : A)) * ((b : A) * star (b : A)) = (b : A) * (b : A) + calc + _ = (↑(star b)⁻¹ : A) * ((b : A) * ((b : A) * star (b : A))) := by noncomm_ring + _ = (↑(star b)⁻¹ : A) * ((b : A) * (star (b : A) * (b : A))) := by rw [hc.eq] + _ = (↑(star b)⁻¹ : A) * (((b : A) * star (b : A)) * (b : A)) := by noncomm_ring + _ = (↑(star b)⁻¹ : A) * ((star (b : A) * (b : A)) * (b : A)) := by rw [hc.eq] + _ = ((↑(star b)⁻¹ : A) * star (b : A)) * ((b : A) * (b : A)) := by noncomm_ring + _ = _ := by rw [← Units.coe_star, Units.inv_mul, one_mul] + +theorem boundedTransform_mul_normSquare (F : A) (hF : IsSelfAdjoint F) : + boundedTransform F hF * + ((cayleyDenominator F hF : A) * star (cayleyDenominator F hF : A)) = (2 : ℂ) • F := by + unfold boundedTransform + rw [smul_mul_assoc, sub_mul, cayleyUnitary_mul_normSquare, star_cayleyUnitary_mul_normSquare] + have hp : star (cayleyDenominator F hF : A) * star (cayleyDenominator F hF : A) - + (cayleyDenominator F hF : A) * (cayleyDenominator F hF : A) = + (-4 * Complex.I : ℂ) • F := by + rw [cayleyDenominator_star, cayleyDenominator_val, Algebra.smul_def] + simp only [map_mul, map_neg, map_ofNat] + have hc := Algebra.commutes (R := ℂ) (A := A) Complex.I F + noncomm_ring [hc] + rw [hp, smul_smul] + have hs : (Complex.I / 2) * (-4 * Complex.I) = (2 : ℂ) := by + calc + _ = -2 * (Complex.I * Complex.I) := by ring + _ = 2 := by rw [Complex.I_mul_I]; norm_num + rw [hs] + +theorem boundedTransform_eq_of_involution (F : A) (hF : IsSelfAdjoint F) (hsq : F * F = 1) : + boundedTransform F hF = F := by + have hh := boundedTransform_mul_normSquare F hF + rw [cayleyDenominator_normSquare, hsq, mul_add, mul_one] at hh + have he : (2 : ℂ) • boundedTransform F hF = (2 : ℂ) • F := by + simpa only [two_smul] using hh + exact (smul_right_injective A (by norm_num : (2 : ℂ) ≠ 0)) he + +variable {H : HilbertSpace} + +theorem boundedTransform_sub_compact (F : End H) (hF : IsSelfAdjoint F) + (hK : IsCompactOperator (F * F - 1 : End H)) : + IsCompactOperator (boundedTransform F hF - F : End H) := by + let b := cayleyDenominator F hF + have hm : IsCompactOperator ((boundedTransform F hF - F) * ((b : End H) * star (b : End H))) := by + rw [sub_mul, boundedTransform_mul_normSquare, cayleyDenominator_normSquare] + have he : (2 : ℂ) • F - F * (F * F + 1) = -(F * (F * F - 1)) := by + rw [Algebra.smul_def] + simp only [map_ofNat] + noncomm_ring + rw [he] + exact (compact_mul_left hK F).neg + let v : (End H)ˣ := b * star b + change IsCompactOperator ((boundedTransform F hF - F) * (v : End H)) at hm + have hn := compact_mul_right hm (↑v⁻¹ : End H) + rwa [mul_assoc, Units.mul_inv, mul_one] at hn + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/BoundedTransformNaturality.lean b/lean/OAI/Topology/CoarseAssembly/BoundedTransformNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..3707b98d6c66b4b8c8cc931f5eb0f4a8799109fe --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/BoundedTransformNaturality.lean @@ -0,0 +1,39 @@ +import OAI.Topology.CoarseAssembly.BoundedTransform +import OAI.Topology.CoarseAssembly.CayleyNaturality +import OAI.Topology.CoarseAssembly.ScalarCutDown + +namespace OAI + +/-! # Naturality of the path-compatible rational normalization -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +theorem boundedTransform_congr {F G : A} (h : F = G) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + boundedTransform F hF = boundedTransform G hG := by + subst G + rfl + +theorem map_boundedTransform (φ : A →⋆ₐ[ℂ] B) (F : A) (hF : IsSelfAdjoint F) : + φ (boundedTransform F hF) = boundedTransform (φ F) (hF.map φ) := by + simp only [boundedTransform, map_smul, map_sub, map_star, map_cayleyUnitary] + +variable {H K : HilbertSpace} + +theorem map_symmetricCutDown (φ : End H →⋆ₐ[ℂ] End K) (P F : End H) : + φ (symmetricCutDown P F) = symmetricCutDown (φ P) (φ F) := by + unfold symmetricCutDown + have hs (T : End H) : φ ((1 / 2 : ℝ) • T) = (1 / 2 : ℝ) • φ T := + φ.toAlgHom.map_smul_of_tower _ _ + rw [map_add, hs] + simp only [map_add, map_mul, map_star, map_sub, map_one] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CayleyBoundary.lean b/lean/OAI/Topology/CoarseAssembly/CayleyBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..832bd1890f09cef58aa41ebc1c32713c61647e9d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CayleyBoundary.lean @@ -0,0 +1,99 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Analysis.CStarAlgebra.Spectrum +import Mathlib.Algebra.Group.Commute.Units +import Mathlib.RingTheory.TwoSidedIdeal.Basic +import Mathlib.Tactic.NoncommRing + +namespace OAI + +/-! # A rational representative of the odd analytic boundary + +For a self-adjoint `F`, the square of its Cayley transform, with a minus sign, +equals one modulo the square defect `F² - 1`. This construction will be applied +to the Roe ideal in the controlled pseudolocal algebra. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +theorem selfAdjoint_add_I_isUnit (F : A) (hF : IsSelfAdjoint F) : + IsUnit (F + algebraMap ℂ A Complex.I) := by + have hn : -Complex.I ∉ spectrum ℂ F := by + intro h + have hi := hF.im_eq_zero_of_mem_spectrum h + simp at hi + have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) := + not_not.mp (fun h => hn (spectrum.mem_iff.mpr h)) + convert hu.neg using 1 + simp only [map_neg, neg_sub, sub_neg_eq_add] + +@[simp] theorem cayleyDenominator_val (F : A) (hF : IsSelfAdjoint F) : + (cayleyDenominator F hF : A) = F + algebraMap ℂ A Complex.I := + (selfAdjoint_add_I_isUnit F hF).unit_spec + +theorem cayleyDenominator_star (F : A) (hF : IsSelfAdjoint F) : + star (cayleyDenominator F hF : A) = F - algebraMap ℂ A Complex.I := by + rw [cayleyDenominator_val, star_add, hF.star_eq] + simp only [← algebraMap_star_comm, Complex.star_def, Complex.conj_I, map_neg, + sub_eq_add_neg] + +theorem cayleyDenominator_normal (F : A) (hF : IsSelfAdjoint F) : + Commute (star (cayleyDenominator F hF : A)) (cayleyDenominator F hF : A) := by + rw [cayleyDenominator_star, cayleyDenominator_val] + have hc : Commute (algebraMap ℂ A Complex.I) F := Algebra.commutes _ _ + exact ((Commute.refl F).sub_left hc).add_right + (hc.symm.sub_left (Commute.refl _)) + +@[simp] theorem cayleyUnitary_val (F : A) (hF : IsSelfAdjoint F) : + (cayleyUnitary F hF : A) = + star (cayleyDenominator F hF : A) * (↑(cayleyDenominator F hF)⁻¹ : A) := rfl + +theorem rationalBoundaryUnitary_defect (F : A) (hF : IsSelfAdjoint F) : + ((rationalBoundaryUnitary F hF : A) - 1) * + (cayleyDenominator F hF : A) ^ 2 = -2 * (F ^ 2 - 1) := by + let b := cayleyDenominator F hF + have hc : Commute (star (b : A)) (b : A) := cayleyDenominator_normal F hF + have hci : Commute (star (b : A)) (↑b⁻¹ : A) := hc.units_inv_right + have he : (cayleyUnitary F hF : A) ^ 2 * (b : A) ^ 2 = star (b : A) ^ 2 := by + rw [cayleyUnitary_val, hci.mul_pow, mul_assoc, + ← (Commute.refl (b : A)).units_inv_left.mul_pow, Units.inv_mul, one_pow, mul_one] + simp only [rationalBoundaryUnitary, Unitary.coe_neg, Submonoid.coe_mul] + rw [← pow_two] + rw [sub_mul, neg_mul, he, one_mul] + rw [cayleyDenominator_star, cayleyDenominator_val] + have hI : (algebraMap ℂ A Complex.I) ^ 2 = -1 := by + rw [← map_pow, Complex.I_sq, map_neg, map_one] + have hcI := Algebra.commutes (R := ℂ) (A := A) Complex.I F + have hI' : algebraMap ℂ A Complex.I * algebraMap ℂ A Complex.I = -1 := by + simpa only [pow_two] using hI + noncomm_ring [hcI, hI'] + norm_num + +theorem rationalBoundaryUnitary_sub_one_mem (I : TwoSidedIdeal A) + (F : A) (hF : IsSelfAdjoint F) (hdefect : F ^ 2 - 1 ∈ I) : + (rationalBoundaryUnitary F hF : A) - 1 ∈ I := by + let b := cayleyDenominator F hF + have h : ((rationalBoundaryUnitary F hF : A) - 1) * (b : A) ^ 2 ∈ I := by + rw [rationalBoundaryUnitary_defect] + exact I.mul_mem_left _ _ hdefect + have h' := I.mul_mem_right _ ((↑b⁻¹ : A) ^ 2) h + have hc : Commute (b : A) (↑b⁻¹ : A) := (Commute.refl (b : A)).units_inv_right + simpa only [mul_assoc, ← hc.mul_pow, Units.mul_inv, one_pow, mul_one] using h' + +theorem rationalBoundaryUnitary_eq_one (F : A) (hF : IsSelfAdjoint F) + (hsq : F ^ 2 = 1) : rationalBoundaryUnitary F hF = 1 := by + apply Subtype.ext + apply sub_eq_zero.mp + have h := rationalBoundaryUnitary_defect F hF + rw [hsq, sub_self, mul_zero] at h + apply (Units.mul_left_inj (cayleyDenominator F hF ^ 2)).mp + simpa only [Units.val_pow_eq_pow_val, zero_mul, Submonoid.coe_one] using h + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CayleyContinuity.lean b/lean/OAI/Topology/CoarseAssembly/CayleyContinuity.lean new file mode 100644 index 0000000000000000000000000000000000000000..d5910039e4e59337389c9877b18e7510f6d39cc8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CayleyContinuity.lean @@ -0,0 +1,36 @@ +import OAI.Topology.CoarseAssembly.CayleyBoundary + +namespace OAI + +/-! # Norm continuity of the rational boundary representative -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A P : Type*} [CStarAlgebra A] [TopologicalSpace P] + +theorem continuous_cayleyDenominator (F : P → A) (hF : ∀ p, IsSelfAdjoint (F p)) + (hcont : Continuous F) : Continuous (fun p => cayleyDenominator (F p) (hF p)) := by + apply (Units.isOpenEmbedding_val (R := A)).isEmbedding.continuous_iff.mpr + simp only [Function.comp_def, cayleyDenominator_val] + convert! hcont.add (continuous_const : Continuous (fun _ : P => algebraMap ℂ A Complex.I)) + +theorem continuous_cayleyUnitary (F : P → A) (hF : ∀ p, IsSelfAdjoint (F p)) + (hcont : Continuous F) : Continuous (fun p => (cayleyUnitary (F p) (hF p) : A)) := by + have hb := continuous_cayleyDenominator F hF hcont + simp only [cayleyUnitary_val] + exact (Units.continuous_val.comp hb).star.mul (Units.continuous_coe_inv.comp hb) + +theorem continuous_rationalBoundaryUnitary (F : P → A) (hF : ∀ p, IsSelfAdjoint (F p)) + (hcont : Continuous F) : + Continuous (fun p => (rationalBoundaryUnitary (F p) (hF p) : A)) := by + have hc := continuous_cayleyUnitary F hF hcont + simp only [rationalBoundaryUnitary, Unitary.coe_neg, Submonoid.coe_mul] + convert! (hc.mul hc).neg + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CayleyIntertwining.lean b/lean/OAI/Topology/CoarseAssembly/CayleyIntertwining.lean new file mode 100644 index 0000000000000000000000000000000000000000..e21cae5f3b0ec59a2e1ae4a38949e289f44ed41f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CayleyIntertwining.lean @@ -0,0 +1,73 @@ +import OAI.Topology.CoarseAssembly.CayleyNaturality +import OAI.Topology.CoarseAssembly.FredholmModule + +namespace OAI + +/-! # The rational boundary respects bounded intertwiners + +This includes restriction to a component of a Hilbert direct sum. No +multiplicativity of compression on arbitrary operators is assumed. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H K : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K] + +theorem cayleyDenominator_intertwines (R : H →L[ℂ] K) (F : H →L[ℂ] H) (G : K →L[ℂ] K) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (h : ∀ x, R (F x) = G (R x)) (x : H) : + R ((cayleyDenominator F hF : H →L[ℂ] H) x) = + (cayleyDenominator G hG : K →L[ℂ] K) (R x) := by + simp only [cayleyDenominator_val, Algebra.algebraMap_eq_smul_one, + add_apply, smul_apply, + one_apply_eq_self, map_add, map_smul, h] + +theorem cayleyDenominator_inv_intertwines (R : H →L[ℂ] K) (F : H →L[ℂ] H) (G : K →L[ℂ] K) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (h : ∀ x, R (F x) = G (R x)) (x : H) : + R ((↑(cayleyDenominator F hF)⁻¹ : H →L[ℂ] H) x) = + (↑(cayleyDenominator G hG)⁻¹ : K →L[ℂ] K) (R x) := by + let b := cayleyDenominator F hF + let d := cayleyDenominator G hG + have hleft (y : K) : (↑d⁻¹ : K →L[ℂ] K) ((d : K →L[ℂ] K) y) = y := by + change ((↑d⁻¹ : K →L[ℂ] K) * (d : K →L[ℂ] K)) y = y + rw [Units.inv_mul, one_apply_eq_self] + have hright (y : H) : (b : H →L[ℂ] H) ((↑b⁻¹ : H →L[ℂ] H) y) = y := by + change ((b : H →L[ℂ] H) * (↑b⁻¹ : H →L[ℂ] H)) y = y + rw [Units.mul_inv, one_apply_eq_self] + calc + R ((↑b⁻¹ : H →L[ℂ] H) x) = (↑d⁻¹ : K →L[ℂ] K) ((d : K →L[ℂ] K) (R ((↑b⁻¹ : H →L[ℂ] H) x))) := + (hleft _).symm + _ = (↑d⁻¹ : K →L[ℂ] K) (R ((b : H →L[ℂ] H) ((↑b⁻¹ : H →L[ℂ] H) x))) := by + rw [cayleyDenominator_intertwines R F G hF hG h] + _ = (↑d⁻¹ : K →L[ℂ] K) (R x) := by rw [hright] + +theorem cayleyUnitary_intertwines (R : H →L[ℂ] K) (F : H →L[ℂ] H) (G : K →L[ℂ] K) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (h : ∀ x, R (F x) = G (R x)) (x : H) : + R ((cayleyUnitary F hF : H →L[ℂ] H) x) = (cayleyUnitary G hG : K →L[ℂ] K) (R x) := by + simp only [cayleyUnitary_val, cayleyDenominator_star, + Algebra.algebraMap_eq_smul_one, mul_apply_eq_comp, + sub_apply, smul_apply, + one_apply_eq_self, map_sub, map_smul, h] + rw [cayleyDenominator_inv_intertwines R F G hF hG h] + +theorem rationalBoundaryUnitary_intertwines (R : H →L[ℂ] K) + (F : H →L[ℂ] H) (G : K →L[ℂ] K) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (h : ∀ x, R (F x) = G (R x)) (x : H) : + R ((rationalBoundaryUnitary F hF : H →L[ℂ] H) x) = + (rationalBoundaryUnitary G hG : K →L[ℂ] K) (R x) := by + simp only [rationalBoundaryUnitary, Unitary.coe_neg, Submonoid.coe_mul, + neg_apply, mul_apply_eq_comp, map_neg] + rw [cayleyUnitary_intertwines R F G hF hG h, + cayleyUnitary_intertwines R F G hF hG h] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CayleyNaturality.lean b/lean/OAI/Topology/CoarseAssembly/CayleyNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..143f520b80c36f288389e5e2c7322be3f20c5252 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CayleyNaturality.lean @@ -0,0 +1,42 @@ +import OAI.Topology.CoarseAssembly.CayleyBoundary + +namespace OAI + +/-! # Naturality of the rational boundary formula -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +theorem map_cayleyDenominator (φ : A →⋆ₐ[ℂ] B) (F : A) (hF : IsSelfAdjoint F) : + Units.map φ.toMonoidHom (cayleyDenominator F hF) = + cayleyDenominator (φ F) (hF.map φ) := by + apply Units.ext + change φ (cayleyDenominator F hF : A) = + (cayleyDenominator (φ F) (hF.map φ) : B) + simp only [cayleyDenominator_val, map_add] + congr 1 + exact φ.commutes Complex.I + +theorem map_cayleyUnitary (φ : A →⋆ₐ[ℂ] B) (F : A) (hF : IsSelfAdjoint F) : + φ (cayleyUnitary F hF : A) = (cayleyUnitary (φ F) (hF.map φ) : B) := by + have hi := congrArg (fun u : Bˣ => (↑(u⁻¹) : B)) (map_cayleyDenominator φ F hF) + change φ (↑(cayleyDenominator F hF)⁻¹ : A) = + (↑(cayleyDenominator (φ F) (hF.map φ))⁻¹ : B) at hi + simp only [cayleyUnitary_val, map_mul, map_star, hi] + congr 2 + exact congrArg (fun u : Bˣ => (u : B)) (map_cayleyDenominator φ F hF) + +theorem map_rationalBoundaryUnitary (φ : A →⋆ₐ[ℂ] B) (F : A) (hF : IsSelfAdjoint F) : + φ (rationalBoundaryUnitary F hF : A) = + (rationalBoundaryUnitary (φ F) (hF.map φ) : B) := by + simp only [rationalBoundaryUnitary, Unitary.coe_neg, Submonoid.coe_mul, map_neg, map_mul, + map_cayleyUnitary] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CayleyNonunitalNaturality.lean b/lean/OAI/Topology/CoarseAssembly/CayleyNonunitalNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..e11ab2f2462acaa0e906053d98a7bc57f4374620 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CayleyNonunitalNaturality.lean @@ -0,0 +1,43 @@ +import OAI.Topology.CoarseAssembly.CayleyUnitization + +namespace OAI + +/-! # Naturality for identity-extended nonunital homomorphisms -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +def nonunitalIdentityExtension (φ : A →⋆ₙₐ[ℂ] B) (F : A) : B := 1 + φ (F - 1) + +theorem nonunitalIdentityExtension_selfAdjoint (φ : A →⋆ₙₐ[ℂ] B) + (F : A) (hF : IsSelfAdjoint F) : IsSelfAdjoint (nonunitalIdentityExtension φ F) := + (IsSelfAdjoint.one B).add ((hF.sub (IsSelfAdjoint.one A)).map φ) + +theorem starLift_inr (φ : A →⋆ₙₐ[ℂ] B) (a : A) : + Unitization.starLift φ (a : Unitization ℂ A) = φ a := by + change algebraMap ℂ B 0 + φ a = φ a + rw [map_zero, zero_add] + +theorem starLift_identityUnitization (φ : A →⋆ₙₐ[ℂ] B) (F : A) : + Unitization.starLift φ (identityUnitization F) = nonunitalIdentityExtension φ F := by + change Unitization.starLift φ (1 + ((F - 1 : A) : Unitization ℂ A)) = 1 + φ (F - 1) + rw [map_add, map_one, starLift_inr] + +theorem nonunital_rationalBoundaryUnitary (φ : A →⋆ₙₐ[ℂ] B) + (F : A) (hF : IsSelfAdjoint F) : + 1 + φ ((rationalBoundaryUnitary F hF : A) - 1) = + (rationalBoundaryUnitary (nonunitalIdentityExtension φ F) + (nonunitalIdentityExtension_selfAdjoint φ F hF) : B) := by + have h := map_rationalBoundaryUnitary (Unitization.starLift φ) + (identityUnitization F) (identityUnitization_selfAdjoint F hF) + rw [rationalBoundaryUnitary_identity F hF] at h + simpa only [map_add, map_one, starLift_inr, starLift_identityUnitization] using h + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CayleyNormControl.lean b/lean/OAI/Topology/CoarseAssembly/CayleyNormControl.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e7e87de4045e6dd20ba120cd43fa57fe36ad88a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CayleyNormControl.lean @@ -0,0 +1,87 @@ +import OAI.Topology.CoarseAssembly.CayleyBoundary + +namespace OAI + +/-! # A uniform Lipschitz estimate for the rational boundary unitary -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +theorem cayleyDenominator_inverse_identity (F : A) (hF : IsSelfAdjoint F) : + (2 * Complex.I : ℂ) • (↑(cayleyDenominator F hF)⁻¹ : A) = + 1 - (cayleyUnitary F hF : A) := by + have hscalar : algebraMap ℂ A (2 * Complex.I) = + (cayleyDenominator F hF : A) - star (cayleyDenominator F hF : A) := by + rw [cayleyDenominator_star, cayleyDenominator_val, map_mul] + simp only [map_ofNat] + noncomm_ring + rw [Algebra.smul_def, hscalar, sub_mul, Units.mul_inv, cayleyUnitary_val] + +theorem cayleyDenominator_inverse_norm_le (F : A) (hF : IsSelfAdjoint F) : + ‖(↑(cayleyDenominator F hF)⁻¹ : A)‖ ≤ 1 := by + nontriviality A + have h := norm_sub_le (1 : A) (cayleyUnitary F hF : A) + rw [← cayleyDenominator_inverse_identity F hF, norm_smul, norm_mul, + Complex.norm_I, norm_one, CStarRing.norm_coe_unitary] at h + norm_num at h + linarith + +theorem cayleyDenominator_inverse_sub_norm_le (F G : A) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + ‖(↑(cayleyDenominator F hF)⁻¹ : A) - ↑(cayleyDenominator G hG)⁻¹‖ ≤ ‖F - G‖ := by + let u := cayleyDenominator F hF + let v := cayleyDenominator G hG + have he : (↑u⁻¹ : A) - ↑v⁻¹ = ↑u⁻¹ * (G - F) * ↑v⁻¹ := by + have hdiff : G - F = (v : A) - u := by + simp only [u, v, cayleyDenominator_val, add_sub_add_right_eq_sub] + rw [hdiff, mul_sub, sub_mul] + rw [mul_assoc, Units.mul_inv, mul_one, Units.inv_mul, one_mul] + rw [he] + calc + _ ≤ ‖(↑u⁻¹ : A)‖ * ‖G - F‖ * ‖(↑v⁻¹ : A)‖ := + (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _)) + _ ≤ 1 * ‖G - F‖ * 1 := by + gcongr + · exact cayleyDenominator_inverse_norm_le F hF + · exact cayleyDenominator_inverse_norm_le G hG + _ = ‖F - G‖ := by rw [one_mul, mul_one, norm_sub_rev] + +theorem cayleyUnitary_sub_norm_le (F G : A) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + ‖(cayleyUnitary F hF : A) - cayleyUnitary G hG‖ ≤ 2 * ‖F - G‖ := by + have he : (cayleyUnitary F hF : A) - cayleyUnitary G hG = + -(2 * Complex.I : ℂ) • + ((↑(cayleyDenominator F hF)⁻¹ : A) - ↑(cayleyDenominator G hG)⁻¹) := by + rw [neg_smul, smul_sub, cayleyDenominator_inverse_identity, + cayleyDenominator_inverse_identity] + abel + rw [he, norm_smul, norm_neg, norm_mul, Complex.norm_I] + norm_num only [Complex.norm_ofNat, mul_one] + exact mul_le_mul_of_nonneg_left (cayleyDenominator_inverse_sub_norm_le F G hF hG) (by norm_num) + +theorem rationalBoundaryUnitary_sub_norm_le (F G : A) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + ‖(rationalBoundaryUnitary F hF : A) - rationalBoundaryUnitary G hG‖ ≤ 4 * ‖F - G‖ := by + nontriviality A + let u : A := cayleyUnitary F hF + let v : A := cayleyUnitary G hG + have hu : ‖u‖ = 1 := CStarRing.norm_coe_unitary _ + have hv : ‖v‖ = 1 := CStarRing.norm_coe_unitary _ + have he : -(u * u) - -(v * v) = (v - u) * v + u * (v - u) := by + rw [neg_sub_neg, sub_mul, mul_sub, sub_add_sub_cancel] + change ‖-(u * u) - -(v * v)‖ ≤ _ + rw [he] + calc + _ ≤ ‖(v - u) * v‖ + ‖u * (v - u)‖ := norm_add_le _ _ + _ ≤ ‖v - u‖ * ‖v‖ + ‖u‖ * ‖v - u‖ := add_le_add (norm_mul_le _ _) (norm_mul_le _ _) + _ = 2 * ‖u - v‖ := by rw [hu, hv, norm_sub_rev]; ring + _ ≤ 2 * (2 * ‖F - G‖) := mul_le_mul_of_nonneg_left (cayleyUnitary_sub_norm_le F G hF hG) (by norm_num) + _ = _ := by ring + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CayleyUnitization.lean b/lean/OAI/Topology/CoarseAssembly/CayleyUnitization.lean new file mode 100644 index 0000000000000000000000000000000000000000..ac88fa6b97d62ca20a4a59288f0d80c9d824dc4a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CayleyUnitization.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.CayleyNaturality +import Mathlib.Analysis.CStarAlgebra.Unitization + +namespace OAI + +/-! # The rational boundary under a nonunital spatial homomorphism + +The lift `1 + (F - 1)` in a unitization makes the complementary summand +explicit. This is the algebraic input to naturality under isometric spatial +inclusions, which extend an operator by the identity off its image. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +def identityUnitization (F : A) : Unitization ℂ A := 1 + ((F - 1 : A) : Unitization ℂ A) + +theorem identityUnitization_selfAdjoint (F : A) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (identityUnitization F) := + (IsSelfAdjoint.one (Unitization ℂ A)).add + ((hF.sub (IsSelfAdjoint.one A)).map (Unitization.inrNonUnitalStarAlgHom ℂ A)) + +def unitizationScalar : Unitization ℂ A →⋆ₐ[ℂ] ℂ where + toAlgHom := Unitization.fstHom ℂ A + map_star' := Unitization.fst_star + +def unitizationEval : Unitization ℂ A →⋆ₐ[ℂ] A := + Unitization.starLift (NonUnitalStarAlgHom.id ℂ A) + +@[simp] theorem unitizationEval_apply (a : Unitization ℂ A) : + unitizationEval a = algebraMap ℂ A a.fst + a.snd := rfl + +@[simp] theorem unitizationScalar_identity (F : A) : + unitizationScalar (identityUnitization F) = 1 := by + change (identityUnitization F).fst = 1 + simp only [identityUnitization, Unitization.fst_add, Unitization.fst_one, + Unitization.fst_inr, add_zero] + +@[simp] theorem unitizationEval_identity (F : A) : + unitizationEval (identityUnitization F) = F := by + simp only [unitizationEval_apply, identityUnitization, Unitization.fst_add, + Unitization.fst_one, Unitization.fst_inr, Unitization.snd_add, Unitization.snd_one, + Unitization.snd_inr, add_zero, zero_add, map_one] + abel + +theorem rationalBoundaryUnitary_identity_scalar (F : A) (hF : IsSelfAdjoint F) : + (rationalBoundaryUnitary (identityUnitization F) + (identityUnitization_selfAdjoint F hF) : Unitization ℂ A).fst = 1 := by + have h := map_rationalBoundaryUnitary (unitizationScalar (A := A)) + (identityUnitization F) (identityUnitization_selfAdjoint F hF) + have hsq : unitizationScalar (identityUnitization F) ^ 2 = (1 : ℂ) := by + rw [unitizationScalar_identity] + simp + have hu := rationalBoundaryUnitary_eq_one _ + ((identityUnitization_selfAdjoint F hF).map (unitizationScalar (A := A))) hsq + exact h.trans (congrArg (fun u : unitary ℂ => (u : ℂ)) hu) + +theorem rationalBoundaryUnitary_identity_eval (F : A) (hF : IsSelfAdjoint F) : + unitizationEval (rationalBoundaryUnitary (identityUnitization F) + (identityUnitization_selfAdjoint F hF) : Unitization ℂ A) = + (rationalBoundaryUnitary F hF : A) := by + have h := map_rationalBoundaryUnitary (unitizationEval (A := A)) + (identityUnitization F) (identityUnitization_selfAdjoint F hF) + simpa only [unitizationEval_identity] using h + +theorem rationalBoundaryUnitary_identity (F : A) (hF : IsSelfAdjoint F) : + (rationalBoundaryUnitary (identityUnitization F) + (identityUnitization_selfAdjoint F hF) : Unitization ℂ A) = + 1 + (((rationalBoundaryUnitary F hF : A) - 1 : A) : Unitization ℂ A) := by + have hs := rationalBoundaryUnitary_identity_scalar F hF + have he := rationalBoundaryUnitary_identity_eval F hF + rw [unitizationEval_apply, hs, map_one] at he + apply Unitization.ext + · simpa only [Unitization.fst_add, Unitization.fst_one, Unitization.fst_inr, + add_zero] using hs + · simpa only [Unitization.snd_add, Unitization.snd_one, Unitization.snd_inr, + zero_add] using eq_sub_of_add_eq' he + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CharacterExtension.lean b/lean/OAI/Topology/CoarseAssembly/CharacterExtension.lean new file mode 100644 index 0000000000000000000000000000000000000000..88dc4361d8e5c37cc003ab7863980852d2f6a45b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CharacterExtension.lean @@ -0,0 +1,79 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ExplicitCutDown +import Mathlib.Algebra.Star.StarProjection + +namespace OAI + +/-! # Completing a represented subspace using a character + +For a unital coefficient algebra with a character, the complement of the +represented subspace can carry that character. The cut-down operator acts +as the identity there, so this completion preserves the Fredholm defects. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] {H : HilbertSpace} + +def characterProjectionRepresentation (χ : A →⋆ₐ[ℂ] ℂ) (P : End H) + (hP : IsStarProjection P) : A →⋆ₙₐ[ℂ] End H where + toFun a := χ a • P + map_zero' := by simp + map_add' a b := by simp [add_smul] + map_mul' a b := by + have hPP : P * P = P := hP.isIdempotentElem + rw [map_mul, smul_mul_assoc, mul_smul_comm, hPP, smul_smul, mul_comm] + map_smul' z a := by simp [smul_smul] + map_star' a := by rw [map_star, star_smul, hP.isSelfAdjoint.star_eq] + +theorem representation_unit_projection (c : OddCycle A) : + IsStarProjection (c.representation 1) := + ⟨representation_unit_sq c, representation_unit_selfAdjoint c⟩ + +theorem representation_complement_right (c : OddCycle A) (a : A) : + c.representation a * (1 - c.representation 1) = 0 := by + rw [mul_sub, mul_one, ← map_mul, mul_one, sub_self] + +theorem representation_complement_left (c : OddCycle A) (a : A) : + (1 - c.representation 1) * c.representation a = 0 := by + rw [sub_mul, one_mul, ← map_mul, one_mul, sub_self] + +@[simp] theorem completedRepresentation_apply (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) (a : A) : + completedRepresentation c χ a = c.representation a + χ a • (1 - c.representation 1) := rfl + +theorem completedRepresentation_one (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + completedRepresentation c χ 1 = 1 := by + simp only [completedRepresentation_apply, map_one, one_smul] + abel + +/-- Any representation with the identity operator is degenerate. -/ +def identityOperatorCycle (ρ : A →⋆ₙₐ[ℂ] End H) : OddCycle A where + space := H + representation := ρ + operator := 1 + commutator_compact _ := by simp; exact isCompactOperator_zero + square_compact _ := by simp; exact isCompactOperator_zero + adjoint_compact _ := by simp; exact isCompactOperator_zero + +theorem identityOperatorCycle_degenerate (ρ : A →⋆ₙₐ[ℂ] End H) : + (identityOperatorCycle ρ).Degenerate := by + constructor + · intro a; change (1 : End H) * ρ a - ρ a * 1 = 0; simp + constructor + · intro a; change ((1 : End H) * 1 - 1) * ρ a = 0; simp + · intro a; change (star (1 : End H) - 1) * ρ a = 0; simp + +theorem characterExtension_unital (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) + (hF : IsSelfAdjoint c.operator) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) + (hsq : IsCompactOperator (c.operator * c.operator - 1 : End c.space)) : + (c.characterExtension χ hF hQ hsq).representation 1 = 1 := + completedRepresentation_one c χ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ChosenHolonomy.lean b/lean/OAI/Topology/CoarseAssembly/ChosenHolonomy.lean new file mode 100644 index 0000000000000000000000000000000000000000..fefdf17e8e9da66d77cf5d11c0c0db81e6ecc5ea --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ChosenHolonomy.lean @@ -0,0 +1,38 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.FiniteWords +import OAI.Topology.CoarseAssembly.TranscendentalUnit + +namespace OAI + +/-! +# A single principal holonomy for all finite scales + +The choice in §3 is made once. The separation level can then depend on the +length bound, without changing the chosen 2-adic unit. +-/ + +namespace CoarseAssembly.Congruence + +theorem chosenHolonomyUnit_transcendental : + Transcendental ℤ (chosenHolonomyUnit : ℤ_[2]) := + (exists_transcendental_principal_unit (p := 2)).choose_spec.1 + +theorem chosenHolonomyUnit_principal : + ∃ a : ℤ_[2], (chosenHolonomyUnit : ℤ_[2]) = 1 + (2 : ℤ_[2]) * a := + (exists_transcendental_principal_unit (p := 2)).choose_spec.2 + +/-- The fixed principal holonomy excludes short charged closed lifts at every +finite length bound. This is an arithmetic statement, not a coarse assembly +or K-homology theorem. -/ +theorem chosenHolonomy_short_lifts (S : Finset ArithmeticGroup) (A : ℕ) : + ∃ N : ℕ, 1 ≤ N ∧ ∀ k, N ≤ k → ∀ z : Quotient k, + ∀ steps : List (ArithmeticGroup × ℤ), steps.length ≤ A → + (∀ s ∈ steps, s.1 ∈ S ∧ s.2.natAbs ≤ 1) → + holonomyEndpoint (holonomy chosenHolonomyUnit k) (reduceSteps k steps) z = z → + holonomyCharge steps = 0 := + bounded_closed_lifts_have_zero_charge chosenHolonomyUnit + chosenHolonomyUnit_transcendental S A + +end CoarseAssembly.Congruence + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CircleCoefficient.lean b/lean/OAI/Topology/CoarseAssembly/CircleCoefficient.lean new file mode 100644 index 0000000000000000000000000000000000000000..395bf363bb5f7e548e3902d1e721a8774b61f596 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CircleCoefficient.lean @@ -0,0 +1,92 @@ +import OAI.Topology.CoarseAssembly.NegativeCircleCycle +import OAI.Topology.CoarseAssembly.CircleInputReduction + +namespace OAI + +/-! # An unconditional circle class of coordinate index one -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty + +variable {X : Type} [TopologicalSpace X] [CompactSpace X] + +def compactFunctionForget : C₀(X, ℂ) →⋆ₙₐ[ℂ] C(X, ℂ) where + toFun f := f.toContinuousMap + map_zero' := rfl + map_add' _ _ := rfl + map_mul' _ _ := rfl + map_smul' _ _ := rfl + map_star' _ := rfl + +theorem compactFunctionForget_lift : + (compactFunctionForget (X := X)).comp compactFunctionLift = NonUnitalStarAlgHom.id ℂ C(X, ℂ) := by + ext f x + rfl + +def negativeCircleClass : LocallyFiniteK1 Circle := + cycleClass C₀(Circle, ℂ) (negativeCircleCycle.precomp compactFunctionForget) + +theorem negativeCircleClass_coordinate_index : + compactIndexPairing (ContinuousMap.id Circle) negativeCircleClass = 1 := by + rw [negativeCircleClass, compactIndexPairing_cycleClass, OddCycle.precomp_comp, + compactFunctionForget_lift, OddCycle.precomp_id] + exact negativeCircleCycle_coordinate_index + +end CoarseAssembly.Analytic + +namespace CoarseAssembly + +open Analytic + +def circleFundamental : LocallyFiniteK1 WindingCircle := + pushforward (compactMap ((AddCircle.homeomorphCircle (T := (1 : ℝ)) one_ne_zero).symm : C(Circle, WindingCircle))) + negativeCircleClass + +theorem circleFundamental_coordinate_index : + compactIndexPairing (circleUnitary (ContinuousMap.id WindingCircle)) circleFundamental = 1 := by + let e := AddCircle.homeomorphCircle (T := (1 : ℝ)) one_ne_zero + have he : (circleUnitary (ContinuousMap.id WindingCircle)).comp (e.symm : C(Circle, WindingCircle)) = + ContinuousMap.id Circle := by + apply ContinuousMap.ext + intro z + change AddCircle.toCircle (e.symm z) = z + rw [← AddCircle.homeomorphCircle_apply one_ne_zero] + exact e.apply_symm_apply z + change compactIndexPairing (circleUnitary (ContinuousMap.id WindingCircle)) + (pushforward (compactMap (e.symm : C(Circle, WindingCircle))) negativeCircleClass) = 1 + have h := DFunLike.congr_fun + (compactIndexPairing_natural (circleUnitary (ContinuousMap.id WindingCircle)) (e.symm : C(Circle, WindingCircle))) + negativeCircleClass + rw [he] at h + exact h.trans negativeCircleClass_coordinate_index + +/-- The complete published circle-index input, now a theorem. -/ +def provedCircleInput : PublishedCircleInput := + circleInputOfIndexOne circleFundamental circleFundamental_coordinate_index + +open Congruence Rips + +local instance coefficientReductionMetric : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +/-- Main theorem with the circle and compact-filling inputs discharged. -/ +theorem bounded_geometry_counterexample_from_additivity_index_gap + (hadd : CountableAdditivityInput CircleFamily) (hfill : CountableAdditivityInput FilledDisc) + (index : PublishedBoundaryAssemblyInput) (hgap : PublishedKazhdanInput) : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ index.total.assembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective index.total.assembly ∧ + ¬ Function.Injective (index.total.assembly.toIntLinearMap.lTensor ℚ) := + bounded_geometry_counterexample_from_circle_index_gap provedCircleInput hadd hfill index hgap + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CircleInputReduction.lean b/lean/OAI/Topology/CoarseAssembly/CircleInputReduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..dc7755a418f0ce99300945963bd4838e7ba30fae --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CircleInputReduction.lean @@ -0,0 +1,38 @@ +import OAI.Topology.CoarseAssembly.WindingIndexEvaluation +import OAI.Topology.CoarseAssembly.PublishedInputReduction + +namespace OAI + +/-! # Reducing the circle input to one explicit index computation -/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance circleReductionMetric : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +/-- The circle pairing and winding laws are now proved. Only a circle +class whose coordinate index is one is required from circle index theory. -/ +theorem bounded_geometry_counterexample_of_circle_index_one + (αcircle : LocallyFiniteK1 WindingCircle) + (hcircle : compactIndexPairing (circleUnitary (ContinuousMap.id WindingCircle)) αcircle = 1) + (hadd : CountableAdditivityInput CircleFamily) (hfill : CountableAdditivityInput FilledDisc) + (index : PublishedBoundaryAssemblyInput) (hgap : PublishedKazhdanInput) : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ index.total.assembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective index.total.assembly ∧ + ¬ Function.Injective (index.total.assembly.toIntLinearMap.lTensor ℚ) := + bounded_geometry_counterexample_from_circle_index_gap + (circleInputOfIndexOne αcircle hcircle) hadd hfill index hgap + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CirclePairing.lean b/lean/OAI/Topology/CoarseAssembly/CirclePairing.lean new file mode 100644 index 0000000000000000000000000000000000000000..0680e49bcea109e375640ca89882d150b3ac0618 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CirclePairing.lean @@ -0,0 +1,80 @@ +import OAI.Topology.CoarseAssembly.LoopCircle +import OAI.Topology.CoarseAssembly.LocallyFinite +import OAI.Topology.CoarseAssembly.FiniteRips +import Mathlib.Analysis.SpecialFunctions.Complex.Circle + +namespace OAI + +/-! # The precise published circle-index input + +Only the scalar-unitary index pairing, its naturality for a parametrized +loop, and the classical winding formula are assumed. The domain groups +are the Fredholm-module groups. + +References: Blackadar, *K-Theory for Operator Algebras*, 2nd ed. (1998), +Proposition 18.7.1 and Corollary 18.10.3; Khalkhali, *Basic Noncommutative +Geometry* (2009), Example 4.2.4, with the sign convention of manuscript §2.3. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic unitInterval + +variable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y] + +/-- Continuous maps from a compact source are cocompact. -/ +def compactMap [CompactSpace X] (f : C(X, Y)) : CocompactMap X Y where + toContinuousMap := f + cocompact_tendsto' := by simp only [Filter.cocompact_eq_bot]; exact Filter.tendsto_bot + +@[simp] theorem compactMap_apply [CompactSpace X] (f : C(X, Y)) (x : X) : + compactMap f x = f x := rfl + +/-- The scalar unitary represented by a circle-valued map. -/ +def circleUnitary (f : C(X, WindingCircle)) : C(X, Circle) := + ⟨fun x => AddCircle.toCircle (f x), AddCircle.continuous_toCircle.comp f.continuous⟩ + +/-- Minimal published analytic data needed to test loops. Each `pairing f` +is the index pairing with the scalar unitary `circleUnitary f`. -/ +structure PublishedCircleInput where + fundamental : LocallyFiniteK1 WindingCircle + pairing : ∀ {Y : Type} [TopologicalSpace Y] [CompactSpace Y] [T2Space Y], + C(Y, WindingCircle) → (LocallyFiniteK1 Y →+ ℤ) + loop_naturality : ∀ {Y : Type} [TopologicalSpace Y] [CompactSpace Y] [T2Space Y] + (f : C(Y, WindingCircle)) (γ : C(WindingCircle, Y)), + pairing f (pushforward (compactMap γ) fundamental) = pairing (f.comp γ) fundamental + winding : ∀ (g : C(WindingCircle, WindingCircle)) (n : ℤ) + (L : Path (0 : ℝ) (n : ℝ)), + (∀ t : unitInterval, g (t : ℝ) = (L t : WindingCircle)) → + pairing g fundamental = n + +/-- The constructed real lift is sufficient for the published index formula. -/ +theorem PublishedCircleInput.loop_pairing (input : PublishedCircleInput) + [CompactSpace Y] [T2Space Y] {y : Y} + (f : C(Y, WindingCircle)) (γ : Path y y) (n : ℤ) + (L : IntegerPathLift f γ n) : + input.pairing f (pushforward (compactMap (loopCircle γ)) input.fundamental) = n := by + rw [input.loop_naturality] + apply input.winding _ n L.path + intro t + exact loopCircle_integerLift γ L t + +/-- In particular the normalized circle class has infinite order; this +deduction is not part of the assumed published data. -/ +theorem PublishedCircleInput.fundamental_infinite_order (input : PublishedCircleInput) + (n : ℤ) (hn : n ≠ 0) : n • input.fundamental ≠ 0 := by + intro h + have hwind : input.pairing (ContinuousMap.id WindingCircle) input.fundamental = 1 := by + apply input.winding _ 1 ((Path.segment (0 : ℝ) 1).cast rfl (by simp)) + intro t + simp [Path.cast, Path.segment_apply, AffineMap.lineMap_apply] + have h' := congrArg (input.pairing (ContinuousMap.id WindingCircle)) h + exact hn (by simpa [map_zsmul, hwind] using h') + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CircleSequenceRepresentation.lean b/lean/OAI/Topology/CoarseAssembly/CircleSequenceRepresentation.lean new file mode 100644 index 0000000000000000000000000000000000000000..d2476baf79b487dbd1ee3163f1a03b1f6a50a446 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CircleSequenceRepresentation.lean @@ -0,0 +1,37 @@ +import OAI.Topology.CoarseAssembly.NegativeProjection +import Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unitary +import Mathlib.Analysis.Complex.Circle + +namespace OAI + +/-! # Continuous circle functions represented by the bilateral shift -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped CStarAlgebra + +def circleCoordinate : C(Circle, ℂ) := ⟨fun z => (z : ℂ), continuous_subtype_val⟩ + +theorem bilateralShift_mem_unitary : bilateralShift ∈ unitary (End circleSequenceSpace) := + Unitary.mem_iff.mpr bilateralShift_unitary + +theorem bilateralShift_spectrum_circle : spectrum ℂ bilateralShift ⊆ + (Submonoid.unitSphere ℂ : Set ℂ) := by + intro z hz + exact mem_sphere_zero_iff_norm.mpr (CStarRing.norm_of_mem_unitary + (spectrum_subset_unitary_of_mem_unitary bilateralShift_mem_unitary hz)) + +/-- Continuous functional calculus of the actual bilateral shift. -/ +def circleRepresentation : C(Circle, ℂ) →⋆ₐ[ℂ] End circleSequenceSpace := + cfcHomSuperset (isStarNormal_of_mem_unitary bilateralShift_mem_unitary) bilateralShift_spectrum_circle + +@[simp] theorem circleRepresentation_coordinate : circleRepresentation circleCoordinate = bilateralShift := + cfcHomSuperset_id _ _ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ClopenNaturality.lean b/lean/OAI/Topology/CoarseAssembly/ClopenNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..9946be5d82a0524833c5b712ddfc283647e99f2a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ClopenNaturality.lean @@ -0,0 +1,55 @@ +import OAI.Topology.CoarseAssembly.ClopenRestriction + +namespace OAI + +/-! # Restriction across a proper map + +If the preimage of a compact open component is exactly the specified +compact open component of the source, the corresponding KK restrictions +commute with pushforward. The identity is proved on functions first. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Topology +open scoped ZeroAtInfty + +variable {A B X Y : Type} [TopologicalSpace A] [TopologicalSpace B] + [TopologicalSpace X] [TopologicalSpace Y] + [CompactSpace A] [CompactSpace B] [T2Space X] [T2Space Y] + +theorem pullback_zeroExtension (e : A ↪ X) (he : IsOpenEmbedding e) + (d : B ↪ Y) (hd : IsOpenEmbedding d) (f : CocompactMap X Y) (g : CocompactMap A B) + (commutes : ∀ a, f (e a) = d (g a)) + (preimage : ∀ x, f x ∈ Set.range d ↔ x ∈ Set.range e) : + (pullback f).comp (zeroExtensionHom d hd) = + (zeroExtensionHom e he).comp (pullback g) := by + ext h x + change zeroExtension d hd h (f x) = zeroExtension e he (pullback g h) x + by_cases hx : x ∈ Set.range e + · obtain ⟨a, rfl⟩ := hx + rw [commutes, zeroExtension_apply, zeroExtension_apply] + rfl + · have hfx : f x ∉ Set.range d := fun h => hx ((preimage x).mp h) + rw [zeroExtension_apply_outside d hd h hfx, zeroExtension_apply_outside e he _ hx] + +/-- This is the coordinate restriction identity used by the changing +finite-component index test. It is derived from the geometric preimage +identity, without invoking or assuming a global detection theorem. -/ +theorem restrictComponent_natural (e : A ↪ X) (he : IsOpenEmbedding e) + (d : B ↪ Y) (hd : IsOpenEmbedding d) (f : CocompactMap X Y) (g : CocompactMap A B) + (commutes : ∀ a, f (e a) = d (g a)) + (preimage : ∀ x, f x ∈ Set.range d ↔ x ∈ Set.range e) : + (restrictComponent d hd).comp (pushforward f) = + (pushforward g).comp (restrictComponent e he) := by + change (precomp (zeroExtensionHom d hd)).comp (precomp (pullback f)) = + (precomp (pullback g)).comp (precomp (zeroExtensionHom e he)) + rw [← precomp_comp, ← precomp_comp, pullback_zeroExtension e he d hd f g commutes preimage] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ClopenRestriction.lean b/lean/OAI/Topology/CoarseAssembly/ClopenRestriction.lean new file mode 100644 index 0000000000000000000000000000000000000000..14b8c9ef7e7cf044507e0fe85c934dd6a7f9bc9c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ClopenRestriction.lean @@ -0,0 +1,64 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.LocallyFinite +import OAI.Topology.CoarseAssembly.CirclePairing +import Mathlib.Topology.Algebra.Support + +namespace OAI + +/-! # Restricting analytic K-homology to a compact open component + +Extension by zero is constructed on the actual continuous-function +algebras. Its contravariant action on Fredholm modules is a left inverse +to pushforward of the component inclusion. No additivity theorem is +needed for this restriction calculation. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Topology +open scoped ZeroAtInfty + +variable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y] + [CompactSpace X] [T2Space Y] + +theorem continuous_zeroExtension (e : X ↪ Y) (he : IsOpenEmbedding e) + (f : C₀(X, ℂ)) : Continuous (Function.extend e f 0) := by + have hs := HasCompactSupport.of_compactSpace (f : X → ℂ) + apply continuous_of_tsupport + intro y hy + obtain ⟨x, _, rfl⟩ := hs.tsupport_extend_zero_subset he.continuous hy + rw [← he.continuousAt_iff, Function.extend_comp e.injective] + exact f.continuous.continuousAt + +@[simp] theorem zeroExtension_apply (e : X ↪ Y) (he : IsOpenEmbedding e) + (f : C₀(X, ℂ)) (x : X) : zeroExtension e he f (e x) = f x := + e.injective.extend_apply _ _ x + +theorem zeroExtension_apply_outside (e : X ↪ Y) (he : IsOpenEmbedding e) + (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : zeroExtension e he f y = 0 := + Function.extend_apply' _ _ _ hy + +def compactOpenInclusion (e : X ↪ Y) (he : IsOpenEmbedding e) : CocompactMap X Y := + compactMap ⟨e, he.continuous⟩ + +def restrictComponent (e : X ↪ Y) (he : IsOpenEmbedding e) : + LocallyFiniteK1 Y →+ LocallyFiniteK1 X := precomp (zeroExtensionHom e he) + +theorem restrictComponent_pushforward (e : X ↪ Y) (he : IsOpenEmbedding e) : + (restrictComponent e he).comp (pushforward (compactOpenInclusion e he)) = + AddMonoidHom.id (LocallyFiniteK1 X) := by + have h : (pullback (compactOpenInclusion e he)).comp (zeroExtensionHom e he) = + NonUnitalStarAlgHom.id ℂ C₀(X, ℂ) := by + ext f x + exact zeroExtension_apply e he f x + change (precomp (zeroExtensionHom e he)).comp + (precomp (pullback (compactOpenInclusion e he))) = _ + rw [← precomp_comp, h, precomp_id] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CocycleCircleMap.lean b/lean/OAI/Topology/CoarseAssembly/CocycleCircleMap.lean new file mode 100644 index 0000000000000000000000000000000000000000..1eb32e920227fd7085097ec91b8fc557fb9155aa --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CocycleCircleMap.lean @@ -0,0 +1,132 @@ +import OAI.Topology.CoarseAssembly.RipsRealization +import Mathlib.Topology.Instances.AddCircle.Defs +import Mathlib.Tactic.Linarith + +namespace OAI + +/-! +# The circle map of an integral Rips cocycle + +On each finite component, barycentric interpolation of an integral edge +cocycle defines a genuine continuous map to `ℝ / ℤ`. The local real lifts +differ by the integral edge charge. This constructs the winding test in +the manuscript, rather than assuming its topological extension. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open scoped BigOperators +open Topology + +variable {X : Type*} [PseudoMetricSpace X] {r : ℝ} + +/-- Integral charges with the two identities required on a Rips simplex. -/ +structure IntegralCocycle (X : Type*) [PseudoMetricSpace X] (r : ℝ) where + charge : X → X → ℤ + antisymm : ∀ x y, dist x y ≤ r → charge y x = -charge x y + triangle : ∀ x y z, dist x y ≤ r → dist y z ≤ r → dist z x ≤ r → + charge x y + charge y z + charge z x = 0 + +theorem IntegralCocycle.difference (c : IntegralCocycle X r) {x y z : X} + (hxy : dist x y ≤ r) (hyz : dist y z ≤ r) (hzx : dist z x ≤ r) : + c.charge x z - c.charge y z = c.charge x y := by + have h := c.triangle x y z hxy hyz hzx + rw [c.antisymm x z (by simpa only [dist_comm] using hzx)] at h + omega + +theorem Point.exists_positive (p : Point X r) : ∃ x, 0 < p.weight x := by + classical + by_contra! h + have hz : p.weight = 0 := by + ext x + exact le_antisymm (h x) (p.nonneg x) + have ht := p.total + simp [hz] at ht + +def Point.supportVertex (p : Point X r) : X := p.exists_positive.choose + +theorem Point.supportVertex_positive (p : Point X r) : + 0 < p.weight p.supportVertex := p.exists_positive.choose_spec + +theorem Point.supportVertex_mem (p : Point X r) : + p.supportVertex ∈ p.weight.support := + Finsupp.mem_support_iff.mpr (ne_of_gt p.supportVertex_positive) + +variable [Fintype X] + +/-- Local real lift based at a vertex of the supporting simplex. -/ +def IntegralCocycle.localAngle (c : IntegralCocycle X r) (x : X) (p : Point X r) : ℝ := + ∑ z : X, p.weight z * (c.charge x z : ℝ) + +theorem IntegralCocycle.localAngle_continuous (c : IntegralCocycle X r) (x : X) : + Continuous (c.localAngle x) := by + unfold localAngle + exact continuous_finsetSum _ (fun z _ => (coordinate_continuous z).mul continuous_const) + +theorem Point.sum_weight (p : Point X r) : ∑ x : X, p.weight x = 1 := by + rw [← p.total] + exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm + +/-- Changes of local lift are exactly the prescribed integral charges. -/ +theorem IntegralCocycle.localAngle_sub (c : IntegralCocycle X r) (p : Point X r) + {x y : X} (hx : x ∈ p.weight.support) (hy : y ∈ p.weight.support) : + c.localAngle x p - c.localAngle y p = (c.charge x y : ℝ) := by + classical + unfold localAngle + rw [← Finset.sum_sub_distrib] + calc + (∑ z : X, (p.weight z * (c.charge x z : ℝ) - + p.weight z * (c.charge y z : ℝ))) = + ∑ z : X, p.weight z * (c.charge x y : ℝ) := by + apply Finset.sum_congr rfl + intro z _ + by_cases hz : z ∈ p.weight.support + · rw [← mul_sub] + congr 1 + exact_mod_cast c.difference (p.diameter x hx y hy) + (p.diameter y hy z hz) (p.diameter z hz x hx) + · have hz' : p.weight z = 0 := by simpa only [Finsupp.mem_support_iff, not_not] using hz + simp only [hz', zero_mul, sub_self] + _ = (c.charge x y : ℝ) := by rw [← Finset.sum_mul, p.sum_weight, one_mul] + +theorem IntegralCocycle.localAngle_coe_eq (c : IntegralCocycle X r) (p : Point X r) + {x y : X} (hx : x ∈ p.weight.support) (hy : y ∈ p.weight.support) : + (c.localAngle x p : AddCircle (1 : ℝ)) = c.localAngle y p := by + apply sub_eq_zero.mp + rw [← AddCircle.coe_sub, c.localAngle_sub p hx hy] + apply (AddCircle.coe_eq_zero_iff (1 : ℝ)).mpr + exact ⟨c.charge x y, by simp⟩ + +/-- Barycentric interpolation of the cocycle, with values in the unit circle. -/ +def IntegralCocycle.circleMap (c : IntegralCocycle X r) (p : Point X r) : + AddCircle (1 : ℝ) := c.localAngle p.supportVertex p + +theorem IntegralCocycle.circleMap_eq (c : IntegralCocycle X r) (p : Point X r) + {x : X} (hx : x ∈ p.weight.support) : + c.circleMap p = (c.localAngle x p : AddCircle (1 : ℝ)) := + c.localAngle_coe_eq p p.supportVertex_mem hx + +theorem IntegralCocycle.circleMap_continuous (c : IntegralCocycle X r) : + Continuous c.circleMap := by + rw [continuous_iff_continuousAt] + intro p + let x := p.supportVertex + have hx : {q : Point X r | 0 < q.weight x} ∈ 𝓝 p := + (isOpen_lt continuous_const (coordinate_continuous x)).mem_nhds + p.supportVertex_positive + have hc := ((AddCircle.continuous_mk' (1 : ℝ)).comp + (c.localAngle_continuous x)).continuousAt (x := p) + apply hc.congr_of_eventuallyEq + filter_upwards [hx] with q hq + exact c.circleMap_eq q (Finsupp.mem_support_iff.mpr (ne_of_gt hq)) + +def IntegralCocycle.toContinuousMap (c : IntegralCocycle X r) : + C(Point X r, AddCircle (1 : ℝ)) := ⟨c.circleMap, c.circleMap_continuous⟩ + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CocyclePathLifting.lean b/lean/OAI/Topology/CoarseAssembly/CocyclePathLifting.lean new file mode 100644 index 0000000000000000000000000000000000000000..19325dd9accbe142cf5b8c303d31b4b860fd344e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CocyclePathLifting.lean @@ -0,0 +1,102 @@ +import OAI.Topology.CoarseAssembly.RipsPaths +import OAI.Topology.CoarseAssembly.ShortLoops + +namespace OAI + +/-! # Integer lifts and winding along graph walks + +The real lift of the constructed circle map along an actual graph walk +ends at the sum of its edge charges. This is the topological degree +calculation used before applying the published circle index formula. +-/ + +noncomputable section + +namespace CoarseAssembly + +open unitInterval + +section Lifts + +variable {Y : Type*} [TopologicalSpace Y] (f : Y → AddCircle (1 : ℝ)) + {x y z : Y} + +/-- A real path lift normalized to start at zero, with integral endpoint. -/ +structure IntegerPathLift (p : Path x y) (n : ℤ) where + path : Path (0 : ℝ) (n : ℝ) + commutes : ∀ t, f (p t) = (path t : AddCircle (1 : ℝ)) + +def shiftedRealPath (a b : ℤ) (p : Path (0 : ℝ) (b : ℝ)) : + Path (a : ℝ) ((a + b : ℤ) : ℝ) where + toFun t := (a : ℝ) + p t + continuous_toFun := continuous_const.add p.continuous + source' := by simp + target' := by simp + +def IntegerPathLift.refl (hfx : f x = 0) : + IntegerPathLift f (Path.refl x) 0 where + path := (Path.refl (0 : ℝ)).cast rfl (by simp) + commutes t := by simpa [Path.cast] using hfx + +def IntegerPathLift.trans {p : Path x y} {q : Path y z} {a b : ℤ} + (hp : IntegerPathLift f p a) (hq : IntegerPathLift f q b) : + IntegerPathLift f (p.trans q) (a + b) where + path := hp.path.trans (shiftedRealPath a b hq.path) + commutes t := by + rw [Path.trans_apply, Path.trans_apply] + split_ifs with ht + · exact hp.commutes _ + · change f (q _) = ((a : ℝ) + hq.path _ : ℝ) + rw [hq.commutes, AddCircle.coe_add] + have ha : ((a : ℝ) : AddCircle (1 : ℝ)) = 0 := + (AddCircle.coe_eq_zero_iff _).mpr ⟨a, by simp⟩ + rw [ha, zero_add] + +end Lifts + +namespace Rips + +variable {X : Type*} [PseudoMetricSpace X] {r : ℝ} + +/-- Follow the barycentric unit edges of a graph walk. -/ +def walkPath {G : SimpleGraph X} (hr : 0 ≤ r) + (hE : ∀ x y, G.Adj x y → dist x y ≤ r) : + {x y : X} → G.Walk x y → Path (vertex x hr) (vertex y hr) + | _, _, .nil => Path.refl _ + | _, _, .cons h p => (edgePath (hE _ _ h)).trans (walkPath hr hE p) + +variable [Fintype X] + +def IntegralCocycle.edgeLift (c : IntegralCocycle X r) + {x y : X} (hxy : dist x y ≤ r) : + IntegerPathLift c.circleMap (edgePath hxy) (c.charge x y) where + path := Path.segment 0 (c.charge x y : ℝ) + commutes t := by + rw [c.circleMap_edgePath] + simp only [Path.segment_apply, AffineMap.lineMap_apply, vsub_eq_sub, vadd_eq_add, + sub_zero, smul_eq_mul, add_zero] + +def IntegralCocycle.walkLift (c : IntegralCocycle X r) {G : SimpleGraph X} + (hr : 0 ≤ r) (hE : ∀ x y, G.Adj x y → dist x y ≤ r) + {x y : X} (p : G.Walk x y) : + IntegerPathLift c.circleMap (walkPath hr hE p) (walkCharge c.charge p) := by + induction p with + | nil => exact IntegerPathLift.refl _ (c.circleMap_vertex hr _) + | cons h p ih => exact (c.edgeLift (hE _ _ h)).trans _ ih + +/-- A closed graph walk yields a circle-valued loop with a real lift whose +endpoint is exactly its integral cocycle evaluation. -/ +theorem IntegralCocycle.closed_walk_lift (c : IntegralCocycle X r) {G : SimpleGraph X} + (hr : 0 ≤ r) (hE : ∀ x y, G.Adj x y → dist x y ≤ r) + {x : X} (p : G.Walk x x) : + ∃ L : Path (0 : ℝ) (walkCharge c.charge p : ℝ), + ∀ t, c.circleMap (walkPath hr hE p t) = (L t : AddCircle (1 : ℝ)) := + ⟨(c.walkLift hr hE p).path, (c.walkLift hr hE p).commutes⟩ + +end Rips + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CoefficientDecomposition.lean b/lean/OAI/Topology/CoarseAssembly/CoefficientDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..3e0d87fe4f8e02edeb1a292c471c4efb7d45c16a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CoefficientDecomposition.lean @@ -0,0 +1,88 @@ +import OAI.Topology.CoarseAssembly.DirectSumIntertwining + +namespace OAI + +/-! # Orthogonal decompositions lifted to the spatial vertex modules -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E F H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem orthogonal_isometries_decompose (V : E →ₗᵢ[ℂ] H) (W : F →ₗᵢ[ℂ] H) + (hex : V.toContinuousLinearMap.comp V.toContinuousLinearMap.adjoint + + W.toContinuousLinearMap.comp W.toContinuousLinearMap.adjoint = 1) + (T : H →L[ℂ] H) (S : E →L[ℂ] E) (R : F →L[ℂ] F) + (hV : T.comp V.toContinuousLinearMap = V.toContinuousLinearMap.comp S) + (hW : T.comp W.toContinuousLinearMap = W.toContinuousLinearMap.comp R) : + T = operatorConjugation V S + operatorConjugation W R := by + ext x + have hx : V (V.toContinuousLinearMap.adjoint x) + W (W.toContinuousLinearMap.adjoint x) = x := + DFunLike.congr_fun hex x + change T x = V (S (V.toContinuousLinearMap.adjoint x)) + W (R (W.toContinuousLinearMap.adjoint x)) + calc + _ = T (V (V.toContinuousLinearMap.adjoint x) + W (W.toContinuousLinearMap.adjoint x)) := + congrArg T hx.symm + _ = _ := by + rw [map_add] + exact congrArg₂ (fun x y : H => x + y) + (DFunLike.congr_fun hV (V.toContinuousLinearMap.adjoint x)) + (DFunLike.congr_fun hW (W.toContinuousLinearMap.adjoint x)) + +namespace DiscreteRoe + +variable {X : Type*} [DecidableEq X] + +omit [CompleteSpace F] [DecidableEq X] in +theorem coefficientIsometry_orthogonal (V : E →ₗᵢ[ℂ] H) (W : F →ₗᵢ[ℂ] H) + (hVW : V.toContinuousLinearMap.adjoint.comp W.toContinuousLinearMap = 0) : + (coefficientIsometry (X := X) V).toContinuousLinearMap.adjoint.comp + (coefficientIsometry W).toContinuousLinearMap = 0 := by + ext v x + change (coefficientIsometry V).toContinuousLinearMap.adjoint (coefficientIsometry W v) x = 0 + rw [coefficientIsometry_adjoint_apply, coefficientIsometry_apply] + exact DFunLike.congr_fun hVW (v x) + +omit [DecidableEq X] in +theorem coefficientIsometry_exhaustive (V : E →ₗᵢ[ℂ] H) (W : F →ₗᵢ[ℂ] H) + (hex : V.toContinuousLinearMap.comp V.toContinuousLinearMap.adjoint + + W.toContinuousLinearMap.comp W.toContinuousLinearMap.adjoint = 1) : + (coefficientIsometry (X := X) V).toContinuousLinearMap.comp + (coefficientIsometry V).toContinuousLinearMap.adjoint + + (coefficientIsometry W).toContinuousLinearMap.comp + (coefficientIsometry W).toContinuousLinearMap.adjoint = 1 := by + ext v x + change coefficientIsometry V ((coefficientIsometry V).toContinuousLinearMap.adjoint v) x + + coefficientIsometry W ((coefficientIsometry W).toContinuousLinearMap.adjoint v) x = v x + rw [coefficientIsometry_apply, coefficientIsometry_apply, + coefficientIsometry_adjoint_apply, coefficientIsometry_adjoint_apply] + exact DFunLike.congr_fun hex (v x) + +end DiscreteRoe + +namespace Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ) + {c d e : OddCycle C(Point X r, ℂ)} + +theorem ripsSpatialOperator_directSum (h : c.IsDirectSum d e) + (hc : c.representation 1 = 1) (hd : d.representation 1 = 1) (he : e.representation 1 = 1) : + ripsSpatialOperator r e he = + operatorConjugation (coefficientIsometry h.left) (ripsSpatialOperator r c hc) + + operatorConjugation (coefficientIsometry h.right) (ripsSpatialOperator r d hd) := + orthogonal_isometries_decompose _ _ (coefficientIsometry_exhaustive h.left h.right h.exhaustive) + _ _ _ (ripsSpatialOperator_directSum_left r h hc he) + (ripsSpatialOperator_directSum_right r h hd he) + +end Rips +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CoefficientFamilyMultiplier.lean b/lean/OAI/Topology/CoarseAssembly/CoefficientFamilyMultiplier.lean new file mode 100644 index 0000000000000000000000000000000000000000..abbad1f408c3be9b4fee04880bf0774083231907 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CoefficientFamilyMultiplier.lean @@ -0,0 +1,74 @@ +import OAI.Topology.CoarseAssembly.FamilyEmbeddingIndependence + +namespace OAI + +/-! # The actual multiplier underlying a coefficient-family boundary -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + {E : ℕ → Type*} [∀ i, NormedAddCommGroup (E i)] + [∀ i, InnerProductSpace ℂ (E i)] [∀ i, CompleteSpace (E i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +variable (o : ∀ i, Q i) (A : ∀ i, Operator (Q i) (E i)) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (r : ℝ) (hr : 0 ≤ r) (hp : ∀ i, PropagationLE r (A i)) + (V : ∀ i, E i →ₗᵢ[ℂ] H) + +def coefficientFamilyMultiplier : + letI := separatedMetric o + multiplierAlgebra (X := Sigma Q) (H := H) := by + let := separatedMetric o + exact separatedFamilyMultiplier o (fun i => coefficientExtension (V i) (A i)) + (C + 2) (by linarith) + (fun i => (coefficientExtension_norm_le (V i) (A i)).trans (by linarith [hA i])) + r hr (fun i => coefficientExtension_propagation (V i) hr (hp i)) + +theorem coefficientFamilyMultiplier_value : + letI := separatedMetric o + (coefficientFamilyMultiplier o A C hC hA r hr hp V).val = + isometricExtension (familyCoefficientIsometry V) (blockOperator A C hC hA) := by + let := separatedMetric o + exact (familyCoefficient_extension V A C hC hA (C + 2) (by linarith) + (fun i => (coefficientExtension_norm_le (V i) (A i)).trans (by linarith [hA i]))).symm + +theorem coefficientFamilyMultiplier_selfAdjoint (hs : ∀ i, IsSelfAdjoint (A i)) : + letI := separatedMetric o + IsSelfAdjoint (coefficientFamilyMultiplier o A C hC hA r hr hp V) := by + let := separatedMetric o + exact separatedFamilyMultiplier_selfAdjoint o (fun i => coefficientExtension (V i) (A i)) + (C + 2) (by linarith) + (fun i => (coefficientExtension_norm_le (V i) (A i)).trans (by linarith [hA i])) + r hr (fun i => coefficientExtension_propagation (V i) hr (hp i)) + (fun i => coefficientExtension_selfAdjoint (V i) (A i) (hs i)) + +theorem coefficientFamilyMultiplier_defect (hs : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) (E i)))) : + letI := separatedMetric o + (coefficientFamilyMultiplier o A C hC hA r hr hp V).val ^ 2 - 1 ∈ + algebra (X := Sigma Q) (H := H) := by + let := separatedMetric o + exact diagonalFamily_square_mem_roe o (fun i => coefficientExtension (V i) (A i)) + (C + 2) (by linarith) + (fun i => (coefficientExtension_norm_le (V i) (A i)).trans (by linarith [hA i])) + r hr (fun i => coefficientExtension_propagation (V i) hr (hp i)) + (fun i => coefficientExtension_selfAdjoint (V i) (A i) (hs i)) + (fun i => coefficientExtension_square_compact (V i) (A i) (hsq i)) + +theorem coefficientFamilyBoundary_eq_multiplier (hs : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) (E i)))) : + letI := separatedMetric o + coefficientFamilyBoundary o A C hC hA r hr hp hs hsq V = + multiplierBoundaryClass (coefficientFamilyMultiplier o A C hC hA r hr hp V) + (coefficientFamilyMultiplier_selfAdjoint o A C hC hA r hr hp V hs) + (coefficientFamilyMultiplier_defect o A C hC hA r hr hp V hs hsq) := rfl + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CoefficientInclusion.lean b/lean/OAI/Topology/CoarseAssembly/CoefficientInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..7d1efe76280ddca7dad492b08f963085aa30e26d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CoefficientInclusion.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.CoefficientIsometry +import OAI.Topology.CoarseAssembly.AmpleRipsFamily +import OAI.Topology.CoarseAssembly.RipsInclusionNaturality + +namespace OAI + +/-! # Ample coefficient transport commutes with vertex inclusion -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X Y E H : Type*} [DecidableEq X] [DecidableEq Y] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +omit [DecidableEq X] [DecidableEq Y] in +theorem coefficientIsometry_inclusion (V : E →ₗᵢ[ℂ] H) (e : X ↪ Y) : + (coefficientIsometry (X := Y) V).comp (inclusionIsometry (H := E) e) = + (inclusionIsometry (H := H) e).comp (coefficientIsometry (X := X) V) := by + apply DFunLike.ext + intro v + apply lp.ext + funext y + change V (inclusionVector e v y) = inclusionVector e (coefficientIsometry V v) y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + rw [inclusionVector_apply, inclusionVector_apply, coefficientIsometry_apply] + · rw [inclusionVector_zero e _ _ hy, inclusionVector_zero e _ _ hy, map_zero] + +end CoarseAssembly.DiscreteRoe + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X Y : Type} [PseudoMetricSpace X] [PseudoMetricSpace Y] + [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] + +theorem ampleRipsOperator_inclusion (r : ℝ) (e : X ↪ Y) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) + (c : OddCycle C(Point X r, ℂ)) (hπ : c.representation 1 = 1) : + ampleRipsOperator r (includedCycle r e he c) (includedCycle_unital r e he c hπ) = + isometricExtension (inclusionIsometry e) (ampleRipsOperator r c hπ) := by + let V := ampleIsometry c.space + change isometricExtension (coefficientIsometry (X := Y) V) + (ripsSpatialOperator r (includedCycle r e he c) (includedCycle_unital r e he c hπ)) = + isometricExtension (inclusionIsometry e) + (isometricExtension (coefficientIsometry (X := X) V) (ripsSpatialOperator r c hπ)) + have h := ripsSpatialOperator_inclusion r e he c hπ + rw [h] + simp only [isometricExtension_comp, coefficientIsometry_inclusion] + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CoefficientIsometry.lean b/lean/OAI/Topology/CoarseAssembly/CoefficientIsometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..78b8db706863ab8f44dfbda20a396a95056c190d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CoefficientIsometry.lean @@ -0,0 +1,98 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ProjectionBlocks +import OAI.Topology.CoarseAssembly.SpatialLocalization + +namespace OAI + +/-! # Isometric changes of the coefficient Hilbert space + +Changing coefficients by a pointwise isometry preserves propagation. +Extending by the identity on its orthogonal complement preserves compact +square defects, as required to place localized cycles on an ample module. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X E H : Type*} [DecidableEq X] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [DecidableEq X] [CompleteSpace E] [CompleteSpace H] in +@[simp] theorem coefficientIsometry_apply (V : E →ₗᵢ[ℂ] H) (v : Module X E) (x : X) : + coefficientIsometry V v x = V (v x) := rfl + +omit [DecidableEq X] in +@[simp] theorem coefficientIsometry_adjoint_apply (V : E →ₗᵢ[ℂ] H) + (v : Module X H) (x : X) : + (coefficientIsometry (X := X) V).toContinuousLinearMap.adjoint v x = + V.toContinuousLinearMap.adjoint (v x) := by + rw [coefficientIsometry, blockIsometry_toCLM, blockOperator_adjoint] + rfl + +theorem coefficientIsometry_adjoint_single (V : E →ₗᵢ[ℂ] H) (x : X) (h : H) : + (coefficientIsometry (X := X) V).toContinuousLinearMap.adjoint (lp.single 2 x h) = + lp.single 2 x (V.toContinuousLinearMap.adjoint h) := by + apply lp.ext + funext y + simp only [coefficientIsometry_adjoint_apply, lp.single_apply, Pi.single_apply] + split_ifs <;> simp + +theorem coefficientConjugation_entry (V : E →ₗᵢ[ℂ] H) (T : Operator X E) (x y : X) : + entry (operatorConjugation (coefficientIsometry V) T) x y = + V.toContinuousLinearMap.comp ((entry T x y).comp V.toContinuousLinearMap.adjoint) := by + ext h + simp only [entry_apply, operatorConjugation, ContinuousLinearMap.comp_apply, + coefficientIsometry_adjoint_single, LinearIsometry.coe_toContinuousLinearMap, + coefficientIsometry_apply] + +variable [PseudoMetricSpace X] + +theorem coefficientConjugation_propagation (V : E →ₗᵢ[ℂ] H) {T : Operator X E} + {r : ℝ} (hp : PropagationLE r T) : + PropagationLE r (operatorConjugation (coefficientIsometry V) T) := by + intro x y hxy + rw [coefficientConjugation_entry, hp x y hxy] + simp + +omit [DecidableEq X] [PseudoMetricSpace X] in +theorem coefficientExtension_selfAdjoint (V : E →ₗᵢ[ℂ] H) (T : Operator X E) + (hs : IsSelfAdjoint T) : IsSelfAdjoint (coefficientExtension V T) := + isometricExtension_selfAdjoint _ _ hs + +omit [DecidableEq X] [PseudoMetricSpace X] in +theorem coefficientExtension_norm_le (V : E →ₗᵢ[ℂ] H) (T : Operator X E) : + ‖coefficientExtension V T‖ ≤ ‖T‖ + 2 := isometricExtension_norm_le _ _ + +omit [DecidableEq X] [PseudoMetricSpace X] in +theorem coefficientExtension_square_compact (V : E →ₗᵢ[ℂ] H) (T : Operator X E) + (hsq : IsCompactOperator (T * T - (1 : Operator X E))) : + IsCompactOperator (coefficientExtension V T * coefficientExtension V T - + (1 : Operator X H)) := isometricExtension_square_compact _ _ hsq + +theorem coefficientExtension_propagation (V : E →ₗᵢ[ℂ] H) {T : Operator X E} + {r : ℝ} (hr : 0 ≤ r) (hp : PropagationLE r T) : + PropagationLE r (coefficientExtension V T) := by + have he : coefficientExtension V T = 1 + + operatorConjugation (coefficientIsometry V) T - + operatorConjugation (coefficientIsometry V) 1 := by + change 1 + operatorConjugation (coefficientIsometry V) (T - 1) = _ + simp only [operatorConjugation, ContinuousLinearMap.comp_sub, + ContinuousLinearMap.sub_comp] + abel + have h1 := propagationLE_one (X := X) (H := H) + have h2 := coefficientConjugation_propagation V hp + have h3 := coefficientConjugation_propagation (X := X) V (propagationLE_one (X := X) (H := E)) + have hn : PropagationLE 0 (-operatorConjugation (coefficientIsometry (X := X) V) 1) := by + convert h3.smul (-1 : ℂ) using 1 + ext v + simp + rw [he, sub_eq_add_neg] + simpa only [max_eq_right hr, max_eq_left hr] using (h1.add h2).add hn + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CoefficientRoeHom.lean b/lean/OAI/Topology/CoarseAssembly/CoefficientRoeHom.lean new file mode 100644 index 0000000000000000000000000000000000000000..9565b907c94594ed7257e8c668809854908d3db9 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CoefficientRoeHom.lean @@ -0,0 +1,61 @@ +import OAI.Topology.CoarseAssembly.CoefficientIsometry +import OAI.Topology.CoarseAssembly.LocallyCompactAlgebra + +namespace OAI + +/-! # The Roe algebra map induced by a coefficient isometry -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X E H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [PseudoMetricSpace X] in +theorem coefficientConjugation_compactEntries (V : E →ₗᵢ[ℂ] H) + {T : Operator X E} (hc : CompactEntries T) : + CompactEntries (operatorConjugation (coefficientIsometry V) T) := by + intro x y + rw [coefficientConjugation_entry] + exact ((hc x y).comp_clm V.toContinuousLinearMap.adjoint).clm_comp V.toContinuousLinearMap + +theorem coefficientConjugation_generator (V : E →ₗᵢ[ℂ] H) + {T : Operator X E} (hT : Generator T) : + Generator (operatorConjugation (coefficientIsometry V) T) := by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + refine ⟨⟨r, hr, coefficientConjugation_propagation V hp⟩, + coefficientConjugation_compactEntries V hc, ?_⟩ + rw [← operatorConjugation_star] + exact coefficientConjugation_compactEntries V hcs + +theorem coefficientConjugation_mem_roe (V : E →ₗᵢ[ℂ] H) + {T : Operator X E} (hT : T ∈ algebra (X := X) (H := E)) : + operatorConjugation (coefficientIsometry V) T ∈ algebra (X := X) (H := H) := by + let φ := operatorConjugationHom (coefficientIsometry (X := X) V) + let S := (algebra (X := X) (H := H)).comap φ + have hcont : Continuous φ := by + show Continuous (fun T : Operator X E => + (coefficientIsometry V).toContinuousLinearMap.comp + (T.comp (coefficientIsometry V).toContinuousLinearMap.adjoint)) + exact continuous_const.clm_comp (continuous_id.clm_comp continuous_const) + have hclosed : IsClosed (S : Set (Operator X E)) := algebra_isClosed.preimage hcont + have hle : NonUnitalStarAlgebra.adjoin ℂ {T : Operator X E | Generator T} ≤ S := by + apply NonUnitalStarAlgebra.adjoin_le + intro T hT + exact generator_mem (coefficientConjugation_generator V hT) + exact (NonUnitalStarSubalgebra.topologicalClosure_minimal _ hle hclosed) hT + +def coefficientRoeHom (V : E →ₗᵢ[ℂ] H) : + algebra (X := X) (H := E) →⋆ₙₐ[ℂ] algebra (X := X) (H := H) := + NonUnitalStarAlgHom.codRestrict + ((operatorConjugationHom (coefficientIsometry V)).comp + (NonUnitalStarSubalgebraClass.subtype _)) _ + (fun T => coefficientConjugation_mem_roe V T.property) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CompactBlockSum.lean b/lean/OAI/Topology/CoarseAssembly/CompactBlockSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..40d97d7d160fa1cfa815d5e473c23e999e6b15b6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CompactBlockSum.lean @@ -0,0 +1,110 @@ +import OAI.Topology.CoarseAssembly.CountableHilbertSum +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation + +namespace OAI + +/-! # Compact diagonal operators on a countable Hilbert sum -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Filter +open scoped Topology + +variable (H : ℕ → HilbertSpace) (K : ∀ j, End (H j)) + +def singleBlock (j : ℕ) : End (countableHilbertSpace H) := + (lp.singleContinuousLinearMap ℂ (fun j => H j) 2 j) ∘L K j ∘L + lp.evalCLM ℂ (fun j => H j) 2 j + +theorem singleBlock_compact (j : ℕ) (hK : IsCompactOperator (K j)) : + IsCompactOperator (singleBlock H K j) := + (hK.comp_clm (lp.evalCLM ℂ (fun j => H j) 2 j)).clm_comp + (lp.singleContinuousLinearMap ℂ (fun j => H j) 2 j) + +def truncateBlocks (N j : ℕ) : End (H j) := if j < N then K j else 0 + +theorem truncateBlocks_norm (N : ℕ) (C : ℝ) (hC : 0 ≤ C) (hK : ∀ j, ‖K j‖ ≤ C) : + ∀ j, ‖truncateBlocks H K N j‖ ≤ C := by + intro j + unfold truncateBlocks + split_ifs + · exact hK j + · simpa only [norm_zero] using hC + +def truncatedBlockSum (N : ℕ) (C : ℝ) (hC : 0 ≤ C) (hK : ∀ j, ‖K j‖ ≤ C) : + End (countableHilbertSpace H) := + CoarseAssembly.blockOperator (truncateBlocks H K N) C hC (truncateBlocks_norm H K N C hC hK) + +theorem truncatedBlockSum_apply (N : ℕ) (C : ℝ) (hC : 0 ≤ C) (hK : ∀ j, ‖K j‖ ≤ C) + (x : HilbertSum H) (j : ℕ) : + truncatedBlockSum H K N C hC hK x j = if j < N then K j (x j) else 0 := by + change (truncateBlocks H K N j) (x j) = _ + unfold truncateBlocks + split_ifs <;> rfl + +theorem truncatedBlockSum_succ (N : ℕ) (C : ℝ) (hC : 0 ≤ C) (hK : ∀ j, ‖K j‖ ≤ C) : + truncatedBlockSum H K (N + 1) C hC hK = + truncatedBlockSum H K N C hC hK + singleBlock H K N := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change truncatedBlockSum H K (N + 1) C hC hK x j = + truncatedBlockSum H K N C hC hK x j + (lp.single (E := fun j => H j) 2 N (K N (x N))) j + rw [truncatedBlockSum_apply H K (N + 1) C hC hK x j, + truncatedBlockSum_apply H K N C hC hK x j] + by_cases hj : j = N + · subst j + simp only [Nat.lt_succ_self, ite_true, lt_self_iff_false, ite_false, + lp.single_apply_self, zero_add] + · have hlt : j < N + 1 ↔ j < N := by omega + rw [lp.single_apply_ne (E := fun j => H j) 2 N (K N (x N)) hj, add_zero] + simp only [hlt] + +theorem truncatedBlockSum_compact (C : ℝ) (hC : 0 ≤ C) (hK : ∀ j, ‖K j‖ ≤ C) + (hc : ∀ j, IsCompactOperator (K j)) (N : ℕ) : + IsCompactOperator (truncatedBlockSum H K N C hC hK) := by + induction N with + | zero => + have he : truncatedBlockSum H K 0 C hC hK = 0 := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + rw [truncatedBlockSum_apply H K 0 C hC hK x j] + simp + rw [he] + exact isCompactOperator_zero + | succ N ih => + rw [truncatedBlockSum_succ] + exact ih.add (singleBlock_compact H K N (hc N)) + +theorem blockSum_compact (C : ℝ) (hC : 0 ≤ C) (hK : ∀ j, ‖K j‖ ≤ C) + (hc : ∀ j, IsCompactOperator (K j)) (htail : Tendsto (fun j => ‖K j‖) atTop (𝓝 0)) : + IsCompactOperator (CoarseAssembly.blockOperator K C hC hK) := by + apply isCompactOperator_of_tendsto (l := atTop) (F := fun N => truncatedBlockSum H K N C hC hK) + · apply Metric.tendsto_atTop.mpr + intro ε hε + obtain ⟨N, hN⟩ := Metric.tendsto_atTop.mp htail (ε / 2) (by positivity) + refine ⟨N, fun n hn => ?_⟩ + rw [dist_eq_norm] + apply lt_of_le_of_lt (CoarseAssembly.blockOperator_dist_le _ _ C C (ε / 2) hC hC + (by positivity) (truncateBlocks_norm H K n C hC hK) hK ?_) (by linarith) + intro j + unfold truncateBlocks + split_ifs with hj + · simp only [sub_self, norm_zero] + positivity + · simp only [zero_sub, norm_neg] + have hjn : N ≤ j := hn.trans (Nat.le_of_not_gt hj) + have hsmall := hN j hjn + simpa only [dist_zero_right, norm_norm] using le_of_lt hsmall + · exact Filter.Eventually.of_forall (truncatedBlockSum_compact H K C hC hK hc) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CompactFamilyHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/CompactFamilyHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..8fdcd195f6b13f27a79ce63beb38603f46992183 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CompactFamilyHomotopy.lean @@ -0,0 +1,108 @@ +import OAI.Topology.CoarseAssembly.CompactFamilyMap +import OAI.Topology.CoarseAssembly.SigmaFunctionNorms +import OAI.Topology.CoarseAssembly.CompactHomotopy + +namespace OAI + +/-! # Norm continuity of pullback along component-preserving family homotopies -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Filter +open scoped ZeroAtInfty Topology CStarAlgebra + +variable {X Y : ℕ → Type} [∀ j, TopologicalSpace (X j)] + [∀ j, TopologicalSpace (Y j)] [∀ j, CompactSpace (X j)] + [∀ j, CompactSpace (Y j)] [∀ j, T2Space (Y j)] + +def compactFamilySlice (F : ∀ j, C(Interval × X j, Y j)) (t : Interval) : + CocompactMap (Sigma X) (Sigma Y) := + compactFamilyMap (fun j => (F j).curry t) + +theorem compactFamilyPullback_continuous (F : ∀ j, C(Interval × X j, Y j)) + (f : C₀(Sigma Y, ℂ)) : + Continuous (fun t => pullback (compactFamilySlice F t) f) := by + have hlocal (j : ℕ) : Continuous (fun t : Interval => + (sigmaFunctionRestriction Y j f).comp ((F j).curry t)) := + (ContinuousMap.continuous_postcomp (sigmaFunctionRestriction Y j f)).comp + (F j).curry.continuous + apply continuous_iff_continuousAt.mpr + intro t₀ + apply Metric.tendsto_nhds.mpr + intro ε hε + obtain ⟨N, hN⟩ := Metric.tendsto_atTop.mp + (sigmaFunctionRestriction_norm_tendsto Y f) (ε / 4) (by positivity) + have hhead : ∀ᶠ t in 𝓝 t₀, ∀ j ∈ Finset.range N, + dist ((sigmaFunctionRestriction Y j f).comp ((F j).curry t)) + ((sigmaFunctionRestriction Y j f).comp ((F j).curry t₀)) < ε / 2 := by + apply (Finset.eventually_all _).mpr + intro j _ + exact Metric.tendsto_nhds.mp (hlocal j).continuousAt (ε / 2) (by positivity) + filter_upwards [hhead] with t ht + change dist (pullback (compactFamilySlice F t) f).toBCF + (pullback (compactFamilySlice F t₀) f).toBCF < ε + apply lt_of_le_of_lt ((BoundedContinuousFunction.dist_le (by positivity : 0 ≤ ε / 2)).mpr ?_) + (by linarith : ε / 2 < ε) + rintro ⟨j, x⟩ + change dist (sigmaFunctionRestriction Y j f ((F j).curry t x)) + (sigmaFunctionRestriction Y j f ((F j).curry t₀ x)) ≤ ε / 2 + by_cases hj : j < N + · exact (ContinuousMap.dist_apply_le_dist x).trans + (ht j (Finset.mem_range.mpr hj)).le + · have hb : ‖sigmaFunctionRestriction Y j f‖ < ε / 4 := by + simpa only [dist_zero_right, norm_norm] using hN j (by omega) + calc + _ ≤ ‖sigmaFunctionRestriction Y j f ((F j).curry t x)‖ + + ‖sigmaFunctionRestriction Y j f ((F j).curry t₀ x)‖ := dist_le_norm_add_norm _ _ + _ ≤ ‖sigmaFunctionRestriction Y j f‖ + ‖sigmaFunctionRestriction Y j f‖ := + add_le_add (ContinuousMap.norm_coe_le_norm _ _) (ContinuousMap.norm_coe_le_norm _ _) + _ ≤ ε / 2 := by linarith + +def compactFamilyCycleHomotopy (F : ∀ j, C(Interval × X j, Y j)) + (c : OddCycle C₀(Sigma X, ℂ)) : OddHomotopy C₀(Sigma Y, ℂ) where + space := c.space + representation t := c.representation.comp (pullback (compactFamilySlice F t)) + operator _ := c.operator + continuous_representation f := + (show Continuous (c.representation : C₀(Sigma X, ℂ) → End c.space) from + map_continuous _).comp (compactFamilyPullback_continuous F f) + continuous_operator := continuous_const + commutator_compact t f := c.commutator_compact (pullback (compactFamilySlice F t) f) + square_compact t f := c.square_compact (pullback (compactFamilySlice F t) f) + adjoint_compact t f := c.adjoint_compact (pullback (compactFamilySlice F t) f) + +/-- Componentwise compact homotopies give a proper family homotopy on analytic classes. -/ +theorem compactFamily_homotopy_invariance (f g : ∀ j, C(X j, Y j)) + (H : ∀ j, (f j).Homotopy (g j)) : + pushforward (compactFamilyMap f) = pushforward (compactFamilyMap g) := by + have hstart : compactFamilySlice (fun j => (H j).toContinuousMap) start = + compactFamilyMap f := by + apply CocompactMap.ext + rintro ⟨j, x⟩ + apply congrArg (Sigma.mk j) + exact (H j).map_zero_left x + have hfinish : compactFamilySlice (fun j => (H j).toContinuousMap) finish = + compactFamilyMap g := by + apply CocompactMap.ext + rintro ⟨j, x⟩ + apply congrArg (Sigma.mk j) + exact (H j).map_one_left x + apply hom_ext + intro c + change precomp _ (cycleClass C₀(Sigma X, ℂ) c) = + precomp _ (cycleClass C₀(Sigma X, ℂ) c) + rw [precomp_cycleClass, precomp_cycleClass] + have hh := homotopy_eq (compactFamilyCycleHomotopy (fun j => (H j).toContinuousMap) c) + change cycleClass C₀(Sigma Y, ℂ) (c.precomp (pullback + (compactFamilySlice (fun j => (H j).toContinuousMap) start))) = + cycleClass C₀(Sigma Y, ℂ) (c.precomp (pullback + (compactFamilySlice (fun j => (H j).toContinuousMap) finish))) at hh + rwa [hstart, hfinish] at hh + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CompactFamilyMap.lean b/lean/OAI/Topology/CoarseAssembly/CompactFamilyMap.lean new file mode 100644 index 0000000000000000000000000000000000000000..6043d060841f2cb522f1c27c280d414aad82ba93 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CompactFamilyMap.lean @@ -0,0 +1,50 @@ +import OAI.Topology.CoarseAssembly.LocallyFinite +import Mathlib.Topology.Compactness.Compact + +namespace OAI + +/-! # Proper maps preserving compact components + +The properness argument for the family of boundary loops uses compactness +of each source component and preservation of the discrete component index. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Topology + +variable {X Y : ℕ → Type} [∀ j, TopologicalSpace (X j)] + [∀ j, TopologicalSpace (Y j)] [∀ j, CompactSpace (X j)] [∀ j, T2Space (Y j)] + +def compactFamilyContinuousMap (γ : ∀ j, C(X j, Y j)) : C(Sigma X, Sigma Y) where + toFun z := ⟨z.1, γ z.1 z.2⟩ + continuous_toFun := continuous_sigma (fun j => continuous_sigmaMk.comp (γ j).continuous) + +theorem compactFamily_preimage_compact (γ : ∀ j, C(X j, Y j)) + (K : Set (Sigma Y)) (hK : IsCompact K) : + IsCompact ((compactFamilyContinuousMap γ) ⁻¹' K) := by + obtain ⟨s, t, hs, _ht, heq⟩ := hK.sigma_exists_finite_sigma_eq + have hcover : (compactFamilyContinuousMap γ) ⁻¹' K ⊆ + s.sigma (fun j => (Set.univ : Set (X j))) := by + rintro ⟨j, z⟩ hz + change Sigma.mk j (γ j z) ∈ K at hz + rw [← heq] at hz + exact ⟨hz.1, Set.mem_univ _⟩ + exact (Set.isCompact_sigma hs (fun _ _ => isCompact_univ)).of_isClosed_subset + (hK.isClosed.preimage (compactFamilyContinuousMap γ).continuous) hcover + +def compactFamilyMap (γ : ∀ j, C(X j, Y j)) : CocompactMap (Sigma X) (Sigma Y) where + toContinuousMap := compactFamilyContinuousMap γ + cocompact_tendsto' := CocompactMap.tendsto_of_forall_preimage + (compactFamily_preimage_compact γ) + +@[simp] theorem compactFamilyMap_apply (γ : ∀ j, C(X j, Y j)) (j : ℕ) (x : X j) : + compactFamilyMap γ ⟨j, x⟩ = ⟨j, γ j x⟩ := rfl + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CompactFunctionalCalculus.lean b/lean/OAI/Topology/CoarseAssembly/CompactFunctionalCalculus.lean new file mode 100644 index 0000000000000000000000000000000000000000..151dd2874992e6161fb0201d227c09b0a2b1656c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CompactFunctionalCalculus.lean @@ -0,0 +1,62 @@ +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation +import Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Range +import Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic + +namespace OAI + +/-! # Functional calculus preserves compact self-adjoint operators + +Compact operators whose adjoints are compact form a closed star algebra. +The nonunital functional calculus stays in that algebra. This supplies the +compactness step in the remaining normalization of the odd coefficient. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +def compactOperatorAlgebra (H : HilbertSpace) : NonUnitalStarSubalgebra ℂ (End H) where + carrier := {T | IsCompactOperator T ∧ IsCompactOperator (star T : End H)} + zero_mem' := by simp only [Set.mem_ofPred_eq, star_zero]; exact ⟨isCompactOperator_zero, isCompactOperator_zero⟩ + add_mem' hT hS := by + refine ⟨hT.1.add hS.1, ?_⟩ + rw [star_add] + exact hT.2.add hS.2 + mul_mem' hT hS := by + refine ⟨compact_mul_right hT.1 _, ?_⟩ + rw [star_mul] + exact compact_mul_right hS.2 _ + smul_mem' z T hT := by + refine ⟨hT.1.smul z, ?_⟩ + rw [star_smul] + exact hT.2.smul (star z) + star_mem' hT := by + exact ⟨hT.2, by simpa only [star_star] using hT.1⟩ + +theorem compactOperatorAlgebra_closed : IsClosed (compactOperatorAlgebra H : Set (End H)) := by + change IsClosed ({T : End H | IsCompactOperator T} ∩ + {T : End H | IsCompactOperator (star T : End H)}) + exact isClosed_setOfPred_isCompactOperator.inter + (isClosed_setOfPred_isCompactOperator.preimage continuous_star) + +theorem compact_cfcₙ (f : ℝ → ℝ) (T : End H) + (hT : IsCompactOperator T) (hTs : IsCompactOperator (star T : End H)) : + IsCompactOperator (cfcₙ f T : End H) := by + let : IsClosed (compactOperatorAlgebra H : Set (End H)) := compactOperatorAlgebra_closed + have ht : T ∈ compactOperatorAlgebra H := ⟨hT, hTs⟩ + exact (cfcₙ_mem (𝕜' := ℂ) (s := compactOperatorAlgebra H) f ht).1 + +theorem compact_cfc (f : ℝ → ℝ) (T : End H) + (hT : IsCompactOperator T) (hTs : IsCompactOperator (star T : End H)) + (hf : ContinuousOn f (quasispectrum ℝ T)) (hf0 : f 0 = 0) : + IsCompactOperator (cfc f T : End H) := by + rw [← cfcₙ_eq_cfc hf hf0] + exact compact_cfcₙ f T hT hTs + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CompactHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/CompactHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..0f67f053027a43bf5784f33ab45f64af029dc2ba --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CompactHomotopy.lean @@ -0,0 +1,88 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.HomotopyFilling +import Mathlib.Topology.CompactOpen +import Mathlib.Analysis.CStarAlgebra.Spectrum + +namespace OAI + +/-! # Compact homotopy invariance in the actual Fredholm presentation + +A homotopy of maps gives a point-norm continuous homotopy of pulled-back +representations. Its Fredholm operator stays fixed. This discharges the +homotopy field of the published filling input directly from the definitions. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty CStarAlgebra + +variable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y] + [CompactSpace X] + +def homotopySlice {f g : C(X, Y)} (F : f.Homotopy g) (t : Interval) : C(X, Y) := + F.toContinuousMap.curry t + +omit [CompactSpace X] in +@[simp] theorem homotopySlice_start {f g : C(X, Y)} (F : f.Homotopy g) : + homotopySlice F start = f := by + ext x + exact F.map_zero_left x + +omit [CompactSpace X] in +@[simp] theorem homotopySlice_finish {f g : C(X, Y)} (F : f.Homotopy g) : + homotopySlice F finish = g := by + ext x + exact F.map_one_left x + +theorem pullback_homotopy_continuous {f g : C(X, Y)} (F : f.Homotopy g) + (a : C₀(Y, ℂ)) : Continuous (fun t : Interval => + pullback (compactMap (homotopySlice F t)) a) := by + have hc : Continuous (fun t : Interval => a.toContinuousMap.comp (homotopySlice F t)) := + (ContinuousMap.continuous_postcomp a.toContinuousMap).comp + F.toContinuousMap.curry.continuous + have hl : Continuous (compactFunctionLift (X := X) : C(X, ℂ) → C₀(X, ℂ)) := + map_continuous _ + exact hl.comp hc + +def pullbackCycleHomotopy {f g : C(X, Y)} (F : f.Homotopy g) + (c : OddCycle C₀(X, ℂ)) : OddHomotopy C₀(Y, ℂ) where + space := c.space + representation t := c.representation.comp (pullback (compactMap (homotopySlice F t))) + operator _ := c.operator + continuous_representation a := + (show Continuous (c.representation : C₀(X, ℂ) → End c.space) from + map_continuous _).comp (pullback_homotopy_continuous F a) + continuous_operator := continuous_const + commutator_compact t a := c.commutator_compact (pullback (compactMap (homotopySlice F t)) a) + square_compact t a := c.square_compact (pullback (compactMap (homotopySlice F t)) a) + adjoint_compact t a := c.adjoint_compact (pullback (compactMap (homotopySlice F t)) a) + +theorem pullbackCycleHomotopy_start {f g : C(X, Y)} (F : f.Homotopy g) + (c : OddCycle C₀(X, ℂ)) : + (pullbackCycleHomotopy F c).eval start = c.precomp (pullback (compactMap f)) := by + change c.precomp (pullback (compactMap (homotopySlice F start))) = _ + rw [homotopySlice_start] + +theorem pullbackCycleHomotopy_finish {f g : C(X, Y)} (F : f.Homotopy g) + (c : OddCycle C₀(X, ℂ)) : + (pullbackCycleHomotopy F c).eval finish = c.precomp (pullback (compactMap g)) := by + change c.precomp (pullback (compactMap (homotopySlice F finish))) = _ + rw [homotopySlice_finish] + +theorem compact_homotopy_invariance (f g : C(X, Y)) (F : f.Homotopy g) : + pushforward (compactMap f) = pushforward (compactMap g) := by + apply hom_ext + intro c + change precomp (pullback (compactMap f)) (cycleClass C₀(X, ℂ) c) = + precomp (pullback (compactMap g)) (cycleClass C₀(X, ℂ) c) + rw [precomp_cycleClass, precomp_cycleClass] + have hh := homotopy_eq (pullbackCycleHomotopy F c) + rwa [pullbackCycleHomotopy_start, pullbackCycleHomotopy_finish] at hh + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CompactIndex.lean b/lean/OAI/Topology/CoarseAssembly/CompactIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..1c67c1d70150edc95cb05a857dea8ee9405390ea --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CompactIndex.lean @@ -0,0 +1,57 @@ +import OAI.Topology.CoarseAssembly.CycleIndex + +namespace OAI + +/-! # Compact perturbation invariance of the Fredholm index + +The compactness of both the perturbation and its adjoint keeps the straight +line path unitary modulo compact operators. Local constancy of the Fredholm +index then gives invariance, without a spectral choice of normalization. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem essentialUnitary_compactPerturb (T K : End H) + (hl : IsCompactOperator (star T * T - 1 : End H)) + (hr : IsCompactOperator (T * star T - 1 : End H)) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End H)) : + IsCompactOperator (star (T + K) * (T + K) - 1 : End H) ∧ + IsCompactOperator ((T + K) * star (T + K) - 1 : End H) := by + constructor + · have he : star (T + K) * (T + K) - 1 = + (star T * T - 1) + star T * K + star K * T + star K * K := by + rw [star_add] + noncomm_ring + rw [he] + exact ((hl.add (compact_mul_left hK _)).add (compact_mul_right hKs _)).add + (compact_mul_left hK _) + · have he : (T + K) * star (T + K) - 1 = + (T * star T - 1) + T * star K + K * star T + K * star K := by + rw [star_add] + noncomm_ring + rw [he] + exact ((hr.add (compact_mul_left hKs _)).add (compact_mul_right hK _)).add + (compact_mul_left hKs _) + +theorem fredholmIndex_compactPerturb (T K : End H) + (hl : IsCompactOperator (star T * T - 1 : End H)) + (hr : IsCompactOperator (T * star T - 1 : End H)) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End H)) : + T.toLinearMap.index = (T + K).toLinearMap.index := by + have hf (t : Interval) : (T + (t : ℝ) • K).IsFredholm := by + obtain ⟨hl', hr'⟩ := essentialUnitary_compactPerturb T ((t : ℝ) • K) hl hr + (hK.smul _) (compact_star_real_smul hKs _) + exact isFredholm_of_compact_essential_unitary _ hl' hr' + have hh := fredholmIndex_homotopy (fun t : Interval => T + (t : ℝ) • K) + (continuous_const.add (continuous_subtype_val.smul continuous_const)) hf + simpa only [start, finish, zero_smul, one_smul, add_zero] using hh + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CompactIndexPairing.lean b/lean/OAI/Topology/CoarseAssembly/CompactIndexPairing.lean new file mode 100644 index 0000000000000000000000000000000000000000..b7bda440994eb358d7fd3012c3d67a2ca9dfecf8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CompactIndexPairing.lean @@ -0,0 +1,65 @@ +import OAI.Topology.CoarseAssembly.IndexPairing +import OAI.Topology.CoarseAssembly.CompactHomotopy + +namespace OAI + +/-! # The scalar-unitary pairing for compact spaces -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty + +variable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y] + [CompactSpace X] [CompactSpace Y] + +/-- A circle-valued map as a unitary in the compact continuous-function algebra. -/ +def compactUnitary (f : C(X, Circle)) : C(X, ℂ) := + ⟨fun x => (f x : ℂ), continuous_subtype_val.comp f.continuous⟩ + +omit [CompactSpace X] in +theorem compactUnitary_star_mul (f : C(X, Circle)) : star (compactUnitary f) * compactUnitary f = 1 := by + ext x + change star (f x : ℂ) * (f x : ℂ) = 1 + simp only [Complex.star_def, Complex.conj_mul', Circle.norm_coe, one_pow, Complex.ofReal_one] + +omit [CompactSpace X] in +theorem compactUnitary_mul_star (f : C(X, Circle)) : compactUnitary f * star (compactUnitary f) = 1 := by + rw [mul_comm] + exact compactUnitary_star_mul f + +/-- The index pairing on the actual locally finite K-homology group. -/ +def compactIndexPairing (f : C(X, Circle)) : LocallyFiniteK1 X →+ ℤ := + (indexPairing (compactUnitary f) (compactUnitary_star_mul f) + (compactUnitary_mul_star f)).comp (precomp compactFunctionLift) + +@[simp] theorem compactIndexPairing_cycleClass (f : C(X, Circle)) (c : OddCycle C₀(X, ℂ)) : + compactIndexPairing f (cycleClass C₀(X, ℂ) c) = + rawCycleIndex (c.precomp compactFunctionLift) (compactUnitary f) := by + simp only [compactIndexPairing, AddMonoidHom.comp_apply, precomp_cycleClass, + indexPairing_cycleClass] + +theorem compactFunctionLift_pullback (γ : C(X, Y)) : + (pullback (compactMap γ)).comp (compactFunctionLift (X := Y)) = + (compactFunctionLift (X := X)).comp + (ContinuousMap.compStarAlgHom' ℂ ℂ γ).toNonUnitalStarAlgHom := by + ext a x + rfl + +theorem compactIndexPairing_natural (f : C(Y, Circle)) (γ : C(X, Y)) : + (compactIndexPairing f).comp (pushforward (compactMap γ)) = + compactIndexPairing (f.comp γ) := by + apply hom_ext + intro c + simp only [AddMonoidHom.comp_apply, pushforward, precomp_cycleClass, + compactIndexPairing_cycleClass, OddCycle.precomp_comp, compactFunctionLift_pullback] + let φ := (ContinuousMap.compStarAlgHom' ℂ ℂ γ).toNonUnitalStarAlgHom + have hφ : φ 1 = 1 := map_one (ContinuousMap.compStarAlgHom' ℂ ℂ γ) + exact rawCycleIndex_precomp (c.precomp compactFunctionLift) φ hφ (compactUnitary f) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ComponentHilbertInclusion.lean b/lean/OAI/Topology/CoarseAssembly/ComponentHilbertInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..938aa19e0baae847efe85a34ed9ad3342324fdac --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ComponentHilbertInclusion.lean @@ -0,0 +1,91 @@ +import OAI.Topology.CoarseAssembly.ComponentInclusion +import OAI.Topology.CoarseAssembly.DiagonalSpatialFamily +import OAI.Topology.CoarseAssembly.IsometricExtension + +namespace OAI + +/-! # Componentwise and whole-union spatial inclusions agree -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q P : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] + {H : Type} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] in +theorem componentEmbedding_range (e : ∀ i, Q i ↪ P i) (i : ℕ) (y : P i) : + (⟨i, y⟩ : Sigma P) ∈ Set.range (componentEmbedding e) ↔ y ∈ Set.range (e i) := by + constructor + · rintro ⟨⟨j, x⟩, h⟩ + have hij : j = i := congrArg Sigma.fst h + subst j + refine ⟨x, ?_⟩ + change (⟨i, e i x⟩ : Sigma P) = ⟨i, y⟩ at h + simpa only [Sigma.mk.inj_iff, heq_eq_eq, true_and] using h + · rintro ⟨x, rfl⟩ + exact ⟨⟨i, x⟩, rfl⟩ + +omit [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] in +theorem row_inclusion_adjoint (e : ∀ i, Q i ↪ P i) (v : Module (Sigma P) H) (i : ℕ) : + rowVector ((inclusionIsometry (H := H) (componentEmbedding e)).toContinuousLinearMap.adjoint v) i = + (inclusionIsometry (H := H) (e i)).toContinuousLinearMap.adjoint (rowVector v i) := by + apply lp.ext + funext x + change ((inclusionIsometry (H := H) (componentEmbedding e)).toContinuousLinearMap.adjoint v) ⟨i, x⟩ = + ((inclusionIsometry (H := H) (e i)).toContinuousLinearMap.adjoint (rowVector v i)) x + rw [inclusion_adjoint_apply, inclusion_adjoint_apply] + rfl + +omit [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] [CompleteSpace H] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] in +theorem row_inclusion (e : ∀ i, Q i ↪ P i) (v : Module (Sigma Q) H) (i : ℕ) : + rowVector (inclusionIsometry (H := H) (componentEmbedding e) v) i = + inclusionIsometry (H := H) (e i) (rowVector v i) := by + apply lp.ext + funext y + by_cases hy : y ∈ Set.range (e i) + · obtain ⟨x, rfl⟩ := hy + change inclusionVector (componentEmbedding e) v (componentEmbedding e ⟨i, x⟩) = + inclusionVector (e i) (rowVector v i) (e i x) + rw [inclusionVector_apply, inclusionVector_apply] + rfl + · have hglobal : (⟨i, y⟩ : Sigma P) ∉ Set.range (componentEmbedding e) := + fun h => hy ((componentEmbedding_range e i y).mp h) + change inclusionVector (componentEmbedding e) v ⟨i, y⟩ = + inclusionVector (e i) (rowVector v i) y + rw [inclusionVector_zero _ _ _ hglobal, inclusionVector_zero _ _ _ hy] + +omit [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] in +theorem row_isometricExtension (e : ∀ i, Q i ↪ P i) (T : Operator (Sigma Q) H) + (A : ∀ i, Operator (Q i) H) + (hT : ∀ v i, rowVector (T v) i = A i (rowVector v i)) + (v : Module (Sigma P) H) (i : ℕ) : + rowVector (isometricExtension (inclusionIsometry (componentEmbedding e)) T v) i = + isometricExtension (inclusionIsometry (e i)) (A i) (rowVector v i) := by + apply lp.ext + funext y + change (rowVector (v + operatorConjugation (inclusionIsometry (componentEmbedding e)) (T - 1) v) i) y = _ + change v ⟨i, y⟩ + + (rowVector (inclusionIsometry (componentEmbedding e) + ((T - 1) ((inclusionIsometry (componentEmbedding e)).toContinuousLinearMap.adjoint v))) i) y = _ + rw [row_inclusion] + have hsub : rowVector ((T - 1) + ((inclusionIsometry (componentEmbedding e)).toContinuousLinearMap.adjoint v)) i = + (A i - 1) ((inclusionIsometry (e i)).toContinuousLinearMap.adjoint (rowVector v i)) := by + apply lp.ext + funext x + change rowVector (T ((inclusionIsometry (componentEmbedding e)).toContinuousLinearMap.adjoint v)) i x - + rowVector ((inclusionIsometry (componentEmbedding e)).toContinuousLinearMap.adjoint v) i x = _ + rw [hT, row_inclusion_adjoint] + rfl + rw [hsub] + rfl + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ComponentInclusion.lean b/lean/OAI/Topology/CoarseAssembly/ComponentInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..f8c275d856bfbd88b6b874fdb1b30f392ac42200 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ComponentInclusion.lean @@ -0,0 +1,48 @@ +import OAI.Topology.CoarseAssembly.RipsFamilyRestriction +import OAI.Topology.CoarseAssembly.RoeInclusion + +namespace OAI + +/-! # Component-preserving inclusions of the separated graph unions -/ + +noncomputable section + +namespace CoarseAssembly + +variable {Q P : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + +def componentEmbedding (e : ∀ i, Q i ↪ P i) : Sigma Q ↪ Sigma P where + toFun x := ⟨x.1, e x.1 x.2⟩ + inj' := by + rintro ⟨i, x⟩ ⟨j, y⟩ h + have hij : i = j := congrArg Sigma.fst h + subst j + have hxy : e i x = e i y := by + simpa only [Sigma.mk.inj_iff, heq_eq_eq, true_and] using h + exact congrArg (Sigma.mk i) ((e i).injective hxy) + +theorem componentEmbedding_nonexpanding (o : ∀ i, Q i) (p : ∀ i, P i) + (e : ∀ i, Q i ↪ P i) (he : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) + (hroot : ∀ i, e i (o i) = p i) : + letI := separatedMetric o + letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y := by + let := separatedMetric o + let := separatedMetric p + rintro ⟨i, x⟩ ⟨j, y⟩ + change separatedDist p ⟨i, e i x⟩ ⟨j, e j y⟩ ≤ separatedDist o ⟨i, x⟩ ⟨j, y⟩ + by_cases hij : i = j + · subst j + simpa only [separatedDist_same] using he i x y + · rw [separatedDist_different p hij, separatedDist_different o hij] + have hx := he i x (o i) + have hy := he j (o j) y + rw [hroot i] at hx + rw [hroot j] at hy + linarith + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ComponentRestrictionNaturality.lean b/lean/OAI/Topology/CoarseAssembly/ComponentRestrictionNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..09b0c04c43091932fa2b2d477cae63b41a756be5 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ComponentRestrictionNaturality.lean @@ -0,0 +1,74 @@ +import OAI.Topology.CoarseAssembly.ComponentRipsPreimage +import OAI.Topology.CoarseAssembly.LateRipsCoarsening +import OAI.Topology.CoarseAssembly.CoefficientInclusion + +namespace OAI + +/-! # Exact restriction identity for a component-preserving geometric inclusion -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic +open scoped ZeroAtInfty + +variable {Q P : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + [∀ i, Fintype (Q i)] [∀ i, Fintype (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] + +omit [∀ i, Fintype (Q i)] [∀ i, Fintype (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] in +theorem componentRips_commutes (o : ∀ i, Q i) (p : ∀ i, P i) + (e : ∀ i, Q i ↪ P i) (hei : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) + (he : letI := separatedMetric o; letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y) + (r : ℝ) (i : ℕ) : + letI := separatedMetric o + letI := separatedMetric p + ∀ x, mapPoint (componentEmbedding e) he (separatedRipsEmbedding o r i x) = + separatedRipsEmbedding p r i (mapPoint (e i) (hei i) x) := by + let := separatedMetric o + let := separatedMetric p + intro x + apply Point.ext + change (x.weight.embDomain (separatedComponent i)).embDomain (componentEmbedding e) = + (x.weight.embDomain (e i)).embDomain (separatedComponent i) + rw [← Finsupp.embDomain_trans_apply, ← Finsupp.embDomain_trans_apply] + rfl + +omit [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] in +theorem lateRipsFunctionHom_inclusion (o : ∀ i, Q i) (p : ∀ i, P i) + (e : ∀ i, Q i ↪ P i) (hei : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) + (he : letI := separatedMetric o; letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y) + (r : ℝ) (i : ℕ) (hi : r < i) : + letI := separatedMetric o + letI := separatedMetric p + (pullback (embeddingMap (componentEmbedding e) he r)).comp (lateRipsFunctionHom p r i) = + (lateRipsFunctionHom o r i).comp (inclusionFunctionHom r (e i) (hei i)).toNonUnitalStarAlgHom := by + let := separatedMetric o + let := separatedMetric p + have heq := pullback_zeroExtension + (separatedRipsEmbedding o r i) (separatedRipsEmbedding_open o r i hi) + (separatedRipsEmbedding p r i) (separatedRipsEmbedding_open p r i hi) + (embeddingMap (componentEmbedding e) he r) (embeddingMap (e i) (hei i) r) + (componentRips_commutes o p e hei he r i) + (componentRips_preimage o p e r he i) + ext f x + have hx := congrArg (fun g : C₀(Point (Sigma Q) r, ℂ) => g x) + (DFunLike.congr_fun heq (compactFunctionLift f)) + simp only [NonUnitalStarAlgHom.comp_apply] at hx + have hc : pullback (embeddingMap (e i) (hei i) r) (compactFunctionLift f) = + compactFunctionLift (inclusionFunctionHom r (e i) (hei i) f) := by + ext a + rfl + rw [hc] at hx + simpa only [lateRipsFunctionHom, dite_eq_left hi, NonUnitalStarAlgHom.comp_apply, + StarAlgHom.coe_toNonUnitalStarAlgHom] using hx + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ComponentRipsPreimage.lean b/lean/OAI/Topology/CoarseAssembly/ComponentRipsPreimage.lean new file mode 100644 index 0000000000000000000000000000000000000000..1d384507341e3cc89c6a1387bd72564cca8c3354 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ComponentRipsPreimage.lean @@ -0,0 +1,57 @@ +import OAI.Topology.CoarseAssembly.ComponentInclusion +import OAI.Topology.CoarseAssembly.RipsMapCalculus + +namespace OAI + +/-! # Exact component preimages for the geometric inclusions -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +variable {Q P : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + +theorem componentRips_preimage (o : ∀ i, Q i) (p : ∀ i, P i) + (e : ∀ i, Q i ↪ P i) (r : ℝ) + (he : letI := separatedMetric o; letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y) + (i : ℕ) : + letI := separatedMetric o + letI := separatedMetric p + ∀ x : Point (Sigma Q) r, + mapPoint (componentEmbedding e) he x ∈ Set.range (separatedRipsEmbedding p r i) ↔ + x ∈ Set.range (separatedRipsEmbedding o r i) := by + let := separatedMetric o + let := separatedMetric p + intro x + change mapPoint (componentEmbedding e) he x ∈ Set.range (mapPoint (separatedComponent i) + (fun a b => ((separatedComponent_isometry p i).dist_eq a b).le)) ↔ + x ∈ Set.range (mapPoint (separatedComponent i) + (fun a b => ((separatedComponent_isometry o i).dist_eq a b).le)) + rw [mapPoint_range (separatedComponent i) (separatedComponent_isometry p i), + mapPoint_range (separatedComponent i) (separatedComponent_isometry o i)] + constructor + · intro hx y hy + have hmem : componentEmbedding e y ∈ (mapPoint (componentEmbedding e) he x).weight.support := by + apply Finsupp.mem_support_iff.mpr + rw [mapPoint_weight_self] + exact Finsupp.mem_support_iff.mp hy + obtain ⟨z, hz⟩ := hx hmem + have hi : i = y.1 := congrArg Sigma.fst hz + rcases y with ⟨j, y⟩ + dsimp only at hi + subst j + exact ⟨y, rfl⟩ + · intro hx y hy + change y ∈ (x.weight.embDomain (componentEmbedding e)).support at hy + rw [Finsupp.support_embDomain, Finset.mem_map] at hy + obtain ⟨z, hz, rfl⟩ := hy + obtain ⟨a, ha⟩ := hx hz + rw [← ha] + exact ⟨e i a, rfl⟩ + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConcreteIndexDiagrams.lean b/lean/OAI/Topology/CoarseAssembly/ConcreteIndexDiagrams.lean new file mode 100644 index 0000000000000000000000000000000000000000..1b854d50c7fb66017f82b08df41c33ab889e62d8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConcreteIndexDiagrams.lean @@ -0,0 +1,106 @@ +import OAI.Topology.CoarseAssembly.ConcreteIndexFamilies +import OAI.Topology.CoarseAssembly.InclusionFunctoriality +import OAI.Topology.CoarseAssembly.ComponentInclusion + +namespace OAI + +/-! # The exact geometric and Roe squares for the two boundary inclusions -/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic DiscreteRoe Rips Congruence + +local instance concreteDiscEq (i : ℕ) : DecidableEq (Disc i) := Classical.decEq _ +local instance concreteDiagramBoundaryEq (i : ℕ) : DecidableEq (BoundaryComponent i) := Classical.decEq _ +local instance concreteDiagramFiberEq (i : ℕ) : DecidableEq (FiberVertex i) := Classical.decEq _ +local instance concreteDiagramBoundaryComponentMetric (i : ℕ) : MetricSpace (BoundaryComponent i) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit i +local instance concreteDiagramBoundaryMetric : MetricSpace BoundaryVertex := + boundaryMetric elementaryMoves chosenHolonomyUnit +local instance concreteDiagramFiberComponentMetric (i : ℕ) : MetricSpace (FiberVertex i) := + componentMetric elementaryMoves chosenHolonomyUnit i +local instance concreteDiagramTotalMetric : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +local instance diagramBoundaryUnionMetric : MetricSpace (Sigma BoundaryComponent) := separatedMetric boundaryRoot +local instance diagramFiberUnionMetric : MetricSpace (Sigma FiberVertex) := separatedMetric fiberBoundaryBase +local instance diagramBoundaryRoeAdd : AddCommMonoid (algebra (X := Sigma BoundaryComponent) (H := AmpleSpace)) := inferInstance +local instance diagramFiberRoeAdd : AddCommMonoid (algebra (X := Sigma FiberVertex) (H := AmpleSpace)) := inferInstance +local instance diagramBaseRoeAdd : AddCommMonoid (letI := separatedBaseEq; algebra (X := BaseUnion) (H := AmpleSpace)) := by + letI := separatedBaseEq + infer_instance + +theorem boundaryBaseComponents_nonexpanding : + letI := separatedMetric boundaryRoot + ∀ x y, dist (componentEmbedding boundaryComponentToBase x) + (componentEmbedding boundaryComponentToBase y) ≤ dist x y := + componentEmbedding_nonexpanding boundaryRoot discBoundaryBase boundaryComponentToBase + boundaryComponentToBase_nonexpanding (fun _ => rfl) + +theorem boundaryFiberComponent_nonexpanding (i : ℕ) (x y : BoundaryComponent i) : + dist (boundaryFiberEmbedding i x) (boundaryFiberEmbedding i y) ≤ dist x y := le_rfl + +theorem boundaryFiberComponents_nonexpanding : + letI := separatedMetric boundaryRoot + letI := separatedMetric fiberBoundaryBase + ∀ x y, dist (componentEmbedding boundaryFiberEmbedding x) + (componentEmbedding boundaryFiberEmbedding y) ≤ dist x y := + componentEmbedding_nonexpanding boundaryRoot fiberBoundaryBase boundaryFiberEmbedding + boundaryFiberComponent_nonexpanding (fun _ => rfl) + +def boundaryBaseComponentsRoeHom : + (letI := separatedMetric boundaryRoot; + algebra (X := Sigma BoundaryComponent) (H := AmpleSpace)) →⋆ₙₐ[ℂ] + (letI := separatedBaseEq; algebra (X := BaseUnion) (H := AmpleSpace)) := by + let := separatedMetric boundaryRoot + exact @inclusionHom (Sigma BoundaryComponent) BaseUnion AmpleSpace _ separatedBaseEq + _ _ _ _ _ (componentEmbedding boundaryComponentToBase) boundaryBaseComponents_nonexpanding + +def boundaryFiberComponentsRoeHom : + (letI := separatedMetric boundaryRoot; + algebra (X := Sigma BoundaryComponent) (H := AmpleSpace)) →⋆ₙₐ[ℂ] + (letI := separatedMetric fiberBoundaryBase; + algebra (X := Sigma FiberVertex) (H := AmpleSpace)) := by + let := separatedMetric boundaryRoot + let := separatedMetric fiberBoundaryBase + exact inclusionHom (X := Sigma BoundaryComponent) (Y := Sigma FiberVertex) (H := AmpleSpace) + (componentEmbedding boundaryFiberEmbedding) boundaryFiberComponents_nonexpanding + +theorem boundaryBaseComponentsRoeHom_eq : + baseReindexRoeHom.comp boundaryBaseComponentsRoeHom = + boundaryBaseRoeHom.comp boundaryReindexRoeHom := by + let := separatedMetric boundaryRoot + have hf := @inclusionHom_comp (Sigma BoundaryComponent) BaseUnion BaseUnion AmpleSpace + _ separatedBaseEq baseUnionDecidableEq _ _ _ _ _ _ + (componentEmbedding boundaryComponentToBase) (Function.Embedding.refl BaseUnion) + boundaryBaseComponents_nonexpanding (fun _ _ => le_rfl) + have hb := inclusionHom_comp (X := Sigma BoundaryComponent) (Y := BoundaryVertex) (Z := BaseUnion) + (H := AmpleSpace) boundaryReindex.toEmbedding boundaryToBase + (fun x y => (boundaryReindex_dist elementaryMoves chosenHolonomyUnit x y).le) + (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit) + exact hf.trans hb.symm + +theorem boundaryFiberComponentsRoeHom_eq : + fiberReindexRoeHom.comp boundaryFiberComponentsRoeHom = + boundaryTotalRoeHom.comp boundaryReindexRoeHom := by + let := separatedMetric boundaryRoot + let := separatedMetric fiberBoundaryBase + have hf := inclusionHom_comp (X := Sigma BoundaryComponent) (Y := Sigma FiberVertex) + (Z := VertexUnion) (H := AmpleSpace) + (componentEmbedding boundaryFiberEmbedding) totalToFiber.symm.toEmbedding + boundaryFiberComponents_nonexpanding + (fun x y => ((equiv_inverse_isometry totalToFiber + (Isometry.of_dist_eq totalToFiber_dist)).dist_eq x y).le) + have hb := inclusionHom_comp (X := Sigma BoundaryComponent) (Y := BoundaryVertex) + (Z := VertexUnion) (H := AmpleSpace) boundaryReindex.toEmbedding boundaryToVertex + (fun x y => (boundaryReindex_dist elementaryMoves chosenHolonomyUnit x y).le) + (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit) + exact hf.trans hb.symm + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConcreteIndexFamilies.lean b/lean/OAI/Topology/CoarseAssembly/ConcreteIndexFamilies.lean new file mode 100644 index 0000000000000000000000000000000000000000..4358003a4cb407aecf16f17411f002f6ef923bb4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConcreteIndexFamilies.lean @@ -0,0 +1,59 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.SeparatedCoarseAssembly +import OAI.Topology.CoarseAssembly.IndexFamilyTransport +import OAI.Topology.CoarseAssembly.ExplicitBoundaryRepresentative +import OAI.Topology.CoarseAssembly.RipsReindex + +namespace OAI + +/-! # The three constructed analytic index families used by the counterexample -/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic DiscreteRoe Rips Congruence + +local instance constructedDiscEq (i : ℕ) : DecidableEq (Disc i) := Classical.decEq _ +local instance constructedBoundaryComponentEq (i : ℕ) : DecidableEq (BoundaryComponent i) := Classical.decEq _ +attribute [local instance] OAI.CoarseAssembly.constructedFiberComponentEq + +local instance constructedBoundaryComponentMetric (i : ℕ) : MetricSpace (BoundaryComponent i) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit i +local instance constructedBoundaryMetric : MetricSpace BoundaryVertex := + boundaryMetric elementaryMoves chosenHolonomyUnit +attribute [local instance] OAI.CoarseAssembly.constructedFiberComponentMetric + +attribute [local instance] OAI.CoarseAssembly.constructedTotalMetric + +private theorem boundaryReindex_isometry : + letI := separatedMetric boundaryRoot + Isometry boundaryReindex := by + let := separatedMetric boundaryRoot + exact Isometry.of_dist_eq (boundaryReindex_dist elementaryMoves chosenHolonomyUnit) + +def boundaryInverseCoarsening : CoarseningMorphism (coarsening BoundaryVertex) + (letI := separatedMetric boundaryRoot; coarsening (Sigma BoundaryComponent)) := by + let := separatedMetric boundaryRoot + exact embeddingCoarsening boundaryReindex.symm.toEmbedding + (fun x y => ((equiv_inverse_isometry boundaryReindex boundaryReindex_isometry).dist_eq x y).le) + +def constructedBoundaryIndex : CompatibleIndexFamily (coarsening BoundaryVertex) BoundaryRoe := + (separatedIndexFamily (Q := BoundaryComponent) boundaryRoot).transport boundaryInverseCoarsening boundaryReindexRoeHom + +def separatedBaseEq : DecidableEq BaseUnion := + @instDecidableEqSigma ℕ Disc instDecidableEqNat constructedDiscEq + +def baseReindexRoeHom : + (letI := separatedBaseEq; algebra (X := BaseUnion) (H := AmpleSpace)) →⋆ₙₐ[ℂ] BaseRoe := + @inclusionHom BaseUnion BaseUnion AmpleSpace separatedBaseEq baseUnionDecidableEq + _ _ _ _ _ (Function.Embedding.refl BaseUnion) (fun _ _ => le_rfl) + +def constructedBaseIndex : CompatibleIndexFamily (coarsening BaseUnion) BaseRoe := + (separatedIndexFamily (Q := Disc) discBoundaryBase).mapTarget baseReindexRoeHom + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConcreteIndexSquares.lean b/lean/OAI/Topology/CoarseAssembly/ConcreteIndexSquares.lean new file mode 100644 index 0000000000000000000000000000000000000000..70b5e41bbb6d45f4a1455e08bfd2bb02f7e3047c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConcreteIndexSquares.lean @@ -0,0 +1,52 @@ +import OAI.Topology.CoarseAssembly.ConcreteIndexDiagrams + +namespace OAI + +/-! # Exact Rips-map squares for the constructed index families -/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic DiscreteRoe Rips Congruence + +local instance squareDiscEq (i : ℕ) : DecidableEq (Disc i) := Classical.decEq _ +local instance indexSquareBoundaryEq (i : ℕ) : DecidableEq (BoundaryComponent i) := Classical.decEq _ +local instance indexSquareFiberEq (i : ℕ) : DecidableEq (FiberVertex i) := Classical.decEq _ +local instance indexSquareBoundaryComponentMetric (i : ℕ) : MetricSpace (BoundaryComponent i) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit i +local instance indexSquareBoundaryUnionMetric : MetricSpace (Sigma BoundaryComponent) := separatedMetric boundaryRoot +local instance indexSquareBoundaryMetric : MetricSpace BoundaryVertex := + boundaryMetric elementaryMoves chosenHolonomyUnit +local instance indexSquareFiberComponentMetric (i : ℕ) : MetricSpace (FiberVertex i) := + componentMetric elementaryMoves chosenHolonomyUnit i +local instance indexSquareFiberUnionMetric : MetricSpace (Sigma FiberVertex) := separatedMetric fiberBoundaryBase +local instance indexSquareTotalMetric : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnit + +def boundaryBaseComponentsMap (r : ℝ) : CocompactMap (Point (Sigma BoundaryComponent) r) (Point BaseUnion r) := + embeddingMap (componentEmbedding boundaryComponentToBase) boundaryBaseComponents_nonexpanding r + +def boundaryFiberComponentsMap (r : ℝ) : + CocompactMap (Point (Sigma BoundaryComponent) r) (Point (Sigma FiberVertex) r) := + embeddingMap (componentEmbedding boundaryFiberEmbedding) boundaryFiberComponents_nonexpanding r + +theorem boundaryBaseComponentsMap_eq (n : ℕ) : + (boundaryBaseComponentsMap n).comp (boundaryInverseCoarsening.atScale n) = + boundaryBaseCoarsening.atScale n := by + change (embeddingMap _ _ _).comp (embeddingMap _ _ _) = embeddingMap _ _ _ + rw [embeddingMap_comp] + rfl + +theorem boundaryFiberComponentsMap_eq (n : ℕ) : + (boundaryFiberComponentsMap n).comp (boundaryInverseCoarsening.atScale n) = + (totalToFiberCoarsening.atScale n).comp (boundaryTotalCoarsening.atScale n) := by + change (embeddingMap _ _ _).comp (embeddingMap _ _ _) = + (embeddingMap _ _ _).comp (embeddingMap _ _ _) + rw [embeddingMap_comp, embeddingMap_comp] + rfl + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConcretePersistence.lean b/lean/OAI/Topology/CoarseAssembly/ConcretePersistence.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce721766e36acd5cdc5e86f046df636d4e10bac8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConcretePersistence.lean @@ -0,0 +1,43 @@ +import OAI.Topology.CoarseAssembly.HexagonSides +import OAI.Topology.CoarseAssembly.FiberedPersistence +import OAI.Topology.CoarseAssembly.KazhdanInput + +namespace OAI + +/-! # Persistence with the geometric boundary input discharged + +The actual six-side boundary walks are now substituted into the graph-family +detector. Only the stated published circle pairing and countable-additivity +inputs remain in the nonvanishing conclusions. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance concretePersistenceMetric1 : MetricSpace FiberedUnion := componentUnionMetric elementaryMoves chosenHolonomyUnit + +def concreteFiberClass (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : KX1 FiberedUnion := + fiberedBoundaryClass elementaryMoves + (hexagonalBoundaryWalks.fiberWalk elementaryMoves chosenHolonomyUnit) input hadd + +theorem concreteFiberClass_infinite_order (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) (n : ℤ) (hn : n ≠ 0) : + n • concreteFiberClass input hadd ≠ 0 := + fiberedBoundaryClass_infinite_order elementaryMoves + (hexagonalBoundaryWalks.fiberWalk elementaryMoves chosenHolonomyUnit) input hadd + (hexagonalBoundaryWalks.fiber_charge_one elementaryMoves chosenHolonomyUnit) n hn + +theorem concreteFiberClass_rational_ne_zero (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : + (1 : ℚ) ⊗ₜ[ℤ] concreteFiberClass input hadd ≠ 0 := + rationalization_ne_zero _ (concreteFiberClass_infinite_order input hadd) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConcreteSpaces.lean b/lean/OAI/Topology/CoarseAssembly/ConcreteSpaces.lean new file mode 100644 index 0000000000000000000000000000000000000000..70d22f20d36256787c0ac3dd4c630572c62c38ee --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConcreteSpaces.lean @@ -0,0 +1,108 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.GraphMetric +import OAI.Topology.CoarseAssembly.SeparatedGeometry +import OAI.Topology.CoarseAssembly.FiberDegree +import OAI.Topology.CoarseAssembly.FiberConnected +import Mathlib.Topology.MetricSpace.TransferInstance + +namespace OAI + +/-! # The actual base and fibered coarse unions + +Both metrics restrict to shortest-path metrics on the components. The +fibered union is indexed by base vertices so its Hilbert module has exactly +the form used by the finite-fiber transfer theorem. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +instance discGraphMetric (j : ℕ) : MetricSpace (Disc j) := + graphMetricOrDiscrete (discGraph j) + +theorem discGraphMetric_eq (j : ℕ) : + discGraphMetric j = connectedGraphMetric (discGraph j) (discGraph_connected j) := + graphMetricOrDiscrete_eq _ _ + +instance baseUnionMetric : MetricSpace BaseUnion := separatedMetric discBoundaryBase + +theorem componentMetric_eq (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) (j : ℕ) : + componentMetric S t j = connectedGraphMetric (fiberedGraph S t j) (fiberedGraph_connected S t j) := + graphMetricOrDiscrete_eq _ _ + +theorem baseUnion_uniform_balls : UniformFiniteBalls BaseUnion := by + classical + apply separated_uniform_finite_balls discBoundaryBase + intro R hR + refine ⟨8 ^ ⌈R⌉₊, ?_⟩ + intro j u + rw [discGraphMetric_eq] + exact graphMetric_ball_bound (discGraph j) (discGraph_connected j) baseNeighbors 7 + (fun x y h => (mem_baseNeighbors x y).mpr (Or.inr h)) card_baseNeighbors_le R u + +theorem baseUnion_separated (x y : BaseUnion) (h : x ≠ y) : 1 ≤ dist x y := + separated_uniform_discrete discBoundaryBase + (fun j _x _y h => by + rw [discGraphMetric_eq, ← graphMetric_eq] + exact graphMetric_separated (discGraph j) (discGraph_connected j) h) x y h + +theorem componentUnion_uniform_balls (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + @UniformFiniteBalls ((j : ℕ) × FiberVertex j) + (componentUnionMetric S t).toPseudoMetricSpace := by + classical + let := componentMetric S t + apply separated_uniform_finite_balls fiberBoundaryBase + intro R hR + refine ⟨(7 * (symmetricMoves S).card * 2 ^ 9 + 1) ^ ⌈R⌉₊, ?_⟩ + intro j x + change ∃ b : Finset (FiberVertex j), + (∀ y, y ∈ b ↔ @dist _ (componentMetric S t j).toDist x y ≤ R) ∧ _ + rw [componentMetric_eq] + exact graphMetric_ball_bound (fiberedGraph S t j) (fiberedGraph_connected S t j) + (fiberedNeighbors S t) _ + (fun x y h => (mem_fiberedNeighbors S t x y).mpr h) + (card_fiberedNeighbors_le S t) R x + +/-- Transport an exact finite-ball bound across an isometric equivalence. -/ +theorem uniform_balls_of_equiv {X Y : Type*} [PseudoMetricSpace X] [PseudoMetricSpace Y] + (e : X ≃ Y) (he : ∀ x y, dist (e x) (e y) = dist x y) + (hY : UniformFiniteBalls Y) : UniformFiniteBalls X := by + classical + intro R hR + obtain ⟨N, hN⟩ := hY R hR + refine ⟨N, ?_⟩ + intro x + obtain ⟨b, hb, hcard⟩ := hN (e x) + refine ⟨b.map e.symm.toEmbedding, ?_, ?_⟩ + · intro y + simp only [Finset.mem_map_equiv, Equiv.symm_symm, hb, he] + · simpa only [Finset.card_map] using hcard + +theorem vertexUnion_uniform_balls (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + @UniformFiniteBalls VertexUnion (vertexUnionMetric S t).toPseudoMetricSpace := by + let := componentUnionMetric S t + let := vertexUnionMetric S t + apply uniform_balls_of_equiv (Equiv.sigmaAssoc (fun j u => Quotient (discDepth j u))) + (fun _ _ => rfl) + exact componentUnion_uniform_balls S t + +theorem vertexUnion_separated (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + (x y : VertexUnion) (h : x ≠ y) : + 1 ≤ @dist VertexUnion (vertexUnionMetric S t).toDist x y := by + let := componentMetric S t + let e := Equiv.sigmaAssoc (fun j u => Quotient (discDepth j u)) + exact separated_uniform_discrete fiberBoundaryBase + (fun j _x _y h => by + change 1 ≤ @dist _ (componentMetric S t j).toDist _x _y + rw [componentMetric_eq, ← graphMetric_eq] + exact graphMetric_separated (fiberedGraph S t j) + (fiberedGraph_connected S t j) h) (e x) (e y) (fun he => h (e.injective he)) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConcreteTransfer.lean b/lean/OAI/Topology/CoarseAssembly/ConcreteTransfer.lean new file mode 100644 index 0000000000000000000000000000000000000000..537b4b8464252138cbc2379928ea97aa910d525e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConcreteTransfer.lean @@ -0,0 +1,51 @@ +import OAI.Topology.CoarseAssembly.ConcreteTransferMaps + +namespace OAI + +/-! # The transfer on the actual coarse spaces + +All metric and inter-fiber hypotheses have been discharged. Only the +averaging projection approximation remains in this intermediate theorem; +it is an own-paper obligation, not an assumed published theorem. +-/ + +noncomputable section + +namespace CoarseAssembly + +open DiscreteRoe +open scoped Topology + +theorem UniformFiniteBalls.finite_closedBall {X : Type*} [PseudoMetricSpace X] + (hX : UniformFiniteBalls X) (x : X) (r : ℝ) : (Metric.closedBall x r).Finite := by + by_cases hr : 0 ≤ r + · obtain ⟨N, hN⟩ := hX r hr + obtain ⟨b, hb, hcard⟩ := hN x + apply b.finite_toSet.subset + intro y hy + exact (hb y).mpr (by simpa only [Metric.mem_closedBall, dist_comm] using hy) + · have he : Metric.closedBall x r = ∅ := Metric.closedBall_eq_empty.mpr (lt_of_not_ge hr) + rw [he] + exact Set.finite_empty + +theorem concrete_transfer_of_approximation + (S : Finset Congruence.ArithmeticGroup) (t : ℤ_[2]ˣ) + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + (Pn : ℕ → Operator VertexUnion H) + (hlim : Filter.Tendsto Pn Filter.atTop (nhds (fiberProjection BaseFiber))) : + letI : MetricSpace VertexUnion := vertexUnionMetric S t + (∀ n, ∃ r : ℝ, 0 ≤ r ∧ PropagationLE r (Pn n)) → + MapsToRoe (fiberEmbedding (H := H) BaseFiber) := by + classical + let : MetricSpace VertexUnion := vertexUnionMetric S t + intro hprop + have hX : ∀ x : VertexUnion, ∀ r : ℝ, (Metric.closedBall x r).Finite := + (vertexUnion_uniform_balls S t).finite_closedBall + exact finite_fiber_transfer (D := BaseUnion) (Q := BaseFiber) (H := H) + baseUnion_uniform_balls hX (concrete_controlled_fiber_maps S t) Pn hlim hprop + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConcreteTransferMaps.lean b/lean/OAI/Topology/CoarseAssembly/ConcreteTransferMaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..493be1acf4d0a7f693b322248f1c8db33d9295ff --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConcreteTransferMaps.lean @@ -0,0 +1,112 @@ +import OAI.Topology.CoarseAssembly.ConcreteSpaces +import Mathlib.Topology.MetricSpace.Bounded + +namespace OAI + +/-! # The controlled fiber maps on the separated coarse union + +Within a component these are compositions of graph-edge maps. On the +finitely many relevant cross-component pairs they are rank-one constant +maps. This discharges the second geometric hypothesis of the transfer +criterion on the actual coarse spaces. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +variable (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + +theorem vertexUnion_dist_same {j : ℕ} (u v : Disc j) + (q : Quotient (discDepth j u)) (r : Quotient (discDepth j v)) : + @dist VertexUnion (vertexUnionMetric S t).toDist + ⟨⟨j, u⟩, q⟩ ⟨⟨j, v⟩, r⟩ = + ((fiberedGraph S t j).dist ⟨u, q⟩ ⟨v, r⟩ : ℝ) := by + let := componentMetric S t + have hdist := separatedDist_same fiberBoundaryBase j ⟨u, q⟩ ⟨v, r⟩ + change _ = @dist _ (componentMetric S t j).toDist ⟨u, q⟩ ⟨v, r⟩ at hdist + rw [componentMetric_eq S t j] at hdist + exact hdist + +private def constantMap (u v : BaseUnion) : + lp (fun _ : BaseFiber v => ℂ) 2 →L[ℂ] lp (fun _ : BaseFiber u => ℂ) 2 := + (fiberConstantIsometry (BaseFiber u)).toContinuousLinearMap.comp + (fiberConstantIsometry (BaseFiber v)).toContinuousLinearMap.adjoint + +private theorem constantMap_norm (u v : BaseUnion) : ‖constantMap u v‖ ≤ 1 := by + apply (ContinuousLinearMap.opNorm_comp_le _ _).trans + have hu := (fiberConstantIsometry (H := ℂ) (BaseFiber u)).norm_toContinuousLinearMap_le + have hv := (fiberConstantIsometry (H := ℂ) (BaseFiber v)).norm_toContinuousLinearMap_le + rw [← LinearIsometryEquiv.norm_map (ContinuousLinearMap.adjoint)] at hv + exact (mul_le_mul hu hv (norm_nonneg _) zero_le_one).trans_eq (one_mul 1) + +private theorem constantMap_constant (u v : BaseUnion) : + constantMap u v (fiberConstant (BaseFiber v) (1 : ℂ)) = + fiberConstant (BaseFiber u) 1 := by + change (fiberConstantIsometry (BaseFiber u)) + ((fiberConstantIsometry (BaseFiber v)).toContinuousLinearMap.adjoint + ((fiberConstantIsometry (BaseFiber v)) (1 : ℂ))) = _ + rw [adjoint_apply_isometry] + rfl + +theorem concrete_controlled_fiber_maps : + letI : MetricSpace VertexUnion := vertexUnionMetric S t + ControlledFiberMaps BaseFiber := by + classical + let : MetricSpace VertexUnion := vertexUnionMetric S t + intro R hR + let e := Equiv.sigmaAssoc (fun j u => Quotient (discDepth j u)) + let initial := componentPrefix (V := FiberVertex) ⌈R⌉₊ + let W : Set VertexUnion := e.symm '' (initial : Set ((j : ℕ) × FiberVertex j)) + have hW : W.Finite := initial.finite_toSet.image e.symm + obtain ⟨B, hB⟩ := Metric.isBounded_iff.mp hW.isBounded + let s : ℝ := max (⌈R⌉₊ : ℝ) B + have hs : 0 ≤ s := (Nat.cast_nonneg _).trans (le_max_left _ _) + have hex : ∀ u v : BaseUnion, ∃ O : + lp (fun _ : BaseFiber v => ℂ) 2 →L[ℂ] lp (fun _ : BaseFiber u => ℂ) 2, + dist u v ≤ R → ‖O‖ ≤ 1 ∧ + O (fiberConstant (BaseFiber v) (1 : ℂ)) = fiberConstant (BaseFiber u) 1 ∧ + ∀ q r, s < dist (⟨u, q⟩ : VertexUnion) ⟨v, r⟩ → O (lp.single 2 r 1) q = 0 := by + rintro ⟨i, u⟩ ⟨j, v⟩ + by_cases hij : i = j + · subst j + obtain ⟨p, hp⟩ := (discGraph_connected i).exists_walk_length_eq_dist v u + obtain ⟨O, hO, hOc, hOs⟩ := exists_base_walk_operator S t p + refine ⟨O, fun huv => ⟨hO, hOc, ?_⟩⟩ + intro q r hdist + by_contra hn + obtain ⟨w, hw⟩ := hOs r q hn + have hbase : ((discGraph i).dist v u : ℝ) ≤ R := by + change separatedDist discBoundaryBase ⟨i, u⟩ ⟨i, v⟩ ≤ R at huv + rw [separatedDist_same, discGraphMetric_eq] at huv + change ((discGraph i).dist u v : ℝ) ≤ R at huv + rwa [SimpleGraph.dist_comm] + have hlen : (p.length : ℝ) ≤ (⌈R⌉₊ : ℝ) := by + rw [hp] + exact hbase.trans (Nat.le_ceil R) + have hup : dist (⟨⟨i, u⟩, q⟩ : VertexUnion) ⟨⟨i, v⟩, r⟩ ≤ s := by + rw [dist_comm, vertexUnion_dist_same S t] + exact (show ((fiberedGraph S t i).dist ⟨v, r⟩ ⟨u, q⟩ : ℝ) ≤ p.length by + exact_mod_cast (SimpleGraph.dist_le w).trans_eq hw).trans (hlen.trans (le_max_left _ _)) + exact (not_lt_of_ge hup) hdist + · refine ⟨constantMap ⟨i, u⟩ ⟨j, v⟩, fun huv => + ⟨constantMap_norm _ _, constantMap_constant _ _, ?_⟩⟩ + intro q r hdist + have hidx := separatedDist_indices discBoundaryBase ⟨i, u⟩ ⟨j, v⟩ hij huv + have hi : i ≤ ⌈R⌉₊ := by exact_mod_cast hidx.1.trans (Nat.le_ceil R) + have hj : j ≤ ⌈R⌉₊ := by exact_mod_cast hidx.2.trans (Nat.le_ceil R) + have hq : (⟨⟨i, u⟩, q⟩ : VertexUnion) ∈ W := by + exact ⟨⟨i, ⟨u, q⟩⟩, (mem_componentPrefix _ _).mpr hi, rfl⟩ + have hr : (⟨⟨j, v⟩, r⟩ : VertexUnion) ∈ W := by + exact ⟨⟨j, ⟨v, r⟩⟩, (mem_componentPrefix _ _).mpr hj, rfl⟩ + exact False.elim ((not_lt_of_ge ((hB hq hr).trans (le_max_right _ _))) hdist) + choose O hO using hex + exact ⟨s, hs, O, hO⟩ + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CongruenceEdgeOperators.lean b/lean/OAI/Topology/CoarseAssembly/CongruenceEdgeOperators.lean new file mode 100644 index 0000000000000000000000000000000000000000..102aadf60d269607b1f2c4b395bcdd3517834389 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CongruenceEdgeOperators.lean @@ -0,0 +1,88 @@ +import OAI.Topology.CoarseAssembly.CongruenceSurjective +import OAI.Topology.CoarseAssembly.FiniteFiberMaps + +namespace OAI + +/-! # The concrete one-step congruence-fiber operators + +The normalized child map is now instantiated with the proved surjective +congruence reduction. Its adjoint and the equal-depth permutations preserve +constants and have coefficients supported precisely on the prescribed +right-holonomy edge relation. +-/ + +noncomputable section + +namespace CoarseAssembly.Congruence + +def childIsometry (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) : + lp (fun _ : Quotient k => ℂ) 2 →ₗᵢ[ℂ] lp (fun _ : Quotient (k + 1) => ℂ) 2 := by + classical + exact twistedQuotientCopy (quotientMap (Nat.le_succ k)) + (quotientMap_successor_surjective k) (holonomy t k ^ a) + +theorem childIsometry_constant (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) : + childIsometry t k a (fiberConstant (Quotient k) (1 : ℂ)) = + fiberConstant (Quotient (k + 1)) 1 := by + classical + exact twistedQuotientCopy_constant _ _ _ + +theorem childAdjoint_constant (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) : + (childIsometry t k a).toContinuousLinearMap.adjoint + (fiberConstant (Quotient (k + 1)) (1 : ℂ)) = + fiberConstant (Quotient k) 1 := by + rw [← childIsometry_constant t k a, adjoint_apply_isometry] + +theorem childIsometry_support (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) + (q : Quotient k) (z : Quotient (k + 1)) + (hne : quotientMap (Nat.le_succ k) z ≠ q * holonomy t k ^ a) : + childIsometry t k a (lp.single 2 q (1 : ℂ)) z = 0 := by + classical + let f := quotientMap (Nat.le_succ k) + change twistedQuotientCopy f (quotientMap_successor_surjective k) (holonomy t k ^ a) + (lp.single 2 q 1) z = 0 + rw [twistedQuotientCopy_apply] + have harg : f z * (holonomy t k ^ a)⁻¹ ≠ q := by + intro he + apply hne + calc + f z = (f z * (holonomy t k ^ a)⁻¹) * holonomy t k ^ a := by group + _ = q * holonomy t k ^ a := by rw [he] + rw [lp.single_apply_ne 2 q 1 harg, mul_zero] + +theorem childAdjoint_support (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) + (q : Quotient k) (z : Quotient (k + 1)) + (hne : quotientMap (Nat.le_succ k) z ≠ q * holonomy t k ^ a) : + (childIsometry t k a).toContinuousLinearMap.adjoint (lp.single 2 z (1 : ℂ)) q = 0 := by + have he := ContinuousLinearMap.adjoint_inner_right + (childIsometry t k a).toContinuousLinearMap (lp.single 2 q 1) (lp.single 2 z 1) + simp only [lp.inner_single_left, lp.inner_single_right] at he + change inner ℂ (1 : ℂ) (_) = inner ℂ (childIsometry t k a (lp.single 2 q 1) z) 1 at he + rw [childIsometry_support t k a q z hne] at he + simpa only [RCLike.inner_apply, map_one, map_zero, mul_one, mul_zero, inner_zero_left] using he + +def sameLevelIsometry (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) : + lp (fun _ : Quotient k => ℂ) 2 ≃ₗᵢ[ℂ] lp (fun _ : Quotient k => ℂ) 2 := + reindexFiber (Equiv.mulRight (holonomy t k ^ a)) + +theorem sameLevelIsometry_constant (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) : + sameLevelIsometry t k a (fiberConstant (Quotient k) (1 : ℂ)) = + fiberConstant (Quotient k) 1 := reindexFiber_constant _ _ + +theorem sameLevelIsometry_support (t : ℤ_[2]ˣ) (k : ℕ) (a : ℤ) + (q z : Quotient k) (hne : z ≠ q * holonomy t k ^ a) : + sameLevelIsometry t k a (lp.single 2 q (1 : ℂ)) z = 0 := by + change (lp.single (E := fun _ : Quotient k => ℂ) 2 q 1) + (z * (holonomy t k ^ a)⁻¹) = 0 + apply lp.single_apply_ne + intro he + apply hne + calc + z = (z * (holonomy t k ^ a)⁻¹) * holonomy t k ^ a := by group + _ = q * holonomy t k ^ a := by rw [he] + +end CoarseAssembly.Congruence + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CongruenceElementary.lean b/lean/OAI/Topology/CoarseAssembly/CongruenceElementary.lean new file mode 100644 index 0000000000000000000000000000000000000000..3e6ed4d625be18ee95279f9d7392d7b72f193dc1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CongruenceElementary.lean @@ -0,0 +1,333 @@ +import OAI.Topology.CoarseAssembly.CongruenceSpectral + +namespace OAI + +/-! # Elementary generators in the finite congruence quotients -/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence +open NuclearUltrapower + +lemma reduce_transvection (k : ℕ) {i j : Fin 3} (h : i ≠ j) (a : ℤ) : + reduce k (Matrix.SpecialLinearGroup.transvection h a) = + Matrix.SpecialLinearGroup.transvection h (a : ZMod (2 ^ k)) := by + apply Subtype.ext + ext r s + simp [reduce, Matrix.SpecialLinearGroup.map_apply_coe, + Matrix.SpecialLinearGroup.transvection_coe, Matrix.single, Matrix.one_apply] + +lemma transvection_mem_elementaryReduction (k : ℕ) {i j : Fin 3} (h : i ≠ j) + (a : ZMod (2 ^ k)) : + Matrix.SpecialLinearGroup.transvection h a ∈ (elementaryReduction k).range := by + refine ⟨Elementary.elementaryTransvection h (a.val : ℤ), ?_⟩ + change reduce k (Matrix.SpecialLinearGroup.transvection h (a.val : ℤ)) = _ + rw [reduce_transvection] + simp only [Int.cast_natCast, ZMod.natCast_zmod_val] + +lemma elementaryReduction_zero_surjective : Function.Surjective (elementaryReduction 0) := by + intro q + exact ⟨1, Subsingleton.elim _ _⟩ + +lemma elementaryReduction_one_surjective : Function.Surjective (elementaryReduction 1) := by + let : Fact (Nat.Prime (2 ^ 1)) := ⟨by norm_num⟩ + intro q + have hmem : q ∈ (elementaryReduction 1).range := by + apply Matrix.SpecialLinearGroup.diagonal_transvection_induction' + (fun M => M ∈ (elementaryReduction 1).range) q + · intro i j hij c hc + have hc1 : c = 1 := by + change ZMod 2 at c + change c ≠ (0 : ZMod 2) at hc + fin_cases c + · exact (hc rfl).elim + · rfl + subst c + have hdiag : Matrix.SpecialLinearGroup.diag2n hij (1 : ZMod (2 ^ 1)) (by simp) = 1 := by + apply Subtype.ext + ext r s + simp [Matrix.SpecialLinearGroup.diag2n_coe, Matrix.one_apply] + rw [hdiag] + exact one_mem _ + · intro i j hij a + exact transvection_mem_elementaryReduction 1 hij a + · intro A B hA hB + exact mul_mem hA hB + exact hmem + +lemma elementary_row_same (k : ℕ) {i j : Fin 3} (h : i ≠ j) + (a : ZMod (2 ^ k)) (q : Congruence.Quotient k) (c : Fin 3) : + (Matrix.SpecialLinearGroup.transvection h a * q).val i c = q.val i c + a * q.val j c := by + change (Matrix.transvection i j a * q.val) i c = _ + simp only [Matrix.transvection_mul_apply_same] + +lemma elementary_row_other (k : ℕ) {i j : Fin 3} (h : i ≠ j) + (a : ZMod (2 ^ k)) (q : Congruence.Quotient k) (r c : Fin 3) (hr : r ≠ i) : + (Matrix.SpecialLinearGroup.transvection h a * q).val r c = q.val r c := by + change (Matrix.transvection i j a * q.val) r c = _ + exact Matrix.transvection_mul_apply_of_ne i j r c hr a q.val + +lemma upperUnitriangular_mem_elementaryReduction (k : ℕ) (q : Congruence.Quotient k) + (h00 : q.val 0 0 = 1) (h11 : q.val 1 1 = 1) (h22 : q.val 2 2 = 1) + (h10 : q.val 1 0 = 0) (h20 : q.val 2 0 = 0) (h21 : q.val 2 1 = 0) : + q ∈ (elementaryReduction k).range := by + let T (i j : Fin 3) (h : i ≠ j) (a : ZMod (2 ^ k)) := + Matrix.SpecialLinearGroup.transvection h a + have he : q = T 0 1 (by decide) (q.val 0 1) * + T 0 2 (by decide) (q.val 0 2 - q.val 0 1 * q.val 1 2) * + T 1 2 (by decide) (q.val 1 2) := by + apply Subtype.ext + ext i j + fin_cases i <;> fin_cases j <;> + simp [T, Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.transvection_coe, + Matrix.mul_apply, Fin.sum_univ_succ, Matrix.single, Matrix.one_apply, + h00, h11, h22, h10, h20, h21] + rw [he] + exact mul_mem (mul_mem (transvection_mem_elementaryReduction k _ _) + (transvection_mem_elementaryReduction k _ _)) (transvection_mem_elementaryReduction k _ _) + +lemma diagonal_mem_elementaryReduction (k : ℕ) (u : (ZMod (2 ^ k))ˣ) : + diagonal u ∈ (elementaryReduction k).range := by + let T (i j : Fin 3) (h : i ≠ j) (a : ZMod (2 ^ k)) := + Matrix.SpecialLinearGroup.transvection h a + have hw (v : (ZMod (2 ^ k))ˣ) : + (T 0 1 (by decide) v * + T 1 0 (by decide) (-((v⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) * + T 0 1 (by decide) v).val = !![0, (v : ZMod (2 ^ k)), 0; -((v⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)), 0, 0; 0, 0, 1] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [T, Matrix.SpecialLinearGroup.coe_mul, + Matrix.SpecialLinearGroup.transvection_coe, Matrix.mul_apply, + Fin.sum_univ_succ, Matrix.single, Matrix.one_apply, mul_add, add_mul] + have hneg : (T 0 1 (by decide) (-1) * T 1 0 (by decide) 1 * + T 0 1 (by decide) (-1)).val = !![0, (-1 : ZMod (2 ^ k)), 0; 1, 0, 0; 0, 0, 1] := by + simpa using hw (-1) + have he : diagonal u = + (T 0 1 (by decide) u * + T 1 0 (by decide) (-((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) * + T 0 1 (by decide) u) * + (T 0 1 (by decide) (-1) * T 1 0 (by decide) 1 * + T 0 1 (by decide) (-1)) := by + apply Subtype.ext + change _ = (T 0 1 (by decide) u * + T 1 0 (by decide) (-((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) * + T 0 1 (by decide) u).val * _ + rw [hw, hneg] + ext i j + fin_cases i <;> fin_cases j <;> + simp [diagonal, Matrix.mul_apply, Fin.sum_univ_succ, Matrix.diagonal] + rw [he] + exact mul_mem + (mul_mem (mul_mem (transvection_mem_elementaryReduction k _ _) + (transvection_mem_elementaryReduction k _ _)) (transvection_mem_elementaryReduction k _ _)) + (mul_mem (mul_mem (transvection_mem_elementaryReduction k _ _) + (transvection_mem_elementaryReduction k _ _)) (transvection_mem_elementaryReduction k _ _)) + +def secondDiagonal (k : ℕ) (u : (ZMod (2 ^ k))ˣ) : Congruence.Quotient k := + ⟨Matrix.diagonal ![1, (u : ZMod (2 ^ k)), ((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))], by + simp [Matrix.det_diagonal, Fin.prod_univ_succ]⟩ + +lemma secondDiagonal_mem_elementaryReduction (k : ℕ) (u : (ZMod (2 ^ k))ˣ) : + secondDiagonal k u ∈ (elementaryReduction k).range := by + let T (i j : Fin 3) (h : i ≠ j) (a : ZMod (2 ^ k)) := + Matrix.SpecialLinearGroup.transvection h a + have hw (v : (ZMod (2 ^ k))ˣ) : + (T 1 2 (by decide) v * + T 2 1 (by decide) (-((v⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) * + T 1 2 (by decide) v).val = !![1, 0, 0; 0, 0, (v : ZMod (2 ^ k)); 0, -((v⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)), 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [T, Matrix.SpecialLinearGroup.coe_mul, + Matrix.SpecialLinearGroup.transvection_coe, Matrix.mul_apply, + Fin.sum_univ_succ, Matrix.single, Matrix.one_apply, mul_add, add_mul] + have hneg : (T 1 2 (by decide) (-1) * T 2 1 (by decide) 1 * + T 1 2 (by decide) (-1)).val = !![1, 0, 0; 0, 0, (-1 : ZMod (2 ^ k)); 0, 1, 0] := by + simpa using hw (-1) + have he : secondDiagonal k u = + (T 1 2 (by decide) u * + T 2 1 (by decide) (-((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) * + T 1 2 (by decide) u) * + (T 1 2 (by decide) (-1) * T 2 1 (by decide) 1 * + T 1 2 (by decide) (-1)) := by + apply Subtype.ext + change _ = (T 1 2 (by decide) u * + T 2 1 (by decide) (-((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) * + T 1 2 (by decide) u).val * _ + rw [hw, hneg] + ext i j + fin_cases i <;> fin_cases j <;> + simp [secondDiagonal, Matrix.mul_apply, Fin.sum_univ_succ, Matrix.diagonal] + rw [he] + exact mul_mem + (mul_mem (mul_mem (transvection_mem_elementaryReduction k _ _) + (transvection_mem_elementaryReduction k _ _)) (transvection_mem_elementaryReduction k _ _)) + (mul_mem (mul_mem (transvection_mem_elementaryReduction k _ _) + (transvection_mem_elementaryReduction k _ _)) (transvection_mem_elementaryReduction k _ _)) + +lemma upperTriangular_mem_elementaryReduction (k : ℕ) (q : Congruence.Quotient k) + (h10 : q.val 1 0 = 0) (h20 : q.val 2 0 = 0) (h21 : q.val 2 1 = 0) + (h00 : IsUnit (q.val 0 0)) (h11 : IsUnit (q.val 1 1)) : + q ∈ (elementaryReduction k).range := by + obtain ⟨u, hu⟩ := h00 + obtain ⟨v, hv⟩ := h11 + let a := diagonal u⁻¹ + let b := secondDiagonal k (u * v)⁻¹ + let n := b * (a * q) + have hn (i j : Fin 3) : n.val i j = + (![1, (((u * v)⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)), ((u * v : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))] i) * + ((![((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)), (u : ZMod (2 ^ k)), 1] i) * q.val i j) := by + change (b.val * (a.val * q.val)) i j = _ + simp [b, a, secondDiagonal, diagonal, Matrix.diagonal_mul] + have hdet : ((u * v : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)) * q.val 2 2 = 1 := by + have h := q.property + rw [Matrix.det_fin_three] at h + simpa only [h10, h20, h21, mul_zero, zero_mul, add_zero, sub_zero, + ← hu, ← hv, Units.val_mul, mul_assoc] using h + have hn00 : n.val 0 0 = 1 := by rw [hn, ← hu]; simp + have hn11 : n.val 1 1 = 1 := by + rw [hn, ← hv] + change (((u * v)⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)) * + ((u : ZMod (2 ^ k)) * (v : ZMod (2 ^ k))) = 1 + change (((u * v)⁻¹ * (u * v) : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)) = 1 + simp + have hn22 : n.val 2 2 = 1 := by simpa [hn] using hdet + have hn10 : n.val 1 0 = 0 := by rw [hn, h10]; simp + have hn20 : n.val 2 0 = 0 := by rw [hn, h20]; simp + have hn21 : n.val 2 1 = 0 := by rw [hn, h21]; simp + have hnmem := upperUnitriangular_mem_elementaryReduction k n hn00 hn11 hn22 hn10 hn20 hn21 + have ha : a ∈ (elementaryReduction k).range := diagonal_mem_elementaryReduction k u⁻¹ + have hb : b ∈ (elementaryReduction k).range := secondDiagonal_mem_elementaryReduction k (u * v)⁻¹ + exact ((elementaryReduction k).range.mul_mem_cancel_left ha).mp + (((elementaryReduction k).range.mul_mem_cancel_left hb).mp hnmem) + +lemma isUnit_of_mod_two_one {k : ℕ} (hk : 1 ≤ k) (a : ZMod (2 ^ k)) + (ha : residueMap hk a = 1) : IsUnit a := by + have hval : (a.val : ZMod 2) = 1 := by + simpa only [residueMap, ZMod.castHom_apply, ZMod.cast_eq_val, pow_one] using ha + rw [← ZMod.natCast_zmod_val a] + apply (ZMod.isUnit_natCast_iff_not_dvd_pow Nat.prime_two (lt_of_lt_of_le Nat.zero_lt_one hk)).2 + intro hd + have hz := (ZMod.natCast_eq_zero_iff a.val 2).2 hd + exact zero_ne_one (hz.symm.trans hval) + +lemma mod_two_identity_entry {k : ℕ} (hk : 1 ≤ k) (q : Congruence.Quotient k) + (hq : quotientMap hk q = 1) (i j : Fin 3) : + residueMap hk (q.val i j) = if i = j then 1 else 0 := by + have h := congrArg (fun z : Congruence.Quotient 1 => z.val i j) hq + simpa only [quotientMap, Matrix.SpecialLinearGroup.map_apply_coe, + Matrix.SpecialLinearGroup.coe_one, Matrix.one_apply, RingHom.mapMatrix_apply, + Matrix.map_apply] using h + +lemma mod_two_identity_first_pivot {k : ℕ} (hk : 1 ≤ k) (q : Congruence.Quotient k) + (hq : quotientMap hk q = 1) : IsUnit (q.val 0 0) := by + apply isUnit_of_mod_two_one hk + simpa using mod_two_identity_entry hk q hq 0 0 + +lemma mod_two_identity_schur_pivot {k : ℕ} (hk : 1 ≤ k) (q : Congruence.Quotient k) + (hq : quotientMap hk q = 1) (a : ZMod (2 ^ k)) : + IsUnit (q.val 1 1 - q.val 1 0 * a * q.val 0 1) := by + apply isUnit_of_mod_two_one hk + rw [map_sub, map_mul, map_mul] + have h11 : residueMap hk (q.val 1 1) = 1 := by + simpa using mod_two_identity_entry hk q hq 1 1 + have h10 : residueMap hk (q.val 1 0) = 0 := by + simpa using mod_two_identity_entry hk q hq 1 0 + rw [h11, h10, zero_mul, zero_mul, sub_zero] + +lemma mod_two_kernel_mem_elementaryReduction {k : ℕ} (hk : 1 ≤ k) + (q : Congruence.Quotient k) (hq : quotientMap hk q = 1) : + q ∈ (elementaryReduction k).range := by + obtain ⟨u, hu⟩ := mod_two_identity_first_pivot hk q hq + let t1 := Matrix.SpecialLinearGroup.transvection (by decide : (1 : Fin 3) ≠ 0) + (-q.val 1 0 * ((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) + let m1 := t1 * q + have hm1row0 (c : Fin 3) : m1.val 0 c = q.val 0 c := + elementary_row_other k _ _ q 0 c (by decide) + have hm1row2 (c : Fin 3) : m1.val 2 c = q.val 2 c := + elementary_row_other k _ _ q 2 c (by decide) + have hm110 : m1.val 1 0 = 0 := by + change (t1 * q).val 1 0 = 0 + rw [elementary_row_same, ← hu] + simp [mul_assoc] + let t2 := Matrix.SpecialLinearGroup.transvection (by decide : (2 : Fin 3) ≠ 0) + (-q.val 2 0 * ((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) + let m2 := t2 * m1 + have hm2row0 (c : Fin 3) : m2.val 0 c = q.val 0 c := + (elementary_row_other k _ _ m1 0 c (by decide)).trans (hm1row0 c) + have hm210 : m2.val 1 0 = 0 := + (elementary_row_other k _ _ m1 1 0 (by decide)).trans hm110 + have hm220 : m2.val 2 0 = 0 := by + change (t2 * m1).val 2 0 = 0 + rw [elementary_row_same, hm1row2, hm1row0, ← hu] + simp [mul_assoc] + have hm211 : m2.val 1 1 = q.val 1 1 - q.val 1 0 * + ((u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)) * q.val 0 1 := by + change (t2 * m1).val 1 1 = _ + rw [elementary_row_other k _ _ m1 1 1 (by decide)] + change (t1 * q).val 1 1 = _ + rw [elementary_row_same] + ring + have hunit2 : IsUnit (m2.val 1 1) := by + rw [hm211] + exact mod_two_identity_schur_pivot hk q hq _ + obtain ⟨v, hv⟩ := hunit2 + let t3 := Matrix.SpecialLinearGroup.transvection (by decide : (2 : Fin 3) ≠ 1) + (-m2.val 2 1 * ((v⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k))) + let m3 := t3 * m2 + have hm310 : m3.val 1 0 = 0 := + (elementary_row_other k _ _ m2 1 0 (by decide)).trans hm210 + have hm320 : m3.val 2 0 = 0 := by + change (t3 * m2).val 2 0 = 0 + rw [elementary_row_same, hm220, hm210, mul_zero, add_zero] + have hm321 : m3.val 2 1 = 0 := by + change (t3 * m2).val 2 1 = 0 + rw [elementary_row_same, ← hv] + simp [mul_assoc] + have hm300 : IsUnit (m3.val 0 0) := by + have he : m3.val 0 0 = q.val 0 0 := + (elementary_row_other k _ _ m2 0 0 (by decide)).trans (hm2row0 0) + rw [he, ← hu] + exact u.isUnit + have hm311 : IsUnit (m3.val 1 1) := by + have he : m3.val 1 1 = m2.val 1 1 := elementary_row_other k _ _ m2 1 1 (by decide) + rw [he, ← hv] + exact v.isUnit + have hm3 := upperTriangular_mem_elementaryReduction k m3 hm310 hm320 hm321 hm300 hm311 + have ht1 : t1 ∈ (elementaryReduction k).range := transvection_mem_elementaryReduction k _ _ + have ht2 : t2 ∈ (elementaryReduction k).range := transvection_mem_elementaryReduction k _ _ + have ht3 : t3 ∈ (elementaryReduction k).range := transvection_mem_elementaryReduction k _ _ + exact ((elementaryReduction k).range.mul_mem_cancel_left ht1).mp + (((elementaryReduction k).range.mul_mem_cancel_left ht2).mp + (((elementaryReduction k).range.mul_mem_cancel_left ht3).mp hm3)) + +/-- Surjectivity is proved by reduction to level one followed by elimination +inside the kernel of reduction modulo two. -/ +theorem elementaryReduction_surjective (k : ℕ) : Function.Surjective (elementaryReduction k) := by + by_cases hk : k = 0 + · subst k + exact elementaryReduction_zero_surjective + have hk1 : 1 ≤ k := Nat.one_le_iff_ne_zero.mpr hk + intro q + obtain ⟨e, he⟩ := elementaryReduction_one_surjective (quotientMap hk1 q) + let r := (elementaryReduction k e)⁻¹ * q + have hr : quotientMap hk1 r = 1 := by + change quotientMap hk1 ((elementaryReduction k e)⁻¹ * q) = 1 + rw [map_mul, map_inv] + have heq : quotientMap hk1 (elementaryReduction k e) = quotientMap hk1 q := by + change quotientMap hk1 (reduce k e.val) = _ + rw [quotientMap_reduce] + exact he + rw [heq, inv_mul_cancel] + obtain ⟨f, hf⟩ := mod_two_kernel_mem_elementaryReduction hk1 r hr + refine ⟨e * f, ?_⟩ + rw [map_mul, hf] + change elementaryReduction k e * ((elementaryReduction k e)⁻¹ * q) = q + group + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CongruenceFibers.lean b/lean/OAI/Topology/CoarseAssembly/CongruenceFibers.lean new file mode 100644 index 0000000000000000000000000000000000000000..c085ea234734671811a7d2a53b8abad7f3fa791d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CongruenceFibers.lean @@ -0,0 +1,61 @@ +import OAI.Topology.CoarseAssembly.CongruenceMaps + +namespace OAI + +/-! # The uniform bound on successive congruence fibers + +A residue modulo `2^(k+1)` is determined by its residue modulo `2^k` +and one binary digit. Applying this to the nine matrix entries bounds +every fiber of the special-linear reduction by `2^9`, including `k=0`. +No surjectivity or formula for the order of the group is needed. +-/ + +namespace CoarseAssembly.Congruence + +def topBit (k : ℕ) (x : ZMod (2 ^ (k + 1))) : Fin 2 := + ⟨x.val / 2 ^ k, (Nat.div_lt_iff_lt_mul (by positivity)).2 + (by simpa only [pow_succ, Nat.mul_comm] using ZMod.val_lt x)⟩ + +theorem residue_topBit_injective (k : ℕ) {x y : ZMod (2 ^ (k + 1))} + (hr : residueMap (Nat.le_succ k) x = residueMap (Nat.le_succ k) y) + (hb : topBit k x = topBit k y) : x = y := by + apply ZMod.val_injective + have hmod := congrArg ZMod.val hr + have hdiv := congrArg Fin.val hb + change x.val / 2 ^ k = y.val / 2 ^ k at hdiv + simp only [residueMap, ZMod.castHom_apply, ZMod.cast_eq_val, ZMod.val_natCast] at hmod + have hx := Nat.mod_add_div x.val (2 ^ k) + have hy := Nat.mod_add_div y.val (2 ^ k) + calc + x.val = x.val % 2 ^ k + 2 ^ k * (x.val / 2 ^ k) := hx.symm + _ = y.val % 2 ^ k + 2 ^ k * (y.val / 2 ^ k) := by rw [hmod, hdiv] + _ = y.val := hy + +def matrixTopBits (k : ℕ) (q : Quotient (k + 1)) : Fin 3 → Fin 3 → Fin 2 := + fun i j => topBit k (q.val i j) + +theorem quotient_fiber_code_injective (k : ℕ) {x y : Quotient (k + 1)} + (hr : quotientMap (Nat.le_succ k) x = quotientMap (Nat.le_succ k) y) + (hb : matrixTopBits k x = matrixTopBits k y) : x = y := by + apply Subtype.ext + ext i j + apply residue_topBit_injective k + · exact congrArg (fun q : Quotient k => q.val i j) hr + · exact congrFun (congrFun hb i) j + +/-- Every shallow fiber has at most 512 children. -/ +theorem card_quotient_fiber_le (k : ℕ) (q : Quotient k) : + Fintype.card {x : Quotient (k + 1) // quotientMap (Nat.le_succ k) x = q} ≤ 2 ^ 9 := by + classical + have hinj : Function.Injective (fun x : {x : Quotient (k + 1) // + quotientMap (Nat.le_succ k) x = q} => matrixTopBits k x.val) := by + intro x y h + apply Subtype.ext + exact quotient_fiber_code_injective k (x.property.trans y.property.symm) h + have hc := Fintype.card_le_of_injective _ hinj + norm_num only [Fintype.card_fun, Fintype.card_fin] at hc ⊢ + exact hc + +end CoarseAssembly.Congruence + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CongruenceMaps.lean b/lean/OAI/Topology/CoarseAssembly/CongruenceMaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..e188372156d88cb3197b74050e35b73354f29302 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CongruenceMaps.lean @@ -0,0 +1,59 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CongruenceQuotients + +namespace OAI + +/-! # Compatible reductions between the congruence fibers + +These are the actual entrywise reductions, including level zero. In +particular, the compatibility of the chosen holonomy is a theorem, not an +extra assumption on the graph construction. +-/ + +namespace CoarseAssembly.Congruence + +@[simp] theorem quotientMap_self (k : ℕ) (q : Quotient k) : + quotientMap (le_refl k) q = q := by + apply Subtype.ext + ext i j + simp [quotientMap, residueMap, Matrix.SpecialLinearGroup.map_apply_coe] + +@[simp] theorem quotientMap_comp {l k n : ℕ} (hlk : l ≤ k) (hkn : k ≤ n) + (q : Quotient n) : + quotientMap hlk (quotientMap hkn q) = quotientMap (hlk.trans hkn) q := by + have hring : (residueMap hlk).comp (residueMap hkn) = + residueMap (hlk.trans hkn) := RingHom.ext_zmod _ _ + apply Subtype.ext + ext i j + exact DFunLike.congr_fun hring (q.val i j) + +@[simp] theorem quotientMap_reduce {l k : ℕ} (h : l ≤ k) (w : ArithmeticGroup) : + quotientMap h (reduce k w) = reduce l w := by + apply Subtype.ext + ext i j + simp [quotientMap, reduce, Matrix.SpecialLinearGroup.map_apply_coe] + +theorem map_diagonal {R S : Type*} [CommRing R] [CommRing S] + (f : R →+* S) (t : Rˣ) : + Matrix.SpecialLinearGroup.map f (diagonal t) = + diagonal (Units.map f.toMonoidHom t) := by + apply Subtype.ext + ext i j + change f ((diagonal t).val i j) = (diagonal (Units.map f.toMonoidHom t)).val i j + fin_cases i <;> fin_cases j <;> + simp [diagonal, Matrix.diagonal] + +@[simp] theorem quotientMap_holonomy (t : ℤ_[2]ˣ) {l k : ℕ} (h : l ≤ k) : + quotientMap h (holonomy t k) = holonomy t l := by + rw [quotientMap, holonomy, map_diagonal, holonomy] + congr 1 + apply Units.ext + exact DFunLike.congr_fun (PadicInt.zmod_cast_comp_toZModPow l k h) (t : ℤ_[2]) + +instance quotientZeroSubsingleton : Subsingleton (Quotient 0) := by + have : Subsingleton (ZMod (2 ^ 0)) := by change Subsingleton (ZMod 1); infer_instance + exact ⟨fun x y => Subtype.ext (Subsingleton.elim _ _)⟩ + +end CoarseAssembly.Congruence + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CongruenceQuotients.lean b/lean/OAI/Topology/CoarseAssembly/CongruenceQuotients.lean new file mode 100644 index 0000000000000000000000000000000000000000..d8335d833e00ca5dd9900c26f2acf9531e8eb51e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CongruenceQuotients.lean @@ -0,0 +1,87 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup +import Mathlib.LinearAlgebra.Matrix.Trace +import Mathlib.NumberTheory.Padics.RingHoms +import Mathlib.Tactic.FinCases +import Mathlib.Tactic.NormNum + +namespace OAI + +/-! +# The actual congruence quotients and diagonal holonomies + +The congruence quotient is `SL₃(ℤ/2^kℤ)`, including the singleton quotient +for `k = 0`. +Its diagonal matrices have entries `t,t⁻¹,1`, and the finite-level matrices +are obtained by the genuine 2-adic reduction maps. +-/ + +namespace CoarseAssembly.Congruence + +theorem diagonal_one {R : Type*} [CommRing R] : + diagonal (1 : Rˣ) = 1 := by + apply Subtype.ext + ext i j + fin_cases i <;> fin_cases j <;> simp [diagonal, Matrix.diagonal] + +theorem diagonal_mul {R : Type*} [CommRing R] (s t : Rˣ) : + diagonal (s * t) = diagonal s * diagonal t := by + apply Subtype.ext + simp only [Matrix.SpecialLinearGroup.coe_mul] + change Matrix.diagonal _ = Matrix.diagonal _ * Matrix.diagonal _ + rw [Matrix.diagonal_mul_diagonal] + congr 1 + ext i + fin_cases i <;> simp [mul_comm] + +/-- The diagonal assignment respects the unit-group multiplication. -/ +def diagonalHom {R : Type*} [CommRing R] : Rˣ →* Matrix.SpecialLinearGroup (Fin 3) R where + toFun := diagonal + map_one' := diagonal_one + map_mul' := diagonal_mul + +/-- Powers of the diagonal holonomy have the expected Laurent trace. -/ +theorem trace_diagonal_pow {R : Type*} [CommRing R] (t : Rˣ) (m : ℕ) : + Matrix.trace ((diagonal t ^ m : Matrix.SpecialLinearGroup (Fin 3) R) : Matrix (Fin 3) (Fin 3) R) = + (t ^ m : Rˣ) + ((t ^ m)⁻¹ : Rˣ) + 1 := by + change Matrix.trace ((diagonalHom t ^ m : Matrix.SpecialLinearGroup (Fin 3) R) : + Matrix (Fin 3) (Fin 3) R) = _ + rw [← map_pow] + simp [diagonalHom, diagonal, Matrix.trace_diagonal, Fin.sum_univ_succ, add_assoc] + +theorem trace_diagonal_zpow {R : Type*} [CommRing R] (t : Rˣ) (m : ℤ) : + Matrix.trace ((diagonal t ^ m : Matrix.SpecialLinearGroup (Fin 3) R) : + Matrix (Fin 3) (Fin 3) R) = + (t ^ m : Rˣ) + ((t ^ m)⁻¹ : Rˣ) + 1 := by + change Matrix.trace ((diagonalHom t ^ m : Matrix.SpecialLinearGroup (Fin 3) R) : + Matrix (Fin 3) (Fin 3) R) = _ + rw [← map_zpow] + simp [diagonalHom, diagonal, Matrix.trace_diagonal, Fin.sum_univ_succ, add_assoc] + +/-- Reversing the signed charge leaves the diagonal trace unchanged. -/ +theorem trace_diagonal_neg {R : Type*} [CommRing R] (t : Rˣ) (m : ℤ) : + Matrix.trace ((diagonal t ^ (-m) : Matrix.SpecialLinearGroup (Fin 3) R) : + Matrix (Fin 3) (Fin 3) R) = + Matrix.trace ((diagonal t ^ m : Matrix.SpecialLinearGroup (Fin 3) R) : + Matrix (Fin 3) (Fin 3) R) := by + rw [trace_diagonal_zpow t (-m), trace_diagonal_zpow t m] + simp only [zpow_neg, inv_inv] + rw [add_comm (((t ^ m)⁻¹ : Rˣ) : R)] + +theorem trace_conjugate {R : Type*} [CommRing R] + (q z : Matrix.SpecialLinearGroup (Fin 3) R) : + Matrix.trace ((z⁻¹ * q * z : Matrix.SpecialLinearGroup (Fin 3) R) : Matrix (Fin 3) (Fin 3) R) = + Matrix.trace (q : Matrix (Fin 3) (Fin 3) R) := by + simp only [Matrix.SpecialLinearGroup.coe_mul] + rw [Matrix.trace_mul_cycle, ← Matrix.SpecialLinearGroup.coe_mul, mul_inv_cancel, + Matrix.SpecialLinearGroup.coe_one, one_mul] + +/-- Integral word traces reduce to their ordinary residue classes. -/ +theorem trace_reduce (k : ℕ) (w : ArithmeticGroup) : + Matrix.trace (reduce k w : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) = + ((Matrix.trace (w : Matrix (Fin 3) (Fin 3) ℤ) : ℤ) : ZMod (2 ^ k)) := by + simp [reduce, Matrix.trace, Matrix.SpecialLinearGroup.map_apply_coe] + +end CoarseAssembly.Congruence + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CongruenceSpectral.lean b/lean/OAI/Topology/CoarseAssembly/CongruenceSpectral.lean new file mode 100644 index 0000000000000000000000000000000000000000..fef671be861cd91747ac25559a31628c0ae69e3f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CongruenceSpectral.lean @@ -0,0 +1,93 @@ +import OAI.Topology.CoarseAssembly.RegularConstants +import OAI.Topology.CoarseAssembly.KazhdanInput +import OAI.Analysis.NuclearUltrapower.Kazhdan + +namespace OAI + +/-! # Applying the integral spectral certificate to the finite congruence fibers + +The required gap follows from surjectivity of elementary reduction. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence +open NuclearUltrapower + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def elementaryReduction (k : ℕ) : SOS.E →* Congruence.Quotient k := + (reduce k).comp SOS.elementary.subtype + +def elementaryRegular (k : ℕ) : SOS.E →* + (lp (fun _ : Congruence.Quotient k => H) 2 ≃ₗᵢ[ℂ] + lp (fun _ : Congruence.Quotient k => H) 2) := + (leftTranslationHom (H := H) (Congruence.Quotient k)).comp (elementaryReduction k) + +def elementaryLaplacian (k : ℕ) : + lp (fun _ : Congruence.Quotient k => H) 2 →L[ℂ] lp (fun _ : Congruence.Quotient k => H) 2 := + SOS.ElementarySpectral.deltaOp (elementaryRegular (H := H) k) + +theorem certificateGenerators_subset : SOS.genSet ⊆ elementaryMoves := by + decide +kernel + +omit [CompleteSpace H] in +theorem elementaryEnergy_le (k : ℕ) (x : lp (fun _ : Congruence.Quotient k => H) 2) : + SOSEnergy.energy SOS.eGenSet (elementaryRegular (H := H) k) x ≤ translationEnergy elementaryMoves k x := by + classical + have hs : SOSEnergy.energy SOS.eGenSet (elementaryRegular (H := H) k) x = + ∑ g ∈ SOS.genSet, ‖leftTranslation (Congruence.Quotient k) (reduce k g) x - x‖ ^ 2 := by + unfold SOSEnergy.energy + apply Finset.sum_bij (fun (g : SOS.E) _ => (g : SOS.SL)) + · intro g hg + exact SOS.mem_eGenSet.mp hg + · intro a _ b _ hab + exact Subtype.ext hab + · intro g hg + let e : SOS.E := ⟨g, Subgroup.subset_closure hg⟩ + exact ⟨e, SOS.mem_eGenSet.mpr hg, rfl⟩ + · intro g _ + rfl + rw [hs] + exact Finset.sum_le_sum_of_subset_of_nonneg certificateGenerators_subset (fun _ _ _ => sq_nonneg _) + +theorem elementaryKernel_projection (k : ℕ) + (hsurj : Function.Surjective (elementaryReduction k)) + (x : lp (fun _ : Congruence.Quotient k => H) 2) + (hx : x ∈ (elementaryLaplacian (H := H) k).ker) : + constantProjection (Congruence.Quotient k) x = x := by + apply regular_fixed_projection + intro q + obtain ⟨g, rfl⟩ := hsurj q + exact SOS.ElementarySpectral.deltaOp_ker_fixed (elementaryRegular (H := H) k) x hx g + +theorem elementaryEnergy_gap (k : ℕ) + (hsurj : Function.Surjective (elementaryReduction k)) + (x : lp (fun _ : Congruence.Quotient k => H) 2) + (hx : constantProjection (Congruence.Quotient k) x = 0) : + (1 / 10 : ℝ) * ‖x‖ ^ 2 ≤ translationEnergy elementaryMoves k x := by + have ho : x ∈ (elementaryLaplacian (H := H) k).kerᗮ := by + rw [Submodule.mem_orthogonal] + intro y hy + exact inner_eq_zero_of_projection_zero _ x y hx (elementaryKernel_projection k hsurj y hy) + exact (SOS.ElementarySpectral.deltaOp_gap (elementaryRegular (H := H) k) x ho).trans (elementaryEnergy_le k x) + +/-- The required published gap follows from the integral certificate and +surjectivity onto the specified finite quotients. -/ +theorem publishedKazhdanInput_of_elementaryReduction + (hsurj : ∀ k, Function.Surjective (elementaryReduction k)) : PublishedKazhdanInput := by + apply uniformAveragingGap_of_energy elementaryMoves elementaryMoves_nonempty (1 / 10) + (by norm_num) + · have hc : (1 : ℝ) ≤ elementaryMoves.card := by + exact_mod_cast elementaryMoves_nonempty.card_pos + linarith + · intro k x hx + exact elementaryEnergy_gap k (hsurj k) x hx + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CongruenceSurjective.lean b/lean/OAI/Topology/CoarseAssembly/CongruenceSurjective.lean new file mode 100644 index 0000000000000000000000000000000000000000..e73ba3dd483283c976be4177ef86c11a8669c88b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CongruenceSurjective.lean @@ -0,0 +1,73 @@ +import OAI.Topology.CoarseAssembly.CongruenceFibers + +namespace OAI + +/-! # Surjectivity of the successive special-linear reductions + +Lift the entries arbitrarily. The lifted determinant is odd, hence a unit; +rescaling one row by its inverse corrects the determinant without changing +the reduction. Level zero is handled by its singleton group. +-/ + +namespace CoarseAssembly.Congruence + +@[simp] theorem residueMap_comp {l k n : ℕ} (hlk : l ≤ k) (hkn : k ≤ n) + (a : ZMod (2 ^ n)) : + residueMap hlk (residueMap hkn a) = residueMap (hlk.trans hkn) a := by + exact DFunLike.congr_fun (RingHom.ext_zmod + ((residueMap hlk).comp (residueMap hkn)) (residueMap (hlk.trans hkn))) a + +theorem isUnit_of_residue_one {k : ℕ} (hk : 1 ≤ k) (a : ZMod (2 ^ (k + 1))) + (ha : residueMap (Nat.le_succ k) a = 1) : IsUnit a := by + have htwo := congrArg (residueMap hk) ha + rw [residueMap_comp, map_one] at htwo + have hval : (a.val : ZMod 2) = 1 := by + simpa only [residueMap, ZMod.castHom_apply, ZMod.cast_eq_val, pow_one] using htwo + rw [← ZMod.natCast_zmod_val a] + apply (ZMod.isUnit_natCast_iff_not_dvd_pow Nat.prime_two (Nat.succ_pos k)).2 + intro hd + have hz := (ZMod.natCast_eq_zero_iff a.val 2).2 hd + exact zero_ne_one (hz.symm.trans hval) + +theorem quotientMap_successor_surjective (k : ℕ) : + Function.Surjective (quotientMap (Nat.le_succ k)) := by + intro q + by_cases hk : k = 0 + · subst k + exact ⟨1, Subsingleton.elim _ _⟩ + have hk1 : 1 ≤ k := Nat.one_le_iff_ne_zero.mpr hk + let φ := residueMap (Nat.le_succ k) + let A : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ (k + 1))) := + fun i j => (q.val i j).val + have hA : φ.mapMatrix A = q.val := by + ext i j + change φ ((q.val i j).val : ZMod (2 ^ (k + 1))) = q.val i j + simp + have hdet : φ A.det = 1 := by + rw [RingHom.map_det, hA] + exact q.property + obtain ⟨u, hu⟩ := isUnit_of_residue_one hk1 A.det hdet + let D : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ (k + 1))) := + Matrix.diagonal ![(u⁻¹ : (ZMod (2 ^ (k + 1)))ˣ), 1, 1] + have hDdet : (D * A).det = 1 := by + simp [D, Matrix.det_mul, Matrix.det_diagonal, Fin.prod_univ_succ, ← hu] + have huφ : Units.map φ.toMonoidHom u = 1 := by + apply Units.ext + change φ (u : ZMod (2 ^ (k + 1))) = 1 + rw [hu] + exact hdet + have hinv : φ ((u⁻¹ : (ZMod (2 ^ (k + 1)))ˣ) : ZMod (2 ^ (k + 1))) = 1 := by + change ((Units.map φ.toMonoidHom u⁻¹ : (ZMod (2 ^ k))ˣ) : ZMod (2 ^ k)) = 1 + rw [map_inv, huφ] + rfl + have hD : φ.mapMatrix D = 1 := by + ext i j + fin_cases i <;> fin_cases j <;> simp [D, Matrix.diagonal, hinv] + refine ⟨⟨D * A, hDdet⟩, ?_⟩ + apply Subtype.ext + change φ.mapMatrix (D * A) = q.val + rw [map_mul, hD, hA, one_mul] + +end CoarseAssembly.Congruence + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Conjugation.lean b/lean/OAI/Topology/CoarseAssembly/Conjugation.lean new file mode 100644 index 0000000000000000000000000000000000000000..6e2e84e862dffbf973bc795e65b4aba648afddb4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Conjugation.lean @@ -0,0 +1,53 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Analysis.CStarAlgebra.ContinuousLinearMap + +namespace OAI + +/-! +# Conjugation by an isometry + +The spatial operator homomorphism and exact boundary factorization used in +§§5--6 of the coarse Novikov manuscript. Restriction of this homomorphism to +the Roe algebras is a separate range-membership obligation. +-/ + +namespace CoarseAssembly + +variable {E F H : Type*} +variable [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] +variable [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +@[simp] theorem adjoint_apply_isometry (V : E →ₗᵢ[ℂ] F) (x : E) : + V.toContinuousLinearMap.adjoint (V x) = x := by + simpa only [ContinuousLinearMap.comp_apply, one_apply_eq_self, + LinearIsometry.coe_toContinuousLinearMap] using DFunLike.congr_fun V.adjoint_comp_self x + +theorem operatorConjugation_mul (V : E →ₗᵢ[ℂ] F) (T S : E →L[ℂ] E) : + operatorConjugation V (T * S) = operatorConjugation V T * operatorConjugation V S := by + ext x + simp [operatorConjugation] + +theorem operatorConjugation_injective (V : E →ₗᵢ[ℂ] F) : + Function.Injective (operatorConjugation V) := by + intro T S h + ext x + have hx := DFunLike.congr_fun h (V x) + simpa [operatorConjugation] using V.injective hx + +theorem operatorConjugation_star (V : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) : + operatorConjugation V (star T) = star (operatorConjugation V T) := by + simp [operatorConjugation, ContinuousLinearMap.star_eq_adjoint, + ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.comp_assoc] + +theorem operatorConjugation_comp (V : F →ₗᵢ[ℂ] H) (W : E →ₗᵢ[ℂ] F) + (T : E →L[ℂ] E) : + operatorConjugation V (operatorConjugation W T) = operatorConjugation (V.comp W) T := by + have hcomp : (V.comp W).toContinuousLinearMap = + V.toContinuousLinearMap.comp W.toContinuousLinearMap := rfl + simp [operatorConjugation, hcomp, ContinuousLinearMap.adjoint_comp, + ContinuousLinearMap.comp_assoc] + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConstructedBoundaryAssembly.lean b/lean/OAI/Topology/CoarseAssembly/ConstructedBoundaryAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..30c3ceaf6e2b50b5059060f37710ad4ac2eb9df2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConstructedBoundaryAssembly.lean @@ -0,0 +1,115 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ConcreteIndexSquares +import OAI.Topology.CoarseAssembly.SeparatedIndexNaturality + +namespace OAI + +/-! # Discharging the published assembly interface + +The three maps are the constructed analytic cycle index maps. Their two naturality squares follow from spatial inclusion, with +explicit reindexing of the manuscript's vertex sets. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic DiscreteRoe Rips Congruence + +local instance assembledDiscEq (i : ℕ) : DecidableEq (Disc i) := Classical.decEq _ +local instance assemblyBoundaryEq (i : ℕ) : DecidableEq (BoundaryComponent i) := Classical.decEq _ +local instance assemblyFiberEq (i : ℕ) : DecidableEq (FiberVertex i) := Classical.decEq _ +local instance assemblyBoundaryComponentMetric (i : ℕ) : MetricSpace (BoundaryComponent i) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit i +local instance assemblyBoundaryUnionMetric : MetricSpace (Sigma BoundaryComponent) := separatedMetric boundaryRoot +local instance assemblyBoundaryMetric : MetricSpace BoundaryVertex := + boundaryMetric elementaryMoves chosenHolonomyUnit +local instance assemblyFiberComponentMetric (i : ℕ) : MetricSpace (FiberVertex i) := + componentMetric elementaryMoves chosenHolonomyUnit i +local instance assemblyFiberUnionMetric : MetricSpace (Sigma FiberVertex) := separatedMetric fiberBoundaryBase +local instance assemblyTotalMetric : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnit + +theorem constructedBoundaryIndex_natural_base (n : ℕ) : + (constructedBaseIndex.atScale n).comp (pushforward (boundaryBaseCoarsening.atScale n)) = + (OperatorKTheory.map boundaryBaseRoeHom).comp (constructedBoundaryIndex.atScale n) := by + apply DFunLike.ext + intro a + let b := pushforward (boundaryInverseCoarsening.atScale n) a + let z := separatedRipsIndex boundaryRoot n (Nat.cast_nonneg n) b + have h := DFunLike.congr_fun + (separatedRipsIndex_inclusion boundaryRoot discBoundaryBase (Nat.cast_nonneg n) + boundaryComponentToBase boundaryComponentToBase_nonexpanding (fun _ => rfl) + boundaryBaseComponents_nonexpanding) b + change separatedRipsIndex discBoundaryBase n (Nat.cast_nonneg n) + (pushforward (boundaryBaseComponentsMap n) b) = + OperatorKTheory.map boundaryBaseComponentsRoeHom z at h + have hg := DFunLike.congr_fun (congrArg pushforward (boundaryBaseComponentsMap_eq n)) a + have hp := DFunLike.congr_fun + (pushforward_comp (boundaryInverseCoarsening.atScale n) (boundaryBaseComponentsMap n)) a + have hg' := hp.symm.trans hg + simp only [constructedBaseIndex, constructedBoundaryIndex, CompatibleIndexFamily.mapTarget, + CompatibleIndexFamily.transport, separatedIndexFamily_atScale, AddMonoidHom.comp_apply] + change OperatorKTheory.map baseReindexRoeHom + (separatedRipsIndex discBoundaryBase n (Nat.cast_nonneg n) + (pushforward (boundaryBaseCoarsening.atScale n) a)) = + OperatorKTheory.map boundaryBaseRoeHom (OperatorKTheory.map boundaryReindexRoeHom z) + have hk := DFunLike.congr_fun + (congrArg OperatorKTheory.map boundaryBaseComponentsRoeHom_eq) z + have hi := (congrArg (separatedRipsIndex discBoundaryBase n (Nat.cast_nonneg n)) hg').symm.trans h + have hkl := DFunLike.congr_fun + (OperatorKTheory.map_comp boundaryBaseComponentsRoeHom baseReindexRoeHom) z + have hkr := DFunLike.congr_fun + (OperatorKTheory.map_comp boundaryReindexRoeHom boundaryBaseRoeHom) z + exact (congrArg (OperatorKTheory.map baseReindexRoeHom) hi).trans + (hkl.symm.trans (hk.trans hkr)) + +theorem constructedBoundaryIndex_natural_total (n : ℕ) : + (constructedTotalIndex.atScale n).comp (pushforward (boundaryTotalCoarsening.atScale n)) = + (OperatorKTheory.map boundaryTotalRoeHom).comp (constructedBoundaryIndex.atScale n) := by + apply DFunLike.ext + intro a + let b := pushforward (boundaryInverseCoarsening.atScale n) a + let z := separatedRipsIndex boundaryRoot n (Nat.cast_nonneg n) b + have h := DFunLike.congr_fun + (separatedRipsIndex_inclusion boundaryRoot fiberBoundaryBase (Nat.cast_nonneg n) + boundaryFiberEmbedding boundaryFiberComponent_nonexpanding (fun _ => rfl) + boundaryFiberComponents_nonexpanding) b + change separatedRipsIndex fiberBoundaryBase n (Nat.cast_nonneg n) + (pushforward (boundaryFiberComponentsMap n) b) = + OperatorKTheory.map boundaryFiberComponentsRoeHom z at h + have hg := DFunLike.congr_fun (congrArg pushforward (boundaryFiberComponentsMap_eq n)) a + have hp := DFunLike.congr_fun + (pushforward_comp (boundaryInverseCoarsening.atScale n) (boundaryFiberComponentsMap n)) a + have hq := DFunLike.congr_fun + (pushforward_comp (boundaryTotalCoarsening.atScale n) (totalToFiberCoarsening.atScale n)) a + have hg' := hp.symm.trans (hg.trans hq) + simp only [constructedTotalIndex, constructedBoundaryIndex, CompatibleIndexFamily.transport, + separatedIndexFamily_atScale, AddMonoidHom.comp_apply] + change OperatorKTheory.map fiberReindexRoeHom + (separatedRipsIndex fiberBoundaryBase n (Nat.cast_nonneg n) + (pushforward (totalToFiberCoarsening.atScale n) + (pushforward (boundaryTotalCoarsening.atScale n) a))) = + OperatorKTheory.map boundaryTotalRoeHom (OperatorKTheory.map boundaryReindexRoeHom z) + have hk := DFunLike.congr_fun + (congrArg OperatorKTheory.map boundaryFiberComponentsRoeHom_eq) z + have hi := (congrArg (separatedRipsIndex fiberBoundaryBase n (Nat.cast_nonneg n)) hg').symm.trans h + have hkl := DFunLike.congr_fun + (OperatorKTheory.map_comp boundaryFiberComponentsRoeHom fiberReindexRoeHom) z + have hkr := DFunLike.congr_fun + (OperatorKTheory.map_comp boundaryReindexRoeHom boundaryTotalRoeHom) z + exact (congrArg (OperatorKTheory.map fiberReindexRoeHom) hi).trans + (hkl.symm.trans (hk.trans hkr)) + +/-- The published interface is now supplied by the constructed analytic index. -/ +def constructedBoundaryAssembly : PublishedBoundaryAssemblyInput where + boundary := constructedBoundaryIndex + base := constructedBaseIndex + total := constructedTotalIndex + natural_base := constructedBoundaryIndex_natural_base + natural_total := constructedBoundaryIndex_natural_total + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ConstructedConclusion.lean b/lean/OAI/Topology/CoarseAssembly/ConstructedConclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..9c3c6836c151230bfa1964b86d17a7b642f7829d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ConstructedConclusion.lean @@ -0,0 +1,34 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ConstructedBoundaryAssembly +import OAI.Topology.CoarseAssembly.ExplicitBoundaryConclusion + +namespace OAI + +/-! # Counterexample for the constructed analytic coarse assembly map + +Only the fixed-generator spectral-gap input remains in this theorem. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +attribute [local instance] OAI.CoarseAssembly.constructedConclusionMetric + +theorem bounded_geometry_counterexample_from_gap (hgap : PublishedKazhdanInput) : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ constructedCoarseAssembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective constructedCoarseAssembly ∧ + ¬ Function.Injective (constructedCoarseAssembly.toIntLinearMap.lTensor ℚ) := + bounded_geometry_counterexample_from_index_gap constructedBoundaryAssembly hgap + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ContinuousUnitalization.lean b/lean/OAI/Topology/CoarseAssembly/ContinuousUnitalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..552011b00661629c80275e7c04f7e14fb5f3888b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ContinuousUnitalization.lean @@ -0,0 +1,69 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.UnitalRepresentative +import OAI.Topology.CoarseAssembly.BoundedCycleTransform + +namespace OAI + +/-! # A path-compatible unital self-adjoint representative -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem OddCycle.unitalSelfAdjoint_unital (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.unitalSelfAdjoint χ).representation 1 = 1 := + characterExtension_unital c.cutDown χ (cutDown_selfAdjoint c) (cutDown_complement c) + (cutDown_square_compact c) + +theorem OddCycle.unitalSelfAdjoint_selfAdjoint (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + IsSelfAdjoint (c.unitalSelfAdjoint χ).operator := cutDown_selfAdjoint c + +theorem OddCycle.unitalSelfAdjoint_class (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + cycleClass A (c.unitalSelfAdjoint χ) = cycleClass A c := + (characterExtension_class c.cutDown χ (cutDown_selfAdjoint c) (cutDown_complement c) + (cutDown_square_compact c)).trans (cutDown_class c) + +theorem OddCycle.unitalSelfAdjoint_operator (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.unitalSelfAdjoint χ).operator = symmetricCutDown (c.representation 1) c.operator := + c.cutDown_operator + +theorem OddCycle.unitalSelfAdjoint_representation (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) (a : A) : + (show End c.space from (c.unitalSelfAdjoint χ).representation a) = + c.representation a + χ a • (1 - c.representation 1) := rfl + +variable {T : Type*} [TopologicalSpace T] {H : HilbertSpace} + +theorem continuous_symmetricCutDown (P F : T → End H) + (hP : Continuous P) (hF : Continuous F) : + Continuous (fun t => symmetricCutDown (P t) (F t)) := by + unfold symmetricCutDown + fun_prop + +def OddHomotopy.unitalSelfAdjoint (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) : OddHomotopy A where + space := h.space + representation t := ((h.eval t).unitalSelfAdjoint χ).representation + operator t := ((h.eval t).unitalSelfAdjoint χ).operator + continuous_representation a := by + change Continuous (fun t => h.representation t a + χ a • (1 - h.representation t 1)) + have hp : Continuous (fun t => (1 : End h.space) - h.representation t 1) := + continuous_const.sub (h.continuous_representation 1) + exact (h.continuous_representation a).add + ((continuous_const : Continuous (fun _ : Interval => χ a)).smul hp) + continuous_operator := by + have hc := continuous_symmetricCutDown (fun t => h.representation t 1) h.operator + (h.continuous_representation 1) h.continuous_operator + exact hc.congr (fun t => ((h.eval t).unitalSelfAdjoint_operator χ).symm) + commutator_compact t a := ((h.eval t).unitalSelfAdjoint χ).commutator_compact a + square_compact t a := ((h.eval t).unitalSelfAdjoint χ).square_compact a + adjoint_compact t a := ((h.eval t).unitalSelfAdjoint χ).adjoint_compact a + +@[simp] theorem OddHomotopy.unitalSelfAdjoint_eval (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (t : Interval) : (h.unitalSelfAdjoint χ).eval t = (h.eval t).unitalSelfAdjoint χ := rfl + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryClass.lean b/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryClass.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce91fcce78ff3b762dac7eb080aed62af8296704 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryClass.lean @@ -0,0 +1,83 @@ +import OAI.Topology.CoarseAssembly.CayleyBoundary +import OAI.Topology.CoarseAssembly.RelativeUnitary +import OAI.Topology.CoarseAssembly.UnitalStructureAlgebra + +namespace OAI + +/-! # The K₁ boundary representative of a controlled Fredholm operator + +The operator, its self-adjointness, and its Roe square defect are concrete +data. Localization of arbitrary Fredholm cycles and descent through their +relations are separate obligations of the assembly construction. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp +local instance : ContinuousStar (Operator X H) := ⟨operator_star_continuous⟩ + +variable (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + +def unitalRoeIdeal : TwoSidedIdeal (unitalStructureAlgebra (X := X) (H := H)) := + TwoSidedIdeal.mk' {T | T.val ∈ algebra (X := X) (H := H)} + (algebra (X := X) (H := H)).zero_mem + (fun hT hS => (algebra (X := X) (H := H)).add_mem hT hS) + (fun hT => (algebra (X := X) (H := H)).neg_mem hT) + (fun {T S} hS => (structureAlgebra_multiplier finiteBalls T.property) ⟨S.val, hS⟩ |>.1) + (fun {T S} hT => (structureAlgebra_multiplier finiteBalls S.property) ⟨T.val, hT⟩ |>.2) + +@[simp] theorem mem_unitalRoeIdeal (T : unitalStructureAlgebra (X := X) (H := H)) : + T ∈ unitalRoeIdeal (H := H) finiteBalls ↔ T.val ∈ algebra (X := X) (H := H) := + TwoSidedIdeal.mem_mk' _ _ _ _ _ _ T + +def controlledBoundaryUnitary (F : unitalStructureAlgebra (X := X) (H := H)) + (hF : IsSelfAdjoint F) : unitary (Operator X H) := + Unitary.map (StarMonoidHom.ofClass (unitalStructureAlgebra (X := X) (H := H)).subtype) + (Analytic.rationalBoundaryUnitary F hF) + +include finiteBalls in +theorem controlledBoundaryUnitary_sub_one_mem + (F : unitalStructureAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hdefect : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + (controlledBoundaryUnitary F hF : Operator X H) - 1 ∈ algebra (X := X) (H := H) := by + have hF' : F ^ 2 - 1 ∈ unitalRoeIdeal (H := H) finiteBalls := by + rw [mem_unitalRoeIdeal] + simpa using hdefect + have h := Analytic.rationalBoundaryUnitary_sub_one_mem + (unitalRoeIdeal (H := H) finiteBalls) F hF hF' + rw [mem_unitalRoeIdeal] at h + exact h + +/-- An actual class of the reduced locally compact Roe algebra. -/ +def controlledBoundaryClass + (F : unitalStructureAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hdefect : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + OperatorKTheory.K1 (algebra (X := X) (H := H)) := + OperatorKTheory.relativeClass (hS := algebra_isClosed) (algebra (X := X) (H := H)) + (controlledBoundaryUnitary F hF) + (controlledBoundaryUnitary_sub_one_mem finiteBalls F hF hdefect) + +theorem controlledBoundaryClass_of_involution + (F : unitalStructureAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hdefect : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) (hsq : F ^ 2 = 1) : + controlledBoundaryClass finiteBalls F hF hdefect = 0 := by + apply OperatorKTheory.relativeClass_eq_zero (hS := algebra_isClosed) + apply Subtype.ext + change ((Analytic.rationalBoundaryUnitary F hF : + unitalStructureAlgebra (X := X) (H := H)) : Operator X H) = 1 + rw [Analytic.rationalBoundaryUnitary_eq_one F hF hsq] + rfl + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..96ba3482699ca64dcf54876710ea9d9e3915efa2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryHomotopy.lean @@ -0,0 +1,45 @@ +import OAI.Topology.CoarseAssembly.ControlledBoundaryClass +import OAI.Topology.CoarseAssembly.CayleyContinuity +import OAI.Topology.CoarseAssembly.RelativeHomotopy + +namespace OAI + +/-! # Homotopies of controlled Fredholm operators give the same Roe class -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp +local instance : ContinuousStar (Operator X H) := ⟨operator_star_continuous⟩ + +variable (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + +theorem controlledBoundaryClass_homotopy + (F : Interval → unitalStructureAlgebra (X := X) (H := H)) + (hF : ∀ t, IsSelfAdjoint (F t)) + (hdefect : ∀ t, (F t).val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hcont : Continuous F) : + controlledBoundaryClass finiteBalls (F start) (hF start) (hdefect start) = + controlledBoundaryClass finiteBalls (F finish) (hF finish) (hdefect finish) := by + have hU : Continuous (fun t => (controlledBoundaryUnitary (F t) (hF t) : Operator X H)) := by + convert! (show Continuous + (fun T : unitalStructureAlgebra (X := X) (H := H) => T.val) from + continuous_subtype_val).comp (continuous_rationalBoundaryUnitary F hF hcont) + exact OperatorKTheory.relativeClass_homotopy (hS := algebra_isClosed) + (algebra (X := X) (H := H)) (fun t => controlledBoundaryUnitary (F t) (hF t)) + (fun t => controlledBoundaryUnitary_sub_one_mem finiteBalls (F t) (hF t) (hdefect t)) hU + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryNearby.lean b/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryNearby.lean new file mode 100644 index 0000000000000000000000000000000000000000..504f328a582e82da24f5a715097e0f962a112ae7 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledBoundaryNearby.lean @@ -0,0 +1,43 @@ +import OAI.Topology.CoarseAssembly.ControlledRipsCycles +import OAI.Topology.CoarseAssembly.SeparatedFamilyNearby + +namespace OAI + +/-! # Norm comparison of bounded cycle families in the actual Roe boundary -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +theorem ControlledCycleFamily.boundary_eq_of_ample_nearby + (c d : ControlledCycleFamily Q r) (o : ∀ i, Q i) (hr : 0 ≤ r) + (δ : ℝ) (hδ : 0 ≤ δ) (hsmall : δ < 1 / 4) + (hnear : ∀ i, ‖ampleRipsOperator r (d.cycle i) (d.unital i) - + ampleRipsOperator r (c.cycle i) (c.unital i)‖ ≤ δ) : + c.boundary o hr = d.boundary o hr := by + let := separatedMetric o + exact separatedFamilyBoundary_eq_of_nearby o _ _ (c.bound + 4) (d.bound + 4) + (by linarith [c.bound_nonneg]) (by linarith [d.bound_nonneg]) + (fun i => (ampleRipsOperator_norm_le r (c.cycle i) (c.unital i)).trans + (add_le_add (c.norm_le i) le_rfl)) + (fun i => (ampleRipsOperator_norm_le r (d.cycle i) (d.unital i)).trans + (add_le_add (d.norm_le i) le_rfl)) + (r + r) (add_nonneg hr hr) + (fun i => ampleRipsOperator_propagation r hr (c.cycle i) (c.unital i)) + (fun i => ampleRipsOperator_propagation r hr (d.cycle i) (d.unital i)) + (fun i => ampleRipsOperator_selfAdjoint r (c.cycle i) (c.unital i) (c.selfAdjoint i)) + (fun i => ampleRipsOperator_selfAdjoint r (d.cycle i) (d.unital i) (d.selfAdjoint i)) + (fun i => ampleRipsOperator_square_compact r (c.cycle i) (c.unital i) (c.selfAdjoint i)) + (fun i => ampleRipsOperator_square_compact r (d.cycle i) (d.unital i) (d.selfAdjoint i)) + δ hδ hsmall hnear + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledCoarseAssembly.lean b/lean/OAI/Topology/CoarseAssembly/ControlledCoarseAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..32851494b97293eb139645a80c29f8a909976211 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledCoarseAssembly.lean @@ -0,0 +1,77 @@ +import OAI.Topology.CoarseAssembly.ControlledRipsCoarsening +import OAI.Topology.CoarseAssembly.Assembly + +namespace OAI + +/-! # The coarsening-limit assembly for controlled component families + +This is the direct limit of the constructed analytic quotient maps. Relating +its source to full locally finite K-homology is a separate remaining theorem. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable (Q : ℕ → Type) [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +def controlledScaleMap (r s : ℕ) (hrs : r ≤ s) : ControlledK Q (r : ℝ) →+ ControlledK Q (s : ℝ) := + controlledCoarsening (by exact_mod_cast hrs) + +instance controlledDirectedSystem : + DirectedSystem (fun r : ℕ => ControlledK Q (r : ℝ)) (fun r s h => controlledScaleMap Q r s h) where + map_self r x := by + change controlledCoarsening (Q := Q) (r := (r : ℝ)) le_rfl x = x + rw [controlledCoarsening_refl] + rfl + map_map t s r hrs hst x := by + change controlledCoarsening (Q := Q) (show (s : ℝ) ≤ t from by exact_mod_cast hst) + (controlledCoarsening (show (r : ℝ) ≤ s from by exact_mod_cast hrs) x) = _ + exact DFunLike.congr_fun (controlledCoarsening_comp + (show (r : ℝ) ≤ s from by exact_mod_cast hrs) + (show (s : ℝ) ≤ t from by exact_mod_cast hst)) x + +abbrev ControlledCoarseK := AddCommGroup.DirectLimit + (fun r : ℕ => ControlledK Q (r : ℝ)) (fun r s h => controlledScaleMap Q r s h) + +def controlledCoarseOf (r : ℕ) : ControlledK Q (r : ℝ) →+ ControlledCoarseK Q := + AddCommGroup.DirectLimit.of (fun r : ℕ => ControlledK Q (r : ℝ)) + (fun r s h => controlledScaleMap Q r s h) r + +variable {Q} + +/-- An actual compatible assembly map on the controlled component model. -/ +def controlledCoarseAssembly (o : ∀ i, Q i) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + ControlledCoarseK Q →+ OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := by + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + apply AddCommGroup.DirectLimit.lift _ _ _ (fun r => controlledAssembly o (Nat.cast_nonneg r)) + intro r s hrs x + exact DFunLike.congr_fun (controlledAssembly_coarsening o (Nat.cast_nonneg r) (Nat.cast_nonneg s) + (show (r : ℝ) ≤ s from by exact_mod_cast hrs)) x + +@[simp] theorem controlledCoarseAssembly_of (o : ∀ i, Q i) (r : ℕ) + (x : ControlledK Q (r : ℝ)) : + controlledCoarseAssembly o (controlledCoarseOf Q r x) = + controlledAssembly o (Nat.cast_nonneg r) x := + AddCommGroup.DirectLimit.lift_of _ _ _ _ _ + +@[simp] theorem controlledCoarseAssembly_cycle (o : ∀ i, Q i) (r : ℕ) + (c : ControlledCycleFamily Q (r : ℝ)) : + controlledCoarseAssembly o (controlledCoarseOf Q r (controlledClass c)) = + c.boundary o (Nat.cast_nonneg r) := by + exact (controlledCoarseAssembly_of o r (controlledClass c)).trans + (controlledAssembly_class o (Nat.cast_nonneg r) c) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledMatrices.lean b/lean/OAI/Topology/CoarseAssembly/ControlledMatrices.lean new file mode 100644 index 0000000000000000000000000000000000000000..72963e801adbd296e4ac6edaced992b721bc57d1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledMatrices.lean @@ -0,0 +1,165 @@ +import OAI.Topology.CoarseAssembly.HilbertSum +import Mathlib.Algebra.Order.BigOperators.Ring.Finset + +namespace OAI + +/-! # Bounded operators from controlled block matrices + +A finite-propagation matrix has uniformly bounded row and column supports. +Cauchy--Schwarz and finite double counting construct its bounded operator +directly. This supplies the boundedness step of the transfer lift without +an auxiliary edge colouring. +-/ + +noncomputable section + +namespace CoarseAssembly + +open scoped BigOperators + +theorem norm_sum_sq_le_card {J E : Type*} [NormedAddCommGroup E] + (s : Finset J) (x : J → E) : + ‖∑ j ∈ s, x j‖ ^ 2 ≤ (s.card : ℝ) * ∑ j ∈ s, ‖x j‖ ^ 2 := by + have hn := norm_sum_le s x + have hs := Finset.sum_mul_sq_le_sq_mul_sq s (fun j => ‖x j‖) (fun _ => (1 : ℝ)) + simp only [mul_one, one_pow, Finset.sum_const, nsmul_eq_mul, mul_one] at hs + have hnon : 0 ≤ ∑ j ∈ s, ‖x j‖ := Finset.sum_nonneg (fun _ _ => norm_nonneg _) + calc + _ ≤ (∑ j ∈ s, ‖x j‖) ^ 2 := by nlinarith [norm_nonneg (∑ j ∈ s, x j)] + _ ≤ _ := by simpa only [mul_comm] using hs + +variable {I : Type*} [DecidableEq I] + +theorem sum_neighbors_le (rows cols : I → Finset I) + (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) (N : ℕ) + (hc : ∀ j, (cols j).card ≤ N) (S : Finset I) (f : I → ℝ) + (hf : ∀ j, 0 ≤ f j) : + ∑ i ∈ S, ∑ j ∈ rows i, f j ≤ (N : ℝ) * ∑ j ∈ S.biUnion rows, f j := by + let T := S.biUnion rows + have heq : (∑ i ∈ S, ∑ j ∈ rows i, f j) = + ∑ j ∈ T, ((S.filter (fun i => j ∈ rows i)).card : ℝ) * f j := by + calc + _ = ∑ i ∈ S, ∑ j ∈ T, if j ∈ rows i then f j else 0 := by + apply Finset.sum_congr rfl + intro i hi + calc + _ = ∑ j ∈ rows i, if j ∈ rows i then f j else 0 := by simp + _ = _ := Finset.sum_subset + (fun j hj => Finset.mem_biUnion.mpr ⟨i, hi, hj⟩) + (by intro j hj hjnot; simp [hjnot]) + _ = ∑ j ∈ T, ∑ i ∈ S, if j ∈ rows i then f j else 0 := Finset.sum_comm + _ = _ := by simp [← Finset.sum_filter, Finset.sum_const, nsmul_eq_mul] + rw [heq, Finset.mul_sum] + apply Finset.sum_le_sum + intro j hj + apply mul_le_mul_of_nonneg_right _ (hf j) + exact_mod_cast (Finset.card_le_card (show S.filter (fun i => j ∈ rows i) ⊆ cols j from + fun i hi => (hdual i j).mp (Finset.mem_filter.mp hi).2)).trans (hc j) + +variable {E : I → Type*} [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace ℂ (E i)] + +def matrixRow (rows : I → Finset I) (A : ∀ i j, E j →L[ℂ] E i) + (x : lp E 2) (i : I) : E i := ∑ j ∈ rows i, A i j (x j) + +omit [DecidableEq I] in +theorem matrixRow_norm_sq (rows : I → Finset I) (A : ∀ i j, E j →L[ℂ] E i) + (N : ℕ) (C : ℝ) (_hC : 0 ≤ C) (hr : ∀ i, (rows i).card ≤ N) + (hA : ∀ i j, j ∈ rows i → ‖A i j‖ ≤ C) (x : lp E 2) (i : I) : + ‖matrixRow rows A x i‖ ^ 2 ≤ (N : ℝ) * C ^ 2 * ∑ j ∈ rows i, ‖x j‖ ^ 2 := by + have hentry (j : I) (hj : j ∈ rows i) : ‖A i j (x j)‖ ≤ C * ‖x j‖ := + (A i j).le_opNorm _ |>.trans (mul_le_mul_of_nonneg_right (hA i j hj) (norm_nonneg _)) + calc + _ ≤ ((rows i).card : ℝ) * ∑ j ∈ rows i, ‖A i j (x j)‖ ^ 2 := + norm_sum_sq_le_card _ _ + _ ≤ (N : ℝ) * ∑ j ∈ rows i, (C * ‖x j‖) ^ 2 := by + refine mul_le_mul (by exact_mod_cast hr i) ?_ + (Finset.sum_nonneg (fun _ _ => sq_nonneg _)) (Nat.cast_nonneg N) + apply Finset.sum_le_sum + intro j hj + gcongr + exact hentry j hj + _ = _ := by simp only [mul_pow, ← Finset.mul_sum]; ring + +theorem matrix_finite_norm_sq (rows cols : I → Finset I) + (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) (A : ∀ i j, E j →L[ℂ] E i) + (N : ℕ) (C : ℝ) (hC : 0 ≤ C) + (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) + (hA : ∀ i j, j ∈ rows i → ‖A i j‖ ≤ C) (x : lp E 2) (S : Finset I) : + ∑ i ∈ S, ‖matrixRow rows A x i‖ ^ 2 ≤ ((N : ℝ) * C * ‖x‖) ^ 2 := by + calc + _ ≤ ∑ i ∈ S, (N : ℝ) * C ^ 2 * ∑ j ∈ rows i, ‖x j‖ ^ 2 := + Finset.sum_le_sum (fun i _ => matrixRow_norm_sq rows A N C hC hr hA x i) + _ = (N : ℝ) * C ^ 2 * ∑ i ∈ S, ∑ j ∈ rows i, ‖x j‖ ^ 2 := + (Finset.mul_sum ..).symm + _ ≤ (N : ℝ) * C ^ 2 * ((N : ℝ) * ∑ j ∈ S.biUnion rows, ‖x j‖ ^ 2) := by + exact mul_le_mul_of_nonneg_left (sum_neighbors_le rows cols hdual N hc S + (fun j => ‖x j‖ ^ 2) (fun _ => sq_nonneg _)) (by positivity) + _ ≤ (N : ℝ) * C ^ 2 * ((N : ℝ) * ‖x‖ ^ 2) := by + gcongr + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.sum_rpow_le_norm_rpow (p := 2) (by norm_num) x (S.biUnion rows) + _ = _ := by ring + +def controlledMatrixLinear (rows cols : I → Finset I) + (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) (A : ∀ i j, E j →L[ℂ] E i) + (N : ℕ) (C : ℝ) (hC : 0 ≤ C) + (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) + (hA : ∀ i j, j ∈ rows i → ‖A i j‖ ≤ C) : lp E 2 →ₗ[ℂ] lp E 2 where + toFun x := ⟨matrixRow rows A x, by + apply memℓp_gen' + intro S + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + matrix_finite_norm_sq rows cols hdual A N C hC hr hc hA x S⟩ + map_add' x y := by + apply lp.ext + funext i + change (∑ j ∈ rows i, A i j (x j + y j)) = + (∑ j ∈ rows i, A i j (x j)) + ∑ j ∈ rows i, A i j (y j) + simp only [map_add, Finset.sum_add_distrib] + map_smul' c x := by + apply lp.ext + funext i + simp [matrixRow, map_smul, Finset.smul_sum] + +theorem controlledMatrixLinear_norm_le (rows cols : I → Finset I) + (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) (A : ∀ i j, E j →L[ℂ] E i) + (N : ℕ) (C : ℝ) (hC : 0 ≤ C) + (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) + (hA : ∀ i j, j ∈ rows i → ‖A i j‖ ≤ C) (x : lp E 2) : + ‖controlledMatrixLinear rows cols hdual A N C hC hr hc hA x‖ ≤ (N : ℝ) * C * ‖x‖ := by + apply lp.norm_le_of_forall_sum_le (by norm_num) (by positivity) + intro S + change (∑ i ∈ S, ‖matrixRow rows A x i‖ ^ (2 : ENNReal).toReal) ≤ + ((N : ℝ) * C * ‖x‖) ^ (2 : ENNReal).toReal + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + matrix_finite_norm_sq rows cols hdual A N C hC hr hc hA x S + +def controlledMatrix (rows cols : I → Finset I) + (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) (A : ∀ i j, E j →L[ℂ] E i) + (N : ℕ) (C : ℝ) (hC : 0 ≤ C) + (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) + (hA : ∀ i j, j ∈ rows i → ‖A i j‖ ≤ C) : lp E 2 →L[ℂ] lp E 2 := + (controlledMatrixLinear rows cols hdual A N C hC hr hc hA).mkContinuous ((N : ℝ) * C) + (controlledMatrixLinear_norm_le rows cols hdual A N C hC hr hc hA) + +theorem controlledMatrix_norm_le (rows cols : I → Finset I) + (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) (A : ∀ i j, E j →L[ℂ] E i) + (N : ℕ) (C : ℝ) (hC : 0 ≤ C) + (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) + (hA : ∀ i j, j ∈ rows i → ‖A i j‖ ≤ C) : + ‖controlledMatrix rows cols hdual A N C hC hr hc hA‖ ≤ (N : ℝ) * C := by + apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) + exact controlledMatrixLinear_norm_le rows cols hdual A N C hC hr hc hA + +@[simp] theorem controlledMatrix_apply (rows cols : I → Finset I) + (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) (A : ∀ i j, E j →L[ℂ] E i) + (N : ℕ) (C : ℝ) (hC : 0 ≤ C) + (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) + (hA : ∀ i j, j ∈ rows i → ‖A i j‖ ≤ C) (x : lp E 2) (i : I) : + controlledMatrix rows cols hdual A N C hC hr hc hA x i = ∑ j ∈ rows i, A i j (x j) := rfl + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledRipsCoarsening.lean b/lean/OAI/Topology/CoarseAssembly/ControlledRipsCoarsening.lean new file mode 100644 index 0000000000000000000000000000000000000000..c5e6049ec10372cd52efe562e129ceb730d1913c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledRipsCoarsening.lean @@ -0,0 +1,139 @@ +import OAI.Topology.CoarseAssembly.ControlledRipsCoordinates +import OAI.Topology.CoarseAssembly.RipsScaleCompatibility + +namespace OAI + +/-! # Coarsening and the constructed controlled assembly homomorphism -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r s : ℝ} + +def ControlledCycleFamily.coarsen (hrs : r ≤ s) (c : ControlledCycleFamily Q r) : + ControlledCycleFamily Q s where + cycle i := coarsenedCycle hrs (c.cycle i) + unital i := coarsenedCycle_unital hrs (c.cycle i) (c.unital i) + selfAdjoint := c.selfAdjoint + bound := c.bound + bound_nonneg := c.bound_nonneg + norm_le := c.norm_le + +def ControlledFamilyHomotopy.coarsen (hrs : r ≤ s) (h : ControlledFamilyHomotopy Q r) : + ControlledFamilyHomotopy Q s where + homotopy i := (h.homotopy i).precomp (scaleFunctionHom hrs).toNonUnitalStarAlgHom + unital t i := coarsenedCycle_unital hrs ((h.homotopy i).eval t) (h.unital t i) + selfAdjoint := h.selfAdjoint + bound := h.bound + bound_nonneg := h.bound_nonneg + norm_le := h.norm_le + operator_continuous := h.operator_continuous + partition_continuous := h.partition_continuous + +theorem ControlledFamilyHomotopy.coarsen_eval (hrs : r ≤ s) + (h : ControlledFamilyHomotopy Q r) (t : Interval) : + (h.coarsen hrs).eval t = (h.eval t).coarsen hrs := rfl + +theorem controlled_coarsen_relation (hrs : r ≤ s) + {z : FreeAbelianGroup (ControlledCycleFamily Q r)} (hz : ControlledCycleRelation z) : + FreeAbelianGroup.lift (fun c => controlledClass (c.coarsen hrs)) z = 0 := by + cases hz with + | degenerate c h => + have hz := controlled_relation_zero (ControlledCycleRelation.degenerate (c.coarsen hrs) + (fun i => (h i).precomp (scaleFunctionHom hrs).toNonUnitalStarAlgHom)) + simpa only [FreeAbelianGroup.lift_apply_of, controlledClass] using hz + | unitary c d h => + have hz := controlled_relation_zero (ControlledCycleRelation.unitary (c.coarsen hrs) (d.coarsen hrs) + (fun i => (h i).precomp (scaleFunctionHom hrs).toNonUnitalStarAlgHom)) + simpa only [map_sub, FreeAbelianGroup.lift_apply_of, controlledClass, + QuotientAddGroup.mk_sub] using hz + | directSum c d e h => + have hz := controlled_relation_zero (ControlledCycleRelation.directSum + (c.coarsen hrs) (d.coarsen hrs) (e.coarsen hrs) + (fun i => (h i).precomp (scaleFunctionHom hrs).toNonUnitalStarAlgHom)) + simpa only [map_sub, map_add, FreeAbelianGroup.lift_apply_of, controlledClass, + QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using hz + | homotopy h => + have hz := controlled_relation_zero (ControlledCycleRelation.homotopy (h.coarsen hrs)) + simpa only [map_sub, FreeAbelianGroup.lift_apply_of, controlledClass, + QuotientAddGroup.mk_sub, ControlledFamilyHomotopy.coarsen_eval] using hz + +def controlledCoarsening (hrs : r ≤ s) : ControlledK Q r →+ ControlledK Q s := + QuotientAddGroup.lift (controlledRelations Q r) + (FreeAbelianGroup.lift (fun c => controlledClass (c.coarsen hrs))) + ((AddSubgroup.closure_le _).2 (fun _ hz => controlled_coarsen_relation hrs hz)) + +@[simp] theorem controlledCoarsening_class (hrs : r ≤ s) (c : ControlledCycleFamily Q r) : + controlledCoarsening hrs (controlledClass c) = controlledClass (c.coarsen hrs) := + FreeAbelianGroup.lift_apply_of _ _ + +theorem controlled_hom_ext {D : Type*} [AddCommGroup D] + (f g : ControlledK Q r →+ D) + (h : ∀ c, f (controlledClass c) = g (controlledClass c)) : f = g := by + apply QuotientAddGroup.addMonoidHom_ext + exact FreeAbelianGroup.lift_ext _ _ h + +omit [∀ i, DecidableEq (Q i)] in +@[simp] theorem ControlledCycleFamily.coarsen_refl (c : ControlledCycleFamily Q r) : + c.coarsen le_rfl = c := by + cases c + rfl + +omit [∀ i, DecidableEq (Q i)] in +theorem ControlledCycleFamily.coarsen_comp {t : ℝ} (hrs : r ≤ s) (hst : s ≤ t) + (c : ControlledCycleFamily Q r) : + (c.coarsen hrs).coarsen hst = c.coarsen (hrs.trans hst) := by + cases c + rfl + +@[simp] theorem controlledCoarsening_refl : + controlledCoarsening (Q := Q) (r := r) le_rfl = AddMonoidHom.id (ControlledK Q r) := by + apply controlled_hom_ext + intro c + simp only [controlledCoarsening_class, ControlledCycleFamily.coarsen_refl, + AddMonoidHom.id_apply] + +theorem controlledCoarsening_comp {t : ℝ} (hrs : r ≤ s) (hst : s ≤ t) : + (controlledCoarsening (Q := Q) hst).comp (controlledCoarsening hrs) = + controlledCoarsening (hrs.trans hst) := by + apply controlled_hom_ext + intro c + simp only [AddMonoidHom.comp_apply, controlledCoarsening_class, + ControlledCycleFamily.coarsen_comp] + +/-- Scale compatibility holds for the whole constructed map on the quotient, +not only for its chosen cycle representatives. -/ +theorem controlledAssembly_coarsening (o : ∀ i, Q i) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hrs : r ≤ s) : + letI := separatedMetric o + letI : Ring (Unitization ℂ + (DiscreteRoe.algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := inferInstance + (controlledAssembly o hs).comp (controlledCoarsening hrs) = controlledAssembly o hr := by + let := separatedMetric o + let : Ring (Unitization ℂ + (DiscreteRoe.algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := inferInstance + apply controlled_hom_ext + intro c + simp only [AddMonoidHom.comp_apply, controlledCoarsening_class, controlledAssembly_class] + exact ampleRipsFamilyBoundary_scale hrs o hr hs c.cycle c.unital c.selfAdjoint + c.bound c.bound_nonneg c.norm_le + +theorem controlledCoordinate_coarsening (i : ℕ) (hrs : r ≤ s) : + (controlledCoordinate i).comp (controlledCoarsening (Q := Q) hrs) = + (Analytic.precomp (scaleFunctionHom hrs).toNonUnitalStarAlgHom).comp + (controlledCoordinate i) := by + apply controlled_hom_ext + intro c + simp only [AddMonoidHom.comp_apply, controlledCoarsening_class, controlledCoordinate_class, + Analytic.precomp_cycleClass] + rfl + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledRipsCoordinates.lean b/lean/OAI/Topology/CoarseAssembly/ControlledRipsCoordinates.lean new file mode 100644 index 0000000000000000000000000000000000000000..81fcd849b530586a5959a7b88e87ce918ee44624 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledRipsCoordinates.lean @@ -0,0 +1,51 @@ +import OAI.Topology.CoarseAssembly.ControlledRipsCycles + +namespace OAI + +/-! # The analytic coordinates of a controlled family class -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +def controlledCoordinateFree (i : ℕ) : + FreeAbelianGroup (ControlledCycleFamily Q r) →+ OddK C(Point (Q i) r, ℂ) := + FreeAbelianGroup.lift (fun c => cycleClass _ (c.cycle i)) + +theorem controlledCoordinateFree_relation (i : ℕ) + {z : FreeAbelianGroup (ControlledCycleFamily Q r)} (hz : ControlledCycleRelation z) : + controlledCoordinateFree i z = 0 := by + cases hz with + | degenerate c h => + simpa only [controlledCoordinateFree, FreeAbelianGroup.lift_apply_of] using + degenerate_zero (c.cycle i) (h i) + | unitary c d h => + simp only [controlledCoordinateFree, map_sub, FreeAbelianGroup.lift_apply_of] + exact sub_eq_zero.mpr (unitary_eq _ _ (h i)) + | directSum c d e h => + simp only [controlledCoordinateFree, map_sub, map_add, FreeAbelianGroup.lift_apply_of] + exact sub_eq_zero.mpr (directSum_eq _ _ _ (h i)) + | homotopy h => + simp only [controlledCoordinateFree, map_sub, FreeAbelianGroup.lift_apply_of] + exact sub_eq_zero.mpr (homotopy_eq (h.homotopy i)) + +/-- Ordinary analytic K-homology of each compact component. Injectivity or +surjectivity of the resulting coordinate family is not asserted here. -/ +def controlledCoordinate (i : ℕ) : ControlledK Q r →+ OddK C(Point (Q i) r, ℂ) := + QuotientAddGroup.lift (controlledRelations Q r) (controlledCoordinateFree i) + ((AddSubgroup.closure_le _).2 (fun _ hz => controlledCoordinateFree_relation i hz)) + +@[simp] theorem controlledCoordinate_class (i : ℕ) (c : ControlledCycleFamily Q r) : + controlledCoordinate i (controlledClass c) = cycleClass _ (c.cycle i) := + FreeAbelianGroup.lift_apply_of _ _ + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ControlledRipsCycles.lean b/lean/OAI/Topology/CoarseAssembly/ControlledRipsCycles.lean new file mode 100644 index 0000000000000000000000000000000000000000..f399bfa1f10ba237f9799f3f368f5a8d26c94e44 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ControlledRipsCycles.lean @@ -0,0 +1,136 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsUniformHomotopy +import OAI.Topology.CoarseAssembly.RipsUnitaryFamily +import OAI.Topology.CoarseAssembly.RipsDirectSumBoundary +import OAI.Topology.CoarseAssembly.RipsBoundaryDegeneracy + +namespace OAI + +/-! # Controlled analytic cycles for the separated finite-component application + +This intermediate cycle group retains uniform analytic homotopy control. +Its map to ordinary analytic coordinates is constructed explicitly; no +identification with the full locally finite analytic group is assumed. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe Filter Topology + +variable (Q : ℕ → Type) [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] (r : ℝ) + +structure ControlledFamilyHomotopy where + homotopy : ∀ i, OddHomotopy C(Point (Q i) r, ℂ) + unital : ∀ t i, ((homotopy i).eval t).representation 1 = 1 + selfAdjoint : ∀ t i, IsSelfAdjoint ((homotopy i).eval t).operator + bound : ℝ + bound_nonneg : 0 ≤ bound + norm_le : ∀ t i, ‖(homotopy i).operator t‖ ≤ bound + operator_continuous : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, + ‖(homotopy i).operator s - (homotopy i).operator t‖ ≤ ε + partition_continuous : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, + ‖(show (homotopy i).space →L[ℂ] Module (Q i) (homotopy i).space from + partitionMap (representedSqrt r ((homotopy i).eval s))) - + (show (homotopy i).space →L[ℂ] Module (Q i) (homotopy i).space from + partitionMap (representedSqrt r ((homotopy i).eval t)))‖ ≤ ε + +variable {Q r} + +def ControlledFamilyHomotopy.eval (h : ControlledFamilyHomotopy Q r) (t : Interval) : + ControlledCycleFamily Q r where + cycle i := (h.homotopy i).eval t + unital := h.unital t + selfAdjoint := h.selfAdjoint t + bound := h.bound + bound_nonneg := h.bound_nonneg + norm_le := h.norm_le t + +inductive ControlledCycleRelation : FreeAbelianGroup (ControlledCycleFamily Q r) → Prop + | degenerate (c : ControlledCycleFamily Q r) (h : ∀ i, (c.cycle i).Degenerate) : + ControlledCycleRelation (FreeAbelianGroup.of c) + | unitary (c d : ControlledCycleFamily Q r) + (h : ∀ i, (c.cycle i).UnitaryEquivalent (d.cycle i)) : + ControlledCycleRelation (FreeAbelianGroup.of c - FreeAbelianGroup.of d) + | directSum (c d e : ControlledCycleFamily Q r) + (h : ∀ i, (c.cycle i).IsDirectSum (d.cycle i) (e.cycle i)) : + ControlledCycleRelation (FreeAbelianGroup.of e - (FreeAbelianGroup.of c + FreeAbelianGroup.of d)) + | homotopy (h : ControlledFamilyHomotopy Q r) : + ControlledCycleRelation (FreeAbelianGroup.of (h.eval start) - FreeAbelianGroup.of (h.eval finish)) + +def controlledRelations (Q : ℕ → Type) [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] (r : ℝ) : AddSubgroup (FreeAbelianGroup (ControlledCycleFamily Q r)) := + AddSubgroup.closure {z | ControlledCycleRelation z} + +abbrev ControlledK (Q : ℕ → Type) [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] (r : ℝ) := + FreeAbelianGroup (ControlledCycleFamily Q r) ⧸ controlledRelations Q r + +def controlledClass (c : ControlledCycleFamily Q r) : ControlledK Q r := + QuotientAddGroup.mk (FreeAbelianGroup.of c) + +theorem controlled_relation_zero {z : FreeAbelianGroup (ControlledCycleFamily Q r)} + (hz : ControlledCycleRelation z) : (QuotientAddGroup.mk z : ControlledK Q r) = 0 := + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz) + +def controlledBoundaryFree (o : ∀ i, Q i) (hr : 0 ≤ r) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + FreeAbelianGroup (ControlledCycleFamily Q r) →+ + OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := + FreeAbelianGroup.lift (fun c => c.boundary o hr) + +theorem controlledBoundaryFree_relation (o : ∀ i, Q i) (hr : 0 ≤ r) + {z : FreeAbelianGroup (ControlledCycleFamily Q r)} (hz : ControlledCycleRelation z) : + controlledBoundaryFree o hr z = 0 := by + let := separatedMetric o + cases hz with + | degenerate c h => + simpa only [controlledBoundaryFree, FreeAbelianGroup.lift_apply_of, + ControlledCycleFamily.boundary] using + ampleRipsFamilyBoundary_degenerate o r hr c.cycle c.unital c.selfAdjoint + c.bound c.bound_nonneg c.norm_le h + | unitary c d h => + simp only [controlledBoundaryFree, map_sub, FreeAbelianGroup.lift_apply_of] + apply sub_eq_zero.mpr + exact ampleRipsFamilyBoundary_unitary o r hr c.cycle d.cycle h c.unital d.unital + c.selfAdjoint d.selfAdjoint c.bound d.bound c.bound_nonneg d.bound_nonneg c.norm_le d.norm_le + | directSum c d e h => + simp only [controlledBoundaryFree, map_sub, map_add, FreeAbelianGroup.lift_apply_of] + apply sub_eq_zero.mpr + exact ampleRipsFamilyBoundary_directSum o r hr c.cycle d.cycle e.cycle h + c.unital d.unital e.unital c.selfAdjoint d.selfAdjoint e.selfAdjoint + c.bound d.bound e.bound c.bound_nonneg d.bound_nonneg e.bound_nonneg c.norm_le d.norm_le e.norm_le + | homotopy h => + simp only [controlledBoundaryFree, map_sub, FreeAbelianGroup.lift_apply_of] + apply sub_eq_zero.mpr + exact ampleRipsFamilyBoundary_uniformHomotopy o r hr h.homotopy h.unital h.selfAdjoint + h.bound h.bound_nonneg h.norm_le h.operator_continuous h.partition_continuous + +/-- The constructed whole-union Roe boundary descends through every relation +of this controlled analytic cycle model. -/ +def controlledAssembly (o : ∀ i, Q i) (hr : 0 ≤ r) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + ControlledK Q r →+ OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := + by + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + exact QuotientAddGroup.lift (controlledRelations Q r) (controlledBoundaryFree o hr) + ((AddSubgroup.closure_le _).2 (fun _ hz => controlledBoundaryFree_relation o hr hz)) + +@[simp] theorem controlledAssembly_class (o : ∀ i, Q i) (hr : 0 ≤ r) + (c : ControlledCycleFamily Q r) : + controlledAssembly o hr (controlledClass c) = c.boundary o hr := + FreeAbelianGroup.lift_apply_of _ _ + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CountableAdditivity.lean b/lean/OAI/Topology/CoarseAssembly/CountableAdditivity.lean new file mode 100644 index 0000000000000000000000000000000000000000..f588f65f5b29870a5accf669157b17b4ebd0f7d8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CountableAdditivity.lean @@ -0,0 +1,75 @@ +import OAI.Topology.CoarseAssembly.ClopenRestriction +import Mathlib.Topology.Constructions + +namespace OAI + +/-! # Countable additivity in the first KK variable + +The coordinate maps below are the proved extension-by-zero restrictions +on actual Fredholm-module groups. The sole published input is their +bijectivity: Blackadar, *K-Theory for Operator Algebras*, 2nd ed. (1998), +Theorem 19.7.1, for a countable disjoint union of compact metrizable spaces. +Construction of a family class and vanishing from vanishing coordinates +are consequences, not assumed inputs. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Topology + +variable (Y : ℕ → Type) [∀ j, TopologicalSpace (Y j)] + +def sigmaComponent (j : ℕ) : Y j ↪ Sigma Y := ⟨Sigma.mk j, sigma_mk_injective⟩ + +theorem sigmaComponent_open (j : ℕ) : IsOpenEmbedding (sigmaComponent Y j) := + IsOpenEmbedding.sigmaMk + +variable [∀ j, CompactSpace (Y j)] [∀ j, T2Space (Y j)] + +def sigmaCoordinates : LocallyFiniteK1 (Sigma Y) →+ (∀ j, LocallyFiniteK1 (Y j)) where + toFun a j := restrictComponent (sigmaComponent Y j) (sigmaComponent_open Y j) a + map_zero' := by funext j; exact map_zero _ + map_add' a b := by funext j; exact map_add _ _ _ + +/-- The exact countable-additivity specialization used in this application. +This is a published input on a specified family of spaces. -/ +def CountableAdditivityInput : Prop := Function.Bijective (sigmaCoordinates Y) + +def sigmaKKEquiv (h : CountableAdditivityInput Y) : + LocallyFiniteK1 (Sigma Y) ≃+ (∀ j, LocallyFiniteK1 (Y j)) := + AddEquiv.ofBijective (sigmaCoordinates Y) h + +/-- Assemble an integral family before any tensoring with the rationals. -/ +def familyClass (h : CountableAdditivityInput Y) (a : ∀ j, LocallyFiniteK1 (Y j)) : + LocallyFiniteK1 (Sigma Y) := (sigmaKKEquiv Y h).symm a + +@[simp] theorem familyClass_coordinate (h : CountableAdditivityInput Y) + (a : ∀ j, LocallyFiniteK1 (Y j)) (j : ℕ) : + restrictComponent (sigmaComponent Y j) (sigmaComponent_open Y j) + (familyClass Y h a) = a j := by + exact congrFun ((sigmaKKEquiv Y h).apply_symm_apply a) j + +theorem eq_zero_of_coordinates (h : CountableAdditivityInput Y) + (a : LocallyFiniteK1 (Sigma Y)) + (ha : ∀ j, restrictComponent (sigmaComponent Y j) (sigmaComponent_open Y j) a = 0) : + a = 0 := by + apply h.injective + ext j + change restrictComponent (sigmaComponent Y j) (sigmaComponent_open Y j) a = + restrictComponent (sigmaComponent Y j) (sigmaComponent_open Y j) 0 + rw [ha j, map_zero] + +theorem sigma_group_subsingleton (h : CountableAdditivityInput Y) + [∀ j, Subsingleton (LocallyFiniteK1 (Y j))] : + Subsingleton (LocallyFiniteK1 (Sigma Y)) := by + refine ⟨fun a b => h.injective ?_⟩ + ext j + exact Subsingleton.elim _ _ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CountableHilbertSum.lean b/lean/OAI/Topology/CoarseAssembly/CountableHilbertSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..eb35258b3b22965d310a5e0c1574015dc79d1c54 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CountableHilbertSum.lean @@ -0,0 +1,72 @@ +import OAI.Topology.CoarseAssembly.BilateralShift +import Mathlib.Topology.DenseEmbedding + +namespace OAI + +/-! # Separable countable sums of the Hilbert spaces in analytic cycles -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open TopologicalSpace + +variable (H : ℕ → HilbertSpace) + +abbrev HilbertSum := lp (fun j => H j) 2 + +instance hilbertSum_secondCountable : SecondCountableTopology (HilbertSum H) := by + let v : ℕ × ℕ → HilbertSum H := fun p => lp.single 2 p.1 (denseSeq (H p.1) p.2) + let P : Submodule ℂ (HilbertSum H) := (Submodule.span ℂ (Set.range v)).topologicalClosure + have hc : IsClosed (P : Set (HilbertSum H)) := Submodule.isClosed_topologicalClosure _ + have hsingle (j : ℕ) (x : H j) : lp.single 2 j x ∈ P := by + refine (denseRange_denseSeq (H j)).induction_on x + (hc.preimage (lp.singleContinuousLinearMap ℂ (fun j => H j) 2 j).continuous) ?_ + intro n + apply Submodule.le_topologicalClosure + exact Submodule.subset_span ⟨(j, n), rfl⟩ + have htop : P = ⊤ := by + apply top_unique + intro x _ + apply hc.mem_of_tendsto (lp.hasSum_single ENNReal.ofNat_ne_top x) + exact Filter.Eventually.of_forall (fun s => Submodule.sum_mem P (fun j _ => hsingle j (x j))) + have hs := ((Set.countable_range v).isSeparable.span (R := ℂ)).closure + change IsSeparable (P : Set (HilbertSum H)) at hs + rw [htop] at hs + have : SeparableSpace (HilbertSum H) := isSeparable_univ_iff.mp hs + infer_instance + +abbrev countableHilbertSpace : HilbertSpace where + Carrier := HilbertSum H + normed := inferInstance + inner := inferInstance + complete := inferInstance + secondCountable := inferInstance + +/-- The inclusion of an individual Hilbert summand. -/ +def summandIsometry (j : ℕ) : H j →ₗᵢ[ℂ] countableHilbertSpace H where + toFun x := lp.single (E := fun j => H j) 2 j x + map_add' x y := lp.single_add (E := fun j => H j) 2 j x y + map_smul' z x := by + simpa only [RingHom.id_apply] using + (lp.single_smul (𝕜 := ℂ) (E := fun j => H j) 2 j z x) + norm_map' x := lp.norm_single (E := fun j => H j) (by norm_num : (0 : ENNReal) < 2) j x + +@[simp] theorem summandIsometry_apply (j : ℕ) (x : H j) : + summandIsometry H j x = lp.single (E := fun j => H j) 2 j x := rfl + +/-- Coordinate evaluation is the adjoint of summand inclusion. -/ +theorem summandIsometry_adjoint (j : ℕ) : + (summandIsometry H j).toContinuousLinearMap.adjoint = lp.evalCLM ℂ (fun j => H j) 2 j := by + apply ContinuousLinearMap.ext + intro x + apply ext_inner_left ℂ + intro y + rw [ContinuousLinearMap.adjoint_inner_right] + exact lp.inner_single_left (𝕜 := ℂ) (G := fun j => H j) j y x + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CycleCompactPerturbation.lean b/lean/OAI/Topology/CoarseAssembly/CycleCompactPerturbation.lean new file mode 100644 index 0000000000000000000000000000000000000000..39d9cc935237cfb5e52d6dc01cf5bcda34fea71b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CycleCompactPerturbation.lean @@ -0,0 +1,69 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.AnalyticKHomology +import Mathlib.Tactic.NoncommRing + +namespace OAI + +/-! # Compact changes of a Fredholm operator + +The straight-line path between operators differing by a compact operator +preserves all three Fredholm defects. This is the normalization step used +when discharging the odd coefficient and circle-index inputs. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem compact_mul_right {K : End H} (hK : IsCompactOperator K) (T : End H) : + IsCompactOperator (K * T) := hK.comp_clm T + +theorem compact_mul_left {K : End H} (hK : IsCompactOperator K) (T : End H) : + IsCompactOperator (T * K) := hK.clm_comp T + +variable {A : Type} [NonUnitalCStarAlgebra A] + +theorem compact_star_real_smul {K : End H} (hKs : IsCompactOperator (star K : End H)) (t : ℝ) : + IsCompactOperator (star (t • K) : End H) := by + rw [star_smul, star_trivial] + exact hKs.smul t + +def OddCycle.compactPerturbHomotopy (c : OddCycle A) (K : End c.space) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End c.space)) : OddHomotopy A where + space := c.space + representation _ := c.representation + operator t := c.operator + (t : ℝ) • K + continuous_representation _ := continuous_const + continuous_operator := continuous_const.add (continuous_subtype_val.smul continuous_const) + commutator_compact t a := + (c.compactPerturb ((t : ℝ) • K) (hK.smul _) (compact_star_real_smul hKs _)).commutator_compact a + square_compact t a := + (c.compactPerturb ((t : ℝ) • K) (hK.smul _) (compact_star_real_smul hKs _)).square_compact a + adjoint_compact t a := + (c.compactPerturb ((t : ℝ) • K) (hK.smul _) (compact_star_real_smul hKs _)).adjoint_compact a + +theorem OddCycle.compactPerturbHomotopy_start (c : OddCycle A) (K : End c.space) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End c.space)) : + (c.compactPerturbHomotopy K hK hKs).eval start = c := by + cases c + simp only [compactPerturbHomotopy, OddHomotopy.eval, start, zero_smul, add_zero] + +theorem OddCycle.compactPerturbHomotopy_finish (c : OddCycle A) (K : End c.space) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End c.space)) : + (c.compactPerturbHomotopy K hK hKs).eval finish = c.compactPerturb K hK hKs := by + simp only [compactPerturbHomotopy, OddHomotopy.eval, finish, compactPerturb, one_smul] + +theorem compactPerturb_class (c : OddCycle A) (K : End c.space) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End c.space)) : + cycleClass A (c.compactPerturb K hK hKs) = cycleClass A c := by + have hh := homotopy_eq (c.compactPerturbHomotopy K hK hKs) + rw [c.compactPerturbHomotopy_start, c.compactPerturbHomotopy_finish] at hh + exact hh.symm + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CycleDirectSumNormalization.lean b/lean/OAI/Topology/CoarseAssembly/CycleDirectSumNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..1f5618a7a1b1e8455f348c3f9d448601f8845ab4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CycleDirectSumNormalization.lean @@ -0,0 +1,68 @@ +import OAI.Topology.CoarseAssembly.CycleUnitaryNormalization +import OAI.Topology.CoarseAssembly.DirectSumIndex + +namespace OAI + +/-! # Direct sums are preserved by explicit cycle normalization -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +theorem boundedTransform_prod (F : A) (G : B) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + boundedTransform (F, G) (Prod.ext hF.star_eq hG.star_eq) = + (boundedTransform F hF, boundedTransform G hG) := by + apply Prod.ext + · exact map_boundedTransform (StarAlgHom.fst ℂ A B) (F, G) _ + · exact map_boundedTransform (StarAlgHom.snd ℂ A B) (F, G) _ + +variable {R : Type} [CStarAlgebra R] {c d e : OddCycle R} + +theorem OddCycle.IsDirectSum.block_boundedTransform (h : c.IsDirectSum d e) + (F : End c.space) (G : End d.space) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + h.block (boundedTransform F hF) (boundedTransform G hG) = + boundedTransform (h.block F G) ((show IsSelfAdjoint (F, G) from Prod.ext hF.star_eq hG.star_eq).map h.blockHom) := by + have hb := map_boundedTransform h.blockHom (F, G) (Prod.ext hF.star_eq hG.star_eq) + rw [boundedTransform_prod] at hb + exact hb + +def OddCycle.IsDirectSum.regularize (h : c.IsDirectSum d e) (χ : R →⋆ₐ[ℂ] ℂ) : + (c.regularize χ).IsDirectSum (d.regularize χ) (e.regularize χ) where + left := h.left + right := h.right + orthogonal := h.orthogonal + exhaustive := h.exhaustive + representation_eq a := by + let φ := h.blockHom + have hr (a : R) : h.block (c.representation a) (d.representation a) = e.representation a := + (h.representation_eq a).symm + change e.representation a + χ a • (1 - e.representation 1) = + φ ((c.representation a, d.representation a) + + χ a • (1 - (c.representation 1, d.representation 1))) + rw [map_add, map_smul, map_sub, map_one φ] + change e.representation a + χ a • (1 - e.representation 1) = + h.block (c.representation a) (d.representation a) + + χ a • (1 - h.block (c.representation 1) (d.representation 1)) + rw [hr a, hr 1] + operator_eq := by + have hc := c.unitalSelfAdjoint_selfAdjoint χ + have hd := d.unitalSelfAdjoint_selfAdjoint χ + have he := e.unitalSelfAdjoint_selfAdjoint χ + have hcut : h.block (c.unitalSelfAdjoint χ).operator (d.unitalSelfAdjoint χ).operator = + (e.unitalSelfAdjoint χ).operator := by + have hr : h.block (c.representation 1) (d.representation 1) = e.representation 1 := + (h.representation_eq 1).symm + have ho : h.block c.operator d.operator = e.operator := h.operator_eq.symm + rw [c.unitalSelfAdjoint_operator, d.unitalSelfAdjoint_operator, + e.unitalSelfAdjoint_operator, h.block_cutDown, hr, ho] + have hb := h.block_boundedTransform (c.unitalSelfAdjoint χ).operator + (d.unitalSelfAdjoint χ).operator hc hd + exact (hb.trans (boundedTransform_congr hcut _ he)).symm + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CycleIndex.lean b/lean/OAI/Topology/CoarseAssembly/CycleIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..004f5ae87170e1bcfb85b86008f5adfefca71fd6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CycleIndex.lean @@ -0,0 +1,107 @@ +import OAI.Topology.CoarseAssembly.ToeplitzCompression +import Mathlib.Topology.Connected.TotallyDisconnected + +namespace OAI + +/-! # The scalar-unitary index of normalized odd cycles + +This constructs the Fredholm operator and its integer index. Descent to the +cycle quotient and the explicit circle-generator calculation are separate +steps; neither is assumed by these declarations. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +def positiveProjection (F : End H) : End H := (1 / 2 : ℝ) • (F + 1) + +theorem positiveProjection_selfAdjoint (F : End H) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (positiveProjection F) := by + change star ((1 / 2 : ℝ) • (F + 1)) = _ + rw [star_smul, star_trivial, star_add, hF.star_eq, star_one] + rfl + +theorem positiveProjection_sq (F : End H) (hF : F * F = 1) : + positiveProjection F * positiveProjection F = positiveProjection F := by + have he : (F + 1) * (F + 1) = (2 : ℝ) • (F + 1) := by + rw [add_mul, mul_add, mul_add, hF, one_mul, mul_one, one_mul] + module + unfold positiveProjection + rw [smul_mul_assoc, mul_smul_comm, he] + module + +theorem positiveProjection_commutator (F U : End H) : + positiveProjection F * U - U * positiveProjection F = + (1 / 2 : ℝ) • (F * U - U * F) := by + simp only [positiveProjection, smul_mul_assoc, mul_smul_comm, add_mul, mul_add, + one_mul, mul_one] + module + +variable {A : Type} [CStarAlgebra A] + +def cycleToeplitz (c : OddCycle A) (u : A) : End c.space := + toeplitzCompression (positiveProjection c.operator) (c.representation u) + +def cycleIndex (c : OddCycle A) (u : A) : ℤ := (cycleToeplitz c u).toLinearMap.index + +theorem cycleToeplitz_fredholm (c : OddCycle A) (u : A) + (hunit : c.representation 1 = 1) (hself : IsSelfAdjoint c.operator) + (hsq : c.operator * c.operator = 1) (hul : star u * u = 1) (hur : u * star u = 1) : + (cycleToeplitz c u).IsFredholm := by + apply toeplitzCompression_fredholm _ _ (positiveProjection_selfAdjoint _ hself) + (positiveProjection_sq _ hsq) + · rw [← map_star, ← map_mul, hul, hunit] + · rw [← map_star, ← map_mul, hur, hunit] + · rw [positiveProjection_commutator] + exact (c.commutator_compact u).smul (1 / 2 : ℝ) + +theorem fredholmIndex_homotopy (T : Interval → End H) (hT : Continuous T) + (hf : ∀ t, (T t).IsFredholm) : + (T start).toLinearMap.index = (T finish).toLinearMap.index := by + have hc : Continuous (fun t => (T t).toLinearMap.index) := by + apply continuous_iff_continuousAt.mpr + intro t + exact (hf t).index_continuousAt.comp hT.continuousAt + exact IsPreconnected.constant isPreconnected_univ hc.continuousOn + (Set.mem_univ start) (Set.mem_univ finish) + +theorem cycleIndex_homotopy (h : OddHomotopy A) (u : A) + (hunit : ∀ t, h.representation t 1 = 1) + (hself : ∀ t, IsSelfAdjoint (h.operator t)) + (hsq : ∀ t, h.operator t * h.operator t = 1) + (hul : star u * u = 1) (hur : u * star u = 1) : + cycleIndex (h.eval start) u = cycleIndex (h.eval finish) u := by + apply fredholmIndex_homotopy (fun t => cycleToeplitz (h.eval t) u) + · change Continuous (fun t => positiveProjection (h.operator t) * h.representation t u * + positiveProjection (h.operator t) + (1 - positiveProjection (h.operator t))) + have hp : Continuous (fun t => positiveProjection (h.operator t)) := + (h.continuous_operator.add continuous_const).const_smul (1 / 2 : ℝ) + exact ((hp.mul (h.continuous_representation u)).mul hp).add (continuous_const.sub hp) + · intro t + exact cycleToeplitz_fredholm (h.eval t) u (hunit t) (hself t) (hsq t) hul hur + +theorem cycleIndex_degenerate (c : OddCycle A) (u : A) (hd : c.Degenerate) + (hunit : c.representation 1 = 1) (hself : IsSelfAdjoint c.operator) + (hsq : c.operator * c.operator = 1) (hul : star u * u = 1) (hur : u * star u = 1) : + cycleIndex c u = 0 := by + have hUl : star (c.representation u) * c.representation u = 1 := by + rw [← map_star, ← map_mul, hul, hunit] + have hUr : c.representation u * star (c.representation u) = 1 := by + rw [← map_star, ← map_mul, hur, hunit] + have hc : Commute (positiveProjection c.operator) (c.representation u) := by + apply sub_eq_zero.mp + rw [positiveProjection_commutator, hd.1 u, smul_zero] + obtain ⟨hl, hr⟩ := toeplitzCompression_unitary _ _ (positiveProjection_selfAdjoint _ hself) + (positiveProjection_sq _ hsq) hUl hUr hc + have hinv : (cycleToeplitz c u).IsInvertible := + ContinuousLinearMap.IsInvertible.of_inverse (g := star (cycleToeplitz c u)) hr hl + exact LinearMap.index_of_bijective hinv.bijective + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/CycleUnitaryNormalization.lean b/lean/OAI/Topology/CoarseAssembly/CycleUnitaryNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..a14a8c85bf222b98cb8837e7c171554dfb4da0cb --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/CycleUnitaryNormalization.lean @@ -0,0 +1,60 @@ +import OAI.Topology.CoarseAssembly.RegularizedCycle +import OAI.Topology.CoarseAssembly.BoundedTransformNaturality + +namespace OAI + +/-! # Unitary equivalence is preserved by explicit cycle normalization -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H K : HilbertSpace} + +theorem unitaryConjugation_eq (U : H ≃ₗᵢ[ℂ] K) (F : End H) : + U.conjStarAlgEquiv.toStarAlgHom F = operatorConjugation U.toLinearIsometry F := by + have hadj : U.toLinearIsometry.toContinuousLinearMap.adjoint = + U.symm.toLinearIsometry.toContinuousLinearMap := U.adjoint_eq_symm + change U.toLinearIsometry.toContinuousLinearMap.comp + (F.comp U.symm.toLinearIsometry.toContinuousLinearMap) = + U.toLinearIsometry.toContinuousLinearMap.comp + (F.comp U.toLinearIsometry.toContinuousLinearMap.adjoint) + rw [hadj] + +variable {A : Type} [CStarAlgebra A] {c d : OddCycle A} + +def OddCycle.UnitaryEquivalent.regularize (e : c.UnitaryEquivalent d) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.regularize χ).UnitaryEquivalent (d.regularize χ) where + unitary := e.unitary + representation_eq a := by + let φ : End c.space →⋆ₐ[ℂ] End d.space := e.unitary.conjStarAlgEquiv.toStarAlgHom + have hφ (T : End c.space) : φ T = operatorConjugation e.unitary.toLinearIsometry T := + unitaryConjugation_eq _ _ + have hr (a : A) : φ (c.representation a) = d.representation a := + (hφ _).trans (e.representation_eq a).symm + change d.representation a + χ a • (1 - d.representation 1) = + operatorConjugation e.unitary.toLinearIsometry + (c.representation a + χ a • (1 - c.representation 1)) + rw [← hφ] + simp only [map_add, map_smul, map_sub, map_one, hr] + operator_eq := by + let φ : End c.space →⋆ₐ[ℂ] End d.space := e.unitary.conjStarAlgEquiv.toStarAlgHom + have hφ (T : End c.space) : φ T = operatorConjugation e.unitary.toLinearIsometry T := + unitaryConjugation_eq _ _ + have hr : φ (c.representation 1) = d.representation 1 := + (hφ _).trans (e.representation_eq 1).symm + have hF : φ c.operator = d.operator := (hφ _).trans e.operator_eq.symm + have hG : (d.unitalSelfAdjoint χ).operator = φ (c.unitalSelfAdjoint χ).operator := by + rw [d.unitalSelfAdjoint_operator, c.unitalSelfAdjoint_operator, map_symmetricCutDown, hr, hF] + change boundedTransform (d.unitalSelfAdjoint χ).operator _ = + operatorConjugation e.unitary.toLinearIsometry + (boundedTransform (c.unitalSelfAdjoint χ).operator _) + rw [← hφ] + erw [map_boundedTransform] + exact boundedTransform_congr hG _ _ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Definitions.lean b/lean/OAI/Topology/CoarseAssembly/Definitions.lean new file mode 100644 index 0000000000000000000000000000000000000000..e0d6d3edf83b93843316a8bbabbee0e3ada84caf --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Definitions.lean @@ -0,0 +1,6634 @@ +import Mathlib + +open scoped Topology + +namespace OAI + +/-! # A bounded-geometry counterexample to coarse Novikov + +The concrete graph union has an infinite-order class killed by its +ordinary reduced coarse assembly map, including after rationalization. +-/ + +section + +noncomputable section + +namespace CoarseAssembly + +attribute [-instance] CStarAlgebra.toNormedRing CommCStarAlgebra.toNormedCommRing + +open Filter + +open scoped Topology + +variable {ι : Type*} {E F : ι → Type*} + +variable [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace ℂ (E i)] + +variable [∀ i, NormedAddCommGroup (F i)] [∀ i, NormedSpace ℂ (F i)] + +def blockLinear (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (_hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) : lp E 2 →ₗ[ℂ] lp F 2 where + toFun x := ⟨fun i => A i (x i), by + apply ((lp.memℓp x).norm.const_smul C).mono + intro i + exact (A i).le_opNorm (x i) |>.trans (mul_le_mul_of_nonneg_right (hA i) (norm_nonneg _))⟩ + map_add' x y := by ext i; exact map_add (A i) _ _ + map_smul' c x := by ext i; exact map_smul (A i) _ _ + +def blockOperator (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) : lp E 2 →L[ℂ] lp F 2 := by + classical + + exact (OAI.CoarseAssembly.blockLinear A C hC hA).mkContinuous C (( + let local_proof {ι : Type _} {E : ι → Type _} {F : ι → Type _} [inst_local_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_local_4 : (i : ι) → NormedSpace ℂ (E i)] [inst_local_5 : (i : ι) → NormedAddCommGroup (F i)] [inst_local_6 : (i : ι) → NormedSpace ℂ (F i)] (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (x : lp E 2) : + ‖OAI.CoarseAssembly.blockLinear A C hC hA x‖ ≤ C * ‖x‖ := + open OAI OAI.CoarseAssembly in + open Filter in + open scoped Topology in + by + calc + _ ≤ ‖C • lp.toNorm x‖ := by + apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0) + intro i + change ‖A i (x i)‖ ≤ ‖C * ‖x i‖‖ + rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg hC (norm_nonneg _))] + exact (A i).le_opNorm (x i) |>.trans + (mul_le_mul_of_nonneg_right (hA i) (norm_nonneg _)) + _ = C * ‖x‖ := by rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg hC, lp.norm_toNorm] + local_proof) A C hC hA) + +def blockIsometry (V : ∀ i, E i →ₗᵢ[ℂ] F i) : lp E 2 →ₗᵢ[ℂ] lp F 2 where + toLinearMap := (blockOperator (fun i => (V i).toContinuousLinearMap) 1 zero_le_one + (fun i => (V i).norm_toContinuousLinearMap_le)).toLinearMap + norm_map' x := by + apply le_antisymm + · apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0) + intro i + exact le_of_eq ((V i).norm_map (x i)) + · apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0) + intro i + exact le_of_eq ((V i).norm_map (x i)).symm + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +variable {ι : Type*} {Q : ι → Type*} {H : Type*} + +variable [NormedAddCommGroup H] [NormedSpace ℂ H] + + +attribute [-instance] CStarAlgebra.toNormedRing CommCStarAlgebra.toNormedCommRing + +attribute [local instance 10000] T4Space.t3Space T5Space.toT4Space OrderTopology.t5Space + AddGroup.existsAddOfLE + +def flattenVector (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) : + lp (fun _ : Sigma Q => H) 2 := by + classical + + exact ⟨fun q => x q.1 q.2, by + apply memℓp_gen + simp only [ENNReal.toReal_ofNat, Real.rpow_two] + apply (summable_sigma_of_nonneg (fun q => sq_nonneg ‖x q.1 q.2‖)).2 + refine ⟨fun i => ( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) (x i), ?_⟩ + simpa only [← ( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof)] using ( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) x⟩ + +def rowVector (x : lp (fun _ : Sigma Q => H) 2) (i : ι) : lp (fun _ : Q i => H) 2 := by + classical + + exact ⟨fun q => x ⟨i, q⟩, by + apply memℓp_gen + simp only [ENNReal.toReal_ofNat, Real.rpow_two] + exact ((summable_sigma_of_nonneg (fun q => sq_nonneg ‖x q‖)).1 + (( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) x)).1 i⟩ + +def unflattenVector (x : lp (fun _ : Sigma Q => H) 2) : + lp (fun i => lp (fun _ : Q i => H) 2) 2 := by + classical + + exact ⟨OAI.CoarseAssembly.rowVector x, by + apply memℓp_gen + simp only [ENNReal.toReal_ofNat, Real.rpow_two, ( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof)] + exact ((summable_sigma_of_nonneg (fun q => sq_nonneg ‖x q‖)).1 + (( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) x)).2⟩ + +def flattenEquiv : + lp (fun i => lp (fun _ : Q i => H) 2) 2 ≃ₗᵢ[ℂ] lp (fun _ : Sigma Q => H) 2 := by + classical + have OAI.CoarseAssembly.flattenVector_norm {ι : Type _} {Q : ι → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) : + ‖OAI.CoarseAssembly.flattenVector x‖ = ‖x‖ := + open OAI OAI.CoarseAssembly in + by + have hsq : ‖OAI.CoarseAssembly.flattenVector x‖ ^ 2 = ‖x‖ ^ 2 := by + calc + _ = ∑' q, ‖OAI.CoarseAssembly.flattenVector x q‖ ^ 2 := ( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof) _ + _ = ∑' i, ∑' q : Q i, ‖OAI.CoarseAssembly.flattenVector x ⟨i, q⟩‖ ^ 2 := + Summable.tsum_sigma' (fun i => ( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) (x i)) + (( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) (OAI.CoarseAssembly.flattenVector x)) + _ = ∑' i, ‖x i‖ ^ 2 := tsum_congr (fun i => (( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof) (x i)).symm) + _ = ‖x‖ ^ 2 := (( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof) x).symm + nlinarith [norm_nonneg (OAI.CoarseAssembly.flattenVector x), norm_nonneg x] + exact { + toFun := OAI.CoarseAssembly.flattenVector + invFun := OAI.CoarseAssembly.unflattenVector + left_inv := ( + let local_proof {ι : Type _} {Q : ι → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) : + OAI.CoarseAssembly.unflattenVector (OAI.CoarseAssembly.flattenVector x) = x := + open OAI OAI.CoarseAssembly in + by + apply lp.ext + funext i + apply lp.ext + rfl + local_proof) + right_inv := ( + let local_proof {ι : Type _} {Q : ι → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (x : lp (fun _ : Sigma Q => H) 2) : + OAI.CoarseAssembly.flattenVector (OAI.CoarseAssembly.unflattenVector x) = x := + open OAI OAI.CoarseAssembly in + by + apply lp.ext + rfl + local_proof) + map_add' _ _ := rfl + map_smul' _ _ := rfl + norm_map' := OAI.CoarseAssembly.flattenVector_norm + } + +end CoarseAssembly + +end +end + +section + +namespace CoarseAssembly + +variable {E F H : Type*} + +variable [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + +variable [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] + +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +noncomputable def operatorConjugation (V : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) : F →L[ℂ] F := + V.toContinuousLinearMap ∘L T ∘L V.toContinuousLinearMap.adjoint + +noncomputable def operatorConjugationHom (V : E →ₗᵢ[ℂ] F) : + (E →L[ℂ] E) →⋆ₙₐ[ℂ] (F →L[ℂ] F) := by + classical + have OAI.CoarseAssembly.operatorConjugation_mul {E : Type _} {F : Type _} [inst_local_2 : NormedAddCommGroup E] [inst_local_3 : InnerProductSpace ℂ E] [inst_local_4 : CompleteSpace E] [inst_local_5 : NormedAddCommGroup F] [inst_local_6 : InnerProductSpace ℂ F] [inst_local_7 : CompleteSpace F] (V : E →ₗᵢ[ℂ] F) (T S : E →L[ℂ] E) : + OAI.CoarseAssembly.operatorConjugation V (T * S) = OAI.CoarseAssembly.operatorConjugation V T * OAI.CoarseAssembly.operatorConjugation V S := + open OAI OAI.CoarseAssembly in + by + have hV (z : E) : V.toContinuousLinearMap.adjoint (V z) = z := by + simpa only [ContinuousLinearMap.comp_apply, one_apply_eq_self, + LinearIsometry.coe_toContinuousLinearMap] using DFunLike.congr_fun V.adjoint_comp_self z + ext x + simp [OAI.CoarseAssembly.operatorConjugation, hV] + exact { + toFun := OAI.CoarseAssembly.operatorConjugation V + map_zero' := by simp [OAI.CoarseAssembly.operatorConjugation] + map_add' T S := by simp [OAI.CoarseAssembly.operatorConjugation, ContinuousLinearMap.comp_add, + ContinuousLinearMap.add_comp] + map_mul' := OAI.CoarseAssembly.operatorConjugation_mul V + map_smul' c T := by simp [OAI.CoarseAssembly.operatorConjugation] + map_star' := ( + let local_proof {E : Type _} {F : Type _} [inst_local_2 : NormedAddCommGroup E] [inst_local_3 : InnerProductSpace ℂ E] [inst_local_4 : CompleteSpace E] [inst_local_5 : NormedAddCommGroup F] [inst_local_6 : InnerProductSpace ℂ F] [inst_local_7 : CompleteSpace F] (V : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) : + OAI.CoarseAssembly.operatorConjugation V (star T) = star (OAI.CoarseAssembly.operatorConjugation V T) := + open OAI OAI.CoarseAssembly in + by + simp [OAI.CoarseAssembly.operatorConjugation, ContinuousLinearMap.star_eq_adjoint, + ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.comp_assoc] + local_proof) V + } + +end CoarseAssembly + +end + +section + +namespace CoarseAssembly.Congruence + +abbrev ArithmeticGroup := Matrix.SpecialLinearGroup (Fin 3) ℤ + +abbrev Quotient (k : ℕ) := Matrix.SpecialLinearGroup (Fin 3) (ZMod (2 ^ k)) + +def reduce (k : ℕ) : ArithmeticGroup →* Quotient k := + Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod (2 ^ k))) + +def diagonal {R : Type*} [CommRing R] (t : Rˣ) : Matrix.SpecialLinearGroup (Fin 3) R := + ⟨Matrix.diagonal ![(t : R), ((t⁻¹ : Rˣ) : R), 1], by + simp [Matrix.det_diagonal, Fin.prod_univ_succ]⟩ + +noncomputable def holonomy (t : ℤ_[2]ˣ) (k : ℕ) : Quotient k := + diagonal (Units.map (PadicInt.toZModPow k).toMonoidHom t) + +end CoarseAssembly.Congruence + +end + +section + +namespace CoarseAssembly.Congruence + +def residueMap {l k : ℕ} (h : l ≤ k) : ZMod (2 ^ k) →+* ZMod (2 ^ l) := + ZMod.castHom (pow_dvd_pow 2 h) _ + +def quotientMap {l k : ℕ} (h : l ≤ k) : Quotient k →* Quotient l := + Matrix.SpecialLinearGroup.map (residueMap h) + +end CoarseAssembly.Congruence + +end + +section + +noncomputable section + +namespace CoarseAssembly + +variable {I : Type*} {Q : I → Type*} {H : Type*} + +variable [NormedAddCommGroup H] [NormedSpace ℂ H] + + +def flattenOperator + (A : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) : + lp (fun _ : Sigma Q => H) 2 →L[ℂ] lp (fun _ : Sigma Q => H) 2 := + (flattenEquiv (Q := Q) (H := H)).toLinearIsometry.toContinuousLinearMap.comp + (A.comp (flattenEquiv (Q := Q) (H := H)).symm.toLinearIsometry.toContinuousLinearMap) + +variable [DecidableEq I] [∀ i, DecidableEq (Q i)] + + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +@[instance_reducible] def discreteGraphMetric (V : Type*) : MetricSpace V := by + classical + exact { + dist := fun x y => if x = y then 0 else 1 + dist_self := by intro x; simp + dist_comm := by intro x y; by_cases hxy : x = y <;> simp_all [eq_comm] + dist_triangle := by intro x y z; split_ifs <;> simp_all + eq_of_dist_eq_zero := by + intro x y hdist + by_contra hxy + simp [hxy] at hdist + } + +variable {V : Type*} (G : SimpleGraph V) + +@[instance_reducible] def connectedGraphMetric (hG : G.Connected) : MetricSpace V where + dist x y := (G.dist x y : ℝ) + dist_self x := (congrArg (fun distance : ℕ => (distance : ℝ)) (G.dist_self (v := x))).trans + Nat.cast_zero + dist_comm x y := congrArg (fun distance : ℕ => (distance : ℝ)) (G.dist_comm (u := x) (v := y)) + dist_triangle x y z := + (show (G.dist x z : ℝ) ≤ ((G.dist x y + G.dist y z : ℕ) : ℝ) from + Nat.cast_le.mpr (hG.dist_triangle (u := x) (v := y) (w := z))).trans_eq (Nat.cast_add _ _) + eq_of_dist_eq_zero := by + intro x y h + exact hG.dist_eq_zero_iff.mp (Nat.cast_eq_zero.mp h) + +@[instance_reducible] def graphMetricOrDiscrete : MetricSpace V := by + classical + exact if hG : G.Connected then connectedGraphMetric G hG else discreteGraphMetric V + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + + +variable {V : ℕ → Type*} [∀ i, MetricSpace (V i)] + +def separatedDist (o : ∀ i, V i) (x y : Sigma V) : ℝ := + if h : x.1 = y.1 then dist (h ▸ x.2) y.2 + else dist x.2 (o x.1) + ((x.1 : ℝ) + (y.1 : ℝ) + 2) + dist (o y.1) y.2 + +@[instance_reducible] def separatedMetric (o : ∀ i, V i) : MetricSpace (Sigma V) := by + classical + have OAI.CoarseAssembly.separatedDist_comm {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y : Sigma V) : + OAI.CoarseAssembly.separatedDist o x y = OAI.CoarseAssembly.separatedDist o y x := + open OAI OAI.CoarseAssembly in + by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + by_cases h : i = j + · subst j; simp only [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof), dist_comm] + · rw [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o h, ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o (Ne.symm h)] + simp only [dist_comm y (o j), dist_comm (o i) x] + ring + have OAI.CoarseAssembly.separatedDist_triangle {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y z : Sigma V) : + OAI.CoarseAssembly.separatedDist o x z ≤ OAI.CoarseAssembly.separatedDist o x y + OAI.CoarseAssembly.separatedDist o y z := + open OAI OAI.CoarseAssembly in + by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + rcases z with ⟨k, z⟩ + by_cases hij : i = j + · subst j + by_cases hik : i = k + · subst k; simp only [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof)]; exact dist_triangle _ _ _ + · simp only [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof), ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hik] + linarith [dist_triangle x y (o i)] + · by_cases hjk : j = k + · subst k + simp only [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof), ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hij] + linarith [dist_triangle (o j) y z] + · by_cases hik : i = k + · subst k + simp only [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof), ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hij, + ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o (Ne.symm hij)] + have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + linarith [dist_triangle x (o i) z, dist_nonneg (x := y) (y := o j), + dist_nonneg (x := o j) (y := y)] + · simp only [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hik, ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hij, + ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hjk] + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + linarith [dist_nonneg (x := y) (y := o j), dist_nonneg (x := o j) (y := y)] + exact { + dist := OAI.CoarseAssembly.separatedDist o + dist_self x := by rcases x with ⟨i, x⟩; simp [OAI.CoarseAssembly.separatedDist] + dist_comm := OAI.CoarseAssembly.separatedDist_comm o + dist_triangle := OAI.CoarseAssembly.separatedDist_triangle o + eq_of_dist_eq_zero := by + rintro ⟨i, x⟩ ⟨j, y⟩ h + by_cases hij : i = j + · subst j + simp only [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof), dist_eq_zero] at h + subst y + rfl + · rw [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hij] at h + have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)] + } + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open scoped Topology + + +variable {X Y H : Type*} + +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +variable [DecidableEq X] [DecidableEq Y] + +abbrev Module (X H : Type*) [NormedAddCommGroup H] := lp (fun _ : X => H) 2 + +abbrev Operator (X H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] := + Module X H →L[ℂ] Module X H + +def insert (x : X) : H →L[ℂ] Module X H := + lp.singleContinuousLinearMap ℂ (fun _ : X => H) 2 x + +def coordinate (x : X) : Module X H →L[ℂ] H := + lp.evalCLM ℂ (fun _ : X => H) 2 x + +def entry (T : Operator X H) (x y : X) : H →L[ℂ] H := + coordinate x ∘L T ∘L insert y + +def CompactEntries (T : Operator X H) : Prop := + ∀ x y, IsCompactOperator (entry T x y) + +variable [CompleteSpace H] [PseudoMetricSpace X] + +local instance operatorScalarTower : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext h; simp + +local instance operatorScalarComm : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext h; simp + +def PropagationLE (r : ℝ) (T : Operator X H) : Prop := + ∀ x y, r < dist x y → entry T x y = 0 + +def Generator (T : Operator X H) : Prop := + (∃ r : ℝ, 0 ≤ r ∧ PropagationLE r T) ∧ CompactEntries T ∧ CompactEntries (star T) + +def algebra : NonUnitalStarSubalgebra ℂ (Operator X H) := + (NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T}).topologicalClosure + +instance : NonUnitalCStarAlgebra (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) := by + classical + + exact NonUnitalStarSubalgebra.nonUnitalCStarAlgebra _ (h_closed := ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + local_proof)) + +variable [PseudoMetricSpace Y] + +end CoarseAssembly.DiscreteRoe + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open scoped Topology + +variable {B D X H : Type*} [DecidableEq B] [DecidableEq D] [DecidableEq X] + +variable [PseudoMetricSpace B] [PseudoMetricSpace D] [PseudoMetricSpace X] + +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +def MapsToRoe (V : Module D H →ₗᵢ[ℂ] Module X H) : Prop := + ∀ T : Operator D H, T ∈ algebra (X := D) (H := H) → + operatorConjugation V T ∈ algebra (X := X) (H := H) + +def conjugationHom (V : Module D H →ₗᵢ[ℂ] Module X H) + (hV : MapsToRoe V) : + algebra (X := D) (H := H) →⋆ₙₐ[ℂ] algebra (X := X) (H := H) := + NonUnitalStarAlgHom.codRestrict + ((operatorConjugationHom V).comp (NonUnitalStarSubalgebraClass.subtype _)) + _ (fun T => hV T T.property) + +end CoarseAssembly.DiscreteRoe + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open DiscreteRoe + +open scoped Topology + +variable {D : Type*} [DecidableEq D] [PseudoMetricSpace D] + +def UniformFiniteBalls (D : Type*) [PseudoMetricSpace D] : Prop := + ∀ R : ℝ, 0 ≤ R → ∃ N : ℕ, ∀ u : D, ∃ b : Finset D, + (∀ v, v ∈ b ↔ dist u v ≤ R) ∧ b.card ≤ N + +variable {Q : D → Type*} [∀ u, Fintype (Q u)] [∀ u, Nonempty (Q u)] + +variable [∀ u, DecidableEq (Q u)] [PseudoMetricSpace (Sigma Q)] + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +end CoarseAssembly + +end +end + +section + +namespace CoarseAssembly + +abbrev LatticeVertex := ℤ × ℤ + +def latticeRadius (u : LatticeVertex) : ℤ := + max (max |u.1| |u.2|) |u.1 + u.2| + +def triangularGraph : SimpleGraph LatticeVertex where + Adj u v := |u.1 - v.1| ≤ 1 ∧ |u.2 - v.2| ≤ 1 ∧ + |(u.1 + u.2) - (v.1 + v.2)| ≤ 1 ∧ u ≠ v + symm := ⟨by intro u v h; simpa only [abs_sub_comm, ne_eq, eq_comm] using h⟩ + loopless := ⟨fun _ h => h.2.2.2 rfl⟩ + +def Disc (j : ℕ) := {u : LatticeVertex // latticeRadius u ≤ (j : ℤ)} + +noncomputable instance (j : ℕ) : Fintype (OAI.CoarseAssembly.Disc j) := by + classical + + exact (( + let local_proof (j : ℕ) : {u : OAI.CoarseAssembly.LatticeVertex | OAI.CoarseAssembly.latticeRadius u ≤ (j : ℤ)}.Finite := + open OAI OAI.CoarseAssembly in + by + apply ((Set.finite_Icc (-(j : ℤ)) j).prod (Set.finite_Icc (-(j : ℤ)) j)).subset + intro u hu + simp only [Set.mem_ofPred_eq, OAI.CoarseAssembly.latticeRadius, max_le_iff, abs_le] at hu + exact ⟨hu.1.1, hu.1.2⟩ + local_proof) j).fintype + +def discGraph (j : ℕ) : SimpleGraph (Disc j) where + Adj u v := triangularGraph.Adj u.val v.val + symm := ⟨fun _ _ h => h.symm⟩ + loopless := ⟨fun _ h => h.2.2.2 rfl⟩ + +def discDepth (j : ℕ) (u : Disc j) : ℕ := ((j : ℤ) - latticeRadius u.val).toNat + +end CoarseAssembly + +end + +section + +namespace CoarseAssembly + +def latticeCharge (u v : LatticeVertex) : ℤ := + if u.2 < 0 ∧ v.2 = 0 ∧ 0 < v.1 then 1 + else if v.2 < 0 ∧ u.2 = 0 ∧ 0 < u.1 then -1 else 0 + +end CoarseAssembly + +end + +section + +namespace CoarseAssembly + +open Set + +variable {p : ℕ} [Fact p.Prime] + +section + +attribute [local instance 1001] instIsDomain BaireSpace.of_completelyPseudoMetrizable + T3Space.toT0Space T4Space.t3Space instT4SpaceOfT1SpaceOfNormalSpace + T2Space.t1Space TopologicalSpace.t2Space_of_metrizableSpace + CompletelyNormalSpace.toNormalSpace + UniformSpace.completelyNormalSpace_of_isCountablyGenerated_uniformity + +end + +end CoarseAssembly + +end + +section + +namespace CoarseAssembly.Congruence + +noncomputable def chosenHolonomyUnit : ℤ_[2]ˣ := by + classical + have OAI.CoarseAssembly.exists_transcendental_principal_unit {p : ℕ} [inst_local_1 : Fact (Nat.Prime p)] : + ∃ t : ℤ_[p]ˣ, Transcendental ℤ (t : ℤ_[p]) ∧ + ∃ a : ℤ_[p], (t : ℤ_[p]) = 1 + (p : ℤ_[p]) * a := + open OAI OAI.CoarseAssembly in + open Set in + by + obtain ⟨x, hx, hclose⟩ := + (( + let local_proof {p : ℕ} [inst_local_1 : Fact (Nat.Prime p)] : Dense {x : ℚ_[p] | Transcendental ℤ x} := + open OAI OAI.CoarseAssembly in + open Set in + by + have hcount : Set.Countable {x : ℚ_[p] | IsAlgebraic ℤ x} := + Algebraic.countable ℤ ℚ_[p] + have hd : Dense (⋂ x ∈ {x : ℚ_[p] | IsAlgebraic ℤ x}, ({x}ᶜ : Set ℚ_[p])) := + dense_biInter_of_isOpen (fun _ _ => isOpen_compl_singleton) hcount + (fun x _ => dense_compl_singleton x) + apply hd.mono + intro x hx hxalg + have hxnot := Set.mem_iInter₂.mp hx x hxalg + exact hxnot (Set.mem_singleton x) + @local_proof) (p := p)).exists_dist_lt (1 : ℚ_[p]) zero_lt_one + have hnear : ‖x - 1‖ < 1 := by + simpa only [dist_eq_norm, norm_sub_rev] using hclose + have hxnorm : ‖x‖ = 1 := by + simpa only [norm_one] using Padic.norm_eq_of_norm_sub_lt_right + (show ‖x - 1‖ < ‖(1 : ℚ_[p])‖ by simpa using hnear) + let z : ℤ_[p] := ⟨x, hxnorm.le⟩ + have hznorm : ‖z‖ = 1 := hxnorm + obtain ⟨t, ht⟩ := PadicInt.isUnit_iff.mpr hznorm + refine ⟨t, ?_, ?_⟩ + · rw [ht] + intro hzalg + let f : ℤ_[p] →ₐ[ℤ] ℚ_[p] := + { PadicInt.Coe.ringHom with commutes' := fun n => by simp } + exact hx (hzalg.algHom f) + · have hzclose : ‖z - 1‖ < 1 := hnear + obtain ⟨a, ha⟩ := (PadicInt.norm_lt_one_iff_dvd (z - 1)).mp hzclose + refine ⟨a, ?_⟩ + rw [ht] + linear_combination ha + exact (OAI.CoarseAssembly.exists_transcendental_principal_unit (p := 2)).choose + +end CoarseAssembly.Congruence + +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +def symmetricMoves (S : Finset ArithmeticGroup) : Finset ArithmeticGroup := + insert 1 (S ∪ S.image Inv.inv) + +abbrev FiberVertex (j : ℕ) := (u : Disc j) × Quotient (discDepth j u) + +instance (j : ℕ) : Fintype (FiberVertex j) := inferInstance + +def fiberCoordinate {j l : ℕ} (x : FiberVertex j) (h : l ≤ discDepth j x.1) : Quotient l := + quotientMap h x.2 + +def fiberCharge {j : ℕ} (x y : FiberVertex j) : ℤ := + latticeCharge x.1.val y.1.val + +def LiftStep (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) {j : ℕ} + (x y : FiberVertex j) : Prop := + ∃ s ∈ symmetricMoves S, + (x.1 = y.1 ∨ (discGraph j).Adj x.1 y.1 ∧ s = 1) ∧ + ∀ l (hx : l ≤ discDepth j x.1) (hy : l ≤ discDepth j y.1), + fiberCoordinate y hy = reduce l s * fiberCoordinate x hx * + holonomy t l ^ fiberCharge x y + +def fiberedGraph (S : Finset OAI.CoarseAssembly.Congruence.ArithmeticGroup) (t : ℤ_[2]ˣ) (j : ℕ) : + SimpleGraph (OAI.CoarseAssembly.FiberVertex j) := by + classical + have OAI.CoarseAssembly.liftStep_reverse {S : Finset OAI.CoarseAssembly.Congruence.ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + {x y : OAI.CoarseAssembly.FiberVertex j} (h : OAI.CoarseAssembly.LiftStep S t x y) : OAI.CoarseAssembly.LiftStep S t y x := + open OAI OAI.CoarseAssembly in + open Congruence in + by + obtain ⟨s, hs, hp, he⟩ := h + refine ⟨s⁻¹, ( + let local_proof {S : Finset OAI.CoarseAssembly.Congruence.ArithmeticGroup} {s : OAI.CoarseAssembly.Congruence.ArithmeticGroup} + (h : s ∈ OAI.CoarseAssembly.symmetricMoves S) : s⁻¹ ∈ OAI.CoarseAssembly.symmetricMoves S := + open OAI OAI.CoarseAssembly in + open Congruence in + by + simp only [OAI.CoarseAssembly.symmetricMoves, Finset.mem_insert, Finset.mem_union, Finset.mem_image] at * + rcases h with h | h | ⟨a, ha, rfl⟩ + · left; simp [h] + · exact Or.inr (Or.inr ⟨s, h, rfl⟩) + · exact Or.inr (Or.inl (by simpa using ha)) + local_proof) hs, ?_, ?_⟩ + · rcases hp with hp | ⟨hp, rfl⟩ + · exact Or.inl hp.symm + · exact Or.inr ⟨hp.symm, inv_one⟩ + · intro l hy hx + have hc : OAI.CoarseAssembly.fiberCharge y x = -OAI.CoarseAssembly.fiberCharge x y := ( + let local_proof (u v : OAI.CoarseAssembly.LatticeVertex) : OAI.CoarseAssembly.latticeCharge v u = -OAI.CoarseAssembly.latticeCharge u v := + open OAI OAI.CoarseAssembly in + by + simp only [OAI.CoarseAssembly.latticeCharge] + split_ifs <;> omega + local_proof) _ _ + rw [hc, map_inv, zpow_neg, he l hx hy] + group + exact { + Adj x y := x ≠ y ∧ OAI.CoarseAssembly.LiftStep S t x y + symm := ⟨fun _ _ h => ⟨Ne.symm h.1, OAI.CoarseAssembly.liftStep_reverse h.2⟩⟩ + loopless := ⟨fun _ h => h.1 rfl⟩ + } + +end CoarseAssembly + +end +end + + +noncomputable section + +namespace CoarseAssembly + +open Congruence + + +section + +attribute [local instance 1001] IsStrictOrderedRing.toIsOrderedRing Int.instSemiring + +def discBoundaryBase (j : ℕ) : Disc j := + ⟨((j : ℤ), 0), by simp [latticeRadius, max_self]⟩ + +end + +def fiberBoundaryBase (j : ℕ) : FiberVertex j := ⟨discBoundaryBase j, 1⟩ + +end CoarseAssembly + +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +abbrev BaseUnion := (j : ℕ) × Disc j + +abbrev BaseFiber (u : BaseUnion) := Quotient (discDepth u.1 u.2) + +abbrev VertexUnion := Sigma BaseFiber + +noncomputable instance baseUnionDecidableEq : DecidableEq BaseUnion := Classical.decEq _ + +noncomputable instance vertexUnionDecidableEq : DecidableEq VertexUnion := + inferInstanceAs (DecidableEq (Sigma BaseFiber)) + +@[instance_reducible] def componentMetric (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + (j : ℕ) : MetricSpace (FiberVertex j) := + graphMetricOrDiscrete (fiberedGraph S t j) + +@[instance_reducible] def componentUnionMetric (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + MetricSpace ((j : ℕ) × FiberVertex j) := by + letI := componentMetric S t + exact separatedMetric fiberBoundaryBase + +@[instance_reducible] def vertexUnionMetric (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) : + MetricSpace VertexUnion := by + letI := componentUnionMetric S t + exact (Equiv.sigmaAssoc (fun j u => Quotient (discDepth j u))).metricSpace + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +def positiveElementaryMove (p : Fin 3 × Fin 3) : ArithmeticGroup := + if h : p.1 ≠ p.2 then Matrix.SpecialLinearGroup.transvection h (1 : ℤ) else 1 + +def elementaryMoves : Finset ArithmeticGroup := + symmetricMoves (Finset.univ.image positiveElementaryMove) + + +abbrev AmpleSpace := lp (fun _ : ℕ => ℂ) 2 + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u + +structure HilbertSpace where + Carrier : Type u + normed : NormedAddCommGroup Carrier + inner : InnerProductSpace ℂ Carrier + complete : CompleteSpace Carrier + secondCountable : SecondCountableTopology Carrier + +attribute [instance] HilbertSpace.normed HilbertSpace.inner + HilbertSpace.complete HilbertSpace.secondCountable + +instance : CoeSort HilbertSpace (Type u) := ⟨HilbertSpace.Carrier⟩ + +abbrev End (H : HilbertSpace) := H →L[ℂ] H + +variable (A : Type u) [NonUnitalCStarAlgebra A] + +structure OddCycle where + space : HilbertSpace.{u} + representation : A →⋆ₙₐ[ℂ] End space + operator : End space + commutator_compact : ∀ a : A, + IsCompactOperator (operator * representation a - representation a * operator : End space) + square_compact : ∀ a : A, + IsCompactOperator ((operator * operator - 1) * representation a : End space) + adjoint_compact : ∀ a : A, + IsCompactOperator ((star operator - operator) * representation a : End space) + +variable {A} {B : Type u} [NonUnitalCStarAlgebra B] + +namespace OddCycle + +def Degenerate (c : OddCycle A) : Prop := + (∀ a, c.operator * c.representation a - c.representation a * c.operator = 0) ∧ + (∀ a, (c.operator * c.operator - 1) * c.representation a = 0) ∧ + (∀ a, (star c.operator - c.operator) * c.representation a = 0) + +def precomp (c : OddCycle A) (φ : B →⋆ₙₐ[ℂ] A) : OddCycle B where + space := c.space + representation := c.representation.comp φ + operator := c.operator + commutator_compact b := c.commutator_compact (φ b) + square_compact b := c.square_compact (φ b) + adjoint_compact b := c.adjoint_compact (φ b) + +structure UnitaryEquivalent (c d : OddCycle A) where + unitary : c.space ≃ₗᵢ[ℂ] d.space + representation_eq : ∀ a, + d.representation a = operatorConjugation unitary.toLinearIsometry (c.representation a) + operator_eq : d.operator = operatorConjugation unitary.toLinearIsometry c.operator + +def UnitaryEquivalent.precomp {c d : OddCycle A} (e : UnitaryEquivalent c d) + (φ : B →⋆ₙₐ[ℂ] A) : UnitaryEquivalent (c.precomp φ) (d.precomp φ) where + unitary := e.unitary + representation_eq b := e.representation_eq (φ b) + operator_eq := e.operator_eq + +structure IsDirectSum (c d e : OddCycle A) where + left : c.space →ₗᵢ[ℂ] e.space + right : d.space →ₗᵢ[ℂ] e.space + orthogonal : left.toContinuousLinearMap.adjoint ∘L right.toContinuousLinearMap = 0 + exhaustive : left.toContinuousLinearMap.comp left.toContinuousLinearMap.adjoint + + right.toContinuousLinearMap.comp right.toContinuousLinearMap.adjoint = 1 + representation_eq : ∀ a, + e.representation a = operatorConjugation left (c.representation a) + + operatorConjugation right (d.representation a) + operator_eq : e.operator = operatorConjugation left c.operator + + operatorConjugation right d.operator + +def IsDirectSum.precomp {c d e : OddCycle A} (h : IsDirectSum c d e) + (φ : B →⋆ₙₐ[ℂ] A) : IsDirectSum (c.precomp φ) (d.precomp φ) (e.precomp φ) where + left := h.left + right := h.right + orthogonal := h.orthogonal + exhaustive := h.exhaustive + representation_eq b := h.representation_eq (φ b) + operator_eq := h.operator_eq + +end OddCycle + +abbrev Interval := Set.Icc (0 : ℝ) 1 + +def start : Interval := ⟨0, by norm_num⟩ + +def finish : Interval := ⟨1, by norm_num⟩ + +structure OddHomotopy (A : Type u) [NonUnitalCStarAlgebra A] where + space : HilbertSpace.{u} + representation : Interval → A →⋆ₙₐ[ℂ] End space + operator : Interval → End space + continuous_representation : ∀ a, Continuous (fun t => representation t a) + continuous_operator : Continuous operator + commutator_compact : ∀ t a, + IsCompactOperator (operator t * representation t a - representation t a * operator t : End space) + square_compact : ∀ t a, + IsCompactOperator ((operator t * operator t - 1) * representation t a : End space) + adjoint_compact : ∀ t a, + IsCompactOperator ((star (operator t) - operator t) * representation t a : End space) + +namespace OddHomotopy + +def eval (h : OddHomotopy A) (t : Interval) : OddCycle A where + space := h.space + representation := h.representation t + operator := h.operator t + commutator_compact := h.commutator_compact t + square_compact := h.square_compact t + adjoint_compact := h.adjoint_compact t + +def precomp (h : OddHomotopy A) (φ : B →⋆ₙₐ[ℂ] A) : OddHomotopy B where + space := h.space + representation t := (h.representation t).comp φ + operator := h.operator + continuous_representation b := h.continuous_representation (φ b) + continuous_operator := h.continuous_operator + commutator_compact t b := h.commutator_compact t (φ b) + square_compact t b := h.square_compact t (φ b) + adjoint_compact t b := h.adjoint_compact t (φ b) + +end OddHomotopy + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u + +variable (A : Type u) [NonUnitalCStarAlgebra A] + +inductive CycleRelation : FreeAbelianGroup (OddCycle A) → Prop + | degenerate (c : OddCycle A) (h : c.Degenerate) : + CycleRelation (FreeAbelianGroup.of c) + | unitary (c d : OddCycle A) (h : c.UnitaryEquivalent d) : + CycleRelation (FreeAbelianGroup.of c - FreeAbelianGroup.of d) + | directSum (c d e : OddCycle A) (h : c.IsDirectSum d e) : + CycleRelation (FreeAbelianGroup.of e - (FreeAbelianGroup.of c + FreeAbelianGroup.of d)) + | homotopy (h : OddHomotopy A) : + CycleRelation (FreeAbelianGroup.of (h.eval start) - FreeAbelianGroup.of (h.eval finish)) + +def relations : AddSubgroup (FreeAbelianGroup (OddCycle A)) := + AddSubgroup.closure {z | CycleRelation A z} + +abbrev OddK := FreeAbelianGroup (OddCycle A) ⧸ relations A + +def cycleClass (c : OddCycle A) : OddK A := + QuotientAddGroup.mk (FreeAbelianGroup.of c) + +variable {A} + +variable {B C : Type u} [NonUnitalCStarAlgebra B] [NonUnitalCStarAlgebra C] + +def precompFree (φ : B →⋆ₙₐ[ℂ] A) : FreeAbelianGroup (OddCycle A) →+ OddK B := + FreeAbelianGroup.lift (fun c => cycleClass B (c.precomp φ)) + +def precomp (φ : B →⋆ₙₐ[ℂ] A) : OAI.CoarseAssembly.Analytic.OddK A →+ OAI.CoarseAssembly.Analytic.OddK B := by + classical + have OAI.CoarseAssembly.Analytic.degenerate_zero {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (hc : c.Degenerate) : OAI.CoarseAssembly.Analytic.cycleClass A c = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + ( + let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz) + local_proof) (.degenerate c hc) + have OAI.CoarseAssembly.Analytic.unitary_eq {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (c d : OAI.CoarseAssembly.Analytic.OddCycle A) (h : c.UnitaryEquivalent d) : + OAI.CoarseAssembly.Analytic.cycleClass A c = OAI.CoarseAssembly.Analytic.cycleClass A d := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hz := ( + let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz) + local_proof) (.unitary c d h) + exact sub_eq_zero.mp (by simpa only [OAI.CoarseAssembly.Analytic.cycleClass, OAI.CoarseAssembly.Analytic.OddK, QuotientAddGroup.mk_sub] using hz) + have OAI.CoarseAssembly.Analytic.directSum_eq {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (c d e : OAI.CoarseAssembly.Analytic.OddCycle A) (h : c.IsDirectSum d e) : + OAI.CoarseAssembly.Analytic.cycleClass A e = OAI.CoarseAssembly.Analytic.cycleClass A c + OAI.CoarseAssembly.Analytic.cycleClass A d := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hz := ( + let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz) + local_proof) (.directSum c d e h) + exact sub_eq_zero.mp (by simpa only [OAI.CoarseAssembly.Analytic.cycleClass, OAI.CoarseAssembly.Analytic.OddK, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using hz) + have OAI.CoarseAssembly.Analytic.homotopy_eq {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (h : OAI.CoarseAssembly.Analytic.OddHomotopy A) : + OAI.CoarseAssembly.Analytic.cycleClass A (h.eval OAI.CoarseAssembly.Analytic.start) = OAI.CoarseAssembly.Analytic.cycleClass A (h.eval OAI.CoarseAssembly.Analytic.finish) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hz := ( + let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz) + local_proof) (.homotopy h) + exact sub_eq_zero.mp (by simpa only [OAI.CoarseAssembly.Analytic.cycleClass, OAI.CoarseAssembly.Analytic.OddK, QuotientAddGroup.mk_sub] using hz) + have OAI.CoarseAssembly.Analytic.precompFree_relation {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} [inst_local_3 : NonUnitalCStarAlgebra B] (φ : B →⋆ₙₐ[ℂ] A) + {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) : + OAI.CoarseAssembly.Analytic.precompFree φ z = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + cases hz with + | degenerate c h => + simpa [OAI.CoarseAssembly.Analytic.precompFree] using OAI.CoarseAssembly.Analytic.degenerate_zero (c.precomp φ) ((( + let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} [inst_local_3 : NonUnitalCStarAlgebra B] {c : OAI.CoarseAssembly.Analytic.OddCycle A} (hc : c.Degenerate) + (φ : B →⋆ₙₐ[ℂ] A) : (c.precomp φ).Degenerate := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic OAI.CoarseAssembly.Analytic.OddCycle in + ⟨fun b => hc.1 (φ b), fun b => hc.2.1 (φ b), fun b => hc.2.2 (φ b)⟩ + local_proof) h φ)) + | unitary c d h => + simpa [OAI.CoarseAssembly.Analytic.precompFree] using sub_eq_zero.mpr + (OAI.CoarseAssembly.Analytic.unitary_eq (c.precomp φ) (d.precomp φ) (h.precomp φ)) + | directSum c d e h => + simpa [OAI.CoarseAssembly.Analytic.precompFree] using sub_eq_zero.mpr + (OAI.CoarseAssembly.Analytic.directSum_eq (c.precomp φ) (d.precomp φ) (e.precomp φ) (h.precomp φ)) + | homotopy h => + simpa [OAI.CoarseAssembly.Analytic.precompFree, OAI.CoarseAssembly.Analytic.OddHomotopy.precomp, OAI.CoarseAssembly.Analytic.OddHomotopy.eval, OAI.CoarseAssembly.Analytic.OddCycle.precomp] using sub_eq_zero.mpr (OAI.CoarseAssembly.Analytic.homotopy_eq (h.precomp φ)) + exact QuotientAddGroup.lift (OAI.CoarseAssembly.Analytic.relations A) (OAI.CoarseAssembly.Analytic.precompFree φ) + ((AddSubgroup.closure_le _).2 (fun _ hz => OAI.CoarseAssembly.Analytic.precompFree_relation φ hz)) + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +variable {A : Type} [NonUnitalCStarAlgebra A] + +def OddCycle.compactPerturb (c : OAI.CoarseAssembly.Analytic.OddCycle A) (K : OAI.CoarseAssembly.Analytic.End c.space) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : OAI.CoarseAssembly.Analytic.End c.space)) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + + exact { + space := c.space + representation := c.representation + operator := c.operator + K + commutator_compact a := by + have he : (c.operator + K) * c.representation a - c.representation a * (c.operator + K) = + (c.operator * c.representation a - c.representation a * c.operator) + + (K * c.representation a - c.representation a * K) := by noncomm_ring + rw [he] + exact (c.commutator_compact a).add + ((( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) hK _).sub (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) hK _)) + square_compact a := by + have he : ((c.operator + K) * (c.operator + K) - 1) * c.representation a = + (c.operator * c.operator - 1) * c.representation a + + (c.operator * K) * c.representation a + + (K * c.operator) * c.representation a + (K * K) * c.representation a := by + noncomm_ring + rw [he] + exact (((c.square_compact a).add + (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) hK _) _)).add + (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) hK _) _)).add + (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) hK _) _) + adjoint_compact a := by + have he : (star (c.operator + K) - (c.operator + K)) * c.representation a = + (star c.operator - c.operator) * c.representation a + + (star K - K) * c.representation a := by + rw [star_add] + noncomm_ring + rw [he] + exact (c.adjoint_compact a).add (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) (hKs.sub hK) _) + } + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] + + +def OddCycle.localCompactPerturb (c : OAI.CoarseAssembly.Analytic.OddCycle A) (K : OAI.CoarseAssembly.Analytic.End c.space) + (hr : ∀ a, IsCompactOperator (K * c.representation a : OAI.CoarseAssembly.Analytic.End c.space)) + (hl : ∀ a, IsCompactOperator (c.representation a * K : OAI.CoarseAssembly.Analytic.End c.space)) + (hs : ∀ a, IsCompactOperator (star K * c.representation a : OAI.CoarseAssembly.Analytic.End c.space)) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + + exact { + space := c.space + representation := c.representation + operator := c.operator + K + commutator_compact a := by + have he : (c.operator + K) * c.representation a - c.representation a * (c.operator + K) = + (c.operator * c.representation a - c.representation a * c.operator) + + (K * c.representation a - c.representation a * K) := by noncomm_ring + rw [he] + exact (c.commutator_compact a).add ((hr a).sub (hl a)) + square_compact a := by + have he : ((c.operator + K) * (c.operator + K) - 1) * c.representation a = + (c.operator * c.operator - 1) * c.representation a + + c.operator * (K * c.representation a) + + K * (c.operator * c.representation a - c.representation a * c.operator) + + (K * c.representation a) * c.operator + K * (K * c.representation a) := by + noncomm_ring + rw [he] + exact ((((c.square_compact a).add (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) (hr a) _)).add + (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) (c.commutator_compact a) _)).add + (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) (hr a) _)).add (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) (hr a) _) + adjoint_compact a := by + have he : (star (c.operator + K) - (c.operator + K)) * c.representation a = + (star c.operator - c.operator) * c.representation a + + (star K * c.representation a - K * c.representation a) := by + rw [star_add] + noncomm_ring + rw [he] + exact (c.adjoint_compact a).add ((hs a).sub (hr a)) + } + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + + +def symmetricCutDown (P F : End H) : End H := + (1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P) + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +def OddCycle.scalarRestriction (c : OddCycle A) : OddCycle ℂ := + c.precomp (StarAlgHom.ofId ℂ A).toNonUnitalStarAlgHom + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +def representedCorrection (c : OddCycle A) : End c.space := + symmetricCutDown (c.representation 1) c.operator - c.operator + +def OddCycle.cutDown (c : OAI.CoarseAssembly.Analytic.OddCycle A) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + have OAI.CoarseAssembly.Analytic.scalarCutDown_compact (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) : + let P := c.representation 1 + let K := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator + IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) ∧ + IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) ∧ + IsCompactOperator (star K * P : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + let P := c.representation 1 + let K := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator + have hp : IsSelfAdjoint P := ( + let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) : IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c + have hpp : P * P = P := ( + let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) : c.representation 1 * c.representation 1 = + c.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by rw [← map_mul, one_mul] + local_proof) c + have hd := c.adjoint_compact 1 + have hc := c.commutator_compact 1 + have hr : IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) := by + dsimp only [K] + rw [( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : + (OAI.CoarseAssembly.Analytic.symmetricCutDown P F - F) * P = -(F * P - P * F) * P + + (1 / 2 : ℝ) • (P * ((star F - F) * P)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + simp only [OAI.CoarseAssembly.Analytic.symmetricCutDown, sub_mul, add_mul, smul_mul_assoc, + star_mul, hP.star_eq, mul_sub, mul_assoc, hPP, one_mul, neg_mul] + module + local_proof) P c.operator hp hpp] + exact (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) hc.neg P).add ((( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) hd P).smul (1 / 2 : ℝ)) + have hl : IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) := by + dsimp only [K] + rw [( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : + P * (OAI.CoarseAssembly.Analytic.symmetricCutDown P F - F) = P * (F * P - P * F) + + (1 / 2 : ℝ) • (P * ((star F - F) * P)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + simp only [OAI.CoarseAssembly.Analytic.symmetricCutDown, mul_sub, mul_add, mul_smul_comm, + star_mul, hP.star_eq, sub_mul, ← mul_assoc, hPP, mul_one] + module + local_proof) P c.operator hp hpp] + exact (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) hc P).add ((( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) hd P).smul (1 / 2 : ℝ)) + refine ⟨hr, hl, ?_⟩ + have he : star K * P = K * P - (star c.operator - c.operator) * P := by + dsimp only [K] + rw [star_sub, (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _ + rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq] + rw [add_comm (star (P * F * P))] + rfl + local_proof) P c.operator hp).star_eq] + noncomm_ring + rw [he] + exact hr.sub hd + have OAI.CoarseAssembly.Analytic.representedCutDown_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + let P := c.representation 1 + let K := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator + IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) ∧ + IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) ∧ + IsCompactOperator (star K * P : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have h := OAI.CoarseAssembly.Analytic.scalarCutDown_compact c.scalarRestriction + change let P : OAI.CoarseAssembly.Analytic.End c.space := c.representation (algebraMap ℂ A 1) + let K : OAI.CoarseAssembly.Analytic.End c.space := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator + IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) ∧ + IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) ∧ + IsCompactOperator (star K * P : OAI.CoarseAssembly.Analytic.End c.space) at h + simpa only [map_one] using h + have OAI.CoarseAssembly.Analytic.representedCorrection_right {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) : + IsCompactOperator (OAI.CoarseAssembly.Analytic.representedCorrection c * c.representation a : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hp : c.representation 1 * c.representation a = c.representation a := by + rw [← map_mul, one_mul] + rw [← hp, ← mul_assoc] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) (OAI.CoarseAssembly.Analytic.representedCutDown_compact c).1 _ + have OAI.CoarseAssembly.Analytic.representedCorrection_left {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) : + IsCompactOperator (c.representation a * OAI.CoarseAssembly.Analytic.representedCorrection c : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hp : c.representation a * c.representation 1 = c.representation a := by + rw [← map_mul, mul_one] + rw [← hp, mul_assoc] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) (OAI.CoarseAssembly.Analytic.representedCutDown_compact c).2.1 _ + have OAI.CoarseAssembly.Analytic.representedCorrection_star {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) : + IsCompactOperator (star (OAI.CoarseAssembly.Analytic.representedCorrection c) * c.representation a : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hp : c.representation 1 * c.representation a = c.representation a := by + rw [← map_mul, one_mul] + rw [← hp, ← mul_assoc] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) (OAI.CoarseAssembly.Analytic.representedCutDown_compact c).2.2 _ + exact c.localCompactPerturb (OAI.CoarseAssembly.Analytic.representedCorrection c) (OAI.CoarseAssembly.Analytic.representedCorrection_right c) + (OAI.CoarseAssembly.Analytic.representedCorrection_left c) (OAI.CoarseAssembly.Analytic.representedCorrection_star c) + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] {H : HilbertSpace} + + +def completedRepresentation (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + A →⋆ₙₐ[ℂ] OAI.CoarseAssembly.Analytic.End c.space := by + classical + have OAI.CoarseAssembly.Analytic.representation_unit_projection {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsStarProjection (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + ⟨( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.representation 1 * c.representation 1 = c.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [← map_mul, one_mul] + local_proof) c, ( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c⟩ + exact { + toFun a := c.representation a + χ a • (1 - c.representation 1) + map_zero' := by simp + map_add' a b := by simp only [map_add, add_smul]; abel + map_smul' z a := by simp [smul_add, smul_smul] + map_star' a := by + simp only [map_star, star_add, star_smul, star_sub, star_one, + (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c).star_eq] + map_mul' a b := by + have hQ := (OAI.CoarseAssembly.Analytic.representation_unit_projection c).one_sub.isIdempotentElem + rw [map_mul, add_mul, mul_add, mul_add, mul_smul_comm, + ( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) : + c.representation a * (1 - c.representation 1) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [mul_sub, mul_one, ← map_mul, mul_one, sub_self] + local_proof), smul_zero, smul_mul_assoc, + ( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) : + (1 - c.representation 1) * c.representation a = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [sub_mul, one_mul, ← map_mul, one_mul, sub_self] + local_proof), smul_zero, smul_mul_assoc, mul_smul_comm, + hQ, smul_smul] + simp only [map_mul, add_zero, zero_add] + } + +def OddCycle.characterExtension (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) + (hF : IsSelfAdjoint c.operator) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) + (hsq : IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + + exact { + space := c.space + representation := OAI.CoarseAssembly.Analytic.completedRepresentation c χ + operator := c.operator + commutator_compact a := by + have hQ' : (1 - c.representation 1) * c.operator = 1 - c.representation 1 := by + have h := congrArg star hQ + simpa only [star_mul, star_sub, star_one, hF.star_eq, + (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c).star_eq] using h + change IsCompactOperator + (c.operator * (c.representation a + χ a • (1 - c.representation 1)) - + (c.representation a + χ a • (1 - c.representation 1)) * c.operator : OAI.CoarseAssembly.Analytic.End c.space) + simpa only [mul_add, add_mul, mul_smul_comm, smul_mul_assoc, hQ, hQ', + add_sub_add_right_eq_sub] using c.commutator_compact a + square_compact a := ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) hsq _ + adjoint_compact a := by + rw [hF.star_eq, sub_self, zero_mul] + exact isCompactOperator_zero + } + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty + +universe u + +variable {X Y Z : Type u} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] + +abbrev LocallyFiniteK1 (X : Type u) [TopologicalSpace X] := OddK C₀(X, ℂ) + +def pullback (f : CocompactMap X Y) : C₀(Y, ℂ) →⋆ₙₐ[ℂ] C₀(X, ℂ) where + toNonUnitalAlgHom := ZeroAtInftyContinuousMap.compNonUnitalAlgHom f + map_star' a := by ext x; rfl + +def pushforward (f : CocompactMap X Y) : LocallyFiniteK1 X →+ LocallyFiniteK1 Y := + precomp (pullback f) + +structure Coarsening where + space : ℕ → Type u + topology : ∀ n, TopologicalSpace (space n) + inclusion : ∀ r s, r ≤ s → @CocompactMap (space r) (space s) (topology r) (topology s) + inclusion_self : ∀ r h, inclusion r r h = @CocompactMap.id (space r) (topology r) + inclusion_comp : ∀ r s t hrs hst, + inclusion r t (hrs.trans hst) = (inclusion s t hst).comp (inclusion r s hrs) + +attribute [instance] Coarsening.topology + +namespace Coarsening + +def map (C : Coarsening) (r s : ℕ) (h : r ≤ s) : + LocallyFiniteK1 (C.space r) →+ LocallyFiniteK1 (C.space s) := + pushforward (C.inclusion r s h) + +abbrev Homology (C : Coarsening) := + AddCommGroup.DirectLimit (fun r => LocallyFiniteK1 (C.space r)) (fun r s h => C.map r s h) + +end Coarsening + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +variable (X : Type*) [PseudoMetricSpace X] + +@[ext] structure Point (r : ℝ) where + weight : X →₀ ℝ + nonneg : ∀ x, 0 ≤ weight x + total : weight.sum (fun _ t => t) = 1 + diameter : ∀ x ∈ weight.support, ∀ y ∈ weight.support, dist x y ≤ r + +variable {X} + +def coordinates {r : ℝ} (p : Point X r) : X → ℝ := p.weight + +instance (r : ℝ) : TopologicalSpace (Point X r) := + TopologicalSpace.induced coordinates inferInstance + +instance (r : ℝ) : T2Space (OAI.CoarseAssembly.Rips.Point X r) := by + classical + + exact (IsEmbedding.mk ⟨rfl⟩ ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Function.Injective (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + intro p q h + apply OAI.CoarseAssembly.Rips.Point.ext + exact Finsupp.ext (congrFun h) + local_proof)).t2Space + +def coarsen {r s : ℝ} (h : r ≤ s) (p : Point X r) : Point X s where + weight := p.weight + nonneg := p.nonneg + total := p.total + diameter x hx y hy := (p.diameter x hx y hy).trans h + +def inclusion {r s : ℝ} (h : r ≤ s) : CocompactMap (OAI.CoarseAssembly.Rips.Point X r) (OAI.CoarseAssembly.Rips.Point X s) := by + classical + have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) : + Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + (continuous_apply x).comp ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + continuous_induced_dom + local_proof) + have OAI.CoarseAssembly.Rips.coarsen_closedEmbedding {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s : ℝ} (h : r ≤ s) : + Topology.IsClosedEmbedding (OAI.CoarseAssembly.Rips.coarsen (X := X) h) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + refine ⟨( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s : ℝ} (h : r ≤ s) : IsEmbedding (OAI.CoarseAssembly.Rips.coarsen (X := X) h) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + exact { + eq_induced := by + change TopologicalSpace.induced OAI.CoarseAssembly.Rips.coordinates _ = + TopologicalSpace.induced (OAI.CoarseAssembly.Rips.coarsen h) (TopologicalSpace.induced OAI.CoarseAssembly.Rips.coordinates _) + rw [induced_compose] + rfl + injective := by + intro p q heq + apply OAI.CoarseAssembly.Rips.Point.ext + exact congrArg (fun p : OAI.CoarseAssembly.Rips.Point X s => p.weight) heq + } + local_proof) h, ?_⟩ + rw [( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s : ℝ} (h : r ≤ s) : + Set.range (OAI.CoarseAssembly.Rips.coarsen (X := X) h) = + {p : OAI.CoarseAssembly.Rips.Point X s | ∀ x y, r < dist x y → p.weight x = 0 ∨ p.weight y = 0} := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + ext p + constructor + · rintro ⟨q, rfl⟩ x y hxy + by_cases hx : q.weight x = 0 + · exact Or.inl hx + by_cases hy : q.weight y = 0 + · exact Or.inr hy + exact False.elim ((not_le_of_gt hxy) + (q.diameter x (Finsupp.mem_support_iff.mpr hx) y (Finsupp.mem_support_iff.mpr hy))) + · intro hp + let q : OAI.CoarseAssembly.Rips.Point X r := + { weight := p.weight + nonneg := p.nonneg + total := p.total + diameter := by + intro x hx y hy + by_contra hxy + rcases hp x y (lt_of_not_ge hxy) with hx' | hy' + · exact Finsupp.mem_support_iff.mp hx hx' + · exact Finsupp.mem_support_iff.mp hy hy' } + exact ⟨q, by apply OAI.CoarseAssembly.Rips.Point.ext; rfl⟩ + local_proof) h] + simp only [Set.ofPred_forall] + refine isClosed_iInter (fun x => isClosed_iInter (fun y => isClosed_iInter (fun _ => ?_))) + exact (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous x) continuous_const).union + (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous y) continuous_const) + exact { + toFun := OAI.CoarseAssembly.Rips.coarsen h + continuous_toFun := (OAI.CoarseAssembly.Rips.coarsen_closedEmbedding h).continuous + cocompact_tendsto' := (OAI.CoarseAssembly.Rips.coarsen_closedEmbedding h).tendsto_cocompact + } + +def coarsening (X : Type*) [PseudoMetricSpace X] : OAI.CoarseAssembly.Analytic.Coarsening := by + classical + + exact { + space n := OAI.CoarseAssembly.Rips.Point X (n : ℝ) + topology _ := inferInstance + inclusion _ _ h := OAI.CoarseAssembly.Rips.inclusion (by exact_mod_cast h) + inclusion_self r _ := ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] (r : ℝ) (h : r ≤ r) : + OAI.CoarseAssembly.Rips.inclusion (X := X) h = CocompactMap.id (OAI.CoarseAssembly.Rips.Point X r) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + apply CocompactMap.ext + intro p + apply OAI.CoarseAssembly.Rips.Point.ext + rfl + local_proof) r _ + inclusion_comp _ _ _ _ _ := ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s t : ℝ} (hrs : r ≤ s) (hst : s ≤ t) : + OAI.CoarseAssembly.Rips.inclusion (X := X) (hrs.trans hst) = (OAI.CoarseAssembly.Rips.inclusion hst).comp (OAI.CoarseAssembly.Rips.inclusion hrs) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + apply CocompactMap.ext + intro p + apply OAI.CoarseAssembly.Rips.Point.ext + rfl + local_proof) _ _ + } + +abbrev KX1 (X : Type*) [PseudoMetricSpace X] := (coarsening X).Homology + +end CoarseAssembly.Rips + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open scoped BigOperators + +open unitInterval + +variable {X : Type*} [PseudoMetricSpace X] {r : ℝ} + +def vertex (x : X) (hr : 0 ≤ r) : Point X r where + weight := Finsupp.single x 1 + nonneg y := by + classical + simp only [Finsupp.single_apply] + split_ifs <;> norm_num + total := by simp + diameter y hy z hz := by + have hy' : y = x := by simpa using hy + have hz' : z = x := by simpa using hz + simpa [hy', hz'] using hr + +end CoarseAssembly.Rips + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open scoped BigOperators +open Topology + +variable {X : Type*} [PseudoMetricSpace X] [Fintype X] (r : ℝ) + +instance : CompactSpace (OAI.CoarseAssembly.Rips.Point X r) := by + classical + have OAI.CoarseAssembly.Rips.range_coordinates {X : Type _} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) : + Set.range (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) = + {f : X → ℝ | (∀ x, 0 ≤ f x) ∧ (∑ x, f x) = 1 ∧ + ∀ x y, r < dist x y → f x = 0 ∨ f y = 0} := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open scoped BigOperators in + open Topology in + by + classical + ext f + constructor + · rintro ⟨p, rfl⟩ + refine ⟨p.nonneg, (( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} [inst_local_3 : Fintype X] (p : OAI.CoarseAssembly.Rips.Point X r) : ∑ x : X, p.weight x = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open scoped BigOperators in + open Topology in + by + rw [← p.total] + exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm + local_proof) p), ?_⟩ + intro x y hxy + by_cases hx : p.weight x = 0 + · exact Or.inl hx + by_cases hy : p.weight y = 0 + · exact Or.inr hy + exact False.elim ((not_le_of_gt hxy) + (p.diameter x (Finsupp.mem_support_iff.mpr hx) y (Finsupp.mem_support_iff.mpr hy))) + · rintro ⟨hnn, ht, hd⟩ + let p : OAI.CoarseAssembly.Rips.Point X r := + { weight := Finsupp.equivFunOnFinite.symm f + nonneg := hnn + total := by + rw [Finsupp.sum_fintype _ _ (by simp)] + exact ht + diameter := by + intro x hx y hy + by_contra h + rcases hd x y (lt_of_not_ge h) with hx' | hy' + · exact Finsupp.mem_support_iff.mp hx hx' + · exact Finsupp.mem_support_iff.mp hy hy' } + exact ⟨p, rfl⟩ + have OAI.CoarseAssembly.Rips.coordinates_closed {X : Type _} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) : IsClosed (Set.range (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r))) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open scoped BigOperators in + open Topology in + by + rw [OAI.CoarseAssembly.Rips.range_coordinates] + have hnn : IsClosed {f : X → ℝ | ∀ x, 0 ≤ f x} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun x => isClosed_le continuous_const (continuous_apply x) + have ht : IsClosed {f : X → ℝ | (∑ x, f x) = 1} := + isClosed_eq (continuous_finsetSum _ (fun x _ => continuous_apply x)) continuous_const + have hd : IsClosed {f : X → ℝ | ∀ x y, r < dist x y → f x = 0 ∨ f y = 0} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun x => isClosed_iInter fun y => isClosed_iInter fun _ => + (isClosed_eq (continuous_apply x) continuous_const).union + (isClosed_eq (continuous_apply y) continuous_const) + exact hnn.inter (ht.inter hd) + have OAI.CoarseAssembly.Rips.coordinates_compact {X : Type _} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) : IsCompact (Set.range (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r))) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open scoped BigOperators in + open Topology in + by + apply IsCompact.of_isClosed_subset (isCompact_Icc (a := (0 : X → ℝ)) (b := 1)) + (OAI.CoarseAssembly.Rips.coordinates_closed r) + rintro f ⟨p, rfl⟩ + refine ⟨p.nonneg, ?_⟩ + intro x + calc + p.weight x ≤ ∑ y : X, p.weight y := Finset.single_le_sum (fun y _ => p.nonneg y) + (Finset.mem_univ x) + _ = 1 := (( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} [inst_local_3 : Fintype X] (p : OAI.CoarseAssembly.Rips.Point X r) : ∑ x : X, p.weight x = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open scoped BigOperators in + open Topology in + by + rw [← p.total] + exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm + local_proof) p) + apply isCompact_univ_iff.mp + have he : IsEmbedding (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) := + ⟨⟨rfl⟩, ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Function.Injective (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + intro p q h + apply OAI.CoarseAssembly.Rips.Point.ext + exact Finsupp.ext (congrFun h) + local_proof)⟩ + apply he.isCompact_iff.mpr + simpa only [Set.image_univ] using OAI.CoarseAssembly.Rips.coordinates_compact (X := X) r + +end CoarseAssembly.Rips + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Topology + +open scoped ZeroAtInfty + +variable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y] + [CompactSpace X] [T2Space Y] + + +def zeroExtension (e : X ↪ Y) (he : IsOpenEmbedding e) (f : C₀(X, ℂ)) : C₀(Y, ℂ) := by + classical + + exact { + toFun := Function.extend e f 0 + continuous_toFun := ( + let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e) + (f : C₀(X, ℂ)) : Continuous (Function.extend e f 0) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open Topology in + open scoped ZeroAtInfty in + by + have hs := HasCompactSupport.of_compactSpace (f : X → ℂ) + apply continuous_of_tsupport + intro y hy + obtain ⟨x, _, rfl⟩ := hs.tsupport_extend_zero_subset he.continuous hy + rw [← he.continuousAt_iff, Function.extend_comp e.injective] + exact f.continuous.continuousAt + local_proof) e he f + zero_at_infty' := ((HasCompactSupport.of_compactSpace (f : X → ℂ)).extend_zero + he.continuous).is_zero_at_infty + } + +def zeroExtensionHom (e : X ↪ Y) (he : IsOpenEmbedding e) : + C₀(X, ℂ) →⋆ₙₐ[ℂ] C₀(Y, ℂ) := by + classical + + have extension_eval (f : C₀(X, ℂ)) (x : X) : + OAI.CoarseAssembly.Analytic.zeroExtension e he f (e x) = f x := + e.injective.extend_apply _ _ x + exact { + toFun := OAI.CoarseAssembly.Analytic.zeroExtension e he + map_zero' := by + ext y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simp [extension_eval] + · simp [( + let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e) + (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open Topology in + open scoped ZeroAtInfty in + Function.extend_apply' _ _ _ hy + local_proof) e he _ hy] + map_add' f g := by + ext y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simp [extension_eval] + · simp [( + let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e) + (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open Topology in + open scoped ZeroAtInfty in + Function.extend_apply' _ _ _ hy + local_proof) e he _ hy] + map_mul' f g := by + ext y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simp [extension_eval] + · simp [( + let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e) + (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open Topology in + open scoped ZeroAtInfty in + Function.extend_apply' _ _ _ hy + local_proof) e he _ hy] + map_smul' c f := by + ext y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simp [extension_eval] + · simp [( + let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e) + (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open Topology in + open scoped ZeroAtInfty in + Function.extend_apply' _ _ _ hy + local_proof) e he _ hy] + map_star' f := by + ext y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simp [extension_eval] + · simp [( + let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e) + (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open Topology in + open scoped ZeroAtInfty in + Function.extend_apply' _ _ _ hy + local_proof) e he _ hy] + } + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +def cayleyDenominator (F : A) (hF : IsSelfAdjoint F) : Aˣ := by + classical + + exact (( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + IsUnit (F + algebraMap ℂ A Complex.I) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hn : -Complex.I ∉ spectrum ℂ F := by + intro h + have hi := hF.im_eq_zero_of_mem_spectrum h + simp at hi + have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) := + not_not.mp (fun h => hn (spectrum.mem_iff.mpr h)) + convert hu.neg using 1 + simp only [map_neg, neg_sub, sub_neg_eq_add] + local_proof) F hF).unit + +def cayleyUnitary (F : A) (hF : IsSelfAdjoint F) : unitary A := by + classical + have OAI.CoarseAssembly.Analytic.cayleyDenominator_val {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F + algebraMap ℂ A Complex.I := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + IsUnit (F + algebraMap ℂ A Complex.I) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hn : -Complex.I ∉ spectrum ℂ F := by + intro h + have hi := hF.im_eq_zero_of_mem_spectrum h + simp at hi + have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) := + not_not.mp (fun h => hn (spectrum.mem_iff.mpr h)) + convert hu.neg using 1 + simp only [map_neg, neg_sub, sub_neg_eq_add] + local_proof) F hF).unit_spec + have OAI.CoarseAssembly.Analytic.cayleyDenominator_star {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F - algebraMap ℂ A Complex.I := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_val, star_add, hF.star_eq] + simp only [← algebraMap_star_comm, Complex.star_def, Complex.conj_I, map_neg, + sub_eq_add_neg] + have OAI.CoarseAssembly.Analytic.cayleyDenominator_normal {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + Commute (star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val] + have hc : Commute (algebraMap ℂ A Complex.I) F := Algebra.commutes _ _ + exact ((Commute.refl F).sub_left hc).add_right + (hc.symm.sub_left (Commute.refl _)) + let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF + refine ⟨(star b * b⁻¹ : Aˣ), (Units.mul_inv_mem_unitary (star b) b).mpr ?_⟩ + apply Units.ext + change star (star (b : A)) * star (b : A) = star (b : A) * (b : A) + rw [star_star] + exact (OAI.CoarseAssembly.Analytic.cayleyDenominator_normal F hF).eq.symm + +def rationalBoundaryUnitary (F : A) (hF : IsSelfAdjoint F) : unitary A := + -(cayleyUnitary F hF * cayleyUnitary F hF) + + +end CoarseAssembly.Analytic + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +def boundedTransform (F : A) (hF : IsSelfAdjoint F) : A := + (Complex.I / 2 : ℂ) • ((cayleyUnitary F hF : A) - star (cayleyUnitary F hF : A)) + +section + +attribute [local instance 2000] instIsDomain instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisors + +end + +variable {H : HilbertSpace} + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + + +def OddCycle.bounded (c : OAI.CoarseAssembly.Analytic.OddCycle A) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + have OAI.CoarseAssembly.Analytic.cayleyDenominator_val {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F + algebraMap ℂ A Complex.I := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + IsUnit (F + algebraMap ℂ A Complex.I) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hn : -Complex.I ∉ spectrum ℂ F := by + intro h + have hi := hF.im_eq_zero_of_mem_spectrum h + simp at hi + have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) := + not_not.mp (fun h => hn (spectrum.mem_iff.mpr h)) + convert hu.neg using 1 + simp only [map_neg, neg_sub, sub_neg_eq_add] + local_proof) F hF).unit_spec + have OAI.CoarseAssembly.Analytic.cayleyDenominator_star {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F - algebraMap ℂ A Complex.I := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_val, star_add, hF.star_eq] + simp only [← algebraMap_star_comm, Complex.star_def, Complex.conj_I, map_neg, + sub_eq_add_neg] + have OAI.CoarseAssembly.Analytic.cayleyDenominator_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F * F + 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val] + have hi : algebraMap ℂ A Complex.I * algebraMap ℂ A Complex.I = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hc := Algebra.commutes (R := ℂ) (A := A) Complex.I F + noncomm_ring [hc, hi] + have OAI.CoarseAssembly.Analytic.cayleyUnitary_mul_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) * + ((OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) = + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) = + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + rfl + local_proof)] + calc + _ = star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * + (((↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) * (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) * + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) := by noncomm_ring + _ = _ := by rw [Units.inv_mul, one_mul] + have OAI.CoarseAssembly.Analytic.cayleyDenominator_normal {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + Commute (star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val] + have hc : Commute (algebraMap ℂ A Complex.I) F := Algebra.commutes _ _ + exact ((Commute.refl F).sub_left hc).add_right + (hc.symm.sub_left (Commute.refl _)) + have OAI.CoarseAssembly.Analytic.star_cayleyUnitary_mul_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + star (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) * + ((OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) = + (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF + have hc : Commute (b : A) (star (b : A)) := (OAI.CoarseAssembly.Analytic.cayleyDenominator_normal F hF).symm + rw [( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) = + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + rfl + local_proof), star_mul, star_star, ← Units.coe_star_inv] + change ((↑(star b)⁻¹ : A) * (b : A)) * ((b : A) * star (b : A)) = (b : A) * (b : A) + calc + _ = (↑(star b)⁻¹ : A) * ((b : A) * ((b : A) * star (b : A))) := by noncomm_ring + _ = (↑(star b)⁻¹ : A) * ((b : A) * (star (b : A) * (b : A))) := by rw [hc.eq] + _ = (↑(star b)⁻¹ : A) * (((b : A) * star (b : A)) * (b : A)) := by noncomm_ring + _ = (↑(star b)⁻¹ : A) * ((star (b : A) * (b : A)) * (b : A)) := by rw [hc.eq] + _ = ((↑(star b)⁻¹ : A) * star (b : A)) * ((b : A) * (b : A)) := by noncomm_ring + _ = _ := by rw [← Units.coe_star, Units.inv_mul, one_mul] + have OAI.CoarseAssembly.Analytic.boundedTransform_mul_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + OAI.CoarseAssembly.Analytic.boundedTransform F hF * + ((OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) = (2 : ℂ) • F := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + unfold OAI.CoarseAssembly.Analytic.boundedTransform + rw [smul_mul_assoc, sub_mul, OAI.CoarseAssembly.Analytic.cayleyUnitary_mul_normSquare, OAI.CoarseAssembly.Analytic.star_cayleyUnitary_mul_normSquare] + have hp : star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) - + (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = + (-4 * Complex.I : ℂ) • F := by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val, Algebra.smul_def] + simp only [map_mul, map_neg, map_ofNat] + have hc := Algebra.commutes (R := ℂ) (A := A) Complex.I F + noncomm_ring [hc] + rw [hp, smul_smul] + have hs : (Complex.I / 2) * (-4 * Complex.I) = (2 : ℂ) := by + calc + _ = -2 * (Complex.I * Complex.I) := by ring + _ = 2 := by rw [Complex.I_mul_I]; norm_num + rw [hs] + have OAI.CoarseAssembly.Analytic.boundedTransform_sub_compact {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (F : OAI.CoarseAssembly.Analytic.End H) (hF : IsSelfAdjoint F) + (hK : IsCompactOperator (F * F - 1 : OAI.CoarseAssembly.Analytic.End H)) : + IsCompactOperator (OAI.CoarseAssembly.Analytic.boundedTransform F hF - F : OAI.CoarseAssembly.Analytic.End H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF + have hm : IsCompactOperator ((OAI.CoarseAssembly.Analytic.boundedTransform F hF - F) * ((b : OAI.CoarseAssembly.Analytic.End H) * star (b : OAI.CoarseAssembly.Analytic.End H))) := by + rw [sub_mul, OAI.CoarseAssembly.Analytic.boundedTransform_mul_normSquare, OAI.CoarseAssembly.Analytic.cayleyDenominator_normSquare] + have he : (2 : ℂ) • F - F * (F * F + 1) = -(F * (F * F - 1)) := by + rw [Algebra.smul_def] + simp only [map_ofNat] + noncomm_ring + rw [he] + exact (( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) hK F).neg + let v : (OAI.CoarseAssembly.Analytic.End H)ˣ := b * star b + change IsCompactOperator ((OAI.CoarseAssembly.Analytic.boundedTransform F hF - F) * (v : OAI.CoarseAssembly.Analytic.End H)) at hm + have hn := ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (K * T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.comp_clm T + local_proof) hm (↑v⁻¹ : OAI.CoarseAssembly.Analytic.End H) + rwa [mul_assoc, Units.mul_inv, mul_one] at hn + have OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : + IsCompactOperator (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + apply OAI.CoarseAssembly.Analytic.boundedTransform_sub_compact + simpa only [hπ, mul_one] using c.square_compact 1 + have OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_star_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : + IsCompactOperator (star (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator) : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [((( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.boundedTransform F hF) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (OAI.CoarseAssembly.Analytic.boundedTransform F hF) = OAI.CoarseAssembly.Analytic.boundedTransform F hF + simp only [OAI.CoarseAssembly.Analytic.boundedTransform, star_smul, star_sub, star_star, Complex.star_def, + map_div₀, Complex.conj_I, map_ofNat, neg_div, neg_smul] + module + local_proof) c.operator hs).sub hs).star_eq] + exact (OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact c hπ hs) + exact { + space := c.space + representation := c.representation + operator := OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs + commutator_compact a := by + have h := (c.compactPerturb _ ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact c hπ hs)) + ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_star_compact c hπ hs))).commutator_compact a + change IsCompactOperator ((c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) * + c.representation a - c.representation a * (c.operator + + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) : OAI.CoarseAssembly.Analytic.End c.space) at h + have he : c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator) = + OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs := by abel + rwa [he] at h + square_compact a := by + have h := (c.compactPerturb _ ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact c hπ hs)) + ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_star_compact c hπ hs))).square_compact a + change IsCompactOperator (((c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) * + (c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) - 1) * c.representation a : + OAI.CoarseAssembly.Analytic.End c.space) at h + have he : c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator) = + OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs := by abel + rwa [he] at h + adjoint_compact a := by + rw [(( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.boundedTransform F hF) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (OAI.CoarseAssembly.Analytic.boundedTransform F hF) = OAI.CoarseAssembly.Analytic.boundedTransform F hF + simp only [OAI.CoarseAssembly.Analytic.boundedTransform, star_smul, star_sub, star_star, Complex.star_def, + map_div₀, Complex.conj_I, map_ofNat, neg_div, neg_smul] + module + local_proof) c.operator hs).star_eq, sub_self, zero_mul] + exact isCompactOperator_zero + } + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + + +def OddCycle.unitalSelfAdjoint (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + have OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : IsSelfAdjoint c.cutDown.operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [(( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.cutDown.operator = OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change c.operator + (OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator - c.operator) = _ + abel + local_proof) c)] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _ + rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq] + rw [add_comm (star (P * F * P))] + rfl + local_proof) _ _ (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c) + have OAI.CoarseAssembly.Analytic.cutDown_complement {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.cutDown.operator * (1 - c.cutDown.representation 1) = 1 - c.cutDown.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change (c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c) * (1 - c.representation 1) = 1 - c.representation 1 + have he : c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c = + OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := by unfold OAI.CoarseAssembly.Analytic.representedCorrection; abel + rw [he] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : OAI.CoarseAssembly.Analytic.symmetricCutDown P F * (1 - P) = 1 - P := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hzero : ∀ T : OAI.CoarseAssembly.Analytic.End H, P * T * P * (1 - P) = 0 := by + intro T + rw [mul_sub, mul_one, mul_assoc (P * T) P P, hPP, sub_self] + have hQ : (1 - P) * (1 - P) = 1 - P := by + calc + (1 - P) * (1 - P) = 1 - P - P + P * P := by noncomm_ring + _ = 1 - P := by rw [hPP]; abel + unfold OAI.CoarseAssembly.Analytic.symmetricCutDown + rw [add_mul, smul_mul_assoc, add_mul, hzero F, + star_mul, star_mul, hP.star_eq, ← mul_assoc, hzero (star F), add_zero, smul_zero, zero_add, hQ] + local_proof) _ _ (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c) (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.representation 1 * c.representation 1 = c.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [← map_mul, one_mul] + local_proof) c) + have OAI.CoarseAssembly.Analytic.represented_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + apply ( + let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hz : (c.operator * c.operator - 1) * (1 - c.representation 1) = 0 := by + calc + _ = c.operator * (c.operator * (1 - c.representation 1)) - + (1 - c.representation 1) := by noncomm_ring + _ = 0 := by rw [hQ, hQ, sub_self] + have he : c.operator * c.operator - 1 = + (c.operator * c.operator - 1) * c.representation 1 := by + exact sub_eq_zero.mp (by simpa only [mul_sub, mul_one] using hz) + rw [he] + exact c.square_compact 1 + local_proof) c.scalarRestriction + change c.operator * (1 - c.representation (algebraMap ℂ A 1)) = + 1 - c.representation (algebraMap ℂ A 1) + simpa only [map_one] using hQ + have OAI.CoarseAssembly.Analytic.cutDown_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsCompactOperator (c.cutDown.operator * c.cutDown.operator - 1 : OAI.CoarseAssembly.Analytic.End c.cutDown.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.represented_square_compact c.cutDown (OAI.CoarseAssembly.Analytic.cutDown_complement c) + exact c.cutDown.characterExtension χ (OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c) (OAI.CoarseAssembly.Analytic.cutDown_complement c) + (OAI.CoarseAssembly.Analytic.cutDown_square_compact c) + +variable {T : Type*} [TopologicalSpace T] {H : HilbertSpace} + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + + +def OddCycle.regularize (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + have OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : IsSelfAdjoint c.cutDown.operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [(( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.cutDown.operator = OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change c.operator + (OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator - c.operator) = _ + abel + local_proof) c)] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _ + rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq] + rw [add_comm (star (P * F * P))] + rfl + local_proof) _ _ (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c) + have OAI.CoarseAssembly.Analytic.cutDown_complement {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.cutDown.operator * (1 - c.cutDown.representation 1) = 1 - c.cutDown.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change (c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c) * (1 - c.representation 1) = 1 - c.representation 1 + have he : c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c = + OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := by unfold OAI.CoarseAssembly.Analytic.representedCorrection; abel + rw [he] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : OAI.CoarseAssembly.Analytic.symmetricCutDown P F * (1 - P) = 1 - P := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hzero : ∀ T : OAI.CoarseAssembly.Analytic.End H, P * T * P * (1 - P) = 0 := by + intro T + rw [mul_sub, mul_one, mul_assoc (P * T) P P, hPP, sub_self] + have hQ : (1 - P) * (1 - P) = 1 - P := by + calc + (1 - P) * (1 - P) = 1 - P - P + P * P := by noncomm_ring + _ = 1 - P := by rw [hPP]; abel + unfold OAI.CoarseAssembly.Analytic.symmetricCutDown + rw [add_mul, smul_mul_assoc, add_mul, hzero F, + star_mul, star_mul, hP.star_eq, ← mul_assoc, hzero (star F), add_zero, smul_zero, zero_add, hQ] + local_proof) _ _ (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c) (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.representation 1 * c.representation 1 = c.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [← map_mul, one_mul] + local_proof) c) + have OAI.CoarseAssembly.Analytic.represented_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + apply ( + let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hz : (c.operator * c.operator - 1) * (1 - c.representation 1) = 0 := by + calc + _ = c.operator * (c.operator * (1 - c.representation 1)) - + (1 - c.representation 1) := by noncomm_ring + _ = 0 := by rw [hQ, hQ, sub_self] + have he : c.operator * c.operator - 1 = + (c.operator * c.operator - 1) * c.representation 1 := by + exact sub_eq_zero.mp (by simpa only [mul_sub, mul_one] using hz) + rw [he] + exact c.square_compact 1 + local_proof) c.scalarRestriction + change c.operator * (1 - c.representation (algebraMap ℂ A 1)) = + 1 - c.representation (algebraMap ℂ A 1) + simpa only [map_one] using hQ + have OAI.CoarseAssembly.Analytic.cutDown_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsCompactOperator (c.cutDown.operator * c.cutDown.operator - 1 : OAI.CoarseAssembly.Analytic.End c.cutDown.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.represented_square_compact c.cutDown (OAI.CoarseAssembly.Analytic.cutDown_complement c) + have OAI.CoarseAssembly.Analytic.completedRepresentation_one {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + OAI.CoarseAssembly.Analytic.completedRepresentation c χ 1 = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + simp only [( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) (a : A) : + OAI.CoarseAssembly.Analytic.completedRepresentation c χ a = c.representation a + χ a • (1 - c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + rfl + local_proof), map_one, one_smul] + abel + have OAI.CoarseAssembly.Analytic.characterExtension_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) + (hF : IsSelfAdjoint c.operator) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) + (hsq : IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)) : + (c.characterExtension χ hF hQ hsq).representation 1 = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.completedRepresentation_one c χ + have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.unitalSelfAdjoint χ).representation 1 = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.characterExtension_unital (c.cutDown) χ (OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c) (OAI.CoarseAssembly.Analytic.cutDown_complement c) (OAI.CoarseAssembly.Analytic.cutDown_square_compact c) + have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + IsSelfAdjoint (c.unitalSelfAdjoint χ).operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c + exact (c.unitalSelfAdjoint χ).bounded ((OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital c χ)) ((OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_selfAdjoint c χ)) + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] (r : ℝ) + +def sqrtCoordinate (x : X) : C(OAI.CoarseAssembly.Rips.Point X r, ℂ) := by + classical + have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) : + Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + (continuous_apply x).comp ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + continuous_induced_dom + local_proof) + exact { + toFun p := (Real.sqrt (p.weight x) : ℂ) + continuous_toFun := Complex.continuous_ofReal.comp + (Real.continuous_sqrt.comp (OAI.CoarseAssembly.Rips.coordinate_continuous x)) + } + +end CoarseAssembly.Rips + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def partitionMap (a : X → H →L[ℂ] H) : H →L[ℂ] Module X H := + ∑ x, (insert x).comp (a x) + +def partitionIsometry (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) : H →ₗᵢ[ℂ] OAI.CoarseAssembly.DiscreteRoe.Module X H := by + classical + have OAI.CoarseAssembly.DiscreteRoe.coordinate_partitionMap {X : Type _} {H : Type _} [inst_local_2 : Fintype X] [inst_local_3 : DecidableEq X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] (a : X → H →L[ℂ] H) (x : X) : + (OAI.CoarseAssembly.DiscreteRoe.coordinate x).comp (OAI.CoarseAssembly.DiscreteRoe.partitionMap a) = a x := by + ext v + simp only [OAI.CoarseAssembly.DiscreteRoe.partitionMap, + ContinuousLinearMap.comp_apply, sum_apply, map_sum] + change (∑ y, (lp.single 2 y ((a y) v)) x) = (a x) v + simp [lp.single_apply] + have OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint {X : Type _} {H : Type _} [inst_local_2 : Fintype X] [inst_local_3 : DecidableEq X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (a : X → H →L[ℂ] H) : + (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).adjoint = ∑ x, (a x).adjoint.comp (OAI.CoarseAssembly.DiscreteRoe.coordinate x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + simp only [OAI.CoarseAssembly.DiscreteRoe.partitionMap, map_sum, ContinuousLinearMap.adjoint_comp, ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (x : X) : (OAI.CoarseAssembly.DiscreteRoe.insert (H := H) x).adjoint = OAI.CoarseAssembly.DiscreteRoe.coordinate x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext v + apply ext_inner_left ℂ + intro h + rw [ContinuousLinearMap.adjoint_inner_right] + change inner ℂ (lp.single 2 x h) v = inner ℂ h (v x) + exact lp.inner_single_left (𝕜 := ℂ) x h v + local_proof)] + have OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint_comp {X : Type _} {H : Type _} [inst_local_2 : Fintype X] [inst_local_3 : DecidableEq X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (a : X → H →L[ℂ] H) : + (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).adjoint.comp (OAI.CoarseAssembly.DiscreteRoe.partitionMap a) = ∑ x, (a x).adjoint.comp (a x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + rw [OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint, ContinuousLinearMap.finsetSum_comp] + apply Finset.sum_congr rfl + intro x _ + rw [ContinuousLinearMap.comp_assoc, OAI.CoarseAssembly.DiscreteRoe.coordinate_partitionMap] + exact { + toLinearMap := (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).toLinearMap + norm_map' := (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).norm_map_iff_adjoint_comp_self.mpr + ((OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint_comp a).trans hpart) + } + +end CoarseAssembly.DiscreteRoe + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +def constantBlock (F : H →L[ℂ] H) : Operator X H := + blockOperator (fun _ : X => F) ‖F‖ (norm_nonneg _) (fun _ => le_rfl) + +def partitionCompression (a : X → H →L[ℂ] H) (F : H →L[ℂ] H) : H →L[ℂ] H := + (partitionMap a).adjoint.comp ((constantBlock F).comp (partitionMap a)) + +end CoarseAssembly.DiscreteRoe + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +variable {E H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +def isometricExtension (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) : H →L[ℂ] H := + 1 + operatorConjugationHom V (F - 1) + +end CoarseAssembly + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by + classical + + exact ⟨( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] : Continuous (fun T : OAI.CoarseAssembly.DiscreteRoe.Operator X H => star T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped ZeroAtInfty CStarAlgebra in + by + exact (ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous + local_proof)⟩ + +def algebraicRoe (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) : + NonUnitalStarSubalgebra ℂ (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by + classical + have OAI.CoarseAssembly.DiscreteRoe.Generator.zero {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] : OAI.CoarseAssembly.DiscreteRoe.Generator (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + refine ⟨⟨0, le_rfl, fun x y _ => ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x y : X) : OAI.CoarseAssembly.DiscreteRoe.entry (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) x y = 0 := by + simp [OAI.CoarseAssembly.DiscreteRoe.entry] + local_proof) x y⟩, ?_, ?_⟩ + · intro x y + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x y : X) : OAI.CoarseAssembly.DiscreteRoe.entry (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) x y = 0 := by + simp [OAI.CoarseAssembly.DiscreteRoe.entry] + local_proof)] + exact isCompactOperator_zero + · rw [star_zero (OAI.CoarseAssembly.DiscreteRoe.Operator X H)] + intro x y + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x y : X) : OAI.CoarseAssembly.DiscreteRoe.entry (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) x y = 0 := by + simp [OAI.CoarseAssembly.DiscreteRoe.entry] + local_proof)] + exact isCompactOperator_zero + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r s : ℝ} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : + OAI.CoarseAssembly.DiscreteRoe.PropagationLE (max r s) (T + S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp] + local_proof), hT x y (lt_of_le_of_lt (le_max_left _ _) hxy), + hS x y (lt_of_le_of_lt (le_max_right _ _) hxy), add_zero] + have OAI.CoarseAssembly.DiscreteRoe.Generator.add {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) (hS : OAI.CoarseAssembly.DiscreteRoe.Generator S) : + OAI.CoarseAssembly.DiscreteRoe.Generator (T + S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + obtain ⟨⟨s, hs, hq⟩, hd, hds⟩ := hS + refine ⟨⟨max r s, le_trans hr (le_max_left _ _), (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add hp hq)⟩, ?_, ?_⟩ + · intro x y + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp] + local_proof)] + exact (hc x y).add (hd x y) + · rw [star_add T S] + intro x y + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp] + local_proof)] + exact (hcs x y).add (hds x y) + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r : ℝ} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (z : ℂ) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (z • T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry] + local_proof), hT x y hxy, smul_zero] + have OAI.CoarseAssembly.DiscreteRoe.Generator.smul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) (z : ℂ) : OAI.CoarseAssembly.DiscreteRoe.Generator (z • T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + refine ⟨⟨r, hr, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul hp z)⟩, ?_, ?_⟩ + · intro x y + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry] + local_proof)] + exact (hc x y).smul z + · rw [star_smul] + intro x y + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry] + local_proof)] + exact (hcs x y).smul (star z) + have OAI.CoarseAssembly.DiscreteRoe.entry_star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (star T) x y = star (OAI.CoarseAssembly.DiscreteRoe.entry T y x) := by + have hI (z : X) : (OAI.CoarseAssembly.DiscreteRoe.insert (H := H) z).adjoint = + OAI.CoarseAssembly.DiscreteRoe.coordinate z := by + ext v + apply ext_inner_left ℂ + intro h + rw [ContinuousLinearMap.adjoint_inner_right] + change inner ℂ (lp.single 2 z h) v = inner ℂ h (v z) + exact lp.inner_single_left (𝕜 := ℂ) z h v + simp only [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.star_eq_adjoint, + ContinuousLinearMap.adjoint_comp] + rw [hI x, ← hI y, ContinuousLinearMap.adjoint_adjoint] + rfl + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (star T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [OAI.CoarseAssembly.DiscreteRoe.entry_star, hT y x (by simpa [dist_comm] using hxy), star_zero] + have OAI.CoarseAssembly.DiscreteRoe.Generator.star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) : OAI.CoarseAssembly.DiscreteRoe.Generator (star T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + exact ⟨⟨r, hr, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hp)⟩, hcs, by simpa only [star_star] using hc⟩ + have OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (s : Finset X) (v : OAI.CoarseAssembly.DiscreteRoe.Module X H) + (hv : ∀ x, x ∉ s → v x = 0) : + v = ∑ x ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert x (v x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + apply lp.ext + funext x + simp only [lp.coeFn_sum, Finset.sum_apply, ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), lp.coeFn_single] + rw [Finset.sum_pi_single] + by_cases hx : x ∈ s + · simp [hx] + · simp [hx, hv x hx] + have OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (s : Finset X) + (hs : ∀ z, z ∉ s → OAI.CoarseAssembly.DiscreteRoe.entry S z y = 0) : + OAI.CoarseAssembly.DiscreteRoe.entry (T * S) x y = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.entry T x z * OAI.CoarseAssembly.DiscreteRoe.entry S z y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext h + have hv : S (OAI.CoarseAssembly.DiscreteRoe.insert y h) = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert z (OAI.CoarseAssembly.DiscreteRoe.entry S z y h) := by + apply OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum + intro z hz + have := DFunLike.congr_fun (hs z hz) h + simpa only [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), zero_apply] using this + change OAI.CoarseAssembly.DiscreteRoe.coordinate x (T (S (OAI.CoarseAssembly.DiscreteRoe.insert y h))) = _ + rw [hv, map_sum, map_sum] + simp only [sum_apply, mul_apply_eq_comp] + rfl + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r s : ℝ} {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : + OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + s) (T * S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) : + ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro z hz + apply hT + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz + local_proof) finiteBalls hS y)] + apply Finset.sum_eq_zero + intro z hz + have hzy : dist z y ≤ s := by + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall] using hz + have hxz : r < dist x z := by + have htri := dist_triangle x z y + linarith + rw [hT x z hxz, zero_mul] + have OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {s : ℝ} + (hT : OAI.CoarseAssembly.DiscreteRoe.CompactEntries T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (T * S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y + rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) : + ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro z hz + apply hT + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz + local_proof) finiteBalls hS y)] + apply ( + let local_proof {H : Type _} [inst_local_1 : NormedAddCommGroup H] [inst_local_2 : InnerProductSpace ℂ H] {ι : Type _} (s : Finset ι) (A : ι → H →L[ℂ] H) + (hA : ∀ i ∈ s, IsCompactOperator (A i)) : + IsCompactOperator (∑ i ∈ s, A i : H →L[ℂ] H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + exact (compactOperator (RingHom.id ℂ) H H).sum_mem hA + local_proof) + intro z _ + exact (hT x z).comp_clm (OAI.CoarseAssembly.DiscreteRoe.entry S z y) + have OAI.CoarseAssembly.DiscreteRoe.Generator.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) (hS : OAI.CoarseAssembly.DiscreteRoe.Generator S) : OAI.CoarseAssembly.DiscreteRoe.Generator (T * S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT + obtain ⟨⟨s, hs, hq⟩, hd, hds⟩ := hS + exact ⟨⟨r + s, add_nonneg hr hs, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul finiteBalls hp hq)⟩, + (OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hc hq), by + rw [star_mul] + exact OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hds (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hp)⟩ + exact { + carrier := {T | OAI.CoarseAssembly.DiscreteRoe.Generator T} + zero_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.zero + add_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.add + mul_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.mul finiteBalls + smul_mem' z _ hT := (OAI.CoarseAssembly.DiscreteRoe.Generator.smul hT z) + star_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.star + } + +end CoarseAssembly.DiscreteRoe + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +local instance : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by + classical + + exact ⟨( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] : Continuous (fun T : OAI.CoarseAssembly.DiscreteRoe.Operator X H => star T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped ZeroAtInfty CStarAlgebra in + by + exact (ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous + local_proof)⟩ + +local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp + +local instance : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp + +def RoeMultiplier (T : Operator X H) : Prop := + ∀ S : algebra (X := X) (H := H), + T * S.val ∈ algebra (X := X) (H := H) ∧ S.val * T ∈ algebra (X := X) (H := H) + +def roeIdealizer : NonUnitalStarSubalgebra ℂ (Operator X H) where + carrier := {T | RoeMultiplier T} + zero_mem' S := by simp only [zero_mul, mul_zero]; exact ⟨zero_mem _, zero_mem _⟩ + add_mem' hT hU S := by + rw [add_mul, mul_add] + exact ⟨add_mem (hT S).1 (hU S).1, add_mem (hT S).2 (hU S).2⟩ + mul_mem' hT hU S := by + constructor + · rw [mul_assoc] + exact (hT ⟨_, (hU S).1⟩).1 + · rw [← mul_assoc] + exact (hU ⟨_, (hT S).2⟩).2 + smul_mem' z T hT S := by + rw [smul_mul_assoc, mul_smul_comm] + exact ⟨(algebra (X := X) (H := H)).smul_mem z (hT S).1, + (algebra (X := X) (H := H)).smul_mem z (hT S).2⟩ + star_mem' hT S := by + have h := hT ⟨star S.val, star_mem S.property⟩ + exact ⟨by simpa only [star_mul, star_star] using star_mem h.2, + by simpa only [star_mul, star_star] using star_mem h.1⟩ + +end CoarseAssembly.DiscreteRoe + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +local instance spatialLocalizationContinuousAdd {H : Type*} [NormedAddCommGroup H] : + ContinuousAdd H := IsTopologicalAddGroup.toContinuousAdd + +local instance spatialLocalizationRingHomCompTriple : + RingHomCompTriple (RingHom.id ℂ) (RingHom.id ℂ) (RingHom.id ℂ) := + RingHomCompTriple.ids + +local instance spatialLocalizationCompleteSpace {X H : Type*} + [NormedAddCommGroup H] [CompleteSpace H] : CompleteSpace (Module X H) := inferInstance + +def localizedSpatialOperator (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) : Operator X H := + isometricExtension (partitionIsometry a hpart) (partitionCompression a F) + +variable [PseudoMetricSpace X] + +end CoarseAssembly.DiscreteRoe + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ) + +def representedSqrt (c : OddCycle C(Point X r, ℂ)) (x : X) : End c.space := + c.representation (sqrtCoordinate r x) + +def ripsSpatialOperator (c : OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point X r, ℂ)) (hπ : c.representation 1 = 1) : + OAI.CoarseAssembly.DiscreteRoe.Operator X c.space := by + classical + have OAI.CoarseAssembly.Rips.sqrtCoordinate_square_sum {X : Type} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) : + ∑ x : X, OAI.CoarseAssembly.Rips.sqrtCoordinate r x * OAI.CoarseAssembly.Rips.sqrtCoordinate r x = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + by + ext p + change (ContinuousMap.evalAlgHom ℂ ℂ p) + (∑ x : X, OAI.CoarseAssembly.Rips.sqrtCoordinate r x * OAI.CoarseAssembly.Rips.sqrtCoordinate r x) = 1 + rw [map_sum] + simp only [map_mul] + change (∑ x : X, (Real.sqrt (p.weight x) : ℂ) * (Real.sqrt (p.weight x) : ℂ)) = 1 + simp only [← Complex.ofReal_mul, Real.mul_self_sqrt (p.nonneg _)] + rw [← Complex.ofReal_sum, (( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} [inst_local_3 : Fintype X] (p : OAI.CoarseAssembly.Rips.Point X r) : ∑ x : X, p.weight x = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open scoped BigOperators in + open Topology in + by + rw [← p.total] + exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm + local_proof) p), Complex.ofReal_one] + have OAI.CoarseAssembly.Rips.representedSqrt_adjoint {X : Type} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) (c : OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point X r, ℂ)) (x : X) : + (OAI.CoarseAssembly.Rips.representedSqrt r c x).adjoint = OAI.CoarseAssembly.Rips.representedSqrt r c x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Analytic DiscreteRoe in + by + exact ((( + let local_proof {X : Type} [inst_local_1 : PseudoMetricSpace X] (r : ℝ) (x : X) : + IsSelfAdjoint (OAI.CoarseAssembly.Rips.sqrtCoordinate r x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + by + ext p + simp [OAI.CoarseAssembly.Rips.sqrtCoordinate] + local_proof) r x).map c.representation).star_eq + have OAI.CoarseAssembly.Rips.representedSqrt_partition {X : Type} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) (c : OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point X r, ℂ)) + (hπ : c.representation 1 = 1) : + ∑ x, (OAI.CoarseAssembly.Rips.representedSqrt r c x).adjoint.comp (OAI.CoarseAssembly.Rips.representedSqrt r c x) = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Analytic DiscreteRoe in + by + simp only [OAI.CoarseAssembly.Rips.representedSqrt_adjoint] + change (∑ x, c.representation (OAI.CoarseAssembly.Rips.sqrtCoordinate r x) * + c.representation (OAI.CoarseAssembly.Rips.sqrtCoordinate r x)) = 1 + simp only [← map_mul, ← map_sum, OAI.CoarseAssembly.Rips.sqrtCoordinate_square_sum, hπ] + exact OAI.CoarseAssembly.DiscreteRoe.localizedSpatialOperator (OAI.CoarseAssembly.Rips.representedSqrt r c) (OAI.CoarseAssembly.Rips.representedSqrt_partition r c hπ) c.operator + +end CoarseAssembly.Rips + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +variable {X Y H : Type*} + +variable [NormedAddCommGroup H] [NormedSpace ℂ H] + + +attribute [local instance 1001] AddGroup.existsAddOfLE + +def extendedFunction (e : X ↪ Y) (x : lp (fun _ : X => H) 2) : Y → H := + Function.extend e x 0 + +def inclusionVector (e : X ↪ Y) (x : lp (fun _ : X => H) 2) : lp (fun _ : Y => H) 2 := by + classical + have OAI.CoarseAssembly.extendedFunction_hasSum {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) : + HasSum (fun y => ‖OAI.CoarseAssembly.extendedFunction e x y‖ ^ 2) (‖x‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + have hf : HasSum (fun a : X => ‖x a‖ ^ 2) (‖x‖ ^ 2) := by + rw [( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof)] + exact (( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) x).hasSum + apply (e.injective.hasSum_iff (fun y hy => by + rw [( + let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) + (y : Y) (hy : y ∉ Set.range e) : OAI.CoarseAssembly.extendedFunction e x y = 0 := + open OAI OAI.CoarseAssembly in + Function.extend_apply' _ _ _ hy + local_proof) e x y hy, norm_zero, zero_pow (by decide : 2 ≠ 0)])).mp + convert hf using 1 + funext a + exact congrArg (fun h : H => ‖h‖ ^ 2) (( + let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) (a : X) : + OAI.CoarseAssembly.extendedFunction e x (e a) = x a := + open OAI OAI.CoarseAssembly in + e.injective.extend_apply _ _ _ + local_proof) e x a) + exact ⟨OAI.CoarseAssembly.extendedFunction e x, by + apply memℓp_gen + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (OAI.CoarseAssembly.extendedFunction_hasSum e x).summable⟩ + +def inclusionIsometry (e : X ↪ Y) : lp (fun _ : X => H) 2 →ₗᵢ[ℂ] lp (fun _ : Y => H) 2 := by + classical + have OAI.CoarseAssembly.extendedFunction_hasSum {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) : + HasSum (fun y => ‖OAI.CoarseAssembly.extendedFunction e x y‖ ^ 2) (‖x‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + have hf : HasSum (fun a : X => ‖x a‖ ^ 2) (‖x‖ ^ 2) := by + rw [( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof)] + exact (( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + local_proof) x).hasSum + apply (e.injective.hasSum_iff (fun y hy => by + rw [( + let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) + (y : Y) (hy : y ∉ Set.range e) : OAI.CoarseAssembly.extendedFunction e x y = 0 := + open OAI OAI.CoarseAssembly in + Function.extend_apply' _ _ _ hy + local_proof) e x y hy, norm_zero, zero_pow (by decide : 2 ≠ 0)])).mp + convert hf using 1 + funext a + exact congrArg (fun h : H => ‖h‖ ^ 2) (( + let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) (a : X) : + OAI.CoarseAssembly.extendedFunction e x (e a) = x a := + open OAI OAI.CoarseAssembly in + e.injective.extend_apply _ _ _ + local_proof) e x a) + exact { + toFun := OAI.CoarseAssembly.inclusionVector e + map_add' x z := by + apply lp.ext + funext y + by_cases hy : y ∈ Set.range e + · obtain ⟨a, rfl⟩ := hy + change extendedFunction e (x + z) (e a) = extendedFunction e x (e a) + extendedFunction e z (e a) + simp only [extendedFunction, e.injective.extend_apply] + rfl + · change extendedFunction e (x + z) y = extendedFunction e x y + extendedFunction e z y + simp only [extendedFunction, Function.extend_apply' _ _ _ hy, Pi.zero_apply, add_zero] + map_smul' c x := by + apply lp.ext + funext y + by_cases hy : y ∈ Set.range e + · obtain ⟨a, rfl⟩ := hy + change extendedFunction e (c • x) (e a) = c • extendedFunction e x (e a) + simp only [extendedFunction, e.injective.extend_apply] + rfl + · change extendedFunction e (c • x) y = c • extendedFunction e x y + simp only [extendedFunction, Function.extend_apply' _ _ _ hy, Pi.zero_apply, smul_zero] + norm_map' x := by + change ‖OAI.CoarseAssembly.inclusionVector e x‖ = ‖x‖ + have hs : ‖OAI.CoarseAssembly.inclusionVector e x‖ ^ 2 = ‖x‖ ^ 2 := by + rw [( + let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := + open OAI OAI.CoarseAssembly in + by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + local_proof)] + exact (OAI.CoarseAssembly.extendedFunction_hasSum e x).tsum_eq + nlinarith [norm_nonneg (OAI.CoarseAssembly.inclusionVector e x), norm_nonneg x] + } + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + + +attribute [local instance 1001] ChainCompletePartialOrder.toPartialOrder + HeytingAlgebra.toOrderBot AddGroup.existsAddOfLE + +def ampleIsometry (H : OAI.CoarseAssembly.Analytic.HilbertSpace) : H →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2 := by + classical + have OAI.CoarseAssembly.Analytic.exists_ampleIsometry (H : OAI.CoarseAssembly.Analytic.HilbertSpace) : + Nonempty (H →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + obtain ⟨s, b, _⟩ := exists_hilbertBasis ℂ H + let : Countable s := ( + let local_proof {H : Type _} [NormedAddCommGroup H] + [InnerProductSpace ℂ H] [SecondCountableTopology H] {ι : Type _} {v : ι → H} + (hv : Orthonormal ℂ v) : Countable ι := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hd : Pairwise (fun i j => Disjoint (Metric.ball (v i) (1 / 2 : ℝ)) + (Metric.ball (v j) (1 / 2 : ℝ))) := by + intro i j hij + apply Set.disjoint_left.mpr + intro z hzi hzj + have hn : ‖v i - v j‖ ^ 2 = 2 := by + rw [@norm_sub_sq ℂ] + norm_num [hv.norm_eq_one, hv.inner_eq_zero hij] + have hzi' : dist (v i) z < 1 / 2 := by simpa only [Metric.mem_ball, dist_comm] using hzi + have hzj' : dist z (v j) < 1 / 2 := hzj + have hdist : dist (v i) (v j) < 1 := by linarith [dist_triangle (v i) z (v j)] + rw [dist_eq_norm] at hdist + nlinarith [norm_nonneg (v i - v j)] + exact hd.countable_of_isOpen_disjoint (fun _ => Metric.isOpen_ball) + (fun i => ⟨v i, Metric.mem_ball_self (by norm_num)⟩) + local_proof) b.orthonormal + obtain ⟨f, hf⟩ := exists_injective_nat s + exact ⟨(OAI.CoarseAssembly.inclusionIsometry (H := ℂ) ⟨f, hf⟩).comp b.repr.toLinearIsometry⟩ + exact (OAI.CoarseAssembly.Analytic.exists_ampleIsometry H).some + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X E H : Type*} [DecidableEq X] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def coefficientIsometry (V : E →ₗᵢ[ℂ] H) : Module X E →ₗᵢ[ℂ] Module X H := + blockIsometry (fun _ : X => V) + +variable [PseudoMetricSpace X] + +def coefficientExtension (V : E →ₗᵢ[ℂ] H) (T : Operator X E) : Operator X H := + isometricExtension (coefficientIsometry V) T + +end CoarseAssembly.DiscreteRoe + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {V : ℕ → Type*} [∀ i, DecidableEq (V i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +def diagonalFamily (A : ∀ i, Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) : Operator (Sigma V) H := + flattenOperator (blockOperator A C hC hA) + +variable [∀ i, MetricSpace (V i)] (o : ∀ i, V i) + + +end CoarseAssembly.DiscreteRoe + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +variable {X Y : Type*} [PseudoMetricSpace X] [PseudoMetricSpace Y] + {r : ℝ} + +def mapPoint (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) + (p : Point X r) : Point Y r where + weight := p.weight.embDomain e + nonneg y := by + classical + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simpa using p.nonneg x + · rw [Finsupp.embDomain_of_notMem_range e p.weight y hy] + total := by simpa only [Finsupp.sum_embDomain] using p.total + diameter x hx y hy := by + rw [Finsupp.support_embDomain, Finset.mem_map] at hx hy + obtain ⟨u, hu, rfl⟩ := hx + obtain ⟨v, hv, rfl⟩ := hy + exact (he u v).trans (p.diameter u hu v hv) + +def unmapPoint (e : X ↪ Y) (he : Isometry e) (q : Point Y r) + (hq : ↑q.weight.support ⊆ Set.range e) : Point X r where + weight := q.weight.comapDomain e e.injective.injOn + nonneg x := by simpa only [Finsupp.comapDomain_apply] using q.nonneg (e x) + total := by + have hm := Finsupp.embDomain_comapDomain hq + have hs := congrArg (fun f : Y →₀ ℝ => f.sum (fun _ t => t)) hm + simpa only [Finsupp.sum_embDomain, q.total] using hs + diameter x hx y hy := by + rw [← he.dist_eq] + exact q.diameter (e x) + (by simpa only [Finsupp.mem_support_iff, Finsupp.comapDomain_apply] using hx) (e y) + (by simpa only [Finsupp.mem_support_iff, Finsupp.comapDomain_apply] using hy) + +end CoarseAssembly.Rips + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Topology Rips + +variable {V : ℕ → Type} [∀ j, MetricSpace (V j)] + +def separatedComponent (j : ℕ) : V j ↪ Sigma V := ⟨Sigma.mk j, sigma_mk_injective⟩ + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.TopologicalK1 + +open CoarseAssembly.Analytic (Interval start finish) + +universe u v w + +variable (R : Type u) [Ring R] [TopologicalSpace R] + +abbrev InvertibleMatrix (n : ℕ) := (Matrix (Fin n) (Fin n) R)ˣ + +abbrev StableGL := Σ n : ℕ, InvertibleMatrix R n + +def IsStabilization {n : ℕ} (g : InvertibleMatrix R n) (h : InvertibleMatrix R (n + 1)) : Prop := + (h : Matrix (Fin (n + 1)) (Fin (n + 1)) R).submatrix finSumFinEquiv finSumFinEquiv = + Matrix.fromBlocks (g : Matrix (Fin n) (Fin n) R) 0 0 + (1 : Matrix (Fin 1) (Fin 1) R) + +inductive Relation : FreeAbelianGroup (StableGL R) → Prop + | mul {n : ℕ} (g h : InvertibleMatrix R n) : + Relation (FreeAbelianGroup.of ⟨n, g * h⟩ - + (FreeAbelianGroup.of ⟨n, g⟩ + FreeAbelianGroup.of ⟨n, h⟩)) + | stabilize {n : ℕ} (g : InvertibleMatrix R n) (h : InvertibleMatrix R (n + 1)) (hs : IsStabilization R g h) : + Relation (FreeAbelianGroup.of ⟨n, g⟩ - FreeAbelianGroup.of ⟨n + 1, h⟩) + | homotopy {n : ℕ} (c : Interval → InvertibleMatrix R n) (hc : Continuous c) : + Relation (FreeAbelianGroup.of ⟨n, c start⟩ - FreeAbelianGroup.of ⟨n, c finish⟩) + +def relations : AddSubgroup (FreeAbelianGroup (StableGL R)) := + AddSubgroup.closure {z | Relation R z} + +abbrev Group := FreeAbelianGroup (StableGL R) ⧸ relations R + +def matrixClass {n : ℕ} (g : InvertibleMatrix R n) : Group R := + QuotientAddGroup.mk (FreeAbelianGroup.of ⟨n, g⟩) + +variable {R} + +variable {S : Type v} {T : Type w} [Ring S] [TopologicalSpace S] [Ring T] [TopologicalSpace T] + +def mapGL (φ : R →+* S) (n : ℕ) : InvertibleMatrix R n →* InvertibleMatrix S n := + Units.map φ.mapMatrix.toMonoidHom + +def mapFree (φ : R →+* S) : FreeAbelianGroup (StableGL R) →+ Group S := + FreeAbelianGroup.lift (fun g => matrixClass S (mapGL φ g.1 g.2)) + +def map (φ : R →+* S) (hφ : Continuous φ) : OAI.CoarseAssembly.TopologicalK1.Group R →+ OAI.CoarseAssembly.TopologicalK1.Group S := by + classical + have OAI.CoarseAssembly.TopologicalK1.matrixClass_mul {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (g h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) : + OAI.CoarseAssembly.TopologicalK1.matrixClass R (g * h) = OAI.CoarseAssembly.TopologicalK1.matrixClass R g + OAI.CoarseAssembly.TopologicalK1.matrixClass R h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + apply sub_eq_zero.mp + simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using + ( + let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h) + local_proof) (.mul g h) + have OAI.CoarseAssembly.TopologicalK1.matrixClass_stabilize {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) (h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R (n + 1)) + (hs : OAI.CoarseAssembly.TopologicalK1.IsStabilization R g h) : OAI.CoarseAssembly.TopologicalK1.matrixClass R g = OAI.CoarseAssembly.TopologicalK1.matrixClass R h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + apply sub_eq_zero.mp + simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub] using ( + let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h) + local_proof) (.stabilize g h hs) + have OAI.CoarseAssembly.TopologicalK1.matrixClass_homotopy {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (c : OAI.CoarseAssembly.Analytic.Interval → OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) (hc : Continuous c) : + OAI.CoarseAssembly.TopologicalK1.matrixClass R (c OAI.CoarseAssembly.Analytic.start) = OAI.CoarseAssembly.TopologicalK1.matrixClass R (c OAI.CoarseAssembly.Analytic.finish) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + apply sub_eq_zero.mp + simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub] using ( + let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h) + local_proof) (.homotopy c hc) + have OAI.CoarseAssembly.TopologicalK1.mapFree_relation {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {S : Type _} [inst_local_4 : Ring S] [inst_local_5 : TopologicalSpace S] (φ : R →+* S) (hφ : Continuous φ) + {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (hz : OAI.CoarseAssembly.TopologicalK1.Relation R z) : OAI.CoarseAssembly.TopologicalK1.mapFree φ z = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + cases hz with + | mul g h => + simpa [OAI.CoarseAssembly.TopologicalK1.mapFree] using sub_eq_zero.mpr (OAI.CoarseAssembly.TopologicalK1.matrixClass_mul (OAI.CoarseAssembly.TopologicalK1.mapGL φ _ g) (OAI.CoarseAssembly.TopologicalK1.mapGL φ _ h)) + | stabilize g h hs => + simpa [OAI.CoarseAssembly.TopologicalK1.mapFree] using sub_eq_zero.mpr + (OAI.CoarseAssembly.TopologicalK1.matrixClass_stabilize _ _ (( + let local_proof {R : Type _} [inst_local_1 : Ring R] {S : Type _} [inst_local_3 : Ring S] (φ : R →+* S) {n : ℕ} (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) (h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R (n + 1)) + (hs : OAI.CoarseAssembly.TopologicalK1.IsStabilization R g h) : OAI.CoarseAssembly.TopologicalK1.IsStabilization S (OAI.CoarseAssembly.TopologicalK1.mapGL φ n g) (OAI.CoarseAssembly.TopologicalK1.mapGL φ (n + 1) h) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + have heq := congrArg (fun M => Matrix.map M φ) hs + simpa [OAI.CoarseAssembly.TopologicalK1.IsStabilization, OAI.CoarseAssembly.TopologicalK1.mapGL, Matrix.fromBlocks_map, Matrix.submatrix_map] using heq + local_proof) φ g h hs)) + | homotopy c hc => + simpa [OAI.CoarseAssembly.TopologicalK1.mapFree] using sub_eq_zero.mpr + (OAI.CoarseAssembly.TopologicalK1.matrixClass_homotopy (fun t => OAI.CoarseAssembly.TopologicalK1.mapGL φ _ (c t)) ((( + let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {S : Type _} [inst_local_4 : Ring S] [inst_local_5 : TopologicalSpace S] (φ : R →+* S) (hφ : Continuous φ) (n : ℕ) : + Continuous (OAI.CoarseAssembly.TopologicalK1.mapGL φ n) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + apply Continuous.units_map + exact continuous_pi (fun i => continuous_pi (fun j => + hφ.comp ((continuous_apply j).comp (continuous_apply i)))) + local_proof) φ hφ _).comp hc)) + exact QuotientAddGroup.lift (OAI.CoarseAssembly.TopologicalK1.relations R) (OAI.CoarseAssembly.TopologicalK1.mapFree φ) + ((AddSubgroup.closure_le _).2 (fun _ hz => OAI.CoarseAssembly.TopologicalK1.mapFree_relation φ hφ hz)) + +end CoarseAssembly.TopologicalK1 + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.TopologicalK1 + +open Analytic + +variable {A : Type*} [CStarAlgebra A] + + +section + +attribute [-instance] LocallyConvexSpace.toPolynormableSpace + +end + +end CoarseAssembly.TopologicalK1 + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +open scoped CStarAlgebra + +universe u v w + +variable (A : Type u) [NonUnitalCStarAlgebra A] + +def scalarMap : TopologicalK1.Group (Unitization ℂ A) →+ TopologicalK1.Group ℂ := + TopologicalK1.map (Unitization.fstHom ℂ A).toRingHom Unitization.continuous_fst + +abbrev K1 := (scalarMap A).ker + +variable {A} {B : Type v} [NonUnitalCStarAlgebra B] + +variable {C : Type w} [NonUnitalCStarAlgebra C] + +def unitizationMap (φ : A →⋆ₙₐ[ℂ] B) : + TopologicalK1.Group (Unitization ℂ A) →+ TopologicalK1.Group (Unitization ℂ B) := + TopologicalK1.map (Unitization.starMap φ).toRingHom (show Continuous (Unitization.starMap φ) from map_continuous _) + +def map (φ : A →⋆ₙₐ[ℂ] B) : OAI.CoarseAssembly.OperatorKTheory.K1 A →+ OAI.CoarseAssembly.OperatorKTheory.K1 B := by + classical + + exact { + toFun x := ⟨OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ x, by + change OAI.CoarseAssembly.OperatorKTheory.scalarMap B (OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ x) = 0 + rw [← AddMonoidHom.comp_apply, ( + let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} [inst_local_3 : NonUnitalCStarAlgebra B] (φ : A →⋆ₙₐ[ℂ] B) : + (OAI.CoarseAssembly.OperatorKTheory.scalarMap B).comp (OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ) = OAI.CoarseAssembly.OperatorKTheory.scalarMap A := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in + open scoped CStarAlgebra in + by + apply QuotientAddGroup.addMonoidHom_ext + apply FreeAbelianGroup.lift_ext + rintro ⟨n, g⟩ + change OAI.CoarseAssembly.TopologicalK1.matrixClass ℂ + (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ B).toRingHom n + (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.starMap φ).toRingHom n g)) = + OAI.CoarseAssembly.TopologicalK1.matrixClass ℂ + (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ A).toRingHom n g) + congr 1 + apply Units.ext + apply Matrix.ext + intro i j + change (Unitization.starMap φ ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j)).fst = + ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j).fst + simp [Unitization.starMap_apply, Unitization.algebraMap_eq_inl] + local_proof)] + exact x.property⟩ + map_zero' := Subtype.ext ((OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ).map_zero) + map_add' x y := Subtype.ext ((OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ).map_add x y) + } + +end CoarseAssembly.OperatorKTheory + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {A : Type*} [CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) + +def relativePart (u : unitary A) (hu : (u : A) - 1 ∈ S) : S := ⟨(u : A) - 1, hu⟩ + +def relativeUnitary (u : unitary A) (hu : (u : A) - 1 ∈ S) : + unitary (Unitization ℂ S) := by + classical + + let r := OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu + refine ⟨1 + (r : Unitization ℂ S), ?_, ?_⟩ + · apply Unitization.ext + · simp + · simpa using ( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) (u : unitary A) (hu : (u : A) - 1 ∈ S) : + OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu + star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) + + star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) * OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in + by + apply Subtype.ext + change ((u : A) - 1) + star ((u : A) - 1) + + star ((u : A) - 1) * ((u : A) - 1) = 0 + rw [star_sub, star_one] + have h := Unitary.coe_star_mul_self u + change star (u : A) * (u : A) = 1 at h + noncomm_ring [h] + local_proof) S u hu + · apply Unitization.ext + · simp + · simpa using ( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) (u : unitary A) (hu : (u : A) - 1 ∈ S) : + star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) + OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu + + OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu * star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in + by + apply Subtype.ext + change star ((u : A) - 1) + ((u : A) - 1) + + ((u : A) - 1) * star ((u : A) - 1) = 0 + rw [star_sub, star_one] + have h := Unitary.coe_mul_star_self u + change (u : A) * star (u : A) = 1 at h + noncomm_ring [h] + local_proof) S u hu + +def relativeMatrix (u : unitary A) (hu : (u : A) - 1 ∈ S) : + TopologicalK1.InvertibleMatrix (Unitization ℂ S) 1 := + Units.map (Matrix.scalar (Fin 1)).toMonoidHom (Unitary.toUnits (relativeUnitary S u hu)) + +variable [hS : IsClosed (S : Set A)] + +def relativeClass (u : unitary A) (hu : (u : A) - 1 ∈ S) : OAI.CoarseAssembly.OperatorKTheory.K1 S := by + classical + have OAI.CoarseAssembly.TopologicalK1.matrixClass_mul {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (g h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) : + OAI.CoarseAssembly.TopologicalK1.matrixClass R (g * h) = OAI.CoarseAssembly.TopologicalK1.matrixClass R g + OAI.CoarseAssembly.TopologicalK1.matrixClass R h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + apply sub_eq_zero.mp + simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using + ( + let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) : + (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h) + local_proof) (.mul g h) + have OAI.CoarseAssembly.TopologicalK1.matrixClass_one {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] (n : ℕ) : OAI.CoarseAssembly.TopologicalK1.matrixClass R (1 : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + by + have h := OAI.CoarseAssembly.TopologicalK1.matrixClass_mul (1 : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) 1 + simp only [one_mul] at h + exact (add_left_cancel ((add_zero _).trans h)).symm + have OAI.CoarseAssembly.OperatorKTheory.scalarMap_matrixClass {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {n : ℕ} + (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix (Unitization ℂ A) n) : + OAI.CoarseAssembly.OperatorKTheory.scalarMap A (OAI.CoarseAssembly.TopologicalK1.matrixClass (Unitization ℂ A) g) = + OAI.CoarseAssembly.TopologicalK1.matrixClass ℂ + (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ A).toRingHom n g) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in + open scoped CStarAlgebra in + ( + let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {S : Type _} [inst_local_4 : Ring S] [inst_local_5 : TopologicalSpace S] (φ : R →+* S) (hφ : Continuous φ) {n : ℕ} (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) : + OAI.CoarseAssembly.TopologicalK1.map φ hφ (OAI.CoarseAssembly.TopologicalK1.matrixClass R g) = OAI.CoarseAssembly.TopologicalK1.matrixClass S (OAI.CoarseAssembly.TopologicalK1.mapGL φ n g) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in + open OAI.CoarseAssembly.Analytic in + FreeAbelianGroup.lift_apply_of _ _ + local_proof) _ _ _ + exact ⟨OAI.CoarseAssembly.TopologicalK1.matrixClass (Unitization ℂ S) (OAI.CoarseAssembly.OperatorKTheory.relativeMatrix S u hu), by + rw [AddMonoidHom.mem_ker, OAI.CoarseAssembly.OperatorKTheory.scalarMap_matrixClass, ( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) (u : unitary A) (hu : (u : A) - 1 ∈ S) : + OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ S).toRingHom 1 (OAI.CoarseAssembly.OperatorKTheory.relativeMatrix S u hu) = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in + by + apply Units.ext + ext i j + have hij : i = j := Subsingleton.elim _ _ + simp [OAI.CoarseAssembly.TopologicalK1.mapGL, OAI.CoarseAssembly.OperatorKTheory.relativeMatrix, OAI.CoarseAssembly.OperatorKTheory.relativeUnitary, Matrix.scalar_apply, + Unitary.val_toUnits_apply, hij] + local_proof), + OAI.CoarseAssembly.TopologicalK1.matrixClass_one]⟩ + +end CoarseAssembly.OperatorKTheory + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +def multiplierAlgebra : StarSubalgebra ℂ (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by + classical + + exact { + carrier := OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H) + add_mem' := (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H)).add_mem + mul_mem' := (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H)).mul_mem + star_mem' := fun h => star_mem h + algebraMap_mem' z := by + rw [Algebra.algebraMap_eq_smul_one] + exact (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H)).smul_mem z ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] : (1 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) ∈ OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro S + constructor + · simpa only [one_mul] using S.property + · simpa only [mul_one] using S.property + local_proof) + } + +instance : CStarAlgebra (OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) := by + classical + have OAI.CoarseAssembly.DiscreteRoe.roeIdealizer_closed {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + simp only [OAI.CoarseAssembly.DiscreteRoe.roeIdealizer, OAI.CoarseAssembly.DiscreteRoe.RoeMultiplier, Set.ofPred_forall] + apply isClosed_iInter + intro S + exact (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + local_proof).preimage (continuous_id.mul continuous_const)).inter + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + local_proof).preimage (continuous_const.mul continuous_id)) + have OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra_closed {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] : + IsClosed (OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + OAI.CoarseAssembly.DiscreteRoe.roeIdealizer_closed + exact StarSubalgebra.cstarAlgebra _ (h_closed := OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra_closed) + +def multiplierRoeIdeal : TwoSidedIdeal (multiplierAlgebra (X := X) (H := H)) := + TwoSidedIdeal.mk' {T | T.val ∈ algebra (X := X) (H := H)} + (algebra (X := X) (H := H)).zero_mem + (fun hT hS => (algebra (X := X) (H := H)).add_mem hT hS) + (fun hT => (algebra (X := X) (H := H)).neg_mem hT) + (fun {T S} hS => T.property ⟨S.val, hS⟩ |>.1) + (fun {T S} hT => S.property ⟨T.val, hT⟩ |>.2) + +def multiplierBoundaryUnitary (F : multiplierAlgebra (X := X) (H := H)) + (hF : IsSelfAdjoint F) : unitary (Operator X H) := + Unitary.map (StarMonoidHom.ofClass (multiplierAlgebra (X := X) (H := H)).subtype) + (Analytic.rationalBoundaryUnitary F hF) + +def multiplierBoundaryClass + (F : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hdefect : F.val ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) : + OAI.CoarseAssembly.OperatorKTheory.K1 (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) := by + classical + have OAI.CoarseAssembly.Analytic.cayleyDenominator_val {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F + algebraMap ℂ A Complex.I := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + IsUnit (F + algebraMap ℂ A Complex.I) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hn : -Complex.I ∉ spectrum ℂ F := by + intro h + have hi := hF.im_eq_zero_of_mem_spectrum h + simp at hi + have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) := + not_not.mp (fun h => hn (spectrum.mem_iff.mpr h)) + convert hu.neg using 1 + simp only [map_neg, neg_sub, sub_neg_eq_add] + local_proof) F hF).unit_spec + have OAI.CoarseAssembly.Analytic.cayleyDenominator_star {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F - algebraMap ℂ A Complex.I := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_val, star_add, hF.star_eq] + simp only [← algebraMap_star_comm, Complex.star_def, Complex.conj_I, map_neg, + sub_eq_add_neg] + have OAI.CoarseAssembly.Analytic.cayleyDenominator_normal {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + Commute (star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val] + have hc : Commute (algebraMap ℂ A Complex.I) F := Algebra.commutes _ _ + exact ((Commute.refl F).sub_left hc).add_right + (hc.symm.sub_left (Commute.refl _)) + have OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_defect {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + ((OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary F hF : A) - 1) * + (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) ^ 2 = -2 * (F ^ 2 - 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF + have hc : Commute (star (b : A)) (b : A) := OAI.CoarseAssembly.Analytic.cayleyDenominator_normal F hF + have hci : Commute (star (b : A)) (↑b⁻¹ : A) := hc.units_inv_right + have he : (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) ^ 2 * (b : A) ^ 2 = star (b : A) ^ 2 := by + rw [( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) = + star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + rfl + local_proof), hci.mul_pow, mul_assoc, + ← (Commute.refl (b : A)).units_inv_left.mul_pow, Units.inv_mul, one_pow, mul_one] + simp only [OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary, Unitary.coe_neg, Submonoid.coe_mul] + rw [← pow_two] + rw [sub_mul, neg_mul, he, one_mul] + rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val] + have hI : (algebraMap ℂ A Complex.I) ^ 2 = -1 := by + rw [← map_pow, Complex.I_sq, map_neg, map_one] + have hcI := Algebra.commutes (R := ℂ) (A := A) Complex.I F + have hI' : algebraMap ℂ A Complex.I * algebraMap ℂ A Complex.I = -1 := by + simpa only [pow_two] using hI + noncomm_ring [hcI, hI'] + norm_num + have OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_sub_one_mem {A : Type _} [inst_local_1 : CStarAlgebra A] (I : TwoSidedIdeal A) + (F : A) (hF : IsSelfAdjoint F) (hdefect : F ^ 2 - 1 ∈ I) : + (OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary F hF : A) - 1 ∈ I := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF + have h : ((OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary F hF : A) - 1) * (b : A) ^ 2 ∈ I := by + rw [OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_defect] + exact I.mul_mem_left _ _ hdefect + have h' := I.mul_mem_right _ ((↑b⁻¹ : A) ^ 2) h + have hc : Commute (b : A) (↑b⁻¹ : A) := (Commute.refl (b : A)).units_inv_right + simpa only [mul_assoc, ← hc.mul_pow, Units.mul_inv, one_pow, mul_one] using h' + have OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary_sub_one_mem {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] + (F : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hdefect : F.val ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) : + (OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary F hF : OAI.CoarseAssembly.DiscreteRoe.Operator X H) - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + have hF' : F ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H) := by + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) : + T ∈ OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H) ↔ T.val ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + TwoSidedIdeal.mem_mk' _ _ _ _ _ _ T + local_proof)] + simpa using hdefect + have h := OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_sub_one_mem + (OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H)) F hF hF' + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) : + T ∈ OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H) ↔ T.val ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + TwoSidedIdeal.mem_mk' _ _ _ _ _ _ T + local_proof)] at h + exact h + exact OAI.CoarseAssembly.OperatorKTheory.relativeClass (hS := ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + local_proof)) (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) + (OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary F hF) (OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary_sub_one_mem F hF hdefect) + +end CoarseAssembly.DiscreteRoe + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +variable (o : ∀ i, V i) (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (r : ℝ) (hr : 0 ≤ r) (hp : ∀ i, PropagationLE r (A i)) + +def separatedFamilyMultiplier : + letI := OAI.CoarseAssembly.separatedMetric o + OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := Sigma V) (H := H) := by + classical + have OAI.CoarseAssembly.DiscreteRoe.entry_star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (star T) x y = star (OAI.CoarseAssembly.DiscreteRoe.entry T y x) := by + have hI (z : X) : (OAI.CoarseAssembly.DiscreteRoe.insert (H := H) z).adjoint = + OAI.CoarseAssembly.DiscreteRoe.coordinate z := by + ext v + apply ext_inner_left ℂ + intro h + rw [ContinuousLinearMap.adjoint_inner_right] + change inner ℂ (lp.single 2 z h) v = inner ℂ h (v z) + exact lp.inner_single_left (𝕜 := ℂ) z h v + simp only [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.star_eq_adjoint, + ContinuousLinearMap.adjoint_comp] + rw [hI x, ← hI y, ContinuousLinearMap.adjoint_adjoint] + rfl + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (star T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [OAI.CoarseAssembly.DiscreteRoe.entry_star, hT y x (by simpa [dist_comm] using hxy), star_zero] + have OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (s : Finset X) (v : OAI.CoarseAssembly.DiscreteRoe.Module X H) + (hv : ∀ x, x ∉ s → v x = 0) : + v = ∑ x ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert x (v x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + apply lp.ext + funext x + simp only [lp.coeFn_sum, Finset.sum_apply, ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), lp.coeFn_single] + rw [Finset.sum_pi_single] + by_cases hx : x ∈ s + · simp [hx] + · simp [hx, hv x hx] + have OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (s : Finset X) + (hs : ∀ z, z ∉ s → OAI.CoarseAssembly.DiscreteRoe.entry S z y = 0) : + OAI.CoarseAssembly.DiscreteRoe.entry (T * S) x y = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.entry T x z * OAI.CoarseAssembly.DiscreteRoe.entry S z y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext h + have hv : S (OAI.CoarseAssembly.DiscreteRoe.insert y h) = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert z (OAI.CoarseAssembly.DiscreteRoe.entry S z y h) := by + apply OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum + intro z hz + have := DFunLike.congr_fun (hs z hz) h + simpa only [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), zero_apply] using this + change OAI.CoarseAssembly.DiscreteRoe.coordinate x (T (S (OAI.CoarseAssembly.DiscreteRoe.insert y h))) = _ + rw [hv, map_sum, map_sum] + simp only [sum_apply, mul_apply_eq_comp] + rfl + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r s : ℝ} {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : + OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + s) (T * S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) : + ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro z hz + apply hT + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz + local_proof) finiteBalls hS y)] + apply Finset.sum_eq_zero + intro z hz + have hzy : dist z y ≤ s := by + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall] using hz + have hxz : r < dist x z := by + have htri := dist_triangle x z y + linarith + rw [hT x z hxz, zero_mul] + have OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {s : ℝ} + (hT : OAI.CoarseAssembly.DiscreteRoe.CompactEntries T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (T * S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y + rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) : + ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro z hz + apply hT + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz + local_proof) finiteBalls hS y)] + apply ( + let local_proof {H : Type _} [inst_local_1 : NormedAddCommGroup H] [inst_local_2 : InnerProductSpace ℂ H] {ι : Type _} (s : Finset ι) (A : ι → H →L[ℂ] H) + (hA : ∀ i ∈ s, IsCompactOperator (A i)) : + IsCompactOperator (∑ i ∈ s, A i : H →L[ℂ] H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + exact (compactOperator (RingHom.id ℂ) H H).sum_mem hA + local_proof) + intro z _ + exact (hT x z).comp_clm (OAI.CoarseAssembly.DiscreteRoe.entry S z y) + have OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_right {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {s : ℝ} + (hS : OAI.CoarseAssembly.DiscreteRoe.CompactEntries S) (hprop : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (T * S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y + rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) : + ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro z hz + apply hT + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz + local_proof) finiteBalls hprop y)] + apply ( + let local_proof {H : Type _} [inst_local_1 : NormedAddCommGroup H] [inst_local_2 : InnerProductSpace ℂ H] {ι : Type _} (s : Finset ι) (A : ι → H →L[ℂ] H) + (hA : ∀ i ∈ s, IsCompactOperator (A i)) : + IsCompactOperator (∑ i ∈ s, A i : H →L[ℂ] H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + exact (compactOperator (RingHom.id ℂ) H H).sum_mem hA + local_proof) + intro z _ + exact (hS z y).clm_comp (OAI.CoarseAssembly.DiscreteRoe.entry T x z) + have OAI.CoarseAssembly.DiscreteRoe.finitePropagation_multiplier {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r : ℝ} (hr : 0 ≤ r) (hp : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) : OAI.CoarseAssembly.DiscreteRoe.RoeMultiplier T := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + have hprod (S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (hS : OAI.CoarseAssembly.DiscreteRoe.Generator S) : + T * S ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) ∧ S * T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := by + obtain ⟨⟨s, hs, hq⟩, hc, hcs⟩ := hS + constructor + · apply ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) : + T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + (NonUnitalStarSubalgebra.le_topologicalClosure _) + (NonUnitalStarAlgebra.subset_adjoin ℂ _ hT) + local_proof) + refine ⟨⟨r + s, add_nonneg hr hs, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul finiteBalls hp hq)⟩, + (OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_right finiteBalls hc hq), ?_⟩ + rw [star_mul] + exact OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hcs (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hp) + · apply ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) : + T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + (NonUnitalStarSubalgebra.le_topologicalClosure _) + (NonUnitalStarAlgebra.subset_adjoin ℂ _ hT) + local_proof) + refine ⟨⟨s + r, add_nonneg hs hr, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul finiteBalls hq hp)⟩, + (OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hc hp), ?_⟩ + rw [star_mul] + exact OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_right finiteBalls hcs (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hq) + have hclosed : IsClosed {S : OAI.CoarseAssembly.DiscreteRoe.Operator X H | + T * S ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) ∧ S * T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)} := + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + local_proof).preimage (continuous_const.mul continuous_id)).inter + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + local_proof).preimage (continuous_id.mul continuous_const)) + intro S + have hm : S.val ∈ (OAI.CoarseAssembly.DiscreteRoe.algebraicRoe (H := H) finiteBalls).topologicalClosure := by + rw [← ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) [ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H)] : + OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) = (OAI.CoarseAssembly.DiscreteRoe.algebraicRoe (H := H) finiteBalls).topologicalClosure := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩ + have he : NonUnitalStarAlgebra.adjoin ℂ {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H | OAI.CoarseAssembly.DiscreteRoe.Generator T} = + OAI.CoarseAssembly.DiscreteRoe.algebraicRoe (H := H) finiteBalls := by + apply le_antisymm + · exact NonUnitalStarAlgebra.adjoin_le (fun _ h => h) + · intro T hT + exact NonUnitalStarAlgebra.subset_adjoin ℂ _ hT + unfold OAI.CoarseAssembly.DiscreteRoe.algebra + rw [he] + local_proof) finiteBalls] + exact S.property + exact closure_minimal hprod hclosed hm + have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨i, y⟩ = OAI.CoarseAssembly.DiscreteRoe.entry (A i) x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext v + simp only [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), ( + let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) : + OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + rfl + local_proof), ( + let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] (i : I) (q : Q i) (h : H) : + OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) i = lp.single 2 q h := + open OAI OAI.CoarseAssembly in + by + apply lp.ext + funext r + change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨i, r⟩ = + lp.single (E := fun _ : Q i => H) 2 q h r + by_cases hr : r = q + · subst r; simp + · have hn : (⟨i, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := by + intro he + cases he + exact hr rfl + simp [hr, hn] + local_proof)] + have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) {i j : ℕ} (hij : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨j, y⟩ = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext v + simp only [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), ( + let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) : + OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + rfl + local_proof), ( + let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] {i j : I} (hji : j ≠ i) (q : Q i) (h : H) : + OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) j = 0 := + open OAI OAI.CoarseAssembly in + by + apply lp.ext + funext r + have hn : (⟨j, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := fun he => hji (congrArg Sigma.fst he) + change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨j, r⟩ = 0 + exact lp.single_apply_ne (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h hn + local_proof) hij, map_zero, + lp.coeFn_zero, Pi.zero_apply, zero_apply] + have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : (i : ℕ) → MetricSpace (V i)] (o : (i : ℕ) → V i) (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (r : ℝ) + (hp : ∀ i, OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) : + letI := OAI.CoarseAssembly.separatedMetric o + OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let := OAI.CoarseAssembly.separatedMetric o + rintro ⟨i, x⟩ ⟨j, y⟩ hxy + by_cases hij : i = j + · subst j + rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same] + apply hp i x y + simpa only [show dist (⟨i, x⟩ : Sigma V) ⟨i, y⟩ = dist x y from + ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof) o i x y] using hxy + · exact OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne A C hC hA hij x y + have OAI.CoarseAssembly.separatedDist_indices {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y : Sigma V) (hxy : x.1 ≠ y.1) + {R : ℝ} (hR : OAI.CoarseAssembly.separatedDist o x y ≤ R) : (x.1 : ℝ) ≤ R ∧ (y.1 : ℝ) ≤ R := + open OAI OAI.CoarseAssembly in + by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + rw [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hxy] at hR + have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + constructor <;> linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)] + have OAI.CoarseAssembly.separated_closedBall_finite {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] [∀ j, Fintype (V j)] + (o : ∀ j, V j) (x : Sigma V) (r : ℝ) : + letI := OAI.CoarseAssembly.separatedMetric o + Set.Finite {y : Sigma V | dist x y ≤ r} := + open OAI OAI.CoarseAssembly in + open Topology Rips in + by + classical + let := OAI.CoarseAssembly.separatedMetric o + let m := max (x.1 + 1) (⌈r⌉₊ + 1) + let s : Finset (Sigma V) := (Finset.range m).sigma (fun _ => Finset.univ) + apply s.finite_toSet.subset + intro y hy + have hm : y.1 < m := by + by_cases hxy : x.1 = y.1 + · dsimp [m] + omega + · have hb := (OAI.CoarseAssembly.separatedDist_indices o x y hxy hy).2 + have hc : y.1 ≤ ⌈r⌉₊ := by exact_mod_cast hb.trans (Nat.le_ceil r) + dsimp [m] + omega + exact Finset.mem_sigma.mpr ⟨Finset.mem_range.mpr hm, Finset.mem_univ _⟩ + have OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] (o : ∀ i, V i) (x : Sigma V) (r : ℝ) : + letI := OAI.CoarseAssembly.separatedMetric o + (Metric.closedBall x r).Finite := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let := OAI.CoarseAssembly.separatedMetric o + simpa only [Metric.closedBall, dist_comm] using OAI.CoarseAssembly.separated_closedBall_finite o x r + let := OAI.CoarseAssembly.separatedMetric o + exact ⟨OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA, + OAI.CoarseAssembly.DiscreteRoe.finitePropagation_multiplier (OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite o) hr + (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation o A C hC hA r hp)⟩ + +-- The self-contained construction includes its support proofs. +def separatedFamilyBoundary (hself : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator ((A i * A i - (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)).toFun)) : + letI := OAI.CoarseAssembly.separatedMetric o + OAI.CoarseAssembly.OperatorKTheory.K1 (OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma V) (H := H)) := by + classical + have OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (s : Finset X) (v : OAI.CoarseAssembly.DiscreteRoe.Module X H) + (hv : ∀ x, x ∉ s → v x = 0) : + v = ∑ x ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert x (v x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + apply lp.ext + funext x + simp only [lp.coeFn_sum, Finset.sum_apply, ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), lp.coeFn_single] + rw [Finset.sum_pi_single] + by_cases hx : x ∈ s + · simp [hx] + · simp [hx, hv x hx] + have OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (s : Finset X) + (hs : ∀ z, z ∉ s → OAI.CoarseAssembly.DiscreteRoe.entry S z y = 0) : + OAI.CoarseAssembly.DiscreteRoe.entry (T * S) x y = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.entry T x z * OAI.CoarseAssembly.DiscreteRoe.entry S z y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext h + have hv : S (OAI.CoarseAssembly.DiscreteRoe.insert y h) = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert z (OAI.CoarseAssembly.DiscreteRoe.entry S z y h) := by + apply OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum + intro z hz + have := DFunLike.congr_fun (hs z hz) h + simpa only [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), zero_apply] using this + change OAI.CoarseAssembly.DiscreteRoe.coordinate x (T (S (OAI.CoarseAssembly.DiscreteRoe.insert y h))) = _ + rw [hv, map_sum, map_sum] + simp only [sum_apply, mul_apply_eq_comp] + rfl + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r s : ℝ} {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : + OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + s) (T * S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) : + ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro z hz + apply hT + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz + local_proof) finiteBalls hS y)] + apply Finset.sum_eq_zero + intro z hz + have hzy : dist z y ≤ s := by + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall] using hz + have hxz : r < dist x z := by + have htri := dist_triangle x z y + linarith + rw [hT x z hxz, zero_mul] + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r s : ℝ} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : + OAI.CoarseAssembly.DiscreteRoe.PropagationLE (max r s) (T + S) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp] + local_proof), hT x y (lt_of_le_of_lt (le_max_left _ _) hxy), + hS x y (lt_of_le_of_lt (le_max_right _ _) hxy), add_zero] + have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r : ℝ} + (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (z : ℂ) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (z • T) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + rw [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) : + OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + by + ext h + simp [OAI.CoarseAssembly.DiscreteRoe.entry] + local_proof), hT x y hxy, smul_zero] + have OAI.CoarseAssembly.DiscreteRoe.propagationLE_one {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] : OAI.CoarseAssembly.DiscreteRoe.PropagationLE 0 (1 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + intro x y hxy + have hne : x ≠ y := by intro h; simp [h] at hxy + ext v + simp [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), lp.single_apply, hne] + have OAI.CoarseAssembly.blockOperator_adjoint {I : Type _} {E : I → Type _} {F : I → Type _} [inst_local_3 : (i : I) → NormedAddCommGroup (E i)] [inst_local_4 : (i : I) → InnerProductSpace ℂ (E i)] [inst_local_5 : ∀ (i : I), CompleteSpace (E i)] [inst_local_6 : (i : I) → NormedAddCommGroup (F i)] [inst_local_7 : (i : I) → InnerProductSpace ℂ (F i)] [inst_local_8 : ∀ (i : I), CompleteSpace (F i)] (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) : + (OAI.CoarseAssembly.blockOperator A C hC hA).adjoint = + OAI.CoarseAssembly.blockOperator (fun i => (A i).adjoint) C hC + (fun i => (LinearIsometryEquiv.norm_map ContinuousLinearMap.adjoint _).trans_le (hA i)) := + open OAI OAI.CoarseAssembly in + open scoped Topology in + by + symm + apply (ContinuousLinearMap.eq_adjoint_iff _ _).mpr + intro x y + simp only [lp.inner_eq_tsum, ( + let local_proof {ι : Type _} {E : ι → Type _} {F : ι → Type _} [inst_local_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_local_4 : (i : ι) → NormedSpace ℂ (E i)] [inst_local_5 : (i : ι) → NormedAddCommGroup (F i)] [inst_local_6 : (i : ι) → NormedSpace ℂ (F i)] (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (x : lp E 2) (i : ι) : + OAI.CoarseAssembly.blockOperator A C hC hA x i = A i (x i) := + open OAI OAI.CoarseAssembly in + open Filter in + open scoped Topology in + rfl + local_proof)] + exact tsum_congr (fun i => ContinuousLinearMap.adjoint_inner_left (A i) (y i) (x i)) + have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_selfAdjoint {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (hself : ∀ i, IsSelfAdjoint (A i)) : + IsSelfAdjoint (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + have hb : IsSelfAdjoint (OAI.CoarseAssembly.blockOperator A C hC hA) := by + change (OAI.CoarseAssembly.blockOperator A C hC hA).adjoint = _ + rw [OAI.CoarseAssembly.blockOperator_adjoint] + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext i + change (A i).adjoint (v i) = A i (v i) + have hi : (A i).adjoint = A i := (hself i).star_eq + exact DFunLike.congr_fun hi (v i) + rw [OAI.CoarseAssembly.DiscreteRoe.diagonalFamily, ( + let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] + (A : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) : + OAI.CoarseAssembly.flattenOperator A = OAI.CoarseAssembly.operatorConjugation + (OAI.CoarseAssembly.flattenEquiv (Q := Q) (H := H)).toLinearIsometry A := + open OAI OAI.CoarseAssembly in + open scoped Topology in + by + let e := OAI.CoarseAssembly.flattenEquiv (Q := Q) (H := H) + have he : e.toLinearIsometry.toContinuousLinearMap.adjoint = + e.symm.toLinearIsometry.toContinuousLinearMap := e.adjoint_eq_symm + unfold OAI.CoarseAssembly.flattenOperator OAI.CoarseAssembly.operatorConjugation + rw [he] + local_proof)] + exact hb.map (OAI.CoarseAssembly.operatorConjugationHom (OAI.CoarseAssembly.flattenEquiv (Q := V) (H := H)).toLinearIsometry) + have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨i, y⟩ = OAI.CoarseAssembly.DiscreteRoe.entry (A i) x y := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext v + simp only [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), ( + let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) : + OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + rfl + local_proof), ( + let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] (i : I) (q : Q i) (h : H) : + OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) i = lp.single 2 q h := + open OAI OAI.CoarseAssembly in + by + apply lp.ext + funext r + change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨i, r⟩ = + lp.single (E := fun _ : Q i => H) 2 q h r + by_cases hr : r = q + · subst r; simp + · have hn : (⟨i, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := by + intro he + cases he + exact hr rfl + simp [hr, hn] + local_proof)] + have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) {i j : ℕ} (hij : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨j, y⟩ = 0 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + ext v + simp only [( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) : + OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + rfl + local_proof), ( + let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) : + OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + rfl + local_proof), ( + let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] {i j : I} (hji : j ≠ i) (q : Q i) (h : H) : + OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) j = 0 := + open OAI OAI.CoarseAssembly in + by + apply lp.ext + funext r + have hn : (⟨j, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := fun he => hji (congrArg Sigma.fst he) + change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨j, r⟩ = 0 + exact lp.single_apply_ne (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h hn + local_proof) hij, map_zero, + lp.coeFn_zero, Pi.zero_apply, zero_apply] + have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : (i : ℕ) → MetricSpace (V i)] (o : (i : ℕ) → V i) (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (r : ℝ) + (hp : ∀ i, OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) : + letI := OAI.CoarseAssembly.separatedMetric o + OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let := OAI.CoarseAssembly.separatedMetric o + rintro ⟨i, x⟩ ⟨j, y⟩ hxy + by_cases hij : i = j + · subst j + rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same] + apply hp i x y + simpa only [show dist (⟨i, x⟩ : Sigma V) ⟨i, y⟩ = dist x y from + ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof) o i x y] using hxy + · exact OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne A C hC hA hij x y + have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_defect {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) : + OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA * OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA - 1 = + OAI.CoarseAssembly.DiscreteRoe.diagonalFamily (fun i => A i * A i - 1) (C * C + 1) (by positivity) + (fun i => ( + let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] (A : OAI.CoarseAssembly.DiscreteRoe.Operator (V 0) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ‖A‖ ≤ C) : ‖A * A - 1‖ ≤ C * C + 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + calc + ‖A * A - 1‖ ≤ ‖A * A‖ + ‖(1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V 0) H)‖ := norm_sub_le _ _ + _ ≤ (‖A‖ * ‖A‖) + 1 := add_le_add (norm_mul_le _ _) ContinuousLinearMap.norm_id_le + _ ≤ C * C + 1 := by gcongr + @local_proof) (V := fun _ => V i) (A i) C hC (hA i)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext z + rcases z with ⟨i, x⟩ + simp only [sub_apply, mul_apply_eq_comp, one_apply_eq_self, lp.coeFn_sub, Pi.sub_apply, + ( + let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) : + OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + rfl + local_proof), ( + let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) : + OAI.CoarseAssembly.rowVector (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v) i = A i (OAI.CoarseAssembly.rowVector v i) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + apply lp.ext + rfl + local_proof)] + rfl + have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_compactEntries {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (hsq : ∀ i, IsCompactOperator ((A i * A i - (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)).toFun)) : + OAI.CoarseAssembly.DiscreteRoe.CompactEntries (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA * OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA - 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + rw [OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_defect] + rintro ⟨i, x⟩ ⟨j, y⟩ + by_cases hij : i = j + · subst j + rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same] + exact ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : IsCompactOperator T) : + OAI.CoarseAssembly.DiscreteRoe.CompactEntries T := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + fun x y => (hT.comp_clm (OAI.CoarseAssembly.DiscreteRoe.insert y)).clm_comp (OAI.CoarseAssembly.DiscreteRoe.coordinate x) + local_proof) (hsq i) x y + · rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne _ _ _ _ hij] + exact isCompactOperator_zero + have OAI.CoarseAssembly.separatedDist_indices {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y : Sigma V) (hxy : x.1 ≠ y.1) + {R : ℝ} (hR : OAI.CoarseAssembly.separatedDist o x y ≤ R) : (x.1 : ℝ) ≤ R ∧ (y.1 : ℝ) ≤ R := + open OAI OAI.CoarseAssembly in + by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + rw [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hxy] at hR + have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + constructor <;> linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)] + have OAI.CoarseAssembly.separated_closedBall_finite {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] [∀ j, Fintype (V j)] + (o : ∀ j, V j) (x : Sigma V) (r : ℝ) : + letI := OAI.CoarseAssembly.separatedMetric o + Set.Finite {y : Sigma V | dist x y ≤ r} := + open OAI OAI.CoarseAssembly in + open Topology Rips in + by + classical + let := OAI.CoarseAssembly.separatedMetric o + let m := max (x.1 + 1) (⌈r⌉₊ + 1) + let s : Finset (Sigma V) := (Finset.range m).sigma (fun _ => Finset.univ) + apply s.finite_toSet.subset + intro y hy + have hm : y.1 < m := by + by_cases hxy : x.1 = y.1 + · dsimp [m] + omega + · have hb := (OAI.CoarseAssembly.separatedDist_indices o x y hxy hy).2 + have hc : y.1 ≤ ⌈r⌉₊ := by exact_mod_cast hb.trans (Nat.le_ceil r) + dsimp [m] + omega + exact Finset.mem_sigma.mpr ⟨Finset.mem_range.mpr hm, Finset.mem_univ _⟩ + have OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] (o : ∀ i, V i) (x : Sigma V) (r : ℝ) : + letI := OAI.CoarseAssembly.separatedMetric o + (Metric.closedBall x r).Finite := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let := OAI.CoarseAssembly.separatedMetric o + simpa only [Metric.closedBall, dist_comm] using OAI.CoarseAssembly.separated_closedBall_finite o x r + have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_mem_roe {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] [inst_local_3 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_5 : NormedAddCommGroup H] [inst_local_6 : InnerProductSpace ℂ H] [inst_local_7 : CompleteSpace H] (o : (i : ℕ) → V i) (A : (i : ℕ) → OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : LE.le 0 C) (hA : ∀ (i : ℕ), LE.le (Norm.norm (A i)) C) (r : ℝ) (hr : LE.le 0 r) (hp : ∀ (i : ℕ), OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) (hself : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator ((A i * A i - (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)).toFun)) : + letI := OAI.CoarseAssembly.separatedMetric o + (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma V) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let := OAI.CoarseAssembly.separatedMetric o + have hT := OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation o A C hC hA r hp + have hdef : OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + r) (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA ^ 2 - 1) := by + have hm := OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul (OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite o) hT hT + have hn := OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul (OAI.CoarseAssembly.DiscreteRoe.propagationLE_one (X := Sigma V) (H := H)) (-1 : ℂ) + have hh := (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add hm hn) + have he : (-1 : ℂ) • (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) = -(1 : OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) := by + ext v + simp + rw [he] at hh + simpa only [pow_two, sub_eq_add_neg, + max_eq_left (add_nonneg hr hr)] using hh + have hc : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA ^ 2 - 1) := by + simpa only [pow_two] using OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_compactEntries A C hC hA hsq + have hs : IsSelfAdjoint (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA ^ 2 - 1) := by + have hs' := (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_selfAdjoint A C hC hA hself).pow 2 + have hi : IsSelfAdjoint (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) := IsSelfAdjoint.one _ + exact @IsSelfAdjoint.sub (OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) inferInstance inferInstance _ _ hs' hi + exact ( + let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) : + T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + open scoped Topology in + (NonUnitalStarSubalgebra.le_topologicalClosure _) + (NonUnitalStarAlgebra.subset_adjoin ℂ _ hT) + local_proof) ⟨⟨r + r, add_nonneg hr hr, hdef⟩, hc, by rwa [hs.star_eq]⟩ + have OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier_selfAdjoint {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] [inst_local_3 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_5 : NormedAddCommGroup H] [inst_local_6 : InnerProductSpace ℂ H] [inst_local_7 : CompleteSpace H] (o : (i : ℕ) → V i) (A : (i : ℕ) → OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : LE.le 0 C) (hA : ∀ (i : ℕ), LE.le (Norm.norm (A i)) C) (r : ℝ) (hr : LE.le 0 r) (hp : ∀ (i : ℕ), OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) (hself : ∀ i, IsSelfAdjoint (A i)) : + letI := OAI.CoarseAssembly.separatedMetric o + IsSelfAdjoint (OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier o A C hC hA r hr hp) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in + by + let := OAI.CoarseAssembly.separatedMetric o + apply Subtype.ext + exact (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_selfAdjoint A C hC hA hself).star_eq + let := OAI.CoarseAssembly.separatedMetric o + exact OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryClass (OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier o A C hC hA r hr hp) + (OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier_selfAdjoint o A C hC hA r hr hp hself) + (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_mem_roe o A C hC hA r hr hp hself hsq) + +end CoarseAssembly.DiscreteRoe + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + + +def partitionConjugate (a : X → H →L[ℂ] H) (F : H →L[ℂ] H) : Operator X H := + (partitionMap a).comp (F.comp (partitionMap a).adjoint) + +variable [PseudoMetricSpace X] + +end CoarseAssembly.DiscreteRoe + +end + +end + + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +attribute [local instance] spatialLocalizationContinuousAdd spatialLocalizationRingHomCompTriple + spatialLocalizationCompleteSpace + +variable [PseudoMetricSpace X] + +end CoarseAssembly.DiscreteRoe + +end + +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] {ι : Type*} [Fintype ι] + +def localizedOperator (c : OddCycle A) (a : ι → A) : End c.space := + ∑ i, c.representation (a i) * c.operator * c.representation (a i) + +def localizedCycle (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A) + (hF : IsSelfAdjoint c.operator) (ha : ∀ i, IsSelfAdjoint (a i)) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : OAI.CoarseAssembly.Analytic.OddCycle A := by + classical + have OAI.CoarseAssembly.Analytic.localizedOperator_sub_compact {A : Type} [inst_local_1 : NonUnitalCStarAlgebra A] {ι : Type _} [inst_local_3 : Fintype ι] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : + IsCompactOperator (OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [( + let local_proof {A : Type} [inst_local_1 : NonUnitalCStarAlgebra A] {ι : Type _} [inst_local_3 : Fintype ι] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : + OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator = + ∑ i, c.representation (a i) * + (c.operator * c.representation (a i) - c.representation (a i) * c.operator) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + calc + OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator = OAI.CoarseAssembly.Analytic.localizedOperator c a - + (∑ i, c.representation (a i) * c.representation (a i)) * c.operator := by + rw [hpart, one_mul] + _ = ∑ i, (c.representation (a i) * c.operator * c.representation (a i) - + (c.representation (a i) * c.representation (a i)) * c.operator) := by + rw [OAI.CoarseAssembly.Analytic.localizedOperator, Finset.sum_mul, ← Finset.sum_sub_distrib] + _ = _ := by + apply Finset.sum_congr rfl + intro i _ + noncomm_ring + local_proof) c a hpart] + exact (compactOperator (RingHom.id ℂ) c.space c.space).sum_mem + (fun i _ => ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) : + IsCompactOperator (T * K) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + hK.clm_comp T + local_proof) (c.commutator_compact (a i)) _) + exact c.compactPerturb (OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator) + (OAI.CoarseAssembly.Analytic.localizedOperator_sub_compact c a hpart) (by + rw [((( + let local_proof {A : Type} [inst_local_1 : NonUnitalCStarAlgebra A] {ι : Type _} [inst_local_3 : Fintype ι] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A) + (hF : IsSelfAdjoint c.operator) (ha : ∀ i, IsSelfAdjoint (a i)) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.localizedOperator c a) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + isSelfAdjoint_sum _ (fun i _ => hF.conjugate_self ((ha i).map c.representation)) + local_proof) c a hF ha).sub hF).star_eq] + exact OAI.CoarseAssembly.Analytic.localizedOperator_sub_compact c a hpart) + +end CoarseAssembly.Analytic + +end + +end + + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + + +def ampleRipsOperator (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : Operator X (lp (fun _ : ℕ => ℂ) 2) := + coefficientExtension (ampleIsometry c.space) (ripsSpatialOperator r c hπ) + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] + +-- The self-contained construction includes its support proofs. +def ampleRipsFamilyBoundary (o : ∀ i, V i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point (V i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (C : ℝ) (hC : 0 ≤ C) (hnorm : ∀ i, ‖(c i).operator‖ ≤ C) : + letI := OAI.CoarseAssembly.separatedMetric o + OAI.CoarseAssembly.OperatorKTheory.K1 (OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma V) (H := lp (fun _ : ℕ => ℂ) 2)) := by + classical + have extensionProperties {E H : Type} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + (W : E →ₗᵢ[ℂ] H) (T : E →L[ℂ] E) (hTs : IsSelfAdjoint T) + (hTc : IsCompactOperator (T * T - (1 : E →L[ℂ] E))) : + let A := isometricExtension W T + ‖A‖ ≤ ‖T‖ + 2 ∧ IsSelfAdjoint A ∧ IsCompactOperator (A * A - (1 : H →L[ℂ] H)) := by + intro A + let q := operatorConjugationHom W + have h1 : ‖(1 : E →L[ℂ] E)‖ ≤ 1 := ContinuousLinearMap.norm_id_le + have hd : ‖T - 1‖ ≤ ‖T‖ + 1 := (norm_sub_le _ _).trans (add_le_add le_rfl h1) + have hq : ‖q (T - 1)‖ ≤ ‖T - 1‖ := NonUnitalStarAlgHom.norm_apply_le q (T - 1) + have hn : ‖A‖ ≤ ‖T‖ + 2 := by + change ‖1 + q (T - 1)‖ ≤ ‖T‖ + 2 + calc + ‖1 + q (T - 1)‖ ≤ ‖(1 : H →L[ℂ] H)‖ + ‖q (T - 1)‖ := norm_add_le _ _ + _ ≤ 1 + (‖T‖ + 1) := add_le_add ContinuousLinearMap.norm_id_le (hq.trans hd) + _ = ‖T‖ + 2 := by ring + have hs : IsSelfAdjoint A := (IsSelfAdjoint.one (H →L[ℂ] H)).add + ((hTs.sub (IsSelfAdjoint.one (E →L[ℂ] E))).map q) + have hpoly : (T - 1) * (T - 1) + (T - 1) + (T - 1) = T * T - 1 := by noncomm_ring + have heq : A * A - 1 = operatorConjugation W (T * T - 1) := calc + A * A - 1 = q (T - 1) * q (T - 1) + q (T - 1) + q (T - 1) := by + change (1 + q (T - 1)) * (1 + q (T - 1)) - 1 = _ + noncomm_ring + _ = q ((T - 1) * (T - 1) + (T - 1) + (T - 1)) := by rw [map_add, map_add, map_mul] + _ = q (T * T - 1) := congrArg q hpoly + _ = operatorConjugation W (T * T - 1) := rfl + have hc : IsCompactOperator (operatorConjugation W (T * T - 1)) := + (hTc.comp_clm W.toContinuousLinearMap.adjoint).clm_comp W.toContinuousLinearMap + exact ⟨hn, hs, heq.symm ▸ hc⟩ + have spatialProperties {X E H : Type} [Fintype X] [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + (W : E →ₗᵢ[ℂ] H) (a : X → E →L[ℂ] E) (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) + (F : E →L[ℂ] E) (hFs : IsSelfAdjoint F) (radius : ℝ) (hradius : 0 ≤ radius) + (ha : ∀ x, (a x).adjoint = a x) + (hsupport : ∀ x y, radius < dist x y → a x * a y = 0) + (hcompact : (∀ v : E, partitionCompression a F v = ∑ x : X, (a x).adjoint (F ((a x) v))) → + IsCompactOperator (partitionCompression a F * partitionCompression a F - (1 : E →L[ℂ] E))) : + let K := partitionCompression a F + let P := partitionIsometry a hpart + let S := isometricExtension P K + let U := coefficientIsometry (X := X) W + let A := isometricExtension U S + ‖A‖ ≤ ‖F‖ + 4 ∧ IsSelfAdjoint A ∧ PropagationLE (radius + radius) A ∧ + IsCompactOperator (A * A - (1 : Module X H →L[ℂ] Module X H)) := by + intro K P S U A + have hblock : ‖constantBlock (X := X) F‖ ≤ ‖F‖ := by + unfold constantBlock blockOperator + generalize_proofs (config := {maxDepth := 0}) + apply LinearMap.mkContinuous_norm_le + assumption + have hPn : ‖partitionMap a‖ ≤ 1 := P.norm_toContinuousLinearMap_le + have hPsn : ‖(partitionMap a).adjoint‖ ≤ 1 := by + simpa only [ContinuousLinearMap.adjoint.norm_map] using hPn + have hP0 : 0 ≤ ‖partitionMap a‖ := (partitionMap a).opNorm_nonneg + have hB0 : 0 ≤ ‖constantBlock (X := X) F‖ := (constantBlock (X := X) F).opNorm_nonneg + have hF0 : 0 ≤ ‖F‖ := F.opNorm_nonneg + have hKn : ‖K‖ ≤ ‖F‖ := calc + ‖K‖ ≤ ‖(partitionMap a).adjoint‖ * (‖constantBlock (X := X) F‖ * ‖partitionMap a‖) := + (ContinuousLinearMap.opNorm_comp_le _ _).trans + (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (partitionMap a).adjoint.opNorm_nonneg) + _ ≤ 1 * (‖F‖ * 1) := mul_le_mul hPsn (mul_le_mul hblock hPn hP0 hF0) + (mul_nonneg hB0 hP0) zero_le_one + _ = ‖F‖ := by simp only [one_mul, mul_one] + have coordP (x : X) : (coordinate x).comp (partitionMap a) = a x := by + ext v + simp only [partitionMap, ContinuousLinearMap.comp_apply, sum_apply, map_sum] + change (∑ y : X, (lp.single 2 y ((a y) v)) x) = (a x) v + simp [lp.single_apply] + have partAdjApply (v : Module X E) : (partitionMap a).adjoint v = ∑ x : X, (a x).adjoint (v x) := by + apply ext_inner_left ℂ + intro h + rw [ContinuousLinearMap.adjoint_inner_right] + change inner ℂ ((∑ x : X, (DiscreteRoe.insert x).comp (a x)) h) v = + inner ℂ h (∑ x : X, (a x).adjoint (v x)) + simp only [sum_apply, ContinuousLinearMap.comp_apply, sum_inner, inner_sum] + apply Finset.sum_congr rfl + intro x _ + change inner ℂ (lp.single (E := fun _ : X => E) 2 x ((a x) h)) v = _ + exact (lp.inner_single_left (𝕜 := ℂ) (G := fun _ : X => E) x ((a x) h) v).trans + (ContinuousLinearMap.adjoint_inner_right (a x) h (v x)).symm + have KApply (v : E) : K v = ∑ x : X, (a x).adjoint (F ((a x) v)) := by + change (partitionMap a).adjoint (constantBlock F (partitionMap a v)) = _ + rw [partAdjApply] + apply Finset.sum_congr rfl + intro x _ + change (a x).adjoint (F ((partitionMap a v) x)) = (a x).adjoint (F ((a x) v)) + exact congrArg (fun h => (a x).adjoint (F h)) (DFunLike.congr_fun (coordP x) v) + have hKs : IsSelfAdjoint K := by + have hKeq : K = ∑ x : X, (a x).adjoint.comp (F.comp (a x)) := by + apply ContinuousLinearMap.ext + intro v + simpa only [sum_apply, ContinuousLinearMap.comp_apply] using KApply v + rw [hKeq] + exact isSelfAdjoint_sum _ (fun x _ => hFs.conjugate' (a x)) + have partAdjSingle (y : X) (h : E) : (partitionMap a).adjoint (lp.single 2 y h) = (a y).adjoint h := by + rw [partAdjApply] + calc + (∑ z : X, (a z).adjoint ((lp.single (E := fun _ : X => E) 2 y h) z)) = + (a y).adjoint ((lp.single (E := fun _ : X => E) 2 y h) y) := by + apply Finset.sum_eq_single + · intro z _ hzy + rw [lp.single_apply_ne (E := fun _ : X => E) 2 y h hzy, map_zero] + · intro hy + exact (hy (Finset.mem_univ y)).elim + _ = (a y).adjoint h := congrArg (a y).adjoint (lp.single_apply_self (E := fun _ : X => E) 2 y h) + have entryConjApply (T : E →L[ℂ] E) (x y : X) (h : E) : + entry (partitionConjugate a T) x y h = a x (T ((a y).adjoint h)) := by + have hy : (partitionMap a).adjoint (lp.single 2 y h) = (a y).adjoint h := partAdjSingle y h + have hx : (partitionMap a (T ((a y).adjoint h))) x = a x (T ((a y).adjoint h)) := + DFunLike.congr_fun (coordP x) (T ((a y).adjoint h)) + change (partitionMap a (T ((partitionMap a).adjoint (lp.single 2 y h)))) x = _ + exact (congrArg (fun v : E => (partitionMap a (T v)) x) hy).trans hx + have hSp : PropagationLE (radius + radius) S := by + intro x y hxy + let L : Operator X E := partitionConjugate a K + let Q : Operator X E := partitionConjugate a 1 + have hne : x ≠ y := by + intro h + subst y + exact (not_lt_of_ge (add_nonneg hradius hradius)) (by simpa only [dist_self] using hxy) + apply ContinuousLinearMap.ext + intro h + have hLv : L (lp.single 2 y h) x = 0 := by + change entry (partitionConjugate a K) x y h = 0 + rw [entryConjApply, ha y, KApply] + simp only [map_sum] + apply Finset.sum_eq_zero + intro z _ + rw [ha z] + by_cases hxz : radius < dist x z + · exact DFunLike.congr_fun (hsupport x z hxz) (F ((a z) ((a y) h))) + · have hzy : radius < dist z y := by + by_contra hz + exact (not_le_of_gt hxy) ((dist_triangle x z y).trans + (add_le_add (le_of_not_gt hxz) (le_of_not_gt hz))) + have hzyv : a z (a y h) = 0 := DFunLike.congr_fun (hsupport z y hzy) h + simp only [hzyv, map_zero] + have hQv : Q (lp.single 2 y h) x = 0 := by + change entry (partitionConjugate a 1) x y h = 0 + rw [entryConjApply, ha y, one_apply_eq_self] + exact DFunLike.congr_fun (hsupport x y ((le_add_of_nonneg_right hradius).trans_lt hxy)) h + have h1v : (lp.single (E := fun _ : X => E) 2 y h) x = 0 := + lp.single_apply_ne (E := fun _ : X => E) 2 y h hne + change (lp.single (E := fun _ : X => E) 2 y h) x + + (partitionMap a ((K - 1) ((partitionMap a).adjoint (lp.single 2 y h)))) x = 0 + rw [sub_apply, one_apply_eq_self, map_sub] + change (lp.single (E := fun _ : X => E) 2 y h) x + + (L (lp.single 2 y h) x - Q (lp.single 2 y h) x) = 0 + rw [h1v, hLv, hQv, sub_self, add_zero] + have hAp : PropagationLE (radius + radius) A := by + intro x y hxy + have hne : x ≠ y := by + intro h + subst y + exact (not_lt_of_ge (add_nonneg hradius hradius)) (by simpa only [dist_self] using hxy) + apply ContinuousLinearMap.ext + intro h + have hU : U.toContinuousLinearMap.adjoint (lp.single 2 y h) = + lp.single 2 y (W.toContinuousLinearMap.adjoint h) := by + apply ext_inner_left ℂ + intro v + calc + inner ℂ v (U.toContinuousLinearMap.adjoint (lp.single 2 y h)) = + inner ℂ (U.toContinuousLinearMap v) (lp.single 2 y h) := + ContinuousLinearMap.adjoint_inner_right _ _ _ + _ = inner ℂ (W (v y)) h := lp.inner_single_right (𝕜 := ℂ) + (G := fun _ : X => H) y h (U.toContinuousLinearMap v) + _ = inner ℂ (v y) (W.toContinuousLinearMap.adjoint h) := + (ContinuousLinearMap.adjoint_inner_right W.toContinuousLinearMap (v y) h).symm + _ = inner ℂ v (lp.single 2 y (W.toContinuousLinearMap.adjoint h)) := + (lp.inner_single_right (𝕜 := ℂ) (G := fun _ : X => E) y + (W.toContinuousLinearMap.adjoint h) v).symm + have hSv : S (lp.single 2 y (W.toContinuousLinearMap.adjoint h)) x = 0 := + DFunLike.congr_fun (hSp x y hxy) (W.toContinuousLinearMap.adjoint h) + have hs : (lp.single (E := fun _ : X => E) 2 y (W.toContinuousLinearMap.adjoint h)) x = 0 := + lp.single_apply_ne (E := fun _ : X => E) 2 y (W.toContinuousLinearMap.adjoint h) hne + have ht : (lp.single (E := fun _ : X => H) 2 y h) x = 0 := + lp.single_apply_ne (E := fun _ : X => H) 2 y h hne + change ((lp.single (E := fun _ : X => H) 2 y h) + + U.toContinuousLinearMap ((S - 1) (U.toContinuousLinearMap.adjoint (lp.single 2 y h)))) x = 0 + rw [hU] + change (lp.single (E := fun _ : X => H) 2 y h) x + + W (S (lp.single 2 y (W.toContinuousLinearMap.adjoint h)) x - + (lp.single (E := fun _ : X => E) 2 y (W.toContinuousLinearMap.adjoint h)) x) = 0 + rw [ht, hSv, hs, sub_self, map_zero, add_zero] + have hKc := hcompact KApply + have first := extensionProperties P K hKs hKc + have second := extensionProperties U S first.2.1 first.2.2 + have hSn : ‖S‖ ≤ ‖F‖ + 2 := first.1.trans (add_le_add hKn le_rfl) + have hAn : ‖A‖ ≤ ‖F‖ + 4 := calc + ‖A‖ ≤ ‖S‖ + 2 := second.1 + _ ≤ (‖F‖ + 2) + 2 := add_le_add hSn le_rfl + _ = ‖F‖ + 4 := by ring + exact ⟨hAn, second.2.1, hAp, second.2.2⟩ + let Good (i : ℕ) (Z : Operator (V i) (lp (fun _ : ℕ => ℂ) 2)) : Prop := + ‖Z‖ ≤ ‖(c i).operator‖ + 4 ∧ IsSelfAdjoint Z ∧ PropagationLE (r + r) Z ∧ + IsCompactOperator (Z * Z - (1 : Operator (V i) (lp (fun _ : ℕ => ℂ) 2))) + have properties (i : ℕ) : let T := ampleRipsOperator r (c i) (hπ i); Good i T := by + intro T + let cycle := c i + let a : V i → cycle.space →L[ℂ] cycle.space := representedSqrt r cycle + let F : cycle.space →L[ℂ] cycle.space := cycle.operator + let W : cycle.space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2 := ampleIsometry cycle.space + have hFi : IsSelfAdjoint F := hF i + have hπi : cycle.representation 1 = 1 := hπ i + have hsqrt (x : V i) : IsSelfAdjoint (sqrtCoordinate r x) := by + ext p + simp [sqrtCoordinate] + have hsum : ∑ x : V i, sqrtCoordinate r x * sqrtCoordinate r x = 1 := by + ext p + change (ContinuousMap.evalAlgHom ℂ ℂ p) (∑ x : V i, sqrtCoordinate r x * sqrtCoordinate r x) = 1 + rw [map_sum] + simp only [map_mul] + change (∑ x : V i, (Real.sqrt (p.weight x) : ℂ) * (Real.sqrt (p.weight x) : ℂ)) = 1 + simp only [← Complex.ofReal_mul, Real.mul_self_sqrt (p.nonneg _)] + have htotal : ∑ x : V i, p.weight x = 1 := by + rw [← p.total] + exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm + rw [← Complex.ofReal_sum, htotal, Complex.ofReal_one] + have hadj (x : V i) : (a x).adjoint = a x := by + change (cycle.representation (sqrtCoordinate r x)).adjoint = cycle.representation (sqrtCoordinate r x) + exact ((hsqrt x).map cycle.representation).star_eq + have hrep : ∑ x : V i, a x * a x = 1 := by + change (∑ x : V i, cycle.representation (sqrtCoordinate r x) * + cycle.representation (sqrtCoordinate r x)) = 1 + simp only [← map_mul, ← map_sum, hsum, hπi] + have hpart : ∑ x : V i, (a x).adjoint.comp (a x) = 1 := by + change (∑ x : V i, (a x).adjoint * a x) = 1 + simpa only [hadj] using hrep + have support (x y : V i) (hxy : r < dist x y) : a x * a y = 0 := by + have hz : sqrtCoordinate r x * sqrtCoordinate r y = 0 := by + ext p + have hp : p.weight x = 0 ∨ p.weight y = 0 := by + by_contra h + push Not at h + exact (not_le_of_gt hxy) (p.diameter x (Finsupp.mem_support_iff.mpr h.1) + y (Finsupp.mem_support_iff.mpr h.2)) + rcases hp with hx | hy + · simp [sqrtCoordinate, hx] + · simp [sqrtCoordinate, hy] + change cycle.representation (sqrtCoordinate r x) * cycle.representation (sqrtCoordinate r y) = 0 + exact (map_mul cycle.representation _ _).symm.trans + ((congrArg cycle.representation hz).trans (map_zero cycle.representation)) + have hcompact (KApply : ∀ v : cycle.space, partitionCompression a F v = + ∑ x : V i, (a x).adjoint (F ((a x) v))) : + IsCompactOperator (partitionCompression a F * partitionCompression a F - + (1 : cycle.space →L[ℂ] cycle.space)) := by + let K := partitionCompression a F + let G := localizedOperator cycle (sqrtCoordinate r) + have hKloc : K = G := by + apply ContinuousLinearMap.ext + intro v + change partitionCompression a F v = G v + rw [KApply] + change (∑ x : V i, (a x).adjoint (F ((a x) v))) = + (∑ x : V i, cycle.representation (sqrtCoordinate r x) * F * cycle.representation (sqrtCoordinate r x)) v + simp only [sum_apply, hadj] + apply Finset.sum_congr rfl + intro x _ + rfl + let d := localizedCycle cycle (sqrtCoordinate r) hFi hsqrt hrep + have hd := d.square_compact 1 + change IsCompactOperator (((F + (G - F)) * (F + (G - F)) - (1 : cycle.space →L[ℂ] cycle.space)) * + cycle.representation 1) at hd + have hsumFG : F + (G - F) = G := by abel + have hGc : IsCompactOperator (G * G - (1 : cycle.space →L[ℂ] cycle.space)) := by + simpa only [hsumFG, hπi, mul_one] using hd + exact (congrArg (fun Q : cycle.space →L[ℂ] cycle.space => Q * Q - 1) hKloc).symm ▸ hGc + let K := partitionCompression a F + let P := partitionIsometry a hpart + let S := isometricExtension P K + let U := coefficientIsometry (X := V i) W + let A := isometricExtension U S + have facts := spatialProperties W a hpart F hFi r hr hadj support hcompact + have result : Good i A := facts + have hAeq : A = T := rfl + rw [← hAeq] + exact result + exact separatedFamilyBoundary o (fun i => ampleRipsOperator r (c i) (hπ i)) + (C + 4) (add_nonneg hC (by norm_num)) + (fun i => (properties i).1.trans (add_le_add (hnorm i) le_rfl)) + (r + r) (add_nonneg hr hr) (fun i => (properties i).2.2.1) + (fun i => (properties i).2.1) (fun i => (properties i).2.2.2) + +end CoarseAssembly.Rips + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + + +universe sourceUniverse targetUniverse coefficientUniverse + +local instance inclusionExponentFact : Fact (1 ≤ (2 : ENNReal)) := ⟨one_le_two⟩ + +variable {X : Type sourceUniverse} {Y : Type targetUniverse} {H : Type coefficientUniverse} + [sourceDecidable : DecidableEq X] [targetDecidable : DecidableEq Y] + [coefficientNormed : NormedAddCommGroup H] [coefficientInner : InnerProductSpace ℂ H] + [coefficientComplete : CompleteSpace H] + +variable [sourceMetric : PseudoMetricSpace X] [targetMetric : PseudoMetricSpace Y] + +-- The self-contained construction includes its support proofs. +def inclusionHom (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) →⋆ₙₐ[ℂ] OAI.CoarseAssembly.DiscreteRoe.algebra (X := Y) (H := H) := by + classical + let V : Module X H →ₗᵢ[ℂ] Module Y H := inclusionIsometry e + let φ : Operator X H →⋆ₙₐ[ℂ] Operator Y H := operatorConjugationHom V + have vector_apply (v : Module X H) (x : X) : V v (e x) = v x := by + change extendedFunction e v (e x) = v x + exact e.injective.extend_apply _ _ _ + have vector_zero (v : Module X H) (y : Y) (hy : y ∉ Set.range e) : V v y = 0 := by + change extendedFunction e v y = 0 + exact Function.extend_apply' _ _ _ hy + have isometry_single (x : X) (h : H) : V (lp.single 2 x h) = lp.single 2 (e x) h := by + apply lp.ext + funext y + by_cases hy : y ∈ Set.range e + · obtain ⟨z, rfl⟩ := hy + rw [vector_apply] + simp only [lp.single_apply, Pi.single_apply, e.injective.eq_iff] + · rw [vector_zero _ y hy] + exact (lp.single_apply_ne (E := fun _ : Y => H) 2 (e x) h + (fun hxy => hy ⟨x, hxy.symm⟩)).symm + have adjoint_apply (v : Module Y H) (x : X) : V.toContinuousLinearMap.adjoint v x = v (e x) := by + apply ext_inner_left ℂ + intro h + calc + inner ℂ h (V.toContinuousLinearMap.adjoint v x) = + inner ℂ (lp.single 2 x h) (V.toContinuousLinearMap.adjoint v) := + (lp.inner_single_left (𝕜 := ℂ) (G := fun _ : X => H) x h + (V.toContinuousLinearMap.adjoint v)).symm + _ = inner ℂ (V.toContinuousLinearMap (lp.single 2 x h)) v := + ContinuousLinearMap.adjoint_inner_right _ _ _ + _ = inner ℂ (lp.single 2 (e x) h) v := + congrArg (fun w => inner ℂ w v) (isometry_single x h) + _ = inner ℂ h (v (e x)) := lp.inner_single_left (𝕜 := ℂ) (G := fun _ : Y => H) (e x) h v + have entry_eq (T : Operator X H) (x y : X) : entry (φ T) (e x) (e y) = entry T x y := by + ext h + change V (T (V.toContinuousLinearMap.adjoint (lp.single 2 (e y) h))) (e x) = + T (lp.single 2 y h) x + have hadj : V.toContinuousLinearMap.adjoint (V (lp.single 2 y h)) = lp.single 2 y h := by + simpa only [ContinuousLinearMap.comp_apply, one_apply_eq_self, + LinearIsometry.coe_toContinuousLinearMap] using + DFunLike.congr_fun V.adjoint_comp_self (lp.single 2 y h) + rw [← isometry_single y h, hadj] + exact vector_apply _ x + have entry_row_zero (T : Operator X H) (x y : Y) (hx : x ∉ Set.range e) : + entry (φ T) x y = 0 := by + ext h + change V (T (V.toContinuousLinearMap.adjoint (lp.single 2 y h))) x = 0 + exact vector_zero _ x hx + have entry_col_zero (T : Operator X H) (x y : Y) (hy : y ∉ Set.range e) : + entry (φ T) x y = 0 := by + ext h + have hz : V.toContinuousLinearMap.adjoint (lp.single 2 y h) = 0 := by + apply lp.ext + funext z + rw [adjoint_apply] + exact lp.single_apply_ne (E := fun _ : Y => H) 2 y h (fun hzy => hy ⟨z, hzy⟩) + change V (T (V.toContinuousLinearMap.adjoint (lp.single 2 y h))) x = 0 + rw [hz, map_zero, map_zero] + rfl + have compact_congr {S T : H →L[ℂ] H} (h : S = T) (hT : IsCompactOperator T.toFun) : + IsCompactOperator S.toFun := by + cases h + exact hT + have compact {T : Operator X H} (hT : CompactEntries T) : CompactEntries (φ T) := by + intro x y + by_cases hx : x ∈ Set.range e + · obtain ⟨a, rfl⟩ := hx + by_cases hy : y ∈ Set.range e + · obtain ⟨b, rfl⟩ := hy + exact compact_congr (entry_eq T a b) (hT a b) + · exact compact_congr (entry_col_zero T _ _ hy) + (show IsCompactOperator (0 : H →L[ℂ] H).toFun from isCompactOperator_zero) + · exact compact_congr (entry_row_zero T _ _ hx) + (show IsCompactOperator (0 : H →L[ℂ] H).toFun from isCompactOperator_zero) + have propagation {T : Operator X H} {r : ℝ} (hT : PropagationLE r T) : PropagationLE r (φ T) := by + intro x y hxy + by_cases hx : x ∈ Set.range e + · obtain ⟨a, rfl⟩ := hx + by_cases hy : y ∈ Set.range e + · obtain ⟨b, rfl⟩ := hy + exact (entry_eq T a b).trans (hT a b (hxy.trans_le (he a b))) + · exact entry_col_zero T _ _ hy + · exact entry_row_zero T _ _ hx + have generator {T : Operator X H} (hT : Generator T) : Generator (φ T) := by + obtain ⟨⟨r, hr, hprop⟩, hc, hcs⟩ := hT + refine ⟨⟨r, hr, propagation hprop⟩, compact hc, ?_⟩ + simpa only [map_star] using compact hcs + have hφ : Continuous φ := by + change Continuous (fun T : Operator X H => + V.toContinuousLinearMap.comp (T.comp V.toContinuousLinearMap.adjoint)) + exact continuous_const.clm_comp (continuous_id.clm_comp continuous_const) + have hgen (T : Operator X H) (hT : Generator T) : φ T ∈ algebra (X := Y) (H := H) := + (NonUnitalStarSubalgebra.le_topologicalClosure _) + (NonUnitalStarAlgebra.subset_adjoin ℂ _ (generator hT)) + refine conjugationHom V ?_ + intro T hT + change φ T ∈ algebra (X := Y) (H := H) + let SX : Set (Operator X H) := + (NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T} : Set (Operator X H)) + let SY : Set (Operator Y H) := (algebra (X := Y) (H := H) : Set (Operator Y H)) + have hclosed : IsClosed SY := by + change IsClosed (closure ((NonUnitalStarAlgebra.adjoin ℂ + {T : Operator Y H | Generator T}) : Set (Operator Y H))) + exact isClosed_closure + have hle : NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T} ≤ + (algebra (X := Y) (H := H)).comap φ := NonUnitalStarAlgebra.adjoin_le hgen + have hmap : SX ⊆ φ ⁻¹' SY := hle + have ht : T ∈ closure SX := hT + exact (closure_minimal hmap (hclosed.preimage hφ)) ht + +end CoarseAssembly.DiscreteRoe + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] {c d e : OddCycle A} + +attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClass + + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe Filter Topology + +variable (Q : ℕ → Type) [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] (r : ℝ) + +structure ControlledCycleFamily where + cycle : ∀ i, OddCycle C(Point (Q i) r, ℂ) + unital : ∀ i, (cycle i).representation 1 = 1 + selfAdjoint : ∀ i, IsSelfAdjoint (cycle i).operator + bound : ℝ + bound_nonneg : 0 ≤ bound + norm_le : ∀ i, ‖(cycle i).operator‖ ≤ bound + +variable {Q r} + +def ControlledCycleFamily.boundary (c : ControlledCycleFamily Q r) + (o : ∀ i, Q i) (hr : 0 ≤ r) : + letI := separatedMetric o + OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := + ampleRipsFamilyBoundary o r hr c.cycle c.unital c.selfAdjoint + c.bound c.bound_nonneg c.norm_le + +end CoarseAssembly.Rips + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + + +def regularizedFamily (c : ∀ i, OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point (Q i) r, ℂ)) + (χ : ∀ i, C(OAI.CoarseAssembly.Rips.Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) : OAI.CoarseAssembly.Rips.ControlledCycleFamily Q r := by + classical + have OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : IsSelfAdjoint c.cutDown.operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [(( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.cutDown.operator = OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change c.operator + (OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator - c.operator) = _ + abel + local_proof) c)] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _ + rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq] + rw [add_comm (star (P * F * P))] + rfl + local_proof) _ _ (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c) + have OAI.CoarseAssembly.Analytic.cutDown_complement {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.cutDown.operator * (1 - c.cutDown.representation 1) = 1 - c.cutDown.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change (c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c) * (1 - c.representation 1) = 1 - c.representation 1 + have he : c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c = + OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := by unfold OAI.CoarseAssembly.Analytic.representedCorrection; abel + rw [he] + exact ( + let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : OAI.CoarseAssembly.Analytic.symmetricCutDown P F * (1 - P) = 1 - P := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hzero : ∀ T : OAI.CoarseAssembly.Analytic.End H, P * T * P * (1 - P) = 0 := by + intro T + rw [mul_sub, mul_one, mul_assoc (P * T) P P, hPP, sub_self] + have hQ : (1 - P) * (1 - P) = 1 - P := by + calc + (1 - P) * (1 - P) = 1 - P - P + P * P := by noncomm_ring + _ = 1 - P := by rw [hPP]; abel + unfold OAI.CoarseAssembly.Analytic.symmetricCutDown + rw [add_mul, smul_mul_assoc, add_mul, hzero F, + star_mul, star_mul, hP.star_eq, ← mul_assoc, hzero (star F), add_zero, smul_zero, zero_add, hQ] + local_proof) _ _ (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsSelfAdjoint (c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + local_proof) c) (( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + c.representation 1 * c.representation 1 = c.representation 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + rw [← map_mul, one_mul] + local_proof) c) + have OAI.CoarseAssembly.Analytic.represented_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + apply ( + let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + have hz : (c.operator * c.operator - 1) * (1 - c.representation 1) = 0 := by + calc + _ = c.operator * (c.operator * (1 - c.representation 1)) - + (1 - c.representation 1) := by noncomm_ring + _ = 0 := by rw [hQ, hQ, sub_self] + have he : c.operator * c.operator - 1 = + (c.operator * c.operator - 1) * c.representation 1 := by + exact sub_eq_zero.mp (by simpa only [mul_sub, mul_one] using hz) + rw [he] + exact c.square_compact 1 + local_proof) c.scalarRestriction + change c.operator * (1 - c.representation (algebraMap ℂ A 1)) = + 1 - c.representation (algebraMap ℂ A 1) + simpa only [map_one] using hQ + have OAI.CoarseAssembly.Analytic.cutDown_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : + IsCompactOperator (c.cutDown.operator * c.cutDown.operator - 1 : OAI.CoarseAssembly.Analytic.End c.cutDown.space) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.represented_square_compact c.cutDown (OAI.CoarseAssembly.Analytic.cutDown_complement c) + have OAI.CoarseAssembly.Analytic.completedRepresentation_one {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + OAI.CoarseAssembly.Analytic.completedRepresentation c χ 1 = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + simp only [( + let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) (a : A) : + OAI.CoarseAssembly.Analytic.completedRepresentation c χ a = c.representation a + χ a • (1 - c.representation 1) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + rfl + local_proof), map_one, one_smul] + abel + have OAI.CoarseAssembly.Analytic.characterExtension_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) + (hF : IsSelfAdjoint c.operator) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) + (hsq : IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)) : + (c.characterExtension χ hF hQ hsq).representation 1 = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.completedRepresentation_one c χ + have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.unitalSelfAdjoint χ).representation 1 = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.characterExtension_unital (c.cutDown) χ (OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c) (OAI.CoarseAssembly.Analytic.cutDown_complement c) (OAI.CoarseAssembly.Analytic.cutDown_square_compact c) + have OAI.CoarseAssembly.Analytic.OddCycle.regularize_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.regularize χ).representation 1 = 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + (OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital c χ) + have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + IsSelfAdjoint (c.unitalSelfAdjoint χ).operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c + have OAI.CoarseAssembly.Analytic.OddCycle.regularize_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + IsSelfAdjoint (c.regularize χ).operator := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + ( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (OAI.CoarseAssembly.Analytic.boundedTransform F hF) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + change star (OAI.CoarseAssembly.Analytic.boundedTransform F hF) = OAI.CoarseAssembly.Analytic.boundedTransform F hF + simp only [OAI.CoarseAssembly.Analytic.boundedTransform, star_smul, star_sub, star_star, Complex.star_def, + map_div₀, Complex.conj_I, map_ofNat, neg_div, neg_smul] + module + local_proof) _ _ + have OAI.CoarseAssembly.Analytic.OddCycle.regularize_norm_le {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + ‖(c.regularize χ).operator‖ ≤ 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + ( + let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) : + ‖OAI.CoarseAssembly.Analytic.boundedTransform F hF‖ ≤ 1 := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + nontriviality A + unfold OAI.CoarseAssembly.Analytic.boundedTransform + rw [norm_smul, norm_div, Complex.norm_I, Complex.norm_ofNat] + have hn := norm_sub_le (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) (star (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A)) + rw [norm_star, CStarRing.norm_coe_unitary] at hn + nlinarith + local_proof) _ _ + exact { + cycle i := (c i).regularize (χ i) + unital i := (OAI.CoarseAssembly.Analytic.OddCycle.regularize_unital (c i) (χ i)) + selfAdjoint i := (OAI.CoarseAssembly.Analytic.OddCycle.regularize_selfAdjoint (c i) (χ i)) + bound := 1 + bound_nonneg := zero_le_one + norm_le i := (OAI.CoarseAssembly.Analytic.OddCycle.regularize_norm_le (c i) (χ i)) + } + +end CoarseAssembly.Rips + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClass + + +variable {H K : HilbertSpace} + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H K : HilbertSpace} + +attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClass + + +variable {A : Type} [CStarAlgebra A] {c d : OddCycle A} + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] {c d e : OddCycle A} + +attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClass + + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClass + + +variable {R : Type} [CStarAlgebra R] {c d e : OddCycle R} + +end CoarseAssembly.Analytic + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable (H : ℕ → HilbertSpace) + +attribute [-instance] StarOrderedRing.toExistsAddOfLE CStarModule.toInner + + +end CoarseAssembly.Analytic + +end + +end + + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} {A : Type} [NonUnitalCStarAlgebra A] + + +def analyticFamilyIndexFree (o : ∀ i, Q i) (hr : 0 ≤ r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (η : ∀ i, C(Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] A) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + FreeAbelianGroup (OddCycle A) →+ + OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := + FreeAbelianGroup.lift (fun c => (regularizedFamily (fun i => c.precomp (η i)) χ).boundary o hr) + +def analyticFamilyIndex (o : ∀ i, Q i) (hr : 0 ≤ r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (η : ∀ i, C(Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] A) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + OddK A →+ OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := by + classical + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + exact if h : relations A ≤ (analyticFamilyIndexFree o hr χ η).ker then + QuotientAddGroup.lift (relations A) (analyticFamilyIndexFree o hr χ η) h + else 0 + +end CoarseAssembly.Rips + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Topology Rips + +variable {V : ℕ → Type} [∀ j, MetricSpace (V j)] + {Z : ℕ → Type} [∀ j, TopologicalSpace (Z j)] [∀ j, CompactSpace (Z j)] + +def separatedRipsMap (o : ∀ j, V j) (r : ℝ) (j : ℕ) : + letI := OAI.CoarseAssembly.separatedMetric o + OAI.CoarseAssembly.Rips.Point (V j) r → OAI.CoarseAssembly.Rips.Point (Sigma V) r := by + classical + have OAI.CoarseAssembly.separatedComponent_isometry {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) : + letI := OAI.CoarseAssembly.separatedMetric o + Isometry (OAI.CoarseAssembly.separatedComponent (V := V) j) := + open OAI OAI.CoarseAssembly in + open Topology Rips in + by + let := OAI.CoarseAssembly.separatedMetric o + apply Isometry.of_dist_eq + intro x y + exact ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof) o j x y + let := OAI.CoarseAssembly.separatedMetric o + exact OAI.CoarseAssembly.Rips.mapPoint (OAI.CoarseAssembly.separatedComponent j) + (fun x y => ((OAI.CoarseAssembly.separatedComponent_isometry o j).dist_eq x y).le) + +variable [∀ j, Fintype (V j)] + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Topology Rips Analytic + +variable {V : ℕ → Type} [∀ j, MetricSpace (V j)] [∀ j, Fintype (V j)] + {Z : ℕ → Type} [∀ j, TopologicalSpace (Z j)] [∀ j, CompactSpace (Z j)] + + +def separatedRipsEmbedding (o : ∀ j, V j) (r : ℝ) (j : ℕ) : + letI := OAI.CoarseAssembly.separatedMetric o + OAI.CoarseAssembly.Rips.Point (V j) r ↪ OAI.CoarseAssembly.Rips.Point (Sigma V) r := by + classical + have OAI.CoarseAssembly.Rips.mapPoint_injective {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Function.Injective (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + intro p q h + apply OAI.CoarseAssembly.Rips.Point.ext + apply Finsupp.ext + intro x + have hx := congrArg (fun p : OAI.CoarseAssembly.Rips.Point Y r => p.weight (e x)) h + simpa only [( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) : + (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + Finsupp.embDomain_apply_self e p.weight x + local_proof)] using hx + have OAI.CoarseAssembly.separatedComponent_isometry {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) : + letI := OAI.CoarseAssembly.separatedMetric o + Isometry (OAI.CoarseAssembly.separatedComponent (V := V) j) := + open OAI OAI.CoarseAssembly in + open Topology Rips in + by + let := OAI.CoarseAssembly.separatedMetric o + apply Isometry.of_dist_eq + intro x y + exact ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof) o j x y + let := OAI.CoarseAssembly.separatedMetric o + exact ⟨OAI.CoarseAssembly.separatedRipsMap o r j, OAI.CoarseAssembly.Rips.mapPoint_injective (OAI.CoarseAssembly.separatedComponent j) + (fun x y => ((OAI.CoarseAssembly.separatedComponent_isometry o j).dist_eq x y).le)⟩ + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty CStarAlgebra + +variable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y] + [CompactSpace X] + + +def compactFunctionLift : C(X, ℂ) →⋆ₙₐ[ℂ] C₀(X, ℂ) where + toFun := ZeroAtInftyContinuousMap.ContinuousMap.liftZeroAtInfty + map_zero' := rfl + map_add' _ _ := rfl + map_mul' _ _ := rfl + map_smul' _ _ := rfl + map_star' _ := rfl + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +open scoped ZeroAtInfty + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + + +def lateRipsFunctionHom (o : ∀ i, Q i) (r : ℝ) (i : ℕ) : + letI := OAI.CoarseAssembly.separatedMetric o + C(OAI.CoarseAssembly.Rips.Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] C₀(OAI.CoarseAssembly.Rips.Point (Sigma Q) r, ℂ) := by + classical + have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) : + Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + (continuous_apply x).comp ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + continuous_induced_dom + local_proof) + have OAI.CoarseAssembly.Rips.mapPoint_range_open {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : Isometry e) + (hsep : ∀ x y, y ∉ Set.range e → r < dist (e x) y) : + IsOpen (Set.range (OAI.CoarseAssembly.Rips.mapPoint (r := r) e (fun x y => (he.dist_eq x y).le))) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + rw [( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : Isometry e) : + Set.range (OAI.CoarseAssembly.Rips.mapPoint (r := r) e (fun x y => (he.dist_eq x y).le)) = + {q : OAI.CoarseAssembly.Rips.Point Y r | ↑q.weight.support ⊆ Set.range e} := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + classical + ext q + constructor + · rintro ⟨p, rfl⟩ y hy + rw [OAI.CoarseAssembly.Rips.mapPoint, Finsupp.support_embDomain, Finset.mem_coe, Finset.mem_map] at hy + obtain ⟨x, _, rfl⟩ := hy + exact ⟨x, rfl⟩ + · intro hq + refine ⟨OAI.CoarseAssembly.Rips.unmapPoint e he q hq, ?_⟩ + apply OAI.CoarseAssembly.Rips.Point.ext + exact Finsupp.embDomain_comapDomain hq + local_proof) e he] + apply isOpen_iff_mem_nhds.mpr + intro q hq + obtain ⟨y, hy⟩ := (( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (p : OAI.CoarseAssembly.Rips.Point X r) : ∃ x, 0 < p.weight x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open scoped BigOperators in + open Topology in + by + classical + by_contra! h + have hz : p.weight = 0 := by + ext x + exact le_antisymm (h x) (p.nonneg x) + have ht := p.total + simp [hz] at ht + local_proof) q) + obtain ⟨x, rfl⟩ := hq (Finsupp.mem_support_iff.mpr (ne_of_gt hy)) + have hnhds : {p : OAI.CoarseAssembly.Rips.Point Y r | 0 < p.weight (e x)} ∈ 𝓝 q := + (isOpen_lt continuous_const (OAI.CoarseAssembly.Rips.coordinate_continuous (e x))).mem_nhds hy + apply Filter.mem_of_superset hnhds + intro p hp y hy + by_contra hnot + exact (not_le_of_gt (hsep x y hnot)) + (p.diameter (e x) (Finsupp.mem_support_iff.mpr (ne_of_gt hp)) y hy) + have OAI.CoarseAssembly.Rips.mapPoint_continuous {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Continuous (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + classical + apply continuous_induced_rng.mpr + apply continuous_pi + intro y + change Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y) + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simpa only [OAI.CoarseAssembly.Rips.coordinates, OAI.CoarseAssembly.Rips.mapPoint, Finsupp.embDomain_apply_self] using + OAI.CoarseAssembly.Rips.coordinate_continuous (r := r) x + · have hz : (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y) = fun _ => 0 := by + funext p + exact Finsupp.embDomain_of_notMem_range e p.weight y hy + rw [hz] + exact continuous_const + have OAI.CoarseAssembly.Rips.mapPoint_injective {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Function.Injective (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + intro p q h + apply OAI.CoarseAssembly.Rips.Point.ext + apply Finsupp.ext + intro x + have hx := congrArg (fun p : OAI.CoarseAssembly.Rips.Point Y r => p.weight (e x)) h + simpa only [( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) : + (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + Finsupp.embDomain_apply_self e p.weight x + local_proof)] using hx + have OAI.CoarseAssembly.Rips.mapPoint_closedEmbedding {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} [inst_local_5 : Fintype X] [Fintype X] (e : X ↪ Y) (he) : + Topology.IsClosedEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + (OAI.CoarseAssembly.Rips.mapPoint_continuous e he).isClosedEmbedding (OAI.CoarseAssembly.Rips.mapPoint_injective e he) + have OAI.CoarseAssembly.separatedComponent_isometry {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) : + letI := OAI.CoarseAssembly.separatedMetric o + Isometry (OAI.CoarseAssembly.separatedComponent (V := V) j) := + open OAI OAI.CoarseAssembly in + open Topology Rips in + by + let := OAI.CoarseAssembly.separatedMetric o + apply Isometry.of_dist_eq + intro x y + exact ( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := + open OAI OAI.CoarseAssembly in + dite_eq_left rfl + local_proof) o j x y + have OAI.CoarseAssembly.separatedComponent_separation {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) (r : ℝ) (hj : r < j) : + letI := OAI.CoarseAssembly.separatedMetric o + ∀ x y, y ∉ Set.range (OAI.CoarseAssembly.separatedComponent (V := V) j) → + r < dist (OAI.CoarseAssembly.separatedComponent j x) y := + open OAI OAI.CoarseAssembly in + open Topology Rips in + by + let := OAI.CoarseAssembly.separatedMetric o + rintro x ⟨k, y⟩ hy + have hjk : j ≠ k := by + rintro rfl + exact hy ⟨y, rfl⟩ + change r < OAI.CoarseAssembly.separatedDist o ⟨j, x⟩ ⟨k, y⟩ + rw [( + let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := + open OAI OAI.CoarseAssembly in + dite_eq_right h + local_proof) o hjk] + have hk : (0 : ℝ) ≤ k := Nat.cast_nonneg k + linarith [dist_nonneg (x := x) (y := o j), dist_nonneg (x := o k) (y := y)] + have OAI.CoarseAssembly.lateRipsComponent_openEmbedding {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] [∀ j, Fintype (V j)] + (o : ∀ j, V j) (j : ℕ) (r : ℝ) (hj : r < j) : + letI := OAI.CoarseAssembly.separatedMetric o + Topology.IsOpenEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) (OAI.CoarseAssembly.separatedComponent (V := V) j) + (fun x y => ((OAI.CoarseAssembly.separatedComponent_isometry o j).dist_eq x y).le)) := + open OAI OAI.CoarseAssembly in + open Topology Rips in + by + let := OAI.CoarseAssembly.separatedMetric o + exact + { toIsEmbedding := (OAI.CoarseAssembly.Rips.mapPoint_closedEmbedding _ _).isEmbedding + isOpen_range := OAI.CoarseAssembly.Rips.mapPoint_range_open _ (OAI.CoarseAssembly.separatedComponent_isometry o j) + (OAI.CoarseAssembly.separatedComponent_separation o j r hj) } + have OAI.CoarseAssembly.separatedRipsEmbedding_open {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] (o : ∀ j, V j) (r : ℝ) (j : ℕ) (hj : r < j) : + letI := OAI.CoarseAssembly.separatedMetric o + Topology.IsOpenEmbedding (OAI.CoarseAssembly.separatedRipsEmbedding o r j) := + open OAI OAI.CoarseAssembly in + open Topology Rips Analytic in + OAI.CoarseAssembly.lateRipsComponent_openEmbedding o j r hj + let := OAI.CoarseAssembly.separatedMetric o + exact if hi : r < i then + (OAI.CoarseAssembly.Analytic.zeroExtensionHom (OAI.CoarseAssembly.separatedRipsEmbedding o r i) (OAI.CoarseAssembly.separatedRipsEmbedding_open o r i hi)).comp + OAI.CoarseAssembly.Analytic.compactFunctionLift + else 0 + +def ripsPointCharacter (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) (i : ℕ) : + C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ := + ContinuousMap.evalStarAlgHom ℂ ℂ (vertex (r := r) (o i) hr) + +def separatedRipsIndex (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + LocallyFiniteK1 (Point (Sigma Q) r) →+ + OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := + analyticFamilyIndex o hr (ripsPointCharacter o r hr) (lateRipsFunctionHom o r) + +end CoarseAssembly.Rips + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +attribute [-instance] T5Space.toT1Space T4Space.toT1Space + TopologicalSpace.PseudoMetrizableSpace.toMetrizableSpace + TopologicalSpace.metrizableSpace_of_t3_secondCountable + TopologicalSpace.IsCompletelyMetrizableSpace.instMetrizableSpace + + +end CoarseAssembly.Analytic + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +attribute [-instance] IsUniformAddGroup.isTopologicalAddGroup + IsLeftUniformAddGroup.toIsTopologicalAddGroup + IsRightUniformAddGroup.toIsTopologicalAddGroup + +attribute [-instance] TopologicalSpace.PseudoMetrizableSpace.toMetrizableSpace + TopologicalSpace.metrizableSpace_of_t3_secondCountable + TopologicalSpace.IsCompletelyMetrizableSpace.instMetrizableSpace + + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +attribute [-instance] IsUniformAddGroup.isTopologicalAddGroup + IsLeftUniformAddGroup.toIsTopologicalAddGroup + IsRightUniformAddGroup.toIsTopologicalAddGroup + + +end CoarseAssembly.Analytic + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u v + +structure CoarseningMorphism (C D : Coarsening.{u}) where + atScale : ∀ r, CocompactMap (C.space r) (D.space r) + compatible : ∀ r s h, + (atScale s).comp (C.inclusion r s h) = (D.inclusion r s h).comp (atScale r) + + +structure CompatibleIndexFamily (C : Coarsening.{u}) (A : Type v) + [NonUnitalCStarAlgebra A] where + atScale : ∀ r, LocallyFiniteK1 (C.space r) →+ OperatorKTheory.K1 A + compatible : ∀ r s h a, atScale s (C.map r s h a) = atScale r a + +namespace CompatibleIndexFamily + +variable {C D : Coarsening.{u}} {A B : Type v} + +variable [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B] + +def assembly (I : CompatibleIndexFamily C A) : C.Homology →+ OperatorKTheory.K1 A := + AddCommGroup.DirectLimit.lift _ _ _ I.atScale I.compatible + +end CompatibleIndexFamily + +end CoarseAssembly.Analytic + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + + +def separatedIndexFamily (o : ∀ i, Q i) : + letI := separatedMetric o + CompatibleIndexFamily (coarsening (Sigma Q)) + (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := by + let := separatedMetric o + classical + let f := fun n : ℕ => separatedRipsIndex o n (Nat.cast_nonneg n) + exact if h : ∀ r s h a, + f s ((coarsening (Sigma Q)).map r s h a) = f r a then + { atScale := f, compatible := h } + else + { atScale := fun _ => 0, compatible := by intros; rfl } + +end CoarseAssembly.Rips + +end +end + +section + +noncomputable section + +namespace CoarseAssembly.Analytic.CompatibleIndexFamily + +universe u v + +variable {C D : Coarsening.{u}} {A B : Type v} + [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B] + + +def transport (I : OAI.CoarseAssembly.Analytic.CompatibleIndexFamily C A) (f : OAI.CoarseAssembly.Analytic.CoarseningMorphism D C) + (φ : A →⋆ₙₐ[ℂ] B) : OAI.CoarseAssembly.Analytic.CompatibleIndexFamily D B := by + classical + have OAI.CoarseAssembly.Analytic.pushforward_comp {X : Type _} {Y : Type _} {Z : Type _} [inst_local_3 : TopologicalSpace X] [inst_local_4 : TopologicalSpace Y] [inst_local_5 : TopologicalSpace Z] (f : CocompactMap X Y) (g : CocompactMap Y Z) : + OAI.CoarseAssembly.Analytic.pushforward (g.comp f) = (OAI.CoarseAssembly.Analytic.pushforward g).comp (OAI.CoarseAssembly.Analytic.pushforward f) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open scoped ZeroAtInfty in + by + rw [OAI.CoarseAssembly.Analytic.pushforward, ( + let local_proof {X : Type _} {Y : Type _} {Z : Type _} [inst_local_3 : TopologicalSpace X] [inst_local_4 : TopologicalSpace Y] [inst_local_5 : TopologicalSpace Z] (f : CocompactMap X Y) (g : CocompactMap Y Z) : + OAI.CoarseAssembly.Analytic.pullback (g.comp f) = (OAI.CoarseAssembly.Analytic.pullback f).comp (OAI.CoarseAssembly.Analytic.pullback g) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + open scoped ZeroAtInfty in + by + ext a x + rfl + local_proof), ( + let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} {C : Type _} [inst_local_4 : NonUnitalCStarAlgebra B] [inst_local_5 : NonUnitalCStarAlgebra C] (φ : B →⋆ₙₐ[ℂ] A) (ψ : C →⋆ₙₐ[ℂ] B) : + OAI.CoarseAssembly.Analytic.precomp (φ.comp ψ) = (OAI.CoarseAssembly.Analytic.precomp ψ).comp (OAI.CoarseAssembly.Analytic.precomp φ) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in + by + apply QuotientAddGroup.addMonoidHom_ext + apply FreeAbelianGroup.lift_ext + intro c + rfl + local_proof)] + rfl + have OAI.CoarseAssembly.Analytic.CoarseningMorphism.pushforward_compatible {C : OAI.CoarseAssembly.Analytic.Coarsening} {D : OAI.CoarseAssembly.Analytic.Coarsening} (f : OAI.CoarseAssembly.Analytic.CoarseningMorphism C D) (r s : ℕ) (h : r ≤ s) : + (OAI.CoarseAssembly.Analytic.pushforward (f.atScale s)).comp (C.map r s h) = + (D.map r s h).comp (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic OAI.CoarseAssembly.Analytic.CoarseningMorphism in + by + change (OAI.CoarseAssembly.Analytic.pushforward (f.atScale s)).comp (OAI.CoarseAssembly.Analytic.pushforward (C.inclusion r s h)) = + (OAI.CoarseAssembly.Analytic.pushforward (D.inclusion r s h)).comp (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r)) + rw [← OAI.CoarseAssembly.Analytic.pushforward_comp, ← OAI.CoarseAssembly.Analytic.pushforward_comp, f.compatible] + exact { + atScale r := (OAI.CoarseAssembly.OperatorKTheory.map φ).comp ((I.atScale r).comp (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r))) + compatible r s hrs a := by + have hf := DFunLike.congr_fun ((OAI.CoarseAssembly.Analytic.CoarseningMorphism.pushforward_compatible f r s hrs)) a + change OAI.CoarseAssembly.Analytic.pushforward (f.atScale s) (D.map r s hrs a) = + C.map r s hrs (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r) a) at hf + change OAI.CoarseAssembly.OperatorKTheory.map φ (I.atScale s (OAI.CoarseAssembly.Analytic.pushforward (f.atScale s) (D.map r s hrs a))) = _ + rw [hf, I.compatible] + rfl + } + +end CoarseAssembly.Analytic.CompatibleIndexFamily + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +universe u + +variable {X Y : Type u} [PseudoMetricSpace X] [PseudoMetricSpace Y] {r : ℝ} + +def embeddingMap (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) (r : ℝ) : + CocompactMap (OAI.CoarseAssembly.Rips.Point X r) (OAI.CoarseAssembly.Rips.Point Y r) := by + classical + have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) : + Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + (continuous_apply x).comp ( + let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + continuous_induced_dom + local_proof) + have OAI.CoarseAssembly.Rips.mapPoint_continuous {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Continuous (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + classical + apply continuous_induced_rng.mpr + apply continuous_pi + intro y + change Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y) + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simpa only [OAI.CoarseAssembly.Rips.coordinates, OAI.CoarseAssembly.Rips.mapPoint, Finsupp.embDomain_apply_self] using + OAI.CoarseAssembly.Rips.coordinate_continuous (r := r) x + · have hz : (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y) = fun _ => 0 := by + funext p + exact Finsupp.embDomain_of_notMem_range e p.weight y hy + rw [hz] + exact continuous_const + have OAI.CoarseAssembly.Rips.mapPoint_injective {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Function.Injective (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + intro p q h + apply OAI.CoarseAssembly.Rips.Point.ext + apply Finsupp.ext + intro x + have hx := congrArg (fun p : OAI.CoarseAssembly.Rips.Point Y r => p.weight (e x)) h + simpa only [( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) : + (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + Finsupp.embDomain_apply_self e p.weight x + local_proof)] using hx + have OAI.CoarseAssembly.Rips.mapPoint_embedding {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + IsEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + refine ⟨IsInducing.of_comp (OAI.CoarseAssembly.Rips.mapPoint_continuous e he) + (show Continuous (fun p : OAI.CoarseAssembly.Rips.Point Y r => fun x : X => p.weight (e x)) from + continuous_pi (fun x => OAI.CoarseAssembly.Rips.coordinate_continuous (e x))) ?_, OAI.CoarseAssembly.Rips.mapPoint_injective e he⟩ + have hcomp : (fun p : OAI.CoarseAssembly.Rips.Point Y r => fun x : X => p.weight (e x)) ∘ OAI.CoarseAssembly.Rips.mapPoint e he = + OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r) := by + funext p x + exact ( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) : + (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + Finsupp.embDomain_apply_self e p.weight x + local_proof) e he p x + rw [hcomp] + exact ⟨rfl⟩ + have OAI.CoarseAssembly.Rips.range_mapPoint {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + Set.range (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) = + {q : OAI.CoarseAssembly.Rips.Point Y r | (∀ y, y ∉ Set.range e → q.weight y = 0) ∧ + ∀ x z, r < dist x z → q.weight (e x) = 0 ∨ q.weight (e z) = 0} := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + classical + ext q + constructor + · rintro ⟨p, rfl⟩ + refine ⟨fun y hy => Finsupp.embDomain_of_notMem_range e p.weight y hy, ?_⟩ + intro x z hxz + simp only [( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) : + (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + Finsupp.embDomain_apply_self e p.weight x + local_proof)] + by_cases hx : p.weight x = 0 + · exact Or.inl hx + by_cases hz : p.weight z = 0 + · exact Or.inr hz + exact False.elim ((not_le_of_gt hxz) + (p.diameter x (Finsupp.mem_support_iff.mpr hx) z (Finsupp.mem_support_iff.mpr hz))) + · rintro ⟨hs, hd⟩ + have hsupport : ↑q.weight.support ⊆ Set.range e := by + intro y hy + by_contra hn + exact Finsupp.mem_support_iff.mp hy (hs y hn) + let p : OAI.CoarseAssembly.Rips.Point X r := + { weight := q.weight.comapDomain e e.injective.injOn + nonneg x := q.nonneg (e x) + total := by + have hm := Finsupp.embDomain_comapDomain (f := e) hsupport + have ht := congrArg (fun f : Y →₀ ℝ => f.sum (fun _ t => t)) hm + simpa only [Finsupp.sum_embDomain, q.total] using ht + diameter := by + intro x hx z hz + by_contra hxz + rcases hd x z (lt_of_not_ge hxz) with hx' | hz' + · exact Finsupp.mem_support_iff.mp hx hx' + · exact Finsupp.mem_support_iff.mp hz hz' } + refine ⟨p, ?_⟩ + apply OAI.CoarseAssembly.Rips.Point.ext + exact Finsupp.embDomain_comapDomain (f := e) hsupport + have OAI.CoarseAssembly.Rips.mapPoint_properEmbedding {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + Topology.IsClosedEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + refine ⟨OAI.CoarseAssembly.Rips.mapPoint_embedding e he, ?_⟩ + rw [OAI.CoarseAssembly.Rips.range_mapPoint e he] + have hs : IsClosed {q : OAI.CoarseAssembly.Rips.Point Y r | ∀ y, y ∉ Set.range e → q.weight y = 0} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun y => isClosed_iInter fun _ => + isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous y) continuous_const + have hd : IsClosed {q : OAI.CoarseAssembly.Rips.Point Y r | ∀ x z, r < dist x z → + q.weight (e x) = 0 ∨ q.weight (e z) = 0} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun x => isClosed_iInter fun z => isClosed_iInter fun _ => + (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous (e x)) continuous_const).union + (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous (e z)) continuous_const) + exact hs.inter hd + exact { + toFun := OAI.CoarseAssembly.Rips.mapPoint e he + continuous_toFun := OAI.CoarseAssembly.Rips.mapPoint_continuous e he + cocompact_tendsto' := (OAI.CoarseAssembly.Rips.mapPoint_properEmbedding e he).tendsto_cocompact + } + +def embeddingCoarsening (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + OAI.CoarseAssembly.Analytic.CoarseningMorphism (OAI.CoarseAssembly.Rips.coarsening X) (OAI.CoarseAssembly.Rips.coarsening Y) := by + classical + + exact { + atScale r := OAI.CoarseAssembly.Rips.embeddingMap e he r + compatible r s hrs := by + apply CocompactMap.ext + intro p + exact (( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} {s : ℝ} (hrs : r ≤ s) (e : X ↪ Y) (he) + (p : OAI.CoarseAssembly.Rips.Point X r) : OAI.CoarseAssembly.Rips.coarsen hrs (OAI.CoarseAssembly.Rips.mapPoint e he p) = OAI.CoarseAssembly.Rips.mapPoint e he (OAI.CoarseAssembly.Rips.coarsen hrs p) := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Topology in + by + apply OAI.CoarseAssembly.Rips.Point.ext + rfl + local_proof) (by exact_mod_cast hrs : (r : ℝ) ≤ (s : ℝ)) e he p).symm + } + +end CoarseAssembly.Rips + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence Analytic DiscreteRoe + + +local instance boundaryAssemblyMetric1 : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnit + +def TotalRoe : Type := algebra (X := VertexUnion) (H := AmpleSpace) + +instance : NonUnitalCStarAlgebra OAI.CoarseAssembly.TotalRoe := by + classical + + exact inferInstanceAs (NonUnitalCStarAlgebra (OAI.CoarseAssembly.DiscreteRoe.algebra (X := OAI.CoarseAssembly.VertexUnion) (H := OAI.CoarseAssembly.AmpleSpace))) + +end CoarseAssembly + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +abbrev FiberedUnion := (j : ℕ) × FiberVertex j + +variable (S : Finset ArithmeticGroup) + (boundary : ∀ j, (fiberedGraph S chosenHolonomyUnit j).Walk + (fiberBoundaryBase j) (fiberBoundaryBase j)) + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance boundaryLoopMetric7 : MetricSpace FiberedUnion := componentUnionMetric elementaryMoves chosenHolonomyUnit + +local instance boundaryLoopMetric8 : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnit + +def totalToFiber : VertexUnion ≃ FiberedUnion := + Equiv.sigmaAssoc (fun j u => Quotient (discDepth j u)) + +def totalToFiberCoarsening : OAI.CoarseAssembly.Analytic.CoarseningMorphism (OAI.CoarseAssembly.Rips.coarsening OAI.CoarseAssembly.VertexUnion) (OAI.CoarseAssembly.Rips.coarsening OAI.CoarseAssembly.FiberedUnion) := by + classical + + exact OAI.CoarseAssembly.Rips.embeddingCoarsening OAI.CoarseAssembly.totalToFiber.toEmbedding (fun x y => (( + let local_proof (x y : OAI.CoarseAssembly.VertexUnion) : dist (OAI.CoarseAssembly.totalToFiber x) (OAI.CoarseAssembly.totalToFiber y) = dist x y := + open OAI OAI.CoarseAssembly in + open Congruence Rips Analytic in + rfl + local_proof) x y).le) + +end CoarseAssembly + +end +end + + +section + +noncomputable section + +namespace CoarseAssembly + +open Analytic DiscreteRoe Rips Congruence + + +local instance constructedFiberComponentEq (i : ℕ) : DecidableEq (FiberVertex i) := Classical.decEq _ + +local instance constructedFiberComponentMetric (i : ℕ) : MetricSpace (FiberVertex i) := + componentMetric elementaryMoves chosenHolonomyUnit i + +local instance constructedTotalMetric : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +def fiberReindexRoeHom : + (letI := OAI.CoarseAssembly.separatedMetric OAI.CoarseAssembly.fiberBoundaryBase; + OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma OAI.CoarseAssembly.FiberVertex) (H := OAI.CoarseAssembly.AmpleSpace)) →⋆ₙₐ[ℂ] OAI.CoarseAssembly.TotalRoe := by + classical + + let := OAI.CoarseAssembly.separatedMetric OAI.CoarseAssembly.fiberBoundaryBase + exact OAI.CoarseAssembly.DiscreteRoe.inclusionHom (X := Sigma OAI.CoarseAssembly.FiberVertex) (Y := OAI.CoarseAssembly.VertexUnion) (H := OAI.CoarseAssembly.AmpleSpace) OAI.CoarseAssembly.totalToFiber.symm.toEmbedding + (fun x y => ((( + let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] (e : X ≃ Y) (he : Isometry e) : Isometry e.symm := + open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in + open Analytic in + by + apply Isometry.of_dist_eq + intro x y + simpa only [Equiv.apply_symm_apply] using (he.dist_eq (e.symm x) (e.symm y)).symm + local_proof) OAI.CoarseAssembly.totalToFiber (Isometry.of_dist_eq ( + let local_proof (x y : OAI.CoarseAssembly.VertexUnion) : dist (OAI.CoarseAssembly.totalToFiber x) (OAI.CoarseAssembly.totalToFiber y) = dist x y := + open OAI OAI.CoarseAssembly in + open Congruence Rips Analytic in + rfl + local_proof))).dist_eq x y).le) + +def constructedTotalIndex : CompatibleIndexFamily (coarsening VertexUnion) TotalRoe := + (separatedIndexFamily (Q := FiberVertex) fiberBoundaryBase).transport totalToFiberCoarsening fiberReindexRoeHom + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance constructedConclusionMetric : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +def constructedCoarseAssembly : KX1 VertexUnion →+ OperatorKTheory.K1 TotalRoe := + constructedTotalIndex.assembly + +end CoarseAssembly + +end +end + +section + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance unconditionalConclusionMetric : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +end CoarseAssembly + +end +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DegenerateCutDown.lean b/lean/OAI/Topology/CoarseAssembly/DegenerateCutDown.lean new file mode 100644 index 0000000000000000000000000000000000000000..01c50850442988827965b34ba8e3e30eef1ffad4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DegenerateCutDown.lean @@ -0,0 +1,112 @@ +import OAI.Topology.CoarseAssembly.RawCycleIndex + +namespace OAI + +/-! # Degenerate cycles have zero explicit Toeplitz index -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem representedCorrection_annihilates (c : OddCycle A) (hd : c.Degenerate) : + (∀ a, representedCorrection c * c.representation a = 0) ∧ + (∀ a, c.representation a * representedCorrection c = 0) ∧ + (∀ a, star (representedCorrection c) * c.representation a = 0) := by + let P := c.representation 1 + let K := representedCorrection c + have hr : K * P = 0 := by + change (symmetricCutDown P c.operator - c.operator) * P = 0 + rw [symmetricCutDown_sub_mul P c.operator (representation_unit_selfAdjoint c) + (representation_unit_sq c), hd.1 1, hd.2.2 1] + simp + have hl : P * K = 0 := by + change P * (symmetricCutDown P c.operator - c.operator) = 0 + rw [mul_symmetricCutDown_sub P c.operator (representation_unit_selfAdjoint c) + (representation_unit_sq c), hd.1 1, hd.2.2 1] + simp + have hs : star K * P = 0 := by + have he : star K * P = K * P - (star c.operator - c.operator) * P := by + dsimp only [K, representedCorrection] + rw [star_sub, (symmetricCutDown_selfAdjoint P c.operator (representation_unit_selfAdjoint c)).star_eq] + noncomm_ring + rw [he, hr, hd.2.2 1, sub_self] + have hp (a : A) : P * c.representation a = c.representation a := by + change c.representation 1 * c.representation a = c.representation a + rw [← map_mul, one_mul] + have hpr (a : A) : c.representation a * P = c.representation a := by + change c.representation a * c.representation 1 = c.representation a + rw [← map_mul, mul_one] + refine ⟨?_, ?_, ?_⟩ + · intro a + rw [← hp a, ← mul_assoc, hr, zero_mul] + · intro a + rw [← hpr a, mul_assoc, hl, mul_zero] + · intro a + rw [← hp a, ← mul_assoc, hs, zero_mul] + +theorem cutDown_degenerate (c : OddCycle A) (hd : c.Degenerate) : c.cutDown.Degenerate := by + obtain ⟨hr, hl, hs⟩ := representedCorrection_annihilates c hd + let K := representedCorrection c + change (∀ a, (c.operator + K) * c.representation a - c.representation a * (c.operator + K) = 0) ∧ + (∀ a, ((c.operator + K) * (c.operator + K) - 1) * c.representation a = 0) ∧ + (∀ a, (star (c.operator + K) - (c.operator + K)) * c.representation a = 0) + refine ⟨?_, ?_, ?_⟩ + · intro a + rw [add_mul, mul_add, hr a, hl a, add_zero, add_zero, hd.1 a] + · intro a + have he : ((c.operator + K) * (c.operator + K) - 1) * c.representation a = + (c.operator * c.operator - 1) * c.representation a + + c.operator * (K * c.representation a) + + K * (c.operator * c.representation a - c.representation a * c.operator) + + (K * c.representation a) * c.operator + K * (K * c.representation a) := by noncomm_ring + rw [he, hd.2.1 a, hr a, hd.1 a, mul_zero, mul_zero, zero_mul] + simp + · intro a + have he : (star (c.operator + K) - (c.operator + K)) * c.representation a = + (star c.operator - c.operator) * c.representation a + + star K * c.representation a - K * c.representation a := by + rw [star_add] + noncomm_ring + rw [he, hd.2.2 a, hs a, hr a, add_zero, sub_self] + +theorem cutDown_degenerate_sq (c : OddCycle A) (hd : c.Degenerate) : + c.cutDown.operator * c.cutDown.operator = 1 := by + let d := c.cutDown + have hd' := cutDown_degenerate c hd + have hp := hd'.2.1 (1 : A) + have hQ := cutDown_complement c + have hq : (d.operator * d.operator - 1) * (1 - d.representation 1) = 0 := by + calc + _ = d.operator * (d.operator * (1 - d.representation 1)) - (1 - d.representation 1) := by noncomm_ring + _ = 0 := by rw [hQ, hQ, sub_self] + apply sub_eq_zero.mp + calc + d.operator * d.operator - 1 = (d.operator * d.operator - 1) * d.representation 1 + + (d.operator * d.operator - 1) * (1 - d.representation 1) := by noncomm_ring + _ = 0 := by rw [hp, hq, add_zero] + +theorem rawCycleToeplitz_eq_cutDown (c : OddCycle A) (u : A) : + rawCycleToeplitz c u = representedToeplitz c.cutDown u := by + change toeplitzCompression (positiveProjection (symmetricCutDown (c.representation 1) c.operator)) + (unitaryExtension c u) = toeplitzCompression + (positiveProjection (c.operator + representedCorrection c)) (unitaryExtension c u) + have he : c.operator + representedCorrection c = symmetricCutDown (c.representation 1) c.operator := by + unfold representedCorrection + abel + rw [he] + +theorem rawCycleIndex_degenerate (c : OddCycle A) (u : A) (hd : c.Degenerate) + (hul : star u * u = 1) (hur : u * star u = 1) : rawCycleIndex c u = 0 := by + have hi := representedIndex_degenerate c.cutDown u (cutDown_degenerate c hd) + (cutDown_selfAdjoint c) (cutDown_degenerate_sq c hd) hul hur + have he : rawCycleIndex c u = representedIndex c.cutDown u := + congrArg (fun T : End c.space => T.toLinearMap.index) (rawCycleToeplitz_eq_cutDown c u) + exact he.trans hi + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DegenerateRegularization.lean b/lean/OAI/Topology/CoarseAssembly/DegenerateRegularization.lean new file mode 100644 index 0000000000000000000000000000000000000000..de1a2358d930d1e5bea5dd8af8d9c631ccd8ce0e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DegenerateRegularization.lean @@ -0,0 +1,124 @@ +import OAI.Topology.CoarseAssembly.RegularizedCycle + +namespace OAI + +/-! # The explicit cut-down of a degenerate cycle remains degenerate -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] {c : OddCycle A} + +theorem OddCycle.Degenerate.cutDown_operator (hc : c.Degenerate) : + (show End c.space from c.cutDown.operator) = c.operator * c.representation 1 + (1 - c.representation 1) := by + let P := c.representation 1 + let F := c.operator + have hP : star P = P := (representation_unit_selfAdjoint c).star_eq + have hPP : P * P = P := representation_unit_sq c + have hFP : F * P = P * F := sub_eq_zero.mp (hc.1 1) + have hstar : star F * P = F * P := by + have hs := hc.2.2 1 + rw [sub_mul] at hs + exact sub_eq_zero.mp hs + have hcut : P * F * P = F * P := by rw [← hFP, mul_assoc, hPP] + have hcuts : star (P * F * P) = F * P := by + rw [star_mul, star_mul, hP, hstar, ← mul_assoc, hcut] + rw [c.cutDown_operator] + change (1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P) = F * P + (1 - P) + rw [hcuts, hcut] + module + +theorem OddCycle.Degenerate.cutDown_square (hc : c.Degenerate) : + c.cutDown.operator * c.cutDown.operator = 1 := by + let P := c.representation 1 + let F := c.operator + have hPP : P * P = P := representation_unit_sq c + have hFP : F * P = P * F := sub_eq_zero.mp (hc.1 1) + have hF2P : F * F * P = P := by + have hh := hc.2.1 1 + rw [sub_mul, one_mul] at hh + exact sub_eq_zero.mp hh + have hcut : P * F * P = F * P := by rw [← hFP, mul_assoc, hPP] + have hsq : (F * P) * (F * P) = P := by + calc + _ = F * (P * F) * P := by noncomm_ring + _ = F * (F * P) * P := by rw [← hFP] + _ = (F * F) * (P * P) := by noncomm_ring + _ = P := by rw [hPP, hF2P] + have hright : F * P * (1 - P) = 0 := by rw [mul_sub, mul_one, mul_assoc, hPP, sub_self] + have hleft : (1 - P) * (F * P) = 0 := by rw [sub_mul, one_mul, ← mul_assoc, hcut, sub_self] + let G : End c.space := c.cutDown.operator + have hG : G = F * P + (1 - P) := hc.cutDown_operator + change G * G = 1 + rw [hG] + rw [add_mul, mul_add, mul_add, hsq, hright, hleft] + noncomm_ring [hPP] + +theorem OddCycle.Degenerate.cutDown_commutator (hc : c.Degenerate) (a : A) : + (show End c.space from c.cutDown.operator) * c.representation a - + c.representation a * (show End c.space from c.cutDown.operator) = 0 := by + let P := c.representation 1 + let F := c.operator + let R := c.representation a + let G : End c.space := c.cutDown.operator + have hG : G = F * P + (1 - P) := hc.cutDown_operator + have hPR : P * R = R := by dsimp [P, R]; rw [← map_mul, one_mul] + have hRP : R * P = R := by dsimp [P, R]; rw [← map_mul, mul_one] + have hFR : F * R = R * F := sub_eq_zero.mp (hc.1 a) + have hleft : (F * P + (1 - P)) * R = F * R := by + rw [add_mul, mul_assoc, hPR, sub_mul, one_mul, hPR, sub_self, add_zero] + have hright : R * (F * P + (1 - P)) = F * R := by + rw [mul_add, ← mul_assoc, ← hFR, mul_assoc, hRP, mul_sub, mul_one, hRP, + sub_self, add_zero] + change G * R - R * G = 0 + rw [hG, hleft, hright, sub_self] + +theorem OddCycle.Degenerate.unitalSelfAdjoint (hc : c.Degenerate) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.unitalSelfAdjoint χ).Degenerate := by + let G : End c.space := c.cutDown.operator + let ρ : A →⋆ₙₐ[ℂ] End c.space := (c.unitalSelfAdjoint χ).representation + have hG : IsSelfAdjoint G := cutDown_selfAdjoint c + have hQ : G * (1 - c.representation 1) = 1 - c.representation 1 := cutDown_complement c + have hQ' : (1 - c.representation 1) * G = 1 - c.representation 1 := by + have hh := congrArg star hQ + simpa only [star_mul, star_sub, star_one, hG.star_eq, + (representation_unit_selfAdjoint c).star_eq] using hh + change (∀ a, G * ρ a - ρ a * G = 0) ∧ + (∀ a, (G * G - 1) * ρ a = 0) ∧ (∀ a, (star G - G) * ρ a = 0) + refine ⟨?_, ?_, ?_⟩ + · intro a + change G * (c.representation a + χ a • (1 - c.representation 1)) - + (c.representation a + χ a • (1 - c.representation 1)) * G = 0 + rw [mul_add, add_mul, mul_smul_comm, smul_mul_assoc, hQ, hQ', add_sub_add_right_eq_sub] + exact hc.cutDown_commutator a + · intro a + have hsq : G * G = 1 := hc.cutDown_square + rw [hsq, sub_self, zero_mul] + · intro a + rw [hG.star_eq, sub_self, zero_mul] + +theorem OddCycle.Degenerate.bounded (hc : c.Degenerate) + (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : + (c.bounded hπ hs).Degenerate := by + have hsq : c.operator * c.operator = 1 := by + have hh := hc.2.1 1 + rw [hπ, mul_one] at hh + exact sub_eq_zero.mp hh + change (∀ a, boundedTransform c.operator hs * c.representation a - + c.representation a * boundedTransform c.operator hs = 0) ∧ + (∀ a, (boundedTransform c.operator hs * boundedTransform c.operator hs - 1) * c.representation a = 0) ∧ + (∀ a, (star (boundedTransform c.operator hs) - boundedTransform c.operator hs) * c.representation a = 0) + rw [boundedTransform_eq_of_involution c.operator hs hsq] + exact hc + +theorem OddCycle.Degenerate.regularize (hc : c.Degenerate) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.regularize χ).Degenerate := + (hc.unitalSelfAdjoint χ).bounded (c.unitalSelfAdjoint_unital χ) + (c.unitalSelfAdjoint_selfAdjoint χ) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DiagonalApproximation.lean b/lean/OAI/Topology/CoarseAssembly/DiagonalApproximation.lean new file mode 100644 index 0000000000000000000000000000000000000000..cf0719a8aa7bd151d22533837f2aa14a3f0d7b53 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DiagonalApproximation.lean @@ -0,0 +1,67 @@ +import OAI.Topology.CoarseAssembly.RoeCompactRows +import Mathlib.Topology.Compactness.Compact + +namespace OAI + +/-! # Finite-support approximation of multiplication operators -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Filter +open scoped ZeroAtInfty Topology + +variable {X H : Type*} [DecidableEq X] [TopologicalSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +theorem diagonalApproximation_norm (f : C₀(X, ℂ)) (s : Finset X) + (ε : ℝ) (hε : 0 ≤ ε) (hs : ∀ x, x ∉ s → ‖f x‖ ≤ ε) : + ‖diagonalMultiplier (H := H) f - finiteDiagonal (H := H) f s‖ ≤ ε := by + apply ContinuousLinearMap.opNorm_le_bound _ hε + intro v + calc + _ ≤ ‖ε • lp.toNorm v‖ := by + apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0) + intro x + change ‖diagonalMultiplier f v x - finiteDiagonal f s v x‖ ≤ ‖ε * ‖v x‖‖ + rw [diagonalMultiplier_apply, finiteDiagonal_apply, + Real.norm_eq_abs, abs_of_nonneg (mul_nonneg hε (norm_nonneg _))] + by_cases hx : x ∈ s + · rw [ite_eq_left hx, sub_self, norm_zero] + positivity + · rw [ite_eq_right hx, sub_zero, norm_smul] + exact mul_le_mul_of_nonneg_right (hs x hx) (norm_nonneg _) + _ = ε * ‖v‖ := by + rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg hε, lp.norm_toNorm] + +variable [DiscreteTopology X] + +theorem finiteDiagonal_tendsto (f : C₀(X, ℂ)) : + Tendsto (fun s : Finset X => finiteDiagonal (H := H) f s) atTop + (𝓝 (diagonalMultiplier (H := H) f)) := by + apply (tendsto_iff_norm_sub_tendsto_zero (E := Operator X H) + (f := fun s : Finset X => finiteDiagonal (H := H) f s) + (b := diagonalMultiplier (H := H) f)).mpr + apply Metric.tendsto_nhds.mpr + intro ε hε + have hsmall : {x : X | dist (f x) 0 < ε / 2} ∈ cocompact X := + Metric.tendsto_nhds.mp (zero_at_infty f) (ε / 2) (by positivity) + obtain ⟨K, hK, hbound⟩ := mem_cocompact.mp hsmall + filter_upwards [eventually_ge_atTop hK.finite_of_discrete.toFinset] with s hs + simp only [dist_zero_right, norm_norm] + rw [norm_sub_rev (finiteDiagonal (H := H) f s) (diagonalMultiplier (H := H) f)] + apply (diagonalApproximation_norm f s (ε / 2) (by positivity) ?_).trans_lt (by linarith) + intro x hx + have hxK : x ∉ K := by + intro h + exact hx (hs (hK.finite_of_discrete.mem_toFinset.mpr h)) + have hb := hbound hxK + change dist (f x) 0 < ε / 2 at hb + exact (by simpa only [dist_zero_right] using hb.le) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DiagonalBoundaryCoordinates.lean b/lean/OAI/Topology/CoarseAssembly/DiagonalBoundaryCoordinates.lean new file mode 100644 index 0000000000000000000000000000000000000000..702ab8d15dd14dcf6fcb183e22c61cda568e3422 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DiagonalBoundaryCoordinates.lean @@ -0,0 +1,55 @@ +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary +import OAI.Topology.CoarseAssembly.CayleyIntertwining + +namespace OAI + +/-! # Coordinates of the whole-union rational boundary unitary -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {V : ℕ → Type*} [∀ i, DecidableEq (V i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def rowRestriction (i : ℕ) : Module (Sigma V) H →L[ℂ] Module (V i) H := + (lp.evalCLM ℂ (fun j => Module (V j) H) 2 i).comp + (flattenEquiv (Q := V) (H := H)).symm.toLinearIsometry.toContinuousLinearMap + +omit [∀ i, DecidableEq (V i)] [CompleteSpace H] in +@[simp] theorem rowRestriction_apply (i : ℕ) (v : Module (Sigma V) H) : + rowRestriction i v = rowVector v i := rfl + +omit [∀ i, DecidableEq (V i)] in +theorem row_rationalBoundaryUnitary (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (hself : ∀ i, IsSelfAdjoint (A i)) (v : Module (Sigma V) H) (i : ℕ) : + rowVector ((rationalBoundaryUnitary (diagonalFamily A C hC hA) + (diagonalFamily_selfAdjoint A C hC hA hself) : Operator (Sigma V) H) v) i = + (rationalBoundaryUnitary (A i) (hself i) : Operator (V i) H) (rowVector v i) := + rationalBoundaryUnitary_intertwines (rowRestriction i) _ _ _ _ + (fun w => rowVector_diagonalFamily A C hC hA w i) v + +variable [PseudoMetricSpace (Sigma V)] + +theorem row_multiplierBoundaryUnitary + (F : multiplierAlgebra (X := Sigma V) (H := H)) (hF : IsSelfAdjoint F) + (A : ∀ i, Operator (V i) H) (hself : ∀ i, IsSelfAdjoint (A i)) + (hrow : ∀ v i, rowVector ((F : Operator (Sigma V) H) v) i = A i (rowVector v i)) + (v : Module (Sigma V) H) (i : ℕ) : + rowVector ((multiplierBoundaryUnitary F hF : Operator (Sigma V) H) v) i = + (rationalBoundaryUnitary (A i) (hself i) : Operator (V i) H) (rowVector v i) := by + let φ := (multiplierAlgebra (X := Sigma V) (H := H)).subtype + have hm := map_rationalBoundaryUnitary φ F hF + change rowVector (φ (rationalBoundaryUnitary F hF) v) i = _ + rw [hm] + exact rationalBoundaryUnitary_intertwines (rowRestriction i) (F : Operator (Sigma V) H) + (A i) (hF.map φ) (hself i) (fun w => hrow w i) v + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DiagonalFamilyContinuity.lean b/lean/OAI/Topology/CoarseAssembly/DiagonalFamilyContinuity.lean new file mode 100644 index 0000000000000000000000000000000000000000..fceaff9a1f6b040fdb475a3cac798f19a861362b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DiagonalFamilyContinuity.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.DiagonalSpatialFamily + +namespace OAI + +/-! # Uniform component estimates give norm-continuous spatial families -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Filter Topology + +variable {V : ℕ → Type*} {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +theorem diagonalFamily_sub_eq (A B : ∀ i, Operator (V i) H) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (δ : ℝ) (hδ : 0 ≤ δ) (hAB : ∀ i, ‖A i - B i‖ ≤ δ) : + diagonalFamily A C hC hA - diagonalFamily B D hD hB = + diagonalFamily (fun i => A i - B i) δ hδ hAB := by + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext z + rcases z with ⟨i, x⟩ + simp only [sub_apply, lp.coeFn_sub, Pi.sub_apply, diagonalFamily_apply] + +/-- The bound does not depend on the number or sizes of the components. -/ +theorem diagonalFamily_sub_norm_le (A B : ∀ i, Operator (V i) H) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (δ : ℝ) (hδ : 0 ≤ δ) (hAB : ∀ i, ‖A i - B i‖ ≤ δ) : + ‖diagonalFamily A C hC hA - diagonalFamily B D hD hB‖ ≤ δ := by + rw [diagonalFamily_sub_eq A B C D hC hD hA hB δ hδ hAB] + exact diagonalFamily_norm_le _ _ _ _ + +theorem continuous_diagonalFamily {P : Type*} [TopologicalSpace P] + (A : P → ∀ i, Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ p i, ‖A p i‖ ≤ C) + (hcont : ∀ p ε, 0 < ε → ∀ᶠ q in 𝓝 p, ∀ i, ‖A q i - A p i‖ ≤ ε) : + Continuous (fun p => diagonalFamily (A p) C hC (hA p)) := by + rw [continuous_iff_continuousAt] + intro p + apply (Metric.continuousAt_iff' + (f := fun q : P => (diagonalFamily (A q) C hC (hA q) : Operator (Sigma V) H))).mpr + intro ε hε + filter_upwards [hcont p (ε / 2) (half_pos hε)] with q hq + rw [dist_eq_norm (diagonalFamily (A q) C hC (hA q)) + (diagonalFamily (A p) C hC (hA p))] + exact (diagonalFamily_sub_norm_le (A q) (A p) C C hC hC (hA q) (hA p) + (ε / 2) (le_of_lt (half_pos hε)) hq).trans_lt (half_lt_self hε) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DiagonalFamilyDefect.lean b/lean/OAI/Topology/CoarseAssembly/DiagonalFamilyDefect.lean new file mode 100644 index 0000000000000000000000000000000000000000..abb78c575117969c2cadae7c5e39d7220add547d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DiagonalFamilyDefect.lean @@ -0,0 +1,55 @@ +import OAI.Topology.CoarseAssembly.DiagonalSpatialFamily +import OAI.Topology.CoarseAssembly.FiniteCompactRoe + +namespace OAI + +/-! # Square defects of uniformly bounded component operators -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {V : ℕ → Type*} [∀ i, DecidableEq (V i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [∀ i, DecidableEq (V i)] in +theorem squareDefect_norm_le (A : Operator (V 0) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ‖A‖ ≤ C) : ‖A * A - 1‖ ≤ C * C + 1 := by + calc + ‖A * A - 1‖ ≤ ‖A * A‖ + ‖(1 : Operator (V 0) H)‖ := norm_sub_le _ _ + _ ≤ (‖A‖ * ‖A‖) + 1 := add_le_add (norm_mul_le _ _) ContinuousLinearMap.norm_id_le + _ ≤ C * C + 1 := by gcongr + +omit [∀ i, DecidableEq (V i)] in +theorem diagonalFamily_square_defect (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) : + diagonalFamily A C hC hA * diagonalFamily A C hC hA - 1 = + diagonalFamily (fun i => A i * A i - 1) (C * C + 1) (by positivity) + (fun i => squareDefect_norm_le (V := fun _ => V i) (A i) C hC (hA i)) := by + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext z + rcases z with ⟨i, x⟩ + simp only [sub_apply, mul_apply_eq_comp, one_apply_eq_self, lp.coeFn_sub, Pi.sub_apply, + diagonalFamily_apply, rowVector_diagonalFamily] + rfl + +theorem diagonalFamily_square_compactEntries (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) : + CompactEntries (diagonalFamily A C hC hA * diagonalFamily A C hC hA - 1) := by + rw [diagonalFamily_square_defect] + rintro ⟨i, x⟩ ⟨j, y⟩ + by_cases hij : i = j + · subst j + rw [entry_diagonalFamily_same] + exact compact_entries_of_compact (hsq i) x y + · rw [entry_diagonalFamily_ne _ _ _ _ hij] + exact isCompactOperator_zero + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DiagonalMultiplier.lean b/lean/OAI/Topology/CoarseAssembly/DiagonalMultiplier.lean new file mode 100644 index 0000000000000000000000000000000000000000..2219f33ed4ffc706a3c44186730fb6b4e54ddec0 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DiagonalMultiplier.lean @@ -0,0 +1,69 @@ +import OAI.Topology.CoarseAssembly.BlockOperators +import OAI.Topology.CoarseAssembly.RoeRows +import Mathlib.Analysis.CStarAlgebra.ContinuousMap + +namespace OAI + +/-! # The concrete multiplication representation on a discrete ample module -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open scoped ZeroAtInfty + +variable {X H : Type*} [TopologicalSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +theorem scalarBlock_norm_le (z : ℂ) : ‖z • (1 : H →L[ℂ] H)‖ ≤ ‖z‖ := by + exact (norm_smul_le z (1 : H →L[ℂ] H)).trans + (mul_le_of_le_one_right (norm_nonneg z) ContinuousLinearMap.norm_id_le) + +def diagonalMultiplier (f : C₀(X, ℂ)) : Operator X H := + blockOperator (fun x => f x • (1 : H →L[ℂ] H)) ‖f‖ (norm_nonneg f) + (fun x => (scalarBlock_norm_le (f x)).trans (f.toBCF.norm_coe_le_norm x)) + +@[simp] theorem diagonalMultiplier_apply (f : C₀(X, ℂ)) (v : Module X H) (x : X) : + diagonalMultiplier f v x = f x • v x := rfl + +theorem diagonalMultiplier_norm (f : C₀(X, ℂ)) : + ‖diagonalMultiplier (H := H) f‖ ≤ ‖f‖ := blockOperator_norm_le _ _ _ _ + +theorem diagonalMultiplier_sub (f g : C₀(X, ℂ)) : + diagonalMultiplier (H := H) (f - g) = diagonalMultiplier f - diagonalMultiplier g := by + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext x + exact sub_smul _ _ _ + +variable [DecidableEq X] + +def finiteDiagonal (f : X → ℂ) (s : Finset X) : Operator X H := + ∑ x ∈ s, f x • ((insert x).comp (coordinate x)) + +omit [TopologicalSpace X] in +@[simp] theorem finiteDiagonal_apply (f : X → ℂ) (s : Finset X) + (v : Module X H) (x : X) : + finiteDiagonal f s v x = if x ∈ s then f x • v x else 0 := by + classical + simp only [finiteDiagonal, sum_apply, smul_apply, + ContinuousLinearMap.comp_apply, insert_apply, coordinate_apply, + lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, Pi.smul_apply, lp.single_apply] + by_cases hx : x ∈ s + · rw [Finset.sum_eq_single x] + · simp [hx] + · intro y _ hy + simp [Pi.single_eq_of_ne (Ne.symm hy)] + · exact fun h => (h hx).elim + · rw [ite_eq_right hx] + apply Finset.sum_eq_zero + intro y hy + have hxy : x ≠ y := fun h => hx (h ▸ hy) + simp [Pi.single_eq_of_ne hxy] + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DiagonalSpatialFamily.lean b/lean/OAI/Topology/CoarseAssembly/DiagonalSpatialFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..f1237dd879c9e9e2cca91ea7b022a02826facad3 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DiagonalSpatialFamily.lean @@ -0,0 +1,90 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ProjectionBlocks +import OAI.Topology.CoarseAssembly.RoeRows +import OAI.Topology.CoarseAssembly.SeparatedUnion + +namespace OAI + +/-! # Uniform diagonal families on the actual separated vertex union -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {V : ℕ → Type*} [∀ i, DecidableEq (V i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [∀ i, DecidableEq (V i)] [CompleteSpace H] in +@[simp] theorem diagonalFamily_apply (A : ∀ i, Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : Module (Sigma V) H) (i : ℕ) (x : V i) : + diagonalFamily A C hC hA v ⟨i, x⟩ = A i (rowVector v i) x := rfl + +omit [∀ i, DecidableEq (V i)] [CompleteSpace H] in +theorem diagonalFamily_norm_le (A : ∀ i, Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) : ‖diagonalFamily A C hC hA‖ ≤ C := + (flattenOperator_norm_le _).trans (blockOperator_norm_le _ _ _ _) + +omit [∀ i, DecidableEq (V i)] [CompleteSpace H] in +theorem rowVector_diagonalFamily (A : ∀ i, Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) (v : Module (Sigma V) H) (i : ℕ) : + rowVector (diagonalFamily A C hC hA v) i = A i (rowVector v i) := by + apply lp.ext + rfl + +omit [CompleteSpace H] in +@[simp] theorem entry_diagonalFamily_same (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (i : ℕ) (x y : V i) : + entry (diagonalFamily A C hC hA) ⟨i, x⟩ ⟨i, y⟩ = entry (A i) x y := by + ext v + simp only [entry_apply, diagonalFamily_apply, rowVector_single_same] + +omit [CompleteSpace H] in +theorem entry_diagonalFamily_ne (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) {i j : ℕ} (hij : i ≠ j) + (x : V i) (y : V j) : + entry (diagonalFamily A C hC hA) ⟨i, x⟩ ⟨j, y⟩ = 0 := by + ext v + simp only [entry_apply, diagonalFamily_apply, rowVector_single_ne hij, map_zero, + lp.coeFn_zero, Pi.zero_apply, zero_apply] + +omit [∀ i, DecidableEq (V i)] in +theorem diagonalFamily_selfAdjoint (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (hself : ∀ i, IsSelfAdjoint (A i)) : + IsSelfAdjoint (diagonalFamily A C hC hA) := by + have hb : IsSelfAdjoint (blockOperator A C hC hA) := by + change (blockOperator A C hC hA).adjoint = _ + rw [blockOperator_adjoint] + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext i + change (A i).adjoint (v i) = A i (v i) + have hi : (A i).adjoint = A i := (hself i).star_eq + exact DFunLike.congr_fun hi (v i) + rw [diagonalFamily, flattenOperator_eq_conjugation] + exact hb.map (operatorConjugationHom (flattenEquiv (Q := V) (H := H)).toLinearIsometry) + +variable [∀ i, MetricSpace (V i)] (o : ∀ i, V i) + + +omit [CompleteSpace H] in +theorem diagonalFamily_propagation (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (r : ℝ) + (hp : ∀ i, PropagationLE r (A i)) : + letI := separatedMetric o + PropagationLE r (diagonalFamily A C hC hA) := by + let := separatedMetric o + rintro ⟨i, x⟩ ⟨j, y⟩ hxy + by_cases hij : i = j + · subst j + rw [entry_diagonalFamily_same] + apply hp i x y + simpa only [show dist (⟨i, x⟩ : Sigma V) ⟨i, y⟩ = dist x y from + separatedDist_same o i x y] using hxy + · exact entry_diagonalFamily_ne A C hC hA hij x y + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DirectSumIndex.lean b/lean/OAI/Topology/CoarseAssembly/DirectSumIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..5acb03855fa82bfe7a58e972e7023f7597f8967e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DirectSumIndex.lean @@ -0,0 +1,104 @@ +import OAI.Topology.CoarseAssembly.OrthogonalBlock + +namespace OAI + +/-! # Direct-sum additivity of the explicit cycle index -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] {c d e : OddCycle A} + +theorem OddCycle.IsDirectSum.block_cutDown (h : c.IsDirectSum d e) + (P F : End c.space) (Q G : End d.space) : + h.block (symmetricCutDown P F) (symmetricCutDown Q G) = + symmetricCutDown (h.block P Q) (h.block F G) := by + let φ := h.blockHom + have hs (r : ℝ) (p : End c.space × End d.space) : φ (r • p) = r • φ p := + φ.toAlgHom.map_smul_of_tower r p + change φ ((1 / 2 : ℝ) • ((P, Q) * (F, G) * (P, Q) + + star ((P, Q) * (F, G) * (P, Q))) + (1 - (P, Q))) = _ + rw [map_add, hs, map_add, map_star, map_mul, map_mul, map_sub, map_one] + rfl + +theorem OddCycle.IsDirectSum.block_positive (h : c.IsDirectSum d e) + (F : End c.space) (G : End d.space) : + h.block (positiveProjection F) (positiveProjection G) = + positiveProjection (h.block F G) := by + let φ := h.blockHom + have hs (r : ℝ) (p : End c.space × End d.space) : φ (r • p) = r • φ p := + φ.toAlgHom.map_smul_of_tower r p + change φ ((1 / 2 : ℝ) • ((F, G) + 1)) = _ + rw [hs, map_add, map_one] + rfl + +theorem OddCycle.IsDirectSum.block_toeplitz (h : c.IsDirectSum d e) + (P U : End c.space) (Q V : End d.space) : + h.block (toeplitzCompression P U) (toeplitzCompression Q V) = + toeplitzCompression (h.block P Q) (h.block U V) := by + let φ := h.blockHom + change φ ((P, Q) * (U, V) * (P, Q) + (1 - (P, Q))) = _ + rw [map_add, map_mul, map_mul, map_sub, map_one] + rfl + +theorem OddCycle.IsDirectSum.block_unitaryExtension (h : c.IsDirectSum d e) (u : A) : + h.block (unitaryExtension c u) (unitaryExtension d u) = unitaryExtension e u := by + let φ := h.blockHom + change φ ((c.representation u, d.representation u) + + (1 - (c.representation 1, d.representation 1))) = _ + rw [map_add, map_sub, map_one] + change h.block (c.representation u) (d.representation u) + + (1 - h.block (c.representation 1) (d.representation 1)) = _ + have hr (a : A) : h.block (c.representation a) (d.representation a) = e.representation a := + (h.representation_eq a).symm + rw [hr u, hr 1] + rfl + +theorem rawCycleToeplitz_directSum (h : c.IsDirectSum d e) (u : A) : + h.block (rawCycleToeplitz c u) (rawCycleToeplitz d u) = rawCycleToeplitz e u := by + unfold rawCycleToeplitz + have hr : h.block (c.representation 1) (d.representation 1) = e.representation 1 := + (h.representation_eq 1).symm + have ho : h.block c.operator d.operator = e.operator := h.operator_eq.symm + rw [h.block_toeplitz, h.block_positive, h.block_cutDown, hr, ho, h.block_unitaryExtension] + +theorem OddCycle.IsDirectSum.block_coordinates (h : c.IsDirectSum d e) + (T : End c.space) (S : End d.space) : + h.coordinates ∘L h.block T S ∘L h.inclusion = T.prodMap S := by + have he : h.block T S = h.inclusion ∘L (T.prodMap S) ∘L h.coordinates := by + apply ContinuousLinearMap.ext + intro x + rfl + rw [he] + simp only [← ContinuousLinearMap.comp_assoc, h.coordinates_inclusion, + ContinuousLinearMap.id_comp] + rw [ContinuousLinearMap.comp_assoc, h.coordinates_inclusion, + ContinuousLinearMap.comp_id] + +theorem rawCycleIndex_directSum (h : c.IsDirectSum d e) (u : A) + (hul : star u * u = 1) (hur : u * star u = 1) : + rawCycleIndex e u = rawCycleIndex c u + rawCycleIndex d u := by + have hc := rawCycleToeplitz_fredholm c u hul hur + have hd := rawCycleToeplitz_fredholm d u hul hur + have he := rawCycleToeplitz_fredholm e u hul hur + have hcoord : h.coordinates.IsFredholm := h.coordinateEquiv.isFredholm + have hincl : h.inclusion.IsFredholm := h.coordinateEquiv.symm.isFredholm + have hcz : h.coordinates.toLinearMap.index = 0 := + LinearMap.index_of_bijective h.coordinateEquiv.bijective + have hiz : h.inclusion.toLinearMap.index = 0 := + LinearMap.index_of_bijective h.coordinateEquiv.symm.bijective + have hi : (h.coordinates ∘L rawCycleToeplitz e u ∘L h.inclusion).toLinearMap.index = + (rawCycleToeplitz e u).toLinearMap.index := by + rw [hcoord.index_comp (he.comp hincl), he.index_comp hincl, hcz, hiz, zero_add, add_zero] + have hprod : h.coordinates ∘L rawCycleToeplitz e u ∘L h.inclusion = + (rawCycleToeplitz c u).prodMap (rawCycleToeplitz d u) := by + rw [← rawCycleToeplitz_directSum h u, h.block_coordinates] + rw [hprod] at hi + exact hi.symm.trans (fredholmIndex_prodMap _ _ hc hd) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DirectSumIntertwining.lean b/lean/OAI/Topology/CoarseAssembly/DirectSumIntertwining.lean new file mode 100644 index 0000000000000000000000000000000000000000..f04b896ab21ff153651285123bb3a9dab13bc44b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DirectSumIntertwining.lean @@ -0,0 +1,77 @@ +import OAI.Topology.CoarseAssembly.OrthogonalBlock +import OAI.Topology.CoarseAssembly.PartitionIntertwining + +namespace OAI + +/-! # Direct-sum inclusions intertwine the actual localized operators -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] {c d e : OddCycle A} + +theorem OddCycle.IsDirectSum.block_apply_left (h : c.IsDirectSum d e) + (T : End c.space) (S : End d.space) (v : c.space) : + h.block T S (h.left v) = h.left (T v) := by + have hz : h.right.toContinuousLinearMap.adjoint (h.left v) = 0 := + DFunLike.congr_fun h.orthogonal_reverse v + change h.left (T (h.left.toContinuousLinearMap.adjoint (h.left v))) + + h.right (S (h.right.toContinuousLinearMap.adjoint (h.left v))) = _ + rw [adjoint_apply_isometry, hz, map_zero, map_zero, add_zero] + +theorem OddCycle.IsDirectSum.block_apply_right (h : c.IsDirectSum d e) + (T : End c.space) (S : End d.space) (v : d.space) : + h.block T S (h.right v) = h.right (S v) := by + have hz : h.left.toContinuousLinearMap.adjoint (h.right v) = 0 := + DFunLike.congr_fun h.orthogonal v + change h.left (T (h.left.toContinuousLinearMap.adjoint (h.right v))) + + h.right (S (h.right.toContinuousLinearMap.adjoint (h.right v))) = _ + rw [adjoint_apply_isometry, hz, map_zero, map_zero, zero_add] + +end CoarseAssembly.Analytic + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ) + {c d e : OddCycle C(Point X r, ℂ)} + +theorem ripsSpatialOperator_directSum_left (h : c.IsDirectSum d e) + (hc : c.representation 1 = 1) (he : e.representation 1 = 1) : + (ripsSpatialOperator r e he).comp (coefficientIsometry h.left).toContinuousLinearMap = + (coefficientIsometry h.left).toContinuousLinearMap.comp (ripsSpatialOperator r c hc) := by + apply localizedSpatialOperator_intertwines h.left + (representedSqrt r c) (representedSqrt r e) + (representedSqrt_adjoint r c) (representedSqrt_adjoint r e) + (representedSqrt_partition r c hc) (representedSqrt_partition r e he) + · intro x v + change e.representation (sqrtCoordinate r x) (h.left v) = _ + rw [h.representation_eq] + exact h.block_apply_left _ _ v + · intro v + rw [h.operator_eq] + exact h.block_apply_left _ _ v + +theorem ripsSpatialOperator_directSum_right (h : c.IsDirectSum d e) + (hd : d.representation 1 = 1) (he : e.representation 1 = 1) : + (ripsSpatialOperator r e he).comp (coefficientIsometry h.right).toContinuousLinearMap = + (coefficientIsometry h.right).toContinuousLinearMap.comp (ripsSpatialOperator r d hd) := by + apply localizedSpatialOperator_intertwines h.right + (representedSqrt r d) (representedSqrt r e) + (representedSqrt_adjoint r d) (representedSqrt_adjoint r e) + (representedSqrt_partition r d hd) (representedSqrt_partition r e he) + · intro x v + change e.representation (sqrtCoordinate r x) (h.right v) = _ + rw [h.representation_eq] + exact h.block_apply_right _ _ v + · intro v + rw [h.operator_eq] + exact h.block_apply_right _ _ v + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/DiscConnected.lean b/lean/OAI/Topology/CoarseAssembly/DiscConnected.lean new file mode 100644 index 0000000000000000000000000000000000000000..773ba3736098ac7e5cb5eaeff192deb3e80ce32c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/DiscConnected.lean @@ -0,0 +1,105 @@ +import OAI.Topology.CoarseAssembly.Lattice +import Mathlib.Tactic.NormNum +import Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected + +namespace OAI + +/-! # Connectivity of the triangular lattice discs + +Moving a nonzero coordinate one step toward zero stays in the hexagonal +disc and decreases the sum of absolute coordinates. This gives paths to +the origin within each finite base disc. +-/ + +namespace CoarseAssembly + +def discOrigin (j : ℕ) : Disc j := ⟨(0, 0), by simp [latticeRadius]⟩ + +def discRank {j : ℕ} (u : Disc j) : ℕ := u.val.1.natAbs + u.val.2.natAbs + +private theorem disc_lower_neighbor {j : ℕ} (u : Disc j) (hu : u ≠ discOrigin j) : + ∃ v : Disc j, (discGraph j).Adj u v ∧ discRank v < discRank u := by + rcases u with ⟨⟨a, b⟩, huj⟩ + have hh := huj + simp only [latticeRadius, max_le_iff, abs_le] at hh + have hstep (c d : ℤ) (hc : |c| ≤ (j : ℤ)) (hd : |d| ≤ (j : ℤ)) + (hcd : |c + d| ≤ (j : ℤ)) (ha : |a - c| ≤ 1) (hb : |b - d| ≤ 1) + (hs : |(a + b) - (c + d)| ≤ 1) (hne : (a, b) ≠ (c, d)) + (hr : c.natAbs + d.natAbs < a.natAbs + b.natAbs) : + ∃ v : Disc j, (discGraph j).Adj ⟨(a, b), huj⟩ v ∧ + discRank v < discRank ⟨(a, b), huj⟩ := by + exact ⟨⟨(c, d), by simp only [latticeRadius, max_le_iff]; exact ⟨⟨hc, hd⟩, hcd⟩⟩, + ⟨ha, hb, hs, hne⟩, hr⟩ + by_cases ha : 0 < a + · apply hstep (a - 1) b + · rw [abs_le]; omega + · rw [abs_le]; omega + · rw [abs_le]; omega + · norm_num + · simp + · norm_num + · intro he; have := congrArg Prod.fst he; omega + · have h1 : (a.natAbs : ℤ) = a := by omega + have h2 : ((a - 1).natAbs : ℤ) = a - 1 := by omega + omega + · by_cases ha' : a < 0 + · apply hstep (a + 1) b + · rw [abs_le]; omega + · rw [abs_le]; omega + · rw [abs_le]; omega + · norm_num + · simp + · norm_num + · intro he; have := congrArg Prod.fst he; omega + · have h1 : (a.natAbs : ℤ) = -a := by omega + have h2 : ((a + 1).natAbs : ℤ) = -(a + 1) := by omega + omega + · have ha0 : a = 0 := by omega + subst a + have hb0 : b ≠ 0 := by + intro hb + apply hu + subst b + rfl + by_cases hb : 0 < b + · apply hstep 0 (b - 1) + · simp + · rw [abs_le]; omega + · rw [abs_le]; omega + · simp + · norm_num + · norm_num + · intro he; have := congrArg Prod.snd he; omega + · have h1 : (b.natAbs : ℤ) = b := by omega + have h2 : ((b - 1).natAbs : ℤ) = b - 1 := by omega + omega + · have hb' : b < 0 := by omega + apply hstep 0 (b + 1) + · simp + · rw [abs_le]; omega + · rw [abs_le]; omega + · simp + · norm_num + · norm_num + · intro he; have := congrArg Prod.snd he; omega + · have h1 : (b.natAbs : ℤ) = -b := by omega + have h2 : ((b + 1).natAbs : ℤ) = -(b + 1) := by omega + omega + +theorem disc_reachable_origin {j : ℕ} (u : Disc j) : + (discGraph j).Reachable u (discOrigin j) := by + induction hn : discRank u using Nat.strong_induction_on generalizing u with + | h n ih => + by_cases hu : u = discOrigin j + · subst u; exact SimpleGraph.Reachable.refl _ + · obtain ⟨v, huv, hv⟩ := disc_lower_neighbor u hu + have hvo := ih (discRank v) (by omega) v rfl + exact huv.reachable.trans hvo + +theorem discGraph_connected (j : ℕ) : (discGraph j).Connected where + preconnected u v := (disc_reachable_origin u).trans (disc_reachable_origin v).symm + nonempty := ⟨discOrigin j⟩ + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/EmbeddingBoundaryComparison.lean b/lean/OAI/Topology/CoarseAssembly/EmbeddingBoundaryComparison.lean new file mode 100644 index 0000000000000000000000000000000000000000..5135f2ff29d101d3ac04a673f4dc148ecd71e9c9 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/EmbeddingBoundaryComparison.lean @@ -0,0 +1,90 @@ +import OAI.Topology.CoarseAssembly.EmbeddingTransition +import OAI.Topology.CoarseAssembly.RelativePartialIsometry +import OAI.Topology.CoarseAssembly.MultiplierBoundaryClass + +namespace OAI + +/-! # Equality of Roe boundary classes from two embeddings of one operator -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic OperatorKTheory + +variable {X E H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem multiplierBoundaryUnitary_embedding (V : E →ₗᵢ[ℂ] Module X H) + (S : E →L[ℂ] E) (hS : IsSelfAdjoint S) + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hFV : F.val = isometricExtension V S) : + (multiplierBoundaryUnitary F hF : Operator X H) - 1 = + operatorConjugation V ((rationalBoundaryUnitary S hS : E →L[ℂ] E) - 1) := by + have hm := map_rationalBoundaryUnitary + (multiplierAlgebra (X := X) (H := H)).subtype F hF + change (multiplierBoundaryUnitary F hF : Operator X H) = + (rationalBoundaryUnitary F.val (hF.map (multiplierAlgebra (X := X) (H := H)).subtype) : + Operator X H) at hm + simp only [hFV] at hm + rw [rationalBoundaryUnitary_isometricExtension V S hS] at hm + rw [hm, add_sub_cancel_left] + +/-- Two embeddings of the same operator give the same class whenever their +transition is a Roe multiplier. Coefficient embeddings satisfy this via propagation zero. -/ +theorem multiplierBoundaryClass_embedding + (V W : E →ₗᵢ[ℂ] Module X H) (S : E →L[ℂ] E) (hS : IsSelfAdjoint S) + (F G : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hGd : G.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hFV : F.val = isometricExtension V S) (hGW : G.val = isometricExtension W S) + (hVW : RoeMultiplier (embeddingTransition V W)) : + multiplierBoundaryClass F hF hFd = multiplierBoundaryClass G hG hGd := by + let T : multiplierAlgebra (X := X) (H := H) := ⟨embeddingTransition V W, hVW⟩ + let u := rationalBoundaryUnitary F hF + let v := rationalBoundaryUnitary G hG + let a := (rationalBoundaryUnitary S hS : E →L[ℂ] E) - 1 + have hu : (u : multiplierAlgebra (X := X) (H := H)).val - 1 = operatorConjugation V a := + multiplierBoundaryUnitary_embedding V S hS F hF hFV + have hv : (v : multiplierAlgebra (X := X) (H := H)).val - 1 = operatorConjugation W a := + multiplierBoundaryUnitary_embedding W S hS G hG hGW + have hT : T * star T * T = T := by + apply Subtype.ext + exact embeddingTransition_partial V W + have hl : (star T * T) * ((u : multiplierAlgebra (X := X) (H := H)) - 1) = + (u : multiplierAlgebra (X := X) (H := H)) - 1 := by + apply Subtype.ext + change (star (embeddingTransition V W) * embeddingTransition V W) * + ((u : multiplierAlgebra (X := X) (H := H)).val - 1) = + (u : multiplierAlgebra (X := X) (H := H)).val - 1 + rw [hu] + exact embeddingTransition_support_left V W a + have hr : ((u : multiplierAlgebra (X := X) (H := H)) - 1) * (star T * T) = + (u : multiplierAlgebra (X := X) (H := H)) - 1 := by + apply Subtype.ext + change ((u : multiplierAlgebra (X := X) (H := H)).val - 1) * + (star (embeddingTransition V W) * embeddingTransition V W) = + (u : multiplierAlgebra (X := X) (H := H)).val - 1 + rw [hu] + exact embeddingTransition_support_right V W a + have he : (v : multiplierAlgebra (X := X) (H := H)) = + 1 + T * ((u : multiplierAlgebra (X := X) (H := H)) - 1) * star T := by + apply Subtype.ext + change (v : multiplierAlgebra (X := X) (H := H)).val = + 1 + embeddingTransition V W * ((u : multiplierAlgebra (X := X) (H := H)).val - 1) * + star (embeddingTransition V W) + rw [hu, embeddingTransition_conjugation] + simpa only [add_comm] using (sub_eq_iff_eq_add.mp hv) + let φ := (multiplierAlgebra (X := X) (H := H)).subtype + exact relativeClass_partialIsometry (hS := algebra_isClosed) + (algebra (X := X) (H := H)) φ continuous_subtype_val + (fun b c hc => b.property ⟨c, hc⟩) T hT u v hl hr he + (multiplierBoundaryUnitary_sub_one_mem F hF hFd) + (multiplierBoundaryUnitary_sub_one_mem G hG hGd) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/EmbeddingTransition.lean b/lean/OAI/Topology/CoarseAssembly/EmbeddingTransition.lean new file mode 100644 index 0000000000000000000000000000000000000000..29b30b125dd2f74dfc7c3642e6ef6955bdd77fb6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/EmbeddingTransition.lean @@ -0,0 +1,57 @@ +import OAI.Topology.CoarseAssembly.IsometricExtension +import OAI.Topology.CoarseAssembly.CayleyNonunitalNaturality + +namespace OAI + +/-! # The partial isometry comparing two Hilbert-space embeddings -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def embeddingTransition (V W : E →ₗᵢ[ℂ] H) : H →L[ℂ] H := + W.toContinuousLinearMap.comp V.toContinuousLinearMap.adjoint + +theorem embeddingTransition_partial (V W : E →ₗᵢ[ℂ] H) : + embeddingTransition V W * star (embeddingTransition V W) * embeddingTransition V W = + embeddingTransition V W := by + ext x + simp [embeddingTransition, ContinuousLinearMap.star_eq_adjoint] + +theorem embeddingTransition_initial (V W : E →ₗᵢ[ℂ] H) : + star (embeddingTransition V W) * embeddingTransition V W = operatorConjugation V 1 := by + ext x + simp [embeddingTransition, operatorConjugation, ContinuousLinearMap.star_eq_adjoint] + +theorem embeddingTransition_support_left (V W : E →ₗᵢ[ℂ] H) (a : E →L[ℂ] E) : + (star (embeddingTransition V W) * embeddingTransition V W) * operatorConjugation V a = + operatorConjugation V a := by + rw [embeddingTransition_initial, ← operatorConjugation_mul, one_mul] + +theorem embeddingTransition_support_right (V W : E →ₗᵢ[ℂ] H) (a : E →L[ℂ] E) : + operatorConjugation V a * (star (embeddingTransition V W) * embeddingTransition V W) = + operatorConjugation V a := by + rw [embeddingTransition_initial, ← operatorConjugation_mul, mul_one] + +theorem embeddingTransition_conjugation (V W : E →ₗᵢ[ℂ] H) (a : E →L[ℂ] E) : + embeddingTransition V W * operatorConjugation V a * star (embeddingTransition V W) = + operatorConjugation W a := by + ext x + simp [embeddingTransition, operatorConjugation, ContinuousLinearMap.star_eq_adjoint] + +theorem rationalBoundaryUnitary_isometricExtension (V : E →ₗᵢ[ℂ] H) + (F : E →L[ℂ] E) (hF : IsSelfAdjoint F) : + (Analytic.rationalBoundaryUnitary (isometricExtension V F) + (isometricExtension_selfAdjoint V F hF) : H →L[ℂ] H) = + 1 + operatorConjugation V ((Analytic.rationalBoundaryUnitary F hF : E →L[ℂ] E) - 1) := + (Analytic.nonunital_rationalBoundaryUnitary (operatorConjugationHom V) F hF).symm + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/EssentialCommutant.lean b/lean/OAI/Topology/CoarseAssembly/EssentialCommutant.lean new file mode 100644 index 0000000000000000000000000000000000000000..01ae121a66cfbccbd6baa1b6ef4376dc55248d56 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/EssentialCommutant.lean @@ -0,0 +1,96 @@ +import OAI.Topology.CoarseAssembly.CircleSequenceRepresentation +import OAI.Topology.CoarseAssembly.ToeplitzProductIndex +import Mathlib.Topology.ContinuousMap.StoneWeierstrass + +namespace OAI + +/-! # Extending compact commutators from the circle coordinate to every function -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped CStarAlgebra + +variable {H : HilbertSpace} + +theorem compact_commutator_add (P T S : End H) + (hT : IsCompactOperator (P * T - T * P : End H)) + (hS : IsCompactOperator (P * S - S * P : End H)) : + IsCompactOperator (P * (T + S) - (T + S) * P : End H) := by + have he : P * (T + S) - (T + S) * P = (P * T - T * P) + (P * S - S * P) := by noncomm_ring + rw [he] + exact hT.add hS + +/-- Operators commuting with `P` modulo compacts, together with their adjoints. -/ +def compactCommutant (P : End H) : StarSubalgebra ℂ (End H) where + carrier := {T | IsCompactOperator (P * T - T * P : End H) ∧ + IsCompactOperator (P * star T - star T * P : End H)} + zero_mem' := by + change IsCompactOperator (P * 0 - 0 * P : End H) ∧ IsCompactOperator (P * star 0 - star 0 * P : End H) + simp only [star_zero, mul_zero, zero_mul, sub_self] + exact ⟨isCompactOperator_zero, isCompactOperator_zero⟩ + one_mem' := by + change IsCompactOperator (P * 1 - 1 * P : End H) ∧ IsCompactOperator (P * star 1 - star 1 * P : End H) + simp only [star_one, mul_one, one_mul, sub_self] + exact ⟨isCompactOperator_zero, isCompactOperator_zero⟩ + add_mem' hT hS := by + refine ⟨compact_commutator_add P _ _ hT.1 hS.1, ?_⟩ + rw [star_add] + exact compact_commutator_add P _ _ hT.2 hS.2 + mul_mem' hT hS := by + refine ⟨compact_commutator_mul P _ _ hT.1 hS.1, ?_⟩ + rw [star_mul] + exact compact_commutator_mul P _ _ hS.2 hT.2 + algebraMap_mem' z := by + have hz (z : ℂ) : P * algebraMap ℂ (End H) z - algebraMap ℂ (End H) z * P = 0 := + sub_eq_zero.mpr (Algebra.commutes z P).symm + change IsCompactOperator (P * algebraMap ℂ (End H) z - algebraMap ℂ (End H) z * P) ∧ + IsCompactOperator (P * star (algebraMap ℂ (End H) z) - star (algebraMap ℂ (End H) z) * P) + have hs : star (algebraMap ℂ (End H) z) = algebraMap ℂ (End H) (star z) := by + simp only [Algebra.algebraMap_eq_smul_one, star_smul, star_one] + rw [hz, hs, hz] + exact ⟨isCompactOperator_zero, isCompactOperator_zero⟩ + star_mem' {T} hT := by + change IsCompactOperator (P * star T - star T * P) ∧ + IsCompactOperator (P * star (star T) - star (star T) * P) + exact ⟨hT.2, by simpa only [star_star] using hT.1⟩ + +theorem compactCommutant_closed (P : End H) : IsClosed (compactCommutant P : Set (End H)) := by + change IsClosed ({T : End H | IsCompactOperator (P * T - T * P)} ∩ + {T : End H | IsCompactOperator (P * star T - star T * P)}) + exact (isClosed_setOfPred_isCompactOperator.preimage + ((continuous_const.mul continuous_id).sub (continuous_id.mul continuous_const))).inter + (isClosed_setOfPred_isCompactOperator.preimage + ((continuous_const.mul continuous_star).sub (continuous_star.mul continuous_const))) + +theorem circleRepresentation_commutator (f : C(Circle, ℂ)) : IsCompactOperator + (negativeProjection * circleRepresentation f - circleRepresentation f * negativeProjection) := by + let S : StarSubalgebra ℂ C(Circle, ℂ) := + (compactCommutant negativeProjection).comap circleRepresentation + have hcoord : circleCoordinate ∈ S := by + change IsCompactOperator (negativeProjection * circleRepresentation circleCoordinate - + circleRepresentation circleCoordinate * negativeProjection) ∧ + IsCompactOperator (negativeProjection * star (circleRepresentation circleCoordinate) - + star (circleRepresentation circleCoordinate) * negativeProjection) + rw [circleRepresentation_coordinate] + exact ⟨negativeProjection_commutator_compact, + compact_commutator_star_unitary _ _ bilateralShift_unitary.1 bilateralShift_unitary.2 + negativeProjection_commutator_compact⟩ + have hsep : S.SeparatesPoints := by + intro x y hxy + exact ⟨circleCoordinate, ⟨circleCoordinate, hcoord, rfl⟩, fun he => hxy (Circle.coe_injective he)⟩ + have htop : S.topologicalClosure = ⊤ := + ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints S hsep + have hclosed : IsClosed (S : Set C(Circle, ℂ)) := + (compactCommutant_closed negativeProjection).preimage (map_continuous circleRepresentation) + have hle : S.topologicalClosure ≤ S := StarSubalgebra.topologicalClosure_minimal le_rfl hclosed + rw [htop] at hle + have hf : f ∈ S := hle (by trivial) + exact hf.1 + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/EssentialToeplitz.lean b/lean/OAI/Topology/CoarseAssembly/EssentialToeplitz.lean new file mode 100644 index 0000000000000000000000000000000000000000..309b21a6051f9b5587e844696151d3eec76ed61f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/EssentialToeplitz.lean @@ -0,0 +1,72 @@ +import OAI.Topology.CoarseAssembly.OperatorNormalization +import OAI.Topology.CoarseAssembly.CompactIndex + +namespace OAI + +/-! # Toeplitz Fredholmness before choosing an involution + +A self-adjoint operator with compact square defect suffices. This lets the +index be defined using the explicit, continuous cut-down operator. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem positiveProjection_sub (F G : End H) : + positiveProjection F - positiveProjection G = (1 / 2 : ℝ) • (F - G) := by + unfold positiveProjection + module + +theorem compact_toeplitz_sub (P Q U : End H) (hPQ : IsCompactOperator (P - Q : End H)) : + IsCompactOperator (toeplitzCompression P U - toeplitzCompression Q U : End H) := by + have he : toeplitzCompression P U - toeplitzCompression Q U = + (P - Q) * U * P + Q * U * (P - Q) - (P - Q) := by + unfold toeplitzCompression + noncomm_ring + rw [he] + exact ((compact_mul_right (compact_mul_right hPQ U) P).add + (compact_mul_left hPQ (Q * U))).sub hPQ + +theorem compact_star_toeplitz_sub (P Q U : End H) (hP : IsSelfAdjoint P) + (hQ : IsSelfAdjoint Q) (hPQ : IsCompactOperator (P - Q : End H)) : + IsCompactOperator (star (toeplitzCompression P U - toeplitzCompression Q U) : End H) := by + rw [star_sub, toeplitzCompression_star P U hP, toeplitzCompression_star Q U hQ] + exact compact_toeplitz_sub P Q (star U) hPQ + +theorem essentialToeplitz_compact_defects (F U : End H) (hF : IsSelfAdjoint F) + (hc : IsCompactOperator (F * F - 1 : End H)) + (hUl : star U * U = 1) (hUr : U * star U = 1) + (hcomm : IsCompactOperator (F * U - U * F : End H)) : + IsCompactOperator (star (toeplitzCompression (positiveProjection F) U) * + toeplitzCompression (positiveProjection F) U - 1 : End H) ∧ + IsCompactOperator (toeplitzCompression (positiveProjection F) U * + star (toeplitzCompression (positiveProjection F) U) - 1 : End H) := by + obtain ⟨N, hNs, hNsq, hNF, _⟩ := exists_compact_involution F hF hc + have hNU := compact_commutator_of_compact_change F N U hNF hcomm + have hQU : IsCompactOperator (positiveProjection N * U - U * positiveProjection N : End H) := by + rw [positiveProjection_commutator] + exact hNU.smul (1 / 2 : ℝ) + obtain ⟨hl, hr⟩ := toeplitzCompression_compact_defects (positiveProjection N) U + (positiveProjection_selfAdjoint N hNs) (positiveProjection_sq N hNsq) hUl hUr hQU + have hPQ : IsCompactOperator (positiveProjection F - positiveProjection N : End H) := by + rw [positiveProjection_sub, show F - N = -(N - F) by abel] + exact hNF.neg.smul (1 / 2 : ℝ) + have hd := compact_toeplitz_sub (positiveProjection F) (positiveProjection N) U hPQ + have hds := compact_star_toeplitz_sub (positiveProjection F) (positiveProjection N) U + (positiveProjection_selfAdjoint F hF) (positiveProjection_selfAdjoint N hNs) hPQ + have h := essentialUnitary_compactPerturb (toeplitzCompression (positiveProjection N) U) + (toeplitzCompression (positiveProjection F) U - toeplitzCompression (positiveProjection N) U) + hl hr hd hds + have he : toeplitzCompression (positiveProjection N) U + + (toeplitzCompression (positiveProjection F) U - toeplitzCompression (positiveProjection N) U) = + toeplitzCompression (positiveProjection F) U := by abel + rwa [he] at h + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/EssentialToeplitzIndex.lean b/lean/OAI/Topology/CoarseAssembly/EssentialToeplitzIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..0b96516a66b5f5b718f331dbf5751a2092cf3985 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/EssentialToeplitzIndex.lean @@ -0,0 +1,73 @@ +import OAI.Topology.CoarseAssembly.ToeplitzProductIndex + +namespace OAI + +/-! # Additivity of the essentially self-adjoint Toeplitz index -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem essentialToeplitz_index_normalize (F N U : End H) + (hF : IsSelfAdjoint F) (hN : IsSelfAdjoint N) (hNN : N * N = 1) + (hNF : IsCompactOperator (N - F : End H)) + (hUl : star U * U = 1) (hUr : U * star U = 1) + (hFU : IsCompactOperator (F * U - U * F : End H)) : + (toeplitzCompression (positiveProjection F) U).toLinearMap.index = + (toeplitzCompression (positiveProjection N) U).toLinearMap.index := by + have hNU := compact_commutator_of_compact_change F N U hNF hFU + have hQU : IsCompactOperator (positiveProjection N * U - U * positiveProjection N : End H) := by + rw [positiveProjection_commutator] + exact hNU.smul (1 / 2 : ℝ) + obtain ⟨hl, hr⟩ := toeplitzCompression_compact_defects (positiveProjection N) U + (positiveProjection_selfAdjoint N hN) (positiveProjection_sq N hNN) hUl hUr hQU + have hPQ : IsCompactOperator (positiveProjection F - positiveProjection N : End H) := by + rw [positiveProjection_sub, show F - N = -(N - F) by abel] + exact hNF.neg.smul (1 / 2 : ℝ) + have hi := fredholmIndex_compactPerturb (toeplitzCompression (positiveProjection N) U) + (toeplitzCompression (positiveProjection F) U - toeplitzCompression (positiveProjection N) U) + hl hr (compact_toeplitz_sub _ _ _ hPQ) + (compact_star_toeplitz_sub _ _ _ (positiveProjection_selfAdjoint F hF) + (positiveProjection_selfAdjoint N hN) hPQ) + have he : toeplitzCompression (positiveProjection N) U + + (toeplitzCompression (positiveProjection F) U - toeplitzCompression (positiveProjection N) U) = + toeplitzCompression (positiveProjection F) U := by abel + rw [he] at hi + exact hi.symm + +theorem essentialToeplitz_index_mul (F U V : End H) (hF : IsSelfAdjoint F) + (hFF : IsCompactOperator (F * F - 1 : End H)) + (hUl : star U * U = 1) (hUr : U * star U = 1) + (hVl : star V * V = 1) (hVr : V * star V = 1) + (hU : IsCompactOperator (F * U - U * F : End H)) + (hV : IsCompactOperator (F * V - V * F : End H)) : + (toeplitzCompression (positiveProjection F) (U * V)).toLinearMap.index = + (toeplitzCompression (positiveProjection F) U).toLinearMap.index + + (toeplitzCompression (positiveProjection F) V).toLinearMap.index := by + obtain ⟨N, hN, hNN, hNF, _⟩ := exists_compact_involution F hF hFF + have hUVl : star (U * V) * (U * V) = 1 := by + calc + _ = star V * (star U * U) * V := by rw [star_mul]; noncomm_ring + _ = 1 := by rw [hUl, mul_one, hVl] + have hUVr : (U * V) * star (U * V) = 1 := by + calc + _ = U * (V * star V) * star U := by rw [star_mul]; noncomm_ring + _ = 1 := by rw [hVr, mul_one, hUr] + rw [essentialToeplitz_index_normalize F N (U * V) hF hN hNN hNF hUVl hUVr + (compact_commutator_mul F U V hU hV)] + rw [essentialToeplitz_index_normalize F N U hF hN hNN hNF hUl hUr hU, + essentialToeplitz_index_normalize F N V hF hN hNN hNF hVl hVr hV] + apply toeplitzCompression_index_mul _ _ _ (positiveProjection_selfAdjoint N hN) + (positiveProjection_sq N hNN) hUl hUr hVl hVr + · rw [positiveProjection_commutator] + exact (compact_commutator_of_compact_change F N U hNF hU).smul (1 / 2 : ℝ) + · rw [positiveProjection_commutator] + exact (compact_commutator_of_compact_change F N V hNF hV).smul (1 / 2 : ℝ) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ExplicitBoundaryConclusion.lean b/lean/OAI/Topology/CoarseAssembly/ExplicitBoundaryConclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..340183b81016e754e8c565f74ca6c95d0907830f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ExplicitBoundaryConclusion.lean @@ -0,0 +1,125 @@ +import OAI.Topology.CoarseAssembly.ExplicitFamilyFilling +import OAI.Topology.CoarseAssembly.ExplicitPersistence +import OAI.Topology.CoarseAssembly.BoundaryConclusion + +namespace OAI + +/-! # The counterexample with circle, filling and additivity inputs discharged -/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +local instance explicitBoundaryMetric1 (j : ℕ) : MetricSpace (BoundaryComponent j) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit j +local instance explicitBoundaryMetric2 (j : ℕ) : PseudoMetricSpace (BoundaryComponent j) := + (boundaryComponentMetric elementaryMoves chosenHolonomyUnit j).toPseudoMetricSpace +local instance explicitBoundaryMetric3 : MetricSpace BoundaryVertex := + boundaryMetric elementaryMoves chosenHolonomyUnit +local instance explicitBoundaryMetric4 : PseudoMetricSpace BoundaryVertex := + (boundaryMetric elementaryMoves chosenHolonomyUnit).toPseudoMetricSpace +local instance explicitBoundaryMetric5 (j : ℕ) : MetricSpace (FiberVertex j) := + componentMetric elementaryMoves chosenHolonomyUnit j +local instance explicitBoundaryMetric6 : MetricSpace FiberedUnion := + componentUnionMetric elementaryMoves chosenHolonomyUnit +local instance explicitBoundaryMetric7 : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +def explicitBoundaryStage : LocallyFiniteK1 (Point BoundaryVertex 1) := + pushforward (boundaryFamilyMap elementaryMoves chosenHolonomyUnit 1 boundaryLoops) + explicitCircleFamily + +def explicitBoundaryClass : KX1 BoundaryVertex := + classAt 1 1 (by norm_num) explicitBoundaryStage + +def explicitCounterexampleClass : KX1 VertexUnion := + boundaryTotalCoarsening.homologyMap explicitBoundaryClass + +def explicitRealFiberStage (r : ℝ) (hr : 1 ≤ r) : + LocallyFiniteK1 (Point FiberedUnion r) := + pushforward (ripsFamilyMap fiberBoundaryBase r (realFiberLoops r hr)) explicitCircleFamily + +theorem explicitRealFiberStage_cast (n : ℕ) (hn : 1 ≤ n) + (r : ℝ) (hr : 1 ≤ r) (h : r = (n : ℝ)) : + (h ▸ explicitRealFiberStage r hr) = explicitFiberStage n hn := by + subst r + rfl + +theorem explicitBoundaryStage_base_zero : + pushforward (embeddingMap boundaryToBase + (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit) 1) + explicitBoundaryStage = 0 := by + change pushforward _ (pushforward _ explicitCircleFamily) = 0 + rw [← AddMonoidHom.comp_apply, ← pushforward_comp, boundaryFamily_toBase] + exact explicitBaseBoundaryFamily_zero discBoundaryBase concreteBaseWalk + +theorem explicitBoundaryClass_base_zero : + boundaryBaseCoarsening.homologyMap explicitBoundaryClass = 0 := by + change (embeddingCoarsening boundaryToBase + (boundaryToBase_nonexpanding elementaryMoves chosenHolonomyUnit)).homologyMap + (classAt 1 1 (by norm_num) explicitBoundaryStage) = 0 + rw [embedding_classAt, explicitBoundaryStage_base_zero, classAt_zero] + +theorem explicitCounterexampleClass_image : + totalToFiberCoarsening.homologyMap explicitCounterexampleClass = explicitFiberClass := by + change (embeddingCoarsening totalToFiber.toEmbedding + (fun x y => (totalToFiber_dist x y).le)).homologyMap + ((embeddingCoarsening boundaryToVertex + (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit)).homologyMap + (classAt 1 1 (by norm_num) explicitBoundaryStage)) = _ + rw [embedding_classAt, embedding_classAt] + have hs : pushforward (embeddingMap totalToFiber.toEmbedding + (fun x y => (totalToFiber_dist x y).le) 1) + (pushforward (embeddingMap boundaryToVertex + (boundaryToVertex_nonexpanding elementaryMoves chosenHolonomyUnit) 1) + explicitBoundaryStage) = explicitRealFiberStage 1 le_rfl := by + have hp := congrArg pushforward boundaryFamily_toFiber + have hv := DFunLike.congr_fun hp explicitCircleFamily + simpa only [pushforward_comp, AddMonoidHom.comp_apply, explicitBoundaryStage, + explicitRealFiberStage, fiberLoopsOne] using hv + rw [hs] + apply congrArg ((coarsening FiberedUnion).of 1) + exact explicitRealFiberStage_cast 1 le_rfl 1 le_rfl (by norm_num) + +theorem explicitCounterexampleClass_infinite_order (n : ℤ) (hn : n ≠ 0) : + n • explicitCounterexampleClass ≠ 0 := by + intro hz + have h := congrArg totalToFiberCoarsening.homologyMap hz + rw [map_zsmul, map_zero, explicitCounterexampleClass_image] at h + exact explicitFiberClass_infinite_order n hn h + +theorem explicitCounterexampleClass_index_zero (index : PublishedBoundaryAssemblyInput) + (hgap : PublishedKazhdanInput) : index.total.assembly explicitCounterexampleClass = 0 := + boundary_assembly_zero index hgap explicitBoundaryClass explicitBoundaryClass_base_zero + +/-- The full geometric conclusion, with only canonical assembly and the fixed-generator +published Kazhdan gap remaining. The particular countable class and its filling are proved. -/ +theorem bounded_geometry_counterexample_from_index_gap + (index : PublishedBoundaryAssemblyInput) (hgap : PublishedKazhdanInput) : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ index.total.assembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective index.total.assembly ∧ + ¬ Function.Injective (index.total.assembly.toIntLinearMap.lTensor ℚ) := by + refine ⟨vertexUnion_proper elementaryMoves chosenHolonomyUnit, + vertexUnion_uniform_balls elementaryMoves chosenHolonomyUnit, + vertexUnion_separated elementaryMoves chosenHolonomyUnit, + explicitCounterexampleClass, explicitCounterexampleClass_infinite_order, + explicitCounterexampleClass_index_zero index hgap, ?_, ?_, ?_⟩ + · exact rationalization_ne_zero _ explicitCounterexampleClass_infinite_order + · exact (kernel_obstructs_injectivity index.total.assembly _ + explicitCounterexampleClass_infinite_order + (explicitCounterexampleClass_index_zero index hgap)).1 + · exact (kernel_obstructs_injectivity index.total.assembly _ + explicitCounterexampleClass_infinite_order + (explicitCounterexampleClass_index_zero index hgap)).2 + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ExplicitBoundaryRepresentative.lean b/lean/OAI/Topology/CoarseAssembly/ExplicitBoundaryRepresentative.lean new file mode 100644 index 0000000000000000000000000000000000000000..d6db49488d039e11f3c701e092ae748901625ac1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ExplicitBoundaryRepresentative.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.AmpleRipsFamily +import OAI.Topology.CoarseAssembly.ExplicitBoundaryConclusion + +namespace OAI + +/-! # The actual Roe representative of the counterexample's boundary cycle + +This constructs the index representative from the explicit circle Fredholm +operator and the paper's hexagonal loops. Identification with the descended +canonical coarse assembly map remains a separate theorem. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic DiscreteRoe Rips Congruence + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] + +def circleRipsCycle (r : ℝ) (γ : C(WindingCircle, Point X r)) : OddCycle C(Point X r, ℂ) := + windingCircleCycle.precomp (ContinuousMap.compStarAlgHom' ℂ ℂ γ).toNonUnitalStarAlgHom + +theorem circleRipsCycle_unital (r : ℝ) (γ : C(WindingCircle, Point X r)) : + (circleRipsCycle r γ).representation 1 = 1 := by + change circleRepresentation 1 = 1 + exact map_one _ + +theorem circleRipsCycle_selfAdjoint (r : ℝ) (γ : C(WindingCircle, Point X r)) : + IsSelfAdjoint (circleRipsCycle r γ).operator := negativeCircleOperator_selfAdjoint + +theorem circleRipsCycle_norm (r : ℝ) (γ : C(WindingCircle, Point X r)) : + ‖(circleRipsCycle r γ).operator‖ ≤ 1 := windingCircleCycle_norm + +local instance explicitRepComponentDecidableEq (j : ℕ) : DecidableEq (BoundaryComponent j) := + Classical.decEq _ + +local instance explicitRepComponentMetric (j : ℕ) : MetricSpace (BoundaryComponent j) := + boundaryComponentMetric elementaryMoves chosenHolonomyUnit j +local instance explicitRepComponentPseudoMetric (j : ℕ) : PseudoMetricSpace (BoundaryComponent j) := + (boundaryComponentMetric elementaryMoves chosenHolonomyUnit j).toPseudoMetricSpace +local instance explicitRepUnionMetric : MetricSpace (Sigma BoundaryComponent) := + boundaryComponentsMetric elementaryMoves chosenHolonomyUnit +local instance explicitRepBoundaryMetric : MetricSpace BoundaryVertex := + boundaryMetric elementaryMoves chosenHolonomyUnit +local instance explicitRepBoundaryPseudoMetric : PseudoMetricSpace BoundaryVertex := + (boundaryMetric elementaryMoves chosenHolonomyUnit).toPseudoMetricSpace + +def explicitBoundaryCycle (j : ℕ) : OddCycle C(Point (BoundaryComponent j) 1, ℂ) := + circleRipsCycle 1 (boundaryLoops j) + +def explicitBoundaryFamilyRepresentative : + OperatorKTheory.K1 (algebra (X := Sigma BoundaryComponent) (H := AmpleSpace)) := + ampleRipsFamilyBoundary boundaryRoot 1 (by norm_num) explicitBoundaryCycle + (fun j => circleRipsCycle_unital 1 (boundaryLoops j)) + (fun j => circleRipsCycle_selfAdjoint 1 (boundaryLoops j)) + 1 (by norm_num) (fun j => circleRipsCycle_norm 1 (boundaryLoops j)) + +def boundaryReindexRoeHom : + algebra (X := Sigma BoundaryComponent) (H := AmpleSpace) →⋆ₙₐ[ℂ] BoundaryRoe := + inclusionHom boundaryReindex.toEmbedding + (fun x y => (boundaryReindex_dist elementaryMoves chosenHolonomyUnit x y).le) + +/-- A concrete class in the same reduced Roe algebra used by the conditional +assembly diagram. Canonical assembly identification is not presumed here. -/ +def explicitBoundaryRoeRepresentative : OperatorKTheory.K1 BoundaryRoe := + OperatorKTheory.map boundaryReindexRoeHom explicitBoundaryFamilyRepresentative + +def explicitBaseRoeRepresentative : OperatorKTheory.K1 BaseRoe := + OperatorKTheory.map boundaryBaseRoeHom explicitBoundaryRoeRepresentative + +def explicitTotalRoeRepresentative : OperatorKTheory.K1 TotalRoe := + OperatorKTheory.map boundaryTotalRoeHom explicitBoundaryRoeRepresentative + +/-- The constructed representative satisfies the previously proved spatial +transfer identity. Its base vanishing still requires the assembly descent. -/ +theorem explicitRoeRepresentative_transfer (hgap : PublishedKazhdanInput) : + OperatorKTheory.map (transferRoeHom hgap) explicitBaseRoeRepresentative = + explicitTotalRoeRepresentative := + DFunLike.congr_fun (transferK1_boundary hgap) explicitBoundaryRoeRepresentative + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ExplicitCircleFamily.lean b/lean/OAI/Topology/CoarseAssembly/ExplicitCircleFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..0da76a940a1bedb385eb596a610e7e2e861536f6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ExplicitCircleFamily.lean @@ -0,0 +1,51 @@ +import OAI.Topology.CoarseAssembly.SigmaCycleRestriction +import OAI.Topology.CoarseAssembly.UniformCycleNormalization + +namespace OAI + +/-! # The circle-family class without a countable-additivity assumption -/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic +open scoped ZeroAtInfty + +def windingCircleCycle : OddCycle C(WindingCircle, ℂ) := + negativeCircleCycle.precomp + (ContinuousMap.compStarAlgHom' ℂ ℂ + ((AddCircle.homeomorphCircle (T := (1 : ℝ)) one_ne_zero).symm : + C(Circle, WindingCircle))).toNonUnitalStarAlgHom + +theorem windingCircleCycle_class : + cycleClass C₀(WindingCircle, ℂ) (windingCircleCycle.precomp compactFunctionForget) = + circleFundamental := by + unfold circleFundamental negativeCircleClass pushforward windingCircleCycle + rw [precomp_cycleClass, OddCycle.precomp_comp, OddCycle.precomp_comp] + congr 2 + +theorem windingCircleCycle_norm : ‖windingCircleCycle.operator‖ ≤ 1 := + involution_norm_le_one _ negativeCircleOperator_selfAdjoint negativeCircleOperator_sq + +def circleSigmaCycle : OddCycle C₀(Sigma CircleFamily, ℂ) := + sigmaCycle CircleFamily (fun _ => windingCircleCycle) 1 (by norm_num) + (fun _ => windingCircleCycle_norm) (fun _ => negativeCircleOperator_selfAdjoint) + (fun _ => negativeCircleOperator_sq) + +/-- The particular product class needed by the counterexample is an actual cycle. -/ +def explicitCircleFamily : LocallyFiniteK1 (Sigma CircleFamily) := + cycleClass C₀(Sigma CircleFamily, ℂ) circleSigmaCycle + +theorem explicitCircleFamily_coordinate (j : ℕ) : + restrictComponent (sigmaComponent CircleFamily j) (sigmaComponent_open CircleFamily j) + explicitCircleFamily = circleFundamental := by + exact (sigmaCycle_coordinate CircleFamily (fun _ => windingCircleCycle) 1 (by norm_num) + (fun _ => windingCircleCycle_norm) (fun _ => negativeCircleOperator_selfAdjoint) + (fun _ => negativeCircleOperator_sq) j).trans windingCircleCycle_class + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ExplicitCutDown.lean b/lean/OAI/Topology/CoarseAssembly/ExplicitCutDown.lean new file mode 100644 index 0000000000000000000000000000000000000000..89f61c728e47b40e143f925551270d6fd58d1e65 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ExplicitCutDown.lean @@ -0,0 +1,77 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RepresentedCutDown + +namespace OAI + +/-! # The explicit represented-subspace cut-down cycle -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem representedCorrection_right (c : OddCycle A) (a : A) : + IsCompactOperator (representedCorrection c * c.representation a : End c.space) := by + have hp : c.representation 1 * c.representation a = c.representation a := by + rw [← map_mul, one_mul] + rw [← hp, ← mul_assoc] + exact compact_mul_right (representedCutDown_compact c).1 _ + +theorem representedCorrection_left (c : OddCycle A) (a : A) : + IsCompactOperator (c.representation a * representedCorrection c : End c.space) := by + have hp : c.representation a * c.representation 1 = c.representation a := by + rw [← map_mul, mul_one] + rw [← hp, mul_assoc] + exact compact_mul_left (representedCutDown_compact c).2.1 _ + +theorem representedCorrection_star (c : OddCycle A) (a : A) : + IsCompactOperator (star (representedCorrection c) * c.representation a : End c.space) := by + have hp : c.representation 1 * c.representation a = c.representation a := by + rw [← map_mul, one_mul] + rw [← hp, ← mul_assoc] + exact compact_mul_right (representedCutDown_compact c).2.2 _ + +theorem OddCycle.cutDown_operator (c : OddCycle A) : + c.cutDown.operator = symmetricCutDown (c.representation 1) c.operator := by + change c.operator + (symmetricCutDown (c.representation 1) c.operator - c.operator) = _ + abel + +@[simp] theorem OddCycle.cutDown_representation (c : OddCycle A) : + c.cutDown.representation = c.representation := rfl + +theorem cutDown_class (c : OddCycle A) : cycleClass A c.cutDown = cycleClass A c := + localCompactPerturb_class c (representedCorrection c) (representedCorrection_right c) + (representedCorrection_left c) (representedCorrection_star c) + +theorem cutDown_selfAdjoint (c : OddCycle A) : IsSelfAdjoint c.cutDown.operator := by + rw [c.cutDown_operator] + exact symmetricCutDown_selfAdjoint _ _ (representation_unit_selfAdjoint c) + +theorem cutDown_complement (c : OddCycle A) : + c.cutDown.operator * (1 - c.cutDown.representation 1) = 1 - c.cutDown.representation 1 := by + change (c.operator + representedCorrection c) * (1 - c.representation 1) = 1 - c.representation 1 + have he : c.operator + representedCorrection c = + symmetricCutDown (c.representation 1) c.operator := by unfold representedCorrection; abel + rw [he] + exact symmetricCutDown_complement _ _ (representation_unit_selfAdjoint c) (representation_unit_sq c) + +theorem cutDown_square_compact (c : OddCycle A) : + IsCompactOperator (c.cutDown.operator * c.cutDown.operator - 1 : End c.cutDown.space) := + represented_square_compact c.cutDown (cutDown_complement c) + +theorem symmetricCutDown_square_compact (c : OddCycle A) : + IsCompactOperator ((symmetricCutDown (c.representation 1) c.operator) * + symmetricCutDown (c.representation 1) c.operator - 1 : End c.space) := by + have h := cutDown_square_compact c + change IsCompactOperator ((c.operator + representedCorrection c) * + (c.operator + representedCorrection c) - 1 : End c.space) at h + have he : c.operator + representedCorrection c = + symmetricCutDown (c.representation 1) c.operator := by unfold representedCorrection; abel + rwa [he] at h + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ExplicitFamilyFilling.lean b/lean/OAI/Topology/CoarseAssembly/ExplicitFamilyFilling.lean new file mode 100644 index 0000000000000000000000000000000000000000..99c36f0b114c0f640c10bd2f15c88bea76c525e1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ExplicitFamilyFilling.lean @@ -0,0 +1,92 @@ +import OAI.Topology.CoarseAssembly.ExplicitCircleFamily +import OAI.Topology.CoarseAssembly.CompactFamilyHomotopy +import OAI.Topology.CoarseAssembly.FamilyFilling + +namespace OAI + +/-! # Filling the explicit circle family without countable-additivity inputs -/ + +noncomputable section + +namespace CoarseAssembly + +open Rips Analytic +open scoped ZeroAtInfty + +theorem windingCircleCycle_representation_const (z : ℂ) : + windingCircleCycle.representation (ContinuousMap.const WindingCircle z) = + z • (1 : End circleSequenceSpace) := by + change circleRepresentation (ContinuousMap.const Circle z) = _ + have he : (ContinuousMap.const Circle z : C(Circle, ℂ)) = z • 1 := by + ext x + simp + rw [he, map_smul, map_one] + +variable {Y : ℕ → Type} [∀ j, TopologicalSpace (Y j)] [∀ j, T2Space (Y j)] + +theorem circleFamily_constant_degenerate (y : ∀ j, Y j) : + (circleSigmaCycle.precomp (pullback + (compactFamilyMap (fun j => ContinuousMap.const WindingCircle (y j))))).Degenerate := by + dsimp only [OddCycle.Degenerate, OddCycle.precomp, circleSigmaCycle, sigmaCycle] + constructor + · intro f + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + have he : sigmaFunctionRestriction CircleFamily j + (pullback (compactFamilyMap (fun k => ContinuousMap.const WindingCircle (y k))) f) = + ContinuousMap.const WindingCircle (f ⟨j, y j⟩) := by + ext z + rfl + change windingCircleCycle.operator + (windingCircleCycle.representation (sigmaFunctionRestriction CircleFamily j + (pullback (compactFamilyMap (fun k => ContinuousMap.const WindingCircle (y k))) f)) (x j)) - + windingCircleCycle.representation (sigmaFunctionRestriction CircleFamily j + (pullback (compactFamilyMap (fun k => ContinuousMap.const WindingCircle (y k))) f)) + (windingCircleCycle.operator (x j)) = 0 + rw [he, windingCircleCycle_representation_const] + change windingCircleCycle.operator ((f ⟨j, y j⟩) • (x j)) - + (f ⟨j, y j⟩) • windingCircleCycle.operator (x j) = 0 + rw [map_smul, sub_self] + constructor + · intro f + have hs := sigmaCycleOperator_sq CircleFamily (fun _ => windingCircleCycle) 1 (by norm_num) + (fun _ => windingCircleCycle_norm) (fun _ => negativeCircleOperator_sq) + rw [hs, sub_self, zero_mul] + · intro f + have hs := sigmaCycleOperator_selfAdjoint CircleFamily (fun _ => windingCircleCycle) 1 + (by norm_num) (fun _ => windingCircleCycle_norm) (fun _ => negativeCircleOperator_selfAdjoint) + rw [hs.star_eq, sub_self, zero_mul] + +theorem explicitCircleFamily_constant_zero (y : ∀ j, Y j) : + pushforward (compactFamilyMap (fun j => ContinuousMap.const WindingCircle (y j))) + explicitCircleFamily = 0 := by + change precomp _ (cycleClass C₀(Sigma CircleFamily, ℂ) circleSigmaCycle) = 0 + rw [precomp_cycleClass] + exact degenerate_zero _ (circleFamily_constant_degenerate y) + +theorem explicitCircleFamily_filled_zero (o : ∀ j, Disc j) + (p : ∀ j, (discGraph j).Walk (o j) (o j)) : + pushforward (compactFamilyMap (filledBoundaryLoops o p)) explicitCircleFamily = 0 := by + have h (j : ℕ) : (filledBoundaryLoops o p j).Homotopy + (ContinuousMap.const WindingCircle (filledDiscCenter j)) := by + have hc : (filledDiscContraction j).center = filledDiscCenter j := rfl + simpa only [ContinuousMap.id_comp, ContinuousMap.const_comp, hc] using + (filledDiscContraction j).homotopy.compContinuousMap (filledBoundaryLoops o p j) + rw [compactFamily_homotopy_invariance _ _ h] + exact explicitCircleFamily_constant_zero _ + +theorem explicitBaseBoundaryFamily_zero (o : ∀ j, Disc j) + (p : ∀ j, (discGraph j).Walk (o j) (o j)) : + letI := separatedMetric o + pushforward (ripsFamilyMap o 1 (baseBoundaryLoops o p)) explicitCircleFamily = 0 := by + let := separatedMetric o + rw [boundaryFamily_factors o p, pushforward_comp, AddMonoidHom.comp_apply, + explicitCircleFamily_filled_zero o p, map_zero] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ExplicitPersistence.lean b/lean/OAI/Topology/CoarseAssembly/ExplicitPersistence.lean new file mode 100644 index 0000000000000000000000000000000000000000..7210d183aa6f05160cf576d5c2a0ee84a887ccee --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ExplicitPersistence.lean @@ -0,0 +1,102 @@ +import OAI.Topology.CoarseAssembly.ExplicitCircleFamily +import OAI.Topology.CoarseAssembly.ConcretePersistence + +namespace OAI + +/-! # Persistence of the explicit circle cycle in the actual graph union -/ + +noncomputable section + +namespace CoarseAssembly + +open Topology Congruence Rips Analytic + +theorem ripsFamily_restriction_class {V Z : ℕ → Type} + [∀ j, MetricSpace (V j)] [∀ j, Fintype (V j)] + [∀ j, TopologicalSpace (Z j)] [∀ j, CompactSpace (Z j)] [∀ j, T2Space (Z j)] + (o : ∀ j, V j) (r : ℝ) (γ : ∀ j, C(Z j, Point (V j) r)) + (j : ℕ) (hj : r < j) (a : LocallyFiniteK1 (Sigma Z)) : + letI := separatedMetric o + restrictComponent (separatedRipsEmbedding o r j) (separatedRipsEmbedding_open o r j hj) + (pushforward (ripsFamilyMap o r γ) a) = + pushforward (compactMap (γ j)) + (restrictComponent (sigmaComponent Z j) (sigmaComponent_open Z j) a) := by + let := separatedMetric o + exact DFunLike.congr_fun (restrictComponent_natural + (sigmaComponent Z j) (sigmaComponent_open Z j) + (separatedRipsEmbedding o r j) (separatedRipsEmbedding_open o r j hj) + (ripsFamilyMap o r γ) (compactMap (γ j)) (fun _ => rfl) + (ripsFamily_component_preimage o r γ j)) a + +local instance explicitPersistenceComponent (j : ℕ) : MetricSpace (FiberVertex j) := + componentMetric elementaryMoves chosenHolonomyUnit j +local instance explicitPersistenceMetric : MetricSpace FiberedUnion := + componentUnionMetric elementaryMoves chosenHolonomyUnit + +def explicitFiberLoops (r : ℕ) (hr : 1 ≤ r) := + fiberedBoundaryLoops elementaryMoves + (hexagonalBoundaryWalks.fiberWalk elementaryMoves chosenHolonomyUnit) r hr + +def explicitFiberStage (r : ℕ) (hr : 1 ≤ r) : + LocallyFiniteK1 (Point FiberedUnion (r : ℝ)) := + pushforward (ripsFamilyMap fiberBoundaryBase r (explicitFiberLoops r hr)) explicitCircleFamily + +theorem explicitFiberStage_coarsen {r s : ℕ} (hr : 1 ≤ r) (hs : 1 ≤ s) (hrs : r ≤ s) : + pushforward (inclusion (by exact_mod_cast hrs)) (explicitFiberStage r hr) = + explicitFiberStage s hs := by + change pushforward _ (pushforward _ explicitCircleFamily) = _ + dsimp only [explicitFiberLoops] + rw [← AddMonoidHom.comp_apply, ← pushforward_comp, + ripsFamilyMap_coarsen fiberBoundaryBase _ _ _ + (fiberedBoundaryLoops_coarsen elementaryMoves + (hexagonalBoundaryWalks.fiberWalk elementaryMoves chosenHolonomyUnit) hr hs hrs)] + rfl + +theorem explicitFiberStage_detected (r : ℕ) (hr : 1 ≤ r) : + ∃ test : LocallyFiniteK1 (Point FiberedUnion (r : ℝ)) →+ ℤ, + test (explicitFiberStage r hr) = 1 := by + obtain ⟨J, hJ⟩ := fiberedGraph_short_loops elementaryMoves (3 * r) + let j := max J (r + 2) + have hj : (r : ℝ) < j := by + have h : r < j := by dsimp [j]; omega + exact_mod_cast h + have hj₂ : 2 ≤ j := by dsimp [j]; omega + have hloop := hJ j (by dsimp [j]; omega) + let c := graphRipsCocycle (fiberedGraph_connected elementaryMoves chosenHolonomyUnit j) + fiberCharge (fun x y _ => latticeCharge_reverse _ _) r hloop + let d := separatedRipsEmbedding fiberBoundaryBase (r : ℝ) j + have hd := separatedRipsEmbedding_open fiberBoundaryBase (r : ℝ) j hj + refine ⟨(provedCircleInput.pairing c.toContinuousMap).comp (restrictComponent d hd), ?_⟩ + change provedCircleInput.pairing c.toContinuousMap + (restrictComponent d hd (explicitFiberStage r hr)) = 1 + rw [explicitFiberStage, ripsFamily_restriction_class fiberBoundaryBase (r : ℝ) + (explicitFiberLoops r hr) j hj, explicitCircleFamily_coordinate] + change provedCircleInput.pairing c.toContinuousMap + (graphLoopClass provedCircleInput + (fiberedGraph_connected elementaryMoves chosenHolonomyUnit j) r hr + (hexagonalBoundaryWalks.fiberWalk elementaryMoves chosenHolonomyUnit j)) = 1 + rw [graph_loop_index provedCircleInput _ fiberCharge + (fun x y _ => latticeCharge_reverse _ _) r hr hloop, + hexagonalBoundaryWalks.fiber_charge_one elementaryMoves chosenHolonomyUnit j hj₂] + +def explicitFiberClass : KX1 FiberedUnion := + (coarsening FiberedUnion).of 1 (explicitFiberStage 1 le_rfl) + +theorem explicitFiberClass_infinite_order (n : ℤ) (hn : n ≠ 0) : + n • explicitFiberClass ≠ 0 := by + let C := coarsening FiberedUnion + let test := fun r hr => (explicitFiberStage_detected r hr).choose + have hdetect : ∀ r (hr : 1 ≤ r), + test r hr (C.map 1 r hr (explicitFiberStage 1 le_rfl)) = 1 := by + intro r hr + change test r hr (pushforward (inclusion (by exact_mod_cast hr)) + (explicitFiberStage 1 le_rfl)) = 1 + rw [explicitFiberStage_coarsen le_rfl hr hr] + exact (explicitFiberStage_detected r hr).choose_spec + exact persistent_multiples_ne_zero C.map 1 (explicitFiberStage 1 le_rfl) test hdetect n hn + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FamilyBoundaryAddition.lean b/lean/OAI/Topology/CoarseAssembly/FamilyBoundaryAddition.lean new file mode 100644 index 0000000000000000000000000000000000000000..07dfb7860a9db90e0eb2e9f2ffbfc2522afa19e1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FamilyBoundaryAddition.lean @@ -0,0 +1,73 @@ +import OAI.Topology.CoarseAssembly.FamilyDecomposition + +namespace OAI + +/-! # Additivity of whole-union coefficient-family boundaries -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + {E F G : ℕ → Type*} + [∀ i, NormedAddCommGroup (E i)] [∀ i, InnerProductSpace ℂ (E i)] [∀ i, CompleteSpace (E i)] + [∀ i, NormedAddCommGroup (F i)] [∀ i, InnerProductSpace ℂ (F i)] [∀ i, CompleteSpace (F i)] + [∀ i, NormedAddCommGroup (G i)] [∀ i, InnerProductSpace ℂ (G i)] [∀ i, CompleteSpace (G i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem coefficientFamilyBoundary_add + (o : ∀ i, Q i) (A : ∀ i, Operator (Q i) (E i)) (B : ∀ i, Operator (Q i) (F i)) + (T : ∀ i, Operator (Q i) (G i)) + (C D K : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) (hK : 0 ≤ K) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) (hT : ∀ i, ‖T i‖ ≤ K) + (r : ℝ) (hr : 0 ≤ r) + (hpA : ∀ i, PropagationLE r (A i)) (hpB : ∀ i, PropagationLE r (B i)) + (hpT : ∀ i, PropagationLE r (T i)) + (hsA : ∀ i, IsSelfAdjoint (A i)) (hsB : ∀ i, IsSelfAdjoint (B i)) (hsT : ∀ i, IsSelfAdjoint (T i)) + (hqA : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) (E i)))) + (hqB : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (Q i) (F i)))) + (hqT : ∀ i, IsCompactOperator (T i * T i - (1 : Operator (Q i) (G i)))) + (L : ∀ i, E i →ₗᵢ[ℂ] G i) (R : ∀ i, F i →ₗᵢ[ℂ] G i) + (hLR : ∀ i, (L i).toContinuousLinearMap.adjoint.comp (R i).toContinuousLinearMap = 0) + (hex : ∀ i, (L i).toContinuousLinearMap.comp (L i).toContinuousLinearMap.adjoint + + (R i).toContinuousLinearMap.comp (R i).toContinuousLinearMap.adjoint = 1) + (hL : ∀ i, (T i).comp (coefficientIsometry (L i)).toContinuousLinearMap = + (coefficientIsometry (L i)).toContinuousLinearMap.comp (A i)) + (hR : ∀ i, (T i).comp (coefficientIsometry (R i)).toContinuousLinearMap = + (coefficientIsometry (R i)).toContinuousLinearMap.comp (B i)) + (U : ∀ i, G i →ₗᵢ[ℂ] H) : + letI := separatedMetric o + coefficientFamilyBoundary o T K hK hT r hr hpT hsT hqT U = + coefficientFamilyBoundary o A C hC hA r hr hpA hsA hqA (fun i => (U i).comp (L i)) + + coefficientFamilyBoundary o B D hD hB r hr hpB hsB hqB (fun i => (U i).comp (R i)) := by + let := separatedMetric o + let UL := fun i => (U i).comp (L i) + let UR := fun i => (U i).comp (R i) + let MT := coefficientFamilyMultiplier o T K hK hT r hr hpT U + let MA := coefficientFamilyMultiplier o A C hC hA r hr hpA UL + let MB := coefficientFamilyMultiplier o B D hD hB r hr hpB UR + have hMTs := coefficientFamilyMultiplier_selfAdjoint o T K hK hT r hr hpT U hsT + have hMAs := coefficientFamilyMultiplier_selfAdjoint o A C hC hA r hr hpA UL hsA + have hMBs := coefficientFamilyMultiplier_selfAdjoint o B D hD hB r hr hpB UR hsB + have hMTd := coefficientFamilyMultiplier_defect o T K hK hT r hr hpT U hsT hqT + have hMAd := coefficientFamilyMultiplier_defect o A C hC hA r hr hpA UL hsA hqA + have hMBd := coefficientFamilyMultiplier_defect o B D hD hB r hr hpB UR hsB hqB + change multiplierBoundaryClass MT hMTs hMTd = + multiplierBoundaryClass MA hMAs hMAd + multiplierBoundaryClass MB hMBs hMBd + exact multiplierBoundaryClass_orthogonalEmbeddings + (familyCoefficientIsometry UL) (familyCoefficientIsometry UR) + (familyCoefficientIsometry_orthogonal U L R hLR) + (blockOperator A C hC hA) (blockOperator B D hD hB) + (blockOperator_selfAdjoint A C hC hA hsA) (blockOperator_selfAdjoint B D hD hB hsB) + MT MA MB hMTs hMAs hMBs hMTd hMAd hMBd + (coefficientFamilyMultiplier_value o A C hC hA r hr hpA UL) + (coefficientFamilyMultiplier_value o B D hD hB r hr hpB UR) + (coefficientFamilyMultiplier_decomposition_value o A B T C D K hC hD hK hA hB hT + r hr hpT L R hex hL hR U) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FamilyCoefficientEmbedding.lean b/lean/OAI/Topology/CoarseAssembly/FamilyCoefficientEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..6756986499b06c5b9c4cfc94e49c5cf798ed6f8c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FamilyCoefficientEmbedding.lean @@ -0,0 +1,103 @@ +import OAI.Topology.CoarseAssembly.CoefficientIsometry +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary +import OAI.Topology.CoarseAssembly.EmbeddingBoundaryComparison + +namespace OAI + +/-! # A single source Hilbert sum for all choices of ample coefficients -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, DecidableEq (Q i)] + {E : ℕ → Type*} [∀ i, NormedAddCommGroup (E i)] + [∀ i, InnerProductSpace ℂ (E i)] [∀ i, CompleteSpace (E i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def familyCoefficientIsometry (V : ∀ i, E i →ₗᵢ[ℂ] H) : + lp (fun i => Module (Q i) (E i)) 2 →ₗᵢ[ℂ] Module (Sigma Q) H := + (flattenEquiv (Q := Q) (H := H)).toLinearIsometry.comp + (blockIsometry (fun i => coefficientIsometry (X := Q i) (V i))) + +omit [∀ i, DecidableEq (Q i)] [∀ i, CompleteSpace (E i)] [CompleteSpace H] in +@[simp] theorem familyCoefficientIsometry_apply (V : ∀ i, E i →ₗᵢ[ℂ] H) + (v : lp (fun i => Module (Q i) (E i)) 2) (i : ℕ) (x : Q i) : + familyCoefficientIsometry V v ⟨i, x⟩ = V i (v i x) := rfl + +omit [∀ i, DecidableEq (Q i)] in +theorem familyCoefficientIsometry_adjoint_apply (V : ∀ i, E i →ₗᵢ[ℂ] H) + (v : Module (Sigma Q) H) (i : ℕ) (x : Q i) : + (familyCoefficientIsometry V).toContinuousLinearMap.adjoint v i x = + (V i).toContinuousLinearMap.adjoint (v ⟨i, x⟩) := by + have he : (familyCoefficientIsometry (Q := Q) V).toContinuousLinearMap = + (flattenEquiv (Q := Q) (H := H)).toLinearIsometry.toContinuousLinearMap.comp + (blockIsometry (fun i => coefficientIsometry (X := Q i) (V i))).toContinuousLinearMap := rfl + have hflat : + (flattenEquiv (Q := Q) (H := H)).toLinearIsometry.toContinuousLinearMap.adjoint = + (flattenEquiv (Q := Q) (H := H)).symm.toLinearIsometry.toContinuousLinearMap := by + exact LinearIsometryEquiv.adjoint_eq_symm (flattenEquiv (Q := Q) (H := H)) + have hadj : (familyCoefficientIsometry (Q := Q) V).toContinuousLinearMap.adjoint = + (blockIsometry (fun i => coefficientIsometry (X := Q i) (V i))).toContinuousLinearMap.adjoint.comp + (flattenEquiv (Q := Q) (H := H)).symm.toLinearIsometry.toContinuousLinearMap := by + rw [he, ContinuousLinearMap.adjoint_comp, hflat] + have hx := congrArg (fun T : Module (Sigma Q) H →L[ℂ] lp (fun i => Module (Q i) (E i)) 2 => + T v i x) hadj + change _ = _ at hx + rw [hx] + change (blockIsometry (fun i => coefficientIsometry (X := Q i) (V i))).toContinuousLinearMap.adjoint + (unflattenVector v) i x = _ + rw [blockIsometry_toCLM, blockOperator_adjoint] + exact coefficientIsometry_adjoint_apply (V i) (rowVector v i) x + +theorem familyEmbeddingTransition_propagation (V W : ∀ i, E i →ₗᵢ[ℂ] H) + [PseudoMetricSpace (Sigma Q)] : + PropagationLE 0 (embeddingTransition (familyCoefficientIsometry (Q := Q) V) + (familyCoefficientIsometry W)) := by + intro x y hxy + have hne : x ≠ y := by rintro rfl; simp at hxy + rcases x with ⟨i, x⟩ + ext h + change familyCoefficientIsometry W + ((familyCoefficientIsometry V).toContinuousLinearMap.adjoint (lp.single 2 y h)) ⟨i, x⟩ = 0 + rw [familyCoefficientIsometry_apply, familyCoefficientIsometry_adjoint_apply] + simp [lp.single_apply, hne] + +omit [∀ i, DecidableEq (Q i)] in +theorem familyCoefficient_extension (V : ∀ i, E i →ₗᵢ[ℂ] H) + (A : ∀ i, Operator (Q i) (E i)) (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (D : ℝ) (hD : 0 ≤ D) (hB : ∀ i, ‖coefficientExtension (V i) (A i)‖ ≤ D) : + isometricExtension (familyCoefficientIsometry V) (blockOperator A C hC hA) = + diagonalFamily (fun i => coefficientExtension (V i) (A i)) D hD hB := by + ext v p + rcases p with ⟨i, x⟩ + have hr : (familyCoefficientIsometry V).toContinuousLinearMap.adjoint v i = + (coefficientIsometry (X := Q i) (V i)).toContinuousLinearMap.adjoint (rowVector v i) := by + apply lp.ext + funext y + rw [familyCoefficientIsometry_adjoint_apply, coefficientIsometry_adjoint_apply] + rfl + change v ⟨i, x⟩ + familyCoefficientIsometry V + ((blockOperator A C hC hA - 1) + ((familyCoefficientIsometry V).toContinuousLinearMap.adjoint v)) ⟨i, x⟩ = + coefficientExtension (V i) (A i) (rowVector v i) x + rw [familyCoefficientIsometry_apply] + simp only [sub_apply, blockOperator_apply, one_apply_eq_self, lp.coeFn_sub, Pi.sub_apply] + rw [hr] + rfl + +omit [∀ i, DecidableEq (Q i)] in +theorem blockOperator_selfAdjoint (A : ∀ i, Operator (Q i) (E i)) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (hs : ∀ i, IsSelfAdjoint (A i)) : + IsSelfAdjoint (blockOperator A C hC hA) := by + change (blockOperator A C hC hA).adjoint = _ + rw [blockOperator_adjoint] + ext v i x + change (A i).adjoint (v i) x = A i (v i) x + rw [show (A i).adjoint = A i from (hs i).star_eq] + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FamilyDecomposition.lean b/lean/OAI/Topology/CoarseAssembly/FamilyDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..72b34fc4edead745e13a46a25f89b41aecd13385 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FamilyDecomposition.lean @@ -0,0 +1,95 @@ +import OAI.Topology.CoarseAssembly.CoefficientFamilyMultiplier +import OAI.Topology.CoarseAssembly.BlockIsometryRelations +import OAI.Topology.CoarseAssembly.IsometricDecomposition +import OAI.Topology.CoarseAssembly.MultiplierOrthogonalEmbeddings + +namespace OAI + +/-! # Orthogonal decomposition of a whole coefficient family -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + {E F G : ℕ → Type*} + [∀ i, NormedAddCommGroup (E i)] [∀ i, InnerProductSpace ℂ (E i)] [∀ i, CompleteSpace (E i)] + [∀ i, NormedAddCommGroup (F i)] [∀ i, InnerProductSpace ℂ (F i)] [∀ i, CompleteSpace (F i)] + [∀ i, NormedAddCommGroup (G i)] [∀ i, InnerProductSpace ℂ (G i)] [∀ i, CompleteSpace (G i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] [∀ i, DecidableEq (Q i)] + [∀ i, CompleteSpace (E i)] [∀ i, CompleteSpace (G i)] [CompleteSpace H] in +theorem familyCoefficientIsometry_comp (U : ∀ i, G i →ₗᵢ[ℂ] H) (V : ∀ i, E i →ₗᵢ[ℂ] G i) : + (familyCoefficientIsometry (Q := Q) U).comp + (blockIsometry (fun i => coefficientIsometry (X := Q i) (V i))) = + familyCoefficientIsometry (fun i => (U i).comp (V i)) := by + ext v p + rcases p with ⟨i, x⟩ + rfl + +omit [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] [∀ i, DecidableEq (Q i)] + [∀ i, CompleteSpace (F i)] in +theorem familyCoefficientIsometry_orthogonal + (U : ∀ i, G i →ₗᵢ[ℂ] H) (L : ∀ i, E i →ₗᵢ[ℂ] G i) (R : ∀ i, F i →ₗᵢ[ℂ] G i) + (hLR : ∀ i, (L i).toContinuousLinearMap.adjoint.comp (R i).toContinuousLinearMap = 0) : + (familyCoefficientIsometry (Q := Q) (fun i => (U i).comp (L i))).toContinuousLinearMap.adjoint.comp + (familyCoefficientIsometry (fun i => (U i).comp (R i))).toContinuousLinearMap = 0 := by + have h := isometry_comp_orthogonal (familyCoefficientIsometry (Q := Q) U) + (blockIsometry (fun i => coefficientIsometry (X := Q i) (L i))) + (blockIsometry (fun i => coefficientIsometry (X := Q i) (R i))) + (blockIsometry_orthogonal _ _ (fun i => coefficientIsometry_orthogonal (L i) (R i) (hLR i))) + simpa only [familyCoefficientIsometry_comp] using h + +theorem coefficientFamilyMultiplier_decomposition_value + (o : ∀ i, Q i) (A : ∀ i, Operator (Q i) (E i)) (B : ∀ i, Operator (Q i) (F i)) + (T : ∀ i, Operator (Q i) (G i)) + (C D K : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) (hK : 0 ≤ K) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) (hT : ∀ i, ‖T i‖ ≤ K) + (r : ℝ) (hr : 0 ≤ r) (hpT : ∀ i, PropagationLE r (T i)) + (L : ∀ i, E i →ₗᵢ[ℂ] G i) (R : ∀ i, F i →ₗᵢ[ℂ] G i) + (hex : ∀ i, (L i).toContinuousLinearMap.comp (L i).toContinuousLinearMap.adjoint + + (R i).toContinuousLinearMap.comp (R i).toContinuousLinearMap.adjoint = 1) + (hL : ∀ i, (T i).comp (coefficientIsometry (L i)).toContinuousLinearMap = + (coefficientIsometry (L i)).toContinuousLinearMap.comp (A i)) + (hR : ∀ i, (T i).comp (coefficientIsometry (R i)).toContinuousLinearMap = + (coefficientIsometry (R i)).toContinuousLinearMap.comp (B i)) + (U : ∀ i, G i →ₗᵢ[ℂ] H) : + letI := separatedMetric o + (coefficientFamilyMultiplier o T K hK hT r hr hpT U).val = + 1 + operatorConjugation (familyCoefficientIsometry (fun i => (U i).comp (L i))) + (blockOperator A C hC hA - 1) + + operatorConjugation (familyCoefficientIsometry (fun i => (U i).comp (R i))) + (blockOperator B D hD hB - 1) := by + let := separatedMetric o + let VL : lp (fun i => Module (Q i) (E i)) 2 →ₗᵢ[ℂ] lp (fun i => Module (Q i) (G i)) 2 := + blockIsometry (fun i => coefficientIsometry (X := Q i) (L i)) + let VR : lp (fun i => Module (Q i) (F i)) 2 →ₗᵢ[ℂ] lp (fun i => Module (Q i) (G i)) 2 := + blockIsometry (fun i => coefficientIsometry (X := Q i) (R i)) + have hext : VL.toContinuousLinearMap.comp VL.toContinuousLinearMap.adjoint + + VR.toContinuousLinearMap.comp VR.toContinuousLinearMap.adjoint = 1 := + blockIsometry_exhaustive _ _ (fun i => coefficientIsometry_exhaustive (L i) (R i) (hex i)) + have hb : blockOperator T K hK hT = operatorConjugation VL (blockOperator A C hC hA) + + operatorConjugation VR (blockOperator B D hD hB) := + blockOperator_decomposition + (fun i => coefficientIsometry (X := Q i) (L i)) + (fun i => coefficientIsometry (X := Q i) (R i)) + (fun i => coefficientIsometry_exhaustive (L i) (R i) (hex i)) + A B T C D K hC hD hK hA hB hT hL hR + have hVL : (familyCoefficientIsometry U).comp VL = + familyCoefficientIsometry (Q := Q) (fun i => (U i).comp (L i)) := + familyCoefficientIsometry_comp U L + have hVR : (familyCoefficientIsometry U).comp VR = + familyCoefficientIsometry (Q := Q) (fun i => (U i).comp (R i)) := + familyCoefficientIsometry_comp U R + rw [coefficientFamilyMultiplier_value, hb] + have h := isometricExtension_decomposition (familyCoefficientIsometry (Q := Q) U) VL VR hext + (blockOperator A C hC hA) (blockOperator B D hD hB) + simpa only [hVL, hVR] using h + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FamilyEmbeddingIndependence.lean b/lean/OAI/Topology/CoarseAssembly/FamilyEmbeddingIndependence.lean new file mode 100644 index 0000000000000000000000000000000000000000..253bdfd1ffe38222c3d2e2e5427c6e8c04d5ed06 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FamilyEmbeddingIndependence.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.FamilyCoefficientEmbedding + +namespace OAI + +/-! # Ample coefficient choices do not affect a whole-family Roe boundary -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + {E : ℕ → Type*} [∀ i, NormedAddCommGroup (E i)] + [∀ i, InnerProductSpace ℂ (E i)] [∀ i, CompleteSpace (E i)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +/-- Boundary of a family after specified coefficient embeddings. -/ +def coefficientFamilyBoundary (o : ∀ i, Q i) (A : ∀ i, Operator (Q i) (E i)) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (r : ℝ) (hr : 0 ≤ r) (hp : ∀ i, PropagationLE r (A i)) + (hs : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) (E i)))) + (V : ∀ i, E i →ₗᵢ[ℂ] H) : + letI := separatedMetric o + OperatorKTheory.K1 (algebra (X := Sigma Q) (H := H)) := by + let := separatedMetric o + exact separatedFamilyBoundary (H := H) o (fun i => coefficientExtension (V i) (A i)) + (C + 2) (by linarith) + (fun i => (coefficientExtension_norm_le (V i) (A i)).trans (by linarith [hA i])) + r hr (fun i => coefficientExtension_propagation (V i) hr (hp i)) + (fun i => coefficientExtension_selfAdjoint (V i) (A i) (hs i)) + (fun i => coefficientExtension_square_compact (V i) (A i) (hsq i)) + +/-- This compares whole-union classes directly, without passing to component K₁ classes. -/ +theorem coefficientFamilyBoundary_independent (o : ∀ i, Q i) + (A : ∀ i, Operator (Q i) (E i)) (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (r : ℝ) (hr : 0 ≤ r) (hp : ∀ i, PropagationLE r (A i)) + (hs : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) (E i)))) + (V W : ∀ i, E i →ₗᵢ[ℂ] H) : + letI := separatedMetric o + coefficientFamilyBoundary o A C hC hA r hr hp hs hsq V = + coefficientFamilyBoundary o A C hC hA r hr hp hs hsq W := by + let := separatedMetric o + let AV := fun i => coefficientExtension (V i) (A i) + let AW := fun i => coefficientExtension (W i) (A i) + have hC' : 0 ≤ C + 2 := by linarith + have hAV : ∀ i, ‖AV i‖ ≤ C + 2 := fun i => + (coefficientExtension_norm_le (V i) (A i)).trans (by linarith [hA i]) + have hAW : ∀ i, ‖AW i‖ ≤ C + 2 := fun i => + (coefficientExtension_norm_le (W i) (A i)).trans (by linarith [hA i]) + have hpV : ∀ i, PropagationLE r (AV i) := fun i => + coefficientExtension_propagation (V i) hr (hp i) + have hpW : ∀ i, PropagationLE r (AW i) := fun i => + coefficientExtension_propagation (W i) hr (hp i) + have hsV : ∀ i, IsSelfAdjoint (AV i) := fun i => + coefficientExtension_selfAdjoint (V i) (A i) (hs i) + have hsW : ∀ i, IsSelfAdjoint (AW i) := fun i => + coefficientExtension_selfAdjoint (W i) (A i) (hs i) + have hsqV : ∀ i, IsCompactOperator (AV i * AV i - (1 : Operator (Q i) H)) := fun i => + coefficientExtension_square_compact (V i) (A i) (hsq i) + have hsqW : ∀ i, IsCompactOperator (AW i * AW i - (1 : Operator (Q i) H)) := fun i => + coefficientExtension_square_compact (W i) (A i) (hsq i) + let F := separatedFamilyMultiplier (H := H) o AV (C + 2) hC' hAV r hr hpV + let G := separatedFamilyMultiplier (H := H) o AW (C + 2) hC' hAW r hr hpW + have hFs := separatedFamilyMultiplier_selfAdjoint o AV (C + 2) hC' hAV r hr hpV hsV + have hGs := separatedFamilyMultiplier_selfAdjoint o AW (C + 2) hC' hAW r hr hpW hsW + have hFd := diagonalFamily_square_mem_roe o AV (C + 2) hC' hAV r hr hpV hsV hsqV + have hGd := diagonalFamily_square_mem_roe o AW (C + 2) hC' hAW r hr hpW hsW hsqW + change multiplierBoundaryClass F hFs hFd = multiplierBoundaryClass G hGs hGd + exact multiplierBoundaryClass_embedding (familyCoefficientIsometry V) (familyCoefficientIsometry W) + (blockOperator A C hC hA) (blockOperator_selfAdjoint A C hC hA hs) F G + (separatedFamilyMultiplier_selfAdjoint o AV (C + 2) hC' hAV r hr hpV hsV) + (separatedFamilyMultiplier_selfAdjoint o AW (C + 2) hC' hAW r hr hpW hsW) + (diagonalFamily_square_mem_roe o AV (C + 2) hC' hAV r hr hpV hsV hsqV) + (diagonalFamily_square_mem_roe o AW (C + 2) hC' hAW r hr hpW hsW hsqW) + (familyCoefficient_extension V A C hC hA (C + 2) hC' hAV).symm + (familyCoefficient_extension W A C hC hA (C + 2) hC' hAW).symm + (finitePropagation_multiplier (separatedMetric_closedBall_finite o) le_rfl + (familyEmbeddingTransition_propagation V W)) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FamilyFilling.lean b/lean/OAI/Topology/CoarseAssembly/FamilyFilling.lean new file mode 100644 index 0000000000000000000000000000000000000000..eb2d56d61253007c1712c5ceeef78379d41fea38 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FamilyFilling.lean @@ -0,0 +1,57 @@ +import OAI.Topology.CoarseAssembly.FilledWalks +import OAI.Topology.CoarseAssembly.CompactFamilyMap +import OAI.Topology.CoarseAssembly.RipsFamilyMap + +namespace OAI + +/-! # The entire family of base loops vanishes through its actual filling + +Both arrows through the disjoint union of compact polygons are constructed +proper maps. The vanishing follows only from the specified published compact +homotopy and countable-additivity inputs. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Rips Analytic + +variable (o : ∀ j, Disc j) (p : ∀ j, (discGraph j).Walk (o j) (o j)) + +def baseBoundaryLoops (j : ℕ) : C(WindingCircle, Point (Disc j) 1) := + loopCircle (walkPath (by norm_num) discEdgeBound (p j)) + +def filledBoundaryLoops (j : ℕ) : C(WindingCircle, FilledDisc j) := + loopCircle (filledWalk (p j)) + +theorem boundaryFamily_factors : + letI := separatedMetric o + ripsFamilyMap o 1 (baseBoundaryLoops o p) = + (ripsFamilyMap o 1 filledToRips).comp (compactFamilyMap (filledBoundaryLoops o p)) := by + let := separatedMetric o + apply CocompactMap.ext + rintro ⟨j, z⟩ + change separatedRipsMap o 1 j (baseBoundaryLoops o p j z) = + separatedRipsMap o 1 j (filledToRips j (filledBoundaryLoops o p j z)) + exact congrArg (separatedRipsMap o 1 j) (DFunLike.congr_fun (filledToRips_loop (p j)) z).symm + +/-- Every class pushed along this family of closed base walks vanishes +already at scale one, before passage to the coarse direct limit. -/ +theorem baseBoundaryFamily_zero (input : PublishedCompactHomotopyInput) + (hadd : CountableAdditivityInput FilledDisc) + (a : LocallyFiniteK1 (Sigma (fun _ : ℕ => WindingCircle))) : + letI := separatedMetric o + pushforward (ripsFamilyMap o 1 (baseBoundaryLoops o p)) a = 0 := by + let := separatedMetric o + let := contracted_family_odd_group_zero input FilledDisc filledDiscContraction hadd + rw [boundaryFamily_factors o p, pushforward_comp, AddMonoidHom.comp_apply] + have hzero : pushforward (compactFamilyMap (filledBoundaryLoops o p)) a = 0 := + Subsingleton.elim _ _ + rw [hzero, map_zero] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiberConnected.lean b/lean/OAI/Topology/CoarseAssembly/FiberConnected.lean new file mode 100644 index 0000000000000000000000000000000000000000..c190171b70cad61ff6776008a502764452dd66b3 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiberConnected.lean @@ -0,0 +1,63 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.DiscConnected +import OAI.Topology.CoarseAssembly.PathFiberOperators + +namespace OAI + +/-! # Connectivity of the finite fibered graphs + +Transport from a singleton boundary fiber reaches every vertex: its image +is the normalized constant vector, which has no zero coordinate. Thus +connectivity does not require an additional Cayley-generation assumption. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +@[simp] theorem discBoundaryBase_depth (j : ℕ) : + discDepth j (discBoundaryBase j) = 0 := by + simp [discDepth, discBoundaryBase, latticeRadius] + +private theorem constant_coordinate_ne_zero (k : ℕ) (q : Quotient k) : + fiberConstant (Quotient k) (1 : ℂ) q ≠ 0 := by + have hc : (0 : ℝ) < Fintype.card (Quotient k) := by exact_mod_cast Fintype.card_pos + have hn : fiberNormalization (Quotient k) ≠ 0 := + inv_ne_zero (ne_of_gt (Real.sqrt_pos.mpr hc)) + simpa only [fiberConstant_apply, smul_eq_mul, mul_one, ne_eq, Complex.ofReal_eq_zero] using hn + +theorem fiberBoundary_reaches (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} (x : FiberVertex j) : + (fiberedGraph S t j).Reachable (fiberBoundaryBase j) x := by + classical + have hsub : Subsingleton (Quotient (discDepth j (discBoundaryBase j))) := by + rw [discBoundaryBase_depth] + infer_instance + let : Unique (Quotient (discDepth j (discBoundaryBase j))) := + ⟨⟨1⟩, fun q => hsub.elim q 1⟩ + have hc : fiberConstant (Quotient (discDepth j (discBoundaryBase j))) (1 : ℂ) = + lp.single 2 1 1 := by + apply lp.ext + funext q + simp [fiberConstant_apply, lp.single_apply, hsub.elim q 1] + obtain ⟨p⟩ := discGraph_connected j (discBoundaryBase j) x.1 + obtain ⟨O, hnorm, hconst, hsupp⟩ := exists_base_walk_operator S t p + have hn : O (lp.single 2 1 1) x.2 ≠ 0 := by + rw [← hc, hconst] + exact constant_coordinate_ne_zero _ _ + obtain ⟨w, hw⟩ := hsupp 1 x.2 hn + exact ⟨w⟩ + +theorem fiberedGraph_connected (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) (j : ℕ) : + (fiberedGraph S t j).Connected where + preconnected x y := + (fiberBoundary_reaches S t x).symm.trans (fiberBoundary_reaches S t y) + nonempty := ⟨fiberBoundaryBase j⟩ + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiberConstants.lean b/lean/OAI/Topology/CoarseAssembly/FiberConstants.lean new file mode 100644 index 0000000000000000000000000000000000000000..cb1e4bda7645be641eaf325df380258268e17233 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiberConstants.lean @@ -0,0 +1,69 @@ +import OAI.Topology.CoarseAssembly.BlockOperators +import Mathlib.Analysis.InnerProductSpace.l2Space + +namespace OAI + +/-! # The normalized constant subspace of a finite fiber + +The fiber embedding sends `h` to the constant vector `|Q|⁻¹ᐟ² h`. +It is an actual linear isometry, including for singleton boundary fibers. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable (Q : Type*) [Fintype Q] +variable {H : Type*} [NormedAddCommGroup H] [NormedSpace ℂ H] + +def fiberNormalization : ℝ := (Real.sqrt (Fintype.card Q))⁻¹ + +theorem fiberNormalization_nonneg : 0 ≤ fiberNormalization Q := by + exact inv_nonneg.mpr (Real.sqrt_nonneg _) + +theorem fiberNormalization_sq [Nonempty Q] : + (Fintype.card Q : ℝ) * fiberNormalization Q ^ 2 = 1 := by + have hn : (0 : ℝ) < Fintype.card Q := by exact_mod_cast Fintype.card_pos + unfold fiberNormalization + rw [inv_pow, Real.sq_sqrt hn.le] + exact mul_inv_cancel₀ (ne_of_gt hn) + +def fiberConstant (h : H) : lp (fun _ : Q => H) 2 := + ⟨fun _ => (fiberNormalization Q : ℂ) • h, Memℓp.all _⟩ + +@[simp] theorem fiberConstant_apply (h : H) (q : Q) : + fiberConstant Q h q = (fiberNormalization Q : ℂ) • h := rfl + +theorem fiberConstant_norm [Nonempty Q] (h : H) : ‖fiberConstant Q h‖ = ‖h‖ := by + have hs := lp.norm_rpow_eq_tsum (p := 2) (by norm_num) (fiberConstant Q h) + have hs' : ‖fiberConstant Q h‖ ^ 2 = + (Fintype.card Q : ℝ) * (fiberNormalization Q * ‖h‖) ^ 2 := by + simpa [Real.rpow_two, norm_smul, Complex.norm_real, Real.norm_eq_abs, + abs_of_nonneg (fiberNormalization_nonneg Q), tsum_fintype] using hs + have hn := fiberNormalization_sq Q + have heq : ‖fiberConstant Q h‖ ^ 2 = ‖h‖ ^ 2 := by + rw [mul_pow, ← mul_assoc, hn, one_mul] at hs' + exact hs' + nlinarith [norm_nonneg (fiberConstant Q h), norm_nonneg h] + +def fiberConstantIsometry [Nonempty Q] : H →ₗᵢ[ℂ] lp (fun _ : Q => H) 2 where + toFun := fiberConstant Q + map_add' x y := by + apply lp.ext + funext q + exact smul_add (fiberNormalization Q : ℂ) x y + map_smul' a x := by + apply lp.ext + funext q + exact smul_comm (fiberNormalization Q : ℂ) a x + norm_map' := fiberConstant_norm Q + +/-- Singleton boundary fibers have normalization one. -/ +@[simp] theorem fiberNormalization_of_unique [Unique Q] : fiberNormalization Q = 1 := by + simp [fiberNormalization] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiberDegree.lean b/lean/OAI/Topology/CoarseAssembly/FiberDegree.lean new file mode 100644 index 0000000000000000000000000000000000000000..eafbeec0c4bc41ac7736bf9165a34db87c0569f2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiberDegree.lean @@ -0,0 +1,167 @@ +import OAI.Topology.CoarseAssembly.FiberedGraph +import OAI.Topology.CoarseAssembly.CongruenceFibers +import OAI.Topology.CoarseAssembly.BoundedGeometry + +namespace OAI + +/-! # A uniform degree bound for the finite fibered graphs + +A neighbor is encoded by its base vertex, one integral left move, and nine +binary digits. The digits distinguish children in a successive congruence +fiber; at equal or smaller depth the reduced equation already determines +the target. The resulting bound is independent of the disc radius. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +abbrev FiberBits := Fin 3 → Fin 3 → Fin 2 + +def fiberBits : (k : ℕ) → Quotient k → FiberBits + | 0, _ => fun _ _ => 0 + | k + 1, q => matrixTopBits k q + +def baseNeighbors {j : ℕ} (u : Disc j) : Finset (Disc j) := by + classical + exact Finset.univ.filter (fun v => v = u ∨ (discGraph j).Adj u v) + +@[simp] theorem mem_baseNeighbors {j : ℕ} (u v : Disc j) : + v ∈ baseNeighbors u ↔ v = u ∨ (discGraph j).Adj u v := by + classical + simp [baseNeighbors] + +theorem card_baseNeighbors_le {j : ℕ} (u : Disc j) : (baseNeighbors u).card ≤ 7 := by + classical + have himage : (baseNeighbors u).image Subtype.val ⊆ insert u.val (latticeNeighbors u.val) := by + intro v hv + obtain ⟨w, hw, rfl⟩ := Finset.mem_image.mp hv + rcases (mem_baseNeighbors u w).mp hw with hw | hw + · subst w; exact Finset.mem_insert_self _ _ + · exact Finset.mem_insert_of_mem ((mem_latticeNeighbors_iff _ _).mpr hw) + calc + (baseNeighbors u).card = ((baseNeighbors u).image Subtype.val).card := + (Finset.card_image_of_injective _ Subtype.val_injective).symm + _ ≤ (insert u.val (latticeNeighbors u.val)).card := Finset.card_le_card himage + _ ≤ (latticeNeighbors u.val).card + 1 := Finset.card_insert_le _ _ + _ ≤ 7 := by have := card_latticeNeighbors_le u.val; omega + +private theorem fiberBits_injective {k l : ℕ} (h : l = k + 1) + (q r : Quotient l) (he : quotientMap (by omega : k ≤ l) q = + quotientMap (by omega : k ≤ l) r) (hb : fiberBits l q = fiberBits l r) : q = r := by + subst l + exact quotient_fiber_code_injective k he hb + +private theorem target_eq_of_same_code {t : ℤ_[2]ˣ} + {j : ℕ} (x : FiberVertex j) (v : Disc j) (q r : Quotient (discDepth j v)) + (s : ArithmeticGroup) + (hp : x.1 = v ∨ (discGraph j).Adj x.1 v ∧ s = 1) + (hq : ∀ m (hx : m ≤ discDepth j x.1) (hv : m ≤ discDepth j v), + quotientMap hv q = reduce m s * quotientMap hx x.2 * + holonomy t m ^ latticeCharge x.1.val v.val) + (hr : ∀ m (hx : m ≤ discDepth j x.1) (hv : m ≤ discDepth j v), + quotientMap hv r = reduce m s * quotientMap hx x.2 * + holonomy t m ^ latticeCharge x.1.val v.val) + (hbits : fiberBits (discDepth j v) q = fiberBits (discDepth j v) r) : q = r := by + by_cases hvx : discDepth j v ≤ discDepth j x.1 + · have he := (hq _ hvx le_rfl).trans (hr _ hvx le_rfl).symm + simpa only [quotientMap_self] using he + · have hdepth : discDepth j v = discDepth j x.1 + 1 := by + rcases hp with hp | ⟨hp, hs⟩ + · subst v; omega + · have := discDepth_adj hp + rw [abs_le] at this + omega + have he := (hq _ le_rfl (by omega)).trans (hr _ le_rfl (by omega)).symm + exact fiberBits_injective hdepth q r he hbits + +private def neighborMove {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + (x : FiberVertex j) (y : {y // (fiberedGraph S t j).Adj x y}) : ArithmeticGroup := + y.property.2.choose + +private theorem neighborMove_spec {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + (x : FiberVertex j) (y : {y // (fiberedGraph S t j).Adj x y}) : + neighborMove x y ∈ symmetricMoves S ∧ + (x.1 = y.val.1 ∨ (discGraph j).Adj x.1 y.val.1 ∧ neighborMove x y = 1) ∧ + ∀ l (hx : l ≤ discDepth j x.1) (hy : l ≤ discDepth j y.val.1), + fiberCoordinate y.val hy = reduce l (neighborMove x y) * fiberCoordinate x hx * + holonomy t l ^ fiberCharge x y.val := y.property.2.choose_spec + +private def neighborCode {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + (x : FiberVertex j) (y : {y // (fiberedGraph S t j).Adj x y}) : + {v // v ∈ baseNeighbors x.1} × {s // s ∈ symmetricMoves S} × FiberBits := by + refine ⟨⟨y.val.1, ?_⟩, ⟨neighborMove x y, (neighborMove_spec x y).1⟩, + fiberBits _ y.val.2⟩ + apply (mem_baseNeighbors _ _).mpr + exact ((neighborMove_spec x y).2.1).elim (fun h => Or.inl h.symm) (fun h => Or.inr h.1) + +private theorem neighborCode_injective {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + (x : FiberVertex j) : Function.Injective (neighborCode (S := S) (t := t) x) := by + intro y z he + have hb : y.val.1 = z.val.1 := congrArg (fun c => c.1.val) he + have hs : neighborMove x y = neighborMove x z := congrArg (fun c => c.2.1.val) he + have hc : fiberBits _ y.val.2 = fiberBits _ z.val.2 := congrArg (fun c => c.2.2) he + apply Subtype.ext + rcases y with ⟨⟨v, q⟩, hy⟩ + rcases z with ⟨⟨w, r⟩, hz⟩ + dsimp only at hb + subst w + apply congrArg (Sigma.mk v) + apply target_eq_of_same_code x v q r (neighborMove x ⟨⟨v, q⟩, hy⟩) + (neighborMove_spec x ⟨⟨v, q⟩, hy⟩).2.1 + · exact (neighborMove_spec x ⟨⟨v, q⟩, hy⟩).2.2 + · simpa only [hs, fiberCoordinate, fiberCharge] using (neighborMove_spec x ⟨⟨v, r⟩, hz⟩).2.2 + · exact hc + +/-- A bound uniform in the component and in the chosen vertex. -/ +theorem card_fibered_neighbors_le (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} (x : FiberVertex j) : + Nat.card {y // (fiberedGraph S t j).Adj x y} ≤ + 7 * (symmetricMoves S).card * 2 ^ 9 := by + classical + rw [Nat.card_eq_fintype_card] + have h := Fintype.card_le_of_injective _ (neighborCode_injective (S := S) (t := t) x) + simp only [Fintype.card_prod, Fintype.card_coe, Fintype.card_fun, + Fintype.card_fin, FiberBits] at h + calc + _ ≤ (baseNeighbors x.1).card * ((symmetricMoves S).card * (2 ^ 3) ^ 3) := h + _ ≤ 7 * ((symmetricMoves S).card * (2 ^ 3) ^ 3) := + Nat.mul_le_mul_right _ (card_baseNeighbors_le x.1) + _ = _ := by ring + +def fiberedNeighbors (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) {j : ℕ} + (x : FiberVertex j) : Finset (FiberVertex j) := by + classical + exact Finset.univ.filter (fun y => (fiberedGraph S t j).Adj x y) + +@[simp] theorem mem_fiberedNeighbors (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} (x y : FiberVertex j) : + y ∈ fiberedNeighbors S t x ↔ (fiberedGraph S t j).Adj x y := by + classical + simp [fiberedNeighbors] + +theorem card_fiberedNeighbors_le (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} (x : FiberVertex j) : + (fiberedNeighbors S t x).card ≤ 7 * (symmetricMoves S).card * 2 ^ 9 := by + classical + have h := card_fibered_neighbors_le S t x + simpa only [Nat.card_eq_fintype_card, Fintype.card_subtype, + fiberedNeighbors] using h + +/-- Uniform bounded geometry in the intrinsic graph distance. -/ +theorem fiberedGraph_ball_bound (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} (x : FiberVertex j) (r : ℕ) : + Set.ncard {y | (fiberedGraph S t j).edist x y ≤ (r : ℕ∞)} ≤ + (7 * (symmetricMoves S).card * 2 ^ 9 + 1) ^ r := by + classical + exact ncard_edist_ball_le (fiberedNeighbors S t) _ + (fun x y h => (mem_fiberedNeighbors S t x y).mpr h) + (card_fiberedNeighbors_le S t) x r + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiberEmbedding.lean b/lean/OAI/Topology/CoarseAssembly/FiberEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..8bd000d14c256133a739d939cb6dd8c33ae71363 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiberEmbedding.lean @@ -0,0 +1,65 @@ +import OAI.Topology.CoarseAssembly.HilbertSum +import OAI.Topology.CoarseAssembly.FiberConstants +import OAI.Topology.CoarseAssembly.Conjugation + +namespace OAI + +/-! # The constant-fiber spatial isometry + +This is the actual map from the base Roe module to the fibered Roe module. +On singleton boundary fibers it is exactly the coordinate inclusion. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {I : Type*} (Q : I → Type*) [∀ i, Fintype (Q i)] [∀ i, Nonempty (Q i)] +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def fiberEmbedding : lp (fun _ : I => H) 2 →ₗᵢ[ℂ] lp (fun _ : Sigma Q => H) 2 := + flattenIsometry.comp (blockIsometry (fun i => fiberConstantIsometry (Q i))) + +omit [CompleteSpace H] in +@[simp] theorem fiberEmbedding_apply (x : lp (fun _ : I => H) 2) (i : I) (q : Q i) : + fiberEmbedding Q x ⟨i, q⟩ = (fiberNormalization (Q i) : ℂ) • x i := rfl + +omit [CompleteSpace H] in +theorem fiberEmbedding_singleton [DecidableEq I] [DecidableEq (Sigma Q)] + (i : I) [Subsingleton (Q i)] (q : Q i) (h : H) : + fiberEmbedding Q (lp.single 2 i h) = lp.single 2 ⟨i, q⟩ h := by + let : Unique (Q i) := ⟨⟨q⟩, fun x => Subsingleton.elim x q⟩ + apply lp.ext + funext z + rcases z with ⟨j, r⟩ + by_cases hji : j = i + · subst j + have hqr : r = q := Subsingleton.elim _ _ + subst r + simp [fiberEmbedding_apply] + · have hz : (⟨j, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := fun h => hji (congrArg Sigma.fst h) + simp [fiberEmbedding_apply, hji, hz] + +def fiberProjection : lp (fun _ : Sigma Q => H) 2 →L[ℂ] lp (fun _ : Sigma Q => H) 2 := + (fiberEmbedding Q).toContinuousLinearMap.comp (fiberEmbedding Q).toContinuousLinearMap.adjoint + +theorem fiberProjection_idempotent : + fiberProjection (H := H) Q * fiberProjection Q = fiberProjection Q := by + ext x + simp [fiberProjection] + +theorem fiberProjection_selfAdjoint : star (fiberProjection (H := H) Q) = fiberProjection Q := by + simp [fiberProjection, ContinuousLinearMap.star_eq_adjoint, + ContinuousLinearMap.adjoint_comp] + +theorem fiberProjection_norm_le : ‖fiberProjection (H := H) Q‖ ≤ 1 := by + apply (ContinuousLinearMap.opNorm_comp_le _ _).trans + rw [LinearIsometryEquiv.norm_map] + have hv := (fiberEmbedding (H := H) Q).norm_toContinuousLinearMap_le + nlinarith [norm_nonneg (fiberEmbedding (H := H) Q).toContinuousLinearMap] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiberedGraph.lean b/lean/OAI/Topology/CoarseAssembly/FiberedGraph.lean new file mode 100644 index 0000000000000000000000000000000000000000..b2750b359ac0dbcb6199cd4f1700e801f37e7b1f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiberedGraph.lean @@ -0,0 +1,139 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CongruenceMaps +import OAI.Topology.CoarseAssembly.LatticeCharge +import OAI.Topology.CoarseAssembly.ChosenHolonomy + +namespace OAI + +/-! # The actual finite graph with congruence fibers + +The inter-fiber edge relation is written at the common shallower level. +This uniformly describes the equal-depth, parent and child cases. The +generating set is symmetrized and contains the identity to record pure +base moves in a common list of left/right operations. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +theorem one_mem_symmetricMoves (S : Finset ArithmeticGroup) : 1 ∈ symmetricMoves S := by + simp [symmetricMoves] + +theorem inv_mem_symmetricMoves {S : Finset ArithmeticGroup} {s : ArithmeticGroup} + (h : s ∈ symmetricMoves S) : s⁻¹ ∈ symmetricMoves S := by + simp only [symmetricMoves, Finset.mem_insert, Finset.mem_union, Finset.mem_image] at * + rcases h with h | h | ⟨a, ha, rfl⟩ + · left; simp [h] + · exact Or.inr (Or.inr ⟨s, h, rfl⟩) + · exact Or.inr (Or.inl (by simpa using ha)) + +abbrev fiberLevel {j : ℕ} (x y : FiberVertex j) : ℕ := + min (discDepth j x.1) (discDepth j y.1) + +theorem liftStep_of_common {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + {x y : FiberVertex j} (s : ArithmeticGroup) (hs : s ∈ symmetricMoves S) + (hp : x.1 = y.1 ∨ (discGraph j).Adj x.1 y.1 ∧ s = 1) + (he : fiberCoordinate y (min_le_right _ _) = + reduce (fiberLevel x y) s * fiberCoordinate x (min_le_left _ _) * + holonomy t (fiberLevel x y) ^ fiberCharge x y) : + LiftStep S t x y := by + refine ⟨s, hs, hp, ?_⟩ + intro l hx hy + have hm : l ≤ fiberLevel x y := le_min hx hy + have hred := congrArg (fun q : Quotient (fiberLevel x y) => quotientMap hm q) he + change quotientMap hm (quotientMap (min_le_right _ _) y.2) = + quotientMap hm (reduce (fiberLevel x y) s * + quotientMap (min_le_left _ _) x.2 * holonomy t (fiberLevel x y) ^ fiberCharge x y) + at hred + simpa only [map_mul, map_zpow, quotientMap_comp, quotientMap_reduce, + quotientMap_holonomy, fiberCoordinate] using hred + +theorem liftStep_reverse {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + {x y : FiberVertex j} (h : LiftStep S t x y) : LiftStep S t y x := by + obtain ⟨s, hs, hp, he⟩ := h + refine ⟨s⁻¹, inv_mem_symmetricMoves hs, ?_, ?_⟩ + · rcases hp with hp | ⟨hp, rfl⟩ + · exact Or.inl hp.symm + · exact Or.inr ⟨hp.symm, inv_one⟩ + · intro l hy hx + have hc : fiberCharge y x = -fiberCharge x y := latticeCharge_reverse _ _ + rw [hc, map_inv, zpow_neg, he l hx hy] + group + +theorem fiberedGraph_projects {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + (x y : FiberVertex j) (h : (fiberedGraph S t j).Adj x y) : + x.1.val = y.1.val ∨ triangularGraph.Adj x.1.val y.1.val := by + obtain ⟨s, hs, hp, he⟩ := h.2 + exact hp.elim (fun e => Or.inl (congrArg Subtype.val e)) (fun e => Or.inr e.1) + +/-- An edge has the same left/right description at every lower common level. -/ +theorem liftStep_reduce {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j l : ℕ} + {x y : FiberVertex j} (h : LiftStep S t x y) + (hx : l ≤ discDepth j x.1) (hy : l ≤ discDepth j y.1) : + ∃ s ∈ symmetricMoves S, + fiberCoordinate y hy = reduce l s * fiberCoordinate x hx * + holonomy t l ^ fiberCharge x y := by + obtain ⟨s, hs, hp, he⟩ := h + exact ⟨s, hs, he l hx hy⟩ + +/-- Record every edge of a walk as an integral left move and a ray charge, +after reducing all its coordinates to one common level. -/ +theorem walk_reduced_lift {S : Finset ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ} + {u v : FiberVertex j} (p : (fiberedGraph S t j).Walk u v) (l : ℕ) + (hp : ∀ w ∈ p.support, l ≤ discDepth j w.1) : + ∃ steps : List (ArithmeticGroup × ℤ), + steps.length = p.length ∧ + holonomyCharge steps = walkCharge fiberCharge p ∧ + (∀ s ∈ steps, s.1 ∈ symmetricMoves S ∧ s.2.natAbs ≤ 1) ∧ + holonomyEndpoint (holonomy t l) (reduceSteps l steps) + (fiberCoordinate u (hp u p.start_mem_support)) = + fiberCoordinate v (hp v p.end_mem_support) := by + induction p with + | nil => exact ⟨[], rfl, rfl, by simp, rfl⟩ + | @cons u v w h p ih => + have ht : ∀ z ∈ p.support, l ≤ discDepth j z.1 := + fun z hz => hp z (by simp [hz]) + obtain ⟨s, hs, he⟩ := liftStep_reduce h.2 (hp u (by simp)) + (hp v (by simp)) + obtain ⟨steps, hlen, hcharge, hsteps, hend⟩ := ih ht + refine ⟨(s, fiberCharge u v) :: steps, ?_, ?_, ?_, ?_⟩ + · simpa only [List.length_cons, SimpleGraph.Walk.length_cons] using congrArg (· + 1) hlen + · simp only [holonomyCharge, walkCharge_cons, hcharge] + · intro a ha + rcases List.mem_cons.mp ha with rfl | ha + · refine ⟨hs, ?_⟩ + simp only [fiberCharge, latticeCharge] + split_ifs <;> norm_num + · exact hsteps a ha + · simpa only [reduceSteps, List.map_cons, holonomyEndpoint, ← he] using hend + +/-- The manuscript's small-loop assertion for the actual finite fibered +graphs. The radius estimate supplies a common deep quotient; arithmetic +trace separation then forces the ray charge to vanish. -/ +theorem fiberedGraph_short_loops (S : Finset ArithmeticGroup) (A : ℕ) : + ∃ J : ℕ, ∀ j, J ≤ j → ∀ u : FiberVertex j, + ∀ p : (fiberedGraph S chosenHolonomyUnit j).Walk u u, + p.length ≤ A → walkCharge fiberCharge p = 0 := by + obtain ⟨N, hN, hsep⟩ := chosenHolonomy_short_lifts (symmetricMoves S) A + refine ⟨N + A / 2, ?_⟩ + intro j hj u p hlen + by_contra hc + have hdepth : ∀ w ∈ p.support, N ≤ discDepth j w.1 := by + intro w hw + have hr := charged_walk_all_radius_bound (fun v : FiberVertex j => v.1.val) + (fiberedGraph_projects) p hc hw + have hd := discDepth_int j w.1 + omega + obtain ⟨steps, hstepslen, hcharge, hsteps, hend⟩ := walk_reduced_lift p N hdepth + have hz := hsep N le_rfl (fiberCoordinate u (hdepth u p.start_mem_support)) + steps (hstepslen.trans_le hlen) hsteps hend + exact hc (hcharge ▸ hz) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiberedPersistence.lean b/lean/OAI/Topology/CoarseAssembly/FiberedPersistence.lean new file mode 100644 index 0000000000000000000000000000000000000000..58618bee37f0fc4654144f3b41cc380b8a42d5b8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiberedPersistence.lean @@ -0,0 +1,157 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.FiniteWindingIndex +import OAI.Topology.CoarseAssembly.RipsFamilyRestriction +import OAI.Topology.CoarseAssembly.RipsPathCoarsening +import OAI.Topology.CoarseAssembly.ConcreteSpaces +import OAI.Topology.CoarseAssembly.Persistence + +namespace OAI + +/-! # Persistence in the actual congruence-fiber graph family + +The arithmetic small-loop theorem, finite-component circle index and exact +family restriction are combined here. Boundary walks remain explicit +geometric arguments; they are not labeled as published inputs. The only +published inputs in the resulting detector are the stated circle pairing +and countable first-variable additivity. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +abbrev CircleFamily := fun _ : ℕ => WindingCircle + +def boundaryCircleFamily (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : LocallyFiniteK1 (Sigma CircleFamily) := + familyClass CircleFamily hadd (fun _ => input.fundamental) + +variable (S : Finset ArithmeticGroup) + (boundary : ∀ j, (fiberedGraph S chosenHolonomyUnit j).Walk + (fiberBoundaryBase j) (fiberBoundaryBase j)) + +def fiberedBoundaryLoops (r : ℕ) (hr : 1 ≤ r) : + letI := componentMetric S chosenHolonomyUnit + ∀ j, C(WindingCircle, Point (FiberVertex j) (r : ℝ)) := by + let := componentMetric S chosenHolonomyUnit + intro j + exact loopCircle (walkPath (by positivity) + (graphEdgeBound (fiberedGraph_connected S chosenHolonomyUnit j) r hr) (boundary j)) + +def fiberedBoundaryStage (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) (r : ℕ) (hr : 1 ≤ r) : + letI := componentUnionMetric S chosenHolonomyUnit + LocallyFiniteK1 (Point FiberedUnion (r : ℝ)) := by + let := componentMetric S chosenHolonomyUnit + let := componentUnionMetric S chosenHolonomyUnit + exact pushforward (ripsFamilyMap fiberBoundaryBase r (fiberedBoundaryLoops S boundary r hr)) + (boundaryCircleFamily input hadd) + +theorem fiberedBoundaryLoops_coarsen {r s : ℕ} (hr : 1 ≤ r) (hs : 1 ≤ s) (hrs : r ≤ s) : + letI := componentMetric S chosenHolonomyUnit + ∀ j z, coarsen (by exact_mod_cast hrs) (fiberedBoundaryLoops S boundary r hr j z) = + fiberedBoundaryLoops S boundary s hs j z := by + let := componentMetric S chosenHolonomyUnit + intro j z + have hrs' : (r : ℝ) ≤ (s : ℝ) := by exact_mod_cast hrs + have h := coarsen_loopCircle hrs' (by positivity : (0 : ℝ) ≤ r) + (graphEdgeBound (fiberedGraph_connected S chosenHolonomyUnit j) r hr) (boundary j) + exact DFunLike.congr_fun h z + +theorem fiberedBoundaryStage_coarsen (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) {r s : ℕ} + (hr : 1 ≤ r) (hs : 1 ≤ s) (hrs : r ≤ s) : + letI := componentUnionMetric S chosenHolonomyUnit + pushforward (inclusion (by exact_mod_cast hrs)) + (fiberedBoundaryStage S boundary input hadd r hr) = + fiberedBoundaryStage S boundary input hadd s hs := by + let := componentMetric S chosenHolonomyUnit + let := componentUnionMetric S chosenHolonomyUnit + change (pushforward (inclusion _)) + ((pushforward (ripsFamilyMap fiberBoundaryBase r (fiberedBoundaryLoops S boundary r hr))) + (boundaryCircleFamily input hadd)) = _ + rw [← AddMonoidHom.comp_apply, ← pushforward_comp, + ripsFamilyMap_coarsen fiberBoundaryBase _ _ _ + (fiberedBoundaryLoops_coarsen S boundary hr hs hrs)] + rfl + +/-- Every integer scale has a detector of the same boundary family, using +the proved eventual small-loop theorem for the actual finite graphs. -/ +theorem fiberedBoundaryStage_detected (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (hboundary : ∀ j, 2 ≤ j → walkCharge fiberCharge (boundary j) = 1) + (r : ℕ) (hr : 1 ≤ r) : + letI := componentUnionMetric S chosenHolonomyUnit + ∃ test : LocallyFiniteK1 (Point FiberedUnion (r : ℝ)) →+ ℤ, + test (fiberedBoundaryStage S boundary input hadd r hr) = 1 := by + let := componentMetric S chosenHolonomyUnit + let := componentUnionMetric S chosenHolonomyUnit + obtain ⟨J, hJ⟩ := fiberedGraph_short_loops S (3 * r) + let j := max J (r + 2) + have hj : (r : ℝ) < j := by + have h : r < j := by dsimp [j]; omega + exact_mod_cast h + have hj₂ : 2 ≤ j := by dsimp [j]; omega + have hloop := hJ j (by dsimp [j]; omega) + let c := graphRipsCocycle (fiberedGraph_connected S chosenHolonomyUnit j) fiberCharge + (fun x y _ => latticeCharge_reverse _ _) r hloop + let d := separatedRipsEmbedding fiberBoundaryBase (r : ℝ) j + have hd := separatedRipsEmbedding_open fiberBoundaryBase (r : ℝ) j hj + refine ⟨(input.pairing c.toContinuousMap).comp (restrictComponent d hd), ?_⟩ + change input.pairing c.toContinuousMap + (restrictComponent d hd (fiberedBoundaryStage S boundary input hadd r hr)) = 1 + have hc := ripsFamily_restriction fiberBoundaryBase (r : ℝ) + (fiberedBoundaryLoops S boundary r hr) j hj hadd (fun _ => input.fundamental) + rw [show restrictComponent d hd (fiberedBoundaryStage S boundary input hadd r hr) = + pushforward (compactMap (fiberedBoundaryLoops S boundary r hr j)) input.fundamental + from hc] + change input.pairing c.toContinuousMap + (graphLoopClass input (fiberedGraph_connected S chosenHolonomyUnit j) r hr (boundary j)) = 1 + rw [graph_loop_index input _ fiberCharge (fun x y _ => latticeCharge_reverse _ _) r hr hloop, + hboundary j hj₂] + +def fiberedBoundaryClass (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) : + letI := componentUnionMetric S chosenHolonomyUnit + KX1 FiberedUnion := by + let := componentUnionMetric S chosenHolonomyUnit + exact (coarsening FiberedUnion).of 1 (fiberedBoundaryStage S boundary input hadd 1 le_rfl) + +/-- The same global class has no nonzero integer annihilator. The boundary +walks and their charge-one proofs are geometric arguments still to be +instantiated; the small-loop and analytic restriction bridges are proved. -/ +theorem fiberedBoundaryClass_infinite_order (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (hboundary : ∀ j, 2 ≤ j → walkCharge fiberCharge (boundary j) = 1) + (n : ℤ) (hn : n ≠ 0) : + letI := componentUnionMetric S chosenHolonomyUnit + n • fiberedBoundaryClass S boundary input hadd ≠ 0 := by + let := componentUnionMetric S chosenHolonomyUnit + let C := coarsening FiberedUnion + let test := fun r hr => (fiberedBoundaryStage_detected S boundary input hadd hboundary r hr).choose + have hdetect : ∀ r (hr : 1 ≤ r), + test r hr (C.map 1 r hr (fiberedBoundaryStage S boundary input hadd 1 le_rfl)) = 1 := by + intro r hr + change test r hr (pushforward (inclusion (by exact_mod_cast hr)) + (fiberedBoundaryStage S boundary input hadd 1 le_rfl)) = 1 + rw [fiberedBoundaryStage_coarsen S boundary input hadd le_rfl hr hr] + exact (fiberedBoundaryStage_detected S boundary input hadd hboundary r hr).choose_spec + exact persistent_multiples_ne_zero C.map 1 + (fiberedBoundaryStage S boundary input hadd 1 le_rfl) test hdetect n hn + +theorem fiberedBoundaryClass_rational_ne_zero (input : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (hboundary : ∀ j, 2 ≤ j → walkCharge fiberCharge (boundary j) = 1) : + letI := componentUnionMetric S chosenHolonomyUnit + (1 : ℚ) ⊗ₜ[ℤ] fiberedBoundaryClass S boundary input hadd ≠ 0 := by + let := componentUnionMetric S chosenHolonomyUnit + exact rationalization_ne_zero _ + (fiberedBoundaryClass_infinite_order S boundary input hadd hboundary) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FilledDisc.lean b/lean/OAI/Topology/CoarseAssembly/FilledDisc.lean new file mode 100644 index 0000000000000000000000000000000000000000..9d42cb058b222d868d0fc0e6a5325e9eac3b2b6f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FilledDisc.lean @@ -0,0 +1,125 @@ +import OAI.Topology.CoarseAssembly.LatticeHat +import OAI.Topology.CoarseAssembly.ConcreteSpaces +import OAI.Topology.CoarseAssembly.RipsPaths +import OAI.Topology.CoarseAssembly.HomotopyFilling + +namespace OAI + +/-! # The actual filled hexagonal discs + +The compact polygon is contracted by radial scaling. The triangular-lattice +hat functions give a continuous map of this polygon into the scale-one Rips +realization of its lattice vertices. Thus the filling is constructed, not +assumed as an analytic vanishing premise. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Topology Rips Analytic + +theorem realLatticeRadius_nonneg (p : ℝ × ℝ) : 0 ≤ realLatticeRadius p := + (abs_nonneg _).trans (le_max_right _ _) + +theorem realLatticeRadius_smul (c : ℝ) (hc : 0 ≤ c) (p : ℝ × ℝ) : + realLatticeRadius (c • p) = c * realLatticeRadius p := by + simp only [realLatticeRadius, Prod.smul_fst, Prod.smul_snd, smul_eq_mul, + ← mul_add, abs_mul, abs_of_nonneg hc, mul_max_of_nonneg _ _ hc] + +def FilledDisc (j : ℕ) := {p : ℝ × ℝ // realLatticeRadius p ≤ j} + +instance (j : ℕ) : TopologicalSpace (FilledDisc j) := inferInstanceAs + (TopologicalSpace {p : ℝ × ℝ // realLatticeRadius p ≤ j}) + +instance (j : ℕ) : T2Space (FilledDisc j) := inferInstanceAs + (T2Space {p : ℝ × ℝ // realLatticeRadius p ≤ j}) + +instance (j : ℕ) : CompactSpace (FilledDisc j) := by + apply isCompact_iff_compactSpace.mp + apply IsCompact.of_isClosed_subset + (isCompact_Icc (a := (-(j : ℝ), -(j : ℝ))) (b := ((j : ℝ), (j : ℝ)))) + (isClosed_le realLatticeRadius_continuous continuous_const) + intro p hp + have h := realLatticeRadius_le_iff.mp hp + rw [abs_le] at h + exact ⟨⟨h.1.1, (abs_le.mp h.2.1).1⟩, ⟨h.1.2, (abs_le.mp h.2.1).2⟩⟩ + +def filledDiscCenter (j : ℕ) : FilledDisc j := + ⟨(0, 0), by simp [realLatticeRadius]⟩ + +def filledDiscContraction (j : ℕ) : CompactContraction (FilledDisc j) where + center := filledDiscCenter j + homotopy := + { toFun := fun z => ⟨(1 - (z.1 : ℝ)) • z.2.val, by + rw [realLatticeRadius_smul _ (sub_nonneg.mpr z.1.2.2)] + exact (mul_le_of_le_one_left (realLatticeRadius_nonneg z.2.val) + (by linarith [z.1.2.1] : 1 - (z.1 : ℝ) ≤ 1)).trans z.2.property⟩ + continuous_toFun := by + apply Continuous.subtype_mk + fun_prop + map_zero_left := by intro x; apply Subtype.ext; simp + map_one_left := by + intro x + apply Subtype.ext + change (1 - (1 : ℝ)) • x.val = (0, 0) + simp + rfl } + +def discHatWeights (j : ℕ) (p : FilledDisc j) : Disc j →₀ ℝ := + (latticeHatWeights p.val).comapDomain Subtype.val Subtype.val_injective.injOn + +@[simp] theorem discHatWeights_apply (j : ℕ) (p : FilledDisc j) (v : Disc j) : + discHatWeights j p v = latticeHat p.val v.val := rfl + +theorem latticeHatWeights_disc_support (j : ℕ) (p : FilledDisc j) : + ↑(latticeHatWeights p.val).support ⊆ Set.range (@Subtype.val LatticeVertex + (fun v => latticeRadius v ≤ (j : ℤ))) := by + intro v hv + have hpos : 0 < latticeHat p.val v := lt_of_le_of_ne (latticeHat_nonneg _ _) + (Finsupp.mem_support_iff.mp hv).symm + exact ⟨⟨v, latticeHat_in_disc p.property hpos⟩, rfl⟩ + +theorem discHatWeights_total (j : ℕ) (p : FilledDisc j) : + (discHatWeights j p).sum (fun _ t => t) = 1 := by + have hm := Finsupp.embDomain_comapDomain + (f := (⟨Subtype.val, Subtype.val_injective⟩ : Disc j ↪ LatticeVertex)) + (latticeHatWeights_disc_support j p) + have hs := congrArg (fun f : LatticeVertex →₀ ℝ => f.sum (fun _ t => t)) hm + simp only [Finsupp.sum_embDomain, latticeHatWeights_total] at hs + convert hs using 1 + apply congrArg (fun f : Disc j →₀ ℝ => f.sum (fun _ t => t)) + apply Finsupp.ext + intro v + rfl + +def filledToRipsPoint (j : ℕ) (p : FilledDisc j) : Point (Disc j) 1 where + weight := discHatWeights j p + nonneg v := latticeHat_nonneg p.val v.val + total := discHatWeights_total j p + diameter v hv w hw := by + have hv' : 0 < latticeHat p.val v.val := lt_of_le_of_ne (latticeHat_nonneg _ _) + (Finsupp.mem_support_iff.mp hv).symm + have hw' : 0 < latticeHat p.val w.val := lt_of_le_of_ne (latticeHat_nonneg _ _) + (Finsupp.mem_support_iff.mp hw).symm + rcases latticeHat_adjacent hv' hw' with heq | hadj + · have hvw : v = w := Subtype.ext heq + simp [hvw] + · rw [discGraphMetric_eq] + change ((discGraph j).dist v w : ℝ) ≤ 1 + exact_mod_cast (discGraph j).dist_le (SimpleGraph.Adj.toWalk hadj) + +def filledToRips (j : ℕ) : C(FilledDisc j, Point (Disc j) 1) where + toFun := filledToRipsPoint j + continuous_toFun := by + apply continuous_induced_rng.mpr + apply continuous_pi + intro v + change Continuous (fun p : FilledDisc j => latticeHat p.val v.val) + exact (latticeHat_continuous v.val).comp continuous_subtype_val + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FilledEdges.lean b/lean/OAI/Topology/CoarseAssembly/FilledEdges.lean new file mode 100644 index 0000000000000000000000000000000000000000..87fbdf98c7e570113b5162a0cb1037c5ba889b53 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FilledEdges.lean @@ -0,0 +1,191 @@ +import OAI.Topology.CoarseAssembly.FilledDisc + +namespace OAI + +/-! # Linear edges in the filled polygon + +The polygon's straight paths map to the actual barycentric Rips edges. +These identities supply the filling factorization of the boundary walk. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Rips + +theorem realLatticeRadius_add_le (p q : ℝ × ℝ) : + realLatticeRadius (p + q) ≤ realLatticeRadius p + realLatticeRadius q := by + have hp := realLatticeRadius_le_iff.mp (le_refl (realLatticeRadius p)) + have hq := realLatticeRadius_le_iff.mp (le_refl (realLatticeRadius q)) + apply realLatticeRadius_le_iff.mpr + refine ⟨(abs_add_le _ _).trans (add_le_add hp.1 hq.1), + (abs_add_le _ _).trans (add_le_add hp.2.1 hq.2.1), ?_⟩ + change |(p.1 + q.1) + (p.2 + q.2)| ≤ _ + rw [show (p.1 + q.1) + (p.2 + q.2) = (p.1 + p.2) + (q.1 + q.2) by ring] + exact (abs_add_le _ _).trans (add_le_add hp.2.2 hq.2.2) + +def realVertex (v : LatticeVertex) : ℝ × ℝ := (v.1, v.2) + +theorem realLatticeRadius_vertex (v : LatticeVertex) : + realLatticeRadius (realVertex v) = (latticeRadius v : ℝ) := by + unfold realLatticeRadius realVertex latticeRadius + push_cast + rfl + +def filledVertex {j : ℕ} (v : Disc j) : FilledDisc j := + ⟨realVertex v.val, by rw [realLatticeRadius_vertex]; exact_mod_cast v.property⟩ + +def filledSegment {j : ℕ} (p q : FilledDisc j) : Path p q where + toFun t := ⟨(1 - (t : ℝ)) • p.val + (t : ℝ) • q.val, by + calc + realLatticeRadius ((1 - (t : ℝ)) • p.val + (t : ℝ) • q.val) ≤ + realLatticeRadius ((1 - (t : ℝ)) • p.val) + realLatticeRadius ((t : ℝ) • q.val) := + realLatticeRadius_add_le _ _ + _ = (1 - (t : ℝ)) * realLatticeRadius p.val + (t : ℝ) * realLatticeRadius q.val := by + rw [realLatticeRadius_smul _ (sub_nonneg.mpr t.2.2), realLatticeRadius_smul _ t.2.1] + _ ≤ (1 - (t : ℝ)) * j + (t : ℝ) * j := + add_le_add (mul_le_mul_of_nonneg_left p.property (sub_nonneg.mpr t.2.2)) + (mul_le_mul_of_nonneg_left q.property t.2.1) + _ = j := by ring⟩ + continuous_toFun := by apply Continuous.subtype_mk; fun_prop + source' := by apply Subtype.ext; simp + target' := by apply Subtype.ext; simp + +@[simp] theorem filledSegment_val {j : ℕ} (p q : FilledDisc j) (t : unitInterval) : + (filledSegment p q t).val = (1 - (t : ℝ)) • p.val + (t : ℝ) • q.val := rfl + +theorem latticeHat_vertex (u v : LatticeVertex) : + latticeHat (realVertex u) v = if v = u then 1 else 0 := by + classical + by_cases h : v = u + · subst v + simp [latticeHat, realVertex, hatKernel, realLatticeRadius] + · rw [ite_eq_right h] + apply le_antisymm _ (latticeHat_nonneg _ _) + by_contra hn + have hp := (latticeHat_pos_iff (realVertex u) v).mp (lt_of_not_ge hn) + dsimp only [realVertex] at hp + have hx : |u.1 - v.1| < 1 := by exact_mod_cast hp.1 + have hy : |u.2 - v.2| < 1 := by exact_mod_cast hp.2.1 + rw [abs_lt] at hx hy + apply h + exact (Prod.ext (by omega) (by omega) : u = v).symm + +@[simp] theorem filledToRips_vertex {j : ℕ} (v : Disc j) : + filledToRipsPoint j (filledVertex v) = vertex v (by norm_num) := by + classical + apply Point.ext + apply Finsupp.ext + intro w + change latticeHat (realVertex v.val) w.val = (Finsupp.single v (1 : ℝ)) w + rw [latticeHat_vertex] + by_cases h : w = v + · subst w + simp + · have hv : v ≠ w := Ne.symm h + have hc : w.val ≠ v.val := fun hc => h (Subtype.ext hc) + simp [hv, hc] + +theorem realLatticeRadius_adj_difference {j : ℕ} {u v : Disc j} + (h : (discGraph j).Adj u v) : realLatticeRadius (realVertex v.val - realVertex u.val) = 1 := by + have hx := h.1 + have hy := h.2.1 + have hn := h.2.2.2 + have hsum := h.2.2.1 + have hr : latticeRadius (v.val - u.val) = 1 := by + change max (max |v.val.1 - u.val.1| |v.val.2 - u.val.2|) + |(v.val.1 - u.val.1) + (v.val.2 - u.val.2)| = 1 + rw [abs_sub_comm] at hx hy hsum + have hz : v.val.1 - u.val.1 + (v.val.2 - u.val.2) = + (v.val.1 + v.val.2) - (u.val.1 + u.val.2) := by ring + rw [hz] + have hne : u.val.1 ≠ v.val.1 ∨ u.val.2 ≠ v.val.2 := by + by_contra! hneg + exact hn (Prod.ext hneg.1 hneg.2) + apply le_antisymm (max_le (max_le hx hy) hsum) + rcases hne with hx' | hy' + · have hpos : 0 < |v.val.1 - u.val.1| := abs_pos.mpr (sub_ne_zero.mpr (Ne.symm hx')) + exact (show 1 ≤ |v.val.1 - u.val.1| by omega).trans + ((le_max_left _ _).trans (le_max_left _ _)) + · have hpos : 0 < |v.val.2 - u.val.2| := abs_pos.mpr (sub_ne_zero.mpr (Ne.symm hy')) + exact (show 1 ≤ |v.val.2 - u.val.2| by omega).trans + ((le_max_right _ _).trans (le_max_left _ _)) + have he : realVertex v.val - realVertex u.val = realVertex (v.val - u.val) := by + ext <;> simp [realVertex] + rw [he, realLatticeRadius_vertex, hr] + norm_num + +theorem latticeHat_eq_radius (p : ℝ × ℝ) (v : LatticeVertex) : + latticeHat p v = max 0 (1 - realLatticeRadius (p - realVertex v)) := rfl + +theorem filledSegment_hat_left {j : ℕ} {u v : Disc j} (h : (discGraph j).Adj u v) + (t : unitInterval) : + latticeHat (filledSegment (filledVertex u) (filledVertex v) t).val u.val = 1 - (t : ℝ) := by + rw [latticeHat_eq_radius] + have he : (filledSegment (filledVertex u) (filledVertex v) t).val - realVertex u.val = + (t : ℝ) • (realVertex v.val - realVertex u.val) := by + rw [filledSegment_val] + ext <;> simp [filledVertex] <;> ring + rw [he, realLatticeRadius_smul _ t.2.1, realLatticeRadius_adj_difference h, mul_one, + max_eq_right (sub_nonneg.mpr t.2.2)] + +theorem filledSegment_hat_right {j : ℕ} {u v : Disc j} (h : (discGraph j).Adj u v) + (t : unitInterval) : + latticeHat (filledSegment (filledVertex u) (filledVertex v) t).val v.val = (t : ℝ) := by + rw [latticeHat_eq_radius] + have he : (filledSegment (filledVertex u) (filledVertex v) t).val - realVertex v.val = + (1 - (t : ℝ)) • (realVertex u.val - realVertex v.val) := by + rw [filledSegment_val] + ext <;> simp [filledVertex] <;> ring + rw [he, realLatticeRadius_smul _ (sub_nonneg.mpr t.2.2), + realLatticeRadius_adj_difference h.symm, mul_one, + max_eq_right (by linarith [t.2.1] : 0 ≤ 1 - (1 - (t : ℝ)))] + ring + +theorem Rips.Point.weight_zero_of_two {X : Type*} [PseudoMetricSpace X] [Fintype X] + {r : ℝ} (p : Point X r) {x y z : X} (hxy : x ≠ y) (hzx : z ≠ x) (hzy : z ≠ y) + (hs : p.weight x + p.weight y = 1) : p.weight z = 0 := by + classical + have hle : (∑ w ∈ ({x, y, z} : Finset X), p.weight w) ≤ ∑ w : X, p.weight w := + Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun w _ _ => p.nonneg w) + have hxz : x ≠ z := Ne.symm hzx + have hyz : y ≠ z := Ne.symm hzy + simp only [Finset.sum_insert (by simp [hxy, hxz] : x ∉ ({y, z} : Finset X)), + Finset.sum_insert (by simp [hyz] : y ∉ ({z} : Finset X)), Finset.sum_singleton, + p.sum_weight] at hle + exact le_antisymm (by linarith) (p.nonneg z) + +/-- The actual hat-function filling agrees exactly with the Rips edge. -/ +theorem filledToRips_edge {j : ℕ} {u v : Disc j} (h : (discGraph j).Adj u v) + (t : unitInterval) : + filledToRipsPoint j (filledSegment (filledVertex u) (filledVertex v) t) = + edgePath (show dist u v ≤ (1 : ℝ) by + rw [discGraphMetric_eq] + change ((discGraph j).dist u v : ℝ) ≤ 1 + exact_mod_cast (show (discGraph j).dist u v ≤ 1 by + simpa using (discGraph j).dist_le h.toWalk)) t := by + classical + let p := filledToRipsPoint j (filledSegment (filledVertex u) (filledVertex v) t) + have hleft : p.weight u = 1 - (t : ℝ) := filledSegment_hat_left h t + have hright : p.weight v = (t : ℝ) := filledSegment_hat_right h t + have huv : u ≠ v := fun he => h.2.2.2 (congrArg Subtype.val he) + apply Point.ext + apply Finsupp.ext + intro w + change p.weight w = (1 - (t : ℝ)) * (Finsupp.single u (1 : ℝ) w) + + (t : ℝ) * (Finsupp.single v (1 : ℝ) w) + by_cases hwu : w = u + · subst w + simpa [Ne.symm huv] using hleft + by_cases hwv : w = v + · subst w + simpa [huv] using hright + · rw [p.weight_zero_of_two huv hwu hwv (by rw [hleft, hright]; ring)] + simp [Ne.symm hwu, Ne.symm hwv] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FilledWalks.lean b/lean/OAI/Topology/CoarseAssembly/FilledWalks.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e7c1e4937c0218e6573b1acd91da623f49c3db7 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FilledWalks.lean @@ -0,0 +1,59 @@ +import OAI.Topology.CoarseAssembly.FilledEdges +import OAI.Topology.CoarseAssembly.CocyclePathLifting +import OAI.Topology.CoarseAssembly.LoopCircle + +namespace OAI + +/-! # Filling the actual parametrized lattice walks + +Straight segments in the compact polygon follow the same concatenation as +the barycentric graph path. Thus every closed base walk, with its original +parametrization, factors through the filled polygon. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Rips + +theorem discEdgeBound {j : ℕ} (u v : Disc j) (h : (discGraph j).Adj u v) : + dist u v ≤ (1 : ℝ) := by + rw [discGraphMetric_eq] + change ((discGraph j).dist u v : ℝ) ≤ 1 + exact_mod_cast (show (discGraph j).dist u v ≤ 1 by + simpa using (discGraph j).dist_le h.toWalk) + +def filledWalk {j : ℕ} : {u v : Disc j} → (discGraph j).Walk u v → + Path (filledVertex u) (filledVertex v) + | _, _, .nil => Path.refl _ + | _, _, .cons _ p => (filledSegment (filledVertex _) (filledVertex _)).trans (filledWalk p) + +theorem filledToRips_walk {j : ℕ} {u v : Disc j} (p : (discGraph j).Walk u v) + (t : unitInterval) : + filledToRipsPoint j (filledWalk p t) = + walkPath (by norm_num : (0 : ℝ) ≤ 1) discEdgeBound p t := by + induction p generalizing t with + | nil => exact filledToRips_vertex _ + | cons h p ih => + simp only [filledWalk, walkPath, Path.trans_apply] + split_ifs + · exact filledToRips_edge h _ + · exact ih _ + +/-- Exact factorization through the filled compact polygon, not a homotopy +or a change of parametrization. -/ +theorem filledToRips_loop {j : ℕ} {u : Disc j} (p : (discGraph j).Walk u u) : + (filledToRips j).comp (loopCircle (filledWalk p)) = + loopCircle (walkPath (by norm_num : (0 : ℝ) ≤ 1) discEdgeBound p) := by + apply ContinuousMap.ext + intro z + obtain ⟨t, rfl⟩ := circle_parameter_surjective z + simp only [ContinuousMap.comp_apply, loopCircle_apply] + exact filledToRips_walk p t + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteCompactRoe.lean b/lean/OAI/Topology/CoarseAssembly/FiniteCompactRoe.lean new file mode 100644 index 0000000000000000000000000000000000000000..8936bb9b041c888bc46a33bc7a419a1c147d0c94 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteCompactRoe.lean @@ -0,0 +1,46 @@ +import OAI.Topology.CoarseAssembly.Roe + +namespace OAI + +/-! # Compact self-adjoint operators on a finite component lie in its Roe algebra -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [CompleteSpace H] in +theorem finite_propagation_bound (T : Operator X H) : + ∃ r : ℝ, 0 ≤ r ∧ PropagationLE r T := by + let r : ℝ := ∑ x : X, ∑ y : X, dist x y + have hr : 0 ≤ r := Finset.sum_nonneg (fun _ _ => Finset.sum_nonneg (fun _ _ => dist_nonneg)) + refine ⟨r, hr, ?_⟩ + intro x y hxy + have h1 : dist x y ≤ ∑ z : X, dist x z := + Finset.single_le_sum (f := fun z : X => dist x z) + (fun _ _ => dist_nonneg) (Finset.mem_univ y) + have h2 : (∑ z : X, dist x z) ≤ r := + Finset.single_le_sum (f := fun z : X => ∑ w : X, dist z w) + (fun _ _ => Finset.sum_nonneg (fun _ _ => dist_nonneg)) + (Finset.mem_univ x) + exact False.elim ((not_lt_of_ge (h1.trans h2)) hxy) + +omit [Fintype X] [PseudoMetricSpace X] [CompleteSpace H] in +theorem compact_entries_of_compact {T : Operator X H} (hT : IsCompactOperator T) : + CompactEntries T := fun x y => (hT.comp_clm (insert y)).clm_comp (coordinate x) + +theorem compact_selfAdjoint_mem_roe {T : Operator X H} + (hT : IsCompactOperator T) (hself : IsSelfAdjoint T) : + T ∈ algebra (X := X) (H := H) := by + apply generator_mem + refine ⟨finite_propagation_bound T, compact_entries_of_compact hT, ?_⟩ + rw [hself.star_eq] + exact compact_entries_of_compact hT + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteCycle.lean b/lean/OAI/Topology/CoarseAssembly/FiniteCycle.lean new file mode 100644 index 0000000000000000000000000000000000000000..ca55b3d274512bafd9534fe15610605363b16db4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteCycle.lean @@ -0,0 +1,48 @@ +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation +import Mathlib.Analysis.Normed.Operator.Compact.FiniteDimension + +namespace OAI + +/-! # Finite-dimensional odd cycles vanish + +Every change of operator is compact on a finite-dimensional Hilbert space. +Changing the operator to the identity gives a degenerate odd cycle. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] + +theorem finiteDimensional_cycleClass_zero (c : OddCycle A) [FiniteDimensional ℂ c.space] : + cycleClass A c = 0 := by + let K : End c.space := 1 - c.operator + have hi : IsCompactOperator (id : c.space → c.space) := + (isCompactOperator_id_iff_finiteDimensional (𝕜 := ℂ)).2 inferInstance + have hK : IsCompactOperator K := hi.comp_clm K + have hKs : IsCompactOperator (star K : End c.space) := + hi.comp_clm (star K : End c.space) + let d := c.compactPerturb K hK hKs + have hd : d.operator = 1 := by + change c.operator + (1 - c.operator) = 1 + abel + have hdeg : d.Degenerate := by + constructor + · intro a + rw [hd] + simp + constructor + · intro a + rw [hd] + simp + · intro a + rw [hd] + simp + exact (compactPerturb_class c K hK hKs).symm.trans (degenerate_zero d hdeg) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteCycleDecomposition.lean b/lean/OAI/Topology/CoarseAssembly/FiniteCycleDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..44a54c63fd9e92e2007688e75d52b1c8742e8039 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteCycleDecomposition.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.HilbertHeadTail +import OAI.Topology.CoarseAssembly.FiniteCycleSum + +namespace OAI + +/-! # Splitting the first summand off a finite active cycle -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +theorem blockOperator_head_tail (H : ℕ → HilbertSpace) (T : ∀ j, End (H j)) + (C : ℝ) (hC : 0 ≤ C) (hT : ∀ j, ‖T j‖ ≤ C) : + blockOperator T C hC hT = + operatorConjugation (summandIsometry H 0) (T 0) + + operatorConjugation (tailInsert H) + (blockOperator (fun j => T (j + 1)) C hC (fun j => hT (j + 1))) := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + have hh : (summandIsometry H 0).toContinuousLinearMap.adjoint x = x 0 := by + rw [summandIsometry_adjoint] + rfl + change T j (x j) = + (lp.single (E := fun j => H j) 2 0 (T 0 ((summandIsometry H 0).toContinuousLinearMap.adjoint x))) j + + (tailInsert H ((blockOperator (fun j => T (j + 1)) C hC (fun j => hT (j + 1))) + ((tailInsert H).toContinuousLinearMap.adjoint x))) j + rw [hh] + cases j with + | zero => rw [tailInsert_zero]; simp + | succ j => + rw [tailInsert_succ, blockOperator_apply, tailInsert_adjoint_apply] + simp + +variable {A : Type} [CStarAlgebra A] + +def finiteActiveCycle_head_tail (c : ℕ → OddCycle A) (C : ℝ) (hC : 0 ≤ C) + (hF : ∀ j, ‖(c j).operator‖ ≤ C) (N : ℕ) + (htail : ∀ j, N + 1 ≤ j → (c j).Degenerate) : + (c 0).IsDirectSum + (finiteActiveCycle (fun j => c (j + 1)) C hC (fun j => hF (j + 1)) N + (fun j hj => htail (j + 1) (Nat.add_le_add_right hj 1))) + (finiteActiveCycle c C hC hF (N + 1) htail) where + left := summandIsometry (familyHilbert c) 0 + right := tailInsert (familyHilbert c) + orthogonal := head_tail_orthogonal _ + exhaustive := head_tail_exhaustive _ + representation_eq a := blockOperator_head_tail (familyHilbert c) + (fun j => (c j).representation a) ‖a‖ (norm_nonneg a) + (fun _ => NonUnitalStarAlgHom.norm_apply_le _ _) + operator_eq := blockOperator_head_tail (familyHilbert c) (fun j => (c j).operator) C hC hF + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteCycleSum.lean b/lean/OAI/Topology/CoarseAssembly/FiniteCycleSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e666c4d0357ae99a2557f22ade29053c8a00674 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteCycleSum.lean @@ -0,0 +1,155 @@ +import OAI.Topology.CoarseAssembly.CompactBlockSum +import OAI.Topology.CoarseAssembly.ProjectionBlocks +import OAI.Topology.CoarseAssembly.AnalyticKHomology +import Mathlib.Analysis.CStarAlgebra.Spectrum + +namespace OAI + +/-! # Finite active sums of analytic cycles + +Countably many summands are allowed as an ambient Hilbert space; all but +finitely many cycles are degenerate. The finite active length may later +vary with the component of the coarse disjoint union. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +theorem diagonal_compact_of_zero_tail (H : ℕ → HilbertSpace) (K : ∀ j, End (H j)) + (T : End (countableHilbertSpace H)) (N : ℕ) + (hT : ∀ x j, (T x) j = K j (x j)) + (hK : ∀ j, IsCompactOperator (K j)) (hzero : ∀ j, N ≤ j → K j = 0) : + IsCompactOperator T := by + let C := ∑ j ∈ Finset.range N, ‖K j‖ + have hC : 0 ≤ C := Finset.sum_nonneg (fun j _ => norm_nonneg (K j)) + have hb : ∀ j, ‖K j‖ ≤ C := by + intro j + by_cases hj : j < N + · exact Finset.single_le_sum (fun k _ => norm_nonneg (K k)) (Finset.mem_range.mpr hj) + · rw [hzero j (Nat.le_of_not_gt hj), norm_zero] + exact hC + have he : T = truncatedBlockSum H K N C hC hb := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + rw [hT, truncatedBlockSum_apply] + by_cases hj : j < N + · simp only [hj, ite_true] + · simp only [hj, ite_false, hzero j (Nat.le_of_not_gt hj), zero_apply] + rw [he] + exact truncatedBlockSum_compact H K C hC hb hK N + +variable {A : Type} [CStarAlgebra A] + +abbrev familyHilbert (c : ℕ → OddCycle A) (j : ℕ) : HilbertSpace := (c j).space + +def familyRepresentation (c : ℕ → OddCycle A) : + A →⋆ₙₐ[ℂ] End (countableHilbertSpace (familyHilbert c)) where + toFun a := blockOperator (fun j => (c j).representation a) ‖a‖ (norm_nonneg a) + (fun j => NonUnitalStarAlgHom.norm_apply_le _ _) + map_zero' := by + ext x j + change (c j).representation 0 (x j) = 0 + rw [map_zero] + rfl + map_add' a b := by + ext x j + change (c j).representation (a + b) (x j) = _ + rw [map_add] + rfl + map_mul' a b := by + ext x j + change (c j).representation (a * b) (x j) = _ + rw [map_mul] + rfl + map_smul' z a := by + ext x j + change (c j).representation (z • a) (x j) = _ + rw [map_smul] + rfl + map_star' a := by + change blockOperator (fun j => (c j).representation (star a)) ‖star a‖ (norm_nonneg _) + (fun j => NonUnitalStarAlgHom.norm_apply_le _ _) = + (blockOperator (fun j => (c j).representation a) ‖a‖ (norm_nonneg _) + (fun j => NonUnitalStarAlgHom.norm_apply_le _ _)).adjoint + rw [blockOperator_adjoint] + ext x j + change (c j).representation (star a) (x j) = ((c j).representation a).adjoint (x j) + rw [map_star] + rfl + +@[simp] theorem familyRepresentation_apply (c : ℕ → OddCycle A) (a : A) + (x : countableHilbertSpace (familyHilbert c)) (j : ℕ) : + familyRepresentation c a x j = (c j).representation a (x j) := rfl + +def finiteActiveCycle (c : ℕ → OddCycle A) (C : ℝ) (hC : 0 ≤ C) + (hnorm : ∀ j, ‖(c j).operator‖ ≤ C) (N : ℕ) + (htail : ∀ j, N ≤ j → (c j).Degenerate) : OddCycle A where + space := countableHilbertSpace (familyHilbert c) + representation := familyRepresentation c + operator := blockOperator (fun j => (c j).operator) C hC hnorm + commutator_compact a := by + apply diagonal_compact_of_zero_tail (familyHilbert c) + (fun j => (c j).operator * (c j).representation a - (c j).representation a * (c j).operator) + _ N + · intro x j + rfl + · exact fun j => (c j).commutator_compact a + · exact fun j hj => (htail j hj).1 a + square_compact a := by + apply diagonal_compact_of_zero_tail (familyHilbert c) + (fun j => ((c j).operator * (c j).operator - 1) * (c j).representation a) _ N + · intro x j + rfl + · exact fun j => (c j).square_compact a + · exact fun j hj => (htail j hj).2.1 a + adjoint_compact a := by + change IsCompactOperator + (((blockOperator (fun j => (c j).operator) C hC hnorm).adjoint - + blockOperator (fun j => (c j).operator) C hC hnorm) * familyRepresentation c a) + rw [blockOperator_adjoint] + apply diagonal_compact_of_zero_tail (familyHilbert c) + (fun j => (star (c j).operator - (c j).operator) * (c j).representation a) _ N + · intro x j + rfl + · exact fun j => (c j).adjoint_compact a + · exact fun j hj => (htail j hj).2.2 a + +theorem finiteActiveCycle_unital (c : ℕ → OddCycle A) (C : ℝ) (hC : 0 ≤ C) + (hnorm : ∀ j, ‖(c j).operator‖ ≤ C) (N : ℕ) + (htail : ∀ j, N ≤ j → (c j).Degenerate) + (hu : ∀ j, (c j).representation 1 = 1) : + (finiteActiveCycle c C hC hnorm N htail).representation 1 = 1 := by + change familyRepresentation c 1 = (1 : End (countableHilbertSpace (familyHilbert c))) + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change (c j).representation 1 (x j) = x j + rw [hu] + rfl + +theorem finiteActiveCycle_selfAdjoint (c : ℕ → OddCycle A) (C : ℝ) (hC : 0 ≤ C) + (hnorm : ∀ j, ‖(c j).operator‖ ≤ C) (N : ℕ) + (htail : ∀ j, N ≤ j → (c j).Degenerate) + (hs : ∀ j, IsSelfAdjoint (c j).operator) : + IsSelfAdjoint (finiteActiveCycle c C hC hnorm N htail).operator := by + change IsSelfAdjoint (blockOperator (fun j => (c j).operator) C hC hnorm) + apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr + intro x y + rw [lp.inner_eq_tsum, lp.inner_eq_tsum] + exact tsum_congr (fun j => (hs j).isSymmetric (x j) (y j)) + +theorem finiteActiveCycle_norm (c : ℕ → OddCycle A) (C : ℝ) (hC : 0 ≤ C) + (hnorm : ∀ j, ‖(c j).operator‖ ≤ C) (N : ℕ) + (htail : ∀ j, N ≤ j → (c j).Degenerate) : + ‖(finiteActiveCycle c C hC hnorm N htail).operator‖ ≤ C := + blockOperator_norm_le _ _ _ _ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteFiberMaps.lean b/lean/OAI/Topology/CoarseAssembly/FiniteFiberMaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..1b3827aa11f5e2c297496161cabb6987353f6598 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteFiberMaps.lean @@ -0,0 +1,127 @@ +import OAI.Topology.CoarseAssembly.FiberEmbedding + +namespace OAI + +/-! # Permutations and normalized quotient-copying maps + +These are the two types of edge operator in the graph construction: +permutations at equal depth, and normalized copying along a surjective +finite-group quotient. Their norm and constant-vector properties are +proved on the actual finite-fiber Hilbert spaces. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {Q R H : Type*} [Fintype Q] [Fintype R] +variable [NormedAddCommGroup H] [NormedSpace ℂ H] + +def reindexFiberVector (e : Q ≃ R) (x : lp (fun _ : Q => H) 2) : + lp (fun _ : R => H) 2 := ⟨fun r => x (e.symm r), Memℓp.all _⟩ + +omit [NormedSpace ℂ H] in +theorem reindexFiber_norm (e : Q ≃ R) (x : lp (fun _ : Q => H) 2) : + ‖reindexFiberVector e x‖ = ‖x‖ := by + have hsq : ‖reindexFiberVector e x‖ ^ 2 = ‖x‖ ^ 2 := by + rw [l2_norm_sq, l2_norm_sq, tsum_fintype, tsum_fintype] + exact Equiv.sum_comp e.symm (fun q => ‖x q‖ ^ 2) + nlinarith [norm_nonneg (reindexFiberVector e x), norm_nonneg x] + +def reindexFiber (e : Q ≃ R) : lp (fun _ : Q => H) 2 ≃ₗᵢ[ℂ] lp (fun _ : R => H) 2 where + toFun := reindexFiberVector e + invFun := reindexFiberVector e.symm + left_inv x := by apply lp.ext; funext q; simp [reindexFiberVector] + right_inv x := by apply lp.ext; funext r; simp [reindexFiberVector] + map_add' _ _ := rfl + map_smul' _ _ := rfl + norm_map' := reindexFiber_norm e + +@[simp] theorem reindexFiber_apply (e : Q ≃ R) (x : lp (fun _ : Q => H) 2) (r : R) : + reindexFiber e x r = x (e.symm r) := rfl + +theorem reindexFiber_constant (e : Q ≃ R) (h : H) : + reindexFiber e (fiberConstant Q h) = fiberConstant R h := by + apply lp.ext + funext r + simp only [reindexFiber_apply, fiberConstant_apply, fiberNormalization, Fintype.card_congr e] + +section GroupQuotient + +variable {G K : Type*} [Group G] [Group K] [Fintype G] [Fintype K] + +def quotientSection (f : G →* K) (hf : Function.Surjective f) (k : K) : G := (hf k).choose + +omit [Fintype G] [Fintype K] in +@[simp] theorem quotientSection_spec (f : G →* K) (hf : Function.Surjective f) (k : K) : + f (quotientSection f hf k) = k := (hf k).choose_spec + +def quotientFiberEquiv (f : G →* K) (hf : Function.Surjective f) : G ≃ ((_k : K) × f.ker) where + toFun g := ⟨f g, ⟨(quotientSection f hf (f g))⁻¹ * g, by simp⟩⟩ + invFun z := quotientSection f hf z.1 * z.2.val + left_inv g := by simp + right_inv z := by + rcases z with ⟨k, z, hz⟩ + have hz' : f z = 1 := hz + simp only [map_mul, quotientSection_spec, hz', mul_one] + congr 1 + apply Subtype.ext + simp + +def quotientCopy (f : G →* K) [Fintype f.ker] (hf : Function.Surjective f) : + lp (fun _ : K => ℂ) 2 →ₗᵢ[ℂ] lp (fun _ : G => ℂ) 2 := by + classical + exact (reindexFiber (quotientFiberEquiv f hf).symm).toLinearIsometry.comp + (fiberEmbedding (fun _ : K => f.ker)) + +@[simp] theorem quotientCopy_apply (f : G →* K) [Fintype f.ker] (hf : Function.Surjective f) + (x : lp (fun _ : K => ℂ) 2) (g : G) : + quotientCopy f hf x g = (fiberNormalization f.ker : ℂ) * x (f g) := rfl + +theorem quotientCopy_constant (f : G →* K) [Fintype f.ker] (hf : Function.Surjective f) : + quotientCopy f hf (fiberConstant K (1 : ℂ)) = fiberConstant G 1 := by + classical + have hcard : Fintype.card G = Fintype.card K * Fintype.card f.ker := by + simpa using Fintype.card_congr (quotientFiberEquiv f hf) + have hnorm : fiberNormalization f.ker * fiberNormalization K = fiberNormalization G := by + simp only [fiberNormalization, hcard, Nat.cast_mul, + Real.sqrt_mul (Nat.cast_nonneg (Fintype.card K)), mul_inv_rev] + apply lp.ext + funext g + simp only [quotientCopy_apply, fiberConstant_apply, smul_eq_mul, mul_one] + exact_mod_cast hnorm + +theorem quotientCopy_adjoint_constant (f : G →* K) [Fintype f.ker] + (hf : Function.Surjective f) : + (quotientCopy f hf).toContinuousLinearMap.adjoint (fiberConstant G (1 : ℂ)) = + fiberConstant K 1 := by + rw [← quotientCopy_constant f hf, adjoint_apply_isometry] + +/-- The shallow-to-deep edge operator, including its right holonomy twist. -/ +def twistedQuotientCopy (f : G →* K) [Fintype f.ker] (hf : Function.Surjective f) (a : K) : + lp (fun _ : K => ℂ) 2 →ₗᵢ[ℂ] lp (fun _ : G => ℂ) 2 := + (quotientCopy f hf).comp (reindexFiber (Equiv.mulRight a)).toLinearIsometry + +theorem twistedQuotientCopy_constant (f : G →* K) [Fintype f.ker] + (hf : Function.Surjective f) (a : K) : + twistedQuotientCopy f hf a (fiberConstant K (1 : ℂ)) = fiberConstant G 1 := by + change quotientCopy f hf (reindexFiber (Equiv.mulRight a) (fiberConstant K 1)) = _ + rw [reindexFiber_constant, quotientCopy_constant] + +theorem twistedQuotientCopy_adjoint_constant (f : G →* K) [Fintype f.ker] + (hf : Function.Surjective f) (a : K) : + (twistedQuotientCopy f hf a).toContinuousLinearMap.adjoint (fiberConstant G (1 : ℂ)) = + fiberConstant K 1 := by + rw [← twistedQuotientCopy_constant f hf a, adjoint_apply_isometry] + +theorem twistedQuotientCopy_apply (f : G →* K) [Fintype f.ker] + (hf : Function.Surjective f) (a : K) (x : lp (fun _ : K => ℂ) 2) (g : G) : + twistedQuotientCopy f hf a x g = (fiberNormalization f.ker : ℂ) * x (f g * a⁻¹) := rfl + +end GroupQuotient + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteHeadBoundary.lean b/lean/OAI/Topology/CoarseAssembly/FiniteHeadBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..dd4c596edc9d602b568f3f2558820d5e0249be4a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteHeadBoundary.lean @@ -0,0 +1,94 @@ +import OAI.Topology.CoarseAssembly.DiagonalBoundaryCoordinates +import OAI.Topology.CoarseAssembly.SeparatedFamilyPerturbation +import OAI.Topology.CoarseAssembly.OperatorNormalization + +namespace OAI + +/-! # Removing finitely many components from the whole-union boundary + +The argument works with the actual rational boundary unitary. Involutive +components contribute the identity in that unitary, before taking K-theory. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem relativeClass_congr {B : Type*} [CStarAlgebra B] + (S : NonUnitalStarSubalgebra ℂ B) [hS : IsClosed (S : Set B)] + (u v : unitary B) (hu : (u : B) - 1 ∈ S) (hv : (v : B) - 1 ∈ S) (h : u = v) : + OperatorKTheory.relativeClass S u hu = OperatorKTheory.relativeClass S v hv := by + subst v + rfl + +theorem separatedFamilyBoundary_eq_of_rational (o : ∀ i, V i) + (A B : ∀ i, Operator (V i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (B i)) + (hAs : ∀ i, IsSelfAdjoint (A i)) (hBs : ∀ i, IsSelfAdjoint (B i)) + (hAsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) + (hBsq : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (V i) H))) + (hAB : ∀ i, rationalBoundaryUnitary (A i) (hAs i) = rationalBoundaryUnitary (B i) (hBs i)) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hp hAs hAsq = + separatedFamilyBoundary o B D hD hB s hs hq hBs hBsq := by + let := separatedMetric o + let F := separatedFamilyMultiplier o A C hC hA r hr hp + let G := separatedFamilyMultiplier o B D hD hB s hs hq + have hFs : IsSelfAdjoint F := separatedFamilyMultiplier_selfAdjoint o A C hC hA r hr hp hAs + have hGs : IsSelfAdjoint G := separatedFamilyMultiplier_selfAdjoint o B D hD hB s hs hq hBs + have hu : multiplierBoundaryUnitary F hFs = multiplierBoundaryUnitary G hGs := by + apply Subtype.ext + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext z + rcases z with ⟨i, x⟩ + have h1 := congrArg (fun w : Module (V i) H => w x) + (row_multiplierBoundaryUnitary F hFs A hAs + (fun w j => rowVector_diagonalFamily A C hC hA w j) v i) + have h2 := congrArg (fun w : Module (V i) H => w x) + (row_multiplierBoundaryUnitary G hGs B hBs + (fun w j => rowVector_diagonalFamily B D hD hB w j) v i) + exact h1.trans ((congrArg (fun u : unitary (Operator (V i) H) => + (u : Operator (V i) H) (rowVector v i) x) (hAB i)).trans h2.symm) + exact relativeClass_congr (hS := algebra_isClosed) _ _ _ _ _ hu + +/-- The finite head can differ arbitrarily when its operators are exact +involutions. Equality is proved for the entire Roe boundary. -/ +theorem separatedFamilyBoundary_eq_of_involutive_head (o : ∀ i, V i) + (A B : ∀ i, Operator (V i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (B i)) + (hAs : ∀ i, IsSelfAdjoint (A i)) (hBs : ∀ i, IsSelfAdjoint (B i)) + (hAsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) + (hBsq : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (V i) H))) + (J : Finset ℕ) (htail : ∀ i, i ∉ J → A i = B i) + (hAi : ∀ i, i ∈ J → A i * A i = 1) (hBi : ∀ i, i ∈ J → B i * B i = 1) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hp hAs hAsq = + separatedFamilyBoundary o B D hD hB s hs hq hBs hBsq := by + apply separatedFamilyBoundary_eq_of_rational o A B C D hC hD hA hB r s hr hs hp hq hAs hBs hAsq hBsq + intro i + by_cases hi : i ∈ J + · exact (rationalBoundaryUnitary_eq_one (A i) (hAs i) (hAi i hi)).trans + (rationalBoundaryUnitary_eq_one (B i) (hBs i) (hBi i hi)).symm + · have hcongr (T U : Operator (V i) H) (hT : IsSelfAdjoint T) (hU : IsSelfAdjoint U) + (he : T = U) : rationalBoundaryUnitary T hT = rationalBoundaryUnitary U hU := by + subst U + rfl + exact hcongr _ _ _ _ (htail i hi) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteHeadNormalization.lean b/lean/OAI/Topology/CoarseAssembly/FiniteHeadNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..97e5c9a959c6f2ada6d56a348971fa58ffbabf95 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteHeadNormalization.lean @@ -0,0 +1,143 @@ +import OAI.Topology.CoarseAssembly.FiniteHeadBoundary +import OAI.Topology.CoarseAssembly.UniformCycleNormalization +import Mathlib.Analysis.Normed.Lp.LpEquiv + +namespace OAI + +/-! # Uniformly controlled involutive replacement of a finite head -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def finiteHeadRadius (J : Finset ℕ) : ℝ := ∑ i ∈ J, ∑ x : V i, ∑ y : V i, dist x y + +omit [∀ i, DecidableEq (V i)] in +theorem finiteHeadRadius_nonneg (J : Finset ℕ) : 0 ≤ finiteHeadRadius (V := V) J := + Finset.sum_nonneg (fun _ _ => Finset.sum_nonneg (fun _ _ => + Finset.sum_nonneg (fun _ _ => dist_nonneg))) + +omit [∀ i, DecidableEq (V i)] in +theorem finiteHeadRadius_diam (J : Finset ℕ) {i : ℕ} (hi : i ∈ J) (x y : V i) : + dist x y ≤ finiteHeadRadius (V := V) J := by + have h1 : dist x y ≤ ∑ z : V i, dist x z := + Finset.single_le_sum (f := fun z : V i => dist x z) (fun _ _ => dist_nonneg) (Finset.mem_univ y) + have h2 : (∑ z : V i, dist x z) ≤ ∑ z : V i, ∑ w : V i, dist z w := + Finset.single_le_sum (f := fun z : V i => ∑ w : V i, dist z w) + (fun _ _ => Finset.sum_nonneg (fun _ _ => dist_nonneg)) (Finset.mem_univ x) + have h3 : (∑ z : V i, ∑ w : V i, dist z w) ≤ finiteHeadRadius (V := V) J := + Finset.single_le_sum (f := fun j => ∑ z : V j, ∑ w : V j, dist z w) + (fun _ _ => Finset.sum_nonneg (fun _ _ => + Finset.sum_nonneg (fun _ _ => dist_nonneg))) hi + exact h1.trans (h2.trans h3) + +omit [CompleteSpace H] in +theorem finiteHead_propagation (J : Finset ℕ) (A B : ∀ i, Operator (V i) H) + (r : ℝ) (hp : ∀ i, PropagationLE r (A i)) (htail : ∀ i, i ∉ J → B i = A i) : + ∀ i, PropagationLE (max r (finiteHeadRadius (V := V) J)) (B i) := by + intro i x y hxy + by_cases hi : i ∈ J + · exact False.elim ((not_lt_of_ge ((finiteHeadRadius_diam J hi x y).trans (le_max_right _ _))) hxy) + · rw [htail i hi] + exact hp i x y ((le_max_left _ _).trans_lt hxy) + +variable [SecondCountableTopology H] + +def componentHilbert (i : ℕ) : HilbertSpace where + Carrier := Module (V i) H + normed := inferInstance + inner := inferInstance + complete := inferInstance + secondCountable := (lpPiLpₗᵢ (fun _ : V i => H) ℂ (p := 2)).isometry.isEmbedding.secondCountableTopology + +/-- Only finitely many components are changed. Their new operators are +involutions, their differences are compact, and all propagation stays bounded. -/ +theorem exists_finiteHead_involution (J : Finset ℕ) (A : ∀ i, Operator (V i) H) + (C : ℝ) (hA : ∀ i, ‖A i‖ ≤ C) (r : ℝ) + (hp : ∀ i, PropagationLE r (A i)) + (hs : ∀ i, IsSelfAdjoint (A i)) + (hc : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) : + ∃ B : ∀ i, Operator (V i) H, + (∀ i, IsSelfAdjoint (B i)) ∧ + (∀ i, ‖B i‖ ≤ max C 1) ∧ + (∀ i, PropagationLE (max r (finiteHeadRadius (V := V) J)) (B i)) ∧ + (∀ i, IsCompactOperator (B i - A i)) ∧ + (∀ i, i ∈ J → B i * B i = 1) ∧ + (∀ i, i ∉ J → B i = A i) := by + have hex (i : ℕ) : ∃ N : Operator (V i) H, + IsSelfAdjoint N ∧ N * N = 1 ∧ IsCompactOperator (N - A i : Operator (V i) H) ∧ + IsCompactOperator (star (N - A i) : Operator (V i) H) := + @exists_compact_involution (componentHilbert (V := V) (H := H) i) (A i) (hs i) (hc i) + choose N hNs hNi hNc _hNcs using hex + let B : ∀ i, Operator (V i) H := fun i => if i ∈ J then N i else A i + have htail (i : ℕ) (hi : i ∉ J) : B i = A i := by simp only [B, ite_eq_right hi] + refine ⟨B, ?_, ?_, finiteHead_propagation J A B r hp htail, ?_, ?_, htail⟩ + · intro i + dsimp only [B] + split_ifs with hi + · exact hNs i + · exact hs i + · intro i + dsimp only [B] + split_ifs with hi + · exact (@involution_norm_le_one (componentHilbert (V := V) (H := H) i) (N i) (hNs i) (hNi i)).trans (le_max_right _ _) + · exact (hA i).trans (le_max_left _ _) + · intro i + dsimp only [B] + split_ifs with hi + · exact hNc i + · rw [sub_self] + change IsCompactOperator (0 : Module (V i) H → Module (V i) H) + exact isCompactOperator_zero + · intro i hi + dsimp only [B] + rw [ite_eq_left hi] + exact hNi i + + +structure FiniteHeadReplacement (J : Finset ℕ) (A : ∀ i, Operator (V i) H) (C r : ℝ) where + operator : ∀ i, Operator (V i) H + selfAdjoint : ∀ i, IsSelfAdjoint (operator i) + norm_le : ∀ i, ‖operator i‖ ≤ max C 1 + propagation : ∀ i, PropagationLE (max r (finiteHeadRadius (V := V) J)) (operator i) + compact_diff : ∀ i, IsCompactOperator (operator i - A i) + involutive : ∀ i, i ∈ J → operator i * operator i = 1 + tail : ∀ i, i ∉ J → operator i = A i + +def finiteHeadReplacement (J : Finset ℕ) (A : ∀ i, Operator (V i) H) + (C : ℝ) (hA : ∀ i, ‖A i‖ ≤ C) (r : ℝ) + (hp : ∀ i, PropagationLE r (A i)) (hs : ∀ i, IsSelfAdjoint (A i)) + (hc : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) : + FiniteHeadReplacement J A C r := + let h := exists_finiteHead_involution J A C hA r hp hs hc + { operator := h.choose + selfAdjoint := h.choose_spec.1 + norm_le := h.choose_spec.2.1 + propagation := h.choose_spec.2.2.1 + compact_diff := h.choose_spec.2.2.2.1 + involutive := h.choose_spec.2.2.2.2.1 + tail := h.choose_spec.2.2.2.2.2 } + +omit [SecondCountableTopology H] in +theorem FiniteHeadReplacement.square_compact {J : Finset ℕ} {A : ∀ i, Operator (V i) H} {C r : ℝ} + (d : FiniteHeadReplacement J A C r) + (hc : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) (i : ℕ) : + IsCompactOperator (d.operator i * d.operator i - (1 : Operator (V i) H)) := by + by_cases hi : i ∈ J + · rw [d.involutive i hi, sub_self] + change IsCompactOperator (0 : Module (V i) H → Module (V i) H) + exact isCompactOperator_zero + · rw [d.tail i hi] + exact hc i + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteLocalization.lean b/lean/OAI/Topology/CoarseAssembly/FiniteLocalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..7b4a8cf9b022519b2e491d09b794660bccc87977 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteLocalization.lean @@ -0,0 +1,70 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation +import Mathlib.Algebra.Star.BigOperators + +namespace OAI + +/-! # Finite partition localization of Fredholm cycles + +This is the operator step used on each compact Rips component. A represented +square partition of unity localizes the operator without changing its cycle +class. The geometric partition and its propagation control are constructed +separately. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] {ι : Type*} [Fintype ι] + +theorem localizedOperator_sub_eq (c : OddCycle A) (a : ι → A) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : + localizedOperator c a - c.operator = + ∑ i, c.representation (a i) * + (c.operator * c.representation (a i) - c.representation (a i) * c.operator) := by + calc + localizedOperator c a - c.operator = localizedOperator c a - + (∑ i, c.representation (a i) * c.representation (a i)) * c.operator := by + rw [hpart, one_mul] + _ = ∑ i, (c.representation (a i) * c.operator * c.representation (a i) - + (c.representation (a i) * c.representation (a i)) * c.operator) := by + rw [localizedOperator, Finset.sum_mul, ← Finset.sum_sub_distrib] + _ = _ := by + apply Finset.sum_congr rfl + intro i _ + noncomm_ring + +theorem localizedOperator_sub_compact (c : OddCycle A) (a : ι → A) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : + IsCompactOperator (localizedOperator c a - c.operator) := by + rw [localizedOperator_sub_eq c a hpart] + exact (compactOperator (RingHom.id ℂ) c.space c.space).sum_mem + (fun i _ => compact_mul_left (c.commutator_compact (a i)) _) + +theorem localizedOperator_selfAdjoint (c : OddCycle A) (a : ι → A) + (hF : IsSelfAdjoint c.operator) (ha : ∀ i, IsSelfAdjoint (a i)) : + IsSelfAdjoint (localizedOperator c a) := + isSelfAdjoint_sum _ (fun i _ => hF.conjugate_self ((ha i).map c.representation)) + +@[simp] theorem localizedCycle_operator (c : OddCycle A) (a : ι → A) + (hF : IsSelfAdjoint c.operator) (ha : ∀ i, IsSelfAdjoint (a i)) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : + (localizedCycle c a hF ha hpart).operator = localizedOperator c a := by + change c.operator + (localizedOperator c a - c.operator) = localizedOperator c a + abel + +theorem localizedCycle_class (c : OddCycle A) (a : ι → A) + (hF : IsSelfAdjoint c.operator) (ha : ∀ i, IsSelfAdjoint (a i)) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : + cycleClass A (localizedCycle c a hF ha hpart) = cycleClass A c := + compactPerturb_class c (localizedOperator c a - c.operator) + (localizedOperator_sub_compact c a hpart) (by + rw [((localizedOperator_selfAdjoint c a hF ha).sub hF).star_eq] + exact localizedOperator_sub_compact c a hpart) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteRips.lean b/lean/OAI/Topology/CoarseAssembly/FiniteRips.lean new file mode 100644 index 0000000000000000000000000000000000000000..bd9b70226040f42ade45e094692d6797fa9f99fc --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteRips.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsPaths +import Mathlib.Topology.MetricSpace.ProperSpace + +namespace OAI + +/-! # Compactness of finite Rips realizations + +The finite Rips complex is a closed subset of the compact probability +simplex. In particular, its circle test has a compact domain. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open scoped BigOperators +open Topology + +variable {X : Type*} [PseudoMetricSpace X] [Fintype X] (r : ℝ) + +theorem range_coordinates : + Set.range (coordinates (X := X) (r := r)) = + {f : X → ℝ | (∀ x, 0 ≤ f x) ∧ (∑ x, f x) = 1 ∧ + ∀ x y, r < dist x y → f x = 0 ∨ f y = 0} := by + classical + ext f + constructor + · rintro ⟨p, rfl⟩ + refine ⟨p.nonneg, p.sum_weight, ?_⟩ + intro x y hxy + by_cases hx : p.weight x = 0 + · exact Or.inl hx + by_cases hy : p.weight y = 0 + · exact Or.inr hy + exact False.elim ((not_le_of_gt hxy) + (p.diameter x (Finsupp.mem_support_iff.mpr hx) y (Finsupp.mem_support_iff.mpr hy))) + · rintro ⟨hnn, ht, hd⟩ + let p : Point X r := + { weight := Finsupp.equivFunOnFinite.symm f + nonneg := hnn + total := by + rw [Finsupp.sum_fintype _ _ (by simp)] + exact ht + diameter := by + intro x hx y hy + by_contra h + rcases hd x y (lt_of_not_ge h) with hx' | hy' + · exact Finsupp.mem_support_iff.mp hx hx' + · exact Finsupp.mem_support_iff.mp hy hy' } + exact ⟨p, rfl⟩ + +theorem coordinates_closed : IsClosed (Set.range (coordinates (X := X) (r := r))) := by + rw [range_coordinates] + have hnn : IsClosed {f : X → ℝ | ∀ x, 0 ≤ f x} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun x => isClosed_le continuous_const (continuous_apply x) + have ht : IsClosed {f : X → ℝ | (∑ x, f x) = 1} := + isClosed_eq (continuous_finsetSum _ (fun x _ => continuous_apply x)) continuous_const + have hd : IsClosed {f : X → ℝ | ∀ x y, r < dist x y → f x = 0 ∨ f y = 0} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun x => isClosed_iInter fun y => isClosed_iInter fun _ => + (isClosed_eq (continuous_apply x) continuous_const).union + (isClosed_eq (continuous_apply y) continuous_const) + exact hnn.inter (ht.inter hd) + +theorem coordinates_compact : IsCompact (Set.range (coordinates (X := X) (r := r))) := by + apply IsCompact.of_isClosed_subset (isCompact_Icc (a := (0 : X → ℝ)) (b := 1)) + (coordinates_closed r) + rintro f ⟨p, rfl⟩ + refine ⟨p.nonneg, ?_⟩ + intro x + calc + p.weight x ≤ ∑ y : X, p.weight y := Finset.single_le_sum (fun y _ => p.nonneg y) + (Finset.mem_univ x) + _ = 1 := p.sum_weight + +instance : SecondCountableTopology (Point X r) := + (show IsEmbedding (coordinates (X := X) (r := r)) from + ⟨⟨rfl⟩, coordinates_injective⟩).secondCountableTopology + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteTailIndependence.lean b/lean/OAI/Topology/CoarseAssembly/FiniteTailIndependence.lean new file mode 100644 index 0000000000000000000000000000000000000000..3f8b9e11da1c65ce742a23f1198c1d6325ea318b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteTailIndependence.lean @@ -0,0 +1,53 @@ +import OAI.Topology.CoarseAssembly.FiniteHeadNormalization + +namespace OAI + +/-! # The whole-union boundary is unchanged by finitely many component changes -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + [SecondCountableTopology H] + +/-- Finite-head independence is proved within the single Roe algebra, +using controlled compact perturbations and equality of rational unitaries. -/ +theorem separatedFamilyBoundary_eq_of_tail (o : ∀ i, V i) + (A B : ∀ i, Operator (V i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (B i)) + (hAs : ∀ i, IsSelfAdjoint (A i)) (hBs : ∀ i, IsSelfAdjoint (B i)) + (hAsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) + (hBsq : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (V i) H))) + (J : Finset ℕ) (htail : ∀ i, i ∉ J → A i = B i) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hp hAs hAsq = + separatedFamilyBoundary o B D hD hB s hs hq hBs hBsq := by + let := separatedMetric o + let a := finiteHeadReplacement J A C hA r hp hAs hAsq + let b := finiteHeadReplacement J B D hB s hq hBs hBsq + have hC' : 0 ≤ max C 1 := zero_le_one.trans (le_max_right C 1) + have hD' : 0 ≤ max D 1 := zero_le_one.trans (le_max_right D 1) + have hr' : 0 ≤ max r (finiteHeadRadius (V := V) J) := hr.trans (le_max_left _ _) + have hs' : 0 ≤ max s (finiteHeadRadius (V := V) J) := hs.trans (le_max_left _ _) + have h1 := separatedFamilyBoundary_eq_of_component_compact o a.operator A (max C 1) C hC' hC a.norm_le hA + (max r (finiteHeadRadius (V := V) J)) r hr' hr a.propagation hp a.selfAdjoint hAs (a.square_compact hAsq) hAsq a.compact_diff + have h2 := separatedFamilyBoundary_eq_of_component_compact o b.operator B (max D 1) D hD' hD b.norm_le hB + (max s (finiteHeadRadius (V := V) J)) s hs' hs b.propagation hq b.selfAdjoint hBs (b.square_compact hBsq) hBsq b.compact_diff + have hm := separatedFamilyBoundary_eq_of_involutive_head o a.operator b.operator (max C 1) (max D 1) + hC' hD' a.norm_le b.norm_le (max r (finiteHeadRadius (V := V) J)) + (max s (finiteHeadRadius (V := V) J)) hr' hs' a.propagation b.propagation a.selfAdjoint b.selfAdjoint (a.square_compact hAsq) (b.square_compact hBsq) J + (fun i hi => (a.tail i hi).trans ((htail i hi).trans (b.tail i hi).symm)) a.involutive b.involutive + exact h1.symm.trans (hm.trans h2) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteWindingIndex.lean b/lean/OAI/Topology/CoarseAssembly/FiniteWindingIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..71b412c88a686ec84e60332a6ad62525ddf4a6ef --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteWindingIndex.lean @@ -0,0 +1,78 @@ +import OAI.Topology.CoarseAssembly.CirclePairing +import OAI.Topology.CoarseAssembly.RipsWindingTest + +namespace OAI + +/-! # The analytic winding test on a finite Rips component + +This derives the finite-component index evaluation from the explicit +published scalar-circle pairing. The cocycle, continuous map, parametrized +loop and its degree are explicit. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Rips Analytic + +variable {X : Type} [Fintype X] {G : SimpleGraph X} + +omit [Fintype X] in +theorem graphEdgeBound (hG : G.Connected) (r : ℕ) (hr : 1 ≤ r) : + letI := graphMetric G hG + ∀ x y, G.Adj x y → dist x y ≤ (r : ℝ) := by + let := graphMetric G hG + intro x y h + rw [graphMetric_eq G hG] + change (G.dist x y : ℝ) ≤ r + exact_mod_cast (G.dist_le h.toWalk).trans (by simpa using hr) + +/-- The analytic class of the parametrized boundary loop at this scale. -/ +def graphLoopClass (input : PublishedCircleInput) (hG : G.Connected) + (r : ℕ) (hr : 1 ≤ r) {x : X} (p : G.Walk x x) : + letI := graphMetric G hG + LocallyFiniteK1 (Point X (r : ℝ)) := by + let := graphMetric G hG + exact pushforward (compactMap (loopCircle (walkPath (by positivity) + (graphEdgeBound hG r hr) p))) input.fundamental + +/-- The finite-component analytic index is the original graph winding. -/ +theorem graph_loop_index (input : PublishedCircleInput) (hG : G.Connected) + (a : X → X → ℤ) (ha : ∀ x y, G.Adj x y → a y x = -a x y) + (r : ℕ) (hr : 1 ≤ r) + (hloop : ∀ x (p : G.Walk x x), p.length ≤ 3 * r → walkCharge a p = 0) + {x : X} (p : G.Walk x x) : + letI := graphMetric G hG + input.pairing (graphRipsCocycle hG a ha r hloop).toContinuousMap + (graphLoopClass input hG r hr p) = walkCharge a p := by + let := graphMetric G hG + let c := graphRipsCocycle hG a ha r hloop + change input.pairing c.toContinuousMap + (pushforward (compactMap (loopCircle (walkPath (by positivity) + (graphEdgeBound hG r hr) p))) input.fundamental) = _ + rw [input.loop_pairing c.toContinuousMap _ _ + (c.walkLift (by positivity) (graphEdgeBound hG r hr) p)] + exact graphRipsCocycle_on_walk hG a ha r hr hloop p + +/-- A charge-one boundary class has infinite order at the specified Rips +scale. Only the cited published circle-index input is conditional. -/ +theorem graph_loop_infinite_order (input : PublishedCircleInput) (hG : G.Connected) + (a : X → X → ℤ) (ha : ∀ x y, G.Adj x y → a y x = -a x y) + (r : ℕ) (hr : 1 ≤ r) + (hloop : ∀ x (p : G.Walk x x), p.length ≤ 3 * r → walkCharge a p = 0) + {x : X} (p : G.Walk x x) (hp : walkCharge a p = 1) + (n : ℤ) (hn : n ≠ 0) : + letI := graphMetric G hG + n • graphLoopClass input hG r hr p ≠ 0 := by + let := graphMetric G hG + intro h + have hi := graph_loop_index input hG a ha r hr hloop p + have h' := congrArg (input.pairing (graphRipsCocycle hG a ha r hloop).toContinuousMap) h + exact hn (by simpa [map_zsmul, hi, hp] using h') + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FiniteWords.lean b/lean/OAI/Topology/CoarseAssembly/FiniteWords.lean new file mode 100644 index 0000000000000000000000000000000000000000..c4021d5d08bc47b47ee6c6b7b844348f64f0fa12 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FiniteWords.lean @@ -0,0 +1,99 @@ +import OAI.Topology.CoarseAssembly.TraceObstruction + +namespace OAI + +/-! +# Uniform exclusion of short charged closed words + +This is the algebraic part of the small-loop lemma in §3, specialized to +`SL₃(ℤ)` and its actual congruence quotients. The finite family of possible +word traces is constructed, rather than postulated as an extra input. +-/ + +namespace CoarseAssembly.Congruence + +/-- Words of length at most `n` in a finite set of left moves. -/ +def wordBall (S : Finset ArithmeticGroup) : ℕ → Finset ArithmeticGroup + | 0 => {1} + | n + 1 => wordBall S n ∪ (wordBall S n).biUnion (fun w => S.image (w * ·)) + +theorem wordBall_mono (S : Finset ArithmeticGroup) {n m : ℕ} (h : n ≤ m) : + wordBall S n ⊆ wordBall S m := by + induction h with + | refl => exact Finset.Subset.refl _ + | step h ih => exact ih.trans Finset.subset_union_left + +theorem holonomyWord_mem (S : Finset ArithmeticGroup) (steps : List (ArithmeticGroup × ℤ)) + (hS : ∀ s ∈ steps, s.1 ∈ S) : holonomyWord steps ∈ wordBall S steps.length := by + induction steps with + | nil => simp [holonomyWord, wordBall] + | cons s steps ih => + have hs : s.1 ∈ S := hS s (by simp) + have ht : ∀ q ∈ steps, q.1 ∈ S := fun q hq => hS q (by simp [hq]) + apply Finset.mem_union_right + exact Finset.mem_biUnion.mpr ⟨holonomyWord steps, ih ht, + Finset.mem_image.mpr ⟨s.1, hs, rfl⟩⟩ + +theorem holonomyCharge_natAbs_le (steps : List (ArithmeticGroup × ℤ)) + (hs : ∀ s ∈ steps, s.2.natAbs ≤ 1) : (holonomyCharge steps).natAbs ≤ steps.length := by + induction steps with + | nil => simp [holonomyCharge] + | cons s steps ih => + have hhead : s.2.natAbs ≤ 1 := hs s (by simp) + have htail : (holonomyCharge steps).natAbs ≤ steps.length := + ih (fun q hq => hs q (by simp [hq])) + exact (Int.natAbs_add_le _ _).trans (by simpa [Nat.add_comm] using Nat.add_le_add hhead htail) + +/-- Reduction of each left move, preserving its signed base charge. -/ +def reduceSteps (k : ℕ) (steps : List (ArithmeticGroup × ℤ)) : List (Quotient k × ℤ) := + steps.map (fun s => (reduce k s.1, s.2)) + +@[simp] theorem holonomyCharge_reduceSteps (k : ℕ) (steps : List (ArithmeticGroup × ℤ)) : + holonomyCharge (reduceSteps k steps) = holonomyCharge steps := by + induction steps with + | nil => rfl + | cons s steps ih => simpa only [reduceSteps, List.map_cons, holonomyCharge] using congrArg (s.2 + ·) ih + +@[simp] theorem holonomyWord_reduceSteps (k : ℕ) (steps : List (ArithmeticGroup × ℤ)) : + holonomyWord (reduceSteps k steps) = reduce k (holonomyWord steps) := by + induction steps with + | nil => simp [reduceSteps, holonomyWord] + | cons s steps ih => + simpa only [reduceSteps, List.map_cons, holonomyWord, map_mul] using + congrArg (· * reduce k s.1) ih + +/-- At a sufficiently deep quotient, no bounded list of allowed Cayley/base +moves can close with nonzero charge. This conclusion does not assume a +spectral gap, a property-(T) theorem, or an analytic K-homology fact. -/ +theorem bounded_closed_lifts_have_zero_charge (t : ℤ_[2]ˣ) + (ht : Transcendental ℤ (t : ℤ_[2])) (S : Finset ArithmeticGroup) (A : ℕ) : + ∃ N : ℕ, 1 ≤ N ∧ ∀ k, N ≤ k → ∀ z : Quotient k, + ∀ steps : List (ArithmeticGroup × ℤ), steps.length ≤ A → + (∀ s ∈ steps, s.1 ∈ S ∧ s.2.natAbs ≤ 1) → + holonomyEndpoint (holonomy t k) (reduceSteps k steps) z = z → + holonomyCharge steps = 0 := by + let traces := (wordBall S A).image + (fun w => Matrix.trace ((w⁻¹ : ArithmeticGroup) : Matrix (Fin 3) (Fin 3) ℤ)) + obtain ⟨N, hN, hsep⟩ := matrix_trace_separation t ht A traces + refine ⟨N, hN, ?_⟩ + intro k hk z steps hlen hsteps hclosed + by_contra hcharge + have hpos : 1 ≤ (holonomyCharge steps).natAbs := + Nat.one_le_iff_ne_zero.mpr (Int.natAbs_ne_zero.mpr hcharge) + have hbound : (holonomyCharge steps).natAbs ≤ A := + (holonomyCharge_natAbs_le steps (fun s hs => (hsteps s hs).2)).trans hlen + have hword : holonomyWord steps ∈ wordBall S A := + wordBall_mono S hlen (holonomyWord_mem S steps (fun s hs => (hsteps s hs).1)) + have htrace : Matrix.trace (((holonomyWord steps)⁻¹ : ArithmeticGroup) : + Matrix (Fin 3) (Fin 3) ℤ) ∈ traces := + Finset.mem_image.mpr ⟨holonomyWord steps, hword, rfl⟩ + have hne := hsep k hk (holonomyCharge steps).natAbs + (Finset.mem_Icc.mpr ⟨hpos, hbound⟩) (holonomyWord steps)⁻¹ htrace + apply hne + rw [← trace_holonomy_natAbs] + simpa only [holonomyCharge_reduceSteps, holonomyWord_reduceSteps, map_inv] using + closed_walk_trace t k z (reduceSteps k steps) hclosed + +end CoarseAssembly.Congruence + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FredholmInvertible.lean b/lean/OAI/Topology/CoarseAssembly/FredholmInvertible.lean new file mode 100644 index 0000000000000000000000000000000000000000..65199cd9290f5adf21cf7c4de10b8a5d4d70b7f8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FredholmInvertible.lean @@ -0,0 +1,43 @@ +import OAI.Topology.CoarseAssembly.KernelProjection + +namespace OAI + +/-! # Invertibility after the finite-rank kernel correction -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem isUnit_of_injective_compact_square (G : End H) (hinj : Function.Injective G) + (hc : IsCompactOperator (G * G - 1 : End H)) : IsUnit G := by + have hne : ¬ Module.End.HasEigenvalue (G * G - 1).toLinearMap (-1) := by + intro he + obtain ⟨x, hx, hxne⟩ := he.exists_hasEigenvector + have hx' : G (G x) - x = -x := by + simpa using (Module.End.mem_eigenspace_iff.mp hx) + have hgg : G (G x) = 0 := + (sub_eq_iff_eq_add.mp hx').trans (neg_add_cancel x) + have hg : G x = 0 := hinj (hgg.trans G.map_zero.symm) + exact hxne (hinj (hg.trans G.map_zero.symm)) + have hr : (-1 : ℂ) ∈ resolventSet ℂ (G * G - 1) := + (hc.hasEigenvalue_or_mem_resolventSet (by norm_num)).resolve_left hne + have hu := (spectrum.mem_resolventSet_iff.mp hr).neg + simp only [map_neg, map_one] at hu + have hs : IsUnit (G * G) := by + convert hu using 1 + noncomm_ring + rw [← pow_two] at hs + exact (isUnit_pow_iff (by norm_num : (2 : ℕ) ≠ 0)).mp hs + +theorem kernel_corrected_isUnit (F : End H) (hF : IsSelfAdjoint F) + (hc : IsCompactOperator (F * F - 1 : End H)) : IsUnit (F + kernelProjection F) := + isUnit_of_injective_compact_square _ (kernel_corrected_injective F hF) + (kernel_corrected_compact_square F hF hc) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FredholmModule.lean b/lean/OAI/Topology/CoarseAssembly/FredholmModule.lean new file mode 100644 index 0000000000000000000000000000000000000000..9f524b911e3d49b3f176a1f73be6bf13f0f7f870 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FredholmModule.lean @@ -0,0 +1,60 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Analysis.CStarAlgebra.ContinuousLinearMap +import Mathlib.Analysis.Normed.Operator.Compact.Basic +import Mathlib.GroupTheory.FreeAbelianGroup +import Mathlib.GroupTheory.QuotientGroup.Defs +import OAI.Topology.CoarseAssembly.Conjugation + +namespace OAI + +/-! +# Odd analytic Fredholm modules + +These are the actual operator cycles for `KK₁(A, ℂ)`: a separable Hilbert +space, a star representation of `A`, and an operator whose commutator, +self-adjointness defect and square defect are locally compact. We keep +degenerate cycles, unitary equivalence, direct sum and norm homotopy explicit +so that the analytic group can be formed as a quotient, rather than supplied +as an arbitrary abelian group. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +universe u + +attribute [instance] HilbertSpace.normed HilbertSpace.inner + HilbertSpace.complete HilbertSpace.secondCountable + +variable (A : Type u) [NonUnitalCStarAlgebra A] + +variable {A} {B : Type u} [NonUnitalCStarAlgebra B] + +namespace OddCycle + +theorem Degenerate.precomp {c : OddCycle A} (hc : c.Degenerate) + (φ : B →⋆ₙₐ[ℂ] A) : (c.precomp φ).Degenerate := + ⟨fun b => hc.1 (φ b), fun b => hc.2.1 (φ b), fun b => hc.2.2 (φ b)⟩ + +@[simp] theorem precomp_id (c : OddCycle A) : + c.precomp (NonUnitalStarAlgHom.id ℂ A) = c := by cases c; rfl + +@[simp] theorem precomp_comp {C : Type u} [NonUnitalCStarAlgebra C] + (c : OddCycle A) (φ : B →⋆ₙₐ[ℂ] A) (ψ : C →⋆ₙₐ[ℂ] B) : + (c.precomp φ).precomp ψ = c.precomp (φ.comp ψ) := rfl + +end OddCycle + +namespace OddHomotopy + +@[simp] theorem precomp_eval (h : OddHomotopy A) (φ : B →⋆ₙₐ[ℂ] A) (t : Interval) : + (h.precomp φ).eval t = (h.eval t).precomp φ := rfl + +end OddHomotopy + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FredholmParametrix.lean b/lean/OAI/Topology/CoarseAssembly/FredholmParametrix.lean new file mode 100644 index 0000000000000000000000000000000000000000..4c92db96459cea277d79695ed0b5070d8054c52b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FredholmParametrix.lean @@ -0,0 +1,126 @@ +import OAI.Topology.CoarseAssembly.InvolutiveNormalization +import Mathlib.Analysis.Normed.Operator.Fredholm.Open + +namespace OAI + +/-! # Compact parametrices and finite-dimensional defects + +These are the finite-dimensional analytic ingredients for the scalar-unitary +index pairing. No index-pairing conclusion is assumed here. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem finiteDimensional_ker_of_compact_parametrix (S T : End H) + (hc : IsCompactOperator (S * T - 1 : End H)) : FiniteDimensional ℂ T.ker := by + let K : End H := S * T - 1 + let V : Submodule ℂ H := Module.End.eigenspace K.toLinearMap (-1) + have hv : FiniteDimensional ℂ V := + ContinuousLinearMap.finite_dimensional_eigenspace hc (-1) (by norm_num) + have hi : T.ker ≤ V := by + intro x hx + have hx' : T x = 0 := hx + rw [Module.End.mem_eigenspace_iff] + simp [K, hx'] + let := hv + exact FiniteDimensional.of_injective (Submodule.inclusion hi) (Submodule.inclusion_injective hi) + +theorem compact_idempotent_finiteRange (P : End H) (hp : P * P = P) + (hc : IsCompactOperator P) : LinearMap.HasFiniteRange P.toLinearMap := by + let V : Submodule ℂ H := Module.End.eigenspace P.toLinearMap 1 + have hv : FiniteDimensional ℂ V := + ContinuousLinearMap.finite_dimensional_eigenspace hc 1 one_ne_zero + have hi : P.range ≤ V := by + rintro y ⟨x, rfl⟩ + rw [Module.End.mem_eigenspace_iff, one_smul] + exact congrArg (fun T : End H => T x) hp + let := hv + apply (Submodule.fg_iff_finiteDimensional _).mpr + exact FiniteDimensional.of_injective (Submodule.inclusion hi) (Submodule.inclusion_injective hi) + +theorem fredholm_of_finite_parametrix (S T : End H) + (hl : LinearMap.HasFiniteRange (S * T - 1 : End H).toLinearMap) + (hr : LinearMap.HasFiniteRange (T * S - 1 : End H).toLinearMap) : T.IsFredholm := by + apply ContinuousLinearMap.IsFredholm.of_isQuasiInverse (v := S) + constructor + · rw [LinearMap.IsLeftQuasiInverse, LinearMap.FiniteRangeSetoid.equiv_iff_hasFiniteRange] + exact hl + · rw [LinearMap.IsRightQuasiInverse, LinearMap.FiniteRangeSetoid.equiv_iff_hasFiniteRange] + exact hr + +theorem isFredholm_of_compact_essential_unitary (T : End H) + (hl : IsCompactOperator (star T * T - 1 : End H)) + (hr : IsCompactOperator (T * star T - 1 : End H)) : T.IsFredholm := by + let G : End H := star T * T + have hG : IsSelfAdjoint G := IsSelfAdjoint.star_mul_self T + have hcG : IsCompactOperator (G * G - 1 : End H) := by + have he : G * G - 1 = G * (G - 1) + (G - 1) := by noncomm_ring + rw [he] + exact (compact_mul_left hl G).add hl + let P := kernelProjection G + have hP := kernelProjection_compact G hcG + have hPP : P * P = P := kernelProjection_sq G + have hTP : T * P = 0 := by + ext x + have hx : G (P x) = 0 := congrArg (fun A : End H => A x) (mul_kernelProjection G) + have he : G.ker = T.ker := ContinuousLinearMap.ker_adjoint_comp_self T + have hx' : P x ∈ G.ker := hx + exact (show P x ∈ T.ker from he ▸ hx') + have hu : IsUnit (G + P) := kernel_corrected_isUnit G hG hcG + let V : End H := ↑(hu.unit⁻¹) + have hVA : V * (G + P) = 1 := by + rw [← hu.unit_spec] + exact Units.inv_mul hu.unit + have hVP : V * P = P := by + have hAP : (G + P) * P = P := by + rw [add_mul, mul_kernelProjection G, hPP, zero_add] + calc + V * P = V * ((G + P) * P) := by rw [hAP] + _ = (V * (G + P)) * P := (mul_assoc _ _ _).symm + _ = P := by rw [hVA, one_mul] + let S : End H := V * star T + have hST : S * T = 1 - P := by + calc + S * T = V * (G + P) - V * P := by dsimp only [S, G]; noncomm_ring + _ = 1 - P := by rw [hVA, hVP] + have hVm : IsCompactOperator (V - 1 : End H) := by + have he : V - 1 = -(V * ((G - 1) + P)) := by + calc + V - 1 = V - V * (G + P) := by rw [hVA] + _ = -(V * ((G - 1) + P)) := by noncomm_ring + rw [he] + exact (compact_mul_left (hl.add hP) V).neg + have hTS : IsCompactOperator (T * S - 1 : End H) := by + have he : T * S - 1 = (T * star T - 1) + (T * (V - 1)) * star T := by + dsimp only [S] + noncomm_ring + rw [he] + exact hr.add (compact_mul_right (compact_mul_left hVm T) (star T)) + have hTSsq : (T * S) * (T * S) = T * S := by + calc + (T * S) * (T * S) = T * (S * T) * S := by noncomm_ring + _ = T * S := by rw [hST, mul_sub, mul_one, hTP, sub_zero] + have hQsq : (1 - T * S) * (1 - T * S) = 1 - T * S := by + calc + _ = 1 - T * S - T * S + (T * S) * (T * S) := by noncomm_ring + _ = 1 - T * S := by rw [hTSsq]; abel + have hQ : IsCompactOperator (1 - T * S : End H) := by + rw [show (1 : End H) - T * S = -(T * S - 1) by abel] + exact hTS.neg + have hlfin : LinearMap.HasFiniteRange (S * T - 1 : End H).toLinearMap := by + rw [hST, show (1 : End H) - P - 1 = -P by abel] + exact (compact_idempotent_finiteRange P hPP hP).neg + have hrfin : LinearMap.HasFiniteRange (T * S - 1 : End H).toLinearMap := by + rw [show T * S - (1 : End H) = -(1 - T * S) by abel] + exact (compact_idempotent_finiteRange _ hQsq hQ).neg + exact fredholm_of_finite_parametrix S T hlfin hrfin + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/FredholmSquare.lean b/lean/OAI/Topology/CoarseAssembly/FredholmSquare.lean new file mode 100644 index 0000000000000000000000000000000000000000..72795a4a9f57e045802401c7cd0a2af913ca9a5a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/FredholmSquare.lean @@ -0,0 +1,44 @@ +import OAI.Topology.CoarseAssembly.UnitalCycleNormalization +import Mathlib.Analysis.InnerProductSpace.Spectrum + +namespace OAI + +/-! # Finite-dimensional kernels from the compact square defect + +The kernel of `F` lies in the `-1` eigenspace of the compact operator +`F² - 1`. This supplies the finite-dimensional obstruction needed before +replacing a unital odd Fredholm operator by an invertible one. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +theorem finiteDimensional_ker_of_compact_square {H : HilbertSpace} (F : End H) + (hF : IsCompactOperator (F * F - 1 : End H)) : + FiniteDimensional ℂ F.ker := by + let K : End H := F * F - 1 + let V : Submodule ℂ H := Module.End.eigenspace K.toLinearMap (-1) + have hV : FiniteDimensional ℂ V := + ContinuousLinearMap.finite_dimensional_eigenspace hF (-1) (by norm_num) + have hi : F.ker ≤ V := by + intro x hx + have hx' : F x = 0 := hx + change x ∈ Module.End.eigenspace K.toLinearMap (-1) + rw [Module.End.mem_eigenspace_iff] + simp [K, hx'] + let := hV + exact FiniteDimensional.of_injective (Submodule.inclusion hi) + (Submodule.inclusion_injective hi) + +theorem OddCycle.finiteDimensional_ker {A : Type} [CStarAlgebra A] + (c : OddCycle A) (hunital : c.representation 1 = 1) : + FiniteDimensional ℂ c.operator.ker := by + apply finiteDimensional_ker_of_compact_square + simpa only [hunital, mul_one] using c.square_compact 1 + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/GraphFiberOperators.lean b/lean/OAI/Topology/CoarseAssembly/GraphFiberOperators.lean new file mode 100644 index 0000000000000000000000000000000000000000..bad05c1e4c471cc374274c50431570eb452c4b03 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/GraphFiberOperators.lean @@ -0,0 +1,96 @@ +import OAI.Topology.CoarseAssembly.CongruenceEdgeOperators +import OAI.Topology.CoarseAssembly.FiberedGraph + +namespace OAI + +/-! # Controlled transport along the base graph + +The three depth cases give actual contractions on the finite scalar Hilbert +spaces. Their nonzero coefficients are supported on edges of the constructed +fibered graph, not on an assumed transport relation. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +private theorem isometry_norm_le_one {E F : Type*} + [NormedAddCommGroup E] [NormedSpace ℂ E] + [NormedAddCommGroup F] [NormedSpace ℂ F] (V : E →ₗᵢ[ℂ] F) : + ‖V.toContinuousLinearMap‖ ≤ 1 := by + apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one + intro x + simpa only [LinearIsometry.coe_toContinuousLinearMap, V.norm_map, one_mul] using le_rfl (a := ‖x‖) + +/-- Transport between adjacent depths, with its exact reduced support. -/ +theorem exists_depth_operator (t : ℤ_[2]ˣ) (k l : ℕ) (a : ℤ) + (hkl : |(k : ℤ) - (l : ℤ)| ≤ 1) : + ∃ O : lp (fun _ : Quotient k => ℂ) 2 →L[ℂ] lp (fun _ : Quotient l => ℂ) 2, + ‖O‖ ≤ 1 ∧ O (fiberConstant (Quotient k) (1 : ℂ)) = + fiberConstant (Quotient l) 1 ∧ + ∀ q z, O (lp.single 2 q 1) z ≠ 0 → + ∀ m (hm : m ≤ k) (hl : m ≤ l), + quotientMap hl z = quotientMap hm q * holonomy t m ^ a := by + have hcases : k = l ∨ l = k + 1 ∨ k = l + 1 := by + rw [abs_le] at hkl + omega + rcases hcases with rfl | rfl | rfl + · refine ⟨(sameLevelIsometry t k a).toLinearIsometry.toContinuousLinearMap, + isometry_norm_le_one _, sameLevelIsometry_constant t k a, ?_⟩ + intro q z hn m hm hl + have he : z = q * holonomy t k ^ a := by + by_contra he + exact hn (sameLevelIsometry_support t k a q z he) + rw [he, map_mul, map_zpow, quotientMap_holonomy] + · refine ⟨(childIsometry t k a).toContinuousLinearMap, + isometry_norm_le_one _, childIsometry_constant t k a, ?_⟩ + intro q z hn m hm hl + have he : quotientMap (Nat.le_succ k) z = q * holonomy t k ^ a := by + by_contra he + exact hn (childIsometry_support t k a q z he) + have hr := congrArg (quotientMap hm) he + simpa only [map_mul, map_zpow, quotientMap_holonomy, quotientMap_comp] using hr + · refine ⟨(childIsometry t l (-a)).toContinuousLinearMap.adjoint, ?_, + childAdjoint_constant t l (-a), ?_⟩ + · rw [LinearIsometryEquiv.norm_map] + exact isometry_norm_le_one _ + · intro q z hn m hm hl + have he : quotientMap (Nat.le_succ l) q = z * holonomy t l ^ (-a) := by + by_contra he + exact hn (childAdjoint_support t l (-a) z q he) + have hz : z = quotientMap (Nat.le_succ l) q * holonomy t l ^ a := by + rw [he, zpow_neg] + group + have hr := congrArg (quotientMap hl) hz + simpa only [map_mul, map_zpow, quotientMap_holonomy, quotientMap_comp] using hr + +/-- Each base edge has a contraction preserving constants, whose matrix +coefficients are supported on actual edges upstairs. -/ +theorem exists_base_edge_operator (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} {u v : Disc j} (huv : (discGraph j).Adj u v) : + ∃ O : lp (fun _ : Quotient (discDepth j u) => ℂ) 2 →L[ℂ] + lp (fun _ : Quotient (discDepth j v) => ℂ) 2, + ‖O‖ ≤ 1 ∧ O (fiberConstant (Quotient (discDepth j u)) (1 : ℂ)) = + fiberConstant (Quotient (discDepth j v)) 1 ∧ + ∀ q z, ¬(fiberedGraph S t j).Adj ⟨u, q⟩ ⟨v, z⟩ → + O (lp.single 2 q 1) z = 0 := by + obtain ⟨O, hnorm, hconst, hsupp⟩ := exists_depth_operator t + (discDepth j u) (discDepth j v) (latticeCharge u.val v.val) (discDepth_adj huv) + refine ⟨O, hnorm, hconst, ?_⟩ + intro q z hnot + by_contra hn + apply hnot + refine ⟨?_, 1, one_mem_symmetricMoves S, Or.inr ⟨huv, rfl⟩, ?_⟩ + · intro heq + have huv' := congrArg (fun x : FiberVertex j => x.1.val) heq + exact huv.2.2.2 huv' + · intro m hm hl + simpa only [fiberCoordinate, fiberCharge, map_one, one_mul] using hsupp q z hn m hm hl + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/GraphMetric.lean b/lean/OAI/Topology/CoarseAssembly/GraphMetric.lean new file mode 100644 index 0000000000000000000000000000000000000000..f96e644f4d0703daf36ebac9cd20acbfcfb131d1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/GraphMetric.lean @@ -0,0 +1,62 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.BoundedGeometry +import Mathlib.Topology.MetricSpace.Basic +import Mathlib.Algebra.Order.Floor.Semiring + +namespace OAI + +/-! # The metric of a connected graph + +The metric on a connected graph is exactly the real-valued shortest-path +length. A proof-independent extension uses the discrete metric otherwise. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {V : Type*} (G : SimpleGraph V) + +theorem graphMetricOrDiscrete_eq (hG : G.Connected) : + graphMetricOrDiscrete G = connectedGraphMetric G hG := by + classical + simp only [graphMetricOrDiscrete, dite_eq_left hG] + +@[instance_reducible] def graphMetric (_hG : G.Connected) : MetricSpace V := + graphMetricOrDiscrete G + +theorem graphMetric_eq (hG : G.Connected) : + graphMetric G hG = connectedGraphMetric G hG := + graphMetricOrDiscrete_eq G hG + +theorem graphMetric_separated (hG : G.Connected) {x y : V} (hxy : x ≠ y) : + (1 : ℝ) ≤ @dist V (graphMetric G hG).toDist x y := by + rw [graphMetric_eq] + change (1 : ℝ) ≤ (G.dist x y : ℝ) + exact_mod_cast hG.pos_dist_of_ne hxy + +/-- An exact metric ball, with the explicit bound inherited from degree. -/ +theorem graphMetric_ball_bound [DecidableEq V] (hG : G.Connected) + (neighbors : V → Finset V) (d : ℕ) + (hN : ∀ x y, G.Adj x y → y ∈ neighbors x) + (hd : ∀ x, (neighbors x).card ≤ d) (R : ℝ) (x : V) : + ∃ b : Finset V, + (∀ y, y ∈ b ↔ (G.dist x y : ℝ) ≤ R) ∧ b.card ≤ (d + 1) ^ ⌈R⌉₊ := by + classical + let b := (walkBall neighbors x ⌈R⌉₊).filter (fun y => (G.dist x y : ℝ) ≤ R) + refine ⟨b, ?_, ?_⟩ + · intro y + simp only [b, Finset.mem_filter] + refine ⟨fun h => h.2, fun hy => ⟨?_, hy⟩⟩ + obtain ⟨p, hp⟩ := hG.exists_walk_length_eq_dist x y + have hlen : p.length ≤ ⌈R⌉₊ := by + rw [hp] + exact_mod_cast hy.trans (Nat.le_ceil R) + exact walkBall_mono neighbors x hlen (endpoint_mem_walkBall neighbors hN p) + · exact (Finset.card_filter_le _ _).trans (card_walkBall_le neighbors d hd x ⌈R⌉₊) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/HexagonSides.lean b/lean/OAI/Topology/CoarseAssembly/HexagonSides.lean new file mode 100644 index 0000000000000000000000000000000000000000..1cf6c0469992dd188fc15ab725bc7a6d292d11cd --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/HexagonSides.lean @@ -0,0 +1,128 @@ +import OAI.Topology.CoarseAssembly.BoundaryWalks + +namespace OAI + +/-! # The six oriented sides of the lattice hexagon + +These explicit vertex sequences support the boundary-walk construction. +They run counterclockwise from `(j,0)`; only the final side crosses the +half-open positive ray used by the integral charge. +-/ + +namespace CoarseAssembly + +def hexagonPoint (s : Fin 6) (j k : ℕ) : LatticeVertex := + match s.val with + | 0 => ((j : ℤ) - k, k) + | 1 => (-(k : ℤ), j) + | 2 => (-(j : ℤ), (j : ℤ) - k) + | 3 => (-(j : ℤ) + k, -(k : ℤ)) + | 4 => (k, -(j : ℤ)) + | _ => (j, -(j : ℤ) + k) + +theorem hexagonPoint_radius (s : Fin 6) (j k : ℕ) (hk : k ≤ j) : + latticeRadius (hexagonPoint s j k) = j := by + have hk' : (k : ℤ) ≤ j := by exact_mod_cast hk + have hj : (0 : ℤ) ≤ j := by positivity + have hn : (0 : ℤ) ≤ k := by positivity + fin_cases s <;> simp only [hexagonPoint, latticeRadius] + all_goals + apply le_antisymm + · simp only [max_le_iff, abs_le] + omega + · try simp only [show -(j : ℤ) + k + -(k : ℤ) = -(j : ℤ) by ring] + try simp only [show (j : ℤ) - k + k = (j : ℤ) by ring] + try simp only [abs_of_nonneg hj, abs_neg] + omega + +def hexagonVertex (s : Fin 6) (j k : ℕ) (hk : k ≤ j) : BoundaryComponent j := + ⟨⟨hexagonPoint s j k, (hexagonPoint_radius s j k hk).le⟩, + (discDepth_eq_zero_iff _ _).mpr (hexagonPoint_radius s j k hk)⟩ + +theorem hexagonPoint_adj (s : Fin 6) (j k : ℕ) : + triangularGraph.Adj (hexagonPoint s j k) (hexagonPoint s j (k + 1)) := by + fin_cases s <;> simp only [hexagonPoint, triangularGraph, Nat.cast_add, Nat.cast_one, + abs_le, ne_eq, Prod.mk.injEq] <;> omega + +theorem hexagonVertex_adj (s : Fin 6) (j k : ℕ) (hk : k + 1 ≤ j) : + (boundaryGraph j).Adj (hexagonVertex s j k (by omega)) (hexagonVertex s j (k + 1) hk) := + hexagonPoint_adj s j k + +theorem hexagonPoint_charge (s : Fin 6) (j k : ℕ) (hk : k < j) : + latticeCharge (hexagonPoint s j k) (hexagonPoint s j (k + 1)) = + if s = 5 ∧ k + 1 = j then 1 else 0 := by + have hk' : (k : ℤ) < j := by exact_mod_cast hk + have hj : (0 : ℤ) < j := by exact_mod_cast (Nat.zero_lt_of_lt hk) + have hn : (0 : ℤ) ≤ k := by positivity + fin_cases s <;> simp only [hexagonPoint, latticeCharge, Nat.cast_add, Nat.cast_one] + all_goals split_ifs <;> norm_num at * <;> omega + +def hexagonSideWalk (s : Fin 6) (j : ℕ) : (k : ℕ) → (hk : k ≤ j) → + (boundaryGraph j).Walk (hexagonVertex s j 0 (Nat.zero_le j)) (hexagonVertex s j k hk) + | 0, _ => .nil + | k + 1, hk => (hexagonSideWalk s j k (by omega)).append + (hexagonVertex_adj s j k hk).toWalk + +def boundaryCharge {j : ℕ} (x y : BoundaryComponent j) : ℤ := + latticeCharge x.val.val y.val.val + +theorem hexagonSideWalk_charge (s : Fin 6) (j k : ℕ) (hk : k ≤ j) : + walkCharge boundaryCharge (hexagonSideWalk s j k hk) = + if s = 5 ∧ k = j ∧ 0 < j then 1 else 0 := by + induction k with + | zero => + simp only [hexagonSideWalk, walkCharge_nil] + split_ifs <;> omega + | succ k ih => + have hklt : k < j := by omega + rw [hexagonSideWalk, walkCharge_append, ih (by omega), walkCharge_cons, + walkCharge_nil, add_zero] + change (if s = 5 ∧ k = j ∧ 0 < j then (1 : ℤ) else 0) + + latticeCharge (hexagonPoint s j k) (hexagonPoint s j (k + 1)) = _ + rw [hexagonPoint_charge s j k hklt] + simp only [show k ≠ j by omega, and_false, false_and, ite_false, zero_add] + split_ifs <;> omega + +def hexagonCorner (s : Fin 6) (j : ℕ) : BoundaryComponent j := + hexagonVertex s j 0 (Nat.zero_le j) + +theorem hexagonSide_end (s : Fin 6) (j : ℕ) : + hexagonVertex s j j le_rfl = hexagonCorner (s + 1) j := by + fin_cases s <;> apply Subtype.ext <;> apply Subtype.ext <;> + simp [hexagonVertex, hexagonCorner, hexagonPoint] + +def hexagonSide (s : Fin 6) (j : ℕ) : + (boundaryGraph j).Walk (hexagonCorner s j) (hexagonCorner (s + 1) j) := + (hexagonSideWalk s j j le_rfl).copy rfl (hexagonSide_end s j) + +theorem hexagonSide_charge (s : Fin 6) (j : ℕ) : + walkCharge boundaryCharge (hexagonSide s j) = if s = 5 ∧ 0 < j then 1 else 0 := by + have h := walkCharge_copy boundaryCharge (hexagonSideWalk s j j le_rfl) + (show hexagonVertex s j 0 (Nat.zero_le j) = hexagonCorner s j from rfl) + (hexagonSide_end s j) + exact h.trans (by simpa only [and_true, true_and] using hexagonSideWalk_charge s j j le_rfl) + +theorem hexagonCorner_zero (j : ℕ) : hexagonCorner 0 j = boundaryRoot j := by + apply Subtype.ext + apply Subtype.ext + simp [hexagonCorner, hexagonVertex, hexagonPoint, boundaryRoot, discBoundaryBase] + +def hexagonalWalk (j : ℕ) : (boundaryGraph j).Walk (boundaryRoot j) (boundaryRoot j) := + (((((hexagonSide 0 j).append (hexagonSide 1 j)).append (hexagonSide 2 j)).append + (hexagonSide 3 j)).append (hexagonSide 4 j) |>.append (hexagonSide 5 j)).copy + (hexagonCorner_zero j) (hexagonCorner_zero j) + +theorem hexagonalWalk_charge (j : ℕ) (hj : 0 < j) : + walkCharge boundaryCharge (hexagonalWalk j) = 1 := by + simp only [hexagonalWalk, walkCharge_copy, walkCharge_append, hexagonSide_charge] + norm_num [hj] + +def hexagonalBoundaryWalks : HexagonalBoundaryWalks where + walk := hexagonalWalk + charge_one j hj := by + rw [walkCharge_map] + exact hexagonalWalk_charge j (by omega) + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/HilbertHeadTail.lean b/lean/OAI/Topology/CoarseAssembly/HilbertHeadTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..4c0f159302ca9a5906938a9332b6568572b9799a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/HilbertHeadTail.lean @@ -0,0 +1,100 @@ +import OAI.Topology.CoarseAssembly.CountableHilbertSum + +namespace OAI + +/-! # The head and tail decomposition used in finite-cycle telescoping -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable (H : ℕ → HilbertSpace) + +def tailInsertVector (x : countableHilbertSpace (fun j => H (j + 1))) : + countableHilbertSpace H := + ⟨(fun | 0 => 0 | j + 1 => x j), by + apply memℓp_gen + simp only [ENNReal.toReal_ofNat, Real.rpow_two] + apply (summable_nat_add_iff 1).mp + exact l2_summable_sq x⟩ + +theorem tailInsertVector_norm (x : countableHilbertSpace (fun j => H (j + 1))) : + ‖tailInsertVector H x‖ = ‖x‖ := by + have he : ‖tailInsertVector H x‖ ^ 2 = ‖x‖ ^ 2 := by + rw [l2_norm_sq, l2_norm_sq, (l2_summable_sq (tailInsertVector H x)).tsum_eq_zero_add] + change ‖(0 : H 0)‖ ^ 2 + ∑' j, ‖x j‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 + simp + nlinarith [norm_nonneg x, norm_nonneg (tailInsertVector H x)] + +def tailInsert : countableHilbertSpace (fun j => H (j + 1)) →ₗᵢ[ℂ] countableHilbertSpace H where + toFun := tailInsertVector H + map_add' x y := by + apply lp.ext + funext j + cases j with + | zero => change (0 : H 0) = 0 + 0; simp + | succ j => rfl + map_smul' z x := by + apply lp.ext + funext j + cases j <;> simp [tailInsertVector] + norm_map' := tailInsertVector_norm H + +@[simp] theorem tailInsert_zero (x : countableHilbertSpace (fun j => H (j + 1))) : + tailInsert H x 0 = 0 := rfl + +@[simp] theorem tailInsert_succ (x : countableHilbertSpace (fun j => H (j + 1))) (j : ℕ) : + tailInsert H x (j + 1) = x j := rfl + +theorem tailInsert_single (j : ℕ) (y : H (j + 1)) : + tailInsert H (lp.single 2 j y) = lp.single 2 (j + 1) y := by + apply lp.ext + funext k + cases k with + | zero => simp [tailInsert, tailInsertVector] + | succ k => + by_cases hk : k = j + · subst k + simp [tailInsert, tailInsertVector, lp.single_apply] + · simp [tailInsert, tailInsertVector, lp.single_apply, hk] + +theorem tailInsert_adjoint_apply (x : countableHilbertSpace H) (j : ℕ) : + (tailInsert H).toContinuousLinearMap.adjoint x j = x (j + 1) := by + apply ext_inner_left ℂ + intro y + rw [← lp.inner_single_left (𝕜 := ℂ) (G := fun j => H (j + 1)), + ContinuousLinearMap.adjoint_inner_right] + change inner ℂ (tailInsert H (lp.single 2 j y)) x = inner ℂ y (x (j + 1)) + rw [tailInsert_single, lp.inner_single_left] + +theorem head_tail_orthogonal : + (summandIsometry H 0).toContinuousLinearMap.adjoint.comp + (tailInsert H).toContinuousLinearMap = 0 := by + rw [summandIsometry_adjoint] + ext x + rfl + +theorem head_tail_exhaustive : + (summandIsometry H 0).toContinuousLinearMap.comp + (summandIsometry H 0).toContinuousLinearMap.adjoint + + (tailInsert H).toContinuousLinearMap.comp (tailInsert H).toContinuousLinearMap.adjoint = 1 := by + rw [summandIsometry_adjoint] + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change (lp.single (E := fun j => H j) 2 0 (x 0)) j + + (tailInsert H ((tailInsert H).toContinuousLinearMap.adjoint x)) j = x j + cases j with + | zero => + rw [tailInsert_zero] + simp + | succ j => + rw [tailInsert_succ, tailInsert_adjoint_apply] + simp + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/HilbertSum.lean b/lean/OAI/Topology/CoarseAssembly/HilbertSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..34d0720ebb801019163bd707f463eee8dd1c1795 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/HilbertSum.lean @@ -0,0 +1,71 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.BlockOperators +import Mathlib.Analysis.InnerProductSpace.l2Space +import Mathlib.Topology.Algebra.InfiniteSum.Real + +namespace OAI + +/-! # Flattening the Hilbert sum of the finite fibers + +The transfer is naturally constructed as a block operator. Flattening its +Hilbert sum identifies it isometrically with the ordinary Roe module on +the sigma type of vertices. Both directions and the norm identity are +constructed from summability of squared norms. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {ι : Type*} {Q : ι → Type*} {H : Type*} +variable [NormedAddCommGroup H] [NormedSpace ℂ H] + +theorem l2_norm_sq {J : Type*} {E : J → Type*} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 := by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x + +theorem l2_summable_sq {J : Type*} {E : J → Type*} [∀ j, NormedAddCommGroup (E j)] + (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) := by + simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using + (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal) + +omit [NormedSpace ℂ H] in +theorem flattenVector_norm (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) : + ‖flattenVector x‖ = ‖x‖ := by + have hsq : ‖flattenVector x‖ ^ 2 = ‖x‖ ^ 2 := by + calc + _ = ∑' q, ‖flattenVector x q‖ ^ 2 := l2_norm_sq _ + _ = ∑' i, ∑' q : Q i, ‖flattenVector x ⟨i, q⟩‖ ^ 2 := + Summable.tsum_sigma' (fun i => l2_summable_sq (x i)) + (l2_summable_sq (flattenVector x)) + _ = ∑' i, ‖x i‖ ^ 2 := tsum_congr (fun i => (l2_norm_sq (x i)).symm) + _ = ‖x‖ ^ 2 := (l2_norm_sq x).symm + nlinarith [norm_nonneg (flattenVector x), norm_nonneg x] + +def flattenIsometry : + lp (fun i => lp (fun _ : Q i => H) 2) 2 →ₗᵢ[ℂ] lp (fun _ : Sigma Q => H) 2 where + toFun := flattenVector + map_add' _ _ := rfl + map_smul' _ _ := rfl + norm_map' := flattenVector_norm + +omit [NormedSpace ℂ H] in +@[simp] theorem flatten_unflatten (x : lp (fun _ : Sigma Q => H) 2) : + flattenVector (unflattenVector x) = x := by + apply lp.ext + rfl + +omit [NormedSpace ℂ H] in +@[simp] theorem unflatten_flatten (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) : + unflattenVector (flattenVector x) = x := by + apply lp.ext + funext i + apply lp.ext + rfl + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Holonomy.lean b/lean/OAI/Topology/CoarseAssembly/Holonomy.lean new file mode 100644 index 0000000000000000000000000000000000000000..915d5c9b48363bb0904d1fde436d5e71f2da0752 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Holonomy.lean @@ -0,0 +1,79 @@ +import Mathlib.Data.List.Basic +import Mathlib.Tactic.Group + +namespace OAI + +/-! +# The group calculation for a charged closed walk + +In §3, left Cayley moves commute with the right holonomy. Recording a step +as `(s,m)` means `z ↦ s * z * g^m`; a pure Cayley step has `m=0`, and a +pure base step has `s=1`. The accumulated endpoint formula and conjugacy +obstruction are expressed using an actual finite list of steps. +-/ + +namespace CoarseAssembly + +variable {Q : Type*} [Group Q] + +/-- Successively apply left Cayley moves and right integral holonomies. -/ +def holonomyEndpoint (g : Q) : List (Q × ℤ) → Q → Q + | [], z => z + | s :: steps, z => holonomyEndpoint g steps (s.1 * z * g ^ s.2) + +/-- Product of the left moves, in the order in which they act. -/ +def holonomyWord : List (Q × ℤ) → Q + | [] => 1 + | s :: steps => holonomyWord steps * s.1 + +/-- Total signed crossing count. -/ +def holonomyCharge : List (Q × ℤ) → ℤ + | [] => 0 + | s :: steps => s.2 + holonomyCharge steps + +/-- Left multiplication and right holonomy accumulate independently. -/ +theorem holonomyEndpoint_eq (g z : Q) (steps : List (Q × ℤ)) : + holonomyEndpoint g steps z = holonomyWord steps * z * g ^ holonomyCharge steps := by + induction steps generalizing z with + | nil => simp [holonomyEndpoint, holonomyWord, holonomyCharge] + | cons s steps ih => + simp only [holonomyEndpoint, holonomyWord, holonomyCharge, ih, zpow_add] + group + +/-- A closed walk forces its right holonomy to be conjugate to the inverse +of its left word. No commutativity of the finite quotient is assumed. -/ +theorem holonomy_conjugacy (g z : Q) (steps : List (Q × ℤ)) + (hclosed : holonomyEndpoint g steps z = z) : + g ^ holonomyCharge steps = z⁻¹ * (holonomyWord steps)⁻¹ * z := by + rw [holonomyEndpoint_eq] at hclosed + calc + g ^ holonomyCharge steps = + (z⁻¹ * (holonomyWord steps)⁻¹) * + (holonomyWord steps * z * g ^ holonomyCharge steps) := by group + _ = z⁻¹ * (holonomyWord steps)⁻¹ * z := by rw [hclosed] + +/-- Any conjugacy invariant, in particular matrix trace, detects the +obstruction supplied by a closed charged walk. -/ +theorem holonomy_invariant_eq {T : Type*} (tr : Q → T) + (htr : ∀ q z, tr (z⁻¹ * q * z) = tr q) + (g z : Q) (steps : List (Q × ℤ)) + (hclosed : holonomyEndpoint g steps z = z) : + tr (g ^ holonomyCharge steps) = tr (holonomyWord steps)⁻¹ := by + rw [holonomy_conjugacy g z steps hclosed, htr] + +/-- If a conjugacy invariant separates all the nonzero possible charges +from the inverse left word, a closed walk has charge zero. This is the +algebraic contradiction used after reducing to the minimum-depth quotient. -/ +theorem holonomyCharge_eq_zero {T : Type*} (tr : Q → T) + (htr : ∀ q z, tr (z⁻¹ * q * z) = tr q) + (g z : Q) (steps : List (Q × ℤ)) + (hclosed : holonomyEndpoint g steps z = z) + (hsep : holonomyCharge steps ≠ 0 → + tr (g ^ holonomyCharge steps) ≠ tr (holonomyWord steps)⁻¹) : + holonomyCharge steps = 0 := by + by_contra hn + exact hsep hn (holonomy_invariant_eq tr htr g z steps hclosed) + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/HomogeneousReindex.lean b/lean/OAI/Topology/CoarseAssembly/HomogeneousReindex.lean new file mode 100644 index 0000000000000000000000000000000000000000..fb9c6e99249dec4a695c2e424f383d88af03e84f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/HomogeneousReindex.lean @@ -0,0 +1,99 @@ +import OAI.Topology.CoarseAssembly.CountableHilbertSum + +namespace OAI + +/-! # Reindexing repeated Hilbert summands for finite telescoping -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable (H : HilbertSpace) + +abbrev repeatedHilbert := countableHilbertSpace (fun _ : ℕ => H) + +def reindexRepeated (e : ℕ ≃ ℕ) (x : repeatedHilbert H) : repeatedHilbert H := + ⟨fun j => x (e.symm j), by + apply memℓp_gen + simp only [ENNReal.toReal_ofNat, Real.rpow_two] + exact e.symm.summable_iff.mpr (l2_summable_sq x)⟩ + +theorem reindexRepeated_norm (e : ℕ ≃ ℕ) (x : repeatedHilbert H) : + ‖reindexRepeated H e x‖ = ‖x‖ := by + have he : ‖reindexRepeated H e x‖ ^ 2 = ‖x‖ ^ 2 := by + rw [l2_norm_sq, l2_norm_sq] + exact e.symm.tsum_eq (fun j => ‖x j‖ ^ 2) + nlinarith [norm_nonneg x, norm_nonneg (reindexRepeated H e x)] + +def repeatedReindexEquiv (e : ℕ ≃ ℕ) : repeatedHilbert H ≃ₗᵢ[ℂ] repeatedHilbert H where + toFun := reindexRepeated H e + invFun := reindexRepeated H e.symm + left_inv x := by apply lp.ext; funext j; simp [reindexRepeated] + right_inv x := by apply lp.ext; funext j; simp [reindexRepeated] + map_add' _ _ := rfl + map_smul' _ _ := rfl + norm_map' := reindexRepeated_norm H e + +theorem blockOperator_reindex (e : ℕ ≃ ℕ) (T : ℕ → End H) + (C : ℝ) (hC : 0 ≤ C) (hT : ∀ j, ‖T j‖ ≤ C) : + operatorConjugation (repeatedReindexEquiv H e).toLinearIsometry + (blockOperator T C hC hT) = + blockOperator (fun j => T (e.symm j)) C hC (fun j => hT (e.symm j)) := by + have hadj : (repeatedReindexEquiv H e).toLinearIsometry.toContinuousLinearMap.adjoint = + (repeatedReindexEquiv H e).symm.toLinearIsometry.toContinuousLinearMap := + (repeatedReindexEquiv H e).adjoint_eq_symm + change (repeatedReindexEquiv H e).toLinearIsometry.toContinuousLinearMap.comp + ((blockOperator T C hC hT).comp (repeatedReindexEquiv H e).toLinearIsometry.toContinuousLinearMap.adjoint) = _ + rw [hadj] + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change T (e.symm j) (x (e (e.symm j))) = T (e.symm j) (x j) + rw [e.apply_symm_apply] + +/-- Rotate the first `N+1` coordinates, leaving the infinite tail fixed. -/ +def rotatePrefix (N : ℕ) : ℕ ≃ ℕ where + toFun j := if j = 0 then N else if j ≤ N then j - 1 else j + invFun j := if j < N then j + 1 else if j = N then 0 else j + left_inv j := by + dsimp only + by_cases h0 : j = 0 + · subst j + simp + by_cases hj : j ≤ N + · have hlt : j - 1 < N := by omega + simp only [ite_eq_right h0, ite_eq_left hj, ite_eq_left hlt] + omega + · have hnj : ¬j < N := by omega + have hne : j ≠ N := by omega + simp [h0, hj, hnj, hne] + right_inv j := by + dsimp only + by_cases hj : j < N + · have hle : j + 1 ≤ N := by omega + simp [hj, hle] + · by_cases he : j = N + · subst j + simp + · have h0 : j ≠ 0 := by omega + have hle : ¬j ≤ N := by omega + simp [hj, he, h0, hle] + +@[simp] theorem rotatePrefix_zero (N : ℕ) : rotatePrefix N 0 = N := by simp [rotatePrefix] + +theorem rotatePrefix_inverse_lt (N j : ℕ) (hj : j < N) : + (rotatePrefix N).symm j = j + 1 := by simp [rotatePrefix, hj] + +@[simp] theorem rotatePrefix_inverse_last (N : ℕ) : (rotatePrefix N).symm N = 0 := by + simp [rotatePrefix] + +theorem rotatePrefix_inverse_gt (N j : ℕ) (hj : N < j) : + (rotatePrefix N).symm j = j := by + simp [rotatePrefix, not_lt.mpr hj.le, ne_of_gt hj] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/HomotopyFilling.lean b/lean/OAI/Topology/CoarseAssembly/HomotopyFilling.lean new file mode 100644 index 0000000000000000000000000000000000000000..7bba32b67d2b27f3b2f88acad8e11a54aa4c2cd0 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/HomotopyFilling.lean @@ -0,0 +1,77 @@ +import OAI.Topology.CoarseAssembly.CountableAdditivity +import Mathlib.Topology.Homotopy.Basic +import Mathlib.Analysis.Convex.Basic + +namespace OAI + +/-! # The precise homotopy and odd-coefficient inputs for filling + +Blackadar, *K-Theory for Operator Algebras*, 2nd ed. (1998), Proposition +17.9.1 and §19.8.3 give homotopy invariance in the first variable and +`KK₁(ℂ, ℂ) = 0`. Their required specializations are explicit below. +Vanishing for a compact contractible space, and then for its countable +family, is derived rather than assumed. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open unitInterval + +structure PublishedCompactHomotopyInput where + homotopy : ∀ {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y] + [CompactSpace X] [CompactSpace Y] (f g : C(X, Y)), + Nonempty (f.Homotopy g) → pushforward (compactMap f) = pushforward (compactMap g) + point_odd_zero : Subsingleton (LocallyFiniteK1 Unit) + +/-- Actual continuous contraction data; this contains no K-theory assertion. -/ +structure CompactContraction (X : Type) [TopologicalSpace X] where + center : X + homotopy : (ContinuousMap.id X).Homotopy (ContinuousMap.const X center) + +theorem compactMap_comp {X Y Z : Type} [TopologicalSpace X] [TopologicalSpace Y] + [TopologicalSpace Z] [CompactSpace X] [CompactSpace Y] + (f : C(X, Y)) (g : C(Y, Z)) : + compactMap (g.comp f) = (compactMap g).comp (compactMap f) := by + apply CocompactMap.ext + intro x + rfl + +theorem compactMap_id {X : Type} [TopologicalSpace X] [CompactSpace X] : + compactMap (ContinuousMap.id X) = CocompactMap.id X := by + apply CocompactMap.ext + intro x + rfl + +theorem contracted_odd_group_zero (input : PublishedCompactHomotopyInput) + {X : Type} [TopologicalSpace X] [CompactSpace X] (c : CompactContraction X) : + Subsingleton (LocallyFiniteK1 X) := by + let toPoint : C(X, Unit) := ContinuousMap.const X () + let fromPoint : C(Unit, X) := ContinuousMap.const Unit c.center + have hconst : ContinuousMap.const X c.center = fromPoint.comp toPoint := by + ext x + rfl + have hh := input.homotopy (ContinuousMap.id X) (ContinuousMap.const X c.center) + ⟨c.homotopy⟩ + rw [compactMap_id, pushforward_id, hconst, compactMap_comp, pushforward_comp] at hh + have hz : ∀ a : LocallyFiniteK1 X, a = 0 := by + intro a + have heq := DFunLike.congr_fun hh a + change a = _ at heq + have hp : pushforward (compactMap toPoint) a = 0 := input.point_odd_zero.elim _ _ + simpa only [AddMonoidHom.comp_apply, hp, map_zero] using heq + exact ⟨fun a b => (hz a).trans (hz b).symm⟩ + +theorem contracted_family_odd_group_zero (input : PublishedCompactHomotopyInput) + (X : ℕ → Type) [∀ j, TopologicalSpace (X j)] [∀ j, CompactSpace (X j)] + [∀ j, T2Space (X j)] (c : ∀ j, CompactContraction (X j)) + (hadd : CountableAdditivityInput X) : Subsingleton (LocallyFiniteK1 (Sigma X)) := by + let : ∀ j, Subsingleton (LocallyFiniteK1 (X j)) := fun j => contracted_odd_group_zero input (c j) + exact sigma_group_subsingleton X hadd + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/HomotopySubdivision.lean b/lean/OAI/Topology/CoarseAssembly/HomotopySubdivision.lean new file mode 100644 index 0000000000000000000000000000000000000000..3fa63876d32dc52072d084fc7fd8f96d6cdad379 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/HomotopySubdivision.lean @@ -0,0 +1,37 @@ +import OAI.Topology.CoarseAssembly.UniformSubdivision +import OAI.Topology.CoarseAssembly.RipsLocalization + +namespace OAI + +/-! # Simultaneous finite subdivision of the operator and partition coordinates -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] + +theorem exists_rips_homotopy_subdivision (r : ℝ) (h : OddHomotopy C(Point X r, ℂ)) + (ε : ℝ) (hε : 0 < ε) : + ∃ (N : ℕ) (hN : 0 < N), ∀ j, j < N → + ‖h.operator (intervalGrid N hN (j + 1)) - h.operator (intervalGrid N hN j)‖ ≤ ε ∧ + ∀ x, ‖h.representation (intervalGrid N hN (j + 1)) (sqrtCoordinate r x) - + h.representation (intervalGrid N hN j) (sqrtCoordinate r x)‖ ≤ ε := by + let f : Interval → End h.space × (X → End h.space) := + fun t => (h.operator t, fun x => h.representation t (sqrtCoordinate r x)) + have hf : Continuous f := h.continuous_operator.prodMk + (continuous_pi (fun x => h.continuous_representation (sqrtCoordinate r x))) + obtain ⟨N, hN, hstep⟩ := exists_interval_subdivision f hf ε hε + refine ⟨N, hN, fun j hj => ?_⟩ + have he : ‖f (intervalGrid N hN (j + 1)) - f (intervalGrid N hN j)‖ ≤ ε := by + simpa only [dist_eq_norm] using (hstep j hj).le + refine ⟨(norm_fst_le _).trans he, fun x => ?_⟩ + exact (norm_le_pi_norm _ x).trans ((norm_snd_le _).trans he) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/InclusionFunctoriality.lean b/lean/OAI/Topology/CoarseAssembly/InclusionFunctoriality.lean new file mode 100644 index 0000000000000000000000000000000000000000..5a8317d56bd5fa4f23379beaae7398e7e17aca62 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/InclusionFunctoriality.lean @@ -0,0 +1,79 @@ +import OAI.Topology.CoarseAssembly.RoeInclusion +import OAI.Topology.CoarseAssembly.RipsMapCalculus + +namespace OAI + +/-! # Composition of the actual geometric and spatial inclusion maps -/ + +noncomputable section + +namespace CoarseAssembly + +variable {X Y Z H : Type} [DecidableEq X] [DecidableEq Y] [DecidableEq Z] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [CompleteSpace H] in +theorem inclusionIsometry_comp (e : X ↪ Y) (f : Y ↪ Z) : + (inclusionIsometry (H := H) f).comp (inclusionIsometry (H := H) e) = + inclusionIsometry (H := H) (e.trans f) := by + have hc : ((inclusionIsometry (H := H) f).comp (inclusionIsometry (H := H) e)).toContinuousLinearMap = + (inclusionIsometry (H := H) (e.trans f)).toContinuousLinearMap := by + apply lp.ext_continuousLinearMap (by norm_num : (2 : ENNReal) ≠ ⊤) + intro x + apply ContinuousLinearMap.ext + intro h + change inclusionIsometry f (inclusionIsometry e (lp.single 2 x h)) = + inclusionIsometry (e.trans f) (lp.single 2 x h) + rw [inclusionIsometry_single, inclusionIsometry_single, inclusionIsometry_single] + rfl + apply DFunLike.ext + intro v + exact DFunLike.congr_fun hc v + +namespace DiscreteRoe + +variable [PseudoMetricSpace X] [PseudoMetricSpace Y] [PseudoMetricSpace Z] + +local instance roeAddX : AddCommMonoid (algebra (X := X) (H := H)) := inferInstance +local instance roeAddY : AddCommMonoid (algebra (X := Y) (H := H)) := inferInstance +local instance roeAddZ : AddCommMonoid (algebra (X := Z) (H := H)) := inferInstance + +theorem inclusionHom_comp (e : X ↪ Y) (f : Y ↪ Z) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) + (hf : ∀ x y, dist (f x) (f y) ≤ dist x y) : + NonUnitalStarAlgHom.comp (R := ℂ) + (A := algebra (X := X) (H := H)) (B := algebra (X := Y) (H := H)) + (C := algebra (X := Z) (H := H)) + (inclusionHom (X := Y) (Y := Z) (H := H) f hf) + (inclusionHom (X := X) (Y := Y) (H := H) e he) = + inclusionHom (X := X) (Y := Z) (H := H) (e.trans f) (fun x y => (hf (e x) (e y)).trans (he x y)) := by + apply DFunLike.ext + intro T + apply Subtype.ext + change operatorConjugation (inclusionIsometry f) (operatorConjugation (inclusionIsometry e) T.val) = + operatorConjugation (inclusionIsometry (e.trans f)) T.val + rw [operatorConjugation_comp, inclusionIsometry_comp] + +end DiscreteRoe + +namespace Rips + +variable [PseudoMetricSpace X] [PseudoMetricSpace Y] [PseudoMetricSpace Z] + +omit [DecidableEq X] [DecidableEq Y] [DecidableEq Z] in +theorem embeddingMap_comp (e : X ↪ Y) (f : Y ↪ Z) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) + (hf : ∀ x y, dist (f x) (f y) ≤ dist x y) (r : ℝ) : + (embeddingMap f hf r).comp (embeddingMap e he r) = + embeddingMap (e.trans f) (fun x y => (hf (e x) (e y)).trans (he x y)) r := by + apply CocompactMap.ext + intro x + exact mapPoint_comp e f he hf x + +end Rips + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/InclusionModule.lean b/lean/OAI/Topology/CoarseAssembly/InclusionModule.lean new file mode 100644 index 0000000000000000000000000000000000000000..56cf803a1d8aaae839082d66aa9170bff2946322 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/InclusionModule.lean @@ -0,0 +1,68 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.HilbertSum +import OAI.Topology.CoarseAssembly.FiberEmbedding +import Mathlib.Topology.Algebra.InfiniteSum.Basic + +namespace OAI + +/-! # Spatial module maps for inclusions + +Extension by zero along an injection is an actual Hilbert-space isometry, +with the exact basis formula used for the boundary inclusions. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {X Y H : Type*} +variable [NormedAddCommGroup H] [NormedSpace ℂ H] + +omit [NormedSpace ℂ H] in +theorem extendedFunction_apply (e : X ↪ Y) (x : lp (fun _ : X => H) 2) (a : X) : + extendedFunction e x (e a) = x a := e.injective.extend_apply _ _ _ + +omit [NormedSpace ℂ H] in +theorem extendedFunction_zero (e : X ↪ Y) (x : lp (fun _ : X => H) 2) + (y : Y) (hy : y ∉ Set.range e) : extendedFunction e x y = 0 := + Function.extend_apply' _ _ _ hy + +omit [NormedSpace ℂ H] in +theorem extendedFunction_hasSum (e : X ↪ Y) (x : lp (fun _ : X => H) 2) : + HasSum (fun y => ‖extendedFunction e x y‖ ^ 2) (‖x‖ ^ 2) := by + have hf : HasSum (fun a : X => ‖x a‖ ^ 2) (‖x‖ ^ 2) := by + rw [l2_norm_sq] + exact (l2_summable_sq x).hasSum + apply (e.injective.hasSum_iff (fun y hy => by + rw [extendedFunction_zero e x y hy, norm_zero, zero_pow (by decide : 2 ≠ 0)])).mp + convert hf using 1 + funext a + exact congrArg (fun h : H => ‖h‖ ^ 2) (extendedFunction_apply e x a) + +omit [NormedSpace ℂ H] in +@[simp] theorem inclusionVector_apply (e : X ↪ Y) (x : lp (fun _ : X => H) 2) (a : X) : + inclusionVector e x (e a) = x a := extendedFunction_apply e x a + +omit [NormedSpace ℂ H] in +theorem inclusionVector_zero (e : X ↪ Y) (x : lp (fun _ : X => H) 2) (y : Y) + (hy : y ∉ Set.range e) : inclusionVector e x y = 0 := extendedFunction_zero e x y hy + +theorem inclusionIsometry_single [DecidableEq X] [DecidableEq Y] + (e : X ↪ Y) (a : X) (h : H) : + inclusionIsometry e (lp.single 2 a h) = lp.single 2 (e a) h := by + apply lp.ext + funext y + by_cases hy : y ∈ Set.range e + · obtain ⟨b, rfl⟩ := hy + change inclusionVector e (lp.single 2 a h) (e b) = _ + rw [inclusionVector_apply] + simp only [lp.single_apply, Pi.single_apply, e.injective.eq_iff] + · have hne : y ≠ e a := fun h => hy ⟨a, h.symm⟩ + change inclusionVector e (lp.single 2 a h) y = _ + rw [inclusionVector_zero e _ y hy, lp.single_apply_ne (E := fun _ : Y => H) 2 (e a) h hne] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/IndexFamilyTransport.lean b/lean/OAI/Topology/CoarseAssembly/IndexFamilyTransport.lean new file mode 100644 index 0000000000000000000000000000000000000000..03af014c81a3fe4d16f7172db4cc938286b64419 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/IndexFamilyTransport.lean @@ -0,0 +1,30 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.Assembly + +namespace OAI + +/-! # Transport of a proved compatible analytic index family -/ + +noncomputable section + +namespace CoarseAssembly.Analytic.CompatibleIndexFamily + +universe u v + +variable {C D : Coarsening.{u}} {A B : Type v} + [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B] + +/-- Apply an actual homomorphism to the target of every scale index. -/ +def mapTarget (I : CompatibleIndexFamily C A) (φ : A →⋆ₙₐ[ℂ] B) : + CompatibleIndexFamily C B where + atScale r := (OperatorKTheory.map φ).comp (I.atScale r) + compatible r s hrs a := by + change OperatorKTheory.map φ (I.atScale s (C.map r s hrs a)) = _ + rw [I.compatible] + rfl + +end CoarseAssembly.Analytic.CompatibleIndexFamily + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/IndexPairing.lean b/lean/OAI/Topology/CoarseAssembly/IndexPairing.lean new file mode 100644 index 0000000000000000000000000000000000000000..9f0a9ed14520b0c3a29e9cdc1a63cb032526ec6f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/IndexPairing.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.DirectSumIndex + +namespace OAI + +/-! # The scalar-unitary index pairing on odd analytic K-homology + +All four defining Fredholm-cycle relations are respected by the explicit +Toeplitz index. Hence it descends to the existing quotient group. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +def indexFree (u : A) : FreeAbelianGroup (OddCycle A) →+ ℤ := + FreeAbelianGroup.lift (fun c => rawCycleIndex c u) + +theorem indexFree_relation (u : A) (hul : star u * u = 1) (hur : u * star u = 1) + {z : FreeAbelianGroup (OddCycle A)} (hz : CycleRelation A z) : indexFree u z = 0 := by + cases hz with + | degenerate c h => + simpa [indexFree] using rawCycleIndex_degenerate c u h hul hur + | unitary c d h => + simpa [indexFree] using sub_eq_zero.mpr (rawCycleIndex_unitary c d h u hul hur).symm + | directSum c d e h => + simpa [indexFree] using sub_eq_zero.mpr (rawCycleIndex_directSum h u hul hur) + | homotopy h => + simpa [indexFree] using sub_eq_zero.mpr (rawCycleIndex_homotopy h u hul hur) + +/-- Pairing an odd analytic class with an actual scalar unitary. -/ +def indexPairing (u : A) (hul : star u * u = 1) (hur : u * star u = 1) : OddK A →+ ℤ := + QuotientAddGroup.lift (relations A) (indexFree u) + ((AddSubgroup.closure_le _).2 (fun _ hz => indexFree_relation u hul hur hz)) + +@[simp] theorem indexPairing_cycleClass (u : A) (hul : star u * u = 1) + (hur : u * star u = 1) (c : OddCycle A) : + indexPairing u hul hur (cycleClass A c) = rawCycleIndex c u := + FreeAbelianGroup.lift_apply_of _ _ + +variable {B : Type} [CStarAlgebra B] + +theorem indexPairing_precomp (φ : B →⋆ₙₐ[ℂ] A) (hφ : φ 1 = 1) (u : B) + (hul : star u * u = 1) (hur : u * star u = 1) : + (indexPairing u hul hur).comp (precomp φ) = indexPairing (φ u) + (by rw [← map_star, ← map_mul, hul, hφ]) + (by rw [← map_star, ← map_mul, hur, hφ]) := by + apply hom_ext + intro c + simp only [AddMonoidHom.comp_apply, precomp_cycleClass, indexPairing_cycleClass] + exact rawCycleIndex_precomp c φ hφ u + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/InvolutionUnitaryPath.lean b/lean/OAI/Topology/CoarseAssembly/InvolutionUnitaryPath.lean new file mode 100644 index 0000000000000000000000000000000000000000..5821b3b7c6a28a4e62db44cc750f74d5915448e4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/InvolutionUnitaryPath.lean @@ -0,0 +1,56 @@ +import OAI.Topology.CoarseAssembly.ProjectionUnitaryPath + +namespace OAI + +/-! # An explicit path from the identity to a self-adjoint involution -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [Ring A] [Algebra ℂ A] [StarRing A] [StarModule ℂ A] + +def involutionNegativeProjection (U : A) : A := (1 / 2 : ℂ) • (1 - U) + +theorem involutionNegativeProjection_isStarProjection (U : A) + (hU : IsSelfAdjoint U) (hUU : U * U = 1) : + IsStarProjection (involutionNegativeProjection U) := by + have hs : (1 - U) * (1 - U) = (2 : ℂ) • (1 - U) := by + calc + _ = 1 - U - U + U * U := by noncomm_ring + _ = _ := by rw [hUU]; module + constructor + · change ((1 / 2 : ℂ) • (1 - U)) * ((1 / 2 : ℂ) • (1 - U)) = + (1 / 2 : ℂ) • (1 - U) + rw [smul_mul_assoc, mul_smul_comm, hs, smul_smul, smul_smul] + norm_num + · change star ((1 / 2 : ℂ) • (1 - U)) = (1 / 2 : ℂ) • (1 - U) + simp only [star_smul, star_sub, star_one, hU.star_eq] + norm_num + +def involutionUnitaryPath (U : A) (hU : IsSelfAdjoint U) (hUU : U * U = 1) : + Interval → unitary A := + projectionSignPath (involutionNegativeProjection U) + (involutionNegativeProjection_isStarProjection U hU hUU) + +theorem involutionUnitaryPath_continuous [TopologicalSpace A] [ContinuousAdd A] + [ContinuousSMul ℂ A] (U : A) (hU : IsSelfAdjoint U) (hUU : U * U = 1) : + Continuous (involutionUnitaryPath U hU hUU) := projectionSignPath_continuous _ _ + +@[simp] theorem involutionUnitaryPath_start (U : A) (hU : IsSelfAdjoint U) (hUU : U * U = 1) : + involutionUnitaryPath U hU hUU start = 1 := projectionSignPath_start _ _ + +@[simp] theorem involutionUnitaryPath_finish (U : A) (hU : IsSelfAdjoint U) (hUU : U * U = 1) : + (involutionUnitaryPath U hU hUU finish : A) = U := by + change (projectionSignPath (involutionNegativeProjection U) + (involutionNegativeProjection_isStarProjection U hU hUU) finish : A) = U + rw [projectionSignPath_finish] + unfold involutionNegativeProjection + rw [smul_smul] + norm_num + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/InvolutiveNormalization.lean b/lean/OAI/Topology/CoarseAssembly/InvolutiveNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..4cb930c4a17e9fc2f9b53671e1cc1c898b38c365 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/InvolutiveNormalization.lean @@ -0,0 +1,113 @@ +import OAI.Topology.CoarseAssembly.RealNormalization +import OAI.Topology.CoarseAssembly.CompactFunctionalCalculus +import OAI.Topology.CoarseAssembly.UnitalCycleInvertible + +namespace OAI + +/-! # Involutive representatives by compact functional calculus -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem squareDefect_cfc (F : End H) (hF : IsSelfAdjoint F) : + cfc (fun x : ℝ => x ^ 2 - 1) F = F * F - 1 := by + rw [cfc_sub (fun x : ℝ => x ^ 2) (fun _ => 1) F, + cfc_pow_id F 2 hF, cfc_const_one ℝ F hF, pow_two] + +theorem inverseSqrtCorrection_continuousOn (F : End H) (hF : IsSelfAdjoint F) + (hu : IsUnit F) : + ContinuousOn inverseSqrtCorrection (quasispectrum ℝ (F * F - 1)) := by + rw [quasispectrum_eq_spectrum_union_zero, ← squareDefect_cfc F hF, + cfc_map_spectrum (fun x : ℝ => x ^ 2 - 1) F hF] + intro t ht + rcases ht with ⟨x, hx, rfl⟩ | ht + · apply (inverseSqrtCorrection_continuousAt _).continuousWithinAt + have hx0 : x ≠ 0 := fun h => spectrum.zero_notMem ℝ hu (h ▸ hx) + simpa using sq_pos_of_ne_zero hx0 + · have ht0 : t = 0 := ht + subst t + exact (inverseSqrtCorrection_continuousAt (by norm_num)).continuousWithinAt + +theorem inverseSqrtCorrection_continuousOn_image (F : End H) (hu : IsUnit F) : + ContinuousOn inverseSqrtCorrection ((fun x : ℝ => x ^ 2 - 1) '' spectrum ℝ F) := by + rintro t ⟨x, hx, rfl⟩ + apply (inverseSqrtCorrection_continuousAt _).continuousWithinAt + have hx0 : x ≠ 0 := fun h => spectrum.zero_notMem ℝ hu (h ▸ hx) + simpa using sq_pos_of_ne_zero hx0 + +theorem normalizedReal_continuousOn (F : End H) (hu : IsUnit F) : + ContinuousOn normalizedReal (spectrum ℝ F) := by + have hc := (inverseSqrtCorrection_continuousOn_image F hu).comp + ((continuous_id.pow 2).sub continuous_const).continuousOn (Set.mapsTo_image _ _) + exact continuousOn_id.add (continuousOn_id.mul hc) + +def involutiveNormalization (F : End H) : End H := cfc normalizedReal F + +theorem involutiveNormalization_eq (F : End H) (hF : IsSelfAdjoint F) (hu : IsUnit F) : + involutiveNormalization F = F + F * cfc inverseSqrtCorrection (F * F - 1) := by + have hg := inverseSqrtCorrection_continuousOn_image F hu + have hc : ContinuousOn (fun x : ℝ => inverseSqrtCorrection (x ^ 2 - 1)) + (spectrum ℝ F) := by + exact hg.comp (by fun_prop) (Set.mapsTo_image _ _) + unfold involutiveNormalization normalizedReal + rw [cfc_add F (fun x : ℝ => x) (fun x => x * inverseSqrtCorrection (x ^ 2 - 1)) + continuousOn_id (continuousOn_id.mul hc), + cfc_mul (fun x : ℝ => x) (fun x => inverseSqrtCorrection (x ^ 2 - 1)) F + continuousOn_id hc, + cfc_id' ℝ F hF, + cfc_comp' inverseSqrtCorrection (fun x : ℝ => x ^ 2 - 1) F hg, + squareDefect_cfc F hF] + +theorem involutiveNormalization_sq (F : End H) (hF : IsSelfAdjoint F) (hu : IsUnit F) : + involutiveNormalization F * involutiveNormalization F = 1 := by + rw [← pow_two, involutiveNormalization, ← cfc_pow normalizedReal 2 F + (normalizedReal_continuousOn F hu) hF] + calc + cfc (fun x => normalizedReal x ^ 2) F = cfc (fun _ : ℝ => 1) F := by + apply cfc_congr + intro x hx + exact normalizedReal_sq (fun h => spectrum.zero_notMem ℝ hu (h ▸ hx)) + _ = 1 := cfc_const_one ℝ F hF + +theorem involutiveNormalization_selfAdjoint (F : End H) : + IsSelfAdjoint (involutiveNormalization F) := IsSelfAdjoint.cfc + +theorem involutiveCorrection_compact (F : End H) (hF : IsSelfAdjoint F) (hu : IsUnit F) + (hc : IsCompactOperator (F * F - 1 : End H)) : + IsCompactOperator (F * cfc inverseSqrtCorrection (F * F - 1) : End H) ∧ + IsCompactOperator (star (F * cfc inverseSqrtCorrection (F * F - 1)) : End H) := by + have hs : star (F * F - 1) = F * F - 1 := by rw [star_sub, star_mul, hF.star_eq, star_one] + have hcs : IsCompactOperator (star (F * F - 1) : End H) := by rw [hs]; exact hc + have hq := compact_cfc inverseSqrtCorrection (F * F - 1) hc hcs + (inverseSqrtCorrection_continuousOn F hF hu) inverseSqrtCorrection_zero + refine ⟨compact_mul_left hq F, ?_⟩ + rw [star_mul, (IsSelfAdjoint.cfc (f := inverseSqrtCorrection) (a := F * F - 1)).star_eq] + exact compact_mul_right hq (star F) + +variable {A : Type} [CStarAlgebra A] + +theorem exists_involutive_representative (c : OddCycle A) (hunital : c.representation 1 = 1) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ d.representation 1 = 1 ∧ + IsSelfAdjoint d.operator ∧ d.operator * d.operator = 1 := by + obtain ⟨d, hdc, hdu, hds, hdi⟩ := exists_invertible_selfAdjoint_representative c hunital + have hc : IsCompactOperator (d.operator * d.operator - 1 : End d.space) := by + simpa only [hdu, mul_one] using d.square_compact 1 + obtain ⟨hK, hKs⟩ := involutiveCorrection_compact d.operator hds hdi hc + refine ⟨d.compactPerturb _ hK hKs, (compactPerturb_class d _ hK hKs).trans hdc, hdu, ?_, ?_⟩ + · change IsSelfAdjoint (d.operator + d.operator * cfc inverseSqrtCorrection + (d.operator * d.operator - 1)) + rw [← involutiveNormalization_eq d.operator hds hdi] + exact involutiveNormalization_selfAdjoint d.operator + · change (d.operator + d.operator * cfc inverseSqrtCorrection (d.operator * d.operator - 1)) * + (d.operator + d.operator * cfc inverseSqrtCorrection (d.operator * d.operator - 1)) = 1 + rw [← involutiveNormalization_eq d.operator hds hdi] + exact involutiveNormalization_sq d.operator hds hdi + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/IsometricDecomposition.lean b/lean/OAI/Topology/CoarseAssembly/IsometricDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..5966ee26c90bdc16357c99e0dade90de4a9daa3c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/IsometricDecomposition.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.CoefficientDecomposition + +namespace OAI + +/-! # Extending an orthogonal decomposition by the identity -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E F G H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] + [NormedAddCommGroup G] [InnerProductSpace ℂ G] [CompleteSpace G] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem isometricExtension_decomposition + (U : G →ₗᵢ[ℂ] H) (V : E →ₗᵢ[ℂ] G) (W : F →ₗᵢ[ℂ] G) + (hex : V.toContinuousLinearMap.comp V.toContinuousLinearMap.adjoint + + W.toContinuousLinearMap.comp W.toContinuousLinearMap.adjoint = 1) + (A : E →L[ℂ] E) (B : F →L[ℂ] F) : + isometricExtension U (operatorConjugation V A + operatorConjugation W B) = + 1 + operatorConjugation (U.comp V) (A - 1) + operatorConjugation (U.comp W) (B - 1) := by + have hone : operatorConjugation V (1 : E →L[ℂ] E) + + operatorConjugation W (1 : F →L[ℂ] F) = 1 := by + ext x + exact DFunLike.congr_fun hex x + have hinside : (operatorConjugation V A + operatorConjugation W B) - 1 = + operatorConjugation V (A - 1) + operatorConjugation W (B - 1) := by + change (operatorConjugationHom V A + operatorConjugationHom W B) - 1 = + operatorConjugationHom V (A - 1) + operatorConjugationHom W (B - 1) + rw [map_sub, map_sub, ← hone] + abel + change 1 + operatorConjugationHom U ((operatorConjugation V A + operatorConjugation W B) - 1) = _ + rw [hinside, map_add] + change 1 + (operatorConjugation U (operatorConjugation V (A - 1)) + + operatorConjugation U (operatorConjugation W (B - 1))) = _ + rw [operatorConjugation_comp, operatorConjugation_comp, add_assoc] + +omit [CompleteSpace F] in +theorem isometry_comp_orthogonal + (U : G →ₗᵢ[ℂ] H) (V : E →ₗᵢ[ℂ] G) (W : F →ₗᵢ[ℂ] G) + (hVW : V.toContinuousLinearMap.adjoint.comp W.toContinuousLinearMap = 0) : + (U.comp V).toContinuousLinearMap.adjoint.comp (U.comp W).toContinuousLinearMap = 0 := by + have hV : (U.comp V).toContinuousLinearMap = U.toContinuousLinearMap.comp V.toContinuousLinearMap := rfl + have hW : (U.comp W).toContinuousLinearMap = U.toContinuousLinearMap.comp W.toContinuousLinearMap := rfl + rw [hV, hW, ContinuousLinearMap.adjoint_comp] + ext x + change V.toContinuousLinearMap.adjoint + (U.toContinuousLinearMap.adjoint (U (W x))) = 0 + rw [adjoint_apply_isometry] + exact DFunLike.congr_fun hVW x + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/IsometricExtension.lean b/lean/OAI/Topology/CoarseAssembly/IsometricExtension.lean new file mode 100644 index 0000000000000000000000000000000000000000..ffb594eaf0724d3be3f1a89bb3ac3151376b9d57 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/IsometricExtension.lean @@ -0,0 +1,76 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation + +namespace OAI + +/-! # Extending a Fredholm operator by the identity off an isometric image -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem isometricExtension_selfAdjoint (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) + (hF : IsSelfAdjoint F) : IsSelfAdjoint (isometricExtension V F) := + (IsSelfAdjoint.one (H →L[ℂ] H)).add + ((hF.sub (IsSelfAdjoint.one (E →L[ℂ] E))).map + (operatorConjugationHom V)) + +theorem isometricExtension_square_defect (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) : + isometricExtension V F * isometricExtension V F - 1 = + operatorConjugation V (F * F - 1) := by + let φ := operatorConjugationHom V + have he : (F - 1) * (F - 1) + (F - 1) + (F - 1) = F * F - 1 := by noncomm_ring + calc + isometricExtension V F * isometricExtension V F - 1 = + φ (F - 1) * φ (F - 1) + φ (F - 1) + φ (F - 1) := by + change (1 + φ (F - 1)) * (1 + φ (F - 1)) - 1 = _ + noncomm_ring + _ = φ ((F - 1) * (F - 1) + (F - 1) + (F - 1)) := by + rw [map_add, map_add, map_mul] + _ = operatorConjugation V (F * F - 1) := by rw [he]; rfl + +theorem isometricExtension_square_compact (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) + (hF : IsCompactOperator (F * F - (1 : E →L[ℂ] E))) : + IsCompactOperator (isometricExtension V F * isometricExtension V F - + (1 : H →L[ℂ] H)) := by + rw [isometricExtension_square_defect] + exact (hF.comp_clm V.toContinuousLinearMap.adjoint).clm_comp V.toContinuousLinearMap + +theorem operatorConjugation_norm_le (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) : + ‖operatorConjugation V F‖ ≤ ‖F‖ := by + have hV := V.norm_toContinuousLinearMap_le + have hVs : ‖V.toContinuousLinearMap.adjoint‖ ≤ 1 := by + simpa only [ContinuousLinearMap.adjoint.norm_map] using hV + have h1 : ‖V.toContinuousLinearMap.comp F‖ ≤ ‖V.toContinuousLinearMap‖ * ‖F‖ := + ContinuousLinearMap.opNorm_comp_le _ _ + have h2 : ‖(V.toContinuousLinearMap.comp F).comp V.toContinuousLinearMap.adjoint‖ ≤ + ‖V.toContinuousLinearMap.comp F‖ * ‖V.toContinuousLinearMap.adjoint‖ := + ContinuousLinearMap.opNorm_comp_le _ _ + calc + ‖operatorConjugation V F‖ ≤ + ‖V.toContinuousLinearMap‖ * ‖F‖ * ‖V.toContinuousLinearMap.adjoint‖ := + h2.trans (mul_le_mul_of_nonneg_right h1 (norm_nonneg _)) + _ ≤ 1 * ‖F‖ * 1 := by gcongr + _ = ‖F‖ := by ring + +theorem isometricExtension_norm_le (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) : + ‖isometricExtension V F‖ ≤ ‖F‖ + 2 := by + have h1 : ‖(1 : E →L[ℂ] E)‖ ≤ 1 := ContinuousLinearMap.norm_id_le + have hd : ‖F - 1‖ ≤ ‖F‖ + 1 := (norm_sub_le _ _).trans (add_le_add le_rfl h1) + calc + ‖isometricExtension V F‖ ≤ ‖(1 : H →L[ℂ] H)‖ + ‖operatorConjugation V (F - 1)‖ := + norm_add_le _ _ + _ ≤ 1 + ‖F - 1‖ := add_le_add ContinuousLinearMap.norm_id_le + (operatorConjugation_norm_le V _) + _ ≤ 1 + (‖F‖ + 1) := add_le_add le_rfl hd + _ = ‖F‖ + 2 := by ring + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/IsometryDilation.lean b/lean/OAI/Topology/CoarseAssembly/IsometryDilation.lean new file mode 100644 index 0000000000000000000000000000000000000000..c3c1139987b6ac64147707c24094e078605ba414 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/IsometryDilation.lean @@ -0,0 +1,99 @@ +import OAI.Topology.CoarseAssembly.InvolutionUnitaryPath +import OAI.Topology.CoarseAssembly.K1TwoByTwo +import Mathlib.LinearAlgebra.Matrix.ConjTranspose + +namespace OAI + +/-! # The explicit two-by-two dilation of a spatial isometry -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +def isometryDilation (V : A) : Matrix (Fin 2) (Fin 2) A := + !![1 - V * star V, V; star V, 0] + +theorem isometryDilation_selfAdjoint (V : A) : IsSelfAdjoint (isometryDilation V) := by + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> simp [isometryDilation, Matrix.star_apply] + +theorem isometry_complement_relations (V : A) (hV : star V * V = 1) : + (1 - V * star V) * (1 - V * star V) = 1 - V * star V ∧ + (1 - V * star V) * V = 0 ∧ star V * (1 - V * star V) = 0 := by + have hP : V * star V * (V * star V) = V * star V := by + calc + _ = V * (star V * V) * star V := by noncomm_ring + _ = _ := by rw [hV, mul_one] + have hPV : V * star V * V = V := by rw [mul_assoc, hV, mul_one] + have hVP : star V * (V * star V) = star V := by rw [← mul_assoc, hV, one_mul] + refine ⟨?_, ?_, ?_⟩ + · noncomm_ring [hP] + · rw [sub_mul, one_mul, hPV, sub_self] + · rw [mul_sub, mul_one, hVP, sub_self] + +theorem isometryDilation_sq (V : A) (hV : star V * V = 1) : + isometryDilation V * isometryDilation V = 1 := by + obtain ⟨hQQ, hQV, hVQ⟩ := isometry_complement_relations V hV + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j + all_goals simp only [Matrix.mul_apply, Fin.sum_univ_two] + · change (1 - V * star V) * (1 - V * star V) + V * star V = 1 + rw [hQQ] + abel + · change (1 - V * star V) * V + V * 0 = 0 + rw [hQV, mul_zero, add_zero] + · change star V * (1 - V * star V) + 0 * star V = 0 + rw [hVQ, zero_mul, add_zero] + · change star V * V + 0 * 0 = 1 + rw [hV, zero_mul, add_zero] + +def isometryDilationPath (V : A) (hV : star V * V = 1) : + Interval → unitary (Matrix (Fin 2) (Fin 2) A) := + involutionUnitaryPath (isometryDilation V) (isometryDilation_selfAdjoint V) + (isometryDilation_sq V hV) + +theorem isometryDilationPath_continuous (V : A) (hV : star V * V = 1) : + Continuous (isometryDilationPath V hV) := involutionUnitaryPath_continuous _ _ _ + +@[simp] theorem isometryDilationPath_start (V : A) (hV : star V * V = 1) : + isometryDilationPath V hV start = 1 := involutionUnitaryPath_start _ _ _ + +@[simp] theorem isometryDilationPath_finish (V : A) (hV : star V * V = 1) : + (isometryDilationPath V hV finish).val = isometryDilation V := + involutionUnitaryPath_finish _ _ _ + +/-- Conjugating the stabilized operator gives its identity extension. -/ +theorem isometryDilation_conjugation (V a : A) (hV : star V * V = 1) : + isometryDilation V * !![1, 0; 0, a] * isometryDilation V = + !![1 + V * (a - 1) * star V, 0; 0, 1] := by + obtain ⟨hQQ, hQV, hVQ⟩ := isometry_complement_relations V hV + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j + all_goals simp only [Matrix.mul_apply, Fin.sum_univ_two] + · change ((1 - V * star V) * 1 + V * 0) * (1 - V * star V) + + ((1 - V * star V) * 0 + V * a) * star V = 1 + V * (a - 1) * star V + simp only [mul_one, mul_zero, add_zero, zero_add] + rw [hQQ] + noncomm_ring + · change ((1 - V * star V) * 1 + V * 0) * V + + ((1 - V * star V) * 0 + V * a) * 0 = 0 + simp only [mul_one, mul_zero, add_zero] + exact hQV + · change (star V * 1 + 0 * 0) * (1 - V * star V) + + (star V * 0 + 0 * a) * star V = 0 + simp only [mul_one, mul_zero, zero_mul, add_zero] + exact hVQ + · change (star V * 1 + 0 * 0) * V + (star V * 0 + 0 * a) * 0 = 1 + simp only [mul_one, mul_zero, zero_mul, add_zero] + exact hV + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/IsometryUnitary.lean b/lean/OAI/Topology/CoarseAssembly/IsometryUnitary.lean new file mode 100644 index 0000000000000000000000000000000000000000..8090f4bd83bb886b571b179ddc5975199024af72 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/IsometryUnitary.lean @@ -0,0 +1,88 @@ +import OAI.Topology.CoarseAssembly.IsometryDilation +import OAI.Topology.CoarseAssembly.RelativeTwoDiagonal + +namespace OAI + +/-! # Identity extension of a unitary along an isometry -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +def isometryCornerHom (V : A) (hV : star V * V = 1) : A →⋆ₙₐ[ℂ] A where + toFun a := V * a * star V + map_zero' := by simp + map_add' a b := by noncomm_ring + map_mul' a b := by + change V * (a * b) * star V = (V * a * star V) * (V * b * star V) + calc + _ = V * a * (star V * V) * b * star V := by rw [hV]; noncomm_ring + _ = _ := by noncomm_ring + map_smul' z a := by simp only [mul_smul_comm, smul_mul_assoc, MonoidHom.id_apply] + map_star' a := by simp only [star_mul, star_star]; noncomm_ring + +def isometryExtensionUnitary (V : A) (hV : star V * V = 1) (u : unitary A) : + unitary A := by + let Q := 1 - V * star V + have hQQ := (isometry_complement_relations V hV).1 + have hQV := (isometry_complement_relations V hV).2.1 + have hVQ := (isometry_complement_relations V hV).2.2 + have hprod (a b : A) : + (Q + V * a * star V) * (Q + V * b * star V) = Q + V * (a * b) * star V := by + have ha : Q * (V * b * star V) = 0 := by + rw [← mul_assoc, ← mul_assoc, hQV]; simp + have hb : (V * a * star V) * Q = 0 := by + rw [mul_assoc, hVQ]; simp + rw [add_mul, mul_add, mul_add, hQQ, ha, hb, add_zero, zero_add] + congr 1 + calc + _ = V * a * (star V * V) * b * star V := by noncomm_ring + _ = _ := by rw [hV]; noncomm_ring + have hQ : star Q = Q := by dsimp [Q]; simp + have huL : star (u : A) * (u : A) = 1 := Unitary.coe_star_mul_self u + have huR : (u : A) * star (u : A) = 1 := by + have h := Unitary.coe_mul_star_self u + change (u : A) * star (u : A) = 1 at h + exact h + refine ⟨Q + V * (u : A) * star V, ?_, ?_⟩ + · change star (Q + V * (u : A) * star V) * (Q + V * (u : A) * star V) = 1 + rw [star_add, hQ, star_mul, star_mul, star_star] + rw [← mul_assoc, hprod, huL] + dsimp [Q] + noncomm_ring + · change (Q + V * (u : A) * star V) * star (Q + V * (u : A) * star V) = 1 + rw [star_add, hQ, star_mul, star_mul, star_star] + rw [← mul_assoc, hprod, huR] + dsimp [Q] + noncomm_ring + +@[simp] theorem isometryExtensionUnitary_val (V : A) (hV) (u : unitary A) : + (isometryExtensionUnitary V hV u : A) = 1 + V * ((u : A) - 1) * star V := by + change (1 - V * star V) + V * (u : A) * star V = _ + noncomm_ring + +theorem isometryDilation_conjugates_unitary (V : A) (hV : star V * V = 1) + (u : unitary A) : + isometryDilation V * + (OperatorKTheory.diagonalTwoUnitary 1 u : Matrix (Fin 2) (Fin 2) A) * + star (isometryDilation V) = + (OperatorKTheory.diagonalTwoUnitary (isometryExtensionUnitary V hV u) 1 : + Matrix (Fin 2) (Fin 2) A) := by + rw [(isometryDilation_selfAdjoint V).star_eq] + have hleft : (OperatorKTheory.diagonalTwoUnitary 1 u : Matrix (Fin 2) (Fin 2) A) = + !![1, 0; 0, (u : A)] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [OperatorKTheory.diagonalTwoUnitary, Matrix.diagonal] + rw [hleft, isometryDilation_conjugation V (u : A) hV] + ext i j + fin_cases i <;> fin_cases j <;> + simp [OperatorKTheory.diagonalTwoUnitary, Matrix.diagonal] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/K1Nearby.lean b/lean/OAI/Topology/CoarseAssembly/K1Nearby.lean new file mode 100644 index 0000000000000000000000000000000000000000..faa4b9dfdc8f5c708eea5d83408b9d225ba3d868 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/K1Nearby.lean @@ -0,0 +1,57 @@ +import OAI.Topology.CoarseAssembly.K1TwoByTwo +import Mathlib.Analysis.Normed.Ring.Units + +namespace OAI + +/-! # A concrete short path between nearby invertibles -/ + +noncomputable section + +namespace CoarseAssembly.TopologicalK1 + +open Analytic + +variable {A : Type*} [CStarAlgebra A] + +def nearbyUnitPath (u v : Aˣ) (h : ‖(v : A) - u‖ < ‖(↑u⁻¹ : A)‖⁻¹) + (t : Interval) : Aˣ := + Units.ofNearby u ((u : A) + (t : ℝ) • ((v : A) - u)) (by + rw [add_sub_cancel_left, norm_smul, Real.norm_of_nonneg t.property.1] + exact (mul_le_of_le_one_left (norm_nonneg _) t.property.2).trans_lt h) + +theorem nearbyUnitPath_continuous (u v : Aˣ) + (h : ‖(v : A) - u‖ < ‖(↑u⁻¹ : A)‖⁻¹) : Continuous (nearbyUnitPath u v h) := by + apply (Units.isOpenEmbedding_val (R := A)).isEmbedding.continuous_iff.mpr + change Continuous (fun t : Interval => (u : A) + (t : ℝ) • ((v : A) - u)) + exact continuous_const.add (continuous_subtype_val.smul continuous_const) + +@[simp] theorem nearbyUnitPath_start (u v : Aˣ) + (h : ‖(v : A) - u‖ < ‖(↑u⁻¹ : A)‖⁻¹) : nearbyUnitPath u v h start = u := by + apply Units.ext + change (u : A) + (0 : ℝ) • ((v : A) - u) = u + simp + +@[simp] theorem nearbyUnitPath_finish (u v : Aˣ) + (h : ‖(v : A) - u‖ < ‖(↑u⁻¹ : A)‖⁻¹) : nearbyUnitPath u v h finish = v := by + apply Units.ext + change (u : A) + (1 : ℝ) • ((v : A) - u) = v + simp + +theorem continuous_scalarUnitMatrix : Continuous (scalarUnitMatrix (R := A)) := by + apply Continuous.units_map + exact continuous_pi (fun i => continuous_pi (fun j => by + change Continuous (fun x : A => if i = j then x else 0) + split_ifs <;> fun_prop)) + +theorem matrixClass_scalar_eq_of_nearby (u v : Aˣ) + (h : ‖(v : A) - u‖ < ‖(↑u⁻¹ : A)‖⁻¹) : + matrixClass A (scalarUnitMatrix u) = matrixClass A (scalarUnitMatrix v) := by + have hp := matrixClass_homotopy (fun t => scalarUnitMatrix (nearbyUnitPath u v h t)) + (continuous_scalarUnitMatrix.comp (nearbyUnitPath_continuous u v h)) + simpa only [nearbyUnitPath_start, nearbyUnitPath_finish] using hp + +end CoarseAssembly.TopologicalK1 + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/K1TwoByTwo.lean b/lean/OAI/Topology/CoarseAssembly/K1TwoByTwo.lean new file mode 100644 index 0000000000000000000000000000000000000000..c9ba8e9740f85c1d8341157fbb247608fe103f81 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/K1TwoByTwo.lean @@ -0,0 +1,94 @@ +import OAI.Topology.CoarseAssembly.TopologicalK1 +import Mathlib.Tactic.FinCases + +namespace OAI + +/-! # The two-by-two stabilization used for spatial K₁ representatives -/ + +noncomputable section + +namespace CoarseAssembly.TopologicalK1 + +variable {R : Type*} [Ring R] [TopologicalSpace R] + +theorem matrixClass_inv {n : ℕ} (g : InvertibleMatrix R n) : + matrixClass R g⁻¹ = -matrixClass R g := by + have h := matrixClass_mul g g⁻¹ + rw [mul_inv_cancel, matrixClass_one] at h + exact eq_neg_of_add_eq_zero_left (by simpa only [add_comm] using h.symm) + +theorem matrixClass_conjugate {n : ℕ} (g h : InvertibleMatrix R n) : + matrixClass R (g * h * g⁻¹) = matrixClass R h := by + rw [matrixClass_mul, matrixClass_mul, matrixClass_inv] + abel + +def scalarUnitMatrix (g : Rˣ) : InvertibleMatrix R 1 := + Units.map (Matrix.scalar (Fin 1)).toMonoidHom g + +def diagonalTwoUnits (g h : Rˣ) : InvertibleMatrix R 2 := + Units.map (Matrix.diagonalRingHom (Fin 2) R).toMonoidHom + { val := fun i => if i = 0 then (g : R) else (h : R) + inv := fun i => if i = 0 then (g⁻¹ : Rˣ) else (h⁻¹ : Rˣ) + val_inv := by ext i; by_cases hi : i = 0 <;> simp [hi] + inv_val := by ext i; by_cases hi : i = 0 <;> simp [hi] } + +omit [TopologicalSpace R] in +theorem diagonalTwo_stabilizes (g : Rˣ) : + IsStabilization R (scalarUnitMatrix g) (diagonalTwoUnits g 1) := by + apply Matrix.ext + intro i j + rcases i with i | i <;> rcases j with j | j <;> fin_cases i <;> fin_cases j <;> + norm_num [IsStabilization, diagonalTwoUnits, scalarUnitMatrix, Matrix.diagonal, + Matrix.scalar, Matrix.fromBlocks, Matrix.submatrix, finSumFinEquiv] + +theorem diagonalTwo_matrixClass_one (g : Rˣ) : + matrixClass R (diagonalTwoUnits g 1) = matrixClass R (scalarUnitMatrix g) := + (matrixClass_stabilize _ _ (diagonalTwo_stabilizes g)).symm + +def flipTwoUnits : InvertibleMatrix R 2 where + val := !![0, 1; 1, 0] + inv := !![0, 1; 1, 0] + val_inv := by + ext i j + fin_cases i <;> fin_cases j <;> simp [Matrix.mul_apply, Fin.sum_univ_two] + inv_val := by + ext i j + fin_cases i <;> fin_cases j <;> simp [Matrix.mul_apply, Fin.sum_univ_two] + +omit [TopologicalSpace R] in +theorem diagonalTwo_flip (g h : Rˣ) : + flipTwoUnits * diagonalTwoUnits g h * (flipTwoUnits : InvertibleMatrix R 2)⁻¹ = + diagonalTwoUnits h g := by + apply Units.ext + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp [flipTwoUnits, diagonalTwoUnits, Matrix.mul_apply, Matrix.diagonal, + Matrix.vecHead, Matrix.vecTail] + +theorem diagonalTwo_matrixClass_swap (g h : Rˣ) : + matrixClass R (diagonalTwoUnits g h) = matrixClass R (diagonalTwoUnits h g) := by + exact (matrixClass_conjugate (flipTwoUnits : InvertibleMatrix R 2) + (diagonalTwoUnits g h)).symm.trans (congrArg (matrixClass R) (diagonalTwo_flip g h)) + +omit [TopologicalSpace R] in +theorem diagonalTwo_mul (g h : Rˣ) : + diagonalTwoUnits g h = diagonalTwoUnits g 1 * diagonalTwoUnits 1 h := by + apply Units.ext + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp [diagonalTwoUnits, Matrix.mul_apply, Matrix.diagonal] + +/-- The exact stabilization identity for two relative unitaries. -/ +theorem diagonalTwo_matrixClass (g h : Rˣ) : + matrixClass R (diagonalTwoUnits g h) = + matrixClass R (scalarUnitMatrix g) + matrixClass R (scalarUnitMatrix h) := by + rw [diagonalTwo_mul, matrixClass_mul, diagonalTwo_matrixClass_one, + diagonalTwo_matrixClass_swap 1 h, diagonalTwo_matrixClass_one] + +end CoarseAssembly.TopologicalK1 + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/KazhdanInput.lean b/lean/OAI/Topology/CoarseAssembly/KazhdanInput.lean new file mode 100644 index 0000000000000000000000000000000000000000..6781650ef414c76ef5e5086126ff12e3fdb29a36 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/KazhdanInput.lean @@ -0,0 +1,44 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.AveragingPropagation + +namespace OAI + +/-! # The fixed published spectral-gap input + +The elementary matrices below and their inverses give a fixed finite +symmetric generating set of SL3(Z), with the identity included. The input +used in the conditional development is exactly the uniform lazy-averaging +estimate on the finite congruence quotients, with the standard ample +coefficient space. It is the specialization of Bekka–de la Harpe–Valette +(2008), Proposition 1.3.2 and Example 1.7.4, explained in manuscript §5.2. + +No proof of that published input is asserted during the conditional phase. +The spatial Roe transfer itself is proved from it below. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +theorem elementaryMoves_nonempty : elementaryMoves.Nonempty := + ⟨1, one_mem_symmetricMoves _⟩ + +theorem elementaryMoves_symmetric {s : ArithmeticGroup} (hs : s ∈ elementaryMoves) : + s⁻¹ ∈ elementaryMoves := inv_mem_symmetricMoves hs + +def PublishedKazhdanInput : Prop := UniformAveragingGap elementaryMoves AmpleSpace + +/-- The transfer in manuscript §5 for the fixed graph family, conditional +only on its identified published spectral-gap input. -/ +theorem roe_transfer_of_published_gap (hgap : PublishedKazhdanInput) : + letI : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnit + DiscreteRoe.MapsToRoe (fiberEmbedding (H := AmpleSpace) BaseFiber) := + concrete_transfer_of_gap elementaryMoves chosenHolonomyUnit elementaryMoves_nonempty hgap + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/KernelProjection.lean b/lean/OAI/Topology/CoarseAssembly/KernelProjection.lean new file mode 100644 index 0000000000000000000000000000000000000000..662f4640549b282f9c166d0a9812b6462137dbb3 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/KernelProjection.lean @@ -0,0 +1,93 @@ +import OAI.Topology.CoarseAssembly.FredholmSquare +import Mathlib.Analysis.Normed.Operator.Compact.FiniteDimension + +namespace OAI + +/-! # The finite-rank kernel correction + +For a self-adjoint operator with compact square defect, the orthogonal +projection onto its kernel is compact. Adding that projection removes the +kernel and preserves self-adjointness and the compact square defect. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +def kernelClosedSubmodule (F : End H) : ClosedSubmodule ℂ H := + ⟨F.ker, F.isClosed_ker⟩ + +def kernelProjection (F : End H) : End H := (kernelClosedSubmodule F).starProjection + +theorem kernelProjection_selfAdjoint (F : End H) : IsSelfAdjoint (kernelProjection F) := + isSelfAdjoint_starProjection _ + +theorem mul_kernelProjection (F : End H) : F * kernelProjection F = 0 := by + ext x + exact (kernelClosedSubmodule F).starProjection_apply_mem x + +theorem kernelProjection_mul (F : End H) (hF : IsSelfAdjoint F) : + kernelProjection F * F = 0 := by + have h := congrArg star (mul_kernelProjection F) + simpa only [star_mul, star_zero, hF.star_eq, (kernelProjection_selfAdjoint F).star_eq] using h + +theorem kernelProjection_sq (F : End H) : + kernelProjection F * kernelProjection F = kernelProjection F := + (kernelClosedSubmodule F).isIdempotentElem_starProjection + +theorem kernelProjection_compact (F : End H) + (hF : IsCompactOperator (F * F - 1 : End H)) : + IsCompactOperator (kernelProjection F) := by + let V := kernelClosedSubmodule F + let : FiniteDimensional ℂ V := finiteDimensional_ker_of_compact_square F hF + have hi : IsCompactOperator (id : V → V) := + (isCompactOperator_id_iff_finiteDimensional (𝕜 := ℂ)).2 inferInstance + have hp : IsCompactOperator V.orthogonalProjectionOnto := hi.comp_clm _ + exact hp.clm_comp V.subtypeL + +theorem kernel_corrected_eq_zero (F : End H) (hF : IsSelfAdjoint F) + (x : H) (hx : (F + kernelProjection F) x = 0) : x = 0 := by + have hprod : kernelProjection F * (F + kernelProjection F) = kernelProjection F := by + rw [mul_add, kernelProjection_mul F hF, kernelProjection_sq, zero_add] + have hp : kernelProjection F x = 0 := by + calc + kernelProjection F x = (kernelProjection F * (F + kernelProjection F)) x := + congrArg (fun T : End H => T x) hprod.symm + _ = kernelProjection F ((F + kernelProjection F) x) := rfl + _ = 0 := by rw [hx, map_zero] + have hf : F x = 0 := by + change F x + kernelProjection F x = 0 at hx + simpa only [hp, add_zero] using hx + have he : kernelProjection F x = x := + (kernelClosedSubmodule F).starProjection_eq_self_iff.mpr hf + exact he.symm.trans hp + +theorem kernel_corrected_injective (F : End H) (hF : IsSelfAdjoint F) : + Function.Injective (F + kernelProjection F) := by + intro x y hxy + apply sub_eq_zero.mp + apply kernel_corrected_eq_zero F hF + rw [map_sub, hxy, sub_self] + +theorem kernel_corrected_selfAdjoint (F : End H) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (F + kernelProjection F) := + hF.add (kernelProjection_selfAdjoint F) + +theorem kernel_corrected_compact_square (F : End H) (hF : IsSelfAdjoint F) + (hc : IsCompactOperator (F * F - 1 : End H)) : + IsCompactOperator ((F + kernelProjection F) * (F + kernelProjection F) - 1 : End H) := by + have he : (F + kernelProjection F) * (F + kernelProjection F) - 1 = + (F * F - 1) + kernelProjection F := by + rw [add_mul, mul_add, mul_add, mul_kernelProjection, + kernelProjection_mul F hF, kernelProjection_sq] + abel + rw [he] + exact hc.add (kernelProjection_compact F hc) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LateRipsCoarsening.lean b/lean/OAI/Topology/CoarseAssembly/LateRipsCoarsening.lean new file mode 100644 index 0000000000000000000000000000000000000000..593666bbd6af8e63e71e383d2211c945cc9b29c3 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LateRipsCoarsening.lean @@ -0,0 +1,66 @@ +import OAI.Topology.CoarseAssembly.SeparatedRipsIndex +import OAI.Topology.CoarseAssembly.ClopenNaturality +import OAI.Topology.CoarseAssembly.RipsScaleCompatibility + +namespace OAI + +/-! # Coarsening commutes with restriction to every sufficiently late component -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic +open scoped ZeroAtInfty + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r s : ℝ} + +omit [∀ i, Fintype (Q i)] [∀ i, DecidableEq (Q i)] in +theorem separatedRips_coarsen_preimage (o : ∀ i, Q i) (hrs : r ≤ s) (i : ℕ) : + letI := separatedMetric o + ∀ x : Point (Sigma Q) r, + coarsen hrs x ∈ Set.range (separatedRipsEmbedding o s i) ↔ + x ∈ Set.range (separatedRipsEmbedding o r i) := by + let := separatedMetric o + intro x + change coarsen hrs x ∈ Set.range (mapPoint (separatedComponent i) + (fun a b => ((separatedComponent_isometry o i).dist_eq a b).le)) ↔ + x ∈ Set.range (mapPoint (separatedComponent i) + (fun a b => ((separatedComponent_isometry o i).dist_eq a b).le)) + rw [mapPoint_range (separatedComponent i) (separatedComponent_isometry o i), + mapPoint_range (separatedComponent i) (separatedComponent_isometry o i)] + rfl + +omit [∀ i, DecidableEq (Q i)] in +theorem lateRipsFunctionHom_coarsen (o : ∀ i, Q i) (hrs : r ≤ s) + (i : ℕ) (hi : s < i) : + letI := separatedMetric o + (pullback (inclusion (X := Sigma Q) hrs)).comp (lateRipsFunctionHom o s i) = + (lateRipsFunctionHom o r i).comp (scaleFunctionHom hrs).toNonUnitalStarAlgHom := by + let := separatedMetric o + have hir : r < i := hrs.trans_lt hi + have heq := pullback_zeroExtension + (separatedRipsEmbedding o r i) (separatedRipsEmbedding_open o r i hir) + (separatedRipsEmbedding o s i) (separatedRipsEmbedding_open o s i hi) + (inclusion (X := Sigma Q) hrs) (inclusion (X := Q i) hrs) + (fun a => coarsen_mapPoint hrs (separatedComponent i) + (fun x y => ((separatedComponent_isometry o i).dist_eq x y).le) a) + (separatedRips_coarsen_preimage o hrs i) + ext f x + have hx := congrArg (fun g : C₀(Point (Sigma Q) r, ℂ) => g x) + (DFunLike.congr_fun heq (compactFunctionLift f)) + have hc : pullback (inclusion (X := Q i) hrs) (compactFunctionLift f) = + compactFunctionLift ((scaleFunctionHom hrs) f) := by + ext p + rfl + simp only [NonUnitalStarAlgHom.comp_apply] at hx + rw [hc] at hx + simpa only [lateRipsFunctionHom, dite_eq_left hi, dite_eq_left hir, + NonUnitalStarAlgHom.comp_apply, StarAlgHom.coe_toNonUnitalStarAlgHom] using hx + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Lattice.lean b/lean/OAI/Topology/CoarseAssembly/Lattice.lean new file mode 100644 index 0000000000000000000000000000000000000000..8b507c97635284679208cbed78815c7ec40e4c34 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Lattice.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Combinatorics.SimpleGraph.Basic +import Mathlib.Data.Set.Finite.Lattice +import Mathlib.Data.Int.Interval +import Mathlib.Algebra.Order.Ring.Abs +import Mathlib.Algebra.Order.Group.MinMax + +namespace OAI + +/-! +# The triangular-lattice discs + +The vertex set, adjacency, radius and depth used in §3 of the coarse Novikov +manuscript. The three integer linear forms are precisely those in its hexagonal +radius `max {|a|, |b|, |a+b|}`. These definitions do not assert the unproved +identification of the filled geometric realization with a topological disc. +-/ + +namespace CoarseAssembly + +theorem latticeRadius_nonneg (u : LatticeVertex) : 0 ≤ latticeRadius u := by + exact (abs_nonneg _).trans (le_max_right _ _) + +def latticeNeighbors (u : LatticeVertex) : Finset LatticeVertex := + {(u.1 + 1, u.2), (u.1 - 1, u.2), (u.1, u.2 + 1), + (u.1, u.2 - 1), (u.1 + 1, u.2 - 1), (u.1 - 1, u.2 + 1)} + +theorem mem_latticeNeighbors_iff (u v : LatticeVertex) : + v ∈ latticeNeighbors u ↔ triangularGraph.Adj u v := by + rcases u with ⟨a, b⟩ + rcases v with ⟨c, d⟩ + simp only [latticeNeighbors, Finset.mem_insert, Finset.mem_singleton, Prod.mk.injEq, + triangularGraph, abs_le, ne_eq, Prod.mk.injEq] + omega + +theorem card_latticeNeighbors_le (u : LatticeVertex) : (latticeNeighbors u).card ≤ 6 := by + unfold latticeNeighbors + exact le_trans (Finset.card_insert_le _ _) (by + apply Nat.succ_le_succ + exact le_trans (Finset.card_insert_le _ _) (by + apply Nat.succ_le_succ + exact le_trans (Finset.card_insert_le _ _) (by + apply Nat.succ_le_succ + exact le_trans (Finset.card_insert_le _ _) (by + apply Nat.succ_le_succ + exact le_trans (Finset.card_insert_le _ _) (by simp))))) + +/-- Radius changes by at most one across a lattice edge. -/ +theorem latticeRadius_adj {u v : LatticeVertex} (h : triangularGraph.Adj u v) : + |latticeRadius u - latticeRadius v| ≤ 1 := by + unfold latticeRadius + apply (abs_max_sub_max_le_max _ _ _ _).trans + apply max_le + · apply (abs_max_sub_max_le_max _ _ _ _).trans + exact max_le ((abs_abs_sub_abs_le_abs_sub _ _).trans h.1) + ((abs_abs_sub_abs_le_abs_sub _ _).trans h.2.1) + · exact (abs_abs_sub_abs_le_abs_sub _ _).trans h.2.2.1 + +theorem finite_disc (j : ℕ) : {u : LatticeVertex | latticeRadius u ≤ (j : ℤ)}.Finite := by + apply ((Set.finite_Icc (-(j : ℤ)) j).prod (Set.finite_Icc (-(j : ℤ)) j)).subset + intro u hu + simp only [Set.mem_ofPred_eq, latticeRadius, max_le_iff, abs_le] at hu + exact ⟨hu.1.1, hu.1.2⟩ + +instance (j : ℕ) : Inhabited (Disc j) := + ⟨⟨(0, 0), by simp [latticeRadius]⟩⟩ + +theorem discDepth_int (j : ℕ) (u : Disc j) : + (discDepth j u : ℤ) = (j : ℤ) - latticeRadius u.val := by + exact Int.toNat_of_nonneg (sub_nonneg.mpr u.property) + +theorem discDepth_adj {j : ℕ} {u v : Disc j} (h : (discGraph j).Adj u v) : + |(discDepth j u : ℤ) - (discDepth j v : ℤ)| ≤ 1 := by + rw [discDepth_int, discDepth_int] + have hr := latticeRadius_adj h + rw [abs_le] at hr ⊢ + omega + +theorem discDepth_eq_zero_iff (j : ℕ) (u : Disc j) : + discDepth j u = 0 ↔ latticeRadius u.val = j := by + have hd := discDepth_int j u + omega + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LatticeCharge.lean b/lean/OAI/Topology/CoarseAssembly/LatticeCharge.lean new file mode 100644 index 0000000000000000000000000000000000000000..140f6cc1a85e88fcb7d2a72d2ae1717da847ee18 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LatticeCharge.lean @@ -0,0 +1,167 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.Lattice +import OAI.Topology.CoarseAssembly.ShortLoops +import Mathlib.Combinatorics.SimpleGraph.Walk.Decomp + +namespace OAI + +/-! +# A combinatorial ray charge and the half-plane argument + +We use a half-open cut along the positive horizontal ray: an edge entering +height zero from below has charge one exactly when its endpoint has positive +first coordinate. This is a combinatorial convention at ray vertices; edges +incident to the origin have charge zero. Its restriction to any of the six +open lattice half-planes is an exact difference of vertex potentials. +-/ + +namespace CoarseAssembly + +@[simp] theorem latticeCharge_self (u : LatticeVertex) : latticeCharge u u = 0 := by + simp only [latticeCharge] + split_ifs <;> omega + +theorem latticeCharge_reverse (u v : LatticeVertex) : latticeCharge v u = -latticeCharge u v := by + simp only [latticeCharge] + split_ifs <;> omega + +theorem latticeCharge_abs_le (u v : LatticeVertex) : |latticeCharge u v| ≤ 1 := by + simp only [latticeCharge] + split_ifs <;> norm_num + +inductive HexDirection + | a | negA | b | negB | sum | negSum + +def HexDirection.eval : HexDirection → LatticeVertex → ℤ + | .a, u => u.1 + | .negA, u => -u.1 + | .b, u => u.2 + | .negB, u => -u.2 + | .sum, u => u.1 + u.2 + | .negSum, u => -(u.1 + u.2) + +def HexDirection.potential : HexDirection → LatticeVertex → ℤ + | .a, u | .sum, u => if 0 ≤ u.2 then 1 else 0 + | _, _ => 0 + +theorem HexDirection.adj_bound (d : HexDirection) {u v : LatticeVertex} + (h : triangularGraph.Adj u v) : |d.eval u - d.eval v| ≤ 1 := by + rcases h with ⟨ha, hb, hab, _⟩ + rw [abs_le] at ha hb hab ⊢ + cases d <;> simp only [HexDirection.eval] <;> omega + +theorem HexDirection.radius_witness (u : LatticeVertex) : + ∃ d : HexDirection, d.eval u = latticeRadius u := by + simp only [latticeRadius] + rcases le_total |u.1| |u.2| with h | h + · rw [max_eq_right h] + rcases le_total |u.2| |u.1 + u.2| with h' | h' + · rw [max_eq_right h'] + by_cases hs : 0 ≤ u.1 + u.2 + · exact ⟨.sum, (abs_of_nonneg hs).symm⟩ + · exact ⟨.negSum, (abs_of_neg (by omega)).symm⟩ + · rw [max_eq_left h'] + by_cases hs : 0 ≤ u.2 + · exact ⟨.b, (abs_of_nonneg hs).symm⟩ + · exact ⟨.negB, (abs_of_neg (by omega)).symm⟩ + · rw [max_eq_left h] + rcases le_total |u.1| |u.1 + u.2| with h' | h' + · rw [max_eq_right h'] + by_cases hs : 0 ≤ u.1 + u.2 + · exact ⟨.sum, (abs_of_nonneg hs).symm⟩ + · exact ⟨.negSum, (abs_of_neg (by omega)).symm⟩ + · rw [max_eq_left h'] + by_cases hs : 0 ≤ u.1 + · exact ⟨.a, (abs_of_nonneg hs).symm⟩ + · exact ⟨.negA, (abs_of_neg (by omega)).symm⟩ + +/-- Exactness on all six open half-planes is the winding-zero argument, +including repeated edges and stationary projections. -/ +theorem latticeCharge_halfPlane (d : HexDirection) {u v : LatticeVertex} + (h : u = v ∨ triangularGraph.Adj u v) (hu : 0 < d.eval u) (hv : 0 < d.eval v) : + latticeCharge u v = d.potential v - d.potential u := by + rcases h with rfl | h + · simp + rcases u with ⟨a, b⟩ + rcases v with ⟨c, e⟩ + simp only [triangularGraph, abs_le] at h + cases d <;> simp only [HexDirection.eval, HexDirection.potential, latticeCharge] at * <;> + split_ifs <;> omega + +section ProjectedWalks + +variable {V : Type*} {G : SimpleGraph V} (π : V → LatticeVertex) +variable (hπ : ∀ u v, G.Adj u v → π u = π v ∨ triangularGraph.Adj (π u) (π v)) + +include hπ + +theorem projected_functional_bound (d : HexDirection) {u v : V} (p : G.Walk u v) : + |d.eval (π u) - d.eval (π v)| ≤ (p.length : ℤ) := by + induction p with + | nil => simp + | @cons u v w h p ih => + have he : |d.eval (π u) - d.eval (π v)| ≤ 1 := by + rcases hπ u v h with he | he + · simp [he] + · exact d.adj_bound he + calc + _ ≤ |d.eval (π u) - d.eval (π v)| + |d.eval (π v) - d.eval (π w)| := + abs_sub_le _ _ _ + _ ≤ 1 + (p.length : ℤ) := add_le_add he ih + _ = ((SimpleGraph.Walk.cons h p).length : ℤ) := by simp; omega + +theorem projected_charge_exact (d : HexDirection) {u v : V} (p : G.Walk u v) + (hp : ∀ w ∈ p.support, 0 < d.eval (π w)) : + walkCharge (fun u v => latticeCharge (π u) (π v)) p = + d.potential (π v) - d.potential (π u) := by + induction p with + | nil => simp + | @cons u v w h p ih => + have hu := hp u (by simp) + have htail : ∀ z ∈ p.support, 0 < d.eval (π z) := by + intro z hz + exact hp z (by simp [hz]) + rw [walkCharge_cons, latticeCharge_halfPlane d (hπ u v h) hu + (htail v p.start_mem_support), ih htail] + omega + +/-- A charged closed path must meet the nonpositive side of every one of +the six linear functionals. -/ +theorem charged_walk_meets_halfPlane (d : HexDirection) {u : V} (p : G.Walk u u) + (hc : walkCharge (fun u v => latticeCharge (π u) (π v)) p ≠ 0) : + ∃ w ∈ p.support, d.eval (π w) ≤ 0 := by + by_contra h + push Not at h + have hz := projected_charge_exact π hπ d p h + exact hc (by simpa using hz) + +/-- The geometric estimate in the small-loop lemma. -/ +theorem charged_walk_radius_bound {u : V} (p : G.Walk u u) + (hc : walkCharge (fun u v => latticeCharge (π u) (π v)) p ≠ 0) : + 2 * latticeRadius (π u) ≤ (p.length : ℤ) := by + obtain ⟨d, hd⟩ := HexDirection.radius_witness (π u) + obtain ⟨w, hw, hf⟩ := charged_walk_meets_halfPlane π hπ d p hc + obtain ⟨q, r, rfl⟩ := SimpleGraph.Walk.mem_support_iff_exists_append.mp hw + have hq := projected_functional_bound π hπ d q + have hr := projected_functional_bound π hπ d r + rw [abs_le] at hq hr + simp only [SimpleGraph.Walk.length_append, Nat.cast_add] + omega + +/-- The same estimate holds at every occurrence of a vertex, by rotating +the closed walk. No simplicity hypothesis is needed. -/ +theorem charged_walk_all_radius_bound {u : V} (p : G.Walk u u) + (hc : walkCharge (fun u v => latticeCharge (π u) (π v)) p ≠ 0) + {w : V} (hw : w ∈ p.support) : + 2 * latticeRadius (π w) ≤ (p.length : ℤ) := by + obtain ⟨q, r, rfl⟩ := SimpleGraph.Walk.mem_support_iff_exists_append.mp hw + have hrot : walkCharge (fun u v => latticeCharge (π u) (π v)) (r.append q) ≠ 0 := by + simpa only [walkCharge_append, add_comm] using hc + have hb := charged_walk_radius_bound π hπ (r.append q) hrot + simpa only [SimpleGraph.Walk.length_append, Nat.add_comm] using hb + +end ProjectedWalks + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LatticeHat.lean b/lean/OAI/Topology/CoarseAssembly/LatticeHat.lean new file mode 100644 index 0000000000000000000000000000000000000000..860fceeed0ddf6781e897691493a7d8adf8f03c8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LatticeHat.lean @@ -0,0 +1,192 @@ +import OAI.Topology.CoarseAssembly.Lattice +import Mathlib.Algebra.Order.Floor.Ring +import Mathlib.Data.Finsupp.Basic +import Mathlib.Topology.Instances.Real.Lemmas +import Mathlib.Tactic.Linarith + +namespace OAI + +/-! # Piecewise linear hat functions of the triangular lattice + +The nodal function at a lattice vertex is `max (0, 1 - ρ(p-v))`, where +`ρ(x,y) = max(|x|, |y|, |x+y|)`. These are the barycentric coordinate +functions for the filled triangular lattice. Their partition of unity +maps the filled hexagons into Rips space. +-/ + +noncomputable section + +namespace CoarseAssembly + +def realLatticeRadius (p : ℝ × ℝ) : ℝ := max (max |p.1| |p.2|) |p.1 + p.2| + +theorem realLatticeRadius_le_iff {p : ℝ × ℝ} {a : ℝ} : + realLatticeRadius p ≤ a ↔ |p.1| ≤ a ∧ |p.2| ≤ a ∧ |p.1 + p.2| ≤ a := by + simp only [realLatticeRadius, max_le_iff, and_assoc] + +theorem realLatticeRadius_lt_iff {p : ℝ × ℝ} {a : ℝ} : + realLatticeRadius p < a ↔ |p.1| < a ∧ |p.2| < a ∧ |p.1 + p.2| < a := by + simp only [realLatticeRadius, max_lt_iff, and_assoc] + +theorem realLatticeRadius_continuous : Continuous realLatticeRadius := by + unfold realLatticeRadius + fun_prop + +def hatKernel (x y : ℝ) : ℝ := max 0 (1 - realLatticeRadius (x, y)) + +def latticeHat (p : ℝ × ℝ) (v : LatticeVertex) : ℝ := + hatKernel (p.1 - v.1) (p.2 - v.2) + +theorem latticeHat_nonneg (p : ℝ × ℝ) (v : LatticeVertex) : 0 ≤ latticeHat p v := + le_max_left _ _ + +theorem latticeHat_continuous (v : LatticeVertex) : Continuous (fun p => latticeHat p v) := by + unfold latticeHat hatKernel realLatticeRadius + fun_prop + +theorem latticeHat_pos_iff (p : ℝ × ℝ) (v : LatticeVertex) : + 0 < latticeHat p v ↔ + |p.1 - v.1| < 1 ∧ |p.2 - v.2| < 1 ∧ |(p.1 - v.1) + (p.2 - v.2)| < 1 := by + simp only [latticeHat, hatKernel, lt_max_iff, lt_self_iff_false, false_or, + sub_pos, realLatticeRadius_lt_iff] + +/-- The four cell functions sum to one; at most three of them are positive. -/ +theorem hatKernel_partition {s t : ℝ} (hs : 0 ≤ s) (ht : 0 ≤ t) + (hs₁ : s ≤ 1) (ht₁ : t ≤ 1) : + hatKernel s t + hatKernel (s - 1) t + hatKernel s (t - 1) + + hatKernel (s - 1) (t - 1) = 1 := by + have r00 : realLatticeRadius (s, t) = s + t := by + simp only [realLatticeRadius, abs_of_nonneg hs, abs_of_nonneg ht, + abs_of_nonneg (add_nonneg hs ht)] + rw [max_eq_right (max_le (by linarith) (by linarith))] + have r11 : realLatticeRadius (s - 1, t - 1) = 2 - s - t := by + rw [realLatticeRadius, abs_of_nonpos (by linarith : s - 1 ≤ 0), + abs_of_nonpos (by linarith : t - 1 ≤ 0), + abs_of_nonpos (by linarith : s - 1 + (t - 1) ≤ 0)] + rw [max_eq_right (max_le (by linarith) (by linarith))] + ring + by_cases hst : s + t ≤ 1 + · have r10 : realLatticeRadius (s - 1, t) = 1 - s := by + rw [realLatticeRadius, abs_of_nonpos (by linarith : s - 1 ≤ 0), + abs_of_nonneg ht, abs_of_nonpos (by linarith : s - 1 + t ≤ 0)] + rw [show max (-(s - 1)) t = -(s - 1) from max_eq_left (by linarith), + max_eq_left (by linarith)] + ring + have r01 : realLatticeRadius (s, t - 1) = 1 - t := by + rw [realLatticeRadius, abs_of_nonneg hs, + abs_of_nonpos (by linarith : t - 1 ≤ 0), + abs_of_nonpos (by linarith : s + (t - 1) ≤ 0)] + rw [show max s (-(t - 1)) = -(t - 1) from max_eq_right (by linarith), + max_eq_left (by linarith)] + ring + simp only [hatKernel, r00, r10, r01, r11] + rw [max_eq_right (by linarith : 0 ≤ 1 - (s + t)), + max_eq_right (by linarith : 0 ≤ 1 - (1 - s)), + max_eq_right (by linarith : 0 ≤ 1 - (1 - t)), + max_eq_left (by linarith : 1 - (2 - s - t) ≤ 0)] + ring + · have r10 : realLatticeRadius (s - 1, t) = t := by + rw [realLatticeRadius, abs_of_nonpos (by linarith : s - 1 ≤ 0), + abs_of_nonneg ht, abs_of_nonneg (by linarith : 0 ≤ s - 1 + t)] + rw [show max (-(s - 1)) t = t from max_eq_right (by linarith), + max_eq_left (by linarith)] + have r01 : realLatticeRadius (s, t - 1) = s := by + rw [realLatticeRadius, abs_of_nonneg hs, + abs_of_nonpos (by linarith : t - 1 ≤ 0), + abs_of_nonneg (by linarith : 0 ≤ s + (t - 1))] + rw [show max s (-(t - 1)) = s from max_eq_left (by linarith), + max_eq_left (by linarith)] + simp only [hatKernel, r00, r10, r01, r11] + rw [max_eq_left (by linarith : 1 - (s + t) ≤ 0), + max_eq_right (by linarith : 0 ≤ 1 - t), max_eq_right (by linarith : 0 ≤ 1 - s), + max_eq_right (by linarith : 0 ≤ 1 - (2 - s - t))] + ring + +def latticeCell (p : ℝ × ℝ) : Finset LatticeVertex := + ({⌊p.1⌋, ⌊p.1⌋ + 1} : Finset ℤ) ×ˢ ({⌊p.2⌋, ⌊p.2⌋ + 1} : Finset ℤ) + +theorem latticeHat_support_cell (p : ℝ × ℝ) (v : LatticeVertex) + (hv : latticeHat p v ≠ 0) : v ∈ latticeCell p := by + have hp := (latticeHat_pos_iff p v).mp (lt_of_le_of_ne (latticeHat_nonneg p v) hv.symm) + have bound (x : ℝ) (n : ℤ) (h : |x - n| < 1) : n = ⌊x⌋ ∨ n = ⌊x⌋ + 1 := by + have hf := Int.floor_le x + have hc := Int.lt_floor_add_one x + rw [abs_lt] at h + have hlow : ⌊x⌋ < n + 1 := by exact_mod_cast (show (⌊x⌋ : ℝ) < (n : ℝ) + 1 by linarith) + have hupp : n < ⌊x⌋ + 2 := by exact_mod_cast (show (n : ℝ) < (⌊x⌋ : ℝ) + 2 by linarith) + omega + simpa only [latticeCell, Finset.mem_product, Finset.mem_insert, Finset.mem_singleton] + using And.intro (bound p.1 v.1 hp.1) (bound p.2 v.2 hp.2.1) + +def latticeHatWeights (p : ℝ × ℝ) : LatticeVertex →₀ ℝ := + Finsupp.onFinset (latticeCell p) (latticeHat p) (latticeHat_support_cell p) + +@[simp] theorem latticeHatWeights_apply (p : ℝ × ℝ) (v : LatticeVertex) : + latticeHatWeights p v = latticeHat p v := rfl + +theorem latticeHatWeights_total (p : ℝ × ℝ) : + (latticeHatWeights p).sum (fun _ t => t) = 1 := by + classical + rw [latticeHatWeights, Finsupp.onFinset_sum (latticeHat_support_cell p) (by simp)] + have hx : (⌊p.1⌋ : ℤ) ≠ ⌊p.1⌋ + 1 := by omega + have hy : (⌊p.2⌋ : ℤ) ≠ ⌊p.2⌋ + 1 := by omega + have hs : 0 ≤ p.1 - (⌊p.1⌋ : ℝ) := sub_nonneg.mpr (Int.floor_le p.1) + have ht : 0 ≤ p.2 - (⌊p.2⌋ : ℝ) := sub_nonneg.mpr (Int.floor_le p.2) + have hs₁ : p.1 - (⌊p.1⌋ : ℝ) ≤ 1 := by linarith [Int.lt_floor_add_one p.1] + have ht₁ : p.2 - (⌊p.2⌋ : ℝ) ≤ 1 := by linarith [Int.lt_floor_add_one p.2] + have h := hatKernel_partition hs ht hs₁ ht₁ + simp only [latticeCell, Finset.sum_product, Finset.sum_insert (Finset.notMem_singleton.mpr hx), + Finset.sum_insert (Finset.notMem_singleton.mpr hy), Finset.sum_singleton, latticeHat, + Int.cast_add, Int.cast_one, sub_add_eq_sub_sub] + linarith + +theorem latticeHat_adjacent {p : ℝ × ℝ} {v w : LatticeVertex} + (hv : 0 < latticeHat p v) (hw : 0 < latticeHat p w) : + v = w ∨ triangularGraph.Adj v w := by + by_cases h : v = w + · exact Or.inl h + right + have hv' := (latticeHat_pos_iff p v).mp hv + have hw' := (latticeHat_pos_iff p w).mp hw + have bound (a b x : ℝ) (ha : |x - a| < 1) (hb : |x - b| < 1) : |a - b| < 2 := by + rw [abs_lt] at ha hb ⊢ + constructor <;> linarith + have hab : |v.1 - w.1| < 2 := by exact_mod_cast bound (v.1 : ℝ) w.1 p.1 hv'.1 hw'.1 + have hbc : |v.2 - w.2| < 2 := by exact_mod_cast bound (v.2 : ℝ) w.2 p.2 hv'.2.1 hw'.2.1 + have hs : |(v.1 + v.2) - (w.1 + w.2)| < 2 := by + have hvsum : |(p.1 + p.2) - ((v.1 : ℝ) + v.2)| < 1 := by + convert hv'.2.2 using 1 + congr 1 + ring + have hwsum : |(p.1 + p.2) - ((w.1 : ℝ) + w.2)| < 1 := by + convert hw'.2.2 using 1 + congr 1 + ring + exact_mod_cast bound ((v.1 : ℝ) + v.2) ((w.1 : ℝ) + w.2) (p.1 + p.2) hvsum hwsum + exact ⟨by omega, by omega, by omega, h⟩ + +theorem latticeHat_in_disc {j : ℕ} {p : ℝ × ℝ} + (hp : realLatticeRadius p ≤ j) {v : LatticeVertex} (hv : 0 < latticeHat p v) : + latticeRadius v ≤ j := by + have hp' := realLatticeRadius_le_iff.mp hp + have hv' := (latticeHat_pos_iff p v).mp hv + have bound (x n : ℝ) (hx : |x| ≤ j) (hn : |x - n| < 1) : |n| < (j : ℝ) + 1 := by + rw [abs_le] at hx + rw [abs_lt] at hn ⊢ + constructor <;> linarith + have ha : |v.1| < (j : ℤ) + 1 := by exact_mod_cast bound p.1 v.1 hp'.1 hv'.1 + have hb : |v.2| < (j : ℤ) + 1 := by exact_mod_cast bound p.2 v.2 hp'.2.1 hv'.2.1 + have hc : |v.1 + v.2| < (j : ℤ) + 1 := by + have hsum : |(p.1 + p.2) - ((v.1 : ℝ) + v.2)| < 1 := by + convert hv'.2.2 using 1 + congr 1 + ring + exact_mod_cast bound (p.1 + p.2) ((v.1 : ℝ) + v.2) hp'.2.2 hsum + simp only [latticeRadius, max_le_iff] + omega + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LocalCompactPerturbation.lean b/lean/OAI/Topology/CoarseAssembly/LocalCompactPerturbation.lean new file mode 100644 index 0000000000000000000000000000000000000000..37fe1b4fe0cb6b4fe989bfcad899e890bd681e9e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LocalCompactPerturbation.lean @@ -0,0 +1,76 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation + +namespace OAI + +/-! # Locally compact changes of Fredholm operators + +This also permits changing an operator on the subspace where its +representation vanishes. Compactness is required only after multiplying +by a represented coefficient. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] + +theorem compact_local_smul_right (c : OddCycle A) (K : End c.space) + (hr : ∀ a, IsCompactOperator (K * c.representation a : End c.space)) (t : ℝ) (a : A) : + IsCompactOperator ((t • K) * c.representation a : End c.space) := by + rw [smul_mul_assoc] + exact (hr a).smul t + +theorem compact_local_smul_left (c : OddCycle A) (K : End c.space) + (hl : ∀ a, IsCompactOperator (c.representation a * K : End c.space)) (t : ℝ) (a : A) : + IsCompactOperator (c.representation a * (t • K) : End c.space) := by + rw [mul_smul_comm] + exact (hl a).smul t + +theorem compact_local_smul_star (c : OddCycle A) (K : End c.space) + (hs : ∀ a, IsCompactOperator (star K * c.representation a : End c.space)) (t : ℝ) (a : A) : + IsCompactOperator (star (t • K) * c.representation a : End c.space) := by + rw [star_smul, star_trivial, smul_mul_assoc] + exact (hs a).smul t + +def OddCycle.localCompactHomotopy (c : OddCycle A) (K : End c.space) + (hr : ∀ a, IsCompactOperator (K * c.representation a : End c.space)) + (hl : ∀ a, IsCompactOperator (c.representation a * K : End c.space)) + (hs : ∀ a, IsCompactOperator (star K * c.representation a : End c.space)) : OddHomotopy A where + space := c.space + representation _ := c.representation + operator t := c.operator + (t : ℝ) • K + continuous_representation _ := continuous_const + continuous_operator := continuous_const.add (continuous_subtype_val.smul continuous_const) + commutator_compact t := + (c.localCompactPerturb _ (compact_local_smul_right c K hr t) + (compact_local_smul_left c K hl t) (compact_local_smul_star c K hs t)).commutator_compact + square_compact t := + (c.localCompactPerturb _ (compact_local_smul_right c K hr t) + (compact_local_smul_left c K hl t) (compact_local_smul_star c K hs t)).square_compact + adjoint_compact t := + (c.localCompactPerturb _ (compact_local_smul_right c K hr t) + (compact_local_smul_left c K hl t) (compact_local_smul_star c K hs t)).adjoint_compact + +theorem localCompactPerturb_class (c : OddCycle A) (K : End c.space) + (hr : ∀ a, IsCompactOperator (K * c.representation a : End c.space)) + (hl : ∀ a, IsCompactOperator (c.representation a * K : End c.space)) + (hs : ∀ a, IsCompactOperator (star K * c.representation a : End c.space)) : + cycleClass A (c.localCompactPerturb K hr hl hs) = cycleClass A c := by + have hstart : (c.localCompactHomotopy K hr hl hs).eval start = c := by + cases c + simp only [OddCycle.localCompactHomotopy, OddHomotopy.eval, start, zero_smul, add_zero] + have hfinish : (c.localCompactHomotopy K hr hl hs).eval finish = + c.localCompactPerturb K hr hl hs := by + simp only [OddCycle.localCompactHomotopy, OddHomotopy.eval, finish, + OddCycle.localCompactPerturb, one_smul] + have hh := homotopy_eq (c.localCompactHomotopy K hr hl hs) + rw [hstart, hfinish] at hh + exact hh.symm + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LocalizationContinuity.lean b/lean/OAI/Topology/CoarseAssembly/LocalizationContinuity.lean new file mode 100644 index 0000000000000000000000000000000000000000..f540ee628edd1a0c4ccc5816fb618ee1322d003f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LocalizationContinuity.lean @@ -0,0 +1,76 @@ +import OAI.Topology.CoarseAssembly.LocalizationNormContinuity + +namespace OAI + +/-! # Norm continuity for representation-varying finite localization -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {T X H : Type*} [TopologicalSpace T] [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [CompleteSpace H] in +theorem continuous_partitionMap (a : T → X → H →L[ℂ] H) + (ha : ∀ x, Continuous (fun t => a t x)) : + Continuous (fun t => partitionMap (a t)) := by + unfold partitionMap + apply continuous_finsetSum + intro x _ + exact continuous_const.clm_comp (ha x) + +theorem continuous_partitionCompression (a : T → X → H →L[ℂ] H) + (ha : ∀ x, Continuous (fun t => a t x)) (F : T → H →L[ℂ] H) + (hF : Continuous F) : Continuous (fun t => partitionCompression (a t) (F t)) := by + simp only [partitionCompression_eq_sum] + apply continuous_finsetSum + intro x _ + exact (ContinuousLinearMap.adjoint.continuous.comp (ha x)).clm_comp + (hF.clm_comp (ha x)) + +theorem continuous_localizedSpatialOperator (a : T → X → H →L[ℂ] H) + (ha : ∀ x, Continuous (fun t => a t x)) + (hp : ∀ t, ∑ x, (a t x).adjoint.comp (a t x) = 1) + (F : T → H →L[ℂ] H) (hF : Continuous F) : + Continuous (fun t => localizedSpatialOperator (a t) (hp t) (F t)) := by + simp only [localizedSpatialOperator_eq, partitionConjugate] + have hP := continuous_partitionMap a ha + have hC := continuous_partitionCompression a ha F hF + have hPa := ContinuousLinearMap.adjoint.continuous.comp hP + exact (continuous_const.add (hP.clm_comp (hC.clm_comp hPa))).sub + (hP.clm_comp (continuous_const.clm_comp hPa)) + +end CoarseAssembly.DiscreteRoe + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + +theorem continuous_ripsSpatialOperator (r : ℝ) (h : OddHomotopy C(Point X r, ℂ)) + (hπ : ∀ t, (h.eval t).representation 1 = 1) : + Continuous (fun t => (show Operator X h.space from ripsSpatialOperator r (h.eval t) (hπ t))) := by + exact continuous_localizedSpatialOperator + (fun t => (show X → End h.space from representedSqrt r (h.eval t))) + (fun x => h.continuous_representation (sqrtCoordinate r x)) + (fun t => representedSqrt_partition r (h.eval t) (hπ t)) + h.operator h.continuous_operator + +theorem continuous_ampleRipsOperator (r : ℝ) (h : OddHomotopy C(Point X r, ℂ)) + (hπ : ∀ t, (h.eval t).representation 1 = 1) : + Continuous (fun t => ampleRipsOperator r (h.eval t) (hπ t)) := by + have hR := continuous_ripsSpatialOperator r h hπ + change Continuous (fun t => 1 + + (coefficientIsometry (X := X) (ampleIsometry h.space)).toContinuousLinearMap.comp + (((show Operator X h.space from ripsSpatialOperator r (h.eval t) (hπ t)) - 1).comp + (coefficientIsometry (X := X) (ampleIsometry h.space)).toContinuousLinearMap.adjoint)) + exact continuous_const.add (continuous_const.clm_comp + ((hR.sub continuous_const).clm_comp continuous_const)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LocalizationNormContinuity.lean b/lean/OAI/Topology/CoarseAssembly/LocalizationNormContinuity.lean new file mode 100644 index 0000000000000000000000000000000000000000..2cda96a5ae90e17060976fef1111f64bb1fb76ac --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LocalizationNormContinuity.lean @@ -0,0 +1,59 @@ +import OAI.Topology.CoarseAssembly.PartitionCompactPerturbation + +namespace OAI + +/-! # Localization is contractive in the Fredholm operator -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X E H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem localizedSpatialOperator_sub_norm_le (a : X → E →L[ℂ] E) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) (F G : E →L[ℂ] E) : + ‖localizedSpatialOperator a ha F - localizedSpatialOperator a ha G‖ ≤ ‖F - G‖ := by + change ‖isometricExtension (partitionIsometry a ha) (partitionCompression a F) - + isometricExtension (partitionIsometry a ha) (partitionCompression a G)‖ ≤ _ + rw [isometricExtension_sub, partitionCompression_sub] + exact (operatorConjugation_norm_le _ _).trans (partitionCompression_norm_le a ha (F - G)) + +omit [Fintype X] [DecidableEq X] in +theorem coefficientExtension_sub_norm_le (V : E →ₗᵢ[ℂ] H) (F G : Operator X E) : + ‖coefficientExtension V F - coefficientExtension V G‖ ≤ ‖F - G‖ := by + change ‖isometricExtension (coefficientIsometry V) F - isometricExtension (coefficientIsometry V) G‖ ≤ _ + rw [isometricExtension_sub] + exact operatorConjugation_norm_le _ _ + +end CoarseAssembly.DiscreteRoe + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ) + +theorem ampleRipsOperator_homotopy_norm_le (h : OddHomotopy C(Point X r, ℂ)) + (s t : Interval) (hs : (h.eval s).representation 1 = 1) (ht : (h.eval t).representation 1 = 1) + (hrep : h.representation s = h.representation t) : + ‖ampleRipsOperator r (h.eval s) hs - ampleRipsOperator r (h.eval t) ht‖ ≤ + ‖h.operator s - h.operator t‖ := by + apply (coefficientExtension_sub_norm_le (ampleIsometry h.space) _ _).trans + have heq : (show X → End h.space from representedSqrt r (h.eval s)) = + (show X → End h.space from representedSqrt r (h.eval t)) := by + funext x + exact congrArg (fun ρ => ρ (sqrtCoordinate r x)) hrep + change ‖(show Operator X h.space from + localizedSpatialOperator (representedSqrt r (h.eval s)) _ (h.operator s)) - + (show Operator X h.space from + localizedSpatialOperator (representedSqrt r (h.eval t)) _ (h.operator t))‖ ≤ _ + simp only [heq] + exact localizedSpatialOperator_sub_norm_le _ _ _ _ + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LocalizationUniformEstimate.lean b/lean/OAI/Topology/CoarseAssembly/LocalizationUniformEstimate.lean new file mode 100644 index 0000000000000000000000000000000000000000..f28ef60d41d8e1f533a25abcd0ca370b5fdd6b43 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LocalizationUniformEstimate.lean @@ -0,0 +1,79 @@ +import OAI.Topology.CoarseAssembly.SandwichNormControl + +namespace OAI + +/-! # A component-independent estimate for representation-varying localization -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [Fintype X] [DecidableEq X] [CompleteSpace H] in +theorem constantBlock_sub (F G : H →L[ℂ] H) : + constantBlock (X := X) F - constantBlock G = constantBlock (F - G) := by + ext v x + rfl + +theorem partitionCompression_variation_norm_le (a b : X → H →L[ℂ] H) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) + (hb : ∑ x, (b x).adjoint.comp (b x) = 1) + (F G : H →L[ℂ] H) (C : ℝ) (hG : ‖G‖ ≤ C) : + ‖partitionCompression a F - partitionCompression b G‖ ≤ + ‖F - G‖ + 2 * C * ‖partitionMap a - partitionMap b‖ := by + have hP : ‖partitionMap a‖ ≤ 1 := (partitionIsometry a ha).norm_toContinuousLinearMap_le + have hQ : ‖partitionMap b‖ ≤ 1 := (partitionIsometry b hb).norm_toContinuousLinearMap_le + have hPa : ‖(partitionMap a).adjoint‖ ≤ 1 := by + simpa only [ContinuousLinearMap.adjoint.norm_map] using hP + have hQa : ‖(partitionMap b).adjoint‖ ≤ 1 := by + simpa only [ContinuousLinearMap.adjoint.norm_map] using hQ + have h := operatorSandwich_sub_norm_le (partitionMap a).adjoint (partitionMap b).adjoint + hPa hQa (constantBlock F) (constantBlock G) C ((constantBlock_norm_le G).trans hG) + have hd : ‖(partitionMap a).adjoint - (partitionMap b).adjoint‖ = + ‖partitionMap a - partitionMap b‖ := by + rw [← map_sub, ContinuousLinearMap.adjoint.norm_map] + simp only [operatorSandwich, ContinuousLinearMap.adjoint_adjoint, hd, + constantBlock_sub] at h + exact h.trans (add_le_add (constantBlock_norm_le (F - G)) le_rfl) + +theorem localizedSpatialOperator_eq_sandwich (a : X → H →L[ℂ] H) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) : + localizedSpatialOperator a ha F = + 1 + operatorSandwich (partitionMap a) (partitionCompression a F - 1) := rfl + +theorem localizedSpatialOperator_variation_norm_le (a b : X → H →L[ℂ] H) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) + (hb : ∑ x, (b x).adjoint.comp (b x) = 1) + (F G : H →L[ℂ] H) (C : ℝ) (hG : ‖G‖ ≤ C) : + ‖localizedSpatialOperator a ha F - localizedSpatialOperator b hb G‖ ≤ + ‖F - G‖ + (4 * C + 2) * ‖partitionMap a - partitionMap b‖ := by + have hP : ‖partitionMap a‖ ≤ 1 := (partitionIsometry a ha).norm_toContinuousLinearMap_le + have hQ : ‖partitionMap b‖ ≤ 1 := (partitionIsometry b hb).norm_toContinuousLinearMap_le + have hK : ‖partitionCompression b G - 1‖ ≤ C + 1 := + (norm_sub_le _ _).trans (add_le_add ((partitionCompression_norm_le b hb G).trans hG) + ContinuousLinearMap.norm_id_le) + have h := operatorSandwich_sub_norm_le (partitionMap a) (partitionMap b) hP hQ + (partitionCompression a F - 1) (partitionCompression b G - 1) (C + 1) hK + have hd : (partitionCompression a F - 1) - (partitionCompression b G - 1) = + partitionCompression a F - partitionCompression b G := sub_sub_sub_cancel_right _ _ _ + have he : localizedSpatialOperator a ha F - localizedSpatialOperator b hb G = + operatorSandwich (partitionMap a) (partitionCompression a F - 1) - + operatorSandwich (partitionMap b) (partitionCompression b G - 1) := by + simp only [localizedSpatialOperator_eq_sandwich, add_sub_add_left_eq_sub] + rw [he] + rw [hd] at h + have hinner := partitionCompression_variation_norm_le a b ha hb F G C hG + calc + _ ≤ ‖partitionCompression a F - partitionCompression b G‖ + + 2 * (C + 1) * ‖partitionMap a - partitionMap b‖ := h + _ ≤ (‖F - G‖ + 2 * C * ‖partitionMap a - partitionMap b‖) + + 2 * (C + 1) * ‖partitionMap a - partitionMap b‖ := add_le_add hinner le_rfl + _ = _ := by ring + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LocallyCompactAlgebra.lean b/lean/OAI/Topology/CoarseAssembly/LocallyCompactAlgebra.lean new file mode 100644 index 0000000000000000000000000000000000000000..b0d1159aba5df8fb35233ba09c8cdd65125fc3de --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LocallyCompactAlgebra.lean @@ -0,0 +1,98 @@ +import OAI.Topology.CoarseAssembly.RoeLocalCompactness +import Mathlib.Analysis.CStarAlgebra.Basic + +namespace OAI + +/-! # Local compactness of every operator in the reduced Roe algebra -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open scoped ZeroAtInfty CStarAlgebra + +variable {X H : Type*} [DecidableEq X] [TopologicalSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp + +omit [DecidableEq X] [CompleteSpace H] in +theorem locallyCompact_zero : LocallyCompact (0 : Operator X H) := by + intro f + simp only [mul_zero, zero_mul] + exact ⟨isCompactOperator_zero, isCompactOperator_zero⟩ + +omit [DecidableEq X] [CompleteSpace H] in +theorem LocallyCompact.add {T S : Operator X H} (hT : LocallyCompact T) + (hS : LocallyCompact S) : LocallyCompact (T + S) := by + intro f + simp only [mul_add, add_mul] + exact ⟨(hT f).1.add (hS f).1, (hT f).2.add (hS f).2⟩ + +omit [DecidableEq X] [CompleteSpace H] in +theorem LocallyCompact.mul {T S : Operator X H} (hT : LocallyCompact T) + (hS : LocallyCompact S) : LocallyCompact (T * S) := by + intro f + constructor + · rw [← mul_assoc] + exact (hT f).1.comp_clm S + · rw [mul_assoc] + exact (hS f).2.clm_comp T + +omit [DecidableEq X] [CompleteSpace H] in +theorem LocallyCompact.smul {T : Operator X H} (hT : LocallyCompact T) (z : ℂ) : + LocallyCompact (z • T) := by + intro f + rw [mul_smul_comm, smul_mul_assoc] + exact ⟨(hT f).1.smul z, (hT f).2.smul z⟩ + +omit [DecidableEq X] in +theorem locallyCompact_closed : IsClosed {T : Operator X H | LocallyCompact T} := by + simp only [LocallyCompact, Set.ofPred_forall] + apply isClosed_iInter + intro f + exact (isClosed_setOfPred_isCompactOperator.preimage (continuous_const.mul continuous_id)).inter + (isClosed_setOfPred_isCompactOperator.preimage (continuous_id.mul continuous_const)) + +def locallyCompactAlgebra : NonUnitalStarSubalgebra ℂ (Operator X H) where + carrier := {T | LocallyCompact T ∧ LocallyCompact (star T)} + zero_mem' := by + change LocallyCompact (0 : Operator X H) ∧ LocallyCompact (star (0 : Operator X H)) + rw [star_zero (Operator X H)] + exact ⟨locallyCompact_zero, locallyCompact_zero⟩ + add_mem' hT hS := ⟨hT.1.add hS.1, by simpa only [star_add] using hT.2.add hS.2⟩ + mul_mem' hT hS := ⟨hT.1.mul hS.1, by simpa only [star_mul] using hS.2.mul hT.2⟩ + smul_mem' z T hT := ⟨hT.1.smul z, by simpa only [star_smul] using hT.2.smul (star z)⟩ + star_mem' hT := ⟨hT.2, by simpa only [star_star] using hT.1⟩ + +omit [DecidableEq X] [TopologicalSpace X] in +theorem operator_star_continuous : Continuous (fun T : Operator X H => star T) := + (ContinuousLinearMap.adjoint : Operator X H ≃ₗᵢ⋆[ℂ] Operator X H).continuous + +omit [DecidableEq X] in +theorem locallyCompactAlgebra_closed : + IsClosed (locallyCompactAlgebra (X := X) (H := H) : Set (Operator X H)) := + locallyCompact_closed.inter (locallyCompact_closed.preimage operator_star_continuous) + +variable [PseudoMetricSpace X] [DiscreteTopology X] + +theorem roe_locallyCompact + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : Operator X H} (hT : T ∈ algebra (X := X) (H := H)) : LocallyCompact T := by + have hgen (S : Operator X H) (hS : Generator S) : + S ∈ locallyCompactAlgebra (X := X) (H := H) := by + refine ⟨generator_locallyCompact finiteBalls hS, ?_⟩ + obtain ⟨⟨r, _, hp⟩, _, hc⟩ := hS + exact locallyCompact_of_propagation finiteBalls hp.star hc + have hle : NonUnitalStarAlgebra.adjoin ℂ {S : Operator X H | Generator S} ≤ + locallyCompactAlgebra := NonUnitalStarAlgebra.adjoin_le hgen + exact (NonUnitalStarSubalgebra.topologicalClosure_minimal _ hle locallyCompactAlgebra_closed hT).1 + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LocallyFinite.lean b/lean/OAI/Topology/CoarseAssembly/LocallyFinite.lean new file mode 100644 index 0000000000000000000000000000000000000000..c4a4754cf6e1fb9ffcbdde3637a48d0b33d28ffd --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LocallyFinite.lean @@ -0,0 +1,68 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.AnalyticKHomology +import Mathlib.Analysis.CStarAlgebra.ContinuousMap +import Mathlib.Algebra.Colimit.Module + +namespace OAI + +/-! +# Locally finite analytic K-homology and coarsening + +The domain is the odd Fredholm-module group of the actual algebra `C₀(Y, ℂ)`. +A proper continuous map acts by pulling back functions and representations. +The coarsening limit is an actual algebraic direct limit of those groups. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty + +universe u + +variable {X Y Z : Type u} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] + +@[simp] theorem pullback_apply (f : CocompactMap X Y) (a : C₀(Y, ℂ)) (x : X) : + pullback f a x = a (f x) := rfl + +theorem pullback_comp (f : CocompactMap X Y) (g : CocompactMap Y Z) : + pullback (g.comp f) = (pullback f).comp (pullback g) := by + ext a x + rfl + +@[simp] theorem pullback_id : pullback (CocompactMap.id X) = NonUnitalStarAlgHom.id ℂ C₀(X, ℂ) := by + ext a x + rfl + +theorem pushforward_comp (f : CocompactMap X Y) (g : CocompactMap Y Z) : + pushforward (g.comp f) = (pushforward g).comp (pushforward f) := by + rw [pushforward, pullback_comp, precomp_comp] + rfl + +@[simp] theorem pushforward_id : pushforward (CocompactMap.id X) = AddMonoidHom.id _ := by + simp only [pushforward, pullback_id, precomp_id] + +attribute [instance] Coarsening.topology + +namespace Coarsening + +instance (C : Coarsening) : + DirectedSystem (fun r => LocallyFiniteK1 (C.space r)) (fun r s h => C.map r s h) where + map_self r x := by simp [map, C.inclusion_self] + map_map t s r hrs hst x := by + change (pushforward (C.inclusion s t hst)) ((pushforward (C.inclusion r s hrs)) x) = _ + rw [← AddMonoidHom.comp_apply, ← pushforward_comp, ← C.inclusion_comp] + rfl + +def of (C : Coarsening) (r : ℕ) : LocallyFiniteK1 (C.space r) →+ C.Homology := + AddCommGroup.DirectLimit.of (fun n => LocallyFiniteK1 (C.space n)) + (fun n m h => C.map n m h) r + +end Coarsening + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/LoopCircle.lean b/lean/OAI/Topology/CoarseAssembly/LoopCircle.lean new file mode 100644 index 0000000000000000000000000000000000000000..9902d39847516069427497be8b6ac097573db325 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/LoopCircle.lean @@ -0,0 +1,70 @@ +import OAI.Topology.CoarseAssembly.CocyclePathLifting +import Mathlib.Topology.Instances.AddCircle.Real + +namespace OAI + +/-! # Parametrizing a closed path by the circle + +The interval endpoints are identified using Mathlib's quotient-circle +construction. The resulting continuous map agrees with the path on the +entire closed interval, including its identified endpoint. +-/ + +noncomputable section + +namespace CoarseAssembly + +open unitInterval + +abbrev WindingCircle := AddCircle (1 : ℝ) + +variable {Y : Type*} [TopologicalSpace Y] {y : Y} + +theorem circle_parameter_surjective : Function.Surjective + (fun t : unitInterval => ((t : ℝ) : WindingCircle)) := by + intro z + have hz : z ∈ (Set.univ : Set WindingCircle) := Set.mem_univ _ + rw [← AddCircle.coe_image_Icc_eq (1 : ℝ) 0] at hz + obtain ⟨t, ht, rfl⟩ := hz + exact ⟨⟨t, by simpa using ht⟩, rfl⟩ + +def loopCircle (γ : Path y y) : C(WindingCircle, Y) where + toFun := AddCircle.liftIco 1 0 γ.extend + continuous_toFun := AddCircle.liftIco_zero_continuous (by simp) + γ.continuous_extend.continuousOn + +theorem loopCircle_apply_lt (γ : Path y y) (t : unitInterval) (ht : (t : ℝ) < 1) : + loopCircle γ (t : ℝ) = γ t := by + change AddCircle.liftIco 1 0 γ.extend (t : ℝ) = γ t + rw [AddCircle.liftIco_zero_coe_apply ⟨t.2.1, ht⟩, Path.extend_apply] + +theorem loopCircle_apply (γ : Path y y) (t : unitInterval) : + loopCircle γ (t : ℝ) = γ t := by + rcases lt_or_eq_of_le t.2.2 with ht | ht + · exact loopCircle_apply_lt γ t ht + · have ht' : t = 1 := Subtype.ext ht + subst t + change loopCircle γ ((1 : ℝ) : WindingCircle) = γ 1 + rw [AddCircle.coe_period] + have hzero := loopCircle_apply_lt γ 0 (by norm_num) + simpa using hzero + +theorem loopCircle_integerLift {f : Y → WindingCircle} (γ : Path y y) {n : ℤ} + (L : IntegerPathLift f γ n) (t : unitInterval) : + f (loopCircle γ (t : ℝ)) = (L.path t : WindingCircle) := by + rw [loopCircle_apply] + exact L.commutes t + +theorem loopCircle_postcompose {Z : Type*} [TopologicalSpace Z] + (f : C(Y, Z)) (γ : Path y y) : + loopCircle (γ.map f.continuous) = f.comp (loopCircle γ) := by + ext z + obtain ⟨t, rfl⟩ := circle_parameter_surjective z + simp only [ContinuousMap.comp_apply, loopCircle_apply] + rfl + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/MultiplicativeIndexPairing.lean b/lean/OAI/Topology/CoarseAssembly/MultiplicativeIndexPairing.lean new file mode 100644 index 0000000000000000000000000000000000000000..333856e3d7a5ce868cfb6106abf11ba3d0d68771 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/MultiplicativeIndexPairing.lean @@ -0,0 +1,79 @@ +import OAI.Topology.CoarseAssembly.EssentialToeplitzIndex +import OAI.Topology.CoarseAssembly.UnitaryHomotopyIndex + +namespace OAI + +/-! # Additivity of the scalar-unitary pairing under multiplication -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem rawCycleIndex_mul (c : OddCycle A) (u v : A) + (hul : star u * u = 1) (hur : u * star u = 1) + (hvl : star v * v = 1) (hvr : v * star v = 1) : + rawCycleIndex c (u * v) = rawCycleIndex c u + rawCycleIndex c v := by + have hc : Commute c.cutDown.operator (c.cutDown.representation 1) := + commute_of_complement _ _ (cutDown_selfAdjoint c) + (representation_unit_selfAdjoint c.cutDown) (cutDown_complement c) + have hcomm (a : A) : IsCompactOperator + (c.cutDown.operator * unitaryExtension c.cutDown a - + unitaryExtension c.cutDown a * c.cutDown.operator : End c.cutDown.space) := by + rw [unitaryExtension_commutator c.cutDown a hc] + exact c.cutDown.commutator_compact a + obtain ⟨hUl, hUr⟩ := unitaryExtension_unitary c.cutDown u hul hur + obtain ⟨hVl, hVr⟩ := unitaryExtension_unitary c.cutDown v hvl hvr + have hi := essentialToeplitz_index_mul c.cutDown.operator + (unitaryExtension c.cutDown u) (unitaryExtension c.cutDown v) + (cutDown_selfAdjoint c) (cutDown_square_compact c) hUl hUr hVl hVr (hcomm u) (hcomm v) + rw [unitaryExtension_mul] at hi + simp only [rawCycleIndex, rawCycleToeplitz_eq_cutDown, representedToeplitz] + exact hi + +open scoped ZeroAtInfty + +variable {X : Type} [TopologicalSpace X] [CompactSpace X] + +theorem compactIndexPairing_mul (f g : C(X, Circle)) : + compactIndexPairing (f * g) = compactIndexPairing f + compactIndexPairing g := by + apply hom_ext + intro c + simp only [AddMonoidHom.add_apply, compactIndexPairing_cycleClass] + have he : compactUnitary (f * g) = compactUnitary f * compactUnitary g := rfl + rw [he] + exact rawCycleIndex_mul _ _ _ (compactUnitary_star_mul f) (compactUnitary_mul_star f) + (compactUnitary_star_mul g) (compactUnitary_mul_star g) + +theorem compactIndexPairing_one : compactIndexPairing (1 : C(X, Circle)) = 0 := by + have h := compactIndexPairing_mul (1 : C(X, Circle)) 1 + rw [one_mul] at h + exact add_eq_left.mp h.symm + +theorem compactIndexPairing_pow (f : C(X, Circle)) (n : ℕ) : + compactIndexPairing (f ^ n) = n • compactIndexPairing f := by + induction n with + | zero => simp only [pow_zero, compactIndexPairing_one, zero_smul] + | succ n ih => rw [pow_succ, compactIndexPairing_mul, ih, succ_nsmul] + +theorem compactIndexPairing_inv (f : C(X, Circle)) : + compactIndexPairing f⁻¹ = -compactIndexPairing f := by + have h := compactIndexPairing_mul f f⁻¹ + rw [mul_inv_cancel, compactIndexPairing_one] at h + exact eq_neg_of_add_eq_zero_right h.symm + +theorem compactIndexPairing_zpow (f : C(X, Circle)) (n : ℤ) : + compactIndexPairing (f ^ n) = n • compactIndexPairing f := by + cases n with + | ofNat n => simpa using compactIndexPairing_pow f n + | negSucc n => + rw [zpow_negSucc, compactIndexPairing_inv, compactIndexPairing_pow] + simp only [Int.negSucc_eq, neg_smul] + rw [← Nat.cast_add_one, natCast_zsmul] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryClass.lean b/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryClass.lean new file mode 100644 index 0000000000000000000000000000000000000000..ea9d668b9f3688214b7b090a54380269d272c82a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryClass.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RoeIdealizer +import OAI.Topology.CoarseAssembly.CayleyBoundary +import OAI.Topology.CoarseAssembly.RelativeUnitary + +namespace OAI + +/-! # Boundary classes in the closed Roe multiplier algebra + +A controlled Rips operator is a Roe multiplier even when it is not +pseudolocal for the discrete vertex representation. The ideal-boundary +construction is therefore performed in this actual closed multiplier +algebra before constructing the coarse assembly map. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp +local instance : ContinuousStar (Operator X H) := ⟨operator_star_continuous⟩ + +theorem roeIdealizer_one : (1 : Operator X H) ∈ roeIdealizer (X := X) (H := H) := by + intro S + constructor + · simpa only [one_mul] using S.property + · simpa only [mul_one] using S.property + +theorem multiplierAlgebra_closed : + IsClosed (multiplierAlgebra (X := X) (H := H) : Set (Operator X H)) := roeIdealizer_closed + +@[simp] theorem mem_multiplierRoeIdeal (T : multiplierAlgebra (X := X) (H := H)) : + T ∈ multiplierRoeIdeal (X := X) (H := H) ↔ T.val ∈ algebra (X := X) (H := H) := + TwoSidedIdeal.mem_mk' _ _ _ _ _ _ T + +theorem multiplierBoundaryUnitary_sub_one_mem + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hdefect : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + (multiplierBoundaryUnitary F hF : Operator X H) - 1 ∈ algebra (X := X) (H := H) := by + have hF' : F ^ 2 - 1 ∈ multiplierRoeIdeal (X := X) (H := H) := by + rw [mem_multiplierRoeIdeal] + simpa using hdefect + have h := Analytic.rationalBoundaryUnitary_sub_one_mem + (multiplierRoeIdeal (X := X) (H := H)) F hF hF' + rw [mem_multiplierRoeIdeal] at h + exact h + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..4edb670dcf7fdea0bc1ea04b8845f5539f05dd29 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryHomotopy.lean @@ -0,0 +1,54 @@ +import OAI.Topology.CoarseAssembly.MultiplierBoundaryClass +import OAI.Topology.CoarseAssembly.CayleyContinuity +import OAI.Topology.CoarseAssembly.RelativeHomotopy + +namespace OAI + +/-! # Norm homotopy invariance of the Roe multiplier boundary class -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance multiplierHomotopyScalarTower : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance multiplierHomotopyScalarComm : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp +local instance multiplierHomotopyContinuousStar : ContinuousStar (Operator X H) := ⟨operator_star_continuous⟩ + +theorem multiplierBoundaryClass_homotopy + (F : Interval → multiplierAlgebra (X := X) (H := H)) + (hF : ∀ t, IsSelfAdjoint (F t)) + (hdefect : ∀ t, (F t).val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hcont : Continuous F) : + multiplierBoundaryClass (F start) (hF start) (hdefect start) = + multiplierBoundaryClass (F finish) (hF finish) (hdefect finish) := by + have hU : Continuous (fun t => (multiplierBoundaryUnitary (F t) (hF t) : Operator X H)) := by + convert! (show Continuous + (fun T : multiplierAlgebra (X := X) (H := H) => T.val) from + continuous_subtype_val).comp (continuous_rationalBoundaryUnitary F hF hcont) + exact OperatorKTheory.relativeClass_homotopy (hS := algebra_isClosed) + (algebra (X := X) (H := H)) (fun t => multiplierBoundaryUnitary (F t) (hF t)) + (fun t => multiplierBoundaryUnitary_sub_one_mem (F t) (hF t) (hdefect t)) hU + +theorem multiplierBoundaryClass_eq_zero + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hdefect : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) (hsq : F * F = 1) : + multiplierBoundaryClass F hF hdefect = 0 := by + apply OperatorKTheory.relativeClass_eq_zero (hS := algebra_isClosed) + have hu := Analytic.rationalBoundaryUnitary_eq_one F hF hsq + apply Subtype.ext + change ((Analytic.rationalBoundaryUnitary F hF : multiplierAlgebra (X := X) (H := H)) : Operator X H) = 1 + rw [hu] + rfl + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryNearby.lean b/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryNearby.lean new file mode 100644 index 0000000000000000000000000000000000000000..c2b0153ce9bd4d2951fa868fe3306f3ba63c3758 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/MultiplierBoundaryNearby.lean @@ -0,0 +1,33 @@ +import OAI.Topology.CoarseAssembly.RelativeNearby +import OAI.Topology.CoarseAssembly.CayleyNormControl +import OAI.Topology.CoarseAssembly.MultiplierBoundaryClass + +namespace OAI + +/-! # Norm-local constancy of the actual Roe boundary class -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem multiplierBoundaryClass_eq_of_nearby + (F G : multiplierAlgebra (X := X) (H := H)) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hGd : G.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hnear : ‖G - F‖ < (1 / 4 : ℝ)) : + multiplierBoundaryClass F hF hFd = multiplierBoundaryClass G hG hGd := by + apply OperatorKTheory.relativeClass_eq_of_nearby (hS := algebra_isClosed) + have hb := Analytic.rationalBoundaryUnitary_sub_norm_le G F hG hF + change ‖(Analytic.rationalBoundaryUnitary G hG : multiplierAlgebra (X := X) (H := H)) - + Analytic.rationalBoundaryUnitary F hF‖ < 1 + exact hb.trans_lt (by linarith) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/MultiplierIsometryInvariance.lean b/lean/OAI/Topology/CoarseAssembly/MultiplierIsometryInvariance.lean new file mode 100644 index 0000000000000000000000000000000000000000..f6af4d3924df66de56f027c63817ad824ef0ba40 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/MultiplierIsometryInvariance.lean @@ -0,0 +1,115 @@ +import OAI.Topology.CoarseAssembly.RelativeIsometry +import OAI.Topology.CoarseAssembly.MultiplierUnitaryHomotopy +import OAI.Topology.CoarseAssembly.CayleyNonunitalNaturality + +namespace OAI + +/-! # The Roe boundary is invariant under multiplier isometries -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +theorem nonunitalIdentityExtension_square_defect (φ : A →⋆ₙₐ[ℂ] B) (F : A) : + nonunitalIdentityExtension φ F ^ 2 - 1 = φ (F ^ 2 - 1) := by + calc + _ = φ ((F - 1) + (F - 1) + (F - 1) * (F - 1)) := by + rw [map_add, map_add, map_mul] + dsimp only [nonunitalIdentityExtension] + noncomm_ring + _ = _ := congrArg φ (by noncomm_ring) + +end CoarseAssembly.Analytic + +namespace CoarseAssembly.DiscreteRoe + +open Analytic OperatorKTheory + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def isometricMultiplier (V : multiplierAlgebra (X := X) (H := H)) + (hV : star V * V = 1) (F : multiplierAlgebra (X := X) (H := H)) : + multiplierAlgebra (X := X) (H := H) := + nonunitalIdentityExtension (isometryCornerHom V hV) F + +theorem isometricMultiplier_selfAdjoint (V : multiplierAlgebra (X := X) (H := H)) + (hV : star V * V = 1) (F : multiplierAlgebra (X := X) (H := H)) + (hF : IsSelfAdjoint F) : IsSelfAdjoint (isometricMultiplier V hV F) := + nonunitalIdentityExtension_selfAdjoint _ F hF + +theorem isometricMultiplier_defect_mem (V : multiplierAlgebra (X := X) (H := H)) + (hV : star V * V = 1) (F : multiplierAlgebra (X := X) (H := H)) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + (isometricMultiplier V hV F).val ^ 2 - 1 ∈ algebra (X := X) (H := H) := by + have he := congrArg (fun T : multiplierAlgebra (X := X) (H := H) => T.val) + (nonunitalIdentityExtension_square_defect (isometryCornerHom V hV) F) + change (isometricMultiplier V hV F).val ^ 2 - 1 = + V.val * (F.val ^ 2 - 1) * (star V).val at he + rw [he] + exact ((star V).property ⟨_, (V.property ⟨_, hFd⟩).1⟩).2 + +theorem rationalBoundaryUnitary_isometricMultiplier + (V : multiplierAlgebra (X := X) (H := H)) (hV : star V * V = 1) + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) : + isometryExtensionUnitary V hV (rationalBoundaryUnitary F hF) = + rationalBoundaryUnitary (isometricMultiplier V hV F) + (isometricMultiplier_selfAdjoint V hV F hF) := by + apply Subtype.ext + rw [isometryExtensionUnitary_val] + exact nonunital_rationalBoundaryUnitary (isometryCornerHom V hV) F hF + +/-- Stabilizing a multiplier by an isometry does not change its actual Roe K₁ boundary. -/ +theorem multiplierBoundaryClass_isometry + (V : multiplierAlgebra (X := X) (H := H)) (hV : star V * V = 1) + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + multiplierBoundaryClass F hF hFd = + multiplierBoundaryClass (isometricMultiplier V hV F) + (isometricMultiplier_selfAdjoint V hV F hF) + (isometricMultiplier_defect_mem V hV F hFd) := by + let φ := (multiplierAlgebra (X := X) (H := H)).subtype + have hφ : ∀ a b, b ∈ algebra (X := X) (H := H) → + φ a * b ∈ algebra (X := X) (H := H) ∧ + b * φ a ∈ algebra (X := X) (H := H) := fun a b hb => a.property ⟨b, hb⟩ + have h := relativeClass_isometry (hS := algebra_isClosed) + (algebra (X := X) (H := H)) φ continuous_subtype_val hφ V hV + (rationalBoundaryUnitary F hF) (multiplierBoundaryUnitary_sub_one_mem F hF hFd) + simp only [rationalBoundaryUnitary_isometricMultiplier V hV F hF] at h + exact h + +/-- Arbitrary multiplier unitaries preserve the boundary; no path is assumed. -/ +theorem multiplierBoundaryClass_unitaryConjugation + (u : unitary (multiplierAlgebra (X := X) (H := H))) + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + multiplierBoundaryClass F hF hFd = + multiplierBoundaryClass (conjugatedMultiplier u F) + (conjugatedMultiplier_selfAdjoint u F hF) + (conjugatedMultiplier_defect_mem u F hFd) := by + have hV : star (u : multiplierAlgebra (X := X) (H := H)) * u = 1 := + Unitary.coe_star_mul_self u + have hu : (u : multiplierAlgebra (X := X) (H := H)) * + star (u : multiplierAlgebra (X := X) (H := H)) = 1 := by + have h := Unitary.coe_mul_star_self u + change (u : multiplierAlgebra (X := X) (H := H)) * + star (u : multiplierAlgebra (X := X) (H := H)) = 1 at h + exact h + have he : isometricMultiplier (u : multiplierAlgebra (X := X) (H := H)) hV F = + conjugatedMultiplier u F := by + change 1 + (u : multiplierAlgebra (X := X) (H := H)) * (F - 1) * + star (u : multiplierAlgebra (X := X) (H := H)) = _ + unfold conjugatedMultiplier + rw [mul_sub, sub_mul, mul_one, hu] + abel + have h := multiplierBoundaryClass_isometry + (u : multiplierAlgebra (X := X) (H := H)) hV F hF hFd + simpa only [he] using h + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/MultiplierOrthogonalEmbeddings.lean b/lean/OAI/Topology/CoarseAssembly/MultiplierOrthogonalEmbeddings.lean new file mode 100644 index 0000000000000000000000000000000000000000..f2c6ecbd5c02ede8828f7ecf136d42978868e97b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/MultiplierOrthogonalEmbeddings.lean @@ -0,0 +1,97 @@ +import OAI.Topology.CoarseAssembly.OrthogonalExtensionBoundary +import OAI.Topology.CoarseAssembly.EmbeddingBoundaryComparison + +namespace OAI + +/-! # Addition of actual Roe boundaries supported in orthogonal images -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E F H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem operatorConjugation_orthogonal (V : E →ₗᵢ[ℂ] H) (W : F →ₗᵢ[ℂ] H) + (hVW : V.toContinuousLinearMap.adjoint.comp W.toContinuousLinearMap = 0) + (A : E →L[ℂ] E) (B : F →L[ℂ] F) : + operatorConjugation V A * operatorConjugation W B = 0 := by + ext x + change V (A (V.toContinuousLinearMap.adjoint (W (B (W.toContinuousLinearMap.adjoint x))))) = 0 + have hz : V.toContinuousLinearMap.adjoint (W (B (W.toContinuousLinearMap.adjoint x))) = 0 := + DFunLike.congr_fun hVW _ + rw [hz, map_zero, map_zero] + +namespace DiscreteRoe + +open Analytic OperatorKTheory + +variable {X : Type*} [DecidableEq X] [PseudoMetricSpace X] + +theorem multiplierBoundaryUnitary_eq_raw + (T : multiplierAlgebra (X := X) (H := H)) (hT : IsSelfAdjoint T) : + (multiplierBoundaryUnitary T hT : Operator X H) = + (rationalBoundaryUnitary T.val (hT.map (multiplierAlgebra (X := X) (H := H)).subtype) : + Operator X H) := + map_rationalBoundaryUnitary (multiplierAlgebra (X := X) (H := H)).subtype T hT + +/-- The complementary target summand carries the identity; the two supported +boundary classes therefore add in the actual Roe K₁ group. -/ +theorem multiplierBoundaryClass_orthogonalEmbeddings + (V : E →ₗᵢ[ℂ] Module X H) (W : F →ₗᵢ[ℂ] Module X H) + (hVW : V.toContinuousLinearMap.adjoint.comp W.toContinuousLinearMap = 0) + (A : E →L[ℂ] E) (B : F →L[ℂ] F) (hA : IsSelfAdjoint A) (hB : IsSelfAdjoint B) + (T L R : multiplierAlgebra (X := X) (H := H)) + (hT : IsSelfAdjoint T) (hL : IsSelfAdjoint L) (hR : IsSelfAdjoint R) + (hTd : T.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hLd : L.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hRd : R.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hLV : L.val = isometricExtension V A) (hRW : R.val = isometricExtension W B) + (hTVW : T.val = 1 + operatorConjugation V (A - 1) + operatorConjugation W (B - 1)) : + multiplierBoundaryClass T hT hTd = + multiplierBoundaryClass L hL hLd + multiplierBoundaryClass R hR hRd := by + let φ := operatorConjugationHom V + let ψ := operatorConjugationHom W + have horth : ∀ a b, φ a * ψ b = 0 := operatorConjugation_orthogonal V W hVW + let σ := nonunitalOrthogonalSumHom φ ψ horth + have ht : T.val = nonunitalIdentityExtension σ (A, B) := by + change T.val = 1 + (operatorConjugation V (A - 1) + operatorConjugation W (B - 1)) + simpa only [add_assoc] using hTVW + have huT := multiplierBoundaryUnitary_eq_raw T hT + simp only [ht] at huT + have hprod := rationalBoundaryUnitary_orthogonalExtension φ ψ horth A B hA hB + have huL : (multiplierBoundaryUnitary L hL : Operator X H) = + (nonunitalUnitaryExtension φ (rationalBoundaryUnitary A hA) : Operator X H) := by + have h := multiplierBoundaryUnitary_embedding V A hA L hL hLV + change (multiplierBoundaryUnitary L hL : Operator X H) = + 1 + operatorConjugation V ((rationalBoundaryUnitary A hA : E →L[ℂ] E) - 1) + simpa only [add_comm] using (sub_eq_iff_eq_add.mp h) + have huR : (multiplierBoundaryUnitary R hR : Operator X H) = + (nonunitalUnitaryExtension ψ (rationalBoundaryUnitary B hB) : Operator X H) := by + have h := multiplierBoundaryUnitary_embedding W B hB R hR hRW + change (multiplierBoundaryUnitary R hR : Operator X H) = + 1 + operatorConjugation W ((rationalBoundaryUnitary B hB : F →L[ℂ] F) - 1) + simpa only [add_comm] using (sub_eq_iff_eq_add.mp h) + have hu : multiplierBoundaryUnitary T hT = multiplierBoundaryUnitary L hL * + multiplierBoundaryUnitary R hR := by + apply Subtype.ext + rw [huT] + have hp := congrArg (fun u : unitary (Operator X H) => u.val) hprod + change _ = (multiplierBoundaryUnitary L hL : Operator X H) * + (multiplierBoundaryUnitary R hR : Operator X H) + rw [huL, huR] + exact hp + have h := relativeClass_mul (hS := algebra_isClosed) (algebra (X := X) (H := H)) + (multiplierBoundaryUnitary L hL) (multiplierBoundaryUnitary R hR) + (multiplierBoundaryUnitary_sub_one_mem L hL hLd) + (multiplierBoundaryUnitary_sub_one_mem R hR hRd) + simpa only [multiplierBoundaryClass, ← hu] using h + +end DiscreteRoe +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/MultiplierUnitaryHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/MultiplierUnitaryHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..019b74230e74d897420121f04081037c0d1af7c6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/MultiplierUnitaryHomotopy.lean @@ -0,0 +1,112 @@ +import OAI.Topology.CoarseAssembly.MultiplierBoundaryHomotopy +import OAI.Topology.CoarseAssembly.InvolutionUnitaryPath + +namespace OAI + +/-! # Unitary homotopies preserve the Roe multiplier boundary + +This is the conjugation step in descent through changes of cycle +coordinates. The path is an actual norm-continuous path of unitaries in +the Roe multiplier algebra. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def conjugatedMultiplier (u : unitary (multiplierAlgebra (X := X) (H := H))) + (F : multiplierAlgebra (X := X) (H := H)) : multiplierAlgebra (X := X) (H := H) := + (u : multiplierAlgebra (X := X) (H := H)) * F * star (u : multiplierAlgebra (X := X) (H := H)) + +theorem conjugatedMultiplier_selfAdjoint + (u : unitary (multiplierAlgebra (X := X) (H := H))) + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (conjugatedMultiplier u F) := by + change star ((u : multiplierAlgebra (X := X) (H := H)) * F * star (u : multiplierAlgebra (X := X) (H := H))) = _ + rw [star_mul, star_mul, star_star, hF.star_eq] + rfl + +theorem conjugatedMultiplier_square_defect + (u : unitary (multiplierAlgebra (X := X) (H := H))) + (F : multiplierAlgebra (X := X) (H := H)) : + (conjugatedMultiplier u F) ^ 2 - 1 = + (u : multiplierAlgebra (X := X) (H := H)) * (F ^ 2 - 1) * star (u : multiplierAlgebra (X := X) (H := H)) := by + let U : multiplierAlgebra (X := X) (H := H) := u + have hleft : star U * U = 1 := Unitary.coe_star_mul_self u + have hright : U * star U = 1 := Unitary.coe_mul_star_self u + change (U * F * star U) ^ 2 - 1 = U * (F ^ 2 - 1) * star U + calc + _ = U * F * (star U * U) * F * star U - 1 := by noncomm_ring + _ = U * (F * F) * star U - 1 := by rw [hleft]; simp only [mul_one, mul_assoc] + _ = _ := by rw [pow_two, mul_sub, sub_mul, mul_one, hright] + +theorem conjugatedMultiplier_defect_mem + (u : unitary (multiplierAlgebra (X := X) (H := H))) + (F : multiplierAlgebra (X := X) (H := H)) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + (conjugatedMultiplier u F).val ^ 2 - 1 ∈ algebra (X := X) (H := H) := by + let U : multiplierAlgebra (X := X) (H := H) := u + have he := congrArg (fun T : multiplierAlgebra (X := X) (H := H) => T.val) + (conjugatedMultiplier_square_defect u F) + change (conjugatedMultiplier u F).val ^ 2 - 1 = U.val * (F.val ^ 2 - 1) * + (star U).val at he + rw [he] + have hleft : U.val * (F.val ^ 2 - 1) ∈ algebra (X := X) (H := H) := + (U.property ⟨_, hFd⟩).1 + exact ((star U).property ⟨_, hleft⟩).2 + +theorem multiplierBoundaryClass_unitaryHomotopy + (U : Interval → unitary (multiplierAlgebra (X := X) (H := H))) + (hU : Continuous U) (F : multiplierAlgebra (X := X) (H := H)) + (hF : IsSelfAdjoint F) (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + multiplierBoundaryClass (conjugatedMultiplier (U start) F) + (conjugatedMultiplier_selfAdjoint (U start) F hF) + (conjugatedMultiplier_defect_mem (U start) F hFd) = + multiplierBoundaryClass (conjugatedMultiplier (U finish) F) + (conjugatedMultiplier_selfAdjoint (U finish) F hF) + (conjugatedMultiplier_defect_mem (U finish) F hFd) := by + apply multiplierBoundaryClass_homotopy + (fun t => conjugatedMultiplier (U t) F) + (fun t => conjugatedMultiplier_selfAdjoint (U t) F hF) + (fun t => conjugatedMultiplier_defect_mem (U t) F hFd) + exact ((continuous_subtype_val.comp hU).mul continuous_const).mul + ((continuous_subtype_val.comp hU).star) + +theorem multiplierBoundaryClass_involutionConjugation + (u : unitary (multiplierAlgebra (X := X) (H := H))) + (hu : IsSelfAdjoint (u : multiplierAlgebra (X := X) (H := H))) + (F : multiplierAlgebra (X := X) (H := H)) + (hF : IsSelfAdjoint F) (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) : + multiplierBoundaryClass F hF hFd = + multiplierBoundaryClass (conjugatedMultiplier u F) + (conjugatedMultiplier_selfAdjoint u F hF) + (conjugatedMultiplier_defect_mem u F hFd) := by + have huu : (u : multiplierAlgebra (X := X) (H := H)) * u = 1 := by + calc + _ = star (u : multiplierAlgebra (X := X) (H := H)) * u := by rw [hu.star_eq] + _ = 1 := Unitary.coe_star_mul_self u + let W : Interval → unitary (multiplierAlgebra (X := X) (H := H)) := + involutionUnitaryPath (u : multiplierAlgebra (X := X) (H := H)) hu huu + have hw0 : W start = 1 := + involutionUnitaryPath_start (u : multiplierAlgebra (X := X) (H := H)) hu huu + have h0 : conjugatedMultiplier (W start) F = F := by + rw [hw0] + simp [conjugatedMultiplier] + have h1 : W finish = u := by + apply Subtype.ext + exact involutionUnitaryPath_finish (u : multiplierAlgebra (X := X) (H := H)) hu huu + have hwc : Continuous W := + involutionUnitaryPath_continuous (u : multiplierAlgebra (X := X) (H := H)) hu huu + have h := multiplierBoundaryClass_unitaryHomotopy W hwc F hF hFd + simpa only [h0, h1] using h + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/NegativeCircleCycle.lean b/lean/OAI/Topology/CoarseAssembly/NegativeCircleCycle.lean new file mode 100644 index 0000000000000000000000000000000000000000..fe670d60874e10cf67062c41ae16e869b140dc2f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/NegativeCircleCycle.lean @@ -0,0 +1,71 @@ +import OAI.Topology.CoarseAssembly.EssentialCommutant +import OAI.Topology.CoarseAssembly.ShiftIndex +import OAI.Topology.CoarseAssembly.RawCycleIndex + +namespace OAI + +/-! # The explicit circle Fredholm cycle and its coordinate index -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +def negativeCircleOperator : End circleSequenceSpace := negativeProjection + negativeProjection - 1 + +theorem negativeCircleOperator_selfAdjoint : IsSelfAdjoint negativeCircleOperator := by + change star (negativeProjection + negativeProjection - 1) = _ + rw [star_sub, star_add, negativeProjection_selfAdjoint.star_eq, star_one] + rfl + +theorem negativeCircleOperator_sq : negativeCircleOperator * negativeCircleOperator = 1 := by + unfold negativeCircleOperator + simp only [sub_mul, mul_sub, add_mul, mul_add, one_mul, mul_one, negativeProjection_sq] + abel + +theorem negativeCircleOperator_commutator (f : C(Circle, ℂ)) : IsCompactOperator + (negativeCircleOperator * circleRepresentation f - circleRepresentation f * negativeCircleOperator) := by + have he : negativeCircleOperator * circleRepresentation f - circleRepresentation f * negativeCircleOperator = + (negativeProjection * circleRepresentation f - circleRepresentation f * negativeProjection) + + (negativeProjection * circleRepresentation f - circleRepresentation f * negativeProjection) := by + unfold negativeCircleOperator + noncomm_ring + rw [he] + exact (circleRepresentation_commutator f).add (circleRepresentation_commutator f) + +def negativeCircleCycle : OddCycle C(Circle, ℂ) where + space := circleSequenceSpace + representation := circleRepresentation.toNonUnitalStarAlgHom + operator := negativeCircleOperator + commutator_compact := negativeCircleOperator_commutator + square_compact f := by + change IsCompactOperator ((negativeCircleOperator * negativeCircleOperator - 1) * circleRepresentation f : End circleSequenceSpace) + rw [negativeCircleOperator_sq, sub_self, zero_mul] + exact isCompactOperator_zero + adjoint_compact f := by + change IsCompactOperator ((star negativeCircleOperator - negativeCircleOperator) * circleRepresentation f : End circleSequenceSpace) + rw [negativeCircleOperator_selfAdjoint.star_eq, sub_self, zero_mul] + exact isCompactOperator_zero + +theorem negativeCircleCycle_coordinate_index : rawCycleIndex negativeCircleCycle circleCoordinate = 1 := by + have hcut : symmetricCutDown (circleRepresentation 1) negativeCircleOperator = negativeCircleOperator := by + rw [map_one] + unfold symmetricCutDown + rw [one_mul, mul_one, negativeCircleOperator_selfAdjoint.star_eq] + module + have hpos : positiveProjection negativeCircleOperator = negativeProjection := by + unfold positiveProjection negativeCircleOperator + module + have hunit : circleRepresentation circleCoordinate + (1 - circleRepresentation 1) = bilateralShift := by + rw [circleRepresentation_coordinate, map_one, sub_self, add_zero] + unfold rawCycleIndex + change (toeplitzCompression (positiveProjection + (symmetricCutDown (circleRepresentation 1) negativeCircleOperator)) + (circleRepresentation circleCoordinate + (1 - circleRepresentation 1))).toLinearMap.index = 1 + rw [hcut, hpos, hunit] + exact shiftToeplitz_index + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/NegativeProjection.lean b/lean/OAI/Topology/CoarseAssembly/NegativeProjection.lean new file mode 100644 index 0000000000000000000000000000000000000000..8c09124fae7cff2719cea69c16a33c5ce88c331b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/NegativeProjection.lean @@ -0,0 +1,82 @@ +import OAI.Topology.CoarseAssembly.BilateralShift +import OAI.Topology.CoarseAssembly.ToeplitzCompression + +namespace OAI + +/-! # The negative-frequency projection for the circle cycle -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +private def negativeCoordinate (n : ℤ) : ℂ →L[ℂ] ℂ := if n < 0 then 1 else 0 + +private theorem negativeCoordinate_norm (n : ℤ) : ‖negativeCoordinate n‖ ≤ 1 := by + unfold negativeCoordinate + split_ifs + · exact ContinuousLinearMap.norm_id_le + · simp + +def negativeProjection : End circleSequenceSpace := + CoarseAssembly.blockOperator negativeCoordinate 1 zero_le_one negativeCoordinate_norm + +@[simp] theorem negativeProjection_apply (x : CircleSequence) (n : ℤ) : + negativeProjection x n = if n < 0 then x n else 0 := by + change (negativeCoordinate n) (x n) = _ + unfold negativeCoordinate + split_ifs <;> rfl + +theorem negativeProjection_sq : negativeProjection * negativeProjection = negativeProjection := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext n + change negativeProjection (negativeProjection x) n = negativeProjection x n + rw [negativeProjection_apply (negativeProjection x) n, negativeProjection_apply x n] + split_ifs <;> rfl + +theorem negativeProjection_selfAdjoint : IsSelfAdjoint negativeProjection := by + apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr + intro x y + rw [lp.inner_eq_tsum, lp.inner_eq_tsum] + apply tsum_congr + intro n + change inner ℂ (negativeProjection x n) (y n) = inner ℂ (x n) (negativeProjection y n) + rw [negativeProjection_apply x n, negativeProjection_apply y n] + split_ifs <;> simp + +/-- The projection/shift commutator has exactly one nonzero row. -/ +theorem negativeProjection_commutator (x : CircleSequence) : + (negativeProjection * bilateralShift - bilateralShift * negativeProjection) x = + -lp.single 2 0 (x (-1)) := by + apply lp.ext + funext n + change negativeProjection (bilateralShift x) n - bilateralShift (negativeProjection x) n = _ + rw [negativeProjection_apply (bilateralShift x) n, bilateralShift_apply (negativeProjection x) n, + negativeProjection_apply x (n - 1)] + simp only [lp.coeFn_neg, Pi.neg_apply, lp.single_apply, Pi.single_apply] + simp only [bilateralShift_apply x n] + by_cases hzero : n = 0 + · subst n + norm_num + · have hsign : n - 1 < 0 ↔ n < 0 := by omega + simp [hsign, hzero] + + +theorem negativeProjection_commutator_compact : IsCompactOperator + (negativeProjection * bilateralShift - bilateralShift * negativeProjection) := by + let ev : CircleSequence →L[ℂ] ℂ := lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 (-1) + let ins : ℂ →L[ℂ] CircleSequence := lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 0 + have he : negativeProjection * bilateralShift - bilateralShift * negativeProjection = + -(ins ∘L ev) := by + apply ContinuousLinearMap.ext + intro x + exact negativeProjection_commutator x + rw [he] + exact ((isCompactOperator_of_locallyCompactSpace_dom ev).clm_comp ins).neg + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/NonUnitalK1.lean b/lean/OAI/Topology/CoarseAssembly/NonUnitalK1.lean new file mode 100644 index 0000000000000000000000000000000000000000..da0c5db7f2acc45a307f339746ecd2be4a7f84a2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/NonUnitalK1.lean @@ -0,0 +1,101 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.TopologicalK1 +import Mathlib.Analysis.CStarAlgebra.Spectrum + +namespace OAI + +/-! +# K₁ of nonunital C*-algebras + +The group is the kernel of the scalar projection from the unitization. +Nonunital star homomorphisms induce actual maps of these kernels, preserving +composition. This is the target functor for the reduced Roe assembly map. +-/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +open scoped CStarAlgebra + +universe u v w + +variable (A : Type u) [NonUnitalCStarAlgebra A] + +variable {A} {B : Type v} [NonUnitalCStarAlgebra B] +variable {C : Type w} [NonUnitalCStarAlgebra C] + +@[simp] theorem scalarMap_matrixClass {n : ℕ} + (g : TopologicalK1.InvertibleMatrix (Unitization ℂ A) n) : + scalarMap A (TopologicalK1.matrixClass (Unitization ℂ A) g) = + TopologicalK1.matrixClass ℂ + (TopologicalK1.mapGL (Unitization.fstHom ℂ A).toRingHom n g) := + TopologicalK1.map_matrixClass _ _ _ + +@[simp] theorem unitizationMap_matrixClass (φ : A →⋆ₙₐ[ℂ] B) {n : ℕ} + (g : TopologicalK1.InvertibleMatrix (Unitization ℂ A) n) : + unitizationMap φ (TopologicalK1.matrixClass (Unitization ℂ A) g) = + TopologicalK1.matrixClass (Unitization ℂ B) + (TopologicalK1.mapGL (Unitization.starMap φ).toRingHom n g) := + TopologicalK1.map_matrixClass _ _ _ + +theorem scalarMap_natural (φ : A →⋆ₙₐ[ℂ] B) : + (scalarMap B).comp (unitizationMap φ) = scalarMap A := by + apply TopologicalK1.hom_ext + intro n g + simp only [AddMonoidHom.comp_apply, unitizationMap_matrixClass, scalarMap_matrixClass] + congr 1 + apply Units.ext + apply Matrix.ext + intro i j + change (Unitization.starMap φ ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j)).fst = + ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j).fst + simp [Unitization.starMap_apply, Unitization.algebraMap_eq_inl] + +@[simp] theorem map_coe (φ : A →⋆ₙₐ[ℂ] B) (x : K1 A) : + (map φ x : TopologicalK1.Group (Unitization ℂ B)) = unitizationMap φ x := rfl + +theorem unitizationMap_comp (φ : A →⋆ₙₐ[ℂ] B) (ψ : B →⋆ₙₐ[ℂ] C) : + unitizationMap (ψ.comp φ) = (unitizationMap ψ).comp (unitizationMap φ) := by + apply TopologicalK1.hom_ext + intro n g + simp only [AddMonoidHom.comp_apply, unitizationMap_matrixClass] + congr 1 + apply Units.ext + apply Matrix.ext + intro i j + change Unitization.starMap (ψ.comp φ) ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j) = + Unitization.starMap ψ (Unitization.starMap φ ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j)) + exact DFunLike.congr_fun (Unitization.starMap_comp (φ := φ) (ψ := ψ)) _ + +theorem map_comp (φ : A →⋆ₙₐ[ℂ] B) (ψ : B →⋆ₙₐ[ℂ] C) : + map (ψ.comp φ) = (map ψ).comp (map φ) := by + apply AddMonoidHom.ext + intro x + apply Subtype.ext + exact DFunLike.congr_fun (unitizationMap_comp φ ψ) (x : TopologicalK1.Group (Unitization ℂ A)) + +@[simp] theorem unitizationMap_id : + unitizationMap (NonUnitalStarAlgHom.id ℂ A) = + AddMonoidHom.id (TopologicalK1.Group (Unitization ℂ A)) := by + apply TopologicalK1.hom_ext + intro n g + simp only [unitizationMap_matrixClass, AddMonoidHom.id_apply] + congr 1 + apply Units.ext + apply Matrix.ext + intro i j + change Unitization.starMap (NonUnitalStarAlgHom.id ℂ A) ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j) = _ + simp + +@[simp] theorem map_id : map (NonUnitalStarAlgHom.id ℂ A) = AddMonoidHom.id (K1 A) := by + apply AddMonoidHom.ext + intro x + apply Subtype.ext + exact DFunLike.congr_fun (unitizationMap_id (A := A)) (x : TopologicalK1.Group (Unitization ℂ A)) + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/NonunitalUnitaryExtension.lean b/lean/OAI/Topology/CoarseAssembly/NonunitalUnitaryExtension.lean new file mode 100644 index 0000000000000000000000000000000000000000..66e276066557e47ca754e92e5fa70156004782d6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/NonunitalUnitaryExtension.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.CayleyNonunitalNaturality + +namespace OAI + +/-! # Identity extension of an arbitrary unitary under a nonunital map -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + +def nonunitalUnitaryExtension (φ : A →⋆ₙₐ[ℂ] B) (u : unitary A) : unitary B := by + have hl : star (u : A) * (u : A) = 1 := Unitary.coe_star_mul_self u + have hr : (u : A) * star (u : A) = 1 := by + have h := Unitary.coe_mul_star_self u + change (u : A) * star (u : A) = 1 at h + exact h + have hl' : ((u : A) - 1) + star ((u : A) - 1) + + star ((u : A) - 1) * ((u : A) - 1) = 0 := by + rw [star_sub, star_one] + noncomm_ring [hl] + have hr' : star ((u : A) - 1) + ((u : A) - 1) + + ((u : A) - 1) * star ((u : A) - 1) = 0 := by + rw [star_sub, star_one] + noncomm_ring [hr] + refine ⟨1 + φ ((u : A) - 1), ?_, ?_⟩ + · change star (1 + φ ((u : A) - 1)) * (1 + φ ((u : A) - 1)) = 1 + calc + _ = 1 + φ (((u : A) - 1) + star ((u : A) - 1) + + star ((u : A) - 1) * ((u : A) - 1)) := by + rw [map_add, map_add, map_mul, map_star, star_add, star_one] + noncomm_ring + _ = 1 := by rw [hl', map_zero, add_zero] + · change (1 + φ ((u : A) - 1)) * star (1 + φ ((u : A) - 1)) = 1 + calc + _ = 1 + φ (star ((u : A) - 1) + ((u : A) - 1) + + ((u : A) - 1) * star ((u : A) - 1)) := by + rw [map_add, map_add, map_mul, map_star, star_add, star_one] + noncomm_ring + _ = 1 := by rw [hr', map_zero, add_zero] + +@[simp] theorem nonunitalUnitaryExtension_val (φ : A →⋆ₙₐ[ℂ] B) (u : unitary A) : + (nonunitalUnitaryExtension φ u : B) = 1 + φ ((u : A) - 1) := rfl + +theorem nonunitalUnitaryExtension_boundary (φ : A →⋆ₙₐ[ℂ] B) + (F : A) (hF : IsSelfAdjoint F) : + nonunitalUnitaryExtension φ (rationalBoundaryUnitary F hF) = + rationalBoundaryUnitary (nonunitalIdentityExtension φ F) + (nonunitalIdentityExtension_selfAdjoint φ F hF) := by + apply Subtype.ext + exact nonunital_rationalBoundaryUnitary φ F hF + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/NormalizedRipsFamily.lean b/lean/OAI/Topology/CoarseAssembly/NormalizedRipsFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..7cf133778aa871bcf0de809961dc1b02ba52fbf9 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/NormalizedRipsFamily.lean @@ -0,0 +1,60 @@ +import OAI.Topology.CoarseAssembly.UnitalRepresentative +import OAI.Topology.CoarseAssembly.AmpleRipsFamily + +namespace OAI + +/-! # Whole-union representatives from arbitrary finite-Rips cycles + +Each root gives an evaluation character. The proved unital normalization +removes the unitality and uniform operator-bound premises from the raw +family construction. Descent through all analytic cycle relations remains +a separate obligation. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] + +def rootCharacter (r : ℝ) (hr : 0 ≤ r) (o : X) : C(Point X r, ℂ) →⋆ₐ[ℂ] ℂ where + toFun f := f (vertex o hr) + map_zero' := rfl + map_one' := rfl + map_add' _ _ := rfl + map_mul' _ _ := rfl + commutes' _ := rfl + map_star' _ := rfl + +def normalizedRipsCycle (r : ℝ) (hr : 0 ≤ r) (o : X) (c : OddCycle C(Point X r, ℂ)) : + OddCycle C(Point X r, ℂ) := + (exists_unital_involutive_representative c (rootCharacter r hr o)).choose + +theorem normalizedRipsCycle_properties (r : ℝ) (hr : 0 ≤ r) (o : X) + (c : OddCycle C(Point X r, ℂ)) : + let d := normalizedRipsCycle r hr o c + cycleClass _ d = cycleClass _ c ∧ d.representation 1 = 1 ∧ + IsSelfAdjoint d.operator ∧ d.operator * d.operator = 1 ∧ ‖d.operator‖ ≤ 1 := + (exists_unital_involutive_representative c (rootCharacter r hr o)).choose_spec + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] + +/-- An actual whole-union Roe class for every family of compact-source +cycles, with all normalization premises discharged. -/ +def normalizedRipsFamilyBoundary (o : ∀ i, V i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OddCycle C(Point (V i) r, ℂ)) : + letI := separatedMetric o + OperatorKTheory.K1 (algebra (X := Sigma V) (H := lp (fun _ : ℕ => ℂ) 2)) := + ampleRipsFamilyBoundary o r hr (fun i => normalizedRipsCycle r hr (o i) (c i)) + (fun i => (normalizedRipsCycle_properties r hr (o i) (c i)).2.1) + (fun i => (normalizedRipsCycle_properties r hr (o i) (c i)).2.2.1) + 1 (by norm_num) (fun i => (normalizedRipsCycle_properties r hr (o i) (c i)).2.2.2.2) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/OperatorNormalization.lean b/lean/OAI/Topology/CoarseAssembly/OperatorNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..25b2936f84244ee562d4e6dfc7cb4842221592a9 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/OperatorNormalization.lean @@ -0,0 +1,50 @@ +import OAI.Topology.CoarseAssembly.InvolutiveNormalization + +namespace OAI + +/-! # A self-adjoint Fredholm operator is a compact perturbation of an involution -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem exists_compact_involution (F : End H) (hF : IsSelfAdjoint F) + (hc : IsCompactOperator (F * F - 1 : End H)) : + ∃ N : End H, IsSelfAdjoint N ∧ N * N = 1 ∧ + IsCompactOperator (N - F : End H) ∧ IsCompactOperator (star (N - F) : End H) := by + let G : End H := F + kernelProjection F + have hgs : IsSelfAdjoint G := kernel_corrected_selfAdjoint F hF + have hgi : IsUnit G := kernel_corrected_isUnit F hF hc + have hgc : IsCompactOperator (G * G - 1 : End H) := kernel_corrected_compact_square F hF hc + let N := involutiveNormalization G + have hNs : IsSelfAdjoint N := involutiveNormalization_selfAdjoint G + have hNsq : N * N = 1 := involutiveNormalization_sq G hgs hgi + have hcor := (involutiveCorrection_compact G hgs hgi hgc).1 + have hNF : IsCompactOperator (N - F : End H) := by + have he : N - F = kernelProjection F + G * cfc inverseSqrtCorrection (G * G - 1) := by + dsimp only [N] + rw [involutiveNormalization_eq G hgs hgi] + dsimp only [G] + abel + rw [he] + exact (kernelProjection_compact F hc).add hcor + refine ⟨N, hNs, hNsq, hNF, ?_⟩ + rw [star_sub, hNs.star_eq, hF.star_eq] + exact hNF + +theorem compact_commutator_of_compact_change (F N U : End H) + (hFN : IsCompactOperator (N - F : End H)) + (hFU : IsCompactOperator (F * U - U * F : End H)) : + IsCompactOperator (N * U - U * N : End H) := by + have he : N * U - U * N = (F * U - U * F) + (N - F) * U - U * (N - F) := by + noncomm_ring + rw [he] + exact (hFU.add (compact_mul_right hFN U)).sub (compact_mul_left hFN U) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/OrthogonalBlock.lean b/lean/OAI/Topology/CoarseAssembly/OrthogonalBlock.lean new file mode 100644 index 0000000000000000000000000000000000000000..3a0464e311b8a789605cfa6f7745db1e7477a74b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/OrthogonalBlock.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.OrthogonalCoordinates + +namespace OAI + +/-! # The operator algebra of an orthogonal direct sum -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] {c d e : OddCycle A} + +def OddCycle.IsDirectSum.block (h : c.IsDirectSum d e) (T : End c.space) (S : End d.space) : + End e.space := operatorConjugation h.left T + operatorConjugation h.right S + +theorem OddCycle.IsDirectSum.cross_left (h : c.IsDirectSum d e) (T : End c.space) (S : End d.space) : + operatorConjugation h.left T * operatorConjugation h.right S = 0 := by + apply ContinuousLinearMap.ext + intro x + change h.left (T (h.left.toContinuousLinearMap.adjoint + (h.right (S (h.right.toContinuousLinearMap.adjoint x))))) = 0 + have hz := DFunLike.congr_fun h.orthogonal (S (h.right.toContinuousLinearMap.adjoint x)) + change h.left.toContinuousLinearMap.adjoint (h.right (S (h.right.toContinuousLinearMap.adjoint x))) = 0 at hz + rw [hz, map_zero, map_zero] + +theorem OddCycle.IsDirectSum.cross_right (h : c.IsDirectSum d e) (T : End c.space) (S : End d.space) : + operatorConjugation h.right S * operatorConjugation h.left T = 0 := by + apply ContinuousLinearMap.ext + intro x + change h.right (S (h.right.toContinuousLinearMap.adjoint + (h.left (T (h.left.toContinuousLinearMap.adjoint x))))) = 0 + have hz := DFunLike.congr_fun h.orthogonal_reverse (T (h.left.toContinuousLinearMap.adjoint x)) + change h.right.toContinuousLinearMap.adjoint (h.left (T (h.left.toContinuousLinearMap.adjoint x))) = 0 at hz + rw [hz, map_zero, map_zero] + +theorem OddCycle.IsDirectSum.block_mul (h : c.IsDirectSum d e) + (T T' : End c.space) (S S' : End d.space) : + h.block T S * h.block T' S' = h.block (T * T') (S * S') := by + unfold block + rw [add_mul, mul_add, mul_add, h.cross_left T S', h.cross_right T' S, + add_zero, zero_add, ← operatorConjugation_mul, ← operatorConjugation_mul] + +theorem OddCycle.IsDirectSum.block_add (h : c.IsDirectSum d e) + (T T' : End c.space) (S S' : End d.space) : + h.block (T + T') (S + S') = h.block T S + h.block T' S' := by + change operatorConjugationHom h.left (T + T') + operatorConjugationHom h.right (S + S') = _ + rw [map_add, map_add] + change (operatorConjugationHom h.left T + operatorConjugationHom h.left T') + + (operatorConjugationHom h.right S + operatorConjugationHom h.right S') = + (operatorConjugationHom h.left T + operatorConjugationHom h.right S) + + (operatorConjugationHom h.left T' + operatorConjugationHom h.right S') + abel + +theorem OddCycle.IsDirectSum.block_smul (h : c.IsDirectSum d e) (z : ℂ) + (T : End c.space) (S : End d.space) : h.block (z • T) (z • S) = z • h.block T S := by + change operatorConjugationHom h.left (z • T) + operatorConjugationHom h.right (z • S) = _ + change operatorConjugationHom h.left (z • T) + operatorConjugationHom h.right (z • S) = + z • (operatorConjugationHom h.left T + operatorConjugationHom h.right S) + rw [map_smul, map_smul, smul_add] + +theorem OddCycle.IsDirectSum.block_one (h : c.IsDirectSum d e) : h.block 1 1 = 1 := by + apply ContinuousLinearMap.ext + intro x + exact DFunLike.congr_fun h.exhaustive x + +def OddCycle.IsDirectSum.blockHom (h : c.IsDirectSum d e) : + (End c.space × End d.space) →⋆ₐ[ℂ] End e.space where + toFun p := h.block p.1 p.2 + map_zero' := by + change operatorConjugationHom h.left 0 + operatorConjugationHom h.right 0 = 0 + rw [map_zero, map_zero, add_zero] + map_one' := h.block_one + map_add' p q := h.block_add p.1 q.1 p.2 q.2 + map_mul' p q := (h.block_mul p.1 q.1 p.2 q.2).symm + map_star' p := by + simp only [block, star_add, ← operatorConjugation_star, Prod.fst_star, Prod.snd_star] + commutes' z := by + simp only [Algebra.algebraMap_eq_smul_one] + change h.block (z • 1) (z • 1) = z • 1 + rw [h.block_smul, h.block_one] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/OrthogonalCoordinates.lean b/lean/OAI/Topology/CoarseAssembly/OrthogonalCoordinates.lean new file mode 100644 index 0000000000000000000000000000000000000000..b5e25b5cbfe42d4e3a2e0d9fcc7b63d9400b9446 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/OrthogonalCoordinates.lean @@ -0,0 +1,56 @@ +import OAI.Topology.CoarseAssembly.ProductIndex + +namespace OAI + +/-! # Coordinates for an orthogonal direct sum of Fredholm cycles -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [NonUnitalCStarAlgebra A] {c d e : OddCycle A} + +def OddCycle.IsDirectSum.coordinates (h : c.IsDirectSum d e) : e.space →L[ℂ] c.space × d.space := + h.left.toContinuousLinearMap.adjoint.prod h.right.toContinuousLinearMap.adjoint + +def OddCycle.IsDirectSum.inclusion (h : c.IsDirectSum d e) : c.space × d.space →L[ℂ] e.space := + h.left.toContinuousLinearMap.coprod h.right.toContinuousLinearMap + +theorem OddCycle.IsDirectSum.orthogonal_reverse (h : c.IsDirectSum d e) : + h.right.toContinuousLinearMap.adjoint ∘L h.left.toContinuousLinearMap = 0 := by + have hz := congrArg ContinuousLinearMap.adjoint h.orthogonal + simpa only [ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.adjoint_adjoint, + map_zero] using hz + +theorem OddCycle.IsDirectSum.coordinates_inclusion (h : c.IsDirectSum d e) : + h.coordinates ∘L h.inclusion = ContinuousLinearMap.id ℂ (c.space × d.space) := by + apply ContinuousLinearMap.ext + intro x + apply Prod.ext + · change h.left.toContinuousLinearMap.adjoint (h.left x.1 + h.right x.2) = x.1 + rw [map_add, adjoint_apply_isometry] + have hz : h.left.toContinuousLinearMap.adjoint (h.right x.2) = 0 := + DFunLike.congr_fun h.orthogonal x.2 + rw [hz, add_zero] + · change h.right.toContinuousLinearMap.adjoint (h.left x.1 + h.right x.2) = x.2 + rw [map_add, adjoint_apply_isometry] + have hz : h.right.toContinuousLinearMap.adjoint (h.left x.1) = 0 := + DFunLike.congr_fun h.orthogonal_reverse x.1 + rw [hz, zero_add] + +theorem OddCycle.IsDirectSum.inclusion_coordinates (h : c.IsDirectSum d e) : + h.inclusion ∘L h.coordinates = ContinuousLinearMap.id ℂ e.space := by + apply ContinuousLinearMap.ext + intro x + exact DFunLike.congr_fun h.exhaustive x + +def OddCycle.IsDirectSum.coordinateEquiv (h : c.IsDirectSum d e) : + e.space ≃L[ℂ] c.space × d.space := + ContinuousLinearEquiv.equivOfInverse' h.coordinates h.inclusion + h.coordinates_inclusion h.inclusion_coordinates + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/OrthogonalExtensionBoundary.lean b/lean/OAI/Topology/CoarseAssembly/OrthogonalExtensionBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..4f40bf725f9476782f34ef5f624a024d33865438 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/OrthogonalExtensionBoundary.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.OrthogonalSumBoundary + +namespace OAI + +/-! # Additivity for orthogonal corners with an unused complementary summand -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B R : Type*} [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra R] + +def nonunitalOrthogonalSumHom (φ : A →⋆ₙₐ[ℂ] R) (ψ : B →⋆ₙₐ[ℂ] R) + (horth : ∀ a b, φ a * ψ b = 0) : A × B →⋆ₙₐ[ℂ] R where + toFun p := φ p.1 + ψ p.2 + map_zero' := by simp + map_add' p q := by simp only [Prod.fst_add, Prod.snd_add, map_add]; abel + map_mul' p q := by + simp only [Prod.fst_mul, Prod.snd_mul, map_mul, add_mul, mul_add, + horth, orthogonal_maps_reverse φ ψ horth, add_zero, zero_add] + map_smul' z p := by + change φ (z • p.1) + ψ (z • p.2) = z • (φ p.1 + ψ p.2) + rw [map_smul, map_smul, smul_add] + map_star' p := by simp only [Prod.fst_star, Prod.snd_star, map_star, star_add] + +theorem nonunitalUnitaryExtension_orthogonal (φ : A →⋆ₙₐ[ℂ] R) (ψ : B →⋆ₙₐ[ℂ] R) + (horth : ∀ a b, φ a * ψ b = 0) (u : unitary A) (v : unitary B) : + ((nonunitalUnitaryExtension φ u * nonunitalUnitaryExtension ψ v : unitary R) : R) = + 1 + φ ((u : A) - 1) + ψ ((v : B) - 1) := by + change (1 + φ ((u : A) - 1)) * (1 + ψ ((v : B) - 1)) = _ + rw [add_mul, mul_add, mul_add, one_mul, mul_one, one_mul, horth, add_zero] + noncomm_ring + +theorem rationalBoundaryUnitary_orthogonalExtension + (φ : A →⋆ₙₐ[ℂ] R) (ψ : B →⋆ₙₐ[ℂ] R) (horth : ∀ a b, φ a * ψ b = 0) + (F : A) (G : B) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + rationalBoundaryUnitary (nonunitalIdentityExtension (nonunitalOrthogonalSumHom φ ψ horth) (F, G)) + (nonunitalIdentityExtension_selfAdjoint _ _ (Prod.ext hF.star_eq hG.star_eq)) = + nonunitalUnitaryExtension φ (rationalBoundaryUnitary F hF) * + nonunitalUnitaryExtension ψ (rationalBoundaryUnitary G hG) := by + have hp : IsSelfAdjoint (F, G) := Prod.ext hF.star_eq hG.star_eq + have h := nonunital_rationalBoundaryUnitary (nonunitalOrthogonalSumHom φ ψ horth) (F, G) hp + have hfst := map_rationalBoundaryUnitary (StarAlgHom.fst ℂ A B) (F, G) hp + have hsnd := map_rationalBoundaryUnitary (StarAlgHom.snd ℂ A B) (F, G) hp + change (rationalBoundaryUnitary (F, G) hp : A × B).1 = (rationalBoundaryUnitary F hF : A) at hfst + change (rationalBoundaryUnitary (F, G) hp : A × B).2 = (rationalBoundaryUnitary G hG : B) at hsnd + apply Subtype.ext + rw [nonunitalUnitaryExtension_orthogonal φ ψ horth] + change 1 + (φ ((rationalBoundaryUnitary (F, G) hp : A × B).1 - 1) + + ψ ((rationalBoundaryUnitary (F, G) hp : A × B).2 - 1)) = _ at h + rw [hfst, hsnd] at h + simpa only [add_assoc] using h.symm + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/OrthogonalSumBoundary.lean b/lean/OAI/Topology/CoarseAssembly/OrthogonalSumBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..c398e46c554ca9624836394c56261be9fbd5d676 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/OrthogonalSumBoundary.lean @@ -0,0 +1,105 @@ +import OAI.Topology.CoarseAssembly.NonunitalUnitaryExtension +import OAI.Topology.CoarseAssembly.RelativeMultiplication + +namespace OAI + +/-! # The boundary of an orthogonal sum is the product of its two boundaries -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B R : Type*} [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra R] + +variable (φ : A →⋆ₙₐ[ℂ] R) (ψ : B →⋆ₙₐ[ℂ] R) + (horth : ∀ a b, φ a * ψ b = 0) (hone : φ 1 + ψ 1 = 1) + +include horth in +theorem orthogonal_maps_reverse (a : A) (b : B) : ψ b * φ a = 0 := by + have h := congrArg star (horth (star a) (star b)) + simpa only [star_mul, ← map_star, star_star, star_zero] using h + +def orthogonalSumHom : A × B →⋆ₐ[ℂ] R where + toFun p := φ p.1 + ψ p.2 + map_zero' := by simp + map_one' := hone + map_add' p q := by simp only [Prod.fst_add, Prod.snd_add, map_add]; abel + map_mul' p q := by + simp only [Prod.fst_mul, Prod.snd_mul, map_mul, add_mul, mul_add, + horth, orthogonal_maps_reverse φ ψ horth, add_zero, zero_add] + commutes' z := by + change φ (algebraMap ℂ A z) + ψ (algebraMap ℂ B z) = algebraMap ℂ R z + simp only [Algebra.algebraMap_eq_smul_one, map_smul, ← smul_add, hone] + map_star' p := by simp only [Prod.fst_star, Prod.snd_star, map_star, star_add] + +include horth hone in +theorem nonunitalUnitaryExtension_product (u : unitary A) (v : unitary B) : + ((nonunitalUnitaryExtension φ u * nonunitalUnitaryExtension ψ v : unitary R) : R) = + φ (u : A) + ψ (v : B) := by + change (1 + φ ((u : A) - 1)) * (1 + ψ ((v : B) - 1)) = _ + rw [add_mul, mul_add, mul_add, one_mul, mul_one, one_mul, horth, add_zero] + rw [map_sub, map_sub, ← hone] + noncomm_ring + +theorem orthogonalSum_selfAdjoint (F : A) (G : B) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + IsSelfAdjoint (φ F + ψ G) := (hF.map φ).add (hG.map ψ) + +include horth hone in +theorem rationalBoundaryUnitary_orthogonalSum (F : A) (G : B) + (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) : + rationalBoundaryUnitary (φ F + ψ G) (orthogonalSum_selfAdjoint φ ψ F G hF hG) = + nonunitalUnitaryExtension φ (rationalBoundaryUnitary F hF) * + nonunitalUnitaryExtension ψ (rationalBoundaryUnitary G hG) := by + have hp : IsSelfAdjoint (F, G) := Prod.ext hF.star_eq hG.star_eq + have h := map_rationalBoundaryUnitary (orthogonalSumHom φ ψ horth hone) (F, G) hp + have hfst := map_rationalBoundaryUnitary (StarAlgHom.fst ℂ A B) (F, G) hp + have hsnd := map_rationalBoundaryUnitary (StarAlgHom.snd ℂ A B) (F, G) hp + apply Subtype.ext + rw [nonunitalUnitaryExtension_product φ ψ horth hone] + change φ (rationalBoundaryUnitary (F, G) hp : A × B).1 + + ψ (rationalBoundaryUnitary (F, G) hp : A × B).2 = _ at h + change (rationalBoundaryUnitary (F, G) hp : A × B).1 = _ at hfst + change (rationalBoundaryUnitary (F, G) hp : A × B).2 = _ at hsnd + rw [hfst, hsnd] at h + exact h.symm + +end CoarseAssembly.Analytic + +namespace CoarseAssembly.OperatorKTheory + +open Analytic + +variable {A B R : Type*} [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra R] + +/-- The exact orthogonal-sum formula gives addition in the existing K₁ group. -/ +theorem relativeClass_orthogonalSum (S : NonUnitalStarSubalgebra ℂ R) + [hS : IsClosed (S : Set R)] + (φ : A →⋆ₙₐ[ℂ] R) (ψ : B →⋆ₙₐ[ℂ] R) + (horth : ∀ a b, φ a * ψ b = 0) (hone : φ 1 + ψ 1 = 1) + (F : A) (G : B) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (hsum : (rationalBoundaryUnitary (φ F + ψ G) + (orthogonalSum_selfAdjoint φ ψ F G hF hG) : R) - 1 ∈ S) + (hleft : (rationalBoundaryUnitary (nonunitalIdentityExtension φ F) + (nonunitalIdentityExtension_selfAdjoint φ F hF) : R) - 1 ∈ S) + (hright : (rationalBoundaryUnitary (nonunitalIdentityExtension ψ G) + (nonunitalIdentityExtension_selfAdjoint ψ G hG) : R) - 1 ∈ S) : + relativeClass S (rationalBoundaryUnitary (φ F + ψ G) + (orthogonalSum_selfAdjoint φ ψ F G hF hG)) hsum = + relativeClass S (rationalBoundaryUnitary (nonunitalIdentityExtension φ F) + (nonunitalIdentityExtension_selfAdjoint φ F hF)) hleft + + relativeClass S (rationalBoundaryUnitary (nonunitalIdentityExtension ψ G) + (nonunitalIdentityExtension_selfAdjoint ψ G hG)) hright := by + have hu := rationalBoundaryUnitary_orthogonalSum φ ψ horth hone F G hF hG + rw [nonunitalUnitaryExtension_boundary, nonunitalUnitaryExtension_boundary] at hu + have h := relativeClass_mul S + (rationalBoundaryUnitary (nonunitalIdentityExtension φ F) + (nonunitalIdentityExtension_selfAdjoint φ F hF)) + (rationalBoundaryUnitary (nonunitalIdentityExtension ψ G) + (nonunitalIdentityExtension_selfAdjoint ψ G hG)) hleft hright + simpa only [← hu] using h + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartialIsometryDilation.lean b/lean/OAI/Topology/CoarseAssembly/PartialIsometryDilation.lean new file mode 100644 index 0000000000000000000000000000000000000000..610f1b4f2c026a3d55c1c05006f65cbd37f35b56 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartialIsometryDilation.lean @@ -0,0 +1,111 @@ +import OAI.Topology.CoarseAssembly.IsometryDilation + +namespace OAI + +/-! # Swapping two isometric images by a partial-isometry dilation -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type*} [CStarAlgebra A] + +def partialIsometryDilation (T : A) : Matrix (Fin 2) (Fin 2) A := + !![1 - star T * T, star T; T, 1 - T * star T] + +theorem partialIsometryDilation_selfAdjoint (T : A) : + IsSelfAdjoint (partialIsometryDilation T) := by + ext i j + fin_cases i <;> fin_cases j <;> simp [partialIsometryDilation, Matrix.star_apply] + +theorem partialIsometry_star_relation (T : A) (hT : T * star T * T = T) : + star T * T * star T = star T := by + have h := congrArg star hT + simpa only [star_mul, star_star, mul_assoc] using h + +theorem partialIsometry_complement_relations (T : A) (hT : T * star T * T = T) : + (1 - star T * T) * (1 - star T * T) = 1 - star T * T ∧ + (1 - T * star T) * (1 - T * star T) = 1 - T * star T ∧ + (1 - star T * T) * star T = 0 ∧ star T * (1 - T * star T) = 0 ∧ + T * (1 - star T * T) = 0 ∧ (1 - T * star T) * T = 0 := by + have hs := partialIsometry_star_relation T hT + have hP : (star T * T) * (star T * T) = star T * T := by + calc + _ = (star T * T * star T) * T := by noncomm_ring + _ = _ := by rw [hs] + have hQ : (T * star T) * (T * star T) = T * star T := by + calc + _ = (T * star T * T) * star T := by noncomm_ring + _ = _ := by rw [hT] + refine ⟨?_, ?_, ?_, ?_, ?_, ?_⟩ + · noncomm_ring [hP] + · noncomm_ring [hQ] + · rw [sub_mul, one_mul, hs, sub_self] + · rw [mul_sub, mul_one, ← mul_assoc, hs, sub_self] + · rw [mul_sub, mul_one, ← mul_assoc, hT, sub_self] + · rw [sub_mul, one_mul, hT, sub_self] + +theorem partialIsometryDilation_sq (T : A) (hT : T * star T * T = T) : + partialIsometryDilation T * partialIsometryDilation T = 1 := by + obtain ⟨hE, hF, hEs, hsF, hTE, hFT⟩ := partialIsometry_complement_relations T hT + ext i j + fin_cases i <;> fin_cases j + all_goals simp only [Matrix.mul_apply, Fin.sum_univ_two] + · change (1 - star T * T) * (1 - star T * T) + star T * T = 1 + rw [hE] + abel + · change (1 - star T * T) * star T + star T * (1 - T * star T) = 0 + rw [hEs, hsF, add_zero] + · change T * (1 - star T * T) + (1 - T * star T) * T = 0 + rw [hTE, hFT, add_zero] + · change T * star T + (1 - T * star T) * (1 - T * star T) = 1 + rw [hF] + abel + +/-- A continuous path from one to the symmetry exchanging the two images. -/ +def partialIsometryDilationPath (T : A) (hT : T * star T * T = T) : + Interval → unitary (Matrix (Fin 2) (Fin 2) A) := + involutionUnitaryPath (partialIsometryDilation T) (partialIsometryDilation_selfAdjoint T) + (partialIsometryDilation_sq T hT) + +theorem partialIsometryDilationPath_continuous (T : A) (hT : T * star T * T = T) : + Continuous (partialIsometryDilationPath T hT) := involutionUnitaryPath_continuous _ _ _ + +@[simp] theorem partialIsometryDilationPath_start (T : A) (hT : T * star T * T = T) : + partialIsometryDilationPath T hT start = 1 := involutionUnitaryPath_start _ _ _ + +@[simp] theorem partialIsometryDilationPath_finish (T : A) (hT : T * star T * T = T) : + (partialIsometryDilationPath T hT finish).val = partialIsometryDilation T := + involutionUnitaryPath_finish _ _ _ + +theorem partialIsometryDilation_conjugation (T f : A) (hT : T * star T * T = T) + (hleft : (star T * T) * f = f) (hright : f * (star T * T) = f) : + partialIsometryDilation T * !![1 + f, 0; 0, 1] * partialIsometryDilation T = + !![1, 0; 0, 1 + T * f * star T] := by + obtain ⟨hE, hF, hEs, hsF, hTE, hFT⟩ := partialIsometry_complement_relations T hT + have hEf : (1 - star T * T) * f = 0 := by rw [sub_mul, one_mul, hleft, sub_self] + have hfE : f * (1 - star T * T) = 0 := by rw [mul_sub, mul_one, hright, sub_self] + ext i j + fin_cases i <;> fin_cases j + all_goals simp only [Matrix.mul_apply, Fin.sum_univ_two] + · change ((1 - star T * T) * (1 + f) + star T * 0) * (1 - star T * T) + + ((1 - star T * T) * 0 + star T * 1) * T = 1 + simp only [mul_add, mul_one, mul_zero, add_zero, zero_add, hEf] + rw [hE] + abel + · change ((1 - star T * T) * (1 + f) + star T * 0) * star T + + ((1 - star T * T) * 0 + star T * 1) * (1 - T * star T) = 0 + simp only [mul_add, mul_one, mul_zero, add_zero, zero_add, hEf, hEs, hsF] + · change (T * (1 + f) + (1 - T * star T) * 0) * (1 - star T * T) + + (T * 0 + (1 - T * star T) * 1) * T = 0 + simp only [mul_add, mul_one, mul_zero, add_zero, zero_add, add_mul, mul_assoc, hfE, hTE, hFT] + · change (T * (1 + f) + (1 - T * star T) * 0) * star T + + (T * 0 + (1 - T * star T) * 1) * (1 - T * star T) = 1 + T * f * star T + simp only [mul_add, mul_one, mul_zero, add_zero, zero_add, add_mul, hF] + noncomm_ring + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartitionCompactPerturbation.lean b/lean/OAI/Topology/CoarseAssembly/PartitionCompactPerturbation.lean new file mode 100644 index 0000000000000000000000000000000000000000..d54e54251e6d4c717a1f135f78baebf1d7f6c4ac --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartitionCompactPerturbation.lean @@ -0,0 +1,96 @@ +import OAI.Topology.CoarseAssembly.RipsLocalization +import OAI.Topology.CoarseAssembly.AmpleRipsFamily + +namespace OAI + +/-! # Compact perturbations through the actual localization operators -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem isometricExtension_sub (V : E →ₗᵢ[ℂ] H) (F G : E →L[ℂ] E) : + isometricExtension V F - isometricExtension V G = operatorConjugation V (F - G) := by + unfold isometricExtension + change (1 + operatorConjugationHom V (F - 1)) - + (1 + operatorConjugationHom V (G - 1)) = operatorConjugationHom V (F - G) + have he : (F - 1) - (G - 1) = F - G := by abel + calc + _ = operatorConjugationHom V (F - 1) - operatorConjugationHom V (G - 1) := by abel + _ = operatorConjugationHom V ((F - 1) - (G - 1)) := (map_sub _ _ _).symm + _ = _ := by rw [he] + +theorem isometricExtension_sub_compact (V : E →ₗᵢ[ℂ] H) (F G : E →L[ℂ] E) + (hFG : IsCompactOperator (F - G)) : + IsCompactOperator (isometricExtension V F - isometricExtension V G) := by + rw [isometricExtension_sub] + exact (hFG.comp_clm V.toContinuousLinearMap.adjoint).clm_comp V.toContinuousLinearMap + +namespace DiscreteRoe + +variable {X : Type*} [Fintype X] [DecidableEq X] + +theorem partitionCompression_sub (a : X → H →L[ℂ] H) (F G : H →L[ℂ] H) : + partitionCompression a F - partitionCompression a G = partitionCompression a (F - G) := by + rw [partitionCompression_eq_sum, partitionCompression_eq_sum, + partitionCompression_eq_sum, ← Finset.sum_sub_distrib] + apply Finset.sum_congr rfl + intro x _ + rw [ContinuousLinearMap.sub_comp, ContinuousLinearMap.comp_sub] + +theorem partitionCompression_sub_compact (a : X → H →L[ℂ] H) (F G : H →L[ℂ] H) + (hFG : IsCompactOperator (F - G)) : + IsCompactOperator (partitionCompression a F - partitionCompression a G) := by + rw [partitionCompression_sub, partitionCompression_eq_sum] + exact (compactOperator (RingHom.id ℂ) H H).sum_mem + (fun x _ => (hFG.comp_clm (a x)).clm_comp (a x).adjoint) + +theorem localizedSpatialOperator_sub_compact (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F G : H →L[ℂ] H) + (hFG : IsCompactOperator (F - G)) : + IsCompactOperator (localizedSpatialOperator a hpart F - localizedSpatialOperator a hpart G) := + isometricExtension_sub_compact _ _ _ (partitionCompression_sub_compact a F G hFG) + +end DiscreteRoe + +namespace Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + +theorem ripsSpatialOperator_compactPerturb (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (K : End c.space) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End c.space)) : + IsCompactOperator + ((show Operator X c.space from ripsSpatialOperator r (c.compactPerturb K hK hKs) hπ) - + ripsSpatialOperator r c hπ) := by + change IsCompactOperator + (localizedSpatialOperator (representedSqrt r c) (representedSqrt_partition r c hπ) + (c.operator + K) - + localizedSpatialOperator (representedSqrt r c) (representedSqrt_partition r c hπ) c.operator) + apply localizedSpatialOperator_sub_compact + simpa only [add_sub_cancel_left] using hK + +theorem ampleRipsOperator_compactPerturb (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (K : End c.space) + (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : End c.space)) : + IsCompactOperator + (ampleRipsOperator r (c.compactPerturb K hK hKs) hπ - ampleRipsOperator r c hπ) := by + change IsCompactOperator + (isometricExtension (coefficientIsometry (ampleIsometry c.space)) + (ripsSpatialOperator r (c.compactPerturb K hK hKs) hπ) - + isometricExtension (coefficientIsometry (ampleIsometry c.space)) (ripsSpatialOperator r c hπ)) + exact isometricExtension_sub_compact _ _ _ (ripsSpatialOperator_compactPerturb r c hπ K hK hKs) + +end Rips + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartitionCompression.lean b/lean/OAI/Topology/CoarseAssembly/PartitionCompression.lean new file mode 100644 index 0000000000000000000000000000000000000000..a2ed33662b733cdf8e597758515e91d046fff015 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartitionCompression.lean @@ -0,0 +1,60 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.PartitionIsometry +import OAI.Topology.CoarseAssembly.BlockOperators + +namespace OAI + +/-! # The contraction estimate for finite partition localization -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [Fintype X] [DecidableEq X] [CompleteSpace H] in +@[simp] theorem constantBlock_apply (F : H →L[ℂ] H) (v : Module X H) (x : X) : + constantBlock F v x = F (v x) := rfl + +omit [Fintype X] [DecidableEq X] [CompleteSpace H] in +theorem constantBlock_norm_le (F : H →L[ℂ] H) : ‖constantBlock (X := X) F‖ ≤ ‖F‖ := + blockOperator_norm_le _ _ _ _ + +theorem partitionMap_adjoint_apply (a : X → H →L[ℂ] H) (v : Module X H) : + (partitionMap a).adjoint v = ∑ x, (a x).adjoint (v x) := by + rw [partitionMap_adjoint] + simp only [sum_apply, ContinuousLinearMap.comp_apply, coordinate_apply] + +theorem partitionCompression_eq_sum (a : X → H →L[ℂ] H) (F : H →L[ℂ] H) : + partitionCompression a F = ∑ x, (a x).adjoint.comp (F.comp (a x)) := by + ext v + simp only [partitionCompression, ContinuousLinearMap.comp_apply, partitionMap_adjoint_apply, + constantBlock_apply, sum_apply] + apply Finset.sum_congr rfl + intro x _ + have hx := DFunLike.congr_fun (coordinate_partitionMap a x) v + exact congrArg (fun h => (a x).adjoint (F h)) hx + +theorem partitionCompression_norm_le (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) : + ‖partitionCompression a F‖ ≤ ‖F‖ := by + have hv : ‖partitionMap a‖ ≤ 1 := by + exact (partitionIsometry a hpart).norm_toContinuousLinearMap_le + have hvs : ‖(partitionMap a).adjoint‖ ≤ 1 := by + simpa only [ContinuousLinearMap.adjoint.norm_map] using hv + calc + ‖partitionCompression a F‖ ≤ ‖(partitionMap a).adjoint‖ * + (‖constantBlock (X := X) F‖ * ‖partitionMap a‖) := + (ContinuousLinearMap.opNorm_comp_le _ _).trans + (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _)) + _ ≤ 1 * (‖F‖ * 1) := by + gcongr + exact constantBlock_norm_le F + _ = ‖F‖ := by ring + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartitionInclusion.lean b/lean/OAI/Topology/CoarseAssembly/PartitionInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..cf45e9891fe1f804a02497c5cb6196a38bcc00f3 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartitionInclusion.lean @@ -0,0 +1,102 @@ +import OAI.Topology.CoarseAssembly.RoeInclusion +import OAI.Topology.CoarseAssembly.SpatialLocalization + +namespace OAI + +/-! # Finite partition localization under vertex inclusions -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E F G : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] + [NormedAddCommGroup G] [InnerProductSpace ℂ G] [CompleteSpace G] + +theorem isometricExtension_comp (V : F →ₗᵢ[ℂ] G) (W : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) : + isometricExtension V (isometricExtension W T) = isometricExtension (V.comp W) T := by + change 1 + operatorConjugation V (1 + operatorConjugation W (T - 1) - 1) = + 1 + operatorConjugation (V.comp W) (T - 1) + rw [add_sub_cancel_left, operatorConjugation_comp] + +namespace DiscreteRoe + +variable {X Y H : Type*} [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [Fintype Y] [DecidableEq Y] [CompleteSpace H] in +@[simp] theorem partitionMap_apply (a : X → H →L[ℂ] H) (v : H) (x : X) : + partitionMap a v x = a x v := DFunLike.congr_fun (coordinate_partitionMap a x) v + +omit [CompleteSpace H] in +theorem partitionMap_inclusion (e : X ↪ Y) (a : X → H →L[ℂ] H) (b : Y → H →L[ℂ] H) + (he : ∀ x, b (e x) = a x) (hz : ∀ y, y ∉ Set.range e → b y = 0) : + (inclusionIsometry (H := H) e).toContinuousLinearMap.comp (partitionMap a) = + partitionMap b := by + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext y + change inclusionVector e (partitionMap a v) y = partitionMap b v y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + rw [inclusionVector_apply, partitionMap_apply, partitionMap_apply, he] + · rw [inclusionVector_zero e _ _ hy, partitionMap_apply, hz y hy, zero_apply] + +theorem partitionIsometry_inclusion (e : X ↪ Y) (a : X → H →L[ℂ] H) (b : Y → H →L[ℂ] H) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) + (hb : ∑ y, (b y).adjoint.comp (b y) = 1) + (he : ∀ x, b (e x) = a x) (hz : ∀ y, y ∉ Set.range e → b y = 0) : + (inclusionIsometry e).comp (partitionIsometry a ha) = partitionIsometry b hb := by + apply DFunLike.ext + intro v + exact DFunLike.congr_fun (partitionMap_inclusion e a b he hz) v + +omit [Fintype Y] [DecidableEq X] [CompleteSpace H] in +theorem constantBlock_inclusion (e : X ↪ Y) (T : H →L[ℂ] H) : + (constantBlock (X := Y) T).comp (inclusionIsometry e).toContinuousLinearMap = + (inclusionIsometry e).toContinuousLinearMap.comp (constantBlock (X := X) T) := by + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext y + change T (inclusionVector e v y) = inclusionVector e (constantBlock T v) y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + rw [inclusionVector_apply, inclusionVector_apply, constantBlock_apply] + · rw [inclusionVector_zero e _ _ hy, inclusionVector_zero e _ _ hy, map_zero] + +theorem partitionCompression_inclusion (e : X ↪ Y) + (a : X → H →L[ℂ] H) (b : Y → H →L[ℂ] H) + (he : ∀ x, b (e x) = a x) (hz : ∀ y, y ∉ Set.range e → b y = 0) (T : H →L[ℂ] H) : + partitionCompression b T = partitionCompression a T := by + unfold partitionCompression + rw [← partitionMap_inclusion e a b he hz, ContinuousLinearMap.adjoint_comp] + apply ContinuousLinearMap.ext + intro v + change (partitionMap a).adjoint ((inclusionIsometry e).toContinuousLinearMap.adjoint + (constantBlock T (inclusionIsometry e (partitionMap a v)))) = + (partitionMap a).adjoint (constantBlock T (partitionMap a v)) + have h := DFunLike.congr_fun (constantBlock_inclusion e T) (partitionMap a v) + change constantBlock T (inclusionIsometry e (partitionMap a v)) = + inclusionIsometry e (constantBlock T (partitionMap a v)) at h + rw [h, adjoint_apply_isometry] + +theorem localizedSpatialOperator_inclusion (e : X ↪ Y) + (a : X → H →L[ℂ] H) (b : Y → H →L[ℂ] H) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) + (hb : ∑ y, (b y).adjoint.comp (b y) = 1) + (he : ∀ x, b (e x) = a x) (hz : ∀ y, y ∉ Set.range e → b y = 0) (T : H →L[ℂ] H) : + localizedSpatialOperator b hb T = + isometricExtension (inclusionIsometry e) (localizedSpatialOperator a ha T) := by + unfold localizedSpatialOperator + rw [isometricExtension_comp, partitionIsometry_inclusion e a b ha hb he hz, + partitionCompression_inclusion e a b he hz] + +end DiscreteRoe +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartitionIntertwining.lean b/lean/OAI/Topology/CoarseAssembly/PartitionIntertwining.lean new file mode 100644 index 0000000000000000000000000000000000000000..92dcedf0985721dd8d9de6c73b1c2bd35c27efc5 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartitionIntertwining.lean @@ -0,0 +1,59 @@ +import OAI.Topology.CoarseAssembly.RipsUnitaryLocalization + +namespace OAI + +/-! # Finite localization respects reducing isometric intertwiners -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X E H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem partitionCompression_intertwines (I : E →ₗᵢ[ℂ] H) + (a : X → E →L[ℂ] E) (b : X → H →L[ℂ] H) + (ha : ∀ x, (a x).adjoint = a x) (hb : ∀ x, (b x).adjoint = b x) + (hI : ∀ x v, b x (I v) = I (a x v)) + (F : E →L[ℂ] E) (G : H →L[ℂ] H) (hF : ∀ v, G (I v) = I (F v)) (v : E) : + partitionCompression b G (I v) = I (partitionCompression a F v) := by + simp only [partitionCompression_eq_sum, sum_apply, ContinuousLinearMap.comp_apply, map_sum] + apply Finset.sum_congr rfl + intro x _ + rw [ha, hb, hI, hF, hI] + +theorem localizedSpatialOperator_apply (a : X → E →L[ℂ] E) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) (F : E →L[ℂ] E) + (v : Module X E) (x : X) : + localizedSpatialOperator a ha F v x = + v x + a x ((partitionCompression a F - 1) (∑ y, (a y).adjoint (v y))) := by + change v x + partitionIsometry a ha + ((partitionCompression a F - 1) ((partitionIsometry a ha).toContinuousLinearMap.adjoint v)) x = _ + rw [partitionIsometry_apply, partitionIsometry_toContinuousLinearMap, partitionMap_adjoint_apply] + +theorem localizedSpatialOperator_intertwines (I : E →ₗᵢ[ℂ] H) + (a : X → E →L[ℂ] E) (b : X → H →L[ℂ] H) + (ha : ∀ x, (a x).adjoint = a x) (hb : ∀ x, (b x).adjoint = b x) + (hpa : ∑ x, (a x).adjoint.comp (a x) = 1) + (hpb : ∑ x, (b x).adjoint.comp (b x) = 1) + (hI : ∀ x v, b x (I v) = I (a x v)) + (F : E →L[ℂ] E) (G : H →L[ℂ] H) (hF : ∀ v, G (I v) = I (F v)) : + (localizedSpatialOperator b hpb G).comp (coefficientIsometry I).toContinuousLinearMap = + (coefficientIsometry I).toContinuousLinearMap.comp (localizedSpatialOperator a hpa F) := by + ext v x + change localizedSpatialOperator b hpb G (coefficientIsometry I v) x = + I (localizedSpatialOperator a hpa F v x) + rw [localizedSpatialOperator_apply, localizedSpatialOperator_apply] + simp only [coefficientIsometry_apply, ha, hb] + have hsum : (∑ y, b y (I (v y))) = I (∑ y, a y (v y)) := by + simp only [hI, map_sum] + rw [hsum] + simp only [sub_apply, one_apply_eq_self, partitionCompression_intertwines I a b ha hb hI F G hF, + ← map_sub, hI, map_add] + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartitionIsometry.lean b/lean/OAI/Topology/CoarseAssembly/PartitionIsometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..e7ea6091288367eb8313a9c5fe731efa611d8cfb --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartitionIsometry.lean @@ -0,0 +1,41 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RoeCalculus + +namespace OAI + +/-! # The Hilbert-space isometry of a finite square partition -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [CompleteSpace H] in +@[simp] theorem coordinate_partitionMap (a : X → H →L[ℂ] H) (x : X) : + (coordinate x).comp (partitionMap a) = a x := by + ext v + simp [partitionMap, ContinuousLinearMap.comp_apply, coordinate_apply, insert_apply, + lp.single_apply] + +theorem partitionMap_adjoint (a : X → H →L[ℂ] H) : + (partitionMap a).adjoint = ∑ x, (a x).adjoint.comp (coordinate x) := by + simp only [partitionMap, map_sum, ContinuousLinearMap.adjoint_comp, insert_adjoint] + +theorem partitionMap_adjoint_comp (a : X → H →L[ℂ] H) : + (partitionMap a).adjoint.comp (partitionMap a) = ∑ x, (a x).adjoint.comp (a x) := by + rw [partitionMap_adjoint, ContinuousLinearMap.finsetSum_comp] + apply Finset.sum_congr rfl + intro x _ + rw [ContinuousLinearMap.comp_assoc, coordinate_partitionMap] + +@[simp] theorem partitionIsometry_toContinuousLinearMap (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) : + (partitionIsometry a hpart).toContinuousLinearMap = partitionMap a := rfl + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartitionMapNorm.lean b/lean/OAI/Topology/CoarseAssembly/PartitionMapNorm.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e9a2bccf9f596588de2d091fddddedd5c45b6cc --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartitionMapNorm.lean @@ -0,0 +1,39 @@ +import OAI.Topology.CoarseAssembly.PartitionIsometry + +namespace OAI + +/-! # A finite-coordinate estimate for partition isometries -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +omit [Fintype X] in +theorem insert_norm_le_one (x : X) : ‖insert (H := H) x‖ ≤ 1 := by + apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one + intro v + change ‖lp.single (E := fun _ : X => H) 2 x v‖ ≤ 1 * ‖v‖ + simpa only [one_mul] using + (lp.norm_single (E := fun _ : X => H) (by norm_num : (0 : ENNReal) < 2) x v).le + +theorem partitionMap_sub (a b : X → H →L[ℂ] H) : + partitionMap a - partitionMap b = ∑ x, (insert x).comp (a x - b x) := by + simp only [partitionMap, ContinuousLinearMap.comp_sub, Finset.sum_sub_distrib] + +theorem partitionMap_sub_norm_le_sum (a b : X → H →L[ℂ] H) : + ‖partitionMap a - partitionMap b‖ ≤ ∑ x, ‖a x - b x‖ := by + rw [partitionMap_sub] + apply (norm_sum_le Finset.univ (fun x => (insert (H := H) x).comp (a x - b x))).trans + apply Finset.sum_le_sum + intro x _ + exact (ContinuousLinearMap.opNorm_comp_le _ _).trans + (by simpa using mul_le_mul_of_nonneg_right (insert_norm_le_one (H := H) x) (norm_nonneg (a x - b x))) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PartitionSpatialControl.lean b/lean/OAI/Topology/CoarseAssembly/PartitionSpatialControl.lean new file mode 100644 index 0000000000000000000000000000000000000000..0c88f7bff3fb9509c6b490d307c390a4222f0732 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PartitionSpatialControl.lean @@ -0,0 +1,65 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.PartitionCompression + +namespace OAI + +/-! # Spatial control of the partition-localized operator -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem partitionMap_adjoint_insert (a : X → H →L[ℂ] H) (y : X) : + (partitionMap a).adjoint.comp (insert y) = (a y).adjoint := by + have h := congrArg ContinuousLinearMap.adjoint (coordinate_partitionMap a y) + simpa only [ContinuousLinearMap.adjoint_comp, coordinate_adjoint] using h + +theorem entry_partitionConjugate (a : X → H →L[ℂ] H) (F : H →L[ℂ] H) (x y : X) : + entry (partitionConjugate a F) x y = a x * F * (a y).adjoint := by + calc + entry (partitionConjugate a F) x y = + ((coordinate x).comp (partitionMap a)).comp + (F.comp ((partitionMap a).adjoint.comp (insert y))) := by + simp only [entry, partitionConjugate, ContinuousLinearMap.comp_assoc] + _ = _ := by + rw [coordinate_partitionMap, partitionMap_adjoint_insert] + rfl + +variable [PseudoMetricSpace X] + +theorem partitionConjugate_one_propagation (a : X → H →L[ℂ] H) + (ha : ∀ x, (a x).adjoint = a x) (r : ℝ) + (hsupport : ∀ x y, r < dist x y → a x * a y = 0) : + PropagationLE r (partitionConjugate a 1) := by + intro x y hxy + rw [entry_partitionConjugate, ha y, mul_one] + exact hsupport x y hxy + +theorem partitionLocalization_propagation (a : X → H →L[ℂ] H) + (ha : ∀ x, (a x).adjoint = a x) (r : ℝ) + (hsupport : ∀ x y, r < dist x y → a x * a y = 0) (F : H →L[ℂ] H) : + PropagationLE (r + r) (partitionConjugate a (partitionCompression a F)) := by + intro x y hxy + rw [entry_partitionConjugate, partitionCompression_eq_sum, ha y] + change a x * (∑ z, (a z).adjoint * F * a z) * a y = 0 + rw [Finset.mul_sum, Finset.sum_mul] + apply Finset.sum_eq_zero + intro z _ + rw [ha z] + by_cases hxz : r < dist x z + · rw [← mul_assoc (a x), ← mul_assoc (a x), hsupport x z hxz, zero_mul, zero_mul, + zero_mul] + · have hzy : r < dist z y := by + have ht := dist_triangle x z y + have hxz' := le_of_not_gt hxz + linarith + simp only [mul_assoc, hsupport z y hzy, mul_zero] + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PathFiberOperators.lean b/lean/OAI/Topology/CoarseAssembly/PathFiberOperators.lean new file mode 100644 index 0000000000000000000000000000000000000000..f568a1907b5c9e7fbc585d0c620024c9f70dfdb2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PathFiberOperators.lean @@ -0,0 +1,120 @@ +import OAI.Topology.CoarseAssembly.GraphFiberOperators +import Mathlib.Combinatorics.SimpleGraph.Metric + +namespace OAI + +/-! # Composing the concrete fiber transports + +Every base walk gives a contraction preserving normalized constants. +A nonzero matrix coefficient comes with an actual lifted walk of the same +length, which is the propagation estimate needed by the transfer criterion. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence + +section FiniteMatrices + +variable {Q R T : Type*} [Fintype Q] [Fintype R] [Fintype T] +variable [DecidableEq Q] [DecidableEq R] [DecidableEq T] + +theorem scalarFiber_expansion (x : lp (fun _ : Q => ℂ) 2) : + x = ∑ q : Q, (x q) • lp.single 2 q (1 : ℂ) := by + apply lp.ext + funext r + simp only [lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, Pi.smul_apply, + lp.single_apply, smul_eq_mul] + simp [Pi.single_apply, mul_ite] + +omit [Fintype R] [DecidableEq R] in +theorem scalarFiber_apply_sum + (A : lp (fun _ : Q => ℂ) 2 →L[ℂ] lp (fun _ : R => ℂ) 2) + (x : lp (fun _ : Q => ℂ) 2) (r : R) : + A x r = ∑ q : Q, x q * A (lp.single 2 q 1) r := by + conv_lhs => rw [scalarFiber_expansion x] + simp only [map_sum, map_smul, lp.coeFn_sum, Finset.sum_apply, + lp.coeFn_smul, Pi.smul_apply, smul_eq_mul] + +omit [Fintype Q] [Fintype T] [DecidableEq T] in +theorem scalarFiber_comp_nonzero + (A : lp (fun _ : Q => ℂ) 2 →L[ℂ] lp (fun _ : R => ℂ) 2) + (B : lp (fun _ : R => ℂ) 2 →L[ℂ] lp (fun _ : T => ℂ) 2) + (q : Q) (t : T) (h : (B.comp A) (lp.single 2 q 1) t ≠ 0) : + ∃ r : R, A (lp.single 2 q 1) r ≠ 0 ∧ B (lp.single 2 r 1) t ≠ 0 := by + classical + by_contra! hn + apply h + rw [ContinuousLinearMap.comp_apply, scalarFiber_apply_sum] + apply Finset.sum_eq_zero + intro r _ + by_cases hr : A (lp.single 2 q 1) r = 0 + · rw [hr, zero_mul] + · rw [hn r hr, mul_zero] + +end FiniteMatrices + +/-- The concrete edge maps compose without any loss in the propagation +bound. This includes the length-zero identity case. -/ +theorem exists_base_walk_operator (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} {u v : Disc j} (p : (discGraph j).Walk u v) : + ∃ O : lp (fun _ : Quotient (discDepth j u) => ℂ) 2 →L[ℂ] + lp (fun _ : Quotient (discDepth j v) => ℂ) 2, + ‖O‖ ≤ 1 ∧ O (fiberConstant (Quotient (discDepth j u)) (1 : ℂ)) = + fiberConstant (Quotient (discDepth j v)) 1 ∧ + ∀ q z, O (lp.single 2 q 1) z ≠ 0 → + ∃ w : (fiberedGraph S t j).Walk ⟨u, q⟩ ⟨v, z⟩, w.length = p.length := by + classical + induction p with + | @nil u => + refine ⟨ContinuousLinearMap.id ℂ _, ContinuousLinearMap.norm_id_le, rfl, ?_⟩ + intro q z hn + have hz : z = q := by + by_contra hne + apply hn + exact lp.single_apply_ne 2 q 1 hne + subst z + exact ⟨.nil, rfl⟩ + | @cons u v w huv p ih => + obtain ⟨A, hA, hAc, hAs⟩ := exists_base_edge_operator S t huv + obtain ⟨B, hB, hBc, hBs⟩ := ih + refine ⟨B.comp A, ?_, ?_, ?_⟩ + · exact (ContinuousLinearMap.opNorm_comp_le B A).trans + ((mul_le_mul hB hA (norm_nonneg A) zero_le_one).trans_eq (one_mul 1)) + · rw [ContinuousLinearMap.comp_apply, hAc, hBc] + · intro q z hn + obtain ⟨r, hAr, hBr⟩ := scalarFiber_comp_nonzero A B q z hn + have he : (fiberedGraph S t j).Adj ⟨u, q⟩ ⟨v, r⟩ := by + by_contra he + exact hAr (hAs q r he) + obtain ⟨p', hp'⟩ := hBs r z hBr + exact ⟨.cons he p', by simp only [SimpleGraph.Walk.length_cons, hp']⟩ + +/-- A shortest base walk provides the desired controlled contraction for +any prescribed finite graph-distance bound. -/ +theorem exists_bounded_base_operator (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) + {j : ℕ} {u v : Disc j} {R : ℕ} (hR : (discGraph j).edist u v ≤ R) : + ∃ O : lp (fun _ : Quotient (discDepth j u) => ℂ) 2 →L[ℂ] + lp (fun _ : Quotient (discDepth j v) => ℂ) 2, + ‖O‖ ≤ 1 ∧ O (fiberConstant (Quotient (discDepth j u)) (1 : ℂ)) = + fiberConstant (Quotient (discDepth j v)) 1 ∧ + ∀ q z, R < (fiberedGraph S t j).edist ⟨u, q⟩ ⟨v, z⟩ → + O (lp.single 2 q 1) z = 0 := by + obtain ⟨p, hp⟩ := (discGraph j).exists_walk_of_edist_ne_top + (ne_of_lt (lt_of_le_of_lt hR (by simp))) + obtain ⟨O, hO, hOc, hOs⟩ := exists_base_walk_operator S t p + refine ⟨O, hO, hOc, ?_⟩ + intro q z hdist + by_contra hn + obtain ⟨w, hw⟩ := hOs q z hn + have hle := w.edist_le + rw [hw, hp] at hle + exact (not_lt_of_ge (hle.trans hR)) hdist + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Persistence.lean b/lean/OAI/Topology/CoarseAssembly/Persistence.lean new file mode 100644 index 0000000000000000000000000000000000000000..42cad49969e0d1b52ec9190d27fa4e75ab356185 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Persistence.lean @@ -0,0 +1,91 @@ +import Mathlib.Algebra.Colimit.Module +import Mathlib.RingTheory.Localization.BaseChange +import Mathlib.Data.Rat.Encodable + +namespace OAI + +/-! +# Algebraic persistence in the coarse Novikov construction + +The direct-limit and rationalization arguments apply to arbitrary abelian +groups. No compatibility between the tests at different scales is assumed +or needed. +-/ + +namespace CoarseAssembly + +section DirectLimit + +variable {G : ℕ → Type*} [∀ r, AddCommGroup (G r)] +variable (f : ∀ r s, r ≤ s → G r →+ G s) +variable [DirectedSystem G (fun r s h => f r s h)] + +/-- A class detected with value one at every later scale has no nonzero integer +multiple that vanishes in the actual algebraic direct limit. This is the last +argument of the manuscript's Proposition 4.1, with the geometric tests supplied +as explicit parameters. The tests need not form a compatible family. -/ +theorem persistent_multiples_ne_zero (r₀ : ℕ) (a : G r₀) + (test : ∀ r, r₀ ≤ r → G r →+ ℤ) + (detects : ∀ r (hr : r₀ ≤ r), test r hr (f r₀ r hr a) = 1) + (n : ℤ) (hn : n ≠ 0) : + n • AddCommGroup.DirectLimit.of G f r₀ a ≠ 0 := by + intro h + have h' : AddCommGroup.DirectLimit.of G f r₀ (n • a) = 0 := by + simpa only [map_zsmul] using h + obtain ⟨r, hr, hz⟩ := AddCommGroup.DirectLimit.of.zero_exact r₀ (n • a) h' + have ht := congrArg (test r hr) hz + simp only [map_zsmul, map_zero, detects, zsmul_eq_mul, mul_one] at ht + exact hn ht + +/-- The cyclic subgroup generated by a persistently detected class is an +embedded copy of the integers. -/ +theorem persistent_cyclic_injective (r₀ : ℕ) (a : G r₀) + (test : ∀ r, r₀ ≤ r → G r →+ ℤ) + (detects : ∀ r (hr : r₀ ≤ r), test r hr (f r₀ r hr a) = 1) : + Function.Injective (fun n : ℤ => n • AddCommGroup.DirectLimit.of G f r₀ a) := by + intro n m h + dsimp only at h + by_contra hne + have hz : (n - m) • AddCommGroup.DirectLimit.of G f r₀ a = 0 := by + rw [sub_smul, h, sub_self] + exact persistent_multiples_ne_zero f r₀ a test detects (n - m) (sub_ne_zero.mpr hne) hz + +end DirectLimit + +section Rationalization + +variable {A B : Type*} [AddCommGroup A] [AddCommGroup B] + +/-- An element with no nonzero integer annihilator remains nonzero after +rationalization. This is the torsion-kernel fact used after Proposition 4.1. -/ +theorem rationalization_ne_zero (a : A) + (ha : ∀ n : ℤ, n ≠ 0 → n • a ≠ 0) : + (1 : ℚ) ⊗ₜ[ℤ] a ≠ 0 := by + intro h + have heq : TensorProduct.mk ℤ ℚ A 1 a = TensorProduct.mk ℤ ℚ A 1 0 := by + simpa using h + obtain ⟨s, hs⟩ := IsLocalizedModule.exists_of_eq (S := nonZeroDivisors ℤ) + (f := TensorProduct.mk ℤ ℚ A 1) heq + exact ha s (mem_nonZeroDivisors_iff_ne_zero.mp s.property) + (by simpa only [Submonoid.smul_def, smul_zero] using hs) + +/-- A non-torsion kernel element prevents both integral and rational +injectivity. The scalar extension is the actual tensor product of groups. -/ +theorem kernel_obstructs_injectivity (μ : A →+ B) (a : A) + (ha : ∀ n : ℤ, n ≠ 0 → n • a ≠ 0) (hμ : μ a = 0) : + ¬ Function.Injective μ ∧ + ¬ Function.Injective (μ.toIntLinearMap.lTensor ℚ) := by + constructor + · intro hinj + have hz : a = 0 := hinj (hμ.trans μ.map_zero.symm) + exact ha 1 one_ne_zero (by simpa using hz) + · intro hinj + apply rationalization_ne_zero a ha + apply hinj + simp [hμ] + +end Rationalization + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PointCoefficient.lean b/lean/OAI/Topology/CoarseAssembly/PointCoefficient.lean new file mode 100644 index 0000000000000000000000000000000000000000..11b96cae531051ffc612941598821e9412df40bc --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PointCoefficient.lean @@ -0,0 +1,65 @@ +import OAI.Topology.CoarseAssembly.SupportedNormalization +import OAI.Topology.CoarseAssembly.CompactHomotopy + +namespace OAI + +/-! # The odd analytic coefficient group of a point + +All scalar Fredholm cycles vanish by explicit operator normalization. The +constant-function and evaluation maps identify the point coefficient algebra +with the scalars, so its odd group vanishes as well. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty + +def pointConstants : ℂ →⋆ₙₐ[ℂ] C₀(Unit, ℂ) where + toFun z := compactFunctionLift (ContinuousMap.const Unit z) + map_zero' := by ext x; rfl + map_add' _ _ := by ext x; rfl + map_mul' _ _ := by ext x; rfl + map_smul' _ _ := by ext x; rfl + map_star' _ := by ext x; rfl + +def pointEvaluation : C₀(Unit, ℂ) →⋆ₙₐ[ℂ] ℂ where + toFun a := a () + map_zero' := rfl + map_add' _ _ := rfl + map_mul' _ _ := rfl + map_smul' _ _ := rfl + map_star' _ := rfl + +theorem pointConstants_evaluation : pointConstants.comp pointEvaluation = + NonUnitalStarAlgHom.id ℂ C₀(Unit, ℂ) := by + ext a x + cases x + rfl + +theorem point_cycleClass_zero (c : OddCycle C₀(Unit, ℂ)) : + cycleClass C₀(Unit, ℂ) c = 0 := by + have h := congrArg (precomp pointEvaluation) (scalar_cycleClass_zero (c.precomp pointConstants)) + simpa only [precomp_cycleClass, map_zero, OddCycle.precomp_comp, + pointConstants_evaluation, OddCycle.precomp_id] using h + +theorem subsingleton_of_cycleClass_zero {A : Type} [NonUnitalCStarAlgebra A] + (hzero : ∀ c : OddCycle A, cycleClass A c = 0) : Subsingleton (OddK A) := by + have h : AddMonoidHom.id (OddK A) = 0 := by + apply hom_ext + intro c + exact hzero c + refine ⟨fun x y => ?_⟩ + have hx : x = 0 := DFunLike.congr_fun h x + have hy : y = 0 := DFunLike.congr_fun h y + exact hx.trans hy.symm + +theorem point_odd_zero : Subsingleton (LocallyFiniteK1 Unit) := + subsingleton_of_cycleClass_zero point_cycleClass_zero + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PointwiseEmbeddingTransition.lean b/lean/OAI/Topology/CoarseAssembly/PointwiseEmbeddingTransition.lean new file mode 100644 index 0000000000000000000000000000000000000000..1155bcad7e60c5dc24651d75430594eee1f04088 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PointwiseEmbeddingTransition.lean @@ -0,0 +1,64 @@ +import OAI.Topology.CoarseAssembly.EmbeddingBoundaryComparison +import OAI.Topology.CoarseAssembly.ProjectionBlocks + +namespace OAI + +/-! # Pointwise coefficient transitions have propagation zero -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X : Type*} [DecidableEq X] [PseudoMetricSpace X] + {E : X → Type*} [∀ x, NormedAddCommGroup (E x)] + [∀ x, InnerProductSpace ℂ (E x)] [∀ x, CompleteSpace (E x)] + {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [DecidableEq X] [PseudoMetricSpace X] in +theorem blockIsometry_adjoint_apply (V : ∀ x, E x →ₗᵢ[ℂ] H) + (v : Module X H) (x : X) : + (blockIsometry V).toContinuousLinearMap.adjoint v x = + (V x).toContinuousLinearMap.adjoint (v x) := by + rw [blockIsometry_toCLM, blockOperator_adjoint] + rfl + +omit [DecidableEq X] [PseudoMetricSpace X] in +theorem pointwiseEmbeddingTransition_apply (V W : ∀ x, E x →ₗᵢ[ℂ] H) + (v : Module X H) (x : X) : + embeddingTransition (blockIsometry V) (blockIsometry W) v x = + W x ((V x).toContinuousLinearMap.adjoint (v x)) := by + change (blockIsometry W) ((blockIsometry V).toContinuousLinearMap.adjoint v) x = _ + rw [blockIsometry_apply, blockIsometry_adjoint_apply] + +theorem pointwiseEmbeddingTransition_propagation (V W : ∀ x, E x →ₗᵢ[ℂ] H) : + PropagationLE 0 (embeddingTransition (blockIsometry V) (blockIsometry W)) := by + intro x y hxy + have hne : x ≠ y := by rintro rfl; simp at hxy + ext h + simp [entry_apply, pointwiseEmbeddingTransition_apply, lp.single_apply, + hne] + +theorem pointwiseEmbeddingTransition_multiplier + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + (V W : ∀ x, E x →ₗᵢ[ℂ] H) : + RoeMultiplier (embeddingTransition (blockIsometry V) (blockIsometry W)) := + finitePropagation_multiplier finiteBalls le_rfl (pointwiseEmbeddingTransition_propagation V W) + +/-- Choice of pointwise embeddings does not change the actual Roe boundary class. -/ +theorem multiplierBoundaryClass_pointwiseEmbedding + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + (V W : ∀ x, E x →ₗᵢ[ℂ] H) (S : lp E 2 →L[ℂ] lp E 2) (hS : IsSelfAdjoint S) + (F G : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) (hG : IsSelfAdjoint G) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hGd : G.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (hFV : F.val = isometricExtension (blockIsometry V) S) + (hGW : G.val = isometricExtension (blockIsometry W) S) : + multiplierBoundaryClass F hF hFd = multiplierBoundaryClass G hG hGd := + multiplierBoundaryClass_embedding (blockIsometry V) (blockIsometry W) S hS + F G hF hG hFd hGd hFV hGW (pointwiseEmbeddingTransition_multiplier finiteBalls V W) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ProductIndex.lean b/lean/OAI/Topology/CoarseAssembly/ProductIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..1472a2dbe08459c7725748a70f3f74d8552bc752 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ProductIndex.lean @@ -0,0 +1,71 @@ +import OAI.Topology.CoarseAssembly.UnitaryIndex +import Mathlib.LinearAlgebra.Isomorphisms + +namespace OAI + +/-! # Additivity of the Fredholm index on products -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H K : HilbertSpace} + +def submoduleProductEquiv (P : Submodule ℂ H) (Q : Submodule ℂ K) : + P.prod Q ≃ₗ[ℂ] P × Q where + toFun x := (⟨x.1.1, x.2.1⟩, ⟨x.1.2, x.2.2⟩) + invFun x := ⟨(x.1, x.2), x.1.property, x.2.property⟩ + left_inv _ := rfl + right_inv _ := rfl + map_add' _ _ := rfl + map_smul' _ _ := rfl + +def quotientProductEquiv (P : Submodule ℂ H) (Q : Submodule ℂ K) : + ((H × K) ⧸ P.prod Q) ≃ₗ[ℂ] (H ⧸ P) × (K ⧸ Q) := by + let f := P.mkQ.prodMap Q.mkQ + have hf : Function.Surjective f := by + rintro ⟨x, y⟩ + obtain ⟨x', rfl⟩ := P.mkQ_surjective x + obtain ⟨y', rfl⟩ := Q.mkQ_surjective y + exact ⟨(x', y'), rfl⟩ + have hk : f.ker = P.prod Q := by simp only [f, LinearMap.ker_prodMap, Submodule.ker_mkQ] + exact (Submodule.quotEquivOfEq _ _ hk.symm).trans (f.quotKerEquivOfSurjective hf) + +theorem finrank_submoduleProduct (P : Submodule ℂ H) (Q : Submodule ℂ K) + [FiniteDimensional ℂ P] [FiniteDimensional ℂ Q] : + Module.finrank ℂ (P.prod Q) = Module.finrank ℂ P + Module.finrank ℂ Q := by + rw [(submoduleProductEquiv P Q).finrank_eq, Module.finrank_prod] + +theorem finrank_quotientProduct (P : Submodule ℂ H) (Q : Submodule ℂ K) + [FiniteDimensional ℂ (H ⧸ P)] [FiniteDimensional ℂ (K ⧸ Q)] : + Module.finrank ℂ ((H × K) ⧸ P.prod Q) = + Module.finrank ℂ (H ⧸ P) + Module.finrank ℂ (K ⧸ Q) := by + rw [(quotientProductEquiv P Q).finrank_eq, Module.finrank_prod] + +theorem fredholmIndex_prodMap (T : End H) (S : End K) (hT : T.IsFredholm) (hS : S.IsFredholm) : + (T.toLinearMap.prodMap S.toLinearMap).index = T.toLinearMap.index + S.toLinearMap.index := by + let := hT.finite_ker + let := hS.finite_ker + let := hT.finite_coker + let := hS.finite_coker + have hk : (T.toLinearMap.prodMap S.toLinearMap).ker = T.ker.prod S.ker := + LinearMap.ker_prodMap T.toLinearMap S.toLinearMap + have hr : (T.toLinearMap.prodMap S.toLinearMap).range = T.range.prod S.range := + LinearMap.range_prodMap T.toLinearMap S.toLinearMap + have hkdim : Module.finrank ℂ (T.toLinearMap.prodMap S.toLinearMap).ker = + Module.finrank ℂ T.ker + Module.finrank ℂ S.ker := by + rw [hk] + exact finrank_submoduleProduct T.ker S.ker + have hrdim : Module.finrank ℂ ((H × K) ⧸ (T.toLinearMap.prodMap S.toLinearMap).range) = + Module.finrank ℂ (H ⧸ T.range) + Module.finrank ℂ (K ⧸ S.range) := by + rw [hr] + exact finrank_quotientProduct T.range S.range + simp only [LinearMap.index_eq_finrank_sub] + rw [hkdim, hrdim, Nat.cast_add, Nat.cast_add] + omega + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ProjectionBlocks.lean b/lean/OAI/Topology/CoarseAssembly/ProjectionBlocks.lean new file mode 100644 index 0000000000000000000000000000000000000000..25114b4c4327a3ff3e1c47309a75814d0b0ad7a4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ProjectionBlocks.lean @@ -0,0 +1,126 @@ +import OAI.Topology.CoarseAssembly.Averaging +import OAI.Topology.CoarseAssembly.SpatialBlocks + +namespace OAI + +/-! # Spatial block projections + +Adjoints commute with uniformly bounded Hilbert direct sums. Under the +explicit flattening equivalence, the sum of constant-fiber projections is +exactly the spatial projection `V V*` used by the Roe transfer. +-/ + +noncomputable section + +namespace CoarseAssembly + +open scoped Topology + +variable {I : Type*} {E F : I → Type*} +variable [∀ i, NormedAddCommGroup (E i)] [∀ i, InnerProductSpace ℂ (E i)] +variable [∀ i, CompleteSpace (E i)] +variable [∀ i, NormedAddCommGroup (F i)] [∀ i, InnerProductSpace ℂ (F i)] +variable [∀ i, CompleteSpace (F i)] + +theorem blockOperator_adjoint (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ i, ‖A i‖ ≤ C) : + (blockOperator A C hC hA).adjoint = + blockOperator (fun i => (A i).adjoint) C hC + (fun i => (LinearIsometryEquiv.norm_map ContinuousLinearMap.adjoint _).trans_le (hA i)) := by + symm + apply (ContinuousLinearMap.eq_adjoint_iff _ _).mpr + intro x y + simp only [lp.inner_eq_tsum, blockOperator_apply] + exact tsum_congr (fun i => ContinuousLinearMap.adjoint_inner_left (A i) (y i) (x i)) + +omit [∀ i, CompleteSpace (E i)] [∀ i, CompleteSpace (F i)] in +theorem blockIsometry_toCLM (V : ∀ i, E i →ₗᵢ[ℂ] F i) : + (blockIsometry V).toContinuousLinearMap = + blockOperator (fun i => (V i).toContinuousLinearMap) 1 zero_le_one + (fun i => (V i).norm_toContinuousLinearMap_le) := by + apply ContinuousLinearMap.ext + intro x + rfl + +variable {Q : I → Type*} [∀ i, Fintype (Q i)] [∀ i, Nonempty (Q i)] +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem block_constantProjection : + blockOperator (fun i => constantProjection (H := H) (Q i)) 1 zero_le_one + (fun i => constantProjection_norm_le (Q i)) = + operatorConjugation (blockIsometry (fun i => fiberConstantIsometry (H := H) (Q i))) 1 := by + rw [operatorConjugation, blockIsometry_toCLM, blockOperator_adjoint] + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext i + rfl + +omit [∀ i, Fintype (Q i)] [∀ i, Nonempty (Q i)] in +theorem flattenOperator_eq_conjugation + (A : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) : + flattenOperator A = operatorConjugation + (flattenEquiv (Q := Q) (H := H)).toLinearIsometry A := by + let e := flattenEquiv (Q := Q) (H := H) + have he : e.toLinearIsometry.toContinuousLinearMap.adjoint = + e.symm.toLinearIsometry.toContinuousLinearMap := by + apply ContinuousLinearMap.ext + intro x + apply ext_inner_right ℂ + intro y + rw [ContinuousLinearMap.adjoint_inner_left] + simpa only [LinearIsometry.coe_toContinuousLinearMap, LinearIsometryEquiv.coe_toLinearIsometry, + LinearIsometryEquiv.apply_symm_apply] using e.inner_map_map (e.symm x) y + unfold flattenOperator operatorConjugation + rw [he] + +/-- Equality with the actual spatial projection, not merely agreement on +formal constant-fiber symbols. -/ +theorem flatten_constantProjection : + flattenOperator (Q := Q) (H := H) (blockOperator (fun i => constantProjection (H := H) (Q i)) + 1 zero_le_one (fun i => constantProjection_norm_le (Q i))) = + fiberProjection (H := H) Q := by + rw [block_constantProjection (Q := Q) (H := H), + flattenOperator_eq_conjugation, operatorConjugation_comp] + rfl + +omit [∀ i, Fintype (Q i)] [∀ i, Nonempty (Q i)] [CompleteSpace H] in +theorem flattenOperator_sub + (A B : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) : + flattenOperator (A - B) = flattenOperator A - flattenOperator B := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext z + rfl + +omit [∀ i, Fintype (Q i)] [∀ i, Nonempty (Q i)] in +theorem flattenOperator_mul + (A B : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) : + flattenOperator (A * B) = flattenOperator A * flattenOperator B := by + rw [flattenOperator_eq_conjugation, flattenOperator_eq_conjugation, + flattenOperator_eq_conjugation, operatorConjugation_mul] + +omit [∀ i, Fintype (Q i)] [∀ i, Nonempty (Q i)] in +theorem flattenOperator_tendsto + (A : ℕ → (lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2)) + (B : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) + (h : Filter.Tendsto A Filter.atTop (nhds B)) : + Filter.Tendsto (fun n => flattenOperator (Q := Q) (H := H) (A n)) + Filter.atTop (nhds (flattenOperator B)) := by + apply tendsto_iff_norm_sub_tendsto_zero.mpr + apply squeeze_zero (fun n => norm_nonneg _) (fun n => ?_) + (tendsto_iff_norm_sub_tendsto_zero.mp h) + rw [← flattenOperator_sub] + exact flattenOperator_norm_le _ + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ProjectionSwap.lean b/lean/OAI/Topology/CoarseAssembly/ProjectionSwap.lean new file mode 100644 index 0000000000000000000000000000000000000000..43254c1517227f507981026cbe7d928c7066a547 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ProjectionSwap.lean @@ -0,0 +1,92 @@ +import OAI.Topology.CoarseAssembly.BinaryHilbertSum +import Mathlib.Algebra.Star.StarProjection +import Mathlib.Tactic.NoncommRing + +namespace OAI + +/-! # The unitary which exchanges complementary represented subspaces -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable (H : HilbertSpace) + +def binaryFlip : End (binaryHilbertSpace H H) := + (LinearIsometryEquiv.withLpProdComm 2 ℂ H H).toContinuousLinearEquiv.toContinuousLinearMap + +@[simp] theorem binaryFlip_apply (x : binaryHilbertSpace H H) : + binaryFlip H x = WithLp.toLp 2 (x.snd, x.fst) := rfl + +theorem binaryFlip_selfAdjoint : IsSelfAdjoint (binaryFlip H) := by + change ContinuousLinearMap.adjoint + (LinearIsometryEquiv.withLpProdComm 2 ℂ H H).toContinuousLinearEquiv.toContinuousLinearMap = _ + rw [LinearIsometryEquiv.adjoint_eq_symm] + rfl + +theorem binaryFlip_block (T : End H) : + binaryFlip H * binaryBlock H H T T = binaryBlock H H T T * binaryFlip H := by + apply ContinuousLinearMap.ext + intro x + change binaryFlip H (binaryBlock H H T T x) = binaryBlock H H T T (binaryFlip H x) + rw [binaryBlock_apply H H, binaryFlip_apply, binaryFlip_apply, binaryBlock_apply H H] + rfl + +def projectionSwap (P : End H) : End (binaryHilbertSpace H H) := + binaryBlock H H P P + binaryBlock H H (1 - P) (1 - P) * binaryFlip H + +@[simp] theorem projectionSwap_apply (P : End H) (x : binaryHilbertSpace H H) : + projectionSwap H P x = + WithLp.toLp 2 (P x.fst + (1 - P) x.snd, (1 - P) x.fst + P x.snd) := by + change binaryBlock H H P P x + binaryBlock H H (1 - P) (1 - P) (binaryFlip H x) = _ + rw [binaryBlock_apply H H, binaryFlip_apply, binaryBlock_apply H H] + apply (WithLp.ofLp_injective 2) + change (P x.fst + (1 - P) x.snd, P x.snd + (1 - P) x.fst) = _ + rw [add_comm (P x.snd)] + +theorem projectionSwap_selfAdjoint (P : End H) (hP : IsSelfAdjoint P) : + IsSelfAdjoint (projectionSwap H P) := by + change star (projectionSwap H P) = projectionSwap H P + unfold projectionSwap + rw [star_add, star_mul, ← binaryBlock_star, ← binaryBlock_star, + hP.star_eq, star_sub, star_one, hP.star_eq, (binaryFlip_selfAdjoint H).star_eq, + binaryFlip_block] + +theorem projectionSwap_sq (P : End H) (hPP : P * P = P) : + projectionSwap H P * projectionSwap H P = 1 := by + apply ContinuousLinearMap.ext + intro x + change projectionSwap H P (projectionSwap H P x) = x + rw [projectionSwap_apply H, projectionSwap_apply H] + apply (WithLp.ofLp_injective 2) + have hp (y : H) : P (P y) = P y := DFunLike.congr_fun hPP y + change + (P (P x.fst + (1 - P) x.snd) + (1 - P) ((1 - P) x.fst + P x.snd), + (1 - P) (P x.fst + (1 - P) x.snd) + P ((1 - P) x.fst + P x.snd)) = (x.fst, x.snd) + simp only [map_add, sub_apply, one_apply_eq_self, map_sub, hp] + ext <;> abel_nf + +def projectionSwapUnitary (P : End H) (hP : IsStarProjection P) : + binaryHilbertSpace H H ≃ₗᵢ[ℂ] binaryHilbertSpace H H := + Unitary.linearIsometryEquiv ⟨projectionSwap H P, by + rw [Unitary.mem_iff, (projectionSwap_selfAdjoint H P hP.isSelfAdjoint).star_eq] + exact ⟨projectionSwap_sq H P hP.isIdempotentElem, + projectionSwap_sq H P hP.isIdempotentElem⟩⟩ + +@[simp] theorem projectionSwapUnitary_clm (P : End H) (hP : IsStarProjection P) : + (projectionSwapUnitary H P hP).toLinearIsometry.toContinuousLinearMap = projectionSwap H P := rfl + +theorem projectionSwapUnitary_conjugation (P : End H) (hP : IsStarProjection P) + (T : End (binaryHilbertSpace H H)) : + operatorConjugation (projectionSwapUnitary H P hP).toLinearIsometry T = + projectionSwap H P * T * projectionSwap H P := by + unfold operatorConjugation + rw [projectionSwapUnitary_clm] + change projectionSwap H P * T * star (projectionSwap H P) = _ + rw [(projectionSwap_selfAdjoint H P hP.isSelfAdjoint).star_eq] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ProjectionUnitaryPath.lean b/lean/OAI/Topology/CoarseAssembly/ProjectionUnitaryPath.lean new file mode 100644 index 0000000000000000000000000000000000000000..516cf6c6eaa9e329fed6671dcb35384f0fec8654 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ProjectionUnitaryPath.lean @@ -0,0 +1,104 @@ +import OAI.Topology.CoarseAssembly.FredholmModule +import Mathlib.Algebra.Star.StarProjection +import Mathlib.Analysis.SpecialFunctions.Sqrt +import Mathlib.Tactic.NoncommRing +import Mathlib.Tactic.Module + +namespace OAI + +/-! # An explicit unitary path for changing a projection's sign -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +def semicircleValue (t : Interval) : ℂ := + ⟨1 - 2 * t.val, 2 * Real.sqrt (t.val * (1 - t.val))⟩ + +theorem semicircleValue_star_mul (t : Interval) : + star (semicircleValue t) * semicircleValue t = 1 := by + have hsq := Real.sq_sqrt (mul_nonneg t.property.1 (sub_nonneg.mpr t.property.2)) + apply Complex.ext + · change (1 - 2 * t.val) * (1 - 2 * t.val) - + (-(2 * Real.sqrt (t.val * (1 - t.val)))) * + (2 * Real.sqrt (t.val * (1 - t.val))) = 1 + nlinarith + · change (1 - 2 * t.val) * (2 * Real.sqrt (t.val * (1 - t.val))) + + (-(2 * Real.sqrt (t.val * (1 - t.val)))) * (1 - 2 * t.val) = 0 + ring + +def semicircleUnitary (t : Interval) : unitary ℂ := + ⟨semicircleValue t, semicircleValue_star_mul t, by + rw [mul_comm]; exact semicircleValue_star_mul t⟩ + +attribute [local fun_prop] Continuous.const_mul continuous_mul_const in +theorem semicircleUnitary_continuous : Continuous semicircleUnitary := by + apply Continuous.subtype_mk + change Continuous (fun t : Interval => semicircleValue t) + simp only [semicircleValue, Complex.mk_eq_add_mul_I] + fun_prop + +@[simp] theorem semicircleUnitary_start : semicircleUnitary start = 1 := by + apply Subtype.ext + change semicircleValue start = 1 + apply Complex.ext <;> norm_num [semicircleValue, start] + +@[simp] theorem semicircleUnitary_finish : (semicircleUnitary finish : ℂ) = -1 := by + apply Complex.ext <;> norm_num [semicircleUnitary, semicircleValue, finish] + +variable {A : Type*} [Ring A] [Algebra ℂ A] [StarRing A] [StarModule ℂ A] + +def projectionPhase (P : A) (hP : IsStarProjection P) (z : unitary ℂ) : unitary A := by + let Q := 1 - P + have hQQ : Q * Q = Q := hP.one_sub.isIdempotentElem + have hPP : P * P = P := hP.isIdempotentElem + have hPQ : P * Q = 0 := hP.mul_one_sub_self + have hQP : Q * P = 0 := hP.one_sub_mul_self + have hz : star (z : ℂ) * (z : ℂ) = 1 := Unitary.coe_star_mul_self z + have hz' : (z : ℂ) * star (z : ℂ) = 1 := Unitary.coe_mul_star_self z + refine ⟨Q + (z : ℂ) • P, ?_, ?_⟩ + · change star (Q + (z : ℂ) • P) * (Q + (z : ℂ) • P) = 1 + rw [star_add, star_smul, hP.isSelfAdjoint.star_eq, + hP.one_sub.isSelfAdjoint.star_eq, add_mul, mul_add, mul_add, + hQQ, mul_smul_comm, hQP, smul_zero, smul_mul_assoc, hPQ, smul_zero, + smul_mul_assoc, mul_smul_comm, hPP, smul_smul] + rw [hz, one_smul, add_zero, zero_add] + dsimp only [Q] + abel + · change (Q + (z : ℂ) • P) * star (Q + (z : ℂ) • P) = 1 + rw [star_add, star_smul, hP.isSelfAdjoint.star_eq, + hP.one_sub.isSelfAdjoint.star_eq, add_mul, mul_add, mul_add, + hQQ, mul_smul_comm, hQP, smul_zero, smul_mul_assoc, hPQ, smul_zero, + smul_mul_assoc, mul_smul_comm, hPP, smul_smul] + rw [hz', one_smul, add_zero, zero_add] + dsimp only [Q] + abel + +def projectionSignPath (P : A) (hP : IsStarProjection P) (t : Interval) : unitary A := + projectionPhase P hP (semicircleUnitary t) + +theorem projectionSignPath_continuous [TopologicalSpace A] [ContinuousAdd A] + [ContinuousSMul ℂ A] (P : A) (hP : IsStarProjection P) : + Continuous (projectionSignPath P hP) := by + apply Continuous.subtype_mk + exact continuous_const.add + ((continuous_subtype_val.comp semicircleUnitary_continuous).smul continuous_const) + +@[simp] theorem projectionSignPath_start (P : A) (hP : IsStarProjection P) : + projectionSignPath P hP start = 1 := by + apply Subtype.ext + change 1 - P + (semicircleUnitary start : ℂ) • P = 1 + rw [semicircleUnitary_start] + simp + +@[simp] theorem projectionSignPath_finish (P : A) (hP : IsStarProjection P) : + (projectionSignPath P hP finish : A) = 1 - (2 : ℂ) • P := by + change 1 - P + (semicircleUnitary finish : ℂ) • P = _ + rw [semicircleUnitary_finish] + module + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ProperGeometry.lean b/lean/OAI/Topology/CoarseAssembly/ProperGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..345029f23e69e6a21f3e0bc8902f61f5ce2ab810 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ProperGeometry.lean @@ -0,0 +1,32 @@ +import OAI.Topology.CoarseAssembly.ConcreteTransfer +import Mathlib.Topology.MetricSpace.ProperSpace + +namespace OAI + +/-! # Properness of the concrete coarse spaces + +The proved finite-ball estimates imply compact closed balls in the actual +shortest-path metrics. No completion or change of metric is involved. +-/ + +noncomputable section + +namespace CoarseAssembly + +theorem UniformFiniteBalls.properSpace {X : Type*} [PseudoMetricSpace X] + (hX : UniformFiniteBalls X) : ProperSpace X := + ⟨fun x r => (hX.finite_closedBall x r).isCompact⟩ + +theorem baseUnion_proper : ProperSpace BaseUnion := + baseUnion_uniform_balls.properSpace + +theorem vertexUnion_proper (S : Finset Congruence.ArithmeticGroup) (t : ℤ_[2]ˣ) : + @ProperSpace VertexUnion (vertexUnionMetric S t).toPseudoMetricSpace := + @UniformFiniteBalls.properSpace VertexUnion (vertexUnionMetric S t).toPseudoMetricSpace + (vertexUnion_uniform_balls S t) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PseudolocalAlgebra.lean b/lean/OAI/Topology/CoarseAssembly/PseudolocalAlgebra.lean new file mode 100644 index 0000000000000000000000000000000000000000..0370903f521a789c7bd1f50a858f4bf71336a732 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PseudolocalAlgebra.lean @@ -0,0 +1,138 @@ +import OAI.Topology.CoarseAssembly.LocallyCompactAlgebra +import Mathlib.Tactic.NoncommRing + +namespace OAI + +/-! # Pseudolocal operators and the controlled structure algebra -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open scoped ZeroAtInfty CStarAlgebra + +variable {X H : Type*} [DecidableEq X] [TopologicalSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp + +def Pseudolocal (T : Operator X H) : Prop := + ∀ f : C₀(X, ℂ), IsCompactOperator (T * diagonalMultiplier (H := H) f - + diagonalMultiplier (H := H) f * T) + +omit [DecidableEq X] [CompleteSpace H] in +theorem LocallyCompact.pseudolocal {T : Operator X H} (hT : LocallyCompact T) : + Pseudolocal T := fun f => (hT f).2.sub (hT f).1 + +omit [DecidableEq X] [CompleteSpace H] in +theorem Pseudolocal.add {T S : Operator X H} (hT : Pseudolocal T) (hS : Pseudolocal S) : + Pseudolocal (T + S) := by + intro f + have he : (T + S) * diagonalMultiplier (H := H) f - diagonalMultiplier (H := H) f * (T + S) = + (T * diagonalMultiplier (H := H) f - diagonalMultiplier (H := H) f * T) + + (S * diagonalMultiplier (H := H) f - diagonalMultiplier (H := H) f * S) := by + simp only [add_mul, mul_add] + abel + rw [he] + exact (hT f).add (hS f) + +omit [DecidableEq X] [CompleteSpace H] in +theorem Pseudolocal.mul {T S : Operator X H} (hT : Pseudolocal T) (hS : Pseudolocal S) : + Pseudolocal (T * S) := by + intro f + have he : (T * S) * diagonalMultiplier (H := H) f - diagonalMultiplier (H := H) f * (T * S) = + T * (S * diagonalMultiplier (H := H) f - diagonalMultiplier (H := H) f * S) + + (T * diagonalMultiplier (H := H) f - diagonalMultiplier (H := H) f * T) * S := by + simp only [mul_sub, sub_mul, mul_assoc] + abel + rw [he] + exact ((hS f).clm_comp T).add ((hT f).comp_clm S) + +omit [DecidableEq X] [CompleteSpace H] in +theorem Pseudolocal.smul {T : Operator X H} (hT : Pseudolocal T) (z : ℂ) : + Pseudolocal (z • T) := by + intro f + have he : (z • T) * diagonalMultiplier (H := H) f - + diagonalMultiplier (H := H) f * (z • T) = + z • (T * diagonalMultiplier (H := H) f - diagonalMultiplier (H := H) f * T) := by + apply ContinuousLinearMap.ext + intro v + simp [map_smul, smul_sub] + rw [he] + exact (hT f).smul z + +omit [DecidableEq X] in +theorem pseudolocal_closed : IsClosed {T : Operator X H | Pseudolocal T} := by + simp only [Pseudolocal, Set.ofPred_forall] + apply isClosed_iInter + intro f + exact isClosed_setOfPred_isCompactOperator.preimage + ((continuous_id.mul continuous_const).sub (continuous_const.mul continuous_id)) + +def pseudolocalAlgebra : StarSubalgebra ℂ (Operator X H) where + carrier := {T | Pseudolocal T ∧ Pseudolocal (star T)} + zero_mem' := by + change Pseudolocal (0 : Operator X H) ∧ Pseudolocal (star (0 : Operator X H)) + rw [star_zero (Operator X H)] + constructor <;> intro f <;> simp only [zero_mul, mul_zero, sub_self] + all_goals exact isCompactOperator_zero + one_mem' := by + change Pseudolocal (1 : Operator X H) ∧ Pseudolocal (star (1 : Operator X H)) + rw [star_one (Operator X H)] + constructor <;> intro f <;> simp only [one_mul, mul_one, sub_self] + all_goals exact isCompactOperator_zero + add_mem' hT hS := ⟨hT.1.add hS.1, by simpa only [star_add] using hT.2.add hS.2⟩ + mul_mem' hT hS := ⟨hT.1.mul hS.1, by simpa only [star_mul] using hS.2.mul hT.2⟩ + algebraMap_mem' z := by + have hz (w : ℂ) : Pseudolocal (algebraMap ℂ (Operator X H) w) := by + intro f + rw [(Algebra.commutes w (diagonalMultiplier (H := H) f)), sub_self] + exact isCompactOperator_zero + refine ⟨hz z, ?_⟩ + have he : star (algebraMap ℂ (Operator X H) z) = algebraMap ℂ (Operator X H) (star z) := by + simp only [Algebra.algebraMap_eq_smul_one, star_smul, star_one] + rw [he] + exact hz (star z) + star_mem' hT := ⟨hT.2, by simpa only [star_star] using hT.1⟩ + +omit [DecidableEq X] in +theorem pseudolocalAlgebra_closed : + IsClosed (pseudolocalAlgebra (X := X) (H := H) : Set (Operator X H)) := + pseudolocal_closed.inter (pseudolocal_closed.preimage operator_star_continuous) + +variable [PseudoMetricSpace X] + +def StructureGenerator (T : Operator X H) : Prop := + (∃ r : ℝ, 0 ≤ r ∧ PropagationLE r T) ∧ Pseudolocal T ∧ Pseudolocal (star T) + +/-- The controlled pseudolocal algebra used to form the analytic-index quotient. -/ +def structureAlgebra : NonUnitalStarSubalgebra ℂ (Operator X H) := + (NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | StructureGenerator T}).topologicalClosure + +theorem structureAlgebra_pseudolocal {T : Operator X H} + (hT : T ∈ structureAlgebra (X := X) (H := H)) : Pseudolocal T := by + have hle : NonUnitalStarAlgebra.adjoin ℂ {S : Operator X H | StructureGenerator S} ≤ + (pseudolocalAlgebra (X := X) (H := H)).toNonUnitalStarSubalgebra := + NonUnitalStarAlgebra.adjoin_le (fun _ h => h.2) + exact (NonUnitalStarSubalgebra.topologicalClosure_minimal _ hle pseudolocalAlgebra_closed hT).1 + +variable [DiscreteTopology X] + +theorem roe_le_structureAlgebra + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) : + algebra (X := X) (H := H) ≤ structureAlgebra (X := X) (H := H) := by + apply NonUnitalStarSubalgebra.topologicalClosure_mono + apply NonUnitalStarAlgebra.adjoin_mono + intro T hT + refine ⟨hT.1, (generator_locallyCompact finiteBalls hT).pseudolocal, ?_⟩ + obtain ⟨⟨r, _, hp⟩, _, hc⟩ := hT + exact (locallyCompact_of_propagation finiteBalls hp.star hc).pseudolocal + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/PublishedInputReduction.lean b/lean/OAI/Topology/CoarseAssembly/PublishedInputReduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..9322926dfe0b68cf1e4396b76f7f535b52ad8cdb --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/PublishedInputReduction.lean @@ -0,0 +1,65 @@ +import OAI.Topology.CoarseAssembly.BoundaryConclusion +import OAI.Topology.CoarseAssembly.CompactHomotopy +import OAI.Topology.CoarseAssembly.PointCoefficient + +namespace OAI + +/-! # Discharging the compact-homotopy input + +The conditional theorem is preserved. This specialization removes its +homotopy hypothesis using the proved Fredholm-cycle homotopy construction. +The odd coefficient group of a point is now proved by explicit Fredholm +normalization; the circle, additivity, index and Kazhdan inputs remain. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +theorem compactFillingInput (hpoint : Subsingleton (LocallyFiniteK1 Unit)) : + PublishedCompactHomotopyInput where + homotopy f g h := by + obtain ⟨F⟩ := h + exact compact_homotopy_invariance f g F + point_odd_zero := hpoint + +local instance inputReductionMetric : MetricSpace VertexUnion := + vertexUnionMetric elementaryMoves chosenHolonomyUnit + +theorem bounded_geometry_counterexample_of_point_odd_zero (circle : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) + (hpoint : Subsingleton (LocallyFiniteK1 Unit)) (hfill : CountableAdditivityInput FilledDisc) + (index : PublishedBoundaryAssemblyInput) (hgap : PublishedKazhdanInput) : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ index.total.assembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective index.total.assembly ∧ + ¬ Function.Injective (index.total.assembly.toIntLinearMap.lTensor ℚ) := + bounded_geometry_counterexample circle hadd (compactFillingInput hpoint) hfill index hgap + +/-- The complete compact-filling input is now a theorem. -/ +theorem provedCompactFillingInput : PublishedCompactHomotopyInput := + compactFillingInput point_odd_zero + +/-- Main theorem after discharging compact homotopy invariance and the odd point coefficient. -/ +theorem bounded_geometry_counterexample_from_circle_index_gap (circle : PublishedCircleInput) + (hadd : CountableAdditivityInput CircleFamily) (hfill : CountableAdditivityInput FilledDisc) + (index : PublishedBoundaryAssemblyInput) (hgap : PublishedKazhdanInput) : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ index.total.assembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective index.total.assembly ∧ + ¬ Function.Injective (index.total.assembly.toIntLinearMap.lTensor ℚ) := + bounded_geometry_counterexample circle hadd provedCompactFillingInput hfill index hgap + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RawCycleIndex.lean b/lean/OAI/Topology/CoarseAssembly/RawCycleIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..083b84d87133e9c5ad2c220aa6b461fedcb4ea45 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RawCycleIndex.lean @@ -0,0 +1,102 @@ +import OAI.Topology.CoarseAssembly.ExplicitCutDown +import OAI.Topology.CoarseAssembly.EssentialToeplitz +import OAI.Topology.CoarseAssembly.RepresentedIndex + +namespace OAI + +/-! # A Fredholm index defined on every odd cycle + +The operator uses the explicit self-adjoint cut-down and varies continuously +along any Fredholm-module homotopy. Its definition makes no spectral choices. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +def rawCycleToeplitz (c : OddCycle A) (u : A) : End c.space := + toeplitzCompression (H := c.space) + (positiveProjection (H := c.space) + (symmetricCutDown (H := c.space) (c.representation 1) c.operator)) (unitaryExtension c u) + +def rawCycleIndex (c : OddCycle A) (u : A) : ℤ := (rawCycleToeplitz c u).toLinearMap.index + +theorem rawCycleToeplitz_compact_defects (c : OddCycle A) (u : A) + (hul : star u * u = 1) (hur : u * star u = 1) : + IsCompactOperator (star (rawCycleToeplitz c u) * rawCycleToeplitz c u - 1 : End c.space) ∧ + IsCompactOperator (rawCycleToeplitz c u * star (rawCycleToeplitz c u) - 1 : End c.space) := by + generalize hT : rawCycleToeplitz c u = T + let F : End c.space := symmetricCutDown (c.representation 1) c.operator + have hF : IsSelfAdjoint F := symmetricCutDown_selfAdjoint _ _ (representation_unit_selfAdjoint c) + have hFP : Commute F (c.representation 1) := + commute_of_complement F _ hF (representation_unit_selfAdjoint c) + (symmetricCutDown_complement _ _ (representation_unit_selfAdjoint c) (representation_unit_sq c)) + have hc : IsCompactOperator (F * c.representation u - c.representation u * F : End c.space) := by + have h := c.cutDown.commutator_compact u + change IsCompactOperator ((c.operator + representedCorrection c) * c.representation u - + c.representation u * (c.operator + representedCorrection c) : End c.space) at h + have he : c.operator + representedCorrection c = F := by unfold representedCorrection; dsimp [F]; abel + rwa [he] at h + have hU : IsCompactOperator (F * unitaryExtension c u - unitaryExtension c u * F : End c.space) := by + have he : F * unitaryExtension c u - unitaryExtension c u * F = + F * c.representation u - c.representation u * F := by + simp only [unitaryExtension, mul_add, add_mul, mul_sub, sub_mul, mul_one, one_mul] + rw [hFP.eq] + abel + rw [he] + exact hc + obtain ⟨hUl, hUr⟩ := unitaryExtension_unitary c u hul hur + have hFF : IsCompactOperator (F * F - 1 : End c.space) := symmetricCutDown_square_compact c + have result := essentialToeplitz_compact_defects (H := c.space) F (unitaryExtension c u) + hF hFF hUl hUr hU + change toeplitzCompression (positiveProjection F) (unitaryExtension c u) = T at hT + rw [hT] at result + exact result + + +theorem rawCycleToeplitz_fredholm (c : OddCycle A) (u : A) + (hul : star u * u = 1) (hur : u * star u = 1) : (rawCycleToeplitz c u).IsFredholm := by + obtain ⟨hl, hr⟩ := rawCycleToeplitz_compact_defects c u hul hur + exact isFredholm_of_compact_essential_unitary _ hl hr + +theorem rawCycleIndex_homotopy (h : OddHomotopy A) (u : A) + (hul : star u * u = 1) (hur : u * star u = 1) : + rawCycleIndex (h.eval start) u = rawCycleIndex (h.eval finish) u := by + apply fredholmIndex_homotopy (fun t => rawCycleToeplitz (h.eval t) u) + · have hP := h.continuous_representation (1 : A) + have hB := (hP.mul h.continuous_operator).mul hP + have hF : Continuous (fun t => symmetricCutDown (h.representation t 1) (h.operator t)) := + ((hB.add hB.star).const_smul (1 / 2 : ℝ)).add (continuous_const.sub hP) + have hpos : Continuous (fun t => positiveProjection + (symmetricCutDown (h.representation t 1) (h.operator t))) := + (hF.add continuous_const).const_smul (1 / 2 : ℝ) + have hU : Continuous (fun t => h.representation t u + (1 - h.representation t 1)) := + (h.continuous_representation u).add (continuous_const.sub hP) + change Continuous (fun t => positiveProjection + (symmetricCutDown (h.representation t 1) (h.operator t)) * + (h.representation t u + (1 - h.representation t 1)) * + positiveProjection (symmetricCutDown (h.representation t 1) (h.operator t)) + + (1 - positiveProjection (symmetricCutDown (h.representation t 1) (h.operator t)))) + exact ((hpos.mul hU).mul hpos).add (continuous_const.sub hpos) + · intro t + exact rawCycleToeplitz_fredholm (h.eval t) u hul hur + +variable {B : Type} [CStarAlgebra B] + +theorem rawCycleIndex_precomp (c : OddCycle A) (φ : B →⋆ₙₐ[ℂ] A) + (hφ : φ 1 = 1) (u : B) : rawCycleIndex (c.precomp φ) u = rawCycleIndex c (φ u) := by + have he : rawCycleToeplitz (c.precomp φ) u = rawCycleToeplitz c (φ u) := by + change toeplitzCompression (positiveProjection (symmetricCutDown + (c.representation (φ 1)) c.operator)) + (c.representation (φ u) + (1 - c.representation (φ 1))) = _ + rw [hφ] + rfl + exact congrArg (fun T : End c.space => T.toLinearMap.index) he + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RealNormalization.lean b/lean/OAI/Topology/CoarseAssembly/RealNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..aadb25ae2bbbdb56459dfcf6758e32baa6bf4c35 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RealNormalization.lean @@ -0,0 +1,36 @@ +import Mathlib.Analysis.SpecialFunctions.Pow.Real + +namespace OAI + +/-! # Scalar functions for involutive Fredholm normalization -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +def inverseSqrtCorrection (t : ℝ) : ℝ := (Real.sqrt (t + 1))⁻¹ - 1 + +@[simp] theorem inverseSqrtCorrection_zero : inverseSqrtCorrection 0 = 0 := by + simp [inverseSqrtCorrection] + +theorem inverseSqrtCorrection_continuousAt {t : ℝ} (ht : 0 < t + 1) : + ContinuousAt inverseSqrtCorrection t := by + have hs : Real.sqrt (t + 1) ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr ht) + exact ((Real.continuous_sqrt.comp (continuous_id.add continuous_const)).continuousAt.inv₀ hs).sub + continuousAt_const + +def normalizedReal (x : ℝ) : ℝ := x + x * inverseSqrtCorrection (x ^ 2 - 1) + +theorem normalizedReal_eq (x : ℝ) : normalizedReal x = x * |x|⁻¹ := by + simp only [normalizedReal, inverseSqrtCorrection, sub_add_cancel, Real.sqrt_sq_eq_abs] + ring + +theorem normalizedReal_sq {x : ℝ} (hx : x ≠ 0) : normalizedReal x ^ 2 = 1 := by + rw [normalizedReal_eq, mul_pow, inv_pow, sq_abs] + exact mul_inv_cancel₀ (pow_ne_zero 2 hx) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RegularConstants.lean b/lean/OAI/Topology/CoarseAssembly/RegularConstants.lean new file mode 100644 index 0000000000000000000000000000000000000000..764f57964b492d6faef78344aa6bc002ef404873 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RegularConstants.lean @@ -0,0 +1,80 @@ +import OAI.Topology.CoarseAssembly.AveragingEnergy + +namespace OAI + +/-! # Invariants of the actual amplified finite regular representation -/ + +noncomputable section + +namespace CoarseAssembly + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] +variable (Q : Type*) [Fintype Q] [Group Q] + +/-- Left translations form a unitary representation, with the ample +coefficient space unchanged. -/ +def leftTranslationHom : Q →* (lp (fun _ : Q => H) 2 ≃ₗᵢ[ℂ] lp (fun _ : Q => H) 2) where + toFun := leftTranslation Q + map_one' := by + ext x q + change x ((1 : Q)⁻¹ * q) = x q + simp + map_mul' a b := by + ext x q + change x ((a * b)⁻¹ * q) = x (b⁻¹ * (a⁻¹ * q)) + simp only [mul_inv_rev, mul_assoc] + +theorem regular_fixed_projection (x : lp (fun _ : Q => H) 2) + (hfix : ∀ g : Q, leftTranslation Q g x = x) : constantProjection Q x = x := by + have hcoord (q : Q) : x q = x 1 := by + have h := congrArg (fun v : lp (fun _ : Q => H) 2 => v q) (hfix q) + change x (q⁻¹ * q) = x q at h + simpa using h.symm + have hr : (fiberNormalization Q : ℂ) ≠ 0 := by + have hs := fiberNormalization_sq Q + have hn : fiberNormalization Q ≠ 0 := by intro hz; rw [hz] at hs; norm_num at hs + exact_mod_cast hn + let a : H := (fiberNormalization Q : ℂ)⁻¹ • x 1 + have hx : x = fiberConstant Q a := by + apply lp.ext + funext q + rw [fiberConstant_apply] + change x q = (fiberNormalization Q : ℂ) • ((fiberNormalization Q : ℂ)⁻¹ • x 1) + rw [smul_smul, mul_inv_cancel₀ hr, one_smul] + exact hcoord q + rw [hx] + change (fiberConstantIsometry (H := H) Q) + ((fiberConstantIsometry (H := H) Q).toContinuousLinearMap.adjoint + ((fiberConstantIsometry (H := H) Q) a)) = _ + rw [adjoint_apply_isometry] + rfl + +theorem regular_fixed_iff_projection (x : lp (fun _ : Q => H) 2) : + (∀ g : Q, leftTranslation Q g x = x) ↔ constantProjection Q x = x := by + refine ⟨regular_fixed_projection Q x, ?_⟩ + intro hx g + have h := DFunLike.congr_fun (leftTranslation_projection (H := H) Q g) x + change leftTranslation Q g (constantProjection Q x) = constantProjection Q x at h + rwa [hx] at h + +/-- The kernel of the constant projection is orthogonal to every invariant +vector of the regular representation. -/ +theorem inner_eq_zero_of_projection_zero (x y : lp (fun _ : Q => H) 2) + (hx : constantProjection Q x = 0) (hy : constantProjection Q y = y) : + inner ℂ y x = 0 := by + let U := (fiberConstantIsometry (H := H) Q).toContinuousLinearMap + have hax : U.adjoint x = 0 := by + apply (fiberConstantIsometry (H := H) Q).injective + change constantProjection Q x = (fiberConstantIsometry (H := H) Q) 0 + simpa only [map_zero] using hx + calc + inner ℂ y x = inner ℂ (constantProjection Q y) x := by rw [hy] + _ = inner ℂ (U.adjoint y) (U.adjoint x) := + (ContinuousLinearMap.adjoint_inner_right U (U.adjoint y) x).symm + _ = 0 := by rw [hax, inner_zero_right] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RegularizedCoarsening.lean b/lean/OAI/Topology/CoarseAssembly/RegularizedCoarsening.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e2188bafa2226da469339a56c4158a8b1fca8aa --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RegularizedCoarsening.lean @@ -0,0 +1,55 @@ +import OAI.Topology.CoarseAssembly.RegularizedPrecomposition +import OAI.Topology.CoarseAssembly.RegularizedRipsFamily +import OAI.Topology.CoarseAssembly.ControlledRipsCoarsening + +namespace OAI + +/-! # Explicit regularization is compatible with Rips coarsening -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r s : ℝ} + +omit [∀ i, DecidableEq (Q i)] in +theorem ControlledCycleFamily.eq_of_cycles_bound (c d : ControlledCycleFamily Q r) + (hc : c.cycle = d.cycle) (hb : c.bound = d.bound) : c = d := by + cases c + cases d + cases hc + cases hb + rfl + +omit [∀ i, DecidableEq (Q i)] in +theorem regularizedFamily_coarsen (hrs : r ≤ s) + (c : ∀ i, OddCycle C(Point (Q i) r, ℂ)) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) : + regularizedFamily (fun i => coarsenedCycle hrs (c i)) + (fun i => (χ i).comp (scaleFunctionHom hrs)) = (regularizedFamily c χ).coarsen hrs := by + apply ControlledCycleFamily.eq_of_cycles_bound _ _ _ rfl + funext i + exact (c i).regularize_precomp_eq (scaleFunctionHom hrs) (χ i) + +theorem regularizedFamily_boundary_coarsen (o : ∀ i, Q i) + (hr : 0 ≤ r) (hs : 0 ≤ s) (hrs : r ≤ s) + (c : ∀ i, OddCycle C(Point (Q i) r, ℂ)) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) : + (regularizedFamily (fun i => coarsenedCycle hrs (c i)) + (fun i => (χ i).comp (scaleFunctionHom hrs))).boundary o hs = + (regularizedFamily c χ).boundary o hr := by + have h1 := congrArg (fun d : ControlledCycleFamily Q s => d.boundary o hs) + (regularizedFamily_coarsen hrs c χ) + exact h1.trans (ampleRipsFamilyBoundary_scale hrs o hr hs + (regularizedFamily c χ).cycle (regularizedFamily c χ).unital + (regularizedFamily c χ).selfAdjoint (regularizedFamily c χ).bound + (regularizedFamily c χ).bound_nonneg (regularizedFamily c χ).norm_le) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RegularizedCycle.lean b/lean/OAI/Topology/CoarseAssembly/RegularizedCycle.lean new file mode 100644 index 0000000000000000000000000000000000000000..34ec11d037b89ff901eeb7a656148207923e218a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RegularizedCycle.lean @@ -0,0 +1,40 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ContinuousUnitalization + +namespace OAI + +/-! # Explicit norm-one representatives compatible with analytic homotopies -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem OddCycle.regularize_class (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + cycleClass A (c.regularize χ) = cycleClass A c := + ((c.unitalSelfAdjoint χ).bounded_class (c.unitalSelfAdjoint_unital χ) + (c.unitalSelfAdjoint_selfAdjoint χ)).trans (c.unitalSelfAdjoint_class χ) + +theorem OddCycle.regularize_unital (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.regularize χ).representation 1 = 1 := c.unitalSelfAdjoint_unital χ + +theorem OddCycle.regularize_selfAdjoint (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + IsSelfAdjoint (c.regularize χ).operator := boundedTransform_selfAdjoint _ _ + +theorem OddCycle.regularize_norm_le (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + ‖(c.regularize χ).operator‖ ≤ 1 := boundedTransform_norm_le _ _ + +def OddHomotopy.regularize (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) : OddHomotopy A := + (h.unitalSelfAdjoint χ).bounded + (fun t => (h.eval t).unitalSelfAdjoint_unital χ) + (fun t => (h.eval t).unitalSelfAdjoint_selfAdjoint χ) + +@[simp] theorem OddHomotopy.regularize_eval (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) (t : Interval) : + (h.regularize χ).eval t = (h.eval t).regularize χ := rfl + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RegularizedPrecomposition.lean b/lean/OAI/Topology/CoarseAssembly/RegularizedPrecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..e8531a082165918566332a32afcc1d2ec18783e0 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RegularizedPrecomposition.lean @@ -0,0 +1,83 @@ +import OAI.Topology.CoarseAssembly.CycleUnitaryNormalization +import OAI.Topology.CoarseAssembly.RipsScaleCompatibility + +namespace OAI + +/-! # Unital precomposition commutes with continuous regularization -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A B : Type} [CStarAlgebra A] [CStarAlgebra B] + +theorem OddCycle.eq_of_data (c d : OddCycle A) (hs : c.space = d.space) + (hr : HEq c.representation d.representation) (ho : HEq c.operator d.operator) : c = d := by + cases c + cases d + cases hs + cases hr + cases ho + rfl + +theorem conjugation_refl {H : HilbertSpace} (T : End H) : + operatorConjugation (LinearIsometryEquiv.refl ℂ H).toLinearIsometry T = T := by + have he : (LinearIsometryEquiv.refl ℂ H).toLinearIsometry.toContinuousLinearMap = + (1 : End H) := rfl + unfold operatorConjugation + rw [he] + change (ContinuousLinearMap.id ℂ H).comp (T.comp (ContinuousLinearMap.id ℂ H).adjoint) = T + rw [ContinuousLinearMap.adjoint_id] + rfl + +def OddCycle.regularize_precomp (c : OddCycle A) (φ : B →⋆ₐ[ℂ] A) (χ : A →⋆ₐ[ℂ] ℂ) : + ((c.precomp φ.toNonUnitalStarAlgHom).regularize (χ.comp φ)).UnitaryEquivalent + ((c.regularize χ).precomp φ.toNonUnitalStarAlgHom) where + unitary := LinearIsometryEquiv.refl ℂ c.space + representation_eq b := by + change (c.regularize χ).representation (φ b) = + operatorConjugation (LinearIsometryEquiv.refl ℂ c.space).toLinearIsometry + (show End c.space from ((c.precomp φ.toNonUnitalStarAlgHom).regularize (χ.comp φ)).representation b) + rw [conjugation_refl] + change c.representation (φ b) + χ (φ b) • (1 - c.representation 1) = + c.representation (φ b) + χ (φ b) • (1 - c.representation (φ 1)) + rw [map_one φ] + operator_eq := by + change (c.regularize χ).operator = + operatorConjugation (LinearIsometryEquiv.refl ℂ c.space).toLinearIsometry + (show End c.space from ((c.precomp φ.toNonUnitalStarAlgHom).regularize (χ.comp φ)).operator) + rw [conjugation_refl] + have hop : + (show End c.space from ((c.precomp φ.toNonUnitalStarAlgHom).unitalSelfAdjoint (χ.comp φ)).operator) = + (c.unitalSelfAdjoint χ).operator := by + rw [OddCycle.unitalSelfAdjoint_operator, OddCycle.unitalSelfAdjoint_operator] + change symmetricCutDown (c.representation (φ 1)) c.operator = + symmetricCutDown (c.representation 1) c.operator + rw [map_one φ] + exact (boundedTransform_congr hop _ _).symm + +theorem OddCycle.regularize_precomp_eq (c : OddCycle A) (φ : B →⋆ₐ[ℂ] A) (χ : A →⋆ₐ[ℂ] ℂ) : + (c.precomp φ.toNonUnitalStarAlgHom).regularize (χ.comp φ) = + (c.regularize χ).precomp φ.toNonUnitalStarAlgHom := by + refine OddCycle.eq_of_data + ((c.precomp φ.toNonUnitalStarAlgHom).regularize (χ.comp φ)) + ((c.regularize χ).precomp φ.toNonUnitalStarAlgHom) rfl ?_ ?_ + · apply heq_of_eq + apply DFunLike.ext + intro b + change c.representation (φ b) + χ (φ b) • (1 - c.representation (φ 1)) = + c.representation (φ b) + χ (φ b) • (1 - c.representation 1) + rw [map_one φ] + · apply heq_of_eq + have h := (c.regularize_precomp φ χ).operator_eq + change (c.regularize χ).operator = + operatorConjugation (LinearIsometryEquiv.refl ℂ c.space).toLinearIsometry + (show End c.space from ((c.precomp φ.toNonUnitalStarAlgHom).regularize (χ.comp φ)).operator) at h + rw [conjugation_refl] at h + exact h.symm + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RegularizedRipsFamily.lean b/lean/OAI/Topology/CoarseAssembly/RegularizedRipsFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..8890199bbad8d4f554c2dfafad22558acf884ce9 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RegularizedRipsFamily.lean @@ -0,0 +1,37 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RegularizedCycle +import OAI.Topology.CoarseAssembly.UnrestrictedBoundedHomotopy + +namespace OAI + +/-! # Whole-union Roe boundaries of arbitrary families of analytic cycles -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +theorem regularizedFamily_homotopy + (h : ∀ i, OddHomotopy C(Point (Q i) r, ℂ)) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (o : ∀ i, Q i) (hr : 0 ≤ r) : + (regularizedFamily (fun i => (h i).eval start) χ).boundary o hr = + (regularizedFamily (fun i => (h i).eval finish) χ).boundary o hr := by + let H : BoundedFamilyHomotopy Q r := { + homotopy := fun i => (h i).regularize (χ i) + unital := fun t i => ((h i).eval t).regularize_unital (χ i) + selfAdjoint := fun t i => ((h i).eval t).regularize_selfAdjoint (χ i) + bound := 1 + one_le_bound := le_rfl + norm_le := fun t i => ((h i).eval t).regularize_norm_le (χ i) } + exact H.endpoint_boundary_eq χ o hr + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RegularizedRipsRelations.lean b/lean/OAI/Topology/CoarseAssembly/RegularizedRipsRelations.lean new file mode 100644 index 0000000000000000000000000000000000000000..5579880678ed28329eaa4fce103a380bfeff0030 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RegularizedRipsRelations.lean @@ -0,0 +1,56 @@ +import OAI.Topology.CoarseAssembly.RegularizedRipsFamily +import OAI.Topology.CoarseAssembly.CycleDirectSumNormalization +import OAI.Topology.CoarseAssembly.DegenerateRegularization + +namespace OAI + +/-! # The regularized whole-union boundary respects all analytic cycle relations -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +theorem regularizedFamily_unitary + (c d : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (h : ∀ i, (c i).UnitaryEquivalent (d i)) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) (o : ∀ i, Q i) (hr : 0 ≤ r) : + (regularizedFamily c χ).boundary o hr = (regularizedFamily d χ).boundary o hr := by + let := separatedMetric o + let C := regularizedFamily c χ + let D := regularizedFamily d χ + exact ampleRipsFamilyBoundary_unitary o r hr C.cycle D.cycle + (fun i => (h i).regularize (χ i)) C.unital D.unital C.selfAdjoint D.selfAdjoint + C.bound D.bound C.bound_nonneg D.bound_nonneg C.norm_le D.norm_le + +theorem regularizedFamily_directSum + (c d e : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (h : ∀ i, (c i).IsDirectSum (d i) (e i)) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) (o : ∀ i, Q i) (hr : 0 ≤ r) : + (regularizedFamily e χ).boundary o hr = + (regularizedFamily c χ).boundary o hr + (regularizedFamily d χ).boundary o hr := by + let := separatedMetric o + let C := regularizedFamily c χ + let D := regularizedFamily d χ + let E := regularizedFamily e χ + exact ampleRipsFamilyBoundary_directSum o r hr C.cycle D.cycle E.cycle + (fun i => (h i).regularize (χ i)) C.unital D.unital E.unital + C.selfAdjoint D.selfAdjoint E.selfAdjoint C.bound D.bound E.bound + C.bound_nonneg D.bound_nonneg E.bound_nonneg C.norm_le D.norm_le E.norm_le + +theorem regularizedFamily_degenerate + (c : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (h : ∀ i, (c i).Degenerate) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) (o : ∀ i, Q i) (hr : 0 ≤ r) : + (regularizedFamily c χ).boundary o hr = 0 := by + let := separatedMetric o + let C := regularizedFamily c χ + exact ampleRipsFamilyBoundary_degenerate o r hr C.cycle C.unital C.selfAdjoint + C.bound C.bound_nonneg C.norm_le (fun i => (h i).regularize (χ i)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/RelativeHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..77152e66bdafe3dfc8e7f14cac48a59af0e22b1f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeHomotopy.lean @@ -0,0 +1,52 @@ +import OAI.Topology.CoarseAssembly.RelativeUnitary + +namespace OAI + +/-! # Homotopy invariance of relative unitary classes -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +open Analytic + +variable {A P : Type*} [CStarAlgebra A] [TopologicalSpace P] +variable (S : NonUnitalStarSubalgebra ℂ A) [hS : IsClosed (S : Set A)] + +theorem continuous_relativeUnitary (u : P → unitary A) + (hu : ∀ p, (u p : A) - 1 ∈ S) (hcont : Continuous (fun p => (u p : A))) : + Continuous (fun p => (relativeUnitary S (u p) (hu p) : Unitization ℂ S)) := by + have hr : Continuous (fun p => relativePart S (u p) (hu p)) := + (hcont.sub continuous_const).subtype_mk hu + exact continuous_const.add (Unitization.continuous_inr.comp hr) + +theorem continuous_relativeMatrix (u : P → unitary A) + (hu : ∀ p, (u p : A) - 1 ∈ S) (hcont : Continuous (fun p => (u p : A))) : + Continuous (fun p => relativeMatrix S (u p) (hu p)) := by + have hv := continuous_relativeUnitary S u hu hcont + have hw : Continuous (fun p => Unitary.toUnits (relativeUnitary S (u p) (hu p))) := by + apply Units.continuous_iff.mpr + exact ⟨hv, hv.star⟩ + apply Continuous.comp _ hw + apply Continuous.units_map + apply continuous_pi + intro i + apply continuous_pi + intro j + have hij : i = j := Subsingleton.elim _ _ + change Continuous (fun x : Unitization ℂ S => if i = j then x else 0) + simp only [hij, ite_true] + convert! (continuous_id : Continuous (fun x : Unitization ℂ S => x)) + +theorem relativeClass_homotopy (u : Interval → unitary A) + (hu : ∀ t, (u t : A) - 1 ∈ S) (hcont : Continuous (fun t => (u t : A))) : + relativeClass S (u start) (hu start) = relativeClass S (u finish) (hu finish) := by + apply Subtype.ext + exact TopologicalK1.matrixClass_homotopy (fun t => relativeMatrix S (u t) (hu t)) + (continuous_relativeMatrix S u hu hcont) + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeIsometry.lean b/lean/OAI/Topology/CoarseAssembly/RelativeIsometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..ae8dad1e9ecd6cfde39c43ec873c0632f51347ef --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeIsometry.lean @@ -0,0 +1,71 @@ +import OAI.Topology.CoarseAssembly.RelativeTwoConjugation +import OAI.Topology.CoarseAssembly.IsometryUnitary + +namespace OAI + +/-! # Isometric stabilization preserves the actual relative K₁ class -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +open Analytic + +variable {A R : Type*} [CStarAlgebra A] [CStarAlgebra R] +variable (S : NonUnitalStarSubalgebra ℂ R) [hS : IsClosed (S : Set R)] + +omit hS in +theorem isometryExtensionUnitary_relative (φ : A →⋆ₐ[ℂ] R) + (hφ : ∀ a b, b ∈ S → φ a * b ∈ S ∧ b * φ a ∈ S) + (V : A) (hV : star V * V = 1) (u : unitary A) + (hu : φ (u : A) - 1 ∈ S) : + φ (isometryExtensionUnitary V hV u : A) - 1 ∈ S := by + rw [isometryExtensionUnitary_val, map_add, map_one, add_sub_cancel_left, + map_mul, map_mul, map_sub, map_one] + exact (hφ (star V) _ ((hφ V _ hu).1)).2 + +/-- The dilation homotopy proves equality in K₁, not just equality in a quotient of operators. -/ +theorem relativeClass_isometry (φ : A →⋆ₐ[ℂ] R) (hφc : Continuous φ) + (hφ : ∀ a b, b ∈ S → φ a * b ∈ S ∧ b * φ a ∈ S) + (V : A) (hV : star V * V = 1) (u : unitary A) + (hu : φ (u : A) - 1 ∈ S) : + relativeClass S (Unitary.map (StarMonoidHom.ofClass φ) u) hu = + relativeClass S (Unitary.map (StarMonoidHom.ofClass φ) (isometryExtensionUnitary V hV u)) + (isometryExtensionUnitary_relative S φ hφ V hV u hu) := by + let W := isometryDilationPath V hV + let v := Unitary.map (StarMonoidHom.ofClass φ) u + let e := Unitary.map (StarMonoidHom.ofClass φ) (isometryExtensionUnitary V hV u) + have hv : (v : R) - 1 ∈ S := hu + have he : (e : R) - 1 ∈ S := isometryExtensionUnitary_relative S φ hφ V hV u hu + have h0 : conjugatedTwoUnitary (mapTwoUnitary φ (W start)) (diagonalTwoUnitary 1 v) = + diagonalTwoUnitary 1 v := by + change conjugatedTwoUnitary (mapTwoUnitary φ (isometryDilationPath V hV start)) _ = _ + rw [isometryDilationPath_start, mapTwoUnitary_one] + simp [conjugatedTwoUnitary] + have hd : conjugatedTwoUnitary (W finish) (diagonalTwoUnitary 1 u) = + diagonalTwoUnitary (isometryExtensionUnitary V hV u) 1 := by + apply Subtype.ext + change (W finish).val * (diagonalTwoUnitary 1 u).val * star (W finish).val = _ + dsimp only [W] + rw [isometryDilationPath_finish] + exact isometryDilation_conjugates_unitary V hV u + have h1 : conjugatedTwoUnitary (mapTwoUnitary φ (W finish)) (diagonalTwoUnitary 1 v) = + diagonalTwoUnitary e 1 := by + have hm := congrArg (mapTwoUnitary φ) hd + rw [mapTwoUnitary_conjugate, mapTwoUnitary_diagonal, mapTwoUnitary_diagonal] at hm + simpa only [map_one] using hm + have hz : ((1 : unitary R) : R) - 1 ∈ S := by simp + have h := relativeTwoClass_conjugationPath S φ hφc hφ W + (isometryDilationPath_continuous V hV) (diagonalTwoUnitary 1 v) + (diagonalTwoUnitary_relative S 1 v hz hv) + simp only [h0, h1] at h + have hleft := relativeTwoClass_diagonal S 1 v hz hv + have hright := relativeTwoClass_diagonal S e 1 he hz + rw [hleft, hright, relativeClass_one S hz, zero_add, add_zero] at h + exact h + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeMultiplication.lean b/lean/OAI/Topology/CoarseAssembly/RelativeMultiplication.lean new file mode 100644 index 0000000000000000000000000000000000000000..92fc5c5491a60f9f4adadd3002739f0b86aa2b6f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeMultiplication.lean @@ -0,0 +1,64 @@ +import OAI.Topology.CoarseAssembly.RelativeUnitary + +namespace OAI + +/-! # Multiplication of relative unitaries adds their actual K₁ classes -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {A : Type*} [CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) + +theorem relative_mul_mem (u v : unitary A) + (hu : (u : A) - 1 ∈ S) (hv : (v : A) - 1 ∈ S) : + ((u * v : unitary A) : A) - 1 ∈ S := by + have he : (u : A) * (v : A) - 1 = + ((u : A) - 1) + ((v : A) - 1) + ((u : A) - 1) * ((v : A) - 1) := by + noncomm_ring + change (u : A) * (v : A) - 1 ∈ S + rw [he] + exact S.add_mem (S.add_mem hu hv) (S.mul_mem hu hv) + +theorem relativePart_mul (u v : unitary A) + (hu : (u : A) - 1 ∈ S) (hv : (v : A) - 1 ∈ S) : + relativePart S (u * v) (relative_mul_mem S u v hu hv) = + relativePart S u hu + relativePart S v hv + relativePart S u hu * relativePart S v hv := by + apply Subtype.ext + change (u : A) * (v : A) - 1 = _ + change (u : A) * (v : A) - 1 = + ((u : A) - 1) + ((v : A) - 1) + ((u : A) - 1) * ((v : A) - 1) + noncomm_ring + +theorem relativeUnitary_mul (u v : unitary A) + (hu : (u : A) - 1 ∈ S) (hv : (v : A) - 1 ∈ S) : + relativeUnitary S (u * v) (relative_mul_mem S u v hu hv) = + relativeUnitary S u hu * relativeUnitary S v hv := by + apply Subtype.ext + change 1 + (relativePart S (u * v) (relative_mul_mem S u v hu hv) : Unitization ℂ S) = + (1 + (relativePart S u hu : Unitization ℂ S)) * + (1 + (relativePart S v hv : Unitization ℂ S)) + rw [relativePart_mul S u v hu hv, Unitization.inr_add, Unitization.inr_add, Unitization.inr_mul] + noncomm_ring + +variable [hS : IsClosed (S : Set A)] + +theorem relativeClass_mul (u v : unitary A) + (hu : (u : A) - 1 ∈ S) (hv : (v : A) - 1 ∈ S) : + relativeClass S (u * v) (relative_mul_mem S u v hu hv) = + relativeClass S u hu + relativeClass S v hv := by + have hm : relativeMatrix S (u * v) (relative_mul_mem S u v hu hv) = + relativeMatrix S u hu * relativeMatrix S v hv := by + unfold relativeMatrix + rw [relativeUnitary_mul, map_mul, map_mul] + apply Subtype.ext + change TopologicalK1.matrixClass (Unitization ℂ S) + (relativeMatrix S (u * v) _) = _ + rw [hm, TopologicalK1.matrixClass_mul] + rfl + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeNaturality.lean b/lean/OAI/Topology/CoarseAssembly/RelativeNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..d0f72e3fdea52efb3f7c2393dfd2f8e349a676fe --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeNaturality.lean @@ -0,0 +1,39 @@ +import OAI.Topology.CoarseAssembly.RelativeUnitary + +namespace OAI + +/-! # Naturality of the relative-unitary K₁ representative -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] + (S : NonUnitalStarSubalgebra ℂ A) (T : NonUnitalStarSubalgebra ℂ B) + [hS : IsClosed (S : Set A)] [hT : IsClosed (T : Set B)] + +theorem map_relativeClass (φ : S →⋆ₙₐ[ℂ] T) + (u : unitary A) (v : unitary B) (hu : (u : A) - 1 ∈ S) (hv : (v : B) - 1 ∈ T) + (h : φ (relativePart S u hu) = relativePart T v hv) : + map φ (relativeClass S u hu) = relativeClass T v hv := by + apply Subtype.ext + change unitizationMap φ (TopologicalK1.matrixClass (Unitization ℂ S) + (relativeMatrix S u hu)) = + TopologicalK1.matrixClass (Unitization ℂ T) (relativeMatrix T v hv) + rw [unitizationMap_matrixClass] + congr 1 + apply Units.ext + apply Matrix.ext + intro i j + change Unitization.starMap φ + (Matrix.scalar (Fin 1) (1 + (relativePart S u hu : Unitization ℂ S)) i j) = + Matrix.scalar (Fin 1) (1 + (relativePart T v hv : Unitization ℂ T)) i j + have hij : i = j := Subsingleton.elim _ _ + simp only [Matrix.scalar_apply, hij, Matrix.diagonal_apply_eq] + rw [map_add, map_one, Unitization.starMap_inr, h] + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeNearby.lean b/lean/OAI/Topology/CoarseAssembly/RelativeNearby.lean new file mode 100644 index 0000000000000000000000000000000000000000..e399a7b32b44073401fc4f2d9e09d6532e498e93 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeNearby.lean @@ -0,0 +1,47 @@ +import OAI.Topology.CoarseAssembly.K1Nearby +import OAI.Topology.CoarseAssembly.RelativeUnitary + +namespace OAI + +/-! # Nearby relative unitaries have the same actual Roe K₁ class -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {A : Type*} [CStarAlgebra A] + (S : NonUnitalStarSubalgebra ℂ A) [hS : IsClosed (S : Set A)] + +theorem relativeUnitary_sub_norm (u v : unitary A) + (hu : (u : A) - 1 ∈ S) (hv : (v : A) - 1 ∈ S) : + ‖(relativeUnitary S v hv : Unitization ℂ S) - relativeUnitary S u hu‖ = ‖(v : A) - u‖ := by + have he : (relativeUnitary S v hv : Unitization ℂ S) - relativeUnitary S u hu = + ((relativePart S v hv - relativePart S u hu : S) : Unitization ℂ S) := by + rw [Unitization.inr_sub, relativeUnitary_val, relativeUnitary_val] + abel + rw [he, Unitization.norm_inr] + change ‖((v : A) - 1) - ((u : A) - 1)‖ = ‖(v : A) - u‖ + congr 1 + abel + +theorem relativeClass_eq_of_nearby (u v : unitary A) + (hu : (u : A) - 1 ∈ S) (hv : (v : A) - 1 ∈ S) + (h : ‖(v : A) - u‖ < 1) : relativeClass S u hu = relativeClass S v hv := by + let u' := relativeUnitary S u hu + let v' := relativeUnitary S v hv + have hn : ‖(v' : Unitization ℂ S) - u'‖ < 1 := by + rw [relativeUnitary_sub_norm] + exact h + have hi : ‖(↑(Unitary.toUnits u')⁻¹ : Unitization ℂ S)‖ = 1 := by + change ‖star (u' : Unitization ℂ S)‖ = 1 + rw [norm_star] + exact CStarRing.norm_coe_unitary u' + apply Subtype.ext + apply TopologicalK1.matrixClass_scalar_eq_of_nearby (Unitary.toUnits u') (Unitary.toUnits v') + simpa only [hi, inv_one, Unitary.val_toUnits_apply] using hn + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativePartialIsometry.lean b/lean/OAI/Topology/CoarseAssembly/RelativePartialIsometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..255d61459c7d047c2d55c71b78532404eaf8e2ad --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativePartialIsometry.lean @@ -0,0 +1,76 @@ +import OAI.Topology.CoarseAssembly.RelativeTwoConjugation +import OAI.Topology.CoarseAssembly.PartialIsometryDilation + +namespace OAI + +/-! # Relative K₁ classes agree under equivalence of their supported corners -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +open Analytic + +variable {A R : Type*} [CStarAlgebra A] [CStarAlgebra R] + +theorem partialIsometryDilation_conjugates_unitary + (T : A) (hT : T * star T * T = T) (u v : unitary A) + (hleft : (star T * T) * ((u : A) - 1) = (u : A) - 1) + (hright : ((u : A) - 1) * (star T * T) = (u : A) - 1) + (hv : (v : A) = 1 + T * ((u : A) - 1) * star T) : + partialIsometryDilation T * (diagonalTwoUnitary u 1).val * + star (partialIsometryDilation T) = (diagonalTwoUnitary 1 v).val := by + rw [(partialIsometryDilation_selfAdjoint T).star_eq] + have hd : (diagonalTwoUnitary u 1).val = !![1 + ((u : A) - 1), 0; 0, 1] := by + ext i j + fin_cases i <;> fin_cases j <;> simp [diagonalTwoUnitary, Matrix.diagonal] + rw [hd, partialIsometryDilation_conjugation T ((u : A) - 1) hT hleft hright] + ext i j + fin_cases i <;> fin_cases j <;> simp [diagonalTwoUnitary, Matrix.diagonal, hv] + +variable (S : NonUnitalStarSubalgebra ℂ R) [hS : IsClosed (S : Set R)] + +/-- A partial isometry between supported defects gives equality in the original K₁. -/ +theorem relativeClass_partialIsometry (φ : A →⋆ₐ[ℂ] R) (hφc : Continuous φ) + (hφ : ∀ a b, b ∈ S → φ a * b ∈ S ∧ b * φ a ∈ S) + (T : A) (hT : T * star T * T = T) (u v : unitary A) + (hleft : (star T * T) * ((u : A) - 1) = (u : A) - 1) + (hright : ((u : A) - 1) * (star T * T) = (u : A) - 1) + (hv : (v : A) = 1 + T * ((u : A) - 1) * star T) + (huS : φ (u : A) - 1 ∈ S) (hvS : φ (v : A) - 1 ∈ S) : + relativeClass S (Unitary.map (StarMonoidHom.ofClass φ) u) huS = + relativeClass S (Unitary.map (StarMonoidHom.ofClass φ) v) hvS := by + let W := partialIsometryDilationPath T hT + let u' := Unitary.map (StarMonoidHom.ofClass φ) u + let v' := Unitary.map (StarMonoidHom.ofClass φ) v + have h0 : conjugatedTwoUnitary (mapTwoUnitary φ (W start)) (diagonalTwoUnitary u' 1) = + diagonalTwoUnitary u' 1 := by + change conjugatedTwoUnitary (mapTwoUnitary φ (partialIsometryDilationPath T hT start)) _ = _ + rw [partialIsometryDilationPath_start, mapTwoUnitary_one] + simp [conjugatedTwoUnitary] + have hd : conjugatedTwoUnitary (W finish) (diagonalTwoUnitary u 1) = + diagonalTwoUnitary 1 v := by + apply Subtype.ext + change (W finish).val * (diagonalTwoUnitary u 1).val * star (W finish).val = _ + dsimp only [W] + rw [partialIsometryDilationPath_finish] + exact partialIsometryDilation_conjugates_unitary T hT u v hleft hright hv + have h1 : conjugatedTwoUnitary (mapTwoUnitary φ (W finish)) (diagonalTwoUnitary u' 1) = + diagonalTwoUnitary 1 v' := by + have hm := congrArg (mapTwoUnitary φ) hd + rw [mapTwoUnitary_conjugate, mapTwoUnitary_diagonal, mapTwoUnitary_diagonal] at hm + simpa only [map_one] using hm + have hz : ((1 : unitary R) : R) - 1 ∈ S := by simp + have h := relativeTwoClass_conjugationPath S φ hφc hφ W + (partialIsometryDilationPath_continuous T hT) (diagonalTwoUnitary u' 1) + (diagonalTwoUnitary_relative S u' 1 huS hz) + simp only [h0, h1] at h + rw [relativeTwoClass_diagonal S u' 1 huS hz, + relativeTwoClass_diagonal S 1 v' hz hvS, relativeClass_one S hz, add_zero, zero_add] at h + exact h + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeTwoByTwo.lean b/lean/OAI/Topology/CoarseAssembly/RelativeTwoByTwo.lean new file mode 100644 index 0000000000000000000000000000000000000000..cdea8479423604f08c9d52ca75e80d1037018697 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeTwoByTwo.lean @@ -0,0 +1,100 @@ +import OAI.Topology.CoarseAssembly.RelativeUnitary +import OAI.Topology.CoarseAssembly.K1TwoByTwo +import Mathlib.LinearAlgebra.Matrix.ConjTranspose + +namespace OAI + +/-! # Two-by-two relative unitaries for the spatial stabilization argument -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {A B : Type*} [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B] + +def matrixTwoStarHom (φ : A →⋆ₙₐ[ℂ] B) : + Matrix (Fin 2) (Fin 2) A →⋆ₙₐ[ℂ] Matrix (Fin 2) (Fin 2) B where + toFun T := T.map φ + map_zero' := by ext i j; exact map_zero φ + map_add' T U := by ext i j; exact map_add φ _ _ + map_mul' T U := by + ext i j + simp only [Matrix.map_apply, Matrix.mul_apply, map_sum, map_mul] + map_smul' z T := by ext i j; exact map_smul φ z _ + map_star' T := by ext i j; exact map_star φ _ + +theorem matrixTwoStarHom_injective (φ : A →⋆ₙₐ[ℂ] B) (hφ : Function.Injective φ) : + Function.Injective (matrixTwoStarHom φ) := by + intro T U h + ext i j + apply hφ + exact congrArg (fun M : Matrix (Fin 2) (Fin 2) B => M i j) h + +theorem matrixTwoStarHom_continuous (φ : A →⋆ₙₐ[ℂ] B) (hφ : Continuous φ) : + Continuous (matrixTwoStarHom φ) := by + exact continuous_pi (fun i => continuous_pi (fun j => + hφ.comp ((continuous_apply j).comp (continuous_apply i)))) + +section Relative + +variable {R : Type*} [CStarAlgebra R] (S : NonUnitalStarSubalgebra ℂ R) + +def relativeTwoPart (u : unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ i j, ((u : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) : + Matrix (Fin 2) (Fin 2) S := + fun i j => ⟨((u : Matrix (Fin 2) (Fin 2) R) - 1) i j, hu i j⟩ + +variable [hS : IsClosed (S : Set R)] + +theorem relativeTwoPart_coe (u : unitary (Matrix (Fin 2) (Fin 2) R)) (hu) : + matrixTwoStarHom (NonUnitalStarSubalgebraClass.subtype S) (relativeTwoPart S u hu) = + (u : Matrix (Fin 2) (Fin 2) R) - 1 := rfl + +theorem relativeTwoPart_star_mul (u : unitary (Matrix (Fin 2) (Fin 2) R)) (hu) : + relativeTwoPart S u hu + star (relativeTwoPart S u hu) + + star (relativeTwoPart S u hu) * relativeTwoPart S u hu = 0 := by + apply matrixTwoStarHom_injective (NonUnitalStarSubalgebraClass.subtype S) Subtype.val_injective + simp only [map_add, map_mul, map_star, map_zero, relativeTwoPart_coe] + rw [star_sub, star_one] + have h := Unitary.coe_star_mul_self u + change star (u : Matrix (Fin 2) (Fin 2) R) * (u : Matrix (Fin 2) (Fin 2) R) = 1 at h + noncomm_ring [h] + +theorem relativeTwoPart_mul_star (u : unitary (Matrix (Fin 2) (Fin 2) R)) (hu) : + star (relativeTwoPart S u hu) + relativeTwoPart S u hu + + relativeTwoPart S u hu * star (relativeTwoPart S u hu) = 0 := by + apply matrixTwoStarHom_injective (NonUnitalStarSubalgebraClass.subtype S) Subtype.val_injective + simp only [map_add, map_mul, map_star, map_zero, relativeTwoPart_coe] + rw [star_sub, star_one] + have h := Unitary.coe_mul_star_self u + change (u : Matrix (Fin 2) (Fin 2) R) * star (u : Matrix (Fin 2) (Fin 2) R) = 1 at h + noncomm_ring [h] + +def relativeTwoUnitary (u : unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ i j, ((u : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) : + unitary (Matrix (Fin 2) (Fin 2) (Unitization ℂ S)) := by + let φ := matrixTwoStarHom (Unitization.inrNonUnitalStarAlgHom ℂ S) + let P := relativeTwoPart S u hu + refine ⟨1 + φ P, ?_, ?_⟩ + · change star (1 + φ P) * (1 + φ P) = 1 + calc + _ = 1 + (φ P + star (φ P) + star (φ P) * φ P) := by + rw [star_add, star_one] + noncomm_ring + _ = 1 + φ (P + star P + star P * P) := by rw [map_add, map_add, map_mul, map_star] + _ = 1 := by rw [relativeTwoPart_star_mul, map_zero, add_zero] + · change (1 + φ P) * star (1 + φ P) = 1 + calc + _ = 1 + (star (φ P) + φ P + φ P * star (φ P)) := by + rw [star_add, star_one] + noncomm_ring + _ = 1 + φ (star P + P + P * star P) := by rw [map_add, map_add, map_mul, map_star] + _ = 1 := by rw [relativeTwoPart_mul_star, map_zero, add_zero] + +end Relative + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeTwoConjugation.lean b/lean/OAI/Topology/CoarseAssembly/RelativeTwoConjugation.lean new file mode 100644 index 0000000000000000000000000000000000000000..2e1f809aff79492c259c479e180ca735565655db --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeTwoConjugation.lean @@ -0,0 +1,119 @@ +import OAI.Topology.CoarseAssembly.RelativeTwoDiagonal + +namespace OAI + +/-! # Relative two-by-two conjugation by idealizing operators -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {A R : Type*} [CStarAlgebra A] [CStarAlgebra R] + +def matrixTwoUnitalStarHom (φ : A →⋆ₐ[ℂ] R) : + Matrix (Fin 2) (Fin 2) A →⋆ₐ[ℂ] Matrix (Fin 2) (Fin 2) R := + { matrixTwoStarHom φ.toNonUnitalStarAlgHom with + map_one' := by + ext i j + by_cases h : i = j <;> simp [matrixTwoStarHom, Matrix.one_apply, h] + commutes' := by + intro z + ext i j + by_cases h : i = j <;> + simp [matrixTwoStarHom, Algebra.algebraMap_eq_smul_one, h] } + +@[simp] theorem matrixTwoUnitalStarHom_apply (φ : A →⋆ₐ[ℂ] R) + (M : Matrix (Fin 2) (Fin 2) A) (i j : Fin 2) : + matrixTwoUnitalStarHom φ M i j = φ (M i j) := rfl + +theorem matrixTwoUnitalStarHom_continuous (φ : A →⋆ₐ[ℂ] R) (hc : Continuous φ) : + Continuous (matrixTwoUnitalStarHom φ) := + matrixTwoStarHom_continuous φ.toNonUnitalStarAlgHom hc + +def mapTwoUnitary (φ : A →⋆ₐ[ℂ] R) + (u : unitary (Matrix (Fin 2) (Fin 2) A)) : + unitary (Matrix (Fin 2) (Fin 2) R) := + Unitary.map (StarMonoidHom.ofClass (matrixTwoUnitalStarHom φ)) u + +@[simp] theorem mapTwoUnitary_diagonal (φ : A →⋆ₐ[ℂ] R) (u v : unitary A) : + mapTwoUnitary φ (diagonalTwoUnitary u v) = + diagonalTwoUnitary (Unitary.map (StarMonoidHom.ofClass φ) u) (Unitary.map (StarMonoidHom.ofClass φ) v) := by + apply Subtype.ext + ext i j + fin_cases i <;> fin_cases j <;> + simp [mapTwoUnitary, diagonalTwoUnitary, Matrix.diagonal, matrixTwoUnitalStarHom, matrixTwoStarHom] + +def conjugatedTwoUnitary (w u : unitary (Matrix (Fin 2) (Fin 2) R)) : + unitary (Matrix (Fin 2) (Fin 2) R) := w * u * star w + +theorem conjugatedTwoUnitary_defect (w u : unitary (Matrix (Fin 2) (Fin 2) R)) : + (conjugatedTwoUnitary w u : Matrix (Fin 2) (Fin 2) R) - 1 = + (w : Matrix (Fin 2) (Fin 2) R) * ((u : Matrix (Fin 2) (Fin 2) R) - 1) * + star (w : Matrix (Fin 2) (Fin 2) R) := by + change w.val * u.val * star w.val - 1 = w.val * (u.val - 1) * star w.val + have hw : w.val * star w.val = 1 := by + have h := Unitary.coe_mul_star_self w + change w.val * star w.val = 1 at h + exact h + rw [mul_sub, mul_one, sub_mul, hw] + +@[simp] theorem mapTwoUnitary_one (φ : A →⋆ₐ[ℂ] R) : mapTwoUnitary φ 1 = 1 := by + apply Subtype.ext + exact map_one (matrixTwoUnitalStarHom φ) + +theorem mapTwoUnitary_conjugate (φ : A →⋆ₐ[ℂ] R) + (w u : unitary (Matrix (Fin 2) (Fin 2) A)) : + mapTwoUnitary φ (conjugatedTwoUnitary w u) = + conjugatedTwoUnitary (mapTwoUnitary φ w) (mapTwoUnitary φ u) := by + apply Subtype.ext + change matrixTwoUnitalStarHom φ (w.val * u.val * star w.val) = + matrixTwoUnitalStarHom φ w.val * matrixTwoUnitalStarHom φ u.val * + star (matrixTwoUnitalStarHom φ w.val) + rw [map_mul, map_mul, map_star] + +variable (S : NonUnitalStarSubalgebra ℂ R) + +/-- The entries of the conjugation defect remain in the idealized algebra. -/ +theorem conjugatedTwoUnitary_relative (φ : A →⋆ₐ[ℂ] R) + (hφ : ∀ a b, b ∈ S → φ a * b ∈ S ∧ b * φ a ∈ S) + (w : unitary (Matrix (Fin 2) (Fin 2) A)) + (u : unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ i j, ((u : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) : + ∀ i j, ((conjugatedTwoUnitary (mapTwoUnitary φ w) u : + Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S := by + intro i j + rw [conjugatedTwoUnitary_defect] + simp only [Matrix.mul_apply] + apply S.sum_mem + intro k _ + rw [Finset.sum_mul] + apply S.sum_mem + intro l _ + rw [Matrix.star_apply] + change φ (w.val i l) * ((u.val - 1) l k) * star (φ (w.val j k)) ∈ S + rw [← map_star] + exact (hφ (star (w.val j k)) _ ((hφ (w.val i l) _ (hu l k)).1)).2 + +variable [hS : IsClosed (S : Set R)] + +theorem relativeTwoClass_conjugationPath (φ : A →⋆ₐ[ℂ] R) (hφc : Continuous φ) + (hφ : ∀ a b, b ∈ S → φ a * b ∈ S ∧ b * φ a ∈ S) + (w : Analytic.Interval → unitary (Matrix (Fin 2) (Fin 2) A)) + (hw : Continuous w) (u : unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ i j, ((u : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) : + relativeTwoClass S (conjugatedTwoUnitary (mapTwoUnitary φ (w Analytic.start)) u) + (conjugatedTwoUnitary_relative S φ hφ (w Analytic.start) u hu) = + relativeTwoClass S (conjugatedTwoUnitary (mapTwoUnitary φ (w Analytic.finish)) u) + (conjugatedTwoUnitary_relative S φ hφ (w Analytic.finish) u hu) := by + apply relativeTwoClass_homotopy S + (fun t => conjugatedTwoUnitary (mapTwoUnitary φ (w t)) u) + (fun t => conjugatedTwoUnitary_relative S φ hφ (w t) u hu) + have hc : Continuous (fun t => (mapTwoUnitary φ (w t)).val) := + (matrixTwoUnitalStarHom_continuous φ hφc).comp (continuous_subtype_val.comp hw) + exact (hc.mul continuous_const).mul hc.star + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeTwoDiagonal.lean b/lean/OAI/Topology/CoarseAssembly/RelativeTwoDiagonal.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e3891e80d95527d48f96436bda2dcdb766b5d60 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeTwoDiagonal.lean @@ -0,0 +1,68 @@ +import OAI.Topology.CoarseAssembly.RelativeTwoHomotopy + +namespace OAI + +/-! # Diagonal relative matrices and addition in Roe K₁ -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {R : Type*} [CStarAlgebra R] + +def diagonalTwoUnitary (u v : unitary R) : unitary (Matrix (Fin 2) (Fin 2) R) := by + refine ⟨Matrix.diagonal (fun i => if i = 0 then (u : R) else (v : R)), ?_, ?_⟩ + · apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Matrix.star_apply, Matrix.diagonal] + · apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Matrix.star_apply, Matrix.diagonal] + +variable (S : NonUnitalStarSubalgebra ℂ R) [hS : IsClosed (S : Set R)] + +omit hS in +theorem diagonalTwoUnitary_relative (u v : unitary R) + (hu : (u : R) - 1 ∈ S) (hv : (v : R) - 1 ∈ S) : + ∀ i j, ((diagonalTwoUnitary u v : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S := by + intro i j + fin_cases i <;> fin_cases j + · simpa [diagonalTwoUnitary, Matrix.diagonal] using hu + · simp [diagonalTwoUnitary, Matrix.diagonal] + · simp [diagonalTwoUnitary, Matrix.diagonal] + · simpa [diagonalTwoUnitary, Matrix.diagonal] using hv + +theorem relativeTwoMatrix_diagonal (u v : unitary R) + (hu : (u : R) - 1 ∈ S) (hv : (v : R) - 1 ∈ S) : + relativeTwoMatrix S (diagonalTwoUnitary u v) (diagonalTwoUnitary_relative S u v hu hv) = + TopologicalK1.diagonalTwoUnits (Unitary.toUnits (relativeUnitary S u hu)) + (Unitary.toUnits (relativeUnitary S v hv)) := by + apply Units.ext + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp [relativeTwoMatrix, relativeTwoUnitary, matrixTwoStarHom, relativeTwoPart, + diagonalTwoUnitary, TopologicalK1.diagonalTwoUnits, Matrix.diagonal, + relativeUnitary, relativePart] + all_goals + change ((0 : S) : Unitization ℂ S) = 0 + simp + +/-- Two diagonal relative unitaries represent the sum of their K₁ classes. -/ +theorem relativeTwoClass_diagonal (u v : unitary R) + (hu : (u : R) - 1 ∈ S) (hv : (v : R) - 1 ∈ S) : + relativeTwoClass S (diagonalTwoUnitary u v) (diagonalTwoUnitary_relative S u v hu hv) = + relativeClass S u hu + relativeClass S v hv := by + apply Subtype.ext + change TopologicalK1.matrixClass (Unitization ℂ S) + (relativeTwoMatrix S (diagonalTwoUnitary u v) _) = _ + rw [relativeTwoMatrix_diagonal, TopologicalK1.diagonalTwo_matrixClass] + rfl + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeTwoHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/RelativeTwoHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..2a56e4fb35388322919d76918494db10d7df8ef5 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeTwoHomotopy.lean @@ -0,0 +1,73 @@ +import OAI.Topology.CoarseAssembly.RelativeTwoByTwo + +namespace OAI + +/-! # Relative two-by-two classes and their actual norm homotopies -/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +open Analytic + +variable {R : Type*} [CStarAlgebra R] +variable (S : NonUnitalStarSubalgebra ℂ R) [hS : IsClosed (S : Set R)] + +def relativeTwoMatrix (u : unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ i j, ((u : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) : + TopologicalK1.InvertibleMatrix (Unitization ℂ S) 2 := + Unitary.toUnits (relativeTwoUnitary S u hu) + +theorem relativeTwoMatrix_scalar (u : unitary (Matrix (Fin 2) (Fin 2) R)) (hu) : + TopologicalK1.mapGL (Unitization.fstHom ℂ S).toRingHom 2 (relativeTwoMatrix S u hu) = 1 := by + apply Units.ext + apply Matrix.ext + intro i j + by_cases hij : i = j + · subst j + simp [TopologicalK1.mapGL, relativeTwoMatrix, relativeTwoUnitary, matrixTwoStarHom] + · simp [TopologicalK1.mapGL, relativeTwoMatrix, relativeTwoUnitary, matrixTwoStarHom, + hij] + +def relativeTwoClass (u : unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ i j, ((u : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) : K1 S := + ⟨TopologicalK1.matrixClass (Unitization ℂ S) (relativeTwoMatrix S u hu), by + rw [AddMonoidHom.mem_ker, scalarMap_matrixClass, relativeTwoMatrix_scalar, + TopologicalK1.matrixClass_one]⟩ + +variable {P : Type*} [TopologicalSpace P] + +theorem continuous_relativeTwoUnitary (u : P → unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ p i j, ((u p : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) + (hc : Continuous (fun p => (u p : Matrix (Fin 2) (Fin 2) R))) : + Continuous (fun p => (relativeTwoUnitary S (u p) (hu p)).val) := by + apply continuous_pi + intro i + apply continuous_pi + intro j + have hp : Continuous (fun p => relativeTwoPart S (u p) (hu p) i j) := + (((continuous_apply j).comp ((continuous_apply i).comp hc)).sub continuous_const).subtype_mk + (fun p => hu p i j) + exact continuous_const.add (Unitization.continuous_inr.comp hp) + +theorem continuous_relativeTwoMatrix (u : P → unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ p i j, ((u p : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) + (hc : Continuous (fun p => (u p : Matrix (Fin 2) (Fin 2) R))) : + Continuous (fun p => relativeTwoMatrix S (u p) (hu p)) := by + apply Units.continuous_iff.mpr + have hv := continuous_relativeTwoUnitary S u hu hc + exact ⟨hv, hv.star⟩ + +theorem relativeTwoClass_homotopy (u : Interval → unitary (Matrix (Fin 2) (Fin 2) R)) + (hu : ∀ t i j, ((u t : Matrix (Fin 2) (Fin 2) R) - 1) i j ∈ S) + (hc : Continuous (fun t => (u t : Matrix (Fin 2) (Fin 2) R))) : + relativeTwoClass S (u start) (hu start) = relativeTwoClass S (u finish) (hu finish) := by + apply Subtype.ext + exact TopologicalK1.matrixClass_homotopy (fun t => relativeTwoMatrix S (u t) (hu t)) + (continuous_relativeTwoMatrix S u hu hc) + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RelativeUnitary.lean b/lean/OAI/Topology/CoarseAssembly/RelativeUnitary.lean new file mode 100644 index 0000000000000000000000000000000000000000..bd64865c4dec9820327f727945f043dc1ea44d70 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RelativeUnitary.lean @@ -0,0 +1,83 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.NonUnitalK1 +import Mathlib.Tactic.NoncommRing + +namespace OAI + +/-! # Unitaries equal to one modulo a nonunital subalgebra + +The scalar part is kept explicit, so no faithfulness assumption on a +unitization representation is needed to obtain its K₁ class. +-/ + +noncomputable section + +namespace CoarseAssembly.OperatorKTheory + +variable {A : Type*} [CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) + +theorem relativePart_mul_star (u : unitary A) (hu : (u : A) - 1 ∈ S) : + star (relativePart S u hu) + relativePart S u hu + + relativePart S u hu * star (relativePart S u hu) = 0 := by + apply Subtype.ext + change star ((u : A) - 1) + ((u : A) - 1) + + ((u : A) - 1) * star ((u : A) - 1) = 0 + rw [star_sub, star_one] + have h := Unitary.coe_mul_star_self u + change (u : A) * star (u : A) = 1 at h + noncomm_ring [h] + +theorem relativePart_star_mul (u : unitary A) (hu : (u : A) - 1 ∈ S) : + relativePart S u hu + star (relativePart S u hu) + + star (relativePart S u hu) * relativePart S u hu = 0 := by + apply Subtype.ext + change ((u : A) - 1) + star ((u : A) - 1) + + star ((u : A) - 1) * ((u : A) - 1) = 0 + rw [star_sub, star_one] + have h := Unitary.coe_star_mul_self u + change star (u : A) * (u : A) = 1 at h + noncomm_ring [h] + +@[simp] theorem relativeUnitary_val (u : unitary A) (hu : (u : A) - 1 ∈ S) : + (relativeUnitary S u hu : Unitization ℂ S) = + 1 + (relativePart S u hu : Unitization ℂ S) := rfl + +@[simp] theorem relativeUnitary_scalar (u : unitary A) (hu : (u : A) - 1 ∈ S) : + (relativeUnitary S u hu : Unitization ℂ S).fst = 1 := by + simp + +theorem relativeMatrix_scalar (u : unitary A) (hu : (u : A) - 1 ∈ S) : + TopologicalK1.mapGL (Unitization.fstHom ℂ S).toRingHom 1 (relativeMatrix S u hu) = 1 := by + apply Units.ext + ext i j + have hij : i = j := Subsingleton.elim _ _ + simp [TopologicalK1.mapGL, relativeMatrix, Matrix.scalar_apply, + Unitary.val_toUnits_apply, hij] + +variable [hS : IsClosed (S : Set A)] + +theorem relativeClass_one (hu : ((1 : unitary A) : A) - 1 ∈ S) : + relativeClass S 1 hu = 0 := by + have hr : relativePart S 1 hu = 0 := by + apply Subtype.ext + simp [relativePart] + have hm : relativeMatrix S 1 hu = 1 := by + apply Units.ext + change Matrix.scalar (Fin 1) + (1 + (relativePart S 1 hu : Unitization ℂ S)) = 1 + rw [hr] + simp + apply Subtype.ext + change TopologicalK1.matrixClass (Unitization ℂ S) (relativeMatrix S 1 hu) = 0 + rw [hm, TopologicalK1.matrixClass_one] + +theorem relativeClass_eq_zero {u : unitary A} (hu : (u : A) - 1 ∈ S) (h : u = 1) : + relativeClass S u hu = 0 := by + subst u + exact relativeClass_one S hu + +end CoarseAssembly.OperatorKTheory + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RepresentedCutDown.lean b/lean/OAI/Topology/CoarseAssembly/RepresentedCutDown.lean new file mode 100644 index 0000000000000000000000000000000000000000..712128bbdd8abd845a8daeaaa61259cd21ef1f3b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RepresentedCutDown.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.SupportedNormalization + +namespace OAI + +/-! # Cutting down arbitrary cycles over the unital coefficient algebras + +The compact-source algebras used by the circle pairing are unital, although +the Fredholm representations themselves may be nonunital. Restriction to +scalar coefficients gives precisely the local estimates needed for the +represented-subspace cut-down. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem representation_unit_selfAdjoint (c : OddCycle A) : + IsSelfAdjoint (c.representation 1) := by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + +theorem representation_unit_sq (c : OddCycle A) : + c.representation 1 * c.representation 1 = c.representation 1 := by + rw [← map_mul, one_mul] + +theorem representedCutDown_compact (c : OddCycle A) : + let P := c.representation 1 + let K := symmetricCutDown P c.operator - c.operator + IsCompactOperator (K * P : End c.space) ∧ + IsCompactOperator (P * K : End c.space) ∧ + IsCompactOperator (star K * P : End c.space) := by + have h := scalarCutDown_compact c.scalarRestriction + change let P : End c.space := c.representation (algebraMap ℂ A 1) + let K : End c.space := symmetricCutDown P c.operator - c.operator + IsCompactOperator (K * P : End c.space) ∧ + IsCompactOperator (P * K : End c.space) ∧ + IsCompactOperator (star K * P : End c.space) at h + simpa only [map_one] using h + +theorem exists_represented_cutDown (c : OddCycle A) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ IsSelfAdjoint d.operator ∧ + d.operator * (1 - d.representation 1) = 1 - d.representation 1 := by + let P := c.representation 1 + let K := symmetricCutDown P c.operator - c.operator + obtain ⟨hr, hl, hs⟩ := representedCutDown_compact c + have hp (a : A) : P * c.representation a = c.representation a := by + change c.representation 1 * c.representation a = c.representation a + rw [← map_mul, one_mul] + have hpr (a : A) : c.representation a * P = c.representation a := by + change c.representation a * c.representation 1 = c.representation a + rw [← map_mul, mul_one] + have hr' (a : A) : IsCompactOperator (K * c.representation a : End c.space) := by + rw [← hp a, ← mul_assoc] + exact compact_mul_right hr _ + have hl' (a : A) : IsCompactOperator (c.representation a * K : End c.space) := by + rw [← hpr a, mul_assoc] + exact compact_mul_left hl _ + have hs' (a : A) : IsCompactOperator (star K * c.representation a : End c.space) := by + rw [← hp a, ← mul_assoc] + exact compact_mul_right hs _ + have he : c.operator + K = symmetricCutDown P c.operator := by dsimp only [K]; abel + refine ⟨c.localCompactPerturb K hr' hl' hs', localCompactPerturb_class c K hr' hl' hs', ?_, ?_⟩ + · change IsSelfAdjoint (c.operator + K) + rw [he] + exact symmetricCutDown_selfAdjoint P c.operator (representation_unit_selfAdjoint c) + · change (c.operator + K) * (1 - P) = 1 - P + rw [he] + exact symmetricCutDown_complement P c.operator (representation_unit_selfAdjoint c) + (representation_unit_sq c) + +theorem represented_square_compact (c : OddCycle A) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : End c.space) := by + apply supported_square_compact c.scalarRestriction + change c.operator * (1 - c.representation (algebraMap ℂ A 1)) = + 1 - c.representation (algebraMap ℂ A 1) + simpa only [map_one] using hQ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RepresentedIndex.lean b/lean/OAI/Topology/CoarseAssembly/RepresentedIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..d788d126550280d93a2569908e337f8b892bc5fa --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RepresentedIndex.lean @@ -0,0 +1,108 @@ +import OAI.Topology.CoarseAssembly.RepresentedNormalization +import OAI.Topology.CoarseAssembly.CycleIndex + +namespace OAI + +/-! # The Toeplitz index for nonunital representations + +A represented unitary is extended by the identity on the complement of the +represented subspace. This supplies a genuine unitary even when the original +representation does not preserve the unit. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +def unitaryExtension (c : OddCycle A) (u : A) : End c.space := + c.representation u + (1 - c.representation 1) + +theorem unitaryExtension_star (c : OddCycle A) (u : A) : + star (unitaryExtension c u) = unitaryExtension c (star u) := by + rw [unitaryExtension, star_add, star_sub, star_one, ← map_star, ← map_star, star_one] + rfl + +theorem unitaryExtension_mul (c : OddCycle A) (u v : A) : + unitaryExtension c u * unitaryExtension c v = unitaryExtension c (u * v) := by + simp only [unitaryExtension, add_mul, mul_add, sub_mul, mul_sub, one_mul, mul_one, + ← map_mul, one_mul, mul_one] + abel + +theorem unitaryExtension_unitary (c : OddCycle A) (u : A) + (hul : star u * u = 1) (hur : u * star u = 1) : + star (unitaryExtension c u) * unitaryExtension c u = 1 ∧ + unitaryExtension c u * star (unitaryExtension c u) = 1 := by + rw [unitaryExtension_star, unitaryExtension_mul, unitaryExtension_mul, hul, hur] + constructor <;> simp only [unitaryExtension, add_sub_cancel] + +theorem unitaryExtension_commutator (c : OddCycle A) (u : A) + (hcomm : Commute c.operator (c.representation 1)) : + c.operator * unitaryExtension c u - unitaryExtension c u * c.operator = + c.operator * c.representation u - c.representation u * c.operator := by + simp only [unitaryExtension, mul_add, add_mul, mul_sub, sub_mul, mul_one, one_mul] + rw [hcomm.eq] + abel + +def representedToeplitz (c : OddCycle A) (u : A) : End c.space := + toeplitzCompression (positiveProjection c.operator) (unitaryExtension c u) + +def representedIndex (c : OddCycle A) (u : A) : ℤ := + (representedToeplitz c u).toLinearMap.index + +theorem representedToeplitz_fredholm (c : OddCycle A) (u : A) + (hself : IsSelfAdjoint c.operator) (hsq : c.operator * c.operator = 1) + (hcomm : Commute c.operator (c.representation 1)) + (hul : star u * u = 1) (hur : u * star u = 1) : + (representedToeplitz c u).IsFredholm := by + obtain ⟨hUl, hUr⟩ := unitaryExtension_unitary c u hul hur + apply toeplitzCompression_fredholm _ _ (positiveProjection_selfAdjoint _ hself) + (positiveProjection_sq _ hsq) hUl hUr + rw [positiveProjection_commutator, unitaryExtension_commutator c u hcomm] + exact (c.commutator_compact u).smul (1 / 2 : ℝ) + +theorem exists_representedToeplitz_fredholm (c : OddCycle A) (u : A) + (hul : star u * u = 1) (hur : u * star u = 1) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ + (representedToeplitz d u).IsFredholm := by + obtain ⟨d, hdc, hdself, hdsq, hdcomm⟩ := exists_represented_involutive_representative c + exact ⟨d, hdc, representedToeplitz_fredholm d u hdself hdsq hdcomm hul hur⟩ + +theorem representedIndex_homotopy (h : OddHomotopy A) (u : A) + (hself : ∀ t, IsSelfAdjoint (h.operator t)) + (hsq : ∀ t, h.operator t * h.operator t = 1) + (hcomm : ∀ t, Commute (h.operator t) (h.representation t 1)) + (hul : star u * u = 1) (hur : u * star u = 1) : + representedIndex (h.eval start) u = representedIndex (h.eval finish) u := by + apply fredholmIndex_homotopy (fun t => representedToeplitz (h.eval t) u) + · change Continuous (fun t => positiveProjection (h.operator t) * + (h.representation t u + (1 - h.representation t 1)) * positiveProjection (h.operator t) + + (1 - positiveProjection (h.operator t))) + have hp : Continuous (fun t => positiveProjection (h.operator t)) := + (h.continuous_operator.add continuous_const).const_smul (1 / 2 : ℝ) + exact ((hp.mul ((h.continuous_representation u).add + (continuous_const.sub (h.continuous_representation 1)))).mul hp).add + (continuous_const.sub hp) + · intro t + exact representedToeplitz_fredholm (h.eval t) u (hself t) (hsq t) (hcomm t) hul hur + +theorem representedIndex_degenerate (c : OddCycle A) (u : A) (hd : c.Degenerate) + (hself : IsSelfAdjoint c.operator) (hsq : c.operator * c.operator = 1) + (hul : star u * u = 1) (hur : u * star u = 1) : representedIndex c u = 0 := by + have hcomm : Commute c.operator (c.representation 1) := sub_eq_zero.mp (hd.1 1) + have hc : Commute (positiveProjection c.operator) (unitaryExtension c u) := by + apply sub_eq_zero.mp + rw [positiveProjection_commutator, unitaryExtension_commutator c u hcomm, hd.1 u, smul_zero] + obtain ⟨hUl, hUr⟩ := unitaryExtension_unitary c u hul hur + obtain ⟨hl, hr⟩ := toeplitzCompression_unitary _ _ (positiveProjection_selfAdjoint _ hself) + (positiveProjection_sq _ hsq) hUl hUr hc + have hinv : (representedToeplitz c u).IsInvertible := + ContinuousLinearMap.IsInvertible.of_inverse (g := star (representedToeplitz c u)) hr hl + exact LinearMap.index_of_bijective hinv.bijective + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RepresentedNormalization.lean b/lean/OAI/Topology/CoarseAssembly/RepresentedNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..d7ef6f8b56316928116071996b8f08c891302cb1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RepresentedNormalization.lean @@ -0,0 +1,64 @@ +import OAI.Topology.CoarseAssembly.RepresentedCutDown + +namespace OAI + +/-! # Involutive representatives with possibly nonunital representations -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem exists_supported_involution (c : OddCycle A) (hF : IsSelfAdjoint c.operator) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + ∃ e : OddCycle A, cycleClass A e = cycleClass A c ∧ IsSelfAdjoint e.operator ∧ + e.operator * e.operator = 1 ∧ Commute e.operator (e.representation 1) := by + let P : End c.space := c.representation 1 + have hc := represented_square_compact c hQ + have hk := kernelProjection_compact c.operator hc + have hks : IsCompactOperator (star (kernelProjection c.operator) : End c.space) := by + rw [(kernelProjection_selfAdjoint c.operator).star_eq] + exact hk + let G : End c.space := c.operator + kernelProjection c.operator + have hgs : IsSelfAdjoint G := kernel_corrected_selfAdjoint c.operator hF + have hgi : IsUnit G := kernel_corrected_isUnit c.operator hF hc + have hgQ : G * (1 - P) = 1 - P := by + change (c.operator + kernelProjection c.operator) * (1 - P) = 1 - P + rw [add_mul, kernelProjection_complement c.operator P hF hQ, add_zero] + exact hQ + have hgcomm : Commute G P := + commute_of_complement G P hgs (representation_unit_selfAdjoint c) hgQ + have hgcpt : IsCompactOperator (G * G - 1 : End c.space) := + kernel_corrected_compact_square c.operator hF hc + obtain ⟨hK, hKs⟩ := involutiveCorrection_compact G hgs hgi hgcpt + let L : End c.space := G * cfc inverseSqrtCorrection (G * G - 1) + let d := c.compactPerturb (kernelProjection c.operator) hk hks + let e := d.compactPerturb L hK hKs + have hec : cycleClass A e = cycleClass A c := + (compactPerturb_class d L hK hKs).trans (compactPerturb_class c _ hk hks) + have heop : G + L = involutiveNormalization G := + (involutiveNormalization_eq G hgs hgi).symm + refine ⟨e, hec, ?_, ?_, ?_⟩ + · change IsSelfAdjoint (G + L) + rw [heop] + exact involutiveNormalization_selfAdjoint G + · change (G + L) * (G + L) = 1 + rw [heop] + exact involutiveNormalization_sq G hgs hgi + · change Commute (G + L) P + rw [heop] + exact hgcomm.cfc_real normalizedReal + +theorem exists_represented_involutive_representative (c : OddCycle A) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ IsSelfAdjoint d.operator ∧ + d.operator * d.operator = 1 ∧ Commute d.operator (d.representation 1) := by + obtain ⟨d, hdc, hdself, hdQ⟩ := exists_represented_cutDown c + obtain ⟨e, hed, heself, hesq, hecomm⟩ := exists_supported_involution d hdself hdQ + exact ⟨e, hed.trans hdc, heself, hesq, hecomm⟩ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsBoundaryDegeneracy.lean b/lean/OAI/Topology/CoarseAssembly/RipsBoundaryDegeneracy.lean new file mode 100644 index 0000000000000000000000000000000000000000..3ede0882d3475b806628eb67081869eceb3a27c6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsBoundaryDegeneracy.lean @@ -0,0 +1,131 @@ +import OAI.Topology.CoarseAssembly.AmpleRipsFamily +import OAI.Topology.CoarseAssembly.MultiplierBoundaryHomotopy + +namespace OAI + +/-! # Degenerate families have zero whole-union Roe boundary + +Vanishing is proved from an exact global involution, not from vanishing of +the individual finite-component K-theory classes. +-/ + +noncomputable section + +namespace CoarseAssembly + +theorem isometricExtension_sq_eq_one {E H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) (hF : F * F = 1) : + isometricExtension V F * isometricExtension V F = 1 := by + apply sub_eq_zero.mp + rw [isometricExtension_square_defect, hF, sub_self] + change operatorConjugationHom V 0 = 0 + exact map_zero _ + +namespace Analytic + +theorem localizedOperator_degenerate {A : Type} [NonUnitalCStarAlgebra A] + {ι : Type*} [Fintype ι] (c : OddCycle A) (a : ι → A) (hc : c.Degenerate) + (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : + localizedOperator c a = c.operator := by + apply sub_eq_zero.mp + rw [localizedOperator_sub_eq c a hpart] + simp only [hc.1, mul_zero, Finset.sum_const_zero] + +end Analytic + +namespace Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + +theorem ripsCompression_degenerate (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hc : c.Degenerate) : + partitionCompression (representedSqrt r c) c.operator = c.operator := by + rw [ripsCompression_eq_localized] + apply localizedOperator_degenerate c _ hc + simp only [← map_mul, ← map_sum, sqrtCoordinate_square_sum, hπ] + +theorem ripsSpatialOperator_degenerate_sq (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hc : c.Degenerate) : + ripsSpatialOperator r c hπ * ripsSpatialOperator r c hπ = 1 := by + have hs : c.operator * c.operator = 1 := by + have h := hc.2.1 1 + rw [hπ, mul_one] at h + exact sub_eq_zero.mp h + unfold ripsSpatialOperator localizedSpatialOperator + apply isometricExtension_sq_eq_one + rwa [ripsCompression_degenerate r c hπ hc] + +theorem ampleRipsOperator_degenerate_sq (r : ℝ) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hc : c.Degenerate) : + ampleRipsOperator r c hπ * ampleRipsOperator r c hπ = 1 := + isometricExtension_sq_eq_one _ _ (ripsSpatialOperator_degenerate_sq r c hπ hc) + +end Rips + +namespace DiscreteRoe + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem separatedFamilyBoundary_involution (o : ∀ i, V i) (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (r : ℝ) (hr : 0 ≤ r) (hp : ∀ i, PropagationLE r (A i)) + (hself : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) + (hinv : ∀ i, A i * A i = 1) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hp hself hsq = 0 := by + let := separatedMetric o + refine multiplierBoundaryClass_eq_zero _ + (separatedFamilyMultiplier_selfAdjoint o A C hC hA r hr hp hself) + (diagonalFamily_square_mem_roe o A C hC hA r hr hp hself hsq) ?_ + apply Subtype.ext + change diagonalFamily A C hC hA * diagonalFamily A C hC hA = 1 + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext z + rcases z with ⟨i, x⟩ + have hi := DFunLike.congr_fun (hinv i) (rowVector v i) + have hix := congrArg (fun w : Module (V i) H => w x) hi + simpa only [mul_apply_eq_comp, one_apply_eq_self, diagonalFamily_apply, + rowVector_diagonalFamily, rowVector] using hix + +end DiscreteRoe + +namespace Rips + +open Analytic DiscreteRoe + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] + +theorem ampleRipsFamilyBoundary_degenerate (o : ∀ i, V i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OddCycle C(Point (V i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (C : ℝ) (hC : 0 ≤ C) (hnorm : ∀ i, ‖(c i).operator‖ ≤ C) + (hc : ∀ i, (c i).Degenerate) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr c hπ hF C hC hnorm = 0 := by + let := separatedMetric o + exact separatedFamilyBoundary_involution o + (fun i => ampleRipsOperator r (c i) (hπ i)) (C + 4) (by linarith) + (fun i => (ampleRipsOperator_norm_le r (c i) (hπ i)).trans (by linarith [hnorm i])) + (r + r) (add_nonneg hr hr) + (fun i => ampleRipsOperator_propagation r hr (c i) (hπ i)) + (fun i => ampleRipsOperator_selfAdjoint r (c i) (hπ i) (hF i)) + (fun i => ampleRipsOperator_square_compact r (c i) (hπ i) (hF i)) + (fun i => ampleRipsOperator_degenerate_sq r (c i) (hπ i) (hc i)) + +end Rips + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsBoundaryRepresentative.lean b/lean/OAI/Topology/CoarseAssembly/RipsBoundaryRepresentative.lean new file mode 100644 index 0000000000000000000000000000000000000000..909c9b3b4ed192580e17a3ebf86f3fee620957fd --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsBoundaryRepresentative.lean @@ -0,0 +1,57 @@ +import OAI.Topology.CoarseAssembly.RipsLocalization +import OAI.Topology.CoarseAssembly.MultiplierBoundaryClass +import OAI.Topology.CoarseAssembly.FiniteCompactRoe + +namespace OAI + +/-! # The actual boundary representative on a finite Rips component + +This constructs the component operator and Roe K₁ class. No inference from +componentwise classes to the whole coarse disjoint union is made here. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + (r : ℝ) (hr : 0 ≤ r) + +def ripsMultiplier (c : OddCycle C(Point X r, ℂ)) (hπ : c.representation 1 = 1) : + multiplierAlgebra (X := X) (H := c.space) := + ⟨ripsSpatialOperator r c hπ, + finitePropagation_multiplier (fun _ _ => Set.toFinite _) (add_nonneg hr hr) + (ripsSpatialOperator_propagation r hr c hπ)⟩ + +theorem ripsMultiplier_selfAdjoint (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + IsSelfAdjoint (ripsMultiplier r hr c hπ) := by + apply Subtype.ext + exact (ripsSpatialOperator_selfAdjoint r c hπ hF).star_eq + +theorem ripsSpatialOperator_square_mem_roe (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + (ripsSpatialOperator r c hπ) ^ 2 - 1 ∈ algebra (X := X) (H := c.space) := by + apply compact_selfAdjoint_mem_roe + · simpa only [pow_two] using ripsSpatialOperator_square_compact r c hπ hF + · have hs : IsSelfAdjoint ((ripsSpatialOperator r c hπ) ^ 2 : Operator X c.space) := + (ripsSpatialOperator_selfAdjoint r c hπ hF).pow 2 + have hi : IsSelfAdjoint (1 : Operator X c.space) := IsSelfAdjoint.one _ + exact @IsSelfAdjoint.sub (Operator X c.space) inferInstance inferInstance _ _ hs hi + +/-- The constructed boundary element, before passage to the fixed ample +module and before descent of the entire assembly homomorphism. -/ +def ripsBoundaryRepresentative (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + OperatorKTheory.K1 (algebra (X := X) (H := c.space)) := + multiplierBoundaryClass (ripsMultiplier r hr c hπ) + (ripsMultiplier_selfAdjoint r hr c hπ hF) + (ripsSpatialOperator_square_mem_roe r c hπ hF) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsCompactSupport.lean b/lean/OAI/Topology/CoarseAssembly/RipsCompactSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..3c5bcdaffa042f8d2be1f5eca3f73a8416b65465 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsCompactSupport.lean @@ -0,0 +1,45 @@ +import OAI.Topology.CoarseAssembly.CocycleCircleMap +import Mathlib.Topology.Compactness.Compact + +namespace OAI + +/-! # Compact subsets of a locally finite Rips complex + +A compact set of probability weights has its entire support in one finite +vertex set. The proof uses a finite cover by positive-coordinate stars and +the finite metric balls around those coordinates. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +variable {X : Type*} [PseudoMetricSpace X] {r : ℝ} + +theorem compact_support_finite + (hballs : ∀ x : X, Set.Finite {y : X | dist x y ≤ r}) + {K : Set (Point X r)} (hK : IsCompact K) : + ∃ s : Finset X, ∀ p ∈ K, p.weight.support ⊆ s := by + classical + obtain ⟨a, ha⟩ := hK.elim_finite_subcover + (fun x : X => {p : Point X r | 0 < p.weight x}) + (fun x => isOpen_lt continuous_const (coordinate_continuous x)) (by + intro p _ + obtain ⟨x, hx⟩ := p.exists_positive + exact Set.mem_iUnion.mpr ⟨x, hx⟩) + let s : Finset X := a.biUnion (fun x => (hballs x).toFinset) + refine ⟨s, ?_⟩ + intro p hp y hy + obtain ⟨x, hx, hpx⟩ := Set.mem_iUnion₂.mp (ha hp) + apply Finset.mem_biUnion.mpr + refine ⟨x, hx, ?_⟩ + exact (hballs x).mem_toFinset.mpr + (p.diameter x (Finsupp.mem_support_iff.mpr (ne_of_gt hpx)) y hy) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsDirectSumBoundary.lean b/lean/OAI/Topology/CoarseAssembly/RipsDirectSumBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..91f2aa5701ce51b03fe0b848c09be1e7f08e9417 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsDirectSumBoundary.lean @@ -0,0 +1,90 @@ +import OAI.Topology.CoarseAssembly.FamilyBoundaryAddition + +namespace OAI + +/-! # Direct sums of Fredholm cycles add their whole-union Rips boundaries -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +theorem ripsFamilyBoundaryWithEmbeddings_directSum + (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c d e : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (h : ∀ i, (c i).IsDirectSum (d i) (e i)) + (hc : ∀ i, (c i).representation 1 = 1) (hd : ∀ i, (d i).representation 1 = 1) + (he : ∀ i, (e i).representation 1 = 1) + (hsC : ∀ i, IsSelfAdjoint (c i).operator) (hsD : ∀ i, IsSelfAdjoint (d i).operator) + (hsE : ∀ i, IsSelfAdjoint (e i).operator) + (C D K : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) (hK : 0 ≤ K) + (hnC : ∀ i, ‖(c i).operator‖ ≤ C) (hnD : ∀ i, ‖(d i).operator‖ ≤ D) + (hnE : ∀ i, ‖(e i).operator‖ ≤ K) + (U : ∀ i, (e i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) : + letI := separatedMetric o + ripsFamilyBoundaryWithEmbeddings o r hr e he hsE K hK hnE U = + ripsFamilyBoundaryWithEmbeddings o r hr c hc hsC C hC hnC + (fun i => (U i).comp (h i).left) + + ripsFamilyBoundaryWithEmbeddings o r hr d hd hsD D hD hnD + (fun i => (U i).comp (h i).right) := by + let := separatedMetric o + exact coefficientFamilyBoundary_add o + (fun i => ripsSpatialOperator r (c i) (hc i)) + (fun i => ripsSpatialOperator r (d i) (hd i)) + (fun i => ripsSpatialOperator r (e i) (he i)) + (C + 2) (D + 2) (K + 2) (by linarith) (by linarith) (by linarith) + (fun i => (ripsSpatialOperator_norm_le r (c i) (hc i)).trans (by linarith [hnC i])) + (fun i => (ripsSpatialOperator_norm_le r (d i) (hd i)).trans (by linarith [hnD i])) + (fun i => (ripsSpatialOperator_norm_le r (e i) (he i)).trans (by linarith [hnE i])) + (r + r) (add_nonneg hr hr) + (fun i => ripsSpatialOperator_propagation r hr (c i) (hc i)) + (fun i => ripsSpatialOperator_propagation r hr (d i) (hd i)) + (fun i => ripsSpatialOperator_propagation r hr (e i) (he i)) + (fun i => ripsSpatialOperator_selfAdjoint r (c i) (hc i) (hsC i)) + (fun i => ripsSpatialOperator_selfAdjoint r (d i) (hd i) (hsD i)) + (fun i => ripsSpatialOperator_selfAdjoint r (e i) (he i) (hsE i)) + (fun i => ripsSpatialOperator_square_compact r (c i) (hc i) (hsC i)) + (fun i => ripsSpatialOperator_square_compact r (d i) (hd i) (hsD i)) + (fun i => ripsSpatialOperator_square_compact r (e i) (he i) (hsE i)) + (fun i => (h i).left) (fun i => (h i).right) + (fun i => (h i).orthogonal) (fun i => (h i).exhaustive) + (fun i => ripsSpatialOperator_directSum_left r (h i) (hc i) (he i)) + (fun i => ripsSpatialOperator_directSum_right r (h i) (hd i) (he i)) U + +theorem ampleRipsFamilyBoundary_directSum + (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c d e : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (h : ∀ i, (c i).IsDirectSum (d i) (e i)) + (hc : ∀ i, (c i).representation 1 = 1) (hd : ∀ i, (d i).representation 1 = 1) + (he : ∀ i, (e i).representation 1 = 1) + (hsC : ∀ i, IsSelfAdjoint (c i).operator) (hsD : ∀ i, IsSelfAdjoint (d i).operator) + (hsE : ∀ i, IsSelfAdjoint (e i).operator) + (C D K : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) (hK : 0 ≤ K) + (hnC : ∀ i, ‖(c i).operator‖ ≤ C) (hnD : ∀ i, ‖(d i).operator‖ ≤ D) + (hnE : ∀ i, ‖(e i).operator‖ ≤ K) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr e he hsE K hK hnE = + ampleRipsFamilyBoundary o r hr c hc hsC C hC hnC + + ampleRipsFamilyBoundary o r hr d hd hsD D hD hnD := by + let := separatedMetric o + let U : ∀ i, (e i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2 := fun i => ampleIsometry (e i).space + calc + _ = ripsFamilyBoundaryWithEmbeddings o r hr e he hsE K hK hnE U := + ampleRipsFamilyBoundary_embeddings o r hr e he hsE K hK hnE U + _ = ripsFamilyBoundaryWithEmbeddings o r hr c hc hsC C hC hnC + (fun i => (U i).comp (h i).left) + + ripsFamilyBoundaryWithEmbeddings o r hr d hd hsD D hD hnD + (fun i => (U i).comp (h i).right) := + ripsFamilyBoundaryWithEmbeddings_directSum o r hr c d e h hc hd he hsC hsD hsE + C D K hC hD hK hnC hnD hnE U + _ = _ := congrArg₂ (fun x y => x + y) + (ampleRipsFamilyBoundary_embeddings o r hr c hc hsC C hC hnC _).symm + (ampleRipsFamilyBoundary_embeddings o r hr d hd hsD D hD hnD _).symm + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsEmbedding.lean b/lean/OAI/Topology/CoarseAssembly/RipsEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..11d0bc539e1bd8c04afed2e08462055323e192ec --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsEmbedding.lean @@ -0,0 +1,102 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.FiniteRips + +namespace OAI + +/-! # Simplicial embeddings and isolated Rips components + +An injective nonexpanding vertex map induces the actual barycentric map. +For an isometric component separated from its complement at the Rips scale, +its realization is a clopen subspace. Finite components are compact, so the +inclusion is proper. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +variable {X Y : Type*} [PseudoMetricSpace X] [PseudoMetricSpace Y] + {r : ℝ} + +@[simp] theorem mapPoint_weight_self (e : X ↪ Y) (he) (p : Point X r) (x : X) : + (mapPoint e he p).weight (e x) = p.weight x := + Finsupp.embDomain_apply_self e p.weight x + +theorem mapPoint_continuous (e : X ↪ Y) (he) : Continuous (mapPoint (r := r) e he) := by + classical + apply continuous_induced_rng.mpr + apply continuous_pi + intro y + change Continuous (fun p : Point X r => coordinates (mapPoint e he p) y) + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simpa only [coordinates, mapPoint, Finsupp.embDomain_apply_self] using + coordinate_continuous (r := r) x + · have hz : (fun p : Point X r => coordinates (mapPoint e he p) y) = fun _ => 0 := by + funext p + exact Finsupp.embDomain_of_notMem_range e p.weight y hy + rw [hz] + exact continuous_const + +theorem mapPoint_injective (e : X ↪ Y) (he) : Function.Injective (mapPoint (r := r) e he) := by + intro p q h + apply Point.ext + apply Finsupp.ext + intro x + have hx := congrArg (fun p : Point Y r => p.weight (e x)) h + simpa only [mapPoint_weight_self] using hx + +theorem coarsen_mapPoint {s : ℝ} (hrs : r ≤ s) (e : X ↪ Y) (he) + (p : Point X r) : coarsen hrs (mapPoint e he p) = mapPoint e he (coarsen hrs p) := by + apply Point.ext + rfl + +theorem mapPoint_range (e : X ↪ Y) (he : Isometry e) : + Set.range (mapPoint (r := r) e (fun x y => (he.dist_eq x y).le)) = + {q : Point Y r | ↑q.weight.support ⊆ Set.range e} := by + classical + ext q + constructor + · rintro ⟨p, rfl⟩ y hy + rw [mapPoint, Finsupp.support_embDomain, Finset.mem_coe, Finset.mem_map] at hy + obtain ⟨x, _, rfl⟩ := hy + exact ⟨x, rfl⟩ + · intro hq + refine ⟨unmapPoint e he q hq, ?_⟩ + apply Point.ext + exact Finsupp.embDomain_comapDomain hq + +theorem mapPoint_range_open (e : X ↪ Y) (he : Isometry e) + (hsep : ∀ x y, y ∉ Set.range e → r < dist (e x) y) : + IsOpen (Set.range (mapPoint (r := r) e (fun x y => (he.dist_eq x y).le))) := by + rw [mapPoint_range e he] + apply isOpen_iff_mem_nhds.mpr + intro q hq + obtain ⟨y, hy⟩ := q.exists_positive + obtain ⟨x, rfl⟩ := hq (Finsupp.mem_support_iff.mpr (ne_of_gt hy)) + have hnhds : {p : Point Y r | 0 < p.weight (e x)} ∈ 𝓝 q := + (isOpen_lt continuous_const (coordinate_continuous (e x))).mem_nhds hy + apply Filter.mem_of_superset hnhds + intro p hp y hy + by_contra hnot + exact (not_le_of_gt (hsep x y hnot)) + (p.diameter (e x) (Finsupp.mem_support_iff.mpr (ne_of_gt hp)) y hy) + +theorem mapPoint_closedEmbedding [Fintype X] (e : X ↪ Y) (he) : + IsClosedEmbedding (mapPoint (r := r) e he) := + (mapPoint_continuous e he).isClosedEmbedding (mapPoint_injective e he) + +def componentInclusion [Fintype X] (e : X ↪ Y) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + CocompactMap (Point X r) (Point Y r) where + toFun := mapPoint e he + continuous_toFun := mapPoint_continuous e he + cocompact_tendsto' := (mapPoint_closedEmbedding e he).tendsto_cocompact + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsEmbeddingIndependence.lean b/lean/OAI/Topology/CoarseAssembly/RipsEmbeddingIndependence.lean new file mode 100644 index 0000000000000000000000000000000000000000..977d7e2f5a0d9e0e39278c458d53c07801575f91 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsEmbeddingIndependence.lean @@ -0,0 +1,74 @@ +import OAI.Topology.CoarseAssembly.AmpleRipsFamily +import OAI.Topology.CoarseAssembly.FamilyEmbeddingIndependence +import OAI.Topology.CoarseAssembly.SeparatedBoundaryCongruence + +namespace OAI + +/-! # Whole-union Rips boundaries are independent of the ample embeddings -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +def ripsFamilyBoundaryWithEmbeddings (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖(c i).operator‖ ≤ C) + (V : ∀ i, (c i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) : + letI := separatedMetric o + OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := + coefficientFamilyBoundary o (fun i => ripsSpatialOperator r (c i) (hπ i)) + (C + 2) (by linarith) + (fun i => (ripsSpatialOperator_norm_le r (c i) (hπ i)).trans (by linarith [hc i])) + (r + r) (add_nonneg hr hr) (fun i => ripsSpatialOperator_propagation r hr (c i) (hπ i)) + (fun i => ripsSpatialOperator_selfAdjoint r (c i) (hπ i) (hF i)) + (fun i => ripsSpatialOperator_square_compact r (c i) (hπ i) (hF i)) V + +theorem ripsFamilyBoundaryWithEmbeddings_independent (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖(c i).operator‖ ≤ C) + (V W : ∀ i, (c i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) : + letI := separatedMetric o + ripsFamilyBoundaryWithEmbeddings o r hr c hπ hF C hC hc V = + ripsFamilyBoundaryWithEmbeddings o r hr c hπ hF C hC hc W := by + let := separatedMetric o + apply coefficientFamilyBoundary_independent + +/-- The previously constructed ample boundary is the representative with the chosen embeddings. -/ +theorem ampleRipsFamilyBoundary_eq_withEmbeddings (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖(c i).operator‖ ≤ C) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr c hπ hF C hC hc = + ripsFamilyBoundaryWithEmbeddings o r hr c hπ hF C hC hc + (fun i => ampleIsometry (c i).space) := by + let := separatedMetric o + apply separatedFamilyBoundary_bound_independent + · exact fun i => ampleRipsOperator_selfAdjoint r (c i) (hπ i) (hF i) + · exact fun i => ampleRipsOperator_square_compact r (c i) (hπ i) (hF i) + +/-- In particular, every choice of ample embeddings gives the existing whole-union class. -/ +theorem ampleRipsFamilyBoundary_embeddings (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖(c i).operator‖ ≤ C) + (V : ∀ i, (c i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr c hπ hF C hC hc = + ripsFamilyBoundaryWithEmbeddings o r hr c hπ hF C hC hc V := by + let := separatedMetric o + exact (ampleRipsFamilyBoundary_eq_withEmbeddings o r hr c hπ hF C hC hc).trans + (ripsFamilyBoundaryWithEmbeddings_independent o r hr c hπ hF C hC hc _ V) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsFamilyCompactPerturbation.lean b/lean/OAI/Topology/CoarseAssembly/RipsFamilyCompactPerturbation.lean new file mode 100644 index 0000000000000000000000000000000000000000..756cdd89463903c696c5f8f13e0aab64404c08f1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsFamilyCompactPerturbation.lean @@ -0,0 +1,63 @@ +import OAI.Topology.CoarseAssembly.PartitionCompactPerturbation +import OAI.Topology.CoarseAssembly.SeparatedFamilyPerturbation + +namespace OAI + +/-! # Compact cycle perturbations preserve the whole-union Rips boundary -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] + +theorem ampleRipsFamilyBoundary_eq_of_compact (o : ∀ i, V i) (r : ℝ) (hr : 0 ≤ r) + (c d : ∀ i, OddCycle C(Point (V i) r, ℂ)) + (hπ : ∀ i, (c i).representation 1 = 1) (hρ : ∀ i, (d i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) (hG : ∀ i, IsSelfAdjoint (d i).operator) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hc : ∀ i, ‖(c i).operator‖ ≤ C) (hd : ∀ i, ‖(d i).operator‖ ≤ D) + (hcd : ∀ i, IsCompactOperator (ampleRipsOperator r (c i) (hπ i) - + ampleRipsOperator r (d i) (hρ i))) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr c hπ hF C hC hc = + ampleRipsFamilyBoundary o r hr d hρ hG D hD hd := by + let := separatedMetric o + exact separatedFamilyBoundary_eq_of_component_compact o + (fun i => ampleRipsOperator r (c i) (hπ i)) + (fun i => ampleRipsOperator r (d i) (hρ i)) + (C + 4) (D + 4) (by linarith) (by linarith) + (fun i => (ampleRipsOperator_norm_le r (c i) (hπ i)).trans (by linarith [hc i])) + (fun i => (ampleRipsOperator_norm_le r (d i) (hρ i)).trans (by linarith [hd i])) + (r + r) (r + r) (add_nonneg hr hr) (add_nonneg hr hr) + (fun i => ampleRipsOperator_propagation r hr (c i) (hπ i)) + (fun i => ampleRipsOperator_propagation r hr (d i) (hρ i)) + (fun i => ampleRipsOperator_selfAdjoint r (c i) (hπ i) (hF i)) + (fun i => ampleRipsOperator_selfAdjoint r (d i) (hρ i) (hG i)) + (fun i => ampleRipsOperator_square_compact r (c i) (hπ i) (hF i)) + (fun i => ampleRipsOperator_square_compact r (d i) (hρ i) (hG i)) hcd + +theorem ampleRipsFamilyBoundary_compactPerturb (o : ∀ i, V i) (r : ℝ) (hr : 0 ≤ r) + (c : ∀ i, OddCycle C(Point (V i) r, ℂ)) (K : ∀ i, End (c i).space) + (hK : ∀ i, IsCompactOperator (K i)) + (hKs : ∀ i, IsCompactOperator (star (K i) : End (c i).space)) + (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (hG : ∀ i, IsSelfAdjoint ((c i).operator + K i)) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hc : ∀ i, ‖(c i).operator‖ ≤ C) (hd : ∀ i, ‖(c i).operator + K i‖ ≤ D) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr (fun i => (c i).compactPerturb (K i) (hK i) (hKs i)) + hπ hG D hD hd = ampleRipsFamilyBoundary o r hr c hπ hF C hC hc := by + let := separatedMetric o + apply ampleRipsFamilyBoundary_eq_of_compact + exact fun i => ampleRipsOperator_compactPerturb r (c i) (hπ i) (K i) (hK i) (hKs i) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsFamilyInclusion.lean b/lean/OAI/Topology/CoarseAssembly/RipsFamilyInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..96f5799ee231130b4f7587cc3732a4b24bbb3c71 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsFamilyInclusion.lean @@ -0,0 +1,63 @@ +import OAI.Topology.CoarseAssembly.SeparatedFamilyInclusion +import OAI.Topology.CoarseAssembly.CoefficientInclusion +import OAI.Topology.CoarseAssembly.ControlledRipsCycles + +namespace OAI + +/-! # Naturality of the controlled Rips boundary under component inclusions -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q P : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + [∀ i, Fintype (Q i)] [∀ i, Fintype (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] {r : ℝ} + +def ControlledCycleFamily.included (c : ControlledCycleFamily Q r) + (e : ∀ i, Q i ↪ P i) (hei : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) : + ControlledCycleFamily P r where + cycle i := includedCycle r (e i) (hei i) (c.cycle i) + unital i := includedCycle_unital r (e i) (hei i) (c.cycle i) (c.unital i) + selfAdjoint := c.selfAdjoint + bound := c.bound + bound_nonneg := c.bound_nonneg + norm_le := c.norm_le + +theorem ControlledCycleFamily.boundary_included (c : ControlledCycleFamily Q r) + (o : ∀ i, Q i) (p : ∀ i, P i) (hr : 0 ≤ r) + (e : ∀ i, Q i ↪ P i) (hei : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) + (he : letI := separatedMetric o; letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y) : + letI := separatedMetric o + letI := separatedMetric p + OperatorKTheory.map (inclusionHom (X := Sigma Q) (Y := Sigma P) (H := lp (fun _ : ℕ => ℂ) 2) + (componentEmbedding e) he) (c.boundary o hr) = + (c.included e hei).boundary p hr := by + let := separatedMetric o + let := separatedMetric p + let d := c.included e hei + exact separatedFamilyBoundary_inclusion o p e he + (fun i => ampleRipsOperator r (c.cycle i) (c.unital i)) + (fun i => ampleRipsOperator r (d.cycle i) (d.unital i)) + (c.bound + 4) (d.bound + 4) (by linarith [c.bound_nonneg]) (by linarith [d.bound_nonneg]) + (fun i => (ampleRipsOperator_norm_le r (c.cycle i) (c.unital i)).trans + (by linarith [c.norm_le i])) + (fun i => (ampleRipsOperator_norm_le r (d.cycle i) (d.unital i)).trans + (by linarith [d.norm_le i])) + (r + r) (r + r) (add_nonneg hr hr) (add_nonneg hr hr) + (fun i => ampleRipsOperator_propagation r hr (c.cycle i) (c.unital i)) + (fun i => ampleRipsOperator_propagation r hr (d.cycle i) (d.unital i)) + (fun i => ampleRipsOperator_selfAdjoint r (c.cycle i) (c.unital i) (c.selfAdjoint i)) + (fun i => ampleRipsOperator_selfAdjoint r (d.cycle i) (d.unital i) (d.selfAdjoint i)) + (fun i => ampleRipsOperator_square_compact r (c.cycle i) (c.unital i) (c.selfAdjoint i)) + (fun i => ampleRipsOperator_square_compact r (d.cycle i) (d.unital i) (d.selfAdjoint i)) + (fun i => ampleRipsOperator_inclusion r (e i) (hei i) (c.cycle i) (c.unital i)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsFamilyMap.lean b/lean/OAI/Topology/CoarseAssembly/RipsFamilyMap.lean new file mode 100644 index 0000000000000000000000000000000000000000..594732e667ba6ede30c17e33b794517909deffb8 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsFamilyMap.lean @@ -0,0 +1,99 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.SeparatedRips +import OAI.Topology.CoarseAssembly.RipsCompactSupport + +namespace OAI + +/-! # Proper maps from componentwise compact families into Rips realizations + +The boundary family will be a countable family of parametrized circles. +Compact subsets of the target use finitely many vertices, hence meet only +finitely many members of this family. This proves properness directly. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Topology Rips + +variable {V : ℕ → Type} [∀ j, MetricSpace (V j)] + {Z : ℕ → Type} [∀ j, TopologicalSpace (Z j)] [∀ j, CompactSpace (Z j)] + +theorem separatedRipsMap_continuous (o : ∀ j, V j) (r : ℝ) (j : ℕ) : + letI := separatedMetric o + Continuous (separatedRipsMap o r j) := by + let := separatedMetric o + exact mapPoint_continuous (separatedComponent j) + (fun x y => ((separatedComponent_isometry o j).dist_eq x y).le) + +@[simp] theorem separatedRipsMap_weight (o : ∀ j, V j) (r : ℝ) (j : ℕ) + (p : Point (V j) r) (x : V j) : + letI := separatedMetric o + (separatedRipsMap o r j p).weight ⟨j, x⟩ = p.weight x := by + let := separatedMetric o + exact mapPoint_weight_self (separatedComponent j) + (fun x y => ((separatedComponent_isometry o j).dist_eq x y).le) p x + +def ripsFamilyContinuousMap (o : ∀ j, V j) (r : ℝ) + (γ : ∀ j, C(Z j, Point (V j) r)) : + letI := separatedMetric o + C(Sigma Z, Point (Sigma V) r) := by + let := separatedMetric o + refine ⟨fun z => separatedRipsMap o r z.1 (γ z.1 z.2), ?_⟩ + exact continuous_sigma (fun j => (separatedRipsMap_continuous o r j).comp (γ j).continuous) + +variable [∀ j, Fintype (V j)] + +theorem ripsFamily_preimage_compact (o : ∀ j, V j) (r : ℝ) + (γ : ∀ j, C(Z j, Point (V j) r)) : + letI := separatedMetric o + ∀ K, IsCompact K → IsCompact ((ripsFamilyContinuousMap o r γ) ⁻¹' K) := by + classical + let := separatedMetric o + intro K hK + obtain ⟨s, hs⟩ := compact_support_finite (fun x => separated_closedBall_finite o x r) hK + let a : Finset ℕ := s.image Sigma.fst + have hcover : (ripsFamilyContinuousMap o r γ) ⁻¹' K ⊆ + ⋃ j ∈ a, Set.range (@Sigma.mk ℕ Z j) := by + rintro ⟨j, z⟩ hz + obtain ⟨x, hx⟩ := (γ j z).exists_positive + have hmem : (⟨j, x⟩ : Sigma V) ∈ s := hs _ hz + (Finsupp.mem_support_iff.mpr (by + change (separatedRipsMap o r j (γ j z)).weight ⟨j, x⟩ ≠ 0 + rw [separatedRipsMap_weight] + exact ne_of_gt hx)) + have hj : j ∈ a := Finset.mem_image.mpr ⟨⟨j, x⟩, hmem, rfl⟩ + exact Set.mem_iUnion₂.mpr ⟨j, hj, ⟨z, rfl⟩⟩ + have hcompact : IsCompact (⋃ j ∈ a, Set.range (@Sigma.mk ℕ Z j)) := + a.isCompact_biUnion (fun j _ => isCompact_range continuous_sigmaMk) + exact hcompact.of_isClosed_subset + (hK.isClosed.preimage (ripsFamilyContinuousMap o r γ).continuous) hcover + +def ripsFamilyMap (o : ∀ j, V j) (r : ℝ) + (γ : ∀ j, C(Z j, Point (V j) r)) : + letI := separatedMetric o + CocompactMap (Sigma Z) (Point (Sigma V) r) := by + let := separatedMetric o + exact + { toContinuousMap := ripsFamilyContinuousMap o r γ + cocompact_tendsto' := CocompactMap.tendsto_of_forall_preimage + (ripsFamily_preimage_compact o r γ) } + +theorem ripsFamilyMap_coarsen (o : ∀ j, V j) {r s : ℝ} (hrs : r ≤ s) + (γ : ∀ j, C(Z j, Point (V j) r)) (δ : ∀ j, C(Z j, Point (V j) s)) + (hγ : ∀ j z, coarsen hrs (γ j z) = δ j z) : + letI := separatedMetric o + (inclusion hrs).comp (ripsFamilyMap o r γ) = ripsFamilyMap o s δ := by + let := separatedMetric o + apply CocompactMap.ext + rintro ⟨j, z⟩ + change coarsen hrs (separatedRipsMap o r j (γ j z)) = separatedRipsMap o s j (δ j z) + dsimp only [separatedRipsMap] + rw [coarsen_mapPoint, hγ] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsFamilyRestriction.lean b/lean/OAI/Topology/CoarseAssembly/RipsFamilyRestriction.lean new file mode 100644 index 0000000000000000000000000000000000000000..8f2686e980054b1245d2307d6418fa87fdb5186c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsFamilyRestriction.lean @@ -0,0 +1,74 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsFamilyMap +import OAI.Topology.CoarseAssembly.CountableAdditivity +import OAI.Topology.CoarseAssembly.ClopenNaturality + +namespace OAI + +/-! # Exact coordinates of the pushed-forward family + +Restriction to a late Rips component recovers precisely the corresponding +member of the source family, irrespective of links among other components. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Topology Rips Analytic + +variable {V : ℕ → Type} [∀ j, MetricSpace (V j)] [∀ j, Fintype (V j)] + {Z : ℕ → Type} [∀ j, TopologicalSpace (Z j)] [∀ j, CompactSpace (Z j)] + +theorem separatedRipsEmbedding_open (o : ∀ j, V j) (r : ℝ) (j : ℕ) (hj : r < j) : + letI := separatedMetric o + IsOpenEmbedding (separatedRipsEmbedding o r j) := lateRipsComponent_openEmbedding o j r hj + +theorem ripsFamily_component_preimage (o : ∀ j, V j) (r : ℝ) + (γ : ∀ j, C(Z j, Point (V j) r)) (j : ℕ) : + letI := separatedMetric o + ∀ z, ripsFamilyMap o r γ z ∈ Set.range (separatedRipsEmbedding o r j) ↔ + z ∈ Set.range (sigmaComponent Z j) := by + let := separatedMetric o + rintro ⟨k, z⟩ + constructor + · intro h + have hs : ↑(ripsFamilyMap o r γ ⟨k, z⟩).weight.support ⊆ + Set.range (separatedComponent (V := V) j) := by + exact (Set.ext_iff.mp (mapPoint_range (separatedComponent j) + (separatedComponent_isometry o j)) _).mp h + obtain ⟨x, hx⟩ := (γ k z).exists_positive + have hmem : (⟨k, x⟩ : Sigma V) ∈ (ripsFamilyMap o r γ ⟨k, z⟩).weight.support := by + apply Finsupp.mem_support_iff.mpr + change (separatedRipsMap o r k (γ k z)).weight ⟨k, x⟩ ≠ 0 + rw [separatedRipsMap_weight] + exact ne_of_gt hx + obtain ⟨y, hy⟩ := hs hmem + have hjk : j = k := congrArg Sigma.fst hy + subst k + exact ⟨z, rfl⟩ + · rintro ⟨z', hz'⟩ + change Sigma.mk j z' = Sigma.mk k z at hz' + cases hz' + exact ⟨γ j z', rfl⟩ + +theorem ripsFamily_restriction [∀ j, T2Space (Z j)] (o : ∀ j, V j) (r : ℝ) + (γ : ∀ j, C(Z j, Point (V j) r)) (j : ℕ) (hj : r < j) + (hadd : CountableAdditivityInput Z) (a : ∀ k, LocallyFiniteK1 (Z k)) : + letI := separatedMetric o + restrictComponent (separatedRipsEmbedding o r j) (separatedRipsEmbedding_open o r j hj) + (pushforward (ripsFamilyMap o r γ) (familyClass Z hadd a)) = + pushforward (compactMap (γ j)) (a j) := by + let := separatedMetric o + have h := restrictComponent_natural (sigmaComponent Z j) (sigmaComponent_open Z j) + (separatedRipsEmbedding o r j) (separatedRipsEmbedding_open o r j hj) + (ripsFamilyMap o r γ) (compactMap (γ j)) (fun _ => rfl) + (ripsFamily_component_preimage o r γ j) + have heq := DFunLike.congr_fun h (familyClass Z hadd a) + simpa only [AddMonoidHom.comp_apply, familyClass_coordinate] using heq + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsFiniteHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/RipsFiniteHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..80acef2375ce410347736135a8d4a086eff4cc5b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsFiniteHomotopy.lean @@ -0,0 +1,92 @@ +import OAI.Topology.CoarseAssembly.LocalizationContinuity +import OAI.Topology.CoarseAssembly.SeparatedFamilyHomotopy + +namespace OAI + +/-! # Whole-union invariance for finitely supported analytic homotopies + +The representations may vary throughout the homotopy. Finitely many changing +components give the uniform continuity required by the actual Roe algebra. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Filter Topology + +theorem uniform_continuity_of_finite_variation {T I : Type*} [TopologicalSpace T] + {E : I → Type*} [∀ i, NormedAddCommGroup (E i)] + (f : ∀ i, T → E i) (hf : ∀ i, Continuous (f i)) + (s : Finset I) (hfix : ∀ i ∉ s, ∀ t u, f i t = f i u) : + ∀ t ε, 0 < ε → ∀ᶠ u in 𝓝 t, ∀ i, ‖f i u - f i t‖ ≤ ε := by + intro t ε hε + have hi : ∀ i ∈ s, ∀ᶠ u in 𝓝 t, ‖f i u - f i t‖ < ε := by + intro i _ + have hc : ContinuousAt (fun u => ‖f i u - f i t‖) t := + ((hf i).sub continuous_const).norm.continuousAt + exact hc.eventually (gt_mem_nhds (by simpa using hε)) + filter_upwards [(Filter.eventually_all_finset s).mpr hi] with u hu + intro i + by_cases his : i ∈ s + · exact (hu i his).le + · rw [hfix i his u t, sub_self, norm_zero] + exact hε.le + +namespace Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +theorem ampleRipsFamilyBoundary_finiteHomotopy + (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (h : ∀ i, OddHomotopy C(Point (Q i) r, ℂ)) + (hπ : ∀ t i, ((h i).eval t).representation 1 = 1) + (hF : ∀ t i, IsSelfAdjoint ((h i).eval t).operator) + (C : ℝ) (hC : 0 ≤ C) (hnorm : ∀ t i, ‖(h i).operator t‖ ≤ C) + (s : Finset ℕ) + (hfix : ∀ i ∉ s, ∀ t u, + (h i).representation t = (h i).representation u ∧ + (h i).operator t = (h i).operator u) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval start) (hπ start) (hF start) + C hC (hnorm start) = + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval finish) (hπ finish) (hF finish) + C hC (hnorm finish) := by + let := separatedMetric o + have hstatic : ∀ i ∉ s, ∀ t u, + ampleRipsOperator r ((h i).eval t) (hπ t i) = + ampleRipsOperator r ((h i).eval u) (hπ u i) := by + intro i hi t u + obtain ⟨hrep, hop⟩ := hfix i hi t u + have ha : (show Q i → End (h i).space from representedSqrt r ((h i).eval t)) = + (show Q i → End (h i).space from representedSqrt r ((h i).eval u)) := by + funext x + exact congrArg (fun ρ => ρ (sqrtCoordinate r x)) hrep + change coefficientExtension (ampleIsometry (h i).space) + (localizedSpatialOperator _ _ ((h i).operator t)) = + coefficientExtension (ampleIsometry (h i).space) + (localizedSpatialOperator _ _ ((h i).operator u)) + simp only [ha, hop] + have hcont := uniform_continuity_of_finite_variation + (fun i t => ampleRipsOperator r ((h i).eval t) (hπ t i)) + (fun i => continuous_ampleRipsOperator r (h i) (fun t => hπ t i)) s hstatic + exact separatedFamilyBoundary_homotopy o + (fun t i => ampleRipsOperator r ((h i).eval t) (hπ t i)) + (C + 4) (by linarith) + (fun t i => (ampleRipsOperator_norm_le r ((h i).eval t) (hπ t i)).trans + (show ‖((h i).eval t).operator‖ + 4 ≤ C + 4 from add_le_add (hnorm t i) le_rfl)) + (r + r) (add_nonneg hr hr) + (fun t i => ampleRipsOperator_propagation r hr ((h i).eval t) (hπ t i)) + (fun t i => ampleRipsOperator_selfAdjoint r ((h i).eval t) (hπ t i) (hF t i)) + (fun t i => ampleRipsOperator_square_compact r ((h i).eval t) (hπ t i) (hF t i)) hcont + +end Rips + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsFiniteTail.lean b/lean/OAI/Topology/CoarseAssembly/RipsFiniteTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..4de250108543e4fab05a5b95f4c45c98ecf359ef --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsFiniteTail.lean @@ -0,0 +1,56 @@ +import OAI.Topology.CoarseAssembly.FiniteTailIndependence +import OAI.Topology.CoarseAssembly.ControlledRipsCycles +import OAI.Topology.CoarseAssembly.CountableHilbertSum + +namespace OAI + +/-! # Finite-tail invariance for the analytic Rips boundary -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +abbrev scalarHilbert : HilbertSpace where + Carrier := ℂ + normed := inferInstance + inner := inferInstance + complete := inferInstance + secondCountable := inferInstance + +local instance : SecondCountableTopology (lp (fun _ : ℕ => ℂ) 2) := + hilbertSum_secondCountable (fun _ => scalarHilbert) + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r s : ℝ} + +theorem ControlledCycleFamily.boundary_eq_of_tail + (c : ControlledCycleFamily Q r) (d : ControlledCycleFamily Q s) + (o : ∀ i, Q i) (hr : 0 ≤ r) (hs : 0 ≤ s) (J : Finset ℕ) + (htail : ∀ i, i ∉ J → + ampleRipsOperator r (c.cycle i) (c.unital i) = ampleRipsOperator s (d.cycle i) (d.unital i)) : + c.boundary o hr = d.boundary o hs := by + let := separatedMetric o + exact separatedFamilyBoundary_eq_of_tail o + (fun i => ampleRipsOperator r (c.cycle i) (c.unital i)) + (fun i => ampleRipsOperator s (d.cycle i) (d.unital i)) + (c.bound + 4) (d.bound + 4) (by linarith [c.bound_nonneg]) (by linarith [d.bound_nonneg]) + (fun i => (ampleRipsOperator_norm_le r (c.cycle i) (c.unital i)).trans + (by linarith [c.norm_le i])) + (fun i => (ampleRipsOperator_norm_le s (d.cycle i) (d.unital i)).trans + (by linarith [d.norm_le i])) + (r + r) (s + s) (add_nonneg hr hr) (add_nonneg hs hs) + (fun i => ampleRipsOperator_propagation r hr (c.cycle i) (c.unital i)) + (fun i => ampleRipsOperator_propagation s hs (d.cycle i) (d.unital i)) + (fun i => ampleRipsOperator_selfAdjoint r (c.cycle i) (c.unital i) (c.selfAdjoint i)) + (fun i => ampleRipsOperator_selfAdjoint s (d.cycle i) (d.unital i) (d.selfAdjoint i)) + (fun i => ampleRipsOperator_square_compact r (c.cycle i) (c.unital i) (c.selfAdjoint i)) + (fun i => ampleRipsOperator_square_compact s (d.cycle i) (d.unital i) (d.selfAdjoint i)) + J htail + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsFixedRepresentationHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/RipsFixedRepresentationHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..51075ba71719061dcad27b48c3c9afb3860c1ccb --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsFixedRepresentationHomotopy.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.LocalizationNormContinuity +import OAI.Topology.CoarseAssembly.SeparatedFamilyHomotopy + +namespace OAI + +/-! # Uniform operator homotopies with fixed representations + +The hypothesis controls the whole family's operator norm. Representation- +varying homotopies and quotient descent are separate obligations. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe Filter Topology + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +theorem ampleRipsFamilyBoundary_fixedRepresentationHomotopy + (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (h : ∀ i, OddHomotopy C(Point (Q i) r, ℂ)) + (hrep : ∀ s t i, (h i).representation s = (h i).representation t) + (hπ : ∀ t i, ((h i).eval t).representation 1 = 1) + (hF : ∀ t i, IsSelfAdjoint ((h i).eval t).operator) + (C : ℝ) (hC : 0 ≤ C) (hnorm : ∀ t i, ‖(h i).operator t‖ ≤ C) + (hcont : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, ‖(h i).operator s - (h i).operator t‖ ≤ ε) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval start) (hπ start) (hF start) + C hC (hnorm start) = + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval finish) (hπ finish) (hF finish) + C hC (hnorm finish) := by + let := separatedMetric o + have hcontinuous : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, + ‖ampleRipsOperator r ((h i).eval s) (hπ s i) - + ampleRipsOperator r ((h i).eval t) (hπ t i)‖ ≤ ε := by + intro t ε hε + filter_upwards [hcont t ε hε] with s hs + intro i + exact (ampleRipsOperator_homotopy_norm_le r (h i) s t (hπ s i) (hπ t i) + (hrep s t i)).trans (hs i) + exact separatedFamilyBoundary_homotopy o + (fun t i => ampleRipsOperator r ((h i).eval t) (hπ t i)) + (C + 4) (by linarith) + (fun t i => (ampleRipsOperator_norm_le r ((h i).eval t) (hπ t i)).trans + (show ‖((h i).eval t).operator‖ + 4 ≤ C + 4 from + add_le_add (hnorm t i) le_rfl)) + (r + r) (add_nonneg hr hr) + (fun t i => ampleRipsOperator_propagation r hr ((h i).eval t) (hπ t i)) + (fun t i => ampleRipsOperator_selfAdjoint r ((h i).eval t) (hπ t i) (hF t i)) + (fun t i => ampleRipsOperator_square_compact r ((h i).eval t) (hπ t i) (hF t i)) hcontinuous + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsInclusionNaturality.lean b/lean/OAI/Topology/CoarseAssembly/RipsInclusionNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..b2afe4943cf39fe3605bca109f0ee8219221d2db --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsInclusionNaturality.lean @@ -0,0 +1,76 @@ +import OAI.Topology.CoarseAssembly.RipsLocalization +import OAI.Topology.CoarseAssembly.RipsEmbedding +import OAI.Topology.CoarseAssembly.PartitionInclusion + +namespace OAI + +/-! # Finite-Rips localization respects an actual vertex inclusion -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X Y : Type} [PseudoMetricSpace X] [PseudoMetricSpace Y] + [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] + (r : ℝ) (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) + +def inclusionFunctionHom : C(Point Y r, ℂ) →⋆ₐ[ℂ] C(Point X r, ℂ) := + ContinuousMap.compStarAlgHom' ℂ ℂ ⟨mapPoint e he, mapPoint_continuous e he⟩ + +omit [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] in +theorem inclusionFunctionHom_sqrt (x : X) : + inclusionFunctionHom r e he (sqrtCoordinate r (e x)) = sqrtCoordinate r x := by + ext p + change (Real.sqrt ((mapPoint e he p).weight (e x)) : ℂ) = _ + rw [mapPoint_weight_self] + rfl + +omit [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] in +theorem inclusionFunctionHom_sqrt_zero (y : Y) (hy : y ∉ Set.range e) : + inclusionFunctionHom r e he (sqrtCoordinate r y) = 0 := by + ext p + change (Real.sqrt ((mapPoint e he p).weight y) : ℂ) = 0 + rw [show (mapPoint e he p).weight y = 0 from + Finsupp.embDomain_of_notMem_range e p.weight y hy] + simp + +def includedCycle (c : OddCycle C(Point X r, ℂ)) : OddCycle C(Point Y r, ℂ) := + c.precomp (inclusionFunctionHom r e he).toNonUnitalStarAlgHom + +omit [DecidableEq X] [DecidableEq Y] in +theorem includedCycle_unital (c : OddCycle C(Point X r, ℂ)) (hπ : c.representation 1 = 1) : + (includedCycle r e he c).representation 1 = 1 := by + change c.representation (inclusionFunctionHom r e he 1) = 1 + rw [map_one, hπ] + +omit [DecidableEq X] [DecidableEq Y] in +theorem includedCycle_representedSqrt (c : OddCycle C(Point X r, ℂ)) (x : X) : + representedSqrt r (includedCycle r e he c) (e x) = representedSqrt r c x := by + change c.representation (inclusionFunctionHom r e he (sqrtCoordinate r (e x))) = _ + rw [inclusionFunctionHom_sqrt] + rfl + +omit [DecidableEq X] [DecidableEq Y] in +theorem includedCycle_representedSqrt_zero (c : OddCycle C(Point X r, ℂ)) + (y : Y) (hy : y ∉ Set.range e) : + representedSqrt r (includedCycle r e he c) y = 0 := by + change c.representation (inclusionFunctionHom r e he (sqrtCoordinate r y)) = 0 + rw [inclusionFunctionHom_sqrt_zero r e he y hy, map_zero] + +theorem ripsSpatialOperator_inclusion (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : + ripsSpatialOperator r (includedCycle r e he c) (includedCycle_unital r e he c hπ) = + isometricExtension (inclusionIsometry e) (ripsSpatialOperator r c hπ) := by + exact localizedSpatialOperator_inclusion e (representedSqrt r c) + (representedSqrt r (includedCycle r e he c)) (representedSqrt_partition r c hπ) + (representedSqrt_partition r (includedCycle r e he c) (includedCycle_unital r e he c hπ)) + (includedCycle_representedSqrt r e he c) + (includedCycle_representedSqrt_zero r e he c) c.operator + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsLocalization.lean b/lean/OAI/Topology/CoarseAssembly/RipsLocalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..8550efa0500ac915b0a57bf6458dff8813221fd2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsLocalization.lean @@ -0,0 +1,93 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsPartition +import OAI.Topology.CoarseAssembly.SpatialLocalization + +namespace OAI + +/-! # The spatial localization of a unital finite-Rips Fredholm cycle -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ) + +omit [DecidableEq X] in +theorem representedSqrt_adjoint (c : OddCycle C(Point X r, ℂ)) (x : X) : + (representedSqrt r c x).adjoint = representedSqrt r c x := by + exact ((sqrtCoordinate_selfAdjoint r x).map c.representation).star_eq + +omit [DecidableEq X] in +theorem representedSqrt_partition (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : + ∑ x, (representedSqrt r c x).adjoint.comp (representedSqrt r c x) = 1 := by + simp only [representedSqrt_adjoint] + change (∑ x, c.representation (sqrtCoordinate r x) * + c.representation (sqrtCoordinate r x)) = 1 + simp only [← map_mul, ← map_sum, sqrtCoordinate_square_sum, hπ] + +omit [DecidableEq X] in +theorem representedSqrt_disjoint (c : OddCycle C(Point X r, ℂ)) + (x y : X) (hxy : r < dist x y) : + representedSqrt r c x * representedSqrt r c y = 0 := by + change c.representation (sqrtCoordinate r x) * c.representation (sqrtCoordinate r y) = 0 + rw [← map_mul, sqrtCoordinate_mul_eq_zero r x y hxy, map_zero] + +theorem ripsCompression_eq_localized (c : OddCycle C(Point X r, ℂ)) : + partitionCompression (representedSqrt r c) c.operator = + localizedOperator c (sqrtCoordinate r) := by + rw [partitionCompression_eq_sum] + simp only [representedSqrt_adjoint] + apply Finset.sum_congr rfl + intro x _ + change (c.representation (sqrtCoordinate r x)).comp + (c.operator.comp (c.representation (sqrtCoordinate r x))) = + (c.representation (sqrtCoordinate r x) * c.operator) * + c.representation (sqrtCoordinate r x) + exact (ContinuousLinearMap.comp_assoc _ _ _).symm + +theorem ripsSpatialOperator_propagation (hr : 0 ≤ r) (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : PropagationLE (r + r) (ripsSpatialOperator r c hπ) := + localizedSpatialOperator_propagation _ _ (representedSqrt_adjoint r c) r hr + (representedSqrt_disjoint r c) c.operator + +theorem ripsSpatialOperator_norm_le (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : ‖ripsSpatialOperator r c hπ‖ ≤ ‖c.operator‖ + 2 := + localizedSpatialOperator_norm_le _ _ _ + +theorem ripsSpatialOperator_selfAdjoint (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + IsSelfAdjoint (ripsSpatialOperator r c hπ) := + localizedSpatialOperator_selfAdjoint _ _ _ hF + +theorem ripsCompression_square_compact (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + IsCompactOperator (partitionCompression (representedSqrt r c) c.operator * + partitionCompression (representedSqrt r c) c.operator - (1 : End c.space)) := by + have hp : ∑ x, c.representation (sqrtCoordinate r x) * + c.representation (sqrtCoordinate r x) = 1 := by + simp only [← map_mul, ← map_sum, sqrtCoordinate_square_sum, hπ] + let d := localizedCycle c (sqrtCoordinate r) hF (sqrtCoordinate_selfAdjoint r) hp + have hd := d.square_compact 1 + change IsCompactOperator (((c.operator + (localizedOperator c (sqrtCoordinate r) - c.operator)) * + (c.operator + (localizedOperator c (sqrtCoordinate r) - c.operator)) - (1 : End c.space)) * + c.representation 1) at hd + have he : c.operator + (localizedOperator c (sqrtCoordinate r) - c.operator) = + localizedOperator c (sqrtCoordinate r) := by abel + rw [he, hπ, mul_one] at hd + rw [ripsCompression_eq_localized] + exact hd + +theorem ripsSpatialOperator_square_compact (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) (hF : IsSelfAdjoint c.operator) : + IsCompactOperator (ripsSpatialOperator r c hπ * ripsSpatialOperator r c hπ - + (1 : Operator X c.space)) := + isometricExtension_square_compact _ _ (ripsCompression_square_compact r c hπ hF) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsMapCalculus.lean b/lean/OAI/Topology/CoarseAssembly/RipsMapCalculus.lean new file mode 100644 index 0000000000000000000000000000000000000000..339dbc82a51710e79957244b193257821ef1f8cb --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsMapCalculus.lean @@ -0,0 +1,102 @@ +import OAI.Topology.CoarseAssembly.RipsProperEmbedding +import OAI.Topology.CoarseAssembly.CocyclePathLifting +import OAI.Topology.CoarseAssembly.LoopCircle + +namespace OAI + +/-! # Exact naturality of the parametrized Rips paths + +Injective nonexpanding vertex maps commute with barycentric interpolation, +edge paths and concatenated graph walks, including their parametrizations. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +variable {X Y Z : Type*} [PseudoMetricSpace X] [PseudoMetricSpace Y] [PseudoMetricSpace Z] + {r : ℝ} + +theorem mapPoint_weight (e : X ↪ Y) (he) (p : Point X r) : + (mapPoint e he p).weight = p.weight.embDomain e := rfl + +theorem mapPoint_comp (e : X ↪ Y) (f : Y ↪ Z) (he) (hf) (p : Point X r) : + mapPoint f hf (mapPoint e he p) = + mapPoint (e.trans f) (fun x y => (hf (e x) (e y)).trans (he x y)) p := by + apply Point.ext + exact (Finsupp.embDomain_trans_apply p.weight e f).symm + +theorem mapPoint_vertex (e : X ↪ Y) (he) (x : X) (hr : 0 ≤ r) : + mapPoint e he (vertex x hr) = vertex (e x) hr := by + apply Point.ext + exact Finsupp.embDomain_single e x 1 + +theorem mapPoint_interpolate (e : X ↪ Y) (he) (p q : Point X r) (hpq) (t : unitInterval) : + mapPoint e he (interpolate p q hpq t) = + interpolate (mapPoint e he p) (mapPoint e he q) + (by + intro x hx y hy + change x ∈ (p.weight.embDomain e).support at hx + change y ∈ (q.weight.embDomain e).support at hy + rw [Finsupp.support_embDomain, Finset.mem_map] at hx hy + obtain ⟨a, ha, rfl⟩ := hx + obtain ⟨b, hb, rfl⟩ := hy + exact (he a b).trans (hpq a ha b hb)) t := by + classical + apply Point.ext + apply Finsupp.ext + intro y + by_cases hy : y ∈ Set.range e + · obtain ⟨x, rfl⟩ := hy + simp only [mapPoint, interpolate, Finsupp.embDomain_apply_self, Finsupp.coe_add, + Pi.add_apply, Finsupp.coe_smul, Pi.smul_apply] + · simp only [mapPoint, interpolate, Finsupp.embDomain_of_notMem_range _ _ _ hy, + Finsupp.coe_add, Pi.add_apply, Finsupp.coe_smul, Pi.smul_apply, smul_zero, add_zero] + +theorem mapPoint_edgePath (e : X ↪ Y) (he) {x y : X} (hxy : dist x y ≤ r) + (t : unitInterval) : + mapPoint e he (edgePath hxy t) = edgePath ((he x y).trans hxy) t := by + simp only [edgePath, simplexPath, Path.coe_mk_mk] + rw [mapPoint_interpolate] + apply Point.ext + change (1 - (t : ℝ)) • (mapPoint e he (vertex x _)).weight + + (t : ℝ) • (mapPoint e he (vertex y _)).weight = _ + rw [congrArg Point.weight (mapPoint_vertex e he x _), + congrArg Point.weight (mapPoint_vertex e he y _)] + rfl + +theorem mapPoint_walkPath {G : SimpleGraph X} {H : SimpleGraph Y} + (e : X ↪ Y) (he) (hgraph : ∀ x y, G.Adj x y → H.Adj (e x) (e y)) + (hr : 0 ≤ r) (hG : ∀ x y, G.Adj x y → dist x y ≤ r) + (hH : ∀ x y, H.Adj x y → dist x y ≤ r) + {x y : X} (p : G.Walk x y) (t : unitInterval) : + mapPoint e he (walkPath hr hG p t) = + walkPath hr hH (p.map ⟨e, fun h => hgraph _ _ h⟩) t := by + induction p generalizing t with + | nil => + change mapPoint e he (vertex _ hr) = vertex _ hr + exact mapPoint_vertex e he _ hr + | cons h p ih => + simp only [walkPath, SimpleGraph.Walk.map_cons, Path.trans_apply] + split_ifs + · exact mapPoint_edgePath e he (hG _ _ h) _ + · exact ih _ + +theorem mapPoint_loopCircle {G : SimpleGraph X} {H : SimpleGraph Y} + (e : X ↪ Y) (he) (hgraph : ∀ x y, G.Adj x y → H.Adj (e x) (e y)) + (hr : 0 ≤ r) (hG : ∀ x y, G.Adj x y → dist x y ≤ r) + (hH : ∀ x y, H.Adj x y → dist x y ≤ r) + {x : X} (p : G.Walk x x) (z : WindingCircle) : + mapPoint e he (loopCircle (walkPath hr hG p) z) = + loopCircle (walkPath hr hH (p.map ⟨e, fun h => hgraph _ _ h⟩)) z := by + obtain ⟨t, rfl⟩ := circle_parameter_surjective z + simp only [loopCircle_apply] + exact mapPoint_walkPath e he hgraph hr hG hH p t + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsPartition.lean b/lean/OAI/Topology/CoarseAssembly/RipsPartition.lean new file mode 100644 index 0000000000000000000000000000000000000000..c2f202e6b838bbf4e3260cbd5e995064accac94f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsPartition.lean @@ -0,0 +1,56 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.FiniteRips +import OAI.Topology.CoarseAssembly.FiniteLocalization +import Mathlib.Analysis.SpecialFunctions.Sqrt +import Mathlib.Analysis.CStarAlgebra.ContinuousMap + +namespace OAI + +/-! # The explicit square partition on a finite Rips realization -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] (r : ℝ) + +omit [Fintype X] in +@[simp] theorem sqrtCoordinate_selfAdjoint (x : X) : + IsSelfAdjoint (sqrtCoordinate r x) := by + ext p + simp [sqrtCoordinate] + +theorem sqrtCoordinate_square_sum : + ∑ x : X, sqrtCoordinate r x * sqrtCoordinate r x = 1 := by + ext p + change (ContinuousMap.evalAlgHom ℂ ℂ p) + (∑ x : X, sqrtCoordinate r x * sqrtCoordinate r x) = 1 + rw [map_sum] + simp only [map_mul] + change (∑ x : X, (Real.sqrt (p.weight x) : ℂ) * (Real.sqrt (p.weight x) : ℂ)) = 1 + simp only [← Complex.ofReal_mul, Real.mul_self_sqrt (p.nonneg _)] + rw [← Complex.ofReal_sum, p.sum_weight, Complex.ofReal_one] + +omit [Fintype X] in +theorem sqrtCoordinate_mul_eq_zero (x y : X) (hxy : r < dist x y) : + sqrtCoordinate r x * sqrtCoordinate r y = 0 := by + ext p + have hz : p.weight x = 0 ∨ p.weight y = 0 := by + by_contra h + push Not at h + exact (not_le_of_gt hxy) (p.diameter x (Finsupp.mem_support_iff.mpr h.1) + y (Finsupp.mem_support_iff.mpr h.2)) + rcases hz with hx | hy + · simp [sqrtCoordinate, hx] + · simp [sqrtCoordinate, hy] + +theorem represented_sqrtCoordinate_square_sum + {H : Analytic.HilbertSpace} (π : C(Point X r, ℂ) →⋆ₐ[ℂ] Analytic.End H) : + ∑ x, π (sqrtCoordinate r x) * π (sqrtCoordinate r x) = 1 := by + simp only [← map_mul, ← map_sum, sqrtCoordinate_square_sum, map_one] + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsPathCoarsening.lean b/lean/OAI/Topology/CoarseAssembly/RipsPathCoarsening.lean new file mode 100644 index 0000000000000000000000000000000000000000..2e4caa5744441736e5b31ba5462cfb89311ac9d0 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsPathCoarsening.lean @@ -0,0 +1,60 @@ +import OAI.Topology.CoarseAssembly.CocyclePathLifting +import OAI.Topology.CoarseAssembly.LoopCircle + +namespace OAI + +/-! # Coarsening preserves the parametrized graph loop + +The paths at different Rips scales are the same barycentric paths. This +gives equality of their pushed-forward analytic classes, not merely a +choice of unrelated loops at successive scales. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +variable {X : Type*} [PseudoMetricSpace X] {r s : ℝ} + +theorem coarsen_interpolate (hrs : r ≤ s) (p q : Point X r) (hpq) (t : unitInterval) : + coarsen hrs (interpolate p q hpq t) = + interpolate (coarsen hrs p) (coarsen hrs q) + (fun x hx y hy => (hpq x hx y hy).trans hrs) t := by + apply Point.ext + rfl + +theorem coarsen_edgePath (hrs : r ≤ s) {x y : X} (hxy : dist x y ≤ r) (t : unitInterval) : + coarsen hrs (edgePath hxy t) = edgePath (hxy.trans hrs) t := by + apply Point.ext + rfl + +theorem coarsen_walkPath {G : SimpleGraph X} (hrs : r ≤ s) (hr : 0 ≤ r) + (hE : ∀ x y, G.Adj x y → dist x y ≤ r) {x y : X} (p : G.Walk x y) + (t : unitInterval) : + coarsen hrs (walkPath hr hE p t) = + walkPath (hr.trans hrs) (fun x y h => (hE x y h).trans hrs) p t := by + induction p generalizing t with + | nil => + apply Point.ext + rfl + | cons h p ih => + simp only [walkPath, Path.trans_apply] + split_ifs + · exact coarsen_edgePath hrs _ _ + · exact ih _ + +theorem coarsen_loopCircle {G : SimpleGraph X} (hrs : r ≤ s) (hr : 0 ≤ r) + (hE : ∀ x y, G.Adj x y → dist x y ≤ r) {x : X} (p : G.Walk x x) : + (inclusion hrs).toContinuousMap.comp (loopCircle (walkPath hr hE p)) = + loopCircle (walkPath (hr.trans hrs) (fun x y h => (hE x y h).trans hrs) p) := by + apply ContinuousMap.ext + intro z + obtain ⟨t, rfl⟩ := circle_parameter_surjective z + simp only [ContinuousMap.comp_apply, loopCircle_apply] + exact coarsen_walkPath hrs hr hE p t + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsPaths.lean b/lean/OAI/Topology/CoarseAssembly/RipsPaths.lean new file mode 100644 index 0000000000000000000000000000000000000000..37a9f6f5163ec12d40a2388570c5fcd11e833d41 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsPaths.lean @@ -0,0 +1,137 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CocycleCircleMap +import Mathlib.Analysis.Convex.PathConnected + +namespace OAI + +/-! # Paths in a finite Rips realization + +Straight barycentric interpolation in a simplex, including its endpoint +and cocycle-lift formulas. These are paths in the actual realization.+-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open scoped BigOperators +open unitInterval + +variable {X : Type*} [PseudoMetricSpace X] {r : ℝ} + +@[simp] theorem vertex_weight (x : X) (hr : 0 ≤ r) : + (vertex x hr).weight = Finsupp.single x 1 := rfl + +def interpolate (p q : Point X r) + (hpq : ∀ x ∈ p.weight.support, ∀ y ∈ q.weight.support, dist x y ≤ r) + (t : unitInterval) : Point X r where + weight := (1 - (t : ℝ)) • p.weight + (t : ℝ) • q.weight + nonneg x := add_nonneg (mul_nonneg (sub_nonneg.mpr t.2.2) (p.nonneg x)) + (mul_nonneg t.2.1 (q.nonneg x)) + total := by + rw [Finsupp.sum_add_index' (by simp) (by simp), + Finsupp.sum_smul_index' (by simp), Finsupp.sum_smul_index' (by simp)] + simp only [smul_eq_mul] + rw [← Finsupp.mul_sum, ← Finsupp.mul_sum, p.total, q.total] + ring + diameter x hx y hy := by + have support : ∀ z, z ∈ ((1 - (t : ℝ)) • p.weight + (t : ℝ) • q.weight).support → + z ∈ p.weight.support ∨ z ∈ q.weight.support := by + intro z hz + by_contra! h + have hpz := Finsupp.notMem_support_iff.mp h.1 + have hqz := Finsupp.notMem_support_iff.mp h.2 + simp [Finsupp.mem_support_iff, hpz, hqz] at hz + rcases support x hx with hx | hx <;> rcases support y hy with hy | hy + · exact p.diameter x hx y hy + · exact hpq x hx y hy + · simpa only [dist_comm] using hpq y hy x hx + · exact q.diameter x hx y hy + +theorem interpolate_continuous (p q : Point X r) (hpq) : + Continuous (interpolate p q hpq) := by + apply continuous_induced_rng.mpr + apply continuous_pi + intro x + change Continuous (fun t : unitInterval => (1 - (t : ℝ)) * p.weight x + (t : ℝ) * q.weight x) + fun_prop + +@[simp] theorem interpolate_zero (p q : Point X r) (hpq) : + interpolate p q hpq 0 = p := by + apply Point.ext + simp [interpolate] + +@[simp] theorem interpolate_one (p q : Point X r) (hpq) : + interpolate p q hpq 1 = q := by + apply Point.ext + simp [interpolate] + +def simplexPath (p q : Point X r) + (hpq : ∀ x ∈ p.weight.support, ∀ y ∈ q.weight.support, dist x y ≤ r) : Path p q where + toFun := interpolate p q hpq + continuous_toFun := interpolate_continuous p q hpq + source' := interpolate_zero p q hpq + target' := interpolate_one p q hpq + +def edgePath {x y : X} (hxy : dist x y ≤ r) : + Path (vertex x (dist_nonneg.trans hxy)) (vertex y (dist_nonneg.trans hxy)) := + simplexPath _ _ (by + intro u hu v hv + have hu' : u = x := by simpa using hu + have hv' : v = y := by simpa using hv + simpa [hu', hv'] using hxy) + +variable [Fintype X] + +omit [Fintype X] in +theorem IntegralCocycle.charge_self (c : IntegralCocycle X r) (hr : 0 ≤ r) (x : X) : + c.charge x x = 0 := by + have h := c.antisymm x x (by simpa using hr) + omega + +theorem IntegralCocycle.localAngle_vertex (c : IntegralCocycle X r) + (hr : 0 ≤ r) (x y : X) : c.localAngle x (vertex y hr) = (c.charge x y : ℝ) := by + classical + simp [localAngle, Finsupp.single_apply] + +@[simp] theorem IntegralCocycle.circleMap_vertex (c : IntegralCocycle X r) + (hr : 0 ≤ r) (x : X) : c.circleMap (vertex x hr) = 0 := by + rw [c.circleMap_eq _ (x := x) (by simp)] + simp [c.localAngle_vertex, c.charge_self hr] + +theorem IntegralCocycle.localAngle_interpolate (c : IntegralCocycle X r) + (x : X) (p q : Point X r) (hpq) (t : unitInterval) : + c.localAngle x (interpolate p q hpq t) = + (1 - (t : ℝ)) * c.localAngle x p + (t : ℝ) * c.localAngle x q := by + simp only [localAngle, interpolate, Finsupp.add_apply, Finsupp.smul_apply, smul_eq_mul, + add_mul, mul_assoc, Finset.sum_add_distrib, Finset.mul_sum] + +/-- The edge has the real lift `t ↦ t * charge x y`. -/ +theorem IntegralCocycle.circleMap_edgePath (c : IntegralCocycle X r) + {x y : X} (hxy : dist x y ≤ r) (t : unitInterval) : + c.circleMap (edgePath hxy t) = ((t : ℝ) * (c.charge x y : ℝ) : ℝ) := by + have hr : 0 ≤ r := dist_nonneg.trans hxy + by_cases ht : (t : ℝ) = 1 + · have ht' : t = 1 := Subtype.ext ht + subst t + simp only [Path.target, c.circleMap_vertex] + exact ((AddCircle.coe_eq_zero_iff (1 : ℝ)).mpr ⟨c.charge x y, by simp⟩).symm + · have hx : x ∈ (edgePath hxy t).weight.support := by + apply Finsupp.mem_support_iff.mpr + change (1 - (t : ℝ)) * (Finsupp.single x 1 x) + + (t : ℝ) * (Finsupp.single y 1 x) ≠ 0 + have hpos : 0 < 1 - (t : ℝ) := sub_pos.mpr (lt_of_le_of_ne t.2.2 ht) + have hnn : 0 ≤ (Finsupp.single y (1 : ℝ) x) := (vertex y hr).nonneg x + simpa only [Finsupp.single_eq_same, mul_one] using + ne_of_gt (add_pos_of_pos_of_nonneg hpos (mul_nonneg t.2.1 hnn)) + rw [c.circleMap_eq _ hx] + dsimp only [edgePath, simplexPath] + simp only [Path.coe_mk_mk] + rw [c.localAngle_interpolate, c.localAngle_vertex, c.localAngle_vertex, + c.charge_self hr] + simp + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsProperEmbedding.lean b/lean/OAI/Topology/CoarseAssembly/RipsProperEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..084592dd7fd65c95b36200cd3ff0cde93ca64284 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsProperEmbedding.lean @@ -0,0 +1,96 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsEmbedding +import OAI.Topology.CoarseAssembly.Assembly + +namespace OAI + +/-! # Proper simplicial maps induced by injective nonexpanding maps + +This construction applies to the actual boundary inclusions. The closed +range conditions record both the allowed vertices and all forbidden pairs +in the source metric, so no finiteness of the whole source is required. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +universe u + +variable {X Y : Type u} [PseudoMetricSpace X] [PseudoMetricSpace Y] {r : ℝ} + +theorem mapPoint_embedding (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + IsEmbedding (mapPoint (r := r) e he) := by + refine ⟨IsInducing.of_comp (mapPoint_continuous e he) + (show Continuous (fun p : Point Y r => fun x : X => p.weight (e x)) from + continuous_pi (fun x => coordinate_continuous (e x))) ?_, mapPoint_injective e he⟩ + have hcomp : (fun p : Point Y r => fun x : X => p.weight (e x)) ∘ mapPoint e he = + coordinates (X := X) (r := r) := by + funext p x + exact mapPoint_weight_self e he p x + rw [hcomp] + exact ⟨rfl⟩ + +theorem range_mapPoint (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + Set.range (mapPoint (r := r) e he) = + {q : Point Y r | (∀ y, y ∉ Set.range e → q.weight y = 0) ∧ + ∀ x z, r < dist x z → q.weight (e x) = 0 ∨ q.weight (e z) = 0} := by + classical + ext q + constructor + · rintro ⟨p, rfl⟩ + refine ⟨fun y hy => Finsupp.embDomain_of_notMem_range e p.weight y hy, ?_⟩ + intro x z hxz + simp only [mapPoint_weight_self] + by_cases hx : p.weight x = 0 + · exact Or.inl hx + by_cases hz : p.weight z = 0 + · exact Or.inr hz + exact False.elim ((not_le_of_gt hxz) + (p.diameter x (Finsupp.mem_support_iff.mpr hx) z (Finsupp.mem_support_iff.mpr hz))) + · rintro ⟨hs, hd⟩ + have hsupport : ↑q.weight.support ⊆ Set.range e := by + intro y hy + by_contra hn + exact Finsupp.mem_support_iff.mp hy (hs y hn) + let p : Point X r := + { weight := q.weight.comapDomain e e.injective.injOn + nonneg x := q.nonneg (e x) + total := by + have hm := Finsupp.embDomain_comapDomain (f := e) hsupport + have ht := congrArg (fun f : Y →₀ ℝ => f.sum (fun _ t => t)) hm + simpa only [Finsupp.sum_embDomain, q.total] using ht + diameter := by + intro x hx z hz + by_contra hxz + rcases hd x z (lt_of_not_ge hxz) with hx' | hz' + · exact Finsupp.mem_support_iff.mp hx hx' + · exact Finsupp.mem_support_iff.mp hz hz' } + refine ⟨p, ?_⟩ + apply Point.ext + exact Finsupp.embDomain_comapDomain (f := e) hsupport + +theorem mapPoint_properEmbedding (e : X ↪ Y) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + IsClosedEmbedding (mapPoint (r := r) e he) := by + refine ⟨mapPoint_embedding e he, ?_⟩ + rw [range_mapPoint e he] + have hs : IsClosed {q : Point Y r | ∀ y, y ∉ Set.range e → q.weight y = 0} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun y => isClosed_iInter fun _ => + isClosed_eq (coordinate_continuous y) continuous_const + have hd : IsClosed {q : Point Y r | ∀ x z, r < dist x z → + q.weight (e x) = 0 ∨ q.weight (e z) = 0} := by + simp only [Set.ofPred_forall] + exact isClosed_iInter fun x => isClosed_iInter fun z => isClosed_iInter fun _ => + (isClosed_eq (coordinate_continuous (e x)) continuous_const).union + (isClosed_eq (coordinate_continuous (e z)) continuous_const) + exact hs.inter hd + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsRealClass.lean b/lean/OAI/Topology/CoarseAssembly/RipsRealClass.lean new file mode 100644 index 0000000000000000000000000000000000000000..f823af3c410e0ba5783947bd85984c4dc09ea4c1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsRealClass.lean @@ -0,0 +1,39 @@ +import OAI.Topology.CoarseAssembly.RipsProperEmbedding + +namespace OAI + +/-! # Real-radius classes at integer coarsening stages -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic + +variable {X Y : Type} [PseudoMetricSpace X] [PseudoMetricSpace Y] + +def classAt (n : ℕ) (r : ℝ) (h : r = (n : ℝ)) + (a : LocallyFiniteK1 (Point X r)) : KX1 X := by + refine (coarsening X).of n ?_ + change LocallyFiniteK1 (Point X (n : ℝ)) + exact h ▸ a + +theorem classAt_zero (n : ℕ) (r : ℝ) (h : r = (n : ℝ)) : + classAt (X := X) n r h 0 = 0 := by + subst r + exact (coarsening X).of n |>.map_zero + +theorem embedding_classAt (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) + (n : ℕ) (r : ℝ) (h : r = (n : ℝ)) + (a : LocallyFiniteK1 (Point X r)) : + (embeddingCoarsening e he).homologyMap (classAt (X := X) n r h a) = + classAt (X := Y) n r h (pushforward (embeddingMap e he r) a) := by + subst r + dsimp only [classAt] + exact CoarseningMorphism.homologyMap_of (embeddingCoarsening e he) n a + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsRealization.lean b/lean/OAI/Topology/CoarseAssembly/RipsRealization.lean new file mode 100644 index 0000000000000000000000000000000000000000..1007a2a17d97f2970e7c1b3a65dd30146bd73e68 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsRealization.lean @@ -0,0 +1,106 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.LocallyFinite +import Mathlib.Data.Finsupp.Basic +import Mathlib.Topology.Instances.Real.Lemmas + +namespace OAI + +/-! +# Barycentric Rips realization and proper coarsening + +Points are actual finitely supported probability weights with support of +bounded diameter. The topology is induced by the barycentric coordinates. +For a locally finite Rips complex this is its usual simplicial topology. +Increasing-scale inclusions are proved to be closed embeddings and therefore +proper, providing the continuous coarsening maps for analytic K-homology. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Topology + +variable (X : Type*) [PseudoMetricSpace X] + +variable {X} + +theorem coordinates_injective {r : ℝ} : Function.Injective (coordinates (X := X) (r := r)) := by + intro p q h + apply Point.ext + exact Finsupp.ext (congrFun h) + +theorem coordinates_continuous {r : ℝ} : Continuous (coordinates (X := X) (r := r)) := + continuous_induced_dom + +theorem coordinate_continuous {r : ℝ} (x : X) : + Continuous (fun p : Point X r => p.weight x) := + (continuous_apply x).comp coordinates_continuous + +@[simp] theorem coarsen_weight {r s : ℝ} (h : r ≤ s) (p : Point X r) : + (coarsen h p).weight = p.weight := rfl + +theorem coarsen_embedding {r s : ℝ} (h : r ≤ s) : IsEmbedding (coarsen (X := X) h) where + eq_induced := by + change TopologicalSpace.induced coordinates _ = + TopologicalSpace.induced (coarsen h) (TopologicalSpace.induced coordinates _) + rw [induced_compose] + rfl + injective := by + intro p q heq + apply Point.ext + exact congrArg (fun p : Point X s => p.weight) heq + +theorem range_coarsen {r s : ℝ} (h : r ≤ s) : + Set.range (coarsen (X := X) h) = + {p : Point X s | ∀ x y, r < dist x y → p.weight x = 0 ∨ p.weight y = 0} := by + ext p + constructor + · rintro ⟨q, rfl⟩ x y hxy + by_cases hx : q.weight x = 0 + · exact Or.inl hx + by_cases hy : q.weight y = 0 + · exact Or.inr hy + exact False.elim ((not_le_of_gt hxy) + (q.diameter x (Finsupp.mem_support_iff.mpr hx) y (Finsupp.mem_support_iff.mpr hy))) + · intro hp + let q : Point X r := + { weight := p.weight + nonneg := p.nonneg + total := p.total + diameter := by + intro x hx y hy + by_contra hxy + rcases hp x y (lt_of_not_ge hxy) with hx' | hy' + · exact Finsupp.mem_support_iff.mp hx hx' + · exact Finsupp.mem_support_iff.mp hy hy' } + exact ⟨q, by apply Point.ext; rfl⟩ + +theorem coarsen_closedEmbedding {r s : ℝ} (h : r ≤ s) : + IsClosedEmbedding (coarsen (X := X) h) := by + refine ⟨coarsen_embedding h, ?_⟩ + rw [range_coarsen h] + simp only [Set.ofPred_forall] + refine isClosed_iInter (fun x => isClosed_iInter (fun y => isClosed_iInter (fun _ => ?_))) + exact (isClosed_eq (coordinate_continuous x) continuous_const).union + (isClosed_eq (coordinate_continuous y) continuous_const) + +theorem inclusion_self (r : ℝ) (h : r ≤ r) : + inclusion (X := X) h = CocompactMap.id (Point X r) := by + apply CocompactMap.ext + intro p + apply Point.ext + rfl + +theorem inclusion_comp {r s t : ℝ} (hrs : r ≤ s) (hst : s ≤ t) : + inclusion (X := X) (hrs.trans hst) = (inclusion hst).comp (inclusion hrs) := by + apply CocompactMap.ext + intro p + apply Point.ext + rfl + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsReindex.lean b/lean/OAI/Topology/CoarseAssembly/RipsReindex.lean new file mode 100644 index 0000000000000000000000000000000000000000..c34e13091e6b23d12fc1c73dfc87375b2d37f05d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsReindex.lean @@ -0,0 +1,78 @@ +import OAI.Topology.CoarseAssembly.RipsMapCalculus + +namespace OAI + +/-! # Isometric reindexing of coarse homology + +The two sigma-type presentations of the fibered vertex set give isomorphic +Rips coarsening limits. This is used to compare the graph detector with the +vertex indexing of the spatial transfer. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic + +universe u + +variable {X Y : Type u} [PseudoMetricSpace X] [PseudoMetricSpace Y] + +theorem equiv_inverse_isometry (e : X ≃ Y) (he : Isometry e) : Isometry e.symm := by + apply Isometry.of_dist_eq + intro x y + simpa only [Equiv.apply_symm_apply] using (he.dist_eq (e.symm x) (e.symm y)).symm + +theorem mapPoint_equiv_inverse (e : X ≃ Y) (he : Isometry e) {r : ℝ} + (p : Point X r) : + mapPoint e.symm.toEmbedding (fun x y => ((equiv_inverse_isometry e he).dist_eq x y).le) + (mapPoint e.toEmbedding (fun x y => (he.dist_eq x y).le) p) = p := by + apply Point.ext + apply Finsupp.ext + intro x + have h := mapPoint_weight_self e.symm.toEmbedding + (fun x y => ((equiv_inverse_isometry e he).dist_eq x y).le) + (mapPoint e.toEmbedding (fun x y => (he.dist_eq x y).le) p) (e x) + calc + _ = (mapPoint e.toEmbedding (fun x y => (he.dist_eq x y).le) p).weight (e x) := by + simpa only [Equiv.toEmbedding_apply, Equiv.symm_apply_apply] using h + _ = p.weight x := mapPoint_weight_self e.toEmbedding _ p x + +def reindexHomology (e : X ≃ Y) (he : Isometry e) : KX1 X →+ KX1 Y := + (embeddingCoarsening e.toEmbedding (fun x y => (he.dist_eq x y).le)).homologyMap + +theorem reindexHomology_inverse (e : X ≃ Y) (he : Isometry e) : + (reindexHomology e.symm (equiv_inverse_isometry e he)).comp (reindexHomology e he) = + AddMonoidHom.id (KX1 X) := by + apply AddCommGroup.DirectLimit.hom_ext + intro r + apply AddMonoidHom.ext + intro a + change reindexHomology e.symm (equiv_inverse_isometry e he) + (reindexHomology e he ((coarsening X).of r a)) = (coarsening X).of r a + dsimp only [reindexHomology] + rw [CoarseningMorphism.homologyMap_of, CoarseningMorphism.homologyMap_of] + have hc : ((embeddingCoarsening e.symm.toEmbedding + (fun x y => ((equiv_inverse_isometry e he).dist_eq x y).le)).atScale r).comp + ((embeddingCoarsening e.toEmbedding (fun x y => (he.dist_eq x y).le)).atScale r) = + CocompactMap.id (Point X (r : ℝ)) := by + apply CocompactMap.ext + intro p + exact mapPoint_equiv_inverse e he p + apply congrArg ((coarsening X).of r) + rw [← AddMonoidHom.comp_apply, ← pushforward_comp, hc] + exact DFunLike.congr_fun (pushforward_id (X := Point X (r : ℝ))) a + +theorem reindexHomology_injective (e : X ≃ Y) (he : Isometry e) : + Function.Injective (reindexHomology e he) := by + intro a b hab + have h := congrArg (reindexHomology e.symm (equiv_inverse_isometry e he)) hab + have hi := reindexHomology_inverse e he + simpa only [← AddMonoidHom.comp_apply, hi, AddMonoidHom.id_apply] using h + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsScaleCompatibility.lean b/lean/OAI/Topology/CoarseAssembly/RipsScaleCompatibility.lean new file mode 100644 index 0000000000000000000000000000000000000000..c89aa761559fdfb04d28fe88ebffb62feab63a0a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsScaleCompatibility.lean @@ -0,0 +1,68 @@ +import OAI.Topology.CoarseAssembly.AmpleRipsFamily + +namespace OAI + +/-! # Increasing-scale compatibility of the explicit Rips representatives + +The barycentric coordinate functions pull back identically under increasing +the Rips scale. Consequently the localized operators themselves agree, +before taking a K-theory class. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] + {r s : ℝ} (hrs : r ≤ s) + +def scaleFunctionHom : C(Point X s, ℂ) →⋆ₐ[ℂ] C(Point X r, ℂ) := + ContinuousMap.compStarAlgHom' ℂ ℂ ⟨coarsen hrs, (coarsen_closedEmbedding hrs).continuous⟩ + +omit [Fintype X] in +theorem scaleFunctionHom_sqrt (x : X) : + scaleFunctionHom hrs (sqrtCoordinate s x) = sqrtCoordinate r x := rfl + +def coarsenedCycle (c : OddCycle C(Point X r, ℂ)) : OddCycle C(Point X s, ℂ) := + c.precomp (scaleFunctionHom hrs).toNonUnitalStarAlgHom + +theorem coarsenedCycle_unital (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : (coarsenedCycle hrs c).representation 1 = 1 := by + change c.representation (scaleFunctionHom hrs 1) = 1 + rw [map_one, hπ] + +theorem coarsenedCycle_representedSqrt (c : OddCycle C(Point X r, ℂ)) : + representedSqrt s (coarsenedCycle hrs c) = representedSqrt r c := rfl + +variable [DecidableEq X] + +theorem ripsSpatialOperator_scale (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : + (show Operator X c.space from + ripsSpatialOperator s (coarsenedCycle hrs c) (coarsenedCycle_unital hrs c hπ)) = + ripsSpatialOperator r c hπ := rfl + +theorem ampleRipsOperator_scale (c : OddCycle C(Point X r, ℂ)) + (hπ : c.representation 1 = 1) : + ampleRipsOperator s (coarsenedCycle hrs c) (coarsenedCycle_unital hrs c hπ) = + ampleRipsOperator r c hπ := rfl + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] + +theorem ampleRipsFamilyBoundary_scale (o : ∀ i, V i) (hr : 0 ≤ r) (hs : 0 ≤ s) + (c : ∀ i, OddCycle C(Point (V i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) + (C : ℝ) (hC : 0 ≤ C) (hnorm : ∀ i, ‖(c i).operator‖ ≤ C) : + letI := separatedMetric o + ampleRipsFamilyBoundary o s hs (fun i => coarsenedCycle hrs (c i)) + (fun i => coarsenedCycle_unital hrs (c i) (hπ i)) hF C hC hnorm = + ampleRipsFamilyBoundary o r hr c hπ hF C hC hnorm := rfl + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsUniformHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/RipsUniformHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..49711f9c0e4c324dcbb3acac5ebea8d31b6b02cd --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsUniformHomotopy.lean @@ -0,0 +1,89 @@ +import OAI.Topology.CoarseAssembly.LocalizationUniformEstimate +import OAI.Topology.CoarseAssembly.SeparatedFamilyHomotopy + +namespace OAI + +/-! # Uniform analytic homotopies of Rips families + +Continuity is imposed on the Fredholm operators and partition isometries, +before taking the Roe boundary. The estimate has no component-size factor. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe Filter Topology + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + +theorem ampleRipsOperator_variation_norm_le (r : ℝ) (h : OddHomotopy C(Point X r, ℂ)) + (s t : Interval) (hs : (h.eval s).representation 1 = 1) + (ht : (h.eval t).representation 1 = 1) (C : ℝ) (hC : ‖h.operator t‖ ≤ C) : + ‖ampleRipsOperator r (h.eval s) hs - ampleRipsOperator r (h.eval t) ht‖ ≤ + ‖h.operator s - h.operator t‖ + (4 * C + 2) * + ‖(show h.space →L[ℂ] Module X h.space from partitionMap (representedSqrt r (h.eval s))) - + (show h.space →L[ℂ] Module X h.space from partitionMap (representedSqrt r (h.eval t)))‖ := by + apply (coefficientExtension_sub_norm_le (ampleIsometry h.space) _ _).trans + exact localizedSpatialOperator_variation_norm_le + (show X → End h.space from representedSqrt r (h.eval s)) + (show X → End h.space from representedSqrt r (h.eval t)) + (representedSqrt_partition r (h.eval s) hs) (representedSqrt_partition r (h.eval t) ht) + (h.operator s) (h.operator t) C hC + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +theorem ampleRipsFamilyBoundary_uniformHomotopy + (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (h : ∀ i, OddHomotopy C(Point (Q i) r, ℂ)) + (hπ : ∀ t i, ((h i).eval t).representation 1 = 1) + (hF : ∀ t i, IsSelfAdjoint ((h i).eval t).operator) + (C : ℝ) (hC : 0 ≤ C) (hnorm : ∀ t i, ‖(h i).operator t‖ ≤ C) + (hoperator : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, + ‖(h i).operator s - (h i).operator t‖ ≤ ε) + (hpartition : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, + ‖(show (h i).space →L[ℂ] Module (Q i) (h i).space from + partitionMap (representedSqrt r ((h i).eval s))) - + (show (h i).space →L[ℂ] Module (Q i) (h i).space from + partitionMap (representedSqrt r ((h i).eval t)))‖ ≤ ε) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval start) (hπ start) (hF start) + C hC (hnorm start) = + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval finish) (hπ finish) (hF finish) + C hC (hnorm finish) := by + let := separatedMetric o + have hcont : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, + ‖ampleRipsOperator r ((h i).eval s) (hπ s i) - + ampleRipsOperator r ((h i).eval t) (hπ t i)‖ ≤ ε := by + intro t ε hε + let δ := ε / (4 * C + 3) + have hden : 0 < 4 * C + 3 := by positivity + have hδ : 0 < δ := div_pos hε hden + filter_upwards [hoperator t δ hδ, hpartition t δ hδ] with s hs hp + intro i + calc + _ ≤ ‖(h i).operator s - (h i).operator t‖ + (4 * C + 2) * + ‖(show (h i).space →L[ℂ] Module (Q i) (h i).space from + partitionMap (representedSqrt r ((h i).eval s))) - + (show (h i).space →L[ℂ] Module (Q i) (h i).space from + partitionMap (representedSqrt r ((h i).eval t)))‖ := + ampleRipsOperator_variation_norm_le r (h i) s t (hπ s i) (hπ t i) C (hnorm t i) + _ ≤ δ + (4 * C + 2) * δ := + add_le_add (hs i) (mul_le_mul_of_nonneg_left (hp i) (by positivity)) + _ = ε := by dsimp [δ]; field_simp; ring + exact separatedFamilyBoundary_homotopy o + (fun t i => ampleRipsOperator r ((h i).eval t) (hπ t i)) + (C + 4) (by linarith) + (fun t i => (ampleRipsOperator_norm_le r ((h i).eval t) (hπ t i)).trans + (show ‖((h i).eval t).operator‖ + 4 ≤ C + 4 from add_le_add (hnorm t i) le_rfl)) + (r + r) (add_nonneg hr hr) + (fun t i => ampleRipsOperator_propagation r hr ((h i).eval t) (hπ t i)) + (fun t i => ampleRipsOperator_selfAdjoint r ((h i).eval t) (hπ t i) (hF t i)) + (fun t i => ampleRipsOperator_square_compact r ((h i).eval t) (hπ t i) (hF t i)) hcont + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsUnitaryFamily.lean b/lean/OAI/Topology/CoarseAssembly/RipsUnitaryFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..f846701d6e58b2e31906d283646c45de66fd3a5a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsUnitaryFamily.lean @@ -0,0 +1,78 @@ +import OAI.Topology.CoarseAssembly.RipsUnitaryLocalization + +namespace OAI + +/-! # Whole-union boundary invariance under unitary equivalence of cycles -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ) + {c d : OddCycle C(Point X r, ℂ)} + +theorem ripsExtension_aligned (e : c.UnitaryEquivalent d) + (hc : c.representation 1 = 1) (hd : d.representation 1 = 1) + (V : c.space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) : + coefficientExtension (V.comp e.unitary.symm.toLinearIsometry) (ripsSpatialOperator r d hd) = + coefficientExtension V (ripsSpatialOperator r c hc) := by + rw [ripsSpatialOperator_unitary r e hc hd] + change isometricExtension (coefficientIsometry (V.comp e.unitary.symm.toLinearIsometry)) + (isometricExtension (coefficientIsometry e.unitary.toLinearIsometry) _) = _ + rw [isometricExtension_comp, coefficientIsometry_comp] + have he : (V.comp e.unitary.symm.toLinearIsometry).comp e.unitary.toLinearIsometry = V := by + ext x + simp + rw [he] + rfl + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +theorem ripsFamilyBoundaryWithEmbeddings_congr (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c d : ∀ i, OddCycle C(Point (Q i) r, ℂ)) + (hc : ∀ i, (c i).representation 1 = 1) (hd : ∀ i, (d i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) (hG : ∀ i, IsSelfAdjoint (d i).operator) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hnc : ∀ i, ‖(c i).operator‖ ≤ C) (hnd : ∀ i, ‖(d i).operator‖ ≤ D) + (V : ∀ i, (c i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) + (W : ∀ i, (d i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) + (hVW : ∀ i, coefficientExtension (V i) (ripsSpatialOperator r (c i) (hc i)) = + coefficientExtension (W i) (ripsSpatialOperator r (d i) (hd i))) : + letI := separatedMetric o + ripsFamilyBoundaryWithEmbeddings o r hr c hc hF C hC hnc V = + ripsFamilyBoundaryWithEmbeddings o r hr d hd hG D hD hnd W := by + let := separatedMetric o + unfold ripsFamilyBoundaryWithEmbeddings coefficientFamilyBoundary + apply separatedFamilyBoundary_congr + exact funext hVW + +theorem ampleRipsFamilyBoundary_unitary (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c d : ∀ i, OddCycle C(Point (Q i) r, ℂ)) (e : ∀ i, (c i).UnitaryEquivalent (d i)) + (hc : ∀ i, (c i).representation 1 = 1) (hd : ∀ i, (d i).representation 1 = 1) + (hF : ∀ i, IsSelfAdjoint (c i).operator) (hG : ∀ i, IsSelfAdjoint (d i).operator) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hnc : ∀ i, ‖(c i).operator‖ ≤ C) (hnd : ∀ i, ‖(d i).operator‖ ≤ D) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr c hc hF C hC hnc = + ampleRipsFamilyBoundary o r hr d hd hG D hD hnd := by + let := separatedMetric o + let V : ∀ i, (c i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2 := + fun i => ampleIsometry (c i).space + let W : ∀ i, (d i).space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2 := + fun i => (V i).comp (e i).unitary.symm.toLinearIsometry + calc + _ = ripsFamilyBoundaryWithEmbeddings o r hr c hc hF C hC hnc V := + ampleRipsFamilyBoundary_embeddings o r hr c hc hF C hC hnc V + _ = ripsFamilyBoundaryWithEmbeddings o r hr d hd hG D hD hnd W := + ripsFamilyBoundaryWithEmbeddings_congr o r hr c d hc hd hF hG C D hC hD hnc hnd V W + (fun i => (ripsExtension_aligned r (e i) (hc i) (hd i) (V i)).symm) + _ = _ := (ampleRipsFamilyBoundary_embeddings o r hr d hd hG D hD hnd W).symm + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsUnitaryLocalization.lean b/lean/OAI/Topology/CoarseAssembly/RipsUnitaryLocalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..a69efbd882ad0d330ce7b73acc41ad84b910a740 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsUnitaryLocalization.lean @@ -0,0 +1,105 @@ +import OAI.Topology.CoarseAssembly.RipsEmbeddingIndependence +import OAI.Topology.CoarseAssembly.PartitionInclusion + +namespace OAI + +/-! # Unitary equivalence commutes with finite-Rips localization -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem isometricExtension_equiv (U : E ≃ₗᵢ[ℂ] H) (F : E →L[ℂ] E) : + isometricExtension U.toLinearIsometry F = operatorConjugation U.toLinearIsometry F := by + have h1 : operatorConjugation U.toLinearIsometry (1 : E →L[ℂ] E) = 1 := by + have hU : U.toLinearIsometry.toContinuousLinearMap.adjoint = + U.symm.toLinearIsometry.toContinuousLinearMap := LinearIsometryEquiv.adjoint_eq_symm U + ext x + simp [operatorConjugation, hU] + change 1 + operatorConjugationHom U.toLinearIsometry (F - 1) = _ + rw [map_sub] + change 1 + (operatorConjugation U.toLinearIsometry F - + operatorConjugation U.toLinearIsometry 1) = _ + rw [h1] + abel + +namespace DiscreteRoe + +variable {X : Type*} [Fintype X] [DecidableEq X] + +theorem partitionIsometry_apply (a : X → E →L[ℂ] E) + (ha : ∑ x, (a x).adjoint.comp (a x) = 1) (v : E) (x : X) : + partitionIsometry a ha v x = a x v := by + exact DFunLike.congr_fun (coordinate_partitionMap a x) v + +omit [CompleteSpace E] [CompleteSpace H] [Fintype X] [DecidableEq X] in +theorem coefficientIsometry_comp {G : Type*} + [NormedAddCommGroup G] [InnerProductSpace ℂ G] [CompleteSpace G] + (V : H →ₗᵢ[ℂ] G) (W : E →ₗᵢ[ℂ] H) : + (coefficientIsometry (X := X) V).comp (coefficientIsometry W) = + coefficientIsometry (V.comp W) := by + ext v x + rfl + +end DiscreteRoe + +namespace Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ) + {c d : OddCycle C(Point X r, ℂ)} + +theorem ripsCompression_unitary (e : c.UnitaryEquivalent d) : + partitionCompression (representedSqrt r d) d.operator = + operatorConjugation e.unitary.toLinearIsometry + (partitionCompression (representedSqrt r c) c.operator) := by + rw [partitionCompression_eq_sum, partitionCompression_eq_sum] + let φ := operatorConjugationHom e.unitary.toLinearIsometry + have hr (x : X) : representedSqrt r d x = φ (representedSqrt r c x) := + e.representation_eq (sqrtCoordinate r x) + have ho : d.operator = φ c.operator := e.operator_eq + change (∑ x, star (representedSqrt r d x) * (d.operator * representedSqrt r d x)) = + φ (∑ x, star (representedSqrt r c x) * (c.operator * representedSqrt r c x)) + simp only [hr, ho, ← map_star, ← map_mul, ← map_sum] + +theorem partitionIsometry_unitary (e : c.UnitaryEquivalent d) + (hc : c.representation 1 = 1) (hd : d.representation 1 = 1) : + (partitionIsometry (representedSqrt r d) (representedSqrt_partition r d hd)).comp + e.unitary.toLinearIsometry = + (coefficientIsometry e.unitary.toLinearIsometry).comp + (partitionIsometry (representedSqrt r c) (representedSqrt_partition r c hc)) := by + ext v x + change partitionIsometry (representedSqrt r d) _ (e.unitary v) x = + e.unitary (partitionIsometry (representedSqrt r c) _ v x) + rw [partitionIsometry_apply, partitionIsometry_apply] + rw [show representedSqrt r d x = operatorConjugation e.unitary.toLinearIsometry + (representedSqrt r c x) from e.representation_eq (sqrtCoordinate r x)] + have hU : e.unitary.toLinearIsometry.toContinuousLinearMap.adjoint = + e.unitary.symm.toLinearIsometry.toContinuousLinearMap := + LinearIsometryEquiv.adjoint_eq_symm e.unitary + simp [operatorConjugation, hU] + +theorem ripsSpatialOperator_unitary (e : c.UnitaryEquivalent d) + (hc : c.representation 1 = 1) (hd : d.representation 1 = 1) : + ripsSpatialOperator r d hd = + isometricExtension (coefficientIsometry e.unitary.toLinearIsometry) + (ripsSpatialOperator r c hc) := by + change isometricExtension (partitionIsometry (representedSqrt r d) _) + (partitionCompression (representedSqrt r d) d.operator) = + isometricExtension (coefficientIsometry e.unitary.toLinearIsometry) + (isometricExtension (partitionIsometry (representedSqrt r c) _) + (partitionCompression (representedSqrt r c) c.operator)) + rw [ripsCompression_unitary r e, ← isometricExtension_equiv e.unitary, + isometricExtension_comp, isometricExtension_comp, partitionIsometry_unitary r e hc hd] + +end Rips +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsUnrestrictedHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/RipsUnrestrictedHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..2e3e6eea2b6afa57934519fde4de750ead85daaa --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsUnrestrictedHomotopy.lean @@ -0,0 +1,50 @@ +import OAI.Topology.CoarseAssembly.UnrestrictedBoundedHomotopy +import OAI.Topology.CoarseAssembly.BoundedRipsTransform + +namespace OAI + +/-! # Arbitrary componentwise analytic homotopies preserve the Rips boundary + +Only the endpoint cycle families need uniform operator bounds. The rational +transform gives norm-one intermediate operators, and finite telescoping +allows arbitrary componentwise speeds. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +theorem ampleRipsFamilyBoundary_homotopy + (o : ∀ i, Q i) (hr : 0 ≤ r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (h : ∀ i, OddHomotopy C(Point (Q i) r, ℂ)) + (hπ : ∀ t i, (h i).representation t 1 = 1) + (hs : ∀ t i, IsSelfAdjoint ((h i).operator t)) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hn0 : ∀ i, ‖(h i).operator start‖ ≤ C) + (hn1 : ∀ i, ‖(h i).operator finish‖ ≤ D) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval start) (hπ start) (hs start) C hC hn0 = + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval finish) (hπ finish) (hs finish) D hD hn1 := by + let c : ControlledCycleFamily Q r := ⟨(fun i => (h i).eval start), hπ start, hs start, C, hC, hn0⟩ + let d : ControlledCycleFamily Q r := ⟨(fun i => (h i).eval finish), hπ finish, hs finish, D, hD, hn1⟩ + let H : BoundedFamilyHomotopy Q r := { + homotopy := fun i => (h i).bounded (fun t => hπ t i) (fun t => hs t i) + unital := hπ + selfAdjoint := fun t i => boundedTransform_selfAdjoint _ _ + bound := 1 + one_le_bound := le_rfl + norm_le := fun t i => boundedTransform_norm_le _ _ } + have he : c.bounded.boundary o hr = d.bounded.boundary o hr := H.endpoint_boundary_eq χ o hr + exact (c.bounded_boundary o hr).symm.trans (he.trans (d.bounded_boundary o hr)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RipsWindingTest.lean b/lean/OAI/Topology/CoarseAssembly/RipsWindingTest.lean new file mode 100644 index 0000000000000000000000000000000000000000..ac81878717bd488d11dec455aaf73a6ab1b97a21 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RipsWindingTest.lean @@ -0,0 +1,83 @@ +import OAI.Topology.CoarseAssembly.CocyclePathLifting +import OAI.Topology.CoarseAssembly.FiniteRips +import OAI.Topology.CoarseAssembly.GraphMetric + +namespace OAI + +/-! # Winding tests from the short-loop theorem + +This connects the proved graph-theoretic small-loop argument to the actual +continuous circle map and its real path lift. It assumes no analytic pairing +or nonvanishing conclusion. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Rips + +variable {X : Type*} {G : SimpleGraph X} + +def graphRipsCocycle (hG : G.Connected) (a : X → X → ℤ) + (ha : ∀ x y, G.Adj x y → a y x = -a x y) (r : ℕ) + (hloop : ∀ x (p : G.Walk x x), p.length ≤ 3 * r → walkCharge a p = 0) : + letI := graphMetric G hG + IntegralCocycle X (r : ℝ) := by + let := graphMetric G hG + have hloop₂ : ∀ x (p : G.Walk x x), p.length ≤ 2 * r → walkCharge a p = 0 := by + intro x p hp + exact hloop x p (by omega) + have toBound : ∀ x y : X, dist x y ≤ (r : ℝ) → G.dist x y ≤ r := by + intro x y h + change @dist X (graphMetric G hG).toDist x y ≤ (r : ℝ) at h + rw [graphMetric_eq G hG] at h + change (G.dist x y : ℝ) ≤ r at h + exact_mod_cast h + exact + { charge := ripsCharge hG a + antisymm := fun x y hxy => ripsCharge_antisymm hG a ha r hloop₂ + (toBound x y hxy) + triangle := fun x y z hxy hyz hzx => ripsCharge_triangle hG a r hloop + (toBound x y hxy) (toBound y z hyz) (toBound z x hzx) } + +theorem graphRipsCocycle_on_walk (hG : G.Connected) (a : X → X → ℤ) + (ha : ∀ x y, G.Adj x y → a y x = -a x y) (r : ℕ) (hr : 1 ≤ r) + (hloop : ∀ x (p : G.Walk x x), p.length ≤ 3 * r → walkCharge a p = 0) + {x y : X} (p : G.Walk x y) : + letI := graphMetric G hG + walkCharge (graphRipsCocycle hG a ha r hloop).charge p = walkCharge a p := by + let := graphMetric G hG + exact ripsCharge_on_walk hG a ha r hr (fun x p hp => hloop x p (by omega)) p + +/-- The winding test on a finite Rips component has a real lift with the +same endpoint as the original graph charge. -/ +theorem graph_winding_lift [Fintype X] (hG : G.Connected) (a : X → X → ℤ) + (ha : ∀ x y, G.Adj x y → a y x = -a x y) (r : ℕ) (hr : 1 ≤ r) + (hloop : ∀ x (p : G.Walk x x), p.length ≤ 3 * r → walkCharge a p = 0) + {x : X} (p : G.Walk x x) : + letI := graphMetric G hG + let c := graphRipsCocycle hG a ha r hloop + ∃ γ : Path (vertex x (by positivity : (0 : ℝ) ≤ r)) + (vertex x (by positivity : (0 : ℝ) ≤ r)), + ∃ L : Path (0 : ℝ) (walkCharge a p : ℝ), + ∀ t, c.circleMap (γ t) = (L t : AddCircle (1 : ℝ)) := by + let := graphMetric G hG + let c := graphRipsCocycle hG a ha r hloop + have hE : ∀ x y, G.Adj x y → dist x y ≤ (r : ℝ) := by + intro x y h + change @dist X (graphMetric G hG).toDist x y ≤ (r : ℝ) + rw [graphMetric_eq G hG] + change (G.dist x y : ℝ) ≤ r + exact_mod_cast (G.dist_le h.toWalk).trans (by simpa using hr) + have hcharge : walkCharge c.charge p = walkCharge a p := + graphRipsCocycle_on_walk hG a ha r hr hloop p + obtain ⟨L, hL⟩ := c.closed_walk_lift (by positivity) hE p + refine ⟨walkPath (by positivity) hE p, L.cast rfl (by rw [hcharge]), ?_⟩ + exact hL + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Roe.lean b/lean/OAI/Topology/CoarseAssembly/Roe.lean new file mode 100644 index 0000000000000000000000000000000000000000..6745f5ea88e606610a2eb53e94a10be59d6c32d2 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Roe.lean @@ -0,0 +1,103 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Analysis.InnerProductSpace.l2Space +import Mathlib.Analysis.CStarAlgebra.ContinuousLinearMap +import Mathlib.Analysis.Normed.Operator.Compact.Basic +import Mathlib.Topology.Algebra.NonUnitalStarAlgebra +import OAI.Topology.CoarseAssembly.Conjugation +import OAI.Topology.CoarseAssembly.Sandwich + +namespace OAI + +/-! +# Discrete reduced Roe algebras + +Operators act on the actual Hilbert sum `ℓ²(X; H)`. Matrix entries are +continuous linear maps on the coefficient Hilbert space. The Roe algebra is +the norm-closed star algebra generated by finite-propagation operators whose +entries, and adjoint entries, are compact. On a discrete space with finite +metric balls these are the usual locally compact generators. + +The coefficient space is a parameter; the ample module used in the paper +is obtained by taking it to be an infinite-dimensional separable Hilbert +space. No compactness is imposed on the averaging projection itself. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open scoped Topology + +variable {X Y H : Type*} +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] +variable [DecidableEq X] [DecidableEq Y] + +@[simp] theorem insert_apply (x : X) (h : H) : insert x h = lp.single 2 x h := rfl + +omit [DecidableEq X] in +@[simp] theorem coordinate_apply (x : X) (v : Module X H) : coordinate x v = v x := rfl + +@[simp] theorem entry_apply (T : Operator X H) (x y : X) (h : H) : + entry T x y h = T (lp.single 2 y h) x := rfl + +theorem entry_continuous (x y : X) : Continuous (fun T : Operator X H => entry T x y) := by + show Continuous (fun T : Operator X H => (coordinate x).comp (T.comp (insert y))) + exact continuous_const.clm_comp (continuous_id.clm_comp continuous_const) + +@[simp] theorem entry_zero (x y : X) : entry (0 : Operator X H) x y = 0 := by + ext h + simp + +@[simp] theorem entry_add (T S : Operator X H) (x y : X) : + entry (T + S) x y = entry T x y + entry S x y := by + ext h + simp [entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp] + +@[simp] theorem entry_smul (c : ℂ) (T : Operator X H) (x y : X) : + entry (c • T) x y = c • entry T x y := by + ext h + simp [entry] + +variable [CompleteSpace H] [PseudoMetricSpace X] + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.operatorScalarTower + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.operatorScalarComm + +theorem algebra_isClosed : IsClosed (algebra (X := X) (H := H) : Set (Operator X H)) := + NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + +theorem generator_mem {T : Operator X H} (hT : Generator T) : + T ∈ algebra (X := X) (H := H) := + (NonUnitalStarSubalgebra.le_topologicalClosure _) + (NonUnitalStarAlgebra.subset_adjoin ℂ _ hT) + +instance : CompleteSpace (algebra (X := X) (H := H)) := + algebra_isClosed.completeSpace_coe + +variable [PseudoMetricSpace Y] + +/-- A continuous spatial homomorphism maps the whole Roe algebra once its +range has been proved on the locally compact finite-propagation generators. +The range proof remains an obligation, rather than part of the definition. -/ +theorem map_mem (φ : Operator X H →⋆ₙₐ[ℂ] Operator Y H) (hφ : Continuous φ) + (hgen : ∀ T, Generator T → φ T ∈ algebra (X := Y) (H := H)) + {T : Operator X H} (hT : T ∈ algebra (X := X) (H := H)) : φ T ∈ algebra (X := Y) (H := H) := by + let S := (algebra (X := Y) (H := H)).comap φ + have hS : IsClosed (S : Set (Operator X H)) := algebra_isClosed.preimage hφ + have hle : NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T} ≤ S := + NonUnitalStarAlgebra.adjoin_le hgen + exact (NonUnitalStarSubalgebra.topologicalClosure_minimal _ hle hS) hT + +/-- The final norm-closure step in the finite-fiber transfer argument. -/ +theorem sandwich_mem {P A : Operator X H} {Pn : ℕ → Operator X H} + (hlim : Filter.Tendsto Pn Filter.atTop (nhds P)) + (hgen : ∀ n, Generator (Pn n * A * Pn n)) : P * A * P ∈ algebra (X := X) (H := H) := + sandwich_mem_of_tendsto _ algebra_isClosed P Pn hlim A + (fun n => generator_mem (hgen n)) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RoeCalculus.lean b/lean/OAI/Topology/CoarseAssembly/RoeCalculus.lean new file mode 100644 index 0000000000000000000000000000000000000000..9c68ca243bd2b403be6922eb6d5b9d66b6c0497c --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RoeCalculus.lean @@ -0,0 +1,143 @@ +import OAI.Topology.CoarseAssembly.Roe + +namespace OAI + +/-! +# Finite-propagation matrix calculus + +The local-compactness step of the finite-fiber transfer states that +sandwiching a locally compact, finite-propagation operator by arbitrary +finite-propagation operators preserves local compactness. The multipliers +themselves are not assumed locally compact. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem insert_adjoint (x : X) : (insert (H := H) x).adjoint = coordinate x := by + ext v + apply ext_inner_left ℂ + intro h + simp [ContinuousLinearMap.adjoint_inner_right, lp.inner_single_left] + +theorem coordinate_adjoint (x : X) : (coordinate (H := H) x).adjoint = insert x := by + rw [← insert_adjoint, ContinuousLinearMap.adjoint_adjoint] + +theorem entry_star (T : Operator X H) (x y : X) : + entry (star T) x y = star (entry T y x) := by + simp [entry, ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_comp, + insert_adjoint, coordinate_adjoint, ContinuousLinearMap.comp_assoc] + +omit [CompleteSpace H] in +theorem vector_eq_sum (s : Finset X) (v : Module X H) + (hv : ∀ x, x ∉ s → v x = 0) : + v = ∑ x ∈ s, insert x (v x) := by + apply lp.ext + funext x + simp only [lp.coeFn_sum, Finset.sum_apply, insert_apply, lp.coeFn_single] + rw [Finset.sum_pi_single] + by_cases hx : x ∈ s + · simp [hx] + · simp [hx, hv x hx] + +omit [CompleteSpace H] in +/-- Matrix multiplication is a finite sum whenever the right-hand column +has finite support. This avoids any exchange of infinite sums. -/ +theorem entry_mul_of_finite_column (T S : Operator X H) (x y : X) (s : Finset X) + (hs : ∀ z, z ∉ s → entry S z y = 0) : + entry (T * S) x y = ∑ z ∈ s, entry T x z * entry S z y := by + ext h + have hv : S (insert y h) = ∑ z ∈ s, insert z (entry S z y h) := by + apply vector_eq_sum + intro z hz + have := DFunLike.congr_fun (hs z hz) h + simpa only [entry_apply, insert_apply, zero_apply] using this + change coordinate x (T (S (insert y h))) = _ + rw [hv, map_sum, map_sum] + simp only [sum_apply, mul_apply_eq_comp] + rfl + +variable [PseudoMetricSpace X] + +theorem PropagationLE.star {r : ℝ} {T : Operator X H} + (hT : PropagationLE r T) : PropagationLE r (star T) := by + intro x y hxy + rw [entry_star, hT y x (by simpa [dist_comm] using hxy), star_zero] + +variable (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + +omit [CompleteSpace H] in +theorem column_support {r : ℝ} {T : Operator X H} (hT : PropagationLE r T) (y : X) : + ∀ z, z ∉ (finiteBalls y r).toFinset → entry T z y = 0 := by + intro z hz + apply hT + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz + +omit [CompleteSpace H] in +include finiteBalls in +theorem PropagationLE.mul {r s : ℝ} {T S : Operator X H} + (hT : PropagationLE r T) (hS : PropagationLE s S) : + PropagationLE (r + s) (T * S) := by + intro x y hxy + rw [entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (column_support finiteBalls hS y)] + apply Finset.sum_eq_zero + intro z hz + have hzy : dist z y ≤ s := by + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall] using hz + have hxz : r < dist x z := by + have htri := dist_triangle x z y + linarith + rw [hT x z hxz, zero_mul] + +omit [CompleteSpace H] in +theorem compact_sum {ι : Type*} (s : Finset ι) (A : ι → H →L[ℂ] H) + (hA : ∀ i ∈ s, IsCompactOperator (A i)) : + IsCompactOperator (∑ i ∈ s, A i : H →L[ℂ] H) := by + exact (compactOperator (RingHom.id ℂ) H H).sum_mem hA + +omit [CompleteSpace H] in +include finiteBalls in +theorem CompactEntries.mul_left {T S : Operator X H} {s : ℝ} + (hT : CompactEntries T) (hS : PropagationLE s S) : CompactEntries (T * S) := by + intro x y + rw [entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (column_support finiteBalls hS y)] + apply compact_sum + intro z _ + exact (hT x z).comp_clm (entry S z y) + +omit [CompleteSpace H] in +include finiteBalls in +theorem CompactEntries.mul_right {T S : Operator X H} {s : ℝ} + (hS : CompactEntries S) (hprop : PropagationLE s S) : CompactEntries (T * S) := by + intro x y + rw [entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset + (column_support finiteBalls hprop y)] + apply compact_sum + intro z _ + exact (hS z y).clm_comp (entry T x z) + +include finiteBalls in +/-- Finite-propagation multipliers preserve locally compact generators. +In particular this applies to amplified finite-propagation projections, +without asserting that those projections are locally compact. -/ +theorem generator_sandwich {A Q : Operator X H} {q : ℝ} + (hA : Generator A) (hq : 0 ≤ q) (hQ : PropagationLE q Q) : + Generator (Q * A * Q) := by + obtain ⟨⟨a, ha, hprop⟩, hc, hcs⟩ := hA + refine ⟨⟨(q + a) + q, by linarith, + (hQ.mul finiteBalls hprop).mul finiteBalls hQ⟩, ?_, ?_⟩ + · exact (hc.mul_right finiteBalls hprop).mul_left finiteBalls hQ + · rw [star_mul, star_mul, ← mul_assoc] + exact (hcs.mul_right finiteBalls hprop.star).mul_left finiteBalls hQ.star + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RoeCompactRows.lean b/lean/OAI/Topology/CoarseAssembly/RoeCompactRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..141bf11b2907a08e7695cef994ddf89b95916906 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RoeCompactRows.lean @@ -0,0 +1,88 @@ +import OAI.Topology.CoarseAssembly.DiagonalMultiplier + +namespace OAI + +/-! # Compact rows and columns of locally compact finite-propagation operators -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +theorem finite_column_operator (T : Operator X H) (y : X) (s : Finset X) + (hs : ∀ x, x ∉ s → entry T x y = 0) : + T.comp (insert y) = ∑ x ∈ s, (insert x).comp (entry T x y) := by + apply ContinuousLinearMap.ext + intro h + change T (insert y h) = _ + have hv : ∀ x, x ∉ s → T (insert y h) x = 0 := by + intro x hx + exact DFunLike.congr_fun (hs x hx) h + simpa only [sum_apply, ContinuousLinearMap.comp_apply, entry_apply, insert_apply] using + vector_eq_sum s (T (insert y h)) hv + +theorem finite_row_operator (T : Operator X H) (x : X) (s : Finset X) + (hs : ∀ y, y ∉ s → entry T x y = 0) : + (coordinate x).comp T = ∑ y ∈ s, (entry T x y).comp (coordinate y) := by + apply ContinuousLinearMap.ext + intro v + simpa only [sum_apply, ContinuousLinearMap.comp_apply, coordinate_apply] using + finite_row_apply T x s hs v + +variable [PseudoMetricSpace X] + +theorem compact_column_of_propagation + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : Operator X H} {r : ℝ} (hp : PropagationLE r T) (hc : CompactEntries T) (y : X) : + IsCompactOperator (T.comp (insert y)) := by + rw [finite_column_operator T y (finiteBalls y r).toFinset (column_support finiteBalls hp y)] + apply (compactOperator (RingHom.id ℂ) H (Module X H)).sum_mem + intro x _ + exact (hc x y).clm_comp (insert x) + +theorem compact_row_of_propagation + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : Operator X H} {r : ℝ} (hp : PropagationLE r T) (hc : CompactEntries T) (x : X) : + IsCompactOperator ((coordinate x).comp T) := by + have hs : ∀ y, y ∉ (finiteBalls x r).toFinset → entry T x y = 0 := by + intro y hy + apply hp + simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le, dist_comm] using hy + rw [finite_row_operator T x (finiteBalls x r).toFinset hs] + apply (compactOperator (RingHom.id ℂ) (Module X H) H).sum_mem + intro y _ + exact (hc x y).comp_clm (coordinate y) + +omit [PseudoMetricSpace X] in +theorem finiteDiagonal_mul_compact (T : Operator X H) + (hr : ∀ x, IsCompactOperator ((coordinate x).comp T)) (f : X → ℂ) (s : Finset X) : + IsCompactOperator (finiteDiagonal (H := H) f s * T) := by + unfold finiteDiagonal + rw [Finset.sum_mul] + apply (compactOperator (RingHom.id ℂ) (Module X H) (Module X H)).sum_mem + intro x _ + exact ((hr x).clm_comp (insert x)).smul (f x) + +omit [PseudoMetricSpace X] in +theorem mul_finiteDiagonal_compact (T : Operator X H) + (hc : ∀ x, IsCompactOperator (T.comp (insert x))) (f : X → ℂ) (s : Finset X) : + IsCompactOperator (T * finiteDiagonal (H := H) f s) := by + unfold finiteDiagonal + rw [Finset.mul_sum] + apply (compactOperator (RingHom.id ℂ) (Module X H) (Module X H)).sum_mem + intro x _ + have he : T * (f x • ((insert x).comp (coordinate x))) = + f x • ((T.comp (insert x)).comp (coordinate x)) := by + apply ContinuousLinearMap.ext + intro v + exact T.map_smul (f x) (insert x (coordinate x v)) + rw [he] + exact ((hc x).comp_clm (coordinate x)).smul (f x) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RoeIdealizer.lean b/lean/OAI/Topology/CoarseAssembly/RoeIdealizer.lean new file mode 100644 index 0000000000000000000000000000000000000000..139592f20d4a4f6093dad3235977458d0f1e2951 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RoeIdealizer.lean @@ -0,0 +1,71 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.AlgebraicRoe +import OAI.Topology.CoarseAssembly.PseudolocalAlgebra + +namespace OAI + +/-! # Multiplication of the Roe ideal by controlled pseudolocal operators -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.instContinuousStarOperator_1 + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.instIsScalarTowerComplexOperator_2 + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.instSMulCommClassComplexOperator_2 + +theorem finitePropagation_multiplier + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : Operator X H} {r : ℝ} (hr : 0 ≤ r) (hp : PropagationLE r T) : RoeMultiplier T := by + have hprod (S : Operator X H) (hS : Generator S) : + T * S ∈ algebra (X := X) (H := H) ∧ S * T ∈ algebra (X := X) (H := H) := by + obtain ⟨⟨s, hs, hq⟩, hc, hcs⟩ := hS + constructor + · apply generator_mem + refine ⟨⟨r + s, add_nonneg hr hs, hp.mul finiteBalls hq⟩, + hc.mul_right finiteBalls hq, ?_⟩ + rw [star_mul] + exact hcs.mul_left finiteBalls hp.star + · apply generator_mem + refine ⟨⟨s + r, add_nonneg hs hr, hq.mul finiteBalls hp⟩, + hc.mul_left finiteBalls hp, ?_⟩ + rw [star_mul] + exact hcs.mul_right finiteBalls hq.star + have hclosed : IsClosed {S : Operator X H | + T * S ∈ algebra (X := X) (H := H) ∧ S * T ∈ algebra (X := X) (H := H)} := + (algebra_isClosed.preimage (continuous_const.mul continuous_id)).inter + (algebra_isClosed.preimage (continuous_id.mul continuous_const)) + intro S + have hm : S.val ∈ (algebraicRoe (H := H) finiteBalls).topologicalClosure := by + rw [← roe_eq_closure_algebraic finiteBalls] + exact S.property + exact closure_minimal hprod hclosed hm + +theorem roeIdealizer_closed : IsClosed (roeIdealizer (X := X) (H := H) : Set (Operator X H)) := by + simp only [roeIdealizer, RoeMultiplier, Set.ofPred_forall] + apply isClosed_iInter + intro S + exact (algebra_isClosed.preimage (continuous_id.mul continuous_const)).inter + (algebra_isClosed.preimage (continuous_const.mul continuous_id)) + +theorem structureAlgebra_multiplier + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : Operator X H} (hT : T ∈ structureAlgebra (X := X) (H := H)) : RoeMultiplier T := by + have hle : NonUnitalStarAlgebra.adjoin ℂ {S : Operator X H | StructureGenerator S} ≤ + roeIdealizer := by + apply NonUnitalStarAlgebra.adjoin_le + intro S hS + obtain ⟨r, hr, hp⟩ := hS.1 + exact finitePropagation_multiplier finiteBalls hr hp + exact NonUnitalStarSubalgebra.topologicalClosure_minimal _ hle roeIdealizer_closed hT + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RoeInclusion.lean b/lean/OAI/Topology/CoarseAssembly/RoeInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..3e5db2f7f7bd8818ba48be60524533aa2a940f94 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RoeInclusion.lean @@ -0,0 +1,148 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.InclusionModule +import OAI.Topology.CoarseAssembly.RoeTransfer + +namespace OAI + +/-! # The reduced Roe map for an actual injective nonexpanding inclusion + +Extension by zero preserves each matrix entry on the image, and all other +entries vanish. Thus propagation and local compactness are proved directly +before extending to the norm closure. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +universe sourceUniverse targetUniverse coefficientUniverse + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.inclusionExponentFact + +variable {X : Type sourceUniverse} {Y : Type targetUniverse} {H : Type coefficientUniverse} + [sourceDecidable : DecidableEq X] [targetDecidable : DecidableEq Y] + [coefficientNormed : NormedAddCommGroup H] [coefficientInner : InnerProductSpace ℂ H] + [coefficientComplete : CompleteSpace H] + +theorem inclusion_adjoint_apply (e : X ↪ Y) (v : Module Y H) (x : X) : + (inclusionIsometry (H := H) e).toContinuousLinearMap.adjoint v x = v (e x) := by + have hi : (inclusionIsometry (H := H) e).toContinuousLinearMap.comp (insert x) = + insert (e x) := by + apply ContinuousLinearMap.ext + intro h + exact inclusionIsometry_single e x h + have ha := congrArg ContinuousLinearMap.adjoint hi + simp only [ContinuousLinearMap.adjoint_comp, insert_adjoint] at ha + exact DFunLike.congr_fun ha v + +theorem inclusion_entry (e : X ↪ Y) (T : Operator X H) (x y : X) : + entry (operatorConjugation (inclusionIsometry e) T) (e x) (e y) = entry T x y := by + ext h + simp only [entry_apply, operatorConjugation, ContinuousLinearMap.comp_apply] + rw [← inclusionIsometry_single e y h, adjoint_apply_isometry] + exact inclusionVector_apply e _ x + +omit [DecidableEq X] in +theorem inclusion_entry_row_zero (e : X ↪ Y) (T : Operator X H) (x y : Y) + (hx : x ∉ Set.range e) : + entry (operatorConjugation (inclusionIsometry e) T) x y = 0 := by + ext h + exact inclusionVector_zero e _ x hx + +theorem inclusion_entry_col_zero (e : X ↪ Y) (T : Operator X H) (x y : Y) + (hy : y ∉ Set.range e) : + entry (operatorConjugation (inclusionIsometry e) T) x y = 0 := by + ext h + have hz : (inclusionIsometry (H := H) e).toContinuousLinearMap.adjoint + (lp.single 2 y h) = 0 := by + apply lp.ext + funext z + rw [inclusion_adjoint_apply] + exact lp.single_apply_ne (E := fun _ : Y => H) 2 y h (fun heq => hy ⟨z, heq⟩) + simp only [entry_apply, operatorConjugation, ContinuousLinearMap.comp_apply, hz, map_zero, + lp.coeFn_zero, Pi.zero_apply, zero_apply] + +theorem inclusion_compactEntries (e : X ↪ Y) {T : Operator X H} + (hT : CompactEntries T) : CompactEntries (operatorConjugation (inclusionIsometry e) T) := by + intro x y + by_cases hx : x ∈ Set.range e + · obtain ⟨a, rfl⟩ := hx + by_cases hy : y ∈ Set.range e + · obtain ⟨b, rfl⟩ := hy + rw [inclusion_entry] + exact hT a b + · rw [inclusion_entry_col_zero e T _ _ hy] + exact isCompactOperator_zero + · rw [inclusion_entry_row_zero e T _ _ hx] + exact isCompactOperator_zero + +variable [sourceMetric : PseudoMetricSpace X] [targetMetric : PseudoMetricSpace Y] + +theorem inclusion_propagation (e : X ↪ Y) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) {T : Operator X H} {r : ℝ} + (hT : PropagationLE r T) : PropagationLE r (operatorConjugation (inclusionIsometry e) T) := by + intro x y hxy + by_cases hx : x ∈ Set.range e + · obtain ⟨a, rfl⟩ := hx + by_cases hy : y ∈ Set.range e + · obtain ⟨b, rfl⟩ := hy + rw [inclusion_entry] + exact hT a b (hxy.trans_le (he a b)) + · exact inclusion_entry_col_zero e T _ _ hy + · exact inclusion_entry_row_zero e T _ _ hx + +theorem inclusion_generator (e : X ↪ Y) + (he : ∀ x y, dist (e x) (e y) ≤ dist x y) {T : Operator X H} + (hT : Generator T) : Generator (operatorConjugation (inclusionIsometry e) T) := by + obtain ⟨⟨r, hr, hprop⟩, hc, hcs⟩ := hT + refine ⟨⟨r, hr, inclusion_propagation e he hprop⟩, inclusion_compactEntries e hc, ?_⟩ + rw [← operatorConjugation_star (inclusionIsometry e) T] + exact inclusion_compactEntries e hcs + +theorem inclusion_mapsToRoe + {Domain : Type sourceUniverse} {Range : Type targetUniverse} + {Coefficient : Type coefficientUniverse} + [domainDecidable : DecidableEq Domain] [rangeDecidable : DecidableEq Range] + [normedCoefficient : NormedAddCommGroup Coefficient] + [innerCoefficient : InnerProductSpace ℂ Coefficient] + [completeCoefficient : CompleteSpace Coefficient] + [domainMetric : PseudoMetricSpace Domain] [rangeMetric : PseudoMetricSpace Range] + (e : Domain ↪ Range) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) : + MapsToRoe.{sourceUniverse, targetUniverse, coefficientUniverse} + (D := Domain) (X := Range) (H := Coefficient) + (inclusionIsometry.{sourceUniverse, targetUniverse, coefficientUniverse} + (H := Coefficient) e) := + let isometry := @inclusionIsometry.{sourceUniverse, targetUniverse, coefficientUniverse} + Domain Range Coefficient normedCoefficient innerCoefficient.toNormedSpace e + let conjugation := @operatorConjugationHom.{max sourceUniverse coefficientUniverse, + max targetUniverse coefficientUniverse} + (Module Domain Coefficient) (Module Range Coefficient) + (lp.normedAddCommGroup (E := fun _ : Domain => Coefficient) (p := 2) + (hp := inclusionExponentFact)) + (lp.instInnerProductSpace (𝕜 := ℂ) (G := fun _ : Domain => Coefficient)) + (lp.completeSpace (E := fun _ : Domain => Coefficient) (p := 2)) + (lp.normedAddCommGroup (E := fun _ : Range => Coefficient) (p := 2) + (hp := inclusionExponentFact)) + (lp.instInnerProductSpace (𝕜 := ℂ) (G := fun _ : Range => Coefficient)) + (lp.completeSpace (E := fun _ : Range => Coefficient) (p := 2)) isometry + fun operator operator_mem => + @map_mem.{sourceUniverse, targetUniverse, coefficientUniverse} + Domain Range Coefficient normedCoefficient innerCoefficient + domainDecidable rangeDecidable completeCoefficient domainMetric rangeMetric conjugation + (@conjugation_continuous.{sourceUniverse, targetUniverse, coefficientUniverse} + Domain Range Coefficient normedCoefficient innerCoefficient completeCoefficient isometry) + (fun generator is_generator => + @generator_mem.{targetUniverse, coefficientUniverse} + Range Coefficient normedCoefficient innerCoefficient rangeDecidable + completeCoefficient rangeMetric (conjugation generator) + (@inclusion_generator.{sourceUniverse, targetUniverse, coefficientUniverse} + Domain Range Coefficient domainDecidable rangeDecidable normedCoefficient + innerCoefficient completeCoefficient domainMetric rangeMetric e he + generator is_generator)) + operator operator_mem + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RoeLocalCompactness.lean b/lean/OAI/Topology/CoarseAssembly/RoeLocalCompactness.lean new file mode 100644 index 0000000000000000000000000000000000000000..52233246f0922eae959649af76140ce691d95e82 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RoeLocalCompactness.lean @@ -0,0 +1,56 @@ +import OAI.Topology.CoarseAssembly.DiagonalApproximation + +namespace OAI + +/-! # Local compactness on the actual discrete ample module -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Filter +open scoped ZeroAtInfty Topology + +variable {X H : Type*} [DecidableEq X] [TopologicalSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +/-- The usual local-compactness condition, with the actual multiplication operators. -/ +def LocallyCompact (T : Operator X H) : Prop := + ∀ f : C₀(X, ℂ), IsCompactOperator (diagonalMultiplier (H := H) f * T) ∧ + IsCompactOperator (T * diagonalMultiplier (H := H) f) + +variable [DiscreteTopology X] [CompleteSpace H] + +theorem locallyCompact_of_compact_rows_columns (T : Operator X H) + (hr : ∀ x, IsCompactOperator ((coordinate x).comp T)) + (hc : ∀ x, IsCompactOperator (T.comp (insert x))) : LocallyCompact T := by + intro f + constructor + · apply isCompactOperator_of_tendsto (l := atTop) + ((finiteDiagonal_tendsto (H := H) f).mul tendsto_const_nhds) + exact Eventually.of_forall (fun s => finiteDiagonal_mul_compact T hr f s) + · apply isCompactOperator_of_tendsto (l := atTop) + (tendsto_const_nhds.mul (finiteDiagonal_tendsto (H := H) f)) + exact Eventually.of_forall (fun s => mul_finiteDiagonal_compact T hc f s) + +variable [PseudoMetricSpace X] + +theorem locallyCompact_of_propagation + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : Operator X H} {r : ℝ} (hp : PropagationLE r T) (hc : CompactEntries T) : + LocallyCompact T := + locallyCompact_of_compact_rows_columns T + (compact_row_of_propagation finiteBalls hp hc) + (compact_column_of_propagation finiteBalls hp hc) + +theorem generator_locallyCompact + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + {T : Operator X H} (hT : Generator T) : LocallyCompact T := by + obtain ⟨⟨r, _, hr⟩, hc, _⟩ := hT + exact locallyCompact_of_propagation finiteBalls hr hc + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RoeRows.lean b/lean/OAI/Topology/CoarseAssembly/RoeRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..b19dee81dde0c647cefd9ad852278faf6fe03b90 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RoeRows.lean @@ -0,0 +1,71 @@ +import OAI.Topology.CoarseAssembly.RoeCalculus + +namespace OAI + +/-! # Reconstruction from finite operator rows + +Finite propagation and finite metric balls make every row finite. The +finite-row formula extends to arbitrary Hilbert-sum vectors by density of +the single-coordinate subspaces. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +theorem operator_ext_entries {T S : Operator X H} + (h : ∀ x y, entry T x y = entry S x y) : T = S := by + apply lp.ext_continuousLinearMap (by norm_num : (2 : ENNReal) ≠ ⊤) + intro y + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext x + exact DFunLike.congr_fun (h x y) v + +theorem entry_norm_le (T : Operator X H) (x y : X) : ‖entry T x y‖ ≤ ‖T‖ := by + apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg T) + intro h + have hsingle : ‖(lp.single 2 y h : Module X H)‖ = ‖h‖ := + lp.norm_single (E := fun _ : X => H) (by norm_num : (0 : ENNReal) < 2) y h + have hop := T.le_opNorm (lp.single 2 y h : Module X H) + rw [hsingle] at hop + exact (lp.norm_apply_le_norm (by norm_num : (2 : ENNReal) ≠ 0) + (T (lp.single 2 y h)) x).trans hop + +theorem finite_row_apply (T : Operator X H) (x : X) (s : Finset X) + (hs : ∀ y, y ∉ s → entry T x y = 0) (v : Module X H) : + T v x = ∑ y ∈ s, entry T x y (v y) := by + have heq : (coordinate x).comp T = + ∑ y ∈ s, (entry T x y).comp (coordinate y) := by + apply lp.ext_continuousLinearMap (by norm_num : (2 : ENNReal) ≠ ⊤) + intro y + apply ContinuousLinearMap.ext + intro z + change entry T x y z = _ + simp only [ContinuousLinearMap.comp_apply, sum_apply, + coordinate_apply, lp.singleContinuousLinearMap_apply] + by_cases hy : y ∈ s + · rw [Finset.sum_eq_single y] + · simp + · intro b hb hby + simp [Ne.symm hby] + · exact fun h => (h hy).elim + · rw [hs y hy] + simp only [zero_apply] + symm + apply Finset.sum_eq_zero + intro b hb + have hby : b ≠ y := fun h => hy (h ▸ hb) + simp [hby] + simpa only [ContinuousLinearMap.comp_apply, sum_apply, coordinate_apply] using + DFunLike.congr_fun heq v + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/RoeTransfer.lean b/lean/OAI/Topology/CoarseAssembly/RoeTransfer.lean new file mode 100644 index 0000000000000000000000000000000000000000..0176cf26d1983f1a0f02884aa0e4cc391d3c79ae --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/RoeTransfer.lean @@ -0,0 +1,83 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RoeCalculus + +namespace OAI + +/-! +# Norm-closure and spatial factorization for the finite-fiber transfer + +The missing construction of the finite-propagation lift is isolated as an +explicit witness here; it is not treated as a published input. Once a lift +has been constructed by matchings, the following argument proves that the +spatial homomorphism lands in the actual reduced Roe algebra. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open scoped Topology + +variable {B D X H : Type*} [DecidableEq B] [DecidableEq D] [DecidableEq X] +variable [PseudoMetricSpace B] [PseudoMetricSpace D] [PseudoMetricSpace X] +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [DecidableEq D] [DecidableEq X] [PseudoMetricSpace D] [PseudoMetricSpace X] in +theorem conjugation_continuous (V : Module D H →ₗᵢ[ℂ] Module X H) : + Continuous (operatorConjugation V) := by + show Continuous (fun T : Operator D H => + V.toContinuousLinearMap.comp (T.comp V.toContinuousLinearMap.adjoint)) + exact continuous_const.clm_comp (continuous_id.clm_comp continuous_const) + +/-- The range proof after constructing the matching lift of each generator. -/ +theorem conjugation_mem_of_sandwich_lifts + (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + (V : Module D H →ₗᵢ[ℂ] Module X H) + (P : Operator X H) (Pn : ℕ → Operator X H) + (hlim : Filter.Tendsto Pn Filter.atTop (nhds P)) + (hprop : ∀ n, ∃ r : ℝ, 0 ≤ r ∧ PropagationLE r (Pn n)) + (hlift : ∀ T : Operator D H, Generator T → + ∃ A : Operator X H, Generator A ∧ P * A * P = operatorConjugation V T) + {T : Operator D H} (hT : T ∈ algebra (X := D) (H := H)) : + operatorConjugation V T ∈ algebra (X := X) (H := H) := by + apply map_mem (operatorConjugationHom V) (conjugation_continuous V) _ hT + intro S hS + obtain ⟨A, hA, heq⟩ := hlift S hS + change operatorConjugation V S ∈ algebra (X := X) (H := H) + rw [← heq] + apply sandwich_mem hlim + intro n + obtain ⟨r, hr, hn⟩ := hprop n + exact generator_sandwich finiteBalls hA hr hn + +@[simp] theorem conjugationHom_apply + (V : Module D H →ₗᵢ[ℂ] Module X H) (hV : MapsToRoe V) + (T : algebra (X := D) (H := H)) : + (conjugationHom V hV T : Operator X H) = operatorConjugation V T := rfl + +theorem conjugationHom_injective + (V : Module D H →ₗᵢ[ℂ] Module X H) (hV : MapsToRoe V) : + Function.Injective (conjugationHom V hV) := by + intro T S h + apply Subtype.ext + apply operatorConjugation_injective V + exact congrArg Subtype.val h + +/-- Exact operator factorization remains exact after restriction to Roe +algebras. This is the final operator identity `Ad V ∘ Ad E = Ad I`. -/ +theorem conjugationHom_comp_apply + (E : Module B H →ₗᵢ[ℂ] Module D H) + (V : Module D H →ₗᵢ[ℂ] Module X H) + (hE : MapsToRoe E) (hV : MapsToRoe V) (hVE : MapsToRoe (V.comp E)) + (T : algebra (X := B) (H := H)) : + conjugationHom (D := D) (X := X) (H := H) V hV + (conjugationHom (D := B) (X := D) (H := H) E hE T) = + conjugationHom (D := B) (X := X) (H := H) (V.comp E) hVE T := by + apply Subtype.ext + exact operatorConjugation_comp V E T + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SampledHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/SampledHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..967f288ad3f8f97d8b3dea7c4f55abed90a863a6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SampledHomotopy.lean @@ -0,0 +1,109 @@ +import OAI.Topology.CoarseAssembly.FiniteCycleSum +import OAI.Topology.CoarseAssembly.CharacterExtension + +namespace OAI + +/-! # Actual finite samples of an analytic homotopy + +The inactive summands are degenerate character cycles on the same Hilbert +space. Thus the ambient countable Hilbert sum does not depend on the samples. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +def sampledCycle (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (j : ℕ) : OddCycle A where + space := h.space + representation := if j < N then h.representation (τ j) else + characterProjectionRepresentation χ (1 : End h.space) (IsStarProjection.one _) + operator := if j < N then h.operator (τ j) else 1 + commutator_compact a := by + by_cases hj : j < N + · simpa only [ite_eq_left hj] using h.commutator_compact (τ j) a + · simp only [ite_eq_right hj, one_mul, mul_one, sub_self] + exact isCompactOperator_zero + square_compact a := by + by_cases hj : j < N + · simpa only [ite_eq_left hj] using h.square_compact (τ j) a + · simp only [ite_eq_right hj, one_mul, sub_self, zero_mul] + exact isCompactOperator_zero + adjoint_compact a := by + by_cases hj : j < N + · simpa only [ite_eq_left hj] using h.adjoint_compact (τ j) a + · simp only [ite_eq_right hj, star_one, sub_self, zero_mul] + exact isCompactOperator_zero + +theorem sampledCycle_active (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (j : ℕ) (hj : j < N) : + sampledCycle h χ N τ j = h.eval (τ j) := by + simp only [sampledCycle, ite_eq_left hj, OddHomotopy.eval] + +theorem sampledCycle_inactive_degenerate (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (j : ℕ) (hj : N ≤ j) : + (sampledCycle h χ N τ j).Degenerate := by + have he : sampledCycle h χ N τ j = identityOperatorCycle + (characterProjectionRepresentation χ (1 : End h.space) (IsStarProjection.one _)) := by + simp only [sampledCycle, identityOperatorCycle, ite_eq_right (not_lt.mpr hj)] + rw [he] + exact identityOperatorCycle_degenerate _ + +theorem sampledCycle_unital (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (j : ℕ) + (hπ : ∀ t, h.representation t 1 = 1) : + (sampledCycle h χ N τ j).representation 1 = 1 := by + change (if j < N then h.representation (τ j) else + characterProjectionRepresentation χ (1 : End h.space) (IsStarProjection.one _)) 1 = 1 + split_ifs with hj + · exact hπ (τ j) + · simp [characterProjectionRepresentation] + +theorem sampledCycle_selfAdjoint (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (j : ℕ) + (hs : ∀ t, IsSelfAdjoint (h.operator t)) : + IsSelfAdjoint (sampledCycle h χ N τ j).operator := by + change IsSelfAdjoint (if j < N then h.operator (τ j) else 1) + split_ifs + · exact hs (τ j) + · exact IsSelfAdjoint.one _ + +theorem sampledCycle_norm_le (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (j : ℕ) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) : ‖(sampledCycle h χ N τ j).operator‖ ≤ C := by + change ‖if j < N then h.operator (τ j) else 1‖ ≤ C + split_ifs + · exact hF (τ j) + · exact ContinuousLinearMap.norm_id_le.trans hC + +def sampledFiniteSum (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) : OddCycle A := + finiteActiveCycle (sampledCycle h χ N τ) C (zero_le_one.trans hC) + (fun j => sampledCycle_norm_le h χ N τ j C hC hF) N + (fun j => sampledCycle_inactive_degenerate h χ N τ j) + +theorem sampledFiniteSum_unital (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) (hπ : ∀ t, h.representation t 1 = 1) : + (sampledFiniteSum h χ N τ C hC hF).representation 1 = 1 := + finiteActiveCycle_unital _ _ _ _ _ _ (fun j => sampledCycle_unital h χ N τ j hπ) + +theorem sampledFiniteSum_selfAdjoint (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) (hs : ∀ t, IsSelfAdjoint (h.operator t)) : + IsSelfAdjoint (sampledFiniteSum h χ N τ C hC hF).operator := + finiteActiveCycle_selfAdjoint _ _ _ _ _ _ (fun j => sampledCycle_selfAdjoint h χ N τ j hs) + +theorem sampledFiniteSum_norm_le (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) : ‖(sampledFiniteSum h χ N τ C hC hF).operator‖ ≤ C := + finiteActiveCycle_norm _ _ _ _ _ _ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SampledHomotopyDecomposition.lean b/lean/OAI/Topology/CoarseAssembly/SampledHomotopyDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..c55edc01e3e68f476a629f79781af0c0e8680d07 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SampledHomotopyDecomposition.lean @@ -0,0 +1,103 @@ +import OAI.Topology.CoarseAssembly.SampledHomotopy +import OAI.Topology.CoarseAssembly.FiniteCycleDecomposition +import OAI.Topology.CoarseAssembly.HomogeneousReindex + +namespace OAI + +/-! # Endpoint and interior decompositions of finite homotopy samples -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +def sampledFiniteSum_head_tail (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) : + (h.eval (τ 0)).IsDirectSum + (sampledFiniteSum h χ N (fun j => τ (j + 1)) C hC hF) + (sampledFiniteSum h χ (N + 1) τ C hC hF) where + left := summandIsometry (fun _ => h.space) 0 + right := tailInsert (fun _ => h.space) + orthogonal := head_tail_orthogonal _ + exhaustive := head_tail_exhaustive _ + representation_eq a := by + change blockOperator (fun j => (if j < N + 1 then h.representation (τ j) else + characterProjectionRepresentation χ (1 : End h.space) (IsStarProjection.one _)) a) + ‖a‖ (norm_nonneg _) _ = _ + erw [blockOperator_head_tail] + simp only [Nat.add_lt_add_iff_right, Nat.zero_lt_succ, ite_true] + rfl + operator_eq := by + change blockOperator (fun j => if j < N + 1 then h.operator (τ j) else 1) + C (zero_le_one.trans hC) _ = _ + erw [blockOperator_head_tail] + simp only [Nat.add_lt_add_iff_right, Nat.zero_lt_succ, ite_true] + rfl + +/-- Put the last endpoint first, leaving the interior list in its original order. -/ +def lastEndpointFirst (N : ℕ) (τ : ℕ → Interval) (j : ℕ) : Interval := + if j = 0 then τ (N + 1) else τ j + +@[simp] theorem lastEndpointFirst_zero (N : ℕ) (τ : ℕ → Interval) : + lastEndpointFirst N τ 0 = τ (N + 1) := by simp [lastEndpointFirst] + +@[simp] theorem lastEndpointFirst_succ (N : ℕ) (τ : ℕ → Interval) (j : ℕ) : + lastEndpointFirst N τ (j + 1) = τ (j + 1) := by simp [lastEndpointFirst] + +def sampledFiniteSum_rotate (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) : + (sampledFiniteSum h χ (N + 1) (lastEndpointFirst N τ) C hC hF).UnitaryEquivalent + (sampledFiniteSum h χ (N + 1) (fun j => τ (j + 1)) C hC hF) where + unitary := repeatedReindexEquiv h.space (rotatePrefix N) + representation_eq a := by + symm + change operatorConjugation (repeatedReindexEquiv h.space (rotatePrefix N)).toLinearIsometry + (blockOperator (fun j => (if j < N + 1 then h.representation (lastEndpointFirst N τ j) else + characterProjectionRepresentation χ (1 : End h.space) (IsStarProjection.one _)) a) + ‖a‖ (norm_nonneg _) _) = _ + erw [blockOperator_reindex] + ext x j + change (sampledCycle h χ (N + 1) (lastEndpointFirst N τ) ((rotatePrefix N).symm j)).representation a (x j) = + (sampledCycle h χ (N + 1) (fun j => τ (j + 1)) j).representation a (x j) + by_cases hj : j < N + · rw [rotatePrefix_inverse_lt N j hj] + simp [sampledCycle, lastEndpointFirst, Nat.lt_add_one_of_lt hj, hj] + rfl + · by_cases he : j = N + · subst j + simp [sampledCycle, lastEndpointFirst] + rfl + · have hgt : N < j := by omega + rw [rotatePrefix_inverse_gt N j hgt] + simp [sampledCycle, show ¬j < N + 1 by omega] + rfl + operator_eq := by + symm + change operatorConjugation (repeatedReindexEquiv h.space (rotatePrefix N)).toLinearIsometry + (blockOperator (fun j => if j < N + 1 then h.operator (lastEndpointFirst N τ j) else 1) + C (zero_le_one.trans hC) _) = _ + erw [blockOperator_reindex] + ext x j + change (sampledCycle h χ (N + 1) (lastEndpointFirst N τ) ((rotatePrefix N).symm j)).operator (x j) = + (sampledCycle h χ (N + 1) (fun j => τ (j + 1)) j).operator (x j) + by_cases hj : j < N + · rw [rotatePrefix_inverse_lt N j hj] + simp [sampledCycle, lastEndpointFirst, Nat.lt_add_one_of_lt hj, hj] + rfl + · by_cases he : j = N + · subst j + simp [sampledCycle, lastEndpointFirst] + rfl + · have hgt : N < j := by omega + rw [rotatePrefix_inverse_gt N j hgt] + simp [sampledCycle, show ¬j < N + 1 by omega] + rfl + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SampledHomotopyEstimates.lean b/lean/OAI/Topology/CoarseAssembly/SampledHomotopyEstimates.lean new file mode 100644 index 0000000000000000000000000000000000000000..0f3440aa2d1bb1f207679c4fdf2469ffd8a59d13 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SampledHomotopyEstimates.lean @@ -0,0 +1,48 @@ +import OAI.Topology.CoarseAssembly.SampledHomotopy +import OAI.Topology.CoarseAssembly.HomogeneousReindex + +namespace OAI + +/-! # Uniform norm estimates for arbitrarily many finite samples -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem sampledFiniteSum_operator_sub_norm_le (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ σ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) (δ : ℝ) (hδ : 0 ≤ δ) + (hnear : ∀ j, j < N → ‖h.operator (τ j) - h.operator (σ j)‖ ≤ δ) : + ‖(show End (repeatedHilbert h.space) from (sampledFiniteSum h χ N τ C hC hF).operator) - + (show End (repeatedHilbert h.space) from (sampledFiniteSum h χ N σ C hC hF).operator)‖ ≤ δ := by + apply blockOperator_dist_le (hε := hδ) + intro j + change ‖(if j < N then h.operator (τ j) else 1) - + (if j < N then h.operator (σ j) else 1)‖ ≤ δ + by_cases hj : j < N + · simpa only [ite_eq_left hj] using hnear j hj + · simpa only [ite_eq_right hj, sub_self, norm_zero] using hδ + +theorem sampledFiniteSum_representation_sub_norm_le (h : OddHomotopy A) (χ : A →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ σ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) (a : A) (δ : ℝ) (hδ : 0 ≤ δ) + (hnear : ∀ j, j < N → ‖h.representation (τ j) a - h.representation (σ j) a‖ ≤ δ) : + ‖(show End (repeatedHilbert h.space) from (sampledFiniteSum h χ N τ C hC hF).representation a) - + (show End (repeatedHilbert h.space) from (sampledFiniteSum h χ N σ C hC hF).representation a)‖ ≤ δ := by + apply blockOperator_dist_le (hε := hδ) + intro j + change ‖(if j < N then h.representation (τ j) else + characterProjectionRepresentation χ (1 : End h.space) (IsStarProjection.one _)) a - + (if j < N then h.representation (σ j) else + characterProjectionRepresentation χ (1 : End h.space) (IsStarProjection.one _)) a‖ ≤ δ + by_cases hj : j < N + · simpa only [ite_eq_left hj] using hnear j hj + · simpa only [ite_eq_right hj, sub_self, norm_zero] using hδ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SampledRipsEstimates.lean b/lean/OAI/Topology/CoarseAssembly/SampledRipsEstimates.lean new file mode 100644 index 0000000000000000000000000000000000000000..1ef9b89d16e6628f7909311f8957d33a21ca585d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SampledRipsEstimates.lean @@ -0,0 +1,61 @@ +import OAI.Topology.CoarseAssembly.SampledHomotopyEstimates +import OAI.Topology.CoarseAssembly.PartitionMapNorm +import OAI.Topology.CoarseAssembly.RipsUniformHomotopy +import OAI.Topology.CoarseAssembly.SeparatedFamilyNearby + +namespace OAI + +/-! # Bounds for the localized finite sums used in homotopy telescoping -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] + +theorem sampledFiniteSum_partition_sub_norm_le + (r : ℝ) (h : OddHomotopy C(Point X r, ℂ)) (χ : C(Point X r, ℂ) →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ σ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) (δ : ℝ) (hδ : 0 ≤ δ) + (hnear : ∀ x j, j < N → ‖h.representation (τ j) (sqrtCoordinate r x) - + h.representation (σ j) (sqrtCoordinate r x)‖ ≤ δ) : + ‖(show repeatedHilbert h.space →L[ℂ] Module X (repeatedHilbert h.space) from + partitionMap (representedSqrt r (sampledFiniteSum h χ N τ C hC hF))) - + (show repeatedHilbert h.space →L[ℂ] Module X (repeatedHilbert h.space) from + partitionMap (representedSqrt r (sampledFiniteSum h χ N σ C hC hF)))‖ ≤ + (Fintype.card X : ℝ) * δ := by + apply (partitionMap_sub_norm_le_sum _ _).trans + calc + _ ≤ ∑ _x : X, δ := Finset.sum_le_sum (fun x _ => + sampledFiniteSum_representation_sub_norm_le h χ N τ σ C hC hF + (sqrtCoordinate r x) δ hδ (hnear x)) + _ = _ := by simp + +theorem sampledFiniteSum_ample_sub_norm_le + (r : ℝ) (h : OddHomotopy C(Point X r, ℂ)) (χ : C(Point X r, ℂ) →⋆ₐ[ℂ] ℂ) + (N : ℕ) (τ σ : ℕ → Interval) (C : ℝ) (hC : 1 ≤ C) + (hF : ∀ t, ‖h.operator t‖ ≤ C) (hπ : ∀ t, h.representation t 1 = 1) + (δ : ℝ) (hδ : 0 ≤ δ) + (hop : ∀ j, j < N → ‖h.operator (τ j) - h.operator (σ j)‖ ≤ δ) + (hrep : ∀ x j, j < N → ‖h.representation (τ j) (sqrtCoordinate r x) - + h.representation (σ j) (sqrtCoordinate r x)‖ ≤ δ) : + ‖ampleRipsOperator r (sampledFiniteSum h χ N τ C hC hF) + (sampledFiniteSum_unital h χ N τ C hC hF hπ) - + ampleRipsOperator r (sampledFiniteSum h χ N σ C hC hF) + (sampledFiniteSum_unital h χ N σ C hC hF hπ)‖ ≤ + δ + (4 * C + 2) * ((Fintype.card X : ℝ) * δ) := by + apply (coefficientExtension_sub_norm_le (ampleIsometry (repeatedHilbert h.space)) _ _).trans + apply (localizedSpatialOperator_variation_norm_le _ _ _ _ _ _ C + (sampledFiniteSum_norm_le h χ N σ C hC hF)).trans + exact add_le_add (sampledFiniteSum_operator_sub_norm_le h χ N τ σ C hC hF δ hδ hop) + (mul_le_mul_of_nonneg_left + (sampledFiniteSum_partition_sub_norm_le r h χ N τ σ C hC hF δ hδ hrep) + (by linarith)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/Sandwich.lean b/lean/OAI/Topology/CoarseAssembly/Sandwich.lean new file mode 100644 index 0000000000000000000000000000000000000000..4dfb553a47fa24b788891b7f5310999656b398e0 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/Sandwich.lean @@ -0,0 +1,60 @@ +import Mathlib.Analysis.Normed.Ring.Basic +import Mathlib.Analysis.Normed.Ring.Lemmas +import Mathlib.Topology.Algebra.Ring.Basic +import Mathlib.Tactic.NoncommRing +import Mathlib.Tactic.Linarith + +namespace OAI + +/-! +# The operator-norm sandwich estimate + +The norm estimate and closure step do not require an amplified +constant-fiber projection to be locally compact. +Membership of the approximating sandwiches in the closed algebra is explicit. +-/ + +namespace CoarseAssembly + +section Estimate + +variable {A : Type*} [NormedRing A] + +/-- The uniform `2 ‖Q-P‖ ‖T‖` bound for sandwiching by contractions. -/ +theorem sandwich_error_bound (P Q T : A) (hP : ‖P‖ ≤ 1) (hQ : ‖Q‖ ≤ 1) : + ‖Q * T * Q - P * T * P‖ ≤ 2 * ‖Q - P‖ * ‖T‖ := by + have hexpand : Q * T * Q - P * T * P = (Q - P) * T * Q + P * T * (Q - P) := by + noncomm_ring + rw [hexpand] + calc + ‖(Q - P) * T * Q + P * T * (Q - P)‖ ≤ + ‖(Q - P) * T * Q‖ + ‖P * T * (Q - P)‖ := norm_add_le _ _ + _ ≤ ‖Q - P‖ * ‖T‖ * ‖Q‖ + ‖P‖ * ‖T‖ * ‖Q - P‖ := by + exact add_le_add + ((norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _))) + ((norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _))) + _ ≤ 2 * ‖Q - P‖ * ‖T‖ := by + have hleft := mul_le_mul_of_nonneg_left hQ (mul_nonneg (norm_nonneg (Q-P)) (norm_nonneg T)) + have hright := mul_le_mul_of_nonneg_right hP (mul_nonneg (norm_nonneg T) (norm_nonneg (Q-P))) + nlinarith + +end Estimate + +section ClosedRange + +variable {A : Type*} [NormedRing A] + +/-- Norm convergence of the finite-propagation projections passes their +sandwiches into any norm-closed algebra. The hypothesis concerns the +sandwiches themselves, as required for local compactness in the paper. -/ +theorem sandwich_mem_of_tendsto (S : Set A) (hS : IsClosed S) (P : A) + (Pn : ℕ → A) (hlim : Filter.Tendsto Pn Filter.atTop (nhds P)) (T : A) + (hmem : ∀ n, Pn n * T * Pn n ∈ S) : P * T * P ∈ S := by + apply hS.mem_of_tendsto ((hlim.mul tendsto_const_nhds).mul hlim) + exact Filter.Eventually.of_forall hmem + +end ClosedRange + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SandwichNormControl.lean b/lean/OAI/Topology/CoarseAssembly/SandwichNormControl.lean new file mode 100644 index 0000000000000000000000000000000000000000..8ea933c00cf51c10ba9672b05f2a7aa1ae3e5bcd --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SandwichNormControl.lean @@ -0,0 +1,64 @@ +import OAI.Topology.CoarseAssembly.LocalizationNormContinuity + +namespace OAI + +/-! # Uniform estimates for changing localization isometries -/ + +noncomputable section + +namespace CoarseAssembly + +variable {E H : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def operatorSandwich (P : E →L[ℂ] H) (F : E →L[ℂ] E) : H →L[ℂ] H := + P.comp (F.comp P.adjoint) + +theorem operatorSandwich_sub_norm_le (P Q : E →L[ℂ] H) + (hP : ‖P‖ ≤ 1) (hQ : ‖Q‖ ≤ 1) (F G : E →L[ℂ] E) (C : ℝ) (hG : ‖G‖ ≤ C) : + ‖operatorSandwich P F - operatorSandwich Q G‖ ≤ + ‖F - G‖ + 2 * C * ‖P - Q‖ := by + have hC : 0 ≤ C := (norm_nonneg G).trans hG + have hPa : ‖P.adjoint‖ ≤ 1 := by simpa only [ContinuousLinearMap.adjoint.norm_map] using hP + have hd : ‖P.adjoint - Q.adjoint‖ = ‖P - Q‖ := by + rw [← map_sub, ContinuousLinearMap.adjoint.norm_map] + have h1 : ‖P.comp ((F - G).comp P.adjoint)‖ ≤ ‖F - G‖ := by + calc + _ ≤ ‖P‖ * (‖F - G‖ * ‖P.adjoint‖) := + (ContinuousLinearMap.opNorm_comp_le _ _).trans + (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _)) + _ ≤ 1 * (‖F - G‖ * 1) := by gcongr + _ = _ := by ring + have h2 : ‖(P - Q).comp (G.comp P.adjoint)‖ ≤ C * ‖P - Q‖ := by + calc + _ ≤ ‖P - Q‖ * (‖G‖ * ‖P.adjoint‖) := + (ContinuousLinearMap.opNorm_comp_le _ _).trans + (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _)) + _ ≤ ‖P - Q‖ * (C * 1) := by gcongr + _ = _ := by ring + have h3 : ‖Q.comp (G.comp (P.adjoint - Q.adjoint))‖ ≤ C * ‖P - Q‖ := by + calc + _ ≤ ‖Q‖ * (‖G‖ * ‖P.adjoint - Q.adjoint‖) := + (ContinuousLinearMap.opNorm_comp_le _ _).trans + (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _)) + _ ≤ 1 * (C * ‖P - Q‖) := by rw [hd]; gcongr + _ = _ := by ring + have he : operatorSandwich P F - operatorSandwich Q G = + P.comp ((F - G).comp P.adjoint) + (P - Q).comp (G.comp P.adjoint) + + Q.comp (G.comp (P.adjoint - Q.adjoint)) := by + simp only [operatorSandwich, ContinuousLinearMap.sub_comp, ContinuousLinearMap.comp_sub] + abel + rw [he] + calc + _ ≤ ‖P.comp ((F - G).comp P.adjoint)‖ + ‖(P - Q).comp (G.comp P.adjoint)‖ + + ‖Q.comp (G.comp (P.adjoint - Q.adjoint))‖ := (norm_add_le _ _).trans + (add_le_add (norm_add_le _ _) le_rfl) + _ ≤ ‖F - G‖ + C * ‖P - Q‖ + C * ‖P - Q‖ := add_le_add (add_le_add h1 h2) h3 + _ = _ := by ring + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ScalarCutDown.lean b/lean/OAI/Topology/CoarseAssembly/ScalarCutDown.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e9c8b0d2f2ba3bcf9595151cfeab1801fd015c9 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ScalarCutDown.lean @@ -0,0 +1,129 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ScalarCycleNormalization +import OAI.Topology.CoarseAssembly.LocalCompactPerturbation + +namespace OAI + +/-! # Cutting a scalar Fredholm operator down to its represented subspace -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem symmetricCutDown_selfAdjoint (P F : End H) (hP : IsSelfAdjoint P) : + IsSelfAdjoint (symmetricCutDown P F) := by + change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _ + rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq] + rw [add_comm (star (P * F * P))] + rfl + +theorem symmetricCutDown_complement (P F : End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : symmetricCutDown P F * (1 - P) = 1 - P := by + have hzero : ∀ T : End H, P * T * P * (1 - P) = 0 := by + intro T + rw [mul_sub, mul_one, mul_assoc (P * T) P P, hPP, sub_self] + have hQ : (1 - P) * (1 - P) = 1 - P := by + calc + (1 - P) * (1 - P) = 1 - P - P + P * P := by noncomm_ring + _ = 1 - P := by rw [hPP]; abel + unfold symmetricCutDown + rw [add_mul, smul_mul_assoc, add_mul, hzero F, + star_mul, star_mul, hP.star_eq, ← mul_assoc, hzero (star F), add_zero, smul_zero, zero_add, hQ] + +theorem scalar_projection_selfAdjoint (c : OddCycle ℂ) : IsSelfAdjoint (c.representation 1) := by + change star (c.representation 1) = c.representation 1 + rw [← map_star, star_one] + +theorem scalar_projection_sq (c : OddCycle ℂ) : c.representation 1 * c.representation 1 = + c.representation 1 := by rw [← map_mul, one_mul] + +theorem symmetricCutDown_sub_mul (P F : End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : + (symmetricCutDown P F - F) * P = -(F * P - P * F) * P + + (1 / 2 : ℝ) • (P * ((star F - F) * P)) := by + simp only [symmetricCutDown, sub_mul, add_mul, smul_mul_assoc, + star_mul, hP.star_eq, mul_sub, mul_assoc, hPP, one_mul, neg_mul] + module + +theorem mul_symmetricCutDown_sub (P F : End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) : + P * (symmetricCutDown P F - F) = P * (F * P - P * F) + + (1 / 2 : ℝ) • (P * ((star F - F) * P)) := by + simp only [symmetricCutDown, mul_sub, mul_add, mul_smul_comm, + star_mul, hP.star_eq, sub_mul, ← mul_assoc, hPP, mul_one] + module + +theorem scalarCutDown_compact (c : OddCycle ℂ) : + let P := c.representation 1 + let K := symmetricCutDown P c.operator - c.operator + IsCompactOperator (K * P : End c.space) ∧ + IsCompactOperator (P * K : End c.space) ∧ + IsCompactOperator (star K * P : End c.space) := by + let P := c.representation 1 + let K := symmetricCutDown P c.operator - c.operator + have hp : IsSelfAdjoint P := scalar_projection_selfAdjoint c + have hpp : P * P = P := scalar_projection_sq c + have hd := c.adjoint_compact 1 + have hc := c.commutator_compact 1 + have hr : IsCompactOperator (K * P : End c.space) := by + dsimp only [K] + rw [symmetricCutDown_sub_mul P c.operator hp hpp] + exact (compact_mul_right hc.neg P).add ((compact_mul_left hd P).smul (1 / 2 : ℝ)) + have hl : IsCompactOperator (P * K : End c.space) := by + dsimp only [K] + rw [mul_symmetricCutDown_sub P c.operator hp hpp] + exact (compact_mul_left hc P).add ((compact_mul_left hd P).smul (1 / 2 : ℝ)) + refine ⟨hr, hl, ?_⟩ + have he : star K * P = K * P - (star c.operator - c.operator) * P := by + dsimp only [K] + rw [star_sub, (symmetricCutDown_selfAdjoint P c.operator hp).star_eq] + noncomm_ring + rw [he] + exact hr.sub hd + +theorem exists_supported_scalar_representative (c : OddCycle ℂ) : + ∃ d : OddCycle ℂ, cycleClass ℂ d = cycleClass ℂ c ∧ IsSelfAdjoint d.operator ∧ + d.operator * (1 - d.representation 1) = 1 - d.representation 1 := by + let P := c.representation 1 + let K := symmetricCutDown P c.operator - c.operator + obtain ⟨hr, hl, hs⟩ := scalarCutDown_compact c + have hr' (z : ℂ) : IsCompactOperator (K * c.representation z : End c.space) := by + rw [scalar_representation, mul_smul_comm] + exact hr.smul z + have hl' (z : ℂ) : IsCompactOperator (c.representation z * K : End c.space) := by + rw [scalar_representation, smul_mul_assoc] + exact hl.smul z + have hs' (z : ℂ) : IsCompactOperator (star K * c.representation z : End c.space) := by + rw [scalar_representation, mul_smul_comm] + exact hs.smul z + have he : c.operator + K = symmetricCutDown P c.operator := by dsimp only [K]; abel + refine ⟨c.localCompactPerturb K hr' hl' hs', localCompactPerturb_class c K hr' hl' hs', ?_, ?_⟩ + · change IsSelfAdjoint (c.operator + K) + rw [he] + exact symmetricCutDown_selfAdjoint P c.operator (scalar_projection_selfAdjoint c) + · change (c.operator + K) * (1 - P) = 1 - P + rw [he] + exact symmetricCutDown_complement P c.operator (scalar_projection_selfAdjoint c) + (scalar_projection_sq c) + +theorem supported_square_compact (c : OddCycle ℂ) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + IsCompactOperator (c.operator * c.operator - 1 : End c.space) := by + have hz : (c.operator * c.operator - 1) * (1 - c.representation 1) = 0 := by + calc + _ = c.operator * (c.operator * (1 - c.representation 1)) - + (1 - c.representation 1) := by noncomm_ring + _ = 0 := by rw [hQ, hQ, sub_self] + have he : c.operator * c.operator - 1 = + (c.operator * c.operator - 1) * c.representation 1 := by + exact sub_eq_zero.mp (by simpa only [mul_sub, mul_one] using hz) + rw [he] + exact c.square_compact 1 + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ScalarCycleNormalization.lean b/lean/OAI/Topology/CoarseAssembly/ScalarCycleNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..eaa31a19b1c11fb291d08e0fce403447e13e3872 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ScalarCycleNormalization.lean @@ -0,0 +1,35 @@ +import OAI.Topology.CoarseAssembly.InvolutiveNormalization + +namespace OAI + +/-! # Vanishing of unital scalar Fredholm cycles -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +theorem scalar_representation (c : OddCycle ℂ) (z : ℂ) : + c.representation z = z • c.representation 1 := by + simpa using c.representation.map_smul z (1 : ℂ) + +theorem scalar_involutive_degenerate (c : OddCycle ℂ) + (hunit : c.representation 1 = 1) (hself : IsSelfAdjoint c.operator) + (hsq : c.operator * c.operator = 1) : c.Degenerate := by + refine ⟨?_, ?_, ?_⟩ + · intro z + rw [scalar_representation, hunit, mul_smul_comm, smul_mul_assoc, mul_one, one_mul, sub_self] + · intro z + rw [hsq, sub_self, zero_mul] + · intro z + rw [hself.star_eq, sub_self, zero_mul] + +theorem unital_scalar_cycleClass_zero (c : OddCycle ℂ) (hunit : c.representation 1 = 1) : + cycleClass ℂ c = 0 := by + obtain ⟨d, hdc, hdu, hds, hsq⟩ := exists_involutive_representative c hunit + exact hdc.symm.trans (degenerate_zero d (scalar_involutive_degenerate d hdu hds hsq)) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparableEmbedding.lean b/lean/OAI/Topology/CoarseAssembly/SeparableEmbedding.lean new file mode 100644 index 0000000000000000000000000000000000000000..ff50a661462ee653926e81483bdcd81db04b28f7 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparableEmbedding.lean @@ -0,0 +1,46 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.FredholmModule +import OAI.Topology.CoarseAssembly.InclusionModule +import Mathlib.Topology.Bases + +namespace OAI + +/-! # Placing each separable cycle on the fixed ample coefficient space -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +theorem orthonormal_countable {H : Type*} [NormedAddCommGroup H] + [InnerProductSpace ℂ H] [SecondCountableTopology H] {ι : Type*} {v : ι → H} + (hv : Orthonormal ℂ v) : Countable ι := by + have hd : Pairwise (fun i j => Disjoint (Metric.ball (v i) (1 / 2 : ℝ)) + (Metric.ball (v j) (1 / 2 : ℝ))) := by + intro i j hij + apply Set.disjoint_left.mpr + intro z hzi hzj + have hn : ‖v i - v j‖ ^ 2 = 2 := by + rw [@norm_sub_sq ℂ] + norm_num [hv.norm_eq_one, hv.inner_eq_zero hij] + have hzi' : dist (v i) z < 1 / 2 := by simpa only [Metric.mem_ball, dist_comm] using hzi + have hzj' : dist z (v j) < 1 / 2 := hzj + have hdist : dist (v i) (v j) < 1 := by linarith [dist_triangle (v i) z (v j)] + rw [dist_eq_norm] at hdist + nlinarith [norm_nonneg (v i - v j)] + exact hd.countable_of_isOpen_disjoint (fun _ => Metric.isOpen_ball) + (fun i => ⟨v i, Metric.mem_ball_self (by norm_num)⟩) + +/-- Only an isometric embedding is needed; the orthogonal complement is +handled by the identity extension of the Fredholm operator. -/ +theorem exists_ampleIsometry (H : HilbertSpace) : + Nonempty (H →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2) := by + obtain ⟨s, b, _⟩ := exists_hilbertBasis ℂ H + let : Countable s := orthonormal_countable b.orthonormal + obtain ⟨f, hf⟩ := exists_injective_nat s + exact ⟨(inclusionIsometry (H := ℂ) ⟨f, hf⟩).comp b.repr.toLinearIsometry⟩ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedBoundaryCongruence.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedBoundaryCongruence.lean new file mode 100644 index 0000000000000000000000000000000000000000..f2decda8ee0ccbafb94620bbadbdd52c41b134a6 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedBoundaryCongruence.lean @@ -0,0 +1,54 @@ +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary + +namespace OAI + +/-! # A boundary class does not depend on its norm or propagation certificate -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem separatedFamilyBoundary_bound_independent (o : ∀ i, Q i) + (A : ∀ i, Operator (Q i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖A i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (A i)) + (hself : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) H))) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hp hself hsq = + separatedFamilyBoundary o A D hD hB s hs hq hself hsq := by + let := separatedMetric o + have he : separatedFamilyMultiplier o A C hC hA r hr hp = + separatedFamilyMultiplier o A D hD hB s hs hq := by + apply Subtype.ext + ext v p + rcases p with ⟨i, x⟩ + rfl + unfold separatedFamilyBoundary + simp only [he] + +theorem separatedFamilyBoundary_congr (o : ∀ i, Q i) + (A B : ∀ i, Operator (Q i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (B i)) + (hselfA : ∀ i, IsSelfAdjoint (A i)) (hselfB : ∀ i, IsSelfAdjoint (B i)) + (hsqA : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) H))) + (hsqB : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (Q i) H))) + (hAB : A = B) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hp hselfA hsqA = + separatedFamilyBoundary o B D hD hB s hs hq hselfB hsqB := by + subst B + exact separatedFamilyBoundary_bound_independent o A C D hC hD hA hB r s hr hs hp hq hselfA hsqA + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedCoarseAssembly.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedCoarseAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..af3a857ce4e020a42c68b545a2c765431c30324f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedCoarseAssembly.lean @@ -0,0 +1,58 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.SeparatedIndexCoarsening +import OAI.Topology.CoarseAssembly.Assembly + +namespace OAI + +/-! # Constructed coarse assembly for the separated finite-component application + +The maps are defined on actual locally finite analytic K-homology and are +compatible with coarsening by the proved finite-tail argument. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +@[simp] theorem separatedIndexFamily_atScale (o : ∀ i, Q i) (n : ℕ) : + letI := separatedMetric o + (separatedIndexFamily o).atScale n = separatedRipsIndex o n (Nat.cast_nonneg n) := by + let := separatedMetric o + dsimp only [separatedIndexFamily] + split_ifs with h + · rfl + · exfalso + apply h + intro r s hrs a + exact DFunLike.congr_fun (separatedRipsIndex_coarsen o + (Nat.cast_nonneg r) (Nat.cast_nonneg s) (by exact_mod_cast hrs)) a + +def separatedCoarseAssembly (o : ∀ i, Q i) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + KX1 (Sigma Q) →+ OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := by + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + exact (separatedIndexFamily o).assembly + +@[simp] theorem separatedCoarseAssembly_of (o : ∀ i, Q i) (n : ℕ) + (a : letI := separatedMetric o; LocallyFiniteK1 (Point (Sigma Q) n)) : + letI := separatedMetric o + separatedCoarseAssembly o ((coarsening (Sigma Q)).of n a) = + separatedRipsIndex o n (Nat.cast_nonneg n) a := + by + exact Eq.trans ((separatedIndexFamily o).assembly_of n a) + (congrArg (fun f => f a) (separatedIndexFamily_atScale o n)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyBoundary.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..ee8563b6b3fd23838b9e08957c2e34df95345b6e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyBoundary.lean @@ -0,0 +1,72 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.DiagonalFamilyDefect +import OAI.Topology.CoarseAssembly.SeparatedRips +import OAI.Topology.CoarseAssembly.MultiplierBoundaryClass +import OAI.Topology.CoarseAssembly.UnitalStructureAlgebra + +namespace OAI + +/-! # A Roe boundary class from a uniformly controlled separated family + +The compact component defects need not decay in norm. Their direct sum is +nevertheless a finite-propagation operator with compact matrix entries, +which is the local compactness needed for the whole-union Roe algebra. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [∀ i, DecidableEq (V i)] in +theorem separatedMetric_closedBall_finite (o : ∀ i, V i) (x : Sigma V) (r : ℝ) : + letI := separatedMetric o + (Metric.closedBall x r).Finite := by + let := separatedMetric o + simpa only [Metric.closedBall, dist_comm] using separated_closedBall_finite o x r + +variable (o : ∀ i, V i) (A : ∀ i, Operator (V i) H) + (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) + (r : ℝ) (hr : 0 ≤ r) (hp : ∀ i, PropagationLE r (A i)) + +include o r hr hp in +theorem diagonalFamily_square_mem_roe (hself : ∀ i, IsSelfAdjoint (A i)) + (hsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) : + letI := separatedMetric o + (diagonalFamily A C hC hA) ^ 2 - 1 ∈ algebra (X := Sigma V) (H := H) := by + let := separatedMetric o + have hT := diagonalFamily_propagation o A C hC hA r hp + have hdef : PropagationLE (r + r) (diagonalFamily A C hC hA ^ 2 - 1) := by + have hm := hT.mul (separatedMetric_closedBall_finite o) hT + have hn := (propagationLE_one (X := Sigma V) (H := H)).smul (-1 : ℂ) + have hh := hm.add hn + have he : (-1 : ℂ) • (1 : Operator (Sigma V) H) = -(1 : Operator (Sigma V) H) := by + ext v + simp + rw [he] at hh + simpa only [pow_two, sub_eq_add_neg, + max_eq_left (add_nonneg hr hr)] using hh + have hc : CompactEntries (diagonalFamily A C hC hA ^ 2 - 1) := by + simpa only [pow_two] using diagonalFamily_square_compactEntries A C hC hA hsq + have hs : IsSelfAdjoint (diagonalFamily A C hC hA ^ 2 - 1) := by + have hs' := (diagonalFamily_selfAdjoint A C hC hA hself).pow 2 + have hi : IsSelfAdjoint (1 : Operator (Sigma V) H) := IsSelfAdjoint.one _ + exact @IsSelfAdjoint.sub (Operator (Sigma V) H) inferInstance inferInstance _ _ hs' hi + exact generator_mem ⟨⟨r + r, add_nonneg hr hr, hdef⟩, hc, by rwa [hs.star_eq]⟩ + +include o r hr hp in +theorem separatedFamilyMultiplier_selfAdjoint (hself : ∀ i, IsSelfAdjoint (A i)) : + letI := separatedMetric o + IsSelfAdjoint (separatedFamilyMultiplier o A C hC hA r hr hp) := by + let := separatedMetric o + apply Subtype.ext + exact (diagonalFamily_selfAdjoint A C hC hA hself).star_eq + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..ff30a8f24f3bbad823563032f5276253e2fcdbc3 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyHomotopy.lean @@ -0,0 +1,42 @@ +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary +import OAI.Topology.CoarseAssembly.DiagonalFamilyContinuity +import OAI.Topology.CoarseAssembly.MultiplierBoundaryHomotopy + +namespace OAI + +/-! # Whole-union boundary classes under uniform family homotopies -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +open Analytic Filter Topology + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem separatedFamilyBoundary_homotopy (o : ∀ i, V i) + (A : Interval → ∀ i, Operator (V i) H) (C : ℝ) (hC : 0 ≤ C) + (hA : ∀ t i, ‖A t i‖ ≤ C) (r : ℝ) (hr : 0 ≤ r) + (hp : ∀ t i, PropagationLE r (A t i)) + (hself : ∀ t i, IsSelfAdjoint (A t i)) + (hsq : ∀ t i, IsCompactOperator (A t i * A t i - (1 : Operator (V i) H))) + (hcont : ∀ t ε, 0 < ε → ∀ᶠ s in 𝓝 t, ∀ i, ‖A s i - A t i‖ ≤ ε) : + letI := separatedMetric o + separatedFamilyBoundary o (A start) C hC (hA start) r hr (hp start) + (hself start) (hsq start) = + separatedFamilyBoundary o (A finish) C hC (hA finish) r hr (hp finish) + (hself finish) (hsq finish) := by + let := separatedMetric o + exact multiplierBoundaryClass_homotopy + (fun t => separatedFamilyMultiplier o (A t) C hC (hA t) r hr (hp t)) + (fun t => separatedFamilyMultiplier_selfAdjoint o (A t) C hC (hA t) r hr (hp t) (hself t)) + (fun t => diagonalFamily_square_mem_roe o (A t) C hC (hA t) r hr (hp t) (hself t) (hsq t)) + ((continuous_diagonalFamily A C hC hA hcont).subtype_mk _) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyInclusion.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyInclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..7049ab912d9033d4860650a638dec21f7a8cdf56 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyInclusion.lean @@ -0,0 +1,63 @@ +import OAI.Topology.CoarseAssembly.ComponentHilbertInclusion +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary +import OAI.Topology.CoarseAssembly.SpatialBoundaryNaturality + +namespace OAI + +/-! # Whole-union boundary naturality for component-preserving inclusions -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q P : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + [∀ i, Fintype (Q i)] [∀ i, Fintype (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] + {H : Type} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem separatedFamilyBoundary_inclusion (o : ∀ i, Q i) (p : ∀ i, P i) + (e : ∀ i, Q i ↪ P i) + (he : letI := separatedMetric o; letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y) + (A : ∀ i, Operator (Q i) H) (B : ∀ i, Operator (P i) H) + (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (B i)) + (hAs : ∀ i, IsSelfAdjoint (A i)) (hBs : ∀ i, IsSelfAdjoint (B i)) + (hAsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) H))) + (hBsq : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (P i) H))) + (hAB : ∀ i, B i = isometricExtension (inclusionIsometry (e i)) (A i)) : + letI := separatedMetric o + letI := separatedMetric p + OperatorKTheory.map (inclusionHom (X := Sigma Q) (Y := Sigma P) (H := H) (componentEmbedding e) he) + (separatedFamilyBoundary o A C hC hA r hr hp hAs hAsq) = + separatedFamilyBoundary p B D hD hB s hs hq hBs hBsq := by + let := separatedMetric o + let := separatedMetric p + let F := separatedFamilyMultiplier o A C hC hA r hr hp + let G := separatedFamilyMultiplier p B D hD hB s hs hq + have hFs := separatedFamilyMultiplier_selfAdjoint o A C hC hA r hr hp hAs + have hGs := separatedFamilyMultiplier_selfAdjoint p B D hD hB s hs hq hBs + have hGF : G.val = isometricExtension (inclusionIsometry (componentEmbedding e)) F.val := by + apply ContinuousLinearMap.ext + intro v + apply lp.ext + funext z + rcases z with ⟨i, x⟩ + have hh := congrArg (fun w : Module (P i) H => w x) + (row_isometricExtension e (diagonalFamily A C hC hA) A + (fun w j => rowVector_diagonalFamily A C hC hA w j) v i) + change B i (rowVector v i) x = _ + rw [hAB i] + exact hh.symm + exact multiplierBoundaryClass_spatial (inclusionIsometry (componentEmbedding e)) + (inclusion_mapsToRoe (componentEmbedding e) he) F hFs + (diagonalFamily_square_mem_roe o A C hC hA r hr hp hAs hAsq) G hGs + (diagonalFamily_square_mem_roe p B D hD hB s hs hq hBs hBsq) hGF + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyNearby.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyNearby.lean new file mode 100644 index 0000000000000000000000000000000000000000..c8f33557101d616ce40c933e5516b9f42516485e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyNearby.lean @@ -0,0 +1,46 @@ +import OAI.Topology.CoarseAssembly.MultiplierBoundaryNearby +import OAI.Topology.CoarseAssembly.DiagonalFamilyContinuity +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary + +namespace OAI + +/-! # A uniform small perturbation preserves the whole-union boundary + +The difference need not be compact. The argument uses the short invertible +path in the actual Roe unitization, with no componentwise K-theory inference. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +theorem separatedFamilyBoundary_eq_of_nearby (o : ∀ i, Q i) + (A B : ∀ i, Operator (Q i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r : ℝ) (hr : 0 ≤ r) (hpA : ∀ i, PropagationLE r (A i)) + (hpB : ∀ i, PropagationLE r (B i)) + (hsA : ∀ i, IsSelfAdjoint (A i)) (hsB : ∀ i, IsSelfAdjoint (B i)) + (hqA : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (Q i) H))) + (hqB : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (Q i) H))) + (δ : ℝ) (hδ : 0 ≤ δ) (hδsmall : δ < 1 / 4) + (hnear : ∀ i, ‖B i - A i‖ ≤ δ) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hpA hsA hqA = + separatedFamilyBoundary o B D hD hB r hr hpB hsB hqB := by + let := separatedMetric o + apply multiplierBoundaryClass_eq_of_nearby _ _ + (separatedFamilyMultiplier_selfAdjoint o A C hC hA r hr hpA hsA) + (separatedFamilyMultiplier_selfAdjoint o B D hD hB r hr hpB hsB) + (diagonalFamily_square_mem_roe o A C hC hA r hr hpA hsA hqA) + (diagonalFamily_square_mem_roe o B D hD hB r hr hpB hsB hqB) + exact (diagonalFamily_sub_norm_le B A D C hD hC hB hA δ hδ hnear).trans_lt hδsmall + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyPerturbation.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyPerturbation.lean new file mode 100644 index 0000000000000000000000000000000000000000..48203d8d752dd5ce6c25ce54aee9bd8ba9e9df5f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedFamilyPerturbation.lean @@ -0,0 +1,88 @@ +import OAI.Topology.CoarseAssembly.SeparatedFamilyBoundary +import OAI.Topology.CoarseAssembly.DiagonalFamilyContinuity +import OAI.Topology.CoarseAssembly.BoundaryRoePerturbation + +namespace OAI + +/-! # Compact changes on components give Roe perturbations on the whole union -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + [∀ i, DecidableEq (V i)] {H : Type*} + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +omit [∀ i, Fintype (V i)] in +theorem diagonalFamily_sub_mem_roe (o : ∀ i, V i) + (A B : ∀ i, Operator (V i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (_hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (B i)) + (hAs : ∀ i, IsSelfAdjoint (A i)) (hBs : ∀ i, IsSelfAdjoint (B i)) + (hAB : ∀ i, IsCompactOperator (A i - B i)) : + letI := separatedMetric o + diagonalFamily A C hC hA - diagonalFamily B D hD hB ∈ algebra (X := Sigma V) (H := H) := by + let := separatedMetric o + have hn : ∀ i, ‖A i - B i‖ ≤ C + D := fun i => + (norm_sub_le _ _).trans (add_le_add (hA i) (hB i)) + rw [diagonalFamily_sub_eq A B C D hC hD hA hB (C + D) (add_nonneg hC hD) hn] + let Q := diagonalFamily (fun i => A i - B i) (C + D) (add_nonneg hC hD) hn + have hQp : PropagationLE (max r s) Q := by + apply diagonalFamily_propagation o + intro i + have hneg : PropagationLE s (-B i) := by + convert (hq i).smul (-1 : ℂ) using 1 + ext v + simp + simpa only [sub_eq_add_neg] using (hp i).add hneg + have hQc : CompactEntries Q := by + rintro ⟨i, x⟩ ⟨j, y⟩ + by_cases hij : i = j + · subst j + rw [entry_diagonalFamily_same] + exact compact_entries_of_compact (hAB i) x y + · rw [entry_diagonalFamily_ne _ _ _ _ hij] + exact isCompactOperator_zero + have hQs : IsSelfAdjoint Q := + diagonalFamily_selfAdjoint _ _ _ _ (fun i => + @IsSelfAdjoint.sub (Operator (V i) H) inferInstance inferInstance _ _ (hAs i) (hBs i)) + exact generator_mem ⟨⟨max r s, le_trans hr (le_max_left _ _), hQp⟩, hQc, + by rwa [hQs.star_eq]⟩ + +/-- Componentwise compact changes preserve the whole-union class, even when +these compact operators do not tend to zero in norm. -/ +theorem separatedFamilyBoundary_eq_of_component_compact (o : ∀ i, V i) + (A B : ∀ i, Operator (V i) H) (C D : ℝ) (hC : 0 ≤ C) (hD : 0 ≤ D) + (hA : ∀ i, ‖A i‖ ≤ C) (hB : ∀ i, ‖B i‖ ≤ D) + (r s : ℝ) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hp : ∀ i, PropagationLE r (A i)) (hq : ∀ i, PropagationLE s (B i)) + (hAs : ∀ i, IsSelfAdjoint (A i)) (hBs : ∀ i, IsSelfAdjoint (B i)) + (hAsq : ∀ i, IsCompactOperator (A i * A i - (1 : Operator (V i) H))) + (hBsq : ∀ i, IsCompactOperator (B i * B i - (1 : Operator (V i) H))) + (hAB : ∀ i, IsCompactOperator (A i - B i)) : + letI := separatedMetric o + separatedFamilyBoundary o A C hC hA r hr hp hAs hAsq = + separatedFamilyBoundary o B D hD hB s hs hq hBs hBsq := by + let := separatedMetric o + have hdiff := diagonalFamily_sub_mem_roe o A B C D hC hD hA hB r s hr hs hp hq hAs hBs hAB + have hrev : diagonalFamily B D hD hB - diagonalFamily A C hC hA ∈ + algebra (X := Sigma V) (H := H) := by + have he : diagonalFamily B D hD hB - diagonalFamily A C hC hA = + -(diagonalFamily A C hC hA - diagonalFamily B D hD hB) := by abel + rw [he] + exact (algebra (X := Sigma V) (H := H)).neg_mem hdiff + exact multiplierBoundaryClass_roePerturbation + (separatedFamilyMultiplier o A C hC hA r hr hp) + (separatedFamilyMultiplier o B D hD hB s hs hq) + (separatedFamilyMultiplier_selfAdjoint o A C hC hA r hr hp hAs) + (separatedFamilyMultiplier_selfAdjoint o B D hD hB s hs hq hBs) + (diagonalFamily_square_mem_roe o A C hC hA r hr hp hAs hAsq) + (diagonalFamily_square_mem_roe o B D hD hB s hs hq hBs hBsq) hrev + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedGeometry.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..185c1707b2e5aa225097f90e4c51b5347fdbdf10 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedGeometry.lean @@ -0,0 +1,98 @@ +import OAI.Topology.CoarseAssembly.SeparatedUnion +import OAI.Topology.CoarseAssembly.TransferCriterion +import Mathlib.Data.Finset.Sigma + +namespace OAI + +/-! # Bounded geometry of the separated union + +Uniform component ball bounds pass to the union. All cross-component pairs +in a fixed distance range lie in a finite prefix, which also supplies the +finite exceptional set in the transfer argument. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {V : ℕ → Type*} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)] + +def componentPrefix (N : ℕ) : Finset (Sigma V) := + (Finset.range (N + 1)).sigma (fun _ => Finset.univ) + +omit [∀ i, MetricSpace (V i)] in +@[simp] theorem mem_componentPrefix (N : ℕ) (x : Sigma V) : + x ∈ componentPrefix N ↔ x.1 ≤ N := by + classical + simp only [componentPrefix, Finset.mem_sigma, Finset.mem_range, Finset.mem_univ, and_true, + Nat.lt_succ_iff] + +theorem finite_cross_pairs (o : ∀ i, V i) (R : ℝ) : + {p : Sigma V × Sigma V | p.1.1 ≠ p.2.1 ∧ separatedDist o p.1 p.2 ≤ R}.Finite := by + apply ((componentPrefix (V := V) ⌈R⌉₊).finite_toSet.prod + (componentPrefix (V := V) ⌈R⌉₊).finite_toSet).subset + intro p hp + obtain ⟨hx, hy⟩ := separatedDist_indices o p.1 p.2 hp.1 hp.2 + have hR : R ≤ (⌈R⌉₊ : ℝ) := Nat.le_ceil R + exact ⟨(mem_componentPrefix _ _).mpr (by exact_mod_cast hx.trans hR), + (mem_componentPrefix _ _).mpr (by exact_mod_cast hy.trans hR)⟩ + +/-- The bounded-geometry hypothesis needed by the Roe transfer is preserved +by this separated union. -/ +theorem separated_uniform_finite_balls (o : ∀ i, V i) + (hcomp : ∀ R : ℝ, 0 ≤ R → ∃ N : ℕ, ∀ i (x : V i), ∃ b : Finset (V i), + (∀ y, y ∈ b ↔ dist x y ≤ R) ∧ b.card ≤ N) : + @UniformFiniteBalls (Sigma V) (separatedMetric o).toPseudoMetricSpace := by + classical + let := separatedMetric o + intro R hR + obtain ⟨N, hN⟩ := hcomp R hR + refine ⟨N + (componentPrefix (V := V) ⌈R⌉₊).card, ?_⟩ + rintro ⟨i, x⟩ + obtain ⟨b, hb, hcard⟩ := hN i x + let emb : V i ↪ Sigma V := ⟨Sigma.mk i, fun _ _ h => by simpa using h⟩ + let c := b.map emb ∪ componentPrefix (V := V) ⌈R⌉₊ + refine ⟨c.filter (fun y => dist (⟨i, x⟩ : Sigma V) y ≤ R), ?_, ?_⟩ + · intro y + simp only [Finset.mem_filter] + refine ⟨fun h => h.2, fun hy => ⟨?_, hy⟩⟩ + rcases y with ⟨j, y⟩ + by_cases hij : i = j + · subst j + apply Finset.mem_union_left + apply Finset.mem_map.mpr + refine ⟨y, (hb y).mpr ?_, rfl⟩ + change separatedDist o ⟨i, x⟩ ⟨i, y⟩ ≤ R at hy + simpa only [separatedDist_same] using hy + · apply Finset.mem_union_right + apply (mem_componentPrefix _ _).mpr + have hi := (separatedDist_indices o ⟨i, x⟩ ⟨j, y⟩ hij hy).2 + exact_mod_cast hi.trans (Nat.le_ceil R) + · calc + _ ≤ c.card := Finset.card_filter_le _ _ + _ ≤ (b.map emb).card + (componentPrefix (V := V) ⌈R⌉₊).card := Finset.card_union_le _ _ + _ ≤ N + (componentPrefix (V := V) ⌈R⌉₊).card := by + rw [Finset.card_map] + exact Nat.add_le_add_right hcard _ + +omit [∀ i, Fintype (V i)] in +/-- Unit separation in each component gives unit separation in the union. -/ +theorem separated_uniform_discrete (o : ∀ i, V i) + (hcomp : ∀ i (x y : V i), x ≠ y → 1 ≤ dist x y) + (x y : Sigma V) (hxy : x ≠ y) : 1 ≤ separatedDist o x y := by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + by_cases hij : i = j + · subst j + rw [separatedDist_same] + exact hcomp i x y (fun h => hxy (congrArg (Sigma.mk i) h)) + · rw [separatedDist_different o hij] + have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedIndexCoarsening.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedIndexCoarsening.lean new file mode 100644 index 0000000000000000000000000000000000000000..315b558feee4ec5bb2e06070c29bf66a6353418f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedIndexCoarsening.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.LateRipsCoarsening +import OAI.Topology.CoarseAssembly.RegularizedCoarsening +import OAI.Topology.CoarseAssembly.RipsFiniteTail + +namespace OAI + +/-! # Coarsening compatibility of the index on the full analytic domain -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe +open scoped ZeroAtInfty + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r s : ℝ} + +omit [∀ i, Fintype (Q i)] [∀ i, DecidableEq (Q i)] in +theorem ripsPointCharacter_coarsen (o : ∀ i, Q i) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hrs : r ≤ s) (i : ℕ) : + ripsPointCharacter o s hs i = (ripsPointCharacter o r hr i).comp (scaleFunctionHom hrs) := by + ext f + change f (vertex (o i) hs) = f (coarsen hrs (vertex (o i) hr)) + rfl + +omit [∀ i, DecidableEq (Q i)] in +theorem late_regularizedCycle_coarsen (o : ∀ i, Q i) (hr : 0 ≤ r) (hs : 0 ≤ s) + (hrs : r ≤ s) (c : letI := separatedMetric o; OddCycle C₀(Point (Sigma Q) r, ℂ)) + (i : ℕ) (hi : s < i) : + letI := separatedMetric o + ((c.precomp (pullback (inclusion hrs))).precomp (lateRipsFunctionHom o s i)).regularize + (ripsPointCharacter o s hs i) = + coarsenedCycle hrs ((c.precomp (lateRipsFunctionHom o r i)).regularize + (ripsPointCharacter o r hr i)) := by + let := separatedMetric o + have hp : (c.precomp (pullback (inclusion hrs))).precomp (lateRipsFunctionHom o s i) = + (c.precomp (lateRipsFunctionHom o r i)).precomp (scaleFunctionHom hrs).toNonUnitalStarAlgHom := + congrArg (fun η => c.precomp η) (lateRipsFunctionHom_coarsen o hrs i hi) + rw [hp, ripsPointCharacter_coarsen o hr hs hrs i] + exact (c.precomp (lateRipsFunctionHom o r i)).regularize_precomp_eq + (scaleFunctionHom hrs) (ripsPointCharacter o r hr i) + +theorem ampleRipsOperator_congr {X : Type} [MetricSpace X] [Fintype X] [DecidableEq X] + (r : ℝ) (c d : OddCycle C(Point X r, ℂ)) (h : c = d) + (hc : c.representation 1 = 1) (hd : d.representation 1 = 1) : + ampleRipsOperator r c hc = ampleRipsOperator r d hd := by + subst d + rfl + +theorem separatedRipsIndex_coarsen (o : ∀ i, Q i) (hr : 0 ≤ r) (hs : 0 ≤ s) (hrs : r ≤ s) : + letI := separatedMetric o + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + (separatedRipsIndex o s hs).comp (pushforward (inclusion (X := Sigma Q) hrs)) = + separatedRipsIndex o r hr := by + let := separatedMetric o + let : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + apply Analytic.hom_ext + intro c + let C := regularizedFamily (fun i => c.precomp (lateRipsFunctionHom o r i)) + (ripsPointCharacter o r hr) + let D := regularizedFamily + (fun i => (c.precomp (pullback (inclusion hrs))).precomp (lateRipsFunctionHom o s i)) + (ripsPointCharacter o s hs) + let J : Finset ℕ := Finset.range (Nat.ceil s + 1) + have ht := D.boundary_eq_of_tail (C.coarsen hrs) o hs hs J (by + intro i hi + have hni : Nat.ceil s < i := Nat.lt_of_succ_le (Nat.le_of_not_lt (by + simpa only [J, Finset.mem_range] using hi)) + have hil : s < i := (Nat.le_ceil s).trans_lt (by exact_mod_cast hni) + exact ampleRipsOperator_congr s _ _ (late_regularizedCycle_coarsen o hr hs hrs c i hil) _ _) + have hbd : D.boundary o hs = C.boundary o hr := + ht.trans (ampleRipsFamilyBoundary_scale hrs o hr hs C.cycle C.unital C.selfAdjoint + C.bound C.bound_nonneg C.norm_le) + have hp := congrArg (separatedRipsIndex o s hs) + (Analytic.precomp_cycleClass (pullback (inclusion (X := Sigma Q) hrs)) c) + exact hp.trans ((separatedRipsIndex_class o s hs (c.precomp (pullback (inclusion hrs)))).trans + (hbd.trans (separatedRipsIndex_class o r hr c).symm)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedIndexNaturality.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedIndexNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..2362a2d323561143842d8537209ab07119432201 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedIndexNaturality.lean @@ -0,0 +1,111 @@ +import OAI.Topology.CoarseAssembly.ComponentRestrictionNaturality +import OAI.Topology.CoarseAssembly.RipsFamilyInclusion +import OAI.Topology.CoarseAssembly.SeparatedIndexCoarsening + +namespace OAI + +/-! # Geometric naturality on the actual locally finite analytic domain -/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe +open scoped ZeroAtInfty + +variable {Q P : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, MetricSpace (P i)] + [∀ i, Fintype (Q i)] [∀ i, Fintype (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] {r : ℝ} + +omit [∀ i, Fintype (Q i)] [∀ i, Fintype (P i)] + [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] in +theorem ripsPointCharacter_included (o : ∀ i, Q i) (p : ∀ i, P i) (hr : 0 ≤ r) + (e : ∀ i, Q i ↪ P i) (hei : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) + (hroot : ∀ i, e i (o i) = p i) (i : ℕ) : + ripsPointCharacter p r hr i = + (ripsPointCharacter o r hr i).comp (inclusionFunctionHom r (e i) (hei i)) := by + ext f + change f (vertex (p i) hr) = f (mapPoint (e i) (hei i) (vertex (o i) hr)) + rw [mapPoint_vertex, hroot i] + +omit [∀ i, DecidableEq (Q i)] [∀ i, DecidableEq (P i)] in +theorem late_regularizedCycle_included (o : ∀ i, Q i) (p : ∀ i, P i) (hr : 0 ≤ r) + (e : ∀ i, Q i ↪ P i) (hei : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) + (hroot : ∀ i, e i (o i) = p i) + (he : letI := separatedMetric o; letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y) + (c : letI := separatedMetric o; OddCycle C₀(Point (Sigma Q) r, ℂ)) (i : ℕ) (hi : r < i) : + letI := separatedMetric o + letI := separatedMetric p + ((c.precomp (pullback (embeddingMap (componentEmbedding e) he r))).precomp + (lateRipsFunctionHom p r i)).regularize (ripsPointCharacter p r hr i) = + includedCycle r (e i) (hei i) + ((c.precomp (lateRipsFunctionHom o r i)).regularize (ripsPointCharacter o r hr i)) := by + let := separatedMetric o + let := separatedMetric p + have hp : (c.precomp (pullback (embeddingMap (componentEmbedding e) he r))).precomp + (lateRipsFunctionHom p r i) = + (c.precomp (lateRipsFunctionHom o r i)).precomp + (inclusionFunctionHom r (e i) (hei i)).toNonUnitalStarAlgHom := + congrArg (fun η => c.precomp η) (lateRipsFunctionHom_inclusion o p e hei he r i hi) + rw [hp, ripsPointCharacter_included o p hr e hei hroot i] + exact (c.precomp (lateRipsFunctionHom o r i)).regularize_precomp_eq + (inclusionFunctionHom r (e i) (hei i)) (ripsPointCharacter o r hr i) + +private theorem ampleRipsOperator_eq_of_cycle_eq {X : Type} [MetricSpace X] [Fintype X] [DecidableEq X] + (r : ℝ) (c d : OddCycle C(Point X r, ℂ)) (h : c = d) + (hc : c.representation 1 = 1) (hd : d.representation 1 = 1) : + ampleRipsOperator r c hc = ampleRipsOperator r d hd := by + subst d + rfl + +theorem separatedRipsIndex_inclusion (o : ∀ i, Q i) (p : ∀ i, P i) (hr : 0 ≤ r) + (e : ∀ i, Q i ↪ P i) (hei : ∀ i x y, dist (e i x) (e i y) ≤ dist x y) + (hroot : ∀ i, e i (o i) = p i) + (he : letI := separatedMetric o; letI := separatedMetric p + ∀ x y, dist (componentEmbedding e x) (componentEmbedding e y) ≤ dist x y) : + letI := separatedMetric o + letI := separatedMetric p + letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + letI : Ring (Unitization ℂ (algebra (X := Sigma P) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + (separatedRipsIndex p r hr).comp (pushforward (embeddingMap (componentEmbedding e) he r)) = + (OperatorKTheory.map (inclusionHom (X := Sigma Q) (Y := Sigma P) (H := lp (fun _ : ℕ => ℂ) 2) + (componentEmbedding e) he)).comp (separatedRipsIndex o r hr) := by + let := separatedMetric o + let := separatedMetric p + let : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + let : Ring (Unitization ℂ (algebra (X := Sigma P) (H := lp (fun _ : ℕ => ℂ) 2))) := + inferInstance + apply Analytic.hom_ext + intro c + let K := OperatorKTheory.map (inclusionHom (X := Sigma Q) (Y := Sigma P) (H := lp (fun _ : ℕ => ℂ) 2) + (componentEmbedding e) he) + let C := regularizedFamily (fun i => c.precomp (lateRipsFunctionHom o r i)) (ripsPointCharacter o r hr) + let D := regularizedFamily + (fun i => (c.precomp (pullback (embeddingMap (componentEmbedding e) he r))).precomp + (lateRipsFunctionHom p r i)) (ripsPointCharacter p r hr) + let J : Finset ℕ := Finset.range (Nat.ceil r + 1) + have ht := D.boundary_eq_of_tail (C.included e hei) p hr hr J (by + intro i hi + have hni : Nat.ceil r < i := Nat.lt_of_succ_le (Nat.le_of_not_lt (by + simpa only [J, Finset.mem_range] using hi)) + have hil : r < i := (Nat.le_ceil r).trans_lt (by exact_mod_cast hni) + exact ampleRipsOperator_eq_of_cycle_eq r _ _ + (late_regularizedCycle_included o p hr e hei hroot he c i hil) _ _) + have hbd : D.boundary p hr = K (C.boundary o hr) := + ht.trans (C.boundary_included o p hr e hei he).symm + have hp := congrArg (separatedRipsIndex p r hr) + (Analytic.precomp_cycleClass (pullback (embeddingMap (componentEmbedding e) he r)) c) + have hsource := congrArg K (separatedRipsIndex_class o r hr c) + exact hp.trans ((separatedRipsIndex_class p r hr + (c.precomp (pullback (embeddingMap (componentEmbedding e) he r)))).trans + (hbd.trans hsource.symm)) + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedRips.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedRips.lean new file mode 100644 index 0000000000000000000000000000000000000000..1692d90936e0c2b5823be6daf409a9101b0f8c38 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedRips.lean @@ -0,0 +1,81 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.RipsEmbedding +import OAI.Topology.CoarseAssembly.SeparatedUnion +import Mathlib.Algebra.Order.Floor.Semiring + +namespace OAI + +/-! # Late components are clopen at a fixed Rips scale + +This proves the topological component separation required for the changing +finite-component winding test in the actual separated coarse union. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Topology Rips + +variable {V : ℕ → Type} [∀ j, MetricSpace (V j)] + +theorem separatedComponent_isometry (o : ∀ j, V j) (j : ℕ) : + letI := separatedMetric o + Isometry (separatedComponent (V := V) j) := by + let := separatedMetric o + apply Isometry.of_dist_eq + intro x y + exact separatedDist_same o j x y + +theorem separatedComponent_separation (o : ∀ j, V j) (j : ℕ) (r : ℝ) (hj : r < j) : + letI := separatedMetric o + ∀ x y, y ∉ Set.range (separatedComponent (V := V) j) → + r < dist (separatedComponent j x) y := by + let := separatedMetric o + rintro x ⟨k, y⟩ hy + have hjk : j ≠ k := by + rintro rfl + exact hy ⟨y, rfl⟩ + change r < separatedDist o ⟨j, x⟩ ⟨k, y⟩ + rw [separatedDist_different o hjk] + have hk : (0 : ℝ) ≤ k := Nat.cast_nonneg k + linarith [dist_nonneg (x := x) (y := o j), dist_nonneg (x := o k) (y := y)] + +theorem separated_closedBall_finite [∀ j, Fintype (V j)] + (o : ∀ j, V j) (x : Sigma V) (r : ℝ) : + letI := separatedMetric o + Set.Finite {y : Sigma V | dist x y ≤ r} := by + classical + let := separatedMetric o + let m := max (x.1 + 1) (⌈r⌉₊ + 1) + let s : Finset (Sigma V) := (Finset.range m).sigma (fun _ => Finset.univ) + apply s.finite_toSet.subset + intro y hy + have hm : y.1 < m := by + by_cases hxy : x.1 = y.1 + · dsimp [m] + omega + · have hb := (separatedDist_indices o x y hxy hy).2 + have hc : y.1 ≤ ⌈r⌉₊ := by exact_mod_cast hb.trans (Nat.le_ceil r) + dsimp [m] + omega + exact Finset.mem_sigma.mpr ⟨Finset.mem_range.mpr hm, Finset.mem_univ _⟩ + +/-- The chosen late finite Rips component really is open and closed in +the global Rips realization; its inclusion is continuous and proper. -/ +theorem lateRipsComponent_openEmbedding [∀ j, Fintype (V j)] + (o : ∀ j, V j) (j : ℕ) (r : ℝ) (hj : r < j) : + letI := separatedMetric o + IsOpenEmbedding (mapPoint (r := r) (separatedComponent (V := V) j) + (fun x y => ((separatedComponent_isometry o j).dist_eq x y).le)) := by + let := separatedMetric o + exact + { toIsEmbedding := (mapPoint_closedEmbedding _ _).isEmbedding + isOpen_range := mapPoint_range_open _ (separatedComponent_isometry o j) + (separatedComponent_separation o j r hj) } + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedRipsIndex.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedRipsIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..8071b13e52b3b8d8b9a5e17272872fe0b34d4ecc --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedRipsIndex.lean @@ -0,0 +1,37 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.AnalyticFamilyIndex +import OAI.Topology.CoarseAssembly.RipsFamilyRestriction +import OAI.Topology.CoarseAssembly.CompactHomotopy + +namespace OAI + +/-! # A scale index on the actual locally finite analytic domain + +Late Rips components are compact and open in the full realization. Their +extension-by-zero homomorphisms give the restriction family used by the +constructed index. Finitely many early components are omitted; compatibility +of this omission across scales is proved separately. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe +open scoped ZeroAtInfty + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] + +@[simp] theorem separatedRipsIndex_class (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) + (c : letI := separatedMetric o; OddCycle C₀(Point (Sigma Q) r, ℂ)) : + separatedRipsIndex o r hr (cycleClass _ c) = + (regularizedFamily (fun i => c.precomp (lateRipsFunctionHom o r i)) + (ripsPointCharacter o r hr)).boundary o hr := + analyticFamilyIndex_class _ _ _ _ _ + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SeparatedUnion.lean b/lean/OAI/Topology/CoarseAssembly/SeparatedUnion.lean new file mode 100644 index 0000000000000000000000000000000000000000..298d44b75751c2780888b2084b6a23c93016aa50 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SeparatedUnion.lean @@ -0,0 +1,81 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Topology.MetricSpace.Basic +import Mathlib.Analysis.SpecialFunctions.Pow.Real +import Mathlib.Tactic.Linarith +import Mathlib.Tactic.Positivity + +namespace OAI + +/-! # A separated metric union + +Components embed isometrically. Paths between different components go +through chosen roots, with bridge length `i + j + 2`; thus bounded-distance +cross-component pairs lie in finitely many finite components. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {V : ℕ → Type*} [∀ i, MetricSpace (V i)] + +@[simp] theorem separatedDist_same (o : ∀ i, V i) (i : ℕ) (x y : V i) : + separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y := dite_eq_left rfl + +theorem separatedDist_different (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j) + (x : V i) (y : V j) : + separatedDist o ⟨i, x⟩ ⟨j, y⟩ = + dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y := dite_eq_right h + +theorem separatedDist_comm (o : ∀ i, V i) (x y : Sigma V) : + separatedDist o x y = separatedDist o y x := by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + by_cases h : i = j + · subst j; simp only [separatedDist_same, dist_comm] + · rw [separatedDist_different o h, separatedDist_different o (Ne.symm h)] + simp only [dist_comm y (o j), dist_comm (o i) x] + ring + +theorem separatedDist_triangle (o : ∀ i, V i) (x y z : Sigma V) : + separatedDist o x z ≤ separatedDist o x y + separatedDist o y z := by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + rcases z with ⟨k, z⟩ + by_cases hij : i = j + · subst j + by_cases hik : i = k + · subst k; simp only [separatedDist_same]; exact dist_triangle _ _ _ + · simp only [separatedDist_same, separatedDist_different o hik] + linarith [dist_triangle x y (o i)] + · by_cases hjk : j = k + · subst k + simp only [separatedDist_same, separatedDist_different o hij] + linarith [dist_triangle (o j) y z] + · by_cases hik : i = k + · subst k + simp only [separatedDist_same, separatedDist_different o hij, + separatedDist_different o (Ne.symm hij)] + have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + linarith [dist_triangle x (o i) z, dist_nonneg (x := y) (y := o j), + dist_nonneg (x := o j) (y := y)] + · simp only [separatedDist_different o hik, separatedDist_different o hij, + separatedDist_different o hjk] + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + linarith [dist_nonneg (x := y) (y := o j), dist_nonneg (x := o j) (y := y)] + +theorem separatedDist_indices (o : ∀ i, V i) (x y : Sigma V) (hxy : x.1 ≠ y.1) + {R : ℝ} (hR : separatedDist o x y ≤ R) : (x.1 : ℝ) ≤ R ∧ (y.1 : ℝ) ≤ R := by + rcases x with ⟨i, x⟩ + rcases y with ⟨j, y⟩ + rw [separatedDist_different o hxy] at hR + have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i + have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j + constructor <;> linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ShiftIndex.lean b/lean/OAI/Topology/CoarseAssembly/ShiftIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..6af920c4ed290cb058b9c34936aefb1ff4f25fe9 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ShiftIndex.lean @@ -0,0 +1,110 @@ +import OAI.Topology.CoarseAssembly.NegativeProjection + +namespace OAI + +/-! # The index-one compressed bilateral shift -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +def shiftToeplitz : End circleSequenceSpace := toeplitzCompression negativeProjection bilateralShift + +def shiftToeplitzInverse : End circleSequenceSpace := toeplitzCompression negativeProjection (star bilateralShift) + +theorem bilateralShift_star_apply (x : CircleSequence) (n : ℤ) : + star bilateralShift x n = x (n + 1) := by + have hs : star bilateralShift = (bilateralShiftEquiv.symm : CircleSequence →L[ℂ] CircleSequence) := + bilateralShiftEquiv.adjoint_eq_symm + rw [hs] + rfl + +theorem shiftToeplitz_apply (x : CircleSequence) (n : ℤ) : + shiftToeplitz x n = if n < 0 then x (n - 1) else x n := by + change negativeProjection (bilateralShift (negativeProjection x)) n + + (x n - negativeProjection x n) = _ + rw [negativeProjection_apply (bilateralShift (negativeProjection x)) n, + bilateralShift_apply (negativeProjection x) n, + negativeProjection_apply x (n - 1), negativeProjection_apply x n] + split_ifs <;> simp_all + all_goals omega + +theorem shiftToeplitzInverse_apply (x : CircleSequence) (n : ℤ) : + shiftToeplitzInverse x n = if n < 0 then (if n + 1 < 0 then x (n + 1) else 0) else x n := by + change negativeProjection (star bilateralShift (negativeProjection x)) n + + (x n - negativeProjection x n) = _ + rw [negativeProjection_apply (star bilateralShift (negativeProjection x)) n, + bilateralShift_star_apply (negativeProjection x) n, + negativeProjection_apply x (n + 1), negativeProjection_apply x n] + split_ifs <;> simp_all + +theorem shiftToeplitz_right_inverse : shiftToeplitz * shiftToeplitzInverse = 1 := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext n + change shiftToeplitz (shiftToeplitzInverse x) n = x n + rw [shiftToeplitz_apply (shiftToeplitzInverse x) n] + by_cases hn : n < 0 + · rw [ite_eq_left hn, shiftToeplitzInverse_apply x (n - 1), + ite_eq_left (by omega : n - 1 < 0), ite_eq_left (by omega : n - 1 + 1 < 0)] + rw [sub_add_cancel] + · rw [ite_eq_right hn, shiftToeplitzInverse_apply x n, ite_eq_right hn] + +theorem shiftToeplitz_surjective : Function.Surjective shiftToeplitz := by + intro x + refine ⟨shiftToeplitzInverse x, ?_⟩ + exact DFunLike.congr_fun shiftToeplitz_right_inverse x + +/-- The kernel is exactly the last negative Fourier coordinate. -/ +theorem shiftToeplitz_ker : shiftToeplitz.ker = + Submodule.span ℂ {lp.single 2 (-1 : ℤ) (1 : ℂ)} := by + apply le_antisymm + · intro x hx + have hz : shiftToeplitz x = 0 := hx + apply Submodule.mem_span_singleton.mpr + refine ⟨x (-1), ?_⟩ + apply lp.ext + funext n + by_cases hn : n = -1 + · subst n + simp only [lp.coeFn_smul, Pi.smul_apply, lp.single_apply_self, smul_eq_mul, mul_one] + · have hx0 : x n = 0 := by + by_cases hneg : n < 0 + · have hnn : n + 1 < 0 := by omega + have h := congrArg (fun y : CircleSequence => y (n + 1)) hz + rw [shiftToeplitz_apply x (n + 1), ite_eq_left hnn] at h + simpa only [add_sub_cancel_right, lp.coeFn_zero, Pi.zero_apply] using h + · have h := congrArg (fun y : CircleSequence => y n) hz + rw [shiftToeplitz_apply x n, ite_eq_right hneg] at h + exact h + simp only [lp.coeFn_smul, Pi.smul_apply, lp.single_apply_ne (E := fun _ : ℤ => ℂ) 2 (-1 : ℤ) (1 : ℂ) hn, + smul_zero, hx0] + · apply Submodule.span_le.mpr + intro x hx + rcases Set.mem_singleton_iff.mp hx with rfl + change shiftToeplitz (lp.single 2 (-1 : ℤ) (1 : ℂ)) = 0 + apply lp.ext + funext n + rw [shiftToeplitz_apply] + split_ifs with hn + · exact lp.single_apply_ne (E := fun _ : ℤ => ℂ) 2 (-1 : ℤ) (1 : ℂ) (by omega) + · exact lp.single_apply_ne (E := fun _ : ℤ => ℂ) 2 (-1 : ℤ) (1 : ℂ) (by omega) + +theorem shiftToeplitz_index : shiftToeplitz.toLinearMap.index = 1 := by + have he : (lp.single 2 (-1 : ℤ) (1 : ℂ) : CircleSequence) ≠ 0 := by + intro h + have h' := congrArg (fun x : CircleSequence => x (-1)) h + have hzero : (1 : ℂ) = 0 := by + simpa only [lp.single_apply_self, lp.coeFn_zero, Pi.zero_apply] using h' + exact one_ne_zero hzero + rw [LinearMap.index_eq_finrank_sub, shiftToeplitz_ker, + LinearMap.range_eq_top.mpr shiftToeplitz_surjective] + simp only [finrank_span_singleton he, Module.finrank_zero_of_subsingleton, Nat.cast_one, + Nat.cast_zero, sub_zero] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ShortLoops.lean b/lean/OAI/Topology/CoarseAssembly/ShortLoops.lean new file mode 100644 index 0000000000000000000000000000000000000000..173bb6446452bc11e3bafe07d0e463b21da41ff7 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ShortLoops.lean @@ -0,0 +1,173 @@ +import Mathlib.Combinatorics.SimpleGraph.Metric +import Mathlib.Tactic.Linarith + +namespace OAI + +/-! +# Short loops and the Rips edge cocycle + +The combinatorial step in §4 of the coarse Novikov manuscript. The only +hypothesis on the charge is vanishing on short closed graph walks, exactly +the output required from the manuscript's small-loop lemma. This is a +conditional combinatorial result, not an assumption about analytic K-homology. +-/ + +namespace CoarseAssembly + +variable {V : Type*} {G : SimpleGraph V} + +/-- Sum an integer edge charge along an actual graph walk. -/ +def walkCharge (a : V → V → ℤ) : {u v : V} → G.Walk u v → ℤ + | _, _, .nil => 0 + | u, _, .cons (v := v) _ p => a u v + walkCharge a p + +@[simp] theorem walkCharge_nil (a : V → V → ℤ) (u : V) : + walkCharge a (.nil : G.Walk u u) = 0 := rfl + +@[simp] theorem walkCharge_cons (a : V → V → ℤ) {u v w : V} + (h : G.Adj u v) (p : G.Walk v w) : + walkCharge a (.cons h p) = a u v + walkCharge a p := rfl + +@[simp] theorem walkCharge_append (a : V → V → ℤ) {u v w : V} + (p : G.Walk u v) (q : G.Walk v w) : + walkCharge a (p.append q) = walkCharge a p + walkCharge a q := by + induction p with + | nil => simp + | cons h p ih => simp [ih, add_assoc] + +@[simp] theorem walkCharge_reverse (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → a v u = -a u v) {u v : V} (p : G.Walk u v) : + walkCharge a p.reverse = -walkCharge a p := by + induction p with + | nil => simp + | cons h p ih => simp [SimpleGraph.Walk.reverse_cons, ih, ha _ _ h] + +/-- Pointwise unit charges give the elementary length bound used to control +both the winding number and the word length in the small-loop argument. -/ +theorem walkCharge_abs_le_length (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → |a u v| ≤ 1) {u v : V} (p : G.Walk u v) : + |walkCharge a p| ≤ (p.length : ℤ) := by + induction p with + | nil => simp + | cons h p ih => + calc + |walkCharge a (.cons h p)| ≤ |a _ _| + |walkCharge a p| := abs_add_le _ _ + _ ≤ 1 + (p.length : ℤ) := add_le_add (ha _ _ h) ih + _ = ((SimpleGraph.Walk.cons h p).length : ℤ) := by simp [add_comm] + +/-- Vanishing short loops makes the charge independent of the chosen short +path. The two paths are compared by concatenating one with the reverse of +the other, exactly as in Proposition 4.1. -/ +theorem walkCharge_eq_of_short_loops (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → a v u = -a u v) (r : ℕ) + (hloop : ∀ u (p : G.Walk u u), p.length ≤ 2 * r → walkCharge a p = 0) + {u v : V} (p q : G.Walk u v) (hp : p.length ≤ r) (hq : q.length ≤ r) : + walkCharge a p = walkCharge a q := by + have hlen : (p.append q.reverse).length ≤ 2 * r := by + simp only [SimpleGraph.Walk.length_append, SimpleGraph.Walk.length_reverse] + omega + have hz := hloop u (p.append q.reverse) hlen + rw [walkCharge_append, walkCharge_reverse a ha] at hz + exact eq_of_sub_eq_zero (by simpa only [sub_eq_add_neg] using hz) + +/-- The graph of the edges of the Rips complex of a connected graph at scale +`r`. Connectedness is supplied to results, because graph distance is zero +between disconnected vertices in Mathlib's natural-valued convention. -/ +def ripsGraph (G : SimpleGraph V) (r : ℕ) : SimpleGraph V where + Adj u v := u ≠ v ∧ G.dist u v ≤ r + symm := ⟨fun u v h => ⟨h.1.symm, (G.dist_comm (u := u) (v := v)) ▸ h.2⟩⟩ + loopless := ⟨fun _ h => h.1 rfl⟩ + +noncomputable def shortestWalk (hG : G.Connected) (u v : V) : G.Walk u v := + (hG.exists_walk_length_eq_dist u v).choose + +@[simp] theorem shortestWalk_length (hG : G.Connected) (u v : V) : + (shortestWalk hG u v).length = G.dist u v := + (hG.exists_walk_length_eq_dist u v).choose_spec + +/-- The charge assigned to an oriented Rips edge, extended to all vertex +pairs by choosing shortest graph walks. -/ +noncomputable def ripsCharge (hG : G.Connected) (a : V → V → ℤ) (u v : V) : ℤ := + walkCharge a (shortestWalk hG u v) + +theorem ripsCharge_eq_walkCharge (hG : G.Connected) (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → a v u = -a u v) (r : ℕ) + (hloop : ∀ u (p : G.Walk u u), p.length ≤ 2 * r → walkCharge a p = 0) + {u v : V} (p : G.Walk u v) (hp : p.length ≤ r) : + ripsCharge hG a u v = walkCharge a p := by + apply walkCharge_eq_of_short_loops a ha r hloop + · simpa only [shortestWalk_length] using (G.dist_le p).trans hp + · exact hp + +/-- The Rips charge is antisymmetric whenever loops of length at most `2r` +have zero charge. -/ +theorem ripsCharge_antisymm (hG : G.Connected) (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → a v u = -a u v) (r : ℕ) + (hloop : ∀ u (p : G.Walk u u), p.length ≤ 2 * r → walkCharge a p = 0) + {u v : V} (huv : G.dist u v ≤ r) : + ripsCharge hG a v u = -ripsCharge hG a u v := by + rw [ripsCharge_eq_walkCharge hG a ha r hloop (shortestWalk hG u v).reverse + (by simpa using huv), walkCharge_reverse a ha] + rfl + +/-- Every triangle in the Rips complex has zero total charge, assuming +vanishing of graph loops of length at most `3r`. This is the cocycle identity +needed for the circle-valued winding test. -/ +theorem ripsCharge_triangle (hG : G.Connected) (a : V → V → ℤ) (r : ℕ) + (hloop : ∀ u (p : G.Walk u u), p.length ≤ 3 * r → walkCharge a p = 0) + {u v w : V} (huv : G.dist u v ≤ r) (hvw : G.dist v w ≤ r) + (hwu : G.dist w u ≤ r) : + ripsCharge hG a u v + ripsCharge hG a v w + ripsCharge hG a w u = 0 := by + have hlen : (((shortestWalk hG u v).append (shortestWalk hG v w)).append + (shortestWalk hG w u)).length ≤ 3 * r := by + simp only [SimpleGraph.Walk.length_append, shortestWalk_length] + omega + have hz := hloop u (((shortestWalk hG u v).append (shortestWalk hG v w)).append + (shortestWalk hG w u)) hlen + simpa only [walkCharge_append, ripsCharge] using hz + +/-- Unit graph edges retain their original charges in the Rips cocycle. -/ +theorem ripsCharge_on_edge (hG : G.Connected) (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → a v u = -a u v) (r : ℕ) (hr : 1 ≤ r) + (hloop : ∀ u (p : G.Walk u u), p.length ≤ 2 * r → walkCharge a p = 0) + {u v : V} (h : G.Adj u v) : ripsCharge hG a u v = a u v := by + rw [ripsCharge_eq_walkCharge hG a ha r hloop h.toWalk (by simpa using hr)] + simp [SimpleGraph.Adj.toWalk] + +/-- In particular, the same boundary walk has the same winding charge after +passing to a Rips scale. -/ +theorem ripsCharge_on_walk (hG : G.Connected) (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → a v u = -a u v) (r : ℕ) (hr : 1 ≤ r) + (hloop : ∀ u (p : G.Walk u u), p.length ≤ 2 * r → walkCharge a p = 0) + {u v : V} (p : G.Walk u v) : + walkCharge (ripsCharge hG a) p = walkCharge a p := by + induction p with + | nil => rfl + | cons h p ih => + simp only [walkCharge_cons, ripsCharge_on_edge hG a ha r hr hloop h, ih] + +/-- The finite-scale combinatorial conclusion used in the paper: a charge-one +boundary and vanishing of loops through length `3r` give an antisymmetric +integer Rips cocycle that still evaluates to one on that boundary. -/ +theorem exists_rips_cocycle (hG : G.Connected) (a : V → V → ℤ) + (ha : ∀ u v, G.Adj u v → a v u = -a u v) (r : ℕ) (hr : 1 ≤ r) + (hloop : ∀ u (p : G.Walk u u), p.length ≤ 3 * r → walkCharge a p = 0) + {u : V} (boundary : G.Walk u u) (hboundary : walkCharge a boundary = 1) : + ∃ b : V → V → ℤ, + (∀ x y, G.dist x y ≤ r → b y x = -b x y) ∧ + (∀ x y z, G.dist x y ≤ r → G.dist y z ≤ r → G.dist z x ≤ r → + b x y + b y z + b z x = 0) ∧ walkCharge b boundary = 1 := by + have hloop₂ : ∀ x (p : G.Walk x x), p.length ≤ 2 * r → walkCharge a p = 0 := by + intro x p hp + apply hloop x p + omega + refine ⟨ripsCharge hG a, ?_, ?_, ?_⟩ + · intro x y hxy + exact ripsCharge_antisymm hG a ha r hloop₂ hxy + · intro x y z hxy hyz hzx + exact ripsCharge_triangle hG a r hloop hxy hyz hzx + · rw [ripsCharge_on_walk hG a ha r hr hloop₂, hboundary] + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SigmaCycle.lean b/lean/OAI/Topology/CoarseAssembly/SigmaCycle.lean new file mode 100644 index 0000000000000000000000000000000000000000..1523d0bf659adc4b2ba74828848e0fc8a634f8a1 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SigmaCycle.lean @@ -0,0 +1,104 @@ +import OAI.Topology.CoarseAssembly.SigmaCycleRepresentation + +namespace OAI + +/-! # Assembling uniformly bounded normalized Fredholm cycles -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Filter +open scoped ZeroAtInfty Topology + +variable {H : HilbertSpace} + +theorem norm_commutator_le (F T : End H) : ‖F * T - T * F‖ ≤ 2 * ‖F‖ * ‖T‖ := by + calc + _ ≤ ‖F * T‖ + ‖T * F‖ := norm_sub_le _ _ + _ ≤ ‖F‖ * ‖T‖ + ‖T‖ * ‖F‖ := add_le_add (norm_mul_le _ _) (norm_mul_le _ _) + _ = _ := by ring + +variable (Y : ℕ → Type) [∀ j, TopologicalSpace (Y j)] [∀ j, CompactSpace (Y j)] +variable (c : ∀ j, OddCycle C(Y j, ℂ)) +variable (M : ℝ) (hM : 0 ≤ M) (hF : ∀ j, ‖(c j).operator‖ ≤ M) + +def sigmaCycleOperator : End (countableHilbertSpace (cycleHilbertFamily Y c)) := + CoarseAssembly.blockOperator (fun j => (c j).operator) M hM hF + +theorem sigmaCycleOperator_selfAdjoint (hself : ∀ j, IsSelfAdjoint (c j).operator) : + IsSelfAdjoint (sigmaCycleOperator Y c M hM hF) := by + apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr + intro x y + rw [lp.inner_eq_tsum, lp.inner_eq_tsum] + exact tsum_congr (fun j => (hself j).isSymmetric (x j) (y j)) + +theorem sigmaCycleOperator_sq (hsq : ∀ j, (c j).operator * (c j).operator = 1) : + sigmaCycleOperator Y c M hM hF * sigmaCycleOperator Y c M hM hF = 1 := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + exact DFunLike.congr_fun (hsq j) (x j) + +def sigmaCommutatorBlocks (f : C₀(Sigma Y, ℂ)) (j : ℕ) : End (c j).space := + (c j).operator * (c j).representation (sigmaFunctionRestriction Y j f) - + (c j).representation (sigmaFunctionRestriction Y j f) * (c j).operator + +include hM hF in +theorem sigmaCommutator_norm (f : C₀(Sigma Y, ℂ)) (j : ℕ) : + ‖sigmaCommutatorBlocks Y c f j‖ ≤ (2 * M) * ‖sigmaFunctionRestriction Y j f‖ := by + apply (norm_commutator_le _ _).trans + exact mul_le_mul (mul_le_mul_of_nonneg_left (hF j) (by norm_num)) + (NonUnitalStarAlgHom.norm_apply_le _ _) (norm_nonneg _) + (mul_nonneg (by norm_num) hM) + +include hM hF in +theorem sigmaCommutator_uniform_bound (f : C₀(Sigma Y, ℂ)) (j : ℕ) : + ‖sigmaCommutatorBlocks Y c f j‖ ≤ (2 * M) * ‖f‖ := + (sigmaCommutator_norm Y c M hM hF f j).trans + (mul_le_mul_of_nonneg_left (sigmaFunctionRestriction_norm_le Y j f) (by positivity)) + +include hM hF in +theorem sigmaCommutator_norm_tendsto (f : C₀(Sigma Y, ℂ)) : + Tendsto (fun j => ‖sigmaCommutatorBlocks Y c f j‖) atTop (𝓝 0) := by + have hb : Tendsto (fun j => (2 * M) * ‖sigmaFunctionRestriction Y j f‖) atTop (𝓝 0) := by + simpa only [mul_zero] using tendsto_const_nhds.mul (sigmaFunctionRestriction_norm_tendsto Y f) + exact squeeze_zero (fun j => norm_nonneg _) (sigmaCommutator_norm Y c M hM hF f) hb + +theorem sigmaCycleOperator_commutator (f : C₀(Sigma Y, ℂ)) : + IsCompactOperator (sigmaCycleOperator Y c M hM hF * sigmaCycleRepresentation Y c f - + sigmaCycleRepresentation Y c f * sigmaCycleOperator Y c M hM hF) := by + have he : sigmaCycleOperator Y c M hM hF * sigmaCycleRepresentation Y c f - + sigmaCycleRepresentation Y c f * sigmaCycleOperator Y c M hM hF = + CoarseAssembly.blockOperator (sigmaCommutatorBlocks Y c f) ((2 * M) * ‖f‖) + (by positivity) (sigmaCommutator_uniform_bound Y c M hM hF f) := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + rfl + rw [he] + exact blockSum_compact (cycleHilbertFamily Y c) (sigmaCommutatorBlocks Y c f) + ((2 * M) * ‖f‖) (by positivity) (sigmaCommutator_uniform_bound Y c M hM hF f) + (fun j => (c j).commutator_compact _) (sigmaCommutator_norm_tendsto Y c M hM hF f) + +/-- A countable family of normalized cycles gives an actual locally finite cycle. -/ +def sigmaCycle (hself : ∀ j, IsSelfAdjoint (c j).operator) + (hsq : ∀ j, (c j).operator * (c j).operator = 1) : OddCycle C₀(Sigma Y, ℂ) where + space := countableHilbertSpace (cycleHilbertFamily Y c) + representation := sigmaCycleRepresentation Y c + operator := sigmaCycleOperator Y c M hM hF + commutator_compact := sigmaCycleOperator_commutator Y c M hM hF + square_compact f := by + rw [sigmaCycleOperator_sq Y c M hM hF hsq, sub_self, zero_mul] + exact isCompactOperator_zero + adjoint_compact f := by + rw [(sigmaCycleOperator_selfAdjoint Y c M hM hF hself).star_eq, sub_self, zero_mul] + exact isCompactOperator_zero + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SigmaCycleRepresentation.lean b/lean/OAI/Topology/CoarseAssembly/SigmaCycleRepresentation.lean new file mode 100644 index 0000000000000000000000000000000000000000..d2c7279aac560d4de1de92bc87f1c9917b25eb13 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SigmaCycleRepresentation.lean @@ -0,0 +1,83 @@ +import Mathlib.Analysis.CStarAlgebra.Spectrum +import OAI.Topology.CoarseAssembly.SigmaFunctionNorms +import OAI.Topology.CoarseAssembly.ProjectionBlocks + +namespace OAI + +/-! # Block representations of a countable compact family -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty CStarAlgebra + +variable (Y : ℕ → Type) [∀ j, TopologicalSpace (Y j)] [∀ j, CompactSpace (Y j)] +variable (c : ∀ j, OddCycle C(Y j, ℂ)) + +abbrev cycleHilbertFamily (j : ℕ) : HilbertSpace := (c j).space + +theorem sigmaRepresentation_block_bound (f : C₀(Sigma Y, ℂ)) (j : ℕ) : + ‖(c j).representation (sigmaFunctionRestriction Y j f)‖ ≤ ‖f‖ := + (NonUnitalStarAlgHom.norm_apply_le _ _).trans (sigmaFunctionRestriction_norm_le Y j f) + +def sigmaRepresentationOperator (f : C₀(Sigma Y, ℂ)) : + End (countableHilbertSpace (cycleHilbertFamily Y c)) := + CoarseAssembly.blockOperator (fun j => (c j).representation (sigmaFunctionRestriction Y j f)) + ‖f‖ (norm_nonneg f) (sigmaRepresentation_block_bound Y c f) + +@[simp] theorem sigmaRepresentationOperator_apply (f : C₀(Sigma Y, ℂ)) + (x : HilbertSum (cycleHilbertFamily Y c)) (j : ℕ) : + sigmaRepresentationOperator Y c f x j = (c j).representation (sigmaFunctionRestriction Y j f) (x j) := rfl + +def sigmaCycleRepresentation : C₀(Sigma Y, ℂ) →⋆ₙₐ[ℂ] + End (countableHilbertSpace (cycleHilbertFamily Y c)) where + toFun := sigmaRepresentationOperator Y c + map_zero' := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change (c j).representation (sigmaFunctionRestriction Y j 0) (x j) = 0 + rw [map_zero, map_zero] + rfl + map_add' f g := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change (c j).representation (sigmaFunctionRestriction Y j (f + g)) (x j) = _ + rw [map_add, map_add] + rfl + map_mul' f g := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change (c j).representation (sigmaFunctionRestriction Y j (f * g)) (x j) = _ + rw [map_mul, map_mul] + rfl + map_smul' z f := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change (c j).representation (sigmaFunctionRestriction Y j (z • f)) (x j) = _ + rw [map_smul, map_smul] + rfl + map_star' f := by + change sigmaRepresentationOperator Y c (star f) = (sigmaRepresentationOperator Y c f).adjoint + rw [sigmaRepresentationOperator, sigmaRepresentationOperator, CoarseAssembly.blockOperator_adjoint] + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext j + change (c j).representation (sigmaFunctionRestriction Y j (star f)) (x j) = _ + rw [map_star, map_star] + rfl + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SigmaCycleRestriction.lean b/lean/OAI/Topology/CoarseAssembly/SigmaCycleRestriction.lean new file mode 100644 index 0000000000000000000000000000000000000000..55daad2c4133b52adf8636c1d09ff76d251ac462 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SigmaCycleRestriction.lean @@ -0,0 +1,122 @@ +import OAI.Topology.CoarseAssembly.BlockSumDecomposition +import OAI.Topology.CoarseAssembly.SigmaCycle +import OAI.Topology.CoarseAssembly.CircleCoefficient + +namespace OAI + +/-! # The coordinates of an actual countable Fredholm cycle -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty + +variable {A : Type} [NonUnitalCStarAlgebra A] + +def zeroRepresentationCycle (H : HilbertSpace) (F : End H) : OddCycle A where + space := H + representation := 0 + operator := F + commutator_compact _ := by simp; exact isCompactOperator_zero + square_compact _ := by simp; exact isCompactOperator_zero + adjoint_compact _ := by simp; exact isCompactOperator_zero + +theorem zeroRepresentationCycle_degenerate (H : HilbertSpace) (F : End H) : + (zeroRepresentationCycle (A := A) H F).Degenerate := by + constructor + · intro a + change F * (0 : End H) - 0 * F = 0 + simp + constructor + · intro a + change (F * F - 1) * (0 : End H) = 0 + simp + · intro a + change (star F - F) * (0 : End H) = 0 + simp + +variable (Y : ℕ → Type) [∀ j, TopologicalSpace (Y j)] [∀ j, CompactSpace (Y j)] + [∀ j, T2Space (Y j)] + +theorem sigmaRestriction_extension_same (j : ℕ) (f : C₀(Y j, ℂ)) : + sigmaFunctionRestriction Y j + (zeroExtensionHom (sigmaComponent Y j) (sigmaComponent_open Y j) f) = + compactFunctionForget f := by + ext x + exact zeroExtension_apply (sigmaComponent Y j) (sigmaComponent_open Y j) f x + +theorem sigmaRestriction_extension_ne (j k : ℕ) (hjk : j ≠ k) (f : C₀(Y j, ℂ)) : + sigmaFunctionRestriction Y k + (zeroExtensionHom (sigmaComponent Y j) (sigmaComponent_open Y j) f) = 0 := by + ext x + apply zeroExtension_apply_outside (sigmaComponent Y j) (sigmaComponent_open Y j) f + rintro ⟨y, hy⟩ + exact hjk (congrArg Sigma.fst hy) + +variable (c : ∀ j, OddCycle C(Y j, ℂ)) +variable (M : ℝ) (hM : 0 ≤ M) (hF : ∀ j, ‖(c j).operator‖ ≤ M) + +theorem sigmaCycleRepresentation_extension (j : ℕ) (f : C₀(Y j, ℂ)) : + sigmaCycleRepresentation Y c + (zeroExtensionHom (sigmaComponent Y j) (sigmaComponent_open Y j) f) = + operatorConjugation (summandIsometry (cycleHilbertFamily Y c) j) + ((c j).representation (compactFunctionForget f)) := by + unfold operatorConjugation + rw [summandIsometry_adjoint] + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext k + change (c k).representation (sigmaFunctionRestriction Y k + (zeroExtensionHom (sigmaComponent Y j) (sigmaComponent_open Y j) f)) (x k) = + lp.single (E := fun k => (c k).space) 2 j + ((c j).representation (compactFunctionForget f) (x j)) k + by_cases hjk : j = k + · subst k + rw [sigmaRestriction_extension_same] + simp + · rw [sigmaRestriction_extension_ne Y j k hjk, map_zero] + simp [Pi.single_eq_of_ne (Ne.symm hjk)] + +def sigmaComplementCycle (j : ℕ) : OddCycle C₀(Y j, ℂ) := + zeroRepresentationCycle (complementHilbertSpace (cycleHilbertFamily Y c) j) + (complementBlockOperator (cycleHilbertFamily Y c) (fun k => (c k).operator) M hM hF j) + +def sigmaCycle_directSum (hself : ∀ j, IsSelfAdjoint (c j).operator) + (hsq : ∀ j, (c j).operator * (c j).operator = 1) (j : ℕ) : + ((c j).precomp compactFunctionForget).IsDirectSum (sigmaComplementCycle Y c M hM hF j) + ((sigmaCycle Y c M hM hF hself hsq).precomp + (zeroExtensionHom (sigmaComponent Y j) (sigmaComponent_open Y j))) where + left := summandIsometry (cycleHilbertFamily Y c) j + right := complementIsometry (cycleHilbertFamily Y c) j + orthogonal := summand_complement_orthogonal (cycleHilbertFamily Y c) j + exhaustive := summand_complement_exhaustive (cycleHilbertFamily Y c) j + representation_eq f := by + change sigmaCycleRepresentation Y c + (zeroExtensionHom (sigmaComponent Y j) (sigmaComponent_open Y j) f) = + operatorConjugation (summandIsometry (cycleHilbertFamily Y c) j) + ((c j).representation (compactFunctionForget f)) + + operatorConjugation (complementIsometry (cycleHilbertFamily Y c) j) + (0 : End (complementHilbertSpace (cycleHilbertFamily Y c) j)) + rw [sigmaCycleRepresentation_extension] + simp [operatorConjugation] + operator_eq := blockOperator_decomposition (cycleHilbertFamily Y c) + (fun k => (c k).operator) M hM hF j + +theorem sigmaCycle_coordinate (hself : ∀ j, IsSelfAdjoint (c j).operator) + (hsq : ∀ j, (c j).operator * (c j).operator = 1) (j : ℕ) : + restrictComponent (sigmaComponent Y j) (sigmaComponent_open Y j) + (cycleClass C₀(Sigma Y, ℂ) (sigmaCycle Y c M hM hF hself hsq)) = + cycleClass C₀(Y j, ℂ) ((c j).precomp compactFunctionForget) := by + rw [restrictComponent, precomp_cycleClass] + rw [directSum_eq _ _ _ (sigmaCycle_directSum Y c M hM hF hself hsq j)] + have hz : cycleClass C₀(Y j, ℂ) (sigmaComplementCycle Y c M hM hF j) = 0 := + degenerate_zero _ (zeroRepresentationCycle_degenerate _ _) + rw [hz, add_zero] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SigmaFunctionNorms.lean b/lean/OAI/Topology/CoarseAssembly/SigmaFunctionNorms.lean new file mode 100644 index 0000000000000000000000000000000000000000..ac01624990e14341a5058177004638d15d0eaab4 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SigmaFunctionNorms.lean @@ -0,0 +1,66 @@ +import OAI.Topology.CoarseAssembly.CompactBlockSum +import OAI.Topology.CoarseAssembly.CountableAdditivity + +namespace OAI + +/-! # Decay of compact-component norms for functions vanishing at infinity -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open Topology Filter +open scoped ZeroAtInfty + +variable (Y : ℕ → Type) [∀ j, TopologicalSpace (Y j)] [∀ j, CompactSpace (Y j)] + +def sigmaFunctionRestriction (j : ℕ) : C₀(Sigma Y, ℂ) →⋆ₙₐ[ℂ] C(Y j, ℂ) where + toFun f := ⟨fun x => f ⟨j, x⟩, f.continuous.comp continuous_sigmaMk⟩ + map_zero' := by ext x; rfl + map_add' _ _ := by ext x; rfl + map_mul' _ _ := by ext x; rfl + map_smul' _ _ := by ext x; rfl + map_star' _ := by ext x; rfl + +omit [∀ j, CompactSpace (Y j)] in +@[simp] theorem sigmaFunctionRestriction_apply (j : ℕ) (f : C₀(Sigma Y, ℂ)) (x : Y j) : + sigmaFunctionRestriction Y j f x = f ⟨j, x⟩ := rfl + +theorem sigmaFunctionRestriction_norm_le (j : ℕ) (f : C₀(Sigma Y, ℂ)) : + ‖sigmaFunctionRestriction Y j f‖ ≤ ‖f‖ := by + apply (ContinuousMap.norm_le _ (norm_nonneg f)).mpr + intro x + exact f.toBCF.norm_coe_le_norm ⟨j, x⟩ + +theorem sigmaFunctionRestriction_norm_tendsto (f : C₀(Sigma Y, ℂ)) : + Tendsto (fun j => ‖sigmaFunctionRestriction Y j f‖) atTop (𝓝 0) := by + apply Metric.tendsto_atTop.mpr + intro ε hε + have hsmall : {x : Sigma Y | dist (f x) 0 < ε / 2} ∈ cocompact (Sigma Y) := + Metric.tendsto_nhds.mp (zero_at_infty f) (ε / 2) (by positivity) + obtain ⟨K, hK, hbound⟩ := mem_cocompact.mp hsmall + obtain ⟨s, t, hs, _ht, hKs⟩ := hK.sigma_exists_finite_sigma_eq + obtain ⟨N, hN⟩ := hs.bddAbove + refine ⟨N + 1, fun j hj => ?_⟩ + have hjout : j ∉ s := by + intro hjs + have := hN hjs + omega + have hnorm : ‖sigmaFunctionRestriction Y j f‖ ≤ ε / 2 := by + apply (ContinuousMap.norm_le _ (by positivity : 0 ≤ ε / 2)).mpr + intro x + have hxout : (⟨j, x⟩ : Sigma Y) ∉ K := by + rw [← hKs] + intro hx + exact hjout hx.1 + have h := hbound hxout + change dist (f ⟨j, x⟩) 0 < ε / 2 at h + simpa only [sigmaFunctionRestriction_apply, dist_zero_right] using h.le + rw [dist_zero_right, norm_norm] + exact hnorm.trans_lt (by linarith) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SpatialAveraging.lean b/lean/OAI/Topology/CoarseAssembly/SpatialAveraging.lean new file mode 100644 index 0000000000000000000000000000000000000000..bb3a78d48e98ede771139c02c4c985c6ace84993 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SpatialAveraging.lean @@ -0,0 +1,69 @@ +import OAI.Topology.CoarseAssembly.ProjectionBlocks +import OAI.Topology.CoarseAssembly.ConcreteTransfer + +namespace OAI + +/-! # Uniform spatial approximation from the published gap + +The gap hypothesis is the norm estimate for the explicitly defined lazy +regular-representation averages. The direct-sum convergence and its +identification with the actual spatial constant-fiber projection are proved +here, as required by the transfer construction. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence DiscreteRoe +open scoped Topology + +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +/-- The precise uniform operator consequence of the Kazhdan estimate for +the chosen generators, on the coefficient Hilbert space used by the Roe +module. For the standard generators this is the specialization of BHV, +Proposition 1.3.2 and Example 1.7.4, described in manuscript §5.2. -/ +def UniformAveragingGap (S : Finset ArithmeticGroup) (H : Type*) + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] : Prop := + ∃ c : ℝ, 0 ≤ c ∧ c < 1 ∧ ∀ k, + ‖lazyAverage (H := H) S k - constantProjection (H := H) (Quotient k)‖ ≤ c + +theorem fiberAveragingPower_norm (S : Finset ArithmeticGroup) (n : ℕ) (u : BaseUnion) : + ‖lazyAverage (H := H) S (discDepth u.1 u.2) ^ (n + 1)‖ ≤ 1 := by + calc + _ ≤ ‖lazyAverage (H := H) S (discDepth u.1 u.2)‖ ^ (n + 1) := + norm_pow_le' _ (Nat.succ_pos n) + _ ≤ 1 ^ (n + 1) := by gcongr; exact lazyAverage_norm_le S _ + _ = 1 := one_pow _ + +def spatialAveragingPower (S : Finset ArithmeticGroup) (n : ℕ) : Operator VertexUnion H := + flattenOperator (Q := BaseFiber) (blockOperator + (fun u : BaseUnion => lazyAverage (H := H) S (discDepth u.1 u.2) ^ (n + 1)) + 1 zero_le_one (fiberAveragingPower_norm (H := H) S n)) + +theorem spatialAveragingPower_tendsto (S : Finset ArithmeticGroup) (hS : S.Nonempty) + (hgap : UniformAveragingGap S H) : + Filter.Tendsto (spatialAveragingPower (H := H) S) Filter.atTop + (nhds (fiberProjection (H := H) BaseFiber)) := by + obtain ⟨c, hc, hc1, hgap⟩ := hgap + let M := fun u : BaseUnion => lazyAverage (H := H) S (discDepth u.1 u.2) + let P := fun u : BaseUnion => constantProjection (H := H) (BaseFiber u) + have hM (u : BaseUnion) : ‖M u‖ ≤ 1 := lazyAverage_norm_le S _ + have hP (u : BaseUnion) : ‖P u‖ ≤ 1 := constantProjection_norm_le _ + have hconv := averaging_blocks_tendsto + (ι := BaseUnion) (E := fun u => lp (fun _ : BaseFiber u => H) 2) + M P c hc hc1 hM hP + (fun u => constantProjection_idempotent (H := H) (BaseFiber u)) + (fun u => lazyAverage_projection (H := H) S hS (discDepth u.1 u.2)) + (fun u => projection_lazyAverage (H := H) S hS (discDepth u.1 u.2)) + (fun u => hgap (discDepth u.1 u.2)) + have hflat := flattenOperator_tendsto (Q := BaseFiber) (H := H) _ _ hconv + rw [flatten_constantProjection (Q := BaseFiber) (H := H)] at hflat + exact hflat + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SpatialBlocks.lean b/lean/OAI/Topology/CoarseAssembly/SpatialBlocks.lean new file mode 100644 index 0000000000000000000000000000000000000000..b7e2a9fdd47c96516534661b22ec75332e3a8276 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SpatialBlocks.lean @@ -0,0 +1,109 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.ControlledMatrices +import OAI.Topology.CoarseAssembly.FiberEmbedding + +namespace OAI + +/-! # Controlled block matrices on the spatial vertex module + +The bounded block-matrix construction is transported through the explicit +Hilbert-sum equivalence. Its vertex entries are the entries of the original +blocks, which allows propagation and local compactness to be checked there. +-/ + +noncomputable section + +namespace CoarseAssembly + +variable {I : Type*} {Q : I → Type*} {H : Type*} +variable [NormedAddCommGroup H] [NormedSpace ℂ H] + +@[simp] theorem flattenOperator_apply + (A : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) + (x : lp (fun _ : Sigma Q => H) 2) (i : I) (q : Q i) : + flattenOperator A x ⟨i, q⟩ = A (unflattenVector x) i q := rfl + +theorem flattenOperator_norm_le + (A : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ] + lp (fun i => lp (fun _ : Q i => H) 2) 2) : ‖flattenOperator A‖ ≤ ‖A‖ := by + apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg A) + intro x + change ‖flattenEquiv (A ((flattenEquiv (Q := Q) (H := H)).symm x))‖ ≤ _ + rw [LinearIsometryEquiv.norm_map] + simpa only [LinearIsometryEquiv.norm_map] using + A.le_opNorm ((flattenEquiv (Q := Q) (H := H)).symm x) + +variable [DecidableEq I] [∀ i, DecidableEq (Q i)] + +omit [NormedSpace ℂ H] in +theorem rowVector_single_same (i : I) (q : Q i) (h : H) : + rowVector (lp.single 2 ⟨i, q⟩ h) i = lp.single 2 q h := by + apply lp.ext + funext r + change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨i, r⟩ = + lp.single (E := fun _ : Q i => H) 2 q h r + by_cases hr : r = q + · subst r; simp + · have hn : (⟨i, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := by + intro he + cases he + exact hr rfl + simp [hr, hn] + +omit [NormedSpace ℂ H] in +theorem rowVector_single_ne {i j : I} (hji : j ≠ i) (q : Q i) (h : H) : + rowVector (lp.single 2 ⟨i, q⟩ h) j = 0 := by + apply lp.ext + funext r + have hn : (⟨j, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := fun he => hji (congrArg Sigma.fst he) + change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨j, r⟩ = 0 + exact lp.single_apply_ne (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h hn + +section Matrix + +variable (rows cols : I → Finset I) (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) +variable (B : ∀ i j, lp (fun _ : Q j => H) 2 →L[ℂ] lp (fun _ : Q i => H) 2) +variable (N : ℕ) (C : ℝ) (hC : 0 ≤ C) +variable (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) +variable (hB : ∀ i j, j ∈ rows i → ‖B i j‖ ≤ C) + +def spatialBlocks : lp (fun _ : Sigma Q => H) 2 →L[ℂ] lp (fun _ : Sigma Q => H) 2 := + flattenOperator (controlledMatrix rows cols hdual B N C hC hr hc hB) + +omit [∀ i, DecidableEq (Q i)] in +theorem spatialBlocks_norm_le : ‖spatialBlocks rows cols hdual B N C hC hr hc hB‖ ≤ + (N : ℝ) * C := + (flattenOperator_norm_le _).trans (controlledMatrix_norm_le rows cols hdual B N C hC hr hc hB) + +omit [∀ i, DecidableEq (Q i)] in +@[simp] theorem spatialBlocks_apply (x : lp (fun _ : Sigma Q => H) 2) (i : I) (q : Q i) : + spatialBlocks rows cols hdual B N C hC hr hc hB x ⟨i, q⟩ = + (∑ j ∈ rows i, B i j (rowVector x j)) q := rfl + +theorem spatialBlocks_single (i j : I) (q : Q i) (r : Q j) (h : H) : + spatialBlocks rows cols hdual B N C hC hr hc hB (lp.single 2 ⟨j, r⟩ h) ⟨i, q⟩ = + if j ∈ rows i then B i j (lp.single 2 r h) q else 0 := by + rw [spatialBlocks_apply] + simp only [lp.coeFn_sum, Finset.sum_apply] + by_cases hj : j ∈ rows i + · rw [ite_eq_left hj, Finset.sum_eq_single j] + · rw [rowVector_single_same] + · intro k hk hkj + rw [rowVector_single_ne hkj, map_zero] + rfl + · exact fun hn => (hn hj).elim + · rw [ite_eq_right hj] + apply Finset.sum_eq_zero + intro k hk + have hkj : k ≠ j := fun h => hj (h ▸ hk) + rw [rowVector_single_ne hkj, map_zero] + rfl + +end Matrix + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SpatialBoundaryNaturality.lean b/lean/OAI/Topology/CoarseAssembly/SpatialBoundaryNaturality.lean new file mode 100644 index 0000000000000000000000000000000000000000..bd3d45e33f2ffd93580e28f7438ad0da920dfc0a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SpatialBoundaryNaturality.lean @@ -0,0 +1,74 @@ +import OAI.Topology.CoarseAssembly.MultiplierBoundaryClass +import OAI.Topology.CoarseAssembly.CayleyNonunitalNaturality +import OAI.Topology.CoarseAssembly.RelativeNaturality +import OAI.Topology.CoarseAssembly.IsometricExtension +import OAI.Topology.CoarseAssembly.RoeTransfer + +namespace OAI + +/-! # The boundary representative respects spatial Roe maps + +The target Fredholm operator is extended by the identity on the complement +of the spatial isometry. The conclusion is the actual K₁ map equality. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X Y H : Type*} [DecidableEq X] [DecidableEq Y] + [PseudoMetricSpace X] [PseudoMetricSpace Y] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance spatialBoundaryScalarTower {Z : Type*} : IsScalarTower ℂ (Operator Z H) (Operator Z H) where + smul_assoc c T S := by ext v; simp +local instance spatialBoundaryScalarComm {Z : Type*} : SMulCommClass ℂ (Operator Z H) (Operator Z H) where + smul_comm c T S := by ext v; simp +local instance spatialBoundaryContinuousStar {Z : Type*} : ContinuousStar (Operator Z H) := ⟨operator_star_continuous⟩ + +theorem multiplierBoundaryUnitary_spatial + (V : Module X H →ₗᵢ[ℂ] Module Y H) + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (G : multiplierAlgebra (X := Y) (H := H)) (hG : IsSelfAdjoint G) + (hGF : G.val = isometricExtension V F.val) : + (multiplierBoundaryUnitary G hG : Operator Y H) - 1 = + operatorConjugation V ((multiplierBoundaryUnitary F hF : Operator X H) - 1) := by + let φ : multiplierAlgebra (X := X) (H := H) →⋆ₙₐ[ℂ] Operator Y H := + (operatorConjugationHom V).comp + (multiplierAlgebra (X := X) (H := H)).subtype.toNonUnitalStarAlgHom + have he : Analytic.nonunitalIdentityExtension φ F = G.val := hGF.symm + have h := Analytic.nonunital_rationalBoundaryUnitary φ F hF + have hg := Analytic.map_rationalBoundaryUnitary + (multiplierAlgebra (X := Y) (H := H)).subtype G hG + have hg' : (multiplierBoundaryUnitary G hG : Operator Y H) = + (Analytic.rationalBoundaryUnitary (Analytic.nonunitalIdentityExtension φ F) + (Analytic.nonunitalIdentityExtension_selfAdjoint φ F hF) : Operator Y H) := by + convert! hg using 2 + congr 1 + have hu : 1 + φ ((Analytic.rationalBoundaryUnitary F hF : multiplierAlgebra + (X := X) (H := H)) - 1) = (multiplierBoundaryUnitary G hG : Operator Y H) := + h.trans hg'.symm + have hu' := congrArg (fun T : Operator Y H => T - 1) hu.symm + have hφ : φ ((Analytic.rationalBoundaryUnitary F hF : + multiplierAlgebra (X := X) (H := H)) - 1) = + operatorConjugation V ((multiplierBoundaryUnitary F hF : Operator X H) - 1) := rfl + simpa only [add_sub_cancel_left, hφ] using hu' + +theorem multiplierBoundaryClass_spatial + (V : Module X H →ₗᵢ[ℂ] Module Y H) (hV : MapsToRoe V) + (F : multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F) + (hFd : F.val ^ 2 - 1 ∈ algebra (X := X) (H := H)) + (G : multiplierAlgebra (X := Y) (H := H)) (hG : IsSelfAdjoint G) + (hGd : G.val ^ 2 - 1 ∈ algebra (X := Y) (H := H)) + (hGF : G.val = isometricExtension V F.val) : + OperatorKTheory.map (conjugationHom V hV) (multiplierBoundaryClass F hF hFd) = + multiplierBoundaryClass G hG hGd := by + apply OperatorKTheory.map_relativeClass (hS := algebra_isClosed) (hT := algebra_isClosed) + apply Subtype.ext + exact (multiplierBoundaryUnitary_spatial V F hF G hG hGF).symm + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SpatialLocalization.lean b/lean/OAI/Topology/CoarseAssembly/SpatialLocalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..dcfa59a5dfadd157d48ce7589c01e1fedd450b05 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SpatialLocalization.lean @@ -0,0 +1,78 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.PartitionSpatialControl +import OAI.Topology.CoarseAssembly.IsometricExtension +import OAI.Topology.CoarseAssembly.UnitalStructureAlgebra + +namespace OAI + +/-! # The controlled spatial representative of a localized operator -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [Fintype X] [DecidableEq X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.spatialLocalizationContinuousAdd + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.spatialLocalizationRingHomCompTriple + +attribute [local instance] OAI.CoarseAssembly.DiscreteRoe.spatialLocalizationCompleteSpace + +theorem partitionConjugate_eq (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) : + partitionConjugate a F = operatorConjugation (partitionIsometry a hpart) F := by + rfl + +theorem localizedSpatialOperator_eq (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) : + localizedSpatialOperator a hpart F = + 1 + partitionConjugate a (partitionCompression a F) - partitionConjugate a 1 := by + rw [partitionConjugate_eq a hpart, partitionConjugate_eq a hpart] + change 1 + operatorConjugationHom (partitionIsometry a hpart) (partitionCompression a F - 1) = + 1 + operatorConjugationHom (partitionIsometry a hpart) (partitionCompression a F) - + operatorConjugationHom (partitionIsometry a hpart) 1 + rw [map_sub, add_sub_assoc] + +theorem partitionCompression_selfAdjoint (a : X → H →L[ℂ] H) + (F : H →L[ℂ] H) (hF : IsSelfAdjoint F) : IsSelfAdjoint (partitionCompression a F) := by + rw [partitionCompression_eq_sum] + exact isSelfAdjoint_sum _ (fun x _ => hF.conjugate' (a x)) + +theorem localizedSpatialOperator_selfAdjoint (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) (hF : IsSelfAdjoint F) : + IsSelfAdjoint (localizedSpatialOperator a hpart F) := + isometricExtension_selfAdjoint _ _ (partitionCompression_selfAdjoint a F hF) + +theorem localizedSpatialOperator_norm_le (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) : + ‖localizedSpatialOperator a hpart F‖ ≤ ‖F‖ + 2 := + (isometricExtension_norm_le _ _).trans + (add_le_add (partitionCompression_norm_le a hpart F) le_rfl) + +variable [PseudoMetricSpace X] + +omit [Fintype X] [CompleteSpace H] [PseudoMetricSpace X] in +theorem entry_sub (T S : Operator X H) (x y : X) : + entry (T - S) x y = entry T x y - entry S x y := by + ext v + simp [entry] + +theorem localizedSpatialOperator_propagation (a : X → H →L[ℂ] H) + (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) + (ha : ∀ x, (a x).adjoint = a x) (r : ℝ) (hr : 0 ≤ r) + (hsupport : ∀ x y, r < dist x y → a x * a y = 0) (F : H →L[ℂ] H) : + PropagationLE (r + r) (localizedSpatialOperator a hpart F) := by + intro x y hxy + rw [localizedSpatialOperator_eq, entry_sub, entry_add, + partitionLocalization_propagation a ha r hsupport F x y hxy, + partitionConjugate_one_propagation a ha r hsupport x y (by linarith), + add_zero, sub_zero] + exact propagationLE_one x y (by linarith) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/StructureQuotient.lean b/lean/OAI/Topology/CoarseAssembly/StructureQuotient.lean new file mode 100644 index 0000000000000000000000000000000000000000..4d8e709fcf178792cdf8248645080f751b4f450a --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/StructureQuotient.lean @@ -0,0 +1,62 @@ +import OAI.Topology.CoarseAssembly.RoeIdealizer +import Mathlib.RingTheory.TwoSidedIdeal.Basic + +namespace OAI + +/-! # The Roe ideal and the algebraic analytic-index quotient + +This is the actual two-sided ideal in the controlled pseudolocal algebra. +The quotient norm and the analytic-index class are constructed separately. +-/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] +variable (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) + +def roeIdeal : TwoSidedIdeal (structureAlgebra (X := X) (H := H)) := + TwoSidedIdeal.mk' {T | T.val ∈ algebra (X := X) (H := H)} + (algebra (X := X) (H := H)).zero_mem + (fun hT hS => (algebra (X := X) (H := H)).add_mem hT hS) + (fun hT => (algebra (X := X) (H := H)).neg_mem hT) + (fun {T S} hS => (structureAlgebra_multiplier finiteBalls T.property) ⟨S.val, hS⟩ |>.1) + (fun {T S} hT => (structureAlgebra_multiplier finiteBalls S.property) ⟨T.val, hT⟩ |>.2) + +@[simp] theorem mem_roeIdeal (T : structureAlgebra (X := X) (H := H)) : + T ∈ roeIdeal (H := H) finiteBalls ↔ T.val ∈ algebra (X := X) (H := H) := by + exact TwoSidedIdeal.mem_mk' _ _ _ _ _ _ T + +theorem roeIdeal_closed : + IsClosed (roeIdeal (H := H) finiteBalls : Set (structureAlgebra (X := X) (H := H))) := by + have he : (roeIdeal (H := H) finiteBalls : Set (structureAlgebra (X := X) (H := H))) = + Subtype.val ⁻¹' (algebra (X := X) (H := H) : Set (Operator X H)) := by + ext T + exact mem_roeIdeal finiteBalls T + rw [he] + exact algebra_isClosed.preimage continuous_subtype_val + +abbrev StructureQuotient := (roeIdeal (H := H) finiteBalls).ringCon.Quotient + +def structureQuotientMap : structureAlgebra (X := X) (H := H) →ₙ+* + StructureQuotient (H := H) finiteBalls where + toFun T := (T : (roeIdeal (H := H) finiteBalls).ringCon.Quotient) + map_zero' := rfl + map_add' _ _ := rfl + map_mul' _ _ := rfl + +theorem structureQuotientMap_eq (T S : structureAlgebra (X := X) (H := H)) : + structureQuotientMap (H := H) finiteBalls T = structureQuotientMap (H := H) finiteBalls S ↔ + T.val - S.val ∈ algebra (X := X) (H := H) := by + change (T : (roeIdeal (H := H) finiteBalls).ringCon.Quotient) = + (S : (roeIdeal (H := H) finiteBalls).ringCon.Quotient) ↔ _ + rw [RingCon.eq] + exact (TwoSidedIdeal.rel_iff _ T S).trans (mem_roeIdeal finiteBalls (T - S)) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SummandComplement.lean b/lean/OAI/Topology/CoarseAssembly/SummandComplement.lean new file mode 100644 index 0000000000000000000000000000000000000000..6b075ae766939890e415bb17e1fdc0b0c3ec2626 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SummandComplement.lean @@ -0,0 +1,80 @@ +import OAI.Topology.CoarseAssembly.CountableHilbertSum + +namespace OAI + +/-! # The orthogonal complement of one countable Hilbert summand -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable (H : ℕ → HilbertSpace) (j : ℕ) + +def summandComplement : Submodule ℂ (countableHilbertSpace H) := + (lp.evalCLM ℂ (fun k => H k) 2 j).ker + +instance summandComplement_complete : CompleteSpace (summandComplement H j) := + (lp.evalCLM ℂ (fun k => H k) 2 j).isClosed_ker.completeSpace_coe + +abbrev complementHilbertSpace : HilbertSpace where + Carrier := summandComplement H j + normed := inferInstance + inner := inferInstance + complete := inferInstance + secondCountable := inferInstance + +def complementIsometry : complementHilbertSpace H j →ₗᵢ[ℂ] countableHilbertSpace H := + (summandComplement H j).subtypeₗᵢ + +def complementProjection : countableHilbertSpace H →L[ℂ] complementHilbertSpace H j := + ((1 : End (countableHilbertSpace H)) - + (summandIsometry H j).toContinuousLinearMap.comp (lp.evalCLM ℂ (fun k => H k) 2 j)).codRestrict + (summandComplement H j) (by + intro x + change (x - lp.single (E := fun k => H k) 2 j (x j)) j = 0 + simp) + +theorem complementProjection_coe (x : countableHilbertSpace H) : + (complementProjection H j x : countableHilbertSpace H) = + x - summandIsometry H j (x j) := rfl + +theorem complementIsometry_adjoint : + (complementIsometry H j).toContinuousLinearMap.adjoint = complementProjection H j := by + apply ContinuousLinearMap.ext + intro x + apply ext_inner_right ℂ + intro y + rw [ContinuousLinearMap.adjoint_inner_left] + symm + change inner ℂ (x - lp.single (E := fun k => H k) 2 j (x j)) + (y : countableHilbertSpace H) = inner ℂ x (y : countableHilbertSpace H) + rw [inner_sub_left, lp.inner_single_left] + have hy : (y : countableHilbertSpace H) j = 0 := y.property + rw [hy, inner_zero_right, sub_zero] + +theorem summand_complement_orthogonal : + (summandIsometry H j).toContinuousLinearMap.adjoint.comp + (complementIsometry H j).toContinuousLinearMap = 0 := by + rw [summandIsometry_adjoint] + apply ContinuousLinearMap.ext + intro x + exact x.property + +theorem summand_complement_exhaustive : + (summandIsometry H j).toContinuousLinearMap.comp + (summandIsometry H j).toContinuousLinearMap.adjoint + + (complementIsometry H j).toContinuousLinearMap.comp + (complementIsometry H j).toContinuousLinearMap.adjoint = 1 := by + rw [summandIsometry_adjoint, complementIsometry_adjoint] + apply ContinuousLinearMap.ext + intro x + change summandIsometry H j (x j) + + (complementProjection H j x : countableHilbertSpace H) = x + rw [complementProjection_coe] + abel + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/SupportedNormalization.lean b/lean/OAI/Topology/CoarseAssembly/SupportedNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..10648c6177eaf96d19190ccab3b220e0209c1ef7 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/SupportedNormalization.lean @@ -0,0 +1,82 @@ +import OAI.Topology.CoarseAssembly.ScalarCutDown +import Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Commute + +namespace OAI + +/-! # Normalization preserving the represented scalar subspace -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem kernelProjection_complement (F P : End H) (hF : IsSelfAdjoint F) + (hQ : F * (1 - P) = 1 - P) : kernelProjection F * (1 - P) = 0 := by + calc + kernelProjection F * (1 - P) = kernelProjection F * (F * (1 - P)) := by rw [hQ] + _ = (kernelProjection F * F) * (1 - P) := (mul_assoc _ _ _).symm + _ = 0 := by rw [kernelProjection_mul F hF, zero_mul] + +theorem commute_of_complement (F P : End H) (hF : IsSelfAdjoint F) (hP : IsSelfAdjoint P) + (hQ : F * (1 - P) = 1 - P) : Commute F P := by + have hQ' : (1 - P) * F = 1 - P := by + have h := congrArg star hQ + simpa only [star_mul, star_sub, star_one, hF.star_eq, hP.star_eq] using h + have h1 : F - F * P = 1 - P := by simpa only [mul_sub, mul_one] using hQ + have h2 : F - P * F = 1 - P := by simpa only [sub_mul, one_mul] using hQ' + have h := congrArg (fun T : End H => F - T) (h1.trans h2.symm) + exact (by simpa only [sub_sub_cancel] using h : F * P = P * F) + +theorem supported_scalar_cycleClass_zero (c : OddCycle ℂ) (hF : IsSelfAdjoint c.operator) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) : + cycleClass ℂ c = 0 := by + let P : End c.space := c.representation 1 + have hc := supported_square_compact c hQ + have hk := kernelProjection_compact c.operator hc + have hks : IsCompactOperator (star (kernelProjection c.operator) : End c.space) := by + rw [(kernelProjection_selfAdjoint c.operator).star_eq] + exact hk + let G : End c.space := c.operator + kernelProjection c.operator + have hgs : IsSelfAdjoint G := kernel_corrected_selfAdjoint c.operator hF + have hgi : IsUnit G := kernel_corrected_isUnit c.operator hF hc + have hgQ : G * (1 - P) = 1 - P := by + change (c.operator + kernelProjection c.operator) * (1 - P) = 1 - P + rw [add_mul, kernelProjection_complement c.operator P hF hQ, add_zero] + exact hQ + have hgcomm : Commute G P := + commute_of_complement G P hgs (scalar_projection_selfAdjoint c) hgQ + have hgcpt : IsCompactOperator (G * G - 1 : End c.space) := + kernel_corrected_compact_square c.operator hF hc + obtain ⟨hK, hKs⟩ := involutiveCorrection_compact G hgs hgi hgcpt + let L : End c.space := G * cfc inverseSqrtCorrection (G * G - 1) + let d := c.compactPerturb (kernelProjection c.operator) hk hks + let e := d.compactPerturb L hK hKs + have hec : cycleClass ℂ e = cycleClass ℂ c := + (compactPerturb_class d L hK hKs).trans (compactPerturb_class c _ hk hks) + have heop : G + L = involutiveNormalization G := + (involutiveNormalization_eq G hgs hgi).symm + have hedeg : e.Degenerate := by + change (∀ z, (G + L) * c.representation z - c.representation z * (G + L) = 0) ∧ + (∀ z, ((G + L) * (G + L) - 1) * c.representation z = 0) ∧ + (∀ z, (star (G + L) - (G + L)) * c.representation z = 0) + rw [heop] + refine ⟨?_, ?_, ?_⟩ + · intro z + have hecomm : Commute (involutiveNormalization G) P := hgcomm.cfc_real normalizedReal + rw [scalar_representation, mul_smul_comm, smul_mul_assoc, hecomm.eq, sub_self] + · intro z + rw [involutiveNormalization_sq G hgs hgi, sub_self, zero_mul] + · intro z + rw [(involutiveNormalization_selfAdjoint G).star_eq, sub_self, zero_mul] + exact hec.symm.trans (degenerate_zero e hedeg) + +theorem scalar_cycleClass_zero (c : OddCycle ℂ) : cycleClass ℂ c = 0 := by + obtain ⟨d, hdc, hdself, hdQ⟩ := exists_supported_scalar_representative c + exact hdc.symm.trans (supported_scalar_cycleClass_zero d hdself hdQ) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/TensorFibers.lean b/lean/OAI/Topology/CoarseAssembly/TensorFibers.lean new file mode 100644 index 0000000000000000000000000000000000000000..6db3a765e3bb88d430f3b3310c3e5696b3f9439d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/TensorFibers.lean @@ -0,0 +1,148 @@ +import OAI.Topology.CoarseAssembly.FiberConstants +import Mathlib.Analysis.InnerProductSpace.TensorProduct + +namespace OAI + +/-! # Amplifying finite-fiber operators + +The algebraic Hilbert tensor product of a finite scalar fiber with the +coefficient Hilbert space is isometrically the fiber's vector-valued ℓ² +space. This gives the norm-controlled amplification used in each transfer +block, using Mathlib's Hilbert tensor-product operator norm theorem. +-/ + +noncomputable section + +namespace CoarseAssembly + +open scoped TensorProduct + +variable {Q R H : Type*} [Fintype Q] [Fintype R] +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] + +def fiberTensorBilinear : lp (fun _ : Q => ℂ) 2 →ₗ[ℂ] + H →ₗ[ℂ] lp (fun _ : Q => H) 2 where + toFun a := + { toFun := fun h => ⟨fun q => a q • h, Memℓp.all _⟩ + map_add' := by intro x y; apply lp.ext; funext q; exact smul_add _ _ _ + map_smul' := by intro c h; apply lp.ext; funext q; exact smul_comm _ _ _ } + map_add' a b := by + apply LinearMap.ext + intro h + apply lp.ext + funext q + exact add_smul (a q) (b q) h + map_smul' c a := by + apply LinearMap.ext + intro h + apply lp.ext + funext q + exact mul_smul c (a q) h + +def fiberTensorMap : (lp (fun _ : Q => ℂ) 2 ⊗[ℂ] H) →ₗ[ℂ] lp (fun _ : Q => H) 2 := + TensorProduct.lift fiberTensorBilinear + +@[simp] theorem fiberTensorMap_tmul_apply (a : lp (fun _ : Q => ℂ) 2) (h : H) (q : Q) : + fiberTensorMap (a ⊗ₜ[ℂ] h) q = a q • h := rfl + +theorem fiberTensorMap_inner (x y : lp (fun _ : Q => ℂ) 2 ⊗[ℂ] H) : + inner ℂ (fiberTensorMap x) (fiberTensorMap y) = inner ℂ x y := by + induction x using TensorProduct.inductionOn with + | tmul a h => + induction y using TensorProduct.inductionOn with + | tmul b k => + rw [TensorProduct.inner_tmul] + change (∑' q : Q, inner ℂ (a q • h) (b q • k)) = + (∑' q : Q, inner ℂ (a q) (b q)) * inner ℂ h k + simp only [inner_smul_left, inner_smul_right, RCLike.inner_apply] + calc + _ = ∑' q : Q, (b q * (starRingEnd ℂ) (a q)) * inner ℂ h k := + tsum_congr (fun q => (mul_assoc _ _ _).symm) + _ = _ := tsum_mul_right + | add y z ihy ihz => simp only [map_add, inner_add_right, ihy, ihz] + | add x z ihx ihz => simp only [map_add, inner_add_left, ihx, ihz] + +def fiberTensorIsometry : + (lp (fun _ : Q => ℂ) 2 ⊗[ℂ] H) →ₗᵢ[ℂ] lp (fun _ : Q => H) 2 where + toLinearMap := fiberTensorMap + norm_map' x := by + have hs := norm_sq_eq_re_inner (𝕜 := ℂ) (fiberTensorMap x) + rw [fiberTensorMap_inner] at hs + have ht := norm_sq_eq_re_inner (𝕜 := ℂ) x + nlinarith [norm_nonneg (fiberTensorMap x), norm_nonneg x] + +variable [DecidableEq Q] + +theorem fiberTensorMap_surjective : Function.Surjective (fiberTensorMap (Q := Q) (H := H)) := by + intro x + refine ⟨∑ q : Q, lp.single 2 q (1 : ℂ) ⊗ₜ[ℂ] x q, ?_⟩ + apply lp.ext + funext r + simp only [map_sum, lp.coeFn_sum, Finset.sum_apply, fiberTensorMap_tmul_apply] + simp [lp.single_apply, Pi.single_apply] + +def fiberTensorEquiv : + (lp (fun _ : Q => ℂ) 2 ⊗[ℂ] H) ≃ₗᵢ[ℂ] lp (fun _ : Q => H) 2 := + LinearIsometryEquiv.ofSurjective fiberTensorIsometry fiberTensorMap_surjective + +@[simp] theorem fiberTensorEquiv_apply (x : lp (fun _ : Q => ℂ) 2 ⊗[ℂ] H) : + fiberTensorEquiv x = fiberTensorMap x := rfl + +theorem fiberTensor_single (q : Q) (h : H) : + fiberTensorEquiv (lp.single 2 q (1 : ℂ) ⊗ₜ[ℂ] h) = lp.single 2 q h := by + apply lp.ext + funext r + simp [fiberTensorMap_tmul_apply, lp.single_apply, Pi.single_apply] + +theorem fiberTensor_constant (h : H) : + fiberTensorEquiv (fiberConstant Q (1 : ℂ) ⊗ₜ[ℂ] h) = fiberConstant Q h := by + apply lp.ext + funext q + simp [fiberTensorMap_tmul_apply, fiberConstant_apply] + +variable [DecidableEq R] + +def amplifyFiber (O : lp (fun _ : Q => ℂ) 2 →L[ℂ] lp (fun _ : R => ℂ) 2) + (T : H →L[ℂ] H) : lp (fun _ : Q => H) 2 →L[ℂ] lp (fun _ : R => H) 2 := + (fiberTensorEquiv (Q := R) (H := H)).toLinearIsometry.toContinuousLinearMap.comp + ((TensorProduct.mapL O T).comp + (fiberTensorEquiv (Q := Q) (H := H)).symm.toLinearIsometry.toContinuousLinearMap) + +theorem amplifyFiber_norm_le (O : lp (fun _ : Q => ℂ) 2 →L[ℂ] lp (fun _ : R => ℂ) 2) + (T : H →L[ℂ] H) : ‖amplifyFiber O T‖ ≤ ‖O‖ * ‖T‖ := by + apply ContinuousLinearMap.opNorm_le_bound _ (mul_nonneg (norm_nonneg _) (norm_nonneg _)) + intro x + change ‖fiberTensorEquiv (TensorProduct.mapL O T (fiberTensorEquiv.symm x))‖ ≤ _ + rw [LinearIsometryEquiv.norm_map] + calc + _ ≤ ‖TensorProduct.mapL O T‖ * ‖fiberTensorEquiv.symm x‖ := + (TensorProduct.mapL O T).le_opNorm _ + _ ≤ (‖O‖ * ‖T‖) * ‖x‖ := by + rw [LinearIsometryEquiv.norm_map] + exact mul_le_mul_of_nonneg_right (TensorProduct.norm_mapL_le O T) (norm_nonneg _) + +theorem amplifyFiber_tensor (O : lp (fun _ : Q => ℂ) 2 →L[ℂ] lp (fun _ : R => ℂ) 2) + (T : H →L[ℂ] H) (a : lp (fun _ : Q => ℂ) 2) (h : H) : + amplifyFiber O T (fiberTensorEquiv (a ⊗ₜ[ℂ] h)) = + fiberTensorEquiv (O a ⊗ₜ[ℂ] T h) := by + change fiberTensorEquiv (TensorProduct.mapL O T + (fiberTensorEquiv.symm (fiberTensorEquiv (a ⊗ₜ[ℂ] h)))) = _ + rw [LinearIsometryEquiv.symm_apply_apply, TensorProduct.mapL_tmul] + +theorem amplifyFiber_single (O : lp (fun _ : Q => ℂ) 2 →L[ℂ] lp (fun _ : R => ℂ) 2) + (T : H →L[ℂ] H) (q : Q) (r : R) (h : H) : + amplifyFiber O T (lp.single 2 q h) r = O (lp.single 2 q 1) r • T h := by + rw [← fiberTensor_single, amplifyFiber_tensor] + rfl + +theorem amplifyFiber_constant (O : lp (fun _ : Q => ℂ) 2 →L[ℂ] lp (fun _ : R => ℂ) 2) + (T : H →L[ℂ] H) + (hO : O (fiberConstant Q (1 : ℂ)) = fiberConstant R (1 : ℂ)) (h : H) : + amplifyFiber O T (fiberConstant Q h) = fiberConstant R (T h) := by + rw [← fiberTensor_constant, amplifyFiber_tensor, hO, fiberTensor_constant] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ToeplitzCompression.lean b/lean/OAI/Topology/CoarseAssembly/ToeplitzCompression.lean new file mode 100644 index 0000000000000000000000000000000000000000..22302db18e57d54aeb8471c83c4aaacd49790c13 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ToeplitzCompression.lean @@ -0,0 +1,86 @@ +import OAI.Topology.CoarseAssembly.FredholmParametrix + +namespace OAI + +/-! # Fredholmness of scalar-unitary Toeplitz compressions -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +def toeplitzCompression (P U : End H) : End H := P * U * P + (1 - P) + +theorem toeplitzCompression_star (P U : End H) (hP : IsSelfAdjoint P) : + star (toeplitzCompression P U) = toeplitzCompression P (star U) := by + simp only [toeplitzCompression, star_add, star_mul, star_sub, star_one, hP.star_eq, mul_assoc] + +theorem toeplitzCompression_mul (P U V : End H) (hP : P * P = P) : + toeplitzCompression P U * toeplitzCompression P V = P * U * P * V * P + (1 - P) := by + have hright (A : End H) : A * P * P = A * P := by rw [mul_assoc, hP] + simp only [toeplitzCompression, mul_add, add_mul, mul_sub, sub_mul, one_mul, mul_one, + ← mul_assoc, hright, hP] + abel + +theorem toeplitzCompression_left_defect (P U : End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) (hU : star U * U = 1) : + star (toeplitzCompression P U) * toeplitzCompression P U - 1 = + P * star U * (P * U - U * P) * P := by + rw [toeplitzCompression_star P U hP, toeplitzCompression_mul P (star U) U hPP] + have he : P * star U * U * P * P = P := by + rw [mul_assoc P (star U) U, hU, mul_one, hPP, hPP] + simp only [mul_sub, sub_mul, ← mul_assoc, he] + abel + +theorem toeplitzCompression_compact_defects (P U : End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) (hUl : star U * U = 1) (hUr : U * star U = 1) + (hcomm : IsCompactOperator (P * U - U * P : End H)) : + IsCompactOperator (star (toeplitzCompression P U) * toeplitzCompression P U - 1 : End H) ∧ + IsCompactOperator (toeplitzCompression P U * star (toeplitzCompression P U) - 1 : End H) := by + have hcommStar : IsCompactOperator (P * star U - star U * P : End H) := by + have he : P * star U - star U * P = -(star U * (P * U - U * P) * star U) := by + symm + calc + _ = -(star U * P * (U * star U) - (star U * U) * P * star U) := by noncomm_ring + _ = _ := by rw [hUr, hUl]; noncomm_ring + rw [he] + exact (compact_mul_right (compact_mul_left hcomm (star U)) (star U)).neg + constructor + · rw [toeplitzCompression_left_defect P U hP hPP hUl] + exact compact_mul_right (compact_mul_left hcomm (P * star U)) P + · have he := toeplitzCompression_left_defect P (star U) hP hPP (by simpa only [star_star] using hUr) + rw [star_star, ← toeplitzCompression_star P U hP, star_star] at he + rw [he] + exact compact_mul_right (compact_mul_left hcommStar (P * U)) P + +theorem toeplitzCompression_fredholm (P U : End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) (hUl : star U * U = 1) (hUr : U * star U = 1) + (hcomm : IsCompactOperator (P * U - U * P : End H)) : + (toeplitzCompression P U).IsFredholm := by + obtain ⟨hl, hr⟩ := toeplitzCompression_compact_defects P U hP hPP hUl hUr hcomm + exact isFredholm_of_compact_essential_unitary _ hl hr + +theorem toeplitzCompression_unitary (P U : End H) (hP : IsSelfAdjoint P) + (hPP : P * P = P) (hUl : star U * U = 1) (hUr : U * star U = 1) + (hcomm : Commute P U) : + star (toeplitzCompression P U) * toeplitzCompression P U = 1 ∧ + toeplitzCompression P U * star (toeplitzCompression P U) = 1 := by + have hc : P * U - U * P = 0 := sub_eq_zero.mpr hcomm.eq + have hcs : P * star U - star U * P = 0 := by + apply sub_eq_zero.mpr + simpa only [star_mul, hP.star_eq] using (congrArg star hcomm.eq).symm + constructor + · apply sub_eq_zero.mp + rw [toeplitzCompression_left_defect P U hP hPP hUl, hc, mul_zero, zero_mul] + · apply sub_eq_zero.mp + have he := toeplitzCompression_left_defect P (star U) hP hPP + (by simpa only [star_star] using hUr) + rw [star_star, ← toeplitzCompression_star P U hP, star_star, hcs, mul_zero, zero_mul] at he + exact he + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/ToeplitzProductIndex.lean b/lean/OAI/Topology/CoarseAssembly/ToeplitzProductIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..40959c4ff2aa2f68c2920f499c0d836a29eee73e --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/ToeplitzProductIndex.lean @@ -0,0 +1,85 @@ +import OAI.Topology.CoarseAssembly.EssentialToeplitz + +namespace OAI + +/-! # Multiplicativity of Toeplitz compression modulo compact operators -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem compact_commutator_mul (P U V : End H) + (hU : IsCompactOperator (P * U - U * P : End H)) + (hV : IsCompactOperator (P * V - V * P : End H)) : + IsCompactOperator (P * (U * V) - (U * V) * P : End H) := by + have he : P * (U * V) - (U * V) * P = (P * U - U * P) * V + U * (P * V - V * P) := by + noncomm_ring + rw [he] + exact (compact_mul_right hU V).add (compact_mul_left hV U) + +theorem compact_commutator_star_unitary (P U : End H) + (hul : star U * U = 1) (hur : U * star U = 1) + (hU : IsCompactOperator (P * U - U * P : End H)) : + IsCompactOperator (P * star U - star U * P : End H) := by + have he : P * star U - star U * P = -(star U * (P * U - U * P) * star U) := by + calc + _ = -(star U * P * (U * star U) - (star U * U) * P * star U) := by rw [hul, hur]; noncomm_ring + _ = _ := by noncomm_ring + rw [he] + exact (compact_mul_right (compact_mul_left hU (star U)) (star U)).neg + +theorem toeplitzCompression_product_difference (P U V : End H) (hPP : P * P = P) : + toeplitzCompression P U * toeplitzCompression P V - toeplitzCompression P (U * V) = + P * U * (P * V - V * P) * P := by + rw [toeplitzCompression_mul P U V hPP] + have hlast : P * U * V * P * P = P * U * V * P := by rw [mul_assoc (P * U * V), hPP] + simp only [toeplitzCompression, mul_sub, sub_mul, ← mul_assoc, hlast] + abel + +theorem toeplitzCompression_product_compact (P U V : End H) (hPP : P * P = P) + (hV : IsCompactOperator (P * V - V * P : End H)) : + IsCompactOperator (toeplitzCompression P U * toeplitzCompression P V - + toeplitzCompression P (U * V) : End H) := by + rw [toeplitzCompression_product_difference P U V hPP] + exact compact_mul_right (compact_mul_left hV (P * U)) P + +theorem toeplitzCompression_index_mul (P U V : End H) (hP : IsSelfAdjoint P) (hPP : P * P = P) + (hUl : star U * U = 1) (hUr : U * star U = 1) + (hVl : star V * V = 1) (hVr : V * star V = 1) + (hU : IsCompactOperator (P * U - U * P : End H)) + (hV : IsCompactOperator (P * V - V * P : End H)) : + (toeplitzCompression P (U * V)).toLinearMap.index = + (toeplitzCompression P U).toLinearMap.index + (toeplitzCompression P V).toLinearMap.index := by + have hUVl : star (U * V) * (U * V) = 1 := by + calc + _ = star V * (star U * U) * V := by rw [star_mul]; noncomm_ring + _ = 1 := by rw [hUl, mul_one, hVl] + have hUVr : (U * V) * star (U * V) = 1 := by + calc + _ = U * (V * star V) * star U := by rw [star_mul]; noncomm_ring + _ = 1 := by rw [hVr, mul_one, hUr] + have hUV := compact_commutator_mul P U V hU hV + obtain ⟨hl, hr⟩ := toeplitzCompression_compact_defects P (U * V) hP hPP hUVl hUVr hUV + have hK := toeplitzCompression_product_compact P U V hPP hV + have hKs : IsCompactOperator (star (toeplitzCompression P U * toeplitzCompression P V - + toeplitzCompression P (U * V)) : End H) := by + rw [star_sub, star_mul, toeplitzCompression_star P U hP, + toeplitzCompression_star P V hP, toeplitzCompression_star P (U * V) hP, star_mul] + exact toeplitzCompression_product_compact P (star V) (star U) hPP + (compact_commutator_star_unitary P U hUl hUr hU) + have hi := fredholmIndex_compactPerturb (toeplitzCompression P (U * V)) + (toeplitzCompression P U * toeplitzCompression P V - toeplitzCompression P (U * V)) hl hr hK hKs + have he : toeplitzCompression P (U * V) + + (toeplitzCompression P U * toeplitzCompression P V - toeplitzCompression P (U * V)) = + toeplitzCompression P U * toeplitzCompression P V := by abel + rw [he] at hi + exact hi.trans ((toeplitzCompression_fredholm P U hP hPP hUl hUr hU).index_comp + (toeplitzCompression_fredholm P V hP hPP hVl hVr hV)) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/TopologicalK1.lean b/lean/OAI/Topology/CoarseAssembly/TopologicalK1.lean new file mode 100644 index 0000000000000000000000000000000000000000..08d5e717dd8f6227e6010b401080da0f8e79a78f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/TopologicalK1.lean @@ -0,0 +1,119 @@ +import OAI.Topology.CoarseAssembly.Definitions +import Mathlib.Topology.Instances.Matrix +import Mathlib.Topology.Algebra.Group.Units +import Mathlib.Data.Matrix.Block +import Mathlib.Analysis.CStarAlgebra.Unitization +import OAI.Topology.CoarseAssembly.FredholmModule + +namespace OAI + +/-! +# Topological K₁ from stable invertible matrices + +The unital group is presented by invertible finite matrices, with the actual +matrix-product, stabilization and continuous-path relations. The nonunital +group will be the kernel of the scalar-quotient map on the unitization. +These definitions keep the analytic assembly target tied to its algebra. +-/ + +noncomputable section + +namespace CoarseAssembly.TopologicalK1 + +open CoarseAssembly.Analytic (Interval start finish) + +universe u v w + +variable (R : Type u) [Ring R] [TopologicalSpace R] + +variable {R} + +theorem relation_zero {z : FreeAbelianGroup (StableGL R)} (h : Relation R z) : + (QuotientAddGroup.mk z : Group R) = 0 := + (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h) + +theorem matrixClass_mul {n : ℕ} (g h : InvertibleMatrix R n) : + matrixClass R (g * h) = matrixClass R g + matrixClass R h := by + apply sub_eq_zero.mp + simpa only [matrixClass, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using + relation_zero (.mul g h) + +theorem matrixClass_stabilize {n : ℕ} (g : InvertibleMatrix R n) (h : InvertibleMatrix R (n + 1)) + (hs : IsStabilization R g h) : matrixClass R g = matrixClass R h := by + apply sub_eq_zero.mp + simpa only [matrixClass, QuotientAddGroup.mk_sub] using relation_zero (.stabilize g h hs) + +theorem matrixClass_homotopy {n : ℕ} (c : Interval → InvertibleMatrix R n) (hc : Continuous c) : + matrixClass R (c start) = matrixClass R (c finish) := by + apply sub_eq_zero.mp + simpa only [matrixClass, QuotientAddGroup.mk_sub] using relation_zero (.homotopy c hc) + +@[simp] theorem matrixClass_one (n : ℕ) : matrixClass R (1 : InvertibleMatrix R n) = 0 := by + have h := matrixClass_mul (1 : InvertibleMatrix R n) 1 + simp only [one_mul] at h + exact (add_left_cancel ((add_zero _).trans h)).symm + +variable {S : Type v} {T : Type w} [Ring S] [TopologicalSpace S] [Ring T] [TopologicalSpace T] + +theorem continuous_mapGL (φ : R →+* S) (hφ : Continuous φ) (n : ℕ) : + Continuous (mapGL φ n) := by + apply Continuous.units_map + exact continuous_pi (fun i => continuous_pi (fun j => + hφ.comp ((continuous_apply j).comp (continuous_apply i)))) + +omit [TopologicalSpace R] [TopologicalSpace S] in +theorem mapGL_stabilize (φ : R →+* S) {n : ℕ} (g : InvertibleMatrix R n) (h : InvertibleMatrix R (n + 1)) + (hs : IsStabilization R g h) : IsStabilization S (mapGL φ n g) (mapGL φ (n + 1) h) := by + have heq := congrArg (fun M => Matrix.map M φ) hs + simpa [IsStabilization, mapGL, Matrix.fromBlocks_map, Matrix.submatrix_map] using heq + +theorem mapFree_relation (φ : R →+* S) (hφ : Continuous φ) + {z : FreeAbelianGroup (StableGL R)} (hz : Relation R z) : mapFree φ z = 0 := by + cases hz with + | mul g h => + simpa [mapFree] using sub_eq_zero.mpr (matrixClass_mul (mapGL φ _ g) (mapGL φ _ h)) + | stabilize g h hs => + simpa [mapFree] using sub_eq_zero.mpr + (matrixClass_stabilize _ _ (mapGL_stabilize φ g h hs)) + | homotopy c hc => + simpa [mapFree] using sub_eq_zero.mpr + (matrixClass_homotopy (fun t => mapGL φ _ (c t)) ((continuous_mapGL φ hφ _).comp hc)) + +@[simp] theorem map_matrixClass (φ : R →+* S) (hφ : Continuous φ) {n : ℕ} (g : InvertibleMatrix R n) : + map φ hφ (matrixClass R g) = matrixClass S (mapGL φ n g) := + FreeAbelianGroup.lift_apply_of _ _ + +theorem hom_ext {D : Type*} [AddCommGroup D] (f g : Group R →+ D) + (h : ∀ n (a : InvertibleMatrix R n), f (matrixClass R a) = g (matrixClass R a)) : f = g := by + apply QuotientAddGroup.addMonoidHom_ext + apply FreeAbelianGroup.lift_ext + rintro ⟨n, a⟩ + exact h n a + +omit [TopologicalSpace R] in +@[simp] theorem mapGL_id {n : ℕ} (g : InvertibleMatrix R n) : mapGL (RingHom.id R) n g = g := by + apply Units.ext + rfl + +@[simp] theorem map_id : map (RingHom.id R) continuous_id = AddMonoidHom.id (Group R) := by + apply hom_ext + intro n a + simp + +omit [TopologicalSpace R] [TopologicalSpace S] [TopologicalSpace T] in +theorem mapGL_comp (φ : R →+* S) (ψ : S →+* T) {n : ℕ} (g : InvertibleMatrix R n) : + mapGL (ψ.comp φ) n g = mapGL ψ n (mapGL φ n g) := by + apply Units.ext + rfl + +theorem map_comp (φ : R →+* S) (ψ : S →+* T) (hφ : Continuous φ) (hψ : Continuous ψ) : + map (ψ.comp φ) (hψ.comp hφ) = (map ψ hψ).comp (map φ hφ) := by + apply hom_ext + intro n a + simp [mapGL_comp] + +end CoarseAssembly.TopologicalK1 + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/TraceObstruction.lean b/lean/OAI/Topology/CoarseAssembly/TraceObstruction.lean new file mode 100644 index 0000000000000000000000000000000000000000..50c6571264a6ee2e94e9f7133b25effb7f561374 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/TraceObstruction.lean @@ -0,0 +1,73 @@ +import OAI.Topology.CoarseAssembly.CongruenceQuotients +import OAI.Topology.CoarseAssembly.TraceSeparation +import OAI.Topology.CoarseAssembly.Holonomy + +namespace OAI + +/-! +# Matrix trace separation in the congruence quotients + +The elementary p-adic separation result is connected here to the actual +`SL₃` matrices and to the closed-walk holonomy identity. +-/ + +namespace CoarseAssembly.Congruence + +/-- The finite matrix trace is the reduction of the p-adic Laurent trace. -/ +theorem trace_holonomy_pow (t : ℤ_[2]ˣ) (k m : ℕ) : + Matrix.trace ((holonomy t k ^ m : Quotient k) : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) = + PadicInt.toZModPow k (diagonalTrace t m) := by + rw [holonomy, trace_diagonal_pow] + simp [diagonalTrace] + +/-- The two nontrivial diagonal entries are exchanged when the charge is +negated, so the trace only depends on its absolute value. -/ +theorem trace_holonomy_natAbs (t : ℤ_[2]ˣ) (k : ℕ) (m : ℤ) : + Matrix.trace ((holonomy t k ^ m : Quotient k) : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) = + Matrix.trace ((holonomy t k ^ m.natAbs : Quotient k) : + Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) := by + cases m with + | ofNat n => + exact congrArg + (fun q : Quotient k => Matrix.trace (q : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k)))) + (zpow_natCast (holonomy t k) n) + | negSucc n => + change Matrix.trace ((holonomy t k ^ (-((n + 1 : ℕ) : ℤ)) : Quotient k) : + Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) = _ + calc + _ = Matrix.trace ((holonomy t k ^ (((n + 1 : ℕ) : ℤ)) : Quotient k) : + Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) := + trace_diagonal_neg _ _ + _ = _ := congrArg + (fun q : Quotient k => Matrix.trace (q : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k)))) + (zpow_natCast (holonomy t k) (n + 1)) + +/-- Simultaneous trace separation from a finite set of integral word traces, +now stated for the actual finite special linear groups. -/ +theorem matrix_trace_separation (t : ℤ_[2]ˣ) + (ht : Transcendental ℤ (t : ℤ_[2])) (A : ℕ) (traces : Finset ℤ) : + ∃ N : ℕ, 1 ≤ N ∧ ∀ k, N ≤ k → ∀ m ∈ Finset.Icc 1 A, + ∀ w : ArithmeticGroup, Matrix.trace (w : Matrix (Fin 3) (Fin 3) ℤ) ∈ traces → + Matrix.trace ((holonomy t k ^ m : Quotient k) : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) ≠ + Matrix.trace (reduce k w : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) := by + obtain ⟨N, hN, hsep⟩ := finite_trace_separation t ht A traces + refine ⟨N, hN, ?_⟩ + intro k hk m hm w hw + rw [trace_holonomy_pow, trace_reduce] + exact hsep k hk m hm _ hw + +/-- A closed word in a finite quotient forces equality of the concrete +matrix traces. This is the contradiction paired with separation above. -/ +theorem closed_walk_trace (t : ℤ_[2]ˣ) (k : ℕ) (z : Quotient k) + (steps : List (Quotient k × ℤ)) + (hclosed : holonomyEndpoint (holonomy t k) steps z = z) : + Matrix.trace ((holonomy t k ^ holonomyCharge steps : Quotient k) : + Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) = + Matrix.trace (((holonomyWord steps)⁻¹ : Quotient k) : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k))) := + holonomy_invariant_eq + (fun q : Quotient k => Matrix.trace (q : Matrix (Fin 3) (Fin 3) (ZMod (2 ^ k)))) + (fun q z => trace_conjugate q z) (holonomy t k) z steps hclosed + +end CoarseAssembly.Congruence + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/TraceSeparation.lean b/lean/OAI/Topology/CoarseAssembly/TraceSeparation.lean new file mode 100644 index 0000000000000000000000000000000000000000..c86eea95e517c640c1b0857bbc18970a2815cb30 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/TraceSeparation.lean @@ -0,0 +1,112 @@ +import Mathlib.NumberTheory.Padics.RingHoms +import Mathlib.RingTheory.Algebraic.Basic +import Mathlib.Tactic.LinearCombination + +namespace OAI + +/-! +# Trace separation for the congruence-fiber construction + +These are elementary ingredients of Lemma 3.1 of *A counterexample to the +coarse Novikov conjecture* (September 23, 2026). No analytic index theorem or +property (T) is assumed here. The actual reduction maps are the existing +`PadicInt.toZModPow` maps. +-/ + +namespace CoarseAssembly + +section LaurentTrace + +variable {R : Type*} [CommRing R] + +/-- The trace of `diag(t^n,t^(-n),1)`, expressed using a unit so that the +inverse is available in an arbitrary commutative ring. -/ +def diagonalTrace (t : Rˣ) (n : ℕ) : R := + (t ^ n : Rˣ) + ((t ^ n)⁻¹ : Rˣ) + 1 + +/-- An integral trace would make the positive power of the unit a root of +`X² + (1-c)X + 1`. Thus a transcendental unit has no such trace. -/ +theorem diagonalTrace_ne_int (t : Rˣ) (ht : Transcendental ℤ (t : R)) + {n : ℕ} (hn : 0 < n) (c : ℤ) : diagonalTrace t n ≠ (c : R) := by + intro h + let y : R := (t ^ n : Rˣ) + let z : R := ((t ^ n)⁻¹ : Rˣ) + have hyz : y * z = 1 := Units.mul_inv (t ^ n) + have heq : y + z + 1 = (c : R) := h + have hmul := congrArg (fun a : R => a * y) heq + have hroot : y ^ 2 + (1 - (c : R)) * y + 1 = 0 := by + linear_combination hmul - hyz + let f : Polynomial ℤ := Polynomial.X ^ 2 + Polynomial.C (1 - c) * Polynomial.X + 1 + have htrans : Transcendental ℤ y := by + simpa [y] using ht.pow hn + have hf : Polynomial.aeval y f = 0 := by + simpa [f] using hroot + have hfzero : f = 0 := (transcendental_iff.mp htrans) f hf + have hcoeff := congrArg (fun q : Polynomial ℤ => q.coeff 0) hfzero + simp [f] at hcoeff + +end LaurentTrace + +section FiniteReduction + +variable {p : ℕ} [Fact p.Prime] + +/-- Once two p-adic integers differ modulo `p^m`, they differ at every +deeper level. This is the compatibility needed by the short-loop argument. -/ +theorem reduction_ne_of_le {x y : ℤ_[p]} {m n : ℕ} (hmn : m ≤ n) + (hxy : PadicInt.toZModPow m x ≠ PadicInt.toZModPow m y) : + PadicInt.toZModPow n x ≠ PadicInt.toZModPow n y := by + intro h + apply hxy + rw [← PadicInt.cast_toZModPow m n hmn x, ← PadicInt.cast_toZModPow m n hmn y, h] + +/-- Distinct p-adic integers are separated by some finite quotient. -/ +theorem exists_reduction_ne {x y : ℤ_[p]} (hxy : x ≠ y) : + ∃ n : ℕ, PadicInt.toZModPow n x ≠ PadicInt.toZModPow n y := by + by_contra h + apply hxy + exact PadicInt.ext_of_toZModPow.mp (by simpa only [not_exists, not_not] using h) + +/-- A finite collection of unequal p-adic pairs has one common positive +level above which every pair remains separated. -/ +theorem finite_uniform_reduction_separation {ι : Type*} (s : Finset ι) + (x y : ι → ℤ_[p]) (hxy : ∀ i ∈ s, x i ≠ y i) : + ∃ N : ℕ, 1 ≤ N ∧ ∀ n, N ≤ n → ∀ i ∈ s, + PadicInt.toZModPow n (x i) ≠ PadicInt.toZModPow n (y i) := by + classical + induction s using Finset.induction_on with + | empty => exact ⟨1, le_rfl, by simp⟩ + | @insert i s his ih => + obtain ⟨N, hN, hs⟩ := ih (fun j hj => hxy j (Finset.mem_insert_of_mem hj)) + obtain ⟨m, hm⟩ := exists_reduction_ne (hxy i (Finset.mem_insert_self _ _)) + refine ⟨max N m, hN.trans (le_max_left _ _), ?_⟩ + intro n hn j hj + rcases Finset.mem_insert.mp hj with rfl | hj + · exact reduction_ne_of_le ((le_max_right _ _).trans hn) hm + · exact hs n ((le_max_left _ _).trans hn) j hj + +/-- The specialization used in the paper: for finitely many integral word +traces and a bounded positive exponent, every sufficiently deep congruence +quotient separates the diagonal holonomy trace from all the word traces. + +For a nonzero signed charge, use its positive absolute value; the diagonal +trace is unchanged by reversing the sign. -/ +theorem finite_trace_separation (t : ℤ_[p]ˣ) + (ht : Transcendental ℤ (t : ℤ_[p])) (A : ℕ) (traces : Finset ℤ) : + ∃ N : ℕ, 1 ≤ N ∧ ∀ n, N ≤ n → ∀ m ∈ Finset.Icc 1 A, ∀ c ∈ traces, + PadicInt.toZModPow n (diagonalTrace t m) ≠ (c : ZMod (p ^ n)) := by + obtain ⟨N, hN, hsep⟩ := finite_uniform_reduction_separation + ((Finset.Icc 1 A).product traces) + (fun q => diagonalTrace t q.1) (fun q => (q.2 : ℤ_[p])) (by + intro q hq + have hqm := (Finset.mem_product.mp hq).1 + exact diagonalTrace_ne_int t ht (Finset.mem_Icc.mp hqm).1 q.2) + refine ⟨N, hN, ?_⟩ + intro n hn m hm c hc + simpa only [map_intCast] using hsep n hn (m, c) (Finset.mem_product.mpr ⟨hm, hc⟩) + +end FiniteReduction + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/TranscendentalUnit.lean b/lean/OAI/Topology/CoarseAssembly/TranscendentalUnit.lean new file mode 100644 index 0000000000000000000000000000000000000000..c1f8aca32c8b633a8dead1b8cff4eaf793ee0636 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/TranscendentalUnit.lean @@ -0,0 +1,65 @@ +import Mathlib.Algebra.AlgebraicCard +import Mathlib.NumberTheory.Padics.RingHoms +import Mathlib.Topology.Algebra.Module.PerfectSpace +import Mathlib.Topology.Baire.CompleteMetrizable +import Mathlib.Tactic.LinearCombination + +namespace OAI + +/-! +# A transcendental principal p-adic unit + +The holonomy construction chooses a transcendental element of `1 + 2ℤ₂`. +The existence proof below works for every prime: algebraic elements form a +countable set, and the Baire theorem makes its complement dense in the +complete, perfect p-adic field. +-/ + +namespace CoarseAssembly + +open Set + +variable {p : ℕ} [Fact p.Prime] + +/-- Transcendental elements over the integers are dense in the p-adic field. -/ +theorem dense_padic_transcendental : Dense {x : ℚ_[p] | Transcendental ℤ x} := by + have hcount : Set.Countable {x : ℚ_[p] | IsAlgebraic ℤ x} := + Algebraic.countable ℤ ℚ_[p] + have hd : Dense (⋂ x ∈ {x : ℚ_[p] | IsAlgebraic ℤ x}, ({x}ᶜ : Set ℚ_[p])) := + dense_biInter_of_isOpen (fun _ _ => isOpen_compl_singleton) hcount + (fun x _ => dense_compl_singleton x) + apply hd.mono + intro x hx hxalg + have hxnot := Set.mem_iInter₂.mp hx x hxalg + exact hxnot (Set.mem_singleton x) + +/-- The exact principal-unit choice needed for diagonal holonomy exists. +The specialization `p = 2` lies in `1 + 2ℤ₂`. -/ +theorem exists_transcendental_principal_unit : + ∃ t : ℤ_[p]ˣ, Transcendental ℤ (t : ℤ_[p]) ∧ + ∃ a : ℤ_[p], (t : ℤ_[p]) = 1 + (p : ℤ_[p]) * a := by + obtain ⟨x, hx, hclose⟩ := + (dense_padic_transcendental (p := p)).exists_dist_lt (1 : ℚ_[p]) zero_lt_one + have hnear : ‖x - 1‖ < 1 := by + simpa only [dist_eq_norm, norm_sub_rev] using hclose + have hxnorm : ‖x‖ = 1 := by + simpa only [norm_one] using Padic.norm_eq_of_norm_sub_lt_right + (show ‖x - 1‖ < ‖(1 : ℚ_[p])‖ by simpa using hnear) + let z : ℤ_[p] := ⟨x, hxnorm.le⟩ + have hznorm : ‖z‖ = 1 := hxnorm + obtain ⟨t, ht⟩ := PadicInt.isUnit_iff.mpr hznorm + refine ⟨t, ?_, ?_⟩ + · rw [ht] + intro hzalg + let f : ℤ_[p] →ₐ[ℤ] ℚ_[p] := + { PadicInt.Coe.ringHom with commutes' := fun n => by simp } + exact hx (hzalg.algHom f) + · have hzclose : ‖z - 1‖ < 1 := hnear + obtain ⟨a, ha⟩ := (PadicInt.norm_lt_one_iff_dvd (z - 1)).mp hzclose + refine ⟨a, ?_⟩ + rw [ht] + linear_combination ha + +end CoarseAssembly + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/TransferCriterion.lean b/lean/OAI/Topology/CoarseAssembly/TransferCriterion.lean new file mode 100644 index 0000000000000000000000000000000000000000..d970c99ee21c2f30a12a02efd3e54dd1f7aeeec7 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/TransferCriterion.lean @@ -0,0 +1,96 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.TensorFibers +import OAI.Topology.CoarseAssembly.TransferLift +import OAI.Topology.CoarseAssembly.RoeTransfer + +namespace OAI + +/-! # The finite-fiber Roe transfer criterion + +This proves the operator statement of Proposition 5.1. The required +finite-propagation scalar contractions between fibers are amplified here; +the bounded lift, compactness and compression are constructed, not assumed. +The concrete graph family still has to supply these fiber contractions and +the averaging approximants. +-/ + +noncomputable section + +namespace CoarseAssembly + +open DiscreteRoe +open scoped Topology + +variable {D : Type*} [DecidableEq D] [PseudoMetricSpace D] + +variable {Q : D → Type*} [∀ u, Fintype (Q u)] [∀ u, Nonempty (Q u)] +variable [∀ u, DecidableEq (Q u)] [PseudoMetricSpace (Sigma Q)] +variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +/-- Uniform controlled scalar maps preserving the normalized constants. -/ +def ControlledFiberMaps (Q : D → Type*) [∀ u, Fintype (Q u)] + [∀ u, DecidableEq (Q u)] [PseudoMetricSpace (Sigma Q)] : Prop := + ∀ R : ℝ, 0 ≤ R → ∃ s : ℝ, 0 ≤ s ∧ + ∃ O : ∀ u v, lp (fun _ : Q v => ℂ) 2 →L[ℂ] lp (fun _ : Q u => ℂ) 2, + ∀ u v, dist u v ≤ R → + ‖O u v‖ ≤ 1 ∧ O u v (fiberConstant (Q v) (1 : ℂ)) = fiberConstant (Q u) 1 ∧ + ∀ q r, s < dist (⟨u, q⟩ : Sigma Q) ⟨v, r⟩ → O u v (lp.single 2 r 1) q = 0 + +theorem lift_generator_from_fiber_maps (hD : UniformFiniteBalls D) + (hO : ControlledFiberMaps Q) (T : Operator D H) (hT : Generator T) : + ∃ A : Operator (Sigma Q) H, Generator A ∧ + fiberProjection Q * A * fiberProjection Q = operatorConjugation (fiberEmbedding Q) T := by + obtain ⟨R, hR, hpropT⟩ := hT.1 + obtain ⟨N, hballs⟩ := hD R hR + let rows : D → Finset D := fun u => (hballs u).choose + have hmem (u v : D) : v ∈ rows u ↔ dist u v ≤ R := (hballs u).choose_spec.1 v + have hcard (u : D) : (rows u).card ≤ N := (hballs u).choose_spec.2 + have hdual (u v : D) : v ∈ rows u ↔ u ∈ rows v := by + rw [hmem, hmem, dist_comm] + obtain ⟨s, hs, O, hO⟩ := hO R hR + let B := fun u v => amplifyFiber (O u v) (entry T u v) + have hB (u v : D) (huv : v ∈ rows u) : ‖B u v‖ ≤ ‖T‖ := by + calc + _ ≤ ‖O u v‖ * ‖entry T u v‖ := amplifyFiber_norm_le _ _ + _ ≤ 1 * ‖T‖ := mul_le_mul (hO u v ((hmem u v).mp huv)).1 + (entry_norm_le T u v) (norm_nonneg _) zero_le_one + _ = _ := one_mul _ + let A := spatialBlocks rows rows hdual B N ‖T‖ (norm_nonneg T) hcard hcard hB + refine ⟨A, ?_, ?_⟩ + · apply spatialBlocks_generator rows rows hdual B N ‖T‖ (norm_nonneg T) hcard hcard hB T hT s hs + · intro u v huv q r hdist + apply ContinuousLinearMap.ext + intro h + change amplifyFiber (O u v) (entry T u v) (lp.single 2 r h) q = 0 + rw [amplifyFiber_single, (hO u v ((hmem u v).mp huv)).2.2 q r hdist, zero_smul] + · intro u v huv q r + refine ⟨O u v (lp.single 2 r 1) q, ?_⟩ + apply ContinuousLinearMap.ext + intro h + exact amplifyFiber_single (O u v) (entry T u v) r q h + · apply spatialBlocks_compression rows rows hdual B N ‖T‖ (norm_nonneg T) hcard hcard hB T + · intro u v huv + exact hpropT u v (lt_of_not_ge (fun h => huv ((hmem u v).mpr h))) + · intro u v huv h + exact amplifyFiber_constant (O u v) (entry T u v) + (hO u v ((hmem u v).mp huv)).2.1 h + +/-- The finite-fiber transfer lands in the ordinary locally compact reduced +Roe algebra. The approximation is an operator-norm approximation of the +amplified projection; the projection itself need not be locally compact. -/ +theorem finite_fiber_transfer (hD : UniformFiniteBalls D) + (hX : ∀ x : Sigma Q, ∀ r : ℝ, (Metric.closedBall x r).Finite) + (hO : ControlledFiberMaps Q) + (Pn : ℕ → Operator (Sigma Q) H) + (hlim : Filter.Tendsto Pn Filter.atTop (nhds (fiberProjection Q))) + (hprop : ∀ n, ∃ r : ℝ, 0 ≤ r ∧ PropagationLE r (Pn n)) : + MapsToRoe (fiberEmbedding (H := H) Q) := by + intro T hT + apply conjugation_mem_of_sandwich_lifts hX (fiberEmbedding Q) (fiberProjection Q) Pn hlim hprop + (fun T hT => lift_generator_from_fiber_maps hD hO T hT) hT + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/TransferLift.lean b/lean/OAI/Topology/CoarseAssembly/TransferLift.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e4fbe6a796689deca85d5166781ea8f74c7af84 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/TransferLift.lean @@ -0,0 +1,141 @@ +import OAI.Topology.CoarseAssembly.SpatialBlocks +import OAI.Topology.CoarseAssembly.RoeRows + +namespace OAI + +/-! # The controlled lift and its exact compression + +The lift is constructed as a bounded block matrix. Its scalar coefficient +condition proves local compactness, while preservation of constant-fiber +vectors proves the compression identity. These are explicit construction +conditions, not published hypotheses for the main result. +-/ + +noncomputable section + +namespace CoarseAssembly + +open DiscreteRoe + +variable {I : Type*} {Q : I → Type*} {H : Type*} +variable [DecidableEq I] [∀ i, DecidableEq (Q i)] +variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +def fiberBlockEntry {i j : I} + (B : lp (fun _ : Q j => H) 2 →L[ℂ] lp (fun _ : Q i => H) 2) + (q : Q i) (r : Q j) : H →L[ℂ] H := + (lp.evalCLM ℂ (fun _ : Q i => H) 2 q).comp + (B.comp (lp.singleContinuousLinearMap ℂ (fun _ : Q j => H) 2 r)) + +variable (rows cols : I → Finset I) (hdual : ∀ i j, j ∈ rows i ↔ i ∈ cols j) +variable (B : ∀ i j, lp (fun _ : Q j => H) 2 →L[ℂ] lp (fun _ : Q i => H) 2) +variable (N : ℕ) (C : ℝ) (hC : 0 ≤ C) +variable (hr : ∀ i, (rows i).card ≤ N) (hc : ∀ i, (cols i).card ≤ N) +variable (hB : ∀ i j, j ∈ rows i → ‖B i j‖ ≤ C) + +local notation "Aₗ" => spatialBlocks rows cols hdual B N C hC hr hc hB + +omit [CompleteSpace H] in +theorem spatialBlocks_entry (i j : I) (q : Q i) (r : Q j) : + entry Aₗ ⟨i, q⟩ ⟨j, r⟩ = if j ∈ rows i then fiberBlockEntry (B i j) q r else 0 := by + apply ContinuousLinearMap.ext + intro h + rw [entry_apply] + rw [spatialBlocks_single] + split_ifs <;> rfl + +section Metric + +variable [PseudoMetricSpace I] [PseudoMetricSpace (Sigma Q)] + +theorem spatialBlocks_generator (T : Operator I H) (hT : Generator T) + (s : ℝ) (hs : 0 ≤ s) + (hprop : ∀ i j, j ∈ rows i → ∀ q r, s < dist (⟨i, q⟩ : Sigma Q) ⟨j, r⟩ → + fiberBlockEntry (B i j) q r = 0) + (hscalar : ∀ i j, j ∈ rows i → ∀ q r, ∃ c : ℂ, + fiberBlockEntry (B i j) q r = c • entry T i j) : Generator Aₗ := by + refine ⟨⟨s, hs, ?_⟩, ?_, ?_⟩ + · intro x y hxy + rcases x with ⟨i, q⟩ + rcases y with ⟨j, r⟩ + rw [spatialBlocks_entry] + split_ifs with hij + · exact hprop i j hij q r hxy + · rfl + · intro x y + rcases x with ⟨i, q⟩ + rcases y with ⟨j, r⟩ + rw [spatialBlocks_entry] + split_ifs with hij + · obtain ⟨c, hcoeff⟩ := hscalar i j hij q r + rw [hcoeff] + exact (hT.2.1 i j).smul c + · exact isCompactOperator_zero + · intro x y + rcases x with ⟨i, q⟩ + rcases y with ⟨j, r⟩ + rw [entry_star, spatialBlocks_entry] + split_ifs with hji + · obtain ⟨c, hcoeff⟩ := hscalar j i hji r q + rw [hcoeff, star_smul] + have hcompact := hT.2.2 i j + rw [entry_star] at hcompact + exact hcompact.smul (star c) + · rw [star_zero] + exact isCompactOperator_zero + +end Metric + +section Constants + +variable [∀ i, Fintype (Q i)] [∀ i, Nonempty (Q i)] + +omit [∀ i, DecidableEq (Q i)] [CompleteSpace H] in +theorem spatialBlocks_intertwines (T : Operator I H) + (houtside : ∀ i j, j ∉ rows i → entry T i j = 0) + (hconstant : ∀ i j, j ∈ rows i → ∀ h : H, + B i j (fiberConstant (Q j) h) = fiberConstant (Q i) (entry T i j h)) : + (Aₗ).comp (fiberEmbedding Q).toContinuousLinearMap = + (fiberEmbedding Q).toContinuousLinearMap.comp T := by + apply ContinuousLinearMap.ext + intro x + apply lp.ext + funext y + rcases y with ⟨i, q⟩ + change Aₗ (fiberEmbedding Q x) ⟨i, q⟩ = fiberEmbedding Q (T x) ⟨i, q⟩ + rw [spatialBlocks_apply] + have heq : (∑ j ∈ rows i, B i j (rowVector (fiberEmbedding Q x) j)) = + fiberConstant (Q i) (∑ j ∈ rows i, entry T i j (x j)) := by + calc + _ = ∑ j ∈ rows i, fiberConstant (Q i) (entry T i j (x j)) := by + apply Finset.sum_congr rfl + intro j hj + exact hconstant i j hj (x j) + _ = _ := (map_sum (fiberConstantIsometry (Q i)).toLinearMap _ _).symm + rw [heq, ← finite_row_apply T i (rows i) (houtside i) x] + rfl + +omit [∀ i, DecidableEq (Q i)] in +theorem spatialBlocks_compression (T : Operator I H) + (houtside : ∀ i j, j ∉ rows i → entry T i j = 0) + (hconstant : ∀ i j, j ∈ rows i → ∀ h : H, + B i j (fiberConstant (Q j) h) = fiberConstant (Q i) (entry T i j h)) : + fiberProjection Q * Aₗ * fiberProjection Q = operatorConjugation (fiberEmbedding Q) T := by + have heq := spatialBlocks_intertwines rows cols hdual B N C hC hr hc hB T houtside hconstant + apply ContinuousLinearMap.ext + intro x + have hx := DFunLike.congr_fun heq ((fiberEmbedding Q).toContinuousLinearMap.adjoint x) + change Aₗ (fiberEmbedding Q ((fiberEmbedding Q).toContinuousLinearMap.adjoint x)) = + fiberEmbedding Q (T ((fiberEmbedding Q).toContinuousLinearMap.adjoint x)) at hx + change fiberEmbedding Q ((fiberEmbedding Q).toContinuousLinearMap.adjoint + (Aₗ (fiberEmbedding Q ((fiberEmbedding Q).toContinuousLinearMap.adjoint x)))) = _ + rw [hx, adjoint_apply_isometry] + rfl + +end Constants + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnconditionalConclusion.lean b/lean/OAI/Topology/CoarseAssembly/UnconditionalConclusion.lean new file mode 100644 index 0000000000000000000000000000000000000000..c3f6bc377ceb85cdb366410039a7a5e0d23c6b37 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnconditionalConclusion.lean @@ -0,0 +1,60 @@ +import OAI.Topology.CoarseAssembly.Definitions +import OAI.Topology.CoarseAssembly.CongruenceElementary +import OAI.Topology.CoarseAssembly.ConstructedConclusion + +namespace OAI + +/-! # The unconditional bounded-geometry counterexample + +The geometric construction, analytic assembly, integral spectral certificate +and finite congruence generation are combined here. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Congruence Rips Analytic + +attribute [local instance] OAI.CoarseAssembly.unconditionalConclusionMetric + +theorem provedKazhdanInput : PublishedKazhdanInput := + publishedKazhdanInput_of_elementaryReduction elementaryReduction_surjective + +/-- The constructed ordinary coarse assembly map has an infinite-order +kernel class and fails injectivity both integrally and rationally. -/ +theorem bounded_geometry_counterexample_unconditional : + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ constructedCoarseAssembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective constructedCoarseAssembly ∧ + ¬ Function.Injective (constructedCoarseAssembly.toIntLinearMap.lTensor ℚ) := + bounded_geometry_counterexample_from_gap provedKazhdanInput + +/-- The graph-family clauses of the main theorem, together with the full +coarse-assembly conclusion for its concrete separated union. -/ +theorem bounded_geometry_graph_counterexample_unconditional : + (∀ j, Finite (FiberVertex j) ∧ + (fiberedGraph elementaryMoves chosenHolonomyUnit j).Connected) ∧ + (∃ D : ℕ, ∀ j (x : FiberVertex j), + Nat.card {y // (fiberedGraph elementaryMoves chosenHolonomyUnit j).Adj x y} ≤ D) ∧ + ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧ + (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧ + ∃ α : KX1 VertexUnion, + (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ constructedCoarseAssembly α = 0 ∧ + (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧ + ¬ Function.Injective constructedCoarseAssembly ∧ + ¬ Function.Injective (constructedCoarseAssembly.toIntLinearMap.lTensor ℚ) := by + refine ⟨?_, ?_, bounded_geometry_counterexample_unconditional⟩ + · intro j + exact ⟨inferInstance, fiberedGraph_connected elementaryMoves chosenHolonomyUnit j⟩ + · exact ⟨7 * (symmetricMoves elementaryMoves).card * 2 ^ 9, + fun _ x => card_fibered_neighbors_le elementaryMoves chosenHolonomyUnit x⟩ + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UniformCycleNormalization.lean b/lean/OAI/Topology/CoarseAssembly/UniformCycleNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..1d271ef49d67fea08822292dbb9c608379bdc3e5 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UniformCycleNormalization.lean @@ -0,0 +1,53 @@ +import OAI.Topology.CoarseAssembly.SigmaCycle +import OAI.Topology.CoarseAssembly.RepresentedNormalization + +namespace OAI + +/-! # Uniformly bounded representatives for countable families -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped ZeroAtInfty + +theorem involution_norm_le_one {H : HilbertSpace} (F : End H) + (hself : IsSelfAdjoint F) (hsq : F * F = 1) : ‖F‖ ≤ 1 := by + have he : ‖F‖ ^ 2 = ‖(1 : End H)‖ := by + rw [← hself.norm_mul_self, hsq] + have hi : ‖(1 : End H)‖ ≤ 1 := ContinuousLinearMap.norm_id_le + nlinarith [norm_nonneg F] + +variable {A : Type} [CStarAlgebra A] + +def normalizedCycle (c : OddCycle A) : OddCycle A := + (exists_represented_involutive_representative c).choose + +theorem normalizedCycle_class (c : OddCycle A) : + cycleClass A (normalizedCycle c) = cycleClass A c := + (exists_represented_involutive_representative c).choose_spec.1 + +theorem normalizedCycle_selfAdjoint (c : OddCycle A) : + IsSelfAdjoint (normalizedCycle c).operator := + (exists_represented_involutive_representative c).choose_spec.2.1 + +theorem normalizedCycle_sq (c : OddCycle A) : + (normalizedCycle c).operator * (normalizedCycle c).operator = 1 := + (exists_represented_involutive_representative c).choose_spec.2.2.1 + +theorem normalizedCycle_norm (c : OddCycle A) : ‖(normalizedCycle c).operator‖ ≤ 1 := + involution_norm_le_one _ (normalizedCycle_selfAdjoint c) (normalizedCycle_sq c) + +variable (Y : ℕ → Type) [∀ j, TopologicalSpace (Y j)] [∀ j, CompactSpace (Y j)] + +/-- Actual locally finite cycle for an arbitrary countable family of compact-source cycles. -/ +def normalizedFamilyCycle (c : ∀ j, OddCycle C(Y j, ℂ)) : OddCycle C₀(Sigma Y, ℂ) := + sigmaCycle Y (fun j => normalizedCycle (c j)) 1 (by norm_num) + (fun j => normalizedCycle_norm (c j)) (fun j => normalizedCycle_selfAdjoint (c j)) + (fun j => normalizedCycle_sq (c j)) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UniformSubdivision.lean b/lean/OAI/Topology/CoarseAssembly/UniformSubdivision.lean new file mode 100644 index 0000000000000000000000000000000000000000..96ccb76bc9115521bbbfee825832c8ec8055609d --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UniformSubdivision.lean @@ -0,0 +1,47 @@ +import OAI.Topology.CoarseAssembly.FredholmModule +import Mathlib.Topology.UniformSpace.HeineCantor +import Mathlib.Algebra.Order.Archimedean.Real.Basic + +namespace OAI + +/-! # Finite subdivisions of an actual norm-continuous homotopy -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +def intervalGrid (N : ℕ) (hN : 0 < N) (j : ℕ) : Interval := + ⟨((min j N : ℕ) : ℝ) / N, div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _), + (div_le_one (Nat.cast_pos.mpr hN)).mpr (by exact_mod_cast Nat.min_le_right j N)⟩ + +@[simp] theorem intervalGrid_start (N : ℕ) (hN : 0 < N) : intervalGrid N hN 0 = start := by + apply Subtype.ext + simp [intervalGrid, start] + +@[simp] theorem intervalGrid_finish (N : ℕ) (hN : 0 < N) : intervalGrid N hN N = finish := by + apply Subtype.ext + simp [intervalGrid, finish, Nat.ne_of_gt hN] + +theorem intervalGrid_dist (N : ℕ) (hN : 0 < N) (j : ℕ) (hj : j < N) : + dist (intervalGrid N hN (j + 1)) (intervalGrid N hN j) = (N : ℝ)⁻¹ := by + change |((min (j + 1) N : ℕ) : ℝ) / N - ((min j N : ℕ) : ℝ) / N| = _ + rw [Nat.min_eq_left (Nat.succ_le_of_lt hj), Nat.min_eq_left hj.le, Nat.cast_succ] + have he : ((j : ℝ) + 1) / N - (j : ℝ) / N = 1 / N := by ring + rw [he, abs_of_nonneg (by positivity), one_div] + +theorem exists_interval_subdivision {E : Type*} [PseudoMetricSpace E] + (f : Interval → E) (hf : Continuous f) (ε : ℝ) (hε : 0 < ε) : + ∃ (N : ℕ) (hN : 0 < N), ∀ j, j < N → + dist (f (intervalGrid N hN (j + 1))) (f (intervalGrid N hN j)) < ε := by + obtain ⟨δ, hδ, hclose⟩ := Metric.uniformContinuous_iff.mp + (CompactSpace.uniformContinuous_of_continuous hf) ε hε + obtain ⟨N, hN, hn⟩ := Real.exists_nat_pos_inv_lt hδ + refine ⟨N, hN, fun j hj => hclose ?_⟩ + rw [intervalGrid_dist N hN j hj] + exact hn + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnitalCycleInvertible.lean b/lean/OAI/Topology/CoarseAssembly/UnitalCycleInvertible.lean new file mode 100644 index 0000000000000000000000000000000000000000..435c9b640d462096a12d84ebaff7fe6fe5413a51 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnitalCycleInvertible.lean @@ -0,0 +1,32 @@ +import OAI.Topology.CoarseAssembly.FredholmInvertible + +namespace OAI + +/-! # Invertible self-adjoint representatives for unital odd cycles -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem exists_invertible_selfAdjoint_representative (c : OddCycle A) + (hunital : c.representation 1 = 1) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ + d.representation 1 = 1 ∧ IsSelfAdjoint d.operator ∧ IsUnit d.operator := by + obtain ⟨d, hdc, hdunit, hdself⟩ := exists_selfAdjoint_representative c hunital + have hc : IsCompactOperator (d.operator * d.operator - 1 : End d.space) := by + simpa only [hdunit, mul_one] using d.square_compact 1 + have hp := kernelProjection_compact d.operator hc + have hps : IsCompactOperator (star (kernelProjection d.operator) : End d.space) := by + rw [(kernelProjection_selfAdjoint d.operator).star_eq] + exact hp + refine ⟨d.compactPerturb (kernelProjection d.operator) hp hps, + (compactPerturb_class d _ hp hps).trans hdc, hdunit, + kernel_corrected_selfAdjoint d.operator hdself, kernel_corrected_isUnit d.operator hdself hc⟩ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnitalCycleNormalization.lean b/lean/OAI/Topology/CoarseAssembly/UnitalCycleNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..8daa25c9acb9c1a9d34edd5f14f02e362b4eb1eb --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnitalCycleNormalization.lean @@ -0,0 +1,43 @@ +import OAI.Topology.CoarseAssembly.CycleCompactPerturbation +import Mathlib.Tactic.Module + +namespace OAI + +/-! # Self-adjoint normalization of a unital Fredholm cycle + +The compact adjoint defect allows replacement of the operator by its +self-adjoint part, with the represented algebra and K-homology class fixed. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {A : Type} [CStarAlgebra A] + +theorem exists_selfAdjoint_representative (c : OddCycle A) + (hunital : c.representation 1 = 1) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ + d.representation 1 = 1 ∧ IsSelfAdjoint d.operator := by + let K : End c.space := (1 / 2 : ℝ) • (star c.operator - c.operator) + have hdefect : IsCompactOperator (star c.operator - c.operator : End c.space) := by + simpa only [hunital, mul_one] using c.adjoint_compact 1 + have hK : IsCompactOperator K := hdefect.smul (1 / 2 : ℝ) + have hstar : star K = -K := by + dsimp only [K] + rw [star_smul, star_trivial, star_sub, star_star] + module + have hKs : IsCompactOperator (star K : End c.space) := by + rw [hstar] + exact hK.neg + refine ⟨c.compactPerturb K hK hKs, compactPerturb_class c K hK hKs, hunital, ?_⟩ + change star (c.operator + K) = c.operator + K + rw [star_add, hstar] + dsimp only [K] + module + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnitalRepresentative.lean b/lean/OAI/Topology/CoarseAssembly/UnitalRepresentative.lean new file mode 100644 index 0000000000000000000000000000000000000000..3272402da310870948a9a0d89d03f7247025be0f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnitalRepresentative.lean @@ -0,0 +1,130 @@ +import OAI.Topology.CoarseAssembly.BinaryCycle +import OAI.Topology.CoarseAssembly.CharacterExtension +import OAI.Topology.CoarseAssembly.ProjectionSwap +import OAI.Topology.CoarseAssembly.UniformCycleNormalization + +namespace OAI + +/-! # Unital representatives for compact-source analytic classes + +Adjoin a degenerate character cycle and exchange the complementary +subspaces by the explicit projection-swap unitary. This proves that +completion of a representation by a character preserves its class. +-/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H : HilbertSpace} + +theorem projectionSwap_representation (P R : End H) (hP : IsStarProjection P) + (hPR : P * R = R) (hRP : R * P = R) (z : ℂ) : + binaryBlock H H (R + z • (1 - P)) (z • P) = + operatorConjugation (projectionSwapUnitary H P hP).toLinearIsometry + (binaryBlock H H R (z • 1)) := by + rw [projectionSwapUnitary_conjugation] + have hu := projectionSwap_sq H P hP.isIdempotentElem + suffices hi : binaryBlock H H (R + z • (1 - P)) (z • P) * projectionSwap H P = + projectionSwap H P * binaryBlock H H R (z • 1) by + have hi' := congrArg (fun T => T * projectionSwap H P) hi + simpa only [mul_assoc, hu, mul_one] using hi' + apply ContinuousLinearMap.ext + intro x + change binaryBlock H H (R + z • (1 - P)) (z • P) (projectionSwap H P x) = + projectionSwap H P (binaryBlock H H R (z • 1) x) + rw [projectionSwap_apply H, binaryBlock_apply H H, binaryBlock_apply H H, + projectionSwap_apply H] + apply (WithLp.ofLp_injective 2) + have hp (y : H) : P (P y) = P y := DFunLike.congr_fun hP.isIdempotentElem y + have hpr (y : H) : P (R y) = R y := DFunLike.congr_fun hPR y + have hrp (y : H) : R (P y) = R y := DFunLike.congr_fun hRP y + change + ((R + z • (1 - P)) (P x.fst + (1 - P) x.snd), + (z • P) ((1 - P) x.fst + P x.snd)) = + (P (R x.fst) + (1 - P) ((z • (1 : End H)) x.snd), + (1 - P) (R x.fst) + P ((z • (1 : End H)) x.snd)) + simp only [add_apply, smul_apply, sub_apply, one_apply_eq_self, map_add, map_sub, + map_smul, hp, hpr, hrp] + ext <;> module + +theorem projectionSwap_operator (P F : End H) (hP : IsStarProjection P) + (hF : IsSelfAdjoint F) (hQ : F * (1 - P) = 1 - P) : + binaryBlock H H F 1 = + operatorConjugation (projectionSwapUnitary H P hP).toLinearIsometry + (binaryBlock H H F 1) := by + rw [projectionSwapUnitary_conjugation] + have hu := projectionSwap_sq H P hP.isIdempotentElem + have hc := (commute_of_complement F P hF hP.isSelfAdjoint hQ).eq + have hQ' : (1 - P) * F = 1 - P := by + have h := congrArg star hQ + simpa only [star_mul, star_sub, star_one, hP.isSelfAdjoint.star_eq, hF.star_eq] using h + suffices hi : binaryBlock H H F 1 * projectionSwap H P = + projectionSwap H P * binaryBlock H H F 1 by + have hi' := congrArg (fun T => T * projectionSwap H P) hi + simpa only [mul_assoc, hu, mul_one] using hi' + apply ContinuousLinearMap.ext + intro x + change binaryBlock H H F 1 (projectionSwap H P x) = + projectionSwap H P (binaryBlock H H F 1 x) + rw [projectionSwap_apply H, binaryBlock_apply H H, binaryBlock_apply H H, + projectionSwap_apply H] + apply (WithLp.ofLp_injective 2) + have hfp (y : H) : F (P y) = P (F y) := DFunLike.congr_fun hc y + have hfq (y : H) : F ((1 - P) y) = (1 - P) y := DFunLike.congr_fun hQ y + have hqf (y : H) : (1 - P) (F y) = (1 - P) y := DFunLike.congr_fun hQ' y + change (F (P x.fst + (1 - P) x.snd), (1 - P) x.fst + P x.snd) = + (P (F x.fst) + (1 - P) x.snd, (1 - P) (F x.fst) + P x.snd) + rw [map_add, hfp, hfq, hqf] + +variable {A : Type} [CStarAlgebra A] + +theorem characterExtension_class (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) + (hF : IsSelfAdjoint c.operator) + (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) + (hsq : IsCompactOperator (c.operator * c.operator - 1 : End c.space)) : + cycleClass A (c.characterExtension χ hF hQ hsq) = cycleClass A c := by + let d := identityOperatorCycle + (characterProjectionRepresentation χ (1 : End c.space) (IsStarProjection.one _)) + let e := identityOperatorCycle + (characterProjectionRepresentation χ (c.representation 1) (representation_unit_projection c)) + have he : (c.binarySum d).UnitaryEquivalent + ((c.characterExtension χ hF hQ hsq).binarySum e) := by + refine ⟨projectionSwapUnitary c.space (c.representation 1) (representation_unit_projection c), + ?_, ?_⟩ + · intro a + change binaryBlock c.space c.space + (c.representation a + χ a • (1 - c.representation 1)) (χ a • c.representation 1) = _ + exact projectionSwap_representation _ _ (representation_unit_projection c) + (by rw [← map_mul, one_mul]) (by rw [← map_mul, mul_one]) (χ a) + · exact projectionSwap_operator _ _ (representation_unit_projection c) hF hQ + have h := unitary_eq _ _ he + rw [binarySum_class, binarySum_class, + degenerate_zero d (identityOperatorCycle_degenerate _), + degenerate_zero e (identityOperatorCycle_degenerate _), add_zero, add_zero] at h + exact h.symm + +/-- Every analytic cycle over an algebra with a character has a unital +representative. The assertion includes equality in the actual cycle quotient. -/ +theorem exists_unital_representative (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ d.representation 1 = 1 := by + let d := c.cutDown + let e := d.characterExtension χ (cutDown_selfAdjoint c) (cutDown_complement c) + (cutDown_square_compact c) + refine ⟨e, ?_, characterExtension_unital d χ _ _ _⟩ + exact (characterExtension_class d χ _ _ _).trans (cutDown_class c) + +/-- The representatives needed by whole-family Rips localization can be +chosen unital, self-adjoint, involutive, and uniformly bounded by one. -/ +theorem exists_unital_involutive_representative (c : OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : + ∃ d : OddCycle A, cycleClass A d = cycleClass A c ∧ d.representation 1 = 1 ∧ + IsSelfAdjoint d.operator ∧ d.operator * d.operator = 1 ∧ ‖d.operator‖ ≤ 1 := by + obtain ⟨d, hdc, hdu⟩ := exists_unital_representative c χ + obtain ⟨e, hed, heu, hes, heq⟩ := exists_involutive_representative d hdu + exact ⟨e, hed.trans hdc, heu, hes, heq, involution_norm_le_one _ hes heq⟩ + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnitalStructureAlgebra.lean b/lean/OAI/Topology/CoarseAssembly/UnitalStructureAlgebra.lean new file mode 100644 index 0000000000000000000000000000000000000000..530a1987058dd2713e56982ef2f4bdbbad903f86 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnitalStructureAlgebra.lean @@ -0,0 +1,66 @@ +import OAI.Topology.CoarseAssembly.StructureQuotient +import Mathlib.Analysis.CStarAlgebra.Spectrum + +namespace OAI + +/-! # The unit of the controlled pseudolocal algebra -/ + +noncomputable section + +namespace CoarseAssembly.DiscreteRoe + +variable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X] + [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] + +local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where + smul_assoc c T S := by ext v; simp +local instance : SMulCommClass ℂ (Operator X H) (Operator X H) where + smul_comm c T S := by ext v; simp +local instance : ContinuousStar (Operator X H) := ⟨operator_star_continuous⟩ + +omit [CompleteSpace H] in +theorem propagationLE_one : PropagationLE 0 (1 : Operator X H) := by + intro x y hxy + have hne : x ≠ y := by intro h; simp [h] at hxy + ext v + simp [entry_apply, lp.single_apply, hne] + +theorem structureGenerator_one : StructureGenerator (1 : Operator X H) := by + refine ⟨⟨0, le_rfl, propagationLE_one⟩, ?_, ?_⟩ + · intro f + simp only [one_mul, mul_one, sub_self] + exact isCompactOperator_zero + · rw [star_one (Operator X H)] + intro f + simp only [one_mul, mul_one, sub_self] + exact isCompactOperator_zero + +theorem structureAlgebra_one : (1 : Operator X H) ∈ structureAlgebra (X := X) (H := H) := + (NonUnitalStarSubalgebra.le_topologicalClosure _) + (NonUnitalStarAlgebra.subset_adjoin ℂ _ (structureGenerator_one (X := X) (H := H))) + +/-- The controlled structure algebra with its actual identity operator. -/ +def unitalStructureAlgebra : StarSubalgebra ℂ (Operator X H) where + carrier := structureAlgebra (X := X) (H := H) + add_mem' := (structureAlgebra (X := X) (H := H)).add_mem + mul_mem' := (structureAlgebra (X := X) (H := H)).mul_mem + star_mem' := fun h => star_mem h + algebraMap_mem' z := by + rw [Algebra.algebraMap_eq_smul_one] + exact (structureAlgebra (X := X) (H := H)).smul_mem z structureAlgebra_one + +theorem unitalStructureAlgebra_closed : + IsClosed (unitalStructureAlgebra (X := X) (H := H) : Set (Operator X H)) := + NonUnitalStarSubalgebra.isClosed_topologicalClosure _ + +instance : CompleteSpace (unitalStructureAlgebra (X := X) (H := H)) := + unitalStructureAlgebra_closed.completeSpace_coe + +instance : CStarAlgebra (unitalStructureAlgebra (X := X) (H := H)) := + StarSubalgebra.cstarAlgebra _ (h_closed := unitalStructureAlgebra_closed) + +end CoarseAssembly.DiscreteRoe + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnitaryHomotopyIndex.lean b/lean/OAI/Topology/CoarseAssembly/UnitaryHomotopyIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..05bb0edb667e94e0d5f2adeff8b63ca3588a6af3 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnitaryHomotopyIndex.lean @@ -0,0 +1,59 @@ +import OAI.Topology.CoarseAssembly.CompactIndexPairing + +namespace OAI + +/-! # Homotopy invariance in the unitary argument of the index pairing -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +open scoped CStarAlgebra + +variable {A : Type} [CStarAlgebra A] + +theorem rawCycleIndex_unitaryHomotopy (c : OddCycle A) (u : Interval → A) + (hu : Continuous u) (hul : ∀ t, star (u t) * u t = 1) + (hur : ∀ t, u t * star (u t) = 1) : + rawCycleIndex c (u start) = rawCycleIndex c (u finish) := by + apply fredholmIndex_homotopy (fun t => rawCycleToeplitz c (u t)) + · have hrep : Continuous (fun t => c.representation (u t)) := (map_continuous c.representation).comp hu + have hext : Continuous (fun t => unitaryExtension c (u t)) := hrep.add continuous_const + exact ((continuous_const.mul hext).mul continuous_const).add continuous_const + · intro t + exact rawCycleToeplitz_fredholm c (u t) (hul t) (hur t) + +theorem indexPairing_unitaryHomotopy (u : Interval → A) (hu : Continuous u) + (hul : ∀ t, star (u t) * u t = 1) (hur : ∀ t, u t * star (u t) = 1) : + indexPairing (u start) (hul start) (hur start) = + indexPairing (u finish) (hul finish) (hur finish) := by + apply hom_ext + intro c + simp only [indexPairing_cycleClass] + exact rawCycleIndex_unitaryHomotopy c u hu hul hur + +open scoped ZeroAtInfty + +variable {X : Type} [TopologicalSpace X] [CompactSpace X] + +theorem compactIndexPairing_homotopy {f g : C(X, Circle)} (F : f.Homotopy g) : + compactIndexPairing f = compactIndexPairing g := by + let u : Interval → C(X, ℂ) := fun t => compactUnitary (homotopySlice F t) + have hu : Continuous u := by + let coeCircle : C(Circle, ℂ) := ⟨fun z => (z : ℂ), continuous_subtype_val⟩ + exact (ContinuousMap.continuous_postcomp coeCircle).comp F.toContinuousMap.curry.continuous + have hul (t : Interval) : star (u t) * u t = 1 := compactUnitary_star_mul _ + have hur (t : Interval) : u t * star (u t) = 1 := compactUnitary_mul_star _ + have hi := indexPairing_unitaryHomotopy u hu hul hur + have he : indexPairing (compactUnitary f) (compactUnitary_star_mul f) + (compactUnitary_mul_star f) = indexPairing (compactUnitary g) + (compactUnitary_star_mul g) (compactUnitary_mul_star g) := by + simpa only [u, homotopySlice_start, homotopySlice_finish] using hi + unfold compactIndexPairing + rw [he] + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnitaryIndex.lean b/lean/OAI/Topology/CoarseAssembly/UnitaryIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..7ab4cc8fca4c7aded5160bd60af5fe74bfb9e69b --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnitaryIndex.lean @@ -0,0 +1,76 @@ +import OAI.Topology.CoarseAssembly.DegenerateCutDown + +namespace OAI + +/-! # Unitary invariance of the explicit cycle index -/ + +noncomputable section + +namespace CoarseAssembly.Analytic + +variable {H K : HilbertSpace} + +theorem operatorConjugation_equiv (e : H ≃ₗᵢ[ℂ] K) (T : End H) : + operatorConjugation e.toLinearIsometry T = e.conjStarAlgEquiv T := by + have he : e.toLinearIsometry.toContinuousLinearMap.adjoint = + (e.symm : K →L[ℂ] H) := e.adjoint_eq_symm + ext x + change e (T (e.toLinearIsometry.toContinuousLinearMap.adjoint x)) = e (T (e.symm x)) + rw [he] + rfl + +theorem symmetricCutDown_map (φ : End H →⋆ₐ[ℂ] End K) (P F : End H) : + φ (symmetricCutDown P F) = symmetricCutDown (φ P) (φ F) := by + have hs (r : ℝ) (T : End H) : φ (r • T) = r • φ T := φ.toAlgHom.map_smul_of_tower r T + unfold symmetricCutDown + rw [map_add, hs, map_add, map_star, + map_mul, map_mul, map_sub, map_one] + +theorem positiveProjection_map (φ : End H →⋆ₐ[ℂ] End K) (F : End H) : + φ (positiveProjection F) = positiveProjection (φ F) := by + have hs (r : ℝ) (T : End H) : φ (r • T) = r • φ T := φ.toAlgHom.map_smul_of_tower r T + unfold positiveProjection + rw [hs, map_add, map_one] + +theorem toeplitzCompression_map (φ : End H →⋆ₐ[ℂ] End K) (P U : End H) : + φ (toeplitzCompression P U) = toeplitzCompression (φ P) (φ U) := by + simp only [toeplitzCompression, map_add, map_mul, map_sub, map_one] + +theorem fredholmIndex_conjugation (e : H ≃ₗᵢ[ℂ] K) (T : End H) (hT : T.IsFredholm) : + (e.conjStarAlgEquiv T).toLinearMap.index = T.toLinearMap.index := by + have he := e.toContinuousLinearEquiv.isFredholm + have hei := e.symm.toContinuousLinearEquiv.isFredholm + have hz : (e.toContinuousLinearEquiv : H →L[ℂ] K).toLinearMap.index = 0 := + LinearMap.index_of_bijective e.bijective + have hzi : (e.symm.toContinuousLinearEquiv : K →L[ℂ] H).toLinearMap.index = 0 := + LinearMap.index_of_bijective e.symm.bijective + change ((e.toContinuousLinearEquiv : H →L[ℂ] K) ∘L T ∘L + (e.symm.toContinuousLinearEquiv : K →L[ℂ] H)).toLinearMap.index = _ + rw [he.index_comp (hT.comp hei), hT.index_comp hei, hz, hzi, zero_add, add_zero] + +variable {A : Type} [CStarAlgebra A] + +theorem rawCycleToeplitz_unitary (c d : OddCycle A) (h : c.UnitaryEquivalent d) (u : A) : + rawCycleToeplitz d u = h.unitary.conjStarAlgEquiv (rawCycleToeplitz c u) := by + let φ : End c.space →⋆ₐ[ℂ] End d.space := h.unitary.conjStarAlgEquiv.toStarAlgHom + have hrep (a : A) : d.representation a = φ (c.representation a) := + (h.representation_eq a).trans (operatorConjugation_equiv h.unitary _) + have hop : d.operator = φ c.operator := + h.operator_eq.trans (operatorConjugation_equiv h.unitary _) + change rawCycleToeplitz d u = φ (rawCycleToeplitz c u) + unfold rawCycleToeplitz + rw [toeplitzCompression_map φ, positiveProjection_map φ, symmetricCutDown_map φ] + simp only [unitaryExtension, map_add, map_sub, map_one] + rw [hop, hrep 1, hrep u] + +theorem rawCycleIndex_unitary (c d : OddCycle A) (h : c.UnitaryEquivalent d) (u : A) + (hul : star u * u = 1) (hur : u * star u = 1) : rawCycleIndex d u = rawCycleIndex c u := by + unfold rawCycleIndex + rw [rawCycleToeplitz_unitary c d h u] + exact fredholmIndex_conjugation h.unitary _ (rawCycleToeplitz_fredholm c u hul hur) + +end CoarseAssembly.Analytic + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/UnrestrictedBoundedHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/UnrestrictedBoundedHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..d046a058d901f8737078a5ccc78ffec80fe5a46f --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/UnrestrictedBoundedHomotopy.lean @@ -0,0 +1,80 @@ +import OAI.Topology.CoarseAssembly.BoundedFamilySubdivision + +namespace OAI + +/-! # Whole-union boundary invariance without uniform homotopy speeds + +Finite subdivisions are chosen separately on each component. The two sums +of consecutive samples have uniformly close localized operators. Rotation +and direct-sum additivity cancel the common interior samples in actual Roe K₁. +-/ + +noncomputable section + +namespace CoarseAssembly.Rips + +open Analytic DiscreteRoe + +variable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)] + [∀ i, DecidableEq (Q i)] {r : ℝ} + +namespace BoundedFamilyHomotopy + +theorem sampled_telescope (h : BoundedFamilyHomotopy Q r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (o : ∀ i, Q i) (hr : 0 ≤ r) (N : ℕ → ℕ) (τ : ℕ → ℕ → Interval) + (hnear : (h.sample χ (fun i => N i + 1) τ).boundary o hr = + (h.sample χ (fun i => N i + 1) (fun i j => τ i (j + 1))).boundary o hr) : + (h.eval (fun i => τ i 0)).boundary o hr = + (h.eval (fun i => τ i (N i + 1))).boundary o hr := by + let := separatedMetric o + have hleft := h.sample_head_tail_boundary χ o hr N τ + have hright := h.sample_head_tail_boundary χ o hr N + (fun i => lastEndpointFirst (N i) (τ i)) + have hh : (fun i => lastEndpointFirst (N i) (τ i) 0) = + (fun i => τ i (N i + 1)) := funext (fun i => lastEndpointFirst_zero (N i) (τ i)) + have ht : (fun i j => lastEndpointFirst (N i) (τ i) (j + 1)) = + (fun i j => τ i (j + 1)) := funext (fun i => funext (fun j => lastEndpointFirst_succ (N i) (τ i) j)) + have hh' := congrArg (fun t : ℕ → Interval => (h.eval t).boundary o hr) hh + have ht' := congrArg (fun t : ℕ → ℕ → Interval => (h.sample χ N t).boundary o hr) ht + have hright' := hright.trans (congrArg₂ (fun a b => a + b) hh' ht') + have hrotate := h.sample_rotate_boundary χ o hr N τ + exact add_right_cancel (hleft.symm.trans (hnear.trans (hrotate.symm.trans hright'))) + +theorem endpoint_boundary_eq (h : BoundedFamilyHomotopy Q r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (o : ∀ i, Q i) (hr : 0 ≤ r) : + (h.eval (fun _ => start)).boundary o hr = (h.eval (fun _ => finish)).boundary o hr := by + let s := h.smallSubdivision + have he := h.sampled_telescope χ o hr s.count s.time + (h.sampled_boundary_eq χ o hr s.count s.time s.step) + have h0 : (fun i => s.time i 0) = (fun _ => start) := funext s.at_start + have h1 : (fun i => s.time i (s.count i + 1)) = (fun _ => finish) := funext s.at_finish + have he0 := congrArg (fun t : ℕ → Interval => (h.eval t).boundary o hr) h0 + have he1 := congrArg (fun t : ℕ → Interval => (h.eval t).boundary o hr) h1 + exact he0.symm.trans (he.trans he1) + +end BoundedFamilyHomotopy + +/-- Arbitrary componentwise continuous unital self-adjoint homotopies with +a common operator bound preserve the whole-union Roe boundary. -/ +theorem ampleRipsFamilyBoundary_boundedHomotopy + (o : ∀ i, Q i) (hr : 0 ≤ r) + (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) + (h : ∀ i, OddHomotopy C(Point (Q i) r, ℂ)) + (hπ : ∀ t i, (h i).representation t 1 = 1) + (hs : ∀ t i, IsSelfAdjoint ((h i).operator t)) + (C : ℝ) (hC : 1 ≤ C) (hn : ∀ t i, ‖(h i).operator t‖ ≤ C) : + letI := separatedMetric o + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval start) (hπ start) (hs start) + C (zero_le_one.trans hC) (hn start) = + ampleRipsFamilyBoundary o r hr (fun i => (h i).eval finish) (hπ finish) (hs finish) + C (zero_le_one.trans hC) (hn finish) := by + let H : BoundedFamilyHomotopy Q r := ⟨h, hπ, hs, C, hC, hn⟩ + exact H.endpoint_boundary_eq χ o hr + +end CoarseAssembly.Rips + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/WindingHomotopy.lean b/lean/OAI/Topology/CoarseAssembly/WindingHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e68c17674c62fc1afd094009998d75407fc9a73 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/WindingHomotopy.lean @@ -0,0 +1,83 @@ +import OAI.Topology.CoarseAssembly.MultiplicativeIndexPairing + +namespace OAI + +/-! # The explicit homotopy from a lifted loop to its winding power -/ + +noncomputable section + +namespace CoarseAssembly + +open unitInterval + +/-- The degree-`n` self-map of the additive circle. -/ +def circleDegree (n : ℤ) : C(WindingCircle, WindingCircle) := + ⟨fun z => n • z, continuous_id.zsmul n⟩ + +theorem windingCircle_intCast (n : ℤ) : ((n : ℝ) : WindingCircle) = 0 := by + have h : ((n • (1 : ℝ) : ℝ) : WindingCircle) = 0 := by + rw [AddCircle.coe_zsmul, AddCircle.coe_period, smul_zero] + simpa only [zsmul_eq_mul, mul_one] using h + +/-- Straight-line interpolation of the real lift with `t ↦ n*t`. -/ +def windingInterpolation (n : ℤ) (L : Path (0 : ℝ) (n : ℝ)) (s : unitInterval) : + Path (0 : WindingCircle) 0 where + toFun t := (((1 - (s : ℝ)) * L t + (s : ℝ) * n * (t : ℝ) : ℝ) : WindingCircle) + continuous_toFun := (AddCircle.continuous_mk' 1).comp + ((L.continuous.const_mul _).add (continuous_subtype_val.const_mul _)) + source' := by simp + target' := by + have he : (1 - (s : ℝ)) * (n : ℝ) + (s : ℝ) * n * 1 = n := by ring + simp only [Path.target, Set.Icc.coe_one, he] + exact windingCircle_intCast n + +def windingInterpolationMap (n : ℤ) (L : Path (0 : ℝ) (n : ℝ)) : + unitInterval × WindingCircle → WindingCircle := + fun p => loopCircle (windingInterpolation n L p.1) p.2 + +theorem windingInterpolationMap_continuous (n : ℤ) (L : Path (0 : ℝ) (n : ℝ)) : + Continuous (windingInterpolationMap n L) := by + let q : unitInterval × unitInterval → unitInterval × WindingCircle := + fun p => (p.1, ((p.2 : ℝ) : WindingCircle)) + have hq : Continuous q := continuous_fst.prodMk + ((AddCircle.continuous_mk' 1).comp (continuous_subtype_val.comp continuous_snd)) + have hqs : Function.Surjective q := by + rintro ⟨s, z⟩ + obtain ⟨t, ht⟩ := circle_parameter_surjective z + exact ⟨(s, t), Prod.ext rfl ht⟩ + apply ((hq.isClosedMap.isQuotientMap hq hqs).continuous_iff).2 + have he : windingInterpolationMap n L ∘ q = fun p : unitInterval × unitInterval => + (((1 - (p.1 : ℝ)) * L p.2 + (p.1 : ℝ) * n * (p.2 : ℝ) : ℝ) : WindingCircle) := by + funext p + exact loopCircle_apply (windingInterpolation n L p.1) p.2 + rw [he] + apply (AddCircle.continuous_mk' 1).comp + exact ((continuous_const.sub (continuous_subtype_val.comp continuous_fst)).mul + (L.continuous.comp continuous_snd)).add + (((continuous_subtype_val.comp continuous_fst).mul continuous_const).mul + (continuous_subtype_val.comp continuous_snd)) + +def windingHomotopy (g : C(WindingCircle, WindingCircle)) (n : ℤ) + (L : Path (0 : ℝ) (n : ℝ)) + (hL : ∀ t : unitInterval, g (t : ℝ) = (L t : WindingCircle)) : + g.Homotopy (circleDegree n) where + toFun := windingInterpolationMap n L + continuous_toFun := windingInterpolationMap_continuous n L + map_zero_left z := by + obtain ⟨t, rfl⟩ := circle_parameter_surjective z + rw [windingInterpolationMap, loopCircle_apply, hL t] + change ((((1 - (0 : ℝ)) * L t + (0 : ℝ) * n * (t : ℝ)) : ℝ) : WindingCircle) = _ + simp + map_one_left z := by + obtain ⟨t, rfl⟩ := circle_parameter_surjective z + rw [windingInterpolationMap, loopCircle_apply] + change ((((1 - (1 : ℝ)) * L t + (1 : ℝ) * n * (t : ℝ)) : ℝ) : WindingCircle) = + n • ((t : ℝ) : WindingCircle) + simpa only [sub_self, zero_mul, zero_add, one_mul, zsmul_eq_mul] using + (AddCircle.coe_zsmul (p := (1 : ℝ)) (n := n) (x := (t : ℝ))) + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/CoarseAssembly/WindingIndexEvaluation.lean b/lean/OAI/Topology/CoarseAssembly/WindingIndexEvaluation.lean new file mode 100644 index 0000000000000000000000000000000000000000..1f5c423792f9a7e17c97eb888bda94dee40786c5 --- /dev/null +++ b/lean/OAI/Topology/CoarseAssembly/WindingIndexEvaluation.lean @@ -0,0 +1,60 @@ +import OAI.Topology.CoarseAssembly.WindingHomotopy + +namespace OAI + +/-! # Reducing the winding index formula to one generator evaluation + +The pairing, its naturality, homotopy invariance and power law are proved. +Only an actual circle class with coordinate index one remains to construct. +-/ + +noncomputable section + +namespace CoarseAssembly + +open Analytic unitInterval + +theorem circleUnitary_degree (n : ℤ) : circleUnitary (circleDegree n) = + circleUnitary (ContinuousMap.id WindingCircle) ^ n := by + apply ContinuousMap.ext + intro z + exact AddCircle.toCircle_zsmul z n + +theorem winding_index_hom (g : C(WindingCircle, WindingCircle)) (n : ℤ) + (L : Path (0 : ℝ) (n : ℝ)) + (hL : ∀ t : unitInterval, g (t : ℝ) = (L t : WindingCircle)) : + compactIndexPairing (circleUnitary g) = + n • compactIndexPairing (circleUnitary (ContinuousMap.id WindingCircle)) := by + let toCircleMap : C(WindingCircle, Circle) := ⟨AddCircle.toCircle, AddCircle.continuous_toCircle⟩ + have h := compactIndexPairing_homotopy + ((ContinuousMap.Homotopy.refl toCircleMap).comp (windingHomotopy g n L hL)) + change compactIndexPairing (circleUnitary g) = compactIndexPairing (circleUnitary (circleDegree n)) at h + rw [circleUnitary_degree, compactIndexPairing_zpow] at h + exact h + +theorem winding_index (g : C(WindingCircle, WindingCircle)) (n : ℤ) + (L : Path (0 : ℝ) (n : ℝ)) + (hL : ∀ t : unitInterval, g (t : ℝ) = (L t : WindingCircle)) + (α : LocallyFiniteK1 WindingCircle) : + compactIndexPairing (circleUnitary g) α = + n * compactIndexPairing (circleUnitary (ContinuousMap.id WindingCircle)) α := by + simpa only [AddMonoidHom.smul_apply, zsmul_eq_mul, Int.cast_id] using + DFunLike.congr_fun (winding_index_hom g n L hL) α + +/-- All the published circle fields follow from a single coordinate-index-one class. -/ +def circleInputOfIndexOne (α : LocallyFiniteK1 WindingCircle) + (hα : compactIndexPairing (circleUnitary (ContinuousMap.id WindingCircle)) α = 1) : + PublishedCircleInput where + fundamental := α + pairing f := compactIndexPairing (circleUnitary f) + loop_naturality f γ := by + have h := DFunLike.congr_fun (compactIndexPairing_natural (circleUnitary f) γ) α + exact h + winding g n L hL := by + rw [winding_index g n L hL α, hα, mul_one] + +end CoarseAssembly + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/AffineTransport.lean b/lean/OAI/Topology/EilenbergGanea/AffineTransport.lean new file mode 100644 index 0000000000000000000000000000000000000000..7d40d3a4baba2c792eff6678a0bf19d9479f7944 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/AffineTransport.lean @@ -0,0 +1,449 @@ +import OAI.Topology.EilenbergGanea.SmallHolonomy +import OAI.GroupTheory.RightAngledArtin.TraceWords + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea +namespace AffineTransport + +/-- A finite family of proper quaternion subspaces cannot cover ℍ. -/ +theorem exists_avoid_subspaces {I : Type*} [Finite I] + (p : I → Submodule ℝ ℍ) (hp : ∀ i, p i ≠ ⊤) : + ∃ q : ℍ, ∀ i, q ∉ p i := by + have ho (i) : IsOpen ((p i : Set ℍ)ᶜ) := + (p i).closed_of_finiteDimensional.isOpen_compl + have hd (i) : Dense ((p i : Set ℍ)ᶜ) := by + apply interior_eq_empty_iff_dense_compl.mp + apply Set.not_nonempty_iff_eq_empty.mp + intro h + exact hp i ((p i).eq_top_of_nonempty_interior' h) + obtain ⟨q,hq⟩ := (dense_iInter_of_isOpen ho hd).nonempty + exact ⟨q,Set.mem_iInter.mp hq⟩ + +/-- Simultaneous general position for finitely many local quaternion gauges. +Different vertices may use different invertible linear transformations in each +chart. No flatness or topology is assumed in this finite-dimensional lemma. -/ +theorem exists_triangle_general_position {A V : Type*} [Finite A] [Fintype V] + (T : A → V → ℍ ≃ₗ[ℝ] ℍ) : + ∃ q : V → ℍ, ∀ a (s : Finset V), s.card ≤ 3 → + LinearIndepOn ℝ (fun v => T a v (q v)) (s : Set V) := by + classical + suffices ∀ U : Finset V, ∃ q : V → ℍ, ∀ a (s : Finset V), s ⊆ U → s.card ≤ 3 → + LinearIndepOn ℝ (fun v => T a v (q v)) (s : Set V) by + obtain ⟨q,hq⟩ := this Finset.univ + exact ⟨q,fun a s h => hq a s (Finset.subset_univ _) h⟩ + intro U + induction U using Finset.induction with + | empty => + refine ⟨0,?_⟩ + intro a s hs _ + have : s = ∅ := Finset.subset_empty.mp hs + subst s + simpa only [Finset.coe_empty,Pi.zero_apply] using + linearIndepOn_empty ℝ (fun v => T a v (0 : ℍ)) + | @insert v U hv ih => + obtain ⟨q,hq⟩ := ih + let I := A × {s : Finset V // s ⊆ U ∧ s.card ≤ 2} + let p : I → Submodule ℝ ℍ := fun i => + (Submodule.span ℝ ((fun w => T i.1 w (q w)) '' (i.2.val : Set V))).comap + (T i.1 v).toLinearMap + have hp (i : I) : p i ≠ ⊤ := by + have hf : Module.finrank ℝ (Submodule.span ℝ + ((fun w => T i.1 w (q w)) '' (i.2.val : Set V))) ≤ 2 := by + have hh := finrank_span_finset_le_card (R := ℝ) (i.2.val.image (fun w => T i.1 w (q w))) + rw [Finset.coe_image] at hh + exact hh.trans ((Finset.card_image_le).trans i.2.property.2) + have hproper : Submodule.span ℝ ((fun w => T i.1 w (q w)) '' + (i.2.val : Set V)) ≠ ⊤ := by + apply ne_of_lt (Submodule.lt_top_of_finrank_lt_finrank _) + rw [Quaternion.finrank_eq_four] + omega + intro hh + apply hproper + apply top_unique + intro x _ + have hm : (T i.1 v).symm x ∈ p i := by rw [hh]; trivial + simpa only [p,Submodule.mem_comap,LinearEquiv.coe_coe, + LinearEquiv.apply_symm_apply] using hm + obtain ⟨z,hz⟩ := exists_avoid_subspaces p hp + refine ⟨Function.update q v z,?_⟩ + intro a s hs hc + by_cases hvs : v ∈ s + · have hsub : s.erase v ⊆ U := by + intro w hw + have hh := hs (Finset.mem_of_mem_erase hw) + exact (Finset.mem_insert.mp hh).resolve_left (Finset.ne_of_mem_erase hw) + have hcard : (s.erase v).card ≤ 2 := by + have he := Finset.card_erase_add_one hvs + omega + have heq : ∀ w ∈ (s.erase v : Finset V), Function.update q v z w = q w := by + intro w hw + exact Function.update_of_ne (Finset.ne_of_mem_erase hw) _ _ + have hi : LinearIndepOn ℝ (fun w => T a w (Function.update q v z w)) + ((s.erase v : Finset V) : Set V) := by + apply (hq a (s.erase v) hsub (by omega)).congr + intro w hw + dsimp only + rw [heq w hw] + have hn : T a v (Function.update q v z v) ∉ Submodule.span ℝ + ((fun w => T a w (Function.update q v z w)) '' + ((s.erase v : Finset V) : Set V)) := by + rw [Function.update_self] + have him : ((fun w => T a w (Function.update q v z w)) '' + ((s.erase v : Finset V) : Set V)) = + ((fun w => T a w (q w)) '' ((s.erase v : Finset V) : Set V)) := by + apply Set.image_congr + intro w hw + rw [heq w hw] + rw [him] + exact hz ⟨a,⟨s.erase v,hsub,hcard⟩⟩ + have ht := (linearIndepOn_insert (by simp : v ∉ ((s.erase v : Finset V) : Set V))).mpr + ⟨hi,hn⟩ + simpa only [← Finset.coe_insert,Finset.insert_erase hvs] using ht + · have hsub : s ⊆ U := by + intro w hw + have hh := hs hw + rcases Finset.mem_insert.mp hh with rfl | hh + · exact False.elim (hvs hw) + · exact hh + apply (hq a s hsub hc).congr + intro w hw + dsimp only + rw [Function.update_of_ne (by intro h; subst w; exact hvs hw)] + + +@[simp] theorem unit_norm (h : SU2) : ‖(h : ℍ)‖ = 1 := + (quaternion_mem_unitary_iff _).mp h.property + +def leftLinearEquiv (h : SU2) : ℍ ≃ₗ[ℝ] ℍ where + toFun q := (h : ℍ) * q + invFun q := (h⁻¹ : SU2) * q + left_inv q := by simp [← mul_assoc,← Submonoid.coe_mul] + right_inv q := by simp [← mul_assoc,← Submonoid.coe_mul] + map_add' _ _ := mul_add _ _ _ + map_smul' r q := mul_smul_comm r (h : ℍ) q + +@[simp] theorem leftLinearEquiv_apply (h : SU2) (q : ℍ) : + leftLinearEquiv h q = (h : ℍ) * q := rfl + +theorem normalize_left (h : SU2) {q : ℍ} (hq : q ≠ 0) : + normalizeQuaternion ((h : ℍ) * q) = h * normalizeQuaternion q := by + have hh : (h : ℍ) * q ≠ 0 := by + exact (leftLinearEquiv h).map_ne_zero_iff.mpr hq + apply Subtype.ext + rw [normalizeQuaternion_coe_of_ne_zero hh] + change ‖(h : ℍ) * q‖⁻¹ • ((h : ℍ) * q) = (h : ℍ) * (normalizeQuaternion q : ℍ) + rw [normalizeQuaternion_coe_of_ne_zero hq,norm_mul,unit_norm,one_mul,mul_smul_comm] + +section FiniteSimplex +variable {V : Type*} [Fintype V] + +def coordinateSimplex : Set (V → ℝ) := + {weights | (∀ vertex, 0 ≤ weights vertex) ∧ ∑ vertex, weights vertex = 1} + +/-- Closed coordinate face of the standard simplex. -/ +def face (s : Finset V) : Set (V → ℝ) := + {b | b ∈ coordinateSimplex ∧ ∀ v ∉ s, b v = 0} + +/-- The whole two-skeleton of a finite standard simplex. -/ +def triangleSet : Set (V → ℝ) := + ⋃ s : {s : Finset V // s.card ≤ 3}, face s.val + +abbrev TrianglePoint (V : Type*) [Fintype V] := (triangleSet : Set (V → ℝ)) + +theorem mem_triangleSet {b : V → ℝ} : b ∈ triangleSet ↔ + ∃ s : Finset V, s.card ≤ 3 ∧ b ∈ coordinateSimplex ∧ ∀ v ∉ s, b v = 0 := by + simp only [triangleSet,Set.mem_iUnion,face,Set.mem_ofPred_eq,Subtype.exists,exists_prop] + +omit [Fintype V] in +private theorem isClosed_face_support (s : Finset V) : + IsClosed {b : V → ℝ | ∀ v ∉ s, b v = 0} := by + have he : {b : V → ℝ | ∀ v ∉ s, b v = 0} = + ⋂ v, ⋂ (_ : v ∉ s), {b : V → ℝ | b v = 0} := by ext b; simp + rw [he] + exact isClosed_iInter fun v => isClosed_iInter fun _ => + isClosed_eq (continuous_apply v) continuous_const + +theorem isCompact_face (s : Finset V) : IsCompact (face s) := by + have compact_simplex : IsCompact (coordinateSimplex : Set (V → ℝ)) := by + convert isCompact_range + (Convexity.StdSimplex.isEmbedding_toFun_comp_weights ℝ V).continuous using 1 + rw [Convexity.StdSimplex.range_toFun_comp_weights] + ext weights + simp [coordinateSimplex] + exact compact_simplex.inter_right (isClosed_face_support s) + +theorem isCompact_triangleSet : IsCompact (triangleSet : Set (V → ℝ)) := + isCompact_iUnion fun _ => isCompact_face _ + +instance : CompactSpace (TrianglePoint V) := + isCompact_iff_compactSpace.mp isCompact_triangleSet + +theorem point_simplex (b : TrianglePoint V) : (b : V → ℝ) ∈ coordinateSimplex := by + obtain ⟨_,_,h,_⟩ := mem_triangleSet.mp b.property + exact h + +theorem point_exists_nonzero (b : TrianglePoint V) : ∃ v, (b : V → ℝ) v ≠ 0 := by + by_contra! h + have he := (point_simplex b).2 + simp only [h,Finset.sum_const_zero] at he + norm_num at he + +variable (h : V → V → SU2) (q : V → ℍ) + +def rawGauge (a : V) (b : V → ℝ) : ℍ := ∑ v, b v • ((h a v : ℍ) * q v) + +def GeneralPosition : Prop := ∀ a (s : Finset V), s.card ≤ 3 → + LinearIndepOn ℝ (fun v => (h a v : ℍ) * q v) (s : Set V) + +theorem exists_generalPosition : ∃ q : V → ℍ, GeneralPosition h q := by + obtain ⟨q,hq⟩ := exists_triangle_general_position (fun a v => leftLinearEquiv (h a v)) + exact ⟨q,hq⟩ + +theorem rawGauge_ne_zero (hq : GeneralPosition h q) (a : V) (b : TrianglePoint V) : + rawGauge h q a b ≠ 0 := by + classical + obtain ⟨s,hs,hb,hout⟩ := mem_triangleSet.mp b.property + intro he + have he' : ∑ v ∈ s, (b : V → ℝ) v • ((h a v : ℍ) * q v) = 0 := by + rw [← he] + apply Finset.sum_subset (Finset.subset_univ _) + intro v _ hv + rw [hout v hv,zero_smul] + have hz := (linearIndepOn_iff'.mp (hq a s hs)) s b (Set.Subset.refl _) he' + have hall : ∀ v, (b : V → ℝ) v = 0 := by + intro v + by_cases hv : v ∈ s + · exact hz v hv + · exact hout v hv + have heq := hb.2 + simp only [hall,Finset.sum_const_zero] at heq + norm_num at heq + +def gauge (a : V) (b : TrianglePoint V) : SU2 := normalizeQuaternion (rawGauge h q a b) + +theorem continuous_rawGauge (a : V) : Continuous (rawGauge h q a) := + continuous_finsetSum _ fun v _ => (continuous_apply v).smul continuous_const + +theorem continuous_gauge (hq : GeneralPosition h q) (a : V) : Continuous (gauge h q a) := by + apply continuous_iff_continuousAt.mpr + intro b + exact ContinuousAt.comp (f := fun c : TrianglePoint V => rawGauge h q a c) + (normalizeQuaternion_continuousAt (rawGauge_ne_zero h q hq a b)) + ((continuous_rawGauge h q a).comp continuous_subtype_val).continuousAt + +/-- Uniform modulus over all charts, including across the edges of all simplices. -/ +theorem gauges_uniform (hq : GeneralPosition h q) {ε : ℝ} (hε : 0 < ε) : + ∃ δ > 0, ∀ b c : TrianglePoint V, dist b c < δ → + ∀ a, dist (gauge h q a b) (gauge h q a c) < ε := by + have hc : Continuous (fun b : TrianglePoint V => fun a => gauge h q a b) := + continuous_pi fun a => continuous_gauge h q hq a + have hu := CompactSpace.uniformContinuous_of_continuous hc + obtain ⟨δ,hδ,H⟩ := Metric.uniformContinuous_iff.mp hu ε hε + refine ⟨δ,hδ,?_⟩ + intro b c hbc a + exact lt_of_le_of_lt (dist_le_pi_dist (fun a => gauge h q a b) (fun a => gauge h q a c) a) (H hbc) + +end FiniteSimplex + +theorem unitary_dist_left (a b c : SU2) : dist (a * b) (a * c) = dist b c := by + change dist ((a : ℍ) * (b : ℍ)) ((a : ℍ) * (c : ℍ)) = dist (b : ℍ) (c : ℍ) + rw [dist_eq_norm,dist_eq_norm,← mul_sub,norm_mul,unit_norm,one_mul] + +theorem unitary_dist_inv_mul_one (a b : SU2) : dist (a⁻¹ * b) 1 = dist a b := by + rw [← unitary_dist_left a (a⁻¹ * b) 1] + simp [dist_comm] + +theorem unitary_dist_mul_one_le (a b : SU2) : + dist (a * b) 1 ≤ dist a 1 + dist b 1 := by + calc + dist (a * b) 1 ≤ dist (a * b) a + dist a 1 := dist_triangle _ _ _ + _ = dist b 1 + dist a 1 := by + exact congrArg (fun t => t + dist a 1) (by simpa only [mul_one] using unitary_dist_left a b 1) + _ = dist a 1 + dist b 1 := add_comm _ _ + +section Connection +variable {V : Type*} [Fintype V] +variable (L : SimpleGraph V) + +def Related (a b : V) : Prop := a = b ∨ L.Adj a b + +omit [Fintype V] in +theorem Related.refl (a : V) : Related L a a := Or.inl rfl + +omit [Fintype V] in +theorem Related.symm {a b : V} : Related L a b → Related L b a := by + rintro (rfl | h) + · exact Related.refl L _ + · exact Or.inr h.symm + +def Star (a : V) (b : TrianglePoint V) : Prop := + ∀ v, (b : V → ℝ) v ≠ 0 → Related L a v + +def CliquePoint (b : TrianglePoint V) : Prop := + ∀ a, (b : V → ℝ) a ≠ 0 → Star L a b + +def Compatible (b c : TrianglePoint V) : Prop := + ∀ v w, ((b : V → ℝ) v ≠ 0 ∨ (c : V → ℝ) v ≠ 0) → + ((b : V → ℝ) w ≠ 0 ∨ (c : V → ℝ) w ≠ 0) → Related L v w + +def root (b : TrianglePoint V) : V := Classical.choose (point_exists_nonzero b) + +theorem root_mem (b : TrianglePoint V) : (b : V → ℝ) (root b) ≠ 0 := + Classical.choose_spec (point_exists_nonzero b) + +variable (h : V → V → SU2) (q : V → ℍ) + +def FlatConnection : Prop := ∀ a b c, Related L a b → Related L b c → + Related L a c → h a b * h b c = h a c + +theorem rawGauge_transition (hf : FlatConnection L h) {a c : V} + {b : TrianglePoint V} (hac : Related L a c) (ha : Star L a b) (hc : Star L c b) : + rawGauge h q a b = (h a c : ℍ) * rawGauge h q c b := by + classical + simp only [rawGauge,Finset.mul_sum] + apply Finset.sum_congr rfl + intro v _ + by_cases hv : (b : V → ℝ) v = 0 + · simp [hv] + · rw [mul_smul_comm,← mul_assoc,← Submonoid.coe_mul,hf a c v hac (hc v hv) (ha v hv)] + +theorem gauge_transition (hf : FlatConnection L h) (hq : GeneralPosition h q) + {a c : V} {b : TrianglePoint V} (hac : Related L a c) + (ha : Star L a b) (hc : Star L c b) : + gauge h q a b = h a c * gauge h q c b := by + unfold gauge + rw [rawGauge_transition L h q hf hac ha hc] + exact normalize_left _ (rawGauge_ne_zero h q hq c b) + +def chartTransport (a : V) (b c : TrianglePoint V) : SU2 := + (gauge h q a b)⁻¹ * gauge h q a c + +def transport (b c : TrianglePoint V) : SU2 := chartTransport h q (root b) b c + +theorem transport_chart (hf : FlatConnection L h) (hq : GeneralPosition h q) + {b c : TrianglePoint V} (hb : Compatible L b c) {a : V} + (hab : Star L a b) (hac : Star L a c) : + transport h q b c = chartTransport h q a b c := by + have hrb : Star L (root b) b := fun v hv => hb _ _ (Or.inl (root_mem b)) (Or.inl hv) + have hrc : Star L (root b) c := fun v hv => hb _ _ (Or.inl (root_mem b)) (Or.inr hv) + have har : Related L a (root b) := hab _ (root_mem b) + unfold transport chartTransport + rw [gauge_transition L h q hf hq har hab hrb, + gauge_transition L h q hf hq har hac hrc] + group + +theorem compatible_symm {b c : TrianglePoint V} (hb : Compatible L b c) : + Compatible L c b := fun v w hv hw => hb v w hv.symm hw.symm + +theorem transport_reverse (hf : FlatConnection L h) (hq : GeneralPosition h q) + {b c : TrianglePoint V} (hb : Compatible L b c) : + transport h q c b = (transport h q b c)⁻¹ := by + have hrc : Star L (root b) c := fun v hv => hb _ _ (Or.inl (root_mem b)) (Or.inr hv) + have hrb : Star L (root b) b := fun v hv => hb _ _ (Or.inl (root_mem b)) (Or.inl hv) + rw [transport_chart L h q hf hq (compatible_symm L hb) hrc hrb] + unfold transport chartTransport + group + +theorem chartTransport_trans (a : V) (b c d : TrianglePoint V) : + chartTransport h q a b c * chartTransport h q a c d = chartTransport h q a b d := by + unfold chartTransport + group + +theorem exists_large_coordinate (b : TrianglePoint V) : + ∃ a, 1 / (Fintype.card V + 1 : ℝ) < (b : V → ℝ) a := by + by_contra! H + have hs := Finset.sum_le_sum (s := Finset.univ) (fun a _ => H a) + have hb := (point_simplex b).2 + rw [hb,Finset.sum_const,Finset.card_univ,nsmul_eq_mul] at hs + have hn : 0 ≤ (Fintype.card V : ℝ) := Nat.cast_nonneg _ + have hd : 0 < (Fintype.card V : ℝ) + 1 := by positivity + have he := (le_div_iff₀ hd).mp (by simpa only [mul_one_div] using hs) + linarith + +theorem nearby_star {b c : TrianglePoint V} {a : V} + (ha : 1 / (Fintype.card V + 1 : ℝ) < (b : V → ℝ) a) + (hc : CliquePoint L c) (hbc : dist b c < 1 / (Fintype.card V + 1 : ℝ)) : + Star L a c := by + apply hc a + intro he + have hd := lt_of_le_of_lt (dist_le_pi_dist (b : V → ℝ) (c : V → ℝ) a) hbc + rw [he, Real.dist_eq,sub_zero,abs_of_nonneg ((point_simplex b).1 a)] at hd + exact (not_lt_of_ge ha.le) hd + +theorem chartTransport_dist (a : V) (b c : TrianglePoint V) : + dist (chartTransport h q a b c) 1 = dist (gauge h q a b) (gauge h q a c) := + unitary_dist_inv_mul_one _ _ + +theorem transport_uniform (hq : GeneralPosition h q) {ε : ℝ} (hε : 0 < ε) : + ∃ δ > 0, ∀ b c : TrianglePoint V, dist b c < δ → dist (transport h q b c) 1 < ε := by + obtain ⟨δ,hδ,H⟩ := gauges_uniform h q hq hε + exact ⟨δ,hδ,fun b c hbc => (chartTransport_dist h q _ b c).symm ▸ H b c hbc (root b)⟩ + +/-- Two compatible pieces, rather than a chosen homotopy class of paths, suffice. -/ +def edgeTransport (b c d : TrianglePoint V) : SU2 := transport h q b c * transport h q c d + +theorem edgeTransport_chart (hf : FlatConnection L h) (hq : GeneralPosition h q) + {b c d : TrianglePoint V} (hbc : Compatible L b c) (hcd : Compatible L c d) + {a : V} (hab : Star L a b) (hac : Star L a c) (had : Star L a d) : + edgeTransport h q b c d = chartTransport h q a b d := by + rw [edgeTransport,transport_chart L h q hf hq hbc hab hac, + transport_chart L h q hf hq hcd hac had,chartTransport_trans] + +theorem edgeTransport_reverse (hf : FlatConnection L h) (hq : GeneralPosition h q) + {b c d : TrianglePoint V} (hbc : Compatible L b c) (hcd : Compatible L c d) : + edgeTransport h q d c b = (edgeTransport h q b c d)⁻¹ := by + rw [edgeTransport,edgeTransport,transport_reverse L h q hf hq hbc, + transport_reverse L h q hf hq hcd,mul_inv_rev] + +theorem edgeTransport_uniform (hq : GeneralPosition h q) {ε : ℝ} (hε : 0 < ε) : + ∃ δ > 0, ∀ b c d : TrianglePoint V, dist b c < δ → dist c d < δ → + dist (edgeTransport h q b c d) 1 < ε := by + obtain ⟨δ,hδ,H⟩ := transport_uniform h q hq (show 0 < ε/2 by positivity) + refine ⟨δ,hδ,?_⟩ + intro b c d hbc hcd + apply lt_of_le_of_lt (unitary_dist_mul_one_le _ _) + have h₁ := H b c hbc + have h₂ := H c d hcd + linarith + +/-- All three edge images in one chart have exactly trivial triangle holonomy. -/ +theorem edgeTransport_triangle (hf : FlatConnection L h) (hq : GeneralPosition h q) + (b c d u v w : TrianglePoint V) {a : V} + (hbu : Compatible L b u) (huc : Compatible L u c) + (hcv : Compatible L c v) (hvd : Compatible L v d) + (hdw : Compatible L d w) (hwb : Compatible L w b) + (hab : Star L a b) (hac : Star L a c) (had : Star L a d) + (hau : Star L a u) (hav : Star L a v) (haw : Star L a w) : + edgeTransport h q b u c * edgeTransport h q c v d * edgeTransport h q d w b = 1 := by + rw [edgeTransport_chart L h q hf hq hbu huc hab hau hac, + edgeTransport_chart L h q hf hq hcv hvd hac hav had, + edgeTransport_chart L h q hf hq hdw hwb had haw hab] + unfold chartTransport + group + +/-- A uniform local chart for any finite or infinite family of nearby clique points. -/ +theorem nearby_family_chart {I : Type*} (b : TrianglePoint V) (c : I → TrianglePoint V) + (hc : ∀ i, CliquePoint L (c i)) + (hbc : ∀ i, dist b (c i) < 1 / (Fintype.card V + 1 : ℝ)) : + ∃ a, ∀ i, Star L a (c i) := by + obtain ⟨a,ha⟩ := exists_large_coordinate b + exact ⟨a,fun i => nearby_star L ha (hc i) (hbc i)⟩ + +end Connection + +end AffineTransport + + + + +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/CliqueCohomology.lean b/lean/OAI/Topology/EilenbergGanea/CliqueCohomology.lean new file mode 100644 index 0000000000000000000000000000000000000000..df0aca37eff9b1c53c157dab9a0aa574b429ec2f --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/CliqueCohomology.lean @@ -0,0 +1,232 @@ +import OAI.Topology.EilenbergGanea.Model +import Mathlib.CategoryTheory.Abelian.Projective.Ext +import Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic +import Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree +import Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence + +namespace OAI + +noncomputable section + +open Classical Set + +namespace EilenbergGanea +section CliqueSquare +variable {V : Type*} (L : SimpleGraph V) + + def generatorExponent (v : V) : ArtinGroup L →* Multiplicative ℤ := by + classical + exact artinLift L (fun w => Multiplicative.ofAdd (if w = v then 1 else 0)) + (fun _ _ _ => Commute.all _ _) + +@[simp] theorem generatorExponent_of [DecidableEq V] (v w : V) : + generatorExponent L v (artinGenerator L w) = Multiplicative.ofAdd (if w = v then 1 else 0) := by + classical + simp [generatorExponent] + + def heightDifference (v b : V) : (height L).ker := + ⟨artinGenerator L v * (artinGenerator L b)⁻¹, by simp⟩ + + theorem heightDifference_commute (v w b : V) + (hvw : L.Adj v w) (hvb : L.Adj v b) (hwb : L.Adj w b) : + Commute (heightDifference L v b) (heightDifference L w b) := by + apply Subtype.ext + exact (((adjacent_generators_commute L hvw).mul_right + (adjacent_generators_commute L hvb).inv_right).mul_left + (((adjacent_generators_commute L hwb).symm.inv_left).mul_right (Commute.refl _))) + + def cliqueSquare (v w b : V) (hvw : L.Adj v w) (hvb : L.Adj v b) (hwb : L.Adj w b) : + Multiplicative (ℤ × ℤ) →* (height L).ker where + toFun n := heightDifference L v b ^ n.toAdd.1 * heightDifference L w b ^ n.toAdd.2 + map_one' := by simp + map_mul' n m := by + change _ ^ (n.toAdd.1 + m.toAdd.1) * _ ^ (n.toAdd.2 + m.toAdd.2) = _ + rw [zpow_add, zpow_add] + simp only [mul_assoc] + congr 1 + rw [← mul_assoc, ((heightDifference_commute L v w b hvw hvb hwb).zpow_zpow m.toAdd.1 n.toAdd.2).eq, mul_assoc] + + theorem cliqueSquare_injective (v w b : V) (hvw : L.Adj v w) (hvb : L.Adj v b) (hwb : L.Adj w b) : + Function.Injective (cliqueSquare L v w b hvw hvb hwb) := by + classical + have hvw' : v ≠ w := L.ne_of_adj hvw + have hvb' : v ≠ b := L.ne_of_adj hvb + have hwb' : w ≠ b := L.ne_of_adj hwb + intro n m he + have h₁ := congrArg (fun x : (height L).ker => generatorExponent L v x.val) he + have h₂ := congrArg (fun x : (height L).ker => generatorExponent L w x.val) he + have hn₁ : n.toAdd.1 = m.toAdd.1 := by + simpa [cliqueSquare, heightDifference, generatorExponent_of, hvw', hvw'.symm, hvb', hvb'.symm] using congrArg Multiplicative.toAdd h₁ + have hn₂ : n.toAdd.2 = m.toAdd.2 := by + simpa [cliqueSquare, heightDifference, generatorExponent_of, hvw', hwb', hwb'.symm] using congrArg Multiplicative.toAdd h₂ + exact congrArg Multiplicative.ofAdd (Prod.ext hn₁ hn₂) +end CliqueSquare + + def seedCliqueVertex : SeedCell := .inl (.inl none) + def seedCliqueEdge : SeedCell := .inr (.inl (.inl (false, 0))) + def seedCliqueFace : SeedCell := .inr (.inr ⟨false, ⟨0, by decide⟩⟩) + + theorem source_contains_int_square : + ∃ f : Multiplicative (ℤ × ℤ) →* SourceGroup, Function.Injective f := by + have hve : seedGraph.Adj seedCliqueVertex seedCliqueEdge := by + change properFace _ _ ∨ _ + left + simp [properFace, seedCliqueVertex, seedCliqueEdge, edgeVertices, circleStart] + have hvf : seedGraph.Adj seedCliqueVertex seedCliqueFace := by + change properFace _ _ ∨ _ + left + simp [properFace, seedCliqueVertex, seedCliqueFace, sectorVertices, sectorEdges, edgeVertices, sectorCircleEdge, sectorLetter, seedWord, circleStart, circleEnd] + have hef : seedGraph.Adj seedCliqueEdge seedCliqueFace := by + change properFace _ _ ∨ _ + left + simp [properFace, seedCliqueEdge, seedCliqueFace, sectorEdges, sectorCircleEdge, sectorLetter, seedWord] + exact ⟨cliqueSquare seedGraph _ _ _ hve hvf hef, + cliqueSquare_injective seedGraph _ _ _ hve hvf hef⟩ + +section CupCocycle +open groupCohomology +variable {G : Type} [Group G] + +/-- The cup product of two integral exponent homomorphisms. -/ +def exponentCup (a b : G →* Multiplicative ℤ) : cocycles₂ (Rep.trivial ℤ G ℤ) := + ⟨fun p => (a p.1).toAdd * (b p.2).toAdd, by + rw [mem_cocycles₂_iff] + intro g h j + simp only [map_mul, toAdd_mul] + change ((a g).toAdd + (a h).toAdd) * (b j).toAdd + (a g).toAdd * (b h).toAdd = + (a h).toAdd * (b j).toAdd + (a g).toAdd * ((b h).toAdd + (b j).toAdd) + ring⟩ + +/-- Antisymmetrizing on a commuting pair detects a nonzero integral class. -/ +theorem exponentCup_not_coboundary (a b : G →* Multiplicative ℤ) (g h : G) + (hc : Commute g h) + (hag : (a g).toAdd = 1) (hah : (a h).toAdd = 0) + (hbg : (b g).toAdd = 0) (hbh : (b h).toAdd = 1) : + ⇑(exponentCup a b) ∉ coboundaries₂ (Rep.trivial ℤ G ℤ) := by + rintro ⟨f, hf⟩ + have h₁ := congrFun hf (g, h) + have h₂ := congrFun hf (h, g) + change f h - f (g*h) + f g = (a g).toAdd * (b h).toAdd at h₁ + change f g - f (h*g) + f h = (a h).toAdd * (b g).toAdd at h₂ + rw [hag, hbh] at h₁ + rw [hah, hbg, ← hc.eq] at h₂ + change (f h : ℤ) - f (g*h) + f g = 1 * 1 at h₁ + change (f g : ℤ) - f (g*h) + f h = 0 * 0 at h₂ + linarith + +theorem exponentCup_class_ne_zero (a b : G →* Multiplicative ℤ) (g h : G) + (hc : Commute g h) + (hag : (a g).toAdd = 1) (hah : (a h).toAdd = 0) + (hbg : (b g).toAdd = 0) (hbh : (b h).toAdd = 1) : + H2π _ (exponentCup a b) ≠ 0 := by + intro he + exact exponentCup_not_coboundary a b g h hc hag hah hbg hbh + ((H2π_eq_zero_iff (A := Rep.trivial ℤ G ℤ) (exponentCup a b)).mp he) + +end CupCocycle + +section CliqueCohomology +open groupCohomology +variable {V : Type} (L : SimpleGraph V) + +theorem clique_exponent_class_nonzero (v w b : V) + (hvw : L.Adj v w) (hvb : L.Adj v b) (hwb : L.Adj w b) : + ∃ x : H2 (Rep.trivial ℤ (height L).ker ℤ), x ≠ 0 := by + classical + let a := (generatorExponent L v).comp (height L).ker.subtype + let d := (generatorExponent L w).comp (height L).ker.subtype + have hvw' := L.ne_of_adj hvw + have hvb' := L.ne_of_adj hvb + have hwb' := L.ne_of_adj hwb + refine ⟨H2π _ (exponentCup a d), exponentCup_class_ne_zero a d + (heightDifference L v b) (heightDifference L w b) + (heightDifference_commute L v w b hvw hvb hwb) ?_ ?_ ?_ ?_⟩ + all_goals simp [a, d, heightDifference, hvw', hvw'.symm, hvb'.symm, hwb'.symm] + +end CliqueCohomology + + +open CategoryTheory CategoryTheory.Limits + +section +variable {C D : Type*} [Category* C] [Category* D] [Abelian C] [Abelian D] + {X Y : C} (P : ProjectiveResolution X) (F : C ⥤ D) + [F.Additive] [F.Full] [F.Faithful] + [F.PreservesProjectiveObjects] [F.PreservesHomology] + +/-- Vanishing in the literal projective-dimension sense forces every +2-cocycle in a projective resolution to be a coboundary; the fully faithful +exact functor permits us to use this for the representation/group-ring equivalence. -/ +theorem cocycle_boundary_of_projectiveDimension_lt_two + [HasProjectiveDimensionLT (F.obj X) 2] + (f : P.complex.X 2 ⟶ Y) (hf : P.complex.d 3 2 ≫ f = 0) : + ∃ g : P.complex.X 1 ⟶ Y, P.complex.d 2 1 ≫ g = f := by + let := HasExt.standard D + let Q := F.mapProjectiveResolution P + have hmf : Q.complex.d 3 2 ≫ F.map f = 0 := by + change F.map (P.complex.d 3 2) ≫ F.map f = 0 + rw [← F.map_comp, hf, F.map_zero] + have hc := Abelian.Ext.eq_zero_of_hasProjectiveDimensionLT (Q.extMk (F.map f) 3 rfl hmf) 2 (by rfl) + obtain ⟨g, hg⟩ := (Q.extMk_eq_zero_iff (F.map f) 3 rfl hmf 1 rfl).mp hc + change F.obj (P.complex.X 1) ⟶ F.obj Y at g + change F.map (P.complex.d 2 1) ≫ g = F.map f at hg + refine ⟨F.preimage g, F.map_injective ?_⟩ + rw [F.map_comp, F.map_preimage] + exact hg + +/-- The same vanishing expressed in the library's older linear-Yoneda model +of Ext. This theorem proves rather than assumes the bridge between the two APIs. -/ +theorem isZero_homology_two_of_projectiveDimension_lt_two + (R : Type*) [Ring R] [Linear R C] + [HasProjectiveDimensionLT (F.obj X) 2] : + IsZero ((P.complex.linearYonedaObj R Y).homology 2) := by + rw [← HomologicalComplex.exactAt_iff_isZero_homology] + rw [HomologicalComplex.exactAt_iff' _ 1 2 3 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + intro f hf + change P.complex.d 3 2 ≫ f = 0 at hf + exact cocycle_boundary_of_projectiveDimension_lt_two P F f hf +end + +open CategoryTheory CategoryTheory.Limits + +theorem two_le_cohomologicalDimension_of_H2_nonzero (G : Type) [Group G] + (hx : ∃ x : groupCohomology.H2 (Rep.trivial ℤ G ℤ), x ≠ 0) : + 2 ≤ cohomologicalDimension G := by + change (2 : ℕ) ≤ CategoryTheory.projectiveDimension + (ModuleCat.of (MonoidAlgebra ℤ G) (Representation.trivial ℤ G ℤ).asModule) + rw [CategoryTheory.projectiveDimension_ge_iff] + intro hd + let F := Rep.toModuleMonoidAlgebra (k := ℤ) (G := G) + let P := Rep.barResolution ℤ G + let : F.Additive := Functor.additive_of_preserves_binary_products F + have : HasProjectiveDimensionLT (F.obj (Rep.trivial ℤ G ℤ)) 2 := hd + have hz := isZero_homology_two_of_projectiveDimension_lt_two + (Y := Rep.trivial ℤ G ℤ) P F ℤ + have hz' : IsZero (groupCohomology.H2 (Rep.trivial ℤ G ℤ)) := + hz.of_iso (groupCohomologyIso (Rep.trivial ℤ G ℤ) 2 P) + obtain ⟨x, hx⟩ := hx + exact hx ((ModuleCat.isZero_iff_subsingleton.mp hz').elim x 0) + +theorem height_kernel_two_le_cohomologicalDimension {V : Type} (L : SimpleGraph V) + (v w b : V) (hvw : L.Adj v w) (hvb : L.Adj v b) (hwb : L.Adj w b) : + 2 ≤ cohomologicalDimension (height L).ker := + two_le_cohomologicalDimension_of_H2_nonzero _ (clique_exponent_class_nonzero L v w b hvw hvb hwb) + +theorem source_two_le_cohomologicalDimension : 2 ≤ cohomologicalDimension SourceGroup := by + apply height_kernel_two_le_cohomologicalDimension seedGraph seedCliqueVertex seedCliqueEdge seedCliqueFace + · change properFace _ _ ∨ _ + left + simp [properFace, seedCliqueVertex, seedCliqueEdge, edgeVertices, circleStart] + · change properFace _ _ ∨ _ + left + simp [properFace, seedCliqueVertex, seedCliqueFace, sectorVertices, sectorEdges, edgeVertices, sectorCircleEdge, sectorLetter, seedWord, circleStart, circleEnd] + · change properFace _ _ ∨ _ + left + simp [properFace, seedCliqueEdge, seedCliqueFace, sectorEdges, sectorCircleEdge, sectorLetter, seedWord] +end EilenbergGanea + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/CubicalCover.lean b/lean/OAI/Topology/EilenbergGanea/CubicalCover.lean new file mode 100644 index 0000000000000000000000000000000000000000..7fd4678c7c568c0ce4ab8fcf132ef1bf3b333eb5 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/CubicalCover.lean @@ -0,0 +1,822 @@ +import OAI.AlgebraicTopology.Cubical.Realization +import OAI.AlgebraicTopology.Cubical.ArtinChains +import OAI.Topology.EilenbergGanea.Model +import OAI.Topology.EilenbergGanea.SeedConnection +import Mathlib.Topology.Covering.Quotient +import Mathlib.Topology.Covering.Deck +import Mathlib.Topology.Homotopy.Lifting + +namespace OAI + +noncomputable section + +open Classical Set Topology +open scoped Quaternion + +namespace EilenbergGanea.DescendingCube.Data +open CubeInterpolation +variable {G A : Type*} [Group G] {f : A → G} (D : Data f) +variable [Fintype A] + +omit [Fintype A] in +theorem cellComm (c : D.Cell) : (c.directions : Set A).Pairwise + (fun a b => Commute (f a) (f b)) := + fun _ ha _ hb he => D.commute c.top _ _ (c.subset ha) (c.subset hb) he + +omit [Fintype A] in +theorem ones_eq_filter (c : D.Cell) (x : D.Coordinates c) : + D.ones c x = c.directions.filter (fun a => D.fullCoord c x a = 1) := by + ext a + simp only [mem_ones,Finset.mem_filter] + constructor + · rintro ⟨ha,hx⟩ + exact ⟨ha,by simpa only [fullCoord,dite_eq_left ha] using hx⟩ + · rintro ⟨ha,hx⟩ + exact ⟨ha,by simpa only [fullCoord,dite_eq_left ha] using hx⟩ + +omit [Fintype A] in +theorem normalize_fullCoord (c : D.Cell) (x : D.Coordinates c) : + CubeInterpolation.normalize (D.fullCoord c x) = D.normalizedCoord c x := by + funext a + by_cases ha : a ∈ c.directions + · simp only [CubeInterpolation.normalize,fullCoord,normalizedCoord,dite_eq_left ha] + · simp [CubeInterpolation.normalize,fullCoord,normalizedCoord,ha] + +def interpolation (p : D.Point) (φ : G → ℝ) : ℝ := + operator f (D.active p) (D.cellComm (D.pointCell p)) p.coord φ p.top + +theorem active_characteristic_subset (c : D.Cell) (x : D.Coordinates c) : + D.active (D.characteristic c x) ⊆ c.directions := by + intro a ha + by_contra h + apply ((D.mem_active _ _).mp ha) + change D.normalizedCoord c x a = 0 + simp [normalizedCoord,h] + +theorem interpolation_characteristic (c : D.Cell) (x : D.Coordinates c) (φ : G → ℝ) : + D.interpolation (D.characteristic c x) φ = + operator f c.directions (D.cellComm c) (D.fullCoord c x) φ c.top := by + have hsub := D.active_characteristic_subset c x + have he := operator_subset f (D.active (D.characteristic c x)) c.directions + (D.cellComm c) hsub (D.normalizedCoord c x) (by + intro a _ hn + exact not_not.mp (by simpa only [mem_active,characteristic] using hn)) + have hn := operator_normalize f c.directions (D.cellComm c) (D.fullCoord c x) + simp only [normalize_fullCoord,← ones_eq_filter] at hn + have hh := congrArg (fun T : Module.End ℝ (G → ℝ) => T φ c.top) hn + rw [Module.End.mul_apply,translation_apply,he] at hh + exact hh.symm + +theorem interpolation_continuous (φ : G → ℝ) : + Continuous (fun p : D.Point => D.interpolation p φ) := by + apply D.evaluation_quotient.continuous_iff.mpr + apply continuous_sigma + intro c + change Continuous (fun x : D.Coordinates c => D.interpolation (D.characteristic c x) φ) + simp only [interpolation_characteristic] + exact operator_continuous f c.directions _ (D.fullCoord c) + (fun a _ => D.fullCoord_continuous c a) φ c.top + +theorem interpolation_vertex_pos (p : D.Point) : + 0 < D.interpolation p (fun a => if a = p.top then 1 else 0) := by + apply operator_pos + · intro a _; exact ⟨p.nonneg a,p.lt_one a⟩ + · intro a; split_ifs <;> norm_num + · simp + +omit [Fintype A] in +theorem descending_operator_delta_zero (s : Finset A) (g : G) (hs : s ⊆ D.desc g) + (x : A → ℝ) (b : G) (hb : D.length g ≤ D.length b) (hne : b ≠ g) : + operator f s (fun a ha d hd hne => D.commute g a d (hs ha) (hs hd) hne) + x (fun a => if a = b then 1 else 0) g = 0 := by + induction s using Finset.induction_on generalizing g with + | empty => simp [operator_empty,hne.symm] + | @insert a s ha ih => + have hga := hs (Finset.mem_insert_self a s) + have hs0 : s ⊆ D.desc g := fun d hd => hs (Finset.mem_insert_of_mem hd) + have hs1 : s ⊆ D.desc (g * f a) := by + intro d hd + exact D.preserve g a d hga (hs0 hd) (by intro he; exact ha (he ▸ hd)) + have hd := D.decrease g a hga + have hb1 : D.length (g*f a) ≤ D.length b := by omega + have hne1 : b ≠ g*f a := by intro he; rw [he] at hb; omega + have hc : (↑(insert a s) : Set A).Pairwise (fun a d => Commute (f a) (f d)) := + fun _ ha _ hd hne => D.commute g _ _ (hs ha) (hs hd) hne + change operator f (insert a s) hc x (fun a => if a = b then 1 else 0) g = 0 + rw [operator_insert f s a ha,Module.End.mul_apply,blend_apply] + rw [ih g hs0 hb hne,ih (g*f a) hs1 hb1 hne1] + ring + +theorem interpolation_vertex_zero (p : D.Point) (b : G) + (hb : D.length p.top ≤ D.length b) (hne : b ≠ p.top) : + D.interpolation p (fun a => if a = b then 1 else 0) = 0 := + D.descending_operator_delta_zero (D.active p) p.top (D.pointCell p).subset p.coord b hb hne + +theorem interpolation_top_eq (p q : D.Point) + (he : ∀ φ, D.interpolation p φ = D.interpolation q φ) : p.top = q.top := by + have length_le (p q : D.Point) (he : ∀ φ, D.interpolation p φ = D.interpolation q φ) : + D.length q.top ≤ D.length p.top := by + by_contra hn + have hlt : D.length p.top < D.length q.top := lt_of_not_ge hn + have hne : q.top ≠ p.top := by intro eq; rw [eq] at hlt; exact lt_irrefl _ hlt + have hz := D.interpolation_vertex_zero p q.top hlt.le hne + have hp := D.interpolation_vertex_pos q + rw [← he,hz] at hp + exact lt_irrefl _ hp + have h₁ := length_le p q he + by_contra hne + have hz := D.interpolation_vertex_zero q p.top h₁ hne + have hp := D.interpolation_vertex_pos p + rw [he,hz] at hp + exact lt_irrefl _ hp + +variable (exponent : A → G →* Multiplicative ℝ) +variable (hexponent : ∀ g a, a ∈ D.desc g → ∀ b, b ∈ D.desc g → + (exponent a (f b)).toAdd = if a = b then 1 else 0) + +include hexponent in +theorem interpolation_exponent (p : D.Point) (a : A) (ha : a ∈ D.desc p.top) : + D.interpolation p (fun g => (exponent a g).toAdd) = + (exponent a p.top).toAdd + p.coord a := by + refine (operator_linear f (exponent a) (D.active p) + (D.cellComm (D.pointCell p)) p.coord p.top).trans ?_ + congr 1 + have he : ∀ b ∈ D.active p, (exponent a (f b)).toAdd = if a = b then 1 else 0 := + fun b hb => hexponent p.top a ha b ((D.pointCell p).subset hb) + simp only [Finset.sum_congr rfl (fun b hb => congrArg (fun t : ℝ => p.coord b * t) (he b hb)), + mul_ite,mul_one,mul_zero,Finset.sum_ite_eq] + by_cases h : p.coord a = 0 + · simp [h] + · simp [mem_active,h] + +include exponent hexponent in +theorem interpolation_injective : Function.Injective + (fun p : D.Point => fun φ : G → ℝ => D.interpolation p φ) := by + intro p q he + have he' : ∀ φ, D.interpolation p φ = D.interpolation q φ := fun φ => congrFun he φ + have hb := D.interpolation_top_eq p q he' + apply Point.ext hb + funext a + by_cases ha : a ∈ D.desc p.top + · have hq : a ∈ D.desc q.top := by simpa only [hb] using ha + have hh := he' (fun g => (exponent a g).toAdd) + rw [D.interpolation_exponent exponent hexponent p a ha, + D.interpolation_exponent exponent hexponent q a hq,hb] at hh + exact add_left_cancel hh + · have hp : p.coord a = 0 := by_contra (fun hn => ha (p.support a hn)) + have hq : q.coord a = 0 := by + by_contra hn + exact ha (by simpa only [hb] using q.support a hn) + rw [hp,hq] + +include exponent hexponent in +theorem point_t2 : T2Space D.Point := + T2Space.of_injective_continuous + (D.interpolation_injective exponent hexponent) + (continuous_pi (fun φ => D.interpolation_continuous φ)) + +end EilenbergGanea.DescendingCube.Data + +open Classical Topology +namespace WeakRealization + +/-- A homeomorphism is induced by point-separating coordinates and actual +continuous lifts on each characteristic disk, in both directions. -/ +def homeomorph {ι κ X Y Z : Type*} {E : ι → Type*} {F : κ → Type*} + [TopologicalSpace X] [TopologicalSpace Y] + [∀ i, TopologicalSpace (E i)] [∀ j, TopologicalSpace (F j)] + (e : ((i : ι) × E i) → X) (f : ((j : κ) × F j) → Y) + (he : IsQuotientMap e) (hf : IsQuotientMap f) + (J : X → Z) (K : Y → Z) (hJ : Function.Injective J) (hK : Function.Injective K) + (hxy : ∀ i, ∃ φ : C(E i,Y), ∀ t, K (φ t) = J (e ⟨i,t⟩)) + (hyx : ∀ j, ∃ φ : C(F j,X), ∀ t, J (φ t) = K (f ⟨j,t⟩)) : X ≃ₜ Y := by + have hx : ∀ x, ∃ y, K y = J x := by + intro x + obtain ⟨⟨i,t⟩,rfl⟩ := he.surjective x + obtain ⟨φ,hφ⟩ := hxy i + exact ⟨φ t,hφ t⟩ + have hy : ∀ y, ∃ x, J x = K y := by + intro y + obtain ⟨⟨j,t⟩,rfl⟩ := hf.surjective y + obtain ⟨φ,hφ⟩ := hyx j + exact ⟨φ t,hφ t⟩ + let A : X → Y := fun x => (hx x).choose + let B : Y → X := fun y => (hy y).choose + have hA : ∀ x, K (A x) = J x := fun x => (hx x).choose_spec + have hB : ∀ y, J (B y) = K y := fun y => (hy y).choose_spec + refine { + toEquiv := { + toFun := A + invFun := B + left_inv := fun x => hJ ((hB (A x)).trans (hA x)) + right_inv := fun y => hK ((hA (B y)).trans (hB y)) } + continuous_toFun := ?_ + continuous_invFun := ?_ } + · apply he.continuous_iff.mpr + apply continuous_sigma + intro i + obtain ⟨φ,hφ⟩ := hxy i + have hh : (fun t => A (e ⟨i,t⟩)) = φ := by + funext t + exact hK ((hA _).trans (hφ t).symm) + change Continuous (fun t => A (e ⟨i,t⟩)) + rw [hh] + exact φ.continuous + · apply hf.continuous_iff.mpr + apply continuous_sigma + intro j + obtain ⟨φ,hφ⟩ := hyx j + have hh : (fun t => B (f ⟨j,t⟩)) = φ := by + funext t + exact hJ ((hB _).trans (hφ t).symm) + change Continuous (fun t => B (f ⟨j,t⟩)) + rw [hh] + exact φ.continuous + +end WeakRealization + +namespace EilenbergGanea.CubeInterpolation +open CubicalChains.Reorientation +variable {G V : Type*} [Group G] + +/-- Interpolation in a listed cube, independent of any topological model. -/ +def listed (f : V → G) (w : List V) (x : V → ℝ) : Module.End ℝ (G → ℝ) := + (w.map (fun v => blend (f v) (x v))).prod + +@[simp] theorem listed_nil (f : V → G) (x : V → ℝ) : listed f [] x = 1 := rfl +@[simp] theorem listed_cons (f : V → G) (v : V) (w : List V) (x : V → ℝ) : + listed f (v::w) x = blend (f v) (x v) * listed f w x := rfl + +theorem operator_listed [DecidableEq V] (f : V → G) (w : List V) (hw : w.Nodup) + (hc : (w.toFinset : Set V).Pairwise (fun v u => Commute (f v) (f u))) (x : V → ℝ) : + operator f w.toFinset hc x = listed f w x := + Finset.noncommProd_toFinset w _ _ hw + +/-- Literal multilinear invariance under reversing selected cube directions. -/ +theorem listed_reorientation (f : V → G) (w : List (Signed V)) + (hw : w.Pairwise (fun a b => Commute (f a.1) (f b.1))) + (x : Signed V → ℝ) (z : V → ℝ) + (hx : ∀ a ∈ w, x a = if a.2 then 1-z a.1 else z a.1) (φ : G → ℝ) (g : G) : + listed (step f) w x φ g = listed f (w.map Prod.fst) z φ (origin f g w) := by + induction w generalizing g with + | nil => rfl + | cons a w ih => + obtain ⟨ha,hw⟩ := List.pairwise_cons.mp hw + have hxw : ∀ b ∈ w, x b = if b.2 then 1-z b.1 else z b.1 := + fun b hb => hx b (by simp [hb]) + simp only [listed_cons,List.map_cons,Module.End.mul_apply,blend_apply, + ih hw hxw,hx a (by simp),step,origin] + cases hb : a.2 + · simp only [Bool.false_eq_true,↓reduceIte] + rw [origin_shift f g (f a.1) w ha] + · simp only [↓reduceIte] + rw [origin_shift f g (f a.1)⁻¹ w (fun b hb => (ha b hb).inv_left), + inv_mul_cancel_right] + ring + +end EilenbergGanea.CubeInterpolation + +namespace EilenbergGanea.ArtinCubicalTopology +open TraceWords CubeInterpolation CubicalChains.Reorientation +variable {V : Type*} [Fintype V] (L : SimpleGraph V) + +local instance : Std.Symm L.Adj := ⟨fun _ _ h => h.symm⟩ +local instance : Std.Irrefl L.Adj := ⟨fun _ => L.irrefl⟩ + +abbrev f := artinGenerator L +abbrev comm := fun v w h => adjacent_generators_commute L (v := v) (w := w) h +abbrev D := artinDescendingData L +abbrev Positive := CubeRealization.Point L (f L) (comm L) +abbrev Descending := (D L).Point + +omit [Fintype V] in +@[simp] theorem step_eq (a : Letter V) : step (f L) a = letterValue (f L) (invLetter a) := by + cases a with | mk v b => cases b <;> rfl + +def exponent (v : V) : ArtinGroup L →* Multiplicative ℝ := + artinLift L (fun w => Multiplicative.ofAdd (if v = w then (1 : ℝ) else 0)) + (fun _ _ _ => Commute.all _ _) + +omit [Fintype V] in +@[simp] theorem exponent_generator (v w : V) : + (exponent L v (f L w)).toAdd = if v = w then 1 else 0 := by + simp [exponent,f] + +omit [Fintype V] in +@[simp] theorem height_generator (v : V) : (height L (f L v)).toAdd = 1 := by + exact congrArg Multiplicative.toAdd (PresentedGroup.toGroup.of _) + +def signedExponent (a : Letter V) : ArtinGroup L →* Multiplicative ℝ := + artinLift L (fun v => Multiplicative.ofAdd + (if a.1 = v then (if a.2 then (-1 : ℝ) else 1) else 0)) + (fun _ _ _ => Commute.all _ _) + +theorem signedExponent_step (g : ArtinGroup L) (a : Letter V) (ha : a ∈ (D L).desc g) + (b : Letter V) (hb : b ∈ (D L).desc g) : + (signedExponent L a (letterValue (f L) (invLetter b))).toAdd = if a = b then 1 else 0 := by + by_cases he : a = b + · subst b + rcases a with ⟨v,b⟩ + cases b <;> simp [signedExponent,letterValue,invLetter,f] + · have hi : Independent L a b := rightDescents_pairwise L g + (by simpa [D,artinDescendingData] using ha) (by simpa [D,artinDescendingData] using hb) he + have hv : a.1 ≠ b.1 := hi.ne + rcases b with ⟨v,b⟩ + cases b <;> simp [signedExponent,letterValue,invLetter,f,hv,he] + +theorem positive_interp_inj : Function.Injective + (fun p : Positive L => fun φ => CubeRealization.interpolation L (f L) (comm L) p φ) := + CubeRealization.interpolation_injective L (f L) (comm L) (height L) (height_generator L) + (exponent L) (exponent_generator L) + +theorem descending_interp_inj : Function.Injective + (fun p : Descending L => fun φ => (D L).interpolation p φ) := + (D L).interpolation_injective (signedExponent L) (by + intro g a ha b hb + by_cases he : a = b <;> simpa [he] using signedExponent_step L g a ha b hb) + +def flip (b : Bool) (t : unitInterval) : unitInterval := + if b then unitInterval.symm t else t + +@[simp] theorem flip_flip (b : Bool) (t : unitInterval) : flip b (flip b t) = t := by + cases b <;> simp [flip] + +theorem flip_continuous (b : Bool) : Continuous (flip b) := by + cases b + · exact continuous_id + · exact unitInterval.continuous_symm + +def vertexEquiv (w : Word V) (hw : (w.map Prod.fst).Nodup) : + w.toFinset ≃ (w.map Prod.fst).toFinset := + Equiv.ofBijective (fun a => ⟨a.val.1,by + exact List.mem_toFinset.mpr (List.mem_map.mpr ⟨a.val,List.mem_toFinset.mp a.property,rfl⟩)⟩) (by + constructor + · intro a b he + apply Subtype.ext + exact (List.nodup_map_iff_inj_on (hw.of_map Prod.fst)).mp hw + a.val (List.mem_toFinset.mp a.property) b.val (List.mem_toFinset.mp b.property) (congrArg Subtype.val he) + · intro v + obtain ⟨a,ha,he⟩ := List.mem_map.mp (List.mem_toFinset.mp v.property) + exact ⟨⟨a,by simpa using ha⟩,Subtype.ext he⟩) + +omit [Fintype V] in +@[simp] theorem vertexEquiv_val (w : Word V) (hw : (w.map Prod.fst).Nodup) + (a : w.toFinset) : (vertexEquiv w hw a).val = a.val.1 := rfl + +def toPositiveCoords (w : Word V) (hw : (w.map Prod.fst).Nodup) + (x : w.toFinset → unitInterval) : (w.map Prod.fst).toFinset → unitInterval := + fun v => flip ((vertexEquiv w hw).symm v).val.2 (x ((vertexEquiv w hw).symm v)) + +omit [Fintype V] in +@[simp] theorem toPositiveCoords_apply (w : Word V) (hw : (w.map Prod.fst).Nodup) + (x : w.toFinset → unitInterval) (a : w.toFinset) : + toPositiveCoords w hw x (vertexEquiv w hw a) = flip a.val.2 (x a) := by + simp [toPositiveCoords] + +omit [Fintype V] in +theorem toPositiveCoords_continuous (w : Word V) (hw : (w.map Prod.fst).Nodup) : + Continuous (toPositiveCoords w hw) := + continuous_pi (fun _ => (flip_continuous _).comp (continuous_apply _)) + +def toDescendingCoords (w : Word V) (hw : (w.map Prod.fst).Nodup) + (z : (w.map Prod.fst).toFinset → unitInterval) : w.toFinset → unitInterval := + fun a => flip a.val.2 (z (vertexEquiv w hw a)) + +omit [Fintype V] in +theorem toDescendingCoords_continuous (w : Word V) (hw : (w.map Prod.fst).Nodup) : + Continuous (toDescendingCoords w hw) := + continuous_pi (fun _ => (flip_continuous _).comp (continuous_apply _)) + +omit [Fintype V] in +@[simp] theorem toPositive_toDescending (w : Word V) (hw : (w.map Prod.fst).Nodup) + (z : (w.map Prod.fst).toFinset → unitInterval) : + toPositiveCoords w hw (toDescendingCoords w hw z) = z := by + funext v + obtain ⟨a,rfl⟩ := (vertexEquiv w hw).surjective v + simp [toDescendingCoords] + +def positiveCell (g : ArtinGroup L) (w : Word V) (hw : (w.map Prod.fst).Pairwise L.Adj) : + CubeRealization.Cell (G := ArtinGroup L) L where + base := origin (f L) g w + directions := (w.map Prod.fst).toFinset + clique := fun _ ha _ hb he => hw.forall (List.mem_toFinset.mp ha) (List.mem_toFinset.mp hb) he + +def descendingCell (g : ArtinGroup L) (w : Word V) + (hd : ∀ a ∈ w, a ∈ rightDescents L g) : (D L).Cell where + top := g + directions := w.toFinset + subset a ha := by simpa [D,artinDescendingData] using hd a (List.mem_toFinset.mp ha) + +theorem interpolation_reorientation (g : ArtinGroup L) (w : Word V) + (hw : (w.map Prod.fst).Pairwise L.Adj) (hd : ∀ a ∈ w, a ∈ rightDescents L g) + (x : (D L).Coordinates (descendingCell L g w hd)) (φ : ArtinGroup L → ℝ) : + (D L).interpolation ((D L).characteristic (descendingCell L g w hd) x) φ = + CubeRealization.interpolation L (f L) (comm L) + (CubeRealization.characteristic (f L) (comm L) (positiveCell L g w hw) + (toPositiveCoords w hw.nodup x)) φ := by + refine ((D L).interpolation_characteristic (descendingCell L g w hd) x φ).trans ?_ + refine Eq.trans ?_ (CubeRealization.interpolation_characteristic L (f L) (comm L) + (positiveCell L g w hw) (toPositiveCoords w hw.nodup x) φ).symm + have hf : (fun a : Letter V => letterValue (artinGenerator L) (invLetter a)) = step (f L) := + funext (fun a => (step_eq L a).symm) + erw [operator_listed _ w (hw.nodup.of_map Prod.fst),operator_listed _ _ hw.nodup] + have hop := congrArg (fun k : Letter V → ArtinGroup L => listed k w) hf + rw [hop] + apply listed_reorientation + · exact (List.pairwise_map.mp hw).imp (fun hh => adjacent_generators_commute L hh) + · intro a ha + let aa : w.toFinset := ⟨a,by simpa using ha⟩ + have h₁ : (D L).fullCoord (descendingCell L g w hd) x a = (x aa : ℝ) := by + exact (D L).fullCoord_mem (descendingCell L g w hd) x aa + have h₂ : CubeRealization.fullCoord (positiveCell L g w hw) + (toPositiveCoords w hw.nodup x) a.1 = (flip a.2 (x aa) : ℝ) := by + have hh := CubeRealization.fullCoord_mem (positiveCell L g w hw) + (toPositiveCoords w hw.nodup x) (vertexEquiv w hw.nodup aa) + exact hh.trans (congrArg (fun z : unitInterval => (z : ℝ)) + (toPositiveCoords_apply w hw.nodup x aa)) + rw [h₁,h₂] + cases h : a.2 <;> simp [flip] + +theorem descendingCell_rep (c : (D L).Cell) : + ∃ (g : ArtinGroup L) (w : Word V) (_hw : (w.map Prod.fst).Pairwise L.Adj) + (hd : ∀ a ∈ w, a ∈ rightDescents L g), descendingCell L g w hd = c := by + let w := c.directions.toList + have hd : ∀ a ∈ w, a ∈ rightDescents L c.top := by + intro a ha + have hh := c.subset (Finset.mem_toList.mp ha) + simpa [D,artinDescendingData] using hh + have hw : (w.map Prod.fst).Pairwise L.Adj := by + apply List.pairwise_map.mpr + apply c.directions.nodup_toList.pairwise_of_forall_ne + intro a ha b hb he + exact rightDescents_pairwise L c.top (hd a ha) (hd b hb) he + refine ⟨c.top,w,hw,hd,?_⟩ + cases c with + | mk g s hs => + dsimp only [descendingCell,w] + congr + exact s.toList_toFinset + +omit [Fintype V] in +theorem positiveCell_rep (c : CubeRealization.Cell (G := ArtinGroup L) L) : + ∃ (g : ArtinGroup L) (w : Word V) (hw : (w.map Prod.fst).Pairwise L.Adj) + (_hd : ∀ a ∈ w, a ∈ rightDescents L g), positiveCell L g w hw = c := by + let v := c.directions.toList + have hv : v.Pairwise L.Adj := c.directions.nodup_toList.pairwise_of_forall_ne + (fun a ha b hb he => c.clique (Finset.mem_toList.mp ha) (Finset.mem_toList.mp hb) he) + let o := CubeDescents.orient L c.base v + have hw : (o.2.map Prod.fst).Pairwise L.Adj := by + simpa only [o,CubeDescents.orient_map] using hv + have hd : ∀ a ∈ o.2, a ∈ rightDescents L o.1 := CubeDescents.orient_descents L c.base v hv + refine ⟨o.1,o.2,hw,hd,?_⟩ + have hb : origin (f L) o.1 o.2 = c.base := CubeDescents.origin_orient L c.base v hv + have hs : (o.2.map Prod.fst).toFinset = c.directions := by + simp only [o,CubeDescents.orient_map,v,Finset.toList_toFinset] + cases c with + | mk g s hc => + change CubeRealization.Cell.mk (origin (f L) o.1 o.2) (o.2.map Prod.fst).toFinset _ = _ + congr + +theorem descending_local_lift (c : (D L).Cell) : + ∃ φ : C((D L).Coordinates c,Positive L), ∀ x, + (fun ψ => CubeRealization.interpolation L (f L) (comm L) (φ x) ψ) = + (fun ψ => (D L).interpolation ((D L).characteristic c x) ψ) := by + obtain ⟨g,w,hw,hd,rfl⟩ := descendingCell_rep L c + refine ⟨⟨fun x => CubeRealization.characteristic (f L) (comm L) (positiveCell L g w hw) + (toPositiveCoords w hw.nodup x), + (CubeRealization.characteristic_continuous (f L) (comm L) (positiveCell L g w hw)).comp + (toPositiveCoords_continuous w hw.nodup)⟩,?_⟩ + intro x + funext ψ + exact (interpolation_reorientation L g w hw hd x ψ).symm + +theorem positive_local_lift (c : CubeRealization.Cell (G := ArtinGroup L) L) : + ∃ φ : C(CubeRealization.Coordinates c,Descending L), ∀ x, + (fun ψ => (D L).interpolation (φ x) ψ) = + (fun ψ => CubeRealization.interpolation L (f L) (comm L) + (CubeRealization.characteristic (f L) (comm L) c x) ψ) := by + obtain ⟨g,w,hw,hd,rfl⟩ := positiveCell_rep L c + refine ⟨⟨fun x => (D L).characteristic (descendingCell L g w hd) (toDescendingCoords w hw.nodup x), + ((D L).characteristic_continuous (descendingCell L g w hd)).comp + (toDescendingCoords_continuous w hw.nodup)⟩,?_⟩ + intro x + funext ψ + change (D L).interpolation ((D L).characteristic (descendingCell L g w hd) + (toDescendingCoords w hw.nodup x)) ψ = _ + change (w.map Prod.fst).toFinset → unitInterval at x + simpa only [toPositive_toDescending] using interpolation_reorientation L g w hw hd + (toDescendingCoords w hw.nodup x) ψ + +/-- Reorientation preserves the actual weak topologies, not only cellular chains. -/ +def reorient : Descending L ≃ₜ Positive L := + WeakRealization.homeomorph (D L).evaluation (CubeRealization.evaluation (f L) (comm L)) + (D L).evaluation_quotient (CubeRealization.evaluation_quotient (f L) (comm L)) + (fun p ψ => (D L).interpolation p ψ) + (fun p ψ => CubeRealization.interpolation L (f L) (comm L) p ψ) + (descending_interp_inj L) (positive_interp_inj L) + (descending_local_lift L) (positive_local_lift L) + +variable [Nonempty V] + +/-- The ordinary positive-cube CW realization is genuinely contractible. -/ +theorem positive_contractible : ContractibleSpace (Positive L) := by + let : ContractibleSpace (Descending L) := artinDescending_contractible L + exact (reorient L).symm.contractibleSpace + +end EilenbergGanea.ArtinCubicalTopology + +open Classical Set Topology +namespace CompactChart + +/-- A characteristic map which has singleton fibers over its open cell has a +continuous inverse there. Compactness is used only on the closed disk; no +regularity of the attaching sphere is required. -/ +theorem continuousOn_symm {A X : Type*} [TopologicalSpace A] [TopologicalSpace X] + [T2Space X] (e : PartialEquiv A X) (K : Set A) (hK : IsCompact K) + (hsub : e.source ⊆ K) (hc : ContinuousOn e K) + (hboundary : ∀ a ∈ K, e a ∈ e.target → a ∈ e.source) : + ContinuousOn e.symm e.target := by + let : CompactSpace K := isCompact_iff_compactSpace.mp hK + let f : K → X := fun a => e a + have hf : Continuous f := continuousOn_iff_continuous_domRestrict.mp hc + let r := e.target.restrictPreimage f + have hr : Function.Surjective r := by + intro x + refine ⟨⟨⟨e.symm x,hsub (e.map_target x.property)⟩,?_⟩,?_⟩ + · change e (e.symm x) ∈ e.target + rw [e.right_inv x.property] + exact x.property + · exact Subtype.ext (e.right_inv x.property) + have hq : IsQuotientMap r := + (hf.isClosedMap.restrictPreimage e.target).isQuotientMap hf.restrictPreimage hr + apply continuousOn_iff_continuous_domRestrict.mpr + apply hq.continuous_iff.mpr + have he : (fun x : e.target => e.symm x) ∘ r = + (fun a : f ⁻¹' e.target => (a.val.val : A)) := by + funext a + exact e.left_inv (hboundary a.val a.val.property a.property) + change Continuous ((fun x : e.target => e.symm x) ∘ r) + rw [he] + exact continuous_subtype_val.comp continuous_subtype_val + +end CompactChart + +namespace EilenbergGanea.CubeRealization + +section +open Metric +variable {G V : Type*} [Group G] [Fintype V] +variable {L : SimpleGraph V} (f : V → G) +variable (comm : ∀ v w, L.Adj v w → Commute (f v) (f w)) + +theorem chartInverse_continuousOn_of_t2 [T2Space (Point (G := G) L f comm)] + {n : ℕ} (c : DimCell (G := G) (L := L) n) : + ContinuousOn (chart f comm c).symm (chart f comm c).target := by + apply CompactChart.continuousOn_symm (chart f comm c) (closedBall 0 1) + (isCompact_closedBall _ _) ball_subset_closedBall (chart_continuous f comm c).continuousOn + intro t ht he + change pointCell (chart f comm c t) = c.val at he + change t ∈ ball 0 1 + by_contra hn + have hs : t ∈ sphere 0 1 := mem_sphere.mpr + (le_antisymm (mem_closedBall.mp ht) (le_of_not_gt hn)) + have hd := boundary_dimension_lt f comm c hs + rw [he,c.property] at hd + exact (lt_irrefl _) hd + +/-- The ordinary CW structure follows from the genuine normalized-cube gluing; +only Hausdorffness and compact characteristic disks are used. -/ +@[instance_reducible] def cwComplexOfT2 [T2Space (Point (G := G) L f comm)] : CWComplex (univ : Set (Point (G := G) L f comm)) where + cell := DimCell (G := G) (L := L) + map := fun _ c => chart f comm c + source_eq := fun _ _ => rfl + continuousOn := fun _ c => (chart_continuous f comm c).continuousOn + continuousOn_symm := fun _ c => chartInverse_continuousOn_of_t2 f comm c + pairwiseDisjoint' := by + intro a _ b _ hab + change Disjoint (chart f comm a.2 '' ball 0 1) (chart f comm b.2 '' ball 0 1) + rw [chart_image_ball,chart_image_ball] + apply Set.disjoint_left.mpr + intro p ha hb + apply hab + have he : a.2.val = b.2.val := ha.symm.trans hb + have hn : a.1 = b.1 := a.2.property.symm.trans ((congrArg (fun c => c.directions.card) he).trans b.2.property) + cases a with | mk n a => + cases b with | mk m b => + dsimp at hn + subst m + exact congrArg (Sigma.mk n) (Subtype.ext he) + mapsTo' := chart_mapsTo f comm + closed' := by + intro A _ hA + apply (evaluation_quotient f comm).isClosed_preimage.mp + rw [isClosed_sigma_iff] + intro c + let d : DimCell (G := G) (L := L) c.directions.card := ⟨c,rfl⟩ + have hh := (hA _ d).preimage (characteristic_continuous f comm c) + rw [chart_image_disk] at hh + change IsClosed (characteristic f comm c ⁻¹' (A ∩ Set.range (characteristic f comm c))) at hh + change IsClosed (characteristic f comm c ⁻¹' A) + simpa only [Set.preimage_inter,Set.preimage_range,Set.inter_univ] using hh + union' := by + apply Set.eq_univ_of_forall + intro p + let d : DimCell (G := G) (L := L) (pointCell p).directions.card := ⟨pointCell p,rfl⟩ + apply Set.mem_iUnion.mpr + refine ⟨_,Set.mem_iUnion.mpr ⟨d,?_⟩⟩ + rw [chart_image_disk] + exact ⟨pointCoordinates p,characteristic_point f comm p⟩ + +end + +variable {G Q V : Type*} [Group G] [Group Q] [Fintype V] +variable {L : SimpleGraph V} (f : V → G) +variable (comm : ∀ v w, L.Adj v w → Commute (f v) (f w)) +variable (q : G →* Q) + +include comm in +omit [Fintype V] in +theorem mappedComm : ∀ v w, L.Adj v w → Commute ((q ∘ f) v) ((q ∘ f) w) := + fun v w hvw => (comm v w hvw).map q + +/-- Applying a group homomorphism only to the initial vertices of cubes. -/ +def mapPoint (p : Point (G := G) L f comm) : Point (G := Q) L (q ∘ f) (mappedComm f comm q) where + base := q p.base + coord := p.coord + nonneg := p.nonneg + lt_one := p.lt_one + clique := p.clique + +def mapCell (c : Cell (G := G) L) : Cell (G := Q) L where + base := q c.base + directions := c.directions + clique := c.clique + +omit [Fintype V] in +@[simp] theorem mapPoint_base (p : Point (G := G) L f comm) : + (mapPoint f comm q p).base = q p.base := rfl + +omit [Fintype V] in +@[simp] theorem mapPoint_coord (p : Point (G := G) L f comm) : + (mapPoint f comm q p).coord = p.coord := rfl + +omit [Fintype V] in +@[simp] theorem mapPoint_characteristic (c : Cell (G := G) L) (x : Coordinates c) : + mapPoint f comm q (characteristic f comm c x) = + characteristic (q ∘ f) (mappedComm f comm q) (mapCell q c) x := by + apply Point.ext + · change q (c.base * product f comm (ones c x) _) = + q c.base * product (q ∘ f) (mappedComm f comm q) (ones c x) _ + rw [map_mul] + congr 1 + exact Finset.map_noncommProd _ _ _ q + · rfl + +theorem mapPoint_continuous : Continuous (mapPoint f comm q) := by + apply (evaluation_quotient f comm).continuous_iff.mpr + apply continuous_sigma + intro c + change Continuous (fun x => mapPoint f comm q (characteristic f comm c x)) + simp only [mapPoint_characteristic] + exact characteristic_continuous (q ∘ f) (mappedComm f comm q) (mapCell q c) + +omit [Fintype V] in +theorem mapCell_surjective (hq : Function.Surjective q) : Function.Surjective (mapCell (L := L) q) := by + rintro ⟨a,s,hs⟩ + obtain ⟨g,rfl⟩ := hq a + exact ⟨⟨g,s,hs⟩,rfl⟩ + +omit [Fintype V] in +theorem mapPoint_surjective (hq : Function.Surjective q) : Function.Surjective (mapPoint f comm q) := by + rintro ⟨a,x,hx,ht,hc⟩ + obtain ⟨g,rfl⟩ := hq a + exact ⟨⟨g,x,hx,ht,hc⟩,rfl⟩ + +/-- The base-label quotient is a genuine topological quotient for the weak +cubical topologies, proved by lifting each actual characteristic disk. -/ +theorem mapPoint_quotient (hq : Function.Surjective q) : IsQuotientMap (mapPoint f comm q) := by + apply isQuotientMap_iff_isClosed.mpr + refine ⟨mapPoint_surjective f comm q hq,?_⟩ + intro A + constructor + · exact fun hA => hA.preimage (mapPoint_continuous f comm q) + · intro hA + apply (evaluation_quotient (q ∘ f) (mappedComm f comm q)).isClosed_preimage.mp + rw [isClosed_sigma_iff] + intro c + obtain ⟨d,rfl⟩ := mapCell_surjective q hq c + have hh := hA.preimage (characteristic_continuous f comm d) + change IsClosed ((fun x => mapPoint f comm q (characteristic f comm d x)) ⁻¹' A) at hh + change IsClosed ((fun x : Coordinates d => + characteristic (q ∘ f) (mappedComm f comm q) (mapCell q d) x) ⁻¹' A) + simpa only [mapPoint_characteristic] using hh + +omit [Fintype V] in +/-- The literal group-kernel orbits are exactly the fibers of the cube map. -/ +theorem mapPoint_eq_iff_orbit (p r : Point (G := G) L f comm) : + mapPoint f comm q p = mapPoint f comm q r ↔ p ∈ MulAction.orbit q.ker r := by + constructor + · intro he + have hb : q p.base = q r.base := congrArg Point.base he + have hx : p.coord = r.coord := congrArg (fun z : Point (G := Q) L (q ∘ f) + (mappedComm f comm q) => z.coord) he + let g : q.ker := ⟨p.base * r.base⁻¹,by simp only [MonoidHom.mem_ker,map_mul,map_inv,hb,mul_inv_cancel]⟩ + refine ⟨g,?_⟩ + apply Point.ext + · change (p.base * r.base⁻¹) * r.base = p.base + simp [mul_assoc] + · exact hx.symm + · rintro ⟨g,rfl⟩ + apply Point.ext + · change q ((g : G) * r.base) = q r.base + rw [map_mul,g.property,one_mul] + · rfl + +/-- The quotient homeomorphism respects the actual weak topologies. -/ +def kernelQuotientHomeomorph (hq : Function.Surjective q) : + Quotient (MulAction.orbitRel q.ker (Point (G := G) L f comm)) ≃ₜ + Point (G := Q) L (q ∘ f) (mappedComm f comm q) := + (Homeomorph.Quotient.congrRight (fun p r => (mapPoint_eq_iff_orbit f comm q p r).symm)).trans + (Topology.IsQuotientMap.homeomorph (f := ⟨mapPoint f comm q,mapPoint_continuous f comm q⟩) + (mapPoint_quotient f comm q hq)) + +variable (h : G →* Multiplicative ℤ) (hf : ∀ v, (h (f v)).toAdd = 1) +variable (exponent : V → G →* Multiplicative ℝ) +variable (hexponent : ∀ v w, (exponent v (f w)).toAdd = if v = w then 1 else 0) + +include h hf exponent hexponent in +theorem quotientPoint_t2 (hq : Function.Surjective q) : + T2Space (Point (G := Q) L (q ∘ f) (mappedComm f comm q)) := by + let := point_t2 L f comm h hf exponent hexponent + let := point_weaklyLocallyCompact L f comm + exact (kernelQuotientHomeomorph f comm q hq).t2Space + +include h hf exponent hexponent in +theorem mapPoint_covering (hq : Function.Surjective q) : + IsQuotientCoveringMap (mapPoint f comm q) q.ker where + toIsQuotientMap := mapPoint_quotient f comm q hq + continuous_const_smul := continuous_const_smul + apply_eq_iff_mem_orbit := mapPoint_eq_iff_orbit f comm q _ _ + disjoint := (subgroup_quotient_covering f comm h hf exponent hexponent q.ker).disjoint + +end EilenbergGanea.CubeRealization + +namespace EilenbergGanea +universe u +namespace ArtinCubicalTopology +open CubeRealization +variable {V : Type u} [Fintype V] [Nonempty V] (L : SimpleGraph V) + +omit [Fintype V] in +theorem height_surjective : Function.Surjective (height L) := by + intro n + let v : V := Classical.choice inferInstance + refine ⟨f L v ^ n.toAdd,?_⟩ + rw [map_zpow] + apply Multiplicative.toAdd.injective + change n.toAdd • (height L (f L v)).toAdd = n.toAdd + simp only [height_generator,zsmul_eq_mul,mul_one,Int.cast_id] + +def HeightQuotient := Point L ((height L) ∘ f L) (mappedComm (f L) (comm L) (height L)) + +instance : TopologicalSpace (HeightQuotient L) := inferInstanceAs (TopologicalSpace + (Point L ((height L) ∘ f L) (mappedComm (f L) (comm L) (height L)))) + +/-- An ordinary cubical classifying space for the height kernel, with one cube +for every integral level and clique. Contractibility above is the explicit +word-length contraction, and the fundamental-group identification reuses +Mathlib's checked covering-monodromy equivalence. -/ +theorem height_hasClassifyingSpace (d : ℕ) + (hd : ∀ s : Finset V, (s : Set V).Pairwise L.Adj → s.card ≤ d) : + HasClassifyingSpace.{u} (height L).ker d := by + let X := Point L ((height L) ∘ f L) (mappedComm (f L) (comm L) (height L)) + let E := Positive L + let : ContractibleSpace E := positive_contractible L + let : T2Space X := quotientPoint_t2 (f L) (comm L) (height L) + (height L) (height_generator L) (exponent L) (exponent_generator L) (height_surjective L) + let : Topology.CWComplex (Set.univ : Set X) := + cwComplexOfT2 ((height L) ∘ f L) (mappedComm (f L) (comm L) (height L)) + let p : E → X := mapPoint (f L) (comm L) (height L) + have hp : IsQuotientCoveringMap p (height L).ker := + mapPoint_covering (f L) (comm L) (height L) (height L) (height_generator L) + (exponent L) (exponent_generator L) (height_surjective L) + have hs : Function.Surjective p := mapPoint_surjective (f L) (comm L) (height L) (height_surjective L) + let : PathConnectedSpace X := hs.pathConnectedSpace hp.continuous + let e : E := Classical.choice (inferInstance : Nonempty E) + refine ⟨X,inferInstance,inferInstance,inferInstance,?_,inferInstance,p e,?_, + E,inferInstance,inferInstance,p,hp.isCoveringMap,hs⟩ + · intro k hk + exact ⟨fun c => Nat.not_lt_of_ge ((c.property.symm ▸ hd c.val.directions c.val.clique)) hk⟩ + · exact ⟨(hp.fundamentalGroupEquiv ⟨e,rfl⟩).trans (MulEquiv.inv' ((height L).ker)).symm⟩ + +end ArtinCubicalTopology + +/-- The fixed source group has an ordinary three-dimensional classifying CW +space, with an actually contractible surjective covering. -/ +theorem source_hasClassifyingSpace_three : HasClassifyingSpace.{0} SourceGroup 3 := + ArtinCubicalTopology.height_hasClassifyingSpace seedGraph 3 SeedConnection.clique_card_le_three +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/Dimension.lean b/lean/OAI/Topology/EilenbergGanea/Dimension.lean new file mode 100644 index 0000000000000000000000000000000000000000..8b4e20093b3d29a23b2a5d8028963e09e2101ccf --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/Dimension.lean @@ -0,0 +1,115 @@ +import OAI.Topology.EilenbergGanea.SeedContraction +import OAI.Topology.EilenbergGanea.LevelBasis +import OAI.Topology.EilenbergGanea.CliqueCohomology + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea.SeedEncoding +@[simp] theorem cellEquiv_symm_apply (i : Fin 103) : cellEquiv.symm i = cellAt i := rfl +end EilenbergGanea.SeedEncoding +namespace EilenbergGanea +noncomputable abbrev sourceVertexOrder : LinearOrder SeedCell := + LinearOrder.lift' SeedEncoding.cellEquiv SeedEncoding.cellEquiv.injective +local instance : LinearOrder SeedCell := sourceVertexOrder +local instance : Preorder SeedCell := sourceVertexOrder.toPartialOrder.toPreorder +local instance : LT SeedCell := sourceVertexOrder.toLT +local instance : LE SeedCell := sourceVertexOrder.toLE + +@[simp] theorem sourceVertexOrder_lt (a b : SeedCell) : + a < b ↔ SeedEncoding.cellEquiv a < SeedEncoding.cellEquiv b := Iff.rfl + +theorem source_valid_to_index (w : List SeedCell) (hw : SimplicialChains.Valid seedGraph w) : + SimplicialChains.Valid SeedChainCertificate.graph (w.map SeedEncoding.cellEquiv) := by + constructor + · rw [List.pairwise_map] + exact hw.1 + · rw [List.pairwise_map] + simpa only [SeedChainCertificate.graph,SimpleGraph.comap_adj, + ← SeedEncoding.cellEquiv_symm_apply,Equiv.symm_apply_apply] using hw.2 + +theorem index_valid_to_source (w : List (Fin 103)) + (hw : SimplicialChains.Valid SeedChainCertificate.graph w) : + SimplicialChains.Valid seedGraph (w.map SeedEncoding.cellEquiv.symm) := by + constructor + · rw [List.pairwise_map] + simpa only [sourceVertexOrder_lt,Equiv.apply_symm_apply] using hw.1 + · rw [List.pairwise_map] + exact hw.2 + +/-- Relabeling uses the original seed graph and merely chooses an order on its +vertices for the signed integral chain convention. -/ +noncomputable def sourceLinkContraction (K : SimplicialChains.Contraction SeedChainCertificate.graph) : + SimplicialChains.Contraction seedGraph := + K.reindex SeedEncoding.cellEquiv.symm (index_valid_to_source) (source_valid_to_index) + +end EilenbergGanea + +namespace EilenbergGanea +local instance : LinearOrder SeedCell := sourceVertexOrder +local instance : Preorder SeedCell := sourceVertexOrder.toPartialOrder.toPreorder +local instance : LT SeedCell := sourceVertexOrder.toLT +local instance : LE SeedCell := sourceVertexOrder.toLE + +theorem source_valid_length_le (w : List SeedCell) (hw : SimplicialChains.Valid seedGraph w) : + w.length ≤ 3 := by + simpa only [List.length_map] using + SeedChainCertificate.valid_length_le (w.map SeedEncoding.cellEquiv) (source_valid_to_index w hw) + +theorem source_cd_eq_two_of_contraction + (K : SimplicialChains.Contraction SeedChainCertificate.graph) : + cohomologicalDimension SourceGroup = 2 := by + apply le_antisymm + · exact LevelBasis.artin_height_kernel_cd_le_two seedGraph seedBase seed_connected.preconnected + (sourceLinkContraction K) source_valid_length_le + · exact source_two_le_cohomologicalDimension + +/-- The exact remaining geometric interface is not limited to finite or +countable presentations. This endpoint excludes any ordinary presentation +whose actual integral equivariant cellular boundaries freely span cycles. -/ +theorem source_no_boundary_basis_of_contraction + (K : SimplicialChains.Contraction SeedChainCertificate.graph) + {A R : Type*} (a₀ : A → SourceGroup) + (ha₀ : Function.Surjective (wordValue a₀)) + (r₀ : R → FreeGroup A) (hr₀ : ∀ i, wordValue a₀ (r₀ i) = 1) + (hp₀ : (wordValue a₀).ker = Subgroup.normalClosure (Set.range r₀)) + (E : BasedChains SourceGroup R ≃ₗ[ℤ] cycles a₀) + (hE : ∀ c, (E c : BasedChains SourceGroup A) = relatorChainMap a₀ r₀ c) : False := by + let : Group.ResiduallyFinite SourceGroup := source_residuallyFinite + exact LevelBasis.no_boundary_basis_presentation seedGraph seedBase seed_connected.preconnected + (sourceLinkContraction K) source_valid_length_le SourceTransport.source_small_labels + a₀ ha₀ r₀ hr₀ hp₀ E hE + +end EilenbergGanea + + + +namespace EilenbergGanea + +/-- Literal integral cohomological dimension of the source's fixed group. -/ +theorem source_cohomologicalDimension : cohomologicalDimension SourceGroup = 2 := + source_cd_eq_two_of_contraction SeedChainCertificate.contraction + +/-- No arbitrary-alphabet genuine presentation has its relators as an integral +basis of Cayley cycles. -/ +theorem source_no_boundary_basis + {A R : Type*} (a₀ : A → SourceGroup) + (ha₀ : Function.Surjective (wordValue a₀)) + (r₀ : R → FreeGroup A) (hr₀ : ∀ i, wordValue a₀ (r₀ i) = 1) + (hp₀ : (wordValue a₀).ker = Subgroup.normalClosure (Set.range r₀)) + (E : BasedChains SourceGroup R ≃ₗ[ℤ] cycles a₀) + (hE : ∀ c, (E c : BasedChains SourceGroup A) = relatorChainMap a₀ r₀ c) : False := + source_no_boundary_basis_of_contraction SeedChainCertificate.contraction + a₀ ha₀ r₀ hr₀ hp₀ E hE + +end EilenbergGanea + + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/IntegralDegree.lean b/lean/OAI/Topology/EilenbergGanea/IntegralDegree.lean new file mode 100644 index 0000000000000000000000000000000000000000..e5fec02e7e741e4a2d1999bbaa08002f1743f2f0 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/IntegralDegree.lean @@ -0,0 +1,1408 @@ +import OAI.Topology.EilenbergGanea.UnitaryWords +import Mathlib.Analysis.Calculus.DifferentialForm.Basic +import Mathlib.MeasureTheory.Integral.DivergenceTheorem +import Mathlib.Analysis.BoxIntegral.DivergenceTheorem +import Mathlib.Analysis.Calculus.BumpFunction.InnerProduct +import Mathlib.MeasureTheory.Integral.Bochner.Basic +import Mathlib.Analysis.Calculus.FDeriv.Equiv + +namespace OAI + +noncomputable section + +open Set Filter Topology MeasureTheory +open scoped ContDiff + +open scoped ContDiff +open Set Filter Topology +namespace EilenbergGanea +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] + [FiniteDimensional ℝ E] +/- Avoidance of an arbitrary open boundary makes the selected fiber +compact whenever the closure of the open set is compact. -/ +omit [NormedSpace ℝ E] [FiniteDimensional ℝ E] in +theorem compact_selected_fiber (f : E → E) (y : E) (U : Set E) + (hU : IsOpen U) (hc : IsCompact (closure U)) (hf : ContinuousOn f (closure U)) + (hb : ∀ x ∈ frontier U, f x ≠ y) : IsCompact (U ∩ f ⁻¹' {y}) := by + have he : U ∩ f ⁻¹' {y} = closure U ∩ f ⁻¹' {y} := by + ext x + constructor + · exact fun ⟨hx, hy⟩ => ⟨subset_closure hx, hy⟩ + · rintro ⟨hx, hy⟩ + refine ⟨?_, hy⟩ + by_contra hn + exact hb x ⟨hx, by simpa only [hU.interior_eq] using hn⟩ hy + rw [he] + exact hc.of_isClosed_subset (hf.preimage_isClosed_of_isClosed isClosed_closure + isClosed_singleton) inter_subset_left + +/- The determinant retains its sign on a sufficiently small neighborhood +of a regular point. -/ +theorem exists_constant_jacobian_sign_patch (f : E → E) {x : E} + (hf : ContDiff ℝ 1 f) (hd : (fderiv ℝ f x).det ≠ 0) (W : Set E) + (hW : IsOpen W) (hxW : x ∈ W) : + ∃ V : Set E, IsOpen V ∧ x ∈ V ∧ V ⊆ W ∧ InjOn f V ∧ IsOpen (f '' V) ∧ + ∀ z ∈ V, (fderiv ℝ f z).det = + (if 0 < (fderiv ℝ f x).det then 1 else -1) * |(fderiv ℝ f z).det| := by + let d : E → ℝ := fun z => (fderiv ℝ f z).det + have hc : Continuous d := ContinuousLinearMap.continuous_det.comp + (hf.continuous_fderiv (by norm_num)) + let e := (fderiv ℝ f x).toContinuousLinearEquivOfDetNeZero hd + have hf' : HasFDerivAt f (e : E →L[ℝ] E) x := + (hf.differentiable (by norm_num) x).hasFDerivAt + let p := hf.contDiffAt.toOpenPartialHomeomorph f hf' (by norm_num) + have hxP : x ∈ p.source := hf.contDiffAt.mem_toOpenPartialHomeomorph_source hf' (by norm_num) + let A : Set E := if 0 < d x then {z | 0 < d z} else {z | d z < 0} + have hA : IsOpen A := by + dsimp [A] + split_ifs + · exact isOpen_lt continuous_const hc + · exact isOpen_lt hc continuous_const + have hxA : x ∈ A := by + dsimp [A] + split_ifs with hp + · exact hp + · exact lt_of_le_of_ne (le_of_not_gt hp) hd + let V := W ∩ p.source ∩ A + have hV : IsOpen V := (hW.inter p.open_source).inter hA + refine ⟨V, hV, ⟨⟨hxW, hxP⟩, hxA⟩, fun _ h => h.1.1, + p.injOn.mono (fun _ h => h.1.2), ?_, ?_⟩ + · exact p.isOpen_image_of_subset_source hV (fun _ h => h.1.2) + · intro z hz + have hzA := hz.2 + dsimp [A] at hzA + split_ifs at hzA ⊢ with hp + · change 0 < (fderiv ℝ f z).det at hzA + simp [abs_of_pos hzA] + · change (fderiv ℝ f z).det < 0 at hzA + simp [abs_of_neg hzA] + +/- Finitely many regular roots admit pairwise disjoint inverse neighborhoods, +all contained in the prescribed isolating open set. -/ +theorem disjoint_regular_inverse_patches (f : E → E) (hf : ContDiff ℝ 1 f) + (U : Set E) (hU : IsOpen U) (S : Set E) (hS : S.Finite) + (hSU : S ⊆ U) (hd : ∀ x ∈ S, (fderiv ℝ f x).det ≠ 0) : + ∃ V : S → Set E, + (∀ x, IsOpen (V x) ∧ (x : E) ∈ V x ∧ V x ⊆ U ∧ InjOn f (V x) ∧ + IsOpen (f '' V x) ∧ ∀ z ∈ V x, (fderiv ℝ f z).det = + (if 0 < (fderiv ℝ f x).det then 1 else -1) * |(fderiv ℝ f z).det|) ∧ + Pairwise (fun x y => Disjoint (V x) (V y)) := by + classical + obtain ⟨W, hW, hdisj⟩ := hS.t2_separation + have hp (x : S) := exists_constant_jacobian_sign_patch f hf (hd x x.property) + (U ∩ W x) (hU.inter (hW x).2) ⟨hSU x.property, (hW x).1⟩ + choose V hopen hmem hsub hinj himg hsign using hp + refine ⟨V, fun x => ⟨hopen x, hmem x, fun _ h => (hsub x h).1, + hinj x, himg x, hsign x⟩, ?_⟩ + intro x y hxy + exact (hdisj x.property y.property (fun he => hxy (Subtype.ext he))).mono + (fun _ h => (hsub x h).2) (fun _ h => (hsub y h).2) + +/- Compactness shrinks the target neighborhood so that all selected +preimages remain in the chosen inverse patches. It does not assert a +smooth boundary or a proper global map. -/ +omit [NormedSpace ℝ E] [FiniteDimensional ℝ E] in +theorem exists_target_neighborhood_of_patches {ι : Type*} [Fintype ι] + (f : E → E) (y : E) (U : Set E) (hU : IsOpen U) + (hc : IsCompact (closure U)) (hf : ContinuousOn f (closure U)) + (hb : ∀ x ∈ frontier U, f x ≠ y) (V : ι → Set E) + (hV : ∀ i, IsOpen (V i)) (himg : ∀ i, IsOpen (f '' V i)) + (hy : ∀ i, y ∈ f '' V i) + (hcover : ∀ x ∈ U, f x = y → ∃ i, x ∈ V i) : + ∃ N : Set E, IsOpen N ∧ y ∈ N ∧ (∀ i, N ⊆ f '' V i) ∧ + ∀ x ∈ U, f x ∈ N → ∃ i, x ∈ V i := by + let K := closure U \ ⋃ i, V i + have hK : IsCompact K := hc.diff (isOpen_iUnion hV) + have hclosed : IsClosed (f '' K) := (hK.image_of_continuousOn + (hf.mono (fun _ h => h.1))).isClosed + have hyK : y ∉ f '' K := by + rintro ⟨x, ⟨hxcl, hxV⟩, hxy⟩ + have hxU : x ∈ U := by + by_contra hn + exact hb x ⟨hxcl, by simpa only [hU.interior_eq] using hn⟩ hxy + obtain ⟨i, hi⟩ := hcover x hxU hxy + exact hxV (mem_iUnion.mpr ⟨i, hi⟩) + refine ⟨(f '' K)ᶜ ∩ ⋂ i, f '' V i, + hclosed.isOpen_compl.inter (isOpen_iInter_of_finite himg), + ⟨hyK, mem_iInter.mpr hy⟩, ?_, ?_⟩ + · intro i z hz + exact mem_iInter.mp hz.2 i + · intro x hxU hxN + by_contra hn + apply hxN.1 + refine ⟨x, ⟨subset_closure hxU, ?_⟩, rfl⟩ + simpa only [mem_iUnion] using hn + +end EilenbergGanea + +open Set MeasureTheory +namespace EilenbergGanea +section SignedIntegralDegree +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] + [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] + (μ : Measure E) [μ.IsAddHaarMeasure] + +/- The integral representative of local degree against a target bump. -/ +def jacobianIntegral (f : E → E) (U : Set E) (ρ : E → ℝ) : ℝ := + ∫ x in U, (fderiv ℝ f x).det * ρ (f x) ∂μ + +/- The signed change-of-variables formula on one regular inverse patch. -/ +theorem jacobianIntegral_of_injOn (f : E → E) (U : Set E) (hU : MeasurableSet U) + (hf : ∀ x ∈ U, DifferentiableAt ℝ f x) (hinj : InjOn f U) + (ρ : E → ℝ) (σ : ℝ) (hσ : ∀ x ∈ U, + (fderiv ℝ f x).det = σ * |(fderiv ℝ f x).det|) : + jacobianIntegral μ f U ρ = σ * ∫ y in f '' U, ρ y ∂μ := by + have hc := integral_image_eq_integral_abs_det_fderiv_smul μ hU + (fun x hx => (hf x hx).hasFDerivAt.hasFDerivWithinAt) hinj ρ + rw [jacobianIntegral, hc, ← integral_const_mul] + apply setIntegral_congr_fun hU + intro x hx + dsimp only + calc + _ = (σ * |(fderiv ℝ f x).det|) * ρ (f x) := congrArg (· * ρ (f x)) (hσ x hx) + _ = _ := by simp only [smul_eq_mul, mul_assoc] + +/- If the normalized target bump is supported inside an inverse patch, the +patch contributes exactly the sign of its Jacobian. -/ +theorem jacobianIntegral_inverse_patch (f : E → E) (U : Set E) (hU : MeasurableSet U) + (hf : ∀ x ∈ U, DifferentiableAt ℝ f x) (hinj : InjOn f U) + (ρ : E → ℝ) (σ : ℝ) (hσ : ∀ x ∈ U, + (fderiv ℝ f x).det = σ * |(fderiv ℝ f x).det|) + (hsupp : Function.support ρ ⊆ f '' U) (hunit : ∫ y, ρ y ∂μ = 1) : + jacobianIntegral μ f U ρ = σ := by + rw [jacobianIntegral_of_injOn μ f U hU hf hinj ρ σ hσ] + have he : (∫ y in f '' U, ρ y ∂μ) = ∫ y, ρ y ∂μ := by + apply setIntegral_eq_integral_of_forall_compl_eq_zero + intro y hy + by_contra hn + exact hy (hsupp hn) + rw [he, hunit, mul_one] + +/- Excision and finite additivity of the analytic degree representative. -/ +omit [FiniteDimensional ℝ E] [BorelSpace E] [μ.IsAddHaarMeasure] in +theorem jacobianIntegral_sum_patches {ι : Type*} [Fintype ι] + (f : E → E) (U : Set E) (hU : MeasurableSet U) (V : ι → Set E) + (hV : ∀ i, MeasurableSet (V i)) (hsub : ∀ i, V i ⊆ U) + (hdisj : Pairwise (fun i j => Disjoint (V i) (V j))) (ρ : E → ℝ) + (hsupp : ∀ x ∈ U, ρ (f x) ≠ 0 → ∃ i, x ∈ V i) + (hint : IntegrableOn (fun x => (fderiv ℝ f x).det * ρ (f x)) U μ) : + jacobianIntegral μ f U ρ = ∑ i, jacobianIntegral μ f (V i) ρ := by + unfold jacobianIntegral + rw [setIntegral_eq_of_subset_of_forall_sdiff_eq_zero hU + (iUnion_subset hsub)] + · exact integral_iUnion_fintype hV hdisj (fun i => hint.mono_set (hsub i)) + · rintro x ⟨hxU, hxV⟩ + have hz : ρ (f x) = 0 := by + by_contra hn + obtain ⟨i, hi⟩ := hsupp x hxU hn + exact hxV (mem_iUnion.mpr ⟨i, hi⟩) + rw [hz, mul_zero] + +/- The regular signed-count formula, once disjoint inverse patches and a +small normalized target bump have been chosen. -/ +theorem jacobianIntegral_eq_sum_signs {ι : Type*} [Fintype ι] + (f : E → E) (U : Set E) (hU : MeasurableSet U) (V : ι → Set E) + (hV : ∀ i, MeasurableSet (V i)) (hsub : ∀ i, V i ⊆ U) + (hdisj : Pairwise (fun i j => Disjoint (V i) (V j))) + (hf : ∀ x ∈ U, DifferentiableAt ℝ f x) (hinj : ∀ i, InjOn f (V i)) + (ρ : E → ℝ) (σ : ι → ℝ) + (hσ : ∀ i x, x ∈ V i → (fderiv ℝ f x).det = σ i * |(fderiv ℝ f x).det|) + (hcovered : ∀ x ∈ U, ρ (f x) ≠ 0 → ∃ i, x ∈ V i) + (hsupp : ∀ i, Function.support ρ ⊆ f '' V i) + (hunit : ∫ y, ρ y ∂μ = 1) + (hint : IntegrableOn (fun x => (fderiv ℝ f x).det * ρ (f x)) U μ) : + jacobianIntegral μ f U ρ = ∑ i, σ i := by + rw [jacobianIntegral_sum_patches μ f U hU V hV hsub hdisj ρ hcovered hint] + apply Finset.sum_congr rfl + intro i _ + exact jacobianIntegral_inverse_patch μ f (V i) (hV i) + (fun x hx => hf x (hsub i hx)) (hinj i) ρ (σ i) (hσ i) (hsupp i) hunit + +/- A vanishing selected preimage forces every supported degree integral to +vanish. This implication supplies existence from nonzero degree. -/ +omit [FiniteDimensional ℝ E] [BorelSpace E] [μ.IsAddHaarMeasure] in +theorem jacobianIntegral_eq_zero_of_no_preimage (f : E → E) (U : Set E) (ρ : E → ℝ) + (h : ∀ x ∈ U, ρ (f x) = 0) : jacobianIntegral μ f U ρ = 0 := by + apply setIntegral_eq_zero_of_forall_eq_zero + intro x hx + simp only [h x hx, mul_zero] + +end SignedIntegralDegree +end EilenbergGanea + +namespace EilenbergGanea +open Set MeasureTheory Filter Topology +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] + [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] + (μ : Measure E) [μ.IsAddHaarMeasure] + +/-- A normalized smooth target bump can be supported in any prescribed +neighborhood of the target. -/ +theorem exists_normalized_smooth_bump (y : E) (N : Set E) (hN : IsOpen N) (hy : y ∈ N) : + ∃ ρ : E → ℝ, ContDiff ℝ ∞ ρ ∧ HasCompactSupport ρ ∧ tsupport ρ ⊆ N ∧ + (∫ z, ρ z ∂μ) = 1 := by + obtain ⟨r, hr, hball⟩ := Metric.isOpen_iff.mp hN y hy + let b : ContDiffBump y := ⟨r / 4, r / 2, by linarith, by linarith⟩ + refine ⟨b.normed μ, b.contDiff_normed, b.hasCompactSupport_normed, + ?_, b.integral_normed⟩ + rw [b.tsupport_normed_eq] + intro z hz + apply hball + exact lt_of_le_of_lt hz (by change r / 2 < r; linarith) + +/-- One target neighborhood works for every normalized continuous density. +This uniformity lets the same density be used throughout a localized homotopy. -/ +theorem regular_signed_count_neighborhood (f : E → E) (hf : ContDiff ℝ 1 f) + (y : E) (U : Set E) (hU : IsOpen U) (hc : IsCompact (closure U)) + (hb : ∀ x ∈ frontier U, f x ≠ y) (s : Finset E) + (hs : ∀ x, x ∈ s ↔ x ∈ U ∧ f x = y) + (hd : ∀ x ∈ s, (fderiv ℝ f x).det ≠ 0) : + ∃ N : Set E, IsOpen N ∧ y ∈ N ∧ ∀ ρ : E → ℝ, Continuous ρ → + Function.support ρ ⊆ N → (∫ z, ρ z ∂μ) = 1 → + jacobianIntegral μ f U ρ = ∑ x ∈ s, (if 0 < (fderiv ℝ f x).det then 1 else -1) := by + classical + obtain ⟨V, hV, hdisj⟩ := disjoint_regular_inverse_patches f hf U hU + (s : Set E) s.finite_toSet (fun x hx => ((hs x).mp hx).1) hd + obtain ⟨N, hN, hyN, hNimg, hNpre⟩ := exists_target_neighborhood_of_patches f y U hU + hc hf.continuous.continuousOn hb V (fun i => (hV i).1) + (fun i => (hV i).2.2.2.2.1) + (fun i => ⟨i, (hV i).2.1, ((hs i).mp i.property).2⟩) + (fun x hx hxy => ⟨⟨x, (hs x).mpr ⟨hx, hxy⟩⟩, (hV _).2.1⟩) + refine ⟨N, hN, hyN, fun ρ hρ hρN hρunit => ?_⟩ + have hcont : Continuous (fun x => (fderiv ℝ f x).det * ρ (f x)) := + (ContinuousLinearMap.continuous_det.comp (hf.continuous_fderiv (by norm_num))).mul + (hρ.comp hf.continuous) + have hint : IntegrableOn (fun x => (fderiv ℝ f x).det * ρ (f x)) U μ := + (hcont.continuousOn.integrableOn_compact hc).mono_set subset_closure + have hcount := jacobianIntegral_eq_sum_signs μ f U hU.measurableSet V + (fun i => (hV i).1.measurableSet) (fun i => (hV i).2.2.1) hdisj + (fun x _ => hf.differentiable (by norm_num) x) (fun i => (hV i).2.2.2.1) + ρ (fun i => if 0 < (fderiv ℝ f i).det then 1 else -1) + (fun i => (hV i).2.2.2.2.2) + (fun x hx hn => hNpre x hx (hρN hn)) + (fun i z hz => hNimg i (hρN hz)) hρunit hint + exact hcount.trans (Finset.sum_subtype (p := fun x => x ∈ (s : Set E)) s + (fun _ => Iff.rfl) (fun x => (if 0 < (fderiv ℝ f x).det then 1 else -1 : ℝ))).symm + +/-- The analytic representative has exactly the expected signed regular +count for a sufficiently concentrated normalized target bump. -/ +theorem regular_signed_count_density (f : E → E) (hf : ContDiff ℝ 1 f) + (y : E) (U : Set E) (hU : IsOpen U) (hc : IsCompact (closure U)) + (hb : ∀ x ∈ frontier U, f x ≠ y) (s : Finset E) + (hs : ∀ x, x ∈ s ↔ x ∈ U ∧ f x = y) + (hd : ∀ x ∈ s, (fderiv ℝ f x).det ≠ 0) : + ∃ ρ : E → ℝ, ContDiff ℝ ∞ ρ ∧ HasCompactSupport ρ ∧ (∫ z, ρ z ∂μ) = 1 ∧ + jacobianIntegral μ f U ρ = ∑ x ∈ s, (if 0 < (fderiv ℝ f x).det then 1 else -1) := by + classical + obtain ⟨V, hV, hdisj⟩ := disjoint_regular_inverse_patches f hf U hU + (s : Set E) s.finite_toSet (fun x hx => ((hs x).mp hx).1) hd + obtain ⟨N, hN, hyN, hNimg, hNpre⟩ := exists_target_neighborhood_of_patches f y U hU + hc hf.continuous.continuousOn hb V (fun i => (hV i).1) + (fun i => (hV i).2.2.2.2.1) + (fun i => ⟨i, (hV i).2.1, ((hs i).mp i.property).2⟩) + (fun x hx hxy => ⟨⟨x, (hs x).mpr ⟨hx, hxy⟩⟩, (hV _).2.1⟩) + obtain ⟨ρ, hρ, hρc, hρN, hρunit⟩ := exists_normalized_smooth_bump μ y N hN hyN + refine ⟨ρ, hρ, hρc, hρunit, ?_⟩ + have hcont : Continuous (fun x => (fderiv ℝ f x).det * ρ (f x)) := + (ContinuousLinearMap.continuous_det.comp (hf.continuous_fderiv (by norm_num))).mul + (hρ.continuous.comp hf.continuous) + have hint : IntegrableOn (fun x => (fderiv ℝ f x).det * ρ (f x)) U μ := + (hcont.continuousOn.integrableOn_compact hc).mono_set subset_closure + have hcount := jacobianIntegral_eq_sum_signs μ f U hU.measurableSet V + (fun i => (hV i).1.measurableSet) (fun i => (hV i).2.2.1) hdisj + (fun x _ => hf.differentiable (by norm_num) x) (fun i => (hV i).2.2.2.1) + ρ (fun i => if 0 < (fderiv ℝ f i).det then 1 else -1) + (fun i => (hV i).2.2.2.2.2) + (fun x hx hn => hNpre x hx (hρN (subset_tsupport ρ hn))) + (fun i z hz => hNimg i (hρN (subset_tsupport ρ hz))) hρunit hint + exact hcount.trans (Finset.sum_subtype (p := fun x => x ∈ (s : Set E)) s + (fun _ => Iff.rfl) (fun x => (if 0 < (fderiv ℝ f x).det then 1 else -1 : ℝ))).symm + +end EilenbergGanea + +open Set MeasureTheory Filter Topology +namespace EilenbergGanea + +/-- Standard coordinate basis as a tuple of vectors. -/ +def coordinateBasis (n : ℕ) : Fin n → (Fin n → ℝ) := fun i => Pi.single i 1 + +/-- The signed coordinate coefficient of an n-form in dimension n+1. -/ +def formFlux {n : ℕ} (form : (Fin (n + 1) → ℝ) → + (Fin (n + 1) → ℝ) [⋀^Fin n]→L[ℝ] ℝ) (i : Fin (n + 1)) + (x : Fin (n + 1) → ℝ) : ℝ := + (-1 : ℝ) ^ i.val * form x (i.removeNth (coordinateBasis (n + 1))) + +/-- Stokes on a rectangular box, as a direct consequence of Mathlib's +Bochner divergence theorem. No smoothness of an arbitrary open-set boundary +is assumed in the later application. -/ +theorem integral_extDeriv_box {n : ℕ} + (form : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) [⋀^Fin n]→L[ℝ] ℝ) + (hform : Differentiable ℝ form) (a b : Fin (n + 1) → ℝ) (hab : a ≤ b) + (hint : IntegrableOn (fun x => extDeriv form x (coordinateBasis (n + 1))) (Icc a b)) : + (∫ x in Icc a b, extDeriv form x (coordinateBasis (n + 1))) = + ∑ i : Fin (n + 1), + ((∫ x in Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + formFlux form i (i.insertNth (b i) x)) - + ∫ x in Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + formFlux form i (i.insertNth (a i) x)) := by + have hd (i : Fin (n + 1)) (x : Fin (n + 1) → ℝ) : + DifferentiableAt ℝ (formFlux form i) x := by + exact ((hform x).continuousAlternatingMap_apply_const _).const_mul _ + have he (x : Fin (n + 1) → ℝ) : + (∑ i : Fin (n + 1), fderiv ℝ (formFlux form i) x (Pi.single i 1)) = + extDeriv form x (coordinateBasis (n + 1)) := by + rw [extDeriv_apply (hform x)] + apply Finset.sum_congr rfl + intro i _ + change (fderiv ℝ (fun y => (-1 : ℝ) ^ i.val * + form y (i.removeNth (coordinateBasis (n + 1)))) x) (Pi.single i 1) = _ + rw [fderiv_const_mul ((hform x).continuousAlternatingMap_apply_const _) ] + simp [coordinateBasis] + have h := integral_divergence_of_hasFDerivAt_off_countable' a b hab + (formFlux form) (fun i x => fderiv ℝ (formFlux form i) x) ∅ countable_empty + (fun i => (show Differentiable ℝ (formFlux form i) from hd i).continuous.continuousOn) + (fun x _ i => (hd i x).hasFDerivAt) (by simpa only [he] using hint) + simpa only [he] using h + +/-- Every top-degree differential form on Euclidean n-space is closed. -/ +theorem extDeriv_topForm_eq_zero {n : ℕ} + (φ : (Fin n → ℝ) → (Fin n → ℝ) [⋀^Fin n]→L[ℝ] ℝ) (x : Fin n → ℝ) : + extDeriv φ x = 0 := by + ext v + apply (extDeriv φ x).toAlternatingMap.map_linearDependent + intro hv + have h := hv.fintype_card_le_finrank + simp at h + +/-- The pullback of a top form by a C² map is closed (the Piola identity). -/ +theorem extDeriv_pullback_topForm_eq_zero {n : ℕ} {E : Type*} + [NormedAddCommGroup E] [NormedSpace ℝ E] + (φ : (Fin n → ℝ) → (Fin n → ℝ) [⋀^Fin n]→L[ℝ] ℝ) + (hφ : Differentiable ℝ φ) (F : E → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) (x : E) : + extDeriv (fun y => (φ (F y)).compContinuousLinearMap (fderiv ℝ F y)) x = 0 := by + rw [extDeriv_pullback (hφ _) hF.contDiffAt (by simp), extDeriv_topForm_eq_zero] + ext v + rfl + + +/-- A closed form has total signed flux zero across the faces of a box. -/ +theorem closedForm_boundary_box {n : ℕ} + (form : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) [⋀^Fin n]→L[ℝ] ℝ) + (hform : Differentiable ℝ form) (hclosed : ∀ x, extDeriv form x = 0) + (a b : Fin (n + 1) → ℝ) (hab : a ≤ b) : + (∑ i : Fin (n + 1), + ((∫ x in Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + formFlux form i (i.insertNth (b i) x)) - + ∫ x in Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + formFlux form i (i.insertNth (a i) x))) = 0 := by + have hz (x) : extDeriv form x (coordinateBasis (n + 1)) = 0 := by rw [hclosed]; rfl + have h := integral_extDeriv_box form hform a b hab (by simpa only [hz] using integrableOn_zero) + simpa only [hz, integral_zero] using h.symm + +/-- The coefficient integrals on two opposing faces of a box agree for a +closed form whose flux on all other faces is zero. This is the analytic +homotopy-invariance step with the sides outside the support of the form. -/ +theorem closedForm_opposite_faces {n : ℕ} + (form : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) [⋀^Fin n]→L[ℝ] ℝ) + (hform : Differentiable ℝ form) (hclosed : ∀ x, extDeriv form x = 0) + (a b : Fin (n + 1) → ℝ) (hab : a ≤ b) (k : Fin (n + 1)) + (hside : ∀ i, i ≠ k → ∀ x ∈ Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + formFlux form i (i.insertNth (b i) x) = 0 ∧ + formFlux form i (i.insertNth (a i) x) = 0) : + (∫ x in Icc (a ∘ k.succAbove) (b ∘ k.succAbove), + formFlux form k (k.insertNth (b k) x)) = + ∫ x in Icc (a ∘ k.succAbove) (b ∘ k.succAbove), + formFlux form k (k.insertNth (a k) x) := by + have h := closedForm_boundary_box form hform hclosed a b hab + rw [Finset.sum_eq_single k] at h + · exact sub_eq_zero.mp h + · intro i _ hi + have hb0 : (∫ x in Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + formFlux form i (i.insertNth (b i) x)) = 0 := by + apply setIntegral_eq_zero_of_forall_eq_zero + intro x hx + exact (hside i hi x hx).1 + have ha0 : (∫ x in Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + formFlux form i (i.insertNth (a i) x)) = 0 := by + apply setIntegral_eq_zero_of_forall_eq_zero + intro x hx + exact (hside i hi x hx).2 + rw [hb0, ha0, sub_self] + · simp + +/-- Determinant form with the standard coordinate orientation. -/ +def coordinateVolumeForm (n : ℕ) : (Fin n → ℝ) [⋀^Fin n]→L[ℝ] ℝ := + { Matrix.detRowAlternating with cont := continuous_id.matrix_det } + +/-- Smooth pullbacks of a top form are differentiable. -/ +theorem differentiable_pullback_topForm {n : ℕ} {E : Type*} + [NormedAddCommGroup E] [NormedSpace ℝ E] + (φ : (Fin n → ℝ) → (Fin n → ℝ) [⋀^Fin n]→L[ℝ] ℝ) + (hφ : Differentiable ℝ φ) (F : E → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) : + Differentiable ℝ (fun y => (φ (F y)).compContinuousLinearMap (fderiv ℝ F y)) := by + intro x + apply ((hφ (F x)).comp x (hF.differentiable (by norm_num) x) + ).continuousAlternatingMapCompContinuousLinearMap + exact (hF.fderiv_right (m := 1) (by norm_num)).differentiable (by norm_num) x + + +/-- Restricting a field to an open set whose boundary avoids its topological +support is locally either the original field or zero. -/ +theorem indicator_eventuallyEq_or_zero {X A : Type*} [TopologicalSpace X] [Zero A] + (U : Set X) (hU : IsOpen U) (f : X → A) + (hb : Disjoint (frontier U) (tsupport f)) (x : X) : + U.indicator f =ᶠ[nhds x] f ∨ U.indicator f =ᶠ[nhds x] fun _ => 0 := by + classical + by_cases hx : x ∈ U + · left + filter_upwards [hU.mem_nhds hx] with y hy + exact Set.indicator_of_mem hy f + · right + by_cases hc : x ∈ closure U + · have hf : x ∉ tsupport f := by + apply Set.disjoint_left.mp hb + exact ⟨hc, by simpa only [hU.interior_eq] using hx⟩ + have he := notMem_tsupport_iff_eventuallyEq.mp hf + filter_upwards [he] with y hy + by_cases hyU : y ∈ U <;> simp [Set.indicator, hyU, hy] + · filter_upwards [isClosed_closure.isOpen_compl.mem_nhds hc] with y hy + exact Set.indicator_of_notMem (fun hyU => hy (subset_closure hyU)) f + +/-- Excision at the differential-form level: cutting off at an arbitrary +isolating open-set boundary preserves differentiability and closedness. -/ +theorem localized_closedForm {n : ℕ} {E : Type*} + [NormedAddCommGroup E] [NormedSpace ℝ E] + (form : E → E [⋀^Fin n]→L[ℝ] ℝ) (hform : Differentiable ℝ form) + (hclosed : ∀ x, extDeriv form x = 0) (U : Set E) (hU : IsOpen U) + (hb : Disjoint (frontier U) (tsupport form)) : + Differentiable ℝ (U.indicator form) ∧ ∀ x, extDeriv (U.indicator form) x = 0 := by + constructor + · intro x + rcases indicator_eventuallyEq_or_zero U hU form hb x with hx | hx + · exact (hform x).congr_of_eventuallyEq hx + · exact differentiableAt_const (c := (0 : E [⋀^Fin n]→L[ℝ] ℝ)) |>.congr_of_eventuallyEq hx + · intro x + rcases indicator_eventuallyEq_or_zero U hU form hb x with hx | hx + · rw [hx.extDeriv_eq, hclosed] + · rw [hx.extDeriv_eq] + ext v + simp [extDeriv, ContinuousAlternatingMap.alternatizeUncurryFin_apply] + +/-- Homotopy-invariant integrals of a pulled-back target top form, with no +unproved mapping-degree primitive. -/ +theorem pullback_topForm_opposite_faces {n : ℕ} + (φ : (Fin n → ℝ) → (Fin n → ℝ) [⋀^Fin n]→L[ℝ] ℝ) + (hφ : Differentiable ℝ φ) (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) + (hF : ContDiff ℝ 2 F) (a b : Fin (n + 1) → ℝ) (hab : a ≤ b) + (k : Fin (n + 1)) + (hside : ∀ i, i ≠ k → ∀ x ∈ Icc (a ∘ i.succAbove) (b ∘ i.succAbove), + φ (F (i.insertNth (b i) x)) = 0 ∧ φ (F (i.insertNth (a i) x)) = 0) : + (∫ x in Icc (a ∘ k.succAbove) (b ∘ k.succAbove), + formFlux (fun y => (φ (F y)).compContinuousLinearMap (fderiv ℝ F y)) + k (k.insertNth (b k) x)) = + ∫ x in Icc (a ∘ k.succAbove) (b ∘ k.succAbove), + formFlux (fun y => (φ (F y)).compContinuousLinearMap (fderiv ℝ F y)) + k (k.insertNth (a k) x) := by + apply closedForm_opposite_faces _ (differentiable_pullback_topForm φ hφ F hF) + (extDeriv_pullback_topForm_eq_zero φ hφ F hF) a b hab k + intro i hi x hx + obtain ⟨hb, ha⟩ := hside i hi x hx + simp [formFlux, hb, ha] + + +/-- Evaluation of the standard volume form is the ordinary linear + determinant. -/ +theorem coordinateVolumeForm_linear {n : ℕ} + (L : (Fin n → ℝ) →L[ℝ] (Fin n → ℝ)) : + coordinateVolumeForm n (fun i => L (coordinateBasis n i)) = L.det := by + change Matrix.det (fun i => L (Pi.single i 1)) = _ + calc + _ = (LinearMap.toMatrix (Pi.basisFun ℝ (Fin n)) (Pi.basisFun ℝ (Fin n)) + L.toLinearMap).transpose.det := by + congr 1 + _ = _ := by rw [Matrix.det_transpose, LinearMap.det_toMatrix] + +/-- At a temporal face, the pullback coefficient is precisely the signed +Jacobian density of the corresponding slice. -/ +theorem formFlux_pullback_first_face {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) + (t : ℝ) (x : Fin n → ℝ) (hF : DifferentiableAt ℝ F (Fin.cons t x)) : + formFlux (fun y => ((ρ (F y)) • coordinateVolumeForm n).compContinuousLinearMap + (fderiv ℝ F y)) 0 (Fin.cons t x) = + (fderiv ℝ (fun z => F (Fin.cons t z)) x).det * ρ (F (Fin.cons t x)) := by + let J : (Fin n → ℝ) →L[ℝ] (Fin (n + 1) → ℝ) := + (0 : (Fin n → ℝ) →L[ℝ] ℝ).finCons (ContinuousLinearMap.id ℝ (Fin n → ℝ)) + have hJ : HasFDerivAt (fun z : Fin n → ℝ => Fin.cons t z) J x := + (hasFDerivAt_const t x).finCons (hasFDerivAt_id x) + have hs := hF.hasFDerivAt.comp x hJ + have he (i : Fin n) : J (coordinateBasis n i) = coordinateBasis (n + 1) i.succ := by + funext j + refine Fin.cases ?_ (fun k => ?_) j + · simp [J, coordinateBasis, ContinuousLinearMap.finCons] + · simp [J, coordinateBasis, ContinuousLinearMap.finCons, Pi.single_apply] + have hs' : fderiv ℝ (fun z => F (Fin.cons t z)) x = + (fderiv ℝ F (Fin.cons t x)).comp J := hs.fderiv + rw [hs'] + have hd := coordinateVolumeForm_linear ((fderiv ℝ F (Fin.cons t x)).comp J) + simp only [ContinuousLinearMap.comp_apply, he] at hd + simp only [formFlux, Fin.val_zero, pow_zero, one_mul, Fin.removeNth_zero, + ContinuousAlternatingMap.compContinuousLinearMap_apply, + ContinuousAlternatingMap.smul_apply, smul_eq_mul] + rw [mul_comm] + congr 1 + +/-- Smooth homotopy invariance of the Jacobian integral against a target +bump whose pullback vanishes on the spatial sides of a containing box. -/ +theorem jacobian_integral_homotopy_box {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (hρ : Differentiable ℝ ρ) + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (t₀ t₁ : ℝ) (ht : t₀ ≤ t₁) (a b : Fin n → ℝ) (hab : a ≤ b) + (hside : ∀ i : Fin (n + 1), i ≠ 0 → + ∀ x ∈ Icc ((Fin.cons t₀ a : Fin (n + 1) → ℝ) ∘ i.succAbove) + ((Fin.cons t₁ b : Fin (n + 1) → ℝ) ∘ i.succAbove), + ρ (F (i.insertNth ((Fin.cons t₁ b : Fin (n + 1) → ℝ) i) x)) = 0 ∧ + ρ (F (i.insertNth ((Fin.cons t₀ a : Fin (n + 1) → ℝ) i) x)) = 0) : + (∫ x in Icc a b, (fderiv ℝ (fun z => F (Fin.cons t₁ z)) x).det * + ρ (F (Fin.cons t₁ x))) = + ∫ x in Icc a b, (fderiv ℝ (fun z => F (Fin.cons t₀ z)) x).det * + ρ (F (Fin.cons t₀ x)) := by + have hφ : Differentiable ℝ (fun y => ρ y • coordinateVolumeForm n) := + hρ.smul_const _ + have hbox : (Fin.cons t₀ a : Fin (n + 1) → ℝ) ≤ Fin.cons t₁ b := by + intro i + exact Fin.cases ht (fun j => hab j) i + have h := pullback_topForm_opposite_faces (fun y => ρ y • coordinateVolumeForm n) + hφ F hF (Fin.cons t₀ a) (Fin.cons t₁ b) hbox 0 (by + intro i hi x hx + obtain ⟨h₁, h₀⟩ := hside i hi x hx + simp only [h₁, h₀, zero_smul, and_self]) + have hins (t : ℝ) (x : Fin n → ℝ) : + (0 : Fin (n + 1)).insertNth t x = (Fin.cons t x : Fin (n + 1) → ℝ) := by + simp only [Fin.insertNth_zero, cast_eq] + simpa only [Fin.succAbove_zero, Function.comp_def, Fin.cons_succ, Fin.cons_zero, + hins, formFlux_pullback_first_face ρ F _ _ (hF.differentiable (by norm_num) _)] using h + + +/-- The support of a pulled-back density lies above the support of the target +bump. This provides the needed collar at an arbitrary isolating boundary. -/ +theorem tsupport_pullback_density_subset {n : ℕ} {E : Type*} + [NormedAddCommGroup E] [NormedSpace ℝ E] + (ρ : (Fin n → ℝ) → ℝ) (F : E → (Fin n → ℝ)) (hF : Continuous F) : + tsupport (fun y => ((ρ (F y)) • coordinateVolumeForm n).compContinuousLinearMap + (fderiv ℝ F y)) ⊆ F ⁻¹' tsupport ρ := by + apply closure_minimal _ ((isClosed_tsupport ρ).preimage hF) + intro x hx + by_contra hn + have hz := image_eq_zero_of_notMem_tsupport hn + exact hx (by ext v; simp [hz]) + +/-- Localized homotopy invariance on an arbitrary open spatial set. The +boundary collar is expressed by avoidance of the target bump, not by a smooth +boundary assumption. The spatial box is only an integration device. -/ +theorem jacobian_integral_homotopy_localized_box {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (hρ : Differentiable ℝ ρ) + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (U : Set (Fin n → ℝ)) (hU : IsOpen U) + (hboundary : ∀ y : Fin (n + 1) → ℝ, + (fun i => y i.succ) ∈ frontier U → F y ∉ tsupport ρ) + (t₀ t₁ : ℝ) (ht : t₀ ≤ t₁) (a b : Fin n → ℝ) (hab : a ≤ b) + (hbox : U ⊆ Icc a b) + (hside : ∀ i : Fin (n + 1), i ≠ 0 → + ∀ x ∈ Icc ((Fin.cons t₀ a : Fin (n + 1) → ℝ) ∘ i.succAbove) + ((Fin.cons t₁ b : Fin (n + 1) → ℝ) ∘ i.succAbove), + (fun j : Fin n => (i.insertNth ((Fin.cons t₁ b : Fin (n + 1) → ℝ) i) x : + Fin (n + 1) → ℝ) j.succ) ∉ U ∧ + (fun j : Fin n => (i.insertNth ((Fin.cons t₀ a : Fin (n + 1) → ℝ) i) x : + Fin (n + 1) → ℝ) j.succ) ∉ U) : + (∫ x in U, (fderiv ℝ (fun z => F (Fin.cons t₁ z)) x).det * + ρ (F (Fin.cons t₁ x))) = + ∫ x in U, (fderiv ℝ (fun z => F (Fin.cons t₀ z)) x).det * + ρ (F (Fin.cons t₀ x)) := by + classical + let π : (Fin (n + 1) → ℝ) → (Fin n → ℝ) := fun y i => y i.succ + have hπ : Continuous π := continuous_pi (fun i => continuous_apply i.succ) + let C := π ⁻¹' U + let form := fun y => ((ρ (F y)) • coordinateVolumeForm n).compContinuousLinearMap + (fderiv ℝ F y) + have hc : Disjoint (frontier C) (tsupport form) := by + apply disjoint_left.mpr + intro y hy hs + exact hboundary y ((hπ.frontier_preimage_subset U) hy) + (tsupport_pullback_density_subset ρ F hF.continuous hs) + obtain ⟨hd, hz⟩ := localized_closedForm form + (differentiable_pullback_topForm _ (hρ.smul_const _) F hF) + (extDeriv_pullback_topForm_eq_zero _ (hρ.smul_const _) F hF) C + (hU.preimage hπ) hc + have htbox : (Fin.cons t₀ a : Fin (n + 1) → ℝ) ≤ Fin.cons t₁ b := by + intro i + exact Fin.cases ht (fun j => hab j) i + have he := closedForm_opposite_faces (C.indicator form) hd hz + (Fin.cons t₀ a) (Fin.cons t₁ b) htbox 0 (by + intro i hi x hx + obtain ⟨h₁, h₀⟩ := hside i hi x hx + have hc₁ : i.insertNth ((Fin.cons t₁ b : Fin (n + 1) → ℝ) i) x ∉ C := h₁ + have hc₀ : i.insertNth ((Fin.cons t₀ a : Fin (n + 1) → ℝ) i) x ∉ C := h₀ + simp [formFlux, indicator_of_notMem hc₁, indicator_of_notMem hc₀]) + have hface (t : ℝ) (x : Fin n → ℝ) : + formFlux (C.indicator form) 0 (Fin.cons t x) = + U.indicator (fun z => (fderiv ℝ (fun w => F (Fin.cons t w)) z).det * + ρ (F (Fin.cons t z))) x := by + by_cases hx : x ∈ U + · have hc : Fin.cons t x ∈ C := by simpa only [C, mem_preimage, π, Fin.cons_succ] using hx + rw [indicator_of_mem hx] + change (-1 : ℝ) ^ (0 : Fin (n + 1)).val * + (C.indicator form) (Fin.cons t x) _ = _ + rw [indicator_of_mem hc] + exact formFlux_pullback_first_face ρ F t x (hF.differentiable (by norm_num) _) + · have hc : Fin.cons t x ∉ C := by simpa only [C, mem_preimage, π, Fin.cons_succ] using hx + simp [formFlux, hc, hx] + have hins (t : ℝ) (x : Fin n → ℝ) : + (0 : Fin (n + 1)).insertNth t x = (Fin.cons t x : Fin (n + 1) → ℝ) := by + simp only [Fin.insertNth_zero, cast_eq] + simpa only [Fin.succAbove_zero, Function.comp_def, Fin.cons_succ, Fin.cons_zero, + hins, hface, setIntegral_indicator hU.measurableSet, + inter_eq_right.mpr hbox] using he + + +/-- Homotopy invariance on a bounded open set, without selecting a box or +requiring any shape or smoothness of its boundary. -/ +theorem jacobian_integral_homotopy_localized {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (hρ : Differentiable ℝ ρ) + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (U : Set (Fin n → ℝ)) (hU : IsOpen U) (hUb : Bornology.IsBounded U) + (hboundary : ∀ y : Fin (n + 1) → ℝ, + (fun i => y i.succ) ∈ frontier U → F y ∉ tsupport ρ) + (t₀ t₁ : ℝ) (ht : t₀ ≤ t₁) : + (∫ x in U, (fderiv ℝ (fun z => F (Fin.cons t₁ z)) x).det * + ρ (F (Fin.cons t₁ x))) = + ∫ x in U, (fderiv ℝ (fun z => F (Fin.cons t₀ z)) x).det * + ρ (F (Fin.cons t₀ x)) := by + obtain ⟨R, hR, hbound⟩ := hUb.exists_pos_norm_lt + have hcoord (x) (hx : x ∈ U) (i : Fin n) : |x i| < R := + lt_of_le_of_lt (norm_le_pi_norm x i) (hbound x hx) + have hout (x : Fin n → ℝ) (i : Fin n) (hx : x i = R ∨ x i = -R) : x ∉ U := by + intro hxu + have h := hcoord x hxu i + rcases hx with hx | hx <;> rw [hx] at h + · simp only [abs_of_pos hR, lt_self_iff_false] at h + · simp only [abs_neg, abs_of_pos hR, lt_self_iff_false] at h + apply jacobian_integral_homotopy_localized_box ρ hρ F hF U hU hboundary + t₀ t₁ ht (fun _ => -R) (fun _ => R) (fun _ => by linarith) + · intro x hx + constructor <;> intro i + · exact (abs_lt.mp (hcoord x hx i)).1.le + · exact (abs_lt.mp (hcoord x hx i)).2.le + · intro i hi x _ + obtain ⟨j, rfl⟩ := Fin.eq_succ_of_ne_zero hi + constructor + · apply hout _ j + left + simp only [Fin.insertNth_apply_same, Fin.cons_succ] + · apply hout _ j + right + simp only [Fin.insertNth_apply_same, Fin.cons_succ] + + +/-- Only boundary avoidance during the given interval is needed. Smooth +saturation of the time coordinate turns it into the global collar hypothesis +of the preceding Stokes argument, with the endpoints unchanged. -/ +theorem jacobian_integral_homotopy_localized_interval {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (hρ : Differentiable ℝ ρ) + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (U : Set (Fin n → ℝ)) (hU : IsOpen U) (hUb : Bornology.IsBounded U) + (hboundary : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, + F (Fin.cons t x) ∉ tsupport ρ) : + (∫ x in U, (fderiv ℝ (fun z => F (Fin.cons 1 z)) x).det * + ρ (F (Fin.cons 1 x))) = + ∫ x in U, (fderiv ℝ (fun z => F (Fin.cons 0 z)) x).det * + ρ (F (Fin.cons 0 x)) := by + let H : (Fin (n + 1) → ℝ) → (Fin n → ℝ) := fun y => + F (Fin.cons (Real.smoothTransition (y 0)) (Fin.tail y)) + have hH : ContDiff ℝ 2 H := by + apply hF.comp + apply contDiff_pi.mpr + intro i + refine Fin.cases ?_ (fun j => ?_) i + · exact Real.smoothTransition.contDiff.comp (contDiff_apply ℝ ℝ 0) + · exact contDiff_apply ℝ ℝ j.succ + have hb : ∀ y : Fin (n + 1) → ℝ, + (fun i => y i.succ) ∈ frontier U → H y ∉ tsupport ρ := by + intro y hy + exact hboundary _ ⟨Real.smoothTransition.nonneg _, Real.smoothTransition.le_one _⟩ _ hy + have h := jacobian_integral_homotopy_localized ρ hρ H hH U hU hUb hb 0 1 zero_le_one + simpa only [H, Fin.cons_zero, Fin.tail_cons, Real.smoothTransition.zero, + Real.smoothTransition.one] using h + +end EilenbergGanea + +namespace EilenbergGanea +open Set MeasureTheory + +/-- A nonzero signed regular count cannot disappear under a smooth homotopy +whose boundary avoids the target. All analytic degree ingredients are proved +above; in particular this is not an assumed Brouwer-degree interface. -/ +theorem regular_count_persists {n : ℕ} + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (y : Fin n → ℝ) (U : Set (Fin n → ℝ)) (hU : IsOpen U) + (hc : IsCompact (closure U)) + (hb : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, F (Fin.cons t x) ≠ y) + (s : Finset (Fin n → ℝ)) + (hs : ∀ x, x ∈ s ↔ x ∈ U ∧ F (Fin.cons 0 x) = y) + (hd : ∀ x ∈ s, (fderiv ℝ (fun z => F (Fin.cons 0 z)) x).det ≠ 0) + (hcount : (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => F (Fin.cons 0 z)) x).det + then 1 else -1 : ℝ)) ≠ 0) : + ∃ x ∈ U, F (Fin.cons 1 x) = y := by + classical + by_contra hno + have hno' : ∀ x ∈ U, F (Fin.cons 1 x) ≠ y := by simpa only [not_exists, not_and] using hno + let f₀ : (Fin n → ℝ) → (Fin n → ℝ) := fun x => F (Fin.cons 0 x) + let f₁ : (Fin n → ℝ) → (Fin n → ℝ) := fun x => F (Fin.cons 1 x) + have hcons (t : ℝ) : ContDiff ℝ 2 (fun x : Fin n → ℝ => + (Fin.cons t x : Fin (n + 1) → ℝ)) := by + apply contDiff_pi.mpr + intro i + refine Fin.cases contDiff_const (fun j => ?_) i + exact contDiff_apply ℝ ℝ j + have hf₀ : ContDiff ℝ 1 f₀ := (hF.comp (hcons 0)).of_le (by norm_num) + have hf₁ : Continuous f₁ := (hF.comp (hcons 1)).continuous + obtain ⟨N, hN, hyN, hsign⟩ := regular_signed_count_neighborhood volume f₀ hf₀ + y U hU hc (hb 0 (by simp)) s hs hd + let K : Set (Fin n → ℝ) := + (fun p : ℝ × (Fin n → ℝ) => F (Fin.cons p.1 p.2)) '' (Icc (0 : ℝ) 1 ×ˢ frontier U) + have hfront : IsCompact (frontier U) := hc.of_isClosed_subset isClosed_frontier frontier_subset_closure + have hK : IsCompact K := (isCompact_Icc.prod hfront).image + (hF.continuous.comp (by + apply continuous_pi + intro i + exact Fin.cases continuous_fst + (fun j => (continuous_apply j).comp continuous_snd) i)) + have hyK : y ∉ K := by + rintro ⟨⟨t, x⟩, ⟨ht, hx⟩, he⟩ + exact hb t ht x hx he + have hy₁ : y ∉ f₁ '' closure U := by + rintro ⟨x, hx, he⟩ + by_cases hxU : x ∈ U + · exact hno' x hxU he + · exact hb 1 (by simp) x ⟨hx, by simpa only [hU.interior_eq] using hxU⟩ he + let M := N \ (K ∪ f₁ '' closure U) + have hM : IsOpen M := hN.sdiff (hK.isClosed.union (hc.image hf₁).isClosed) + have hyM : y ∈ M := ⟨hyN, fun h => h.elim hyK hy₁⟩ + obtain ⟨ρ, hρ, _, hρM, hunit⟩ := exists_normalized_smooth_bump volume y M hM hyM + have hρN : Function.support ρ ⊆ N := fun z hz => (hρM (subset_tsupport ρ hz)).1 + have hval : jacobianIntegral volume f₀ U ρ = + ∑ x ∈ s, (if 0 < (fderiv ℝ f₀ x).det then 1 else -1) := + hsign ρ hρ.continuous hρN hunit + have hcollar : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, + F (Fin.cons t x) ∉ tsupport ρ := by + intro t ht x hx hsup + exact (hρM hsup).2 (Or.inl ⟨(t, x), ⟨ht, hx⟩, rfl⟩) + have hinv := jacobian_integral_homotopy_localized_interval ρ + (hρ.differentiable (by simp)) F hF U hU + (hc.isBounded.subset subset_closure) hcollar + have hzero : jacobianIntegral volume f₁ U ρ = 0 := by + apply jacobianIntegral_eq_zero_of_no_preimage + intro x hx + apply image_eq_zero_of_notMem_tsupport + intro hsup + exact (hρM hsup).2 (Or.inr ⟨x, subset_closure hx, rfl⟩) + apply hcount + exact hval.symm.trans (hinv.symm.trans hzero) + +end EilenbergGanea + +namespace EilenbergGanea +open Set +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] + +/-- The analytic nonzero-count theorem is independent of a choice of linear +coordinates. This form applies directly to finite products of quaternions. -/ +theorem regular_count_persists_finiteDimensional + (F : ℝ × E → E) (hF : ContDiff ℝ 2 F) + (y : E) (U : Set E) (hU : IsOpen U) (hc : IsCompact (closure U)) + (hb : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, F (t, x) ≠ y) + (s : Finset E) (hs : ∀ x, x ∈ s ↔ x ∈ U ∧ F (0, x) = y) + (hd : ∀ x ∈ s, (fderiv ℝ (fun z => F (0, z)) x).det ≠ 0) + (hcount : (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => F (0, z)) x).det + then 1 else -1 : ℝ)) ≠ 0) : ∃ x ∈ U, F (1, x) = y := by + classical + let n := Module.finrank ℝ E + let e : E ≃L[ℝ] (Fin n → ℝ) := (Module.finBasis ℝ E).equivFunL + let G : (Fin (n + 1) → ℝ) → (Fin n → ℝ) := + fun z => e (F (z 0, e.symm (Fin.tail z))) + have hG : ContDiff ℝ 2 G := by + apply e.contDiff.comp + apply hF.comp + exact (contDiff_apply ℝ ℝ 0).prodMk (e.symm.contDiff.comp + (contDiff_pi.mpr (fun i => contDiff_apply ℝ ℝ i.succ))) + have hdet (x : E) : + (fderiv ℝ (fun z => G (Fin.cons 0 z)) (e x)).det = + (fderiv ℝ (fun z => F (0, z)) x).det := by + have h₀ : DifferentiableAt ℝ (fun z => F (0, z)) x := + (hF.comp (contDiff_const.prodMk contDiff_id)).differentiable (by norm_num) x + have h₀' : HasFDerivAt (fun z => F (0, z)) + (fderiv ℝ (fun z => F (0, z)) x) (e.symm (e x)) := by + simpa only [ContinuousLinearEquiv.symm_apply_apply] using h₀.hasFDerivAt + have hcomp := e.hasFDerivAt.comp (e x) + (h₀'.comp (e x) e.symm.hasFDerivAt) + have hh : (fun z => G (Fin.cons 0 z)) = e ∘ (fun z => F (0, z)) ∘ e.symm := by + funext z + simp [G, Function.comp_def] + rw [hh, hcomp.fderiv] + exact LinearMap.det_conj _ e.toLinearEquiv + have hVc : IsCompact (closure (e '' U)) := by + rw [← show (e : E → (Fin n → ℝ)) '' closure U = closure (e '' U) from e.toHomeomorph.image_closure U] + exact hc.image e.continuous + have hb' : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier (e '' U), + G (Fin.cons t x) ≠ e y := by + intro t ht x hx he + rw [← show (e : E → (Fin n → ℝ)) '' frontier U = frontier (e '' U) from e.toHomeomorph.image_frontier U] at hx + obtain ⟨z, hz, rfl⟩ := hx + apply hb t ht z hz + apply e.injective + simpa [G] using he + let s' := s.map e.toEquiv.toEmbedding + have hs' : ∀ x, x ∈ s' ↔ x ∈ e '' U ∧ G (Fin.cons 0 x) = e y := by + intro x + constructor + · intro hx + obtain ⟨z, hz, rfl⟩ := Finset.mem_map.mp hx + refine ⟨⟨z, (hs z).mp hz |>.1, rfl⟩, ?_⟩ + simp [G, (hs z).mp hz |>.2] + · rintro ⟨⟨z, hz, rfl⟩, he⟩ + apply Finset.mem_map.mpr + refine ⟨z, (hs z).mpr ⟨hz, ?_⟩, rfl⟩ + exact e.injective (by simpa [G] using he) + have hd' : ∀ x ∈ s', (fderiv ℝ (fun z => G (Fin.cons 0 z)) x).det ≠ 0 := by + intro x hx + obtain ⟨z, hz, rfl⟩ := Finset.mem_map.mp hx + change (fderiv ℝ (fun z => G (Fin.cons 0 z)) (e z)).det ≠ 0 + rw [hdet] + exact hd z hz + have hcount' : (∑ x ∈ s', (if 0 < (fderiv ℝ (fun z => G (Fin.cons 0 z)) x).det + then 1 else -1 : ℝ)) ≠ 0 := by + change (∑ x ∈ s.map e.toEquiv.toEmbedding, _) ≠ 0 + rw [Finset.sum_map] + change (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => G (Fin.cons 0 z)) (e x)).det then 1 else -1 : ℝ)) ≠ 0 + simpa only [hdet] using hcount + obtain ⟨x, hx, he⟩ := regular_count_persists G hG (e y) (e '' U) + (e.toHomeomorph.isOpenMap _ hU) hVc hb' s' hs' hd' hcount' + obtain ⟨z, hz, rfl⟩ := hx + exact ⟨z, hz, e.injective (by simpa [G] using he)⟩ + +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff + +/-- A regular perturbation at time zero can be propagated along an arbitrary +boundary-root-free smooth homotopy. The perturbation need not be equivariant +away from the initial time. -/ +theorem regular_approximation_persists + {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] + (F : ℝ × E → E) (hF : ContDiff ℝ 2 F) + (U : Set E) (hU : IsOpen U) (hc : IsCompact (closure U)) + (hb : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, F (t, x) ≠ 0) + (happrox : ∀ ε : ℝ, 0 < ε → ∃ g : E → E, ContDiff ℝ ∞ g ∧ + (∀ x ∈ closure U, ‖g x - F (0, x)‖ < ε) ∧ + ∃ s : Finset E, (∀ x, x ∈ s ↔ x ∈ closure U ∧ g x = 0) ∧ + (∀ x ∈ s, (fderiv ℝ g x).det ≠ 0) ∧ + (∑ x ∈ s, (if 0 < (fderiv ℝ g x).det then 1 else -1 : ℝ)) ≠ 0) : + ∃ x ∈ U, F (1, x) = 0 := by + classical + let P := Icc (0 : ℝ) 1 ×ˢ frontier U + have hP : IsCompact P := isCompact_Icc.prod + (hc.of_isClosed_subset isClosed_frontier frontier_subset_closure) + have hz : (0 : E) ∈ (F '' P)ᶜ := by + rintro ⟨⟨t, x⟩, ⟨ht, hx⟩, he⟩ + exact hb t ht x hx he + obtain ⟨ε, hε, hball⟩ := Metric.isOpen_iff.mp (hP.image hF.continuous).isClosed.isOpen_compl 0 hz + have hbound : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, ε ≤ ‖F (t, x)‖ := by + intro t ht x hx + by_contra hn + have hmem : F (t, x) ∈ Metric.ball (0 : E) ε := by + simpa only [Metric.mem_ball, dist_zero_right] using lt_of_not_ge hn + exact hball hmem ⟨(t, x), ⟨ht, hx⟩, rfl⟩ + obtain ⟨g, hg, hclose, s, hs, hd, hcount⟩ := happrox ε hε + let G : ℝ × E → E := fun q => F q + (1 - q.1) • (g q.2 - F (0, q.2)) + have hG : ContDiff ℝ 2 G := hF.add + ((contDiff_const.sub contDiff_fst).smul (((contDiff_infty.mp hg 2).comp contDiff_snd).sub + (hF.comp (contDiff_const.prodMk contDiff_snd)))) + have hG0 : (fun x => G (0, x)) = g := by funext x; simp [G] + have hG1 : (fun x => G (1, x)) = fun x => F (1, x) := by funext x; simp [G] + have hGb : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, G (t, x) ≠ 0 := by + intro t ht x hx he + have heq : F (t, x) = -((1 - t) • (g x - F (0, x))) := eq_neg_of_add_eq_zero_left he + have hn : ‖F (t, x)‖ < ε := by + rw [heq, norm_neg, norm_smul, Real.norm_eq_abs, abs_of_nonneg (by linarith [ht.2])] + calc + (1 - t) * ‖g x - F (0, x)‖ ≤ ‖g x - F (0, x)‖ := + mul_le_of_le_one_left (norm_nonneg _) (by linarith [ht.1]) + _ < ε := hclose x (frontier_subset_closure hx) + exact (not_lt_of_ge (hbound t ht x hx)) hn + have hsU : ∀ x, x ∈ s ↔ x ∈ U ∧ G (0, x) = 0 := by + intro x + rw [hs, show G (0, x) = g x from congrFun hG0 x] + constructor + · rintro ⟨hx, he⟩ + refine ⟨?_, he⟩ + by_contra hn + have hxf : x ∈ frontier U := ⟨hx, by simpa only [hU.interior_eq] using hn⟩ + exact hGb 0 (by simp) x hxf (by rw [show G (0, x) = g x from congrFun hG0 x]; exact he) + · rintro ⟨hx, he⟩; exact ⟨subset_closure hx, he⟩ + have hd' : ∀ x ∈ s, (fderiv ℝ (fun z => G (0, z)) x).det ≠ 0 := by rw [hG0]; exact hd + have hcount' : (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => G (0, z)) x).det then 1 else -1 : ℝ)) ≠ 0 := by + rw [hG0]; exact hcount + obtain ⟨x, hx, he⟩ := regular_count_persists_finiteDimensional G hG 0 U hU hc hGb s hsU hd' hcount' + exact ⟨x, hx, by simpa only [show G (1, x) = F (1, x) from congrFun hG1 x] using he⟩ + +/-- Localized nonsingular-exponent word-map roots cannot disappear under a +boundary-root-free smooth homotopy, even though the initial word map can have +singular roots. -/ +theorem localized_word_root_persists {m : ℕ} + (w : Fin m → FreeGroup (Fin m)) (hB : (exponentMatrix w).det ≠ 0) + (F : ℝ × ((Fin m → ℂ) × (Fin m → ℂ)) → ((Fin m → ℂ) × (Fin m → ℂ))) + (hF : ContDiff ℝ 2 F) (hF0 : ∀ q, F (0, q) = splitWordMap w q) + (U : Set ((Fin m → ℂ) × (Fin m → ℂ))) (hU : IsOpen U) + (hc : IsCompact (closure U)) + (hUi : ∀ z : ℂ, ‖z‖ = 1 → ∀ q ∈ closure U, (q.1, z • q.2) ∈ closure U) + (h1 : (1, 0) ∈ U) + (hb : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x ∈ frontier U, F (t, x) ≠ 0) : + ∃ x ∈ U, F (1, x) = 0 := by + apply regular_approximation_persists F hF U hU hc hb + intro ε hε + simpa only [hF0] using word_exists_regularization_nonzero_count w hB + (closure U) hc hUi (subset_closure h1) (closure U) hc (Subset.refl _) ε hε + +end EilenbergGanea + +namespace EilenbergGanea +open Set MeasureTheory + +/-- Stokes localization in an arbitrary open subset of time times space. +The two slices may be different; no regularity of the moving boundary is used. -/ +theorem jacobian_integral_moving_box {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (hρ : Differentiable ℝ ρ) + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (C : Set (Fin (n + 1) → ℝ)) (hC : IsOpen C) + (hboundary : ∀ y ∈ frontier C, F y ∉ tsupport ρ) + (t₀ t₁ : ℝ) (ht : t₀ ≤ t₁) (a b : Fin n → ℝ) (hab : a ≤ b) + (hbox : ∀ t, {x | (Fin.cons t x : Fin (n + 1) → ℝ) ∈ C} ⊆ Icc a b) + (hside : ∀ i : Fin (n + 1), i ≠ 0 → + ∀ x ∈ Icc ((Fin.cons t₀ a : Fin (n + 1) → ℝ) ∘ i.succAbove) + ((Fin.cons t₁ b : Fin (n + 1) → ℝ) ∘ i.succAbove), + i.insertNth ((Fin.cons t₁ b : Fin (n + 1) → ℝ) i) x ∉ C ∧ + i.insertNth ((Fin.cons t₀ a : Fin (n + 1) → ℝ) i) x ∉ C) : + (∫ x in {x | (Fin.cons t₁ x : Fin (n + 1) → ℝ) ∈ C}, + (fderiv ℝ (fun z => F (Fin.cons t₁ z)) x).det * ρ (F (Fin.cons t₁ x))) = + ∫ x in {x | (Fin.cons t₀ x : Fin (n + 1) → ℝ) ∈ C}, + (fderiv ℝ (fun z => F (Fin.cons t₀ z)) x).det * ρ (F (Fin.cons t₀ x)) := by + classical + let form := fun y => ((ρ (F y)) • coordinateVolumeForm n).compContinuousLinearMap + (fderiv ℝ F y) + have hc : Disjoint (frontier C) (tsupport form) := by + apply disjoint_left.mpr + intro y hy hs + exact hboundary y hy (tsupport_pullback_density_subset ρ F hF.continuous hs) + obtain ⟨hd, hz⟩ := localized_closedForm form + (differentiable_pullback_topForm _ (hρ.smul_const _) F hF) + (extDeriv_pullback_topForm_eq_zero _ (hρ.smul_const _) F hF) C hC hc + have htbox : (Fin.cons t₀ a : Fin (n + 1) → ℝ) ≤ Fin.cons t₁ b := by + intro i + exact Fin.cases ht (fun j => hab j) i + have he := closedForm_opposite_faces (C.indicator form) hd hz + (Fin.cons t₀ a) (Fin.cons t₁ b) htbox 0 (by + intro i hi x hx + obtain ⟨h₁, h₀⟩ := hside i hi x hx + simp [formFlux, indicator_of_notMem h₁, indicator_of_notMem h₀]) + have hface (t : ℝ) (x : Fin n → ℝ) : + formFlux (C.indicator form) 0 (Fin.cons t x) = + {x | (Fin.cons t x : Fin (n + 1) → ℝ) ∈ C}.indicator + (fun z => (fderiv ℝ (fun w => F (Fin.cons t w)) z).det * + ρ (F (Fin.cons t z))) x := by + by_cases hx : (Fin.cons t x : Fin (n + 1) → ℝ) ∈ C + · rw [indicator_of_mem (show x ∈ {x | (Fin.cons t x : Fin (n + 1) → ℝ) ∈ C} from hx)] + change (-1 : ℝ) ^ (0 : Fin (n + 1)).val * + (C.indicator form) (Fin.cons t x) _ = _ + rw [indicator_of_mem hx] + exact formFlux_pullback_first_face ρ F t x (hF.differentiable (by norm_num) _) + · simp [formFlux, hx] + have hins (t : ℝ) (x : Fin n → ℝ) : + (0 : Fin (n + 1)).insertNth t x = (Fin.cons t x : Fin (n + 1) → ℝ) := by + simp only [Fin.insertNth_zero, cast_eq] + have hm (t : ℝ) : MeasurableSet {x | (Fin.cons t x : Fin (n + 1) → ℝ) ∈ C} := by + apply (hC.preimage _).measurableSet + apply continuous_pi + intro i + exact Fin.cases continuous_const (fun j => continuous_apply j) i + simpa only [Fin.succAbove_zero, Function.comp_def, Fin.cons_succ, Fin.cons_zero, + hins, hface, setIntegral_indicator (hm _), + inter_eq_right.mpr (hbox _)] using he + +end EilenbergGanea + +namespace EilenbergGanea +open Set MeasureTheory Filter Topology + +/-- Box-free moving-domain Stokes, with arbitrary open moving slices contained +in one bounded spatial set. -/ +theorem jacobian_integral_moving {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (hρ : Differentiable ℝ ρ) + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (C : Set (Fin (n + 1) → ℝ)) (hC : IsOpen C) + (hboundary : ∀ y ∈ frontier C, F y ∉ tsupport ρ) + (hCb : Bornology.IsBounded {x : Fin n → ℝ | ∃ t : ℝ, Fin.cons t x ∈ C}) + (t₀ t₁ : ℝ) (ht : t₀ ≤ t₁) : + (∫ x in {x | (Fin.cons t₁ x : Fin (n + 1) → ℝ) ∈ C}, + (fderiv ℝ (fun z => F (Fin.cons t₁ z)) x).det * ρ (F (Fin.cons t₁ x))) = + ∫ x in {x | (Fin.cons t₀ x : Fin (n + 1) → ℝ) ∈ C}, + (fderiv ℝ (fun z => F (Fin.cons t₀ z)) x).det * ρ (F (Fin.cons t₀ x)) := by + obtain ⟨R, hR, hbound⟩ := hCb.exists_pos_norm_lt + have hcoord (t : ℝ) (x : Fin n → ℝ) (hx : Fin.cons t x ∈ C) (i : Fin n) : |x i| < R := + lt_of_le_of_lt (by simpa only [Real.norm_eq_abs] using norm_le_pi_norm x i) + (hbound x ⟨t, hx⟩) + have hout (y : Fin (n + 1) → ℝ) (j : Fin n) + (hj : y j.succ = R ∨ y j.succ = -R) : y ∉ C := by + intro hy + have hh := hcoord (y 0) (Fin.tail y) (by simpa only [Fin.cons_self_tail] using hy) j + change |y j.succ| < R at hh + rcases hj with hj | hj + · rw [hj, abs_of_pos hR] at hh; exact lt_irrefl _ hh + · rw [hj, abs_neg, abs_of_pos hR] at hh; exact lt_irrefl _ hh + apply jacobian_integral_moving_box ρ hρ F hF C hC hboundary t₀ t₁ ht + (fun _ => -R) (fun _ => R) (fun _ => by linarith) + · intro t x hx + constructor <;> intro i + · exact (abs_lt.mp (hcoord t x hx i)).1.le + · exact (abs_lt.mp (hcoord t x hx i)).2.le + · intro i hi x _ + obtain ⟨j, rfl⟩ := Fin.eq_succ_of_ne_zero hi + constructor + · apply hout _ j + left + simp only [Fin.insertNth_apply_same, Fin.cons_succ] + · apply hout _ j + right + simp only [Fin.insertNth_apply_same, Fin.cons_succ] + +/-- Smooth time saturation reduces the collar hypothesis to the actual time +interval even for moving open domains. -/ +theorem jacobian_integral_moving_interval {n : ℕ} + (ρ : (Fin n → ℝ) → ℝ) (hρ : Differentiable ℝ ρ) + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (C : Set (Fin (n + 1) → ℝ)) (hC : IsOpen C) + (hboundary : ∀ y ∈ frontier C, y 0 ∈ Icc (0 : ℝ) 1 → F y ∉ tsupport ρ) + (hCb : Bornology.IsBounded {x : Fin n → ℝ | ∃ t ∈ Icc (0 : ℝ) 1, Fin.cons t x ∈ C}) : + (∫ x in {x | (Fin.cons 1 x : Fin (n + 1) → ℝ) ∈ C}, + (fderiv ℝ (fun z => F (Fin.cons 1 z)) x).det * ρ (F (Fin.cons 1 x))) = + ∫ x in {x | (Fin.cons 0 x : Fin (n + 1) → ℝ) ∈ C}, + (fderiv ℝ (fun z => F (Fin.cons 0 z)) x).det * ρ (F (Fin.cons 0 x)) := by + let T : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) := + fun y => Fin.cons (Real.smoothTransition (y 0)) (Fin.tail y) + have hT : ContDiff ℝ 2 T := by + apply contDiff_pi.mpr + intro i + refine Fin.cases ?_ (fun j => ?_) i + · exact Real.smoothTransition.contDiff.comp (contDiff_apply ℝ ℝ 0) + · exact contDiff_apply ℝ ℝ j.succ + have hb : ∀ y ∈ frontier (T ⁻¹' C), (F ∘ T) y ∉ tsupport ρ := by + intro y hy + exact hboundary (T y) (hT.continuous.frontier_preimage_subset C hy) + ⟨Real.smoothTransition.nonneg _, Real.smoothTransition.le_one _⟩ + have hbound : Bornology.IsBounded {x : Fin n → ℝ | ∃ t : ℝ, Fin.cons t x ∈ T ⁻¹' C} := by + apply hCb.subset + rintro x ⟨t, ht⟩ + exact ⟨Real.smoothTransition t, ⟨Real.smoothTransition.nonneg _, Real.smoothTransition.le_one _⟩, ht⟩ + have he := jacobian_integral_moving ρ hρ (F ∘ T) (hF.comp hT) (T ⁻¹' C) + (hC.preimage hT.continuous) hb hbound 0 1 zero_le_one + simpa only [T, Function.comp_apply, mem_preimage, Fin.cons_zero, Fin.tail_cons, + Real.smoothTransition.zero, Real.smoothTransition.one] using he + +end EilenbergGanea + +namespace EilenbergGanea +open Set MeasureTheory Filter Topology + +/-- A nonzero signed count survives an arbitrary moving open set. The compact +boundary slab hypothesis is satisfied by the fixed annulus in the quaternion +application; no boundary triangulation or regular-value hypothesis is used +along the homotopy. -/ +theorem regular_count_persists_moving {n : ℕ} + (F : (Fin (n + 1) → ℝ) → (Fin n → ℝ)) (hF : ContDiff ℝ 2 F) + (y : Fin n → ℝ) (C : Set (Fin (n + 1) → ℝ)) (hC : IsOpen C) + (hc₀ : IsCompact (closure {x | (Fin.cons 0 x : Fin (n + 1) → ℝ) ∈ C})) + (hc₁ : IsCompact (closure {x | (Fin.cons 1 x : Fin (n + 1) → ℝ) ∈ C})) + (hcB : IsCompact {q | q ∈ frontier C ∧ q 0 ∈ Icc (0 : ℝ) 1}) + (hCb : Bornology.IsBounded {x : Fin n → ℝ | ∃ t ∈ Icc (0 : ℝ) 1, Fin.cons t x ∈ C}) + (hb : ∀ q ∈ frontier C, q 0 ∈ Icc (0 : ℝ) 1 → F q ≠ y) + (s : Finset (Fin n → ℝ)) + (hs : ∀ x, x ∈ s ↔ Fin.cons 0 x ∈ C ∧ F (Fin.cons 0 x) = y) + (hd : ∀ x ∈ s, (fderiv ℝ (fun z => F (Fin.cons 0 z)) x).det ≠ 0) + (hcount : (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => F (Fin.cons 0 z)) x).det + then 1 else -1 : ℝ)) ≠ 0) : ∃ x, Fin.cons 1 x ∈ C ∧ F (Fin.cons 1 x) = y := by + classical + by_contra hno + have hno' : ∀ x, Fin.cons 1 x ∈ C → F (Fin.cons 1 x) ≠ y := by simpa using hno + let U : ℝ → Set (Fin n → ℝ) := fun t => {x | (Fin.cons t x : Fin (n + 1) → ℝ) ∈ C} + let f₀ := fun x => F (Fin.cons 0 x) + let f₁ := fun x => F (Fin.cons 1 x) + have hcons (t : ℝ) : ContDiff ℝ 2 (fun x : Fin n → ℝ => (Fin.cons t x : Fin (n + 1) → ℝ)) := by + apply contDiff_pi.mpr + intro i + exact Fin.cases contDiff_const (fun j => contDiff_apply ℝ ℝ j) i + have hU (t : ℝ) : IsOpen (U t) := hC.preimage (hcons t).continuous + have hfront (t : ℝ) : frontier (U t) ⊆ + (fun x : Fin n → ℝ => Fin.cons t x) ⁻¹' frontier C := + (hcons t).continuous.frontier_preimage_subset C + have hf₀ : ContDiff ℝ 1 f₀ := (hF.comp (hcons 0)).of_le (by norm_num) + have hf₁ : Continuous f₁ := (hF.comp (hcons 1)).continuous + obtain ⟨N, hN, hyN, hsign⟩ := regular_signed_count_neighborhood volume f₀ hf₀ y (U 0) + (hU 0) hc₀ (fun x hx => hb _ (hfront 0 hx) (by simp)) s hs hd + let K := F '' {q | q ∈ frontier C ∧ q 0 ∈ Icc (0 : ℝ) 1} + have hK : IsCompact K := hcB.image hF.continuous + have hyK : y ∉ K := by + rintro ⟨q, ⟨hq, ht⟩, he⟩ + exact hb q hq ht he + have hy₁ : y ∉ f₁ '' closure (U 1) := by + rintro ⟨x, hx, he⟩ + by_cases hxU : x ∈ U 1 + · exact hno' x hxU he + · have hxf : x ∈ frontier (U 1) := ⟨hx, by simpa only [(hU 1).interior_eq] using hxU⟩ + exact hb _ (hfront 1 hxf) (by simp) he + let M := N \ (K ∪ f₁ '' closure (U 1)) + have hM : IsOpen M := hN.sdiff (hK.isClosed.union (hc₁.image hf₁).isClosed) + have hyM : y ∈ M := ⟨hyN, fun h => h.elim hyK hy₁⟩ + obtain ⟨ρ, hρ, _, hρM, hunit⟩ := exists_normalized_smooth_bump volume y M hM hyM + have hρN : Function.support ρ ⊆ N := fun z hz => (hρM (subset_tsupport ρ hz)).1 + have hval : jacobianIntegral volume f₀ (U 0) ρ = + ∑ x ∈ s, (if 0 < (fderiv ℝ f₀ x).det then 1 else -1) := + hsign ρ hρ.continuous hρN hunit + have hcollar : ∀ q ∈ frontier C, q 0 ∈ Icc (0 : ℝ) 1 → F q ∉ tsupport ρ := by + intro q hq ht hsup + exact (hρM hsup).2 (Or.inl ⟨q, ⟨hq, ht⟩, rfl⟩) + have hinv := jacobian_integral_moving_interval ρ (hρ.differentiable (by simp)) F hF C hC hcollar hCb + have hzero : jacobianIntegral volume f₁ (U 1) ρ = 0 := by + apply jacobianIntegral_eq_zero_of_no_preimage + intro x hx + apply image_eq_zero_of_notMem_tsupport + intro hsup + exact (hρM hsup).2 (Or.inr ⟨x, subset_closure hx, rfl⟩) + apply hcount + exact hval.symm.trans (hinv.symm.trans hzero) + +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] + +/-- Coordinate-free moving-domain nonzero-count persistence. -/ +theorem regular_count_persists_moving_finiteDimensional + (F : ℝ × E → E) (hF : ContDiff ℝ 2 F) (y : E) + (C : Set (ℝ × E)) (hC : IsOpen C) + (hc₀ : IsCompact (closure {x | (0, x) ∈ C})) + (hc₁ : IsCompact (closure {x | (1, x) ∈ C})) + (hcB : IsCompact {q : ℝ × E | q ∈ frontier C ∧ q.1 ∈ Icc (0 : ℝ) 1}) + (hCb : Bornology.IsBounded {x : E | ∃ t ∈ Icc (0 : ℝ) 1, (t, x) ∈ C}) + (hb : ∀ q ∈ frontier C, q.1 ∈ Icc (0 : ℝ) 1 → F q ≠ y) + (s : Finset E) (hs : ∀ x, x ∈ s ↔ (0, x) ∈ C ∧ F (0, x) = y) + (hd : ∀ x ∈ s, (fderiv ℝ (fun z => F (0, z)) x).det ≠ 0) + (hcount : (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => F (0, z)) x).det + then 1 else -1 : ℝ)) ≠ 0) : ∃ x, (1, x) ∈ C ∧ F (1, x) = y := by + classical + let n := Module.finrank ℝ E + let e : E ≃L[ℝ] (Fin n → ℝ) := (Module.finBasis ℝ E).equivFunL + let H : (ℝ × E) ≃L[ℝ] (Fin (n + 1) → ℝ) := + ((ContinuousLinearEquiv.refl ℝ ℝ).prodCongr e).trans (Fin.consEquivL ℝ (fun _ => ℝ)) + let G : (Fin (n + 1) → ℝ) → (Fin n → ℝ) := fun q => e (F (H.symm q)) + let D := H.symm ⁻¹' C + have hH (t : ℝ) (x : E) : H (t, x) = Fin.cons t (e x) := rfl + have hHi (t : ℝ) (x : Fin n → ℝ) : H.symm (Fin.cons t x) = (t, e.symm x) := by + apply H.injective + rw [H.apply_symm_apply, hH, e.apply_symm_apply] + have hG : ContDiff ℝ 2 G := e.contDiff.comp (hF.comp H.symm.contDiff) + have hdet (x : E) : + (fderiv ℝ (fun z => G (Fin.cons 0 z)) (e x)).det = + (fderiv ℝ (fun z => F (0, z)) x).det := by + have h₀ : DifferentiableAt ℝ (fun z => F (0, z)) x := + (hF.comp (contDiff_const.prodMk contDiff_id)).differentiable (by norm_num) x + have h₀' : HasFDerivAt (fun z => F (0, z)) + (fderiv ℝ (fun z => F (0, z)) x) (e.symm (e x)) := by + simpa only [ContinuousLinearEquiv.symm_apply_apply] using h₀.hasFDerivAt + have hcomp := e.hasFDerivAt.comp (e x) (h₀'.comp (e x) e.symm.hasFDerivAt) + have hh : (fun z => G (Fin.cons 0 z)) = e ∘ (fun z => F (0, z)) ∘ e.symm := by + funext z; simp only [G, hHi, Function.comp_def] + rw [hh, hcomp.fderiv] + exact LinearMap.det_conj _ e.toLinearEquiv + have hslice (t : ℝ) : {x : Fin n → ℝ | Fin.cons t x ∈ D} = e '' {x | (t, x) ∈ C} := by + ext x + change H.symm (Fin.cons t x) ∈ C ↔ _ + rw [hHi] + constructor + · intro hx; exact ⟨e.symm x, hx, e.apply_symm_apply x⟩ + · rintro ⟨z, hz, rfl⟩; simpa only [ContinuousLinearEquiv.symm_apply_apply, mem_ofPred_eq] using hz + have hcompact (t : ℝ) (ht : IsCompact (closure {x : E | (t, x) ∈ C})) : + IsCompact (closure {x : Fin n → ℝ | Fin.cons t x ∈ D}) := by + rw [hslice, ← show (e : E → (Fin n → ℝ)) '' closure {x | (t, x) ∈ C} = closure (e '' {x | (t, x) ∈ C}) from e.toHomeomorph.image_closure _] + exact ht.image e.continuous + have hfront : frontier D = H.symm ⁻¹' frontier C := by + exact (H.symm.toHomeomorph.preimage_frontier C).symm + have hboundary : {q : Fin (n + 1) → ℝ | q ∈ frontier D ∧ q 0 ∈ Icc (0 : ℝ) 1} = + H '' {q : ℝ × E | q ∈ frontier C ∧ q.1 ∈ Icc (0 : ℝ) 1} := by + ext q + rw [hfront] + constructor + · rintro ⟨hq, ht⟩ + refine ⟨H.symm q, ⟨hq, ?_⟩, H.apply_symm_apply q⟩ + exact ht + · rintro ⟨z, ⟨hz, ht⟩, rfl⟩ + refine ⟨?_, ?_⟩ + · simpa only [mem_preimage, ContinuousLinearEquiv.symm_apply_apply] using hz + · exact ht + have hbounded : {x : Fin n → ℝ | ∃ t ∈ Icc (0 : ℝ) 1, Fin.cons t x ∈ D} = + e '' {x : E | ∃ t ∈ Icc (0 : ℝ) 1, (t, x) ∈ C} := by + ext x + constructor + · rintro ⟨t, ht, hx⟩ + have hx' : x ∈ e '' {z | (t, z) ∈ C} := by rw [← hslice]; exact hx + obtain ⟨z, hz, rfl⟩ := hx' + exact ⟨z, ⟨t, ht, hz⟩, rfl⟩ + · rintro ⟨z, ⟨t, ht, hz⟩, rfl⟩ + exact ⟨t, ht, by change e z ∈ {x | Fin.cons t x ∈ D}; rw [hslice]; exact ⟨z, hz, rfl⟩⟩ + let s' := s.map e.toEquiv.toEmbedding + have hs' : ∀ x, x ∈ s' ↔ Fin.cons 0 x ∈ D ∧ G (Fin.cons 0 x) = e y := by + intro x + constructor + · intro hx + obtain ⟨z, hz, rfl⟩ := Finset.mem_map.mp hx + change H.symm (Fin.cons 0 (e z)) ∈ C ∧ e (F (H.symm (Fin.cons 0 (e z)))) = e y + rw [hHi, e.symm_apply_apply] + exact ⟨((hs z).mp hz).1, congrArg e ((hs z).mp hz).2⟩ + · rintro ⟨hx, he⟩ + refine Finset.mem_map.mpr ⟨e.symm x, (hs _).mpr ⟨?_, ?_⟩, e.apply_symm_apply x⟩ + · simpa only [D, mem_preimage, hHi] using hx + · apply e.injective; simpa only [G, hHi] using he + have hd' : ∀ x ∈ s', (fderiv ℝ (fun z => G (Fin.cons 0 z)) x).det ≠ 0 := by + intro x hx + obtain ⟨z, hz, rfl⟩ := Finset.mem_map.mp hx + change (fderiv ℝ (fun z => G (Fin.cons 0 z)) (e z)).det ≠ 0 + rw [hdet]; exact hd z hz + have hcount' : (∑ x ∈ s', (if 0 < (fderiv ℝ (fun z => G (Fin.cons 0 z)) x).det + then 1 else -1 : ℝ)) ≠ 0 := by + change (∑ x ∈ s.map e.toEquiv.toEmbedding, _) ≠ 0 + rw [Finset.sum_map] + change (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => G (Fin.cons 0 z)) (e x)).det then 1 else -1 : ℝ)) ≠ 0 + simpa only [hdet] using hcount + obtain ⟨x, hx, he⟩ := regular_count_persists_moving G hG (e y) D + (hC.preimage H.symm.continuous) (hcompact 0 hc₀) (hcompact 1 hc₁) + (by rw [hboundary]; exact hcB.image H.continuous) + (by rw [hbounded]; exact e.lipschitzWith.isBounded_image hCb) + (by + intro q hq ht heq + apply hb (H.symm q) (by rw [hfront] at hq; exact hq) ht + exact e.injective heq) s' hs' hd' hcount' + exact ⟨e.symm x, by simpa only [D, mem_preimage, hHi] using hx, + e.injective (by simpa only [G, hHi] using he)⟩ +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] + +/-- Arbitrarily small regular approximations at the initial slice suffice for +moving-domain continuation. Uniform closeness is requested on the spatial +projection of the boundary slab, not on an assumed fixed isolating domain. -/ +theorem regular_approximation_persists_moving + (F : ℝ × E → E) (hF : ContDiff ℝ 2 F) + (C : Set (ℝ × E)) (hC : IsOpen C) + (hc₀ : IsCompact (closure {x | (0, x) ∈ C})) + (hc₁ : IsCompact (closure {x | (1, x) ∈ C})) + (hcB : IsCompact {q : ℝ × E | q ∈ frontier C ∧ q.1 ∈ Icc (0 : ℝ) 1}) + (hCb : Bornology.IsBounded {x : E | ∃ t ∈ Icc (0 : ℝ) 1, (t, x) ∈ C}) + (hb : ∀ q ∈ frontier C, q.1 ∈ Icc (0 : ℝ) 1 → F q ≠ 0) + (L : Set E) (hLB : ∀ q ∈ frontier C, q.1 ∈ Icc (0 : ℝ) 1 → q.2 ∈ L) + (happrox : ∀ ε : ℝ, 0 < ε → ∃ g : E → E, ContDiff ℝ ∞ g ∧ + (∀ x ∈ L, ‖g x - F (0, x)‖ < ε) ∧ + ∃ s : Finset E, (∀ x, x ∈ s ↔ x ∈ closure {z | (0, z) ∈ C} ∧ g x = 0) ∧ + (∀ x ∈ s, (fderiv ℝ g x).det ≠ 0) ∧ + (∑ x ∈ s, (if 0 < (fderiv ℝ g x).det then 1 else -1 : ℝ)) ≠ 0) : + ∃ x, (1, x) ∈ C ∧ F (1, x) = 0 := by + classical + let P := {q : ℝ × E | q ∈ frontier C ∧ q.1 ∈ Icc (0 : ℝ) 1} + have hz : (0 : E) ∈ (F '' P)ᶜ := by + rintro ⟨q, ⟨hq, ht⟩, he⟩ + exact hb q hq ht he + obtain ⟨ε, hε, hball⟩ := Metric.isOpen_iff.mp (hcB.image hF.continuous).isClosed.isOpen_compl 0 hz + have hbound : ∀ q ∈ frontier C, q.1 ∈ Icc (0 : ℝ) 1 → ε ≤ ‖F q‖ := by + intro q hq ht + by_contra hn + have hmem : F q ∈ Metric.ball (0 : E) ε := by + simpa only [Metric.mem_ball, dist_zero_right] using lt_of_not_ge hn + exact hball hmem ⟨q, ⟨hq, ht⟩, rfl⟩ + obtain ⟨g, hg, hclose, s, hs, hd, hcount⟩ := happrox ε hε + let G : ℝ × E → E := fun q => F q + (1 - q.1) • (g q.2 - F (0, q.2)) + have hG : ContDiff ℝ 2 G := hF.add + ((contDiff_const.sub contDiff_fst).smul (((contDiff_infty.mp hg 2).comp contDiff_snd).sub + (hF.comp (contDiff_const.prodMk contDiff_snd)))) + have hG0 : (fun x => G (0, x)) = g := by funext x; simp [G] + have hG1 : (fun x => G (1, x)) = fun x => F (1, x) := by funext x; simp [G] + have hGb : ∀ q ∈ frontier C, q.1 ∈ Icc (0 : ℝ) 1 → G q ≠ 0 := by + intro q hq ht he + have heq : F q = -((1 - q.1) • (g q.2 - F (0, q.2))) := eq_neg_of_add_eq_zero_left he + have hn : ‖F q‖ < ε := by + rw [heq, norm_neg, norm_smul, Real.norm_eq_abs, abs_of_nonneg (by linarith [ht.2])] + calc + (1 - q.1) * ‖g q.2 - F (0, q.2)‖ ≤ ‖g q.2 - F (0, q.2)‖ := + mul_le_of_le_one_left (norm_nonneg _) (by linarith [ht.1]) + _ < ε := hclose q.2 (hLB q hq ht) + exact (not_lt_of_ge (hbound q hq ht)) hn + have hU : IsOpen {x : E | (0, x) ∈ C} := hC.preimage (continuous_const.prodMk continuous_id) + have hfront : frontier {x : E | (0, x) ∈ C} ⊆ (fun x : E => ((0 : ℝ), x)) ⁻¹' frontier C := + (continuous_const.prodMk continuous_id).frontier_preimage_subset C + have hsU : ∀ x, x ∈ s ↔ (0, x) ∈ C ∧ G (0, x) = 0 := by + intro x + rw [hs, show G (0, x) = g x from congrFun hG0 x] + constructor + · rintro ⟨hx, he⟩ + refine ⟨?_, he⟩ + by_contra hn + have hxf : x ∈ frontier {z : E | (0, z) ∈ C} := + ⟨hx, by simpa only [hU.interior_eq, mem_ofPred_eq] using hn⟩ + exact hGb (0, x) (hfront hxf) (by simp) + (by rw [show G (0, x) = g x from congrFun hG0 x]; exact he) + · rintro ⟨hx, he⟩; exact ⟨subset_closure hx, he⟩ + have hd' : ∀ x ∈ s, (fderiv ℝ (fun z => G (0, z)) x).det ≠ 0 := by rw [hG0]; exact hd + have hcount' : (∑ x ∈ s, (if 0 < (fderiv ℝ (fun z => G (0, z)) x).det then 1 else -1 : ℝ)) ≠ 0 := by + rw [hG0]; exact hcount + obtain ⟨x, hx, he⟩ := regular_count_persists_moving_finiteDimensional G hG 0 C hC hc₀ hc₁ hcB hCb hGb s hsU hd' hcount' + exact ⟨x, hx, by simpa only [show G (1, x) = F (1, x) from congrFun hG1 x] using he⟩ + +/-- Full localized word-root persistence for moving open sets. Contains the +singular pure-word initial maps used in the manuscript's finite-quotient step. -/ +theorem localized_word_root_persists_moving {m : ℕ} + (w : Fin m → FreeGroup (Fin m)) (hB : (exponentMatrix w).det ≠ 0) + (F : ℝ × ((Fin m → ℂ) × (Fin m → ℂ)) → ((Fin m → ℂ) × (Fin m → ℂ))) + (hF : ContDiff ℝ 2 F) (hF0 : ∀ q, F (0, q) = splitWordMap w q) + (C : Set (ℝ × ((Fin m → ℂ) × (Fin m → ℂ)))) (hC : IsOpen C) + (hc₀ : IsCompact (closure {x | (0, x) ∈ C})) + (hc₁ : IsCompact (closure {x | (1, x) ∈ C})) + (hcB : IsCompact {q | q ∈ frontier C ∧ q.1 ∈ Icc (0 : ℝ) 1}) + (hCb : Bornology.IsBounded {x | ∃ t ∈ Icc (0 : ℝ) 1, (t, x) ∈ C}) + (hUi : ∀ z : ℂ, ‖z‖ = 1 → ∀ q ∈ closure {x | (0, x) ∈ C}, + (q.1, z • q.2) ∈ closure {x | (0, x) ∈ C}) + (h1 : (0, (1, 0)) ∈ C) + (hb : ∀ q ∈ frontier C, q.1 ∈ Icc (0 : ℝ) 1 → F q ≠ 0) : + ∃ x, (1, x) ∈ C ∧ F (1, x) = 0 := by + let K := closure {x | (0, x) ∈ C} + let L := K ∪ Prod.snd '' {q | q ∈ frontier C ∧ q.1 ∈ Icc (0 : ℝ) 1} + have hL : IsCompact L := hc₀.union (hcB.image continuous_snd) + apply regular_approximation_persists_moving F hF C hC hc₀ hc₁ hcB hCb hb L + (fun q hq ht => Or.inr ⟨q, ⟨hq, ht⟩, rfl⟩) + intro ε hε + simpa only [hF0] using word_exists_regularization_nonzero_count w hB + K hc₀ hUi (subset_closure h1) L hL subset_union_left ε hε +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/IntegralModules.lean b/lean/OAI/Topology/EilenbergGanea/IntegralModules.lean new file mode 100644 index 0000000000000000000000000000000000000000..746e9ab98cbbc638570035f4eeb531ddccede40e --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/IntegralModules.lean @@ -0,0 +1,308 @@ +import OAI.Topology.EilenbergGanea.Model +import OAI.Topology.EilenbergGanea.PresentationAlignment +import Mathlib.Algebra.Category.ModuleCat.ProjectiveDimension +import Mathlib.RingTheory.Noetherian.Basic + +namespace OAI + +noncomputable section + +open Classical Set + +/-! Group-ring augmentation and literal two-syzygy dimension criterion. -/ +namespace EilenbergGanea +open CategoryTheory + +section ProjectiveBound +variable {R P Q M : Type} [Ring R] + [AddCommGroup P] [Module R P] [AddCommGroup Q] [Module R Q] + [AddCommGroup M] [Module R M] + +/-- Two successive projective syzygies give the literal integral upper bound. -/ +theorem projectiveDimension_le_two_of_syzygies + (ε : P →ₗ[R] M) (hε : Function.Surjective ε) + (d : Q →ₗ[R] LinearMap.ker ε) (hd : Function.Surjective d) + [Module.Projective R P] [Module.Projective R Q] + [Module.Projective R (LinearMap.ker d)] : + CategoryTheory.projectiveDimension (ModuleCat.of R M) ≤ 2 := by + have h₁ := (LinearMap.shortExact_shortComplexKer hd).hasProjectiveDimensionLT_X₃ 1 + (inferInstance : HasProjectiveDimensionLT (ModuleCat.of R (LinearMap.ker d)) 1) + (inferInstance : HasProjectiveDimensionLT (ModuleCat.of R Q) 2) + have h₂ := (LinearMap.shortExact_shortComplexKer hε).hasProjectiveDimensionLT_X₃ 2 + h₁ (inferInstance : HasProjectiveDimensionLT (ModuleCat.of R P) 3) + exact (CategoryTheory.projectiveDimension_le_iff _ 2).mpr h₂ +end ProjectiveBound + +section CayleyModules +variable {Γ S : Type} [Group Γ] + +abbrev IntegralGroupRing (Γ : Type) [Group Γ] := MonoidAlgebra ℤ Γ +abbrev IntegralTrivialModule (Γ : Type) [Group Γ] := + (Representation.trivial ℤ Γ ℤ).asModule + +def cayleyAugmentation : IntegralGroupRing Γ →ₗ[IntegralGroupRing Γ] IntegralTrivialModule Γ := + LinearMap.toSpanSingleton (IntegralGroupRing Γ) _ + ((Representation.trivial ℤ Γ ℤ).asModuleEquiv.symm 1) + +@[simp] theorem cayleyAugmentation_single (g : Γ) (n : ℤ) : + cayleyAugmentation (MonoidAlgebra.single g n) = + (Representation.trivial ℤ Γ ℤ).asModuleEquiv.symm n := by + change (MonoidAlgebra.single g n : IntegralGroupRing Γ) • + ((Representation.trivial ℤ Γ ℤ).asModuleEquiv.symm 1) = _ + rw [Representation.single_smul] + change (n : ℤ) * 1 = n + exact mul_one n + +theorem cayleyAugmentation_surjective : + Function.Surjective (cayleyAugmentation (Γ := Γ)) := by + intro n + refine ⟨MonoidAlgebra.single (1 : Γ) ((Representation.trivial ℤ Γ ℤ).asModuleEquiv n),?_⟩ + rw [cayleyAugmentation_single,LinearEquiv.symm_apply_apply] + +def cayleyDifferential (v : S → Γ) : + (S →₀ IntegralGroupRing Γ) →ₗ[IntegralGroupRing Γ] IntegralGroupRing Γ := + Finsupp.linearCombination _ (fun s => MonoidAlgebra.single (v s) 1 - 1) + +@[simp] theorem cayleyDifferential_single (v : S → Γ) (s : S) (r : IntegralGroupRing Γ) : + cayleyDifferential v (Finsupp.single s r) = r * (MonoidAlgebra.single (v s) 1 - 1) := by + simp [cayleyDifferential] + +@[simp] theorem cayleyAugmentation_one : + cayleyAugmentation (1 : IntegralGroupRing Γ) = + (Representation.trivial ℤ Γ ℤ).asModuleEquiv.symm 1 := + cayleyAugmentation_single (1 : Γ) 1 + +@[simp] theorem cayleyAugmentation_difference (g : Γ) : + cayleyAugmentation (MonoidAlgebra.single g 1 - 1) = 0 := by + rw [map_sub, cayleyAugmentation_single, cayleyAugmentation_one, sub_self] + +theorem cayleyDifferential_aug (v : S → Γ) : + (cayleyAugmentation (Γ := Γ)).comp (cayleyDifferential v) = 0 := by + change (cayleyAugmentation (Γ := Γ)).comp + (Finsupp.linearCombination _ (fun s => MonoidAlgebra.single (v s) 1 - 1)) = 0 + rw [← Finsupp.linearCombination_linear_comp] + have he : (cayleyAugmentation (Γ := Γ)) ∘ + (fun s => MonoidAlgebra.single (v s) 1 - 1) = (0 : S → IntegralTrivialModule Γ) := by + funext s + exact cayleyAugmentation_difference (v s) + rw [he, Finsupp.linearCombination_zero] + + theorem cayleyGeneratorDifference_mem (v : S → Γ) (w : FreeGroup S) : + MonoidAlgebra.single (FreeGroup.lift v w) 1 - 1 ∈ LinearMap.range (cayleyDifferential v) := by + induction w using FreeGroup.induction_on with + | one => + simp only [map_one] + have he : (MonoidAlgebra.single (1 : Γ) 1 : IntegralGroupRing Γ) = 1 := rfl + rw [he,sub_self] + exact Submodule.zero_mem _ + | of s => + exact ⟨Finsupp.single s 1,by simp⟩ + | inv_of s => + refine ⟨Finsupp.single s (-MonoidAlgebra.single (v s)⁻¹ 1),?_⟩ + simp [mul_sub,MonoidAlgebra.single_mul_single] + rfl + | mul w z hw hz => + have hh := (LinearMap.range (cayleyDifferential v)).smul_mem + (MonoidAlgebra.single (FreeGroup.lift v w) 1) hz + have hc := (LinearMap.range (cayleyDifferential v)).add_mem hw hh + rw [map_mul] + convert hc using 1 + change _ = (_ - 1) + _ * (_ - 1) + rw [mul_sub,mul_one,MonoidAlgebra.single_mul_single,one_mul] + abel + +theorem cayleyAugmentation_normalize (v : S → Γ) + (hv : Function.Surjective (FreeGroup.lift v)) (r : IntegralGroupRing Γ) : + r - MonoidAlgebra.single 1 + ((Representation.trivial ℤ Γ ℤ).asModuleEquiv (cayleyAugmentation r)) ∈ + LinearMap.range (cayleyDifferential v) := by + classical + induction r using MonoidAlgebra.induction_linear with + | zero => simp + | add r t hr ht => + rw [map_add, map_add, MonoidAlgebra.single_add] + convert (LinearMap.range (cayleyDifferential v)).add_mem hr ht using 1; abel + | single g n => + rw [cayleyAugmentation_single, LinearEquiv.apply_symm_apply] + obtain ⟨w, hw⟩ := hv g + have hm := (LinearMap.range (cayleyDifferential v)).toAddSubgroup.zsmul_mem + (cayleyGeneratorDifference_mem v w) n + rw [hw] at hm + convert hm using 1 + simp only [smul_sub, MonoidAlgebra.smul_single, zsmul_eq_mul, mul_one] + rfl + +theorem cayley_exact (v : S → Γ) (hv : Function.Surjective (FreeGroup.lift v)) : + LinearMap.range (cayleyDifferential v) = LinearMap.ker (cayleyAugmentation (Γ := Γ)) := by + apply le_antisymm + · rintro _ ⟨r,rfl⟩ + exact LinearMap.congr_fun (cayleyDifferential_aug v) r + · intro r hr + have hm := cayleyAugmentation_normalize v hv r + rw [LinearMap.mem_ker.mp hr, map_zero, MonoidAlgebra.single_zero, sub_zero] at hm + exact hm + +def cayleySyzygyDifferential (v : S → Γ) : + (S →₀ IntegralGroupRing Γ) →ₗ[IntegralGroupRing Γ] + LinearMap.ker (cayleyAugmentation (Γ := Γ)) := + (cayleyDifferential v).codRestrict _ (by + intro r + exact LinearMap.congr_fun (cayleyDifferential_aug v) r) + +theorem cayleySyzygyDifferential_surjective (v : S → Γ) + (hv : Function.Surjective (FreeGroup.lift v)) : + Function.Surjective (cayleySyzygyDifferential v) := by + intro r + have hr : (r : IntegralGroupRing Γ) ∈ LinearMap.range (cayleyDifferential v) := by + rw [cayley_exact v hv] + exact r.property + obtain ⟨s, hs⟩ := hr + exact ⟨s, Subtype.ext hs⟩ + +theorem cayley_projectiveDimension_le_two (v : S → Γ) + (hv : Function.Surjective (FreeGroup.lift v)) + [Module.Projective (IntegralGroupRing Γ) (LinearMap.ker (cayleyDifferential v))] : + CategoryTheory.projectiveDimension + (ModuleCat.of (IntegralGroupRing Γ) (IntegralTrivialModule Γ)) ≤ 2 := by + have hk : LinearMap.ker (cayleySyzygyDifferential v) = + LinearMap.ker (cayleyDifferential v) := LinearMap.ker_codRestrict _ _ _ + have : Module.Projective (IntegralGroupRing Γ) + (LinearMap.ker (cayleySyzygyDifferential v)) := hk ▸ inferInstance + exact projectiveDimension_le_two_of_syzygies cayleyAugmentation + cayleyAugmentation_surjective (cayleySyzygyDifferential v) + (cayleySyzygyDifferential_surjective v hv) + +end CayleyModules +end EilenbergGanea + +namespace EilenbergGanea +section ChainPackaging +variable {Γ S T : Type} [Group Γ] + +/-- Reindex the actual integral edge chains as a free left group-ring module. -/ +def chainPackaging : BasedChains Γ S ≃ₗ[ℤ] S →₀ IntegralGroupRing Γ := + ((Finsupp.domLCongr (Equiv.prodComm Γ S)).trans (Finsupp.curryLinearEquiv ℤ)).trans + (Finsupp.mapRange.linearEquiv (MonoidAlgebra.coeffLinearEquiv ℤ).symm) + +@[simp] theorem chainPackaging_single (g : Γ) (s : S) (n : ℤ) : + chainPackaging (Finsupp.single (g,s) n) = + Finsupp.single s (MonoidAlgebra.single g n) := by + simp [chainPackaging, Finsupp.curry_single] + +@[simp] theorem chainPackaging_symm_single (g : Γ) (s : S) (n : ℤ) : + (chainPackaging (Γ := Γ) (S := S)).symm + (Finsupp.single s (MonoidAlgebra.single g n)) = Finsupp.single (g,s) n := by + apply (chainPackaging (Γ := Γ) (S := S)).injective + simp + +theorem chainPackaging_translate (g : Γ) (c : BasedChains Γ S) : + chainPackaging (translateChains g c) = + (MonoidAlgebra.single g 1 : IntegralGroupRing Γ) • chainPackaging c := by + have he : (chainPackaging (Γ := Γ) (S := S)).toLinearMap.comp (translateChains g) = + (DistribSMul.toLinearMap ℤ (S →₀ IntegralGroupRing Γ) (MonoidAlgebra.single g 1 : IntegralGroupRing Γ)).comp + (chainPackaging (Γ := Γ) (S := S)).toLinearMap := by + apply Finsupp.lhom_ext + rintro ⟨h,s⟩ n + simp [Finsupp.smul_single, MonoidAlgebra.single_mul_single] + exact LinearMap.congr_fun he c + +theorem chainPackaging_boundary (v : S → Γ) (c : BasedChains Γ S) : + cayleyDifferential v (chainPackaging c) = MonoidAlgebra.ofCoeff (edgeBoundary v c) := by + have he : ((cayleyDifferential v).restrictScalars ℤ).comp + (chainPackaging (Γ := Γ) (S := S)).toLinearMap = + (MonoidAlgebra.coeffLinearEquiv ℤ).symm.toLinearMap.comp (edgeBoundary v) := by + apply Finsupp.lhom_ext + rintro ⟨g,s⟩ n + simp only [LinearMap.comp_apply, LinearMap.coe_restrictScalars, LinearEquiv.coe_coe, + chainPackaging_single, cayleyDifferential_single, edgeBoundary_single, map_smul, + map_sub] + simp only [mul_sub, MonoidAlgebra.single_mul_single, mul_one, + MonoidAlgebra.coeffLinearEquiv_symm_apply, MonoidAlgebra.ofCoeff_single, + MonoidAlgebra.smul_single, smul_sub, smul_eq_mul] + exact LinearMap.congr_fun he c + +theorem chainPackaging_symm_translate (g : Γ) (c : S →₀ IntegralGroupRing Γ) : + (chainPackaging (Γ := Γ) (S := S)).symm ((MonoidAlgebra.single g 1 : IntegralGroupRing Γ) • c) = + translateChains g (chainPackaging.symm c) := by + apply (chainPackaging (Γ := Γ) (S := S)).injective + rw [chainPackaging_translate, LinearEquiv.apply_symm_apply, LinearEquiv.apply_symm_apply] + +/-- Equivariance on integral chains is exactly full group-ring linearity. -/ +def chainRingMap (A : BasedChains Γ S →ₗ[ℤ] BasedChains Γ T) + (hA : ChainsEquivariant A) : + (S →₀ IntegralGroupRing Γ) →ₗ[IntegralGroupRing Γ] T →₀ IntegralGroupRing Γ where + toFun c := chainPackaging (A (chainPackaging.symm c)) + map_add' _ _ := by simp only [map_add] + map_smul' r c := by + induction r using MonoidAlgebra.induction_linear with + | zero => simp only [zero_smul, map_zero] + | add r t hr ht => simp only [add_smul, map_add, hr, ht] + | single g n => + have hn : (MonoidAlgebra.single g n : IntegralGroupRing Γ) = + n • MonoidAlgebra.single g 1 := by simp + rw [hn] + simp only [smul_assoc, map_smul, chainPackaging_symm_translate, RingHom.id_apply] + rw [hA g _, chainPackaging_translate] + +@[simp] theorem chainRingMap_apply (A : BasedChains Γ S →ₗ[ℤ] BasedChains Γ T) + (hA : ChainsEquivariant A) (c : S →₀ IntegralGroupRing Γ) : + chainRingMap A hA c = chainPackaging (A (chainPackaging.symm c)) := rfl + +theorem chainPackaging_mem_cycles (v : S → Γ) (c : BasedChains Γ S) : + c ∈ cycles v ↔ chainPackaging c ∈ LinearMap.ker (cayleyDifferential v) := by + change edgeBoundary v c = 0 ↔ cayleyDifferential v (chainPackaging c) = 0 + rw [chainPackaging_boundary] + constructor + · intro h + rw [h] + rfl + · intro h + have hh := congrArg MonoidAlgebra.coeff h + exact hh + +theorem projective_cayley_cycles_of_boundary_basis (v : S → Γ) + (A : BasedChains Γ T →ₗ[ℤ] BasedChains Γ S) (hA : ChainsEquivariant A) + (hAi : Function.Injective A) (hAr : LinearMap.range A = cycles v) : + Module.Projective (IntegralGroupRing Γ) (LinearMap.ker (cayleyDifferential v)) := by + have hm : ∀ c, chainRingMap A hA c ∈ LinearMap.ker (cayleyDifferential v) := by + intro c + apply (chainPackaging_mem_cycles v _).mp + rw [← hAr] + exact ⟨chainPackaging.symm c,rfl⟩ + let d := (chainRingMap A hA).codRestrict _ hm + have hi : Function.Injective d := by + intro c c' h + apply (chainPackaging (Γ := Γ) (S := T)).symm.injective + apply hAi + apply chainPackaging.injective + exact congrArg Subtype.val h + have hs : Function.Surjective d := by + intro c + have hc : chainPackaging.symm (c : S →₀ IntegralGroupRing Γ) ∈ cycles v := by + apply (chainPackaging_mem_cycles v _).mpr + rw [LinearEquiv.apply_symm_apply] + exact c.property + rw [← hAr] at hc + obtain ⟨b,hb⟩ := hc + refine ⟨chainPackaging b,Subtype.ext ?_⟩ + change chainPackaging (A (chainPackaging.symm (chainPackaging b))) = c.val + rw [LinearEquiv.symm_apply_apply,hb,LinearEquiv.apply_symm_apply] + exact Module.Projective.of_equiv' (LinearEquiv.ofBijective d ⟨hi,hs⟩) + +theorem projectiveDimension_le_two_of_boundary_basis (v : S → Γ) + (hv : Function.Surjective (FreeGroup.lift v)) + (A : BasedChains Γ T →ₗ[ℤ] BasedChains Γ S) (hA : ChainsEquivariant A) + (hAi : Function.Injective A) (hAr : LinearMap.range A = cycles v) : + CategoryTheory.projectiveDimension + (ModuleCat.of (IntegralGroupRing Γ) (IntegralTrivialModule Γ)) ≤ 2 := by + have := projective_cayley_cycles_of_boundary_basis v A hA hAi hAr + exact cayley_projectiveDimension_le_two v hv + +end ChainPackaging + + +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/LevelBasis.lean b/lean/OAI/Topology/EilenbergGanea/LevelBasis.lean new file mode 100644 index 0000000000000000000000000000000000000000..b79749b9d6bec52de292a044dbe0c4c5721deff8 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/LevelBasis.lean @@ -0,0 +1,968 @@ +import OAI.AlgebraicTopology.Cubical.HeightChains +import OAI.Topology.EilenbergGanea.IntegralModules +import OAI.Topology.EilenbergGanea.LevelTransport + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea.LevelBasis +open CubicalChains CubicalChains.LevelExact CubicalChains.HeightFiltration +variable {G A : Type} [Group G] [LinearOrder A] +variable (L : SimpleGraph A) (φ : G →* Multiplicative ℤ) (v : A → G) (root : A) +def ht (g : G) : ℤ := (φ g).toAdd +@[simp] theorem ht_mul (g q : G) : ht φ (g*q) = ht φ g + ht φ q := by simp [ht] +@[simp] theorem ht_one : ht φ 1 = 0 := by simp [ht] +@[simp] theorem ht_inv (g : G) : ht φ g⁻¹ = -ht φ g := by simp [ht] +@[simp] theorem ht_zpow (g : G) (n : ℤ) : ht φ (g^n) = n * ht φ g := by simp [ht] +@[simp] theorem ht_ker (g : φ.ker) : ht φ g = 0 := by simp [ht,MonoidHom.mem_ker.mp g.property] +variable (hv : ∀ a, φ (v a) = Multiplicative.ofAdd (1 : ℤ)) +include hv in +omit [LinearOrder A] in +@[simp] theorem ht_generator (a : A) : ht φ (v a) = 1 := by simp [ht,hv] +include hv in +omit [LinearOrder A] in +theorem ht_step (g : G) (a : A) : ht φ (g * v a) = ht φ g + 1 := by simp [ht_generator φ v hv] + +def Shape (k : ℕ) := {p : List A × ℤ // SimplicialChains.Valid L p.1 ∧ p.1.length = k ∧ + p.2 < 0 ∧ 0 < p.2 + (k : ℤ)} +def basisIndex (k : ℕ) (p : φ.ker × Shape L k) : G × List A := + (p.1.val * (v (p.2.val.1.headD root)) ^ p.2.val.2,p.2.val.1) + +include hv in +theorem basisIndex_height (k : ℕ) (p : φ.ker × Shape L k) : + ht φ (basisIndex L φ v root k p).1 = p.2.val.2 := by + simp only [basisIndex,ht_mul,ht_ker,ht_zpow,ht_generator φ v hv,mul_one,zero_add] + +include hv in +theorem basisIndex_injective (k : ℕ) : Function.Injective (basisIndex L φ v root k) := by + intro p q he + have hw : p.2.val.1 = q.2.val.1 := congrArg Prod.snd he + have hh := congrArg (fun x => ht φ x.1) he + rw [basisIndex_height L φ v root hv,basisIndex_height L φ v root hv] at hh + have hs : p.2 = q.2 := Subtype.ext (Prod.ext hw hh) + have hg := congrArg Prod.fst he + simp only [basisIndex,hs] at hg + exact Prod.ext (Subtype.ext (mul_right_cancel hg)) hs + +include hv in +theorem basisIndex_mem (k : ℕ) (p : φ.ker × Shape L k) : + SimplicialChains.Valid L (basisIndex L φ v root k p).2 ∧ + (basisIndex L φ v root k p).2.length = k ∧ + ht φ (basisIndex L φ v root k p).1 < 0 ∧ + 0 < ht φ (basisIndex L φ v root k p).1 + (k : ℤ) := by + rw [basisIndex_height L φ v root hv] + exact p.2.property + +include hv in +theorem exists_basisIndex {k : ℕ} (p : G × List A) + (hp : SimplicialChains.Valid L p.2 ∧ p.2.length = k ∧ ht φ p.1 < 0 ∧ 0 < ht φ p.1 + (k : ℤ)) : + ∃ q : φ.ker × Shape L k, basisIndex L φ v root k q = p := by + let s : Shape L k := ⟨(p.2,ht φ p.1),hp⟩ + let g : φ.ker := ⟨p.1 * (v (p.2.headD root)) ^ (-ht φ p.1),by + apply (Multiplicative.toAdd.injective) + change ht φ (p.1 * (v (p.2.headD root)) ^ (-ht φ p.1)) = 0 + simp only [ht_mul,ht_zpow,ht_generator φ v hv,mul_one,add_neg_cancel]⟩ + refine ⟨(g,s),?_⟩ + apply Prod.ext + · change (p.1 * (v (p.2.headD root)) ^ (-ht φ p.1)) * (v (p.2.headD root)) ^ (ht φ p.1) = p.1 + rw [mul_assoc,← zpow_add,neg_add_cancel,zpow_zero,mul_one] + · rfl + +def includeBasis (k : ℕ) : (φ.ker × Shape L k →₀ ℤ) →ₗ[ℤ] CubicalChains.Chains G A := + Finsupp.lmapDomain ℤ ℤ (basisIndex L φ v root k) +@[simp] theorem includeBasis_single (k : ℕ) (p : φ.ker × Shape L k) (n : ℤ) : + includeBasis L φ v root k (Finsupp.single p n) = Finsupp.single (basisIndex L φ v root k p) n := by + simp [includeBasis] +include hv in +theorem includeBasis_injective (k : ℕ) : Function.Injective (includeBasis L φ v root k) := + Finsupp.mapDomain_injective (basisIndex_injective L φ v root hv k) + +include hv in +theorem includeBasis_range (k : ℕ) : LinearMap.range (includeBasis L φ v root k) = crossing L (ht φ) k := by + rw [includeBasis,Finsupp.range_lmapDomain,crossing,Finsupp.supported_eq_span_single] + congr 1 + ext c + constructor + · rintro ⟨p,rfl⟩ + exact ⟨basisIndex L φ v root k p,basisIndex_mem L φ v root hv k p,rfl⟩ + · rintro ⟨p,hp,rfl⟩ + obtain ⟨q,rfl⟩ := exists_basisIndex L φ v root hv p hp + exact ⟨q,rfl⟩ + +variable (comm : ∀ a b, L.Adj a b → Commute (v a) (v b)) +include hv in +def projectBasis (k : ℕ) : CubicalChains.Chains G A →ₗ[ℤ] (φ.ker × Shape L k →₀ ℤ) := + Finsupp.lcomapDomain (basisIndex L φ v root k) (basisIndex_injective L φ v root hv k) + +@[simp] theorem project_include (k : ℕ) (c : φ.ker × Shape L k →₀ ℤ) : + projectBasis L φ v root hv k (includeBasis L φ v root k c) = c := + Finsupp.leftInverse_lcomapDomain_mapDomain _ _ c + +include hv in +theorem include_project {k : ℕ} {c : CubicalChains.Chains G A} (hc : c ∈ crossing L (ht φ) k) : + includeBasis L φ v root k (projectBasis L φ v root hv k c) = c := by + rw [← includeBasis_range L φ v root hv k] at hc + obtain ⟨d,rfl⟩ := hc + rw [project_include] + +include hv in +theorem includeBasis_mem (k : ℕ) (c : φ.ker × Shape L k →₀ ℤ) : + includeBasis L φ v root k c ∈ crossing L (ht φ) k := by + rw [← includeBasis_range L φ v root hv k] + exact ⟨c,rfl⟩ + +/-- The level edge parameter has precisely two directions and initial height -1. -/ +theorem shape_two_form (s : Shape L 2) : ∃ a b, s.val = ([a,b],-1) := by + obtain ⟨a,b,hab⟩ := List.length_eq_two.mp s.property.2.1 + refine ⟨a,b,Prod.ext hab ?_⟩ + have hn := s.property.2.2.1 + have hm := s.property.2.2.2 + norm_num at hm + omega + +def generator (s : Shape L 2) : φ.ker := + ⟨(v (s.val.1.headD root))⁻¹ * v (s.val.1.tail.headD root),by simp [hv]⟩ + +def includeVertices : (φ.ker →₀ ℤ) →ₗ[ℤ] CubicalChains.Chains G A := + Finsupp.lmapDomain ℤ ℤ (fun g => (g.val,[])) +omit [LinearOrder A] in +@[simp] theorem includeVertices_single (g : φ.ker) (n : ℤ) : + includeVertices (A := A) φ (Finsupp.single g n) = Finsupp.single (g.val,[]) n := by simp [includeVertices] +omit [LinearOrder A] in +theorem includeVertices_injective : Function.Injective (includeVertices (A := A) φ) := by + apply Finsupp.mapDomain_injective + intro p q he + exact Subtype.ext (congrArg Prod.fst he) + +include hv in +omit [LinearOrder A] in +theorem boundary_square (g : G) (a b : A) (hab : Commute (v a) (v b)) + (hg : ht φ g = -1) : + levelBoundary v (ht φ) (Finsupp.single (g,[a,b]) 1) = + Finsupp.single (g*v b,[]) 1 - Finsupp.single (g*v a,[]) 1 := by + have hga : ht φ (g * v a) = 0 := by rw [ht_step φ v hv,hg]; omega + have hgb : ht φ (g * v b) = 0 := by rw [ht_step φ v hv,hg]; omega + simp only [levelBoundary_apply,boundary_single,one_smul,boundaryTerm_cons,boundaryTerm_nil, + map_zero,sub_zero,map_sub,front_single,plus,select_single,hga,hgb,hg] + norm_num + rw [mul_assoc,hab.eq,← mul_assoc] + abel + + +include hv comm in +theorem levelBoundary_include_single (p : φ.ker × Shape L 2) : + levelBoundary v (ht φ) (includeBasis L φ v root 2 (Finsupp.single p 1)) = + includeVertices (A := A) φ (edgeBoundary (generator L φ v root hv) (Finsupp.single p 1)) := by + rcases p with ⟨g,⟨⟨w,n⟩,hs⟩⟩ + obtain ⟨a,b,hw⟩ := List.length_eq_two.mp hs.2.1 + change w = [a,b] at hw + subst w + have hn : n = -1 := by have h₁ := hs.2.2.1; have h₂ := hs.2.2.2; norm_num at h₂; omega + subst n + have hab : L.Adj a b := (List.pairwise_cons.mp hs.1.2).1 b (by simp) + rw [includeBasis_single] + change levelBoundary v (ht φ) (Finsupp.single (g.val * (v a)^(-1 : ℤ),[a,b]) 1) = _ + rw [boundary_square φ v hv _ a b (comm a b hab) (by simp [ht_generator φ v hv])] + simp only [edgeBoundary,Finsupp.linearCombination_single] + simp only [zpow_neg_one,one_smul,map_sub,includeVertices_single, + Subgroup.coe_mul,generator,List.headD_cons,List.tail_cons,mul_assoc,inv_mul_cancel,mul_one] + +include hv comm in +theorem levelBoundary_include (c : φ.ker × Shape L 2 →₀ ℤ) : + levelBoundary v (ht φ) (includeBasis L φ v root 2 c) = + includeVertices (A := A) φ (edgeBoundary (generator L φ v root hv) c) := by + induction c using Finsupp.induction_linear with + | zero => simp + | add c d hc hd => simp only [map_add,hc,hd] + | single p n => + have he : Finsupp.single p n = n • Finsupp.single p (1 : ℤ) := by simp + rw [he,map_smul,map_smul,map_smul,map_smul,levelBoundary_include_single L φ v root hv comm] + +/-- The literal based integral boundary of the crossing three-cubes. -/ +def triangleBoundary : (φ.ker × Shape L 3 →₀ ℤ) →ₗ[ℤ] (φ.ker × Shape L 2 →₀ ℤ) := + (projectBasis L φ v root hv 2).comp ((crossPart (ht φ)).comp ((boundary v).comp (includeBasis L φ v root 3))) + +include hv in +theorem triangleBoundary_inclusion (c : φ.ker × Shape L 3 →₀ ℤ) : + includeBasis L φ v root 2 (triangleBoundary L φ v root hv c) = + crossPart (ht φ) (boundary v (includeBasis L φ v root 3 c)) := by + apply include_project L φ v root hv + exact crossPart_mem L (ht φ) (boundary_total L v (ht φ) (ht_step φ v hv) + (crossing_total L (ht φ) (includeBasis_mem L φ v root hv 3 c))) + +include hv comm in +theorem triangleBoundary_cycle (c : φ.ker × Shape L 3 →₀ ℤ) : + triangleBoundary L φ v root hv c ∈ cycles (generator L φ v root hv) := by + apply includeVertices_injective φ + rw [map_zero,← levelBoundary_include L φ v root hv comm,triangleBoundary_inclusion L φ v root hv] + exact levelBoundary_cross_boundary L v (ht φ) (ht_step φ v hv) comm (includeBasis_mem L φ v root hv 3 c) + +variable (K : SimplicialChains.Contraction L) +variable (exactTotal : ∀ {k : ℕ}, 0 < k → ∀ c, c ∈ total (G := G) L k → boundary v c = 0 → + ∃ b ∈ total (G := G) L (k+1), boundary v b = c) +variable (dim : ∀ w, SimplicialChains.Valid L w → w.length ≤ 3) +include hv comm K exactTotal in +theorem triangleBoundary_range : LinearMap.range (triangleBoundary L φ v root hv) = + cycles (generator L φ v root hv) := by + apply le_antisymm + · rintro _ ⟨c,rfl⟩ + exact triangleBoundary_cycle L φ v root hv comm c + · intro c hc + have hz : levelBoundary v (ht φ) (includeBasis L φ v root 2 c) = 0 := by + rw [levelBoundary_include L φ v root hv comm,LinearMap.mem_ker.mp hc,map_zero] + obtain ⟨t,ht,hdt⟩ := level_cycle_bounds L v (ht φ) K (ht_step φ v hv) comm exactTotal + _ (includeBasis_mem L φ v root hv 2 c) hz + rw [← includeBasis_range L φ v root hv 3] at ht + obtain ⟨b,rfl⟩ := ht + refine ⟨b,includeBasis_injective L φ v root hv 2 ?_⟩ + rwa [triangleBoundary_inclusion L φ v root hv] + +include hv comm K exactTotal dim in +theorem triangleBoundary_injective : Function.Injective (triangleBoundary L φ v root hv) := by + suffices hz : ∀ c, triangleBoundary L φ v root hv c = 0 → c = 0 by + intro c d he + exact sub_eq_zero.mp (hz (c-d) (by simp only [map_sub,he,sub_self])) + intro c hc + apply includeBasis_injective L φ v root hv 3 + rw [map_zero] + apply level_boundary_injective L v (ht φ) K (ht_step φ v hv) comm exactTotal dim + _ (includeBasis_mem L φ v root hv 3 c) + rw [← triangleBoundary_inclusion L φ v root hv,hc,map_zero] + + +/-- Left translation on the actual ambient cube chains. -/ +def leftTranslate (g : G) : CubicalChains.Chains G A →ₗ[ℤ] CubicalChains.Chains G A := + Finsupp.lmapDomain ℤ ℤ (fun p => (g*p.1,p.2)) +omit [LinearOrder A] in +@[simp] theorem leftTranslate_single (g q : G) (w : List A) (n : ℤ) : + leftTranslate g (Finsupp.single (q,w) n) = Finsupp.single (g*q,w) n := by simp [leftTranslate] +omit [LinearOrder A] in +theorem leftTranslate_front (g : G) (a : A) (c : CubicalChains.Chains G A) : + leftTranslate g (CubicalChains.front a c) = CubicalChains.front a (leftTranslate g c) := by + induction c using Finsupp.induction_linear with + | zero => simp + | add c d hc hd => simp only [map_add,hc,hd] + | single p n => rcases p with ⟨q,w⟩; simp +omit [LinearOrder A] in +theorem leftTranslate_boundaryTerm (g q : G) (w : List A) : + leftTranslate g (boundaryTerm v q w) = boundaryTerm v (g*q) w := by + induction w with + | nil => simp + | cons a w ih => simp only [boundaryTerm_cons,map_sub,leftTranslate_single,leftTranslate_front,ih,mul_assoc] +omit [LinearOrder A] in +theorem leftTranslate_boundary (g : G) (c : CubicalChains.Chains G A) : + leftTranslate g (boundary v c) = boundary v (leftTranslate g c) := by + induction c using Finsupp.induction_linear with + | zero => simp + | add c d hc hd => simp only [map_add,hc,hd] + | single p n => rcases p with ⟨q,w⟩; simp [leftTranslate_boundaryTerm] +omit [LinearOrder A] in +theorem leftTranslate_crossPart (g : φ.ker) (c : CubicalChains.Chains G A) : + leftTranslate g.val (crossPart (ht φ) c) = crossPart (ht φ) (leftTranslate g.val c) := by + induction c using Finsupp.induction_linear with + | zero => simp + | add c d hc hd => simp only [map_add,hc,hd] + | single p n => + rcases p with ⟨q,w⟩ + simp only [crossPart,select_single,leftTranslate_single,ht_mul,ht_ker,zero_add] + split <;> simp_all + +theorem includeBasis_translate (k : ℕ) (g : φ.ker) (c : φ.ker × Shape L k →₀ ℤ) : + includeBasis L φ v root k (translateChains g c) = leftTranslate g.val (includeBasis L φ v root k c) := by + induction c using Finsupp.induction_linear with + | zero => simp + | add c d hc hd => simp only [map_add,hc,hd] + | single p n => + rcases p with ⟨q,s⟩ + simp only [translateChains_single,includeBasis_single,leftTranslate_single,basisIndex, + Subgroup.coe_mul,mul_assoc] + +include hv in +theorem triangleBoundary_equivariant : ChainsEquivariant (triangleBoundary L φ v root hv) := by + intro g c + apply includeBasis_injective L φ v root hv 2 + rw [triangleBoundary_inclusion L φ v root hv,includeBasis_translate, + ← leftTranslate_boundary,← leftTranslate_crossPart,includeBasis_translate, + triangleBoundary_inclusion L φ v root hv] + +end EilenbergGanea.LevelBasis + +namespace EilenbergGanea.LevelBasis +variable {V : Type} [LinearOrder V] (L : SimpleGraph V) + +def pairShape (a b : V) (hab : a < b) (hadj : L.Adj a b) : Shape L 2 := + ⟨([a,b],-1),by simp [SimplicialChains.Valid,hab,hadj]⟩ + +@[simp] theorem generator_pair (root a b : V) (hab : a < b) (hadj : L.Adj a b) : + (generator L (height L) (artinGenerator L) root (height_generator L) + (pairShape L a b hab hadj)).val = (artinGenerator L a)⁻¹ * artinGenerator L b := rfl + +/-- The actual oriented crossing-square edges generate precisely the height kernel. -/ +theorem generator_surjective (hconn : L.Preconnected) (root : V) : + Function.Surjective (FreeGroup.lift (generator L (height L) (artinGenerator L) root (height_generator L))) := by + let f := FreeGroup.lift (generator L (height L) (artinGenerator L) root (height_generator L)) + let F := (height L).ker.subtype.comp f + have hgen : edgeGenerated L ≤ F.range := by + apply (Subgroup.closure_le _).mpr + rintro x ⟨a,b,hadj,rfl⟩ + have hab : a ≠ b := L.ne_of_adj hadj + rcases lt_or_gt_of_ne hab with hab | hab + · refine ⟨(FreeGroup.of (pairShape L a b hab hadj))⁻¹,?_⟩ + change (f ((FreeGroup.of (pairShape L a b hab hadj))⁻¹)).val = _ + simp only [f,map_inv,FreeGroup.lift_apply_of,Subgroup.coe_inv,generator_pair,mul_inv_rev,inv_inv] + exact (adjacent_generators_commute L hadj).inv_right.eq.symm + · refine ⟨FreeGroup.of (pairShape L b a hab hadj.symm),?_⟩ + change (f (FreeGroup.of (pairShape L b a hab hadj.symm))).val = _ + simp only [f,FreeGroup.lift_apply_of,generator_pair] + exact (adjacent_generators_commute L hadj).inv_right.eq.symm + intro g + have he : g.val ∈ edgeGenerated L := by rw [edgeGenerated_eq_height_kernel L hconn root]; exact g.property + obtain ⟨w,hw⟩ := hgen he + exact ⟨w,Subtype.ext hw⟩ + +end EilenbergGanea.LevelBasis + +namespace EilenbergGanea.LevelBasis +open CubicalChains CubicalChains.HeightFiltration +variable {V : Type} [LinearOrder V] [Fintype V] [Nonempty V] (L : SimpleGraph V) + +/-- The exactness input to the level slicing is the actual RAAG cube-chain +contraction, not an assumption about a classifying space. -/ +theorem artin_total_cycle_bounds {k : ℕ} (hk : 0 < k) + (c : Chains (ArtinGroup L) V) (hc : c ∈ total (G := ArtinGroup L) L k) + (hz : boundary (artinGenerator L) c = 0) : + ∃ b ∈ total (G := ArtinGroup L) L (k+1), boundary (artinGenerator L) b = c := by + have he : ∀ n, total (G := ArtinGroup L) L n = TraceWords.CubeDescents.positiveChains L n := by + intro n + simp only [total,TraceWords.CubeDescents.positiveChains,SimplicialChains.Valid,and_assoc] + rw [he] at hc ⊢ + exact TraceWords.CubeDescents.positive_cycle_bounds L hk c hc hz + +/-- Integral cd at most two for the genuine height kernel, from a genuine +finite augmented link contraction and the dimension of its flag complex. -/ +theorem artin_height_kernel_cd_le_two (root : V) (hconn : L.Preconnected) + (K : SimplicialChains.Contraction L) + (dim : ∀ w, SimplicialChains.Valid L w → w.length ≤ 3) : + cohomologicalDimension (height L).ker ≤ 2 := by + exact projectiveDimension_le_two_of_boundary_basis + (generator L (height L) (artinGenerator L) root (height_generator L)) + (generator_surjective L hconn root) + (triangleBoundary L (height L) (artinGenerator L) root (height_generator L)) + (triangleBoundary_equivariant L (height L) (artinGenerator L) root (height_generator L)) + (triangleBoundary_injective L (height L) (artinGenerator L) root (height_generator L) + (fun _ _ h => adjacent_generators_commute L h) K (artin_total_cycle_bounds L) dim) + (triangleBoundary_range L (height L) (artinGenerator L) root (height_generator L) + (fun _ _ h => adjacent_generators_commute L h) K (artin_total_cycle_bounds L)) +end EilenbergGanea.LevelBasis +namespace EilenbergGanea.LevelBasis +open CubicalChains CubicalChains.LevelExact CubicalChains.HeightFiltration +variable {G A : Type} [Group G] [LinearOrder A] +variable (L : SimpleGraph A) (φ : G →* Multiplicative ℤ) (v : A → G) (root : A) +variable (hv : ∀ a, φ (v a) = Multiplicative.ofAdd (1 : ℤ)) +variable (comm : ∀ a b, L.Adj a b → Commute (v a) (v b)) + +instance shape_finite [Fintype A] (k : ℕ) : Finite (Shape L k) := by + let f : Shape L k → List.Vector A k × Fin k := fun s => + (⟨s.val.1,s.property.2.1⟩,⟨(-s.val.2).toNat,by + have hn := s.property.2.2.1 + have hm := s.property.2.2.2 + omega⟩) + apply Finite.of_injective f + intro s t h + apply Subtype.ext + apply Prod.ext + · exact congrArg (fun p : List.Vector A k × Fin k => p.1.val) h + · have he := congrArg (fun p : List.Vector A k × Fin k => p.2.val) h + have hs := s.property.2.2.1 + have ht := t.property.2.2.1 + dsimp [f] at he + omega + +noncomputable instance shape_fintype [Fintype A] (k : ℕ) : Fintype (Shape L k) := Fintype.ofFinite _ + +def edgeShape (a b : A) (hab : SimplicialChains.Valid L [a,b]) : Shape L 2 := + ⟨([a,b],-1),hab,rfl,by norm_num,by norm_num⟩ + +def triangleShape (a b c : A) (habc : SimplicialChains.Valid L [a,b,c]) + (n : ℤ) (hn : n = -1 ∨ n = -2) : Shape L 3 := + ⟨([a,b,c],n),habc,rfl,by omega,by norm_num; omega⟩ + +@[simp] theorem generator_edgeShape (a b : A) (hab : SimplicialChains.Valid L [a,b]) : + (generator L φ v root hv (edgeShape L a b hab) : G) = (v a)⁻¹ * v b := rfl + +theorem valid_triangle_edges {a b c : A} (h : SimplicialChains.Valid L [a,b,c]) : + SimplicialChains.Valid L [a,b] ∧ SimplicialChains.Valid L [a,c] ∧ + SimplicialChains.Valid L [b,c] := by + simp [SimplicialChains.Valid] at h ⊢ + tauto + +include comm in +theorem edge_values_compose (a b c : A) (h : SimplicialChains.Valid L [a,b,c]) : + ((v a)⁻¹ * v b) * ((v b)⁻¹ * v c) = (v a)⁻¹ * v c ∧ + ((v b)⁻¹ * v c) * ((v a)⁻¹ * v b) = (v a)⁻¹ * v c := by + have he := valid_triangle_edges L h + have ha : L.Adj a b := by simpa [SimplicialChains.Valid] using he.1.2 + have hb : L.Adj a c := by simpa [SimplicialChains.Valid] using he.2.1.2 + have hc : L.Adj b c := by simpa [SimplicialChains.Valid] using he.2.2.2 + constructor + · group + · calc + ((v b)⁻¹ * v c) * ((v a)⁻¹ * v b) = (v a)⁻¹ * ((v b)⁻¹ * v c) * v b := by + rw [← mul_assoc, + ((comm a b ha).inv_left.inv_right.mul_right (comm a c hb).inv_left).symm.eq] + _ = (v a)⁻¹ * v c := by + rw [mul_assoc,mul_assoc,← (comm b c hc).eq,inv_mul_cancel_left] + +def lowerTriangleWord (ab ac bc : Shape L 2) : FreeGroup (Shape L 2) := + FreeGroup.of ac * (FreeGroup.of bc)⁻¹ * (FreeGroup.of ab)⁻¹ + +def upperTriangleWord (ab ac bc : Shape L 2) : FreeGroup (Shape L 2) := + FreeGroup.of ab * (FreeGroup.of bc * FreeGroup.of ab * (FreeGroup.of ac)⁻¹) * + (FreeGroup.of ab)⁻¹ + +include comm in +theorem triangle_words_trivial (a b c : A) (h : SimplicialChains.Valid L [a,b,c]) : + let e := valid_triangle_edges L h + let ab := edgeShape L a b e.1 + let ac := edgeShape L a c e.2.1 + let bc := edgeShape L b c e.2.2 + wordValue (generator L φ v root hv) (lowerTriangleWord L ab ac bc) = 1 ∧ + wordValue (generator L φ v root hv) (upperTriangleWord L ab ac bc) = 1 := by + dsimp only + have he := edge_values_compose L v comm a b c h + constructor <;> apply Subtype.ext + · simp only [lowerTriangleWord,map_mul,map_inv,wordValue,FreeGroup.lift_apply_of, + Subgroup.coe_mul,Subgroup.coe_inv,generator_edgeShape,OneMemClass.coe_one] + group + · simp only [upperTriangleWord,map_mul,map_inv,wordValue,FreeGroup.lift_apply_of, + Subgroup.coe_mul,Subgroup.coe_inv,generator_edgeShape,OneMemClass.coe_one] + rw [he.2,mul_inv_cancel,mul_one,mul_inv_cancel] + +include hv in +theorem triangle_boundary_low (g : φ.ker) (a b c : A) + (h : SimplicialChains.Valid L [a,b,c]) : + let e := valid_triangle_edges L h + let ab := edgeShape L a b e.1 + let ac := edgeShape L a c e.2.1 + let bc := edgeShape L b c e.2.2 + triangleBoundary L φ v root hv + (Finsupp.single (g,triangleShape L a b c h (-1) (Or.inl rfl)) 1) = + Finsupp.single (g,ac) 1 - Finsupp.single (g,ab) 1 - + Finsupp.single (g * generator L φ v root hv ab,bc) 1 := by + dsimp only + apply includeBasis_injective L φ v root hv 2 + rw [triangleBoundary_inclusion L φ v root hv] + simp only [map_sub,includeBasis_single,basisIndex,triangleShape,edgeShape, + List.headD_cons,zpow_neg_one,Subgroup.coe_mul,generator,List.tail_cons] + simp only [boundary_single,one_smul,boundaryTerm_cons,boundaryTerm_nil,map_zero, + sub_zero,map_sub,front_single,crossPart,select,Finsupp.linearCombination_single, + ht_mul,ht_ker,ht_inv,ht_generator φ v hv,List.length_cons,List.length_nil] + norm_num + simp only [mul_assoc,mul_inv_cancel,mul_one] + abel + +include hv comm in +theorem triangle_boundary_high (g : φ.ker) (a b c : A) + (h : SimplicialChains.Valid L [a,b,c]) : + let e := valid_triangle_edges L h + let ab := edgeShape L a b e.1 + let ac := edgeShape L a c e.2.1 + let bc := edgeShape L b c e.2.2 + triangleBoundary L φ v root hv + (Finsupp.single (g,triangleShape L a b c h (-2) (Or.inr rfl)) 1) = + Finsupp.single (g * generator L φ v root hv ab,bc) 1 - + Finsupp.single (g * generator L φ v root hv ab,ac) 1 + + Finsupp.single (g * generator L φ v root hv ac,ab) 1 := by + dsimp only + have eh := valid_triangle_edges L h + have hab : L.Adj a b := by simpa [SimplicialChains.Valid] using eh.1.2 + have hac : L.Adj a c := by simpa [SimplicialChains.Valid] using eh.2.1.2 + apply includeBasis_injective L φ v root hv 2 + rw [triangleBoundary_inclusion L φ v root hv] + simp only [map_sub,map_add,includeBasis_single,basisIndex,triangleShape,edgeShape, + List.headD_cons,Subgroup.coe_mul,generator,List.tail_cons] + simp only [boundary_single,one_smul,boundaryTerm_cons,boundaryTerm_nil,map_zero, + sub_zero,map_sub,front_single,crossPart,select,map_sub,Finsupp.linearCombination_single, + ht_mul,ht_ker,ht_zpow,ht_generator φ v hv,List.length_cons,List.length_nil] + norm_num + have hb : (v a)^(-2 : ℤ) * v b = (v a)⁻¹ * v b * (v a)⁻¹ := by + calc + (v a)^(-2 : ℤ) * v b = (v a)⁻¹ * ((v a)⁻¹ * v b) := by group + _ = (v a)⁻¹ * (v b * (v a)⁻¹) := congrArg ((v a)⁻¹ * ·) (comm a b hab).inv_left.eq + _ = _ := (mul_assoc _ _ _).symm + have hc : (v a)^(-2 : ℤ) * v c = (v a)⁻¹ * v c * (v a)⁻¹ := by + calc + (v a)^(-2 : ℤ) * v c = (v a)⁻¹ * ((v a)⁻¹ * v c) := by group + _ = (v a)⁻¹ * (v c * (v a)⁻¹) := congrArg ((v a)⁻¹ * ·) (comm a c hac).inv_left.eq + _ = _ := (mul_assoc _ _ _).symm + have ha : (v a)^(-2 : ℤ) * v a = (v a)⁻¹ := by group + simp only [zpow_neg,zpow_ofNat] at ha hb hc + simp only [mul_assoc] at hb hc + simp only [mul_assoc,ha,hb,hc,mul_inv_cancel,mul_one] + abel + +section WordChains +variable (w : Shape L 2 → G) (ab ac bc : Shape L 2) +theorem lowerTriangleWord_chain (habc : w ab * w bc = w ac) (g : G) : + pathChain w (lowerTriangleWord L ab ac bc) g = + Finsupp.single (g,ac) 1 - Finsupp.single (g,ab) 1 - + Finsupp.single (g * w ab,bc) 1 := by + simp only [lowerTriangleWord,pathChain_mul,pathChain_inv,pathChain_of, + map_mul,map_inv,wordValue,FreeGroup.lift_apply_of] + rw [← habc] + simp only [mul_assoc,mul_inv_cancel,mul_one] + abel + +theorem upperTriangleWord_chain (habc : w ab * w bc = w ac) + (hbac : w bc * w ab = w ac) (g : G) : + pathChain w (upperTriangleWord L ab ac bc) g = + Finsupp.single (g * w ab,bc) 1 - Finsupp.single (g * w ab,ac) 1 + + Finsupp.single (g * w ac,ab) 1 := by + have hr : wordValue w (FreeGroup.of bc * FreeGroup.of ab * (FreeGroup.of ac)⁻¹) = 1 := by + simp only [wordValue,map_mul,map_inv,FreeGroup.lift_apply_of,hbac,mul_inv_cancel] + rw [upperTriangleWord,pathChain_conjugate w _ _ hr] + simp only [pathChain_mul,pathChain_inv,pathChain_of,map_mul,wordValue, + FreeGroup.lift_apply_of] + rw [hbac] + simp only [mul_assoc,habc,mul_inv_cancel,mul_one] + abel +end WordChains + +include comm in +theorem triangle_words_chain (g : φ.ker) (a b c : A) (h : SimplicialChains.Valid L [a,b,c]) : + let e := valid_triangle_edges L h + let ab := edgeShape L a b e.1 + let ac := edgeShape L a c e.2.1 + let bc := edgeShape L b c e.2.2 + pathChain (generator L φ v root hv) (lowerTriangleWord L ab ac bc) g = + triangleBoundary L φ v root hv + (Finsupp.single (g,triangleShape L a b c h (-1) (Or.inl rfl)) 1) ∧ + pathChain (generator L φ v root hv) (upperTriangleWord L ab ac bc) g = + triangleBoundary L φ v root hv + (Finsupp.single (g,triangleShape L a b c h (-2) (Or.inr rfl)) 1) := by + dsimp only + have he := edge_values_compose L v comm a b c h + have h₁ : generator L φ v root hv (edgeShape L a b (valid_triangle_edges L h).1) * + generator L φ v root hv (edgeShape L b c (valid_triangle_edges L h).2.2) = + generator L φ v root hv (edgeShape L a c (valid_triangle_edges L h).2.1) := + Subtype.ext he.1 + have h₂ : generator L φ v root hv (edgeShape L b c (valid_triangle_edges L h).2.2) * + generator L φ v root hv (edgeShape L a b (valid_triangle_edges L h).1) = + generator L φ v root hv (edgeShape L a c (valid_triangle_edges L h).2.1) := + Subtype.ext he.2 + constructor + · rw [lowerTriangleWord_chain L _ _ _ _ h₁,triangle_boundary_low L φ v root hv] + · rw [upperTriangleWord_chain L _ _ _ _ h₁ h₂, + triangle_boundary_high L φ v root hv comm] + +def triangleWordList : (w : List A) → SimplicialChains.Valid L w → ℤ → FreeGroup (Shape L 2) + | [a,b,c],h,n => + let e := valid_triangle_edges L h + if n = -1 then + lowerTriangleWord L (edgeShape L a b e.1) (edgeShape L a c e.2.1) (edgeShape L b c e.2.2) + else upperTriangleWord L (edgeShape L a b e.1) (edgeShape L a c e.2.1) (edgeShape L b c e.2.2) + | _,_,_ => 1 + +def triangleWord (s : Shape L 3) : FreeGroup (Shape L 2) := + triangleWordList L s.val.1 s.property.1 s.val.2 + +theorem shape_three_form (s : Shape L 3) : + ∃ (a b c : A) (h : SimplicialChains.Valid L [a,b,c]) (n : ℤ) (hn : n = -1 ∨ n = -2), + s = triangleShape L a b c h n hn := by + obtain ⟨a,b,c,hw⟩ := List.length_eq_three.mp s.property.2.1 + have hn : s.val.2 = -1 ∨ s.val.2 = -2 := by + have h₁ := s.property.2.2.1 + have h₂ := s.property.2.2.2 + norm_num at h₂ + omega + refine ⟨a,b,c,hw ▸ s.property.1,s.val.2,hn,?_⟩ + exact Subtype.ext (Prod.ext hw rfl) + +include comm in +theorem triangleWord_trivial (s : Shape L 3) : + wordValue (generator L φ v root hv) (triangleWord L s) = 1 := by + obtain ⟨a,b,c,h,n,hn,rfl⟩ := shape_three_form L s + rcases hn with rfl | rfl + · simpa [triangleWord,triangleWordList,triangleShape] using + (triangle_words_trivial L φ v root hv comm a b c h).1 + · simpa [triangleWord,triangleWordList,triangleShape] using + (triangle_words_trivial L φ v root hv comm a b c h).2 + +include comm in +theorem triangleWord_chain (s : Shape L 3) (g : φ.ker) : + pathChain (generator L φ v root hv) (triangleWord L s) g = + triangleBoundary L φ v root hv (Finsupp.single (g,s) 1) := by + obtain ⟨a,b,c,h,n,hn,rfl⟩ := shape_three_form L s + rcases hn with rfl | rfl + · simpa [triangleWord,triangleWordList,triangleShape] using + (triangle_words_chain L φ v root hv comm g a b c h).1 + · simpa [triangleWord,triangleWordList,triangleShape] using + (triangle_words_chain L φ v root hv comm g a b c h).2 + +end EilenbergGanea.LevelBasis +namespace EilenbergGanea.LevelBasis +open CubicalChains CubicalChains.HeightFiltration +variable {G A : Type} [Group G] [LinearOrder A] +variable (L : SimpleGraph A) (φ : G →* Multiplicative ℤ) (v : A → G) (root : A) +variable (hv : ∀ a, φ (v a) = Multiplicative.ofAdd (1 : ℤ)) +variable (comm : ∀ a b, L.Adj a b → Commute (v a) (v b)) + +include comm in +theorem triangleBoundary_eq_relatorChainMap : + triangleBoundary L φ v root hv = + relatorChainMap (generator L φ v root hv) (triangleWord L) := by + apply Finsupp.lhom_ext' + intro p + apply LinearMap.ext + intro n + simp only [LinearMap.coe_comp,Function.comp_apply,Finsupp.lsingle_apply, + relatorChainMap,Finsupp.linearCombination_single] + have he : Finsupp.single p n = n • Finsupp.single p (1 : ℤ) := by simp + rw [he,map_smul,← triangleWord_chain L φ v root hv comm p.2 p.1] + +variable (K : SimplicialChains.Contraction L) +variable (exactTotal : ∀ {k : ℕ}, 0 < k → ∀ c, c ∈ total (G := G) L k → boundary v c = 0 → + ∃ b ∈ total (G := G) L (k+1), boundary v b = c) +variable (dim : ∀ w, SimplicialChains.Valid L w → w.length ≤ 3) + +noncomputable def triangleBasis : (φ.ker × Shape L 3 →₀ ℤ) ≃ₗ[ℤ] + cycles (generator L φ v root hv) := + LinearEquiv.ofBijective + ((triangleBoundary L φ v root hv).codRestrict (cycles (generator L φ v root hv)) + (triangleBoundary_cycle L φ v root hv comm)) + ⟨fun c d h => triangleBoundary_injective L φ v root hv comm K exactTotal dim + (congrArg Subtype.val h),fun c => by + have hc : c.val ∈ LinearMap.range (triangleBoundary L φ v root hv) := by + rw [triangleBoundary_range L φ v root hv comm K exactTotal] + exact c.property + obtain ⟨b,hb⟩ := hc + exact ⟨b,Subtype.ext hb⟩⟩ + +theorem triangleBasis_value (c : φ.ker × Shape L 3 →₀ ℤ) : + (triangleBasis L φ v root hv comm K exactTotal dim c : φ.ker × Shape L 2 →₀ ℤ) = + relatorChainMap (generator L φ v root hv) (triangleWord L) c := by + change triangleBoundary L φ v root hv c = _ + rw [triangleBoundary_eq_relatorChainMap L φ v root hv comm] + +end EilenbergGanea.LevelBasis +namespace EilenbergGanea.LevelBasis +open LevelTransport +variable {V : Type} [LinearOrder V] (L : SimpleGraph V) (root : V) (N : ℕ) + +noncomputable def levelEquiv : (height L).ker ≃ NegativeLevel L N where + toFun := fun g => ⟨(artinGenerator L root)⁻¹ ^ N * g.val,by + simp only [map_mul,map_pow,map_inv,height_generator] + rw [show height L g.val = 1 from g.property,mul_one] + change N • (-1 : ℤ) = -(N : ℤ) + simp⟩ + invFun := fun g => ⟨artinGenerator L root ^ N * g.val,by + change (height L (artinGenerator L root ^ N * g.val)).toAdd = 0 + simp only [map_mul,map_pow,height_generator] + change N • (1 : ℤ) + (height L g.val).toAdd = 0 + rw [g.property] + simp⟩ + left_inv := fun g => Subtype.ext (by dsimp; group) + right_inv := fun g => Subtype.ext (by dsimp; group) + +def basedLabel (a : NegativeLevel L N → V → V → SU2) + (g : (height L).ker) (s : Shape L 2) : SU2 := + a (levelEquiv L root N g) (s.val.1.tail.headD root) (s.val.1.headD root) + +@[simp] theorem basedLabel_edge (a : NegativeLevel L N → V → V → SU2) + (g : (height L).ker) (q r : V) (h : SimplicialChains.Valid L [q,r]) : + basedLabel L root N a g (edgeShape L q r h) = a (levelEquiv L root N g) r q := rfl + +theorem levelEquiv_edge (g : (height L).ker) (q r : V) + (h : SimplicialChains.Valid L [q,r]) : + levelEquiv L root N + (g * generator L (height L) (artinGenerator L) root (height_generator L) (edgeShape L q r h)) = + edgeVertex L N (levelEquiv L root N g) r q := by + have ha : L.Adj q r := by simpa [SimplicialChains.Valid] using h.2 + apply Subtype.ext + simp only [levelEquiv,Equiv.coe_fn_mk,Subgroup.coe_mul,generator_edgeShape,edgeVertex] + rw [mul_assoc, (adjacent_generators_commute L ha).inv_left.eq] + group + +theorem shape_two_presentation (s : Shape L 2) : + ∃ (q r : V) (h : SimplicialChains.Valid L [q,r]), s = edgeShape L q r h := by + obtain ⟨q,r,hw⟩ := List.length_eq_two.mp s.property.2.1 + have hn : s.val.2 = -1 := by + have h₁ := s.property.2.2.1 + have h₂ := s.property.2.2.2 + norm_num at h₂ + omega + refine ⟨q,r,hw ▸ s.property.1,?_⟩ + exact Subtype.ext (Prod.ext hw hn) + +theorem levelEquiv_edge_inv (g : (height L).ker) (q r : V) + (h : SimplicialChains.Valid L [q,r]) : + levelEquiv L root N + (g * (generator L (height L) (artinGenerator L) root (height_generator L) (edgeShape L q r h))⁻¹) = + edgeVertex L N (levelEquiv L root N g) q r := by + have he := levelEquiv_edge L root N + (g * (generator L (height L) (artinGenerator L) root (height_generator L) (edgeShape L q r h))⁻¹) + q r h + simp only [inv_mul_cancel_right] at he + simpa only [edgeVertex_reverse] using congrArg (fun x => edgeVertex L N x q r) he.symm + +variable (a : NegativeLevel L N → V → V → SU2) +variable (rev : ∀ g q r, a (edgeVertex L N g q r) r q = (a g q r)⁻¹) +include rev in +theorem basedLabel_inv_edge (g : (height L).ker) (q r : V) + (h : SimplicialChains.Valid L [q,r]) : + (basedLabel L root N a + (g * (generator L (height L) (artinGenerator L) root (height_generator L) (edgeShape L q r h))⁻¹) + (edgeShape L q r h))⁻¹ = a (levelEquiv L root N g) q r := by + rw [basedLabel_edge,levelEquiv_edge_inv,rev,inv_inv] + +def orientedWord (q r : V) (h : L.Adj q r) : FreeGroup (Shape L 2) := + if hlt : q < r then + (FreeGroup.of (edgeShape L q r (by simpa [SimplicialChains.Valid] using And.intro hlt h)))⁻¹ + else + FreeGroup.of (edgeShape L r q (by + have hlt' : r < q := lt_of_le_of_ne (le_of_not_gt hlt) (Ne.symm (L.ne_of_adj h)) + simpa [SimplicialChains.Valid] using And.intro hlt' h.symm)) + +theorem orientedWord_value (q r : V) (h : L.Adj q r) : + (wordValue (generator L (height L) (artinGenerator L) root (height_generator L)) + (orientedWord L q r h) : ArtinGroup L) = + artinGenerator L q * (artinGenerator L r)⁻¹ := by + unfold orientedWord + split_ifs + · simp only [map_inv,wordValue,FreeGroup.lift_apply_of,Subgroup.coe_inv,generator_edgeShape, + mul_inv_rev,inv_inv] + exact (adjacent_generators_commute L h).inv_right.symm.eq + · simp only [wordValue,FreeGroup.lift_apply_of,generator_edgeShape] + exact (adjacent_generators_commute L h).inv_right.symm.eq + +theorem levelEquiv_orientedWord (g : (height L).ker) (q r : V) (h : L.Adj q r) : + levelEquiv L root N + (g * wordValue (generator L (height L) (artinGenerator L) root (height_generator L)) + (orientedWord L q r h)) = edgeVertex L N (levelEquiv L root N g) q r := by + apply Subtype.ext + simp only [levelEquiv,Equiv.coe_fn_mk,Subgroup.coe_mul,orientedWord_value,edgeVertex,mul_assoc] + +include rev in +theorem orientedWord_product (g : (height L).ker) (q r : V) (h : L.Adj q r) : + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) (orientedWord L q r h) g = a (levelEquiv L root N g) q r := by + unfold orientedWord + split_ifs + · simp only [pathProduct_inv,pathProduct_of,wordValue,FreeGroup.lift_apply_of] + exact basedLabel_inv_edge L root N a rev g q r _ + · exact pathProduct_of _ _ _ _ + + +include rev in +theorem inverse_edgeWord_product (g : (height L).ker) (q r : V) + (h : SimplicialChains.Valid L [q,r]) : + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) (FreeGroup.of (edgeShape L q r h))⁻¹ g = + a (levelEquiv L root N g) q r := by + simp only [pathProduct_inv,pathProduct_of,wordValue,FreeGroup.lift_apply_of] + exact basedLabel_inv_edge L root N a rev g q r h + +variable (tri : ∀ g₀ g₁ g₂ q₀ r₀ q₁ r₁ q₂ r₂, + edgeVertex L N g₀ q₀ r₀ = g₁ → edgeVertex L N g₁ q₁ r₁ = g₂ → + edgeVertex L N g₂ q₂ r₂ = g₀ → a g₀ q₀ r₀ * a g₁ q₁ r₁ * a g₂ q₂ r₂ = 1) + +include rev tri in +theorem lowerTriangleWord_product (g : (height L).ker) (q r s : V) + (h : SimplicialChains.Valid L [q,r,s]) : + let e := valid_triangle_edges L h + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) + (lowerTriangleWord L (edgeShape L q r e.1) (edgeShape L q s e.2.1) + (edgeShape L r s e.2.2)) g = 1 := by + let gen := generator L (height L) (artinGenerator L) root (height_generator L) + let e := valid_triangle_edges L h + let ab := edgeShape L q r e.1 + let ac := edgeShape L q s e.2.1 + let bc := edgeShape L r s e.2.2 + have he : gen ab * gen bc = gen ac := + Subtype.ext (edge_values_compose L (artinGenerator L) + (fun _ _ hh => adjacent_generators_commute L hh) q r s h).1 + have hc : gen ac * (gen bc)⁻¹ = gen ab := by rw [← he]; group + have hc' : g * gen ac * (gen bc)⁻¹ = g * gen ab := by rw [mul_assoc,hc] + have ha : g * gen ab * (gen ab)⁻¹ = g := by group + have T := tri (levelEquiv L root N g) (levelEquiv L root N (g * gen ac)) + (levelEquiv L root N (g * gen ab)) s q r s q r + (levelEquiv_edge L root N g q s e.2.1).symm + (by rw [← levelEquiv_edge_inv L root N (g * gen ac) r s e.2.2]; exact congrArg _ hc') + (by rw [← levelEquiv_edge_inv L root N (g * gen ab) q r e.1]; exact congrArg _ ha) + change pathProduct gen (basedLabel L root N a) (lowerTriangleWord L ab ac bc) g = 1 + simp only [lowerTriangleWord,pathProduct_mul,pathProduct_of,map_mul,map_inv, + wordValue,FreeGroup.lift_apply_of] + rw [hc] + rw [inverse_edgeWord_product L root N a rev _ r s e.2.2, + inverse_edgeWord_product L root N a rev _ q r e.1] + exact T + +include rev tri in +theorem upperInnerWord_product (g : (height L).ker) (q r s : V) + (h : SimplicialChains.Valid L [q,r,s]) : + let e := valid_triangle_edges L h + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) + (FreeGroup.of (edgeShape L r s e.2.2) * FreeGroup.of (edgeShape L q r e.1) * + (FreeGroup.of (edgeShape L q s e.2.1))⁻¹) g = 1 := by + let gen := generator L (height L) (artinGenerator L) root (height_generator L) + let e := valid_triangle_edges L h + let ab := edgeShape L q r e.1 + let ac := edgeShape L q s e.2.1 + let bc := edgeShape L r s e.2.2 + have he : gen bc * gen ab = gen ac := + Subtype.ext (edge_values_compose L (artinGenerator L) + (fun _ _ hh => adjacent_generators_commute L hh) q r s h).2 + have hc : g * gen bc * gen ab = g * gen ac := by rw [mul_assoc,he] + have ha : g * gen ac * (gen ac)⁻¹ = g := by group + have T := tri (levelEquiv L root N g) (levelEquiv L root N (g * gen bc)) + (levelEquiv L root N (g * gen ac)) s r r q q s + (levelEquiv_edge L root N g r s e.2.2).symm + (by rw [← levelEquiv_edge L root N (g * gen bc) q r e.1]; exact congrArg _ hc) + (by rw [← levelEquiv_edge_inv L root N (g * gen ac) q s e.2.1]; exact congrArg _ ha) + change pathProduct gen (basedLabel L root N a) + (FreeGroup.of bc * FreeGroup.of ab * (FreeGroup.of ac)⁻¹) g = 1 + simp only [pathProduct_mul,pathProduct_of,map_mul,wordValue,FreeGroup.lift_apply_of] + rw [he,inverse_edgeWord_product L root N a rev _ q s e.2.1] + exact T + +include rev tri in +theorem upperTriangleWord_product (g : (height L).ker) (q r s : V) + (h : SimplicialChains.Valid L [q,r,s]) : + let e := valid_triangle_edges L h + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) + (upperTriangleWord L (edgeShape L q r e.1) (edgeShape L q s e.2.1) + (edgeShape L r s e.2.2)) g = 1 := by + let gen := generator L (height L) (artinGenerator L) root (height_generator L) + let e := valid_triangle_edges L h + let ab := edgeShape L q r e.1 + let ac := edgeShape L q s e.2.1 + let bc := edgeShape L r s e.2.2 + have he : gen bc * gen ab = gen ac := + Subtype.ext (edge_values_compose L (artinGenerator L) + (fun _ _ hh => adjacent_generators_commute L hh) q r s h).2 + have hr : wordValue gen (FreeGroup.of bc * FreeGroup.of ab * (FreeGroup.of ac)⁻¹) = 1 := by + simp only [map_mul,map_inv,wordValue,FreeGroup.lift_apply_of,he,mul_inv_cancel] + change pathProduct gen (basedLabel L root N a) (upperTriangleWord L ab ac bc) g = 1 + rw [upperTriangleWord,pathProduct_conjugate_loop gen _ _ _ hr] + rw [upperInnerWord_product L root N a rev tri _ q r s h] + group + +include rev tri in +theorem triangleWord_product (s : Shape L 3) (g : (height L).ker) : + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) (triangleWord L s) g = 1 := by + obtain ⟨q,r,t,h,n,hn,rfl⟩ := shape_three_form L s + rcases hn with rfl | rfl + · simpa [triangleWord,triangleWordList,triangleShape] using + lowerTriangleWord_product L root N a rev tri g q r t h + · simpa [triangleWord,triangleWordList,triangleShape] using + upperTriangleWord_product L root N a rev tri g q r t h + + +variable {L N} +def walkWord {g k : NegativeLevel L N} : Walk L N g k → FreeGroup (Shape L 2) + | .nil _ => 1 + | .cons q r h p => orientedWord L q r h * walkWord p + + theorem walkWord_endpoint {g k : NegativeLevel L N} (p : Walk L N g k) + (x : (height L).ker) (hx : levelEquiv L root N x = g) : + levelEquiv L root N + (x * wordValue (generator L (height L) (artinGenerator L) root (height_generator L)) + (walkWord p)) = k := by + induction p generalizing x with + | nil g => simpa [walkWord] using hx + | @cons g k q r h p ih => + simp only [walkWord,map_mul,← mul_assoc] + exact ih _ ((levelEquiv_orientedWord L root N x q r h).trans + (congrArg (fun t => edgeVertex L N t q r) hx)) + +include rev in + theorem walkWord_product {g k : NegativeLevel L N} (p : Walk L N g k) + (x : (height L).ker) (hx : levelEquiv L root N x = g) : + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) (walkWord p) x = p.eval a := by + induction p generalizing x with + | nil g => simp [walkWord,Walk.eval] + | @cons g k q r h p ih => + rw [walkWord,pathProduct_mul,orientedWord_product L root N a rev x q r h] + rw [ih _ ((levelEquiv_orientedWord L root N x q r h).trans + (congrArg (fun t => edgeVertex L N t q r) hx)),hx] + rfl + +include rev in + theorem nontrivial_word_of_walk {g : NegativeLevel L N} (p : Walk L N g g) + (hp : p.eval a ≠ 1) : + ∃ (w : FreeGroup (Shape L 2)) (x : (height L).ker), + wordValue (generator L (height L) (artinGenerator L) root (height_generator L)) w = 1 ∧ + pathProduct (generator L (height L) (artinGenerator L) root (height_generator L)) + (basedLabel L root N a) w x ≠ 1 := by + let x := (levelEquiv L root N).symm g + have hx : levelEquiv L root N x = g := (levelEquiv L root N).apply_symm_apply g + refine ⟨walkWord p,x,?_,?_⟩ + · have he := walkWord_endpoint root p x hx + have he' := (levelEquiv L root N).injective (he.trans hx.symm) + exact mul_left_cancel (he'.trans (mul_one x).symm) + · rwa [walkWord_product root a rev p x hx] + +end EilenbergGanea.LevelBasis + +namespace EilenbergGanea.LevelBasis +open LevelTransport +variable {V : Type} [LinearOrder V] [Fintype V] [Nonempty V] (L : SimpleGraph V) +variable [Group.ResiduallyFinite (height L).ker] +variable (root : V) (hconn : L.Preconnected) +variable (K : SimplicialChains.Contraction L) +variable (dim : ∀ w, SimplicialChains.Valid L w → w.length ≤ 3) + +include root hconn K dim in +/-- The source obstruction's algebraic endpoint, with no cardinal bound on +an alleged presentation. Its geometric premise must still be derived from an +ordinary two-dimensional classifying CW space. -/ +theorem no_boundary_basis_presentation + (small : ∀ ε : ℝ, 0 < ε → + ∃ N : ℕ, 1 < N ∧ ∃ a : NegativeLevel L N → V → V → SU2, + (∀ g q r, a (edgeVertex L N g q r) r q = (a g q r)⁻¹) ∧ + (∀ g q r, dist (a g q r) 1 < ε) ∧ + (∀ g₀ g₁ g₂ q₀ r₀ q₁ r₁ q₂ r₂, + edgeVertex L N g₀ q₀ r₀ = g₁ → + edgeVertex L N g₁ q₁ r₁ = g₂ → + edgeVertex L N g₂ q₂ r₂ = g₀ → + a g₀ q₀ r₀ * a g₁ q₁ r₁ * a g₂ q₂ r₂ = 1) ∧ + ∃ (g : NegativeLevel L N) (p : Walk L N g g), p.eval a ≠ 1) + {A R : Type*} (a₀ : A → (height L).ker) + (ha₀ : Function.Surjective (wordValue a₀)) + (r₀ : R → FreeGroup A) (hr₀ : ∀ i, wordValue a₀ (r₀ i) = 1) + (hp₀ : (wordValue a₀).ker = Subgroup.normalClosure (Set.range r₀)) + (E : BasedChains (height L).ker R ≃ₗ[ℤ] cycles a₀) + (hE : ∀ c, (E c : BasedChains (height L).ker A) = relatorChainMap a₀ r₀ c) : False := by + let gen := generator L (height L) (artinGenerator L) root (height_generator L) + let comm := fun q r h => @adjacent_generators_commute V L q r h + let B := triangleBasis L (height L) (artinGenerator L) root (height_generator L) + comm K (artin_total_cycle_bounds L) dim + obtain ⟨η,hη,hηa⟩ := boundary_basis_small_transport gen + (generator_surjective L hconn root) (triangleWord L) + (triangleWord_trivial L (height L) (artinGenerator L) root (height_generator L) comm) + B (triangleBasis_value L (height L) (artinGenerator L) root (height_generator L) + comm K (artin_total_cycle_bounds L) dim) a₀ ha₀ r₀ hr₀ hp₀ E hE + obtain ⟨N,_,a,ha,hb,ht,g,p,hp⟩ := small η hη + obtain ⟨w,x,hw,hx⟩ := nontrivial_word_of_walk root a ha p hp + apply hx + exact hηa (basedLabel L root N a) + (fun x s => by + simpa only [basedLabel,Subtype.dist_eq,dist_eq_norm,OneMemClass.coe_one] using + hb (levelEquiv L root N x) (s.val.1.tail.headD root) (s.val.1.headD root)) + (triangleWord_product L root N a ha ht) w hw x + +end EilenbergGanea.LevelBasis + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/LevelTransport.lean b/lean/OAI/Topology/EilenbergGanea/LevelTransport.lean new file mode 100644 index 0000000000000000000000000000000000000000..6aef94404be17a91288e78f9f9f6d8a6f6caf4fb --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/LevelTransport.lean @@ -0,0 +1,626 @@ +import OAI.Topology.EilenbergGanea.AffineTransport +import OAI.Topology.EilenbergGanea.SeedConnection + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea +namespace LevelTransport +open TraceWords AffineTransport + +variable {V : Type*} [Fintype V] [LinearOrder V] (L : SimpleGraph V) +variable (hdim : ∀ s : Finset V, (s : Set V).Pairwise L.Adj → s.card ≤ 3) + +def point (g : ArtinGroup L) (hg : 0 < traceLength L (artinNormalTrace L g)) : TrianglePoint V := + ⟨artinDirection L g,by + apply mem_triangleSet.mpr + refine ⟨(traceCounts L (artinNormalTrace L g)).support, + hdim _ (traceCounts_support_clique L _),⟨?_,?_⟩,?_⟩ + · exact traceDirection_nonneg L _ + · exact traceDirection_sum L hg + · intro v hv + simp only [Finsupp.notMem_support_iff] at hv + simp [artinDirection,traceDirection,hv]⟩ + +@[simp] theorem point_val (g : ArtinGroup L) (hg : 0 < traceLength L (artinNormalTrace L g)) : + (point L hdim g hg : V → ℝ) = artinDirection L g := rfl + +theorem point_mem_support (g : ArtinGroup L) (hg : 0 < traceLength L (artinNormalTrace L g)) + {v : V} (hv : (point L hdim g hg : V → ℝ) v ≠ 0) : + v ∈ (traceCounts L (artinNormalTrace L g)).support := by + by_contra h + have he := Finsupp.notMem_support_iff.mp h + exact hv (by simp [point,artinDirection,traceDirection,he]) + +theorem point_clique (g : ArtinGroup L) (hg : 0 < traceLength L (artinNormalTrace L g)) : + CliquePoint L (point L hdim g hg) := by + intro a ha v hv + by_cases hav : a = v + · exact Or.inl hav + · exact Or.inr (traceCounts_support_clique L _ + (point_mem_support L hdim g hg ha) (point_mem_support L hdim g hg hv) hav) + +/-- Both hypotheses refer to actual reduced Artin lengths, not an assumed word metric. -/ +theorem point_step (g : ArtinGroup L) (x : Letter V) + (hg : 0 < traceLength L (artinNormalTrace L g)) + (hgx : 0 < traceLength L (artinNormalTrace L (g * letterValue (artinGenerator L) x))) + (N : ℕ) (hNg : N ≤ traceLength L (artinNormalTrace L g)) + (hNgx : N ≤ traceLength L (artinNormalTrace L (g * letterValue (artinGenerator L) x))) : + Compatible L (point L hdim g hg) (point L hdim (g * letterValue (artinGenerator L) x) hgx) ∧ + dist (point L hdim g hg) (point L hdim (g * letterValue (artinGenerator L) x) hgx) ≤ + 2 / (N+1 : ℝ) := by + classical + obtain ⟨hs,n,_,hn,hbd⟩ := artinDirection_right_step L g x hg hgx + have hNn : N ≤ n := by rcases hn with ⟨he,_⟩ | ⟨he,_⟩ <;> omega + constructor + · intro v w hv hw + by_cases he : v = w + · exact Or.inl he + · apply Or.inr + apply hs _ _ he + · rcases hv with hv | hv + · exact Finset.mem_union_left _ (point_mem_support L hdim g hg hv) + · exact Finset.mem_union_right _ (point_mem_support L hdim _ hgx hv) + · rcases hw with hw | hw + · exact Finset.mem_union_left _ (point_mem_support L hdim g hg hw) + · exact Finset.mem_union_right _ (point_mem_support L hdim _ hgx hw) + · have hc : (N : ℝ) + 1 ≤ (n : ℝ) + 1 := by exact_mod_cast Nat.add_le_add_right hNn 1 + have hd : 0 < (N : ℝ) + 1 := by positivity + have hfrac : 2 / (n+1 : ℝ) ≤ 2 / (N+1 : ℝ) := + div_le_div_of_nonneg_left (by norm_num) hd hc + apply le_trans ?_ hfrac + change dist (artinDirection L g) (artinDirection L (g * letterValue (artinGenerator L) x)) ≤ _ + apply (dist_pi_le_iff (by positivity)).mpr + intro v + rw [Real.dist_eq,abs_sub_comm] + exact le_trans (Finset.single_le_sum (fun w _ => abs_nonneg (artinDirection L (g * letterValue (artinGenerator L) x) w - artinDirection L g w)) (Finset.mem_univ v)) hbd + + +/-- The integral level downstairs; the action is by left multiplication by the height kernel. -/ +abbrev NegativeLevel (N : ℕ) := {g : ArtinGroup L // (height L g).toAdd = -(N : ℤ)} + +omit [Fintype V] [LinearOrder V] in +theorem negative_level_length (N : ℕ) {g : ArtinGroup L} + (hg : (height L g).toAdd = -(N : ℤ)) : + N ≤ traceLength L (artinNormalTrace L g) := by + have hh := height_abs_le_traceLength L g + rw [hg,abs_neg,abs_of_nonneg (Nat.cast_nonneg N)] at hh + exact_mod_cast hh + +def levelPoint (N : ℕ) (hN : 0 < N) (g : NegativeLevel L N) : TrianglePoint V := + point L hdim g (lt_of_lt_of_le hN (negative_level_length L N g.property)) + +@[simp] theorem levelPoint_val (N : ℕ) (hN : 0 < N) (g : NegativeLevel L N) : + (levelPoint L hdim N hN g : V → ℝ) = artinDirection L g := rfl + +def upperVertex (N : ℕ) (hN : 1 < N) (g : NegativeLevel L N) (v : V) : + NegativeLevel L (N-1) := + ⟨(g : ArtinGroup L) * artinGenerator L v,by + rw [map_mul,height_generator] + change (height L (g : ArtinGroup L)).toAdd + 1 = _ + rw [g.property] + omega⟩ + +def edgeVertex (N : ℕ) (g : NegativeLevel L N) (q r : V) : NegativeLevel L N := + ⟨(g : ArtinGroup L) * artinGenerator L q * (artinGenerator L r)⁻¹,by + simp only [map_mul,map_inv,height_generator] + change (height L (g : ArtinGroup L)).toAdd + 1 + -1 = _ + rw [g.property] + omega⟩ + +omit [Fintype V] [LinearOrder V] in +theorem edgeVertex_reverse (N : ℕ) (g : NegativeLevel L N) (q r : V) : + edgeVertex L N (edgeVertex L N g q r) r q = g := by + apply Subtype.ext + change (g : ArtinGroup L) * _ * _ * _ * _ = _ + group + +omit [Fintype V] [LinearOrder V] in +theorem upperVertex_reverse (N : ℕ) (hN : 1 < N) (g : NegativeLevel L N) (q r : V) : + upperVertex L N hN (edgeVertex L N g q r) r = upperVertex L N hN g q := by + apply Subtype.ext + dsimp only [edgeVertex,upperVertex] + group + +theorem upperPoint_step (N : ℕ) (hN : 1 < N) (g : NegativeLevel L N) (v : V) : + Compatible L (levelPoint L hdim N (by omega) g) + (levelPoint L hdim (N-1) (by omega) (upperVertex L N hN g v)) ∧ + dist (levelPoint L hdim N (by omega) g) + (levelPoint L hdim (N-1) (by omega) (upperVertex L N hN g v)) ≤ 2 / (N : ℝ) := by + let hu := upperVertex L N hN g v + have hlen := negative_level_length L N g.property + have hlen' := negative_level_length L (N-1) hu.property + dsimp only [hu,upperVertex] at hlen' + have H := point_step L hdim (g : ArtinGroup L) (v,true) + (lt_of_lt_of_le (by omega : 0 < N) hlen) + (by simpa only [letterValue_positive] using lt_of_lt_of_le (by omega : 0 < N-1) hlen') + (N-1) (le_trans (Nat.sub_le N 1) hlen) + (by simpa only [letterValue_positive] using hlen') + have he : ((N-1 : ℕ) : ℝ) + 1 = (N : ℝ) := by exact_mod_cast (show (N-1 : ℕ) + 1 = N by omega) + simpa only [levelPoint,upperVertex,letterValue_positive,he] using H + +variable (h : V → V → SU2) (Q : V → ℍ) + +def edgeLabel (N : ℕ) (hN : 1 < N) (g : NegativeLevel L N) (q r : V) : SU2 := + edgeTransport h Q (levelPoint L hdim N (by omega) g) + (levelPoint L hdim (N-1) (by omega) (upperVertex L N hN g q)) + (levelPoint L hdim N (by omega) (edgeVertex L N g q r)) + +theorem edgeLabel_reverse (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (N : ℕ) (hN : 1 < N) (g : NegativeLevel L N) (q r : V) : + edgeLabel L hdim h Q N hN (edgeVertex L N g q r) r q = + (edgeLabel L hdim h Q N hN g q r)⁻¹ := by + have h₁ := (upperPoint_step L hdim N hN g q).1 + have h₂ := (upperPoint_step L hdim N hN (edgeVertex L N g q r) r).1 + rw [upperVertex_reverse] at h₂ + unfold edgeLabel + rw [edgeVertex_reverse,upperVertex_reverse] + exact edgeTransport_reverse L h Q hf hQ h₁ (compatible_symm L h₂) + +theorem edgeLabel_uniform (hQ : GeneralPosition h Q) {ε : ℝ} (hε : 0 < ε) : + ∃ M : ℕ, ∀ N : ℕ, M ≤ N → ∀ hN : 1 < N, ∀ g : NegativeLevel L N, ∀ q r : V, + dist (edgeLabel L hdim h Q N hN g q r) 1 < ε := by + obtain ⟨δ,hδ,H⟩ := edgeTransport_uniform h Q hQ hε + obtain ⟨M,hM⟩ := exists_nat_gt (2 / δ) + refine ⟨M,?_⟩ + intro N hMN hN g q r + have hN0 : (0 : ℝ) < N := by exact_mod_cast (by omega : 0 < N) + have hbound : 2 / (N : ℝ) < δ := by + apply (div_lt_iff₀ hN0).mpr + have hMN' : (M : ℝ) ≤ N := by exact_mod_cast hMN + have hh := (div_lt_iff₀ hδ).mp hM + nlinarith + apply H + · exact lt_of_le_of_lt (upperPoint_step L hdim N hN g q).2 hbound + · have hh := (upperPoint_step L hdim N hN (edgeVertex L N g q r) r).2 + rw [upperVertex_reverse,dist_comm] at hh + exact lt_of_le_of_lt hh hbound + + +omit [LinearOrder V] in +/-- Six compatible generator pieces around a level triangle lie in one flat chart +once the three edge images are uniformly short. -/ +theorem triangle_of_short (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (b c d u v w : TrianglePoint V) (δ : ℝ) (hδ : 0 < δ) + (hsmall : 4 * δ < 1 / (Fintype.card V + 1 : ℝ)) + (hb : CliquePoint L b) (hc : CliquePoint L c) (hd : CliquePoint L d) + (hu : CliquePoint L u) (hv : CliquePoint L v) (hw : CliquePoint L w) + (hbu : Compatible L b u) (huc : Compatible L u c) + (hcv : Compatible L c v) (hvd : Compatible L v d) + (hdw : Compatible L d w) (hwb : Compatible L w b) + (dbu : dist b u ≤ δ) (duc : dist u c ≤ δ) + (dcv : dist c v ≤ δ) (dvd : dist v d ≤ δ) + (_ddw : dist d w ≤ δ) (dwb : dist w b ≤ δ) : + edgeTransport h Q b u c * edgeTransport h Q c v d * edgeTransport h Q d w b = 1 := by + have dbc : dist b c ≤ 2 * δ := by linarith [dist_triangle b u c] + have dbv : dist b v ≤ 3 * δ := by linarith [dist_triangle b c v] + have dbd : dist b d ≤ 4 * δ := by linarith [dist_triangle b v d] + have dbw : dist b w ≤ δ := by simpa only [dist_comm] using dwb + obtain ⟨a,ha⟩ := exists_large_coordinate b + apply edgeTransport_triangle L h Q hf hQ b c d u v w hbu huc hcv hvd hdw hwb + · exact nearby_star L ha hb (by simpa using lt_of_lt_of_le hδ (le_of_lt (by linarith : δ < 1 / (Fintype.card V + 1 : ℝ)))) + · exact nearby_star L ha hc (by linarith) + · exact nearby_star L ha hd (lt_of_le_of_lt dbd hsmall) + · exact nearby_star L ha hu (by linarith) + · exact nearby_star L ha hv (by linarith) + · exact nearby_star L ha hw (by linarith) + +/-- Every oriented three-edge loop with these actual level endpoints is flat. +In particular both kinds of sections of a three-cube are covered. -/ +theorem edgeLabel_triangle (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (N : ℕ) (hN : 1 < N) (hsize : 8 / (N : ℝ) < 1 / (Fintype.card V + 1 : ℝ)) + (g₀ g₁ g₂ : NegativeLevel L N) (q₀ r₀ q₁ r₁ q₂ r₂ : V) + (e₀ : edgeVertex L N g₀ q₀ r₀ = g₁) + (e₁ : edgeVertex L N g₁ q₁ r₁ = g₂) + (e₂ : edgeVertex L N g₂ q₂ r₂ = g₀) : + edgeLabel L hdim h Q N hN g₀ q₀ r₀ * + edgeLabel L hdim h Q N hN g₁ q₁ r₁ * + edgeLabel L hdim h Q N hN g₂ q₂ r₂ = 1 := by + have h₀ := upperPoint_step L hdim N hN g₀ q₀ + have h₁ := upperPoint_step L hdim N hN g₁ q₁ + have h₂ := upperPoint_step L hdim N hN g₂ q₂ + have j₀ := upperPoint_step L hdim N hN g₁ r₀ + have j₁ := upperPoint_step L hdim N hN g₂ r₁ + have j₂ := upperPoint_step L hdim N hN g₀ r₂ + rw [← e₀,upperVertex_reverse,e₀] at j₀ + rw [← e₁,upperVertex_reverse,e₁] at j₁ + rw [← e₂,upperVertex_reverse,e₂] at j₂ + unfold edgeLabel + rw [e₀,e₁,e₂] + apply triangle_of_short L h Q hf hQ _ _ _ _ _ _ (2/(N : ℝ)) + · positivity + · convert hsize using 1; ring + · exact point_clique L hdim _ _ + · exact point_clique L hdim _ _ + · exact point_clique L hdim _ _ + · exact point_clique L hdim _ _ + · exact point_clique L hdim _ _ + · exact point_clique L hdim _ _ + · exact h₀.1 + · exact compatible_symm L j₀.1 + · exact h₁.1 + · exact compatible_symm L j₁.1 + · exact h₂.1 + · exact compatible_symm L j₂.1 + · exact h₀.2 + · simpa only [dist_comm] using j₀.2 + · exact h₁.2 + · simpa only [dist_comm] using j₁.2 + · exact h₂.2 + · simpa only [dist_comm] using j₂.2 + + +/-- A vertex of the simplex is also an honest point of its two-skeleton. -/ +def vertexPoint (v : V) : TrianglePoint V := + ⟨fun w => if v = w then 1 else 0,by + apply mem_triangleSet.mpr + refine ⟨{v},by simp,⟨?_,?_⟩,?_⟩ + · intro w; dsimp only; split_ifs <;> norm_num + · simp + · intro w hw + simp only [Finset.mem_singleton] at hw + simp [Ne.symm hw]⟩ + +@[simp] theorem vertexPoint_val (v w : V) : + (vertexPoint v : V → ℝ) w = if v = w then 1 else 0 := rfl + +theorem star_vertex {a v : V} (hav : Related L a v) : Star L a (vertexPoint v) := by + intro w hw + have he : v = w := by by_contra hh; exact hw (by simp [vertexPoint,hh]) + simpa only [← he] using hav + +omit [Fintype V] [LinearOrder V] in +theorem negative_powers_upper {q r : V} (hqr : L.Adj q r) (n m : ℕ) : + (artinGenerator L q)⁻¹ ^ (n+1) * (artinGenerator L r)⁻¹ ^ m * artinGenerator L q = + (artinGenerator L q)⁻¹ ^ n * (artinGenerator L r)⁻¹ ^ m := by + have hc := (adjacent_generators_commute L hqr).inv_right.pow_right m + calc + _ = (artinGenerator L q)⁻¹ ^ n * + ((artinGenerator L q)⁻¹ * ((artinGenerator L r)⁻¹ ^ m * artinGenerator L q)) := by + simp only [pow_succ]; group + _ = (artinGenerator L q)⁻¹ ^ n * + ((artinGenerator L q)⁻¹ * (artinGenerator L q * (artinGenerator L r)⁻¹ ^ m)) := by + rw [← hc.eq] + _ = _ := by group + +/-- Negative commuting powers remain exactly in their two-coordinate face. -/ +theorem powersPoint_star {q r : V} (hqr : L.Adj q r) (n m : ℕ) + (hg : 0 < traceLength L (artinNormalTrace L + ((artinGenerator L q)⁻¹ ^ n * (artinGenerator L r)⁻¹ ^ m))) : + Star L q (point L hdim ((artinGenerator L q)⁻¹ ^ n * (artinGenerator L r)⁻¹ ^ m) hg) := by + intro v hv + by_cases hqv : q = v + · exact Or.inl hqv + by_cases hrv : r = v + · exact Or.inr (hrv ▸ hqr) + exfalso + apply hv + rw [point_val,direction_negative_commuting_powers L hqr] + simp [hqv,hrv] + +/-- Constant endpoint in the q-direction, stated with a concrete positive height. -/ +theorem powersPoint_first {q r : V} (hqr : L.Adj q r) (N : ℕ) (hN : 0 < N) + (hg : 0 < traceLength L (artinNormalTrace L + ((artinGenerator L q)⁻¹ ^ N * (artinGenerator L r)⁻¹ ^ 0))) : + point L hdim ((artinGenerator L q)⁻¹ ^ N * (artinGenerator L r)⁻¹ ^ 0) hg = + vertexPoint q := by + apply Subtype.ext + funext v + rw [point_val,vertexPoint_val,direction_negative_commuting_powers L hqr] + have hn : (N : ℝ) ≠ 0 := by exact_mod_cast Nat.ne_of_gt hN + by_cases hv : q = v <;> simp [hv,hn] + +theorem powersPoint_last {q r : V} (hqr : L.Adj q r) (N : ℕ) (hN : 0 < N) + (hg : 0 < traceLength L (artinNormalTrace L + ((artinGenerator L q)⁻¹ ^ 0 * (artinGenerator L r)⁻¹ ^ N))) : + point L hdim ((artinGenerator L q)⁻¹ ^ 0 * (artinGenerator L r)⁻¹ ^ N) hg = + vertexPoint r := by + apply Subtype.ext + funext v + rw [point_val,vertexPoint_val,direction_negative_commuting_powers L hqr] + have hn : (N : ℝ) ≠ 0 := by exact_mod_cast Nat.ne_of_gt hN + by_cases hv : r = v <;> simp [hv,hn] + +def powerVertex (N : ℕ) (q r : V) (j : ℕ) : NegativeLevel L N := + ⟨(artinGenerator L q)⁻¹ ^ (N - min j N) * (artinGenerator L r)⁻¹ ^ min j N,by + simp only [map_mul,map_pow,map_inv,height_generator] + change (N-min j N : ℕ) • (-1 : ℤ) + (min j N : ℕ) • (-1 : ℤ) = _ + simp only [nsmul_eq_mul,mul_neg,mul_one] + have hh : min j N ≤ N := min_le_right _ _ + omega⟩ + +omit [Fintype V] [LinearOrder V] in +theorem powerVertex_step (N : ℕ) {q r : V} (hqr : L.Adj q r) {j : ℕ} (hj : j < N) : + edgeVertex L N (powerVertex L N q r j) q r = powerVertex L N q r (j+1) := by + apply Subtype.ext + dsimp only [powerVertex,edgeVertex] + rw [min_eq_left (by omega : j ≤ N),min_eq_left (by omega : j+1 ≤ N)] + have he : N-j = (N-(j+1))+1 := by omega + rw [he,negative_powers_upper L hqr,pow_succ] + group + +omit [Fintype V] [LinearOrder V] in +theorem powerVertex_upper (N : ℕ) (hN : 1 < N) {q r : V} + (hqr : L.Adj q r) {j : ℕ} (hj : j < N) : + (upperVertex L N hN (powerVertex L N q r j) q : ArtinGroup L) = + (artinGenerator L q)⁻¹ ^ (N-(j+1)) * (artinGenerator L r)⁻¹ ^ j := by + dsimp only [powerVertex,upperVertex] + rw [min_eq_left (by omega : j ≤ N)] + have he : N-j = (N-(j+1))+1 := by omega + rw [he,negative_powers_upper L hqr] + +theorem powerVertex_star (N : ℕ) (hN : 0 < N) {q r : V} (hqr : L.Adj q r) (j : ℕ) : + Star L q (levelPoint L hdim N hN (powerVertex L N q r j)) := + powersPoint_star L hdim hqr _ _ _ + +theorem powerVertex_upper_star (N : ℕ) (hN : 1 < N) {q r : V} + (hqr : L.Adj q r) {j : ℕ} (hj : j < N) : + Star L q (levelPoint L hdim (N-1) (by omega) + (upperVertex L N hN (powerVertex L N q r j) q)) := by + unfold levelPoint + generalize_proofs hpos + simp only [powerVertex_upper L N hN hqr hj] at hpos ⊢ + exact powersPoint_star L hdim hqr _ _ _ + +theorem powerLabel_chart (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (N : ℕ) (hN : 1 < N) {q r : V} (hqr : L.Adj q r) {j : ℕ} (hj : j < N) : + edgeLabel L hdim h Q N hN (powerVertex L N q r j) q r = + chartTransport h Q q (levelPoint L hdim N (by omega) (powerVertex L N q r j)) + (levelPoint L hdim N (by omega) (powerVertex L N q r (j+1))) := by + have hb := upperPoint_step L hdim N hN (powerVertex L N q r j) q + have hc := upperPoint_step L hdim N hN (edgeVertex L N (powerVertex L N q r j) q r) r + rw [upperVertex_reverse] at hc + unfold edgeLabel + rw [edgeTransport_chart L h Q hf hQ hb.1 (compatible_symm L hc.1) + (powerVertex_star L hdim N (by omega) hqr j) (powerVertex_upper_star L hdim N hN hqr hj)] + · rw [powerVertex_step L N hqr hj] + · rw [powerVertex_step L N hqr hj] + exact powerVertex_star L hdim N (by omega) hqr (j+1) + + +/-- Directed walks retain the chosen generator pair, including parallel edges. -/ +inductive Walk (N : ℕ) : NegativeLevel L N → NegativeLevel L N → Type _ + | nil (g : NegativeLevel L N) : Walk N g g + | cons {g k : NegativeLevel L N} (q r : V) (hqr : L.Adj q r) + (p : Walk N (edgeVertex L N g q r) k) : Walk N g k + +namespace Walk +variable {L} {N : ℕ} + +def append {g k l : NegativeLevel L N} : Walk L N g k → Walk L N k l → Walk L N g l + | .nil _, p => p + | .cons q r hqr p, t => .cons q r hqr (append p t) + +def cast {g k g' k' : NegativeLevel L N} (p : Walk L N g k) + (hg : g = g') (hk : k = k') : Walk L N g' k' := hg ▸ hk ▸ p + +end Walk + +def walkProduct (N : ℕ) (hN : 1 < N) {g k : NegativeLevel L N} : Walk L N g k → SU2 + | .nil _ => 1 + | .cons (g := g) q r _ p => edgeLabel L hdim h Q N hN g q r * walkProduct N hN p + +@[simp] theorem walkProduct_nil (N : ℕ) (hN : 1 < N) (g : NegativeLevel L N) : + walkProduct L hdim h Q N hN (.nil g) = 1 := rfl + +@[simp] theorem walkProduct_cons (N : ℕ) (hN : 1 < N) {g k : NegativeLevel L N} + (q r : V) (hqr : L.Adj q r) (p : Walk L N (edgeVertex L N g q r) k) : + walkProduct L hdim h Q N hN (.cons q r hqr p) = + edgeLabel L hdim h Q N hN g q r * walkProduct L hdim h Q N hN p := rfl + +@[simp] theorem walkProduct_append (N : ℕ) (hN : 1 < N) {g k l : NegativeLevel L N} + (p : Walk L N g k) (t : Walk L N k l) : + walkProduct L hdim h Q N hN (p.append t) = + walkProduct L hdim h Q N hN p * walkProduct L hdim h Q N hN t := by + induction p with + | nil => simp [Walk.append] + | cons q r hqr p ih => simp [Walk.append,ih,mul_assoc] + +@[simp] theorem walkProduct_cast (N : ℕ) (hN : 1 < N) {g k g' k' : NegativeLevel L N} + (p : Walk L N g k) (hg : g = g') (hk : k = k') : + walkProduct L hdim h Q N hN (p.cast hg hk) = walkProduct L hdim h Q N hN p := by + subst g'; subst k'; rfl + +/-- The entire subdivided edge has the exact endpoint transport, not merely a limit. -/ +theorem exists_powerWalk (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (N : ℕ) (hN : 1 < N) {q r : V} (hqr : L.Adj q r) (k : ℕ) (hk : k ≤ N) : + ∃ p : Walk L N (powerVertex L N q r 0) (powerVertex L N q r k), + walkProduct L hdim h Q N hN p = + chartTransport h Q q (levelPoint L hdim N (by omega) (powerVertex L N q r 0)) + (levelPoint L hdim N (by omega) (powerVertex L N q r k)) := by + induction k with + | zero => exact ⟨.nil _,by simp [chartTransport]⟩ + | succ k ih => + obtain ⟨p,hp⟩ := ih (by omega) + let t : Walk L N (powerVertex L N q r k) + (edgeVertex L N (powerVertex L N q r k) q r) := .cons q r hqr (.nil _) + let t' := t.cast rfl (powerVertex_step L N hqr (by omega : k < N)) + refine ⟨p.append t',?_⟩ + rw [walkProduct_append,hp] + simp only [t',walkProduct_cast,t,walkProduct_cons,walkProduct_nil,mul_one] + rw [powerLabel_chart L hdim h Q hf hQ N hN hqr (by omega),chartTransport_trans] + +def pureVertex (N : ℕ) (q : V) : NegativeLevel L N := + ⟨(artinGenerator L q)⁻¹ ^ N,by + simp only [map_pow,map_inv,height_generator] + change N • (-1 : ℤ) = -(N : ℤ) + simp⟩ + +omit [Fintype V] [LinearOrder V] in +theorem powerVertex_zero (N : ℕ) (q r : V) : + powerVertex L N q r 0 = pureVertex L N q := by apply Subtype.ext; simp [powerVertex,pureVertex] + +omit [Fintype V] [LinearOrder V] in +theorem powerVertex_last (N : ℕ) (q r : V) : + powerVertex L N q r N = pureVertex L N r := by apply Subtype.ext; simp [powerVertex,pureVertex] + +def vertexGauge (v : V) : SU2 := gauge h Q v (vertexPoint v) + +theorem levelPoint_power_zero (N : ℕ) (hN : 0 < N) {q r : V} (hqr : L.Adj q r) : + levelPoint L hdim N hN (powerVertex L N q r 0) = vertexPoint q := by + unfold levelPoint + have hh : (powerVertex L N q r 0 : ArtinGroup L) = + (artinGenerator L q)⁻¹ ^ N * (artinGenerator L r)⁻¹ ^ 0 := by simp [powerVertex] + simp only [hh] + exact powersPoint_first L hdim hqr N hN _ + +theorem levelPoint_power_last (N : ℕ) (hN : 0 < N) {q r : V} (hqr : L.Adj q r) : + levelPoint L hdim N hN (powerVertex L N q r N) = vertexPoint r := by + unfold levelPoint + have hh : (powerVertex L N q r N : ArtinGroup L) = + (artinGenerator L q)⁻¹ ^ 0 * (artinGenerator L r)⁻¹ ^ N := by simp [powerVertex] + simp only [hh] + exact powersPoint_last L hdim hqr N hN _ + +theorem exists_expanded_edge (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (N : ℕ) (hN : 1 < N) {q r : V} (hqr : L.Adj q r) : + ∃ p : Walk L N (pureVertex L N q) (pureVertex L N r), + walkProduct L hdim h Q N hN p = + (vertexGauge h Q q)⁻¹ * h q r * vertexGauge h Q r := by + obtain ⟨p,hp⟩ := exists_powerWalk L hdim h Q hf hQ N hN hqr N le_rfl + refine ⟨p.cast (powerVertex_zero L N q r) (powerVertex_last L N q r),?_⟩ + rw [walkProduct_cast,hp,levelPoint_power_zero L hdim N (by omega) hqr, + levelPoint_power_last L hdim N (by omega) hqr] + unfold chartTransport vertexGauge + rw [gauge_transition L h Q hf hQ (Or.inr hqr) + (star_vertex L (Or.inr hqr)) (star_vertex L (Or.inl rfl))] + group + +omit [Fintype V] [LinearOrder V] in +def graphWalkProduct {a b : V} : L.Walk a b → SU2 + | .nil => 1 + | .cons (u := u) (v := v) _ p => h u v * graphWalkProduct p + +theorem exists_expanded_walk (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (N : ℕ) (hN : 1 < N) {q r : V} (w : L.Walk q r) : + ∃ p : Walk L N (pureVertex L N q) (pureVertex L N r), + walkProduct L hdim h Q N hN p = + (vertexGauge h Q q)⁻¹ * graphWalkProduct L h w * vertexGauge h Q r := by + induction w with + | nil => exact ⟨.nil _,by simp [graphWalkProduct]⟩ + | @cons q t r hqt w ih => + obtain ⟨p,hp⟩ := exists_expanded_edge L hdim h Q hf hQ N hN hqt + obtain ⟨s,hs⟩ := ih + refine ⟨p.append s,?_⟩ + rw [walkProduct_append,hp,hs] + simp only [graphWalkProduct] + group + +omit [Fintype V] [LinearOrder V] in +theorem graphWalkProduct_eq_zipWith {a b : V} (w : L.Walk a b) : + graphWalkProduct L h w = (List.zipWith h w.support w.support.tail).prod := by + induction w with + | nil => simp [graphWalkProduct] + | @cons q t r hqt w ih => + cases w with + | nil => simp [graphWalkProduct] + | cons htl p => simpa only [graphWalkProduct,SimpleGraph.Walk.support_cons, + List.tail_cons,List.zipWith_cons_cons,List.prod_cons] using congrArg (h q t * ·) ih + +/-- A nontrivial seed holonomy survives every sufficiently translated level. -/ +theorem exists_nontrivial_level_walk (hf : FlatConnection L h) (hQ : GeneralPosition h Q) + (N : ℕ) (hN : 1 < N) {q : V} (w : L.Walk q q) + (hw : graphWalkProduct L h w ≠ 1) : + ∃ p : Walk L N (pureVertex L N q) (pureVertex L N q), + walkProduct L hdim h Q N hN p ≠ 1 := by + obtain ⟨p,hp⟩ := exists_expanded_walk L hdim h Q hf hQ N hN w + refine ⟨p,?_⟩ + rw [hp] + intro he + apply hw + calc + graphWalkProduct L h w = vertexGauge h Q q * + ((vertexGauge h Q q)⁻¹ * graphWalkProduct L h w * vertexGauge h Q q) * + (vertexGauge h Q q)⁻¹ := by group + _ = 1 := by rw [he]; group + + +namespace Walk +variable {L} {N : ℕ} +omit [Fintype V] [LinearOrder V] in +def eval (a : NegativeLevel L N → V → V → SU2) + {g k : NegativeLevel L N} : Walk L N g k → SU2 + | .nil _ => 1 + | .cons (g := g) q r _ p => a g q r * eval a p +end Walk + +theorem walkProduct_eq_eval (N : ℕ) (hN : 1 < N) {g k : NegativeLevel L N} + (p : Walk L N g k) : + walkProduct L hdim h Q N hN p = p.eval (edgeLabel L hdim h Q N hN) := by + induction p with + | nil => rfl + | cons q r hqr p ih => simp only [walkProduct,Walk.eval,ih] + +end LevelTransport + +namespace SourceTransport +open LevelTransport AffineTransport + +def seedWalk : seedGraph.Walk (.inl (.inl none)) (.inl (.inl none)) := + SimpleGraph.Walk.ofSupport SeedConnection.roseLoop + (by simp [SeedConnection.roseLoop]) SeedConnection.roseLoop_edges + +theorem seedWalk_support : seedWalk.support = SeedConnection.roseLoop := + SimpleGraph.Walk.support_ofSupport _ _ + +theorem seedWalk_product_ne : graphWalkProduct seedGraph SeedConnection.connection seedWalk ≠ 1 := by + rw [graphWalkProduct_eq_zipWith,seedWalk_support] + exact SeedConnection.roseLoop_nontrivial + +/-- Actual small flat transport for the fixed source level graph. There are no +representation, direction-map, local-chart, or nontriviality hypotheses here. -/ +theorem source_small_labels (ε : ℝ) (hε : 0 < ε) : + ∃ N : ℕ, 1 < N ∧ ∃ a : NegativeLevel seedGraph N → SeedCell → SeedCell → SU2, + (∀ g q r, a (edgeVertex seedGraph N g q r) r q = (a g q r)⁻¹) ∧ + (∀ g q r, dist (a g q r) 1 < ε) ∧ + (∀ g₀ g₁ g₂ q₀ r₀ q₁ r₁ q₂ r₂, + edgeVertex seedGraph N g₀ q₀ r₀ = g₁ → + edgeVertex seedGraph N g₁ q₁ r₁ = g₂ → + edgeVertex seedGraph N g₂ q₂ r₂ = g₀ → + a g₀ q₀ r₀ * a g₁ q₁ r₁ * a g₂ q₂ r₂ = 1) ∧ + ∃ (g : NegativeLevel seedGraph N) (p : Walk seedGraph N g g), p.eval a ≠ 1 := by + let : LinearOrder SeedCell := LinearOrder.lift' (Fintype.equivFin SeedCell) + (Fintype.equivFin SeedCell).injective + obtain ⟨Q,hQ⟩ := exists_generalPosition SeedConnection.connection + have hf : FlatConnection seedGraph SeedConnection.connection := + fun _ _ _ hab hbc hac => SeedConnection.connection_flat hab hbc hac + obtain ⟨M,hM⟩ := edgeLabel_uniform seedGraph SeedConnection.clique_card_le_three + SeedConnection.connection Q hQ hε + let D := Fintype.card SeedCell + 1 + let N := max M (8 * D + 2) + have hMN : M ≤ N := le_max_left _ _ + have hNbound : 8 * D + 2 ≤ N := le_max_right _ _ + have hN : 1 < N := by omega + have hD : (0 : ℝ) < D := by dsimp [D]; positivity + have hNr : (0 : ℝ) < N := by exact_mod_cast (by omega : 0 < N) + have hsize : 8 / (N : ℝ) < 1 / (Fintype.card SeedCell + 1 : ℝ) := by + have hBN : (8 : ℝ) * D + 2 ≤ N := by exact_mod_cast hNbound + have hDcast : (D : ℝ) = (Fintype.card SeedCell : ℝ) + 1 := by simp [D] + rw [← hDcast] + apply (div_lt_div_iff₀ hNr hD).mpr + nlinarith + let a := edgeLabel seedGraph SeedConnection.clique_card_le_three + SeedConnection.connection Q N hN + refine ⟨N,hN,a,?_,?_,?_,?_⟩ + · exact edgeLabel_reverse seedGraph SeedConnection.clique_card_le_three + SeedConnection.connection Q hf hQ N hN + · exact hM N hMN hN + · exact edgeLabel_triangle seedGraph SeedConnection.clique_card_le_three + SeedConnection.connection Q hf hQ N hN hsize + · obtain ⟨p,hp⟩ := exists_nontrivial_level_walk seedGraph SeedConnection.clique_card_le_three + SeedConnection.connection Q hf hQ N hN seedWalk seedWalk_product_ne + refine ⟨_,p,?_⟩ + rwa [walkProduct_eq_eval] at hp + +end SourceTransport +end EilenbergGanea + + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/Main.lean b/lean/OAI/Topology/EilenbergGanea/Main.lean new file mode 100644 index 0000000000000000000000000000000000000000..55f932a18706cdb3908f83d15b5be425304dbbb4 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/Main.lean @@ -0,0 +1,43 @@ +import OAI.Topology.EilenbergGanea.Dimension +import OAI.Topology.EilenbergGanea.CubicalCover +import OAI.AlgebraicTopology.CWComplex.Presentation + +namespace OAI + +noncomputable section + +open Classical Set Metric Topology + +namespace EilenbergGanea +universe u + +/-- Exclusion is for arbitrary ordinary2-dimensional classifying CW spaces, +not merely finite presentations or cell complexes with finitely many orbits. -/ +theorem source_no_classifyingSpace_two : ¬ HasClassifyingSpace.{u} SourceGroup 2 := by + rintro ⟨X,tX,hTX,cX,hd,hpc,x,⟨χ⟩,E,tE,hcon,p,cov,hs⟩ + let : TopologicalSpace X := tX + let : T2Space X := hTX + let : Topology.CWComplex (Set.univ : Set X) := cX + let : PathConnectedSpace X := hpc + let : TopologicalSpace E := tE + let : ContractibleSpace E := hcon + obtain ⟨A,a,ha,r,hr,hp,B,hB⟩ := CWPresentation.ordinary_boundary_basis cov hd hs x χ + exact source_no_boundary_basis a ha r hr hp B hB + +/-- Source Theorem1.1 for the exact103-cell flag triangulation and its actual +Artin height kernel. The last conjunct is polymorphic in the universe of the +hypothetical ordinary CW model, with unrestricted numbers of cells. -/ +theorem source_main : + Group.FG SourceGroup ∧ Group.ResiduallyFinite SourceGroup ∧ + cohomologicalDimension SourceGroup = 2 ∧ + HasClassifyingSpace.{0} SourceGroup 3 ∧ + ¬ HasClassifyingSpace.{u} SourceGroup 2 := + ⟨source_finitely_generated,source_residuallyFinite,source_cohomologicalDimension, + source_hasClassifyingSpace_three,source_no_classifyingSpace_two⟩ + +end EilenbergGanea + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/Model.lean b/lean/OAI/Topology/EilenbergGanea/Model.lean new file mode 100644 index 0000000000000000000000000000000000000000..095480f10cc329e05b12cd66340bae766f913e1e --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/Model.lean @@ -0,0 +1,61 @@ +import OAI.Topology.EilenbergGanea.Seed +import OAI.GroupTheory.RightAngledArtin.ResidualFiniteness +import Mathlib.Algebra.Category.ModuleCat.ProjectiveDimension +import Mathlib.RepresentationTheory.Basic +import Mathlib.Topology.CWComplex.Classical.Basic +import Mathlib.Topology.Covering.Basic +import Mathlib.Topology.Homotopy.Contractible +import Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup + +namespace OAI + +noncomputable section + +open Classical Set Topology + +namespace EilenbergGanea +abbrev SourceGroup := (height seedGraph).ker + +/-- Integral, left-module cohomological dimension; no rational replacement. -/ +def cohomologicalDimension (G : Type*) [Group G] : WithBot ℕ∞ := + CategoryTheory.projectiveDimension + (ModuleCat.of (MonoidAlgebra ℤ G) (Representation.trivial ℤ G ℤ).asModule) + +universe u +/-- Ordinary K(G,1) of dimension at most n. The cell and space types have no +finiteness or countability restriction. The contractible surjective covering +is the usual universal-cover characterization of a classifying space. -/ +def HasClassifyingSpace (G : Type*) [Group G] (n : ℕ) : Prop := + ∃ (X : Type u) (_ : TopologicalSpace X) (_ : T2Space X) + (_ : Topology.CWComplex (Set.univ : Set X)), + (∀ k : ℕ, n < k → IsEmpty (Topology.CWComplex.cell (Set.univ : Set X) k)) ∧ + PathConnectedSpace X ∧ + ∃ x : X, Nonempty (FundamentalGroup X x ≃* G) ∧ + ∃ (E : Type u) (_ : TopologicalSpace E), ContractibleSpace E ∧ + ∃ p : E → X, IsCoveringMap p ∧ Function.Surjective p + + +end EilenbergGanea + +namespace EilenbergGanea +/-- The finite-generation conjunct for the exact source height kernel. -/ +theorem source_finitely_generated : Group.FG SourceGroup := + height_kernel_fg seedGraph seed_connected.preconnected seedBase + + + +end EilenbergGanea + +namespace EilenbergGanea +/-- The second exact conjunct of the source main theorem. -/ +theorem source_residuallyFinite : Group.ResiduallyFinite SourceGroup := by + have := artin_residuallyFinite SeedCell seedGraph + infer_instance + +end EilenbergGanea + + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/PresentationAlignment.lean b/lean/OAI/Topology/EilenbergGanea/PresentationAlignment.lean new file mode 100644 index 0000000000000000000000000000000000000000..185bc06451de98c2d6df38a43e2230185fa81056 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/PresentationAlignment.lean @@ -0,0 +1,1205 @@ +import OAI.Topology.EilenbergGanea.PresentationComparison + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +/-! Actual word and cycle-basis alignment. -/ +namespace EilenbergGanea +section WordRealization +variable {Γ S R : Type*} [Group Γ] + +theorem pathChain_zpow_loop (v : S → Γ) (w : FreeGroup S) + (hw : wordValue v w = 1) (n : ℤ) (g : Γ) : + pathChain v (w ^ n) g = n • pathChain v w g := by + induction n using Int.induction_on with + | zero => simp + | succ n ih => + rw [zpow_add, zpow_one, pathChain_mul, map_zpow, hw, one_zpow, mul_one, ih] + simp [add_zsmul] + | pred n ih => + rw [zpow_sub, zpow_one, pathChain_mul, map_zpow, hw, one_zpow, mul_one, + pathChain_inv, hw, inv_one, mul_one, ih] + simp only [sub_eq_add_neg, add_zsmul, neg_zsmul, one_zsmul] + +/-- Every finitely supported integral relator combination is realized by a +finite word in the same normal closure. Surjectivity supplies the finitely +many conjugating words; no infinite product of presentation moves occurs. -/ +theorem realize_relator_chain (v : S → Γ) (hv : Function.Surjective (wordValue v)) + (r : R → FreeGroup S) (hr : ∀ i, wordValue v (r i) = 1) + (c : (Γ × R) →₀ ℤ) : + ∃ w ∈ Subgroup.normalClosure (Set.range r), + pathChain v w 1 = relatorChainMap v r c := by + classical + induction c using Finsupp.induction with + | zero => exact ⟨1, Subgroup.one_mem _, by simp⟩ + | @single_add a n c ha hn ih => + obtain ⟨w,hw,hcw⟩ := ih + obtain ⟨u,hu⟩ := hv a.1 + let z := u * r a.2 * u⁻¹ + have hz : z ∈ Subgroup.normalClosure (Set.range r) := + (Subgroup.normalClosure_normal (s := Set.range r)).conj_mem _ + (Subgroup.subset_normalClosure (Set.mem_range_self a.2)) u + have hzw : wordValue v z = 1 := by simp [z,hr] + refine ⟨z ^ n * w, Subgroup.mul_mem _ (Subgroup.zpow_mem _ hz n) hw, ?_⟩ + rw [pathChain_mul, map_zpow, hzw, one_zpow, mul_one, pathChain_zpow_loop _ _ hzw, + hcw, map_add] + congr 1 + rw [pathChain_conjugate v u _ (hr a.2), one_mul, hu] + simp [relatorChainMap] + +end WordRealization +end EilenbergGanea +namespace EilenbergGanea +section RelatorShears +variable {Γ S R I : Type*} [Group Γ] + +theorem relatorChainMap_equivariant (v : S → Γ) (r : R → FreeGroup S) : + ChainsEquivariant (relatorChainMap v r) := by + intro g c + have he : (relatorChainMap v r).comp (translateChains g) = + (translateChains g).comp (relatorChainMap v r) := by + apply Finsupp.lhom_ext + rintro ⟨h,i⟩ n + simp only [LinearMap.comp_apply, translateChains_single, relatorChainMap, + Finsupp.linearCombination_single, map_smul, pathChain_translate] + exact LinearMap.congr_fun he c + +theorem normal_relators_trivial (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) : + Subgroup.normalClosure (Set.range r) ≤ (wordValue v).ker := by + apply Subgroup.normalClosure_le_normal + rintro _ ⟨i,rfl⟩ + exact hr i + +@[simp] theorem relatorChainMap_single (v : S → Γ) (r : R → FreeGroup S) + (g : Γ) (i : R) (n : ℤ) : + relatorChainMap v r (Finsupp.single (g,i) n) = n • pathChain v (r i) g := by + simp [relatorChainMap] + +/-- A whole column-finite shear is realized by honest finite relator words, +including when the relator alphabets have arbitrary cardinality. -/ +theorem shear_relators (v : S → Γ) (hv : Function.Surjective (wordValue v)) + (r : R → FreeGroup S) (u : I → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (hu : ∀ i, wordValue v (u i) = 1) + (C : BasedChains Γ I →ₗ[ℤ] BasedChains Γ R) (hC : ChainsEquivariant C) : + ∃ u' : I → FreeGroup S, + (∀ i, wordValue v (u' i) = 1) ∧ + Subgroup.normalClosure (Set.range r ∪ Set.range u') = + Subgroup.normalClosure (Set.range r ∪ Set.range u) ∧ + relatorChainMap v u' = relatorChainMap v u + (relatorChainMap v r).comp C := by + classical + choose p hp hc using fun i => realize_relator_chain v hv r hr (C (Finsupp.single (1,i) 1)) + let u' : I → FreeGroup S := fun i => u i * p i + have hpr (i) : wordValue v (p i) = 1 := normal_relators_trivial v r hr (hp i) + have hu' (i) : wordValue v (u' i) = 1 := by simp [u',hu,hpr] + refine ⟨u',hu',?_,?_⟩ + · apply le_antisymm + · apply Subgroup.normalClosure_le_normal + rintro _ (⟨i,rfl⟩ | ⟨i,rfl⟩) + · exact Subgroup.subset_normalClosure (Or.inl (Set.mem_range_self i)) + · exact Subgroup.mul_mem _ (Subgroup.subset_normalClosure (Or.inr (Set.mem_range_self i))) + (Subgroup.normalClosure_mono Set.subset_union_left (hp i)) + · apply Subgroup.normalClosure_le_normal + rintro _ (⟨i,rfl⟩ | ⟨i,rfl⟩) + · exact Subgroup.subset_normalClosure (Or.inl (Set.mem_range_self i)) + · have h : u' i * (p i)⁻¹ ∈ Subgroup.normalClosure (Set.range r ∪ Set.range u') := + Subgroup.mul_mem _ (Subgroup.subset_normalClosure (Or.inr (Set.mem_range_self i))) + (Subgroup.inv_mem _ (Subgroup.normalClosure_mono Set.subset_union_left (hp i))) + simpa [u'] using h + · have hb (i) : pathChain v (u' i) 1 = pathChain v (u i) 1 + + relatorChainMap v r (C (Finsupp.single (1,i) 1)) := by + simp only [u',pathChain_mul,hu,mul_one,hc] + have hbg (g : Γ) (i : I) : pathChain v (u' i) g = pathChain v (u i) g + + relatorChainMap v r (C (Finsupp.single (g,i) 1)) := by + have h := congrArg (translateChains g) (hb i) + rw [map_add,pathChain_translate,pathChain_translate,mul_one, + ← relatorChainMap_equivariant v r g, ← hC g, translateChains_single,mul_one] at h + exact h + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + have hn : Finsupp.single (g,i) n = n • Finsupp.single (g,i) (1 : ℤ) := by simp + simpa only [hn, map_smul, LinearMap.add_apply, LinearMap.comp_apply, + relatorChainMap_single, one_smul, smul_add] using congrArg (n • ·) (hbg g i) + +/-- The source's three shears P,Q,P, at the level of relator words rather +than merely chain matrices. No infinite product or cardinality restriction. -/ +theorem block_word_alignment (v : S → Γ) (hv : Function.Surjective (wordValue v)) + (r : R → FreeGroup S) (u : I → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (hu : ∀ i, wordValue v (u i) = 1) + (A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ I) + (hA : ChainsEquivariant A.toLinearMap) : + ∃ (r' : R → FreeGroup S) (u' : I → FreeGroup S), + (∀ i, wordValue v (r' i) = 1) ∧ (∀ i, wordValue v (u' i) = 1) ∧ + Subgroup.normalClosure (Set.range r' ∪ Set.range u') = + Subgroup.normalClosure (Set.range r ∪ Set.range u) ∧ + relatorChainMap v r' = -((relatorChainMap v u).comp A.toLinearMap) ∧ + relatorChainMap v u' = (relatorChainMap v r).comp A.symm.toLinearMap := by + have hAi := ChainsEquivariant.symm A hA + have hnA : ChainsEquivariant (-A.toLinearMap) := by + intro g c + simp only [LinearMap.neg_apply, map_neg] + exact congrArg Neg.neg (hA g c) + obtain ⟨u₁,hu₁,hN₁,hD₁⟩ := shear_relators v hv r u hr hu A.symm.toLinearMap hAi + obtain ⟨r₂,hr₂,hN₂,hD₂⟩ := shear_relators v hv u₁ r hu₁ hr (-A.toLinearMap) hnA + have hD₂' : relatorChainMap v r₂ = -((relatorChainMap v u).comp A.toLinearMap) := by + rw [hD₂,hD₁] + ext c + simp only [LinearMap.add_apply, LinearMap.comp_apply, LinearMap.neg_apply, + map_neg, LinearEquiv.coe_coe, LinearEquiv.symm_apply_apply] + abel_nf + obtain ⟨u₃,hu₃,hN₃,hD₃⟩ := shear_relators v hv r₂ u₁ hr₂ hu₁ A.symm.toLinearMap hAi + refine ⟨r₂,u₃,hr₂,hu₃,?_,hD₂',?_⟩ + · rw [hN₃,Set.union_comm (Set.range r₂) (Set.range u₁),hN₂, + Set.union_comm (Set.range u₁) (Set.range r),hN₁] + · rw [hD₃,hD₁,hD₂'] + ext c + simp only [LinearMap.add_apply, LinearMap.comp_apply, LinearMap.neg_apply, + LinearEquiv.coe_coe, LinearEquiv.apply_symm_apply] + abel_nf + +end RelatorShears +end EilenbergGanea + +namespace EilenbergGanea +section CycleSpaces +variable {Γ S T U R : Type*} [Group Γ] + +def edgeBoundary (v : S → Γ) : BasedChains Γ S →ₗ[ℤ] (Γ →₀ ℤ) := + Finsupp.linearCombination ℤ (fun p : Γ × S => + Finsupp.single (p.1 * v p.2) 1 - Finsupp.single p.1 1) + +@[simp] theorem edgeBoundary_single (v : S → Γ) (g : Γ) (s : S) (n : ℤ) : + edgeBoundary v (Finsupp.single (g,s) n) = + n • (Finsupp.single (g * v s) 1 - Finsupp.single g 1) := by + simp [edgeBoundary] + +theorem edgeBoundary_pathChain (v : S → Γ) (w : FreeGroup S) (g : Γ) : + edgeBoundary v (pathChain v w g) = + Finsupp.single (g * wordValue v w) 1 - Finsupp.single g 1 := by + induction w using FreeGroup.induction_on generalizing g with + | one => simp + | of s => simp [wordValue] + | inv_of s _ih => simp [pathChain_inv,wordValue] + | mul w z hw hz => + rw [pathChain_mul,map_add,hw,hz,map_mul] + simp only [mul_assoc] + abel + +abbrev cycles (v : S → Γ) := LinearMap.ker (edgeBoundary v) + +theorem relatorChainMap_boundary (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) : + (edgeBoundary v).comp (relatorChainMap v r) = 0 := by + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + simp [edgeBoundary_pathChain,hr] + +def relatorCycles (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) : BasedChains Γ R →ₗ[ℤ] cycles v := + (relatorChainMap v r).codRestrict _ (fun c => by + rw [LinearMap.mem_ker] + exact LinearMap.congr_fun (relatorChainMap_boundary v r hr) c) + +@[simp] theorem relatorCycles_coe (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (c : BasedChains Γ R) : + (relatorCycles v r hr c : BasedChains Γ S) = relatorChainMap v r c := rfl + +theorem wordValue_substitution (v : T → Γ) (f : S → FreeGroup T) (w : FreeGroup S) : + wordValue v (FreeGroup.lift f w) = wordValue (fun s => wordValue v (f s)) w := by + have h : (wordValue v).comp (FreeGroup.lift f) = + wordValue (fun s => wordValue v (f s)) := by + apply FreeGroup.ext_hom + intro s + simp [wordValue] + exact DFunLike.congr_fun h w + +/-- Naturality of the actual path chain under arbitrary finite-word substitution. -/ +theorem pathChain_substitution (v : T → Γ) (f : S → FreeGroup T) + (w : FreeGroup S) (g : Γ) : + relatorChainMap v f (pathChain (fun s => wordValue v (f s)) w g) = + pathChain v (FreeGroup.lift f w) g := by + induction w using FreeGroup.induction_on generalizing g with + | one => simp + | of s => simp + | inv_of s _ih => + simp only [pathChain_inv,map_neg,pathChain_of,relatorChainMap_single,one_smul, + map_inv,FreeGroup.lift_apply_of,wordValue] + | mul w z hw hz => + rw [pathChain_mul,map_add,hw,hz,map_mul,pathChain_mul,wordValue_substitution] + +theorem relatorChainMap_substitution (v : U → Γ) + (f : T → FreeGroup U) (e : S → FreeGroup T) : + (relatorChainMap v f).comp (relatorChainMap (fun t => wordValue v (f t)) e) = + relatorChainMap v (fun s => FreeGroup.lift f (e s)) := by + apply Finsupp.lhom_ext + rintro ⟨g,s⟩ n + simp [pathChain_substitution] + +@[simp] theorem relatorChainMap_of (v : S → Γ) : + relatorChainMap v FreeGroup.of = LinearMap.id := by + apply Finsupp.lhom_ext + rintro ⟨g,s⟩ n + simp + +end CycleSpaces +end EilenbergGanea + +namespace EilenbergGanea +section SumChains +variable {Γ S T : Type*} + +def sumChainsEquiv : BasedChains Γ (S ⊕ T) ≃ₗ[ℤ] BasedChains Γ S × BasedChains Γ T := + (Finsupp.domLCongr (Equiv.prodSumDistrib Γ S T)).trans (Finsupp.sumFinsuppLEquivProdFinsupp ℤ) + +@[simp] theorem sumChainsEquiv_fst (c : BasedChains Γ (S ⊕ T)) (g : Γ) (s : S) : + (sumChainsEquiv c).1 (g,s) = c (g,Sum.inl s) := by + rfl + +@[simp] theorem sumChainsEquiv_snd (c : BasedChains Γ (S ⊕ T)) (g : Γ) (t : T) : + (sumChainsEquiv c).2 (g,t) = c (g,Sum.inr t) := by + rfl + +@[simp] theorem sumChainsEquiv_single_left (g : Γ) (s : S) (n : ℤ) : + sumChainsEquiv (Finsupp.single (g,Sum.inl s) n : BasedChains Γ (S ⊕ T)) = + (Finsupp.single (g,s) n,0) := by + classical + apply Prod.ext + · ext ⟨h,i⟩ + simp [Finsupp.single_apply] + · ext ⟨h,i⟩ + simp + +@[simp] theorem sumChainsEquiv_single_right (g : Γ) (t : T) (n : ℤ) : + sumChainsEquiv (Finsupp.single (g,Sum.inr t) n : BasedChains Γ (S ⊕ T)) = + (0,Finsupp.single (g,t) n) := by + classical + apply Prod.ext + · ext ⟨h,i⟩ + simp + · ext ⟨h,i⟩ + simp [Finsupp.single_apply] + +end SumChains +end EilenbergGanea + +namespace EilenbergGanea +section TrivialGenerators +variable {Γ S T : Type*} [Group Γ] + +theorem edgeBoundary_sum_trivial (v : S → Γ) (c : BasedChains Γ (S ⊕ T)) : + edgeBoundary (Sum.elim v (fun _ : T => 1)) c = + edgeBoundary v (sumChainsEquiv c).1 := by + have h : edgeBoundary (Sum.elim v (fun _ : T => 1)) = + (edgeBoundary v).comp ((LinearMap.fst ℤ _ _).comp sumChainsEquiv.toLinearMap) := by + apply Finsupp.lhom_ext + rintro ⟨g,s | t⟩ n <;> simp + exact LinearMap.congr_fun h c + +/-- A trivial extra generator contributes an +independent free summand to the cycle module, with no cardinality restriction. -/ +def cycleSumEquiv (v : S → Γ) : + cycles (Sum.elim v (fun _ : T => 1)) ≃ₗ[ℤ] cycles v × BasedChains Γ T where + toFun c := (⟨(sumChainsEquiv c.val).1, by + rw [LinearMap.mem_ker, ← edgeBoundary_sum_trivial] + exact c.property⟩, (sumChainsEquiv c.val).2) + invFun c := ⟨sumChainsEquiv.symm (c.1.val,c.2), by + rw [LinearMap.mem_ker,edgeBoundary_sum_trivial,LinearEquiv.apply_symm_apply] + exact c.1.property⟩ + left_inv c := by + apply Subtype.ext + exact sumChainsEquiv.symm_apply_apply c.val + right_inv c := by + apply Prod.ext + · apply Subtype.ext + exact congrArg Prod.fst (sumChainsEquiv.apply_symm_apply (c.1.val,c.2)) + · exact congrArg (fun p : BasedChains Γ S × BasedChains Γ T => p.2) (sumChainsEquiv.apply_symm_apply (c.1.val,c.2)) + map_add' c d := by + apply Prod.ext + · apply Subtype.ext + exact congrArg Prod.fst (sumChainsEquiv.map_add c.val d.val) + · exact congrArg (fun p : BasedChains Γ S × BasedChains Γ T => p.2) (sumChainsEquiv.map_add c.val d.val) + map_smul' n c := by + apply Prod.ext + · apply Subtype.ext + exact congrArg Prod.fst (sumChainsEquiv.map_smul n c.val) + · exact congrArg (fun p : BasedChains Γ S × BasedChains Γ T => p.2) (sumChainsEquiv.map_smul n c.val) + +end TrivialGenerators +end EilenbergGanea + +namespace EilenbergGanea +section WordEquivalence +variable {Γ S T : Type*} [Group Γ] + +theorem pathChain_hom (v : S → Γ) (w : T → Γ) (e : FreeGroup S →* FreeGroup T) + (he : (wordValue w).comp e = wordValue v) (a : FreeGroup S) (g : Γ) : + relatorChainMap w (fun s => e (FreeGroup.of s)) (pathChain v a g) = + pathChain w (e a) g := by + have hv : (fun s => wordValue w (e (FreeGroup.of s))) = v := by + funext s + simpa [wordValue] using DFunLike.congr_fun he (FreeGroup.of s) + have hl : FreeGroup.lift (fun s => e (FreeGroup.of s)) = e := by + apply FreeGroup.ext_hom + intro s + simp + rw [← hv,pathChain_substitution,hl] + +theorem edgeBoundary_hom (v : S → Γ) (w : T → Γ) (e : FreeGroup S →* FreeGroup T) + (he : (wordValue w).comp e = wordValue v) : + (edgeBoundary w).comp (relatorChainMap w (fun s => e (FreeGroup.of s))) = edgeBoundary v := by + apply Finsupp.lhom_ext + rintro ⟨g,s⟩ n + have hs : wordValue w (e (FreeGroup.of s)) = v s := by + simpa [wordValue] using DFunLike.congr_fun he (FreeGroup.of s) + simp [edgeBoundary_pathChain,hs] + +/-- An honest free-generator equivalence gives an invertible integral edge-chain +map; the path chains, not only their augmented exponent sums, are transported. -/ +def wordChainEquiv (v : S → Γ) (w : T → Γ) (e : FreeGroup S ≃* FreeGroup T) + (he : (wordValue w).comp e.toMonoidHom = wordValue v) : + BasedChains Γ S ≃ₗ[ℤ] BasedChains Γ T where + __ := relatorChainMap w (fun s => e (FreeGroup.of s)) + invFun := relatorChainMap v (fun t => e.symm (FreeGroup.of t)) + left_inv c := by + have hi : (wordValue v).comp e.symm.toMonoidHom = wordValue w := by + ext t + have h := DFunLike.congr_fun he (e.symm (FreeGroup.of t)) + simpa using h.symm + have hh : (relatorChainMap v (fun t => e.symm (FreeGroup.of t))).comp + (relatorChainMap w (fun s => e (FreeGroup.of s))) = LinearMap.id := by + apply Finsupp.lhom_ext + rintro ⟨g,s⟩ n + simp only [LinearMap.comp_apply, relatorChainMap_single, map_zsmul, + LinearMap.id_coe, id_eq] + have hh := pathChain_hom w v e.symm.toMonoidHom hi (e (FreeGroup.of s)) g + simpa using congrArg (n • ·) hh + exact LinearMap.congr_fun hh c + right_inv c := by + have hh : (relatorChainMap w (fun s => e (FreeGroup.of s))).comp + (relatorChainMap v (fun t => e.symm (FreeGroup.of t))) = LinearMap.id := by + apply Finsupp.lhom_ext + rintro ⟨g,t⟩ n + simp only [LinearMap.comp_apply, relatorChainMap_single, map_zsmul, + LinearMap.id_coe, id_eq] + have hh := pathChain_hom v w e.toMonoidHom he (e.symm (FreeGroup.of t)) g + simpa using congrArg (n • ·) hh + exact LinearMap.congr_fun hh c + +/-- Invertible change of free generators preserves the full cycle module. -/ +def wordCycleEquiv (v : S → Γ) (w : T → Γ) (e : FreeGroup S ≃* FreeGroup T) + (he : (wordValue w).comp e.toMonoidHom = wordValue v) : cycles v ≃ₗ[ℤ] cycles w := + (wordChainEquiv v w e he).ofSubmodules (cycles v) (cycles w) (by + ext c + rw [Submodule.mem_map_equiv] + change edgeBoundary v ((wordChainEquiv v w e he).symm c) = 0 ↔ edgeBoundary w c = 0 + have h := LinearMap.congr_fun (edgeBoundary_hom v w e.toMonoidHom he) + ((wordChainEquiv v w e he).symm c) + change edgeBoundary w (wordChainEquiv v w e he ((wordChainEquiv v w e he).symm c)) = + edgeBoundary v ((wordChainEquiv v w e he).symm c) at h + rw [LinearEquiv.apply_symm_apply] at h + rw [← h]) + +end WordEquivalence +end EilenbergGanea + +namespace EilenbergGanea +section TrivialPresentationExtension +variable {Γ S T R : Type*} [Group Γ] + +def eraseExtra : FreeGroup (S ⊕ T) →* FreeGroup S := + FreeGroup.lift (Sum.elim FreeGroup.of (fun _ => 1)) + +def unitExtendedRelators (r : R → FreeGroup S) : R ⊕ T → FreeGroup (S ⊕ T) := + Sum.elim (fun i => FreeGroup.map Sum.inl (r i)) (fun t => FreeGroup.of (.inr t)) + +theorem unitExtendedRelators_trivial (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (i : R ⊕ T) : + wordValue (Sum.elim v (fun _ : T => 1)) (unitExtendedRelators r i) = 1 := by + rcases i with i | t + · change wordValue _ (FreeGroup.map Sum.inl (r i)) = 1 + have he : (wordValue (Sum.elim v (fun _ : T => 1))).comp (FreeGroup.map Sum.inl) = + wordValue v := by + apply FreeGroup.ext_hom + intro s + simp [wordValue] + exact (DFunLike.congr_fun he (r i)).trans (hr i) + · simp [unitExtendedRelators,wordValue] + +/-- Adjoining arbitrarily many generators of value one and their unit relators +preserves the actual presentation, not merely its abelianization. -/ +theorem unitExtension_normalClosure (v : S → Γ) (r : R → FreeGroup S) + (hp : (wordValue v).ker = Subgroup.normalClosure (Set.range r)) : + (wordValue (Sum.elim v (fun _ : T => 1))).ker = + Subgroup.normalClosure (Set.range (unitExtendedRelators r : R ⊕ T → _)) := by + let N := Subgroup.normalClosure (Set.range (unitExtendedRelators r : R ⊕ T → _)) + have hr (i) : wordValue v (r i) = 1 := by + change r i ∈ (wordValue v).ker + rw [hp] + exact Subgroup.subset_normalClosure (Set.mem_range_self i) + apply le_antisymm + · intro w hw + have hcomp : (wordValue v).comp eraseExtra = + wordValue (Sum.elim v (fun _ : T => 1)) := by + apply FreeGroup.ext_hom + intro s + rcases s with s | t <;> simp [eraseExtra,wordValue] + have hker : eraseExtra w ∈ Subgroup.normalClosure (Set.range r) := by + rw [← hp] + exact (DFunLike.congr_fun hcomp w).trans hw + have hmap : FreeGroup.map Sum.inl (eraseExtra w) ∈ N := by + apply Subgroup.normalClosure_mono (s := (FreeGroup.map Sum.inl) '' Set.range r) + (by rintro _ ⟨a,⟨i,rfl⟩,rfl⟩; exact ⟨Sum.inl i,rfl⟩) + exact Subgroup.comap_normalClosure_image_ge _ (FreeGroup.map Sum.inl) hker + have heq : (QuotientGroup.mk' N : FreeGroup (S ⊕ T) →* _) = + ((QuotientGroup.mk' N).comp (FreeGroup.map Sum.inl)).comp eraseExtra := by + apply FreeGroup.ext_hom + intro s + rcases s with s | t + · simp [eraseExtra] + · simp only [MonoidHom.comp_apply,eraseExtra,FreeGroup.lift_apply_of,Sum.elim_inr,map_one] + apply (QuotientGroup.eq_one_iff _).mpr + exact Subgroup.subset_normalClosure ⟨Sum.inr t,rfl⟩ + apply (QuotientGroup.eq_one_iff _).mp + change (QuotientGroup.mk' N) w = 1 + rw [DFunLike.congr_fun heq w] + exact (QuotientGroup.eq_one_iff _).mpr hmap + · exact normal_relators_trivial _ _ (unitExtendedRelators_trivial v r hr) + +/-- The chain matrix of adjoining unit relators is a block diagonal matrix. -/ +theorem unitExtension_chain (v : S → Γ) (r : R → FreeGroup S) + (c : BasedChains Γ (R ⊕ T)) : + sumChainsEquiv (relatorChainMap (Sum.elim v (fun _ : T => 1)) + (unitExtendedRelators r) c) = + (relatorChainMap v r (sumChainsEquiv c).1,(sumChainsEquiv c).2) := by + have hi (w : FreeGroup S) (g : Γ) : + sumChainsEquiv (pathChain (Sum.elim v (fun _ : T => 1)) (FreeGroup.map Sum.inl w) g) = + (pathChain v w g,0) := by + induction w using FreeGroup.induction_on generalizing g with + | one => simp only [map_one,pathChain_one,map_zero]; rfl + | of s => simp + | inv_of s _ih => simp [pathChain_inv,wordValue] + | mul w z hw hz => + have hv : wordValue (Sum.elim v (fun _ : T => 1)) (FreeGroup.map Sum.inl w) = wordValue v w := by + have h : (wordValue (Sum.elim v (fun _ : T => 1))).comp (FreeGroup.map Sum.inl) = wordValue v := by + apply FreeGroup.ext_hom + intro s + simp [wordValue] + exact DFunLike.congr_fun h w + simp only [map_mul,pathChain_mul,map_add,hw,hz,hv,Prod.mk_add_mk,add_zero] + have he : sumChainsEquiv.toLinearMap.comp (relatorChainMap + (Sum.elim v (fun _ : T => 1)) (unitExtendedRelators r)) = + (((relatorChainMap v r).comp (LinearMap.fst ℤ _ _)).prod + (LinearMap.snd ℤ _ _)).comp sumChainsEquiv.toLinearMap := by + apply Finsupp.lhom_ext + rintro ⟨g,i | t⟩ n + · simp [unitExtendedRelators,hi] + · simp [unitExtendedRelators] + exact LinearMap.congr_fun he c + +end TrivialPresentationExtension +end EilenbergGanea + +namespace EilenbergGanea +section UnitExtensionBasis +variable {Γ S T R : Type*} [Group Γ] + +/-- Completely explicit stabilization of a boundary-basis presentation. -/ +def unitExtensionBasis (v : S → Γ) (B : BasedChains Γ R ≃ₗ[ℤ] cycles v) : + BasedChains Γ (R ⊕ T) ≃ₗ[ℤ] cycles (Sum.elim v (fun _ : T => 1)) := + sumChainsEquiv.trans ((B.prodCongr (LinearEquiv.refl ℤ (BasedChains Γ T))).trans + (cycleSumEquiv v).symm) + +theorem unitExtensionBasis_value (v : S → Γ) (r : R → FreeGroup S) + (B : BasedChains Γ R ≃ₗ[ℤ] cycles v) + (hB : ∀ c, (B c : BasedChains Γ S) = relatorChainMap v r c) + (c : BasedChains Γ (R ⊕ T)) : + (unitExtensionBasis v B c : BasedChains Γ (S ⊕ T)) = + relatorChainMap (Sum.elim v (fun _ : T => 1)) (unitExtendedRelators r) c := by + apply sumChainsEquiv.injective + rw [unitExtension_chain] + change sumChainsEquiv (sumChainsEquiv.symm + ((B (sumChainsEquiv c).1).val,(sumChainsEquiv c).2)) = _ + rw [LinearEquiv.apply_symm_apply,hB] + +/-- Equivariance is automatic for an isomorphism whose columns are actual path +chains. This derives, rather than assumes, equivariance of its inverse. -/ +theorem chainBasisCoordinate_equivariant (v : S → Γ) + (r : R → FreeGroup S) (u : T → FreeGroup S) + (E : BasedChains Γ R ≃ₗ[ℤ] cycles v) + (B : BasedChains Γ T ≃ₗ[ℤ] cycles v) + (hE : ∀ c, (E c : BasedChains Γ S) = relatorChainMap v r c) + (hB : ∀ c, (B c : BasedChains Γ S) = relatorChainMap v u c) : + ChainsEquivariant (E.trans B.symm).toLinearMap := by + intro g c + apply B.injective + apply Subtype.ext + change (B (B.symm (E (translateChains g c)))).val = + (B (translateChains g (B.symm (E c)))).val + rw [B.apply_symm_apply,hE,hB,relatorChainMap_equivariant v u g] + rw [← hB,B.apply_symm_apply,hE] + exact relatorChainMap_equivariant v r g c + +end UnitExtensionBasis +end EilenbergGanea + +namespace EilenbergGanea +section Nielsen +variable {Γ S T A R : Type*} [Group Γ] + +def nielsenHom (a : T → FreeGroup S) : FreeGroup (S ⊕ T) →* FreeGroup (S ⊕ T) := + FreeGroup.lift (Sum.elim (fun s => FreeGroup.of (.inl s)) + (fun t => FreeGroup.of (.inr t) * FreeGroup.map Sum.inl (a t))) + +@[simp] theorem nielsenHom_of_left (a : T → FreeGroup S) (s : S) : + nielsenHom a (FreeGroup.of (.inl s)) = FreeGroup.of (.inl s) := by + simp [nielsenHom] + +@[simp] theorem nielsenHom_of_right (a : T → FreeGroup S) (t : T) : + nielsenHom a (FreeGroup.of (.inr t)) = + FreeGroup.of (.inr t) * FreeGroup.map Sum.inl (a t) := by + simp [nielsenHom] + +@[simp] theorem nielsenHom_left (a : T → FreeGroup S) (w : FreeGroup S) : + nielsenHom a (FreeGroup.map Sum.inl w) = FreeGroup.map Sum.inl w := by + have h : (nielsenHom a).comp (FreeGroup.map Sum.inl) = FreeGroup.map Sum.inl := by + apply FreeGroup.ext_hom + intro s + simp [nielsenHom] + exact DFunLike.congr_fun h w + +def nielsenEquiv (a : T → FreeGroup S) : FreeGroup (S ⊕ T) ≃* FreeGroup (S ⊕ T) where + __ := nielsenHom a + invFun := nielsenHom (fun t => (a t)⁻¹) + left_inv w := by + have h : (nielsenHom (fun t => (a t)⁻¹)).comp (nielsenHom a) = MonoidHom.id _ := by + apply FreeGroup.ext_hom + intro s + rcases s with s | t <;> simp [mul_assoc] + exact DFunLike.congr_fun h w + right_inv w := by + have h : (nielsenHom a).comp (nielsenHom (fun t => (a t)⁻¹)) = MonoidHom.id _ := by + apply FreeGroup.ext_hom + intro s + rcases s with s | t <;> simp [mul_assoc] + exact DFunLike.congr_fun h w + +@[simp] theorem nielsenEquiv_apply (a : T → FreeGroup S) (w : FreeGroup (S ⊕ T)) : + nielsenEquiv a w = nielsenHom a w := rfl + +theorem nielsen_wordValue (v : S → Γ) (w : T → Γ) (a : T → FreeGroup S) : + (wordValue (Sum.elim v w)).comp (nielsenEquiv a).toMonoidHom = + wordValue (Sum.elim v (fun t => w t * wordValue v (a t))) := by + have hi (u : FreeGroup S) : wordValue (Sum.elim v w) (FreeGroup.map Sum.inl u) = + wordValue v u := by + have h : (wordValue (Sum.elim v w)).comp (FreeGroup.map Sum.inl) = wordValue v := by + apply FreeGroup.ext_hom + intro s + simp [wordValue] + exact DFunLike.congr_fun h u + apply FreeGroup.ext_hom + intro s + rcases s with s | t + · simp [nielsenHom,wordValue] + · change wordValue (Sum.elim v w) (nielsenHom a (FreeGroup.of (.inr t))) = _ + rw [nielsenHom_of_right,map_mul,hi] + simp [wordValue] + +theorem wordPresentation_transport (v : S → Γ) (w : T → Γ) + (e : FreeGroup S ≃* FreeGroup T) + (he : (wordValue w).comp e.toMonoidHom = wordValue v) + (r : R → FreeGroup S) + (hp : (wordValue v).ker = Subgroup.normalClosure (Set.range r)) : + (wordValue w).ker = Subgroup.normalClosure (Set.range (fun i => e (r i))) := by + have hi : (wordValue v).comp e.symm.toMonoidHom = wordValue w := by + apply FreeGroup.ext_hom + intro t + simpa using (DFunLike.congr_fun he (e.symm (FreeGroup.of t))).symm + change (wordValue w).ker = Subgroup.normalClosure (Set.range (e ∘ r)) + rw [Set.range_comp] + change (wordValue w).ker = Subgroup.normalClosure (e.toMonoidHom '' Set.range r) + rw [← Subgroup.map_normalClosure _ e.toMonoidHom e.surjective, ← hp] + ext a + constructor + · intro ha + refine ⟨e.symm a,?_,e.apply_symm_apply a⟩ + exact (DFunLike.congr_fun hi a).trans ha + · rintro ⟨b,hb,rfl⟩ + exact (DFunLike.congr_fun he b).trans hb + +def wordBasisTransport (v : S → Γ) (w : T → Γ) + (e : FreeGroup S ≃* FreeGroup T) + (he : (wordValue w).comp e.toMonoidHom = wordValue v) + (B : BasedChains Γ R ≃ₗ[ℤ] cycles v) : BasedChains Γ R ≃ₗ[ℤ] cycles w := + B.trans (wordCycleEquiv v w e he) + +theorem wordBasisTransport_value (v : S → Γ) (w : T → Γ) + (e : FreeGroup S ≃* FreeGroup T) + (he : (wordValue w).comp e.toMonoidHom = wordValue v) + (B : BasedChains Γ R ≃ₗ[ℤ] cycles v) (r : R → FreeGroup S) + (hB : ∀ c, (B c : BasedChains Γ S) = relatorChainMap v r c) + (c : BasedChains Γ R) : + (wordBasisTransport v w e he B c : BasedChains Γ T) = + relatorChainMap w (fun i => e (r i)) c := by + change relatorChainMap w (fun s => e (FreeGroup.of s)) (B c).val = _ + rw [hB] + have hh : (relatorChainMap w (fun s => e (FreeGroup.of s))).comp (relatorChainMap v r) = + relatorChainMap w (fun i => e (r i)) := by + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + simp only [LinearMap.comp_apply,relatorChainMap_single,map_zsmul] + exact congrArg (n • ·) (pathChain_hom v w e.toMonoidHom he (r i) g) + exact LinearMap.congr_fun hh c + +end Nielsen +end EilenbergGanea + +namespace EilenbergGanea +section GeneratorAlignment +variable {Γ S T A R : Type*} [Group Γ] + +def freeGroupCongr (e : S ≃ T) : FreeGroup S ≃* FreeGroup T where + __ := FreeGroup.map e + invFun := FreeGroup.map e.symm + left_inv w := by simpa [Function.comp_def] using FreeGroup.map.comp e e.symm w + right_inv w := by simpa [Function.comp_def] using FreeGroup.map.comp e.symm e w + +@[simp] theorem freeGroupCongr_apply (e : S ≃ T) (w : FreeGroup S) : + freeGroupCongr e w = FreeGroup.map e w := rfl + +theorem wordValue_congr_alphabet (v : S → Γ) (w : T → Γ) (e : S ≃ T) + (h : ∀ s, w (e s) = v s) : + (wordValue w).comp (freeGroupCongr e).toMonoidHom = wordValue v := by + apply FreeGroup.ext_hom + intro s + simpa [wordValue] using h s + +theorem wordRelators_transport_trivial (v : S → Γ) (w : T → Γ) + (e : FreeGroup S ≃* FreeGroup T) + (he : (wordValue w).comp e.toMonoidHom = wordValue v) + (r : R → FreeGroup S) (hr : ∀ i, wordValue v (r i) = 1) : + ∀ i, wordValue w (e (r i)) = 1 := by + intro i + exact (DFunLike.congr_fun he (r i)).trans (hr i) + +/-- Generator change starting with an actual boundary-basis presentation, +not with an assumed aligned one. -/ +theorem align_generators (v : S → Γ) (hv : Function.Surjective (wordValue v)) + (a : A → Γ) (ha : Function.Surjective (wordValue a)) + (r : R → FreeGroup A) (hr : ∀ i, wordValue a (r i) = 1) + (hp : (wordValue a).ker = Subgroup.normalClosure (Set.range r)) + (B : BasedChains Γ R ≃ₗ[ℤ] cycles a) + (hB : ∀ c, (B c : BasedChains Γ A) = relatorChainMap a r c) : + ∃ (r' : R ⊕ S → FreeGroup (S ⊕ A)) + (B' : BasedChains Γ (R ⊕ S) ≃ₗ[ℤ] cycles (Sum.elim v (fun _ : A => 1))), + (∀ i, wordValue (Sum.elim v (fun _ : A => 1)) (r' i) = 1) ∧ + (wordValue (Sum.elim v (fun _ : A => 1))).ker = + Subgroup.normalClosure (Set.range r') ∧ + ∀ c, (B' c : BasedChains Γ (S ⊕ A)) = + relatorChainMap (Sum.elim v (fun _ : A => 1)) r' c := by + classical + choose f hf using fun s => ha (v s) + choose g hg using fun t => hv (a t) + let v₀ : A ⊕ S → Γ := Sum.elim a (fun _ => 1) + let v₁ : A ⊕ S → Γ := Sum.elim a v + let v₂ : S ⊕ A → Γ := Sum.elim v a + let v₃ : S ⊕ A → Γ := Sum.elim v (fun _ => 1) + let e₁ := nielsenEquiv (fun s => (f s)⁻¹) + let e₂ := freeGroupCongr (Equiv.sumComm A S) + let e₃ := nielsenEquiv g + have he₁ : (wordValue v₁).comp e₁.toMonoidHom = wordValue v₀ := by + change (wordValue (Sum.elim a v)).comp + (nielsenEquiv (fun s => (f s)⁻¹)).toMonoidHom = _ + simpa only [map_inv,hf,mul_inv_cancel] using + nielsen_wordValue a v (fun s => (f s)⁻¹) + have he₂ : (wordValue v₂).comp e₂.toMonoidHom = wordValue v₁ := by + apply wordValue_congr_alphabet + intro s + rcases s with t | s <;> rfl + have he₃ : (wordValue v₃).comp e₃.toMonoidHom = wordValue v₂ := by + change (wordValue (Sum.elim v (fun _ : A => 1))).comp + (nielsenEquiv g).toMonoidHom = _ + simpa only [one_mul,hg] using nielsen_wordValue v (fun _ : A => 1) g + let r₀ : R ⊕ S → FreeGroup (A ⊕ S) := unitExtendedRelators r + let r₁ : R ⊕ S → FreeGroup (A ⊕ S) := fun i => e₁ (r₀ i) + let r₂ : R ⊕ S → FreeGroup (S ⊕ A) := fun i => e₂ (r₁ i) + let r₃ : R ⊕ S → FreeGroup (S ⊕ A) := fun i => e₃ (r₂ i) + let B₀ : BasedChains Γ (R ⊕ S) ≃ₗ[ℤ] cycles v₀ := unitExtensionBasis a B + let B₁ := wordBasisTransport v₀ v₁ e₁ he₁ B₀ + let B₂ := wordBasisTransport v₁ v₂ e₂ he₂ B₁ + let B₃ := wordBasisTransport v₂ v₃ e₃ he₃ B₂ + have hr₀ : ∀ i, wordValue v₀ (r₀ i) = 1 := unitExtendedRelators_trivial a r hr + have hr₁ := wordRelators_transport_trivial v₀ v₁ e₁ he₁ r₀ hr₀ + have hr₂ := wordRelators_transport_trivial v₁ v₂ e₂ he₂ r₁ hr₁ + have hr₃ := wordRelators_transport_trivial v₂ v₃ e₃ he₃ r₂ hr₂ + have hp₀ : (wordValue v₀).ker = Subgroup.normalClosure (Set.range r₀) := + unitExtension_normalClosure a r hp + have hp₁ := wordPresentation_transport v₀ v₁ e₁ he₁ r₀ hp₀ + have hp₂ := wordPresentation_transport v₁ v₂ e₂ he₂ r₁ hp₁ + have hp₃ := wordPresentation_transport v₂ v₃ e₃ he₃ r₂ hp₂ + have hB₀ : ∀ c, (B₀ c : BasedChains Γ (A ⊕ S)) = relatorChainMap v₀ r₀ c := + unitExtensionBasis_value a r B hB + have hB₁ := wordBasisTransport_value v₀ v₁ e₁ he₁ B₀ r₀ hB₀ + have hB₂ := wordBasisTransport_value v₁ v₂ e₂ he₂ B₁ r₁ hB₁ + have hB₃ := wordBasisTransport_value v₂ v₃ e₃ he₃ B₂ r₂ hB₂ + exact ⟨r₃,B₃,hr₃,hp₃,hB₃⟩ + +end GeneratorAlignment +end EilenbergGanea + +namespace EilenbergGanea +section RelatorBlocks +variable {Γ S T R I : Type*} [Group Γ] + +theorem relatorChainMap_sum (v : S → Γ) (r : R → FreeGroup S) (u : I → FreeGroup S) + (c : BasedChains Γ (R ⊕ I)) : + relatorChainMap v (Sum.elim r u) c = + relatorChainMap v r (sumChainsEquiv c).1 + relatorChainMap v u (sumChainsEquiv c).2 := by + have h : relatorChainMap v (Sum.elim r u) = + ((relatorChainMap v r).comp (LinearMap.fst ℤ _ _) + + (relatorChainMap v u).comp (LinearMap.snd ℤ _ _)).comp sumChainsEquiv.toLinearMap := by + apply Finsupp.lhom_ext + rintro ⟨g,i | j⟩ n <;> simp + exact LinearMap.congr_fun h c + +theorem sumChains_pathChain_left (v : S → Γ) (w : FreeGroup S) (g : Γ) : + sumChainsEquiv (pathChain (Sum.elim v (fun _ : T => 1)) (FreeGroup.map Sum.inl w) g) = + (pathChain v w g,0) := by + induction w using FreeGroup.induction_on generalizing g with + | one => simp only [map_one,pathChain_one,map_zero]; rfl + | of s => simp + | inv_of s _ih => simp [pathChain_inv,wordValue] + | mul w z hw hz => + have hv : wordValue (Sum.elim v (fun _ : T => 1)) (FreeGroup.map Sum.inl w) = wordValue v w := by + have h : (wordValue (Sum.elim v (fun _ : T => 1))).comp (FreeGroup.map Sum.inl) = wordValue v := by + apply FreeGroup.ext_hom + intro s + simp [wordValue] + exact DFunLike.congr_fun h w + simp only [map_mul,pathChain_mul,map_add,hw,hz,hv,Prod.mk_add_mk,add_zero] + +theorem sumChains_relatorMap_left (v : S → Γ) (r : R → FreeGroup S) (c : BasedChains Γ R) : + sumChainsEquiv (relatorChainMap (Sum.elim v (fun _ : T => 1)) + (fun i => FreeGroup.map Sum.inl (r i)) c) = (relatorChainMap v r c,0) := by + have h : sumChainsEquiv.toLinearMap.comp (relatorChainMap + (Sum.elim v (fun _ : T => 1)) (fun i => FreeGroup.map Sum.inl (r i))) = + (relatorChainMap v r).prod 0 := by + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + simp [sumChains_pathChain_left] + exact LinearMap.congr_fun h c + +theorem sumChains_relatorMap_right (v : S → Γ) (c : BasedChains Γ T) : + sumChainsEquiv (relatorChainMap (Sum.elim v (fun _ : T => 1)) + (fun i => FreeGroup.of (.inr i)) c) = (0,c) := by + have h : sumChainsEquiv.toLinearMap.comp (relatorChainMap + (Sum.elim v (fun _ : T => 1)) (fun i => FreeGroup.of (.inr i))) = + (0 : BasedChains Γ T →ₗ[ℤ] BasedChains Γ S).prod LinearMap.id := by + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + simp + exact LinearMap.congr_fun h c + +theorem range_sumElim {α β γ : Type*} (f : α → γ) (g : β → γ) : + Set.range (Sum.elim f g) = Set.range f ∪ Set.range g := by + ext x + constructor + · rintro ⟨a | b,rfl⟩ + · exact Or.inl ⟨a,rfl⟩ + · exact Or.inr ⟨b,rfl⟩ + · rintro (⟨a,rfl⟩ | ⟨b,rfl⟩) + · exact ⟨Sum.inl a,rfl⟩ + · exact ⟨Sum.inr b,rfl⟩ + +/-- The stabilized three-shear conclusion in exact cycle coordinates. This +includes injectivity for the entire new boundary list, even for infinite sets. -/ +theorem stabilized_alignment (v : S → Γ) (hv : Function.Surjective (wordValue v)) + (r : R → FreeGroup S) (z : I → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (_hz : ∀ i, wordValue v (z i) = 1) + (hp : (wordValue v).ker = Subgroup.normalClosure (Set.range r)) + (E : BasedChains Γ R ≃ₗ[ℤ] cycles v) (B : BasedChains Γ I ≃ₗ[ℤ] cycles v) + (hE : ∀ c, (E c : BasedChains Γ S) = relatorChainMap v r c) + (hB : ∀ c, (B c : BasedChains Γ S) = relatorChainMap v z c) : + ∃ (r' : R → FreeGroup (S ⊕ I)) (u' : I → FreeGroup (S ⊕ I)), + (∀ i, wordValue (Sum.elim v (fun _ : I => 1)) (r' i) = 1) ∧ + (∀ i, wordValue (Sum.elim v (fun _ : I => 1)) (u' i) = 1) ∧ + (wordValue (Sum.elim v (fun _ : I => 1))).ker = + Subgroup.normalClosure (Set.range (Sum.elim r' u')) ∧ + Function.Injective (relatorChainMap (Sum.elim v (fun _ : I => 1)) (Sum.elim r' u')) ∧ + (∀ c, sumChainsEquiv (relatorChainMap (Sum.elim v (fun _ : I => 1)) r' c) = + (0,-(E.trans B.symm) c)) ∧ + ∀ c, sumChainsEquiv (relatorChainMap (Sum.elim v (fun _ : I => 1)) u' c) = + ((B c).val,0) := by + let w : S ⊕ I → Γ := Sum.elim v (fun _ => 1) + let r₀ : R → FreeGroup (S ⊕ I) := fun i => FreeGroup.map Sum.inl (r i) + let u₀ : I → FreeGroup (S ⊕ I) := fun i => FreeGroup.of (.inr i) + let A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ I := E.trans B.symm + have hA : ChainsEquivariant A.toLinearMap := chainBasisCoordinate_equivariant v r z E B hE hB + have hw : Function.Surjective (wordValue w) := by + intro g + obtain ⟨a,ha⟩ := hv g + refine ⟨FreeGroup.map Sum.inl a,?_⟩ + have h : (wordValue w).comp (FreeGroup.map Sum.inl) = wordValue v := by + apply FreeGroup.ext_hom + intro s + simp [wordValue,w] + exact (DFunLike.congr_fun h a).trans ha + have hr₀ : ∀ i, wordValue w (r₀ i) = 1 := fun i => + unitExtendedRelators_trivial v r hr (.inl i) + have hu₀ : ∀ i, wordValue w (u₀ i) = 1 := fun i => + unitExtendedRelators_trivial v r hr (.inr i) + obtain ⟨r',u',hr',hu',hN,hDr,hDu⟩ := block_word_alignment w hw r₀ u₀ hr₀ hu₀ A hA + have hcr (c) : sumChainsEquiv (relatorChainMap w r' c) = (0,-A c) := by + rw [hDr,LinearMap.neg_apply,LinearMap.comp_apply,map_neg] + rw [sumChains_relatorMap_right] + rfl + have hcu (c) : sumChainsEquiv (relatorChainMap w u' c) = ((B c).val,0) := by + rw [hDu,LinearMap.comp_apply,sumChains_relatorMap_left,← hE] + simp [A] + have hinj : Function.Injective (relatorChainMap w (Sum.elim r' u')) := by + have hz₀ (c) (hc : relatorChainMap w (Sum.elim r' u') c = 0) : c = 0 := by + have h := congrArg sumChainsEquiv hc + rw [relatorChainMap_sum,map_add,hcr,hcu,map_zero] at h + have hi : (sumChainsEquiv c).2 = 0 := by + apply B.injective + apply Subtype.ext + simpa only [Prod.mk_add_mk,zero_add,Prod.fst_zero,map_zero,Submodule.coe_zero] using congrArg Prod.fst h + have hr0 : (sumChainsEquiv c).1 = 0 := by + apply A.injective + simpa only [Prod.mk_add_mk,add_zero,Prod.snd_zero,neg_eq_zero,map_zero] using congrArg Prod.snd h + apply sumChainsEquiv.injective + exact Prod.ext (by simpa using hr0) (by simpa using hi) + intro c d h + apply sub_eq_zero.mp + apply hz₀ + rw [map_sub,h,sub_self] + refine ⟨r',u',hr',hu',?_,hinj,hcr,hcu⟩ + rw [range_sumElim,hN] + simpa only [unitExtendedRelators,range_sumElim] using unitExtension_normalClosure (T := I) v r hp + +end RelatorBlocks +end EilenbergGanea + +namespace EilenbergGanea +section Reindexing +variable {Γ S T U R I : Type*} [Group Γ] + +def chainIndexEquiv (e : S ≃ T) : BasedChains Γ S ≃ₗ[ℤ] BasedChains Γ T := + Finsupp.domLCongr (Equiv.prodCongr (Equiv.refl Γ) e) + +omit [Group Γ] in +@[simp] theorem chainIndexEquiv_single (e : S ≃ T) (g : Γ) (s : S) (n : ℤ) : + chainIndexEquiv e (Finsupp.single (g,s) n) = Finsupp.single (g,e s) n := by + simp [chainIndexEquiv] + +theorem relatorChainMap_reindex (v : S → Γ) (r : R → FreeGroup S) (e : I ≃ R) + (c : BasedChains Γ I) : + relatorChainMap v (r ∘ e) c = relatorChainMap v r (chainIndexEquiv e c) := by + have h : relatorChainMap v (r ∘ e) = (relatorChainMap v r).comp (chainIndexEquiv e).toLinearMap := by + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + simp + exact LinearMap.congr_fun h c + +theorem chainIndexEquiv_pathChain (v : S → Γ) (w : T → Γ) (e : S ≃ T) + (he : ∀ s, w (e s) = v s) (a : FreeGroup S) (g : Γ) : + chainIndexEquiv e (pathChain v a g) = pathChain w (freeGroupCongr e a) g := by + have hl : relatorChainMap w (fun s => freeGroupCongr e (FreeGroup.of s)) = + (chainIndexEquiv e).toLinearMap := by + apply Finsupp.lhom_ext + rintro ⟨h,s⟩ n + simp + change (chainIndexEquiv e).toLinearMap _ = _ + rw [← hl] + exact pathChain_hom v w (freeGroupCongr e).toMonoidHom (wordValue_congr_alphabet v w e he) a g + +theorem chainIndexEquiv_relatorMap (v : S → Γ) (w : T → Γ) (e : S ≃ T) + (he : ∀ s, w (e s) = v s) (r : R → FreeGroup S) (c : BasedChains Γ R) : + chainIndexEquiv e (relatorChainMap v r c) = + relatorChainMap w (fun i => freeGroupCongr e (r i)) c := by + have h : (chainIndexEquiv e).toLinearMap.comp (relatorChainMap v r) = + relatorChainMap w (fun i => freeGroupCongr e (r i)) := by + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + simp [chainIndexEquiv_pathChain v w e he] + exact LinearMap.congr_fun h c + +/-- Permutation of the stabilized relator indices into distinguished and +ordinary blocks, in exactly the order of source (ordinary-diagonal). -/ +def alignmentIndexEquiv : I ⊕ (T ⊕ R) ≃ R ⊕ (I ⊕ T) where + toFun + | .inl i => .inr (.inl i) + | .inr (.inl t) => .inr (.inr t) + | .inr (.inr r) => .inl r + invFun + | .inl r => .inr (.inr r) + | .inr (.inl i) => .inl i + | .inr (.inr t) => .inr (.inl t) + left_inv := by rintro (i | (t | r)) <;> rfl + right_inv := by rintro (r | (i | t)) <;> rfl + +end Reindexing +end EilenbergGanea + +namespace EilenbergGanea +section ExtraProjectionAlignment +variable {Γ S T I R : Type*} [Group Γ] + +omit [Group Γ] in +theorem projectExtraChains_eq_sum_snd (c : BasedChains Γ (S ⊕ T)) : + projectExtraChains c = (sumChainsEquiv c).2 := by + have h : projectExtraChains = (LinearMap.snd ℤ _ _).comp + (sumChainsEquiv : BasedChains Γ (S ⊕ T) ≃ₗ[ℤ] _).toLinearMap := by + apply Finsupp.lhom_ext + rintro ⟨g,s | t⟩ n <;> simp + exact LinearMap.congr_fun h c + +omit [Group Γ] in +theorem chainIndexEquiv_sumAssoc (c : BasedChains Γ ((S ⊕ T) ⊕ I)) : + sumChainsEquiv (chainIndexEquiv (Equiv.sumAssoc S T I) c) = + ((sumChainsEquiv (sumChainsEquiv c).1).1, + sumChainsEquiv.symm ((sumChainsEquiv (sumChainsEquiv c).1).2,(sumChainsEquiv c).2)) := by + apply Prod.ext + · ext ⟨g,s⟩ + rfl + · apply sumChainsEquiv.injective + rw [LinearEquiv.apply_symm_apply] + apply Prod.ext + · ext ⟨g,t⟩ + rfl + · ext ⟨g,i⟩ + rfl + +omit [Group Γ] in +theorem projectExtraChains_assoc (c : BasedChains Γ ((S ⊕ T) ⊕ I)) : + sumChainsEquiv (projectExtraChains (chainIndexEquiv (Equiv.sumAssoc S T I) c)) = + ((sumChainsEquiv (sumChainsEquiv c).1).2,(sumChainsEquiv c).2) := by + rw [projectExtraChains_eq_sum_snd,chainIndexEquiv_sumAssoc,LinearEquiv.apply_symm_apply] + +/-- The ordinary diagonal block (1,-A), without finite-rank assumptions. -/ +def ordinaryBlockEquiv (A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ I) : + BasedChains Γ (T ⊕ R) ≃ₗ[ℤ] BasedChains Γ (T ⊕ I) := + sumChainsEquiv.trans (((LinearEquiv.refl ℤ (BasedChains Γ T)).prodCongr + (A.trans (LinearEquiv.neg ℤ))).trans sumChainsEquiv.symm) + +omit [Group Γ] in +@[simp] theorem ordinaryBlockEquiv_value (A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ I) + (c : BasedChains Γ (T ⊕ R)) : + sumChainsEquiv (ordinaryBlockEquiv A c) = ((sumChainsEquiv c).1,-A (sumChainsEquiv c).2) := by + simp [ordinaryBlockEquiv] + +end ExtraProjectionAlignment +end EilenbergGanea + +namespace EilenbergGanea +section FinishedAlignment +variable {Γ S T R Z : Type*} [Group Γ] + +/-- Reorder the two stabilization blocks into the distinguished and ordinary +lists. The projected ordinary block is exactly `(1,-A)`, not only injective. -/ +theorem finish_alignment + (v : S → Γ) (z : Z → FreeGroup S) + (B : BasedChains Γ Z ≃ₗ[ℤ] cycles v) + (hB : ∀ c, (B c : BasedChains Γ S) = relatorChainMap v z c) + (A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ (Z ⊕ T)) + (r : R → FreeGroup ((S ⊕ T) ⊕ (Z ⊕ T))) + (u : Z ⊕ T → FreeGroup ((S ⊕ T) ⊕ (Z ⊕ T))) + (hr : ∀ i, wordValue (Sum.elim (Sum.elim v (fun _ : T => 1)) (fun _ : Z ⊕ T => 1)) (r i) = 1) + (hu : ∀ i, wordValue (Sum.elim (Sum.elim v (fun _ : T => 1)) (fun _ : Z ⊕ T => 1)) (u i) = 1) + (hp : (wordValue (Sum.elim (Sum.elim v (fun _ : T => 1)) (fun _ : Z ⊕ T => 1))).ker = + Subgroup.normalClosure (Set.range (Sum.elim r u))) + (hinj : Function.Injective (relatorChainMap + (Sum.elim (Sum.elim v (fun _ : T => 1)) (fun _ : Z ⊕ T => 1)) (Sum.elim r u))) + (hcr : ∀ c, sumChainsEquiv (relatorChainMap + (Sum.elim (Sum.elim v (fun _ : T => 1)) (fun _ : Z ⊕ T => 1)) r c) = (0,-A c)) + (hcu : ∀ c, sumChainsEquiv (relatorChainMap + (Sum.elim (Sum.elim v (fun _ : T => 1)) (fun _ : Z ⊕ T => 1)) u c) = + ((unitExtensionBasis v B c).val,0)) : + ∃ r' : Z ⊕ (T ⊕ R) → FreeGroup (S ⊕ (T ⊕ (Z ⊕ T))), + (∀ i, wordValue (Sum.elim v (fun _ : T ⊕ (Z ⊕ T) => 1)) (r' i) = 1) ∧ + (wordValue (Sum.elim v (fun _ : T ⊕ (Z ⊕ T) => 1))).ker = + Subgroup.normalClosure (Set.range r') ∧ + Function.Injective (relatorChainMap (Sum.elim v (fun _ : T ⊕ (Z ⊕ T) => 1)) r') ∧ + (∀ i, pathChain (Sum.elim v (fun _ : T ⊕ (Z ⊕ T) => 1)) + (FreeGroup.map Sum.inl (z i)) 1 = + pathChain (Sum.elim v (fun _ : T ⊕ (Z ⊕ T) => 1)) (r' (.inl i)) 1) ∧ + (ordinaryBlockEquiv A).toLinearMap = extraRelatorMap + (Sum.elim v (fun _ : T ⊕ (Z ⊕ T) => 1)) (fun i => r' (.inr i)) := by + let w := Sum.elim (Sum.elim v (fun _ : T => 1)) (fun _ : Z ⊕ T => 1) + let w' := Sum.elim v (fun _ : T ⊕ (Z ⊕ T) => 1) + let e := Equiv.sumAssoc S T (Z ⊕ T) + let j : Z ⊕ (T ⊕ R) ≃ R ⊕ (Z ⊕ T) := alignmentIndexEquiv + have he : ∀ s, w' (e s) = w s := by rintro ((s | t) | i) <;> rfl + let f : R ⊕ (Z ⊕ T) → FreeGroup (S ⊕ (T ⊕ (Z ⊕ T))) := + fun i => freeGroupCongr e (Sum.elim r u i) + let r' := f ∘ j + have hrf : ∀ i, wordValue w' (f i) = 1 := by + intro i + have h := DFunLike.congr_fun (wordValue_congr_alphabet w w' e he) (Sum.elim r u i) + exact h.trans (by rcases i with i | i; exact hr i; exact hu i) + have hpf : (wordValue w').ker = Subgroup.normalClosure (Set.range f) := + wordPresentation_transport w w' (freeGroupCongr e) (wordValue_congr_alphabet w w' e he) _ hp + have hpr : (wordValue w').ker = Subgroup.normalClosure (Set.range r') := by + rw [hpf] + congr 1 + ext x + constructor + · rintro ⟨i,rfl⟩ + exact ⟨j.symm i,congrArg f (j.apply_symm_apply i)⟩ + · rintro ⟨i,rfl⟩ + exact ⟨j i,rfl⟩ + have hDf (c : BasedChains Γ (R ⊕ (Z ⊕ T))) : + relatorChainMap w' f c = chainIndexEquiv e (relatorChainMap w (Sum.elim r u) c) := + (chainIndexEquiv_relatorMap w w' e he _ c).symm + have hDr (c) : relatorChainMap w' r' c = + chainIndexEquiv e (relatorChainMap w (Sum.elim r u) (chainIndexEquiv j c)) := by + rw [relatorChainMap_reindex,hDf] + have hinjr : Function.Injective (relatorChainMap w' r') := by + intro a b h + rw [hDr,hDr] at h + exact (chainIndexEquiv j).injective (hinj ((chainIndexEquiv e).injective h)) + have hcU (c : BasedChains Γ (Z ⊕ T)) : + sumChainsEquiv (sumChainsEquiv (relatorChainMap w u c)).1 = + ((B (sumChainsEquiv c).1).val,(sumChainsEquiv c).2) := by + rw [hcu] + change sumChainsEquiv (sumChainsEquiv.symm _) = _ + exact LinearEquiv.apply_symm_apply _ _ + have hd (i : Z) : pathChain w' (FreeGroup.map Sum.inl (z i)) 1 = + pathChain w' (r' (.inl i)) 1 := by + have h := hcu (Finsupp.single (1,Sum.inl i) 1) + have h' := hcU (Finsupp.single (1,Sum.inl i) 1) + simp only [relatorChainMap_single,one_smul,sumChainsEquiv_single_left] at h h' + apply (sumChainsEquiv : BasedChains Γ (S ⊕ (T ⊕ (Z ⊕ T))) ≃ₗ[ℤ] _).injective + have hh : pathChain w' (r' (.inl i)) 1 = chainIndexEquiv e (pathChain w (u (.inl i)) 1) := + (chainIndexEquiv_pathChain w w' e he _ _).symm + rw [hh] + rw [sumChains_pathChain_left,chainIndexEquiv_sumAssoc] + rw [h] + rw [h] at h' + rw [h'] + simp only [hB,relatorChainMap_single,one_smul] + change (_,0) = (_,sumChainsEquiv.symm (0 : BasedChains Γ T × BasedChains Γ (Z ⊕ T))) + rw [map_zero] + have hQ : (ordinaryBlockEquiv A).toLinearMap = extraRelatorMap w' (fun i => r' (.inr i)) := by + apply Finsupp.lhom_ext + rintro ⟨g,t | i⟩ n + · apply sumChainsEquiv.injective + have hh : pathChain w' (r' (.inr (.inl t))) g = + chainIndexEquiv e (pathChain w (u (.inr t)) g) := + (chainIndexEquiv_pathChain w w' e he _ _).symm + simp only [LinearEquiv.coe_coe,ordinaryBlockEquiv_value,sumChainsEquiv_single_left, + map_zero,neg_zero,extraRelatorMap_single,hh,← map_smul] + have hsingle : n • pathChain w (u (.inr t)) g = + relatorChainMap w u (Finsupp.single (g,Sum.inr t) n) := by simp + rw [hsingle,projectExtraChains_assoc,hcu] + have hh' := hcU (Finsupp.single (g,Sum.inr t) n) + rw [hcu] at hh' + simp only [sumChainsEquiv_single_right,map_zero,Submodule.coe_zero] at hh' + rw [hh'] + · apply sumChainsEquiv.injective + have hh : pathChain w' (r' (.inr (.inr i))) g = + chainIndexEquiv e (pathChain w (r i) g) := + (chainIndexEquiv_pathChain w w' e he _ _).symm + simp only [LinearEquiv.coe_coe,ordinaryBlockEquiv_value,sumChainsEquiv_single_right, + extraRelatorMap_single,hh,← map_smul] + have hsingle : n • pathChain w (r i) g = relatorChainMap w r (Finsupp.single (g,i) n) := by simp + rw [hsingle,projectExtraChains_assoc,hcr] + simp + exact ⟨r',fun i => hrf (j i),hpr,hinjr,hd,hQ⟩ + +end FinishedAlignment +end EilenbergGanea + +namespace EilenbergGanea +section BoundaryBasisPresentation +variable {Γ S A R Z : Type*} [Group Γ] + +/-- Full algebraic alignment. The initial and final +presentations are genuine normal-closure presentations. No finiteness of the +old generators or of either relator family is required. -/ +theorem boundary_basis_presentation_alignment + (v : S → Γ) (hv : Function.Surjective (wordValue v)) + (z : Z → FreeGroup S) (hz : ∀ i, wordValue v (z i) = 1) + (B : BasedChains Γ Z ≃ₗ[ℤ] cycles v) + (hB : ∀ c, (B c : BasedChains Γ S) = relatorChainMap v z c) + (a : A → Γ) (ha : Function.Surjective (wordValue a)) + (r : R → FreeGroup A) (hr : ∀ i, wordValue a (r i) = 1) + (hp : (wordValue a).ker = Subgroup.normalClosure (Set.range r)) + (E : BasedChains Γ R ≃ₗ[ℤ] cycles a) + (hE : ∀ c, (E c : BasedChains Γ A) = relatorChainMap a r c) : + ∃ (r' : Z ⊕ (A ⊕ (R ⊕ S)) → FreeGroup (S ⊕ (A ⊕ (Z ⊕ A)))) + (Q : BasedChains Γ (A ⊕ (R ⊕ S)) ≃ₗ[ℤ] BasedChains Γ (A ⊕ (Z ⊕ A))), + (∀ i, wordValue (Sum.elim v (fun _ : A ⊕ (Z ⊕ A) => 1)) (r' i) = 1) ∧ + (wordValue (Sum.elim v (fun _ : A ⊕ (Z ⊕ A) => 1))).ker = + Subgroup.normalClosure (Set.range r') ∧ + Function.Injective (relatorChainMap (Sum.elim v (fun _ : A ⊕ (Z ⊕ A) => 1)) r') ∧ + (∀ i, pathChain (Sum.elim v (fun _ : A ⊕ (Z ⊕ A) => 1)) + (FreeGroup.map Sum.inl (z i)) 1 = + pathChain (Sum.elim v (fun _ : A ⊕ (Z ⊕ A) => 1)) (r' (.inl i)) 1) ∧ + Q.toLinearMap = extraRelatorMap (Sum.elim v (fun _ : A ⊕ (Z ⊕ A) => 1)) + (fun i => r' (.inr i)) := by + obtain ⟨r₀,E₀,hr₀,hp₀,hE₀⟩ := align_generators v hv a ha r hr hp E hE + let v₀ : S ⊕ A → Γ := Sum.elim v (fun _ => 1) + have hv₀ : Function.Surjective (wordValue v₀) := by + intro g + obtain ⟨w,hw⟩ := hv g + refine ⟨FreeGroup.map Sum.inl w,?_⟩ + have h : (wordValue v₀).comp (FreeGroup.map Sum.inl) = wordValue v := by + apply FreeGroup.ext_hom + intro s + simp [wordValue,v₀] + exact (DFunLike.congr_fun h w).trans hw + let B₀ : BasedChains Γ (Z ⊕ A) ≃ₗ[ℤ] cycles v₀ := unitExtensionBasis v B + let z₀ : Z ⊕ A → FreeGroup (S ⊕ A) := unitExtendedRelators z + have hz₀ : ∀ i, wordValue v₀ (z₀ i) = 1 := unitExtendedRelators_trivial v z hz + have hB₀ : ∀ c, (B₀ c : BasedChains Γ (S ⊕ A)) = relatorChainMap v₀ z₀ c := + unitExtensionBasis_value v z B hB + obtain ⟨r₁,u₁,hr₁,hu₁,hp₁,hi₁,hcr,hcu⟩ := + stabilized_alignment v₀ hv₀ r₀ z₀ hr₀ hz₀ hp₀ E₀ B₀ hE₀ hB₀ + obtain ⟨r',hr',hp',hi',hd,hQ⟩ := + finish_alignment v z B hB (E₀.trans B₀.symm) r₁ u₁ hr₁ hu₁ hp₁ hi₁ hcr hcu + exact ⟨r',ordinaryBlockEquiv (E₀.trans B₀.symm),hr',hp',hi',hd,hQ⟩ + +end BoundaryBasisPresentation +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion +section BoundaryBasisTransport +variable {Γ S Z A R : Type*} [Group Γ] [Group.ResiduallyFinite Γ] [Fintype Z] + +/-- Full algebraic content of source Theorem presentation: the only additional +input is a genuine arbitrary-alphabet presentation with boundary basis. The +separate CW-to-presentation bridge must supply that input; it is not asserted +here as a hypothesis of the main result. -/ +theorem boundary_basis_small_transport + (v : S → Γ) (hv : Function.Surjective (wordValue v)) + (z : Z → FreeGroup S) (hz : ∀ i, wordValue v (z i) = 1) + (B : BasedChains Γ Z ≃ₗ[ℤ] cycles v) + (hB : ∀ c, (B c : BasedChains Γ S) = relatorChainMap v z c) + (a₀ : A → Γ) (ha₀ : Function.Surjective (wordValue a₀)) + (r₀ : R → FreeGroup A) (hr₀ : ∀ i, wordValue a₀ (r₀ i) = 1) + (hp₀ : (wordValue a₀).ker = Subgroup.normalClosure (Set.range r₀)) + (E : BasedChains Γ R ≃ₗ[ℤ] cycles a₀) + (hE : ∀ c, (E c : BasedChains Γ A) = relatorChainMap a₀ r₀ c) : + ∃ η : ℝ, 0 < η ∧ ∀ a : Γ → S → SU2, + (∀ g s, ‖(a g s : ℍ)-1‖ < η) → + (∀ i g, pathProduct v a (z i) g = 1) → + ∀ w : FreeGroup S, wordValue v w = 1 → ∀ g, + pathProduct v a w g = 1 := by + obtain ⟨r,Q,hr,hp,hinj,hd,hQ⟩ := + boundary_basis_presentation_alignment v hv z hz B hB a₀ ha₀ r₀ hr₀ hp₀ E hE + exact aligned_presentation_small_transport + (Sum.elim v (fun _ : A ⊕ (Z ⊕ A) => 1)) r z (fun _ => rfl) + hr hz hp hinj hd Q hQ + +end BoundaryBasisTransport +end EilenbergGanea + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/PresentationComparison.lean b/lean/OAI/Topology/EilenbergGanea/PresentationComparison.lean new file mode 100644 index 0000000000000000000000000000000000000000..bb28acb3a712a9df30032e03e35dbede2f7a3710 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/PresentationComparison.lean @@ -0,0 +1,1070 @@ +import OAI.Topology.EilenbergGanea.SmallHolonomy +import Mathlib.Topology.Algebra.Star.Unitary + +namespace OAI + +noncomputable section + +universe u + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea +section NaturalPath +variable {Γ S H K : Type*} [Group Γ] [Group H] [Group K] + +theorem pathProduct_map (v : S → Γ) (a : Γ → S → H) (w : FreeGroup S) + (g : Γ) (f : H →* K) : + pathProduct v (fun p s => f (a p s)) w g = f (pathProduct v a w g) := by + induction w using FreeGroup.induction_on generalizing g with + | one => simp + | of s => simp + | inv_of s => simp only [pathProduct_inv, pathProduct_of, map_inv] + | mul w z hw hz => simp only [pathProduct_mul, hw, hz, map_mul] + +/-- The literal edge word traversed by a generator word. Free reduction of +this word is harmless for all nonabelian edge labelings. -/ +def pathSpelling (v : S → Γ) (w : FreeGroup S) (g : Γ) : FreeGroup (Γ × S) := + pathProduct v (fun p s => FreeGroup.of (p,s)) w g + +theorem pathSpelling_eval (v : S → Γ) (a : Γ → S → H) (w : FreeGroup S) (g : Γ) : + FreeGroup.lift (fun i : Γ × S => a i.1 i.2) (pathSpelling v w g) = + pathProduct v a w g := by + symm + simpa only [FreeGroup.lift_apply_of, pathSpelling] using + pathProduct_map v (fun p s => FreeGroup.of (p,s)) w g + (FreeGroup.lift (fun i : Γ × S => a i.1 i.2)) + +/-- Abelianizing the literal edge word gives exactly the integral edge chain. -/ +theorem pathSpelling_abelianization (v : S → Γ) (w : FreeGroup S) (g : Γ) : + FreeGroup.lift (fun i : Γ × S => Multiplicative.ofAdd (Finsupp.single i (1 : ℤ))) + (pathSpelling v w g) = Multiplicative.ofAdd (pathChain v w g) := by + exact pathSpelling_eval v (fun p s => Multiplicative.ofAdd (Finsupp.single (p,s) (1 : ℤ))) w g + +/-- Naturality in the target additive free module; used when projecting to +extra generators and when tensoring with a finite quotient. -/ +theorem pathChain_pairing {M : Type*} [AddCommGroup M] + (v : S → Γ) (b : Γ × S → M) (w : FreeGroup S) (g : Γ) : + Finsupp.linearCombination ℤ b (pathChain v w g) = + (pathProduct v (fun p s => Multiplicative.ofAdd (b (p,s))) w g).toAdd := by + induction w using FreeGroup.induction_on generalizing g with + | one => simp + | of s => simp [pathChain_of, Finsupp.linearCombination_single, pathProduct_of] + | inv_of s hs => + simpa only [pathChain_inv, map_neg, pathProduct_inv, toAdd_inv] using congrArg Neg.neg (hs _) + | mul w z hw hz => simp only [pathChain_mul, map_add, pathProduct_mul, + toAdd_mul, hw, hz] + +end NaturalPath +end EilenbergGanea + +namespace EilenbergGanea +section NormalExpressions +variable {S R : Type*} + +def inverseNormalFactor (f : NormalFactor S R) : NormalFactor S R := + (f.1, f.2.1, !f.2.2) + +theorem normalFactor_inverse (r : R → FreeGroup S) (f : NormalFactor S R) : + normalFactorWord r (inverseNormalFactor f) = (normalFactorWord r f)⁻¹ := by + rcases f with ⟨u, i, ε⟩ + cases ε <;> simp [normalFactorWord, inverseNormalFactor, mul_assoc] + +/-- Every element of a normal closure admits one finite product of conjugates, +including for arbitrary (possibly uncountable) index types. -/ +theorem exists_normalExpression (r : R → FreeGroup S) {w : FreeGroup S} + (hw : w ∈ Subgroup.normalClosure (Set.range r)) : + ∃ l : List (NormalFactor S R), w = (l.map (normalFactorWord r)).prod := by + change w ∈ Subgroup.closure (Group.conjugatesOfSet (Set.range r)) at hw + induction hw using Subgroup.closure_induction with + | mem x hx => + obtain ⟨y, ⟨i, rfl⟩, hy⟩ := Group.mem_conjugatesOfSet_iff.mp hx + obtain ⟨u, hu⟩ := isConj_iff.mp hy + refine ⟨[(u,i,true)], ?_⟩ + simpa [normalFactorWord] using hu.symm + | one => exact ⟨[], by simp⟩ + | mul x y hx hy ihx ihy => + obtain ⟨l, rfl⟩ := ihx + obtain ⟨k, rfl⟩ := ihy + exact ⟨l ++ k, by simp⟩ + | inv x hx ih => + obtain ⟨l, rfl⟩ := ih + refine ⟨(l.map inverseNormalFactor).reverse, ?_⟩ + simp only [List.map_reverse, List.prod_inv_reverse, List.map_map] + congr 2 + apply List.map_congr_left + intro f _ + exact (normalFactor_inverse r f).symm + +end NormalExpressions +end EilenbergGanea + +namespace EilenbergGanea +section WordNorm +open scoped Quaternion +variable {Γ S : Type*} [Group Γ] + +theorem su2_mul_distance (a b : SU2) : + ‖((a*b : SU2) : ℍ) - 1‖ ≤ ‖(a : ℍ) - 1‖ + ‖(b : ℍ) - 1‖ := by + have he : ((a*b : SU2) : ℍ) - 1 = ((a : ℍ) - 1) * (b : ℍ) + ((b : ℍ) - 1) := by + change (a : ℍ) * (b : ℍ) - 1 = _ + noncomm_ring + rw [he] + exact (norm_add_le _ _).trans_eq (by rw [norm_mul, su2_norm, mul_one]) + +/-- A finite control set for a word, uniform over all base vertices and all +labelings. Both the set and the coefficient are chosen before any quotient. -/ +theorem finite_word_control (v : S → Γ) (w : FreeGroup S) : + ∃ (P : Finset S) (n : ℕ), ∀ (ε : ℝ), 0 ≤ ε → ∀ (a : Γ → S → SU2), + (∀ g, ∀ s ∈ P, ‖(a g s : ℍ) - 1‖ ≤ ε) → + ∀ g, ‖((pathProduct v a w g : SU2) : ℍ) - 1‖ ≤ n * ε := by + classical + induction w using FreeGroup.induction_on with + | one => exact ⟨∅, 0, fun ε _ a _ g => by simp⟩ + | of s => + refine ⟨{s}, 1, fun ε _ a ha g => ?_⟩ + simpa using ha g s (by simp) + | inv_of s ih => + obtain ⟨P, n, hn⟩ := ih + refine ⟨P, n, fun ε hε a ha g => ?_⟩ + rw [pathProduct_inv, su2_inverse_distance] + exact hn ε hε a ha _ + | mul w z hw hz => + obtain ⟨P, n, hn⟩ := hw + obtain ⟨Q, m, hm⟩ := hz + refine ⟨P ∪ Q, n+m, fun ε hε a ha g => ?_⟩ + rw [pathProduct_mul] + calc + _ ≤ ‖((pathProduct v a w g : SU2) : ℍ) - 1‖ + + ‖((pathProduct v a z (g * wordValue v w) : SU2) : ℍ) - 1‖ := su2_mul_distance _ _ + _ ≤ n * ε + m * ε := add_le_add + (hn ε hε a (fun p s hs => ha p s (Finset.mem_union_left _ hs)) _) + (hm ε hε a (fun p s hs => ha p s (Finset.mem_union_right _ hs)) _) + _ = _ := by push_cast; ring + +/-- A finite control set for a word, uniform over all base vertices and all +labelings. Both the set and the coefficient are chosen before any quotient. -/ +theorem finite_word_control_universal (w : FreeGroup S) : + ∃ (P : Finset S) (n : ℕ), ∀ {D : Type u} [Group D] (v : S → D) (ε : ℝ), 0 ≤ ε → ∀ (a : D → S → SU2), + (∀ g, ∀ s ∈ P, ‖(a g s : ℍ) - 1‖ ≤ ε) → + ∀ g, ‖((pathProduct v a w g : SU2) : ℍ) - 1‖ ≤ n * ε := by + classical + induction w using FreeGroup.induction_on with + | one => exact ⟨∅, 0, fun v ε _ a _ g => by simp⟩ + | of s => + refine ⟨{s}, 1, fun v ε _ a ha g => ?_⟩ + simpa using ha g s (by simp) + | inv_of s ih => + obtain ⟨P, n, hn⟩ := ih + refine ⟨P, n, fun v ε hε a ha g => ?_⟩ + rw [pathProduct_inv, su2_inverse_distance] + exact hn v ε hε a ha _ + | mul w z hw hz => + obtain ⟨P, n, hn⟩ := hw + obtain ⟨Q, m, hm⟩ := hz + refine ⟨P ∪ Q, n+m, fun v ε hε a ha g => ?_⟩ + rw [pathProduct_mul] + calc + _ ≤ ‖((pathProduct v a w g : SU2) : ℍ) - 1‖ + + ‖((pathProduct v a z (g * wordValue v w) : SU2) : ℍ) - 1‖ := su2_mul_distance _ _ + _ ≤ n * ε + m * ε := add_le_add + (hn v ε hε a (fun p s hs => ha p s (Finset.mem_union_left _ hs)) _) + (hm v ε hε a (fun p s hs => ha p s (Finset.mem_union_right _ hs)) _) + _ = _ := by push_cast; ring + +end WordNorm +end EilenbergGanea + +namespace EilenbergGanea +section EvaluatedNormalExpression +open scoped Quaternion +variable {Γ D S R : Type*} [Group Γ] [Group D] + +theorem wordValue_quotient (v : S → Γ) (q : Γ →* D) (w : FreeGroup S) : + wordValue (fun s => q (v s)) w = q (wordValue v w) := by + have he : wordValue (fun s => q (v s)) = q.comp (wordValue v) := by + apply FreeGroup.ext_hom + intro s + simp [wordValue] + exact congrArg (fun f : FreeGroup S →* D => f w) he + +def evaluatedNormalFactor (v : S → Γ) (a : Γ → S → SU2) + (f : NormalFactor S R) (g : Γ) : RelatorFactor (Γ × R) := + (pathProduct v a f.1 g, (g * wordValue v f.1, f.2.1), f.2.2) + +theorem evaluatedNormalFactor_value (v : S → Γ) (a : Γ → S → SU2) + (r : R → FreeGroup S) (hr : ∀ i, wordValue v (r i) = 1) + (f : NormalFactor S R) (g : Γ) : + relatorFactorValue (fun i : Γ × R => pathProduct v a (r i.2) i.1) + (evaluatedNormalFactor v a f g) = pathProduct v a (normalFactorWord r f) g := by + rcases f with ⟨u, i, σ⟩ + cases σ <;> + simp [relatorFactorValue, evaluatedNormalFactor, signedUnit, normalFactorWord, + pathProduct_conjugate_loop, hr, pathProduct_inv] + +theorem pathProduct_normalProduct (v : S → Γ) (a : Γ → S → SU2) + (r : R → FreeGroup S) (hr : ∀ i, wordValue v (r i) = 1) + (l : List (NormalFactor S R)) (g : Γ) : + ((l.map (fun f => evaluatedNormalFactor v a f g)).map + (relatorFactorValue (fun i : Γ × R => pathProduct v a (r i.2) i.1))).prod = + pathProduct v a (l.map (normalFactorWord r)).prod g := by + induction l with + | nil => simp + | cons f l ih => + simp only [List.map_cons, List.prod_cons, pathProduct_mul, + normalFactor_value v r hr, mul_one, evaluatedNormalFactor_value v a r hr, ih] + +/-- Exact translated signed counts are preserved upon passage to every quotient. +No flatness, finiteness, or injectivity of the quotient is used. -/ +theorem quotient_evaluated_counts (v : S → Γ) (q : Γ →* D) + (a : D → S → SU2) (l : List (NormalFactor S R)) (ρ : R) + (hc : (l.map (fun f => normalFactorCount v f 1)).sum = Finsupp.single (1,ρ) 1) + (g : D) : + relatorSignedCounts (l.map (fun f => evaluatedNormalFactor (fun s => q (v s)) a f g)) = + Finsupp.single (g,ρ) 1 := by + let T : ((Γ × R) →₀ ℤ) →ₗ[ℤ] ((D × R) →₀ ℤ) := + Finsupp.lmapDomain ℤ ℤ (fun i => (g * q i.1, i.2)) + have hs : relatorSignedCounts + (l.map (fun f => evaluatedNormalFactor (fun s => q (v s)) a f g)) = + T (l.map (fun f => normalFactorCount v f 1)).sum := by + simp only [relatorSignedCounts, List.map_map, map_list_sum] + congr 1 + apply List.map_congr_left + intro f _ + simp [T, evaluatedNormalFactor, normalFactorCount, wordValue_quotient] + rw [hs, hc] + simp [T] + +/-- The actual relator expression, evaluated by arbitrary edge labels on a +quotient graph, has the uniform quadratic error predicted by its exact chain +counts. -/ +theorem normalExpression_quadratic (v : S → Γ) (q : Γ →* D) + (a : D → S → SU2) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (z : FreeGroup S) + (l : List (NormalFactor S R)) (he : z = (l.map (normalFactorWord r)).prod) + (ρ : R) (hc : (l.map (fun f => normalFactorCount v f 1)).sum = + Finsupp.single (1,ρ) 1) + (h ε K : ℝ) (hh : 0 ≤ h) (hε : 0 ≤ ε) (hK : 0 ≤ K) + (hb : ∀ f ∈ l, ∀ g, ‖((pathProduct (fun s => q (v s)) a (r f.2.1) g : SU2) : ℍ) - 1‖ ≤ h) + (ha : ∀ f ∈ l, ∀ g, ‖((pathProduct (fun s => q (v s)) a f.1 g : SU2) : ℍ) - 1‖ ≤ K * (ε+h)) + (g : D) : + ‖((pathProduct (fun s => q (v s)) a z g : SU2) : ℍ) - + ((pathProduct (fun s => q (v s)) a (r ρ) g : SU2) : ℍ)‖ ≤ + ((l.length : ℝ)^2 + l.length + 2*l.length*K) * (ε+h)*h := by + let v' := fun s => q (v s) + let L := l.map (fun f => evaluatedNormalFactor v' a f g) + let x := fun i : D × R => pathProduct v' a (r i.2) i.1 + have hp := relator_product_quadratic L x (g,ρ) + (quotient_evaluated_counts v q a l ρ hc g) h ε K hh hε hK + (by intro f hf; obtain ⟨b,hb',rfl⟩ := List.mem_map.mp hf; exact hb b hb' _) + (by intro f hf; obtain ⟨b,hb',rfl⟩ := List.mem_map.mp hf; exact ha b hb' _) + have hprod : (L.map (fun f => (relatorFactorValue x f : ℍ))).prod = + ((pathProduct v' a z g : SU2) : ℍ) := by + have hz := pathProduct_normalProduct v' a r + (fun i => by simp [v', wordValue_quotient, hr]) l g + rw [← he] at hz + have hco (ll : List SU2) : ((ll.prod : SU2) : ℍ) = (ll.map (fun b : SU2 => (b : ℍ))).prod := by + induction ll with + | nil => rfl + | cons b ll ih => simp only [List.prod_cons, Submonoid.coe_mul, List.map_cons, ih] + have hz' := congrArg (fun x : SU2 => (x : ℍ)) hz + rw [hco] at hz' + simpa only [L, x, List.map_map, Function.comp_def] using hz' + simpa only [hprod, L, List.length_map, x, v'] using hp + +end EvaluatedNormalExpression +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion +section NormalProductSize +variable {Γ S R : Type*} [Group Γ] + + theorem normalFactor_product_distance (v : S → Γ) (a : Γ → S → SU2) + (r : R → FreeGroup S) (hr : ∀ i, wordValue v (r i) = 1) + (f : NormalFactor S R) (g : Γ) : + ‖((pathProduct v a (normalFactorWord r f) g : SU2) : ℍ) - 1‖ = + ‖((pathProduct v a (r f.2.1) (g * wordValue v f.1) : SU2) : ℍ) - 1‖ := by + rw [← evaluatedNormalFactor_value v a r hr] + exact (su2_conjugation_distance _ _).trans (signedUnit_distance _ _) + +/-- Unlike the quadratic estimate, this linear bound needs no information +whatever about the conjugating words. It controls the finitely many auxiliary +loop labels before any bound on the conjugators is obtained. -/ +theorem normalProduct_distance (v : S → Γ) (a : Γ → S → SU2) + (r : R → FreeGroup S) (hr : ∀ i, wordValue v (r i) = 1) + (l : List (NormalFactor S R)) (h : ℝ) + (hb : ∀ f ∈ l, ∀ g, ‖((pathProduct v a (r f.2.1) g : SU2) : ℍ) - 1‖ ≤ h) + (g : Γ) : + ‖((pathProduct v a (l.map (normalFactorWord r)).prod g : SU2) : ℍ) - 1‖ ≤ l.length * h := by + induction l with + | nil => simp + | cons f l ih => + simp only [List.map_cons, List.prod_cons, pathProduct_mul, normalFactor_value v r hr, mul_one] + calc + _ ≤ ‖((pathProduct v a (normalFactorWord r f) g : SU2) : ℍ) - 1‖ + + ‖((pathProduct v a (l.map (normalFactorWord r)).prod g : SU2) : ℍ) - 1‖ := su2_mul_distance _ _ + _ ≤ h + l.length * h := add_le_add + (by rw [normalFactor_product_distance v a r hr]; exact hb f (by simp) _) + (ih (fun b hb' => hb b (by simp [hb']))) + _ = _ := by simp only [List.length_cons, Nat.cast_add, Nat.cast_one]; ring + +end NormalProductSize +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion +section FiniteControl +variable {S T H : Type*} [Group H] + + theorem pathProduct_map_alphabet {Γ : Type*} [Group Γ] + (f : S → T) (v : T → Γ) (a : Γ → T → H) (w : FreeGroup S) (g : Γ) : + pathProduct v a (FreeGroup.map f w) g = + pathProduct (v ∘ f) (fun p s => a p (f s)) w g := by + have he : (labelLift v a).comp (FreeGroup.map f) = + labelLift (v ∘ f) (fun p s => a p (f s)) := by + apply FreeGroup.ext_hom + intro s + simp [labelLift] + exact congrArg (fun l : FreeGroup S →* ((Γ → H) ⋊[functionShift Γ H] Γ) => (l w).left g) he + + theorem finite_word_family_control (W : Finset (FreeGroup S)) : + ∃ (P : Finset S) (n : ℕ), ∀ w ∈ W, + ∀ {D : Type u} [Group D] (v : S → D) (ε : ℝ), 0 ≤ ε → ∀ (a : D → S → SU2), + (∀ g, ∀ s ∈ P, ‖(a g s : ℍ) - 1‖ ≤ ε) → + ∀ g, ‖((pathProduct v a w g : SU2) : ℍ) - 1‖ ≤ n * ε := by + classical + induction W using Finset.induction_on with + | empty => exact ⟨∅,0, by simp⟩ + | @insert w W _ ih => + obtain ⟨P,n,hn⟩ := finite_word_control_universal w + obtain ⟨Q,m,hm⟩ := ih + refine ⟨P ∪ Q, n+m, ?_⟩ + intro z hz D _ v ε hε a ha g + rcases Finset.mem_insert.mp hz with rfl | hz + · exact (hn v ε hε a (fun p s hs => ha p s (Finset.mem_union_left _ hs)) g).trans + (mul_le_mul_of_nonneg_right (by exact_mod_cast Nat.le_add_right n m) hε) + · exact (hm z hz v ε hε a (fun p s hs => ha p s (Finset.mem_union_right _ hs)) g).trans + (mul_le_mul_of_nonneg_right (by exact_mod_cast Nat.le_add_left m n) hε) + +end FiniteControl +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion BigOperators +section UniformComparison +variable {Γ S T Z R : Type*} [Group Γ] [Fintype Z] + +/-- All constants and all ordinary relators needed by the quadratic estimate +are chosen before the group quotient and before the edge labels. The normal +expressions are literal finite words, while the ambient alphabets may have any +cardinality. -/ +theorem finite_normal_comparison + (v : S ⊕ T → Γ) (r : Z ⊕ R → FreeGroup (S ⊕ T)) + (hr : ∀ i, wordValue v (r i) = 1) (z : Z → FreeGroup S) + (lz : Z → List (NormalFactor (S ⊕ T) (Z ⊕ R))) + (lt : T → List (NormalFactor (S ⊕ T) (Z ⊕ R))) + (hz : ∀ i, FreeGroup.map Sum.inl (z i) = ((lz i).map (normalFactorWord r)).prod) + (ht : ∀ t, FreeGroup.of (Sum.inr t) = ((lt t).map (normalFactorWord r)).prod) + (hc : ∀ i, ((lz i).map (fun f => normalFactorCount v f 1)).sum = + Finsupp.single (1,Sum.inl i) 1) : + ∃ (A : Finset R) (C : ℝ), 1 ≤ C ∧ + ∀ {F : Type u} [Group F] (q : Γ →* F) (a : F → S ⊕ T → SU2) + (ε h : ℝ), 0 ≤ ε → 0 ≤ h → + (∀ g s, ‖(a g (.inl s) : ℍ) - 1‖ ≤ ε) → + (∀ i ∈ A, ∀ g, pathProduct (fun s => q (v s)) a (r (.inr i)) g = 1) → + (∀ i g, ‖((pathProduct (fun s => q (v s)) a (r (.inl i)) g : SU2) : ℍ) - 1‖ ≤ h) → + ∀ i g, + ‖((pathProduct (fun s => q (v s)) a (FreeGroup.map Sum.inl (z i)) g : SU2) : ℍ) - + ((pathProduct (fun s => q (v s)) a (r (.inl i)) g : SU2) : ℍ)‖ ≤ C * (ε+h)*h ∧ + ‖((pathProduct (fun s => q (v s)) a (FreeGroup.map Sum.inl (z i)) g : SU2) : ℍ) - 1‖ ≤ C*ε := by + classical + let W : Finset (FreeGroup (S ⊕ T)) := Finset.univ.biUnion fun i => + (lz i).toFinset.image Prod.fst + obtain ⟨P,n,hn⟩ := finite_word_family_control W + obtain ⟨_,nz,hnz⟩ := finite_word_family_control (Finset.univ.image z) + let U : Finset (Z ⊕ R) := + (Finset.univ.biUnion fun i => (lz i).toFinset.image (fun f => f.2.1)) ∪ + (P.toRight.biUnion fun t => (lt t).toFinset.image (fun f => f.2.1)) + let M : ℕ := 1 + P.toRight.sup (fun t => (lt t).length) + let N : ℕ := Finset.univ.sup (fun i => (lz i).length) + let K : ℝ := n * M + let C : ℝ := 1 + nz + (N : ℝ)^2 + N + 2*N*K + have hM : 1 ≤ M := Nat.le_add_right 1 _ + have hMr : 1 ≤ (M : ℝ) := by exact_mod_cast hM + have hK : 0 ≤ K := by dsimp [K]; positivity + have hcoef : 0 ≤ (2 : ℝ)*N*K := by positivity + have hNr : (0 : ℝ) ≤ N := Nat.cast_nonneg _ + have hnzr : (0 : ℝ) ≤ nz := Nat.cast_nonneg _ + have hC : 1 ≤ C := by dsimp [C]; nlinarith [sq_nonneg (N : ℝ)] + have hnzC : (nz : ℝ) ≤ C := by dsimp [C]; nlinarith [sq_nonneg (N : ℝ)] + have hNC : (N : ℝ)^2 + N + 2*N*K ≤ C := by dsimp [C]; linarith + refine ⟨U.toRight,C,hC,?_⟩ + intro F _ q a ε h hε hh ha hordinary hdist i g + let v' := fun s => q (v s) + have hr' (j) : wordValue v' (r j) = 1 := by simp [v', wordValue_quotient, hr] + have hused (j : Z ⊕ R) (hj : j ∈ U) (p : F) : + ‖((pathProduct v' a (r j) p : SU2) : ℍ)-1‖ ≤ h := by + rcases j with j | j + · exact hdist j p + · rw [hordinary j (Finset.mem_toRight.mpr hj) p] + simpa using hh + have hZ (j : Z) (f : NormalFactor (S ⊕ T) (Z ⊕ R)) (hf : f ∈ lz j) (p : F) : + ‖((pathProduct v' a (r f.2.1) p : SU2) : ℍ)-1‖ ≤ h := by + apply hused _ _ p + exact Finset.mem_union_left _ (Finset.mem_biUnion.mpr ⟨j,Finset.mem_univ _, + Finset.mem_image.mpr ⟨f,List.mem_toFinset.mpr hf,rfl⟩⟩) + have hT (t : T) (htP : t ∈ P.toRight) (p : F) : ‖(a p (.inr t) : ℍ)-1‖ ≤ M*h := by + have hb := normalProduct_distance v' a r hr' (lt t) h + (fun f hf p => hused _ (Finset.mem_union_right _ + (Finset.mem_biUnion.mpr ⟨t,htP,Finset.mem_image.mpr ⟨f,List.mem_toFinset.mpr hf,rfl⟩⟩)) p) p + rw [← ht t, pathProduct_of] at hb + exact hb.trans (mul_le_mul_of_nonneg_right (by + exact_mod_cast (show (lt t).length ≤ M from + (Finset.le_sup (f := fun t => (lt t).length) htP).trans (Nat.le_add_left _ 1))) hh) + have hsize : 0 ≤ (M : ℝ)*(ε+h) := mul_nonneg (Nat.cast_nonneg _) (add_nonneg hε hh) + have hP (p : F) (s : S ⊕ T) (hs : s ∈ P) : ‖(a p s : ℍ)-1‖ ≤ M*(ε+h) := by + rcases s with s | t + · calc + _ ≤ ε := ha p s + _ ≤ (M : ℝ)*ε := by nlinarith + _ ≤ (M : ℝ)*(ε+h) := mul_le_mul_of_nonneg_left (by linarith) (Nat.cast_nonneg _) + · exact (hT t (Finset.mem_toRight.mpr hs) p).trans + (mul_le_mul_of_nonneg_left (by linarith) (Nat.cast_nonneg _)) + have hconj (j : Z) (f : NormalFactor (S ⊕ T) (Z ⊕ R)) (hf : f ∈ lz j) (p : F) : + ‖((pathProduct v' a f.1 p : SU2) : ℍ)-1‖ ≤ K*(ε+h) := by + have hW : f.1 ∈ W := Finset.mem_biUnion.mpr ⟨j,Finset.mem_univ _, + Finset.mem_image.mpr ⟨f,List.mem_toFinset.mpr hf,rfl⟩⟩ + simpa only [K, mul_assoc] using hn f.1 hW v' _ hsize a hP p + constructor + · have hb := normalExpression_quadratic v q a r hr _ (lz i) (hz i) (.inl i) (hc i) + h ε K hh hε hK (hZ i) (hconj i) g + apply hb.trans + apply mul_le_mul_of_nonneg_right _ hh + apply mul_le_mul_of_nonneg_right _ (add_nonneg hε hh) + have hl : ((lz i).length : ℝ) ≤ N := by + exact_mod_cast (show (lz i).length ≤ N from + Finset.le_sup (f := fun j => (lz j).length) (Finset.mem_univ i)) + have h0 : (0 : ℝ) ≤ (lz i).length := Nat.cast_nonneg _ + have hn0 : (0 : ℝ) ≤ N := Nat.cast_nonneg _ + have hp := mul_le_mul_of_nonneg_right hl hK + nlinarith [sq_nonneg ((N : ℝ) - (lz i).length)] + · rw [pathProduct_map_alphabet] + exact (hnz (z i) (Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩) + _ ε hε (fun p s => a p (.inl s)) (fun p s _ => ha p s) g).trans + (mul_le_mul_of_nonneg_right hnzC hε) + +end UniformComparison +end EilenbergGanea + +namespace EilenbergGanea + +section QuotientChains +variable {Γ F R S T : Type*} [Group Γ] [Group F] + +abbrev BasedChains (Γ S : Type*) := (Γ × S) →₀ ℤ + +def translateChains (g : Γ) : BasedChains Γ S →ₗ[ℤ] BasedChains Γ S := + Finsupp.lmapDomain ℤ ℤ (fun i => (g*i.1, i.2)) + +def quotientChains (q : Γ →* F) : BasedChains Γ S →ₗ[ℤ] BasedChains F S := + Finsupp.lmapDomain ℤ ℤ (fun i => (q i.1, i.2)) + +@[simp] theorem translateChains_single (g h : Γ) (s : S) (n : ℤ) : + translateChains g (Finsupp.single (h,s) n) = Finsupp.single (g*h,s) n := by + simp [translateChains] + +@[simp] theorem quotientChains_single (q : Γ →* F) (g : Γ) (s : S) (n : ℤ) : + quotientChains q (Finsupp.single (g,s) n) = Finsupp.single (q g,s) n := by + simp [quotientChains] + +theorem translateChains_mul (g h : Γ) (c : BasedChains Γ S) : + translateChains (g*h) c = translateChains g (translateChains h c) := by + have he : (translateChains (g*h) : BasedChains Γ S →ₗ[ℤ] _) = + (translateChains g).comp (translateChains h) := by + apply Finsupp.lhom_ext + rintro ⟨p,s⟩ n + simp [mul_assoc] + exact LinearMap.congr_fun he c + +@[simp] theorem translateChains_one (c : BasedChains Γ S) : translateChains (1 : Γ) c = c := by + have he : (translateChains (1 : Γ) : BasedChains Γ S →ₗ[ℤ] _) = LinearMap.id := by + apply Finsupp.lhom_ext + rintro ⟨g,s⟩ n + simp + exact LinearMap.congr_fun he c + +theorem quotientChains_translate (q : Γ →* F) (g : Γ) (c : BasedChains Γ S) : + quotientChains q (translateChains g c) = translateChains (q g) (quotientChains q c) := by + have he : (quotientChains q).comp (translateChains g) = + ((translateChains (q g)).comp (quotientChains q) : BasedChains Γ S →ₗ[ℤ] _) := by + apply Finsupp.lhom_ext + rintro ⟨p,s⟩ n + simp + exact LinearMap.congr_fun he c + +/-- The elementary equivariance expressing a left integral group-ring map. -/ +def ChainsEquivariant (A : BasedChains Γ R →ₗ[ℤ] BasedChains Γ S) : Prop := + ∀ g c, A (translateChains g c) = translateChains g (A c) + +/-- Base change of a translation-equivariant matrix, directly on its finitely +supported columns. Its definition needs neither finite index sets nor flatness. -/ +def quotientMatrix (q : Γ →* F) (A : BasedChains Γ R →ₗ[ℤ] BasedChains Γ S) : + BasedChains F R →ₗ[ℤ] BasedChains F S := + Finsupp.linearCombination ℤ (fun i => + translateChains i.1 (quotientChains q (A (Finsupp.single (1,i.2) 1)))) + +@[simp] theorem quotientMatrix_single (q : Γ →* F) + (A : BasedChains Γ R →ₗ[ℤ] BasedChains Γ S) (f : F) (r : R) (n : ℤ) : + quotientMatrix q A (Finsupp.single (f,r) n) = + n • translateChains f (quotientChains q (A (Finsupp.single (1,r) 1))) := by + simp [quotientMatrix] + +theorem quotientMatrix_equivariant (q : Γ →* F) + (A : BasedChains Γ R →ₗ[ℤ] BasedChains Γ S) : ChainsEquivariant (quotientMatrix q A) := by + intro f c + have he : (quotientMatrix q A).comp (translateChains f) = + (translateChains f).comp (quotientMatrix q A) := by + apply Finsupp.lhom_ext + rintro ⟨p,r⟩ n + simp only [LinearMap.comp_apply, translateChains_single, quotientMatrix_single, + map_smul, translateChains_mul] + exact LinearMap.congr_fun he c + +theorem quotientMatrix_natural (q : Γ →* F) + (A : BasedChains Γ R →ₗ[ℤ] BasedChains Γ S) (hA : ChainsEquivariant A) + (c : BasedChains Γ R) : + quotientMatrix q A (quotientChains q c) = quotientChains q (A c) := by + have he : (quotientMatrix q A).comp (quotientChains q) = (quotientChains q).comp A := by + apply Finsupp.lhom_ext + rintro ⟨g,r⟩ n + have hb : Finsupp.single (g,r) n = + n • translateChains g (Finsupp.single (1,r) (1 : ℤ)) := by simp + simp only [LinearMap.comp_apply, quotientChains_single, quotientMatrix_single] + rw [hb, map_smul, map_smul, hA, quotientChains_translate] + exact LinearMap.congr_fun he c + +theorem quotientMatrix_comp (q : Γ →* F) + (A : BasedChains Γ R →ₗ[ℤ] BasedChains Γ S) + (B : BasedChains Γ S →ₗ[ℤ] BasedChains Γ T) (hB : ChainsEquivariant B) : + quotientMatrix q (B.comp A) = (quotientMatrix q B).comp (quotientMatrix q A) := by + apply Finsupp.lhom_ext + rintro ⟨f,r⟩ n + simp only [LinearMap.comp_apply, quotientMatrix_single, map_smul] + rw [quotientMatrix_equivariant q B f, quotientMatrix_natural q B hB] + +theorem quotientMatrix_id (q : Γ →* F) : + quotientMatrix q (LinearMap.id : BasedChains Γ R →ₗ[ℤ] _) = LinearMap.id := by + apply Finsupp.lhom_ext + rintro ⟨f,r⟩ n + simp + +theorem ChainsEquivariant.symm (A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ S) + (hA : ChainsEquivariant A.toLinearMap) : ChainsEquivariant A.symm.toLinearMap := by + intro g c + apply A.injective + simp only [LinearEquiv.coe_coe, LinearEquiv.apply_symm_apply] + simpa only [LinearEquiv.coe_coe, LinearEquiv.apply_symm_apply] using (hA g (A.symm c)).symm + +/-- Tensoring an isomorphism is an isomorphism. This finite-column proof makes +no assertion that the quotient group ring is a flat module. -/ +def quotientChainEquiv (q : Γ →* F) (A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ S) + (hA : ChainsEquivariant A.toLinearMap) : BasedChains F R ≃ₗ[ℤ] BasedChains F S where + __ := quotientMatrix q A.toLinearMap + invFun := quotientMatrix q A.symm.toLinearMap + left_inv c := by + have he := quotientMatrix_comp q A.toLinearMap A.symm.toLinearMap (ChainsEquivariant.symm A hA) + have hi : A.symm.toLinearMap.comp A.toLinearMap = LinearMap.id := by ext; simp + rw [hi, quotientMatrix_id] at he + exact (LinearMap.congr_fun he c).symm + right_inv c := by + have he := quotientMatrix_comp q A.symm.toLinearMap A.toLinearMap hA + have hi : A.toLinearMap.comp A.symm.toLinearMap = LinearMap.id := by ext; simp + rw [hi, quotientMatrix_id] at he + exact (LinearMap.congr_fun he c).symm + +end QuotientChains +end EilenbergGanea + + + +namespace EilenbergGanea +open scoped BigOperators + +/-- A finite family with an integral left inverse has a nonzero square minor. +Expansion of the alternating determinant avoids a flatness or rationalization +assumption, and also covers the empty row family. -/ +theorem nonsingular_minor_of_left_inverse {I J : Type*} [Fintype I] [DecidableEq I] [Fintype J] + (v : J → I → ℤ) (b : I → J → ℤ) + (hb : ∀ i, ∑ j, b i j • v j = Pi.single i 1) : + ∃ e : I → J, Function.Injective e ∧ Matrix.det (fun i k => v (e i) k) ≠ 0 := by + classical + have hex : ∃ e : I → J, Matrix.det (fun i k => v (e i) k) ≠ 0 := by + by_contra h + push Not at h + let D := (Matrix.detRowAlternating : (I → ℤ) [⋀^I]→ₗ[ℤ] ℤ).toMultilinearMap + have hz : D (fun i => ∑ j, b i j • v j) = 0 := by + rw [D.map_sum] + apply Finset.sum_eq_zero + intro e _ + rw [D.map_smul_univ] + change (∏ i, b i (e i)) • Matrix.det (fun i k => v (e i) k) = 0 + rw [h] + exact smul_zero _ + have he : (fun i => ∑ j, b i j • v j) = (1 : Matrix I I ℤ) := by + ext i k + rw [show (∑ j, b i j • v j) = Pi.single i 1 from hb i] + simp [Matrix.one_apply, Pi.single_apply, eq_comm] + rw [he] at hz + change Matrix.det (1 : Matrix I I ℤ) = 0 at hz + simp at hz + obtain ⟨e, he⟩ := hex + refine ⟨e, ?_, he⟩ + intro i j hij + by_contra hne + exact he (Matrix.det_zero_of_row_eq hne (by simp [hij])) + +/-- The same finite-minor statement for an arbitrary direct sum. All supports +are retained, but only the finite union needed by the chosen rows is used. -/ +theorem finitely_supported_split_family_minor {I S : Type*} [Fintype I] [DecidableEq I] + (v : I → S →₀ ℤ) (B : (S →₀ ℤ) →ₗ[ℤ] (I → ℤ)) + (hB : ∀ i, B (v i) = Pi.single i 1) : + ∃ e : I → S, Function.Injective e ∧ Matrix.det (fun i j => v i (e j)) ≠ 0 := by + classical + let P : Finset S := Finset.univ.biUnion (fun i => (v i).support) + have hP (i : I) : (v i).support ⊆ P := by + intro s hs + exact Finset.mem_biUnion.mpr ⟨i, Finset.mem_univ _, hs⟩ + have hexpand (i : I) : v i = ∑ p : P, (v i) p.1 • (Finsupp.single p.1 (1 : ℤ)) := by + rw [Finset.sum_coe_sort P (fun p => (v i) p • (Finsupp.single p (1 : ℤ)))] + simp only [Finsupp.smul_single, smul_eq_mul, mul_one] + rw [← Finsupp.sum_of_support_subset (v i) (hP i) + (fun p t => Finsupp.single p t) (by intro p _; simp)] + exact (Finsupp.sum_single (v i)).symm + let w : P → I → ℤ := fun p j => v j p.1 + let b : I → P → ℤ := fun i p => B (Finsupp.single p.1 1) i + have hb (i : I) : ∑ p, b i p • w p = Pi.single i 1 := by + ext j + have hi := congrFun (hB j) i + rw [hexpand j, map_sum] at hi + simp only [map_smul, Finset.sum_apply, Pi.smul_apply, smul_eq_mul] at hi + simpa only [b, w, Finset.sum_apply, Pi.smul_apply, smul_eq_mul, mul_comm, + Pi.single_apply, eq_comm] using hi + obtain ⟨e, he, hd⟩ := nonsingular_minor_of_left_inverse w b hb + refine ⟨fun i => (e i).1, ?_, ?_⟩ + · intro i j hij + exact he (Subtype.ext hij) + · have ht := Matrix.det_transpose (fun i j => v i (e j).1) + exact fun h => hd (ht.trans h) + +/-- Every finite subfamily of an arbitrary integral basis has a nonsingular +finite coordinate minor, including when the ambient basis is uncountable. -/ +theorem basis_subfamily_minor {I R S : Type*} [Fintype I] [DecidableEq I] + (A : (R →₀ ℤ) ≃ₗ[ℤ] (S →₀ ℤ)) (j : I ↪ R) : + ∃ e : I → S, Function.Injective e ∧ + Matrix.det (fun i k => A (Finsupp.single (j i) 1) (e k)) ≠ 0 := by + classical + let B : (S →₀ ℤ) →ₗ[ℤ] (I → ℤ) := + LinearMap.pi fun i => (Finsupp.lapply (j i)).comp A.symm.toLinearMap + apply finitely_supported_split_family_minor (fun i => A (Finsupp.single (j i) 1)) B + intro i + ext k + simp [B, Pi.single_apply, Finsupp.single_apply, j.injective.eq_iff, eq_comm] + +end EilenbergGanea + +namespace EilenbergGanea +section ChainProjection +variable {Γ D S T R : Type*} [Group Γ] [Group D] + +theorem pathChain_translate (v : S → Γ) (w : FreeGroup S) (g h : Γ) : + translateChains g (pathChain v w h) = pathChain v w (g*h) := by + induction w using FreeGroup.induction_on generalizing h with + | one => simp + | of s => simp + | inv_of s ih => simp only [pathChain_inv, map_neg, ih, mul_assoc] + | mul w z hw hz => simp only [pathChain_mul, map_add, hw, hz, mul_assoc] + +theorem pathChain_quotient (v : S → Γ) (q : Γ →* D) (w : FreeGroup S) (g : Γ) : + quotientChains q (pathChain v w g) = pathChain (fun s => q (v s)) w (q g) := by + induction w using FreeGroup.induction_on generalizing g with + | one => simp + | of s => simp + | inv_of s ih => simp only [pathChain_inv, map_neg, ih, map_mul, map_inv, wordValue_quotient] + | mul w z hw hz => simp only [pathChain_mul, map_add, hw, hz, map_mul, wordValue_quotient] + +def projectExtraChains : BasedChains Γ (S ⊕ T) →ₗ[ℤ] BasedChains Γ T := + Finsupp.linearCombination ℤ fun p => match p.2 with + | .inl _ => 0 + | .inr t => Finsupp.single (p.1,t) 1 + +omit [Group Γ] in +@[simp] theorem projectExtraChains_single_left (g : Γ) (s : S) (n : ℤ) : + projectExtraChains (Finsupp.single (g,Sum.inl s) n : BasedChains Γ (S ⊕ T)) = 0 := by + simp [projectExtraChains] + +omit [Group Γ] in +@[simp] theorem projectExtraChains_single_right (g : Γ) (t : T) (n : ℤ) : + projectExtraChains (Finsupp.single (g,Sum.inr t) n : BasedChains Γ (S ⊕ T)) = + Finsupp.single (g,t) n := by simp [projectExtraChains] + +theorem projectExtraChains_translate (g : Γ) (c : BasedChains Γ (S ⊕ T)) : + projectExtraChains (translateChains g c) = translateChains g (projectExtraChains c) := by + have he : (projectExtraChains (Γ := Γ) (S := S) (T := T)).comp (translateChains g) = + (translateChains g).comp projectExtraChains := by + apply Finsupp.lhom_ext + rintro ⟨h, s | t⟩ n <;> simp + exact LinearMap.congr_fun he c + +theorem projectExtraChains_quotient (q : Γ →* D) (c : BasedChains Γ (S ⊕ T)) : + projectExtraChains (quotientChains q c) = quotientChains q (projectExtraChains c) := by + have he : (projectExtraChains (Γ := D) (S := S) (T := T)).comp (quotientChains q) = + (quotientChains q).comp projectExtraChains := by + apply Finsupp.lhom_ext + rintro ⟨h, s | t⟩ n <;> simp + exact LinearMap.congr_fun he c + +def extraRelatorMap (v : S ⊕ T → Γ) (r : R → FreeGroup (S ⊕ T)) : + BasedChains Γ R →ₗ[ℤ] BasedChains Γ T := + projectExtraChains.comp (relatorChainMap v r) + +@[simp] theorem extraRelatorMap_single (v : S ⊕ T → Γ) (r : R → FreeGroup (S ⊕ T)) + (g : Γ) (i : R) (n : ℤ) : + extraRelatorMap v r (Finsupp.single (g,i) n) = + n • projectExtraChains (pathChain v (r i) g) := by + simp [extraRelatorMap, relatorChainMap] + +theorem extraRelatorMap_equivariant (v : S ⊕ T → Γ) (r : R → FreeGroup (S ⊕ T)) : + ChainsEquivariant (extraRelatorMap v r) := by + intro g c + have he : (extraRelatorMap v r).comp (translateChains g) = + (translateChains g).comp (extraRelatorMap v r) := by + apply Finsupp.lhom_ext + rintro ⟨h,i⟩ n + simp only [LinearMap.comp_apply, translateChains_single, extraRelatorMap_single, map_smul] + rw [← projectExtraChains_translate, pathChain_translate] + exact LinearMap.congr_fun he c + +theorem extraRelatorMap_quotientMatrix (v : S ⊕ T → Γ) (r : R → FreeGroup (S ⊕ T)) + (q : Γ →* D) : + quotientMatrix q (extraRelatorMap v r) = extraRelatorMap (fun s => q (v s)) r := by + apply Finsupp.lhom_ext + rintro ⟨g,i⟩ n + simp only [quotientMatrix_single, extraRelatorMap_single, one_smul] + rw [← projectExtraChains_quotient, pathChain_quotient, + ← projectExtraChains_translate, pathChain_translate, map_one, mul_one] + +/-- The exponent minor used on a finite quotient is a consequence of the +ordinary projected boundary isomorphism itself; no independent rank hypothesis +and no unproved flatness claim is inserted. -/ +theorem finite_extra_boundary_minor {I : Type*} [Fintype I] [DecidableEq I] + (v : S ⊕ T → Γ) (r : R → FreeGroup (S ⊕ T)) + (A : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ T) + (hA : A.toLinearMap = extraRelatorMap v r) (q : Γ →* D) (j : I ↪ D × R) : + ∃ e : I → D × T, Function.Injective e ∧ + Matrix.det (fun i k => projectExtraChains + (pathChain (fun s => q (v s)) (r (j i).2) (j i).1) (e k)) ≠ 0 := by + let B := quotientChainEquiv q A (by rw [hA]; exact extraRelatorMap_equivariant v r) + obtain ⟨e,he,hd⟩ := basis_subfamily_minor B j + refine ⟨e,he,?_⟩ + have hB : B.toLinearMap = extraRelatorMap (fun s => q (v s)) r := by + change quotientMatrix q A.toLinearMap = _ + rw [hA, extraRelatorMap_quotientMatrix] + have hb (i : I) : B (Finsupp.single (j i) 1) = projectExtraChains + (pathChain (fun s => q (v s)) (r (j i).2) (j i).1) := by + change B.toLinearMap _ = _ + rw [hB] + rcases j i with ⟨g,k⟩ + simp + simpa only [hb] using hd + +end ChainProjection +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion +section FiniteQuotientEquations +variable {Γ F S T R Z : Type*} [Group Γ] [Group F] + +/-- The exponent of a literal edge is exactly its cellular path coefficient. -/ +theorem pathSpelling_exponent [DecidableEq F] [DecidableEq S] + (v : S → F) (w : FreeGroup S) (g : F) (e : F × S) : + wordExponents (pathSpelling v w g) e = pathChain v w g e := by + have he : (FreeGroup.lift (fun i : F × S => + Multiplicative.ofAdd (if e = i then (1 : ℤ) else 0))) = + (Finsupp.applyAddHom e).toMultiplicative.comp + (FreeGroup.lift (fun i : F × S => Multiplicative.ofAdd (Finsupp.single i (1 : ℤ)))) := by + apply FreeGroup.ext_hom + intro i + simp [Finsupp.single_apply, eq_comm] + simp only [wordExponents, he, MonoidHom.comp_apply, pathSpelling_abelianization] + rfl + +omit [Group F] in +/-- Projection to the extra alphabet really deletes only the prescribed edges. -/ +theorem projectExtraChains_apply (c : BasedChains F (S ⊕ T)) (e : F × T) : + projectExtraChains c e = c (e.1, Sum.inr e.2) := by + classical + induction c using Finsupp.induction_linear with + | zero => simp + | add c d hc hd => simp only [map_add, Finsupp.add_apply, hc, hd] + | single p n => + rcases p with ⟨g,s | t⟩ + · simp + · simp [Finsupp.single_apply, Prod.ext_iff] + +/-- Sup norm agrees with the zero-normalized supremum, including an empty index. -/ +theorem norm_eq_familySize {I : Type*} [Fintype I] (f : I → ℍ) : + ‖f‖ = familySize (fun i => ‖f i‖) := by + have hb : BddAbove (Set.range (fun i => ‖f i‖)) := Set.finite_range _ |>.bddAbove + apply le_antisymm + · exact (pi_norm_le_iff_of_nonneg (familySize_nonneg _ hb)).mpr + (fun i => le_familySize _ hb i) + · exact familySize_le _ (norm_nonneg _) (fun i => norm_le_pi_norm f i) + +/-- Reindexing does not change the actual supremum norm of a finite word family. -/ +theorem norm_comp_equiv {I J : Type*} [Fintype I] [Fintype J] (e : I ≃ J) (f : J → ℍ) : + ‖fun i => f (e i)‖ = ‖f‖ := by + apply le_antisymm + · exact (pi_norm_le_iff_of_nonneg (norm_nonneg _)).mpr fun i => norm_le_pi_norm f (e i) + · exact (pi_norm_le_iff_of_nonneg (norm_nonneg _)).mpr fun j => by + simpa using norm_le_pi_norm (fun i => f (e i)) (e.symm j) + +end FiniteQuotientEquations +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion ContDiff +open Set +section FiniteQuotientSolvability +variable {F S T R Z : Type*} [Group F] [Fintype F] [Fintype Z] + +/-- The full finite quotient step. All coefficients on the prescribed alphabet +are retained exactly, not merely up to a small perturbation. -/ +theorem finite_quotient_comparison_solvable + (v : S ⊕ T → F) (r : Z ⊕ R → FreeGroup (S ⊕ T)) (z : Z → FreeGroup S) + (A : Finset R) (B : Finset R) (hAB : A ⊆ B) + (Q : BasedChains F R ≃ₗ[ℤ] BasedChains F T) + (hQ : Q.toLinearMap = extraRelatorMap v (fun i => r (.inr i))) + (C δ η : ℝ) (hC : 0 ≤ C) (hδ : 0 < δ) (hη : 0 < η) (hη1 : η < 1) + (hc₁ : C*(δ+η) < 1/2) (hc₂ : C*η < δ/2) + (hcomp : ∀ (b : F → S ⊕ T → SU2) (h : ℝ), 0 ≤ h → + (∀ g s, ‖(b g (.inl s) : ℍ)-1‖ ≤ η) → + (∀ i ∈ A, ∀ g, pathProduct (H := SU2) v b (r (.inr i)) g = 1) → + (∀ i g, ‖(pathProduct (H := SU2) v b (r (.inl i)) g : ℍ)-1‖ ≤ h) → + ∀ i g, + ‖(pathProduct (H := SU2) v b (FreeGroup.map Sum.inl (z i)) g : ℍ) - + (pathProduct (H := SU2) v b (r (.inl i)) g : ℍ)‖ ≤ C*(η+h)*h ∧ + ‖(pathProduct (H := SU2) v b (FreeGroup.map Sum.inl (z i)) g : ℍ)-1‖ ≤ C*η) + (a : F → S → SU2) (ha : ∀ g s, ‖(a g s : ℍ)-1‖ < η) : + ∃ b : F → T → SU2, + (∀ i ∈ B, ∀ g, pathProduct (H := SU2) v (mergeLabels a b) (r (.inr i)) g = 1) ∧ + (∀ i g, ‖(pathProduct (H := SU2) v (mergeLabels a b) (r (.inl i)) g : ℍ)-1‖ < δ) := by + classical + let I := F × ↥B + let J := F × Z + let eI : Fin (Fintype.card I) ≃ I := (Fintype.equivFin I).symm + let eJ : Fin (Fintype.card J) ≃ J := (Fintype.equivFin J).symm + let j : Fin (Fintype.card I) ↪ F × R := + ⟨fun k => ((eI k).1, (eI k).2.val), fun k l h => by + apply eI.injective + exact Prod.ext (congrArg (fun p : F × R => p.1) h) (Subtype.ext (congrArg (fun p : F × R => p.2) h))⟩ + obtain ⟨e,he,hd⟩ := finite_extra_boundary_minor v (fun i => r (.inr i)) Q hQ + (MonoidHom.id F) j + let σ : Fin (Fintype.card I) ↪ F × (S ⊕ T) := + ⟨fun k => ((e k).1, .inr (e k).2), fun k l h => + he (Prod.ext (congrArg (fun p : F × (S ⊕ T) => p.1) h) + (Sum.inr_injective (congrArg (fun p : F × (S ⊕ T) => p.2) h)))⟩ + let w : Fin (Fintype.card I) → FreeGroup (F × (S ⊕ T)) := + fun k => pathSpelling v (r (.inr (eI k).2.val)) (eI k).1 + let ρ : Fin (Fintype.card J) → FreeGroup (F × (S ⊕ T)) := + fun k => pathSpelling v (r (.inl (eJ k).2)) (eJ k).1 + have hdet : Matrix.det (fun i k => wordExponents (w i) (σ k)) ≠ 0 := by + simp only [projectExtraChains_apply, MonoidHom.id_apply] at hd + simp only [w, pathSpelling_exponent] + exact hd + let base : F × (S ⊕ T) → SU2 := fun p => Sum.elim (a p.1) (fun _ => 1) p.2 + have hbase (p) : ‖(base p : ℍ)-1‖ < 1 := by + rcases p with ⟨g,s | t⟩ + · exact (ha g s).trans hη1 + · simp [base] + let arc : ℝ → F × (S ⊕ T) → SU2 := fun t p => smallQuaternionArc (base p) t + let L (t : ℝ) (x : Fin (Fintype.card I) → SU2) : F → S ⊕ T → SU2 := + fun g s => selectedLabel σ (arc t) x (g,s) + have hleft (g : F) (s : S) (k : Fin (Fintype.card I)) : σ k ≠ (g,.inl s) := by + change ((e k).1, Sum.inr (e k).2) ≠ (g,Sum.inl s) + simp + have hsmall (t : ℝ) (x : Fin (Fintype.card I) → SU2) (g : F) (s : S) : + ‖(L t x g (.inl s) : ℍ)-1‖ ≤ η := by + dsimp only [L] + rw [selectedLabel_other σ _ x _ (hleft g s)] + exact (smallQuaternionArc_distance (base (g,.inl s)) (hbase _) t).trans (ha g s).le + have hword (b : F × (S ⊕ T) → SU2) (r : FreeGroup (S ⊕ T)) (g : F) : + FreeGroup.lift b (pathSpelling v r g) = pathProduct (H := SU2) v (fun g s => b (g,s)) r g := + pathSpelling_eval v (fun g s => b (g,s)) r g + obtain ⟨b,hfixed,hw,hρ⟩ := selected_word_sublevel_solvable σ w ρ arc + (fun p => smallQuaternionArc_smooth _ (hbase p)) (by intro p; simp [arc]) + hdet δ hδ (fun t _ x hx => by + let f : J → ℍ := fun p => (pathProduct (H := SU2) v (L t x) (r (.inl p.2)) p.1 : ℍ)-1 + have hordinary (i : R) (hi : i ∈ B) (g : F) : + pathProduct (H := SU2) v (L t x) (r (.inr i)) g = 1 := by + have h := hx (eI.symm (g,⟨i,hi⟩)) + simpa only [w, Equiv.apply_symm_apply, hword] using h + have hb (i : Z) (g : F) : ‖(pathProduct (H := SU2) v (L t x) (r (.inl i)) g : ℍ)-1‖ ≤ + C*η + C*(‖f‖+η)*‖f‖ := by + obtain ⟨h₁,h₂⟩ := hcomp (L t x) ‖f‖ (norm_nonneg _) (hsmall t x) + (fun i hi => hordinary i (hAB hi)) + (fun i g => norm_le_pi_norm f (g,i)) i g + have htri := norm_sub_le_norm_sub_add_norm_sub (pathProduct (H := SU2) v (L t x) (r (.inl i)) g : ℍ) + (pathProduct (H := SU2) v (L t x) (FreeGroup.map Sum.inl (z i)) g : ℍ) 1 + calc + _ ≤ C*(η+‖f‖)*‖f‖ + C*η := htri.trans (add_le_add ((norm_sub_rev _ _).trans_le h₁) h₂) + _ = _ := by ring + have hne : ‖f‖ ≠ δ := by + rw [norm_eq_familySize] + exact familySize_ne_threshold (fun p : J => ‖f p‖) (Set.finite_range _ |>.bddAbove) + C δ η η hδ hC hη.le hη.le le_rfl hc₁ hc₂ (fun p => by + simpa only [← norm_eq_familySize] using hb p.2 p.1) + have heq : ‖(fun k => (FreeGroup.lift (selectedLabel σ (arc t) x) (ρ k) : ℍ))-1‖ = ‖f‖ := by + change ‖fun k => (FreeGroup.lift (selectedLabel σ (arc t) x) (ρ k) : ℍ)-1‖ = _ + simpa only [ρ, hword, f, L] using norm_comp_equiv eJ f + intro h + exact hne (heq.symm.trans h)) + let b' : F → T → SU2 := fun g t => b (g,.inr t) + have heval : (fun g s => b (g,s)) = mergeLabels a b' := by + funext g s + rcases s with s | t + · rw [hfixed _ (hleft g s)] + simp [arc, base, mergeLabels] + · rfl + refine ⟨b',?_,?_⟩ + · intro i hi g + have h := hw (eI.symm (g,⟨i,hi⟩)) + simpa only [w, Equiv.apply_symm_apply, hword, heval] using h + · intro i g + have h := (norm_le_pi_norm + ((fun k => (FreeGroup.lift b (ρ k) : ℍ))-1) (eJ.symm (g,i))).trans_lt hρ + simpa only [ρ, Pi.sub_apply, Pi.one_apply, Equiv.apply_symm_apply, hword, heval] using h + +end FiniteQuotientSolvability +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion +section AlignedComparison +variable {Γ : Type u} {S T Z R : Type*} [Group Γ] [Group.ResiduallyFinite Γ] [Fintype Z] + +omit [Group.ResiduallyFinite Γ] in +theorem wordValue_map_alphabet {E : Type*} (v : S → Γ) (f : E → S) (w : FreeGroup E) : + wordValue v (FreeGroup.map f w) = wordValue (fun e => v (f e)) w := by + have he : (wordValue v).comp (FreeGroup.map f) = wordValue (fun e => v (f e)) := by + apply FreeGroup.ext_hom + intro e + simp [wordValue] + exact congrArg (fun h : FreeGroup E →* Γ => h w) he + +/-- The algebraic core of the manuscript's presentation comparison, for an +actual aligned presentation. The passage from arbitrary ordinary CW classifying +spaces to this presentation is a separate topological obligation. -/ +theorem aligned_presentation_small_transport + (v : S ⊕ T → Γ) (r : Z ⊕ R → FreeGroup (S ⊕ T)) (z : Z → FreeGroup S) + (hvT : ∀ t, v (.inr t) = 1) + (hr : ∀ i, wordValue v (r i) = 1) + (hz : ∀ i, wordValue (fun s => v (.inl s)) (z i) = 1) + (hp : (wordValue v).ker = Subgroup.normalClosure (Set.range r)) + (hinj : Function.Injective (relatorChainMap v r)) + (hchain : ∀ i, pathChain v (FreeGroup.map Sum.inl (z i)) 1 = pathChain v (r (.inl i)) 1) + (Q : BasedChains Γ R ≃ₗ[ℤ] BasedChains Γ T) + (hQ : Q.toLinearMap = extraRelatorMap v (fun i => r (.inr i))) : + ∃ η : ℝ, 0 < η ∧ ∀ a : Γ → S → SU2, + (∀ g s, ‖(a g s : ℍ)-1‖ < η) → + (∀ i g, pathProduct (fun s => v (.inl s)) a (z i) g = 1) → + ∀ w : FreeGroup S, wordValue (fun s => v (.inl s)) w = 1 → ∀ g, + pathProduct (fun s => v (.inl s)) a w g = 1 := by + classical + have hzn (i) : FreeGroup.map Sum.inl (z i) ∈ Subgroup.normalClosure (Set.range r) := by + rw [← hp] + change wordValue v (FreeGroup.map Sum.inl (z i)) = 1 + rw [wordValue_map_alphabet, hz] + have htn (t) : FreeGroup.of (.inr t) ∈ Subgroup.normalClosure (Set.range r) := by + rw [← hp] + change wordValue v (FreeGroup.of (.inr t)) = 1 + simpa [wordValue] using hvT t + choose lz hlz using fun i => exists_normalExpression r (hzn i) + choose lt hlt using fun t => exists_normalExpression r (htn t) + have hc (i) : ((lz i).map (fun f => normalFactorCount v f 1)).sum = + Finsupp.single (1,Sum.inl i) 1 := + exact_translated_relator_counts v r hr hinj _ (.inl i) (hchain i) (lz i) (hlz i) + obtain ⟨A,C,hC,hcomp⟩ := finite_normal_comparison v r hr z lz lt hlz hlt hc + obtain ⟨δ,η,hδ,hδ1,hη,hη1,hc₁,hc₂⟩ := small_thresholds_exist C hC + refine ⟨η,hη,?_⟩ + intro a ha haz + let W : Γ × (Z ⊕ R) → FreeGroup (S ⊕ T) := fun p => r p.2 + let K : Γ × (Z ⊕ R) → Set SU2 := fun p => match p.2 with + | .inl _ => {b | ‖(b : ℍ)-1‖ ≤ δ} + | .inr _ => {1} + have hK (p) : IsClosed (K p) := by + rcases p with ⟨g,i | i⟩ + · exact isClosed_le ((continuous_subtype_val.sub continuous_const).norm) continuous_const + · exact isClosed_singleton + obtain ⟨b,hb⟩ := compact_labeling_from_finite_quotients v a W Prod.fst K hK + (fun b : SU2 => ‖(b : ℍ)-1‖ < η) (by simpa using hη) ha (by + intro N J aF haF + let : Fintype (Γ ⧸ N.toSubgroup) := Fintype.ofFinite _ + let q := QuotientGroup.mk' N.toSubgroup + let B := A ∪ (J.image Prod.snd).toRight + let QF := quotientChainEquiv q Q (by rw [hQ]; exact extraRelatorMap_equivariant _ _) + have hQF : QF.toLinearMap = extraRelatorMap (fun s => q (v s)) (fun i => r (.inr i)) := by + change quotientMatrix q Q.toLinearMap = _ + rw [hQ, extraRelatorMap_quotientMatrix] + obtain ⟨bF,hord,hdis⟩ := finite_quotient_comparison_solvable (fun s => q (v s)) r z A B + (Finset.subset_union_left) QF hQF C δ η (by linarith) hδ hη hη1 hc₁ hc₂ + (fun b h hh hsmall hord hdist => hcomp q b η h hη.le hh hsmall hord hdist) aF haF + refine ⟨bF,?_⟩ + rintro ⟨g,i | i⟩ hi d + · exact (hdis i d).le + · exact hord i (Finset.mem_union_right _ (Finset.mem_toRight.mpr + (Finset.mem_image.mpr ⟨(g,.inr i),hi,rfl⟩))) d) + have hord (i : R) (g : Γ) : pathProduct v (mergeLabels a b) (r (.inr i)) g = 1 := + hb (g,.inr i) + have hdis (i : Z) (g : Γ) : ‖(pathProduct (H := SU2) v (mergeLabels a b) (r (.inl i)) g : ℍ)-1‖ ≤ δ := + hb (g,.inl i) + let f : Z × Γ → ℝ := fun p => ‖(pathProduct (H := SU2) v (mergeLabels a b) (r (.inl p.1)) p.2 : ℍ)-1‖ + have hbounded : BddAbove (Set.range f) := ⟨δ, by rintro _ ⟨⟨i,g⟩,rfl⟩; exact hdis i g⟩ + have hzero : ∀ p, f p = 0 := familySize_contraction f (fun _ => norm_nonneg _) + δ C η hδ.le (by linarith) hη.le (fun p => hdis p.1 p.2) (by linarith) (by + rintro ⟨i,g⟩ + have h := (hcomp (MonoidHom.id Γ) (mergeLabels a b) η (familySize f) hη.le + (familySize_nonneg f hbounded) (fun g s => (ha g s).le) (fun i _ => hord i) + (fun i g => le_familySize f hbounded (i,g)) i g).1 + have hz' : pathProduct v (mergeLabels a b) (FreeGroup.map Sum.inl (z i)) g = 1 := by + rw [pathProduct_map_alphabet] + exact haz i g + change ‖(pathProduct (H := SU2) v (mergeLabels a b) (FreeGroup.map Sum.inl (z i)) g : ℍ)- + (pathProduct (H := SU2) v (mergeLabels a b) (r (.inl i)) g : ℍ)‖ ≤ _ at h + rw [hz'] at h + change ‖(1 : ℍ) - (pathProduct (H := SU2) v (mergeLabels a b) (r (.inl i)) g : ℍ)‖ ≤ + C * (η + familySize f) * familySize f at h + change ‖(pathProduct (H := SU2) v (mergeLabels a b) (r (.inl i)) g : ℍ) - 1‖ ≤ + C * (familySize f + η) * familySize f + rw [norm_sub_rev] + rwa [add_comm η (familySize f)] at h) + have hdist (i : Z) (g : Γ) : pathProduct v (mergeLabels a b) (r (.inl i)) g = 1 := by + apply Subtype.ext + exact sub_eq_zero.mp (norm_eq_zero.mp (hzero (i,g))) + intro w hw g + have hw' : wordValue v (FreeGroup.map Sum.inl w) = 1 := by + rw [wordValue_map_alphabet, hw] + have h := pathProduct_trivial_of_relators v (mergeLabels a b) (Set.range r) + (by rintro _ ⟨i,rfl⟩; exact hr i) hp + (by rintro _ ⟨i | i,rfl⟩ g; exact hdist i g; exact hord i g) + (FreeGroup.map Sum.inl w) hw' g + simpa only [pathProduct_map_alphabet, mergeLabels, Sum.elim_inl, Function.comp_def] using h + +end AlignedComparison +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/Regularization.lean b/lean/OAI/Topology/EilenbergGanea/Regularization.lean new file mode 100644 index 0000000000000000000000000000000000000000..86b17239caeedfbcc429048c82126bef6e7dbf10 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/Regularization.lean @@ -0,0 +1,1199 @@ +import Mathlib.Tactic +import Mathlib.Analysis.Calculus.InverseFunctionTheorem.FiniteDimensional +import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff +import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension +import Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox +import Mathlib.Analysis.Calculus.FDeriv.Equiv +import Mathlib.Analysis.Complex.Basic +import Mathlib.Analysis.InnerProductSpace.PiL2 +import Mathlib.RingTheory.Complex +import Mathlib.LinearAlgebra.Eigenspace.Minpoly +import Mathlib.MeasureTheory.Function.Jacobian + +namespace OAI + +noncomputable section + +open Set Filter Topology + +/-! Localized regularization for finite SU(2) systems. -/ +namespace EilenbergGanea +section ComplexCentralizer +variable {V : Type*} [AddCommGroup V] [Module ℂ V] [Module ℝ V] + [IsScalarTower ℝ ℂ V] + +theorem complex_smul_decompose (z : ℂ) (x : V) : + z • x = z.re • x + z.im • (Complex.I • x) := by + conv_lhs => rw [← Complex.re_add_im z] + rw [add_smul, mul_smul] + change (algebraMap ℝ ℂ z.re) • x + + (algebraMap ℝ ℂ z.im) • (Complex.I • x) = _ + simp only [IsScalarTower.algebraMap_smul] + +/-- Commuting with a non-real scalar forces a real-linear map to be complex-linear. -/ +theorem realLinear_map_complex_smul (f : V →ₗ[ℝ] V) (z : ℂ) (hz : z.im ≠ 0) + (hf : ∀ x, f (z • x) = z • f x) (w : ℂ) (x : V) : + f (w • x) = w • f x := by + have hI (y : V) : f (Complex.I • y) = Complex.I • f y := by + have he := hf y + rw [complex_smul_decompose z y, complex_smul_decompose z (f y), + map_add, map_smul, map_smul] at he + exact smul_right_injective V hz (add_left_cancel he) + rw [complex_smul_decompose w x, complex_smul_decompose w (f x), + map_add, map_smul, map_smul, hI] + +theorem complexLinear_of_commutes_nonreal (N : V →ₗ[ℝ] V) (z : ℂ) (hz : z.im ≠ 0) + (h : ∀ v, N (z • v) = z • N v) : + ∃ C : V →ₗ[ℂ] V, C.restrictScalars ℝ = N := by + let C : V →ₗ[ℂ] V := + { toFun := N + map_add' := N.map_add + map_smul' := realLinear_map_complex_smul N z hz h } + exact ⟨C, rfl⟩ + +end ComplexCentralizer + +section RotationDerivative +variable {A V : Type*} [AddCommGroup A] [Module ℝ A] + [AddCommGroup V] [Module ℂ V] [Module ℝ V] [IsScalarTower ℝ ℂ V] + +/-- A real derivative commuting with the fixed-plus-rotating representation +has no mixed blocks. Its normal block is complex-linear. -/ +theorem rotation_commutant_blocks (L : A × V →ₗ[ℝ] A × V) + (z : ℂ) (hz : z.im ≠ 0) + (h : ∀ a v, L (a, z • v) = ((L (a, v)).1, z • (L (a, v)).2)) : + ∃ (T : A →ₗ[ℝ] A) (N : V →ₗ[ℂ] V), + L = T.prodMap (N.restrictScalars ℝ) := by + have hz1 : z ≠ 1 := by intro he; simp [he] at hz + let T := (LinearMap.fst ℝ A V).comp (L.comp (LinearMap.inl ℝ A V)) + let N := (LinearMap.snd ℝ A V).comp (L.comp (LinearMap.inr ℝ A V)) + let P := (LinearMap.fst ℝ A V).comp (L.comp (LinearMap.inr ℝ A V)) + have hP (v : V) : P (z • v) = P v := by + have hv := congrArg Prod.fst (h 0 v) + exact hv + have hPzero (v : V) : P v = 0 := by + let u := (z - 1)⁻¹ • v + have huv : z • u - u = v := by + dsimp [u] + calc + z • ((z - 1)⁻¹ • v) - (z - 1)⁻¹ • v = + (z - 1) • ((z - 1)⁻¹ • v) := by rw [sub_smul, one_smul] + _ = v := by rw [smul_smul, mul_inv_cancel₀ (sub_ne_zero.mpr hz1), one_smul] + rw [← huv, map_sub, hP, sub_self] + have hQzero (a : A) : (L (a, 0)).2 = 0 := by + have hv := congrArg Prod.snd (h a 0) + simp only [smul_zero] at hv + have hh : (z - 1) • (L (a, 0)).2 = 0 := by + rw [sub_smul, one_smul, ← hv, sub_self] + exact (smul_eq_zero.mp hh).resolve_left (sub_ne_zero.mpr hz1) + obtain ⟨C, hC⟩ := complexLinear_of_commutes_nonreal N z hz + (fun v => congrArg Prod.snd (h 0 v)) + refine ⟨T, C, ?_⟩ + rw [hC] + apply LinearMap.ext + intro q + apply Prod.ext + · change (L q).1 = T q.1 + have he : q = (q.1, 0) + (0, q.2) := by simp + rw [he, map_add] + change T q.1 + P q.2 = _ + rw [hPzero, add_zero] + simp + · change (L q).2 = N q.2 + have he : q = (q.1, 0) + (0, q.2) := by simp + rw [he, map_add] + change (L (q.1, 0)).2 + N q.2 = _ + rw [hQzero, zero_add] + simp + +end RotationDerivative + +section NormalDeterminant +variable {V : Type*} [AddCommGroup V] [Module ℂ V] [Module ℝ V] + [IsScalarTower ℝ ℂ V] [FiniteDimensional ℂ V] + +theorem complex_real_det_nonneg (N : V →ₗ[ℂ] V) : + 0 ≤ (N.restrictScalars ℝ).det := by + rw [LinearMap.det_restrictScalars, Algebra.norm_complex_apply] + exact Complex.normSq_nonneg _ + +theorem complex_real_det_pos (N : V →ₗ[ℂ] V) (hN : N.det ≠ 0) : + 0 < (N.restrictScalars ℝ).det := by + rw [LinearMap.det_restrictScalars, Algebra.norm_complex_apply] + exact Complex.normSq_pos.mpr hN + +end NormalDeterminant + +section SimultaneousShift +open Set +variable {V : Type*} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] + +/-- A single real scalar regularizes any finite collection of normal blocks. -/ +theorem exists_small_simultaneous_regular_shift {ι : Type*} [Fintype ι] + (N : ι → Module.End ℂ V) {ε : ℝ} (hε : 0 < ε) : + ∃ s : ℝ, |s| < ε ∧ ∀ i, IsUnit (N i + algebraMap ℂ (Module.End ℂ V) (s : ℂ)) := by + let bad : Set ℝ := ⋃ i, {r | -(r : ℂ) ∈ spectrum ℂ (N i)} + have hbad : bad.Finite := Set.finite_iUnion (fun i => + (Module.End.finite_spectrum (N i)).preimage + (fun _ _ _ _ h => Complex.ofReal_injective (neg_injective h))) + obtain ⟨s, hs, hgood⟩ := (Set.Ioo_infinite (by linarith : -ε < ε)).exists_notMem_finite hbad + refine ⟨s, abs_lt.mpr hs, fun i => ?_⟩ + have hn : -(s : ℂ) ∉ spectrum ℂ (N i) := by + intro hh + exact hgood (Set.mem_iUnion.mpr ⟨i, hh⟩) + have hi := (spectrum.notMem_iff.mp hn).neg + simpa only [map_neg, neg_sub, sub_neg_eq_add] using hi + +end SimultaneousShift +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff +section EquivariantDerivative +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] + +omit [FiniteDimensional ℝ E] in +theorem equivariant_fderiv (f : E → E) (L : E ≃L[ℝ] E) + (hf : Differentiable ℝ f) (he : ∀ x, f (L x) = L (f x)) (x : E) : + (fderiv ℝ f (L x)).comp L.toContinuousLinearMap = + L.toContinuousLinearMap.comp (fderiv ℝ f x) := by + have h₁ := (hf (L x)).hasFDerivAt.comp x L.hasFDerivAt + have h₂ := L.hasFDerivAt.comp x (hf x).hasFDerivAt + have hh : f ∘ L = L ∘ f := funext he + rw [hh] at h₁ + exact h₁.unique h₂ + +omit [FiniteDimensional ℝ E] in +theorem equivariant_fderiv_det (f : E → E) (L : E ≃L[ℝ] E) + (hf : Differentiable ℝ f) (he : ∀ x, f (L x) = L (f x)) (x : E) : + (fderiv ℝ f (L x)).det = (fderiv ℝ f x).det := by + have h := congrArg (fun M : E →L[ℝ] E => M.det) (equivariant_fderiv f L hf he x) + change ((fderiv ℝ f (L x)).toLinearMap.comp L.toLinearEquiv.toLinearMap).det = + (L.toLinearEquiv.toLinearMap.comp (fderiv ℝ f x).toLinearMap).det at h + rw [LinearMap.det_comp, LinearMap.det_comp, mul_comm] at h + exact mul_left_cancel₀ L.toLinearEquiv.isUnit_det'.ne_zero h +end EquivariantDerivative + +section FixedRegularization +variable {A V : Type*} [NormedAddCommGroup A] [NormedSpace ℝ A] + [NormedAddCommGroup V] [NormedSpace ℝ V] + +/-- The complement of the fixed subspace. -/ +def normalProjection : (A × V) →L[ℝ] (A × V) := + (ContinuousLinearMap.inr ℝ A V).comp (ContinuousLinearMap.snd ℝ A V) + +@[simp] theorem normalProjection_apply (x : A × V) : normalProjection x = (0, x.2) := rfl + +def normalShift (f : A × V → A × V) (s : ℝ) (x : A × V) := f x + s • normalProjection x + +theorem normalShift_contDiff (f : A × V → A × V) (hf : ContDiff ℝ ∞ f) (s : ℝ) : + ContDiff ℝ ∞ (normalShift f s) := + hf.add ((show ContDiff ℝ ∞ (fun _ : A × V => s) from contDiff_const).smul + (normalProjection (A := A) (V := V)).contDiff) + +theorem normalShift_fderiv (f : A × V → A × V) (hf : Differentiable ℝ f) (s : ℝ) (x : A × V) : + fderiv ℝ (normalShift f s) x = fderiv ℝ f x + s • normalProjection := + ((hf x).hasFDerivAt.add ((normalProjection (A := A) (V := V)).hasFDerivAt.const_smul s)).fderiv + +@[simp] theorem normalShift_fixed (f : A × V → A × V) (s : ℝ) (a : A) : + normalShift f s (a, 0) = f (a, 0) := by simp [normalShift] + +variable [NormedSpace ℂ V] [IsScalarTower ℝ ℂ V] + +def scalarRotation (z : ℂˣ) : (A × V) ≃L[ℝ] (A × V) := + (ContinuousLinearEquiv.refl ℝ A).prodCongr + ((ContinuousLinearEquiv.smulLeft z : V ≃L[ℂ] V).restrictScalars ℝ) + +@[simp] theorem scalarRotation_apply (z : ℂˣ) (q : A × V) : + scalarRotation z q = (q.1, (z : ℂ) • q.2) := rfl + +/-- At a fixed point the derivative splits with a complex-linear normal block. -/ +theorem fixed_fderiv_blocks (f : A × V → A × V) (hf : Differentiable ℝ f) + (z : ℂˣ) (hz : (z : ℂ).im ≠ 0) + (he : ∀ q, f (scalarRotation z q) = scalarRotation z (f q)) (a : A) : + ∃ (T : A →ₗ[ℝ] A) (N : V →ₗ[ℂ] V), + (fderiv ℝ f (a, 0)).toLinearMap = T.prodMap (N.restrictScalars ℝ) := by + apply rotation_commutant_blocks _ (z : ℂ) hz + intro b v + have h := congrArg (fun L : (A × V) →L[ℝ] (A × V) => L (b, v)) (equivariant_fderiv f (scalarRotation z) hf he (a, 0)) + simpa using h + +variable [FiniteDimensional ℝ A] [FiniteDimensional ℂ V] + +/-- Scalar shifts have the claimed fixed-block Jacobian, with no chart convention. -/ +theorem normalShift_fixed_det (f : A × V → A × V) (hf : Differentiable ℝ f) + (a : A) (T : A →ₗ[ℝ] A) (N : V →ₗ[ℂ] V) + (h : (fderiv ℝ f (a, 0)).toLinearMap = T.prodMap (N.restrictScalars ℝ)) (s : ℝ) : + (fderiv ℝ (normalShift f s) (a, 0)).det = + T.det * ((N + algebraMap ℂ (Module.End ℂ V) (s : ℂ)).restrictScalars ℝ).det := by + let : FiniteDimensional ℝ V := Module.Finite.trans ℂ V + rw [normalShift_fderiv f hf] + have he : (fderiv ℝ f (a, 0) + s • normalProjection).toLinearMap = + T.prodMap ((N + algebraMap ℂ (Module.End ℂ V) (s : ℂ)).restrictScalars ℝ) := by + apply LinearMap.ext + intro q + have hh := LinearMap.congr_fun h q + change (fderiv ℝ f (a, 0)) q + s • (0, q.2) = _ + change (fderiv ℝ f (a, 0)) q = (T q.1, N q.2) at hh + rw [hh] + simp only [Prod.smul_mk, smul_zero, Prod.mk_add_mk, add_zero, + LinearMap.prodMap_apply, LinearMap.restrictScalars_apply, LinearMap.add_apply, + Module.algebraMap_end_apply] + congr 2 + exact (IsScalarTower.algebraMap_smul ℂ s q.2).symm + change (fderiv ℝ f (a, 0) + s • normalProjection).toLinearMap.det = _ + rw [he, LinearMap.det_prodMap] + + +def fixedRestriction (f : A × V → A × V) (a : A) : A := (f (a, 0)).1 + +omit [FiniteDimensional ℝ A] [FiniteDimensional ℂ V] in +theorem fixedRestriction_fderiv (f : A × V → A × V) (hf : Differentiable ℝ f) + (a : A) (T : A →ₗ[ℝ] A) (N : V →ₗ[ℂ] V) + (h : (fderiv ℝ f (a, 0)).toLinearMap = T.prodMap (N.restrictScalars ℝ)) : + (fderiv ℝ (fixedRestriction f) a).toLinearMap = T := by + have hd := (ContinuousLinearMap.fst ℝ A V).hasFDerivAt.comp a + ((hf (a, 0)).hasFDerivAt.comp a (ContinuousLinearMap.inl ℝ A V).hasFDerivAt) + have hfun : (ContinuousLinearMap.fst ℝ A V) ∘ (f ∘ (ContinuousLinearMap.inl ℝ A V)) = + fixedRestriction f := rfl + rw [hfun] at hd + rw [hd.fderiv] + apply LinearMap.ext + intro q + exact congrArg Prod.fst (LinearMap.congr_fun h (q, 0)) + +/-- Simultaneously regularize the finite fixed fiber, retaining its tangent sign. -/ +theorem exists_normalShift_regular_fixed (f : A × V → A × V) (hf : Differentiable ℝ f) + (z : ℂˣ) (hz : (z : ℂ).im ≠ 0) + (he : ∀ q, f (scalarRotation z q) = scalarRotation z (f q)) + (S : Finset A) (c : ℝ) (hc : c ≠ 0) + (hT : ∀ a ∈ S, (fderiv ℝ (fixedRestriction f) a).det = c) + (ε : ℝ) (hε : 0 < ε) : + ∃ s : ℝ, |s| < ε ∧ ∀ a ∈ S, + (fderiv ℝ (normalShift f s) (a, 0)).det ≠ 0 ∧ + (0 < (fderiv ℝ (normalShift f s) (a, 0)).det ↔ 0 < c) := by + classical + choose T N hblock using (fun a : S => fixed_fderiv_blocks f hf z hz he a.val) + obtain ⟨s, hs, hregular⟩ := exists_small_simultaneous_regular_shift N hε + refine ⟨s, hs, fun a ha => ?_⟩ + let i : S := ⟨a, ha⟩ + have ht : (T i).det = c := by + rw [← fixedRestriction_fderiv f hf a (T i) (N i) (hblock i)] + exact hT a ha + have hn : 0 < ((N i + algebraMap ℂ (Module.End ℂ V) (s : ℂ)).restrictScalars ℝ).det := + complex_real_det_pos _ (LinearMap.isUnit_det _ (hregular i)).ne_zero + rw [normalShift_fixed_det f hf a (T i) (N i) (hblock i), ht] + exact ⟨mul_ne_zero hc hn.ne', mul_pos_iff_of_pos_right hn⟩ + +end FixedRegularization +end EilenbergGanea + +open Set Filter Topology +namespace EilenbergGanea +section LinearParameters +variable {ι E : Type*} [Fintype ι] [DecidableEq ι] + [NormedAddCommGroup E] [NormedSpace ℝ E] + +def linearPerturbation (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (x : E) (p : ι → E) : E := f x + ∑ j, T j x (p j) + +def linearPerturbationDerivative (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (x : E) (p : ι → E) : E →L[ℝ] E := + fderiv ℝ f x + ∑ j, (fderiv ℝ (T j) x).flip (p j) + +omit [DecidableEq ι] in +theorem linearPerturbation_hasFDerivAt (f : E → E) (T : ι → E → (E →L[ℝ] E)) + {x : E} (hf : DifferentiableAt ℝ f x) (hT : ∀ j, DifferentiableAt ℝ (T j) x) + (p : ι → E) : HasFDerivAt (fun z => linearPerturbation f T z p) + (linearPerturbationDerivative f T x p) x := by + apply hf.hasFDerivAt.add + apply HasFDerivAt.fun_sum + intro j _ + simpa using (hT j).hasFDerivAt.clm_apply (hasFDerivAt_const (p j) x) + +def linearSolvedParameter (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (i : ι) (q : ι → E) : ι → E := + Function.update q i (-(Ring.inverse (T i (q i)) + (f (q i) + ∑ j ∈ Finset.univ.erase i, T j (q i) (q j)))) + +theorem linearSolvedParameter_outside (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (i j : ι) (hji : j ≠ i) : + (fun q => linearSolvedParameter f T i q j) = fun q => q j := by + funext q + exact Function.update_of_ne hji _ _ + +theorem inverse_apply_cancel (A : E →L[ℝ] E) (hA : IsUnit A) (v : E) : + Ring.inverse A (A v) = v := by + exact congrArg (fun B : E →L[ℝ] E => B v) (Ring.inverse_mul_cancel A hA) + +theorem apply_inverse_cancel (A : E →L[ℝ] E) (hA : IsUnit A) (v : E) : + A (Ring.inverse A v) = v := by + exact congrArg (fun B : E →L[ℝ] E => B v) (Ring.mul_inverse_cancel A hA) + +theorem linearSolvedParameter_root (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (i : ι) (q : ι → E) (hi : IsUnit (T i (q i))) : + linearPerturbation f T (q i) (linearSolvedParameter f T i q) = 0 := by + rw [linearPerturbation, ← Finset.sum_erase_add _ _ (Finset.mem_univ i)] + have he : (∑ j ∈ Finset.univ.erase i, T j (q i) (linearSolvedParameter f T i q j)) = + ∑ j ∈ Finset.univ.erase i, T j (q i) (q j) := by + apply Finset.sum_congr rfl + intro j hj + rw [linearSolvedParameter, Function.update_of_ne (Finset.ne_of_mem_erase hj)] + rw [he] + simp only [linearSolvedParameter, Function.update_self, map_neg, + apply_inverse_cancel _ hi] + abel + +variable [FiniteDimensional ℝ E] + +theorem linearSolvedParameter_differentiableAt (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (i : ι) (q : ι → E) (hf : DifferentiableAt ℝ f (q i)) + (hT : ∀ j, DifferentiableAt ℝ (T j) (q i)) (hi : IsUnit (T i (q i))) : + DifferentiableAt ℝ (linearSolvedParameter f T i) q := by + have hproj := differentiableAt_apply i q (𝕜 := ℝ) + apply differentiableAt_pi.mpr + intro j + by_cases hj : j = i + · subst j + simp only [linearSolvedParameter, Function.update_self] + apply DifferentiableAt.neg + apply DifferentiableAt.clm_apply + · exact ((hT i).inverse hi).comp q hproj + · exact (hf.comp q hproj).add (DifferentiableAt.fun_sum (fun k _ => + ((hT k).comp q hproj).clm_apply (differentiableAt_apply k q))) + · simpa only [linearSolvedParameter_outside f T i j hj] using differentiableAt_apply j q (𝕜 := ℝ) + +omit [FiniteDimensional ℝ E] in +theorem linearSolvedParameter_fderiv_outside (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (i j : ι) (hji : j ≠ i) (q : ι → E) + (hG : DifferentiableAt ℝ (linearSolvedParameter f T i) q) : + (ContinuousLinearMap.proj j : (ι → E) →L[ℝ] E).comp + (fderiv ℝ (linearSolvedParameter f T i) q) = ContinuousLinearMap.proj j := by + have h := ((ContinuousLinearMap.proj j : (ι → E) →L[ℝ] E)).hasFDerivAt.comp q hG.hasFDerivAt + have he : (ContinuousLinearMap.proj j : (ι → E) →L[ℝ] E) ∘ + linearSolvedParameter f T i = fun q => q j := + linearSolvedParameter_outside f T i j hji + rw [he] at h + exact h.unique ((ContinuousLinearMap.proj j : (ι → E) →L[ℝ] E)).hasFDerivAt + +theorem linearSolvedParameter_differential_relation + (f : E → E) (T : ι → E → (E →L[ℝ] E)) (i : ι) (q : ι → E) + (hf : DifferentiableAt ℝ f (q i)) (hT : ∀ j, DifferentiableAt ℝ (T j) (q i)) + (hi : IsUnit (T i (q i))) (v : E) : + linearPerturbationDerivative f T (q i) (linearSolvedParameter f T i q) v + + ∑ j, T j (q i) ((fderiv ℝ (linearSolvedParameter f T i) q (Pi.single i v)) j) = 0 := by + let G := linearSolvedParameter f T i + have hG := linearSolvedParameter_differentiableAt f T i q hf hT hi + have hfi := hf.hasFDerivAt.comp q ((ContinuousLinearMap.proj i : (ι → E) →L[ℝ] E)).hasFDerivAt + have hx := hfi.fun_add (HasFDerivAt.fun_sum (u := Finset.univ) (fun j _ => + ((hT j).hasFDerivAt.comp q ((ContinuousLinearMap.proj i : (ι → E) →L[ℝ] E)).hasFDerivAt).clm_apply + (((ContinuousLinearMap.proj j : (ι → E) →L[ℝ] E)).hasFDerivAt.comp q hG.hasFDerivAt))) + have hz : (fun t => linearPerturbation f T (t i) (G t)) =ᶠ[𝓝 q] fun _ => 0 := by + have hcont : ContinuousAt (fun t : ι → E => T i (t i)) q := + ((hT i).comp q (differentiableAt_apply i q)).continuousAt + have he : ∀ᶠ t in 𝓝 q, IsUnit (T i (t i)) := + hcont (Units.isOpen.mem_nhds hi) + filter_upwards [he] with t ht + exact linearSolvedParameter_root f T i t ht + have hc := (hasFDerivAt_const (𝕜 := ℝ) (0 : E) q).congr_of_eventuallyEq hz + have he := congrArg (fun l : (ι → E) →L[ℝ] E => l (Pi.single i v)) (hx.unique hc) + simp only [add_apply, sum_apply, ContinuousLinearMap.comp_apply, + ContinuousLinearMap.proj_apply, ContinuousLinearMap.flip_apply, + Pi.single_eq_same, zero_apply, Finset.sum_add_distrib] at he + simp only [linearPerturbationDerivative, add_apply, sum_apply, ContinuousLinearMap.flip_apply] + dsimp [G] at he + exact (by convert he using 1; abel) + +omit [FiniteDimensional ℝ E] in +theorem linearSolvedParameter_recovers_root (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (i : ι) (x : E) (p : ι → E) (hi : IsUnit (T i x)) + (hroot : linearPerturbation f T x p = 0) : + linearSolvedParameter f T i (Function.update p i x) = p := by + have he : (∑ j ∈ Finset.univ.erase i, T j x (Function.update p i x j)) = + ∑ j ∈ Finset.univ.erase i, T j x (p j) := by + apply Finset.sum_congr rfl + intro j hj + rw [Function.update_of_ne (Finset.ne_of_mem_erase hj)] + have hs : T i x (p i) = -(f x + ∑ j ∈ Finset.univ.erase i, T j x (p j)) := by + rw [linearPerturbation, ← Finset.sum_erase_add _ _ (Finset.mem_univ i), + ← add_assoc] at hroot + exact eq_neg_of_add_eq_zero_right hroot + funext j + by_cases hj : j = i + · subst j + simp only [linearSolvedParameter, Function.update_self, he] + rw [← map_neg, ← hs, inverse_apply_cancel _ hi] + · simp [linearSolvedParameter, Function.update_of_ne hj] + +theorem linearSolvedParameter_critical (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (i : ι) (q : ι → E) (hf : DifferentiableAt ℝ f (q i)) + (hT : ∀ j, DifferentiableAt ℝ (T j) (q i)) (hi : IsUnit (T i (q i))) + (hcrit : (linearPerturbationDerivative f T (q i) (linearSolvedParameter f T i q)).det = 0) : + (fderiv ℝ (linearSolvedParameter f T i) q).det = 0 := by + have hG := linearSolvedParameter_differentiableAt f T i q hf hT hi + obtain ⟨v, hv, hv0⟩ := Submodule.exists_mem_ne_zero_of_ne_bot + (LinearMap.det_eq_zero_iff_ker_ne_bot.mp hcrit) + change linearPerturbationDerivative f T (q i) (linearSolvedParameter f T i q) v = 0 at hv + let w := fderiv ℝ (linearSolvedParameter f T i) q (Pi.single i v) + have hw (j : ι) (hji : j ≠ i) : w j = 0 := by + have he := congrArg (fun l : (ι → E) →L[ℝ] E => l (Pi.single i v)) + (linearSolvedParameter_fderiv_outside f T i j hji q hG) + simpa [w, Pi.single_eq_of_ne hji] using he + have hrel := linearSolvedParameter_differential_relation f T i q hf hT hi v + rw [hv, zero_add] at hrel + have hwi : w i = 0 := by + have hs : (∑ j, T j (q i) (w j)) = T i (q i) (w i) := by + apply Finset.sum_eq_single i + · intro j _ hji + simp [hw j hji] + · simp + rw [hs] at hrel + have he := congrArg (fun v => Ring.inverse (T i (q i)) v) hrel + simpa only [inverse_apply_cancel _ hi, map_zero] using he + apply LinearMap.det_eq_zero_iff_ker_ne_bot.mpr + apply (Submodule.ne_bot_iff _).mpr + refine ⟨Pi.single i v, ?_, ?_⟩ + · change w = 0 + funext j + by_cases hj : j = i + · subst j; exact hwi + · exact hw j hj + · intro he + apply hv0 + simpa using congrFun he i + +/-- Transversality with source-dependent linear parameter blocks, including +finite equivariant bump perturbations. Only invertibility of a single active +block is required at each root. -/ +theorem ae_regular_linear_parameters [MeasurableSpace E] [BorelSpace E] + (μ : MeasureTheory.Measure (ι → E)) [μ.IsAddHaarMeasure] + (f : E → E) (T : ι → E → (E →L[ℝ] E)) (s : Set E) + (hf : ∀ x ∈ s, DifferentiableAt ℝ f x) + (hT : ∀ i x, x ∈ s → DifferentiableAt ℝ (T i) x) : + ∀ᵐ p ∂μ, ∀ x ∈ s, linearPerturbation f T x p = 0 → + (∃ i, IsUnit (T i x)) → (linearPerturbationDerivative f T x p).det ≠ 0 := by + let C : ι → Set (ι → E) := fun i => + {q | q i ∈ s ∧ IsUnit (T i (q i)) ∧ (fderiv ℝ (linearSolvedParameter f T i) q).det = 0} + have hnull (i : ι) : μ (linearSolvedParameter f T i '' C i) = 0 := by + apply MeasureTheory.addHaar_image_eq_zero_of_det_fderivWithin_eq_zero μ + · intro q hq + exact (linearSolvedParameter_differentiableAt f T i q (hf _ hq.1) + (fun j => hT j _ hq.1) hq.2.1).hasFDerivAt.hasFDerivWithinAt + · intro q hq + exact hq.2.2 + have hae : ∀ᵐ p ∂μ, p ∉ ⋃ i, linearSolvedParameter f T i '' C i := by + rw [MeasureTheory.ae_iff] + simpa only [not_not, Set.ofPred_mem_eq] using MeasureTheory.measure_iUnion_null hnull + filter_upwards [hae] with p hp + intro x hs hx ⟨i, hi⟩ hcrit + let q := Function.update p i x + have hqi : q i = x := Function.update_self _ _ _ + have hGq : linearSolvedParameter f T i q = p := + linearSolvedParameter_recovers_root f T i x p hi hx + apply hp + apply Set.mem_iUnion.mpr + refine ⟨i, q, ⟨?_, ?_, ?_⟩, hGq⟩ + · simpa only [hqi] using hs + · simpa only [hqi] using hi + · apply linearSolvedParameter_critical f T i q + (by simpa only [hqi] using hf x hs) + (fun j => by simpa only [hqi] using hT j x hs) + · simpa only [hqi] using hi + · simpa only [hqi, hGq] using hcrit + +end LinearParameters +end EilenbergGanea +open scoped ContDiff +open Set Filter Topology +namespace EilenbergGanea +section EquivariantBumps +variable {G E : Type*} [Group G] [Fintype G] + [NormedAddCommGroup E] [NormedSpace ℝ E] + +def equivariantBumpOperator (ρ : G →* E ≃L[ℝ] E) (b : E → ℝ) (x : E) : E →L[ℝ] E := + ∑ g, b (ρ g⁻¹ x) • (ρ g : E →L[ℝ] E) + +omit [Fintype G] in +theorem representation_cancel (ρ : G →* E ≃L[ℝ] E) (g : G) (x : E) : + ρ g⁻¹ (ρ g x) = x := by + change ((ρ g⁻¹) * ρ g) x = x + rw [← map_mul, inv_mul_cancel, map_one] + rfl + +omit [Fintype G] in +theorem representation_mul_apply (ρ : G →* E ≃L[ℝ] E) (g h : G) (x : E) : + ρ (g * h) x = ρ g (ρ h x) := by rw [map_mul]; rfl + +theorem equivariantBumpOperator_equivariant (ρ : G →* E ≃L[ℝ] E) (b : E → ℝ) + (h : G) (x : E) : + equivariantBumpOperator ρ b (ρ h x) = + (ρ h : E →L[ℝ] E).comp (equivariantBumpOperator ρ b x) := by + ext v + simp only [equivariantBumpOperator, sum_apply, smul_apply, + ContinuousLinearMap.comp_apply, map_sum, map_smul] + symm + apply Fintype.sum_equiv (Equiv.mulLeft h) + intro g + change b (ρ g⁻¹ x) • ρ h (ρ g v) = + b (ρ (h * g)⁻¹ (ρ h x)) • ρ (h * g) v + simp only [mul_inv_rev, representation_mul_apply, representation_cancel] + +theorem equivariantBumpOperator_contDiff (ρ : G →* E ≃L[ℝ] E) (b : E → ℝ) + (hb : ContDiff ℝ ∞ b) : ContDiff ℝ ∞ (equivariantBumpOperator ρ b) := by + apply ContDiff.sum + intro g _ + exact (hb.comp (ρ g⁻¹).contDiff).smul contDiff_const + +theorem unit_smul_equiv (a : ℝ) (ha : a ≠ 0) (e : E ≃L[ℝ] E) : + IsUnit (a • (e : E →L[ℝ] E)) := by + refine ⟨⟨a • (e : E →L[ℝ] E), a⁻¹ • (e.symm : E →L[ℝ] E), ?_, ?_⟩, rfl⟩ + · ext v + simp [smul_smul, ha] + · ext v + simp [smul_smul, ha] + +theorem equivariantBumpOperator_isUnit (ρ : G →* E ≃L[ℝ] E) (b : E → ℝ) + (hbd : Pairwise fun g h : G => Disjoint (ρ g '' tsupport b) (ρ h '' tsupport b)) + (x : E) (g : G) (hg : b (ρ g⁻¹ x) ≠ 0) : IsUnit (equivariantBumpOperator ρ b x) := by + have hx (k : G) (hk : b (ρ k⁻¹ x) ≠ 0) : x ∈ ρ k '' tsupport b := + ⟨ρ k⁻¹ x, subset_tsupport b hk, by simpa using representation_cancel ρ k⁻¹ x⟩ + have he : equivariantBumpOperator ρ b x = b (ρ g⁻¹ x) • (ρ g : E →L[ℝ] E) := by + apply Finset.sum_eq_single g + · intro h _ hh + have hh0 : b (ρ h⁻¹ x) = 0 := by + by_contra hh0 + exact Set.disjoint_left.mp (hbd hh) (hx h hh0) (hx g hg) + simp only [hh0, zero_smul] + · simp + rw [he] + exact unit_smul_equiv _ hg _ + +/-- A free orbit for a finite linear action has a neighborhood with pairwise +disjoint translates. No isometry hypothesis or metric constants are needed. -/ +theorem free_orbit_disjoint_neighborhood (ρ : G →* E ≃L[ℝ] E) (x : E) + (hx : ∀ g : G, ρ g x = x → g = 1) (W : Set E) (hW : IsOpen W) (hxW : x ∈ W) : + ∃ V : Set E, IsOpen V ∧ x ∈ V ∧ V ⊆ W ∧ + Pairwise fun g h : G => Disjoint (ρ g '' V) (ρ h '' V) := by + classical + have hsep (g : {g : G // g ≠ 1}) : + ∃ U : Set E, IsOpen U ∧ x ∈ U ∧ Disjoint U (ρ g.val '' U) := by + have hgx : x ≠ ρ g.val x := fun he => g.property (hx _ he.symm) + obtain ⟨A, B, hA, hB, hxA, hxB, hAB⟩ := t2_separation hgx + refine ⟨A ∩ (ρ g.val ⁻¹' B), hA.inter (hB.preimage (ρ g.val).continuous), ⟨hxA, hxB⟩, ?_⟩ + apply hAB.mono inter_subset_left + rintro y ⟨z, hz, rfl⟩ + exact hz.2 + choose U hU hxU hdU using hsep + let V : Set E := W ∩ ⋂ g : {g : G // g ≠ 1}, U g + have hVo : IsOpen V := hW.inter (isOpen_iInter_of_finite hU) + have hxV : x ∈ V := ⟨hxW, mem_iInter.mpr hxU⟩ + refine ⟨V, hVo, hxV, inter_subset_left, ?_⟩ + intro g h hgh + apply Set.disjoint_left.mpr + rintro y ⟨a, ha, rfl⟩ ⟨b, hb, he⟩ + have hk : g⁻¹ * h ≠ 1 := by + intro heq + apply hgh + have := congrArg (fun k => g * k) heq + simpa only [← mul_assoc, mul_inv_cancel, one_mul, mul_one] using this.symm + have haU : a ∈ U ⟨g⁻¹ * h, hk⟩ := mem_iInter.mp ha.2 _ + have hbU : b ∈ U ⟨g⁻¹ * h, hk⟩ := mem_iInter.mp hb.2 _ + apply Set.disjoint_left.mp (hdU ⟨g⁻¹ * h, hk⟩) haU + refine ⟨b, hbU, ?_⟩ + rw [representation_mul_apply, he, representation_cancel] + +variable [FiniteDimensional ℝ E] + +/-- The bump family used in the free part of the localized-degree argument. +Its complete closed support has disjoint translates, so each active parameter +block is invertible. -/ +theorem free_orbit_smooth_bump (ρ : G →* E ≃L[ℝ] E) (x : E) + (hx : ∀ g : G, ρ g x = x → g = 1) (W : Set E) (hW : IsOpen W) (hxW : x ∈ W) : + ∃ b : E → ℝ, ContDiff ℝ ∞ b ∧ HasCompactSupport b ∧ tsupport b ⊆ W ∧ b x = 1 ∧ + Pairwise fun g h : G => Disjoint (ρ g '' tsupport b) (ρ h '' tsupport b) := by + obtain ⟨V, hV, hxV, hVW, hdisj⟩ := free_orbit_disjoint_neighborhood ρ x hx W hW hxW + obtain ⟨b, hbV, hcb, hdb, _, hbx⟩ := exists_contDiff_tsupport_subset (n := (⊤ : ℕ∞)) (hV.mem_nhds hxV) + refine ⟨b, hdb, hcb, hbV.trans hVW, hbx, ?_⟩ + intro g h hgh + exact (hdisj hgh).mono (image_mono hbV) (image_mono hbV) + +end EquivariantBumps +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff +section CompactRootStability +variable {P X Y : Type*} [TopologicalSpace P] [TopologicalSpace X] + [TopologicalSpace Y] [CompactSpace X] [T1Space Y] + +theorem compact_root_good_stability (f : P × X → Y) (hf : Continuous f) + (y : Y) (V : Set (P × X)) (hV : IsOpen V) (p₀ : P) + (h₀ : ∀ x, f (p₀, x) = y → (p₀, x) ∈ V) : + ∀ᶠ p in 𝓝 p₀, ∀ x, f (p, x) = y → (p, x) ∈ V := by + let C : Set (P × X) := {q | f q = y} ∩ Vᶜ + have hC : IsClosed C := (isClosed_singleton.preimage hf).inter hV.isClosed_compl + have hn : p₀ ∉ Prod.fst '' C := by + rintro ⟨⟨p, x⟩, ⟨hr, hv⟩, rfl⟩ + exact hv (h₀ x hr) + filter_upwards [(isClosedMap_fst_of_compactSpace _ hC).isOpen_compl.mem_nhds hn] with p hp + intro x hr + by_contra hv + exact hp ⟨(p, x), ⟨hr, hv⟩, rfl⟩ +end CompactRootStability + +section CompactFreeBumps +universe uE uG +variable {G : Type uG} {E : Type uE} [Group G] [Fintype G] [NormedAddCommGroup E] + [NormedSpace ℝ E] [FiniteDimensional ℝ E] + +theorem compact_free_bump_family (ρ : G →* E ≃L[ℝ] E) + (K W : Set E) (hK : IsCompact K) (hW : IsOpen W) (hKW : K ⊆ W) + (hfree : ∀ x ∈ K, ∀ g : G, ρ g x = x → g = 1) : + ∃ (ι : Type uE) (_ : Fintype ι) (b : ι → E → ℝ), + (∀ i, ContDiff ℝ ∞ (b i) ∧ HasCompactSupport (b i) ∧ tsupport (b i) ⊆ W ∧ + Pairwise fun g h : G => Disjoint (ρ g '' tsupport (b i)) (ρ h '' tsupport (b i))) ∧ + (∀ x ∈ K, ∃ i, IsUnit (equivariantBumpOperator ρ (b i) x)) := by + classical + have hb (x : K) := free_orbit_smooth_bump ρ x.val (hfree x.val x.property) + W hW (hKW x.property) + choose b hbd hbc hbs hbx hdis using hb + have hcov : K ⊆ ⋃ x : K, {y | b x y ≠ 0} := by + intro x hx + exact mem_iUnion.mpr ⟨⟨x, hx⟩, by simp [hbx]⟩ + obtain ⟨t, ht⟩ := hK.elim_finite_subcover (fun x : K => {y | b x y ≠ 0}) + (fun x => isOpen_ne_fun (hbd x).continuous continuous_const) hcov + refine ⟨{x // x ∈ t}, inferInstance, fun i => b i.val, ?_, ?_⟩ + · exact fun i => ⟨hbd i.val, hbc i.val, hbs i.val, hdis i.val⟩ + · intro x hx + obtain ⟨i, hi, hbix⟩ := Set.mem_iUnion₂.mp (ht hx) + refine ⟨⟨i, hi⟩, equivariantBumpOperator_isUnit ρ (b i) (hdis i) x 1 ?_⟩ + rw [inv_one, map_one] + exact hbix + +end CompactFreeBumps + +section LinearRegularization +variable {ι E : Type*} [Fintype ι] [DecidableEq ι] + [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] + [MeasurableSpace E] [BorelSpace E] + +omit [DecidableEq ι] [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in +theorem linearPerturbation_contDiff (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (hf : ContDiff ℝ ∞ f) (hT : ∀ i, ContDiff ℝ ∞ (T i)) : + ContDiff ℝ ∞ (fun q : (ι → E) × E => linearPerturbation f T q.2 q.1) := by + apply (hf.comp contDiff_snd).add + apply ContDiff.sum + intro i _ + exact ((hT i).comp contDiff_snd).clm_apply ((contDiff_apply ℝ E i).comp contDiff_fst) + +omit [DecidableEq ι] [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in +theorem linearPerturbationDerivative_continuous (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (hf : ContDiff ℝ ∞ f) (hT : ∀ i, ContDiff ℝ ∞ (T i)) : + Continuous (fun q : (ι → E) × E => linearPerturbationDerivative f T q.2 q.1) := by + apply (hf.continuous_fderiv (by norm_num)).comp continuous_snd |>.add + apply continuous_finsetSum + intro i _ + exact ((ContinuousLinearMap.flipₗᵢ ℝ E E E).continuous.comp + (((hT i).continuous_fderiv (by norm_num)).comp continuous_snd)).clm_apply + ((continuous_apply i).comp continuous_fst) + +/-- A finite linear bump family regularizes all roots on a compact set, provided +it has an invertible block at every initially critical root. The parameters +can be chosen in any prescribed neighborhood of zero. -/ +theorem exists_regular_linear_perturbation + (μ : MeasureTheory.Measure (ι → E)) [μ.IsAddHaarMeasure] + (f : E → E) (T : ι → E → (E →L[ℝ] E)) + (hf : ContDiff ℝ ∞ f) (hT : ∀ i, ContDiff ℝ ∞ (T i)) + (K : Set E) (hK : IsCompact K) + (hcover : ∀ x ∈ K, f x = 0 → (fderiv ℝ f x).det = 0 → ∃ i, IsUnit (T i x)) + (U : Set (ι → E)) (hU : U ∈ 𝓝 0) : + ∃ p ∈ U, ∀ x ∈ K, linearPerturbation f T x p = 0 → + (linearPerturbationDerivative f T x p).det ≠ 0 := by + let : CompactSpace K := isCompact_iff_compactSpace.mp hK + let F : (ι → E) × K → E := fun q => linearPerturbation f T q.2.val q.1 + let V : Set ((ι → E) × K) := {q | + (linearPerturbationDerivative f T q.2.val q.1).det ≠ 0 ∨ ∃ i, IsUnit (T i q.2.val)} + have hc : Continuous (fun q : (ι → E) × K => (q.1, q.2.val)) := + continuous_fst.prodMk (continuous_subtype_val.comp continuous_snd) + have hV : IsOpen V := by + have hd : IsOpen {q : (ι → E) × K | + (linearPerturbationDerivative f T q.2.val q.1).det ≠ 0} := + isOpen_ne_fun (ContinuousLinearMap.continuous_det.comp + ((linearPerturbationDerivative_continuous f T hf hT).comp hc)) continuous_const + have ho := isOpen_iUnion (fun i => Units.isOpen.preimage ((hT i).continuous.comp + (continuous_subtype_val.comp (continuous_snd : Continuous (Prod.snd : (ι → E) × K → K))))) + have he : {q : (ι → E) × K | ∃ i, IsUnit (T i q.2.val)} = + ⋃ i, (T i ∘ Subtype.val ∘ Prod.snd) ⁻¹' {a | IsUnit a} := by + ext q + simp + have hi : IsOpen {q : (ι → E) × K | ∃ i, IsUnit (T i q.2.val)} := he ▸ ho + exact hd.union hi + have h₀ : ∀ x : K, F (0, x) = 0 → ((0 : ι → E), x) ∈ V := by + intro x hx + by_cases hd : (fderiv ℝ f x.val).det = 0 + · exact Or.inr (hcover x.val x.property (by simpa [F, linearPerturbation] using hx) hd) + · exact Or.inl (by simpa [linearPerturbationDerivative] using hd) + have he := compact_root_good_stability F ((linearPerturbation_contDiff f T hf hT).continuous.comp hc) + 0 V hV 0 h₀ + have hdense : Dense {p : ι → E | ∀ x ∈ K, linearPerturbation f T x p = 0 → + (∃ i, IsUnit (T i x)) → (linearPerturbationDerivative f T x p).det ≠ 0} := + MeasureTheory.Measure.dense_of_ae (ae_regular_linear_parameters μ f T K + (fun x _ => hf.differentiable (by norm_num) x) + (fun i x _ => (hT i).differentiable (by norm_num) x)) + obtain ⟨p, hpreg, hpU, hpgood⟩ := hdense.inter_nhds_nonempty (inter_mem hU he) + refine ⟨p, hpU, ?_⟩ + intro x hx hr + rcases hpgood ⟨x, hx⟩ hr with hd | hi + · exact hd + · exact hpreg x hx hr hi + +end LinearRegularization +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +section EquivariantRegularization +universe uE uG +variable {G : Type uG} {E : Type uE} [Group G] [Fintype G] [NormedAddCommGroup E] + [NormedSpace ℝ E] [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] + +omit [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] in +theorem equivariantBumpOperator_eventually_zero_outside + (ρ : G →* E ≃L[ℝ] E) (b : E → ℝ) (W : Set E) + (hb : tsupport b ⊆ W) (hinv : ∀ g x, x ∈ W → ρ g x ∈ W) + (x : E) (hx : x ∉ W) : equivariantBumpOperator ρ b =ᶠ[𝓝 x] 0 := by + have hzero (a : G) : ∀ᶠ y in 𝓝 x, b (ρ a⁻¹ y) = 0 := by + have hn : ρ a⁻¹ x ∉ tsupport b := by + intro hs + have hw := hinv a (ρ a⁻¹ x) (hb hs) + have he : ρ a (ρ a⁻¹ x) = x := by + rw [← representation_mul_apply, mul_inv_cancel, map_one] + rfl + exact hx (he ▸ hw) + filter_upwards [((isClosed_tsupport b).preimage (ρ a⁻¹).continuous).isOpen_compl.mem_nhds hn] + with y hy + exact image_eq_zero_of_notMem_tsupport hy + filter_upwards [Filter.eventually_all.mpr hzero] with y hy + change (∑ a : G, b (ρ a⁻¹ y) • (ρ a : E →L[ℝ] E)) = 0 + apply Finset.sum_eq_zero + intro a _ + rw [hy a, zero_smul] + +/-- The free-action regularization step. Critical roots must lie in the free +locus, but already regular fixed roots need not. The perturbation is unchanged +outside any chosen invariant open neighborhood of the critical roots. -/ +theorem exists_equivariant_regular_perturbation + (ρ : G →* E ≃L[ℝ] E) (f : E → E) (hf : ContDiff ℝ ∞ f) + (heq : ∀ g x, f (ρ g x) = ρ g (f x)) + (K W : Set E) (hK : IsCompact K) (hW : IsOpen W) + (hinv : ∀ g x, x ∈ W → ρ g x ∈ W) + (hcritical : ∀ x ∈ K, f x = 0 → (fderiv ℝ f x).det = 0 → + x ∈ W ∧ ∀ g : G, ρ g x = x → g = 1) + (ε : ℝ) (hε : 0 < ε) : + ∃ g : E → E, ContDiff ℝ ∞ g ∧ (∀ a x, g (ρ a x) = ρ a (g x)) ∧ + (∀ x ∉ W, g =ᶠ[𝓝 x] f) ∧ (∀ x ∈ K, ‖g x - f x‖ < ε) ∧ + ∀ x ∈ K, g x = 0 → (fderiv ℝ g x).det ≠ 0 := by + classical + let A : Set E := {x ∈ K | f x = 0 ∧ (fderiv ℝ f x).det = 0} + have hA : IsCompact A := hK.inter_right + ((isClosed_singleton.preimage hf.continuous).inter + (isClosed_singleton.preimage (ContinuousLinearMap.continuous_det.comp + (hf.continuous_fderiv (by norm_num))))) + obtain ⟨ι, hι, b, hb, hcover⟩ := compact_free_bump_family ρ A W hA hW + (fun x hx => (hcritical x hx.1 hx.2.1 hx.2.2).1) + (fun x hx => (hcritical x hx.1 hx.2.1 hx.2.2).2) + let := hι + let T : ι → E → (E →L[ℝ] E) := fun i => equivariantBumpOperator ρ (b i) + have hT (i : ι) : ContDiff ℝ ∞ (T i) := equivariantBumpOperator_contDiff ρ _ (hb i).1 + let : CompactSpace K := isCompact_iff_compactSpace.mp hK + have hc : Continuous (fun q : (ι → E) × K => (q.1, q.2.val)) := + continuous_fst.prodMk (continuous_subtype_val.comp continuous_snd) + have hopen : IsOpen {q : (ι → E) × K | + ‖linearPerturbation f T q.2.val q.1 - f q.2.val‖ < ε} := + isOpen_lt (((linearPerturbation_contDiff f T hf hT).continuous.comp hc).sub + (hf.continuous.comp (continuous_subtype_val.comp continuous_snd))).norm continuous_const + have hsmall : ∀ᶠ p : ι → E in 𝓝 0, + ∀ x : K, ‖linearPerturbation f T x.val p - f x.val‖ < ε := by + have h := compact_root_good_stability (fun _ : (ι → E) × K => (0 : ℝ)) + continuous_const (0 : ℝ) _ hopen (0 : ι → E) (by + intro x _ + simpa [linearPerturbation] using hε) + filter_upwards [h] with p hp + exact fun x => hp x rfl + obtain ⟨p, hp, hreg⟩ := exists_regular_linear_perturbation + (Module.finBasis ℝ (ι → E)).addHaar f T hf hT K hK + (fun x hx hr hd => hcover x ⟨hx, hr, hd⟩) _ hsmall + refine ⟨fun x => linearPerturbation f T x p, ?_, ?_, ?_, ?_, ?_⟩ + · exact (linearPerturbation_contDiff f T hf hT).comp (contDiff_const.prodMk contDiff_id) + · intro a x + simp only [linearPerturbation, heq, map_add, map_sum] + congr 1 + apply Finset.sum_congr rfl + intro i _ + exact congrArg (fun L : E →L[ℝ] E => L (p i)) (equivariantBumpOperator_equivariant ρ (b i) a x) + · intro x hx + have hz (i : ι) : T i =ᶠ[𝓝 x] 0 := + equivariantBumpOperator_eventually_zero_outside ρ (b i) W (hb i).2.2.1 hinv x hx + filter_upwards [Filter.eventually_all.mpr hz] with y hy + simp only [linearPerturbation, hy, Pi.zero_apply, zero_apply, + Finset.sum_const_zero, add_zero] + · intro x hx + exact hp ⟨x, hx⟩ + · intro x hx hr + rw [(linearPerturbation_hasFDerivAt f T (hf.differentiable (by norm_num) x) + (fun i => (hT i).differentiable (by norm_num) x) p).fderiv] + exact hreg x hx hr + +end EquivariantRegularization +end EilenbergGanea +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff +section MixedRegularization +variable {G A V : Type*} [Group G] [Fintype G] + [NormedAddCommGroup A] [NormedSpace ℝ A] [FiniteDimensional ℝ A] + [NormedAddCommGroup V] [NormedSpace ℂ V] [NormedSpace ℝ V] + [IsScalarTower ℝ ℂ V] [FiniteDimensional ℂ V] + +def scalarRotationRepresentation (χ : G →* ℂˣ) : G →* (A × V) ≃L[ℝ] (A × V) where + toFun g := scalarRotation (χ g) + map_one' := by + apply ContinuousLinearEquiv.ext + funext q + change scalarRotation (χ 1) q = q + simp [scalarRotation_apply] + map_mul' g h := by + apply ContinuousLinearEquiv.ext + funext q + change scalarRotation (χ (g * h)) q = scalarRotation (χ g) (scalarRotation (χ h) q) + simp [mul_smul] + +omit [Fintype G] [FiniteDimensional ℝ A] [FiniteDimensional ℂ V] in +@[simp] theorem scalarRotationRepresentation_apply (χ : G →* ℂˣ) (g : G) (q : A × V) : + scalarRotationRepresentation χ g q = (q.1, (χ g : ℂ) • q.2) := rfl + +omit [Fintype G] [FiniteDimensional ℝ A] [FiniteDimensional ℂ V] in + theorem scalarRotation_free (χ : G →* ℂˣ) (hχ : Function.Injective χ) + (q : A × V) (hq : q.2 ≠ 0) : + ∀ g : G, scalarRotationRepresentation χ g q = q → g = 1 := by + intro g hg + have hh : (χ g : ℂ) • q.2 = (1 : ℂ) • q.2 := by + have hg_snd := congrArg Prod.snd hg + change (χ g : ℂ) • q.2 = q.2 at hg_snd + simpa using hg_snd + have he : (χ g : ℂ) = 1 := (smul_left_injective ℂ hq) hh + apply hχ + apply Units.ext + simpa using he + +omit [Fintype G] [FiniteDimensional ℝ A] [FiniteDimensional ℂ V] in + theorem normalShift_equivariant (χ : G →* ℂˣ) (f : A × V → A × V) + (hf : ∀ g q, f (scalarRotationRepresentation χ g q) = + scalarRotationRepresentation χ g (f q)) (s : ℝ) : + ∀ g q, normalShift f s (scalarRotationRepresentation χ g q) = + scalarRotationRepresentation χ g (normalShift f s q) := by + intro g q + simp only [normalShift, hf, map_add, map_smul] + congr 1 + +/-- The full fixed-plus-free regularization step in fixed/normal coordinates. +Unlike an assumed transversality interface, this is assembled from the finite +normal spectrum argument and explicit free-orbit bump parameters above. -/ +theorem exists_fixed_free_regularization (χ : G →* ℂˣ) (hχ : Function.Injective χ) + (a₀ : G) (ha₀ : (χ a₀ : ℂ).im ≠ 0) + (f : A × V → A × V) (hf : ContDiff ℝ ∞ f) + (he : ∀ g q, f (scalarRotationRepresentation χ g q) = + scalarRotationRepresentation χ g (f q)) + (K : Set (A × V)) (hK : IsCompact K) (S : Finset A) + (hS : ∀ a, (a, 0) ∈ K → f (a, 0) = 0 → a ∈ S) + (c : ℝ) (hc : c ≠ 0) + (hT : ∀ a ∈ S, (fderiv ℝ (fixedRestriction f) a).det = c) + (ε : ℝ) (hε : 0 < ε) : + ∃ g : A × V → A × V, ContDiff ℝ ∞ g ∧ + (∀ a q, g (scalarRotationRepresentation χ a q) = + scalarRotationRepresentation χ a (g q)) ∧ + (∀ a, g (a, 0) = f (a, 0)) ∧ + (∀ q ∈ K, ‖g q - f q‖ < ε) ∧ + (∀ q ∈ K, g q = 0 → (fderiv ℝ g q).det ≠ 0) ∧ + (∀ a ∈ S, (0 < (fderiv ℝ g (a, 0)).det ↔ 0 < c)) := by + classical + let : FiniteDimensional ℝ V := Module.Finite.trans ℂ V + let : MeasurableSpace (A × V) := borel (A × V) + let : BorelSpace (A × V) := ⟨rfl⟩ + let ρ := scalarRotationRepresentation (A := A) (V := V) χ + obtain ⟨R, hR, hbound⟩ := hK.isBounded.exists_pos_norm_lt + have hδ : 0 < (ε / 2) / (R + 1) := div_pos (by linarith) (by linarith) + obtain ⟨s, hs, hreg⟩ := exists_normalShift_regular_fixed f + (hf.differentiable (by simp)) (χ a₀) ha₀ (he a₀) S c hc hT _ hδ + let f₁ := normalShift f s + have hf₁ : ContDiff ℝ ∞ f₁ := normalShift_contDiff f hf s + have he₁ : ∀ a q, f₁ (ρ a q) = ρ a (f₁ q) := normalShift_equivariant χ f he s + have hsmall : ∀ q ∈ K, ‖f₁ q - f q‖ < ε / 2 := by + intro q hq + have hnorm : ‖normalProjection q‖ ≤ R + 1 := by + simp only [normalProjection_apply, Prod.norm_def, norm_zero, max_eq_right (norm_nonneg _)] + exact (norm_snd_le q).trans (hbound q hq).le |>.trans (by linarith) + calc + ‖f₁ q - f q‖ = |s| * ‖normalProjection q‖ := by simp only [f₁, normalShift, add_sub_cancel_left, norm_smul, Real.norm_eq_abs] + _ ≤ |s| * (R + 1) := mul_le_mul_of_nonneg_left hnorm (abs_nonneg _) + _ < ε / 2 := (lt_div_iff₀ (by linarith : 0 < R + 1)).mp hs + let W : Set (A × V) := {q | q.2 ≠ 0} + have hW : IsOpen W := (isClosed_singleton.preimage continuous_snd).isOpen_compl + have hinv : ∀ a q, q ∈ W → ρ a q ∈ W := by + intro a q hq + exact smul_ne_zero (Units.ne_zero _) hq + have hcritical : ∀ q ∈ K, f₁ q = 0 → (fderiv ℝ f₁ q).det = 0 → + q ∈ W ∧ ∀ a : G, ρ a q = q → a = 1 := by + intro q hq hr hd + have hn : q.2 ≠ 0 := by + intro hz + have hqeq : q = (q.1, 0) := Prod.ext rfl hz + rw [hqeq] at hq hr hd + have ha : q.1 ∈ S := hS q.1 hq (by simpa [f₁] using hr) + exact (hreg q.1 ha).1 hd + exact ⟨hn, scalarRotation_free χ hχ q hn⟩ + obtain ⟨g, hg, hge, hprotected, hclose, hgood⟩ := + exists_equivariant_regular_perturbation ρ f₁ hf₁ he₁ K W hK hW hinv hcritical + (ε / 2) (by linarith) + refine ⟨g, hg, hge, ?_, ?_, hgood, ?_⟩ + · intro a + exact ((hprotected (a, 0) (by simp [W])).eq_of_nhds).trans (normalShift_fixed f s a) + · intro q hq + have hh := norm_sub_le_norm_sub_add_norm_sub (g q) (f₁ q) (f q) + linarith [hclose q hq, hsmall q hq] + · intro a ha + have hd := (hprotected (a, 0) (by simp [W])).fderiv_eq (𝕜 := ℝ) + rw [hd] + exact (hreg a ha).2 + +end MixedRegularization +end EilenbergGanea + + +namespace EilenbergGanea +section SignedAction +variable {G X : Type*} [Group G] [MulAction G X] + +@[instance_reducible] def invariantSubtypeAction (P : X → Prop) (hP : ∀ (g : G) x, P x → P (g • x)) : + MulAction G {x // P x} where + smul g x := ⟨g • x.1, hP g x.1 x.2⟩ + one_smul x := Subtype.ext (one_smul G x.1) + mul_smul g h x := Subtype.ext (mul_smul g h x.1) + +theorem signed_finite_action_nonzero {p : ℕ} [Fact p.Prime] [Fintype X] + (hG : IsPGroup p G) (σ : X → Bool) + (hσ : ∀ (g : G) x, σ (g • x) = σ x) + (b : Bool) (hb : ∀ x ∈ MulAction.fixedPoints G X, σ x = b) + (hex : (MulAction.fixedPoints G X).Nonempty) + (hsmall : Nat.card (MulAction.fixedPoints G X) < p) : + (∑ x : X, (if σ x then (1 : ℤ) else -1)) ≠ 0 := by + classical + let A := {x : X // σ x = b} + let B := {x : X // σ x ≠ b} + let : MulAction G A := invariantSubtypeAction _ (by intro g x hx; simpa [hσ] using hx) + let : MulAction G B := invariantSubtypeAction _ (by intro g x hx; simpa [hσ] using hx) + let e : MulAction.fixedPoints G A ≃ MulAction.fixedPoints G X := + { toFun := fun x => ⟨x.1.1, fun g => congrArg Subtype.val (x.2 g)⟩ + invFun := fun x => ⟨⟨x.1, hb x.1 x.2⟩, fun g => Subtype.ext (x.2 g)⟩ + left_inv := by intro x; rfl + right_inv := by intro x; rfl } + have hempty : IsEmpty (MulAction.fixedPoints G B) := ⟨by + intro x + have hx : x.1.1 ∈ MulAction.fixedPoints G X := fun g => congrArg Subtype.val (x.2 g) + exact x.1.2 (hb x.1.1 hx)⟩ + have hnon : Nonempty (MulAction.fixedPoints G X) := hex.to_subtype + have hpos : 0 < Nat.card (MulAction.fixedPoints G A) := by + rw [Nat.card_congr e] + exact Nat.card_pos + have hs : Nat.card (MulAction.fixedPoints G A) < p := by rw [Nat.card_congr e]; exact hsmall + have hn : Nat.card (MulAction.fixedPoints G B) = 0 := by simp + have hneq : Nat.card A ≠ Nat.card B := by + intro hh + have h := (hG.card_modEq_card_fixedPoints A).symm + rw [hh] at h + have h' := h.trans (hG.card_modEq_card_fixedPoints B) + rw [hn] at h' + have heq := h'.eq_of_lt_of_lt hs (Fact.out : p.Prime).pos + omega + have hcounts : (∑ x : X, (if σ x = b then (1 : ℤ) else -1)) = + (Nat.card A : ℤ) - Nat.card B := by + rw [Finset.sum_ite] + simp [A, B, Nat.card_eq_fintype_card, Fintype.card_subtype, sub_eq_add_neg] + intro hz + have hz' : (∑ x : X, (if σ x = b then (1 : ℤ) else -1)) = 0 := by + cases b + · have hh : (fun x : X => if σ x = false then (1 : ℤ) else -1) = + fun x => -(if σ x then (1 : ℤ) else -1) := by funext x; cases σ x <;> rfl + rw [hh, Finset.sum_neg_distrib, hz, neg_zero] + · simpa using hz + rw [hcounts, sub_eq_zero] at hz' + exact hneq (by exact_mod_cast hz') +end SignedAction +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff +variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] + [FiniteDimensional ℝ E] + +/- A nonsingular derivative supplies an open inverse patch, without assuming +that the map is proper or globally injective. -/ +theorem exists_regular_inverse_patch (f : E → E) {x : E} + (hf : ContDiffAt ℝ 1 f x) (hd : (fderiv ℝ f x).det ≠ 0) : + ∃ V : Set E, IsOpen V ∧ x ∈ V ∧ InjOn f V ∧ + IsOpen (f '' V) := by + let e := (fderiv ℝ f x).toContinuousLinearEquivOfDetNeZero hd + have he : (e : E →L[ℝ] E) = fderiv ℝ f x := rfl + have hf' : HasFDerivAt f (e : E →L[ℝ] E) x := by + rw [he] + exact (hf.differentiableAt (by norm_num)).hasFDerivAt + let p := hf.toOpenPartialHomeomorph f hf' (by norm_num) + refine ⟨p.source, p.open_source, hf.mem_toOpenPartialHomeomorph_source hf' (by norm_num), + p.injOn, ?_⟩ + change IsOpen (p '' p.source) + rw [p.image_source_eq_target] + exact p.open_target + +/- A regular level set is discrete. Only smoothness at the level set is +required. -/ +theorem regular_fiber_isDiscrete (f : E → E) (y : E) (K : Set E) + (hf : ∀ x ∈ K, f x = y → ContDiffAt ℝ 1 f x) + (hd : ∀ x ∈ K, f x = y → (fderiv ℝ f x).det ≠ 0) : + IsDiscrete (K ∩ f ⁻¹' {y}) := by + rw [isDiscrete_iff_forall_mem_exists_isOpen] + rintro x ⟨hxK, hxy⟩ + obtain ⟨V, ho, hxV, hi, _⟩ := exists_regular_inverse_patch f (hf x hxK hxy) (hd x hxK hxy) + refine ⟨V, ho, ?_⟩ + ext z + constructor + · rintro ⟨hzV, hzK, hzy⟩ + exact hi hzV hxV (hzy.trans hxy.symm) + · rintro rfl + exact ⟨hxV, hxK, hxy⟩ + +/- Compact regular fibers are finite, in the form needed by the signed +count formula after regularization. -/ +theorem compact_regular_fiber_finite (f : E → E) (y : E) (K : Set E) + (hK : IsCompact K) (hf : ContinuousOn f K) + (hs : ∀ x ∈ K, f x = y → ContDiffAt ℝ 1 f x) + (hd : ∀ x ∈ K, f x = y → (fderiv ℝ f x).det ≠ 0) : + (K ∩ f ⁻¹' {y}).Finite := by + exact (hK.of_isClosed_subset (hf.preimage_isClosed_of_isClosed hK.isClosed + isClosed_singleton) inter_subset_left).finite + (regular_fiber_isDiscrete f y K hs hd) + + +end EilenbergGanea +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff +section LocalizedRegularization +variable {G A V : Type*} [Group G] [Fintype G] + [NormedAddCommGroup A] [NormedSpace ℝ A] [FiniteDimensional ℝ A] + [NormedAddCommGroup V] [NormedSpace ℂ V] [NormedSpace ℝ V] + [IsScalarTower ℝ ℂ V] [FiniteDimensional ℂ V] + +/-- The localized noncancellation part of degree, now for actual regular +perturbations of a smooth map, not an assumed finite-orbit-count interface. -/ +theorem exists_regularization_nonzero_count {p : ℕ} [Fact p.Prime] + (hG : IsPGroup p G) (χ : G →* ℂˣ) (hχ : Function.Injective χ) + (a₀ : G) (ha₀ : (χ a₀ : ℂ).im ≠ 0) + (f : A × V → A × V) (hf : ContDiff ℝ ∞ f) + (he : ∀ a q, f (scalarRotationRepresentation χ a q) = + scalarRotationRepresentation χ a (f q)) + (K : Set (A × V)) (hK : IsCompact K) + (hKi : ∀ a q, q ∈ K → scalarRotationRepresentation χ a q ∈ K) + (L : Set (A × V)) (hL : IsCompact L) (hKL : K ⊆ L) + (S : Finset A) (hS : ∀ a, (a, 0) ∈ L → f (a, 0) = 0 → a ∈ S) + (hex : ∃ a, (a, 0) ∈ K ∧ f (a, 0) = 0) (hSp : S.card < p) + (c : ℝ) (hc : c ≠ 0) + (hT : ∀ a ∈ S, (fderiv ℝ (fixedRestriction f) a).det = c) + (ε : ℝ) (hε : 0 < ε) : + ∃ g : A × V → A × V, ContDiff ℝ ∞ g ∧ + (∀ q ∈ L, ‖g q - f q‖ < ε) ∧ + ∃ s : Finset (A × V), (∀ q, q ∈ s ↔ q ∈ K ∧ g q = 0) ∧ + (∀ q ∈ s, (fderiv ℝ g q).det ≠ 0) ∧ + (∑ q ∈ s, (if 0 < (fderiv ℝ g q).det then 1 else -1 : ℝ)) ≠ 0 := by + classical + let : FiniteDimensional ℝ V := Module.Finite.trans ℂ V + let ρ := scalarRotationRepresentation (A := A) (V := V) χ + obtain ⟨g, hg, hge, hgf, hclose, hreg, hsign⟩ := exists_fixed_free_regularization + χ hχ a₀ ha₀ f hf he L hL S hS c hc hT ε hε + have hfinite : (K ∩ g ⁻¹' {0}).Finite := compact_regular_fiber_finite g 0 K hK + hg.continuous.continuousOn (fun q _ _ => hg.of_le (by norm_num) |>.contDiffAt) (fun q hq => hreg q (hKL hq)) + let s := hfinite.toFinset + have hs : ∀ q, q ∈ s ↔ q ∈ K ∧ g q = 0 := by intro q; exact hfinite.mem_toFinset + let X := {q : A × V // q ∈ K ∧ g q = 0} + let : Fintype X := hfinite.fintype + let : MulAction G (A × V) := { + smul := fun a q => ρ a q + one_smul := by intro q; change ρ 1 q = q; rw [map_one]; rfl + mul_smul := by intro a b q; change ρ (a * b) q = ρ a (ρ b q); rw [map_mul]; rfl } + let : MulAction G X := invariantSubtypeAction _ (by + intro a q hq + refine ⟨hKi a q hq.1, ?_⟩ + change g (ρ a q) = 0 + rw [hge, hq.2, map_zero]) + have hfixed (x : MulAction.fixedPoints G X) : x.1.1.2 = 0 := by + by_contra hn + have hh := congrArg (fun q : X => q.1.2) (x.2 a₀) + change (χ a₀ : ℂ) • x.1.1.2 = x.1.1.2 at hh + have hh' : (χ a₀ : ℂ) • x.1.1.2 = (1 : ℂ) • x.1.1.2 := by simpa using hh + have heq := (smul_left_injective ℂ hn) hh' + exact ha₀ (by rw [heq]; rfl) + have hmem (x : MulAction.fixedPoints G X) : x.1.1.1 ∈ S := by + have hx := x.1.2 + have heq : x.1.1 = (x.1.1.1, 0) := Prod.ext rfl (hfixed x) + rw [heq] at hx + exact hS _ (hKL hx.1) (by rw [← hgf]; exact hx.2) + let e : MulAction.fixedPoints G X ↪ S := + ⟨fun x => ⟨x.1.1.1, hmem x⟩, by + intro x y h + apply Subtype.ext + apply Subtype.ext + apply Prod.ext + · exact congrArg Subtype.val h + · exact (hfixed x).trans (hfixed y).symm⟩ + have hsmall : Nat.card (MulAction.fixedPoints G X) < p := + (Nat.card_le_card_of_injective e e.injective).trans_lt (by simpa using hSp) + have hex' : (MulAction.fixedPoints G X).Nonempty := by + obtain ⟨a, haK, haf⟩ := hex + refine ⟨⟨(a, 0), haK, by rw [hgf]; exact haf⟩, ?_⟩ + intro b + apply Subtype.ext + change ρ b (a, 0) = (a, 0) + simp [ρ] + let σ : X → Bool := fun q => decide (0 < (fderiv ℝ g q.1).det) + have hσ : ∀ (a : G) (q : X), σ (a • q) = σ q := by + intro a q + unfold σ + congr 1 + exact congrArg (fun t : ℝ => 0 < t) + (equivariant_fderiv_det g (ρ a) (hg.differentiable (by simp)) (hge a) q.1) + have hb : ∀ q ∈ MulAction.fixedPoints G X, σ q = decide (0 < c) := by + intro q hq + let x : MulAction.fixedPoints G X := ⟨q, hq⟩ + have heq : q.1 = (q.1.1, 0) := Prod.ext rfl (hfixed x) + change decide (0 < (fderiv ℝ g q.1).det) = decide (0 < c) + rw [heq] + exact decide_eq_decide.mpr (hsign _ (hmem x)) + have hcount := signed_finite_action_nonzero hG σ hσ (decide (0 < c)) hb hex' hsmall + refine ⟨g, hg, hclose, s, hs, fun q hq => hreg q (hKL ((hs q).mp hq).1) ((hs q).mp hq).2, ?_⟩ + have hsum : (∑ q ∈ s, (if 0 < (fderiv ℝ g q).det then (1 : ℤ) else -1)) ≠ 0 := by + have hsum' : (∑ q : X, (if σ q then (1 : ℤ) else -1)) = + ∑ q ∈ s, (if 0 < (fderiv ℝ g q).det then (1 : ℤ) else -1) := by + unfold σ + simpa only [decide_eq_true_eq] using (Finset.sum_subtype s hs + (fun q => if 0 < (fderiv ℝ g q).det then (1 : ℤ) else -1)).symm + exact hsum' ▸ hcount + exact_mod_cast hsum +end LocalizedRegularization +end EilenbergGanea + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/Seed.lean b/lean/OAI/Topology/EilenbergGanea/Seed.lean new file mode 100644 index 0000000000000000000000000000000000000000..ea6a1742303d4404640718e3663683b93e385a14 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/Seed.lean @@ -0,0 +1,164 @@ +import Mathlib.Tactic +import Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected +import Mathlib.Data.Fintype.Sum +import Mathlib.LinearAlgebra.Matrix.Notation + +namespace OAI + +noncomputable section + +open Classical Set + +namespace EilenbergGanea +/-- `false` names x; `true` names y. The second Boolean is the positive sign. -/ +def seedWord : Bool → List (Bool × Bool) + | false => [(false, true), (false, true), (true, false), (true, false), + (true, false), (true, false), (true, false)] + | true => [(false, true), (false, true), (true, true), (false, false), + (true, true), (false, false), (true, true), (false, false)] + +/-- Numbers of sectors in the two coned boundary polygons. -/ +def boundaryLength (r : Bool) : ℕ := 3 * (seedWord r).length + +abbrev RoseVertex := Option (Bool × Fin 2) +abbrev SeedVertex := RoseVertex ⊕ Bool +abbrev CircleEdge := Bool × Fin 3 +abbrev Sector := (r : Bool) × Fin (boundaryLength r) +abbrev SeedEdge := CircleEdge ⊕ Sector +abbrev SeedCell := SeedVertex ⊕ (SeedEdge ⊕ Sector) + +def circleStart (e : CircleEdge) : RoseVertex := + ![none, some (e.1, 0), some (e.1, 1)] e.2 + +def circleEnd (e : CircleEdge) : RoseVertex := + ![some (e.1, 0), some (e.1, 1), none] e.2 + +def sectorLetter (s : Sector) : Bool × Bool := + (seedWord s.1).get ⟨s.2.val / 3, by + have h := s.2.isLt + dsimp [boundaryLength] at h + omega⟩ + +def sectorCircleEdge (s : Sector) : CircleEdge := + ((sectorLetter s).1, if (sectorLetter s).2 then + ⟨s.2.val % 3, Nat.mod_lt _ (by decide)⟩ else + ⟨2 - s.2.val % 3, by omega⟩) + +def sectorStart (s : Sector) : RoseVertex := + if (sectorLetter s).2 then circleStart (sectorCircleEdge s) + else circleEnd (sectorCircleEdge s) + +def nextSector (s : Sector) : Sector := + ⟨s.1, ⟨(s.2.val + 1) % boundaryLength s.1, + Nat.mod_lt _ (by have := s.2.isLt; omega)⟩⟩ + +def edgeVertices : SeedEdge → Finset SeedVertex + | .inl e => {.inl (circleStart e), .inl (circleEnd e)} + | .inr s => {.inr s.1, .inl (sectorStart s)} + +def sectorEdges (s : Sector) : Finset SeedEdge := + {.inl (sectorCircleEdge s), .inr s, .inr (nextSector s)} + +def sectorVertices (s : Sector) : Finset SeedVertex := + (sectorEdges s).biUnion edgeVertices + +/-- Proper cell-face incidence, including vertices of closed triangles. -/ +def properFace : SeedCell → SeedCell → Prop + | .inl v, .inr (.inl e) => v ∈ edgeVertices e + | .inl v, .inr (.inr s) => v ∈ sectorVertices s + | .inr (.inl e), .inr (.inr s) => e ∈ sectorEdges s + | _, _ => False + +def seedGraph : SimpleGraph SeedCell where + Adj a b := properFace a b ∨ properFace b a + symm := ⟨fun _ _ h => h.elim Or.inr Or.inl⟩ + loopless := ⟨by + intro a + rcases a with a | a + · simp [properFace] + · rcases a with a | a <;> simp [properFace]⟩ + + +end EilenbergGanea + +namespace EilenbergGanea + +/-- The vertex of the rose common to its two circles. -/ +def seedBase : SeedCell := .inl (.inl none) + +theorem seed_vertex_edge_adj {v : SeedVertex} {e : SeedEdge} (h : v ∈ edgeVertices e) : + seedGraph.Adj (.inl v) (.inr (.inl e)) := Or.inl h + +theorem seed_edge_sector_adj {e : SeedEdge} {s : Sector} (h : e ∈ sectorEdges s) : + seedGraph.Adj (.inr (.inl e)) (.inr (.inr s)) := Or.inl h + +theorem rose_vertex_reachable (v : RoseVertex) : + seedGraph.Reachable seedBase (.inl (.inl v)) := by + rcases v with _ | ⟨b, i⟩ + · exact .refl _ + · fin_cases i + · have h₁ : seedGraph.Adj seedBase (.inr (.inl (.inl (b, 0)))) := by + apply seed_vertex_edge_adj + simp [edgeVertices, circleStart, circleEnd] + have h₂ : seedGraph.Adj (.inl (.inl (some (b, 0)))) + (.inr (.inl (.inl (b, 0)))) := by + apply seed_vertex_edge_adj + simp [edgeVertices, circleStart, circleEnd] + exact h₁.reachable.trans h₂.reachable.symm + · have h₁ : seedGraph.Adj seedBase (.inr (.inl (.inl (b, 2)))) := by + apply seed_vertex_edge_adj + simp [edgeVertices, circleStart, circleEnd] + have h₂ : seedGraph.Adj (.inl (.inl (some (b, 1)))) + (.inr (.inl (.inl (b, 2)))) := by + apply seed_vertex_edge_adj + simp [edgeVertices, circleStart, circleEnd] + exact h₁.reachable.trans h₂.reachable.symm + +def firstSector (r : Bool) : Sector := + ⟨r, ⟨0, by cases r <;> decide⟩⟩ + +theorem seed_vertex_reachable (v : SeedVertex) : + seedGraph.Reachable seedBase (.inl v) := by + rcases v with v | r + · exact rose_vertex_reachable v + · let s := firstSector r + have h₁ : seedGraph.Adj (.inl (.inl (sectorStart s))) (.inr (.inl (.inr s))) := by + apply seed_vertex_edge_adj + simp [edgeVertices] + have h₂ : seedGraph.Adj (.inl (.inr r)) (.inr (.inl (.inr s))) := by + apply seed_vertex_edge_adj + simp [edgeVertices, s, firstSector] + exact ((rose_vertex_reachable (sectorStart s)).trans h₁.reachable).trans h₂.reachable.symm + +theorem seed_edge_reachable (e : SeedEdge) : + seedGraph.Reachable seedBase (.inr (.inl e)) := by + rcases e with e | s + · apply (seed_vertex_reachable (.inl (circleStart e))).trans + apply SimpleGraph.Adj.reachable + apply seed_vertex_edge_adj + simp [edgeVertices] + · apply (seed_vertex_reachable (.inr s.1)).trans + apply SimpleGraph.Adj.reachable + apply seed_vertex_edge_adj + simp [edgeVertices] + +theorem seed_cell_reachable (x : SeedCell) : seedGraph.Reachable seedBase x := by + rcases x with v | e + · exact seed_vertex_reachable v + · rcases e with e | s + · exact seed_edge_reachable e + · apply (seed_edge_reachable (.inl (sectorCircleEdge s))).trans + apply SimpleGraph.Adj.reachable + apply seed_edge_sector_adj + simp [sectorEdges] + +theorem seed_connected : seedGraph.Connected := by + exact { preconnected := fun v w => + (seed_cell_reachable v).symm.trans (seed_cell_reachable w), nonempty := ⟨seedBase⟩ } + + +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/SeedChains.lean b/lean/OAI/Topology/EilenbergGanea/SeedChains.lean new file mode 100644 index 0000000000000000000000000000000000000000..6345e02bdbbef67320d862b0dc494b78662c055b --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/SeedChains.lean @@ -0,0 +1,3688 @@ +import OAI.Topology.EilenbergGanea.Seed +import OAI.AlgebraicTopology.Simplicial.Chains + +namespace OAI + +noncomputable section + +open Classical Set + +namespace EilenbergGanea +namespace SeedEncoding + +def finite (n : ℕ) : Fin 103 := ⟨n % 103, Nat.mod_lt _ (by decide)⟩ +def roseAt : ℕ → RoseVertex + | 0 => none + | 1 => some (false,0) + | 2 => some (false,1) + | 3 => some (true,0) + | _ => some (true,1) + +def sectorAt (n : ℕ) : Sector := + if n < 21 then ⟨false,⟨n % 21,by change n % 21 < 21; omega⟩⟩ + else ⟨true,⟨(n-21) % 24,by change (n-21) % 24 < 24; omega⟩⟩ + +def cellAt (i : Fin 103) : SeedCell := + if i.val < 5 then .inl (.inl (roseAt i.val)) + else if i.val < 7 then .inl (.inr (decide (i.val = 6))) + else if i.val < 13 then .inr (.inl (.inl (decide (10 ≤ i.val),⟨(i.val-7)%3,by omega⟩))) + else if i.val < 58 then .inr (.inl (.inr (sectorAt (i.val-13)))) + else .inr (.inr (sectorAt (i.val-58))) + +def sectorCode (s : Sector) : ℕ := (if s.1 then 21 else 0) + s.2.val + +def cellCode : SeedCell → Fin 103 + | .inl (.inl none) => finite 0 + | .inl (.inl (some (q,j))) => finite (1 + (if q then 2 else 0) + j.val) + | .inl (.inr r) => finite (5 + if r then 1 else 0) + | .inr (.inl (.inl (q,j))) => finite (7 + (if q then 3 else 0) + j.val) + | .inr (.inl (.inr s)) => finite (13 + sectorCode s) + | .inr (.inr s) => finite (58 + sectorCode s) + +theorem cellAt_code (c : SeedCell) : cellAt (cellCode c) = c := by + rcases c with (v|e) + · rcases v with (v|r) + · rcases v with _ | ⟨q,j⟩ + · decide +kernel + · cases q <;> fin_cases j <;> decide +kernel + · cases r <;> decide +kernel + · rcases e with (e|s) + · rcases e with (⟨q,j⟩|⟨r,i⟩) + · cases q <;> fin_cases j <;> decide +kernel + · cases r <;> fin_cases i <;> decide +kernel + · rcases s with ⟨r,i⟩ + cases r <;> fin_cases i <;> decide +kernel +theorem code_cellAt : ∀ i : Fin 103, cellCode (cellAt i) = i := by decide +kernel + +def cellEquiv : SeedCell ≃ Fin 103 where + toFun := cellCode + invFun := cellAt + left_inv := cellAt_code + right_inv := code_cellAt + +instance properFaceDecidable : DecidableRel properFace := by + intro a b + unfold properFace + split <;> infer_instance + +instance seedAdjDecidable : DecidableRel seedGraph.Adj := + fun a b => inferInstanceAs (Decidable (properFace a b ∨ properFace b a)) + +def adjCodes : List ℕ := [7243717715589717591194788771456,7726619075706194405914338017664,3863334018612617729895957824256,482913190295244515963480050688,965825603447607950602534918144,604462621576955615502336,10141204197363213635018010132480,5151073943635249663071907479555,2575545132070798340360931115014,1287788886541746187830420307973,160971236130163140008121204745,321941954165072225809775722520,643883649282517424516318101521,302231743134033445388321,864691128455135266,1729382256910270500,3458764513820540961,6917529027641081890,13835058055282163748,27670116110564327457,55340232221128654896,110680464442257309736,221360928884514619425,442721857769029238832,885443715538058477608,1770887431076116955169,3541774862152233910320,7083549724304467820584,14167099448608935641121,28334198897217871282224,56668397794435742564392,113336795588871485128737,226673591177742970257456,453347182355485940514856,5070603005375827413301400174657,1813388729421943762059330,3626777458843887524118596,7253554917687775048237121,14507109835375550096474178,29014219670751100192948292,58028439341502200385896513,116056878683004400771792968,232113757366008801543585872,464227514732017603087171649,928455029464035206174343236,1856910058928070412348686402,3713820117856140824697372737,7427640235712281649394745416,14855280471424563298789490768,29710560942849126597578981441,59421121885698253195157962820,118842243771396506390315925570,237684487542793012780631851073,475368975085586025561263702088,950737950171172051122527404112,1901475900342344102245054808129,3802951800684688204490109616196,7605903601369376408980219232322,24739,49446,98853,196771,393510,786981,1577009,3147832,6292521,12587057,25167928,50332713,100667441,201328696,402654249,805310513,1610614840,3221226537,6442455089,12884903992,8589943849,51539607747,103079215430,206158430789,412316860611,824633721158,1649267442245,3298534884425,6597069768792,13194139537489,26388279067205,52776558133574,105553116266691,211106232534089,422212465068120,844424930136145,1688849860264517,3377699720528198,6755399441055939,13510798882112585,27021597764225112,54043195528450129,108086391056892485,216172782113784134,144115205255725251] + +def indexedAdj (a b : Fin 103) : Prop := ((adjCodes.getD a.val 0 >>> b.val) % 2) = 1 +instance : DecidableRel indexedAdj := fun a b => inferInstanceAs (Decidable (((adjCodes.getD a.val 0 >>> b.val) % 2) = 1)) + +theorem adjacency_certificate : ∀ a b : Fin 103, + seedGraph.Adj (cellAt a) (cellAt b) ↔ indexedAdj a b := by decide +kernel + +end SeedEncoding +end EilenbergGanea +namespace EilenbergGanea.SeedChainCertificate +def edgeData_0 : List (Fin 103 × Fin 103) := [ + (0,7), + (0,9), + (0,10), + (0,12), + (0,13), + (0,16), + (0,19), + (0,22), + (0,25), + (0,28), + (0,31), + (0,34), + (0,37), + (0,40), + (0,43), + (0,46)] + +def edgeData_1 : List (Fin 103 × Fin 103) := [ + (0,49), + (0,52), + (0,55), + (0,58), + (0,60), + (0,61), + (0,63), + (0,64), + (0,66), + (0,67), + (0,69), + (0,70), + (0,72), + (0,73), + (0,75), + (0,76)] + +def edgeData_2 : List (Fin 103 × Fin 103) := [ + (0,78), + (0,79), + (0,81), + (0,82), + (0,84), + (0,85), + (0,87), + (0,88), + (0,90), + (0,91), + (0,93), + (0,94), + (0,96), + (0,97), + (0,99), + (0,100)] + +def edgeData_3 : List (Fin 103 × Fin 103) := [ + (0,102), + (1,7), + (1,8), + (1,14), + (1,17), + (1,35), + (1,38), + (1,45), + (1,51), + (1,57), + (1,58), + (1,59), + (1,61), + (1,62), + (1,79), + (1,80)] + +def edgeData_4 : List (Fin 103 × Fin 103) := [ + (1,82), + (1,83), + (1,89), + (1,90), + (1,95), + (1,96), + (1,101), + (1,102), + (2,8), + (2,9), + (2,15), + (2,18), + (2,36), + (2,39), + (2,44), + (2,50)] + +def edgeData_5 : List (Fin 103 × Fin 103) := [ + (2,56), + (2,59), + (2,60), + (2,62), + (2,63), + (2,80), + (2,81), + (2,83), + (2,84), + (2,88), + (2,89), + (2,94), + (2,95), + (2,100), + (2,101), + (3,10)] + +def edgeData_6 : List (Fin 103 × Fin 103) := [ + (3,11), + (3,21), + (3,24), + (3,27), + (3,30), + (3,33), + (3,41), + (3,47), + (3,53), + (3,65), + (3,66), + (3,68), + (3,69), + (3,71), + (3,72), + (3,74)] + +def edgeData_7 : List (Fin 103 × Fin 103) := [ + (3,75), + (3,77), + (3,78), + (3,85), + (3,86), + (3,91), + (3,92), + (3,97), + (3,98), + (4,11), + (4,12), + (4,20), + (4,23), + (4,26), + (4,29), + (4,32)] + +def edgeData_8 : List (Fin 103 × Fin 103) := [ + (4,42), + (4,48), + (4,54), + (4,64), + (4,65), + (4,67), + (4,68), + (4,70), + (4,71), + (4,73), + (4,74), + (4,76), + (4,77), + (4,86), + (4,87), + (4,92)] + +def edgeData_9 : List (Fin 103 × Fin 103) := [ + (4,93), + (4,98), + (4,99), + (5,13), + (5,14), + (5,15), + (5,16), + (5,17), + (5,18), + (5,19), + (5,20), + (5,21), + (5,22), + (5,23), + (5,24), + (5,25)] + +def edgeData_10 : List (Fin 103 × Fin 103) := [ + (5,26), + (5,27), + (5,28), + (5,29), + (5,30), + (5,31), + (5,32), + (5,33), + (5,58), + (5,59), + (5,60), + (5,61), + (5,62), + (5,63), + (5,64), + (5,65)] + +def edgeData_11 : List (Fin 103 × Fin 103) := [ + (5,66), + (5,67), + (5,68), + (5,69), + (5,70), + (5,71), + (5,72), + (5,73), + (5,74), + (5,75), + (5,76), + (5,77), + (5,78), + (6,34), + (6,35), + (6,36)] + +def edgeData_12 : List (Fin 103 × Fin 103) := [ + (6,37), + (6,38), + (6,39), + (6,40), + (6,41), + (6,42), + (6,43), + (6,44), + (6,45), + (6,46), + (6,47), + (6,48), + (6,49), + (6,50), + (6,51), + (6,52)] + +def edgeData_13 : List (Fin 103 × Fin 103) := [ + (6,53), + (6,54), + (6,55), + (6,56), + (6,57), + (6,79), + (6,80), + (6,81), + (6,82), + (6,83), + (6,84), + (6,85), + (6,86), + (6,87), + (6,88), + (6,89)] + +def edgeData_14 : List (Fin 103 × Fin 103) := [ + (6,90), + (6,91), + (6,92), + (6,93), + (6,94), + (6,95), + (6,96), + (6,97), + (6,98), + (6,99), + (6,100), + (6,101), + (6,102), + (7,58), + (7,61), + (7,79)] + +def edgeData_15 : List (Fin 103 × Fin 103) := [ + (7,82), + (7,90), + (7,96), + (7,102), + (8,59), + (8,62), + (8,80), + (8,83), + (8,89), + (8,95), + (8,101), + (9,60), + (9,63), + (9,81), + (9,84), + (9,88)] + +def edgeData_16 : List (Fin 103 × Fin 103) := [ + (9,94), + (9,100), + (10,66), + (10,69), + (10,72), + (10,75), + (10,78), + (10,85), + (10,91), + (10,97), + (11,65), + (11,68), + (11,71), + (11,74), + (11,77), + (11,86)] + +def edgeData_17 : List (Fin 103 × Fin 103) := [ + (11,92), + (11,98), + (12,64), + (12,67), + (12,70), + (12,73), + (12,76), + (12,87), + (12,93), + (12,99), + (13,58), + (13,78), + (14,58), + (14,59), + (15,59), + (15,60)] + +def edgeData_18 : List (Fin 103 × Fin 103) := [ + (16,60), + (16,61), + (17,61), + (17,62), + (18,62), + (18,63), + (19,63), + (19,64), + (20,64), + (20,65), + (21,65), + (21,66), + (22,66), + (22,67), + (23,67), + (23,68)] + +def edgeData_19 : List (Fin 103 × Fin 103) := [ + (24,68), + (24,69), + (25,69), + (25,70), + (26,70), + (26,71), + (27,71), + (27,72), + (28,72), + (28,73), + (29,73), + (29,74), + (30,74), + (30,75), + (31,75), + (31,76)] + +def edgeData_20 : List (Fin 103 × Fin 103) := [ + (32,76), + (32,77), + (33,77), + (33,78), + (34,79), + (34,102), + (35,79), + (35,80), + (36,80), + (36,81), + (37,81), + (37,82), + (38,82), + (38,83), + (39,83), + (39,84)] + +def edgeData_21 : List (Fin 103 × Fin 103) := [ + (40,84), + (40,85), + (41,85), + (41,86), + (42,86), + (42,87), + (43,87), + (43,88), + (44,88), + (44,89), + (45,89), + (45,90), + (46,90), + (46,91), + (47,91), + (47,92)] + +def edgeData_22 : List (Fin 103 × Fin 103) := [ + (48,92), + (48,93), + (49,93), + (49,94), + (50,94), + (50,95), + (51,95), + (51,96), + (52,96), + (52,97), + (53,97), + (53,98), + (54,98), + (54,99), + (55,99), + (55,100)] + +def edgeData_23 : List (Fin 103 × Fin 103) := [ + (56,100), + (56,101), + (57,101), + (57,102)] + +def edgeData : List (Fin 103 × Fin 103) := [edgeData_0,edgeData_1,edgeData_2,edgeData_3,edgeData_4,edgeData_5,edgeData_6,edgeData_7,edgeData_8,edgeData_9,edgeData_10,edgeData_11,edgeData_12,edgeData_13,edgeData_14,edgeData_15,edgeData_16,edgeData_17,edgeData_18,edgeData_19,edgeData_20,edgeData_21,edgeData_22,edgeData_23].flatten + +def triangleEdgeData_0 : List (Fin 372 × Fin 372 × Fin 372) := [ + (237,19,0), + (238,21,0), + (239,33,0), + (240,35,0), + (241,40,0), + (242,44,0), + (243,48,0), + (251,20,1), + (252,22,1), + (253,34,1), + (254,36,1), + (255,39,1), + (256,43,1), + (257,47,1), + (258,24,2), + (259,26,2)] + +def triangleEdgeData_1 : List (Fin 372 × Fin 372 × Fin 372) := [ + (260,28,2), + (261,30,2), + (262,32,2), + (263,37,2), + (264,41,2), + (265,45,2), + (274,23,3), + (275,25,3), + (276,27,3), + (277,29,3), + (278,31,3), + (279,38,3), + (280,42,3), + (281,46,3), + (282,19,4), + (283,32,4)] + +def triangleEdgeData_2 : List (Fin 372 × Fin 372 × Fin 372) := [ + (288,20,5), + (289,21,5), + (294,22,6), + (295,23,6), + (300,24,7), + (301,25,7), + (306,26,8), + (307,27,8), + (312,28,9), + (313,29,9), + (318,30,10), + (319,31,10), + (324,33,11), + (325,48,11), + (330,34,12), + (331,35,12)] + +def triangleEdgeData_3 : List (Fin 372 × Fin 372 × Fin 372) := [ + (336,36,13), + (337,37,13), + (342,38,14), + (343,39,14), + (348,40,15), + (349,41,15), + (354,42,16), + (355,43,16), + (360,44,17), + (361,45,17), + (366,46,18), + (367,47,18), + (237,58,49), + (238,60,49), + (239,62,49), + (240,64,49)] + +def triangleEdgeData_4 : List (Fin 372 × Fin 372 × Fin 372) := [ + (241,67,49), + (242,69,49), + (243,71,49), + (244,59,50), + (245,61,50), + (246,63,50), + (247,65,50), + (248,66,50), + (249,68,50), + (250,70,50), + (284,58,51), + (285,59,51), + (290,60,52), + (291,61,52), + (326,62,53), + (327,63,53)] + +def triangleEdgeData_5 : List (Fin 372 × Fin 372 × Fin 372) := [ + (332,64,54), + (333,65,54), + (346,66,55), + (347,67,55), + (358,68,56), + (359,69,56), + (370,70,57), + (371,71,57), + (244,81,72), + (245,83,72), + (246,85,72), + (247,87,72), + (248,90,72), + (249,92,72), + (250,94,72), + (251,82,73)] + +def triangleEdgeData_6 : List (Fin 372 × Fin 372 × Fin 372) := [ + (252,84,73), + (253,86,73), + (254,88,73), + (255,89,73), + (256,91,73), + (257,93,73), + (286,81,74), + (287,82,74), + (292,83,75), + (293,84,75), + (328,85,76), + (329,86,76), + (334,87,77), + (335,88,77), + (344,89,78), + (345,90,78)] + +def triangleEdgeData_7 : List (Fin 372 × Fin 372 × Fin 372) := [ + (356,91,79), + (357,92,79), + (368,93,80), + (369,94,80), + (258,106,95), + (259,108,95), + (260,110,95), + (261,112,95), + (262,114,95), + (263,115,95), + (264,117,95), + (265,119,95), + (266,105,96), + (267,107,96), + (268,109,96), + (269,111,96)] + +def triangleEdgeData_8 : List (Fin 372 × Fin 372 × Fin 372) := [ + (270,113,96), + (271,116,96), + (272,118,96), + (273,120,96), + (298,105,97), + (299,106,97), + (304,107,98), + (305,108,98), + (310,109,99), + (311,110,99), + (316,111,100), + (317,112,100), + (322,113,101), + (323,114,101), + (338,115,102), + (339,116,102)] + +def triangleEdgeData_9 : List (Fin 372 × Fin 372 × Fin 372) := [ + (350,117,103), + (351,118,103), + (362,119,104), + (363,120,104), + (266,132,121), + (267,134,121), + (268,136,121), + (269,138,121), + (270,140,121), + (271,141,121), + (272,143,121), + (273,145,121), + (274,131,122), + (275,133,122), + (276,135,122), + (277,137,122)] + +def triangleEdgeData_10 : List (Fin 372 × Fin 372 × Fin 372) := [ + (278,139,122), + (279,142,122), + (280,144,122), + (281,146,122), + (296,131,123), + (297,132,123), + (302,133,124), + (303,134,124), + (308,135,125), + (309,136,125), + (314,137,126), + (315,138,126), + (320,139,127), + (321,140,127), + (340,141,128), + (341,142,128)] + +def triangleEdgeData_11 : List (Fin 372 × Fin 372 × Fin 372) := [ + (352,143,129), + (353,144,129), + (364,145,130), + (365,146,130), + (282,168,147), + (283,188,147), + (284,168,148), + (285,169,148), + (286,169,149), + (287,170,149), + (288,170,150), + (289,171,150), + (290,171,151), + (291,172,151), + (292,172,152), + (293,173,152)] + +def triangleEdgeData_12 : List (Fin 372 × Fin 372 × Fin 372) := [ + (294,173,153), + (295,174,153), + (296,174,154), + (297,175,154), + (298,175,155), + (299,176,155), + (300,176,156), + (301,177,156), + (302,177,157), + (303,178,157), + (304,178,158), + (305,179,158), + (306,179,159), + (307,180,159), + (308,180,160), + (309,181,160)] + +def triangleEdgeData_13 : List (Fin 372 × Fin 372 × Fin 372) := [ + (310,181,161), + (311,182,161), + (312,182,162), + (313,183,162), + (314,183,163), + (315,184,163), + (316,184,164), + (317,185,164), + (318,185,165), + (319,186,165), + (320,186,166), + (321,187,166), + (322,187,167), + (323,188,167), + (324,213,189), + (325,236,189)] + +def triangleEdgeData_14 : List (Fin 372 × Fin 372 × Fin 372) := [ + (326,213,190), + (327,214,190), + (328,214,191), + (329,215,191), + (330,215,192), + (331,216,192), + (332,216,193), + (333,217,193), + (334,217,194), + (335,218,194), + (336,218,195), + (337,219,195), + (338,219,196), + (339,220,196), + (340,220,197), + (341,221,197)] + +def triangleEdgeData_15 : List (Fin 372 × Fin 372 × Fin 372) := [ + (342,221,198), + (343,222,198), + (344,222,199), + (345,223,199), + (346,223,200), + (347,224,200), + (348,224,201), + (349,225,201), + (350,225,202), + (351,226,202), + (352,226,203), + (353,227,203), + (354,227,204), + (355,228,204), + (356,228,205), + (357,229,205)] + +def triangleEdgeData_16 : List (Fin 372 × Fin 372 × Fin 372) := [ + (358,229,206), + (359,230,206), + (360,230,207), + (361,231,207), + (362,231,208), + (363,232,208), + (364,232,209), + (365,233,209), + (366,233,210), + (367,234,210), + (368,234,211), + (369,235,211), + (370,235,212), + (371,236,212)] + +def triangleEdgeData : List (Fin 372 × Fin 372 × Fin 372) := [triangleEdgeData_0,triangleEdgeData_1,triangleEdgeData_2,triangleEdgeData_3,triangleEdgeData_4,triangleEdgeData_5,triangleEdgeData_6,triangleEdgeData_7,triangleEdgeData_8,triangleEdgeData_9,triangleEdgeData_10,triangleEdgeData_11,triangleEdgeData_12,triangleEdgeData_13,triangleEdgeData_14,triangleEdgeData_15,triangleEdgeData_16].flatten + +def edge (e : Fin 372) : Fin 103 × Fin 103 := edgeData.getD e.val (0,0) +def triangleEdges (t : Fin 270) : Fin 372 × Fin 372 × Fin 372 := + triangleEdgeData.getD t.val (0,0,0) +def triangle (t : Fin 270) : Fin 103 × Fin 103 × Fin 103 := + ((edge (triangleEdges t).2.2).1,(edge (triangleEdges t).2.2).2, + (edge (triangleEdges t).1).2) +def edgeLookupCodes_0 : List ℕ := [ +539308444549082356491752287909326183426464912366339139781129275178863916183935784697545588561881155762728260682345972670060416696876225432522252714072845974688325235239916136445621603303845709788079501054819797455545459152796807710230896398097542351676936324040692200595397156860396293377773231214769324687360, +798494385964783801143608826032965403140977342049928697190365372535310697209048811264676733180033956852196987546018861884172872086035816854132865449803533653731351945270377344793394695381665482860124458693186222147656939956350863819080464639432715829750053259145346874197799978907023390893592477163043145383936, +1032387827937896701936999347097236551693905144394577639124200286695598642925199909094821986611074343810155524683346113527032504172512929739408948259436470887823449221440818458968284597631224047201777603335447575643157087950602789437247149806822943141981229487422757983248555496472872278645363095269653086208, +1227431811162305011616494391569921538066725297217451758593339146680570242602422105775973732280028000445395431755498796189549993047440367773266567159143686638500912515102786283150425818079438313775233888034455925753784251790014568730990740621861692432328386488949034824047556274534105294242651832320, +1529218593185593780992386251337889671275517429626312788471185376766237507998661442998244821126555289608058121021326215327298212263035612554355603818593632632366190010903576641690757999226741840976037058671880300770519223722199137497194509100910088885351914645103311095294119195116094448307598350352384, +1196675864571150401516528216380653912802418752795291780028657428993776888722459038110017505120398351103732672361286816204322660269274811012807720991223823320519687240637009183021430337509433213724369886758051538385002455557923674779549696, +2654178362004863499238265706443280593203245108170597463794461375685477716122751997321391831422752866401740697670288527293272183367478580954432066527644705872269975931439293468963002848585639539314109127634550739286331541262437734163025643906154482777589271651577174328551039699158578973116449075348141558988800, +2730246448572142287222248249269631093664924786693548868506890145819922899481162462438562083519182065769767651405449718099610134106275904219948082631539477187198015464924326724976203632679714848731114036987319818608680493233279978129935271914721101293903556707078737730030991118052291050554050738171353524862976, +2743062034396844343997678270943799725959330023168550399064946236750171955952951956306506596584346365945732302040042574276952026844306435640763769988839014179323182992053281300070489984043040019597414388365987658377079736031202740593457472327253636858212589368120404321185541783954055359385686610532240457728, +2753777120468707017216679429648657555675299740560145397429702066978119760636416461324143666331518005441460015474577528586259130144708809356511564772308163510423830837839965336919061923152342734365095912881892789698777343884746556441432017621140575145058740455701929787274178999174423865065121390545338368, +2644488410133503752729766330679270302620347895575680336413021429746389909425847482609469099509330044651673384061576217262485171998179187347122896259462153577335095901894885149561835987406417023500527933980964264073640301799478418295978604495611784386708698849443245801643821282283184219507130368, +2789705751055249966351632240625415946744831959974004638270325607901435856745935371984448185915035667857372272438703593346830953680827012952405676397411148673749060041386863250371936274628239279569752293990023695194647339626275502458441822455281075557204717421727924311057958788595487336490596302848, +2940370299017003100065775368842505322092981939075596914744753502613505505136206203794894786014252715409252327535266198445782324964446989287542408831976266180196508776663973626054687402580030659107865598022230342254785256054817645714221986925655032467059235645009503873019514595494212380998792208449536, +1799629292016028174938772255682102161972014050689126977340833788769352877371219803561766504053205919065558106484553724118760589248856161840286364059636524187388342730337610728137589063974043498152669833817633751391008599231600187083325440, +1156018339198867022526243815205494651869163363597478520368892099169304143792328242644184133497833012392659682682456619013898850548509206247368951248207767036551533387314665382477824, +1192069914999997287673270577044417617615171247972350227167307128226970800922442227596667403727505187090758129976555467145451085129353694911545228044385391751638218843587730139277950976] +def edgeLookupCodes_1 : List ℕ := [ +1229186099876203258142379507014050520797510872699783628264313596830283938407977302759106820867306874359227130763545964974765821232162777728803481610860574779236011518530808757144176820224, +1267397229355427116756305861769848218784856460775301758883128007020697371311486734806247649605271999628818366905445510750811884842872188793021081297173000606509554627817248616107757405208576, +1306734481856125027507010670957884113175615270815769684401765264268476405445841624665261992593839882151719067554836432248282694393865925828349334963020567182419387863714763842457474812423962624, +1347229901672747711954497678810566297923110426416773496532180428132104911532770132878260625399686386363932802456060581363439635157637867860628564662001645305623543591469737064469100586920287666176, +1388916422579019157239620024893705486289296195090635608306640103068968943502334404709676001672479471006213406449631903851149098246099996337180068169595115332044425226747449297164028893100480107905024, +1431827892065428129216342452925840469509455169055227039912271306476198356577394885992461437886136404352777854140679958923403274332957507568718321792307758972037470019409805148479179556039255701141323776, +1475999096227779216813377536369179157564079139161746654124588182947607055368600925759707801661085522324677816398783332662507388991394425741480195869644922720318923373189347549862290970156666646310812647424, +1521465785324093470012641690564912818534887613656003399044106801217113081448396275981450333109009783390321776801290636684748620867420532462175058149341901059349992905219127938746267724727434705564579582181376, +1568264700017603606536586018701093048037537985341827301646986550370177575116129488880598914372677623726257632880872592100443827617436849116236181225643418883167650074923380722107954683918789391674252301722189824, +1616433598324055551774952392974044538772839479603104893616955121965088107344999619743941312145130730763085584708836937969361989085834314742994025376113388627518369192860031421378284766941886100326784113961626238976, +1666011283282007050707395279665325871467765823709366917475733520743541122837588626303128920035982924626414953828004189826938366660007215094745294005419946310321218262014485486917656512052154228305033083862763620532224, +1717037631365305565590773052339435658477715476792478130061009916513107992323991185396185022909800428494264595368099179697408057852026974098088658970316577450049153505833265969504204208901956700032449776669513699689496576, +1769553621657431973127345498420815487562177280109122085505913556771665791858986616276957216463620446383186204688713798668319977722067517377697932164181124995409284619636427571614441625049607649567278771674682830800891674624, +1823601365807914032219893136635954033503410085870332483409257430050722815568083208917218272734827780083963354849785894222329962704547239197647951403784268474335473714482780969427536015548018317620560867368738440314612587954176, +1879224138791544549332361710478328839928986252194738126090710403038474096919105661713236332350370020425261092964688751214899474659018076774946017557961794512252764137940848748054409018414324123734249751083624101774450791519617024, +1936466410491683972783670117418435327539692110293253928110429386449928223433209976315126941102363027501612759616713468668040261128785695346176545667531262061348867268865361698216981664673256949990446258157219881642740012005537611776] +def edgeLookupCodes_2 : List ℕ := [ +1995373878129486158900225887546431409143912753499234319466466631872981986940165893156761474947017885785864355878487711838232023251698565196603770220246678059162525757930797341108478458358011901211669269713724091462085031418867088359424, +2055993499561459639982052940652938283916473124923572855345002057749747172438758165060436953298141216163919099811287891722640198766101072239332103861187936017923902906924507446520594116700783294088316488780241944700932393517121190154469376, +3651564180189079187575151168790206490161515738476560225866548523516447087100679967024532353689508733326977191018575597845260542557491091109293241670011947979580717350417385549841912539136546118805039121169584138397650868536775549575891753164029441963244459033186921082086065178495527506780214408232072460107776, +2182563544459054957480898675882037950097848853441320509524077456836132243308874035097777848139572595552217568216058000911338216021111136788521198731917903935419822604058623355095999806056842142504400508123368804621690639436243296325004454526976, +2248614499113475977722303940274185439384343980484659813481467644314315693485813157686743452506709024141493796169959931076124405249008748769860452381391211831464393419594034045463153111888325572675200498601408223466673680816189962182451447384244224, +2316578742989700791279787659719847954297334512686497203415326692176314337099099446715763085842939607488017205746356704480295400747417286111513801995569653793852301816455206681915394480511431466420116353929714473984753814374058791862372693332853784576, +2386510068620495033724862550629304339113063208301263624013445648972563869766375649239348097350665394437268238555826626087566756372326004206275072770656979632419906325756029441307156658635998767534927254826585013390984990302555199948713067053303279386624, +2458463748525605332151523878610415997978271616626231410411107087520339822943512028202756909873316485946170223029641202470206486916399828412784652592999048990653496925657013494100940154089770714578591091946641823151700044478539977759085052040974626168242176, +2532496575266635519763239429505458537169680904142816122708424530424600825084165520982447480892980846580303636252790722382586486074918736402783877804897639257814026008309609308470632335089949379790250675149681246813216213900557753109184433581431494906451329024, +2608666902572084407708998049089383518627442353009020191903616412905854639589554918487318411341502066228970459262186345918137886256582705675137301867073794405579644072700351282157467599249380913000472649877505297120349780229212742648899352445854691959421613899776, +2687034687560841260216769456501941755077766615220015794333497453216684067115954527732337256702557947453143034881551351927303383830987392280395686770618783960225510925201062535619591871863453348962026095003378685444061345202436450420729697182027297929868356484071424, +2767661534093176921026073508594027301970977035221805990049476300408599534891217734588068311236011805785928007146110858889659977866479712204237595063658498507916765511635932526909375408225833618443845833248964553356169743820962869625842132438527376684327915862806757376, +2850610737279029648988339295979587836664136761813315386062286037732674135097034785564900630127210775940953647691277448607499561666589014746470407039184242934336110423926760465760551669415414791731790791899616596805243566238341953557357624281762611495393929918386561613824, +2935947329174165637986282822818705117296632872508929472833442144099268962780633713573498172977915353863287824450495874777075001341852471496500753134778555798083023835072845848541084590906957781173333453365548534757139778359314358904681374665188545808420939769097219762814976, +3023738125695595433378310355511615784805570253743128566107241866813726321891229498090023015122500478118952052393086609592392142374008618898038588888506825555359611490349761515666805014868511555188032651085711026570967188367940154743427627075432629704251899189008998843467956224, +3114051774788449539541675110867842590207373768742004072481831913543476455316572235244322714742390409095062909490038214054972910974935354351268256324608419812845779531350967175605800354455857502673481570227302762035838201544645023711704603129561281024697094199769543321408898072576] +def edgeLookupCodes_3 : List ℕ := [ +3206958805877359979831255467716393591576415843994669561108324511200969888784922075591128946687324496482630571345465077644632338594699144141767677570443110663171396502101789244588843390654831792982443730680665531251718146253331792861326659721092658413814009477113724750957167587098624, +3302531680636259974319959676829815163679212491568667598843139218363821964621490362667081147881923803189162724734086168675299754343490033078104740520434892224500443918438592615789923551587190275304696149451338786999027685503945811396472633177614914619738311161511359632170622513028530176, +3400844845111401809195738884831276328534195362700076612722026636552039181442273812407138564460571977707634426276266084190715897821192337976360324309745704069031298886374351918203772386451284781665658796734132295676207092986347383708617489204050889752300622457301263482225771946872903041024, +3501974783233303966400347198042953655767938185250649706730167002623513263218832889285822498293815276492355811763023802017715043527322503250679187790403664384178322637074007037786790969423141602733372146104415921628579672081053958704380930083045485500404955428060052173935438274974301370187776, +3606000071754273259708679964691128679543664966754735065121770218923764126352156052138736749137924964159584226323610761035916295870201909671490973171330793268908641499648693976404909071483051611178096316777554301424356639686746313206924852450450288531920971222879857195081406542183168026999783424, +3713001436649106696011166104152343363154904301376312146485093813412915887276264679064362250263534679235580007835530392377029004460467789838629333038375151829420728953788011260022931650843449570464992825286847179879472839846393213645377159675762687909301522521524450267190194473771675085749539045376, +3823061811017561675858579378648034261460065973038874200356346800791446844587951678196385863075670215855867666345659766224158435276645195953819555378490953063914505228222218125524210086387972394069621782726122245222814188189243599428467988932878623090601953803079605009015837335908132978535731061325824, +3936266394528192609281766058643526573106698180063646477017044517527621448299528524831605536646636462258689438379762084509940910065429888115591857895102208670210236423951885026083776678207746486254685094255117289727025344896799281238087440750362883852369048109177009095095209503410248365326268559551102976, +4052702714444187711983971157556701247977767735025137431418050468909876559606778399938674636291877502444513675695686214048095828385356897868259830868612793756643347962065119940229900521425110262765647342590653849954190296153920631461297828693461051043800776216576514724821198412646982206087115276599871668224, +4172460688272902340672935803967929635936539170473063291259542888316384006302555740620580047930981649956996471286267958843404456820442716473501285634704308055031207757827593844480014053750259838573053080232005217513376398472723250109229176891955721239322262701420310667535259948853114968146054705376679822360576, +0, +0, +0, +0, +0, +0] +def edgeLookupCodes_4 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def edgeLookupCodes_5 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def edgeLookupCodes_6 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0] +def edgeLookupCodes : List ℕ := [edgeLookupCodes_0,edgeLookupCodes_1,edgeLookupCodes_2,edgeLookupCodes_3,edgeLookupCodes_4,edgeLookupCodes_5,edgeLookupCodes_6].flatten +def triangleLookupCodes_0 : List ℕ := [ +13294967190722672327635403631087981764154919981897080582554330842249092294775263194477922715455889686138890840707770007378246892529447488991165886118815198159099258842327506663501475934384289129658747857741106779387446195516772979632326571246780444414872038835124894742903521280, +109885262476218376871924296866160913150533682044021661152220457271242472100193684741113876104254617735388509981091103653519468909707703360923130924086172159123903261819743868502552963274301024981339404767223825637569903388432703533859248614854415898347962782985284942299136, +1322529930335160584440694777204285280003964984688105905584588626029735375535456493664810237828321950055558629210387188020243086679066214921045384693822042178256362130242211882077239496894959459279870241403630496971307896543677371929269978180130149681499373389742080, +478766918841696655167265841034159787385582703552910865082659397267834541485140960344502076529873083444648328857745501682276988759444909982734466107419132637536579956649449600549638863027134356608285549561866089221405552100843293014911871113278550088088525673424792584192, +652256851791998314897882745477135954528242135550073558989674691588359370031752069886978243534587085960744212701833906547547000602882154806381427471248106524032226418708778612403085585960654645696082060682140319744, +60926090171221782694573436686486640725556986254891875812103672266538549252485557335008576587493331543867088940163393370116535622229926004108428915985348394991776432128, +8672988336031482040082543481224112597442867659693666745736500213070071835083345982765352860651479745592258970278698761130301577785045725046401022790428495970263199193667469312, +1230590710896269474258835957075909978847128585749397693154962126836384224384640572166663121703375468993593685748163890291904061990801804614745201317991922355944081728571260168117944320, +174095510475444102371473844802169853679302081138638858740172053362069890966752624119638999372893013427680049982699069428744579747497247719942174420094228014088000117216589852507320367984934912, +24565056273876482518646047030038662949159521782899638389745043721333134161083623115006043711392500551716967694067670419086951638451191862266687993056357787854672883709733143662116610562900626077908992, +3457906178127349103174261892931755724689644437154339819932373766895833428486734890168406261718602360998534867973017070481591899292902777958299915141196226709732780567936635939684859489542615130471294717394944, +99712253930420037844647187615551837095479233674217389013632735591105016888844692209184459057832238531764518024802768480194881302749147726201990851085254876409382442566858625492647682133840854662213802562446526529554513275883162541061957588221082477738957692011394273896501870592, +68086976544455123851443014185553577785401142814741534120116820553099548250008495832730620235194995226968347537163627157498552687436328005747276194963420270626046493765648285667006159267799082053419789937034700527117868728320, +9527366886735991160621276470213248102767843487852853031638479498980179869805851907913320235428920378360219628614034828151935750973845208628745997301131623319102338934877950006326042045809535768830031920833314735967393212528691511296, +1330937145942708950183693561926647540961465204074316324556632208796468675352362749138974832452404810748417147224009707920420401221275869974002579658821710019423992253076520148304069931915473011130975210206200144050941416550876306002040324096, +185640935834764777475771402737796666356502209809535908930409940363510419887908639498777291445550917690080029091035405251832652533117130032952236978535189101868272787734350876483066032575867289297235047279311344573110485051026339870294183422053056512] +def triangleLookupCodes_1 : List ℕ := [ +25856577124987281773487090236950460581671140768115929294901153980832139515104858814456571208831234079499646374179355459269729056940802184007243390871574497581220807543210415688107376985323773030175281881352014733193148948462735813891959450221506104559403008, +3596612273344502738523859370257459947515999854844108528229773773797774899461920114940023180599113966813376012631421546118920632321354589683284461435455911147594737503708086130463916244185229096652574038653656642170922911558313217303630599128070321533026664542371840, +499667571229751385815622372821352862903107286556539187147651838106291010461932331151647270834244764025631726214560008018595410351122133764700775397567479038584663480559808996170338378562335083278463482287497494632498257009638086487115091266815097687419761709045341820551168, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_2 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_3 : List ℕ := [ +0, +146244639097949396834020997173330021645114182012520063764157859879918914024466441881050805191526630873038184114795382261805449365352119822640607117984405035947940105805268599953476529675781231208360391140712836091994722840861403544223423866373504191727948262861880286117678284800, +315928582331626005259959602382665871675571801919503796860566929819839216599719783283490465704520075680373549938940402017853896412314855314218864534508541092301295121326134303675808141352654794398834610805944177042645235292598545795096847829785883096577649416454905390931378176, +528232450351730156348427302687715045282448507475427064642085174257409176876082837898726719229617605096392996568951669064240462732602196308089946328944721417732096, +72788826064673282916768264623553037691024603616430369590263744560401442585200136551465823068612070956000000397321861266377411178165053373528406568814253659044995661824000, +436576803934513939977110233074892993126590609099186060963895975685659523655769082669011865700732005528421809757932499867725466647287703214811377298217857276570184487928117956170373868445737087877399409295041077337653248, +60079835142268852957813437752978788852723434365571455644490095119977806868054282274861503060579223979076991030878564672416859766461941197135758609373598507322579168866964387963921412032623010295796513690145040591747592736473088, +567821437046316870563543859090659428973659039695133475306703730218578355023598276682479080497418077182504939466494401023410106793658188652783421947992284163405279238841095423740481894515106435089819744914067559478352857339879345537710351141830656, +10475448441702404762485195524959540357780414890148241670825700001114041173006367340586843977564696624976651182480956703745498945402030176485947095723940045587147912087444918911429962962194121489881612729609351235546669443318541697435789255166054253332208572956672, +193149214102198189627022742329951323332084991270847312138820701748104857772905516878587839531140221302696495092113945828872349053588314976481210815355297737256315270814724889857642394696899887629897494648368868052804620310163474025712497898225441488451404651441897855924106690560, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_4 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +406812147111956773965496629218182891125446297448265522975296776117052904635984454150879428905762326052495867137694870270382435144913018920815377773178499761473939466470357238363608310050866101530453732690291693847940478691711332068019001781824524197860103784427956384263307264, +853723962315235085027361272454469852100399378208581354258391855449932476097338681773409601924146123811549864809666046458677354586702550008271500752047767046246598802035709544322137990790642293257031890782775279412619130545548585221014884825744110126882496793217159219118080, +371427511056364703867098802607987358529620400526307298530902692102600428261750118893621049644308414234511751681334339150812622440375324698387237383010239887152513024, +50820178012646875849284773987588028885087261154127786808513994039107574970772676442191782481242352963713413138164265935420310692626567257590072273629792684923782757473058816, +302754152721668082827219891305882858240929328557681817050531117158307156930715206366862147506695653386196452807032829242525757353453251717021916990287204046449192182541965405973108934490477532493666096605064897210498416640, +41394520592253895195861023462710043372985858217762569288468949202663738761144375789679239801436708670177207922773733658502717051385271054035186179767228452958944465846625253352522198539436559029030516559083867104852163517321576448, +1483164366550955711229120783856444771425846985895751728395639501240108626546139083658489813992297048529234042847700295224491406811675253462523633673171180173768556495674558660109392983423400446078580960737537714414224353807617127573599427756032, +27199733470759428933185504330830037608532505007429851313384029492733014151369476477893467149456540592814311211506187891069298888284013027337361772864756376394823930640546840037690604511648373828835286699166561214557138818358892367823095696113469062344188362752] +def triangleLookupCodes_5 : List ℕ := [ +498659321117078968692958932341839690959566066434799249222670625093113603318902821757340345501383170282534740131715376788511763390804822889352932743927082518402133824573396894967202354460849623415713785538992173579428940497641370131536518186333800798304381424663698487581343744, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +7746246734820226297275874885555707565232111191494709215958558642005709247329543290683206179408140982645670193450993858636552646777673401283688629002856099662223950621791464453316373479204380328190935472067886933609236823316323933112039587307490315228007603667730432] +def triangleLookupCodes_6 : List ℕ := [ +4224034642259042424595178311245771544774277075761758829459944438626882607541207446738246446371342773718655156906754717276234978066642610236050535371083096196798179729302502905916879574013544838936519766055742677795654864977234133639360316078536129731246822274577203200, +8639927619433971788738542594113786102639074143476470483792227425846370239779049591447729874742523122457738202139765327280775645983068683035476858403989487135034494387282659661316096, +1177069777745036436884759733010709194146676536802171801896137739101783940307310758997054717820038046390824371975696485802137984174393618789058140691504039695088578906573898303706345592848384, +160324163303243939983050770224308237156748049744714395960552825078980529375712923361817776189692430988221490758416107472897601083909132891258598518775038606575175092857019710345912199115545656688640, +21832485834358278738062713795146582102503891218227173389481870578265458752535495738361328027432884677731853885183730395059366922128922673772566018162534049239877330785005171231381523883884045975151636905984, +2972469922115601191607463126628792708098337332951607903165856674068496360817316015821294749234613498860547907057070959715766574793127303914279383578053061294054384676406739489659370491681943990513024870973066706944, +14236202776874425758082354664329032806066830555455828749992322425689380723395904453432572289356481041186484868560017658532291846109521819265946253240308870751220051016367188421419545102920349839436455386856581589328499682437779796525056, +260043484994121278592466653335262351842510479319182350799557225910242454220479787962492629984020893197990414762420175192628654307928972906797595558725065880187039751284756556764528045048077680333521857418494889952178908483823677785601177736832029294592, +4749142002217831161907904527253451025198254210517874238928498872244534372306182581539846094428089682953047290616216668328585365946542920632846730275856289088089637737317678141255860775468268146492070842219377245611763335890340241280293883101465966784009469078242590720, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_7 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +4997903584352302105764969420769519358900585512911165840305663695638966770781974709399407690036875067064262773548557034514427181841857612505533648359148989001419521998378449825170848182737471570212521588949862949357272728636115481568159394607106817315152451591978614784, +2691000267972294997071308692792713538701323089217349040084136091204092300625885845920762803601342877840602791214051433133385668792322587779061290543911746312077090401453875815902152825139784200011049140676592755176842026955058027617422258801302327656537843938751884034048, +20935034502289460181017175389187016753333657913322974977685953319927192721917283364764261451427856300099505300183710098240056941963860649416492976752444645305133263621754489667584, +2843911990288277334046063853459374206457890149729676553781023707476785810829950727216503223066387056453359303567921108874046340741044214325013348536308346152564251560779258567153009295360, +386274757602904137378237317898234820998968104164473780997552416534956601461253412793473258876924639526571458662883145250202605414574575168648938208764294024672553642859704619250375840792003477504, +52458476779477953278068766224579422532702541068744546612709677603901959860109914629612723717325777001694109457503335035451242519667473930267226270110668825955118806050305626859263739807957853986917187584, +7123207717752304870920156404508142987217125805983749903606467187279416522667805920424555629906668394004704048462648078393479134725026126483838917621853837916135043187947192401127834704356656990240367637711290368] +def triangleLookupCodes_8 : List ℕ := [ +8920048589965046012420127014222893081320427859240596580377424490352044686493875109981969809547706170337733474278671677824694235320343254219361244533091007717820207425106929882935649008146631602287562271335468945001129883741086897789730816, +162525779737345404835076598823604708434845869802068453104580227060615288230377731104284488208554766030561615214817823411422202184796391412775025522785878989346410561697782028680364097158893204555190602046715154279425905891718235787017161116829241625804800, +2960887061527319147433468816512698602917460605504937432307258304875693223643421444463979427437744686011741393716481268192568997009209814583958007338643670018871430398247841849296749288461641502449646192079431188134722707886365045668370033790660515838020530378998760341504, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_9 : List ℕ := [ +0, +0, +0, +3808338392721022419242476675205213153858446017243977876748082531468781577104570802879596130481970746739925616833879874931021614972289252761026008532075601527194254038830102782454680240606241419831066499058126290944, +1288906949475482757646141766432326064901640094213706450446266881242840845942010309722323307892032061424317246241618879981617875978874798175673649255826598670630912, +667132679308324233616017728958485034897140211430195462730928291973677865243823257569934745740630715479618897035568229735582745752704110965133850194882542985168289792, +345264640248423063202411967233852991777096035646962290090684385664522863291052665119764458414356999941113530365658927575335495170162854535333269489040316134898458951680, +178666162529783868822232502907372362591670416917332225670724344749323601703561125050225831428869669661011038949942743821338943751649896579337219931289994373832065807286272, +92445096577216066193833000238598140617455443754710916513289361427666686669876882206275717196589340340312038580566075762742330355802322757930908612705969605937213763231940608, +47827516384861589273949675002174275373043524632446839543381943471964000904975599814059934055217873824863449712005870944747070213509068015227474237742828591345873834564254695424, +24741449380960538960208309187679387007974329375990625193963383753196881016306808800515430863760386762489413463430098482672674449841841550537893512079462781159369841845122969370624, +12797547710910435436623045004413719052774591559766255893358188773759075107464248574070873851519601728844155225248353813317042662587924621967011949790513829657421967561393937758289920, +6618866349449766361917151080824623082222759157260959583952448033731249732904658453646257715606469342870390147696894568194906115510695101470014679754927470264958246962219476581796020224, +3422918794707655567505051197127384068825562847191857229058817748632500741523262278332532745848270131493157283874115575793401030541502871804374651503161272189602020624898691600049971920896, +1769972745470479747946762772926751293211173379003444813380598837245236029337261787339868949148686315231577503809239619927557186530063284047924114929561435957015254428232197729392835321397248, +915154466841927600809440938457232354910033193085265267447338489441603419655482003544822339800605861446993140876765217305033239256513074038788305044226201883112588439816327864094763529879420928] +def triangleLookupCodes_10 : List ℕ := [ +473130438657520420183111340634095640420324155453832596707230911597386748052626417649475470150187176701654323099238271594064485892932478282260205181192677660791483705537418491259082432104166850560, +244583316629490641280915927438381217344876193816580800758489352499544343163722777335808973989101645999333456931621248987111400082703494480210328668027668458203812930503105083444042719697955935223808, +126425010517161383643176370417717998998807767060889247745472756869748055718144424363564291717789418254038989023453441494047633094771486760910557329041759208490181736330778572474078839889192162795978752, +65343161815052062182668178425336225135123928518496832257330670212981456761068946806371527041617302403286655026133403395427445425765777586152154306587316309186565761148911279219101597334031814019772317696, +33769839741602557921295388260762027408823439514531005270517395921229777405157349549362246002547928402178738008196426109902081385988379622767668869481088974656593138327789531817715112266136187232257799356416, +17450998084556011522593110613888976664813274945326915801744122211027481061707467946937482321811352562623850825222425436848799085560156734169822583802609663492948278757036282201728105828991019871432792090869760, +9017261169362694855415287008393111191710181815917545935351468907717281839090878937395965281442900881066080148607119721178999040765062707959090537692621707244401085793405093945746469978992799682534190546562318336, +4659000995549548447366605507827233961490415032231788021867492988614908607788817554411489082428615296035199321446583100770003430258342486027894739188893320591571278265962297038954572684053604961738133269810851610624, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_11 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +494129613921859298652362729739290214939819313541121727778668889749643772184587036321595417461360951485286013169141965833786663200918840831091533133524806472001544201255527841857045895862699255552992945931236478307626126957511606769436983328366294788666002354744161116437524512768, +1243434857063054261657157665262706628797403999029375016056278169509489336683696653950254789188207348519778881939979293903477872533596601092296017698995656079821274597409442998889829575864402053771922948686542498904932352, +642297706038226420936960399755329911498564771552961333494887021189376360440549932253982457226356510053244250854053069143598550625061598878615453334285751707214582431353832602032583993831592433209827235373652892697441075200] +def triangleLookupCodes_12 : List ℕ := [ +331753863813206558671593510346830862875063652148675921289707325230025820415512154974942444742835639124153197647276410782011612422615929854963376950623092480799064201643023558980390525348152839622876119562135565289245074522112, +171341466693038689189613207561693599264185416326264647592976637752878563474156925253553086149517693491735213494926156883200392665702564395046728598575042604802182245597637030768690199477519540962468195641835954952908963093413888, +88486377018222397613757715366814615929005180289232498424639039993847760330532673105887047982440212352974842774756757220357549962765195624628330597596703672030844733416471551661783270388113831955468194850743552244594917392131293184, +45693912621879801017565935852565559825790682838741758608217109226609508435096064246760916918439611206748803194936996923656447426913627278844280910194168591566321744428519907107838545225593681376334168848827952923289828188382553964544, +23594393707740024041926615775908882583516525245130996747785743347900909353451212730013524618173354848652537287269649485050792587720434891713974555862438350363059704498076866439600156678386217365231934430246506033841694040060869539266560, +12182274126375726060984049866395749650548849088935021101140135307150208198724219169630955404342081924838239917430556951137015855544879419729754770281196739504211290034560788705273332839049456571279756497865267287531005976406974181727535104, +6289519961286942624000856297229389526188665473209841596115952650329677213942485719805432936539855957589186940814875323355149263962570841549800738795942422334738437819446385558257349354887766963999110434531493624696353077403024977587502841856, +3246958371773190914446274080186447478423715948997095622885455883980005289030743667077026153500961776466531862479516409716810961861715671141359122026451002390180195912293195417300353175645292627713528597583856843866537520581467737154819947757568, +1676125451964143209166904184930021129952683609963905202462486533627502512395742538554199369468680858955468805766050126784402176294192676561520776084162296087026847570447278811531747062573080867768070478176045543366933639952684383121837281528250368, +865181807401171287110305812891945549287641422869144292355901263184508066205565091617260210352573075640357528546604980118424135738975707903316829025680219622544094634905826083535725209198475217995168928967248067929190435516240529828048255899968471040, +446559940299111040577104221747056783380228524767625789978116823629688241185029121789322415891036954365703694612988055205495990894246279888453130596489903948047586976636234452770404312248080912226859915831480738639109553856873807614830501712626049875968, +230475159146917059662710716054239972108894536205439847562246246660561076466078165335351093289756924929814699320378552622263718036550142633168918902697746150068529920102751206794504866501909766574178990096245998847218485621469421546342551759087740200681472, +118943553976672904473571364133881278017081378677685908815716699966833548004055767201059384137371099762887222783440497141408506232446049261286315489276242677113187997781888191370528115267994678317161320082828216069740994390128360240072645960351202746812071936, +61380519152703628492715438923771745440977282466911547227936420681451430327029511040214532357317966828395171591601753774191610281051353853127753984190074534600339802353237895609482106310149916747951614585025782133609535560736960843989967575065335045568117866496, +31673312598707573706220717778430093587050956314034129480819656181700651046903024268025169938586588456034347580457970182134817469998249208052180192189804963081588403119180307065473954612780317797128516243273481031429981180788839037472123094236597393801448909701120, +16342937288310215487575618983879195396260630530564887951839162866943062920379872708331775646835905482716348060680111325124367603762281084571110576370837383397275047645953439528393252246919105648284572579335045944551362639093941310884547988500348541067274993539219456] +def triangleLookupCodes_13 : List ℕ := [ +8432198925354062457633909998183517632486999771312282424063314825653960962429643259614548113979124570082872402004859861501802835397354790205186505902333248356749738442181919661703085942832480555232944559162403635717414355775486481706684903808798318852202570399470321664, +4350368747055766827842100775229894257709341036019375214993908870877733739327893346592372273550471952903666993634049394964443882326231892536301771111832451284016462074693467281852839288444098057494624234345095038886159892651456006267126393602774110555115696182712464310272, +2244327241897089882816327491271591673643693152832953256380109082122567406536606384262193107324739648473550498530104596910061933019657283833624602215255183057601053730298773348819813669968878628203510197452308181137921861194681822157020219625187062711246682276298815451430912, +1157768030874433100686079685440244473518184291954681038173868453046136390931113664035374904622918480414936830115622862642344242323601325408595301182081101341586267585717499622057458495618242074096523666903002983611458486964130902581899123571585935778956353590809010778113310720, +597217543115548764861542244018910213186968417105351684649533980695305354094328247976195552407331973535444892151722071893369228769862718205119900687335193066332567378699277972233816264812758164763059257707737179381914102270251372656334794083878960870274255798350350359088125181952, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_14 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_15 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_16 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_17 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_18 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_19 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_20 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_21 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_22 : List ℕ := [ +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0] +def triangleLookupCodes_23 : List ℕ := [ +0, +0, +0, +0] +def triangleLookupCodes : List ℕ := [triangleLookupCodes_0,triangleLookupCodes_1,triangleLookupCodes_2,triangleLookupCodes_3,triangleLookupCodes_4,triangleLookupCodes_5,triangleLookupCodes_6,triangleLookupCodes_7,triangleLookupCodes_8,triangleLookupCodes_9,triangleLookupCodes_10,triangleLookupCodes_11,triangleLookupCodes_12,triangleLookupCodes_13,triangleLookupCodes_14,triangleLookupCodes_15,triangleLookupCodes_16,triangleLookupCodes_17,triangleLookupCodes_18,triangleLookupCodes_19,triangleLookupCodes_20,triangleLookupCodes_21,triangleLookupCodes_22,triangleLookupCodes_23].flatten +def edgeIndex (a b : Fin 103) : Fin 372 := + ⟨((edgeLookupCodes.getD a.val 0 >>> (10*b.val)) % 1024) % 372, + Nat.mod_lt _ (by decide)⟩ +def triangleIndex (e : Fin 372) (c : Fin 103) : Fin 270 := + ⟨((triangleLookupCodes.getD e.val 0 >>> (9*c.val)) % 512) % 270, + Nat.mod_lt _ (by decide)⟩ +theorem edge_complete_0 : ∀ b : Fin 103, + 0 < b → SeedEncoding.indexedAdj 0 b → + edge (edgeIndex 0 b) = (0,b) := by decide +kernel +theorem edge_complete_1 : ∀ b : Fin 103, + 1 < b → SeedEncoding.indexedAdj 1 b → + edge (edgeIndex 1 b) = (1,b) := by decide +kernel +theorem edge_complete_2 : ∀ b : Fin 103, + 2 < b → SeedEncoding.indexedAdj 2 b → + edge (edgeIndex 2 b) = (2,b) := by decide +kernel +theorem edge_complete_3 : ∀ b : Fin 103, + 3 < b → SeedEncoding.indexedAdj 3 b → + edge (edgeIndex 3 b) = (3,b) := by decide +kernel +theorem edge_complete_4 : ∀ b : Fin 103, + 4 < b → SeedEncoding.indexedAdj 4 b → + edge (edgeIndex 4 b) = (4,b) := by decide +kernel +theorem edge_complete_5 : ∀ b : Fin 103, + 5 < b → SeedEncoding.indexedAdj 5 b → + edge (edgeIndex 5 b) = (5,b) := by decide +kernel +theorem edge_complete_6 : ∀ b : Fin 103, + 6 < b → SeedEncoding.indexedAdj 6 b → + edge (edgeIndex 6 b) = (6,b) := by decide +kernel +theorem edge_complete_7 : ∀ b : Fin 103, + 7 < b → SeedEncoding.indexedAdj 7 b → + edge (edgeIndex 7 b) = (7,b) := by decide +kernel +theorem edge_complete_8 : ∀ b : Fin 103, + 8 < b → SeedEncoding.indexedAdj 8 b → + edge (edgeIndex 8 b) = (8,b) := by decide +kernel +theorem edge_complete_9 : ∀ b : Fin 103, + 9 < b → SeedEncoding.indexedAdj 9 b → + edge (edgeIndex 9 b) = (9,b) := by decide +kernel +theorem edge_complete_10 : ∀ b : Fin 103, + 10 < b → SeedEncoding.indexedAdj 10 b → + edge (edgeIndex 10 b) = (10,b) := by decide +kernel +theorem edge_complete_11 : ∀ b : Fin 103, + 11 < b → SeedEncoding.indexedAdj 11 b → + edge (edgeIndex 11 b) = (11,b) := by decide +kernel +theorem edge_complete_12 : ∀ b : Fin 103, + 12 < b → SeedEncoding.indexedAdj 12 b → + edge (edgeIndex 12 b) = (12,b) := by decide +kernel +theorem edge_complete_13 : ∀ b : Fin 103, + 13 < b → SeedEncoding.indexedAdj 13 b → + edge (edgeIndex 13 b) = (13,b) := by decide +kernel +theorem edge_complete_14 : ∀ b : Fin 103, + 14 < b → SeedEncoding.indexedAdj 14 b → + edge (edgeIndex 14 b) = (14,b) := by decide +kernel +theorem edge_complete_15 : ∀ b : Fin 103, + 15 < b → SeedEncoding.indexedAdj 15 b → + edge (edgeIndex 15 b) = (15,b) := by decide +kernel +theorem edge_complete_16 : ∀ b : Fin 103, + 16 < b → SeedEncoding.indexedAdj 16 b → + edge (edgeIndex 16 b) = (16,b) := by decide +kernel +theorem edge_complete_17 : ∀ b : Fin 103, + 17 < b → SeedEncoding.indexedAdj 17 b → + edge (edgeIndex 17 b) = (17,b) := by decide +kernel +theorem edge_complete_18 : ∀ b : Fin 103, + 18 < b → SeedEncoding.indexedAdj 18 b → + edge (edgeIndex 18 b) = (18,b) := by decide +kernel +theorem edge_complete_19 : ∀ b : Fin 103, + 19 < b → SeedEncoding.indexedAdj 19 b → + edge (edgeIndex 19 b) = (19,b) := by decide +kernel +theorem edge_complete_20 : ∀ b : Fin 103, + 20 < b → SeedEncoding.indexedAdj 20 b → + edge (edgeIndex 20 b) = (20,b) := by decide +kernel +theorem edge_complete_21 : ∀ b : Fin 103, + 21 < b → SeedEncoding.indexedAdj 21 b → + edge (edgeIndex 21 b) = (21,b) := by decide +kernel +theorem edge_complete_22 : ∀ b : Fin 103, + 22 < b → SeedEncoding.indexedAdj 22 b → + edge (edgeIndex 22 b) = (22,b) := by decide +kernel +theorem edge_complete_23 : ∀ b : Fin 103, + 23 < b → SeedEncoding.indexedAdj 23 b → + edge (edgeIndex 23 b) = (23,b) := by decide +kernel +theorem edge_complete_24 : ∀ b : Fin 103, + 24 < b → SeedEncoding.indexedAdj 24 b → + edge (edgeIndex 24 b) = (24,b) := by decide +kernel +theorem edge_complete_25 : ∀ b : Fin 103, + 25 < b → SeedEncoding.indexedAdj 25 b → + edge (edgeIndex 25 b) = (25,b) := by decide +kernel +theorem edge_complete_26 : ∀ b : Fin 103, + 26 < b → SeedEncoding.indexedAdj 26 b → + edge (edgeIndex 26 b) = (26,b) := by decide +kernel +theorem edge_complete_27 : ∀ b : Fin 103, + 27 < b → SeedEncoding.indexedAdj 27 b → + edge (edgeIndex 27 b) = (27,b) := by decide +kernel +theorem edge_complete_28 : ∀ b : Fin 103, + 28 < b → SeedEncoding.indexedAdj 28 b → + edge (edgeIndex 28 b) = (28,b) := by decide +kernel +theorem edge_complete_29 : ∀ b : Fin 103, + 29 < b → SeedEncoding.indexedAdj 29 b → + edge (edgeIndex 29 b) = (29,b) := by decide +kernel +theorem edge_complete_30 : ∀ b : Fin 103, + 30 < b → SeedEncoding.indexedAdj 30 b → + edge (edgeIndex 30 b) = (30,b) := by decide +kernel +theorem edge_complete_31 : ∀ b : Fin 103, + 31 < b → SeedEncoding.indexedAdj 31 b → + edge (edgeIndex 31 b) = (31,b) := by decide +kernel +theorem edge_complete_32 : ∀ b : Fin 103, + 32 < b → SeedEncoding.indexedAdj 32 b → + edge (edgeIndex 32 b) = (32,b) := by decide +kernel +theorem edge_complete_33 : ∀ b : Fin 103, + 33 < b → SeedEncoding.indexedAdj 33 b → + edge (edgeIndex 33 b) = (33,b) := by decide +kernel +theorem edge_complete_34 : ∀ b : Fin 103, + 34 < b → SeedEncoding.indexedAdj 34 b → + edge (edgeIndex 34 b) = (34,b) := by decide +kernel +theorem edge_complete_35 : ∀ b : Fin 103, + 35 < b → SeedEncoding.indexedAdj 35 b → + edge (edgeIndex 35 b) = (35,b) := by decide +kernel +theorem edge_complete_36 : ∀ b : Fin 103, + 36 < b → SeedEncoding.indexedAdj 36 b → + edge (edgeIndex 36 b) = (36,b) := by decide +kernel +theorem edge_complete_37 : ∀ b : Fin 103, + 37 < b → SeedEncoding.indexedAdj 37 b → + edge (edgeIndex 37 b) = (37,b) := by decide +kernel +theorem edge_complete_38 : ∀ b : Fin 103, + 38 < b → SeedEncoding.indexedAdj 38 b → + edge (edgeIndex 38 b) = (38,b) := by decide +kernel +theorem edge_complete_39 : ∀ b : Fin 103, + 39 < b → SeedEncoding.indexedAdj 39 b → + edge (edgeIndex 39 b) = (39,b) := by decide +kernel +theorem edge_complete_40 : ∀ b : Fin 103, + 40 < b → SeedEncoding.indexedAdj 40 b → + edge (edgeIndex 40 b) = (40,b) := by decide +kernel +theorem edge_complete_41 : ∀ b : Fin 103, + 41 < b → SeedEncoding.indexedAdj 41 b → + edge (edgeIndex 41 b) = (41,b) := by decide +kernel +theorem edge_complete_42 : ∀ b : Fin 103, + 42 < b → SeedEncoding.indexedAdj 42 b → + edge (edgeIndex 42 b) = (42,b) := by decide +kernel +theorem edge_complete_43 : ∀ b : Fin 103, + 43 < b → SeedEncoding.indexedAdj 43 b → + edge (edgeIndex 43 b) = (43,b) := by decide +kernel +theorem edge_complete_44 : ∀ b : Fin 103, + 44 < b → SeedEncoding.indexedAdj 44 b → + edge (edgeIndex 44 b) = (44,b) := by decide +kernel +theorem edge_complete_45 : ∀ b : Fin 103, + 45 < b → SeedEncoding.indexedAdj 45 b → + edge (edgeIndex 45 b) = (45,b) := by decide +kernel +theorem edge_complete_46 : ∀ b : Fin 103, + 46 < b → SeedEncoding.indexedAdj 46 b → + edge (edgeIndex 46 b) = (46,b) := by decide +kernel +theorem edge_complete_47 : ∀ b : Fin 103, + 47 < b → SeedEncoding.indexedAdj 47 b → + edge (edgeIndex 47 b) = (47,b) := by decide +kernel +theorem edge_complete_48 : ∀ b : Fin 103, + 48 < b → SeedEncoding.indexedAdj 48 b → + edge (edgeIndex 48 b) = (48,b) := by decide +kernel +theorem edge_complete_49 : ∀ b : Fin 103, + 49 < b → SeedEncoding.indexedAdj 49 b → + edge (edgeIndex 49 b) = (49,b) := by decide +kernel +theorem edge_complete_50 : ∀ b : Fin 103, + 50 < b → SeedEncoding.indexedAdj 50 b → + edge (edgeIndex 50 b) = (50,b) := by decide +kernel +theorem edge_complete_51 : ∀ b : Fin 103, + 51 < b → SeedEncoding.indexedAdj 51 b → + edge (edgeIndex 51 b) = (51,b) := by decide +kernel +theorem edge_complete_52 : ∀ b : Fin 103, + 52 < b → SeedEncoding.indexedAdj 52 b → + edge (edgeIndex 52 b) = (52,b) := by decide +kernel +theorem edge_complete_53 : ∀ b : Fin 103, + 53 < b → SeedEncoding.indexedAdj 53 b → + edge (edgeIndex 53 b) = (53,b) := by decide +kernel +theorem edge_complete_54 : ∀ b : Fin 103, + 54 < b → SeedEncoding.indexedAdj 54 b → + edge (edgeIndex 54 b) = (54,b) := by decide +kernel +theorem edge_complete_55 : ∀ b : Fin 103, + 55 < b → SeedEncoding.indexedAdj 55 b → + edge (edgeIndex 55 b) = (55,b) := by decide +kernel +theorem edge_complete_56 : ∀ b : Fin 103, + 56 < b → SeedEncoding.indexedAdj 56 b → + edge (edgeIndex 56 b) = (56,b) := by decide +kernel +theorem edge_complete_57 : ∀ b : Fin 103, + 57 < b → SeedEncoding.indexedAdj 57 b → + edge (edgeIndex 57 b) = (57,b) := by decide +kernel +theorem edge_complete_58 : ∀ b : Fin 103, + 58 < b → SeedEncoding.indexedAdj 58 b → + edge (edgeIndex 58 b) = (58,b) := by decide +kernel +theorem edge_complete_59 : ∀ b : Fin 103, + 59 < b → SeedEncoding.indexedAdj 59 b → + edge (edgeIndex 59 b) = (59,b) := by decide +kernel +theorem edge_complete_60 : ∀ b : Fin 103, + 60 < b → SeedEncoding.indexedAdj 60 b → + edge (edgeIndex 60 b) = (60,b) := by decide +kernel +theorem edge_complete_61 : ∀ b : Fin 103, + 61 < b → SeedEncoding.indexedAdj 61 b → + edge (edgeIndex 61 b) = (61,b) := by decide +kernel +theorem edge_complete_62 : ∀ b : Fin 103, + 62 < b → SeedEncoding.indexedAdj 62 b → + edge (edgeIndex 62 b) = (62,b) := by decide +kernel +theorem edge_complete_63 : ∀ b : Fin 103, + 63 < b → SeedEncoding.indexedAdj 63 b → + edge (edgeIndex 63 b) = (63,b) := by decide +kernel +theorem edge_complete_64 : ∀ b : Fin 103, + 64 < b → SeedEncoding.indexedAdj 64 b → + edge (edgeIndex 64 b) = (64,b) := by decide +kernel +theorem edge_complete_65 : ∀ b : Fin 103, + 65 < b → SeedEncoding.indexedAdj 65 b → + edge (edgeIndex 65 b) = (65,b) := by decide +kernel +theorem edge_complete_66 : ∀ b : Fin 103, + 66 < b → SeedEncoding.indexedAdj 66 b → + edge (edgeIndex 66 b) = (66,b) := by decide +kernel +theorem edge_complete_67 : ∀ b : Fin 103, + 67 < b → SeedEncoding.indexedAdj 67 b → + edge (edgeIndex 67 b) = (67,b) := by decide +kernel +theorem edge_complete_68 : ∀ b : Fin 103, + 68 < b → SeedEncoding.indexedAdj 68 b → + edge (edgeIndex 68 b) = (68,b) := by decide +kernel +theorem edge_complete_69 : ∀ b : Fin 103, + 69 < b → SeedEncoding.indexedAdj 69 b → + edge (edgeIndex 69 b) = (69,b) := by decide +kernel +theorem edge_complete_70 : ∀ b : Fin 103, + 70 < b → SeedEncoding.indexedAdj 70 b → + edge (edgeIndex 70 b) = (70,b) := by decide +kernel +theorem edge_complete_71 : ∀ b : Fin 103, + 71 < b → SeedEncoding.indexedAdj 71 b → + edge (edgeIndex 71 b) = (71,b) := by decide +kernel +theorem edge_complete_72 : ∀ b : Fin 103, + 72 < b → SeedEncoding.indexedAdj 72 b → + edge (edgeIndex 72 b) = (72,b) := by decide +kernel +theorem edge_complete_73 : ∀ b : Fin 103, + 73 < b → SeedEncoding.indexedAdj 73 b → + edge (edgeIndex 73 b) = (73,b) := by decide +kernel +theorem edge_complete_74 : ∀ b : Fin 103, + 74 < b → SeedEncoding.indexedAdj 74 b → + edge (edgeIndex 74 b) = (74,b) := by decide +kernel +theorem edge_complete_75 : ∀ b : Fin 103, + 75 < b → SeedEncoding.indexedAdj 75 b → + edge (edgeIndex 75 b) = (75,b) := by decide +kernel +theorem edge_complete_76 : ∀ b : Fin 103, + 76 < b → SeedEncoding.indexedAdj 76 b → + edge (edgeIndex 76 b) = (76,b) := by decide +kernel +theorem edge_complete_77 : ∀ b : Fin 103, + 77 < b → SeedEncoding.indexedAdj 77 b → + edge (edgeIndex 77 b) = (77,b) := by decide +kernel +theorem edge_complete_78 : ∀ b : Fin 103, + 78 < b → SeedEncoding.indexedAdj 78 b → + edge (edgeIndex 78 b) = (78,b) := by decide +kernel +theorem edge_complete_79 : ∀ b : Fin 103, + 79 < b → SeedEncoding.indexedAdj 79 b → + edge (edgeIndex 79 b) = (79,b) := by decide +kernel +theorem edge_complete_80 : ∀ b : Fin 103, + 80 < b → SeedEncoding.indexedAdj 80 b → + edge (edgeIndex 80 b) = (80,b) := by decide +kernel +theorem edge_complete_81 : ∀ b : Fin 103, + 81 < b → SeedEncoding.indexedAdj 81 b → + edge (edgeIndex 81 b) = (81,b) := by decide +kernel +theorem edge_complete_82 : ∀ b : Fin 103, + 82 < b → SeedEncoding.indexedAdj 82 b → + edge (edgeIndex 82 b) = (82,b) := by decide +kernel +theorem edge_complete_83 : ∀ b : Fin 103, + 83 < b → SeedEncoding.indexedAdj 83 b → + edge (edgeIndex 83 b) = (83,b) := by decide +kernel +theorem edge_complete_84 : ∀ b : Fin 103, + 84 < b → SeedEncoding.indexedAdj 84 b → + edge (edgeIndex 84 b) = (84,b) := by decide +kernel +theorem edge_complete_85 : ∀ b : Fin 103, + 85 < b → SeedEncoding.indexedAdj 85 b → + edge (edgeIndex 85 b) = (85,b) := by decide +kernel +theorem edge_complete_86 : ∀ b : Fin 103, + 86 < b → SeedEncoding.indexedAdj 86 b → + edge (edgeIndex 86 b) = (86,b) := by decide +kernel +theorem edge_complete_87 : ∀ b : Fin 103, + 87 < b → SeedEncoding.indexedAdj 87 b → + edge (edgeIndex 87 b) = (87,b) := by decide +kernel +theorem edge_complete_88 : ∀ b : Fin 103, + 88 < b → SeedEncoding.indexedAdj 88 b → + edge (edgeIndex 88 b) = (88,b) := by decide +kernel +theorem edge_complete_89 : ∀ b : Fin 103, + 89 < b → SeedEncoding.indexedAdj 89 b → + edge (edgeIndex 89 b) = (89,b) := by decide +kernel +theorem edge_complete_90 : ∀ b : Fin 103, + 90 < b → SeedEncoding.indexedAdj 90 b → + edge (edgeIndex 90 b) = (90,b) := by decide +kernel +theorem edge_complete_91 : ∀ b : Fin 103, + 91 < b → SeedEncoding.indexedAdj 91 b → + edge (edgeIndex 91 b) = (91,b) := by decide +kernel +theorem edge_complete_92 : ∀ b : Fin 103, + 92 < b → SeedEncoding.indexedAdj 92 b → + edge (edgeIndex 92 b) = (92,b) := by decide +kernel +theorem edge_complete_93 : ∀ b : Fin 103, + 93 < b → SeedEncoding.indexedAdj 93 b → + edge (edgeIndex 93 b) = (93,b) := by decide +kernel +theorem edge_complete_94 : ∀ b : Fin 103, + 94 < b → SeedEncoding.indexedAdj 94 b → + edge (edgeIndex 94 b) = (94,b) := by decide +kernel +theorem edge_complete_95 : ∀ b : Fin 103, + 95 < b → SeedEncoding.indexedAdj 95 b → + edge (edgeIndex 95 b) = (95,b) := by decide +kernel +theorem edge_complete_96 : ∀ b : Fin 103, + 96 < b → SeedEncoding.indexedAdj 96 b → + edge (edgeIndex 96 b) = (96,b) := by decide +kernel +theorem edge_complete_97 : ∀ b : Fin 103, + 97 < b → SeedEncoding.indexedAdj 97 b → + edge (edgeIndex 97 b) = (97,b) := by decide +kernel +theorem edge_complete_98 : ∀ b : Fin 103, + 98 < b → SeedEncoding.indexedAdj 98 b → + edge (edgeIndex 98 b) = (98,b) := by decide +kernel +theorem edge_complete_99 : ∀ b : Fin 103, + 99 < b → SeedEncoding.indexedAdj 99 b → + edge (edgeIndex 99 b) = (99,b) := by decide +kernel +theorem edge_complete_100 : ∀ b : Fin 103, + 100 < b → SeedEncoding.indexedAdj 100 b → + edge (edgeIndex 100 b) = (100,b) := by decide +kernel +theorem edge_complete_101 : ∀ b : Fin 103, + 101 < b → SeedEncoding.indexedAdj 101 b → + edge (edgeIndex 101 b) = (101,b) := by decide +kernel +theorem edge_complete_102 : ∀ b : Fin 103, + 102 < b → SeedEncoding.indexedAdj 102 b → + edge (edgeIndex 102 b) = (102,b) := by decide +kernel +theorem triangle_complete_0 : ∀ c : Fin 103, + (edge 0).2 < c → SeedEncoding.indexedAdj (edge 0).1 c → + SeedEncoding.indexedAdj (edge 0).2 c → + triangle (triangleIndex 0 c) = ((edge 0).1,(edge 0).2,c) := by decide +kernel +theorem triangle_complete_1 : ∀ c : Fin 103, + (edge 1).2 < c → SeedEncoding.indexedAdj (edge 1).1 c → + SeedEncoding.indexedAdj (edge 1).2 c → + triangle (triangleIndex 1 c) = ((edge 1).1,(edge 1).2,c) := by decide +kernel +theorem triangle_complete_2 : ∀ c : Fin 103, + (edge 2).2 < c → SeedEncoding.indexedAdj (edge 2).1 c → + SeedEncoding.indexedAdj (edge 2).2 c → + triangle (triangleIndex 2 c) = ((edge 2).1,(edge 2).2,c) := by decide +kernel +theorem triangle_complete_3 : ∀ c : Fin 103, + (edge 3).2 < c → SeedEncoding.indexedAdj (edge 3).1 c → + SeedEncoding.indexedAdj (edge 3).2 c → + triangle (triangleIndex 3 c) = ((edge 3).1,(edge 3).2,c) := by decide +kernel +theorem triangle_complete_4 : ∀ c : Fin 103, + (edge 4).2 < c → SeedEncoding.indexedAdj (edge 4).1 c → + SeedEncoding.indexedAdj (edge 4).2 c → + triangle (triangleIndex 4 c) = ((edge 4).1,(edge 4).2,c) := by decide +kernel +theorem triangle_complete_5 : ∀ c : Fin 103, + (edge 5).2 < c → SeedEncoding.indexedAdj (edge 5).1 c → + SeedEncoding.indexedAdj (edge 5).2 c → + triangle (triangleIndex 5 c) = ((edge 5).1,(edge 5).2,c) := by decide +kernel +theorem triangle_complete_6 : ∀ c : Fin 103, + (edge 6).2 < c → SeedEncoding.indexedAdj (edge 6).1 c → + SeedEncoding.indexedAdj (edge 6).2 c → + triangle (triangleIndex 6 c) = ((edge 6).1,(edge 6).2,c) := by decide +kernel +theorem triangle_complete_7 : ∀ c : Fin 103, + (edge 7).2 < c → SeedEncoding.indexedAdj (edge 7).1 c → + SeedEncoding.indexedAdj (edge 7).2 c → + triangle (triangleIndex 7 c) = ((edge 7).1,(edge 7).2,c) := by decide +kernel +theorem triangle_complete_8 : ∀ c : Fin 103, + (edge 8).2 < c → SeedEncoding.indexedAdj (edge 8).1 c → + SeedEncoding.indexedAdj (edge 8).2 c → + triangle (triangleIndex 8 c) = ((edge 8).1,(edge 8).2,c) := by decide +kernel +theorem triangle_complete_9 : ∀ c : Fin 103, + (edge 9).2 < c → SeedEncoding.indexedAdj (edge 9).1 c → + SeedEncoding.indexedAdj (edge 9).2 c → + triangle (triangleIndex 9 c) = ((edge 9).1,(edge 9).2,c) := by decide +kernel +theorem triangle_complete_10 : ∀ c : Fin 103, + (edge 10).2 < c → SeedEncoding.indexedAdj (edge 10).1 c → + SeedEncoding.indexedAdj (edge 10).2 c → + triangle (triangleIndex 10 c) = ((edge 10).1,(edge 10).2,c) := by decide +kernel +theorem triangle_complete_11 : ∀ c : Fin 103, + (edge 11).2 < c → SeedEncoding.indexedAdj (edge 11).1 c → + SeedEncoding.indexedAdj (edge 11).2 c → + triangle (triangleIndex 11 c) = ((edge 11).1,(edge 11).2,c) := by decide +kernel +theorem triangle_complete_12 : ∀ c : Fin 103, + (edge 12).2 < c → SeedEncoding.indexedAdj (edge 12).1 c → + SeedEncoding.indexedAdj (edge 12).2 c → + triangle (triangleIndex 12 c) = ((edge 12).1,(edge 12).2,c) := by decide +kernel +theorem triangle_complete_13 : ∀ c : Fin 103, + (edge 13).2 < c → SeedEncoding.indexedAdj (edge 13).1 c → + SeedEncoding.indexedAdj (edge 13).2 c → + triangle (triangleIndex 13 c) = ((edge 13).1,(edge 13).2,c) := by decide +kernel +theorem triangle_complete_14 : ∀ c : Fin 103, + (edge 14).2 < c → SeedEncoding.indexedAdj (edge 14).1 c → + SeedEncoding.indexedAdj (edge 14).2 c → + triangle (triangleIndex 14 c) = ((edge 14).1,(edge 14).2,c) := by decide +kernel +theorem triangle_complete_15 : ∀ c : Fin 103, + (edge 15).2 < c → SeedEncoding.indexedAdj (edge 15).1 c → + SeedEncoding.indexedAdj (edge 15).2 c → + triangle (triangleIndex 15 c) = ((edge 15).1,(edge 15).2,c) := by decide +kernel +theorem triangle_complete_16 : ∀ c : Fin 103, + (edge 16).2 < c → SeedEncoding.indexedAdj (edge 16).1 c → + SeedEncoding.indexedAdj (edge 16).2 c → + triangle (triangleIndex 16 c) = ((edge 16).1,(edge 16).2,c) := by decide +kernel +theorem triangle_complete_17 : ∀ c : Fin 103, + (edge 17).2 < c → SeedEncoding.indexedAdj (edge 17).1 c → + SeedEncoding.indexedAdj (edge 17).2 c → + triangle (triangleIndex 17 c) = ((edge 17).1,(edge 17).2,c) := by decide +kernel +theorem triangle_complete_18 : ∀ c : Fin 103, + (edge 18).2 < c → SeedEncoding.indexedAdj (edge 18).1 c → + SeedEncoding.indexedAdj (edge 18).2 c → + triangle (triangleIndex 18 c) = ((edge 18).1,(edge 18).2,c) := by decide +kernel +theorem triangle_complete_19 : ∀ c : Fin 103, + (edge 19).2 < c → SeedEncoding.indexedAdj (edge 19).1 c → + SeedEncoding.indexedAdj (edge 19).2 c → + triangle (triangleIndex 19 c) = ((edge 19).1,(edge 19).2,c) := by decide +kernel +theorem triangle_complete_20 : ∀ c : Fin 103, + (edge 20).2 < c → SeedEncoding.indexedAdj (edge 20).1 c → + SeedEncoding.indexedAdj (edge 20).2 c → + triangle (triangleIndex 20 c) = ((edge 20).1,(edge 20).2,c) := by decide +kernel +theorem triangle_complete_21 : ∀ c : Fin 103, + (edge 21).2 < c → SeedEncoding.indexedAdj (edge 21).1 c → + SeedEncoding.indexedAdj (edge 21).2 c → + triangle (triangleIndex 21 c) = ((edge 21).1,(edge 21).2,c) := by decide +kernel +theorem triangle_complete_22 : ∀ c : Fin 103, + (edge 22).2 < c → SeedEncoding.indexedAdj (edge 22).1 c → + SeedEncoding.indexedAdj (edge 22).2 c → + triangle (triangleIndex 22 c) = ((edge 22).1,(edge 22).2,c) := by decide +kernel +theorem triangle_complete_23 : ∀ c : Fin 103, + (edge 23).2 < c → SeedEncoding.indexedAdj (edge 23).1 c → + SeedEncoding.indexedAdj (edge 23).2 c → + triangle (triangleIndex 23 c) = ((edge 23).1,(edge 23).2,c) := by decide +kernel +theorem triangle_complete_24 : ∀ c : Fin 103, + (edge 24).2 < c → SeedEncoding.indexedAdj (edge 24).1 c → + SeedEncoding.indexedAdj (edge 24).2 c → + triangle (triangleIndex 24 c) = ((edge 24).1,(edge 24).2,c) := by decide +kernel +theorem triangle_complete_25 : ∀ c : Fin 103, + (edge 25).2 < c → SeedEncoding.indexedAdj (edge 25).1 c → + SeedEncoding.indexedAdj (edge 25).2 c → + triangle (triangleIndex 25 c) = ((edge 25).1,(edge 25).2,c) := by decide +kernel +theorem triangle_complete_26 : ∀ c : Fin 103, + (edge 26).2 < c → SeedEncoding.indexedAdj (edge 26).1 c → + SeedEncoding.indexedAdj (edge 26).2 c → + triangle (triangleIndex 26 c) = ((edge 26).1,(edge 26).2,c) := by decide +kernel +theorem triangle_complete_27 : ∀ c : Fin 103, + (edge 27).2 < c → SeedEncoding.indexedAdj (edge 27).1 c → + SeedEncoding.indexedAdj (edge 27).2 c → + triangle (triangleIndex 27 c) = ((edge 27).1,(edge 27).2,c) := by decide +kernel +theorem triangle_complete_28 : ∀ c : Fin 103, + (edge 28).2 < c → SeedEncoding.indexedAdj (edge 28).1 c → + SeedEncoding.indexedAdj (edge 28).2 c → + triangle (triangleIndex 28 c) = ((edge 28).1,(edge 28).2,c) := by decide +kernel +theorem triangle_complete_29 : ∀ c : Fin 103, + (edge 29).2 < c → SeedEncoding.indexedAdj (edge 29).1 c → + SeedEncoding.indexedAdj (edge 29).2 c → + triangle (triangleIndex 29 c) = ((edge 29).1,(edge 29).2,c) := by decide +kernel +theorem triangle_complete_30 : ∀ c : Fin 103, + (edge 30).2 < c → SeedEncoding.indexedAdj (edge 30).1 c → + SeedEncoding.indexedAdj (edge 30).2 c → + triangle (triangleIndex 30 c) = ((edge 30).1,(edge 30).2,c) := by decide +kernel +theorem triangle_complete_31 : ∀ c : Fin 103, + (edge 31).2 < c → SeedEncoding.indexedAdj (edge 31).1 c → + SeedEncoding.indexedAdj (edge 31).2 c → + triangle (triangleIndex 31 c) = ((edge 31).1,(edge 31).2,c) := by decide +kernel +theorem triangle_complete_32 : ∀ c : Fin 103, + (edge 32).2 < c → SeedEncoding.indexedAdj (edge 32).1 c → + SeedEncoding.indexedAdj (edge 32).2 c → + triangle (triangleIndex 32 c) = ((edge 32).1,(edge 32).2,c) := by decide +kernel +theorem triangle_complete_33 : ∀ c : Fin 103, + (edge 33).2 < c → SeedEncoding.indexedAdj (edge 33).1 c → + SeedEncoding.indexedAdj (edge 33).2 c → + triangle (triangleIndex 33 c) = ((edge 33).1,(edge 33).2,c) := by decide +kernel +theorem triangle_complete_34 : ∀ c : Fin 103, + (edge 34).2 < c → SeedEncoding.indexedAdj (edge 34).1 c → + SeedEncoding.indexedAdj (edge 34).2 c → + triangle (triangleIndex 34 c) = ((edge 34).1,(edge 34).2,c) := by decide +kernel +theorem triangle_complete_35 : ∀ c : Fin 103, + (edge 35).2 < c → SeedEncoding.indexedAdj (edge 35).1 c → + SeedEncoding.indexedAdj (edge 35).2 c → + triangle (triangleIndex 35 c) = ((edge 35).1,(edge 35).2,c) := by decide +kernel +theorem triangle_complete_36 : ∀ c : Fin 103, + (edge 36).2 < c → SeedEncoding.indexedAdj (edge 36).1 c → + SeedEncoding.indexedAdj (edge 36).2 c → + triangle (triangleIndex 36 c) = ((edge 36).1,(edge 36).2,c) := by decide +kernel +theorem triangle_complete_37 : ∀ c : Fin 103, + (edge 37).2 < c → SeedEncoding.indexedAdj (edge 37).1 c → + SeedEncoding.indexedAdj (edge 37).2 c → + triangle (triangleIndex 37 c) = ((edge 37).1,(edge 37).2,c) := by decide +kernel +theorem triangle_complete_38 : ∀ c : Fin 103, + (edge 38).2 < c → SeedEncoding.indexedAdj (edge 38).1 c → + SeedEncoding.indexedAdj (edge 38).2 c → + triangle (triangleIndex 38 c) = ((edge 38).1,(edge 38).2,c) := by decide +kernel +theorem triangle_complete_39 : ∀ c : Fin 103, + (edge 39).2 < c → SeedEncoding.indexedAdj (edge 39).1 c → + SeedEncoding.indexedAdj (edge 39).2 c → + triangle (triangleIndex 39 c) = ((edge 39).1,(edge 39).2,c) := by decide +kernel +theorem triangle_complete_40 : ∀ c : Fin 103, + (edge 40).2 < c → SeedEncoding.indexedAdj (edge 40).1 c → + SeedEncoding.indexedAdj (edge 40).2 c → + triangle (triangleIndex 40 c) = ((edge 40).1,(edge 40).2,c) := by decide +kernel +theorem triangle_complete_41 : ∀ c : Fin 103, + (edge 41).2 < c → SeedEncoding.indexedAdj (edge 41).1 c → + SeedEncoding.indexedAdj (edge 41).2 c → + triangle (triangleIndex 41 c) = ((edge 41).1,(edge 41).2,c) := by decide +kernel +theorem triangle_complete_42 : ∀ c : Fin 103, + (edge 42).2 < c → SeedEncoding.indexedAdj (edge 42).1 c → + SeedEncoding.indexedAdj (edge 42).2 c → + triangle (triangleIndex 42 c) = ((edge 42).1,(edge 42).2,c) := by decide +kernel +theorem triangle_complete_43 : ∀ c : Fin 103, + (edge 43).2 < c → SeedEncoding.indexedAdj (edge 43).1 c → + SeedEncoding.indexedAdj (edge 43).2 c → + triangle (triangleIndex 43 c) = ((edge 43).1,(edge 43).2,c) := by decide +kernel +theorem triangle_complete_44 : ∀ c : Fin 103, + (edge 44).2 < c → SeedEncoding.indexedAdj (edge 44).1 c → + SeedEncoding.indexedAdj (edge 44).2 c → + triangle (triangleIndex 44 c) = ((edge 44).1,(edge 44).2,c) := by decide +kernel +theorem triangle_complete_45 : ∀ c : Fin 103, + (edge 45).2 < c → SeedEncoding.indexedAdj (edge 45).1 c → + SeedEncoding.indexedAdj (edge 45).2 c → + triangle (triangleIndex 45 c) = ((edge 45).1,(edge 45).2,c) := by decide +kernel +theorem triangle_complete_46 : ∀ c : Fin 103, + (edge 46).2 < c → SeedEncoding.indexedAdj (edge 46).1 c → + SeedEncoding.indexedAdj (edge 46).2 c → + triangle (triangleIndex 46 c) = ((edge 46).1,(edge 46).2,c) := by decide +kernel +theorem triangle_complete_47 : ∀ c : Fin 103, + (edge 47).2 < c → SeedEncoding.indexedAdj (edge 47).1 c → + SeedEncoding.indexedAdj (edge 47).2 c → + triangle (triangleIndex 47 c) = ((edge 47).1,(edge 47).2,c) := by decide +kernel +theorem triangle_complete_48 : ∀ c : Fin 103, + (edge 48).2 < c → SeedEncoding.indexedAdj (edge 48).1 c → + SeedEncoding.indexedAdj (edge 48).2 c → + triangle (triangleIndex 48 c) = ((edge 48).1,(edge 48).2,c) := by decide +kernel +theorem triangle_complete_49 : ∀ c : Fin 103, + (edge 49).2 < c → SeedEncoding.indexedAdj (edge 49).1 c → + SeedEncoding.indexedAdj (edge 49).2 c → + triangle (triangleIndex 49 c) = ((edge 49).1,(edge 49).2,c) := by decide +kernel +theorem triangle_complete_50 : ∀ c : Fin 103, + (edge 50).2 < c → SeedEncoding.indexedAdj (edge 50).1 c → + SeedEncoding.indexedAdj (edge 50).2 c → + triangle (triangleIndex 50 c) = ((edge 50).1,(edge 50).2,c) := by decide +kernel +theorem triangle_complete_51 : ∀ c : Fin 103, + (edge 51).2 < c → SeedEncoding.indexedAdj (edge 51).1 c → + SeedEncoding.indexedAdj (edge 51).2 c → + triangle (triangleIndex 51 c) = ((edge 51).1,(edge 51).2,c) := by decide +kernel +theorem triangle_complete_52 : ∀ c : Fin 103, + (edge 52).2 < c → SeedEncoding.indexedAdj (edge 52).1 c → + SeedEncoding.indexedAdj (edge 52).2 c → + triangle (triangleIndex 52 c) = ((edge 52).1,(edge 52).2,c) := by decide +kernel +theorem triangle_complete_53 : ∀ c : Fin 103, + (edge 53).2 < c → SeedEncoding.indexedAdj (edge 53).1 c → + SeedEncoding.indexedAdj (edge 53).2 c → + triangle (triangleIndex 53 c) = ((edge 53).1,(edge 53).2,c) := by decide +kernel +theorem triangle_complete_54 : ∀ c : Fin 103, + (edge 54).2 < c → SeedEncoding.indexedAdj (edge 54).1 c → + SeedEncoding.indexedAdj (edge 54).2 c → + triangle (triangleIndex 54 c) = ((edge 54).1,(edge 54).2,c) := by decide +kernel +theorem triangle_complete_55 : ∀ c : Fin 103, + (edge 55).2 < c → SeedEncoding.indexedAdj (edge 55).1 c → + SeedEncoding.indexedAdj (edge 55).2 c → + triangle (triangleIndex 55 c) = ((edge 55).1,(edge 55).2,c) := by decide +kernel +theorem triangle_complete_56 : ∀ c : Fin 103, + (edge 56).2 < c → SeedEncoding.indexedAdj (edge 56).1 c → + SeedEncoding.indexedAdj (edge 56).2 c → + triangle (triangleIndex 56 c) = ((edge 56).1,(edge 56).2,c) := by decide +kernel +theorem triangle_complete_57 : ∀ c : Fin 103, + (edge 57).2 < c → SeedEncoding.indexedAdj (edge 57).1 c → + SeedEncoding.indexedAdj (edge 57).2 c → + triangle (triangleIndex 57 c) = ((edge 57).1,(edge 57).2,c) := by decide +kernel +theorem triangle_complete_58 : ∀ c : Fin 103, + (edge 58).2 < c → SeedEncoding.indexedAdj (edge 58).1 c → + SeedEncoding.indexedAdj (edge 58).2 c → + triangle (triangleIndex 58 c) = ((edge 58).1,(edge 58).2,c) := by decide +kernel +theorem triangle_complete_59 : ∀ c : Fin 103, + (edge 59).2 < c → SeedEncoding.indexedAdj (edge 59).1 c → + SeedEncoding.indexedAdj (edge 59).2 c → + triangle (triangleIndex 59 c) = ((edge 59).1,(edge 59).2,c) := by decide +kernel +theorem triangle_complete_60 : ∀ c : Fin 103, + (edge 60).2 < c → SeedEncoding.indexedAdj (edge 60).1 c → + SeedEncoding.indexedAdj (edge 60).2 c → + triangle (triangleIndex 60 c) = ((edge 60).1,(edge 60).2,c) := by decide +kernel +theorem triangle_complete_61 : ∀ c : Fin 103, + (edge 61).2 < c → SeedEncoding.indexedAdj (edge 61).1 c → + SeedEncoding.indexedAdj (edge 61).2 c → + triangle (triangleIndex 61 c) = ((edge 61).1,(edge 61).2,c) := by decide +kernel +theorem triangle_complete_62 : ∀ c : Fin 103, + (edge 62).2 < c → SeedEncoding.indexedAdj (edge 62).1 c → + SeedEncoding.indexedAdj (edge 62).2 c → + triangle (triangleIndex 62 c) = ((edge 62).1,(edge 62).2,c) := by decide +kernel +theorem triangle_complete_63 : ∀ c : Fin 103, + (edge 63).2 < c → SeedEncoding.indexedAdj (edge 63).1 c → + SeedEncoding.indexedAdj (edge 63).2 c → + triangle (triangleIndex 63 c) = ((edge 63).1,(edge 63).2,c) := by decide +kernel +theorem triangle_complete_64 : ∀ c : Fin 103, + (edge 64).2 < c → SeedEncoding.indexedAdj (edge 64).1 c → + SeedEncoding.indexedAdj (edge 64).2 c → + triangle (triangleIndex 64 c) = ((edge 64).1,(edge 64).2,c) := by decide +kernel +theorem triangle_complete_65 : ∀ c : Fin 103, + (edge 65).2 < c → SeedEncoding.indexedAdj (edge 65).1 c → + SeedEncoding.indexedAdj (edge 65).2 c → + triangle (triangleIndex 65 c) = ((edge 65).1,(edge 65).2,c) := by decide +kernel +theorem triangle_complete_66 : ∀ c : Fin 103, + (edge 66).2 < c → SeedEncoding.indexedAdj (edge 66).1 c → + SeedEncoding.indexedAdj (edge 66).2 c → + triangle (triangleIndex 66 c) = ((edge 66).1,(edge 66).2,c) := by decide +kernel +theorem triangle_complete_67 : ∀ c : Fin 103, + (edge 67).2 < c → SeedEncoding.indexedAdj (edge 67).1 c → + SeedEncoding.indexedAdj (edge 67).2 c → + triangle (triangleIndex 67 c) = ((edge 67).1,(edge 67).2,c) := by decide +kernel +theorem triangle_complete_68 : ∀ c : Fin 103, + (edge 68).2 < c → SeedEncoding.indexedAdj (edge 68).1 c → + SeedEncoding.indexedAdj (edge 68).2 c → + triangle (triangleIndex 68 c) = ((edge 68).1,(edge 68).2,c) := by decide +kernel +theorem triangle_complete_69 : ∀ c : Fin 103, + (edge 69).2 < c → SeedEncoding.indexedAdj (edge 69).1 c → + SeedEncoding.indexedAdj (edge 69).2 c → + triangle (triangleIndex 69 c) = ((edge 69).1,(edge 69).2,c) := by decide +kernel +theorem triangle_complete_70 : ∀ c : Fin 103, + (edge 70).2 < c → SeedEncoding.indexedAdj (edge 70).1 c → + SeedEncoding.indexedAdj (edge 70).2 c → + triangle (triangleIndex 70 c) = ((edge 70).1,(edge 70).2,c) := by decide +kernel +theorem triangle_complete_71 : ∀ c : Fin 103, + (edge 71).2 < c → SeedEncoding.indexedAdj (edge 71).1 c → + SeedEncoding.indexedAdj (edge 71).2 c → + triangle (triangleIndex 71 c) = ((edge 71).1,(edge 71).2,c) := by decide +kernel +theorem triangle_complete_72 : ∀ c : Fin 103, + (edge 72).2 < c → SeedEncoding.indexedAdj (edge 72).1 c → + SeedEncoding.indexedAdj (edge 72).2 c → + triangle (triangleIndex 72 c) = ((edge 72).1,(edge 72).2,c) := by decide +kernel +theorem triangle_complete_73 : ∀ c : Fin 103, + (edge 73).2 < c → SeedEncoding.indexedAdj (edge 73).1 c → + SeedEncoding.indexedAdj (edge 73).2 c → + triangle (triangleIndex 73 c) = ((edge 73).1,(edge 73).2,c) := by decide +kernel +theorem triangle_complete_74 : ∀ c : Fin 103, + (edge 74).2 < c → SeedEncoding.indexedAdj (edge 74).1 c → + SeedEncoding.indexedAdj (edge 74).2 c → + triangle (triangleIndex 74 c) = ((edge 74).1,(edge 74).2,c) := by decide +kernel +theorem triangle_complete_75 : ∀ c : Fin 103, + (edge 75).2 < c → SeedEncoding.indexedAdj (edge 75).1 c → + SeedEncoding.indexedAdj (edge 75).2 c → + triangle (triangleIndex 75 c) = ((edge 75).1,(edge 75).2,c) := by decide +kernel +theorem triangle_complete_76 : ∀ c : Fin 103, + (edge 76).2 < c → SeedEncoding.indexedAdj (edge 76).1 c → + SeedEncoding.indexedAdj (edge 76).2 c → + triangle (triangleIndex 76 c) = ((edge 76).1,(edge 76).2,c) := by decide +kernel +theorem triangle_complete_77 : ∀ c : Fin 103, + (edge 77).2 < c → SeedEncoding.indexedAdj (edge 77).1 c → + SeedEncoding.indexedAdj (edge 77).2 c → + triangle (triangleIndex 77 c) = ((edge 77).1,(edge 77).2,c) := by decide +kernel +theorem triangle_complete_78 : ∀ c : Fin 103, + (edge 78).2 < c → SeedEncoding.indexedAdj (edge 78).1 c → + SeedEncoding.indexedAdj (edge 78).2 c → + triangle (triangleIndex 78 c) = ((edge 78).1,(edge 78).2,c) := by decide +kernel +theorem triangle_complete_79 : ∀ c : Fin 103, + (edge 79).2 < c → SeedEncoding.indexedAdj (edge 79).1 c → + SeedEncoding.indexedAdj (edge 79).2 c → + triangle (triangleIndex 79 c) = ((edge 79).1,(edge 79).2,c) := by decide +kernel +theorem triangle_complete_80 : ∀ c : Fin 103, + (edge 80).2 < c → SeedEncoding.indexedAdj (edge 80).1 c → + SeedEncoding.indexedAdj (edge 80).2 c → + triangle (triangleIndex 80 c) = ((edge 80).1,(edge 80).2,c) := by decide +kernel +theorem triangle_complete_81 : ∀ c : Fin 103, + (edge 81).2 < c → SeedEncoding.indexedAdj (edge 81).1 c → + SeedEncoding.indexedAdj (edge 81).2 c → + triangle (triangleIndex 81 c) = ((edge 81).1,(edge 81).2,c) := by decide +kernel +theorem triangle_complete_82 : ∀ c : Fin 103, + (edge 82).2 < c → SeedEncoding.indexedAdj (edge 82).1 c → + SeedEncoding.indexedAdj (edge 82).2 c → + triangle (triangleIndex 82 c) = ((edge 82).1,(edge 82).2,c) := by decide +kernel +theorem triangle_complete_83 : ∀ c : Fin 103, + (edge 83).2 < c → SeedEncoding.indexedAdj (edge 83).1 c → + SeedEncoding.indexedAdj (edge 83).2 c → + triangle (triangleIndex 83 c) = ((edge 83).1,(edge 83).2,c) := by decide +kernel +theorem triangle_complete_84 : ∀ c : Fin 103, + (edge 84).2 < c → SeedEncoding.indexedAdj (edge 84).1 c → + SeedEncoding.indexedAdj (edge 84).2 c → + triangle (triangleIndex 84 c) = ((edge 84).1,(edge 84).2,c) := by decide +kernel +theorem triangle_complete_85 : ∀ c : Fin 103, + (edge 85).2 < c → SeedEncoding.indexedAdj (edge 85).1 c → + SeedEncoding.indexedAdj (edge 85).2 c → + triangle (triangleIndex 85 c) = ((edge 85).1,(edge 85).2,c) := by decide +kernel +theorem triangle_complete_86 : ∀ c : Fin 103, + (edge 86).2 < c → SeedEncoding.indexedAdj (edge 86).1 c → + SeedEncoding.indexedAdj (edge 86).2 c → + triangle (triangleIndex 86 c) = ((edge 86).1,(edge 86).2,c) := by decide +kernel +theorem triangle_complete_87 : ∀ c : Fin 103, + (edge 87).2 < c → SeedEncoding.indexedAdj (edge 87).1 c → + SeedEncoding.indexedAdj (edge 87).2 c → + triangle (triangleIndex 87 c) = ((edge 87).1,(edge 87).2,c) := by decide +kernel +theorem triangle_complete_88 : ∀ c : Fin 103, + (edge 88).2 < c → SeedEncoding.indexedAdj (edge 88).1 c → + SeedEncoding.indexedAdj (edge 88).2 c → + triangle (triangleIndex 88 c) = ((edge 88).1,(edge 88).2,c) := by decide +kernel +theorem triangle_complete_89 : ∀ c : Fin 103, + (edge 89).2 < c → SeedEncoding.indexedAdj (edge 89).1 c → + SeedEncoding.indexedAdj (edge 89).2 c → + triangle (triangleIndex 89 c) = ((edge 89).1,(edge 89).2,c) := by decide +kernel +theorem triangle_complete_90 : ∀ c : Fin 103, + (edge 90).2 < c → SeedEncoding.indexedAdj (edge 90).1 c → + SeedEncoding.indexedAdj (edge 90).2 c → + triangle (triangleIndex 90 c) = ((edge 90).1,(edge 90).2,c) := by decide +kernel +theorem triangle_complete_91 : ∀ c : Fin 103, + (edge 91).2 < c → SeedEncoding.indexedAdj (edge 91).1 c → + SeedEncoding.indexedAdj (edge 91).2 c → + triangle (triangleIndex 91 c) = ((edge 91).1,(edge 91).2,c) := by decide +kernel +theorem triangle_complete_92 : ∀ c : Fin 103, + (edge 92).2 < c → SeedEncoding.indexedAdj (edge 92).1 c → + SeedEncoding.indexedAdj (edge 92).2 c → + triangle (triangleIndex 92 c) = ((edge 92).1,(edge 92).2,c) := by decide +kernel +theorem triangle_complete_93 : ∀ c : Fin 103, + (edge 93).2 < c → SeedEncoding.indexedAdj (edge 93).1 c → + SeedEncoding.indexedAdj (edge 93).2 c → + triangle (triangleIndex 93 c) = ((edge 93).1,(edge 93).2,c) := by decide +kernel +theorem triangle_complete_94 : ∀ c : Fin 103, + (edge 94).2 < c → SeedEncoding.indexedAdj (edge 94).1 c → + SeedEncoding.indexedAdj (edge 94).2 c → + triangle (triangleIndex 94 c) = ((edge 94).1,(edge 94).2,c) := by decide +kernel +theorem triangle_complete_95 : ∀ c : Fin 103, + (edge 95).2 < c → SeedEncoding.indexedAdj (edge 95).1 c → + SeedEncoding.indexedAdj (edge 95).2 c → + triangle (triangleIndex 95 c) = ((edge 95).1,(edge 95).2,c) := by decide +kernel +theorem triangle_complete_96 : ∀ c : Fin 103, + (edge 96).2 < c → SeedEncoding.indexedAdj (edge 96).1 c → + SeedEncoding.indexedAdj (edge 96).2 c → + triangle (triangleIndex 96 c) = ((edge 96).1,(edge 96).2,c) := by decide +kernel +theorem triangle_complete_97 : ∀ c : Fin 103, + (edge 97).2 < c → SeedEncoding.indexedAdj (edge 97).1 c → + SeedEncoding.indexedAdj (edge 97).2 c → + triangle (triangleIndex 97 c) = ((edge 97).1,(edge 97).2,c) := by decide +kernel +theorem triangle_complete_98 : ∀ c : Fin 103, + (edge 98).2 < c → SeedEncoding.indexedAdj (edge 98).1 c → + SeedEncoding.indexedAdj (edge 98).2 c → + triangle (triangleIndex 98 c) = ((edge 98).1,(edge 98).2,c) := by decide +kernel +theorem triangle_complete_99 : ∀ c : Fin 103, + (edge 99).2 < c → SeedEncoding.indexedAdj (edge 99).1 c → + SeedEncoding.indexedAdj (edge 99).2 c → + triangle (triangleIndex 99 c) = ((edge 99).1,(edge 99).2,c) := by decide +kernel +theorem triangle_complete_100 : ∀ c : Fin 103, + (edge 100).2 < c → SeedEncoding.indexedAdj (edge 100).1 c → + SeedEncoding.indexedAdj (edge 100).2 c → + triangle (triangleIndex 100 c) = ((edge 100).1,(edge 100).2,c) := by decide +kernel +theorem triangle_complete_101 : ∀ c : Fin 103, + (edge 101).2 < c → SeedEncoding.indexedAdj (edge 101).1 c → + SeedEncoding.indexedAdj (edge 101).2 c → + triangle (triangleIndex 101 c) = ((edge 101).1,(edge 101).2,c) := by decide +kernel +theorem triangle_complete_102 : ∀ c : Fin 103, + (edge 102).2 < c → SeedEncoding.indexedAdj (edge 102).1 c → + SeedEncoding.indexedAdj (edge 102).2 c → + triangle (triangleIndex 102 c) = ((edge 102).1,(edge 102).2,c) := by decide +kernel +theorem triangle_complete_103 : ∀ c : Fin 103, + (edge 103).2 < c → SeedEncoding.indexedAdj (edge 103).1 c → + SeedEncoding.indexedAdj (edge 103).2 c → + triangle (triangleIndex 103 c) = ((edge 103).1,(edge 103).2,c) := by decide +kernel +theorem triangle_complete_104 : ∀ c : Fin 103, + (edge 104).2 < c → SeedEncoding.indexedAdj (edge 104).1 c → + SeedEncoding.indexedAdj (edge 104).2 c → + triangle (triangleIndex 104 c) = ((edge 104).1,(edge 104).2,c) := by decide +kernel +theorem triangle_complete_105 : ∀ c : Fin 103, + (edge 105).2 < c → SeedEncoding.indexedAdj (edge 105).1 c → + SeedEncoding.indexedAdj (edge 105).2 c → + triangle (triangleIndex 105 c) = ((edge 105).1,(edge 105).2,c) := by decide +kernel +theorem triangle_complete_106 : ∀ c : Fin 103, + (edge 106).2 < c → SeedEncoding.indexedAdj (edge 106).1 c → + SeedEncoding.indexedAdj (edge 106).2 c → + triangle (triangleIndex 106 c) = ((edge 106).1,(edge 106).2,c) := by decide +kernel +theorem triangle_complete_107 : ∀ c : Fin 103, + (edge 107).2 < c → SeedEncoding.indexedAdj (edge 107).1 c → + SeedEncoding.indexedAdj (edge 107).2 c → + triangle (triangleIndex 107 c) = ((edge 107).1,(edge 107).2,c) := by decide +kernel +theorem triangle_complete_108 : ∀ c : Fin 103, + (edge 108).2 < c → SeedEncoding.indexedAdj (edge 108).1 c → + SeedEncoding.indexedAdj (edge 108).2 c → + triangle (triangleIndex 108 c) = ((edge 108).1,(edge 108).2,c) := by decide +kernel +theorem triangle_complete_109 : ∀ c : Fin 103, + (edge 109).2 < c → SeedEncoding.indexedAdj (edge 109).1 c → + SeedEncoding.indexedAdj (edge 109).2 c → + triangle (triangleIndex 109 c) = ((edge 109).1,(edge 109).2,c) := by decide +kernel +theorem triangle_complete_110 : ∀ c : Fin 103, + (edge 110).2 < c → SeedEncoding.indexedAdj (edge 110).1 c → + SeedEncoding.indexedAdj (edge 110).2 c → + triangle (triangleIndex 110 c) = ((edge 110).1,(edge 110).2,c) := by decide +kernel +theorem triangle_complete_111 : ∀ c : Fin 103, + (edge 111).2 < c → SeedEncoding.indexedAdj (edge 111).1 c → + SeedEncoding.indexedAdj (edge 111).2 c → + triangle (triangleIndex 111 c) = ((edge 111).1,(edge 111).2,c) := by decide +kernel +theorem triangle_complete_112 : ∀ c : Fin 103, + (edge 112).2 < c → SeedEncoding.indexedAdj (edge 112).1 c → + SeedEncoding.indexedAdj (edge 112).2 c → + triangle (triangleIndex 112 c) = ((edge 112).1,(edge 112).2,c) := by decide +kernel +theorem triangle_complete_113 : ∀ c : Fin 103, + (edge 113).2 < c → SeedEncoding.indexedAdj (edge 113).1 c → + SeedEncoding.indexedAdj (edge 113).2 c → + triangle (triangleIndex 113 c) = ((edge 113).1,(edge 113).2,c) := by decide +kernel +theorem triangle_complete_114 : ∀ c : Fin 103, + (edge 114).2 < c → SeedEncoding.indexedAdj (edge 114).1 c → + SeedEncoding.indexedAdj (edge 114).2 c → + triangle (triangleIndex 114 c) = ((edge 114).1,(edge 114).2,c) := by decide +kernel +theorem triangle_complete_115 : ∀ c : Fin 103, + (edge 115).2 < c → SeedEncoding.indexedAdj (edge 115).1 c → + SeedEncoding.indexedAdj (edge 115).2 c → + triangle (triangleIndex 115 c) = ((edge 115).1,(edge 115).2,c) := by decide +kernel +theorem triangle_complete_116 : ∀ c : Fin 103, + (edge 116).2 < c → SeedEncoding.indexedAdj (edge 116).1 c → + SeedEncoding.indexedAdj (edge 116).2 c → + triangle (triangleIndex 116 c) = ((edge 116).1,(edge 116).2,c) := by decide +kernel +theorem triangle_complete_117 : ∀ c : Fin 103, + (edge 117).2 < c → SeedEncoding.indexedAdj (edge 117).1 c → + SeedEncoding.indexedAdj (edge 117).2 c → + triangle (triangleIndex 117 c) = ((edge 117).1,(edge 117).2,c) := by decide +kernel +theorem triangle_complete_118 : ∀ c : Fin 103, + (edge 118).2 < c → SeedEncoding.indexedAdj (edge 118).1 c → + SeedEncoding.indexedAdj (edge 118).2 c → + triangle (triangleIndex 118 c) = ((edge 118).1,(edge 118).2,c) := by decide +kernel +theorem triangle_complete_119 : ∀ c : Fin 103, + (edge 119).2 < c → SeedEncoding.indexedAdj (edge 119).1 c → + SeedEncoding.indexedAdj (edge 119).2 c → + triangle (triangleIndex 119 c) = ((edge 119).1,(edge 119).2,c) := by decide +kernel +theorem triangle_complete_120 : ∀ c : Fin 103, + (edge 120).2 < c → SeedEncoding.indexedAdj (edge 120).1 c → + SeedEncoding.indexedAdj (edge 120).2 c → + triangle (triangleIndex 120 c) = ((edge 120).1,(edge 120).2,c) := by decide +kernel +theorem triangle_complete_121 : ∀ c : Fin 103, + (edge 121).2 < c → SeedEncoding.indexedAdj (edge 121).1 c → + SeedEncoding.indexedAdj (edge 121).2 c → + triangle (triangleIndex 121 c) = ((edge 121).1,(edge 121).2,c) := by decide +kernel +theorem triangle_complete_122 : ∀ c : Fin 103, + (edge 122).2 < c → SeedEncoding.indexedAdj (edge 122).1 c → + SeedEncoding.indexedAdj (edge 122).2 c → + triangle (triangleIndex 122 c) = ((edge 122).1,(edge 122).2,c) := by decide +kernel +theorem triangle_complete_123 : ∀ c : Fin 103, + (edge 123).2 < c → SeedEncoding.indexedAdj (edge 123).1 c → + SeedEncoding.indexedAdj (edge 123).2 c → + triangle (triangleIndex 123 c) = ((edge 123).1,(edge 123).2,c) := by decide +kernel +theorem triangle_complete_124 : ∀ c : Fin 103, + (edge 124).2 < c → SeedEncoding.indexedAdj (edge 124).1 c → + SeedEncoding.indexedAdj (edge 124).2 c → + triangle (triangleIndex 124 c) = ((edge 124).1,(edge 124).2,c) := by decide +kernel +theorem triangle_complete_125 : ∀ c : Fin 103, + (edge 125).2 < c → SeedEncoding.indexedAdj (edge 125).1 c → + SeedEncoding.indexedAdj (edge 125).2 c → + triangle (triangleIndex 125 c) = ((edge 125).1,(edge 125).2,c) := by decide +kernel +theorem triangle_complete_126 : ∀ c : Fin 103, + (edge 126).2 < c → SeedEncoding.indexedAdj (edge 126).1 c → + SeedEncoding.indexedAdj (edge 126).2 c → + triangle (triangleIndex 126 c) = ((edge 126).1,(edge 126).2,c) := by decide +kernel +theorem triangle_complete_127 : ∀ c : Fin 103, + (edge 127).2 < c → SeedEncoding.indexedAdj (edge 127).1 c → + SeedEncoding.indexedAdj (edge 127).2 c → + triangle (triangleIndex 127 c) = ((edge 127).1,(edge 127).2,c) := by decide +kernel +theorem triangle_complete_128 : ∀ c : Fin 103, + (edge 128).2 < c → SeedEncoding.indexedAdj (edge 128).1 c → + SeedEncoding.indexedAdj (edge 128).2 c → + triangle (triangleIndex 128 c) = ((edge 128).1,(edge 128).2,c) := by decide +kernel +theorem triangle_complete_129 : ∀ c : Fin 103, + (edge 129).2 < c → SeedEncoding.indexedAdj (edge 129).1 c → + SeedEncoding.indexedAdj (edge 129).2 c → + triangle (triangleIndex 129 c) = ((edge 129).1,(edge 129).2,c) := by decide +kernel +theorem triangle_complete_130 : ∀ c : Fin 103, + (edge 130).2 < c → SeedEncoding.indexedAdj (edge 130).1 c → + SeedEncoding.indexedAdj (edge 130).2 c → + triangle (triangleIndex 130 c) = ((edge 130).1,(edge 130).2,c) := by decide +kernel +theorem triangle_complete_131 : ∀ c : Fin 103, + (edge 131).2 < c → SeedEncoding.indexedAdj (edge 131).1 c → + SeedEncoding.indexedAdj (edge 131).2 c → + triangle (triangleIndex 131 c) = ((edge 131).1,(edge 131).2,c) := by decide +kernel +theorem triangle_complete_132 : ∀ c : Fin 103, + (edge 132).2 < c → SeedEncoding.indexedAdj (edge 132).1 c → + SeedEncoding.indexedAdj (edge 132).2 c → + triangle (triangleIndex 132 c) = ((edge 132).1,(edge 132).2,c) := by decide +kernel +theorem triangle_complete_133 : ∀ c : Fin 103, + (edge 133).2 < c → SeedEncoding.indexedAdj (edge 133).1 c → + SeedEncoding.indexedAdj (edge 133).2 c → + triangle (triangleIndex 133 c) = ((edge 133).1,(edge 133).2,c) := by decide +kernel +theorem triangle_complete_134 : ∀ c : Fin 103, + (edge 134).2 < c → SeedEncoding.indexedAdj (edge 134).1 c → + SeedEncoding.indexedAdj (edge 134).2 c → + triangle (triangleIndex 134 c) = ((edge 134).1,(edge 134).2,c) := by decide +kernel +theorem triangle_complete_135 : ∀ c : Fin 103, + (edge 135).2 < c → SeedEncoding.indexedAdj (edge 135).1 c → + SeedEncoding.indexedAdj (edge 135).2 c → + triangle (triangleIndex 135 c) = ((edge 135).1,(edge 135).2,c) := by decide +kernel +theorem triangle_complete_136 : ∀ c : Fin 103, + (edge 136).2 < c → SeedEncoding.indexedAdj (edge 136).1 c → + SeedEncoding.indexedAdj (edge 136).2 c → + triangle (triangleIndex 136 c) = ((edge 136).1,(edge 136).2,c) := by decide +kernel +theorem triangle_complete_137 : ∀ c : Fin 103, + (edge 137).2 < c → SeedEncoding.indexedAdj (edge 137).1 c → + SeedEncoding.indexedAdj (edge 137).2 c → + triangle (triangleIndex 137 c) = ((edge 137).1,(edge 137).2,c) := by decide +kernel +theorem triangle_complete_138 : ∀ c : Fin 103, + (edge 138).2 < c → SeedEncoding.indexedAdj (edge 138).1 c → + SeedEncoding.indexedAdj (edge 138).2 c → + triangle (triangleIndex 138 c) = ((edge 138).1,(edge 138).2,c) := by decide +kernel +theorem triangle_complete_139 : ∀ c : Fin 103, + (edge 139).2 < c → SeedEncoding.indexedAdj (edge 139).1 c → + SeedEncoding.indexedAdj (edge 139).2 c → + triangle (triangleIndex 139 c) = ((edge 139).1,(edge 139).2,c) := by decide +kernel +theorem triangle_complete_140 : ∀ c : Fin 103, + (edge 140).2 < c → SeedEncoding.indexedAdj (edge 140).1 c → + SeedEncoding.indexedAdj (edge 140).2 c → + triangle (triangleIndex 140 c) = ((edge 140).1,(edge 140).2,c) := by decide +kernel +theorem triangle_complete_141 : ∀ c : Fin 103, + (edge 141).2 < c → SeedEncoding.indexedAdj (edge 141).1 c → + SeedEncoding.indexedAdj (edge 141).2 c → + triangle (triangleIndex 141 c) = ((edge 141).1,(edge 141).2,c) := by decide +kernel +theorem triangle_complete_142 : ∀ c : Fin 103, + (edge 142).2 < c → SeedEncoding.indexedAdj (edge 142).1 c → + SeedEncoding.indexedAdj (edge 142).2 c → + triangle (triangleIndex 142 c) = ((edge 142).1,(edge 142).2,c) := by decide +kernel +theorem triangle_complete_143 : ∀ c : Fin 103, + (edge 143).2 < c → SeedEncoding.indexedAdj (edge 143).1 c → + SeedEncoding.indexedAdj (edge 143).2 c → + triangle (triangleIndex 143 c) = ((edge 143).1,(edge 143).2,c) := by decide +kernel +theorem triangle_complete_144 : ∀ c : Fin 103, + (edge 144).2 < c → SeedEncoding.indexedAdj (edge 144).1 c → + SeedEncoding.indexedAdj (edge 144).2 c → + triangle (triangleIndex 144 c) = ((edge 144).1,(edge 144).2,c) := by decide +kernel +theorem triangle_complete_145 : ∀ c : Fin 103, + (edge 145).2 < c → SeedEncoding.indexedAdj (edge 145).1 c → + SeedEncoding.indexedAdj (edge 145).2 c → + triangle (triangleIndex 145 c) = ((edge 145).1,(edge 145).2,c) := by decide +kernel +theorem triangle_complete_146 : ∀ c : Fin 103, + (edge 146).2 < c → SeedEncoding.indexedAdj (edge 146).1 c → + SeedEncoding.indexedAdj (edge 146).2 c → + triangle (triangleIndex 146 c) = ((edge 146).1,(edge 146).2,c) := by decide +kernel +theorem triangle_complete_147 : ∀ c : Fin 103, + (edge 147).2 < c → SeedEncoding.indexedAdj (edge 147).1 c → + SeedEncoding.indexedAdj (edge 147).2 c → + triangle (triangleIndex 147 c) = ((edge 147).1,(edge 147).2,c) := by decide +kernel +theorem triangle_complete_148 : ∀ c : Fin 103, + (edge 148).2 < c → SeedEncoding.indexedAdj (edge 148).1 c → + SeedEncoding.indexedAdj (edge 148).2 c → + triangle (triangleIndex 148 c) = ((edge 148).1,(edge 148).2,c) := by decide +kernel +theorem triangle_complete_149 : ∀ c : Fin 103, + (edge 149).2 < c → SeedEncoding.indexedAdj (edge 149).1 c → + SeedEncoding.indexedAdj (edge 149).2 c → + triangle (triangleIndex 149 c) = ((edge 149).1,(edge 149).2,c) := by decide +kernel +theorem triangle_complete_150 : ∀ c : Fin 103, + (edge 150).2 < c → SeedEncoding.indexedAdj (edge 150).1 c → + SeedEncoding.indexedAdj (edge 150).2 c → + triangle (triangleIndex 150 c) = ((edge 150).1,(edge 150).2,c) := by decide +kernel +theorem triangle_complete_151 : ∀ c : Fin 103, + (edge 151).2 < c → SeedEncoding.indexedAdj (edge 151).1 c → + SeedEncoding.indexedAdj (edge 151).2 c → + triangle (triangleIndex 151 c) = ((edge 151).1,(edge 151).2,c) := by decide +kernel +theorem triangle_complete_152 : ∀ c : Fin 103, + (edge 152).2 < c → SeedEncoding.indexedAdj (edge 152).1 c → + SeedEncoding.indexedAdj (edge 152).2 c → + triangle (triangleIndex 152 c) = ((edge 152).1,(edge 152).2,c) := by decide +kernel +theorem triangle_complete_153 : ∀ c : Fin 103, + (edge 153).2 < c → SeedEncoding.indexedAdj (edge 153).1 c → + SeedEncoding.indexedAdj (edge 153).2 c → + triangle (triangleIndex 153 c) = ((edge 153).1,(edge 153).2,c) := by decide +kernel +theorem triangle_complete_154 : ∀ c : Fin 103, + (edge 154).2 < c → SeedEncoding.indexedAdj (edge 154).1 c → + SeedEncoding.indexedAdj (edge 154).2 c → + triangle (triangleIndex 154 c) = ((edge 154).1,(edge 154).2,c) := by decide +kernel +theorem triangle_complete_155 : ∀ c : Fin 103, + (edge 155).2 < c → SeedEncoding.indexedAdj (edge 155).1 c → + SeedEncoding.indexedAdj (edge 155).2 c → + triangle (triangleIndex 155 c) = ((edge 155).1,(edge 155).2,c) := by decide +kernel +theorem triangle_complete_156 : ∀ c : Fin 103, + (edge 156).2 < c → SeedEncoding.indexedAdj (edge 156).1 c → + SeedEncoding.indexedAdj (edge 156).2 c → + triangle (triangleIndex 156 c) = ((edge 156).1,(edge 156).2,c) := by decide +kernel +theorem triangle_complete_157 : ∀ c : Fin 103, + (edge 157).2 < c → SeedEncoding.indexedAdj (edge 157).1 c → + SeedEncoding.indexedAdj (edge 157).2 c → + triangle (triangleIndex 157 c) = ((edge 157).1,(edge 157).2,c) := by decide +kernel +theorem triangle_complete_158 : ∀ c : Fin 103, + (edge 158).2 < c → SeedEncoding.indexedAdj (edge 158).1 c → + SeedEncoding.indexedAdj (edge 158).2 c → + triangle (triangleIndex 158 c) = ((edge 158).1,(edge 158).2,c) := by decide +kernel +theorem triangle_complete_159 : ∀ c : Fin 103, + (edge 159).2 < c → SeedEncoding.indexedAdj (edge 159).1 c → + SeedEncoding.indexedAdj (edge 159).2 c → + triangle (triangleIndex 159 c) = ((edge 159).1,(edge 159).2,c) := by decide +kernel +theorem triangle_complete_160 : ∀ c : Fin 103, + (edge 160).2 < c → SeedEncoding.indexedAdj (edge 160).1 c → + SeedEncoding.indexedAdj (edge 160).2 c → + triangle (triangleIndex 160 c) = ((edge 160).1,(edge 160).2,c) := by decide +kernel +theorem triangle_complete_161 : ∀ c : Fin 103, + (edge 161).2 < c → SeedEncoding.indexedAdj (edge 161).1 c → + SeedEncoding.indexedAdj (edge 161).2 c → + triangle (triangleIndex 161 c) = ((edge 161).1,(edge 161).2,c) := by decide +kernel +theorem triangle_complete_162 : ∀ c : Fin 103, + (edge 162).2 < c → SeedEncoding.indexedAdj (edge 162).1 c → + SeedEncoding.indexedAdj (edge 162).2 c → + triangle (triangleIndex 162 c) = ((edge 162).1,(edge 162).2,c) := by decide +kernel +theorem triangle_complete_163 : ∀ c : Fin 103, + (edge 163).2 < c → SeedEncoding.indexedAdj (edge 163).1 c → + SeedEncoding.indexedAdj (edge 163).2 c → + triangle (triangleIndex 163 c) = ((edge 163).1,(edge 163).2,c) := by decide +kernel +theorem triangle_complete_164 : ∀ c : Fin 103, + (edge 164).2 < c → SeedEncoding.indexedAdj (edge 164).1 c → + SeedEncoding.indexedAdj (edge 164).2 c → + triangle (triangleIndex 164 c) = ((edge 164).1,(edge 164).2,c) := by decide +kernel +theorem triangle_complete_165 : ∀ c : Fin 103, + (edge 165).2 < c → SeedEncoding.indexedAdj (edge 165).1 c → + SeedEncoding.indexedAdj (edge 165).2 c → + triangle (triangleIndex 165 c) = ((edge 165).1,(edge 165).2,c) := by decide +kernel +theorem triangle_complete_166 : ∀ c : Fin 103, + (edge 166).2 < c → SeedEncoding.indexedAdj (edge 166).1 c → + SeedEncoding.indexedAdj (edge 166).2 c → + triangle (triangleIndex 166 c) = ((edge 166).1,(edge 166).2,c) := by decide +kernel +theorem triangle_complete_167 : ∀ c : Fin 103, + (edge 167).2 < c → SeedEncoding.indexedAdj (edge 167).1 c → + SeedEncoding.indexedAdj (edge 167).2 c → + triangle (triangleIndex 167 c) = ((edge 167).1,(edge 167).2,c) := by decide +kernel +theorem triangle_complete_168 : ∀ c : Fin 103, + (edge 168).2 < c → SeedEncoding.indexedAdj (edge 168).1 c → + SeedEncoding.indexedAdj (edge 168).2 c → + triangle (triangleIndex 168 c) = ((edge 168).1,(edge 168).2,c) := by decide +kernel +theorem triangle_complete_169 : ∀ c : Fin 103, + (edge 169).2 < c → SeedEncoding.indexedAdj (edge 169).1 c → + SeedEncoding.indexedAdj (edge 169).2 c → + triangle (triangleIndex 169 c) = ((edge 169).1,(edge 169).2,c) := by decide +kernel +theorem triangle_complete_170 : ∀ c : Fin 103, + (edge 170).2 < c → SeedEncoding.indexedAdj (edge 170).1 c → + SeedEncoding.indexedAdj (edge 170).2 c → + triangle (triangleIndex 170 c) = ((edge 170).1,(edge 170).2,c) := by decide +kernel +theorem triangle_complete_171 : ∀ c : Fin 103, + (edge 171).2 < c → SeedEncoding.indexedAdj (edge 171).1 c → + SeedEncoding.indexedAdj (edge 171).2 c → + triangle (triangleIndex 171 c) = ((edge 171).1,(edge 171).2,c) := by decide +kernel +theorem triangle_complete_172 : ∀ c : Fin 103, + (edge 172).2 < c → SeedEncoding.indexedAdj (edge 172).1 c → + SeedEncoding.indexedAdj (edge 172).2 c → + triangle (triangleIndex 172 c) = ((edge 172).1,(edge 172).2,c) := by decide +kernel +theorem triangle_complete_173 : ∀ c : Fin 103, + (edge 173).2 < c → SeedEncoding.indexedAdj (edge 173).1 c → + SeedEncoding.indexedAdj (edge 173).2 c → + triangle (triangleIndex 173 c) = ((edge 173).1,(edge 173).2,c) := by decide +kernel +theorem triangle_complete_174 : ∀ c : Fin 103, + (edge 174).2 < c → SeedEncoding.indexedAdj (edge 174).1 c → + SeedEncoding.indexedAdj (edge 174).2 c → + triangle (triangleIndex 174 c) = ((edge 174).1,(edge 174).2,c) := by decide +kernel +theorem triangle_complete_175 : ∀ c : Fin 103, + (edge 175).2 < c → SeedEncoding.indexedAdj (edge 175).1 c → + SeedEncoding.indexedAdj (edge 175).2 c → + triangle (triangleIndex 175 c) = ((edge 175).1,(edge 175).2,c) := by decide +kernel +theorem triangle_complete_176 : ∀ c : Fin 103, + (edge 176).2 < c → SeedEncoding.indexedAdj (edge 176).1 c → + SeedEncoding.indexedAdj (edge 176).2 c → + triangle (triangleIndex 176 c) = ((edge 176).1,(edge 176).2,c) := by decide +kernel +theorem triangle_complete_177 : ∀ c : Fin 103, + (edge 177).2 < c → SeedEncoding.indexedAdj (edge 177).1 c → + SeedEncoding.indexedAdj (edge 177).2 c → + triangle (triangleIndex 177 c) = ((edge 177).1,(edge 177).2,c) := by decide +kernel +theorem triangle_complete_178 : ∀ c : Fin 103, + (edge 178).2 < c → SeedEncoding.indexedAdj (edge 178).1 c → + SeedEncoding.indexedAdj (edge 178).2 c → + triangle (triangleIndex 178 c) = ((edge 178).1,(edge 178).2,c) := by decide +kernel +theorem triangle_complete_179 : ∀ c : Fin 103, + (edge 179).2 < c → SeedEncoding.indexedAdj (edge 179).1 c → + SeedEncoding.indexedAdj (edge 179).2 c → + triangle (triangleIndex 179 c) = ((edge 179).1,(edge 179).2,c) := by decide +kernel +theorem triangle_complete_180 : ∀ c : Fin 103, + (edge 180).2 < c → SeedEncoding.indexedAdj (edge 180).1 c → + SeedEncoding.indexedAdj (edge 180).2 c → + triangle (triangleIndex 180 c) = ((edge 180).1,(edge 180).2,c) := by decide +kernel +theorem triangle_complete_181 : ∀ c : Fin 103, + (edge 181).2 < c → SeedEncoding.indexedAdj (edge 181).1 c → + SeedEncoding.indexedAdj (edge 181).2 c → + triangle (triangleIndex 181 c) = ((edge 181).1,(edge 181).2,c) := by decide +kernel +theorem triangle_complete_182 : ∀ c : Fin 103, + (edge 182).2 < c → SeedEncoding.indexedAdj (edge 182).1 c → + SeedEncoding.indexedAdj (edge 182).2 c → + triangle (triangleIndex 182 c) = ((edge 182).1,(edge 182).2,c) := by decide +kernel +theorem triangle_complete_183 : ∀ c : Fin 103, + (edge 183).2 < c → SeedEncoding.indexedAdj (edge 183).1 c → + SeedEncoding.indexedAdj (edge 183).2 c → + triangle (triangleIndex 183 c) = ((edge 183).1,(edge 183).2,c) := by decide +kernel +theorem triangle_complete_184 : ∀ c : Fin 103, + (edge 184).2 < c → SeedEncoding.indexedAdj (edge 184).1 c → + SeedEncoding.indexedAdj (edge 184).2 c → + triangle (triangleIndex 184 c) = ((edge 184).1,(edge 184).2,c) := by decide +kernel +theorem triangle_complete_185 : ∀ c : Fin 103, + (edge 185).2 < c → SeedEncoding.indexedAdj (edge 185).1 c → + SeedEncoding.indexedAdj (edge 185).2 c → + triangle (triangleIndex 185 c) = ((edge 185).1,(edge 185).2,c) := by decide +kernel +theorem triangle_complete_186 : ∀ c : Fin 103, + (edge 186).2 < c → SeedEncoding.indexedAdj (edge 186).1 c → + SeedEncoding.indexedAdj (edge 186).2 c → + triangle (triangleIndex 186 c) = ((edge 186).1,(edge 186).2,c) := by decide +kernel +theorem triangle_complete_187 : ∀ c : Fin 103, + (edge 187).2 < c → SeedEncoding.indexedAdj (edge 187).1 c → + SeedEncoding.indexedAdj (edge 187).2 c → + triangle (triangleIndex 187 c) = ((edge 187).1,(edge 187).2,c) := by decide +kernel +theorem triangle_complete_188 : ∀ c : Fin 103, + (edge 188).2 < c → SeedEncoding.indexedAdj (edge 188).1 c → + SeedEncoding.indexedAdj (edge 188).2 c → + triangle (triangleIndex 188 c) = ((edge 188).1,(edge 188).2,c) := by decide +kernel +theorem triangle_complete_189 : ∀ c : Fin 103, + (edge 189).2 < c → SeedEncoding.indexedAdj (edge 189).1 c → + SeedEncoding.indexedAdj (edge 189).2 c → + triangle (triangleIndex 189 c) = ((edge 189).1,(edge 189).2,c) := by decide +kernel +theorem triangle_complete_190 : ∀ c : Fin 103, + (edge 190).2 < c → SeedEncoding.indexedAdj (edge 190).1 c → + SeedEncoding.indexedAdj (edge 190).2 c → + triangle (triangleIndex 190 c) = ((edge 190).1,(edge 190).2,c) := by decide +kernel +theorem triangle_complete_191 : ∀ c : Fin 103, + (edge 191).2 < c → SeedEncoding.indexedAdj (edge 191).1 c → + SeedEncoding.indexedAdj (edge 191).2 c → + triangle (triangleIndex 191 c) = ((edge 191).1,(edge 191).2,c) := by decide +kernel +theorem triangle_complete_192 : ∀ c : Fin 103, + (edge 192).2 < c → SeedEncoding.indexedAdj (edge 192).1 c → + SeedEncoding.indexedAdj (edge 192).2 c → + triangle (triangleIndex 192 c) = ((edge 192).1,(edge 192).2,c) := by decide +kernel +theorem triangle_complete_193 : ∀ c : Fin 103, + (edge 193).2 < c → SeedEncoding.indexedAdj (edge 193).1 c → + SeedEncoding.indexedAdj (edge 193).2 c → + triangle (triangleIndex 193 c) = ((edge 193).1,(edge 193).2,c) := by decide +kernel +theorem triangle_complete_194 : ∀ c : Fin 103, + (edge 194).2 < c → SeedEncoding.indexedAdj (edge 194).1 c → + SeedEncoding.indexedAdj (edge 194).2 c → + triangle (triangleIndex 194 c) = ((edge 194).1,(edge 194).2,c) := by decide +kernel +theorem triangle_complete_195 : ∀ c : Fin 103, + (edge 195).2 < c → SeedEncoding.indexedAdj (edge 195).1 c → + SeedEncoding.indexedAdj (edge 195).2 c → + triangle (triangleIndex 195 c) = ((edge 195).1,(edge 195).2,c) := by decide +kernel +theorem triangle_complete_196 : ∀ c : Fin 103, + (edge 196).2 < c → SeedEncoding.indexedAdj (edge 196).1 c → + SeedEncoding.indexedAdj (edge 196).2 c → + triangle (triangleIndex 196 c) = ((edge 196).1,(edge 196).2,c) := by decide +kernel +theorem triangle_complete_197 : ∀ c : Fin 103, + (edge 197).2 < c → SeedEncoding.indexedAdj (edge 197).1 c → + SeedEncoding.indexedAdj (edge 197).2 c → + triangle (triangleIndex 197 c) = ((edge 197).1,(edge 197).2,c) := by decide +kernel +theorem triangle_complete_198 : ∀ c : Fin 103, + (edge 198).2 < c → SeedEncoding.indexedAdj (edge 198).1 c → + SeedEncoding.indexedAdj (edge 198).2 c → + triangle (triangleIndex 198 c) = ((edge 198).1,(edge 198).2,c) := by decide +kernel +theorem triangle_complete_199 : ∀ c : Fin 103, + (edge 199).2 < c → SeedEncoding.indexedAdj (edge 199).1 c → + SeedEncoding.indexedAdj (edge 199).2 c → + triangle (triangleIndex 199 c) = ((edge 199).1,(edge 199).2,c) := by decide +kernel +theorem triangle_complete_200 : ∀ c : Fin 103, + (edge 200).2 < c → SeedEncoding.indexedAdj (edge 200).1 c → + SeedEncoding.indexedAdj (edge 200).2 c → + triangle (triangleIndex 200 c) = ((edge 200).1,(edge 200).2,c) := by decide +kernel +theorem triangle_complete_201 : ∀ c : Fin 103, + (edge 201).2 < c → SeedEncoding.indexedAdj (edge 201).1 c → + SeedEncoding.indexedAdj (edge 201).2 c → + triangle (triangleIndex 201 c) = ((edge 201).1,(edge 201).2,c) := by decide +kernel +theorem triangle_complete_202 : ∀ c : Fin 103, + (edge 202).2 < c → SeedEncoding.indexedAdj (edge 202).1 c → + SeedEncoding.indexedAdj (edge 202).2 c → + triangle (triangleIndex 202 c) = ((edge 202).1,(edge 202).2,c) := by decide +kernel +theorem triangle_complete_203 : ∀ c : Fin 103, + (edge 203).2 < c → SeedEncoding.indexedAdj (edge 203).1 c → + SeedEncoding.indexedAdj (edge 203).2 c → + triangle (triangleIndex 203 c) = ((edge 203).1,(edge 203).2,c) := by decide +kernel +theorem triangle_complete_204 : ∀ c : Fin 103, + (edge 204).2 < c → SeedEncoding.indexedAdj (edge 204).1 c → + SeedEncoding.indexedAdj (edge 204).2 c → + triangle (triangleIndex 204 c) = ((edge 204).1,(edge 204).2,c) := by decide +kernel +theorem triangle_complete_205 : ∀ c : Fin 103, + (edge 205).2 < c → SeedEncoding.indexedAdj (edge 205).1 c → + SeedEncoding.indexedAdj (edge 205).2 c → + triangle (triangleIndex 205 c) = ((edge 205).1,(edge 205).2,c) := by decide +kernel +theorem triangle_complete_206 : ∀ c : Fin 103, + (edge 206).2 < c → SeedEncoding.indexedAdj (edge 206).1 c → + SeedEncoding.indexedAdj (edge 206).2 c → + triangle (triangleIndex 206 c) = ((edge 206).1,(edge 206).2,c) := by decide +kernel +theorem triangle_complete_207 : ∀ c : Fin 103, + (edge 207).2 < c → SeedEncoding.indexedAdj (edge 207).1 c → + SeedEncoding.indexedAdj (edge 207).2 c → + triangle (triangleIndex 207 c) = ((edge 207).1,(edge 207).2,c) := by decide +kernel +theorem triangle_complete_208 : ∀ c : Fin 103, + (edge 208).2 < c → SeedEncoding.indexedAdj (edge 208).1 c → + SeedEncoding.indexedAdj (edge 208).2 c → + triangle (triangleIndex 208 c) = ((edge 208).1,(edge 208).2,c) := by decide +kernel +theorem triangle_complete_209 : ∀ c : Fin 103, + (edge 209).2 < c → SeedEncoding.indexedAdj (edge 209).1 c → + SeedEncoding.indexedAdj (edge 209).2 c → + triangle (triangleIndex 209 c) = ((edge 209).1,(edge 209).2,c) := by decide +kernel +theorem triangle_complete_210 : ∀ c : Fin 103, + (edge 210).2 < c → SeedEncoding.indexedAdj (edge 210).1 c → + SeedEncoding.indexedAdj (edge 210).2 c → + triangle (triangleIndex 210 c) = ((edge 210).1,(edge 210).2,c) := by decide +kernel +theorem triangle_complete_211 : ∀ c : Fin 103, + (edge 211).2 < c → SeedEncoding.indexedAdj (edge 211).1 c → + SeedEncoding.indexedAdj (edge 211).2 c → + triangle (triangleIndex 211 c) = ((edge 211).1,(edge 211).2,c) := by decide +kernel +theorem triangle_complete_212 : ∀ c : Fin 103, + (edge 212).2 < c → SeedEncoding.indexedAdj (edge 212).1 c → + SeedEncoding.indexedAdj (edge 212).2 c → + triangle (triangleIndex 212 c) = ((edge 212).1,(edge 212).2,c) := by decide +kernel +theorem triangle_complete_213 : ∀ c : Fin 103, + (edge 213).2 < c → SeedEncoding.indexedAdj (edge 213).1 c → + SeedEncoding.indexedAdj (edge 213).2 c → + triangle (triangleIndex 213 c) = ((edge 213).1,(edge 213).2,c) := by decide +kernel +theorem triangle_complete_214 : ∀ c : Fin 103, + (edge 214).2 < c → SeedEncoding.indexedAdj (edge 214).1 c → + SeedEncoding.indexedAdj (edge 214).2 c → + triangle (triangleIndex 214 c) = ((edge 214).1,(edge 214).2,c) := by decide +kernel +theorem triangle_complete_215 : ∀ c : Fin 103, + (edge 215).2 < c → SeedEncoding.indexedAdj (edge 215).1 c → + SeedEncoding.indexedAdj (edge 215).2 c → + triangle (triangleIndex 215 c) = ((edge 215).1,(edge 215).2,c) := by decide +kernel +theorem triangle_complete_216 : ∀ c : Fin 103, + (edge 216).2 < c → SeedEncoding.indexedAdj (edge 216).1 c → + SeedEncoding.indexedAdj (edge 216).2 c → + triangle (triangleIndex 216 c) = ((edge 216).1,(edge 216).2,c) := by decide +kernel +theorem triangle_complete_217 : ∀ c : Fin 103, + (edge 217).2 < c → SeedEncoding.indexedAdj (edge 217).1 c → + SeedEncoding.indexedAdj (edge 217).2 c → + triangle (triangleIndex 217 c) = ((edge 217).1,(edge 217).2,c) := by decide +kernel +theorem triangle_complete_218 : ∀ c : Fin 103, + (edge 218).2 < c → SeedEncoding.indexedAdj (edge 218).1 c → + SeedEncoding.indexedAdj (edge 218).2 c → + triangle (triangleIndex 218 c) = ((edge 218).1,(edge 218).2,c) := by decide +kernel +theorem triangle_complete_219 : ∀ c : Fin 103, + (edge 219).2 < c → SeedEncoding.indexedAdj (edge 219).1 c → + SeedEncoding.indexedAdj (edge 219).2 c → + triangle (triangleIndex 219 c) = ((edge 219).1,(edge 219).2,c) := by decide +kernel +theorem triangle_complete_220 : ∀ c : Fin 103, + (edge 220).2 < c → SeedEncoding.indexedAdj (edge 220).1 c → + SeedEncoding.indexedAdj (edge 220).2 c → + triangle (triangleIndex 220 c) = ((edge 220).1,(edge 220).2,c) := by decide +kernel +theorem triangle_complete_221 : ∀ c : Fin 103, + (edge 221).2 < c → SeedEncoding.indexedAdj (edge 221).1 c → + SeedEncoding.indexedAdj (edge 221).2 c → + triangle (triangleIndex 221 c) = ((edge 221).1,(edge 221).2,c) := by decide +kernel +theorem triangle_complete_222 : ∀ c : Fin 103, + (edge 222).2 < c → SeedEncoding.indexedAdj (edge 222).1 c → + SeedEncoding.indexedAdj (edge 222).2 c → + triangle (triangleIndex 222 c) = ((edge 222).1,(edge 222).2,c) := by decide +kernel +theorem triangle_complete_223 : ∀ c : Fin 103, + (edge 223).2 < c → SeedEncoding.indexedAdj (edge 223).1 c → + SeedEncoding.indexedAdj (edge 223).2 c → + triangle (triangleIndex 223 c) = ((edge 223).1,(edge 223).2,c) := by decide +kernel +theorem triangle_complete_224 : ∀ c : Fin 103, + (edge 224).2 < c → SeedEncoding.indexedAdj (edge 224).1 c → + SeedEncoding.indexedAdj (edge 224).2 c → + triangle (triangleIndex 224 c) = ((edge 224).1,(edge 224).2,c) := by decide +kernel +theorem triangle_complete_225 : ∀ c : Fin 103, + (edge 225).2 < c → SeedEncoding.indexedAdj (edge 225).1 c → + SeedEncoding.indexedAdj (edge 225).2 c → + triangle (triangleIndex 225 c) = ((edge 225).1,(edge 225).2,c) := by decide +kernel +theorem triangle_complete_226 : ∀ c : Fin 103, + (edge 226).2 < c → SeedEncoding.indexedAdj (edge 226).1 c → + SeedEncoding.indexedAdj (edge 226).2 c → + triangle (triangleIndex 226 c) = ((edge 226).1,(edge 226).2,c) := by decide +kernel +theorem triangle_complete_227 : ∀ c : Fin 103, + (edge 227).2 < c → SeedEncoding.indexedAdj (edge 227).1 c → + SeedEncoding.indexedAdj (edge 227).2 c → + triangle (triangleIndex 227 c) = ((edge 227).1,(edge 227).2,c) := by decide +kernel +theorem triangle_complete_228 : ∀ c : Fin 103, + (edge 228).2 < c → SeedEncoding.indexedAdj (edge 228).1 c → + SeedEncoding.indexedAdj (edge 228).2 c → + triangle (triangleIndex 228 c) = ((edge 228).1,(edge 228).2,c) := by decide +kernel +theorem triangle_complete_229 : ∀ c : Fin 103, + (edge 229).2 < c → SeedEncoding.indexedAdj (edge 229).1 c → + SeedEncoding.indexedAdj (edge 229).2 c → + triangle (triangleIndex 229 c) = ((edge 229).1,(edge 229).2,c) := by decide +kernel +theorem triangle_complete_230 : ∀ c : Fin 103, + (edge 230).2 < c → SeedEncoding.indexedAdj (edge 230).1 c → + SeedEncoding.indexedAdj (edge 230).2 c → + triangle (triangleIndex 230 c) = ((edge 230).1,(edge 230).2,c) := by decide +kernel +theorem triangle_complete_231 : ∀ c : Fin 103, + (edge 231).2 < c → SeedEncoding.indexedAdj (edge 231).1 c → + SeedEncoding.indexedAdj (edge 231).2 c → + triangle (triangleIndex 231 c) = ((edge 231).1,(edge 231).2,c) := by decide +kernel +theorem triangle_complete_232 : ∀ c : Fin 103, + (edge 232).2 < c → SeedEncoding.indexedAdj (edge 232).1 c → + SeedEncoding.indexedAdj (edge 232).2 c → + triangle (triangleIndex 232 c) = ((edge 232).1,(edge 232).2,c) := by decide +kernel +theorem triangle_complete_233 : ∀ c : Fin 103, + (edge 233).2 < c → SeedEncoding.indexedAdj (edge 233).1 c → + SeedEncoding.indexedAdj (edge 233).2 c → + triangle (triangleIndex 233 c) = ((edge 233).1,(edge 233).2,c) := by decide +kernel +theorem triangle_complete_234 : ∀ c : Fin 103, + (edge 234).2 < c → SeedEncoding.indexedAdj (edge 234).1 c → + SeedEncoding.indexedAdj (edge 234).2 c → + triangle (triangleIndex 234 c) = ((edge 234).1,(edge 234).2,c) := by decide +kernel +theorem triangle_complete_235 : ∀ c : Fin 103, + (edge 235).2 < c → SeedEncoding.indexedAdj (edge 235).1 c → + SeedEncoding.indexedAdj (edge 235).2 c → + triangle (triangleIndex 235 c) = ((edge 235).1,(edge 235).2,c) := by decide +kernel +theorem triangle_complete_236 : ∀ c : Fin 103, + (edge 236).2 < c → SeedEncoding.indexedAdj (edge 236).1 c → + SeedEncoding.indexedAdj (edge 236).2 c → + triangle (triangleIndex 236 c) = ((edge 236).1,(edge 236).2,c) := by decide +kernel +theorem triangle_complete_237 : ∀ c : Fin 103, + (edge 237).2 < c → SeedEncoding.indexedAdj (edge 237).1 c → + SeedEncoding.indexedAdj (edge 237).2 c → + triangle (triangleIndex 237 c) = ((edge 237).1,(edge 237).2,c) := by decide +kernel +theorem triangle_complete_238 : ∀ c : Fin 103, + (edge 238).2 < c → SeedEncoding.indexedAdj (edge 238).1 c → + SeedEncoding.indexedAdj (edge 238).2 c → + triangle (triangleIndex 238 c) = ((edge 238).1,(edge 238).2,c) := by decide +kernel +theorem triangle_complete_239 : ∀ c : Fin 103, + (edge 239).2 < c → SeedEncoding.indexedAdj (edge 239).1 c → + SeedEncoding.indexedAdj (edge 239).2 c → + triangle (triangleIndex 239 c) = ((edge 239).1,(edge 239).2,c) := by decide +kernel +theorem triangle_complete_240 : ∀ c : Fin 103, + (edge 240).2 < c → SeedEncoding.indexedAdj (edge 240).1 c → + SeedEncoding.indexedAdj (edge 240).2 c → + triangle (triangleIndex 240 c) = ((edge 240).1,(edge 240).2,c) := by decide +kernel +theorem triangle_complete_241 : ∀ c : Fin 103, + (edge 241).2 < c → SeedEncoding.indexedAdj (edge 241).1 c → + SeedEncoding.indexedAdj (edge 241).2 c → + triangle (triangleIndex 241 c) = ((edge 241).1,(edge 241).2,c) := by decide +kernel +theorem triangle_complete_242 : ∀ c : Fin 103, + (edge 242).2 < c → SeedEncoding.indexedAdj (edge 242).1 c → + SeedEncoding.indexedAdj (edge 242).2 c → + triangle (triangleIndex 242 c) = ((edge 242).1,(edge 242).2,c) := by decide +kernel +theorem triangle_complete_243 : ∀ c : Fin 103, + (edge 243).2 < c → SeedEncoding.indexedAdj (edge 243).1 c → + SeedEncoding.indexedAdj (edge 243).2 c → + triangle (triangleIndex 243 c) = ((edge 243).1,(edge 243).2,c) := by decide +kernel +theorem triangle_complete_244 : ∀ c : Fin 103, + (edge 244).2 < c → SeedEncoding.indexedAdj (edge 244).1 c → + SeedEncoding.indexedAdj (edge 244).2 c → + triangle (triangleIndex 244 c) = ((edge 244).1,(edge 244).2,c) := by decide +kernel +theorem triangle_complete_245 : ∀ c : Fin 103, + (edge 245).2 < c → SeedEncoding.indexedAdj (edge 245).1 c → + SeedEncoding.indexedAdj (edge 245).2 c → + triangle (triangleIndex 245 c) = ((edge 245).1,(edge 245).2,c) := by decide +kernel +theorem triangle_complete_246 : ∀ c : Fin 103, + (edge 246).2 < c → SeedEncoding.indexedAdj (edge 246).1 c → + SeedEncoding.indexedAdj (edge 246).2 c → + triangle (triangleIndex 246 c) = ((edge 246).1,(edge 246).2,c) := by decide +kernel +theorem triangle_complete_247 : ∀ c : Fin 103, + (edge 247).2 < c → SeedEncoding.indexedAdj (edge 247).1 c → + SeedEncoding.indexedAdj (edge 247).2 c → + triangle (triangleIndex 247 c) = ((edge 247).1,(edge 247).2,c) := by decide +kernel +theorem triangle_complete_248 : ∀ c : Fin 103, + (edge 248).2 < c → SeedEncoding.indexedAdj (edge 248).1 c → + SeedEncoding.indexedAdj (edge 248).2 c → + triangle (triangleIndex 248 c) = ((edge 248).1,(edge 248).2,c) := by decide +kernel +theorem triangle_complete_249 : ∀ c : Fin 103, + (edge 249).2 < c → SeedEncoding.indexedAdj (edge 249).1 c → + SeedEncoding.indexedAdj (edge 249).2 c → + triangle (triangleIndex 249 c) = ((edge 249).1,(edge 249).2,c) := by decide +kernel +theorem triangle_complete_250 : ∀ c : Fin 103, + (edge 250).2 < c → SeedEncoding.indexedAdj (edge 250).1 c → + SeedEncoding.indexedAdj (edge 250).2 c → + triangle (triangleIndex 250 c) = ((edge 250).1,(edge 250).2,c) := by decide +kernel +theorem triangle_complete_251 : ∀ c : Fin 103, + (edge 251).2 < c → SeedEncoding.indexedAdj (edge 251).1 c → + SeedEncoding.indexedAdj (edge 251).2 c → + triangle (triangleIndex 251 c) = ((edge 251).1,(edge 251).2,c) := by decide +kernel +theorem triangle_complete_252 : ∀ c : Fin 103, + (edge 252).2 < c → SeedEncoding.indexedAdj (edge 252).1 c → + SeedEncoding.indexedAdj (edge 252).2 c → + triangle (triangleIndex 252 c) = ((edge 252).1,(edge 252).2,c) := by decide +kernel +theorem triangle_complete_253 : ∀ c : Fin 103, + (edge 253).2 < c → SeedEncoding.indexedAdj (edge 253).1 c → + SeedEncoding.indexedAdj (edge 253).2 c → + triangle (triangleIndex 253 c) = ((edge 253).1,(edge 253).2,c) := by decide +kernel +theorem triangle_complete_254 : ∀ c : Fin 103, + (edge 254).2 < c → SeedEncoding.indexedAdj (edge 254).1 c → + SeedEncoding.indexedAdj (edge 254).2 c → + triangle (triangleIndex 254 c) = ((edge 254).1,(edge 254).2,c) := by decide +kernel +theorem triangle_complete_255 : ∀ c : Fin 103, + (edge 255).2 < c → SeedEncoding.indexedAdj (edge 255).1 c → + SeedEncoding.indexedAdj (edge 255).2 c → + triangle (triangleIndex 255 c) = ((edge 255).1,(edge 255).2,c) := by decide +kernel +theorem triangle_complete_256 : ∀ c : Fin 103, + (edge 256).2 < c → SeedEncoding.indexedAdj (edge 256).1 c → + SeedEncoding.indexedAdj (edge 256).2 c → + triangle (triangleIndex 256 c) = ((edge 256).1,(edge 256).2,c) := by decide +kernel +theorem triangle_complete_257 : ∀ c : Fin 103, + (edge 257).2 < c → SeedEncoding.indexedAdj (edge 257).1 c → + SeedEncoding.indexedAdj (edge 257).2 c → + triangle (triangleIndex 257 c) = ((edge 257).1,(edge 257).2,c) := by decide +kernel +theorem triangle_complete_258 : ∀ c : Fin 103, + (edge 258).2 < c → SeedEncoding.indexedAdj (edge 258).1 c → + SeedEncoding.indexedAdj (edge 258).2 c → + triangle (triangleIndex 258 c) = ((edge 258).1,(edge 258).2,c) := by decide +kernel +theorem triangle_complete_259 : ∀ c : Fin 103, + (edge 259).2 < c → SeedEncoding.indexedAdj (edge 259).1 c → + SeedEncoding.indexedAdj (edge 259).2 c → + triangle (triangleIndex 259 c) = ((edge 259).1,(edge 259).2,c) := by decide +kernel +theorem triangle_complete_260 : ∀ c : Fin 103, + (edge 260).2 < c → SeedEncoding.indexedAdj (edge 260).1 c → + SeedEncoding.indexedAdj (edge 260).2 c → + triangle (triangleIndex 260 c) = ((edge 260).1,(edge 260).2,c) := by decide +kernel +theorem triangle_complete_261 : ∀ c : Fin 103, + (edge 261).2 < c → SeedEncoding.indexedAdj (edge 261).1 c → + SeedEncoding.indexedAdj (edge 261).2 c → + triangle (triangleIndex 261 c) = ((edge 261).1,(edge 261).2,c) := by decide +kernel +theorem triangle_complete_262 : ∀ c : Fin 103, + (edge 262).2 < c → SeedEncoding.indexedAdj (edge 262).1 c → + SeedEncoding.indexedAdj (edge 262).2 c → + triangle (triangleIndex 262 c) = ((edge 262).1,(edge 262).2,c) := by decide +kernel +theorem triangle_complete_263 : ∀ c : Fin 103, + (edge 263).2 < c → SeedEncoding.indexedAdj (edge 263).1 c → + SeedEncoding.indexedAdj (edge 263).2 c → + triangle (triangleIndex 263 c) = ((edge 263).1,(edge 263).2,c) := by decide +kernel +theorem triangle_complete_264 : ∀ c : Fin 103, + (edge 264).2 < c → SeedEncoding.indexedAdj (edge 264).1 c → + SeedEncoding.indexedAdj (edge 264).2 c → + triangle (triangleIndex 264 c) = ((edge 264).1,(edge 264).2,c) := by decide +kernel +theorem triangle_complete_265 : ∀ c : Fin 103, + (edge 265).2 < c → SeedEncoding.indexedAdj (edge 265).1 c → + SeedEncoding.indexedAdj (edge 265).2 c → + triangle (triangleIndex 265 c) = ((edge 265).1,(edge 265).2,c) := by decide +kernel +theorem triangle_complete_266 : ∀ c : Fin 103, + (edge 266).2 < c → SeedEncoding.indexedAdj (edge 266).1 c → + SeedEncoding.indexedAdj (edge 266).2 c → + triangle (triangleIndex 266 c) = ((edge 266).1,(edge 266).2,c) := by decide +kernel +theorem triangle_complete_267 : ∀ c : Fin 103, + (edge 267).2 < c → SeedEncoding.indexedAdj (edge 267).1 c → + SeedEncoding.indexedAdj (edge 267).2 c → + triangle (triangleIndex 267 c) = ((edge 267).1,(edge 267).2,c) := by decide +kernel +theorem triangle_complete_268 : ∀ c : Fin 103, + (edge 268).2 < c → SeedEncoding.indexedAdj (edge 268).1 c → + SeedEncoding.indexedAdj (edge 268).2 c → + triangle (triangleIndex 268 c) = ((edge 268).1,(edge 268).2,c) := by decide +kernel +theorem triangle_complete_269 : ∀ c : Fin 103, + (edge 269).2 < c → SeedEncoding.indexedAdj (edge 269).1 c → + SeedEncoding.indexedAdj (edge 269).2 c → + triangle (triangleIndex 269 c) = ((edge 269).1,(edge 269).2,c) := by decide +kernel +theorem triangle_complete_270 : ∀ c : Fin 103, + (edge 270).2 < c → SeedEncoding.indexedAdj (edge 270).1 c → + SeedEncoding.indexedAdj (edge 270).2 c → + triangle (triangleIndex 270 c) = ((edge 270).1,(edge 270).2,c) := by decide +kernel +theorem triangle_complete_271 : ∀ c : Fin 103, + (edge 271).2 < c → SeedEncoding.indexedAdj (edge 271).1 c → + SeedEncoding.indexedAdj (edge 271).2 c → + triangle (triangleIndex 271 c) = ((edge 271).1,(edge 271).2,c) := by decide +kernel +theorem triangle_complete_272 : ∀ c : Fin 103, + (edge 272).2 < c → SeedEncoding.indexedAdj (edge 272).1 c → + SeedEncoding.indexedAdj (edge 272).2 c → + triangle (triangleIndex 272 c) = ((edge 272).1,(edge 272).2,c) := by decide +kernel +theorem triangle_complete_273 : ∀ c : Fin 103, + (edge 273).2 < c → SeedEncoding.indexedAdj (edge 273).1 c → + SeedEncoding.indexedAdj (edge 273).2 c → + triangle (triangleIndex 273 c) = ((edge 273).1,(edge 273).2,c) := by decide +kernel +theorem triangle_complete_274 : ∀ c : Fin 103, + (edge 274).2 < c → SeedEncoding.indexedAdj (edge 274).1 c → + SeedEncoding.indexedAdj (edge 274).2 c → + triangle (triangleIndex 274 c) = ((edge 274).1,(edge 274).2,c) := by decide +kernel +theorem triangle_complete_275 : ∀ c : Fin 103, + (edge 275).2 < c → SeedEncoding.indexedAdj (edge 275).1 c → + SeedEncoding.indexedAdj (edge 275).2 c → + triangle (triangleIndex 275 c) = ((edge 275).1,(edge 275).2,c) := by decide +kernel +theorem triangle_complete_276 : ∀ c : Fin 103, + (edge 276).2 < c → SeedEncoding.indexedAdj (edge 276).1 c → + SeedEncoding.indexedAdj (edge 276).2 c → + triangle (triangleIndex 276 c) = ((edge 276).1,(edge 276).2,c) := by decide +kernel +theorem triangle_complete_277 : ∀ c : Fin 103, + (edge 277).2 < c → SeedEncoding.indexedAdj (edge 277).1 c → + SeedEncoding.indexedAdj (edge 277).2 c → + triangle (triangleIndex 277 c) = ((edge 277).1,(edge 277).2,c) := by decide +kernel +theorem triangle_complete_278 : ∀ c : Fin 103, + (edge 278).2 < c → SeedEncoding.indexedAdj (edge 278).1 c → + SeedEncoding.indexedAdj (edge 278).2 c → + triangle (triangleIndex 278 c) = ((edge 278).1,(edge 278).2,c) := by decide +kernel +theorem triangle_complete_279 : ∀ c : Fin 103, + (edge 279).2 < c → SeedEncoding.indexedAdj (edge 279).1 c → + SeedEncoding.indexedAdj (edge 279).2 c → + triangle (triangleIndex 279 c) = ((edge 279).1,(edge 279).2,c) := by decide +kernel +theorem triangle_complete_280 : ∀ c : Fin 103, + (edge 280).2 < c → SeedEncoding.indexedAdj (edge 280).1 c → + SeedEncoding.indexedAdj (edge 280).2 c → + triangle (triangleIndex 280 c) = ((edge 280).1,(edge 280).2,c) := by decide +kernel +theorem triangle_complete_281 : ∀ c : Fin 103, + (edge 281).2 < c → SeedEncoding.indexedAdj (edge 281).1 c → + SeedEncoding.indexedAdj (edge 281).2 c → + triangle (triangleIndex 281 c) = ((edge 281).1,(edge 281).2,c) := by decide +kernel +theorem triangle_complete_282 : ∀ c : Fin 103, + (edge 282).2 < c → SeedEncoding.indexedAdj (edge 282).1 c → + SeedEncoding.indexedAdj (edge 282).2 c → + triangle (triangleIndex 282 c) = ((edge 282).1,(edge 282).2,c) := by decide +kernel +theorem triangle_complete_283 : ∀ c : Fin 103, + (edge 283).2 < c → SeedEncoding.indexedAdj (edge 283).1 c → + SeedEncoding.indexedAdj (edge 283).2 c → + triangle (triangleIndex 283 c) = ((edge 283).1,(edge 283).2,c) := by decide +kernel +theorem triangle_complete_284 : ∀ c : Fin 103, + (edge 284).2 < c → SeedEncoding.indexedAdj (edge 284).1 c → + SeedEncoding.indexedAdj (edge 284).2 c → + triangle (triangleIndex 284 c) = ((edge 284).1,(edge 284).2,c) := by decide +kernel +theorem triangle_complete_285 : ∀ c : Fin 103, + (edge 285).2 < c → SeedEncoding.indexedAdj (edge 285).1 c → + SeedEncoding.indexedAdj (edge 285).2 c → + triangle (triangleIndex 285 c) = ((edge 285).1,(edge 285).2,c) := by decide +kernel +theorem triangle_complete_286 : ∀ c : Fin 103, + (edge 286).2 < c → SeedEncoding.indexedAdj (edge 286).1 c → + SeedEncoding.indexedAdj (edge 286).2 c → + triangle (triangleIndex 286 c) = ((edge 286).1,(edge 286).2,c) := by decide +kernel +theorem triangle_complete_287 : ∀ c : Fin 103, + (edge 287).2 < c → SeedEncoding.indexedAdj (edge 287).1 c → + SeedEncoding.indexedAdj (edge 287).2 c → + triangle (triangleIndex 287 c) = ((edge 287).1,(edge 287).2,c) := by decide +kernel +theorem triangle_complete_288 : ∀ c : Fin 103, + (edge 288).2 < c → SeedEncoding.indexedAdj (edge 288).1 c → + SeedEncoding.indexedAdj (edge 288).2 c → + triangle (triangleIndex 288 c) = ((edge 288).1,(edge 288).2,c) := by decide +kernel +theorem triangle_complete_289 : ∀ c : Fin 103, + (edge 289).2 < c → SeedEncoding.indexedAdj (edge 289).1 c → + SeedEncoding.indexedAdj (edge 289).2 c → + triangle (triangleIndex 289 c) = ((edge 289).1,(edge 289).2,c) := by decide +kernel +theorem triangle_complete_290 : ∀ c : Fin 103, + (edge 290).2 < c → SeedEncoding.indexedAdj (edge 290).1 c → + SeedEncoding.indexedAdj (edge 290).2 c → + triangle (triangleIndex 290 c) = ((edge 290).1,(edge 290).2,c) := by decide +kernel +theorem triangle_complete_291 : ∀ c : Fin 103, + (edge 291).2 < c → SeedEncoding.indexedAdj (edge 291).1 c → + SeedEncoding.indexedAdj (edge 291).2 c → + triangle (triangleIndex 291 c) = ((edge 291).1,(edge 291).2,c) := by decide +kernel +theorem triangle_complete_292 : ∀ c : Fin 103, + (edge 292).2 < c → SeedEncoding.indexedAdj (edge 292).1 c → + SeedEncoding.indexedAdj (edge 292).2 c → + triangle (triangleIndex 292 c) = ((edge 292).1,(edge 292).2,c) := by decide +kernel +theorem triangle_complete_293 : ∀ c : Fin 103, + (edge 293).2 < c → SeedEncoding.indexedAdj (edge 293).1 c → + SeedEncoding.indexedAdj (edge 293).2 c → + triangle (triangleIndex 293 c) = ((edge 293).1,(edge 293).2,c) := by decide +kernel +theorem triangle_complete_294 : ∀ c : Fin 103, + (edge 294).2 < c → SeedEncoding.indexedAdj (edge 294).1 c → + SeedEncoding.indexedAdj (edge 294).2 c → + triangle (triangleIndex 294 c) = ((edge 294).1,(edge 294).2,c) := by decide +kernel +theorem triangle_complete_295 : ∀ c : Fin 103, + (edge 295).2 < c → SeedEncoding.indexedAdj (edge 295).1 c → + SeedEncoding.indexedAdj (edge 295).2 c → + triangle (triangleIndex 295 c) = ((edge 295).1,(edge 295).2,c) := by decide +kernel +theorem triangle_complete_296 : ∀ c : Fin 103, + (edge 296).2 < c → SeedEncoding.indexedAdj (edge 296).1 c → + SeedEncoding.indexedAdj (edge 296).2 c → + triangle (triangleIndex 296 c) = ((edge 296).1,(edge 296).2,c) := by decide +kernel +theorem triangle_complete_297 : ∀ c : Fin 103, + (edge 297).2 < c → SeedEncoding.indexedAdj (edge 297).1 c → + SeedEncoding.indexedAdj (edge 297).2 c → + triangle (triangleIndex 297 c) = ((edge 297).1,(edge 297).2,c) := by decide +kernel +theorem triangle_complete_298 : ∀ c : Fin 103, + (edge 298).2 < c → SeedEncoding.indexedAdj (edge 298).1 c → + SeedEncoding.indexedAdj (edge 298).2 c → + triangle (triangleIndex 298 c) = ((edge 298).1,(edge 298).2,c) := by decide +kernel +theorem triangle_complete_299 : ∀ c : Fin 103, + (edge 299).2 < c → SeedEncoding.indexedAdj (edge 299).1 c → + SeedEncoding.indexedAdj (edge 299).2 c → + triangle (triangleIndex 299 c) = ((edge 299).1,(edge 299).2,c) := by decide +kernel +theorem triangle_complete_300 : ∀ c : Fin 103, + (edge 300).2 < c → SeedEncoding.indexedAdj (edge 300).1 c → + SeedEncoding.indexedAdj (edge 300).2 c → + triangle (triangleIndex 300 c) = ((edge 300).1,(edge 300).2,c) := by decide +kernel +theorem triangle_complete_301 : ∀ c : Fin 103, + (edge 301).2 < c → SeedEncoding.indexedAdj (edge 301).1 c → + SeedEncoding.indexedAdj (edge 301).2 c → + triangle (triangleIndex 301 c) = ((edge 301).1,(edge 301).2,c) := by decide +kernel +theorem triangle_complete_302 : ∀ c : Fin 103, + (edge 302).2 < c → SeedEncoding.indexedAdj (edge 302).1 c → + SeedEncoding.indexedAdj (edge 302).2 c → + triangle (triangleIndex 302 c) = ((edge 302).1,(edge 302).2,c) := by decide +kernel +theorem triangle_complete_303 : ∀ c : Fin 103, + (edge 303).2 < c → SeedEncoding.indexedAdj (edge 303).1 c → + SeedEncoding.indexedAdj (edge 303).2 c → + triangle (triangleIndex 303 c) = ((edge 303).1,(edge 303).2,c) := by decide +kernel +theorem triangle_complete_304 : ∀ c : Fin 103, + (edge 304).2 < c → SeedEncoding.indexedAdj (edge 304).1 c → + SeedEncoding.indexedAdj (edge 304).2 c → + triangle (triangleIndex 304 c) = ((edge 304).1,(edge 304).2,c) := by decide +kernel +theorem triangle_complete_305 : ∀ c : Fin 103, + (edge 305).2 < c → SeedEncoding.indexedAdj (edge 305).1 c → + SeedEncoding.indexedAdj (edge 305).2 c → + triangle (triangleIndex 305 c) = ((edge 305).1,(edge 305).2,c) := by decide +kernel +theorem triangle_complete_306 : ∀ c : Fin 103, + (edge 306).2 < c → SeedEncoding.indexedAdj (edge 306).1 c → + SeedEncoding.indexedAdj (edge 306).2 c → + triangle (triangleIndex 306 c) = ((edge 306).1,(edge 306).2,c) := by decide +kernel +theorem triangle_complete_307 : ∀ c : Fin 103, + (edge 307).2 < c → SeedEncoding.indexedAdj (edge 307).1 c → + SeedEncoding.indexedAdj (edge 307).2 c → + triangle (triangleIndex 307 c) = ((edge 307).1,(edge 307).2,c) := by decide +kernel +theorem triangle_complete_308 : ∀ c : Fin 103, + (edge 308).2 < c → SeedEncoding.indexedAdj (edge 308).1 c → + SeedEncoding.indexedAdj (edge 308).2 c → + triangle (triangleIndex 308 c) = ((edge 308).1,(edge 308).2,c) := by decide +kernel +theorem triangle_complete_309 : ∀ c : Fin 103, + (edge 309).2 < c → SeedEncoding.indexedAdj (edge 309).1 c → + SeedEncoding.indexedAdj (edge 309).2 c → + triangle (triangleIndex 309 c) = ((edge 309).1,(edge 309).2,c) := by decide +kernel +theorem triangle_complete_310 : ∀ c : Fin 103, + (edge 310).2 < c → SeedEncoding.indexedAdj (edge 310).1 c → + SeedEncoding.indexedAdj (edge 310).2 c → + triangle (triangleIndex 310 c) = ((edge 310).1,(edge 310).2,c) := by decide +kernel +theorem triangle_complete_311 : ∀ c : Fin 103, + (edge 311).2 < c → SeedEncoding.indexedAdj (edge 311).1 c → + SeedEncoding.indexedAdj (edge 311).2 c → + triangle (triangleIndex 311 c) = ((edge 311).1,(edge 311).2,c) := by decide +kernel +theorem triangle_complete_312 : ∀ c : Fin 103, + (edge 312).2 < c → SeedEncoding.indexedAdj (edge 312).1 c → + SeedEncoding.indexedAdj (edge 312).2 c → + triangle (triangleIndex 312 c) = ((edge 312).1,(edge 312).2,c) := by decide +kernel +theorem triangle_complete_313 : ∀ c : Fin 103, + (edge 313).2 < c → SeedEncoding.indexedAdj (edge 313).1 c → + SeedEncoding.indexedAdj (edge 313).2 c → + triangle (triangleIndex 313 c) = ((edge 313).1,(edge 313).2,c) := by decide +kernel +theorem triangle_complete_314 : ∀ c : Fin 103, + (edge 314).2 < c → SeedEncoding.indexedAdj (edge 314).1 c → + SeedEncoding.indexedAdj (edge 314).2 c → + triangle (triangleIndex 314 c) = ((edge 314).1,(edge 314).2,c) := by decide +kernel +theorem triangle_complete_315 : ∀ c : Fin 103, + (edge 315).2 < c → SeedEncoding.indexedAdj (edge 315).1 c → + SeedEncoding.indexedAdj (edge 315).2 c → + triangle (triangleIndex 315 c) = ((edge 315).1,(edge 315).2,c) := by decide +kernel +theorem triangle_complete_316 : ∀ c : Fin 103, + (edge 316).2 < c → SeedEncoding.indexedAdj (edge 316).1 c → + SeedEncoding.indexedAdj (edge 316).2 c → + triangle (triangleIndex 316 c) = ((edge 316).1,(edge 316).2,c) := by decide +kernel +theorem triangle_complete_317 : ∀ c : Fin 103, + (edge 317).2 < c → SeedEncoding.indexedAdj (edge 317).1 c → + SeedEncoding.indexedAdj (edge 317).2 c → + triangle (triangleIndex 317 c) = ((edge 317).1,(edge 317).2,c) := by decide +kernel +theorem triangle_complete_318 : ∀ c : Fin 103, + (edge 318).2 < c → SeedEncoding.indexedAdj (edge 318).1 c → + SeedEncoding.indexedAdj (edge 318).2 c → + triangle (triangleIndex 318 c) = ((edge 318).1,(edge 318).2,c) := by decide +kernel +theorem triangle_complete_319 : ∀ c : Fin 103, + (edge 319).2 < c → SeedEncoding.indexedAdj (edge 319).1 c → + SeedEncoding.indexedAdj (edge 319).2 c → + triangle (triangleIndex 319 c) = ((edge 319).1,(edge 319).2,c) := by decide +kernel +theorem triangle_complete_320 : ∀ c : Fin 103, + (edge 320).2 < c → SeedEncoding.indexedAdj (edge 320).1 c → + SeedEncoding.indexedAdj (edge 320).2 c → + triangle (triangleIndex 320 c) = ((edge 320).1,(edge 320).2,c) := by decide +kernel +theorem triangle_complete_321 : ∀ c : Fin 103, + (edge 321).2 < c → SeedEncoding.indexedAdj (edge 321).1 c → + SeedEncoding.indexedAdj (edge 321).2 c → + triangle (triangleIndex 321 c) = ((edge 321).1,(edge 321).2,c) := by decide +kernel +theorem triangle_complete_322 : ∀ c : Fin 103, + (edge 322).2 < c → SeedEncoding.indexedAdj (edge 322).1 c → + SeedEncoding.indexedAdj (edge 322).2 c → + triangle (triangleIndex 322 c) = ((edge 322).1,(edge 322).2,c) := by decide +kernel +theorem triangle_complete_323 : ∀ c : Fin 103, + (edge 323).2 < c → SeedEncoding.indexedAdj (edge 323).1 c → + SeedEncoding.indexedAdj (edge 323).2 c → + triangle (triangleIndex 323 c) = ((edge 323).1,(edge 323).2,c) := by decide +kernel +theorem triangle_complete_324 : ∀ c : Fin 103, + (edge 324).2 < c → SeedEncoding.indexedAdj (edge 324).1 c → + SeedEncoding.indexedAdj (edge 324).2 c → + triangle (triangleIndex 324 c) = ((edge 324).1,(edge 324).2,c) := by decide +kernel +theorem triangle_complete_325 : ∀ c : Fin 103, + (edge 325).2 < c → SeedEncoding.indexedAdj (edge 325).1 c → + SeedEncoding.indexedAdj (edge 325).2 c → + triangle (triangleIndex 325 c) = ((edge 325).1,(edge 325).2,c) := by decide +kernel +theorem triangle_complete_326 : ∀ c : Fin 103, + (edge 326).2 < c → SeedEncoding.indexedAdj (edge 326).1 c → + SeedEncoding.indexedAdj (edge 326).2 c → + triangle (triangleIndex 326 c) = ((edge 326).1,(edge 326).2,c) := by decide +kernel +theorem triangle_complete_327 : ∀ c : Fin 103, + (edge 327).2 < c → SeedEncoding.indexedAdj (edge 327).1 c → + SeedEncoding.indexedAdj (edge 327).2 c → + triangle (triangleIndex 327 c) = ((edge 327).1,(edge 327).2,c) := by decide +kernel +theorem triangle_complete_328 : ∀ c : Fin 103, + (edge 328).2 < c → SeedEncoding.indexedAdj (edge 328).1 c → + SeedEncoding.indexedAdj (edge 328).2 c → + triangle (triangleIndex 328 c) = ((edge 328).1,(edge 328).2,c) := by decide +kernel +theorem triangle_complete_329 : ∀ c : Fin 103, + (edge 329).2 < c → SeedEncoding.indexedAdj (edge 329).1 c → + SeedEncoding.indexedAdj (edge 329).2 c → + triangle (triangleIndex 329 c) = ((edge 329).1,(edge 329).2,c) := by decide +kernel +theorem triangle_complete_330 : ∀ c : Fin 103, + (edge 330).2 < c → SeedEncoding.indexedAdj (edge 330).1 c → + SeedEncoding.indexedAdj (edge 330).2 c → + triangle (triangleIndex 330 c) = ((edge 330).1,(edge 330).2,c) := by decide +kernel +theorem triangle_complete_331 : ∀ c : Fin 103, + (edge 331).2 < c → SeedEncoding.indexedAdj (edge 331).1 c → + SeedEncoding.indexedAdj (edge 331).2 c → + triangle (triangleIndex 331 c) = ((edge 331).1,(edge 331).2,c) := by decide +kernel +theorem triangle_complete_332 : ∀ c : Fin 103, + (edge 332).2 < c → SeedEncoding.indexedAdj (edge 332).1 c → + SeedEncoding.indexedAdj (edge 332).2 c → + triangle (triangleIndex 332 c) = ((edge 332).1,(edge 332).2,c) := by decide +kernel +theorem triangle_complete_333 : ∀ c : Fin 103, + (edge 333).2 < c → SeedEncoding.indexedAdj (edge 333).1 c → + SeedEncoding.indexedAdj (edge 333).2 c → + triangle (triangleIndex 333 c) = ((edge 333).1,(edge 333).2,c) := by decide +kernel +theorem triangle_complete_334 : ∀ c : Fin 103, + (edge 334).2 < c → SeedEncoding.indexedAdj (edge 334).1 c → + SeedEncoding.indexedAdj (edge 334).2 c → + triangle (triangleIndex 334 c) = ((edge 334).1,(edge 334).2,c) := by decide +kernel +theorem triangle_complete_335 : ∀ c : Fin 103, + (edge 335).2 < c → SeedEncoding.indexedAdj (edge 335).1 c → + SeedEncoding.indexedAdj (edge 335).2 c → + triangle (triangleIndex 335 c) = ((edge 335).1,(edge 335).2,c) := by decide +kernel +theorem triangle_complete_336 : ∀ c : Fin 103, + (edge 336).2 < c → SeedEncoding.indexedAdj (edge 336).1 c → + SeedEncoding.indexedAdj (edge 336).2 c → + triangle (triangleIndex 336 c) = ((edge 336).1,(edge 336).2,c) := by decide +kernel +theorem triangle_complete_337 : ∀ c : Fin 103, + (edge 337).2 < c → SeedEncoding.indexedAdj (edge 337).1 c → + SeedEncoding.indexedAdj (edge 337).2 c → + triangle (triangleIndex 337 c) = ((edge 337).1,(edge 337).2,c) := by decide +kernel +theorem triangle_complete_338 : ∀ c : Fin 103, + (edge 338).2 < c → SeedEncoding.indexedAdj (edge 338).1 c → + SeedEncoding.indexedAdj (edge 338).2 c → + triangle (triangleIndex 338 c) = ((edge 338).1,(edge 338).2,c) := by decide +kernel +theorem triangle_complete_339 : ∀ c : Fin 103, + (edge 339).2 < c → SeedEncoding.indexedAdj (edge 339).1 c → + SeedEncoding.indexedAdj (edge 339).2 c → + triangle (triangleIndex 339 c) = ((edge 339).1,(edge 339).2,c) := by decide +kernel +theorem triangle_complete_340 : ∀ c : Fin 103, + (edge 340).2 < c → SeedEncoding.indexedAdj (edge 340).1 c → + SeedEncoding.indexedAdj (edge 340).2 c → + triangle (triangleIndex 340 c) = ((edge 340).1,(edge 340).2,c) := by decide +kernel +theorem triangle_complete_341 : ∀ c : Fin 103, + (edge 341).2 < c → SeedEncoding.indexedAdj (edge 341).1 c → + SeedEncoding.indexedAdj (edge 341).2 c → + triangle (triangleIndex 341 c) = ((edge 341).1,(edge 341).2,c) := by decide +kernel +theorem triangle_complete_342 : ∀ c : Fin 103, + (edge 342).2 < c → SeedEncoding.indexedAdj (edge 342).1 c → + SeedEncoding.indexedAdj (edge 342).2 c → + triangle (triangleIndex 342 c) = ((edge 342).1,(edge 342).2,c) := by decide +kernel +theorem triangle_complete_343 : ∀ c : Fin 103, + (edge 343).2 < c → SeedEncoding.indexedAdj (edge 343).1 c → + SeedEncoding.indexedAdj (edge 343).2 c → + triangle (triangleIndex 343 c) = ((edge 343).1,(edge 343).2,c) := by decide +kernel +theorem triangle_complete_344 : ∀ c : Fin 103, + (edge 344).2 < c → SeedEncoding.indexedAdj (edge 344).1 c → + SeedEncoding.indexedAdj (edge 344).2 c → + triangle (triangleIndex 344 c) = ((edge 344).1,(edge 344).2,c) := by decide +kernel +theorem triangle_complete_345 : ∀ c : Fin 103, + (edge 345).2 < c → SeedEncoding.indexedAdj (edge 345).1 c → + SeedEncoding.indexedAdj (edge 345).2 c → + triangle (triangleIndex 345 c) = ((edge 345).1,(edge 345).2,c) := by decide +kernel +theorem triangle_complete_346 : ∀ c : Fin 103, + (edge 346).2 < c → SeedEncoding.indexedAdj (edge 346).1 c → + SeedEncoding.indexedAdj (edge 346).2 c → + triangle (triangleIndex 346 c) = ((edge 346).1,(edge 346).2,c) := by decide +kernel +theorem triangle_complete_347 : ∀ c : Fin 103, + (edge 347).2 < c → SeedEncoding.indexedAdj (edge 347).1 c → + SeedEncoding.indexedAdj (edge 347).2 c → + triangle (triangleIndex 347 c) = ((edge 347).1,(edge 347).2,c) := by decide +kernel +theorem triangle_complete_348 : ∀ c : Fin 103, + (edge 348).2 < c → SeedEncoding.indexedAdj (edge 348).1 c → + SeedEncoding.indexedAdj (edge 348).2 c → + triangle (triangleIndex 348 c) = ((edge 348).1,(edge 348).2,c) := by decide +kernel +theorem triangle_complete_349 : ∀ c : Fin 103, + (edge 349).2 < c → SeedEncoding.indexedAdj (edge 349).1 c → + SeedEncoding.indexedAdj (edge 349).2 c → + triangle (triangleIndex 349 c) = ((edge 349).1,(edge 349).2,c) := by decide +kernel +theorem triangle_complete_350 : ∀ c : Fin 103, + (edge 350).2 < c → SeedEncoding.indexedAdj (edge 350).1 c → + SeedEncoding.indexedAdj (edge 350).2 c → + triangle (triangleIndex 350 c) = ((edge 350).1,(edge 350).2,c) := by decide +kernel +theorem triangle_complete_351 : ∀ c : Fin 103, + (edge 351).2 < c → SeedEncoding.indexedAdj (edge 351).1 c → + SeedEncoding.indexedAdj (edge 351).2 c → + triangle (triangleIndex 351 c) = ((edge 351).1,(edge 351).2,c) := by decide +kernel +theorem triangle_complete_352 : ∀ c : Fin 103, + (edge 352).2 < c → SeedEncoding.indexedAdj (edge 352).1 c → + SeedEncoding.indexedAdj (edge 352).2 c → + triangle (triangleIndex 352 c) = ((edge 352).1,(edge 352).2,c) := by decide +kernel +theorem triangle_complete_353 : ∀ c : Fin 103, + (edge 353).2 < c → SeedEncoding.indexedAdj (edge 353).1 c → + SeedEncoding.indexedAdj (edge 353).2 c → + triangle (triangleIndex 353 c) = ((edge 353).1,(edge 353).2,c) := by decide +kernel +theorem triangle_complete_354 : ∀ c : Fin 103, + (edge 354).2 < c → SeedEncoding.indexedAdj (edge 354).1 c → + SeedEncoding.indexedAdj (edge 354).2 c → + triangle (triangleIndex 354 c) = ((edge 354).1,(edge 354).2,c) := by decide +kernel +theorem triangle_complete_355 : ∀ c : Fin 103, + (edge 355).2 < c → SeedEncoding.indexedAdj (edge 355).1 c → + SeedEncoding.indexedAdj (edge 355).2 c → + triangle (triangleIndex 355 c) = ((edge 355).1,(edge 355).2,c) := by decide +kernel +theorem triangle_complete_356 : ∀ c : Fin 103, + (edge 356).2 < c → SeedEncoding.indexedAdj (edge 356).1 c → + SeedEncoding.indexedAdj (edge 356).2 c → + triangle (triangleIndex 356 c) = ((edge 356).1,(edge 356).2,c) := by decide +kernel +theorem triangle_complete_357 : ∀ c : Fin 103, + (edge 357).2 < c → SeedEncoding.indexedAdj (edge 357).1 c → + SeedEncoding.indexedAdj (edge 357).2 c → + triangle (triangleIndex 357 c) = ((edge 357).1,(edge 357).2,c) := by decide +kernel +theorem triangle_complete_358 : ∀ c : Fin 103, + (edge 358).2 < c → SeedEncoding.indexedAdj (edge 358).1 c → + SeedEncoding.indexedAdj (edge 358).2 c → + triangle (triangleIndex 358 c) = ((edge 358).1,(edge 358).2,c) := by decide +kernel +theorem triangle_complete_359 : ∀ c : Fin 103, + (edge 359).2 < c → SeedEncoding.indexedAdj (edge 359).1 c → + SeedEncoding.indexedAdj (edge 359).2 c → + triangle (triangleIndex 359 c) = ((edge 359).1,(edge 359).2,c) := by decide +kernel +theorem triangle_complete_360 : ∀ c : Fin 103, + (edge 360).2 < c → SeedEncoding.indexedAdj (edge 360).1 c → + SeedEncoding.indexedAdj (edge 360).2 c → + triangle (triangleIndex 360 c) = ((edge 360).1,(edge 360).2,c) := by decide +kernel +theorem triangle_complete_361 : ∀ c : Fin 103, + (edge 361).2 < c → SeedEncoding.indexedAdj (edge 361).1 c → + SeedEncoding.indexedAdj (edge 361).2 c → + triangle (triangleIndex 361 c) = ((edge 361).1,(edge 361).2,c) := by decide +kernel +theorem triangle_complete_362 : ∀ c : Fin 103, + (edge 362).2 < c → SeedEncoding.indexedAdj (edge 362).1 c → + SeedEncoding.indexedAdj (edge 362).2 c → + triangle (triangleIndex 362 c) = ((edge 362).1,(edge 362).2,c) := by decide +kernel +theorem triangle_complete_363 : ∀ c : Fin 103, + (edge 363).2 < c → SeedEncoding.indexedAdj (edge 363).1 c → + SeedEncoding.indexedAdj (edge 363).2 c → + triangle (triangleIndex 363 c) = ((edge 363).1,(edge 363).2,c) := by decide +kernel +theorem triangle_complete_364 : ∀ c : Fin 103, + (edge 364).2 < c → SeedEncoding.indexedAdj (edge 364).1 c → + SeedEncoding.indexedAdj (edge 364).2 c → + triangle (triangleIndex 364 c) = ((edge 364).1,(edge 364).2,c) := by decide +kernel +theorem triangle_complete_365 : ∀ c : Fin 103, + (edge 365).2 < c → SeedEncoding.indexedAdj (edge 365).1 c → + SeedEncoding.indexedAdj (edge 365).2 c → + triangle (triangleIndex 365 c) = ((edge 365).1,(edge 365).2,c) := by decide +kernel +theorem triangle_complete_366 : ∀ c : Fin 103, + (edge 366).2 < c → SeedEncoding.indexedAdj (edge 366).1 c → + SeedEncoding.indexedAdj (edge 366).2 c → + triangle (triangleIndex 366 c) = ((edge 366).1,(edge 366).2,c) := by decide +kernel +theorem triangle_complete_367 : ∀ c : Fin 103, + (edge 367).2 < c → SeedEncoding.indexedAdj (edge 367).1 c → + SeedEncoding.indexedAdj (edge 367).2 c → + triangle (triangleIndex 367 c) = ((edge 367).1,(edge 367).2,c) := by decide +kernel +theorem triangle_complete_368 : ∀ c : Fin 103, + (edge 368).2 < c → SeedEncoding.indexedAdj (edge 368).1 c → + SeedEncoding.indexedAdj (edge 368).2 c → + triangle (triangleIndex 368 c) = ((edge 368).1,(edge 368).2,c) := by decide +kernel +theorem triangle_complete_369 : ∀ c : Fin 103, + (edge 369).2 < c → SeedEncoding.indexedAdj (edge 369).1 c → + SeedEncoding.indexedAdj (edge 369).2 c → + triangle (triangleIndex 369 c) = ((edge 369).1,(edge 369).2,c) := by decide +kernel +theorem triangle_complete_370 : ∀ c : Fin 103, + (edge 370).2 < c → SeedEncoding.indexedAdj (edge 370).1 c → + SeedEncoding.indexedAdj (edge 370).2 c → + triangle (triangleIndex 370 c) = ((edge 370).1,(edge 370).2,c) := by decide +kernel +theorem triangle_complete_371 : ∀ c : Fin 103, + (edge 371).2 < c → SeedEncoding.indexedAdj (edge 371).1 c → + SeedEncoding.indexedAdj (edge 371).2 c → + triangle (triangleIndex 371 c) = ((edge 371).1,(edge 371).2,c) := by decide +kernel +theorem edge_valid : ∀ e : Fin 372, + (edge e).1 < (edge e).2 ∧ SeedEncoding.indexedAdj (edge e).1 (edge e).2 := by decide +kernel + +theorem edge_index_inverse : ∀ e : Fin 372, edgeIndex (edge e).1 (edge e).2 = e := by decide +kernel + +theorem triangle_valid : ∀ t : Fin 270, + (triangle t).1 < (triangle t).2.1 ∧ (triangle t).2.1 < (triangle t).2.2 ∧ + SeedEncoding.indexedAdj (triangle t).1 (triangle t).2.1 ∧ + SeedEncoding.indexedAdj (triangle t).1 (triangle t).2.2 ∧ + SeedEncoding.indexedAdj (triangle t).2.1 (triangle t).2.2 := by decide +kernel + +theorem triangle_edges_valid : ∀ t : Fin 270, + edge (triangleEdges t).1 = ((triangle t).2.1,(triangle t).2.2) ∧ + edge (triangleEdges t).2.1 = ((triangle t).1,(triangle t).2.2) ∧ + edge (triangleEdges t).2.2 = ((triangle t).1,(triangle t).2.1) := by decide +kernel + +theorem triangle_index_inverse : ∀ t : Fin 270, + triangleIndex (edgeIndex (triangle t).1 (triangle t).2.1) (triangle t).2.2 = t := by decide +kernel +theorem edge_complete (a b : Fin 103) : a < b → SeedEncoding.indexedAdj a b → + edge (edgeIndex a b) = (a,b) := by + fin_cases a + · exact edge_complete_0 b + · exact edge_complete_1 b + · exact edge_complete_2 b + · exact edge_complete_3 b + · exact edge_complete_4 b + · exact edge_complete_5 b + · exact edge_complete_6 b + · exact edge_complete_7 b + · exact edge_complete_8 b + · exact edge_complete_9 b + · exact edge_complete_10 b + · exact edge_complete_11 b + · exact edge_complete_12 b + · exact edge_complete_13 b + · exact edge_complete_14 b + · exact edge_complete_15 b + · exact edge_complete_16 b + · exact edge_complete_17 b + · exact edge_complete_18 b + · exact edge_complete_19 b + · exact edge_complete_20 b + · exact edge_complete_21 b + · exact edge_complete_22 b + · exact edge_complete_23 b + · exact edge_complete_24 b + · exact edge_complete_25 b + · exact edge_complete_26 b + · exact edge_complete_27 b + · exact edge_complete_28 b + · exact edge_complete_29 b + · exact edge_complete_30 b + · exact edge_complete_31 b + · exact edge_complete_32 b + · exact edge_complete_33 b + · exact edge_complete_34 b + · exact edge_complete_35 b + · exact edge_complete_36 b + · exact edge_complete_37 b + · exact edge_complete_38 b + · exact edge_complete_39 b + · exact edge_complete_40 b + · exact edge_complete_41 b + · exact edge_complete_42 b + · exact edge_complete_43 b + · exact edge_complete_44 b + · exact edge_complete_45 b + · exact edge_complete_46 b + · exact edge_complete_47 b + · exact edge_complete_48 b + · exact edge_complete_49 b + · exact edge_complete_50 b + · exact edge_complete_51 b + · exact edge_complete_52 b + · exact edge_complete_53 b + · exact edge_complete_54 b + · exact edge_complete_55 b + · exact edge_complete_56 b + · exact edge_complete_57 b + · exact edge_complete_58 b + · exact edge_complete_59 b + · exact edge_complete_60 b + · exact edge_complete_61 b + · exact edge_complete_62 b + · exact edge_complete_63 b + · exact edge_complete_64 b + · exact edge_complete_65 b + · exact edge_complete_66 b + · exact edge_complete_67 b + · exact edge_complete_68 b + · exact edge_complete_69 b + · exact edge_complete_70 b + · exact edge_complete_71 b + · exact edge_complete_72 b + · exact edge_complete_73 b + · exact edge_complete_74 b + · exact edge_complete_75 b + · exact edge_complete_76 b + · exact edge_complete_77 b + · exact edge_complete_78 b + · exact edge_complete_79 b + · exact edge_complete_80 b + · exact edge_complete_81 b + · exact edge_complete_82 b + · exact edge_complete_83 b + · exact edge_complete_84 b + · exact edge_complete_85 b + · exact edge_complete_86 b + · exact edge_complete_87 b + · exact edge_complete_88 b + · exact edge_complete_89 b + · exact edge_complete_90 b + · exact edge_complete_91 b + · exact edge_complete_92 b + · exact edge_complete_93 b + · exact edge_complete_94 b + · exact edge_complete_95 b + · exact edge_complete_96 b + · exact edge_complete_97 b + · exact edge_complete_98 b + · exact edge_complete_99 b + · exact edge_complete_100 b + · exact edge_complete_101 b + · exact edge_complete_102 b +theorem triangle_complete (e : Fin 372) (c : Fin 103) : + (edge e).2 < c → SeedEncoding.indexedAdj (edge e).1 c → + SeedEncoding.indexedAdj (edge e).2 c → + triangle (triangleIndex e c) = ((edge e).1,(edge e).2,c) := by + fin_cases e + · exact triangle_complete_0 c + · exact triangle_complete_1 c + · exact triangle_complete_2 c + · exact triangle_complete_3 c + · exact triangle_complete_4 c + · exact triangle_complete_5 c + · exact triangle_complete_6 c + · exact triangle_complete_7 c + · exact triangle_complete_8 c + · exact triangle_complete_9 c + · exact triangle_complete_10 c + · exact triangle_complete_11 c + · exact triangle_complete_12 c + · exact triangle_complete_13 c + · exact triangle_complete_14 c + · exact triangle_complete_15 c + · exact triangle_complete_16 c + · exact triangle_complete_17 c + · exact triangle_complete_18 c + · exact triangle_complete_19 c + · exact triangle_complete_20 c + · exact triangle_complete_21 c + · exact triangle_complete_22 c + · exact triangle_complete_23 c + · exact triangle_complete_24 c + · exact triangle_complete_25 c + · exact triangle_complete_26 c + · exact triangle_complete_27 c + · exact triangle_complete_28 c + · exact triangle_complete_29 c + · exact triangle_complete_30 c + · exact triangle_complete_31 c + · exact triangle_complete_32 c + · exact triangle_complete_33 c + · exact triangle_complete_34 c + · exact triangle_complete_35 c + · exact triangle_complete_36 c + · exact triangle_complete_37 c + · exact triangle_complete_38 c + · exact triangle_complete_39 c + · exact triangle_complete_40 c + · exact triangle_complete_41 c + · exact triangle_complete_42 c + · exact triangle_complete_43 c + · exact triangle_complete_44 c + · exact triangle_complete_45 c + · exact triangle_complete_46 c + · exact triangle_complete_47 c + · exact triangle_complete_48 c + · exact triangle_complete_49 c + · exact triangle_complete_50 c + · exact triangle_complete_51 c + · exact triangle_complete_52 c + · exact triangle_complete_53 c + · exact triangle_complete_54 c + · exact triangle_complete_55 c + · exact triangle_complete_56 c + · exact triangle_complete_57 c + · exact triangle_complete_58 c + · exact triangle_complete_59 c + · exact triangle_complete_60 c + · exact triangle_complete_61 c + · exact triangle_complete_62 c + · exact triangle_complete_63 c + · exact triangle_complete_64 c + · exact triangle_complete_65 c + · exact triangle_complete_66 c + · exact triangle_complete_67 c + · exact triangle_complete_68 c + · exact triangle_complete_69 c + · exact triangle_complete_70 c + · exact triangle_complete_71 c + · exact triangle_complete_72 c + · exact triangle_complete_73 c + · exact triangle_complete_74 c + · exact triangle_complete_75 c + · exact triangle_complete_76 c + · exact triangle_complete_77 c + · exact triangle_complete_78 c + · exact triangle_complete_79 c + · exact triangle_complete_80 c + · exact triangle_complete_81 c + · exact triangle_complete_82 c + · exact triangle_complete_83 c + · exact triangle_complete_84 c + · exact triangle_complete_85 c + · exact triangle_complete_86 c + · exact triangle_complete_87 c + · exact triangle_complete_88 c + · exact triangle_complete_89 c + · exact triangle_complete_90 c + · exact triangle_complete_91 c + · exact triangle_complete_92 c + · exact triangle_complete_93 c + · exact triangle_complete_94 c + · exact triangle_complete_95 c + · exact triangle_complete_96 c + · exact triangle_complete_97 c + · exact triangle_complete_98 c + · exact triangle_complete_99 c + · exact triangle_complete_100 c + · exact triangle_complete_101 c + · exact triangle_complete_102 c + · exact triangle_complete_103 c + · exact triangle_complete_104 c + · exact triangle_complete_105 c + · exact triangle_complete_106 c + · exact triangle_complete_107 c + · exact triangle_complete_108 c + · exact triangle_complete_109 c + · exact triangle_complete_110 c + · exact triangle_complete_111 c + · exact triangle_complete_112 c + · exact triangle_complete_113 c + · exact triangle_complete_114 c + · exact triangle_complete_115 c + · exact triangle_complete_116 c + · exact triangle_complete_117 c + · exact triangle_complete_118 c + · exact triangle_complete_119 c + · exact triangle_complete_120 c + · exact triangle_complete_121 c + · exact triangle_complete_122 c + · exact triangle_complete_123 c + · exact triangle_complete_124 c + · exact triangle_complete_125 c + · exact triangle_complete_126 c + · exact triangle_complete_127 c + · exact triangle_complete_128 c + · exact triangle_complete_129 c + · exact triangle_complete_130 c + · exact triangle_complete_131 c + · exact triangle_complete_132 c + · exact triangle_complete_133 c + · exact triangle_complete_134 c + · exact triangle_complete_135 c + · exact triangle_complete_136 c + · exact triangle_complete_137 c + · exact triangle_complete_138 c + · exact triangle_complete_139 c + · exact triangle_complete_140 c + · exact triangle_complete_141 c + · exact triangle_complete_142 c + · exact triangle_complete_143 c + · exact triangle_complete_144 c + · exact triangle_complete_145 c + · exact triangle_complete_146 c + · exact triangle_complete_147 c + · exact triangle_complete_148 c + · exact triangle_complete_149 c + · exact triangle_complete_150 c + · exact triangle_complete_151 c + · exact triangle_complete_152 c + · exact triangle_complete_153 c + · exact triangle_complete_154 c + · exact triangle_complete_155 c + · exact triangle_complete_156 c + · exact triangle_complete_157 c + · exact triangle_complete_158 c + · exact triangle_complete_159 c + · exact triangle_complete_160 c + · exact triangle_complete_161 c + · exact triangle_complete_162 c + · exact triangle_complete_163 c + · exact triangle_complete_164 c + · exact triangle_complete_165 c + · exact triangle_complete_166 c + · exact triangle_complete_167 c + · exact triangle_complete_168 c + · exact triangle_complete_169 c + · exact triangle_complete_170 c + · exact triangle_complete_171 c + · exact triangle_complete_172 c + · exact triangle_complete_173 c + · exact triangle_complete_174 c + · exact triangle_complete_175 c + · exact triangle_complete_176 c + · exact triangle_complete_177 c + · exact triangle_complete_178 c + · exact triangle_complete_179 c + · exact triangle_complete_180 c + · exact triangle_complete_181 c + · exact triangle_complete_182 c + · exact triangle_complete_183 c + · exact triangle_complete_184 c + · exact triangle_complete_185 c + · exact triangle_complete_186 c + · exact triangle_complete_187 c + · exact triangle_complete_188 c + · exact triangle_complete_189 c + · exact triangle_complete_190 c + · exact triangle_complete_191 c + · exact triangle_complete_192 c + · exact triangle_complete_193 c + · exact triangle_complete_194 c + · exact triangle_complete_195 c + · exact triangle_complete_196 c + · exact triangle_complete_197 c + · exact triangle_complete_198 c + · exact triangle_complete_199 c + · exact triangle_complete_200 c + · exact triangle_complete_201 c + · exact triangle_complete_202 c + · exact triangle_complete_203 c + · exact triangle_complete_204 c + · exact triangle_complete_205 c + · exact triangle_complete_206 c + · exact triangle_complete_207 c + · exact triangle_complete_208 c + · exact triangle_complete_209 c + · exact triangle_complete_210 c + · exact triangle_complete_211 c + · exact triangle_complete_212 c + · exact triangle_complete_213 c + · exact triangle_complete_214 c + · exact triangle_complete_215 c + · exact triangle_complete_216 c + · exact triangle_complete_217 c + · exact triangle_complete_218 c + · exact triangle_complete_219 c + · exact triangle_complete_220 c + · exact triangle_complete_221 c + · exact triangle_complete_222 c + · exact triangle_complete_223 c + · exact triangle_complete_224 c + · exact triangle_complete_225 c + · exact triangle_complete_226 c + · exact triangle_complete_227 c + · exact triangle_complete_228 c + · exact triangle_complete_229 c + · exact triangle_complete_230 c + · exact triangle_complete_231 c + · exact triangle_complete_232 c + · exact triangle_complete_233 c + · exact triangle_complete_234 c + · exact triangle_complete_235 c + · exact triangle_complete_236 c + · exact triangle_complete_237 c + · exact triangle_complete_238 c + · exact triangle_complete_239 c + · exact triangle_complete_240 c + · exact triangle_complete_241 c + · exact triangle_complete_242 c + · exact triangle_complete_243 c + · exact triangle_complete_244 c + · exact triangle_complete_245 c + · exact triangle_complete_246 c + · exact triangle_complete_247 c + · exact triangle_complete_248 c + · exact triangle_complete_249 c + · exact triangle_complete_250 c + · exact triangle_complete_251 c + · exact triangle_complete_252 c + · exact triangle_complete_253 c + · exact triangle_complete_254 c + · exact triangle_complete_255 c + · exact triangle_complete_256 c + · exact triangle_complete_257 c + · exact triangle_complete_258 c + · exact triangle_complete_259 c + · exact triangle_complete_260 c + · exact triangle_complete_261 c + · exact triangle_complete_262 c + · exact triangle_complete_263 c + · exact triangle_complete_264 c + · exact triangle_complete_265 c + · exact triangle_complete_266 c + · exact triangle_complete_267 c + · exact triangle_complete_268 c + · exact triangle_complete_269 c + · exact triangle_complete_270 c + · exact triangle_complete_271 c + · exact triangle_complete_272 c + · exact triangle_complete_273 c + · exact triangle_complete_274 c + · exact triangle_complete_275 c + · exact triangle_complete_276 c + · exact triangle_complete_277 c + · exact triangle_complete_278 c + · exact triangle_complete_279 c + · exact triangle_complete_280 c + · exact triangle_complete_281 c + · exact triangle_complete_282 c + · exact triangle_complete_283 c + · exact triangle_complete_284 c + · exact triangle_complete_285 c + · exact triangle_complete_286 c + · exact triangle_complete_287 c + · exact triangle_complete_288 c + · exact triangle_complete_289 c + · exact triangle_complete_290 c + · exact triangle_complete_291 c + · exact triangle_complete_292 c + · exact triangle_complete_293 c + · exact triangle_complete_294 c + · exact triangle_complete_295 c + · exact triangle_complete_296 c + · exact triangle_complete_297 c + · exact triangle_complete_298 c + · exact triangle_complete_299 c + · exact triangle_complete_300 c + · exact triangle_complete_301 c + · exact triangle_complete_302 c + · exact triangle_complete_303 c + · exact triangle_complete_304 c + · exact triangle_complete_305 c + · exact triangle_complete_306 c + · exact triangle_complete_307 c + · exact triangle_complete_308 c + · exact triangle_complete_309 c + · exact triangle_complete_310 c + · exact triangle_complete_311 c + · exact triangle_complete_312 c + · exact triangle_complete_313 c + · exact triangle_complete_314 c + · exact triangle_complete_315 c + · exact triangle_complete_316 c + · exact triangle_complete_317 c + · exact triangle_complete_318 c + · exact triangle_complete_319 c + · exact triangle_complete_320 c + · exact triangle_complete_321 c + · exact triangle_complete_322 c + · exact triangle_complete_323 c + · exact triangle_complete_324 c + · exact triangle_complete_325 c + · exact triangle_complete_326 c + · exact triangle_complete_327 c + · exact triangle_complete_328 c + · exact triangle_complete_329 c + · exact triangle_complete_330 c + · exact triangle_complete_331 c + · exact triangle_complete_332 c + · exact triangle_complete_333 c + · exact triangle_complete_334 c + · exact triangle_complete_335 c + · exact triangle_complete_336 c + · exact triangle_complete_337 c + · exact triangle_complete_338 c + · exact triangle_complete_339 c + · exact triangle_complete_340 c + · exact triangle_complete_341 c + · exact triangle_complete_342 c + · exact triangle_complete_343 c + · exact triangle_complete_344 c + · exact triangle_complete_345 c + · exact triangle_complete_346 c + · exact triangle_complete_347 c + · exact triangle_complete_348 c + · exact triangle_complete_349 c + · exact triangle_complete_350 c + · exact triangle_complete_351 c + · exact triangle_complete_352 c + · exact triangle_complete_353 c + · exact triangle_complete_354 c + · exact triangle_complete_355 c + · exact triangle_complete_356 c + · exact triangle_complete_357 c + · exact triangle_complete_358 c + · exact triangle_complete_359 c + · exact triangle_complete_360 c + · exact triangle_complete_361 c + · exact triangle_complete_362 c + · exact triangle_complete_363 c + · exact triangle_complete_364 c + · exact triangle_complete_365 c + · exact triangle_complete_366 c + · exact triangle_complete_367 c + · exact triangle_complete_368 c + · exact triangle_complete_369 c + · exact triangle_complete_370 c + · exact triangle_complete_371 c +def rankIndex (a : Fin 103) : Fin 3 := if a.val < 7 then 0 else if a.val < 58 then 1 else 2 + theorem sorted_adj_rank : ∀ a b : Fin 103, a < b → SeedEncoding.indexedAdj a b → + rankIndex a < rankIndex b := by decide +kernel +end EilenbergGanea.SeedChainCertificate +namespace EilenbergGanea.SeedChainCertificate +open SimplicialChains + +def graph : SimpleGraph (Fin 103) := seedGraph.comap SeedEncoding.cellAt +@[simp] theorem graph_adj (a b : Fin 103) : graph.Adj a b ↔ SeedEncoding.indexedAdj a b := + SeedEncoding.adjacency_certificate a b + + theorem valid_pair_iff (a b : Fin 103) : + Valid graph [a,b] ↔ a < b ∧ SeedEncoding.indexedAdj a b := by simp [Valid] + theorem valid_triple_iff (a b c : Fin 103) : + Valid graph [a,b,c] ↔ a < b ∧ b < c ∧ SeedEncoding.indexedAdj a b ∧ + SeedEncoding.indexedAdj a c ∧ SeedEncoding.indexedAdj b c := by + simp [Valid] + constructor + · rintro ⟨⟨⟨hab,_⟩,hbc⟩,⟨⟨h₁,h₂⟩,h₃⟩⟩ + exact ⟨hab,hbc,h₁,h₂,h₃⟩ + · rintro ⟨hab,hbc,h₁,h₂,h₃⟩ + exact ⟨⟨⟨hab,hab.trans hbc⟩,hbc⟩,⟨⟨h₁,h₂⟩,h₃⟩⟩ + + theorem valid_length_le (w : List (Fin 103)) (hw : Valid graph w) : w.length ≤ 3 := by + have hp : w.Pairwise (fun a b => rankIndex a < rankIndex b) := by + have hh := hw.1.and hw.2 + exact hh.imp (fun {a b} h => sorted_adj_rank a b h.1 ((graph_adj a b).mp h.2)) + have hn : (w.map rankIndex).Nodup := by + apply List.nodup_iff_pairwise_ne.mpr + rw [List.pairwise_map] + exact hp.imp (fun {_ _} h => ne_of_lt h) + have he := hn.length_le_card + simpa using he + + def indices : TwoDimensionalIndices (L := graph) (Fin 372) (Fin 270) where + edge := edge + triangle := triangle + face := triangleEdges + edgeIndex := edgeIndex + triangleIndex := fun a b c => triangleIndex (edgeIndex a b) c + edge_valid := fun e => (valid_pair_iff _ _).mpr (edge_valid e) + triangle_valid := fun t => (valid_triple_iff _ _ _).mpr (triangle_valid t) + edge_inverse := edge_index_inverse + edge_complete := fun a b h => edge_complete a b ((valid_pair_iff a b).mp h).1 + ((valid_pair_iff a b).mp h).2 + triangle_complete := by + intro a b c h + obtain ⟨hab,hbc,h₁,h₂,h₃⟩ := (valid_triple_iff a b c).mp h + have he := edge_complete a b hab h₁ + have ht := triangle_complete (edgeIndex a b) c + rw [he] at ht + exact ht hbc h₂ h₃ + face_edge := triangle_edges_valid + length_le := valid_length_le + +end EilenbergGanea.SeedChainCertificate + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/SeedConnection.lean b/lean/OAI/Topology/EilenbergGanea/SeedConnection.lean new file mode 100644 index 0000000000000000000000000000000000000000..9f4f8b3b7b19c10a717c08f88899ee8354e89805 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/SeedConnection.lean @@ -0,0 +1,277 @@ +import OAI.Topology.EilenbergGanea.SeedHolonomy +import OAI.GroupTheory.RightAngledArtin.Basic + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea +namespace SeedConnection + +def circleWord (e : CircleEdge) : FreeGroup Bool := if e.2 = 0 then FreeGroup.of e.1 else 1 + +def boundaryEdgeWord (s : Sector) : FreeGroup Bool := + if (sectorLetter s).2 then circleWord (sectorCircleEdge s) else + (circleWord (sectorCircleEdge s))⁻¹ + +def boundaryWords (r : Bool) : List (FreeGroup Bool) := + List.ofFn (fun i : Fin (boundaryLength r) => boundaryEdgeWord ⟨r,i⟩) + +theorem boundaryWords_prod : ∀ r, (boundaryWords r).prod = seedRelator r := by + decide + +theorem sector_end : ∀ s : Sector, sectorStart (nextSector s) = + if (sectorLetter s).2 then circleEnd (sectorCircleEdge s) + else circleStart (sectorCircleEdge s) := by decide + +theorem circle_distinct : ∀ e : CircleEdge, circleStart e ≠ circleEnd e := by decide + +theorem sector_distinct : ∀ s : Sector, sectorStart s ≠ sectorStart (nextSector s) := by decide + +def circleLabel (e : CircleEdge) : SeedSU2 := FreeGroup.lift seedLetterUnit (circleWord e) + +def radialLabel (s : Sector) : SeedSU2 := + FreeGroup.lift seedLetterUnit ((boundaryWords s.1).take s.2.val).prod + +@[simp] theorem boundaryWords_length (r : Bool) : (boundaryWords r).length = boundaryLength r := + List.length_ofFn + +@[simp] theorem boundaryWords_get (s : Sector) : + (boundaryWords s.1)[s.2.val]'(by simp) = boundaryEdgeWord s := by + simp [boundaryWords] + +theorem radial_step (s : Sector) : radialLabel (nextSector s) = radialLabel s * + (if (sectorLetter s).2 then circleLabel (sectorCircleEdge s) + else (circleLabel (sectorCircleEdge s))⁻¹) := by + have hs : s.2.val < (boundaryWords s.1).length := by simp + have he := congrArg (FreeGroup.lift seedLetterUnit) (congrArg List.prod + (List.take_succ_eq_append_getElem hs)) + rw [List.prod_append,List.prod_singleton,map_mul,boundaryWords_get] at he + have hf : FreeGroup.lift seedLetterUnit (boundaryEdgeWord s) = + if (sectorLetter s).2 then circleLabel (sectorCircleEdge s) + else (circleLabel (sectorCircleEdge s))⁻¹ := by + unfold boundaryEdgeWord circleLabel + split <;> simp + rw [hf] at he + change radialLabel (nextSector s) = + FreeGroup.lift seedLetterUnit ((boundaryWords s.1).take s.2.val).prod * _ + rw [← he] + unfold radialLabel nextSector + dsimp only + by_cases hn : s.2.val + 1 < boundaryLength s.1 + · rw [Nat.mod_eq_of_lt hn] + · have hn' : s.2.val + 1 = boundaryLength s.1 := by have hh := s.2.isLt; omega + rw [hn',Nat.mod_self,List.take_zero,List.prod_nil,map_one, + ← boundaryWords_length,List.take_length,boundaryWords_prod,seedRelator_unit] + +def edgeAnchor : SeedEdge → SeedVertex + | .inl e => .inl (circleStart e) + | .inr s => .inr s.1 + +def edgeLocal : SeedEdge → SeedVertex → SeedSU2 + | .inl e, v => if v = .inl (circleStart e) then 1 else circleLabel e + | .inr s, v => if v = .inr s.1 then 1 else radialLabel s + +def faceLocal (s : Sector) (v : SeedVertex) : SeedSU2 := + if v = .inr s.1 then 1 else + if v = .inl (sectorStart s) then radialLabel s else radialLabel (nextSector s) + +theorem edgeLocal_anchor (e : SeedEdge) : edgeLocal e (edgeAnchor e) = 1 := by + cases e <;> simp [edgeLocal,edgeAnchor] + +theorem nextSector_first (s : Sector) : (nextSector s).1 = s.1 := rfl + +theorem faceLocal_incidence (s : Sector) (e : SeedEdge) (he : e ∈ sectorEdges s) + (v : SeedVertex) (hv : v ∈ edgeVertices e) : + faceLocal s v = faceLocal s (edgeAnchor e) * edgeLocal e v := by + simp only [sectorEdges,Finset.mem_insert,Finset.mem_singleton] at he + rcases he with rfl | rfl | rfl + · simp only [edgeVertices,Finset.mem_insert,Finset.mem_singleton] at hv + rcases hv with rfl | rfl + · simp [edgeAnchor,edgeLocal] + · have hd := circle_distinct (sectorCircleEdge s) + have hr := radial_step s + cases hb : (sectorLetter s).2 + · simp only [hb,Bool.false_eq_true,↓reduceIte] at hr + simp only [sectorStart,hb,Bool.false_eq_true,↓reduceIte, + edgeAnchor,edgeLocal,faceLocal,Sum.inl_ne_inr, + Sum.inl.injEq,Ne.symm hd,hd] + rw [hr] + group + · simp only [hb,↓reduceIte] at hr + simp only [sectorStart,hb,↓reduceIte,edgeAnchor,edgeLocal,faceLocal, + Sum.inl_ne_inr,Sum.inl.injEq,Ne.symm hd] + exact hr + · simp only [edgeVertices,Finset.mem_insert,Finset.mem_singleton] at hv + rcases hv with rfl | rfl <;> simp [faceLocal,edgeLocal,edgeAnchor] + · simp only [edgeVertices,Finset.mem_insert,Finset.mem_singleton] at hv + rcases hv with rfl | rfl + · simp [faceLocal,edgeLocal,edgeAnchor,nextSector_first] + · simp [faceLocal,edgeLocal,edgeAnchor,nextSector_first,Ne.symm (sector_distinct s)] + +def cellRank : SeedCell → ℕ + | .inl _ => 0 + | .inr (.inl _) => 1 + | .inr (.inr _) => 2 + +theorem properFace_rank {a b : SeedCell} (h : properFace a b) : cellRank a < cellRank b := by + rcases a with a | (a | a) <;> rcases b with b | (b | b) <;> + simp only [properFace,cellRank] at * <;> omega + +theorem properFace_trans {a b c : SeedCell} (hab : properFace a b) (hbc : properFace b c) : + properFace a c := by + rcases a with a | (a | a) <;> rcases b with b | (b | b) <;> + rcases c with c | (c | c) <;> simp only [properFace] at * + exact Finset.mem_biUnion.mpr ⟨b,hbc,hab⟩ + +def upLabel : SeedCell → SeedCell → SeedSU2 + | .inl v, .inr (.inl e) => (edgeLocal e v)⁻¹ + | .inl v, .inr (.inr s) => (faceLocal s v)⁻¹ + | .inr (.inl e), .inr (.inr s) => (faceLocal s (edgeAnchor e))⁻¹ + | _, _ => 1 + +@[simp] theorem upLabel_diag (a : SeedCell) : upLabel a a = 1 := by + rcases a with a | (a | a) <;> rfl + +theorem upLabel_same_rank {a b : SeedCell} (hab : cellRank a = cellRank b) : + upLabel a b = 1 := by + rcases a with a | (a | a) <;> rcases b with b | (b | b) <;> + simp [upLabel,cellRank] at * + +theorem upLabel_trans {a b c : SeedCell} (hab : a = b ∨ properFace a b) + (hbc : b = c ∨ properFace b c) : upLabel a b * upLabel b c = upLabel a c := by + rcases hab with rfl | hab + · simp + rcases hbc with rfl | hbc + · simp + rcases a with a | (a | a) <;> rcases b with b | (b | b) <;> + rcases c with c | (c | c) <;> simp only [properFace] at hab hbc + simp only [upLabel,← mul_inv_rev] + exact congrArg Inv.inv (faceLocal_incidence c b hbc a hab).symm + +def Related (a b : SeedCell) : Prop := a = b ∨ seedGraph.Adj a b + +theorem related_symm {a b : SeedCell} : Related a b → Related b a := by + rintro (rfl | h) + · exact Or.inl rfl + · exact Or.inr h.symm + +theorem related_forward {a b : SeedCell} (h : Related a b) (hr : cellRank a ≤ cellRank b) : + a = b ∨ properFace a b := by + rcases h with h | h + · exact Or.inl h + rcases h with h | h + · exact Or.inr h + · have hd := properFace_rank h + omega + +def connection (a b : SeedCell) : SeedSU2 := + if cellRank a ≤ cellRank b then upLabel a b else (upLabel b a)⁻¹ + +@[simp] theorem connection_diag (a : SeedCell) : connection a a = 1 := by + simp [connection] + +theorem connection_reverse (a b : SeedCell) : connection b a = (connection a b)⁻¹ := by + by_cases hab : cellRank a ≤ cellRank b + · by_cases hba : cellRank b ≤ cellRank a + · have he := le_antisymm hab hba + simp [connection,hab,hba,upLabel_same_rank he,upLabel_same_rank he.symm] + · simp [connection,hab,hba] + · have hba : cellRank b ≤ cellRank a := (le_total _ _).resolve_left hab + simp [connection,hab,hba] + +theorem connection_flat_sorted {a b c : SeedCell} (hab : Related a b) (hbc : Related b c) + (hrab : cellRank a ≤ cellRank b) (hrbc : cellRank b ≤ cellRank c) : + connection a b * connection b c = connection a c := by + simp only [connection,hrab,hrbc,le_trans hrab hrbc,↓reduceIte] + exact upLabel_trans (related_forward hab hrab) (related_forward hbc hrbc) + +theorem connection_flat {a b c : SeedCell} (hab : Related a b) (hbc : Related b c) + (hac : Related a c) : connection a b * connection b c = connection a c := by + by_cases hrab : cellRank a ≤ cellRank b + · by_cases hrbc : cellRank b ≤ cellRank c + · exact connection_flat_sorted hab hbc hrab hrbc + · have hrcb := le_of_lt (lt_of_not_ge hrbc) + by_cases hrac : cellRank a ≤ cellRank c + · have H := connection_flat_sorted hac (related_symm hbc) hrac hrcb + rw [connection_reverse b c] at H + rw [← H] + group + · have hrca := le_of_lt (lt_of_not_ge hrac) + have H := connection_flat_sorted (related_symm hac) hab hrca hrab + rw [connection_reverse a c,connection_reverse b c] at H + calc + connection a b * connection b c = + connection a c * ((connection a c)⁻¹ * connection a b) * connection b c := by group + _ = connection a c * (connection b c)⁻¹ * connection b c := by rw [H] + _ = connection a c := by group + · have hrba := le_of_lt (lt_of_not_ge hrab) + by_cases hrac : cellRank a ≤ cellRank c + · have H := connection_flat_sorted (related_symm hab) hac hrba hrac + rw [connection_reverse a b] at H + rw [← H] + group + · have hrca := le_of_lt (lt_of_not_ge hrac) + by_cases hrbc : cellRank b ≤ cellRank c + · have H := connection_flat_sorted hbc (related_symm hac) hrbc hrca + rw [connection_reverse a c,connection_reverse a b] at H + calc + connection a b * connection b c = + connection a b * (connection b c * (connection a c)⁻¹) * connection a c := by group + _ = connection a b * (connection a b)⁻¹ * connection a c := by rw [H] + _ = connection a c := by group + · have hrcb := le_of_lt (lt_of_not_ge hrbc) + have H := connection_flat_sorted (related_symm hbc) (related_symm hab) hrcb hrba + rw [connection_reverse b c,connection_reverse a b,connection_reverse a c] at H + have H' := congrArg Inv.inv H + simpa only [mul_inv_rev,inv_inv] using H' + +def rankFin (a : SeedCell) : Fin 3 := ⟨cellRank a,by + rcases a with a | (a | a) <;> norm_num [cellRank]⟩ + +theorem adjacent_rank_ne {a b : SeedCell} (h : seedGraph.Adj a b) : rankFin a ≠ rankFin b := by + intro he + have he' := congrArg Fin.val he + change cellRank a = cellRank b at he' + rcases h with h | h <;> have hh := properFace_rank h <;> omega + +theorem clique_card_le_three (s : Finset SeedCell) (hs : (s : Set SeedCell).Pairwise seedGraph.Adj) : + s.card ≤ 3 := by + have hi : Set.InjOn rankFin (s : Set SeedCell) := by + intro a ha b hb he + by_contra hn + exact adjacent_rank_ne (hs ha hb hn) he + have hc := Finset.card_le_card (Finset.subset_univ (s.image rankFin)) + rwa [Finset.card_image_of_injOn hi,Finset.card_univ,Fintype.card_fin] at hc + +/-- The subdivided x-circle in the exact 103-cell order graph. -/ +def roseLoop : List SeedCell := + [.inl (.inl none), .inr (.inl (.inl (false,0))), + .inl (.inl (some (false,0))), .inr (.inl (.inl (false,1))), + .inl (.inl (some (false,1))), .inr (.inl (.inl (false,2))), .inl (.inl none)] + +theorem roseLoop_edges : roseLoop.IsChain seedGraph.Adj := by + simp [roseLoop,List.isChain_cons_cons,seedGraph,properFace,edgeVertices,circleStart,circleEnd] + +theorem roseLoop_holonomy : (List.zipWith connection roseLoop roseLoop.tail).prod = seedXUnit := by + simp [roseLoop,connection,cellRank,upLabel,edgeLocal,circleLabel,circleWord, + circleStart,seedLetterUnit] + +theorem roseLoop_nontrivial : (List.zipWith connection roseLoop roseLoop.tail).prod ≠ 1 := by + rw [roseLoop_holonomy] + intro h + have hh := congrArg (fun q : SeedSU2 => (q : ℍ).re) h + norm_num [seedXUnit,seedXQuaternion] at hh + +end SeedConnection + + + +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/SeedContraction.lean b/lean/OAI/Topology/EilenbergGanea/SeedContraction.lean new file mode 100644 index 0000000000000000000000000000000000000000..244ebf22008a51dfdc2f0e81fdc5c0e3b3949fec --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/SeedContraction.lean @@ -0,0 +1,6288 @@ +import OAI.Topology.EilenbergGanea.SeedChains +import OAI.AlgebraicTopology.Integral.Contraction + +namespace OAI + +noncomputable section + +open Classical Set + +namespace EilenbergGanea.SeedChainCertificate +def d1Data_0 : List (List (Fin 372 × ℤ)) := [ + [(0,-1),(1,-1),(2,-1),(3,-1),(4,-1),(5,-1),(6,-1),(7,-1),(8,-1),(9,-1),(10,-1),(11,-1),(12,-1),(13,-1),(14,-1),(15,-1),(16,-1),(17,-1),(18,-1),(19,-1),(20,-1),(21,-1),(22,-1),(23,-1),(24,-1),(25,-1),(26,-1),(27,-1),(28,-1),(29,-1),(30,-1),(31,-1),(32,-1),(33,-1),(34,-1),(35,-1),(36,-1),(37,-1),(38,-1),(39,-1),(40,-1),(41,-1),(42,-1),(43,-1),(44,-1),(45,-1),(46,-1),(47,-1),(48,-1)], + [(49,-1),(50,-1),(51,-1),(52,-1),(53,-1),(54,-1),(55,-1),(56,-1),(57,-1),(58,-1),(59,-1),(60,-1),(61,-1),(62,-1),(63,-1),(64,-1),(65,-1),(66,-1),(67,-1),(68,-1),(69,-1),(70,-1),(71,-1)], + [(72,-1),(73,-1),(74,-1),(75,-1),(76,-1),(77,-1),(78,-1),(79,-1),(80,-1),(81,-1),(82,-1),(83,-1),(84,-1),(85,-1),(86,-1),(87,-1),(88,-1),(89,-1),(90,-1),(91,-1),(92,-1),(93,-1),(94,-1)], + [(95,-1),(96,-1),(97,-1),(98,-1),(99,-1),(100,-1),(101,-1),(102,-1),(103,-1),(104,-1),(105,-1),(106,-1),(107,-1),(108,-1),(109,-1),(110,-1),(111,-1),(112,-1),(113,-1),(114,-1),(115,-1),(116,-1),(117,-1),(118,-1),(119,-1),(120,-1)], + [(121,-1),(122,-1),(123,-1),(124,-1),(125,-1),(126,-1),(127,-1),(128,-1),(129,-1),(130,-1),(131,-1),(132,-1),(133,-1),(134,-1),(135,-1),(136,-1),(137,-1),(138,-1),(139,-1),(140,-1),(141,-1),(142,-1),(143,-1),(144,-1),(145,-1),(146,-1)], + [(147,-1),(148,-1),(149,-1),(150,-1),(151,-1),(152,-1),(153,-1),(154,-1),(155,-1),(156,-1),(157,-1),(158,-1),(159,-1),(160,-1),(161,-1),(162,-1),(163,-1),(164,-1),(165,-1),(166,-1),(167,-1),(168,-1),(169,-1),(170,-1),(171,-1),(172,-1),(173,-1),(174,-1),(175,-1),(176,-1),(177,-1),(178,-1),(179,-1),(180,-1),(181,-1),(182,-1),(183,-1),(184,-1),(185,-1),(186,-1),(187,-1),(188,-1)], + [(189,-1),(190,-1),(191,-1),(192,-1),(193,-1),(194,-1),(195,-1),(196,-1),(197,-1),(198,-1),(199,-1),(200,-1),(201,-1),(202,-1),(203,-1),(204,-1),(205,-1),(206,-1),(207,-1),(208,-1),(209,-1),(210,-1),(211,-1),(212,-1),(213,-1),(214,-1),(215,-1),(216,-1),(217,-1),(218,-1),(219,-1),(220,-1),(221,-1),(222,-1),(223,-1),(224,-1),(225,-1),(226,-1),(227,-1),(228,-1),(229,-1),(230,-1),(231,-1),(232,-1),(233,-1),(234,-1),(235,-1),(236,-1)], + [(0,1),(49,1),(237,-1),(238,-1),(239,-1),(240,-1),(241,-1),(242,-1),(243,-1)], + [(50,1),(72,1),(244,-1),(245,-1),(246,-1),(247,-1),(248,-1),(249,-1),(250,-1)], + [(1,1),(73,1),(251,-1),(252,-1),(253,-1),(254,-1),(255,-1),(256,-1),(257,-1)], + [(2,1),(95,1),(258,-1),(259,-1),(260,-1),(261,-1),(262,-1),(263,-1),(264,-1),(265,-1)], + [(96,1),(121,1),(266,-1),(267,-1),(268,-1),(269,-1),(270,-1),(271,-1),(272,-1),(273,-1)], + [(3,1),(122,1),(274,-1),(275,-1),(276,-1),(277,-1),(278,-1),(279,-1),(280,-1),(281,-1)], + [(4,1),(147,1),(282,-1),(283,-1)], + [(51,1),(148,1),(284,-1),(285,-1)], + [(74,1),(149,1),(286,-1),(287,-1)]] + +def d1Data_1 : List (List (Fin 372 × ℤ)) := [ + [(5,1),(150,1),(288,-1),(289,-1)], + [(52,1),(151,1),(290,-1),(291,-1)], + [(75,1),(152,1),(292,-1),(293,-1)], + [(6,1),(153,1),(294,-1),(295,-1)], + [(123,1),(154,1),(296,-1),(297,-1)], + [(97,1),(155,1),(298,-1),(299,-1)], + [(7,1),(156,1),(300,-1),(301,-1)], + [(124,1),(157,1),(302,-1),(303,-1)], + [(98,1),(158,1),(304,-1),(305,-1)], + [(8,1),(159,1),(306,-1),(307,-1)], + [(125,1),(160,1),(308,-1),(309,-1)], + [(99,1),(161,1),(310,-1),(311,-1)], + [(9,1),(162,1),(312,-1),(313,-1)], + [(126,1),(163,1),(314,-1),(315,-1)], + [(100,1),(164,1),(316,-1),(317,-1)], + [(10,1),(165,1),(318,-1),(319,-1)]] + +def d1Data_2 : List (List (Fin 372 × ℤ)) := [ + [(127,1),(166,1),(320,-1),(321,-1)], + [(101,1),(167,1),(322,-1),(323,-1)], + [(11,1),(189,1),(324,-1),(325,-1)], + [(53,1),(190,1),(326,-1),(327,-1)], + [(76,1),(191,1),(328,-1),(329,-1)], + [(12,1),(192,1),(330,-1),(331,-1)], + [(54,1),(193,1),(332,-1),(333,-1)], + [(77,1),(194,1),(334,-1),(335,-1)], + [(13,1),(195,1),(336,-1),(337,-1)], + [(102,1),(196,1),(338,-1),(339,-1)], + [(128,1),(197,1),(340,-1),(341,-1)], + [(14,1),(198,1),(342,-1),(343,-1)], + [(78,1),(199,1),(344,-1),(345,-1)], + [(55,1),(200,1),(346,-1),(347,-1)], + [(15,1),(201,1),(348,-1),(349,-1)], + [(103,1),(202,1),(350,-1),(351,-1)]] + +def d1Data_3 : List (List (Fin 372 × ℤ)) := [ + [(129,1),(203,1),(352,-1),(353,-1)], + [(16,1),(204,1),(354,-1),(355,-1)], + [(79,1),(205,1),(356,-1),(357,-1)], + [(56,1),(206,1),(358,-1),(359,-1)], + [(17,1),(207,1),(360,-1),(361,-1)], + [(104,1),(208,1),(362,-1),(363,-1)], + [(130,1),(209,1),(364,-1),(365,-1)], + [(18,1),(210,1),(366,-1),(367,-1)], + [(80,1),(211,1),(368,-1),(369,-1)], + [(57,1),(212,1),(370,-1),(371,-1)], + [(19,1),(58,1),(168,1),(237,1),(282,1),(284,1)], + [(59,1),(81,1),(169,1),(244,1),(285,1),(286,1)], + [(20,1),(82,1),(170,1),(251,1),(287,1),(288,1)], + [(21,1),(60,1),(171,1),(238,1),(289,1),(290,1)], + [(61,1),(83,1),(172,1),(245,1),(291,1),(292,1)], + [(22,1),(84,1),(173,1),(252,1),(293,1),(294,1)]] + +def d1Data_4 : List (List (Fin 372 × ℤ)) := [ + [(23,1),(131,1),(174,1),(274,1),(295,1),(296,1)], + [(105,1),(132,1),(175,1),(266,1),(297,1),(298,1)], + [(24,1),(106,1),(176,1),(258,1),(299,1),(300,1)], + [(25,1),(133,1),(177,1),(275,1),(301,1),(302,1)], + [(107,1),(134,1),(178,1),(267,1),(303,1),(304,1)], + [(26,1),(108,1),(179,1),(259,1),(305,1),(306,1)], + [(27,1),(135,1),(180,1),(276,1),(307,1),(308,1)], + [(109,1),(136,1),(181,1),(268,1),(309,1),(310,1)], + [(28,1),(110,1),(182,1),(260,1),(311,1),(312,1)], + [(29,1),(137,1),(183,1),(277,1),(313,1),(314,1)], + [(111,1),(138,1),(184,1),(269,1),(315,1),(316,1)], + [(30,1),(112,1),(185,1),(261,1),(317,1),(318,1)], + [(31,1),(139,1),(186,1),(278,1),(319,1),(320,1)], + [(113,1),(140,1),(187,1),(270,1),(321,1),(322,1)], + [(32,1),(114,1),(188,1),(262,1),(283,1),(323,1)], + [(33,1),(62,1),(213,1),(239,1),(324,1),(326,1)]] + +def d1Data_5 : List (List (Fin 372 × ℤ)) := [ + [(63,1),(85,1),(214,1),(246,1),(327,1),(328,1)], + [(34,1),(86,1),(215,1),(253,1),(329,1),(330,1)], + [(35,1),(64,1),(216,1),(240,1),(331,1),(332,1)], + [(65,1),(87,1),(217,1),(247,1),(333,1),(334,1)], + [(36,1),(88,1),(218,1),(254,1),(335,1),(336,1)], + [(37,1),(115,1),(219,1),(263,1),(337,1),(338,1)], + [(116,1),(141,1),(220,1),(271,1),(339,1),(340,1)], + [(38,1),(142,1),(221,1),(279,1),(341,1),(342,1)], + [(39,1),(89,1),(222,1),(255,1),(343,1),(344,1)], + [(66,1),(90,1),(223,1),(248,1),(345,1),(346,1)], + [(40,1),(67,1),(224,1),(241,1),(347,1),(348,1)], + [(41,1),(117,1),(225,1),(264,1),(349,1),(350,1)], + [(118,1),(143,1),(226,1),(272,1),(351,1),(352,1)], + [(42,1),(144,1),(227,1),(280,1),(353,1),(354,1)], + [(43,1),(91,1),(228,1),(256,1),(355,1),(356,1)], + [(68,1),(92,1),(229,1),(249,1),(357,1),(358,1)]] + +def d1Data_6 : List (List (Fin 372 × ℤ)) := [ + [(44,1),(69,1),(230,1),(242,1),(359,1),(360,1)], + [(45,1),(119,1),(231,1),(265,1),(361,1),(362,1)], + [(120,1),(145,1),(232,1),(273,1),(363,1),(364,1)], + [(46,1),(146,1),(233,1),(281,1),(365,1),(366,1)], + [(47,1),(93,1),(234,1),(257,1),(367,1),(368,1)], + [(70,1),(94,1),(235,1),(250,1),(369,1),(370,1)], + [(48,1),(71,1),(236,1),(243,1),(325,1),(371,1)]] + +def d1Data : List (List (Fin 372 × ℤ)) := [d1Data_0,d1Data_1,d1Data_2,d1Data_3,d1Data_4,d1Data_5,d1Data_6].flatten + +def d2Data_0 : List (List (Fin 270 × ℤ)) := [ + [(0,1),(1,1),(2,1),(3,1),(4,1),(5,1),(6,1)], + [(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1)], + [(14,1),(15,1),(16,1),(17,1),(18,1),(19,1),(20,1),(21,1)], + [(22,1),(23,1),(24,1),(25,1),(26,1),(27,1),(28,1),(29,1)], + [(30,1),(31,1)], + [(32,1),(33,1)], + [(34,1),(35,1)], + [(36,1),(37,1)], + [(38,1),(39,1)], + [(40,1),(41,1)], + [(42,1),(43,1)], + [(44,1),(45,1)], + [(46,1),(47,1)], + [(48,1),(49,1)], + [(50,1),(51,1)], + [(52,1),(53,1)]] + +def d2Data_1 : List (List (Fin 270 × ℤ)) := [ + [(54,1),(55,1)], + [(56,1),(57,1)], + [(58,1),(59,1)], + [(0,-1),(30,-1)], + [(7,-1),(32,-1)], + [(1,-1),(33,-1)], + [(8,-1),(34,-1)], + [(22,-1),(35,-1)], + [(14,-1),(36,-1)], + [(23,-1),(37,-1)], + [(15,-1),(38,-1)], + [(24,-1),(39,-1)], + [(16,-1),(40,-1)], + [(25,-1),(41,-1)], + [(17,-1),(42,-1)], + [(26,-1),(43,-1)]] + +def d2Data_2 : List (List (Fin 270 × ℤ)) := [ + [(18,-1),(31,-1)], + [(2,-1),(44,-1)], + [(9,-1),(46,-1)], + [(3,-1),(47,-1)], + [(10,-1),(48,-1)], + [(19,-1),(49,-1)], + [(27,-1),(50,-1)], + [(11,-1),(51,-1)], + [(4,-1),(52,-1)], + [(20,-1),(53,-1)], + [(28,-1),(54,-1)], + [(12,-1),(55,-1)], + [(5,-1),(56,-1)], + [(21,-1),(57,-1)], + [(29,-1),(58,-1)], + [(13,-1),(59,-1)]] + +def d2Data_3 : List (List (Fin 270 × ℤ)) := [ + [(6,-1),(45,-1)], + [(60,1),(61,1),(62,1),(63,1),(64,1),(65,1),(66,1)], + [(67,1),(68,1),(69,1),(70,1),(71,1),(72,1),(73,1)], + [(74,1),(75,1)], + [(76,1),(77,1)], + [(78,1),(79,1)], + [(80,1),(81,1)], + [(82,1),(83,1)], + [(84,1),(85,1)], + [(86,1),(87,1)], + [(60,-1),(74,-1)], + [(67,-1),(75,-1)], + [(61,-1),(76,-1)], + [(68,-1),(77,-1)], + [(62,-1),(78,-1)], + [(69,-1),(79,-1)]] + +def d2Data_4 : List (List (Fin 270 × ℤ)) := [ + [(63,-1),(80,-1)], + [(70,-1),(81,-1)], + [(71,-1),(82,-1)], + [(64,-1),(83,-1)], + [(72,-1),(84,-1)], + [(65,-1),(85,-1)], + [(73,-1),(86,-1)], + [(66,-1),(87,-1)], + [(88,1),(89,1),(90,1),(91,1),(92,1),(93,1),(94,1)], + [(95,1),(96,1),(97,1),(98,1),(99,1),(100,1),(101,1)], + [(102,1),(103,1)], + [(104,1),(105,1)], + [(106,1),(107,1)], + [(108,1),(109,1)], + [(110,1),(111,1)], + [(112,1),(113,1)]] + +def d2Data_5 : List (List (Fin 270 × ℤ)) := [ + [(114,1),(115,1)], + [(88,-1),(102,-1)], + [(95,-1),(103,-1)], + [(89,-1),(104,-1)], + [(96,-1),(105,-1)], + [(90,-1),(106,-1)], + [(97,-1),(107,-1)], + [(91,-1),(108,-1)], + [(98,-1),(109,-1)], + [(99,-1),(110,-1)], + [(92,-1),(111,-1)], + [(100,-1),(112,-1)], + [(93,-1),(113,-1)], + [(101,-1),(114,-1)], + [(94,-1),(115,-1)], + [(116,1),(117,1),(118,1),(119,1),(120,1),(121,1),(122,1),(123,1)]] + +def d2Data_6 : List (List (Fin 270 × ℤ)) := [ + [(124,1),(125,1),(126,1),(127,1),(128,1),(129,1),(130,1),(131,1)], + [(132,1),(133,1)], + [(134,1),(135,1)], + [(136,1),(137,1)], + [(138,1),(139,1)], + [(140,1),(141,1)], + [(142,1),(143,1)], + [(144,1),(145,1)], + [(146,1),(147,1)], + [(124,-1),(132,-1)], + [(116,-1),(133,-1)], + [(125,-1),(134,-1)], + [(117,-1),(135,-1)], + [(126,-1),(136,-1)], + [(118,-1),(137,-1)], + [(127,-1),(138,-1)]] + +def d2Data_7 : List (List (Fin 270 × ℤ)) := [ + [(119,-1),(139,-1)], + [(128,-1),(140,-1)], + [(120,-1),(141,-1)], + [(121,-1),(142,-1)], + [(129,-1),(143,-1)], + [(122,-1),(144,-1)], + [(130,-1),(145,-1)], + [(123,-1),(146,-1)], + [(131,-1),(147,-1)], + [(148,1),(149,1),(150,1),(151,1),(152,1),(153,1),(154,1),(155,1)], + [(156,1),(157,1),(158,1),(159,1),(160,1),(161,1),(162,1),(163,1)], + [(164,1),(165,1)], + [(166,1),(167,1)], + [(168,1),(169,1)], + [(170,1),(171,1)], + [(172,1),(173,1)]] + +def d2Data_8 : List (List (Fin 270 × ℤ)) := [ + [(174,1),(175,1)], + [(176,1),(177,1)], + [(178,1),(179,1)], + [(156,-1),(164,-1)], + [(148,-1),(165,-1)], + [(157,-1),(166,-1)], + [(149,-1),(167,-1)], + [(158,-1),(168,-1)], + [(150,-1),(169,-1)], + [(159,-1),(170,-1)], + [(151,-1),(171,-1)], + [(160,-1),(172,-1)], + [(152,-1),(173,-1)], + [(153,-1),(174,-1)], + [(161,-1),(175,-1)], + [(154,-1),(176,-1)]] + +def d2Data_9 : List (List (Fin 270 × ℤ)) := [ + [(162,-1),(177,-1)], + [(155,-1),(178,-1)], + [(163,-1),(179,-1)], + [(180,1),(181,1)], + [(182,1),(183,1)], + [(184,1),(185,1)], + [(186,1),(187,1)], + [(188,1),(189,1)], + [(190,1),(191,1)], + [(192,1),(193,1)], + [(194,1),(195,1)], + [(196,1),(197,1)], + [(198,1),(199,1)], + [(200,1),(201,1)], + [(202,1),(203,1)], + [(204,1),(205,1)]] + +def d2Data_10 : List (List (Fin 270 × ℤ)) := [ + [(206,1),(207,1)], + [(208,1),(209,1)], + [(210,1),(211,1)], + [(212,1),(213,1)], + [(214,1),(215,1)], + [(216,1),(217,1)], + [(218,1),(219,1)], + [(220,1),(221,1)], + [(180,-1),(182,-1)], + [(183,-1),(184,-1)], + [(185,-1),(186,-1)], + [(187,-1),(188,-1)], + [(189,-1),(190,-1)], + [(191,-1),(192,-1)], + [(193,-1),(194,-1)], + [(195,-1),(196,-1)]] + +def d2Data_11 : List (List (Fin 270 × ℤ)) := [ + [(197,-1),(198,-1)], + [(199,-1),(200,-1)], + [(201,-1),(202,-1)], + [(203,-1),(204,-1)], + [(205,-1),(206,-1)], + [(207,-1),(208,-1)], + [(209,-1),(210,-1)], + [(211,-1),(212,-1)], + [(213,-1),(214,-1)], + [(215,-1),(216,-1)], + [(217,-1),(218,-1)], + [(219,-1),(220,-1)], + [(181,-1),(221,-1)], + [(222,1),(223,1)], + [(224,1),(225,1)], + [(226,1),(227,1)]] + +def d2Data_12 : List (List (Fin 270 × ℤ)) := [ + [(228,1),(229,1)], + [(230,1),(231,1)], + [(232,1),(233,1)], + [(234,1),(235,1)], + [(236,1),(237,1)], + [(238,1),(239,1)], + [(240,1),(241,1)], + [(242,1),(243,1)], + [(244,1),(245,1)], + [(246,1),(247,1)], + [(248,1),(249,1)], + [(250,1),(251,1)], + [(252,1),(253,1)], + [(254,1),(255,1)], + [(256,1),(257,1)], + [(258,1),(259,1)]] + +def d2Data_13 : List (List (Fin 270 × ℤ)) := [ + [(260,1),(261,1)], + [(262,1),(263,1)], + [(264,1),(265,1)], + [(266,1),(267,1)], + [(268,1),(269,1)], + [(222,-1),(224,-1)], + [(225,-1),(226,-1)], + [(227,-1),(228,-1)], + [(229,-1),(230,-1)], + [(231,-1),(232,-1)], + [(233,-1),(234,-1)], + [(235,-1),(236,-1)], + [(237,-1),(238,-1)], + [(239,-1),(240,-1)], + [(241,-1),(242,-1)], + [(243,-1),(244,-1)]] + +def d2Data_14 : List (List (Fin 270 × ℤ)) := [ + [(245,-1),(246,-1)], + [(247,-1),(248,-1)], + [(249,-1),(250,-1)], + [(251,-1),(252,-1)], + [(253,-1),(254,-1)], + [(255,-1),(256,-1)], + [(257,-1),(258,-1)], + [(259,-1),(260,-1)], + [(261,-1),(262,-1)], + [(263,-1),(264,-1)], + [(265,-1),(266,-1)], + [(267,-1),(268,-1)], + [(223,-1),(269,-1)], + [(0,1),(60,1)], + [(1,1),(61,1)], + [(2,1),(62,1)]] + +def d2Data_15 : List (List (Fin 270 × ℤ)) := [ + [(3,1),(63,1)], + [(4,1),(64,1)], + [(5,1),(65,1)], + [(6,1),(66,1)], + [(67,1),(88,1)], + [(68,1),(89,1)], + [(69,1),(90,1)], + [(70,1),(91,1)], + [(71,1),(92,1)], + [(72,1),(93,1)], + [(73,1),(94,1)], + [(7,1),(95,1)], + [(8,1),(96,1)], + [(9,1),(97,1)], + [(10,1),(98,1)], + [(11,1),(99,1)]] + +def d2Data_16 : List (List (Fin 270 × ℤ)) := [ + [(12,1),(100,1)], + [(13,1),(101,1)], + [(14,1),(116,1)], + [(15,1),(117,1)], + [(16,1),(118,1)], + [(17,1),(119,1)], + [(18,1),(120,1)], + [(19,1),(121,1)], + [(20,1),(122,1)], + [(21,1),(123,1)], + [(124,1),(148,1)], + [(125,1),(149,1)], + [(126,1),(150,1)], + [(127,1),(151,1)], + [(128,1),(152,1)], + [(129,1),(153,1)]] + +def d2Data_17 : List (List (Fin 270 × ℤ)) := [ + [(130,1),(154,1)], + [(131,1),(155,1)], + [(22,1),(156,1)], + [(23,1),(157,1)], + [(24,1),(158,1)], + [(25,1),(159,1)], + [(26,1),(160,1)], + [(27,1),(161,1)], + [(28,1),(162,1)], + [(29,1),(163,1)], + [(30,1),(180,1)], + [(31,1),(181,1)], + [(74,1),(182,1)], + [(75,1),(183,1)], + [(102,1),(184,1)], + [(103,1),(185,1)]] + +def d2Data_18 : List (List (Fin 270 × ℤ)) := [ + [(32,1),(186,1)], + [(33,1),(187,1)], + [(76,1),(188,1)], + [(77,1),(189,1)], + [(104,1),(190,1)], + [(105,1),(191,1)], + [(34,1),(192,1)], + [(35,1),(193,1)], + [(164,1),(194,1)], + [(165,1),(195,1)], + [(132,1),(196,1)], + [(133,1),(197,1)], + [(36,1),(198,1)], + [(37,1),(199,1)], + [(166,1),(200,1)], + [(167,1),(201,1)]] + +def d2Data_19 : List (List (Fin 270 × ℤ)) := [ + [(134,1),(202,1)], + [(135,1),(203,1)], + [(38,1),(204,1)], + [(39,1),(205,1)], + [(168,1),(206,1)], + [(169,1),(207,1)], + [(136,1),(208,1)], + [(137,1),(209,1)], + [(40,1),(210,1)], + [(41,1),(211,1)], + [(170,1),(212,1)], + [(171,1),(213,1)], + [(138,1),(214,1)], + [(139,1),(215,1)], + [(42,1),(216,1)], + [(43,1),(217,1)]] + +def d2Data_20 : List (List (Fin 270 × ℤ)) := [ + [(172,1),(218,1)], + [(173,1),(219,1)], + [(140,1),(220,1)], + [(141,1),(221,1)], + [(44,1),(222,1)], + [(45,1),(223,1)], + [(78,1),(224,1)], + [(79,1),(225,1)], + [(106,1),(226,1)], + [(107,1),(227,1)], + [(46,1),(228,1)], + [(47,1),(229,1)], + [(80,1),(230,1)], + [(81,1),(231,1)], + [(108,1),(232,1)], + [(109,1),(233,1)]] + +def d2Data_21 : List (List (Fin 270 × ℤ)) := [ + [(48,1),(234,1)], + [(49,1),(235,1)], + [(142,1),(236,1)], + [(143,1),(237,1)], + [(174,1),(238,1)], + [(175,1),(239,1)], + [(50,1),(240,1)], + [(51,1),(241,1)], + [(110,1),(242,1)], + [(111,1),(243,1)], + [(82,1),(244,1)], + [(83,1),(245,1)], + [(52,1),(246,1)], + [(53,1),(247,1)], + [(144,1),(248,1)], + [(145,1),(249,1)]] + +def d2Data_22 : List (List (Fin 270 × ℤ)) := [ + [(176,1),(250,1)], + [(177,1),(251,1)], + [(54,1),(252,1)], + [(55,1),(253,1)], + [(112,1),(254,1)], + [(113,1),(255,1)], + [(84,1),(256,1)], + [(85,1),(257,1)], + [(56,1),(258,1)], + [(57,1),(259,1)], + [(146,1),(260,1)], + [(147,1),(261,1)], + [(178,1),(262,1)], + [(179,1),(263,1)], + [(58,1),(264,1)], + [(59,1),(265,1)]] + +def d2Data_23 : List (List (Fin 270 × ℤ)) := [ + [(114,1),(266,1)], + [(115,1),(267,1)], + [(86,1),(268,1)], + [(87,1),(269,1)]] + +def d2Data : List (List (Fin 270 × ℤ)) := [d2Data_0,d2Data_1,d2Data_2,d2Data_3,d2Data_4,d2Data_5,d2Data_6,d2Data_7,d2Data_8,d2Data_9,d2Data_10,d2Data_11,d2Data_12,d2Data_13,d2Data_14,d2Data_15,d2Data_16,d2Data_17,d2Data_18,d2Data_19,d2Data_20,d2Data_21,d2Data_22,d2Data_23].flatten + +def h0CodeData_0 : List (ℕ) := [ + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467198805, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065167114401743759279967291397462, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974580047499508942991460908927726036895443277145, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775440332605179127999059521355709682110447775227769225458570597, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867818480452138321292628547852962782554227063323134017148470870931120785282453, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701006361921833641501652060710894045368114183781018220226386875789505889593007828205433083477, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127084933600319805317659541841036625864998163475823904152171255209796171635266570836387262136116819224009742737909044565, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467198806, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303066434765001971988681463994602838, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467198809, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467198821, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775446609706914514679823357145132889776863877583213689493083493, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467198869, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467199061, + 30845763132983623646676132847120415275432388327850829810140857402521664303920611415308389472992066420305377421240443803744195824843594904142167318387202259389270767566357586271705003989733389129756858685030629456371141399893, + 30845763132983623646676132847120415275432388327850768943674869880702735352128329236507716764886623543954148569785233442317704764266908459090343653106599350587318271407067042771716092562677811178945251578508837479747941651797] + +def h0CodeData_1 : List (ℕ) := [ + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467199829, + 30845763132983623646676132847120415275432388327846873489851668484291282437422269793264663446138279457475502076651770311022276887358975975773629075148013187262358517212472258772425761231120822327002396761114150926385134523733, + 30845763132983623646676132847120415275432388327597564445166779113958295896234465425709251046244257922842126516110129908114892765251297043503896085798498734464934248758406082817844556011473535802659688447854211313253385327957, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467202901, + 30845763132983623646676132847120415275432388311641785585333859412647157260214985902162857453026879706306090641445144122042308950359845378240984767429573755429781067698170821724647421954047198244726356399218075281173064799573, + 30845763132983623646676132847120415275432387290471938556026998528734284554968296395193667487114673847999794662886053813396944797306938801414660391818375097179977479843114111760030842278761594536993105286505366061439062988117, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467215189, + 30845763132983623646676132847120415275432321935601728680387901958310431419180167949165509668733498916396852035104274060093639001920917884529900352701660969192547857119484674024569743060482957242065034072891963332088995075413, + 30845763132983623646676132847120415275428139223908296639485721451183830728739947403363409292338303293808523857070369848682068097215579203905257849231956777997052002807200658955059393090650170366668476401634137988188840744277, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467264341, + 30845763132983623646676132847120415275160445675528646021746168995081386540565832472028985203045783448155520462900500318341530196073903643928137627170888541485317326821023694506396995021351810341288785441133113316595731879253, + 30845763132983623646676132847120415258028058579231006486414811804524958497422476866625843488324513326363303236028850376547104523006667805392443415262521404734298063705697969792003518586256768716988563969066723686703837828437, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341467460949, + 30845763132983623646676132847120414161555284416182076225207951608913563736247718120824773746163225531661400716243254101703861446703574139108013853127024652669065224324851588070821026740174104761774389756814544781890911819093, + 30845763132983623646676132847120343987297737981050539507968899089784299021063158389556310247840806670739639449965092511736304563305579496904521876455232520494163503950683157915141548590883611628067240172662124506936820192597, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341468247381] + +def h0CodeData_2 : List (ℕ) := [ + 30845763132983623646676132847115852834814766132632189604669537865511357249251335588374646355205999571746918408162750753812664025833922395881035369460536061300453400003903627951654947036292051070809666786855345442167647982933, + 30845763132983623646676132846828419075904567833857795793510419512043083853294676312748157226578345236212771732812878246699669627647867930377898921799962672903006747410013710288512447542432175406324970095013959426111394108757, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341471393109, + 30845763132983623646676132828432658505651876712296591879326844890073586512068482672652852994408467762027384510421037791468028143740382138177166271523265815466420981401058979847392479935400132879304381816335150915194216338773, + 30845763132983623646676131651103982009479644932379541371578069084025756673592089706553382135536309414162602277343248656642973173661291437330276653814666939524931956827956231615714553085349411149986731977570992283227119768917, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341483976021, + 30845763132983623646676056302068686254456811017688308875656417496964647011102939876187247167718175150816539360364744027839455088599486583129341120464338879269634384149380344788327234682103220473657142283383184104262062134613, + 30845763132983623646671233963809757932995440477449429136670715925053628611797350732754609227357582296668512673740447784414297644643975914269466986043343022930589732720523587835538856874347017188563401802236837718214864885077, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341534307669, + 30845763132983623646362604315238345359467725902161125841585815322748451056239645553065781044279639631194804729785488205204221231491293107237522383099608217231732041273691142857082677177950006942564010796364177282060206298453, + 30845763132983623626610306806667940653693993083709714956152176775217087500546514052980777327291309040877496316668075135759330789719593457193067794700580652504839788676414664235887176608541351198602985570487942451625918289237, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630341735634261, + 30845763132983622362463266258162039484175092702819418288399309733209819936186098047540539440038151260569757877153638691286342516330815854347974137162816509983735622450720032479375140166387383585097367714305045637686931838293, + 30845763132983541457052671153784364634965468325840431552215819044744695817119473699365314655836053320874497748229706245015093019449049272261980054745911388633068984006263600062604807868533456320737811318184178881013583533397, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630342540940629, + 30845763132978363510774584473613174285549508199185280436472414982976752196855515416150928466901785180377849497098029683655125219015988018758358780063983622190404123561051925389303540805882111401726147564786823795606430242133] + +def h0CodeData_3 : List (ℕ) := [ + 30845763132646974948977036942656991922928060093255609028894555029828360499962185290430212375108624188592361424670729756617185991300067794526597200420606569859853055067504746298022448796196036584979449740708567696297172489557, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630345762166101, + 30845763111438106993933994961461320715155381313756638943911518028331291898789057244304382500346320714321124789323534426189075417481173443693856103244475220704584671480485284456032560176287248313189918573110054807498887877973, + 30845761754070557871179308164938363417703939425822553504997149932518901423708862292251270515558898360961980127103033278789998693071934990398425883972068874767408121911239726568679688502124798918656442140444739792385518949717, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630358647067989, + 30845674882547414014879353187469096380811658598041085414477591800525911018576385360852103489163867745976721744990959845249088330880673979490891850538062734788108949479524021778095901355728037668500023624422618297037292393813, + 30840115105066207211682234629436006019705685620027127621225871352974525090097861751305413799881908386920185289818260098630825150639969281408713710761669776112961913849718915180733523986335317658433531297239000482380332225877, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630410186675541, + 30484289346268971807066646915318222908923415027133828853115762709685825667472350740317273685836509407301852158765476315061981615234868604149312765072520420903551633542192092949541372345201237013955193150416091894853039117653, + 7711440783245905911669033211780103818858097081962707694068809539209062619439646037076306386930974711728531771387314166655995349308425259547652240966961687501293693860475470153243667312620075766450234925464468495178910750037, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816630616345105749, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480635372166060630711985231732361483606, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816631440978826581, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816634739513709909, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250485619977150254065235374508208412775766, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816647933653243221] + +def h0CodeData_4 : List (ℕ) := [ + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816700710211376469, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005176420944889926385170154028703913060187093183640861349088807179621, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800816911816443909461, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800817756241374041429, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005201103513249744475802478566442273317761834221625365047039036314981, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800821133941094569301, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800834644739976680789, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005596024607006833925919671170256037438957690829377424214242702480741, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051800888687935505126741, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051801104860717618910549, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750011914762107120265127794752831276263378091396553410370889501361132901, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051801969551846074045781, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051805428316359894586709, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750113014562108935164357796059407599878404230688137937517693639899567461, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051819263374415176750421, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027051874603606636305405269] + +def h0CodeData_5 : List (ℕ) := [ + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250565373656897349017609602931825233450326, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027052095964535520820024661, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027052981408251058878502229, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669251841432532850868255597257709694364243286, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027056523183113211112412501, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027070690282561820048053589, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846756906921122230896392613883861336546808160791082618161782931749682369893, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027127358680356255790617941, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484027354032271533998760875349, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669255924820935902129817157752998875582780758, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484028260726636244970641904981, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484031887504095088858166023509, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846860433116324089353204135221795491928594927425665173960110369613039359333, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484046394613930464408262497621, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484104423053271966608648394069, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669337592588996927361048367658782499953530198] + +def h0CodeData_6 : List (ℕ) := [ + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065484336536810637975410191979861, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065485264991840102010616366323029, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867848516852239553824662188476628741978037183193578986066733349375426751190373, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065488978811957958151441063695701, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065503834092429382714739853186389, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974670644276877973331060747726151320489885521238, + 30845763132983623646676132847120415275432388327850830776275238156836250477758584148305225547723898846914127085549256666623981397233701038190608963867846750005174775441901880612974669250480303065563255214315080967935011149141] + +def h0CodeData : List (ℕ) := [h0CodeData_0,h0CodeData_1,h0CodeData_2,h0CodeData_3,h0CodeData_4,h0CodeData_5,h0CodeData_6].flatten + +def h1CodeData_0 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_1 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_2 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_3 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300865144476228943516043342214815198253176837891581657254566598836413859227936136125673519515098118422877928451228177, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635303325364955898838061585360244827795465809614575239324861042770312704164212589224709486874342433786983838546313888304, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805637822591136137870852696674465908071579317897865882500919089851016790018483368931497125460763467888715537899789513934352, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729808217550740826477213839029923238840721863572264876256292295700172361753225775353964453997876697813105863069046485115519504, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755814420799306014560234469342536876691485834951643579865823362757224918392377818603407507846731229198776416106772242757710266896, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034842375733576576327101394067437513832132662909545164174170941158490084026479832315235272725528706818646360199917126189562840236560, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934123481160017501376369248822516759602077226627120164064450119690055566073077504748652246667055395459313979361079913873848081156948496, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817983386684085972060805192651575135018994570459010245894418766627412687323772419726023749812753, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817920238568819602992130870835234444296001974938806601870649046273482701503479756288132064494128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110815899498880295792794552572712332341160238918292289993110017994947723155254114526275598134298128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_4 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110751235828847533866472047032779465040815821105603758512769824352523417675274427165874512368026128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183108681998387799152224151869754927711429794451099570751141883627794945642315924431633039767847322128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183042466400274250939669906196863671595877110610906514515273525337952456830816724574582327943184794128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624180923567260640708137934044664343475898191227724728714967486060062992814862842329148959549553983898128, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493709276229865134941413878190174019190825402744316372452573608220385472085412448293820241118753521346427542802634134988137754146171167169379151277, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263580008995425388482955328859984145899741704752857253127512941029186733483647906629839037973973250865011421448145304974484635254967571794882514554197425799696, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982373309509094072578951961030827826639684716472498726706576351861193803255497465178009113595582226696970689299417696445732332233169234612558097688228201979462160, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629814094736317610111795619570653514432897990436709877088871441002507147037097447484551052627266381194691123349880356022349175449080169143286879595063325394413600391696, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629929154456613052356189224531074119125408038488555627631460383468753043401570837082886093327904280708203388922930824283851403184812103040089141595965223132670890361360, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969633499492443962532906490881909542856935629607659085757461805643650420953492718651330423483539301688647338569221962097333723635163235811479129238213649465300840562049552, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967973403776407085014095500149918352927954938487253394476577022303822826742483726842907710055235319875673755461827102015309676287812333034124391206219410620638974555407794704] + +def h1CodeData_5 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258971834167336999521817337135377424571605392540015137757461087165445546765252136913086180837547403519883667296236621470399770464108680791734786215818505703857247541345284276752, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493709276229862295727647098475757810894700840296596076734064804964132568782085782612902469946698326378260351568824659233917759212066035964579261869, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985847706158736659998499130721869826292513980491152537636959371407318254024622979587915637589901193279813086077805223905076222322943085005377126928, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493709276229774280100876927328855353714839404417266909460291904020292566378959146504451563612987282365077423320730910853097916254806968615782690221, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531982823512250618042524348208405507696433820026040445846834564563102681175152641331643424091052558435432752003738281361239146257096503775544138547728, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493709276226957780044231450627976723959273456278733556699559073817412489478906791034022560934233873943223719381730962666862941622516813454292397485, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531886049307190822283351518694281919540955613483617831741157930697354294651249228597419694601857590184326797368873517755929387369850445872784504013328, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493709276136829778231576196199860571781163115845666268356108507325250028677231415980294475214124804443905193333732620707343753389231848286603029933, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746528789274745277357989820974242327098565653004126094180359505646993405925886340021102260350947618606148936249053201082386017102977976592984476198912528, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746429692488764046500596843551779772827355969504685337336146632568467058125409245381257161354011971117016438702951683150548824002438013300558610435686928, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493709273252733720226608054500143702081632221987513041365690379576051283023619414260995732170634580465712359797785678002729729924112962920543268269, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472743258595337364659064021566032978036148646097522581118321334694055623928510142216906213993452071251464776517227703109331758644785159187942930906012467728, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493709180961659864067627520109203871696643618526609777672310291601691422108035359243435954778947413163541686647483511455080979040308631206630895021, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472641783486492584261093612685431322462429930194095246109847352661644643780821597305704832620589968222593099030019748747130472909832236776498844364469453328, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886807188311493706227647296466980250419599129299377008307777705339484147476422175872809345598681523078244958059494080145837814181930320950758570016361434951085, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_6 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057796353110101155923600439580054484443885629461711639506960134456195592460583732562185742334278490591531218211689271425618104634073639825528068752769071736149872948064087213034180954762557268686598062608, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866214407528947678071954777031977187271420295877868395166529395881582535935017064875629296194025060420079518877697987391853249157896336719713864648139513091907784851247431167197909880578040864898226881839632, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905470026584251586626440087879607768335633232878960349169503259842647146320794673821219392946672340886163679395969859212382156712985610775451992456095011585120588222022041142072741497720957705818220559513799901712, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905634245304566649678744394906285693607404890217622252933836327461420874001677960234293657020602422668940055188580291396443675980326553284578227238325465318583711921525656223098257691293149055121394102480467935760, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509483073794214907191215238354790224605787041009962327197033359554044269034361752075277905493063309188440649191610719434414077753098448273900072624939869135222189203113673104714170936701894151890910882346425550853653008, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509488291849029243177734421416754041564788284311735946071617338074274117535272981579937898350401919335774029204915672224815130551015022833299370362781797157233742675357789829586719222974809137216290997410672999387382288, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463514998557732968044941991734850544881992323429542917952650173880449213712236624534804807309162120508619906168746302018200627446927780603443511494112990040207385885103016446668558664261286657625719240597322050573074711056, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023469157510822886301051541480691052369563177200921578747414646205247766165596332504122492509537688490420273785269357962476113756831818483370721891304589330729547681678899494306356219980250141853384687621760620915613044851216, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819255010683206244309718504706195671590220238832449136340367010291965253213022478600943260361303082417827057898354447286167726000086855003811309922029380411415566108975092965327376, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819132334804075584460824495455769926583962813683294935267769635016143176189369638794826783426376705867512217453327143281055407723029838855211166019136449872440877812258346960962064, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445815206706671894469296216199442146086383725208910360500944653626189836711432478764999099521508732656257437323212453415117461222857205322100006561126562672625250852317322474821272080, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_7 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445689586606442098784028750727006183199976121856176458602604941343748029839211970803535827140144123068735040707504494113882447307150820785933459204564201800715170036479374566351192592, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972441669743399088636855469855609055370834932814568691597855734148305610209928155716036711110936476616268018349004849796474362002004546515628603943794568653899592583929665041495308648976, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972313034760763777855141585211834629375153546981369176053955868771085199972774355563498320192419116398645084214519899472009707752321208750594059450674711121063669828511606383221947253264, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113968196715316433832840297276611052997513349200318984678649160176700032072383852750682269810799863589434711191911001489089140771762454400269488635670839270070314141655133729318474382590480, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113836474493097875592365279401386040777935610107122680761695698030426331989538361394482957510238086726588826638198412356837334820086716528874115074716105156446329240107041663246552313381392, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044452616901348026675598931611105873467868282367323118523088495099156165919487124704665277384349373925025435890979550075601528966922766206467281650992303087620415427860630357749793444064945979697488425185688181142574606917347186544425455, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340227717887866003986708107514431018446301383985749757656516712670414354880812502076292139436155207426165993441598757668690544582652842718251306215016339292314631159427338456852773534296639059529571806179597441529821718921831414480039864325577325953552, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182347380451947582575729200217968360671258546392901965383764802970019891996602768465858915664539928384679494523834214392937725517010630876365716511282917622340337491928099362831766135544407794468806845363624590488005666596625833602262569828180098850243088, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266189671780129097547595518110993811532632002406321713427166621968630276541944219083131944407529752048491707814356678087675630589538183967546797893800884322254201329386392236523714924868839881039862015997278278847170804610383517422900281605806020940903498256, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016273689857049530667985634626414929834259825874038980063433547464825033615522681994349289216146593311409276544273934579137703557019377243284963037271954978370581795668272676183699169500881537287723893180488795641757286004296736292032350441742820988841221440016, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532023953879572916738996786489967068540775366899515978903690471053916831669673698281276433078775158441244730959861305570048239914098683615986459790235177019466427700435134387677913159856397663931441016125393591740191856981083076402681494231775508738379175902593552] + +def h1CodeData_8 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665783926729103323175872706160432309656302671776334284280275575506387135046490942044432408044860729691443842485777378537134125394533334518205009770333860437966065054690039789103212111654339629980271029168403225022825052975898369692121044728437776821633646338698134032, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150923488330297268886291197550521027525052920286611350746314028904779551827999462678494689373611231555651269226247200386423127745769860907031603127951080014259797024517652902432469719954986387722710975219796092117796023509383556799823389432760388152708214648610920874512, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670414812797584098805516390399928725405572105725992940792192710327539953888893690472986605097879115353108799291864601678926882160660684833377039602288152852487133577957277234530125712232112151961558174525833219865840907673755054088560846824542449411322724814061043880313360, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964032560632809959759711112685485123647176930801517003983126593701820214925111778863746335254023383124827248837010794356759448383947707929903363462184745151384360365443879315862331263269011980376681826392159368473600335121989482123442536976, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044452616901342243095011497181672121692959447289463326032714178024458079418920795730695781676641986540750087506325891382735368582870293429173857090355841889826841537931322106657332138440036289734670016012450526753273077805479305436150255, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967963835428095521984941961635865958108922720632442607594314230601430239819079343473472227585637183956909643007706917795441608021541400026407231195432363709522368028740568844092424724112784103622532551693797613987431917866665988483322231669264, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044452616901162952096801029869225816670785559875809758831110348708817397901364597537641414737712977628214287582062471903884396677243637333077695710625544758226050950122766322791031664067835900887299331642083240684925675337574991079619055, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967957527186902306790773978377641093637740119084957506484909558848739667152014757700943627597898322318023747291543941830156762362579874217681721818478090569393845416744567716942421295297267036171520387450772161794098078876073956521683483902480, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044452616895425640154066075870944055961221162638895608379787810608315589339566255359901672691984692427068690005633048580653295697190642258000531559256036547000752140248981239069416484157423457771437431790330086497808796364636931670620655, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967755663468719420577398514114445430559896869565434270983960062762641341805948012980028427990254749873675084374328710941041701275811048338465421755941350085281121832872531648142311573200720877739131131673957691607415231177128933749243555365392, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044452616711831657986547547925927713255160451057642793937466591392257715362019305672229927228679565990409567559891502237258064335494799855531278715431773787791190224287858559977730727024225278063856636534229152510068669230619030582671855, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725961296024486867061749383657692184212068912884940690734953576188007494930731812181910742040545660431654517871023441322489359746499208620203543819754765654593673967148967377446538800466111243807902674946815894645633564104810888205031165842178576, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044452610836824228625954653685404746661217680457552731783187576478405748080516915666734072402915520017317649296162019248610660761227842976515187713055365493085208913531932829043786498761883527421271188338999264902384600942046195768310255, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044452422836586489086982037988669815655049021254670742846259099235142795072440435490866717978466048878376264856818563611893746384685222848000275637010300062493806969342309439157571194366947506858536846091642861456494415707715481708739055, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725754587577067591579252908252179825220357425376948897581981292195842809776359465587693577642318642248641487043795044892035537193647930919886052555717143398862245017264002442995226445039247977573136077031357877174470328061091184886052679020200464, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044446406828978823839858335693152023457651926762447096864547827450728298813993069863111376396082972432251962797827983236952486335321378735523089203568206283568944755274360962798681453728994848851037894176237951188008488209132631802460655] + +def h1CodeData_9 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220719139917259650776139365695275784337485589825121211516686868204446572884836444374572744316899054060392224500572486359117513215502407044509726332106513231215456518620945124540553231071379623458060604943736701318097246774662060678678741100716900880, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665948956660832856044253894585533535931899862236582673140944903011290425449787130349464418543677369774940445759824526156274296910129411238832164755678367136253123333421205357973353905100009719314209753314509792611071432883280822596458808254481434801551855, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220507470467102312682062974880031128729973026616937615328043249396469935286759161462094367973114587440986880933490608414332798921382698679384615277731988041346473273938741031662409379114271638833659608678307691427626093065893084480044770595011314192, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710068317275551160585018477437820239511779539412779475260537699943790818464494691735506520375616814992110428000127063614945688692796839885217674650856755211200630137335983264339400784615466751468049462447535702697995343492082717684967880385242547746596147171809124692041872720400, + 16407379234535226782272828564066658318726156512863643464757583252208349461195887089829744964774863856842472560226876262923333452586874710773555079145228746432142450202516317912116863135496915705465833440863467908092982176599987589048521135852925969227068076884361942618699551892913866152206685882237385980473593871809885049913814244660776752942318320367868422311382884565495406245871770171500758664214140530, + 16407379234535226782272828564066658318726156512863643464757583252208349461195887089829744964774863856842472560226876262923333461379279679571481971757674089954579996754996300563107965493156758920294395599931686120262200121860391848493795011276770223547621400990974518438811401520262460678897369985489051519886798992512598630505982910145119974244390828839220565638636120664539496818546165413603454023068472946, + 16407379234535226782272828564066658318726156512863643464757583252208349461195887089829744964774863856842472560226876262923342464801967728648620006901705856930627666494498535177996779736836210904742046485787135381541376068514353520454243445293286647794225286162252158233345419925223256010157891715194563879008842592091305156886696366112578587566639503503816876091678907519169866328310241721632258154670249586, + 20130869397570307530812050273335080045523454110951293152952935234773930558441758411260367838783695207933551291393603658718705609502750044158630187469378668241980060018968403090422344641158106550172087560402490047156185741254609841356918488662998832799673623503068872654420572753262741369685118769966439601522324906142359351977783590218982033772819740610172583840710703492701919883991295034214686197560470197, + 20130869397570307530812050273335080045523454110951293152952935234773930558441758411260367838783695207933551291393603668159478558046499153250969375723467344403324828314131944743706725066202150730147374323967085120353624365768747440534065791389069639715170981125494065957303572924188013202518366457293918357511796747916965534970588124101905023999104844301960839748594514074985644817991467295924005077303257781, + 20130869397570307530812050273335080045523454110951293152952935234773930558441758411260367838783695207933551291393613335510977866845586863806298147910271733620367562561598597706912280311303391024841020214112440074530775868245648997932903782885575921184465186488892008109495747951666370023763998280632164490730962725113696919602430820215047015715051024694715275448134498218702022605916619631873362653669583541, + 18641473332356275231396361589627711354804535071716233277674794441747698119627706712612153301886829810687416112954396151147455434433355806529304003945842775481080116349304358129719166872267364032038972996610579983788477501444007833686277916865568019665273333716106265695860502475016995442946846899251968993511741299376532291918367097848739750460091970913119625931469924728121791900813099768637209977155248788, + 18641473332356275231396361589627711354804535071716233277674794441747698119627706712612153301886829810687416123091348916886678746628539070951928554545070425283186387942401904358015854150410612716471878052327011244602338720971458877632049357436165966305956464076696442757982115620499189902581635624029355413695446339184904011005286631825845290442143433569941328135571406728003410616867282199744911039095661204, + 18641473332356275231396361589627711354804535071716233277674794441747698119627706712612153301886829810687426503330981033851350434496201839719468368154183822640008499274289242133823626969097265575766655105952622317996227517081327878102004501728463326365481953321037754370513976594266316568605289796073049681809407102957544356010889424381918232062841195773679676289867609033195436527076589555419311491961873044, + 17152077267142242931980672905920342664085616032481173402396653648721465680813655013963938764989964413451920690265152253376344168304830391746580640634179199856537943359996282919749947968219926961875747719946734112257235757487914272056366152471430642408063458917807318889491331505036556052488175606054118528384617818739793763022113629691130444033563097943135783305220972964483022308272943657877951759411534451, + 17152077267142242931980672905920342664085616032481173402396653648721465680813655013963938764989964424336390842751830600956121690660253583574175630323926026958749888457091888330941075143928514842019530248703629182595505459484951055741747592468052419407473333352972741098143760343647508471685280494815000392906451478862198357975920906431963308810212221498598301064361808252341572937745412776617305913619602035] + +def h1CodeData_10 : List (ℕ) := [ + 17152077267142242931980672905920342664085616032481173402396653648721465680813655013963938764989975570033826989110458522648304582613602015031445072624676979623781667882991829390655303069522504109252839695764181208983680304450617549572342149008752066803184754962365082758230891081262785729520686585958029663264119444204503590674572289044816840098916399447074628508298795667905144341487641387553298327792212595, + 15662681201928210632564984222212973973366696993246113527118512855695233241999603315315724228104523366962305681896333783144771300164349161341697125341529219503401231886722110071208585156151951812318561293893923827531369819068437789860904082654087471075439963159201448566792738637173680410991657167098369382180262914234094383360427618258182999473006093117206422824880672981150066766787144228304093924408578642, + 15662681201928210632564984222212973973366696993246113527118512855695233241999603315315724239791634201766909826527950085512884174449212899104427077572470907866544524343318740977469892799041830247005322259295545834357604537777872699378623303327555076575065453343250016089993064314139592429769083560158563944224689687285776604432602273762607583692444841858409424156162379164670759855845015144217438963708351058, + 15662681201928210632564984222212973973366696993246113527118512855695233241999603315315736207393129041681553929303043710460467442149680368139898162056759791725275999898268788989048919118277347366248550830556480824421956496239220045523105272958383108191567401808983159847126557527233499657853710053797795477717705292208370982339449510293381824399420479425020281119601823059372750759368279400917388440753558098, + 14173285136714178333149295538505605282647777954011053651840372062669000803185551616679776494426979717030979992549799104486918924750321994528631810716686079696735848739347439718429948232407014451817297021602768157287388313838630758591849311933721371737753459626417568066056901841446403055652115305492464382802348571828195321239353431911213587625450061312558145613977836638781066560188216272499849125784275505, + 14173285136714178333149295538505605282647777954011053651840372062669000803185551629228716199480238054885691489122672141559431210127133332656516008417367132912447356040891229207531666934005842039459635527770909875206583879593461554917636927067801676884867864223365848075836314998311999120962309556336928355133295886150603371487245925041437091390048268999908645716114024451776021591257868731944149210232343089, + 14173285136714178333149295538505605282647777954011053651840372062669000803185564479342974174016776018110263979744662103812011435981943575609934453914765625801030832821731666047691617371205291785214265843948029024462843212540196992524154824366034147530018171498404578089955387628682369998601222421068036022023345752296446825329158890390304948076265753378014330819217801739172106668351061311967771381184678449, + 12683889071500146033733606854798236591928858914775993776562231269642768364384671297694925562534784962826359198213266898155348068629585693976765780237017441532823395374103440223470489943767296238223687426403051978955569759307051457879110328320581925230640811383305263270344650895637898428981473713465519743287385580478871961909311709918458460658117761495347754588666203590771192404189778217174785140139246096, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059661697953033845622240702784167303698334618189699445519155435534125439275202355408891523296351616743961654839494090149413884414424993217832338026132074398602070328552624640101764118281140897239249698503734565884529930787169243380351256947758347470516367209015263502507983376, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812709791338792411104924338901916665928853180985985906649179944275679576641657471031572382397101361986980383504950924838821464894824559563341222720640276814833535731993172754929709404690691652922302579703561612657748683424884518463622879057509298053544336976810631484024534128411151, + 16407379234535226782272828564066658318726156512863643464757583252208349461195887089829744964774863856842472560226876262923333452303248744038138082609343412770128335797597608794342956607830469150148783048635460868990749339656103580679318752774737444894147001913180891785792718033967137296506986395035719350169942093722700740862453965129023745803541787836534482156906920906464857575666633785746380760511338098, + 16407379234535226782272828564066658318726156512863643464757583252208349461195887089829744964774863856842472560226876262923333170946289742504477519011092420052126846118238163962627681162715486275634793958452478079575775091323167278430554739211721306636440630501578465542213529958812112442405095090982422088947378231235866161913056669630040664137221516753265894223301728406151041046401153322177109621240157810, + 16407379234535226782272828564066658318726156512863643464757583252208349461195887089829744964774863856842472560226876262923045061420272172036060394402075876818601414454166656286185625364973022773309965611078101718642144798396393775696204850683195730745116305020693992117124941000066661842068476081793032111345456835422636497224676975426791826657283178458303170986851411768483566827428454055548342524507248210, + 20130869397570307530812050273335080045523454110951293152952935234773930558441758411260367838783695207933551291393603658414164546646500072897586987848279033527097970719124417875800267853253459963721271858352019238343365140463831209125397607929899774512076934547506769644650153392910313246045336586504262867458148395117372055752209250416307098604229898555598720857305528091835082286982621687907542760313154229, + 20130869397570307530812050273335080045523454110951293152952935234773930558441758411260367838783695207933551291393603356309430193246528581942732963717441396364065385273891084970700094251844046204512095424284976896025329156011428035456683920695633953216161490629900583952394147923301614595381410592024942675795049458329974199982464166162771411363106580418373035227346962614167643825708407839397210933619944117, + 18641473332356275231396361589627711354804535071716233277674794441747698119627706712612153301886829810687416112944177448762637668997675178238555390487577425027650573736811316248440641985898268015219988213288136888173319195461561219601210138339597464166025097799891506635801063754037165028725845117949948455821343008779023136845955473855584086775731132107811820139537008813801137784645272682572651864460649108] + +def h1CodeData_11 : List (ℕ) := [ + 18641473332356275231396361589627711354804535071716233277674794441747698119627706712612153301886829810687416112627397674833286940491575701225348373281351560971334752749527017928806370508456291493831459930297146717310611010491509412913833676847161634289767426285119485790630773018711118202313466617807537173505815330350455784851047112881736345944541923730592071165503235345597922038129083910097647390570603156, + 18641473332356275231396361589627711354804535071716233277674794441747698119627706712612153301886829810687415788244909171178140950245711239701362754106066767303934061770405538623312377607872333591978498147371346371267051985613076006649147578588027341787907254746233819802739152363280895494000227424931171727627254056482560774069622025614359066518895118710765105093389922491027776097244936931032474286293803668, + 17152077267142242931980672905920342664085616032481173402396653648721465680813655013963938764989964413440948442127564876009832295802455973206431855362314535716313939383083888156230602073889575562803022132568299278951113918452614542014059194479022771149271564282401800716952638359972780078857826203259124200207883938079761643119423766769013385016719164539437675166942913156320189033447037603420212654607391347, + 17152077267142242931980672905920342664085616032481173402396653648721465680813655013963938764989964413100808749862356177647964248228848998461819511934509947369369816098799650487130879349648682191548528928696511690633420605810590504840708686665088004440340559742479402044050930574758783393804398028997315887593590926477780711571990814312393900008509900358466817124388359214586057584679747749996396428114221683, + 17152077267142242931980672905920342664085616032481173402396653648721465680813655013963938764989964064797763870288649055095083532855306859978779841862611480098587572991740277329014809726973870026947488008475869439808790141905413426908502606773191140459224577817185891367173207739208305979497041588649096222894913802560833673050157958605742227155737945014390814985211439044165081639644131924748202377447430771, + 15662681201928210632564984222212973973366696993246113527118512855695233241999603315315724228092742005233672008363439008646416347670110387412500824986457705704648063245132798951343402386350651531638433355152520378937165054306853044047826525221317873358978797488065786894843311695070204754899832119621798388489589355246260992422141311901772361910548257455819174837171339352725096940377842787532820144953381458, + 15662681201928210632564984222212973973366696993246113527118512855695233241999603315315724227727519791646028128843700999197412820348708395607415513979240777943299835355864154235522736522510342830554472230493871504730523537819746341166784107793653032188355269927457946388624986195981231636192385347967395364049797534458233666551647790661266077401411242934004898298378826266775452758669067030919993026597769810, + 15662681201928210632564984222212973973366696993246113527118512855695233241999603315315723853739973077898695500631979323417800843233068787200057042589106750322714476744771965235160891950034232920578121337641967286291012539117829236599769046242689656200339584037903785646214564533072047035314740770041169378628140796804402592242058814519679382379369676277464596707088686432020932746214675518699168976169751122, + 14173285136714178333149295538505605282647777954011053651840372062669000803185551616667126353595272803383949033379866772796321634140063112131325475839971683473736139558599915737090127951457822085297337034745448080362178105629785046872766185979531956555826647401647860650043480363571335738257280514978753701246648311247046971786341042074106903788118681514839847476897874173342419206429049740735662888747354673, + 14173285136714178333149295538505605282647777954011053651840372062669000803185551616274971987812358480325989299111964490387805625222037757814829094661825400560745154955426672315555699242032858723183673198823150682515801360104603958710372292090686523184620736897483752581870469158966867698706625168368449415952963174591988609941034319229593474600732522207891316383516831574408411542896203745884433643597285937, + 14173285136714178333149295538505605282647777954011053651840372062669000803185551214708901426108091668975221408780027304067412493164074937722534768240031697657976921306025408664300700790870375918628841001442615709101543255950018476285168607800116758476959789795138792268929248139267793608780409141345602301362649116274931002008474539062441354131944371655354107073003852376012500043684589178033251077910514225, + 12683889071500146033733606854798236591928858914775993776562231269642768364371088312404431704042011448542766530427231959686030623132100497279487649309475023045618003290895879631171911680813448854585584487911817470259943524594970990040732911926615657662274930405160898202600550686488008285193123942468330660338905252392013585567126228315787304571996966293742116435908160046226546213757429975333925018210419216, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059399663865590555660049942250848711461501269915985529244179967022448209019534219878592212337431338778765896339577434613589158770035479885805861758798756780571923768757361133580016427448373389724487398484212093135081473365136038649973471576781315333230893450813487452325954064, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642782592833422795821573912646467311817718425532012277565855594322830297251274940931837291323108274214477622480003429852197763526672490132895004406943620711456664688134293299792818822066372694531614821522602117600896732140662290829019816004619704424386682762470965658380548333064469294463269883615875483580745479874414943084409951054836810256, + 16407379234535226782272828564066658318726156512863643464757583252222492540124187286309811919324623668403475253366019459004130503502199110280092023266559481321015973935844278154933061954943751526729845416580314447739288718506347567194148236957063919565515685612893568252391922557663967344398982466645568531467239769626716547613279830360205443441985757352223797467290429706705820318224022062946375853481316979] + +def h1CodeData_12 : List (ℕ) := [ + 16407379234535226782272828564066658318726156512863643464757583266690434986094792401307707772713429294953846240660519966786550278118521678630698620979211932514994287853318488612382253566258366845074882267779213706135661675873280719323506785284725655920302263890280326495164334550550709900550141037968903010572622369967713107260784102976543445094214458434912932473910068285264988640177381758216014716840104563, + 16407379234535226782272828564066658318726156512863643464757598081863499659994430159153061642850390882533737230229039935984399485232831669651854678735321955148787739346909997040354463552424452830392617895452054304021570019612828499786660272810343683221758419934320767094114215266575087399336518073063409614484405119148190186305159262108479198011957075948469954800061107449300443089070691764889117191321604723, + 20130869397570307530812050273335080045523454110951293152968120801647306830469365514226047537107887915433189279560215790368131210154482535836320014071128559991820649058796249550177268763059565366789434591076137654930354307993259927459310109500208969351632438519321207242923209037227012771297473756905078047932722341949873489759229932382674474793807256366980565613827338144708534126486172860116764244954638038, + 20130869397570307530812050273335080045523454110951293168502955713110805817030935964005780271741546087207467079955437394298330304867627535570737684894221812594013993268337618938235722852837705896742957267578906469157799348046706859090645771948804621041912474268362691713044895014887180195383425014261781449440727009883509524486091803148914483953833055820147429921172960634572920160762091428303436000608970454, + 20130869397570307530812050273335080045523454110951309076173905051733768056079076538452100536607513984067934684662359818822203291128107263614432607741712477239998463838699872310092710785653608569150178006414172238061520362776364849578364119310751951888669081286842789117651336138898622459397512547526064593637506973926809084792647469644474364226225547902978641427612342969527214359956325027871462355651847894, + 21620265462784339830227738957042448736242373150202658406504168594673333280189076470132266296255505766432897083000039083566955864537395446291690710862537545821598191420715061222567297467585565017600035062603588727037905154371163009012171910865135529329409063578568923694158332428453050202077378300200767420371665792708664388216979276353049700219322604295474095854733871045410440009851235857025677126747942647, + 21620265462784339830227738957042448736242373166883060379877864505926105423240067094850318393408924128111970248888256628207396933328708591739110441233709373633810979590906709535545937835546187091493479990242482715204646320228196658765975312149525497985370073365185056297766383850536481037926658429162976703119242459588412395131471237191125304223978429278289583066935693639912335933120121100292140920984170231, + 21620265462784339830227738957042448736242390247614681114542477628764779907454466806135665878509326487482892118423022340019051375633369529896914341313661053339706065867154582025673674627223190758381085892469926597947600157830654006660658227364853401689444094860104842392411040063969656947589510486465282236637749344450371475571241045950016220708767700602601131712081609364600744429765261255287196785520275191, + 17896775299749259081688517247774027009462583318706663722910963433001870645753899840900867747312511132215807790856383839367056655737950142967445830105037644337735832470794389650196369927911882080253995814737151410993689563663474017412484797517983853879759928320517211328132282245292658946718296781884854051329307994120063324010099010877877574732737321886800841946698779880992908142232234988872843926484769428, + 17896775299749259081688517247774027027373028558650135404280857118937830244145560585425404386816890855986077077347412456735550707885839900349776065517536932983723035359938597831930439433708892418500529858933942486556907397979500032444989625189938257000922985330141189443165939151155309581477134604211968753204609007724794536016377918124039698602345521469237869631324844713486676028571629958886170214542301844, + 17896775299749259081688517247774045367668954260765137127051991517360458997206162978550923239301727996741826444160716642073460107324951459855937127916808506474618793843607775927617613369847478782951391116448003863291969737590139425729933161271247053071893363185094779237630610754509559574527064667177423473512846938969555630447935361333808235519018549247461009579504082848015654610122754591929989423851854484, + 19386171364963291381104205931500194521415792265761961119971756295158534570077065237730442720671825527875313239433318980391499775653235060098771783202240892634645315388179761243858665879768970511270043746616882449877849344543045843222110863928969218866278096252113802159457968357707488136837786502373941495536159291443632860671469214364112667599422417262277674946319058648880080283306644178371059028601889461, + 19386171364963291381104205950731388662004813205808417584994716701525903844292039221786705861261530628523368866682763864077926041495855792440938161791685682145493087280270624517955926334104660937564002811039053794605668910355498996175400858381118132701207732067486122746949127143748200460303490567022743426433152198052987463281738651804084146967597189998484621699838385409898673776150278032819504719378277045, + 19386171364963291381104225643474188625162255813379837768506172821712040640425398895400161825119553692132331170114324758978422264339485710819309837383150141253611504781314617193550631573851657462578084779342510795892904302307527620344355177381605899669154807008742404337895724049437619689184452767395920664953888566032100538201019885442662124364259563286151969778611041465457291738962892531272936192270426805, + 15662681201928210632585169302832929171586188368426455996041887909750538783739833354148445941726339476618651152865953741300410816348302069751243449963612840128332445576181494736249017698213035505962486363447168998283305362101334535950099340417020687938075911396265135919849169742546275757709191443624359960097952760204660574882696298841393779654454291914892375978090423749083744793423402809081322456326196818, + 15662681201928210653234506777047096950125865177916801704654568208327681117492952257349204332118286307874934205262884924027775298433595589209348445400286594506082020281845299129890490644841248671976482129175750762421656852467951121394099595877756870010129514142990644338646149931003618841529409948320419079755742826676243475804610759466695502451962081101019658064977637622500818352628998959919552337876209234] + +def h1CodeData_13 : List (ℕ) := [ + 15662681201928231798156080372354902174754918096030807324039193951321430880686709134925796093471841514308779859720416036849004953774159514308863772554211077321646518881580998218758787992131530670308146235243477240093582987883334616050361187671607311793018726789911265186753862911322936673433158757084957609332770893577136071303368630145558538051711813331321929419106683060918584893064141701192127745262997074, + 17152077267163916497263130651254820885624025284007621449174095569947420829907803472003974256409238299812865202681392118086986665189665482402108304943842850552871514967485654561249422607645847336970805212145203345701268347791666881498481451895825963524752814144261314322783951422218842937501141996872930797892578947916628517745507455392328206104860304543882693611521791796264393244862457638309836980112512627, + 17152077289335973781217404128426041519416689595563973302497180984099111486719465224286727321913379875953833662825549751794065052347990631785794058462335663912555231427893463725008654862382529959992489284504254663320637668954959565653358280416668898363793271581187739716030002731233749242812041081626120559674857618205659082742863220971586365721990737541362730407558276733006040329849756039925388257187780211, + 17152099993522632550393444751755970523104944629268271105336645075430344061861099561825866398154353844305536850442966667842333502472943600680005661398976544228680886885490047414462483712745535934196979380172803905554822540166668140247230685759834173541221686993847342399986543162497805881172703868892436624728215994175058333385762112908406148279726298189504736329886848714921175195240025009630836960513414771, + 13451858917626131438119821332334848573080801544381571524752522616046919909648789880473657594902866085358522239511161305483082790556563687832024875440094560102813495190210123148903447107900589948559303386131916837621490361872744290969214947367395733859939171993906596022543414464360282662331732338508837102879434902562597004602859104929499741217657350791636191902368146505591490184829605761151526492569092624, + 12683889071500146033733606854798236591928858914775993776562231269642768350041038830933410994165953879352502016160371874556125623285218252137859462212829651441899232763421992406002774758723788804465814909785074972543361610944602008047946146237670282517819862907352876955559681655903197056529702632078493113547297921009469410147928580995577338211379843685762004532432849160453618693678918957407316788883505680, + 12683889071500146033733606854798236591928858914775993776562231269642326823477135919400360521270037472930793325639519381254496521119244853621979621923592815124418947780697460111982466861030572416058882993377262506135329495070658925371184386028065556512682082555232595377244167361103609448497642107191130137059857933960465257689571137112968328886019520613744900054280368635859646479440294609342791608898698768, + 16407379234535226782272828564066658318726156512863643464757583251755784719286425830987299149860468648192172963453293636172439543030704833881685358824215853863145705744958013301466958999740054258396134550412608020049083139236446497770620541849719992586329021797493995405850877009506330487748945093377073870850937105099587626334328079630646097406862679974041991219045745582998649960185428440626749095596970611, + 16407379234535226782272828564066658318726156512863643464757582788781626448227062151054631841418688598580301370029277387135006755308382646662274232019337415655839660385783278663092827437672364071354955312047831751365148503494585629631146995364544429233158516921117731637133693237130568690911870811030370539478693894187697717614191355907828319098957547687042812318251741812742150880434875595359514837059818099, + 16407379234535226782272828564066658318726156512863643464757108703243556883438653900003307997035917796023789703836638372803832127650462933985280383823816691374449212590855008967982107880357612541187415226516932619016081503829056654810235394544767555586561523511823632470737510324350488809797551908700325493635140319255394164943505916238008288344915805677394001549637501443491288541363779497957361227681911411, + 20130869397570307530812050273335080045523454110951293152466997094825903637354476144878314223087447329246922253741015093467157045808897213264242024689738455069169250858488463440885060566615109220661901601511532209310114145410890671600234765550254270910010501882255352905177348199237975112455991458280668260787302836532659424122879549454674253625265185922375721684534159402589441548061929714106819794730542806, + 20130869397570307530812050273335080045523454110951292655352279927993936067384221751926866714810385832470032641093923767700786014988257221762876558350754371798982236153164643023014529693714612262149175953422930154031872863700588859397493567195193416821049357912927849861283396914112617541705551222866159412531153462656306312863299684933227113439661219091452766348731321211101604554356916574011717412499285718, + 20130869397570307530812050273335080045523454110950783609881901092059144417843723369644618239099413132935069290472406182936850454652905924364639027231053103127479177901572535123590915843605726912095866369445994162970783234498470307518697344206382222689905037492230637199842656102776853723572646797721675229440328320925885054305410522385476043883309371747184032014617351690773677659087468124869286783399814870, + 21620265462784339830227738957042448736242373149664580923492113887858727727187431611270393647960234206378733432487515936965651313931224054503064267947338454601849391802321782244729276810554577208764762645582979243548655439343516762245920188243058433566313547133839371029525814640643907271888691844427792927379808480873833807348769858203135926079396108215599511081412890955028330128435019780903379903590559479, + 21620265462784339830227738957042448736242372615891717775533844727770019149555731620292726539050846632648392124064554508471537112609203400185632896069839964611040170356189036229412785035814670844174524961138371622212938131918439970124211347142579436575561233962123127714068169133974120524711727717637095879457355140721897586085027109575465203597344155272207279530206007723624150183196878879851788364388626167, + 17896775299749259081688517247774027009444528434392204578070872814366854557449069537730984141829139781687813567785324334712451318991833318615245900432242786183858829242075494279045428325587489932735602131224856258699775029556300604090879449909443577263710368787241380705032449929863279948928611510995754261107449448540897688856422987488150925736527479949905261751970323100473697180613361873273540753332329108] + +def h1CodeData_14 : List (ℕ) := [ + 17896775299749259081688517247774027008884827020643971088028063636681355819999330139464592371844627915319992652582479690419685879862211763697048080575602183413671729151789737773366238653531333359665397942343706537588424472233924791121113674044695002166174023255690631388937648151555154087532527819874301964172040219487652639751831889590148867606003935541052546246984208359952636589478556721409700284609550996, + 17896775299749259081688517247774026435750579342452877284191465686730648671466186314679419907704476754671375484869563934627876211129739527462480547375624946742081236699175075957876014468027002535776308528046392119565453774121092310080959188542154102288956198947723331707860627163950333775249717505406631504162407784136253855550905005039533106719414771767307521332424481400397413977593286359639132456694274708, + 17896775299749259081688517247773439546280956874772822155515164937206528573526909734662816628189688250487395746843830003814775429078169623265326550598934595033416965221761376895886448511592409858568904449202688654617889264912544680411681809212729149021606558773355353917231379702270145169478031301098989810067410061415659349795985672263505605119508106690872536165845792436878858575984970468451005789815659156, + 19386171364963291381104205930879833420106469009631430266261338217533780722521743496309272941943125363338279186941401403498389250948634391313540609699355576843972806617467152751145851026403303078163787002603264019402758390807160257642972477011157963581280366064521146656635672912996497416725989597062689820345933713811073034780754163556692162182841947592774794641938823094371033557691608471569959209027789493, + 19386171364963291381104205315481620921257798928144823385526605213777963947642576006508852443072562142600499114959165125532748743984770956364216494837122312496844106070559527980033516487661209436757096941093780988112532284808659363137692654542392720863532019972606887856918591759693703065823459528301028031642160702311725751250235027887540633855429433015770155847052391313014186785472852072834048388162675381, + 15662681201928210632564353438443600373422337887771727824964657385256005374129195129447638725606992756022626673982489092930725973120393507735660682831116193198516165762970140094723169439194257065270939996747845831182359443260239156327675953062725590980341986393496259399265705044691715193359004004353785050735919526572776693377566230991697358851305231840608453503171747794001295442039212127171579892695944786, + 15662681201928210631919061642374407630342972987475154521570511125925469676199410163722615025907244417545867828595084993470495833055228085252594901723720138374211491553418146207421873409612125403833002629068827651053035959186282388032550945079577585290590311307661087261178299413886361464682732782182551601399314370963641771564483932620392786308745592043613466664242228493420628831777660683605757453527535186, + 15662681201928209971140262467521038717073315083784091845964741571456914996099605261298346533364945817344810151893287146194832406325835462593235047750159998286225100972176405610894739117509304091385138125754211198625788267454551653824542770336019758984875023412444817859674933383251382782435740631908659772350032243872988940120552300385008585869034431264021533241444545491934753685386174117878116038718639698, + 15662681201927533333649907417671271528943621704135912025656717795656922573899385178847410170051179211461749209252291535915483435427789859408744578824576548188161145780634034767109224004395369010211796216397808661340838861826035093520062016727711122523339204789755095852512473453795171353014757736715208754954379088627585243441760717773254986733469255288730704498258583912229926499043733353351310196138954322, + 17152077266448688842942025055217039574856519983634835905518512169490914679688072447736788673651040184453479123321903162160951878507138864680053925798085017863849459597795080072095898986525309187841073467875556529003869337431560665880582199362895546271880541323715300600421175573540942734104016219945408547512505442423433919220013861691495084132404723244500743978597931334083380053220687604774236934610015859, + 17152076556942855756405273785737979293491262013831576599179778916636813661714896374688690577518509747942488398708858883534443489440734084402109813206314990353970532864745186831800466834951465251147183152385914365184051060206194772924523686695921631422585903342069688016547533685063940964155245507843336170479587993174453850011683724008665354855238280041779164680827223967480911477719566115088545934699320947, + 13427859859934694394232752129911829448669803337206397220121576011471790159936726252005617263798511409596907663784790174203709445574019019266676326154663392399410977947472886502998164246772210505567966132357027497951494882348016152517247905920952604376896712573588507380997709486129847118709109977299132243850954322138839704820647543537177896854019394977149721462531586504844475423951533869558302536687436304, + 12683889071500146033733606854798236591928858914775993776562231269642767918862753769496366999563516460986855816267285104543135751115134293740871298306297193593932943422618550479934395551792447772836511265335457968181635017081443860506269621081215590402580470543727759493080857911474681834256157481585152283837098114754885802802211638223180807594278686120104395516584422383029994474432549399359192616342667792, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210129, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210160, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933211152] + +def h1CodeData_15 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933242896, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729934258704, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729966764560, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062731006951952, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624253102841178480101642226618159224980954845818944204725369536490074521263836421734615335484394670932496, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568626422855560163227930619748827459905375385189894390271462303900931633194639042202650453060556001540325904, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568695854942567675158457900459525081677997156200308664407044203563061510742645627191957260262847421360914960, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739570917681726808056935330883201848978401893828533565436745664992751217592278856346849775090736172855619764752, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739642016138822500273795266330956213673566587343197782151581530246772212201437599375899945665882586751902958096, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862741917166765884651213313200659095883918836779812452717026329218375444039694517376305505404070567831432965145104, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862814721986831873481277887099159565331767482938828610633018255238492942519473070238052880073020495661226955129360, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062764292948496, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183063829444837904, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183097914305298960, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072184188629840052752, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072219091526952174096] + +def h1CodeData_16 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705073335984234540057104, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705109076550877352313360, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041706252774683447344513552, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041742851114925687094919696, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862042913998002677359107916304, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862080390698410730863523807760, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767863279645111468443004832334352, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767901655786329315231526705185296, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402769129692305300412464226636415504, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402808426860912375523910624435782160, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643118323528256413924042094920570341295741616012765680646448884602109943341263242841141143402329374743731919603693698222797414982722331206599632646699496725286354985907475755724313037850034704, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643253207083808217562288513224800753808589220844198695857409229839894212226097025989889239198104634251286105386695389494223264277238286786908495173117144457677555825746366945503072583271596560, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006647569480861465933986173898960173954219712575450055182608140277448990816540778086749828304662912938493020050442749510179850441701748865356792096018481871894195982700590885018423378036761575952, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006785690241746512859550506242492116367375659922837462758631533800940082154610572031067878399536778674228506292236481372119920119286087379593067323070153149862785642695615463351873152548440916496, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263011205554590068014477609141235514273588365975039234505191380126552655004972843978249245481435500482217764066029635900954202149801984919835153874588723634044857654762536401970022265936922179813904, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263152641213736356066255485461012223304660056058763939863039335094607532535156312977230928778586338995610901977626417327580833499648347558413099707089635022684693466597441570183474835036881824530960] + +def h1CodeData_17 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643267678582306417573723147527693866912298954138737954511314173894072363613501027320944644794287413171424191315148723422979633036694731951992907366347118799459159439445314406953013957046235590455476752, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643412508697272216538743692879145216960116364784472052797750479781360558204408899575901888490569871809138764536623827603845303538937407293896723898828052061426351310764257299203589387804594266645742096, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669404065936256338779090195354015515152, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669444306236909983693211306700566970896, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830670731995857826620945086869790213554704, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830711938063727159013005104888658904236560, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911832030532235545795558925681492457006055952, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911874225545733742165028384132813996264276496, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403913224465977676025988051054575103252527333904, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403956432159799829108324776508728359452945170960, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927405339078362108727743099991041632557866315956752, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927449583756835993484055906856094566907094181102096, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300937291704371755672804111132820519355629991396375497659751048917996116021060158169337623057091098044108481860485647, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225886703277800036751703350360976748782465901223762232164435311196755893685482386050872578709374477737727947821313601413829266305610599090656044221152909338193325, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_18 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621928865413468000305686065726537788466082385865753104, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621974171964225258296150379956351993239691719774585360, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635377204126574138486584608690802899556757443646887886095563648127739642087154066535318877382250746188663900169533145584, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920225780402824579472380442560627886570663656882401367799354156945748263235231718316249130218104481872026267567957947768283950676461503480385385135588817289293966765, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155623423981588457513991008435310406545995190404857217552, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155669817889563889696226466206640152234171148327501447696, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142665949173410349817165020065231600757420723810031139712161788823481232683428840166309915161978500230750925330711016814357450744798698518839953735488450667222715638729876965144764130204817507586446721411670159160515480609602004007433135482119206982312737263, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057494956968918135832264780823039073604418626307209070222989523072779924359285458055184092215232686580867897713919979455835748672428524289970294497324768107698415373798285984679082753481697865948069380624, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397157154422944777719527761114889192014255801801852116812304, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397204661784711620274136869872730851598947982714639808479760, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142666170908166201037197278513870687453642951162859567274150519295146522327792369662444202874324933529652711887075897776033971191995667703249833146465737676410485140307115629291397649840449547623696831934646204568273104141892654123025037100562754473956948463] + +def h1CodeData_19 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469865905777880376265498427062456942150307443854318441172192495809424489682253418763134227588819509227599378531096527708579508017433021949929555247483376176444724458784790040924214734828086389846622229232108048, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544398724897361250582021628350123663958309097771923845941838352, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544447372435810497357941355718153523373033891026618442209313296, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764142893227298157850154674452930802301847947539062317518671959046556613065275213238977317697380329431825992457703420773911259221594306500831771086310289207441223161261624618485791134143798804233256886797010248506471579786313904726919924209281925654958127397359, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469710547491449499964795499882681217581661411432960762232977524342268031919249356439518173755953059610840568559014302115585976524294610147454113515823900562459727057655679750802004723386093543830042103534600720, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263546004093666186394187372631495109024644227275176845522768511504, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263595819173038215092729173456357685065322415567984112100662854160, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008668764375398970649606540193525792204994240423646463407999843511043739137071351247516706155388137553153294347022160799190620492901632684260049807285888404132562018578117689951088192625700343430664321293868299967223394961628253858630612730017799642984360044608829935, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905310623662186232168044998067788445036181000545719406098831331892495419578668338578208147968145012639010983410341453851067906830337366629325655041958235440454924467680283774612225765977572913931875608226714632720, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097265189901712943133446066799851960118367024440937816642593281819152, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097316200542989900520752870844511237984021489252772457618357088698896] + +def h1CodeData_20 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008669002461280162533064939728488771736540903788974283010383470194657800365342036912932336423104987299751942093597719943247411646282560753827812566493227335257742323640962670769496826562173127308578459977559825196476872899448568597564619396775182021453866071732206063, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482742405653109643684282172427603165980142476316735254105026889729698006260923823670986132062838359749527514509497787985775930768424100896825021110140162518485958085405374237935000295305330076821979290993160748548624, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461098948541063852536914570600273608129684964363231480968842798908850704, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461151183437731456901516737942004708664115136330550153328024937153708560, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805713474443033215270940272435630033489618098501942952928383957048186349074512481017173856492250619828661200199794500845072, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172920116928738726718556209037107586511575298061504274171199770687919988440585645208928565095854522712271175756585211211436159415977422443096946683669276966821534477741, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891462822700131094796568786092877399925765880639284747668821853360989159952, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891516311234318721665921405450810046873022376733819068164624362923723604496, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729885685047083433734903516605216828386696811626199441818312812488031250214533571387925033458963990680910230198582102670688784, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359172808652824702517044396678436669793473066363270974175336366828875733823154835232334797718480213294917726169886167429264712512405803876743919995069308336470476729986477, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData_21 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546893227944328322781485205224904654749185230251758917324030304668931225829904, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546948000203336452695702287447427685223175882252562061511732074461171297042960, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509649883223924809211876864625956119382962987158862223317375228539850702651849546766309191786118435953197502052145055389244525640588391314198710392374802090686742968655320515109535660268744940353918692692725338563166736, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004217008424725881711246718862436896302788827972545015889746427403435931942745298560247694367062976938769303000584866565455334545457287255023889948569043698965812003381886157768887197482841802869337241072246369403867609827944337961591942590446445072194092405494174808750575, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306548700712491596609950648918568164660390876746278262675518188707812853575860752, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306604787505715921642108941114431747865757304395100682323724800975066686498030096, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489359287171041481990569194537353280394213660506518339063450489772004078425425441387114396906334452415228349856857627075529327263819796916526736503078041704102476173958032813, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755647834695170871913298586684916890363520918791701371041975970365044973542030981449799454248916065386446384402441982795589370384, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062308399564888894322671174291382066410437482989157418111066336393527189340007449104, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062365832441150603155601265499946375612732704901551575830829907355195114252308857360, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463680468125626027663903853581073472304358774707883744902270503267175197716132840893041177880411540977461376673326477979951726895097184236115328259237962588451354833963945077896800786582049672068846904382011502044939567632] + +def h1CodeData_22 : List (ℕ) := [ + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013004216758773584925050857450891700630423587171974119454625937488901091893875043699029626646191080997886989504755514146457388121589767503037542111965605298279039314755593553564056137258467703745907850128585925577898226261388753632950446818479953864895501228100543860508670447, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720064203684481525285809364184174004270086179806098164622863264178128568711445953921552, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720123014949773515130729777581743856893236487044389782127901160842876523821642595975696, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855489476165755395354589111073076327713439148301815157257361635750733997275940433417578093057663968334204384028033154234362296456938349341876126130076799319338126116161806773677, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034671791562942190256639050226030410034017321676160870615486170957502448733952315470845050910816059790884458943831694431572640416272, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423722004975439117190168183006303979140834046318669721542289113854114811087347935141708304, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423782227711098114791366686325415508226939960930680337867447920038816717120189296605151760, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023638598348345379350868488011223330041636201087954858153424719482854391732610756090393085289475517688997134279848011350553252355803568581090050821186856756015790978065266643380168252133728196708113716259390390619790228603408, + 11194493006286113734317918171090867901209939875540933901284090476616535925135964069750907553869167108505258650611032314838375170032013003961116005245304812247042296011415249578392765033373047973306764987318675041668007347080567350518607886103353216801211395703121789719353292811603242602505076783110831651569288255743042776962481484075538912953792584816075624216677493424811457778461786100772523447381604847, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985425709355252186038029718792536984438982329228515020060272529717949277710171112863435342352, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985487377436566999581656986191307190223154785791213891177235147251084029487800667002001441296] + +def h1CodeData_23 : List (ℕ) := [ + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128, + 8960398908465065285194385145529814865131561316688344088366879287077187266704144446968499216757201154660315097893421471351046172841839609630003338937122754501682145693782416653467136646900445911869935907422332147268002814888941585855609159836133760895492848968612050511860403636271448387730374524717478779261945177968548559467700422311938235421454074670485205306464560377414507051407898557463841132158234029, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800933948802969287890040215808728915749703262180657395336365218833711719575637024612120825601131012047485799842113541191895849207683629584, + 12683889071500146033733606854798236591928858914775993776562231269642768363950015768399122090766032505751393829060148867137189812710059670150665532016266182340220725967964038919746916023463509482905469866057643263006643113972445819258967969629813982263472746531985945260800934034755729805635300862739568624183110817985423720062306546891461097263544397155621927403911830669402767862041705072183062729933210128] + +def h1CodeData : List (ℕ) := [h1CodeData_0,h1CodeData_1,h1CodeData_2,h1CodeData_3,h1CodeData_4,h1CodeData_5,h1CodeData_6,h1CodeData_7,h1CodeData_8,h1CodeData_9,h1CodeData_10,h1CodeData_11,h1CodeData_12,h1CodeData_13,h1CodeData_14,h1CodeData_15,h1CodeData_16,h1CodeData_17,h1CodeData_18,h1CodeData_19,h1CodeData_20,h1CodeData_21,h1CodeData_22,h1CodeData_23].flatten + +def d1Row (v : Fin 103) : List (Fin 372 × ℤ) := d1Data.getD v.val [] +def d2Row (e : Fin 372) : List (Fin 270 × ℤ) := d2Data.getD e.val [] +def h0Coeff (v : Fin 103) (e : Fin 372) : ℤ := + (((h0CodeData.getD v.val 0 >>> (2*e.val)) % 4 : ℕ) : ℤ) - 1 +def h1Coeff (e : Fin 372) (t : Fin 270) : ℤ := + (((h1CodeData.getD e.val 0 >>> (5*t.val)) % 32 : ℕ) : ℤ) - 16 + +def rowEval {I : Type*} (r : List (I × ℤ)) (c : I → ℤ) : ℤ := + (r.map (fun p => p.2 * c p.1)).sum + +theorem h1_boundary_cert_0 : ∀ j : Fin 270, + h1Coeff (triangleEdges 0).1 j - h1Coeff (triangleEdges 0).2.1 j + + h1Coeff (triangleEdges 0).2.2 j = if j = 0 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_1 : ∀ j : Fin 270, + h1Coeff (triangleEdges 1).1 j - h1Coeff (triangleEdges 1).2.1 j + + h1Coeff (triangleEdges 1).2.2 j = if j = 1 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_2 : ∀ j : Fin 270, + h1Coeff (triangleEdges 2).1 j - h1Coeff (triangleEdges 2).2.1 j + + h1Coeff (triangleEdges 2).2.2 j = if j = 2 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_3 : ∀ j : Fin 270, + h1Coeff (triangleEdges 3).1 j - h1Coeff (triangleEdges 3).2.1 j + + h1Coeff (triangleEdges 3).2.2 j = if j = 3 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_4 : ∀ j : Fin 270, + h1Coeff (triangleEdges 4).1 j - h1Coeff (triangleEdges 4).2.1 j + + h1Coeff (triangleEdges 4).2.2 j = if j = 4 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_5 : ∀ j : Fin 270, + h1Coeff (triangleEdges 5).1 j - h1Coeff (triangleEdges 5).2.1 j + + h1Coeff (triangleEdges 5).2.2 j = if j = 5 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_6 : ∀ j : Fin 270, + h1Coeff (triangleEdges 6).1 j - h1Coeff (triangleEdges 6).2.1 j + + h1Coeff (triangleEdges 6).2.2 j = if j = 6 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_7 : ∀ j : Fin 270, + h1Coeff (triangleEdges 7).1 j - h1Coeff (triangleEdges 7).2.1 j + + h1Coeff (triangleEdges 7).2.2 j = if j = 7 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_8 : ∀ j : Fin 270, + h1Coeff (triangleEdges 8).1 j - h1Coeff (triangleEdges 8).2.1 j + + h1Coeff (triangleEdges 8).2.2 j = if j = 8 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_9 : ∀ j : Fin 270, + h1Coeff (triangleEdges 9).1 j - h1Coeff (triangleEdges 9).2.1 j + + h1Coeff (triangleEdges 9).2.2 j = if j = 9 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_10 : ∀ j : Fin 270, + h1Coeff (triangleEdges 10).1 j - h1Coeff (triangleEdges 10).2.1 j + + h1Coeff (triangleEdges 10).2.2 j = if j = 10 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_11 : ∀ j : Fin 270, + h1Coeff (triangleEdges 11).1 j - h1Coeff (triangleEdges 11).2.1 j + + h1Coeff (triangleEdges 11).2.2 j = if j = 11 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_12 : ∀ j : Fin 270, + h1Coeff (triangleEdges 12).1 j - h1Coeff (triangleEdges 12).2.1 j + + h1Coeff (triangleEdges 12).2.2 j = if j = 12 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_13 : ∀ j : Fin 270, + h1Coeff (triangleEdges 13).1 j - h1Coeff (triangleEdges 13).2.1 j + + h1Coeff (triangleEdges 13).2.2 j = if j = 13 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_14 : ∀ j : Fin 270, + h1Coeff (triangleEdges 14).1 j - h1Coeff (triangleEdges 14).2.1 j + + h1Coeff (triangleEdges 14).2.2 j = if j = 14 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_15 : ∀ j : Fin 270, + h1Coeff (triangleEdges 15).1 j - h1Coeff (triangleEdges 15).2.1 j + + h1Coeff (triangleEdges 15).2.2 j = if j = 15 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_16 : ∀ j : Fin 270, + h1Coeff (triangleEdges 16).1 j - h1Coeff (triangleEdges 16).2.1 j + + h1Coeff (triangleEdges 16).2.2 j = if j = 16 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_17 : ∀ j : Fin 270, + h1Coeff (triangleEdges 17).1 j - h1Coeff (triangleEdges 17).2.1 j + + h1Coeff (triangleEdges 17).2.2 j = if j = 17 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_18 : ∀ j : Fin 270, + h1Coeff (triangleEdges 18).1 j - h1Coeff (triangleEdges 18).2.1 j + + h1Coeff (triangleEdges 18).2.2 j = if j = 18 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_19 : ∀ j : Fin 270, + h1Coeff (triangleEdges 19).1 j - h1Coeff (triangleEdges 19).2.1 j + + h1Coeff (triangleEdges 19).2.2 j = if j = 19 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_20 : ∀ j : Fin 270, + h1Coeff (triangleEdges 20).1 j - h1Coeff (triangleEdges 20).2.1 j + + h1Coeff (triangleEdges 20).2.2 j = if j = 20 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_21 : ∀ j : Fin 270, + h1Coeff (triangleEdges 21).1 j - h1Coeff (triangleEdges 21).2.1 j + + h1Coeff (triangleEdges 21).2.2 j = if j = 21 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_22 : ∀ j : Fin 270, + h1Coeff (triangleEdges 22).1 j - h1Coeff (triangleEdges 22).2.1 j + + h1Coeff (triangleEdges 22).2.2 j = if j = 22 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_23 : ∀ j : Fin 270, + h1Coeff (triangleEdges 23).1 j - h1Coeff (triangleEdges 23).2.1 j + + h1Coeff (triangleEdges 23).2.2 j = if j = 23 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_24 : ∀ j : Fin 270, + h1Coeff (triangleEdges 24).1 j - h1Coeff (triangleEdges 24).2.1 j + + h1Coeff (triangleEdges 24).2.2 j = if j = 24 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_25 : ∀ j : Fin 270, + h1Coeff (triangleEdges 25).1 j - h1Coeff (triangleEdges 25).2.1 j + + h1Coeff (triangleEdges 25).2.2 j = if j = 25 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_26 : ∀ j : Fin 270, + h1Coeff (triangleEdges 26).1 j - h1Coeff (triangleEdges 26).2.1 j + + h1Coeff (triangleEdges 26).2.2 j = if j = 26 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_27 : ∀ j : Fin 270, + h1Coeff (triangleEdges 27).1 j - h1Coeff (triangleEdges 27).2.1 j + + h1Coeff (triangleEdges 27).2.2 j = if j = 27 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_28 : ∀ j : Fin 270, + h1Coeff (triangleEdges 28).1 j - h1Coeff (triangleEdges 28).2.1 j + + h1Coeff (triangleEdges 28).2.2 j = if j = 28 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_29 : ∀ j : Fin 270, + h1Coeff (triangleEdges 29).1 j - h1Coeff (triangleEdges 29).2.1 j + + h1Coeff (triangleEdges 29).2.2 j = if j = 29 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_30 : ∀ j : Fin 270, + h1Coeff (triangleEdges 30).1 j - h1Coeff (triangleEdges 30).2.1 j + + h1Coeff (triangleEdges 30).2.2 j = if j = 30 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_31 : ∀ j : Fin 270, + h1Coeff (triangleEdges 31).1 j - h1Coeff (triangleEdges 31).2.1 j + + h1Coeff (triangleEdges 31).2.2 j = if j = 31 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_32 : ∀ j : Fin 270, + h1Coeff (triangleEdges 32).1 j - h1Coeff (triangleEdges 32).2.1 j + + h1Coeff (triangleEdges 32).2.2 j = if j = 32 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_33 : ∀ j : Fin 270, + h1Coeff (triangleEdges 33).1 j - h1Coeff (triangleEdges 33).2.1 j + + h1Coeff (triangleEdges 33).2.2 j = if j = 33 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_34 : ∀ j : Fin 270, + h1Coeff (triangleEdges 34).1 j - h1Coeff (triangleEdges 34).2.1 j + + h1Coeff (triangleEdges 34).2.2 j = if j = 34 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_35 : ∀ j : Fin 270, + h1Coeff (triangleEdges 35).1 j - h1Coeff (triangleEdges 35).2.1 j + + h1Coeff (triangleEdges 35).2.2 j = if j = 35 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_36 : ∀ j : Fin 270, + h1Coeff (triangleEdges 36).1 j - h1Coeff (triangleEdges 36).2.1 j + + h1Coeff (triangleEdges 36).2.2 j = if j = 36 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_37 : ∀ j : Fin 270, + h1Coeff (triangleEdges 37).1 j - h1Coeff (triangleEdges 37).2.1 j + + h1Coeff (triangleEdges 37).2.2 j = if j = 37 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_38 : ∀ j : Fin 270, + h1Coeff (triangleEdges 38).1 j - h1Coeff (triangleEdges 38).2.1 j + + h1Coeff (triangleEdges 38).2.2 j = if j = 38 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_39 : ∀ j : Fin 270, + h1Coeff (triangleEdges 39).1 j - h1Coeff (triangleEdges 39).2.1 j + + h1Coeff (triangleEdges 39).2.2 j = if j = 39 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_40 : ∀ j : Fin 270, + h1Coeff (triangleEdges 40).1 j - h1Coeff (triangleEdges 40).2.1 j + + h1Coeff (triangleEdges 40).2.2 j = if j = 40 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_41 : ∀ j : Fin 270, + h1Coeff (triangleEdges 41).1 j - h1Coeff (triangleEdges 41).2.1 j + + h1Coeff (triangleEdges 41).2.2 j = if j = 41 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_42 : ∀ j : Fin 270, + h1Coeff (triangleEdges 42).1 j - h1Coeff (triangleEdges 42).2.1 j + + h1Coeff (triangleEdges 42).2.2 j = if j = 42 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_43 : ∀ j : Fin 270, + h1Coeff (triangleEdges 43).1 j - h1Coeff (triangleEdges 43).2.1 j + + h1Coeff (triangleEdges 43).2.2 j = if j = 43 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_44 : ∀ j : Fin 270, + h1Coeff (triangleEdges 44).1 j - h1Coeff (triangleEdges 44).2.1 j + + h1Coeff (triangleEdges 44).2.2 j = if j = 44 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_45 : ∀ j : Fin 270, + h1Coeff (triangleEdges 45).1 j - h1Coeff (triangleEdges 45).2.1 j + + h1Coeff (triangleEdges 45).2.2 j = if j = 45 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_46 : ∀ j : Fin 270, + h1Coeff (triangleEdges 46).1 j - h1Coeff (triangleEdges 46).2.1 j + + h1Coeff (triangleEdges 46).2.2 j = if j = 46 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_47 : ∀ j : Fin 270, + h1Coeff (triangleEdges 47).1 j - h1Coeff (triangleEdges 47).2.1 j + + h1Coeff (triangleEdges 47).2.2 j = if j = 47 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_48 : ∀ j : Fin 270, + h1Coeff (triangleEdges 48).1 j - h1Coeff (triangleEdges 48).2.1 j + + h1Coeff (triangleEdges 48).2.2 j = if j = 48 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_49 : ∀ j : Fin 270, + h1Coeff (triangleEdges 49).1 j - h1Coeff (triangleEdges 49).2.1 j + + h1Coeff (triangleEdges 49).2.2 j = if j = 49 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_50 : ∀ j : Fin 270, + h1Coeff (triangleEdges 50).1 j - h1Coeff (triangleEdges 50).2.1 j + + h1Coeff (triangleEdges 50).2.2 j = if j = 50 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_51 : ∀ j : Fin 270, + h1Coeff (triangleEdges 51).1 j - h1Coeff (triangleEdges 51).2.1 j + + h1Coeff (triangleEdges 51).2.2 j = if j = 51 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_52 : ∀ j : Fin 270, + h1Coeff (triangleEdges 52).1 j - h1Coeff (triangleEdges 52).2.1 j + + h1Coeff (triangleEdges 52).2.2 j = if j = 52 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_53 : ∀ j : Fin 270, + h1Coeff (triangleEdges 53).1 j - h1Coeff (triangleEdges 53).2.1 j + + h1Coeff (triangleEdges 53).2.2 j = if j = 53 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_54 : ∀ j : Fin 270, + h1Coeff (triangleEdges 54).1 j - h1Coeff (triangleEdges 54).2.1 j + + h1Coeff (triangleEdges 54).2.2 j = if j = 54 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_55 : ∀ j : Fin 270, + h1Coeff (triangleEdges 55).1 j - h1Coeff (triangleEdges 55).2.1 j + + h1Coeff (triangleEdges 55).2.2 j = if j = 55 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_56 : ∀ j : Fin 270, + h1Coeff (triangleEdges 56).1 j - h1Coeff (triangleEdges 56).2.1 j + + h1Coeff (triangleEdges 56).2.2 j = if j = 56 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_57 : ∀ j : Fin 270, + h1Coeff (triangleEdges 57).1 j - h1Coeff (triangleEdges 57).2.1 j + + h1Coeff (triangleEdges 57).2.2 j = if j = 57 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_58 : ∀ j : Fin 270, + h1Coeff (triangleEdges 58).1 j - h1Coeff (triangleEdges 58).2.1 j + + h1Coeff (triangleEdges 58).2.2 j = if j = 58 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_59 : ∀ j : Fin 270, + h1Coeff (triangleEdges 59).1 j - h1Coeff (triangleEdges 59).2.1 j + + h1Coeff (triangleEdges 59).2.2 j = if j = 59 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_60 : ∀ j : Fin 270, + h1Coeff (triangleEdges 60).1 j - h1Coeff (triangleEdges 60).2.1 j + + h1Coeff (triangleEdges 60).2.2 j = if j = 60 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_61 : ∀ j : Fin 270, + h1Coeff (triangleEdges 61).1 j - h1Coeff (triangleEdges 61).2.1 j + + h1Coeff (triangleEdges 61).2.2 j = if j = 61 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_62 : ∀ j : Fin 270, + h1Coeff (triangleEdges 62).1 j - h1Coeff (triangleEdges 62).2.1 j + + h1Coeff (triangleEdges 62).2.2 j = if j = 62 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_63 : ∀ j : Fin 270, + h1Coeff (triangleEdges 63).1 j - h1Coeff (triangleEdges 63).2.1 j + + h1Coeff (triangleEdges 63).2.2 j = if j = 63 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_64 : ∀ j : Fin 270, + h1Coeff (triangleEdges 64).1 j - h1Coeff (triangleEdges 64).2.1 j + + h1Coeff (triangleEdges 64).2.2 j = if j = 64 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_65 : ∀ j : Fin 270, + h1Coeff (triangleEdges 65).1 j - h1Coeff (triangleEdges 65).2.1 j + + h1Coeff (triangleEdges 65).2.2 j = if j = 65 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_66 : ∀ j : Fin 270, + h1Coeff (triangleEdges 66).1 j - h1Coeff (triangleEdges 66).2.1 j + + h1Coeff (triangleEdges 66).2.2 j = if j = 66 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_67 : ∀ j : Fin 270, + h1Coeff (triangleEdges 67).1 j - h1Coeff (triangleEdges 67).2.1 j + + h1Coeff (triangleEdges 67).2.2 j = if j = 67 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_68 : ∀ j : Fin 270, + h1Coeff (triangleEdges 68).1 j - h1Coeff (triangleEdges 68).2.1 j + + h1Coeff (triangleEdges 68).2.2 j = if j = 68 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_69 : ∀ j : Fin 270, + h1Coeff (triangleEdges 69).1 j - h1Coeff (triangleEdges 69).2.1 j + + h1Coeff (triangleEdges 69).2.2 j = if j = 69 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_70 : ∀ j : Fin 270, + h1Coeff (triangleEdges 70).1 j - h1Coeff (triangleEdges 70).2.1 j + + h1Coeff (triangleEdges 70).2.2 j = if j = 70 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_71 : ∀ j : Fin 270, + h1Coeff (triangleEdges 71).1 j - h1Coeff (triangleEdges 71).2.1 j + + h1Coeff (triangleEdges 71).2.2 j = if j = 71 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_72 : ∀ j : Fin 270, + h1Coeff (triangleEdges 72).1 j - h1Coeff (triangleEdges 72).2.1 j + + h1Coeff (triangleEdges 72).2.2 j = if j = 72 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_73 : ∀ j : Fin 270, + h1Coeff (triangleEdges 73).1 j - h1Coeff (triangleEdges 73).2.1 j + + h1Coeff (triangleEdges 73).2.2 j = if j = 73 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_74 : ∀ j : Fin 270, + h1Coeff (triangleEdges 74).1 j - h1Coeff (triangleEdges 74).2.1 j + + h1Coeff (triangleEdges 74).2.2 j = if j = 74 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_75 : ∀ j : Fin 270, + h1Coeff (triangleEdges 75).1 j - h1Coeff (triangleEdges 75).2.1 j + + h1Coeff (triangleEdges 75).2.2 j = if j = 75 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_76 : ∀ j : Fin 270, + h1Coeff (triangleEdges 76).1 j - h1Coeff (triangleEdges 76).2.1 j + + h1Coeff (triangleEdges 76).2.2 j = if j = 76 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_77 : ∀ j : Fin 270, + h1Coeff (triangleEdges 77).1 j - h1Coeff (triangleEdges 77).2.1 j + + h1Coeff (triangleEdges 77).2.2 j = if j = 77 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_78 : ∀ j : Fin 270, + h1Coeff (triangleEdges 78).1 j - h1Coeff (triangleEdges 78).2.1 j + + h1Coeff (triangleEdges 78).2.2 j = if j = 78 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_79 : ∀ j : Fin 270, + h1Coeff (triangleEdges 79).1 j - h1Coeff (triangleEdges 79).2.1 j + + h1Coeff (triangleEdges 79).2.2 j = if j = 79 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_80 : ∀ j : Fin 270, + h1Coeff (triangleEdges 80).1 j - h1Coeff (triangleEdges 80).2.1 j + + h1Coeff (triangleEdges 80).2.2 j = if j = 80 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_81 : ∀ j : Fin 270, + h1Coeff (triangleEdges 81).1 j - h1Coeff (triangleEdges 81).2.1 j + + h1Coeff (triangleEdges 81).2.2 j = if j = 81 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_82 : ∀ j : Fin 270, + h1Coeff (triangleEdges 82).1 j - h1Coeff (triangleEdges 82).2.1 j + + h1Coeff (triangleEdges 82).2.2 j = if j = 82 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_83 : ∀ j : Fin 270, + h1Coeff (triangleEdges 83).1 j - h1Coeff (triangleEdges 83).2.1 j + + h1Coeff (triangleEdges 83).2.2 j = if j = 83 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_84 : ∀ j : Fin 270, + h1Coeff (triangleEdges 84).1 j - h1Coeff (triangleEdges 84).2.1 j + + h1Coeff (triangleEdges 84).2.2 j = if j = 84 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_85 : ∀ j : Fin 270, + h1Coeff (triangleEdges 85).1 j - h1Coeff (triangleEdges 85).2.1 j + + h1Coeff (triangleEdges 85).2.2 j = if j = 85 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_86 : ∀ j : Fin 270, + h1Coeff (triangleEdges 86).1 j - h1Coeff (triangleEdges 86).2.1 j + + h1Coeff (triangleEdges 86).2.2 j = if j = 86 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_87 : ∀ j : Fin 270, + h1Coeff (triangleEdges 87).1 j - h1Coeff (triangleEdges 87).2.1 j + + h1Coeff (triangleEdges 87).2.2 j = if j = 87 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_88 : ∀ j : Fin 270, + h1Coeff (triangleEdges 88).1 j - h1Coeff (triangleEdges 88).2.1 j + + h1Coeff (triangleEdges 88).2.2 j = if j = 88 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_89 : ∀ j : Fin 270, + h1Coeff (triangleEdges 89).1 j - h1Coeff (triangleEdges 89).2.1 j + + h1Coeff (triangleEdges 89).2.2 j = if j = 89 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_90 : ∀ j : Fin 270, + h1Coeff (triangleEdges 90).1 j - h1Coeff (triangleEdges 90).2.1 j + + h1Coeff (triangleEdges 90).2.2 j = if j = 90 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_91 : ∀ j : Fin 270, + h1Coeff (triangleEdges 91).1 j - h1Coeff (triangleEdges 91).2.1 j + + h1Coeff (triangleEdges 91).2.2 j = if j = 91 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_92 : ∀ j : Fin 270, + h1Coeff (triangleEdges 92).1 j - h1Coeff (triangleEdges 92).2.1 j + + h1Coeff (triangleEdges 92).2.2 j = if j = 92 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_93 : ∀ j : Fin 270, + h1Coeff (triangleEdges 93).1 j - h1Coeff (triangleEdges 93).2.1 j + + h1Coeff (triangleEdges 93).2.2 j = if j = 93 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_94 : ∀ j : Fin 270, + h1Coeff (triangleEdges 94).1 j - h1Coeff (triangleEdges 94).2.1 j + + h1Coeff (triangleEdges 94).2.2 j = if j = 94 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_95 : ∀ j : Fin 270, + h1Coeff (triangleEdges 95).1 j - h1Coeff (triangleEdges 95).2.1 j + + h1Coeff (triangleEdges 95).2.2 j = if j = 95 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_96 : ∀ j : Fin 270, + h1Coeff (triangleEdges 96).1 j - h1Coeff (triangleEdges 96).2.1 j + + h1Coeff (triangleEdges 96).2.2 j = if j = 96 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_97 : ∀ j : Fin 270, + h1Coeff (triangleEdges 97).1 j - h1Coeff (triangleEdges 97).2.1 j + + h1Coeff (triangleEdges 97).2.2 j = if j = 97 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_98 : ∀ j : Fin 270, + h1Coeff (triangleEdges 98).1 j - h1Coeff (triangleEdges 98).2.1 j + + h1Coeff (triangleEdges 98).2.2 j = if j = 98 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_99 : ∀ j : Fin 270, + h1Coeff (triangleEdges 99).1 j - h1Coeff (triangleEdges 99).2.1 j + + h1Coeff (triangleEdges 99).2.2 j = if j = 99 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_100 : ∀ j : Fin 270, + h1Coeff (triangleEdges 100).1 j - h1Coeff (triangleEdges 100).2.1 j + + h1Coeff (triangleEdges 100).2.2 j = if j = 100 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_101 : ∀ j : Fin 270, + h1Coeff (triangleEdges 101).1 j - h1Coeff (triangleEdges 101).2.1 j + + h1Coeff (triangleEdges 101).2.2 j = if j = 101 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_102 : ∀ j : Fin 270, + h1Coeff (triangleEdges 102).1 j - h1Coeff (triangleEdges 102).2.1 j + + h1Coeff (triangleEdges 102).2.2 j = if j = 102 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_103 : ∀ j : Fin 270, + h1Coeff (triangleEdges 103).1 j - h1Coeff (triangleEdges 103).2.1 j + + h1Coeff (triangleEdges 103).2.2 j = if j = 103 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_104 : ∀ j : Fin 270, + h1Coeff (triangleEdges 104).1 j - h1Coeff (triangleEdges 104).2.1 j + + h1Coeff (triangleEdges 104).2.2 j = if j = 104 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_105 : ∀ j : Fin 270, + h1Coeff (triangleEdges 105).1 j - h1Coeff (triangleEdges 105).2.1 j + + h1Coeff (triangleEdges 105).2.2 j = if j = 105 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_106 : ∀ j : Fin 270, + h1Coeff (triangleEdges 106).1 j - h1Coeff (triangleEdges 106).2.1 j + + h1Coeff (triangleEdges 106).2.2 j = if j = 106 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_107 : ∀ j : Fin 270, + h1Coeff (triangleEdges 107).1 j - h1Coeff (triangleEdges 107).2.1 j + + h1Coeff (triangleEdges 107).2.2 j = if j = 107 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_108 : ∀ j : Fin 270, + h1Coeff (triangleEdges 108).1 j - h1Coeff (triangleEdges 108).2.1 j + + h1Coeff (triangleEdges 108).2.2 j = if j = 108 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_109 : ∀ j : Fin 270, + h1Coeff (triangleEdges 109).1 j - h1Coeff (triangleEdges 109).2.1 j + + h1Coeff (triangleEdges 109).2.2 j = if j = 109 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_110 : ∀ j : Fin 270, + h1Coeff (triangleEdges 110).1 j - h1Coeff (triangleEdges 110).2.1 j + + h1Coeff (triangleEdges 110).2.2 j = if j = 110 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_111 : ∀ j : Fin 270, + h1Coeff (triangleEdges 111).1 j - h1Coeff (triangleEdges 111).2.1 j + + h1Coeff (triangleEdges 111).2.2 j = if j = 111 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_112 : ∀ j : Fin 270, + h1Coeff (triangleEdges 112).1 j - h1Coeff (triangleEdges 112).2.1 j + + h1Coeff (triangleEdges 112).2.2 j = if j = 112 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_113 : ∀ j : Fin 270, + h1Coeff (triangleEdges 113).1 j - h1Coeff (triangleEdges 113).2.1 j + + h1Coeff (triangleEdges 113).2.2 j = if j = 113 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_114 : ∀ j : Fin 270, + h1Coeff (triangleEdges 114).1 j - h1Coeff (triangleEdges 114).2.1 j + + h1Coeff (triangleEdges 114).2.2 j = if j = 114 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_115 : ∀ j : Fin 270, + h1Coeff (triangleEdges 115).1 j - h1Coeff (triangleEdges 115).2.1 j + + h1Coeff (triangleEdges 115).2.2 j = if j = 115 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_116 : ∀ j : Fin 270, + h1Coeff (triangleEdges 116).1 j - h1Coeff (triangleEdges 116).2.1 j + + h1Coeff (triangleEdges 116).2.2 j = if j = 116 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_117 : ∀ j : Fin 270, + h1Coeff (triangleEdges 117).1 j - h1Coeff (triangleEdges 117).2.1 j + + h1Coeff (triangleEdges 117).2.2 j = if j = 117 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_118 : ∀ j : Fin 270, + h1Coeff (triangleEdges 118).1 j - h1Coeff (triangleEdges 118).2.1 j + + h1Coeff (triangleEdges 118).2.2 j = if j = 118 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_119 : ∀ j : Fin 270, + h1Coeff (triangleEdges 119).1 j - h1Coeff (triangleEdges 119).2.1 j + + h1Coeff (triangleEdges 119).2.2 j = if j = 119 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_120 : ∀ j : Fin 270, + h1Coeff (triangleEdges 120).1 j - h1Coeff (triangleEdges 120).2.1 j + + h1Coeff (triangleEdges 120).2.2 j = if j = 120 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_121 : ∀ j : Fin 270, + h1Coeff (triangleEdges 121).1 j - h1Coeff (triangleEdges 121).2.1 j + + h1Coeff (triangleEdges 121).2.2 j = if j = 121 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_122 : ∀ j : Fin 270, + h1Coeff (triangleEdges 122).1 j - h1Coeff (triangleEdges 122).2.1 j + + h1Coeff (triangleEdges 122).2.2 j = if j = 122 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_123 : ∀ j : Fin 270, + h1Coeff (triangleEdges 123).1 j - h1Coeff (triangleEdges 123).2.1 j + + h1Coeff (triangleEdges 123).2.2 j = if j = 123 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_124 : ∀ j : Fin 270, + h1Coeff (triangleEdges 124).1 j - h1Coeff (triangleEdges 124).2.1 j + + h1Coeff (triangleEdges 124).2.2 j = if j = 124 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_125 : ∀ j : Fin 270, + h1Coeff (triangleEdges 125).1 j - h1Coeff (triangleEdges 125).2.1 j + + h1Coeff (triangleEdges 125).2.2 j = if j = 125 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_126 : ∀ j : Fin 270, + h1Coeff (triangleEdges 126).1 j - h1Coeff (triangleEdges 126).2.1 j + + h1Coeff (triangleEdges 126).2.2 j = if j = 126 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_127 : ∀ j : Fin 270, + h1Coeff (triangleEdges 127).1 j - h1Coeff (triangleEdges 127).2.1 j + + h1Coeff (triangleEdges 127).2.2 j = if j = 127 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_128 : ∀ j : Fin 270, + h1Coeff (triangleEdges 128).1 j - h1Coeff (triangleEdges 128).2.1 j + + h1Coeff (triangleEdges 128).2.2 j = if j = 128 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_129 : ∀ j : Fin 270, + h1Coeff (triangleEdges 129).1 j - h1Coeff (triangleEdges 129).2.1 j + + h1Coeff (triangleEdges 129).2.2 j = if j = 129 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_130 : ∀ j : Fin 270, + h1Coeff (triangleEdges 130).1 j - h1Coeff (triangleEdges 130).2.1 j + + h1Coeff (triangleEdges 130).2.2 j = if j = 130 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_131 : ∀ j : Fin 270, + h1Coeff (triangleEdges 131).1 j - h1Coeff (triangleEdges 131).2.1 j + + h1Coeff (triangleEdges 131).2.2 j = if j = 131 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_132 : ∀ j : Fin 270, + h1Coeff (triangleEdges 132).1 j - h1Coeff (triangleEdges 132).2.1 j + + h1Coeff (triangleEdges 132).2.2 j = if j = 132 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_133 : ∀ j : Fin 270, + h1Coeff (triangleEdges 133).1 j - h1Coeff (triangleEdges 133).2.1 j + + h1Coeff (triangleEdges 133).2.2 j = if j = 133 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_134 : ∀ j : Fin 270, + h1Coeff (triangleEdges 134).1 j - h1Coeff (triangleEdges 134).2.1 j + + h1Coeff (triangleEdges 134).2.2 j = if j = 134 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_135 : ∀ j : Fin 270, + h1Coeff (triangleEdges 135).1 j - h1Coeff (triangleEdges 135).2.1 j + + h1Coeff (triangleEdges 135).2.2 j = if j = 135 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_136 : ∀ j : Fin 270, + h1Coeff (triangleEdges 136).1 j - h1Coeff (triangleEdges 136).2.1 j + + h1Coeff (triangleEdges 136).2.2 j = if j = 136 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_137 : ∀ j : Fin 270, + h1Coeff (triangleEdges 137).1 j - h1Coeff (triangleEdges 137).2.1 j + + h1Coeff (triangleEdges 137).2.2 j = if j = 137 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_138 : ∀ j : Fin 270, + h1Coeff (triangleEdges 138).1 j - h1Coeff (triangleEdges 138).2.1 j + + h1Coeff (triangleEdges 138).2.2 j = if j = 138 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_139 : ∀ j : Fin 270, + h1Coeff (triangleEdges 139).1 j - h1Coeff (triangleEdges 139).2.1 j + + h1Coeff (triangleEdges 139).2.2 j = if j = 139 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_140 : ∀ j : Fin 270, + h1Coeff (triangleEdges 140).1 j - h1Coeff (triangleEdges 140).2.1 j + + h1Coeff (triangleEdges 140).2.2 j = if j = 140 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_141 : ∀ j : Fin 270, + h1Coeff (triangleEdges 141).1 j - h1Coeff (triangleEdges 141).2.1 j + + h1Coeff (triangleEdges 141).2.2 j = if j = 141 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_142 : ∀ j : Fin 270, + h1Coeff (triangleEdges 142).1 j - h1Coeff (triangleEdges 142).2.1 j + + h1Coeff (triangleEdges 142).2.2 j = if j = 142 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_143 : ∀ j : Fin 270, + h1Coeff (triangleEdges 143).1 j - h1Coeff (triangleEdges 143).2.1 j + + h1Coeff (triangleEdges 143).2.2 j = if j = 143 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_144 : ∀ j : Fin 270, + h1Coeff (triangleEdges 144).1 j - h1Coeff (triangleEdges 144).2.1 j + + h1Coeff (triangleEdges 144).2.2 j = if j = 144 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_145 : ∀ j : Fin 270, + h1Coeff (triangleEdges 145).1 j - h1Coeff (triangleEdges 145).2.1 j + + h1Coeff (triangleEdges 145).2.2 j = if j = 145 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_146 : ∀ j : Fin 270, + h1Coeff (triangleEdges 146).1 j - h1Coeff (triangleEdges 146).2.1 j + + h1Coeff (triangleEdges 146).2.2 j = if j = 146 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_147 : ∀ j : Fin 270, + h1Coeff (triangleEdges 147).1 j - h1Coeff (triangleEdges 147).2.1 j + + h1Coeff (triangleEdges 147).2.2 j = if j = 147 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_148 : ∀ j : Fin 270, + h1Coeff (triangleEdges 148).1 j - h1Coeff (triangleEdges 148).2.1 j + + h1Coeff (triangleEdges 148).2.2 j = if j = 148 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_149 : ∀ j : Fin 270, + h1Coeff (triangleEdges 149).1 j - h1Coeff (triangleEdges 149).2.1 j + + h1Coeff (triangleEdges 149).2.2 j = if j = 149 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_150 : ∀ j : Fin 270, + h1Coeff (triangleEdges 150).1 j - h1Coeff (triangleEdges 150).2.1 j + + h1Coeff (triangleEdges 150).2.2 j = if j = 150 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_151 : ∀ j : Fin 270, + h1Coeff (triangleEdges 151).1 j - h1Coeff (triangleEdges 151).2.1 j + + h1Coeff (triangleEdges 151).2.2 j = if j = 151 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_152 : ∀ j : Fin 270, + h1Coeff (triangleEdges 152).1 j - h1Coeff (triangleEdges 152).2.1 j + + h1Coeff (triangleEdges 152).2.2 j = if j = 152 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_153 : ∀ j : Fin 270, + h1Coeff (triangleEdges 153).1 j - h1Coeff (triangleEdges 153).2.1 j + + h1Coeff (triangleEdges 153).2.2 j = if j = 153 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_154 : ∀ j : Fin 270, + h1Coeff (triangleEdges 154).1 j - h1Coeff (triangleEdges 154).2.1 j + + h1Coeff (triangleEdges 154).2.2 j = if j = 154 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_155 : ∀ j : Fin 270, + h1Coeff (triangleEdges 155).1 j - h1Coeff (triangleEdges 155).2.1 j + + h1Coeff (triangleEdges 155).2.2 j = if j = 155 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_156 : ∀ j : Fin 270, + h1Coeff (triangleEdges 156).1 j - h1Coeff (triangleEdges 156).2.1 j + + h1Coeff (triangleEdges 156).2.2 j = if j = 156 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_157 : ∀ j : Fin 270, + h1Coeff (triangleEdges 157).1 j - h1Coeff (triangleEdges 157).2.1 j + + h1Coeff (triangleEdges 157).2.2 j = if j = 157 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_158 : ∀ j : Fin 270, + h1Coeff (triangleEdges 158).1 j - h1Coeff (triangleEdges 158).2.1 j + + h1Coeff (triangleEdges 158).2.2 j = if j = 158 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_159 : ∀ j : Fin 270, + h1Coeff (triangleEdges 159).1 j - h1Coeff (triangleEdges 159).2.1 j + + h1Coeff (triangleEdges 159).2.2 j = if j = 159 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_160 : ∀ j : Fin 270, + h1Coeff (triangleEdges 160).1 j - h1Coeff (triangleEdges 160).2.1 j + + h1Coeff (triangleEdges 160).2.2 j = if j = 160 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_161 : ∀ j : Fin 270, + h1Coeff (triangleEdges 161).1 j - h1Coeff (triangleEdges 161).2.1 j + + h1Coeff (triangleEdges 161).2.2 j = if j = 161 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_162 : ∀ j : Fin 270, + h1Coeff (triangleEdges 162).1 j - h1Coeff (triangleEdges 162).2.1 j + + h1Coeff (triangleEdges 162).2.2 j = if j = 162 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_163 : ∀ j : Fin 270, + h1Coeff (triangleEdges 163).1 j - h1Coeff (triangleEdges 163).2.1 j + + h1Coeff (triangleEdges 163).2.2 j = if j = 163 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_164 : ∀ j : Fin 270, + h1Coeff (triangleEdges 164).1 j - h1Coeff (triangleEdges 164).2.1 j + + h1Coeff (triangleEdges 164).2.2 j = if j = 164 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_165 : ∀ j : Fin 270, + h1Coeff (triangleEdges 165).1 j - h1Coeff (triangleEdges 165).2.1 j + + h1Coeff (triangleEdges 165).2.2 j = if j = 165 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_166 : ∀ j : Fin 270, + h1Coeff (triangleEdges 166).1 j - h1Coeff (triangleEdges 166).2.1 j + + h1Coeff (triangleEdges 166).2.2 j = if j = 166 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_167 : ∀ j : Fin 270, + h1Coeff (triangleEdges 167).1 j - h1Coeff (triangleEdges 167).2.1 j + + h1Coeff (triangleEdges 167).2.2 j = if j = 167 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_168 : ∀ j : Fin 270, + h1Coeff (triangleEdges 168).1 j - h1Coeff (triangleEdges 168).2.1 j + + h1Coeff (triangleEdges 168).2.2 j = if j = 168 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_169 : ∀ j : Fin 270, + h1Coeff (triangleEdges 169).1 j - h1Coeff (triangleEdges 169).2.1 j + + h1Coeff (triangleEdges 169).2.2 j = if j = 169 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_170 : ∀ j : Fin 270, + h1Coeff (triangleEdges 170).1 j - h1Coeff (triangleEdges 170).2.1 j + + h1Coeff (triangleEdges 170).2.2 j = if j = 170 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_171 : ∀ j : Fin 270, + h1Coeff (triangleEdges 171).1 j - h1Coeff (triangleEdges 171).2.1 j + + h1Coeff (triangleEdges 171).2.2 j = if j = 171 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_172 : ∀ j : Fin 270, + h1Coeff (triangleEdges 172).1 j - h1Coeff (triangleEdges 172).2.1 j + + h1Coeff (triangleEdges 172).2.2 j = if j = 172 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_173 : ∀ j : Fin 270, + h1Coeff (triangleEdges 173).1 j - h1Coeff (triangleEdges 173).2.1 j + + h1Coeff (triangleEdges 173).2.2 j = if j = 173 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_174 : ∀ j : Fin 270, + h1Coeff (triangleEdges 174).1 j - h1Coeff (triangleEdges 174).2.1 j + + h1Coeff (triangleEdges 174).2.2 j = if j = 174 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_175 : ∀ j : Fin 270, + h1Coeff (triangleEdges 175).1 j - h1Coeff (triangleEdges 175).2.1 j + + h1Coeff (triangleEdges 175).2.2 j = if j = 175 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_176 : ∀ j : Fin 270, + h1Coeff (triangleEdges 176).1 j - h1Coeff (triangleEdges 176).2.1 j + + h1Coeff (triangleEdges 176).2.2 j = if j = 176 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_177 : ∀ j : Fin 270, + h1Coeff (triangleEdges 177).1 j - h1Coeff (triangleEdges 177).2.1 j + + h1Coeff (triangleEdges 177).2.2 j = if j = 177 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_178 : ∀ j : Fin 270, + h1Coeff (triangleEdges 178).1 j - h1Coeff (triangleEdges 178).2.1 j + + h1Coeff (triangleEdges 178).2.2 j = if j = 178 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_179 : ∀ j : Fin 270, + h1Coeff (triangleEdges 179).1 j - h1Coeff (triangleEdges 179).2.1 j + + h1Coeff (triangleEdges 179).2.2 j = if j = 179 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_180 : ∀ j : Fin 270, + h1Coeff (triangleEdges 180).1 j - h1Coeff (triangleEdges 180).2.1 j + + h1Coeff (triangleEdges 180).2.2 j = if j = 180 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_181 : ∀ j : Fin 270, + h1Coeff (triangleEdges 181).1 j - h1Coeff (triangleEdges 181).2.1 j + + h1Coeff (triangleEdges 181).2.2 j = if j = 181 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_182 : ∀ j : Fin 270, + h1Coeff (triangleEdges 182).1 j - h1Coeff (triangleEdges 182).2.1 j + + h1Coeff (triangleEdges 182).2.2 j = if j = 182 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_183 : ∀ j : Fin 270, + h1Coeff (triangleEdges 183).1 j - h1Coeff (triangleEdges 183).2.1 j + + h1Coeff (triangleEdges 183).2.2 j = if j = 183 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_184 : ∀ j : Fin 270, + h1Coeff (triangleEdges 184).1 j - h1Coeff (triangleEdges 184).2.1 j + + h1Coeff (triangleEdges 184).2.2 j = if j = 184 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_185 : ∀ j : Fin 270, + h1Coeff (triangleEdges 185).1 j - h1Coeff (triangleEdges 185).2.1 j + + h1Coeff (triangleEdges 185).2.2 j = if j = 185 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_186 : ∀ j : Fin 270, + h1Coeff (triangleEdges 186).1 j - h1Coeff (triangleEdges 186).2.1 j + + h1Coeff (triangleEdges 186).2.2 j = if j = 186 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_187 : ∀ j : Fin 270, + h1Coeff (triangleEdges 187).1 j - h1Coeff (triangleEdges 187).2.1 j + + h1Coeff (triangleEdges 187).2.2 j = if j = 187 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_188 : ∀ j : Fin 270, + h1Coeff (triangleEdges 188).1 j - h1Coeff (triangleEdges 188).2.1 j + + h1Coeff (triangleEdges 188).2.2 j = if j = 188 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_189 : ∀ j : Fin 270, + h1Coeff (triangleEdges 189).1 j - h1Coeff (triangleEdges 189).2.1 j + + h1Coeff (triangleEdges 189).2.2 j = if j = 189 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_190 : ∀ j : Fin 270, + h1Coeff (triangleEdges 190).1 j - h1Coeff (triangleEdges 190).2.1 j + + h1Coeff (triangleEdges 190).2.2 j = if j = 190 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_191 : ∀ j : Fin 270, + h1Coeff (triangleEdges 191).1 j - h1Coeff (triangleEdges 191).2.1 j + + h1Coeff (triangleEdges 191).2.2 j = if j = 191 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_192 : ∀ j : Fin 270, + h1Coeff (triangleEdges 192).1 j - h1Coeff (triangleEdges 192).2.1 j + + h1Coeff (triangleEdges 192).2.2 j = if j = 192 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_193 : ∀ j : Fin 270, + h1Coeff (triangleEdges 193).1 j - h1Coeff (triangleEdges 193).2.1 j + + h1Coeff (triangleEdges 193).2.2 j = if j = 193 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_194 : ∀ j : Fin 270, + h1Coeff (triangleEdges 194).1 j - h1Coeff (triangleEdges 194).2.1 j + + h1Coeff (triangleEdges 194).2.2 j = if j = 194 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_195 : ∀ j : Fin 270, + h1Coeff (triangleEdges 195).1 j - h1Coeff (triangleEdges 195).2.1 j + + h1Coeff (triangleEdges 195).2.2 j = if j = 195 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_196 : ∀ j : Fin 270, + h1Coeff (triangleEdges 196).1 j - h1Coeff (triangleEdges 196).2.1 j + + h1Coeff (triangleEdges 196).2.2 j = if j = 196 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_197 : ∀ j : Fin 270, + h1Coeff (triangleEdges 197).1 j - h1Coeff (triangleEdges 197).2.1 j + + h1Coeff (triangleEdges 197).2.2 j = if j = 197 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_198 : ∀ j : Fin 270, + h1Coeff (triangleEdges 198).1 j - h1Coeff (triangleEdges 198).2.1 j + + h1Coeff (triangleEdges 198).2.2 j = if j = 198 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_199 : ∀ j : Fin 270, + h1Coeff (triangleEdges 199).1 j - h1Coeff (triangleEdges 199).2.1 j + + h1Coeff (triangleEdges 199).2.2 j = if j = 199 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_200 : ∀ j : Fin 270, + h1Coeff (triangleEdges 200).1 j - h1Coeff (triangleEdges 200).2.1 j + + h1Coeff (triangleEdges 200).2.2 j = if j = 200 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_201 : ∀ j : Fin 270, + h1Coeff (triangleEdges 201).1 j - h1Coeff (triangleEdges 201).2.1 j + + h1Coeff (triangleEdges 201).2.2 j = if j = 201 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_202 : ∀ j : Fin 270, + h1Coeff (triangleEdges 202).1 j - h1Coeff (triangleEdges 202).2.1 j + + h1Coeff (triangleEdges 202).2.2 j = if j = 202 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_203 : ∀ j : Fin 270, + h1Coeff (triangleEdges 203).1 j - h1Coeff (triangleEdges 203).2.1 j + + h1Coeff (triangleEdges 203).2.2 j = if j = 203 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_204 : ∀ j : Fin 270, + h1Coeff (triangleEdges 204).1 j - h1Coeff (triangleEdges 204).2.1 j + + h1Coeff (triangleEdges 204).2.2 j = if j = 204 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_205 : ∀ j : Fin 270, + h1Coeff (triangleEdges 205).1 j - h1Coeff (triangleEdges 205).2.1 j + + h1Coeff (triangleEdges 205).2.2 j = if j = 205 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_206 : ∀ j : Fin 270, + h1Coeff (triangleEdges 206).1 j - h1Coeff (triangleEdges 206).2.1 j + + h1Coeff (triangleEdges 206).2.2 j = if j = 206 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_207 : ∀ j : Fin 270, + h1Coeff (triangleEdges 207).1 j - h1Coeff (triangleEdges 207).2.1 j + + h1Coeff (triangleEdges 207).2.2 j = if j = 207 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_208 : ∀ j : Fin 270, + h1Coeff (triangleEdges 208).1 j - h1Coeff (triangleEdges 208).2.1 j + + h1Coeff (triangleEdges 208).2.2 j = if j = 208 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_209 : ∀ j : Fin 270, + h1Coeff (triangleEdges 209).1 j - h1Coeff (triangleEdges 209).2.1 j + + h1Coeff (triangleEdges 209).2.2 j = if j = 209 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_210 : ∀ j : Fin 270, + h1Coeff (triangleEdges 210).1 j - h1Coeff (triangleEdges 210).2.1 j + + h1Coeff (triangleEdges 210).2.2 j = if j = 210 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_211 : ∀ j : Fin 270, + h1Coeff (triangleEdges 211).1 j - h1Coeff (triangleEdges 211).2.1 j + + h1Coeff (triangleEdges 211).2.2 j = if j = 211 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_212 : ∀ j : Fin 270, + h1Coeff (triangleEdges 212).1 j - h1Coeff (triangleEdges 212).2.1 j + + h1Coeff (triangleEdges 212).2.2 j = if j = 212 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_213 : ∀ j : Fin 270, + h1Coeff (triangleEdges 213).1 j - h1Coeff (triangleEdges 213).2.1 j + + h1Coeff (triangleEdges 213).2.2 j = if j = 213 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_214 : ∀ j : Fin 270, + h1Coeff (triangleEdges 214).1 j - h1Coeff (triangleEdges 214).2.1 j + + h1Coeff (triangleEdges 214).2.2 j = if j = 214 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_215 : ∀ j : Fin 270, + h1Coeff (triangleEdges 215).1 j - h1Coeff (triangleEdges 215).2.1 j + + h1Coeff (triangleEdges 215).2.2 j = if j = 215 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_216 : ∀ j : Fin 270, + h1Coeff (triangleEdges 216).1 j - h1Coeff (triangleEdges 216).2.1 j + + h1Coeff (triangleEdges 216).2.2 j = if j = 216 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_217 : ∀ j : Fin 270, + h1Coeff (triangleEdges 217).1 j - h1Coeff (triangleEdges 217).2.1 j + + h1Coeff (triangleEdges 217).2.2 j = if j = 217 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_218 : ∀ j : Fin 270, + h1Coeff (triangleEdges 218).1 j - h1Coeff (triangleEdges 218).2.1 j + + h1Coeff (triangleEdges 218).2.2 j = if j = 218 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_219 : ∀ j : Fin 270, + h1Coeff (triangleEdges 219).1 j - h1Coeff (triangleEdges 219).2.1 j + + h1Coeff (triangleEdges 219).2.2 j = if j = 219 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_220 : ∀ j : Fin 270, + h1Coeff (triangleEdges 220).1 j - h1Coeff (triangleEdges 220).2.1 j + + h1Coeff (triangleEdges 220).2.2 j = if j = 220 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_221 : ∀ j : Fin 270, + h1Coeff (triangleEdges 221).1 j - h1Coeff (triangleEdges 221).2.1 j + + h1Coeff (triangleEdges 221).2.2 j = if j = 221 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_222 : ∀ j : Fin 270, + h1Coeff (triangleEdges 222).1 j - h1Coeff (triangleEdges 222).2.1 j + + h1Coeff (triangleEdges 222).2.2 j = if j = 222 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_223 : ∀ j : Fin 270, + h1Coeff (triangleEdges 223).1 j - h1Coeff (triangleEdges 223).2.1 j + + h1Coeff (triangleEdges 223).2.2 j = if j = 223 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_224 : ∀ j : Fin 270, + h1Coeff (triangleEdges 224).1 j - h1Coeff (triangleEdges 224).2.1 j + + h1Coeff (triangleEdges 224).2.2 j = if j = 224 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_225 : ∀ j : Fin 270, + h1Coeff (triangleEdges 225).1 j - h1Coeff (triangleEdges 225).2.1 j + + h1Coeff (triangleEdges 225).2.2 j = if j = 225 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_226 : ∀ j : Fin 270, + h1Coeff (triangleEdges 226).1 j - h1Coeff (triangleEdges 226).2.1 j + + h1Coeff (triangleEdges 226).2.2 j = if j = 226 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_227 : ∀ j : Fin 270, + h1Coeff (triangleEdges 227).1 j - h1Coeff (triangleEdges 227).2.1 j + + h1Coeff (triangleEdges 227).2.2 j = if j = 227 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_228 : ∀ j : Fin 270, + h1Coeff (triangleEdges 228).1 j - h1Coeff (triangleEdges 228).2.1 j + + h1Coeff (triangleEdges 228).2.2 j = if j = 228 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_229 : ∀ j : Fin 270, + h1Coeff (triangleEdges 229).1 j - h1Coeff (triangleEdges 229).2.1 j + + h1Coeff (triangleEdges 229).2.2 j = if j = 229 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_230 : ∀ j : Fin 270, + h1Coeff (triangleEdges 230).1 j - h1Coeff (triangleEdges 230).2.1 j + + h1Coeff (triangleEdges 230).2.2 j = if j = 230 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_231 : ∀ j : Fin 270, + h1Coeff (triangleEdges 231).1 j - h1Coeff (triangleEdges 231).2.1 j + + h1Coeff (triangleEdges 231).2.2 j = if j = 231 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_232 : ∀ j : Fin 270, + h1Coeff (triangleEdges 232).1 j - h1Coeff (triangleEdges 232).2.1 j + + h1Coeff (triangleEdges 232).2.2 j = if j = 232 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_233 : ∀ j : Fin 270, + h1Coeff (triangleEdges 233).1 j - h1Coeff (triangleEdges 233).2.1 j + + h1Coeff (triangleEdges 233).2.2 j = if j = 233 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_234 : ∀ j : Fin 270, + h1Coeff (triangleEdges 234).1 j - h1Coeff (triangleEdges 234).2.1 j + + h1Coeff (triangleEdges 234).2.2 j = if j = 234 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_235 : ∀ j : Fin 270, + h1Coeff (triangleEdges 235).1 j - h1Coeff (triangleEdges 235).2.1 j + + h1Coeff (triangleEdges 235).2.2 j = if j = 235 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_236 : ∀ j : Fin 270, + h1Coeff (triangleEdges 236).1 j - h1Coeff (triangleEdges 236).2.1 j + + h1Coeff (triangleEdges 236).2.2 j = if j = 236 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_237 : ∀ j : Fin 270, + h1Coeff (triangleEdges 237).1 j - h1Coeff (triangleEdges 237).2.1 j + + h1Coeff (triangleEdges 237).2.2 j = if j = 237 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_238 : ∀ j : Fin 270, + h1Coeff (triangleEdges 238).1 j - h1Coeff (triangleEdges 238).2.1 j + + h1Coeff (triangleEdges 238).2.2 j = if j = 238 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_239 : ∀ j : Fin 270, + h1Coeff (triangleEdges 239).1 j - h1Coeff (triangleEdges 239).2.1 j + + h1Coeff (triangleEdges 239).2.2 j = if j = 239 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_240 : ∀ j : Fin 270, + h1Coeff (triangleEdges 240).1 j - h1Coeff (triangleEdges 240).2.1 j + + h1Coeff (triangleEdges 240).2.2 j = if j = 240 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_241 : ∀ j : Fin 270, + h1Coeff (triangleEdges 241).1 j - h1Coeff (triangleEdges 241).2.1 j + + h1Coeff (triangleEdges 241).2.2 j = if j = 241 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_242 : ∀ j : Fin 270, + h1Coeff (triangleEdges 242).1 j - h1Coeff (triangleEdges 242).2.1 j + + h1Coeff (triangleEdges 242).2.2 j = if j = 242 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_243 : ∀ j : Fin 270, + h1Coeff (triangleEdges 243).1 j - h1Coeff (triangleEdges 243).2.1 j + + h1Coeff (triangleEdges 243).2.2 j = if j = 243 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_244 : ∀ j : Fin 270, + h1Coeff (triangleEdges 244).1 j - h1Coeff (triangleEdges 244).2.1 j + + h1Coeff (triangleEdges 244).2.2 j = if j = 244 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_245 : ∀ j : Fin 270, + h1Coeff (triangleEdges 245).1 j - h1Coeff (triangleEdges 245).2.1 j + + h1Coeff (triangleEdges 245).2.2 j = if j = 245 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_246 : ∀ j : Fin 270, + h1Coeff (triangleEdges 246).1 j - h1Coeff (triangleEdges 246).2.1 j + + h1Coeff (triangleEdges 246).2.2 j = if j = 246 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_247 : ∀ j : Fin 270, + h1Coeff (triangleEdges 247).1 j - h1Coeff (triangleEdges 247).2.1 j + + h1Coeff (triangleEdges 247).2.2 j = if j = 247 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_248 : ∀ j : Fin 270, + h1Coeff (triangleEdges 248).1 j - h1Coeff (triangleEdges 248).2.1 j + + h1Coeff (triangleEdges 248).2.2 j = if j = 248 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_249 : ∀ j : Fin 270, + h1Coeff (triangleEdges 249).1 j - h1Coeff (triangleEdges 249).2.1 j + + h1Coeff (triangleEdges 249).2.2 j = if j = 249 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_250 : ∀ j : Fin 270, + h1Coeff (triangleEdges 250).1 j - h1Coeff (triangleEdges 250).2.1 j + + h1Coeff (triangleEdges 250).2.2 j = if j = 250 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_251 : ∀ j : Fin 270, + h1Coeff (triangleEdges 251).1 j - h1Coeff (triangleEdges 251).2.1 j + + h1Coeff (triangleEdges 251).2.2 j = if j = 251 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_252 : ∀ j : Fin 270, + h1Coeff (triangleEdges 252).1 j - h1Coeff (triangleEdges 252).2.1 j + + h1Coeff (triangleEdges 252).2.2 j = if j = 252 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_253 : ∀ j : Fin 270, + h1Coeff (triangleEdges 253).1 j - h1Coeff (triangleEdges 253).2.1 j + + h1Coeff (triangleEdges 253).2.2 j = if j = 253 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_254 : ∀ j : Fin 270, + h1Coeff (triangleEdges 254).1 j - h1Coeff (triangleEdges 254).2.1 j + + h1Coeff (triangleEdges 254).2.2 j = if j = 254 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_255 : ∀ j : Fin 270, + h1Coeff (triangleEdges 255).1 j - h1Coeff (triangleEdges 255).2.1 j + + h1Coeff (triangleEdges 255).2.2 j = if j = 255 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_256 : ∀ j : Fin 270, + h1Coeff (triangleEdges 256).1 j - h1Coeff (triangleEdges 256).2.1 j + + h1Coeff (triangleEdges 256).2.2 j = if j = 256 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_257 : ∀ j : Fin 270, + h1Coeff (triangleEdges 257).1 j - h1Coeff (triangleEdges 257).2.1 j + + h1Coeff (triangleEdges 257).2.2 j = if j = 257 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_258 : ∀ j : Fin 270, + h1Coeff (triangleEdges 258).1 j - h1Coeff (triangleEdges 258).2.1 j + + h1Coeff (triangleEdges 258).2.2 j = if j = 258 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_259 : ∀ j : Fin 270, + h1Coeff (triangleEdges 259).1 j - h1Coeff (triangleEdges 259).2.1 j + + h1Coeff (triangleEdges 259).2.2 j = if j = 259 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_260 : ∀ j : Fin 270, + h1Coeff (triangleEdges 260).1 j - h1Coeff (triangleEdges 260).2.1 j + + h1Coeff (triangleEdges 260).2.2 j = if j = 260 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_261 : ∀ j : Fin 270, + h1Coeff (triangleEdges 261).1 j - h1Coeff (triangleEdges 261).2.1 j + + h1Coeff (triangleEdges 261).2.2 j = if j = 261 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_262 : ∀ j : Fin 270, + h1Coeff (triangleEdges 262).1 j - h1Coeff (triangleEdges 262).2.1 j + + h1Coeff (triangleEdges 262).2.2 j = if j = 262 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_263 : ∀ j : Fin 270, + h1Coeff (triangleEdges 263).1 j - h1Coeff (triangleEdges 263).2.1 j + + h1Coeff (triangleEdges 263).2.2 j = if j = 263 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_264 : ∀ j : Fin 270, + h1Coeff (triangleEdges 264).1 j - h1Coeff (triangleEdges 264).2.1 j + + h1Coeff (triangleEdges 264).2.2 j = if j = 264 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_265 : ∀ j : Fin 270, + h1Coeff (triangleEdges 265).1 j - h1Coeff (triangleEdges 265).2.1 j + + h1Coeff (triangleEdges 265).2.2 j = if j = 265 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_266 : ∀ j : Fin 270, + h1Coeff (triangleEdges 266).1 j - h1Coeff (triangleEdges 266).2.1 j + + h1Coeff (triangleEdges 266).2.2 j = if j = 266 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_267 : ∀ j : Fin 270, + h1Coeff (triangleEdges 267).1 j - h1Coeff (triangleEdges 267).2.1 j + + h1Coeff (triangleEdges 267).2.2 j = if j = 267 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_268 : ∀ j : Fin 270, + h1Coeff (triangleEdges 268).1 j - h1Coeff (triangleEdges 268).2.1 j + + h1Coeff (triangleEdges 268).2.2 j = if j = 268 then 1 else 0 := by decide +kernel + +theorem h1_boundary_cert_269 : ∀ j : Fin 270, + h1Coeff (triangleEdges 269).1 j - h1Coeff (triangleEdges 269).2.1 j + + h1Coeff (triangleEdges 269).2.2 j = if j = 269 then 1 else 0 := by decide +kernel + +theorem d1_basis_cert_0 : ∀ e : Fin 372, + rowEval (d1Row 0) (fun j => if j = e then 1 else 0) = + (if 0 = (edge e).2 then 1 else 0) - + (if 0 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_1 : ∀ e : Fin 372, + rowEval (d1Row 1) (fun j => if j = e then 1 else 0) = + (if 1 = (edge e).2 then 1 else 0) - + (if 1 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_2 : ∀ e : Fin 372, + rowEval (d1Row 2) (fun j => if j = e then 1 else 0) = + (if 2 = (edge e).2 then 1 else 0) - + (if 2 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_3 : ∀ e : Fin 372, + rowEval (d1Row 3) (fun j => if j = e then 1 else 0) = + (if 3 = (edge e).2 then 1 else 0) - + (if 3 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_4 : ∀ e : Fin 372, + rowEval (d1Row 4) (fun j => if j = e then 1 else 0) = + (if 4 = (edge e).2 then 1 else 0) - + (if 4 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_5 : ∀ e : Fin 372, + rowEval (d1Row 5) (fun j => if j = e then 1 else 0) = + (if 5 = (edge e).2 then 1 else 0) - + (if 5 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_6 : ∀ e : Fin 372, + rowEval (d1Row 6) (fun j => if j = e then 1 else 0) = + (if 6 = (edge e).2 then 1 else 0) - + (if 6 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_7 : ∀ e : Fin 372, + rowEval (d1Row 7) (fun j => if j = e then 1 else 0) = + (if 7 = (edge e).2 then 1 else 0) - + (if 7 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_8 : ∀ e : Fin 372, + rowEval (d1Row 8) (fun j => if j = e then 1 else 0) = + (if 8 = (edge e).2 then 1 else 0) - + (if 8 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_9 : ∀ e : Fin 372, + rowEval (d1Row 9) (fun j => if j = e then 1 else 0) = + (if 9 = (edge e).2 then 1 else 0) - + (if 9 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_10 : ∀ e : Fin 372, + rowEval (d1Row 10) (fun j => if j = e then 1 else 0) = + (if 10 = (edge e).2 then 1 else 0) - + (if 10 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_11 : ∀ e : Fin 372, + rowEval (d1Row 11) (fun j => if j = e then 1 else 0) = + (if 11 = (edge e).2 then 1 else 0) - + (if 11 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_12 : ∀ e : Fin 372, + rowEval (d1Row 12) (fun j => if j = e then 1 else 0) = + (if 12 = (edge e).2 then 1 else 0) - + (if 12 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_13 : ∀ e : Fin 372, + rowEval (d1Row 13) (fun j => if j = e then 1 else 0) = + (if 13 = (edge e).2 then 1 else 0) - + (if 13 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_14 : ∀ e : Fin 372, + rowEval (d1Row 14) (fun j => if j = e then 1 else 0) = + (if 14 = (edge e).2 then 1 else 0) - + (if 14 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_15 : ∀ e : Fin 372, + rowEval (d1Row 15) (fun j => if j = e then 1 else 0) = + (if 15 = (edge e).2 then 1 else 0) - + (if 15 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_16 : ∀ e : Fin 372, + rowEval (d1Row 16) (fun j => if j = e then 1 else 0) = + (if 16 = (edge e).2 then 1 else 0) - + (if 16 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_17 : ∀ e : Fin 372, + rowEval (d1Row 17) (fun j => if j = e then 1 else 0) = + (if 17 = (edge e).2 then 1 else 0) - + (if 17 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_18 : ∀ e : Fin 372, + rowEval (d1Row 18) (fun j => if j = e then 1 else 0) = + (if 18 = (edge e).2 then 1 else 0) - + (if 18 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_19 : ∀ e : Fin 372, + rowEval (d1Row 19) (fun j => if j = e then 1 else 0) = + (if 19 = (edge e).2 then 1 else 0) - + (if 19 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_20 : ∀ e : Fin 372, + rowEval (d1Row 20) (fun j => if j = e then 1 else 0) = + (if 20 = (edge e).2 then 1 else 0) - + (if 20 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_21 : ∀ e : Fin 372, + rowEval (d1Row 21) (fun j => if j = e then 1 else 0) = + (if 21 = (edge e).2 then 1 else 0) - + (if 21 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_22 : ∀ e : Fin 372, + rowEval (d1Row 22) (fun j => if j = e then 1 else 0) = + (if 22 = (edge e).2 then 1 else 0) - + (if 22 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_23 : ∀ e : Fin 372, + rowEval (d1Row 23) (fun j => if j = e then 1 else 0) = + (if 23 = (edge e).2 then 1 else 0) - + (if 23 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_24 : ∀ e : Fin 372, + rowEval (d1Row 24) (fun j => if j = e then 1 else 0) = + (if 24 = (edge e).2 then 1 else 0) - + (if 24 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_25 : ∀ e : Fin 372, + rowEval (d1Row 25) (fun j => if j = e then 1 else 0) = + (if 25 = (edge e).2 then 1 else 0) - + (if 25 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_26 : ∀ e : Fin 372, + rowEval (d1Row 26) (fun j => if j = e then 1 else 0) = + (if 26 = (edge e).2 then 1 else 0) - + (if 26 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_27 : ∀ e : Fin 372, + rowEval (d1Row 27) (fun j => if j = e then 1 else 0) = + (if 27 = (edge e).2 then 1 else 0) - + (if 27 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_28 : ∀ e : Fin 372, + rowEval (d1Row 28) (fun j => if j = e then 1 else 0) = + (if 28 = (edge e).2 then 1 else 0) - + (if 28 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_29 : ∀ e : Fin 372, + rowEval (d1Row 29) (fun j => if j = e then 1 else 0) = + (if 29 = (edge e).2 then 1 else 0) - + (if 29 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_30 : ∀ e : Fin 372, + rowEval (d1Row 30) (fun j => if j = e then 1 else 0) = + (if 30 = (edge e).2 then 1 else 0) - + (if 30 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_31 : ∀ e : Fin 372, + rowEval (d1Row 31) (fun j => if j = e then 1 else 0) = + (if 31 = (edge e).2 then 1 else 0) - + (if 31 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_32 : ∀ e : Fin 372, + rowEval (d1Row 32) (fun j => if j = e then 1 else 0) = + (if 32 = (edge e).2 then 1 else 0) - + (if 32 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_33 : ∀ e : Fin 372, + rowEval (d1Row 33) (fun j => if j = e then 1 else 0) = + (if 33 = (edge e).2 then 1 else 0) - + (if 33 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_34 : ∀ e : Fin 372, + rowEval (d1Row 34) (fun j => if j = e then 1 else 0) = + (if 34 = (edge e).2 then 1 else 0) - + (if 34 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_35 : ∀ e : Fin 372, + rowEval (d1Row 35) (fun j => if j = e then 1 else 0) = + (if 35 = (edge e).2 then 1 else 0) - + (if 35 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_36 : ∀ e : Fin 372, + rowEval (d1Row 36) (fun j => if j = e then 1 else 0) = + (if 36 = (edge e).2 then 1 else 0) - + (if 36 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_37 : ∀ e : Fin 372, + rowEval (d1Row 37) (fun j => if j = e then 1 else 0) = + (if 37 = (edge e).2 then 1 else 0) - + (if 37 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_38 : ∀ e : Fin 372, + rowEval (d1Row 38) (fun j => if j = e then 1 else 0) = + (if 38 = (edge e).2 then 1 else 0) - + (if 38 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_39 : ∀ e : Fin 372, + rowEval (d1Row 39) (fun j => if j = e then 1 else 0) = + (if 39 = (edge e).2 then 1 else 0) - + (if 39 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_40 : ∀ e : Fin 372, + rowEval (d1Row 40) (fun j => if j = e then 1 else 0) = + (if 40 = (edge e).2 then 1 else 0) - + (if 40 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_41 : ∀ e : Fin 372, + rowEval (d1Row 41) (fun j => if j = e then 1 else 0) = + (if 41 = (edge e).2 then 1 else 0) - + (if 41 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_42 : ∀ e : Fin 372, + rowEval (d1Row 42) (fun j => if j = e then 1 else 0) = + (if 42 = (edge e).2 then 1 else 0) - + (if 42 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_43 : ∀ e : Fin 372, + rowEval (d1Row 43) (fun j => if j = e then 1 else 0) = + (if 43 = (edge e).2 then 1 else 0) - + (if 43 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_44 : ∀ e : Fin 372, + rowEval (d1Row 44) (fun j => if j = e then 1 else 0) = + (if 44 = (edge e).2 then 1 else 0) - + (if 44 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_45 : ∀ e : Fin 372, + rowEval (d1Row 45) (fun j => if j = e then 1 else 0) = + (if 45 = (edge e).2 then 1 else 0) - + (if 45 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_46 : ∀ e : Fin 372, + rowEval (d1Row 46) (fun j => if j = e then 1 else 0) = + (if 46 = (edge e).2 then 1 else 0) - + (if 46 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_47 : ∀ e : Fin 372, + rowEval (d1Row 47) (fun j => if j = e then 1 else 0) = + (if 47 = (edge e).2 then 1 else 0) - + (if 47 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_48 : ∀ e : Fin 372, + rowEval (d1Row 48) (fun j => if j = e then 1 else 0) = + (if 48 = (edge e).2 then 1 else 0) - + (if 48 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_49 : ∀ e : Fin 372, + rowEval (d1Row 49) (fun j => if j = e then 1 else 0) = + (if 49 = (edge e).2 then 1 else 0) - + (if 49 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_50 : ∀ e : Fin 372, + rowEval (d1Row 50) (fun j => if j = e then 1 else 0) = + (if 50 = (edge e).2 then 1 else 0) - + (if 50 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_51 : ∀ e : Fin 372, + rowEval (d1Row 51) (fun j => if j = e then 1 else 0) = + (if 51 = (edge e).2 then 1 else 0) - + (if 51 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_52 : ∀ e : Fin 372, + rowEval (d1Row 52) (fun j => if j = e then 1 else 0) = + (if 52 = (edge e).2 then 1 else 0) - + (if 52 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_53 : ∀ e : Fin 372, + rowEval (d1Row 53) (fun j => if j = e then 1 else 0) = + (if 53 = (edge e).2 then 1 else 0) - + (if 53 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_54 : ∀ e : Fin 372, + rowEval (d1Row 54) (fun j => if j = e then 1 else 0) = + (if 54 = (edge e).2 then 1 else 0) - + (if 54 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_55 : ∀ e : Fin 372, + rowEval (d1Row 55) (fun j => if j = e then 1 else 0) = + (if 55 = (edge e).2 then 1 else 0) - + (if 55 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_56 : ∀ e : Fin 372, + rowEval (d1Row 56) (fun j => if j = e then 1 else 0) = + (if 56 = (edge e).2 then 1 else 0) - + (if 56 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_57 : ∀ e : Fin 372, + rowEval (d1Row 57) (fun j => if j = e then 1 else 0) = + (if 57 = (edge e).2 then 1 else 0) - + (if 57 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_58 : ∀ e : Fin 372, + rowEval (d1Row 58) (fun j => if j = e then 1 else 0) = + (if 58 = (edge e).2 then 1 else 0) - + (if 58 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_59 : ∀ e : Fin 372, + rowEval (d1Row 59) (fun j => if j = e then 1 else 0) = + (if 59 = (edge e).2 then 1 else 0) - + (if 59 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_60 : ∀ e : Fin 372, + rowEval (d1Row 60) (fun j => if j = e then 1 else 0) = + (if 60 = (edge e).2 then 1 else 0) - + (if 60 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_61 : ∀ e : Fin 372, + rowEval (d1Row 61) (fun j => if j = e then 1 else 0) = + (if 61 = (edge e).2 then 1 else 0) - + (if 61 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_62 : ∀ e : Fin 372, + rowEval (d1Row 62) (fun j => if j = e then 1 else 0) = + (if 62 = (edge e).2 then 1 else 0) - + (if 62 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_63 : ∀ e : Fin 372, + rowEval (d1Row 63) (fun j => if j = e then 1 else 0) = + (if 63 = (edge e).2 then 1 else 0) - + (if 63 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_64 : ∀ e : Fin 372, + rowEval (d1Row 64) (fun j => if j = e then 1 else 0) = + (if 64 = (edge e).2 then 1 else 0) - + (if 64 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_65 : ∀ e : Fin 372, + rowEval (d1Row 65) (fun j => if j = e then 1 else 0) = + (if 65 = (edge e).2 then 1 else 0) - + (if 65 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_66 : ∀ e : Fin 372, + rowEval (d1Row 66) (fun j => if j = e then 1 else 0) = + (if 66 = (edge e).2 then 1 else 0) - + (if 66 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_67 : ∀ e : Fin 372, + rowEval (d1Row 67) (fun j => if j = e then 1 else 0) = + (if 67 = (edge e).2 then 1 else 0) - + (if 67 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_68 : ∀ e : Fin 372, + rowEval (d1Row 68) (fun j => if j = e then 1 else 0) = + (if 68 = (edge e).2 then 1 else 0) - + (if 68 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_69 : ∀ e : Fin 372, + rowEval (d1Row 69) (fun j => if j = e then 1 else 0) = + (if 69 = (edge e).2 then 1 else 0) - + (if 69 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_70 : ∀ e : Fin 372, + rowEval (d1Row 70) (fun j => if j = e then 1 else 0) = + (if 70 = (edge e).2 then 1 else 0) - + (if 70 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_71 : ∀ e : Fin 372, + rowEval (d1Row 71) (fun j => if j = e then 1 else 0) = + (if 71 = (edge e).2 then 1 else 0) - + (if 71 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_72 : ∀ e : Fin 372, + rowEval (d1Row 72) (fun j => if j = e then 1 else 0) = + (if 72 = (edge e).2 then 1 else 0) - + (if 72 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_73 : ∀ e : Fin 372, + rowEval (d1Row 73) (fun j => if j = e then 1 else 0) = + (if 73 = (edge e).2 then 1 else 0) - + (if 73 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_74 : ∀ e : Fin 372, + rowEval (d1Row 74) (fun j => if j = e then 1 else 0) = + (if 74 = (edge e).2 then 1 else 0) - + (if 74 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_75 : ∀ e : Fin 372, + rowEval (d1Row 75) (fun j => if j = e then 1 else 0) = + (if 75 = (edge e).2 then 1 else 0) - + (if 75 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_76 : ∀ e : Fin 372, + rowEval (d1Row 76) (fun j => if j = e then 1 else 0) = + (if 76 = (edge e).2 then 1 else 0) - + (if 76 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_77 : ∀ e : Fin 372, + rowEval (d1Row 77) (fun j => if j = e then 1 else 0) = + (if 77 = (edge e).2 then 1 else 0) - + (if 77 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_78 : ∀ e : Fin 372, + rowEval (d1Row 78) (fun j => if j = e then 1 else 0) = + (if 78 = (edge e).2 then 1 else 0) - + (if 78 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_79 : ∀ e : Fin 372, + rowEval (d1Row 79) (fun j => if j = e then 1 else 0) = + (if 79 = (edge e).2 then 1 else 0) - + (if 79 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_80 : ∀ e : Fin 372, + rowEval (d1Row 80) (fun j => if j = e then 1 else 0) = + (if 80 = (edge e).2 then 1 else 0) - + (if 80 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_81 : ∀ e : Fin 372, + rowEval (d1Row 81) (fun j => if j = e then 1 else 0) = + (if 81 = (edge e).2 then 1 else 0) - + (if 81 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_82 : ∀ e : Fin 372, + rowEval (d1Row 82) (fun j => if j = e then 1 else 0) = + (if 82 = (edge e).2 then 1 else 0) - + (if 82 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_83 : ∀ e : Fin 372, + rowEval (d1Row 83) (fun j => if j = e then 1 else 0) = + (if 83 = (edge e).2 then 1 else 0) - + (if 83 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_84 : ∀ e : Fin 372, + rowEval (d1Row 84) (fun j => if j = e then 1 else 0) = + (if 84 = (edge e).2 then 1 else 0) - + (if 84 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_85 : ∀ e : Fin 372, + rowEval (d1Row 85) (fun j => if j = e then 1 else 0) = + (if 85 = (edge e).2 then 1 else 0) - + (if 85 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_86 : ∀ e : Fin 372, + rowEval (d1Row 86) (fun j => if j = e then 1 else 0) = + (if 86 = (edge e).2 then 1 else 0) - + (if 86 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_87 : ∀ e : Fin 372, + rowEval (d1Row 87) (fun j => if j = e then 1 else 0) = + (if 87 = (edge e).2 then 1 else 0) - + (if 87 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_88 : ∀ e : Fin 372, + rowEval (d1Row 88) (fun j => if j = e then 1 else 0) = + (if 88 = (edge e).2 then 1 else 0) - + (if 88 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_89 : ∀ e : Fin 372, + rowEval (d1Row 89) (fun j => if j = e then 1 else 0) = + (if 89 = (edge e).2 then 1 else 0) - + (if 89 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_90 : ∀ e : Fin 372, + rowEval (d1Row 90) (fun j => if j = e then 1 else 0) = + (if 90 = (edge e).2 then 1 else 0) - + (if 90 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_91 : ∀ e : Fin 372, + rowEval (d1Row 91) (fun j => if j = e then 1 else 0) = + (if 91 = (edge e).2 then 1 else 0) - + (if 91 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_92 : ∀ e : Fin 372, + rowEval (d1Row 92) (fun j => if j = e then 1 else 0) = + (if 92 = (edge e).2 then 1 else 0) - + (if 92 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_93 : ∀ e : Fin 372, + rowEval (d1Row 93) (fun j => if j = e then 1 else 0) = + (if 93 = (edge e).2 then 1 else 0) - + (if 93 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_94 : ∀ e : Fin 372, + rowEval (d1Row 94) (fun j => if j = e then 1 else 0) = + (if 94 = (edge e).2 then 1 else 0) - + (if 94 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_95 : ∀ e : Fin 372, + rowEval (d1Row 95) (fun j => if j = e then 1 else 0) = + (if 95 = (edge e).2 then 1 else 0) - + (if 95 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_96 : ∀ e : Fin 372, + rowEval (d1Row 96) (fun j => if j = e then 1 else 0) = + (if 96 = (edge e).2 then 1 else 0) - + (if 96 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_97 : ∀ e : Fin 372, + rowEval (d1Row 97) (fun j => if j = e then 1 else 0) = + (if 97 = (edge e).2 then 1 else 0) - + (if 97 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_98 : ∀ e : Fin 372, + rowEval (d1Row 98) (fun j => if j = e then 1 else 0) = + (if 98 = (edge e).2 then 1 else 0) - + (if 98 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_99 : ∀ e : Fin 372, + rowEval (d1Row 99) (fun j => if j = e then 1 else 0) = + (if 99 = (edge e).2 then 1 else 0) - + (if 99 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_100 : ∀ e : Fin 372, + rowEval (d1Row 100) (fun j => if j = e then 1 else 0) = + (if 100 = (edge e).2 then 1 else 0) - + (if 100 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_101 : ∀ e : Fin 372, + rowEval (d1Row 101) (fun j => if j = e then 1 else 0) = + (if 101 = (edge e).2 then 1 else 0) - + (if 101 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d1_basis_cert_102 : ∀ e : Fin 372, + rowEval (d1Row 102) (fun j => if j = e then 1 else 0) = + (if 102 = (edge e).2 then 1 else 0) - + (if 102 = (edge e).1 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_0 : ∀ t : Fin 270, + rowEval (d2Row 0) (fun j => if j = t then 1 else 0) = + (if 0 = (triangleEdges t).1 then 1 else 0) - + (if 0 = (triangleEdges t).2.1 then 1 else 0) + + (if 0 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_1 : ∀ t : Fin 270, + rowEval (d2Row 1) (fun j => if j = t then 1 else 0) = + (if 1 = (triangleEdges t).1 then 1 else 0) - + (if 1 = (triangleEdges t).2.1 then 1 else 0) + + (if 1 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_2 : ∀ t : Fin 270, + rowEval (d2Row 2) (fun j => if j = t then 1 else 0) = + (if 2 = (triangleEdges t).1 then 1 else 0) - + (if 2 = (triangleEdges t).2.1 then 1 else 0) + + (if 2 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_3 : ∀ t : Fin 270, + rowEval (d2Row 3) (fun j => if j = t then 1 else 0) = + (if 3 = (triangleEdges t).1 then 1 else 0) - + (if 3 = (triangleEdges t).2.1 then 1 else 0) + + (if 3 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_4 : ∀ t : Fin 270, + rowEval (d2Row 4) (fun j => if j = t then 1 else 0) = + (if 4 = (triangleEdges t).1 then 1 else 0) - + (if 4 = (triangleEdges t).2.1 then 1 else 0) + + (if 4 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_5 : ∀ t : Fin 270, + rowEval (d2Row 5) (fun j => if j = t then 1 else 0) = + (if 5 = (triangleEdges t).1 then 1 else 0) - + (if 5 = (triangleEdges t).2.1 then 1 else 0) + + (if 5 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_6 : ∀ t : Fin 270, + rowEval (d2Row 6) (fun j => if j = t then 1 else 0) = + (if 6 = (triangleEdges t).1 then 1 else 0) - + (if 6 = (triangleEdges t).2.1 then 1 else 0) + + (if 6 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_7 : ∀ t : Fin 270, + rowEval (d2Row 7) (fun j => if j = t then 1 else 0) = + (if 7 = (triangleEdges t).1 then 1 else 0) - + (if 7 = (triangleEdges t).2.1 then 1 else 0) + + (if 7 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_8 : ∀ t : Fin 270, + rowEval (d2Row 8) (fun j => if j = t then 1 else 0) = + (if 8 = (triangleEdges t).1 then 1 else 0) - + (if 8 = (triangleEdges t).2.1 then 1 else 0) + + (if 8 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_9 : ∀ t : Fin 270, + rowEval (d2Row 9) (fun j => if j = t then 1 else 0) = + (if 9 = (triangleEdges t).1 then 1 else 0) - + (if 9 = (triangleEdges t).2.1 then 1 else 0) + + (if 9 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_10 : ∀ t : Fin 270, + rowEval (d2Row 10) (fun j => if j = t then 1 else 0) = + (if 10 = (triangleEdges t).1 then 1 else 0) - + (if 10 = (triangleEdges t).2.1 then 1 else 0) + + (if 10 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_11 : ∀ t : Fin 270, + rowEval (d2Row 11) (fun j => if j = t then 1 else 0) = + (if 11 = (triangleEdges t).1 then 1 else 0) - + (if 11 = (triangleEdges t).2.1 then 1 else 0) + + (if 11 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_12 : ∀ t : Fin 270, + rowEval (d2Row 12) (fun j => if j = t then 1 else 0) = + (if 12 = (triangleEdges t).1 then 1 else 0) - + (if 12 = (triangleEdges t).2.1 then 1 else 0) + + (if 12 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_13 : ∀ t : Fin 270, + rowEval (d2Row 13) (fun j => if j = t then 1 else 0) = + (if 13 = (triangleEdges t).1 then 1 else 0) - + (if 13 = (triangleEdges t).2.1 then 1 else 0) + + (if 13 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_14 : ∀ t : Fin 270, + rowEval (d2Row 14) (fun j => if j = t then 1 else 0) = + (if 14 = (triangleEdges t).1 then 1 else 0) - + (if 14 = (triangleEdges t).2.1 then 1 else 0) + + (if 14 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_15 : ∀ t : Fin 270, + rowEval (d2Row 15) (fun j => if j = t then 1 else 0) = + (if 15 = (triangleEdges t).1 then 1 else 0) - + (if 15 = (triangleEdges t).2.1 then 1 else 0) + + (if 15 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_16 : ∀ t : Fin 270, + rowEval (d2Row 16) (fun j => if j = t then 1 else 0) = + (if 16 = (triangleEdges t).1 then 1 else 0) - + (if 16 = (triangleEdges t).2.1 then 1 else 0) + + (if 16 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_17 : ∀ t : Fin 270, + rowEval (d2Row 17) (fun j => if j = t then 1 else 0) = + (if 17 = (triangleEdges t).1 then 1 else 0) - + (if 17 = (triangleEdges t).2.1 then 1 else 0) + + (if 17 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_18 : ∀ t : Fin 270, + rowEval (d2Row 18) (fun j => if j = t then 1 else 0) = + (if 18 = (triangleEdges t).1 then 1 else 0) - + (if 18 = (triangleEdges t).2.1 then 1 else 0) + + (if 18 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_19 : ∀ t : Fin 270, + rowEval (d2Row 19) (fun j => if j = t then 1 else 0) = + (if 19 = (triangleEdges t).1 then 1 else 0) - + (if 19 = (triangleEdges t).2.1 then 1 else 0) + + (if 19 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_20 : ∀ t : Fin 270, + rowEval (d2Row 20) (fun j => if j = t then 1 else 0) = + (if 20 = (triangleEdges t).1 then 1 else 0) - + (if 20 = (triangleEdges t).2.1 then 1 else 0) + + (if 20 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_21 : ∀ t : Fin 270, + rowEval (d2Row 21) (fun j => if j = t then 1 else 0) = + (if 21 = (triangleEdges t).1 then 1 else 0) - + (if 21 = (triangleEdges t).2.1 then 1 else 0) + + (if 21 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_22 : ∀ t : Fin 270, + rowEval (d2Row 22) (fun j => if j = t then 1 else 0) = + (if 22 = (triangleEdges t).1 then 1 else 0) - + (if 22 = (triangleEdges t).2.1 then 1 else 0) + + (if 22 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_23 : ∀ t : Fin 270, + rowEval (d2Row 23) (fun j => if j = t then 1 else 0) = + (if 23 = (triangleEdges t).1 then 1 else 0) - + (if 23 = (triangleEdges t).2.1 then 1 else 0) + + (if 23 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_24 : ∀ t : Fin 270, + rowEval (d2Row 24) (fun j => if j = t then 1 else 0) = + (if 24 = (triangleEdges t).1 then 1 else 0) - + (if 24 = (triangleEdges t).2.1 then 1 else 0) + + (if 24 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_25 : ∀ t : Fin 270, + rowEval (d2Row 25) (fun j => if j = t then 1 else 0) = + (if 25 = (triangleEdges t).1 then 1 else 0) - + (if 25 = (triangleEdges t).2.1 then 1 else 0) + + (if 25 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_26 : ∀ t : Fin 270, + rowEval (d2Row 26) (fun j => if j = t then 1 else 0) = + (if 26 = (triangleEdges t).1 then 1 else 0) - + (if 26 = (triangleEdges t).2.1 then 1 else 0) + + (if 26 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_27 : ∀ t : Fin 270, + rowEval (d2Row 27) (fun j => if j = t then 1 else 0) = + (if 27 = (triangleEdges t).1 then 1 else 0) - + (if 27 = (triangleEdges t).2.1 then 1 else 0) + + (if 27 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_28 : ∀ t : Fin 270, + rowEval (d2Row 28) (fun j => if j = t then 1 else 0) = + (if 28 = (triangleEdges t).1 then 1 else 0) - + (if 28 = (triangleEdges t).2.1 then 1 else 0) + + (if 28 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_29 : ∀ t : Fin 270, + rowEval (d2Row 29) (fun j => if j = t then 1 else 0) = + (if 29 = (triangleEdges t).1 then 1 else 0) - + (if 29 = (triangleEdges t).2.1 then 1 else 0) + + (if 29 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_30 : ∀ t : Fin 270, + rowEval (d2Row 30) (fun j => if j = t then 1 else 0) = + (if 30 = (triangleEdges t).1 then 1 else 0) - + (if 30 = (triangleEdges t).2.1 then 1 else 0) + + (if 30 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_31 : ∀ t : Fin 270, + rowEval (d2Row 31) (fun j => if j = t then 1 else 0) = + (if 31 = (triangleEdges t).1 then 1 else 0) - + (if 31 = (triangleEdges t).2.1 then 1 else 0) + + (if 31 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_32 : ∀ t : Fin 270, + rowEval (d2Row 32) (fun j => if j = t then 1 else 0) = + (if 32 = (triangleEdges t).1 then 1 else 0) - + (if 32 = (triangleEdges t).2.1 then 1 else 0) + + (if 32 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_33 : ∀ t : Fin 270, + rowEval (d2Row 33) (fun j => if j = t then 1 else 0) = + (if 33 = (triangleEdges t).1 then 1 else 0) - + (if 33 = (triangleEdges t).2.1 then 1 else 0) + + (if 33 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_34 : ∀ t : Fin 270, + rowEval (d2Row 34) (fun j => if j = t then 1 else 0) = + (if 34 = (triangleEdges t).1 then 1 else 0) - + (if 34 = (triangleEdges t).2.1 then 1 else 0) + + (if 34 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_35 : ∀ t : Fin 270, + rowEval (d2Row 35) (fun j => if j = t then 1 else 0) = + (if 35 = (triangleEdges t).1 then 1 else 0) - + (if 35 = (triangleEdges t).2.1 then 1 else 0) + + (if 35 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_36 : ∀ t : Fin 270, + rowEval (d2Row 36) (fun j => if j = t then 1 else 0) = + (if 36 = (triangleEdges t).1 then 1 else 0) - + (if 36 = (triangleEdges t).2.1 then 1 else 0) + + (if 36 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_37 : ∀ t : Fin 270, + rowEval (d2Row 37) (fun j => if j = t then 1 else 0) = + (if 37 = (triangleEdges t).1 then 1 else 0) - + (if 37 = (triangleEdges t).2.1 then 1 else 0) + + (if 37 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_38 : ∀ t : Fin 270, + rowEval (d2Row 38) (fun j => if j = t then 1 else 0) = + (if 38 = (triangleEdges t).1 then 1 else 0) - + (if 38 = (triangleEdges t).2.1 then 1 else 0) + + (if 38 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_39 : ∀ t : Fin 270, + rowEval (d2Row 39) (fun j => if j = t then 1 else 0) = + (if 39 = (triangleEdges t).1 then 1 else 0) - + (if 39 = (triangleEdges t).2.1 then 1 else 0) + + (if 39 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_40 : ∀ t : Fin 270, + rowEval (d2Row 40) (fun j => if j = t then 1 else 0) = + (if 40 = (triangleEdges t).1 then 1 else 0) - + (if 40 = (triangleEdges t).2.1 then 1 else 0) + + (if 40 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_41 : ∀ t : Fin 270, + rowEval (d2Row 41) (fun j => if j = t then 1 else 0) = + (if 41 = (triangleEdges t).1 then 1 else 0) - + (if 41 = (triangleEdges t).2.1 then 1 else 0) + + (if 41 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_42 : ∀ t : Fin 270, + rowEval (d2Row 42) (fun j => if j = t then 1 else 0) = + (if 42 = (triangleEdges t).1 then 1 else 0) - + (if 42 = (triangleEdges t).2.1 then 1 else 0) + + (if 42 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_43 : ∀ t : Fin 270, + rowEval (d2Row 43) (fun j => if j = t then 1 else 0) = + (if 43 = (triangleEdges t).1 then 1 else 0) - + (if 43 = (triangleEdges t).2.1 then 1 else 0) + + (if 43 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_44 : ∀ t : Fin 270, + rowEval (d2Row 44) (fun j => if j = t then 1 else 0) = + (if 44 = (triangleEdges t).1 then 1 else 0) - + (if 44 = (triangleEdges t).2.1 then 1 else 0) + + (if 44 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_45 : ∀ t : Fin 270, + rowEval (d2Row 45) (fun j => if j = t then 1 else 0) = + (if 45 = (triangleEdges t).1 then 1 else 0) - + (if 45 = (triangleEdges t).2.1 then 1 else 0) + + (if 45 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_46 : ∀ t : Fin 270, + rowEval (d2Row 46) (fun j => if j = t then 1 else 0) = + (if 46 = (triangleEdges t).1 then 1 else 0) - + (if 46 = (triangleEdges t).2.1 then 1 else 0) + + (if 46 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_47 : ∀ t : Fin 270, + rowEval (d2Row 47) (fun j => if j = t then 1 else 0) = + (if 47 = (triangleEdges t).1 then 1 else 0) - + (if 47 = (triangleEdges t).2.1 then 1 else 0) + + (if 47 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_48 : ∀ t : Fin 270, + rowEval (d2Row 48) (fun j => if j = t then 1 else 0) = + (if 48 = (triangleEdges t).1 then 1 else 0) - + (if 48 = (triangleEdges t).2.1 then 1 else 0) + + (if 48 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_49 : ∀ t : Fin 270, + rowEval (d2Row 49) (fun j => if j = t then 1 else 0) = + (if 49 = (triangleEdges t).1 then 1 else 0) - + (if 49 = (triangleEdges t).2.1 then 1 else 0) + + (if 49 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_50 : ∀ t : Fin 270, + rowEval (d2Row 50) (fun j => if j = t then 1 else 0) = + (if 50 = (triangleEdges t).1 then 1 else 0) - + (if 50 = (triangleEdges t).2.1 then 1 else 0) + + (if 50 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_51 : ∀ t : Fin 270, + rowEval (d2Row 51) (fun j => if j = t then 1 else 0) = + (if 51 = (triangleEdges t).1 then 1 else 0) - + (if 51 = (triangleEdges t).2.1 then 1 else 0) + + (if 51 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_52 : ∀ t : Fin 270, + rowEval (d2Row 52) (fun j => if j = t then 1 else 0) = + (if 52 = (triangleEdges t).1 then 1 else 0) - + (if 52 = (triangleEdges t).2.1 then 1 else 0) + + (if 52 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_53 : ∀ t : Fin 270, + rowEval (d2Row 53) (fun j => if j = t then 1 else 0) = + (if 53 = (triangleEdges t).1 then 1 else 0) - + (if 53 = (triangleEdges t).2.1 then 1 else 0) + + (if 53 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_54 : ∀ t : Fin 270, + rowEval (d2Row 54) (fun j => if j = t then 1 else 0) = + (if 54 = (triangleEdges t).1 then 1 else 0) - + (if 54 = (triangleEdges t).2.1 then 1 else 0) + + (if 54 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_55 : ∀ t : Fin 270, + rowEval (d2Row 55) (fun j => if j = t then 1 else 0) = + (if 55 = (triangleEdges t).1 then 1 else 0) - + (if 55 = (triangleEdges t).2.1 then 1 else 0) + + (if 55 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_56 : ∀ t : Fin 270, + rowEval (d2Row 56) (fun j => if j = t then 1 else 0) = + (if 56 = (triangleEdges t).1 then 1 else 0) - + (if 56 = (triangleEdges t).2.1 then 1 else 0) + + (if 56 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_57 : ∀ t : Fin 270, + rowEval (d2Row 57) (fun j => if j = t then 1 else 0) = + (if 57 = (triangleEdges t).1 then 1 else 0) - + (if 57 = (triangleEdges t).2.1 then 1 else 0) + + (if 57 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_58 : ∀ t : Fin 270, + rowEval (d2Row 58) (fun j => if j = t then 1 else 0) = + (if 58 = (triangleEdges t).1 then 1 else 0) - + (if 58 = (triangleEdges t).2.1 then 1 else 0) + + (if 58 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_59 : ∀ t : Fin 270, + rowEval (d2Row 59) (fun j => if j = t then 1 else 0) = + (if 59 = (triangleEdges t).1 then 1 else 0) - + (if 59 = (triangleEdges t).2.1 then 1 else 0) + + (if 59 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_60 : ∀ t : Fin 270, + rowEval (d2Row 60) (fun j => if j = t then 1 else 0) = + (if 60 = (triangleEdges t).1 then 1 else 0) - + (if 60 = (triangleEdges t).2.1 then 1 else 0) + + (if 60 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_61 : ∀ t : Fin 270, + rowEval (d2Row 61) (fun j => if j = t then 1 else 0) = + (if 61 = (triangleEdges t).1 then 1 else 0) - + (if 61 = (triangleEdges t).2.1 then 1 else 0) + + (if 61 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_62 : ∀ t : Fin 270, + rowEval (d2Row 62) (fun j => if j = t then 1 else 0) = + (if 62 = (triangleEdges t).1 then 1 else 0) - + (if 62 = (triangleEdges t).2.1 then 1 else 0) + + (if 62 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_63 : ∀ t : Fin 270, + rowEval (d2Row 63) (fun j => if j = t then 1 else 0) = + (if 63 = (triangleEdges t).1 then 1 else 0) - + (if 63 = (triangleEdges t).2.1 then 1 else 0) + + (if 63 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_64 : ∀ t : Fin 270, + rowEval (d2Row 64) (fun j => if j = t then 1 else 0) = + (if 64 = (triangleEdges t).1 then 1 else 0) - + (if 64 = (triangleEdges t).2.1 then 1 else 0) + + (if 64 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_65 : ∀ t : Fin 270, + rowEval (d2Row 65) (fun j => if j = t then 1 else 0) = + (if 65 = (triangleEdges t).1 then 1 else 0) - + (if 65 = (triangleEdges t).2.1 then 1 else 0) + + (if 65 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_66 : ∀ t : Fin 270, + rowEval (d2Row 66) (fun j => if j = t then 1 else 0) = + (if 66 = (triangleEdges t).1 then 1 else 0) - + (if 66 = (triangleEdges t).2.1 then 1 else 0) + + (if 66 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_67 : ∀ t : Fin 270, + rowEval (d2Row 67) (fun j => if j = t then 1 else 0) = + (if 67 = (triangleEdges t).1 then 1 else 0) - + (if 67 = (triangleEdges t).2.1 then 1 else 0) + + (if 67 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_68 : ∀ t : Fin 270, + rowEval (d2Row 68) (fun j => if j = t then 1 else 0) = + (if 68 = (triangleEdges t).1 then 1 else 0) - + (if 68 = (triangleEdges t).2.1 then 1 else 0) + + (if 68 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_69 : ∀ t : Fin 270, + rowEval (d2Row 69) (fun j => if j = t then 1 else 0) = + (if 69 = (triangleEdges t).1 then 1 else 0) - + (if 69 = (triangleEdges t).2.1 then 1 else 0) + + (if 69 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_70 : ∀ t : Fin 270, + rowEval (d2Row 70) (fun j => if j = t then 1 else 0) = + (if 70 = (triangleEdges t).1 then 1 else 0) - + (if 70 = (triangleEdges t).2.1 then 1 else 0) + + (if 70 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_71 : ∀ t : Fin 270, + rowEval (d2Row 71) (fun j => if j = t then 1 else 0) = + (if 71 = (triangleEdges t).1 then 1 else 0) - + (if 71 = (triangleEdges t).2.1 then 1 else 0) + + (if 71 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_72 : ∀ t : Fin 270, + rowEval (d2Row 72) (fun j => if j = t then 1 else 0) = + (if 72 = (triangleEdges t).1 then 1 else 0) - + (if 72 = (triangleEdges t).2.1 then 1 else 0) + + (if 72 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_73 : ∀ t : Fin 270, + rowEval (d2Row 73) (fun j => if j = t then 1 else 0) = + (if 73 = (triangleEdges t).1 then 1 else 0) - + (if 73 = (triangleEdges t).2.1 then 1 else 0) + + (if 73 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_74 : ∀ t : Fin 270, + rowEval (d2Row 74) (fun j => if j = t then 1 else 0) = + (if 74 = (triangleEdges t).1 then 1 else 0) - + (if 74 = (triangleEdges t).2.1 then 1 else 0) + + (if 74 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_75 : ∀ t : Fin 270, + rowEval (d2Row 75) (fun j => if j = t then 1 else 0) = + (if 75 = (triangleEdges t).1 then 1 else 0) - + (if 75 = (triangleEdges t).2.1 then 1 else 0) + + (if 75 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_76 : ∀ t : Fin 270, + rowEval (d2Row 76) (fun j => if j = t then 1 else 0) = + (if 76 = (triangleEdges t).1 then 1 else 0) - + (if 76 = (triangleEdges t).2.1 then 1 else 0) + + (if 76 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_77 : ∀ t : Fin 270, + rowEval (d2Row 77) (fun j => if j = t then 1 else 0) = + (if 77 = (triangleEdges t).1 then 1 else 0) - + (if 77 = (triangleEdges t).2.1 then 1 else 0) + + (if 77 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_78 : ∀ t : Fin 270, + rowEval (d2Row 78) (fun j => if j = t then 1 else 0) = + (if 78 = (triangleEdges t).1 then 1 else 0) - + (if 78 = (triangleEdges t).2.1 then 1 else 0) + + (if 78 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_79 : ∀ t : Fin 270, + rowEval (d2Row 79) (fun j => if j = t then 1 else 0) = + (if 79 = (triangleEdges t).1 then 1 else 0) - + (if 79 = (triangleEdges t).2.1 then 1 else 0) + + (if 79 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_80 : ∀ t : Fin 270, + rowEval (d2Row 80) (fun j => if j = t then 1 else 0) = + (if 80 = (triangleEdges t).1 then 1 else 0) - + (if 80 = (triangleEdges t).2.1 then 1 else 0) + + (if 80 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_81 : ∀ t : Fin 270, + rowEval (d2Row 81) (fun j => if j = t then 1 else 0) = + (if 81 = (triangleEdges t).1 then 1 else 0) - + (if 81 = (triangleEdges t).2.1 then 1 else 0) + + (if 81 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_82 : ∀ t : Fin 270, + rowEval (d2Row 82) (fun j => if j = t then 1 else 0) = + (if 82 = (triangleEdges t).1 then 1 else 0) - + (if 82 = (triangleEdges t).2.1 then 1 else 0) + + (if 82 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_83 : ∀ t : Fin 270, + rowEval (d2Row 83) (fun j => if j = t then 1 else 0) = + (if 83 = (triangleEdges t).1 then 1 else 0) - + (if 83 = (triangleEdges t).2.1 then 1 else 0) + + (if 83 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_84 : ∀ t : Fin 270, + rowEval (d2Row 84) (fun j => if j = t then 1 else 0) = + (if 84 = (triangleEdges t).1 then 1 else 0) - + (if 84 = (triangleEdges t).2.1 then 1 else 0) + + (if 84 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_85 : ∀ t : Fin 270, + rowEval (d2Row 85) (fun j => if j = t then 1 else 0) = + (if 85 = (triangleEdges t).1 then 1 else 0) - + (if 85 = (triangleEdges t).2.1 then 1 else 0) + + (if 85 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_86 : ∀ t : Fin 270, + rowEval (d2Row 86) (fun j => if j = t then 1 else 0) = + (if 86 = (triangleEdges t).1 then 1 else 0) - + (if 86 = (triangleEdges t).2.1 then 1 else 0) + + (if 86 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_87 : ∀ t : Fin 270, + rowEval (d2Row 87) (fun j => if j = t then 1 else 0) = + (if 87 = (triangleEdges t).1 then 1 else 0) - + (if 87 = (triangleEdges t).2.1 then 1 else 0) + + (if 87 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_88 : ∀ t : Fin 270, + rowEval (d2Row 88) (fun j => if j = t then 1 else 0) = + (if 88 = (triangleEdges t).1 then 1 else 0) - + (if 88 = (triangleEdges t).2.1 then 1 else 0) + + (if 88 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_89 : ∀ t : Fin 270, + rowEval (d2Row 89) (fun j => if j = t then 1 else 0) = + (if 89 = (triangleEdges t).1 then 1 else 0) - + (if 89 = (triangleEdges t).2.1 then 1 else 0) + + (if 89 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_90 : ∀ t : Fin 270, + rowEval (d2Row 90) (fun j => if j = t then 1 else 0) = + (if 90 = (triangleEdges t).1 then 1 else 0) - + (if 90 = (triangleEdges t).2.1 then 1 else 0) + + (if 90 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_91 : ∀ t : Fin 270, + rowEval (d2Row 91) (fun j => if j = t then 1 else 0) = + (if 91 = (triangleEdges t).1 then 1 else 0) - + (if 91 = (triangleEdges t).2.1 then 1 else 0) + + (if 91 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_92 : ∀ t : Fin 270, + rowEval (d2Row 92) (fun j => if j = t then 1 else 0) = + (if 92 = (triangleEdges t).1 then 1 else 0) - + (if 92 = (triangleEdges t).2.1 then 1 else 0) + + (if 92 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_93 : ∀ t : Fin 270, + rowEval (d2Row 93) (fun j => if j = t then 1 else 0) = + (if 93 = (triangleEdges t).1 then 1 else 0) - + (if 93 = (triangleEdges t).2.1 then 1 else 0) + + (if 93 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_94 : ∀ t : Fin 270, + rowEval (d2Row 94) (fun j => if j = t then 1 else 0) = + (if 94 = (triangleEdges t).1 then 1 else 0) - + (if 94 = (triangleEdges t).2.1 then 1 else 0) + + (if 94 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_95 : ∀ t : Fin 270, + rowEval (d2Row 95) (fun j => if j = t then 1 else 0) = + (if 95 = (triangleEdges t).1 then 1 else 0) - + (if 95 = (triangleEdges t).2.1 then 1 else 0) + + (if 95 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_96 : ∀ t : Fin 270, + rowEval (d2Row 96) (fun j => if j = t then 1 else 0) = + (if 96 = (triangleEdges t).1 then 1 else 0) - + (if 96 = (triangleEdges t).2.1 then 1 else 0) + + (if 96 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_97 : ∀ t : Fin 270, + rowEval (d2Row 97) (fun j => if j = t then 1 else 0) = + (if 97 = (triangleEdges t).1 then 1 else 0) - + (if 97 = (triangleEdges t).2.1 then 1 else 0) + + (if 97 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_98 : ∀ t : Fin 270, + rowEval (d2Row 98) (fun j => if j = t then 1 else 0) = + (if 98 = (triangleEdges t).1 then 1 else 0) - + (if 98 = (triangleEdges t).2.1 then 1 else 0) + + (if 98 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_99 : ∀ t : Fin 270, + rowEval (d2Row 99) (fun j => if j = t then 1 else 0) = + (if 99 = (triangleEdges t).1 then 1 else 0) - + (if 99 = (triangleEdges t).2.1 then 1 else 0) + + (if 99 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_100 : ∀ t : Fin 270, + rowEval (d2Row 100) (fun j => if j = t then 1 else 0) = + (if 100 = (triangleEdges t).1 then 1 else 0) - + (if 100 = (triangleEdges t).2.1 then 1 else 0) + + (if 100 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_101 : ∀ t : Fin 270, + rowEval (d2Row 101) (fun j => if j = t then 1 else 0) = + (if 101 = (triangleEdges t).1 then 1 else 0) - + (if 101 = (triangleEdges t).2.1 then 1 else 0) + + (if 101 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_102 : ∀ t : Fin 270, + rowEval (d2Row 102) (fun j => if j = t then 1 else 0) = + (if 102 = (triangleEdges t).1 then 1 else 0) - + (if 102 = (triangleEdges t).2.1 then 1 else 0) + + (if 102 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_103 : ∀ t : Fin 270, + rowEval (d2Row 103) (fun j => if j = t then 1 else 0) = + (if 103 = (triangleEdges t).1 then 1 else 0) - + (if 103 = (triangleEdges t).2.1 then 1 else 0) + + (if 103 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_104 : ∀ t : Fin 270, + rowEval (d2Row 104) (fun j => if j = t then 1 else 0) = + (if 104 = (triangleEdges t).1 then 1 else 0) - + (if 104 = (triangleEdges t).2.1 then 1 else 0) + + (if 104 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_105 : ∀ t : Fin 270, + rowEval (d2Row 105) (fun j => if j = t then 1 else 0) = + (if 105 = (triangleEdges t).1 then 1 else 0) - + (if 105 = (triangleEdges t).2.1 then 1 else 0) + + (if 105 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_106 : ∀ t : Fin 270, + rowEval (d2Row 106) (fun j => if j = t then 1 else 0) = + (if 106 = (triangleEdges t).1 then 1 else 0) - + (if 106 = (triangleEdges t).2.1 then 1 else 0) + + (if 106 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_107 : ∀ t : Fin 270, + rowEval (d2Row 107) (fun j => if j = t then 1 else 0) = + (if 107 = (triangleEdges t).1 then 1 else 0) - + (if 107 = (triangleEdges t).2.1 then 1 else 0) + + (if 107 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_108 : ∀ t : Fin 270, + rowEval (d2Row 108) (fun j => if j = t then 1 else 0) = + (if 108 = (triangleEdges t).1 then 1 else 0) - + (if 108 = (triangleEdges t).2.1 then 1 else 0) + + (if 108 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_109 : ∀ t : Fin 270, + rowEval (d2Row 109) (fun j => if j = t then 1 else 0) = + (if 109 = (triangleEdges t).1 then 1 else 0) - + (if 109 = (triangleEdges t).2.1 then 1 else 0) + + (if 109 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_110 : ∀ t : Fin 270, + rowEval (d2Row 110) (fun j => if j = t then 1 else 0) = + (if 110 = (triangleEdges t).1 then 1 else 0) - + (if 110 = (triangleEdges t).2.1 then 1 else 0) + + (if 110 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_111 : ∀ t : Fin 270, + rowEval (d2Row 111) (fun j => if j = t then 1 else 0) = + (if 111 = (triangleEdges t).1 then 1 else 0) - + (if 111 = (triangleEdges t).2.1 then 1 else 0) + + (if 111 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_112 : ∀ t : Fin 270, + rowEval (d2Row 112) (fun j => if j = t then 1 else 0) = + (if 112 = (triangleEdges t).1 then 1 else 0) - + (if 112 = (triangleEdges t).2.1 then 1 else 0) + + (if 112 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_113 : ∀ t : Fin 270, + rowEval (d2Row 113) (fun j => if j = t then 1 else 0) = + (if 113 = (triangleEdges t).1 then 1 else 0) - + (if 113 = (triangleEdges t).2.1 then 1 else 0) + + (if 113 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_114 : ∀ t : Fin 270, + rowEval (d2Row 114) (fun j => if j = t then 1 else 0) = + (if 114 = (triangleEdges t).1 then 1 else 0) - + (if 114 = (triangleEdges t).2.1 then 1 else 0) + + (if 114 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_115 : ∀ t : Fin 270, + rowEval (d2Row 115) (fun j => if j = t then 1 else 0) = + (if 115 = (triangleEdges t).1 then 1 else 0) - + (if 115 = (triangleEdges t).2.1 then 1 else 0) + + (if 115 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_116 : ∀ t : Fin 270, + rowEval (d2Row 116) (fun j => if j = t then 1 else 0) = + (if 116 = (triangleEdges t).1 then 1 else 0) - + (if 116 = (triangleEdges t).2.1 then 1 else 0) + + (if 116 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_117 : ∀ t : Fin 270, + rowEval (d2Row 117) (fun j => if j = t then 1 else 0) = + (if 117 = (triangleEdges t).1 then 1 else 0) - + (if 117 = (triangleEdges t).2.1 then 1 else 0) + + (if 117 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_118 : ∀ t : Fin 270, + rowEval (d2Row 118) (fun j => if j = t then 1 else 0) = + (if 118 = (triangleEdges t).1 then 1 else 0) - + (if 118 = (triangleEdges t).2.1 then 1 else 0) + + (if 118 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_119 : ∀ t : Fin 270, + rowEval (d2Row 119) (fun j => if j = t then 1 else 0) = + (if 119 = (triangleEdges t).1 then 1 else 0) - + (if 119 = (triangleEdges t).2.1 then 1 else 0) + + (if 119 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_120 : ∀ t : Fin 270, + rowEval (d2Row 120) (fun j => if j = t then 1 else 0) = + (if 120 = (triangleEdges t).1 then 1 else 0) - + (if 120 = (triangleEdges t).2.1 then 1 else 0) + + (if 120 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_121 : ∀ t : Fin 270, + rowEval (d2Row 121) (fun j => if j = t then 1 else 0) = + (if 121 = (triangleEdges t).1 then 1 else 0) - + (if 121 = (triangleEdges t).2.1 then 1 else 0) + + (if 121 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_122 : ∀ t : Fin 270, + rowEval (d2Row 122) (fun j => if j = t then 1 else 0) = + (if 122 = (triangleEdges t).1 then 1 else 0) - + (if 122 = (triangleEdges t).2.1 then 1 else 0) + + (if 122 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_123 : ∀ t : Fin 270, + rowEval (d2Row 123) (fun j => if j = t then 1 else 0) = + (if 123 = (triangleEdges t).1 then 1 else 0) - + (if 123 = (triangleEdges t).2.1 then 1 else 0) + + (if 123 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_124 : ∀ t : Fin 270, + rowEval (d2Row 124) (fun j => if j = t then 1 else 0) = + (if 124 = (triangleEdges t).1 then 1 else 0) - + (if 124 = (triangleEdges t).2.1 then 1 else 0) + + (if 124 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_125 : ∀ t : Fin 270, + rowEval (d2Row 125) (fun j => if j = t then 1 else 0) = + (if 125 = (triangleEdges t).1 then 1 else 0) - + (if 125 = (triangleEdges t).2.1 then 1 else 0) + + (if 125 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_126 : ∀ t : Fin 270, + rowEval (d2Row 126) (fun j => if j = t then 1 else 0) = + (if 126 = (triangleEdges t).1 then 1 else 0) - + (if 126 = (triangleEdges t).2.1 then 1 else 0) + + (if 126 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_127 : ∀ t : Fin 270, + rowEval (d2Row 127) (fun j => if j = t then 1 else 0) = + (if 127 = (triangleEdges t).1 then 1 else 0) - + (if 127 = (triangleEdges t).2.1 then 1 else 0) + + (if 127 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_128 : ∀ t : Fin 270, + rowEval (d2Row 128) (fun j => if j = t then 1 else 0) = + (if 128 = (triangleEdges t).1 then 1 else 0) - + (if 128 = (triangleEdges t).2.1 then 1 else 0) + + (if 128 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_129 : ∀ t : Fin 270, + rowEval (d2Row 129) (fun j => if j = t then 1 else 0) = + (if 129 = (triangleEdges t).1 then 1 else 0) - + (if 129 = (triangleEdges t).2.1 then 1 else 0) + + (if 129 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_130 : ∀ t : Fin 270, + rowEval (d2Row 130) (fun j => if j = t then 1 else 0) = + (if 130 = (triangleEdges t).1 then 1 else 0) - + (if 130 = (triangleEdges t).2.1 then 1 else 0) + + (if 130 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_131 : ∀ t : Fin 270, + rowEval (d2Row 131) (fun j => if j = t then 1 else 0) = + (if 131 = (triangleEdges t).1 then 1 else 0) - + (if 131 = (triangleEdges t).2.1 then 1 else 0) + + (if 131 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_132 : ∀ t : Fin 270, + rowEval (d2Row 132) (fun j => if j = t then 1 else 0) = + (if 132 = (triangleEdges t).1 then 1 else 0) - + (if 132 = (triangleEdges t).2.1 then 1 else 0) + + (if 132 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_133 : ∀ t : Fin 270, + rowEval (d2Row 133) (fun j => if j = t then 1 else 0) = + (if 133 = (triangleEdges t).1 then 1 else 0) - + (if 133 = (triangleEdges t).2.1 then 1 else 0) + + (if 133 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_134 : ∀ t : Fin 270, + rowEval (d2Row 134) (fun j => if j = t then 1 else 0) = + (if 134 = (triangleEdges t).1 then 1 else 0) - + (if 134 = (triangleEdges t).2.1 then 1 else 0) + + (if 134 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_135 : ∀ t : Fin 270, + rowEval (d2Row 135) (fun j => if j = t then 1 else 0) = + (if 135 = (triangleEdges t).1 then 1 else 0) - + (if 135 = (triangleEdges t).2.1 then 1 else 0) + + (if 135 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_136 : ∀ t : Fin 270, + rowEval (d2Row 136) (fun j => if j = t then 1 else 0) = + (if 136 = (triangleEdges t).1 then 1 else 0) - + (if 136 = (triangleEdges t).2.1 then 1 else 0) + + (if 136 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_137 : ∀ t : Fin 270, + rowEval (d2Row 137) (fun j => if j = t then 1 else 0) = + (if 137 = (triangleEdges t).1 then 1 else 0) - + (if 137 = (triangleEdges t).2.1 then 1 else 0) + + (if 137 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_138 : ∀ t : Fin 270, + rowEval (d2Row 138) (fun j => if j = t then 1 else 0) = + (if 138 = (triangleEdges t).1 then 1 else 0) - + (if 138 = (triangleEdges t).2.1 then 1 else 0) + + (if 138 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_139 : ∀ t : Fin 270, + rowEval (d2Row 139) (fun j => if j = t then 1 else 0) = + (if 139 = (triangleEdges t).1 then 1 else 0) - + (if 139 = (triangleEdges t).2.1 then 1 else 0) + + (if 139 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_140 : ∀ t : Fin 270, + rowEval (d2Row 140) (fun j => if j = t then 1 else 0) = + (if 140 = (triangleEdges t).1 then 1 else 0) - + (if 140 = (triangleEdges t).2.1 then 1 else 0) + + (if 140 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_141 : ∀ t : Fin 270, + rowEval (d2Row 141) (fun j => if j = t then 1 else 0) = + (if 141 = (triangleEdges t).1 then 1 else 0) - + (if 141 = (triangleEdges t).2.1 then 1 else 0) + + (if 141 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_142 : ∀ t : Fin 270, + rowEval (d2Row 142) (fun j => if j = t then 1 else 0) = + (if 142 = (triangleEdges t).1 then 1 else 0) - + (if 142 = (triangleEdges t).2.1 then 1 else 0) + + (if 142 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_143 : ∀ t : Fin 270, + rowEval (d2Row 143) (fun j => if j = t then 1 else 0) = + (if 143 = (triangleEdges t).1 then 1 else 0) - + (if 143 = (triangleEdges t).2.1 then 1 else 0) + + (if 143 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_144 : ∀ t : Fin 270, + rowEval (d2Row 144) (fun j => if j = t then 1 else 0) = + (if 144 = (triangleEdges t).1 then 1 else 0) - + (if 144 = (triangleEdges t).2.1 then 1 else 0) + + (if 144 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_145 : ∀ t : Fin 270, + rowEval (d2Row 145) (fun j => if j = t then 1 else 0) = + (if 145 = (triangleEdges t).1 then 1 else 0) - + (if 145 = (triangleEdges t).2.1 then 1 else 0) + + (if 145 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_146 : ∀ t : Fin 270, + rowEval (d2Row 146) (fun j => if j = t then 1 else 0) = + (if 146 = (triangleEdges t).1 then 1 else 0) - + (if 146 = (triangleEdges t).2.1 then 1 else 0) + + (if 146 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_147 : ∀ t : Fin 270, + rowEval (d2Row 147) (fun j => if j = t then 1 else 0) = + (if 147 = (triangleEdges t).1 then 1 else 0) - + (if 147 = (triangleEdges t).2.1 then 1 else 0) + + (if 147 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_148 : ∀ t : Fin 270, + rowEval (d2Row 148) (fun j => if j = t then 1 else 0) = + (if 148 = (triangleEdges t).1 then 1 else 0) - + (if 148 = (triangleEdges t).2.1 then 1 else 0) + + (if 148 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_149 : ∀ t : Fin 270, + rowEval (d2Row 149) (fun j => if j = t then 1 else 0) = + (if 149 = (triangleEdges t).1 then 1 else 0) - + (if 149 = (triangleEdges t).2.1 then 1 else 0) + + (if 149 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_150 : ∀ t : Fin 270, + rowEval (d2Row 150) (fun j => if j = t then 1 else 0) = + (if 150 = (triangleEdges t).1 then 1 else 0) - + (if 150 = (triangleEdges t).2.1 then 1 else 0) + + (if 150 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_151 : ∀ t : Fin 270, + rowEval (d2Row 151) (fun j => if j = t then 1 else 0) = + (if 151 = (triangleEdges t).1 then 1 else 0) - + (if 151 = (triangleEdges t).2.1 then 1 else 0) + + (if 151 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_152 : ∀ t : Fin 270, + rowEval (d2Row 152) (fun j => if j = t then 1 else 0) = + (if 152 = (triangleEdges t).1 then 1 else 0) - + (if 152 = (triangleEdges t).2.1 then 1 else 0) + + (if 152 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_153 : ∀ t : Fin 270, + rowEval (d2Row 153) (fun j => if j = t then 1 else 0) = + (if 153 = (triangleEdges t).1 then 1 else 0) - + (if 153 = (triangleEdges t).2.1 then 1 else 0) + + (if 153 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_154 : ∀ t : Fin 270, + rowEval (d2Row 154) (fun j => if j = t then 1 else 0) = + (if 154 = (triangleEdges t).1 then 1 else 0) - + (if 154 = (triangleEdges t).2.1 then 1 else 0) + + (if 154 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_155 : ∀ t : Fin 270, + rowEval (d2Row 155) (fun j => if j = t then 1 else 0) = + (if 155 = (triangleEdges t).1 then 1 else 0) - + (if 155 = (triangleEdges t).2.1 then 1 else 0) + + (if 155 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_156 : ∀ t : Fin 270, + rowEval (d2Row 156) (fun j => if j = t then 1 else 0) = + (if 156 = (triangleEdges t).1 then 1 else 0) - + (if 156 = (triangleEdges t).2.1 then 1 else 0) + + (if 156 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_157 : ∀ t : Fin 270, + rowEval (d2Row 157) (fun j => if j = t then 1 else 0) = + (if 157 = (triangleEdges t).1 then 1 else 0) - + (if 157 = (triangleEdges t).2.1 then 1 else 0) + + (if 157 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_158 : ∀ t : Fin 270, + rowEval (d2Row 158) (fun j => if j = t then 1 else 0) = + (if 158 = (triangleEdges t).1 then 1 else 0) - + (if 158 = (triangleEdges t).2.1 then 1 else 0) + + (if 158 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_159 : ∀ t : Fin 270, + rowEval (d2Row 159) (fun j => if j = t then 1 else 0) = + (if 159 = (triangleEdges t).1 then 1 else 0) - + (if 159 = (triangleEdges t).2.1 then 1 else 0) + + (if 159 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_160 : ∀ t : Fin 270, + rowEval (d2Row 160) (fun j => if j = t then 1 else 0) = + (if 160 = (triangleEdges t).1 then 1 else 0) - + (if 160 = (triangleEdges t).2.1 then 1 else 0) + + (if 160 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_161 : ∀ t : Fin 270, + rowEval (d2Row 161) (fun j => if j = t then 1 else 0) = + (if 161 = (triangleEdges t).1 then 1 else 0) - + (if 161 = (triangleEdges t).2.1 then 1 else 0) + + (if 161 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_162 : ∀ t : Fin 270, + rowEval (d2Row 162) (fun j => if j = t then 1 else 0) = + (if 162 = (triangleEdges t).1 then 1 else 0) - + (if 162 = (triangleEdges t).2.1 then 1 else 0) + + (if 162 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_163 : ∀ t : Fin 270, + rowEval (d2Row 163) (fun j => if j = t then 1 else 0) = + (if 163 = (triangleEdges t).1 then 1 else 0) - + (if 163 = (triangleEdges t).2.1 then 1 else 0) + + (if 163 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_164 : ∀ t : Fin 270, + rowEval (d2Row 164) (fun j => if j = t then 1 else 0) = + (if 164 = (triangleEdges t).1 then 1 else 0) - + (if 164 = (triangleEdges t).2.1 then 1 else 0) + + (if 164 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_165 : ∀ t : Fin 270, + rowEval (d2Row 165) (fun j => if j = t then 1 else 0) = + (if 165 = (triangleEdges t).1 then 1 else 0) - + (if 165 = (triangleEdges t).2.1 then 1 else 0) + + (if 165 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_166 : ∀ t : Fin 270, + rowEval (d2Row 166) (fun j => if j = t then 1 else 0) = + (if 166 = (triangleEdges t).1 then 1 else 0) - + (if 166 = (triangleEdges t).2.1 then 1 else 0) + + (if 166 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_167 : ∀ t : Fin 270, + rowEval (d2Row 167) (fun j => if j = t then 1 else 0) = + (if 167 = (triangleEdges t).1 then 1 else 0) - + (if 167 = (triangleEdges t).2.1 then 1 else 0) + + (if 167 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_168 : ∀ t : Fin 270, + rowEval (d2Row 168) (fun j => if j = t then 1 else 0) = + (if 168 = (triangleEdges t).1 then 1 else 0) - + (if 168 = (triangleEdges t).2.1 then 1 else 0) + + (if 168 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_169 : ∀ t : Fin 270, + rowEval (d2Row 169) (fun j => if j = t then 1 else 0) = + (if 169 = (triangleEdges t).1 then 1 else 0) - + (if 169 = (triangleEdges t).2.1 then 1 else 0) + + (if 169 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_170 : ∀ t : Fin 270, + rowEval (d2Row 170) (fun j => if j = t then 1 else 0) = + (if 170 = (triangleEdges t).1 then 1 else 0) - + (if 170 = (triangleEdges t).2.1 then 1 else 0) + + (if 170 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_171 : ∀ t : Fin 270, + rowEval (d2Row 171) (fun j => if j = t then 1 else 0) = + (if 171 = (triangleEdges t).1 then 1 else 0) - + (if 171 = (triangleEdges t).2.1 then 1 else 0) + + (if 171 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_172 : ∀ t : Fin 270, + rowEval (d2Row 172) (fun j => if j = t then 1 else 0) = + (if 172 = (triangleEdges t).1 then 1 else 0) - + (if 172 = (triangleEdges t).2.1 then 1 else 0) + + (if 172 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_173 : ∀ t : Fin 270, + rowEval (d2Row 173) (fun j => if j = t then 1 else 0) = + (if 173 = (triangleEdges t).1 then 1 else 0) - + (if 173 = (triangleEdges t).2.1 then 1 else 0) + + (if 173 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_174 : ∀ t : Fin 270, + rowEval (d2Row 174) (fun j => if j = t then 1 else 0) = + (if 174 = (triangleEdges t).1 then 1 else 0) - + (if 174 = (triangleEdges t).2.1 then 1 else 0) + + (if 174 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_175 : ∀ t : Fin 270, + rowEval (d2Row 175) (fun j => if j = t then 1 else 0) = + (if 175 = (triangleEdges t).1 then 1 else 0) - + (if 175 = (triangleEdges t).2.1 then 1 else 0) + + (if 175 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_176 : ∀ t : Fin 270, + rowEval (d2Row 176) (fun j => if j = t then 1 else 0) = + (if 176 = (triangleEdges t).1 then 1 else 0) - + (if 176 = (triangleEdges t).2.1 then 1 else 0) + + (if 176 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_177 : ∀ t : Fin 270, + rowEval (d2Row 177) (fun j => if j = t then 1 else 0) = + (if 177 = (triangleEdges t).1 then 1 else 0) - + (if 177 = (triangleEdges t).2.1 then 1 else 0) + + (if 177 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_178 : ∀ t : Fin 270, + rowEval (d2Row 178) (fun j => if j = t then 1 else 0) = + (if 178 = (triangleEdges t).1 then 1 else 0) - + (if 178 = (triangleEdges t).2.1 then 1 else 0) + + (if 178 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_179 : ∀ t : Fin 270, + rowEval (d2Row 179) (fun j => if j = t then 1 else 0) = + (if 179 = (triangleEdges t).1 then 1 else 0) - + (if 179 = (triangleEdges t).2.1 then 1 else 0) + + (if 179 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_180 : ∀ t : Fin 270, + rowEval (d2Row 180) (fun j => if j = t then 1 else 0) = + (if 180 = (triangleEdges t).1 then 1 else 0) - + (if 180 = (triangleEdges t).2.1 then 1 else 0) + + (if 180 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_181 : ∀ t : Fin 270, + rowEval (d2Row 181) (fun j => if j = t then 1 else 0) = + (if 181 = (triangleEdges t).1 then 1 else 0) - + (if 181 = (triangleEdges t).2.1 then 1 else 0) + + (if 181 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_182 : ∀ t : Fin 270, + rowEval (d2Row 182) (fun j => if j = t then 1 else 0) = + (if 182 = (triangleEdges t).1 then 1 else 0) - + (if 182 = (triangleEdges t).2.1 then 1 else 0) + + (if 182 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_183 : ∀ t : Fin 270, + rowEval (d2Row 183) (fun j => if j = t then 1 else 0) = + (if 183 = (triangleEdges t).1 then 1 else 0) - + (if 183 = (triangleEdges t).2.1 then 1 else 0) + + (if 183 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_184 : ∀ t : Fin 270, + rowEval (d2Row 184) (fun j => if j = t then 1 else 0) = + (if 184 = (triangleEdges t).1 then 1 else 0) - + (if 184 = (triangleEdges t).2.1 then 1 else 0) + + (if 184 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_185 : ∀ t : Fin 270, + rowEval (d2Row 185) (fun j => if j = t then 1 else 0) = + (if 185 = (triangleEdges t).1 then 1 else 0) - + (if 185 = (triangleEdges t).2.1 then 1 else 0) + + (if 185 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_186 : ∀ t : Fin 270, + rowEval (d2Row 186) (fun j => if j = t then 1 else 0) = + (if 186 = (triangleEdges t).1 then 1 else 0) - + (if 186 = (triangleEdges t).2.1 then 1 else 0) + + (if 186 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_187 : ∀ t : Fin 270, + rowEval (d2Row 187) (fun j => if j = t then 1 else 0) = + (if 187 = (triangleEdges t).1 then 1 else 0) - + (if 187 = (triangleEdges t).2.1 then 1 else 0) + + (if 187 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_188 : ∀ t : Fin 270, + rowEval (d2Row 188) (fun j => if j = t then 1 else 0) = + (if 188 = (triangleEdges t).1 then 1 else 0) - + (if 188 = (triangleEdges t).2.1 then 1 else 0) + + (if 188 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_189 : ∀ t : Fin 270, + rowEval (d2Row 189) (fun j => if j = t then 1 else 0) = + (if 189 = (triangleEdges t).1 then 1 else 0) - + (if 189 = (triangleEdges t).2.1 then 1 else 0) + + (if 189 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_190 : ∀ t : Fin 270, + rowEval (d2Row 190) (fun j => if j = t then 1 else 0) = + (if 190 = (triangleEdges t).1 then 1 else 0) - + (if 190 = (triangleEdges t).2.1 then 1 else 0) + + (if 190 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_191 : ∀ t : Fin 270, + rowEval (d2Row 191) (fun j => if j = t then 1 else 0) = + (if 191 = (triangleEdges t).1 then 1 else 0) - + (if 191 = (triangleEdges t).2.1 then 1 else 0) + + (if 191 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_192 : ∀ t : Fin 270, + rowEval (d2Row 192) (fun j => if j = t then 1 else 0) = + (if 192 = (triangleEdges t).1 then 1 else 0) - + (if 192 = (triangleEdges t).2.1 then 1 else 0) + + (if 192 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_193 : ∀ t : Fin 270, + rowEval (d2Row 193) (fun j => if j = t then 1 else 0) = + (if 193 = (triangleEdges t).1 then 1 else 0) - + (if 193 = (triangleEdges t).2.1 then 1 else 0) + + (if 193 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_194 : ∀ t : Fin 270, + rowEval (d2Row 194) (fun j => if j = t then 1 else 0) = + (if 194 = (triangleEdges t).1 then 1 else 0) - + (if 194 = (triangleEdges t).2.1 then 1 else 0) + + (if 194 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_195 : ∀ t : Fin 270, + rowEval (d2Row 195) (fun j => if j = t then 1 else 0) = + (if 195 = (triangleEdges t).1 then 1 else 0) - + (if 195 = (triangleEdges t).2.1 then 1 else 0) + + (if 195 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_196 : ∀ t : Fin 270, + rowEval (d2Row 196) (fun j => if j = t then 1 else 0) = + (if 196 = (triangleEdges t).1 then 1 else 0) - + (if 196 = (triangleEdges t).2.1 then 1 else 0) + + (if 196 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_197 : ∀ t : Fin 270, + rowEval (d2Row 197) (fun j => if j = t then 1 else 0) = + (if 197 = (triangleEdges t).1 then 1 else 0) - + (if 197 = (triangleEdges t).2.1 then 1 else 0) + + (if 197 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_198 : ∀ t : Fin 270, + rowEval (d2Row 198) (fun j => if j = t then 1 else 0) = + (if 198 = (triangleEdges t).1 then 1 else 0) - + (if 198 = (triangleEdges t).2.1 then 1 else 0) + + (if 198 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_199 : ∀ t : Fin 270, + rowEval (d2Row 199) (fun j => if j = t then 1 else 0) = + (if 199 = (triangleEdges t).1 then 1 else 0) - + (if 199 = (triangleEdges t).2.1 then 1 else 0) + + (if 199 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_200 : ∀ t : Fin 270, + rowEval (d2Row 200) (fun j => if j = t then 1 else 0) = + (if 200 = (triangleEdges t).1 then 1 else 0) - + (if 200 = (triangleEdges t).2.1 then 1 else 0) + + (if 200 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_201 : ∀ t : Fin 270, + rowEval (d2Row 201) (fun j => if j = t then 1 else 0) = + (if 201 = (triangleEdges t).1 then 1 else 0) - + (if 201 = (triangleEdges t).2.1 then 1 else 0) + + (if 201 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_202 : ∀ t : Fin 270, + rowEval (d2Row 202) (fun j => if j = t then 1 else 0) = + (if 202 = (triangleEdges t).1 then 1 else 0) - + (if 202 = (triangleEdges t).2.1 then 1 else 0) + + (if 202 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_203 : ∀ t : Fin 270, + rowEval (d2Row 203) (fun j => if j = t then 1 else 0) = + (if 203 = (triangleEdges t).1 then 1 else 0) - + (if 203 = (triangleEdges t).2.1 then 1 else 0) + + (if 203 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_204 : ∀ t : Fin 270, + rowEval (d2Row 204) (fun j => if j = t then 1 else 0) = + (if 204 = (triangleEdges t).1 then 1 else 0) - + (if 204 = (triangleEdges t).2.1 then 1 else 0) + + (if 204 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_205 : ∀ t : Fin 270, + rowEval (d2Row 205) (fun j => if j = t then 1 else 0) = + (if 205 = (triangleEdges t).1 then 1 else 0) - + (if 205 = (triangleEdges t).2.1 then 1 else 0) + + (if 205 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_206 : ∀ t : Fin 270, + rowEval (d2Row 206) (fun j => if j = t then 1 else 0) = + (if 206 = (triangleEdges t).1 then 1 else 0) - + (if 206 = (triangleEdges t).2.1 then 1 else 0) + + (if 206 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_207 : ∀ t : Fin 270, + rowEval (d2Row 207) (fun j => if j = t then 1 else 0) = + (if 207 = (triangleEdges t).1 then 1 else 0) - + (if 207 = (triangleEdges t).2.1 then 1 else 0) + + (if 207 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_208 : ∀ t : Fin 270, + rowEval (d2Row 208) (fun j => if j = t then 1 else 0) = + (if 208 = (triangleEdges t).1 then 1 else 0) - + (if 208 = (triangleEdges t).2.1 then 1 else 0) + + (if 208 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_209 : ∀ t : Fin 270, + rowEval (d2Row 209) (fun j => if j = t then 1 else 0) = + (if 209 = (triangleEdges t).1 then 1 else 0) - + (if 209 = (triangleEdges t).2.1 then 1 else 0) + + (if 209 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_210 : ∀ t : Fin 270, + rowEval (d2Row 210) (fun j => if j = t then 1 else 0) = + (if 210 = (triangleEdges t).1 then 1 else 0) - + (if 210 = (triangleEdges t).2.1 then 1 else 0) + + (if 210 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_211 : ∀ t : Fin 270, + rowEval (d2Row 211) (fun j => if j = t then 1 else 0) = + (if 211 = (triangleEdges t).1 then 1 else 0) - + (if 211 = (triangleEdges t).2.1 then 1 else 0) + + (if 211 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_212 : ∀ t : Fin 270, + rowEval (d2Row 212) (fun j => if j = t then 1 else 0) = + (if 212 = (triangleEdges t).1 then 1 else 0) - + (if 212 = (triangleEdges t).2.1 then 1 else 0) + + (if 212 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_213 : ∀ t : Fin 270, + rowEval (d2Row 213) (fun j => if j = t then 1 else 0) = + (if 213 = (triangleEdges t).1 then 1 else 0) - + (if 213 = (triangleEdges t).2.1 then 1 else 0) + + (if 213 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_214 : ∀ t : Fin 270, + rowEval (d2Row 214) (fun j => if j = t then 1 else 0) = + (if 214 = (triangleEdges t).1 then 1 else 0) - + (if 214 = (triangleEdges t).2.1 then 1 else 0) + + (if 214 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_215 : ∀ t : Fin 270, + rowEval (d2Row 215) (fun j => if j = t then 1 else 0) = + (if 215 = (triangleEdges t).1 then 1 else 0) - + (if 215 = (triangleEdges t).2.1 then 1 else 0) + + (if 215 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_216 : ∀ t : Fin 270, + rowEval (d2Row 216) (fun j => if j = t then 1 else 0) = + (if 216 = (triangleEdges t).1 then 1 else 0) - + (if 216 = (triangleEdges t).2.1 then 1 else 0) + + (if 216 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_217 : ∀ t : Fin 270, + rowEval (d2Row 217) (fun j => if j = t then 1 else 0) = + (if 217 = (triangleEdges t).1 then 1 else 0) - + (if 217 = (triangleEdges t).2.1 then 1 else 0) + + (if 217 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_218 : ∀ t : Fin 270, + rowEval (d2Row 218) (fun j => if j = t then 1 else 0) = + (if 218 = (triangleEdges t).1 then 1 else 0) - + (if 218 = (triangleEdges t).2.1 then 1 else 0) + + (if 218 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_219 : ∀ t : Fin 270, + rowEval (d2Row 219) (fun j => if j = t then 1 else 0) = + (if 219 = (triangleEdges t).1 then 1 else 0) - + (if 219 = (triangleEdges t).2.1 then 1 else 0) + + (if 219 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_220 : ∀ t : Fin 270, + rowEval (d2Row 220) (fun j => if j = t then 1 else 0) = + (if 220 = (triangleEdges t).1 then 1 else 0) - + (if 220 = (triangleEdges t).2.1 then 1 else 0) + + (if 220 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_221 : ∀ t : Fin 270, + rowEval (d2Row 221) (fun j => if j = t then 1 else 0) = + (if 221 = (triangleEdges t).1 then 1 else 0) - + (if 221 = (triangleEdges t).2.1 then 1 else 0) + + (if 221 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_222 : ∀ t : Fin 270, + rowEval (d2Row 222) (fun j => if j = t then 1 else 0) = + (if 222 = (triangleEdges t).1 then 1 else 0) - + (if 222 = (triangleEdges t).2.1 then 1 else 0) + + (if 222 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_223 : ∀ t : Fin 270, + rowEval (d2Row 223) (fun j => if j = t then 1 else 0) = + (if 223 = (triangleEdges t).1 then 1 else 0) - + (if 223 = (triangleEdges t).2.1 then 1 else 0) + + (if 223 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_224 : ∀ t : Fin 270, + rowEval (d2Row 224) (fun j => if j = t then 1 else 0) = + (if 224 = (triangleEdges t).1 then 1 else 0) - + (if 224 = (triangleEdges t).2.1 then 1 else 0) + + (if 224 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_225 : ∀ t : Fin 270, + rowEval (d2Row 225) (fun j => if j = t then 1 else 0) = + (if 225 = (triangleEdges t).1 then 1 else 0) - + (if 225 = (triangleEdges t).2.1 then 1 else 0) + + (if 225 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_226 : ∀ t : Fin 270, + rowEval (d2Row 226) (fun j => if j = t then 1 else 0) = + (if 226 = (triangleEdges t).1 then 1 else 0) - + (if 226 = (triangleEdges t).2.1 then 1 else 0) + + (if 226 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_227 : ∀ t : Fin 270, + rowEval (d2Row 227) (fun j => if j = t then 1 else 0) = + (if 227 = (triangleEdges t).1 then 1 else 0) - + (if 227 = (triangleEdges t).2.1 then 1 else 0) + + (if 227 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_228 : ∀ t : Fin 270, + rowEval (d2Row 228) (fun j => if j = t then 1 else 0) = + (if 228 = (triangleEdges t).1 then 1 else 0) - + (if 228 = (triangleEdges t).2.1 then 1 else 0) + + (if 228 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_229 : ∀ t : Fin 270, + rowEval (d2Row 229) (fun j => if j = t then 1 else 0) = + (if 229 = (triangleEdges t).1 then 1 else 0) - + (if 229 = (triangleEdges t).2.1 then 1 else 0) + + (if 229 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_230 : ∀ t : Fin 270, + rowEval (d2Row 230) (fun j => if j = t then 1 else 0) = + (if 230 = (triangleEdges t).1 then 1 else 0) - + (if 230 = (triangleEdges t).2.1 then 1 else 0) + + (if 230 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_231 : ∀ t : Fin 270, + rowEval (d2Row 231) (fun j => if j = t then 1 else 0) = + (if 231 = (triangleEdges t).1 then 1 else 0) - + (if 231 = (triangleEdges t).2.1 then 1 else 0) + + (if 231 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_232 : ∀ t : Fin 270, + rowEval (d2Row 232) (fun j => if j = t then 1 else 0) = + (if 232 = (triangleEdges t).1 then 1 else 0) - + (if 232 = (triangleEdges t).2.1 then 1 else 0) + + (if 232 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_233 : ∀ t : Fin 270, + rowEval (d2Row 233) (fun j => if j = t then 1 else 0) = + (if 233 = (triangleEdges t).1 then 1 else 0) - + (if 233 = (triangleEdges t).2.1 then 1 else 0) + + (if 233 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_234 : ∀ t : Fin 270, + rowEval (d2Row 234) (fun j => if j = t then 1 else 0) = + (if 234 = (triangleEdges t).1 then 1 else 0) - + (if 234 = (triangleEdges t).2.1 then 1 else 0) + + (if 234 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_235 : ∀ t : Fin 270, + rowEval (d2Row 235) (fun j => if j = t then 1 else 0) = + (if 235 = (triangleEdges t).1 then 1 else 0) - + (if 235 = (triangleEdges t).2.1 then 1 else 0) + + (if 235 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_236 : ∀ t : Fin 270, + rowEval (d2Row 236) (fun j => if j = t then 1 else 0) = + (if 236 = (triangleEdges t).1 then 1 else 0) - + (if 236 = (triangleEdges t).2.1 then 1 else 0) + + (if 236 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_237 : ∀ t : Fin 270, + rowEval (d2Row 237) (fun j => if j = t then 1 else 0) = + (if 237 = (triangleEdges t).1 then 1 else 0) - + (if 237 = (triangleEdges t).2.1 then 1 else 0) + + (if 237 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_238 : ∀ t : Fin 270, + rowEval (d2Row 238) (fun j => if j = t then 1 else 0) = + (if 238 = (triangleEdges t).1 then 1 else 0) - + (if 238 = (triangleEdges t).2.1 then 1 else 0) + + (if 238 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_239 : ∀ t : Fin 270, + rowEval (d2Row 239) (fun j => if j = t then 1 else 0) = + (if 239 = (triangleEdges t).1 then 1 else 0) - + (if 239 = (triangleEdges t).2.1 then 1 else 0) + + (if 239 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_240 : ∀ t : Fin 270, + rowEval (d2Row 240) (fun j => if j = t then 1 else 0) = + (if 240 = (triangleEdges t).1 then 1 else 0) - + (if 240 = (triangleEdges t).2.1 then 1 else 0) + + (if 240 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_241 : ∀ t : Fin 270, + rowEval (d2Row 241) (fun j => if j = t then 1 else 0) = + (if 241 = (triangleEdges t).1 then 1 else 0) - + (if 241 = (triangleEdges t).2.1 then 1 else 0) + + (if 241 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_242 : ∀ t : Fin 270, + rowEval (d2Row 242) (fun j => if j = t then 1 else 0) = + (if 242 = (triangleEdges t).1 then 1 else 0) - + (if 242 = (triangleEdges t).2.1 then 1 else 0) + + (if 242 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_243 : ∀ t : Fin 270, + rowEval (d2Row 243) (fun j => if j = t then 1 else 0) = + (if 243 = (triangleEdges t).1 then 1 else 0) - + (if 243 = (triangleEdges t).2.1 then 1 else 0) + + (if 243 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_244 : ∀ t : Fin 270, + rowEval (d2Row 244) (fun j => if j = t then 1 else 0) = + (if 244 = (triangleEdges t).1 then 1 else 0) - + (if 244 = (triangleEdges t).2.1 then 1 else 0) + + (if 244 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_245 : ∀ t : Fin 270, + rowEval (d2Row 245) (fun j => if j = t then 1 else 0) = + (if 245 = (triangleEdges t).1 then 1 else 0) - + (if 245 = (triangleEdges t).2.1 then 1 else 0) + + (if 245 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_246 : ∀ t : Fin 270, + rowEval (d2Row 246) (fun j => if j = t then 1 else 0) = + (if 246 = (triangleEdges t).1 then 1 else 0) - + (if 246 = (triangleEdges t).2.1 then 1 else 0) + + (if 246 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_247 : ∀ t : Fin 270, + rowEval (d2Row 247) (fun j => if j = t then 1 else 0) = + (if 247 = (triangleEdges t).1 then 1 else 0) - + (if 247 = (triangleEdges t).2.1 then 1 else 0) + + (if 247 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_248 : ∀ t : Fin 270, + rowEval (d2Row 248) (fun j => if j = t then 1 else 0) = + (if 248 = (triangleEdges t).1 then 1 else 0) - + (if 248 = (triangleEdges t).2.1 then 1 else 0) + + (if 248 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_249 : ∀ t : Fin 270, + rowEval (d2Row 249) (fun j => if j = t then 1 else 0) = + (if 249 = (triangleEdges t).1 then 1 else 0) - + (if 249 = (triangleEdges t).2.1 then 1 else 0) + + (if 249 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_250 : ∀ t : Fin 270, + rowEval (d2Row 250) (fun j => if j = t then 1 else 0) = + (if 250 = (triangleEdges t).1 then 1 else 0) - + (if 250 = (triangleEdges t).2.1 then 1 else 0) + + (if 250 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_251 : ∀ t : Fin 270, + rowEval (d2Row 251) (fun j => if j = t then 1 else 0) = + (if 251 = (triangleEdges t).1 then 1 else 0) - + (if 251 = (triangleEdges t).2.1 then 1 else 0) + + (if 251 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_252 : ∀ t : Fin 270, + rowEval (d2Row 252) (fun j => if j = t then 1 else 0) = + (if 252 = (triangleEdges t).1 then 1 else 0) - + (if 252 = (triangleEdges t).2.1 then 1 else 0) + + (if 252 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_253 : ∀ t : Fin 270, + rowEval (d2Row 253) (fun j => if j = t then 1 else 0) = + (if 253 = (triangleEdges t).1 then 1 else 0) - + (if 253 = (triangleEdges t).2.1 then 1 else 0) + + (if 253 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_254 : ∀ t : Fin 270, + rowEval (d2Row 254) (fun j => if j = t then 1 else 0) = + (if 254 = (triangleEdges t).1 then 1 else 0) - + (if 254 = (triangleEdges t).2.1 then 1 else 0) + + (if 254 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_255 : ∀ t : Fin 270, + rowEval (d2Row 255) (fun j => if j = t then 1 else 0) = + (if 255 = (triangleEdges t).1 then 1 else 0) - + (if 255 = (triangleEdges t).2.1 then 1 else 0) + + (if 255 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_256 : ∀ t : Fin 270, + rowEval (d2Row 256) (fun j => if j = t then 1 else 0) = + (if 256 = (triangleEdges t).1 then 1 else 0) - + (if 256 = (triangleEdges t).2.1 then 1 else 0) + + (if 256 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_257 : ∀ t : Fin 270, + rowEval (d2Row 257) (fun j => if j = t then 1 else 0) = + (if 257 = (triangleEdges t).1 then 1 else 0) - + (if 257 = (triangleEdges t).2.1 then 1 else 0) + + (if 257 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_258 : ∀ t : Fin 270, + rowEval (d2Row 258) (fun j => if j = t then 1 else 0) = + (if 258 = (triangleEdges t).1 then 1 else 0) - + (if 258 = (triangleEdges t).2.1 then 1 else 0) + + (if 258 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_259 : ∀ t : Fin 270, + rowEval (d2Row 259) (fun j => if j = t then 1 else 0) = + (if 259 = (triangleEdges t).1 then 1 else 0) - + (if 259 = (triangleEdges t).2.1 then 1 else 0) + + (if 259 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_260 : ∀ t : Fin 270, + rowEval (d2Row 260) (fun j => if j = t then 1 else 0) = + (if 260 = (triangleEdges t).1 then 1 else 0) - + (if 260 = (triangleEdges t).2.1 then 1 else 0) + + (if 260 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_261 : ∀ t : Fin 270, + rowEval (d2Row 261) (fun j => if j = t then 1 else 0) = + (if 261 = (triangleEdges t).1 then 1 else 0) - + (if 261 = (triangleEdges t).2.1 then 1 else 0) + + (if 261 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_262 : ∀ t : Fin 270, + rowEval (d2Row 262) (fun j => if j = t then 1 else 0) = + (if 262 = (triangleEdges t).1 then 1 else 0) - + (if 262 = (triangleEdges t).2.1 then 1 else 0) + + (if 262 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_263 : ∀ t : Fin 270, + rowEval (d2Row 263) (fun j => if j = t then 1 else 0) = + (if 263 = (triangleEdges t).1 then 1 else 0) - + (if 263 = (triangleEdges t).2.1 then 1 else 0) + + (if 263 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_264 : ∀ t : Fin 270, + rowEval (d2Row 264) (fun j => if j = t then 1 else 0) = + (if 264 = (triangleEdges t).1 then 1 else 0) - + (if 264 = (triangleEdges t).2.1 then 1 else 0) + + (if 264 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_265 : ∀ t : Fin 270, + rowEval (d2Row 265) (fun j => if j = t then 1 else 0) = + (if 265 = (triangleEdges t).1 then 1 else 0) - + (if 265 = (triangleEdges t).2.1 then 1 else 0) + + (if 265 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_266 : ∀ t : Fin 270, + rowEval (d2Row 266) (fun j => if j = t then 1 else 0) = + (if 266 = (triangleEdges t).1 then 1 else 0) - + (if 266 = (triangleEdges t).2.1 then 1 else 0) + + (if 266 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_267 : ∀ t : Fin 270, + rowEval (d2Row 267) (fun j => if j = t then 1 else 0) = + (if 267 = (triangleEdges t).1 then 1 else 0) - + (if 267 = (triangleEdges t).2.1 then 1 else 0) + + (if 267 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_268 : ∀ t : Fin 270, + rowEval (d2Row 268) (fun j => if j = t then 1 else 0) = + (if 268 = (triangleEdges t).1 then 1 else 0) - + (if 268 = (triangleEdges t).2.1 then 1 else 0) + + (if 268 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_269 : ∀ t : Fin 270, + rowEval (d2Row 269) (fun j => if j = t then 1 else 0) = + (if 269 = (triangleEdges t).1 then 1 else 0) - + (if 269 = (triangleEdges t).2.1 then 1 else 0) + + (if 269 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_270 : ∀ t : Fin 270, + rowEval (d2Row 270) (fun j => if j = t then 1 else 0) = + (if 270 = (triangleEdges t).1 then 1 else 0) - + (if 270 = (triangleEdges t).2.1 then 1 else 0) + + (if 270 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_271 : ∀ t : Fin 270, + rowEval (d2Row 271) (fun j => if j = t then 1 else 0) = + (if 271 = (triangleEdges t).1 then 1 else 0) - + (if 271 = (triangleEdges t).2.1 then 1 else 0) + + (if 271 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_272 : ∀ t : Fin 270, + rowEval (d2Row 272) (fun j => if j = t then 1 else 0) = + (if 272 = (triangleEdges t).1 then 1 else 0) - + (if 272 = (triangleEdges t).2.1 then 1 else 0) + + (if 272 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_273 : ∀ t : Fin 270, + rowEval (d2Row 273) (fun j => if j = t then 1 else 0) = + (if 273 = (triangleEdges t).1 then 1 else 0) - + (if 273 = (triangleEdges t).2.1 then 1 else 0) + + (if 273 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_274 : ∀ t : Fin 270, + rowEval (d2Row 274) (fun j => if j = t then 1 else 0) = + (if 274 = (triangleEdges t).1 then 1 else 0) - + (if 274 = (triangleEdges t).2.1 then 1 else 0) + + (if 274 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_275 : ∀ t : Fin 270, + rowEval (d2Row 275) (fun j => if j = t then 1 else 0) = + (if 275 = (triangleEdges t).1 then 1 else 0) - + (if 275 = (triangleEdges t).2.1 then 1 else 0) + + (if 275 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_276 : ∀ t : Fin 270, + rowEval (d2Row 276) (fun j => if j = t then 1 else 0) = + (if 276 = (triangleEdges t).1 then 1 else 0) - + (if 276 = (triangleEdges t).2.1 then 1 else 0) + + (if 276 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_277 : ∀ t : Fin 270, + rowEval (d2Row 277) (fun j => if j = t then 1 else 0) = + (if 277 = (triangleEdges t).1 then 1 else 0) - + (if 277 = (triangleEdges t).2.1 then 1 else 0) + + (if 277 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_278 : ∀ t : Fin 270, + rowEval (d2Row 278) (fun j => if j = t then 1 else 0) = + (if 278 = (triangleEdges t).1 then 1 else 0) - + (if 278 = (triangleEdges t).2.1 then 1 else 0) + + (if 278 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_279 : ∀ t : Fin 270, + rowEval (d2Row 279) (fun j => if j = t then 1 else 0) = + (if 279 = (triangleEdges t).1 then 1 else 0) - + (if 279 = (triangleEdges t).2.1 then 1 else 0) + + (if 279 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_280 : ∀ t : Fin 270, + rowEval (d2Row 280) (fun j => if j = t then 1 else 0) = + (if 280 = (triangleEdges t).1 then 1 else 0) - + (if 280 = (triangleEdges t).2.1 then 1 else 0) + + (if 280 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_281 : ∀ t : Fin 270, + rowEval (d2Row 281) (fun j => if j = t then 1 else 0) = + (if 281 = (triangleEdges t).1 then 1 else 0) - + (if 281 = (triangleEdges t).2.1 then 1 else 0) + + (if 281 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_282 : ∀ t : Fin 270, + rowEval (d2Row 282) (fun j => if j = t then 1 else 0) = + (if 282 = (triangleEdges t).1 then 1 else 0) - + (if 282 = (triangleEdges t).2.1 then 1 else 0) + + (if 282 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_283 : ∀ t : Fin 270, + rowEval (d2Row 283) (fun j => if j = t then 1 else 0) = + (if 283 = (triangleEdges t).1 then 1 else 0) - + (if 283 = (triangleEdges t).2.1 then 1 else 0) + + (if 283 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_284 : ∀ t : Fin 270, + rowEval (d2Row 284) (fun j => if j = t then 1 else 0) = + (if 284 = (triangleEdges t).1 then 1 else 0) - + (if 284 = (triangleEdges t).2.1 then 1 else 0) + + (if 284 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_285 : ∀ t : Fin 270, + rowEval (d2Row 285) (fun j => if j = t then 1 else 0) = + (if 285 = (triangleEdges t).1 then 1 else 0) - + (if 285 = (triangleEdges t).2.1 then 1 else 0) + + (if 285 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_286 : ∀ t : Fin 270, + rowEval (d2Row 286) (fun j => if j = t then 1 else 0) = + (if 286 = (triangleEdges t).1 then 1 else 0) - + (if 286 = (triangleEdges t).2.1 then 1 else 0) + + (if 286 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_287 : ∀ t : Fin 270, + rowEval (d2Row 287) (fun j => if j = t then 1 else 0) = + (if 287 = (triangleEdges t).1 then 1 else 0) - + (if 287 = (triangleEdges t).2.1 then 1 else 0) + + (if 287 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_288 : ∀ t : Fin 270, + rowEval (d2Row 288) (fun j => if j = t then 1 else 0) = + (if 288 = (triangleEdges t).1 then 1 else 0) - + (if 288 = (triangleEdges t).2.1 then 1 else 0) + + (if 288 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_289 : ∀ t : Fin 270, + rowEval (d2Row 289) (fun j => if j = t then 1 else 0) = + (if 289 = (triangleEdges t).1 then 1 else 0) - + (if 289 = (triangleEdges t).2.1 then 1 else 0) + + (if 289 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_290 : ∀ t : Fin 270, + rowEval (d2Row 290) (fun j => if j = t then 1 else 0) = + (if 290 = (triangleEdges t).1 then 1 else 0) - + (if 290 = (triangleEdges t).2.1 then 1 else 0) + + (if 290 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_291 : ∀ t : Fin 270, + rowEval (d2Row 291) (fun j => if j = t then 1 else 0) = + (if 291 = (triangleEdges t).1 then 1 else 0) - + (if 291 = (triangleEdges t).2.1 then 1 else 0) + + (if 291 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_292 : ∀ t : Fin 270, + rowEval (d2Row 292) (fun j => if j = t then 1 else 0) = + (if 292 = (triangleEdges t).1 then 1 else 0) - + (if 292 = (triangleEdges t).2.1 then 1 else 0) + + (if 292 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_293 : ∀ t : Fin 270, + rowEval (d2Row 293) (fun j => if j = t then 1 else 0) = + (if 293 = (triangleEdges t).1 then 1 else 0) - + (if 293 = (triangleEdges t).2.1 then 1 else 0) + + (if 293 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_294 : ∀ t : Fin 270, + rowEval (d2Row 294) (fun j => if j = t then 1 else 0) = + (if 294 = (triangleEdges t).1 then 1 else 0) - + (if 294 = (triangleEdges t).2.1 then 1 else 0) + + (if 294 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_295 : ∀ t : Fin 270, + rowEval (d2Row 295) (fun j => if j = t then 1 else 0) = + (if 295 = (triangleEdges t).1 then 1 else 0) - + (if 295 = (triangleEdges t).2.1 then 1 else 0) + + (if 295 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_296 : ∀ t : Fin 270, + rowEval (d2Row 296) (fun j => if j = t then 1 else 0) = + (if 296 = (triangleEdges t).1 then 1 else 0) - + (if 296 = (triangleEdges t).2.1 then 1 else 0) + + (if 296 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_297 : ∀ t : Fin 270, + rowEval (d2Row 297) (fun j => if j = t then 1 else 0) = + (if 297 = (triangleEdges t).1 then 1 else 0) - + (if 297 = (triangleEdges t).2.1 then 1 else 0) + + (if 297 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_298 : ∀ t : Fin 270, + rowEval (d2Row 298) (fun j => if j = t then 1 else 0) = + (if 298 = (triangleEdges t).1 then 1 else 0) - + (if 298 = (triangleEdges t).2.1 then 1 else 0) + + (if 298 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_299 : ∀ t : Fin 270, + rowEval (d2Row 299) (fun j => if j = t then 1 else 0) = + (if 299 = (triangleEdges t).1 then 1 else 0) - + (if 299 = (triangleEdges t).2.1 then 1 else 0) + + (if 299 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_300 : ∀ t : Fin 270, + rowEval (d2Row 300) (fun j => if j = t then 1 else 0) = + (if 300 = (triangleEdges t).1 then 1 else 0) - + (if 300 = (triangleEdges t).2.1 then 1 else 0) + + (if 300 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_301 : ∀ t : Fin 270, + rowEval (d2Row 301) (fun j => if j = t then 1 else 0) = + (if 301 = (triangleEdges t).1 then 1 else 0) - + (if 301 = (triangleEdges t).2.1 then 1 else 0) + + (if 301 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_302 : ∀ t : Fin 270, + rowEval (d2Row 302) (fun j => if j = t then 1 else 0) = + (if 302 = (triangleEdges t).1 then 1 else 0) - + (if 302 = (triangleEdges t).2.1 then 1 else 0) + + (if 302 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_303 : ∀ t : Fin 270, + rowEval (d2Row 303) (fun j => if j = t then 1 else 0) = + (if 303 = (triangleEdges t).1 then 1 else 0) - + (if 303 = (triangleEdges t).2.1 then 1 else 0) + + (if 303 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_304 : ∀ t : Fin 270, + rowEval (d2Row 304) (fun j => if j = t then 1 else 0) = + (if 304 = (triangleEdges t).1 then 1 else 0) - + (if 304 = (triangleEdges t).2.1 then 1 else 0) + + (if 304 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_305 : ∀ t : Fin 270, + rowEval (d2Row 305) (fun j => if j = t then 1 else 0) = + (if 305 = (triangleEdges t).1 then 1 else 0) - + (if 305 = (triangleEdges t).2.1 then 1 else 0) + + (if 305 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_306 : ∀ t : Fin 270, + rowEval (d2Row 306) (fun j => if j = t then 1 else 0) = + (if 306 = (triangleEdges t).1 then 1 else 0) - + (if 306 = (triangleEdges t).2.1 then 1 else 0) + + (if 306 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_307 : ∀ t : Fin 270, + rowEval (d2Row 307) (fun j => if j = t then 1 else 0) = + (if 307 = (triangleEdges t).1 then 1 else 0) - + (if 307 = (triangleEdges t).2.1 then 1 else 0) + + (if 307 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_308 : ∀ t : Fin 270, + rowEval (d2Row 308) (fun j => if j = t then 1 else 0) = + (if 308 = (triangleEdges t).1 then 1 else 0) - + (if 308 = (triangleEdges t).2.1 then 1 else 0) + + (if 308 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_309 : ∀ t : Fin 270, + rowEval (d2Row 309) (fun j => if j = t then 1 else 0) = + (if 309 = (triangleEdges t).1 then 1 else 0) - + (if 309 = (triangleEdges t).2.1 then 1 else 0) + + (if 309 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_310 : ∀ t : Fin 270, + rowEval (d2Row 310) (fun j => if j = t then 1 else 0) = + (if 310 = (triangleEdges t).1 then 1 else 0) - + (if 310 = (triangleEdges t).2.1 then 1 else 0) + + (if 310 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_311 : ∀ t : Fin 270, + rowEval (d2Row 311) (fun j => if j = t then 1 else 0) = + (if 311 = (triangleEdges t).1 then 1 else 0) - + (if 311 = (triangleEdges t).2.1 then 1 else 0) + + (if 311 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_312 : ∀ t : Fin 270, + rowEval (d2Row 312) (fun j => if j = t then 1 else 0) = + (if 312 = (triangleEdges t).1 then 1 else 0) - + (if 312 = (triangleEdges t).2.1 then 1 else 0) + + (if 312 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_313 : ∀ t : Fin 270, + rowEval (d2Row 313) (fun j => if j = t then 1 else 0) = + (if 313 = (triangleEdges t).1 then 1 else 0) - + (if 313 = (triangleEdges t).2.1 then 1 else 0) + + (if 313 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_314 : ∀ t : Fin 270, + rowEval (d2Row 314) (fun j => if j = t then 1 else 0) = + (if 314 = (triangleEdges t).1 then 1 else 0) - + (if 314 = (triangleEdges t).2.1 then 1 else 0) + + (if 314 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_315 : ∀ t : Fin 270, + rowEval (d2Row 315) (fun j => if j = t then 1 else 0) = + (if 315 = (triangleEdges t).1 then 1 else 0) - + (if 315 = (triangleEdges t).2.1 then 1 else 0) + + (if 315 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_316 : ∀ t : Fin 270, + rowEval (d2Row 316) (fun j => if j = t then 1 else 0) = + (if 316 = (triangleEdges t).1 then 1 else 0) - + (if 316 = (triangleEdges t).2.1 then 1 else 0) + + (if 316 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_317 : ∀ t : Fin 270, + rowEval (d2Row 317) (fun j => if j = t then 1 else 0) = + (if 317 = (triangleEdges t).1 then 1 else 0) - + (if 317 = (triangleEdges t).2.1 then 1 else 0) + + (if 317 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_318 : ∀ t : Fin 270, + rowEval (d2Row 318) (fun j => if j = t then 1 else 0) = + (if 318 = (triangleEdges t).1 then 1 else 0) - + (if 318 = (triangleEdges t).2.1 then 1 else 0) + + (if 318 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_319 : ∀ t : Fin 270, + rowEval (d2Row 319) (fun j => if j = t then 1 else 0) = + (if 319 = (triangleEdges t).1 then 1 else 0) - + (if 319 = (triangleEdges t).2.1 then 1 else 0) + + (if 319 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_320 : ∀ t : Fin 270, + rowEval (d2Row 320) (fun j => if j = t then 1 else 0) = + (if 320 = (triangleEdges t).1 then 1 else 0) - + (if 320 = (triangleEdges t).2.1 then 1 else 0) + + (if 320 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_321 : ∀ t : Fin 270, + rowEval (d2Row 321) (fun j => if j = t then 1 else 0) = + (if 321 = (triangleEdges t).1 then 1 else 0) - + (if 321 = (triangleEdges t).2.1 then 1 else 0) + + (if 321 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_322 : ∀ t : Fin 270, + rowEval (d2Row 322) (fun j => if j = t then 1 else 0) = + (if 322 = (triangleEdges t).1 then 1 else 0) - + (if 322 = (triangleEdges t).2.1 then 1 else 0) + + (if 322 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_323 : ∀ t : Fin 270, + rowEval (d2Row 323) (fun j => if j = t then 1 else 0) = + (if 323 = (triangleEdges t).1 then 1 else 0) - + (if 323 = (triangleEdges t).2.1 then 1 else 0) + + (if 323 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_324 : ∀ t : Fin 270, + rowEval (d2Row 324) (fun j => if j = t then 1 else 0) = + (if 324 = (triangleEdges t).1 then 1 else 0) - + (if 324 = (triangleEdges t).2.1 then 1 else 0) + + (if 324 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_325 : ∀ t : Fin 270, + rowEval (d2Row 325) (fun j => if j = t then 1 else 0) = + (if 325 = (triangleEdges t).1 then 1 else 0) - + (if 325 = (triangleEdges t).2.1 then 1 else 0) + + (if 325 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_326 : ∀ t : Fin 270, + rowEval (d2Row 326) (fun j => if j = t then 1 else 0) = + (if 326 = (triangleEdges t).1 then 1 else 0) - + (if 326 = (triangleEdges t).2.1 then 1 else 0) + + (if 326 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_327 : ∀ t : Fin 270, + rowEval (d2Row 327) (fun j => if j = t then 1 else 0) = + (if 327 = (triangleEdges t).1 then 1 else 0) - + (if 327 = (triangleEdges t).2.1 then 1 else 0) + + (if 327 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_328 : ∀ t : Fin 270, + rowEval (d2Row 328) (fun j => if j = t then 1 else 0) = + (if 328 = (triangleEdges t).1 then 1 else 0) - + (if 328 = (triangleEdges t).2.1 then 1 else 0) + + (if 328 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_329 : ∀ t : Fin 270, + rowEval (d2Row 329) (fun j => if j = t then 1 else 0) = + (if 329 = (triangleEdges t).1 then 1 else 0) - + (if 329 = (triangleEdges t).2.1 then 1 else 0) + + (if 329 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_330 : ∀ t : Fin 270, + rowEval (d2Row 330) (fun j => if j = t then 1 else 0) = + (if 330 = (triangleEdges t).1 then 1 else 0) - + (if 330 = (triangleEdges t).2.1 then 1 else 0) + + (if 330 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_331 : ∀ t : Fin 270, + rowEval (d2Row 331) (fun j => if j = t then 1 else 0) = + (if 331 = (triangleEdges t).1 then 1 else 0) - + (if 331 = (triangleEdges t).2.1 then 1 else 0) + + (if 331 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_332 : ∀ t : Fin 270, + rowEval (d2Row 332) (fun j => if j = t then 1 else 0) = + (if 332 = (triangleEdges t).1 then 1 else 0) - + (if 332 = (triangleEdges t).2.1 then 1 else 0) + + (if 332 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_333 : ∀ t : Fin 270, + rowEval (d2Row 333) (fun j => if j = t then 1 else 0) = + (if 333 = (triangleEdges t).1 then 1 else 0) - + (if 333 = (triangleEdges t).2.1 then 1 else 0) + + (if 333 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_334 : ∀ t : Fin 270, + rowEval (d2Row 334) (fun j => if j = t then 1 else 0) = + (if 334 = (triangleEdges t).1 then 1 else 0) - + (if 334 = (triangleEdges t).2.1 then 1 else 0) + + (if 334 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_335 : ∀ t : Fin 270, + rowEval (d2Row 335) (fun j => if j = t then 1 else 0) = + (if 335 = (triangleEdges t).1 then 1 else 0) - + (if 335 = (triangleEdges t).2.1 then 1 else 0) + + (if 335 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_336 : ∀ t : Fin 270, + rowEval (d2Row 336) (fun j => if j = t then 1 else 0) = + (if 336 = (triangleEdges t).1 then 1 else 0) - + (if 336 = (triangleEdges t).2.1 then 1 else 0) + + (if 336 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_337 : ∀ t : Fin 270, + rowEval (d2Row 337) (fun j => if j = t then 1 else 0) = + (if 337 = (triangleEdges t).1 then 1 else 0) - + (if 337 = (triangleEdges t).2.1 then 1 else 0) + + (if 337 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_338 : ∀ t : Fin 270, + rowEval (d2Row 338) (fun j => if j = t then 1 else 0) = + (if 338 = (triangleEdges t).1 then 1 else 0) - + (if 338 = (triangleEdges t).2.1 then 1 else 0) + + (if 338 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_339 : ∀ t : Fin 270, + rowEval (d2Row 339) (fun j => if j = t then 1 else 0) = + (if 339 = (triangleEdges t).1 then 1 else 0) - + (if 339 = (triangleEdges t).2.1 then 1 else 0) + + (if 339 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_340 : ∀ t : Fin 270, + rowEval (d2Row 340) (fun j => if j = t then 1 else 0) = + (if 340 = (triangleEdges t).1 then 1 else 0) - + (if 340 = (triangleEdges t).2.1 then 1 else 0) + + (if 340 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_341 : ∀ t : Fin 270, + rowEval (d2Row 341) (fun j => if j = t then 1 else 0) = + (if 341 = (triangleEdges t).1 then 1 else 0) - + (if 341 = (triangleEdges t).2.1 then 1 else 0) + + (if 341 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_342 : ∀ t : Fin 270, + rowEval (d2Row 342) (fun j => if j = t then 1 else 0) = + (if 342 = (triangleEdges t).1 then 1 else 0) - + (if 342 = (triangleEdges t).2.1 then 1 else 0) + + (if 342 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_343 : ∀ t : Fin 270, + rowEval (d2Row 343) (fun j => if j = t then 1 else 0) = + (if 343 = (triangleEdges t).1 then 1 else 0) - + (if 343 = (triangleEdges t).2.1 then 1 else 0) + + (if 343 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_344 : ∀ t : Fin 270, + rowEval (d2Row 344) (fun j => if j = t then 1 else 0) = + (if 344 = (triangleEdges t).1 then 1 else 0) - + (if 344 = (triangleEdges t).2.1 then 1 else 0) + + (if 344 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_345 : ∀ t : Fin 270, + rowEval (d2Row 345) (fun j => if j = t then 1 else 0) = + (if 345 = (triangleEdges t).1 then 1 else 0) - + (if 345 = (triangleEdges t).2.1 then 1 else 0) + + (if 345 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_346 : ∀ t : Fin 270, + rowEval (d2Row 346) (fun j => if j = t then 1 else 0) = + (if 346 = (triangleEdges t).1 then 1 else 0) - + (if 346 = (triangleEdges t).2.1 then 1 else 0) + + (if 346 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_347 : ∀ t : Fin 270, + rowEval (d2Row 347) (fun j => if j = t then 1 else 0) = + (if 347 = (triangleEdges t).1 then 1 else 0) - + (if 347 = (triangleEdges t).2.1 then 1 else 0) + + (if 347 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_348 : ∀ t : Fin 270, + rowEval (d2Row 348) (fun j => if j = t then 1 else 0) = + (if 348 = (triangleEdges t).1 then 1 else 0) - + (if 348 = (triangleEdges t).2.1 then 1 else 0) + + (if 348 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_349 : ∀ t : Fin 270, + rowEval (d2Row 349) (fun j => if j = t then 1 else 0) = + (if 349 = (triangleEdges t).1 then 1 else 0) - + (if 349 = (triangleEdges t).2.1 then 1 else 0) + + (if 349 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_350 : ∀ t : Fin 270, + rowEval (d2Row 350) (fun j => if j = t then 1 else 0) = + (if 350 = (triangleEdges t).1 then 1 else 0) - + (if 350 = (triangleEdges t).2.1 then 1 else 0) + + (if 350 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_351 : ∀ t : Fin 270, + rowEval (d2Row 351) (fun j => if j = t then 1 else 0) = + (if 351 = (triangleEdges t).1 then 1 else 0) - + (if 351 = (triangleEdges t).2.1 then 1 else 0) + + (if 351 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_352 : ∀ t : Fin 270, + rowEval (d2Row 352) (fun j => if j = t then 1 else 0) = + (if 352 = (triangleEdges t).1 then 1 else 0) - + (if 352 = (triangleEdges t).2.1 then 1 else 0) + + (if 352 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_353 : ∀ t : Fin 270, + rowEval (d2Row 353) (fun j => if j = t then 1 else 0) = + (if 353 = (triangleEdges t).1 then 1 else 0) - + (if 353 = (triangleEdges t).2.1 then 1 else 0) + + (if 353 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_354 : ∀ t : Fin 270, + rowEval (d2Row 354) (fun j => if j = t then 1 else 0) = + (if 354 = (triangleEdges t).1 then 1 else 0) - + (if 354 = (triangleEdges t).2.1 then 1 else 0) + + (if 354 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_355 : ∀ t : Fin 270, + rowEval (d2Row 355) (fun j => if j = t then 1 else 0) = + (if 355 = (triangleEdges t).1 then 1 else 0) - + (if 355 = (triangleEdges t).2.1 then 1 else 0) + + (if 355 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_356 : ∀ t : Fin 270, + rowEval (d2Row 356) (fun j => if j = t then 1 else 0) = + (if 356 = (triangleEdges t).1 then 1 else 0) - + (if 356 = (triangleEdges t).2.1 then 1 else 0) + + (if 356 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_357 : ∀ t : Fin 270, + rowEval (d2Row 357) (fun j => if j = t then 1 else 0) = + (if 357 = (triangleEdges t).1 then 1 else 0) - + (if 357 = (triangleEdges t).2.1 then 1 else 0) + + (if 357 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_358 : ∀ t : Fin 270, + rowEval (d2Row 358) (fun j => if j = t then 1 else 0) = + (if 358 = (triangleEdges t).1 then 1 else 0) - + (if 358 = (triangleEdges t).2.1 then 1 else 0) + + (if 358 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_359 : ∀ t : Fin 270, + rowEval (d2Row 359) (fun j => if j = t then 1 else 0) = + (if 359 = (triangleEdges t).1 then 1 else 0) - + (if 359 = (triangleEdges t).2.1 then 1 else 0) + + (if 359 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_360 : ∀ t : Fin 270, + rowEval (d2Row 360) (fun j => if j = t then 1 else 0) = + (if 360 = (triangleEdges t).1 then 1 else 0) - + (if 360 = (triangleEdges t).2.1 then 1 else 0) + + (if 360 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_361 : ∀ t : Fin 270, + rowEval (d2Row 361) (fun j => if j = t then 1 else 0) = + (if 361 = (triangleEdges t).1 then 1 else 0) - + (if 361 = (triangleEdges t).2.1 then 1 else 0) + + (if 361 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_362 : ∀ t : Fin 270, + rowEval (d2Row 362) (fun j => if j = t then 1 else 0) = + (if 362 = (triangleEdges t).1 then 1 else 0) - + (if 362 = (triangleEdges t).2.1 then 1 else 0) + + (if 362 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_363 : ∀ t : Fin 270, + rowEval (d2Row 363) (fun j => if j = t then 1 else 0) = + (if 363 = (triangleEdges t).1 then 1 else 0) - + (if 363 = (triangleEdges t).2.1 then 1 else 0) + + (if 363 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_364 : ∀ t : Fin 270, + rowEval (d2Row 364) (fun j => if j = t then 1 else 0) = + (if 364 = (triangleEdges t).1 then 1 else 0) - + (if 364 = (triangleEdges t).2.1 then 1 else 0) + + (if 364 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_365 : ∀ t : Fin 270, + rowEval (d2Row 365) (fun j => if j = t then 1 else 0) = + (if 365 = (triangleEdges t).1 then 1 else 0) - + (if 365 = (triangleEdges t).2.1 then 1 else 0) + + (if 365 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_366 : ∀ t : Fin 270, + rowEval (d2Row 366) (fun j => if j = t then 1 else 0) = + (if 366 = (triangleEdges t).1 then 1 else 0) - + (if 366 = (triangleEdges t).2.1 then 1 else 0) + + (if 366 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_367 : ∀ t : Fin 270, + rowEval (d2Row 367) (fun j => if j = t then 1 else 0) = + (if 367 = (triangleEdges t).1 then 1 else 0) - + (if 367 = (triangleEdges t).2.1 then 1 else 0) + + (if 367 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_368 : ∀ t : Fin 270, + rowEval (d2Row 368) (fun j => if j = t then 1 else 0) = + (if 368 = (triangleEdges t).1 then 1 else 0) - + (if 368 = (triangleEdges t).2.1 then 1 else 0) + + (if 368 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_369 : ∀ t : Fin 270, + rowEval (d2Row 369) (fun j => if j = t then 1 else 0) = + (if 369 = (triangleEdges t).1 then 1 else 0) - + (if 369 = (triangleEdges t).2.1 then 1 else 0) + + (if 369 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_370 : ∀ t : Fin 270, + rowEval (d2Row 370) (fun j => if j = t then 1 else 0) = + (if 370 = (triangleEdges t).1 then 1 else 0) - + (if 370 = (triangleEdges t).2.1 then 1 else 0) + + (if 370 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d2_basis_cert_371 : ∀ t : Fin 270, + rowEval (d2Row 371) (fun j => if j = t then 1 else 0) = + (if 371 = (triangleEdges t).1 then 1 else 0) - + (if 371 = (triangleEdges t).2.1 then 1 else 0) + + (if 371 = (triangleEdges t).2.2 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_0 : ∀ v : Fin 103, + rowEval (d1Row 0) (h0Coeff v) = + (if 0 = v then 1 else 0) - (if 0 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_1 : ∀ v : Fin 103, + rowEval (d1Row 1) (h0Coeff v) = + (if 1 = v then 1 else 0) - (if 1 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_2 : ∀ v : Fin 103, + rowEval (d1Row 2) (h0Coeff v) = + (if 2 = v then 1 else 0) - (if 2 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_3 : ∀ v : Fin 103, + rowEval (d1Row 3) (h0Coeff v) = + (if 3 = v then 1 else 0) - (if 3 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_4 : ∀ v : Fin 103, + rowEval (d1Row 4) (h0Coeff v) = + (if 4 = v then 1 else 0) - (if 4 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_5 : ∀ v : Fin 103, + rowEval (d1Row 5) (h0Coeff v) = + (if 5 = v then 1 else 0) - (if 5 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_6 : ∀ v : Fin 103, + rowEval (d1Row 6) (h0Coeff v) = + (if 6 = v then 1 else 0) - (if 6 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_7 : ∀ v : Fin 103, + rowEval (d1Row 7) (h0Coeff v) = + (if 7 = v then 1 else 0) - (if 7 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_8 : ∀ v : Fin 103, + rowEval (d1Row 8) (h0Coeff v) = + (if 8 = v then 1 else 0) - (if 8 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_9 : ∀ v : Fin 103, + rowEval (d1Row 9) (h0Coeff v) = + (if 9 = v then 1 else 0) - (if 9 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_10 : ∀ v : Fin 103, + rowEval (d1Row 10) (h0Coeff v) = + (if 10 = v then 1 else 0) - (if 10 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_11 : ∀ v : Fin 103, + rowEval (d1Row 11) (h0Coeff v) = + (if 11 = v then 1 else 0) - (if 11 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_12 : ∀ v : Fin 103, + rowEval (d1Row 12) (h0Coeff v) = + (if 12 = v then 1 else 0) - (if 12 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_13 : ∀ v : Fin 103, + rowEval (d1Row 13) (h0Coeff v) = + (if 13 = v then 1 else 0) - (if 13 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_14 : ∀ v : Fin 103, + rowEval (d1Row 14) (h0Coeff v) = + (if 14 = v then 1 else 0) - (if 14 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_15 : ∀ v : Fin 103, + rowEval (d1Row 15) (h0Coeff v) = + (if 15 = v then 1 else 0) - (if 15 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_16 : ∀ v : Fin 103, + rowEval (d1Row 16) (h0Coeff v) = + (if 16 = v then 1 else 0) - (if 16 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_17 : ∀ v : Fin 103, + rowEval (d1Row 17) (h0Coeff v) = + (if 17 = v then 1 else 0) - (if 17 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_18 : ∀ v : Fin 103, + rowEval (d1Row 18) (h0Coeff v) = + (if 18 = v then 1 else 0) - (if 18 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_19 : ∀ v : Fin 103, + rowEval (d1Row 19) (h0Coeff v) = + (if 19 = v then 1 else 0) - (if 19 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_20 : ∀ v : Fin 103, + rowEval (d1Row 20) (h0Coeff v) = + (if 20 = v then 1 else 0) - (if 20 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_21 : ∀ v : Fin 103, + rowEval (d1Row 21) (h0Coeff v) = + (if 21 = v then 1 else 0) - (if 21 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_22 : ∀ v : Fin 103, + rowEval (d1Row 22) (h0Coeff v) = + (if 22 = v then 1 else 0) - (if 22 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_23 : ∀ v : Fin 103, + rowEval (d1Row 23) (h0Coeff v) = + (if 23 = v then 1 else 0) - (if 23 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_24 : ∀ v : Fin 103, + rowEval (d1Row 24) (h0Coeff v) = + (if 24 = v then 1 else 0) - (if 24 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_25 : ∀ v : Fin 103, + rowEval (d1Row 25) (h0Coeff v) = + (if 25 = v then 1 else 0) - (if 25 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_26 : ∀ v : Fin 103, + rowEval (d1Row 26) (h0Coeff v) = + (if 26 = v then 1 else 0) - (if 26 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_27 : ∀ v : Fin 103, + rowEval (d1Row 27) (h0Coeff v) = + (if 27 = v then 1 else 0) - (if 27 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_28 : ∀ v : Fin 103, + rowEval (d1Row 28) (h0Coeff v) = + (if 28 = v then 1 else 0) - (if 28 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_29 : ∀ v : Fin 103, + rowEval (d1Row 29) (h0Coeff v) = + (if 29 = v then 1 else 0) - (if 29 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_30 : ∀ v : Fin 103, + rowEval (d1Row 30) (h0Coeff v) = + (if 30 = v then 1 else 0) - (if 30 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_31 : ∀ v : Fin 103, + rowEval (d1Row 31) (h0Coeff v) = + (if 31 = v then 1 else 0) - (if 31 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_32 : ∀ v : Fin 103, + rowEval (d1Row 32) (h0Coeff v) = + (if 32 = v then 1 else 0) - (if 32 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_33 : ∀ v : Fin 103, + rowEval (d1Row 33) (h0Coeff v) = + (if 33 = v then 1 else 0) - (if 33 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_34 : ∀ v : Fin 103, + rowEval (d1Row 34) (h0Coeff v) = + (if 34 = v then 1 else 0) - (if 34 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_35 : ∀ v : Fin 103, + rowEval (d1Row 35) (h0Coeff v) = + (if 35 = v then 1 else 0) - (if 35 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_36 : ∀ v : Fin 103, + rowEval (d1Row 36) (h0Coeff v) = + (if 36 = v then 1 else 0) - (if 36 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_37 : ∀ v : Fin 103, + rowEval (d1Row 37) (h0Coeff v) = + (if 37 = v then 1 else 0) - (if 37 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_38 : ∀ v : Fin 103, + rowEval (d1Row 38) (h0Coeff v) = + (if 38 = v then 1 else 0) - (if 38 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_39 : ∀ v : Fin 103, + rowEval (d1Row 39) (h0Coeff v) = + (if 39 = v then 1 else 0) - (if 39 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_40 : ∀ v : Fin 103, + rowEval (d1Row 40) (h0Coeff v) = + (if 40 = v then 1 else 0) - (if 40 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_41 : ∀ v : Fin 103, + rowEval (d1Row 41) (h0Coeff v) = + (if 41 = v then 1 else 0) - (if 41 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_42 : ∀ v : Fin 103, + rowEval (d1Row 42) (h0Coeff v) = + (if 42 = v then 1 else 0) - (if 42 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_43 : ∀ v : Fin 103, + rowEval (d1Row 43) (h0Coeff v) = + (if 43 = v then 1 else 0) - (if 43 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_44 : ∀ v : Fin 103, + rowEval (d1Row 44) (h0Coeff v) = + (if 44 = v then 1 else 0) - (if 44 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_45 : ∀ v : Fin 103, + rowEval (d1Row 45) (h0Coeff v) = + (if 45 = v then 1 else 0) - (if 45 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_46 : ∀ v : Fin 103, + rowEval (d1Row 46) (h0Coeff v) = + (if 46 = v then 1 else 0) - (if 46 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_47 : ∀ v : Fin 103, + rowEval (d1Row 47) (h0Coeff v) = + (if 47 = v then 1 else 0) - (if 47 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_48 : ∀ v : Fin 103, + rowEval (d1Row 48) (h0Coeff v) = + (if 48 = v then 1 else 0) - (if 48 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_49 : ∀ v : Fin 103, + rowEval (d1Row 49) (h0Coeff v) = + (if 49 = v then 1 else 0) - (if 49 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_50 : ∀ v : Fin 103, + rowEval (d1Row 50) (h0Coeff v) = + (if 50 = v then 1 else 0) - (if 50 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_51 : ∀ v : Fin 103, + rowEval (d1Row 51) (h0Coeff v) = + (if 51 = v then 1 else 0) - (if 51 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_52 : ∀ v : Fin 103, + rowEval (d1Row 52) (h0Coeff v) = + (if 52 = v then 1 else 0) - (if 52 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_53 : ∀ v : Fin 103, + rowEval (d1Row 53) (h0Coeff v) = + (if 53 = v then 1 else 0) - (if 53 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_54 : ∀ v : Fin 103, + rowEval (d1Row 54) (h0Coeff v) = + (if 54 = v then 1 else 0) - (if 54 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_55 : ∀ v : Fin 103, + rowEval (d1Row 55) (h0Coeff v) = + (if 55 = v then 1 else 0) - (if 55 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_56 : ∀ v : Fin 103, + rowEval (d1Row 56) (h0Coeff v) = + (if 56 = v then 1 else 0) - (if 56 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_57 : ∀ v : Fin 103, + rowEval (d1Row 57) (h0Coeff v) = + (if 57 = v then 1 else 0) - (if 57 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_58 : ∀ v : Fin 103, + rowEval (d1Row 58) (h0Coeff v) = + (if 58 = v then 1 else 0) - (if 58 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_59 : ∀ v : Fin 103, + rowEval (d1Row 59) (h0Coeff v) = + (if 59 = v then 1 else 0) - (if 59 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_60 : ∀ v : Fin 103, + rowEval (d1Row 60) (h0Coeff v) = + (if 60 = v then 1 else 0) - (if 60 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_61 : ∀ v : Fin 103, + rowEval (d1Row 61) (h0Coeff v) = + (if 61 = v then 1 else 0) - (if 61 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_62 : ∀ v : Fin 103, + rowEval (d1Row 62) (h0Coeff v) = + (if 62 = v then 1 else 0) - (if 62 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_63 : ∀ v : Fin 103, + rowEval (d1Row 63) (h0Coeff v) = + (if 63 = v then 1 else 0) - (if 63 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_64 : ∀ v : Fin 103, + rowEval (d1Row 64) (h0Coeff v) = + (if 64 = v then 1 else 0) - (if 64 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_65 : ∀ v : Fin 103, + rowEval (d1Row 65) (h0Coeff v) = + (if 65 = v then 1 else 0) - (if 65 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_66 : ∀ v : Fin 103, + rowEval (d1Row 66) (h0Coeff v) = + (if 66 = v then 1 else 0) - (if 66 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_67 : ∀ v : Fin 103, + rowEval (d1Row 67) (h0Coeff v) = + (if 67 = v then 1 else 0) - (if 67 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_68 : ∀ v : Fin 103, + rowEval (d1Row 68) (h0Coeff v) = + (if 68 = v then 1 else 0) - (if 68 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_69 : ∀ v : Fin 103, + rowEval (d1Row 69) (h0Coeff v) = + (if 69 = v then 1 else 0) - (if 69 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_70 : ∀ v : Fin 103, + rowEval (d1Row 70) (h0Coeff v) = + (if 70 = v then 1 else 0) - (if 70 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_71 : ∀ v : Fin 103, + rowEval (d1Row 71) (h0Coeff v) = + (if 71 = v then 1 else 0) - (if 71 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_72 : ∀ v : Fin 103, + rowEval (d1Row 72) (h0Coeff v) = + (if 72 = v then 1 else 0) - (if 72 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_73 : ∀ v : Fin 103, + rowEval (d1Row 73) (h0Coeff v) = + (if 73 = v then 1 else 0) - (if 73 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_74 : ∀ v : Fin 103, + rowEval (d1Row 74) (h0Coeff v) = + (if 74 = v then 1 else 0) - (if 74 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_75 : ∀ v : Fin 103, + rowEval (d1Row 75) (h0Coeff v) = + (if 75 = v then 1 else 0) - (if 75 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_76 : ∀ v : Fin 103, + rowEval (d1Row 76) (h0Coeff v) = + (if 76 = v then 1 else 0) - (if 76 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_77 : ∀ v : Fin 103, + rowEval (d1Row 77) (h0Coeff v) = + (if 77 = v then 1 else 0) - (if 77 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_78 : ∀ v : Fin 103, + rowEval (d1Row 78) (h0Coeff v) = + (if 78 = v then 1 else 0) - (if 78 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_79 : ∀ v : Fin 103, + rowEval (d1Row 79) (h0Coeff v) = + (if 79 = v then 1 else 0) - (if 79 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_80 : ∀ v : Fin 103, + rowEval (d1Row 80) (h0Coeff v) = + (if 80 = v then 1 else 0) - (if 80 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_81 : ∀ v : Fin 103, + rowEval (d1Row 81) (h0Coeff v) = + (if 81 = v then 1 else 0) - (if 81 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_82 : ∀ v : Fin 103, + rowEval (d1Row 82) (h0Coeff v) = + (if 82 = v then 1 else 0) - (if 82 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_83 : ∀ v : Fin 103, + rowEval (d1Row 83) (h0Coeff v) = + (if 83 = v then 1 else 0) - (if 83 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_84 : ∀ v : Fin 103, + rowEval (d1Row 84) (h0Coeff v) = + (if 84 = v then 1 else 0) - (if 84 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_85 : ∀ v : Fin 103, + rowEval (d1Row 85) (h0Coeff v) = + (if 85 = v then 1 else 0) - (if 85 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_86 : ∀ v : Fin 103, + rowEval (d1Row 86) (h0Coeff v) = + (if 86 = v then 1 else 0) - (if 86 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_87 : ∀ v : Fin 103, + rowEval (d1Row 87) (h0Coeff v) = + (if 87 = v then 1 else 0) - (if 87 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_88 : ∀ v : Fin 103, + rowEval (d1Row 88) (h0Coeff v) = + (if 88 = v then 1 else 0) - (if 88 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_89 : ∀ v : Fin 103, + rowEval (d1Row 89) (h0Coeff v) = + (if 89 = v then 1 else 0) - (if 89 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_90 : ∀ v : Fin 103, + rowEval (d1Row 90) (h0Coeff v) = + (if 90 = v then 1 else 0) - (if 90 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_91 : ∀ v : Fin 103, + rowEval (d1Row 91) (h0Coeff v) = + (if 91 = v then 1 else 0) - (if 91 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_92 : ∀ v : Fin 103, + rowEval (d1Row 92) (h0Coeff v) = + (if 92 = v then 1 else 0) - (if 92 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_93 : ∀ v : Fin 103, + rowEval (d1Row 93) (h0Coeff v) = + (if 93 = v then 1 else 0) - (if 93 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_94 : ∀ v : Fin 103, + rowEval (d1Row 94) (h0Coeff v) = + (if 94 = v then 1 else 0) - (if 94 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_95 : ∀ v : Fin 103, + rowEval (d1Row 95) (h0Coeff v) = + (if 95 = v then 1 else 0) - (if 95 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_96 : ∀ v : Fin 103, + rowEval (d1Row 96) (h0Coeff v) = + (if 96 = v then 1 else 0) - (if 96 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_97 : ∀ v : Fin 103, + rowEval (d1Row 97) (h0Coeff v) = + (if 97 = v then 1 else 0) - (if 97 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_98 : ∀ v : Fin 103, + rowEval (d1Row 98) (h0Coeff v) = + (if 98 = v then 1 else 0) - (if 98 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_99 : ∀ v : Fin 103, + rowEval (d1Row 99) (h0Coeff v) = + (if 99 = v then 1 else 0) - (if 99 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_100 : ∀ v : Fin 103, + rowEval (d1Row 100) (h0Coeff v) = + (if 100 = v then 1 else 0) - (if 100 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_101 : ∀ v : Fin 103, + rowEval (d1Row 101) (h0Coeff v) = + (if 101 = v then 1 else 0) - (if 101 = 0 then 1 else 0) := by decide +kernel + +theorem d1_h0_cert_102 : ∀ v : Fin 103, + rowEval (d1Row 102) (h0Coeff v) = + (if 102 = v then 1 else 0) - (if 102 = 0 then 1 else 0) := by decide +kernel + +theorem h1_boundary_cert (t : Fin 270) (j : Fin 270) : + h1Coeff (triangleEdges t).1 j - h1Coeff (triangleEdges t).2.1 j + + h1Coeff (triangleEdges t).2.2 j = if j = t then 1 else 0 := by + fin_cases t + · exact h1_boundary_cert_0 j + · exact h1_boundary_cert_1 j + · exact h1_boundary_cert_2 j + · exact h1_boundary_cert_3 j + · exact h1_boundary_cert_4 j + · exact h1_boundary_cert_5 j + · exact h1_boundary_cert_6 j + · exact h1_boundary_cert_7 j + · exact h1_boundary_cert_8 j + · exact h1_boundary_cert_9 j + · exact h1_boundary_cert_10 j + · exact h1_boundary_cert_11 j + · exact h1_boundary_cert_12 j + · exact h1_boundary_cert_13 j + · exact h1_boundary_cert_14 j + · exact h1_boundary_cert_15 j + · exact h1_boundary_cert_16 j + · exact h1_boundary_cert_17 j + · exact h1_boundary_cert_18 j + · exact h1_boundary_cert_19 j + · exact h1_boundary_cert_20 j + · exact h1_boundary_cert_21 j + · exact h1_boundary_cert_22 j + · exact h1_boundary_cert_23 j + · exact h1_boundary_cert_24 j + · exact h1_boundary_cert_25 j + · exact h1_boundary_cert_26 j + · exact h1_boundary_cert_27 j + · exact h1_boundary_cert_28 j + · exact h1_boundary_cert_29 j + · exact h1_boundary_cert_30 j + · exact h1_boundary_cert_31 j + · exact h1_boundary_cert_32 j + · exact h1_boundary_cert_33 j + · exact h1_boundary_cert_34 j + · exact h1_boundary_cert_35 j + · exact h1_boundary_cert_36 j + · exact h1_boundary_cert_37 j + · exact h1_boundary_cert_38 j + · exact h1_boundary_cert_39 j + · exact h1_boundary_cert_40 j + · exact h1_boundary_cert_41 j + · exact h1_boundary_cert_42 j + · exact h1_boundary_cert_43 j + · exact h1_boundary_cert_44 j + · exact h1_boundary_cert_45 j + · exact h1_boundary_cert_46 j + · exact h1_boundary_cert_47 j + · exact h1_boundary_cert_48 j + · exact h1_boundary_cert_49 j + · exact h1_boundary_cert_50 j + · exact h1_boundary_cert_51 j + · exact h1_boundary_cert_52 j + · exact h1_boundary_cert_53 j + · exact h1_boundary_cert_54 j + · exact h1_boundary_cert_55 j + · exact h1_boundary_cert_56 j + · exact h1_boundary_cert_57 j + · exact h1_boundary_cert_58 j + · exact h1_boundary_cert_59 j + · exact h1_boundary_cert_60 j + · exact h1_boundary_cert_61 j + · exact h1_boundary_cert_62 j + · exact h1_boundary_cert_63 j + · exact h1_boundary_cert_64 j + · exact h1_boundary_cert_65 j + · exact h1_boundary_cert_66 j + · exact h1_boundary_cert_67 j + · exact h1_boundary_cert_68 j + · exact h1_boundary_cert_69 j + · exact h1_boundary_cert_70 j + · exact h1_boundary_cert_71 j + · exact h1_boundary_cert_72 j + · exact h1_boundary_cert_73 j + · exact h1_boundary_cert_74 j + · exact h1_boundary_cert_75 j + · exact h1_boundary_cert_76 j + · exact h1_boundary_cert_77 j + · exact h1_boundary_cert_78 j + · exact h1_boundary_cert_79 j + · exact h1_boundary_cert_80 j + · exact h1_boundary_cert_81 j + · exact h1_boundary_cert_82 j + · exact h1_boundary_cert_83 j + · exact h1_boundary_cert_84 j + · exact h1_boundary_cert_85 j + · exact h1_boundary_cert_86 j + · exact h1_boundary_cert_87 j + · exact h1_boundary_cert_88 j + · exact h1_boundary_cert_89 j + · exact h1_boundary_cert_90 j + · exact h1_boundary_cert_91 j + · exact h1_boundary_cert_92 j + · exact h1_boundary_cert_93 j + · exact h1_boundary_cert_94 j + · exact h1_boundary_cert_95 j + · exact h1_boundary_cert_96 j + · exact h1_boundary_cert_97 j + · exact h1_boundary_cert_98 j + · exact h1_boundary_cert_99 j + · exact h1_boundary_cert_100 j + · exact h1_boundary_cert_101 j + · exact h1_boundary_cert_102 j + · exact h1_boundary_cert_103 j + · exact h1_boundary_cert_104 j + · exact h1_boundary_cert_105 j + · exact h1_boundary_cert_106 j + · exact h1_boundary_cert_107 j + · exact h1_boundary_cert_108 j + · exact h1_boundary_cert_109 j + · exact h1_boundary_cert_110 j + · exact h1_boundary_cert_111 j + · exact h1_boundary_cert_112 j + · exact h1_boundary_cert_113 j + · exact h1_boundary_cert_114 j + · exact h1_boundary_cert_115 j + · exact h1_boundary_cert_116 j + · exact h1_boundary_cert_117 j + · exact h1_boundary_cert_118 j + · exact h1_boundary_cert_119 j + · exact h1_boundary_cert_120 j + · exact h1_boundary_cert_121 j + · exact h1_boundary_cert_122 j + · exact h1_boundary_cert_123 j + · exact h1_boundary_cert_124 j + · exact h1_boundary_cert_125 j + · exact h1_boundary_cert_126 j + · exact h1_boundary_cert_127 j + · exact h1_boundary_cert_128 j + · exact h1_boundary_cert_129 j + · exact h1_boundary_cert_130 j + · exact h1_boundary_cert_131 j + · exact h1_boundary_cert_132 j + · exact h1_boundary_cert_133 j + · exact h1_boundary_cert_134 j + · exact h1_boundary_cert_135 j + · exact h1_boundary_cert_136 j + · exact h1_boundary_cert_137 j + · exact h1_boundary_cert_138 j + · exact h1_boundary_cert_139 j + · exact h1_boundary_cert_140 j + · exact h1_boundary_cert_141 j + · exact h1_boundary_cert_142 j + · exact h1_boundary_cert_143 j + · exact h1_boundary_cert_144 j + · exact h1_boundary_cert_145 j + · exact h1_boundary_cert_146 j + · exact h1_boundary_cert_147 j + · exact h1_boundary_cert_148 j + · exact h1_boundary_cert_149 j + · exact h1_boundary_cert_150 j + · exact h1_boundary_cert_151 j + · exact h1_boundary_cert_152 j + · exact h1_boundary_cert_153 j + · exact h1_boundary_cert_154 j + · exact h1_boundary_cert_155 j + · exact h1_boundary_cert_156 j + · exact h1_boundary_cert_157 j + · exact h1_boundary_cert_158 j + · exact h1_boundary_cert_159 j + · exact h1_boundary_cert_160 j + · exact h1_boundary_cert_161 j + · exact h1_boundary_cert_162 j + · exact h1_boundary_cert_163 j + · exact h1_boundary_cert_164 j + · exact h1_boundary_cert_165 j + · exact h1_boundary_cert_166 j + · exact h1_boundary_cert_167 j + · exact h1_boundary_cert_168 j + · exact h1_boundary_cert_169 j + · exact h1_boundary_cert_170 j + · exact h1_boundary_cert_171 j + · exact h1_boundary_cert_172 j + · exact h1_boundary_cert_173 j + · exact h1_boundary_cert_174 j + · exact h1_boundary_cert_175 j + · exact h1_boundary_cert_176 j + · exact h1_boundary_cert_177 j + · exact h1_boundary_cert_178 j + · exact h1_boundary_cert_179 j + · exact h1_boundary_cert_180 j + · exact h1_boundary_cert_181 j + · exact h1_boundary_cert_182 j + · exact h1_boundary_cert_183 j + · exact h1_boundary_cert_184 j + · exact h1_boundary_cert_185 j + · exact h1_boundary_cert_186 j + · exact h1_boundary_cert_187 j + · exact h1_boundary_cert_188 j + · exact h1_boundary_cert_189 j + · exact h1_boundary_cert_190 j + · exact h1_boundary_cert_191 j + · exact h1_boundary_cert_192 j + · exact h1_boundary_cert_193 j + · exact h1_boundary_cert_194 j + · exact h1_boundary_cert_195 j + · exact h1_boundary_cert_196 j + · exact h1_boundary_cert_197 j + · exact h1_boundary_cert_198 j + · exact h1_boundary_cert_199 j + · exact h1_boundary_cert_200 j + · exact h1_boundary_cert_201 j + · exact h1_boundary_cert_202 j + · exact h1_boundary_cert_203 j + · exact h1_boundary_cert_204 j + · exact h1_boundary_cert_205 j + · exact h1_boundary_cert_206 j + · exact h1_boundary_cert_207 j + · exact h1_boundary_cert_208 j + · exact h1_boundary_cert_209 j + · exact h1_boundary_cert_210 j + · exact h1_boundary_cert_211 j + · exact h1_boundary_cert_212 j + · exact h1_boundary_cert_213 j + · exact h1_boundary_cert_214 j + · exact h1_boundary_cert_215 j + · exact h1_boundary_cert_216 j + · exact h1_boundary_cert_217 j + · exact h1_boundary_cert_218 j + · exact h1_boundary_cert_219 j + · exact h1_boundary_cert_220 j + · exact h1_boundary_cert_221 j + · exact h1_boundary_cert_222 j + · exact h1_boundary_cert_223 j + · exact h1_boundary_cert_224 j + · exact h1_boundary_cert_225 j + · exact h1_boundary_cert_226 j + · exact h1_boundary_cert_227 j + · exact h1_boundary_cert_228 j + · exact h1_boundary_cert_229 j + · exact h1_boundary_cert_230 j + · exact h1_boundary_cert_231 j + · exact h1_boundary_cert_232 j + · exact h1_boundary_cert_233 j + · exact h1_boundary_cert_234 j + · exact h1_boundary_cert_235 j + · exact h1_boundary_cert_236 j + · exact h1_boundary_cert_237 j + · exact h1_boundary_cert_238 j + · exact h1_boundary_cert_239 j + · exact h1_boundary_cert_240 j + · exact h1_boundary_cert_241 j + · exact h1_boundary_cert_242 j + · exact h1_boundary_cert_243 j + · exact h1_boundary_cert_244 j + · exact h1_boundary_cert_245 j + · exact h1_boundary_cert_246 j + · exact h1_boundary_cert_247 j + · exact h1_boundary_cert_248 j + · exact h1_boundary_cert_249 j + · exact h1_boundary_cert_250 j + · exact h1_boundary_cert_251 j + · exact h1_boundary_cert_252 j + · exact h1_boundary_cert_253 j + · exact h1_boundary_cert_254 j + · exact h1_boundary_cert_255 j + · exact h1_boundary_cert_256 j + · exact h1_boundary_cert_257 j + · exact h1_boundary_cert_258 j + · exact h1_boundary_cert_259 j + · exact h1_boundary_cert_260 j + · exact h1_boundary_cert_261 j + · exact h1_boundary_cert_262 j + · exact h1_boundary_cert_263 j + · exact h1_boundary_cert_264 j + · exact h1_boundary_cert_265 j + · exact h1_boundary_cert_266 j + · exact h1_boundary_cert_267 j + · exact h1_boundary_cert_268 j + · exact h1_boundary_cert_269 j + +theorem d1_basis_cert (i : Fin 103) (e : Fin 372) : + rowEval (d1Row i) (fun j => if j = e then 1 else 0) = + (if i = (edge e).2 then 1 else 0) - (if i = (edge e).1 then 1 else 0) := by + fin_cases i + · exact d1_basis_cert_0 e + · exact d1_basis_cert_1 e + · exact d1_basis_cert_2 e + · exact d1_basis_cert_3 e + · exact d1_basis_cert_4 e + · exact d1_basis_cert_5 e + · exact d1_basis_cert_6 e + · exact d1_basis_cert_7 e + · exact d1_basis_cert_8 e + · exact d1_basis_cert_9 e + · exact d1_basis_cert_10 e + · exact d1_basis_cert_11 e + · exact d1_basis_cert_12 e + · exact d1_basis_cert_13 e + · exact d1_basis_cert_14 e + · exact d1_basis_cert_15 e + · exact d1_basis_cert_16 e + · exact d1_basis_cert_17 e + · exact d1_basis_cert_18 e + · exact d1_basis_cert_19 e + · exact d1_basis_cert_20 e + · exact d1_basis_cert_21 e + · exact d1_basis_cert_22 e + · exact d1_basis_cert_23 e + · exact d1_basis_cert_24 e + · exact d1_basis_cert_25 e + · exact d1_basis_cert_26 e + · exact d1_basis_cert_27 e + · exact d1_basis_cert_28 e + · exact d1_basis_cert_29 e + · exact d1_basis_cert_30 e + · exact d1_basis_cert_31 e + · exact d1_basis_cert_32 e + · exact d1_basis_cert_33 e + · exact d1_basis_cert_34 e + · exact d1_basis_cert_35 e + · exact d1_basis_cert_36 e + · exact d1_basis_cert_37 e + · exact d1_basis_cert_38 e + · exact d1_basis_cert_39 e + · exact d1_basis_cert_40 e + · exact d1_basis_cert_41 e + · exact d1_basis_cert_42 e + · exact d1_basis_cert_43 e + · exact d1_basis_cert_44 e + · exact d1_basis_cert_45 e + · exact d1_basis_cert_46 e + · exact d1_basis_cert_47 e + · exact d1_basis_cert_48 e + · exact d1_basis_cert_49 e + · exact d1_basis_cert_50 e + · exact d1_basis_cert_51 e + · exact d1_basis_cert_52 e + · exact d1_basis_cert_53 e + · exact d1_basis_cert_54 e + · exact d1_basis_cert_55 e + · exact d1_basis_cert_56 e + · exact d1_basis_cert_57 e + · exact d1_basis_cert_58 e + · exact d1_basis_cert_59 e + · exact d1_basis_cert_60 e + · exact d1_basis_cert_61 e + · exact d1_basis_cert_62 e + · exact d1_basis_cert_63 e + · exact d1_basis_cert_64 e + · exact d1_basis_cert_65 e + · exact d1_basis_cert_66 e + · exact d1_basis_cert_67 e + · exact d1_basis_cert_68 e + · exact d1_basis_cert_69 e + · exact d1_basis_cert_70 e + · exact d1_basis_cert_71 e + · exact d1_basis_cert_72 e + · exact d1_basis_cert_73 e + · exact d1_basis_cert_74 e + · exact d1_basis_cert_75 e + · exact d1_basis_cert_76 e + · exact d1_basis_cert_77 e + · exact d1_basis_cert_78 e + · exact d1_basis_cert_79 e + · exact d1_basis_cert_80 e + · exact d1_basis_cert_81 e + · exact d1_basis_cert_82 e + · exact d1_basis_cert_83 e + · exact d1_basis_cert_84 e + · exact d1_basis_cert_85 e + · exact d1_basis_cert_86 e + · exact d1_basis_cert_87 e + · exact d1_basis_cert_88 e + · exact d1_basis_cert_89 e + · exact d1_basis_cert_90 e + · exact d1_basis_cert_91 e + · exact d1_basis_cert_92 e + · exact d1_basis_cert_93 e + · exact d1_basis_cert_94 e + · exact d1_basis_cert_95 e + · exact d1_basis_cert_96 e + · exact d1_basis_cert_97 e + · exact d1_basis_cert_98 e + · exact d1_basis_cert_99 e + · exact d1_basis_cert_100 e + · exact d1_basis_cert_101 e + · exact d1_basis_cert_102 e + +theorem d2_basis_cert (e : Fin 372) (t : Fin 270) : + rowEval (d2Row e) (fun i => if i = t then 1 else 0) = + (if e = (triangleEdges t).1 then 1 else 0) - + (if e = (triangleEdges t).2.1 then 1 else 0) + (if e = (triangleEdges t).2.2 then 1 else 0) := by + fin_cases e + · exact d2_basis_cert_0 t + · exact d2_basis_cert_1 t + · exact d2_basis_cert_2 t + · exact d2_basis_cert_3 t + · exact d2_basis_cert_4 t + · exact d2_basis_cert_5 t + · exact d2_basis_cert_6 t + · exact d2_basis_cert_7 t + · exact d2_basis_cert_8 t + · exact d2_basis_cert_9 t + · exact d2_basis_cert_10 t + · exact d2_basis_cert_11 t + · exact d2_basis_cert_12 t + · exact d2_basis_cert_13 t + · exact d2_basis_cert_14 t + · exact d2_basis_cert_15 t + · exact d2_basis_cert_16 t + · exact d2_basis_cert_17 t + · exact d2_basis_cert_18 t + · exact d2_basis_cert_19 t + · exact d2_basis_cert_20 t + · exact d2_basis_cert_21 t + · exact d2_basis_cert_22 t + · exact d2_basis_cert_23 t + · exact d2_basis_cert_24 t + · exact d2_basis_cert_25 t + · exact d2_basis_cert_26 t + · exact d2_basis_cert_27 t + · exact d2_basis_cert_28 t + · exact d2_basis_cert_29 t + · exact d2_basis_cert_30 t + · exact d2_basis_cert_31 t + · exact d2_basis_cert_32 t + · exact d2_basis_cert_33 t + · exact d2_basis_cert_34 t + · exact d2_basis_cert_35 t + · exact d2_basis_cert_36 t + · exact d2_basis_cert_37 t + · exact d2_basis_cert_38 t + · exact d2_basis_cert_39 t + · exact d2_basis_cert_40 t + · exact d2_basis_cert_41 t + · exact d2_basis_cert_42 t + · exact d2_basis_cert_43 t + · exact d2_basis_cert_44 t + · exact d2_basis_cert_45 t + · exact d2_basis_cert_46 t + · exact d2_basis_cert_47 t + · exact d2_basis_cert_48 t + · exact d2_basis_cert_49 t + · exact d2_basis_cert_50 t + · exact d2_basis_cert_51 t + · exact d2_basis_cert_52 t + · exact d2_basis_cert_53 t + · exact d2_basis_cert_54 t + · exact d2_basis_cert_55 t + · exact d2_basis_cert_56 t + · exact d2_basis_cert_57 t + · exact d2_basis_cert_58 t + · exact d2_basis_cert_59 t + · exact d2_basis_cert_60 t + · exact d2_basis_cert_61 t + · exact d2_basis_cert_62 t + · exact d2_basis_cert_63 t + · exact d2_basis_cert_64 t + · exact d2_basis_cert_65 t + · exact d2_basis_cert_66 t + · exact d2_basis_cert_67 t + · exact d2_basis_cert_68 t + · exact d2_basis_cert_69 t + · exact d2_basis_cert_70 t + · exact d2_basis_cert_71 t + · exact d2_basis_cert_72 t + · exact d2_basis_cert_73 t + · exact d2_basis_cert_74 t + · exact d2_basis_cert_75 t + · exact d2_basis_cert_76 t + · exact d2_basis_cert_77 t + · exact d2_basis_cert_78 t + · exact d2_basis_cert_79 t + · exact d2_basis_cert_80 t + · exact d2_basis_cert_81 t + · exact d2_basis_cert_82 t + · exact d2_basis_cert_83 t + · exact d2_basis_cert_84 t + · exact d2_basis_cert_85 t + · exact d2_basis_cert_86 t + · exact d2_basis_cert_87 t + · exact d2_basis_cert_88 t + · exact d2_basis_cert_89 t + · exact d2_basis_cert_90 t + · exact d2_basis_cert_91 t + · exact d2_basis_cert_92 t + · exact d2_basis_cert_93 t + · exact d2_basis_cert_94 t + · exact d2_basis_cert_95 t + · exact d2_basis_cert_96 t + · exact d2_basis_cert_97 t + · exact d2_basis_cert_98 t + · exact d2_basis_cert_99 t + · exact d2_basis_cert_100 t + · exact d2_basis_cert_101 t + · exact d2_basis_cert_102 t + · exact d2_basis_cert_103 t + · exact d2_basis_cert_104 t + · exact d2_basis_cert_105 t + · exact d2_basis_cert_106 t + · exact d2_basis_cert_107 t + · exact d2_basis_cert_108 t + · exact d2_basis_cert_109 t + · exact d2_basis_cert_110 t + · exact d2_basis_cert_111 t + · exact d2_basis_cert_112 t + · exact d2_basis_cert_113 t + · exact d2_basis_cert_114 t + · exact d2_basis_cert_115 t + · exact d2_basis_cert_116 t + · exact d2_basis_cert_117 t + · exact d2_basis_cert_118 t + · exact d2_basis_cert_119 t + · exact d2_basis_cert_120 t + · exact d2_basis_cert_121 t + · exact d2_basis_cert_122 t + · exact d2_basis_cert_123 t + · exact d2_basis_cert_124 t + · exact d2_basis_cert_125 t + · exact d2_basis_cert_126 t + · exact d2_basis_cert_127 t + · exact d2_basis_cert_128 t + · exact d2_basis_cert_129 t + · exact d2_basis_cert_130 t + · exact d2_basis_cert_131 t + · exact d2_basis_cert_132 t + · exact d2_basis_cert_133 t + · exact d2_basis_cert_134 t + · exact d2_basis_cert_135 t + · exact d2_basis_cert_136 t + · exact d2_basis_cert_137 t + · exact d2_basis_cert_138 t + · exact d2_basis_cert_139 t + · exact d2_basis_cert_140 t + · exact d2_basis_cert_141 t + · exact d2_basis_cert_142 t + · exact d2_basis_cert_143 t + · exact d2_basis_cert_144 t + · exact d2_basis_cert_145 t + · exact d2_basis_cert_146 t + · exact d2_basis_cert_147 t + · exact d2_basis_cert_148 t + · exact d2_basis_cert_149 t + · exact d2_basis_cert_150 t + · exact d2_basis_cert_151 t + · exact d2_basis_cert_152 t + · exact d2_basis_cert_153 t + · exact d2_basis_cert_154 t + · exact d2_basis_cert_155 t + · exact d2_basis_cert_156 t + · exact d2_basis_cert_157 t + · exact d2_basis_cert_158 t + · exact d2_basis_cert_159 t + · exact d2_basis_cert_160 t + · exact d2_basis_cert_161 t + · exact d2_basis_cert_162 t + · exact d2_basis_cert_163 t + · exact d2_basis_cert_164 t + · exact d2_basis_cert_165 t + · exact d2_basis_cert_166 t + · exact d2_basis_cert_167 t + · exact d2_basis_cert_168 t + · exact d2_basis_cert_169 t + · exact d2_basis_cert_170 t + · exact d2_basis_cert_171 t + · exact d2_basis_cert_172 t + · exact d2_basis_cert_173 t + · exact d2_basis_cert_174 t + · exact d2_basis_cert_175 t + · exact d2_basis_cert_176 t + · exact d2_basis_cert_177 t + · exact d2_basis_cert_178 t + · exact d2_basis_cert_179 t + · exact d2_basis_cert_180 t + · exact d2_basis_cert_181 t + · exact d2_basis_cert_182 t + · exact d2_basis_cert_183 t + · exact d2_basis_cert_184 t + · exact d2_basis_cert_185 t + · exact d2_basis_cert_186 t + · exact d2_basis_cert_187 t + · exact d2_basis_cert_188 t + · exact d2_basis_cert_189 t + · exact d2_basis_cert_190 t + · exact d2_basis_cert_191 t + · exact d2_basis_cert_192 t + · exact d2_basis_cert_193 t + · exact d2_basis_cert_194 t + · exact d2_basis_cert_195 t + · exact d2_basis_cert_196 t + · exact d2_basis_cert_197 t + · exact d2_basis_cert_198 t + · exact d2_basis_cert_199 t + · exact d2_basis_cert_200 t + · exact d2_basis_cert_201 t + · exact d2_basis_cert_202 t + · exact d2_basis_cert_203 t + · exact d2_basis_cert_204 t + · exact d2_basis_cert_205 t + · exact d2_basis_cert_206 t + · exact d2_basis_cert_207 t + · exact d2_basis_cert_208 t + · exact d2_basis_cert_209 t + · exact d2_basis_cert_210 t + · exact d2_basis_cert_211 t + · exact d2_basis_cert_212 t + · exact d2_basis_cert_213 t + · exact d2_basis_cert_214 t + · exact d2_basis_cert_215 t + · exact d2_basis_cert_216 t + · exact d2_basis_cert_217 t + · exact d2_basis_cert_218 t + · exact d2_basis_cert_219 t + · exact d2_basis_cert_220 t + · exact d2_basis_cert_221 t + · exact d2_basis_cert_222 t + · exact d2_basis_cert_223 t + · exact d2_basis_cert_224 t + · exact d2_basis_cert_225 t + · exact d2_basis_cert_226 t + · exact d2_basis_cert_227 t + · exact d2_basis_cert_228 t + · exact d2_basis_cert_229 t + · exact d2_basis_cert_230 t + · exact d2_basis_cert_231 t + · exact d2_basis_cert_232 t + · exact d2_basis_cert_233 t + · exact d2_basis_cert_234 t + · exact d2_basis_cert_235 t + · exact d2_basis_cert_236 t + · exact d2_basis_cert_237 t + · exact d2_basis_cert_238 t + · exact d2_basis_cert_239 t + · exact d2_basis_cert_240 t + · exact d2_basis_cert_241 t + · exact d2_basis_cert_242 t + · exact d2_basis_cert_243 t + · exact d2_basis_cert_244 t + · exact d2_basis_cert_245 t + · exact d2_basis_cert_246 t + · exact d2_basis_cert_247 t + · exact d2_basis_cert_248 t + · exact d2_basis_cert_249 t + · exact d2_basis_cert_250 t + · exact d2_basis_cert_251 t + · exact d2_basis_cert_252 t + · exact d2_basis_cert_253 t + · exact d2_basis_cert_254 t + · exact d2_basis_cert_255 t + · exact d2_basis_cert_256 t + · exact d2_basis_cert_257 t + · exact d2_basis_cert_258 t + · exact d2_basis_cert_259 t + · exact d2_basis_cert_260 t + · exact d2_basis_cert_261 t + · exact d2_basis_cert_262 t + · exact d2_basis_cert_263 t + · exact d2_basis_cert_264 t + · exact d2_basis_cert_265 t + · exact d2_basis_cert_266 t + · exact d2_basis_cert_267 t + · exact d2_basis_cert_268 t + · exact d2_basis_cert_269 t + · exact d2_basis_cert_270 t + · exact d2_basis_cert_271 t + · exact d2_basis_cert_272 t + · exact d2_basis_cert_273 t + · exact d2_basis_cert_274 t + · exact d2_basis_cert_275 t + · exact d2_basis_cert_276 t + · exact d2_basis_cert_277 t + · exact d2_basis_cert_278 t + · exact d2_basis_cert_279 t + · exact d2_basis_cert_280 t + · exact d2_basis_cert_281 t + · exact d2_basis_cert_282 t + · exact d2_basis_cert_283 t + · exact d2_basis_cert_284 t + · exact d2_basis_cert_285 t + · exact d2_basis_cert_286 t + · exact d2_basis_cert_287 t + · exact d2_basis_cert_288 t + · exact d2_basis_cert_289 t + · exact d2_basis_cert_290 t + · exact d2_basis_cert_291 t + · exact d2_basis_cert_292 t + · exact d2_basis_cert_293 t + · exact d2_basis_cert_294 t + · exact d2_basis_cert_295 t + · exact d2_basis_cert_296 t + · exact d2_basis_cert_297 t + · exact d2_basis_cert_298 t + · exact d2_basis_cert_299 t + · exact d2_basis_cert_300 t + · exact d2_basis_cert_301 t + · exact d2_basis_cert_302 t + · exact d2_basis_cert_303 t + · exact d2_basis_cert_304 t + · exact d2_basis_cert_305 t + · exact d2_basis_cert_306 t + · exact d2_basis_cert_307 t + · exact d2_basis_cert_308 t + · exact d2_basis_cert_309 t + · exact d2_basis_cert_310 t + · exact d2_basis_cert_311 t + · exact d2_basis_cert_312 t + · exact d2_basis_cert_313 t + · exact d2_basis_cert_314 t + · exact d2_basis_cert_315 t + · exact d2_basis_cert_316 t + · exact d2_basis_cert_317 t + · exact d2_basis_cert_318 t + · exact d2_basis_cert_319 t + · exact d2_basis_cert_320 t + · exact d2_basis_cert_321 t + · exact d2_basis_cert_322 t + · exact d2_basis_cert_323 t + · exact d2_basis_cert_324 t + · exact d2_basis_cert_325 t + · exact d2_basis_cert_326 t + · exact d2_basis_cert_327 t + · exact d2_basis_cert_328 t + · exact d2_basis_cert_329 t + · exact d2_basis_cert_330 t + · exact d2_basis_cert_331 t + · exact d2_basis_cert_332 t + · exact d2_basis_cert_333 t + · exact d2_basis_cert_334 t + · exact d2_basis_cert_335 t + · exact d2_basis_cert_336 t + · exact d2_basis_cert_337 t + · exact d2_basis_cert_338 t + · exact d2_basis_cert_339 t + · exact d2_basis_cert_340 t + · exact d2_basis_cert_341 t + · exact d2_basis_cert_342 t + · exact d2_basis_cert_343 t + · exact d2_basis_cert_344 t + · exact d2_basis_cert_345 t + · exact d2_basis_cert_346 t + · exact d2_basis_cert_347 t + · exact d2_basis_cert_348 t + · exact d2_basis_cert_349 t + · exact d2_basis_cert_350 t + · exact d2_basis_cert_351 t + · exact d2_basis_cert_352 t + · exact d2_basis_cert_353 t + · exact d2_basis_cert_354 t + · exact d2_basis_cert_355 t + · exact d2_basis_cert_356 t + · exact d2_basis_cert_357 t + · exact d2_basis_cert_358 t + · exact d2_basis_cert_359 t + · exact d2_basis_cert_360 t + · exact d2_basis_cert_361 t + · exact d2_basis_cert_362 t + · exact d2_basis_cert_363 t + · exact d2_basis_cert_364 t + · exact d2_basis_cert_365 t + · exact d2_basis_cert_366 t + · exact d2_basis_cert_367 t + · exact d2_basis_cert_368 t + · exact d2_basis_cert_369 t + · exact d2_basis_cert_370 t + · exact d2_basis_cert_371 t + +theorem d1_h0_cert (i v : Fin 103) : + rowEval (d1Row i) (h0Coeff v) = + (if i = v then 1 else 0) - (if i = 0 then 1 else 0) := by + fin_cases i + · exact d1_h0_cert_0 v + · exact d1_h0_cert_1 v + · exact d1_h0_cert_2 v + · exact d1_h0_cert_3 v + · exact d1_h0_cert_4 v + · exact d1_h0_cert_5 v + · exact d1_h0_cert_6 v + · exact d1_h0_cert_7 v + · exact d1_h0_cert_8 v + · exact d1_h0_cert_9 v + · exact d1_h0_cert_10 v + · exact d1_h0_cert_11 v + · exact d1_h0_cert_12 v + · exact d1_h0_cert_13 v + · exact d1_h0_cert_14 v + · exact d1_h0_cert_15 v + · exact d1_h0_cert_16 v + · exact d1_h0_cert_17 v + · exact d1_h0_cert_18 v + · exact d1_h0_cert_19 v + · exact d1_h0_cert_20 v + · exact d1_h0_cert_21 v + · exact d1_h0_cert_22 v + · exact d1_h0_cert_23 v + · exact d1_h0_cert_24 v + · exact d1_h0_cert_25 v + · exact d1_h0_cert_26 v + · exact d1_h0_cert_27 v + · exact d1_h0_cert_28 v + · exact d1_h0_cert_29 v + · exact d1_h0_cert_30 v + · exact d1_h0_cert_31 v + · exact d1_h0_cert_32 v + · exact d1_h0_cert_33 v + · exact d1_h0_cert_34 v + · exact d1_h0_cert_35 v + · exact d1_h0_cert_36 v + · exact d1_h0_cert_37 v + · exact d1_h0_cert_38 v + · exact d1_h0_cert_39 v + · exact d1_h0_cert_40 v + · exact d1_h0_cert_41 v + · exact d1_h0_cert_42 v + · exact d1_h0_cert_43 v + · exact d1_h0_cert_44 v + · exact d1_h0_cert_45 v + · exact d1_h0_cert_46 v + · exact d1_h0_cert_47 v + · exact d1_h0_cert_48 v + · exact d1_h0_cert_49 v + · exact d1_h0_cert_50 v + · exact d1_h0_cert_51 v + · exact d1_h0_cert_52 v + · exact d1_h0_cert_53 v + · exact d1_h0_cert_54 v + · exact d1_h0_cert_55 v + · exact d1_h0_cert_56 v + · exact d1_h0_cert_57 v + · exact d1_h0_cert_58 v + · exact d1_h0_cert_59 v + · exact d1_h0_cert_60 v + · exact d1_h0_cert_61 v + · exact d1_h0_cert_62 v + · exact d1_h0_cert_63 v + · exact d1_h0_cert_64 v + · exact d1_h0_cert_65 v + · exact d1_h0_cert_66 v + · exact d1_h0_cert_67 v + · exact d1_h0_cert_68 v + · exact d1_h0_cert_69 v + · exact d1_h0_cert_70 v + · exact d1_h0_cert_71 v + · exact d1_h0_cert_72 v + · exact d1_h0_cert_73 v + · exact d1_h0_cert_74 v + · exact d1_h0_cert_75 v + · exact d1_h0_cert_76 v + · exact d1_h0_cert_77 v + · exact d1_h0_cert_78 v + · exact d1_h0_cert_79 v + · exact d1_h0_cert_80 v + · exact d1_h0_cert_81 v + · exact d1_h0_cert_82 v + · exact d1_h0_cert_83 v + · exact d1_h0_cert_84 v + · exact d1_h0_cert_85 v + · exact d1_h0_cert_86 v + · exact d1_h0_cert_87 v + · exact d1_h0_cert_88 v + · exact d1_h0_cert_89 v + · exact d1_h0_cert_90 v + · exact d1_h0_cert_91 v + · exact d1_h0_cert_92 v + · exact d1_h0_cert_93 v + · exact d1_h0_cert_94 v + · exact d1_h0_cert_95 v + · exact d1_h0_cert_96 v + · exact d1_h0_cert_97 v + · exact d1_h0_cert_98 v + · exact d1_h0_cert_99 v + · exact d1_h0_cert_100 v + · exact d1_h0_cert_101 v + · exact d1_h0_cert_102 v + +theorem fin_ite {n : ℕ} (i j : Fin n) (a b : ℤ) : + @ite ℤ (i = j) (Classical.propDecidable _) a b = + @ite ℤ (i = j) (instDecidableEqFin n i j) a b := by + by_cases h : i = j <;> simp [h] + +local instance : DecidableEq (Fin 103) := Classical.decEq _ +local instance : DecidableEq (Fin 372) := Classical.decEq _ +local instance : DecidableEq (Fin 270) := Classical.decEq _ + +noncomputable def d₁ := FiniteIntegralContraction.rowsMap d1Row +noncomputable def d₂ := FiniteIntegralContraction.rowsMap d2Row +noncomputable def h₀ := FiniteIntegralContraction.matrixMap h0Coeff +noncomputable def h₁ := FiniteIntegralContraction.matrixMap h1Coeff +noncomputable def h₁' := FiniteIntegralContraction.corrected d₁ h₀ h₁ + +theorem d₁_single (e : Fin 372) : + d₁ (Pi.single e 1) = Pi.single (edge e).2 1 - Pi.single (edge e).1 1 := +by + apply FiniteIntegralContraction.rows_single_one edge d1Row + intro i e + simpa only [rowEval,FiniteIntegralContraction.rowEval,fin_ite] using d1_basis_cert i e + +theorem d₂_single (t : Fin 270) : + d₂ (Pi.single t 1) = Pi.single (triangleEdges t).1 1 - + Pi.single (triangleEdges t).2.1 1 + Pi.single (triangleEdges t).2.2 1 := +by + apply FiniteIntegralContraction.rows_single_two triangleEdges d2Row + intro e t + simpa only [rowEval,FiniteIntegralContraction.rowEval,fin_ite] using d2_basis_cert e t + +theorem bottom_identity (v : Fin 103) : d₁ (h₀ (Pi.single v 1)) = Pi.single v 1 - Pi.single 0 1 := +by + apply FiniteIntegralContraction.certificate_bottom d1Row h0Coeff 0 + intro i v + simpa only [rowEval,FiniteIntegralContraction.rowEval,fin_ite] using d1_h0_cert i v + +theorem left_identity (t : Fin 270) : h₁ (d₂ (Pi.single t 1)) = Pi.single t 1 := +by + apply FiniteIntegralContraction.certificate_left triangleEdges d2Row h1Coeff d₂_single + intro t j + simpa only [fin_ite] using h1_boundary_cert t j + +theorem d₁_d₂_single (t : Fin 270) : d₁ (d₂ (Pi.single t 1)) = 0 := by + rw [d₂_single,map_add,map_sub,d₁_single,d₁_single,d₁_single] + obtain ⟨h₁,h₂,h₃⟩ := triangle_edges_valid t + rw [h₁,h₂,h₃] + dsimp + abel + +theorem corrected_identities : + (∀ t, h₁' (d₂ (Pi.single t 1)) = Pi.single t 1) ∧ + (∀ e, d₂ (h₁' (Pi.single e 1)) + h₀ (d₁ (Pi.single e 1)) = Pi.single e 1) := + FiniteIntegralContraction.middle_of_rank (by simp only [Fintype.card_fin]) 0 d₁ d₂ h₀ h₁ + d₁_d₂_single bottom_identity left_identity + +theorem fin_single {n : ℕ} (d : DecidableEq (Fin n)) (i : Fin n) (a : ℤ) : + @Pi.single (Fin n) (fun _ => ℤ) (fun _ => inferInstance) d i a = + @Pi.single (Fin n) (fun _ => ℤ) (fun _ => inferInstance) (instDecidableEqFin n) i a := by + ext j + simp only [Pi.single_apply] + split_ifs <;> rfl + +/-- An augmented integral chain contraction of the actual103-vertex source +cell-order complex, not an assumed homology property of the seed. -/ +noncomputable def contraction : SimplicialChains.Contraction graph := + indices.contraction 0 h₀ h₁' d₁ d₂ + (by simpa only [indices,fin_single] using d₁_single) + (by simpa only [indices,fin_single] using d₂_single) + (by simpa only [fin_single] using bottom_identity) + (by simpa only [fin_single] using corrected_identities.1) + (by simpa only [fin_single] using corrected_identities.2) + +end EilenbergGanea.SeedChainCertificate + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/SeedHolonomy.lean b/lean/OAI/Topology/EilenbergGanea/SeedHolonomy.lean new file mode 100644 index 0000000000000000000000000000000000000000..fcf4bd7ed212bec0a2d50bfe61814c43a65f4004 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/SeedHolonomy.lean @@ -0,0 +1,191 @@ +import OAI.Topology.EilenbergGanea.Seed +import OAI.Topology.EilenbergGanea.SmallHolonomy + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +/-! Exact quaternion monodromy of the fixed presentation seed. -/ +open scoped Quaternion +namespace EilenbergGanea + +abbrev SeedSU2 := unitary ℍ + +def seedGoldenReal : ℝ := (1 + Real.sqrt 5) / 4 + +def seedXQuaternion : ℍ := ⟨0,1,0,0⟩ +def seedYQuaternion : ℍ := + ⟨seedGoldenReal,1/2,Real.sqrt ((3 - Real.sqrt 5)/8),0⟩ + +theorem seedGoldenReal_quadratic : 4 * seedGoldenReal ^ 2 - 2 * seedGoldenReal - 1 = 0 := by + have h := Real.sq_sqrt (show (0 : ℝ) ≤ 5 by norm_num) + dsimp [seedGoldenReal] + nlinarith + +theorem seedGoldenReal_cubic : 8 * seedGoldenReal ^ 3 - 4 * seedGoldenReal = 1 := by + have h := seedGoldenReal_quadratic + nlinarith [sq_nonneg (2 * seedGoldenReal - 1), + mul_eq_zero_of_left h seedGoldenReal] + +theorem seedGoldenReal_quartic : 16 * seedGoldenReal ^ 4 - 12 * seedGoldenReal ^ 2 + 1 = 0 := by + have h := seedGoldenReal_quadratic + have h' := seedGoldenReal_cubic + nlinarith [mul_eq_zero_of_left h (seedGoldenReal ^ 2), + congrArg (fun t : ℝ => t * seedGoldenReal) h'] + +theorem seedX_normSq : Quaternion.normSq seedXQuaternion = 1 := by + rw [Quaternion.normSq_def'] + norm_num [seedXQuaternion] + +theorem seedY_normSq : Quaternion.normSq seedYQuaternion = 1 := by + have hs := Real.sq_sqrt (show (0 : ℝ) ≤ 5 by norm_num) + have hn := Real.sqrt_nonneg (5 : ℝ) + have hle : Real.sqrt (5 : ℝ) ≤ 3 := by nlinarith + have hc := Real.sq_sqrt (show (0 : ℝ) ≤ (3 - Real.sqrt 5)/8 by positivity) + rw [Quaternion.normSq_def'] + change seedGoldenReal ^ 2 + (1 / 2 : ℝ) ^ 2 + Real.sqrt ((3 - Real.sqrt 5)/8) ^ 2 + 0 ^ 2 = 1 + dsimp [seedGoldenReal] + nlinarith + +def seedXUnit : SeedSU2 := ⟨seedXQuaternion,by + rw [Unitary.mem_iff,Quaternion.star_mul_self,Quaternion.self_mul_star,seedX_normSq] + simp⟩ + +def seedYUnit : SeedSU2 := ⟨seedYQuaternion,by + rw [Unitary.mem_iff,Quaternion.star_mul_self,Quaternion.self_mul_star,seedY_normSq] + simp⟩ + +theorem unitQuaternion_quadratic (q : ℍ) (h : Quaternion.normSq q = 1) : + q ^ 2 = (2 * q.re : ℝ) * q - 1 := by + have hh := Quaternion.star_mul_self q + rw [h,Quaternion.star_eq_two_re_sub,sub_mul] at hh + simp only [Quaternion.coe_one] at hh + have hh' : ((2 * q.re : ℝ) : ℍ) * q = 1 + q * q := by + simpa only [add_comm] using sub_eq_iff_eq_add.mp hh + rw [pow_two] + apply eq_sub_iff_add_eq.mpr + simpa only [add_comm] using hh'.symm + +theorem unitQuaternion_half_cube (q : ℍ) (h : Quaternion.normSq q = 1) + (hr : q.re = 1/2) : q ^ 3 = -1 := by + have hh := unitQuaternion_quadratic q h + rw [hr] at hh + norm_num at hh + calc + q ^ 3 = q ^ 2 * q := by rw [pow_succ] + _ = (q - 1) * q := by rw [hh] + _ = q ^ 2 - q := by noncomm_ring + _ = -1 := by rw [hh]; noncomm_ring + +theorem seedX_square : seedXQuaternion ^ 2 = -1 := by + rw [pow_two] + apply Quaternion.ext + · rw [Quaternion.re_mul] + norm_num [seedXQuaternion] + · rw [Quaternion.imI_mul] + norm_num [seedXQuaternion] + · rw [Quaternion.imJ_mul] + norm_num [seedXQuaternion] + · rw [Quaternion.imK_mul] + norm_num [seedXQuaternion] + +theorem seedY_fifth : seedYQuaternion ^ 5 = -1 := by + let q := seedYQuaternion + let c : ℍ := (seedGoldenReal : ℝ) + have hh : q ^ 2 = 2 * c * q - 1 := by + simpa only [q,c,seedYQuaternion,Quaternion.coe_mul, show ((2 : ℝ) : ℍ) = 2 from rfl] using unitQuaternion_quadratic seedYQuaternion seedY_normSq + have h3 : q ^ 3 = (4 * c ^ 2 - 1) * q - 2 * c := by + calc + q ^ 3 = q ^ 2 * q := by rw [pow_succ] + _ = (2 * c * q - 1) * q := by rw [hh] + _ = 2 * c * q ^ 2 - q := by noncomm_ring + _ = (4 * c ^ 2 - 1) * q - 2 * c := by rw [hh]; noncomm_ring + have h4 : q ^ 4 = (8 * c ^ 3 - 4 * c) * q - (4 * c ^ 2 - 1) := by + calc + q ^ 4 = q ^ 3 * q := by rw [pow_succ] + _ = ((4 * c ^ 2 - 1) * q - 2 * c) * q := by rw [h3] + _ = (4 * c ^ 2 - 1) * q ^ 2 - 2 * c * q := by noncomm_ring + _ = (8 * c ^ 3 - 4 * c) * q - (4 * c ^ 2 - 1) := by rw [hh]; noncomm_ring + have h5 : q ^ 5 = (16 * c ^ 4 - 12 * c ^ 2 + 1) * q - (8 * c ^ 3 - 4 * c) := by + calc + q ^ 5 = q ^ 4 * q := by rw [pow_succ] + _ = ((8 * c ^ 3 - 4 * c) * q - (4 * c ^ 2 - 1)) * q := by rw [h4] + _ = (8 * c ^ 3 - 4 * c) * q ^ 2 - (4 * c ^ 2 - 1) * q := by noncomm_ring + _ = _ := by rw [hh]; noncomm_ring + have hc3 : 8 * c ^ 3 - 4 * c = 1 := by + change (8 : ℍ) * (seedGoldenReal : ℍ) ^ 3 - 4 * (seedGoldenReal : ℍ) = 1 + have h := congrArg (fun r : ℝ => (r : ℍ)) seedGoldenReal_cubic + simpa only [Quaternion.coe_sub,Quaternion.coe_mul,Quaternion.coe_pow,Quaternion.coe_one, + show ((8 : ℝ) : ℍ) = 8 from rfl, show ((4 : ℝ) : ℍ) = 4 from rfl] using h + have hc4 : 16 * c ^ 4 - 12 * c ^ 2 + 1 = 0 := by + change (16 : ℍ) * (seedGoldenReal : ℍ) ^ 4 - 12 * (seedGoldenReal : ℍ) ^ 2 + 1 = 0 + have h := congrArg (fun r : ℝ => (r : ℍ)) seedGoldenReal_quartic + simpa only [Quaternion.coe_sub,Quaternion.coe_mul,Quaternion.coe_pow,Quaternion.coe_add, + Quaternion.coe_one,Quaternion.coe_zero, show ((16 : ℝ) : ℍ) = 16 from rfl, + show ((12 : ℝ) : ℍ) = 12 from rfl] using h + simpa [hc3,hc4] using h5 + +theorem seedXYinv_cube : (seedXQuaternion * star seedYQuaternion) ^ 3 = -1 := by + apply unitQuaternion_half_cube + · rw [map_mul,Quaternion.normSq_star,seedX_normSq,seedY_normSq,mul_one] + · rw [Quaternion.re_mul] + rw [Quaternion.imI_star] + norm_num [seedXQuaternion,seedYQuaternion] + +theorem seed_unit_relations : + seedXUnit ^ 2 = seedYUnit ^ 5 ∧ + seedXUnit ^ 2 = (seedXUnit * seedYUnit⁻¹) ^ 3 := by + constructor + · apply Subtype.val_injective + change seedXQuaternion ^ 2 = seedYQuaternion ^ 5 + rw [seedX_square,seedY_fifth] + · apply Subtype.val_injective + change seedXQuaternion ^ 2 = (seedXQuaternion * star seedYQuaternion) ^ 3 + rw [seedX_square,seedXYinv_cube] + +def seedRelator : Bool → FreeGroup Bool + | false => FreeGroup.of false ^ 2 * (FreeGroup.of true ^ 5)⁻¹ + | true => FreeGroup.of false ^ 2 * ((FreeGroup.of false * (FreeGroup.of true)⁻¹) ^ 3)⁻¹ + +theorem seedWord_relator (r : Bool) : FreeGroup.mk (seedWord r) = seedRelator r := by + cases r <;> decide + +def seedLetterUnit : Bool → SeedSU2 + | false => seedXUnit + | true => seedYUnit + +theorem seedRelator_unit (r : Bool) : FreeGroup.lift seedLetterUnit (seedRelator r) = 1 := by + cases r + · simp only [seedRelator,map_mul,map_inv,map_pow,FreeGroup.lift_apply_of,seedLetterUnit] + rw [seed_unit_relations.1,mul_inv_cancel] + · simp only [seedRelator,map_mul,map_inv,map_pow,FreeGroup.lift_apply_of,seedLetterUnit] + rw [seed_unit_relations.2,mul_inv_cancel] + +abbrev SeedPresentationGroup := PresentedGroup (Set.range seedRelator) + +def seedMonodromy : SeedPresentationGroup →* SeedSU2 := + PresentedGroup.toGroup (f := seedLetterUnit) (by + rintro _ ⟨r,rfl⟩ + exact seedRelator_unit r) + +theorem seedMonodromy_nontrivial : seedMonodromy (PresentedGroup.of false) ≠ 1 := by + intro h + have hh := congrArg (fun q : SeedSU2 => (q : ℍ).re) h + simp [seedMonodromy,seedLetterUnit,seedXUnit,seedXQuaternion] at hh + +/-- The source exponent-sum boundary, with rows indexed by its two relators. -/ +def seedExponentMatrix : Matrix (Fin 2) (Fin 2) ℤ := !![2,-5;-1,3] + +theorem seedExponentMatrix_det : seedExponentMatrix.det = 1 := by + norm_num [seedExponentMatrix,Matrix.det_fin_two] + +end EilenbergGanea + + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/SmallHolonomy.lean b/lean/OAI/Topology/EilenbergGanea/SmallHolonomy.lean new file mode 100644 index 0000000000000000000000000000000000000000..de0cfe812b57b6dad09f747e78a06f7d86f64301 --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/SmallHolonomy.lean @@ -0,0 +1,744 @@ +import OAI.Topology.EilenbergGanea.WordEquations +import OAI.GroupTheory.RightAngledArtin.ResidualFiniteness +import Mathlib.Topology.Compactness.Compact +import Mathlib.LinearAlgebra.Finsupp.LinearCombination + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea +open scoped Quaternion ContDiff +/-- Squared chord length on the unit-quaternion sphere. -/ +theorem su2_distance_square (a : SU2) : + ‖(a : ℍ) - 1‖ ^ 2 = 2 - 2 * (a : ℍ).re := by + have hu := (quaternion_mem_unitary_iff _).mp a.property + have hs : Quaternion.normSq ((a : ℍ) - 1) = Quaternion.normSq (a : ℍ) + 1 - 2 * (a : ℍ).re := by + simp only [Quaternion.normSq_def', Quaternion.re_sub, Quaternion.imI_sub, + Quaternion.imJ_sub, Quaternion.imK_sub, Quaternion.re_one, + Quaternion.imI_one, Quaternion.imJ_one, Quaternion.imK_one] + ring + simpa only [Quaternion.normSq_eq_norm_mul_self, hu, one_mul, sq, one_add_one_eq_two] using hs + +def arcBlend (a : SU2) (t : ℝ) : ℍ := + (1 - Real.smoothTransition t) • (1 : ℍ) + Real.smoothTransition t • (a : ℍ) + +theorem arcBlend_norm_le (a : SU2) (t : ℝ) : ‖arcBlend a t‖ ≤ 1 := by + have h0 := Real.smoothTransition.nonneg t + have h1 := Real.smoothTransition.le_one t + have hn := (quaternion_mem_unitary_iff _).mp a.property + calc + _ ≤ ‖(1 - Real.smoothTransition t) • (1 : ℍ)‖ + + ‖Real.smoothTransition t • (a : ℍ)‖ := norm_add_le _ _ + _ = 1 := by rw [norm_smul, norm_smul, norm_one, hn, Real.norm_eq_abs, + Real.norm_eq_abs, abs_of_nonneg (sub_nonneg.mpr h1), abs_of_nonneg h0]; ring + +theorem small_unit_re (a : SU2) (ha : ‖(a : ℍ) - 1‖ < 1) : + 0 < (a : ℍ).re ∧ (a : ℍ).re ≤ 1 := by + have h := su2_distance_square a + have hn := norm_nonneg ((a : ℍ) - 1) + constructor <;> nlinarith [sq_nonneg ‖(a : ℍ) - 1‖] + +theorem arcBlend_re_le (a : SU2) (ha : ‖(a : ℍ) - 1‖ < 1) (t : ℝ) : + (a : ℍ).re ≤ (arcBlend a t).re := by + have h := (small_unit_re a ha).2 + have h0 := Real.smoothTransition.nonneg t + have h1 := Real.smoothTransition.le_one t + simp only [arcBlend, Quaternion.re_add, Quaternion.re_smul, Quaternion.re_one, smul_eq_mul] + nlinarith + +theorem arcBlend_ne_zero (a : SU2) (ha : ‖(a : ℍ) - 1‖ < 1) (t : ℝ) : + arcBlend a t ≠ 0 := by + have h := (small_unit_re a ha).1.trans_le (arcBlend_re_le a ha t) + intro he + simp only [he, Quaternion.re_zero, lt_self_iff_false] at h + +/-- A globally smooth path that remains in the closed chord ball of its +endpoint, avoiding any branch choice of a quaternion logarithm. -/ +def smallQuaternionArc (a : SU2) (t : ℝ) : SU2 := normalizeQuaternion (arcBlend a t) + +@[simp] theorem smallQuaternionArc_zero (a : SU2) : smallQuaternionArc a 0 = 1 := by + simpa [smallQuaternionArc, arcBlend] using (normalizeQuaternion_unitary (1 : SU2)) + +@[simp] theorem smallQuaternionArc_one (a : SU2) : smallQuaternionArc a 1 = a := by + simp [smallQuaternionArc, arcBlend] + +theorem smallQuaternionArc_smooth (a : SU2) (ha : ‖(a : ℍ) - 1‖ < 1) : + ContDiff ℝ ∞ (fun t => (smallQuaternionArc a t : ℍ)) := by + apply contDiff_iff_contDiffAt.mpr + intro t + exact (normalizeQuaternion_coe_contDiffAt (arcBlend_ne_zero a ha t)).comp t + (((contDiff_const.sub Real.smoothTransition.contDiff).smul contDiff_const).add + (Real.smoothTransition.contDiff.smul contDiff_const)).contDiffAt + +theorem smallQuaternionArc_distance (a : SU2) (ha : ‖(a : ℍ) - 1‖ < 1) (t : ℝ) : + ‖(smallQuaternionArc a t : ℍ) - 1‖ ≤ ‖(a : ℍ) - 1‖ := by + have hp : 0 < ‖arcBlend a t‖ := norm_pos_iff.mpr (arcBlend_ne_zero a ha t) + have hre : (a : ℍ).re ≤ (smallQuaternionArc a t : ℍ).re := by + rw [smallQuaternionArc, normalizeQuaternion_coe_of_ne_zero (arcBlend_ne_zero a ha t)] + simp only [Quaternion.re_smul, smul_eq_mul] + rw [mul_comm, ← div_eq_mul_inv, le_div_iff₀ hp] + exact (mul_le_of_le_one_right (small_unit_re a ha).1.le (arcBlend_norm_le a t)).trans + (arcBlend_re_le a ha t) + have h0 := su2_distance_square a + have h1 := su2_distance_square (smallQuaternionArc a t) + nlinarith [norm_nonneg ((a : ℍ)-1), norm_nonneg ((smallQuaternionArc a t : ℍ)-1)] + +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion ContDiff +open Set +section SelectedEquations +variable {E : Type*} {m d : ℕ} + +/-- The selected unknowns remain separate from coefficients, even when two +letters have the same image in the group quotient. -/ +def selectedAlphabet (σ : Fin m ↪ E) (e : E) : E ⊕ Fin m := by + classical + exact if h : ∃ i, σ i = e then .inr h.choose else .inl e + +@[simp] theorem selectedAlphabet_selected (σ : Fin m ↪ E) (i : Fin m) : + selectedAlphabet σ (σ i) = .inr i := by + classical + have h : ∃ j, σ j = σ i := ⟨i,rfl⟩ + simp only [selectedAlphabet, dite_eq_left h] + exact congrArg Sum.inr (σ.injective h.choose_spec) + + theorem selectedAlphabet_other (σ : Fin m ↪ E) (e : E) (he : ∀ i, σ i ≠ e) : + selectedAlphabet σ e = .inl e := by + classical + simp [selectedAlphabet, he] + +def selectedWord (σ : Fin m ↪ E) : FreeGroup E →* FreeGroup (E ⊕ Fin m) := + FreeGroup.map (selectedAlphabet σ) + +def selectedLabel (σ : Fin m ↪ E) (a : E → SU2) (x : Fin m → SU2) (e : E) : SU2 := + Sum.elim a x (selectedAlphabet σ e) + +@[simp] theorem selectedLabel_selected (σ : Fin m ↪ E) (a : E → SU2) + (x : Fin m → SU2) (i : Fin m) : selectedLabel σ a x (σ i) = x i := by + simp [selectedLabel] + + theorem selectedLabel_other (σ : Fin m ↪ E) (a : E → SU2) (x : Fin m → SU2) + (e : E) (he : ∀ i, σ i ≠ e) : selectedLabel σ a x e = a e := by + rw [selectedLabel, selectedAlphabet_other σ e he] + rfl + + theorem selectedWord_eval (σ : Fin m ↪ E) (a : E → SU2) (x : Fin m → SU2) + (w : FreeGroup E) : + FreeGroup.lift (Sum.elim a x) (selectedWord σ w) = + FreeGroup.lift (selectedLabel σ a x) w := by + have he : (FreeGroup.lift (Sum.elim a x)).comp (selectedWord σ) = + FreeGroup.lift (selectedLabel σ a x) := by + apply FreeGroup.ext_hom + intro e + simp [selectedWord, selectedLabel] + exact congrArg (fun f : FreeGroup E →* SU2 => f w) he + + theorem selectedWord_exponents [DecidableEq E] (σ : Fin m ↪ E) (w : FreeGroup E) (j : Fin m) : + wordExponents (eraseCoefficients (selectedWord σ w)) j = wordExponents w (σ j) := by + classical + have he : (FreeGroup.lift (fun i : Fin m => Multiplicative.ofAdd (if j = i then (1 : ℤ) else 0))).comp + (eraseCoefficients.comp (selectedWord σ)) = + FreeGroup.lift (fun e : E => Multiplicative.ofAdd (if σ j = e then (1 : ℤ) else 0)) := by + apply FreeGroup.ext_hom + intro e + by_cases h : ∃ i, σ i = e + · obtain ⟨i,rfl⟩ := h + simp [selectedWord, eraseCoefficients, σ.injective.eq_iff] + · have h' : ∀ i, σ i ≠ e := by simpa only [not_exists] using h + simp [selectedWord, eraseCoefficients, selectedAlphabet_other σ e h', h' j] + exact congrArg (fun f : FreeGroup E →* Multiplicative ℤ => (f w).toAdd) he + +/-- Solve a finite, full-rank system while keeping every unselected label fixed. +The distinguished sublevel condition is the actual isolated root condition, +not a nonsingularity assumption on the roots. -/ +theorem selected_word_sublevel_solvable [DecidableEq E] + (σ : Fin m ↪ E) (w : Fin m → FreeGroup E) (ρ : Fin d → FreeGroup E) + (a : ℝ → E → SU2) (ha : ∀ e, ContDiff ℝ ∞ (fun t => (a t e : ℍ))) + (ha0 : ∀ e, a 0 e = 1) + (hB : Matrix.det (fun i j => wordExponents (w i) (σ j)) ≠ 0) + (δ : ℝ) (hδ : 0 < δ) + (hiso : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x : Fin m → SU2, + (∀ i, FreeGroup.lift (selectedLabel σ (a t) x) (w i) = 1) → + ‖(fun i => (FreeGroup.lift (selectedLabel σ (a t) x) (ρ i) : ℍ)) - 1‖ ≠ δ) : + ∃ b : E → SU2, + (∀ e, (∀ i, σ i ≠ e) → b e = a 1 e) ∧ + (∀ i, FreeGroup.lift b (w i) = 1) ∧ + ‖(fun i => (FreeGroup.lift b (ρ i) : ℍ)) - 1‖ < δ := by + have hb : (exponentMatrix (fun i => eraseCoefficients (selectedWord σ (w i)))).det ≠ 0 := by + change (Matrix.det (fun i j => wordExponents (eraseCoefficients (selectedWord σ (w i))) j)) ≠ 0 + simpa only [selectedWord_exponents] using hB + obtain ⟨x,hx,hρ⟩ := coefficient_word_sublevel_solvable + (fun i => selectedWord σ (w i)) (fun i => selectedWord σ (ρ i)) a ha ha0 hb δ hδ + (fun t ht x hx => by + simp only [coefficientWordMap, selectedWord_eval] + apply hiso t ht x + intro i + have hi := congrFun hx i + simpa only [coefficientWordMap, selectedWord_eval, Pi.one_apply] using hi) + refine ⟨selectedLabel σ (a 1) x, fun e he => selectedLabel_other σ _ x e he, ?_, ?_⟩ + · intro i + have hi := congrFun hx i + simpa only [coefficientWordMap, selectedWord_eval, Pi.one_apply] using hi + · simpa only [coefficientWordMap, selectedWord_eval] using hρ + +end SelectedEquations +end EilenbergGanea + +namespace EilenbergGanea + +variable {Γ S H : Type*} [Group Γ] [Group H] + +def labelLift (v : S → Γ) (a : Γ → S → H) : + FreeGroup S →* ((Γ → H) ⋊[functionShift Γ H] Γ) := + FreeGroup.lift (fun s => ⟨fun g => a g s, v s⟩) + +def wordValue (v : S → Γ) : FreeGroup S →* Γ := FreeGroup.lift v + +def pathProduct (v : S → Γ) (a : Γ → S → H) (w : FreeGroup S) (g : Γ) : H := + (labelLift v a w).left g + + theorem labelLift_right (v : S → Γ) (a : Γ → S → H) (w : FreeGroup S) : + (labelLift v a w).right = wordValue v w := by + have he : (SemidirectProduct.rightHom : ((Γ → H) ⋊[functionShift Γ H] Γ) →* Γ).comp + (labelLift v a) = wordValue v := by + apply FreeGroup.ext_hom + intro s + simp [labelLift, wordValue] + exact congrArg (fun f : FreeGroup S →* Γ => f w) he + +@[simp] theorem pathProduct_one (v : S → Γ) (a : Γ → S → H) (g : Γ) : + pathProduct v a 1 g = 1 := by simp [pathProduct] +@[simp] theorem pathProduct_of (v : S → Γ) (a : Γ → S → H) (s : S) (g : Γ) : + pathProduct v a (FreeGroup.of s) g = a g s := by simp [pathProduct, labelLift] + theorem pathProduct_mul (v : S → Γ) (a : Γ → S → H) (w z : FreeGroup S) (g : Γ) : + pathProduct v a (w*z) g = pathProduct v a w g * pathProduct v a z (g * wordValue v w) := by + simp only [pathProduct, map_mul, SemidirectProduct.mul_left, Pi.mul_apply, labelLift_right] + rfl + theorem pathProduct_inv (v : S → Γ) (a : Γ → S → H) (w : FreeGroup S) (g : Γ) : + pathProduct v a w⁻¹ g = (pathProduct v a w (g * (wordValue v w)⁻¹))⁻¹ := by + simp only [pathProduct, map_inv, SemidirectProduct.inv_left, labelLift_right] + rfl + + theorem pathProduct_conjugate_loop (v : S → Γ) (a : Γ → S → H) + (u r : FreeGroup S) (hr : wordValue v r = 1) (g : Γ) : + pathProduct v a (u*r*u⁻¹) g = pathProduct v a u g * + pathProduct v a r (g * wordValue v u) * (pathProduct v a u g)⁻¹ := by + rw [pathProduct_mul, pathProduct_mul, pathProduct_inv, map_mul, hr, mul_one] + simp only [mul_inv_cancel_right] + + theorem pathProduct_continuous [TopologicalSpace H] [IsTopologicalGroup H] + (v : S → Γ) (w : FreeGroup S) (g : Γ) : + Continuous (fun a : Γ → S → H => pathProduct v a w g) := by + induction w using FreeGroup.induction_on generalizing g with + | one => simpa using (continuous_const : Continuous (fun _ : Γ → S → H => (1 : H))) + | of s => + simp only [pathProduct_of] + exact continuous_apply_apply g s + | inv_of s => + simp only [pathProduct_inv, pathProduct_of] + exact (continuous_apply_apply (g * (wordValue v (FreeGroup.of s))⁻¹) s).inv + | mul w z hw hz => + simp only [pathProduct_mul] + exact (hw g).mul (hz (g * wordValue v w)) + +/-- The set of vertices inspected by a word is finite, independently of the +label values. No countability hypothesis on the alphabet is needed. -/ +theorem pathProduct_finite_locations (v : S → Γ) (w : FreeGroup S) (g : Γ) : + ∃ P : Finset Γ, ∀ a b : Γ → S → H, + (∀ p ∈ P, ∀ s, a p s = b p s) → pathProduct v a w g = pathProduct v b w g := by + classical + induction w using FreeGroup.induction_on generalizing g with + | one => exact ⟨∅, fun _ _ _ => by simp⟩ + | of s => exact ⟨{g}, fun a b hab => by simpa using hab g (by simp) s⟩ + | inv_of s => + exact ⟨{g * (wordValue v (FreeGroup.of s))⁻¹}, fun a b hab => by + rw [pathProduct_inv, pathProduct_inv, pathProduct_of, pathProduct_of, hab _ (by simp)]⟩ + | mul w z hw hz => + obtain ⟨P, hP⟩ := hw g + obtain ⟨Q, hQ⟩ := hz (g * wordValue v w) + refine ⟨P ∪ Q, fun a b hab => ?_⟩ + rw [pathProduct_mul, pathProduct_mul, hP a b (fun p hp => hab p (Finset.mem_union_left Q hp)), + hQ a b (fun p hp => hab p (Finset.mem_union_right P hp))] + +/-- Evaluation commutes with pullback of a labeling along a group quotient, +including when different alphabet letters have the same image. -/ +theorem pathProduct_pullback {D : Type*} [Group D] (q : Γ →* D) + (v : S → Γ) (a : D → S → H) (w : FreeGroup S) (g : Γ) : + pathProduct v (fun p s => a (q p) s) w g = pathProduct (fun s => q (v s)) a w (q g) := by + have hv : ∀ w : FreeGroup S, wordValue (fun s => q (v s)) w = q (wordValue v w) := by + have he : wordValue (fun s => q (v s)) = q.comp (wordValue v) := by + apply FreeGroup.ext_hom + intro s + simp [wordValue] + intro w + exact congrArg (fun f : FreeGroup S →* D => f w) he + induction w using FreeGroup.induction_on generalizing g with + | one => simp + | of s => simp + | inv_of s => simp only [pathProduct_inv, pathProduct_of, hv, map_inv, map_mul] + | mul w z hw hz => simp only [pathProduct_mul, hv, map_mul, hw, hz] + + +/-- Once every final relator has trivial transport at every vertex, normal +closure gives trivial transport on every null word, not just on a finite +collection of test loops. -/ + theorem pathProduct_trivial_of_relators (v : S → Γ) (a : Γ → S → H) + (R : Set (FreeGroup S)) (hR : R ⊆ (wordValue v).ker) + (hp : (wordValue v).ker = Subgroup.normalClosure R) + (ha : ∀ r ∈ R, ∀ g, pathProduct v a r g = 1) + (w : FreeGroup S) (hw : wordValue v w = 1) (g : Γ) : pathProduct v a w g = 1 := by + have hrel : R ⊆ (labelLift v a).ker := by + intro r hr + change labelLift v a r = 1 + apply SemidirectProduct.ext + · funext g + exact ha r hr g + · rw [labelLift_right] + exact hR hr + have hle : Subgroup.normalClosure R ≤ (labelLift v a).ker := + Subgroup.normalClosure_le_normal hrel + have he : labelLift v a w = 1 := hle (by rw [← hp]; exact hw) + change (labelLift v a w).left g = 1 + rw [he] + rfl + + def pathChain (v : S → Γ) (w : FreeGroup S) (g : Γ) : (Γ × S) →₀ ℤ := + (pathProduct v (fun p s => Multiplicative.ofAdd (Finsupp.single (p,s) 1)) w g).toAdd + +@[simp] theorem pathChain_one (v : S → Γ) (g : Γ) : pathChain v 1 g = 0 := by + simp [pathChain] +@[simp] theorem pathChain_of (v : S → Γ) (s : S) (g : Γ) : + pathChain v (FreeGroup.of s) g = Finsupp.single (g,s) 1 := by simp [pathChain] + theorem pathChain_mul (v : S → Γ) (w z : FreeGroup S) (g : Γ) : + pathChain v (w*z) g = pathChain v w g + pathChain v z (g * wordValue v w) := by + simp only [pathChain, pathProduct_mul, toAdd_mul] + theorem pathChain_inv (v : S → Γ) (w : FreeGroup S) (g : Γ) : + pathChain v w⁻¹ g = -pathChain v w (g * (wordValue v w)⁻¹) := by + simp only [pathChain, pathProduct_inv, toAdd_inv] + theorem pathChain_conjugate (v : S → Γ) (u r : FreeGroup S) + (hr : wordValue v r = 1) (g : Γ) : + pathChain v (u*r*u⁻¹) g = pathChain v r (g * wordValue v u) := by + simp only [pathChain, pathProduct_conjugate_loop v _ u r hr g, + toAdd_mul, toAdd_inv] + abel + +variable {R : Type*} +abbrev NormalFactor (S R : Type*) := FreeGroup S × R × Bool + + def normalFactorWord (r : R → FreeGroup S) (f : NormalFactor S R) : FreeGroup S := + f.1 * (if f.2.2 then r f.2.1 else (r f.2.1)⁻¹) * f.1⁻¹ + + def normalFactorCount (v : S → Γ) (f : NormalFactor S R) (g : Γ) : (Γ × R) →₀ ℤ := + Finsupp.single (g * wordValue v f.1, f.2.1) (if f.2.2 then 1 else -1) + + def relatorChainMap (v : S → Γ) (r : R → FreeGroup S) : + ((Γ × R) →₀ ℤ) →ₗ[ℤ] ((Γ × S) →₀ ℤ) := + Finsupp.linearCombination ℤ (fun i => pathChain v (r i.2) i.1) + + theorem normalFactor_value (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (f : NormalFactor S R) : + wordValue v (normalFactorWord r f) = 1 := by + dsimp only [normalFactorWord] + split_ifs <;> simp [hr] + + theorem pathChain_normalFactor (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (f : NormalFactor S R) (g : Γ) : + pathChain v (normalFactorWord r f) g = relatorChainMap v r (normalFactorCount v f g) := by + simp only [normalFactorWord, normalFactorCount, relatorChainMap, Finsupp.linearCombination_single] + split_ifs with h + · rw [pathChain_conjugate v _ _ (hr _)]; simp only [one_smul] + · rw [pathChain_conjugate v _ _ (by simp [hr]), pathChain_inv, hr] + simp only [inv_one, mul_one, neg_one_smul] + + theorem pathChain_normalProduct (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (l : List (NormalFactor S R)) (g : Γ) : + pathChain v (l.map (normalFactorWord r)).prod g = + relatorChainMap v r (l.map (fun f => normalFactorCount v f g)).sum := by + induction l with + | nil => simp + | cons f l ih => + simp only [List.map_cons, List.prod_cons, List.sum_cons, map_add, pathChain_mul, + normalFactor_value v r hr f, mul_one, pathChain_normalFactor v r hr f g, ih] + +/-- The coefficient identity is an equality in the full free abelian group of +translated indexed relators. Injectivity is sufficient; no finiteness of the +relator or generator types is assumed. -/ + theorem exact_translated_relator_counts (v : S → Γ) (r : R → FreeGroup S) + (hr : ∀ i, wordValue v (r i) = 1) (hinj : Function.Injective (relatorChainMap v r)) + (z : FreeGroup S) (ρ : R) (hchain : pathChain v z 1 = pathChain v (r ρ) 1) + (l : List (NormalFactor S R)) (he : z = (l.map (normalFactorWord r)).prod) : + (l.map (fun f => normalFactorCount v f 1)).sum = Finsupp.single (1,ρ) 1 := by + apply hinj + rw [← pathChain_normalProduct v r hr, ← he, hchain] + simp [relatorChainMap] + +end EilenbergGanea + +namespace EilenbergGanea +variable {Γ S H : Type*} [Group Γ] [Group H] + + +section CompactLabeling +variable {T I : Type*} + + def mergeLabels (a : Γ → S → H) (b : Γ → T → H) : Γ → S ⊕ T → H := + fun g => Sum.elim (a g) (b g) + + omit [Group Γ] [Group H] in + theorem mergeLabels_continuous [TopologicalSpace H] (a : Γ → S → H) : + Continuous (fun b : Γ → T → H => mergeLabels a b) := by + apply continuous_pi + intro g + apply continuous_pi + intro s + cases s with + | inl s => exact continuous_const + | inr t => exact continuous_apply_apply g t + +/-- Copy arbitrary prescribed labels to a finite quotient solely on the finite +set of vertices currently being tested. This does not assert that the original +labeling is periodic or descends to a single quotient. -/ + theorem copy_labels_on_finite_set {D : Type*} [Group D] (q : Γ →* D) + (P : Finset Γ) (hq : Set.InjOn q (P : Set Γ)) (a : Γ → S → H) + (Allowed : H → Prop) (h1 : Allowed 1) (ha : ∀ g s, Allowed (a g s)) : + ∃ aF : D → S → H, (∀ d s, Allowed (aF d s)) ∧ ∀ p ∈ P, ∀ s, aF (q p) s = a p s := by + classical + let aF : D → S → H := fun d s => if hd : ∃ p ∈ P, q p = d then a hd.choose s else 1 + refine ⟨aF, ?_, ?_⟩ + · intro d s + dsimp [aF] + split_ifs + · exact ha _ _ + · exact h1 + · intro p hp s + have he : ∃ p' ∈ P, q p' = q p := ⟨p, hp, rfl⟩ + simp only [aF, dite_eq_left he] + have heq : he.choose = p := hq he.choose_spec.1 hp he.choose_spec.2 + rw [heq] + +/-- Tychonoff compactness for all extra generators, with the original labels +fixed. The finite-quotient premise is exactly the separate finite solvability +obligation, not a periodicity assumption on the prescribed assignment. -/ + theorem compact_labeling_from_finite_quotients [Group.ResiduallyFinite Γ] + [TopologicalSpace H] [IsTopologicalGroup H] [CompactSpace H] + (v : S ⊕ T → Γ) (a : Γ → S → H) (w : I → FreeGroup (S ⊕ T)) (g : I → Γ) + (K : I → Set H) (hK : ∀ i, IsClosed (K i)) + (Allowed : H → Prop) (h1 : Allowed 1) (ha : ∀ g s, Allowed (a g s)) + (hsolve : ∀ (N : FiniteIndexNormalSubgroup Γ) (J : Finset I) + (aF : (Γ ⧸ N.toSubgroup) → S → H), (∀ d s, Allowed (aF d s)) → + ∃ bF : (Γ ⧸ N.toSubgroup) → T → H, ∀ i ∈ J, ∀ d, + pathProduct (fun s => QuotientGroup.mk' N.toSubgroup (v s)) + (mergeLabels aF bF) (w i) d ∈ K i) : + ∃ b : Γ → T → H, ∀ i, pathProduct v (mergeLabels a b) (w i) (g i) ∈ K i := by + classical + let C : I → Set (Γ → T → H) := fun i => + {b | pathProduct v (mergeLabels a b) (w i) (g i) ∈ K i} + have hc : ∀ i, IsClosed (C i) := fun i => + (hK i).preimage ((pathProduct_continuous v (w i) (g i)).comp (mergeLabels_continuous a)) + have hf : ∀ J : Finset I, (⋂ i ∈ J, C i).Nonempty := by + intro J + choose P hP using (fun i : I => pathProduct_finite_locations (H := H) v (w i) (g i)) + let V := J.biUnion P + obtain ⟨N, hN⟩ := finite_set_quotient_injective V + let q := QuotientGroup.mk' N.toSubgroup + obtain ⟨aF, haF, heF⟩ := copy_labels_on_finite_set q V hN a Allowed h1 ha + obtain ⟨bF, hbF⟩ := hsolve N J aF haF + refine ⟨fun p t => bF (q p) t, ?_⟩ + simp only [Set.mem_iInter] + intro i hi + change pathProduct v (mergeLabels a (fun p t => bF (q p) t)) (w i) (g i) ∈ K i + have he : pathProduct v (mergeLabels a (fun p t => bF (q p) t)) (w i) (g i) = + pathProduct v (fun p s => mergeLabels aF bF (q p) s) (w i) (g i) := by + apply hP i + intro p hp s + cases s with + | inl s => exact (heF p (Finset.mem_biUnion.mpr ⟨i, hi, hp⟩) s).symm + | inr t => rfl + rw [he, pathProduct_pullback] + exact hbF i hi (q (g i)) + obtain ⟨b, hb⟩ := CompactSpace.iInter_nonempty hc hf + exact ⟨b, fun i => Set.mem_iInter.mp hb i⟩ +end CompactLabeling +end EilenbergGanea + +open scoped Quaternion +namespace EilenbergGanea + +theorem su2_norm (a : SU2) : ‖(a : ℍ)‖ = 1 := by + have h : star (a : ℍ) * (a : ℍ) = 1 := a.property.1 + have hn := congrArg norm h + simp only [norm_mul, norm_star, norm_one] at hn + nlinarith [norm_nonneg (a : ℍ)] + +/-- The two elementary estimates needed for the presentation argument, with +constants independent of the Cayley graph or any finite quotient. -/ +theorem unit_product_linearization (l : List ℍ) (h : ℝ) (hh : 0 ≤ h) + (hu : ∀ a ∈ l, ‖a‖ = 1) (hb : ∀ a ∈ l, ‖a - 1‖ ≤ h) : + ‖l.prod - 1‖ ≤ l.length * h ∧ + ‖l.prod - 1 - (l.map (fun a => a - 1)).sum‖ ≤ (l.length : ℝ)^2 * h^2 := by + induction l with + | nil => simp + | cons a l ih => + obtain ⟨hp, he⟩ := ih (fun b hm => hu b (by simp [hm])) (fun b hm => hb b (by simp [hm])) + have hna := hu a (by simp) + have hba := hb a (by simp) + have hid : a * l.prod - 1 = a * (l.prod - 1) + (a - 1) := by noncomm_ring + have hie : a * l.prod - 1 - ((a - 1) + (l.map (fun b => b - 1)).sum) = + (a - 1) * (l.prod - 1) + (l.prod - 1 - (l.map (fun b => b - 1)).sum) := by noncomm_ring + constructor + · simp only [List.prod_cons, List.length_cons, Nat.cast_add, Nat.cast_one] + rw [hid] + calc + _ ≤ ‖a * (l.prod - 1)‖ + ‖a - 1‖ := norm_add_le _ _ + _ = ‖l.prod - 1‖ + ‖a - 1‖ := by rw [norm_mul, hna, one_mul] + _ ≤ (l.length + 1) * h := by nlinarith + · simp only [List.prod_cons, List.map_cons, List.sum_cons, List.length_cons, Nat.cast_add, Nat.cast_one] + rw [hie] + have hn : 0 ≤ (l.length : ℝ) := Nat.cast_nonneg _ + calc + _ ≤ ‖(a - 1) * (l.prod - 1)‖ + ‖l.prod - 1 - (l.map (fun b => b - 1)).sum‖ := norm_add_le _ _ + _ = ‖a - 1‖ * ‖l.prod - 1‖ + ‖l.prod - 1 - (l.map (fun b => b - 1)).sum‖ := by rw [norm_mul] + _ ≤ h * (l.length * h) + (l.length : ℝ)^2 * h^2 := + add_le_add (mul_le_mul hba hp (norm_nonneg _) hh) he + _ ≤ (l.length + 1)^2 * h^2 := by nlinarith [sq_nonneg h] + + theorem quaternion_commutator_bound (a b : ℍ) : + ‖a * b - b * a‖ ≤ 2 * ‖a - 1‖ * ‖b - 1‖ := by + have he : a * b - b * a = (a - 1) * (b - 1) - (b - 1) * (a - 1) := by noncomm_ring + rw [he] + calc + _ ≤ ‖(a - 1) * (b - 1)‖ + ‖(b - 1) * (a - 1)‖ := norm_sub_le _ _ + _ = _ := by rw [norm_mul, norm_mul]; ring + + theorem su2_conjugation_error (a b : SU2) : + ‖((a * b * a⁻¹ : SU2) : ℍ) - (b : ℍ)‖ ≤ 2 * ‖(a : ℍ) - 1‖ * ‖(b : ℍ) - 1‖ := by + have he : ((a * b * a⁻¹ : SU2) : ℍ) - (b : ℍ) = + ((a : ℍ) * (b : ℍ) - (b : ℍ) * (a : ℍ)) * ((a⁻¹ : SU2) : ℍ) := by + change (a : ℍ) * (b : ℍ) * star (a : ℍ) - (b : ℍ) = _ + change _ = ((a : ℍ) * (b : ℍ) - (b : ℍ) * (a : ℍ)) * star (a : ℍ) + rw [sub_mul, mul_assoc (b : ℍ), a.property.2, mul_one] + rw [he, norm_mul, su2_norm, mul_one] + exact quaternion_commutator_bound _ _ + + theorem su2_inverse_distance (b : SU2) : ‖((b⁻¹ : SU2) : ℍ) - 1‖ = ‖(b : ℍ) - 1‖ := by + change ‖star (b : ℍ) - 1‖ = _ + calc + _ = ‖star ((b : ℍ) - 1)‖ := by rw [star_sub, star_one] + _ = _ := norm_star _ + + theorem su2_inverse_linearization (b : SU2) : + ‖((b⁻¹ : SU2) : ℍ) - 1 + ((b : ℍ) - 1)‖ ≤ ‖(b : ℍ) - 1‖^2 := by + have he : ((b⁻¹ : SU2) : ℍ) - 1 + ((b : ℍ) - 1) = + -((((b⁻¹ : SU2) : ℍ) - 1) * ((b : ℍ) - 1)) := by + have hb : ((b⁻¹ : SU2) : ℍ) * (b : ℍ) = 1 := b.property.1 + noncomm_ring [hb] + rw [he, norm_neg, norm_mul, su2_inverse_distance, pow_two] + +/-- Replacing each displacement by its linear model introduces only the sum +of the errors. Combined with exact signed counts, this avoids any choice of +an ordering of the relator indices (which can be uncountable). -/ +theorem unit_product_with_linear_models {I : Type*} (l : List I) + (f : I → SU2) (v : I → ℍ) (h D : ℝ) (hh : 0 ≤ h) + (hb : ∀ i ∈ l, ‖(f i : ℍ) - 1‖ ≤ h) + (he : ∀ i ∈ l, ‖(f i : ℍ) - 1 - v i‖ ≤ D) : + ‖((l.map (fun i => (f i : ℍ))).prod - 1) - (l.map v).sum‖ ≤ + (l.length : ℝ)^2 * h^2 + l.length * D := by + have hp := (unit_product_linearization (l.map (fun i => (f i : ℍ))) h hh + (by intro a ha; obtain ⟨i, _, rfl⟩ := List.mem_map.mp ha; exact su2_norm _) + (by intro a ha; obtain ⟨i, hi, rfl⟩ := List.mem_map.mp ha; exact hb i hi)).2 + simp only [List.length_map, List.map_map, Function.comp_def] at hp + have hs : ∀ l : List I, (∀ i ∈ l, ‖(f i : ℍ) - 1 - v i‖ ≤ D) → + ‖(l.map (fun i => (f i : ℍ) - 1)).sum - (l.map v).sum‖ ≤ l.length * D := by + intro l he + induction l with + | nil => simp + | cons i l ih => + have hi := he i (by simp) + have hrest := ih (fun j hj => he j (by simp [hj])) + simp only [List.map_cons, List.sum_cons, List.length_cons, Nat.cast_add, Nat.cast_one] + have heq : (f i : ℍ) - 1 + (l.map (fun j => (f j : ℍ) - 1)).sum - + (v i + (l.map v).sum) = ((f i : ℍ) - 1 - v i) + + ((l.map (fun j => (f j : ℍ) - 1)).sum - (l.map v).sum) := by abel + rw [heq] + exact (norm_add_le _ _).trans (by linarith) + + calc + _ ≤ ‖((l.map (fun i => (f i : ℍ))).prod - 1) - (l.map (fun i => (f i : ℍ) - 1)).sum‖ + + ‖(l.map (fun i => (f i : ℍ) - 1)).sum - (l.map v).sum‖ := norm_sub_le_norm_sub_add_norm_sub _ _ _ + _ ≤ _ := add_le_add hp (hs l he) +end EilenbergGanea + +namespace EilenbergGanea +open scoped Quaternion + +theorem su2_conjugation_distance (a b : SU2) : + ‖((a * b * a⁻¹ : SU2) : ℍ) - 1‖ = ‖(b : ℍ) - 1‖ := by + have he : ((a * b * a⁻¹ : SU2) : ℍ) - 1 = + (a : ℍ) * ((b : ℍ) - 1) * star (a : ℍ) := by + change (a : ℍ) * (b : ℍ) * star (a : ℍ) - 1 = _ + rw [mul_sub, sub_mul, mul_one, a.property.2] + rw [he, norm_mul, norm_mul, norm_star, su2_norm, one_mul, mul_one] + +def signedUnit (b : SU2) (ε : Bool) : SU2 := if ε then b else b⁻¹ +def signedDisplacement (b : SU2) (ε : Bool) : ℍ := if ε then (b : ℍ) - 1 else -((b : ℍ) - 1) + + theorem signedUnit_distance (b : SU2) (ε : Bool) : + ‖(signedUnit b ε : ℍ) - 1‖ = ‖(b : ℍ) - 1‖ := by + cases ε <;> simp [signedUnit, su2_inverse_distance] + + theorem signedUnit_error (b : SU2) (ε : Bool) : + ‖(signedUnit b ε : ℍ) - 1 - signedDisplacement b ε‖ ≤ ‖(b : ℍ) - 1‖^2 := by + cases ε with + | false => + change ‖((b⁻¹ : SU2) : ℍ) - 1 - (-((b : ℍ) - 1))‖ ≤ _ + simpa only [sub_neg_eq_add] using su2_inverse_linearization b + | true => simp [signedUnit, signedDisplacement] + + theorem conjugated_signedUnit_error (a b : SU2) (ε : Bool) (A h : ℝ) + (hA : 0 ≤ A) (hh : 0 ≤ h) (ha : ‖(a : ℍ) - 1‖ ≤ A) (hb : ‖(b : ℍ) - 1‖ ≤ h) : + ‖((a * signedUnit b ε * a⁻¹ : SU2) : ℍ) - 1 - signedDisplacement b ε‖ ≤ + 2 * A * h + h^2 := by + have he : ((a * signedUnit b ε * a⁻¹ : SU2) : ℍ) - 1 - signedDisplacement b ε = + (((a * signedUnit b ε * a⁻¹ : SU2) : ℍ) - (signedUnit b ε : ℍ)) + + ((signedUnit b ε : ℍ) - 1 - signedDisplacement b ε) := by abel + rw [he] + have hsq : ‖(b : ℍ) - 1‖^2 ≤ h^2 := by nlinarith [norm_nonneg ((b : ℍ) - 1)] + calc + _ ≤ ‖((a * signedUnit b ε * a⁻¹ : SU2) : ℍ) - (signedUnit b ε : ℍ)‖ + + ‖(signedUnit b ε : ℍ) - 1 - signedDisplacement b ε‖ := norm_add_le _ _ + _ ≤ 2 * ‖(a : ℍ) - 1‖ * ‖(b : ℍ) - 1‖ + ‖(b : ℍ) - 1‖^2 := by + simpa only [signedUnit_distance] using add_le_add (su2_conjugation_error a (signedUnit b ε)) (signedUnit_error b ε) + _ ≤ _ := add_le_add (mul_le_mul (mul_le_mul_of_nonneg_left ha (by positivity)) hb + (norm_nonneg _) (mul_nonneg (by positivity) hA)) hsq + +abbrev RelatorFactor (I : Type*) := SU2 × I × Bool + +def relatorFactorValue {I : Type*} (x : I → SU2) (r : RelatorFactor I) : SU2 := + r.1 * signedUnit (x r.2.1) r.2.2 * r.1⁻¹ + +def relatorSignedCounts {I : Type*} (l : List (RelatorFactor I)) : I →₀ ℤ := + (l.map (fun r => Finsupp.single r.2.1 (if r.2.2 then 1 else -1))).sum + + theorem relator_linear_models {I : Type*} (l : List (RelatorFactor I)) (x : I → SU2) : + (l.map (fun r => signedDisplacement (x r.2.1) r.2.2)).sum = + Finsupp.linearCombination ℤ (fun i => (x i : ℍ) - 1) (relatorSignedCounts l) := by + induction l with + | nil => simp [relatorSignedCounts] + | cons r l ih => + simp only [List.map_cons, List.sum_cons, relatorSignedCounts, map_add, Finsupp.linearCombination_single] + rw [← show Finsupp.linearCombination ℤ (fun i => (x i : ℍ) - 1) + ((l.map (fun r => Finsupp.single r.2.1 (if r.2.2 then 1 else -1))).sum) = + (l.map (fun r => signedDisplacement (x r.2.1) r.2.2)).sum from ih.symm] + congr 2 + cases r.2.2 <;> simp [signedDisplacement] + +/-- Exact translated counts cancel the full linear term; the remaining bound +is quadratic. The index set is arbitrary, not necessarily countable. -/ +theorem relator_product_quadratic {I : Type*} (l : List (RelatorFactor I)) (x : I → SU2) + (i₀ : I) (hc : relatorSignedCounts l = Finsupp.single i₀ 1) + (h ε K : ℝ) (hh : 0 ≤ h) (hε : 0 ≤ ε) (hK : 0 ≤ K) + (hb : ∀ r ∈ l, ‖(x r.2.1 : ℍ) - 1‖ ≤ h) + (ha : ∀ r ∈ l, ‖(r.1 : ℍ) - 1‖ ≤ K * (ε + h)) : + ‖(l.map (fun r => (relatorFactorValue x r : ℍ))).prod - (x i₀ : ℍ)‖ ≤ + ((l.length : ℝ)^2 + l.length + 2 * l.length * K) * (ε + h) * h := by + have hp := unit_product_with_linear_models l (relatorFactorValue x) + (fun r => signedDisplacement (x r.2.1) r.2.2) h + (2 * (K * (ε + h)) * h + h^2) hh + (fun r hr => by rw [relatorFactorValue, su2_conjugation_distance, signedUnit_distance]; exact hb r hr) + (fun r hr => conjugated_signedUnit_error r.1 (x r.2.1) r.2.2 _ h + (mul_nonneg hK (add_nonneg hε hh)) hh (ha r hr) (hb r hr)) + rw [relator_linear_models, hc, Finsupp.linearCombination_single, one_smul] at hp + have he : (l.map (fun r => (relatorFactorValue x r : ℍ))).prod - 1 - ((x i₀ : ℍ) - 1) = + (l.map (fun r => (relatorFactorValue x r : ℍ))).prod - (x i₀ : ℍ) := by abel + rw [he] at hp + apply hp.trans + have hlen : 0 ≤ (l.length : ℝ) := Nat.cast_nonneg _ + have hnh : 0 ≤ ((l.length : ℝ)^2 + l.length) * ε * h := + mul_nonneg (mul_nonneg (add_nonneg (sq_nonneg _) hlen) hε) hh + nlinarith +end EilenbergGanea + +namespace EilenbergGanea + +/-- A uniform size for an arbitrary family, normalized to zero for an empty +index set. This is a real supremum, not an attained maximum. -/ +def familySize {I : Type*} (f : I → ℝ) : ℝ := sSup (Set.range f ∪ {0}) + + theorem familySize_nonneg {I : Type*} (f : I → ℝ) (hf : BddAbove (Set.range f)) : + 0 ≤ familySize f := by + apply le_csSup (hf.union bddAbove_singleton) + exact Or.inr (Set.mem_singleton _) + + theorem le_familySize {I : Type*} (f : I → ℝ) (hf : BddAbove (Set.range f)) (i : I) : + f i ≤ familySize f := le_csSup (hf.union bddAbove_singleton) (Or.inl (Set.mem_range_self i)) + + theorem familySize_le {I : Type*} (f : I → ℝ) {c : ℝ} (hc : 0 ≤ c) (hf : ∀ i, f i ≤ c) : + familySize f ≤ c := by + apply csSup_le (Set.union_nonempty.mpr (Or.inr (Set.singleton_nonempty 0))) + rintro x (⟨i, rfl⟩ | rfl) + · exact hf i + · exact hc + +/-- The source no-threshold-crossing argument does not assume attainment of +its supremum. -/ + theorem familySize_ne_threshold {I : Type*} (f : I → ℝ) + (hf : BddAbove (Set.range f)) (C δ η ε : ℝ) + (hδ : 0 < δ) (hC : 0 ≤ C) (_hη : 0 ≤ η) (hε : 0 ≤ ε) (hεη : ε ≤ η) + (hc₁ : C * (δ + η) < 1/2) (hc₂ : C * η < δ/2) + (hbound : ∀ i, f i ≤ C * ε + C * (familySize f + ε) * familySize f) : + familySize f ≠ δ := by + intro he + have hs : familySize f ≤ C * ε + C * (familySize f + ε) * familySize f := + familySize_le f (by positivity [familySize_nonneg f hf]) hbound + rw [he] at hs + have hce : C * ε ≤ C * η := mul_le_mul_of_nonneg_left hεη hC + have hfactor : C * (δ + ε) ≤ C * (δ + η) := mul_le_mul_of_nonneg_left (by linarith) hC + nlinarith [mul_lt_mul_of_pos_right hc₁ hδ, mul_le_mul_of_nonneg_right hfactor hδ.le] + +/-- Uniform contraction of all residual errors. This handles even an +uncountable family and does not replace the supremum by a maximum. -/ + theorem familySize_contraction {I : Type*} (f : I → ℝ) + (hf : ∀ i, 0 ≤ f i) (δ C η : ℝ) (hδ : 0 ≤ δ) (hC : 0 ≤ C) (hη : 0 ≤ η) + (hb : ∀ i, f i ≤ δ) (hc : C * (δ + η) < 1) + (he : ∀ i, f i ≤ C * (familySize f + η) * familySize f) : ∀ i, f i = 0 := by + have hbounded : BddAbove (Set.range f) := ⟨δ, by rintro _ ⟨i, rfl⟩; exact hb i⟩ + have h0 := familySize_nonneg f hbounded + have hmax := familySize_le f hδ hb + have hs := familySize_le f (c := C * (familySize f + η) * familySize f) (by positivity) he + have hmul : C * (familySize f + η) ≤ C * (δ + η) := + mul_le_mul_of_nonneg_left (by linarith) hC + have heq : familySize f = 0 := by + by_contra hn + have hp : 0 < familySize f := lt_of_le_of_ne h0 (Ne.symm hn) + have ht := mul_lt_mul_of_pos_right (lt_of_le_of_lt hmul hc) hp + nlinarith + intro i + exact le_antisymm (by simpa only [heq] using le_familySize f hbounded i) (hf i) + + theorem small_thresholds_exist (C : ℝ) (hC : 1 ≤ C) : + ∃ δ η : ℝ, 0 < δ ∧ δ < 1 ∧ 0 < η ∧ η < 1 ∧ + C * (δ + η) < 1/2 ∧ C * η < δ/2 := by + have hc : 0 < C := by linarith + let δ := 1 / (8*C) + let η := δ / (8*C) + have hd : 0 < δ := by dsimp [δ]; positivity + have hd1 : δ < 1 := by dsimp [δ]; apply (div_lt_iff₀ (by positivity)).mpr; linarith + have he : 0 < η := by dsimp [η]; positivity + have heδ : η < δ := by dsimp [η]; apply (div_lt_iff₀ (by positivity)).mpr; nlinarith + have hcd : C * δ = 1/8 := by dsimp [δ]; field_simp + have hce : C * η = δ/8 := by dsimp [η]; field_simp + refine ⟨δ, η, hd, hd1, he, heδ.trans hd1, ?_, ?_⟩ + · rw [mul_add, hcd, hce]; linarith + · rw [hce]; linarith +end EilenbergGanea + + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/UnitaryWords.lean b/lean/OAI/Topology/EilenbergGanea/UnitaryWords.lean new file mode 100644 index 0000000000000000000000000000000000000000..7e8a3f310b9e1b7d6b49618c1b724ee95b0de63e --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/UnitaryWords.lean @@ -0,0 +1,890 @@ +import OAI.Topology.EilenbergGanea.Regularization +import Mathlib.Analysis.Quaternion +import Mathlib.Analysis.Complex.Circle +import Mathlib.Analysis.Complex.Polynomial.Basic +import Mathlib.Analysis.Calculus.Deriv.ZPow +import Mathlib.GroupTheory.FreeGroup.Basic +import Mathlib.Analysis.SpecialFunctions.SmoothTransition + +namespace OAI + +noncomputable section + +open Set Filter Topology +open scoped Quaternion ContDiff + +open scoped Quaternion +namespace EilenbergGanea +abbrev SU2 := unitary ℍ + +theorem quaternion_mem_unitary_iff (q : ℍ) : q ∈ unitary ℍ ↔ ‖q‖ = 1 := by + rw [Unitary.mem_iff, Quaternion.star_mul_self, Quaternion.self_mul_star, and_self] + constructor + · intro h + have he : Quaternion.normSq q = 1 := Quaternion.coe_inj.mp h + rw [Quaternion.normSq_eq_norm_mul_self] at he + nlinarith [norm_nonneg q] + · intro h + simp [Quaternion.normSq_eq_norm_mul_self, h] + +instance su2_compactSpace : CompactSpace SU2 := by + apply isCompact_iff_compactSpace.mp + have hs : (unitary ℍ : Set ℍ) = Metric.sphere 0 1 := by + ext q + simp [quaternion_mem_unitary_iff] + rw [hs] + exact isCompact_sphere 0 1 + +def circleQuaternion : Circle →* SU2 where + toFun z := ⟨Quaternion.ofComplex z, by + rw [Unitary.mem_iff, Quaternion.star_mul_self, Quaternion.self_mul_star, and_self] + have hz := Circle.normSq_coe z + have he : Quaternion.normSq (Quaternion.ofComplex z) = 1 := by + simpa [Quaternion.normSq_def', Complex.normSq_apply, sq] using hz + rw [he]; rfl⟩ + map_one' := Subtype.ext (map_one Quaternion.ofComplex) + map_mul' z w := Subtype.ext (map_mul Quaternion.ofComplex (z : ℂ) (w : ℂ)) + +@[simp] theorem circleQuaternion_coe (z : Circle) : + ((circleQuaternion z : SU2) : ℍ) = (z : ℂ) := rfl + +theorem circleQuaternion_injective : Function.Injective circleQuaternion := by + intro z w h + apply Subtype.ext + apply Complex.ext + · exact congrArg (fun q : ℍ => q.re) (congrArg Subtype.val h) + · exact congrArg (fun q : ℍ => q.imI) (congrArg Subtype.val h) + +theorem circleQuaternion_continuous : Continuous circleQuaternion := by + apply Continuous.subtype_mk + exact Quaternion.ofComplex.toLinearMap.continuous_of_finiteDimensional.comp continuous_subtype_val + +def wordMap {m : ℕ} (w : Fin m → FreeGroup (Fin m)) (x : Fin m → SU2) : Fin m → SU2 := + fun i => FreeGroup.lift x (w i) + +def exponentMatrix {m : ℕ} (w : Fin m → FreeGroup (Fin m)) : Matrix (Fin m) (Fin m) ℤ := + fun i j => Multiplicative.toAdd + (FreeGroup.lift (fun k => Multiplicative.ofAdd (if j = k then (1 : ℤ) else 0)) (w i)) + +open Set Filter Topology +open scoped ContDiff + +/-- Radial normalization is only used on nonzero quaternions. The harmless +value at zero makes it a total function without changing that domain. -/ +def normalizeQuaternion (q : ℍ) : SU2 := by + classical + exact if h : q = 0 then 1 else + ⟨‖q‖⁻¹ • q, (quaternion_mem_unitary_iff _).mpr (by + simp only [norm_smul, Real.norm_eq_abs, abs_inv, abs_norm] + exact inv_mul_cancel₀ (norm_ne_zero_iff.mpr h))⟩ + +theorem normalizeQuaternion_coe_of_ne_zero {q : ℍ} (hq : q ≠ 0) : + (normalizeQuaternion q : ℍ) = ‖q‖⁻¹ • q := by simp [normalizeQuaternion, hq] + +theorem normalizeQuaternion_coe_contDiffAt {q : ℍ} (hq : q ≠ 0) : + ContDiffAt ℝ ∞ (fun z => (normalizeQuaternion z : ℍ)) q := by + have h : ContDiffAt ℝ ∞ (fun z : ℍ => ‖z‖⁻¹ • z) q := + ((contDiffAt_norm ℝ hq).inv (norm_ne_zero_iff.mpr hq)).smul contDiffAt_id + apply h.congr_of_eventuallyEq + filter_upwards [eventually_ne_nhds hq] with z hz + exact normalizeQuaternion_coe_of_ne_zero hz + +theorem normalizeQuaternion_continuousAt {q : ℍ} (hq : q ≠ 0) : + ContinuousAt normalizeQuaternion q := by + exact tendsto_subtype_rng.mpr (normalizeQuaternion_coe_contDiffAt hq).continuousAt + +@[simp] theorem normalizeQuaternion_unitary (q : SU2) : normalizeQuaternion (q : ℍ) = q := by + have hqnorm : ‖(q : ℍ)‖ = 1 := (quaternion_mem_unitary_iff _).mp q.property + have hq : (q : ℍ) ≠ 0 := by intro he; simp [he] at hqnorm + apply Subtype.ext + simp [normalizeQuaternion_coe_of_ne_zero hq, hqnorm] + +/-- Smoothness of coefficient-free word evaluation follows directly by +induction, using quaternion conjugation for unitary inverses. -/ +theorem freeGroup_lift_coe_contDiffAt {D ι : Type*} + [NormedAddCommGroup D] [NormedSpace ℝ D] (w : FreeGroup ι) + (a : D) (x : D → ι → SU2) + (hx : ∀ i, ContDiffAt ℝ ∞ (fun z => (x z i : ℍ)) a) : + ContDiffAt ℝ ∞ (fun z => ((FreeGroup.lift (x z) w : SU2) : ℍ)) a := by + induction w using FreeGroup.induction_on with + | one => simpa using (contDiffAt_const : ContDiffAt ℝ ∞ (fun _ : D => (1 : ℍ)) a) + | of i => simpa using hx i + | inv_of i hi => + simp only [map_inv] + change ContDiffAt ℝ ∞ (fun z => star ((FreeGroup.lift (x z) (FreeGroup.of i) : SU2) : ℍ)) a + let L : ℍ →ₗ[ℝ] ℍ := + { toFun := star + map_add' := star_add + map_smul' := Quaternion.star_smul } + exact L.toContinuousLinearMap.contDiff.contDiffAt.comp a hi + | mul v w hv hw => simpa only [map_mul, Submonoid.coe_mul] using hv.mul hw + +def radialWordMap {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℍ) : Fin m → ℍ := + fun i => ‖x i‖ • ((wordMap w (fun j => normalizeQuaternion (x j)) i : SU2) : ℍ) + +@[simp] theorem radialWordMap_norm {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℍ) (i : Fin m) : ‖radialWordMap w x i‖ = ‖x i‖ := by + have h : ‖((wordMap w (fun j => normalizeQuaternion (x j)) i : SU2) : ℍ)‖ = 1 := + (quaternion_mem_unitary_iff _).mp (wordMap w (fun j => normalizeQuaternion (x j)) i).property + simp [radialWordMap, norm_smul, h] + +theorem radialWordMap_contDiffAt {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℍ) (hx : ∀ i, x i ≠ 0) : ContDiffAt ℝ ∞ (radialWordMap w) x := by + apply contDiffAt_pi.mpr + intro i + exact ((contDiffAt_apply ℝ ℍ i x).norm ℝ (hx i)).smul + (freeGroup_lift_coe_contDiffAt (w i) x (fun z j => normalizeQuaternion (z j)) + (fun j => (normalizeQuaternion_coe_contDiffAt (hx j)).comp (f := fun z : Fin m → ℍ => z j) x (contDiffAt_apply ℝ ℍ j x))) + +theorem radialWordMap_eq_one_iff {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℍ) : radialWordMap w x = 1 ↔ + (∀ i, ‖x i‖ = 1) ∧ wordMap w (fun j => normalizeQuaternion (x j)) = 1 := by + constructor + · intro h + have hn (i : Fin m) : ‖x i‖ = 1 := by + have he := congrArg (fun y : Fin m → ℍ => ‖y i‖) h + simpa only [radialWordMap_norm, Pi.one_apply, norm_one] using he + refine ⟨hn, ?_⟩ + funext i + apply Subtype.ext + have he := congrFun h i + simpa [radialWordMap, hn] using he + · rintro ⟨hn, hw⟩ + funext i + simp [radialWordMap, hn, hw] + + +/-- A conjugation-invariant smooth cutoff, zero near coordinate hyperplanes +and one near the unit quaternion locus. -/ +def radialCutoff {m : ℕ} (x : Fin m → ℍ) : ℝ := + ∏ i, Real.smoothTransition (4 * ‖x i‖ ^ 2 - 1) + +def smoothRadialWordMap {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℍ) : Fin m → ℍ := radialCutoff x • radialWordMap w x + +theorem radialCutoff_contDiff {m : ℕ} : ContDiff ℝ ∞ (@radialCutoff m) := by + apply contDiff_prod + intro i _ + have hn : ContDiff ℝ ∞ (fun x : Fin m → ℍ => ‖x i‖ ^ 2) := + (contDiff_apply ℝ ℍ i).norm_sq ℝ + exact Real.smoothTransition.contDiff.comp ((contDiff_const.mul hn).sub contDiff_const) + +theorem radialCutoff_nonneg {m : ℕ} (x : Fin m → ℍ) : 0 ≤ radialCutoff x := + Finset.prod_nonneg (fun _ _ => Real.smoothTransition.nonneg _) + +theorem radialCutoff_le_one {m : ℕ} (x : Fin m → ℍ) : radialCutoff x ≤ 1 := + Finset.prod_le_one₀ (fun _ _ => Real.smoothTransition.nonneg _) + (fun _ _ => Real.smoothTransition.le_one _) + +theorem radialCutoff_eq_one {m : ℕ} (x : Fin m → ℍ) (hx : ∀ i, 1 ≤ ‖x i‖) : + radialCutoff x = 1 := by + apply Finset.prod_eq_one + intro i _ + apply Real.smoothTransition.one_of_one_le + nlinarith [hx i] + +theorem radialCutoff_eventually_zero {m : ℕ} (x : Fin m → ℍ) (i : Fin m) + (hi : x i = 0) : radialCutoff =ᶠ[𝓝 x] (fun _ => 0) := by + have h : ∀ᶠ y in 𝓝 x, ‖y i‖ < (1 / 2 : ℝ) := + ((continuous_apply i).norm.continuousAt.eventually_lt_const (by simp [hi])) + filter_upwards [h] with y hy + apply Finset.prod_eq_zero (Finset.mem_univ i) + apply Real.smoothTransition.zero_of_nonpos + nlinarith [norm_nonneg (y i)] + +theorem radialCutoff_eventually_one {m : ℕ} (x : Fin m → ℍ) + (hx : ∀ i, ‖x i‖ = 1) : radialCutoff =ᶠ[𝓝 x] (fun _ => 1) := by + have h (i : Fin m) : ∀ᶠ y in 𝓝 x, (3 / 4 : ℝ) < ‖y i‖ := + ((continuous_apply i).norm.continuousAt.eventually_const_lt (by change (3 / 4 : ℝ) < ‖x i‖; rw [hx i]; norm_num)) + filter_upwards [Filter.eventually_all.mpr h] with y hy + apply Finset.prod_eq_one + intro i _ + apply Real.smoothTransition.one_of_one_le + nlinarith [hy i] + +theorem smoothRadialWordMap_contDiff {m : ℕ} (w : Fin m → FreeGroup (Fin m)) : + ContDiff ℝ ∞ (smoothRadialWordMap w) := by + rw [contDiff_iff_contDiffAt] + intro x + by_cases hx : ∀ i, x i ≠ 0 + · exact radialCutoff_contDiff.contDiffAt.smul (radialWordMap_contDiffAt w x hx) + · push Not at hx + obtain ⟨i, hi⟩ := hx + apply (contDiffAt_const : ContDiffAt ℝ ∞ (fun _ : Fin m → ℍ => (0 : Fin m → ℍ)) x).congr_of_eventuallyEq + filter_upwards [radialCutoff_eventually_zero x i hi] with y hy + simp [smoothRadialWordMap, hy] + +theorem smoothRadialWordMap_eq_one_iff {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℍ) : smoothRadialWordMap w x = 1 ↔ radialWordMap w x = 1 := by + constructor + · intro h + have hn (i : Fin m) : radialCutoff x * ‖x i‖ = 1 := by + have he := congrArg (fun y : Fin m → ℍ => ‖y i‖) h + simpa only [smoothRadialWordMap, Pi.smul_apply, norm_smul, Real.norm_eq_abs, + abs_of_nonneg (radialCutoff_nonneg x), radialWordMap_norm, Pi.one_apply, norm_one] using he + have hlarge (i : Fin m) : 1 ≤ ‖x i‖ := by + have hle := mul_le_mul_of_nonneg_right (radialCutoff_le_one x) (norm_nonneg (x i)) + rw [hn i, one_mul] at hle + exact hle + simpa only [smoothRadialWordMap, radialCutoff_eq_one x hlarge, one_smul] using h + · intro h + have hn := (radialWordMap_eq_one_iff w x).mp h + simp only [smoothRadialWordMap, radialCutoff_eq_one x (fun i => (hn.1 i).ge), one_smul, h] + +theorem smoothRadialWordMap_eventuallyEq {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℍ) (hx : ∀ i, ‖x i‖ = 1) : + smoothRadialWordMap w =ᶠ[𝓝 x] radialWordMap w := by + filter_upwards [radialCutoff_eventually_one x hx] with y hy + simp [smoothRadialWordMap, hy] + +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +variable {n : Type*} [Fintype n] [DecidableEq n] + +def splitComplex : (n → ℂ) ≃ₗ[ℝ] ((n → ℝ) × (n → ℝ)) where + toFun z := (fun i => (z i).re, fun i => (z i).im) + invFun p i := (p.1 i : ℂ) + (p.2 i : ℂ) * Complex.I + left_inv z := by funext i; exact Complex.re_add_im (z i) + right_inv p := by ext i <;> simp + map_add' a b := by ext i <;> simp + map_smul' a b := by ext i <;> simp + +def radialAngularLinear (B : Matrix n n ℝ) : (n → ℂ) →L[ℝ] (n → ℂ) := + ((splitComplex (n := n)).symm.toLinearMap.comp + (((LinearMap.id : (n → ℝ) →ₗ[ℝ] (n → ℝ)).prodMap B.toLin').comp + (splitComplex (n := n)).toLinearMap)).toContinuousLinearMap + +@[simp] theorem radialAngularLinear_apply (B : Matrix n n ℝ) (z : n → ℂ) (i : n) : + radialAngularLinear B z i = ((z i).re : ℂ) + (∑ j, B i j * (z j).im : ℝ) * Complex.I := rfl + +theorem radialAngularLinear_det (B : Matrix n n ℝ) : + (radialAngularLinear B).toLinearMap.det = B.det := by + change LinearMap.det ((splitComplex (n := n)).symm.toLinearMap ∘ₗ + ((LinearMap.id : (n → ℝ) →ₗ[ℝ] (n → ℝ)).prodMap B.toLin') ∘ₗ + (splitComplex (n := n)).toLinearMap) = _ + have he := LinearMap.det_conj + ((LinearMap.id : (n → ℝ) →ₗ[ℝ] (n → ℝ)).prodMap B.toLin') + (splitComplex (n := n)).symm + rw [LinearEquiv.symm_symm] at he + rw [he, LinearMap.det_prodMap, LinearMap.det_id, one_mul, LinearMap.det_toLin'] + +def complexPolarChart (x z : n → ℂ) : n → ℂ := fun i => x i * Complex.exp (z i) + +def complexRadialTorus (B : Matrix n n ℤ) (z : n → ℂ) : n → ℂ := + fun i => ‖z i‖ • ∏ j, (‖z j‖⁻¹ • z j) ^ B i j + +theorem normalize_complex_mul_exp (x z : ℂ) (hx : ‖x‖ = 1) : + ‖x * Complex.exp z‖⁻¹ • (x * Complex.exp z) = + x * Complex.exp ((z.im : ℂ) * Complex.I) := by + rw [norm_mul, hx, one_mul, Complex.norm_exp, Complex.real_smul, Complex.ofReal_inv] + have he : Complex.exp z = (Real.exp z.re : ℂ) * + Complex.exp ((z.im : ℂ) * Complex.I) := by + rw [Complex.ofReal_exp, ← Complex.exp_add, Complex.re_add_im] + rw [he] + have hn : (Real.exp z.re : ℂ) ≠ 0 := by exact_mod_cast Real.exp_ne_zero z.re + field_simp + + theorem complexRadialTorus_chart (B : Matrix n n ℤ) (x : n → ℂ) + (hx : ∀ i, ‖x i‖ = 1) (hroot : ∀ i, ∏ j, x j ^ B i j = 1) : + complexRadialTorus B ∘ complexPolarChart x = + fun z => fun i => Complex.exp (radialAngularLinear (B.map (Int.castRingHom ℝ)) z i) := by + funext z i + have hn (j : n) := normalize_complex_mul_exp (x j) (z j) (hx j) + simp only [Function.comp_apply, complexRadialTorus, complexPolarChart] + simp only [hn] + simp only [mul_zpow, Finset.prod_mul_distrib, + hroot, one_mul, norm_mul, hx, one_mul, Complex.norm_exp, radialAngularLinear_apply, + ← Complex.exp_int_mul] + rw [Complex.real_smul, Complex.ofReal_exp, ← Complex.exp_sum, ← Complex.exp_add] + congr 1 + simp only [Matrix.map_apply, Int.coe_castRingHom, Complex.ofReal_sum, + Complex.ofReal_mul, Complex.ofReal_intCast] + rw [Finset.sum_mul] + congr 1 + apply Finset.sum_congr rfl + intro j _ + ring + + +/-- The real derivative of multiplication by a unit complex tuple has determinant one. -/ +def complexDiagonal (x : n → ℂ) : (n → ℂ) →L[ℝ] (n → ℂ) := + ((Matrix.diagonal x).toLin').toContinuousLinearMap.restrictScalars ℝ + +@[simp] theorem complexDiagonal_apply (x z : n → ℂ) (i : n) : + complexDiagonal x z i = x i * z i := by simp [complexDiagonal, Matrix.toLin'_apply, Matrix.mulVec, Matrix.diagonal_apply, dotProduct] + +theorem complexDiagonal_det (x : n → ℂ) (hx : ∀ i, ‖x i‖ = 1) : + (complexDiagonal x).toLinearMap.det = 1 := by + change (((Matrix.diagonal x).toLin').restrictScalars ℝ).det = _ + rw [LinearMap.det_restrictScalars, Algebra.norm_complex_apply, LinearMap.det_toLin', + Matrix.det_diagonal] + rw [Complex.normSq_eq_norm_sq, norm_prod] + simp [hx] + +theorem complexPolarChart_hasFDerivAt (x : n → ℂ) : + HasFDerivAt (complexPolarChart x) (complexDiagonal x) 0 := by + apply hasFDerivAt_pi'.mpr + intro i + have h := ((ContinuousLinearMap.proj i : (n → ℂ) →L[ℝ] ℂ).hasFDerivAt + (x := 0)).cexp.const_mul (x i) + change HasFDerivAt (fun z : n → ℂ => x i * Complex.exp (z i)) _ (0 : n → ℂ) + have he : (ContinuousLinearMap.proj i : (n → ℂ) →L[ℝ] ℂ).comp (complexDiagonal x) = + x i • (ContinuousLinearMap.proj i : (n → ℂ) →L[ℝ] ℂ) := by + ext z + simp + rw [he] + simpa using h + +theorem exp_radialAngularLinear_hasFDerivAt (B : Matrix n n ℝ) : + HasFDerivAt (fun z i => Complex.exp (radialAngularLinear B z i)) + (radialAngularLinear B) 0 := by + apply hasFDerivAt_pi'.mpr + intro i + simpa using (((ContinuousLinearMap.proj i : (n → ℂ) →L[ℝ] ℂ).comp + (radialAngularLinear B)).hasFDerivAt (x := 0)).cexp + +theorem complexRadialTorus_differentiableAt (B : Matrix n n ℤ) (x : n → ℂ) + (hx : ∀ i, x i ≠ 0) : DifferentiableAt ℝ (complexRadialTorus B) x := by + apply differentiableAt_pi.mpr + intro i + have hn (j : n) : DifferentiableAt ℝ (fun z : n → ℂ => ‖z j‖) x := + (differentiableAt_apply j x).norm ℝ (hx j) + apply (hn i).smul + have hp (j : n) : DifferentiableAt ℝ (fun z : n → ℂ => (‖z j‖⁻¹ • z j) ^ B i j) x := by + have hne : ‖x j‖⁻¹ • x j ≠ 0 := + smul_ne_zero (inv_ne_zero (norm_ne_zero_iff.mpr (hx j))) (hx j) + have hz : DifferentiableAt ℝ (fun z : ℂ => z ^ B i j) (‖x j‖⁻¹ • x j) := + ((differentiableAt_zpow (𝕜 := ℂ) (m := B i j)).mpr (Or.inl hne)).restrictScalars ℝ + exact hz.comp x (((hn j).inv (norm_ne_zero_iff.mpr (hx j))).smul + (differentiableAt_apply j x)) + exact (HasFDerivAt.finsetProd (fun j _ => (hp j).hasFDerivAt)).differentiableAt + +/-- At every torus root, the radial extension has exactly determinant det B. +The extra radial coordinates contribute the identity, not an additional sign. -/ +theorem complexRadialTorus_det (B : Matrix n n ℤ) (x : n → ℂ) + (hx : ∀ i, ‖x i‖ = 1) (hroot : ∀ i, ∏ j, x j ^ B i j = 1) : + (fderiv ℝ (complexRadialTorus B) x).det = (B.det : ℝ) := by + have hne (i : n) : x i ≠ 0 := by intro h; simpa [h] using hx i + have hd := (complexRadialTorus_differentiableAt B x hne).hasFDerivAt + have hchart : complexPolarChart x 0 = x := by ext i; simp [complexPolarChart] + have hc := (show HasFDerivAt (complexRadialTorus B) (fderiv ℝ (complexRadialTorus B) x) + (complexPolarChart x 0) by rw [hchart]; exact hd).comp 0 (complexPolarChart_hasFDerivAt x) + have he : (fderiv ℝ (complexRadialTorus B) x).comp (complexDiagonal x) = + radialAngularLinear (B.map (Int.castRingHom ℝ)) := by + apply hc.unique + rw [complexRadialTorus_chart B x hx hroot] + exact exp_radialAngularLinear_hasFDerivAt _ + have hdet := congrArg (fun L : (n → ℂ) →L[ℝ] (n → ℂ) => L.det) he + change ((fderiv ℝ (complexRadialTorus B) x).toLinearMap.comp + (complexDiagonal x).toLinearMap).det = (radialAngularLinear (B.map (Int.castRingHom ℝ))).toLinearMap.det at hdet + rw [LinearMap.det_comp, complexDiagonal_det x hx, + mul_one, radialAngularLinear_det] at hdet + exact hdet.trans ((Int.castRingHom ℝ).map_det B).symm + +end EilenbergGanea +namespace EilenbergGanea +section CommutativeWords +variable {n A : Type*} [Fintype n] [DecidableEq n] [CommGroup A] +def wordExponents {ι : Type*} [DecidableEq ι] (w : FreeGroup ι) (j : ι) : ℤ := + Multiplicative.toAdd + (FreeGroup.lift (fun k => Multiplicative.ofAdd (if j = k then (1 : ℤ) else 0)) w) + +@[simp] theorem wordExponents_one {ι : Type*} [DecidableEq ι] (j : ι) : wordExponents (1 : FreeGroup ι) j = 0 := by + simp [wordExponents] + +@[simp] theorem wordExponents_of {ι : Type*} [DecidableEq ι] (j k : ι) : + wordExponents (FreeGroup.of k) j = if j = k then 1 else 0 := by + simp [wordExponents] + +@[simp] theorem wordExponents_inv {ι : Type*} [DecidableEq ι] (w : FreeGroup ι) (j : ι) : + wordExponents w⁻¹ j = -wordExponents w j := by + simp [wordExponents] + +@[simp] theorem wordExponents_mul {ι : Type*} [DecidableEq ι] (w v : FreeGroup ι) (j : ι) : + wordExponents (w * v) j = wordExponents w j + wordExponents v j := by + simp [wordExponents] + +theorem freeGroup_lift_commutative (x : n → A) (w : FreeGroup n) : + FreeGroup.lift x w = ∏ j, x j ^ wordExponents w j := by + induction w using FreeGroup.induction_on with + | one => simp + | of i => simp + | inv_of i hi => simp [hi, Finset.prod_inv_distrib] + | mul a b ha hb => simp [ha, hb, zpow_add, Finset.prod_mul_distrib] + +end CommutativeWords +end EilenbergGanea +namespace EilenbergGanea +open Set Filter Topology +open scoped Quaternion ContDiff + +def quaternionCoordinates : ℍ ≃ₗ[ℝ] ℂ × ℂ where + toFun q := (⟨q.re, q.imI⟩, ⟨q.imJ, q.imK⟩) + invFun z := ⟨z.1.re, z.1.im, z.2.re, z.2.im⟩ + left_inv q := by cases q; rfl + right_inv z := by rcases z with ⟨⟨a,b⟩,⟨c,d⟩⟩; rfl + map_add' q r := by ext <;> rfl + map_smul' r q := by apply Prod.ext <;> apply Complex.ext <;> simp + +@[simp] theorem quaternionCoordinates_apply (q : ℍ) : + quaternionCoordinates q = (⟨q.re, q.imI⟩, ⟨q.imJ, q.imK⟩) := rfl + +@[simp] theorem quaternionCoordinates_ofComplex (z : ℂ) : + quaternionCoordinates (Quaternion.ofComplex z) = (z, 0) := by + ext <;> rfl + +@[simp] theorem norm_quaternion_ofComplex (z : ℂ) : ‖Quaternion.ofComplex z‖ = ‖z‖ := by + have h : ‖Quaternion.ofComplex z‖ ^ 2 = ‖z‖ ^ 2 := by + rw [sq, ← Quaternion.normSq_eq_norm_mul_self, ← Complex.normSq_eq_norm_sq] + simp [Quaternion.normSq_def', Complex.normSq_apply, sq] + nlinarith [norm_nonneg (Quaternion.ofComplex z), norm_nonneg z] + +def quaternionTupleCoordinates {m : ℕ} : + (Fin m → ℍ) ≃L[ℝ] ((Fin m → ℂ) × (Fin m → ℂ)) := + (show (Fin m → ℍ) ≃ₗ[ℝ] ((Fin m → ℂ) × (Fin m → ℂ)) from + { toFun := fun q => (fun i => (quaternionCoordinates (q i)).1, + fun i => (quaternionCoordinates (q i)).2) + invFun := fun z i => quaternionCoordinates.symm (z.1 i, z.2 i) + left_inv := by intro q; funext i; exact quaternionCoordinates.symm_apply_apply _ + right_inv := by intro z; ext i <;> simp + map_add' := by intro q r; ext i <;> rfl + map_smul' := by intro r q; ext i <;> simp [quaternionCoordinates] }).toContinuousLinearEquiv + +@[simp] theorem quaternionTupleCoordinates_fixed {m : ℕ} (z : Fin m → ℂ) : + quaternionTupleCoordinates (fun i => Quaternion.ofComplex (z i)) = (z, 0) := by + apply Prod.ext + · funext i; exact congrArg Prod.fst (quaternionCoordinates_ofComplex (z i)) + · funext i; exact congrArg Prod.snd (quaternionCoordinates_ofComplex (z i)) + +@[simp] theorem quaternionTupleCoordinates_symm_fixed {m : ℕ} (z : Fin m → ℂ) : + quaternionTupleCoordinates.symm (z, 0) = fun i => Quaternion.ofComplex (z i) := by + exact quaternionTupleCoordinates.injective (by rw [ContinuousLinearEquiv.apply_symm_apply, quaternionTupleCoordinates_fixed]) + +/-- Circle normalization chosen compatibly with quaternion normalization. -/ +def normalizeCircle (z : ℂ) : Circle := by + classical + exact if hz : z = 0 then 1 else ⟨‖z‖⁻¹ • z, by apply mem_sphere_zero_iff_norm.mpr; simp [hz]⟩ + +theorem normalizeCircle_coe_of_ne_zero {z : ℂ} (hz : z ≠ 0) : + (normalizeCircle z : ℂ) = ‖z‖⁻¹ • z := by simp [normalizeCircle, hz] + +theorem normalizeQuaternion_ofComplex (z : ℂ) : + normalizeQuaternion (Quaternion.ofComplex z) = circleQuaternion (normalizeCircle z) := by + by_cases hz : z = 0 + · subst z + simp [normalizeQuaternion, normalizeCircle] + · have hq : Quaternion.ofComplex z ≠ 0 := by + intro h + have hh := congrArg quaternionCoordinates h + apply hz + have hz0 := congrArg Prod.fst hh + change (quaternionCoordinates (Quaternion.ofComplex z)).1 = (quaternionCoordinates (Quaternion.ofComplex 0)).1 at hz0 + simpa only [quaternionCoordinates_ofComplex] using hz0 + apply Subtype.ext + rw [normalizeQuaternion_coe_of_ne_zero hq, circleQuaternion_coe, + normalizeCircle_coe_of_ne_zero hz, norm_quaternion_ofComplex] + exact (map_smul Quaternion.ofComplex (‖z‖⁻¹) z).symm + +theorem wordMap_circleQuaternion {m : ℕ} (w : Fin m → FreeGroup (Fin m)) (x : Fin m → Circle) : + wordMap w (fun j => circleQuaternion (x j)) = + fun i => circleQuaternion (∏ j, x j ^ exponentMatrix w i j) := by + funext i + have he : FreeGroup.lift (fun j => circleQuaternion (x j)) = + circleQuaternion.comp (FreeGroup.lift x) := by + apply FreeGroup.ext_hom + intro j + simp + change FreeGroup.lift (fun j => circleQuaternion (x j)) (w i) = _ + rw [he, MonoidHom.comp_apply, freeGroup_lift_commutative] + rfl + +theorem radialWordMap_fixed {m : ℕ} (w : Fin m → FreeGroup (Fin m)) (z : Fin m → ℂ) + (hz : ∀ i, z i ≠ 0) : + radialWordMap w (fun i => Quaternion.ofComplex (z i)) = + fun i => Quaternion.ofComplex (complexRadialTorus (exponentMatrix w) z i) := by + funext i + simp only [radialWordMap, normalizeQuaternion_ofComplex, wordMap_circleQuaternion, + circleQuaternion_coe, complexRadialTorus, norm_quaternion_ofComplex] + rw [map_smul] + congr 1 + apply congrArg Quaternion.ofComplex + change Circle.coeHom (∏ j, normalizeCircle (z j) ^ exponentMatrix w i j) = _ + rw [map_prod] + apply Finset.prod_congr rfl + intro j _ + change (normalizeCircle (z j) : ℂ) ^ exponentMatrix w i j = _ + rw [normalizeCircle_coe_of_ne_zero (hz j)] + +theorem quaternionCoordinates_conjComplex (c : ℂ) (q : ℍ) : + quaternionCoordinates (Quaternion.ofComplex c * q * star (Quaternion.ofComplex c)) = + ((Complex.normSq c : ℂ) * (quaternionCoordinates q).1, + c ^ 2 * (quaternionCoordinates q).2) := by + apply Prod.ext <;> apply Complex.ext <;> + simp [quaternionCoordinates_apply, Complex.normSq_apply, pow_two] <;> ring + +@[simp] theorem quaternionCoordinates_conjCircle (c : Circle) (q : ℍ) : + quaternionCoordinates (Quaternion.ofComplex c * q * star (Quaternion.ofComplex c)) = + ((quaternionCoordinates q).1, (c : ℂ) ^ 2 * (quaternionCoordinates q).2) := by + simpa using quaternionCoordinates_conjComplex (c : ℂ) q + +/-- Ambient conjugation, compatible with the group operation on unit quaternions. -/ +def quaternionConjugate (a : SU2) (q : ℍ) : ℍ := (a : ℍ) * q * star (a : ℍ) + +@[simp] theorem quaternionConjugate_norm (a : SU2) (q : ℍ) : + ‖quaternionConjugate a q‖ = ‖q‖ := by + have ha := (quaternion_mem_unitary_iff _).mp a.property + simp [quaternionConjugate, ha] + +@[simp] theorem quaternionConjugate_zero (a : SU2) : quaternionConjugate a 0 = 0 := by + simp [quaternionConjugate] + +@[simp] theorem quaternionConjugate_one (a : SU2) : quaternionConjugate a 1 = 1 := by + simp [quaternionConjugate] + +theorem quaternionConjugate_smul (a : SU2) (r : ℝ) (q : ℍ) : + quaternionConjugate a (r • q) = r • quaternionConjugate a q := by + simp only [quaternionConjugate, mul_smul_comm, smul_mul_assoc] + +@[simp] theorem quaternionConjugate_coe (a q : SU2) : + quaternionConjugate a (q : ℍ) = ((a * q * a⁻¹ : SU2) : ℍ) := rfl + +theorem normalizeQuaternion_conjugate (a : SU2) (q : ℍ) : + normalizeQuaternion (quaternionConjugate a q) = a * normalizeQuaternion q * a⁻¹ := by + by_cases hq : q = 0 + · subst q; simp [normalizeQuaternion] + · have hn : quaternionConjugate a q ≠ 0 := by + intro hz + have he := quaternionConjugate_norm a q + rw [hz, norm_zero, eq_comm, norm_eq_zero] at he + exact hq he + apply Subtype.ext + rw [normalizeQuaternion_coe_of_ne_zero hn, ← quaternionConjugate_coe, + normalizeQuaternion_coe_of_ne_zero hq, quaternionConjugate_smul, quaternionConjugate_norm] + +theorem wordMap_conjugation {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (a : SU2) (x : Fin m → SU2) : + wordMap w (fun i => a * x i * a⁻¹) = fun i => a * wordMap w x i * a⁻¹ := by + have he : FreeGroup.lift (fun i => a * x i * a⁻¹) = + (MulAut.conj a).toMonoidHom.comp (FreeGroup.lift x) := by + apply FreeGroup.ext_hom + intro i + simp + funext i + change FreeGroup.lift (fun i => a * x i * a⁻¹) (w i) = _ + rw [he] + rfl + +theorem radialWordMap_conjugation {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (a : SU2) (x : Fin m → ℍ) : + radialWordMap w (fun i => quaternionConjugate a (x i)) = + fun i => quaternionConjugate a (radialWordMap w x i) := by + funext i + simp only [radialWordMap, quaternionConjugate_norm, normalizeQuaternion_conjugate, + wordMap_conjugation, quaternionConjugate_smul, quaternionConjugate_coe] + +theorem smoothRadialWordMap_conjugation {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (a : SU2) (x : Fin m → ℍ) : + smoothRadialWordMap w (fun i => quaternionConjugate a (x i)) = + fun i => quaternionConjugate a (smoothRadialWordMap w x i) := by + funext i + simp only [smoothRadialWordMap, radialCutoff, quaternionConjugate_norm, + Pi.smul_apply, radialWordMap_conjugation, quaternionConjugate_smul] + +end EilenbergGanea + + +namespace EilenbergGanea + +theorem complex_root_of_unity_norm {p : ℕ} (hp : p ≠ 0) (z : rootsOfUnity p ℂ) : + ‖((z : ℂˣ) : ℂ)‖ = 1 := by + have h := congrArg norm ((mem_rootsOfUnity' p (z : ℂˣ)).mp z.property) + simpa only [norm_pow, norm_one, pow_eq_one_iff_of_nonneg (norm_nonneg _) hp] using h + +theorem rootsOfUnity_isPGroup {p : ℕ} [Fact p.Prime] : IsPGroup p (rootsOfUnity p ℂ) := by + let : NeZero p := ⟨(Fact.out : p.Prime).ne_zero⟩ + rw [isPGroup_iff_card_dvd_pow, Complex.card_rootsOfUnity] + exact ⟨1, by simp⟩ + +theorem rootsOfUnity_exists_nonreal {p : ℕ} (hp : 2 < p) : + ∃ z : rootsOfUnity p ℂ, (((z : ℂˣ) : ℂ)).im ≠ 0 := by + have hp0 : p ≠ 0 := by omega + let ζ := Complex.exp (2 * Real.pi * Complex.I / p) + have hζ : IsPrimitiveRoot ζ p := Complex.isPrimitiveRoot_exp p hp0 + let u : ℂˣ := Units.mk0 ζ (Complex.exp_ne_zero _) + let z : rootsOfUnity p ℂ := ⟨u, (mem_rootsOfUnity' p u).mpr hζ.pow_eq_one⟩ + refine ⟨z, ?_⟩ + intro him + change ζ.im = 0 at him + have hn : ‖ζ‖ = 1 := complex_root_of_unity_norm hp0 z + have hs : ζ.re ^ 2 = 1 := by + have hh := Complex.normSq_eq_norm_sq ζ + simp only [Complex.normSq_apply, him, mul_zero, add_zero, hn, one_pow] at hh + nlinarith + have hpow : ζ ^ 2 = 1 := by + apply Complex.ext <;> simp [pow_two, him] + nlinarith + have hd := hζ.dvd_of_pow_eq_one 2 hpow + have ht := Nat.le_of_dvd (by decide : 0 < 2) hd + omega + +theorem circle_exists_square_root (z : ℂ) (hz : ‖z‖ = 1) : + ∃ c : Circle, (c : ℂ) ^ 2 = z := by + obtain ⟨c, hc⟩ := IsAlgClosed.exists_pow_nat_eq z (by decide : 0 < 2) + have hn : ‖c‖ = 1 := by + have hh := congrArg norm hc + rw [norm_pow, hz] at hh + nlinarith [norm_nonneg c] + exact ⟨⟨c, mem_sphere_zero_iff_norm.mpr hn⟩, hc⟩ + +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped Quaternion ContDiff + +def splitWordMap {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (q : (Fin m → ℂ) × (Fin m → ℂ)) : (Fin m → ℂ) × (Fin m → ℂ) := + quaternionTupleCoordinates (smoothRadialWordMap w (quaternionTupleCoordinates.symm q)) - (1, 0) + +theorem splitWordMap_contDiff {m : ℕ} (w : Fin m → FreeGroup (Fin m)) : + ContDiff ℝ ∞ (splitWordMap w) := + (quaternionTupleCoordinates.contDiff.comp ((smoothRadialWordMap_contDiff w).comp + quaternionTupleCoordinates.symm.contDiff)).sub contDiff_const + +theorem quaternionTupleCoordinates_conjCircle {m : ℕ} (c : Circle) (q : Fin m → ℍ) : + quaternionTupleCoordinates (fun i => quaternionConjugate (circleQuaternion c) (q i)) = + ((quaternionTupleCoordinates q).1, (c : ℂ) ^ 2 • (quaternionTupleCoordinates q).2) := by + apply Prod.ext + · funext i + change (quaternionCoordinates (Quaternion.ofComplex c * q i * star (Quaternion.ofComplex c))).1 = _ + have hh := congrArg Prod.fst (quaternionCoordinates_conjCircle c (q i)) + exact hh + · funext i + change (quaternionCoordinates (Quaternion.ofComplex c * q i * star (Quaternion.ofComplex c))).2 = _ + have hh := congrArg Prod.snd (quaternionCoordinates_conjCircle c (q i)) + exact hh + +theorem splitWordMap_rotation {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (z : ℂ) (hz : ‖z‖ = 1) (q : (Fin m → ℂ) × (Fin m → ℂ)) : + splitWordMap w (q.1, z • q.2) = ((splitWordMap w q).1, z • (splitWordMap w q).2) := by + obtain ⟨c, hc⟩ := circle_exists_square_root z hz + let x := quaternionTupleCoordinates.symm q + have hx : quaternionTupleCoordinates x = q := quaternionTupleCoordinates.apply_symm_apply q + have heq : (q.1, z • q.2) = quaternionTupleCoordinates + (fun i => quaternionConjugate (circleQuaternion c) (x i)) := by + rw [quaternionTupleCoordinates_conjCircle, hc, hx] + have hh := congrArg (fun v : Fin m → ℍ => quaternionTupleCoordinates v) + (smoothRadialWordMap_conjugation w (circleQuaternion c) x) + rw [quaternionTupleCoordinates_conjCircle, hc] at hh + have heq' : quaternionTupleCoordinates.symm (q.1, z • q.2) = + fun i => quaternionConjugate (circleQuaternion c) (x i) := by + rw [heq, ContinuousLinearEquiv.symm_apply_apply] + unfold splitWordMap + rw [heq', hh] + change (_, z • _) - (1, 0) = ((quaternionTupleCoordinates (smoothRadialWordMap w x) - (1, 0)).1, + z • (quaternionTupleCoordinates (smoothRadialWordMap w x) - (1, 0)).2) + simp + +theorem splitWordMap_fixed_eventually {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℂ) (hx : ∀ i, ‖x i‖ = 1) : + (fun z => (splitWordMap w (z, 0)).1) =ᶠ[𝓝 x] + (fun z => complexRadialTorus (exponentMatrix w) z - 1) := by + have hne (i : Fin m) : x i ≠ 0 := by intro h; simpa [h] using hx i + have hz : ∀ᶠ z in 𝓝 x, ∀ i, z i ≠ 0 := Filter.eventually_all.mpr + (fun i => (continuous_apply i).continuousAt.eventually_ne (hne i)) + have hcont : Continuous (fun z : Fin m → ℂ => fun i => Quaternion.ofComplex (z i)) := + continuous_pi (fun i => Quaternion.ofComplex.toLinearMap.continuous_of_finiteDimensional.comp + (continuous_apply i)) + have he := (smoothRadialWordMap_eventuallyEq w (fun i => Quaternion.ofComplex (x i)) + (fun i => (norm_quaternion_ofComplex _).trans (hx i))).comp_tendsto hcont.continuousAt + filter_upwards [hz, he] with z hz he + change smoothRadialWordMap w (fun i => Quaternion.ofComplex (z i)) = + radialWordMap w (fun i => Quaternion.ofComplex (z i)) at he + simp only [splitWordMap, quaternionTupleCoordinates_symm_fixed] + rw [he, radialWordMap_fixed w z hz, quaternionTupleCoordinates_fixed] + rfl + +theorem splitWordMap_fixed_det {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (x : Fin m → ℂ) (hx : ∀ i, ‖x i‖ = 1) + (hr : ∀ i, ∏ j, x j ^ exponentMatrix w i j = 1) : + (fderiv ℝ (fun z => (splitWordMap w (z, 0)).1) x).det = + ((exponentMatrix w).det : ℝ) := by + rw [(splitWordMap_fixed_eventually w x hx).fderiv_eq (𝕜 := ℝ)] + have hne (i : Fin m) : x i ≠ 0 := by intro h; simpa [h] using hx i + rw [((complexRadialTorus_differentiableAt (exponentMatrix w) x hne).hasFDerivAt.sub_const 1).fderiv] + exact complexRadialTorus_det (exponentMatrix w) x hx hr + +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped Quaternion + +theorem splitWordMap_zero_iff {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (q : (Fin m → ℂ) × (Fin m → ℂ)) : + splitWordMap w q = 0 ↔ + smoothRadialWordMap w (quaternionTupleCoordinates.symm q) = 1 := by + unfold splitWordMap + rw [sub_eq_zero] + have he : quaternionTupleCoordinates (1 : Fin m → ℍ) = (1, 0) := by + change quaternionTupleCoordinates (fun i : Fin m => Quaternion.ofComplex (1 : ℂ)) = _ + exact quaternionTupleCoordinates_fixed 1 + rw [← he] + exact quaternionTupleCoordinates.injective.eq_iff + +theorem splitWordMap_fixed_zero_iff {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (z : Fin m → ℂ) : splitWordMap w (z, 0) = 0 ↔ + (∀ i, ‖z i‖ = 1) ∧ (∀ i, ∏ j, z j ^ exponentMatrix w i j = 1) := by + rw [splitWordMap_zero_iff, quaternionTupleCoordinates_symm_fixed, + smoothRadialWordMap_eq_one_iff] + constructor + · intro h + have hn : ∀ i, ‖z i‖ = 1 := fun i => (norm_quaternion_ofComplex (z i)).symm.trans + (((radialWordMap_eq_one_iff w _).mp h).1 i) + have hz (i : Fin m) : z i ≠ 0 := by intro h; simpa [h] using hn i + rw [radialWordMap_fixed w z hz] at h + refine ⟨hn, fun i => ?_⟩ + have hh := congrArg (fun v : Fin m → ℍ => (quaternionCoordinates (v i)).1) h + change (quaternionCoordinates (Quaternion.ofComplex _)).1 = (1 : ℂ) at hh + simpa only [quaternionCoordinates_ofComplex, complexRadialTorus, hn, inv_one, one_smul] using hh + · rintro ⟨hn, hr⟩ + have hz (i : Fin m) : z i ≠ 0 := by intro h; simpa [h] using hn i + rw [radialWordMap_fixed w z hz] + funext i + simp [complexRadialTorus, hn, hr] + +@[simp] theorem splitWordMap_fixed_one {m : ℕ} (w : Fin m → FreeGroup (Fin m)) : + splitWordMap w (1, 0) = 0 := by + rw [splitWordMap_fixed_zero_iff] + simp + +end EilenbergGanea + +namespace EilenbergGanea +open Set +section Torus +variable {n : Type*} [Fintype n] [DecidableEq n] +variable {A : Type*} [CommGroup A] +theorem zpow_finite_sum {ι : Type*} (a : A) (s : Finset ι) (e : ι → ℤ) : + a ^ (∑ i ∈ s, e i) = ∏ i ∈ s, a ^ e i := by + classical + induction s using Finset.induction with + | empty => simp + | @insert i s hi ih => simp [hi, ih, zpow_add] + +def torusMap (B : Matrix n n ℤ) (x : n → A) : n → A := + fun i => ∏ j, x j ^ B i j + +omit [DecidableEq n] in +theorem torusMap_comp (B C : Matrix n n ℤ) (x : n → A) : + torusMap B (torusMap C x) = torusMap (B * C) x := by + funext i + simp only [torusMap, Matrix.mul_apply, ← Finset.prod_zpow, zpow_finite_sum, ← zpow_mul] + rw [Finset.prod_comm] + congr 1 + funext j + congr 1 + funext k + rw [Int.mul_comm] + +theorem torusMap_det_one (B : Matrix n n ℤ) (x : n → A) : + torusMap (B.det • (1 : Matrix n n ℤ)) x = fun i => x i ^ B.det := by + funext i + simp [torusMap, Matrix.one_apply] + +theorem torusMap_kernel_pow_det (B : Matrix n n ℤ) (x : n → A) + (hx : torusMap B x = 1) (i : n) : x i ^ B.det = 1 := by + have he := congrArg (fun y => torusMap B.adjugate y i) hx + rw [torusMap_comp, Matrix.adjugate_mul, torusMap_det_one] at he + simpa [torusMap] using he + +theorem circle_finite_pow_roots {d : ℤ} (hd : d ≠ 0) : + {z : Circle | z ^ d = 1}.Finite := by + have hr := Polynomial.finite_setOfPred_isRoot + (Polynomial.X_pow_sub_C_ne_zero (Nat.pos_of_ne_zero (Int.natAbs_ne_zero.mpr hd)) (1 : ℂ)) + apply Set.Finite.of_injOn (f := fun z : Circle => (z : ℂ)) _ + Subtype.val_injective.injOn hr + intro z hz + have hp : z ^ d.natAbs = 1 := pow_natAbs_eq_one.mpr hz + have he : (z : ℂ) ^ d.natAbs = 1 := by + simpa using congrArg (fun t : Circle => (t : ℂ)) hp + simpa [Polynomial.IsRoot.def] using sub_eq_zero.mpr he + +theorem torusMap_finite_kernel (B : Matrix n n ℤ) (hB : B.det ≠ 0) : + {x : n → Circle | torusMap B x = 1}.Finite := by + apply Set.Finite.subset (Set.Finite.pi (fun _ : n => circle_finite_pow_roots hB)) + intro x hx i _ + exact torusMap_kernel_pow_det B x hx i + +end Torus +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology + +theorem splitWordMap_fixed_finite {m : ℕ} (w : Fin m → FreeGroup (Fin m)) + (hB : (exponentMatrix w).det ≠ 0) : + {z : Fin m → ℂ | splitWordMap w (z, 0) = 0}.Finite := by + classical + let e : (Fin m → Circle) → (Fin m → ℂ) := fun x i => (x i : ℂ) + have hf := (torusMap_finite_kernel (exponentMatrix w) hB).image e + apply hf.subset + intro z hz + obtain ⟨hn, hr⟩ := (splitWordMap_fixed_zero_iff w z).mp hz + let x : Fin m → Circle := fun i => ⟨z i, mem_sphere_zero_iff_norm.mpr (hn i)⟩ + refine ⟨x, ?_, rfl⟩ + funext i + apply Subtype.ext + change Circle.coeHom (∏ j, x j ^ exponentMatrix w i j) = (1 : ℂ) + rw [map_prod] + simp only [map_zpow] + exact hr i + +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff + +/-- The signed-root noncancellation for the actual ambient quaternion word +map, with no regularity assumed of the original word map. -/ +theorem word_exists_regularization_nonzero_count {m : ℕ} + (w : Fin m → FreeGroup (Fin m)) (hB : (exponentMatrix w).det ≠ 0) + (K : Set ((Fin m → ℂ) × (Fin m → ℂ))) (hK : IsCompact K) + (hKi : ∀ z : ℂ, ‖z‖ = 1 → ∀ q ∈ K, (q.1, z • q.2) ∈ K) + (h1 : (1, 0) ∈ K) + (L : Set ((Fin m → ℂ) × (Fin m → ℂ))) (hL : IsCompact L) (hKL : K ⊆ L) + (ε : ℝ) (hε : 0 < ε) : + ∃ g : ((Fin m → ℂ) × (Fin m → ℂ)) → ((Fin m → ℂ) × (Fin m → ℂ)), + ContDiff ℝ ∞ g ∧ (∀ q ∈ L, ‖g q - splitWordMap w q‖ < ε) ∧ + ∃ s : Finset ((Fin m → ℂ) × (Fin m → ℂ)), + (∀ q, q ∈ s ↔ q ∈ K ∧ g q = 0) ∧ + (∀ q ∈ s, (fderiv ℝ g q).det ≠ 0) ∧ + (∑ q ∈ s, (if 0 < (fderiv ℝ g q).det then 1 else -1 : ℝ)) ≠ 0 := by + classical + let S := (splitWordMap_fixed_finite w hB).toFinset + have hS (z) : z ∈ S ↔ splitWordMap w (z, 0) = 0 := (splitWordMap_fixed_finite w hB).mem_toFinset + obtain ⟨p, hpbound, hp⟩ := Nat.exists_infinite_primes (S.card + 3) + let : Fact p.Prime := ⟨hp⟩ + let : NeZero p := ⟨hp.ne_zero⟩ + let : Fintype (rootsOfUnity p ℂ) := Fintype.ofFinite _ + obtain ⟨a₀, ha₀⟩ := rootsOfUnity_exists_nonreal (p := p) (by omega) + let χ : rootsOfUnity p ℂ →* ℂˣ := (rootsOfUnity p ℂ).subtype + apply exists_regularization_nonzero_count (rootsOfUnity_isPGroup (p := p)) χ + Subtype.val_injective a₀ ha₀ (splitWordMap w) (splitWordMap_contDiff w) + (fun a q => splitWordMap_rotation w (χ a : ℂ) (complex_root_of_unity_norm hp.ne_zero a) q) + K hK (fun a q hq => hKi (χ a : ℂ) (complex_root_of_unity_norm hp.ne_zero a) q hq) + L hL hKL S (fun z _ hz => (hS z).mpr hz) ⟨1, h1, splitWordMap_fixed_one w⟩ (by omega) + ((exponentMatrix w).det : ℝ) (by exact_mod_cast hB) _ ε hε + intro z hz + obtain ⟨hn, hr⟩ := (splitWordMap_fixed_zero_iff w z).mp ((hS z).mp hz) + exact splitWordMap_fixed_det w z hn hr + +end EilenbergGanea + +end + +end OAI diff --git a/lean/OAI/Topology/EilenbergGanea/WordEquations.lean b/lean/OAI/Topology/EilenbergGanea/WordEquations.lean new file mode 100644 index 0000000000000000000000000000000000000000..01e9a4f2a246d67e005b437350150d1b282e9f8e --- /dev/null +++ b/lean/OAI/Topology/EilenbergGanea/WordEquations.lean @@ -0,0 +1,388 @@ +import OAI.Topology.EilenbergGanea.IntegralDegree +import OAI.Topology.EilenbergGanea.UnitaryWords + +namespace OAI + +noncomputable section + +open Classical Set Filter Topology MeasureTheory +open scoped Quaternion ContDiff + +namespace EilenbergGanea +open Set Filter Topology +open scoped ContDiff + +/-- A concrete sublevel version of localized degree. The only root isolation +conditions are a uniform radial bound and exclusion of the threshold; no +regularity of any root or of the sublevel boundary is assumed. -/ +theorem localized_word_root_sublevel {m : ℕ} + (w : Fin m → FreeGroup (Fin m)) (hB : (exponentMatrix w).det ≠ 0) + (F : ℝ × ((Fin m → ℂ) × (Fin m → ℂ)) → ((Fin m → ℂ) × (Fin m → ℂ))) + (hF : ContDiff ℝ 2 F) (hF0 : ∀ q, F (0, q) = splitWordMap w q) + (h : ℝ × ((Fin m → ℂ) × (Fin m → ℂ)) → ℝ) (hh : Continuous h) + (δ R : ℝ) (hR : ‖((1 : Fin m → ℂ), (0 : Fin m → ℂ))‖ < R) + (h1 : h (0, (1, 0)) < δ) + (hi : ∀ z : ℂ, ‖z‖ = 1 → ∀ q, h (0, (q.1, z • q.2)) = h (0, q)) + (hbound : ∀ q, q.1 ∈ Icc (0 : ℝ) 1 → F q = 0 → ‖q.2‖ < R) + (hiso : ∀ q, q.1 ∈ Icc (0 : ℝ) 1 → F q = 0 → h q ≠ δ) : + ∃ x, F (1, x) = 0 ∧ h (1, x) < δ := by + let E := (Fin m → ℂ) × (Fin m → ℂ) + let C : Set (ℝ × E) := {q | ‖q.2‖ < R ∧ h q < δ} + have hC : IsOpen C := (isOpen_lt continuous_snd.norm continuous_const).inter + (isOpen_lt hh continuous_const) + have hcl : closure C ⊆ {q | ‖q.2‖ ≤ R ∧ h q ≤ δ} := + closure_minimal (fun _ hq => ⟨hq.1.le, hq.2.le⟩) + ((isClosed_le continuous_snd.norm continuous_const).inter (isClosed_le hh continuous_const)) + have hslice (t : ℝ) : Bornology.IsBounded {x : E | (t, x) ∈ C} := by + apply (Metric.isBounded_closedBall (x := (0 : E)) (r := R)).subset + intro x hx + exact Metric.mem_closedBall.mpr (by simpa only [dist_zero_right] using hx.1.le) + have hBcompact : IsCompact {q : ℝ × E | q ∈ frontier C ∧ q.1 ∈ Icc (0 : ℝ) 1} := by + apply (isCompact_Icc.prod (isCompact_closedBall (0 : E) R)).of_isClosed_subset + (isClosed_frontier.inter (isClosed_Icc.preimage continuous_fst)) + intro q hq + refine ⟨hq.2, ?_⟩ + exact Metric.mem_closedBall.mpr (by simpa only [dist_zero_right] using (hcl (frontier_subset_closure hq.1)).1) + have hCb : Bornology.IsBounded {x : E | ∃ t ∈ Icc (0 : ℝ) 1, (t, x) ∈ C} := by + apply (Metric.isBounded_closedBall (x := (0 : E)) (r := R)).subset + rintro x ⟨t, _, hx⟩ + exact Metric.mem_closedBall.mpr (by simpa only [dist_zero_right] using hx.1.le) + have hUi : ∀ z : ℂ, ‖z‖ = 1 → ∀ q ∈ closure {x : E | (0, x) ∈ C}, + (q.1, z • q.2) ∈ closure {x : E | (0, x) ∈ C} := by + intro z hz + have hmaps : MapsTo (fun q : E => (q.1, z • q.2)) {x | (0, x) ∈ C} {x | (0, x) ∈ C} := by + intro q hq + refine ⟨?_, ?_⟩ + · have hn : ‖(q.1, z • q.2)‖ = ‖q‖ := by + change max ‖q.1‖ ‖z • q.2‖ = max ‖q.1‖ ‖q.2‖ + rw [norm_smul, hz, one_mul] + simpa only [hn] using hq.1 + · simpa only [hi z hz q] using hq.2 + have hr : Continuous (fun q : E => (q.1, z • q.2)) := by fun_prop + exact hmaps.closure_of_continuousOn hr.continuousOn + have hb : ∀ q ∈ frontier C, q.1 ∈ Icc (0 : ℝ) 1 → F q ≠ 0 := by + intro q hq ht hf + have hhδ : h q < δ := lt_of_le_of_ne (hcl (frontier_subset_closure hq)).2 (hiso q ht hf) + have hqC : q ∈ C := ⟨hbound q ht hf, hhδ⟩ + exact hq.2 (by simpa only [hC.interior_eq] using hqC) + obtain ⟨x, hx, he⟩ := localized_word_root_persists_moving w hB F hF hF0 C hC + (hslice 0).isCompact_closure (hslice 1).isCompact_closure hBcompact hCb hUi ⟨hR, h1⟩ hb + exact ⟨x, he, hx.2⟩ +end EilenbergGanea +namespace EilenbergGanea +open Set Filter Topology +open scoped Quaternion ContDiff + +/-- Word evaluation with a fixed alphabet of coefficient letters and a finite +alphabet of unknowns. Coefficients may vary smoothly with a real parameter. -/ +def coefficientWordMap {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (q : ℝ × (Fin m → SU2)) : Fin d → SU2 := + fun i => FreeGroup.lift (Sum.elim (a q.1) q.2) (w i) + +def eraseCoefficients {ι : Type*} {m : ℕ} : FreeGroup (ι ⊕ Fin m) →* FreeGroup (Fin m) := + FreeGroup.lift (Sum.elim (fun _ => 1) FreeGroup.of) + +theorem coefficientWordMap_initial {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, a 0 i = 1) (x : Fin m → SU2) : + coefficientWordMap w a (0, x) = fun i => FreeGroup.lift x (eraseCoefficients (w i)) := by + have he : FreeGroup.lift (Sum.elim (a 0) x) = (FreeGroup.lift x).comp eraseCoefficients := by + apply FreeGroup.ext_hom + intro i + cases i with + | inl i => simp [eraseCoefficients, ha] + | inr i => simp [eraseCoefficients] + funext i + exact congrArg (fun f : FreeGroup (ι ⊕ Fin m) →* SU2 => f (w i)) he + +/-- The same conjugation-invariant radial cutoff handles arbitrary coefficient +words, and does not create roots on the coordinate hyperplanes. -/ +theorem radialCutoff_family_smooth {m : ℕ} {V : Type*} + [NormedAddCommGroup V] [NormedSpace ℝ V] + (f : ℝ × (Fin m → ℍ) → V) + (hf : ∀ q, (∀ i, q.2 i ≠ 0) → ContDiffAt ℝ ∞ f q) : + ContDiff ℝ ∞ (fun q => radialCutoff q.2 • f q) := by + rw [contDiff_iff_contDiffAt] + intro q + by_cases hq : ∀ i, q.2 i ≠ 0 + · exact (radialCutoff_contDiff.comp contDiff_snd).contDiffAt.smul (hf q hq) + · push Not at hq + obtain ⟨i, hi⟩ := hq + apply (contDiffAt_const : ContDiffAt ℝ ∞ (fun _ : ℝ × (Fin m → ℍ) => (0 : V)) q).congr_of_eventuallyEq + have he : ∀ᶠ p in 𝓝 q, radialCutoff p.2 = 0 := + continuous_snd.continuousAt (radialCutoff_eventually_zero q.2 i hi) + filter_upwards [he] with p hp + simp only [hp, zero_smul] + +theorem coefficientWordMap_normalized_smoothAt {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, ContDiff ℝ ∞ (fun t => (a t i : ℍ))) + (q : ℝ × (Fin m → ℍ)) (hq : ∀ i, q.2 i ≠ 0) : + ContDiffAt ℝ ∞ (fun p : ℝ × (Fin m → ℍ) => + fun i => (coefficientWordMap w a (p.1, fun j => normalizeQuaternion (p.2 j)) i : ℍ)) q := by + apply contDiffAt_pi.mpr + intro i + refine freeGroup_lift_coe_contDiffAt (w i) q + (fun parameter => Sum.elim (a parameter.1) + (fun index => normalizeQuaternion (parameter.2 index))) ?_ + intro j + cases j with + | inl j => exact ((ha j).comp contDiff_fst).contDiffAt + | inr j => + change ContDiffAt ℝ ∞ (fun p : ℝ × (Fin m → ℍ) => (normalizeQuaternion (p.2 j) : ℍ)) q + exact (normalizeQuaternion_coe_contDiffAt (hq j)).comp (f := fun p : ℝ × (Fin m → ℍ) => p.2 j) q + ((contDiff_apply ℝ ℍ j).comp contDiff_snd).contDiffAt + +def radialCoefficientWordMap {ι : Type*} {m : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (q : ℝ × (Fin m → ℍ)) : Fin m → ℍ := + fun i => ‖q.2 i‖ • (coefficientWordMap w a (q.1, fun j => normalizeQuaternion (q.2 j)) i : ℍ) + +def smoothRadialCoefficientWordMap {ι : Type*} {m : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (q : ℝ × (Fin m → ℍ)) : Fin m → ℍ := + radialCutoff q.2 • radialCoefficientWordMap w a q + +theorem smoothRadialCoefficientWordMap_smooth {ι : Type*} {m : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, ContDiff ℝ ∞ (fun t => (a t i : ℍ))) : + ContDiff ℝ ∞ (smoothRadialCoefficientWordMap w a) := by + apply radialCutoff_family_smooth + intro q hq + apply contDiffAt_pi.mpr + intro i + exact (((contDiff_apply ℝ ℍ i).comp contDiff_snd).contDiffAt.norm ℝ (hq i)).smul + ((contDiffAt_pi.mp (coefficientWordMap_normalized_smoothAt w a ha q hq)) i) + +@[simp] theorem radialCoefficientWordMap_norm {ι : Type*} {m : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (q : ℝ × (Fin m → ℍ)) (i : Fin m) : + ‖radialCoefficientWordMap w a q i‖ = ‖q.2 i‖ := by + have h := (quaternion_mem_unitary_iff _).mp + (coefficientWordMap w a (q.1, fun j => normalizeQuaternion (q.2 j)) i).property + simp [radialCoefficientWordMap, norm_smul, h] + +theorem radialCoefficientWordMap_eq_one_iff {ι : Type*} {m : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (q : ℝ × (Fin m → ℍ)) : radialCoefficientWordMap w a q = 1 ↔ + (∀ i, ‖q.2 i‖ = 1) ∧ coefficientWordMap w a + (q.1, fun j => normalizeQuaternion (q.2 j)) = 1 := by + constructor + · intro h + have hn (i : Fin m) : ‖q.2 i‖ = 1 := by + have he := congrArg (fun y : Fin m → ℍ => ‖y i‖) h + simpa only [radialCoefficientWordMap_norm, Pi.one_apply, norm_one] using he + refine ⟨hn, ?_⟩ + funext i + apply Subtype.ext + have he := congrFun h i + simpa [radialCoefficientWordMap, hn] using he + · rintro ⟨hn, hw⟩ + funext i + simp [radialCoefficientWordMap, hn, hw] + +theorem smoothRadialCoefficientWordMap_eq_one_iff {ι : Type*} {m : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (q : ℝ × (Fin m → ℍ)) : smoothRadialCoefficientWordMap w a q = 1 ↔ + (∀ i, ‖q.2 i‖ = 1) ∧ coefficientWordMap w a + (q.1, fun j => normalizeQuaternion (q.2 j)) = 1 := by + rw [← radialCoefficientWordMap_eq_one_iff] + constructor + · intro h + have hn (i : Fin m) : radialCutoff q.2 * ‖q.2 i‖ = 1 := by + have he := congrArg (fun y : Fin m → ℍ => ‖y i‖) h + simpa only [smoothRadialCoefficientWordMap, Pi.smul_apply, norm_smul, Real.norm_eq_abs, + abs_of_nonneg (radialCutoff_nonneg q.2), radialCoefficientWordMap_norm, Pi.one_apply, norm_one] using he + have hlarge (i : Fin m) : 1 ≤ ‖q.2 i‖ := by + have hle := mul_le_mul_of_nonneg_right (radialCutoff_le_one q.2) (norm_nonneg (q.2 i)) + rw [hn i, one_mul] at hle + exact hle + simpa only [smoothRadialCoefficientWordMap, radialCutoff_eq_one q.2 hlarge, one_smul] using h + · intro h + have hn := (radialCoefficientWordMap_eq_one_iff w a q).mp h + simp only [smoothRadialCoefficientWordMap, radialCutoff_eq_one q.2 (fun i => (hn.1 i).ge), one_smul, h] + +theorem smoothRadialCoefficientWordMap_initial {ι : Type*} {m : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, a 0 i = 1) (x : Fin m → ℍ) : + smoothRadialCoefficientWordMap w a (0, x) = + smoothRadialWordMap (fun i => eraseCoefficients (w i)) x := by + unfold smoothRadialCoefficientWordMap smoothRadialWordMap + congr 1 + funext i + dsimp only [radialCoefficientWordMap, radialWordMap] + rw [coefficientWordMap_initial w a ha] + rfl +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped Quaternion ContDiff + +def cutoffCoefficientProducts {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (q : ℝ × (Fin m → ℍ)) : Fin d → ℍ := + radialCutoff q.2 • fun i => + (coefficientWordMap w a (q.1, fun j => normalizeQuaternion (q.2 j)) i : ℍ) + +theorem cutoffCoefficientProducts_smooth {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, ContDiff ℝ ∞ (fun t => (a t i : ℍ))) : + ContDiff ℝ ∞ (cutoffCoefficientProducts w a) := + radialCutoff_family_smooth _ (coefficientWordMap_normalized_smoothAt w a ha) + +theorem cutoffCoefficientProducts_unitary {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (t : ℝ) (x : Fin m → SU2) : + cutoffCoefficientProducts w a (t, fun i => (x i : ℍ)) = + fun i => (coefficientWordMap w a (t, x) i : ℍ) := by + have hn (i : Fin m) : ‖(x i : ℍ)‖ = 1 := (quaternion_mem_unitary_iff _).mp (x i).property + simp only [cutoffCoefficientProducts, radialCutoff_eq_one _ (fun i => (hn i).ge), one_smul, + normalizeQuaternion_unitary] +end EilenbergGanea + +namespace EilenbergGanea +open Set Filter Topology +open scoped Quaternion ContDiff + + theorem quaternionConjugate_sub (a : SU2) (q r : ℍ) : + quaternionConjugate a (q - r) = quaternionConjugate a q - quaternionConjugate a r := by + simp only [quaternionConjugate, mul_sub, sub_mul] + + theorem coefficientWordMap_initial_conjugate {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, a 0 i = 1) (b : SU2) (x : Fin m → SU2) : + coefficientWordMap w a (0, fun i => b * x i * b⁻¹) = + fun i => b * coefficientWordMap w a (0, x) i * b⁻¹ := by + rw [coefficientWordMap_initial w a ha, coefficientWordMap_initial w a ha] + have he : FreeGroup.lift (fun i => b * x i * b⁻¹) = + (MulAut.conj b).toMonoidHom.comp (FreeGroup.lift x) := by + apply FreeGroup.ext_hom + intro i + simp + funext i + rw [he] + rfl + + theorem cutoffCoefficientProducts_initial_conjugate {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, a 0 i = 1) (b : SU2) (x : Fin m → ℍ) : + cutoffCoefficientProducts w a (0, fun i => quaternionConjugate b (x i)) = + fun i => quaternionConjugate b (cutoffCoefficientProducts w a (0, x) i) := by + funext i + simp only [cutoffCoefficientProducts, radialCutoff, quaternionConjugate_norm, + normalizeQuaternion_conjugate, coefficientWordMap_initial_conjugate w a ha, + Pi.smul_apply, quaternionConjugate_smul, quaternionConjugate_coe] + + theorem cutoffCoefficientProducts_initial_size_invariant {ι : Type*} {m d : ℕ} + (w : Fin d → FreeGroup (ι ⊕ Fin m)) (a : ℝ → ι → SU2) + (ha : ∀ i, a 0 i = 1) (b : SU2) (x : Fin m → ℍ) : + ‖cutoffCoefficientProducts w a (0, fun i => quaternionConjugate b (x i)) - 1‖ = + ‖cutoffCoefficientProducts w a (0, x) - 1‖ := by + rw [cutoffCoefficientProducts_initial_conjugate w a ha] + have hn (i : Fin d) : ‖quaternionConjugate b (cutoffCoefficientProducts w a (0, x) i) - 1‖ = + ‖cutoffCoefficientProducts w a (0, x) i - 1‖ := by + calc + _ = ‖quaternionConjugate b (cutoffCoefficientProducts w a (0, x) i - 1)‖ := by rw [quaternionConjugate_sub, quaternionConjugate_one] + _ = _ := quaternionConjugate_norm _ _ + have hnn (i : Fin d) : ‖quaternionConjugate b (cutoffCoefficientProducts w a (0, x) i) - 1‖₊ = + ‖cutoffCoefficientProducts w a (0, x) i - 1‖₊ := NNReal.eq (hn i) + simp only [Pi.norm_def, Pi.sub_apply, Pi.one_apply, hnn] + +/-- Finite-word-system solvability with an actual distinguished-word sublevel +isolator. Arbitrarily singular initial word roots are allowed. -/ +theorem coefficient_word_sublevel_solvable {ι : Type*} {m d : ℕ} + (w : Fin m → FreeGroup (ι ⊕ Fin m)) (ρ : Fin d → FreeGroup (ι ⊕ Fin m)) + (a : ℝ → ι → SU2) (ha : ∀ i, ContDiff ℝ ∞ (fun t => (a t i : ℍ))) + (ha0 : ∀ i, a 0 i = 1) + (hB : (exponentMatrix (fun i => eraseCoefficients (w i))).det ≠ 0) + (δ : ℝ) (hδ : 0 < δ) + (hiso : ∀ t ∈ Icc (0 : ℝ) 1, ∀ x : Fin m → SU2, + coefficientWordMap w a (t, x) = 1 → + ‖(fun i => (coefficientWordMap ρ a (t, x) i : ℍ)) - 1‖ ≠ δ) : + ∃ x : Fin m → SU2, coefficientWordMap w a (1, x) = 1 ∧ + ‖(fun i => (coefficientWordMap ρ a (1, x) i : ℍ)) - 1‖ < δ := by + let E := (Fin m → ℂ) × (Fin m → ℂ) + let e : (Fin m → ℍ) ≃L[ℝ] E := quaternionTupleCoordinates + let H : ℝ × E → ℝ × (Fin m → ℍ) := fun q => (q.1, e.symm q.2) + have hH : ContDiff ℝ ∞ H := contDiff_fst.prodMk (e.symm.contDiff.comp contDiff_snd) + let F : ℝ × E → E := fun q => e (smoothRadialCoefficientWordMap w a (H q)) - (1, 0) + let h : ℝ × E → ℝ := fun q => ‖cutoffCoefficientProducts ρ a (H q) - 1‖ + have hF : ContDiff ℝ 2 F := contDiff_infty.mp + ((e.contDiff.comp ((smoothRadialCoefficientWordMap_smooth w a ha).comp hH)).sub contDiff_const) 2 + have hF0 : ∀ q, F (0, q) = splitWordMap (fun i => eraseCoefficients (w i)) q := by + intro q + dsimp only [F, H] + rw [smoothRadialCoefficientWordMap_initial w a ha0] + rfl + have hh : Continuous h := (((cutoffCoefficientProducts_smooth ρ a ha).comp hH).continuous.sub continuous_const).norm + have he1 : e (1 : Fin m → ℍ) = (1, 0) := by + change quaternionTupleCoordinates + (fun _ : Fin m => Quaternion.ofComplex (1 : ℂ)) = _ + exact quaternionTupleCoordinates_fixed 1 + have hroot (q : ℝ × E) (hq : F q = 0) : + (∀ i, ‖e.symm q.2 i‖ = 1) ∧ + coefficientWordMap w a (q.1, fun i => normalizeQuaternion (e.symm q.2 i)) = 1 := by + apply (smoothRadialCoefficientWordMap_eq_one_iff w a (H q)).mp + apply e.injective + rw [he1] + exact sub_eq_zero.mp hq + have hnorm (q : ℝ × E) (hq : F q = 0) : ‖q.2‖ ≤ ‖e.toContinuousLinearMap‖ := by + have hle : ‖e.symm q.2‖ ≤ 1 := (pi_norm_le_iff_of_nonneg (by positivity)).mpr + (fun i => (hroot q hq).1 i |>.le) + calc + ‖q.2‖ = ‖e (e.symm q.2)‖ := by rw [e.apply_symm_apply] + _ ≤ ‖e.toContinuousLinearMap‖ * ‖e.symm q.2‖ := e.toContinuousLinearMap.le_opNorm _ + _ ≤ ‖e.toContinuousLinearMap‖ := mul_le_of_le_one_right (norm_nonneg e.toContinuousLinearMap) hle + have hunit (q : ℝ × E) (hq : F q = 0) : + (fun i => ((normalizeQuaternion (e.symm q.2 i) : SU2) : ℍ)) = e.symm q.2 := by + funext i + have hn := (hroot q hq).1 i + rw [normalizeQuaternion_coe_of_ne_zero (by intro hz; simp [hz] at hn), hn, inv_one, one_smul] + have hsizeroot (q : ℝ × E) (hq : F q = 0) : + h q = ‖(fun i => (coefficientWordMap ρ a + (q.1, fun j => normalizeQuaternion (e.symm q.2 j)) i : ℍ)) - 1‖ := by + dsimp only [h, H] + conv_lhs => rw [← hunit q hq, cutoffCoefficientProducts_unitary] + have hi : ∀ z : ℂ, ‖z‖ = 1 → ∀ q : E, h (0, (q.1, z • q.2)) = h (0, q) := by + intro z hz q + obtain ⟨c, hc⟩ := circle_exists_square_root z hz + have heq : e.symm (q.1, z • q.2) = + fun i => quaternionConjugate (circleQuaternion c) (e.symm q i) := by + apply e.injective + rw [e.apply_symm_apply, quaternionTupleCoordinates_conjCircle, hc, e.apply_symm_apply] + dsimp only [h, H] + rw [heq] + exact cutoffCoefficientProducts_initial_size_invariant ρ a ha0 _ _ + have h1 : h (0, (1, 0)) < δ := by + have he : e.symm (1, 0) = 1 := by rw [← he1, e.symm_apply_apply] + have hp : coefficientWordMap ρ a (0, (1 : Fin m → SU2)) = 1 := by + rw [coefficientWordMap_initial ρ a ha0] + have hl : FreeGroup.lift (1 : Fin m → SU2) = 1 := by + apply FreeGroup.ext_hom + intro i + simp + funext i + rw [hl] + rfl + dsimp only [h, H] + rw [he] + have hco : (1 : Fin m → ℍ) = fun i => ((1 : Fin m → SU2) i : ℍ) := rfl + rw [hco, cutoffCoefficientProducts_unitary, hp] + change ‖(1 : Fin d → ℍ) - 1‖ < δ + simpa only [sub_self, norm_zero] using hδ + let R : ℝ := ‖e.toContinuousLinearMap‖ + ‖((1 : Fin m → ℂ), (0 : Fin m → ℂ))‖ + 1 + obtain ⟨q, hq, hhq⟩ := localized_word_root_sublevel + (fun i => eraseCoefficients (w i)) hB F hF hF0 h hh δ R + (by dsimp only [R]; have hn := norm_nonneg e.toContinuousLinearMap; linarith) h1 hi + (fun q _ hq => by dsimp only [R]; have hn := hnorm q hq; have hp := norm_nonneg ((1 : Fin m → ℂ), (0 : Fin m → ℂ)); linarith) + (fun q ht hq => by rw [hsizeroot q hq]; exact hiso q.1 ht _ (hroot q hq).2) + refine ⟨fun i => normalizeQuaternion (e.symm q i), (hroot (1, q) hq).2, ?_⟩ + simpa only [hsizeroot (1, q) hq] using hhq +end EilenbergGanea + + +end + +end OAI diff --git a/lean/OAI/Topology/HahnSeries/Pivots.lean b/lean/OAI/Topology/HahnSeries/Pivots.lean new file mode 100644 index 0000000000000000000000000000000000000000..ecd1001b22d2079e4e3b19a7b150337443449053 --- /dev/null +++ b/lean/OAI/Topology/HahnSeries/Pivots.lean @@ -0,0 +1,852 @@ +import OAI.LinearAlgebra.RankMatching.Basic + +namespace OAI + +noncomputable section +open scoped BigOperators nonZeroDivisors +open LinearMap Submodule +open CategoryTheory CategoryTheory.Limits HomologicalComplex + +namespace HahnWilson.PivotTopology +open HahnSeries +open scoped BigOperators Topology +variable {k : Type*} [Field k] + +def poleLattice (J : ℤ) : Submodule k (LaurentSeries k) where + carrier := {f | ∀ i : ℤ, J < i → f.coeff (-i) = 0} + zero_mem' := by simp + add_mem' hf hg i hi := by simp [hf i hi, hg i hi] + smul_mem' c f hf i hi := by simp [hf i hi] + +def monomial (j : ℤ) : LaurentSeries k := HahnSeries.single (-j) 1 + +def PreservesPoles (a : LaurentSeries k →ₗ[k] LaurentSeries k) : Prop := + ∀ J, ∀ f ∈ poleLattice (k := k) J, a f ∈ poleLattice (k := k) J + +def matrixOf (a : LaurentSeries k →ₗ[k] LaurentSeries k) : Matrix ℤ ℤ k := + fun l j => (a (monomial j)).coeff (-l) + +def HasLeadingTerm (f : LaurentSeries k) (j : ℤ) : Prop := + f ∈ poleLattice (k := k) j ∧ f.coeff (-j) = 1 + +def HasLeadingPosition (f : LaurentSeries k) (j : ℤ) : Prop := + f ∈ poleLattice (k := k) j ∧ f.coeff (-j) ≠ 0 + +def crossing (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : Set (ℤ × ℤ) := + {p | RankMatching.Matched (matrixOf a) p.1 p.2 ∧ p.1 ≤ J ∧ J < p.2} + +def crossingQuotient (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) := + ↥(LinearMap.range a ⊓ poleLattice (k := k) J) ⧸ + Submodule.comap (LinearMap.range a ⊓ poleLattice (k := k) J).subtype + ((poleLattice (k := k) J).map a) + +instance crossingQuotient_addCommGroup (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : + AddCommGroup (crossingQuotient a J) := by + unfold crossingQuotient + infer_instance + +instance crossingQuotient_module (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : + Module k (crossingQuotient a J) := by + unfold crossingQuotient + infer_instance + +@[simp] lemma mem_poleLattice (J : ℤ) (f : LaurentSeries k) : + f ∈ poleLattice J ↔ ∀ i : ℤ, J < i → f.coeff (-i) = 0 := Iff.rfl + +lemma poleLattice_mono {I J : ℤ} (h : I ≤ J) : + poleLattice (k := k) I ≤ poleLattice J := by + intro f hf i hi + exact hf i (lt_of_le_of_lt h hi) + +@[simp] lemma coeff_monomial (j i : ℤ) : + (monomial (k := k) j).coeff (-i) = if i = j then 1 else 0 := by + simp [monomial, HahnSeries.coeff_single] + +lemma monomial_mem {j J : ℤ} (h : j ≤ J) : monomial (k := k) j ∈ poleLattice J := by + intro i hi + simp [show i ≠ j by omega] + +lemma exists_poleLattice (f : LaurentSeries k) : ∃ J, f ∈ poleLattice J := by + refine ⟨-f.order, ?_⟩ + intro i hi + exact HahnSeries.coeff_eq_zero_of_lt_order (by omega) + +lemma matrixOf_triangular (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) : RankMatching.Triangular (matrixOf a) := by + intro l j h + exact ha j (monomial j) (monomial_mem le_rfl) l h + +def truncate (f : LaurentSeries k) (L J : ℤ) : LaurentSeries k := + ∑ c ∈ Finset.Icc L J, f.coeff (-c) • monomial c + +lemma coeff_truncate (f : LaurentSeries k) (L J i : ℤ) : + (truncate f L J).coeff (-i) = if L ≤ i ∧ i ≤ J then f.coeff (-i) else 0 := by + classical + simp [truncate, HahnSeries.coeff_sum, HahnSeries.coeff_smul, smul_eq_mul, + mul_ite] + +lemma truncate_mem (f : LaurentSeries k) (L J : ℤ) : truncate f L J ∈ poleLattice J := by + intro i hi + rw [coeff_truncate, ite_eq_right (by omega)] + +lemma sub_truncate_mem {f : LaurentSeries k} {L J : ℤ} (hf : f ∈ poleLattice J) : + f - truncate f L J ∈ poleLattice (L - 1) := by + intro i hi + rw [HahnSeries.coeff_sub, coeff_truncate] + by_cases hij : i ≤ J + · rw [ite_eq_left (by omega), sub_self] + · rw [ite_eq_right (by omega), sub_zero, hf i (by omega)] + +def poleProjection (L : ℤ) : LaurentSeries k →ₗ[k] (ℤ → k) where + toFun f i := if L ≤ i then f.coeff (-i) else 0 + map_add' f g := by ext i; by_cases hi : L ≤ i <;> simp [hi] + map_smul' c f := by ext i; by_cases hi : L ≤ i <;> simp [hi] + +lemma poleProjection_eq_zero {L : ℤ} {f : LaurentSeries k} : + poleProjection L f = 0 ↔ f ∈ poleLattice (L - 1) := by + constructor + · intro h i hi + have := congrFun h i + simpa [poleProjection, show L ≤ i by omega] using this + · intro h + ext i + by_cases hi : L ≤ i + · simp [poleProjection, hi, h i (by omega)] + · simp [poleProjection, hi] + +@[simp] lemma poleProjection_monomial_image + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (L j : ℤ) : + poleProjection L (a (monomial j)) = RankMatching.column (matrixOf a) L j := rfl + +lemma poleProjection_truncate_image (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) {f : LaurentSeries k} {L J : ℤ} + (hf : f ∈ poleLattice J) : + poleProjection L (a (truncate f L J)) = poleProjection L (a f) := by + have h := (poleProjection_eq_zero).mpr (ha (L - 1) _ (sub_truncate_mem hf)) + rw [map_sub, map_sub, sub_eq_zero] at h + exact h.symm + +lemma columnSpace_eq_projectedImage (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) (L J : ℤ) : + RankMatching.columnSpace (matrixOf a) L J = + ((poleLattice J).map a).map (poleProjection L) := by + classical + apply le_antisymm + · apply Submodule.span_le.mpr + rintro _ ⟨c, hc, rfl⟩ + exact ⟨a (monomial c), ⟨monomial c, monomial_mem hc, rfl⟩, rfl⟩ + · rintro y ⟨z, ⟨f,hf,rfl⟩,rfl⟩ + rw [← poleProjection_truncate_image a ha hf] + simp only [truncate, map_sum, map_smul] + exact Submodule.sum_mem _ fun c hc => + Submodule.smul_mem _ _ (Submodule.subset_span + ⟨c, (Finset.mem_Icc.mp hc).2, rfl⟩) + +lemma increment_zero_iff_finite_solution + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) (L j : ℤ) : + RankMatching.increment (matrixOf a) L j = 0 ↔ + ∃ f, HasLeadingTerm f j ∧ a f ∈ poleLattice (L - 1) := by + rw [RankMatching.increment_eq_zero_iff, columnSpace_eq_projectedImage a ha] + constructor + · rintro ⟨z, ⟨g,hg,rfl⟩,heq⟩ + refine ⟨monomial j - g, ⟨?_, ?_⟩, ?_⟩ + · intro i hi + simp only [HahnSeries.coeff_sub, coeff_monomial, + ite_eq_right (show i ≠ j by omega), hg i (by omega), sub_self] + · simp [HahnSeries.coeff_sub, hg j (by omega)] + · apply poleProjection_eq_zero.mp + rw [map_sub, map_sub, poleProjection_monomial_image, ← heq, sub_self] + · rintro ⟨f, ⟨hf,hfj⟩,haf⟩ + have hg : monomial j - f ∈ poleLattice (j - 1) := by + intro i hi + by_cases hij : i = j + · subst i; simp [HahnSeries.coeff_sub, hfj] + · simp [HahnSeries.coeff_sub, coeff_monomial, hij, hf i (by omega)] + refine ⟨a (monomial j - f), ⟨monomial j - f, hg, rfl⟩, ?_⟩ + rw [map_sub, map_sub, poleProjection_monomial_image, + poleProjection_eq_zero.mpr haf, sub_zero] + +open WithZero + +lemma mem_poleLattice_iff_valuation (J : ℤ) (f : LaurentSeries k) : + f ∈ poleLattice J ↔ Valued.v f ≤ WithZero.exp J := by + rw [show J = -(-J) by omega, LaurentSeries.valuation_le_iff_coeff_lt_eq_zero] + constructor + · intro hf n hn + simpa using hf (-n) (by omega) + · intro hf i hi + exact hf (-i) (by omega) + +lemma poleLattice_eq_ball (J : ℤ) : + (poleLattice (k := k) J : Set (LaurentSeries k)) = + {f | (Valued.v : Valuation (LaurentSeries k) ℤᵐ⁰).restrict f ≤ + (Valued.v : Valuation (LaurentSeries k) ℤᵐ⁰).restrict (monomial J)} := by + ext f + change f ∈ poleLattice J ↔ (Valued.v : Valuation (LaurentSeries k) ℤᵐ⁰).restrict f ≤ + (Valued.v : Valuation (LaurentSeries k) ℤᵐ⁰).restrict (monomial J) + rw [Valuation.restrict_le_iff, mem_poleLattice_iff_valuation] + simp [monomial, LaurentSeries.valuation_single_zpow] + +lemma isClosed_poleLattice (J : ℤ) : IsClosed (poleLattice (k := k) J : Set (LaurentSeries k)) := by + rw [poleLattice_eq_ball] + exact Valued.isClosed_closedBall _ _ + +lemma isOpen_poleLattice (J : ℤ) : IsOpen (poleLattice (k := k) J : Set (LaurentSeries k)) := by + rw [poleLattice_eq_ball] + apply Valued.isOpen_closedBall + rw [ne_eq, Valuation.restrict_eq_zero_iff] + simp [monomial, LaurentSeries.valuation_single_zpow] + +lemma poleLattice_nhds_basis : + (𝓝 (0 : LaurentSeries k)).HasBasis (fun _ : ℤ => True) + (fun J => (poleLattice (k := k) J : Set (LaurentSeries k))) := by + let v : Valuation (LaurentSeries k) ℤᵐ⁰ := Valued.v + apply (Valued.hasBasis_nhds_zero (LaurentSeries k) ℤᵐ⁰).to_hasBasis + · intro γ _ + let r : ℤᵐ⁰ := MonoidWithZeroHom.ValueGroup₀.embedding γ.val + have hr : r ≠ 0 := (Units.map + (MonoidWithZeroHom.ValueGroup₀.embedding (f := .ofClass v)).toMonoidHom γ).ne_zero + refine ⟨WithZero.log r - 1, trivial, ?_⟩ + intro f hf + rw [Set.mem_ofPred_eq, Valuation.restrict_lt_iff_lt_embedding] + apply (mem_poleLattice_iff_valuation _ f).mp hf |>.trans_lt + change WithZero.exp (WithZero.log r - 1) < r + calc + _ < WithZero.exp (WithZero.log r) := WithZero.exp_lt_exp.mpr (by omega) + _ = r := WithZero.exp_log hr + · intro J _ + have hn : v.restrict (monomial J) ≠ 0 := by + rw [ne_eq, Valuation.restrict_eq_zero_iff] + simp [v, monomial, LaurentSeries.valuation_single_zpow] + refine ⟨Units.mk0 _ hn, trivial, ?_⟩ + intro f hf + rw [poleLattice_eq_ball] + change v.restrict f < v.restrict (monomial J) at hf + exact hf.le + +lemma continuous_of_preservesPoles (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) : Continuous a := by + apply continuous_of_continuousAt_zero a + simp only [ContinuousAt, map_zero] + rw [poleLattice_nhds_basis.tendsto_iff poleLattice_nhds_basis] + exact fun J _ => ⟨J, trivial, ha J⟩ + +lemma continuous_of_bounded_coefficients [UniformSpace k] [DiscreteTopology k] + {X : Type*} [TopologicalSpace X] (g : X → LaurentSeries k) (J : ℤ) + (hg : ∀ x, g x ∈ poleLattice J) + (hcoeff : ∀ n : ℤ, Continuous (fun x => (g x).coeff n)) : Continuous g := by + rw [continuous_iff_continuousAt] + intro x + apply tendsto_sub_nhds_zero_iff.mp + rw [poleLattice_nhds_basis.tendsto_right_iff] + intro M _ + have hev : ∀ᶠ y in 𝓝 x, ∀ i ∈ Finset.Ioc M J, + (g y).coeff (-i) = (g x).coeff (-i) := by + rw [Filter.eventually_all_finset] + intro i _ + exact (hcoeff (-i)).continuousAt.eventually + ((isOpen_discrete {(g x).coeff (-i)}).mem_nhds rfl) + filter_upwards [hev] with y hy + intro i hi + rw [HahnSeries.coeff_sub, sub_eq_zero] + by_cases hij : i ≤ J + · exact hy i (Finset.mem_Ioc.mpr ⟨hi,hij⟩) + · rw [hg y i (by omega), hg x i (by omega)] + +def stageSeries (J : ℤ) (c : ℤ → k) : LaurentSeries k := + HahnSeries.ofSuppBddBelow (fun n => if -J ≤ n then c n else 0) + ⟨-J, by + intro n hn + by_contra h + exact hn (ite_eq_right h)⟩ + +@[simp] lemma coeff_stageSeries (J : ℤ) (c : ℤ → k) (n : ℤ) : + (stageSeries J c).coeff n = if -J ≤ n then c n else 0 := rfl + +lemma stageSeries_mem (J : ℤ) (c : ℤ → k) : stageSeries J c ∈ poleLattice J := by + intro i hi + rw [coeff_stageSeries, ite_eq_right (by omega)] + +lemma range_stageSeries (J : ℤ) : + Set.range (stageSeries (k := k) J) = (poleLattice (k := k) J : Set (LaurentSeries k)) := by + ext f + constructor + · rintro ⟨c,rfl⟩ + exact stageSeries_mem J c + · intro hf + refine ⟨f.coeff, ?_⟩ + apply HahnSeries.ext + funext n + rw [coeff_stageSeries] + split_ifs with hn + · rfl + · symm + simpa using hf (-n) (by omega) + +lemma continuous_stageSeries [UniformSpace k] [DiscreteTopology k] (J : ℤ) : + Continuous (stageSeries (k := k) J) := by + apply continuous_of_bounded_coefficients _ J (stageSeries_mem J) + intro n + simp only [coeff_stageSeries] + split_ifs + · exact continuous_apply n + · exact continuous_const + +lemma isCompact_poleLattice [Finite k] (J : ℤ) : + IsCompact (poleLattice (k := k) J : Set (LaurentSeries k)) := by + let : UniformSpace k := ⊥ + rw [← range_stageSeries, ← Set.image_univ] + exact isCompact_univ.image (continuous_stageSeries J) + +lemma isCompact_leadingTerm [Finite k] (j : ℤ) : + IsCompact {f : LaurentSeries k | HasLeadingTerm f j} := by + let : UniformSpace k := ⊥ + exact (isCompact_poleLattice j).inter_right + (isClosed_eq (LaurentSeries.uniformContinuous_coeff (-j)).continuous continuous_const) + +lemma isClosed_leadingTerm (j : ℤ) : + IsClosed {f : LaurentSeries k | HasLeadingTerm f j} := by + let : UniformSpace k := ⊥ + exact (isClosed_poleLattice j).inter + (isClosed_eq (LaurentSeries.uniformContinuous_coeff (-j)).continuous continuous_const) + +lemma unmatched_iff_increments_zero (A : Matrix ℤ ℤ k) + (hA : RankMatching.Triangular A) (j : ℤ) : + (∀ l, ¬ RankMatching.Matched A l j) ↔ ∀ L, RankMatching.increment A L j = 0 := by + constructor + · intro h L + by_cases hLj : L ≤ j + · have hw : ∀ l, RankMatching.weight A l j = 0 := fun l => + (RankMatching.weight_zero_or_one A hA l j).resolve_right (h l) + have hs := RankMatching.sum_interval_difference + (fun l => (RankMatching.increment A l j : ℤ)) L j (by omega) + simp_rw [← RankMatching.weight_eq_increment_sub A hA, hw] at hs + rw [RankMatching.increment_zero A hA (show j < j + 1 by omega)] at hs + simpa using hs.symm + · exact RankMatching.increment_zero A hA (by omega) + · intro h l hm + have hi := (RankMatching.matched_iff_increments A hA l j).mp hm + rw [h l] at hi + exact Nat.zero_ne_one hi.1 + +theorem unmatched_iff_kernel [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) (j : ℤ) : + (∀ l, ¬ RankMatching.Matched (matrixOf a) l j) ↔ + ∃ f, a f = 0 ∧ HasLeadingTerm f j := by + rw [unmatched_iff_increments_zero _ (matrixOf_triangular a ha)] + constructor + · intro h + let S : ℤ → Set (LaurentSeries k) := fun L => + {f | HasLeadingTerm f j ∧ a f ∈ poleLattice (L - 1)} + have hc : ∀ L, IsClosed (S L) := fun L => + (isClosed_leadingTerm j).inter + ((isClosed_poleLattice (L - 1)).preimage (continuous_of_preservesPoles a ha)) + have hk : ∀ L, IsCompact (S L) := fun L => + (isCompact_leadingTerm j).of_isClosed_subset (hc L) (fun _ h => h.1) + have hn : ∀ L, (S L).Nonempty := fun L => + (increment_zero_iff_finite_solution a ha L j).mp (h L) + have hd : Directed (fun s t : Set (LaurentSeries k) => s ⊇ t) S := by + intro L M + refine ⟨min L M, ?_, ?_⟩ + · intro f hf + exact ⟨hf.1, poleLattice_mono (by omega) hf.2⟩ + · intro f hf + exact ⟨hf.1, poleLattice_mono (by omega) hf.2⟩ + obtain ⟨f,hf⟩ := IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed S hd hn hk hc + have hf' : ∀ L, f ∈ S L := Set.mem_iInter.mp hf + refine ⟨f, ?_, (hf' j).1⟩ + apply HahnSeries.ext + funext n + simpa using (hf' (-n)).2 (-n) (by omega) + · rintro ⟨f,haf,hfj⟩ L + apply (increment_zero_iff_finite_solution a ha L j).mpr + exact ⟨f,hfj,haf ▸ (poleLattice (L - 1)).zero_mem⟩ + +lemma rowRank_step (A : Matrix ℤ ℤ k) (hA : RankMatching.Triangular A) (l J : ℤ) : + RankMatching.blockRank A l J = RankMatching.blockRank A (l + 1) J + + RankMatching.increment (RankMatching.reflected A) (-J) (-l) := by + have h := RankMatching.blockRank_step (RankMatching.reflected A) + (RankMatching.triangular_reflected A hA) (-J) (-l) + simpa only [RankMatching.blockRank_reflected, neg_neg, neg_sub, + Int.reduceNeg, sub_neg_eq_add, add_comm] using h + +lemma matchedRow_iff_unequal_ranks (A : Matrix ℤ ℤ k) + (hA : RankMatching.Triangular A) (l : ℤ) : + (∃ j, RankMatching.Matched A l j) ↔ + ∃ J, RankMatching.blockRank A l J ≠ RankMatching.blockRank A (l + 1) J := by + have hn : (∀ j, ¬ RankMatching.Matched A l j) ↔ + ∀ J, RankMatching.blockRank A l J = RankMatching.blockRank A (l + 1) J := by + have hh := unmatched_iff_increments_zero (RankMatching.reflected A) + (RankMatching.triangular_reflected A hA) (-l) + constructor + · intro h J + have hh' : ∀ r, ¬ RankMatching.Matched (RankMatching.reflected A) r (-l) := by + intro r hr + apply h (-r) + simpa only [RankMatching.Matched, RankMatching.weight_reflected, neg_neg] using hr + rw [rowRank_step A hA l J, hh.mp hh' (-J), add_zero] + · intro h j hm + have hh' : ∀ r, RankMatching.increment (RankMatching.reflected A) r (-l) = 0 := by + intro r + have hs := rowRank_step A hA l (-r) + rw [neg_neg, h (-r)] at hs + omega + apply hh.mpr hh' (-j) + simpa only [RankMatching.Matched, RankMatching.weight_reflected, neg_neg] using hm + simpa only [not_forall, not_not] using not_congr hn + +lemma exists_rowCut_kernel_of_unequal_ranks (A : Matrix ℤ ℤ k) + (hA : RankMatching.Triangular A) (l J : ℤ) + (hr : RankMatching.blockRank A l J ≠ RankMatching.blockRank A (l + 1) J) : + ∃ v ∈ RankMatching.columnSpace A l J, + RankMatching.rowCut (l + 1) v = 0 ∧ v l ≠ 0 := by + let F : RankMatching.columnSpace A l J →ₗ[k] RankMatching.columnSpace A (l + 1) J := + (RankMatching.rowCut (l + 1)).restrict + (fun _ hv => RankMatching.rowCut_columnSpace A (by omega) J hv) + have hs : Function.Surjective F := by + intro v + have hm : (v : ℤ → k) ∈ (RankMatching.columnSpace A l J).map + (RankMatching.rowCut (l + 1)) := by + rw [RankMatching.rowCut_map_columnSpace A (by omega)] + exact v.property + obtain ⟨w,hw,he⟩ := Submodule.mem_map.mp hm + exact ⟨⟨w,hw⟩, Subtype.ext he⟩ + have hni : ¬ Function.Injective F := by + intro hi + apply hr + have he := (LinearEquiv.ofBijective F ⟨hi,hs⟩).finrank_eq + simpa only [RankMatching.blockRank_eq_finrank A hA] using he + have hk : F.ker ≠ ⊥ := fun h => hni (LinearMap.ker_eq_bot.mp h) + obtain ⟨v,hv,hvz⟩ := F.ker.ne_bot_iff.mp hk + have hcut : RankMatching.rowCut (l + 1) (v : ℤ → k) = 0 := + congrArg Subtype.val (show F v = 0 from hv) + refine ⟨v, v.property, hcut, ?_⟩ + intro hvl + apply hvz + apply Subtype.ext + funext r + rcases lt_trichotomy r l with hlt | heq | hgt + · exact RankMatching.columnSpace_supported A l J v.property hlt + · simpa [heq] using hvl + · have he := congrFun hcut r + simpa [RankMatching.rowCut, hgt] using he + +theorem matched_row_iff_image + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) (l : ℤ) : + (∃ j, RankMatching.Matched (matrixOf a) l j) ↔ + ∃ f, HasLeadingPosition (a f) l := by + rw [matchedRow_iff_unequal_ranks _ (matrixOf_triangular a ha)] + constructor + · rintro ⟨J,hJ⟩ + obtain ⟨v,hv,hcut,hvl⟩ := exists_rowCut_kernel_of_unequal_ranks + (matrixOf a) (matrixOf_triangular a ha) l J hJ + rw [columnSpace_eq_projectedImage a ha] at hv + obtain ⟨z,⟨f,hf,rfl⟩,rfl⟩ := hv + refine ⟨f, ?_, ?_⟩ + · intro i hi + have he := congrFun hcut i + simpa [RankMatching.rowCut, poleProjection, hi, + show l ≤ i by omega] using he + · simpa [poleProjection] using hvl + · rintro ⟨f,hf,hfl⟩ + obtain ⟨J,hJ⟩ := exists_poleLattice f + refine ⟨J, ?_⟩ + intro heq + have hv : poleProjection l (a f) ∈ RankMatching.columnSpace (matrixOf a) l J := by + rw [columnSpace_eq_projectedImage a ha] + exact ⟨a f,⟨f,hJ,rfl⟩,rfl⟩ + have hcut : RankMatching.rowCut (l + 1) (poleProjection l (a f)) = 0 := by + ext i + by_cases hi : l + 1 ≤ i + · simp [RankMatching.rowCut, poleProjection, show l ≤ i by omega, + hf i (by omega)] + · simp [RankMatching.rowCut, show ¬ l < i by omega] + have hi := RankMatching.rowCut_injOn_of_equal_ranks + (matrixOf a) (matrixOf_triangular a ha) l J heq + have he : poleProjection l (a f) = 0 := hi hv (Submodule.zero_mem _) (by simpa using hcut) + apply hfl + simpa [poleProjection] using congrFun he l + +def stageImage (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : + Submodule k (LaurentSeries k) := (poleLattice J).map a + +lemma stageImage_mono (a : LaurentSeries k →ₗ[k] LaurentSeries k) : Monotone (stageImage a) := by + intro I J h + exact Submodule.map_mono (poleLattice_mono h) + +lemma stageImage_le_poleLattice (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) (J : ℤ) : stageImage a J ≤ poleLattice J := by + rintro z ⟨f,hf,rfl⟩ + exact ha J f hf + +lemma stageImage_step (a : LaurentSeries k →ₗ[k] LaurentSeries k) (j : ℤ) : + stageImage a j = stageImage a (j - 1) ⊔ Submodule.span k {a (monomial j)} := by + apply le_antisymm + · rintro z ⟨f,hf,rfl⟩ + have ht : f - f.coeff (-j) • monomial j ∈ poleLattice (j - 1) := by + intro i hi + by_cases hij : i = j + · subst i; simp [HahnSeries.coeff_sub, HahnSeries.coeff_smul] + · simp [HahnSeries.coeff_sub, HahnSeries.coeff_smul, coeff_monomial, hij, + hf i (by omega)] + apply Submodule.mem_sup.mpr + refine ⟨a (f - f.coeff (-j) • monomial j), ⟨_,ht,rfl⟩, + f.coeff (-j) • a (monomial j), + Submodule.smul_mem _ _ (Submodule.subset_span (Set.mem_singleton _)), ?_⟩ + simp + · apply sup_le (stageImage_mono a (by omega)) + rw [Submodule.span_singleton_le_iff_mem] + exact ⟨monomial j, monomial_mem le_rfl, rfl⟩ + +lemma monomial_image_mem_iff_unmatched [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) (j : ℤ) : + a (monomial j) ∈ stageImage a (j - 1) ↔ + ∀ l, ¬ RankMatching.Matched (matrixOf a) l j := by + rw [unmatched_iff_kernel a ha] + constructor + · rintro ⟨g,hg,he⟩ + refine ⟨monomial j - g, by simp [he], ?_, ?_⟩ + · intro i hi + simp [HahnSeries.coeff_sub, coeff_monomial, show i ≠ j by omega, hg i (by omega)] + · simp [HahnSeries.coeff_sub, hg j (by omega)] + · rintro ⟨f,haf,hf,hfj⟩ + refine ⟨monomial j - f, ?_, by simp [haf]⟩ + intro i hi + by_cases hij : i = j + · subst i; simp [HahnSeries.coeff_sub, hfj] + · simp [HahnSeries.coeff_sub, coeff_monomial, hij, hf i (by omega)] + +def imageModulo (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J N : ℤ) : + Submodule k (LaurentSeries k ⧸ stageImage a J) := + (stageImage a N).map (stageImage a J).mkQ + +lemma imageModulo_mono (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : + Monotone (imageModulo a J) := fun _ _ h => Submodule.map_mono (stageImage_mono a h) + +lemma imageModulo_zero (a : LaurentSeries k →ₗ[k] LaurentSeries k) {J N : ℤ} (h : N ≤ J) : + imageModulo a J N = ⊥ := by + apply le_antisymm _ bot_le + rw [imageModulo, Submodule.map_le_iff_le_comap, Submodule.comap_bot, Submodule.ker_mkQ] + exact stageImage_mono a h + +lemma imageModulo_step (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J n : ℤ) : + imageModulo a J n = imageModulo a J (n - 1) ⊔ + Submodule.span k {(stageImage a J).mkQ (a (monomial n))} := by + rw [imageModulo, stageImage_step a n, Submodule.map_sup, Submodule.map_span, Set.image_singleton] + rfl + +lemma imageModulo_finite (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J N : ℤ) : + FiniteDimensional k (imageModulo a J N) := by + by_cases h : J ≤ N + · induction N, h using Int.leInduction with + | base => rw [imageModulo_zero a le_rfl]; infer_instance + | succ n hn ih => + rw [imageModulo_step, add_sub_cancel_right] + let := ih + infer_instance + · rw [imageModulo_zero a (by omega)] + infer_instance + +lemma mem_imageModulo (a : LaurentSeries k →ₗ[k] LaurentSeries k) {J N : ℤ} + (h : J ≤ N) (f : LaurentSeries k) : + (stageImage a J).mkQ f ∈ imageModulo a J N ↔ f ∈ stageImage a N := by + change f ∈ ((stageImage a N).map (stageImage a J).mkQ).comap (stageImage a J).mkQ ↔ _ + rw [Submodule.comap_map_eq, Submodule.ker_mkQ, sup_eq_left.mpr (stageImage_mono a h)] + +open scoped Classical + +lemma imageModulo_finrank_step [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) {J n : ℤ} + (h : J < n) : + Module.finrank k (imageModulo a J n) = Module.finrank k (imageModulo a J (n - 1)) + + if ∃ l, RankMatching.Matched (matrixOf a) l n then 1 else 0 := by + classical + let := imageModulo_finite a J (n - 1) + rw [imageModulo_step, RankMatching.finrank_sup_singleton, + mem_imageModulo a (by omega), monomial_image_mem_iff_unmatched a ha] + by_cases hm : ∃ l, RankMatching.Matched (matrixOf a) l n + · have hn : ¬ (∀ l, ¬ RankMatching.Matched (matrixOf a) l n) := + fun hh => hh hm.choose hm.choose_spec + simp [hm, hn] + · simp [show ∀ l, ¬ RankMatching.Matched (matrixOf a) l n from fun l hl => hm ⟨l,hl⟩] + +lemma imageModulo_finrank [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) (J N : ℤ) : + Module.finrank k (imageModulo a J N) = + ∑ j ∈ Finset.Ioc J N, if ∃ l, RankMatching.Matched (matrixOf a) l j then 1 else 0 := by + classical + by_cases h : J ≤ N + · induction N, h using Int.leInduction with + | base => rw [imageModulo_zero a (J := J) (N := J) le_rfl, finrank_bot]; simp + | succ n hn ih => + have he : Finset.Ioc J (n + 1) = insert (n + 1) (Finset.Ioc J n) := by + ext i + simp only [Finset.mem_Ioc, Finset.mem_insert] + omega + rw [imageModulo_finrank_step a ha (by omega), add_sub_cancel_right, ih, + he, Finset.sum_insert (by simp)] + omega + · rw [imageModulo_zero a (by omega), finrank_bot, Finset.Ioc_eq_empty_of_le (by omega), + Finset.sum_empty] + +lemma matched_le (A : Matrix ℤ ℤ k) (hA : RankMatching.Triangular A) {l j : ℤ} + (h : RankMatching.Matched A l j) : l ≤ j := by + by_contra hn + have hz := RankMatching.increment_zero A hA (lt_of_not_ge hn) + have ho := ((RankMatching.matched_iff_increments A hA l j).mp h).1 + omega + +def columnMatches (A : Matrix ℤ ℤ k) (J N : ℤ) : Set (ℤ × ℤ) := + {p | RankMatching.Matched A p.1 p.2 ∧ J < p.2 ∧ p.2 ≤ N} + +def crossingStageMatches (A : Matrix ℤ ℤ k) (J N : ℤ) : Set (ℤ × ℤ) := + {p | RankMatching.Matched A p.1 p.2 ∧ p.1 ≤ J ∧ J < p.2 ∧ p.2 ≤ N} + +lemma columnMatches_snd_inj (A : Matrix ℤ ℤ k) (hA : RankMatching.Triangular A) + (J N : ℤ) : Set.InjOn Prod.snd (columnMatches A J N) := by + rintro ⟨l,j⟩ hp ⟨l',j'⟩ hq he + change j = j' at he + subst j' + exact Prod.ext (RankMatching.column_unique A hA hp.1 hq.1) rfl + +lemma columnMatches_finite (A : Matrix ℤ ℤ k) (hA : RankMatching.Triangular A) + (J N : ℤ) : (columnMatches A J N).Finite := by + exact Set.Finite.of_injOn (fun _ hp => hp.2) (columnMatches_snd_inj A hA J N) + (Set.finite_Ioc J N) + +lemma columnMatches_ncard (A : Matrix ℤ ℤ k) (hA : RankMatching.Triangular A) + (J N : ℤ) : (columnMatches A J N).ncard = + ∑ j ∈ Finset.Ioc J N, if ∃ l, RankMatching.Matched A l j then 1 else 0 := by + classical + have he : Prod.snd '' columnMatches A J N = + ↑((Finset.Ioc J N).filter (fun j => ∃ l, RankMatching.Matched A l j)) := by + ext j + simp only [Set.mem_image, columnMatches, Set.mem_ofPred_eq, Finset.mem_coe, + Finset.mem_filter, Finset.mem_Ioc] + constructor + · rintro ⟨⟨l,j'⟩,⟨hm,hJ,hN⟩,rfl⟩ + exact ⟨⟨hJ,hN⟩,l,hm⟩ + · rintro ⟨⟨hJ,hN⟩,l,hm⟩ + exact ⟨(l,j),⟨hm,hJ,hN⟩,rfl⟩ + rw [← (columnMatches_snd_inj A hA J N).ncard_image, he, + Set.ncard_coe_finset, Finset.sum_boole] + rfl + +lemma columnMatches_partition (A : Matrix ℤ ℤ k) (hA : RankMatching.Triangular A) + (J N : ℤ) : + (columnMatches A J N).ncard = (crossingStageMatches A J N).ncard + + RankMatching.blockRank A (J + 1) N := by + classical + let high := ((Finset.Icc (J + 1) N ×ˢ Finset.Icc (J + 1) N).filter + (fun p : ℤ × ℤ => RankMatching.Matched A p.1 p.2)) + have he : columnMatches A J N = crossingStageMatches A J N ∪ (high : Set (ℤ × ℤ)) := by + ext p + simp only [columnMatches, crossingStageMatches, Set.mem_ofPred_eq, Set.mem_union, + high, Finset.mem_coe, Finset.mem_filter, Finset.mem_product, Finset.mem_Icc] + constructor + · rintro ⟨hm,hJ,hN⟩ + by_cases hl : p.1 ≤ J + · exact Or.inl ⟨hm,hl,hJ,hN⟩ + · have hh := matched_le A hA hm + exact Or.inr ⟨⟨⟨by omega,by omega⟩,⟨by omega,hN⟩⟩,hm⟩ + · rintro (⟨hm,hl,hJ,hN⟩ | ⟨⟨hl,hj⟩,hm⟩) + · exact ⟨hm,hJ,hN⟩ + · exact ⟨hm,by omega,hj.2⟩ + have hd : Disjoint (crossingStageMatches A J N) (high : Set (ℤ × ℤ)) := by + apply Set.disjoint_left.mpr + intro p hp hq + simp only [high, Finset.mem_coe, Finset.mem_filter, Finset.mem_product, + Finset.mem_Icc] at hq + have hh := hp.2.1 + omega + have hf : (crossingStageMatches A J N).Finite := + (columnMatches_finite A hA J N).subset (fun _ h => ⟨h.1,h.2.2⟩) + rw [he, Set.ncard_union_eq hd hf high.finite_toSet, Set.ncard_coe_finset, + RankMatching.rank_eq_count A hA] + rfl + +lemma imageModulo_finrank_partition [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) (J N : ℤ) : + Module.finrank k (imageModulo a J N) = + (crossingStageMatches (matrixOf a) J N).ncard + RankMatching.blockRank (matrixOf a) (J + 1) N := by + rw [imageModulo_finrank a ha, ← columnMatches_ncard _ (matrixOf_triangular a ha), + columnMatches_partition _ (matrixOf_triangular a ha)] + +lemma stageImage_le_ker_projection (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) (J : ℤ) : stageImage a J ≤ (poleProjection (J + 1)).ker := by + intro f hf + change poleProjection (J + 1) f = 0 + apply poleProjection_eq_zero.mpr + simpa using stageImage_le_poleLattice a ha J hf + +def quotientProjection (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) (J : ℤ) : + (LaurentSeries k ⧸ stageImage a J) →ₗ[k] (ℤ → k) := + (stageImage a J).liftQ (poleProjection (J + 1)) (stageImage_le_ker_projection a ha J) + +@[simp] lemma quotientProjection_mkQ (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) (J : ℤ) (f : LaurentSeries k) : + quotientProjection a ha J ((stageImage a J).mkQ f) = poleProjection (J + 1) f := rfl + +def crossingStage (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J N : ℤ) : + Submodule k (LaurentSeries k ⧸ stageImage a J) := + (stageImage a N ⊓ poleLattice J).map (stageImage a J).mkQ + +lemma crossingStage_mono (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : + Monotone (crossingStage a J) := fun _ _ h => + Submodule.map_mono (inf_le_inf_right _ (stageImage_mono a h)) + +lemma crossingStage_finite (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J N : ℤ) : + FiniteDimensional k (crossingStage a J N) := by + let := imageModulo_finite a J N + exact Submodule.finiteDimensional_of_le (show crossingStage a J N ≤ imageModulo a J N + from Submodule.map_mono inf_le_left) + +lemma crossingStage_eq_inf (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) (J N : ℤ) : + crossingStage a J N = imageModulo a J N ⊓ (quotientProjection a ha J).ker := by + ext z + constructor + · rintro ⟨f,⟨hf,hJ⟩,rfl⟩ + exact ⟨⟨f,hf,rfl⟩, poleProjection_eq_zero.mpr (by simpa using hJ)⟩ + · rintro ⟨⟨f,hf,rfl⟩,hz⟩ + refine ⟨f,⟨hf,?_⟩,rfl⟩ + have he : poleProjection (J + 1) f = 0 := hz + simpa using poleProjection_eq_zero.mp he + +lemma quotientProjection_stage_range (a : LaurentSeries k →ₗ[k] LaurentSeries k) + (ha : PreservesPoles a) (J N : ℤ) : + ((quotientProjection a ha J).domRestrict (imageModulo a J N)).range = + RankMatching.columnSpace (matrixOf a) (J + 1) N := by + rw [LinearMap.range_domRestrict, columnSpace_eq_projectedImage a ha] + ext v + constructor + · rintro ⟨z,⟨f,hf,rfl⟩,rfl⟩ + exact ⟨f,hf,rfl⟩ + · rintro ⟨f,hf,rfl⟩ + exact ⟨(stageImage a J).mkQ f, ⟨f,hf,rfl⟩,rfl⟩ + +lemma crossingStage_finrank [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) (J N : ℤ) : + Module.finrank k (crossingStage a J N) = (crossingStageMatches (matrixOf a) J N).ncard := by + let := imageModulo_finite a J N + let f := (quotientProjection a ha J).domRestrict (imageModulo a J N) + have hr := LinearMap.finrank_range_add_finrank_ker f + have hk : Module.finrank k f.ker = Module.finrank k (crossingStage a J N) := by + rw [← Submodule.finrank_map_subtype_eq (imageModulo a J N) f.ker, + show f.ker = ((quotientProjection a ha J).ker).comap (imageModulo a J N).subtype + from LinearMap.ker_domRestrict _ _, + Submodule.map_comap_subtype, ← crossingStage_eq_inf a ha] + have hi : Module.finrank k f.range = RankMatching.blockRank (matrixOf a) (J + 1) N := by + rw [quotientProjection_stage_range, ← RankMatching.blockRank_eq_finrank _ (matrixOf_triangular a ha)] + rw [hk,hi,imageModulo_finrank_partition a ha] at hr + omega + +def crossingSpace (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : + Submodule k (LaurentSeries k ⧸ stageImage a J) := + (a.range ⊓ poleLattice J).map (stageImage a J).mkQ + +lemma crossingStage_le_space (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J N : ℤ) : + crossingStage a J N ≤ crossingSpace a J := by + apply Submodule.map_mono + apply inf_le_inf_right + rintro f ⟨g,hg,rfl⟩ + exact ⟨g,rfl⟩ + +lemma crossingSpace_stabilizes [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) + (J : ℤ) (hc : (crossing a J).Finite) : + ∃ N : ℤ, J ≤ N ∧ crossingSpace a J = crossingStage a J N ∧ + crossingStageMatches (matrixOf a) J N = crossing a J := by + obtain ⟨b,hb⟩ := (hc.image Prod.snd).bddAbove + let N := max J b + have he (M : ℤ) (hM : N ≤ M) : + crossingStageMatches (matrixOf a) J M = crossing a J := by + ext p + constructor + · intro hp + exact ⟨hp.1,hp.2.1,hp.2.2.1⟩ + · intro hp + exact ⟨hp.1,hp.2.1,hp.2.2,le_trans (hb ⟨p,hp,rfl⟩) (le_trans (le_max_right J b) hM)⟩ + refine ⟨N, le_max_left _ _, ?_, he N le_rfl⟩ + apply le_antisymm _ (crossingStage_le_space a J N) + rintro z ⟨f,⟨⟨x,hx⟩,hf⟩,rfl⟩ + obtain ⟨M,hM⟩ := exists_poleLattice x + have heq : crossingStage a J N = crossingStage a J (max N M) := by + let := crossingStage_finite a J (max N M) + apply Submodule.eq_of_le_of_finrank_eq (crossingStage_mono a J (le_max_left _ _)) + rw [crossingStage_finrank a ha, crossingStage_finrank a ha, + he N le_rfl, he (max N M) (le_max_left _ _)] + rw [heq] + exact ⟨f,⟨⟨x,poleLattice_mono (le_max_right N M) hM,hx⟩,hf⟩,rfl⟩ + +def crossingQuotientEquiv (a : LaurentSeries k →ₗ[k] LaurentSeries k) (J : ℤ) : + crossingQuotient a J ≃ₗ[k] crossingSpace a J := by + let I := a.range ⊓ poleLattice (k := k) J + let f := (stageImage a J).mkQ.domRestrict I + have hk : f.ker = (stageImage a J).comap I.subtype := by + rw [LinearMap.ker_domRestrict, Submodule.ker_mkQ] + exact (Submodule.quotEquivOfEq _ _ hk.symm).trans + (f.quotKerEquivRange.trans (LinearEquiv.ofEq _ _ (LinearMap.range_domRestrict _ _))) + +theorem crossing_dimension [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) + (hc : ∀ J, (crossing a J).Finite) (J : ℤ) : + FiniteDimensional k (crossingQuotient a J) ∧ + Module.finrank k (crossingQuotient a J) = (crossing a J).ncard := by + obtain ⟨N,hN,he,hcN⟩ := crossingSpace_stabilizes a ha J (hc J) + have : FiniteDimensional k (crossingSpace a J) := by + rw [he] + exact crossingStage_finite a J N + refine ⟨(crossingQuotientEquiv a J).symm.finiteDimensional, ?_⟩ + rw [(crossingQuotientEquiv a J).finrank_eq, he, crossingStage_finrank a ha, hcN] + +lemma range_inf_stabilizes [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) + (J : ℤ) (hc : (crossing a J).Finite) : + ∃ N : ℤ, a.range ⊓ poleLattice J = stageImage a N ⊓ poleLattice J := by + obtain ⟨N,hN,he,_⟩ := crossingSpace_stabilizes a ha J hc + refine ⟨N,le_antisymm ?_ ?_⟩ + · intro f hf + have hq : (stageImage a J).mkQ f ∈ crossingStage a J N := by + rw [← he] + exact ⟨f,hf,rfl⟩ + have hi : (stageImage a J).mkQ f ∈ imageModulo a J N := + (Submodule.map_mono (show stageImage a N ⊓ poleLattice J ≤ stageImage a N + from inf_le_left)) hq + exact ⟨(mem_imageModulo a hN f).mp hi,hf.2⟩ + · rintro f ⟨⟨x,hx,rfl⟩,hf⟩ + exact ⟨⟨x,rfl⟩,hf⟩ + +lemma isCompact_range_inter_poleLattice [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) + (J : ℤ) (hc : (crossing a J).Finite) : + IsCompact ((Set.range a) ∩ (poleLattice (k := k) J : Set (LaurentSeries k))) := by + obtain ⟨N,he⟩ := range_inf_stabilizes a ha J hc + change IsCompact (↑(a.range ⊓ poleLattice J) : Set (LaurentSeries k)) + rw [he] + change IsCompact ((a '' (poleLattice (k := k) N : Set (LaurentSeries k))) ∩ + (poleLattice (k := k) J : Set (LaurentSeries k))) + exact ((isCompact_poleLattice N).image (continuous_of_preservesPoles a ha)).inter_right + (isClosed_poleLattice J) + +theorem closed_image [Finite k] + (a : LaurentSeries k →ₗ[k] LaurentSeries k) (ha : PreservesPoles a) + (hc : ∀ J, (crossing a J).Finite) : + IsClosed (Set.range a) := by + rw [← isOpen_compl_iff, isOpen_iff_forall_mem_open] + intro f hf + obtain ⟨J,hJ⟩ := exists_poleLattice f + refine ⟨(poleLattice (k := k) J : Set (LaurentSeries k)) ∩ + ((Set.range a) ∩ (poleLattice (k := k) J : Set (LaurentSeries k)))ᶜ, ?_, ?_, ?_⟩ + · intro g hg hga + exact hg.2 ⟨hga,hg.1⟩ + · exact (isOpen_poleLattice J).inter + (isCompact_range_inter_poleLattice a ha J (hc J)).isClosed.isOpen_compl + · exact ⟨hJ,fun h => hf h.1⟩ + +end HahnWilson.PivotTopology + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/BasedMaps.lean b/lean/OAI/Topology/Homotopy/BasedMaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..4cfb83f7fe422d250956cfd6a0f89983db9c42f0 --- /dev/null +++ b/lean/OAI/Topology/Homotopy/BasedMaps.lean @@ -0,0 +1,71 @@ +import Mathlib + +namespace OAI + +/-! Maps of based generalized loops and homotopy groups. -/ + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.BasedHomotopy +open scoped Topology Topology.Homotopy +variable {N X Y Z : Type*} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] +variable {x : X} {y : Y} {z : Z} + +def loopMap (e : C(X,Y)) (he : e x = y) (f : GenLoop N X x) : GenLoop N Y y := + ⟨e.comp f.1,fun t ht => (congrArg e (GenLoop.boundary f t ht)).trans he⟩ + +lemma loopMap_homotopic (e : C(X,Y)) (he : e x = y) {f g : GenLoop N X x} + (h : GenLoop.Homotopic f g) : GenLoop.Homotopic (loopMap e he f) (loopMap e he g) := by + obtain ⟨H⟩ := h + exact ⟨H.compContinuousMap e⟩ + +@[simp] theorem loopMap_const (e : C(X,Y)) (he : e x = y) : + loopMap (N:=N) e he GenLoop.const = GenLoop.const := by ext t; exact he + +@[simp] theorem loopMap_id (f : GenLoop N X x) : loopMap (ContinuousMap.id X) rfl f = f := by + ext t; rfl + +@[simp] theorem loopMap_comp (e : C(X,Y)) (he : e x = y) (d : C(Y,Z)) (hd : d y = z) + (f : GenLoop N X x) : loopMap d hd (loopMap e he f) = + loopMap (d.comp e) ((congrArg d he).trans hd) f := by + ext t; rfl + +lemma loopMap_transAt [DecidableEq N] (e : C(X,Y)) (he : e x = y) + (i : N) (f g : GenLoop N X x) : loopMap e he (GenLoop.transAt i f g) = + GenLoop.transAt i (loopMap e he f) (loopMap e he g) := by + ext t + simp only [loopMap,GenLoop.mk_apply,ContinuousMap.comp_apply,GenLoop.transAt,GenLoop.coe_copy,GenLoop.coe_coe] + split_ifs <;> rfl + +def groupMap [DecidableEq N] [Nonempty N] (e : C(X,Y)) (he : e x = y) : + HomotopyGroup N X x →* HomotopyGroup N Y y where + toFun := Quotient.map (loopMap e he) (fun _ _ h => loopMap_homotopic e he h) + map_one' := by + rw [HomotopyGroup.one_def,HomotopyGroup.one_def] + change Quotient.mk'' (loopMap e he GenLoop.const) = Quotient.mk'' GenLoop.const + rw [loopMap_const] + map_mul' a b := Quotient.inductionOn₂ a b fun f g => by + simp only [HomotopyGroup.mul_spec (i:=Classical.arbitrary N)] + change (⟦loopMap e he (GenLoop.transAt (Classical.arbitrary N) g f)⟧ : HomotopyGroup N Y y) = + ((· * ·) : HomotopyGroup N Y y → HomotopyGroup N Y y → HomotopyGroup N Y y) + ⟦loopMap e he f⟧ ⟦loopMap e he g⟧ + rw [HomotopyGroup.mul_spec (i:=Classical.arbitrary N),loopMap_transAt] + +@[simp] theorem groupMap_id [DecidableEq N] [Nonempty N] (a : HomotopyGroup N X x) : + groupMap (ContinuousMap.id X) rfl a = a := by + induction a using Quotient.inductionOn with + | h f => change Quotient.mk'' (loopMap _ _ f) = _; rw [loopMap_id]; rfl + +@[simp] theorem groupMap_comp [DecidableEq N] [Nonempty N] + (e : C(X,Y)) (he : e x = y) (d : C(Y,Z)) (hd : d y = z) (a : HomotopyGroup N X x) : + groupMap d hd (groupMap e he a) = groupMap (d.comp e) ((congrArg d he).trans hd) a := by + induction a using Quotient.inductionOn with + | h f => change Quotient.mk'' (loopMap _ _ (loopMap _ _ f)) = _; rw [loopMap_comp]; rfl + +end NearbyLagrangian.BasedHomotopy + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/ConeHomotopy.lean b/lean/OAI/Topology/Homotopy/ConeHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..24b17cb36d61f20cbdd9bf085c8d373c349bee1c --- /dev/null +++ b/lean/OAI/Topology/Homotopy/ConeHomotopy.lean @@ -0,0 +1,234 @@ +import Mathlib +import OAI.Topology.Homotopy.FiberCone + +namespace OAI + +/-! Right suspension homotopies and suspension of maps and homotopies. -/ + +noncomputable section +universe u v w +open Set ContinuousMap +open scoped Topology unitInterval + +namespace NearbyLagrangian.FiberCone +variable {B A X : Type*} [TopologicalSpace B] [TopologicalSpace A] [TopologicalSpace X] +variable (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) (hf : ∀ a, p (f a) = q a) + +def sweepBase : C(unitInterval × X,Susp p) := meridian p + +def sweepRay : C(unitInterval × (unitInterval × A),Susp p) where + toFun z := meridian p (max z.2.1 z.1,f z.2.2) + continuous_toFun := (meridian p).continuous.comp + (((continuous_fst.comp continuous_snd).max continuous_fst).prodMk + (f.continuous.comp (continuous_snd.comp continuous_snd))) + +def sweepApex : C(unitInterval × B,Susp p) := (north p).comp ⟨Prod.snd,continuous_snd⟩ + +lemma sweepRay_bottom (s : unitInterval) (a : A) : + sweepRay f p (s,(0,a)) = sweepBase p (s,f a) := by + change meridian p (max 0 s,f a) = meridian p (s,f a) + rw [max_eq_right (show (0:unitInterval) ≤ s from bot_le)] + +include hf in +lemma sweepRay_top (s : unitInterval) (a : A) : + sweepRay f p (s,(1,a)) = sweepApex p (s,q a) := by + change meridian p (max 1 s,f a) = north p (q a) + rw [max_eq_left (show s ≤ (1:unitInterval) from le_top),ray_one,hf] + +def sweep : C(unitInterval × Space f q,Susp p) := + cylinderLift f q (sweepBase p) (sweepRay f p) (sweepApex p) + (sweepRay_bottom f p) (sweepRay_top f p q hf) + +@[simp] lemma sweep_base (s : unitInterval) (x : X) : + sweep f p q hf (s,base f q x) = meridian p (s,x) := rfl +@[simp] lemma sweep_ray (s : unitInterval) (ta : unitInterval × A) : + sweep f p q hf (s,ray f q ta) = meridian p (max ta.1 s,f ta.2) := rfl +@[simp] lemma sweep_apex (s : unitInterval) (b : B) : + sweep f p q hf (s,apex f q b) = north p b := rfl + +lemma sweep_zero (z : Space f q) : + sweep f p q hf (0,z) = suspMap f p q hf (collapse f p q hf z) := by + induction z using induction with + | hbase x => rw [sweep_base,ray_zero,collapse_base,suspMap_south] + | hray ta => + rw [sweep_ray,max_eq_left (show (0:unitInterval) ≤ ta.1 from bot_le), + collapse_ray,suspMap_meridian] + | hapex b => rw [sweep_apex,collapse_apex,suspMap_north] + +lemma sweep_one (z : Space f q) : + sweep f p q hf (1,z) = north p (projection f p q hf z) := by + induction z using induction with + | hbase x => rw [sweep_base,ray_one,projection_base] + | hray ta => + rw [sweep_ray,max_eq_right (show ta.1 ≤ (1:unitInterval) from le_top), + ray_one,hf,projection_ray] + | hapex b => rfl + +lemma sweep_over (s : unitInterval) (z : Space f q) : + suspProjection p (sweep f p q hf (s,z)) = projection f p q hf z := by + induction z using induction with + | hbase x => rfl + | hray ta => exact hf ta.2 + | hapex b => rfl + +namespace Contraction +variable {f p q hf} (H : Contraction f p q hf) + +def rightRay : C(unitInterval × (unitInterval × X),Susp p) where + toFun z := sweep f p q hf (horizontal (z.1,z.2.1), + H.hom (vertical (z.1,z.2.1),base f q z.2.2)) + continuous_toFun := (sweep f p q hf).continuous.comp + ((horizontal.continuous.comp (continuous_fst.prodMk (continuous_fst.comp continuous_snd))).prodMk + (H.hom.continuous.comp + ((vertical.continuous.comp (continuous_fst.prodMk (continuous_fst.comp continuous_snd))).prodMk + ((base f q).continuous.comp (continuous_snd.comp continuous_snd))))) + +lemma rightRay_bottom (s : unitInterval) (x : X) : H.rightRay (s,(0,x)) = south p (p x) := by + change sweep f p q hf (horizontal (s,0),H.hom (vertical (s,0),base f q x)) = _ + rw [horizontal_bottom,vertical_bottom,H.at_zero,sweep_base,ray_zero] + +lemma rightRay_top (s : unitInterval) (x : X) : H.rightRay (s,(1,x)) = north p (p x) := by + change sweep f p q hf (horizontal (s,1),H.hom (vertical (s,1),base f q x)) = _ + rcases square_top s with hx | hy + · rw [hx,sweep_one,H.staysOver,projection_base] + · rw [hy,H.at_one,projection_base,sweep_apex] + +def rightDeformation : C(unitInterval × Susp p,Susp p) := + cylinderLift p p ((south p).comp ⟨Prod.snd,continuous_snd⟩) H.rightRay + ((north p).comp ⟨Prod.snd,continuous_snd⟩) H.rightRay_bottom H.rightRay_top + +@[simp] lemma rightDeformation_south (s : unitInterval) (b : B) : + H.rightDeformation (s,south p b) = south p b := rfl +@[simp] lemma rightDeformation_meridian (s : unitInterval) (tx : unitInterval × X) : + H.rightDeformation (s,meridian p tx) = H.rightRay (s,tx) := rfl +@[simp] lemma rightDeformation_north (s : unitInterval) (b : B) : + H.rightDeformation (s,north p b) = north p b := rfl + +lemma rightDeformation_zero (z : Susp p) : H.rightDeformation (0,z) = z := by + induction z using induction with + | hbase b => rfl + | hray tx => + rw [rightDeformation_meridian] + change sweep f p q hf (horizontal (0,tx.1), + H.hom (vertical (0,tx.1),base f q tx.2)) = _ + rw [horizontal_left,vertical_left,H.at_zero,sweep_base] + | hapex b => rfl + +lemma rightDeformation_one (z : Susp p) : + H.rightDeformation (1,z) = suspMap f p q hf (H.inverse z) := by + induction z using induction with + | hbase b => rw [rightDeformation_south,inverse_south,suspMap_south] + | hray tx => + rw [rightDeformation_meridian,inverse_meridian] + change sweep f p q hf (horizontal (1,tx.1), + H.hom (vertical (1,tx.1),base f q tx.2)) = _ + rw [horizontal_right,vertical_right,sweep_zero] + | hapex b => rw [rightDeformation_north,inverse_north,suspMap_north] + +lemma rightDeformation_over (s : unitInterval) (z : Susp p) : + suspProjection p (H.rightDeformation (s,z)) = suspProjection p z := by + induction z using induction with + | hbase b => rfl + | hray tx => + rw [rightDeformation_meridian] + change suspProjection p (sweep f p q hf (horizontal (s,tx.1), + H.hom (vertical (s,tx.1),base f q tx.2))) = _ + rw [sweep_over,H.staysOver,projection_base] + rfl + | hapex b => rfl + +def rightHomotopy : ((suspMap f p q hf).comp H.inverse).Homotopy (ContinuousMap.id (Susp p)) := + ContinuousMap.Homotopy.symm + { toContinuousMap := H.rightDeformation + map_zero_left := H.rightDeformation_zero + map_one_left := H.rightDeformation_one } + +lemma rightHomotopy_over (s : unitInterval) (z : Susp p) : + suspProjection p (H.rightHomotopy (s,z)) = suspProjection p z := + H.rightDeformation_over (unitInterval.symm s) z + +end Contraction +end NearbyLagrangian.FiberCone + +end + +noncomputable section +universe u v w +open Set ContinuousMap +open scoped Topology unitInterval + +namespace NearbyLagrangian.FiberCone +variable {B A X Y : Type*} [TopologicalSpace B] [TopologicalSpace A] + [TopologicalSpace X] [TopologicalSpace Y] + +@[simp] lemma suspMap_id (q : C(A,B)) : + suspMap (ContinuousMap.id A) q q (fun _ => rfl) = ContinuousMap.id (Susp q) := by + ext z + induction z using induction with + | hbase _ => rfl + | hray _ => rfl + | hapex _ => rfl + +lemma suspMap_comp (f : C(A,X)) (g : C(X,Y)) (p : C(X,B)) (q : C(A,B)) (r : C(Y,B)) + (hf : ∀ a, p (f a) = q a) (hg : ∀ x, r (g x) = p x) : + (suspMap g r p hg).comp (suspMap f p q hf) = + suspMap (g.comp f) r q (fun a => (hg (f a)).trans (hf a)) := by + ext z + induction z using induction with + | hbase _ => rfl + | hray _ => rfl + | hapex _ => rfl + +variable {p : C(X,B)} {q : C(A,B)} {f g : C(A,X)} + (hf : ∀ a, p (f a) = q a) (hg : ∀ a, p (g a) = q a) + (H : f.Homotopy g) (hH : ∀ s a, p (H (s,a)) = q a) + +def suspHomotopyRay : C(unitInterval × (unitInterval × A),Susp p) := + (meridian p).comp ⟨fun z => (z.2.1,H (z.1,z.2.2)), + (continuous_fst.comp continuous_snd).prodMk + (H.continuous.comp (continuous_fst.prodMk (continuous_snd.comp continuous_snd)))⟩ + +include hH in +lemma suspHomotopyRay_bottom (s : unitInterval) (a : A) : + suspHomotopyRay H (s,(0,a)) = south p (q a) := by + change meridian p (0,H (s,a)) = _ + rw [ray_zero,hH] + +include hH in +lemma suspHomotopyRay_top (s : unitInterval) (a : A) : + suspHomotopyRay H (s,(1,a)) = north p (q a) := by + change meridian p (1,H (s,a)) = _ + rw [ray_one,hH] + +def suspHomotopy : (suspMap f p q hf).Homotopy (suspMap g p q hg) where + toContinuousMap := cylinderLift q q + ((south p).comp ⟨Prod.snd,continuous_snd⟩) (suspHomotopyRay H) + ((north p).comp ⟨Prod.snd,continuous_snd⟩) + (suspHomotopyRay_bottom H hH) (suspHomotopyRay_top H hH) + map_zero_left z := by + induction z using induction with + | hbase _ => rfl + | hray ta => + change meridian p (ta.1,H (0,ta.2)) = meridian p (ta.1,f ta.2) + rw [HomotopyLike.map_zero_left H] + | hapex _ => rfl + map_one_left z := by + induction z using induction with + | hbase _ => rfl + | hray ta => + change meridian p (ta.1,H (1,ta.2)) = meridian p (ta.1,g ta.2) + rw [HomotopyLike.map_one_left H] + | hapex _ => rfl + +lemma suspHomotopy_over (s : unitInterval) (z : Susp q) : + suspProjection p (suspHomotopy hf hg H hH (s,z)) = suspProjection q z := by + induction z using induction with + | hbase _ => rfl + | hray ta => exact hH s ta.2 + | hapex _ => rfl + +end NearbyLagrangian.FiberCone + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/CubicalNullity.lean b/lean/OAI/Topology/Homotopy/CubicalNullity.lean new file mode 100644 index 0000000000000000000000000000000000000000..6349552a8e28411e666c949e7d6edceecfacf19e --- /dev/null +++ b/lean/OAI/Topology/Homotopy/CubicalNullity.lean @@ -0,0 +1,263 @@ +import Mathlib + +namespace OAI + +/-! Cubical free nullity and change of basepoint. -/ + +noncomputable section +universe u v w +open Set ContinuousMap +open scoped Topology Topology.Homotopy + +namespace NearbyLagrangian.CubicalFreeNullity +variable {N : Type*} [Fintype N] [Nonempty N] + +def radius (t : N → unitInterval) : ℝ := ‖fun i => 2*(t i:ℝ)-1‖ +omit [Nonempty N] in +lemma radius_nonneg (t : N → unitInterval) : 0 ≤ radius t := norm_nonneg _ +omit [Nonempty N] in +lemma radius_le_one (t : N → unitInterval) : radius t ≤ 1 := by + apply (pi_norm_le_iff_of_nonneg (by norm_num : (0:ℝ) ≤ 1)).mpr + intro i + rw [Real.norm_eq_abs,abs_le] + have hi₀ := (t i).property.1 + have hi₁ := (t i).property.2 + constructor <;> linarith +omit [Nonempty N] in +lemma continuous_radius : Continuous (radius (N:=N)) := + (continuous_pi fun i => (continuous_const.mul + (continuous_subtype_val.comp (continuous_apply i))).sub continuous_const).norm +omit [Nonempty N] in +lemma radius_boundary {t : N → unitInterval} (ht : t ∈ Cube.boundary N) : radius t = 1 := by + apply le_antisymm (radius_le_one t) + obtain ⟨i,hi⟩ := ht + have hh := norm_le_pi_norm (fun i => 2*(t i:ℝ)-1) i + rcases hi with hi | hi + · simpa [radius,hi] using hh + · norm_num [hi] at hh + exact hh + +def collarTime (s : unitInterval) (t : N → unitInterval) : unitInterval := + ⟨min (s:ℝ) (2*(1-radius t)), + le_min s.property.1 (by have := radius_le_one t; linarith), + (min_le_left _ _).trans s.property.2⟩ +omit [Nonempty N] in +lemma continuous_collarTime : Continuous (fun a : unitInterval × (N → unitInterval) => collarTime a.1 a.2) := + ((continuous_subtype_val.comp continuous_fst).min + (continuous_const.mul (continuous_const.sub (continuous_radius.comp continuous_snd)))).subtype_mk _ +omit [Nonempty N] in +@[simp] lemma collarTime_zero (t : N → unitInterval) : collarTime 0 t = 0 := by + apply Subtype.ext + change min 0 (2*(1-radius t)) = 0 + apply min_eq_left + have := radius_le_one t + linarith +omit [Nonempty N] in +lemma collarTime_boundary (s : unitInterval) {t : N → unitInterval} (ht : t ∈ Cube.boundary N) : + collarTime s t = 0 := by + apply Subtype.ext + change min (s:ℝ) (2*(1-radius t)) = 0 + rw [radius_boundary ht] + simp only [sub_self,mul_zero,min_eq_right s.property.1] + +lemma denominator_pos (s : unitInterval) : 0 < 1-(s:ℝ)/2 := by + have := s.property.2 + linarith + +def expand (s : unitInterval) (t : N → unitInterval) : N → unitInterval := + fun i => projIcc 0 1 (zero_le_one' ℝ) (((t i:ℝ)-(s:ℝ)/4)/(1-(s:ℝ)/2)) +omit [Fintype N] [Nonempty N] in +lemma continuous_expand : Continuous (fun a : unitInterval × (N → unitInterval) => expand a.1 a.2) := by + apply continuous_pi + intro i + apply continuous_projIcc.comp + exact ((continuous_subtype_val.comp ((continuous_apply i).comp continuous_snd)).sub + ((continuous_subtype_val.comp continuous_fst).div_const 4)).div + (continuous_const.sub ((continuous_subtype_val.comp continuous_fst).div_const 2)) + (fun a => ne_of_gt (denominator_pos a.1)) +omit [Fintype N] [Nonempty N] in +@[simp] lemma expand_zero (t : N → unitInterval) : expand 0 t = t := by + funext i + change projIcc 0 1 _ (((t i:ℝ)-(0:ℝ)/4)/(1-(0:ℝ)/2)) = t i + simp only [zero_div,sub_zero,div_one,projIcc_val] + +lemma expand_mem_boundary {s : unitInterval} {t : N → unitInterval} + (ht : 1-(s:ℝ)/2 ≤ radius t) : expand s t ∈ Cube.boundary N := by + obtain ⟨⟨i,hi⟩,_⟩ := IsGreatest.pi_norm (fun i => 2*(t i:ℝ)-1) + have habs : 1-(s:ℝ)/2 ≤ |2*(t i:ℝ)-1| := by + change ‖2*(t i:ℝ)-1‖ = radius t at hi + rw [Real.norm_eq_abs] at hi + exact ht.trans_eq hi.symm + rcases (le_abs.mp habs) with h | h + · refine ⟨i,Or.inr ?_⟩ + apply projIcc_of_right_le + apply (le_div_iff₀ (denominator_pos s)).mpr + linarith + · refine ⟨i,Or.inl ?_⟩ + apply projIcc_of_le_left + apply div_nonpos_of_nonpos_of_nonneg _ (denominator_pos s).le + linarith + +lemma expand_boundary (s : unitInterval) {t : N → unitInterval} (ht : t ∈ Cube.boundary N) : + expand s t ∈ Cube.boundary N := by + apply expand_mem_boundary + rw [radius_boundary ht] + have := s.property.1 + linarith + +variable {X : Type*} [TopologicalSpace X] + +theorem null_of_moving_base {x y : X} (f : GenLoop N X x) + (H : f.1.Homotopy (ContinuousMap.const _ y)) + (p : C(unitInterval,X)) + (hp : ∀ s t, t ∈ Cube.boundary N → H (s,t) = p s) : + GenLoop.Homotopic f GenLoop.const := by + let z : N → unitInterval := fun _ => 0 + have hz : z ∈ Cube.boundary N := ⟨Classical.choice inferInstance,Or.inl rfl⟩ + have hp0 : p 0 = x := by + rw [← hp 0 z hz,H.apply_zero] + exact GenLoop.boundary f z hz + have hp1 : p 1 = y := by rw [← hp 1 z hz,H.apply_one]; rfl + let a : C(N → unitInterval,X) := p.comp ⟨fun t => collarTime 1 t, + continuous_collarTime.comp (continuous_const.prodMk continuous_id)⟩ + have ha (t : N → unitInterval) : H (collarTime 1 t,expand 1 t) = a t := by + change H (collarTime 1 t,expand 1 t) = p (collarTime 1 t) + by_cases ht : collarTime 1 t = 1 + · rw [ht,H.apply_one,hp1]; rfl + · apply hp + apply expand_mem_boundary + have hk : (collarTime 1 t:ℝ) < 1 := lt_of_le_of_ne (collarTime 1 t).property.2 + (fun h => ht (Subtype.ext h)) + change min 1 (2*(1-radius t)) < 1 at hk + have hr : 2*(1-radius t) < 1 := by simpa only [min_lt_iff,lt_self_iff_false,false_or] using hk + change 1-(1:ℝ)/2 ≤ radius t + linarith + let H₁ : f.1.HomotopyRel a (Cube.boundary N) := { + toFun := fun q => H (collarTime q.1 q.2,expand q.1 q.2) + continuous_toFun := H.continuous.comp (continuous_collarTime.prodMk continuous_expand) + map_zero_left := by intro t; simp only [collarTime_zero,expand_zero,H.apply_zero] + map_one_left := ha + prop' := by + intro s t ht + change H (collarTime s t,expand s t) = f t + rw [collarTime_boundary s ht,hp 0 _ (expand_boundary s ht),hp0,GenLoop.boundary f t ht] } + let H₂ : a.HomotopyRel (ContinuousMap.const _ x) (Cube.boundary N) := { + toFun := fun q => p ⟨(1-(q.1:ℝ))*(collarTime 1 q.2:ℝ), + mul_nonneg (by linarith [q.1.property.2]) (collarTime _ _).property.1, + (mul_le_of_le_one_left (collarTime _ _).property.1 + (by linarith [q.1.property.1])).trans (collarTime _ _).property.2⟩ + continuous_toFun := p.continuous.comp (Continuous.subtype_mk + ((continuous_const.sub (continuous_subtype_val.comp continuous_fst)).mul + (continuous_subtype_val.comp (continuous_collarTime.comp (continuous_const.prodMk continuous_snd)))) _) + map_zero_left := by + intro t + change p _ = p (collarTime 1 t) + congr 1 + apply Subtype.ext + change (1-(0:ℝ))*(collarTime 1 t:ℝ) = (collarTime 1 t:ℝ) + ring + map_one_left := by + intro t + change p _ = x + convert hp0 using 1 + congr 1 + apply Subtype.ext + change (1-(1:ℝ))*(collarTime 1 t:ℝ) = 0 + ring + prop' := by + intro s t ht + change p _ = p (collarTime 1 t) + rw [collarTime_boundary 1 ht] + congr 1 + apply Subtype.ext + change (1-(s:ℝ))*(0:ℝ) = 0 + ring } + exact ⟨H₁.trans H₂⟩ + +end NearbyLagrangian.CubicalFreeNullity + +end + +noncomputable section +universe u v w +open scoped Classical Topology Topology.Homotopy + +namespace NearbyLagrangian.CubicalFreeNullity +variable {N : Type*} [Fintype N] [Nonempty N] +variable {X : Type*} [TopologicalSpace X] {x y : X} + +def outerTime (s : unitInterval) (t : N → unitInterval) : unitInterval := + ⟨max 0 ((s:ℝ)-2*(1-radius t)),le_max_left _ _,by + apply max_le zero_le_one + have := radius_le_one t + linarith [s.property.2]⟩ +omit [Nonempty N] in +lemma continuous_outerTime : Continuous (fun a : unitInterval × (N → unitInterval) => outerTime a.1 a.2) := + ((continuous_const.max ((continuous_subtype_val.comp continuous_fst).sub + (continuous_const.mul (continuous_const.sub (continuous_radius.comp continuous_snd)))))).subtype_mk _ + +omit [Nonempty N] in +lemma outerTime_eq_zero {s : unitInterval} {t : N → unitInterval} + (h : radius t ≤ 1-(s:ℝ)/2) : outerTime s t = 0 := by + apply Subtype.ext + change max 0 ((s:ℝ)-2*(1-radius t)) = 0 + apply max_eq_left + linarith + +omit [Nonempty N] in +lemma outerTime_boundary (s : unitInterval) {t : N → unitInterval} + (h : t ∈ Cube.boundary N) : outerTime s t = s := by + apply Subtype.ext + change max 0 ((s:ℝ)-2*(1-radius t)) = s + rw [radius_boundary h] + simp only [sub_self,mul_zero,sub_zero,max_eq_right s.property.1] + +def rebaseValue (f : GenLoop N X x) (p : Path x y) (s : unitInterval) + (t : N → unitInterval) : X := + if radius t ≤ 1-(s:ℝ)/2 then f (expand s t) else p (outerTime s t) + +lemma continuous_rebaseValue (f : GenLoop N X x) (p : Path x y) : + Continuous (fun q : unitInterval × (N → unitInterval) => rebaseValue f p q.1 q.2) := by + apply (f.1.continuous.comp continuous_expand).if_le + (p.continuous.comp continuous_outerTime) (continuous_radius.comp continuous_snd) + (continuous_const.sub ((continuous_subtype_val.comp continuous_fst).div_const 2)) + intro q h + change f (expand q.1 q.2) = p (outerTime q.1 q.2) + change radius q.2 = 1-(q.1:ℝ)/2 at h + rw [GenLoop.boundary f _ (expand_mem_boundary h.ge),outerTime_eq_zero h.le,p.source] + +omit [Nonempty N] in +@[simp] lemma rebaseValue_zero (f : GenLoop N X x) (p : Path x y) + (t : N → unitInterval) : rebaseValue f p 0 t = f t := by + rw [rebaseValue,ite_eq_left (by simpa using radius_le_one t),expand_zero] + +omit [Nonempty N] in +lemma rebaseValue_boundary (f : GenLoop N X x) (p : Path x y) + (s : unitInterval) {t : N → unitInterval} (ht : t ∈ Cube.boundary N) : + rebaseValue f p s t = p s := by + rw [rebaseValue] + split_ifs with h + · have hs : s = 0 := by + apply Subtype.ext + change (s:ℝ) = 0 + rw [radius_boundary ht] at h + linarith [s.property.1] + rw [hs,expand_zero,GenLoop.boundary f t ht,p.source] + · rw [outerTime_boundary s ht] + +def rebase (f : GenLoop N X x) (p : Path x y) : GenLoop N X y := + ⟨⟨fun t => rebaseValue f p 1 t, + (continuous_rebaseValue f p).comp (continuous_const.prodMk continuous_id)⟩, + fun _t ht => (rebaseValue_boundary f p 1 ht).trans p.target⟩ + +def rebaseHomotopy (f : GenLoop N X x) (p : Path x y) : f.1.Homotopy (rebase f p).1 where + toFun q := rebaseValue f p q.1 q.2 + continuous_toFun := continuous_rebaseValue f p + map_zero_left := rebaseValue_zero f p + map_one_left _ := rfl + +end NearbyLagrangian.CubicalFreeNullity + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/CubicalSpheres.lean b/lean/OAI/Topology/Homotopy/CubicalSpheres.lean new file mode 100644 index 0000000000000000000000000000000000000000..e858b1d49ef8ed1dcd3399d853f57304d654116a --- /dev/null +++ b/lean/OAI/Topology/Homotopy/CubicalSpheres.lean @@ -0,0 +1,341 @@ +import Mathlib +import OAI.Topology.Homotopy.CubicalNullity +import OAI.Topology.Homotopy.OpenCollapse + +namespace OAI + +/-! Cubical and spherical representatives of homotopy classes. -/ + +noncomputable section +universe u v w +open Set ContinuousMap Topology +open scoped OnePoint Topology Topology.Homotopy + +namespace NearbyLagrangian.CubicalSphere +variable (N : Type*) [Fintype N] [Nonempty N] + +def interiorCube : Set (N → unitInterval) := {t | ∀ i, 0 < (t i:ℝ) ∧ (t i:ℝ) < 1} +omit [Fintype N] [Nonempty N] in +lemma interiorCube_eq : interiorCube N = (Cube.boundary N)ᶜ := by + ext t + simp only [interiorCube,mem_ofPred_eq,Set.mem_compl_iff,Cube.boundary,not_exists,not_or] + constructor + · intro ht i + constructor + · intro h; have := (ht i).1; simp [h] at this + · intro h; have := (ht i).2; simp [h] at this + · intro ht i + constructor + · exact lt_of_le_of_ne (t i).property.1 (fun h => (ht i).1 (Subtype.ext h.symm)) + · exact lt_of_le_of_ne (t i).property.2 (fun h => (ht i).2 (Subtype.ext h)) + +omit [Nonempty N] in +lemma isOpen_interiorCube : IsOpen (interiorCube N) := by + have he : interiorCube N = ⋂ i, {t : N → unitInterval | 0 < (t i:ℝ) ∧ (t i:ℝ) < 1} := by + ext t; simp [interiorCube] + rw [he] + apply isOpen_iInter_of_finite + intro i + exact isOpen_Ioo.preimage (continuous_subtype_val.comp (continuous_apply i)) + +omit [Fintype N] in +lemma complement_nonempty : (interiorCube N)ᶜ.Nonempty := by + refine ⟨fun _ => 0,?_⟩ + rw [interiorCube_eq,compl_compl] + exact ⟨Classical.choice inferInstance,Or.inl rfl⟩ + +def interiorHomeomorph : interiorCube N ≃ₜ (N → Ioo (0:ℝ) 1) where + toFun t i := ⟨t.1 i,(t.property i)⟩ + invFun t := ⟨fun i => ⟨(t i:ℝ),(t i).property.1.le,(t i).property.2.le⟩, + fun i => (t i).property⟩ + left_inv _ := rfl + right_inv _ := rfl + continuous_toFun := by + apply continuous_pi + intro i + exact (continuous_subtype_val.comp ((continuous_apply i).comp continuous_subtype_val)).subtype_mk _ + continuous_invFun := by + apply Continuous.subtype_mk + apply continuous_pi + intro i + exact (continuous_subtype_val.comp (continuous_apply i)).subtype_mk _ + +def intervalHomeomorph : Ioo (0:ℝ) 1 ≃ₜ Ioo (-1:ℝ) 1 where + toFun x := ⟨2*(x:ℝ)-1,by have h := x.property; constructor <;> linarith [h.1,h.2]⟩ + invFun y := ⟨((y:ℝ)+1)/2,by have h := y.property; constructor <;> linarith [h.1,h.2]⟩ + left_inv x := Subtype.ext (by dsimp; ring) + right_inv y := Subtype.ext (by dsimp; ring) + continuous_toFun := by + apply Continuous.subtype_mk + exact (continuous_const.mul continuous_subtype_val).sub continuous_const + continuous_invFun := by + apply Continuous.subtype_mk + exact (continuous_subtype_val.add continuous_const).div_const 2 + +def interiorEuclidean : interiorCube N ≃ₜ (N → ℝ) := + (interiorHomeomorph N).trans (Homeomorph.piCongrRight fun _ => + intervalHomeomorph.trans (orderIsoIooNegOneOne ℝ).toHomeomorph.symm) + +def compactificationSphere (n : ℕ) : OnePoint (interiorCube (Fin (n+1))) ≃ₜ + Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1 := + (interiorEuclidean (Fin (n+1))).onePointCongr.trans + (onePointEquivSphereOfFinrankEq (by simp)) + +def spherePoint (n : ℕ) : Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1 := + compactificationSphere n ∞ + +def sphereQuotient (n : ℕ) : C((Fin (n+1) → unitInterval), + Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1) := + ⟨fun t => compactificationSphere n (OpenCollapse.collapse (interiorCube _) t), + (compactificationSphere n).continuous.comp + (OpenCollapse.continuous_collapse (isOpen_interiorCube _))⟩ + +lemma sphereQuotient_boundary (n : ℕ) {t : Fin (n+1) → unitInterval} + (ht : t ∈ Cube.boundary _) : sphereQuotient n t = spherePoint n := by + change compactificationSphere n _ = compactificationSphere n ∞ + rw [OpenCollapse.collapse_of_notMem] + simpa only [interiorCube_eq,mem_compl_iff,not_not] using ht + +lemma sphereQuotient_surjective (n : ℕ) : Function.Surjective (sphereQuotient n) := + (compactificationSphere n).surjective.comp + (OpenCollapse.collapse_surjective (complement_nonempty _)) + +variable {X : Type*} [TopologicalSpace X] {x : X} + +def sphereMap {n : ℕ} (f : GenLoop (Fin (n+1)) X x) : + C(Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1,X) := + (OpenCollapse.descend (isOpen_interiorCube _) (complement_nonempty _) f.1 x + (fun t ht => GenLoop.boundary f t (by simpa only [interiorCube_eq,mem_compl_iff,not_not] using ht))).comp + ⟨(compactificationSphere n).symm,(compactificationSphere n).symm.continuous⟩ + +@[simp] lemma sphereMap_quotient {n : ℕ} (f : GenLoop (Fin (n+1)) X x) + (t : Fin (n+1) → unitInterval) : sphereMap f (sphereQuotient n t) = f t := by + simp only [sphereMap,ContinuousMap.comp_apply,ContinuousMap.coe_mk,sphereQuotient, + Homeomorph.symm_apply_apply,OpenCollapse.descend_collapse] + rfl + +@[simp] lemma sphereMap_point {n : ℕ} (f : GenLoop (Fin (n+1)) X x) : + sphereMap f (spherePoint n) = x := by + simp only [sphereMap,ContinuousMap.comp_apply,ContinuousMap.coe_mk,spherePoint, + Homeomorph.symm_apply_apply] + rfl + +theorem sphereMap_null_implies_cube_null {n : ℕ} (f : GenLoop (Fin (n+1)) X x) + (hf : (sphereMap f).Nullhomotopic) : GenLoop.Homotopic f GenLoop.const := by + obtain ⟨y,⟨H⟩⟩ := hf + let H' : f.1.Homotopy (ContinuousMap.const _ y) := { + toFun := fun q => H (q.1,sphereQuotient n q.2) + continuous_toFun := H.continuous.comp (continuous_fst.prodMk ((sphereQuotient n).continuous.comp continuous_snd)) + map_zero_left := fun t => (H.apply_zero _).trans (sphereMap_quotient f t) + map_one_left := fun t => H.apply_one _ } + let p : C(unitInterval,X) := + ⟨fun s => H (s,spherePoint n),H.continuous.comp (continuous_id.prodMk continuous_const)⟩ + apply CubicalFreeNullity.null_of_moving_base f H' p + intro s t ht + change H (s,sphereQuotient n t) = H (s,spherePoint n) + rw [sphereQuotient_boundary n ht] + +theorem sphereMap_null_implies_class_one {n : ℕ} (f : GenLoop (Fin (n+1)) X x) + (hf : (sphereMap f).Nullhomotopic) : + (⟦f⟧ : HomotopyGroup.Pi (n+1) X x) = (1 : HomotopyGroup.Pi (n+1) X x) := by + rw [HomotopyGroup.one_def] + exact Quotient.sound (sphereMap_null_implies_cube_null f hf) + +end NearbyLagrangian.CubicalSphere + +end + +noncomputable section +universe u v w +open Set ContinuousMap Topology +open scoped OnePoint Topology Topology.Homotopy + +namespace NearbyLagrangian.CubicalSphere +variable {X : Type*} [TopologicalSpace X] {x : X} + +def sphereHomotopy {n : ℕ} {f g : GenLoop (Fin (n+1)) X x} + (H : f.1.HomotopyRel g.1 (Cube.boundary _)) : (sphereMap f).Homotopy (sphereMap g) where + toFun := fun q => ((compactificationSphere n).symm q.2).elim x + (fun t => H (q.1,t)) + continuous_toFun := by + let F : C(unitInterval × (Fin (n+1) → unitInterval),X) := ⟨H,H.continuous⟩ + have hF : ∀ s t, t ∉ interiorCube (Fin (n+1)) → F (s,t) = x := by + intro s t ht + have ht' : t ∈ Cube.boundary _ := by + simpa only [interiorCube_eq,mem_compl_iff,not_not] using ht + exact (H.eq_fst s ht').trans (GenLoop.boundary f t ht') + exact (OpenCollapse.continuous_descend_param (isOpen_interiorCube _) (complement_nonempty _) + F (const _ x) hF).comp (continuous_fst.prodMk + ((compactificationSphere n).symm.continuous.comp continuous_snd)) + map_zero_left := by + intro u + change ((compactificationSphere n).symm u).elim x (fun t => H (0,t)) = + ((compactificationSphere n).symm u).elim x (fun t => f t) + generalize (compactificationSphere n).symm u = z + induction z using OnePoint.rec with + | infty => rfl + | coe t => exact H.apply_zero t + map_one_left := by + intro u + change ((compactificationSphere n).symm u).elim x (fun t => H (1,t)) = + ((compactificationSphere n).symm u).elim x (fun t => g t) + generalize (compactificationSphere n).symm u = z + induction z using OnePoint.rec with + | infty => rfl + | coe t => exact H.apply_one t + +@[simp] theorem sphereMap_const (n : ℕ) : sphereMap (GenLoop.const : GenLoop (Fin (n+1)) X x) = + ContinuousMap.const _ x := by + ext u + obtain ⟨t,rfl⟩ := sphereQuotient_surjective n u + exact sphereMap_quotient GenLoop.const t + +theorem sphereMap_null_iff_cube_null {n : ℕ} (f : GenLoop (Fin (n+1)) X x) : + (sphereMap f).Nullhomotopic ↔ GenLoop.Homotopic f GenLoop.const := by + constructor + · exact sphereMap_null_implies_cube_null f + · rintro ⟨H⟩ + refine ⟨x,?_⟩ + rw [← sphereMap_const] + exact ⟨sphereHomotopy H⟩ + +theorem sphereMap_null_iff_class_one {n : ℕ} (f : GenLoop (Fin (n+1)) X x) : + (sphereMap f).Nullhomotopic ↔ + (⟦f⟧ : HomotopyGroup.Pi (n+1) X x) = (1 : HomotopyGroup.Pi (n+1) X x) := by + rw [sphereMap_null_iff_cube_null,HomotopyGroup.one_def,Quotient.eq] + rfl + +end NearbyLagrangian.CubicalSphere + +end + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.SphereConnectivity +open scoped Topology Topology.Homotopy + +def genLoopMap {N A B : Type*} [TopologicalSpace A] [TopologicalSpace B] + (e : C(A,B)) {x : A} (f : GenLoop N A x) : GenLoop N B (e x) := + ⟨e.comp f.1,fun t ht => congrArg e (GenLoop.boundary f t ht)⟩ +lemma genLoopMap_homotopic {N A B : Type*} [TopologicalSpace A] [TopologicalSpace B] + (e : C(A,B)) {x : A} {f g : GenLoop N A x} (h : GenLoop.Homotopic f g) : + GenLoop.Homotopic (genLoopMap e f) (genLoopMap e g) := by + obtain ⟨H⟩ := h + exact ⟨H.compContinuousMap e⟩ +def homotopyGroupMap {n : ℕ} {A B : Type*} [TopologicalSpace A] [TopologicalSpace B] + (e : C(A,B)) (x : A) : HomotopyGroup.Pi n A x → HomotopyGroup.Pi n B (e x) := + Quotient.map (genLoopMap e) (fun _ _ h => genLoopMap_homotopic e h) +end NearbyLagrangian.SphereConnectivity + +end + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.CubicalSphere +open Set ContinuousMap SphereConnectivity +open scoped Topology Topology.Homotopy +variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {x : X} + +def sphereLoop {n : ℕ} + (a : C(Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1,X)) : + GenLoop (Fin (n+1)) X (a (spherePoint n)) := + ⟨a.comp (sphereQuotient n),fun _t ht => congrArg a (sphereQuotient_boundary n ht)⟩ + +@[simp] theorem sphereMap_sphereLoop {n : ℕ} + (a : C(Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1,X)) : + sphereMap (sphereLoop a) = a := by + ext u + obtain ⟨t,rfl⟩ := sphereQuotient_surjective n u + rw [sphereMap_quotient] + rfl + +@[simp] theorem sphereMap_natural {n : ℕ} (e : C(X,Y)) + (f : GenLoop (Fin (n+1)) X x) : + sphereMap (genLoopMap e f) = e.comp (sphereMap f) := by + ext u + obtain ⟨t,rfl⟩ := sphereQuotient_surjective n u + rw [sphereMap_quotient,ContinuousMap.comp_apply,sphereMap_quotient] + rfl + +theorem null_iff_class_one {n : ℕ} + (a : C(Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1,X)) : + a.Nullhomotopic ↔ + (⟦sphereLoop a⟧ : HomotopyGroup.Pi (n+1) X (a (spherePoint n))) = + (1 : HomotopyGroup.Pi (n+1) X (a (spherePoint n))) := by + simpa only [sphereMap_sphereLoop] using sphereMap_null_iff_class_one (sphereLoop a) + +theorem comp_null_iff_mapped_class_one {n : ℕ} (e : C(X,Y)) + (a : C(Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1,X)) : + (e.comp a).Nullhomotopic ↔ + homotopyGroupMap (n:=n+1) e (a (spherePoint n)) ⟦sphereLoop a⟧ = + (1 : HomotopyGroup.Pi (n+1) Y (e (a (spherePoint n)))) := by + change (e.comp a).Nullhomotopic ↔ + (⟦genLoopMap e (sphereLoop a)⟧ : HomotopyGroup.Pi (n+1) Y (e (a (spherePoint n)))) = _ + simpa only [sphereMap_natural,sphereMap_sphereLoop] using + sphereMap_null_iff_class_one (genLoopMap e (sphereLoop a)) + +end NearbyLagrangian.CubicalSphere + +end + +noncomputable section +universe u v w +open scoped Classical Topology Topology.Homotopy + +namespace NearbyLagrangian.CubicalSphere +open Set ContinuousMap +open scoped OnePoint +variable {X : Type*} [TopologicalSpace X] {x y : X} + +def sphereMovingHomotopy {n : ℕ} {f : GenLoop (Fin (n+1)) X x} + {g : GenLoop (Fin (n+1)) X y} (H : f.1.Homotopy g.1) + (p : Path x y) (hp : ∀ s t, t ∈ Cube.boundary (Fin (n+1)) → H (s,t) = p s) : + (sphereMap f).Homotopy (sphereMap g) where + toFun q := ((compactificationSphere n).symm q.2).elim (p q.1) (fun t => H (q.1,t)) + continuous_toFun := by + let F : C(unitInterval × (Fin (n+1) → unitInterval),X) := ⟨H,H.continuous⟩ + have hF (s : unitInterval) (t : Fin (n+1) → unitInterval) + (ht : t ∉ interiorCube (Fin (n+1))) : F (s,t) = p s := by + apply hp + simpa only [interiorCube_eq,mem_compl_iff,not_not] using ht + exact (OpenCollapse.continuous_descend_param (isOpen_interiorCube _) (complement_nonempty _) + F p.toContinuousMap hF).comp (continuous_fst.prodMk + ((compactificationSphere n).symm.continuous.comp continuous_snd)) + map_zero_left := by + intro u + change ((compactificationSphere n).symm u).elim (p 0) (fun t => H (0,t)) = + ((compactificationSphere n).symm u).elim x (fun t => f t) + rw [p.source] + generalize (compactificationSphere n).symm u = z + induction z using OnePoint.rec with + | infty => rfl + | coe t => exact H.apply_zero t + map_one_left := by + intro u + change ((compactificationSphere n).symm u).elim (p 1) (fun t => H (1,t)) = + ((compactificationSphere n).symm u).elim y (fun t => g t) + rw [p.target] + generalize (compactificationSphere n).symm u = z + induction z using OnePoint.rec with + | infty => rfl + | coe t => exact H.apply_one t + +theorem exists_based_representative [PathConnectedSpace X] {n : ℕ} + (a : C(Metric.sphere (0 : EuclideanSpace ℝ (Fin (n+2))) 1,X)) (x : X) : + ∃ f : GenLoop (Fin (n+1)) X x, a.Homotopic (sphereMap f) := by + obtain ⟨p⟩ := PathConnectedSpace.joined (a (spherePoint n)) x + refine ⟨CubicalFreeNullity.rebase (sphereLoop a) p,?_⟩ + have h := sphereMovingHomotopy (CubicalFreeNullity.rebaseHomotopy (sphereLoop a) p) p + (fun s _t ht => CubicalFreeNullity.rebaseValue_boundary (sphereLoop a) p s ht) + simpa only [sphereMap_sphereLoop] using (show (sphereMap (sphereLoop a)).Homotopic + (sphereMap (CubicalFreeNullity.rebase (sphereLoop a) p)) from ⟨h⟩) + +end NearbyLagrangian.CubicalSphere + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/FiberCone.lean b/lean/OAI/Topology/Homotopy/FiberCone.lean new file mode 100644 index 0000000000000000000000000000000000000000..1660b0a1f604e731abf5db1ae6f6d7751885f3f3 --- /dev/null +++ b/lean/OAI/Topology/Homotopy/FiberCone.lean @@ -0,0 +1,393 @@ +import Mathlib + +namespace OAI + +/-! Fiberwise cones, contractions and left suspension homotopies. -/ + +noncomputable section +universe u v w +open Set ContinuousMap +open scoped Topology unitInterval + +namespace NearbyLagrangian.FiberCone + +variable {B A X Y : Type*} [TopologicalSpace B] [TopologicalSpace A] + [TopologicalSpace X] [TopologicalSpace Y] + +abbrev Raw (B A X : Type*) := X ⊕ ((unitInterval × A) ⊕ B) + +inductive Seam (f : C(A,X)) (q : C(A,B)) : Raw B A X → Raw B A X → Prop + | bottom (a : A) : Seam f q (.inr (.inl (0,a))) (.inl (f a)) + | top (a : A) : Seam f q (.inr (.inl (1,a))) (.inr (.inr (q a))) + +def Space (f : C(A,X)) (q : C(A,B)) := Quot (Seam f q) +instance (f : C(A,X)) (q : C(A,B)) : TopologicalSpace (Space f q) := + inferInstanceAs (TopologicalSpace (Quot (Seam f q))) + +def base (f : C(A,X)) (q : C(A,B)) : C(X,Space f q) := + ⟨fun x => Quot.mk _ (.inl x),continuous_quot_mk.comp continuous_inl⟩ +def ray (f : C(A,X)) (q : C(A,B)) : C(unitInterval × A,Space f q) := + ⟨fun z => Quot.mk _ (.inr (.inl z)), + continuous_quot_mk.comp (continuous_inr.comp continuous_inl)⟩ +def apex (f : C(A,X)) (q : C(A,B)) : C(B,Space f q) := + ⟨fun b => Quot.mk _ (.inr (.inr b)), + continuous_quot_mk.comp (continuous_inr.comp continuous_inr)⟩ + +@[simp] lemma ray_zero (f : C(A,X)) (q : C(A,B)) (a : A) : + ray f q (0,a) = base f q (f a) := Quot.sound (Seam.bottom a) +@[simp] lemma ray_one (f : C(A,X)) (q : C(A,B)) (a : A) : + ray f q (1,a) = apex f q (q a) := Quot.sound (Seam.top a) + +def lift (f : C(A,X)) (q : C(A,B)) (i : C(X,Y)) + (c : C(unitInterval × A,Y)) (v : C(B,Y)) + (h₀ : ∀ a, c (0,a) = i (f a)) (h₁ : ∀ a, c (1,a) = v (q a)) : + C(Space f q,Y) where + toFun := Quot.lift (Sum.elim i (Sum.elim c v)) (by + intro a b h + cases h with + | bottom a => exact h₀ a + | top a => exact h₁ a) + continuous_toFun := continuous_quot_lift _ + (i.continuous.sumElim (c.continuous.sumElim v.continuous)) + +@[simp] lemma lift_base (f : C(A,X)) (q : C(A,B)) (i : C(X,Y)) + (c : C(unitInterval × A,Y)) (v : C(B,Y)) + (h₀ : ∀ a, c (0,a) = i (f a)) (h₁ : ∀ a, c (1,a) = v (q a)) (x : X) : + lift f q i c v h₀ h₁ (base f q x) = i x := rfl +@[simp] lemma lift_ray (f : C(A,X)) (q : C(A,B)) (i : C(X,Y)) + (c : C(unitInterval × A,Y)) (v : C(B,Y)) + (h₀ : ∀ a, c (0,a) = i (f a)) (h₁ : ∀ a, c (1,a) = v (q a)) (z : unitInterval × A) : + lift f q i c v h₀ h₁ (ray f q z) = c z := rfl +@[simp] lemma lift_apex (f : C(A,X)) (q : C(A,B)) (i : C(X,Y)) + (c : C(unitInterval × A,Y)) (v : C(B,Y)) + (h₀ : ∀ a, c (0,a) = i (f a)) (h₁ : ∀ a, c (1,a) = v (q a)) (b : B) : + lift f q i c v h₀ h₁ (apex f q b) = v b := rfl + +@[elab_as_elim] theorem induction {f : C(A,X)} {q : C(A,B)} + {P : Space f q → Prop} (hbase : ∀ x, P (base f q x)) + (hray : ∀ ta, P (ray f q ta)) (hapex : ∀ b, P (apex f q b)) (z : Space f q) : P z := by + induction z using Quot.inductionOn with + | h z => + rcases z with x | (ta | b) + · exact hbase x + · exact hray ta + · exact hapex b + +def projection (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) : C(Space f q,B) := + lift f q p (q.comp ⟨Prod.snd,continuous_snd⟩) (ContinuousMap.id B) + (fun a => (hf a).symm) (fun _ => rfl) + +@[simp] lemma projection_base (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (x : X) : projection f p q hf (base f q x) = p x := rfl +@[simp] lemma projection_ray (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (ta : unitInterval × A) : + projection f p q hf (ray f q ta) = q ta.2 := rfl +@[simp] lemma projection_apex (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (b : B) : projection f p q hf (apex f q b) = b := rfl + +abbrev Susp (q : C(A,B)) := Space q q + +def suspProjection (q : C(A,B)) : C(Susp q,B) := + projection q (ContinuousMap.id B) q (fun _ => rfl) + +abbrev south (q : C(A,B)) : C(B,Susp q) := base q q +abbrev meridian (q : C(A,B)) : C(unitInterval × A,Susp q) := ray q q +abbrev north (q : C(A,B)) : C(B,Susp q) := apex q q + +def suspMap (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) : C(Susp q,Susp p) := + lift q q (south p) + ((meridian p).comp ⟨fun ta => (ta.1,f ta.2),continuous_fst.prodMk + (f.continuous.comp continuous_snd)⟩) (north p) + (fun a => by change meridian p (0,f a) = south p (q a); rw [ray_zero,hf]) + (fun a => by change meridian p (1,f a) = north p (q a); rw [ray_one,hf]) + +@[simp] lemma suspMap_south (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (b : B) : suspMap f p q hf (south q b) = south p b := rfl +@[simp] lemma suspMap_meridian (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (ta : unitInterval × A) : + suspMap f p q hf (meridian q ta) = meridian p (ta.1,f ta.2) := rfl +@[simp] lemma suspMap_north (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (b : B) : suspMap f p q hf (north q b) = north p b := rfl + +lemma suspMap_over (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (z : Susp q) : + suspProjection p (suspMap f p q hf z) = suspProjection q z := by + induction z using induction with + | hbase b => rfl + | hray ta => exact hf ta.2 + | hapex b => rfl + +def collapse (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) : C(Space f q,Susp q) := + lift f q ((south q).comp p) (meridian q) (north q) + (fun a => by change meridian q (0,a) = south q (p (f a)); rw [ray_zero,hf]) + (fun a => ray_one q q a) + +@[simp] lemma collapse_base (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (x : X) : collapse f p q hf (base f q x) = south q (p x) := rfl +@[simp] lemma collapse_ray (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (ta : unitInterval × A) : collapse f p q hf (ray f q ta) = meridian q ta := rfl +@[simp] lemma collapse_apex (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (b : B) : collapse f p q hf (apex f q b) = north q b := rfl + +lemma collapse_over (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) (z : Space f q) : + suspProjection q (collapse f p q hf z) = projection f p q hf z := by + induction z using induction with + | hbase x => rfl + | hray ta => rfl + | hapex b => rfl + +end NearbyLagrangian.FiberCone + +end + +noncomputable section +universe u v w +open Set ContinuousMap +open scoped Topology unitInterval + +namespace NearbyLagrangian.FiberCone +variable {B A X : Type*} [TopologicalSpace B] [TopologicalSpace A] [TopologicalSpace X] + +structure Contraction (f : C(A,X)) (p : C(X,B)) (q : C(A,B)) + (hf : ∀ a, p (f a) = q a) where + hom : C(unitInterval × Space f q,Space f q) + at_zero : ∀ z, hom (0,z) = z + at_one : ∀ z, hom (1,z) = apex f q (projection f p q hf z) + staysOver : ∀ t z, projection f p q hf (hom (t,z)) = projection f p q hf z + fixed : ∀ t b, hom (t,apex f q b) = apex f q b + +namespace Contraction +variable {f : C(A,X)} {p : C(X,B)} {q : C(A,B)} {hf : ∀ a, p (f a) = q a} +variable (H : Contraction f p q hf) + +def inverseRay : C(unitInterval × X,Susp q) := + (collapse f p q hf).comp + (H.hom.comp ⟨fun tx => (tx.1,base f q tx.2), + continuous_fst.prodMk ((base f q).continuous.comp continuous_snd)⟩) + +@[simp] lemma inverseRay_zero (x : X) : H.inverseRay (0,x) = south q (p x) := by + change collapse f p q hf (H.hom (0,base f q x)) = _ + rw [H.at_zero,collapse_base] +@[simp] lemma inverseRay_one (x : X) : H.inverseRay (1,x) = north q (p x) := by + change collapse f p q hf (H.hom (1,base f q x)) = _ + rw [H.at_one,projection_base,collapse_apex] + +def inverse : C(Susp p,Susp q) := + lift p p (south q) H.inverseRay (north q) H.inverseRay_zero H.inverseRay_one + +@[simp] lemma inverse_south (b : B) : H.inverse (south p b) = south q b := rfl +@[simp] lemma inverse_meridian (tx : unitInterval × X) : + H.inverse (meridian p tx) = collapse f p q hf (H.hom (tx.1,base f q tx.2)) := rfl +@[simp] lemma inverse_north (b : B) : H.inverse (north p b) = north q b := rfl + +lemma inverse_over (z : Susp p) : suspProjection q (H.inverse z) = suspProjection p z := by + induction z using induction with + | hbase b => rfl + | hray tx => + rw [inverse_meridian,collapse_over,H.staysOver,projection_base] + rfl + | hapex b => rfl + +end Contraction + +def squareDen (s : unitInterval) : ℝ := max (s:ℝ) (1-(s:ℝ)) +lemma squareDen_pos (s : unitInterval) : 0 < squareDen s := by + have ha := le_max_left (s:ℝ) (1-(s:ℝ)) + have hb := le_max_right (s:ℝ) (1-(s:ℝ)) + dsimp [squareDen] + linarith +lemma continuous_squareDen : Continuous squareDen := + continuous_subtype_val.max (continuous_const.sub continuous_subtype_val) + +def horizontal : C(unitInterval × unitInterval,unitInterval) where + toFun st := ⟨(1-(st.1:ℝ))*(st.2:ℝ) / squareDen st.1,by + refine ⟨div_nonneg (mul_nonneg (sub_nonneg.mpr st.1.property.2) st.2.property.1) + (squareDen_pos st.1).le,?_⟩ + apply (div_le_one (squareDen_pos st.1)).mpr + have h := mul_le_mul_of_nonneg_left st.2.property.2 (sub_nonneg.mpr st.1.property.2) + have h' : (1 - (st.1:ℝ)) * (st.2:ℝ) ≤ 1 - (st.1:ℝ) := by + simpa only [mul_one] using h + exact h'.trans (le_max_right _ _)⟩ + continuous_toFun := by + apply Continuous.subtype_mk + exact (((continuous_const.sub (continuous_subtype_val.comp continuous_fst)).mul + (continuous_subtype_val.comp continuous_snd)).div + (continuous_squareDen.comp continuous_fst) (fun _ => (squareDen_pos _).ne')) + +def vertical : C(unitInterval × unitInterval,unitInterval) where + toFun st := ⟨(st.1:ℝ)*(st.2:ℝ) / squareDen st.1,by + refine ⟨div_nonneg (mul_nonneg st.1.property.1 st.2.property.1) (squareDen_pos st.1).le,?_⟩ + apply (div_le_one (squareDen_pos st.1)).mpr + have h := mul_le_mul_of_nonneg_left st.2.property.2 st.1.property.1 + have h' : (st.1:ℝ) * (st.2:ℝ) ≤ (st.1:ℝ) := by + simpa only [mul_one] using h + exact h'.trans (le_max_left _ _)⟩ + continuous_toFun := by + apply Continuous.subtype_mk + exact (((continuous_subtype_val.comp continuous_fst).mul + (continuous_subtype_val.comp continuous_snd)).div + (continuous_squareDen.comp continuous_fst) (fun _ => (squareDen_pos _).ne')) + +@[simp] lemma horizontal_left (t : unitInterval) : horizontal (0,t) = t := by + apply Subtype.ext + simp [horizontal,squareDen] +@[simp] lemma horizontal_right (t : unitInterval) : horizontal (1,t) = 0 := by + apply Subtype.ext + simp [horizontal,squareDen] +@[simp] lemma vertical_left (t : unitInterval) : vertical (0,t) = 0 := by + apply Subtype.ext + simp [vertical,squareDen] +@[simp] lemma vertical_right (t : unitInterval) : vertical (1,t) = t := by + apply Subtype.ext + simp [vertical,squareDen] +@[simp] lemma horizontal_bottom (s : unitInterval) : horizontal (s,0) = 0 := by + apply Subtype.ext + simp [horizontal] +@[simp] lemma vertical_bottom (s : unitInterval) : vertical (s,0) = 0 := by + apply Subtype.ext + simp [vertical] + +lemma square_top (s : unitInterval) : horizontal (s,1) = 1 ∨ vertical (s,1) = 1 := by + rcases le_total (s:ℝ) (1-(s:ℝ)) with hs | hs + · left + apply Subtype.ext + have hn : 1-(s:ℝ) ≠ 0 := by + have hd := squareDen_pos s + rw [squareDen,max_eq_right hs] at hd + exact hd.ne' + simp [horizontal,squareDen,max_eq_right hs,hn] + · right + apply Subtype.ext + have hn : (s:ℝ) ≠ 0 := by + have hd := squareDen_pos s + rw [squareDen,max_eq_left hs] at hd + exact hd.ne' + simp [vertical,squareDen,max_eq_left hs,hn] + +end NearbyLagrangian.FiberCone + +end + +noncomputable section +universe u v w +open Set ContinuousMap +open scoped Topology unitInterval + +namespace NearbyLagrangian.FiberCone +variable {B A X Y : Type*} [TopologicalSpace B] [TopologicalSpace A] + [TopologicalSpace X] [TopologicalSpace Y] + +def cylinderLift (f : C(A,X)) (q : C(A,B)) (i : C(unitInterval × X,Y)) + (c : C(unitInterval × (unitInterval × A),Y)) (v : C(unitInterval × B,Y)) + (h₀ : ∀ s a, c (s,(0,a)) = i (s,f a)) + (h₁ : ∀ s a, c (s,(1,a)) = v (s,q a)) : C(unitInterval × Space f q,Y) := + (ContinuousMap.uncurry (lift f q + (ContinuousMap.curry (i.comp ContinuousMap.prodSwap)) + (ContinuousMap.curry (c.comp ContinuousMap.prodSwap)) + (ContinuousMap.curry (v.comp ContinuousMap.prodSwap)) + (fun a => by ext s; exact h₀ s a) + (fun a => by ext s; exact h₁ s a))).comp ContinuousMap.prodSwap + +@[simp] lemma cylinderLift_base (f : C(A,X)) (q : C(A,B)) (i : C(unitInterval × X,Y)) + (c : C(unitInterval × (unitInterval × A),Y)) (v : C(unitInterval × B,Y)) + (h₀ : ∀ s a, c (s,(0,a)) = i (s,f a)) + (h₁ : ∀ s a, c (s,(1,a)) = v (s,q a)) (s : unitInterval) (x : X) : + cylinderLift f q i c v h₀ h₁ (s,base f q x) = i (s,x) := rfl +@[simp] lemma cylinderLift_ray (f : C(A,X)) (q : C(A,B)) (i : C(unitInterval × X,Y)) + (c : C(unitInterval × (unitInterval × A),Y)) (v : C(unitInterval × B,Y)) + (h₀ : ∀ s a, c (s,(0,a)) = i (s,f a)) + (h₁ : ∀ s a, c (s,(1,a)) = v (s,q a)) (s : unitInterval) (ta : unitInterval × A) : + cylinderLift f q i c v h₀ h₁ (s,ray f q ta) = c (s,ta) := rfl +@[simp] lemma cylinderLift_apex (f : C(A,X)) (q : C(A,B)) (i : C(unitInterval × X,Y)) + (c : C(unitInterval × (unitInterval × A),Y)) (v : C(unitInterval × B,Y)) + (h₀ : ∀ s a, c (s,(0,a)) = i (s,f a)) + (h₁ : ∀ s a, c (s,(1,a)) = v (s,q a)) (s : unitInterval) (b : B) : + cylinderLift f q i c v h₀ h₁ (s,apex f q b) = v (s,b) := rfl + +namespace Contraction +variable {f : C(A,X)} {p : C(X,B)} {q : C(A,B)} {hf : ∀ a, p (f a) = q a} +variable (H : Contraction f p q hf) + +def leftRay : C(unitInterval × (unitInterval × A),Susp q) where + toFun z := collapse f p q hf (H.hom + (vertical (z.1,z.2.1),ray f q (horizontal (z.1,z.2.1),z.2.2))) + continuous_toFun := (collapse f p q hf).continuous.comp (H.hom.continuous.comp + ((vertical.continuous.comp (continuous_fst.prodMk (continuous_fst.comp continuous_snd))).prodMk + ((ray f q).continuous.comp + ((horizontal.continuous.comp (continuous_fst.prodMk (continuous_fst.comp continuous_snd))).prodMk + (continuous_snd.comp continuous_snd))))) + +lemma leftRay_bottom (s : unitInterval) (a : A) : H.leftRay (s,(0,a)) = south q (q a) := by + change collapse f p q hf (H.hom (vertical (s,0),ray f q (horizontal (s,0),a))) = _ + rw [horizontal_bottom,vertical_bottom,H.at_zero,ray_zero,collapse_base,hf] + +lemma leftRay_top (s : unitInterval) (a : A) : H.leftRay (s,(1,a)) = north q (q a) := by + change collapse f p q hf (H.hom (vertical (s,1),ray f q (horizontal (s,1),a))) = _ + rcases square_top s with hx | hy + · rw [hx,ray_one,H.fixed,collapse_apex] + · rw [hy,H.at_one,projection_ray,collapse_apex] + +def leftDeformation : C(unitInterval × Susp q,Susp q) := + cylinderLift q q ((south q).comp ⟨Prod.snd,continuous_snd⟩) H.leftRay + ((north q).comp ⟨Prod.snd,continuous_snd⟩) H.leftRay_bottom H.leftRay_top + +@[simp] lemma leftDeformation_south (s : unitInterval) (b : B) : + H.leftDeformation (s,south q b) = south q b := rfl +@[simp] lemma leftDeformation_meridian (s : unitInterval) (ta : unitInterval × A) : + H.leftDeformation (s,meridian q ta) = H.leftRay (s,ta) := rfl +@[simp] lemma leftDeformation_north (s : unitInterval) (b : B) : + H.leftDeformation (s,north q b) = north q b := rfl + +lemma leftDeformation_zero (z : Susp q) : H.leftDeformation (0,z) = z := by + induction z using induction with + | hbase b => rfl + | hray ta => + rw [leftDeformation_meridian] + change collapse f p q hf (H.hom + (vertical (0,ta.1),ray f q (horizontal (0,ta.1),ta.2))) = _ + rw [horizontal_left,vertical_left,H.at_zero,collapse_ray] + | hapex b => rfl + +lemma leftDeformation_one (z : Susp q) : + H.leftDeformation (1,z) = H.inverse (suspMap f p q hf z) := by + induction z using induction with + | hbase b => rw [leftDeformation_south,suspMap_south,inverse_south] + | hray ta => + rw [leftDeformation_meridian,suspMap_meridian,inverse_meridian] + change collapse f p q hf (H.hom + (vertical (1,ta.1),ray f q (horizontal (1,ta.1),ta.2))) = _ + rw [horizontal_right,vertical_right,ray_zero] + | hapex b => rw [leftDeformation_north,suspMap_north,inverse_north] + +lemma leftDeformation_over (s : unitInterval) (z : Susp q) : + suspProjection q (H.leftDeformation (s,z)) = suspProjection q z := by + induction z using induction with + | hbase b => rfl + | hray ta => + rw [leftDeformation_meridian] + change suspProjection q (collapse f p q hf (H.hom + (vertical (s,ta.1),ray f q (horizontal (s,ta.1),ta.2)))) = _ + rw [collapse_over,H.staysOver,projection_ray] + rfl + | hapex b => rfl + +def leftHomotopy : (H.inverse.comp (suspMap f p q hf)).Homotopy (ContinuousMap.id (Susp q)) := + ContinuousMap.Homotopy.symm + { toContinuousMap := H.leftDeformation + map_zero_left := H.leftDeformation_zero + map_one_left := H.leftDeformation_one } + +lemma leftHomotopy_over (s : unitInterval) (z : Susp q) : + suspProjection q (H.leftHomotopy (s,z)) = suspProjection q z := + H.leftDeformation_over (unitInterval.symm s) z + +end Contraction +end NearbyLagrangian.FiberCone + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/FiberKernel.lean b/lean/OAI/Topology/Homotopy/FiberKernel.lean new file mode 100644 index 0000000000000000000000000000000000000000..e73123de7a34f9629ae10913496cfae8c1e59c01 --- /dev/null +++ b/lean/OAI/Topology/Homotopy/FiberKernel.lean @@ -0,0 +1,57 @@ +import Mathlib +import OAI.Topology.Homotopy.HomotopyFiber +import OAI.Topology.Homotopy.LoopHomotopy + +namespace OAI + +/-! Nontrivial homotopy kernels from finite cardinality bounds. -/ + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.HomotopyFiber +open ContinuousMap +open scoped Topology Topology.Homotopy +open BasedHomotopy +variable {N X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] +variable [DecidableEq N] [Nonempty N] + +theorem nontrivial_kernel_of_large_fiber (e : C(X,Y)) (x : X) + {K : Type*} [Fintype K] + [Fintype (HomotopyGroup N (Path (e x) (e x)) (Path.refl (e x)))] + (ι : K ↪ HomotopyGroup N (Fiber e (e x)) (base e x)) + (hcard : Fintype.card (HomotopyGroup N (Path (e x) (e x)) (Path.refl (e x))) < Fintype.card K) : + ∃ a : HomotopyGroup N X x, a ≠ 1 ∧ groupMap e rfl a = 1 := by + classical + suffices h : ∃ k, groupMap (projection e (e x)) rfl (ι k) ≠ 1 by + obtain ⟨k,hk⟩ := h + exact ⟨groupMap (projection e (e x)) rfl (ι k),hk, + (kernel_eq_projection_range e x _).mpr ⟨ι k,rfl⟩⟩ + by_contra! h + choose q hq using fun k => (projection_kernel_eq_loop_range e x (ι k)).mp (h k) + have hi : Function.Injective q := by + intro k l hkl + apply ι.injective + have hk := hq k + rw [hkl] at hk + exact hk.symm.trans (hq l) + exact (Nat.not_le_of_lt hcard) (Fintype.card_le_of_injective q hi) + +theorem nontrivial_pi9_kernel_of_source_sizes (e : C(X,Y)) (x : X) + (sphereCalculation : π_ 10 Y (e x) ≃ (Fin 3 → ZMod 2)) + (whiteheadClasses : (ZMod 8 × (ZMod 2 × ZMod 2)) ↪ + π_ 9 (Fiber e (e x)) (base e x)) : + ∃ a : π_ 9 X x, a ≠ 1 ∧ groupMap e rfl a = 1 := by + let calculation := (pi9LoopEquivPi10 (e x)).trans sphereCalculation + let : Fintype (π_ 9 (Path (e x) (e x)) (Path.refl (e x))) := + Fintype.ofEquiv (Fin 3 → ZMod 2) calculation.symm + apply nontrivial_kernel_of_large_fiber e x whiteheadClasses + rw [Fintype.card_congr calculation] + norm_num + +end NearbyLagrangian.HomotopyFiber + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/HomotopyFiber.lean b/lean/OAI/Topology/Homotopy/HomotopyFiber.lean new file mode 100644 index 0000000000000000000000000000000000000000..50a0abb1361319986272216436627a785f3d2d22 --- /dev/null +++ b/lean/OAI/Topology/Homotopy/HomotopyFiber.lean @@ -0,0 +1,319 @@ +import Mathlib +import OAI.Topology.Homotopy.BasedMaps + +namespace OAI + +/-! The path-space homotopy fiber and exactness at its projection. -/ + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.HomotopyFiber +open ContinuousMap +open scoped Topology Topology.Homotopy +open BasedHomotopy +variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] + +def Fiber (e : C(X,Y)) (y : Y) := + {z : X × C(unitInterval,Y) // z.2 0 = e z.1 ∧ z.2 1 = y} + +instance (e : C(X,Y)) (y : Y) : TopologicalSpace (Fiber e y) := inferInstanceAs + (TopologicalSpace {z : X × C(unitInterval,Y) // z.2 0 = e z.1 ∧ z.2 1 = y}) + +def base (e : C(X,Y)) (x : X) : Fiber e (e x) := + ⟨(x,ContinuousMap.const _ (e x)),rfl,rfl⟩ + +def projection (e : C(X,Y)) (y : Y) : C(Fiber e y,X) := + ⟨fun z => z.1.1,continuous_fst.comp continuous_subtype_val⟩ + +@[simp] theorem projection_base (e : C(X,Y)) (x : X) : + projection e (e x) (base e x) = x := rfl + +variable {N : Type*} + +def projectionNullhomotopy (e : C(X,Y)) (x : X) + (f : GenLoop N (Fiber e (e x)) (base e x)) : + (loopMap e rfl (loopMap (projection e (e x)) rfl f)).1.HomotopyRel (ContinuousMap.const _ (e x)) (Cube.boundary N) where + toFun z := (f z.2).1.2 z.1 + continuous_toFun := by + exact ((continuous_snd.comp (continuous_subtype_val.comp (f.1.continuous.comp continuous_snd))).eval continuous_fst) + map_zero_left t := (f t).2.1 + map_one_left t := (f t).2.2 + prop' s t ht := by + change (f t).1.2 s = e (f t).1.1 + rw [GenLoop.boundary f t ht] + rfl + +def liftNullhomotopy (e : C(X,Y)) (x : X) (f : GenLoop N X x) + (H : (loopMap e rfl f).1.HomotopyRel (ContinuousMap.const _ (e x)) (Cube.boundary N)) : + GenLoop N (Fiber e (e x)) (base e x) := + ⟨⟨fun t => ⟨(f t,(H.toContinuousMap.comp ContinuousMap.prodSwap).curry t), + H.map_zero_left t,H.map_one_left t⟩,by + apply Continuous.subtype_mk + exact f.1.continuous.prodMk (H.toContinuousMap.comp ContinuousMap.prodSwap).curry.continuous⟩, + by + intro t ht + apply Subtype.ext + apply Prod.ext (GenLoop.boundary f t ht) + ext s + exact (H.prop s t ht).trans (congrArg e (GenLoop.boundary f t ht))⟩ + +@[simp] theorem projection_liftNullhomotopy (e : C(X,Y)) (x : X) (f : GenLoop N X x) + (H : (loopMap e rfl f).1.HomotopyRel (ContinuousMap.const _ (e x)) (Cube.boundary N)) : + loopMap (projection e (e x)) rfl (liftNullhomotopy e x f H) = f := by ext; rfl + +theorem kernel_eq_projection_range [DecidableEq N] [Nonempty N] + (e : C(X,Y)) (x : X) (a : HomotopyGroup N X x) : + groupMap e rfl a = 1 ↔ + ∃ b : HomotopyGroup N (Fiber e (e x)) (base e x), + groupMap (projection e (e x)) rfl b = a := by + induction a using Quotient.inductionOn with + | h f => + constructor + · intro h + change (⟦loopMap e rfl f⟧ : HomotopyGroup N Y (e x)) = ⟦GenLoop.const⟧ at h + obtain ⟨H⟩ := Quotient.exact h + exact ⟨⟦liftNullhomotopy e x f H⟧,congrArg Quotient.mk'' (projection_liftNullhomotopy e x f H)⟩ + · rintro ⟨b,hb⟩ + rw [← hb] + induction b using Quotient.inductionOn with + | h g => + change (⟦loopMap e rfl (loopMap (projection e (e x)) rfl g)⟧ : HomotopyGroup N Y (e x)) = ⟦GenLoop.const⟧ + exact Quotient.sound ⟨projectionNullhomotopy e x g⟩ + +end NearbyLagrangian.HomotopyFiber + +end + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.HomotopyFiber +open ContinuousMap Set +open scoped Topology Topology.Homotopy +open BasedHomotopy + +def frontTime (s r : unitInterval) : unitInterval := projIcc 0 1 zero_le_one ((s:ℝ)-2*r) +def backTime (s r : unitInterval) : unitInterval := projIcc 0 1 zero_le_one ((2*(r:ℝ)-s)/(2-s)) + +lemma continuous_frontTime : Continuous (fun z : unitInterval × unitInterval => frontTime z.1 z.2) := by + unfold frontTime + fun_prop + +lemma continuous_backTime : Continuous (fun z : unitInterval × unitInterval => backTime z.1 z.2) := by + unfold backTime + apply continuous_projIcc.comp + apply Continuous.div + · fun_prop + · fun_prop + · intro z + have := z.1.property.2 + linarith + +@[simp] lemma frontTime_zero_right (s : unitInterval) : frontTime s 0 = s := by + change projIcc 0 1 zero_le_one ((s:ℝ)-2*0) = s + simp only [mul_zero,sub_zero] + exact projIcc_val _ s + +@[simp] lemma backTime_one_right (s : unitInterval) : backTime s 1 = 1 := by + unfold backTime + have hs : (2:ℝ)-s ≠ 0 := by linarith [s.property.2] + simp [hs] + +@[simp] lemma backTime_zero_left (r : unitInterval) : backTime 0 r = r := by + change projIcc 0 1 zero_le_one ((2*(r:ℝ)-0)/(2-0)) = r + have he : (2*(r:ℝ)-(0:ℝ))/(2-(0:ℝ)) = r := by ring + rw [he] + exact projIcc_val _ r + +lemma frontTime_seam {s r : unitInterval} (h : 2*(r:ℝ)=s) : frontTime s r = 0 := by + unfold frontTime + rw [h,sub_self] + exact projIcc_left _ + +lemma backTime_seam {s r : unitInterval} (h : 2*(r:ℝ)=s) : backTime s r = 0 := by + unfold backTime + rw [h,sub_self,zero_div] + exact projIcc_left _ + +variable {A X Y : Type*} [TopologicalSpace A] [TopologicalSpace X] [TopologicalSpace Y] +variable (e : C(X,Y)) (x : X) (f : C(A,Fiber e (e x))) +variable (H : ((projection e (e x)).comp f).Homotopy (ContinuousMap.const A x)) + +def deformValue (z : (unitInterval × A) × unitInterval) : Y := + if 2*(z.2:ℝ) ≤ z.1.1 then e (H (frontTime z.1.1 z.2,z.1.2)) + else (f z.1.2).1.2 (backTime z.1.1 z.2) + +lemma continuous_deformValue : Continuous (deformValue e x f H) := by + unfold deformValue + apply continuous_if_le + · fun_prop + · fun_prop + · apply Continuous.continuousOn + apply e.continuous.comp + apply H.continuous.comp + exact (continuous_frontTime.comp ((continuous_fst.comp continuous_fst).prodMk continuous_snd)).prodMk + (continuous_snd.comp continuous_fst) + · apply Continuous.continuousOn + exact (continuous_snd.comp (continuous_subtype_val.comp + (f.continuous.comp (continuous_snd.comp continuous_fst)))).eval + (continuous_backTime.comp ((continuous_fst.comp continuous_fst).prodMk continuous_snd)) + · intro z hz + rw [frontTime_seam hz,backTime_seam hz,H.apply_zero] + exact (f z.1.2).2.1.symm + +@[simp] lemma deformValue_start (s : unitInterval) (a : A) : + deformValue e x f H ((s,a),0) = e (H (s,a)) := by + change (if 2*(0:ℝ) ≤ s then e (H (frontTime s 0,a)) else (f a).1.2 (backTime s 0)) = e (H (s,a)) + simp only [mul_zero,ite_eq_left s.property.1,frontTime_zero_right] + +@[simp] lemma deformValue_end (s : unitInterval) (a : A) : + deformValue e x f H ((s,a),1) = e x := by + change (if 2*(1:ℝ) ≤ s then e (H (frontTime s 1,a)) else (f a).1.2 (backTime s 1)) = e x + have hs : ¬ 2*(1:ℝ) ≤ (s:ℝ) := by linarith [s.property.2] + rw [ite_eq_right hs,backTime_one_right] + exact (f a).2.2 + +@[simp] lemma deformValue_zero (a : A) (r : unitInterval) : + deformValue e x f H ((0,a),r) = (f a).1.2 r := by + unfold deformValue + split_ifs with hr + · have he : r = 0 := Subtype.ext (by dsimp at hr ⊢; linarith [r.property.1]) + rw [he,frontTime_zero_right,H.apply_zero] + exact (f a).2.1.symm + · rw [backTime_zero_left] + +def deformPath : C(unitInterval × A,C(unitInterval,Y)) := + (⟨deformValue e x f H,continuous_deformValue e x f H⟩ : C((unitInterval × A) × unitInterval,Y)).curry + +def deformFiber : C(unitInterval × A,Fiber e (e x)) where + toFun z := ⟨(H z,deformPath e x f H z),deformValue_start e x f H z.1 z.2,deformValue_end e x f H z.1 z.2⟩ + continuous_toFun := (H.continuous.prodMk (deformPath e x f H).continuous).subtype_mk _ + +@[simp] lemma deformFiber_zero (a : A) : deformFiber e x f H (0,a) = f a := by + apply Subtype.ext + apply Prod.ext + · exact H.apply_zero a + · ext r + exact deformValue_zero e x f H a r + +def loopInclusion : C(Path (e x) (e x),Fiber e (e x)) where + toFun p := ⟨(x,p.toContinuousMap),p.source,p.target⟩ + continuous_toFun := (continuous_const.prodMk continuous_induced_dom).subtype_mk _ + +@[simp] lemma loopInclusion_base : loopInclusion e x (Path.refl (e x)) = base e x := rfl + +def loopRepresentative : C(A,Path (e x) (e x)) where + toFun a := { + toContinuousMap := deformPath e x f H (1,a) + source' := by + change deformValue e x f H ((1,a),0) = e x + rw [deformValue_start,H.apply_one,ContinuousMap.const_apply] + target' := deformValue_end e x f H 1 a } + continuous_toFun := by + apply Path.continuous_uncurry_iff.mp + exact (continuous_deformValue e x f H).comp ((continuous_const.prodMk continuous_fst).prodMk continuous_snd) + +def deformHomotopy : f.Homotopy ((loopInclusion e x).comp (loopRepresentative e x f H)) where + toContinuousMap := deformFiber e x f H + map_zero_left := deformFiber_zero e x f H + map_one_left a := by + apply Subtype.ext + apply Prod.ext + · exact H.apply_one a + · rfl + +lemma deformValue_fixed (a : A) (ha : f a = base e x) (hH : ∀ s, H (s,a) = x) + (s r : unitInterval) : deformValue e x f H ((s,a),r) = e x := by + unfold deformValue + split_ifs + · rw [hH] + · rw [ha] + rfl + +lemma deformFiber_fixed (a : A) (ha : f a = base e x) (hH : ∀ s, H (s,a) = x) + (s : unitInterval) : deformFiber e x f H (s,a) = base e x := by + apply Subtype.ext + apply Prod.ext (hH s) + ext r + exact deformValue_fixed e x f H a ha hH s r + +lemma loopRepresentative_fixed (a : A) (ha : f a = base e x) (hH : ∀ s, H (s,a) = x) : + loopRepresentative e x f H a = Path.refl (e x) := by + apply Path.ext + funext r + exact deformValue_fixed e x f H a ha hH 1 r + +end NearbyLagrangian.HomotopyFiber + +end + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.HomotopyFiber +open ContinuousMap +open scoped Topology Topology.Homotopy +open BasedHomotopy +variable {N X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] +variable (e : C(X,Y)) (x : X) + +def boundaryRepresentative (f : GenLoop N (Fiber e (e x)) (base e x)) + (H : (loopMap (projection e (e x)) rfl f).1.HomotopyRel + (ContinuousMap.const _ x) (Cube.boundary N)) : + GenLoop N (Path (e x) (e x)) (Path.refl (e x)) := + ⟨loopRepresentative e x f.1 H.toHomotopy,by + intro t ht + apply loopRepresentative_fixed + · exact GenLoop.boundary f t ht + · intro s + exact (H.prop s t ht).trans (congrArg (projection e (e x)) (GenLoop.boundary f t ht))⟩ + +def boundaryRepresentativeHomotopy (f : GenLoop N (Fiber e (e x)) (base e x)) + (H : (loopMap (projection e (e x)) rfl f).1.HomotopyRel + (ContinuousMap.const _ x) (Cube.boundary N)) : + f.1.HomotopyRel (loopMap (loopInclusion e x) rfl (boundaryRepresentative e x f H)).1 + (Cube.boundary N) where + toHomotopy := deformHomotopy e x f.1 H.toHomotopy + prop' s t ht := by + change deformFiber e x f.1 H.toHomotopy (s,t) = f t + rw [GenLoop.boundary f t ht] + apply deformFiber_fixed + · exact GenLoop.boundary f t ht + · intro r + exact (H.prop r t ht).trans (congrArg (projection e (e x)) (GenLoop.boundary f t ht)) + +@[simp] theorem projection_loopInclusion (g : GenLoop N (Path (e x) (e x)) (Path.refl (e x))) : + loopMap (projection e (e x)) rfl (loopMap (loopInclusion e x) rfl g) = GenLoop.const := by + ext t + rfl + +theorem projection_kernel_eq_loop_range [DecidableEq N] [Nonempty N] + (a : HomotopyGroup N (Fiber e (e x)) (base e x)) : + groupMap (projection e (e x)) rfl a = 1 ↔ + ∃ b : HomotopyGroup N (Path (e x) (e x)) (Path.refl (e x)), + groupMap (loopInclusion e x) rfl b = a := by + induction a using Quotient.inductionOn with + | h f => + constructor + · intro h + change (⟦loopMap (projection e (e x)) rfl f⟧ : HomotopyGroup N X x) = ⟦GenLoop.const⟧ at h + obtain ⟨H⟩ := Quotient.exact h + refine ⟨⟦boundaryRepresentative e x f H⟧, ?_⟩ + exact Quotient.sound ⟨(boundaryRepresentativeHomotopy e x f H).symm⟩ + · rintro ⟨b,hb⟩ + rw [← hb] + induction b using Quotient.inductionOn with + | h g => + change (⟦loopMap (projection e (e x)) rfl (loopMap (loopInclusion e x) rfl g)⟧ : + HomotopyGroup N X x) = ⟦GenLoop.const⟧ + exact congrArg Quotient.mk'' (projection_loopInclusion e x g) + +end NearbyLagrangian.HomotopyFiber + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/LoopHomotopy.lean b/lean/OAI/Topology/Homotopy/LoopHomotopy.lean new file mode 100644 index 0000000000000000000000000000000000000000..69aa93de71227f2fa4ad548f394b8bc2eb8c3ff2 --- /dev/null +++ b/lean/OAI/Topology/Homotopy/LoopHomotopy.lean @@ -0,0 +1,143 @@ +import Mathlib + +namespace OAI + +/-! Loop-space homeomorphisms and the degree-shift equivalence. -/ + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.BasedHomotopy +open ContinuousMap +open scoped Topology Topology.Homotopy +variable {N M X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] +variable {x : X} {y : Y} + +theorem genLoop_homotopic_iff_joined (f g : GenLoop N X x) : + GenLoop.Homotopic f g ↔ Joined f g := by + constructor + · rintro ⟨H⟩ + refine ⟨{ + toFun := fun s => ⟨H.toContinuousMap.curry s,fun t ht => + (H.prop s t ht).trans (GenLoop.boundary f t ht)⟩ + continuous_toFun := H.toContinuousMap.curry.continuous.subtype_mk _ + source' := ?_ + target' := ?_ }⟩ + · ext t; exact H.apply_zero t + · ext t; exact H.apply_one t + · rintro ⟨P⟩ + refine ⟨{ + toFun := fun z => P z.1 z.2 + continuous_toFun := ?_ + map_zero_left := ?_ + map_one_left := ?_ + prop' := ?_ }⟩ + · exact (continuous_subtype_val.comp (P.continuous.comp continuous_fst)).eval continuous_snd + · intro t; exact congrArg (fun z : GenLoop N X x => z t) P.source + · intro t; exact congrArg (fun z : GenLoop N X x => z t) P.target + · intro s t ht + exact (GenLoop.boundary (P s) t ht).trans (GenLoop.boundary f t ht).symm + +def piEquivOfLoopHomeomorph (e : GenLoop N X x ≃ₜ GenLoop M Y y) : + HomotopyGroup N X x ≃ HomotopyGroup M Y y := + Quotient.congr e.toEquiv fun f g => by + change GenLoop.Homotopic f g ↔ GenLoop.Homotopic (e f) (e g) + rw [genLoop_homotopic_iff_joined,genLoop_homotopic_iff_joined] + constructor + · intro h; exact h.map e.continuous_toFun + · intro h + have hh : Joined (e.symm (e f)) (e.symm (e g)) := h.map e.symm.continuous_toFun + simpa only [Homeomorph.symm_apply_apply] using hh + +def piReindexEquiv (e : N ≃ M) (x : X) : + HomotopyGroup N X x ≃ HomotopyGroup M X x := + piEquivOfLoopHomeomorph (GenLoop.congr x e) + +def flattenPathLoop (f : GenLoop N (Path y y) (Path.refl y)) : + GenLoop (N ⊕ Unit) Y y := + ⟨⟨fun a => f (a ∘ Sum.inl) (a (Sum.inr ())),by + apply Continuous.eval + · exact f.1.continuous.comp (by fun_prop) + · fun_prop⟩,by + rintro a ⟨i | i,hi⟩ <;> change f (a ∘ Sum.inl) (a (Sum.inr ())) = y + · have h : a ∘ Sum.inl ∈ Cube.boundary N := ⟨i,hi⟩ + rw [GenLoop.boundary f _ h] + rfl + · cases i + rcases hi with hi | hi + · rw [hi]; exact (f _).source + · rw [hi]; exact (f _).target⟩ + +def curryPathLoop (g : GenLoop (N ⊕ Unit) Y y) : + GenLoop N (Path y y) (Path.refl y) := + ⟨⟨fun a => { + toFun := fun r => g (Sum.elim a (fun _ => r)) + continuous_toFun := g.1.continuous.comp (by apply continuous_pi; intro i; cases i <;> dsimp only [Sum.elim] <;> fun_prop) + source' := GenLoop.boundary g _ ⟨Sum.inr (),Or.inl rfl⟩ + target' := GenLoop.boundary g _ ⟨Sum.inr (),Or.inr rfl⟩ },by + apply Path.continuous_uncurry_iff.mp + exact g.1.continuous.comp (by apply continuous_pi; intro i; cases i <;> dsimp only [Sum.elim] <;> fun_prop)⟩,by + rintro a ⟨i,hi⟩ + apply Path.ext + funext r + exact GenLoop.boundary g _ ⟨Sum.inl i,hi⟩⟩ + +@[simp] lemma curry_flatten (f : GenLoop N (Path y y) (Path.refl y)) : + curryPathLoop (flattenPathLoop f) = f := by + apply Subtype.ext + ext a r + rfl + +@[simp] lemma flatten_curry (g : GenLoop (N ⊕ Unit) Y y) : + flattenPathLoop (curryPathLoop g) = g := by + apply Subtype.ext + ext a + change g (Sum.elim (a ∘ Sum.inl) (fun _ => a (Sum.inr ()))) = g a + congr 1 + funext i + cases i with + | inl i => rfl + | inr i => cases i; rfl + +lemma continuous_flattenPathLoop : Continuous (@flattenPathLoop N Y _ y) := by + apply Continuous.subtype_mk + apply ContinuousMap.continuous_of_continuous_uncurry + change Continuous (fun z : GenLoop N (Path y y) (Path.refl y) × ((N ⊕ Unit) → unitInterval) => + z.1 (z.2 ∘ Sum.inl) (z.2 (Sum.inr ()))) + have h : Continuous (fun z : GenLoop N (Path y y) (Path.refl y) × ((N ⊕ Unit) → unitInterval) => + z.1 (z.2 ∘ Sum.inl)) := + (continuous_subtype_val.comp continuous_fst).eval + (continuous_pi (fun i => (continuous_apply (Sum.inl i)).comp continuous_snd)) + exact h.eval ((continuous_apply (Sum.inr ())).comp continuous_snd) + +lemma continuous_curryPathLoop : Continuous (@curryPathLoop N Y _ y) := by + apply Continuous.subtype_mk + apply ContinuousMap.continuous_of_continuous_uncurry + apply Path.continuous_uncurry_iff.mp + exact (continuous_subtype_val.comp (continuous_fst.comp continuous_fst)).eval + (by apply continuous_pi; intro i; cases i <;> dsimp only [Sum.elim] <;> fun_prop) + +def loopSpaceCubeHomeomorph : + GenLoop N (Path y y) (Path.refl y) ≃ₜ GenLoop (N ⊕ Unit) Y y where + toFun := flattenPathLoop + invFun := curryPathLoop + left_inv := curry_flatten + right_inv := flatten_curry + continuous_toFun := continuous_flattenPathLoop + continuous_invFun := continuous_curryPathLoop + +def loopPiEquiv (y : Y) : + HomotopyGroup N (Path y y) (Path.refl y) ≃ HomotopyGroup (N ⊕ Unit) Y y := + piEquivOfLoopHomeomorph loopSpaceCubeHomeomorph + +def pi9LoopEquivPi10 (y : Y) : + π_ 9 (Path y y) (Path.refl y) ≃ π_ 10 Y y := + (loopPiEquiv y).trans (piReindexEquiv + ((Equiv.sumCongr (Equiv.refl (Fin 9)) (Equiv.ofUnique Unit (Fin 1))).trans finSumFinEquiv) y) + +end NearbyLagrangian.BasedHomotopy + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/OpenCollapse.lean b/lean/OAI/Topology/Homotopy/OpenCollapse.lean new file mode 100644 index 0000000000000000000000000000000000000000..1afd3a48b2554d8d9c38de5b72315eed29fcec66 --- /dev/null +++ b/lean/OAI/Topology/Homotopy/OpenCollapse.lean @@ -0,0 +1,128 @@ +import Mathlib + +namespace OAI + +/-! Continuous collapse to a one-point compactification and parameterized descent. -/ + +noncomputable section +universe u v w +open Set ContinuousMap Topology +open scoped Classical OnePoint Topology + +namespace NearbyLagrangian.OpenCollapse +variable {Y : Type*} + +def collapse (U : Set Y) (y : Y) : OnePoint U := + if h : y ∈ U then (⟨y,h⟩ : U) else ∞ + +@[simp] lemma collapse_of_mem {U : Set Y} {y : Y} (h : y ∈ U) : + collapse U y = (⟨y,h⟩ : U) := by simp [collapse,h] +@[simp] lemma collapse_of_notMem {U : Set Y} {y : Y} (h : y ∉ U) : + collapse U y = ∞ := by simp [collapse,h] +lemma collapse_eq_infty {U : Set Y} {y : Y} : collapse U y = ∞ ↔ y ∉ U := by + by_cases h : y ∈ U <;> simp [h] +lemma collapse_eq {U : Set Y} {y z : Y} : + collapse U y = collapse U z ↔ y = z ∨ y ∉ U ∧ z ∉ U := by + by_cases hy : y ∈ U + · by_cases hz : z ∈ U + · simp [collapse,hy,hz] + · have hn : y ≠ z := by rintro rfl; contradiction + simp [collapse,hy,hz,hn] + · by_cases hz : z ∈ U + · have hn : y ≠ z := by rintro rfl; contradiction + simp [collapse,hy,hz,hn] + · simp [collapse,hy,hz] + +variable [TopologicalSpace Y] [T2Space Y] + +lemma continuous_collapse {U : Set Y} (hU : IsOpen U) : Continuous (collapse U) := by + rw [continuous_def] + intro S hS + by_cases hi : ∞ ∈ S + · have hK := ((OnePoint.isOpen_iff_of_mem hi).mp hS).2 + have he : (collapse U ⁻¹' S)ᶜ = Subtype.val '' (((↑) : U → OnePoint U) ⁻¹' S)ᶜ := by + ext y + by_cases hy : y ∈ U + · simp [hy,Set.mem_image,collapse] + · simp [hy,collapse,hi] + rw [← isClosed_compl_iff,he] + exact (hK.image continuous_subtype_val).isClosed + · have hV := (OnePoint.isOpen_iff_of_notMem hi).mp hS + have he : collapse U ⁻¹' S = Subtype.val '' (((↑) : U → OnePoint U) ⁻¹' S) := by + ext y + by_cases hy : y ∈ U + · simp [hy,Set.mem_image,collapse] + · simp [hy,collapse,hi] + rw [he] + exact hU.isOpenMap_subtype_val _ hV + +omit [TopologicalSpace Y] [T2Space Y] in +lemma collapse_surjective {U : Set Y} (hU : Uᶜ.Nonempty) : Function.Surjective (collapse U) := by + intro z + induction z using OnePoint.rec with + | infty => obtain ⟨y,hy⟩ := hU; exact ⟨y,collapse_of_notMem hy⟩ + | coe y => exact ⟨y,collapse_of_mem y.property⟩ + +variable [CompactSpace Y] +lemma isQuotientMap_collapse {U : Set Y} (hU : IsOpen U) (hUc : Uᶜ.Nonempty) : + IsQuotientMap (collapse U) := by + let : LocallyCompactSpace U := hU.locallyCompactSpace + exact (continuous_collapse hU).isClosedMap.isQuotientMap (continuous_collapse hU) + (collapse_surjective hUc) + +def descend {U : Set Y} (hU : IsOpen U) (hUc : Uᶜ.Nonempty) + {X : Type*} [TopologicalSpace X] (f : C(Y,X)) (x : X) + (hf : ∀ y ∉ U, f y = x) : C(OnePoint U,X) where + toFun := fun z => z.elim x (fun y => f y) + continuous_toFun := (isQuotientMap_collapse hU hUc).continuous_iff.mpr (by + have he : (fun z : OnePoint U => z.elim x (fun y => f y)) ∘ collapse U = f := by + funext y + by_cases hy : y ∈ U + · simp [hy] + · simp [hy,hf y hy] + rw [he] + exact f.continuous) + +@[simp] lemma descend_collapse {U : Set Y} (hU : IsOpen U) (hUc : Uᶜ.Nonempty) + {X : Type*} [TopologicalSpace X] (f : C(Y,X)) (x : X) + (hf : ∀ y ∉ U, f y = x) (y : Y) : descend hU hUc f x hf (collapse U y) = f y := by + by_cases hy : y ∈ U <;> simp [descend,hy,hf y] + +end NearbyLagrangian.OpenCollapse + +end + +noncomputable section +universe u v w +open Set ContinuousMap Topology +open scoped Classical OnePoint Topology + +namespace NearbyLagrangian.OpenCollapse +variable {Y P X : Type*} [TopologicalSpace Y] [T2Space Y] [CompactSpace Y] + [TopologicalSpace P] [T2Space P] [CompactSpace P] [TopologicalSpace X] + +lemma continuous_descend_param {U : Set Y} (hU : IsOpen U) (hUc : Uᶜ.Nonempty) + (F : C(P × Y,X)) (g : C(P,X)) (hF : ∀ p y, y ∉ U → F (p,y) = g p) : + Continuous (fun q : P × OnePoint U => q.2.elim (g q.1) (fun y => F (q.1,y))) := by + let : LocallyCompactSpace U := hU.locallyCompactSpace + let c : P × Y → P × OnePoint U := fun z => (z.1,collapse U z.2) + have hc : Continuous c := continuous_fst.prodMk ((continuous_collapse hU).comp continuous_snd) + have hs : Function.Surjective c := by + rintro ⟨p,z⟩ + obtain ⟨y,hy⟩ := collapse_surjective hUc z + exact ⟨(p,y),Prod.ext rfl hy⟩ + have hq := hc.isClosedMap.isQuotientMap hc hs + apply hq.continuous_iff.mpr + have he : (fun q : P × OnePoint U => q.2.elim (g q.1) (fun y => F (q.1,y))) ∘ c = F := by + funext q + rcases q with ⟨p,y⟩ + change (collapse U y).elim (g p) (fun y => F (p,y)) = F (p,y) + by_cases hy : y ∈ U <;> simp [hy,hF p y] + rw [he] + exact F.continuous + +end NearbyLagrangian.OpenCollapse + +end + +end OAI diff --git a/lean/OAI/Topology/Homotopy/RayTelescope.lean b/lean/OAI/Topology/Homotopy/RayTelescope.lean new file mode 100644 index 0000000000000000000000000000000000000000..84c2e7f9861004767048c7014e390b54131bf093 --- /dev/null +++ b/lean/OAI/Topology/Homotopy/RayTelescope.lean @@ -0,0 +1,383 @@ +import Mathlib + +namespace OAI + +/-! Sequential ray telescopes, finite-stage representatives and path connectedness. -/ + +noncomputable section +universe u v w +open Set ContinuousMap +open scoped Topology + +namespace NearbyLagrangian.RayTelescope +variable (X : ℕ → Type u) [∀ n, TopologicalSpace (X n)] +variable (φ : ∀ m n, m ≤ n → C(X m,X n)) + +abbrev Raw := Σ n, X n × {t : ℝ // (n:ℝ) ≤ t} + +inductive Glue : Raw X → Raw X → Prop + | step (n m : ℕ) (h : n ≤ m) (x : X n) (t : ℝ) (ht : (m:ℝ) ≤ t) : + Glue ⟨n,(x,⟨t,(by exact le_trans (by exact_mod_cast h) ht)⟩)⟩ + ⟨m,(φ n m h x,⟨t,ht⟩)⟩ + +abbrev Space := Quot (Glue X φ) + +def rawHeight : C(Raw X,ℝ) := + ⟨fun a => a.2.2,continuous_sigma (fun _ => continuous_subtype_val.comp continuous_snd)⟩ + +def height : C(Space X φ,ℝ) := + ⟨Quot.lift (rawHeight X) (by intro a b h; cases h; rfl), + continuous_quot_lift _ (rawHeight X).continuous⟩ + +@[simp] theorem height_quot (a : Raw X) : height X φ (Quot.mk _ a) = a.2.2 := rfl + +def bottomTime (n : ℕ) : {t : ℝ // (n:ℝ) ≤ t} := ⟨(n:ℝ),by exact le_rfl⟩ + +def stage (n : ℕ) : C(X n,Space X φ) := + ⟨fun x => Quot.mk _ ⟨n,(x,bottomTime n)⟩,by + exact continuous_quot_mk.comp (continuous_sigmaMk.comp + (continuous_id.prodMk (continuous_const : + Continuous (fun _ : X n => bottomTime n))))⟩ + +@[simp] theorem height_stage (n : ℕ) (x : X n) : height X φ (stage X φ n x) = n := rfl + +variable [∀ n, Nonempty (X n)] +variable [DirectedSystem X (fun {m n} h => (φ m n h : _ → _))] + +def rawCollapse (N : ℕ) : C(Raw X,X N) where + toFun a := if h : a.1 ≤ N then φ a.1 N h a.2.1 else Classical.choice inferInstance + continuous_toFun := continuous_sigma (fun n => by + by_cases h : n ≤ N + · simpa only [dite_eq_left h,Function.comp_def] using (φ n N h).continuous.comp continuous_fst + · simpa only [dite_eq_right h] using + (continuous_const : Continuous (fun _ : X n × {t : ℝ // (n:ℝ) ≤ t} => (Classical.choice inferInstance : X N)))) + +omit [∀ n, Nonempty (X n)] in +lemma stage_le_of_height_lt {N : ℕ} (a : Raw X) (h : rawHeight X a < (N:ℝ)+1) : a.1 ≤ N := by + have h' : (a.1:ℝ) < (N:ℝ)+1 := lt_of_le_of_lt a.2.2.2 h + have : a.1 < N+1 := by exact_mod_cast h' + omega + +lemma collapse_compatible {N : ℕ} {a b : Raw X} + (h : Quot.mk (Glue X φ) a = Quot.mk (Glue X φ) b) + (ha : rawHeight X a < (N:ℝ)+1) : rawCollapse X φ N a = rawCollapse X φ N b := by + have hrel := Quot.eqvGen_exact h + have aux : ∀ a b, Relation.EqvGen (Glue X φ) a b → + rawHeight X a = rawHeight X b ∧ + (rawHeight X a < (N:ℝ)+1 → rawCollapse X φ N a = rawCollapse X φ N b) := by + intro a b h + induction h with + | rel a b hab => + cases hab with + | step n m h x t ht => + refine ⟨rfl,fun hz => ?_⟩ + have hm : m ≤ N := stage_le_of_height_lt X ⟨m,(φ n m h x,⟨t,ht⟩)⟩ hz + have hn := h.trans hm + simp only [rawCollapse,ContinuousMap.coe_mk,dite_eq_left hn,dite_eq_left hm] + exact (DirectedSystem.map_map (f:=fun {m n} h => (φ m n h : _ → _)) h hm x).symm + | refl a => exact ⟨rfl,fun _ => rfl⟩ + | symm a b hab ih => exact ⟨ih.1.symm,fun hb => (ih.2 (ih.1.symm ▸ hb)).symm⟩ + | trans a b c hab hbc ihab ihbc => + exact ⟨ihab.1.trans ihbc.1,fun ha => (ihab.2 ha).trans (ihbc.2 (ihab.1 ▸ ha))⟩ + exact (aux a b hrel).2 ha + +abbrev Trunc (N : ℕ) := {z : Space X φ // height X φ z < (N:ℝ)+1} + +def representative (z : Space X φ) : Raw X := (Quot.mk_surjective z).choose + +omit [∀ n, Nonempty (X n)] [DirectedSystem X (fun {m n} h => (φ m n h : _ → _))] in +@[simp] theorem representative_mk (z : Space X φ) : + Quot.mk (Glue X φ) (representative X φ z) = z := (Quot.mk_surjective z).choose_spec + +def retract (N : ℕ) : C(Trunc X φ N,X N) where + toFun z := rawCollapse X φ N (representative X φ z.1) + continuous_toFun := by + let s := {z : Space X φ | height X φ z < (N:ℝ)+1} + have hs : IsOpen s := isOpen_lt (height X φ).continuous continuous_const + have hq := (isQuotientMap_quot_mk (r:=Glue X φ)).restrictPreimage_isOpen hs + apply hq.continuous_iff.mpr + change Continuous (fun a : {a : Raw X // Quot.mk (Glue X φ) a ∈ s} => + rawCollapse X φ N (representative X φ (Quot.mk _ a.1))) + have hf : (fun a : {a : Raw X // Quot.mk (Glue X φ) a ∈ s} => + rawCollapse X φ N (representative X φ (Quot.mk _ a.1))) = + fun a => rawCollapse X φ N a.1 := by + funext a + apply collapse_compatible X φ + · exact representative_mk X φ _ + · change height X φ (Quot.mk _ (representative X φ (Quot.mk _ a.1))) < _ + rw [representative_mk] + exact a.2 + rw [hf] + exact (rawCollapse X φ N).continuous.comp continuous_subtype_val + +@[simp] theorem retract_quot (N : ℕ) (a : Raw X) + (ha : rawHeight X a < (N:ℝ)+1) : + retract X φ N ⟨Quot.mk _ a,ha⟩ = rawCollapse X φ N a := by + apply collapse_compatible X φ + · exact representative_mk X φ _ + · change height X φ (Quot.mk _ (representative X φ (Quot.mk _ a))) < _ + rw [representative_mk] + exact ha + +@[simp] theorem retract_stage (N n : ℕ) (h : n ≤ N) (x : X n) + (hx : height X φ (stage X φ n x) < (N:ℝ)+1) : + retract X φ N ⟨stage X φ n x,hx⟩ = φ n N h x := by + calc + retract X φ N ⟨stage X φ n x,hx⟩ = rawCollapse X φ N ⟨n,(x,bottomTime n)⟩ := + retract_quot X φ N ⟨n,(x,bottomTime n)⟩ hx + _ = φ n N h x := by simp only [rawCollapse,ContinuousMap.coe_mk,dite_eq_left h] + +end NearbyLagrangian.RayTelescope + +end + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.RayTelescope +open Set ContinuousMap +open scoped Topology +variable (X : ℕ → Type u) [∀ n, TopologicalSpace (X n)] +variable (φ : ∀ m n, m ≤ n → C(X m,X n)) + +def raiseTime (N : ℕ) (s : unitInterval) (t : ℝ) : ℝ := t + s * (max t N-t) + +lemma le_raiseTime (N : ℕ) (s : unitInterval) (t : ℝ) : t ≤ raiseTime N s t := by + unfold raiseTime + exact le_add_of_nonneg_right (mul_nonneg s.2.1 (sub_nonneg.mpr (le_max_left _ _))) + +@[simp] theorem raiseTime_zero (N : ℕ) (t : ℝ) : raiseTime N 0 t = t := by simp [raiseTime] +@[simp] theorem raiseTime_one (N : ℕ) (t : ℝ) : raiseTime N 1 t = max t N := by simp [raiseTime] + +def cylinderRaise (N n : ℕ) : C((X n × {t : ℝ // (n:ℝ) ≤ t}) × unitInterval,Space X φ) where + toFun z := Quot.mk _ ⟨n,(z.1.1,⟨raiseTime N z.2 z.1.2, + z.1.2.2.trans (le_raiseTime _ _ _)⟩)⟩ + continuous_toFun := by + have ht : Continuous (fun z : (X n × {t : ℝ // (n:ℝ) ≤ t}) × unitInterval => raiseTime N z.2 z.1.2) := by + unfold raiseTime + fun_prop + exact continuous_quot_mk.comp (continuous_sigmaMk.comp + (continuous_fst.fst.prodMk (ht.subtype_mk _))) + +def rawRaise (N : ℕ) : C(Raw X,C(unitInterval,Space X φ)) := + ⟨fun a => (cylinderRaise X φ N a.1).curry a.2, + continuous_sigma (fun _ => (cylinderRaise X φ N _).curry.continuous)⟩ + +def raiseFamily (N : ℕ) : C(Space X φ,C(unitInterval,Space X φ)) := + ⟨Quot.lift (rawRaise X φ N) (by + intro a b h + ext s + cases h with + | step n m h x t ht => + exact Quot.sound (Glue.step n m h x (raiseTime N s t) (ht.trans (le_raiseTime _ _ _)))), + continuous_quot_lift _ (rawRaise X φ N).continuous⟩ + +@[simp] theorem raiseFamily_apply (N : ℕ) (a : Raw X) (s : unitInterval) : + raiseFamily X φ N (Quot.mk _ a) s = Quot.mk _ + ⟨a.1,(a.2.1,⟨raiseTime N s a.2.2,a.2.2.2.trans (le_raiseTime _ _ _)⟩)⟩ := rfl + +def raised (N : ℕ) : C(Space X φ,Space X φ) := + ⟨fun z => raiseFamily X φ N z 1,(continuous_eval_const (1:unitInterval)).comp + (raiseFamily X φ N).continuous⟩ + +def raiseHomotopy (N : ℕ) : (ContinuousMap.id (Space X φ)).Homotopy (raised X φ N) where + toFun z := raiseFamily X φ N z.2 z.1 + continuous_toFun := (raiseFamily X φ N).uncurry.continuous.comp continuous_swap + map_zero_left z := by + induction z using Quot.inductionOn with + | h a => + change Quot.mk _ ⟨a.1,(a.2.1,⟨raiseTime N 0 a.2.2,_⟩)⟩ = Quot.mk _ a + exact congrArg (fun t : {t : ℝ // (a.1:ℝ) ≤ t} => Quot.mk (Glue X φ) ⟨a.1,(a.2.1,t)⟩) + (Subtype.ext (raiseTime_zero N a.2.2)) + map_one_left _ := rfl + +@[simp] theorem height_raised (N : ℕ) (z : Space X φ) : + height X φ (raised X φ N z) = max (height X φ z) N := by + induction z using Quot.inductionOn with + | h a => change raiseTime N 1 a.2.2 = max (a.2.2:ℝ) N; exact raiseTime_one _ _ + +variable [∀ n, Nonempty (X n)] +variable [DirectedSystem X (fun {m n} h => (φ m n h : _ → _))] + +theorem raised_eq_stage_retract (N : ℕ) (z : Space X φ) (hz : height X φ z ≤ N) : + raised X φ N z = stage X φ N + (retract X φ N ⟨z,lt_of_le_of_lt hz (by linarith)⟩) := by + induction z using Quot.inductionOn with + | h a => + have hn : a.1 ≤ N := stage_le_of_height_lt X a (lt_of_le_of_lt hz (by linarith)) + have hr : retract X φ N ⟨Quot.mk _ a,lt_of_le_of_lt hz (by linarith)⟩ = + rawCollapse X φ N a := retract_quot X φ N a _ + rw [hr] + change Quot.mk (Glue X φ) ⟨a.1,(a.2.1,⟨raiseTime N 1 a.2.2,_⟩)⟩ = + Quot.mk (Glue X φ) ⟨N,(rawCollapse X φ N a,⟨(N:ℝ),le_rfl⟩)⟩ + have hz' : (a.2.2:ℝ) ≤ N := hz + simp only [raiseTime_one,max_eq_right hz',rawCollapse,ContinuousMap.coe_mk,dite_eq_left hn] + exact Quot.sound (Glue.step a.1 N hn a.2.1 (N:ℝ) le_rfl) + +end NearbyLagrangian.RayTelescope + +end + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.RayTelescope +open Set ContinuousMap +open scoped Topology +variable (X : ℕ → Type u) [∀ n, TopologicalSpace (X n)] +variable (φ : ∀ m n, m ≤ n → C(X m,X n)) +variable {A : Type v} [TopologicalSpace A] + +theorem exists_height_bound [CompactSpace A] (f : C(A,Space X φ)) : + ∃ N : ℕ, ∀ a, height X φ (f a) ≤ N := by + obtain ⟨r,hr⟩ := (isCompact_range ((height X φ).continuous.comp f.continuous)).bddAbove + obtain ⟨N,hN⟩ := exists_nat_gt r + exact ⟨N,fun a => le_of_lt ((hr ⟨a,rfl⟩).trans_lt hN)⟩ + +variable [∀ n, Nonempty (X n)] +variable [DirectedSystem X (fun {m n} h => (φ m n h : _ → _))] + +def finiteMap (N : ℕ) (f : C(A,Space X φ)) (hf : ∀ a, height X φ (f a) < (N:ℝ)+1) : C(A,X N) := + (retract X φ N).comp ⟨fun a => ⟨f a,hf a⟩,f.continuous.subtype_mk _⟩ + +def finiteHomotopy (N : ℕ) (f : C(A,Space X φ)) (hf : ∀ a, height X φ (f a) ≤ N) : + f.Homotopy ((stage X φ N).comp + (finiteMap X φ N f (fun a => lt_of_le_of_lt (hf a) (by linarith)))) := + ((raiseHomotopy X φ N).compContinuousMap f).cast (by ext; rfl) (by + ext a + exact raised_eq_stage_retract X φ N (f a) (hf a)) + +theorem exists_finite_representative [CompactSpace A] (f : C(A,Space X φ)) : + ∃ N : ℕ, ∃ g : C(A,X N), f.Homotopic ((stage X φ N).comp g) := by + obtain ⟨N,hN⟩ := exists_height_bound X φ f + exact ⟨N,finiteMap X φ N f (fun a => lt_of_le_of_lt (hN a) (by linarith)), + ⟨finiteHomotopy X φ N f hN⟩⟩ + +@[simp] theorem finiteMap_stage (N m : ℕ) (h : m ≤ N) (f : C(A,X m)) + (hf : ∀ a, height X φ ((stage X φ m).comp f a) < (N:ℝ)+1) : + finiteMap X φ N ((stage X φ m).comp f) hf = (φ m N h).comp f := by + ext a + exact retract_stage X φ N m h (f a) (hf a) + +theorem stage_stabilize_homotopic (m N : ℕ) (h : m ≤ N) : + (stage X φ m).Homotopic ((stage X φ N).comp (φ m N h)) := by + have hh : ∀ x : X m, height X φ (stage X φ m x) ≤ N := by + intro x + change (m:ℝ) ≤ N + exact_mod_cast h + have H := finiteHomotopy X φ N (stage X φ m) hh + refine ⟨H.cast rfl ?_⟩ + apply congrArg ((stage X φ N).comp) + ext x + exact retract_stage X φ N m h x _ + +def finiteStageHomotopy {m n N : ℕ} (hm : m ≤ N) (hn : n ≤ N) + (f : C(A,X m)) (g : C(A,X n)) + (H : ((stage X φ m).comp f).Homotopy ((stage X φ n).comp g)) + (hH : ∀ z, height X φ (H z) < (N:ℝ)+1) : + ((φ m N hm).comp f).Homotopy ((φ n N hn).comp g) where + toFun z := retract X φ N ⟨H z,hH z⟩ + continuous_toFun := (retract X φ N).continuous.comp (H.continuous.subtype_mk _) + map_zero_left a := by + have ha : height X φ (stage X φ m (f a)) < (N:ℝ)+1 := by + have := hH (0,a) + simpa only [ContinuousMap.Homotopy.apply_zero,ContinuousMap.comp_apply] using this + calc + retract X φ N ⟨H (0,a),hH (0,a)⟩ = retract X φ N ⟨stage X φ m (f a),ha⟩ := + congrArg (retract X φ N) (Subtype.ext (H.map_zero_left a)) + _ = _ := retract_stage X φ N m hm (f a) ha + map_one_left a := by + have ha : height X φ (stage X φ n (g a)) < (N:ℝ)+1 := by + have := hH (1,a) + simpa only [ContinuousMap.Homotopy.apply_one,ContinuousMap.comp_apply] using this + calc + retract X φ N ⟨H (1,a),hH (1,a)⟩ = retract X φ N ⟨stage X φ n (g a),ha⟩ := + congrArg (retract X φ N) (Subtype.ext (H.map_one_left a)) + _ = _ := retract_stage X φ N n hn (g a) ha + +theorem stage_homotopic_iff [CompactSpace A] {m n : ℕ} (f : C(A,X m)) (g : C(A,X n)) : + ((stage X φ m).comp f).Homotopic ((stage X φ n).comp g) ↔ + ∃ (N : ℕ) (hm : m ≤ N) (hn : n ≤ N), ((φ m N hm).comp f).Homotopic ((φ n N hn).comp g) := by + constructor + · rintro ⟨H⟩ + obtain ⟨K,hK⟩ := exists_height_bound X φ H.toContinuousMap + let N := max K (max m n) + have hm : m ≤ N := (le_max_left m n).trans (le_max_right _ _) + have hn : n ≤ N := (le_max_right m n).trans (le_max_right _ _) + have hKN : (K:ℝ) ≤ N := by exact_mod_cast (le_max_left K (max m n)) + refine ⟨N,hm,hn,⟨finiteStageHomotopy X φ hm hn f g H ?_⟩⟩ + intro z + exact lt_of_le_of_lt ((hK z).trans hKN) (by linarith) + · rintro ⟨N,hm,hn,h⟩ + exact (((stage_stabilize_homotopic X φ m N hm).comp (ContinuousMap.Homotopic.refl f)).trans + ((ContinuousMap.Homotopic.refl (stage X φ N)).comp h)).trans + (((stage_stabilize_homotopic X φ n N hn).comp (ContinuousMap.Homotopic.refl g)).symm) + +theorem stage_nullhomotopic_iff [CompactSpace A] {m : ℕ} (f : C(A,X m)) : + ((stage X φ m).comp f).Nullhomotopic ↔ + ∃ (N : ℕ) (hm : m ≤ N), ((φ m N hm).comp f).Nullhomotopic := by + constructor + · rintro ⟨c,⟨H⟩⟩ + obtain ⟨K,hK⟩ := exists_height_bound X φ H.toContinuousMap + obtain ⟨J,hJ⟩ := exists_nat_gt (height X φ c) + let N := max K (max m J) + have hm : m ≤ N := (le_max_left m J).trans (le_max_right _ _) + have hKN : (K:ℝ) ≤ N := by exact_mod_cast (le_max_left K (max m J)) + have hJN : (J:ℝ) ≤ N := by exact_mod_cast ((le_max_right m J).trans (le_max_right K (max m J))) + have hc : height X φ c < (N:ℝ)+1 := lt_of_lt_of_le hJ (by linarith) + have hH : ∀ z, height X φ (H z) < (N:ℝ)+1 := + fun z => lt_of_le_of_lt ((hK z).trans hKN) (by linarith) + refine ⟨N,hm,retract X φ N ⟨c,hc⟩,⟨{ + toFun := fun z => retract X φ N ⟨H z,hH z⟩ + continuous_toFun := (retract X φ N).continuous.comp (H.continuous.subtype_mk _) + map_zero_left := ?_ + map_one_left := ?_ }⟩⟩ + · intro a + have ha : height X φ (stage X φ m (f a)) < (N:ℝ)+1 := by + simpa only [ContinuousMap.Homotopy.apply_zero,ContinuousMap.comp_apply] using hH (0,a) + calc + retract X φ N ⟨H (0,a),hH (0,a)⟩ = retract X φ N ⟨stage X φ m (f a),ha⟩ := + congrArg (retract X φ N) (Subtype.ext (H.map_zero_left a)) + _ = _ := retract_stage X φ N m hm (f a) ha + · intro a + exact congrArg (retract X φ N) (Subtype.ext (H.map_one_left a)) + · rintro ⟨N,hm,c,h⟩ + refine ⟨stage X φ N c,?_⟩ + exact ((stage_stabilize_homotopic X φ m N hm).comp (ContinuousMap.Homotopic.refl f)).trans + ((ContinuousMap.Homotopic.refl (stage X φ N)).comp h) + +end NearbyLagrangian.RayTelescope + +end + +noncomputable section +universe u v w + + +namespace NearbyLagrangian.RayTelescope +open ContinuousMap +variable (X : ℕ → Type u) [∀ n, TopologicalSpace (X n)] +variable (φ : ∀ m n, m ≤ n → C(X m,X n)) +variable [DirectedSystem X (fun {m n} h => (φ m n h : _ → _))] +variable [∀ n, PathConnectedSpace (X n)] + +theorem joined_base (b : X 0) (z : Space X φ) : Joined z (stage X φ 0 b) := by + obtain ⟨N,g,⟨H⟩⟩ := exists_finite_representative X φ (ContinuousMap.const Unit z) + have h₁ : Joined z (stage X φ N (g ())) := ⟨H.evalAt ()⟩ + have h₂ : Joined (stage X φ N (g ())) (stage X φ N (φ 0 N (Nat.zero_le N) b)) := + (PathConnectedSpace.joined _ _).map (stage X φ N).continuous + obtain ⟨K⟩ := stage_stabilize_homotopic X φ 0 N (Nat.zero_le N) + exact (h₁.trans h₂).trans (Joined.symm ⟨K.evalAt b⟩) + +instance pathConnected : PathConnectedSpace (Space X φ) where + nonempty := ⟨stage X φ 0 (Classical.choice inferInstance)⟩ + joined z w := (joined_base X φ (Classical.choice inferInstance) z).trans + (joined_base X φ (Classical.choice inferInstance) w).symm + +end NearbyLagrangian.RayTelescope + +end + +end OAI diff --git a/lean/OAI/Topology/TorusCompression/Boundary.lean b/lean/OAI/Topology/TorusCompression/Boundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..e1d7d0ba2532439a71480f577414a9fddfca6879 --- /dev/null +++ b/lean/OAI/Topology/TorusCompression/Boundary.lean @@ -0,0 +1,572 @@ +import Mathlib + +namespace OAI + +/-! Boundary restoration, bundle rank bounds and elementary torus compression. -/ + +noncomputable section + +namespace TorusCompression + +open Set Metric +open scoped Classical + +abbrev Slot (t : ℕ) := Fin t → ℝ +abbrev Slots (t n : ℕ) := Fin n → Slot t + +def cubeSet (t n : ℕ) : Set (Slots t n) := {x | ∀ j, ‖x j‖ ≤ 1} +abbrev Cube (t n : ℕ) := {x : Slots t n // x ∈ cubeSet t n} + +def OnBoundary {t : ℕ} (v : Slot t) : Prop := ‖v‖ = 1 + +lemma slot_unit_ball (t : ℕ) : + {v : Slot t | ∀ i, v i ∈ Icc (-1 : ℝ) 1} = closedBall 0 1 := by + ext v + simp only [mem_ofPred_eq, mem_Icc, mem_closedBall, dist_zero_right] + rw [pi_norm_le_iff_of_nonneg (by norm_num : (0 : ℝ) ≤ 1)] + simp only [Real.norm_eq_abs, abs_le] + +lemma onBoundary_iff_frontier {t : ℕ} (v : Slot t) : + OnBoundary v ↔ v ∈ frontier {w : Slot t | ∀ i, w i ∈ Icc (-1 : ℝ) 1} := by + rw [slot_unit_ball, frontier_closedBall _ (by norm_num : (1 : ℝ) ≠ 0)] + simp [OnBoundary] + +def support {t n : ℕ} (x : Slots t n) : Finset (Fin n) := + Finset.univ.filter (fun j => x j ≠ 0) + +def Sparse {t n : ℕ} (s : ℕ) : Set (Slots t n) := {x | (support x).card ≤ s} + +def sparseParameters (t n : ℕ) (s : ℝ) : Set (Slots t n) := + {z | (∀ j, ‖z j‖ ≤ 2) ∧ ((support z).card : ℝ) ≤ s} + +def boundarySlots {t n : ℕ} (x : Slots t n) : Finset (Fin n) := + Finset.univ.filter (fun j => OnBoundary (x j)) + +@[simp] lemma mem_support {t n : ℕ} (x : Slots t n) (j : Fin n) : + j ∈ support x ↔ x j ≠ 0 := by simp [support] + +@[simp] lemma mem_boundarySlots {t n : ℕ} (x : Slots t n) (j : Fin n) : + j ∈ boundarySlots x ↔ OnBoundary (x j) := by simp [boundarySlots] + +@[simp] lemma support_zero (t n : ℕ) : support (0 : Slots t n) = ∅ := by + ext j + simp + +lemma sparse_nonempty (t n s : ℕ) : (Sparse (t := t) (n := n) s).Nonempty := by + exact ⟨0, by simp [Sparse]⟩ + +lemma sparse_eq_union (t n s : ℕ) : + Sparse (t := t) (n := n) s = + ⋃ A : {A : Finset (Fin n) // A.card ≤ s}, + {x : Slots t n | ∀ j, j ∉ A.val → x j = 0} := by + ext x + constructor + · intro hx + refine mem_iUnion.mpr ⟨⟨support x, hx⟩, ?_⟩ + intro j hj + simpa using hj + · intro hx + obtain ⟨A, hA⟩ := mem_iUnion.mp hx + exact (Finset.card_le_card (show support x ⊆ A.val from by + intro j hj + by_contra hjA + exact (mem_support x j).mp hj (hA j hjA))).trans A.property + +lemma isClosed_sparse (t n s : ℕ) : IsClosed (Sparse (t := t) (n := n) s) := by + rw [sparse_eq_union] + apply isClosed_iUnion_of_finite + intro A + simp only [ofPred_forall] + exact isClosed_iInter fun j => isClosed_iInter fun _ => + isClosed_eq (continuous_apply j) + (continuous_const : Continuous (fun _ : Slots t n => (0 : Slot t))) + +lemma sparseParameters_eq_empty {t n : ℕ} {s : ℝ} (hs : s < 0) : + sparseParameters t n s = ∅ := by + apply Set.eq_empty_iff_forall_notMem.mpr + intro x hx + have hcard : (0 : ℝ) ≤ (support x).card := Nat.cast_nonneg _ + exact (not_le_of_gt hs) (hcard.trans hx.2) + +lemma sparseParameters_eq_inter {t n : ℕ} {s : ℝ} (hs : 0 ≤ s) : + sparseParameters t n s = closedBall (0 : Slots t n) 2 ∩ Sparse ⌊s⌋₊ := by + ext x + simp only [sparseParameters, Sparse, mem_ofPred_eq, mem_inter_iff, + mem_closedBall, dist_zero_right] + rw [pi_norm_le_iff_of_nonneg (by norm_num : (0 : ℝ) ≤ 2)] + exact and_congr Iff.rfl (Nat.le_floor_iff hs).symm + +lemma isCompact_sparseParameters (t n : ℕ) (s : ℝ) : + IsCompact (sparseParameters t n s) := by + by_cases hs : 0 ≤ s + · rw [sparseParameters_eq_inter hs] + exact (isCompact_closedBall (0 : Slots t n) 2).inter_right (isClosed_sparse t n ⌊s⌋₊) + · rw [sparseParameters_eq_empty (lt_of_not_ge hs)] + exact isCompact_empty + +lemma sparseParameters_eq_parameterCube {t n : ℕ} {s : ℝ} (hs : (n : ℝ) ≤ s) : + sparseParameters t n s = {z : Slots t n | ∀ j, ‖z j‖ ≤ 2} := by + ext z + refine ⟨fun hz => hz.1, fun hz => ⟨hz, ?_⟩⟩ + have hcard : (support z).card ≤ n := by + exact (Finset.card_le_card (Finset.filter_subset _ _)).trans_eq (Finset.card_fin n) + exact (Nat.cast_le.mpr hcard).trans hs + +def restorationRadius {t n : ℕ} (s : ℕ) (x : Slots t n) : ℝ := + min (1 / 2) (infDist x (Sparse s) / 2) + +lemma continuous_restorationRadius (t n s : ℕ) : + Continuous (restorationRadius (t := t) (n := n) s) := by + unfold restorationRadius + exact continuous_const.min ((continuous_infDist_pt (Sparse s)).div_const 2) + +lemma restorationRadius_pos {t n s : ℕ} {x : Slots t n} (hx : x ∉ Sparse s) : + 0 < restorationRadius s x := by + have h := (isClosed_sparse t n s).notMem_iff_infDist_pos (sparse_nonempty t n s) |>.mp hx + exact lt_min (by norm_num) (by positivity) + +lemma restorationRadius_le_half {t n s : ℕ} (x : Slots t n) : + restorationRadius s x ≤ 1 / 2 := min_le_left _ _ + +lemma restorationRadius_lt_infDist {t n s : ℕ} {x : Slots t n} + (hx : x ∉ Sparse s) : restorationRadius s x < infDist x (Sparse s) := by + have h := (isClosed_sparse t n s).notMem_iff_infDist_pos (sparse_nonempty t n s) |>.mp hx + exact (min_le_right _ _).trans_lt (by linarith) + +lemma many_large_slots {t n s : ℕ} {x : Slots t n} (hx : x ∉ Sparse s) : + s < (Finset.univ.filter (fun j => restorationRadius s x ≤ ‖x j‖)).card := by + let δ := restorationRadius s x + have hδ : 0 < δ := restorationRadius_pos hx + let A : Finset (Fin n) := Finset.univ.filter (fun j => δ ≤ ‖x j‖) + let y : Slots t n := fun j => if j ∈ A then x j else 0 + by_contra h + have hA : A.card ≤ s := Nat.le_of_not_lt h + have hy : y ∈ Sparse s := by + apply le_trans (Finset.card_le_card (show support y ⊆ A from ?_)) hA + intro j hj + by_contra hjA + have hnonzero := (mem_support y j).mp hj + exact hnonzero (by simp [y, hjA]) + have hdist : dist x y ≤ δ := by + rw [dist_eq_norm, pi_norm_le_iff_of_nonneg hδ.le] + intro j + by_cases hj : j ∈ A + · simp [y, hj, hδ.le] + · have hj' : ‖x j‖ < δ := by simpa [A] using hj + simpa [y, hj] using hj'.le + have hlt := restorationRadius_lt_infDist hx + exact not_lt_of_ge ((infDist_le_dist_of_mem hy).trans hdist) hlt + +def radial {t : ℕ} (δ : ℝ) (v : Slot t) : Slot t := + (max δ ‖v‖)⁻¹ • v + +lemma norm_radial_le_one {t : ℕ} {δ : ℝ} (hδ : 0 < δ) (v : Slot t) : + ‖radial δ v‖ ≤ 1 := by + have hden : 0 < max δ ‖v‖ := hδ.trans_le (le_max_left _ _) + rw [radial, norm_smul, Real.norm_eq_abs, abs_inv, + abs_of_pos hden, ← div_eq_inv_mul] + exact (div_le_one hden).mpr (le_max_right _ _) + +lemma radial_boundary {t : ℕ} {δ : ℝ} (hδ : 0 < δ) {v : Slot t} + (hv : δ ≤ ‖v‖) : OnBoundary (radial δ v) := by + have hn : 0 < ‖v‖ := hδ.trans_le hv + simp [OnBoundary, radial, max_eq_right hv, norm_smul, inv_mul_cancel₀ hn.ne'] + +lemma radial_fixes_boundary {t : ℕ} {δ : ℝ} (hδ : δ ≤ 1) {v : Slot t} + (hv : OnBoundary v) : radial δ v = v := by + simp [radial, show ‖v‖ = 1 from hv, max_eq_right hδ] + +def cutoff {t : ℕ} (v : Slot t) : ℝ := max 0 (4 * ‖v‖ - 3) + +def blend {t : ℕ} (v w : Slot t) : Slot t := + (1 - cutoff v) • w + cutoff v • v + +lemma cutoff_range {t : ℕ} {v : Slot t} (hv : ‖v‖ ≤ 1) : + 0 ≤ cutoff v ∧ cutoff v ≤ 1 := by + refine ⟨le_max_left _ _, max_le (by norm_num) ?_⟩ + linarith + +lemma blend_sub {t : ℕ} (v w : Slot t) : + blend v w - v = (1 - cutoff v) • (w - v) := by + simp only [blend, smul_sub, sub_smul, one_smul] + abel + +lemma norm_blend_sub_le {t : ℕ} {v w : Slot t} (hv : ‖v‖ ≤ 1) : + ‖blend v w - v‖ ≤ ‖w - v‖ := by + obtain ⟨h0, h1⟩ := cutoff_range hv + rw [blend_sub, norm_smul, Real.norm_eq_abs, abs_of_nonneg (sub_nonneg.mpr h1)] + exact mul_le_of_le_one_left (norm_nonneg _) (by linarith) + +lemma blend_nonzero {t : ℕ} {v w : Slot t} (hv : ‖v‖ ≤ 1) + (hvw : ‖w - v‖ < 1 / 2) (hw : w ≠ 0) : blend v w ≠ 0 := by + by_cases hχ : cutoff v = 0 + · simpa [blend, hχ] using hw + · have hχpos : 0 < cutoff v := lt_of_le_of_ne (cutoff_range hv).1 (Ne.symm hχ) + have hnorm : 3 / 4 < ‖v‖ := by + have h := (lt_max_iff.mp hχpos).resolve_left (lt_irrefl 0) + linarith + intro hzero + have h := (norm_blend_sub_le hv).trans_lt hvw + rw [hzero, zero_sub, norm_neg] at h + linarith + +lemma blend_fixes_boundary {t : ℕ} {v w : Slot t} (hv : OnBoundary v) : + blend v w = v := by + have hχ : cutoff v = 1 := by simp [cutoff, show ‖v‖ = 1 from hv]; norm_num + simp [blend, hχ] + +lemma continuous_blend {t : ℕ} : Continuous (fun p : Slot t × Slot t => blend p.1 p.2) := by + unfold blend cutoff + fun_prop + +lemma continuous_blend_of {X : Type*} [TopologicalSpace X] {t : ℕ} + {v w : X → Slot t} (hv : Continuous v) (hw : Continuous w) : + Continuous (fun x => blend (v x) (w x)) := by + have hc : Continuous (fun x => cutoff (v x)) := + continuous_const.max ((continuous_const.mul hv.norm).sub continuous_const) + exact ((continuous_const.sub hc).smul hw).add (hc.smul hv) + +theorem boundary_restoration {X : Type*} [TopologicalSpace X] + {t n s : ℕ} (f : X → Cube t n) (g : X → Slots t n) + (hf : Continuous f) (hg : Continuous g) + (havoid : ∀ x, g x ∉ Sparse s) + (hclose : ∀ x, ‖g x - (f x).val‖ < 1 / 2) : + ∃ G : X → Cube t n, Continuous G ∧ + (∀ x, s + 1 ≤ (boundarySlots (G x).val).card) ∧ + (∀ x j, OnBoundary ((f x).val j) → (G x).val j = (f x).val j) := by + let g' : X → Slots t n := fun x j => blend ((f x).val j) (g x j) + have hfj : ∀ j, Continuous (fun x => (f x).val j) := fun j => + (continuous_apply j).comp hf.subtype_val + have hgj : ∀ j, Continuous (fun x => g x j) := fun j => + (continuous_apply j).comp hg + have hg' : Continuous g' := by + apply continuous_pi + intro j + exact continuous_blend_of (hfj j) (hgj j) + have havoid' : ∀ x, g' x ∉ Sparse s := by + intro x hx + apply havoid x + apply le_trans (Finset.card_le_card (show support (g x) ⊆ support (g' x) from ?_)) hx + intro j hj + apply (mem_support _ _).mpr + apply blend_nonzero ((f x).property j) _ ((mem_support _ _).mp hj) + exact (norm_le_pi_norm (g x - (f x).val) j).trans_lt (hclose x) + let G : X → Cube t n := fun x => + ⟨fun j => radial (restorationRadius s (g' x)) (g' x j), + fun j => norm_radial_le_one (restorationRadius_pos (havoid' x)) (g' x j)⟩ + refine ⟨G, ?_, ?_, ?_⟩ + · apply Continuous.subtype_mk + apply continuous_pi + intro j + have hden : ∀ x, max (restorationRadius s (g' x)) ‖g' x j‖ ≠ 0 := by + intro x + exact ne_of_gt ((restorationRadius_pos (havoid' x)).trans_le (le_max_left _ _)) + exact (((continuous_restorationRadius t n s).comp hg').max + (((continuous_apply j).comp hg').norm)).inv₀ hden |>.smul + ((continuous_apply j).comp hg') + · intro x + apply (Nat.succ_le_of_lt (many_large_slots (havoid' x))).trans + apply Finset.card_le_card + intro j hj + exact (mem_boundarySlots _ _).mpr + (radial_boundary (restorationRadius_pos (havoid' x)) ((Finset.mem_filter.mp hj).2)) + · intro x j hj + change radial (restorationRadius s (g' x)) (blend ((f x).val j) (g x j)) = _ + rw [blend_fixes_boundary hj] + exact radial_fixes_boundary ((restorationRadius_le_half (g' x)).trans (by norm_num)) hj + +theorem boundary_restoration_of_sparseParameters {X : Type*} [TopologicalSpace X] + {t n s : ℕ} (f : X → Cube t n) (g : X → Slots t n) + (hf : Continuous f) (hg : Continuous g) + (havoid : ∀ x, g x ∉ sparseParameters t n (s : ℝ)) + (hclose : ∀ x, ‖g x - (f x).val‖ < 1 / 2) : + ∃ G : X → Cube t n, Continuous G ∧ + (∀ x, s + 1 ≤ (boundarySlots (G x).val).card) ∧ + (∀ x j, OnBoundary ((f x).val j) → (G x).val j = (f x).val j) := by + apply boundary_restoration f g hf hg ?_ hclose + intro x hx + apply havoid x + refine ⟨?_, ?_⟩ + · intro j + have hj := (norm_le_pi_norm (g x - (f x).val) j).trans_lt (hclose x) + have hfbound := (f x).property j + have hadd := norm_le_norm_sub_add (g x j) ((f x).val j) + dsimp only [Pi.sub_apply] at hj + linarith + · exact_mod_cast hx + +def torusLocus {Y : Type*} {t n : ℕ} (f : Y → Cube t n) + (L : Set (Slot t)) (Z : Set (Slots t n)) : Set (Y × Z) := + {q | ∀ j, (f q.1).val j - q.2.val j ∈ L} + +abbrev TorusLocus {Y : Type*} {t n : ℕ} (f : Y → Cube t n) + (L : Set (Slot t)) (Z : Set (Slots t n)) := ↥(torusLocus f L Z) + +def locusDifference {Y : Type*} {t n : ℕ} {f : Y → Cube t n} + {L : Set (Slot t)} {Z : Set (Slots t n)} (q : TorusLocus f L Z) : Fin n → L := + fun j => ⟨(f q.val.1).val j - q.val.2.val j, q.property j⟩ + +lemma isClosed_torusLocus {Y : Type*} [TopologicalSpace Y] {t n : ℕ} + {f : Y → Cube t n} {L : Set (Slot t)} {Z : Set (Slots t n)} + (hf : Continuous f) (hL : IsClosed L) : IsClosed (torusLocus f L Z) := by + unfold torusLocus + simp only [ofPred_forall] + apply isClosed_iInter + intro j + apply hL.preimage + have hc₁ : Continuous (fun q : Y × Z => (f q.1).val j) := + (continuous_apply j).comp (hf.subtype_val.comp continuous_fst) + have hc₂ : Continuous (fun q : Y × Z => q.2.val j) := + (continuous_apply j).comp (continuous_subtype_val.comp continuous_snd) + exact hc₁.sub hc₂ + +lemma isCompact_sparse_torusLocus {Y : Type*} [TopologicalSpace Y] [CompactSpace Y] + {t n : ℕ} {f : Y → Cube t n} {L : Set (Slot t)} + (hf : Continuous f) (hL : IsClosed L) (s : ℝ) : + IsCompact (torusLocus f L (sparseParameters t n s)) := by + let : CompactSpace (sparseParameters t n s) := + isCompact_iff_compactSpace.mp (isCompact_sparseParameters t n s) + exact (isClosed_torusLocus hf hL).isCompact + +lemma continuous_locusDifference {Y : Type*} [TopologicalSpace Y] {t n : ℕ} + {f : Y → Cube t n} {L : Set (Slot t)} {Z : Set (Slots t n)} + (hf : Continuous f) : Continuous (locusDifference (f := f) (L := L) (Z := Z)) := by + apply continuous_pi + intro j + apply Continuous.subtype_mk + have hc₁ : Continuous (fun q : TorusLocus f L Z => (f q.val.1).val j) := + (continuous_apply j).comp + (hf.subtype_val.comp (continuous_fst.comp continuous_subtype_val)) + have hc₂ : Continuous (fun q : TorusLocus f L Z => q.val.2.val j) := + (continuous_apply j).comp (continuous_subtype_val.comp + (continuous_snd.comp continuous_subtype_val)) + exact hc₁.sub hc₂ + +def slotBundleFiber {Y : Type*} {t n r : ℕ} {f : Y → Cube t n} + {L : Set (Slot t)} {Z : Set (Slots t n)} + (H : L → Submodule ℂ (Fin r → ℂ)) (q : TorusLocus f L Z) : + Submodule ℂ (Fin n → Fin r → ℂ) := + Submodule.pi univ (fun j => H (locusDifference q j)) + +@[simp] lemma mem_slotBundleFiber {Y : Type*} {t n r : ℕ} {f : Y → Cube t n} + {L : Set (Slot t)} {Z : Set (Slots t n)} (H : L → Submodule ℂ (Fin r → ℂ)) + (q : TorusLocus f L Z) (v : Fin n → Fin r → ℂ) : + v ∈ slotBundleFiber H q ↔ ∀ j, v j ∈ H (locusDifference q j) := by + simp [slotBundleFiber, Submodule.mem_pi] + +def EmbeddedTotal {B V : Type*} [AddCommGroup V] [Module ℂ V] + (E : B → Submodule ℂ V) := {q : B × V // q.2 ∈ E q.1} + +instance {B V : Type*} [TopologicalSpace B] [TopologicalSpace V] + [AddCommGroup V] [Module ℂ V] (E : B → Submodule ℂ V) : + TopologicalSpace (EmbeddedTotal E) := inferInstanceAs (TopologicalSpace {q : B × V // q.2 ∈ E q.1}) + +structure BundleMono {B V : Type*} [TopologicalSpace B] [TopologicalSpace V] + [AddCommGroup V] [Module ℂ V] (E : B → Submodule ℂ V) (K : ℕ) where + map : ∀ b, E b →ₗ[ℂ] (Fin K → ℂ) + injective : ∀ b, Function.Injective (map b) + continuous_total : Continuous (fun q : EmbeddedTotal E => map q.val.1 ⟨q.val.2, q.property⟩) + +def slotBundleFiberEquiv {Y : Type*} {t n r : ℕ} {f : Y → Cube t n} + {L : Set (Slot t)} {Z : Set (Slots t n)} + (H : L → Submodule ℂ (Fin r → ℂ)) (q : TorusLocus f L Z) : + slotBundleFiber H q ≃ₗ[ℂ] ((j : Fin n) → H (locusDifference q j)) where + toFun v j := ⟨v.val j, (mem_slotBundleFiber H q v.val).mp v.property j⟩ + invFun v := ⟨fun j => (v j).val, + (mem_slotBundleFiber H q _).mpr (fun j => (v j).property)⟩ + left_inv _ := rfl + right_inv _ := rfl + map_add' _ _ := rfl + map_smul' _ _ := rfl + +lemma finrank_slotBundleFiber {Y : Type*} {t n r p : ℕ} {f : Y → Cube t n} + {L : Set (Slot t)} {Z : Set (Slots t n)} + (H : L → Submodule ℂ (Fin r → ℂ)) (hH : ∀ l, Module.finrank ℂ (H l) = p) + (q : TorusLocus f L Z) : Module.finrank ℂ (slotBundleFiber H q) = p * n := by + rw [(slotBundleFiberEquiv H q).finrank_eq, Module.finrank_pi_fintype] + simp [hH, Nat.mul_comm] + +lemma BundleMono.finrank_le {B V : Type*} [TopologicalSpace B] [TopologicalSpace V] + [AddCommGroup V] [Module ℂ V] {E : B → Submodule ℂ V} {K : ℕ} + (M : BundleMono E K) (b : B) : Module.finrank ℂ (E b) ≤ K := by + have h := LinearMap.finrank_le_finrank_of_injective (M.injective b) + simpa using h + +theorem rank_le_target_of_nonempty_locus {Y : Type*} [TopologicalSpace Y] + {t n r p K : ℕ} {f : Y → Cube t n} + {L : Set (Slot t)} {Z : Set (Slots t n)} + (H : L → Submodule ℂ (Fin r → ℂ)) (hH : ∀ l, Module.finrank ℂ (H l) = p) + (M : BundleMono (slotBundleFiber H (f := f) (Z := Z)) K) + (hq : (torusLocus f L Z).Nonempty) : p * n ≤ K := by + obtain ⟨q, hq⟩ := hq + simpa [finrank_slotBundleFiber H hH] using M.finrank_le (⟨q, hq⟩ : TorusLocus f L Z) + +def slotIndex {u n : ℕ} (b : Fin u) (j : Fin n) : Fin (u * n) := + finProdFinEquiv (b, j) + +@[simp] lemma slotIndex_val {u n : ℕ} (b : Fin u) (j : Fin n) : + (slotIndex b j).val = b.val * n + j.val := by + simp [slotIndex, finProdFinEquiv, Nat.mul_comm, Nat.add_comm] + +def powerMap {X Y : Type*} (q : X → Y) (u : ℕ) (x : Fin u → X) : Fin u → Y := + fun b => q (x b) + +lemma continuous_powerMap {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] + {q : X → Y} (hq : Continuous q) (u : ℕ) : Continuous (powerMap q u) := by + exact continuous_pi fun b => hq.comp (continuous_apply b) + +def concatenate {X : Type*} {t n : ℕ} (f : X → Cube t n) (u : ℕ) + (x : Fin u → X) : Cube t (u * n) := + ⟨fun k => (f (x (finProdFinEquiv.symm k).1)).val (finProdFinEquiv.symm k).2, + fun k => (f (x (finProdFinEquiv.symm k).1)).property (finProdFinEquiv.symm k).2⟩ + +@[simp] lemma concatenate_slot {X : Type*} {t n : ℕ} (f : X → Cube t n) + (u : ℕ) (x : Fin u → X) (b : Fin u) (j : Fin n) : + (concatenate f u x).val (slotIndex b j) = (f (x b)).val j := by + simp only [concatenate, slotIndex, Equiv.symm_apply_apply] + +lemma boundarySlots_concatenate_sum {X : Type*} {t n : ℕ} + (f : X → Cube t n) (u : ℕ) (x : Fin u → X) : + (boundarySlots (concatenate f u x).val).card = + ∑ b : Fin u, (boundarySlots (f (x b)).val).card := by + simp only [boundarySlots, Finset.card_filter] + rw [← Equiv.sum_comp finProdFinEquiv, Fintype.sum_prod_type] + apply Finset.sum_congr rfl + intro b _ + apply Finset.sum_congr rfl + intro j _ + rw [show finProdFinEquiv (b, j) = slotIndex b j from rfl, concatenate_slot] + +lemma continuous_concatenate {X : Type*} [TopologicalSpace X] {t n : ℕ} + {f : X → Cube t n} (hf : Continuous f) (u : ℕ) : Continuous (concatenate f u) := by + apply Continuous.subtype_mk + apply continuous_pi + intro k + exact (continuous_apply (finProdFinEquiv.symm k).2).comp + (hf.subtype_val.comp (continuous_apply (finProdFinEquiv.symm k).1)) + +def IsCompression {X : Type*} [TopologicalSpace X] {t n : ℕ} + (f : X → Cube t n) (a : ℝ) (u : ℕ) (G : (Fin u → X) → Cube t (u * n)) : Prop := + Continuous G ∧ + (∀ x, (a / 8) * (u : ℝ) * (n : ℝ) ≤ ((boundarySlots (G x).val).card : ℝ)) ∧ + (∀ x b j, OnBoundary ((f (x b)).val j) → + (G x).val (slotIndex b j) = (f (x b)).val j) + +def ArbitrarilyCompresses {X : Type*} [TopologicalSpace X] {t n : ℕ} + (f : X → Cube t n) (a : ℝ) : Prop := + ∀ U : ℕ, 1 ≤ U → ∃ u : ℕ, U ≤ u ∧ + ∃ G : (Fin u → X) → Cube t (u * n), IsCompression f a u G + +theorem compression_pullback {X P : Type*} [TopologicalSpace X] [TopologicalSpace P] + {t n u : ℕ} {a : ℝ} {f : X → Cube t n} {fP : P → Cube t n} + (q : X → P) (hq : Continuous q) (hfactor : f = fP ∘ q) + {G : (Fin u → P) → Cube t (u * n)} (hG : IsCompression fP a u G) : + IsCompression f a u (G ∘ powerMap q u) := by + refine ⟨hG.1.comp (continuous_powerMap hq u), ?_, ?_⟩ + · intro x + exact hG.2.1 (powerMap q u x) + · intro x b j hx + rw [hfactor] at hx ⊢ + exact hG.2.2 (powerMap q u x) b j hx + +theorem arbitrarily_compresses_pullback {X P : Type*} + [TopologicalSpace X] [TopologicalSpace P] + {t n : ℕ} {a : ℝ} {f : X → Cube t n} {fP : P → Cube t n} + (q : X → P) (hq : Continuous q) (hfactor : f = fP ∘ q) + (hP : ArbitrarilyCompresses fP a) : ArbitrarilyCompresses f a := by + intro U hU + obtain ⟨u, hUu, G, hG⟩ := hP U hU + exact ⟨u, hUu, G ∘ powerMap q u, compression_pullback q hq hfactor hG⟩ + +theorem arbitrarily_compresses_of_isEmpty {X : Type*} [TopologicalSpace X] [IsEmpty X] + {t n : ℕ} (f : X → Cube t n) (a : ℝ) : ArbitrarilyCompresses f a := by + intro U hU + let G : (Fin U → X) → Cube t (U * n) := fun _ => ⟨0, by simp [cubeSet]⟩ + refine ⟨U, le_rfl, G, continuous_const, ?_, ?_⟩ + · intro x + exact isEmptyElim (x ⟨0, by omega⟩) + · intro x + exact isEmptyElim (x ⟨0, by omega⟩) + +lemma repeated_compression {X : Type*} [TopologicalSpace X] {t n : ℕ} + {f F : X → Cube t n} {a : ℝ} (hF : Continuous F) + (hcount : ∀ x, (a / 8) * (n : ℝ) ≤ ((boundarySlots (F x).val).card : ℝ)) + (hfix : ∀ x j, OnBoundary ((f x).val j) → (F x).val j = (f x).val j) + (u : ℕ) : IsCompression f a u (concatenate F u) := by + refine ⟨continuous_concatenate hF u, ?_, ?_⟩ + · intro x + rw [boundarySlots_concatenate_sum, Nat.cast_sum] + calc + a / 8 * (u : ℝ) * (n : ℝ) = ∑ _b : Fin u, (a / 8) * (n : ℝ) := by + simp [Finset.sum_const, mul_comm, mul_left_comm] + _ ≤ ∑ b : Fin u, ((boundarySlots (F (x b)).val).card : ℝ) := + Finset.sum_le_sum (fun b _ => hcount (x b)) + · intro x b j hj + rw [concatenate_slot] + exact hfix (x b) j hj + +theorem arbitrarily_compresses_of_empty_locus {X : Type*} [TopologicalSpace X] + {t n : ℕ} {f : X → Cube t n} {L : Set (Slot t)} {a : ℝ} + (hf : Continuous f) (ha : 0 ≤ a) (l : Slot t) (hlL : l ∈ L) (hl : ‖l‖ < 1 / 2) + (hempty : torusLocus f L (sparseParameters t n (a * (n : ℝ))) = ∅) : + ArbitrarilyCompresses f a := by + let s := ⌊a * (n : ℝ)⌋₊ + let g : X → Slots t n := fun x j => (f x).val j - l + have hg : Continuous g := hf.subtype_val.sub continuous_const + have hclose : ∀ x, ‖g x - (f x).val‖ < 1 / 2 := by + intro x + have heq : g x - (f x).val = fun _ : Fin n => -l := by + funext j + dsimp [g] + abel + rw [heq] + have hbound : ‖(fun _ : Fin n => -l)‖ ≤ ‖l‖ := by + rw [pi_norm_le_iff_of_nonneg (norm_nonneg l)] + intro j + simp + exact hbound.trans_lt hl + have havoid : ∀ x, g x ∉ sparseParameters t n (s : ℝ) := by + intro x hx + have hz : g x ∈ sparseParameters t n (a * (n : ℝ)) := + ⟨hx.1, hx.2.trans (Nat.floor_le (mul_nonneg ha (Nat.cast_nonneg n)))⟩ + have hq : (x, ⟨g x, hz⟩) ∈ torusLocus f L (sparseParameters t n (a * (n : ℝ))) := by + intro j + change (f x).val j - ((f x).val j - l) ∈ L + simpa only [sub_sub_cancel] using hlL + rw [hempty] at hq + exact hq + obtain ⟨F, hF, hcount, hfix⟩ := + boundary_restoration_of_sparseParameters f g hf hg havoid hclose + have hreal : (a / 8) * (n : ℝ) ≤ ((s + 1 : ℕ) : ℝ) := by + have h0 : 0 ≤ a * (n : ℝ) := mul_nonneg ha (Nat.cast_nonneg n) + have hfloor := Nat.lt_floor_add_one (a * (n : ℝ)) + dsimp [s] + push_cast + linarith + intro U _hU + refine ⟨U, le_rfl, concatenate F U, repeated_compression hF ?_ hfix U⟩ + intro x + exact hreal.trans (Nat.cast_le.mpr (hcount x)) + +lemma floor_batch_lower_bound {a : ℝ} {b : ℕ} (hab : 16 ≤ a * (b : ℝ)) : + 3 * a * (b : ℝ) / 16 ≤ (⌊a * (b : ℝ) / 4⌋₊ : ℝ) := by + have hfloor := Nat.lt_floor_add_one (a * (b : ℝ) / 4) + linarith + +theorem padding_boundary_fraction {a : ℝ} {b B j : ℕ} + (ha : 0 ≤ a) (hab : 16 ≤ a * (b : ℝ)) (hj : 2 * B ≤ j) : + (a / 8) * ((b * (B + j) : ℕ) : ℝ) ≤ + ((j * ⌊a * (b : ℝ) / 4⌋₊ : ℕ) : ℝ) := by + have hfloor := floor_batch_lower_bound hab + have hBj : 2 * (B : ℝ) ≤ (j : ℝ) := by exact_mod_cast hj + have hcount := mul_le_mul_of_nonneg_left hfloor (Nat.cast_nonneg j : 0 ≤ (j : ℝ)) + have hscale := mul_le_mul_of_nonneg_left hBj + (mul_nonneg ha (Nat.cast_nonneg b : 0 ≤ (b : ℝ))) + push_cast + nlinarith + +end TorusCompression + +end + +end OAI diff --git a/lean/patches/AINTLIB-lean4341.patch b/lean/patches/AINTLIB-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..7d46fae7b8176d798990be61c7bd0c9c3c31fe0e --- /dev/null +++ b/lean/patches/AINTLIB-lean4341.patch @@ -0,0 +1,23288 @@ +diff --git a/lakefile.toml b/lakefile.toml +index 2bca04769..e4a5c654b 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -12,7 +12,7 @@ pp.unicode.fun = true # universal across all origin projects + [[require]] + name = "mathlib" + git = "https://github.com/leanprover-community/mathlib4.git" +-rev = "e4b72ca0d01c" # daily steady-state bump 2026-08-25, toolchain v4.34.0-rc2 ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" # Zauner compatibility: Lean/Mathlib v4.34.1 + + # ───────────────────────── shared, refactored-out lemmas ───────────────────────── + [[lean_lib]] +@@ -85,7 +85,6 @@ globs = ["CebotarevDensity"] + [lean_lib.leanOptions] + autoImplicit = false + relaxedAutoImplicit = false +-maxSynthPendingDepth = 3 + + # ───────── Belabas–Friedman: effective residue of the Dedekind zeta function ───────── + # Imports mathlib (and CebotarevDensity for the ζ_K Euler product); built on demand. +diff --git a/lean-toolchain b/lean-toolchain +index b814d987e..ba8ebf2db 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.34.0-rc2 ++leanprover/lean4:v4.34.1 +diff --git a/projects/Chebotarev/CebotarevDensity/Abelian.lean b/projects/Chebotarev/CebotarevDensity/Abelian.lean +index ceca8bdf6..497e8ecc3 100644 +--- a/projects/Chebotarev/CebotarevDensity/Abelian.lean ++++ b/projects/Chebotarev/CebotarevDensity/Abelian.lean +@@ -233,13 +233,13 @@ private theorem prime_dvd_natAbs_discr_cyclotomic_dvd + (E : Type*) [Field E] [NumberField E] (m : ℕ) [NeZero m] [IsCyclotomicExtension {m} ℚ E] + {p : ℕ} (hp : p.Prime) (hpd : p ∣ (NumberField.discr E).natAbs) : p ∣ m := by + by_contra hpm +- haveI : Fact (Nat.Prime p) := ⟨hp⟩ ++ have : Fact (Nat.Prime p) := ⟨hp⟩ + have hpprime : Prime (p : ℤ) := Nat.prime_iff_prime_int.mp hp + refine absurd (Int.ofNat_dvd_left.mpr hpd) ?_ + rw [NumberField.not_dvd_discr_iff_forall_liesOver E (𝓞 E) hpprime] + intro P hPmax hlo +- haveI := hPmax.isPrime +- haveI := hlo ++ have := hPmax.isPrime ++ have := hlo + have hspanbot : Ideal.span {(p : ℤ)} ≠ ⊥ := by + rw [Ne, Ideal.span_singleton_eq_bot]; exact hpprime.ne_zero + have hPbot : P ≠ ⊥ := Ideal.ne_bot_of_liesOver_of_ne_bot hspanbot P +@@ -263,9 +263,9 @@ private theorem cyclotomicField_finrank_eq + (Set.mem_singleton m) (NeZero.ne m) + set K₁ : IntermediateField ℚ M := IntermediateField.adjoin ℚ {ζ} with hK₁def + set K₂ : IntermediateField ℚ M := (IsScalarTower.toAlgHom ℚ K M).fieldRange with hK₂def +- haveI hK₁cyc : IsCyclotomicExtension {m} ℚ K₁ := ++ have hK₁cyc : IsCyclotomicExtension {m} ℚ K₁ := + hζ.intermediateField_adjoin_isCyclotomicExtension (K := ℚ) +- haveI : IsGalois ℚ K₁ := IsCyclotomicExtension.isGalois (S := {m}) (K := ℚ) (L := K₁) ++ have : IsGalois ℚ K₁ := IsCyclotomicExtension.isGalois (S := {m}) (K := ℚ) (L := K₁) + have hfinK₁ : Module.finrank ℚ K₁ = m.totient := + IsCyclotomicExtension.finrank K₁ (Polynomial.cyclotomic.irreducible_rat (NeZero.pos m)) + have hsup : K₁ ⊔ K₂ = ⊤ := by +@@ -317,8 +317,8 @@ private theorem compositum_charProd_bijective + [IsGalois K L] [IsGalois K M] (m : ℕ) [NeZero m] [IsCyclotomicExtension {m} L M] + (hcop : ((NumberField.discr L).natAbs).Coprime m) (ζ : M) (hζ : IsPrimitiveRoot ζ m) : + Function.Bijective ((AlgEquiv.restrictNormalHom L).prod (hζ.autToPow K)) := by +- haveI : FiniteDimensional K M := inferInstance +- haveI : IsGalois L M := IsGalois.tower_top_of_isGalois K L M ++ have : FiniteDimensional K M := inferInstance ++ have : IsGalois L M := IsGalois.tower_top_of_isGalois K L M + set χK : Gal(M/K) →* (ZMod m)ˣ := hζ.autToPow K with hχK + set Φ : Gal(M/K) →* Gal(L/K) × (ZMod m)ˣ := + (AlgEquiv.restrictNormalHom L).prod χK with hΦ +@@ -372,8 +372,8 @@ private theorem autToPow_L_bijective + [IsGalois K L] [IsGalois K M] (m : ℕ) [NeZero m] [IsCyclotomicExtension {m} L M] + (hcop : ((NumberField.discr L).natAbs).Coprime m) (ζ : M) (hζ : IsPrimitiveRoot ζ m) : + Function.Bijective (hζ.autToPow L) := by +- haveI : FiniteDimensional K M := inferInstance +- haveI : IsGalois L M := IsGalois.tower_top_of_isGalois K L M ++ have : FiniteDimensional K M := inferInstance ++ have : IsGalois L M := IsGalois.tower_top_of_isGalois K L M + have hML : Module.finrank L M = m.totient := cyclotomicField_finrank_eq L M m hcop + have hcardML : Nat.card Gal(M/L) = Nat.card (ZMod m)ˣ := by + rw [IsGalois.card_aut_eq_finrank L M, hML, Nat.card_eq_fintype_card, +@@ -426,7 +426,7 @@ private theorem compositum_isCyclotomic_over_fixedField + (IntermediateField.adjoin_le_iff.mpr (Set.singleton_subset_iff.mpr + (IntermediateField.subset_adjoin K _ hζ.pow_eq_one))) + (IntermediateField.adjoin_le_iff.mpr fun x hx ↦ by +- obtain ⟨i, -, rfl⟩ := hζ.eq_pow_of_pow_eq_one (Set.mem_setOf_eq ▸ hx) ++ obtain ⟨i, -, rfl⟩ := hζ.eq_pow_of_pow_eq_one (Set.mem_ofPred_eq ▸ hx) + exact pow_mem (IntermediateField.subset_adjoin K _ (Set.mem_singleton ζ)) i) + have hsup : (F ⊔ Kμ).fixingSubgroup = ⊥ := by + rw [IntermediateField.fixingSubgroup_sup, IntermediateField.fixingSubgroup_fixedField, _hmeet] +@@ -437,8 +437,8 @@ private theorem compositum_isCyclotomic_over_fixedField + apply IntermediateField.restrictScalars_injective K + rw [IntermediateField.restrictScalars_adjoin_eq_sup, hadjζ, htop] + rfl +- haveI : Algebra.IsIntegral ↥F M := Algebra.IsIntegral.of_finite ↥F M +- haveI hcyc : IsCyclotomicExtension {m} ↥F (IntermediateField.adjoin (↥F) {ζ}) := ++ have : Algebra.IsIntegral ↥F M := Algebra.IsIntegral.of_finite ↥F M ++ have hcyc : IsCyclotomicExtension {m} ↥F (IntermediateField.adjoin (↥F) {ζ}) := + IsPrimitiveRoot.intermediateField_adjoin_isCyclotomicExtension (K := ↥F) hζ + rw [htopF] at hcyc + exact IsCyclotomicExtension.equiv (S := {m}) (A := ↥F) (f := IntermediateField.topEquiv) +@@ -454,7 +454,7 @@ private theorem smul_algebraMap_eq_repl + [Algebra K L] [Algebra K M] [Algebra L M] [IsScalarTower K L M] + [IsGalois K L] [IsGalois K M] (σ : Gal(M/K)) (y : 𝓞 L) : + σ • (algebraMap (𝓞 L) (𝓞 M) y) = algebraMap (𝓞 L) (𝓞 M) ((σ.restrictNormal L) • y) := by +- haveI : IsScalarTower (𝓞 K) (𝓞 L) (𝓞 M) := inferInstance ++ have : IsScalarTower (𝓞 K) (𝓞 L) (𝓞 M) := inferInstance + have hbridgeM : ∀ (g : M ≃ₐ[K] M) (x : 𝓞 M), ((g • x : 𝓞 M) : M) = g • (x : M) := fun g x ↦ + by simpa [Algebra.smul_def] using + (smul_distrib_smul (G := M ≃ₐ[K] M) (R := 𝓞 M) (S := M) g x 1).symm +@@ -479,7 +479,7 @@ private theorem isArithFrobAt_restrictNormal_repl + [IsGalois K L] [IsGalois K M] (σ : Gal(M/K)) (𝔓 : Ideal (𝓞 M)) + (hσ : IsArithFrobAt (𝓞 K) σ 𝔓) : + IsArithFrobAt (𝓞 K) (σ.restrictNormal L) (𝔓.under (𝓞 L)) := by +- haveI : IsScalarTower (𝓞 K) (𝓞 L) (𝓞 M) := inferInstance ++ have : IsScalarTower (𝓞 K) (𝓞 L) (𝓞 M) := inferInstance + have hunder : (𝔓.under (𝓞 L)).under (𝓞 K) = 𝔓.under (𝓞 K) := Ideal.under_under 𝔓 + intro y + rw [hunder, Ideal.under, Ideal.mem_comap, map_sub, map_pow, +@@ -495,16 +495,16 @@ private theorem frobeniusClass_proj_isPrime_aux + (_hfr : frobeniusClass K M 𝔭 = ConjClasses.mk τM) : + frobeniusClass K L 𝔭 = ConjClasses.mk σ := by + obtain ⟨𝔓, h𝔓p, h𝔓lo, -⟩ := exists_prime_liesOver K M 𝔭 (UnramifiedIn.ne_bot K M _hunrM) +- haveI := h𝔓p +- haveI := h𝔓lo +- haveI : Finite (𝓞 M ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 ++ have := h𝔓p ++ have := h𝔓lo ++ have : Finite (𝓞 M ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 + (ne_bot_of_ramificationIdx_eq_one K M (UnramifiedIn.ramificationIdx_eq_one K M _hunrM 𝔓 h𝔓lo)) + set σM : Gal(M/K) := arithFrobAt (𝓞 K) Gal(M/K) 𝔓 + have hMfrobσM : IsArithFrobAt (𝓞 K) σM 𝔓 := IsArithFrobAt.arithFrobAt (𝓞 K) Gal(M/K) 𝔓 + have hconjM : IsConj σM τM := ConjClasses.mk_eq_mk_iff_isConj.mp + ((frobeniusClass_eq_mk_of_isArithFrobAt K M 𝔭 _hunrM σM 𝔓 hMfrobσM h𝔓lo).symm.trans _hfr) +- haveI : (𝔓.under (𝓞 L)).IsPrime := Ideal.IsPrime.under (𝓞 L) 𝔓 +- haveI : (𝔓.under (𝓞 L)).LiesOver 𝔭 := ⟨((Ideal.under_under 𝔓).trans h𝔓lo.over.symm).symm⟩ ++ have : (𝔓.under (𝓞 L)).IsPrime := Ideal.IsPrime.under (𝓞 L) 𝔓 ++ have : (𝔓.under (𝓞 L)).LiesOver 𝔭 := ⟨((Ideal.under_under 𝔓).trans h𝔓lo.over.symm).symm⟩ + rw [frobeniusClass_eq_mk_of_isArithFrobAt K L 𝔭 _hunrL (σM.restrictNormal L) (𝔓.under (𝓞 L)) + (isArithFrobAt_restrictNormal_repl K L M σM 𝔓 hMfrobσM) inferInstance] + refine ConjClasses.mk_eq_mk_iff_isConj.mpr ?_ +@@ -527,12 +527,12 @@ private theorem frobeniusClass_proj + (_hfr : frobeniusClass K M 𝔭 = ConjClasses.mk τM) : + frobeniusClass K L 𝔭 = ConjClasses.mk σ := by + by_cases hp : 𝔭.IsPrime +- · haveI := hp ++ · have := hp + exact frobeniusClass_proj_isPrime_aux K L M σ τM _hτM 𝔭 _hunrM _hunrL _hfr + · have hMjunk : frobeniusClass K M 𝔭 = ConjClasses.mk 1 := by +- rw [frobeniusClass, dif_neg fun h ↦ hp h.1] ++ rw [frobeniusClass, dite_eq_right fun h ↦ hp h.1] + have hLjunk : frobeniusClass K L 𝔭 = ConjClasses.mk 1 := by +- rw [frobeniusClass, dif_neg fun h ↦ hp h.1] ++ rw [frobeniusClass, dite_eq_right fun h ↦ hp h.1] + have hconj : IsConj (1 : Gal(M/K)) τM := + ConjClasses.mk_eq_mk_iff_isConj.mp (hMjunk.symm.trans _hfr) + have hτM1 : τM = 1 := isConj_one_right.mp hconj +@@ -583,16 +583,16 @@ private theorem isGalois_compositum_base + [IsScalarTower K L M] [IsCyclotomicExtension {m} L M] : IsGalois K M := by + obtain ⟨ζ, hζ⟩ : ∃ r : M, IsPrimitiveRoot r m := + IsCyclotomicExtension.exists_isPrimitiveRoot (S := {m}) L M (Set.mem_singleton m) (NeZero.ne m) +- haveI : FiniteDimensional K M := inferInstance +- haveI hsep : Algebra.IsSeparable K M := inferInstance ++ have : FiniteDimensional K M := inferInstance ++ have hsep : Algebra.IsSeparable K M := inferInstance + set A : IntermediateField K M := (IsScalarTower.toAlgHom K L M).fieldRange with hA + set B : IntermediateField K M := IntermediateField.adjoin K {ζ} with hB +- haveI hAnormal : Normal K A := ++ have hAnormal : Normal K A := + Normal.of_algEquiv (AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom K L M)) +- haveI hBcyc : IsCyclotomicExtension {m} K B := ++ have hBcyc : IsCyclotomicExtension {m} K B := + hζ.intermediateField_adjoin_isCyclotomicExtension (K := K) +- haveI hBgal : IsGalois K B := IsCyclotomicExtension.isGalois (S := {m}) (K := K) (L := B) +- haveI hBnormal : Normal K B := hBgal.to_normal ++ have hBgal : IsGalois K B := IsCyclotomicExtension.isGalois (S := {m}) (K := K) (L := B) ++ have hBnormal : Normal K B := hBgal.to_normal + have hsup : A ⊔ B = ⊤ := by + have hζalg : IsAlgebraic K ζ := Algebra.IsAlgebraic.isAlgebraic ζ + have hsubalg : (IsScalarTower.toAlgHom K L M).range ⊔ Algebra.adjoin K {ζ} +@@ -606,7 +606,7 @@ private theorem isGalois_compositum_base + IntermediateField.adjoin_simple_toSubalgebra_of_isAlgebraic hζalg, + AlgHom.fieldRange_toSubalgebra, IntermediateField.top_toSubalgebra] + exact hsubalg +- haveI hnormal : Normal K M := by ++ have hnormal : Normal K M := by + have h := IntermediateField.normal_sup K M A B + rw [hsup] at h + exact Normal.of_algEquiv (IntermediateField.topEquiv (F := K) (E := M)) +@@ -615,35 +615,38 @@ private theorem isGalois_compositum_base + /-- **Unramifiedness descends to an intermediate field.** If a prime `𝔭` of `K` is unramified + in the top field `M` of a tower `K ⊆ L ⊆ M`, it is unramified in `L`: for a maximal prime `𝔮` + of `𝓞 L` over `𝔭`, pick a prime `𝔓` of `𝓞 M` over `𝔮`; then `e(𝔓/𝔭) = 1` (from the `M`-side +-hypothesis) factors as `e(𝔮/𝔭)·e(𝔓/𝔮)` (`Ideal.ramificationIdx_algebra_tower`), forcing ++hypothesis) factors as `e(𝔮/𝔭)·e(𝔓/𝔮)` (`Ideal.ramificationIdx'_algebra_tower`), forcing + `e(𝔮/𝔭) = 1`. Supplies C4's `_hunrL : UnramifiedIn K L 𝔭` input from `UnramifiedIn K M 𝔭`. -/ + private theorem unramifiedIn_tower_descend + (K L M : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Field M] [NumberField M] + [Algebra K L] [Algebra K M] [Algebra L M] [IsScalarTower K L M] [IsGalois K L] [IsGalois K M] + (𝔭 : Ideal (𝓞 K)) (hunr : UnramifiedIn K M 𝔭) : UnramifiedIn K L 𝔭 := by +- haveI : IsScalarTower (𝓞 K) (𝓞 L) (𝓞 M) := inferInstance ++ have : IsScalarTower (𝓞 K) (𝓞 L) (𝓞 M) := inferInstance + refine ⟨hunr.1, fun 𝔮 h𝔮max h𝔮lo ↦ ?_⟩ +- haveI := h𝔮max +- haveI := h𝔮lo +- haveI h𝔮p : 𝔮.IsPrime := h𝔮max.isPrime ++ have := h𝔮max ++ have := h𝔮lo ++ have h𝔮p : 𝔮.IsPrime := h𝔮max.isPrime + have h𝔮bot : 𝔮 ≠ ⊥ := Ideal.ne_bot_of_liesOver_of_ne_bot hunr.1 𝔮 + obtain ⟨𝔓, _, h𝔓p, h𝔓comap⟩ := + Ideal.exists_ideal_over_prime_of_isIntegral (S := 𝓞 M) 𝔮 ⊥ (by simp) +- haveI := h𝔓p +- haveI h𝔓lo𝔮 : 𝔓.LiesOver 𝔮 := ⟨h𝔓comap.symm⟩ ++ have := h𝔓p ++ have h𝔓lo𝔮 : 𝔓.LiesOver 𝔮 := ⟨h𝔓comap.symm⟩ + have h𝔓bot : 𝔓 ≠ ⊥ := Ideal.ne_bot_of_liesOver_of_ne_bot h𝔮bot 𝔓 +- haveI h𝔓max : 𝔓.IsMaximal := h𝔓p.isMaximal h𝔓bot ++ have h𝔓max : 𝔓.IsMaximal := h𝔓p.isMaximal h𝔓bot + have h𝔮under : Ideal.under (𝓞 L) 𝔓 = 𝔮 := h𝔓lo𝔮.over.symm + have h𝔭under : Ideal.under (𝓞 K) 𝔮 = 𝔭 := h𝔮lo.over.symm +- haveI h𝔓lo𝔭 : 𝔓.LiesOver 𝔭 := ⟨by rw [← h𝔭under, ← h𝔮under, Ideal.under_under]⟩ ++ have h𝔓lo𝔭 : 𝔓.LiesOver 𝔭 := ⟨by rw [← h𝔭under, ← h𝔮under, Ideal.under_under]⟩ + have hunderP : Ideal.under (𝓞 K) 𝔓 = 𝔭 := h𝔓lo𝔭.over.symm + have hP1 : (Ideal.under (𝓞 K) 𝔓).ramificationIdx' 𝔓 = 1 := by + rw [Ideal.ramificationIdx'_eq_ramificationIdx _ 𝔓 (hunderP ▸ hunr.1)] + exact Ideal.ramificationIdx_eq_one_iff.mpr (hunr.2 𝔓 h𝔓max h𝔓lo𝔭) + rw [hunderP] at hP1 +- have htower := Ideal.ramificationIdx_algebra_tower (R := 𝓞 K) (S := 𝓞 L) (T := 𝓞 M) ++ have htower := Ideal.ramificationIdx'_algebra_tower (R := 𝓞 K) (S := 𝓞 L) (T := 𝓞 M) + (p := 𝔭) (P := 𝔮) (Q := 𝔓) (Ideal.map_ne_bot_of_ne_bot h𝔮bot) +- (Ideal.map_ne_bot_of_ne_bot hunr.1) (by rw [Ideal.map_le_iff_le_comap, h𝔓comap]) ++ (Ideal.map_ne_bot_of_ne_bot hunr.1) (by ++ rw [Ideal.map_le_iff_le_comap] ++ change 𝔮 ≤ 𝔓.under (𝓞 L) ++ rw [h𝔓comap]) + rw [hP1] at htower + have he𝔮 : 𝔭.ramificationIdx' 𝔮 = 1 := Nat.eq_one_of_mul_eq_one_right htower.symm + rw [← Ideal.ramificationIdx_eq_one_iff, +@@ -732,15 +735,15 @@ private theorem density_crossing_fibre_aux + frobeniusClass K M 𝔭 = ConjClasses.mk s} + ((Nat.card Gal(L/K) * Nat.card ((ZMod m)ˣ) : ℝ)⁻¹) := by + set F : IntermediateField K M := IntermediateField.fixedField (Subgroup.zpowers s) with hF +- haveI : IsScalarTower K ↥F M := F.isScalarTower_mid' +- haveI : IsCyclotomicExtension {m} ↥F M := ++ have : IsScalarTower K ↥F M := F.isScalarTower_mid' ++ have : IsCyclotomicExtension {m} ↥F M := + compositum_isCyclotomic_over_fixedField K L M m s hgate + set σE : Gal(M/↥F) := + IntermediateField.subgroupEquivAlgEquiv (Subgroup.zpowers s) ⟨s, Subgroup.mem_zpowers s⟩ + have hlift := density_lift_through_fixedField_repl K M s F σE + (by ext x; rfl) rfl (chebotarev_cyclotomic (K := ↥F) (L := M) m hm4 σE) + have hcarrier : Nat.card (ConjClasses.mk s).carrier = 1 := by +- letI : CommMonoid Gal(M/K) := IsMulCommutative.instCommMonoid ++ let : CommMonoid Gal(M/K) := IsMulCommutative.instCommMonoid + have hcar : (ConjClasses.mk s).carrier = {s} := by + ext a + rw [ConjClasses.mem_carrier_iff_mk_eq, ConjClasses.mk_eq_mk_iff_isConj, +@@ -782,11 +785,11 @@ private theorem exists_crossing_family_tagged + (∀ τ, HasDirichletDensity (S τ) + ((Nat.card Gal(L/K) * Nat.card ((ZMod m)ˣ) : ℝ)⁻¹)) := by + classical +- haveI : NeZero m := ⟨by lia⟩ ++ have : NeZero m := ⟨by lia⟩ + let M := CyclotomicField m L +- haveI : IsGalois K M := isGalois_compositum_base K L m M +- haveI : IsGalois L M := IsGalois.tower_top_of_isGalois K L M +- haveI : FiniteDimensional K M := inferInstance ++ have : IsGalois K M := isGalois_compositum_base K L m M ++ have : IsGalois L M := IsGalois.tower_top_of_isGalois K L M ++ have : FiniteDimensional K M := inferInstance + obtain ⟨ζ, hζ⟩ : ∃ r : M, IsPrimitiveRoot r m := + IsCyclotomicExtension.exists_isPrimitiveRoot (S := {m}) L M (Set.mem_singleton m) (NeZero.ne m) + set χK : Gal(M/K) →* (ZMod m)ˣ := hζ.autToPow K with hχK +@@ -796,10 +799,10 @@ private theorem exists_crossing_family_tagged + MulEquiv.ofBijective _ hΦbij with hequivΦ + set e2 : Gal(M/L) ≃* (ZMod m)ˣ := + MulEquiv.ofBijective (hζ.autToPow L) (autToPow_L_bijective K L M m hcop ζ hζ) with he2 +- haveI : IsMulCommutative Gal(M/L) := ++ have : IsMulCommutative Gal(M/L) := + .of_comm fun a b ↦ e2.injective (by rw [map_mul, map_mul]; exact mul_comm (e2 a) (e2 b)) +- haveI hGcomm : ∀ x y : Gal(L/K), x * y = y * x := fun x y ↦ mul_comm' x y +- haveI : IsMulCommutative Gal(M/K) := ++ have hGcomm : ∀ x y : Gal(L/K), x * y = y * x := fun x y ↦ mul_comm' x y ++ have : IsMulCommutative Gal(M/K) := + .of_comm fun a b ↦ equivΦ.injective (by + rw [map_mul, map_mul, Prod.mul_def, Prod.mul_def, hGcomm, mul_comm + ((equivΦ a).2) ((equivΦ b).2)]) +@@ -933,8 +936,8 @@ private theorem factorization_ordCompl_mul_pow (E p v : ℕ) (hp : p.Prime) (hE + simp only [Finsupp.coe_add, Pi.add_apply, hp.factorization_pow, Finsupp.single_apply, + Nat.factorization_ordCompl] + by_cases hq : q = p +- · subst hq; rw [Finsupp.erase_same, if_pos rfl, if_pos rfl, zero_add] +- · rw [Finsupp.erase_ne hq, if_neg fun h ↦ hq h.symm, if_neg hq, add_zero] ++ · subst hq; rw [Finsupp.erase_same, ite_eq_left rfl, ite_eq_left rfl, zero_add] ++ · rw [Finsupp.erase_ne hq, ite_eq_right fun h ↦ hq h.symm, ite_eq_right hq, add_zero] + + /-- If `d ∣ E` and the `p`-adic valuation of `d` is `≤ v - 1`, then `d` divides the + "capped" modulus `ordCompl[p] E * p ^ (v - 1)` (which replaces `E`'s `p`-part by +@@ -947,8 +950,8 @@ private theorem dvd_capped (E d p v : ℕ) (hp : p.Prime) (hE : E ≠ 0) (hd : d + intro q + rw [factorization_ordCompl_mul_pow E p v hp hE q] + by_cases hq : q = p +- · subst hq; rwa [if_pos rfl] +- · rw [if_neg hq]; exact (Nat.factorization_le_iff_dvd hdne hE).mpr hd q ++ · subst hq; rwa [ite_eq_left rfl] ++ · rw [ite_eq_right hq]; exact (Nat.factorization_le_iff_dvd hdne hE).mpr hd q + + /-- The capped modulus `ordCompl[p] E * p ^ (v - 1)` divides `E` when `v - 1 ≤ v_p(E)`. -/ + private theorem M_dvd_E (E p v : ℕ) (hp : p.Prime) (hE : E ≠ 0) (hle : v - 1 ≤ E.factorization p) : +@@ -958,8 +961,8 @@ private theorem M_dvd_E (E p v : ℕ) (hp : p.Prime) (hE : E ≠ 0) (hle : v - 1 + intro q + rw [factorization_ordCompl_mul_pow E p v hp hE q] + by_cases hq : q = p +- · subst hq; rwa [if_pos rfl] +- · rw [if_neg hq] ++ · subst hq; rwa [ite_eq_left rfl] ++ · rw [ite_eq_right hq] + + /-- Factoring out the complementary `p`-power: `E = (ordCompl[p] E * p ^ (v - 1)) * + p ^ (v_p(E) - (v - 1))`, used to compute `E / M = p ^ (v_p(E) - (v - 1))`. -/ +@@ -1341,7 +1344,7 @@ theorem liminf_ratio_ge_inv_card_G + rw [Nat.coprime_comm, (hmp k).coprime_iff_not_dvd] + exact fun hdvd ↦ absurd (Nat.le_of_dvd hdBpos hdvd) (Nat.not_le.mpr (hmgt k)) + have hexp : ∀ k, Monoid.exponent (ZMod (m k))ˣ = m k - 1 := fun k ↦ by +- haveI : Fact (m k).Prime := ⟨hmp k⟩ ++ have : Fact (m k).Prime := ⟨hmp k⟩ + rw [IsCyclic.exponent_eq_card, Nat.card_eq_fintype_card, ZMod.card_units_eq_totient, + Nat.totient_prime (hmp k)] + have hbound : ∀ k : ℕ, +@@ -1393,7 +1396,7 @@ theorem ratioSum_frobeniusFibres_tendsto_one + set R : Set (Ideal (𝓞 K)) := + {𝔭 : Ideal (𝓞 K) | 𝔭.IsPrime ∧ 𝔭 ≠ ⊥ ∧ ¬ UnramifiedIn K L 𝔭} with hR + set D : ℝ → ℝ := primeIdealZetaSum (Set.univ : Set (Ideal (𝓞 K))) with hD +- letI : CommMonoid Gal(L/K) := IsMulCommutative.instCommMonoid ++ let : CommMonoid Gal(L/K) := IsMulCommutative.instCommMonoid + have hmk_inj : Function.Injective (ConjClasses.mk : Gal(L/K) → ConjClasses Gal(L/K)) := + ConjClasses.mk_injective + have hpd : ((Finset.univ : Finset Gal(L/K)) : Set Gal(L/K)).PairwiseDisjoint S := by +@@ -1514,7 +1517,7 @@ theorem tendsto_inv_card_of_liminf_ge_of_sum_tendsto_one {ι : Type*} [Fintype + have hFlimsup : limsup F l = 1 := hsum.limsup_eq + have hgle : ∀ i, l.IsBoundedUnder (· ≤ ·) (g i) := + isBoundedUnder_le_of_isBoundedUnder_le_sum g hFle hbelow +- haveI : Nonempty ι := ⟨i₀⟩ ++ have : Nonempty ι := ⟨i₀⟩ + have hNpos : 0 < N := Fintype.card_pos + have hNR : (0 : ℝ) < N := by exact_mod_cast hNpos + set t : Finset ι := Finset.univ.erase i₀ with ht +diff --git a/projects/Chebotarev/CebotarevDensity/AbsoluteDegreeOneDensity.lean b/projects/Chebotarev/CebotarevDensity/AbsoluteDegreeOneDensity.lean +new file mode 100644 +index 000000000..a484ff648 +--- /dev/null ++++ b/projects/Chebotarev/CebotarevDensity/AbsoluteDegreeOneDensity.lean +@@ -0,0 +1,144 @@ ++module ++ ++public import CebotarevDensity.Density ++public import CebotarevDensity.ForMathlib.TsumFiberBound ++public import Mathlib.RingTheory.RamificationInertia.Basic ++public import Mathlib.NumberTheory.RamificationInertia.Inertia ++public import Mathlib.Analysis.PSeries ++public import Mathlib.RingTheory.Ideal.Int ++ ++/-! ++# Discarding primes of absolute residue degree greater than one ++ ++The higher-degree terms are bounded by `[K : ℚ] * ∑ n⁻²`, independently of ++`s > 1`. They consequently have zero Dirichlet density, even after intersection ++with an arbitrary set of prime ideals. ++-/ ++ ++@[expose] public section ++ ++noncomputable section ++ ++open Filter NumberField Topology Set ++ ++namespace Chebotarev ++ ++variable {K : Type*} [Field K] [NumberField K] ++ ++private theorem absNorm_rpow_neg_le_intUnder_sq ++ (P : Ideal (𝓞 K)) [P.IsPrime] (hP : P ≠ ⊥) ++ (hdegree : ¬ P.absNorm.Prime) {s : ℝ} (hs : 1 < s) : ++ (P.absNorm : ℝ) ^ (-s) ≤ ((P.under ℤ).absNorm : ℝ) ^ (-(2 : ℝ)) := by ++ let : NeZero P := ⟨hP⟩ ++ have hp : (P.under ℤ).absNorm.Prime := Nat.absNorm_under_prime P ++ have : P.LiesOver (P.under ℤ) := Ideal.over_under (A := ℤ) (P := P) ++ have hpow := (Ideal.absNorm_pow_inertiaDeg (P.under ℤ) P).symm ++ have hdeg : 2 ≤ P.inertiaDeg ℤ := by ++ have hpos : 0 < P.inertiaDeg ℤ := Ideal.inertiaDeg_pos P ℤ ++ have hne : P.inertiaDeg ℤ ≠ 1 := by ++ intro h ++ apply hdegree ++ rw [hpow, h, pow_one] ++ exact hp ++ omega ++ rw [hpow, Nat.cast_pow, ++ ← Real.rpow_natCast ((P.under ℤ).absNorm : ℝ) (P.inertiaDeg ℤ), ++ ← Real.rpow_mul (by positivity)] ++ apply Real.rpow_le_rpow_of_exponent_le (by exact_mod_cast hp.one_lt.le) ++ nlinarith [mul_le_mul (show (2 : ℝ) ≤ (P.inertiaDeg ℤ : ℝ) by exact_mod_cast hdeg) ++ hs.le (by norm_num) (by positivity : (0 : ℝ) ≤ (P.inertiaDeg ℤ : ℝ))] ++ ++/-- The non-prime-norm part of any set of prime ideals has a uniform Dirichlet-series bound. -/ ++theorem primeIdealZetaSum_nonprimeNorm_le (S : Set (Ideal (𝓞 K))) {s : ℝ} (hs : 1 < s) : ++ primeIdealZetaSum {P | P ∈ S ∧ ¬ P.absNorm.Prime} s ≤ ++ (Module.finrank ℚ K : ℝ) * ∑' n : ℕ, (n : ℝ) ^ (-(2 : ℝ)) := by ++ let A := {P : Ideal (𝓞 K) // (P ∈ S ∧ ¬ P.absNorm.Prime) ∧ P.IsPrime ∧ P ≠ ⊥} ++ let B := {p : Ideal ℤ // p.IsPrime ∧ p ≠ ⊥} ++ have hunder : ∀ P : A, (P.1.under ℤ).IsPrime ∧ P.1.under ℤ ≠ ⊥ := by ++ intro P ++ let := P.2.2.1 ++ exact ⟨inferInstance, Ideal.IsIntegral.under_ne_bot ℤ P.2.2.2⟩ ++ let g : A → B := fun P => ⟨P.1.under ℤ, hunder P⟩ ++ have hfib : ∀ p : B, Finite (g ⁻¹' {p} : Set A) ∧ ++ Nat.card (g ⁻¹' {p} : Set A) ≤ Module.finrank ℚ K := by ++ intro p ++ let := p.2.1 ++ let : p.1.IsMaximal := p.2.1.isMaximal p.2.2 ++ have hmem : ∀ P : (g ⁻¹' {p} : Set A), P.1.1.IsPrime ∧ P.1.1.LiesOver p.1 := by ++ intro P ++ let := P.1.2.2.1 ++ refine ⟨P.1.2.2.1, ⟨?_⟩⟩ ++ exact (congrArg Subtype.val P.2 : P.1.1.under ℤ = p.1) ▸ ++ (Ideal.over_under (A := ℤ) (P := P.1.1)).over ++ let f : (g ⁻¹' {p} : Set A) → p.1.primesOver (𝓞 K) := fun P => ⟨P.1.1, hmem P⟩ ++ have hfinj : Function.Injective f := by ++ intro P Q h ++ apply Subtype.ext ++ apply Subtype.ext ++ exact congrArg (fun x : p.1.primesOver (𝓞 K) => x.1) h ++ let : Finite (p.1.primesOver (𝓞 K)) := ++ (IsDedekindDomain.primesOver_finite p.1 _).to_subtype ++ have hcard : Nat.card (p.1.primesOver (𝓞 K)) ≤ Module.finrank ℚ K := by ++ classical ++ let : Fintype (p.1.primesOver (𝓞 K)) := Fintype.ofFinite _ ++ calc ++ Nat.card (p.1.primesOver (𝓞 K)) = ∑ _q : p.1.primesOver (𝓞 K), (1 : ℕ) := by ++ simp [Nat.card_eq_fintype_card] ++ _ ≤ ∑ q : p.1.primesOver (𝓞 K), q.1.ramificationIdx ℤ * q.1.inertiaDeg ℤ := by ++ apply Finset.sum_le_sum ++ intro q _ ++ have : q.1.IsPrime := q.2.1 ++ exact Nat.mul_pos (Ideal.ramificationIdx_pos q.1 ℤ) (Ideal.inertiaDeg_pos q.1 ℤ) ++ _ = Module.finrank ℤ (𝓞 K) := Ideal.sum_ramification_inertia_eq_finrank p.1 (𝓞 K) ++ _ = Module.finrank ℚ K := RingOfIntegers.rank K ++ exact ⟨Finite.of_injective f hfinj, (Nat.card_le_card_of_injective f hfinj).trans hcard⟩ ++ have hnorminj : Function.Injective (fun p : B => p.1.absNorm) := by ++ intro p q h ++ change p.1.absNorm = q.1.absNorm at h ++ apply Subtype.ext ++ rw [← Int.ideal_span_absNorm_eq_self p.1, ← Int.ideal_span_absNorm_eq_self q.1, h] ++ have hnat : Summable (fun n : ℕ => (n : ℝ) ^ (-(2 : ℝ))) := ++ Real.summable_nat_rpow.mpr (by norm_num) ++ have hsum : Summable (fun p : B => (p.1.absNorm : ℝ) ^ (-(2 : ℝ))) := ++ hnat.comp_injective hnorminj ++ calc ++ primeIdealZetaSum {P | P ∈ S ∧ ¬ P.absNorm.Prime} s ≤ ++ (Module.finrank ℚ K : ℝ) * ∑' p : B, (p.1.absNorm : ℝ) ^ (-(2 : ℝ)) := by ++ apply tsum_real_comp_le_card_fibre_mul g _ _ _ ++ (summable_prime_absNorm_rpow _ hs) hsum ++ (fun _ => by positivity) (fun _ => by positivity) ++ · intro P ++ let := P.2.2.1 ++ exact absNorm_rpow_neg_le_intUnder_sq P.1 P.2.2.2 P.2.1.2 hs ++ · exact fun p => (hfib p).1 ++ · exact fun p => (hfib p).2 ++ _ ≤ (Module.finrank ℚ K : ℝ) * ∑' n : ℕ, (n : ℝ) ^ (-(2 : ℝ)) := by ++ apply mul_le_mul_of_nonneg_left _ (by positivity) ++ exact hsum.tsum_le_tsum_of_inj _ hnorminj (fun _ _ => by positivity) ++ (fun _ => le_rfl) hnat ++ ++/-- Removing prime ideals of absolute residue degree greater than one preserves density. -/ ++theorem HasDirichletDensity.primeNorm {S : Set (Ideal (𝓞 K))} {δ : ℝ} ++ (hS : HasDirichletDensity S δ) : ++ HasDirichletDensity {P | P ∈ S ∧ P.absNorm.Prime} δ := by ++ let T : Set (Ideal (𝓞 K)) := {P | P ∈ S ∧ P.absNorm.Prime} ++ let U : Set (Ideal (𝓞 K)) := {P | P ∈ S ∧ ¬ P.absNorm.Prime} ++ have hzero : HasDirichletDensity U 0 := ++ tendsto_primeIdealZetaSum_div_univ_zero_of_le_const K U _ ++ (eventually_nhdsWithin_of_forall fun s hs => primeIdealZetaSum_nonprimeNorm_le S hs) ++ have hdisjoint : Disjoint T U := by ++ rw [Set.disjoint_left] ++ exact fun _ ht hu => hu.2 ht.2 ++ have hunion : T ∪ U = S := by ++ ext P ++ simp only [T, U, Set.mem_union, Set.mem_ofPred_eq] ++ tauto ++ have h := hS.sub hzero ++ simp only [sub_zero] at h ++ apply h.congr' ++ filter_upwards [self_mem_nhdsWithin] with s hs ++ have hsum : primeIdealZetaSum S s = primeIdealZetaSum T s + primeIdealZetaSum U s := by ++ rw [← hunion, primeIdealZetaSum_union_of_disjoint hdisjoint hs] ++ rw [hsum, add_div, add_sub_cancel_right] ++ ++end Chebotarev +diff --git a/projects/Chebotarev/CebotarevDensity/Cyclotomic.lean b/projects/Chebotarev/CebotarevDensity/Cyclotomic.lean +index c0e83f4b7..7a08eb09f 100644 +--- a/projects/Chebotarev/CebotarevDensity/Cyclotomic.lean ++++ b/projects/Chebotarev/CebotarevDensity/Cyclotomic.lean +@@ -205,7 +205,7 @@ theorem character_orthogonality_cyclotomic_eq + ConjClasses.mk_eq_mk_iff_isConj.mp (hmk.trans _h) + rw [SemiconjBy, mul_comm' (c : Gal(L/K))] at hc + rw [mul_right_cancel hc, mul_inv_cancel] +- rw [sum_galoisCharacter_mul_inv_eq K L σ τ, if_pos heq] ++ rw [sum_galoisCharacter_mul_inv_eq K L σ τ, ite_eq_left heq] + + /-- Sharifi 7.2.1 character orthogonality, **non-matching case**: + when `frobeniusClass K L 𝔭 ≠ ConjClasses.mk σ`, the character sum +@@ -222,7 +222,7 @@ theorem character_orthogonality_cyclotomic_ne + have hmk : ConjClasses.mk τ = frobeniusClass K L 𝔭 := Quotient.out_eq _ + have hne : σ * τ⁻¹ ≠ 1 := fun hσ ↦ + _h <| hmk.symm.trans (congrArg ConjClasses.mk (mul_inv_eq_one.mp hσ)).symm +- rw [sum_galoisCharacter_mul_inv_eq K L σ τ, if_neg hne] ++ rw [sum_galoisCharacter_mul_inv_eq K L σ τ, ite_eq_right hne] + + /-! ### Complex-analytic core of the cyclotomic χ≠1 bound + +@@ -615,7 +615,7 @@ private theorem artinLSeries_prime_sum_bounded_of_analytic_extension + set D : Set ℂ := {s : ℂ | 1 - (Module.finrank ℚ K : ℝ)⁻¹ < s.re} with hD + have hDopen : IsOpen D := by rw [hD]; exact isOpen_lt continuous_const Complex.continuous_re + have hmemD : ∀ s : ℝ, 1 ≤ s → (s : ℂ) ∈ D := fun s hs ↦ by +- rw [hD]; simp only [Set.mem_setOf_eq, Complex.ofReal_re] ++ rw [hD]; simp only [Set.mem_ofPred_eq, Complex.ofReal_re] + have hfr : 0 < Module.finrank ℚ K := Module.finrank_pos + have : (0 : ℝ) < (Module.finrank ℚ K : ℝ)⁻¹ := by positivity + linarith +@@ -796,8 +796,8 @@ private theorem sum_charTwist_mul_twistedPrimeSum_eq + (Nat.card Gal(L/K) : ℂ) * (Ideal.absNorm 𝔭.1 : ℂ) ^ (-(s : ℂ)) else 0 := fun 𝔭 ↦ by + have := 𝔭.2.1 + by_cases h : frobeniusClass K L 𝔭.1 = ConjClasses.mk σ +- · rw [sum_charTwist_eq K L m σ 𝔭.1 𝔭.2.2 h, if_pos h] +- · rw [sum_charTwist_ne K L m σ 𝔭.1 𝔭.2.2 h, if_neg h, zero_mul] ++ · rw [sum_charTwist_eq K L m σ 𝔭.1 𝔭.2.2 h, ite_eq_left h] ++ · rw [sum_charTwist_ne K L m σ 𝔭.1 𝔭.2.2 h, ite_eq_right h, zero_mul] + have hfinj : Function.Injective + (fun 𝔭 : {𝔭 : Ideal (𝓞 K) // 𝔭 ∈ {𝔭 : Ideal (𝓞 K) | 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭 ∧ + frobeniusClass K L 𝔭 = ConjClasses.mk σ} ∧ 𝔭.IsPrime ∧ 𝔭 ≠ ⊥} ↦ +@@ -812,11 +812,11 @@ private theorem sum_charTwist_mul_twistedPrimeSum_eq + (f := fun 𝔭 : {𝔭 : Ideal (𝓞 K) // 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭} ↦ + if frobeniusClass K L 𝔭.1 = ConjClasses.mk σ then (Ideal.absNorm 𝔭.1 : ℝ) ^ (-s) else 0) + ?_] +- · exact tsum_congr fun 𝔭 ↦ (if_pos 𝔭.2.1.2.2).symm ++ · exact tsum_congr fun 𝔭 ↦ (ite_eq_left 𝔭.2.1.2.2).symm + · rintro 𝔭 h𝔭 + have h : frobeniusClass K L 𝔭.1 = ConjClasses.mk σ := by + by_contra hne +- exact h𝔭 (if_neg hne) ++ exact h𝔭 (ite_eq_right hne) + exact ⟨⟨𝔭.1, ⟨𝔭.2.1, 𝔭.2.2, h⟩, 𝔭.2.1, UnramifiedIn.ne_bot K L 𝔭.2.2⟩, rfl⟩ + rw [hinterchange, tsum_congr hcollapse, hfibre, Complex.ofReal_tsum, ← tsum_mul_left] + refine tsum_congr fun 𝔭 ↦ ?_ +diff --git a/projects/Chebotarev/CebotarevDensity/CyclotomicNormResidue.lean b/projects/Chebotarev/CebotarevDensity/CyclotomicNormResidue.lean +index 4cf9574ba..1bcb85b86 100644 +--- a/projects/Chebotarev/CebotarevDensity/CyclotomicNormResidue.lean ++++ b/projects/Chebotarev/CebotarevDensity/CyclotomicNormResidue.lean +@@ -56,7 +56,7 @@ theorem cyclotomic_frobenius_acts_as_norm_power + haveI : Finite (𝓞 L ⧸ 𝔓) := UnramifiedIn.finite_quotient K L hunr 𝔓 hP + ∀ ζ : L, ζ ∈ primitiveRoots m L → + arithFrobAt (𝓞 K) Gal(L/K) 𝔓 ζ = ζ ^ Ideal.absNorm 𝔭 := by +- haveI : Finite (𝓞 L ⧸ 𝔓) := UnramifiedIn.finite_quotient K L hunr 𝔓 hP ++ have : Finite (𝓞 L ⧸ 𝔓) := UnramifiedIn.finite_quotient K L hunr 𝔓 hP + intro ζ hζmem + set φ := arithFrobAt (𝓞 K) Gal(L/K) 𝔓 + have hζ : IsPrimitiveRoot ζ m := (mem_primitiveRoots (NeZero.pos m)).mp hζmem +@@ -64,9 +64,8 @@ theorem cyclotomic_frobenius_acts_as_norm_power + have hzc : (algebraMap (𝓞 L) L) z = ζ := rfl + have hzpow : z ^ m = 1 := hζ.toInteger_isPrimitiveRoot.pow_eq_one + set q := Ideal.absNorm 𝔭 +- have h𝔭ne : 𝔭 ≠ ⊥ := UnramifiedIn.ne_bot K L hunr + have hcopP : (Ideal.absNorm 𝔓).Coprime m := by +- rw [Ideal.absNorm_eq_pow_inertiaDeg'_of_liesOver 𝔓 𝔭 ‹𝔭.IsPrime› h𝔭ne] ++ rw [← Ideal.absNorm_pow_inertiaDeg 𝔭 𝔓] + exact Nat.Coprime.pow_left _ hcop + have hN1 : Ideal.absNorm 𝔓 ≠ 1 := fun h ↦ ‹𝔓.IsPrime›.ne_top (Ideal.absNorm_eq_one_iff.mp h) + have hmnotmem : (m : 𝓞 L) ∉ 𝔓 := by +@@ -92,7 +91,6 @@ private theorem pow_natModEq_of_pow_eq {S : Type*} [CommRing S] [IsDomain S] {μ + [NeZero n] (hμ : IsPrimitiveRoot μ n) {a b : ℕ} (h : μ ^ a = μ ^ b) : a ≡ b [MOD n] := + hμ.eq_orderOf ▸ (hμ.isOfFinOrder (NeZero.ne n)).pow_eq_pow_iff_modEq.mp h + +-set_option backward.isDefEq.respectTransparency false in + /-- **The cyclotomic Frobenius is the norm residue** (multiplicative form). For `L = K(μ_m)`, + a primitive `m`-th root `ζ` of unity in `L`, and a prime `𝔭` of `K` unramified in `L` with + `N𝔭` coprime to `m`, the cyclotomic character `IsPrimitiveRoot.autToPow` sends the Frobenius +@@ -105,15 +103,16 @@ theorem autToPow_frobeniusClass_out + hζ.autToPow K ((frobeniusClass K L 𝔭).out : L ≃ₐ[K] L) = + ZMod.unitOfCoprime (Ideal.absNorm 𝔭) hcop := by + obtain ⟨𝔓, h𝔓prime, h𝔓lo, _⟩ := exists_prime_liesOver K L 𝔭 (UnramifiedIn.ne_bot K L hunr) +- haveI := h𝔓prime +- haveI := h𝔓lo +- haveI : Finite (𝓞 L ⧸ 𝔓) := UnramifiedIn.finite_quotient K L hunr 𝔓 h𝔓lo ++ have := h𝔓prime ++ have := h𝔓lo ++ have : Finite (𝓞 L ⧸ 𝔓) := UnramifiedIn.finite_quotient K L hunr 𝔓 h𝔓lo + set φ : L ≃ₐ[K] L := arithFrobAt (𝓞 K) Gal(L/K) 𝔓 + have hclass : frobeniusClass K L 𝔭 = ConjClasses.mk φ := + frobeniusClass_eq_mk_of_isArithFrobAt K L 𝔭 hunr φ 𝔓 + (IsArithFrobAt.arithFrobAt (𝓞 K) Gal(L/K) 𝔓) h𝔓lo + have hconj : IsConj ((frobeniusClass K L 𝔭).out) φ := by +- rw [← ConjClasses.mk_eq_mk_iff_isConj, ← hclass, ConjClasses.mk, Quotient.out_eq] ++ apply ConjClasses.mk_eq_mk_iff_isConj.mp ++ exact (Quotient.out_eq (frobeniusClass K L 𝔭)).trans hclass + rw [isConj_iff_eq.mp ((hζ.autToPow K).map_isConj hconj)] + have hact : φ ζ = ζ ^ Ideal.absNorm 𝔭 := + cyclotomic_frobenius_acts_as_norm_power K L m 𝔭 hunr hcop 𝔓 h𝔓lo ζ +@@ -145,7 +144,7 @@ private theorem smul_algebraMap_eq + (σ : L ≃ₐ[K] L) (y : 𝓞 F) : + haveI : IsScalarTower K F L := F.isScalarTower_mid' + σ • (algebraMap (𝓞 F) (𝓞 L) y) = algebraMap (𝓞 F) (𝓞 L) ((σ.restrictNormal F) • y) := by +- haveI : IsScalarTower K F L := F.isScalarTower_mid' ++ have : IsScalarTower K F L := F.isScalarTower_mid' + have hbridgeL : ∀ (g : L ≃ₐ[K] L) (x : 𝓞 L), ((g • x : 𝓞 L) : L) = g • (x : L) := fun g x ↦ + by simpa [Algebra.smul_def] using + (smul_distrib_smul (G := L ≃ₐ[K] L) (R := 𝓞 L) (S := L) g x 1).symm +@@ -173,7 +172,7 @@ private theorem isArithFrobAt_restrictNormal + (𝔓 : Ideal (𝓞 L)) (hσ : IsArithFrobAt (𝓞 K) σ 𝔓) : + haveI : IsScalarTower K F L := F.isScalarTower_mid' + IsArithFrobAt (𝓞 K) (σ.restrictNormal F) (𝔓.under (𝓞 F)) := by +- haveI : IsScalarTower K F L := F.isScalarTower_mid' ++ have : IsScalarTower K F L := F.isScalarTower_mid' + intro y + rw [Ideal.under_under 𝔓, Ideal.under, Ideal.mem_comap, map_sub, map_pow, + show (MulSemiringAction.toAlgHom (𝓞 K) (𝓞 F) (σ.restrictNormal F)) y +@@ -188,21 +187,20 @@ private theorem unramifiedIn_intermediateField + (F : IntermediateField K L) [IsGalois K F] + (𝔭 : Ideal (𝓞 K)) (hunr : UnramifiedIn K L 𝔭) : + UnramifiedIn K (↥F) 𝔭 := by +- haveI : IsScalarTower K F L := F.isScalarTower_mid' +- haveI : IsScalarTower (𝓞 K) (𝓞 F) (𝓞 L) := inferInstance ++ have : IsScalarTower K F L := F.isScalarTower_mid' ++ have : IsScalarTower (𝓞 K) (𝓞 F) (𝓞 L) := inferInstance + refine ⟨hunr.1, fun 𝔮 h𝔮max h𝔮lo ↦ ?_⟩ +- haveI := h𝔮lo +- haveI := h𝔮max.isPrime ++ have := h𝔮lo ++ have := h𝔮max.isPrime + obtain ⟨𝔓, h𝔓prime, h𝔓lo, -⟩ := exists_prime_liesOver (↥F) L 𝔮 + (Ideal.ne_bot_of_liesOver_of_ne_bot hunr.1 𝔮) +- haveI := h𝔓prime +- haveI := h𝔓lo +- haveI : 𝔓.LiesOver 𝔭 := ⟨by rw [← Ideal.under_under (B := 𝓞 F) 𝔓, h𝔓lo.over.symm, h𝔮lo.over.symm]⟩ +- haveI : Algebra.IsUnramifiedAt (𝓞 K) 𝔓 := ++ have := h𝔓prime ++ have := h𝔓lo ++ have : 𝔓.LiesOver 𝔭 := ⟨by rw [← Ideal.under_under (B := 𝓞 F) 𝔓, h𝔓lo.over.symm, h𝔮lo.over.symm]⟩ ++ have : Algebra.IsUnramifiedAt (𝓞 K) 𝔓 := + hunr.2 𝔓 (h𝔓prime.isMaximal (Ideal.ne_bot_of_liesOver_of_ne_bot hunr.1 𝔓)) inferInstance + exact Algebra.IsUnramifiedAt.of_liesOver (𝓞 K) 𝔮 𝔓 + +-set_option backward.isDefEq.respectTransparency false in + /-- **Step (A): a Frobenius-trivial prime splits completely.** For `F = fixedField H` with `H` + abelian (hence normal) and a nonzero prime `𝔭` of `𝓞 K` unramified in `L` whose Frobenius + representative lies in `H`, the `F`-Frobenius class of `𝔭` is trivial: `frobeniusClass K F 𝔭 = [1]`. +@@ -220,19 +218,20 @@ private theorem frobeniusClass_fixedField_eq_one + IsGalois.of_fixedField_normal_subgroup H + frobeniusClass K (↥(IntermediateField.fixedField H)) 𝔭 = ConjClasses.mk 1 := by + set F := IntermediateField.fixedField H with hF +- haveI : IsScalarTower K F L := F.isScalarTower_mid' +- haveI : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H +- haveI : NumberField F := NumberField.of_intermediateField F ++ have : IsScalarTower K F L := F.isScalarTower_mid' ++ have : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H ++ have : NumberField F := NumberField.of_intermediateField F + obtain ⟨𝔓, h𝔓p, h𝔓lo, -⟩ := exists_prime_liesOver K L 𝔭 (UnramifiedIn.ne_bot K L hunr) +- haveI := h𝔓p +- haveI := h𝔓lo +- haveI : Finite (𝓞 L ⧸ 𝔓) := UnramifiedIn.finite_quotient K L hunr 𝔓 h𝔓lo ++ have := h𝔓p ++ have := h𝔓lo ++ have : Finite (𝓞 L ⧸ 𝔓) := UnramifiedIn.finite_quotient K L hunr 𝔓 h𝔓lo + set σ : L ≃ₐ[K] L := arithFrobAt (𝓞 K) Gal(L/K) 𝔓 + have hclass : frobeniusClass K L 𝔭 = ConjClasses.mk σ := + frobeniusClass_eq_mk_of_isArithFrobAt K L 𝔭 hunr σ 𝔓 + (IsArithFrobAt.arithFrobAt (𝓞 K) Gal(L/K) 𝔓) h𝔓lo + have hconj : IsConj σ ((frobeniusClass K L 𝔭).out) := by +- rw [← ConjClasses.mk_eq_mk_iff_isConj, hclass.symm, ConjClasses.mk, Quotient.out_eq] ++ apply ConjClasses.mk_eq_mk_iff_isConj.mp ++ exact hclass.symm.trans (Quotient.out_eq (frobeniusClass K L 𝔭)).symm + have hσeq : σ = (frobeniusClass K L 𝔭).out := by + obtain ⟨c, hc⟩ := hconj + rw [SemiconjBy, mul_comm' (c : Gal(L/K)) σ] at hc +@@ -244,7 +243,7 @@ private theorem frobeniusClass_fixedField_eq_one + MonoidHom.mem_ker.mp <| (IntermediateField.restrictNormalHom_ker F).ge hσfix + have h𝔮lo : (𝔓.under (𝓞 F)).LiesOver 𝔭 := + ⟨by rw [← Ideal.under_under (B := 𝓞 F) 𝔓]; exact h𝔓lo.over⟩ +- haveI := h𝔮lo ++ have := h𝔮lo + have hfrobF : IsArithFrobAt (𝓞 K) (σ.restrictNormal F) (𝔓.under (𝓞 F)) := + isArithFrobAt_restrictNormal K L F σ 𝔓 (IsArithFrobAt.arithFrobAt (𝓞 K) Gal(L/K) 𝔓) + rw [frobeniusClass_eq_mk_of_isArithFrobAt K (↥F) 𝔭 (unramifiedIn_intermediateField K L F 𝔭 hunr) +@@ -267,14 +266,14 @@ private theorem finrank_residue_fixedField_eq_one + ∀ 𝔮 : Ideal (𝓞 ↥(IntermediateField.fixedField H)), 𝔮.IsPrime → 𝔮.LiesOver 𝔭 → + Module.finrank (𝓞 K ⧸ 𝔮.under (𝓞 K)) (𝓞 ↥(IntermediateField.fixedField H) ⧸ 𝔮) = 1 := by + set F := IntermediateField.fixedField H +- haveI : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H +- haveI : NumberField F := NumberField.of_intermediateField F ++ have : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H ++ have : NumberField F := NumberField.of_intermediateField F + have hunrF : UnramifiedIn K (↥F) 𝔭 := unramifiedIn_intermediateField K L F 𝔭 hunr + have hfc : frobeniusClass K (↥F) 𝔭 = ConjClasses.mk (1 : Gal(↥F/K)) := + frobeniusClass_fixedField_eq_one K L H 𝔭 hunr hmem + intro 𝔮 h𝔮p h𝔮lo +- haveI := h𝔮p +- haveI := h𝔮lo ++ have := h𝔮p ++ have := h𝔮lo + rw [finrank_residue_eq_orderOf K (↥F) (1 : Gal(↥F/K)) (ConjClasses.mk 1) rfl 𝔭 hunrF hfc 𝔮 + h𝔮lo, orderOf_one] + +@@ -291,13 +290,13 @@ private theorem card_primesOver_fixedField_eq_finrank + 𝔮.IsPrime ∧ 𝔮.LiesOver 𝔭 ∧ 𝔮 ≠ ⊥} = + Module.finrank K ↥(IntermediateField.fixedField H) := by + set F := IntermediateField.fixedField H +- haveI : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H +- haveI : NumberField F := NumberField.of_intermediateField F ++ have : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H ++ have : NumberField F := NumberField.of_intermediateField F + have hunrF : UnramifiedIn K (↥F) 𝔭 := unramifiedIn_intermediateField K L F 𝔭 hunr + have hresdeg := finrank_residue_fixedField_eq_one K L H 𝔭 hunr hmem + obtain ⟨𝔮₀, h𝔮₀p, h𝔮₀lo, -⟩ := exists_prime_liesOver K (↥F) 𝔭 (UnramifiedIn.ne_bot K L hunr) +- haveI := h𝔮₀p +- haveI := h𝔮₀lo ++ have := h𝔮₀p ++ have := h𝔮₀lo + have hcard := card_primesAbove_mul_finrank_eq K (↥F) 𝔭 hunrF 𝔮₀ h𝔮₀lo + rw [hresdeg 𝔮₀ h𝔮₀p h𝔮₀lo, mul_one] at hcard + rw [hcard, IsGalois.card_aut_eq_finrank K (↥F)] +@@ -318,18 +317,19 @@ private theorem absNorm_eq_of_liesOver_fixedField + ∀ 𝔮 : Ideal (𝓞 ↥(IntermediateField.fixedField H)), 𝔮.IsPrime → 𝔮.LiesOver 𝔭 → + Ideal.absNorm 𝔮 = Ideal.absNorm 𝔭 := by + set F := IntermediateField.fixedField H +- haveI : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H +- haveI : NumberField F := NumberField.of_intermediateField F ++ have : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H ++ have : NumberField F := NumberField.of_intermediateField F + have hresdeg := finrank_residue_fixedField_eq_one K L H 𝔭 hunr hmem + intro 𝔮 h𝔮p h𝔮lo +- haveI := h𝔮p +- haveI := h𝔮lo +- have hinert : (𝔮.under (𝓞 K)).inertiaDeg' 𝔮 = 1 := by +- rw [Ideal.inertiaDeg'_algebraMap] ++ have := h𝔮p ++ have := h𝔮lo ++ have : 𝔭.IsMaximal := ‹𝔭.IsPrime›.isMaximal (UnramifiedIn.ne_bot K L hunr) ++ have : 𝔮.IsMaximal := Ideal.IsMaximal.of_liesOver_isMaximal 𝔮 𝔭 ++ have : (𝔮.under (𝓞 K)).IsMaximal := h𝔮lo.over ▸ ‹𝔭.IsMaximal› ++ have hinert : 𝔮.inertiaDeg (𝓞 K) = 1 := by ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (𝔮.under (𝓞 K)) 𝔮] + exact hresdeg 𝔮 h𝔮p h𝔮lo +- have hunder : 𝔮.under (𝓞 K) = 𝔭 := h𝔮lo.over.symm +- rw [Ideal.absNorm_eq_pow_inertiaDeg'_of_liesOver 𝔮 (𝔮.under (𝓞 K)) inferInstance +- (hunder ▸ UnramifiedIn.ne_bot K L hunr), hinert, pow_one, hunder] ++ rw [← Ideal.absNorm_pow_inertiaDeg 𝔭 𝔮, hinert, pow_one] + + /-! ### Coprime-restricted Frobenii generation + +@@ -409,8 +409,8 @@ private theorem finite_primesLiesOver_ne_bot (F : IntermediateField K L) [IsGalo + (𝔭 : Ideal (𝓞 K)) [𝔭.IsMaximal] : + haveI : NumberField F := NumberField.of_intermediateField F + Finite {𝔮 : Ideal (𝓞 ↥F) // 𝔮.IsPrime ∧ 𝔮.LiesOver 𝔭 ∧ 𝔮 ≠ ⊥} := by +- haveI : NumberField F := NumberField.of_intermediateField F +- haveI : Finite (𝔭.primesOver (𝓞 ↥F)) := ++ have : NumberField F := NumberField.of_intermediateField F ++ have : Finite (𝔭.primesOver (𝓞 ↥F)) := + (IsDedekindDomain.primesOver_finite 𝔭 (𝓞 ↥F)).to_subtype + refine Finite.of_injective (β := 𝔭.primesOver (𝓞 ↥F)) (fun y ↦ ⟨y.1, y.2.1, y.2.2.1⟩) + fun a b hab ↦ Subtype.ext ?_ +@@ -436,8 +436,8 @@ private theorem primeIdealZetaSum_under_eq_finrank_mul [IsMulCommutative Gal(L/K + = (Module.finrank K ↥(IntermediateField.fixedField H) : ℝ) * primeIdealZetaSum + {𝔭 : Ideal (𝓞 K) | 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭 ∧ (Ideal.absNorm 𝔭).Coprime m} s := by + set F := IntermediateField.fixedField H +- haveI : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H +- haveI : NumberField F := NumberField.of_intermediateField F ++ have : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H ++ have : NumberField F := NumberField.of_intermediateField F + set U : Set (Ideal (𝓞 K)) := + {𝔭 | 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭 ∧ (Ideal.absNorm 𝔭).Coprime m} + set V : Set (Ideal (𝓞 F)) := +@@ -446,9 +446,9 @@ private theorem primeIdealZetaSum_under_eq_finrank_mul [IsMulCommutative Gal(L/K + set IV := {𝔮 : Ideal (𝓞 F) // 𝔮 ∈ V ∧ 𝔮.IsPrime ∧ 𝔮 ≠ ⊥} + have hφ_mem : ∀ 𝔮 : IV, (𝔮.1.under (𝓞 K)) ∈ U ∧ (𝔮.1.under (𝓞 K)).IsPrime + ∧ (𝔮.1.under (𝓞 K)) ≠ ⊥ := fun 𝔮 ↦ by +- haveI := 𝔮.2.2.1 ++ have := 𝔮.2.2.1 + exact ⟨⟨inferInstance, 𝔮.2.1.2.1, 𝔮.2.1.2.2⟩, inferInstance, +- Ideal.IsIntegral.comap_ne_bot (𝓞 K) 𝔮.2.2.2⟩ ++ Ideal.IsIntegral.under_ne_bot (𝓞 K) 𝔮.2.2.2⟩ + set φ : IV → IU := fun 𝔮 ↦ ⟨𝔮.1.under (𝓞 K), hφ_mem 𝔮⟩ + set e := Equiv.sigmaFiberEquiv φ + have hsummSig : Summable (fun p : Σ 𝔭 : IU, {𝔮 : IV // φ 𝔮 = 𝔭} ↦ +@@ -458,13 +458,13 @@ private theorem primeIdealZetaSum_under_eq_finrank_mul [IsMulCommutative Gal(L/K + rw [primeIdealZetaSum_def, ← e.tsum_eq (fun 𝔮 : IV ↦ (Ideal.absNorm (𝔮.1) : ℝ) ^ (-s)), + hsummSig.tsum_sigma, primeIdealZetaSum_def, ← tsum_mul_left] + refine tsum_congr (fun 𝔭 ↦ ?_) +- haveI := 𝔭.2.2.1 ++ have := 𝔭.2.2.1 + have hfibeq : {𝔮 : IV // φ 𝔮 = 𝔭} ≃ + {𝔮 : Ideal (𝓞 F) // 𝔮.IsPrime ∧ 𝔮.LiesOver 𝔭.1 ∧ 𝔮 ≠ ⊥} := + { toFun := fun x ↦ ⟨x.1.1, x.1.2.2.1, ⟨(Subtype.ext_iff.mp x.2).symm⟩, x.1.2.2.2⟩ + invFun := fun y ↦ ⟨⟨y.1, ⟨y.2.1, by +- haveI := y.2.1 +- haveI := y.2.2.1 ++ have := y.2.1 ++ have := y.2.2.1 + exact (y.2.2.1.over ▸ 𝔭.2.1.2 : UnramifiedIn K L (y.1.under (𝓞 K)) ∧ + (Ideal.absNorm (y.1.under (𝓞 K))).Coprime m)⟩, y.2.1, y.2.2.2⟩, + Subtype.ext (haveI := y.2.2.1; y.2.2.1.over.symm)⟩ +@@ -474,10 +474,10 @@ private theorem primeIdealZetaSum_under_eq_finrank_mul [IsMulCommutative Gal(L/K + = (Ideal.absNorm 𝔭.1 : ℝ) ^ (-s) := fun x ↦ by + change (Ideal.absNorm x.1.1 : ℝ) ^ (-s) = (Ideal.absNorm 𝔭.1 : ℝ) ^ (-s) + rw [(hsplit 𝔭.1 𝔭.2.2.1 𝔭.2.1.2.1 𝔭.2.1.2.2).2 x.1.1 x.1.2.2.1 ⟨(Subtype.ext_iff.mp x.2).symm⟩] +- haveI : 𝔭.1.IsMaximal := 𝔭.2.2.1.isMaximal 𝔭.2.2.2 +- haveI : Finite {𝔮 : Ideal (𝓞 F) // 𝔮.IsPrime ∧ 𝔮.LiesOver 𝔭.1 ∧ 𝔮 ≠ ⊥} := ++ have : 𝔭.1.IsMaximal := 𝔭.2.2.1.isMaximal 𝔭.2.2.2 ++ have : Finite {𝔮 : Ideal (𝓞 F) // 𝔮.IsPrime ∧ 𝔮.LiesOver 𝔭.1 ∧ 𝔮 ≠ ⊥} := + finite_primesLiesOver_ne_bot K L F 𝔭.1 +- haveI : Finite {𝔮 : IV // φ 𝔮 = 𝔭} := Finite.of_equiv _ hfibeq.symm ++ have : Finite {𝔮 : IV // φ 𝔮 = 𝔭} := Finite.of_equiv _ hfibeq.symm + rw [tsum_congr hconst, tsum_const, Nat.card_congr hfibeq, + (hsplit 𝔭.1 𝔭.2.2.1 𝔭.2.1.2.1 𝔭.2.1.2.2).1, nsmul_eq_mul, mul_comm] + +@@ -498,8 +498,8 @@ private theorem finrank_mul_unramified_coprime_le_univ + {𝔭 : Ideal (𝓞 K) | 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭 ∧ (Ideal.absNorm 𝔭).Coprime m} s + ≤ primeIdealZetaSum (Set.univ : Set (Ideal (𝓞 ↥(IntermediateField.fixedField H)))) s := by + set F := IntermediateField.fixedField H +- haveI : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H +- haveI : NumberField F := NumberField.of_intermediateField F ++ have : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H ++ have : NumberField F := NumberField.of_intermediateField F + have hsplit : ∀ 𝔭 : Ideal (𝓞 K), 𝔭.IsPrime → UnramifiedIn K L 𝔭 → (Ideal.absNorm 𝔭).Coprime m → + Nat.card {𝔮 : Ideal (𝓞 F) // 𝔮.IsPrime ∧ 𝔮.LiesOver 𝔭 ∧ 𝔮 ≠ ⊥} = Module.finrank K ↥F + ∧ ∀ 𝔮 : Ideal (𝓞 F), 𝔮.IsPrime → 𝔮.LiesOver 𝔭 → Ideal.absNorm 𝔮 = Ideal.absNorm 𝔭 := +@@ -522,8 +522,8 @@ private theorem finrank_fixedField_le_one_of_forall_frobenius_mem_of_coprime + (Ideal.absNorm 𝔭).Coprime m → ((frobeniusClass K L 𝔭).out : L ≃ₐ[K] L) ∈ H) : + Module.finrank K (IntermediateField.fixedField H) ≤ 1 := by + set F := IntermediateField.fixedField H +- haveI : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H +- haveI : NumberField F := NumberField.of_intermediateField F ++ have : IsGalois K F := IsGalois.of_fixedField_normal_subgroup H ++ have : NumberField F := NumberField.of_intermediateField F + set d : ℕ := Module.finrank K ↥F + rw [← Nat.cast_le (α := ℝ), Nat.cast_one] + set A : ℝ → ℝ := fun s ↦ primeIdealZetaSum +diff --git a/projects/Chebotarev/CebotarevDensity/FixedFieldDensity.lean b/projects/Chebotarev/CebotarevDensity/FixedFieldDensity.lean +index 7d40bad6a..33f8b2367 100644 +--- a/projects/Chebotarev/CebotarevDensity/FixedFieldDensity.lean ++++ b/projects/Chebotarev/CebotarevDensity/FixedFieldDensity.lean +@@ -1,8 +1,9 @@ + module + + public import Mathlib.RingTheory.Ideal.Over +-public import Mathlib.NumberTheory.RamificationInertia.Basic ++public import Mathlib.RingTheory.RamificationInertia.Basic + public import CebotarevDensity.Cyclotomic ++public import CebotarevDensity.ForMathlib.TsumFiberBound + + /-! + # Density transfer through a fixed-field subextension (Sharifi 7.2.2 Step 1) +@@ -65,18 +66,18 @@ theorem frobeniusFibre_card_eq_of_isConj + simp only [MulAction.toPerm_apply] + constructor + · rintro ⟨hp, hP, hne, hfrob⟩ +- haveI := hp +- haveI := hP ++ have := hp ++ have := hP + refine ⟨inferInstance, inferInstance, ?_, ?_⟩ + · rw [← Ideal.smul_bot c] + exact (MulAction.injective c).ne hne + · exact hc ▸ hfrob.conj c + · rintro ⟨hp, hP, hne, hfrob⟩ +- haveI := hp +- haveI := hP ++ have := hp ++ have := hP + have hsmul : c⁻¹ • (c • 𝔓) = 𝔓 := inv_smul_smul c 𝔓 +- haveI hp' : 𝔓.IsPrime := hsmul ▸ (inferInstance : (c⁻¹ • (c • 𝔓)).IsPrime) +- haveI hP' : 𝔓.LiesOver 𝔭 := hsmul ▸ (inferInstance : (c⁻¹ • (c • 𝔓)).LiesOver 𝔭) ++ have hp' : 𝔓.IsPrime := hsmul ▸ (inferInstance : (c⁻¹ • (c • 𝔓)).IsPrime) ++ have hP' : 𝔓.LiesOver 𝔭 := hsmul ▸ (inferInstance : (c⁻¹ • (c • 𝔓)).LiesOver 𝔭) + have hne' : 𝔓 ≠ ⊥ := by + rw [← hsmul, ← Ideal.smul_bot c⁻¹] + exact (MulAction.injective c⁻¹).ne hne +@@ -84,7 +85,6 @@ theorem frobeniusFibre_card_eq_of_isConj + have hconj := hfrob.conj c⁻¹ + rwa [hsmul, ← hc, show c⁻¹ * (c * σ * c⁻¹) * c⁻¹⁻¹ = σ by group] at hconj + +-set_option backward.isDefEq.respectTransparency false in + /-- **Balanced fibre count.** If every prime above `𝔭` has Frobenius in the class `C = [σ]` + and conjugate Frobenius values occur equally often (`hequi`), the total number of primes + above `𝔭` is `|C|` times the number with `Frob_𝔓 = σ`: partition by the (class-`C`-valued) +@@ -103,21 +103,21 @@ theorem card_primesAbove_eq_card_carrier_mul_frobeniusFibre + * Nat.card {𝔓 : Ideal (𝓞 L) // ∃ (_ : 𝔓.IsPrime) (_ : 𝔓.LiesOver 𝔭) (_ : 𝔓 ≠ ⊥), + IsArithFrobAt (𝓞 K) σ 𝔓} := by + have hpbot : 𝔭 ≠ ⊥ := UnramifiedIn.ne_bot K L hunr +- haveI : 𝔭.IsMaximal := ‹𝔭.IsPrime›.isMaximal hpbot +- haveI : Finite (𝔭.primesOver (𝓞 L)) := (IsDedekindDomain.primesOver_finite 𝔭 (𝓞 L)).to_subtype +- haveI : Finite {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} := ++ have : 𝔭.IsMaximal := ‹𝔭.IsPrime›.isMaximal hpbot ++ have : Finite (𝔭.primesOver (𝓞 L)) := (IsDedekindDomain.primesOver_finite 𝔭 (𝓞 L)).to_subtype ++ have : Finite {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} := + Finite.of_injective + (fun 𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} ↦ + (⟨𝔓.1, 𝔓.2.1, 𝔓.2.2.1⟩ : 𝔭.primesOver (𝓞 L))) +- fun _ _ hab ↦ Subtype.ext (by simpa using hab) +- haveI : Fintype C.carrier := Fintype.ofFinite _ ++ fun _ _ hab ↦ Subtype.ext (congrArg (fun q : 𝔭.primesOver (𝓞 L) ↦ q.1) hab) ++ have : Fintype C.carrier := Fintype.ofFinite _ + have hfinP : ∀ (𝔓 : Ideal (𝓞 L)) [𝔓.IsPrime] (hP : 𝔓.LiesOver 𝔭), Finite (𝓞 L ⧸ 𝔓) := + fun 𝔓 _ hP ↦ UnramifiedIn.finite_quotient K L hunr 𝔓 hP + have hmem : ∀ (𝔓 : Ideal (𝓞 L)) [𝔓.IsPrime] (hP : 𝔓.LiesOver 𝔭), + haveI := hfinP 𝔓 hP + arithFrobAt (𝓞 K) Gal(L/K) 𝔓 ∈ C.carrier := by + intro 𝔓 _ hP +- haveI := hfinP 𝔓 hP ++ have := hfinP 𝔓 hP + rw [ConjClasses.mem_carrier_iff_mk_eq, ← frobeniusClass_eq_mk_of_isArithFrobAt K L 𝔭 hunr _ 𝔓 + (IsArithFrobAt.arithFrobAt (𝓞 K) Gal(L/K) 𝔓) hP, hCfrob] + have hconj : ∀ g : C.carrier, IsConj σ g.1 := by +@@ -138,18 +138,18 @@ theorem card_primesAbove_eq_card_carrier_mul_frobeniusFibre + refine Nat.card_congr ⟨fun x ↦ ⟨x.1.1, x.1.2.1, x.1.2.2.1, x.1.2.2.2, ?_⟩, + fun x ↦ ⟨⟨x.1, by obtain ⟨hp, hP, hne, _⟩ := x.2; exact ⟨hp, hP, hne⟩⟩, ?_⟩, + fun _ ↦ rfl, fun _ ↦ rfl⟩ +- · haveI := x.1.2.1 +- haveI := hfinP x.1.1 x.1.2.2.1 ++ · have := x.1.2.1 ++ have := hfinP x.1.1 x.1.2.2.1 + rw [← Subtype.ext_iff.mp x.2] + exact IsArithFrobAt.arithFrobAt (𝓞 K) Gal(L/K) x.1.1 + · obtain ⟨hp, hP, hne, hg⟩ := x.2 +- haveI := hp +- haveI := hP +- haveI := hfinP x.1 hP +- haveI : Algebra.IsUnramifiedAt (𝓞 K) x.1 := ++ have := hp ++ have := hP ++ have := hfinP x.1 hP ++ have : Algebra.IsUnramifiedAt (𝓞 K) x.1 := + Ideal.ramificationIdx_eq_one_iff.mp + ((Ideal.ramificationIdx'_eq_ramificationIdx (x.1.under (𝓞 K)) x.1 +- (Ideal.IsIntegral.comap_ne_bot (𝓞 K) hne)).symm.trans ++ (Ideal.IsIntegral.under_ne_bot (𝓞 K) hne)).symm.trans + (UnramifiedIn.ramificationIdx_eq_one K L hunr x.1 hP)) + exact Subtype.ext (eq_arithFrobAt_of_isArithFrobAt K L x.1 g.1 hg).symm + simp_rw [hfib] +@@ -239,11 +239,11 @@ theorem arithFrobAt_restrictScalars_eq (E : IntermediateField K L) + Ideal.finiteQuotientOfFreeOfNeBot 𝔓 (ne_bot_of_ramificationIdx_eq_one K L hunrK) + haveI : IsGalois (↥E) L := IsGalois.tower_top_intermediateField E + (arithFrobAt (𝓞 ↥E) Gal(L/(↥E)) 𝔓).restrictScalars K = arithFrobAt (𝓞 K) Gal(L/K) 𝔓 := by +- haveI : IsScalarTower K ↥E L := E.isScalarTower_mid' +- haveI : IsGalois (↥E) L := IsGalois.tower_top_intermediateField E +- haveI : IsGaloisGroup Gal(L/(↥E)) (↥E) L := IsGaloisGroup.of_isGalois (↥E) L +- haveI hPbot : 𝔓 ≠ ⊥ := ne_bot_of_ramificationIdx_eq_one K L hunrK +- haveI : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot ++ have : IsScalarTower K ↥E L := E.isScalarTower_mid' ++ have : IsGalois (↥E) L := IsGalois.tower_top_intermediateField E ++ have : IsGaloisGroup Gal(L/(↥E)) (↥E) L := IsGaloisGroup.of_isGalois (↥E) L ++ have hPbot : 𝔓 ≠ ⊥ := ne_bot_of_ramificationIdx_eq_one K L hunrK ++ have : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot + set σE := arithFrobAt (𝓞 ↥E) Gal(L/(↥E)) 𝔓 with hσE + have hKfrob1 : IsArithFrobAt (𝓞 K) (σE.restrictScalars K) 𝔓 := by + intro x +@@ -279,28 +279,29 @@ private theorem stabilizer_intermediate_eq_top_of_frobenius + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' + MulAction.stabilizer + Gal(L/↥(IntermediateField.fixedField (Subgroup.zpowers σ))) 𝔓 = ⊤ := by +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' + have hraK := UnramifiedIn.ramificationIdx_eq_one K L hunrK 𝔓 hPK + have hPbot : 𝔓 ≠ ⊥ := ne_bot_of_ramificationIdx_eq_one K L hraK + have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := UnramifiedIn.ne_bot K L hunrK +- haveI : 𝔓.IsMaximal := ‹𝔓.IsPrime›.isMaximal hPbot +- haveI : (𝔓.under (𝓞 K)).IsMaximal := ++ have : 𝔓.IsMaximal := ‹𝔓.IsPrime›.isMaximal hPbot ++ have : (𝔓.under (𝓞 K)).IsMaximal := + (inferInstance : (𝔓.under (𝓞 K)).IsPrime).isMaximal hpbot +- haveI : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot +- haveI : Algebra.IsSeparable (𝓞 K ⧸ 𝔓.under (𝓞 K)) (𝓞 L ⧸ 𝔓) := by +- letI : Field (𝓞 K ⧸ 𝔓.under (𝓞 K)) := Ideal.Quotient.field _ +- letI : Field (𝓞 L ⧸ 𝔓) := Ideal.Quotient.field _ ++ have : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot ++ have : Algebra.IsSeparable (𝓞 K ⧸ 𝔓.under (𝓞 K)) (𝓞 L ⧸ 𝔓) := by ++ let : Field (𝓞 K ⧸ 𝔓.under (𝓞 K)) := Ideal.Quotient.field _ ++ let : Field (𝓞 L ⧸ 𝔓) := Ideal.Quotient.field _ + exact IsGalois.to_isSeparable + have hmem : σ ∈ MulAction.stabilizer Gal(L/K) 𝔓 := hfrob.mem_stabilizer +- have hinertK : (𝔓.under (𝓞 K)).inertiaDeg' 𝔓 = orderOf σ := by +- rw [Ideal.inertiaDeg'_algebraMap, orderOf_eq_finrank_of_isArithFrobAt K L σ 𝔓 hraK hfrob] ++ have hinertK : 𝔓.inertiaDeg (𝓞 K) = orderOf σ := by ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (𝔓.under (𝓞 K)) 𝔓, ++ orderOf_eq_finrank_of_isArithFrobAt K L σ 𝔓 hraK hfrob] + have hcardstab' : Nat.card (MulAction.stabilizer Gal(L/K) 𝔓) = orderOf σ := by + rw [Ideal.card_stabilizer_eq (𝔓.under (𝓞 K)) 𝔓, + Ideal.ramificationIdxIn_eq_ramificationIdx (𝔓.under (𝓞 K)) 𝔓 Gal(L/K), + ← Ideal.ramificationIdx'_eq_ramificationIdx (𝔓.under (𝓞 K)) 𝔓 hpbot, hraK, one_mul, + Ideal.inertiaDegIn_eq_inertiaDeg (𝔓.under (𝓞 K)) 𝔓 Gal(L/K), +- ← Ideal.inertiaDeg'_eq_inertiaDeg (𝔓.under (𝓞 K)) 𝔓, hinertK] ++ hinertK] + have hstab : Subgroup.zpowers σ = MulAction.stabilizer Gal(L/K) 𝔓 := + Subgroup.eq_of_le_of_card_ge (by rwa [Subgroup.zpowers_le]) + (by rw [Nat.card_zpowers, hcardstab']) +@@ -331,34 +332,33 @@ private theorem inertiaDeg_under_E_eq_one_of_frobenius + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' + Ideal.ramificationIdx' + (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) 𝔓 = 1 +- ∧ (𝔓.under (𝓞 K)).inertiaDeg' +- (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) = 1 ++ ∧ (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).inertiaDeg (𝓞 K) = 1 + ∧ Nat.card (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) + ⧸ 𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) + = Nat.card (𝓞 K ⧸ 𝔓.under (𝓞 K)) := by + set E := IntermediateField.fixedField (Subgroup.zpowers σ) with hE +- haveI : IsScalarTower K ↥E L := E.isScalarTower_mid' +- haveI : IsGalois (↥E) L := IsGalois.tower_top_intermediateField _ ++ have : IsScalarTower K ↥E L := E.isScalarTower_mid' ++ have : IsGalois (↥E) L := IsGalois.tower_top_intermediateField _ + have hraK := UnramifiedIn.ramificationIdx_eq_one K L hunrK 𝔓 hPK + have hPbot : 𝔓 ≠ ⊥ := ne_bot_of_ramificationIdx_eq_one K L hraK + have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := UnramifiedIn.ne_bot K L hunrK +- haveI : 𝔓.IsMaximal := ‹𝔓.IsPrime›.isMaximal hPbot +- haveI : (𝔓.under (𝓞 K)).IsMaximal := ++ have : 𝔓.IsMaximal := ‹𝔓.IsPrime›.isMaximal hPbot ++ have : (𝔓.under (𝓞 K)).IsMaximal := + (inferInstance : (𝔓.under (𝓞 K)).IsPrime).isMaximal hpbot +- haveI : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot +- haveI hPEp : (𝔓.under (𝓞 ↥E)).IsPrime := inferInstance +- haveI hPK' : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) +- haveI hPEK : (𝔓.under (𝓞 ↥E)).LiesOver (𝔓.under (𝓞 K)) := inferInstance +- haveI hPPE : 𝔓.LiesOver (𝔓.under (𝓞 ↥E)) := Ideal.over_under (A := 𝓞 ↥E) (P := 𝔓) +- have hpEbot : 𝔓.under (𝓞 ↥E) ≠ ⊥ := Ideal.IsIntegral.comap_ne_bot (𝓞 ↥E) hPbot +- haveI : (𝔓.under (𝓞 ↥E)).IsMaximal := hPEp.isMaximal hpEbot ++ have : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot ++ have hPEp : (𝔓.under (𝓞 ↥E)).IsPrime := inferInstance ++ have hPK' : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) ++ have hPEK : (𝔓.under (𝓞 ↥E)).LiesOver (𝔓.under (𝓞 K)) := inferInstance ++ have hPPE : 𝔓.LiesOver (𝔓.under (𝓞 ↥E)) := Ideal.over_under (A := 𝓞 ↥E) (P := 𝔓) ++ have hpEbot : 𝔓.under (𝓞 ↥E) ≠ ⊥ := Ideal.IsIntegral.under_ne_bot (𝓞 ↥E) hPbot ++ have : (𝔓.under (𝓞 ↥E)).IsMaximal := hPEp.isMaximal hpEbot + have hraE : Ideal.ramificationIdx' (𝔓.under (𝓞 ↥E)) 𝔓 = 1 := by + have htower := Ideal.ramificationIdx'_algebra_tower' (𝔓.under (𝓞 K)) (𝔓.under (𝓞 ↥E)) 𝔓 + rw [hraK] at htower + exact Nat.eq_one_of_mul_eq_one_left htower.symm +- haveI : Algebra.IsSeparable (𝓞 ↥E ⧸ 𝔓.under (𝓞 ↥E)) (𝓞 L ⧸ 𝔓) := by +- letI : Field (𝓞 ↥E ⧸ 𝔓.under (𝓞 ↥E)) := Ideal.Quotient.field _ +- letI : Field (𝓞 L ⧸ 𝔓) := Ideal.Quotient.field _ ++ have : Algebra.IsSeparable (𝓞 ↥E ⧸ 𝔓.under (𝓞 ↥E)) (𝓞 L ⧸ 𝔓) := by ++ let : Field (𝓞 ↥E ⧸ 𝔓.under (𝓞 ↥E)) := Ideal.Quotient.field _ ++ let : Field (𝓞 L ⧸ 𝔓) := Ideal.Quotient.field _ + exact IsGalois.to_isSeparable + have hstabE : MulAction.stabilizer Gal(L/(↥E)) 𝔓 = ⊤ := + stabilizer_intermediate_eq_top_of_frobenius σ 𝔓 hunrK hPK hfrob horderE +@@ -369,26 +369,25 @@ private theorem inertiaDeg_under_E_eq_one_of_frobenius + Ideal.ramificationIdxIn_eq_ramificationIdx (𝔓.under (𝓞 ↥E)) 𝔓 Gal(L/(↥E)), + ← Ideal.ramificationIdx'_eq_ramificationIdx (𝔓.under (𝓞 ↥E)) 𝔓 hpEbot, hraE, one_mul, + Ideal.inertiaDegIn_eq_inertiaDeg (𝔓.under (𝓞 ↥E)) 𝔓 Gal(L/(↥E)), +- ← Ideal.inertiaDeg'_eq_inertiaDeg (𝔓.under (𝓞 ↥E)) 𝔓, +- Ideal.inertiaDeg'_algebraMap] at hcardE +- have hinertTower : (𝔓.under (𝓞 K)).inertiaDeg' 𝔓 +- = (𝔓.under (𝓞 K)).inertiaDeg' (𝔓.under (𝓞 ↥E)) +- * (𝔓.under (𝓞 ↥E)).inertiaDeg' 𝔓 := +- Ideal.inertiaDeg'_algebra_tower (𝔓.under (𝓞 K)) (𝔓.under (𝓞 ↥E)) 𝔓 +- have hinertK : (𝔓.under (𝓞 K)).inertiaDeg' 𝔓 = orderOf σ := by +- rw [Ideal.inertiaDeg'_algebraMap, orderOf_eq_finrank_of_isArithFrobAt K L σ 𝔓 hraK hfrob] +- have hfPE : (𝔓.under (𝓞 ↥E)).inertiaDeg' 𝔓 = orderOf σ := by +- rw [Ideal.inertiaDeg'_algebraMap, ← hcardE, horderE] ++ Ideal.inertiaDeg_eq_of_isMaximal (𝔓.under (𝓞 ↥E)) 𝔓] at hcardE ++ have hinertTower : 𝔓.inertiaDeg (𝓞 K) ++ = (𝔓.under (𝓞 ↥E)).inertiaDeg (𝓞 K) ++ * 𝔓.inertiaDeg (𝓞 ↥E) := ++ Ideal.inertiaDeg_tower (R := 𝓞 K) (𝔓.under (𝓞 ↥E)) 𝔓 ++ have hinertK : 𝔓.inertiaDeg (𝓞 K) = orderOf σ := by ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (𝔓.under (𝓞 K)) 𝔓, ++ orderOf_eq_finrank_of_isArithFrobAt K L σ 𝔓 hraK hfrob] ++ have hfPE : 𝔓.inertiaDeg (𝓞 ↥E) = orderOf σ := by ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (𝔓.under (𝓞 ↥E)) 𝔓, ← hcardE, horderE] + have hpos : 0 < orderOf σ := orderOf_pos_iff.mpr (isOfFinOrder_of_finite σ) +- have hinertPK : (𝔓.under (𝓞 K)).inertiaDeg' (𝔓.under (𝓞 ↥E)) = 1 := by ++ have hinertPK : (𝔓.under (𝓞 ↥E)).inertiaDeg (𝓞 K) = 1 := by + rw [hinertK, hfPE] at hinertTower + exact Nat.eq_of_mul_eq_mul_right hpos (by rw [one_mul]; exact hinertTower.symm) + refine ⟨hraE, hinertPK, ?_⟩ + have hnormP : Nat.card (𝓞 ↥E ⧸ 𝔓.under (𝓞 ↥E)) +- = Nat.card (𝓞 K ⧸ 𝔓.under (𝓞 K)) ^ (𝔓.under (𝓞 K)).inertiaDeg' (𝔓.under (𝓞 ↥E)) := by ++ = Nat.card (𝓞 K ⧸ 𝔓.under (𝓞 K)) ^ (𝔓.under (𝓞 ↥E)).inertiaDeg (𝓞 K) := by + simpa [Submodule.cardQuot_apply, Ideal.absNorm_apply] using +- Ideal.absNorm_eq_pow_inertiaDeg'_of_liesOver (𝔓.under (𝓞 ↥E)) (𝔓.under (𝓞 K)) +- inferInstance hpbot ++ (Ideal.absNorm_pow_inertiaDeg (𝔓.under (𝓞 K)) (𝔓.under (𝓞 ↥E))).symm + rw [hnormP, hinertPK, pow_one] + + open scoped Pointwise in +@@ -405,15 +404,15 @@ private theorem eq_of_liesOver_under_E_of_frobenius + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' + 𝔔.LiesOver (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))))) : + 𝔔 = 𝔓 := by +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := ++ have : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := + IsGalois.tower_top_intermediateField _ +- haveI : IsGaloisGroup Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) ++ have : IsGaloisGroup Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) + (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := IsGaloisGroup.of_isGalois _ L + set E := IntermediateField.fixedField (Subgroup.zpowers σ) with hE +- haveI := hQ +- haveI : 𝔓.LiesOver (𝔓.under (𝓞 ↥E)) := Ideal.over_under (A := 𝓞 ↥E) (P := 𝔓) ++ have := hQ ++ have : 𝔓.LiesOver (𝔓.under (𝓞 ↥E)) := Ideal.over_under (A := 𝓞 ↥E) (P := 𝔓) + have hstabE : MulAction.stabilizer Gal(L/(↥E)) 𝔓 = ⊤ := + stabilizer_intermediate_eq_top_of_frobenius σ 𝔓 hunrK hPK hfrob horderE + obtain ⟨τ, hτ⟩ := Ideal.exists_smul_eq_of_isGaloisGroup (𝔓.under (𝓞 ↥E)) 𝔓 𝔔 Gal(L/(↥E)) +@@ -446,18 +445,18 @@ private theorem arithFrobAt_E_eq_of_isArithFrobAt + IsGalois.tower_top_intermediateField _ + arithFrobAt (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) + Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) 𝔓 = σE := by +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := ++ have : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := + IsGalois.tower_top_intermediateField _ + have hraK : Ideal.ramificationIdx' (𝔓.under (𝓞 K)) 𝔓 = 1 := + UnramifiedIn.ramificationIdx_eq_one K L hunrK 𝔓 hPK + have hPbot : 𝔓 ≠ ⊥ := ne_bot_of_ramificationIdx_eq_one K L hraK +- haveI : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot +- haveI : Algebra.IsUnramifiedAt (𝓞 K) 𝔓 := ++ have : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot ++ have : Algebra.IsUnramifiedAt (𝓞 K) 𝔓 := + Ideal.ramificationIdx_eq_one_iff.mp + ((Ideal.ramificationIdx'_eq_ramificationIdx (𝔓.under (𝓞 K)) 𝔓 +- (Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPbot)).symm.trans hraK) ++ (Ideal.IsIntegral.under_ne_bot (𝓞 K) hPbot)).symm.trans hraK) + have hbridge := arithFrobAt_restrictScalars_eq + (IntermediateField.fixedField (Subgroup.zpowers σ)) 𝔓 hraK hraE hnorm + rw [(eq_arithFrobAt_of_isArithFrobAt K L 𝔓 σ hfrob).symm] at hbridge +@@ -480,49 +479,47 @@ private theorem exists_arithFrobAt_over_fibrePrime + (hPunr : UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P) + (hPfrob : frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P + = ConjClasses.mk σE) +- (hPdeg : (P.under (𝓞 K)).inertiaDeg' P = 1) (hPbot : P ≠ ⊥) : ++ (hPdeg : P.inertiaDeg (𝓞 K) = 1) (hPbot : P ≠ ⊥) : + ∃ (𝔓 : Ideal (𝓞 L)) (_ : 𝔓.IsPrime) (_ : 𝔓.LiesOver P) (_ : 𝔓 ≠ ⊥), + 𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) = P ∧ + IsArithFrobAt (𝓞 K) σ 𝔓 := by +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := ++ have : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := + IsGalois.tower_top_intermediateField _ + obtain ⟨𝔓, h𝔓p, h𝔓lo, h𝔓bot⟩ := exists_prime_liesOver + (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L P hPbot +- haveI := h𝔓p +- haveI := h𝔓lo ++ have := h𝔓p ++ have := h𝔓lo + have hPeq : 𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) = P := + h𝔓lo.over.symm +- haveI hPPE : 𝔓.LiesOver (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := ++ have hPPE : 𝔓.LiesOver (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := + Ideal.over_under (A := 𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) (P := 𝔓) + have hunderK : 𝔓.under (𝓞 K) = P.under (𝓞 K) := by + rw [← Ideal.under_under (B := 𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) 𝔓, hPeq] + have hunrK : UnramifiedIn K L (𝔓.under (𝓞 K)) := hunderK ▸ hunrP +- haveI : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) +- have hinertPK1 : (𝔓.under (𝓞 K)).inertiaDeg' +- (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) = 1 := by +- rw [hPeq, hunderK] ++ have : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) ++ have hinertPK1 : (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).inertiaDeg (𝓞 K) = 1 := by ++ rw [hPeq] + exact hPdeg + have hraE : Ideal.ramificationIdx' + (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) 𝔓 = 1 := + (Ideal.ramificationIdx'_eq_ramificationIdx + (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) 𝔓 +- (Ideal.IsIntegral.comap_ne_bot _ h𝔓bot)).trans ++ (Ideal.IsIntegral.under_ne_bot _ h𝔓bot)).trans + (Ideal.ramificationIdx_eq_one_iff.mpr + (hPunr.2 𝔓 (h𝔓p.isMaximal h𝔓bot) (hPeq ▸ hPPE))) + have hnorm : Nat.card (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) + ⧸ 𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) + = Nat.card (𝓞 K ⧸ 𝔓.under (𝓞 K)) := by +- have hnP := Ideal.absNorm_eq_pow_inertiaDeg'_of_liesOver +- (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) (𝔓.under (𝓞 K)) +- inferInstance (UnramifiedIn.ne_bot K L hunrK) ++ have hnP := (Ideal.absNorm_pow_inertiaDeg (𝔓.under (𝓞 K)) ++ (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))))).symm + simp only [Submodule.cardQuot_apply, Ideal.absNorm_apply] at hnP ⊢ + rw [hnP, hinertPK1, pow_one] +- haveI : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 h𝔓bot ++ have : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 h𝔓bot + have hfrEeqσE : arithFrobAt (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) + Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) 𝔓 = σE := by +- letI : CommMonoid Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := ++ let : CommMonoid Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := + IsMulCommutative.instCommMonoid + have hcl := frobeniusClass_eq_mk_of_isArithFrobAt + (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L P hPunr _ 𝔓 +@@ -560,40 +557,40 @@ private theorem under_E_mem_fibre_of_isArithFrobAt + {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) | + P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P ∧ + frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P +- = ConjClasses.mk σE ∧ (P.under (𝓞 K)).inertiaDeg' P = 1} ++ = ConjClasses.mk σE ∧ P.inertiaDeg (𝓞 K) = 1} + ∧ (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).LiesOver 𝔭 + ∧ (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) ≠ ⊥ := by +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := ++ have : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := + IsGalois.tower_top_intermediateField _ +- haveI := hP ++ have := hP + have hunderK : 𝔓.under (𝓞 K) = 𝔭 := hP.over.symm + have hunrK : UnramifiedIn K L (𝔓.under (𝓞 K)) := hunderK ▸ hunr +- haveI : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) +- haveI : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot ++ have : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) ++ have : Finite (𝓞 L ⧸ 𝔓) := Ideal.finiteQuotientOfFreeOfNeBot 𝔓 hPbot + obtain ⟨hraE, hinPK, hnorm⟩ := + inertiaDeg_under_E_eq_one_of_frobenius σ 𝔓 hunrK inferInstance hfrob horderE + have hfrE := arithFrobAt_E_eq_of_isArithFrobAt σ σE hσE 𝔓 hunrK inferInstance hfrob horderE + hraE hnorm + have hunram : UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L + (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := by +- refine ⟨Ideal.IsIntegral.comap_ne_bot _ hPbot, fun 𝔔 h𝔔max h𝔔lo ↦ ?_⟩ +- haveI := h𝔔max.isPrime ++ refine ⟨Ideal.IsIntegral.under_ne_bot _ hPbot, fun 𝔔 h𝔔max h𝔔lo ↦ ?_⟩ ++ have := h𝔔max.isPrime + have h𝔔eq : 𝔔 = 𝔓 := eq_of_liesOver_under_E_of_frobenius σ 𝔓 hunrK inferInstance hfrob + horderE 𝔔 h𝔔lo + subst h𝔔eq + exact Ideal.ramificationIdx_eq_one_iff.mp + ((Ideal.ramificationIdx'_eq_ramificationIdx + (𝔔.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) 𝔔 +- (Ideal.IsIntegral.comap_ne_bot _ hPbot)).symm.trans hraE) +- haveI hPEK : (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).LiesOver 𝔭 := by +- haveI : (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).LiesOver ++ (Ideal.IsIntegral.under_ne_bot _ hPbot)).symm.trans hraE) ++ have hPEK : (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).LiesOver 𝔭 := by ++ have : (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).LiesOver + (𝔓.under (𝓞 K)) := inferInstance + rwa [hunderK] at this +- haveI hPPE : 𝔓.LiesOver (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := ++ have hPPE : 𝔓.LiesOver (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := + Ideal.over_under (A := 𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) (P := 𝔓) +- refine ⟨⟨inferInstance, hunram, ?_, ?_⟩, hPEK, Ideal.IsIntegral.comap_ne_bot _ hPbot⟩ ++ refine ⟨⟨inferInstance, hunram, ?_, ?_⟩, hPEK, Ideal.IsIntegral.under_ne_bot _ hPbot⟩ + · rw [frobeniusClass_eq_mk_of_isArithFrobAt + (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) + L (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) hunram _ 𝔓 +@@ -601,9 +598,7 @@ private theorem under_E_mem_fibre_of_isArithFrobAt + Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) 𝔓) hPPE, + ConjClasses.mk_eq_mk_iff_isConj] + exact isConj_iff.mpr ⟨1, by simp [hfrE]⟩ +- · rw [show (𝔓.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))).under (𝓞 K) +- = 𝔓.under (𝓞 K) from Ideal.under_under 𝔓] +- exact hinPK ++ · exact hinPK + + /-- **Fibre bijection: degree-one `E`-primes with Frobenius `σ_E` ↔ `L`-primes with + Frobenius `σ`** (Sharifi 7.2.2 p. 143). For a prime `𝔭` of `𝓞 K` unramified in `L` with +@@ -628,12 +623,12 @@ private theorem card_fibre_E_eq_card_fibre_L + P ∈ {P | P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P + ∧ frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P + = ConjClasses.mk σE +- ∧ (P.under (𝓞 K)).inertiaDeg' P = 1} ∧ P.LiesOver 𝔭 ∧ P ≠ ⊥} ++ ∧ P.inertiaDeg (𝓞 K) = 1} ∧ P.LiesOver 𝔭 ∧ P ≠ ⊥} + = Nat.card {𝔓 : Ideal (𝓞 L) // ∃ (_ : 𝔓.IsPrime) (_ : 𝔓.LiesOver 𝔭) (_ : 𝔓 ≠ ⊥), + IsArithFrobAt (𝓞 K) σ 𝔓} := by +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := ++ have : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := + IsGalois.tower_top_intermediateField _ + refine (Nat.card_congr (Equiv.ofBijective + (fun 𝔓 ↦ ⟨𝔓.1.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))), +@@ -641,37 +636,37 @@ private theorem card_fibre_E_eq_card_fibre_L + exact under_E_mem_fibre_of_isArithFrobAt σ σE hσE horderE 𝔭 hunr 𝔓.1 hP hPbot hfrob⟩) + ⟨?_, ?_⟩)).symm + · rintro ⟨𝔓₁, h𝔓₁, hP₁, hP₁bot, hfrob₁⟩ ⟨𝔓₂, h𝔓₂, hP₂, hP₂bot, hfrob₂⟩ hΦ +- haveI := h𝔓₁ +- haveI := h𝔓₂ +- haveI := hP₁ +- haveI := hP₂ ++ have := h𝔓₁ ++ have := h𝔓₂ ++ have := hP₁ ++ have := hP₂ + have hunderK₁ : 𝔓₁.under (𝓞 K) = 𝔭 := hP₁.over.symm + have hunrK₁ : UnramifiedIn K L (𝔓₁.under (𝓞 K)) := hunderK₁ ▸ hunr +- haveI : 𝔓₁.LiesOver (𝔓₁.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓₁) ++ have : 𝔓₁.LiesOver (𝔓₁.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓₁) + have hΦ' : 𝔓₂.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) + = 𝔓₁.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) := + congrArg Subtype.val hΦ |>.symm +- haveI hP₂lo : 𝔓₂.LiesOver ++ have hP₂lo : 𝔓₂.LiesOver + (𝔓₁.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := by +- haveI : 𝔓₂.LiesOver ++ have : 𝔓₂.LiesOver + (𝔓₂.under (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := + Ideal.over_under (A := 𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) (P := 𝔓₂) + rwa [hΦ'] at this + exact Subtype.ext (eq_of_liesOver_under_E_of_frobenius σ 𝔓₁ hunrK₁ inferInstance hfrob₁ + horderE 𝔓₂ hP₂lo).symm + · rintro ⟨P, ⟨hPp, hPunr, hPfrob, hPdeg⟩, hPlo, hPbot⟩ +- haveI := hPp +- haveI := hPlo ++ have := hPp ++ have := hPlo + have hunrP : UnramifiedIn K L (P.under (𝓞 K)) := hPlo.over.symm ▸ hunr + obtain ⟨𝔓, h𝔓p, h𝔓lo, h𝔓bot, hPeq, hfrobK⟩ := + exists_arithFrobAt_over_fibrePrime σ σE hσE P hunrP hPunr hPfrob hPdeg hPbot +- haveI := h𝔓p +- haveI := h𝔓lo ++ have := h𝔓p ++ have := h𝔓lo + have hunderK : 𝔓.under (𝓞 K) = 𝔭 := by + rw [← Ideal.under_under (B := 𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) 𝔓, + hPeq] + exact hPlo.over.symm +- haveI hPK𝔓 : 𝔓.LiesOver 𝔭 := hunderK ▸ Ideal.over_under (A := 𝓞 K) (P := 𝔓) ++ have hPK𝔓 : 𝔓.LiesOver 𝔭 := hunderK ▸ Ideal.over_under (A := 𝓞 K) (P := 𝔓) + exact ⟨⟨𝔓, h𝔓p, hPK𝔓, h𝔓bot, hfrobK⟩, Subtype.ext hPeq⟩ + + /-- **A degree-one fibre prime has `K`-Frobenius class `[σ]`** (Sharifi 7.2.2 p. 143). If `P` +@@ -690,18 +685,18 @@ private theorem frobeniusClass_under_eq_of_mem_fibre + (hPunr : UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P) + (hPfrob : frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P + = ConjClasses.mk σE) +- (hPdeg : (P.under (𝓞 K)).inertiaDeg' P = 1) (hPbot : P ≠ ⊥) : ++ (hPdeg : P.inertiaDeg (𝓞 K) = 1) (hPbot : P ≠ ⊥) : + frobeniusClass K L (P.under (𝓞 K)) = ConjClasses.mk σ := by +- haveI : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := ++ have : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := + IsGalois.tower_top_intermediateField _ + obtain ⟨𝔓, h𝔓p, h𝔓lo, h𝔓bot, hPeq, hfrobK⟩ := + exists_arithFrobAt_over_fibrePrime σ σE hσE P hunrP hPunr hPfrob hPdeg hPbot +- haveI := h𝔓p +- haveI := h𝔓lo ++ have := h𝔓p ++ have := h𝔓lo + have hunderK : P.under (𝓞 K) = 𝔓.under (𝓞 K) := by + rw [← hPeq, Ideal.under_under] + have hunrK : UnramifiedIn K L (𝔓.under (𝓞 K)) := hunderK ▸ hunrP +- haveI : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) ++ have : 𝔓.LiesOver (𝔓.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓) + rw [hunderK, + frobeniusClass_eq_mk_of_isArithFrobAt K L (𝔓.under (𝓞 K)) hunrK _ 𝔓 hfrobK inferInstance] + +@@ -715,8 +710,8 @@ private theorem tsum_comp_eq_card_fibre_smul {β γ : Type*} (g : β → γ) (h + ∑' b, h (g b) = c * ∑' y, h y := by + rw [← (hsumm.hasSum.tsum_fiberwise g).tsum_eq, ← tsum_mul_left] + refine tsum_congr fun y ↦ ?_ +- haveI := hfin y +- letI := Fintype.ofFinite (g ⁻¹' {y} : Set β) ++ have := hfin y ++ let := Fintype.ofFinite (g ⁻¹' {y} : Set β) + rw [tsum_congr fun b : (g ⁻¹' {y} : Set β) ↦ congrArg h b.2, tsum_fintype, Finset.sum_const, + Finset.card_univ, ← Nat.card_eq_fintype_card, nsmul_eq_mul, hcard, mul_comm] + +@@ -738,13 +733,12 @@ private theorem card_fibre_T1_over_prime + Nat.card {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) // + P ∈ {P | P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P + ∧ frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P +- = ConjClasses.mk σE ∧ (P.under (𝓞 K)).inertiaDeg' P = 1} ++ = ConjClasses.mk σE ∧ P.inertiaDeg (𝓞 K) = 1} + ∧ P.LiesOver 𝔭 ∧ P ≠ ⊥} + = Nat.card Gal(L/K) := by + rw [card_fibre_E_eq_card_fibre_L σ σE hσE horderE 𝔭 hunr𝔭 hfrob𝔭, mul_comm, ← mul_assoc] + exact count_primes_above_with_frobenius_eq_sigma K L σ (ConjClasses.mk σ) rfl 𝔭 hunr𝔭 hfrob𝔭 + +-set_option backward.isDefEq.respectTransparency false in + /-- **LEAF A: the degree-one part of `T` carries the main term** (Sharifi 7.2.2 p. 143). For + `1 < s`, the partial Dirichlet sum over the set `T₁` of degree-one (over `K`) primes `P` of + `𝓞 E` above an unramified-in-`L` prime, with `Frob^E_P = [σ_E]`, equals `|G|/(f·|C|)` times the +@@ -767,26 +761,26 @@ private theorem primeIdealZetaSum_fibre_eq_smul + {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) | + P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P ∧ + frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P +- = ConjClasses.mk σE ∧ (P.under (𝓞 K)).inertiaDeg' P = 1 ∧ ++ = ConjClasses.mk σE ∧ P.inertiaDeg (𝓞 K) = 1 ∧ + UnramifiedIn K L (P.under (𝓞 K))} s + = ((Nat.card Gal(L/K) : ℝ) / (orderOf σ * Nat.card (ConjClasses.mk σ).carrier)) + * primeIdealZetaSum {𝔭 : Ideal (𝓞 K) | 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭 ∧ + frobeniusClass K L 𝔭 = ConjClasses.mk σ} s := by +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := ++ have : IsGalois (↥(IntermediateField.fixedField (Subgroup.zpowers σ))) L := + IsGalois.tower_top_intermediateField _ + set Sset := {𝔭 : Ideal (𝓞 K) | 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭 ∧ + frobeniusClass K L 𝔭 = ConjClasses.mk σ} with hSset + set T₁set := {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) | + P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P ∧ + frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P = ConjClasses.mk σE ∧ +- (P.under (𝓞 K)).inertiaDeg' P = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))} with hT₁set ++ P.inertiaDeg (𝓞 K) = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))} with hT₁set + set S' := {𝔭 : Ideal (𝓞 K) // 𝔭 ∈ Sset ∧ 𝔭.IsPrime ∧ 𝔭 ≠ ⊥} with hS' + have hgmem : ∀ P : {P // P ∈ T₁set ∧ P.IsPrime ∧ P ≠ ⊥}, + P.1.under (𝓞 K) ∈ Sset ∧ (P.1.under (𝓞 K)).IsPrime ∧ P.1.under (𝓞 K) ≠ ⊥ := by + rintro ⟨P, ⟨hPp, hPunr, hPfrob, hPdeg, hunrP⟩, _, hPbot⟩ +- haveI := hPp ++ have := hPp + refine ⟨⟨inferInstance, hunrP, ?_⟩, inferInstance, UnramifiedIn.ne_bot K L hunrP⟩ + exact frobeniusClass_under_eq_of_mem_fibre σ σE hσE horderE P hunrP hPunr hPfrob hPdeg hPbot + set g : {P // P ∈ T₁set ∧ P.IsPrime ∧ P ≠ ⊥} → S' := +@@ -794,28 +788,28 @@ private theorem primeIdealZetaSum_fibre_eq_smul + have hnormeq : ∀ P : {P // P ∈ T₁set ∧ P.IsPrime ∧ P ≠ ⊥}, + (Ideal.absNorm P.1 : ℝ) = (Ideal.absNorm (P.1.under (𝓞 K)) : ℝ) := by + rintro ⟨P, ⟨hPp, _, _, hPdeg, _⟩, _, hPbot⟩ +- haveI := hPp +- have hpbot : P.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPbot +- haveI : P.LiesOver (P.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := P) +- have hpow := Ideal.absNorm_eq_pow_inertiaDeg'_of_liesOver P (P.under (𝓞 K)) inferInstance hpbot ++ have := hPp ++ have hpbot : P.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.under_ne_bot (𝓞 K) hPbot ++ have : P.LiesOver (P.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := P) ++ have hpow := (Ideal.absNorm_pow_inertiaDeg (P.under (𝓞 K)) P).symm + rw [hPdeg, pow_one] at hpow + rw [hpow] + have hcardfib : ∀ 𝔭 : S', (orderOf σ * Nat.card (ConjClasses.mk σ).carrier) * + Nat.card {P : {P // P ∈ T₁set ∧ P.IsPrime ∧ P ≠ ⊥} // g P = 𝔭} = Nat.card Gal(L/K) := by + intro 𝔭 + obtain ⟨hp𝔭, hunr𝔭, hfrob𝔭⟩ := 𝔭.2.1 +- haveI := hp𝔭 ++ have := hp𝔭 + have hreindex : Nat.card {P : {P // P ∈ T₁set ∧ P.IsPrime ∧ P ≠ ⊥} // g P = 𝔭} + = Nat.card {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) // + P ∈ {P | P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) + L P ∧ frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P +- = ConjClasses.mk σE ∧ (P.under (𝓞 K)).inertiaDeg' P = 1} ++ = ConjClasses.mk σE ∧ P.inertiaDeg (𝓞 K) = 1} + ∧ P.LiesOver 𝔭.1 ∧ P ≠ ⊥} := by + refine Nat.card_congr ⟨fun x ↦ ⟨x.1.1, ?_, ?_, x.1.2.2.2⟩, + fun y ↦ ⟨⟨y.1, ?_, y.2.1.1, y.2.2.2⟩, ?_⟩, fun _ ↦ rfl, fun _ ↦ rfl⟩ + · exact ⟨x.1.2.1.1, x.1.2.1.2.1, x.1.2.1.2.2.1, x.1.2.1.2.2.2.1⟩ + · exact ⟨(congrArg Subtype.val x.2).symm ▸ (Ideal.over_under (A := 𝓞 K) (P := x.1.1)).over⟩ +- · haveI := y.2.1.1 ++ · have := y.2.1.1 + have hunderK : y.1.under (𝓞 K) = 𝔭.1 := (y.2.2.1).over.symm + exact ⟨y.2.1.1, y.2.1.2.1, y.2.1.2.2.1, y.2.1.2.2.2, by rw [hunderK]; exact hunr𝔭⟩ + · exact Subtype.ext (y.2.2.1).over.symm +@@ -823,18 +817,20 @@ private theorem primeIdealZetaSum_fibre_eq_smul + exact card_fibre_T1_over_prime σ σE hσE horderE 𝔭.1 hunr𝔭 hfrob𝔭 + have hfibfin : ∀ 𝔭 : S', Finite {P : {P // P ∈ T₁set ∧ P.IsPrime ∧ P ≠ ⊥} // g P = 𝔭} := by + intro 𝔭 +- haveI := 𝔭.2.2.1 +- haveI : 𝔭.1.IsMaximal := 𝔭.2.2.1.isMaximal 𝔭.2.2.2 +- haveI : Finite (𝔭.1.primesOver ++ have := 𝔭.2.2.1 ++ have : 𝔭.1.IsMaximal := 𝔭.2.2.1.isMaximal 𝔭.2.2.2 ++ have : Finite (𝔭.1.primesOver + (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := + (IsDedekindDomain.primesOver_finite 𝔭.1 _).to_subtype + refine Finite.of_injective (β := 𝔭.1.primesOver + (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) + (fun P ↦ ⟨P.1.1, P.1.2.2.1, ?_⟩) ?_ +- · haveI := P.1.2.2.1 ++ · have := P.1.2.2.1 + exact ⟨(congrArg Subtype.val P.2).symm ▸ (Ideal.over_under (A := 𝓞 K) (P := P.1.1)).over⟩ + · rintro ⟨⟨P, hP⟩, hgP⟩ ⟨⟨Q, hQ⟩, hgQ⟩ hPQ +- simpa using hPQ ++ exact Subtype.ext (Subtype.ext (congrArg ++ (fun q : 𝔭.1.primesOver ++ (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) ↦ q.1) hPQ)) + have hordC_pos : (0 : ℝ) < orderOf σ * Nat.card (ConjClasses.mk σ).carrier := by + have h₁ : 0 < orderOf σ := orderOf_pos_iff.mpr (isOfFinOrder_of_finite σ) + have : Nonempty (ConjClasses.mk σ).carrier := ⟨⟨σ, ConjClasses.mem_carrier_mk⟩⟩ +@@ -871,83 +867,55 @@ most `[E:K]` primes of `𝓞 E` above it, by `Ideal.card_primesOverFinset_le_fin + over `B` is bounded by the finite cardinality of `B`. Both are constants in `s`, so + `Σ_{T₂} s ≤ C` for all `s > 1`, whence `Σ_{T₂}/Σ_univ^E → 0` since `Σ_univ^E → ∞`. -/ + +-/-- **Fibre-counting bound for `ℝ≥0∞`-valued sums.** If every fibre `g ⁻¹' {y}` is finite with at +-most `d` elements, then `Σ_b f(g b) ≤ d · Σ_y f y`: group `b` by its image `g b`, on each fibre +-the summand is the constant `f y`, and the fibre has `≤ d` terms. -/ +-private theorem tsum_comp_le_card_fibre_mul {β γ : Type*} (g : β → γ) (f : γ → ℝ≥0∞) (d : ℕ) +- (hfin : ∀ y, Finite (g ⁻¹' {y} : Set β)) (hfib : ∀ y, Nat.card (g ⁻¹' {y} : Set β) ≤ d) : +- ∑' b, f (g b) ≤ (d : ℝ≥0∞) * ∑' y, f y := by +- rw [← ENNReal.tsum_fiberwise (fun b ↦ f (g b)) g, ← ENNReal.tsum_mul_left] +- refine ENNReal.tsum_le_tsum (fun y ↦ ?_) +- rw [tsum_congr (fun b : (g ⁻¹' {y} : Set β) ↦ by rw [b.2])] +- haveI := hfin y +- letI := Fintype.ofFinite (g ⁻¹' {y} : Set β) +- rw [tsum_fintype, Finset.sum_const, Finset.card_univ, ← Nat.card_eq_fintype_card, nsmul_eq_mul] +- gcongr +- exact_mod_cast hfib y +- +-/-- **Fibre-counting bound for real-valued sums.** The `ℝ`-valued companion of +-`tsum_comp_le_card_fibre_mul`: for nonnegative summable `FA, FK` with `FA b ≤ FK (g b)` and every +-fibre `g ⁻¹' {y}` finite of size `≤ d`, the sum `Σ_b FA b` is at most `d · Σ_y FK y`. -/ +-private theorem tsum_real_comp_le_card_fibre_mul {β γ : Type*} (g : β → γ) (FA : β → ℝ) +- (FK : γ → ℝ) (d : ℕ) (hsummA : Summable FA) (hsummK : Summable FK) (hnonnegA : ∀ b, 0 ≤ FA b) +- (hnonnegK : ∀ y, 0 ≤ FK y) (hterm : ∀ b, FA b ≤ FK (g b)) +- (hfin : ∀ y, Finite (g ⁻¹' {y} : Set β)) (hfib : ∀ y, Nat.card (g ⁻¹' {y} : Set β) ≤ d) : +- ∑' b, FA b ≤ (d : ℝ) * ∑' y, FK y := by +- have hchain : ∑' b, ENNReal.ofReal (FA b) +- ≤ (d : ℝ≥0∞) * ∑' y, ENNReal.ofReal (FK y) := +- calc ∑' b, ENNReal.ofReal (FA b) ≤ ∑' b, ENNReal.ofReal (FK (g b)) := +- ENNReal.tsum_le_tsum fun b ↦ ENNReal.ofReal_le_ofReal (hterm b) +- _ ≤ (d : ℝ≥0∞) * ∑' y, ENNReal.ofReal (FK y) := +- tsum_comp_le_card_fibre_mul g (ENNReal.ofReal <| FK ·) d hfin hfib +- rw [← ENNReal.ofReal_tsum_of_nonneg hnonnegA hsummA, +- ← ENNReal.ofReal_tsum_of_nonneg hnonnegK hsummK] at hchain +- rw [← ENNReal.toReal_ofReal (tsum_nonneg hnonnegA), +- ← ENNReal.toReal_ofReal (mul_nonneg (Nat.cast_nonneg d) (tsum_nonneg hnonnegK)), +- ENNReal.ofReal_mul (Nat.cast_nonneg d), ENNReal.ofReal_natCast] +- exact ENNReal.toReal_mono (ENNReal.mul_ne_top (by simp) ENNReal.ofReal_ne_top) hchain +- + omit [IsGalois K L] in + /-- For a degree-`≥ 2` prime `P` of `𝓞 E` over `𝔭 = P ∩ 𝓞 K`, the Dirichlet term is dominated by + the square term of `𝔭`: `N P^{-s} ≤ N𝔭^{-2}` for `1 < s`. Here `N P = N𝔭^{f}` with `f ≥ 2` and + `N𝔭 ≥ 2`, so the exponent `f·s ≥ 2` dominates. -/ + private theorem absNorm_rpow_neg_le_under_sq (σ : Gal(L/K)) + (P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) [P.IsPrime] +- (hPb : P ≠ ⊥) {s : ℝ} (hs : 1 < s) (hdeg : 2 ≤ (P.under (𝓞 K)).inertiaDeg' P) : ++ (hPb : P ≠ ⊥) {s : ℝ} (hs : 1 < s) (hdeg : 2 ≤ P.inertiaDeg (𝓞 K)) : + (Ideal.absNorm P : ℝ) ^ (-s) ≤ (Ideal.absNorm (P.under (𝓞 K)) : ℝ) ^ (-(2 : ℝ)) := by + have hppr : (P.under (𝓞 K)).IsPrime := inferInstance +- have hpbot : P.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPb +- haveI : P.LiesOver (P.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := P) +- have hpow := Ideal.absNorm_eq_pow_inertiaDeg'_of_liesOver P (P.under (𝓞 K)) hppr hpbot ++ have hpbot : P.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.under_ne_bot (𝓞 K) hPb ++ have : P.LiesOver (P.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := P) ++ have hpow := (Ideal.absNorm_pow_inertiaDeg (P.under (𝓞 K)) P).symm + have hn2 : 2 ≤ Ideal.absNorm (P.under (𝓞 K)) := by + have h0 : Ideal.absNorm (P.under (𝓞 K)) ≠ 0 := Ideal.absNorm_eq_zero_iff.not.mpr hpbot + have h1 : Ideal.absNorm (P.under (𝓞 K)) ≠ 1 := Ideal.absNorm_eq_one_iff.not.mpr hppr.ne_top + omega + rw [hpow, Nat.cast_pow, +- ← Real.rpow_natCast (Ideal.absNorm (P.under (𝓞 K)) : ℝ) ((P.under (𝓞 K)).inertiaDeg' P), ++ ← Real.rpow_natCast (Ideal.absNorm (P.under (𝓞 K)) : ℝ) (P.inertiaDeg (𝓞 K)), + ← Real.rpow_mul (by positivity)] + refine Real.rpow_le_rpow_of_exponent_le (by exact_mod_cast Nat.one_le_of_lt hn2) ?_ +- nlinarith [mul_le_mul (show (2 : ℝ) ≤ ((P.under (𝓞 K)).inertiaDeg' P : ℝ) by exact_mod_cast hdeg) +- hs.le (by norm_num) (by positivity : (0 : ℝ) ≤ ((P.under (𝓞 K)).inertiaDeg' P : ℝ))] ++ nlinarith [mul_le_mul (show (2 : ℝ) ≤ (P.inertiaDeg (𝓞 K) : ℝ) by exact_mod_cast hdeg) ++ hs.le (by norm_num) (by positivity : (0 : ℝ) ≤ (P.inertiaDeg (𝓞 K) : ℝ))] + + omit [IsGalois K L] in + /-- The number of primes of `𝓞 E` over a fixed maximal prime `𝔭` of `𝓞 K` is at most `[E : K]`, + a `Nat.card` repackaging of `Ideal.card_primesOverFinset_le_finrank`. -/ + private theorem card_primesOver_le_finrank (σ : Gal(L/K)) + [NoZeroSMulDivisors (𝓞 K) (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))] +- (𝔭 : Ideal (𝓞 K)) [𝔭.IsMaximal] (h𝔭 : 𝔭 ≠ ⊥) : ++ (𝔭 : Ideal (𝓞 K)) [𝔭.IsMaximal] (_h𝔭 : 𝔭 ≠ ⊥) : + Nat.card {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) // + P.IsPrime ∧ P.LiesOver 𝔭} + ≤ Module.finrank K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) := by +- letI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := +- (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- rw [show {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) // +- P.IsPrime ∧ P.LiesOver 𝔭} +- = ↥(𝔭.primesOver (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) from rfl, +- Nat.card_coe_set_eq, ← IsDedekindDomain.coe_primesOverFinset h𝔭, Set.ncard_coe_finset] +- exact Ideal.card_primesOverFinset_le_finrank (R := 𝓞 K) +- (S := 𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) +- (K := K) (L := ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) h𝔭 ++ classical ++ let E := IntermediateField.fixedField (Subgroup.zpowers σ) ++ let : IsScalarTower K ↥E L := E.isScalarTower_mid' ++ let : Finite (𝔭.primesOver (𝓞 ↥E)) := ++ (IsDedekindDomain.primesOver_finite 𝔭 (𝓞 ↥E)).to_subtype ++ let : Fintype (𝔭.primesOver (𝓞 ↥E)) := Fintype.ofFinite _ ++ change Nat.card (𝔭.primesOver (𝓞 ↥E)) ≤ Module.finrank K ↥E ++ calc ++ Nat.card (𝔭.primesOver (𝓞 ↥E)) = ∑ _q : 𝔭.primesOver (𝓞 ↥E), (1 : ℕ) := by ++ simp [Nat.card_eq_fintype_card] ++ _ ≤ ∑ q : 𝔭.primesOver (𝓞 ↥E), q.1.ramificationIdx (𝓞 K) * q.1.inertiaDeg (𝓞 K) := by ++ apply Finset.sum_le_sum ++ intro q _ ++ have : q.1.IsPrime := q.2.1 ++ exact Nat.mul_pos (Ideal.ramificationIdx_pos q.1 (𝓞 K)) (Ideal.inertiaDeg_pos q.1 (𝓞 K)) ++ _ = Module.finrank (𝓞 K) (𝓞 ↥E) := Ideal.sum_ramification_inertia_eq_finrank 𝔭 (𝓞 ↥E) ++ _ = Module.finrank K ↥E := (IsFractionRing.finrank_eq (𝓞 K) K (𝓞 ↥E) ↥E).symm + + /-- **The degree-`≥ 2` part of `T₂` is bounded by a constant.** For `1 < s`, the partial sum over + the set `A` of primes `P` of `𝓞 E` whose underlying `K`-prime is unramified in `L` but of inertia +@@ -958,13 +926,13 @@ degree `≥ 2` is bounded by `[E:K]·Σ_𝔭 N𝔭^{-2}`. Indeed `N P = N𝔭^{f + private theorem primeIdealZetaSum_degTwo_le (σ : Gal(L/K)) {s : ℝ} + (hs : 1 < s) (Aset : Set (Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))))) + (hA : Aset = {P | P.IsPrime ∧ P ≠ ⊥ ∧ +- UnramifiedIn K L (P.under (𝓞 K)) ∧ 2 ≤ (P.under (𝓞 K)).inertiaDeg' P}) : ++ UnramifiedIn K L (P.under (𝓞 K)) ∧ 2 ≤ P.inertiaDeg (𝓞 K)}) : + primeIdealZetaSum Aset s + ≤ (Module.finrank K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) : ℝ) + * primeIdealZetaSum (univ : Set (Ideal (𝓞 K))) 2 := by +- letI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ let : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : NoZeroSMulDivisors (𝓞 K) ++ have : NoZeroSMulDivisors (𝓞 K) + (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) := + ⟨fun {c x} h ↦ by + rw [Algebra.smul_def, mul_eq_zero] at h +@@ -974,24 +942,24 @@ private theorem primeIdealZetaSum_degTwo_le (σ : Gal(L/K)) {s : ℝ} + set KP := {𝔭 : Ideal (𝓞 K) // 𝔭 ∈ (univ : Set (Ideal (𝓞 K))) ∧ 𝔭.IsPrime ∧ 𝔭 ≠ ⊥} with hKP + have hunder : ∀ P : AP, (P.1.under (𝓞 K)).IsPrime ∧ P.1.under (𝓞 K) ≠ ⊥ := by + rintro ⟨P, hPA, hPp, hPb⟩ +- haveI := hPp +- exact ⟨inferInstance, Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPb⟩ ++ have := hPp ++ exact ⟨inferInstance, Ideal.IsIntegral.under_ne_bot (𝓞 K) hPb⟩ + set g : AP → KP := fun P ↦ ⟨P.1.under (𝓞 K), mem_univ _, (hunder P).1, (hunder P).2⟩ with hg + have hterm : ∀ P : AP, (Ideal.absNorm P.1 : ℝ) ^ (-s) + ≤ (Ideal.absNorm (g P).1 : ℝ) ^ (-(2 : ℝ)) := by + rintro ⟨P, hPA, hPp, hPb⟩ +- haveI := hPp ++ have := hPp + rw [hA] at hPA + exact absNorm_rpow_neg_le_under_sq σ P hPb hs hPA.2.2.2 + have hinj : ∀ 𝔭 : KP, Finite (g ⁻¹' {𝔭} : Set AP) ∧ + Nat.card (g ⁻¹' {𝔭} : Set AP) + ≤ Module.finrank K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) := by + intro 𝔭 +- haveI := 𝔭.2.2.1 +- haveI : 𝔭.1.IsMaximal := 𝔭.2.2.1.isMaximal 𝔭.2.2.2 ++ have := 𝔭.2.2.1 ++ have : 𝔭.1.IsMaximal := 𝔭.2.2.1.isMaximal 𝔭.2.2.2 + have hmem : ∀ P : (g ⁻¹' {𝔭} : Set AP), P.1.1.IsPrime ∧ P.1.1.LiesOver 𝔭.1 := by + rintro ⟨⟨P, hPA, hPp, hPb⟩, hgP⟩ +- haveI := hPp ++ have := hPp + exact ⟨hPp, ⟨(congrArg Subtype.val hgP : P.under (𝓞 K) = 𝔭.1) ▸ + (Ideal.over_under (A := 𝓞 K) (P := P)).over⟩⟩ + set hmap : (g ⁻¹' {𝔭} : Set AP) → {P : Ideal (𝓞 ↥(IntermediateField.fixedField +@@ -999,7 +967,7 @@ private theorem primeIdealZetaSum_degTwo_le (σ : Gal(L/K)) {s : ℝ} + have hmapinj : Function.Injective hmap := by + rintro ⟨⟨P, hP⟩, hgP⟩ ⟨⟨Q, hQ⟩, hgQ⟩ hPQ + exact Subtype.ext (Subtype.ext (by simpa only [hhmap, Subtype.mk.injEq] using hPQ)) +- haveI : Finite {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) // ++ have : Finite {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) // + P.IsPrime ∧ P.LiesOver 𝔭.1} := + (IsDedekindDomain.primesOver_finite 𝔭.1 _).to_subtype + exact ⟨Finite.of_injective hmap hmapinj, (Nat.card_le_card_of_injective hmap hmapinj).trans +@@ -1021,12 +989,12 @@ private theorem ramifiedBelow_finite (σ : Gal(L/K)) + (𝔭.primesOver (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))))) ?_) + · rw [hB] + rintro P ⟨hPp, hPb, hPnu⟩ +- haveI := hPp +- exact Set.mem_biUnion ⟨inferInstance, Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPb, hPnu⟩ ++ have := hPp ++ exact Set.mem_biUnion ⟨inferInstance, Ideal.IsIntegral.under_ne_bot (𝓞 K) hPb, hPnu⟩ + ⟨hPp, Ideal.over_under (A := 𝓞 K) (P := P)⟩ + · rintro 𝔭 ⟨hp, hb, -⟩ +- haveI := hp +- haveI : 𝔭.IsMaximal := hp.isMaximal hb ++ have := hp ++ have : 𝔭.IsMaximal := hp.isMaximal hb + exact IsDedekindDomain.primesOver_finite 𝔭 _ + + /-- **LEAF B: the degree-`≥ 2` part of `T` vanishes in the density ratio** (Sharifi 7.2.2 +@@ -1051,32 +1019,32 @@ private theorem primeIdealZetaSum_T2_div_univ_tendsto_zero + P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P ∧ + frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P + = ConjClasses.mk σE} | +- (P.under (𝓞 K)).inertiaDeg' P = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))}) : ++ P.inertiaDeg (𝓞 K) = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))}) : + Tendsto (fun s : ℝ ↦ primeIdealZetaSum T₂set s + / primeIdealZetaSum (univ : Set (Ideal (𝓞 ↥(IntermediateField.fixedField + (Subgroup.zpowers σ))))) s) (𝓝[>] 1) (𝓝 0) := by +- haveI : IsGalois ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsGalois ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + IsGalois.tower_top_intermediateField _ + set Aset := {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) | + P.IsPrime ∧ P ≠ ⊥ ∧ UnramifiedIn K L (P.under (𝓞 K)) ∧ +- 2 ≤ (P.under (𝓞 K)).inertiaDeg' P} with hAdef ++ 2 ≤ P.inertiaDeg (𝓞 K)} with hAdef + set Bset := {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) | + P.IsPrime ∧ P ≠ ⊥ ∧ ¬ UnramifiedIn K L (P.under (𝓞 K))} with hBdef + have hsub : T₂set ⊆ Aset ∪ Bset := by + rw [hT₂] + rintro P ⟨⟨hPp, hPunr, hPfr⟩, hPnotT1⟩ +- haveI := hPp +- simp only [Set.mem_setOf_eq, not_and] at hPnotT1 ++ have := hPp ++ simp only [Set.mem_ofPred_eq, not_and] at hPnotT1 + have hPb : P ≠ ⊥ := UnramifiedIn.ne_bot _ L hPunr + by_cases hunrK : UnramifiedIn K L (P.under (𝓞 K)) + · refine Or.inl ⟨hPp, hPb, hunrK, ?_⟩ +- have hdegne : (P.under (𝓞 K)).inertiaDeg' P ≠ 1 := fun hdeg1 ↦ ++ have hdegne : P.inertiaDeg (𝓞 K) ≠ 1 := fun hdeg1 ↦ + hPnotT1 ⟨hPp, hPunr, hPfr⟩ hdeg1 hunrK + have hppr : (P.under (𝓞 K)).IsPrime := inferInstance +- haveI : (P.under (𝓞 K)).IsMaximal := +- hppr.isMaximal (Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPb) +- haveI : P.LiesOver (P.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := P) +- have hpos : 0 < (P.under (𝓞 K)).inertiaDeg' P := Ideal.inertiaDeg_pos' _ _ ++ have : (P.under (𝓞 K)).IsMaximal := ++ hppr.isMaximal (Ideal.IsIntegral.under_ne_bot (𝓞 K) hPb) ++ have : P.LiesOver (P.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := P) ++ have hpos : 0 < P.inertiaDeg (𝓞 K) := Ideal.inertiaDeg_pos P (𝓞 K) + omega + · exact Or.inr ⟨hPp, hPb, hunrK⟩ + have hdisj : Disjoint Aset Bset := by +@@ -1149,9 +1117,9 @@ theorem density_lift_through_fixedField + frobeniusClass K L 𝔭 = ConjClasses.mk σ} + ((Nat.card (ConjClasses.mk σ).carrier : ℝ) / Nat.card Gal(L/K)) := by + subst _hEfix +- haveI : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := ++ have : IsScalarTower K ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L := + (IntermediateField.fixedField (Subgroup.zpowers σ)).isScalarTower_mid' +- haveI : IsMulCommutative Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := ++ have : IsMulCommutative Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := + isMulCommutative_galGroup_fixedField σ + have horderE' : + orderOf σ = Nat.card Gal(L/(↥(IntermediateField.fixedField (Subgroup.zpowers σ)))) := +@@ -1160,7 +1128,7 @@ theorem density_lift_through_fixedField + P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P ∧ + frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P + = ConjClasses.mk σE} with hTset +- set T₁set := {P ∈ Tset | (P.under (𝓞 K)).inertiaDeg' P = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))} ++ set T₁set := {P ∈ Tset | P.inertiaDeg (𝓞 K) = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))} + with hT₁set + set T₂set := Tset \ T₁set with hT₂set + have hT₁sub : T₁set ⊆ Tset := fun x hx ↦ hx.1 +@@ -1212,10 +1180,10 @@ theorem density_lift_through_fixedField + have hT₁flat : T₁set = {P : Ideal (𝓞 ↥(IntermediateField.fixedField (Subgroup.zpowers σ))) | + P.IsPrime ∧ UnramifiedIn ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P ∧ + frobeniusClass ↥(IntermediateField.fixedField (Subgroup.zpowers σ)) L P = ConjClasses.mk σE ∧ +- (P.under (𝓞 K)).inertiaDeg' P = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))} := by ++ P.inertiaDeg (𝓞 K) = 1 ∧ UnramifiedIn K L (P.under (𝓞 K))} := by + rw [hT₁set, hTset] + ext P +- simp only [Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq] + tauto + have hleafA := primeIdealZetaSum_fibre_eq_smul σ σE hσE horderE' hs + rw [← hT₁flat] at hleafA +diff --git a/projects/Chebotarev/CebotarevDensity/ForMathlib/CharacterOrthogonality.lean b/projects/Chebotarev/CebotarevDensity/ForMathlib/CharacterOrthogonality.lean +index a82fed3f7..a4a9a2d72 100644 +--- a/projects/Chebotarev/CebotarevDensity/ForMathlib/CharacterOrthogonality.lean ++++ b/projects/Chebotarev/CebotarevDensity/ForMathlib/CharacterOrthogonality.lean +@@ -78,7 +78,7 @@ theorem card_mul_eq_sum_of_sum_char_mul_eq_zero {G : Type*} [CommGroup G] [Finty + intro s + by_cases hs : s = u + · subst hs; simp +- · rw [if_neg hs] ++ · rw [ite_eq_right hs] + exact sum_char_apply_eq_zero_of_ne_one fun h ↦ hs (inv_mul_eq_one.mp h).symm + calc (Fintype.card (G →* Rˣ) : R) * f u + = ∑ s : G, (if s = u then (Fintype.card (G →* Rˣ) : R) else 0) * f s := by +diff --git a/projects/Chebotarev/CebotarevDensity/ForMathlib/IdealCongruenceCount.lean b/projects/Chebotarev/CebotarevDensity/ForMathlib/IdealCongruenceCount.lean +index 96f816150..4499927f7 100644 +--- a/projects/Chebotarev/CebotarevDensity/ForMathlib/IdealCongruenceCount.lean ++++ b/projects/Chebotarev/CebotarevDensity/ForMathlib/IdealCongruenceCount.lean +@@ -331,7 +331,7 @@ theorem exists_card_coset_inter_smul_sub_volume_mul_rpow_le + set Ts : (ι → ℝ) →L[ℝ] (ι → ℝ) := (T.symm.toContinuousLinearEquiv : (ι → ℝ) →L[ℝ] (ι → ℝ)) + with hTs + have hTslip : LipschitzWith ‖Ts‖₊ (T.symm : (ι → ℝ) → (ι → ℝ)) := by +- simpa [hTs] using Ts.lipschitz ++ simpa [hTs] using Ts.lipschitzWith + have hD'bdd : Bornology.IsBounded D' := hTslip.isBounded_image hbdd + have hD'meas : MeasurableSet D' := + (T.symm.toContinuousLinearEquiv.toHomeomorph.toMeasurableEquiv).measurableSet_image.mpr hmeas +@@ -434,10 +434,10 @@ private theorem norm_eq_prod_real_emb_mul_prod_complex {K : Type*} [Field K] [Nu + star_involutive.eq_iff] + rw [hfilter] + by_cases hw : IsReal w +- · rw [dif_pos hw, ComplexEmbedding.isReal_iff.mp (isReal_iff.mp hw), ++ · rw [dite_eq_left hw, ComplexEmbedding.isReal_iff.mp (isReal_iff.mp hw), + Finset.insert_eq_self.mpr (Finset.mem_singleton_self _), Finset.prod_singleton, + embedding_of_isReal_apply hw] +- · rw [dif_neg hw, Finset.prod_pair] ++ · rw [dite_eq_right hw, Finset.prod_pair] + · rw [ComplexEmbedding.conjugate_coe_eq, Complex.mul_conj] + norm_cast + rw [Complex.normSq_eq_norm_sq] +@@ -452,8 +452,8 @@ private theorem norm_eq_prod_real_emb_mul_prod_complex {K : Type*} [Field K] [Nu + simp_rw [hperplace] + rw [prod_eq_prod_mul_prod] + congr 1 +- · rw [Finset.prod_congr rfl (fun w _ ↦ by rw [dif_pos w.2]), Complex.ofReal_prod] +- · rw [Finset.prod_congr rfl (fun w _ ↦ by rw [dif_neg (not_isReal_iff_isComplex.mpr w.2)]), ++ · rw [Finset.prod_congr rfl (fun w _ ↦ by rw [dite_eq_left w.2]), Complex.ofReal_prod] ++ · rw [Finset.prod_congr rfl (fun w _ ↦ by rw [dite_eq_right (not_isReal_iff_isComplex.mpr w.2)]), + Complex.ofReal_prod] + exact_mod_cast hcc + +@@ -520,7 +520,7 @@ open Ideal in + /-- **Class split of the residue count.** The number of nonzero integral ideals of norm `≤ N` + with norm residue `a (mod c)` is the sum over the (finite) class group of the per-class counts. + The class group is a `Fintype`; finiteness of each fibre follows from +-`Ideal.finite_setOf_absNorm_le₀`. -/ ++`Ideal.finite_setOfPred_absNorm_le₀`. -/ + private theorem card_norm_le_residue_eq_sum_class {K : Type*} [Field K] [NumberField K] + (c : ℕ) [NeZero c] (a : ZMod c) (N : ℕ) : + Nat.card {I : (Ideal (𝓞 K))⁰ // Ideal.absNorm (I : Ideal (𝓞 K)) ≤ N ∧ +@@ -530,7 +530,7 @@ private theorem card_norm_le_residue_eq_sum_class {K : Type*} [Field K] [NumberF + ((Ideal.absNorm (I : Ideal (𝓞 K)) : ZMod c)) = a) ∧ ClassGroup.mk0 I = C} := by + classical + have hbase : Finite {I : (Ideal (𝓞 K))⁰ // Ideal.absNorm (I : Ideal (𝓞 K)) ≤ N} := +- Ideal.finite_setOf_absNorm_le₀ N ++ Ideal.finite_setOfPred_absNorm_le₀ N + have hfin : Finite {I : (Ideal (𝓞 K))⁰ // Ideal.absNorm (I : Ideal (𝓞 K)) ≤ N ∧ + ((Ideal.absNorm (I : Ideal (𝓞 K)) : ZMod c)) = a} := + Finite.of_injective (fun I ↦ (⟨I.1, I.2.1⟩ : +@@ -660,7 +660,7 @@ private theorem cone_normLe_eq_smul_normLeOne {K : Type*} [Field K] [NumberField + have ht0 : (0 : ℝ) < t := lt_of_lt_of_le one_pos ht + have htne : t ≠ 0 := ht0.ne' + ext x +- simp only [Set.mem_setOf_eq, Set.mem_smul_set, normLeOne, Set.mem_inter_iff, Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq, Set.mem_smul_set, normLeOne, Set.mem_inter_iff, Set.mem_ofPred_eq] + constructor + · rintro ⟨hcone, hnorm⟩ + refine ⟨t⁻¹ • x, ⟨(smul_mem_iff_mem (inv_ne_zero htne)).mpr hcone, ?_⟩, ?_⟩ +@@ -736,8 +736,8 @@ private theorem exists_lipschitz_cube_cover_hyperplane_slab {ι : Type*} [Fintyp + rw [dist_pi_le_iff (by positivity)] + intro i + by_cases hij : i = j +- · simp only [hφ, dif_pos hij, dist_self]; positivity +- · simp only [hφ, dif_neg hij] ++ · simp only [hφ, dite_eq_left hij, dist_self]; positivity ++ · simp only [hφ, dite_eq_right hij] + have hreorg : (2 * R) * c (σ.symm ⟨i, hij⟩) - R - ((2 * R) * c' (σ.symm ⟨i, hij⟩) - R) + = (2 * R) * (c (σ.symm ⟨i, hij⟩) - c' (σ.symm ⟨i, hij⟩)) := by ring + rw [Real.dist_eq, hreorg, abs_mul, abs_of_nonneg (by positivity : (0 : ℝ) ≤ 2 * R), +@@ -752,8 +752,8 @@ private theorem exists_lipschitz_cube_cover_hyperplane_slab {ι : Type*} [Fintyp + refine ⟨0, ⟨le_refl _, zero_le_one⟩, ?_⟩ + ext i; simp only [hφ] + by_cases hij : i = j +- · rw [dif_pos hij, hx0]; rfl +- · rw [dif_neg hij, hx0]; simp [← hR0] ++ · rw [dite_eq_left hij, hx0]; rfl ++ · rw [dite_eq_right hij, hx0]; simp [← hR0] + · refine ⟨fun k ↦ (x (σ k) + R) / (2 * R), ⟨?_, ?_⟩, ?_⟩ + · intro k; simp only [Pi.zero_apply] + rw [le_div_iff₀ (by positivity)]; have := (abs_le.mp (hxbd (σ k))).1; linarith +@@ -761,8 +761,8 @@ private theorem exists_lipschitz_cube_cover_hyperplane_slab {ι : Type*} [Fintyp + rw [div_le_one (by positivity)]; have := (abs_le.mp (hxbd (σ k))).2; linarith + · ext i + by_cases hij : i = j +- · rw [hφ]; simp only; rw [dif_pos hij, hij]; exact hxj.symm +- · rw [hφ]; simp only [dif_neg hij, Equiv.apply_symm_apply]; field_simp; ring ++ · rw [hφ]; simp only; rw [dite_eq_left hij, hij]; exact hxj.symm ++ · rw [hφ]; simp only [dite_eq_right hij, Equiv.apply_symm_apply]; field_simp; ring + + /-- **Union of two Lipschitz cube covers.** If `A` and `B` are each covered by finitely many + `Lipschitz`-images of `[0,1]^(card ι - 1)`, so is `A ∪ B` (concatenate the families, take the max +@@ -822,13 +822,13 @@ private theorem frontier_signOrthant_subset {ι κ : Type*} [Finite κ] (g : κ + set O : Set (ι → ℝ) := {y | (∀ k ∈ s, y (g k) ≤ 0) ∧ (∀ k ∉ s, 0 ≤ y (g k))} with hO + set Os : Set (ι → ℝ) := {y | (∀ k ∈ s, y (g k) < 0) ∧ (∀ k ∉ s, 0 < y (g k))} with hOs + have hOclosed : IsClosed O := by +- simp only [hO, Set.setOf_and, Set.setOf_forall] ++ simp only [hO, Set.ofPred_and, Set.ofPred_forall] + exact (isClosed_iInter fun k ↦ isClosed_iInter fun _ ↦ + isClosed_le (continuous_apply (g k)) continuous_const).inter + (isClosed_iInter fun k ↦ isClosed_iInter fun _ ↦ + isClosed_le continuous_const (continuous_apply (g k))) + have hOsopen : IsOpen Os := by +- simp only [hOs, Set.setOf_and, Set.setOf_forall] ++ simp only [hOs, Set.ofPred_and, Set.ofPred_forall] + exact (isOpen_iInter_of_finite fun k ↦ isOpen_iInter_of_finite fun _ ↦ + isOpen_lt (continuous_apply (g k)) continuous_const).inter + (isOpen_iInter_of_finite fun k ↦ isOpen_iInter_of_finite fun _ ↦ +@@ -840,7 +840,7 @@ private theorem frontier_signOrthant_subset {ι κ : Type*} [Finite κ] (g : κ + rw [frontier_eq_closure_inter_closure] at hy + rw [interior_eq_compl_closure_compl]; exact fun hh ↦ hh hy.2 + by_contra hcon +- simp only [Set.mem_iUnion, Set.mem_setOf_eq, not_exists] at hcon ++ simp only [Set.mem_iUnion, Set.mem_ofPred_eq, not_exists] at hcon + exact hyni (mem_interior.mpr ⟨Os, hsub, hOsopen, + ⟨fun k hk ↦ lt_of_le_of_ne (hyO.1 k hk) (hcon k), + fun k hk ↦ lt_of_le_of_ne (hyO.2 k hk) (Ne.symm (hcon k))⟩⟩) +@@ -985,14 +985,14 @@ private theorem exists_card_cell_sub_mul_rpow_le_explicit {ι : Type*} [Fintype + * t ^ (Fintype.card ι)| + ≤ C * t ^ (Fintype.card ι - 1 : ℕ) := by + classical +- haveI : Fintype κ := Fintype.ofFinite κ ++ have : Fintype κ := Fintype.ofFinite κ + set T' : (ι → ℝ) ≃ₗ[ℝ] (ι → ℝ) := (LinearEquiv.smulOfNeZero ℝ (ι → ℝ) (m : ℝ) hm).trans T + set Ds : Set (ι → ℝ) := + D₀ ∩ {y : ι → ℝ | (∀ k ∈ s, y (g k) ≤ 0) ∧ (∀ k ∉ s, 0 ≤ y (g k))} + have hDsbdd : Bornology.IsBounded Ds := hbdd.subset Set.inter_subset_left + have hOclosed : IsClosed {y : ι → ℝ | (∀ k ∈ s, y (g k) ≤ 0) ∧ (∀ k ∉ s, 0 ≤ y (g k))} := by + classical +- rw [setOf_and] ++ rw [ofPred_and] + refine IsClosed.inter ?_ ?_ + · have h : {y : ι → ℝ | ∀ k ∈ s, y (g k) ≤ 0} = ⋂ k ∈ s, {y : ι → ℝ | y (g k) ≤ 0} := by + ext y; simp +@@ -1514,7 +1514,7 @@ private theorem exists_card_residue_fibre_sub_mul_rpow_le_explicit {K : Type*} [ + ((Φ.toHomeomorph.toMeasurableEquiv).measurableSet_image.mpr (measurableSet_normLeOne K)) + hcov (Sum.inl : {w : InfinitePlace K // IsReal w} → index K) s + refine ⟨cellC, fun t ht ↦ ?_⟩ +- rw [if_pos ⟨a₀, horth₀, hcos₀, hres₀⟩] ++ rw [ite_eq_left ⟨a₀, horth₀, hcos₀, hres₀⟩] + have hfibre : Nat.card {a : idealSet K J // + (mixedEmbedding.norm (a : mixedSpace K) ≤ t ^ Module.finrank ℚ K ∧ + ((intNorm (idealSetEquiv K J a).val : ZMod m) = (b : ZMod m))) ∧ +@@ -1538,7 +1538,7 @@ private theorem exists_card_residue_fibre_sub_mul_rpow_le_explicit {K : Type*} [ + rw [hpow1, hpow2] + exact hcell (T (fun i ↦ ((k i).val : ℝ))) t ht + · refine ⟨0, fun t ht ↦ ?_⟩ +- rw [if_neg hQ] ++ rw [ite_eq_right hQ] + have hempty : IsEmpty {a : idealSet K J // + (mixedEmbedding.norm (a : mixedSpace K) ≤ t ^ Module.finrank ℚ K ∧ + ((intNorm (idealSetEquiv K J a).val : ZMod m) = (b : ZMod m))) ∧ +@@ -1590,14 +1590,14 @@ private theorem exists_card_residue_fibre_sub_mul_rpow_le {K : Type*} [Field K] + open Ideal NumberField.mixedEmbedding NumberField.mixedEmbedding.fundamentalCone Units in + /-- **Finiteness of bounded-norm cone points.** The cone points of `idealSet K J` of norm `≤ s` + form a finite set: they inject (via `integerSetEquiv ∘ idealSetMap`) into the product of the +-finite set of integral ideals of norm `≤ ⌊s⌋` (`Ideal.finite_setOf_absNorm_le₀`) with the finite ++finite set of integral ideals of norm `≤ ⌊s⌋` (`Ideal.finite_setOfPred_absNorm_le₀`) with the finite + torsion group. -/ + private theorem finite_idealSet_norm_le {K : Type*} [Field K] [NumberField K] + (J : (Ideal (𝓞 K))⁰) (s : ℝ) : + Finite {a : idealSet K J // mixedEmbedding.norm (a : mixedSpace K) ≤ s} := by + classical + have : Finite {I : (Ideal (𝓞 K))⁰ // Ideal.absNorm (I : Ideal (𝓞 K)) ≤ ⌊s⌋₊} := +- (Ideal.finite_setOf_absNorm_le₀ ⌊s⌋₊).to_subtype ++ (Ideal.finite_setOfPred_absNorm_le₀ ⌊s⌋₊).to_subtype + refine Finite.of_injective (β := {I : (Ideal (𝓞 K))⁰ // Ideal.absNorm (I : Ideal (𝓞 K)) ≤ ⌊s⌋₊} × + torsion K) (fun a ↦ ⟨⟨(integerSetEquiv K (idealSetMap K J a.1)).1.1, ?_⟩, + (integerSetEquiv K (idealSetMap K J a.1)).2⟩) ?_ +@@ -1838,7 +1838,7 @@ private theorem exists_card_norm_le_residue_class_eq_sub_mul_rpow_le + classical + obtain ⟨J, hJ⟩ := ClassGroup.mk0_surjective C⁻¹ + have hNJ : 0 < Ideal.absNorm (J : Ideal (𝓞 K)) := absNorm_pos_of_nonZeroDivisors J +- haveI : NeZero (c * Ideal.absNorm (J : Ideal (𝓞 K))) := ++ have : NeZero (c * Ideal.absNorm (J : Ideal (𝓞 K))) := + ⟨Nat.mul_ne_zero (NeZero.ne c) hNJ.ne'⟩ + obtain ⟨κ, C', hκ⟩ := exists_card_dvd_principal_residue_eq_sub_mul_rpow_le + (c * Ideal.absNorm (J : Ideal (𝓞 K))) (a.val * Ideal.absNorm (J : Ideal (𝓞 K))) J +@@ -2403,7 +2403,7 @@ private theorem crt_single_coset {ι : Type*} [Finite ι] (L L' : Submodule ℤ + = {z | ∃ x ∈ M, z = m • x} := by + intro M + ext z +- simp only [Set.mem_smul_set, SetLike.mem_coe, Set.mem_setOf_eq] ++ simp only [Set.mem_smul_set, SetLike.mem_coe, Set.mem_ofPred_eq] + exact ⟨fun ⟨x, hx, h⟩ ↦ ⟨x, hx, by rw [← h, Nat.cast_smul_eq_nsmul]⟩, + fun ⟨x, hx, h⟩ ↦ ⟨x, hx, by rw [h, Nat.cast_smul_eq_nsmul]⟩⟩ + have hbij := hcop.nsmul_right_bijective +@@ -2429,7 +2429,7 @@ private theorem crt_single_coset {ι : Type*} [Finite ι] (L L' : Submodule ℤ + rw [QuotientAddGroup.eq_zero_iff, AddSubgroup.mem_addSubgroupOf] at hq0 + simpa using hq0 + ext a +- simp only [Set.mem_setOf_eq, hmsmul, Set.mem_vadd_set, Set.mem_setOf_eq, vadd_eq_add] ++ simp only [Set.mem_ofPred_eq, hmsmul, Set.mem_vadd_set, Set.mem_ofPred_eq, vadd_eq_add] + constructor + · rintro ⟨haL', w, ⟨x, hxL, rfl⟩, hweq⟩ + rw [hξeq] at hweq +@@ -2578,7 +2578,7 @@ private theorem exists_card_fibre_dvd_eq_card_cell {K : Type*} [Field K] [Number + have hrel : L'.toAddSubgroup.relIndex L.toAddSubgroup = Ideal.absNorm (𝔟 : Ideal (𝓞 K)) := + relIndex_chart_eq_absNorm J 𝔟 T T' hT hT' + have hNB : 0 < Ideal.absNorm (𝔟 : Ideal (𝓞 K)) := absNorm_pos_of_nonZeroDivisors 𝔟 +- haveI hfin : Finite (L.toAddSubgroup ⧸ L'.toAddSubgroup.addSubgroupOf L.toAddSubgroup) := by ++ have hfin : Finite (L.toAddSubgroup ⧸ L'.toAddSubgroup.addSubgroupOf L.toAddSubgroup) := by + rw [← AddSubgroup.index_ne_zero_iff_finite] + rw [show (L'.toAddSubgroup.addSubgroupOf L.toAddSubgroup).index + = L'.toAddSubgroup.relIndex L.toAddSubgroup from rfl, hrel] +@@ -2779,7 +2779,7 @@ private theorem exists_card_fibre_dvd_residue_sub_mul_rpow_le {K : Type*} [Field + ((fun i ↦ (round ((T.symm (Φ (a : mixedSpace K))) i) : ZMod m)) = k) ∧ + ((intNorm (idealSetEquiv K J a).val : ZMod m) = (b : ZMod m)) + · obtain ⟨a₀, horth₀, hcos₀, hres₀⟩ := hQ +- rw [if_pos ⟨a₀, horth₀, hcos₀, hres₀⟩] ++ rw [ite_eq_left ⟨a₀, horth₀, hcos₀, hres₀⟩] + have hdrop : Nat.card {a : idealSet K (𝔟 * J) // + (mixedEmbedding.norm (a : mixedSpace K) ≤ t ^ d ∧ + ((intNorm (idealSetEquiv K (𝔟 * J) a).val : ZMod m) = (b : ZMod m))) ∧ +@@ -2806,7 +2806,7 @@ private theorem exists_card_fibre_dvd_residue_sub_mul_rpow_le {K : Type*} [Field + have hcell'' := hcell' ξ' t ht + rw [smul_chart_lattice_eq T' m hm, ← hOs, hdetratio, hcard] at hcell'' + exact hcell''.trans (by gcongr; exact le_abs_self _) +- · rw [if_neg hQ, zero_div, zero_mul, sub_zero] ++ · rw [ite_eq_right hQ, zero_div, zero_mul, sub_zero] + have : IsEmpty {a : idealSet K (𝔟 * J) // + (mixedEmbedding.norm (a : mixedSpace K) ≤ t ^ d ∧ + ((intNorm (idealSetEquiv K (𝔟 * J) a).val : ZMod m) = (b : ZMod m))) ∧ +@@ -3011,7 +3011,7 @@ private theorem cardNormLeResidueClassDvd_div_density {K : Type*} [Field K] [Num + have hNJ : 0 < NJ := absNorm_pos_of_nonZeroDivisors J + have hNBc : NB.Coprime c := by rw [hNBdef, ZMod.isUnit_iff_coprime] at hu; exact hu + have hcop : NB.Coprime (c * NJ) := Nat.Coprime.mul_right hNBc (hNJdef ▸ hJcop.symm) +- haveI : NeZero (c * NJ) := ⟨Nat.mul_ne_zero (NeZero.ne c) hNJ.ne'⟩ ++ have : NeZero (c * NJ) := ⟨Nat.mul_ne_zero (NeZero.ne c) hNJ.ne'⟩ + have hm : ((c * NJ : ℕ) : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (NeZero.ne (c * NJ)) + obtain ⟨κ, C', hJcone, h𝔟Jcone⟩ := + exists_card_idealSet_residue_real_le_dvd (c * NJ) hm (y.val * NJ) J 𝔟 hcop +diff --git a/projects/Chebotarev/CebotarevDensity/ForMathlib/LatticePointCount.lean b/projects/Chebotarev/CebotarevDensity/ForMathlib/LatticePointCount.lean +index d1ed572f5..ad3fc2802 100644 +--- a/projects/Chebotarev/CebotarevDensity/ForMathlib/LatticePointCount.lean ++++ b/projects/Chebotarev/CebotarevDensity/ForMathlib/LatticePointCount.lean +@@ -296,7 +296,7 @@ theorem abs_card_inter_sub_volume_mul_pow_le {s : Set (ι → ℝ)} + set Tag : Set (ι → ℤ) := {ν | tag n ν ∈ s} with hTag + have himg : index n '' (s ∩ (n : ℝ)⁻¹ • span ℤ (Set.range (Pi.basisFun ℝ ι))) = Tag := by + ext ν +- simp only [hTag, Set.mem_image, Set.mem_inter_iff, Set.mem_setOf_eq] ++ simp only [hTag, Set.mem_image, Set.mem_inter_iff, Set.mem_ofPred_eq] + constructor + · rintro ⟨x, ⟨hxs, hxL⟩, rfl⟩ + rwa [tag_index_eq_self_of_mem_smul_span n hxL] +diff --git a/projects/Chebotarev/CebotarevDensity/ForMathlib/NormLeOneLipschitz.lean b/projects/Chebotarev/CebotarevDensity/ForMathlib/NormLeOneLipschitz.lean +index 8241f43b0..e8d648364 100644 +--- a/projects/Chebotarev/CebotarevDensity/ForMathlib/NormLeOneLipschitz.lean ++++ b/projects/Chebotarev/CebotarevDensity/ForMathlib/NormLeOneLipschitz.lean +@@ -152,19 +152,19 @@ open scoped Classical in + theorem contDiff_faceMapZero : ContDiff ℝ 1 (faceMapZero K) := by + refine (contDiff_expMapBasis K).comp (contDiff_pi.mpr fun w ↦ ?_) + by_cases hw : w = w₀ +- · simpa only [dif_pos hw] using contDiff_const +- · simpa only [dif_neg hw] using contDiff_apply ℝ ℝ _ ++ · simpa only [dite_eq_left hw] using contDiff_const ++ · simpa only [dite_eq_right hw] using contDiff_apply ℝ ℝ _ + + open scoped Classical in + theorem contDiff_faceMapSide (i : {w : InfinitePlace K // w ≠ w₀}) (a : ℝ) : + ContDiff ℝ 1 (faceMapSide K i a) := by + refine (contDiff_apply ℝ ℝ i).smul ((contDiff_expMapBasis K).comp (contDiff_pi.mpr fun w ↦ ?_)) + by_cases hw : w = w₀ +- · simpa only [dif_pos hw] using contDiff_const +- · simp only [dif_neg hw] ++ · simpa only [dite_eq_left hw] using contDiff_const ++ · simp only [dite_eq_right hw] + by_cases hi : (⟨w, hw⟩ : {w // w ≠ w₀}) = i +- · simpa only [if_pos hi] using contDiff_const +- · simpa only [if_neg hi] using contDiff_apply ℝ ℝ _ ++ · simpa only [ite_eq_left hi] using contDiff_const ++ · simpa only [ite_eq_right hi] using contDiff_apply ℝ ℝ _ + + /-- **Abstract topological core.** For an open injective map `f` and a set `s`, if the closure of + `f '' s` is contained in `f '' closure s` together with one extra point `p`, then the frontier of +@@ -222,12 +222,12 @@ private theorem expMapBasis_mem_iUnion_faceMapSide + fun w' ↦ if w' = w₀ then 0 else y w' := by + funext w' + by_cases hw'₀ : w' = w₀ +- · simp only [dif_pos hw'₀, if_pos hw'₀] +- · simp only [dif_neg hw'₀, if_neg hw'₀] ++ · simp only [dite_eq_left hw'₀, ite_eq_left hw'₀] ++ · simp only [dite_eq_right hw'₀, ite_eq_right hw'₀] + by_cases hw'w : (⟨w', hw'₀⟩ : {w // w ≠ w₀}) = i + · obtain rfl : w' = w := by rw [hi, Subtype.mk_eq_mk] at hw'w; exact hw'w +- simp only [if_pos hw'w] +- · simp only [hc, if_neg hw'w] ++ simp only [ite_eq_left hw'w] ++ · simp only [hc, ite_eq_right hw'w] + rw [faceMapSide, expMapBasis_apply'' y, hci, hfun] + refine Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion₂.mpr ⟨y w, ?_, ⟨c, hcmem, hkey⟩⟩⟩ + rcases ha with h | h <;> simp [h] +@@ -252,16 +252,16 @@ theorem image_boundary_subset_faces : + have hIcc : ∀ v : InfinitePlace K, v ≠ w₀ → y v ∈ Icc (0 : ℝ) 1 := fun v hv ↦ by + simpa [hv] using hyc v + by_cases hwe : w = w₀ +- · rw [if_pos hwe, Set.mem_Iio, not_lt, hwe] at hw ++ · rw [ite_eq_left hwe, Set.mem_Iio, not_lt, hwe] at hw + have hy0 : y w₀ = 0 := le_antisymm hw₀ hw + refine Or.inl ⟨fun i ↦ y i.1, ⟨fun i ↦ (hIcc i.1 i.2).1, fun i ↦ (hIcc i.1 i.2).2⟩, ?_⟩ + rw [faceMapZero] + congr 1 + funext v + by_cases hv : v = w₀ +- · rw [dif_pos hv, hv, hy0] +- · simp only [dif_neg hv] +- · rw [if_neg hwe] at hw ++ · rw [dite_eq_left hv, hv, hy0] ++ · simp only [dite_eq_right hv] ++ · rw [ite_eq_right hwe] at hw + have h1 := hIcc w hwe + rw [Set.mem_Ioo, not_and_or, not_lt, not_lt] at hw + refine Or.inr (expMapBasis_mem_iUnion_faceMapSide K hwe hw₀ hIcc ?_) +@@ -598,8 +598,8 @@ theorem mem_iUnion_image_liftToMixed_of_eq + refine Prod.ext (funext fun w ↦ ?_) (funext fun w ↦ ?_) + · simp only [hε, hmodreal w] + by_cases hpos : 0 ≤ x.1 w +- · rw [decide_eq_true hpos, if_pos rfl, one_mul, abs_of_nonneg hpos] +- · rw [decide_eq_false hpos, if_neg (by simp), abs_of_neg (not_le.mp hpos)] ++ · rw [decide_eq_true hpos, ite_eq_left rfl, one_mul, abs_of_nonneg hpos] ++ · rw [decide_eq_false hpos, ite_eq_right (by simp), abs_of_neg (not_le.mp hpos)] + ring + · simp only [hcph w, hmodcplx w] + exact hθeq w +@@ -675,7 +675,7 @@ theorem normLeOne_frontier_lipschitz_cover_index : + refine ⟨m, ‖(Φ : mixedSpace K →L[ℝ] (index K → ℝ))‖₊ * (M * 1), + fun j c ↦ Φ (φ j (fun a ↦ c (g.symm a))), + fun j ↦ (Φ : mixedSpace K →L[ℝ] (index K → ℝ)).lipschitzWith.comp ((hφ j).comp +- (IsometryEquiv.piCongrLeft' (Y := fun _ ↦ ℝ) g).isometry.lipschitz), ?_⟩ ++ (IsometryEquiv.piCongrLeft' (Y := fun _ ↦ ℝ) g).isometry.lipschitzWith), ?_⟩ + rw [← Φ.coe_toHomeomorph, ← Φ.toHomeomorph.image_frontier] + refine (Set.image_mono hcov).trans ?_ + rw [Set.image_iUnion] +diff --git a/projects/Chebotarev/CebotarevDensity/ForMathlib/TsumFiberBound.lean b/projects/Chebotarev/CebotarevDensity/ForMathlib/TsumFiberBound.lean +new file mode 100644 +index 000000000..02e8c54a0 +--- /dev/null ++++ b/projects/Chebotarev/CebotarevDensity/ForMathlib/TsumFiberBound.lean +@@ -0,0 +1,51 @@ ++module ++ ++public import Mathlib.Topology.Algebra.InfiniteSum.Real ++public import Mathlib.Topology.Instances.ENNReal.Lemmas ++ ++/-! Fibre-counting bounds for nonnegative sums. -/ ++ ++@[expose] public section ++ ++open Set ++open scoped ENNReal ++ ++namespace Chebotarev ++ ++/-- **Fibre-counting bound for `ℝ≥0∞`-valued sums.** If every fibre `g ⁻¹' {y}` is finite with at ++most `d` elements, then `Σ_b f(g b) ≤ d · Σ_y f y`: group `b` by its image `g b`, on each fibre ++the summand is the constant `f y`, and the fibre has `≤ d` terms. -/ ++private theorem tsum_comp_le_card_fibre_mul {β γ : Type*} (g : β → γ) (f : γ → ℝ≥0∞) (d : ℕ) ++ (hfin : ∀ y, Finite (g ⁻¹' {y} : Set β)) (hfib : ∀ y, Nat.card (g ⁻¹' {y} : Set β) ≤ d) : ++ ∑' b, f (g b) ≤ (d : ℝ≥0∞) * ∑' y, f y := by ++ rw [← ENNReal.tsum_fiberwise (fun b ↦ f (g b)) g, ← ENNReal.tsum_mul_left] ++ refine ENNReal.tsum_le_tsum (fun y ↦ ?_) ++ rw [tsum_congr (fun b : (g ⁻¹' {y} : Set β) ↦ by rw [b.2])] ++ have := hfin y ++ let := Fintype.ofFinite (g ⁻¹' {y} : Set β) ++ rw [tsum_fintype, Finset.sum_const, Finset.card_univ, ← Nat.card_eq_fintype_card, nsmul_eq_mul] ++ gcongr ++ exact_mod_cast hfib y ++ ++/-- **Fibre-counting bound for real-valued sums.** The `ℝ`-valued companion of ++`tsum_comp_le_card_fibre_mul`: for nonnegative summable `FA, FK` with `FA b ≤ FK (g b)` and every ++fibre `g ⁻¹' {y}` finite of size `≤ d`, the sum `Σ_b FA b` is at most `d · Σ_y FK y`. -/ ++theorem tsum_real_comp_le_card_fibre_mul {β γ : Type*} (g : β → γ) (FA : β → ℝ) ++ (FK : γ → ℝ) (d : ℕ) (hsummA : Summable FA) (hsummK : Summable FK) (hnonnegA : ∀ b, 0 ≤ FA b) ++ (hnonnegK : ∀ y, 0 ≤ FK y) (hterm : ∀ b, FA b ≤ FK (g b)) ++ (hfin : ∀ y, Finite (g ⁻¹' {y} : Set β)) (hfib : ∀ y, Nat.card (g ⁻¹' {y} : Set β) ≤ d) : ++ ∑' b, FA b ≤ (d : ℝ) * ∑' y, FK y := by ++ have hchain : ∑' b, ENNReal.ofReal (FA b) ++ ≤ (d : ℝ≥0∞) * ∑' y, ENNReal.ofReal (FK y) := ++ calc ∑' b, ENNReal.ofReal (FA b) ≤ ∑' b, ENNReal.ofReal (FK (g b)) := ++ ENNReal.tsum_le_tsum fun b ↦ ENNReal.ofReal_le_ofReal (hterm b) ++ _ ≤ (d : ℝ≥0∞) * ∑' y, ENNReal.ofReal (FK y) := ++ tsum_comp_le_card_fibre_mul g (ENNReal.ofReal <| FK ·) d hfin hfib ++ rw [← ENNReal.ofReal_tsum_of_nonneg hnonnegA hsummA, ++ ← ENNReal.ofReal_tsum_of_nonneg hnonnegK hsummK] at hchain ++ rw [← ENNReal.toReal_ofReal (tsum_nonneg hnonnegA), ++ ← ENNReal.toReal_ofReal (mul_nonneg (Nat.cast_nonneg d) (tsum_nonneg hnonnegK)), ++ ENNReal.ofReal_mul (Nat.cast_nonneg d), ENNReal.ofReal_natCast] ++ exact ENNReal.toReal_mono (ENNReal.mul_ne_top (by simp) ENNReal.ofReal_ne_top) hchain ++ ++end Chebotarev +diff --git a/projects/Chebotarev/CebotarevDensity/Frobenius.lean b/projects/Chebotarev/CebotarevDensity/Frobenius.lean +index a5556b12b..de813c534 100644 +--- a/projects/Chebotarev/CebotarevDensity/Frobenius.lean ++++ b/projects/Chebotarev/CebotarevDensity/Frobenius.lean +@@ -102,7 +102,7 @@ theorem UnramifiedIn.ramificationIdx_eq_one [IsGalois K L] + (hP : 𝔓.LiesOver 𝔭) : Ideal.ramificationIdx' (𝔓.under (𝓞 K)) 𝔓 = 1 := by + have := hP + have h𝔓 : 𝔓 ≠ ⊥ := Ideal.ne_bot_of_liesOver_of_ne_bot hunr.1 𝔓 +- have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.comap_ne_bot (𝓞 K) h𝔓 ++ have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.under_ne_bot (𝓞 K) h𝔓 + have : Algebra.IsUnramifiedAt (𝓞 K) 𝔓 := hunr.2 𝔓 (‹𝔓.IsPrime›.isMaximal h𝔓) hP + rw [Ideal.ramificationIdx'_eq_ramificationIdx (𝔓.under (𝓞 K)) 𝔓 hpbot] + exact Ideal.ramificationIdx_eq_one_of_isUnramifiedAt +@@ -120,7 +120,7 @@ theorem inertiaGroup_trivial_of_unramified [IsGalois K L] + (hunr : Ideal.ramificationIdx' (𝔓.under (𝓞 K)) 𝔓 = 1) : + Ideal.inertia Gal(L/K) 𝔓 = ⊥ := by + have hPbot : 𝔓 ≠ ⊥ := ne_bot_of_ramificationIdx_eq_one K L hunr +- have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPbot ++ have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.under_ne_bot (𝓞 K) hPbot + have : 𝔓.IsMaximal := ‹𝔓.IsPrime›.isMaximal hPbot + have : (𝔓.under (𝓞 K)).IsMaximal := + (inferInstance : (𝔓.under (𝓞 K)).IsPrime).isMaximal hpbot +@@ -129,7 +129,7 @@ theorem inertiaGroup_trivial_of_unramified [IsGalois K L] + let : Field (𝓞 K ⧸ 𝔓.under (𝓞 K)) := Ideal.Quotient.field _ + let : Field (𝓞 L ⧸ 𝔓) := Ideal.Quotient.field _ + exact IsGalois.to_isSeparable +- haveI : Finite (𝓞 K ⧸ 𝔓.under (𝓞 K)) := Ideal.finiteQuotientOfFreeOfNeBot _ hpbot ++ have : Finite (𝓞 K ⧸ 𝔓.under (𝓞 K)) := Ideal.finiteQuotientOfFreeOfNeBot _ hpbot + have hcard : + Nat.card (Ideal.inertia Gal(L/K) 𝔓) = + Ideal.ramificationIdx' (𝔓.under (𝓞 K)) 𝔓 := by +@@ -206,7 +206,7 @@ theorem frobeniusClass_eq_mk_of_isArithFrobAt [IsGalois K L] + (σ : Gal(L/K)) (𝔓 : Ideal (𝓞 L)) [𝔓.IsPrime] (hσ : IsArithFrobAt (𝓞 K) σ 𝔓) + (hP : 𝔓.LiesOver 𝔭) : + frobeniusClass K L 𝔭 = ConjClasses.mk σ := by +- rw [frobeniusClass, dif_pos ⟨‹𝔭.IsPrime›, hunr⟩] ++ rw [frobeniusClass, dite_eq_left ⟨‹𝔭.IsPrime›, hunr⟩] + exact (exists_frobeniusClass K L 𝔭 hunr).choose_spec σ 𝔓 hσ hP + + /-- The order of an arithmetic Frobenius at an unramified prime is its residue degree. -/ +@@ -218,7 +218,7 @@ theorem orderOf_eq_finrank_of_isArithFrobAt + (hσ : IsArithFrobAt (𝓞 K) σ 𝔓) : + orderOf σ = Module.finrank (𝓞 K ⧸ 𝔓.under (𝓞 K)) (𝓞 L ⧸ 𝔓) := by + have hPbot : 𝔓 ≠ ⊥ := ne_bot_of_ramificationIdx_eq_one K L h +- have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.comap_ne_bot (𝓞 K) hPbot ++ have hpbot : 𝔓.under (𝓞 K) ≠ ⊥ := Ideal.IsIntegral.under_ne_bot (𝓞 K) hPbot + have : 𝔓.IsMaximal := ‹𝔓.IsPrime›.isMaximal hPbot + have : (𝔓.under (𝓞 K)).IsMaximal := + (inferInstance : (𝔓.under (𝓞 K)).IsPrime).isMaximal hpbot +@@ -287,14 +287,13 @@ theorem card_primesAbove_mul_finrank_eq + let : Field (𝓞 K ⧸ 𝔓₀.under (𝓞 K)) := Ideal.Quotient.field _ + let : Field (𝓞 L ⧸ 𝔓₀) := Ideal.Quotient.field _ + exact IsGalois.to_isSeparable +- haveI : Finite (𝓞 K ⧸ 𝔓₀.under (𝓞 K)) := ++ have : Finite (𝓞 K ⧸ 𝔓₀.under (𝓞 K)) := + Ideal.finiteQuotientOfFreeOfNeBot _ hp_under_bot + have H := + Ideal.ncard_primesOver_mul_card_inertia_mul_finrank + (G := Gal(L/K)) (𝔓₀.under (𝓞 K)) 𝔓₀ + rw [inertiaGroup_trivial_of_unramified K L 𝔓₀ he, Subgroup.card_bot, mul_one, +- ← Ideal.inertiaDeg'_eq_inertiaDeg (𝔓₀.under (𝓞 K)) 𝔓₀, +- Ideal.inertiaDeg'_algebraMap (𝔓₀.under (𝓞 K)) 𝔓₀] at H ++ Ideal.inertiaDeg_eq_of_isMaximal (𝔓₀.under (𝓞 K)) 𝔓₀] at H + have hset : (𝔓₀.under (𝓞 K)).primesOver (𝓞 L) + = {𝔓 : Ideal (𝓞 L) | 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} := by + ext 𝔓 +@@ -427,7 +426,7 @@ theorem finite_primes_natCast_mem (p : ℕ) (hp : p ≠ 0) : + have hfin := Ideal.finite_factors (R := 𝓞 K) hspan + apply Set.Finite.ofFinset (hfin.toFinset.image (·.asIdeal)) + intro 𝔭 +- simp only [Set.Finite.mem_toFinset, Finset.mem_image, Set.mem_setOf_eq] ++ simp only [Set.Finite.mem_toFinset, Finset.mem_image, Set.mem_ofPred_eq] + constructor + · rintro ⟨v, hv, rfl⟩ + exact +diff --git a/projects/Chebotarev/CebotarevDensity/Main.lean b/projects/Chebotarev/CebotarevDensity/Main.lean +index 678f99731..5cb630f0a 100644 +--- a/projects/Chebotarev/CebotarevDensity/Main.lean ++++ b/projects/Chebotarev/CebotarevDensity/Main.lean +@@ -90,7 +90,7 @@ so `|C| = 1`. -/ + theorem ConjClasses_carrier_card_eq_one_of_comm + {G : Type*} [Monoid G] [IsMulCommutative G] [Finite G] (g : G) : + Nat.card (ConjClasses.mk g).carrier = 1 := by +- letI : CommMonoid G := IsMulCommutative.instCommMonoid ++ let : CommMonoid G := IsMulCommutative.instCommMonoid + have h : (ConjClasses.mk g).carrier = {g} := by + ext a + simp [ConjClasses.mem_carrier_iff_mk_eq, ConjClasses.mk_eq_mk_iff_isConj, isConj_iff_eq] +@@ -260,7 +260,7 @@ private theorem ratPrime_eq_span (𝔭 : Ideal (𝓞 ℚ)) (hp : 𝔭.IsPrime) ( + `p`, via the same `𝓞 ℚ ≃+* ℤ` transport (`comap` of the prime `span {(p : ℤ)}`). -/ + private theorem span_nat_isPrime {p : ℕ} (hpp : p.Prime) : + (Ideal.span {(p : 𝓞 ℚ)}).IsPrime := by +- haveI : (Ideal.span {(p : ℤ)}).IsPrime := ++ have : (Ideal.span {(p : ℤ)}).IsPrime := + (Ideal.span_singleton_prime (by exact_mod_cast hpp.ne_zero)).mpr + (Nat.prime_iff_prime_int.mp hpp) + rw [ratSpan_eq_comap_intSpan] +@@ -278,8 +278,8 @@ private theorem unramifiedIn_cyclotomic_of_coprime {K : Type*} [Field K] [Number + UnramifiedIn K L 𝔭 := by + classical + refine ⟨h𝔭, fun 𝔓 h𝔓max h𝔓lo ↦ ?_⟩ +- haveI := h𝔓lo +- haveI : 𝔓.IsPrime := h𝔓max.isPrime ++ have := h𝔓lo ++ have : 𝔓.IsPrime := h𝔓max.isPrime + rw [← not_dvd_differentIdeal_iff (A := 𝓞 K) (B := 𝓞 L)] + intro hdvd + obtain ⟨ζ, hζ⟩ := IsCyclotomicExtension.exists_isPrimitiveRoot K L +@@ -337,7 +337,7 @@ private theorem frobeniusClass_eq_iff_residue + (𝔭 : Ideal (𝓞 ℚ)) [𝔭.IsPrime] (hunr : UnramifiedIn ℚ L 𝔭) + (hcop : (Ideal.absNorm 𝔭).Coprime n) : + frobeniusClass ℚ L 𝔭 = ConjClasses.mk σ ↔ (Ideal.absNorm 𝔭 : ZMod n) = a := by +- letI : CommMonoid (L ≃ₐ[ℚ] L) := IsMulCommutative.instCommMonoid ++ let : CommMonoid (L ≃ₐ[ℚ] L) := IsMulCommutative.instCommMonoid + have hdict := autToPow_frobeniusClass_out ℚ L n hζ 𝔭 hunr hcop + rw [show frobeniusClass ℚ L 𝔭 = ConjClasses.mk (frobeniusClass ℚ L 𝔭).out from + (Quotient.out_eq _).symm, ConjClasses.mk_eq_mk_iff_isConj, isConj_iff_eq] +@@ -389,7 +389,7 @@ private theorem dirichlet_AP_fibre_diff_image_subset_bad + (fun p : ℕ ↦ Ideal.span {(p : 𝓞 ℚ)}) '' {p : ℕ | p.Prime ∧ (p : ZMod n) = a} ⊆ + (fun q : ℕ ↦ Ideal.span {(q : 𝓞 ℚ)}) '' {q : ℕ | q.Prime ∧ q ∣ n} := by + rintro 𝔭 ⟨⟨hpr, hunr, hfrob⟩, hnotI⟩ +- haveI := hpr ++ have := hpr + obtain ⟨q, hqp, hqeq⟩ := ratPrime_eq_span 𝔭 hpr (UnramifiedIn.ne_bot ℚ L hunr) + have hnorm : Ideal.absNorm 𝔭 = q := by rw [hqeq, absNorm_span_nat] + by_cases hcop : (Ideal.absNorm 𝔭).Coprime n +@@ -414,7 +414,7 @@ private theorem dirichlet_AP_image_diff_fibre_subset_bad + (fun q : ℕ ↦ Ideal.span {(q : 𝓞 ℚ)}) '' {q : ℕ | q.Prime ∧ q ∣ n} := by + rintro 𝔭 ⟨⟨p, ⟨hpp, hpa⟩, rfl⟩, hnotF⟩ + have hprime : (Ideal.span {(p : 𝓞 ℚ)}).IsPrime := span_nat_isPrime hpp +- haveI := hprime ++ have := hprime + have hp0 : (p : 𝓞 ℚ) ≠ 0 := Nat.cast_ne_zero.mpr hpp.ne_zero + by_cases hdvd : p ∣ n + · exact ⟨p, ⟨hpp, hdvd⟩, rfl⟩ +@@ -438,11 +438,11 @@ private theorem dirichlet_AP_main (n : ℕ) (hn4 : n % 4 ≠ 2) (hn : 1 ≤ n) + ((Nat.totient n : ℝ)⁻¹) := by + have : NeZero n := ⟨by lia⟩ + -- The module system does not auto-synthesise `NeZero (n : ℚ)` for `CyclotomicField n ℚ` here. +- haveI : NeZero ((n : ℕ) : ℚ) := ⟨by exact_mod_cast (show n ≠ 0 by lia)⟩ ++ have : NeZero ((n : ℕ) : ℚ) := ⟨by exact_mod_cast (show n ≠ 0 by lia)⟩ + set L := CyclotomicField n ℚ +- haveI : IsCyclotomicExtension {n} ℚ L := CyclotomicField.isCyclotomicExtension n ℚ +- haveI : IsGalois ℚ L := IsCyclotomicExtension.isGalois {n} ℚ L +- haveI : IsMulCommutative (L ≃ₐ[ℚ] L) := ++ have : IsCyclotomicExtension {n} ℚ L := CyclotomicField.isCyclotomicExtension n ℚ ++ have : IsGalois ℚ L := IsCyclotomicExtension.isGalois {n} ℚ L ++ have : IsMulCommutative (L ≃ₐ[ℚ] L) := + IsCyclotomicExtension.isMulCommutative (S := {n}) ℚ L + have hirr : Irreducible (Polynomial.cyclotomic n ℚ) := + Polynomial.cyclotomic.irreducible_rat (by lia) +diff --git a/projects/Chebotarev/CebotarevDensity/NumberFieldEulerProduct.lean b/projects/Chebotarev/CebotarevDensity/NumberFieldEulerProduct.lean +index 753a2f1ee..28b3b5b8b 100644 +--- a/projects/Chebotarev/CebotarevDensity/NumberFieldEulerProduct.lean ++++ b/projects/Chebotarev/CebotarevDensity/NumberFieldEulerProduct.lean +@@ -2,7 +2,7 @@ module + + public import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics + public import Mathlib.Analysis.Normed.Ring.InfiniteSum +-public import Mathlib.Data.Finite.Vector ++public import Mathlib.Data.Fintype.Vector + public import Mathlib.Data.Finsupp.Multiset + public import Mathlib.Data.Sym.Card + public import Mathlib.NumberTheory.NumberField.Cyclotomic.Basic +@@ -249,7 +249,7 @@ lemma sum_idealNormMultiplicity_isBigO : + classical + have h_finite : ∀ (b : ℕ), {I : NonzeroIdeal L | Ideal.absNorm I.1 = b}.Finite := fun b ↦ + Set.Finite.preimage (f := fun I : NonzeroIdeal L ↦ I.1) (fun _ _ _ _ ↦ Subtype.ext) +- (Ideal.finite_setOf_absNorm_eq (S := 𝓞 L) b) ++ (Ideal.finite_setOfPred_absNorm_eq (S := 𝓞 L) b) + have h_sum_card : ∀ n : ℕ, ∑ k ∈ Finset.Icc 1 n, idealNormMultiplicity L k = + Nat.card {I : NonzeroIdeal L // Ideal.absNorm I.1 ≤ n} := fun n ↦ by + have key := Finset.card_preimage_eq_sum_card_image_eq (f := fun I : NonzeroIdeal L ↦ +@@ -257,7 +257,7 @@ lemma sum_idealNormMultiplicity_isBigO : + rw [show ((fun I : NonzeroIdeal L ↦ Ideal.absNorm I.1) ⁻¹' ↑(Finset.Icc 1 n)) = + {I : NonzeroIdeal L | Ideal.absNorm I.1 ≤ n} by + ext ⟨I, hI⟩ +- simp only [Set.mem_preimage, Finset.coe_Icc, Set.mem_Icc, Set.mem_setOf_eq] ++ simp only [Set.mem_preimage, Finset.coe_Icc, Set.mem_Icc, Set.mem_ofPred_eq] + exact ⟨fun h ↦ h.2, fun h ↦ + ⟨Nat.one_le_iff_ne_zero.mpr (mt Ideal.absNorm_eq_zero_iff.mp hI), h⟩⟩] at key + exact key.symm +@@ -501,7 +501,7 @@ eventually captured, so the partial sums tend to `∑_𝔞 N𝔞^{-s} = ζ_K(s)` + private instance instFiniteAbsNormFiber (n : ℕ) : + Finite {I : NonzeroIdeal L // Ideal.absNorm I.1 = n} := + Set.Finite.to_subtype <| Set.Finite.of_finite_image (f := fun I : NonzeroIdeal L ↦ I.1) +- ((Ideal.finite_setOf_absNorm_eq (S := 𝓞 L) n).subset (by rintro _ ⟨⟨I, _⟩, rfl, rfl⟩; rfl)) ++ ((Ideal.finite_setOfPred_absNorm_eq (S := 𝓞 L) n).subset (by rintro _ ⟨⟨I, _⟩, rfl, rfl⟩; rfl)) + (fun _ _ _ _ ↦ Subtype.ext) + + private lemma tsum_absNormFiber {M : Type*} [AddCommGroup M] [TopologicalSpace M] [T2Space M] +@@ -583,14 +583,14 @@ private theorem factorization_prod_primePow_eq + rw [factorization_prod_primePow_apply L S e 𝔮] + simp_rw [factorization_primePow_apply L] + by_cases h𝔮 : 𝔮 ∈ S +- · rw [if_pos h𝔮, Finset.sum_eq_single (⟨𝔮, h𝔮⟩ : {x // x ∈ S})] +- · rw [if_pos rfl] ++ · rw [ite_eq_left h𝔮, Finset.sum_eq_single (⟨𝔮, h𝔮⟩ : {x // x ∈ S})] ++ · rw [ite_eq_left rfl] + · rintro b _ hb +- rw [if_neg (fun h ↦ hb (Subtype.ext h.symm))] ++ rw [ite_eq_right (fun h ↦ hb (Subtype.ext h.symm))] + · exact fun h ↦ absurd (Finset.mem_attach S _) h +- · rw [if_neg h𝔮, Finset.sum_eq_zero] ++ · rw [ite_eq_right h𝔮, Finset.sum_eq_zero] + rintro ⟨b, hb⟩ - +- rw [if_neg (fun h : 𝔮 = b ↦ h𝔮 (h.symm ▸ hb))] ++ rw [ite_eq_right (fun h : 𝔮 = b ↦ h𝔮 (h.symm ▸ hb))] + + open UniqueFactorizationMonoid in + /-- The normalized prime factors of `𝔞` as a `Finset` of nonzero prime ideals. -/ +@@ -624,9 +624,9 @@ private theorem factorization_idealOfExp_eq + classical + have hprod : (∏ 𝔭 ∈ S.attach, 𝔭.1.1 ^ (fun q ↦ if h : q ∈ S then f ⟨q, h⟩ else 0) 𝔭.1) + = ∏ 𝔭 ∈ S.attach, 𝔭.1.1 ^ f 𝔭 := +- Finset.prod_congr rfl fun 𝔭 _ ↦ by simp only [dif_pos 𝔭.2] ++ Finset.prod_congr rfl fun 𝔭 _ ↦ by simp only [dite_eq_left 𝔭.2] + rw [← hprod, factorization_prod_primePow_eq L S +- (fun q ↦ if h : q ∈ S then f ⟨q, h⟩ else 0) 𝔮.1, if_pos 𝔮.2, dif_pos 𝔮.2] ++ (fun q ↦ if h : q ∈ S then f ⟨q, h⟩ else 0) 𝔮.1, ite_eq_left 𝔮.2, dite_eq_left 𝔮.2] + + open UniqueFactorizationMonoid in + private theorem prod_primePow_count_eq (S : Finset {𝔭 : Ideal (𝓞 L) // 𝔭.IsPrime ∧ 𝔭 ≠ ⊥}) +diff --git a/projects/Chebotarev/CebotarevDensity/ZetaProduct.lean b/projects/Chebotarev/CebotarevDensity/ZetaProduct.lean +index 356695e9a..c67aa3c90 100644 +--- a/projects/Chebotarev/CebotarevDensity/ZetaProduct.lean ++++ b/projects/Chebotarev/CebotarevDensity/ZetaProduct.lean +@@ -172,11 +172,11 @@ private theorem norm_galoisCharacterOnIdeal_le_one + (χ : galoisCharacter K L) (𝔞 : Ideal (𝓞 K)) : + ‖galoisCharacterOnIdeal K L χ 𝔞‖ ≤ 1 := by + rw [galoisCharacterOnIdeal, norm_prod] +- refine Finset.prod_le_one (fun i _ ↦ norm_nonneg _) (fun 𝔭 _ ↦ ?_) ++ refine Finset.prod_le_one₀ (fun i _ ↦ norm_nonneg _) (fun 𝔭 _ ↦ ?_) + rw [norm_pow] + by_cases h : UnramifiedIn K L 𝔭 +- · rw [if_pos h, norm_galoisCharacter_out, one_pow] +- · rw [if_neg h, norm_zero] ++ · rw [ite_eq_left h, norm_galoisCharacter_out, one_pow] ++ · rw [ite_eq_right h, norm_zero] + exact zero_pow_le_one _ + + /-- Sharifi 7.1.18 (p. 141): Euler product for an abelian Galois +@@ -212,18 +212,18 @@ theorem exists_artinLSeries_eulerProduct_abelian + have hsupp : Function.mulSupport f ⊆ Set.range g := by + intro 𝔭 hmem + simp only [Function.mem_mulSupport, hf] at hmem +- haveI := 𝔭.2.1 ++ have := 𝔭.2.1 + have hunr : UnramifiedIn K L 𝔭.1 := by + by_contra hnr + apply hmem +- rw [hw, galoisCharacterOnIdeal_apply_prime K L χ 𝔭.1 𝔭.2.2, if_neg hnr, zero_mul, sub_zero, ++ rw [hw, galoisCharacterOnIdeal_apply_prime K L χ 𝔭.1 𝔭.2.2, ite_eq_right hnr, zero_mul, sub_zero, + inv_one] + exact ⟨⟨𝔭.1, 𝔭.2.1, hunr⟩, rfl⟩ + rw [← hg_inj.tprod_eq hsupp] + refine tprod_congr fun 𝔭 ↦ ?_ + simp only [hf, hg, hw] +- haveI := 𝔭.2.1 +- rw [galoisCharacterOnIdeal_apply_prime K L χ 𝔭.1 𝔭.2.2.ne_bot, if_pos 𝔭.2.2] ++ have := 𝔭.2.1 ++ rw [galoisCharacterOnIdeal_apply_prime K L χ 𝔭.1 𝔭.2.2.ne_bot, ite_eq_left 𝔭.2.2] + + /-! ### Sub-lemmas for `dedekindZeta_local_factor_eq_product_artin_local` + +@@ -350,7 +350,6 @@ private theorem cpow_neg_absNorm_eq_pow {a b : ℕ} (f : ℕ) (s : ℂ) + (h : b = a ^ f) : ((b : ℂ)) ^ (-s) = ((a : ℂ) ^ (-s)) ^ f := by + rw [h, Nat.cast_pow, ← Complex.natCast_cpow_natCast_mul, Complex.cpow_nat_mul] + +-set_option backward.isDefEq.respectTransparency false in + /-- Sharifi 7.1.16 (p. 141) local step: the local Euler factor at an + unramified prime `𝔭` of `K` factors as a product over characters. + Source quote (paraphrased identity): the local factor +@@ -365,12 +364,12 @@ theorem dedekindZeta_local_factor_eq_product_artin_local + (1 - (χ (frobeniusClass K L 𝔭).out : ℂ) * (Ideal.absNorm 𝔭 : ℂ) ^ (-s))⁻¹ := by + classical + open scoped IsMulCommutative in +- letI : CommGroup Gal(L/K) := inferInstance ++ let : CommGroup Gal(L/K) := inferInstance + set σ : Gal(L/K) := (frobeniusClass K L 𝔭).out + set Y : ℂ := (Ideal.absNorm 𝔭 : ℂ) ^ (-s) with hY + set f : ℕ := orderOf σ with hf +- haveI : Fintype Gal(L/K) := Fintype.ofFinite _ +- haveI : Fintype (Gal(L/K) →* ℂˣ) := Fintype.ofFinite _ ++ have : Fintype Gal(L/K) := Fintype.ofFinite _ ++ have : Fintype (Gal(L/K) →* ℂˣ) := Fintype.ofFinite _ + have hfpos : 0 < f := hf ▸ orderOf_pos_iff.mpr (isOfFinOrder_of_finite σ) + have hcount : Nat.card {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} + = Nat.card Gal(L/K) / f := by +@@ -383,29 +382,29 @@ theorem dedekindZeta_local_factor_eq_product_artin_local + = ((1 - Y ^ f) ^ (Nat.card Gal(L/K) / f))⁻¹ := by + rw [tprod_fintype, Finset.prod_inv_distrib, prod_galoisCharacter_one_sub σ Y, hf] + have hpbot : 𝔭 ≠ ⊥ := UnramifiedIn.ne_bot K L _hunr +- haveI : 𝔭.IsMaximal := ‹𝔭.IsPrime›.isMaximal hpbot +- haveI : Finite (𝔭.primesOver (𝓞 L)) := (IsDedekindDomain.primesOver_finite 𝔭 (𝓞 L)).to_subtype +- haveI : Finite {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} := ++ have : 𝔭.IsMaximal := ‹𝔭.IsPrime›.isMaximal hpbot ++ have : Finite (𝔭.primesOver (𝓞 L)) := (IsDedekindDomain.primesOver_finite 𝔭 (𝓞 L)).to_subtype ++ have : Finite {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} := + Finite.of_injective + (fun 𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} ↦ + (⟨𝔓.1, 𝔓.2.1, 𝔓.2.2.1⟩ : 𝔭.primesOver (𝓞 L))) +- fun _ _ hab ↦ Subtype.ext (by simpa using hab) +- haveI : Fintype {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} := Fintype.ofFinite _ ++ fun _ _ hab ↦ Subtype.ext (congrArg (fun q : 𝔭.primesOver (𝓞 L) ↦ q.1) hab) ++ have : Fintype {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥} := Fintype.ofFinite _ + have hterm : ∀ 𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver 𝔭 ∧ 𝔓 ≠ ⊥}, + (1 - (Ideal.absNorm 𝔓.1 : ℂ) ^ (-s))⁻¹ = (1 - Y ^ f)⁻¹ := by + intro 𝔓 +- haveI := 𝔓.2.1 +- haveI hlo : 𝔓.1.LiesOver 𝔭 := 𝔓.2.2.1 +- have hdeg : (𝔓.1.under (𝓞 K)).inertiaDeg' 𝔓.1 = f := by +- rw [Ideal.inertiaDeg'_algebraMap, hf] ++ have := 𝔓.2.1 ++ have hlo : 𝔓.1.LiesOver 𝔭 := 𝔓.2.2.1 ++ have : 𝔓.1.IsMaximal := 𝔓.2.1.isMaximal 𝔓.2.2.2 ++ have : (𝔓.1.under (𝓞 K)).IsMaximal := hlo.over ▸ ‹𝔭.IsMaximal› ++ have hdeg : 𝔓.1.inertiaDeg (𝓞 K) = f := by ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (𝔓.1.under (𝓞 K)) 𝔓.1, hf] + exact finrank_residue_eq_orderOf K L σ (frobeniusClass K L 𝔭) (Quotient.out_eq _) + 𝔭 _hunr rfl 𝔓.1 hlo +- haveI : 𝔓.1.LiesOver (𝔓.1.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓.1) +- have hpubot : 𝔓.1.under (𝓞 K) ≠ ⊥ := hlo.over ▸ hpbot +- haveI : (𝔓.1.under (𝓞 K)).IsPrime := hlo.over ▸ ‹𝔭.IsPrime› ++ have : 𝔓.1.LiesOver (𝔓.1.under (𝓞 K)) := Ideal.over_under (A := 𝓞 K) (P := 𝔓.1) ++ have : (𝔓.1.under (𝓞 K)).IsPrime := hlo.over ▸ ‹𝔭.IsPrime› + have hnorm : Ideal.absNorm 𝔓.1 = Ideal.absNorm 𝔭 ^ f := by +- rw [Ideal.absNorm_eq_pow_inertiaDeg'_of_liesOver 𝔓.1 (𝔓.1.under (𝓞 K)) inferInstance hpubot, +- hdeg, ← hlo.over] ++ rw [← Ideal.absNorm_pow_inertiaDeg 𝔭 𝔓.1, hdeg] + rw [cpow_neg_absNorm_eq_pow f s hnorm, hY] + rw [tprod_congr hterm, tprod_fintype, Finset.prod_const, Finset.card_univ, + ← Nat.card_eq_fintype_card, hcount, hRHS, Nat.card_eq_fintype_card, inv_pow] +@@ -460,7 +459,7 @@ open Classical in + (K L : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Algebra K L] [IsGalois K L] + [IsMulCommutative Gal(L/K)] (𝔭 : Ideal (𝓞 K)) [𝔭.IsPrime] (h𝔭 : 𝔭 ≠ ⊥) : + frobeniusIdeal K L 𝔭 = (frobeniusClass K L 𝔭).out := by +- letI : CommGroup Gal(L/K) := { mul_comm := mul_comm' } ++ let : CommGroup Gal(L/K) := { mul_comm := mul_comm' } + rw [frobeniusIdeal, UniqueFactorizationMonoid.normalizedFactors_irreducible + (Ideal.prime_of_isPrime h𝔭 ‹_›).irreducible, normalize_eq, Multiset.map_singleton, + Multiset.prod_singleton] +@@ -470,7 +469,7 @@ theorem frobeniusIdeal_mul + (K L : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Algebra K L] [IsGalois K L] + [IsMulCommutative Gal(L/K)] {𝔞 𝔟 : Ideal (𝓞 K)} (h𝔞 : 𝔞 ≠ ⊥) (h𝔟 : 𝔟 ≠ ⊥) : + frobeniusIdeal K L (𝔞 * 𝔟) = frobeniusIdeal K L 𝔞 * frobeniusIdeal K L 𝔟 := by +- letI : CommGroup Gal(L/K) := { mul_comm := mul_comm' } ++ let : CommGroup Gal(L/K) := { mul_comm := mul_comm' } + rw [frobeniusIdeal, frobeniusIdeal, frobeniusIdeal, + UniqueFactorizationMonoid.normalizedFactors_mul h𝔞 h𝔟, Multiset.map_add, Multiset.prod_add] + +@@ -479,7 +478,7 @@ theorem frobeniusIdeal_mul + (K L : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Algebra K L] [IsGalois K L] + [IsMulCommutative Gal(L/K)] : + frobeniusIdeal K L ⊤ = 1 := by +- letI : CommGroup Gal(L/K) := { mul_comm := mul_comm' } ++ let : CommGroup Gal(L/K) := { mul_comm := mul_comm' } + rw [frobeniusIdeal, ← Ideal.one_eq_top, UniqueFactorizationMonoid.normalizedFactors_one, + Multiset.map_zero, Multiset.prod_zero] + +@@ -495,7 +494,7 @@ theorem galoisCharacterOnIdeal_eq_char_frobeniusIdeal + [IsCyclotomicExtension {m} K L] (χ : galoisCharacter K L) {𝔞 : Ideal (𝓞 K)} + (hU : ∀ 𝔭 ∈ UniqueFactorizationMonoid.normalizedFactors 𝔞, UnramifiedIn K L 𝔭) : + galoisCharacterOnIdeal K L χ 𝔞 = (χ (frobeniusIdeal K L 𝔞) : ℂ) := by +- letI : CommGroup Gal(L/K) := { mul_comm := mul_comm' } ++ let : CommGroup Gal(L/K) := { mul_comm := mul_comm' } + have hfrob : (χ (frobeniusIdeal K L 𝔞) : ℂ) = + ((UniqueFactorizationMonoid.normalizedFactors 𝔞).map + (fun 𝔭 ↦ (χ (frobeniusClass K L 𝔭).out : ℂ))).prod := by +@@ -504,7 +503,7 @@ theorem galoisCharacterOnIdeal_eq_char_frobeniusIdeal + rfl + rw [galoisCharacterOnIdeal_eq_map_prod, hfrob] + refine congrArg Multiset.prod (Multiset.map_congr rfl fun 𝔭 h𝔭 ↦ ?_) +- rw [if_pos (hU 𝔭 h𝔭)] ++ rw [ite_eq_left (hU 𝔭 h𝔭)] + + open Classical in + /-- If the ideal character `χ(𝔞)` is nonzero then every prime factor of `𝔞` is unramified in `L` +@@ -516,7 +515,7 @@ private theorem unramifiedIn_of_mem_normalizedFactors_of_galoisCharacterOnIdeal_ + by_contra hnr + refine h ?_ + rw [galoisCharacterOnIdeal_eq_map_prod] +- exact Multiset.prod_eq_zero (Multiset.mem_map.mpr ⟨𝔭, h𝔭, if_neg hnr⟩) ++ exact Multiset.prod_eq_zero (Multiset.mem_map.mpr ⟨𝔭, h𝔭, ite_eq_right hnr⟩) + + open Classical in + /-- **Helper 1a (cardinality form) — value-fibre = unramified-supported Frobenius-value-fibre.** For +@@ -555,8 +554,8 @@ theorem charFibre_mem_range {G : Type*} [CommGroup G] [Finite G] (χ : G →* + (hζ : ζ ^ orderOf χ = 1) : + ∃ g : G, χ g = ζ := by + classical +- haveI : NeZero (orderOf χ) := ⟨(orderOf_pos_iff.mpr (isOfFinOrder_of_finite χ)).ne'⟩ +- haveI : Finite (MonoidHom.range χ) := ++ have : NeZero (orderOf χ) := ⟨(orderOf_pos_iff.mpr (isOfFinOrder_of_finite χ)).ne'⟩ ++ have : Finite (MonoidHom.range χ) := + Finite.of_surjective χ.rangeRestrict χ.rangeRestrict_surjective + have hpow : ∀ g : G, (χ g) ^ orderOf χ = 1 := fun g ↦ by + rw [← MonoidHom.pow_apply, pow_orderOf_eq_one, MonoidHom.one_apply] +@@ -620,8 +619,8 @@ private theorem unramifiedIn_of_coprime_absNorm + UnramifiedIn K L 𝔭 := by + classical + refine ⟨h𝔭, fun 𝔓 h𝔓max h𝔓lo ↦ ?_⟩ +- haveI := h𝔓lo +- haveI : 𝔓.IsPrime := h𝔓max.isPrime ++ have := h𝔓lo ++ have : 𝔓.IsPrime := h𝔓max.isPrime + rw [← not_dvd_differentIdeal_iff (A := 𝓞 K) (B := 𝓞 L)] + intro hdvd + obtain ⟨ζ, hζ⟩ := IsCyclotomicExtension.exists_isPrimitiveRoot K L +@@ -697,7 +696,7 @@ private theorem autToPow_frobeniusIdeal + intro hpa hcop + have hp' : p ≠ ⊥ := hp.ne_zero + have ha' : a ≠ ⊥ := ha +- haveI : p.IsPrime := Ideal.isPrime_of_prime hp ++ have : p.IsPrime := Ideal.isPrime_of_prime hp + have hsplit : Ideal.absNorm (p * a) = Ideal.absNorm p * Ideal.absNorm a := + map_mul Ideal.absNorm p a + have hcp : (Ideal.absNorm p).Coprime m := +@@ -885,7 +884,7 @@ private theorem card_fibre_eq_card_good_fibre + intro 𝔭 h𝔭 + rw [normalizedFactors_mul h0 h𝔟, Multiset.mem_add] at h𝔭 + rcases h𝔭 with h𝔭 | h𝔭 +- · haveI : 𝔭.IsPrime := Ideal.isPrime_of_prime (prime_of_normalized_factor _ h𝔭) ++ · have : 𝔭.IsPrime := Ideal.isPrime_of_prime (prime_of_normalized_factor _ h𝔭) + exact unramifiedIn_of_coprime_absNorm K L m 𝔭 + (prime_of_normalized_factor _ h𝔭).ne_zero + (coprime_absNorm_of_mem_factors_of_coprime K m hcop h𝔭) +@@ -921,18 +920,18 @@ omit [NumberField L] [FiniteDimensional K L] [IsMulCommutative Gal(L/K)] [NeZero + /-- The bad-supported ideals of norm `≤ N` form a finite set: they are a subset of the (finitely + many) ideals of norm `≤ N`. -/ + private theorem finite_isBadPart (N : ℕ) : {𝔟 : Ideal (𝓞 K) | IsBadPart K L m N 𝔟}.Finite := +- (Ideal.finite_setOf_absNorm_le (S := 𝓞 K) N).subset fun _ h𝔟 ↦ h𝔟.2.2 ++ (Ideal.finite_setOfPred_absNorm_le (S := 𝓞 K) N).subset fun _ h𝔟 ↦ h𝔟.2.2 + + open UniqueFactorizationMonoid in + /-- The L2 fibre subtype at `g` is finite (subset of all ideals of norm `≤ N`). -/ + private instance finite_L2 (g : Gal(L/K)) (N : ℕ) : + Finite {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ N ∧ + (∀ 𝔭 ∈ normalizedFactors 𝔞, UnramifiedIn K L 𝔭) ∧ frobeniusIdeal K L 𝔞 = g} := by +- haveI : Finite {I : Ideal (𝓞 K) // Ideal.absNorm I ≤ N} := +- (Ideal.finite_setOf_absNorm_le (S := 𝓞 K) N).to_subtype ++ have : Finite {I : Ideal (𝓞 K) // Ideal.absNorm I ≤ N} := ++ (Ideal.finite_setOfPred_absNorm_le (S := 𝓞 K) N).to_subtype + exact Finite.of_injective (β := {I : Ideal (𝓞 K) // Ideal.absNorm I ≤ N}) + (fun 𝔞 ↦ ⟨𝔞.1, 𝔞.2.2.1⟩) +- (fun _ _ hab ↦ Subtype.ext (by simpa using hab)) ++ (fun _ _ hab ↦ Subtype.ext (congrArg (fun q : {I : Ideal (𝓞 K) // Ideal.absNorm I ≤ N} ↦ q.1) hab)) + + omit [FiniteDimensional K L] [NeZero m] [IsCyclotomicExtension {m} K L] in + open UniqueFactorizationMonoid in +@@ -1054,7 +1053,7 @@ private theorem autToPow_range_le_realizedResidues + have hHtop : H = ⊤ := by + refine subgroup_eq_top_of_forall_frobenius_mem_of_coprime K L m H + (fun 𝔭 h𝔭p h𝔭ne h𝔭unr h𝔭cop ↦ ?_) +- haveI := h𝔭p ++ have := h𝔭p + rw [hH, Subgroup.mem_comap, autToPow_frobeniusClass_out K L m hζ 𝔭 h𝔭unr h𝔭cop] + exact ⟨⟨𝔭, mem_nonZeroDivisors_of_ne_zero h𝔭ne⟩, by rw [ZMod.coe_unitOfCoprime]⟩ + intro a ha +@@ -1203,7 +1202,7 @@ private theorem sum_rpow_le_euler_prod (K : Type*) [Field K] [NumberField K] + rw [Finset.prod_sum P (fun _ ↦ Finset.range (Kn + 1)) + (fun 𝔭 k ↦ (((Ideal.absNorm 𝔭 : ℝ)) ^ e) ^ k)] + _ ≤ ∏ 𝔭 ∈ P, (1 - ((Ideal.absNorm 𝔭 : ℝ)) ^ e)⁻¹ := by +- refine Finset.prod_le_prod ++ refine Finset.prod_le_prod₀ + (fun 𝔭 h𝔭 ↦ Finset.sum_nonneg fun k _ ↦ pow_nonneg (hx0 𝔭 h𝔭) k) (fun 𝔭 h𝔭 ↦ ?_) + have h1x : 0 < 1 - ((Ideal.absNorm 𝔭 : ℝ)) ^ e := by have := hxlt 𝔭 h𝔭; linarith + have hkey := geom_sum_mul (((Ideal.absNorm 𝔭 : ℝ)) ^ e) (Kn + 1) +@@ -1658,7 +1657,7 @@ private theorem coprime_absNorm_of_unramified_of_finrank_eq_one + by_contra hncop + obtain ⟨p, hpm, hpmem𝔭⟩ := exists_primeFactor_natCast_mem_of_not_coprime K m 𝔭 h𝔭 hncop + have hp : p.Prime := (Nat.mem_primeFactors.mp hpm).1 +- haveI : Fact p.Prime := ⟨hp⟩ ++ have : Fact p.Prime := ⟨hp⟩ + have hpdvd : p ∣ m := Nat.dvd_of_mem_primeFactors hpm + have hm0 : m ≠ 0 := (Nat.mem_primeFactors.mp hpm).2.2 + set v := m.factorization p with hv +@@ -1684,11 +1683,11 @@ private theorem coprime_absNorm_of_unramified_of_finrank_eq_one + have hφ2 : 2 ≤ p ^ k * (p - 1) := two_le_pow_mul_pred hp hbad + have hspan𝔭 : Ideal.span {(p : 𝓞 K)} = 𝔭 := + span_singleton_natCast_eq_of_finrank_eq_one K hd1 p hp 𝔭 hpmem𝔭 +- haveI : 𝔭.IsMaximal := ‹𝔭.IsPrime›.isMaximal h𝔭 ++ have : 𝔭.IsMaximal := ‹𝔭.IsPrime›.isMaximal h𝔭 + obtain ⟨𝔓, h𝔓max, h𝔓lo⟩ := + Ideal.exists_maximal_ideal_liesOver_of_isIntegral (R := 𝓞 K) (S := 𝓞 L) 𝔭 +- haveI : 𝔓.IsPrime := h𝔓max.isPrime +- haveI := h𝔓lo ++ have : 𝔓.IsPrime := h𝔓max.isPrime ++ have := h𝔓lo + have hnotdvd : ¬ 𝔓 ∣ differentIdeal (𝓞 K) (𝓞 L) := by + rw [not_dvd_differentIdeal_iff (A := 𝓞 K) (B := 𝓞 L)] + exact hunr.2 𝔓 h𝔓max h𝔓lo +@@ -1747,7 +1746,7 @@ private theorem card_fibre_bound_eq_one {ζ : L} (hζ : IsPrimitiveRoot ζ m) + rw [Ideal.one_eq_top] at this; exact htop this + obtain ⟨𝔭, h𝔭⟩ := Multiset.exists_mem_of_ne_zero hfac0 + have hprime := prime_of_normalized_factor 𝔭 h𝔭 +- haveI : 𝔭.IsPrime := Ideal.isPrime_of_prime hprime ++ have : 𝔭.IsPrime := Ideal.isPrime_of_prime hprime + exact (hfac 𝔭 h𝔭).2 (coprime_absNorm_of_unramified_of_finrank_eq_one K L m hd1 𝔭 + hprime.ne_zero (hfac 𝔭 h𝔭).1 hm) + rw [card_L2_eq_sum_residue K L m hζ g N, hbadtop, Finset.sum_singleton, +@@ -1819,9 +1818,9 @@ private theorem card_unramifiedSupported_frobeniusValueFibre_eq_sum + (∀ 𝔭 ∈ UniqueFactorizationMonoid.normalizedFactors 𝔞, UnramifiedIn K L 𝔭) ∧ + frobeniusIdeal K L 𝔞 = g.1} := by + classical +- haveI hfinN : Finite {𝔞 : Ideal (𝓞 K) // Ideal.absNorm 𝔞 ≤ N} := +- (Ideal.finite_setOf_absNorm_le (S := 𝓞 K) N).to_subtype +- haveI hfin : ∀ g : {g : Gal(L/K) // (χ g : ℂ) = ζ}, ++ have hfinN : Finite {𝔞 : Ideal (𝓞 K) // Ideal.absNorm 𝔞 ≤ N} := ++ (Ideal.finite_setOfPred_absNorm_le (S := 𝓞 K) N).to_subtype ++ have hfin : ∀ g : {g : Gal(L/K) // (χ g : ℂ) = ζ}, + Finite {𝔞 : Ideal (𝓞 K) // + 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ N ∧ + (∀ 𝔭 ∈ UniqueFactorizationMonoid.normalizedFactors 𝔞, UnramifiedIn K L 𝔭) ∧ +@@ -1916,7 +1915,7 @@ theorem exists_card_galoisCharacterOnIdeal_eq_const_mul_add_pow + rw [← hζuval] + exact ⟨fun h ↦ Units.ext h, fun h ↦ congrArg Units.val h⟩ + rw [heq] +- letI : CommGroup Gal(L/K) := { mul_comm := mul_comm' } ++ let : CommGroup Gal(L/K) := { mul_comm := mul_comm' } + exact card_charFibre_eq_card_ker χ ζu hζun + have hcardℝ : (Fintype.card {g : Gal(L/K) // (χ g : ℂ) = ζ} : ℝ) = (κ₀ : ℝ) := by + rw [← Nat.card_eq_fintype_card, hSκ₀] +@@ -1985,7 +1984,7 @@ private theorem galoisCharacterOnIdeal_mem_insert_zero_nthRootsFinset + · push Not at hU + obtain ⟨𝔭, h𝔭, hram⟩ := hU + rw [galoisCharacterOnIdeal_eq_map_prod, +- Multiset.prod_eq_zero (Multiset.mem_map.mpr ⟨𝔭, h𝔭, if_neg hram⟩)] ++ Multiset.prod_eq_zero (Multiset.mem_map.mpr ⟨𝔭, h𝔭, ite_eq_right hram⟩)] + exact Finset.mem_insert_self _ _ + + private theorem sum_galoisCharacterOnIdeal_eq_sum_card_sub_mul +@@ -2044,9 +2043,9 @@ many) ideals of norm `≤ N`. -/ + private theorem finite_nonzeroIdeal_absNorm_le (K : Type*) [Field K] [NumberField K] (N : ℕ) : + Finite {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ N} := + haveI : Finite {𝔞 : Ideal (𝓞 K) // Ideal.absNorm 𝔞 ≤ N} := +- (Ideal.finite_setOf_absNorm_le (S := 𝓞 K) N).to_subtype ++ (Ideal.finite_setOfPred_absNorm_le (S := 𝓞 K) N).to_subtype + Finite.of_injective (fun a ↦ (⟨a.1, a.2.2⟩ : {𝔞 : Ideal (𝓞 K) // Ideal.absNorm 𝔞 ≤ N})) +- fun _ _ hab ↦ Subtype.ext (by simpa using hab) ++ fun _ _ hab ↦ Subtype.ext (congrArg (fun q : {I : Ideal (𝓞 K) // Ideal.absNorm I ≤ N} ↦ q.1) hab) + + /-- Sharifi 7.1.19 step 1 (p. 142): geometry-of-numbers bound. The + partial-sum character sum `Σ_{N𝔞≤N} χ(𝔞)` (with `χ(𝔞) = galoisCharacterOnIdeal K L χ 𝔞` the +@@ -2067,7 +2066,7 @@ theorem character_sum_geometry_of_numbers_bound + refine ⟨(orderOf χ : ℝ) * C', fun N ↦ ?_⟩ + have hC' : 0 ≤ C' := (abs_nonneg _).trans (by simpa using hcount 1 (one_pow _) 1 le_rfl) + rcases Nat.eq_zero_or_pos N with rfl | hN1 +- · haveI : IsEmpty {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ 0} := ++ · have : IsEmpty {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ 0} := + ⟨fun 𝔞 ↦ 𝔞.2.1 (Ideal.absNorm_eq_zero_iff.mp (Nat.le_zero.mp 𝔞.2.2))⟩ + rw [tsum_empty, norm_zero] + positivity +@@ -2079,8 +2078,8 @@ theorem character_sum_geometry_of_numbers_bound + set R : Finset ℂ := Polynomial.nthRootsFinset (orderOf χ) (1 : ℂ) with hR + have hmemR : ∀ {z : ℂ}, z ∈ R ↔ z ^ orderOf χ = 1 := fun {z} ↦ + Polynomial.mem_nthRootsFinset (Nat.pos_of_ne_zero hord0) 1 +- haveI := finite_nonzeroIdeal_absNorm_le K N +- haveI := Fintype.ofFinite {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ N} ++ have := finite_nonzeroIdeal_absNorm_le K N ++ have := Fintype.ofFinite {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ N} + rw [tsum_fintype, sum_galoisCharacterOnIdeal_eq_sum_card_sub_mul K L m χ hord2 C₀ N] + calc ‖∑ v ∈ R, (((Nat.card {𝔞 : Ideal (𝓞 K) // + 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ N ∧ galoisCharacterOnIdeal K L χ 𝔞 = v} : ℝ) +@@ -2111,7 +2110,7 @@ private theorem finite_nonzeroIdeal_absNorm_eq + (K : Type*) [Field K] [NumberField K] (n : ℕ) : + Finite {𝔞 : NonzeroIdeal K // Ideal.absNorm 𝔞.1 = n} := + Set.Finite.to_subtype <| Set.Finite.of_finite_image (f := fun I : NonzeroIdeal K ↦ I.1) +- ((Ideal.finite_setOf_absNorm_eq (S := 𝓞 K) n).subset (by rintro _ ⟨⟨I, _⟩, rfl, rfl⟩; rfl)) ++ ((Ideal.finite_setOfPred_absNorm_eq (S := 𝓞 K) n).subset (by rintro _ ⟨⟨I, _⟩, rfl, rfl⟩; rfl)) + (fun _ _ _ _ ↦ Subtype.ext) + + /-- The `0`-th coefficient vanishes: no nonzero ideal has norm `0`, so the fibre is empty. -/ +@@ -2128,8 +2127,8 @@ private theorem norm_galoisCharacterCoeff_le + (K L : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Algebra K L] [IsGalois K L] + (χ : galoisCharacter K L) (n : ℕ) : + ‖galoisCharacterCoeff K L χ n‖ ≤ (idealNormMultiplicity K n : ℝ) := by +- haveI := finite_nonzeroIdeal_absNorm_eq K n +- haveI := Fintype.ofFinite {𝔞 : NonzeroIdeal K // Ideal.absNorm 𝔞.1 = n} ++ have := finite_nonzeroIdeal_absNorm_eq K n ++ have := Fintype.ofFinite {𝔞 : NonzeroIdeal K // Ideal.absNorm 𝔞.1 = n} + calc ‖galoisCharacterCoeff K L χ n‖ + ≤ ∑' 𝔞 : {𝔞 : NonzeroIdeal K // Ideal.absNorm 𝔞.1 = n}, + ‖galoisCharacterOnIdeal K L χ 𝔞.1.1‖ := +@@ -2154,8 +2153,8 @@ private theorem sum_galoisCharacterCoeff_eq_tsum_absNorm_le + ∑' 𝔞 : {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ n}, + galoisCharacterOnIdeal K L χ 𝔞.1 := by + classical +- haveI := finite_nonzeroIdeal_absNorm_le K n +- haveI := Fintype.ofFinite {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ n} ++ have := finite_nonzeroIdeal_absNorm_le K n ++ have := Fintype.ofFinite {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ n} + rw [tsum_fintype, ← Finset.sum_fiberwise_of_maps_to (t := Finset.Icc 1 n) + (g := fun 𝔞 : {𝔞 : Ideal (𝓞 K) // 𝔞 ≠ ⊥ ∧ Ideal.absNorm 𝔞 ≤ n} ↦ Ideal.absNorm 𝔞.1) + (fun 𝔞 _ ↦ Finset.mem_Icc.mpr +@@ -2163,8 +2162,8 @@ private theorem sum_galoisCharacterCoeff_eq_tsum_absNorm_le + (fun 𝔞 ↦ galoisCharacterOnIdeal K L χ 𝔞.1)] + refine Finset.sum_congr rfl fun k hk ↦ ?_ + rw [galoisCharacterCoeff, ← Finset.sum_subtype_eq_sum_filter, Finset.subtype_univ] +- haveI := finite_nonzeroIdeal_absNorm_eq K k +- haveI := Fintype.ofFinite {𝔞 : NonzeroIdeal K // Ideal.absNorm 𝔞.1 = k} ++ have := finite_nonzeroIdeal_absNorm_eq K k ++ have := Fintype.ofFinite {𝔞 : NonzeroIdeal K // Ideal.absNorm 𝔞.1 = k} + rw [tsum_fintype] + exact Fintype.sum_equiv + { toFun := fun ⟨⟨𝔞, h𝔞ne⟩, hnorm⟩ ↦ +@@ -2260,8 +2259,8 @@ private theorem setIntegral_Ioi_one_mul_cpow_eq_mellin (S : ℝ → ℂ) (hS : + ae_iff.mpr (by simp : volume {x : ℝ | ¬x ≠ 1} = 0)] with t ht _ + rw [indicator_apply] + by_cases h1 : t ∈ Ioi (1 : ℝ) +- · rw [if_pos h1] +- · rw [if_neg h1, hS t (lt_of_le_of_ne (not_lt.mp (by simpa using h1)) ht), smul_zero] ++ · rw [ite_eq_left h1] ++ · rw [ite_eq_right h1, hS t (lt_of_le_of_ne (not_lt.mp (by simpa using h1)) ht), smul_zero] + + open Filter Topology Set MeasureTheory Asymptotics in + /-- Sharifi 7.1.19 step 1b (p. 142) — analytic extension of `L(χ,·)`. +@@ -2467,7 +2466,7 @@ private theorem norm_one_sub_inv_sub_one_le {y : ℂ} (hy : ‖y‖ ≤ 1 / 2) : + + /-- A nonzero prime ideal `𝔭` of a number ring has `2 ≤ N𝔭`: its norm is neither `0` (only `⊥` has + norm `0`) nor `1` (only `⊤` has norm `1`). -/ +-private theorem two_le_absNorm {R : Type*} [CommRing R] [IsDedekindDomain R] ++private theorem two_le_absNorm {R : Type*} [CommRing R] [IsDedekindDomain R] [Infinite R] + [Module.Free ℤ R] [Module.Finite ℤ R] {𝔭 : Ideal R} (hp : 𝔭.IsPrime) (hb : 𝔭 ≠ ⊥) : + 2 ≤ Ideal.absNorm 𝔭 := by + have hne0 : Ideal.absNorm 𝔭 ≠ 0 := fun h ↦ hb (Ideal.absNorm_eq_zero_iff.mp h) +@@ -2476,7 +2475,7 @@ private theorem two_le_absNorm {R : Type*} [CommRing R] [IsDedekindDomain R] + + /-- For a nonzero prime `𝔭` of a number ring and `Re s > 1`, `‖N𝔭^{-s}‖ ≤ 1/2` (since `N𝔭 ≥ 2`, + `Re s > 1`). The bound that lets the Euler factors enter `norm_one_sub_inv_sub_one_le`. -/ +-private theorem norm_absNorm_cpow_neg_le_half {R : Type*} [CommRing R] [IsDedekindDomain R] ++private theorem norm_absNorm_cpow_neg_le_half {R : Type*} [CommRing R] [IsDedekindDomain R] [Infinite R] + [Module.Free ℤ R] [Module.Finite ℤ R] {s : ℂ} (hs : 1 < s.re) + (𝔭 : {𝔭 : Ideal R // 𝔭.IsPrime ∧ 𝔭 ≠ ⊥}) : + ‖(Ideal.absNorm 𝔭.1 : ℂ) ^ (-s)‖ ≤ 1 / 2 := by +@@ -2581,7 +2580,7 @@ private def underUP + (K L : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Algebra K L] [IsGalois K L] + (𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ UnramifiedIn K L (𝔓.under (𝓞 K))}) : + {𝔭 : Ideal (𝓞 K) // 𝔭.IsPrime ∧ UnramifiedIn K L 𝔭} := +- ⟨𝔓.1.under (𝓞 K), by haveI := 𝔓.2.1; exact inferInstance, 𝔓.2.2.2⟩ ++ ⟨𝔓.1.under (𝓞 K), by have := 𝔓.2.1; exact inferInstance, 𝔓.2.2.2⟩ + + @[simp] private theorem underUP_val + (K L : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Algebra K L] [IsGalois K L] +@@ -2600,8 +2599,8 @@ private def fiberUnderEquiv + toFun 𝔓 := ⟨𝔓.1.1, 𝔓.1.2.1, ⟨by + have h := congrArg Subtype.val 𝔓.2; rw [underUP_val] at h; rw [← h]⟩, 𝔓.1.2.2.1⟩ + invFun 𝔔 := ⟨⟨𝔔.1, 𝔔.2.1, 𝔔.2.2.2, by +- haveI := 𝔔.2.1; haveI := 𝔔.2.2.1; rw [← 𝔔.2.2.1.over]; exact c.2.2⟩, by +- haveI := 𝔔.2.1; haveI := 𝔔.2.2.1 ++ have := 𝔔.2.1; have := 𝔔.2.2.1; rw [← 𝔔.2.2.1.over]; exact c.2.2⟩, by ++ have := 𝔔.2.1; have := 𝔔.2.2.1 + exact Subtype.ext (by rw [underUP_val]; exact 𝔔.2.2.1.over.symm)⟩ + left_inv 𝔓 := by ext; rfl + right_inv 𝔔 := by ext; rfl +@@ -2632,7 +2631,6 @@ private def ramifiedFlattenEquiv + left_inv _ := rfl + right_inv _ := rfl + +-set_option backward.isDefEq.respectTransparency false in + /-- The unramified part of the prime-ideal Euler product equals `∏_χ L_χ`. Regroup the unramified + `L`-primes fibrewise over the `K`-prime below them (`Equiv.sigmaFiberEquiv` + + `Multipliable.tprod_sigma`); each fibre product is `∏_χ (1 - χ(σ_𝔭) N𝔭^{-s})^{-1}` +@@ -2672,16 +2670,16 @@ private theorem tprod_unramified_eq_prod_artinDirichletSeries + HasProd (fun 𝔓 : {𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ + UnramifiedIn K L (𝔓.under (𝓞 K))} // underUP K L 𝔓 = c} ↦ F 𝔓.1.1) (G c) := by + intro c +- haveI : c.1.IsPrime := c.2.1 +- haveI : c.1.IsMaximal := c.2.1.isMaximal (UnramifiedIn.ne_bot K L c.2.2) +- haveI : Finite (c.1.primesOver (𝓞 L)) := ++ have : c.1.IsPrime := c.2.1 ++ have : c.1.IsMaximal := c.2.1.isMaximal (UnramifiedIn.ne_bot K L c.2.2) ++ have : Finite (c.1.primesOver (𝓞 L)) := + (IsDedekindDomain.primesOver_finite c.1 (𝓞 L)).to_subtype +- haveI : Finite {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver c.1 ∧ 𝔓 ≠ ⊥} := ++ have : Finite {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver c.1 ∧ 𝔓 ≠ ⊥} := + Finite.of_injective + (fun 𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓.LiesOver c.1 ∧ 𝔓 ≠ ⊥} ↦ + (⟨𝔓.1, 𝔓.2.1, 𝔓.2.2.1⟩ : c.1.primesOver (𝓞 L))) +- (fun _ _ hab ↦ Subtype.ext (by simpa using hab)) +- haveI : Finite {𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ ++ (fun _ _ hab ↦ Subtype.ext (congrArg (fun q : c.1.primesOver (𝓞 L) ↦ q.1) hab)) ++ have : Finite {𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ + UnramifiedIn K L (𝔓.under (𝓞 K))} // underUP K L 𝔓 = c} := + Finite.of_equiv _ (fiberUnderEquiv K L c).symm + have hval : (∏' 𝔓 : {𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ +@@ -2786,12 +2784,12 @@ private instance finite_ramifiedAbove + (K L : Type*) [Field K] [NumberField K] [Field L] [NumberField L] [Algebra K L] [IsGalois K L] : + Finite {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ ¬ UnramifiedIn K L (𝔓.under (𝓞 K))} := by + classical +- haveI : Finite {𝔭 : Ideal (𝓞 K) // 𝔭.IsPrime ∧ 𝔭 ≠ ⊥ ∧ ¬ UnramifiedIn K L 𝔭} := ++ have : Finite {𝔭 : Ideal (𝓞 K) // 𝔭.IsPrime ∧ 𝔭 ≠ ⊥ ∧ ¬ UnramifiedIn K L 𝔭} := + (finite_ramifiedIn K L).to_subtype +- haveI : ∀ 𝔭 : {𝔭 : Ideal (𝓞 K) // 𝔭.IsPrime ∧ 𝔭 ≠ ⊥ ∧ ¬ UnramifiedIn K L 𝔭}, ++ have : ∀ 𝔭 : {𝔭 : Ideal (𝓞 K) // 𝔭.IsPrime ∧ 𝔭 ≠ ⊥ ∧ ¬ UnramifiedIn K L 𝔭}, + Finite (𝔭.1.primesOver (𝓞 L)) := fun 𝔭 ↦ by +- haveI : 𝔭.1.IsPrime := 𝔭.2.1 +- haveI : 𝔭.1.IsMaximal := 𝔭.2.1.isMaximal 𝔭.2.2.1 ++ have : 𝔭.1.IsPrime := 𝔭.2.1 ++ have : 𝔭.1.IsMaximal := 𝔭.2.1.isMaximal 𝔭.2.2.1 + exact (IsDedekindDomain.primesOver_finite 𝔭.1 (𝓞 L)).to_subtype + refine Finite.of_injective + (fun 𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ ¬ UnramifiedIn K L (𝔓.under (𝓞 K))} ↦ +@@ -2834,7 +2832,7 @@ private theorem log_norm_ramified_factor_bounded + ¬ UnramifiedIn K L (𝔓.under (𝓞 K))}, (1 - (Ideal.absNorm 𝔓.1 : ℂ) ^ (-(s : ℂ)))⁻¹‖| ≤ + C := by + classical +- haveI : Fintype {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ ++ have : Fintype {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ + ¬ UnramifiedIn K L (𝔓.under (𝓞 K))} := Fintype.ofFinite _ + set R : ℝ → ℂ := fun s ↦ ∏ 𝔓 : {𝔓 : Ideal (𝓞 L) // 𝔓.IsPrime ∧ 𝔓 ≠ ⊥ ∧ + ¬ UnramifiedIn K L (𝔓.under (𝓞 K))}, (1 - (Ideal.absNorm 𝔓.1 : ℂ) ^ (-(s : ℂ)))⁻¹ with hR +@@ -2932,7 +2930,7 @@ private theorem analyticAt_one_of_analyticOn_finrankDomain (K : Type*) [Field K] + have hdpos : (0 : ℝ) < (Module.finrank ℚ K : ℝ)⁻¹ := by + have : 0 < Module.finrank ℚ K := Module.finrank_pos + positivity +- simp only [Set.mem_setOf_eq, Complex.one_re]; linarith ++ simp only [Set.mem_ofPred_eq, Complex.one_re]; linarith + exact hLf.analyticAt ((isOpen_lt continuous_const Complex.continuous_re).mem_nhds hmem) + + open Filter Topology Set in +@@ -3034,8 +3032,8 @@ private theorem sum_ite_pole_zero_cancel + (if χ' = 1 then a else if χ' = χ then -a else 0) = + (if χ' = 1 then a else 0) + (if χ' = χ then -a else 0) := fun χ' ↦ by + by_cases h1 : χ' = 1 +- · rw [if_pos h1, if_pos h1, if_neg (h1 ▸ Ne.symm hχ), add_zero] +- · rw [if_neg h1, if_neg h1]; by_cases hc : χ' = χ <;> simp [hc] ++ · rw [ite_eq_left h1, ite_eq_left h1, ite_eq_right (h1 ▸ Ne.symm hχ), add_zero] ++ · rw [ite_eq_right h1, ite_eq_right h1]; by_cases hc : χ' = χ <;> simp [hc] + rw [Finset.sum_congr rfl fun χ' _ ↦ hsplit χ', Finset.sum_add_distrib, + Finset.sum_ite_eq' Finset.univ (1 : galoisCharacter K L), Finset.sum_ite_eq' Finset.univ χ] + simp +@@ -3061,14 +3059,14 @@ private theorem log_norm_artinDirichletSeries_le_pole_zero_ite + by_cases h1 : χ' = 1 + · subst h1 + obtain ⟨C1, hC1⟩ := log_norm_artinDirichletSeries_one_le K L +- exact ⟨C1, by filter_upwards [hC1] with s hs; rwa [if_pos rfl]⟩ ++ exact ⟨C1, by filter_upwards [hC1] with s hs; rwa [ite_eq_left rfl]⟩ + · by_cases hc : χ' = χ + · subst hc +- exact ⟨Cχ, by filter_upwards [hCχ] with s hs; rwa [if_neg h1, if_pos rfl]⟩ ++ exact ⟨Cχ, by filter_upwards [hCχ] with s hs; rwa [ite_eq_right h1, ite_eq_left rfl]⟩ + · obtain ⟨C, hC⟩ := artinDirichletSeries_norm_le_of_ne_one K L m hm χ' h1 + refine ⟨Real.log (max C 1), ?_⟩ + filter_upwards [hC] with s hs +- simp only [if_neg h1, if_neg hc, zero_add] ++ simp only [ite_eq_right h1, ite_eq_right hc, zero_add] + have hmax1 : (1 : ℝ) ≤ max C 1 := le_max_right _ _ + rcases le_total ‖artinDirichletSeries K L χ' (s : ℂ)‖ 0 with h0 | h0 + · have hz : ‖artinDirichletSeries K L χ' (s : ℂ)‖ = 0 := le_antisymm h0 (norm_nonneg _) +diff --git a/projects/DedekindResidue/DedekindResidue/AuxiliaryFunction.lean b/projects/DedekindResidue/DedekindResidue/AuxiliaryFunction.lean +index 8e22b1de6..f9545f056 100644 +--- a/projects/DedekindResidue/DedekindResidue/AuxiliaryFunction.lean ++++ b/projects/DedekindResidue/DedekindResidue/AuxiliaryFunction.lean +@@ -44,7 +44,7 @@ noncomputable def auxF (s : ℂ) (X t : ℝ) : ℂ := + + /-- On the plateau `|t| ≤ log X`, `F_{s,X}(t) = 1` — eq. (11). -/ + theorem auxF_of_le (s : ℂ) (X : ℝ) {t : ℝ} (h : |t| ≤ Real.log X) : auxF s X t = 1 := by +- unfold auxF; exact if_pos h ++ unfold auxF; exact ite_eq_left h + + /-- `F_{s,X}(0) = 1` whenever `X ≥ 1` (so `log X ≥ 0`, putting `0` on the plateau). -/ + theorem auxF_zero (s : ℂ) {X : ℝ} (hX : 1 ≤ X) : auxF s X 0 = 1 := +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/AnalyticControl.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/AnalyticControl.lean +index 5c23f3c90..8c56d23e6 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/AnalyticControl.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/AnalyticControl.lean +@@ -228,7 +228,7 @@ theorem exists_re_norm_dedekindZeta_ge_half : + · simp + rcases eq_or_ne n 0 with rfl | hn0 + · simp +- rw [if_neg hn1, LSeries.norm_term_eq, LSeries.norm_term_eq, if_neg hn0, if_neg hn0, ++ rw [ite_eq_right hn1, LSeries.norm_term_eq, LSeries.norm_term_eq, ite_eq_right hn0, ite_eq_right hn0, + show ((2:ℂ)).re = (2:ℝ) by norm_num] + have hn2 : (2:ℝ) ≤ (n:ℝ) := by exact_mod_cast (by omega : 2 ≤ n) + have hnpos : (0:ℝ) < n := by linarith +@@ -259,7 +259,7 @@ theorem exists_re_norm_dedekindZeta_ge_half : + refine Summable.of_nonneg_of_le (fun n => norm_nonneg _) (fun n => ?_) hsummS.norm + rcases eq_or_ne n 1 with rfl | hn1 + · simp +- · rw [if_neg hn1] ++ · rw [ite_eq_right hn1] + have hcompar : Summable (fun n : ℕ => (1/2:ℝ)^m * ‖LSeries.term f 2 n‖) := + (hsum2.norm).mul_left _ + have hRbound : ‖∑' n : ℕ, ite (n = 1) 0 (LSeries.term f s n)‖ ≤ T * (1/2)^m := by +@@ -463,7 +463,7 @@ theorem norm_dedekindZeta_le_of_two_le_re {s : ℂ} (hs : 2 ≤ s.re) : + intro n + rcases eq_or_ne n 0 with rfl | hn0 + · simp +- rw [LSeries.norm_term_eq, LSeries.norm_term_eq, if_neg hn0, if_neg hn0, ++ rw [LSeries.norm_term_eq, LSeries.norm_term_eq, ite_eq_right hn0, ite_eq_right hn0, + show ((2:ℂ)).re = (2:ℝ) by norm_num] + have hn1 : (1:ℝ) ≤ (n:ℝ) := by exact_mod_cast Nat.one_le_iff_ne_zero.mpr hn0 + gcongr +@@ -602,11 +602,10 @@ theorem one_add_abs_im_le_two_norm_sub_four {z : ℂ} (_h1 : -1 ≤ z.re) (h2 : + simpa using h + linarith + +-/-- The comparator sine-exponent: `n_K = r₁ + 2r₂`. -/ ++ + noncomputable def gammaExponent : ℕ := nrRealPlaces K + 2 * nrComplexPlaces K + +-/-- Right boundary bound for the comparator +-`G = H⁴·sin(πz)^{n_K}/(z-4)^{4n_K+8}` on `Re z = 2`. -/ ++ + theorem comparator_bound_right : + ∃ M : ℝ, 0 < M ∧ ∀ t : ℝ, + ‖completedDedekindZetaEntire K (((2:ℝ) : ℂ) + (t : ℂ) * Complex.I)‖^4 +@@ -715,8 +714,7 @@ theorem comparator_bound_right : + + (B * 25)^4 * Real.exp ((n:ℝ) * (π * 2)) / 2^(4*n+8) := + le_add_of_nonneg_left (by positivity) + +-/-- Left boundary bound for the comparator on `Re z = -1`, by reflecting to the right +-boundary through the functional equation. -/ ++ + theorem comparator_bound_left : + ∃ M : ℝ, 0 < M ∧ ∀ t : ℝ, + ‖completedDedekindZetaEntire K (((-1:ℝ) : ℂ) + (t : ℂ) * Complex.I)‖^4 +@@ -794,10 +792,7 @@ theorem comparator_bound_left : + (by positivity) (pow_le_pow_left₀ (norm_nonneg _) hden _) + _ ≤ M := hM (-t) + +-/-- Sub-double-exponential growth of the AC-A3 comparator +-`completedDedekindZetaEntire K ^ 4 * sin (π z) ^ n / (z - 4) ^ (4 n + 8)` on the strip +-`-1 ≤ Re ≤ 2`, from the polynomial strip bound `‖H‖ ≤ B (1 + ‖z‖)²`. Supplies the +-growth hypothesis of the Phragmén–Lindelöf step in `comparator_bound_strip`. -/ ++ + private theorem comparator_isBigO_growth {B : ℝ} (hB0 : 0 ≤ B) + (hB : ∀ w : ℂ, -1 ≤ w.re → w.re ≤ 2 → + ‖completedDedekindZetaEntire K w‖ ≤ B * (1 + ‖w‖) ^ 2) : +@@ -904,8 +899,7 @@ private theorem comparator_isBigO_growth {B : ℝ} (hB0 : 0 ≤ B) + nlinarith + exact mul_le_mul_of_nonneg_left hexp_le (by positivity) + +-/-- **The comparator is bounded on the whole strip** `-1 ≤ Re z ≤ 2` +-(Phragmén–Lindelöf between the two boundary bounds). -/ ++ + theorem comparator_bound_strip : + ∃ M : ℝ, 0 < M ∧ ∀ z : ℂ, -1 ≤ z.re → z.re ≤ 2 → + ‖completedDedekindZetaEntire K z^4 * Complex.sin (π * z)^(gammaExponent K) +@@ -925,7 +919,7 @@ theorem comparator_bound_strip : + simp [sub_eq_zero] at this + rw [this] at hw + norm_num at hw +- -- differentiability up to the boundary ++ + have hfd : DiffContOnCl ℂ f (Complex.re ⁻¹' Set.Ioo (-1 : ℝ) 2) := by + have hcl : closure (Complex.re ⁻¹' Set.Ioo (-1 : ℝ) 2) + ⊆ Complex.re ⁻¹' Set.Icc (-1 : ℝ) 2 := +@@ -946,7 +940,7 @@ theorem comparator_bound_strip : + fun z => Real.exp (Bg * Real.exp (c * |z.im|)) := by + simp only [hf, hn] + exact comparator_isBigO_growth K hB0 hB +- -- boundary bounds in PL form ++ + have hle_a : ∀ w : ℂ, w.re = -1 → ‖f w‖ ≤ M₁ + M₂ := by + intro w hw + have hweq : w = ((-1:ℝ) : ℂ) + (w.im : ℂ) * Complex.I := by +@@ -995,7 +989,7 @@ theorem exists_H_strip_decay : + set t : ℝ := z.im with hts + set C₀ : ℝ := (M * 5^(4*n+8) * 3^n) ^ ((1:ℝ)/4) + 1 with hC₀ + have hC₀0 : 0 < C₀ := by positivity +- -- the comparator bound, cleared of the normalizer ++ + have hcomp := hM z h1 h2 + rw [norm_div, norm_mul, norm_pow, norm_pow, norm_pow] at hcomp + -- sine lower bound +@@ -1041,7 +1035,7 @@ theorem exists_H_strip_decay : + rw [abs_sub_comm, abs_of_pos (by linarith : (0:ℝ) < 4 - z.re)] + linarith + nlinarith [abs_nonneg t] +- -- solve the comparator inequality for ‖H‖⁴ ++ + have hsinpos : (0:ℝ) < ‖Complex.sin (π * z)‖ := by + have h3 : (0:ℝ) < Real.exp (π * |t|) / 3 := by positivity + linarith +@@ -1656,8 +1650,7 @@ theorem exists_H_upper_right (σ₁ : ℝ) (hσ₁ : 2 ≤ σ₁) : + rw [pow_add] + ring + +-/-- Sphere-sup bound for the Jensen ball: at center `A+iT` with radius `A+1`, every +-point of the closed ball satisfies the decaying envelope bound (in terms of `|T|`). -/ ++ + theorem exists_H_ball_sup (A : ℝ) (hA : 2 ≤ A) : + ∃ C : ℝ, 0 < C ∧ ∃ P : ℕ, ∀ T : ℝ, A + 5 ≤ |T| → + ∀ z ∈ Metric.closedBall ((A : ℂ) + (T : ℂ) * Complex.I) (A + 1), +@@ -1743,10 +1736,7 @@ theorem exists_H_ball_sup (A : ℝ) (hA : 2 ≤ A) : + rw [mul_pow] + ring + +-/-- **AC-A4: per-height zero counting.** There are an abscissa `A` and a constant `C` +-such that for all heights `|T| ≥ A+5`, the number of zeros of `H` (with multiplicity) +-in the closed ball of radius `√(A²+1)` around `A+iT` — a ball containing the critical +-slab `0 ≤ Re ≤ 1`, `|Im - T| ≤ 1` — is at most `C·log(2+|T|)`. -/ ++ + theorem exists_ball_zero_count : + ∃ A : ℝ, 2 ≤ A ∧ ∃ C : ℝ, 0 < C ∧ ∀ T : ℝ, A + 5 ≤ |T| → + ((∑ᶠ u, (MeromorphicOn.divisor (completedDedekindZetaEntire K) +@@ -1858,7 +1848,7 @@ theorem exists_ball_zero_count : + meromorphicOrderAt (fun _ : ℂ => (completedDedekindZetaEntire K c)⁻¹) z ≠ ⊤ := by + intro z _ + classical +- rw [meromorphicOrderAt_const, if_neg (inv_ne_zero hHcne)] ++ rw [meromorphicOrderAt_const, ite_eq_right (inv_ne_zero hHcne)] + exact WithTop.zero_ne_top + have hcmem : c ∈ Metric.closedBall c |Real.sqrt (A^2+1)| := by + rw [habs_r] +@@ -2079,10 +2069,7 @@ theorem exists_H_ball_factorization (c : ℂ) {R : ℝ} + congr 1 + rw [Function.FactorizedRational.finprod_eq_fun hfinsupp] + +-/-- Sphere-sup bound for the Landau ball: at center `A+iT` with the larger radius +-`A+3`, every point of the closed ball satisfies the decaying envelope bound (in +-terms of `|T|`). Left of the critical strip the functional equation reflects the +-bound from the right half-plane. -/ ++ + theorem exists_H_ball_sup_big (A : ℝ) (hA : 2 ≤ A) : + ∃ C : ℝ, 0 < C ∧ ∃ P : ℕ, ∀ T : ℝ, A + 5 ≤ |T| → + ∀ z ∈ Metric.closedBall ((A : ℂ) + (T : ℂ) * Complex.I) (A + 3), +@@ -2186,10 +2173,7 @@ theorem exists_H_ball_sup_big (A : ℝ) (hA : 2 ≤ A) : + rw [mul_pow] + ring + +-/-- **Per-height zero counting at the Landau radius.** Given the abscissa `A` with the +-envelope-matched center lower bound, the number of zeros of `H` (with multiplicity) in +-the closed ball of radius `A+2` around `A+iT` is at most `C·log(2+|T|)`. Parametric in +-`A` and the center bound so that downstream users can share one `A`. -/ ++ + theorem exists_ball_zero_count_big (A : ℝ) (hA2 : 2 ≤ A) (cL : ℝ) (hcL : 0 < cL) + (hlow : ∀ t : ℝ, 2 ≤ |t| → + cL * Real.exp (-(((gammaExponent K : ℕ) : ℝ) * (π * |t|)) / 4) +@@ -2298,7 +2282,7 @@ theorem exists_ball_zero_count_big (A : ℝ) (hA2 : 2 ≤ A) (cL : ℝ) (hcL : 0 + meromorphicOrderAt (fun _ : ℂ => (completedDedekindZetaEntire K c)⁻¹) z ≠ ⊤ := by + intro z _ + classical +- rw [meromorphicOrderAt_const, if_neg (inv_ne_zero hHcne)] ++ rw [meromorphicOrderAt_const, ite_eq_right (inv_ne_zero hHcne)] + exact WithTop.zero_ne_top + have hcmem : c ∈ Metric.closedBall c |A + 2| := by + rw [habs_r] +@@ -2482,11 +2466,7 @@ theorem exists_H_two_radius_factorization (c : ℂ) {r₁ r₂ : ℝ} (h12 : r + rw [hfac z hz, hsplit z] + ring + +-/-- **Landau's logarithmic-derivative bound** (A5-ii-c, generic form): if `h` is +-holomorphic and zero-free on `ball c r` with `‖h‖ ≤ mS` there and `mL ≤ ‖h c‖` at the +-center, then `‖h'/h‖ ≤ 32·r·(log(mS/mL) + 1)` on the concentric closed ball of radius +-`r - 3/4`. Chain: holomorphic logarithm on the convex ball, Borel–Carathéodory from the +-`Re`-bound `log(mS/mL)`, then the Schwarz derivative estimate on quarter-balls. -/ ++ + theorem norm_logDeriv_le_of_norm_le {h : ℂ → ℂ} {c : ℂ} {r : ℝ} (hr : 3/4 < r) + (hd : DifferentiableOn ℂ h (Metric.ball c r)) + (h0 : ∀ z ∈ Metric.ball c r, h z ≠ 0) +@@ -2535,7 +2515,7 @@ theorem norm_logDeriv_le_of_norm_le {h : ℂ → ℂ} {c : ℂ} {r : ℝ} (hr : + intro w hw + refine Complex.borelCaratheodory_zero hM0 hGd ?_ hr0 hw ?_ + · intro x hx +- simp only [Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq] + refine hreG (c + x) ?_ + rw [Metric.mem_ball] at hx ⊢ + simpa [dist_eq_norm] using hx +@@ -2630,7 +2610,7 @@ private theorem pow_sum_toNat_le_norm_prod_sub {F : Finset ℂ} {D : ℂ → ℤ + (hzu : ∀ u ∈ F, b ≤ ‖z - u‖) : + b ^ (∑ u ∈ F, (D u).toNat) ≤ ‖∏ u ∈ F, (z - u) ^ D u‖ := by + rw [norm_prod_sub_zpow hD, ← Finset.prod_pow_eq_pow_sum] +- exact Finset.prod_le_prod (fun u _ => by positivity) ++ exact Finset.prod_le_prod₀ (fun u _ => by positivity) + (fun u hu => pow_le_pow_left₀ hb (hzu u hu) _) + + /-- Upper bound for the norm of a monic-type product: if every factor distance `‖z - u‖` +@@ -2640,13 +2620,10 @@ private theorem norm_prod_sub_le_pow {F : Finset ℂ} {D : ℂ → ℤ} + (hzu : ∀ u ∈ F, ‖z - u‖ ≤ B) : + ‖∏ u ∈ F, (z - u) ^ D u‖ ≤ B ^ (∑ u ∈ F, (D u).toNat) := by + rw [norm_prod_sub_zpow hD, ← Finset.prod_pow_eq_pow_sum] +- exact Finset.prod_le_prod (fun u _ => by positivity) ++ exact Finset.prod_le_prod₀ (fun u _ => by positivity) + (fun u hu => pow_le_pow_left₀ (norm_nonneg _) (hzu u hu) _) + +-/-- **Divisor monotonicity from an open ball to its closed ball.** For an everywhere-analytic +-`f`, the (nonnegative) zero-count divisor over `ball c r` sums to at most the divisor over +-`closedBall c r`, since the local orders agree and the open-ball support is contained in the +-closed-ball support. -/ ++ + private theorem finsum_divisor_ball_le_closedBall {f : ℂ → ℂ} + (hf : ∀ z : ℂ, AnalyticAt ℂ f z) (c : ℂ) (r : ℝ) : + (∑ᶠ u, (MeromorphicOn.divisor f (Metric.ball c r)) u) +@@ -2692,9 +2669,7 @@ private theorem finsum_divisor_ball_le_closedBall {f : ℂ → ℂ} + exact hu (hfin₁.mem_toFinset.mpr (Function.mem_support.mpr h0))) + _ ≤ ∑ u ∈ hfincl.toFinset, Dcl u := Finset.sum_le_sum (fun u _ => hpt u) + +-/-- **Maximum-modulus sup bound on a closed ball from a bound on its sphere.** If `f` is +-analytic on the open ball `ball c R` and `‖f‖ ≤ C` on the sphere `sphere c ρ` (with +-`0 < ρ < R`), then `‖f‖ ≤ C` on the whole closed ball `closedBall c ρ`. -/ ++ + private theorem norm_le_of_frontier_ball {f : ℂ → ℂ} {c : ℂ} {ρ R : ℝ} + (hρ : 0 < ρ) (hρR : ρ < R) + (hanal : AnalyticOnNhd ℂ f (Metric.ball c R)) +@@ -2891,7 +2866,7 @@ theorem exists_H_landau_cofactor : + _ ≤ ((∑ᶠ u, (MeromorphicOn.divisor (completedDedekindZetaEntire K) + (Metric.closedBall c (A+2))) u : ℤ) : ℝ) := by exact_mod_cast hDnatZ_le + _ ≤ Cc * Real.log (2 + |T|) := hclosed +- -- export the open-ball zero count ++ + have hcount_open : ((∑ᶠ u, D₁ u : ℤ) : ℝ) + ≤ (32 * (A+2) + * (|Real.log (cB/cL)| + (P+Pn) + Cc * Real.log (2*(A+2)) + 1) + Cc) +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/Existence.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/Existence.lean +index d305719d4..3dc187db1 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/Existence.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/Existence.lean +@@ -48,7 +48,7 @@ theorem prod_place_gamma (σ : ℝ) : + rw [Finset.prod_const, Finset.card_univ]] + refine Finset.prod_congr rfl (fun w _ => ?_) + rw [show (mult (w : InfinitePlace K) : ℝ) = 1 by +- rw [mult, if_pos w.2] ++ rw [mult, ite_eq_left w.2] + norm_num] + norm_num + · rw [show (π ^ (-(2 * σ)) * Real.Gamma (2 * σ)) ^ (nrComplexPlaces K) +@@ -60,7 +60,7 @@ theorem prod_place_gamma (σ : ℝ) : + (fun w : InfinitePlace K => not_isReal_iff_isComplex))).trans rfl).symm] + refine Finset.prod_congr rfl (fun w _ => ?_) + rw [show (mult (w : InfinitePlace K) : ℝ) = 2 by +- rw [mult, if_neg w.2] ++ rw [mult, ite_eq_right w.2] + norm_num] + + open scoped Classical in +@@ -231,7 +231,7 @@ theorem analyticOnNhd_completedDedekindZeta : + intro h + have : z = 0 := by linear_combination (2:ℂ) * h + rw [this] at hz +- norm_num [Set.mem_setOf_eq] at hz ++ norm_num [Set.mem_ofPred_eq] at hz + have hzk : z / 2 ≠ (((heckeFEPair K).k : ℝ) : ℂ) := by + intro h + rw [show (heckeFEPair K).k = 1/2 from rfl] at h +@@ -239,7 +239,7 @@ theorem analyticOnNhd_completedDedekindZeta : + push_cast at h + linear_combination (2:ℂ) * h + rw [this] at hz +- norm_num [Set.mem_setOf_eq] at hz ++ norm_num [Set.mem_ofPred_eq] at hz + have hd := (heckeFEPair K).differentiableAt_Λ (Or.inl hz2) (Or.inl hzk) + have hhalf : DifferentiableAt ℂ (fun w : ℂ => w / 2) z := by fun_prop + exact DifferentiableAt.comp (𝕜 := ℂ) (g := (heckeFEPair K).Λ) +@@ -358,7 +358,7 @@ theorem completedDedekindZeta_eq_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : + exact (LSeries_hasDerivAt hz').differentiableAt + have hF₂ := analyticOnNhd_completedZetaPrefactor_mul_dedekindZeta K hζat + have h2mem : (2:ℂ) ∈ {z : ℂ | 1 < z.re} := by +- norm_num [Set.mem_setOf_eq] ++ norm_num [Set.mem_ofPred_eq] + have hfreq := frequently_completedDedekindZeta_eq K + have hEq := hF₁.eqOn_of_preconnected_of_frequently_eq hF₂ hUconn h2mem hfreq + exact hEq hs +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/FunctionalEquation.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/FunctionalEquation.lean +index e9cae2b15..8df65b3b9 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/FunctionalEquation.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/FunctionalEquation.lean +@@ -82,10 +82,10 @@ theorem IsCompletedDedekindZeta.eqOn {K : Type*} [Field K] [NumberField K] + intro s hs + have hs0' : s ≠ 0 := by + rintro rfl +- norm_num [Set.mem_setOf_eq, Complex.zero_re] at hs ++ norm_num [Set.mem_ofPred_eq, Complex.zero_re] at hs + have hs1' : s ≠ 1 := by + rintro rfl +- norm_num [Set.mem_setOf_eq, Complex.one_re] at hs ++ norm_num [Set.mem_ofPred_eq, Complex.one_re] at hs + rw [hH₁eq s hs0' hs1', hH₂eq s hs0' hs1', h₁.1 s hs, h₂.1 s hs] + have h2mem : (2 : ℂ) ∈ {s : ℂ | 1 < s.re} := by norm_num [Complex.ofReal_re] + have := AnalyticOnNhd.eqOn_of_preconnected_of_eventuallyEq +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/HeckeTheta.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/HeckeTheta.lean +index 372944eb4..ba69d2efb 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/HeckeTheta.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/HeckeTheta.lean +@@ -8,23 +8,6 @@ module + public import Mathlib + public import DedekindResidue.CompletedZeta.IdealLattice + +-/-! +-# The multivariable Hecke theta of a fractional ideal (SP1-AGE-3) +- +-Hecke's functional-equation argument for a number field of unit rank `> 0` uses the +-**multivariable** theta of an ideal lattice, with one weight per infinite place, averaged +-over a fundamental domain of the unit action. This file builds the per-place weight +-machinery and the theta function itself: +- +-* `placeWeights c` — expand per-place weights to the `index K` coordinates (equal on the +- `(re, im)` pair of a complex place — the shape preserved by the unit action, since complex +- multiplication mixes the pair but preserves `re² + im²`); +-* `sum_placeWeights_embeddingCoords_sq` — `∑ᵢ c_i·ζ(x)ᵢ² = ∑_w c_w·w(x)²`: the weighted +- square-sum of embedding coordinates is the place-absolute-value form. +- +-The unit equivariance `Θ(c·w(ε)², L_I) = Θ(c, L_I)` and the box-averaged `g_I` follow +-(SP1-AGE-3 continuation), then the Mellin definition of `Λ_K` (AGE-4). +--/ + + namespace DedekindResidue + +@@ -36,8 +19,7 @@ open scoped nonZeroDivisors Real + + variable (K : Type*) [Field K] [NumberField K] + +-/-- The `ℝ`-cast field degree `[K : ℚ]` is positive — the packaged `Module.finrank_pos` used +-for the degree denominators throughout the Hecke-weight normalisation. -/ ++ + theorem finrank_pos_real : (0 : ℝ) < (Module.finrank ℚ K : ℝ) := by + have := Module.finrank_pos (R := ℚ) (M := K) + positivity +@@ -198,10 +180,10 @@ theorem placeWeights_dualPlaceWeights (c : InfinitePlace K → ℝ) (i : index K + placeWeights K (dualPlaceWeights K c) i + = (placeWeights K c i)⁻¹ * (dualityWeights K i) ^ 2 := by + rcases i with w | ⟨w, j⟩ +- · simp only [placeWeights, Sum.elim_inl, dualPlaceWeights, dualityWeights, if_pos w.2] ++ · simp only [placeWeights, Sum.elim_inl, dualPlaceWeights, dualityWeights, ite_eq_left w.2] + norm_num + · simp only [placeWeights, Sum.elim_inr, dualPlaceWeights, dualityWeights] +- rw [if_neg (by rw [not_isReal_iff_isComplex]; exact w.2)] ++ rw [ite_eq_right (by rw [not_isReal_iff_isComplex]; exact w.2)] + fin_cases j <;> norm_num <;> ring + + open scoped Classical in +@@ -237,7 +219,6 @@ theorem heckeTheta_inversion (I : (FractionalIdeal (𝓞 K)⁰ K)ˣ) + ring + + +- + open scoped Classical in + /-- Extend hyperplane coordinates `u : logSpace K` (indexed by `w ≠ w₀`) to all infinite + places by the trace-zero condition: the `w₀`-component is `-∑_{w ≠ w₀} u_w`. On the image of +@@ -268,10 +249,8 @@ theorem fullLog_add (u v : logSpace K) : + · rfl + + open scoped Classical in +-/-- **The Hecke weight family**: `c(t,u)_w = t^{1/n}·exp(2·(trace-zero extension of u)_w / mult w)`. +-Pinned by two requirements: `∏_w c_w^{mult w} = t` (the norm ray, giving `N(𝔞)^{-s}` under the +-Mellin transform) and equivariance under `u ↦ u + logEmbedding ε` matching +-`heckeTheta_unit_mul` (making the theta integrand periodic modulo the unit lattice). -/ ++ ++ + noncomputable def heckeWeights (t : ℝ) (u : logSpace K) : InfinitePlace K → ℝ := fun w => + t ^ ((1 : ℝ) / (Module.finrank ℚ K)) * Real.exp (2 * fullLog K u w / mult w) + +@@ -322,11 +301,11 @@ theorem sum_fullLog (u : logSpace K) : ∑ w : InfinitePlace K, fullLog K u w = + have h1 : fullLog K u (w₀ : InfinitePlace K) + = -∑ w' : {w : InfinitePlace K // w ≠ (w₀ : InfinitePlace K)}, u w' := by + rw [fullLog] +- exact dif_pos rfl ++ exact dite_eq_left rfl + have h2 : ∀ w : {w : InfinitePlace K // w ≠ (w₀ : InfinitePlace K)}, + fullLog K u (w : InfinitePlace K) = u w := by + intro w +- rw [fullLog, dif_neg w.2] ++ rw [fullLog, dite_eq_right w.2] + rw [h1, Finset.sum_congr rfl (fun w _ => h2 w)] + ring + +@@ -404,7 +383,7 @@ theorem prod_placeWeights (c : InfinitePlace K → ℝ) : + congr 1 + · refine Finset.prod_congr rfl (fun w _ => ?_) + simp only [placeWeights, Sum.elim_inl] +- rw [mult, if_pos w.2, pow_one] ++ rw [mult, ite_eq_left w.2, pow_one] + · have hre : (∏ i : {w : InfinitePlace K // ¬ IsReal w}, c ↑i ^ mult (i : InfinitePlace K)) + = ∏ w : {w : InfinitePlace K // IsComplex w}, c ↑w ^ mult (w : InfinitePlace K) := + Fintype.prod_equiv (Equiv.subtypeEquivRight +@@ -413,7 +392,7 @@ theorem prod_placeWeights (c : InfinitePlace K → ℝ) : + refine Finset.prod_congr rfl (fun w _ => ?_) + rw [Fin.prod_univ_two] + simp only [placeWeights, Sum.elim_inr] +- rw [mult, if_neg (by rw [not_isReal_iff_isComplex]; exact w.2)] ++ rw [mult, ite_eq_right (by rw [not_isReal_iff_isComplex]; exact w.2)] + ring + + open scoped Classical in +@@ -471,7 +450,7 @@ theorem fullLog_dualShift (w : InfinitePlace K) : + (mult (w : InfinitePlace K) : ℝ) / 2 * + (if IsReal (w : InfinitePlace K) then 0 else Real.log 4)) = 0 := by + refine Finset.sum_eq_zero (fun w _ => ?_) +- rw [if_pos w.2, mul_zero] ++ rw [ite_eq_left w.2, mul_zero] + have hc : (∑ w : {w : InfinitePlace K // ¬ IsReal w}, + (mult (w : InfinitePlace K) : ℝ) / 2 * + (if IsReal (w : InfinitePlace K) then 0 else Real.log 4)) +@@ -480,7 +459,7 @@ theorem fullLog_dualShift (w : InfinitePlace K) : + (mult (w : InfinitePlace K) : ℝ) / 2 * + (if IsReal (w : InfinitePlace K) then 0 else Real.log 4) = Real.log 4 := by + intro w +- rw [if_neg w.2, mult, if_neg w.2] ++ rw [ite_eq_right w.2, mult, ite_eq_right w.2] + norm_num + rw [Finset.sum_congr rfl (fun w _ => hterm w), Finset.sum_const, nsmul_eq_mul] + congr 1 +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/MellinAgreement.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/MellinAgreement.lean +index c1ddb8fb9..cb30568d9 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/MellinAgreement.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/MellinAgreement.lean +@@ -341,7 +341,7 @@ theorem lintegral_eq_tsum_box_shift (f : logSpace K → ℝ≥0∞) : + classical + set B := (basisUnitLattice K).ofZLatticeBasis ℝ with hB + have hFD := ZSpan.isAddFundamentalDomain B volume +- haveI : VAddInvariantMeasure (Submodule.span ℤ (Set.range ⇑B)) (logSpace K) volume := ++ have : VAddInvariantMeasure (Submodule.span ℤ (Set.range ⇑B)) (logSpace K) volume := + inferInstanceAs + (VAddInvariantMeasure (Submodule.span ℤ (Set.range ⇑B)).toAddSubgroup + (logSpace K) volume) +@@ -453,11 +453,11 @@ theorem tsum_ite_eq_tsum_coneUnfold_ennreal (J : (Ideal (𝓞 K))⁰) + have hgpr : g ((euclidMixedEquiv K).symm + ((∏ i, fundSystem K i ^ (pr.2 i)) • ((pr.1 : mixedSpace K)))) ≠ 0 := by + rw [hvw] +- rwa [if_neg hvne] at hv ++ rwa [ite_eq_right hvne] at hv + refine ⟨⟨pr, hgpr⟩, ?_⟩ + exact Subtype.ext hvw + · rintro ⟨p, hp⟩ +- rw [if_neg (hne p)] ++ rw [ite_eq_right (hne p)] + + open scoped Classical in + /-- The canonical algebraic preimage of a cone point. -/ +@@ -577,9 +577,9 @@ theorem lintegral_box_theta_tail (J : (Ideal (𝓞 K))⁰) {t : ℝ} (ht : 0 < t + rw [lintegral_tsum (fun v => ?_)] + swap + · by_cases hv : v = 0 +- · simp only [if_pos hv] ++ · simp only [ite_eq_left hv] + exact aemeasurable_const +- · simp only [if_neg hv] ++ · simp only [ite_eq_right hv] + exact (ENNReal.continuous_ofReal.comp (continuous_gaussTerm K t _)).aemeasurable + -- Step 3: the per-v box integral is `ite (v = 0) 0 (G ↑v)` + have hstep3 : ∀ v : idealZLattice K (FractionalIdeal.mk0 K J), +@@ -589,12 +589,12 @@ theorem lintegral_box_theta_tail (J : (Ideal (𝓞 K))⁰) {t : ℝ} (ht : 0 < t + = if v = 0 then 0 else G (v : EuclideanSpace ℝ (index K)) := by + intro v + by_cases hv : v = 0 +- · rw [if_pos hv] ++ · rw [ite_eq_left hv] + rw [setLIntegral_congr_fun (ZSpan.fundamentalDomain_measurableSet _) +- (fun u _ => if_pos hv), lintegral_zero] +- · rw [if_neg hv, hG] ++ (fun u _ => ite_eq_left hv), lintegral_zero] ++ · rw [ite_eq_right hv, hG] + exact setLIntegral_congr_fun (ZSpan.fundamentalDomain_measurableSet _) +- (fun u _ => if_neg hv) ++ (fun u _ => ite_eq_right hv) + rw [tsum_congr hstep3] + -- Step 4: cone reindex (on the G-valued family) + rw [tsum_ite_eq_tsum_coneUnfold_ennreal K J G] +@@ -692,7 +692,7 @@ theorem heckeLogMap_injective : Function.Injective (heckeLogMap K) := by + field_simp at this + linarith + rw [fullLog] at hfl +- rw [dif_neg w'.2] at hfl ++ rw [dite_eq_right w'.2] at hfl + simpa using hfl + rw [hτ, hu] + rfl +@@ -906,7 +906,7 @@ theorem tsum_idealSet_norm_rpow (J : (Ideal (𝓞 K))⁰) (σ : ℝ) : + (∑' _ζ : torsion K, ENNReal.ofReal ((((n : ℝ)) ^ 2) ^ (-σ))) + = (torsionOrder K) * ENNReal.ofReal ((((n : ℝ)) ^ 2) ^ (-σ)) := by + intro I +- letI := Fintype.ofFinite (torsion K) ++ let := Fintype.ofFinite (torsion K) + rw [tsum_fintype, Finset.sum_const, nsmul_eq_mul, Units.torsionOrder, + Nat.card_eq_fintype_card] + norm_cast +@@ -1142,8 +1142,8 @@ theorem sum_mult_heckeLogCLE (p : ℝ × logSpace K) : + field_simp + + open scoped Classical in +-/-- **The universal Mellin constant in closed form**: the change of variables along the +-Hecke substitution factorises the master integral into per-place Gamma integrals. -/ ++ ++ + theorem lintegral_exp_heckeLog (σ : ℝ) (hσ : 0 < σ) : + ∫⁻ p : ℝ × logSpace K, ENNReal.ofReal (Real.exp (σ * p.1 + - π * ∑ w : InfinitePlace K, Real.exp ((heckeLogCLE K p) w))) +@@ -1367,7 +1367,7 @@ theorem setLIntegral_box_swap (f : logSpace K → ℝ≥0∞) + have h2 := ZSpan.isAddFundamentalDomain ((basisUnitLattice K).ofZLatticeBasis ℝ) volume + rw [(Module.Free.chooseBasis ℤ (unitLattice K)).ofZLatticeBasis_span ℝ] at h1 + rw [(basisUnitLattice K).ofZLatticeBasis_span ℝ] at h2 +- haveI : VAddInvariantMeasure (unitLattice K) (logSpace K) volume := ++ have : VAddInvariantMeasure (unitLattice K) (logSpace K) volume := + inferInstanceAs (VAddInvariantMeasure (unitLattice K).toAddSubgroup (logSpace K) volume) + refine h1.setLIntegral_eq h2 (f := f) (fun l x => ?_) + rw [Submodule.vadd_def, vadd_eq_add] +@@ -1774,8 +1774,8 @@ theorem sum_count_eq_card_le (n : ℕ) : + ∑ k ∈ Finset.Icc 1 n, + (Nat.card {I : Ideal (𝓞 K) // Ideal.absNorm I = k} : ℝ) + = (Nat.card {I : (Ideal (𝓞 K))⁰ // Ideal.absNorm (I : Ideal (𝓞 K)) ≤ n} : ℝ) := by +- haveI : ∀ k : (Finset.Icc 1 n), Finite {I : Ideal (𝓞 K) // Ideal.absNorm I = (k : ℕ)} := +- fun k => (Ideal.finite_setOf_absNorm_eq (S := 𝓞 K) (k : ℕ)).to_subtype ++ have : ∀ k : (Finset.Icc 1 n), Finite {I : Ideal (𝓞 K) // Ideal.absNorm I = (k : ℕ)} := ++ fun k => (Ideal.finite_setOfPred_absNorm_eq (S := 𝓞 K) (k : ℕ)).to_subtype + rw [show (Nat.card {I : (Ideal (𝓞 K))⁰ // Ideal.absNorm (I : Ideal (𝓞 K)) ≤ n}) + = Nat.card (Σ k : (Finset.Icc 1 n), + {I : Ideal (𝓞 K) // Ideal.absNorm I = (k : ℕ)}) from +@@ -1885,18 +1885,18 @@ theorem summable_ideal_norm_rpow {s : ℝ} (hs : 1 < s) : + exact h1.congr (fun n => (h2 n)) + refine h3.congr (fun n => ?_) + by_cases hn : n = 0 +- · rw [if_pos hn, hn] ++ · rw [ite_eq_left hn, hn] + rw [Nat.cast_zero, Real.zero_rpow (by linarith), mul_zero] +- · rw [if_neg hn, Real.rpow_neg (Nat.cast_nonneg n), div_eq_mul_inv] ++ · rw [ite_eq_right hn, Real.rpow_neg (Nat.cast_nonneg n), div_eq_mul_inv] + -- transfer to the ideal-indexed sum by fibering over the norm + have hnn : ∀ p : (Σ n : ℕ, {b : (Ideal (𝓞 K))⁰ // + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n}), + 0 ≤ ((Ideal.absNorm ((p.2 : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) : ℝ)) ^ (-s) := + fun p => Real.rpow_nonneg (Nat.cast_nonneg _) _ +- haveI hfibfin : ∀ n : ℕ, Finite {b : (Ideal (𝓞 K))⁰ // ++ have hfibfin : ∀ n : ℕ, Finite {b : (Ideal (𝓞 K))⁰ // + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n} := fun n => by +- haveI : Finite {I : Ideal (𝓞 K) // Ideal.absNorm I = n} := +- (Ideal.finite_setOf_absNorm_eq (S := 𝓞 K) n).to_subtype ++ have : Finite {I : Ideal (𝓞 K) // Ideal.absNorm I = n} := ++ (Ideal.finite_setOfPred_absNorm_eq (S := 𝓞 K) n).to_subtype + exact Finite.of_injective _ (normFiber_forget_injective K n) + rw [← Equiv.summable_iff (Equiv.sigmaFiberEquiv (fun b : (Ideal (𝓞 K))⁰ => + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K))))] +@@ -1909,7 +1909,7 @@ theorem summable_ideal_norm_rpow {s : ℝ} (hs : 1 < s) : + = ((n : ℝ)) ^ (-s) := by + intro b + rw [b.2] +- haveI : Fintype {b : (Ideal (𝓞 K))⁰ // ++ have : Fintype {b : (Ideal (𝓞 K))⁰ // + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n} := Fintype.ofFinite _ + rw [show (∑' b : {b : (Ideal (𝓞 K))⁰ // + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n}, +@@ -1961,10 +1961,10 @@ theorem dedekindZeta_real_eq {s : ℝ} (hs : 1 < s) : + rw [tsum_congr h2, ← Complex.ofReal_tsum] + congr 1 + -- fiber-glue the real n-sum into the ideal-type sum +- haveI hfibfin : ∀ n : ℕ, Finite {b : (Ideal (𝓞 K))⁰ // ++ have hfibfin : ∀ n : ℕ, Finite {b : (Ideal (𝓞 K))⁰ // + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n} := fun n => by +- haveI : Finite {I : Ideal (𝓞 K) // Ideal.absNorm I = n} := +- (Ideal.finite_setOf_absNorm_eq (S := 𝓞 K) n).to_subtype ++ have : Finite {I : Ideal (𝓞 K) // Ideal.absNorm I = n} := ++ (Ideal.finite_setOfPred_absNorm_eq (S := 𝓞 K) n).to_subtype + exact Finite.of_injective _ (normFiber_forget_injective K n) + have hsum := summable_ideal_norm_rpow K hs + have hsigma : Summable (fun p : (Σ n : ℕ, {b : (Ideal (𝓞 K))⁰ // +@@ -1986,7 +1986,7 @@ theorem dedekindZeta_real_eq {s : ℝ} (hs : 1 < s) : + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n}, + ((Ideal.absNorm ((b.val : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) : ℝ)) ^ (-s) + = ((n : ℝ)) ^ (-s) := fun b => by rw [b.2] +- haveI : Fintype {b : (Ideal (𝓞 K))⁰ // ++ have : Fintype {b : (Ideal (𝓞 K))⁰ // + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n} := Fintype.ofFinite _ + rw [show (∑' b : {b : (Ideal (𝓞 K))⁰ // + Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) = n}, +@@ -1997,8 +1997,8 @@ theorem dedekindZeta_real_eq {s : ℝ} (hs : 1 < s) : + rw [tsum_fintype, Finset.sum_const, nsmul_eq_mul, Finset.card_univ] + by_cases hn : n = 0 + · subst hn +- rw [if_pos rfl, Nat.cast_zero, Real.zero_rpow (by linarith), mul_zero] +- · rw [if_neg hn] ++ rw [ite_eq_left rfl, Nat.cast_zero, Real.zero_rpow (by linarith), mul_zero] ++ · rw [ite_eq_right hn] + congr 2 + rw [← Nat.card_eq_fintype_card] + exact Nat.card_congr (normFiberEquiv K n hn).symm +@@ -2014,8 +2014,7 @@ theorem heckeF_dev_nonneg {t : ℝ} (ht : 0 < t) : + rw [hFsum] + exact Finset.sum_nonneg (fun C _ => heckeGClass_dev_nonneg K C ht) + +-/-- Positivity of the Gamma-product factor `∏ w, π^(-mult w·σ)·Γ(mult w·σ)` of the closed +-Hecke Λ-form (each factor is positive for `σ > 0`). -/ ++ + theorem prod_pi_rpow_mul_Gamma_nonneg {σ : ℝ} (hσ0 : 0 < σ) : + 0 ≤ ∏ w : InfinitePlace K, + π ^ (-((mult w : ℝ) * σ)) * Real.Gamma ((mult w : ℝ) * σ) := by +@@ -2026,8 +2025,7 @@ theorem prod_pi_rpow_mul_Gamma_nonneg {σ : ℝ} (hσ0 : 0 < σ) : + positivity + positivity + +-/-- Nonnegativity of the closed real Λ-form (a `heckeBeta` power times the nonnegative +-Gamma-product times a nonnegative ideal-norm `tsum`). -/ ++ + theorem heckeClosedLambdaForm_nonneg {σ : ℝ} (hσ0 : 0 < σ) : + (0:ℝ) ≤ (heckeBeta K) ^ (-σ) + * ((((heckeJacobian K : ℝ≥0)) : ℝ) +@@ -2044,8 +2042,8 @@ theorem heckeClosedLambdaForm_nonneg {σ : ℝ} (hσ0 : 0 < σ) : + positivity + + open scoped Classical in +-/-- The `ENNReal.ofReal` of the Mellin integral of the Hecke theta deviation equals the +-`ofReal` of the closed Γ–ζ form; the ENNReal core of `heckeFEPair_Λ_real`. -/ ++ ++ + theorem ennreal_ofReal_integral_heckeF_dev_eq {σ : ℝ} (hσ0 : 0 < σ) (h2σ : 1 < 2 * σ) + (hri : IntegrableOn (fun t : ℝ => t ^ (σ - 1) * (heckeF K t - heckeFConst K)) + (Set.Ioi (0:ℝ)) volume) +@@ -2066,7 +2064,7 @@ theorem ennreal_ofReal_integral_heckeF_dev_eq {σ : ℝ} (hσ0 : 0 < σ) (h2σ : + fun t ht => ENNReal.ofReal_mul (Real.rpow_nonneg (le_of_lt ht) _) + rw [setLIntegral_congr_fun measurableSet_Ioi hsplit, + lintegral_mellin_heckeF_dev K hσ0] +- -- identify the closed ENNReal form with ofReal of the real one ++ + have hzsum : (∑' b : (Ideal (𝓞 K))⁰, + ENNReal.ofReal ((((Ideal.absNorm ((b : (Ideal (𝓞 K))⁰) : Ideal (𝓞 K)) : ℝ)) ^ 2) + ^ (-σ))) +@@ -2094,8 +2092,8 @@ theorem ennreal_ofReal_integral_heckeF_dev_eq {σ : ℝ} (hσ0 : 0 < σ) (h2σ : + ← ENNReal.ofReal_mul (by positivity)] + + open scoped Classical in +-/-- **The Λ-value identification (e-vi)**: at real `σ > 1/2` the abstract completed +-function of the Hecke theta pair is the closed Γ–ζ form. -/ ++ ++ + theorem heckeFEPair_Λ_real {σ : ℝ} (hσ : 1/2 < σ) : + (heckeFEPair K).Λ (σ : ℂ) + = (((heckeBeta K) ^ (-σ) +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/PoissonLattice.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/PoissonLattice.lean +index db7f899ca..d8a411dcb 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/PoissonLattice.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/PoissonLattice.lean +@@ -9,22 +9,6 @@ public import Mathlib + public import DedekindResidue.CompletedZeta.DualLattice + public import DedekindResidue.CompletedZeta.PoissonSummation + +-/-! +-# Poisson summation over a general `ℤ`-lattice (SP1-AGP, leaf P.3) +- +-Transport of the `ℤ^ι` Poisson formula (`tsum_eq_tsum_fourier_zpoint`) to an arbitrary +-`ℤ`-lattice `L ⊂ EuclideanSpace ℝ ι`: conjugate by the linear equivalence sending the standard +-lattice to `L`. The Fourier side transforms by the **`GL` change-of-variables law** +-(`fourier_comp_linearEquiv`, new to this development: mathlib only has the isometry case +-`Real.fourier_comp_linearIsometry`), the dual lattice appears via `dualZLattice_eq_span` +-(P.1), and the covolume factor via `ZLattice.covolume_eq_det_mul_measureReal`. +- +-## Main results (this file) +-* `DedekindResidue.fourier_comp_linearEquiv` — +- `𝓕(g ∘ T) w = |det T|⁻¹ • 𝓕 g ((T⁻¹)^* w)` for `T ∈ GL(EuclideanSpace ℝ ι)`. +-* `DedekindResidue.tsum_eq_tsum_fourier_zlattice` — **Poisson summation over a `ℤ`-lattice**: +- `∑'_{v ∈ L} g(v) = covol(L)⁻¹ • ∑'_{w ∈ L♯} 𝓕g(w)`. +--/ + + namespace DedekindResidue + +@@ -160,7 +144,7 @@ theorem adjoint_symm_latticeEquiv_zpoint [DecidableEq ι] + innerₗ_nondegenerate c i j + rw [← innerₗ_apply_apply] + exact this +- simp only [this, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq, Finset.mem_univ, if_true] ++ simp only [this, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq, Finset.mem_univ, ite_true] + rw [hLHS, hRHS] + + /-- **P3d.** The determinant of the lattice-basis change of variables is (up to sign) the +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/PoissonSummation.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/PoissonSummation.lean +index d37431765b6cd844993a19f34fa0da37c8e6c6ad..9e1c836c4e548e89a5aebceddd3da2d4fbff7de7 100644 +GIT binary patch +delta 148 +zcmbQ$!F2Q!m%Xs$<$LWp-SeBP72dKPNxEa`VGL +USD5*mwL>O}g0*eln;9zw0CzSwivR!s + +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaEstimates.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaEstimates.lean +index c9a2e644c..4c7e21d05 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaEstimates.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaEstimates.lean +@@ -91,12 +91,12 @@ theorem tsum_ite_gaussian_tail (L : Submodule ℤ (EuclideanSpace ℝ ι)) + rw [← smul_eq_mul, ← tsum_const_smul'' (Real.exp (-π * (a - a₀) * δ ^ 2))] + refine Summable.tsum_le_tsum (fun v => ?_) ?_ (hsum₀.const_smul _) + · by_cases hv : v = 0 +- · rw [if_pos hv] ++ · rw [ite_eq_left hv] + have : (0:ℝ) < Real.exp (-π * (a - a₀) * δ ^ 2) + * Real.exp (-π * ∑ i, a₀ * ((v : EuclideanSpace ℝ ι) i) ^ 2) := by + positivity + exact le_of_lt (by simpa [smul_eq_mul] using this) +- · rw [if_neg hv, smul_eq_mul, ← Real.exp_add] ++ · rw [ite_eq_right hv, smul_eq_mul, ← Real.exp_add] + refine Real.exp_le_exp.mpr ?_ + have hnorm : δ ^ 2 ≤ ∑ i, ((v : EuclideanSpace ℝ ι) i) ^ 2 := by + have h1 : δ ^ 2 ≤ ‖(v : EuclideanSpace ℝ ι)‖ ^ 2 := +diff --git a/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaLattice.lean b/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaLattice.lean +index dab1b9d9e..efc5f57f2 100644 +--- a/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaLattice.lean ++++ b/projects/DedekindResidue/DedekindResidue/CompletedZeta/ThetaLattice.lean +@@ -10,30 +10,6 @@ public import DedekindResidue.CompletedZeta.DualLattice + public import DedekindResidue.CompletedZeta.PoissonSummation + public import DedekindResidue.CompletedZeta.PoissonLattice + +-/-! +-# The lattice Gaussian theta function and its transformation law (SP1-AGΘ) +- +-For a `ℤ`-lattice `L ⊂ EuclideanSpace ℝ ι` the **theta function** +-`Θ_L(t) := ∑_{v ∈ L} e^{-π t ‖v‖²}` (`t > 0`) satisfies the **inversion law** +- +-`Θ_L(t) = covol(L)⁻¹ · t^{-n/2} · Θ_{L♯}(1/t)`, +- +-the standard lattice theta transformation (Neukirch, *Algebraic Number Theory*, VII §3; +-the 1-D case is mathlib's `jacobiTheta` functional equation). It is the Gaussian +-instantiation of the lattice Poisson formula `tsum_eq_tsum_fourier_zlattice` (P.3): mathlib's +-`fourier_gaussian_innerProductSpace` at `b = πt` gives `𝓕 g_t(w) = t^{-n/2} e^{-π‖w‖²/t}`, +-and `summable_gaussian_zlattice` discharges the convergence hypotheses. +- +-This is the analytic engine of the Hecke functional-equation route (SP1-AGE → SP1-FE): +-applied to the ideal lattices of a number field it produces the completed `Λ_K`. +- +-## Main definitions / results (this file) +-* `DedekindResidue.thetaLattice L t` — `Θ_L(t) = ∑'_{v ∈ L} exp(-π t ‖v‖²)` (real-valued). +-* `thetaLattice_transform` — **the inversion law** `Θ_L(t) = covol(L)⁻¹·t^{-n/2}·Θ_{L♯}(1/t)` +- for `t > 0`, fully proven from the lattice Poisson formula + mathlib's Gaussian Fourier +- transform (`fourier_gaussianCM`), with both convergence hypotheses discharged +- (`summable_norm_restrict_gaussianCM`, `summable_fourier_gaussianCM`). +--/ + + namespace DedekindResidue + +@@ -72,12 +48,12 @@ theorem norm_gaussianCM_apply (t : ℝ) (x : EuclideanSpace ℝ ι) : + push_cast; ring + rw [this, Complex.ofReal_re] + +-/-- Sub-level sets of a lattice are finite (lattice ∩ closed ball in a proper space). -/ ++ + theorem finite_norm_le_zlattice (L : Submodule ℤ (EuclideanSpace ℝ ι)) + [DiscreteTopology L] (R : ℝ) : + {v : L | ‖(v : EuclideanSpace ℝ ι)‖ ≤ R}.Finite := by + have hcl : IsClosed (L : Set (EuclideanSpace ℝ ι)) := by +- rw [← Submodule.coe_toAddSubgroup]; exact AddSubgroup.isClosed_of_discrete ++ rw [← Submodule.coe_toAddSubgroup]; exact AddSubgroup.isClosed_of_discreteTopology + have hfb : (Metric.closedBall 0 R ∩ (L : Set (EuclideanSpace ℝ ι))).Finite := + Metric.finite_isBounded_inter_isClosed DiscreteTopology.isDiscrete + Metric.isBounded_closedBall hcl +@@ -107,7 +83,7 @@ theorem summable_norm_restrict_gaussianCM (L : Submodule ℤ (EuclideanSpace ℝ + · exact (summable_gaussian_zlattice L (by positivity)).mul_left _ + · rw [Filter.eventually_cofinite] + refine (finite_norm_le_zlattice L R').subset (fun v hv => ?_) +- simp only [Set.mem_setOf_eq] at hv ⊢ ++ simp only [Set.mem_ofPred_eq] at hv ⊢ + by_contra hnotle + rw [not_le] at hnotle + refine hv ?_ +diff --git a/projects/DedekindResidue/DedekindResidue/ExplicitFormula/FourierJordan.lean b/projects/DedekindResidue/DedekindResidue/ExplicitFormula/FourierJordan.lean +index 5171d0c7f..e5f838c02 100644 +--- a/projects/DedekindResidue/DedekindResidue/ExplicitFormula/FourierJordan.lean ++++ b/projects/DedekindResidue/DedekindResidue/ExplicitFormula/FourierJordan.lean +@@ -10,7 +10,7 @@ public import Mathlib.Analysis.Fourier.RiemannLebesgueLemma + public import DedekindResidue.ExplicitFormula.PhiTransform + + /-! +-# Fourier–Jordan inversion: the Dirichlet integral (SP2-FJ-c) ++# Fourier–Jordan inversion: the Dirichlet integral + + The classical Dirichlet integral `∫₀^∞ (sin x)/x dx = π/2`, phrased as convergence of the + truncated integrals `∫₀^b (sin x)/x dx → π/2` as `b → ∞`. This is the analytic engine of +@@ -18,7 +18,7 @@ Jordan's pointwise Fourier-inversion criterion for functions of bounded variatio + Poitou's proof of the explicit formula (Poitou, *Sur les petits discriminants*, Séminaire + DPP 1976/77, exposé 6, p. 6-03) to invert the transform `Φ` on the prime side. + +-Not available in mathlib. We follow the Frullani/Fubini route: ++The Frullani/Fubini argument uses + `1/x = ∫₀^∞ e^{-xy} dy`, so + `∫₀^b (sin x)/x dx = ∫₀^∞ (1 - e^{-yb}(cos y + y sin b))/(1+y²) dy` + by Fubini and the closed form of the damped sine integral; dominated convergence then gives +@@ -181,7 +181,7 @@ theorem integral_sinc_eq {b : ℝ} (hb : 0 < b) : + rw [mul_comm x y]; ring)] + exact integral_exp_neg_mul_sin y b + +-/-- **The Dirichlet integral** (SP2-FJ-c): `∫₀^∞ sin x/x dx = π/2`, as a limit of the ++/-- **The Dirichlet integral**: `∫₀^∞ sin x/x dx = π/2`, as a limit of the + truncated integrals. Fubini against `1/x = ∫ e^{-xy} dy` plus dominated convergence. -/ + theorem tendsto_integral_sinc_atTop : + Filter.Tendsto (fun b : ℝ => ∫ x in (0:ℝ)..b, Real.sin x / x) +@@ -490,7 +490,7 @@ theorem integral_fourier_window_collapse {H : ℝ → ℂ} (hH : Integrable H) { + refine MeasureTheory.integral_congr_ae ?_ + have h0 : ∀ᵐ (u : ℝ), u ≠ 0 := by + rw [MeasureTheory.ae_iff] +- simp only [ne_eq, not_not, Set.setOf_eq_eq_singleton] ++ simp only [ne_eq, not_not, Set.ofPred_eq_eq_singleton] + exact MeasureTheory.measure_singleton 0 + filter_upwards [h0] with u hu + rw [MeasureTheory.integral_const_mul] +@@ -740,7 +740,7 @@ theorem abs_integral_monotone_kernel_le {g K : ℝ → ℝ} (hg : Monotone g) { + have hcount : Set.Countable {x : ℝ | g x ≠ Function.rightLim g x} := by + refine Set.Countable.mono ?_ hg.countable_not_continuousAt + intro x hx +- simp only [Set.mem_setOf_eq] at hx ⊢ ++ simp only [Set.mem_ofPred_eq] at hx ⊢ + intro hcont + exact hx (hcont.continuousWithinAt.rightLim_eq).symm + have hnull : volume {x : ℝ | g x ≠ Function.rightLim g x} = 0 := +@@ -1023,8 +1023,8 @@ theorem integral_dirichlet_split {H : ℝ → ℂ} (hH : Integrable H) {δ : ℝ + funext u + simp only [Set.indicator_apply, Set.mem_Ico, Set.mem_Ioc] + by_cases hu : -δ ≤ -u ∧ -u < 0 +- · rw [if_pos hu, if_pos ⟨by linarith [hu.2], by linarith [hu.1]⟩] +- · rw [if_neg hu, if_neg (fun h => hu ⟨by linarith [h.2], by linarith [h.1]⟩)] ++ · rw [ite_eq_left hu, ite_eq_left ⟨by linarith [hu.2], by linarith [hu.1]⟩] ++ · rw [ite_eq_right hu, ite_eq_right (fun h => hu ⟨by linarith [h.2], by linarith [h.1]⟩)] + rw [h1, h2, h3, MeasureTheory.integral_indicator measurableSet_Ioc] + have hK_even : ∀ u : ℝ, f (-u) = H (-u) * ((2 * Real.sin (T * u) / u : ℝ) : ℂ) := by + intro u +@@ -1122,8 +1122,7 @@ theorem tendsto_integral_dirichlet_plateau {δ : ℝ} (hδ : 0 < δ) : + push_cast + ring + +-/-- **Jordan's Fourier inversion criterion, Dirichlet-kernel form** (SP2-FJ-a/g; Poitou +-p. 6-03): for integrable `H` whose real and imaginary parts have bounded variation, with ++/-- **Jordan's Fourier inversion criterion, Dirichlet-kernel form**: for integrable `H` whose real and imaginary parts have bounded variation, with + one-sided limits `Hp` (from the right) and `Hm` (from the left) at `0`, + + `∫_ℝ H(u) · 2sin(Tu)/u du → π(Hp + Hm)` as `T → ∞`. +@@ -1394,7 +1393,7 @@ theorem tendsto_integral_dirichlet_jordan {H : ℝ → ℂ} (hH : Integrable H) + (add_lt_add_of_lt_of_lt hfarT hplat_piece) (hRright.trans hδR.le)) (hRleft.trans hδL.le) + _ = ε := by ring + +-/-- **Jordan's Fourier inversion, symmetric-window form** (SP2-FJ-a; Poitou p. 6-03): for ++/-- **Jordan's Fourier inversion, symmetric-window form**: for + integrable `H` of bounded variation with one-sided limits `Hp`, `Hm` at `0`, + + `∫_{-T}^{T} (∫_ℝ H(u) e^{itu} du) dt → π(Hp + Hm)` as `T → ∞`. +diff --git a/projects/DedekindResidue/DedekindResidue/ExplicitFormula/GammaSide.lean b/projects/DedekindResidue/DedekindResidue/ExplicitFormula/GammaSide.lean +index 1f1506cfc..ebf01aa5c 100644 +--- a/projects/DedekindResidue/DedekindResidue/ExplicitFormula/GammaSide.lean ++++ b/projects/DedekindResidue/DedekindResidue/ExplicitFormula/GammaSide.lean +@@ -10,35 +10,13 @@ public import DedekindResidue.ExplicitFormula.RectangleContour + public import DedekindResidue.Lemma2 + + /-! +-# The archimedean side: digamma integrals (SP2-Γψ) ++Gauss's integral representation of the digamma function supplies the ++archimedean part of Poitou's explicit formula. It follows from the ++logarithmic derivative of Euler's gamma integral, the Frullani representation ++of the logarithm and Fubini's theorem. Taking digamma differences cancels ++the counterterms and gives the kernel used on vertical lines. + +-Poitou's computation of the archimedean part of the explicit formula (Poitou, *Sur les +-petits discriminants*, exposé 6, pp. 6-03–6-06) rests on **Gauss's integral formula** +-(his eq. (5)) +- +-`ψ(z) = -∫₀^∞ (e^{-xz}/(1-e^{-x}) - e^{-x}/x) dx`, `Re z > 0`, +- +-and its consequences for `Re ψ` on vertical lines. Mathlib defines `Complex.digamma` +-(as `logDeriv Gamma`) but has no integral representation (explicit TODO in +-`Mathlib.Analysis.SpecialFunctions.Gamma.Digamma`), so this file builds it from the +-Euler integral: `Γ'(z) = ∫₀^∞ t^{z-1}e^{-t} log t dt` (mathlib's +-`hasDerivAt_GammaIntegral`), the Frullani representation of `log`, and Fubini — the +-classical Gauss derivation. +- +-## Main results +- +-- `integral_frullani_log` : `∫₀^∞ (e^{-x} - e^{-tx})/x dx = log t` for `t > 0`. +-- `integrableOn_rpow_mul_exp_neg_mul_abs_log` : the log-weighted Euler integrand is +- integrable. +-- `abs_frullani_kernel_le` : exponential domination of the Frullani kernel. +-- `integral_gauss_inner` : the inner evaluation +- `∫₀^∞ t^{z-1}e^{-t}(e^{-x}-e^{-tx})/x dt = Γ(z)(e^{-x} - (1+x)^{-z})/x`. +-- `digamma_eq_integral_gauss_one` : **Gauss's first form** +- `ψ(z) = ∫₀^∞ (e^{-x} - (1+x)^{-z})/x dx` for `Re z > 0`. +-- `integrableOn_gauss_one_integrand` : integrability of that integrand. +-- `digamma_sub_digamma_eq_integral` : **Poitou's difference form** +- `ψ(w) - ψ(σ) = ∫₀^∞ (e^{-σu} - e^{-wu})/(1-e^{-u}) du` (`x = e^u - 1`), the form his +- eq. (5) is used in — both counterterms cancel in the difference. ++Reference: Poitou, *Sur les petits discriminants*, exposé 6, pp. 6-03–6-06. + -/ + + @[expose] public section +@@ -1216,7 +1194,7 @@ theorem hasDerivAt_gammaFT {F : ℝ → ℂ} (hF : Integrable F) + refine h0.congr ?_ + refine (MeasureTheory.ae_restrict_iff' measurableSet_Ioc).mpr ?_ + filter_upwards [MeasureTheory.ae_iff.mpr (by +- simp only [ne_eq, not_not, Set.setOf_eq_eq_singleton] ++ simp only [ne_eq, not_not, Set.ofPred_eq_eq_singleton] + exact MeasureTheory.measure_singleton (0:ℝ) : volume {x : ℝ | ¬ x ≠ 0} = 0)] + with x hx _ + have hxne : (x:ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hx +@@ -1364,7 +1342,7 @@ theorem hasDerivAt_gammaFT {F : ℝ → ℂ} (hF : Integrable F) + refine MeasureTheory.integral_congr_ae ?_ + refine ((MeasureTheory.ae_restrict_iff' measurableSet_Ioc).mpr ?_) + filter_upwards [MeasureTheory.ae_iff.mpr (by +- simp only [ne_eq, not_not, Set.setOf_eq_eq_singleton] ++ simp only [ne_eq, not_not, Set.ofPred_eq_eq_singleton] + exact MeasureTheory.measure_singleton (0:ℝ) : volume {x : ℝ | ¬ x ≠ 0} = 0)] + with x hx _ + have hxne : (x:ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hx +@@ -1518,7 +1496,7 @@ theorem hasDerivAt_rhoFT {k : ℝ → ℂ} (hk : Integrable k) (t : ℝ) : + rw [h0, Real.exp_zero, mul_one] + · exact hk.norm + · filter_upwards [MeasureTheory.ae_iff.mpr (by +- simp only [ne_eq, not_not, Set.setOf_eq_eq_singleton] ++ simp only [ne_eq, not_not, Set.ofPred_eq_eq_singleton] + exact MeasureTheory.measure_singleton (0:ℝ) : volume {x : ℝ | ¬ x ≠ 0} = 0)] + with x hx + intro τ _ +@@ -2479,7 +2457,8 @@ theorem tendsto_eLpNorm_indicator_truncation {g : ℝ → ℂ} + = (∫⁻ x, ((Set.Ioc (-(n:ℝ)) (n:ℝ))ᶜ.indicator (fun y => ‖g y‖ₑ ^ (2:ℝ)) x)) + ^ (1/(2:ℝ)) := by + intro n +- rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num) (by norm_num)] ++ rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num) (by norm_num) ++ ((hg.aestronglyMeasurable.indicator measurableSet_Ioc).sub hg.aestronglyMeasurable)] + rw [show ((2:ℝ≥0∞).toReal) = (2:ℝ) by norm_num] + congr 1 + refine lintegral_congr (fun x => ?_) +@@ -2507,7 +2486,8 @@ theorem tendsto_eLpNorm_indicator_truncation {g : ℝ → ℂ} + · rw [Set.indicator_of_notMem hx] + exact bot_le + · have := hg.eLpNorm_lt_top +- rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num) (by norm_num), ++ rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num) (by norm_num) ++ hg.aestronglyMeasurable, + show ((2:ℝ≥0∞).toReal) = (2:ℝ) by norm_num] at this + have h1 : (∫⁻ x, ‖g x‖ₑ ^ (2:ℝ)) < ⊤ := by + by_contra hcon +@@ -2615,11 +2595,7 @@ theorem gammaFT_ae_eq_fourierL2 {F : ℝ → ℂ} (hF : Integrable F) + exact tendsto_eLpNorm_indicator_truncation hFdiv2 + have hmeas : TendstoInMeasure volume (fun n : ℕ => 𝓕 (fun x : ℝ => hn n x)) atTop + ((𝓕 (hFdiv2.toLp h) : Lp ℂ 2 (volume : Measure ℝ)) : ℝ → ℂ) := by +- refine tendstoInMeasure_of_tendsto_eLpNorm (p := 2) (by norm_num) ?_ ?_ heLp +- · intro n +- refine Continuous.aestronglyMeasurable ?_ +- exact VectorFourier.fourierIntegral_continuous (by fun_prop) (by fun_prop) (hn1 n) +- · exact (MeasureTheory.Lp.memLp _).aestronglyMeasurable ++ exact MeasureTheory.tendstoInMeasure_of_tendsto_eLpNorm (p := 2) (by norm_num) heLp + obtain ⟨ns, hns_mono, hns_ae⟩ := hmeas.exists_seq_tendsto_ae + have hqmp : Measure.QuasiMeasurePreserving (fun t : ℝ => -t/(2*π)) + volume volume := by +@@ -2637,7 +2613,7 @@ theorem gammaFT_ae_eq_fourierL2 {F : ℝ → ℂ} (hF : Integrable F) + have hae_t := hqmp.ae hns_ae + have hne : ∀ᵐ t : ℝ, t ≠ 0 := by + rw [MeasureTheory.ae_iff] +- simp only [ne_eq, not_not, Set.setOf_eq_eq_singleton] ++ simp only [ne_eq, not_not, Set.ofPred_eq_eq_singleton] + exact MeasureTheory.measure_singleton 0 + filter_upwards [hae_t, hne] with t hlim ht + have hpt : Tendsto (fun i : ℕ => 𝓕 (fun x : ℝ => hn (ns i) x) (-t/(2*π))) +@@ -4275,7 +4251,7 @@ theorem differentiableAt_logDeriv_gammaFactor (K : Type*) [Field K] [NumberField + have hU : IsOpen {w : ℂ | 0 < w.re} := isOpen_lt continuous_const Complex.continuous_re + have hdiff : DifferentiableOn ℂ (gammaFactor K) {w : ℂ | 0 < w.re} := by + intro w hw +- rw [Set.mem_setOf_eq] at hw ++ rw [Set.mem_ofPred_eq] at hw + exact (((differentiableAt_Gammaℝ_of_re_pos hw).pow _).mul + ((differentiableAt_Gammaℂ_of_re_pos hw).pow _)).differentiableWithinAt + have han : AnalyticOnNhd ℂ (gammaFactor K) {w : ℂ | 0 < w.re} := +diff --git a/projects/DedekindResidue/DedekindResidue/ExplicitFormula/PrimeSide.lean b/projects/DedekindResidue/DedekindResidue/ExplicitFormula/PrimeSide.lean +index 257b1ee8f..bfe4ae128 100644 +--- a/projects/DedekindResidue/DedekindResidue/ExplicitFormula/PrimeSide.lean ++++ b/projects/DedekindResidue/DedekindResidue/ExplicitFormula/PrimeSide.lean +@@ -557,11 +557,11 @@ instance countable_ideal_ringOfIntegers (K : Type*) [Field K] [NumberField K] : + Countable (Ideal (𝓞 K)) := by + have h0 : (Set.univ : Set (Ideal (𝓞 K))) = ⋃ n : ℕ, {I | Ideal.absNorm I = n} := by + ext I +- simp only [Set.mem_univ, Set.mem_iUnion, Set.mem_setOf_eq, true_iff] ++ simp only [Set.mem_univ, Set.mem_iUnion, Set.mem_ofPred_eq, true_iff] + exact ⟨Ideal.absNorm I, rfl⟩ + have h1 : (Set.univ : Set (Ideal (𝓞 K))).Countable := by + rw [h0] +- exact Set.countable_iUnion (fun n => (Ideal.finite_setOf_absNorm_eq n).countable) ++ exact Set.countable_iUnion (fun n => (Ideal.finite_setOfPred_absNorm_eq n).countable) + exact Set.countable_univ_iff.mp h1 + + /-- A pointwise `tsum` of integrable functions with summable `L¹` norms is +diff --git a/projects/DedekindResidue/DedekindResidue/ExplicitFormula/ZeroCapture.lean b/projects/DedekindResidue/DedekindResidue/ExplicitFormula/ZeroCapture.lean +index 7d31587b8f2e079d6c96c21bf6d5ff6fd91172a5..74884c4ad50c792dfd89f70ce83086df94199c96 100644 +GIT binary patch +delta 407 +zcmY+9u}T9$5Qd3~2&au$3NnRQg&>HHDI?lxV;jO`cP_WMH+$|*5|T!IhU=o0jh4Y! +zi4S69?F0A%?h#M}+bsV#|9tcM(0H3Q=B{>o$$$*5AO=rLkO!8UAQ^#jd0|ON!zpRH +zHmqSvf{+ebiE#`mDsesl#+MY{>7f$P6qGl8!vio9;)Hhr#N-qqV8$Uw*Fb?qM{npjc3?1+tVA3;Kw& +zF7N6)2T`IZ?4(*08 1/2`, `X ≥ 1`). -/ ++ + theorem integrable_auxF_kernel (s : ℂ) {X : ℝ} (hX : 1 ≤ X) (hs : 1/2 < s.re) (γ : ℝ) : + Integrable (fun t : ℝ => auxF s X t * Complex.exp (Complex.I * t * γ)) := by + refine Integrable.mono' +@@ -186,9 +174,7 @@ theorem hasDerivAt_gAux_deriv (h : ℂ) {t : ℝ} (ht : 0 < t) : + field_simp + ring + +-/-- Master decay bound: a continuous multiplier `φ` bounded on `(T, ∞)` times the +-kernel `e^{-ht}/t` (with `Re h > 0`, `T > 0`) is integrable on `(T, ∞)`, by comparison +-with `(C/T)·e^{-Re h · t}`. -/ ++ + theorem integrableOn_bounded_mul_exp_div {h : ℂ} (hh : 0 < h.re) {T : ℝ} (hT : 0 < T) + {φ : ℝ → ℂ} (hφc : ContinuousOn φ (Set.Ioi T)) {C : ℝ} + (hφb : ∀ t ∈ Set.Ioi T, ‖φ t‖ ≤ C) : +@@ -218,7 +204,7 @@ theorem integrableOn_bounded_mul_exp_div {h : ℂ} (hh : 0 < h.re) {T : ℝ} (hT + mul_le_mul (hφb t ht) hle (by positivity) hC0 + _ = C / T * Real.exp (-h.re * t) := by ring + +-/-- The kernel `e^{-ht}/t` times an eventually-bounded multiplier tends to `0` at `∞`. -/ ++ + theorem tendsto_exp_div_mul_atTop {h : ℂ} (hh : 0 < h.re) {v : ℝ → ℂ} {C : ℝ} + (hv : ∀ᶠ t : ℝ in Filter.atTop, ‖v t‖ ≤ C) : + Filter.Tendsto (fun t : ℝ => Complex.exp (-h * t) / t * v t) Filter.atTop (nhds 0) := by +@@ -343,7 +329,7 @@ theorem integral_Ioi_gAux_ibp₁ (h : ℂ) (hh : 0 < h.re) {T γ : ℝ} (hT : 0 + gcongr + exact abs_le.mpr ⟨Real.neg_one_le_sin _, Real.sin_le_one _⟩ + +-/-- Integrability of the kernel against a bounded continuous real multiplier. -/ ++ + theorem integrableOn_exp_div_mul_real {h : ℂ} (hh : 0 < h.re) {T : ℝ} (hT : 0 < T) + {ψ : ℝ → ℝ} (hψc : Continuous ψ) {C : ℝ} (hψb : ∀ t, |ψ t| ≤ C) : + IntegrableOn (fun t : ℝ => Complex.exp (-h * t) / t * ((ψ t : ℝ) : ℂ)) +@@ -412,9 +398,7 @@ theorem integrableOn_gAux_deriv2_mul_real {h : ℂ} (hh : 0 < h.re) {T : ℝ} (h + rw [norm_pow] + linarith + +-/-- Second integration by parts for the Fourier tail: with `g(t) = e^{-ht}/t`, +-`∫_T^∞ (g″(t)·(-cos(tγ)/γ²) + g′(t)·sin(tγ)/γ) dt = +-(h+1/T)·g(T)·cos(Tγ)/γ²`, stated with the boundary value in raw `-(u(T)·v(T))` form. -/ ++ + theorem integral_Ioi_gAux_ibp₂ (h : ℂ) (hh : 0 < h.re) {T γ : ℝ} (hT : 0 < T) + (hγ : γ ≠ 0) : + (∫ t in Set.Ioi T, +@@ -561,9 +545,7 @@ theorem tail_integral_identity (h : ℂ) (hh : 0 < h.re) {T γ : ℝ} (hT : 0 < + field_simp at h2 ⊢ + linear_combination (-1 : ℂ) * h2 + +-/-- On the tail `t > log X`, the auxiliary function factors as a constant times the +-exponential kernel: `F_{s,X}(t) = log X · e^{h·log X} · (e^{-h t}/t)` with `h = s - 1/2` +-(the `|t| > log X` branch of `auxF`, rearranged). -/ ++ + theorem auxF_of_gt (s : ℂ) {X : ℝ} (hX : 1 < X) {t : ℝ} (ht : Real.log X < t) : + auxF s X t + = (Real.log X : ℂ) * Complex.exp ((s - 1/2) * (Real.log X : ℂ)) +@@ -574,17 +556,13 @@ theorem auxF_of_gt (s : ℂ) {X : ℝ} (hX : 1 < X) {t : ℝ} (ht : Real.log X < + rw [abs_of_pos htpos] + exact not_le.mpr ht + have htc : ((t : ℝ) : ℂ) ≠ 0 := by exact_mod_cast htpos.ne' +- rw [auxF, if_neg hnot, abs_of_pos htpos] ++ rw [auxF, ite_eq_right hnot, abs_of_pos htpos] + push_cast + rw [show -(s - 1/2) * ((t:ℂ) - (Real.log X : ℂ)) + = -(s - 1/2) * (t:ℂ) + (s - 1/2) * (Real.log X : ℂ) by ring, Complex.exp_add] + field_simp + +-/-- **Belabas–Friedman Lemma 2, eq. (8)** (the `γ ≠ 0` case): the paper-convention +-Fourier transform of the auxiliary function `F_{s,X}` in closed form. With `h = s - 1/2` +-and `T = log X`, +-`F̂(γ) = 2h²·sin(Tγ)/((h²+γ²)γ) + 2(h+1/T)·cos(Tγ)/(h²+γ²) +- - 4/(h²+γ²)·∫_T^∞ cos(tγ)·F_{s,X}(t)·(ht+1)/t² dt`. -/ ++ + theorem fourier_auxF (s : ℂ) {X : ℝ} (hX : 1 < X) (hs : 1/2 < s.re) {γ : ℝ} + (hγ : γ ≠ 0) : + paperFourierIntegral (auxF s X) γ +@@ -706,9 +684,7 @@ theorem fourier_auxF (s : ℂ) {X : ℝ} (hX : 1 < X) (hs : 1/2 < s.re) {γ : + + (4*s - 2)*(Real.log X : ℂ)*(γ:ℂ)*Complex.cos ((Real.log X : ℂ)*(γ:ℂ)) + + 4*(γ:ℂ)*Complex.cos ((Real.log X : ℂ)*(γ:ℂ)))) * hEE' + +-/-- FTC on `(T,∞)` for the second-derivative kernel: with `g(t) = e^{-ht}/t` and `Re h > 0`, +-`∫_T^∞ (h² + (2ht+2)/t²)·g(t) dt = (h + 1/T)·g(T)`. The integrand has antiderivative +-`-(h + 1/t)·g(t)`, which vanishes at `∞`. -/ ++ + theorem integral_Ioi_gAux_deriv2 {h : ℂ} (hh : 0 < h.re) {T : ℝ} (hT : 0 < T) : + (∫ t in Set.Ioi T, (h^2 + (2*h*t + 2)/t^2) * (Complex.exp (-h * t) / t)) + = (h + 1/(T:ℂ)) * (Complex.exp (-h * (T:ℂ)) / (T:ℂ)) := by +@@ -734,7 +710,7 @@ theorem integral_Ioi_gAux_deriv2 {h : ℂ} (hh : 0 < h.re) {T : ℝ} (hT : 0 < T + rw [norm_neg] + exact norm_affine_inv_le h hT htT + +-/-- Integrability on `(T,∞)` of the remainder kernel `g(t)·(ht+1)/t²`, `g(t) = e^{-ht}/t`. -/ ++ + theorem integrableOn_gAux_mul_affine_div_sq {h : ℂ} (hh : 0 < h.re) {T : ℝ} (hT : 0 < T) : + IntegrableOn (fun t : ℝ => + (Complex.exp (-h * t) / t) * ((h*t + 1)/t^2)) (Set.Ioi T) := by +@@ -749,9 +725,7 @@ theorem integrableOn_gAux_mul_affine_div_sq {h : ℂ} (hh : 0 < h.re) {T : ℝ} + · intro t ht + exact norm_affine_div_sq_le h hT (le_of_lt ht) + +-/-- Linearity split of the second-derivative-kernel integral into plain and remainder parts: +-with `g(t) = e^{-ht}/t`, +-`∫_T^∞ (h²+(2ht+2)/t²)·g = h²·∫_T^∞ g + 2·∫_T^∞ g·(ht+1)/t²`. -/ ++ + theorem integral_Ioi_gAux_deriv2_split {h : ℂ} (hh : 0 < h.re) {T : ℝ} (hT : 0 < T) : + (∫ t in Set.Ioi T, (h^2 + (2*h*t + 2)/t^2) * (Complex.exp (-h * t) / t)) + = h^2 * (∫ t in Set.Ioi T, Complex.exp (-h * t) / t) +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/BernoulliGeneralized.lean b/projects/FltRegularBernoulli/BernoulliRegular/BernoulliGeneralized.lean +index f626dd2f5..69ea46900 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/BernoulliGeneralized.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/BernoulliGeneralized.lean +@@ -182,7 +182,7 @@ lemma bernoulliGen_teichmuller_inverse_eq_p_sub_one_div_p_add_padicInt + ((p - 1 : ℚ_[p]) / p) + z := by + have hp : Nat.Prime p := Fact.out + have hp_gt2 : 2 < p := lt_of_le_of_ne hp.two_le (Ne.symm hp_odd) +- haveI : NeZero p := ⟨hp.ne_zero⟩ ++ have : NeZero p := ⟨hp.ne_zero⟩ + let ωZ : DirichletCharacter ℤ_[p] p := (teichmullerChar p) ^ (p - 2) + let ωQ : DirichletCharacter ℚ_[p] p := (teichmullerCharQp p) ^ (p - 2) + let S : ℤ_[p] := ∑ a : ZMod p, ωZ a * (a.val : ℤ_[p]) +@@ -206,7 +206,7 @@ lemma bernoulliGen_teichmuller_inverse_eq_p_sub_one_div_p_add_padicInt + dsimp [ωZ]; rw [MulChar.pow_apply' _ hpow_ne_zero, map_pow, teichmullerChar_apply, + toZMod_teichmuller] + have hval : PadicInt.toZMod (a.val : ℤ_[p]) = a := by simp +- rw [map_mul, hω, hval, if_neg ha] ++ rw [map_mul, hω, hval, ite_eq_right ha] + calc + a ^ (p - 2) * a = a ^ ((p - 2) + 1) := by rw [mul_comm, pow_succ'] + _ = a ^ (p - 1) := by congr; omega +@@ -215,7 +215,7 @@ lemma bernoulliGen_teichmuller_inverse_eq_p_sub_one_div_p_add_padicInt + have hsplit : + (∑ a : ZMod p, if a = 0 then 0 else 1) = + (Finset.univ.erase (0 : ZMod p)).sum (fun _ ↦ (1 : ZMod p)) := by +- rw [← Finset.sum_erase_add _ _ (Finset.mem_univ 0), if_pos rfl, add_zero] ++ rw [← Finset.sum_erase_add _ _ (Finset.mem_univ 0), ite_eq_left rfl, add_zero] + refine Finset.sum_congr rfl fun a ha ↦ ?_ + simp [(Finset.mem_erase.mp ha).1] + calc +@@ -278,7 +278,7 @@ lemma val_add_val_neg_cast [NeZero N] (a : ZMod N) : + ((a.val : R) + ((-a).val : R)) = if a = 0 then (0 : R) else (N : R) := by + rcases eq_or_ne a 0 with rfl | ha + · simp +- · rw [if_neg ha, ZMod.neg_val, if_neg ha, Nat.cast_sub (ZMod.val_lt _).le] ++ · rw [ite_eq_right ha, ZMod.neg_val, ite_eq_right ha, Nat.cast_sub (ZMod.val_lt _).le] + ring + + omit [Algebra ℚ R] in +@@ -386,7 +386,7 @@ theorem bernoulli_mem_padicInt_of_lt_sub_one {p : ℕ} [hp : Fact p.Prime] + -- `k ≥ 1`. Apply `sum_bernoulli (k + 1) = 0`. + have hkp1_lt : k + 1 < p := by omega + have h_sum := _root_.sum_bernoulli (k + 1) +- rw [if_neg (by omega : k + 1 ≠ 1), Finset.sum_range_succ] at h_sum ++ rw [ite_eq_right (by omega : k + 1 ≠ 1), Finset.sum_range_succ] at h_sum + have h_choose_k : (Nat.choose (k + 1) k : ℚ) = (k + 1 : ℚ) := by + rw [Nat.choose_succ_self_right]; push_cast; rfl + rw [h_choose_k] at h_sum +@@ -399,7 +399,7 @@ theorem bernoulli_mem_padicInt_of_lt_sub_one {p : ℕ} [hp : Fact p.Prime] + let z_of : ℕ → ℤ_[p] := fun j ↦ + if h : j < k then (hj_wit j h).choose else 0 + have hz_of : ∀ j, j < k → (bernoulli j : ℚ_[p]) = ((z_of j : ℤ_[p]) : ℚ_[p]) := by +- intro j hj; simp only [z_of, dif_pos hj]; exact (hj_wit j hj).choose_spec ++ intro j hj; simp only [z_of, dite_eq_left hj]; exact (hj_wit j hj).choose_spec + let S : ℤ_[p] := ∑ j ∈ Finset.range k, (Nat.choose (k + 1) j : ℤ_[p]) * z_of j + have hS_coe : (S : ℚ_[p]) = + ∑ j ∈ Finset.range k, (Nat.choose (k + 1) j : ℚ_[p]) * (bernoulli j : ℚ_[p]) := by +@@ -541,7 +541,7 @@ theorem bernoulli_pSubOne_add_inv_p_mem_padicInt + -- Step 1: From `sum_bernoulli p = 0` derive + -- `p * bernoulli (p - 1) + 1 = -∑ k ∈ range (p - 2), C(p, k+1) * bernoulli (k+1)`. + have h_sum := _root_.sum_bernoulli p +- rw [if_neg hp.ne_one] at h_sum ++ rw [ite_eq_right hp.ne_one] at h_sum + have hp_eq : p = (p - 1) + 1 := by omega + nth_rewrite 1 [hp_eq] at h_sum + rw [Finset.sum_range_succ] at h_sum +@@ -576,7 +576,7 @@ theorem bernoulli_pSubOne_add_inv_p_mem_padicInt + if h : k < p - 2 then (h_wit k h).choose else 0 + have hz_of : ∀ k, k < p - 2 → + ((_root_.bernoulli (k + 1) : ℚ) : ℚ_[p]) = (z_of k : ℚ_[p]) := by +- intro k hk; simp only [z_of, dif_pos hk]; exact (h_wit k hk).choose_spec ++ intro k hk; simp only [z_of, dite_eq_left hk]; exact (h_wit k hk).choose_spec + -- `c k : ℕ := C(p, k + 1) / p`, satisfying `p * c k = C(p, k + 1)` for `k < p - 2`. + let c : ℕ → ℕ := fun k ↦ Nat.choose p (k + 1) / p + have hc_eq : ∀ k, k < p - 2 → p * c k = Nat.choose p (k + 1) := fun k hk ↦ +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/Characters.lean b/projects/FltRegularBernoulli/BernoulliRegular/Characters.lean +index 356776bea..c528b5dc6 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/Characters.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/Characters.lean +@@ -221,16 +221,16 @@ Dirichlet characters mod `p` is (noncanonically) isomorphic to + `(ZMod p)ˣ`, hence cyclic of order `p - 1`. -/ + lemma dirichletCharacter_mulEquiv_zmodUnits : + Nonempty (DirichletCharacter ℤ_[p] p ≃* (ZMod p)ˣ) := by +- haveI : NeZero p := ⟨hp.1.ne_zero⟩ +- haveI : HasEnoughRootsOfUnity ℤ_[p] (Monoid.exponent (ZMod p)ˣ) := ++ have : NeZero p := ⟨hp.1.ne_zero⟩ ++ have : HasEnoughRootsOfUnity ℤ_[p] (Monoid.exponent (ZMod p)ˣ) := + exponent_zmod_units (p := p) ▸ inferInstance + exact DirichletCharacter.mulEquiv_units ℤ_[p] p + + /-- The `ℤ_[p]`-valued Dirichlet character group mod `p` has `p - 1` + elements. -/ + lemma card_dirichletCharacter : Nat.card (DirichletCharacter ℤ_[p] p) = p - 1 := by +- haveI : NeZero p := ⟨hp.1.ne_zero⟩ +- haveI : HasEnoughRootsOfUnity ℤ_[p] (Monoid.exponent (ZMod p)ˣ) := ++ have : NeZero p := ⟨hp.1.ne_zero⟩ ++ have : HasEnoughRootsOfUnity ℤ_[p] (Monoid.exponent (ZMod p)ˣ) := + exponent_zmod_units (p := p) ▸ inferInstance + rw [DirichletCharacter.card_eq_totient_of_hasEnoughRootsOfUnity, + Nat.totient_prime hp.1] +@@ -313,7 +313,7 @@ lemma teichmuller_neg_one (hp_odd : p ≠ 2) : teichmuller p (-1) = -1 := by + have h_sq : teichmuller p (-1 : ZMod p) ^ 2 = 1 := by + rw [sq, ← map_mul, neg_one_mul, neg_neg, map_one] + rcases sq_eq_one_iff.mp h_sq with h1 | h_neg +- · haveI : Fact (2 < p) := ⟨lt_of_le_of_ne hp.1.two_le (Ne.symm hp_odd)⟩ ++ · have : Fact (2 < p) := ⟨lt_of_le_of_ne hp.1.two_le (Ne.symm hp_odd)⟩ + exact absurd (by simpa using congrArg PadicInt.toZMod h1) ZMod.neg_one_ne_one + · exact h_neg + +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/Basic.lean b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/Basic.lean +index 7733831c9..d24c5d66e 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/Basic.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/Basic.lean +@@ -54,9 +54,9 @@ prime `p`, paired with the standard additive character + `ZMod.stdAddChar : AddChar (ZMod p) ℂ`, evaluates to `-1`. -/ + theorem gaussSum_one_stdAddChar : + gaussSum (1 : DirichletCharacter ℂ p) (ZMod.stdAddChar (N := p)) = -1 := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ +- haveI : Fact (1 < p) := ⟨hp.out.one_lt⟩ +- haveI : Nontrivial (ZMod p) := ZMod.nontrivial p ++ have : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : Fact (1 < p) := ⟨hp.out.one_lt⟩ ++ have : Nontrivial (ZMod p) := ZMod.nontrivial p + -- `stdAddChar` is not the trivial additive character, so its values sum to `0`. + have h_ne : (ZMod.stdAddChar (N := p)) ≠ 1 := by + intro h +@@ -83,7 +83,7 @@ theorem gaussSum_one_stdAddChar : + MulChar.map_nonunit _ (by simp) + simp [h0] + · have hu : IsUnit a := ha.isUnit +- simp [MulChar.one_apply hu, if_neg ha] ++ simp [MulChar.one_apply hu, ite_eq_right ha] + classical + calc gaussSum (1 : DirichletCharacter ℂ p) (ZMod.stdAddChar (N := p)) + = ∑ a : ZMod p, (1 : DirichletCharacter ℂ p) a * (ZMod.stdAddChar (N := p)) a := rfl +@@ -107,7 +107,7 @@ theorem gaussSum_mul_gaussSum_inv_stdAddChar + gaussSum χ (ZMod.stdAddChar (N := p)) * + gaussSum χ⁻¹ (ZMod.stdAddChar (N := p)) = + χ (-1) * p := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + have h_prim : (ZMod.stdAddChar : AddChar (ZMod p) ℂ).IsPrimitive := + ZMod.isPrimitive_stdAddChar p + have h_card : (Fintype.card (ZMod p) : ℂ) = p := by +@@ -153,7 +153,7 @@ does not vanish as soon as their product is nontrivial. -/ + theorem jacobiSum_ne_zero_stdAddChar + {χ φ : DirichletCharacter ℂ p} (hχφ : χ * φ ≠ 1) : + jacobiSum χ φ ≠ 0 := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + by_cases hχ : χ = 1 + · subst hχ + have hφ : φ ≠ 1 := by simpa using hχφ +@@ -187,7 +187,7 @@ character factoring through `1` is the trivial character. -/ + theorem DirichletCharacter.isPrimitive_of_ne_one + {χ : DirichletCharacter ℂ p} (hχ : χ ≠ 1) : + χ.IsPrimitive := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + rw [DirichletCharacter.isPrimitive_def] + rcases (Nat.dvd_prime hp.out).mp χ.conductor_dvd_level with h | h + · exact absurd ((DirichletCharacter.factorsThrough_one_iff χ).mp +@@ -340,7 +340,7 @@ theorem dft_quadraticCharComplex_eq_gaussSum (hp₂ : p ≠ 2) (k : ZMod p) : + ZMod.dft (quadraticCharComplex p) k = + quadraticCharComplex p (-k) * + gaussSum (quadraticCharComplex p) (ZMod.stdAddChar (N := p)) := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + have hprim : (quadraticCharComplex p).IsPrimitive := + DirichletCharacter.isPrimitive_of_ne_one (p := p) + (quadraticCharComplex_ne_one (p := p) hp₂) +@@ -352,12 +352,12 @@ theorem dft_quadraticCharComplex_eq_gaussSum (hp₂ : p ≠ 2) (k : ZMod p) : + `p` at `0` and `0` away from `0`. -/ + theorem dft_const_one (k : ZMod p) : + ZMod.dft (fun _ : ZMod p ↦ (1 : ℂ)) k = if k = 0 then p else 0 := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + by_cases hk : k = 0 + · subst hk + rw [ZMod.dft_apply_zero] + simp +- · rw [ZMod.dft_apply, if_neg hk] ++ · rw [ZMod.dft_apply, ite_eq_right hk] + have hne : ((ZMod.stdAddChar : AddChar (ZMod p) ℂ).mulShift (-k)) ≠ 1 := by + intro hshift + have heval : (ZMod.stdAddChar (N := p)) (-k) = 1 := by +@@ -466,7 +466,7 @@ theorem conj_gaussSum_quadraticCharComplex_eq_neg_self_of_mod_four_eq_three + theorem gaussSum_quadraticCharComplex_sq (hp₂ : p ≠ 2) : + gaussSum (quadraticCharComplex p) (ZMod.stdAddChar (N := p)) ^ 2 = + quadraticCharComplex p (-1) * p := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + simpa [ZMod.card] using + gaussSum_sq (χ := quadraticCharComplex p) + (quadraticCharComplex_ne_one (p := p) hp₂) +@@ -579,7 +579,7 @@ character `χ : DirichletCharacter ℂ p`. Uses `χ^(p-1) = 1` + membership in + `Algebra.adjoin ℤ {μ_{p-1}}`, which is contained in the integral closure. -/ + theorem DirichletCharacter.isIntegral_apply (χ : DirichletCharacter ℂ p) (a : ZMod p) : + IsIntegral ℤ (χ a) := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + have hp_sub : 0 < p - 1 := by have := hp.out.one_lt; omega + set μ : ℂ := Complex.exp (2 * Real.pi * Complex.I / (p - 1 : ℕ)) + have hμ : IsPrimitiveRoot μ (p - 1) := +@@ -597,7 +597,7 @@ theorem DirichletCharacter.isIntegral_apply (χ : DirichletCharacter ℂ p) (a : + integral over `ℤ` (each is a `p`-th root of unity). -/ + theorem ZMod.isIntegral_stdAddChar (a : ZMod p) : + IsIntegral ℤ ((ZMod.stdAddChar : AddChar (ZMod p) ℂ) a) := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + have hx_pow : ((ZMod.stdAddChar : AddChar (ZMod p) ℂ) a) ^ p = 1 := by + rw [← AddChar.map_nsmul_eq_pow, show ((p : ℕ) • a : ZMod p) = 0 from by + rw [show ((p : ℕ) • a : ZMod p) = (p : ZMod p) * a from by ring, +@@ -636,7 +636,7 @@ theorem gaussSum_mem_algebraAdjoin_stickelbergerComplexRoot + (χ : DirichletCharacter ℂ p) : + gaussSum χ (ZMod.stdAddChar : AddChar (ZMod p) ℂ) ∈ + Algebra.adjoin ℤ ({stickelbergerComplexRoot p} : Set ℂ) := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + have hp_one_lt : 1 < p := hp.out.one_lt + have hp_sub : 0 < p - 1 := by omega + have hp_pos : 0 < p := hp.out.pos +@@ -665,7 +665,7 @@ theorem gaussSum_mem_algebraAdjoin_stickelbergerComplexRoot + have h_pow : χ ^ (p - 1) = 1 := by + have h := MulChar.pow_card_eq_one χ (M := ZMod p) + rwa [ZMod.card_units_eq_totient, Nat.totient_prime hp.out] at h +- haveI : NeZero (p - 1) := ⟨hp_sub.ne'⟩ ++ have : NeZero (p - 1) := ⟨hp_sub.ne'⟩ + have h_mem : χ a ∈ Algebra.adjoin ℤ ({ζ ^ p} : Set ℂ) := + MulChar.apply_mem_algebraAdjoin_of_pow_eq_one h_pow hζ_pm1 a + have h_sub : Algebra.adjoin ℤ ({ζ ^ p} : Set ℂ) ≤ Algebra.adjoin ℤ ({ζ} : Set ℂ) := by +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BlockDeterminant.lean b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BlockDeterminant.lean +index c3148c6ba..5764b48d9 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BlockDeterminant.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BlockDeterminant.lean +@@ -280,7 +280,7 @@ theorem toMatrix_deltaZeroConstOneDirichletCharacterBasis_normalizedDft : + simp [Module.Basis.repr_self, hij] + simpa only [Matrix.mul_diagonal, PEquiv.toMatrix_apply, Equiv.toPEquiv_apply, + Equiv.Perm.coe_inv, Option.mem_def, Option.some.injEq, ite_mul, one_mul, zero_mul, hneq', +- if_false] ++ ite_false] + using hsingle + + /-- The determinant of that monomial matrix: the sign of the permutation times the +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BranchChoice.lean b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BranchChoice.lean +index 34468899d..419594284 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BranchChoice.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/BranchChoice.lean +@@ -50,7 +50,7 @@ theorem card_even_eq_card_odd_characters (hp₂ : p ≠ 2) : + simp only [E, O, Finset.mem_union, Finset.mem_filter, Finset.mem_univ, true_and, iff_true] + exact DirichletCharacter.even_or_odd χ + have hneg_ne_one : (-1 : ZMod p) ≠ 1 := by +- haveI : Fact (2 < p) := ⟨lt_of_le_of_ne hp.out.two_le (Ne.symm hp₂)⟩ ++ have : Fact (2 < p) := ⟨lt_of_le_of_ne hp.out.two_le (Ne.symm hp₂)⟩ + exact ZMod.neg_one_ne_one + have hsum_zero : + ∑ χ : DirichletCharacter ℂ p, χ (-1 : ZMod p) = 0 := +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Operator.lean b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Operator.lean +index e01362db2..cdfae2bc9 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Operator.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Operator.lean +@@ -172,7 +172,7 @@ noncomputable def zmodEquivFin : ZMod p ≃ Fin p := + + theorem zmodEquivFin_symm_apply (i : Fin p) : + (zmodEquivFin (p := p)).symm i = (i : ZMod p) := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + change ZMod.finEquiv p i = (i : ZMod p) + cases p with + | zero => +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Trace.lean b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Trace.lean +index a5de9475f..f41b89788 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Trace.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/GaussSum/SignInvariant/Trace.lean +@@ -49,12 +49,12 @@ theorem dft_deltaZero_eq_constOne : + /-- The DFT of the constant-one function is concentrated at `0`. -/ + theorem dft_constOne (k : ZMod p) : + ZMod.dft (fun _ : ZMod p ↦ (1 : ℂ)) k = if k = 0 then p else 0 := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + by_cases hk : k = 0 + · subst hk + rw [ZMod.dft_apply_zero] + simp +- · rw [ZMod.dft_apply, if_neg hk] ++ · rw [ZMod.dft_apply, ite_eq_right hk] + have hne : ((ZMod.stdAddChar : AddChar (ZMod p) ℂ).mulShift (-k)) ≠ 1 := by + intro hshift + have heval : (ZMod.stdAddChar (N := p)) (-k) = 1 := by +@@ -149,7 +149,7 @@ theorem dft_eq_scalar_smul_inv_character {χ : DirichletCharacter ℂ p} + ZMod.dft χ = + (χ⁻¹ (-1) * gaussSum χ (ZMod.stdAddChar (N := p))) • + ((χ⁻¹ : DirichletCharacter ℂ p) : ZMod p → ℂ) := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + have hprim : χ.IsPrimitive := DirichletCharacter.isPrimitive_of_ne_one (p := p) hχ + ext k + simp only [Pi.smul_apply, smul_eq_mul] +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Defs.lean b/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Defs.lean +index e65342489..e45157576 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Defs.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Defs.lean +@@ -64,7 +64,7 @@ theorem odd_LFunction_one_eq_oddLValueRhs_of_LFunction_inv_zero + (Or.inr hp.out.ne_one), hχinv_odd.gammaFactor_def] + simp + have hfe := DirichletCharacter.IsPrimitive.completedLFunction_one_sub (χ := χ) hχ_prim (0 : ℂ) +- rw [DirichletCharacter.rootNumber, if_neg hχ_odd.not_even, pow_one, ++ rw [DirichletCharacter.rootNumber, ite_eq_right hχ_odd.not_even, pow_one, + ← mul_comm_div, ← mul_comm_div, ← Complex.cpow_sub _ _ (by exact_mod_cast hp.out.ne_zero), + sub_sub, add_halves, hL0, hχ0] at hfe + have hfe' : DirichletCharacter.completedLFunction χ 1 = +diff --git a/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Even.lean b/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Even.lean +index da64fd5da..f1e07c897 100644 +--- a/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Even.lean ++++ b/projects/FltRegularBernoulli/BernoulliRegular/LValueAtOne/Even.lean +@@ -96,7 +96,7 @@ private lemma LFunction_dft_inv_eq_gaussSum_mul_LFunction + {χ : DirichletCharacter ℂ p} (hχ_even : χ.Even) (hχinv_prim : (χ⁻¹).IsPrimitive) : + ZMod.LFunction (ZMod.dft (fun a : ZMod p => χ⁻¹ a)) 1 = + gaussSum χ⁻¹ (ZMod.stdAddChar (N := p)) * ZMod.LFunction χ 1 := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + have hft : + ZMod.dft (fun a : ZMod p => χ⁻¹ a) = fun a : ZMod p => + gaussSum χ⁻¹ (ZMod.stdAddChar (N := p)) * χ a := by +@@ -152,7 +152,7 @@ private lemma sum_mulChar_cosZeta_eq_neg_evenLValueLogSum + {χ : DirichletCharacter ℂ p} (hχinv_zero : χ⁻¹ 0 = 0) : + ∑ a : ZMod p, χ⁻¹ a * HurwitzZeta.cosZeta (ZMod.toAddCircle a) 1 = + -evenLValueLogSum p χ := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + simp only [evenLValueLogSum] + calc + ∑ a : ZMod p, χ⁻¹ a * HurwitzZeta.cosZeta (ZMod.toAddCircle a) 1 +@@ -176,7 +176,7 @@ theorem even_LFunction_one_eq_evenLValueRhs + {χ : DirichletCharacter ℂ p} (hχ_prim : χ.IsPrimitive) (hχ_even : χ.Even) + (hχ_ne_one : χ ≠ 1) : + DirichletCharacter.LFunction χ 1 = evenLValueRhs p χ := by +- haveI : NeZero p := ⟨hp.out.ne_zero⟩ ++ have : NeZero p := ⟨hp.out.ne_zero⟩ + change ZMod.LFunction (fun a : ZMod p => χ a) 1 = evenLValueRhs p χ + have hχinv_even : (χ⁻¹).Even := by + rw [DirichletCharacter.Even] at hχ_even ⊢ +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/CharP.lean b/projects/HasseWeil/HasseWeil/FormalGroup/CharP.lean +index f9dac12ed..b5845ada0 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/CharP.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/CharP.lean +@@ -61,7 +61,7 @@ private theorem exists_expand_of_coeff_vanishing (p : ℕ) (hp : p ≠ 0) + vanishes unless `p ∣ n` (or `n = 0`). -/ + private theorem coeff_eq_zero_of_derivative_eq_zero_charP {p : ℕ} + [Fact p.Prime] [CharP R p] {f : PowerSeries R} +- (hf : PowerSeries.derivative R f = 0) ++ (hf : PowerSeries.derivative (R := R) f = 0) + (n : ℕ) (hpn : ¬ p ∣ n) : + PowerSeries.coeff n f = 0 := by + -- `n ≠ 0` since `p ∣ 0`; write `n = m + 1`. +@@ -101,7 +101,7 @@ theorem FormalGroup.mulByP_exists_expand (F : FormalGroup R) (p : ℕ) + apply exists_expand_of_coeff_vanishing p hp_prime.out.ne_zero + intro n hpn + -- `derivative [p] = 0`, from the chain rule and `[p] = 0` in characteristic `p`. +- have hder : PowerSeries.derivative R (F.mulByNatHom p).toSeries = 0 := by ++ have hder : PowerSeries.derivative (R := R) (F.mulByNatHom p).toSeries = 0 := by + have chain := FormalGroupHom.invariantDifferential_chain (F.mulByNatHom p) + have hp_zero : + PowerSeries.C (PowerSeries.coeff 1 (F.mulByNatHom p).toSeries) * +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/Differential.lean b/projects/HasseWeil/HasseWeil/FormalGroup/Differential.lean +index 655b8afa6..7d00d2a24 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/Differential.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/Differential.lean +@@ -193,7 +193,7 @@ private theorem coeff_subst_runit_eq (n : ℕ) + · simp only [hd0, pow_zero, one_mul, MvPowerSeries.coeff_X_pow] + have hne : d 1 ≠ n := + fun h ↦ hd (Finsupp.ext (fun i ↦ by fin_cases i <;> simp [*, Finsupp.single_eq_same])) +- rw [if_neg (fun h ↦ hne ((Finsupp.single_injective (1 : Fin 2)).eq_iff.mp h).symm)] ++ rw [ite_eq_right (fun h ↦ hne ((Finsupp.single_injective (1 : Fin 2)).eq_iff.mp h).symm)] + · rw [zero_pow hd0, zero_mul, map_zero] + + -- Helper: coeff at (single 1 m) of F.toSeries equals [m = 1] (from runit: F(0,Y)=Y) +@@ -234,11 +234,11 @@ private theorem coeff_one_pow {f : PowerSeries R} (hf : PowerSeries.constantCoef + PowerSeries.coeff 1 (f ^ d) = if d = 1 then PowerSeries.coeff 1 f else 0 := by + by_cases hd : d = 1 + · simp [hd] +- · rw [if_neg hd] ++ · rw [ite_eq_right hd] + rcases d with _ | _ | d + · simp only [pow_zero] + show PowerSeries.coeff 1 (1 : PowerSeries R) = 0 +- rw [PowerSeries.coeff_one, if_neg one_ne_zero] ++ rw [PowerSeries.coeff_one, ite_eq_right one_ne_zero] + · omega + · exact coeff_one_pow_eq_zero hf (by omega) + +@@ -258,12 +258,12 @@ private theorem coeff_subst_X0 (g : PowerSeries R) (a b : ℕ) : + · simp [MvPowerSeries.coeff_X_pow, smul_eq_mul] + · intro d hd + simp only [MvPowerSeries.coeff_X_pow, smul_eq_mul] +- rw [if_neg (fun h ↦ hd ((Finsupp.single_injective (0 : Fin 2)).eq_iff.mp h).symm), ++ rw [ite_eq_right (fun h ↦ hd ((Finsupp.single_injective (0 : Fin 2)).eq_iff.mp h).symm), + mul_zero] +- · rw [if_neg hb] ++ · rw [ite_eq_right hb] + apply finsum_eq_zero_of_forall_eq_zero + intro d +- rw [MvPowerSeries.coeff_X_pow, if_neg] ++ rw [MvPowerSeries.coeff_X_pow, ite_eq_right] + · exact smul_zero _ + · intro h + have := DFunLike.congr_fun h 1 +@@ -284,12 +284,12 @@ private theorem coeff_subst_X1 (g : PowerSeries R) (a b : ℕ) : + · simp [MvPowerSeries.coeff_X_pow, smul_eq_mul] + · intro d hd + simp only [MvPowerSeries.coeff_X_pow, smul_eq_mul] +- rw [if_neg (fun h ↦ hd ((Finsupp.single_injective (1 : Fin 2)).eq_iff.mp h).symm), ++ rw [ite_eq_right (fun h ↦ hd ((Finsupp.single_injective (1 : Fin 2)).eq_iff.mp h).symm), + mul_zero] +- · rw [if_neg hab] ++ · rw [ite_eq_right hab] + apply finsum_eq_zero_of_forall_eq_zero + intro d +- rw [MvPowerSeries.coeff_X_pow, if_neg] ++ rw [MvPowerSeries.coeff_X_pow, ite_eq_right] + · exact smul_zero _ + · intro h + have := DFunLike.congr_fun h 0 +@@ -333,7 +333,7 @@ private lemma coeff_subst_X0_X1_mul_eq_zero_of_ne (g : PowerSeries R) (d0 d1 n : + from finsupp_fin2_decompose e2] + rw [coeff_subst_X0, coeff_subst_X1] + by_cases h1 : e1 1 = 0 +- · rw [if_pos h1] ++ · rw [ite_eq_left h1] + by_cases h2 : e2 0 = 0 + · -- Both e1 1 = 0 and e2 0 = 0: forces (e1, e2) = (single 0 1, single 1 n) + exfalso; apply hne +@@ -348,8 +348,8 @@ private lemma coeff_subst_X0_X1_mul_eq_zero_of_ne (g : PowerSeries R) (d0 d1 n : + rw [finsupp_fin2_decompose e1, h1, he10]; simp + · show e2 = Finsupp.single 1 n + rw [finsupp_fin2_decompose e2, h2, he21]; simp +- · rw [if_neg h2, mul_zero] +- · rw [if_neg h1, zero_mul] ++ · rw [ite_eq_right h2, mul_zero] ++ · rw [ite_eq_right h1, zero_mul] + + -- Orthogonality: coeff_{(1,n)} (f(X_0)^d0 * f(X_1)^d1) = coeff_1(f^d0) * coeff_n(f^d1) + private theorem coeff_10_prod_orthogonal (g : PowerSeries R) (d0 d1 n : ℕ) : +@@ -424,15 +424,15 @@ private lemma finsum_fin2_reduce_full (p : (Fin 2 →₀ ℕ) → R) : + Set.indicator (Set.range ι) (fun d ↦ if d 0 = 1 then p d else 0) d := by + intro d; classical rw [Set.indicator_apply] + by_cases hd : d ∈ Set.range ι +- · rw [if_pos hd] +- · rw [if_neg hd, if_neg (mt (hmem d).mpr hd)] ++ · rw [ite_eq_left hd] ++ · rw [ite_eq_right hd, ite_eq_right (mt (hmem d).mpr hd)] + conv_lhs => arg 1; ext d; rw [key d] + rw [← finsum_mem_def, ← finsum_subtype_eq_finsum_cond (· ∈ Set.range ι), + ← finsum_comp_equiv (Equiv.ofInjective ι hinj)] + congr 1; ext k + show (if (ι k : Fin 2 →₀ ℕ) 0 = 1 then p (ι k) else 0) = + p (Finsupp.single 0 1 + Finsupp.single 1 k) +- rw [if_pos (hι0 k)] ++ rw [ite_eq_left (hι0 k)] + + -- Helper: c * finsum f = finsum (c * f ·) when f has finite support. + private lemma mul_finsum_of_support_subset {α : Type*} (c : R) (f : α → R) +@@ -503,11 +503,11 @@ private theorem antidiag_term_vanish (F : FormalGroup R) (d n : ℕ) + rcases Nat.eq_zero_or_pos (e1 0) with he10 | he10 + · have he1eq : e1 = Finsupp.single 1 (e1 1) := Finsupp.ext fun i ↦ by + fin_cases i <;> simp_all [Finsupp.single_eq_same] +- rw [he1eq, coeff_single1_F, if_neg (fun h ↦ hA ⟨he10, h⟩), zero_mul] ++ rw [he1eq, coeff_single1_F, ite_eq_right (fun h ↦ hA ⟨he10, h⟩), zero_mul] + · have he20 : e2 0 = 0 := by omega + have he2eq : e2 = Finsupp.single 1 (e2 1) := Finsupp.ext fun i ↦ by + fin_cases i <;> simp_all [Finsupp.single_eq_same] +- rw [he2eq, coeff_runit_pow, if_neg (fun h ↦ hB ⟨by omega, h⟩), mul_zero] ++ rw [he2eq, coeff_runit_pow, ite_eq_right (fun h ↦ hB ⟨by omega, h⟩), mul_zero] + + -- Sub-lemma: the antidiagonal sum for `coeff_{(1,n)} (F^d * F)` collapses to the two + -- surviving terms — pair A `(single 1 1, single 0 1 + single 1 (n-1))` and pair B +@@ -661,9 +661,9 @@ private theorem coeff_10_FG_pow (F : FormalGroup R) : + induction d with + | zero => + intro n +- simp only [pow_zero, Nat.zero_le, le_add_iff_nonneg_left, if_true, ++ simp only [pow_zero, Nat.zero_le, le_add_iff_nonneg_left, ite_true, + Nat.cast_zero, zero_mul, MvPowerSeries.coeff_one] +- rw [if_neg]; intro h ++ rw [ite_eq_right]; intro h + exact absurd (DFunLike.congr_fun h 0) (by + simp [Finsupp.add_apply, Finsupp.single_eq_same]) + | succ d ih => +@@ -671,7 +671,7 @@ private theorem coeff_10_FG_pow (F : FormalGroup R) : + -- For d+1 > n+1, use direct vanishing from nilpotent coefficient + by_cases hdn : d + 1 ≤ n + 1 + · -- d + 1 ≤ n + 1, i.e., d ≤ n +- rw [if_pos hdn] ++ rw [ite_eq_left hdn] + have hdn' : d ≤ n := by omega + rw [pow_succ, mul_comm, MvPowerSeries.coeff_mul] + -- The antidiag sum: Σ coeff_e1(F) * coeff_e2(F^d) +@@ -703,7 +703,7 @@ private theorem coeff_10_FG_pow (F : FormalGroup R) : + (Finsupp.single (0 : Fin 2) 1 + Finsupp.single (1 : Fin 2) (n - 1)) + (F.toSeries ^ d) = + (d : R) * PowerSeries.coeff (n - d) F.dX_at_zero := by +- rw [coeff_single1_F, if_pos rfl, one_mul, ih, if_pos (by omega : d ≤ n - 1 + 1)] ++ rw [coeff_single1_F, ite_eq_left rfl, one_mul, ih, ite_eq_left (by omega : d ≤ n - 1 + 1)] + have : n - 1 + 1 - d = n - d := by omega + rw [this] + -- Compute pair B value +@@ -713,7 +713,7 @@ private theorem coeff_10_FG_pow (F : FormalGroup R) : + F.toSeries * + MvPowerSeries.coeff (Finsupp.single (1 : Fin 2) d) (F.toSeries ^ d) = + PowerSeries.coeff (n - d) F.dX_at_zero := by +- rw [coeff_runit_pow, if_pos rfl, mul_one, FormalGroup.dX_at_zero, ++ rw [coeff_runit_pow, ite_eq_left rfl, mul_one, FormalGroup.dX_at_zero, + PowerSeries.coeff_mk] + -- The sum = A_val + B_val = (d+1) * coeff_{n-d} dxF + -- (the split into the two surviving terms is `coeff_10_FG_pow_antidiag_split`) +@@ -725,7 +725,7 @@ private theorem coeff_10_FG_pow (F : FormalGroup R) : + · -- A_val + B_val = (d+1) * coeff_{n+1-(d+1)} dxF + rw [show n + 1 - (d + 1) = n - d from by omega]; push_cast; ring + · -- d + 1 > n + 1: coeff vanishes by nilpotent degree bound +- rw [if_neg hdn] ++ rw [ite_eq_right hdn] + exact coeff_10_FG_pow_succ_vanish F hdn + + /-- The explicit `Finset` sum that both sides of `coeff_10_lhs` reduce to: +@@ -770,7 +770,7 @@ private theorem coeff_10_subst_eq_sum (F G : FormalGroup R) (f : FormalGroupHom + rw [Function.mem_support, ne_eq] at hd + rw [Finset.mem_coe, Finset.mem_range] + by_contra h; push Not at h +- exact hd (if_neg (by omega : ¬(d ≤ n + 1))))] ++ exact hd (ite_eq_right (by omega : ¬(d ≤ n + 1))))] + -- Kill the d = 0 term (it contributes 0 since d = 0 gives 0 * ... = 0) + rw [Finset.sum_range_succ' (n := n + 1)] + simp only [Nat.cast_zero, zero_mul, Nat.sub_zero, le_add_iff_nonneg_left, +@@ -784,7 +784,7 @@ private theorem coeff_10_subst_eq_sum (F G : FormalGroup R) (f : FormalGroupHom + (↑(k + 1) : R) * PowerSeries.coeff (k + 1) f.toSeries * + PowerSeries.coeff (n - k) F.dX_at_zero := by + intro k hk; rw [Finset.mem_range] at hk +- rw [if_pos (by omega : k + 1 ≤ n + 1)] ++ rw [ite_eq_left (by omega : k + 1 ≤ n + 1)] + have : n + 1 - (k + 1) = n - k := by omega + rw [this] + rw [Finset.sum_congr rfl hsimp] +@@ -795,7 +795,7 @@ unfolds (via `coeff_mul` and `coeff_derivative`) to the explicit range sum + bijection `k ↦ (k, n - k)`. -/ + private theorem coeff_derivative_mul_dX_eq_sum (F G : FormalGroup R) + (f : FormalGroupHom F G) (n : ℕ) : +- PowerSeries.coeff n (PowerSeries.derivative R f.toSeries * F.dX_at_zero) = ++ PowerSeries.coeff n (PowerSeries.derivative (R := R) f.toSeries * F.dX_at_zero) = + coeff_10_sum F G f n := by + rw [coeff_10_sum] + -- Expand the RHS via `coeff_mul` and `coeff_derivative`, then match the range sum against +@@ -824,11 +824,11 @@ private theorem coeff_derivative_mul_dX_eq_sum (F G : FormalGroup R) + private theorem coeff_10_lhs (F G : FormalGroup R) (f : FormalGroupHom F G) (n : ℕ) : + MvPowerSeries.coeff (Finsupp.single (0 : Fin 2) 1 + Finsupp.single (1 : Fin 2) n) + (PowerSeries.subst F.toSeries f.toSeries) = +- PowerSeries.coeff n (PowerSeries.derivative R f.toSeries * F.dX_at_zero) := ++ PowerSeries.coeff n (PowerSeries.derivative (R := R) f.toSeries * F.dX_at_zero) := + (coeff_10_subst_eq_sum F G f n).trans (coeff_derivative_mul_dX_eq_sum F G f n).symm + + theorem FormalGroup.dX_at_zero_chain (f : FormalGroupHom F G) : +- (PowerSeries.derivative R f.toSeries) * F.dX_at_zero = ++ (PowerSeries.derivative (R := R) f.toSeries) * F.dX_at_zero = + PowerSeries.C (PowerSeries.coeff 1 f.toSeries) * + PowerSeries.subst f.toSeries G.dX_at_zero := by + ext n +@@ -882,14 +882,14 @@ invariant differential. + Reference: Silverman, *The Arithmetic of Elliptic Curves*, IV.4, Corollary 4.3. -/ + theorem FormalGroup.invariantDiff_chain (f : FormalGroupHom F G) : + PowerSeries.subst f.toSeries G.invariantDiff * +- (PowerSeries.derivative R f.toSeries) = ++ (PowerSeries.derivative (R := R) f.toSeries) = + PowerSeries.C (PowerSeries.coeff 1 f.toSeries) * F.invariantDiff := by + -- Set up abbreviations to ensure all terms are in PowerSeries R, avoiding + -- MvPowerSeries Unit R / PowerSeries R defeq issues with rw/simp. + set c₁ : PowerSeries R := PowerSeries.C (PowerSeries.coeff 1 f.toSeries) + set ωG' : PowerSeries R := PowerSeries.subst f.toSeries G.invariantDiff + set dG' : PowerSeries R := PowerSeries.subst f.toSeries G.dX_at_zero +- set f' : PowerSeries R := PowerSeries.derivative R f.toSeries ++ set f' : PowerSeries R := PowerSeries.derivative (R := R) f.toSeries + set ωF : PowerSeries R := F.invariantDiff + set dF : PowerSeries R := F.dX_at_zero + -- Two ingredients: the `dX_at_zero` chain identity `f' * dF = c₁ * dG'` and the +@@ -1207,7 +1207,7 @@ private lemma coeff_prod_subst_vec_zero_X0 (d e : Fin 2 →₀ ℕ) : + simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_zero] + by_cases hd0 : d 0 = 0 + · simp [hd0] +- · rw [zero_pow hd0, zero_mul, map_zero, if_neg hd0] ++ · rw [zero_pow hd0, zero_mul, map_zero, ite_eq_right hd0] + + /-- Reindexing: a finsum over `d : Fin 2 →₀ ℕ` of a term that vanishes unless + `d 0 = 0` collapses to a finsum over `n : ℕ` along `n ↦ Finsupp.single 1 n`, the +@@ -1434,4 +1434,4 @@ theorem invariantDiff_translation (F : FormalGroup R) : + + end FormalGroup + +-end HasseWeil.FormalGroup +\ No newline at end of file ++end HasseWeil.FormalGroup +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/EvalGroup.lean b/projects/HasseWeil/HasseWeil/FormalGroup/EvalGroup.lean +index 5d7732dc9..9c4831e16 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/EvalGroup.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/EvalGroup.lean +@@ -9,49 +9,6 @@ import Mathlib.Algebra.Group.MinimalAxioms + import Mathlib.RingTheory.AdicCompletion.Topology + import Mathlib.RingTheory.PowerSeries.Evaluation + +-/-! +-# The group `F(M)` associated to a formal group over a complete local ring +-# (Silverman IV.3, ticket T-IV-3-001) +- +-Let `R` be a commutative local ring with maximal ideal `M = IsLocalRing.maximalIdeal R`, +-equipped with the `M`-adic topology (so that it is both a topological ring with +-a linear topology, a uniform ring, etc.), and assume moreover that it is +-`M`-adically complete (so `R` is Hausdorff and complete for this topology). +- +-For a formal group law `F(X, Y) ∈ R[[X, Y]]`, the set `M` acquires a structure of +-an abelian group via +- `x +_F y := F(x, y) = MvPowerSeries.eval₂ (RingHom.id R) ![x, y] F.toSeries`. +- +-The convergence of the power series `F(x, y)` is guaranteed by `x, y ∈ M` (they are +-topologically nilpotent, as `M^n → 0` in the adic topology) and by completeness. +- +-## Main definitions +- +-* `HasseWeil.FormalGroup.FormalGroup.evalAdd F x y` — the binary operation +- `x +_F y` on `M`, returning an element of `R`. +-* `HasseWeil.FormalGroup.FormalGroup.evalAdd_mem F x y` — the operation is closed +- in `M`, i.e. `evalAdd F x y ∈ M`. +-* `HasseWeil.FormalGroup.FormalGroup.evalNeg F x` — the formal negation +- `-_F x := i(x)` for `x ∈ M`, where `i = F.inverse` is the formal inverse +- power series. +-* `HasseWeil.FormalGroup.FormalGroup.evalNeg_mem F x` — the negation is closed +- in `M`, i.e. `evalNeg F x ∈ M`. +- +-The formal-group axioms induce the group laws for `evalAdd`; the resulting +-operation and `evalNeg` are bundled as an `AddCommGroup` on `F.EvalGroup hAdic`. +-The substitution bridge used for associativity and inverses is proved for the +-`M`-adic uniformity, where `MvPowerSeries.eval₂_subst` does not apply directly. +- +-## Assumptions on `R` +- +-We require `R` to be a `CommRing`, `IsLocalRing`, equipped with topology and uniform +-space structure coming from the `M`-adic topology, and `M`-adically complete. +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], IV.3 (Definition of the group +- `F(M)`, p. 122). +--/ + + set_option linter.dupNamespace false + +@@ -127,10 +84,8 @@ noncomputable def FormalGroup.evalAdd (F : FormalGroup R) + /-! ### Closure under `+_F`: `evalAdd F x y ∈ M` -/ + + omit [IsUniformAddGroup R] [IsLinearTopology R R] [T2Space R] [CompleteSpace R] in +-/-- The maximal ideal is closed in the `M`-adic topology. + +-`M` is open (as the basis of neighborhoods of 0 at level 1, i.e. `M^1 = M`), +-hence closed. -/ ++ + lemma maximalIdeal_isClosed + (hAdic : IsAdic (IsLocalRing.maximalIdeal R)) : + IsClosed (IsLocalRing.maximalIdeal R : Set R) := by +@@ -296,7 +251,7 @@ private lemma coeff_swap_diag (d : Fin 2 →₀ ℕ) : + ((MvPowerSeries.X (1 : Fin 2) : MvPowerSeries (Fin 2) R) ^ ((finsupp_swap d) 0) * + (MvPowerSeries.X 0) ^ ((finsupp_swap d) 1)) = 1 := by + rw [coeff_X_one_pow_mul_X_zero_pow, finsupp_swap_apply_zero, finsupp_swap_apply_one, +- if_pos] ++ ite_eq_left] + ext i; fin_cases i <;> simp + + omit [IsLocalRing R] [UniformSpace R] [IsUniformAddGroup R] [IsTopologicalRing R] +@@ -450,7 +405,7 @@ private lemma coeff_single_X_pow_mul_zero_pow_of_ne + rw [show ((MvPowerSeries.X (0 : Fin 2) : MvPowerSeries (Fin 2) R) ^ (d 0)) = + MvPowerSeries.monomial (R := R) (Finsupp.single 0 (d 0)) 1 from by + rw [MvPowerSeries.X_pow_eq]] +- rw [MvPowerSeries.coeff_monomial, if_neg] ++ rw [MvPowerSeries.coeff_monomial, ite_eq_right] + intro heq + apply hdj + have := DFunLike.congr_fun heq 0 +@@ -528,9 +483,9 @@ private lemma evalAdd_zero_right_term_eq (F : FormalGroup R) + rw [hd_single, HasseWeil.FG.FormalGroup.coeff_10] + rw [show (Finsupp.single (0 : Fin 2) 1) 0 = 1 from by + simp] +- rw [pow_one, one_mul, if_pos rfl] ++ rw [pow_one, one_mul, ite_eq_left rfl] + · +- rw [hdeq, F.coeff_j0_of_ne_one (d 0) hd0, zero_mul, if_neg] ++ rw [hdeq, F.coeff_j0_of_ne_one (d 0) hd0, zero_mul, ite_eq_right] + intro hcontra + apply hd0 + have := DFunLike.congr_fun hcontra 0 +@@ -538,7 +493,7 @@ private lemma evalAdd_zero_right_term_eq (F : FormalGroup R) + · + rw [Finsupp.prod_fintype _ _ (fun i ↦ pow_zero _), Fin.prod_univ_two, + Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_zero, +- zero_pow hd1, mul_zero, mul_zero, if_neg] ++ zero_pow hd1, mul_zero, mul_zero, ite_eq_right] + intro hcontra + apply hd1 + have := DFunLike.congr_fun hcontra 1 +@@ -585,7 +540,7 @@ private lemma coeff_single_zero_pow_mul_X_pow_of_ne + rw [show ((MvPowerSeries.X (1 : Fin 2) : MvPowerSeries (Fin 2) R) ^ (d 1)) = + MvPowerSeries.monomial (R := R) (Finsupp.single 1 (d 1)) 1 from by + rw [MvPowerSeries.X_pow_eq]] +- rw [MvPowerSeries.coeff_monomial, if_neg] ++ rw [MvPowerSeries.coeff_monomial, ite_eq_right] + intro heq + apply hdj + have := DFunLike.congr_fun heq 1 +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroup.lean b/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroup.lean +index 2febf6bff..953c00c2d 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroup.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroup.lean +@@ -197,16 +197,16 @@ theorem conv₂_truncate (n : ℕ) : + (if n - i < n then formalW_coeff W (n - i) else 0) = + formalW_coeff W i * formalW_coeff W (n - i) + rcases lt_or_eq_of_le hi with h_lt | h_eq +- · rw [if_pos h_lt] ++ · rw [ite_eq_left h_lt] + by_cases h_ni : n - i < n +- · rw [if_pos h_ni] ++ · rw [ite_eq_left h_ni] + · have h_i_eq_zero : i = 0 := by omega + subst h_i_eq_zero +- rw [if_neg h_ni] ++ rw [ite_eq_right h_ni] + rw [show formalW_coeff W 0 = 0 from formalW_coeff_zero W] + ring + · subst h_eq +- rw [if_neg (by omega : ¬ (i < i))] ++ rw [ite_eq_right (by omega : ¬ (i < i))] + rw [show i - i = 0 from Nat.sub_self i] + rw [show formalW_coeff W 0 = 0 from formalW_coeff_zero W] + ring +@@ -223,9 +223,9 @@ theorem conv₂_truncate' (n : ℕ) (hn : 1 ≤ n) : + (if n - 1 - i < n then formalW_coeff W (n - 1 - i) else 0) = + formalW_coeff W i * formalW_coeff W (n - 1 - i) + have h_i_lt_n : i < n := by omega +- rw [if_pos h_i_lt_n] ++ rw [ite_eq_left h_i_lt_n] + have h_ni_lt_n : n - 1 - i < n := by omega +- rw [if_pos h_ni_lt_n] ++ rw [ite_eq_left h_ni_lt_n] + + /-- `coeff n (formalW W * formalW W) = conv₂ (formalW_coeff W) n`. -/ + theorem coeff_formalW_sq (n : ℕ) : +@@ -287,19 +287,19 @@ private theorem conv₃_truncate_term {n i j : ℕ} (hi : i ≤ n) (hj : j ≤ n + (if n - i - j < n then formalW_coeff W (n - i - j) else 0) = + formalW_coeff W i * formalW_coeff W j * formalW_coeff W (n - i - j) := by + rcases lt_or_eq_of_le hi with h_i_lt | h_i_eq +- · rw [if_pos h_i_lt] ++ · rw [ite_eq_left h_i_lt] + rcases lt_or_eq_of_le hj with h_j_lt | h_j_eq + · -- j ≤ n - i and j < n - i, so j < n + have h_j_lt_n : j < n := by omega +- rw [if_pos h_j_lt_n] ++ rw [ite_eq_left h_j_lt_n] + by_cases h_k_lt_n : n - i - j < n +- · rw [if_pos h_k_lt_n] ++ · rw [ite_eq_left h_k_lt_n] + · -- n - i - j ≥ n means i + j = 0 + have h_i_eq_zero : i = 0 := by omega + have h_j_eq_zero : j = 0 := by omega + subst h_i_eq_zero + subst h_j_eq_zero +- rw [if_neg h_k_lt_n] ++ rw [ite_eq_right h_k_lt_n] + rw [show formalW_coeff W 0 = 0 from formalW_coeff_zero W] + ring + · -- j = n - i +@@ -313,7 +313,7 @@ private theorem conv₃_truncate_term {n i j : ℕ} (hi : i ≤ n) (hj : j ≤ n + -- j ≤ n - n = 0, so j = 0 + have h_j_eq_zero : j = 0 := by omega + subst h_j_eq_zero +- rw [if_neg (by omega : ¬ (i < i))] ++ rw [ite_eq_right (by omega : ¬ (i < i))] + rw [show formalW_coeff W 0 = 0 from formalW_coeff_zero W] + ring + +@@ -389,7 +389,7 @@ private theorem formalW_step_eq_recurrence_rhs_of_lt_three (n : ℕ) (hn3 : n < + unfold formalW_step + dsimp only + simp only [dite_eq_ite] +- rw [if_pos hn3, if_neg (by omega : ¬ (n = 3))] ++ rw [ite_eq_left hn3, ite_eq_right (by omega : ¬ (n = 3))] + interval_cases n + all_goals + simp [conv₂, conv₃, formalW_coeff_zero, formalW_coeff_one, formalW_coeff_two, +@@ -408,11 +408,11 @@ private theorem formalW_step_eq_recurrence_rhs_three (n : ℕ) (hn_eq3 : n = 3) + unfold formalW_step + dsimp only + simp only [dite_eq_ite] +- rw [if_neg (by omega : ¬ (n < 3)), if_pos hn_eq3] ++ rw [ite_eq_right (by omega : ¬ (n < 3)), ite_eq_left hn_eq3] + subst hn_eq3 + simp only [] +- rw [if_pos (by norm_num : (1 : ℕ) ≤ 3), if_pos (by norm_num : (2 : ℕ) ≤ 3), +- if_pos (by norm_num : (1 : ℕ) ≤ 3)] ++ rw [ite_eq_left (by norm_num : (1 : ℕ) ≤ 3), ite_eq_left (by norm_num : (2 : ℕ) ≤ 3), ++ ite_eq_left (by norm_num : (1 : ℕ) ≤ 3)] + rw [show formalW_coeff W (3 - 1) = formalW_coeff W 2 from by norm_num, + show formalW_coeff W (3 - 2) = formalW_coeff W 1 from by norm_num, + formalW_coeff_one W, formalW_coeff_two W] +@@ -434,17 +434,17 @@ private theorem formalW_step_eq_recurrence_rhs_of_four_le (n : ℕ) (hn4 : 4 ≤ + dsimp only + simp only [dite_eq_ite] + -- Clear the step's `n < 3` / `n = 3` guards (LHS) and the `n = 3` term on the RHS. +- rw [if_neg (by omega : ¬ (n < 3)), if_neg (by omega : ¬ (n = 3)), +- if_neg (by omega : ¬ (n = 3))] +- rw [if_pos (show 1 ≤ n from by omega), if_pos (show 2 ≤ n from by omega), +- if_pos (show 1 ≤ n from by omega)] ++ rw [ite_eq_right (by omega : ¬ (n < 3)), ite_eq_right (by omega : ¬ (n = 3)), ++ ite_eq_right (by omega : ¬ (n = 3))] ++ rw [ite_eq_left (show 1 ≤ n from by omega), ite_eq_left (show 2 ≤ n from by omega), ++ ite_eq_left (show 1 ≤ n from by omega)] + -- Use conv₂_truncate, conv₃_truncate for the LHS + rw [conv₂_truncate W n, conv₂_truncate' W n (by omega), conv₃_truncate W n] + -- The truncated w(n-1) and w(n-2) become formalW_coeff (already beta-reduced) + rw [show (if n - 1 < n then formalW_coeff W (n - 1) else 0) = formalW_coeff W (n - 1) from +- if_pos (by omega)] ++ ite_eq_left (by omega)] + rw [show (if n - 2 < n then formalW_coeff W (n - 2) else 0) = formalW_coeff W (n - 2) from +- if_pos (by omega)] ++ ite_eq_left (by omega)] + ring + + /-- The `formalW_step` recursion equals the recurrence right-hand side from +@@ -491,23 +491,5 @@ theorem formalW_recurrence : + formalW_coeff_eq_step W n] + exact formalW_step_eq_recurrence_rhs W n + +-/-! ### Uniqueness of `formalW` (Silverman IV.1.1(b)) +- +-Uniqueness of `formalW` follows the factoring pattern: if `d := w' - formalW W`, +-then `d = K · d` for some `K` with zero constant coefficient, hence `d = 0` +-by `PowerSeries.eq_zero_of_self_eq_mul_self` +-(see `HasseWeil/PowerSeriesHelpers.lean`). +- +-**Status**: infrastructure ready (`eq_zero_of_self_eq_mul_self`), but the +-factoring step `RHS(w') − RHS(formalW W) = K · d` cannot be established by +-`ring`/`linear_combination`/`abel` because of a `PowerSeries R` typeclass +-gap: `RightDistribClass (PowerSeries R)` and `IsRightCancelAdd (PowerSeries R)` +-fail to synthesize in Lean 4.29 / mathlib v4.29.0-rc6, blocking the ring +-tactic on distributivity-heavy identities. The factoring works on simple +-identities in isolation but stops mid-normalisation on the multi-term +-combination needed here. A coefficient-induction route (via +-`PowerSeries.ext` and strong induction on `n`, using `coeff_mul`) avoids +-the ring issue and is the recommended next step. +--/ + + end HasseWeil +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupAssoc.lean b/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupAssoc.lean +index b2a59710e..f835d413b 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupAssoc.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupAssoc.lean +@@ -122,7 +122,7 @@ theorem formalGroupLaw_coeff_right_unit (n : ℕ) : + -- d 0 = n, d 1 = 0, so the definition enters the "j = 0" branch + -- and returns "if i = 1 then 1 else 0" = "if n = 1 then 1 else 0". + simp only [formalGroupLaw_coeff] +- simp only [Finsupp.single_apply, if_true, if_false, show (0 : Fin 2) ≠ 1 from by decide] ++ simp only [Finsupp.single_apply, ite_true, ite_false, show (0 : Fin 2) ≠ 1 from by decide] + split_ifs <;> simp_all + + /-- `F(0, Y) = Y`: coefficient `F_{0,n} = [n=1]`. -/ +@@ -130,7 +130,7 @@ theorem formalGroupLaw_coeff_left_unit (n : ℕ) : + formalGroupLaw_coeff W (Finsupp.single 1 n) = + if n = 1 then 1 else 0 := by + simp only [formalGroupLaw_coeff] +- simp only [Finsupp.single_apply, if_true, if_false, show (1 : Fin 2) ≠ 0 from by decide] ++ simp only [Finsupp.single_apply, ite_true, ite_false, show (1 : Fin 2) ≠ 0 from by decide] + + /-! ### The ring homomorphism property of the pullback coefficient (Silverman III.5.6) -/ + +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupCorrespondence.lean b/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupCorrespondence.lean +index c3196d467..960671107 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupCorrespondence.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupCorrespondence.lean +@@ -5,41 +5,6 @@ import Mathlib.RingTheory.Kaehler.Basic + import Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition + import Mathlib.LinearAlgebra.Basis.VectorSpace + +-/-! +-# Formal Group ↔ Curve Correspondence (Silverman IV.1–2, IV.4) +- +-This file establishes the connection between the formal group of an elliptic curve +-and the curve's group law. The key results: +- +-1. **Local parameter**: z = -x/y is a local uniformizer at O (Silverman IV.1). +-2. **w(z)**: The power series solving w = f(z,w) (already in FormalGroup.lean). +-3. **Formal group law**: z(P+Q) = F(z(P), z(Q)) where F is the formal group law. +-4. **Pullback coefficient**: For [m], the formal group series has linear coefficient m. +- +-## The Key Connection (Silverman IV.4) +- +-For an endomorphism φ of E, the pullback coefficient a_φ is defined by: +- φ*ω = a_φ · ω +-where ω = dx/(2y+a₁x+a₃) is the invariant differential. +- +-Equivalently (via the formal group): φ induces a power series φ_F(T) = a_φ T + O(T²), +-and a_φ is the linear coefficient. +- +-The map φ ↦ a_φ is a ring homomorphism End(E) → K̄ (Silverman Cor. III.5.6). +- +-## Kähler Module is 1-Dimensional (Silverman III.1.5) +- +-For an elliptic curve E/K (genus 1), the space Ω_{K(E)/K} of differentials is +-1-dimensional over K(E). This means every differential η can be written as c·ω +-for a unique c ∈ K(E). +- +-This follows from the Riemann-Roch theorem (genus = dim Ω) applied to the +-function field K(E) of transcendence degree 1 over K. +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, III.1.5, III.5, IV.1–4 +--/ + + open WeierstrassCurve + +@@ -286,13 +251,12 @@ private lemma span_invariantDifferential_eq_top : + (Set.singleton_subset_iff.mpr (D_coordXFF_mem_span_invariantDifferential E)) + (D_mem_derivSpanX E f) + +--- The Kähler differential module Ω[K(E)/F] is generated by dx/(2y+a₁x+a₃) +--- as a K(E)-module. Every element η ∈ Ω is of the form c · ω for some c ∈ K(E). ++ + -- This follows from E having genus 1: by Riemann-Roch, dim_K(E) Ω = g = 1. + -- Reference: Silverman III.1.5, Prop. II.4.2(a). + theorem kaehler_rank_one : + Module.finrank E.FunctionField (KaehlerDifferential F E.FunctionField) = 1 := by +- haveI : Module.Free E.FunctionField (KaehlerDifferential F E.FunctionField) := ++ have : Module.Free E.FunctionField (KaehlerDifferential F E.FunctionField) := + Module.Free.of_divisionRing _ _ + rw [finrank_eq_one_iff'] + refine ⟨invariantDifferential E, invariantDifferential_ne_zero E, fun w ↦ ?_⟩ +@@ -309,6 +273,7 @@ section MulByMFormal + + variable (W : WeierstrassCurve F) [W.toAffine.IsElliptic] + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The formal group power series [m]_F(T) = m·T + O(T²) for the multiplication + by m map. The linear coefficient is m. + +@@ -321,6 +286,7 @@ theorem formalMulByInt_linear_coeff (m : ℤ) : + formalMulByInt_coeff W.toAffine m 1 = (m : F) := by + simp only [formalMulByInt_coeff, one_ne_zero, ↓reduceIte] + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The multiplication-by-m on the formal group starts with 0 (no constant term). -/ + theorem formalMulByInt_const_zero (m : ℤ) : + formalMulByInt_coeff W.toAffine m 0 = 0 := by +@@ -352,6 +318,7 @@ section Correspondence + + variable (W : WeierstrassCurve F) [W.toAffine.IsElliptic] + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The formal group ↔ curve correspondence for the pullback coefficient. + + For the multiplication-by-m endomorphism [m]: +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupLawSpec.lean b/projects/HasseWeil/HasseWeil/FormalGroup/FormalGroupLawSpec.lean +index b652da19cfba4c065baf926dcd4db03ff6447aa1..e63da5ebe93847d80c49394dc1eddf0cefbfaea9 100644 +GIT binary patch +delta 1896 +zcmZ3rm~~wz>x9pnrMNmcxJy#wQw!sZGSf3kHZK=i$;br}$Vp8rnXVwkD6%?M78D +zyZLJAV|FC5&3kLb7*X`>t(DpQrEVItG_to6lTbW1d3KYPEOIi;KvDn+{bx-xIX5Tu +zm9nB3erK`=lI4>%r({bZTVsrB%aSRT_DIr*L<HQ3;uQ@uDKK?#bUTYNPPgFFBy5my}{uPj0Tbv>cY?puvy=R{_dPoAs~# +zvEI%n!YFTmWbt+*7seY*(4-30hX`PhzU@-(jK)kl#6|%~%k&IS#%s33>cEIJun{R< +zjJ}i^vHiLiBR``b+0KBv3z2rf?uzwgltPY~>1IBRfwZs$DUzmN_hAgBg&oKq* simp [h0, h1] +- rw [if_neg this, smul_zero])] ++ rw [ite_eq_right this, smul_zero])] + -- Eval at d = Finsupp.single 1 1: d 0 = 0, d 1 = 1. + have hd01 : (Finsupp.single (1 : Fin 2) 1) 0 = 0 := by simp + have hd11 : (Finsupp.single (1 : Fin 2) 1) 1 = 1 := by simp +- rw [hd01, hd11, if_pos ⟨rfl, rfl⟩] ++ rw [hd01, hd11, ite_eq_left ⟨rfl, rfl⟩] + -- coeff (Finsupp.single 1 1) F.toSeries = 1 by the right-unit axiom. + rw [HasseWeil.FG.FormalGroup.coeff_01, one_smul] + +@@ -460,7 +423,7 @@ private theorem support_finite_coeff_smul_indicator + apply hne + ext i + fin_cases i <;> simp [h0, h1] +- rw [if_neg this, smul_zero] ++ rw [ite_eq_right this, smul_zero] + + /-- The map `d ↦ coeff d F • coeff k (X^(d 0) * g^(d 1))` has finite support; + this is the support of the `![X, g]`-substitution coefficient finsum, finite by +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/Logarithm.lean b/projects/HasseWeil/HasseWeil/FormalGroup/Logarithm.lean +index 401695b65..199e735cd 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/Logarithm.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/Logarithm.lean +@@ -6,33 +6,6 @@ Authors: Chris Birkbeck + import HasseWeil.FormalGroup.InvariantDiff + import Mathlib.Algebra.Module.Rat + +-/-! +-# The formal logarithm of a formal group (Silverman IV.5) +- +-For a formal group `F` over a `ℚ`-algebra `R` (or more generally a ring with a +-`Module ℚ R` structure), the **formal logarithm** +- +-`log_F(T) := ∫₀^T ω_F(s) ds = T + (c₁/2) T² + (c₂/3) T³ + ⋯` +- +-is the integral of the normalized invariant differential +-`ω_F(T) = 1 + c₁T + c₂T² + ⋯`. It is a power series with +-constant term `0` and linear coefficient `1`. +- +-## Main definition +- +-* `HasseWeil.FormalGroup.FormalGroup.log F` — the formal logarithm of `F`, +- defined over any commutative ring `R` equipped with a `ℚ`-module structure. +- +-## Main results +- +-* `FormalGroup.log_coeff_zero` — `constantCoeff (log F) = 0`. +-* `FormalGroup.log_coeff_succ` — `coeff (n + 1) (log F) = (1/(n+1)) • coeff n ω_F`. +-* `FormalGroup.log_coeff_one` — `coeff 1 (log F) = 1`. +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], IV.5. +--/ + + set_option linter.dupNamespace false + +@@ -40,16 +13,7 @@ namespace HasseWeil.FormalGroup + + variable {R : Type*} [CommRing R] + +-/-- The **formal logarithm** of a formal group `F` over a ring `R` with a +-`Module ℚ R` structure. +- +-Concretely, if `ω_F(T) = 1 + c₁T + c₂T² + ⋯`, then +-`log_F(T) = T + (c₁/2)T² + (c₂/3)T³ + ⋯ = ∑ (c_{n-1}/n)·T^n`. + +-The coefficient at `T^n` for `n ≥ 1` is the ℚ-scalar multiple +-`((n : ℚ)⁻¹) • (coeff of ω_F at n - 1)`. +- +-Reference: Silverman, *The Arithmetic of Elliptic Curves*, IV.5. -/ + noncomputable def FormalGroup.log (F : FormalGroup R) [Module ℚ R] : + PowerSeries R := + PowerSeries.mk fun n ↦ +@@ -91,24 +55,6 @@ theorem FormalGroup.log_coeff_one (F : FormalGroup R) [Module ℚ R] : + rw [PowerSeries.coeff_zero_eq_constantCoeff_apply] + exact F.normalizedDifferential_isNormalized + +-/-! ### The formal exponential +- +-We construct `exp_F` as the compositional inverse of `log_F` via an iterative +-truncation argument. +- +-Let `f : PowerSeries R` with `coeff 0 f = 0` and `coeff 1 f = 1` +-(e.g., `f = log_F`). We build the compositional inverse `g` incrementally: +- +-* `compInvTrunc f 0 = 0`. +-* `compInvTrunc f (n+1) = compInvTrunc f n + c · T^(n+1)` where the correction +- `c` is chosen so that `coeff (n+1) (f ∘ compInvTrunc f (n+1)) = [n+1 = 1]` +- (Kronecker delta). Since `f = T + O(T²)`, this determines `c` uniquely: +- `c = δ_{1, n+1} - coeff (n+1) (f(compInvTrunc f n))`. +- +-By induction, `compInvTrunc f n` has the correct coefficients up to degree `n`, +-and adding a `T^(n+1)` correction doesn't change any lower coefficient. +-The compositional inverse is recovered by taking the `n`-th coefficient of +-`compInvTrunc f n`. -/ + + /-- Iterative truncation of the compositional inverse of `f`. + At each step we add a correction of the form `c · T^(n+1)` chosen to zero out +@@ -205,7 +151,7 @@ theorem compInverse_coeff_one (f : PowerSeries R) : + else -PowerSeries.coeff (0 + 1) + (PowerSeries.subst (compInvTrunc f 0) f)) * + PowerSeries.X ^ (0 + 1)) = 1 +- rw [compInvTrunc_zero, if_pos rfl, coeff_one_subst_zero, sub_zero, zero_add] ++ rw [compInvTrunc_zero, ite_eq_left rfl, coeff_one_subst_zero, sub_zero, zero_add] + -- Goal: coeff 1 (C 1 * X^1) = 1. + simp + +@@ -248,7 +194,7 @@ theorem coeff_compInvTrunc_succ_of_le (f : PowerSeries R) (n k : ℕ) (hk : k + PowerSeries.C _ * PowerSeries.X ^ (n + 1)) = _ + rw [map_add, PowerSeries.coeff_C_mul_X_pow] + -- `k ≠ n + 1` since `k ≤ n`. +- rw [if_neg (by omega : k ≠ n + 1), add_zero] ++ rw [ite_eq_right (by omega : k ≠ n + 1), add_zero] + + open PowerSeries in + /-- For `k ≤ n`, the `k`-th coefficient of `compInvTrunc f n` equals the +@@ -383,7 +329,7 @@ theorem coeff_monomial_pow_high (n : ℕ) (c : R) (i : ℕ) (hi : 2 ≤ i) : + PowerSeries.coeff (n + 1) ((PowerSeries.C c * PowerSeries.X ^ (n + 1)) ^ i) = 0 := by + rw [monomial_pow_eq] + rw [PowerSeries.coeff_C_mul_X_pow] +- rw [if_neg] ++ rw [ite_eq_right] + intro heq + -- n + 1 = i * (n + 1) with i ≥ 2 contradicts n + 1 ≥ 1. + nlinarith +@@ -460,7 +406,7 @@ private theorem coeff_add_monomial_pow_eq_zero (g : PowerSeries R) (n : ℕ) (c + PowerSeries.coeff (n + 1) (g ^ 0) + (if (0 : ℕ) = 1 then c else 0) := by + rw [coeff_add_monomial_pow_eq_sum, Finset.sum_range_one] + simp only [Nat.choose_self, Nat.cast_one, one_mul, pow_zero, Nat.sub_self, mul_one] +- rw [if_neg (by decide : (0 : ℕ) ≠ 1), add_zero] ++ rw [ite_eq_right (by decide : (0 : ℕ) ≠ 1), add_zero] + + open PowerSeries in + /-- The `d = 1` case of `coeff_add_monomial_pow_eq`: the expansion has two terms, +@@ -478,11 +424,11 @@ private theorem coeff_add_monomial_pow_eq_one (g : PowerSeries R) (n : ℕ) (c : + rw [show (h ^ 0 : PowerSeries R) = 1 from pow_zero _] + rw [show (h ^ 1 : PowerSeries R) = h from pow_one _] + rw [show (g ^ 0 : PowerSeries R) = 1 from pow_zero _] +- rw [if_pos rfl] ++ rw [ite_eq_left rfl] + simp only [Nat.cast_one, one_mul, mul_one] + -- Goal: coeff (n+1) g + coeff (n+1) h = coeff (n+1) g + c + rw [show PowerSeries.coeff (n + 1) h = c from by +- rw [hdef, PowerSeries.coeff_C_mul_X_pow, if_pos rfl]] ++ rw [hdef, PowerSeries.coeff_C_mul_X_pow, ite_eq_left rfl]] + + open PowerSeries in + /-- The `d + 2` case of `coeff_add_monomial_pow_eq`: split the binomial sum into +@@ -517,7 +463,7 @@ private theorem coeff_add_monomial_pow_eq_succ_succ (g : PowerSeries R) + rw [Finset.sum_eq_zero (fun m hm ↦ by + simp only [Finset.mem_filter, Finset.mem_range] at hm + rw [coeff_monomial_pow_mul_eq_zero g n c hm.2 (d + 2 - m), mul_zero]), add_zero] +- rw [if_neg (by omega : d + 2 ≠ 1), add_zero] ++ rw [ite_eq_right (by omega : d + 2 ≠ 1), add_zero] + -- The m = 1 term vanishes since g has zero constant coefficient. + rw [coeff_monomial_mul_pow_succ_eq_zero g hg n c d, mul_zero, add_zero] + +@@ -577,8 +523,8 @@ theorem coeff_subst_add_monomial (f g : PowerSeries R) (n : ℕ) (c : R) + congr 1 + rw [finsum_eq_single _ 1 (by + intro d hd +- rw [if_neg hd, smul_zero])] +- rw [if_pos rfl, smul_eq_mul, mul_comm] ++ rw [ite_eq_right hd, smul_zero])] ++ rw [ite_eq_left rfl, smul_eq_mul, mul_comm] + + /-! ### The core invariant and the compositional-inverse identity -/ + +@@ -881,15 +827,7 @@ theorem compInverseOfUnit_coeff_one (f : PowerSeries R) (u : R) (hu : IsUnit u) + -- Goal: v ^ 1 * coeff 1 (compInverse (v • f)) = v. + rw [pow_one, compInverse_coeff_one, mul_one] + +-/-- The **formal exponential** of a formal group `F` over a ring with a +-`ℚ`-module structure. +- +-Defined as the compositional inverse of `log_F`, via `compInverse`. +-The full inverse identity `log_F ∘ exp_F = X` (Silverman IV.5.2) is future +-work — this file only establishes the definition and basic coefficient +-properties. + +-Reference: Silverman, *The Arithmetic of Elliptic Curves*, IV.5. -/ + noncomputable def FormalGroup.exp (F : FormalGroup R) [Module ℚ R] : + PowerSeries R := + compInverse F.log +@@ -936,14 +874,7 @@ theorem FormalGroup.commutative_of_torsion_free (F : FormalGroup R) + F.toSeries = F.toSeries := + F.commutative + +-/-- **Silverman IV.5.4 (coefficient identity)**: for `n ≥ 1`, +-`n • log_F.coeff n = ω_F.coeff (n - 1)`. + +-This is the `ℚ`-module-level identity that, after multiplying by `(n : ℚ)⁻¹`, +-recovers the explicit formula `log_F.coeff n = (n : ℚ)⁻¹ • ω_F.coeff (n-1)` +-(which is the content of `log_coeff_succ`). Over a torsion-free `ℤ`-algebra +-it shows `n · log_F.coeff n` lies in the image of `ω_F`, which is the +-`ℤ[a_i]`-containment stated in Silverman. -/ + theorem FormalGroup.log_coeff_succ_nsmul (F : FormalGroup R) [Module ℚ R] (n : ℕ) : + (n + 1) • PowerSeries.coeff (n + 1) F.log = + PowerSeries.coeff n F.normalizedDifferential.toSeries := by +@@ -1064,23 +995,23 @@ private theorem FormalGroup.dX_at_zero_additiveFormalGroup [Module ℚ R] : + | 0 => + -- The LHS: (if pos then 1 else 0) + (if single 0 1 = single 1 1 then 1 else 0) + -- = 1 + 0 = 1. +- simp only [Finsupp.single_zero, add_zero, if_true] +- rw [if_neg (by ++ simp only [Finsupp.single_zero, add_zero, ite_true] ++ rw [ite_eq_right (by + intro h + have := DFunLike.congr_fun h 0 + simp [Finsupp.single_eq_same] at this)] + rw [add_zero, PowerSeries.coeff_zero_eq_constantCoeff_apply] + simp + | k + 1 => +- rw [if_neg (by ++ rw [ite_eq_right (by + intro h + have := DFunLike.congr_fun h 1 + simp [Finsupp.add_apply, Finsupp.single_eq_same] at this)] +- rw [if_neg (by ++ rw [ite_eq_right (by + intro h + have h0 := DFunLike.congr_fun h 0 + simp [Finsupp.add_apply, Finsupp.single_eq_same] at h0)] +- rw [zero_add, PowerSeries.coeff_one, if_neg (by omega : k + 1 ≠ 0)] ++ rw [zero_add, PowerSeries.coeff_one, ite_eq_right (by omega : k + 1 ≠ 0)] + + /-- For the additive formal group, the normalized differential `ω_{Ĝ_a}` is the + constant series `1`. This follows from `dX_at_zero = 1` (see +@@ -1121,8 +1052,8 @@ theorem FormalGroup.log_additiveFormalGroup [Module ℚ R] : + -- so its coefficient at `n + 1 ≥ 1` is `0`. + rw [FormalGroup.normalizedDifferential_toSeries_additiveFormalGroup] + -- Goal: ((n+2)⁻¹ : ℚ) • coeff (n+1) (1 : PowerSeries R) = coeff (n+2) X +- rw [PowerSeries.coeff_one, if_neg (by omega : n + 1 ≠ 0), smul_zero, +- PowerSeries.coeff_X, if_neg (by omega : n + 1 + 1 ≠ 1)] ++ rw [PowerSeries.coeff_one, ite_eq_right (by omega : n + 1 ≠ 0), smul_zero, ++ PowerSeries.coeff_X, ite_eq_right (by omega : n + 1 + 1 ≠ 1)] + + /-- **Silverman IV.5.2 for `Ĝ_a`**: the additive formal group's log is + the identity, and as a trivial consequence, it preserves addition. -/ +@@ -1146,15 +1077,6 @@ theorem FormalGroup.additiveFormalGroup_logPreservesAdd [Module ℚ R] : + -- Goal: (additiveFormalGroup R).toSeries = X 0 + X 1. This is rfl by definition. + rfl + +-/-! #### The general case: `LogPreservesAdd F` via Silverman IV.4.2 +- +-The proof follows Silverman IV.5: differentiate both sides of +-`log_F(F(X, Y)) = log_F(X) + log_F(Y)` with respect to `X`. The LHS derivative +-(chain rule + IV.4.2 translation invariance) equals `ω_F(X)`; the RHS +-derivative is `ω_F(X)` directly. Hence both sides have the same partial +-derivative in `X`. Combined with agreement at `X = 0` (via the right unit +-`F(0, Y) = Y` and `log_F(0) = 0`), they are equal because `Module ℚ R` +-makes `R` torsion-free. -/ + + /-- **Key derivative identity**: `pderiv' () F.log = F.invariantDiff` + (both viewed as `MvPowerSeries Unit R = PowerSeries R`). +@@ -1210,9 +1132,7 @@ private theorem pderiv_PowerSeries_subst {τ : Type*} + /-! #### Uniqueness: a two-variable series is determined by its derivative in + variable 0 and its value at `X 0 = 0`. -/ + +-/-- Auxiliary: if `h : MvPowerSeries (Fin 2) R` has zero derivative in variable +-`0` (over a `Module ℚ R`), then all coefficients with positive 0-degree vanish. +--/ ++ + private theorem coeff_zero_of_pderiv_zero_fin2 [Module ℚ R] + (h : MvPowerSeries (Fin 2) R) (hd : MvPowerSeries.pderiv' 0 h = 0) + (e : Fin 2 →₀ ℕ) (he : e 0 ≠ 0) : +@@ -1226,9 +1146,9 @@ private theorem coeff_zero_of_pderiv_zero_fin2 [Module ℚ R] + intro i + by_cases hi : i = 0 + · subst hi +- rw [Finsupp.single_apply, if_pos rfl, ha] ++ rw [Finsupp.single_apply, ite_eq_left rfl, ha] + exact Nat.succ_pos a +- · rw [Finsupp.single_apply, if_neg (Ne.symm hi)] ++ · rw [Finsupp.single_apply, ite_eq_right (Ne.symm hi)] + exact Nat.zero_le _ + have hd_sum : d + Finsupp.single (0 : Fin 2) 1 = e := by + rw [hd_def, tsub_add_cancel_of_le hle] +@@ -1520,7 +1440,7 @@ private theorem coeff_subst_zero_X1_at_single_1 (h : MvPowerSeries (Fin 2) R) (b + rw [finsum_eq_single _ (Finsupp.single (1 : Fin 2) b)] + · -- Case d = single 1 b: d.prod _ = (X 1)^b, coeff (single 1 b) ((X 1)^b) = 1. + rw [prod_eval_zero_X1_of_fst_eq_zero _ (by simp), coeff_single_1_X1_pow, +- if_pos (by simp), smul_eq_mul, mul_one] ++ ite_eq_left (by simp), smul_eq_mul, mul_one] + · -- For d ≠ single 1 b: the contribution is zero. + intro d hd + -- Two cases: d 0 ≠ 0 OR (d 0 = 0 AND d 1 ≠ b). +@@ -1535,7 +1455,7 @@ private theorem coeff_subst_zero_X1_at_single_1 (h : MvPowerSeries (Fin 2) R) (b + rw [h0]; simp + · change d 1 = (Finsupp.single (1 : Fin 2) b) 1 + rw [h1]; simp +- rw [prod_eval_zero_X1_of_fst_eq_zero _ h0, coeff_single_1_X1_pow, if_neg hd1, smul_zero] ++ rw [prod_eval_zero_X1_of_fst_eq_zero _ h0, coeff_single_1_X1_pow, ite_eq_right hd1, smul_zero] + · -- d 0 ≠ 0: d.prod = 0. + rw [prod_eval_zero_X1_of_fst_ne_zero _ h0, map_zero, smul_zero] + +@@ -1601,15 +1521,6 @@ theorem FormalGroup.logPreservesAdd (F : FormalGroup R) [Module ℚ R] : + exact eq_zero_of_pderiv_zero_and_subst_zero_X1 h + (hh ▸ pderiv_zero_LogPreservesAdd_diff F) (hh ▸ subst_zero_X1_LogPreservesAdd_diff F) + +-/-! #### Packaging `log_F` as a formal group homomorphism +- +-Assuming `LogPreservesAdd F` (i.e., the target identity of Silverman IV.5.2), +-we package `log_F` as a `FormalGroupHom F (additiveFormalGroup R)`. +- +-The construction only requires the identity of `LogPreservesAdd` plus the +-fact that `log_F` has zero constant coefficient (which is `log_coeff_zero`). +-The `preserves_add` axiom of the homomorphism is an unfolding of the +-`LogPreservesAdd` identity. -/ + + /-- Under the hypothesis `LogPreservesAdd F`, `log_F` extends to a formal + group homomorphism `F → Ĝ_a`. This is the packaging part of the +@@ -1663,11 +1574,7 @@ noncomputable def FormalGroup.additiveFormalGroup_logHom [Module ℚ R] : + (additiveFormalGroup R).logHomOfLogPreservesAdd + (FormalGroup.additiveFormalGroup_logPreservesAdd) + +-/-- **`log_F` as a `FormalGroupHom`** (Silverman IV.5.2 packaged). + +-For a formal group `F` over a `ℚ`-module `R`, `log_F : F → Ĝ_a` is a formal +-group homomorphism. The underlying series is `F.log`, and the `preserves_add` +-axiom is `F.logPreservesAdd`. -/ + noncomputable def FormalGroup.logHom (F : FormalGroup R) [Module ℚ R] : + FormalGroupHom F (additiveFormalGroup R) := + F.logHomOfLogPreservesAdd F.logPreservesAdd +diff --git a/projects/HasseWeil/HasseWeil/FormalGroup/PDeriv.lean b/projects/HasseWeil/HasseWeil/FormalGroup/PDeriv.lean +index 1cb34befc..a82fdd140 100644 +--- a/projects/HasseWeil/HasseWeil/FormalGroup/PDeriv.lean ++++ b/projects/HasseWeil/HasseWeil/FormalGroup/PDeriv.lean +@@ -9,43 +9,6 @@ import Mathlib.RingTheory.MvPowerSeries.Basic + import Mathlib.RingTheory.MvPowerSeries.PiTopology + import Mathlib.RingTheory.MvPowerSeries.Substitution + +-/-! +-# Partial derivatives of multivariate formal power series +- +-This file defines the formal partial derivative `MvPowerSeries.pderiv' s` on +-`MvPowerSeries σ R`. Mathlib provides a univariate version +-`PowerSeries.derivative` for `PowerSeries R` and a polynomial version +-`MvPolynomial.pderiv`, but there is no `pderiv'` for multivariate power series. +- +-The derivative is defined by the convention +- +- `pderiv' s f := ∑_d ((d s + 1) • coeff_{d + e_s} f) · X^d`, +- +-which matches the univariate `PowerSeries.derivativeFun` for `σ = Unit` and +-agrees with `MvPolynomial.pderiv` under the coercion +-`MvPolynomial σ R → MvPowerSeries σ R` (see `pderiv'_coe`). +- +-This is used downstream in the proof of Silverman IV.4.2 (translation +-invariance of the invariant differential on a formal group). +- +-## Main definitions and results +- +-* `MvPowerSeries.pderiv' s f` — partial derivative w.r.t. `s : σ`. +-* `MvPowerSeries.coeff_pderiv'` — the coefficient of the derivative. +-* `MvPowerSeries.pderiv_add`, `pderiv_zero`, `pderiv_smul`, `pderiv'_C`, +- `pderiv'_X_self`, `pderiv'_X_of_ne`, `pderiv_sub`, `pderiv_neg`, `pderiv'_one` +- — basic API. +-* `MvPowerSeries.pderiv_monomial` — the derivative of a monomial. +-* `MvPowerSeries.pderiv_mul` — **Leibniz rule** for the multivariate formal +- derivative. +-* `MvPowerSeries.pderiv'_coe` — agreement with `MvPolynomial.pderiv`. +-* `MvPowerSeries.continuous_pderiv` — continuity of `pderiv'` in the product +- topology. +-* `MvPowerSeries.pderiv_subst` — **substitution chain rule** for +- `MvPowerSeries.pderiv'` over a finite index type. +-* `MvPowerSeries.pderiv_subst_fin2` — specialization to `σ = Fin 2`, as used +- in Silverman IV.4.2. +--/ + + noncomputable section + +@@ -106,13 +69,13 @@ private lemma add_single_ne_zero (d : σ →₀ ℕ) (s : σ) : + theorem pderiv'_one (s : σ) : pderiv' s (1 : MvPowerSeries σ R) = 0 := by + classical + ext d +- rw [coeff_pderiv', coeff_one, if_neg (add_single_ne_zero d s), smul_zero, coeff_zero] ++ rw [coeff_pderiv', coeff_one, ite_eq_right (add_single_ne_zero d s), smul_zero, coeff_zero] + + @[simp] + theorem pderiv'_C (s : σ) (r : R) : pderiv' s (C (σ := σ) r) = 0 := by + classical + ext d +- rw [coeff_pderiv', coeff_C, if_neg (add_single_ne_zero d s), smul_zero, coeff_zero] ++ rw [coeff_pderiv', coeff_C, ite_eq_right (add_single_ne_zero d s), smul_zero, coeff_zero] + + @[simp] + theorem pderiv'_X_self (s : σ) : pderiv' s (X s : MvPowerSeries σ R) = 1 := by +@@ -122,14 +85,14 @@ theorem pderiv'_X_self (s : σ) : pderiv' s (X s : MvPowerSeries σ R) = 1 := by + by_cases hd : d = 0 + · subst hd + have h : (0 : σ →₀ ℕ) + Finsupp.single s 1 = Finsupp.single s 1 := by simp +- rw [h, if_pos rfl, if_pos rfl, Finsupp.coe_zero, Pi.zero_apply, zero_add, one_smul] ++ rw [h, ite_eq_left rfl, ite_eq_left rfl, Finsupp.coe_zero, Pi.zero_apply, zero_add, one_smul] + · have h : d + Finsupp.single s 1 ≠ Finsupp.single s 1 := by + intro heq + apply hd + have : d + Finsupp.single s 1 = 0 + Finsupp.single s 1 := by + rw [heq, zero_add] + exact add_right_cancel this +- rw [if_neg h, if_neg hd, smul_zero] ++ rw [ite_eq_right h, ite_eq_right hd, smul_zero] + + @[simp] + theorem pderiv'_X_of_ne {s t : σ} (h : s ≠ t) : +@@ -142,9 +105,9 @@ theorem pderiv'_X_of_ne {s t : σ} (h : s ≠ t) : + have hs : (d + Finsupp.single s 1 : σ →₀ ℕ) s = (Finsupp.single t (1 : ℕ)) s := by + rw [heq] + rw [Finsupp.add_apply, single_self_apply, +- Finsupp.single_apply, if_neg h.symm] at hs ++ Finsupp.single_apply, ite_eq_right h.symm] at hs + omega +- rw [if_neg h', smul_zero] ++ rw [ite_eq_right h', smul_zero] + + /-! ### Leibniz rule -/ + +@@ -161,7 +124,7 @@ private lemma smul_eq_zero_of_not_le {s : σ} {a : σ →₀ ℕ} + · subst hi + rw [single_self_apply] + exact Nat.one_le_iff_ne_zero.mpr hne +- · rw [Finsupp.single_apply, if_neg (Ne.symm hi)] ++ · rw [Finsupp.single_apply, ite_eq_right (Ne.symm hi)] + exact Nat.zero_le _ + rw [this] + simp +@@ -342,20 +305,20 @@ private lemma coeff_pderiv_monomial_single_le {s : σ} {n d : σ →₀ ℕ} {a + have hdeq : d = n - Finsupp.single s 1 := by + rw [← hd] + exact (add_tsub_cancel_right d _).symm +- rw [if_pos hd, if_pos hdeq] ++ rw [ite_eq_left hd, ite_eq_left hdeq] + -- `(d s + 1) • a = a * n s`. + have heq : d s + 1 = n s := by + have hds : (d + Finsupp.single s 1 : σ →₀ ℕ) s = n s := by rw [hd] + simp only [Finsupp.add_apply, he_s] at hds + exact hds + rw [heq, nsmul_eq_mul, mul_comm] +- · rw [if_neg hd] ++ · rw [ite_eq_right hd] + -- d + single s 1 ≠ n means d ≠ n - single s 1 (when single s 1 ≤ n). + have hd' : d ≠ n - Finsupp.single s 1 := by + intro heq + apply hd + rw [heq, tsub_add_cancel_of_le hle] +- rw [if_neg hd', smul_zero] ++ rw [ite_eq_right hd', smul_zero] + + /-- Per-coefficient identity behind `pderiv_monomial` when `¬ single s 1 ≤ n` (i.e. + `single s 1 ⊄ n`): then `n s = 0`, so the right-hand coefficient `a * n s` vanishes, and +@@ -376,7 +339,7 @@ private lemma coeff_pderiv_monomial_not_single_le {s : σ} {n d : σ →₀ ℕ} + · subst hi + rw [he_s] + exact Nat.one_le_iff_ne_zero.mpr hne +- · rw [Finsupp.single_apply, if_neg (Ne.symm hi)] ++ · rw [Finsupp.single_apply, ite_eq_right (Ne.symm hi)] + exact Nat.zero_le _ + rw [hns, Nat.cast_zero, mul_zero] + -- and `d + single s 1 = n` is impossible. +@@ -385,7 +348,7 @@ private lemma coeff_pderiv_monomial_not_single_le {s : σ} {n d : σ →₀ ℕ} + apply hle + rw [← heq] + exact le_add_self +- rw [if_neg hne, smul_zero] ++ rw [ite_eq_right hne, smul_zero] + split_ifs <;> rfl + + theorem pderiv_monomial (s : σ) (n : σ →₀ ℕ) (a : R) : +diff --git a/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback.lean b/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback.lean +index 0ec0adda3..569d1317f 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback.lean +@@ -26,9 +26,7 @@ addition formulas from mathlib. + ## References + + * Silverman, *The Arithmetic of Elliptic Curves*, III.2.3c (explicit addition +- formulas) + III.3.6 (`+` is a morphism). Round-13 D-R13-A-04 fix: III.3.6 is +- the morphism property; the explicit formula is III.2.3c (referenced inside +- III.3.6's proof at book p. 64). ++ formulas) and III.3.6 (`+` is a morphism). + * Mathlib: `WeierstrassCurve.Affine.equation_add` + -/ + +@@ -268,7 +266,7 @@ omit [DecidableEq F] [W.toAffine.IsElliptic] α in + private lemma minpoly_F_x_gen_natDegree_le_two + (α : KE) (hfin : Module.finrank (FractionRing (Polynomial F)) KE = 2) : + (minpoly (FractionRing (Polynomial F)) α).natDegree ≤ 2 := by +- haveI : FiniteDimensional (FractionRing (Polynomial F)) KE := ++ have : FiniteDimensional (FractionRing (Polynomial F)) KE := + Module.finite_of_finrank_pos (by rw [hfin]; exact (by decide : 0 < 2)) + have h_le := minpoly.natDegree_le (A := FractionRing (Polynomial F)) (B := KE) (x := α) + rw [hfin] at h_le +@@ -311,7 +309,7 @@ private lemma addPullback_x_quadratic_over_F_case_two + rw [Polynomial.aeval_eq_sum_range, h_eq_2_F] at h_aeval + simp only [Finset.sum_range_succ, Finset.sum_range_zero, zero_add, + pow_zero, pow_one, Algebra.smul_def, mul_one] at h_aeval +- rw [h_lc_2, map_one, one_mul] at h_aeval ++ rw [h_lc_2, map_one (algebraMap F KE), one_mul] at h_aeval + rw [map_neg, neg_mul, sub_neg_eq_add] + linear_combination h_aeval + +diff --git a/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/Differential.lean b/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/Differential.lean +index 35e8ea489..2925f2b5b 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/Differential.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/Differential.lean +@@ -12,27 +12,17 @@ import HasseWeil.HasseBound.QuadraticFormHoleE + /-! + # Differential pullback for the addition isogeny `1 − π` + +-Witness #1 of `hasse_bound_via_signed_QF_negFrobenius` needs the omega-pullback +-coefficient of `isogOneSub_negFrobenius W hq` to equal `1`. This file assembles the +-separability of `1 − π` from that coefficient via the cotangent (T-II-4-004) criterion, +-and computes the supporting coefficients for `mulByInt (-1)` and `negFrobeniusIsog`. ++The invariant-differential coefficient of `1 − π` is one under the corresponding ++additivity hypothesis. The cotangent criterion then gives separability. The supporting ++computations identify the coefficients of negation and negative Frobenius as `-1` and zero. + +-The omega-coefficient identity itself is reduced to a Silverman III.5.2 additivity +-hypothesis (the `id + (-1)·π` decomposition); several witness-parametric consumers below +-take that hypothesis in different shapes and produce the separability conclusion. ++The function-field extension defined by the pullback of `1 − π` is finite-dimensional: ++its x-coordinate is transcendental, hence forms a transcendence basis, and the function ++field is algebraic over the pullback range. Finite-dimensionality gives the equivalence ++between separability and a nonzero invariant-differential coefficient. + +-## Main results +- +-* `isogOneSub_negFrobenius_isSeparable_iff_omegaPullbackCoeff_ne_zero`: the T-II-4-004 +- separability criterion for `1 − π`, unconditional. +-* `omegaPullbackCoeff_mulByInt_neg_one`, `omegaPullbackCoeff_negFrobeniusIsog`: the +- supporting omega-coefficient computations. +-* `isogOneSub_negFrobenius_finiteDimensional`: Witness #2 (finite-dimensionality). +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, III.5.2 (additivity), +- III.5.3 (`[m]*ω = m·ω`), III.5.5 (Frobenius is purely inseparable). ++References: Silverman, *The Arithmetic of Elliptic Curves*, III.5.2 (additivity), ++III.5.3 (`[m]*ω = m·ω`), and III.5.5 (Frobenius is purely inseparable). + -/ + + open WeierstrassCurve +@@ -44,17 +34,8 @@ variable (W : WeierstrassCurve K) [W.toAffine.IsElliptic] + + local notation "KE" => W.toAffine.FunctionField + +-/-- **Witness-parametric Witness #1 omega-coefficient closer**: takes the +-Silverman III.5.2 additivity witness for `isogOneSub_negFrobenius` and +-produces the deliverable `omegaPullbackCoeff = 1`. +- +-The additivity hypothesis is exactly the III.5.2 specialization to the +-`1 − π = 1·id + (-1)·π` decomposition. Closing it via the witness-parametric +-bridge chain (`omegaPullbackCoeff_add_of_leading_witness`, +-`FormalIsogenySeries.lean`; the unconditional +-`omegaPullbackCoeff_add_via_bridge_of_constCoeff` was deleted 2026-06-11 as +-refutable) is the substantive piece — once that's in hand, this lemma fires +-the closure axiom-clean. -/ ++/-- The additivity identity for `1 − π = id + (-1)·π` implies that its ++invariant-differential coefficient is one (Silverman III.5.2). -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_additivity_witness + (hq : 2 ≤ Fintype.card K) + (h_add : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -64,11 +45,8 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_additivity_witness + simpa using omegaPullbackCoeff_m_plus_n_frob_of_witness W + (isogOneSub_negFrobenius W hq) 1 (-1) h_add + +-/-- **Hom decomposition for `1 − π`**: the rational-point map of +-`isogOneSub_negFrobenius W hq` equals the sum of `(Isogeny.id W.toAffine).toAddMonoidHom` +-and `(negFrobeniusIsog W).toAddMonoidHom`. (Historically the `h_add` input of the +-deleted-2026-06-11 `omegaPullbackCoeff_add_via_bridge_of_constCoeff`; retained as the +-group-law decomposition identity in its own right.) -/ ++/-- The rational-point map of `1 − π` is the sum of the identity map and negative Frobenius. ++-/ + theorem isogOneSub_negFrobenius_toAddMonoidHom_decomposition + (hq : 2 ≤ Fintype.card K) : + (isogOneSub_negFrobenius W hq).toAddMonoidHom = +@@ -81,15 +59,8 @@ theorem isogOneSub_negFrobenius_toAddMonoidHom_decomposition + rw [Isogeny.id_toAddMonoidHom, AddMonoidHom.id_apply, + negFrobeniusIsog_toAddMonoidHom_apply, sub_eq_add_neg] + +-/-- **Composed Witness #1**: separability of `isogOneSub_negFrobenius W hq`, +-taking only the additivity sum hypothesis (Silverman III.5.2 input for the +-specific `1 − π = 1·id + (-1)·π` decomposition) and the T-II-4-004 +-differential separability criterion. +- +-Hypothesis count drops from two (omega-coeff + T-II-4-004) to two of a +-sharper shape (additivity sum + T-II-4-004) — the additivity sum is the +-direct discharge target of the T-DIFFERENTIAL-PULLBACK-ADDITION-MAP +-infrastructure, removing one layer of indirection. -/ ++/-- The differential additivity identity and the nonzero-coefficient separability ++criterion imply that `1 − π` is separable. -/ + theorem isogOneSub_negFrobenius_isSeparable_of_additivity_and_T2_4_004 + (hq : 2 ≤ Fintype.card K) + (h_add : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -103,15 +74,8 @@ theorem isogOneSub_negFrobenius_isSeparable_of_additivity_and_T2_4_004 + W hq h_add) + h_sep_iff + +-/-- **Composed Witness #1 (sharper)**: separability of `isogOneSub_negFrobenius W hq`, +-taking the additivity sum, Witness #2 (FiniteDim), and the algebra-Kähler bridge +-(Subsingleton ↔ pullbackKaehler injective) as inputs. +- +-Composes Commit 13 (T-II-4-004 full iff witness-parametric) with the existing +-additivity-Witness-1 closer. Replaces the iff hypothesis with the two +-witnesses underlying it; when the bridge discharges (cotangent-sequence +-argument unblocked by Sub-piece A break-through), this becomes an +-unconditional consumer of Witness #2 only. -/ ++/-- Differential additivity, finite-dimensionality, and the cotangent criterion imply ++separability of `1 − π`. -/ + theorem isogOneSub_negFrobenius_isSeparable_of_additivity_finiteDim_bridge + (hq : 2 ≤ Fintype.card K) + (h_add : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -127,9 +91,8 @@ theorem isogOneSub_negFrobenius_isSeparable_of_additivity_finiteDim_bridge + (isSeparable_iff_omegaPullbackCoeff_ne_zero_of_witnesses W + (isogOneSub_negFrobenius W hq) h_fin h_bridge) + +-/-- **{addPullback_x_negFrobenius} is alg-indep over K (axiom-clean)**: +-the singleton family is algebraically independent over `K`, by transcendentality +-(`addPullback_x_transcendental_negFrobenius`). -/ ++/-- The singleton consisting of the x-coordinate of `1 − π` is algebraically independent ++because that coordinate is transcendental over the base field. -/ + theorem addPullback_x_negFrobenius_algebraicIndependent + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) : +@@ -139,9 +102,8 @@ theorem addPullback_x_negFrobenius_algebraicIndependent + rw [algebraicIndependent_unique_type_iff] + exact addPullback_x_transcendental_negFrobenius W hq hxy + +-/-- **{addPullback_x_negFrobenius} is a transcendence basis (axiom-clean)**: +-combines alg-independence with `trdeg K K(E) = 1` to yield the 1-element +-transcendence basis via `AlgebraicIndependent.isTranscendenceBasis_of_lift_trdeg_le_of_finite`. -/ ++/-- The x-coordinate of `1 − π` is a transcendence basis, since the function field has ++transcendence degree one. -/ + theorem addPullback_x_negFrobenius_isTranscendenceBasis + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) : +@@ -153,13 +115,8 @@ theorem addPullback_x_negFrobenius_isTranscendenceBasis + rw [weierstrass_functionField_trdeg_eq_one W] + simp + +-/-- **K(E) is algebraic over `Algebra.adjoin K {addPullback_x_negFrobenius}` +-(axiom-clean, Path (a) step 4)**: applying `IsTranscendenceBasis.isAlgebraic` +-to the trans-basis singleton gives the relative algebraicity over the +-adjoin subalgebra. +- +-@-explicit `Subalgebra.toAlgebra` to bypass typeclass-synthesis flakiness +-on the specific Weierstrass term `addPullback_x W (negFrobeniusIsog W)`. -/ ++/-- The function field is algebraic over the subalgebra generated by the x-coordinate ++of `1 − π`. -/ + theorem addPullback_x_negFrobenius_isAlgebraic_subalgebra + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) : +@@ -170,9 +127,8 @@ theorem addPullback_x_negFrobenius_isAlgebraic_subalgebra + (Subalgebra.toAlgebra _) := + (addPullback_x_negFrobenius_isTranscendenceBasis W hq hxy).isAlgebraic + +-/-- **addPullback_x is in the negFrobenius pullback's range (axiom-clean)**: +-direct identification via the `addPullbackAlgHom` construction — +-`x_gen` maps to `addPullback_x`. -/ ++/-- The x-coordinate of `1 − π` belongs to its pullback range: it is the image of `x_gen`. ++-/ + theorem addPullback_x_negFrobenius_mem_range + (hq : 2 ≤ Fintype.card K) : + addPullback_x W (negFrobeniusIsog W) ∈ +@@ -195,11 +151,8 @@ theorem addPullback_x_negFrobenius_mem_range + AdjoinRoot.lift_mk] + simp [addBaseHom, Polynomial.eval₂_C] + +-/-- **Algebraicity over α.pullback.range** (Path (a) step 5, witness-parametric): +-given `addPullback_x ∈ (isogOneSub_negFrobenius W hq).pullback.range`, +-lift the IsAlgebraic from the smaller adjoin subalgebra to α.pullback.range. +- +-Uses `IsAlgebraic.tower_top_of_subalgebra_le` element-wise. -/ ++/-- If the x-coordinate belongs to the pullback range, algebraicity over the subalgebra ++it generates implies algebraicity over that range. -/ + theorem addPullback_x_negFrobenius_isAlgebraic_range_of_witness + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) +@@ -223,8 +176,7 @@ theorem addPullback_x_negFrobenius_isAlgebraic_range_of_witness + exact ((addPullback_x_negFrobenius_isAlgebraic_subalgebra W hq hxy).isAlgebraic + y).tower_top_of_subalgebra_le h_le + +-/-- **Algebraicity over α.pullback.range (UNCONDITIONAL, axiom-clean)**: +-discharges Commit 26 by feeding Commit 27's membership witness. -/ ++/-- The function field is algebraic over the pullback range of `1 − π`. -/ + theorem addPullback_x_negFrobenius_isAlgebraic_range + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) : +@@ -236,12 +188,8 @@ theorem addPullback_x_negFrobenius_isAlgebraic_range + (addPullback_x_negFrobenius_mem_range W hq) + + set_option backward.isDefEq.respectTransparency.types false in +-/-- **Algebraicity over the type-synonym wrapper (UNCONDITIONAL, axiom-clean, +-Path (a) step 8)**: `K(E)` is algebraic over `IsogenyAlgebraSource W +-(isogOneSub_negFrobenius W hq)`. +- +-Transfers Commit 28's algebraicity-over-`α.pullback.range` to the type-synonym +-form via the bijective range iso `α.pullback : K(E) ≃ₐ[K] α.pullback.range`. -/ ++/-- Algebraicity over the pullback range transfers to the algebra-source type via the ++range isomorphism `K(E) ≃ₐ[K] α.pullback.range`. -/ + theorem isogOneSub_negFrobenius_isAlgebraic_synonym + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) : +@@ -265,41 +213,18 @@ theorem isogOneSub_negFrobenius_isAlgebraic_synonym + change α.pullback (e.symm z) = (z : W.toAffine.FunctionField) + exact congrArg Subtype.val (e.apply_symm_apply z) + +-/-- **WITNESS #2 UNCONDITIONAL (axiom-clean)**: K(E) is finite-dimensional +-over `(isogOneSub_negFrobenius W hq).pullback K(E)` (via `α.toAlgebra.toModule`). +- +-Composes: +-* Commit 18 (`isogeny_finiteDimensional_of_isAlgebraic_synonym`): the +- type-synonym Witness #2 producer. +-* Commit 19 (`isogenyAlgebraSource_essFiniteType` UNCONDITIONAL): synonym +- EssFiniteType from FractionRing localization + `EssFiniteType.of_comp`. +-* Commit 29 (`isogOneSub_negFrobenius_isAlgebraic_synonym` UNCONDITIONAL): +- synonym IsAlgebraic from trans-deg + IsTranscendenceBasis + range iso. +- +-This closes the bound's Witness #2 fully unconditional. T-II-4-004's full +-iff (Commit 17 = `isSeparable_iff_omegaPullbackCoeff_ne_zero_of_finiteDim`) +-chains to fully unconditional `α.IsSeparable ↔ ω-coeff ≠ 0` for the +-negFrobenius case. -/ ++/-- The pullback function-field extension for `1 − π` is finite-dimensional, since it ++is algebraic and essentially of finite type. -/ + theorem isogOneSub_negFrobenius_finiteDimensional + (hq : 2 ≤ Fintype.card K) : + @FiniteDimensional W.toAffine.FunctionField W.toAffine.FunctionField + _ _ (isogOneSub_negFrobenius W hq).toAlgebra.toModule := by +- haveI := isogOneSub_negFrobenius_isAlgebraic_synonym W hq ++ have := isogOneSub_negFrobenius_isAlgebraic_synonym W hq + (negFrobeniusIsog_addNonInverse W) + exact isogeny_finiteDimensional_of_isAlgebraic_synonym W (isogOneSub_negFrobenius W hq) + +-/-- **T-II-4-004 FULLY UNCONDITIONAL for negFrobenius (axiom-clean)**: +-the iff `α.IsSeparable ↔ omegaPullbackCoeff W α ≠ 0` for +-`α = isogOneSub_negFrobenius W hq` lands axiom-clean with no remaining +-hypotheses (modulo only the `hq : 2 ≤ Fintype.card K` standing on +-the bound's signature). +- +-One-line composition of Commit 17 (witness-parametric iff on FiniteDim) +-+ Commit 30 (Witness #2 UNCONDITIONAL). +- +-This closes T-II-4-004 for the bound's purpose. The bound's deferred- +-witness count drops to 2 (Witness #1 unconditional + the additivity +-discharge for general α through BRIDGE-001). -/ ++/-- The isogeny `1 − π` is separable exactly when its invariant-differential coefficient ++is nonzero. -/ + theorem isogOneSub_negFrobenius_isSeparable_iff_omegaPullbackCoeff_ne_zero + (hq : 2 ≤ Fintype.card K) : + (isogOneSub_negFrobenius W hq).IsSeparable ↔ +@@ -308,11 +233,8 @@ theorem isogOneSub_negFrobenius_isSeparable_iff_omegaPullbackCoeff_ne_zero + (isogOneSub_negFrobenius W hq) + (isogOneSub_negFrobenius_finiteDimensional W hq) + +--- `[Fintype K]` is unused in the statement but needed transitively by the proof's +--- instance resolution, so it cannot be `omit`ted. +-/-- **`alpha_star_u` for `mulByInt (-1)` equals `-u_gen` (axiom-clean)**: +-the negation isogeny pulls `u_gen = 2y + a₁x + a₃` to its negative +-(via `mulByInt_pullback_y_neg_one`). -/ ++omit [Fintype K] in ++/-- Negation pulls `u_gen = 2y + a₁x + a₃` back to `-u_gen`. -/ + theorem alpha_star_u_mulByInt_neg_one : + alpha_star_u W (mulByInt W.toAffine (-1)) = -u_gen W := by + change 2 * (mulByInt W.toAffine (-1)).pullback (y_gen W) + +@@ -324,14 +246,9 @@ theorem alpha_star_u_mulByInt_neg_one : + rw [mulByInt_pullback_y_neg_one, mulByInt_pullback_x_neg_one] + ring + +--- `[Fintype K]` is unused in the statement but needed transitively by the proof. +-/-- **omegaPullbackCoeff for `mulByInt (-1)` equals `-1` (axiom-clean)**: +-direct via `omegaPullbackCoeff_unique` + the spec equation, using +-`alpha_star_u_mulByInt_neg_one` and `mulByInt_pullback_x_neg_one`. +- +-This is independent of the Wronskian-based `omegaPullbackCoeff_mulByInt`, +-so it lands axiom-clean (`omegaPullbackCoeff_mulByInt` uses `sorryAx` via +-the Wronskian derivation). -/ ++omit [Fintype K] in ++/-- The invariant-differential coefficient of negation is `-1`, by the differential ++of the x-coordinate and the negation formula for `u_gen`. -/ + theorem omegaPullbackCoeff_mulByInt_neg_one : + omegaPullbackCoeff W (mulByInt W.toAffine (-1)) = -1 := by + apply omegaPullbackCoeff_unique +@@ -342,13 +259,8 @@ theorem omegaPullbackCoeff_mulByInt_neg_one : + rw [h_pb_x, alpha_star_u_mulByInt_neg_one, inv_neg, neg_smul, neg_one_smul] + rfl + +-/-- **omegaPullbackCoeff for `negFrobeniusIsog` = 0 (axiom-clean)**: +-`negFrobeniusIsog = mulByInt(-1) ∘ frobeniusIsog`, so by the chain rule +-`omegaPullbackCoeff_comp_of_base` (with the outer-base coefficient -1 ∈ K), +-`omega-coeff(negFrob) = (-1) * omega-coeff(frobenius) = (-1) * 0 = 0`. +- +-Avoids the Wronskian-tainted `omegaPullbackCoeff_mulByInt`; uses the +-direct `omegaPullbackCoeff_mulByInt_neg_one` (Commit 35) instead. -/ ++/-- Negative Frobenius has invariant-differential coefficient zero, by the chain rule ++for negation composed with Frobenius. -/ + theorem omegaPullbackCoeff_negFrobeniusIsog : + omegaPullbackCoeff W (negFrobeniusIsog W) = 0 := by + simp only [negFrobeniusIsog] +@@ -358,13 +270,8 @@ theorem omegaPullbackCoeff_negFrobeniusIsog : + push_cast + rfl + +-/-- **Witness #1 (witness-parametric on additivity ONLY, axiom-clean)**: +-separability of `isogOneSub_negFrobenius W hq`, taking only the additivity +-sum hypothesis. T-II-4-004 iff (Commit 31) + Witness #2 (Commit 30) absorbed. +- +-When the additivity discharge lands (per-α BRIDGE-001 instances + +-`omegaPullbackCoeff_add_of_leading_witness`, `FormalIsogenySeries.lean`), +-this fires the unconditional Witness #1 of the bound. -/ ++/-- Differential additivity gives coefficient one and hence separability of `1 − π`. ++-/ + theorem isogOneSub_negFrobenius_isSeparable_of_h_add_only + (hq : 2 ≤ Fintype.card K) + (h_add : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -374,13 +281,7 @@ theorem isogOneSub_negFrobenius_isSeparable_of_h_add_only + isogOneSub_negFrobenius_isSeparable_of_additivity_and_T2_4_004 W hq h_add + (isogOneSub_negFrobenius_isSeparable_iff_omegaPullbackCoeff_ne_zero W hq) + +-/-- **Witness #1 (taking ONLY `omegaPullbackCoeff = 1`, axiom-clean)**: +-shorter consumer of the existing chain — takes only the omega-coefficient +-identity (= 1), since T-II-4-004 iff (Commit 31) is now unconditional. +- +-When the omega-coefficient computation lands axiom-clean (via either direct +-algebraic computation or BRIDGE-001 + III.5.2), this fires the unconditional +-Witness #1 of the bound. -/ ++/-- A differential coefficient equal to one implies separability of `1 − π`. -/ + theorem isogOneSub_negFrobenius_isSeparable_of_h_coeff_only + (hq : 2 ≤ Fintype.card K) + (h_coeff : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = 1) : +@@ -388,9 +289,8 @@ theorem isogOneSub_negFrobenius_isSeparable_of_h_coeff_only + isogOneSub_negFrobenius_isSeparable_of_witnesses W hq h_coeff + (isogOneSub_negFrobenius_isSeparable_iff_omegaPullbackCoeff_ne_zero W hq) + +-/-- **Witness #3 (FiniteDim absorbed)**: sepDegree = pointCount for +-`isogOneSub_negFrobenius W hq`, taking only IsSeparable, the fiber witness, +-and Finite kernel — Witness #2 is absorbed via Commit 30 (unconditional). -/ ++/-- Separability and a fiber-cardinality witness identify the separable degree of ++`1 − π` with the rational-point count. -/ + theorem isogOneSub_negFrobenius_sepDegree_eq_pointCount_of_sep_and_fiber + [Fintype W.toAffine.Point] + (hq : 2 ≤ Fintype.card K) +@@ -423,14 +323,8 @@ theorem isogOneSub_negFrobenius_fiber_witness_of_sepDegree_eq_pointCount + (AddMonoidHom.id _) - (frobeniusIsog W).toAddMonoidHom) + h_sepDeg + +-/-- **Witness #1 via leading-coefficient bridge witness (axiom-clean)**: +-takes BRIDGE-001 for the three isogenies + leading-coefficient additivity +-of formal series, then chains via Commit 46 to derive omega-coeff(γ) = 1 +-unconditional, which closes Witness #1 via Commit 38. +- +-When the leading-coefficient additivity (`h_leading_add`) and BRIDGE-001 for +-negFrobeniusIsog and isogOneSub_negFrobenius are discharged, this becomes +-the unconditional Witness #1 of the bound. -/ ++/-- Leading-coefficient additivity and its equality with the differential coefficients ++for negative Frobenius and `1 − π` imply separability of `1 − π`. -/ + theorem isogOneSub_negFrobenius_isSeparable_via_leading_witnesses + (hq : 2 ≤ Fintype.card K) + (h_bridge_negFrob : omegaPullbackCoeff W (negFrobeniusIsog W) = +diff --git a/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/SilvermanIV14.lean b/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/SilvermanIV14.lean +index fa13c9ee6..d6729de59 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/SilvermanIV14.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/AdditionPullback/SilvermanIV14.lean +@@ -8,50 +8,20 @@ import HasseWeil.Foundation.BridgeFrobenius + import HasseWeil.Foundation.HahnSeriesAux + + /-! +-# Silverman IV.1.4 scaffold for the leading-coefficient bridge ++# Local expansions and differential pullback for `1 − π` + +-Substantive computation toward closing BRIDGE-001 / BRIDGE-003 for the +-specific case `γ = isogOneSub_negFrobenius`. The deliverable target is +-the leading-coefficient identity: ++For the addition isogeny `γ = 1 − π`, the x- and y-coordinate pullbacks have orders ++`-2` and `-3` at infinity. Thus the pullback of the parameter `t = -x/y` has order one. ++Laurent-series leading coefficients relate its linear formal-series coefficient to ++the leading coefficient of the y-coordinate. Negative Frobenius has zero linear ++coefficient, because its parameter pullback has order `q ≥ 2`. + +-``` +-PowerSeries.coeff 1 (formalIsogenySeries W (isogOneSub_negFrobenius W hq)) = 1 +-``` +- +-which equivalently says: +- +-``` +-(localExpand W (addPullbackAlgHom_negFrobenius W hq (localParam W))).coeff (1 : ℤ) = 1 +-``` +- +-where `localParam W = -x_gen / y_gen` is the local parameter at the point at +-infinity `O`. +- +-## Decomposition +- +-The substantive piece breaks into: +- +-1. **Order computation** — `ord (γ.pullback localParam) = 1` at infinity. +- Direct from `ord (addPullback_x) = -2` (`ord_addPullback_x_negFrobenius`, +- existing) and `ord (addPullback_y) = -3` (analog, this file). +-2. **Leading-coefficient computation** — extract the coefficient of `t¹` in +- the Laurent expansion. The key formula (at the formal-group leading order): +- `coeff 1 (formal γ) = 1 - (coeff q (formal id) * coeff 1 (formal frobeniusIsog))`. +- Specializes via `formalIsogenySeries_id = X` (coeff 1 = 1) and +- `formalIsogenySeries_frobenius = X^q` (coeff 1 = 0 for q ≥ 2), +- giving `coeff 1 = 1 + 0 = 1`. +- +-## Sub-helpers shipped here +- +-* `ord_addPullback_y_negFrobenius` — `ord (addPullback_y W (negFrobeniusIsog W)) = -3`. +-* `ord_localParam_pullback_negFrobenius` — `ord (γ.pullback localParam) = 1`. +-* `formalIsogenySeries_isogOneSub_negFrobenius_constantCoeff` — the +- `constantCoeff = 0` fact (genuine isogeny). +- +-## References ++Kähler differentiation of the curve and addition-slope equations proves that the ++invariant-differential coefficient of `γ` is one, and hence that `γ` is separable. ++The general addition formulas retain the hypotheses relating coordinate pullbacks, ++point maps, and formal series. + +-* Silverman, *The Arithmetic of Elliptic Curves*, IV.1.4 (formal group law +- agreement with the addition formula's local expansion). ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, IV.1.4 and III.5.2. + -/ + + open WeierstrassCurve PowerSeries LaurentSeries +@@ -63,21 +33,8 @@ variable (W : WeierstrassCurve K) [W.toAffine.IsElliptic] + + local notation "KE" => W.toAffine.FunctionField + +-/-- **Order of `-addPullback_x / addPullback_y = 1` at infinity (axiom-clean, +-witness-parametric)**: given `ord (addPullback_x) = -2` and `ord (addPullback_y) +-= -3`, the local-parameter form `-addPullback_x / addPullback_y` (which equals +-`γ.pullback (localParam W)` once the addition-pullback γ is realized as a ring +-hom) has order `1` at infinity. +- +-Substantive content of Silverman IV.1.4's leading-order claim: since +-`γ.pullback (localParam) = γ.pullback (-x_gen / y_gen) = -γ.pullback(x_gen) / +-γ.pullback(y_gen) = -addPullback_x / addPullback_y` for any ring-hom realization +-of γ, the order-1 fact reduces to the purely arithmetic +-`ord(-a / b) = ord(a) - ord(b) = -2 - (-3) = 1`. +- +-Witness-parametric: plugs the existing axiom-clean +-`ord_addPullback_x_negFrobenius` and the (currently sorry-bearing) +-`ord_addPullback_y_negFrobenius` into a closed-form ord computation. -/ ++/-- Coordinate orders `-2` and `-3` imply that `-addPullback_x / addPullback_y` has ++order one at infinity, by `ord(-a/b) = ord(a) - ord(b)`. -/ + theorem ord_neg_addPullback_x_div_y_negFrobenius + (h_x : (W_smooth W).ordAtInfty (addPullback_x W (negFrobeniusIsog W)) = + ((-2 : ℤ) : WithTop ℤ)) +@@ -99,15 +56,8 @@ theorem ord_neg_addPullback_x_div_y_negFrobenius + ((W_smooth W).ordAtInfty_neg _).trans h_x + exact ((W_smooth W).ord_div_concrete h_y_ne (-2) (-3) h_neg_x h_y).trans rfl + +-/-- **IV.1.4 step 1 unconditional**: `ord(-addPullback_x / addPullback_y) = 1` +-at infinity for the negFrobenius case (q ≥ 2, any characteristic). Combines +-the witness-parametric `ord_neg_addPullback_x_div_y_negFrobenius` with the +-two axiom-clean witnesses `ord_addPullback_x_negFrobenius` and the new +-`ord_addPullback_y_negFrobenius`. +- +-This is the substantive ord-1 conclusion of Silverman IV.1.4 step 1. The +-ord-1 fact for `γ.pullback (localParam W)` follows once the addition-pullback +-ring hom γ is realized via `addPullbackAlgHom_negFrobenius W hq`. -/ ++/-- The local parameter of `1 − π` has order one at infinity, in every characteristic. ++-/ + theorem ord_neg_addPullback_x_div_y_negFrobenius_unconditional + (hq : 2 ≤ Fintype.card K) : + (W_smooth W).ordAtInfty +@@ -119,7 +69,7 @@ theorem ord_neg_addPullback_x_div_y_negFrobenius_unconditional + (ord_addPullback_y_negFrobenius W hq) + + /-- **`(negFrob).pullback localParam = ((mulByInt(-1)).pullback localParam)^q`** +-(axiom-clean). Direct from `negFrob = mulByInt(-1) ∘ frobenius` and ++. Direct from `negFrob = mulByInt(-1) ∘ frobenius` and + `frobenius.pullback = (·)^q`. -/ + theorem negFrobeniusIsog_pullback_localParam_eq_pow : + (negFrobeniusIsog W).pullback (localParam W) = +@@ -127,7 +77,8 @@ theorem negFrobeniusIsog_pullback_localParam_eq_pow : + simp only [negFrobeniusIsog] + rw [Isogeny.comp_algebraMap_eq, frobeniusIsog_pullback_apply] + +-/-- **Closed form for `(mulByInt(-1)).pullback localParam`** (axiom-clean). ++omit [Fintype K] in ++/-- **Closed form for `(mulByInt(-1)).pullback localParam`** . + The σ-action on the local parameter `t = -x/y` evaluates to + `x_gen / (y_gen + a₁·x_gen + a₃)`. From `mulByInt_pullback_x_neg_one` + (σ fixes `x_gen`) and `mulByInt_pullback_y_neg_one` (σ sends `y_gen` to +@@ -146,10 +97,10 @@ theorem mulByInt_neg_one_pullback_localParam : + rw [neg_div_neg_eq] + + /-- **`ord((negFrobeniusIsog W).pullback (localParam W)) = q`** at infinity +-(axiom-clean). Direct from the chain rule on `localParam = -x_gen/y_gen`: ++. Direct from the chain rule on `localParam = -x_gen/y_gen`: + `(negFrob).pullback localParam = -(negFrob).pullback x_gen / (negFrob).pullback y_gen`, + combined with `ord((negFrob).pb x_gen) = -2q` and `ord((negFrob).pb y_gen) = -3q` +-(both existing axiom-clean), gives `ord = -2q - (-3q) = q`. ++, gives `ord = -2q - (-3q) = q`. + + This computes the order of the local-parameter image under `−π` directly (i.e., + without going through the addition-pullback γ). For q ≥ 2 this gives ord ≥ 2, +@@ -185,22 +136,22 @@ theorem ord_negFrobeniusIsog_pullback_localParam (hq : 2 ≤ Fintype.card K) : + ring + + omit [Fintype K] in +-/-- **`constantCoeff (formal id) = 0` (axiom-clean, scaffold extraction)**: ++/-- **`constantCoeff (formal id) = 0` **: + direct from `formalIsogenySeries_id = X`. -/ + @[simp] theorem constantCoeff_formalIsogenySeries_id : + PowerSeries.constantCoeff (formalIsogenySeries W (Isogeny.id W.toAffine)) = 0 := by + rw [formalIsogenySeries_id, PowerSeries.constantCoeff_X] + +-/-- **`constantCoeff (formal frobenius) = 0` (axiom-clean, scaffold extraction)**: ++/-- **`constantCoeff (formal frobenius) = 0` **: + direct from `formalIsogenySeries_frobenius = X^q` for `q ≥ 1`. -/ + @[simp] theorem constantCoeff_formalIsogenySeries_frobenius + (h : 1 ≤ Fintype.card K) : + PowerSeries.constantCoeff (formalIsogenySeries W (frobeniusIsog W)) = 0 := by + rw [formalIsogenySeries_frobenius, ← PowerSeries.coeff_zero_eq_constantCoeff_apply, + PowerSeries.coeff_X_pow] +- exact if_neg (by omega) ++ exact ite_eq_right (by omega) + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **Orderbound for denominator's lower terms**: the orderTop of + `HahnSeries.C a₁ * formalX + HahnSeries.C a₃` is ≥ -2 in `LaurentSeries K` + (since each term has orderTop ≥ -2). -/ +@@ -225,7 +176,7 @@ private theorem orderTop_a₁_formalX_plus_a₃_ge_neg_two : + · rw [HahnSeries.C_apply, HahnSeries.orderTop_single ha₃] + exact_mod_cast (by norm_num : (-2 : ℤ) ≤ 0) + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **orderTop of the localExpand of the denominator = -3**: in + `LaurentSeries K`, `formalY + C a₁ * formalX + C a₃` has orderTop = -3, + since `formalY` (orderTop = -3) strictly dominates the other terms +@@ -244,8 +195,9 @@ theorem orderTop_localExpand_y_gen_plus_a₁_x_gen_plus_a₃ : + refine lt_of_lt_of_le ?_ (orderTop_a₁_formalX_plus_a₃_ge_neg_two W) + exact_mod_cast (by norm_num : (-3 : ℤ) < -2) + ++omit [Fintype K] in + /-- **orderTop of `localExpand((mulByInt(-1)).pullback (localParam W)) = 1`** +-(axiom-clean). The σ-image of the local parameter has orderTop = 1 in ++. The σ-image of the local parameter has orderTop = 1 in + `LaurentSeries K`: from the closed form `σ(t) = formalX / denom` (with + `denom = formalY + C(a₁)·formalX + C(a₃)` in LaurentSeries K), and: + * `orderTop formalX = -2` +@@ -320,14 +272,8 @@ theorem coeff_one_formalIsogenySeries_negFrobeniusIsog_of_orderTop_witness + exact_mod_cast (by linarith : (1 : ℤ) < (Fintype.card K : ℤ)) + exact HahnSeries.coeff_eq_zero_of_lt_orderTop h_lt + +-/-- **`constantCoeff (formal negFrob) = 0` (axiom-clean, unconditional)** for q ≥ 1. +- +-Same orderTop argument as `coeff_one_formalIsogenySeries_negFrobeniusIsog_eq_zero`, +-but for `coeff 0` (= constantCoeff). Holds for any q ≥ 1 (since orderTop ≥ q ≥ 1 > 0). +- +-This discharges the `h_β_const` hypothesis of +-`formalIsogenySeries_add_coeff_one_via_FGL` (`FormalIsogenySeries.lean`) +-for β = negFrobeniusIsog. -/ ++/-- The formal series of negative Frobenius has zero constant coefficient: its order ++is at least `q ≥ 1`. -/ + @[simp] theorem constantCoeff_formalIsogenySeries_negFrobeniusIsog + (hq : 1 ≤ Fintype.card K) : + PowerSeries.constantCoeff (formalIsogenySeries W (negFrobeniusIsog W)) = 0 := by +@@ -349,35 +295,16 @@ for β = negFrobeniusIsog. -/ + exact_mod_cast (by linarith : (0 : ℤ) < (Fintype.card K : ℤ)) + exact HahnSeries.coeff_eq_zero_of_lt_orderTop h_lt + +-/-- **`coeff 1 (formal negFrob) = 0` (axiom-clean, unconditional)** for q ≥ 2. +- +-Discharges the orderTop witness in +-`coeff_one_formalIsogenySeries_negFrobeniusIsog_of_orderTop_witness` using +-the axiom-clean `orderTop_localExpand_mulByInt_neg_one_pullback_localParam = 1`. +- +-This is the cascade collapse: with this `coeff 1 (formal negFrob) = 0` +-in hand, the `h_negfrob` hypothesis of +-`coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_of_witnesses` +-(helper 4 from previous batch) discharges, leaving only the BRIDGE-003 +-leading-coefficient additivity to close IV.1.4 step 2 unconditionally. -/ ++/-- Negative Frobenius has zero linear formal-series coefficient, since its parameter ++pullback has order `q ≥ 2`. -/ + theorem coeff_one_formalIsogenySeries_negFrobeniusIsog_eq_zero + (hq : 2 ≤ Fintype.card K) : + PowerSeries.coeff 1 (formalIsogenySeries W (negFrobeniusIsog W)) = 0 := + coeff_one_formalIsogenySeries_negFrobeniusIsog_of_orderTop_witness W hq + (orderTop_localExpand_mulByInt_neg_one_pullback_localParam W).symm.le + +-/-- **BRIDGE-001 for `negFrobeniusIsog` (axiom-clean, UNCONDITIONAL)** for q ≥ 2. +- +-Both sides equal 0: +-* LHS: `omegaPullbackCoeff(negFrob) = 0` (axiom-clean, Differential.lean) +-* RHS: `algebraMap (coeff 1 (formal negFrob)) = algebraMap 0 = 0` (axiom-clean, +- prior commit `coeff_one_formalIsogenySeries_negFrobeniusIsog_eq_zero`). +- +-This BRIDGE-001 instance is one of the three needed by the additivity bridge +-`omegaPullbackCoeff_add_of_leading_witness` for the +-`γ = id + (-π)` case. Combined with `omegaPullbackCoeff_eq_formalIsogenyLeading_id` +-(axiom-clean, FormalIsogenySeries.lean), the only remaining BRIDGE-001 is for +-`γ = isogOneSub_negFrobenius` itself. -/ ++/-- For negative Frobenius, the differential coefficient equals the image of the linear ++formal-series coefficient: both are zero. -/ + theorem omegaPullbackCoeff_eq_formalIsogenyLeading_negFrobeniusIsog + (hq : 2 ≤ Fintype.card K) : + omegaPullbackCoeff W (negFrobeniusIsog W) = +@@ -386,21 +313,8 @@ theorem omegaPullbackCoeff_eq_formalIsogenyLeading_negFrobeniusIsog + rw [coeff_one_formalIsogenySeries_negFrobeniusIsog_eq_zero W hq, map_zero] + exact omegaPullbackCoeff_negFrobeniusIsog W + +-/-- **Leading-coefficient closure for `isogOneSub_negFrobenius` (axiom-clean, +-witness-parametric)**: from +-* the additivity decomposition `h_add : coeff 1 (formal (id + (-π))) = +- coeff 1 (formal id) + coeff 1 (formal (-π))` (Silverman IV.1.4 / formal +- group law leading-order additivity), and +-* `h_negfrob : coeff 1 (formal (-π)) = 0` (Silverman III.5.5 inseparability +- on `−π = mulByInt(-1) ∘ π`), +-combine with the existing axiom-clean `coeff_one_formalIsogenySeries_id = 1` +-to conclude `coeff 1 (formal (id + (-π))) = 1`. +- +-This is Silverman IV.1.4's substantive arithmetic content for the +-`isogOneSub_negFrobenius` case, factored as a witness consumer that +-plumbs the (still-missing) BRIDGE-003 leading-order additivity and the +-(also missing but Frobenius-flavored) `(-π)` linear-coeff vanishing into +-the closed-form `1 + 0 = 1`. -/ ++/-- Linear-coefficient additivity and vanishing for negative Frobenius give linear ++coefficient one for `1 − π`. -/ + theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_of_witnesses + (hq : 2 ≤ Fintype.card K) + (h_add : PowerSeries.coeff 1 +@@ -413,17 +327,8 @@ theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_of_witnesses + (formalIsogenySeries W (isogOneSub_negFrobenius W hq)) = 1 := by + rw [h_add, coeff_one_formalIsogenySeries_id, h_negfrob, add_zero] + +-/-- **IV.1.4 step 2: closer (axiom-clean, witness-parametric on h_add ONLY)**. +- +-With `coeff_one_formalIsogenySeries_negFrobeniusIsog_eq_zero` (axiom-clean +-unconditional from the localExpand → orderTop bridge), `h_negfrob` is +-discharged automatically. The remaining hypothesis `h_add` is the +-BRIDGE-003 leading-coefficient additivity for the specific +-`id + (-π)` decomposition. +- +-Once BRIDGE-003 is closed for this case, `coeff 1 (formal γ) = 1` ships +-unconditionally and feeds directly into the omega-pullback Witness #1 +-chain (commits 45-48). -/ ++/-- Linear-coefficient additivity implies that the formal series of `1 − π` has linear ++coefficient one. -/ + theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_of_h_add + (hq : 2 ≤ Fintype.card K) + (h_add : PowerSeries.coeff 1 +@@ -435,15 +340,8 @@ theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_of_h_add + coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_of_witnesses W hq h_add + (coeff_one_formalIsogenySeries_negFrobeniusIsog_eq_zero W hq) + +-/-- **`coeff 1 (formal isogOneSub_negFrobenius) = 1` (axiom-clean, +-witness-parametric on BRIDGE-003 for our case)**: given the BRIDGE-003 +-identity `formal γ = subst F (formal id, formal negFrob)` for our case, +-applies `coeff_one_subst_bivariate` (axiom-clean from FormalIsogenySeries.lean) +-+ the formal group law's leading coefficients + the axiom-clean constantCoeff +-witnesses to conclude. +- +-Closes IV.1.4 step 2 unconditionally up to one named witness: BRIDGE-003 for +-`id + (-π)`. -/ ++/-- If the formal series of `1 − π` is obtained by substituting those of the identity ++and negative Frobenius into the formal group law, its linear coefficient is one. -/ + theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_via_bridge_003 + (hq : 2 ≤ Fintype.card K) + (h_bridge_003 : +@@ -467,21 +365,8 @@ theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_via_bridge_003 + rw [coeff_one_formalIsogenySeries_id W, + coeff_one_formalIsogenySeries_negFrobeniusIsog_eq_zero W hq, add_zero] + +-/-- **Witness #1 omega-coefficient closer (axiom-clean, witness-parametric on +-BRIDGE-001 for γ + leading-additivity)**: takes BRIDGE-001 for the addition +-isogeny γ = `isogOneSub_negFrobenius` and the leading-coefficient additivity +-for `id + (-π)`, and produces `omegaPullbackCoeff(γ) = 1`. +- +-Composes: +-* `omegaPullbackCoeff_add_of_leading_witness` (axiom-clean, FormalIsogenySeries.lean) +-* `omegaPullbackCoeff_eq_formalIsogenyLeading_id` (axiom-clean) +-* `omegaPullbackCoeff_eq_formalIsogenyLeading_negFrobeniusIsog` (axiom-clean, +- this file) +-* `omegaPullbackCoeff_id`, `omegaPullbackCoeff_negFrobeniusIsog` +- (axiom-clean, prior commits) +- +-Result: `omegaPullbackCoeff(γ) = omegaPullbackCoeff(id) + omegaPullbackCoeff(negFrob) +-= 1 + 0 = 1`. -/ ++/-- Equality of the differential and linear formal-series coefficients for `1 − π`, ++together with linear-coefficient additivity, gives differential coefficient one. -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_bridge_and_leading + (hq : 2 ≤ Fintype.card K) + (h_bridge_γ : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -500,12 +385,8 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_bridge_and_leading + rw [h_omega_add, omegaPullbackCoeff_id W, omegaPullbackCoeff_negFrobeniusIsog W, + add_zero] + +-/-- **Witness #1 (witness-parametric on BRIDGE-001 for γ + leading-additivity, +-axiom-clean)**: separability of `isogOneSub_negFrobenius W hq`, taking only +-the BRIDGE-001 for γ + leading-coefficient additivity. T-II-4-004 absorbed. +- +-Once BRIDGE-001 for γ + the leading-additivity (= BRIDGE-003 specialization) +-land, this fires the unconditional Witness #1 of the Hasse-Weil bound. -/ ++/-- The differential/formal-series coefficient identity and linear-coefficient ++additivity imply separability of `1 − π`. -/ + theorem isogOneSub_negFrobenius_isSeparable_of_bridge_and_leading + (hq : 2 ≤ Fintype.card K) + (h_bridge_γ : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -520,17 +401,8 @@ theorem isogOneSub_negFrobenius_isSeparable_of_bridge_and_leading + (omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_bridge_and_leading W hq + h_bridge_γ h_leading_add) + +-/-- **Witness #1 closer (axiom-clean) taking BRIDGE-001 for γ + BRIDGE-003 +-for our case**: with both substantive witnesses in hand, produces +-`(isogOneSub_negFrobenius W hq).IsSeparable`. +- +-Chain: +-1. BRIDGE-003 for our case → `coeff 1 (formal γ) = 1` +- (via `coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_via_bridge_003`). +-2. Leading-additivity follows trivially: `1 = 1 + 0`. +-3. BRIDGE-001 for γ + leading-additivity → `omegaPullbackCoeff(γ) = 1` +- (via the existing `isogOneSub_negFrobenius_isSeparable_of_bridge_and_leading`). +-4. T-II-4-004 (axiom-clean) → IsSeparable. -/ ++/-- A formal group law substitution identity and equality of the differential and ++linear formal-series coefficients imply separability of `1 − π`. -/ + theorem isogOneSub_negFrobenius_isSeparable_of_bridge_001_γ_and_bridge_003 + (hq : 2 ≤ Fintype.card K) + (h_bridge_001_γ : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -557,12 +429,8 @@ theorem isogOneSub_negFrobenius_isSeparable_of_bridge_001_γ_and_bridge_003 + exact isogOneSub_negFrobenius_isSeparable_of_bridge_and_leading W hq + h_bridge_001_γ h_leading_add + +-/-- **omegaPullbackCoeff(γ) = 1 axiom-clean given BRIDGE-001 for γ + BRIDGE-003 for our case**. +-Direct consequence: derives `coeff 1 (formal γ) = 1` from BRIDGE-003 via the +-just-shipped via_bridge_003 closer, then leading-additivity follows trivially +-(both sides = 1), then the existing +-`omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_bridge_and_leading` +-fires. -/ ++/-- Formal group law substitution and the differential/formal-series coefficient ++identity give differential coefficient one for `1 − π`. -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_bridge_001_γ_and_bridge_003 + (hq : 2 ≤ Fintype.card K) + (h_bridge_001_γ : omegaPullbackCoeff W (isogOneSub_negFrobenius W hq) = +@@ -589,14 +457,15 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_bridge_001_γ_and_ + exact omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_bridge_and_leading W hq + h_bridge_001_γ h_leading_add + +-/-- **Sub-helper 1**: `localExpand(x_gen - π·x_gen) = formalX - formalX^q` +-(axiom-clean). Direct from `localExpand` ring hom + `frobeniusIsog_pullback_apply`. -/ ++/-- `localExpand(x_gen - π·x_gen) = formalX - formalX^q` ++. Direct from `localExpand` ring hom + `frobeniusIsog_pullback_apply`. -/ + theorem localExpand_x_gen_sub_frobenius_pullback_x_gen : + localExpand W (x_gen W - (frobeniusIsog W).pullback (x_gen W)) = + formalX W - (formalX W) ^ Fintype.card K := by + rw [frobeniusIsog_pullback_apply, map_sub, map_pow, localExpand_x_gen] + +-/-- **Sub-helper 2**: `(formalX - formalX^q).orderTop = -2q` for q ≥ 2. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX - formalX^q).orderTop = -2q` for q ≥ 2. + For q ≥ 2, `formalX^q` strictly dominates `formalX` (orderTop -2q < -2), + so by `orderTop_add_eq_right`, the sum's orderTop = orderTop(-formalX^q) = -2q. -/ + theorem orderTop_formalX_sub_formalX_pow (hq : 2 ≤ Fintype.card K) : +@@ -620,14 +489,15 @@ theorem orderTop_formalX_sub_formalX_pow (hq : 2 ≤ Fintype.card K) : + nlinarith + rw [HahnSeries.orderTop_add_eq_right h_lt, hX_neg_pow_orderTop] + +-/-- **Sub-helper 3**: `localExpand((x_gen - π·x_gen)²) = (formalX - formalX^q)²`. ++/-- `localExpand((x_gen - π·x_gen)²) = (formalX - formalX^q)²`. + Direct from `localExpand` ring hom + `localExpand_x_gen_sub_frobenius_pullback_x_gen`. -/ + theorem localExpand_x_gen_sub_frob_pullback_x_gen_sq : + localExpand W ((x_gen W - (frobeniusIsog W).pullback (x_gen W)) ^ 2) = + (formalX W - (formalX W) ^ Fintype.card K) ^ 2 := by + rw [map_pow, localExpand_x_gen_sub_frobenius_pullback_x_gen] + +-/-- **Sub-helper 4**: `((formalX - formalX^q)²).orderTop = -4q` for q ≥ 2. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `((formalX - formalX^q)²).orderTop = -4q` for q ≥ 2. + By `orderTop_mul` + `orderTop_formalX_sub_formalX_pow`. -/ + theorem orderTop_formalX_sub_formalX_pow_sq (hq : 2 ≤ Fintype.card K) : + ((formalX W - (formalX W) ^ Fintype.card K) ^ 2 : LaurentSeries K).orderTop = +@@ -641,7 +511,7 @@ theorem orderTop_formalX_sub_formalX_pow_sq (hq : 2 ≤ Fintype.card K) : + congr 1 + ring + +-/-- **Sub-helper 5**: `localExpand(x_gen · (π·x_gen)²) = formalX^(2q+1)`. ++/-- `localExpand(x_gen · (π·x_gen)²) = formalX^(2q+1)`. + The dominant term of `addPullbackNumerator_reduced_negFrobenius` at infinity. -/ + theorem localExpand_x_gen_mul_frob_pullback_x_gen_sq : + localExpand W (x_gen W * (frobeniusIsog W).pullback (x_gen W) ^ 2) = +@@ -649,7 +519,8 @@ theorem localExpand_x_gen_mul_frob_pullback_x_gen_sq : + rw [frobeniusIsog_pullback_apply, ← pow_mul, map_mul, map_pow, localExpand_x_gen] + ring + +-/-- **Sub-helper 6**: `(formalX^(2q+1)).orderTop = -4q - 2` for q ≥ 1. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX^(2q+1)).orderTop = -4q - 2` for q ≥ 1. + Direct from `formalX_pow_orderTop`. -/ + theorem orderTop_formalX_pow_two_q_plus_one : + ((formalX W) ^ (2 * Fintype.card K + 1) : LaurentSeries K).orderTop = +@@ -659,13 +530,14 @@ theorem orderTop_formalX_pow_two_q_plus_one : + push_cast + ring + +-/-- **Sub-helper 7**: `(formalX^(2q+1)).leadingCoeff = 1`. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX^(2q+1)).leadingCoeff = 1`. + Direct from `formalX_pow_leadingCoeff`. -/ + theorem leadingCoeff_formalX_pow_two_q_plus_one : + ((formalX W) ^ (2 * Fintype.card K + 1) : LaurentSeries K).leadingCoeff = 1 := + formalX_pow_leadingCoeff W (2 * Fintype.card K + 1) + +-/-- **Sub-helper 8**: `(localExpand(x_gen · (π·x_gen)²)).orderTop = -2 - 4q`. Composes ++/-- `(localExpand(x_gen · (π·x_gen)²)).orderTop = -2 - 4q`. Composes + the dominant-term identification with the orderTop computation. -/ + theorem orderTop_localExpand_x_gen_mul_frob_pullback_x_gen_sq : + (localExpand W (x_gen W * (frobeniusIsog W).pullback (x_gen W) ^ 2)).orderTop = +@@ -673,7 +545,7 @@ theorem orderTop_localExpand_x_gen_mul_frob_pullback_x_gen_sq : + rw [localExpand_x_gen_mul_frob_pullback_x_gen_sq W] + exact orderTop_formalX_pow_two_q_plus_one W + +-/-- **Sub-helper 9**: `(localExpand(x_gen · (π·x_gen)²)).leadingCoeff = 1`. The ++/-- `(localExpand(x_gen · (π·x_gen)²)).leadingCoeff = 1`. The + leading coefficient at infinity of the dominant term is 1 (rather than 0 or + some other value), which feeds into the leading-coefficient analysis for + `addPullback_x` and ultimately `coeff 1 (formal γ) = 1`. -/ +@@ -682,8 +554,8 @@ theorem leadingCoeff_localExpand_x_gen_mul_frob_pullback_x_gen_sq : + rw [localExpand_x_gen_mul_frob_pullback_x_gen_sq W] + exact leadingCoeff_formalX_pow_two_q_plus_one W + +-omit [Fintype K] in +-/-- **Sub-helper 10**: `(formalY^n).orderTop = -3 * n`. ++omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalY^n).orderTop = -3 * n`. + Mirror of `formalX_pow_orderTop`. -/ + theorem formalY_pow_orderTop (n : ℕ) : + ((formalY W) ^ n : LaurentSeries K).orderTop = +@@ -704,14 +576,15 @@ theorem formalY_pow_orderTop (n : ℕ) : + push_cast + ring + +-/-- **Sub-helper 11**: `localExpand(y_gen · π·y_gen) = formalY · formalY^q`. ++/-- `localExpand(y_gen · π·y_gen) = formalY · formalY^q`. + Direct from `localExpand` ring hom + `frobeniusIsog_pullback_apply`. -/ + theorem localExpand_y_gen_mul_frob_pullback_y_gen : + localExpand W (y_gen W * (frobeniusIsog W).pullback (y_gen W)) = + formalY W * (formalY W) ^ Fintype.card K := by + rw [frobeniusIsog_pullback_apply, map_mul, map_pow, localExpand_y_gen] + +-/-- **Sub-helper 12**: `(formalY · formalY^q).orderTop = -3 - 3q` for q ≥ 1. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalY · formalY^q).orderTop = -3 - 3q` for q ≥ 1. + Direct from `orderTop_mul` + `formalY_orderTop` + `formalY_pow_orderTop`. -/ + theorem orderTop_formalY_mul_formalY_pow : + (formalY W * (formalY W) ^ Fintype.card K : LaurentSeries K).orderTop = +@@ -719,7 +592,7 @@ theorem orderTop_formalY_mul_formalY_pow : + rw [HahnSeries.orderTop_mul, formalY_orderTop, formalY_pow_orderTop, ← WithTop.coe_add, + show ((-3 : ℤ) + -3 * (Fintype.card K : ℤ)) = -3 - 3 * (Fintype.card K : ℤ) from by ring] + +-/-- **Sub-helper 13**: `localExpand(x_gen² · π·x_gen) = formalX^(q+2)`. ++/-- `localExpand(x_gen² · π·x_gen) = formalX^(q+2)`. + The "term 6" of `addPullbackNumerator_reduced_negFrobenius`: `x² · π·x` with + orderTop -4 - 2q (sub-dominant). -/ + theorem localExpand_x_gen_sq_mul_frob_pullback_x_gen : +@@ -729,7 +602,8 @@ theorem localExpand_x_gen_sq_mul_frob_pullback_x_gen : + congr 1 + ring + +-/-- **Sub-helper 14**: `(formalX^(q+2)).orderTop = -4 - 2q`. -/ ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX^(q+2)).orderTop = -4 - 2q`. -/ + theorem orderTop_formalX_pow_q_plus_two : + ((formalX W) ^ (Fintype.card K + 2) : LaurentSeries K).orderTop = + (((-4 - 2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) := by +@@ -738,7 +612,7 @@ theorem orderTop_formalX_pow_q_plus_two : + push_cast + ring + +-/-- **Sub-helper 15**: `localExpand(x_gen · π·x_gen) = formalX^(q+1)`. ++/-- `localExpand(x_gen · π·x_gen) = formalX^(q+1)`. + The "x · π·x" component (used in term 8 of `addPullbackNumerator_reduced`). -/ + theorem localExpand_x_gen_mul_frob_pullback_x_gen : + localExpand W (x_gen W * (frobeniusIsog W).pullback (x_gen W)) = +@@ -746,7 +620,8 @@ theorem localExpand_x_gen_mul_frob_pullback_x_gen : + rw [frobeniusIsog_pullback_apply, map_mul, map_pow, localExpand_x_gen, + show Fintype.card K + 1 = 1 + Fintype.card K from by ring, pow_add, pow_one] + +-/-- **Sub-helper 16**: `(formalX^(q+1)).orderTop = -2 - 2q`. -/ ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX^(q+1)).orderTop = -2 - 2q`. -/ + theorem orderTop_formalX_pow_q_plus_one : + ((formalX W) ^ (Fintype.card K + 1) : LaurentSeries K).orderTop = + (((-2 - 2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) := by +@@ -755,14 +630,15 @@ theorem orderTop_formalX_pow_q_plus_one : + push_cast + ring + +-/-- **Sub-helper 17**: `localExpand(x_gen + π·x_gen) = formalX + formalX^q`. ++/-- `localExpand(x_gen + π·x_gen) = formalX + formalX^q`. + Term 1's "x + π·x" component (used in `a₄ · (x + π·x)`). -/ + theorem localExpand_x_gen_add_frob_pullback_x_gen : + localExpand W (x_gen W + (frobeniusIsog W).pullback (x_gen W)) = + formalX W + (formalX W) ^ Fintype.card K := by + rw [frobeniusIsog_pullback_apply, map_add, map_pow, localExpand_x_gen] + +-/-- **Sub-helper 18**: `(formalX + formalX^q).orderTop ≥ -2q` for q ≥ 1. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX + formalX^q).orderTop ≥ -2q` for q ≥ 1. + Via `min_orderTop_le_orderTop_add` + `formalX_orderTop` + `formalX_pow_orderTop`. -/ + theorem orderTop_formalX_add_formalX_pow_ge_neg_two_q (hq : 2 ≤ Fintype.card K) : + (((-2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -777,14 +653,15 @@ theorem orderTop_formalX_add_formalX_pow_ge_neg_two_q (hq : 2 ≤ Fintype.card K + · -- -2q ≤ orderTop formalX^q = -2q + rw [formalX_pow_orderTop] + +-/-- **Sub-helper 19**: `localExpand(y_gen + π·y_gen) = formalY + formalY^q`. ++/-- `localExpand(y_gen + π·y_gen) = formalY + formalY^q`. + Term 3's "y + π·y" component (used in `a₃ · (y + π·y)`). -/ + theorem localExpand_y_gen_add_frob_pullback_y_gen : + localExpand W (y_gen W + (frobeniusIsog W).pullback (y_gen W)) = + formalY W + (formalY W) ^ Fintype.card K := by + rw [frobeniusIsog_pullback_apply, map_add, map_pow, localExpand_y_gen] + +-/-- **Sub-helper 20**: `(formalY + formalY^q).orderTop ≥ -3q` for q ≥ 1. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalY + formalY^q).orderTop ≥ -3q` for q ≥ 1. + Via `min_orderTop_le_orderTop_add` + `formalY_orderTop` + `formalY_pow_orderTop`. -/ + theorem orderTop_formalY_add_formalY_pow_ge_neg_three_q (hq : 2 ≤ Fintype.card K) : + (((-3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -797,13 +674,14 @@ theorem orderTop_formalY_add_formalY_pow_ge_neg_three_q (hq : 2 ≤ Fintype.card + nlinarith + · rw [formalY_pow_orderTop] + +-/-- **Sub-helper 21**: `localExpand(x · π·y) = formalX · formalY^q`. -/ ++/-- `localExpand(x · π·y) = formalX · formalY^q`. -/ + theorem localExpand_x_gen_mul_frob_pullback_y_gen : + localExpand W (x_gen W * (frobeniusIsog W).pullback (y_gen W)) = + formalX W * (formalY W) ^ Fintype.card K := by + rw [frobeniusIsog_pullback_apply, map_mul, map_pow, localExpand_x_gen, localExpand_y_gen] + +-/-- **Sub-helper 22**: `(formalX · formalY^q).orderTop = -2 - 3q`. -/ ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX · formalY^q).orderTop = -2 - 3q`. -/ + theorem orderTop_formalX_mul_formalY_pow : + (formalX W * (formalY W) ^ Fintype.card K : LaurentSeries K).orderTop = + (((-2 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) := by +@@ -811,13 +689,14 @@ theorem orderTop_formalX_mul_formalY_pow : + show ((-2 : ℤ) + (-3 : ℤ) * (Fintype.card K : ℤ)) = + -2 - 3 * (Fintype.card K : ℤ) from by ring] + +-/-- **Sub-helper 23**: `localExpand(π·x · y) = formalX^q · formalY`. -/ ++/-- `localExpand(π·x · y) = formalX^q · formalY`. -/ + theorem localExpand_frob_pullback_x_gen_mul_y_gen : + localExpand W ((frobeniusIsog W).pullback (x_gen W) * y_gen W) = + (formalX W) ^ Fintype.card K * formalY W := by + rw [frobeniusIsog_pullback_apply, map_mul, map_pow, localExpand_x_gen, localExpand_y_gen] + +-/-- **Sub-helper 24**: `(formalX^q · formalY).orderTop = -3 - 2q`. -/ ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX^q · formalY).orderTop = -3 - 2q`. -/ + theorem orderTop_formalX_pow_mul_formalY : + ((formalX W) ^ Fintype.card K * formalY W : LaurentSeries K).orderTop = + (((-3 - 2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) := by +@@ -825,7 +704,8 @@ theorem orderTop_formalX_pow_mul_formalY : + show ((-2 : ℤ) * (Fintype.card K : ℤ) + (-3 : ℤ)) = + -3 - 2 * (Fintype.card K : ℤ) from by ring] + +-/-- **Sub-helper 25**: `(formalX·formalY^q + formalX^q·formalY).orderTop ≥ -2 - 3q` ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX·formalY^q + formalX^q·formalY).orderTop ≥ -2 - 3q` + for q ≥ 2. Via `min_orderTop_le_orderTop_add`, since `-2-3q ≤ min(-2-3q, -3-2q)` for q ≥ 2. -/ + theorem orderTop_formalX_mul_formalY_pow_plus_formalX_pow_mul_formalY_ge + (hq : 2 ≤ Fintype.card K) : +@@ -841,7 +721,7 @@ theorem orderTop_formalX_mul_formalY_pow_plus_formalX_pow_mul_formalY_ge + nlinarith + + omit [Fintype K] in +-/-- **Sub-helper 26**: `(HahnSeries.C c).orderTop ≥ 0` for any `c : K`. ++/-- `(HahnSeries.C c).orderTop ≥ 0` for any `c : K`. + Helper for term 2 (`2·a₆`) and similar constant-coefficient bounds. -/ + theorem orderTop_HahnSeries_C_ge_zero (c : K) : + (0 : WithTop ℤ) ≤ (HahnSeries.C c : LaurentSeries K).orderTop := by +@@ -851,8 +731,8 @@ theorem orderTop_HahnSeries_C_ge_zero (c : K) : + · rw [HahnSeries.C_apply, HahnSeries.orderTop_single hc] + rfl + +-omit [Fintype K] in +-/-- **Sub-helper 27**: `localExpand W (algebraMap K KE c) = HahnSeries.C c`. ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `localExpand W (algebraMap K KE c) = HahnSeries.C c`. + Direct from `localExpand_algebraMap` + `HahnSeries.ofPowerSeries_C`. The + constant-coefficient bridge: `algebraMap K KE` factors through `localExpand` + to give a constant Hahn series. -/ +@@ -861,8 +741,8 @@ theorem localExpand_algebraMap_eq_C (c : K) : + rw [localExpand_algebraMap] + exact HahnSeries.ofPowerSeries_C c + +-omit [Fintype K] in +-/-- **Sub-helper 28**: `(localExpand W (algebraMap K KE c * f)).orderTop ≥ ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(localExpand W (algebraMap K KE c * f)).orderTop ≥ + (localExpand W f).orderTop`. The constant factor `algebraMap K KE c` has + orderTop ≥ 0 in the local expansion (it's a constant Hahn series), so + multiplication by it does not decrease the orderTop. Bridge for terms 1, 3, 5 +@@ -877,8 +757,8 @@ theorem orderTop_localExpand_algebraMap_mul_ge (c : K) (f : KE) : + _ ≤ (HahnSeries.C c : LaurentSeries K).orderTop + (localExpand W f).orderTop := by + gcongr + +-omit [Fintype K] in +-/-- **Sub-helper 29**: `(localExpand W (2 * f)).orderTop ≥ (localExpand W f).orderTop`. ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(localExpand W (2 * f)).orderTop ≥ (localExpand W f).orderTop`. + Bridge for terms 4, 7 of `addPullbackNumerator_reduced_negFrobenius` (the `2·...` + terms). Uses `2 * f = f + f` to dodge characteristic-2 considerations. -/ + theorem orderTop_localExpand_two_mul_ge (f : KE) : +@@ -887,15 +767,14 @@ theorem orderTop_localExpand_two_mul_ge (f : KE) : + refine le_trans ?_ HahnSeries.min_orderTop_le_orderTop_add + exact le_min (le_refl _) (le_refl _) + +-omit [Fintype K] in +-/-- **Sub-helper 30**: `(localExpand W (-f)).orderTop = (localExpand W f).orderTop`. ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(localExpand W (-f)).orderTop = (localExpand W f).orderTop`. + Negation preserves orderTop. -/ + theorem orderTop_localExpand_neg (f : KE) : + (localExpand W (-f)).orderTop = (localExpand W f).orderTop := by + rw [map_neg, HahnSeries.orderTop_neg] + +-/-- **Sub-helper 31**: +-`localExpand((negFrob).pullback y_gen) = -formalY^q - C(a₁)·formalX^q - C(a₃)`. ++/-- `localExpand((negFrob).pullback y_gen) = -formalY^q - C(a₁)·formalX^q - C(a₃)`. + Direct from `negFrobeniusIsog_pullback_y_gen` + ring-hom facts. -/ + theorem localExpand_negFrobeniusIsog_pullback_y_gen : + localExpand W ((negFrobeniusIsog W).pullback (y_gen W)) = +@@ -907,7 +786,8 @@ theorem localExpand_negFrobeniusIsog_pullback_y_gen : + localExpand_y_gen, localExpand_x_gen, localExpand_algebraMap_eq_C, + localExpand_algebraMap_eq_C] + +-/-- **Sub-helper 32**: `(C(a₁)·formalX^q + C(a₃)).orderTop ≥ -2q` for q ≥ 1. -/ ++omit [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(C(a₁)·formalX^q + C(a₃)).orderTop ≥ -2q` for q ≥ 1. -/ + theorem orderTop_C_a₁_mul_formalX_pow_plus_C_a₃_ge : + (((-2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ + (HahnSeries.C W.a₁ * (formalX W) ^ Fintype.card K + +@@ -929,7 +809,7 @@ theorem orderTop_C_a₁_mul_formalX_pow_plus_C_a₃_ge : + have : (Fintype.card K : ℤ) ≥ 0 := by positivity + nlinarith + +-/-- **Sub-helper 33**: `(localExpand((negFrob).pullback y_gen)).orderTop = -3q` ++/-- `(localExpand((negFrob).pullback y_gen)).orderTop = -3q` + for q ≥ 2. The `formalY^q` term dominates strictly. -/ + theorem orderTop_localExpand_negFrobeniusIsog_pullback_y_gen + (hq : 2 ≤ Fintype.card K) : +@@ -962,8 +842,8 @@ theorem orderTop_localExpand_negFrobeniusIsog_pullback_y_gen + nlinarith + rw [HahnSeries.orderTop_add_eq_left h_lt, h_neg_y_pow] + +-omit [Fintype K] in +-/-- **Sub-helper 34**: `(C(a₃) · formalY).orderTop ≥ -3` for q ≥ 1. -/ ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(C(a₃) · formalY).orderTop ≥ -3` for q ≥ 1. -/ + theorem orderTop_C_a₃_mul_formalY_ge : + (((-3 : ℤ)) : WithTop ℤ) ≤ + (HahnSeries.C W.a₃ * formalY W : LaurentSeries K).orderTop := by +@@ -974,7 +854,8 @@ theorem orderTop_C_a₃_mul_formalY_ge : + · rw [HahnSeries.C_apply, HahnSeries.orderTop_single ha₃, + show ((0 : ℤ) : WithTop ℤ) = (0 : WithTop ℤ) from rfl, zero_add] + +-/-- **Sub-helper 35**: `(C(a₁) · (formalY · formalX^q)).orderTop ≥ -2-3q` ++omit [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(C(a₁) · (formalY · formalX^q)).orderTop ≥ -2-3q` + for q ≥ 1. -/ + theorem orderTop_C_a₁_mul_formalY_mul_formalX_pow_ge (hq : 1 ≤ Fintype.card K) : + (((-2 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -995,7 +876,7 @@ theorem orderTop_C_a₁_mul_formalY_mul_formalX_pow_ge (hq : 1 ≤ Fintype.card + have h_q : (1 : ℤ) ≤ (Fintype.card K : ℤ) := by exact_mod_cast hq + omega + +-/-- **Sub-helper 36**: `localExpand(y · negFrob.π·y) = -formalY · formalY^q - ++/-- `localExpand(y · negFrob.π·y) = -formalY · formalY^q - + C(a₁) · (formalY · formalX^q) - C(a₃) · formalY`. -/ + theorem localExpand_y_gen_mul_negFrobeniusIsog_pullback_y_gen : + localExpand W (y_gen W * (negFrobeniusIsog W).pullback (y_gen W)) = +@@ -1005,11 +886,11 @@ theorem localExpand_y_gen_mul_negFrobeniusIsog_pullback_y_gen : + rw [map_mul, localExpand_negFrobeniusIsog_pullback_y_gen, localExpand_y_gen] + ring + +-/-- **Sub-helper 37**: `(localExpand(y · negFrob.π·y)).orderTop ≥ -3-3q` for q ≥ 2. ++/-- `(localExpand(y · negFrob.π·y)).orderTop ≥ -3-3q` for q ≥ 2. + Each of the three terms has orderTop ≥ -3-3q: +-* `-formalY · formalY^q`: = -3-3q (sub-helper 12). +-* `-C(a₁) · (formalY · formalX^q)`: ≥ -2-3q ≥ -3-3q (sub-helper 35). +-* `-C(a₃) · formalY`: ≥ -3 ≥ -3-3q for q ≥ 0 (sub-helper 34). -/ ++* `-formalY · formalY^q`: = -3-3q. ++* `-C(a₁) · (formalY · formalX^q)`: ≥ -2-3q ≥ -3-3q. ++* `-C(a₃) · formalY`: ≥ -3 ≥ -3-3q for q ≥ 0. -/ + theorem orderTop_localExpand_y_gen_mul_negFrobeniusIsog_pullback_y_gen_ge + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1041,7 +922,7 @@ theorem orderTop_localExpand_y_gen_mul_negFrobeniusIsog_pullback_y_gen_ge + have h_q_nn : (0 : ℤ) ≤ (Fintype.card K : ℤ) := by positivity + linarith + +-/-- **Sub-helper 38**: `(localExpand(y_gen + (negFrob).pullback y_gen)).orderTop = -3q` ++/-- `(localExpand(y_gen + (negFrob).pullback y_gen)).orderTop = -3q` + for q ≥ 2. The `(negFrob).pullback y_gen` part dominates strictly (orderTop -3q + < -3 for q ≥ 2). -/ + theorem orderTop_localExpand_y_gen_add_negFrobeniusIsog_pullback_y_gen +@@ -1063,7 +944,7 @@ theorem orderTop_localExpand_y_gen_add_negFrobeniusIsog_pullback_y_gen + nlinarith + rw [HahnSeries.orderTop_add_eq_right h_lt, h_negFrob_y] + +-/-- **Sub-helper 39**: `(localExpand(a₃ · (y_gen + (negFrob).pullback y_gen))).orderTop ≥ -3q`. -/ ++/-- `(localExpand(a₃ · (y_gen + (negFrob).pullback y_gen))).orderTop ≥ -3q`. -/ + theorem orderTop_localExpand_a₃_mul_y_gen_add_negFrobeniusIsog_pullback_y_gen_ge + (hq : 2 ≤ Fintype.card K) : + (((-3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1072,7 +953,7 @@ theorem orderTop_localExpand_a₃_mul_y_gen_add_negFrobeniusIsog_pullback_y_gen_ + refine le_trans ?_ (orderTop_localExpand_algebraMap_mul_ge W W.a₃ _) + rw [orderTop_localExpand_y_gen_add_negFrobeniusIsog_pullback_y_gen W hq] + +-/-- **Sub-helper 40**: `(localExpand(x_gen + (negFrob).pullback x_gen)).orderTop ≥ -2q` ++/-- `(localExpand(x_gen + (negFrob).pullback x_gen)).orderTop ≥ -2q` + for q ≥ 2. Uses the fact that `(negFrob).pullback x_gen = (frob).pullback x_gen`. -/ + theorem orderTop_localExpand_x_gen_add_negFrobeniusIsog_pullback_x_gen_ge + (hq : 2 ≤ Fintype.card K) : +@@ -1082,7 +963,7 @@ theorem orderTop_localExpand_x_gen_add_negFrobeniusIsog_pullback_x_gen_ge + rw [negFrobeniusIsog_pullback_x_gen, localExpand_x_gen_add_frob_pullback_x_gen] + exact orderTop_formalX_add_formalX_pow_ge_neg_two_q W hq + +-/-- **Sub-helper 41**: `(localExpand(a₄ · (x_gen + (negFrob).pullback x_gen))).orderTop ≥ -2q`. -/ ++/-- `(localExpand(a₄ · (x_gen + (negFrob).pullback x_gen))).orderTop ≥ -2q`. -/ + theorem orderTop_localExpand_a₄_mul_x_gen_add_negFrobeniusIsog_pullback_x_gen_ge + (hq : 2 ≤ Fintype.card K) : + (((-2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1091,8 +972,8 @@ theorem orderTop_localExpand_a₄_mul_x_gen_add_negFrobeniusIsog_pullback_x_gen_ + refine le_trans ?_ (orderTop_localExpand_algebraMap_mul_ge W W.a₄ _) + exact orderTop_localExpand_x_gen_add_negFrobeniusIsog_pullback_x_gen_ge W hq + +-omit [Fintype K] in +-/-- **Sub-helper 42**: `(localExpand(2·a₆)).orderTop ≥ 0`. -/ ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(localExpand(2·a₆)).orderTop ≥ 0`. -/ + theorem orderTop_localExpand_two_mul_a₆_ge : + (0 : WithTop ℤ) ≤ + (localExpand W ((2 : W.toAffine.FunctionField) * +@@ -1101,7 +982,7 @@ theorem orderTop_localExpand_two_mul_a₆_ge : + rw [localExpand_algebraMap_eq_C] + exact orderTop_HahnSeries_C_ge_zero W.a₆ + +-/-- **Sub-helper 43**: `(localExpand(2 · y_gen · (negFrob).π·y)).orderTop ≥ -3-3q`. -/ ++/-- `(localExpand(2 · y_gen · (negFrob).π·y)).orderTop ≥ -3-3q`. -/ + theorem orderTop_localExpand_two_mul_y_gen_mul_negFrob_π_y_ge + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1114,7 +995,7 @@ theorem orderTop_localExpand_two_mul_y_gen_mul_negFrob_π_y_ge + refine le_trans ?_ (orderTop_localExpand_two_mul_ge W _) + exact orderTop_localExpand_y_gen_mul_negFrobeniusIsog_pullback_y_gen_ge W hq + +-/-- **Sub-helper 44**: `(localExpand(x_gen² · (negFrob).π·x)).orderTop = -4 - 2q`. -/ ++/-- `(localExpand(x_gen² · (negFrob).π·x)).orderTop = -4 - 2q`. -/ + theorem orderTop_localExpand_x_gen_sq_mul_negFrobeniusIsog_pullback_x_gen : + (localExpand W (x_gen W ^ 2 * + (negFrobeniusIsog W).pullback (x_gen W))).orderTop = +@@ -1122,7 +1003,7 @@ theorem orderTop_localExpand_x_gen_sq_mul_negFrobeniusIsog_pullback_x_gen : + rw [negFrobeniusIsog_pullback_x_gen, localExpand_x_gen_sq_mul_frob_pullback_x_gen] + exact orderTop_formalX_pow_q_plus_two W + +-/-- **Sub-helper 45**: `(localExpand(x_gen · ((negFrob).π·x)²)).orderTop = -2 - 4q`. ++/-- `(localExpand(x_gen · ((negFrob).π·x)²)).orderTop = -2 - 4q`. + The DOMINANT term of `addPullbackNumerator_reduced_negFrobenius`. -/ + theorem orderTop_localExpand_x_gen_mul_negFrobeniusIsog_pullback_x_gen_sq : + (localExpand W (x_gen W * +@@ -1131,7 +1012,7 @@ theorem orderTop_localExpand_x_gen_mul_negFrobeniusIsog_pullback_x_gen_sq : + rw [negFrobeniusIsog_pullback_x_gen] + exact orderTop_localExpand_x_gen_mul_frob_pullback_x_gen_sq W + +-/-- **Sub-helper 46**: `(localExpand(2 · a₂ · x_gen · (negFrob).π·x)).orderTop ≥ -2 - 2q`. -/ ++/-- `(localExpand(2 · a₂ · x_gen · (negFrob).π·x)).orderTop ≥ -2 - 2q`. -/ + theorem orderTop_localExpand_two_mul_a₂_mul_x_gen_mul_negFrob_π_x_ge : + (((-2 - 2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ + (localExpand W ((2 : W.toAffine.FunctionField) * +@@ -1149,7 +1030,7 @@ theorem orderTop_localExpand_two_mul_a₂_mul_x_gen_mul_negFrob_π_x_ge : + localExpand_x_gen_mul_frob_pullback_x_gen] + exact (orderTop_formalX_pow_q_plus_one W).symm.le + +-/-- **Sub-helper 47**: `(localExpand(x · (negFrob).π·y)).orderTop = -2 - 3q` for q ≥ 2. -/ ++/-- `(localExpand(x · (negFrob).π·y)).orderTop = -2 - 3q` for q ≥ 2. -/ + theorem orderTop_localExpand_x_gen_mul_negFrob_pullback_y_gen + (hq : 2 ≤ Fintype.card K) : + (localExpand W (x_gen W * (negFrobeniusIsog W).pullback (y_gen W))).orderTop = +@@ -1159,16 +1040,16 @@ theorem orderTop_localExpand_x_gen_mul_negFrob_pullback_y_gen + show ((-2 : ℤ) + (-3 : ℤ) * (Fintype.card K : ℤ)) = + -2 - 3 * (Fintype.card K : ℤ) from by ring] + +-/-- **Sub-helper 48**: `(localExpand((negFrob).π·x · y)).orderTop = -3 - 2q`. -/ ++/-- `(localExpand((negFrob).π·x · y)).orderTop = -3 - 2q`. -/ + theorem orderTop_localExpand_negFrob_pullback_x_gen_mul_y_gen : + (localExpand W ((negFrobeniusIsog W).pullback (x_gen W) * y_gen W)).orderTop = + (((-3 - 2 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) := by + rw [negFrobeniusIsog_pullback_x_gen, localExpand_frob_pullback_x_gen_mul_y_gen] + exact orderTop_formalX_pow_mul_formalY W + +-/-- **Sub-helper 49** (Term 5 inner): `(localExpand(x · negFrob.π·y + ++/-- Term 5 inner: `(localExpand(x · negFrob.π·y + + negFrob.π·x · y)).orderTop ≥ -3-3q` for q ≥ 2. The `min_orderTop_le_orderTop_add` +-extracts both summands. Sub-helper 47 = -2-3q ≥ -3-3q, sub-helper 48 = -3-2q ≥ -3-3q. -/ ++The summands have orders `-2-3q` and `-3-2q`, both at least `-3-3q`. -/ + theorem orderTop_localExpand_x_gen_mul_negFrob_π_y_plus_negFrob_π_x_mul_y_gen_ge + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1185,8 +1066,8 @@ theorem orderTop_localExpand_x_gen_mul_negFrob_π_y_plus_negFrob_π_x_mul_y_gen_ + refine WithTop.coe_le_coe.mpr ?_ + linarith + +-/-- **Sub-helper 50** (Term 5 outer): `(localExpand(a₁ · (x · negFrob.π·y + +-negFrob.π·x · y))).orderTop ≥ -3-3q` for q ≥ 2. Composition of sub-helpers 28 + 49. -/ ++/-- Term 5 outer: `(localExpand(a₁ · (x · negFrob.π·y + ++negFrob.π·x · y))).orderTop ≥ -3-3q` for q ≥ 2. Multiplication by a base-field constant preserves the lower order bound. -/ + theorem orderTop_localExpand_a₁_mul_x_negFrob_π_y_plus_negFrob_π_x_y_ge + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1196,8 +1077,8 @@ theorem orderTop_localExpand_a₁_mul_x_negFrob_π_y_plus_negFrob_π_x_y_ge + refine le_trans ?_ (orderTop_localExpand_algebraMap_mul_ge W W.a₁ _) + exact orderTop_localExpand_x_gen_mul_negFrob_π_y_plus_negFrob_π_x_mul_y_gen_ge W hq + +-/-- **Sub-helper 51** (Term 1 promoted): `(localExpand(a₄ · (x_gen + +-negFrob.π·x))).orderTop ≥ -3-3q` for q ≥ 1. From sub-helper 41 (≥ -2q). -/ ++/-- Term 1 promoted: `(localExpand(a₄ · (x_gen + ++negFrob.π·x))).orderTop ≥ -3-3q` for q ≥ 1. The sharper lower bound is `-2q`. -/ + theorem orderTop_localExpand_a₄_mul_x_gen_add_negFrob_π_x_promoted + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1208,7 +1089,8 @@ theorem orderTop_localExpand_a₄_mul_x_gen_add_negFrob_π_x_promoted + refine WithTop.coe_le_coe.mpr ?_ + linarith + +-/-- **Sub-helper 52** (Term 2 promoted): `(localExpand(2·a₆)).orderTop ≥ -3-3q`. -/ ++omit [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- Term 2 promoted: `(localExpand(2·a₆)).orderTop ≥ -3-3q`. -/ + theorem orderTop_localExpand_two_mul_a₆_promoted + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1219,8 +1101,8 @@ theorem orderTop_localExpand_two_mul_a₆_promoted + refine WithTop.coe_le_coe.mpr ?_ + linarith + +-/-- **Sub-helper 53** (Term 3 promoted): `(localExpand(a₃ · (y_gen + +-negFrob.π·y))).orderTop ≥ -3-3q`. From sub-helper 39 (≥ -3q). -/ ++/-- Term 3 promoted: `(localExpand(a₃ · (y_gen + ++negFrob.π·y))).orderTop ≥ -3-3q`. The sharper lower bound is `-3q`. -/ + theorem orderTop_localExpand_a₃_mul_y_gen_add_negFrob_π_y_promoted + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1231,8 +1113,8 @@ theorem orderTop_localExpand_a₃_mul_y_gen_add_negFrob_π_y_promoted + refine WithTop.coe_le_coe.mpr ?_ + linarith + +-/-- **Sub-helper 54** (Term 6 promoted): `(localExpand(x² · negFrob.π·x)).orderTop ≥ -3-3q`. +-From sub-helper 44 (= -4-2q). -/ ++/-- Term 6 promoted: `(localExpand(x² · negFrob.π·x)).orderTop ≥ -3-3q`. ++The exact order is `-4-2q`. -/ + theorem orderTop_localExpand_x_gen_sq_mul_negFrob_π_x_promoted + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1243,8 +1125,8 @@ theorem orderTop_localExpand_x_gen_sq_mul_negFrob_π_x_promoted + refine WithTop.coe_le_coe.mpr ?_ + linarith + +-/-- **Sub-helper 55** (Term 8 promoted): `(localExpand(2·a₂·x·negFrob.π·x)).orderTop ≥ -3-3q`. +-From sub-helper 46 (≥ -2-2q). -/ ++/-- Term 8 promoted: `(localExpand(2·a₂·x·negFrob.π·x)).orderTop ≥ -3-3q`. ++The sharper lower bound is `-2-2q`. -/ + theorem orderTop_localExpand_two_a₂_x_negFrob_π_x_promoted + (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1257,14 +1139,14 @@ theorem orderTop_localExpand_two_a₂_x_negFrob_π_x_promoted + linarith + + omit [Fintype K] [DecidableEq K] in +-/-- **Sub-helper 56**: `add_ge_of_both_ge` — addition preserves orderTop bounds. -/ ++/-- `add_ge_of_both_ge` — addition preserves orderTop bounds. -/ + theorem orderTop_add_ge_of_both_ge {a b : LaurentSeries K} {n : WithTop ℤ} + (ha : n ≤ a.orderTop) (hb : n ≤ b.orderTop) : + n ≤ (a + b).orderTop := + le_trans (le_min ha hb) HahnSeries.min_orderTop_le_orderTop_add + + omit [Fintype K] [DecidableEq K] in +-/-- **Sub-helper 57**: `sub_ge_of_both_ge` — subtraction preserves orderTop bounds. ++/-- `sub_ge_of_both_ge` — subtraction preserves orderTop bounds. + Uses `HahnSeries.orderTop_neg` to convert `b` ↔ `-b`. -/ + theorem orderTop_sub_ge_of_both_ge {a b : LaurentSeries K} {n : WithTop ℤ} + (ha : n ≤ a.orderTop) (hb : n ≤ b.orderTop) : +@@ -1274,7 +1156,7 @@ theorem orderTop_sub_ge_of_both_ge {a b : LaurentSeries K} {n : WithTop ℤ} + rw [HahnSeries.orderTop_neg] + exact hb + +-/-- **Sub-helper 58** (Cumulative sum): `(localExpand(rest)).orderTop ≥ -3-3q`, ++/-- Cumulative sum: `(localExpand(rest)).orderTop ≥ -3-3q`, + where `rest` is `addPullbackNumerator_reduced_negFrobenius` minus the dominant + term `x · (negFrob.π·x)²`. Sequential `add/sub_ge_of_both_ge` chain over + the 7 sub-dominant term bounds. -/ +@@ -1339,7 +1221,7 @@ private theorem addPullbackNumerator_reduced_negFrobenius_split_eq : + + /-- The dominant term `localExpand(x_gen · (negFrob.π·x)²)` has strictly smaller + `orderTop` than the `rest` (for `q ≥ 2`): `-2-4q < -3-3q`. Combines the dominant +-order (sub-helper 45) with the `rest ≥ -3-3q` bound (sub-helper 58). -/ ++order with the `rest ≥ -3-3q` bound. -/ + private theorem orderTop_localExpand_dominant_lt_rest_negFrobenius + (hq : 2 ≤ Fintype.card K) : + (localExpand W (x_gen W * +@@ -1374,8 +1256,8 @@ private theorem orderTop_localExpand_dominant_lt_rest_negFrobenius + for q ≥ 2. + + Algebraic decomposition: the full expression is `rest + dominant`, where +-* `dominant = x_gen · (negFrob.π·x)²` has orderTop = -2-4q (sub-helper 45) +-* `rest` (the other 7 terms) has orderTop ≥ -3-3q (sub-helper 58) ++* `dominant = x_gen · (negFrob.π·x)²` has orderTop = -2-4q ++* `rest` (the other 7 terms) has orderTop ≥ -3-3q + + For q ≥ 2: -2-4q < -3-3q, so `orderTop_add_eq_right` extracts the dominant + orderTop. -/ +@@ -1442,7 +1324,7 @@ private lemma orderTop_localExpand_dominant_lt_rest (hq : 2 ≤ Fintype.card K) + /-- **Leading coefficient companion**: + `(localExpand(addPullbackNumerator_reduced_negFrobenius)).leadingCoeff = 1` + for q ≥ 2. The leading coefficient of the dominant term `x_gen · (negFrob.π·x)²` +-is 1 (sub-helper 9 / `leadingCoeff_localExpand_x_gen_mul_frob_pullback_x_gen_sq`), ++is 1 by `leadingCoeff_localExpand_x_gen_mul_frob_pullback_x_gen_sq`, + which propagates through the strict-non-arch via `leadingCoeff_add_eq_right`. -/ + theorem leadingCoeff_localExpand_addPullbackNumerator_reduced_negFrobenius_eq + (hq : 2 ≤ Fintype.card K) : +@@ -1454,7 +1336,8 @@ theorem leadingCoeff_localExpand_addPullbackNumerator_reduced_negFrobenius_eq + negFrobeniusIsog_pullback_x_gen] + exact leadingCoeff_localExpand_x_gen_mul_frob_pullback_x_gen_sq W + +-/-- **Sub-helper 61**: `(formalX - formalX^q).leadingCoeff = -1` for q ≥ 2. ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- `(formalX - formalX^q).leadingCoeff = -1` for q ≥ 2. + The dominant term `-formalX^q` (orderTop -2q < -2) determines the leading + coefficient via `leadingCoeff_add_eq_right`. -/ + theorem leadingCoeff_formalX_sub_formalX_pow (hq : 2 ≤ Fintype.card K) : +@@ -1469,16 +1352,16 @@ theorem leadingCoeff_formalX_sub_formalX_pow (hq : 2 ≤ Fintype.card K) : + rw [HahnSeries.leadingCoeff_add_eq_right h_lt, HahnSeries.leadingCoeff_neg, + formalX_pow_leadingCoeff] + +-/-- **Sub-helper 62**: `((formalX - formalX^q)²).leadingCoeff = 1` for q ≥ 2. +-Direct from `HahnSeries.leadingCoeff_mul` (squared) and sub-helper 61 +-(`(-1)² = 1`). -/ ++omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- Squaring `formalX - formalX^q`, whose leading coefficient is `-1`, gives leading ++coefficient one. -/ + theorem leadingCoeff_formalX_sub_formalX_pow_sq (hq : 2 ≤ Fintype.card K) : + ((formalX W - (formalX W) ^ Fintype.card K) ^ 2 : LaurentSeries K).leadingCoeff = 1 := by + rw [sq, HahnSeries.leadingCoeff_mul, leadingCoeff_formalX_sub_formalX_pow W hq] + ring + +-/-- **Sub-helper 63**: `(localExpand((x_gen - negFrob.π·x)²)).orderTop = -4q` for q ≥ 2. +-Bridges via `negFrobeniusIsog_pullback_x_gen` to the frobenius-side sub-helper 4. -/ ++/-- `(localExpand((x_gen - negFrob.π·x)²)).orderTop = -4q` for q ≥ 2. ++Negative Frobenius has the same x-coordinate pullback as Frobenius. -/ + theorem orderTop_localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq + (hq : 2 ≤ Fintype.card K) : + (localExpand W ((x_gen W - +@@ -1487,7 +1370,7 @@ theorem orderTop_localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq + rw [negFrobeniusIsog_pullback_x_gen, localExpand_x_gen_sub_frob_pullback_x_gen_sq] + exact orderTop_formalX_sub_formalX_pow_sq W hq + +-/-- **Sub-helper 64**: `(localExpand((x_gen - negFrob.π·x)²)).leadingCoeff = 1` for q ≥ 2. -/ ++/-- `(localExpand((x_gen - negFrob.π·x)²)).leadingCoeff = 1` for q ≥ 2. -/ + theorem leadingCoeff_localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq + (hq : 2 ≤ Fintype.card K) : + (localExpand W ((x_gen W - +@@ -1495,7 +1378,7 @@ theorem leadingCoeff_localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq + rw [negFrobeniusIsog_pullback_x_gen, localExpand_x_gen_sub_frob_pullback_x_gen_sq] + exact leadingCoeff_formalX_sub_formalX_pow_sq W hq + +-/-- **Sub-helper 65**: `(localExpand((x_gen - negFrob.π·x)²)) ≠ 0` for q ≥ 2. ++/-- `(localExpand((x_gen - negFrob.π·x)²)) ≠ 0` for q ≥ 2. + Direct from orderTop being a finite value. -/ + theorem localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq_ne_zero + (hq : 2 ≤ Fintype.card K) : +@@ -1508,7 +1391,7 @@ theorem localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq_ne_zero + rw [orderTop_localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq W hq] at h_top + exact WithTop.coe_ne_top h_top + +-/-- **Sub-helper 65b**: `(x_gen - negFrob.π·x) ≠ 0` in K(E). Derived from the ++/-- `(x_gen - negFrob.π·x) ≠ 0` in K(E). Derived from the + LaurentSeries-side fact `(formalX - formalX^q).orderTop = -2q ≠ ⊤`. -/ + private theorem x_gen_sub_negFrob_pullback_x_gen_ne_zero_local + (hq : 2 ≤ Fintype.card K) : +@@ -1569,7 +1452,7 @@ theorem leadingCoeff_localExpand_addPullback_x_negFrobenius_eq + leadingCoeff_localExpand_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq W hq] + ring + +-/-- **Sub-helper 66**: `localExpand(addPullback_x_negFrobenius) ≠ 0` for q ≥ 2. ++/-- `localExpand(addPullback_x_negFrobenius) ≠ 0` for q ≥ 2. + Direct from orderTop being a finite value. -/ + theorem localExpand_addPullback_x_negFrobenius_ne_zero + (hq : 2 ≤ Fintype.card K) : +@@ -1580,11 +1463,11 @@ theorem localExpand_addPullback_x_negFrobenius_ne_zero + rw [orderTop_localExpand_addPullback_x_negFrobenius_eq W hq] at h_top + exact WithTop.coe_ne_top h_top + +-/-- **Sub-helper 67**: `(localExpand(addPullback_x_negFrobenius)).coeff (-2) = 1` for q ≥ 2. ++/-- `(localExpand(addPullback_x_negFrobenius)).coeff (-2) = 1` for q ≥ 2. + Direct extraction of the leading coefficient at the leading exponent + via `HahnSeries.coeff_untop_eq_leadingCoeff` (when orderTop = -2 finite). + +-This is the ACTUAL coefficient value at the most-negative exponent, the ++This is the coefficient value at the most-negative exponent, the + LaurentSeries-side input for the IV.1.4 step 2 leading-coefficient + computation. -/ + theorem coeff_neg_two_localExpand_addPullback_x_negFrobenius_eq +@@ -1602,7 +1485,7 @@ theorem coeff_neg_two_localExpand_addPullback_x_negFrobenius_eq + rw [← h_untop, HahnSeries.coeff_untop_eq_leadingCoeff] + exact h_leadingCoeff + +-/-- **Sub-helper 68**: `((localExpand addPullback_x)^2).orderTop = -4`. -/ ++/-- `((localExpand addPullback_x)^2).orderTop = -4`. -/ + theorem orderTop_localExpand_addPullback_x_negFrobenius_sq + (hq : 2 ≤ Fintype.card K) : + ((localExpand W (addPullback_x W (negFrobeniusIsog W))) ^ 2 : +@@ -1612,7 +1495,7 @@ theorem orderTop_localExpand_addPullback_x_negFrobenius_sq + orderTop_localExpand_addPullback_x_negFrobenius_eq W hq, ← WithTop.coe_add] + congr 1 + +-/-- **Sub-helper 69**: `((localExpand addPullback_x)^3).orderTop = -6`. -/ ++/-- `((localExpand addPullback_x)^3).orderTop = -6`. -/ + theorem orderTop_localExpand_addPullback_x_negFrobenius_cube + (hq : 2 ≤ Fintype.card K) : + ((localExpand W (addPullback_x W (negFrobeniusIsog W))) ^ 3 : +@@ -1623,7 +1506,7 @@ theorem orderTop_localExpand_addPullback_x_negFrobenius_cube + orderTop_localExpand_addPullback_x_negFrobenius_eq W hq, ← WithTop.coe_add] + congr 1 + +-/-- **Sub-helper 70**: `localExpand(addPullback_y)` is nonzero for q ≥ 2. ++/-- `localExpand(addPullback_y)` is nonzero for q ≥ 2. + Direct from `localExpand` being a ring hom to a field + addPullback_y ≠ 0 + (via `ord_addPullback_y_negFrobenius`). -/ + theorem localExpand_addPullback_y_negFrobenius_ne_zero +@@ -1638,7 +1521,7 @@ theorem localExpand_addPullback_y_negFrobenius_ne_zero + rw [h_y_eq_zero] at h_y_ord + exact WithTop.top_ne_coe ((W_smooth W).ordAtInfty_zero.symm.trans h_y_ord) + +-/-- **Sub-helper 71**: localExpand of the curve equation ++/-- localExpand of the curve equation + `Y² + a₁·X·Y + a₃·Y = X³ + a₂·X² + a₄·X + a₆` applied to the addPullback + coordinates. Direct from `addPullback_equation` + `localExpand` ring hom. + +@@ -1675,7 +1558,7 @@ theorem localExpand_addPullback_curve_equation : + rw [ha₁, ha₂, ha₃, ha₄, ha₆] at h_le + exact h_le + +-/-- **Sub-helper 72**: `(localExpand(a₂·X² + a₄·X + a₆)).orderTop ≥ -4` for q ≥ 2. ++/-- `(localExpand(a₂·X² + a₄·X + a₆)).orderTop ≥ -4` for q ≥ 2. + The non-cubic RHS terms have orderTop bounded by -4 (since `a₂·X²` has + orderTop ≥ -4 = orderTop X² when a₂ ≠ 0, and `a₄·X` has orderTop ≥ -2 ≥ -4, + and `a₆` has orderTop ≥ 0 ≥ -4). -/ +@@ -1713,7 +1596,7 @@ theorem orderTop_localExpand_RHS_lower_terms_ge + refine le_trans ?_ (orderTop_HahnSeries_C_ge_zero W.a₆) + exact_mod_cast (by norm_num : (-4 : ℤ) ≤ 0) + +-/-- **Sub-helper 73**: `(localExpand(X³ + a₂·X² + a₄·X + a₆)).orderTop = -6` ++/-- `(localExpand(X³ + a₂·X² + a₄·X + a₆)).orderTop = -6` + for q ≥ 2. Strict non-arch with `X³` dominating (orderTop -6) and the other + terms bounded ≥ -4. -/ + theorem orderTop_localExpand_addPullback_RHS_eq +@@ -1751,8 +1634,7 @@ theorem orderTop_localExpand_addPullback_RHS_eq + exact (HahnSeries.orderTop_add_eq_left h_lt).trans + (orderTop_localExpand_addPullback_x_negFrobenius_cube W hq) + +-/-- **Sub-helper 74** (Y-side LHS orderTop = -6): direct from sub-helper 73 + +-the curve equation (sub-helper 71). -/ ++/-- Y-side LHS orderTop = -6: the curve equation identifies its order with the cubic right-hand side. -/ + theorem orderTop_localExpand_addPullback_LHS_eq + (hq : 2 ≤ Fintype.card K) : + ((localExpand W (addPullback_y W (negFrobeniusIsog W)))^2 + +@@ -1766,8 +1648,8 @@ theorem orderTop_localExpand_addPullback_LHS_eq + rw [localExpand_addPullback_curve_equation W] + exact orderTop_localExpand_addPullback_RHS_eq W hq + +-/-- **Sub-helper 75** (extract m): `localExpand(addPullback_y).orderTop = (m : ℤ)` +-for some integer `m`. Uses sub-helper 70 (≠ 0). -/ ++/-- extract m: `localExpand(addPullback_y).orderTop = (m : ℤ)` ++for some integer `m`. The series is nonzero, so its order is finite. -/ + theorem exists_m_orderTop_localExpand_addPullback_y_negFrobenius + (hq : 2 ≤ Fintype.card K) : + ∃ m : ℤ, (localExpand W (addPullback_y W (negFrobeniusIsog W))).orderTop = +@@ -1779,7 +1661,7 @@ theorem exists_m_orderTop_localExpand_addPullback_y_negFrobenius + obtain ⟨m, hm⟩ := WithTop.ne_top_iff_exists.mp h_ne_top + exact ⟨m, hm.symm⟩ + +-/-- **Sub-helper 76** (Y² orderTop = 2m): with `m = orderTop(Y)`, `Y²` has orderTop `2m`. -/ ++/-- Y² orderTop = 2m: with `m = orderTop(Y)`, `Y²` has orderTop `2m`. -/ + theorem orderTop_localExpand_addPullback_y_negFrobenius_sq_eq_two_m + (_hq : 2 ≤ Fintype.card K) (m : ℤ) + (hm : (localExpand W (addPullback_y W (negFrobeniusIsog W))).orderTop = +@@ -1790,7 +1672,7 @@ theorem orderTop_localExpand_addPullback_y_negFrobenius_sq_eq_two_m + rw [sq, HahnSeries.orderTop_mul, hm, ← WithTop.coe_add] + congr 1; ring + +-/-- **Sub-helper 77** (X·Y orderTop = -2 + m): -/ ++/-- X·Y orderTop = -2 + m: -/ + theorem orderTop_localExpand_addPullback_x_mul_y_negFrobenius_eq + (hq : 2 ≤ Fintype.card K) (m : ℤ) + (hm : (localExpand W (addPullback_y W (negFrobeniusIsog W))).orderTop = +@@ -1858,7 +1740,7 @@ private theorem orderTop_a3_mul_y_negFrobenius_ge (m : ℤ) (h_m_ge : -2 ≤ m) + rw [zero_add] + refine WithTop.coe_le_coe.mpr ?_; linarith + +-/-- **Sub-helper 78** (rule out m ≥ -2): if `m ≥ -2`, then LHS orderTop ≥ -4, ++/-- rule out m ≥ -2: if `m ≥ -2`, then LHS orderTop ≥ -4, + contradicting LHS orderTop = -6. -/ + theorem m_le_neg_three_orderTop_localExpand_addPullback_y_negFrobenius + (hq : 2 ≤ Fintype.card K) (m : ℤ) +@@ -1876,7 +1758,7 @@ theorem m_le_neg_three_orderTop_localExpand_addPullback_y_negFrobenius + have h46 : (-4 : ℤ) ≤ -6 := by exact_mod_cast h_lhs_ge + omega + +-/-- **Sub-helper 79** (Y² strictly dominates a₁·X·Y, given m ≤ -3): for `m ≤ -3`, ++/-- Y² strictly dominates a₁·X·Y, given m ≤ -3: for `m ≤ -3`, + `Y²` has orderTop = `2m ≤ -6 < -2 + m = orderTop(a₁·X·Y)`. -/ + theorem orderTop_y_sq_lt_a1xy_negFrobenius + (hq : 2 ≤ Fintype.card K) (m : ℤ) (h_m_le : m ≤ -3) +@@ -1907,7 +1789,7 @@ theorem orderTop_y_sq_lt_a1xy_negFrobenius + refine WithTop.coe_lt_coe.mpr ?_ + linarith + +-/-- **Sub-helper 80** (Y² strictly dominates a₃·Y, given m ≤ -3): for `m ≤ -3`, ++/-- Y² strictly dominates a₃·Y, given m ≤ -3: for `m ≤ -3`, + `Y²` has orderTop = `2m ≤ -6 < m = orderTop(a₃·Y)` (since `2m < m` for `m ≤ -3`). -/ + theorem orderTop_y_sq_lt_a3y_negFrobenius + (hq : 2 ≤ Fintype.card K) (m : ℤ) (h_m_le : m ≤ -3) +@@ -1976,8 +1858,8 @@ theorem orderTop_localExpand_addPullback_y_negFrobenius_eq + congr 1 + omega + +-/-- **Sub-helper 84**: leadingCoeff of `(localExpand X)^3 = 1`, derived from +-sub-helper main companion (`leadingCoeff(localExpand X) = 1`) + leadingCoeff_mul. -/ ++/-- leadingCoeff of `(localExpand X)^3 = 1`, derived from ++`leadingCoeff(localExpand X) = 1` and multiplicativity of leading coefficients. -/ + theorem leadingCoeff_localExpand_addPullback_x_negFrobenius_cube_eq + (hq : 2 ≤ Fintype.card K) : + ((localExpand W (addPullback_x W (negFrobeniusIsog W))) ^ 3 : +@@ -1987,7 +1869,7 @@ theorem leadingCoeff_localExpand_addPullback_x_negFrobenius_cube_eq + leadingCoeff_localExpand_addPullback_x_negFrobenius_eq W hq] + ring + +-/-- **Sub-helper 85**: leadingCoeff of RHS = 1. ++/-- leadingCoeff of RHS = 1. + + Strict-dominance of `X³` on RHS (orderTop -6 < -4 of other terms) gives + `leadingCoeff(RHS) = leadingCoeff(X³) = 1` via `leadingCoeff_add_eq_left`. -/ +@@ -2025,7 +1907,7 @@ theorem leadingCoeff_localExpand_addPullback_RHS_eq + rw [HahnSeries.leadingCoeff_add_eq_left h_lt] + exact leadingCoeff_localExpand_addPullback_x_negFrobenius_cube_eq W hq + +-/-- **Sub-helper 86**: leadingCoeff of LHS = 1. ++/-- leadingCoeff of LHS = 1. + + LHS = RHS (curve equation), so leadingCoeff equal. -/ + theorem leadingCoeff_localExpand_addPullback_LHS_eq +@@ -2040,7 +1922,7 @@ theorem leadingCoeff_localExpand_addPullback_LHS_eq + rw [localExpand_addPullback_curve_equation W] + exact leadingCoeff_localExpand_addPullback_RHS_eq W hq + +-/-- **Sub-helper 87**: leadingCoeff of `Y²` extracted from LHS via strict-dominance. ++/-- leadingCoeff of `Y²` extracted from LHS via strict-dominance. + + For the actual y-orderTop = -3, `Y²` (orderTop = -6) strictly dominates `a₁·X·Y` + (orderTop = -5) and `a₃·Y` (orderTop = -3). So `leadingCoeff(LHS) = leadingCoeff(Y²)`. -/ +@@ -2080,7 +1962,7 @@ theorem leadingCoeff_localExpand_addPullback_y_negFrobenius_sq_eq_one + exact h_lhs_lc + + /-- **MAIN Y-SIDE LEADING-COEFFICIENT**: `(leadingCoeff(localExpand addPullback_y))² = 1` +-for q ≥ 2. From `leadingCoeff(Y²) = 1` (sub-helper 87) + `leadingCoeff_mul`. -/ ++for q ≥ 2. From `leadingCoeff(Y²) = 1` + `leadingCoeff_mul`. -/ + theorem leadingCoeff_localExpand_addPullback_y_negFrobenius_sq + (hq : 2 ≤ Fintype.card K) : + ((localExpand W (addPullback_y W (negFrobeniusIsog W))).leadingCoeff)^2 = 1 := by +@@ -2089,7 +1971,7 @@ theorem leadingCoeff_localExpand_addPullback_y_negFrobenius_sq + rw [sq] + exact h + +-/-- **Sub-helper 89**: `leadingCoeff(localExpand addPullback_y) ≠ 0` for q ≥ 2. ++/-- `leadingCoeff(localExpand addPullback_y) ≠ 0` for q ≥ 2. + Direct from the squared identity = 1 (so leadingCoeff = ±1). -/ + theorem leadingCoeff_localExpand_addPullback_y_negFrobenius_ne_zero + (hq : 2 ≤ Fintype.card K) : +@@ -2099,7 +1981,7 @@ theorem leadingCoeff_localExpand_addPullback_y_negFrobenius_ne_zero + rw [h, sq, mul_zero] at h_sq + exact zero_ne_one h_sq + +-/-- **Sub-helper 89b**: `addPullbackAlgHom_negFrobenius (x_gen) = addPullback_x`. -/ ++/-- `addPullbackAlgHom_negFrobenius (x_gen) = addPullback_x`. -/ + theorem addPullbackAlgHom_negFrobenius_x_gen_eq + (hq : 2 ≤ Fintype.card K) : + addPullbackAlgHom_negFrobenius W hq (x_gen W) = +@@ -2119,7 +2001,7 @@ theorem addPullbackAlgHom_negFrobenius_x_gen_eq + rw [AdjoinRoot.lift_mk] + simp [addBaseHom, Polynomial.eval₂_C] + +-/-- **Sub-helper 89c**: `addPullbackAlgHom_negFrobenius (y_gen) = addPullback_y`. -/ ++/-- `addPullbackAlgHom_negFrobenius (y_gen) = addPullback_y`. -/ + theorem addPullbackAlgHom_negFrobenius_y_gen_eq + (hq : 2 ≤ Fintype.card K) : + addPullbackAlgHom_negFrobenius W hq (y_gen W) = +@@ -2141,8 +2023,7 @@ theorem addPullbackAlgHom_negFrobenius_y_gen_eq + rw [AdjoinRoot.lift_mk] + simp [addBaseHom, Polynomial.eval₂_X] + +-/-- **Sub-helper 90**: +-`localExpand(γ.pullback localParam) = -localExpand(addPullback_x) / localExpand(addPullback_y)` ++/-- `localExpand(γ.pullback localParam) = -localExpand(addPullback_x) / localExpand(addPullback_y)` + for γ = isogOneSub_negFrobenius. Direct ring-hom + AlgHom.commutes_div + map_div₀. -/ + theorem localExpand_isogOneSub_negFrobenius_pullback_localParam + (hq : 2 ≤ Fintype.card K) : +@@ -2155,7 +2036,7 @@ theorem localExpand_isogOneSub_negFrobenius_pullback_localParam + addPullbackAlgHom_negFrobenius_x_gen_eq W hq, + addPullbackAlgHom_negFrobenius_y_gen_eq W hq] + +-/-- **Sub-helper 91**: `(localExpand(γ.pullback localParam)).orderTop = 1` for ++/-- `(localExpand(γ.pullback localParam)).orderTop = 1` for + γ = isogOneSub_negFrobenius. Via `orderTop_div`: `-2 - (-3) = 1`. -/ + theorem orderTop_localExpand_isogOneSub_negFrobenius_pullback_localParam + (hq : 2 ≤ Fintype.card K) : +@@ -2169,7 +2050,7 @@ theorem orderTop_localExpand_isogOneSub_negFrobenius_pullback_localParam + orderTop_localExpand_addPullback_y_negFrobenius_eq W hq] + rfl + +-/-- **Sub-helper 92**: `(localExpand(γ.pullback localParam)).leadingCoeff = -1 / leadingCoeff(Y)` ++/-- `(localExpand(γ.pullback localParam)).leadingCoeff = -1 / leadingCoeff(Y)` + for γ = isogOneSub_negFrobenius. Via `leadingCoeff_div` + `leadingCoeff_neg`. -/ + theorem leadingCoeff_localExpand_isogOneSub_negFrobenius_pullback_localParam + (hq : 2 ≤ Fintype.card K) : +@@ -2181,7 +2062,7 @@ theorem leadingCoeff_localExpand_isogOneSub_negFrobenius_pullback_localParam + rw [HahnSeries.leadingCoeff_neg, + leadingCoeff_localExpand_addPullback_x_negFrobenius_eq W hq] + +-/-- **Sub-helper 93**: `coeff 1 (formal γ) = -1 / leadingCoeff(Y)` for γ = isogOneSub_negFrobenius. ++/-- `coeff 1 (formal γ) = -1 / leadingCoeff(Y)` for γ = isogOneSub_negFrobenius. + + Via `formalIsogenySeries_coeff` + `coeff_untop_eq_leadingCoeff` at orderTop = 1. + This is the LaurentSeries-side computation of `coeff 1 (formal γ)` modulo +@@ -2209,8 +2090,8 @@ theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_eq_neg_one_div_lea + HahnSeries.coeff_untop_eq_leadingCoeff] + exact h_Z_lc + +-/-- **Sub-helper 94** (witness-parametric coeff 1 = 1): with `leadingCoeff(Y) = -1` +-witness, `coeff 1 (formalIsogenySeries γ) = 1` axiom-clean. -/ ++/-- witness-parametric coeff 1 = 1: with `leadingCoeff(Y) = -1` ++witness, `coeff 1 (formalIsogenySeries γ) = 1`. -/ + theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_eq_one_of_y_lc + (hq : 2 ≤ Fintype.card K) + (h_y_lc : (localExpand W (addPullback_y W (negFrobeniusIsog W))).leadingCoeff = -1) : +@@ -2220,9 +2101,8 @@ theorem coeff_one_formalIsogenySeries_isogOneSub_negFrobenius_eq_one_of_y_lc + -- Goal: -1 / -1 = 1 + norm_num + +-/-- **Sub-helper 95** (Witness #1 closer via leadingCoeff(Y) witness + BRIDGE-001 γ): +-takes `leadingCoeff(Y) = -1` as the LaurentSeries-side witness and BRIDGE-001 +-for γ as the K(E)-side witness, fires Witness #1 unconditional. -/ ++/-- A y-coordinate Laurent leading coefficient of `-1`, together with equality of the ++differential and linear formal-series coefficients, implies separability of `1 − π`. -/ + theorem isogOneSub_negFrobenius_isSeparable_via_y_lc_and_bridge_001 + (hq : 2 ≤ Fintype.card K) + (h_y_lc : (localExpand W (addPullback_y W (negFrobeniusIsog W))).leadingCoeff = -1) +@@ -2241,8 +2121,8 @@ theorem isogOneSub_negFrobenius_isSeparable_via_y_lc_and_bridge_001 + exact isogOneSub_negFrobenius_isSeparable_of_bridge_and_leading W hq + h_bridge_001_γ h_leading_add + +-/-- **Sub-helper 96** (omegaPullbackCoeff = 1 via leadingCoeff(Y) + BRIDGE-001 γ): +-companion to 95 producing `omegaPullbackCoeff(γ) = 1`. -/ ++/-- A y-coordinate Laurent leading coefficient of `-1` and the differential/formal-series ++coefficient identity give differential coefficient one for `1 − π`. -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_y_lc_and_bridge_001 + (hq : 2 ≤ Fintype.card K) + (h_y_lc : (localExpand W (addPullback_y W (negFrobeniusIsog W))).leadingCoeff = -1) +@@ -2261,12 +2141,8 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_y_lc_and_bridge_00 + exact omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_of_bridge_and_leading W hq + h_bridge_001_γ h_leading_add + +-/-- **Sub-helper 96b** (sign determination — char 2 case axiom-clean): +-in characteristic 2, `(localExpand addPullback_y).leadingCoeff = -1` +-because `c_y² = 1` (sub-helper 88) and `1 = -1` in char 2 (via `CharTwo.neg_eq`). +- +-This pins the sign for characteristic 2 axiom-clean, closing the +-sign-determination work for q = 2^k case. -/ ++/-- In characteristic two the y-coordinate Laurent leading coefficient is `-1`, ++since its square is one and `1 = -1`. -/ + theorem leadingCoeff_localExpand_addPullback_y_negFrobenius_eq_neg_one_char_two + [CharP K 2] + (hq : 2 ≤ Fintype.card K) : +@@ -2294,8 +2170,8 @@ theorem leadingCoeff_localExpand_addPullback_y_negFrobenius_eq_neg_one_char_two + pow_eq_zero_iff (n := 2) (by norm_num : 2 ≠ 0) |>.mp h_c_plus_one_sq + exact eq_neg_of_add_eq_zero_left h_c_plus_one + +-/-- **Sub-helper 98** (Witness #1 char 2): in characteristic 2, the y-side +-sign pin is automatic via 96b. Witness #1 fires with only BRIDGE-001 for γ. -/ ++/-- In characteristic two, equality of the differential and linear formal-series ++coefficients implies separability of `1 − π`. -/ + theorem isogOneSub_negFrobenius_isSeparable_char_two + [CharP K 2] + (hq : 2 ≤ Fintype.card K) +@@ -2307,7 +2183,7 @@ theorem isogOneSub_negFrobenius_isSeparable_char_two + (leadingCoeff_localExpand_addPullback_y_negFrobenius_eq_neg_one_char_two W hq) + h_bridge_001_γ + +-/-- **Sub-helper 99** (omegaPullbackCoeff(γ) = 1 char 2). -/ ++/-- omegaPullbackCoeff(γ) = 1 char 2. -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_char_two + [CharP K 2] + (hq : 2 ≤ Fintype.card K) +@@ -2319,10 +2195,8 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_char_two + (leadingCoeff_localExpand_addPullback_y_negFrobenius_eq_neg_one_char_two W hq) + h_bridge_001_γ + +-/-- **Sub-helper 101** (BRIDGE-001 for γ char-2 from omega witness): takes +-`omegaPullbackCoeff(γ) = 1` directly and discharges BRIDGE-001 for γ +-axiom-clean. The LaurentSeries side gives `coeff 1 (formal γ) = 1` via +-y-lc (sub-helper 96b) + ratio chain. -/ ++/-- In characteristic two, differential coefficient one implies its equality with the ++linear formal-series coefficient, which is also one. -/ + theorem bridge_001_γ_isogOneSub_negFrobenius_char_two + [CharP K 2] + (hq : 2 ≤ Fintype.card K) +@@ -2336,7 +2210,7 @@ theorem bridge_001_γ_isogOneSub_negFrobenius_char_two + exact (map_one _).symm + + omit [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 104** (Frobenius D vanishing): for finite K with characteristic ++/-- Frobenius D vanishing: for finite K with characteristic + p (and `q = #K` a power of p), the Kähler differential of `x_gen^q` vanishes. + + Proof: `D(x^q) = q · x^(q-1) · D(x)` (Leibniz pow), and `(q : K) = 0` since +@@ -2355,9 +2229,8 @@ theorem kaehler_D_x_gen_pow_card_eq_zero + rw [Nat.cast_smul_eq_nsmul, smul_assoc]] + rw [h_card_zero, zero_smul, zero_smul] + +-/-- **Sub-helper 105** (Frobenius D pullback vanishing): the Kähler differential +-of `(frobeniusIsog).pullback x_gen` vanishes. Direct from sub-helper 104 + +-`frobeniusIsog_pullback_apply` (= `x_gen^q`). -/ ++/-- The Kähler differential of the Frobenius pullback of `x_gen` vanishes, because that ++pullback is a q-th power. -/ + theorem kaehler_D_frobeniusIsog_pullback_x_gen + (p : ℕ) [Fact p.Prime] [CharP K p] : + KaehlerDifferential.D K W.toAffine.FunctionField +@@ -2365,7 +2238,7 @@ theorem kaehler_D_frobeniusIsog_pullback_x_gen + rw [frobeniusIsog_pullback_apply] + exact kaehler_D_x_gen_pow_card_eq_zero W p + +-/-- **Sub-helper 106** (Frobenius D pullback y vanishing): the Kähler differential ++/-- Frobenius D pullback y vanishing: the Kähler differential + of `(frobeniusIsog).pullback y_gen` vanishes. Same proof shape as 105. -/ + theorem kaehler_D_frobeniusIsog_pullback_y_gen + (p : ℕ) [Fact p.Prime] [CharP K p] : +@@ -2382,13 +2255,13 @@ theorem kaehler_D_frobeniusIsog_pullback_y_gen + rw [Nat.cast_smul_eq_nsmul, smul_assoc]] + rw [h_card_zero, zero_smul, zero_smul] + +-/-- **Sub-helper 107** (negFrobenius D pullback x vanishing): the Kähler differential ++/-- negFrobenius D pullback x vanishing: the Kähler differential + of `(negFrobeniusIsog).pullback x_gen` vanishes. + + `negFrobeniusIsog = mulByInt(-1) ∘ frobeniusIsog`, so + `(negFrob).pullback x_gen = frobenius.pullback ((mulByInt(-1)).pullback x_gen) = + frobenius.pullback x_gen = x_gen^q` (since `[-1]` fixes `x_gen`). +-Then by sub-helper 104, `D(x_gen^q) = 0`. -/ ++The differential of a q-th power vanishes. -/ + theorem kaehler_D_negFrobeniusIsog_pullback_x_gen + (p : ℕ) [Fact p.Prime] [CharP K p] : + KaehlerDifferential.D K W.toAffine.FunctionField +@@ -2396,13 +2269,13 @@ theorem kaehler_D_negFrobeniusIsog_pullback_x_gen + rw [negFrobeniusIsog_pullback_x_gen] + exact kaehler_D_frobeniusIsog_pullback_x_gen W p + +-/-- **Sub-helper 108** (negFrobenius D pullback y vanishing): the Kähler differential ++/-- negFrobenius D pullback y vanishing: the Kähler differential + of `(negFrobeniusIsog).pullback y_gen` vanishes. + + `(negFrob).pullback y_gen = -π·y_gen - a₁·π·x_gen - a₃` (where π·· = + frobeniusIsog.pullback). The differential operator `D` is a K-derivation, + so `D(constant) = 0` for `a₃ ∈ K`, and `D(a₁ · f) = a₁ · D(f)` for `a₁ ∈ K`, +-and `D(-f) = -D(f)`. Combined with sub-helpers 105-106, all three terms ++and `D(-f) = -D(f)`. Vanishing of both Frobenius coordinate differentials shows that all three terms + vanish. -/ + theorem kaehler_D_negFrobeniusIsog_pullback_y_gen + (p : ℕ) [Fact p.Prime] [CharP K p] : +@@ -2419,7 +2292,7 @@ theorem kaehler_D_negFrobeniusIsog_pullback_y_gen + simp + + omit [Fintype K] in +-/-- **Sub-helper 109** (D(addPullback_x) formula via slope). ++/-- D(addPullback_x) formula via slope. + + For any α : Isogeny W W with `D((α).pullback x_gen) = 0` (i.e., α has its + x-pullback Kähler-flat, true for Frobenius / negFrobenius in characteristic +@@ -2452,9 +2325,9 @@ theorem kaehler_D_addPullback_x_via_slope_witness + (Nat.cast_smul_eq_nsmul (R := KE) 2 _).symm] + rw [smul_smul] + +-/-- **Sub-helper 110** (D(addPullback_x) for negFrobenius — specialized). ++/-- D(addPullback_x) for negFrobenius — specialized. + +-Direct from sub-helper 109 + sub-helper 107: for the addition-pullback ++Differentiating the addition formula and using the vanishing Frobenius differential gives, for the addition-pullback + under negFrobenius, `D(addPullback_x) = (2·ℓ + a₁) • D(ℓ) - D(x_gen)` + where ℓ = addSlope W (negFrobeniusIsog W). + +@@ -2473,7 +2346,7 @@ theorem kaehler_D_addPullback_x_negFrobenius + (kaehler_D_negFrobeniusIsog_pullback_x_gen W p) + + omit [Fintype K] in +-/-- **Route B core (III.5.2), general slope-differential formula** (no `D(α*x)=0` ++/-- **General slope-differential formula** (no `D(α*x)=0` + hypothesis): for any `α`, the Kähler differential of the `id + α` addition-pullback + x-coordinate is the slope term minus `D(x_gen)` minus `D(α*x)`. Generalizes + `kaehler_D_addPullback_x_via_slope_witness` (which drops the last term under the +@@ -2502,19 +2375,8 @@ theorem kaehler_D_addPullback_x_general + rw [show (2 : ℕ) • (ℓ • D ℓ) = ((2 : KE)) • (ℓ • D ℓ) from + (Nat.cast_smul_eq_nsmul (R := KE) 2 _).symm, smul_smul] + +-/-- **Sub-helper 111** (ω(γ) = 1 via Kähler witness). +- +-Closing-arc witness consumer: given that +- `(α*(u))⁻¹ • D(addPullback_x) = invariantDifferential` +-(equivalently, `α*(u) • ω = D(addPullback_x)` for ω = invariantDifferential), +-conclude `omegaPullbackCoeff(γ) = 1`. Direct from +-`omegaPullbackCoeff_spec` + `omegaPullbackCoeff_unique`. +- +-The hypothesis is the SUBSTANTIVE Kähler identity in K(E) that III.5.2 / IV.1.4 +-carries out: relating the slope's differential to the addition-pullback's +-differential. Once this identity is closed (via, e.g., the curve equation +-matching at orderTop -6 and the slope-of-formal-identity lemma), `ω(γ) = 1` +-follows axiom-clean and the Hasse-Weil bound discharges via sub-helper 103. -/ ++/-- The Kähler identity `(α*u)⁻¹ • D(α*x) = ω` gives differential coefficient one. ++This follows from the defining identity and uniqueness of the coefficient. -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_kaehler_witness + (hq : 2 ≤ Fintype.card K) + (h_kaehler : +@@ -2528,12 +2390,8 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_kaehler_witness + simp only [x_gen] at h_kaehler + exact h_kaehler + +-/-- **Sub-helper 113** (Kähler ω(γ) = 1 via pullbackKaehler witness — closing-arc). +- +-The cleaner reformulation of sub-helper 111 using `pullbackKaehler` directly: +-given `γ.pullbackKaehler ω = ω`, conclude `omegaPullbackCoeff(γ) = 1`. +- +-Direct from `pullbackKaehler_invariantDifferential` + `omegaPullbackCoeff_unique`. -/ ++/-- An isogeny fixing the invariant differential has differential coefficient one. ++-/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_pullbackKaehler_witness + (hq : 2 ≤ Fintype.card K) + (h_pK : (isogOneSub_negFrobenius W hq).pullbackKaehler +@@ -2544,7 +2402,7 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_pullbackKaehler_wi + exact h_pK + + omit [Fintype K] in +-/-- **Sub-helper 114** (id.pullbackKaehler ω = ω, axiom-clean). ++/-- id.pullbackKaehler ω = ω. + + The identity isogeny acts trivially on the invariant differential. Direct + from `pullbackKaehler_invariantDifferential (Isogeny.id W.toAffine)` + +@@ -2554,28 +2412,15 @@ theorem pullbackKaehler_invariantDifferential_id : + invariantDifferential W.toAffine := by + rw [Isogeny.pullbackKaehler_invariantDifferential, omegaPullbackCoeff_id, one_smul] + +-/-- **Sub-helper 115** ((-π).pullbackKaehler ω = 0, axiom-clean). +- +-The negation-of-Frobenius isogeny annihilates the invariant differential +-(at the cotangent level). Direct from `pullbackKaehler_invariantDifferential +-(negFrobeniusIsog W)` + `omegaPullbackCoeff_negFrobeniusIsog = 0` +-(Differential.lean line 430, axiom-clean). -/ ++/-- Negative Frobenius annihilates the invariant differential, because its ++invariant-differential coefficient is zero. -/ + theorem pullbackKaehler_invariantDifferential_negFrobeniusIsog : + (negFrobeniusIsog W).pullbackKaehler (invariantDifferential W.toAffine) = 0 := by + rw [Isogeny.pullbackKaehler_invariantDifferential, + omegaPullbackCoeff_negFrobeniusIsog, zero_smul] + +-/-- **Sub-helper 116** (γ.pullbackKaehler ω = ω via III.5.2 additivity witness — axiom-clean). +- +-Given the III.5.2 additivity at the differential level for our specific +-decomposition `γ = id + (-π)`: +- `γ.pullbackKaehler ω = id.pullbackKaehler ω + (-π).pullbackKaehler ω`, +-combine with sub-helpers 114-115 (axiom-clean: `id.pullbackKaehler ω = ω` and +-`(-π).pullbackKaehler ω = 0`) to conclude `γ.pullbackKaehler ω = ω + 0 = ω`. +- +-This is the closing-arc commit: the only remaining substantive input is the +-III.5.2 differential additivity for our specific case, which is the III.5.2 +-content for elliptic curve isogenies. -/ ++/-- Differential additivity for `id + (-π)` gives pullback of the invariant differential ++equal to itself, since the identity fixes it and negative Frobenius annihilates it. -/ + theorem pullbackKaehler_invariantDifferential_isogOneSub_negFrobenius_via_additivity_witness + (hq : 2 ≤ Fintype.card K) + (h_add : (isogOneSub_negFrobenius W hq).pullbackKaehler +@@ -2587,11 +2432,8 @@ theorem pullbackKaehler_invariantDifferential_isogOneSub_negFrobenius_via_additi + rw [h_add, pullbackKaehler_invariantDifferential_id W, + pullbackKaehler_invariantDifferential_negFrobeniusIsog W, add_zero] + +-/-- **Sub-helper 117** (ω(γ) = 1 via III.5.2 additivity witness — closing-arc). +- +-Composes sub-helper 113 (Kähler witness → ω(γ) = 1) with sub-helper 116 +-(III.5.2 additivity → γ.pullbackKaehler ω = ω). The single substantive +-input is the III.5.2 differential additivity for our specific decomposition. -/ ++/-- Additivity of the pullback of the invariant differential for `id + (-π)` gives ++differential coefficient one. -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_additivity_witness + (hq : 2 ≤ Fintype.card K) + (h_add : (isogOneSub_negFrobenius W hq).pullbackKaehler +@@ -2603,20 +2445,9 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one_via_additivity_witness + (pullbackKaehler_invariantDifferential_isogOneSub_negFrobenius_via_additivity_witness + W hq h_add) + +-/-- **Sub-helper 119** (Kähler witness via slope-derivative witness — closing-arc). +- +-Given `D(addSlope W (negFrobeniusIsog W)) = c • D(x_gen)` for some `c : K(E)` +-(derived from differentiating the slope formula `(y_gen - π·y) / (x_gen - π·x)` +-with the Frobenius differential vanishing — sub-helpers 107, 108) and the +-algebraic identity in K(E): +- `(2ℓ + a₁) · c - 1 = (alpha_star_u γ) · u_gen⁻¹` +-(equivalently, after clearing denominators: the K(E) identity that the III.5.2 +-content carries out), conclude the Kähler witness needed by sub-helper 111. +- +-This factors the III.5.2 differential additivity through an explicit K(E) +-identity. The slope-derivative witness is the Kähler-differential form of +-the curve-tangent calculation; the K(E) identity is the substantive arithmetic +-content of III.5.2 for our `id + (-π)` decomposition. -/ ++/-- A slope derivative `D(ℓ) = c • D(x)` and the coefficient identity ++`((2ℓ + a₁)c - 1)u = α*u` imply `(α*u)⁻¹ • D(α*x) = ω` for `α = 1 − π`. ++This expresses differential additivity through an identity in the function field. -/ + theorem kaehler_witness_via_slope_deriv_witness + (p : ℕ) [Fact p.Prime] [CharP K p] + (hq : 2 ≤ Fintype.card K) +@@ -2665,14 +2496,8 @@ theorem kaehler_witness_via_slope_deriv_witness + linear_combination h_KE_identity + + omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 120** (Weierstrass equation in K(E), axiom-clean): +-`y_gen² + a₁·x_gen·y_gen + a₃·y_gen = x_gen³ + a₂·x_gen² + a₄·x_gen + a₆` +-in K(E). Direct from the affine equation `Affine.Equation` for the generic +-point on `W_KE`, with W_KE coefficients lifted to algebraMap form. +- +-This is the foundational K(E) identity that the curve-equation Kähler +-differential identity (sub-helper 121) builds upon. No derivation involved +-yet — purely the equation in K(E). -/ ++/-- The generic coordinates satisfy the Weierstrass equation in the function field. ++-/ + theorem weierstrass_equation_in_KE : + y_gen W ^ 2 + algebraMap K KE W.a₁ * x_gen W * y_gen W + + algebraMap K KE W.a₃ * y_gen W = +@@ -2684,14 +2509,8 @@ theorem weierstrass_equation_in_KE : + exact h_gen + + omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 121** (Kähler form of curve equation, axiom-clean foundation): +-literal D-application of the Weierstrass equation in K(E): +-`D(y² + a₁xy + a₃y) = D(x³ + a₂x² + a₄x + a₆)` in `Ω[K(E)/K]`. +- +-Direct from `congrArg D` applied to `weierstrass_equation_in_KE` (sub-helper +-120). The substantive Kähler identity `(a₃ + 2y + a₁x)·Dy = (3x² + 2a₂x + +-a₄ - a₁y)·Dx` follows by Leibniz expansion; the explicit ℕ-smul ↔ KE-smul +-conversion in that expansion is technical and deferred. -/ ++/-- Applying the universal derivation to the generic Weierstrass equation gives ++`D(y² + a₁xy + a₃y) = D(x³ + a₂x² + a₄x + a₆)` in `Ω[K(E)/K]`. -/ + theorem kaehler_D_weierstrass_equation_K_E : + KaehlerDifferential.D K W.toAffine.FunctionField + (y_gen W ^ 2 + +@@ -2706,9 +2525,8 @@ theorem kaehler_D_weierstrass_equation_K_E : + (weierstrass_equation_in_KE W) + + omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 122** (D(y²) via pow_two — axiom-clean KE-smul-only): +-`D(y_gen²) = y_gen • D(y_gen) + y_gen • D(y_gen)`. Wall-break: avoids +-`Derivation.leibniz_pow`'s ℕ-smul. -/ ++/-- D(y²) via pow_two — KE-smul-only: ++`D(y_gen²) = y_gen • D(y_gen) + y_gen • D(y_gen)`. The product rule expresses both summands using function-field scalar multiplication. -/ + theorem kaehler_D_y_gen_sq : + KaehlerDifferential.D K W.toAffine.FunctionField (y_gen W ^ 2) = + y_gen W • KaehlerDifferential.D K W.toAffine.FunctionField (y_gen W) + +@@ -2717,7 +2535,7 @@ theorem kaehler_D_y_gen_sq : + (KaehlerDifferential.D K W.toAffine.FunctionField).leibniz (y_gen W) (y_gen W)] + + omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 123** (D(x²) via pow_two — axiom-clean): ++/-- D(x²) via pow_two —: + `D(x_gen²) = x_gen • D(x_gen) + x_gen • D(x_gen)`. -/ + theorem kaehler_D_x_gen_sq : + KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W ^ 2) = +@@ -2727,7 +2545,7 @@ theorem kaehler_D_x_gen_sq : + (KaehlerDifferential.D K W.toAffine.FunctionField).leibniz (x_gen W) (x_gen W)] + + omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 124** (D(x³) via pow expansion + leibniz — axiom-clean): ++/-- D(x³) via pow expansion + leibniz —: + `D(x_gen³) = x_gen² • D(x_gen) + x_gen • D(x_gen²)`. -/ + theorem kaehler_D_x_gen_cube : + KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W ^ 3) = +@@ -2739,9 +2557,8 @@ theorem kaehler_D_x_gen_cube : + (KaehlerDifferential.D K W.toAffine.FunctionField).leibniz (x_gen W ^ 2) (x_gen W)] + + omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 125** (D-distribution of Weierstrass equation LHS, axiom-clean): +-fully Leibniz-expanded LHS in KE-smul-only form. Uses sub-helper 122 (D(y²) +-bypass) + Derivation.leibniz + D.map_algebraMap. -/ ++/-- Applying the product rule to the left-hand side of the Weierstrass equation gives ++its expansion using function-field scalar multiplication. -/ + theorem kaehler_D_weierstrass_LHS_expanded : + KaehlerDifferential.D K W.toAffine.FunctionField + (y_gen W ^ 2 + +@@ -2770,8 +2587,8 @@ theorem kaehler_D_weierstrass_LHS_expanded : + simp only [smul_zero, add_zero] + + omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in +-/-- **Sub-helper 126** (D-distribution of Weierstrass equation RHS, axiom-clean): +-fully Leibniz-expanded RHS. Uses sub-helpers 123, 124. -/ ++/-- D-distribution of Weierstrass equation RHS: ++fully Leibniz-expanded RHS. The product rule expands the square and cube. -/ + theorem kaehler_D_weierstrass_RHS_expanded : + KaehlerDifferential.D K W.toAffine.FunctionField + (x_gen W ^ 3 + +@@ -2803,17 +2620,10 @@ theorem kaehler_D_weierstrass_RHS_expanded : + (KaehlerDifferential.D K W.toAffine.FunctionField).map_algebraMap W.a₆] + simp only [smul_zero, add_zero] + +-/-- **Sub-helper 127** (curve-equation Kähler identity, axiom-clean): +- ++omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in ++/-- Differentiating the Weierstrass equation gives + `(a₃ + 2y + a₁x) • D(y) = (3x² + 2a₂x + a₄ - a₁y) • D(x)` in `Ω[K(E)/K]`. +- +-Combines sub-helper 121 (D(LHS) = D(RHS) via congrArg) + 125 (LHS expansion) +-+ 126 (RHS expansion) + `linear_combination`. All KE-smul throughout — +-ℕ-smul wall bypassed via sub-helpers 122-124. +- +-This is the SUBSTANTIVE K(E) Kähler identity. NO witnesses. Foundational +-for sub-helper 128 (D(slope)) and the III.5.2 invariant-differential +-additivity. -/ ++-/ + theorem kaehler_curve_equation_K_E : + (algebraMap K KE W.a₃ + (2 : KE) * y_gen W + + algebraMap K KE W.a₁ * x_gen W) • +@@ -2823,10 +2633,7 @@ theorem kaehler_curve_equation_K_E : + algebraMap K KE W.a₄ - + algebraMap K KE W.a₁ * y_gen W) • + KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W) := by +- -- Sixth wall-break attempt: pre-rewrite goal `(2 : KE) * y_gen` to +- -- `y_gen + y_gen` using ring identities BEFORE expansion, eliminating the +- -- (2 : KE) literal at the source. Then both sides use only +-additive +- -- composition + KE-smul, no `(2 : ℕ)` casts anywhere. ++ -- Expand the integer coefficients as sums in the function field before differentiating. + set Dx := KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W) + set Dy := KaehlerDifferential.D K W.toAffine.FunctionField (y_gen W) + -- Substitute literals with explicit sums in K(E). +@@ -2851,24 +2658,9 @@ theorem kaehler_curve_equation_K_E : + -- Now both sides are sums of (KE-coefficient) • (Dx or Dy). Match via abel. + linear_combination (norm := abel) h_eq + +-/-- **Sub-helper 128** (D(addSlope) for negFrobenius — substantive K(E) identity, axiom-clean): +- +-The Kähler derivative of `addSlope W (negFrobeniusIsog W) = +-(y_gen - π·y) / (x_gen - π·x)` satisfies the closed-form identity: +- +-``` +-(x_gen - π·x)² • D(addSlope) = (x_gen - π·x) • D(y_gen) - (y_gen - π·y) • D(x_gen) +-``` +- +-where π·x = (negFrob).pullback x_gen, π·y = (negFrob).pullback y_gen. +- +-Proof: apply `Derivation.leibniz_div` to `addSlope_negFrobeniusIsog_eq`, +-simplify via `D(π·x) = 0` (sub-helper 107), `D(π·y) = 0` (sub-helper 108), +-cancel Den² · Den⁻² = 1. +- +-This is the SUBSTANTIVE K(E) Kähler identity for the addition slope — +-NO witnesses, NO hypotheses beyond Mathlib's quotient rule and the +-existing Frobenius-differential vanishing (axiom-clean). -/ ++/-- The quotient rule and vanishing of Frobenius differentials give ++`Den² • D(ℓ) = Den • D(y) - N • D(x)` for the addition slope, where ++`Den = x - (-π)*x` and `N = y - (-π)*y`. -/ + theorem kaehler_D_addSlope_negFrobenius + (p : ℕ) [Fact p.Prime] [CharP K p] : + (x_gen W - (negFrobeniusIsog W).pullback (x_gen W)) ^ 2 • +@@ -2902,7 +2694,7 @@ theorem kaehler_D_addSlope_negFrobenius + rw [one_smul] + + omit [Fintype K] in +-/-- **Route B core (III.5.2), general slope differential** (no Frobenius flatness): for any `α` ++/-- **General slope differential** (no Frobenius flatness): for any `α` + with `x_gen ≠ α*x_gen` (non-doubling), the Kähler derivative of `addSlope = (y−α*y)/(x−α*x)` + satisfies `Den²·D(addSlope) = Den·(D(y)−D(α*y)) − N·(D(x)−D(α*x))` where `N = y−α*y`, + `Den = x−α*x`. Generalizes `kaehler_D_addSlope_negFrobenius` (which used `D(π*x)=D(π*y)=0`). -/ +@@ -2931,10 +2723,9 @@ theorem kaehler_D_addSlope_general + show Den ^ 2 * Den⁻¹ ^ 2 = 1 from by rw [← mul_pow, mul_inv_cancel₀ hDen_ne, one_pow], + one_smul] + +-/-- **Sub-helper 129** (D(γ.pullback x_gen) cleared form, axiom-clean): ++/-- D(γ.pullback x_gen) cleared form: + +-Combines sub-helper 110 (`D(addPullback_x) = (2ℓ + a₁) • D(ℓ) - D(x_gen)`) +-with sub-helper 128 (`Den² • D(addSlope) = Den • D(y_gen) - N • D(x_gen)`) ++Combines the differentiated addition formula with the denominator-cleared slope derivative + to give a single closed-form identity for D(γ.pullback x_gen) involving + D(y_gen) and D(x_gen) (with Den² as the multiplier). + +@@ -2949,7 +2740,7 @@ where ℓ = addSlope, Den = x_gen - π·x, N = y_gen - π·y. + + This is the substantive D(γ.pullback x_gen) reduction in K(E), expressed + purely in terms of the curve generators' Kähler differentials and Den, N +-without any inverses. Foundational for the III.5.2 cascade closure. -/ ++without any inverses. This is a differential form of Silverman III.5.2. -/ + theorem kaehler_D_addPullback_x_negFrobenius_cleared + (p : ℕ) [Fact p.Prime] [CharP K p] : + (x_gen W - (negFrobeniusIsog W).pullback (x_gen W)) ^ 2 • +@@ -2963,14 +2754,14 @@ theorem kaehler_D_addPullback_x_negFrobenius_cleared + KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W)) - + (x_gen W - (negFrobeniusIsog W).pullback (x_gen W)) ^ 2 • + KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W) := by +- -- Multiply sub-helper 110 by Den² and use sub-helper 128. ++ -- Multiply the x-coordinate differential by Den² and substitute the slope derivative. + rw [kaehler_D_addPullback_x_negFrobenius W p, smul_sub, smul_smul] + rw [mul_comm ((x_gen W - (negFrobeniusIsog W).pullback (x_gen W)) ^ 2) + (2 * addSlope W (negFrobeniusIsog W) + algebraMap K KE W.a₁)] + rw [← smul_smul, kaehler_D_addSlope_negFrobenius W p, smul_sub] + + omit [Fintype K] in +-/-- **Route B core (III.5.2), general cleared form**: combines `kaehler_D_addPullback_x_general` ++/-- **General cleared form**: combines `kaehler_D_addPullback_x_general` + with `kaehler_D_addSlope_general` to clear the `Den²` denominator from `D(addPullback_x)` for + arbitrary `α` (non-doubling). Generalizes `kaehler_D_addPullback_x_negFrobenius_cleared`. -/ + theorem kaehler_D_addPullback_x_general_cleared +@@ -3004,8 +2795,9 @@ theorem kaehler_D_x_gen_eq_u_smul_omega : + (u_gen W)⁻¹ • KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W) from rfl, + smul_smul, mul_inv_cancel₀ (u_gen_ne_zero W), one_smul] + ++omit [Fintype K] [DecidableEq K] in + /-- **RB-ω2 leaf**: `D(y_gen) = (3x²+2a₂x+a₄−a₁y) • ω`. From the curve-equation differential +-`u_gen·D(y) = (3x²+2a₂x+a₄−a₁y)·D(x)` (Sub-helper 121 chain) and `D(x) = u_gen·ω` (RB-ω1), ++`u_gen·D(y) = (3x²+2a₂x+a₄−a₁y)·D(x)` from the differentiated curve equation and `D(x) = u_gen·ω` , + dividing through by `u_gen ≠ 0`. Silverman III.5: the relation `(2y+a₁x+a₃)dy = + (3x²+2a₂x+a₄−a₁y)dx` from differentiating the Weierstrass equation. -/ + theorem kaehler_D_y_gen_eq_num_smul_omega : +@@ -3032,7 +2824,7 @@ omit [Fintype K] in + /-- **RB-ω3 leaf** (α-image differentials): for the omega coefficient + `a_α = omegaPullbackCoeff W α`, `D(α*x) = (α*u)·a_α·ω` and `D(α*y) = (α*num)·a_α·ω`. From + `omegaPullbackCoeff_spec` (`a_α•ω = (α*u)⁻¹•D(α*x)`) and the α-image curve-equation differential +-(Sub-helper 121 at the pulled-back point `(α*x, α*y)`, also on the curve by `pullback_equation`). -/ ++(the differentiated curve equation at the pulled-back point `(α*x, α*y)`, also on the curve by `pullback_equation`). -/ + theorem kaehler_D_alpha_pullback_x_eq_smul_omega + (α : Isogeny W.toAffine W.toAffine) : + KaehlerDifferential.D K W.toAffine.FunctionField (α.pullback (x_gen W)) = +@@ -3049,6 +2841,7 @@ theorem kaehler_D_alpha_pullback_x_eq_smul_omega + rw [hspec, smul_smul, mul_inv_cancel₀ h_au_ne, one_smul] + rw [← key, smul_smul] + ++omit [Fintype K] in + /-- **RB-ω3b leaf** (α-image `D(y)`): `D(α*y) = (α*num)·a_α·ω`. From the α-image curve-equation + differential (apply `Isogeny.pullbackKaehler` to `kaehler_curve_equation_K_E` — `pullbackKaehler` is + α-semilinear and sends `D g ↦ D(α*g)`) + `kaehler_D_alpha_pullback_x_eq_smul_omega` (RB-ω3a), cancel +@@ -3094,6 +2887,7 @@ theorem kaehler_D_alpha_pullback_y_eq_smul_omega + congr 1 + ring + ++omit [Fintype K] in + /-- **RB-ω4 leaf (the III.5.2 ring collapse)**: for genuine α (x≠α*x), the differential of the + addition-pullback x-coordinate equals `addPullback_u • (1 + a_α) • ω`, where + `addPullback_u = 2·addPullback_y + a₁·addPullback_x + a₃` is the u-coordinate at the sum point. +@@ -3151,23 +2945,11 @@ theorem kaehler_D_addPullback_x_eq_one_add_smul_omega + (-(2 * (Y - PY) + c1 * (X - PX)) * (1 - omegaPullbackCoeff W α)) * hP + + ((2 * (Y - PY) + c1 * (X - PX)) * (1 - omegaPullbackCoeff W α)) * hαP + +-/-- **Sub-helper 130** (D(addSlope) reduced to D(x_gen) via curve equation, axiom-clean): +- +-Combines sub-helper 127 (curve equation Kähler identity) with sub-helper 128 +-(D(slope) identity) to express D(addSlope) entirely in terms of D(x_gen): +- +-``` +-(u_gen · Den²) • D(addSlope) = (Den · num - u_gen · N) • D(x_gen) +-``` +- +-where: +-- u_gen = a₃ + 2y + a₁x +-- Den = x - π·x +-- N = y - π·y +-- num = 3x² + 2a₂x + a₄ - a₁y +- +-Substantive K(E) Kähler identity — combines axiom-clean Path A sub-helpers +-127 + 128. Foundational for ω(γ) = 1 via the Kähler-witness route. -/ ++/-- The differential of the addition slope satisfies ++`(u · Den²) • D(ℓ) = (Den · num - u · N) • D(x)`, where ++`u = a₃ + 2y + a₁x`, `num = 3x² + 2a₂x + a₄ - a₁y`, ++`Den = x - (-π)*x`, and `N = y - (-π)*y`. ++This combines the quotient rule with the differentiated curve equation. -/ + theorem kaehler_D_addSlope_via_curve_equation_negFrobenius + (p : ℕ) [Fact p.Prime] [CharP K p] : + ((algebraMap K KE W.a₃ + (2 : KE) * y_gen W + +@@ -3184,7 +2966,7 @@ theorem kaehler_D_addSlope_via_curve_equation_negFrobenius + algebraMap K KE W.a₁ * x_gen W) * + (y_gen W - (negFrobeniusIsog W).pullback (y_gen W))) • + KaehlerDifferential.D K W.toAffine.FunctionField (x_gen W) := by +- -- Multiply sub-helper 128 by u_gen' on the left, then substitute via 127. ++ -- Multiply the slope derivative by u, then substitute the differentiated curve equation. + have h_slope := kaehler_D_addSlope_negFrobenius W p + have h_curve := kaehler_curve_equation_K_E W + -- Step 1: multiply h_slope by u_gen' (smul-distribute). +@@ -3203,13 +2985,8 @@ theorem kaehler_D_addSlope_via_curve_equation_negFrobenius + -- Now collect smul forms. + rw [smul_smul, smul_smul, ← sub_smul] + +-/-- **Sub-helper 131** (`alpha_star_u` computed explicitly for γ, axiom-clean): +-the explicit form of `alpha_star_u (isogOneSub_negFrobenius W hq)` in K(E): +-`α*(u) = 2·addPullback_y + a₁·addPullback_x + a₃`. +- +-Direct from `alpha_star_u_eq` + sub-helpers 89b, 89c (axiom-clean +-`γ.pullback x_gen = addPullback_x` and `γ.pullback y_gen = addPullback_y`) +-+ `u_gen` definition. -/ ++/-- For `γ = 1 − π`, the pulled-back differential denominator is ++`α*u = 2·addPullback_y + a₁·addPullback_x + a₃`. -/ + theorem alpha_star_u_isogOneSub_negFrobenius + (hq : 2 ≤ Fintype.card K) : + alpha_star_u W (isogOneSub_negFrobenius W hq) = +@@ -3233,13 +3010,13 @@ theorem alpha_star_u_isogOneSub_negFrobenius + rw [(isogOneSub_negFrobenius W hq).pullback.commutes W.a₁, + (isogOneSub_negFrobenius W hq).pullback.commutes W.a₃] + +-/-- **Sub-helper 132** (α*(u) + u_gen identity in K(E), axiom-clean): ++/-- α*(u) + u_gen identity in K(E): + + `α*(u) + u_gen = -(2ℓ + a₁) · (addPullback_x - x_gen)` in K(E) + + where ℓ = addSlope W (negFrobeniusIsog W). + +-Proof: substitute α*(u) = 2·addPullback_y + a₁·addPullback_x + a₃ (sub-helper 131) ++Proof: substitute α*(u) = 2·addPullback_y + a₁·addPullback_x + a₃ + and addPullback_y via Affine.addY/negY/negAddY definitional unfoldings, + then verify by ring algebra in K(E). + +@@ -3247,8 +3024,7 @@ This is the substantive K(E) identity that simplifies the RHS of the + target Kähler-witness identity to: + `(α*(u) + u_gen) · Den² = -(2ℓ + a₁) · (addPullback_x - x_gen) · Den²`. + +-Combined with sub-helper 130 (LHS reduction), the target K(E) identity +-becomes a sub-divisible polynomial identity. -/ ++Together with the slope derivative formula, this reduces differential additivity to a polynomial identity. -/ + theorem alpha_star_u_plus_u_gen_negFrobenius + (hq : 2 ≤ Fintype.card K) : + alpha_star_u W (isogOneSub_negFrobenius W hq) + u_gen W = +@@ -3266,7 +3042,7 @@ theorem alpha_star_u_plus_u_gen_negFrobenius + rw [h_a1, h_a2, h_a3] + ring + +-/-- **Sub-helper 133** (curve equation for π·(x_gen, y_gen) in K(E), axiom-clean): ++/-- curve equation for π·(x_gen, y_gen) in K(E): + + The π-shifted Weierstrass equation in K(E): + `(π·y)² + a₁(π·x)(π·y) + a₃(π·y) = (π·x)³ + a₂(π·x)² + a₄(π·x) + a₆` +@@ -3274,7 +3050,7 @@ The π-shifted Weierstrass equation in K(E): + where π·x = (negFrob).pullback x_gen, π·y = (negFrob).pullback y_gen. + + Proof: apply `(negFrobeniusIsog W).pullback` (a K-algebra hom) to +-`weierstrass_equation_in_KE` (sub-helper 120). The hom respects + and * ++`weierstrass_equation_in_KE`. The hom respects + and * + and fixes algebraMap-images of K, so the equation transforms term-by-term. -/ + theorem weierstrass_equation_pi_negFrobenius : + (negFrobeniusIsog W).pullback (y_gen W) ^ 2 + +@@ -3296,7 +3072,7 @@ theorem weierstrass_equation_pi_negFrobenius : + AlgHom.commutes (negFrobeniusIsog W).pullback] at h_pi + exact h_pi + +-/-- **Sub-helper 134** (substantive K(E) polynomial identity for III.5.2, axiom-clean): ++/-- substantive K(E) polynomial identity for III.5.2: + + The K(E) ring identity that closes the Kähler-witness route to ω(γ) = 1: + +@@ -3316,7 +3092,7 @@ where: + + Proof: substitute the slope formula `ℓ = (y - π·y)/(x - π·x)` (squared and + multiplied by Den² gives the polynomial form), then close via +-`linear_combination` with the two curve equations (sub-helpers 120 + 133) ++`linear_combination` with the two curve equations + as multipliers. The identity holds because γ = id - π is a curve isogeny, + which respects the curve equation. + +@@ -3342,7 +3118,7 @@ theorem kaehler_witness_polynomial_identity_negFrobenius : + have h_curve_pi := weierstrass_equation_pi_negFrobenius W + linear_combination -h_curve + h_curve_pi + +-/-- **Sub-helper 135** ((addPullback_x - x_gen) · Den² polynomial form, axiom-clean): ++/-- (addPullback_x - x_gen) · Den² polynomial form: + + ``` + (addPullback_x - x_gen) · Den² = +@@ -3355,7 +3131,7 @@ slope formula `ℓ = (y - π·y) / (x - π·x)` giving `ℓ · (x - π·x) = (y + hence `ℓ² · (x - π·x)² = (y - π·y)²` and `ℓ · (x - π·x)² = (y - π·y) · (x - π·x)`. + + Substantive polynomial-form bridge between the slope-divisor identity +-and the curve-equation polynomial identity (sub-helper 134). -/ ++and the curve-equation polynomial identity. -/ + theorem addPullback_x_sub_x_gen_mul_Den_sq_negFrobenius : + (addPullback_x W (negFrobeniusIsog W) - x_gen W) * + (x_gen W - (negFrobeniusIsog W).pullback (x_gen W)) ^ 2 = +@@ -3394,18 +3170,8 @@ theorem addPullback_x_sub_x_gen_mul_Den_sq_negFrobenius : + algebraMap K KE W.a₁ * + (x_gen W - (negFrobeniusIsog W).pullback (x_gen W))) * h_slope_lin + +-/-- **Sub-helper 136** (curve-equation form of K(E) Kähler-witness identity, axiom-clean): +- +-``` +-Den · num - u_gen · N + (addPullback_x - x_gen) · Den² = 0 +-``` +- +-Combines sub-helper 134 (polynomial form identity) with sub-helper 135 +-(`(addPullback_x - x_gen) · Den² = polynomial form`) to give the K(E) +-identity in the form needed by the Kähler-witness consumer. +- +-This is THE identity that closes ω(γ) = 1 / Witness #1 / III.5.2 via +-the Kähler witness route. -/ ++/-- The two curve equations and the addition formula give ++`Den · num - u · N + (addPullback_x - x) · Den² = 0` in the function field. -/ + theorem kaehler_witness_curve_form_negFrobenius : + (x_gen W - (negFrobeniusIsog W).pullback (x_gen W)) * + ((3 : KE) * x_gen W ^ 2 + +@@ -3420,14 +3186,8 @@ theorem kaehler_witness_curve_form_negFrobenius : + rw [addPullback_x_sub_x_gen_mul_Den_sq_negFrobenius W] + exact kaehler_witness_polynomial_identity_negFrobenius W + +-/-- **Sub-helper 137** (K(E) coefficient identity for Kähler witness, axiom-clean): +-the K(E) coefficient identity that closes the Kähler-witness chain: +- +-``` +-(2ℓ + a₁) · (Den · num - u_gen · N) = (α*(u) + u_gen) · Den² +-``` +- +-Combines sub-helpers 132 + 136 axiom-clean. -/ ++/-- The addition formulas and curve equations give the coefficient identity ++`(2ℓ + a₁)(Den · num - u · N) = (α*u + u) · Den²`. -/ + theorem kaehler_witness_coefficient_identity_negFrobenius + (hq : 2 ≤ Fintype.card K) : + ((2 : KE) * addSlope W (negFrobeniusIsog W) + +@@ -3443,7 +3203,7 @@ theorem kaehler_witness_coefficient_identity_negFrobenius + (alpha_star_u W (isogOneSub_negFrobenius W hq) + u_gen W) * + (x_gen W - (negFrobeniusIsog W).pullback (x_gen W)) ^ 2 := by + rw [alpha_star_u_plus_u_gen_negFrobenius W hq] +- -- Use sub-helper 136 (curve-form K(E) identity, axiom-clean): ++ -- The curve-form identity gives: + -- Den·num - u_gen·N + (addPullback_x - x_gen)·Den² = 0. + -- Multiply by (2ℓ+a₁) to get: (2ℓ+a₁)·(Den·num - u_gen·N + (addPullback_x - x_gen)·Den²) = 0. + -- Rearrange to: (2ℓ+a₁)·(Den·num - u_gen·N) = -(2ℓ+a₁)·(addPullback_x - x_gen)·Den². +@@ -3451,16 +3211,9 @@ theorem kaehler_witness_coefficient_identity_negFrobenius + linear_combination + (2 * addSlope W (negFrobeniusIsog W) + algebraMap K KE W.a₁) * h_136 + +-/-- **Sub-helper 138** (ω(γ) = 1 axiom-clean — Witness #1 omega-coefficient). +- +-Instantiates `kaehler_witness_via_slope_deriv_witness` with the explicit +-witness `c := (Den · num - u · N) / (u · Den²)`, where `u = a₃ + 2y + a₁x`, +-`Den = x - π·x`, `N = y - π·y`, `num = 3x² + 2a₂x + a₄ - a₁y`. +- +-The slope-deriv witness `D(addSlope) = c • D(x_gen)` follows from sub-helper +-130 by smul-cancelling `u · Den²`. The K(E) coefficient identity +-`((2ℓ + a₁) · c - 1) · u_gen = α*(u)` follows from sub-helper 137 by +-field-simplification + linear_combination. -/ ++/-- The invariant-differential coefficient of `1 − π` is one. ++The slope derivative has coefficient `c = (Den · num - u · N)/(u · Den²)` relative ++to `D(x)`, and the two curve equations give `((2ℓ + a₁)c - 1)u = α*u`. -/ + theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one + (p : ℕ) [Fact p.Prime] [CharP K p] + (hq : 2 ≤ Fintype.card K) : +@@ -3496,11 +3249,8 @@ theorem omegaPullbackCoeff_isogOneSub_negFrobenius_eq_one + sub_eq_iff_eq_add, div_eq_iff huDen_ne] + linear_combination u * h_137 + +-/-- **Sub-helper 139** (Witness #1 axiom-clean — IsSeparable γ). +- +-Composes sub-helper 138 (ω(γ) = 1 axiom-clean) with +-`isogOneSub_negFrobenius_isSeparable_of_h_coeff_only` (T-II-4-004 absorbed, +-axiom-clean) to produce the unconditional Witness #1 of the Hasse-Weil bound. -/ ++/-- The isogeny `1 − π` is separable, because its invariant-differential coefficient ++is one. -/ + theorem isogOneSub_negFrobenius_isSeparable + (p : ℕ) [Fact p.Prime] [CharP K p] + (hq : 2 ≤ Fintype.card K) : +@@ -3607,7 +3357,7 @@ rule (`kaehler_D_addSlopePair_clearDenomSq`) with the `addX` Leibniz expansion + (`kaehler_D_addPullback_x_pair_via_slope`) into a single denominator-free expression for + `(X₁ - X₂)² • D(addPullback_x_pair)`. A leaf of + `kaehler_D_addPullback_x_pair_eq_smul_omega`. -/ +-private theorem kaehler_D_addPullback_x_pair_clearDenomSq ++theorem kaehler_D_addPullback_x_pair_clearDenomSq + (α₁ α₂ : Isogeny W.toAffine W.toAffine) + (h_ne : α₁.pullback (x_gen W) ≠ α₂.pullback (x_gen W)) : + (α₁.pullback (x_gen W) - α₂.pullback (x_gen W)) ^ 2 • +@@ -3641,7 +3391,7 @@ unfolding `addPullback_x/y_pair` and `alpha_star_u`, substituting the two pullba + equations (`pullback_equation α₁/α₂`), clearing the denominator, and closing with the free-variable + algebra core `kaehler_D_addPullback_x_pair_ring_identity`. The scalar half of + `kaehler_D_addPullback_x_pair_eq_smul_omega`. -/ +-private theorem kaehler_D_addPullback_x_pair_coeff_collapse ++theorem kaehler_D_addPullback_x_pair_coeff_collapse + (α₁ α₂ : Isogeny W.toAffine W.toAffine) + (h_ne : α₁.pullback (x_gen W) ≠ α₂.pullback (x_gen W)) : + (2 * addSlopePair α₁ α₂ + algebraMap K KE W.a₁) * +@@ -3691,6 +3441,7 @@ private theorem kaehler_D_addPullback_x_pair_coeff_collapse + (omegaPullbackCoeff W α₁) (omegaPullbackCoeff W α₂) (algebraMap K KE W.a₂) + (algebraMap K KE W.a₃) (algebraMap K KE W.a₄) (algebraMap K KE W.a₆) hα₁ hα₂ + ++omit [Fintype K] in + /-- **General-pair III.5.2 differential collapse**: for genuine pairs (`α₁*x ≠ α₂*x`), the + differential of the pair addition `x`-coordinate is + `u₃ • ((a_{α₁} + a_{α₂}) • ω)`, where `u₃ = 2·addPullback_y_pair + a₁·addPullback_x_pair + a₃` +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/DiffQuotientRule.lean b/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/DiffQuotientRule.lean +index 218313002..5de8144cd 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/DiffQuotientRule.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/DiffQuotientRule.lean +@@ -22,6 +22,7 @@ variable (E : Affine F) [E.IsElliptic] + local notation "KE" => E.FunctionField + + omit [DecidableEq F] in ++omit [WeierstrassCurve.IsElliptic E] in + /-- `D(f⁻¹) = -f⁻² • D(f)` for nonzero `f ∈ K(E)`. -/ + theorem D_inv_smul (f : KE) (hf : f ≠ 0) : + KaehlerDifferential.D F KE f⁻¹ = +@@ -36,7 +37,7 @@ theorem D_inv_smul (f : KE) (hf : f ≠ 0) : + _ = f⁻¹ • (-(f⁻¹ • D f)) := by rw [h3] + _ = -(f⁻¹ ^ 2 • D f) := by rw [smul_neg, smul_smul, ← sq] + +-omit [DecidableEq F] in ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic E] in + /-- `D(f * g⁻¹) = g⁻¹ • D(f) + (stuff involving D(g))`. Leibniz + inverse rule. -/ + theorem D_mul_inv_smul (f g : KE) (hg : g ≠ 0) : + KaehlerDifferential.D F KE (f * g⁻¹) = +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/EllipticDivisibilitySequence.lean b/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/EllipticDivisibilitySequence.lean +index b07632812..bf6d0816a 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/EllipticDivisibilitySequence.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Auxiliary/EllipticDivisibilitySequence.lean +@@ -12,21 +12,6 @@ import Mathlib.NumberTheory.EllipticDivisibilitySequence + import Mathlib.Tactic.IntervalCases + import Mathlib.Tactic.LinearCombination + +-/-! +-# Additional lemmas for elliptic divisibility sequences +- +-This file provides definitions and lemmas about normalised elliptic divisibility sequences +-that are not yet in mathlib. These are needed for the division polynomial / ZSMul development. +- +-The key results are: +-* `IsEllipticSequence.normEDS`: a normalised EDS is an elliptic sequence. +-* `IsEllipticSequence.ext`: two elliptic sequences with the same first four terms are equal. +-* `normEDS_two_three_two`: when `b = 2, c = 3, d = 2`, the normalised EDS is the identity. +-* `complEDSAux₂`: auxiliary complement used in the `ω` definition. +-* `redInvarDenom`, `redInvarNum`: reduced invariant decomposition. +- +-Ported from the LutzNagell project (`LutzNagell/EllipticDivisibilitySequence.lean`). +--/ + + open scoped nonZeroDivisors + +@@ -417,12 +402,12 @@ theorem rel₄_of_anti_oddRec_evenRec (one : W 1 ∈ R⁰) (two : W 2 ∈ R⁰) + linarith only [hba] + obtain ⟨m, rfl|rfl⟩ := b.even_or_odd' + · have ea : Even a := by rw [← ha']; exact (even_two_mul _).add even_two +- simp_rw [cMin, dMin, if_pos ea] ++ simp_rw [cMin, dMin, ite_eq_left ea] + convert (rel₃_iff₄ W (m + 1) m 1).mp ((rel₃_iff_oddRec W m).mpr <| oddRec _ ?_) using 2 + all_goals linarith only [h6, ha'] + · have nea : ¬ Even a := by + rw [← ha', not_even_iff_odd]; convert odd_two_mul_add_one (m + 1) using 1; ring +- simp_rw [cMin, dMin, if_neg nea] ++ simp_rw [cMin, dMin, ite_eq_right nea] + convert (rel₄_iff_evenRec W (m + 1)).mpr (evenRec _ ?_) using 2 + all_goals linarith only [h6, ha'] + +@@ -623,9 +608,9 @@ lemma invarDenom_normEDS_two : + simp [EllSequence.invarDenom] + + lemma normEDS_six_eq_mul : normEDS b c d 6 = (normEDS b c d 5 - d ^ 2) * b * c := by +- rw [show (6 : ℤ) = 2 * 3 by rfl, ← normEDS_mul_complEDS₂, complEDS₂, if_neg (by decide)] ++ rw [show (6 : ℤ) = 2 * 3 by rfl, ← normEDS_mul_complEDS₂, complEDS₂, ite_eq_right (by decide)] + simp_rw [Int.reduceAdd, Int.reduceSub, normEDS_three, normEDS] +- rw [preNormEDS_one, preNormEDS_two, preNormEDS_four, if_neg (by decide)] ++ rw [preNormEDS_one, preNormEDS_two, preNormEDS_four, ite_eq_right (by decide)] + ring + + end NormEDSLemmas +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Basic.lean b/projects/HasseWeil/HasseWeil/Foundation/Basic.lean +index b2c035a234ea01cc215b69064d795adea7e2c888..31b9bd23d3724605cf874fab7e45adf87d019f61 100644 +GIT binary patch +delta 149 +zcmbPop6UH6rVT$CCl|9>Y+k}C%(OXyr;2fNDc?hu$>G9oljni4;^dor0+Yo=6egRC +zv~1oZGLdKV1C51(j9inqSSoH#v0iP*%B8ETkT5y1LUD3$)xyn<)vAn>m)E3j=B;(* +z0x}dQm$b`I=B?G7yrIiz^ZWK@=FQ8yrCGR3QsYw#7%Q6xKL#el{&hlaS!J&=&}hShiD#91=AxstSRUrY%Y-qEZ!)y<=zSdS^Sk +zwv%v3kOHd20ii82Q2rziQ6*4IS7-%-OAq{r1CRq!PlbRKQ9w$l1ch>7b{xkct$o_r +zH}k&t-Z$TSv+z~D`%(SHIy7ejwt$)}P4pQsvYM8_$y27H9GfDbu_V@jOdD7?Dbr10 +zDX@e+ImNgdv9K +zJuUO48AGE_Tr0B9NNQ_rYHAnT-R^F{+xN(i|1Fq`fK#2317M +zVTNDH@B$Bv*1d7zV?LLM%4C +zJa5Mab~`ULkN6u|YEoy`ILSDlxBpxp@I;ZK(?pFJj0#C?NXEIa^E&F3+foUzk)9BP +zvv^NKO)bk%tAO7^J+|BZO%p8DtY>p(AG-?_R$UIxDm)u0DR02V5(d#ZNdoa{A=TM_(O}k;Xxa3X4I^Fl4;MS^ulF?BpIvWvzMOnR +z>8cnsY=4^A=`1|k)nFf4xy$~xq0Twa2k%?|X|V5KZGP|XSKIowCL%j?qr=Nwm<~FB +zV4raBtPwrnjIX@nt0<;Ryjusf5Clt*G6-u^k<) +zsS0>_2O30$4_i=&4|)sTZK%zCrxjf-n%o!L(bD=d-hra18dTwIC;Gh*3?NIwxrG4w +zwZ58zd!`$m^H)95_aK_Ct9oKFg5FiCo){lO{}xFtzBvDzGtduldo9@Jo_P!{*EEsS +zS*%6Gb3%B*7(+u6c-@WaIl@h{F+AN5#t=fSWx simp + | tmul x y => simp [KaehlerDifferential.mapBaseChange_tmul, h_map_zero] + | add x y hx hy => simp [map_add, hx, hy] + +-/-- **T-II-4-004 forward direction (axiom-clean)**: if `α` is separable, +-then `omegaPullbackCoeff W α ≠ 0`. +- +-Pipeline: `IsSeparable → Subsingleton Ω[K(E)/K(E)_α]` → +-`mapBaseChange surjective` (via the type synonym) → in particular, +-`invariantDifferential ∈ image(mapBaseChange)` (cotangent exact sequence). +-A nonzero image element forces `α.pullbackKaehler` not-identically-zero, +-which (with the 1-dim Ω structure) forces `omegaPullbackCoeff ≠ 0`. -/ + theorem isogeny_omegaCoeff_ne_zero_of_isSeparable + (α : Isogeny W.toAffine W.toAffine) + (h_sep : α.IsSeparable) : +@@ -761,7 +556,7 @@ theorem isogeny_omegaCoeff_ne_zero_of_isSeparable + have h_pK_zero : ∀ ω' : Ω[W.toAffine.FunctionField⁄F], + α.pullbackKaehler ω' = 0 := + pullbackKaehler_eq_zero_of_omegaPullbackCoeff_eq_zero W α h_zero +- haveI : Subsingleton (Ω[W.toAffine.FunctionField⁄IsogenyAlgebraSource W α]) := ++ have : Subsingleton (Ω[W.toAffine.FunctionField⁄IsogenyAlgebraSource W α]) := + (isogeny_subsingleton_via_synonym_eq W α).mpr + (isogeny_subsingleton_kaehler_of_isSeparable W α h_sep) + have h_surj : Function.Surjective (KaehlerDifferential.mapBaseChange F +@@ -779,12 +574,6 @@ theorem isogeny_omegaCoeff_ne_zero_of_isSeparable + rw [h_mbc_zero, LinearMap.zero_apply] at ht + exact (invariantDifferential_ne_zero W.toAffine) ht.symm + +-/-- **T-II-4-004 reverse direction (witness-parametric on FiniteDim only, +-axiom-clean)**: if `omegaPullbackCoeff W α ≠ 0` and `K(E)` is finite-dimensional +-over `K(E)_α` (Witness #2), then `α` is separable. +- +-Combines the cotangent-sequence bridge (omega-coeff ≠ 0 → Subsingleton) with the +-algebra-Kähler reverse direction (Subsingleton + FiniteDim → IsSeparable). -/ + theorem isogeny_isSeparable_of_omegaCoeff_ne_zero_finiteDim + (α : Isogeny W.toAffine W.toAffine) + (h_coeff : omegaPullbackCoeff W α ≠ 0) +@@ -796,14 +585,6 @@ theorem isogeny_isSeparable_of_omegaCoeff_ne_zero_finiteDim + (isogeny_subsingleton_kaehler_of_omegaCoeff_ne_zero W α h_coeff)) + h_fin + +-/-- **T-II-4-004 full iff (witness-parametric on FiniteDim only, axiom-clean)**: +-the deliverable iff `α.IsSeparable ↔ omegaPullbackCoeff W α ≠ 0` modulo only +-the Witness #2 hypothesis (FiniteDimensional). +- +-Combines the forward direction (no extra hypothesis) and the reverse direction +-(needs FiniteDim). +- +-Once Witness #2 discharges unconditionally, the full T-II-4-004 lands. -/ + theorem isSeparable_iff_omegaPullbackCoeff_ne_zero_of_finiteDim + (α : Isogeny W.toAffine W.toAffine) + (h_fin : @FiniteDimensional W.toAffine.FunctionField W.toAffine.FunctionField +@@ -812,16 +593,6 @@ theorem isSeparable_iff_omegaPullbackCoeff_ne_zero_of_finiteDim + ⟨isogeny_omegaCoeff_ne_zero_of_isSeparable W α, + fun h ↦ isogeny_isSeparable_of_omegaCoeff_ne_zero_finiteDim W α h h_fin⟩ + +-/-- **T-II-4-004 reverse direction (axiom-clean, unconditional)**: if the +-differential pullback `α.pullbackKaehler` is injective on `Ω[K(E)/F]`, then `α` +-is separable. +- +-Discharge path: +-* Witness #2 (`FiniteDimensional` of `K(E)/(image)`) — gives `EssFiniteType`. +-* Connection from `omegaPullbackCoeff ≠ 0` (the scalar form of injectivity) +- to `Subsingleton Ω[K(E)/(image)]` (the algebra-side condition). +-* Mathlib's `Algebra.FormallyUnramified.iff_isSeparable` for the final +- conclusion. -/ + theorem isogeny_isSeparable_of_pullbackKaehler_injective + (α : Isogeny W.toAffine W.toAffine) + (h_inj : Function.Injective α.pullbackKaehler) : +@@ -830,14 +601,6 @@ theorem isogeny_isSeparable_of_pullbackKaehler_injective + ((pullbackKaehler_injective_iff_omegaPullbackCoeff_ne_zero W α).mp h_inj) + (isogeny_finiteDimensional W α) + +-/-- **T-II-4-004 algebra-Kähler half (axiom-clean)**: an isogeny `α` is separable +-(in the `Algebra.IsSeparable` sense) iff its differential pullback +-`α.pullbackKaehler` is injective on `Ω[K(E)/F]`. +- +-This is the substantive Silverman II.4.2(c) algebra-Kähler glue. +-The forward direction: `Algebra.IsSeparable → FormallyUnramified +-→ Ω[K(E)/(image)] = 0 → cotangent surjective → pullbackKaehler injective`. +-The reverse: the converse chain via `FormallyUnramified.iff_isSeparable`. -/ + theorem isSeparable_iff_pullbackKaehler_injective + (α : Isogeny W.toAffine W.toAffine) : + α.IsSeparable ↔ Function.Injective α.pullbackKaehler := +@@ -845,12 +608,6 @@ theorem isSeparable_iff_pullbackKaehler_injective + (isogeny_omegaCoeff_ne_zero_of_isSeparable W α h), + isogeny_isSeparable_of_pullbackKaehler_injective W α⟩ + +-/-- **T-II-4-004 (elliptic curve form, deliverable target)**: separability of +-an isogeny `α` is equivalent to its omega-pullback coefficient being nonzero +-(equivalently, to the differential pullback `α*` being injective on +-`Ω[K(E)/F]`). +- +-Reference: Silverman II.4.2(c). -/ + theorem isSeparable_iff_omegaPullbackCoeff_ne_zero + (α : Isogeny W.toAffine W.toAffine) : + α.IsSeparable ↔ omegaPullbackCoeff W α ≠ 0 := +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/Divisors.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/Divisors.lean +index 272a5d45e..77de07569 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/Divisors.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/Divisors.lean +@@ -16,9 +16,6 @@ The divisor group `Div C` of a smooth plane curve `C` is the free abelian group + on its smooth points: a formal sum `Σ nₚ (P)` with integer coefficients that + are zero for all but finitely many points. + +-This closes tickets `T-II-3-001` (`Divisor`) and `T-II-3-002` +-(`Divisor.degree`, `Divisor.degreeHom`). +- + ## References + + * [Silverman, *The Arithmetic of Elliptic Curves*], II.3 (definition) +@@ -95,7 +92,7 @@ end Divisor + noncomputable abbrev Divisor₀ (C : SmoothPlaneCurve F) : AddSubgroup (Divisor C) := + Divisor.degZero C + +-/-! ### `divisorOf f`: the principal divisor (T-II-3-005) -/ ++ + + namespace SmoothPlaneCurve + +@@ -116,7 +113,7 @@ noncomputable def divisorOf (C : SmoothPlaneCurve F) (f : C.FunctionField) : + rw [this]; exact Set.finite_empty + · refine (C.finite_setOf_ord_P_nonzero hf).subset ?_ + intro P hP +- simp only [Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq] + intro h0 + apply hP + simp [h0] +@@ -184,7 +181,7 @@ noncomputable def divisorHom (C : SmoothPlaneCurve F) : + congr 1 + exact C.divisorOf_mul u.ne_zero v.ne_zero + +-/-! ### Principal divisors and linear equivalence (T-II-3-006) -/ ++ + + /-- A divisor `D` on `C` is **principal** if `D = div(f)` for some nonzero + rational function `f ∈ F(C)`. Equivalently, `D` lies in the image of the +@@ -244,7 +241,7 @@ theorem LinearlyEquiv.trans {C : SmoothPlaneCurve F} {D₁ D₂ D₃ : Divisor C + rw [show D₁ - D₃ = (D₁ - D₂) + (D₂ - D₃) by abel] + exact h₁.add h₂ + +-/-! ### T-II-3-008: constants have zero divisor -/ ++ + + /-- `ord_P` of an `F`-constant `c ≠ 0` is zero: a nonzero constant is a unit + at every smooth point (image of the F-subfield, which lives in the local +@@ -289,15 +286,11 @@ zeros or poles. -/ + refine Finsupp.ext fun P ↦ ?_ + rw [divisorOf_apply, C.ord_P_algebraMap_F_of_ne_zero hc P]; rfl + +-/-! ### T-II-3-008 (⇒): `divisorOf = 0 ⇒ const` (prime-indexed via IC-006) -/ + +-/-- **T-II-3-008 (⇒), prime-indexed**: if `f ∈ F(C)` has valuation at most 1 +-at every nonzero prime of `C.CoordinateRing` **and** has nonnegative order at +-infinity, then `f` is the image of a constant from `F`. This is the content +-of Silverman II.3.1(a) `⇒` in the prime-indexed reformulation made available +-by IC-006; the SmoothPoint-indexed statement follows once every nonzero +-prime is in the image of `SmoothPoint.toHeightOneSpectrum` (the surjection +-step under `[IsAlgClosed F]`, tracked separately). -/ ++ ++/-- If a function has valuation at most one at every nonzero prime of the ++coordinate ring and has nonnegative order at infinity, it is constant. ++This is the prime-indexed form of Silverman II.3.1(a). -/ + theorem const_of_valuation_le_one_of_ordAtInfty_nonneg + [IsIntegrallyClosed C.CoordinateRing] (f : C.FunctionField) + (h_primes : ∀ v : IsDedekindDomain.HeightOneSpectrum C.CoordinateRing, +@@ -306,7 +299,7 @@ theorem const_of_valuation_le_one_of_ordAtInfty_nonneg + ∃ c : F, f = algebraMap F C.FunctionField c := + C.const_of_no_poles_of_valuation_of_ordAtInfty f h_primes h_inf + +-/-! ### Pic and Pic₀ (T-II-3-007) -/ ++ + + /-- The **Picard group** of `C`: divisors modulo principal divisors. + Silverman II.3 (definition). -/ +@@ -314,8 +307,7 @@ abbrev Pic (C : SmoothPlaneCurve F) : Type _ := + Divisor C ⧸ C.principalSubgroup + + /-- The **degree-zero Picard group** `Pic⁰(C)`: degree-zero divisors modulo +-principal divisors (principal divisors automatically have degree zero by +-Silverman II.3.1(b), tracked as T-II-3-009). -/ ++principal divisors (principal divisors have degree zero by Silverman II.3.1(b)). -/ + abbrev Pic₀ (C : SmoothPlaneCurve F) : Type _ := + (Divisor.degZero C) ⧸ (C.principalSubgroup.addSubgroupOf (Divisor.degZero C)) + +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/EffectiveSumReduce.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/EffectiveSumReduce.lean +index 03a560829..5a38ff39d 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/EffectiveSumReduce.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/EffectiveSumReduce.lean +@@ -92,6 +92,7 @@ omit [W.IsElliptic] in + @[simp] theorem listSum_cons (P : W.Point) (Ps : List W.Point) : + listSum W (P :: Ps) = P + listSum W Ps := rfl + ++omit [W.IsElliptic] in + /-- σ on the list-divisor equals the list sum. -/ + theorem projectiveDivisorSum_listToDivisor (Ps : List W.Point) : + projectiveDivisorSum W (listToDivisor W Ps) = listSum W Ps := by +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/Miller.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/Miller.lean +index 0cca33fbbad2caeffd72dbaa7a093fb8e19faddd..746ea1a153571d3a8d47b2d1a9b99a29dd929f72 100644 +GIT binary patch +delta 2890 +zcmai0+iw(A7|&@5mm#SrY$F%pD^_fEce%8PDFKAE)EdohfrOw5%<0V8og*{n3^TJ^ +zN@5nGCK^qMjyN$<6Z``Vu_XJVk!XDIi4dMmOcUdS58{LRz>D8GGuxe(Hok2;=X|%{ +zi?0$z;a|@gA9y_iaHY!xLh#&639l~$poK~mO*-S`}3w0128iLK6JjCo~77Z^B +zm9pRI{R8TLn!}_6iH6 +znpAxKiT>DIx4y+$ST>AtRu32}>91KuAy`s`>{0_GxpNROyJ6v6B$z{Y-yTm(QSX+DxO}#=EgT~Z;e~Gx988rw6ZOE562E +zmj%y;I2o5lT#7Lqc7U^;!*+@=4P$V&TvhZm7unca&c?G26TomVETeM9N`rR*)SO8< +z0!=D-=&gQ3c^M#? +zR*^ycVejUC<1}M%n!A|SqawrSVEp)oEy?B0WK&Y#LEf4F{ojjEubIFjN#A}lnC#y~ +zwzUlNA{Ir*v%WN;um>F9GIA-}Bc(D{**TUfDImo(-BGqEJ-4H!l&cDoGL-hJ6Ea|) +z`uaMu{}i*^=Xa2|2&p9f17x&i^O|N_q*Y=Z&_*(nPBaC15#l21>Jg!I(-qZKL&#E% +z3m&nOFI|+YA4ng8nL~jh5Xg?>C#QtpK-W5JB9Mf|H_bvpDTl&1v)M(CMrKQoa?w7t +zi%b%7Ci!U(89W9lDQbu%CIaTV+(*2@Y6MND@N^80QS&9Dt|+=&9Z~d?EdylF5yNt5 +zK&^-cJXDvLb`M$iWmpN?(F7*R&i0kvWFu*v(Pq}2Mm|-heV9RzN|+Fh)m~mNS``|f +zCj;NXGSF94?YdBPJM#>QywTLAZk^2pRIwXJXt^>e50DLMJ@*F5!!^2|uI*$2ifCdD +z5n=Wf+y~R3iFQ_lfjGU%tcc?*GYeF_Qrd(ERhNTDaN8mz#D(tT(otszoK +z&YvUelj|k&u&gwvMn%=G`@a}ra_?nQ*kvdSQ$Q>&qeb|YTm(TqhM;9(bLc*TN&D~pq%VbXksF~0Gc1~AXn1P4tBygfe|11p +z$jDJhuc2k^TZP}+FGTyh7f26j9T$kdL~p^;QE;}+H8+qZO%$T7`|%s0gCm<&BJ%?l +zGE`#jxnX21LGM-AE^`xYH2Hp(aH^#YtRwk3?Q=^Nj}HO0QL$%S{`oL@C5G90Hu9Bf +zt8q|!sro{1rE&C*mS1e28zbNJK0Q@KU(Q3UpISrHIna}@j*@3il#RSybCK#vy+e?M +zYB^y?h|KbpF|xSQN897a$QRW?HLax-R7&XVzf=-2y|ZOs<}~PP=__u@`oh_y>noa- +znIXhCuWoOnmJ3HH--XKr)wkj$4EQwjv9B`(Vz);{Za3G{)54jxI5qP+c8KGcbv>>=XJ28v$$=Sfk +z(+Ii;C!of*Ay!gvUVt(e|6fjgZy-wM<1FQFU!21V6rlU-5Q^CC{%D&8>C_9gi?Jt{ +zQV*3WLY5Lg#k;=47}#bp2i@O?V6Nrt*q9-3C;}x@*MX#niye+U*vB7uCEmy|dA?Pq +zq!vnd=29GTOadUKc#nKv4P3*mQF(HY^PT4FgZy<~)<5UKGRMh-uR(O=b +z#tz^>z!2+$oe>=?E&dMO>1tZ-S4mw~{$*NR4mbPYXT;BuKYj6EMsH2cZVa)o^g7zi +zQ3epmfM^q(#{M3&jNiO + +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/ProjectiveDivisor.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/ProjectiveDivisor.lean +index 42df6e4ba..40dbf3639 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/ProjectiveDivisor.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/ProjectiveDivisor.lean +@@ -233,7 +233,7 @@ theorem projectiveDivisorOf_apply_affine (f : C.FunctionField) (P : C.SmoothPoin + (ProjectiveSmoothPoint.infinity : ProjectiveSmoothPoint C) := by + intro h; nomatch h + rw [Finsupp.add_apply, Finsupp.single_eq_of_ne h_ne, add_zero, +- Finsupp.mapDomain_apply ProjectiveSmoothPoint.affine_injective ++ Finsupp.mapDomain_apply_of_injective ProjectiveSmoothPoint.affine_injective + (C.divisorOf f) P, C.divisorOf_apply] + + theorem projectiveDivisorOf_apply_infinity (f : C.FunctionField) : +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/PushforwardDivisor.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/PushforwardDivisor.lean +index 37f06f385..9d556ad1d 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/PushforwardDivisor.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Divisor/PushforwardDivisor.lean +@@ -8,40 +8,17 @@ import HasseWeil.Foundation.Curves.Map.CoordHomFinite + import HasseWeil.Foundation.Curves.Valuation.NormValuation + + /-! +-# The divisor pushforward of a finite curve map preserves principal divisors ++# Divisor pushforward and principal divisors + +-For a (nonconstant) curve map `φ : C₁ → C₂` between smooth plane curves, the +-**divisor pushforward** `φ_∗ : Div(C₁) → Div(C₂)` sends `Σ nᵢ (Pᵢ)` to +-`Σ nᵢ (φ Pᵢ)`. Silverman II.3.6 / II.3.7 says it carries *principal* divisors +-to *principal* divisors, via the **norm–conorm identity** ++For a finite curve map `φ : C₁ → C₂` over an algebraically closed field, the ++divisor pushforward sends `Σ nᵢ(Pᵢ)` to `Σ nᵢ(φ(Pᵢ))`. The norm–conorm identity ++`div(N_φ f) = φ_∗(div f)` shows that principal divisors remain principal. ++Here `N_φ` is the field norm from `K(C₁)` to `φ*K(C₂)`. + +- `div(N_φ f) = φ_∗(div f)` (Silverman II.3.6) +- +-where `N_φ f = Norm_{K(C₁)/φ*K(C₂)}(f) ∈ K(C₂)` is the field norm (already +-defined as `CurveMap.pushforward`). This is the only deep input to Silverman +-III.4.8 (every isogeny is a group homomorphism, proved at the divisor/σ level in +-`HasseWeil/EC/IsogenyAG/GroupHom.lean`). +- +-## The valuation-theoretic pushforward +- +-We realise the divisor pushforward as `Finsupp.mapDomain` along the place-image +-map `P ↦ φ(P)` (affine smooth point `↦` affine smooth point, `∞ ↦ ∞`), supplied +-by a coordinate-ring witness `cd : φ.CoordHom`. This is definitionally the +-point-map pushforward `pushforwardProjectiveDivisor`, so the compatibility +-sub-leaf NEW-1(iii) is `rfl`; the mathematical content is concentrated in the +-norm–conorm identity NEW-1(ii). +- +-## Main definitions +- +-* `CurveMap.pushforwardDivisorVal` — the valuation-theoretic divisor pushforward +- (= `pushforwardProjectiveDivisor`, via the place-image map). +- +-## Main results +- +-* `CurveMap.projectiveDivisorOf_pushforward_eq_pushforwardDivisorVal` — the +- norm–conorm identity `div(N_φ f) = φ_∗(div f)` (Silverman II.3.6). +-* `EC.Isogeny.pushforward_preserves_principal` — the gap `h_pres`: the +- pushforward of a principal projective divisor is principal (Silverman II.3.7). ++The pushforward is realized by `Finsupp.mapDomain` along the projective ++place-image map. Its coefficients are sums over the fibres. The local ++norm formula, together with residue degree one, identifies these coefficients ++with the orders of the norm. + + ## References + +@@ -50,7 +27,6 @@ norm–conorm identity NEW-1(ii). + + open WeierstrassCurve + +-set_option linter.unusedSectionVars false + + namespace HasseWeil.Curves.CurveMap + +@@ -58,7 +34,7 @@ variable {F : Type*} [Field F] + variable {C₁ C₂ : SmoothPlaneCurve F} + [C₁.toAffine.IsElliptic] [C₂.toAffine.IsElliptic] + +-/-! ### NEW-1(i): the valuation-theoretic divisor pushforward -/ ++/-! ### the valuation-theoretic divisor pushforward -/ + + /-- The place-image map on the projective closure induced by a curve map `φ` + together with a coordinate-ring witness: an affine smooth point `P` is sent to +@@ -96,7 +72,7 @@ theorem degree_pushforwardDivisorVal (φ : CurveMap C₁ C₂) (cd : φ.CoordHom + simp only [ProjectiveDivisor.degree] + rw [Finsupp.sum_mapDomain_index (h := fun _ n ↦ n) (fun _ ↦ rfl) (fun _ _ _ ↦ rfl)] + +-/-! ### NEW-1(ii): the norm–conorm identity `div(N_φ f) = φ_∗(div f)` ++/-! ### the norm–conorm identity `div(N_φ f) = φ_∗(div f)` + + The mathematical content is the per-place identity (Silverman II.3.6) + +@@ -107,7 +83,7 @@ by generalising the `F[X] → F[C]` machinery of `NormValuation.lean` to the + coordinate-ring extension `F[C₂] → F[C₁]` supplied by a `CoordHom`. The generic + ideal/localisation lemmas (`count_preservation_localization`, + `count_finset_prod_factors`, `map_eq_localRing_max_pow_count`, …) are reused +-verbatim; the curve-specific inputs are `inertiaDeg' = 1`, `relNorm m_P = m_{φP}`, ++verbatim; the curve-specific inputs are `inertiaDeg = 1`, `relNorm m_P = m_{φP}`, + and the fibre bijection `maximalIdealAt_toPointMap`. -/ + + section NormConorm +@@ -129,8 +105,8 @@ theorem coordHom_injective : Function.Injective cd.toAlgHom := by + injective into a domain). -/ + theorem isTorsionFree_coordHom : + @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ cd.toAlgebra.toModule := by +- letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI : FaithfulSMul C₂.CoordinateRing C₁.CoordinateRing := ++ let : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have : FaithfulSMul C₂.CoordinateRing C₁.CoordinateRing := + (faithfulSMul_iff_algebraMap_injective C₂.CoordinateRing C₁.CoordinateRing).mpr + (CurveMap.coordHom_injective φ cd) + infer_instance +@@ -146,8 +122,8 @@ private theorem isScalarTower_residueField_maximalIdealAt (P : C₁.SmoothPoint) + ⟨maximalIdealAt_toPointMap cd P⟩ + IsScalarTower F (C₂.CoordinateRing ⧸ C₂.maximalIdealAt (toPointMap cd P)) + (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := by +- letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI : (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := ++ let : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have : (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := + ⟨maximalIdealAt_toPointMap cd P⟩ + set Q := toPointMap cd P with hQ + refine IsScalarTower.of_algebraMap_eq fun c ↦ ?_ +@@ -177,15 +153,15 @@ private theorem finrank_residueField_maximalIdealAt_le_one (P : C₁.SmoothPoint + ⟨maximalIdealAt_toPointMap cd P⟩ + Module.finrank (C₂.CoordinateRing ⧸ C₂.maximalIdealAt (toPointMap cd P)) + (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) ≤ 1 := by +- letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI : (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := ++ let : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have : (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := + ⟨maximalIdealAt_toPointMap cd P⟩ + set Q := toPointMap cd P with hQ +- haveI hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q +- haveI hPmax : (C₁.maximalIdealAt P).IsMaximal := C₁.maximalIdealAt_isMaximal P +- haveI : Field (C₂.CoordinateRing ⧸ C₂.maximalIdealAt Q) := Ideal.Quotient.field _ +- haveI : Field (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := Ideal.Quotient.field _ +- haveI htower := isScalarTower_residueField_maximalIdealAt φ cd P ++ have hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hPmax : (C₁.maximalIdealAt P).IsMaximal := C₁.maximalIdealAt_isMaximal P ++ have : Field (C₂.CoordinateRing ⧸ C₂.maximalIdealAt Q) := Ideal.Quotient.field _ ++ have : Field (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := Ideal.Quotient.field _ ++ have htower := isScalarTower_residueField_maximalIdealAt φ cd P + have hbijSP := C₁.algebraMap_bijective_quotient_of_maximal hPmax + refine finrank_le_one (1 : C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) fun w ↦ ?_ + obtain ⟨c, hc⟩ := hbijSP.2 w +@@ -212,16 +188,17 @@ theorem inertiaDeg_maximalIdealAt_toPointMap (P : C₁.SmoothPoint) : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra + haveI : (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := + ⟨(maximalIdealAt_toPointMap cd P)⟩ +- Ideal.inertiaDeg' (C₂.maximalIdealAt (toPointMap cd P)) (C₁.maximalIdealAt P) = 1 := by +- letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI hLies : (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := ++ (C₁.maximalIdealAt P).inertiaDeg C₂.CoordinateRing = 1 := by ++ let : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have hLies : (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := + ⟨maximalIdealAt_toPointMap cd P⟩ + set Q := toPointMap cd P with hQ +- haveI hPmax : (C₁.maximalIdealAt P).IsMaximal := C₁.maximalIdealAt_isMaximal P +- rw [Ideal.inertiaDeg'_algebraMap] ++ have hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hPmax : (C₁.maximalIdealAt P).IsMaximal := C₁.maximalIdealAt_isMaximal P ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (C₂.maximalIdealAt Q) (C₁.maximalIdealAt P)] + -- The residue field `F[C₁]/m_P` is `F` (alg-closed), hence nontrivial. +- haveI : Field (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := Ideal.Quotient.field _ +- haveI : Nontrivial (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := ++ have : Field (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := Ideal.Quotient.field _ ++ have : Nontrivial (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := + (Ideal.Quotient.nontrivial_iff).mpr hPmax.ne_top + -- Squeeze the residue rank between `1` (`finrank_pos`) and `1` (alg-closed surjectivity). + have hSP : Module.finrank F (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) = 1 := +@@ -229,9 +206,9 @@ theorem inertiaDeg_maximalIdealAt_toPointMap (P : C₁.SmoothPoint) : + have h_le : Module.finrank (C₂.CoordinateRing ⧸ C₂.maximalIdealAt Q) + (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) ≤ 1 := + finrank_residueField_maximalIdealAt_le_one φ cd P +- haveI : Module.Finite F (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := ++ have : Module.Finite F (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := + Module.finite_of_finrank_pos (by rw [hSP]; norm_num) +- haveI : Module.Finite (C₂.CoordinateRing ⧸ C₂.maximalIdealAt Q) ++ have : Module.Finite (C₂.CoordinateRing ⧸ C₂.maximalIdealAt Q) + (C₁.CoordinateRing ⧸ C₁.maximalIdealAt P) := + Module.Finite.of_restrictScalars_finite F _ _ + have h_ge : 1 ≤ Module.finrank (C₂.CoordinateRing ⧸ C₂.maximalIdealAt Q) +@@ -244,22 +221,17 @@ packaged as a `LiesOver` instance for the `cd`-induced algebra. -/ + theorem maximalIdealAt_liesOver_toPointMap (P : C₁.SmoothPoint) : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra + (C₁.maximalIdealAt P).LiesOver (C₂.maximalIdealAt (toPointMap cd P)) := +- letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra + ⟨maximalIdealAt_toPointMap cd P⟩ + + end NormConorm + +-/-! ### NEW-1(ii) — structural sub-lemmas of the norm–conorm identity ++/-! ### Coordinate-ring norms + +-The norm–conorm identity is assembled below from three sub-lemmas, each carrying its +-own elaboration budget so the assembling theorem stays light: +-* `relNorm_maximalIdealAt_eq` — the **`s = 1` core** `relNorm(m_R) = m_{φR}`; +-* `count_relNorm_eq_sum_fiber` — the **affine count identity** matching +- `count_{m_Q}(relNorm(span{w}))` to the fibre sum `Σ_{φP=Q} count_{m_P}(span{w})`; +-* `projectiveDivisorOf_pushforward_algebraMap_eq` — the **`algebraMap` case** of the +- norm–conorm identity (affine coefficients via the count identity, infinity +- coefficient forced by degree). +-The `f = u/v` reduction is then a short additivity argument in the main theorem. -/ ++The prime-ideal identity `relNorm(m_P) = m_{φP}` gives the corresponding ++valuation count as a sum over the fibre. Equality of affine coefficients, ++together with degree zero, determines the projective divisor. Additivity ++then extends the identity to quotients of coordinate-ring elements. -/ + + section NormConormSteps + +@@ -276,8 +248,8 @@ finiteness/degree arguments. -/ + private theorem faithfulSMul_coordinateRing_functionField : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra + FaithfulSMul C₂.CoordinateRing C₁.FunctionField := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +@@ -300,9 +272,9 @@ private theorem isScalarTower_coordinateRing_functionField : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra + letI : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra + IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- haveI tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ have tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +@@ -321,23 +293,23 @@ to `K(C₂)`). This is the algebraicity input to the localisation-finiteness st + private theorem isAlgebraic_functionField : + letI : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra + Algebra.IsAlgebraic C₂.FunctionField C₁.FunctionField := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ algCR.toModule := ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ algCR.toModule := + cd.module_finite +- haveI hint : Algebra.IsIntegral C₂.CoordinateRing C₁.CoordinateRing := ++ have hint : Algebra.IsIntegral C₂.CoordinateRing C₁.CoordinateRing := + Algebra.IsIntegral.of_finite C₂.CoordinateRing C₁.CoordinateRing +- haveI faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := ++ have faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := + faithfulSMul_coordinateRing_functionField φ cd +- letI algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- haveI tower1 : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := ++ let algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ have tower1 : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := + isScalarTower_coordinateRing_functionField φ cd +- haveI hab : Algebra.IsAlgebraic C₂.CoordinateRing C₁.CoordinateRing := ++ have hab : Algebra.IsAlgebraic C₂.CoordinateRing C₁.CoordinateRing := + Algebra.IsIntegral.isAlgebraic +- haveI halgAB : Algebra.IsAlgebraic C₂.CoordinateRing C₁.FunctionField := ++ have halgAB : Algebra.IsAlgebraic C₂.CoordinateRing C₁.FunctionField := + (IsFractionRing.isAlgebraic_iff' C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField).mp hab + exact (IsFractionRing.comap_isAlgebraic_iff (A := C₂.CoordinateRing) + (K := C₂.FunctionField) (C := C₁.FunctionField)).mp halgAB +@@ -352,25 +324,25 @@ theorem finiteDimensional_functionField : + have hfin : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ + cd.toAlgebra.toModule := by + exact cd.module_finite +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin +- haveI hint : Algebra.IsIntegral C₂.CoordinateRing C₁.CoordinateRing := ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin ++ have hint : Algebra.IsIntegral C₂.CoordinateRing C₁.CoordinateRing := + Algebra.IsIntegral.of_finite C₂.CoordinateRing C₁.CoordinateRing +- haveI faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := ++ have faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := + faithfulSMul_coordinateRing_functionField φ cd +- letI algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- haveI tower1 : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := ++ let algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ have tower1 : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := + isScalarTower_coordinateRing_functionField φ cd +- haveI halgFF : Algebra.IsAlgebraic C₂.FunctionField C₁.FunctionField := ++ have halgFF : Algebra.IsAlgebraic C₂.FunctionField C₁.FunctionField := + isAlgebraic_functionField φ cd +- haveI hicl : IsIntegralClosure C₁.CoordinateRing C₂.CoordinateRing C₁.FunctionField := ++ have hicl : IsIntegralClosure C₁.CoordinateRing C₂.CoordinateRing C₁.FunctionField := + IsIntegralClosure.of_isIntegrallyClosed C₁.CoordinateRing C₂.CoordinateRing _ +- haveI hloc : IsLocalization ++ have hloc : IsLocalization + (Algebra.algebraMapSubmonoid C₁.CoordinateRing (nonZeroDivisors C₂.CoordinateRing)) + C₁.FunctionField := + IsIntegralClosure.isLocalization C₂.CoordinateRing C₂.FunctionField C₁.FunctionField +@@ -394,12 +366,12 @@ private theorem finrank_functionField_eq_degree : + faithfulSMul_coordinateRing_functionField φ cd + @Module.finrank C₂.FunctionField C₁.FunctionField _ _ + (FractionRing.liftAlgebra C₂.CoordinateRing C₁.FunctionField).toModule = φ.degree := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- haveI tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ have tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +- haveI faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := ++ have faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := + faithfulSMul_coordinateRing_functionField φ cd + have halgmap : + IsFractionRing.lift (A := C₂.CoordinateRing) (K := C₂.FunctionField) +@@ -436,13 +408,13 @@ private theorem one_le_of_relNorm_eq_pow + isTorsionFree_coordHom φ cd + Ideal.relNorm C₂.CoordinateRing P' = q ^ t) : + 1 ≤ t := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI : P'.LiesOver q := hlies ++ have : P'.LiesOver q := hlies + rcases Nat.eq_zero_or_pos t with ht0 | ht0 + · exfalso + have hcomap : P'.comap (algebraMap C₂.CoordinateRing C₁.CoordinateRing) = q := +@@ -468,35 +440,26 @@ private theorem inertiaDeg_eq_one_of_liesOver_maximalIdealAt (Q : C₂.SmoothPoi + cd.module_finite + haveI : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- Ideal.inertiaDeg' (C₂.maximalIdealAt Q) P' = 1 := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ P'.inertiaDeg C₂.CoordinateRing = 1 := by ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI hP'prime' : P'.IsPrime := hP'prime +- haveI hP'lies' : P'.LiesOver (C₂.maximalIdealAt Q) := hP'lies +- haveI hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hP'prime' : P'.IsPrime := hP'prime ++ have hP'lies' : P'.LiesOver (C₂.maximalIdealAt Q) := hP'lies ++ have hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q + have hQ0 : C₂.maximalIdealAt Q ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + have hP'_ne_bot : P' ≠ ⊥ := by + intro h + apply hQ0 + have hh : C₂.maximalIdealAt Q = P'.under C₂.CoordinateRing := hP'lies.over + rw [hh, h, Ideal.under_bot] +- haveI hP'max : P'.IsMaximal := Ideal.IsPrime.isMaximal hP'prime hP'_ne_bot ++ have hP'max : P'.IsMaximal := Ideal.IsPrime.isMaximal hP'prime hP'_ne_bot + obtain ⟨P'', hP''⟩ := C₁.exists_smoothPoint_of_isMaximal hP'max +- haveI hlies'' : (C₁.maximalIdealAt P'').LiesOver +- (C₂.maximalIdealAt (toPointMap cd P'')) := +- maximalIdealAt_liesOver_toPointMap φ cd P'' +- have h1 : C₂.maximalIdealAt (toPointMap cd P'') = +- (C₁.maximalIdealAt P'').under C₂.CoordinateRing := hlies''.over +- have h2 : C₂.maximalIdealAt Q = P'.under C₂.CoordinateRing := hP'lies.over +- rw [hP''] at h1 +- have hpeq : C₂.maximalIdealAt (toPointMap cd P'') = C₂.maximalIdealAt Q := h1.trans h2.symm +- have hid := inertiaDeg_maximalIdealAt_toPointMap φ cd P'' +- rw [← hP'', ← hpeq] +- exact hid ++ rw [← hP''] ++ exact inertiaDeg_maximalIdealAt_toPointMap φ cd P'' + + include φ cd in + /-- **Sum of ramification indices equals `φ.degree`**: over a smooth point `Q` of +@@ -514,12 +477,12 @@ private theorem sum_ramificationIdx_eq_degree (Q : C₂.SmoothPoint) + isTorsionFree_coordHom φ cd + ∑ P' ∈ IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing, + (C₂.maximalIdealAt Q).ramificationIdx' P' = φ.degree := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q + have hQ0 : C₂.maximalIdealAt Q ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + have hsumef := φ.sum_ramificationIdx_mul_inertiaDeg_eq_degree cd hfin hQmax hQ0 + rw [← hsumef] +@@ -557,12 +520,12 @@ private theorem degree_eq_sum_relNormExp_mul_ramificationIdx (Q : C₂.SmoothPoi + haveI : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q + φ.degree = ∑ P' ∈ ((C₂.maximalIdealAt Q).primesOver C₁.CoordinateRing).toFinset, + sfn P' * (C₂.maximalIdealAt Q).ramificationIdx' P' := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q + set p : Ideal C₂.CoordinateRing := C₂.maximalIdealAt Q with hp_def + have hp0 : p ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + have hpNotUnit : ¬ IsUnit p := by rw [Ideal.isUnit_iff]; exact hQmax.ne_top +@@ -571,11 +534,11 @@ private theorem degree_eq_sum_relNormExp_mul_ramificationIdx (Q : C₂.SmoothPoi + finrank_functionField_eq_degree φ cd + -- `relNorm_algebraMap`'s exponent is the *coordinate-ring* `finrank`, so pull `hcoh` down the + -- fraction-field tower with `IsFractionRing.finrank_eq`. +- letI algFF : Algebra C₂.FunctionField C₁.FunctionField := ++ let algFF : Algebra C₂.FunctionField C₁.FunctionField := + FractionRing.liftAlgebra C₂.CoordinateRing C₁.FunctionField +- haveI towerFF : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := ++ have towerFF : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := + FractionRing.isScalarTower_liftAlgebra C₂.CoordinateRing C₁.FunctionField +- haveI towerCR : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by ++ have towerCR : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +@@ -619,14 +582,14 @@ private theorem one_le_ramificationIdx_of_liesOver_maximalIdealAt (Q : C₂.Smoo + haveI : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + 1 ≤ (C₂.maximalIdealAt Q).ramificationIdx' P' := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI : P'.IsPrime := hP'prime +- haveI : P'.LiesOver (C₂.maximalIdealAt Q) := hP'lies ++ have : P'.IsPrime := hP'prime ++ have : P'.LiesOver (C₂.maximalIdealAt Q) := hP'lies + have hp0 : C₂.maximalIdealAt Q ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + rw [Nat.one_le_iff_ne_zero] + exact Ideal.IsDedekindDomain.ramificationIdx'_ne_zero_of_liesOver P' hp0 +@@ -664,17 +627,17 @@ theorem relNorm_maximalIdealAt_eq + have hfin : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ + cd.toAlgebra.toModule := by + exact cd.module_finite +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := hfin ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + set Q := toPointMap cd R with hQ +- haveI hLies : (C₁.maximalIdealAt R).LiesOver (C₂.maximalIdealAt Q) := ++ have hLies : (C₁.maximalIdealAt R).LiesOver (C₂.maximalIdealAt Q) := + maximalIdealAt_liesOver_toPointMap φ cd R +- haveI hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q +- haveI hRmax : (C₁.maximalIdealAt R).IsMaximal := C₁.maximalIdealAt_isMaximal R +- haveI hRprime : (C₁.maximalIdealAt R).IsPrime := hRmax.isPrime ++ have hQmax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hRmax : (C₁.maximalIdealAt R).IsMaximal := C₁.maximalIdealAt_isMaximal R ++ have hRprime : (C₁.maximalIdealAt R).IsPrime := hRmax.isPrime + have hQ0 : C₂.maximalIdealAt Q ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + obtain ⟨s, hs⟩ := Ideal.exists_relNorm_eq_pow_of_isPrime + (C₁.maximalIdealAt R) (C₂.maximalIdealAt Q) +@@ -683,14 +646,14 @@ theorem relNorm_maximalIdealAt_eq + have hge1 : 1 ≤ s := one_le_of_relNorm_eq_pow φ cd hQmax s hLies hs + set p : Ideal C₂.CoordinateRing := C₂.maximalIdealAt Q with hp_def + -- Every residue degree over `m_Q` is `1`. +- have hinertia : ∀ P' ∈ p.primesOver C₁.CoordinateRing, Ideal.inertiaDeg' p P' = 1 := by ++ have hinertia : ∀ P' ∈ p.primesOver C₁.CoordinateRing, P'.inertiaDeg C₂.CoordinateRing = 1 := by + intro P' hP' + obtain ⟨hP'prime, hP'lies⟩ := hP' + exact inertiaDeg_eq_one_of_liesOver_maximalIdealAt φ cd Q P' hP'prime hP'lies + have hp0 : p ≠ ⊥ := hQ0 + have hpNotUnit : ¬ IsUnit p := by + rw [Ideal.isUnit_iff]; exact hQmax.ne_top +- haveI hpMax : p.IsMaximal := hQmax ++ have hpMax : p.IsMaximal := hQmax + -- Each relative norm over `m_Q` is a positive power of `m_Q`. + have hexp : ∀ P' ∈ p.primesOver C₁.CoordinateRing, + ∃ t : ℕ, 1 ≤ t ∧ Ideal.relNorm C₂.CoordinateRing P' = p ^ t := by +@@ -753,16 +716,16 @@ private theorem primesOverFinset_ne_bot {p : Ideal C₂.CoordinateRing} + (hpMax : p.IsMaximal) (hp_ne : p ≠ ⊥) : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra + ∀ Q' ∈ IsDedekindDomain.primesOverFinset p C₁.CoordinateRing, Q' ≠ ⊥ := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI faithCR : FaithfulSMul C₂.CoordinateRing C₁.CoordinateRing := ++ have faithCR : FaithfulSMul C₂.CoordinateRing C₁.CoordinateRing := + (faithfulSMul_iff_algebraMap_injective C₂.CoordinateRing C₁.CoordinateRing).mpr + (CurveMap.coordHom_injective φ cd) +- haveI hpMax' : p.IsMaximal := hpMax ++ have hpMax' : p.IsMaximal := hpMax + intro Q' hQ' + rw [IsDedekindDomain.mem_primesOverFinset_iff (B := C₁.CoordinateRing) hp_ne] at hQ' + intro h_eq +@@ -790,15 +753,15 @@ private theorem exists_smoothPoint_relNorm_maximalIdealAt_eq + ∃ P' : C₁.SmoothPoint, C₁.maximalIdealAt P' = Q' ∧ + Ideal.relNorm C₂.CoordinateRing Q' = C₂.maximalIdealAt (toPointMap cd P') ∧ + Q'.LiesOver (C₂.maximalIdealAt (toPointMap cd P')) := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI hQ'max' : Q'.IsMaximal := hQ'max ++ have hQ'max' : Q'.IsMaximal := hQ'max + obtain ⟨P', hP'⟩ := C₁.exists_smoothPoint_of_isMaximal hQ'max +- haveI hlies' : (C₁.maximalIdealAt P').LiesOver ++ have hlies' : (C₁.maximalIdealAt P').LiesOver + (C₂.maximalIdealAt (toPointMap cd P')) := + maximalIdealAt_liesOver_toPointMap φ cd P' + refine ⟨P', hP', ?_, hP' ▸ hlies'⟩ +@@ -822,15 +785,15 @@ private theorem count_maximalIdealAt_relNorm_pow_self (Q : C₂.SmoothPoint) + isTorsionFree_coordHom φ cd + (Associates.mk (C₂.maximalIdealAt Q)).count + (Associates.mk ((Ideal.relNorm C₂.CoordinateRing Q') ^ k)).factors = k := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI hQ'lies' : Q'.LiesOver (C₂.maximalIdealAt Q) := hQ'lies ++ have hQ'lies' : Q'.LiesOver (C₂.maximalIdealAt Q) := hQ'lies + set p : Ideal C₂.CoordinateRing := C₂.maximalIdealAt Q with hp_def +- haveI hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q + have hp_ne : p ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + have h_vp_irr : Irreducible (Associates.mk p) := + (⟨p, hpMax.isPrime, hp_ne⟩ : +@@ -862,14 +825,14 @@ private theorem count_maximalIdealAt_relNorm_pow_of_not_liesOver (Q : C₂.Smoot + isTorsionFree_coordHom φ cd + (Associates.mk (C₂.maximalIdealAt Q)).count + (Associates.mk ((Ideal.relNorm C₂.CoordinateRing Q') ^ k)).factors = 0 := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + set p : Ideal C₂.CoordinateRing := C₂.maximalIdealAt Q with hp_def +- haveI hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q + have hp_ne : p ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + have h_vp_irr : Irreducible (Associates.mk p) := + (⟨p, hpMax.isPrime, hp_ne⟩ : +@@ -880,7 +843,7 @@ private theorem count_maximalIdealAt_relNorm_pow_of_not_liesOver (Q : C₂.Smoot + rw [hrel] + intro hpe + exact hQ'not (hpe ▸ hlies') +- haveI hP'max2 : (Ideal.relNorm C₂.CoordinateRing Q').IsMaximal := ++ have hP'max2 : (Ideal.relNorm C₂.CoordinateRing Q').IsMaximal := + hrel ▸ C₂.maximalIdealAt_isMaximal _ + have hP'_ne_bot2 : Ideal.relNorm C₂.CoordinateRing Q' ≠ ⊥ := hrel ▸ C₂.maximalIdealAt_ne_bot _ + have h_vP'_irr : Irreducible (Associates.mk (Ideal.relNorm C₂.CoordinateRing Q')) := +@@ -915,14 +878,14 @@ private theorem count_factors_relNorm_pow_eq_ite (Q : C₂.SmoothPoint) + (Associates.mk ((Ideal.relNorm C₂.CoordinateRing Q') ^ k)).factors = + if Q' ∈ IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing + then k else 0 := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + have hp_ne : C₂.maximalIdealAt Q ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q +- haveI hpMax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hpMax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q + by_cases h_over : Q' ∈ IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing + · rw [if_pos h_over] + haveI hQ'lies : Q'.LiesOver (C₂.maximalIdealAt Q) := +@@ -979,11 +942,11 @@ private theorem associates_relNorm_pow_ne_zero + haveI : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + Associates.mk ((Ideal.relNorm C₂.CoordinateRing Q'.asIdeal) ^ k) ≠ 0 := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + rw [Associates.mk_ne_zero] + apply pow_ne_zero +@@ -1018,14 +981,14 @@ private theorem count_relNorm_span_eq_sum_support (Q : C₂.SmoothPoint) + (Associates.mk ((Ideal.relNorm C₂.CoordinateRing Q'.asIdeal) ^ + ((Associates.mk Q'.asIdeal).count + (Associates.mk (Ideal.span ({w} : Set _))).factors))).factors := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + set p : Ideal C₂.CoordinateRing := C₂.maximalIdealAt Q with hp_def +- haveI hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q + have hp_ne : p ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + have h_vp_irr : Irreducible (Associates.mk p) := + (⟨p, hpMax.isPrime, hp_ne⟩ : +@@ -1070,15 +1033,15 @@ theorem count_relNorm_eq_sum_fiber : + ∑ Q' ∈ IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing, + (Associates.mk Q').count (Associates.mk (Ideal.span ({w} : Set _))).factors := by + classical +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + intro w hw Q + set p : Ideal C₂.CoordinateRing := C₂.maximalIdealAt Q with hp_def +- haveI hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hpMax : p.IsMaximal := C₂.maximalIdealAt_isMaximal Q + have hp_ne : p ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + have hI_ne : Ideal.span ({w} : Set C₁.CoordinateRing) ≠ 0 := by + rw [Ne, Ideal.zero_eq_bot, Ideal.span_singleton_eq_bot]; exact hw +@@ -1185,28 +1148,28 @@ private theorem pushforward_algebraMap_eq_algebraMap_intNorm (w : C₁.Coordinat + algebraMap C₂.CoordinateRing C₂.FunctionField + (Algebra.intNorm C₂.CoordinateRing C₁.CoordinateRing w) := by + classical +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI hint : Algebra.IsIntegral C₂.CoordinateRing C₁.CoordinateRing := ++ have hint : Algebra.IsIntegral C₂.CoordinateRing C₁.CoordinateRing := + Algebra.IsIntegral.of_finite C₂.CoordinateRing C₁.CoordinateRing +- haveI tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by ++ have tower2 : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +- haveI faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := ++ have faith : FaithfulSMul C₂.CoordinateRing C₁.FunctionField := + faithfulSMul_coordinateRing_functionField φ cd +- letI algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- haveI tower1 : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := by ++ let algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ have tower1 : IsScalarTower C₂.CoordinateRing C₂.FunctionField C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_smul fun r x ↦ ?_ + rw [Algebra.smul_def] + show φ.pullback ((algebraMap C₂.CoordinateRing C₂.FunctionField) r) * x = r • x + rw [cd.compat r, ← IsScalarTower.algebraMap_smul C₁.CoordinateRing r x, ← Algebra.smul_def] + rfl +- haveI hfd : FiniteDimensional C₂.FunctionField C₁.FunctionField := ++ have hfd : FiniteDimensional C₂.FunctionField C₁.FunctionField := + finiteDimensional_functionField φ cd + rw [Algebra.algebraMap_intNorm (A := C₂.CoordinateRing) (B := C₁.CoordinateRing) + (K := C₂.FunctionField) (L := C₁.FunctionField) w] +@@ -1226,11 +1189,11 @@ private theorem intNorm_ne_zero_of_ne_zero (w : C₁.CoordinateRing) (hw : w ≠ + isTorsionFree_coordHom φ cd + Algebra.intNorm C₂.CoordinateRing C₁.CoordinateRing w ≠ 0 := by + classical +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + have hw_FF : algebraMap C₁.CoordinateRing C₁.FunctionField w ≠ 0 := by + intro h +@@ -1283,25 +1246,25 @@ private theorem exists_smoothPoint_maximalIdealAt_eq_of_mem_primesOverFinset + (hQ' : letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra + Q' ∈ IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing) : + ∃ P' : C₁.SmoothPoint, C₁.maximalIdealAt P' = Q' ∧ toPointMap cd P' = Q := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd +- haveI hpMax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q ++ have hpMax : (C₂.maximalIdealAt Q).IsMaximal := C₂.maximalIdealAt_isMaximal Q + have hp_ne : C₂.maximalIdealAt Q ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q + rw [IsDedekindDomain.mem_primesOverFinset_iff (B := C₁.CoordinateRing) hp_ne] at hQ' + obtain ⟨hQ'prime, hQ'lies⟩ := hQ' +- haveI : Q'.IsPrime := hQ'prime +- haveI : Q'.LiesOver (C₂.maximalIdealAt Q) := hQ'lies +- haveI hQ'max : Q'.IsMaximal := Ideal.IsPrime.isMaximal hQ'prime (by ++ have : Q'.IsPrime := hQ'prime ++ have : Q'.LiesOver (C₂.maximalIdealAt Q) := hQ'lies ++ have hQ'max : Q'.IsMaximal := Ideal.IsPrime.isMaximal hQ'prime (by + intro h; apply hp_ne + have : C₂.maximalIdealAt Q = Q'.under C₂.CoordinateRing := hQ'lies.over + rw [this, h, Ideal.under_bot]) + obtain ⟨P', hP'⟩ := C₁.exists_smoothPoint_of_isMaximal hQ'max + refine ⟨P', hP', ?_⟩ +- haveI hlies' : (C₁.maximalIdealAt P').LiesOver ++ have hlies' : (C₁.maximalIdealAt P').LiesOver + (C₂.maximalIdealAt (toPointMap cd P')) := + maximalIdealAt_liesOver_toPointMap φ cd P' + have h1 : C₂.maximalIdealAt (toPointMap cd P') = +@@ -1333,11 +1296,11 @@ private theorem affine_section_injOn_attach (Q : C₂.SmoothPoint) : + (_ : b ∈ (IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing).attach), + ProjectiveSmoothPoint.affine (g a.1 a.2) = ProjectiveSmoothPoint.affine (g b.1 b.2) → + a = b := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + intro g hg a _ b _ hab + simp only [ProjectiveSmoothPoint.affine.injEq] at hab +@@ -1373,11 +1336,11 @@ private theorem sum_filter_support_eq_sum_image_section + ∑ x ∈ (IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) + C₁.CoordinateRing).attach.image + (fun Q' ↦ ProjectiveSmoothPoint.affine (g Q'.1 Q'.2)), D x := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + intro g hg_ideal hg_Q + have hp_ne : C₂.maximalIdealAt Q ≠ ⊥ := C₂.maximalIdealAt_ne_bot Q +@@ -1439,11 +1402,11 @@ private theorem sum_image_section_eq_sum_primesOver + (C₁.projectiveDivisorOf (algebraMap C₁.CoordinateRing C₁.FunctionField w)) x) = + ∑ Q' ∈ IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing, + ((Associates.mk Q').count (Associates.mk (Ideal.span ({w} : Set _))).factors : ℤ) := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + intro g hg_ideal + rw [Finset.sum_image (affine_section_injOn_attach φ cd Q g hg_ideal)] +@@ -1480,11 +1443,11 @@ private theorem pushforwardDivisorVal_projectiveDivisorOf_affine_eq_sum_fiber + ∑ Q' ∈ IsDedekindDomain.primesOverFinset (C₂.maximalIdealAt Q) C₁.CoordinateRing, + ((Associates.mk Q').count (Associates.mk (Ideal.span ({w} : Set _))).factors : ℤ) := by + classical +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + -- Choose a section `pt` of the fibre `{primes over m_Q} → {smooth points P'}`, with + -- `m_{pt Q'} = Q'` and `φ (pt Q') = Q`, via the existence lemma. +@@ -1532,11 +1495,11 @@ private theorem projectiveDivisorOf_pushforward_algebraMap_apply_affine + φ.pushforwardDivisorVal cd (C₁.projectiveDivisorOf + (algebraMap C₁.CoordinateRing C₁.FunctionField w)) (ProjectiveSmoothPoint.affine Q) := by + classical +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := cd.toAlgebra ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have hfin' : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + cd.module_finite +- haveI htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := ++ have htf : @Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing _ _ modCR := + isTorsionFree_coordHom φ cd + have hnw : Algebra.intNorm C₂.CoordinateRing C₁.CoordinateRing w ≠ 0 := + intNorm_ne_zero_of_ne_zero φ cd w hw +@@ -1585,10 +1548,10 @@ theorem projectiveDivisorOf_pushforward_algebraMap_eq + + end NormConormSteps + +-/-! ### NEW-1(ii): the `f = u/v` reduction ++/-! ### the `f = u/v` reduction + + The deep per-place arithmetic is the `algebraMap` case +-`projectiveDivisorOf_pushforward_algebraMap_eq` (in `section NormConormSteps`). ++`projectiveDivisorOf_pushforward_algebraMap_eq`. + The norm–conorm identity for a *general* `f ∈ K(C₁)` follows from it by the + multiplicativity of both sides together with `IsFractionRing.div_surjective`. + The next four `private` helpers package that reduction: +@@ -1606,8 +1569,8 @@ private theorem projectiveDivisorOf_pushforward_zero (φ : CurveMap C₁ C₂) + FiniteDimensional C₂.FunctionField C₁.FunctionField) : + C₂.projectiveDivisorOf (φ.pushforward (0 : C₁.FunctionField)) = + φ.pushforwardDivisorVal cd (C₁.projectiveDivisorOf (0 : C₁.FunctionField)) := by +- letI algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- haveI : FiniteDimensional C₂.FunctionField C₁.FunctionField := hfd ++ let algFF : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ have : FiniteDimensional C₂.FunctionField C₁.FunctionField := hfd + rw [show φ.pushforward (0 : C₁.FunctionField) = 0 from Algebra.norm_zero, + C₂.projectiveDivisorOf_zero, C₁.projectiveDivisorOf_zero, map_zero] + +@@ -1690,44 +1653,16 @@ private theorem projectiveDivisorOf_pushforward_eq_of_algebraMap (φ : CurveMap + pushforwardDivisorVal_projectiveDivisorOf_eq_sub_of_mul_eq φ cd hf hav_ne hf_av, + hau, hav, key u hu_ne, key v hv_ne] + +-/-- **NEW-1(ii) — Silverman II.3.6, norm–conorm identity** `div(N_φ f) = φ_∗(div f)`. +-For a curve map `φ : C₁ → C₂` with coordinate-ring witness `cd` and a function +-`f ∈ K(C₁)`, the projective divisor of the conorm `N_φ f = φ.pushforward f` +-equals the valuation-theoretic pushforward of the projective divisor of `f`. +- +-The content is the per-place identity `ord_Q(N_φ f) = Σ_{P ↦ Q} f_{P/Q}·ord_P(f)` +-(with inertia degrees `f_{P/Q} = 1` over an algebraically closed field), proved +-via `Ideal.sum_ramification_inertia`, `Ideal.relNorm`, and `Algebra.intNorm`. +- +-The proof is the generalisation of the `F[X] → F[C]` machinery of +-`NormValuation.lean` (`count_relNorm_singleton_eq_sum_count_fiber`, +-`relNorm_maximalIdealAt`) to the *coordinate-ring extension* `F[C₂] → F[C₁]` +-induced by `cd`. The instance-heavy steps are factored into the sub-lemmas of +-`section NormConormSteps`, each re-establishing the `cd`-induced algebra and its +-`Module.Finite`/`IsTorsionFree` structure internally (a `relNorm`/`intNorm` +-statement only typechecks with those instances in scope, so the sub-lemmas state +-them via `letI`/`haveI`-in-type and re-derive them in the body): +-* `finiteDimensional_functionField` — the finite extension `K(C₂) → K(C₁)` +- (needed only for the `f = 0` branch below); +-* the degree/`finrank` coherence `finrank_{liftAlgebra} = φ.degree` +- (`IsFractionRing.lift_unique` + `cd.compat`, so `relNorm_algebraMap` yields +- `m_Q ^ φ.degree`), computed inside `relNorm_maximalIdealAt_eq`; +-* `relNorm_maximalIdealAt_eq` — the **`s = 1` core** `relNorm_{F[C₂]}(m_P) = m_{φP}` +- from the global balance `relNorm(m_Q·F[C₁]) = m_Q^{φ.degree} = +- ∏ relNorm(m_{P'})^{e_{P'}}` together with `Σ e_{P'}·f_{P'} = φ.degree` +- (`sum_ramificationIdx_mul_inertiaDeg_eq_degree`) and `f_{P'} = 1` +- (`inertiaDeg_maximalIdealAt_toPointMap`), forcing each exponent to 1; +-* `count_relNorm_eq_sum_fiber` — the affine count identity +- `count_{m_Q}(relNorm (span{u})) = Σ_{Q' over m_Q} count_{Q'}(span{u})`; +-* `projectiveDivisorOf_pushforward_algebraMap_eq` — the `algebraMap` case, matching +- the affine coefficients to the `mapDomain` fibre sum of `pushforwardDivisorVal` +- via the bijection `{P : φP = Q} ≃ {primes over m_Q}` (`maximalIdealAt_toPointMap` +- + `exists_smoothPoint_of_isMaximal`), the place at infinity being forced by +- `projectiveDivisorOf_degree_eq_zero` (both projective divisors have degree `0`, +- and `pushforwardDivisorVal` preserves degree). +-Here the general `f = u/v` reduces to `f = algebraMap u`, `u ∈ F[C₁]` nonzero, via +-`IsFractionRing.div_surjective` and the additivity of both sides +-(`projectiveDivisorOf_mul`, `pushforward_mul`, `pushforwardDivisorVal` a hom). -/ ++/-- **Silverman II.3.6, norm–conorm identity** `div(N_φ f) = φ_∗(div f)`. ++ ++For a curve map with a coordinate-ring witness over an algebraically closed field, ++the local norm formula is `ord_Q(N_φ f) = Σ_{P ↦ Q} ord_P(f)`, since the residue ++degrees are one. The prime-ideal norm formula follows from the fundamental ++ramification identity and the degree of the function-field extension. The ++bijection between points over `Q` and primes over its maximal ideal then gives ++the affine coefficients; degree zero determines the coefficient at infinity. ++The quotient representation `f = u/v` and additivity extend the identity from ++nonzero coordinate-ring elements to all rational functions. -/ + theorem projectiveDivisorOf_pushforward_eq_pushforwardDivisorVal [IsAlgClosed F] + [IsDedekindDomain C₁.CoordinateRing] [IsDedekindDomain C₂.CoordinateRing] + (φ : CurveMap C₁ C₂) (cd : φ.CoordHom) +@@ -1746,7 +1681,7 @@ theorem projectiveDivisorOf_pushforward_eq_pushforwardDivisorVal [IsAlgClosed F] + + end HasseWeil.Curves.CurveMap + +-/-! ### NEW-1(iii)/(iv): compatibility + the gap `h_pres` -/ ++/-! ### Compatibility of divisor pushforwards -/ + + namespace HasseWeil.EC.Isogeny + +@@ -1755,7 +1690,7 @@ open HasseWeil.Curves + variable {F : Type*} [Field F] [DecidableEq F] + variable {W₁ W₂ : Affine F} [W₁.IsElliptic] [W₂.IsElliptic] + +-/-- **NEW-1(iii)**: the point-map pushforward `pushforwardProjectiveDivisor` ++/-- the point-map pushforward `pushforwardProjectiveDivisor` + agrees with the valuation-theoretic pushforward `pushforwardDivisorVal`. By + construction the two `mapDomain` place-image maps coincide, so this is `rfl` + up to the `(φP).toProjectiveSmoothPoint = affine (toPointMap cd P)` identity. -/ +@@ -1776,10 +1711,10 @@ theorem pushforwardProjectiveDivisor_eq_pushforwardDivisorVal (φ : Isogeny W₁ + -- `affine (toPointMap cd P')` after the round-trip. + rfl + +-/-- **NEW-1(iv) / `h_pres` — Silverman II.3.7**: the pushforward `φ_∗` carries ++/-- **Silverman II.3.7**: the pushforward `φ_∗` carries + principal projective divisors to principal ones. This is the sole deep input to + Silverman III.4.8 (`EC.Isogeny.addHomProperty`); it falls out of the norm–conorm +-identity (NEW-1 ii) since the pushforward of `div f` is `div(N_φ f)`, again ++identity since the pushforward of `div f` is `div(N_φ f)`, again + principal. -/ + theorem pushforward_preserves_principal [IsAlgClosed F] + [IsDedekindDomain (⟨W₁⟩ : SmoothPlaneCurve F).CoordinateRing] +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/AFConditional.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/AFConditional.lean +index d56788426..bb5320f8d 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/AFConditional.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/AFConditional.lean +@@ -3,27 +3,16 @@ import HasseWeil.Foundation.Curves.Ramification.PoleOrderParity + import HasseWeil.Isogeny.GroupHom.PicZero + + /-! +-# AF unified package: conditional witnesses ++# Divisor witnesses for additivity of isogenies + +-Wires together the shipped infrastructure into the witnesses needed by +-`AddHomProperty_of_picZero_witnesses` (the universal Silverman III.4.8 +-theorem). Each witness is parametrized over the remaining outstanding +-hypotheses, making the dependency chain explicit: ++The reduction `D ~ (σD) − (O)` of degree-zero divisors identifies their ++Picard classes with point classes. Combined with the assertion that ++`(P) − (O)` is principal only when `P = O`, it shows that the sum of ++points vanishes on principal divisors. These two identities give the ++Picard-group witnesses for additivity of an isogeny whose pushforward ++preserves principal divisors. + +-* `h_inj` (`κ ∘ σ̄ = id`): `DivZeroReduce W` (= reduction lemma). +-* `h_van` (`σ` vanishes on principal): `DivZeroReduce W` AND a +- `point_minus_O_principal_eq_zero` over arbitrary functions +- (= the no-finite-poles bridge). +- +-Once `DivZeroReduce W` lands (which itself decomposes into the +-list-induction `effective_sum_reduce` + Finsupp-to-list bridge for +-multiplicities) and the no-finite-poles bridge, the AF unified package +-fully closes B-4-003 conditionally on Miller (the geometric chord/tangent +-construction, the only remaining genuinely-new mathematical piece). +- +-## References +- +-* `T-PIC-AF-UNIFIED.md` for the full plan. ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.3–III.4. + -/ + + open WeierstrassCurve +@@ -33,19 +22,14 @@ namespace HasseWeil.Curves + variable {F : Type*} [Field F] [DecidableEq F] + (W : Affine F) [W.IsElliptic] + +-/-- The full divisor reduction property: every degree-zero divisor is +-linearly equivalent to `(σD) − (O)`. The proof requires Miller (via +-`effective_sum_reduce`) plus a Finsupp-to-list bridge for handling +-multiplicities. Both are outstanding tickets. -/ ++/-- Every degree-zero divisor is linearly equivalent to `(σD) − (O)`, ++where `σD` is its sum of points with multiplicity. -/ + def DivZeroReduce : Prop := + ∀ D : ProjectiveDivisor.degZero (⟨W⟩ : SmoothPlaneCurve F), + SmoothPlaneCurve.ProjLinearlyEquiv (⟨W⟩ : SmoothPlaneCurve F) + D.val (kappaDivisor W (projectiveDivisorSum W D.val)) + +-/-- The unconditional `point_minus_O` property: if `(P) − (O)` is +-principal, then `P = 0`. The proof requires the parity lemma (shipped +-as `point_minus_O_principal_eq_zero_of_coord`) plus the no-finite-poles +-→ CR-image bridge (outstanding ticket: `T-PIC-AF-UNIFIED.md` piece (a)). -/ ++/-- A point divisor `(P) − (O)` is principal only when `P = O`. -/ + def PointMinusOPrincipalEqZero : Prop := + ∀ P : W.Point, + SmoothPlaneCurve.ProjIsPrincipal (⟨W⟩ : SmoothPlaneCurve F) +@@ -112,11 +96,8 @@ theorem h_van_degZero_of_divZeroReduce_and_pointMinusO + + /-! ### `PointMinusOPrincipalEqZero` from the no-finite-poles bridge -/ + +-/-- The no-finite-poles → CR-image bridge: any nonzero function with all +-local orders nonneg lies in the coordinate-ring image. The proof composes +-worker-I's `pointValuation_algebraMap_le_one`, `smoothPointEquivMaxIdeal` +-(under `[IsAlgClosed F] [IsElliptic]`), and mathlib's +-`mem_coordinateRing_of_valuation_le_one`. ~80-150 LOC follow-up ticket. -/ ++/-- A nonzero function with nonnegative order at every affine point ++lies in the image of the coordinate ring. -/ + def NoFinitePolesBridge : Prop := + ∀ (f : (⟨W⟩ : SmoothPlaneCurve F).FunctionField), f ≠ 0 → + (∀ P : (⟨W⟩ : SmoothPlaneCurve F).SmoothPoint, +@@ -151,9 +132,9 @@ theorem pointMinusO_of_bridge + ((ProjectiveSmoothPoint.infinity : ProjectiveSmoothPoint + (⟨W⟩ : SmoothPlaneCurve F))) ≠ ProjectiveSmoothPoint.affine Q := by + nofun +- rw [if_neg h_inf_ne, sub_zero] at h_eq ++ rw [ite_eq_right h_inf_ne, sub_zero] at h_eq + by_cases h_eq_pt : P.toProjectiveSmoothPoint = ProjectiveSmoothPoint.affine Q +- · rw [if_pos h_eq_pt] at h_eq ++ · rw [ite_eq_left h_eq_pt] at h_eq + cases h_top : (⟨W⟩ : SmoothPlaneCurve F).ord_P Q f with + | top => + rw [h_top, WithTop.untopD_top] at h_eq +@@ -163,7 +144,7 @@ theorem pointMinusO_of_bridge + have hn : n = 1 := h_eq.symm + subst hn + exact_mod_cast (by decide : (0 : ℤ) ≤ 1) +- · rw [if_neg h_eq_pt] at h_eq ++ · rw [ite_eq_right h_eq_pt] at h_eq + cases h_top : (⟨W⟩ : SmoothPlaneCurve F).ord_P Q f with + | top => + exact absurd (((⟨W⟩ : SmoothPlaneCurve F).ord_P_eq_top_iff (P := Q) f).mp h_top) hf_ne +@@ -174,17 +155,10 @@ theorem pointMinusO_of_bridge + + /-! ### Bundled AFInputs structure -/ + +-/-- The three input Props needed for the AF unified package on a single +-elliptic curve `W`: +- +-* `miller`: chord/tangent geometric identity at the divisor level. +-* `divZeroReduce`: combinatorial reduction `D ~ (σD) − (O)` for D ∈ Div⁰. +-* `noFinitePolesBridge`: the algebraic bridge from "no finite poles" to +- "in coordinate-ring image". +- +-Each is its own outstanding ticket; once all three are discharged for a +-specific `W`, both witnesses needed by `AddHomProperty_of_picZero_witnesses` +-(restricted to that curve's side of the isogeny) follow immediately. -/ ++/-- The divisor identities needed to identify an elliptic curve with ++its degree-zero Picard group: the Miller relation, reduction of ++degree-zero divisors to point divisors, and the coordinate-ring ++characterization of functions with no finite poles. -/ + structure AFInputs (W : Affine F) [W.IsElliptic] where + miller : MillerHypothesis W + divZeroReduce : DivZeroReduce W +@@ -217,12 +191,9 @@ theorem h_van_degZero {W : Affine F} [W.IsElliptic] (a : AFInputs W) + + end AFInputs + +-/-! ### Final B-4-003 wrapper -/ ++/-! ### Additivity from divisor witnesses -/ + +-/-- The "principal divisors lie in degZero" predicate. Proved by +-worker-K's T-II-3-009 (`projectiveDivisorOf_degree_zero`) under +-`[IsAlgClosed F]`. We take it as a hypothesis here to keep the wrapper +-conditional. -/ ++/-- Principal projective divisors have degree zero. -/ + def PrincipalImpliesDegZero (W : Affine F) [W.IsElliptic] : Prop := + ∀ D : ProjectiveDivisor (⟨W⟩ : SmoothPlaneCurve F), + D ∈ (⟨W⟩ : SmoothPlaneCurve F).projPrincipalSubgroup → +@@ -230,8 +201,8 @@ def PrincipalImpliesDegZero (W : Affine F) [W.IsElliptic] : Prop := + + namespace AFInputs + +-/-- The full h_van witness, given `AFInputs` + the principal-implies-degZero +-bridge (worker-K's T-II-3-009). -/ ++/-- The sum of points vanishes on principal divisors, given the divisor ++identities in `AFInputs` and the degree-zero property of principal divisors. -/ + theorem h_van {W : Affine F} [W.IsElliptic] (a : AFInputs W) + (h_pdz : PrincipalImpliesDegZero W) + (D : ProjectiveDivisor (⟨W⟩ : SmoothPlaneCurve F)) +@@ -241,20 +212,9 @@ theorem h_van {W : Affine F} [W.IsElliptic] (a : AFInputs W) + + end AFInputs + +-/-- **Final conditional B-4-003** for an isogeny: given `AFInputs` for +-both curves, the principal-degZero bridge for both curves, and the +-pushforward-preserves-principal hypothesis (T-PIC-C-003), the universal +-hom property holds. +- +-This closes B-4-003 over `[IsAlgClosed F]` modulo: +-- `MillerHypothesis` for both W₁ and W₂ (geometric chord/tangent — the BIG remaining piece) +-- `DivZeroReduce` for both W₁ and W₂ (Finsupp decomposition + miller corollaries) +-- `NoFinitePolesBridge` for both W₁ and W₂ (valuation bridge) +-- `PrincipalImpliesDegZero` for both W₁ and W₂ (worker-K's T-II-3-009) +-- `h_pres` (T-PIC-C-003 = norm-divisor identity) +- +-All the structural plumbing is here; the remaining work is to prove +-each of these Props for elliptic curves. -/ ++/-- An isogeny is additive given the divisor identities on both curves, ++the degree-zero property of principal divisors, and preservation of ++principal divisors by its pushforward. See Silverman III.4.8. -/ + theorem AddHomProperty_of_AFInputs + {W₁ W₂ : Affine F} [W₁.IsElliptic] [W₂.IsElliptic] + (φ : HasseWeil.EC.Isogeny W₁ W₂) +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/GenericFiber.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/GenericFiber.lean +index 7a21963e5..91c992b49 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/GenericFiber.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Fiber/GenericFiber.lean +@@ -12,38 +12,13 @@ import Mathlib.RingTheory.DedekindDomain.Different + import Mathlib.RingTheory.DedekindDomain.Factorization + + /-! +-# Generic fiber cardinality (T-II-2-009, Silverman II.2.6(b)) ++For a coordinate-ring morphism, if a nonzero prime is unramified and all residue ++field degrees above it are one, its number of primes above equals the ++function-field degree. For a separable morphism this is the separable degree. ++The algebraic support also identifies finite ramification loci through the ++different ideal and constructs smooth points over algebraically closed fields. + +-For a nonconstant morphism `φ : C₁ → C₂` of smooth curves, for almost all +-points `Q ∈ C₂`, the fiber `φ⁻¹(Q)` has cardinality equal to the +-separable degree `deg_s(φ)`. +- +-This file provides the **algebraic-geometric content** of T-II-2-009 at +-the Dedekind-domain level, building on the `CurveMap` + `CoordHom` +-infrastructure: if we can exhibit a maximal ideal `p ⊂ C₂.CoordinateRing` +-that is **unramified** and has **trivial residue-field degrees**, then +-the number of primes above it equals the function-field degree `deg(φ)` +-(which coincides with `deg_s(φ)` for separable `φ`). +- +-This is one side of Silverman's II.2.6(b): the fibre-cardinality statement +-in terms of the discrete-prime count. The other direction — **exhibiting** +-such an unramified prime `p` — requires the primitive-element-plus- +-discriminant construction over a base that sees "almost all" `Q` (i.e. +-the unramified locus is a dense open). Over arbitrary `F`, this is the +-main piece still missing; see the progress note at the end. +- +-## Main results +- +-* `CurveMap.primesOverFinset_card_eq_degree_of_unramified` — given an +- unramified prime `p` with every residue-field degree `f_P = 1`, the +- number of primes above `p` equals `φ.degree`. +-* `CurveMap.primesOverFinset_card_eq_sepDegree_of_separable_and_unramified` +- — same conclusion in terms of `sepDegree` under the separability +- hypothesis (which forces `deg = sepDeg`). +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], II.2.6(b). ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, II.2.6(b). + -/ + + namespace HasseWeil.Curves +@@ -52,12 +27,6 @@ namespace CurveMap + + variable {F : Type*} [Field F] {C₁ C₂ : SmoothPlaneCurve F} + +-/-- **T-II-2-009, algebraic direction** (unramified + trivial residue +-degrees ⇒ fiber count = degree). Given a `CurveMap` with `CoordHom` +-witness and a maximal ideal `p ⊂ C₂.CoordinateRing` that is +-(i) non-zero, (ii) has every ramification index = 1 on the primes above it, +-and (iii) has every inertia (residue) degree = 1, the number of primes +-above `p` equals `φ.degree`. -/ + theorem primesOverFinset_card_eq_degree_of_unramified + [IsIntegrallyClosed C₂.CoordinateRing] + [IsIntegrallyClosed C₁.CoordinateRing] +@@ -67,10 +36,10 @@ theorem primesOverFinset_card_eq_degree_of_unramified + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + ∀ P ∈ IsDedekindDomain.primesOverFinset p C₁.CoordinateRing, + Ideal.ramificationIdx' p P * +- Ideal.inertiaDeg' p P = 1) : ++ P.inertiaDeg C₂.CoordinateRing = 1) : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + (IsDedekindDomain.primesOverFinset p C₁.CoordinateRing).card = φ.degree := by +- letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra ++ let : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + have hsum := φ.sum_ramificationIdx_mul_inertiaDeg_eq_degree + coordHom coordHom.module_finite hpMax hp0 + -- Σ_{P ∈ S} (e · f) = deg. With each e·f = 1, LHS = S.card. +@@ -80,10 +49,6 @@ theorem primesOverFinset_card_eq_degree_of_unramified + rw [Finset.sum_const, Nat.smul_one_eq_cast] at hsum' + exact_mod_cast hsum' + +-/-- **T-II-2-009 (separable case)**: for a separable `CurveMap` with an +-unramified + trivial-residue-degree prime, the fiber count equals +-`sepDegree`. Uses the fact that `sepDegree = degree` for separable +-extensions (via `Field.finSepDegree_eq_finrank_iff`). -/ + theorem primesOverFinset_card_eq_sepDegree_of_separable_and_unramified + [IsIntegrallyClosed C₂.CoordinateRing] + [IsIntegrallyClosed C₁.CoordinateRing] +@@ -94,11 +59,11 @@ theorem primesOverFinset_card_eq_sepDegree_of_separable_and_unramified + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + ∀ P ∈ IsDedekindDomain.primesOverFinset p C₁.CoordinateRing, + Ideal.ramificationIdx' p P * +- Ideal.inertiaDeg' p P = 1) : ++ P.inertiaDeg C₂.CoordinateRing = 1) : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + (IsDedekindDomain.primesOverFinset p C₁.CoordinateRing).card = φ.separableDegree := by + -- separable + finite-dim ⇒ sepDegree = degree. +- letI : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ let : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra + have hsep_eq : φ.degree = φ.separableDegree := by + change φ.degree = @Field.finSepDegree _ _ _ _ φ.toAlgebra + have hinsep : φ.inseparableDegree = 1 := hsep +@@ -112,17 +77,6 @@ theorem primesOverFinset_card_eq_sepDegree_of_separable_and_unramified + exact φ.primesOverFinset_card_eq_degree_of_unramified coordHom + hpMax hp0 h_ef_one + +-/-! ### Piece 1 — bad locus `{p : p ∣ differentIdeal}` is finite +- +-For a finite separable extension of Dedekind domains `A → B`, the set of +-maximal ideals `p ⊂ A` that ramify (i.e. divide `differentIdeal A B`) +-is **finite**. Direct consequence of `differentIdeal_ne_bot` + +-`Ideal.finite_factors`. -/ +- +-/-- **T-II-2-009 Piece 1**: the set of height-one primes of `B` that +-divide `differentIdeal A B` is finite. These are the "ramified primes" +-in the `A → B` extension (primes above which at least one prime of `B` +-has `e_P ≥ 2`). Silverman II.2.6(b) "finitely many bad Q". -/ + theorem _root_.IsDedekindDomain.finite_ramified_primes + {A : Type*} [CommRing A] [IsDedekindDomain A] + {B : Type*} [CommRing B] [IsDedekindDomain B] +@@ -132,20 +86,13 @@ theorem _root_.IsDedekindDomain.finite_ramified_primes + (FractionRing.liftAlgebra A (FractionRing B))) : + {P : IsDedekindDomain.HeightOneSpectrum B | + P.asIdeal ∣ differentIdeal A B}.Finite := by +- letI : Algebra (FractionRing A) (FractionRing B) := ++ let : Algebra (FractionRing A) (FractionRing B) := + FractionRing.liftAlgebra A (FractionRing B) +- haveI : IsScalarTower A (FractionRing A) (FractionRing B) := ++ have : IsScalarTower A (FractionRing A) (FractionRing B) := + FractionRing.isScalarTower_liftAlgebra A (FractionRing B) +- haveI := hsep ++ have := hsep + exact Ideal.finite_factors (differentIdeal_ne_bot (A := A) (B := B)) + +-/-! ### Piece 2 — `¬ P ∣ differentIdeal ⇒ IsUnramifiedAt A P` +- +-Direct corollary of mathlib's `not_dvd_differentIdeal_iff`. Packages the +-easier direction as a standalone lemma for use in Pieces 3–5. -/ +- +-/-- **T-II-2-009 Piece 2**: a prime of `B` that does not divide the +-different ideal is unramified over `A`. -/ + theorem _root_.IsDedekindDomain.isUnramifiedAt_of_not_dvd_differentIdeal + {A : Type*} [CommRing A] [IsDedekindDomain A] + {B : Type*} [CommRing B] [IsDedekindDomain B] +@@ -155,50 +102,27 @@ theorem _root_.IsDedekindDomain.isUnramifiedAt_of_not_dvd_differentIdeal + (FractionRing.liftAlgebra A (FractionRing B))) + {P : Ideal B} [P.IsPrime] (hnd : ¬ P ∣ differentIdeal A B) : + Algebra.IsUnramifiedAt A P := by +- letI : Algebra (FractionRing A) (FractionRing B) := ++ let : Algebra (FractionRing A) (FractionRing B) := + FractionRing.liftAlgebra A (FractionRing B) +- haveI : IsScalarTower A (FractionRing A) (FractionRing B) := ++ have : IsScalarTower A (FractionRing A) (FractionRing B) := + FractionRing.isScalarTower_liftAlgebra A (FractionRing B) +- haveI := hsep ++ have := hsep + exact not_dvd_differentIdeal_iff.mp hnd + +-/-! ### Piece 3 — `IsUnramifiedAt P ⇒ e_{P|A} = 1` +- +-Corollary of mathlib's `Ideal.ramificationIdx_eq_one_of_isUnramifiedAt`. +-Packages the ramification-index side of unramifiedness; the inertia-degree +-side (`f_P = 1`) requires the residue field to be trivial over the base, +-which is **automatic over algebraically closed `F`** but must be supplied +-externally over arbitrary base fields. -/ +- +-/-- **T-II-2-009 Piece 3 (ramification half)**: a prime `P` of `B` that is +-unramified over `A` has ramification index `1` (at its image in `A`). +-Direct corollary of mathlib's `Ideal.ramificationIdx_eq_one_of_isUnramifiedAt`. -/ + theorem _root_.IsDedekindDomain.ramificationIdx_eq_one_of_isUnramifiedAt_of_ne_bot + {A : Type*} [CommRing A] [IsDomain A] + {B : Type*} [CommRing B] [IsDomain B] [IsNoetherianRing B] + [Algebra A B] [Algebra.EssFiniteType A B] + {P : Ideal B} [P.IsPrime] [Algebra.IsUnramifiedAt A P] (hP : P ≠ ⊥) : + Ideal.ramificationIdx' (P.under A) P = 1 := by +- haveI : P.LiesOver (P.under A) := ⟨rfl⟩ +- letI := Localization.AtPrime.algebraOfLiesOver (P.under A) P ++ have : P.LiesOver (P.under A) := ⟨rfl⟩ ++ let := Localization.AtPrime.algebraOfLiesOver (P.under A) P + have hmap : (P.under A).map (algebraMap A (Localization.AtPrime P)) = + IsLocalRing.maximalIdeal _ := + ((Algebra.isUnramifiedAt_iff_map_eq A (P.under A) P).mp ‹_›).2 + exact Ideal.ramificationIdx'_eq_one_of_map_localization Ideal.map_comap_le hP + (Ideal.primeCompl_le_nonZeroDivisors P) hmap + +-/-! ### Piece 4 — existence of an unramified prime +- +-Given Piece 1 (bad locus finite) and the assumption that `B` has +-infinitely many height-one primes (a genuine curve-theory input, since a +-Dedekind domain of infinite F-dimension has infinite spectrum), there +-exists a prime `P` of `B` outside the ramified locus. Piece 2 then turns +-"not in bad locus" into `IsUnramifiedAt A P`. -/ +- +-/-- **T-II-2-009 Piece 4**: combining Piece 1 (bad locus finite) + Piece 2 +-(not-in-bad-locus ⇒ IsUnramifiedAt), plus the hypothesis that `B` has +-infinitely many height-one primes, we extract a specific prime +-`P : HeightOneSpectrum B` that is unramified over `A`. -/ + theorem _root_.IsDedekindDomain.exists_unramified_prime + {A : Type*} [CommRing A] [IsDedekindDomain A] + {B : Type*} [CommRing B] [IsDedekindDomain B] +@@ -229,30 +153,9 @@ theorem _root_.IsDedekindDomain.exists_unramified_prime + exact hfin_bad.subset this + obtain ⟨P, hP⟩ := hgood_nonempty + refine ⟨P, ?_⟩ +- haveI : P.asIdeal.IsPrime := P.isPrime ++ have : P.asIdeal.IsPrime := P.isPrime + exact IsDedekindDomain.isUnramifiedAt_of_not_dvd_differentIdeal hsep hP + +-/-! ### Piece 5 — composed theorem at the abstract Dedekind level +- +-Combining Pieces 1–4 yields: for a finite separable extension of Dedekind +-domains `A → B` with `B` having infinitely many height-one primes, there +-exists a specific prime `P` of `B` for which the ramification index is +-exactly `1`. +- +-Specialised to `CurveMap + CoordHom` + `[IsAlgClosed F]` (where residue +-field degrees are automatically `1`), this gives `(primesOverFinset).card +-= φ.degree` — the full Silverman II.2.6(b) content. -/ +- +-/-- **T-II-2-009 Piece 5 (composed at A → B level)**: assembles Pieces +-1–4 into a single witness. For `A → B` Dedekind + finite separable + +-`B` infinite in primes, there exists a `P ∈ HeightOneSpectrum B`, +-nonzero, with `ramificationIdx' (P.under A → P) = 1`. +- +-The inertia degree `f_P = 1` is NOT concluded here — it depends on the +-residue-field extension being trivial, which is automatic over +-algebraically closed base (or for F-rational smooth points), and +-supplied as a separate hypothesis when needed (see +-`primesOverFinset_card_eq_degree_of_unramified`). -/ + theorem _root_.IsDedekindDomain.exists_unramifiedPrime_ramificationIdx_eq_one + {A : Type*} [CommRing A] [IsDedekindDomain A] + {B : Type*} [CommRing B] [IsDedekindDomain B] +@@ -265,31 +168,17 @@ theorem _root_.IsDedekindDomain.exists_unramifiedPrime_ramificationIdx_eq_one + ∃ P : IsDedekindDomain.HeightOneSpectrum B, + Ideal.ramificationIdx' (P.asIdeal.under A) P.asIdeal = 1 := by + obtain ⟨P, hunram⟩ := IsDedekindDomain.exists_unramified_prime hsep hinf +- haveI : P.asIdeal.IsPrime := P.isPrime +- haveI := hunram ++ have : P.asIdeal.IsPrime := P.isPrime ++ have := hunram + refine ⟨P, ?_⟩ + exact IsDedekindDomain.ramificationIdx_eq_one_of_isUnramifiedAt_of_ne_bot P.ne_bot + + end CurveMap + +-/-! ### Piece 6 — HeightOneSpectrum infinite over alg-closed base +- +-Over an algebraically closed base `F` with `[IsElliptic]`, the coordinate +-ring `C.CoordinateRing` has infinitely many height-one primes. The proof +-goes via the `smoothPointEquivHeightOneSpectrum` bijection +-(in `HasseWeil/Curves/SmoothPointPrime.lean`), reducing to showing +-`C.SmoothPoint` is infinite. This follows because for each `x ∈ F`, the +-Weierstrass equation in `y` is a quadratic over an algebraically closed +-field and hence has a root — giving an injection `F → C.SmoothPoint`. -/ +- + namespace SmoothPlaneCurve + + variable {F : Type*} [Field F] + +-/-- **T-II-2-009 Piece 6 (smooth points)**: for every `x ∈ F` over an +-algebraically closed field, there exists `y : F` with `(x, y)` a +-nonsingular point on the elliptic curve (any point on an elliptic curve +-is automatically nonsingular since `Δ ≠ 0`). -/ + theorem exists_smoothPoint_of_x + [IsAlgClosed F] (C : SmoothPlaneCurve F) [C.toAffine.IsElliptic] (x : F) : + ∃ P : C.SmoothPoint, P.x = x := by +@@ -320,9 +209,6 @@ theorem exists_smoothPoint_of_x + (W := C.toAffine)).mp heq + exact ⟨⟨x, y, hns⟩, rfl⟩ + +-/-- **T-II-2-009 Piece 6**: `C.SmoothPoint` is infinite over an +-algebraically closed base. Via the injection `x ↦ (smooth point with +-that x-coordinate)`. -/ + theorem smoothPoint_infinite + [IsAlgClosed F] (C : SmoothPlaneCurve F) [C.toAffine.IsElliptic] : + Infinite C.SmoothPoint := by +@@ -338,17 +224,13 @@ theorem smoothPoint_infinite + rw [h₁, h₂] at this + exact this + +-/-- **T-II-2-009 Piece 6 (main)**: the height-one spectrum of +-`C.CoordinateRing` is infinite over an algebraically closed elliptic +-curve, via the bijection `SmoothPoint ≃ HeightOneSpectrum` from +-`HasseWeil/Curves/SmoothPointPrime.lean`. -/ + theorem heightOneSpectrum_infinite + [IsAlgClosed F] (C : SmoothPlaneCurve F) [C.toAffine.IsElliptic] + [IsIntegrallyClosed C.CoordinateRing] : + Set.Infinite ({_P : IsDedekindDomain.HeightOneSpectrum C.CoordinateRing | + True}) := by +- haveI : Infinite C.SmoothPoint := C.smoothPoint_infinite +- haveI : Infinite (IsDedekindDomain.HeightOneSpectrum C.CoordinateRing) := ++ have : Infinite C.SmoothPoint := C.smoothPoint_infinite ++ have : Infinite (IsDedekindDomain.HeightOneSpectrum C.CoordinateRing) := + Infinite.of_injective C.smoothPointEquivHeightOneSpectrum + C.smoothPointEquivHeightOneSpectrum.injective + exact Set.infinite_univ +@@ -358,52 +240,11 @@ end SmoothPlaneCurve + namespace CurveMap + variable {F : Type*} [Field F] {C₁ C₂ : SmoothPlaneCurve F} + +-/-! ### Piece 7 — residue fields at smooth points are `F` +- +-The residue-field-degree-one content (f_P = 1) of T-II-2-009 Piece 7. +-Rather than prove `inertiaDeg' = 1` directly — which hits a diamond +-between `Module.Free` from `Ideal.Quotient` vs `DivisionRing` paths — +-we package the residue-field F-rank: `finrank F (C.CoordinateRing / +-maximalIdealAt P) = 1`. Any consumer wanting `inertiaDeg' = 1` over an +-F-rational SmoothPoint combines this (for source + target) with the +-tower `finrank_mul_finrank`; the direct +-`inertiaDeg_maximalIdealAt` covers the specific `F[X] → F[C]` case. -/ +- +-/-- **T-II-2-009 Piece 7 (residue field)**: the residue field of +-`C.CoordinateRing` at a smooth point `P` equals `F` (as `F`-module of +-rank 1). Direct re-export of `finrank_quotientMaximalIdealAt` +-for use in the Piece 8 chain. -/ + theorem finrank_quotientMaximalIdealAt_eq_one + (C : SmoothPlaneCurve F) (P : C.SmoothPoint) : + Module.finrank F (C.CoordinateRing ⧸ C.maximalIdealAt P) = 1 := + C.finrank_quotientMaximalIdealAt P + +-/-! ### Piece 8 — final assembly: T-II-2-009 for CurveMap +- +-Combines Pieces 1–7: given a CurveMap with CoordHom, separable, +-and ([IsAlgClosed F] providing infinite spectrum + residue-degree=1), +-there's a maximal ideal of `C₂.CoordinateRing` whose fiber (primes above +-it in `C₁.CoordinateRing`) has cardinality equal to `φ.separableDegree`. +- +-The `f_P = 1` side of the inertia +-computation is supplied as a **witness hypothesis** (`h_inertia_one`) +-rather than proven in-line, due to the `Module.Free` diamond between +-`Ideal.Quotient.semiring` and `DivisionRing.toDivisionSemiring.toSemiring` +-paths. Under `[IsAlgClosed F]`, the hypothesis is always satisfied +-(both residue fields are `F`); the caller supplies it via +-`SmoothPlaneCurve.finrank_quotientMaximalIdealAt_eq_one` (Piece 7) for +-each prime in their specific setting. -/ +- +-/-- **T-II-2-009 Piece 8 (full assembly, witness form)**: given the +-witness hypotheses for unramified existence + trivial residue degrees, +-produce a prime of `C₂.CoordinateRing` whose fiber in `C₁.CoordinateRing` +-has cardinality `φ.separableDegree`. +- +-The existence of an unramified Q (via Pieces 1–6 for alg-closed base) is +-bundled as `h_unramified_Q`. The trivial residue degree is bundled as +-`h_inertia_one` (follows from Piece 7 over [IsAlgClosed F] via the +-`maximalIdealAt` ↔ `HeightOneSpectrum` bijection from +-`smoothPointEquivHeightOneSpectrum`). -/ + theorem exists_heightOneSpectrum_fiber_card_eq_sepDegree + [IsIntegrallyClosed C₂.CoordinateRing] + [IsIntegrallyClosed C₁.CoordinateRing] +@@ -414,94 +255,15 @@ theorem exists_heightOneSpectrum_fiber_card_eq_sepDegree + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + ∀ P ∈ IsDedekindDomain.primesOverFinset Q.asIdeal C₁.CoordinateRing, + Ideal.ramificationIdx' Q.asIdeal P * +- Ideal.inertiaDeg' Q.asIdeal P = 1) : ++ P.inertiaDeg C₂.CoordinateRing = 1) : + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + (IsDedekindDomain.primesOverFinset Q.asIdeal C₁.CoordinateRing).card = φ.separableDegree := by +- haveI : Q.asIdeal.IsPrime := Q.isPrime +- haveI hQmax : Q.asIdeal.IsMaximal := ++ have : Q.asIdeal.IsPrime := Q.isPrime ++ have hQmax : Q.asIdeal.IsMaximal := + Q.isPrime.isMaximal Q.ne_bot + exact φ.primesOverFinset_card_eq_sepDegree_of_separable_and_unramified + coordHom hsep hQmax Q.ne_bot h_ef_one_Q + +-/-! ### Piece 9 — `inertiaDeg' = 1` at smooth points: diamond-blocked +- +-**Status**: blocked by the `Module.Free (C₂.CR/Q) (C₁.CR/P)` typeclass +-diamond. The attempted workaround — using `F` as outer ring in +-`Module.finrank_mul_finrank F _ _` — does **not** bypass the problem, +-because `finrank_mul_finrank` still requires `Module.Free` on the +-intermediate extension. Specifically: +- +-- `Module.Free.of_divisionRing` produces `Module.Free` via +- `DivisionRing.toDivisionSemiring.toSemiring`. +-- The expected instance on `(C₂.CR/Q)`-module `(C₁.CR/P)` goes through +- `Ideal.Quotient.semiring` and `Algebra.toModule`. +-- These two `Semiring` parent-paths do not unify — the same `Module.Free` +- diamond between the two `Semiring` structures. +- +-The narrower witness form (`exists_heightOneSpectrum_fiber_card_eq_sepDegree`, +-Piece 8 above) takes the `e_P · f_P = 1` hypothesis as input and is the +-shippable deliverable. Closing `inertiaDeg' = 1` without the diamond +-requires either: +- +-1. A mathlib-level change to make `Ideal.Quotient.semiring` and +- `Field`-derived `Semiring` agree definitionally, OR +-2. A residue-field algebra isomorphism `C.CR/(maximalIdealAt P) ≃ₐ[F] F` +- (under `[IsAlgClosed F]`), expressed without passing through +- `Module.Free` synthesis on the intermediate quotient, OR +-3. A direct computation of `Ideal.inertiaDeg'` from the algebra-map +- surjectivity at smooth points on an algebraically closed base. +- +-The second route is the most promising — a dedicated file +-`HasseWeil/Curves/ResidueFieldAtSmoothPoint.lean` building an explicit +-`AlgEquiv` at each smooth point and then transporting `inertiaDeg'` +-through it would sidestep `finrank_mul_finrank` entirely. Estimated +-~100 LOC. Deferred. -/ +- +-/-! ### Progress note — the remaining piece (existence of unramified p) +- +-The full T-II-2-009 statement **`∃ Q, #φ⁻¹(Q) = sepDeg(φ)`** reduces (via +-the theorems above) to exhibiting a maximal `p ⊂ C₂.CoordinateRing` with +-the ramification + inertia witnesses. Over an algebraically-closed base +-field `F`, such a `p` always exists because: +- +-1. **Primitive element**: the separable closure `L ⊂ C₁.FunctionField` +- of `φ*(C₂.FunctionField)` is generated by a primitive element `α` +- with minimal polynomial `m(T) ∈ (φ*C₂.FunctionField)[T]` of degree +- `sepDeg(φ)`. +- +-2. **Discriminant**: `m` is separable (primitive-element condition), so +- `discriminant(m)` is a nonzero element of `φ*C₂.FunctionField`. +- Viewed in `C₂.FunctionField`, it has finitely many zeros (as an element +- of a function field with a degree structure). +- +-3. **Dense open**: at any `p ⊂ C₂.CoordinateRing` outside the zero locus +- of `discriminant(m)`, the specialisation `m̄ ∈ (C₂.CoordinateRing/p)[T]` +- has `sepDeg(φ)` distinct roots in `C₁.CoordinateRing/P` for each `P` +- above `p`. This gives the ramification + inertia witnesses. +- +-The formalisation gap: +-- Mathlib has `Field.exists_primitive_element` (step 1) and +- `Polynomial.discriminant_ne_zero_of_separable` (step 2). +-- Step 3 requires the algebraic-geometric bridge between "discriminant +- nonzero at `p`" and "unramified at `p` with trivial residue +- extensions". For Dedekind extensions this is +- `Algebra.IsUnramifiedAt ↔ ¬ p ∣ differentIdeal`, and over alg-closed +- base the residue fields all equal `F`, making `inertiaDeg' = 1` +- automatic. +- +-This last step is ~200 lines of algebraic-geometric infrastructure +-following Silverman + Neukirch (*Algebraic Number Theory*, III.2). The +-algebraic core (steps 1–2) is immediate in mathlib; step 3 is the +-substantive remaining content. Tracked under T-II-2-009's progress log. +- +-The **alternative path** `#ker β_pc = sepDeg β_pc` (for the specific +-β_pc = 1 − π) can be closed *without* the full T-II-2-009 once +-`AdditionPullback.lean` replaces the `isogOneSub` placeholder — that +-gives the real function-field pullback, from which `deg β_pc = +-[K(E) : φ*K(E)] = q + 1 − t` follows via explicit computation, and +-`#ker β_pc = pointCount = q + 1 − t` then furnishes `#ker β_pc = deg +-β_pc` directly. -/ +- + end CurveMap + + end HasseWeil.Curves +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Frobenius/FrobeniusFixedPoint.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Frobenius/FrobeniusFixedPoint.lean +index 758285749..d4ec75e01 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Frobenius/FrobeniusFixedPoint.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Frobenius/FrobeniusFixedPoint.lean +@@ -9,60 +9,12 @@ import Mathlib.FieldTheory.Finite.Basic + import Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure + + /-! +-# Geometric Frobenius on points over the algebraic closure (Route B, Step 2) ++For a finite field `K` of cardinality `q`, the map `(x, y) ↦ (x ^ q, y ^ q)` ++on the algebraic-closure points of a Weierstrass curve fixes exactly the ++`K`-rational points. Consequently the kernel of the identity minus Frobenius ++has cardinality equal to the number of `K`-rational points. + +-For a finite field `K` with `q = Fintype.card K` and a Weierstrass curve `W` over `K`, +-base-changed to `L = AlgebraicClosure K`, this file builds the **geometric Frobenius** +-endomorphism on the `L`-points, +- +-``` +-geomFrobeniusPoint : (W.baseChange L).toAffine.Point →+ (W.baseChange L).toAffine.Point +-``` +- +-acting as `(x, y) ↦ (x ^ q, y ^ q)` (and `0 ↦ 0`), via mathlib's `FiniteField.frobeniusAlgHom` +-(`x ↦ x ^ q`, a `K`-algebra hom on `L`) transported to points by the project's +-`HasseWeil.Affine.Point.map`. The codomain identification +- +-``` +-(W.baseChange L).map (frobeniusAlgHom K L) = W.baseChange L +-``` +- +-(`WeierstrassCurve.map_baseChange`, because the `q`-power map is a `K`-algebra hom and so +-fixes the `algebraMap K L` image) makes this an *endomorphism* of the same point type. +- +-It also packages the base-change inclusion of `K`-points +- +-``` +-includePointBC : W.toAffine.Point →+ (W.baseChange L).toAffine.Point +-``` +- +-via `HasseWeil.Affine.Point.map (algebraMap K L)`. +- +-## Main result (Step 2 = S2) +- +-* `HasseWeil.geomFrobeniusPoint_fixed_iff_mem_range_includePointBC`: +- `geomFrobeniusPoint P = P ↔ P ∈ Set.range includePointBC`, +- the *point-level* fixed-locus theorem. Proof by cases on `P`: +- - `P = 0` is fixed and `0 = includePointBC 0`; +- - `P = (x, y)` is fixed iff `x ^ q = x ∧ y ^ q = y`, iff (by Step 1 +- `frobenius_fixed_iff_mem_baseField`) both coordinates lie in `range (algebraMap K L)`, +- iff `P = includePointBC (x₀, y₀)`. +- +-## Further results (S3/S4 and the `1 − π` kernel) +- +-* `fixedLocus_geomFrobenius_eq_range_includePointBC` (S3): the `Set`-form of S2 — the +- geometric-Frobenius fixed locus equals `Set.range (includePointBC W)`. +-* `ncard_fixedLocus_geomFrobenius_eq_pointCount` (S4): that fixed locus has cardinality +- `Fintype.card W.toAffine.Point` (`= pointCount W`), using injectivity of `includePointBC`. +-* `ncard_ker_oneSubGeomFrobHom_eq_pointCount`: the same count for the kernel of the +- `AddMonoidHom` `id − geomFrobeniusPoint`. +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, V.1.1. +-* Step 1: `HasseWeil.frobenius_fixed_iff_mem_baseField` (`Curves/FrobeniusFixedLocus.lean`). +-* mathlib: `FiniteField.frobeniusAlgHom`, `WeierstrassCurve.map_baseChange`, +- `WeierstrassCurve.Affine.Point.map`. ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, V.1.1. + -/ + + open WeierstrassCurve +@@ -76,8 +28,6 @@ local notation "L" => AlgebraicClosure K + + noncomputable local instance : DecidableEq (AlgebraicClosure K) := Classical.decEq _ + +-/-! ### The geometric Frobenius `K`-algebra hom and the codomain identification -/ +- + /-- The geometric Frobenius `K`-algebra hom `x ↦ x ^ q` on `L = AlgebraicClosure K`, + as a ring hom. This is `FiniteField.frobeniusAlgHom K L`, coerced to a `RingHom`. -/ + noncomputable def geomFrobRingHom : AlgebraicClosure K →+* AlgebraicClosure K := +@@ -106,13 +56,11 @@ fixes `algebraMap K L`). -/ + rw [AlgHom.toRingHom_eq_coe] + exact W.map_baseChange (FiniteField.frobeniusAlgHom K (AlgebraicClosure K)) + +-/-! ### Geometric Frobenius on points and the base-change inclusion -/ +- + /-- The geometric Frobenius on `L`-points as a raw map: mathlib's + `WeierstrassCurve.Affine.Point.map` of the geometric Frobenius `K`-algebra hom + `frobeniusAlgHom K L : L →ₐ[K] L`. Its codomain `W⟮L⟯ = Point (W.baseChange L)` + is **definitionally** `(W.baseChange L).toAffine.Point`, so no cast is needed. +-This mirrors `frobeniusW_KE` in `Hasse/IsogOneSubXyFamily.lean`. -/ ++-/ + noncomputable def geomFrobeniusPointFun : + (W.baseChange (AlgebraicClosure K)).toAffine.Point → + (W.baseChange (AlgebraicClosure K)).toAffine.Point := +@@ -184,17 +132,9 @@ theorem includePointBC_injective : Function.Injective (includePointBC W) := by + subst hx' hy' + rfl + +-/-! ### S2 — the point-level fixed-locus theorem +- +-We work directly with the raw functions to keep the rewriting along +-`map_geomFrob_baseChange_eq_self` explicit. The `0` case is reflexivity; the affine case +-reduces, via `HasseWeil.Affine.Point.map_some` and `some.injEq`, to the conjunction +-`x ^ q = x ∧ y ^ q = y`, which Step 1 (`frobenius_fixed_iff_mem_baseField`) turns into +-membership of both coordinates in `range (algebraMap K L)`. -/ +- + omit [DecidableEq K] in + set_option backward.isDefEq.respectTransparency false in +-/-- **S2 (point fixed-locus)**: a point `P` over the algebraic closure is fixed by the ++/-- a point `P` over the algebraic closure is fixed by the + geometric Frobenius iff it is the base-change inclusion of a `K`-rational point. + + `geomFrobeniusPointFun P = P ↔ P ∈ Set.range (includePointBC W)`. +@@ -202,7 +142,7 @@ geometric Frobenius iff it is the base-change inclusion of a `K`-rational point. + Proof by cases on `P`: + * `P = 0`: fixed, and `0 = includePointBC 0`. + * `P = some x y h`: `Frob P = P ↔ x ^ q = x ∧ y ^ q = y` (coordinatewise, by +- `Affine.Point.map_some` + `some.injEq`), and by Step 1 each coordinate is fixed iff it ++ `Affine.Point.map_some` + `some.injEq`), and each coordinate is fixed iff it + lies in `range (algebraMap K L)`; assembling the two `K`-rational coordinates back into a + nonsingular `K`-point gives `P ∈ range includePointBC`. + +@@ -217,7 +157,7 @@ theorem geomFrobeniusPoint_fixed_iff_mem_range_includePointBC + · -- `P = 0`: fixed (`map_zero` is `rfl`), and `0 = includePointBC 0`. + exact iff_of_true rfl ⟨0, includePointBC_zero W⟩ + · -- `P = some x y h`. LHS reduces to `x ^ q = x ∧ y ^ q = y` (coordinatewise), +- -- each equivalent by Step 1 to membership in `range (algebraMap K L)`. ++ -- each equivalent to membership in `range (algebraMap K L)`. + rw [geomFrobeniusPointFun_some, Affine.Point.some.injEq] + show (FiniteField.frobeniusAlgHom K (AlgebraicClosure K)) x = x ∧ + (FiniteField.frobeniusAlgHom K (AlgebraicClosure K)) y = y ↔ _ +@@ -242,37 +182,18 @@ theorem geomFrobeniusPoint_fixed_iff_mem_range_includePointBC + rw [Affine.Point.some.injEq] at hQ + exact ⟨⟨x₀, hQ.1⟩, ⟨y₀, hQ.2⟩⟩ + +-/-! ### S3 — kernel of `1 − π` over `L` = image of `E(K)` +- +-The forward inclusion `range includePointBC ⊆ +-{P | geomFrobeniusPointFun P = P}` is the "rational ⇒ fixed" direction (a rational `P` +-has `(1 − π)P = P − πP = P − P = 0`); the reverse is the substantive S2 content. As an +-*equality of sets* this is literally S2 (`geomFrobeniusPoint_fixed_iff_mem_range_includePointBC`) +-repackaged, so we state it that way and reduce to S2. -/ +- + omit [DecidableEq K] in +-/-- **S3 (set form)**: the fixed locus of the geometric Frobenius equals the image of the +-`K`-rational points. This is S2 in `Set` form. -/ ++/-- the fixed locus of the geometric Frobenius equals the image of the ++`K`-rational points. -/ + theorem fixedLocus_geomFrobenius_eq_range_includePointBC : + {P : (W.baseChange (AlgebraicClosure K)).toAffine.Point | geomFrobeniusPointFun W P = P} = + Set.range (includePointBC W) := by + ext P + exact geomFrobeniusPoint_fixed_iff_mem_range_includePointBC W P + +-/-! ### S4 — cardinality glue +- +-The final glue: `# ker(id − geomFrobeniusPoint) = pointCount W`. S2/S3 identify the +-fixed locus with `range includePointBC`, and `includePointBC` is injective (it is +-`Affine.Point.map` of an injective ring hom, see `WeierstrassCurve.Affine.Point.map_injective`), +-so the fixed locus is in bijection with `W.toAffine.Point`, whose cardinality is `pointCount W`. +-Combined with the algebraic-closed fibre count +-(`CurveMap.exists_heightOneSpectrum_fiber_card_eq_sepDegree_unconditional`) this yields +-`deg(1 − π) = pointCount`. -/ +- + omit [DecidableEq K] in +-/-- **S4 (cardinality)**: the number of geometric-Frobenius-fixed `L`-points equals +-the `K`-rational point count `Fintype.card W.toAffine.Point` (= `pointCount`). Reduces to S3 +-(`fixedLocus … = range includePointBC`) plus injectivity of `includePointBC`. -/ ++/-- the number of geometric-Frobenius-fixed `L`-points equals ++the `K`-rational point count `Fintype.card W.toAffine.Point` (= `pointCount`). -/ + theorem ncard_fixedLocus_geomFrobenius_eq_pointCount [Fintype W.toAffine.Point] : + {P : (W.baseChange (AlgebraicClosure K)).toAffine.Point | + geomFrobeniusPointFun W P = P}.ncard = Fintype.card W.toAffine.Point := by +@@ -280,15 +201,6 @@ theorem ncard_fixedLocus_geomFrobenius_eq_pointCount [Fintype W.toAffine.Point] + Set.ncard_range_of_injective (includePointBC_injective W), + Nat.card_eq_fintype_card] + +-/-! ### PRIORITY 1 — kernel of `id − geomFrobenius` over `L` +- +-The geometric Frobenius on `L`-points is already mathlib's +-`WeierstrassCurve.Affine.Point.map (frobeniusAlgHom K L)`, an `AddMonoidHom` +-`(W.baseChange L)⟮L⟯ →+ (W.baseChange L)⟮L⟯` whose `.toFun` is definitionally +-`geomFrobeniusPointFun W` (mirroring `frobeniusW_KE` in +-`Hasse/IsogOneSubXyFamily.lean`). We bundle it, form `1 − π` as an +-`AddMonoidHom`, and identify its kernel with the fixed locus. -/ +- + /-- **Geometric Frobenius on `L`-points as an `AddMonoidHom`**: mathlib's + `Affine.Point.map (frobeniusAlgHom K L)`. Its `.toFun` is definitionally + `geomFrobeniusPointFun W`. -/ +@@ -317,19 +229,19 @@ omit [DecidableEq K] in + oneSubGeomFrobHom W P = P - geomFrobeniusPointFun W P := rfl + + omit [DecidableEq K] in +-/-- **PRIORITY 1 (kernel = fixed locus)**: `P ∈ ker(id − geomFrob) ⟺ ++/-- `P ∈ ker(id − geomFrob) ⟺ + geomFrob P = P`. Direct from `sub_eq_zero`. -/ + theorem ker_oneSubGeomFrobHom_eq_fixedLocus : + ((oneSubGeomFrobHom W).ker : Set (W.baseChange (AlgebraicClosure K)).toAffine.Point) = + {P | geomFrobeniusPointFun W P = P} := by + ext P +- rw [SetLike.mem_coe, AddMonoidHom.mem_ker, Set.mem_setOf_eq, oneSubGeomFrobHom_apply, ++ rw [SetLike.mem_coe, AddMonoidHom.mem_ker, Set.mem_ofPred_eq, oneSubGeomFrobHom_apply, + sub_eq_zero, eq_comm] + + omit [DecidableEq K] in +-/-- **PRIORITY 1 (cardinality)**: the geometric-Frobenius fixed locus, i.e. ++/-- the geometric-Frobenius fixed locus, i.e. + `ker(id − geomFrob)`, has cardinality `pointCount W`. Composes +-`ker_oneSubGeomFrobHom_eq_fixedLocus` with S4 ++`ker_oneSubGeomFrobHom_eq_fixedLocus` with + (`ncard_fixedLocus_geomFrobenius_eq_pointCount`). -/ + theorem ncard_ker_oneSubGeomFrobHom_eq_pointCount [Fintype W.toAffine.Point] : + ((oneSubGeomFrobHom W).ker : +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/IntegralClosure.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/IntegralClosure.lean +index b3c5b8f64e3264fafd4ab131a093d258bbd32966..e257fed368990ece1c76792d0f26d887b83c989d 100644 +GIT binary patch +delta 353 +zcmYjMy-EW?5QaljTx|5TH6vK4gcKrzQN(~xU}9kv*1O5w;O%VO-HWCY?JTTTC8f0p +z5w7wfYF8~CqW>#7;BLNURz{Cib3_j7D!*ELspUs +zOcTct(*O;)+fEQcL~=^@g$1dM1;yBaQ;twi#H>3 +zt#Xz-sH}VYetuP1T$s5zn +l`4E)ESU?jPzVBaPd$SHSLviD5wL0_XU)k?k-Ws*%{sE*_f>{6n + +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CoordHomFinite.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CoordHomFinite.lean +index 5456f6e64..33637b28c 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CoordHomFinite.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CoordHomFinite.lean +@@ -6,70 +6,20 @@ Authors: Chris Birkbeck + import HasseWeil.Foundation.Curves.Map.CurveMap + + /-! +-# Module-finiteness along a coordinate-ring witness (the standing `hfin`, DERIVED) +- +-For a curve map `φ : C₁ → C₂` with a coordinate-ring pullback witness +-`cd : φ.CoordHom`, the coordinate ring `F[C₁]` is a **finite module** over +-`F[C₂]` via `cd.toAlgebra` — *unconditionally*. This derives the standing +-`Module.Finite` hypothesis (`hfin`) carried throughout the isogeny theory by +-`CurveMap.sum_ramificationIdx_mul_inertiaDeg_eq_degree`, +-`EC.Isogeny.addHomProperty` / `toBasicIsogeny` (K̄-level), +-`EC.Isogeny.addHomProperty_descend` / `toBasicIsogenyDescend` +-(K-level), `Isogeny.pushforward` (`Curves/PushforwardDivisor.lean`), +-`EC/KernelCount.lean`, and friends. +- +-## The proof (no separability, no places classification) +- +-Write `u := ψ(x₂) ∈ F[C₁]` for the image of the coordinate generator of `C₂` +-under an injective `F`-algebra map `ψ : F[C₂] →ₐ[F] F[C₁]`, and decompose +-`u = p•1 + q•Y` in the `{1, Y}` basis of `F[C₁]` over `F[x₁] = F[X]`. Then +-`u` satisfies the quadratic relation of its conjugate pair over `F[X]`: +- +-`u² − t(x₁)·u + n(x₁) = 0`, where `t := 2p − q·(a₁X + a₃)` and +-`n := p² − pq·(a₁X + a₃) − q²·(X³ + a₂X² + a₄X + a₆)` +- +-(`n` is mathlib's `Algebra.norm F[X] u`; the difference of the two sides is +-`q²·W(X, Y)`, which vanishes mod the Weierstrass polynomial). Reading the +-relation backwards as a polynomial in `x₁` with coefficients in the image of +-`ψ` gives `n(T) − u·t(T) + u² = 0` at `T = x₁`. +- +-**The parity trick**: `deg(p²) = 2 deg p` is even while +-`deg(q²·(X³ + ⋯)) = 2 deg q + 3` is odd, so the two leading terms never +-cancel: `deg n = max(2 deg p, 2 deg q + 3)` with leading coefficient a +-**unit of `F`** (`WeierstrassCurve.Affine.CoordinateRing.degree_norm_smul_basis`), +-and `deg t < deg n`. Hence the displayed `T`-polynomial is monic after +-scaling by that unit's inverse, with coefficients in the image of `F[C₂]`: +-the generator `x₁` is **integral** over `F[C₂]`. (`u ∉ F·1` because `ψ` is +-injective, ruling out the degenerate `q = 0 ∧ p constant` case.) Since +-`F[C₁]` is spanned by `F[x₁]·{1, Y}`, module-finiteness follows from +-`IsIntegral.fg_adjoin_singleton`. +- +-This argument works in **any characteristic and for inseparable maps** (for +-the Frobenius comorphism `u = x₁^p` it produces the monic witness +-`(T^p − u)²`-style relation), so no separability hypothesis, no AKLB +-machinery, and no Nagata-style finiteness of integral closures is needed. +-The classical "places of `K(C₁)` over affine places of `C₂` are point +-places" wall is bypassed entirely by the explicit Weierstrass presentation. +- +-## Main results +- +-* `algHom_coordinateRing_isIntegralElem_X` — the keystone: the coordinate +- generator `x₁` is integral over `F[C₂]` along any injective `F`-algebra +- hom `F[C₂] →ₐ[F] F[C₁]`. +-* `algHom_coordinateRing_module_finite` — `F[C₁]` is a finite module over +- `F[C₂]` along any injective `F`-algebra hom. +-* `CurveMap.CoordHom.toAlgHom_injective` — a `CoordHom` is automatically +- injective (from `compat` plus injectivity of the function-field pullback). +-* `CurveMap.CoordHom.module_finite` — **the deliverable**: the standing +- `hfin` hypothesis holds for every `(φ, cd)`, with no further assumptions. +-* `CurveMap.sum_ramificationIdx_mul_inertiaDeg_eq_degree'` — Silverman +- II.2.6(a) `Σ e·f = deg φ` with `hfin` discharged. +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], II.2.6, II.3 (finiteness +- of morphisms of smooth curves) — obtained here by direct +- Weierstrass-presentation algebra instead of valuation theory. ++An injective homomorphism between Weierstrass coordinate rings makes the target ++a finite module over the source. Writing the image of the source coordinate as ++`u = p + qY`, its trace and norm give a quadratic relation in `u` with ++polynomial coefficients in the target coordinate. The terms of the norm have ++opposite degree parity, so its leading coefficient is a unit and the trace ++has smaller degree. Reading this relation as a polynomial in the target ++coordinate gives a monic integral relation after scaling. ++ ++A compatible function-field pullback makes the coordinate-ring homomorphism ++injective. Thus the finite-module hypothesis in the weighted ramification ++sum follows for every coordinate-ring pullback witness, without separability ++or characteristic assumptions. ++ ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, II.2.6 and II.3. + -/ + + namespace HasseWeil.Curves +@@ -413,9 +363,9 @@ theorem algHom_coordinateRing_module_finite + (ψ : C₂.CoordinateRing →ₐ[F] C₁.CoordinateRing) (hψ : Function.Injective ψ) : + @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ + ψ.toRingHom.toAlgebra.toModule := by +- letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := ψ.toRingHom.toAlgebra +- letI : Module C₂.CoordinateRing C₁.CoordinateRing := Algebra.toModule +- haveI : IsScalarTower F C₂.CoordinateRing C₁.CoordinateRing := ++ let : Algebra C₂.CoordinateRing C₁.CoordinateRing := ψ.toRingHom.toAlgebra ++ let : Module C₂.CoordinateRing C₁.CoordinateRing := Algebra.toModule ++ have : IsScalarTower F C₂.CoordinateRing C₁.CoordinateRing := + IsScalarTower.of_algebraMap_eq fun c ↦ (ψ.commutes c).symm + have hx : IsIntegral C₂.CoordinateRing + (algebraMap (Polynomial F) C₁.CoordinateRing Polynomial.X) := +@@ -487,12 +437,7 @@ namespace CurveMap + -- Instance synthesis and unification at curve-indexed coordinate-ring types + -- (`AdjoinRoot`-quotients) need a higher budget; same settings as + -- `CurveMap.sum_ramificationIdx_mul_inertiaDeg_eq_degree`. +-/-- **Silverman II.2.6(a), Σ e·f form, `hfin`-free** (T-II-2-008): for a +-`CurveMap φ : C₁ → C₂` with coordinate-ring pullback witness `coordHom`, the +-sum `Σ_{P over p} e_P · f_P` equals the function-field degree `φ.degree`. +-The module-finiteness input of +-`sum_ramificationIdx_mul_inertiaDeg_eq_degree` is supplied by +-`CoordHom.module_finite`. -/ ++ + theorem sum_ramificationIdx_mul_inertiaDeg_eq_degree' + {C₁ C₂ : SmoothPlaneCurve F} + [IsIntegrallyClosed C₂.CoordinateRing] +@@ -502,7 +447,7 @@ theorem sum_ramificationIdx_mul_inertiaDeg_eq_degree' + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + ∑ P ∈ IsDedekindDomain.primesOverFinset p C₁.CoordinateRing, + Ideal.ramificationIdx' p P * +- Ideal.inertiaDeg' p P = φ.degree := ++ P.inertiaDeg C₂.CoordinateRing = φ.degree := + φ.sum_ramificationIdx_mul_inertiaDeg_eq_degree coordHom + coordHom.module_finite hpMax hp0 + +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMap.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMap.lean +index aae9d4fe3..67470605c 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMap.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMap.lean +@@ -1,6 +1,6 @@ + import HasseWeil.Foundation.Curves.Valuation.Valuation + import HasseWeil.Foundation.Curves.IntegralClosure +-import Mathlib.NumberTheory.RamificationInertia.Basic ++import Mathlib.RingTheory.RamificationInertia.Basic + + /-! + # Curve maps via function-field pullback +@@ -14,10 +14,6 @@ injective). + The **degree** of `φ` is the dimension of `K(C₁)` as a `K(C₂)`-module via + the pullback: `deg φ = [K(C₁) : φ*K(C₂)]`. + +-This closes tickets T-II-INFRA-B-006/007 of the Stream-A infrastructure plan +-and provides the foundational object for T-II-2-002..011 (which will add +-surjectivity, ramification, and the fiber-card formula). +- + ## References + + * [Silverman, *The Arithmetic of Elliptic Curves*], II.2.4 (curves-fields +@@ -79,8 +75,6 @@ theorem comp_assoc {C₄ : SmoothPlaneCurve F} + @[simp] theorem comp_id (φ : CurveMap C₁ C₂) : φ.comp (id C₁) = φ := + CurveMap.ext (AlgHom.id_comp _) + +-/-! ### Degree -/ +- + /-- The algebra structure on `K(C₁)` induced by the pullback of `φ`. -/ + @[reducible] + noncomputable def toAlgebra (φ : CurveMap C₁ C₂) : +@@ -110,12 +104,12 @@ theorem comp_algebraMap_eq (ψ : CurveMap C₂ C₃) (φ : CurveMap C₁ C₂) + theorem degree_comp (ψ : CurveMap C₂ C₃) (φ : CurveMap C₁ C₂) : + (ψ.comp φ).degree = φ.degree * ψ.degree := by + simp only [degree] +- letI : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- letI : Algebra C₃.FunctionField C₂.FunctionField := ψ.toAlgebra +- letI : Algebra C₃.FunctionField C₁.FunctionField := (ψ.comp φ).toAlgebra +- haveI : IsScalarTower C₃.FunctionField C₂.FunctionField C₁.FunctionField := ++ let : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ let : Algebra C₃.FunctionField C₂.FunctionField := ψ.toAlgebra ++ let : Algebra C₃.FunctionField C₁.FunctionField := (ψ.comp φ).toAlgebra ++ have : IsScalarTower C₃.FunctionField C₂.FunctionField C₁.FunctionField := + IsScalarTower.of_algebraMap_eq fun _ ↦ rfl +- haveI : Module.Free C₂.FunctionField C₁.FunctionField := ++ have : Module.Free C₂.FunctionField C₁.FunctionField := + Module.Free.of_divisionRing _ _ + rw [mul_comm] + exact (Module.finrank_mul_finrank +@@ -138,27 +132,11 @@ def IsSeparable (φ : CurveMap C₁ C₂) : Prop := φ.inseparableDegree = 1 + /-- A curve map is **purely inseparable** if its separable degree is 1. -/ + def IsPurelyInseparable (φ : CurveMap C₁ C₂) : Prop := φ.separableDegree = 1 + +--- **Silverman II.2.4.1** (pullback half, deferred): if `φ : C₁ → C₂` has +--- degree 1, its pullback is surjective. +--- Proof sketch: `finrank_eq_one_iff'` gives `v ≠ 0` with `K(C₁) = K(C₂) • v`. +--- From `c₀ • v = 1` in a field, `v = (algebraMap c₀)⁻¹`, so every `x ∈ K(C₁)` +--- is `c_x • v = algebraMap c_x / algebraMap c₀ = algebraMap (c_x / c₀)`. +--- The Lean proof needs `algebraMap C₂.FunctionField C₁.FunctionField` to +--- resolve to `φ.pullback.toRingHom` via `haveI : Algebra ... := φ.toAlgebra`, +--- but instance synthesis tends to pick unrelated `Algebra` instances. +--- Deferred for future cleanup. +- +-/-! ### Ramification order -/ +- + /-- The order of the pullback of a function `t ∈ K(C₂)` at a smooth point + `P ∈ C₁`: `ord_P (φ* t)`. When `t` is a uniformizer at the image point + `φ(P) ∈ C₂`, this equals Silverman's ramification index `e_φ(P)` of II.2.5. + +-Our formulation takes the test function `t` as an explicit argument rather +-than deriving it from an intrinsic "image point" `φ(P)`, since the +-point-image correspondence (Silverman II.2.4(c)) is deferred to later +-infrastructure. Downstream users supply a uniformizer at the intended +-image point. ++The test function `t` is an explicit uniformizer at the intended image point. + Reference: Silverman II.2.5 (definition). -/ + noncomputable def ramificationIndex (φ : CurveMap C₁ C₂) (P : C₁.SmoothPoint) + (t : C₂.FunctionField) : WithTop ℤ := +@@ -239,8 +217,6 @@ theorem one_le_ramificationIndex_of_pullback_pointValuation_lt_one + (1 : WithTop ℤ) ≤ φ.ramificationIndex P t := + (C₁.one_le_ord_P_iff_pointValuation_lt_one (φ.pullback_ne_zero ht)).mpr h + +-/-! ### Pushforward / Norm map (T-II-2-005) -/ +- + /-- The **pushforward** (norm map) `φ_* : K(C₁) →* K(C₂)` for a curve map + `φ : C₁ → C₂`, defined as the `K(C₂)`-algebra norm on `K(C₁)` via `φ.toAlgebra`. + Silverman's `φ_* = (φ*)⁻¹ ∘ N_{K(C₁)/φ*K(C₂)}` simplifies to the direct +@@ -255,7 +231,7 @@ noncomputable def pushforward (φ : CurveMap C₁ C₂) : + Reference: Silverman II.2 (after definition of `φ_*`). -/ + theorem pushforward_pullback (φ : CurveMap C₁ C₂) (g : C₂.FunctionField) : + φ.pushforward (φ.pullback g) = g ^ φ.degree := by +- letI : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ let : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra + exact Algebra.norm_algebraMap g + + /-- The pushforward is multiplicative. -/ +@@ -268,18 +244,6 @@ theorem pushforward_pullback (φ : CurveMap C₁ C₂) (g : C₂.FunctionField) + φ.pushforward (1 : C₁.FunctionField) = 1 := + φ.pushforward.map_one + +-/-! ### Fiber cardinality (T-II-2-011): Silverman II.2.7 +- +-The classical Silverman II.2.7 asserts that a nonconstant curve map `φ` is +-unramified iff every geometric fiber has cardinality `deg(φ)`. Since our +-`CurveMap` models the function-field side only (no explicit `fiber` type), +-we record the combinatorial content as a **witness-parametric** statement: +-given a `Finset` of points, their ramification indices, and the sum formula +-II.2.6(a) (`Σ e_φ(P) = deg(φ)` witness), the fiber-count equals `deg(φ)` iff +-every index is `1`. Once II.2.6(a) is formalized, this immediately gives +-T-II-2-011 for every image point `Q`. +--/ +- + /-- **Combinatorial lemma**: if `e : α → ℤ` is ≥ 1 on every element of a + finset `S`, then `∑ P ∈ S, e P = #S` iff each `e P = 1`. + +@@ -298,7 +262,7 @@ theorem _root_.Finset.sum_eq_card_iff_forall_eq_one_of_one_le + linarith + · exact (Finset.sum_congr rfl h).trans hconst + +-/-- **Witness-parametric Silverman II.2.7** (T-II-2-011): given a finite ++/-- **Witness-parametric Silverman II.2.7**: given a finite + fiber `S` with ramification indices ≥ 1 summing to `deg(φ)`, the fiber + count equals `deg(φ)` iff every ramification index equals `1`. + +@@ -321,15 +285,13 @@ theorem fiber_card_eq_degree_iff_all_ramificationIndexℤ_one + rw [← hsum, eq_comm] + exact Finset.sum_eq_card_iff_forall_eq_one_of_one_le hle + +-/-! ### Degree-one morphisms are isomorphisms on function fields (T-II-2-006) -/ +- + /-- **Silverman II.2.4.1 (pullback-surjectivity form)**: if a curve map `φ` + has degree 1, its pullback `φ*` is surjective. Combined with the automatic + injectivity of pullbacks, `φ*` is then a bijection of function fields. -/ + theorem pullback_surjective_of_degree_one (φ : CurveMap C₁ C₂) + (h : φ.degree = 1) : Function.Surjective φ.pullback := by +- letI : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- haveI : Module.Free C₂.FunctionField C₁.FunctionField := ++ let : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ have : Module.Free C₂.FunctionField C₁.FunctionField := + Module.Free.of_divisionRing _ _ + have hfr : Module.finrank C₂.FunctionField C₁.FunctionField = 1 := h + obtain ⟨v, _hv_ne, hv⟩ := finrank_eq_one_iff'.mp hfr +@@ -345,17 +307,6 @@ theorem pullback_surjective_of_degree_one (φ : CurveMap C₁ C₂) + rw [map_div₀, div_eq_mul_inv, ← hv_eq, ← Algebra.smul_def] + exact hcv + +-/-! ### Silverman II.2.6(a): `Σ e_φ(P) · f_φ(P) = deg(φ)` (T-II-2-008 via +-coordinate-ring algebra witness) +- +-`CurveMap` stores only the function-field pullback; a generic Dedekind-style +-sum-of-ramification-indices formula requires the pullback to restrict to a +-ring hom `C₂.CoordinateRing → C₁.CoordinateRing`. We expose this as an +-**auxiliary data bundle** (`CurveMap.CoordHom`) together with a compatibility +-condition. For the specific coordinate function `x : C → A¹` +-(`algebraMap F[X] → F[C]`), see `HasseWeil/Curves/NormValuation.lean`'s +-`sum_ramificationIdx_over_fiber` for the unconditional instance. -/ +- + /-- **Coordinate-ring pullback witness**: for a `CurveMap φ : C₁ → C₂`, a + ring hom `C₂.CoordinateRing → C₁.CoordinateRing` compatible with the + function-field pullback. Not every function-field pullback restricts to +@@ -378,7 +329,7 @@ noncomputable def CoordHom.toAlgebra {φ : CurveMap C₁ C₂} (coordHom : φ.Co + Algebra C₂.CoordinateRing C₁.CoordinateRing := + coordHom.toAlgHom.toRingHom.toAlgebra + +-/-- **Silverman II.2.6(a), Σ e·f form** (T-II-2-008, generic `CurveMap`): ++/-- **Silverman II.2.6(a), Σ e·f form**: + for a `CurveMap φ : C₁ → C₂` with coordinate-ring pullback witness + `coordHom` and finite-module structure, the sum `Σ_{P over p} e_P · f_P` + equals the function-field degree `φ.degree`. +@@ -402,16 +353,16 @@ theorem sum_ramificationIdx_mul_inertiaDeg_eq_degree + letI : Algebra C₂.CoordinateRing C₁.CoordinateRing := coordHom.toAlgebra + ∑ P ∈ IsDedekindDomain.primesOverFinset p C₁.CoordinateRing, + Ideal.ramificationIdx' p P * +- Ideal.inertiaDeg' p P = φ.degree := by +- letI algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := ++ P.inertiaDeg C₂.CoordinateRing = φ.degree := by ++ let algCR : Algebra C₂.CoordinateRing C₁.CoordinateRing := + coordHom.toAlgebra +- letI : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra +- haveI : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing ++ let : Algebra C₂.FunctionField C₁.FunctionField := φ.toAlgebra ++ have : IsScalarTower C₂.CoordinateRing C₁.CoordinateRing + C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_eq fun x ↦ ?_ + rw [RingHom.algebraMap_toAlgebra] + rfl +- haveI : IsScalarTower C₂.CoordinateRing C₂.FunctionField ++ have : IsScalarTower C₂.CoordinateRing C₂.FunctionField + C₁.FunctionField := by + refine IsScalarTower.of_algebraMap_smul fun r x ↦ ?_ + rw [Algebra.smul_def] +@@ -420,12 +371,44 @@ theorem sum_ramificationIdx_mul_inertiaDeg_eq_degree + rw [coordHom.compat r, ← IsScalarTower.algebraMap_smul C₁.CoordinateRing r x, + ← Algebra.smul_def] + rfl +- haveI : p.IsMaximal := hpMax +- letI modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule +- haveI : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ ++ have : p.IsMaximal := hpMax ++ let modCR : Module C₂.CoordinateRing C₁.CoordinateRing := algCR.toModule ++ have : @Module.Finite C₂.CoordinateRing C₁.CoordinateRing _ _ + modCR := hfin +- exact Ideal.sum_ramification_inertia (R := C₂.CoordinateRing) +- (S := C₁.CoordinateRing) C₂.FunctionField C₁.FunctionField hp0 ++ have : Module.IsTorsionFree C₂.CoordinateRing C₁.CoordinateRing := by ++ apply Module.isTorsionFree_iff_algebraMap_injective.mpr ++ intro a b hab ++ apply IsFractionRing.injective C₂.CoordinateRing C₂.FunctionField ++ apply φ.pullback.injective ++ change φ.pullback (algebraMap C₂.CoordinateRing C₂.FunctionField a) = ++ φ.pullback (algebraMap C₂.CoordinateRing C₂.FunctionField b) ++ rw [coordHom.compat a, coordHom.compat b] ++ exact congrArg (algebraMap C₁.CoordinateRing C₁.FunctionField) hab ++ classical ++ let : Fintype (p.primesOver C₁.CoordinateRing) := Fintype.ofFinite _ ++ calc ++ _ = ∑ P : p.primesOver C₁.CoordinateRing, ++ P.1.ramificationIdx C₂.CoordinateRing * P.1.inertiaDeg C₂.CoordinateRing := by ++ apply Finset.sum_bij (fun P hP ↦ ++ ⟨P, (IsDedekindDomain.mem_primesOverFinset_iff hp0 C₁.CoordinateRing).mp hP⟩) ++ · intro P hP ++ exact Finset.mem_univ _ ++ · intro P hP Q hQ h ++ exact congrArg Subtype.val h ++ · intro P _ ++ exact ⟨P.1, ++ (IsDedekindDomain.mem_primesOverFinset_iff hp0 C₁.CoordinateRing).mpr P.2, rfl⟩ ++ · intro P hP ++ obtain ⟨hprime, hover⟩ := ++ (IsDedekindDomain.mem_primesOverFinset_iff hp0 C₁.CoordinateRing).mp hP ++ let := hprime ++ let := hover ++ rw [Ideal.ramificationIdx'_eq_ramificationIdx p P hp0] ++ _ = Module.finrank C₂.CoordinateRing C₁.CoordinateRing := ++ Ideal.sum_ramification_inertia_eq_finrank p C₁.CoordinateRing ++ _ = φ.degree := ++ (IsFractionRing.finrank_eq C₂.CoordinateRing C₂.FunctionField ++ C₁.CoordinateRing C₁.FunctionField).symm + + end CurveMap + +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMapBaseChange.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMapBaseChange.lean +index e1c402904..2537c2d15 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMapBaseChange.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Map/CurveMapBaseChange.lean +@@ -16,33 +16,14 @@ import Mathlib.RingTheory.TensorProduct.Free + /-! + # Base change of curves and curve maps + +-For a smooth plane curve `C / F` and an `F`-algebra extension `L`, this file builds the +-natural scalar-extension maps and identifies the scalar extension of the coordinate ring +-and function field with the base-changed curve. These are foundations for the +-Galois-descent route to the unconditional `AddHomProperty` (Phase G of the Pic⁰ roadmap). ++Scalar extension identifies the coordinate ring of a smooth plane curve with the ++coordinate ring of its base change. The corresponding function-field tensor product ++is a localization of the coordinate-ring tensor product. For algebraic field extensions, ++this gives the natural isomorphism between scalar extension and the fraction field ++of the extended coordinate ring. + +-## Main definitions +- +-* `SmoothPlaneCurve.coordRingMap` — the include of coordinate rings. +-* `SmoothPlaneCurve.functionFieldMap` — the include of function fields. +-* `SmoothPlaneCurve.coordRingScalarExt` — the scalar-extension iso +- `L ⊗[F] C.CoordinateRing ≃ₐ[L] (C.baseChange L).CoordinateRing`. +-* `CurveMap.CoordHom.baseChangeAlgHom` — the base-changed coordinate-ring alg hom of a `CoordHom`. +- +-## Main results +- +-* `SmoothPlaneCurve.isDomain_tensorCoordRing` — `L ⊗[F] C.CoordinateRing` is a domain. +-* `SmoothPlaneCurve.tensor_functionField_isFractionRing` — `L ⊗[F] C.FunctionField` is the +- fraction ring of `L ⊗[F] C.CoordinateRing`. +-* `SmoothPlaneCurve.functionField_tensor_locBaseChange` — localization commutes with the base +- change `L/F`: `L ⊗[F] C.FunctionField ≃ₐ[L] FractionRing (L ⊗[F] C.CoordinateRing)`. +- +-## Implementation notes +- +-The `Algebra F` / `Algebra F[X]` instances on `AdjoinRoot W.polynomial` form a typeclass +-diamond that blocks synthesis of the tensor-product algebra/module structures. Section +-`PhaseGInstances` pins the F-route instances at high priority so signatures mentioning +-`L ⊗[F] C.CoordinateRing` (and its function-field analogue) elaborate diamond-free. ++The algebra and module structures are chosen compatibly with the scalar tower through ++the polynomial ring. + + ## References + +@@ -179,7 +160,6 @@ theorem baseChange_inner_comp_mapRingHom_eq {φ : CurveMap C₁ C₂} + C₁.coordRingMap L (cd.toAlgHom + (algebraMap (Polynomial F) C₂.CoordinateRing (Polynomial.C a))) + rw [Polynomial.map_C] +- change (cd.baseChangeInnerAlgHom L) (Polynomial.C (algebraMap F L a)) = _ + simp only [baseChangeInnerAlgHom] + rw [Polynomial.aeval_C, show (algebraMap (Polynomial F) C₂.CoordinateRing) (Polynomial.C a) = + algebraMap F C₂.CoordinateRing a from +@@ -262,8 +242,8 @@ noncomputable instance (priority := 100000) coordRingModuleBase : + /-- `CommRing` on the scalar-extension tensor `L ⊗[F] C.CR`, pinned at high + priority. The default synthesis loses to the `Algebra F` / `Algebra F[X]` + diamond on `AdjoinRoot W.polynomial` (it tries the `F[X]`-route algebra on +-`C.CR`); pinning the F-route `CommRing` here unblocks any signature that +-mentions `L ⊗[F] C.CR` (e.g. `FractionRing (L ⊗[F] C.CR)`). -/ ++`C.CR`). This instance uses the algebra over `F` in the tensor product ++and its fraction field. -/ + noncomputable instance (priority := 100000) tensorCoordRingCommRing + (L : Type*) [Field L] [Algebra F L] : + CommRing (L ⊗[F] C.toAffine.CoordinateRing) := +@@ -310,8 +290,8 @@ noncomputable instance (priority := 100000) tensorFunctionFieldFLScalarTower + pinned at high priority. The same `Algebra F` / `Algebra F[X]` diamond on + `AdjoinRoot W.polynomial` that taints `L ⊗[F] C.CR` recurs at the function-field + level (since `C.FF = FractionRing C.CR` carries the `C.CR`-algebra, which routes +-back through the diamond). Pinning the F-route `CommRing` unblocks any signature +-mentioning `L ⊗[F] C.FF`. -/ ++back through the diamond). This instance uses the algebra over `F` ++in the function-field tensor product. -/ + noncomputable instance (priority := 100000) tensorFunctionFieldCommRing + (L : Type*) [Field L] [Algebra F L] : + CommRing (L ⊗[F] C.toAffine.FunctionField) := +@@ -693,8 +673,7 @@ theorem tensorFunctionFieldStructureHom_injective (L : Type*) [Field L] [Algebra + Module.Flat.lTensor_preserves_injective_linearMap gF hg + have hfun : ⇑(C.tensorFunctionFieldStructureHom L) = ⇑(LinearMap.lTensor L gF) := by + funext x +- induction x using TensorProduct.induction_on with +- | zero => simp ++ induction x using TensorProduct.inductionOn with + | tmul l u => + rw [LinearMap.lTensor_tmul] + change Algebra.TensorProduct.map (AlgHom.id L L) +@@ -707,12 +686,12 @@ theorem tensorFunctionFieldStructureHom_injective (L : Type*) [Field L] [Algebra + exact hlin + + /-- `C.CoordinateRing ⊗[F] L` is a domain, for any field extension `L/F`. Obtained from the +-sibling `isDomain_tensorCoordRing` (which gives the `L`-on-the-left orientation ++`isDomain_tensorCoordRing` (which gives the `L`-on-the-left orientation + `L ⊗[F] C.CoordinateRing`) by transporting the domain structure across the commutativity + ring-iso `Algebra.TensorProduct.comm`. -/ + private theorem tensorCoordRing_comm_isDomain (L : Type*) [Field L] [Algebra F L] : + IsDomain (C.toAffine.CoordinateRing ⊗[F] L) := by +- letI := C.isDomain_tensorCoordRing L ++ let := C.isDomain_tensorCoordRing L + exact + (Algebra.TensorProduct.comm F L C.toAffine.CoordinateRing).symm.toRingEquiv.toMulEquiv.isDomain + (L ⊗[F] C.toAffine.CoordinateRing) +@@ -727,9 +706,9 @@ private theorem tensorCoordRing_algebraMapSubmonoid_le_nonZeroDivisors + Algebra.algebraMapSubmonoid (C.toAffine.CoordinateRing ⊗[F] L) + (nonZeroDivisors C.toAffine.CoordinateRing) ≤ + nonZeroDivisors (C.toAffine.CoordinateRing ⊗[F] L) := by +- haveI hflatCR : Module.Flat F C.toAffine.CoordinateRing := Module.Flat.of_free +- letI := C.tensorCoordRing_comm_isDomain L +- haveI hnzdCR : NoZeroDivisors (C.toAffine.CoordinateRing ⊗[F] L) := ++ have hflatCR : Module.Flat F C.toAffine.CoordinateRing := Module.Flat.of_free ++ let := C.tensorCoordRing_comm_isDomain L ++ have hnzdCR : NoZeroDivisors (C.toAffine.CoordinateRing ⊗[F] L) := + isCancelMulZero_iff_noZeroDivisors.mp ‹IsDomain _›.toIsCancelMulZero + have hinjL : Function.Injective + (Algebra.TensorProduct.includeLeft : +@@ -758,11 +737,11 @@ private theorem tensorFunctionField_isLocalization (L : Type*) [Field L] [Algebr + (Algebra.algebraMapSubmonoid (C.toAffine.CoordinateRing ⊗[F] L) + (nonZeroDivisors C.toAffine.CoordinateRing)) + (C.toAffine.FunctionField ⊗[F] L) := by +- letI algBC : Algebra (C.toAffine.CoordinateRing ⊗[F] L) (C.toAffine.FunctionField ⊗[F] L) := ++ let algBC : Algebra (C.toAffine.CoordinateRing ⊗[F] L) (C.toAffine.FunctionField ⊗[F] L) := + (Algebra.TensorProduct.map + (IsScalarTower.toAlgHom F C.toAffine.CoordinateRing C.toAffine.FunctionField) + (AlgHom.id F L)).toRingHom.toAlgebra +- haveI tower : IsScalarTower C.toAffine.CoordinateRing (C.toAffine.CoordinateRing ⊗[F] L) ++ have tower : IsScalarTower C.toAffine.CoordinateRing (C.toAffine.CoordinateRing ⊗[F] L) + (C.toAffine.FunctionField ⊗[F] L) := + IsScalarTower.of_algebraMap_eq fun _ ↦ rfl + exact @IsLocalization.tensorProduct_tensorProduct F L _ _ _ C.toAffine.CoordinateRing _ _ +@@ -786,14 +765,14 @@ the function field on the **left** (`FunctionField ⊗[F] L`) to match that cons + private theorem tensorFunctionField_isDomain (L : Type*) [Field L] [Algebra F L] : + IsDomain (C.toAffine.FunctionField ⊗[F] L) := by + -- `C.CoordinateRing ⊗[F] L` is a domain (the base ring of the localization below). +- letI := C.tensorCoordRing_comm_isDomain L ++ let := C.tensorCoordRing_comm_isDomain L + -- The natural `lTensor`-of-localization algebra structure exhibiting the function field + -- tensor as a localization of the coordinate-ring tensor. +- letI _algBC : Algebra (C.toAffine.CoordinateRing ⊗[F] L) (C.toAffine.FunctionField ⊗[F] L) := ++ let _algBC : Algebra (C.toAffine.CoordinateRing ⊗[F] L) (C.toAffine.FunctionField ⊗[F] L) := + (Algebra.TensorProduct.map + (IsScalarTower.toAlgHom F C.toAffine.CoordinateRing C.toAffine.FunctionField) + (AlgHom.id F L)).toRingHom.toAlgebra +- haveI := C.tensorFunctionField_isLocalization L ++ have := C.tensorFunctionField_isLocalization L + -- A localization of a domain at a submonoid of nonzerodivisors is again a domain. + exact IsLocalization.isDomain_of_le_nonZeroDivisors (C.toAffine.FunctionField ⊗[F] L) + (C.tensorCoordRing_algebraMapSubmonoid_le_nonZeroDivisors L) +@@ -805,7 +784,7 @@ when consumed by `tensor_functionField_isFractionRing`. -/ + theorem tensor_functionField_isField (L : Type*) [Field L] [Algebra F L] + [Algebra.IsAlgebraic F L] : + IsField (L ⊗[F] C.toAffine.FunctionField) := by +- haveI := C.tensorFunctionField_isDomain L ++ have := C.tensorFunctionField_isDomain L + have hF : IsField (C.toAffine.FunctionField ⊗[F] L) := + Algebra.TensorProduct.isField_of_isAlgebraic F C.toAffine.FunctionField L + (Or.inr (inferInstance : Algebra.IsAlgebraic F L)) +@@ -842,7 +821,7 @@ private theorem oneTmul_mem_nonZeroDivisors (L : Type*) [Field L] [Algebra F L] + (hb : b ∈ nonZeroDivisors C.toAffine.CoordinateRing) : + (1 ⊗ₜ b : L ⊗[F] C.toAffine.CoordinateRing) + ∈ nonZeroDivisors (L ⊗[F] C.toAffine.CoordinateRing) := by +- letI := C.isDomain_tensorCoordRing L ++ let := C.isDomain_tensorCoordRing L + rw [mem_nonZeroDivisors_iff_ne_zero] + have hb0 : b ≠ 0 := mem_nonZeroDivisors_iff_ne_zero.mp hb + intro hc +@@ -861,17 +840,15 @@ theorem tensor_functionField_surj (L : Type*) [Field L] [Algebra F L] : + (L ⊗[F] C.toAffine.FunctionField) x.2 + = algebraMap (L ⊗[F] C.toAffine.CoordinateRing) + (L ⊗[F] C.toAffine.FunctionField) x.1 := by +- letI alg := C.tensorFunctionFieldAlgebra L +- letI := C.isDomain_tensorCoordRing L +- haveI hflatL : Module.Flat F L := Module.Flat.of_free ++ let alg := C.tensorFunctionFieldAlgebra L ++ let := C.isDomain_tensorCoordRing L ++ have hflatL : Module.Flat F L := Module.Flat.of_free + have halg : ∀ (l : L) (u : C.toAffine.CoordinateRing), + algebraMap (L ⊗[F] C.toAffine.CoordinateRing) (L ⊗[F] C.toAffine.FunctionField) (l ⊗ₜ u) + = l ⊗ₜ algebraMap C.toAffine.CoordinateRing C.toAffine.FunctionField u := + fun l u ↦ rfl + refine fun z ↦ ?_ +- induction z using TensorProduct.induction_on with +- | zero => +- exact ⟨(0, 1), by rw [zero_mul, map_zero]⟩ ++ induction z using TensorProduct.inductionOn with + | tmul l f => + obtain ⟨a, b, hbmem, hab⟩ := IsFractionRing.div_surjective (A := C.toAffine.CoordinateRing) f + refine ⟨(l ⊗ₜ a, ⟨1 ⊗ₜ b, C.oneTmul_mem_nonZeroDivisors L b hbmem⟩), ?_⟩ +@@ -895,8 +872,8 @@ theorem tensor_functionField_isFractionRing (L : Type*) [Field L] [Algebra F L] + [Algebra.IsAlgebraic F L] : + @IsFractionRing (L ⊗[F] C.toAffine.CoordinateRing) _ + (L ⊗[F] C.toAffine.FunctionField) _ (C.tensorFunctionFieldAlgebra L) := by +- letI alg := C.tensorFunctionFieldAlgebra L +- letI := C.isDomain_tensorCoordRing L ++ let alg := C.tensorFunctionFieldAlgebra L ++ let := C.isDomain_tensorCoordRing L + have hinj : Function.Injective + (algebraMap (L ⊗[F] C.toAffine.CoordinateRing) (L ⊗[F] C.toAffine.FunctionField)) := + C.tensorFunctionFieldStructureHom_injective L +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/InseparableDegree.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/InseparableDegree.lean +index ebd777c8c..9132c544f 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/InseparableDegree.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/InseparableDegree.lean +@@ -8,29 +8,13 @@ import Mathlib.FieldTheory.PurelyInseparable.Basic + import Mathlib.FieldTheory.SeparableClosure + + /-! +-# Inseparable degree API for isogenies (Silverman II.2.10-12) ++For an elliptic-curve isogeny, the separable degree times the inseparable degree ++equals the function-field degree. In positive characteristic the inseparable ++degree is a power of the characteristic. The separable closure of the pullback ++field gives the maximal intermediate field over which the extension is purely ++inseparable. + +-This file builds the inseparable-degree / separable-closure API for +-elliptic-curve isogenies, building on mathlib's +-`Mathlib.FieldTheory.SeparableClosure` (`Field.sepDegree`, +-`Field.finInsepDegree`, `separableClosure`) and +-`Mathlib.FieldTheory.PurelyInseparable.Basic` (`IsPurelyInseparable`, +-`isPurelyInseparable_iff_pow_mem`, `IsPurelyInseparable.pow_mem`). +- +-## Main results +- +-* `Isogeny.inseparableDegree_dvd_degree` — the inseparable degree +- divides the degree (consequence of `finSepDegree · finInsepDegree = +- finrank`, mathlib `PurelyInseparable/Basic.lean:595`). +-* `Isogeny.inseparableDegree_eq_one_iff_separable` — direct from the +- project's definition `IsSeparable := inseparableDegree = 1`. +-* `Isogeny.inseparableDegree_isPow_of_charP` — in characteristic `p`, +- the inseparable degree is a power of `p`. Uses +- `isPurelyInseparable_iff_pow_mem` (mathlib). +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], II.2.10-12. ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, II.2.10–12. + -/ + + open WeierstrassCurve +@@ -70,7 +54,7 @@ theorem separableDegree_mul_finInsepDegree (α : Isogeny W W) : + α.separableDegree * + Field.finInsepDegree W.FunctionField W.FunctionField = + α.degree := by +- letI : Algebra W.FunctionField W.FunctionField := α.toAlgebra ++ let : Algebra W.FunctionField W.FunctionField := α.toAlgebra + rw [separableDegree_eq_finSepDegree, degree_eq_finrank] + exact Field.finSepDegree_mul_finInsepDegree W.FunctionField W.FunctionField + +@@ -83,7 +67,7 @@ theorem inseparableDegree_eq_finInsepDegree (α : Isogeny W W) + letI : Algebra W.FunctionField W.FunctionField := α.toAlgebra + α.inseparableDegree = + Field.finInsepDegree W.FunctionField W.FunctionField := by +- letI : Algebra W.FunctionField W.FunctionField := α.toAlgebra ++ let : Algebra W.FunctionField W.FunctionField := α.toAlgebra + -- inseparableDegree = degree / separableDegree + -- = (separableDegree * finInsepDegree) / separableDegree + -- = finInsepDegree (since separableDegree > 0) +@@ -102,7 +86,7 @@ theorem inseparableDegree_dvd_degree (α : Isogeny W W) : + α.inseparableDegree ∣ α.degree := by + -- inseparableDegree = degree / separableDegree; degree = separableDegree * finInsepDegree. + -- So separableDegree | degree, hence (degree / separableDegree) | degree. +- letI : Algebra W.FunctionField W.FunctionField := α.toAlgebra ++ let : Algebra W.FunctionField W.FunctionField := α.toAlgebra + have h_mul := separableDegree_mul_finInsepDegree α + show α.degree / α.separableDegree ∣ α.degree + rw [show α.degree = α.separableDegree * +@@ -130,15 +114,15 @@ theorem inseparableDegree_isPow_of_charP + (α : Isogeny W.toAffine W.toAffine) + (h_deg_pos : 0 < α.degree) : + ∃ e : ℕ, α.inseparableDegree = p ^ e := by +- letI alg : Algebra W.toAffine.FunctionField W.toAffine.FunctionField := α.toAlgebra ++ let alg : Algebra W.toAffine.FunctionField W.toAffine.FunctionField := α.toAlgebra + -- CharP transports along the algebraMap (it's a ringHom into a field of char p) +- haveI : CharP W.toAffine.FunctionField p := ++ have : CharP W.toAffine.FunctionField p := + charP_of_injective_algebraMap + (algebraMap K W.toAffine.FunctionField).injective p + -- ExpChar from CharP + Prime +- haveI : ExpChar W.toAffine.FunctionField p := ExpChar.prime Fact.out ++ have : ExpChar W.toAffine.FunctionField p := ExpChar.prime Fact.out + -- From h_deg_pos: FiniteDimensional via the matching finrank +- haveI hfin : @FiniteDimensional W.toAffine.FunctionField ++ have hfin : @FiniteDimensional W.toAffine.FunctionField + W.toAffine.FunctionField _ _ alg.toModule := + @FiniteDimensional.of_finrank_pos _ _ _ _ alg.toModule h_deg_pos + -- Pull down the mathlib lemma with explicit instances +@@ -155,7 +139,7 @@ theorem inseparableDegree_isPow_of_charP + rw [inseparableDegree_eq_finInsepDegree α h_sep_pos] + exact he + +-/-! ### P0-B — `Isogeny.separableSubfield` ++/-! The separable subfield + + The maximal intermediate field over which `K(E)` is purely inseparable. + Direct specialisation of `Mathlib.FieldTheory.separableClosure` to +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/PoleOrderParity.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/PoleOrderParity.lean +index 07d5e7569..e5fe1c773 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/PoleOrderParity.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/PoleOrderParity.lean +@@ -183,7 +183,7 @@ theorem point_minus_O_principal_eq_zero_of_coord + have := congr_arg ProjectiveSmoothPoint.toAffinePoint h + rwa [P.toProjectiveSmoothPoint_toAffinePoint, + ProjectiveSmoothPoint.toAffinePoint_infinity] at this +- rw [if_neg h_ne, if_pos rfl] ++ rw [ite_eq_right h_ne, ite_eq_left rfl] + decide + -- Use projectiveDivisorOf_apply_infinity to convert: -1 = (ordAtInfty f).untopD 0 + rw [SmoothPlaneCurve.projectiveDivisorOf_apply_infinity] at h_inf +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/RamificationAtInfinity.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/RamificationAtInfinity.lean +index c09705086..7142cc012 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/RamificationAtInfinity.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Ramification/RamificationAtInfinity.lean +@@ -3,82 +3,21 @@ Copyright (c) 2026 Chris Birkbeck. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Chris Birkbeck + -/ +-import Mathlib.NumberTheory.RamificationInertia.Basic ++import Mathlib.RingTheory.RamificationInertia.Basic ++import Mathlib.LinearAlgebra.Dimension.Localization ++import Mathlib.NumberTheory.RamificationInertia.Ramification + import Mathlib.RingTheory.DedekindDomain.IntegralClosure + + /-! +-# Abstract ramification at infinity (Worker A Action 1) +- +-For a smooth plane curve `C` over a field `k` and a nonconstant function +-`f ∈ K(C)`, this file establishes the **function-field-degree-equals-pole- +-divisor-degree identity**: +- +-``` +-[K(C) : k(f)] = Σ_{P pole of f} (- ord_P f) · [κ(P) : k]. +-``` +- +-This is *not* Riemann–Roch. It is the degree formula for the finite morphism +-`f : C → ℙ¹`, scoped to the fibre at `∞`. The proof goes via Mathlib's +-`Ideal.sum_ramification_inertia` applied at the `(u)`-prime of `k[u]`, where +-`u = 1/f` is the uniformizer at infinity on `ℙ¹`: +- +- * `e_P = ord_P(u) = -ord_P(f)` (ramification index), +- * `f_P = [κ(P) : κ((u))] = [κ(P) : k]` (inertia degree). +- +-## Strategy +- +-The proof packages Mathlib's abstract ramification–inertia machinery: pick +-the integral closure `S` of `k[u]` in `K(C)` (via the algebra structure +-`u ↦ 1/f`), observe `S` is Dedekind, then `Ideal.sum_ramification_inertia` +-at the `(u)` prime gives the sum directly. The curve-specific notation +-(`poleSupport`, `ordAt`, `kappa`) is bookkeeping over the resulting finset. +- +-This is the deliverable for "Worker A — Action 1 abstract ramification-at- +-infinity setup". Worker B's closing application combines this with their +-Action 2 (translation valuation transport) plus Action 3 (a small closed- +-point lemma) to discharge the project's `pc_sepDeg_eq_pointCount` witness. +- +-## Main definitions +- +-* `polyToFieldOfInv f`, `ratFunToFieldOfInv hf` — the `k`-algebra maps +- `Polynomial k →ₐ[k] L` and `FractionRing (Polynomial k) →ₐ[k] L` sending the +- indeterminate to `f⁻¹` (the uniformizer `u = 1/f`). +-* `LinfAt f` — `L` as a type synonym carrying the `X ↦ f⁻¹` polynomial-algebra +- structure, so it does not clash with the project's pre-existing `X ↦ coordX` +- instance. +-* `Sinf f` — structural package of "an integral closure of `Polynomial k` in +- `LinfAt f`": the carrier plus every typeclass instance the closing theorem +- needs as an honest field. +-* `xIdeal`, `Sinf.ordAt`, `Sinf.kappa` — the prime `(X)` at infinity, the order +- `-(ramificationIdx' …)`, and the residue field `carrier ⧸ P`. +- +-## Main results +- +-* `finrank_eq_sum_ramificationIdx_mul_inertiaDeg` — the abstract fundamental +- identity `Σ e(P) · f(P) = [LinfAt f : k(f)]` from `Ideal.sum_ramification_inertia`. +-* `finrank_eq_weighted_poleDegree_of_nonconstant` — the closing corollary +- `[L : k(f)] = Σ_P (−ord_P f) · inertiaDeg' P`. +-* `Sinf.inertiaDeg_eq_one_of_algebraMap_surjective` — `inertiaDeg' (X) P = 1` +- when the residue map `k → κ(P)` is surjective. +- +-## Implementation notes +- +-`LinfAt` and `Sinf` exist to dodge two Lean-elaboration hazards. `LinfAt f` +-isolates the `X ↦ f⁻¹` algebra structure from the project's `X ↦ coordX` one; +-transcendence is carried as `Fact (Transcendental k f⁻¹)` (use sites declare +-`haveI : Fact (Transcendental k f⁻¹) := ⟨_⟩` once and the algebra instances +-resolve). `Sinf` bundles the integral-closure instances as record fields so they +-resolve by projection, sidestepping the `Meta.SynthInstance.tryResolve` +-negative-cache anomaly that the `↥(integralClosure …)` Subalgebra coercion +-triggers under `Ideal.sum_ramification_inertia` (commit 538ff64). +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, II.2 (degree of a +- morphism between curves; formula II.2.6.a as the sum over preimages of +- one point). +-* Mathlib's `Ideal.sum_ramification_inertia` provides the abstract +- fundamental identity `Σ e · f = [Frac S : Frac R]`. ++# Ramification at infinity ++ ++For a nonconstant function on a smooth curve, the degree of the function-field ++extension equals the degree of its pole divisor. Applying the fundamental ++ramification–inertia identity to the prime `(X)` of `k[X]`, embedded by ++`X ↦ f⁻¹`, identifies its ramification indices with pole orders and its ++inertia degrees with residue-field degrees. ++ ++See Silverman, *The Arithmetic of Elliptic Curves*, II.2. + -/ + + namespace HasseWeil.Curves +@@ -144,11 +83,7 @@ theorem ratFunToFieldOfInv_injective {L : Type*} [Field L] [Algebra k L] + Function.Injective (ratFunToFieldOfInv hf) := + (ratFunToFieldOfInv hf).toRingHom.injective + +-/-- The function field viewed as a type-synonym, used to install a +-`Polynomial k`-algebra structure via `X ↦ f⁻¹` that does not conflict with +-the project's existing `X ↦ coordX` instance. +-The unused argument `_f` indexes the algebra structure intended for the +-synonym. -/ ++ + @[nolint unusedArguments] + def LinfAt {L : Type*} [Field L] [Algebra k L] (_f : L) : Type _ := L + +@@ -238,12 +173,7 @@ instance isScalarTower_k_fractionRing + + end LinfAt + +-/-- Structural package of "an integral closure of `Polynomial k` inside +-`LinfAt f`": carrier type plus every typeclass instance the closing +-`Ideal.sum_ramification_inertia` invocation requires, bundled as record +-fields so `letI` can install them at the use site. Sidesteps the Lean 4 +-synthesis anomaly that affects the `↥(integralClosure …)` Subalgebra +-coercion (commit 538ff64). -/ ++ + structure Sinf.{u} {L : Type*} [Field L] [Algebra k L] (f : L) where + /-- Carrier type — canonically `↥(integralClosure (Polynomial k) (LinfAt f))`. -/ + carrier : Type u +@@ -262,18 +192,14 @@ structure Sinf.{u} {L : Type*} [Field L] [Algebra k L] (f : L) where + [isFractionRing : IsFractionRing carrier (LinfAt (k := k) f)] + /-- Compatible scalar tower with the ambient `Polynomial k → LinfAt f`. -/ + [isScalarTower : IsScalarTower (Polynomial k) carrier (LinfAt (k := k) f)] +- /-- Finite as a `Polynomial k`-module. -/ ++ + [moduleFinite : Module.Finite (Polynomial k) carrier] +- /-- Torsion-free as a `Polynomial k`-module (algebraMap injective). -/ ++ + [isTorsionFree : Module.IsTorsionFree (Polynomial k) carrier] + + section SinfConstruction + + +-/-- Canonical construction of `Sinf` from Mathlib's `integralClosure` +-Subalgebra. Given the ambient finite-separability hypotheses, all the +-required instances are synthesised once here; downstream code consumes +-them only by field projection. -/ + noncomputable def Sinf.ofIntegralClosure + {L : Type*} [Field L] [Algebra k L] (f : L) [Fact (Transcendental k f⁻¹)] + [Module.Finite (FractionRing (Polynomial k)) (LinfAt (k := k) f)] +@@ -288,13 +214,13 @@ noncomputable def Sinf.ofIntegralClosure + (integralClosure (Polynomial k) (LinfAt (k := k) f)) := + IsIntegralClosure.finite (Polynomial k) (FractionRing (Polynomial k)) + (LinfAt (k := k) f) (integralClosure (Polynomial k) (LinfAt (k := k) f)) +- haveI : FaithfulSMul (Polynomial k) (LinfAt (k := k) f) := by ++ have : FaithfulSMul (Polynomial k) (LinfAt (k := k) f) := by + rw [faithfulSMul_iff_algebraMap_injective] + exact polyToFieldOfInv_injective_of_transcendental + (Fact.out (p := Transcendental k f⁻¹)) +- haveI : Module.IsTorsionFree (Polynomial k) (LinfAt (k := k) f) := ++ have : Module.IsTorsionFree (Polynomial k) (LinfAt (k := k) f) := + inferInstance +- haveI : Module.IsTorsionFree (Polynomial k) ++ have : Module.IsTorsionFree (Polynomial k) + (integralClosure (Polynomial k) (LinfAt (k := k) f)) := + Subalgebra.instIsTorsionFree (integralClosure (Polynomial k) + (LinfAt (k := k) f)) +@@ -316,13 +242,7 @@ theorem xIdeal_ne_bot : (xIdeal (k := k)) ≠ ⊥ := by + rw [xIdeal, Ne, Ideal.span_singleton_eq_bot] + exact Polynomial.X_ne_zero + +-/-- **Abstract fundamental ramification–inertia identity at infinity.** +-For a function `f` realising `LinfAt f` as a finite separable extension of +-`FractionRing (Polynomial k) = k(f)` and an integral-closure package +-`data : Sinf k f`, the sum over primes of the carrier lying over `(X)` of +-`e(P) · f(P)` equals `[LinfAt f : k(f)]`. This is the abstract content of +-the `[K(C):k(f)] = Σ (pole degree)` identity, before specialisation to +-`LinfAt f = K(C)` for a smooth curve `C`. -/ ++ + theorem finrank_eq_sum_ramificationIdx_mul_inertiaDeg + {L : Type*} [Field L] [Algebra k L] (f : L) [Fact (Transcendental k f⁻¹)] + [Module.Finite (FractionRing (Polynomial k)) (LinfAt (k := k) f)] +@@ -332,18 +252,42 @@ theorem finrank_eq_sum_ramificationIdx_mul_inertiaDeg + letI := data.algPoly + ∑ P ∈ IsDedekindDomain.primesOverFinset (xIdeal (k := k)) data.carrier, + Ideal.ramificationIdx' (xIdeal (k := k)) P * +- Ideal.inertiaDeg' (xIdeal (k := k)) P = ++ P.inertiaDeg (Polynomial k) = + Module.finrank (FractionRing (Polynomial k)) (LinfAt (k := k) f) := by +- letI := data.commRing +- letI := data.isDomain +- letI := data.isDedekindDomain +- letI := data.algPoly +- letI := data.algLinfAt +- letI := data.isFractionRing +- letI := data.isScalarTower +- letI := data.moduleFinite +- exact Ideal.sum_ramification_inertia (R := Polynomial k) data.carrier +- (FractionRing (Polynomial k)) (LinfAt (k := k) f) xIdeal_ne_bot ++ let := data.commRing ++ let := data.isDomain ++ let := data.isDedekindDomain ++ let := data.algPoly ++ let := data.algLinfAt ++ let := data.isFractionRing ++ let := data.isScalarTower ++ let := data.moduleFinite ++ classical ++ let := data.isTorsionFree ++ let : Fintype ((xIdeal (k := k)).primesOver data.carrier) := Fintype.ofFinite _ ++ calc ++ _ = ∑ P : (xIdeal (k := k)).primesOver data.carrier, ++ P.1.ramificationIdx (Polynomial k) * P.1.inertiaDeg (Polynomial k) := by ++ apply Finset.sum_bij (fun P hP ↦ ++ ⟨P, (IsDedekindDomain.mem_primesOverFinset_iff xIdeal_ne_bot data.carrier).mp hP⟩) ++ · intro P hP ++ exact Finset.mem_univ _ ++ · intro P hP Q hQ h ++ exact congrArg Subtype.val h ++ · intro P _ ++ exact ⟨P.1, ++ (IsDedekindDomain.mem_primesOverFinset_iff xIdeal_ne_bot data.carrier).mpr P.2, rfl⟩ ++ · intro P hP ++ obtain ⟨hprime, hover⟩ := ++ (IsDedekindDomain.mem_primesOverFinset_iff xIdeal_ne_bot data.carrier).mp hP ++ let := hprime ++ let := hover ++ rw [Ideal.ramificationIdx'_eq_ramificationIdx (xIdeal (k := k)) P xIdeal_ne_bot] ++ _ = Module.finrank (Polynomial k) data.carrier := ++ Ideal.sum_ramification_inertia_eq_finrank (xIdeal (k := k)) data.carrier ++ _ = Module.finrank (FractionRing (Polynomial k)) (LinfAt (k := k) f) := ++ (IsFractionRing.finrank_eq (Polynomial k) (FractionRing (Polynomial k)) ++ data.carrier (LinfAt (k := k) f)).symm + + /-- The `R[X] ⧸ (X) ≃ₐ[R] R`-style algebra equivalence specialised to + `R = k`, given by evaluation at `0`. -/ +@@ -374,8 +318,8 @@ theorem Sinf.toNat_neg_ordAt_eq_ramificationIdx + ∀ P : Ideal data.carrier, + (-(data.ordAt P)).toNat = + Ideal.ramificationIdx' (xIdeal (k := k)) P := by +- letI := data.commRing +- letI := data.algPoly ++ let := data.commRing ++ let := data.algPoly + intro P + simp [Sinf.ordAt] + +@@ -415,16 +359,34 @@ theorem Sinf.inertiaDeg_eq_finrank_kappa + letI := data.commRing + letI := data.algPoly + ∀ (P : Ideal data.carrier) [P.LiesOver (xIdeal (k := k))], +- Ideal.inertiaDeg' (xIdeal (k := k)) P = +- Module.finrank (Polynomial k ⧸ xIdeal (k := k)) (data.kappa P) := by +- letI := data.commRing +- letI := data.algPoly ++ (if h : P.comap (algebraMap (Polynomial k) data.carrier) = xIdeal (k := k) then ++ letI : Algebra (Polynomial k ⧸ xIdeal (k := k)) (data.carrier ⧸ P) := ++ Ideal.Quotient.algebraQuotientOfLEComap h.ge ++ Module.finrank (Polynomial k ⧸ xIdeal (k := k)) (data.kappa P) ++ else 0) = Module.finrank (Polynomial k ⧸ xIdeal (k := k)) (data.kappa P) := by ++ let := data.commRing ++ let := data.algPoly + intro P _ +- exact Ideal.inertiaDeg'_algebraMap _ _ ++ simp only [dite_eq_left (Ideal.over_def P (xIdeal (k := k))).symm] ++ ++/-- For a prime above `(X)`, the inertia degree is its residue-field degree. -/ ++theorem Sinf.prime_inertiaDeg_eq_finrank_kappa ++ {L : Type*} [Field L] [Algebra k L] {f : L} ++ (data : Sinf (k := k) f) : ++ letI := data.commRing ++ letI := data.algPoly ++ ∀ (P : Ideal data.carrier) [P.IsPrime] [P.LiesOver (xIdeal (k := k))], ++ P.inertiaDeg (Polynomial k) = ++ Module.finrank (Polynomial k ⧸ xIdeal (k := k)) (data.kappa P) := by ++ let := data.commRing ++ let := data.algPoly ++ let := data.moduleFinite ++ intro P _ _ ++ let : P.IsMaximal := Ideal.isMaximal_of_isIntegral_of_isMaximal_under (R := Polynomial k) P (by ++ simpa only [← Ideal.over_def P (xIdeal (k := k))] using (xIdeal_isMaximal (k := k))) ++ exact Ideal.inertiaDeg_eq_of_isMaximal (xIdeal (k := k)) P ++ + +-/-- The `Polynomial k ⧸ xIdeal`-finrank of a module agrees with its +-`k`-finrank, given a compatible scalar tower `k → (Polynomial k ⧸ xIdeal) +-→ M`. Uses `quotientXAlgEquiv` plus the tower formula. -/ + theorem finrank_residue_eq_finrank_k + {M : Type*} [AddCommGroup M] [Module (Polynomial k ⧸ xIdeal (k := k)) M] + [Module k M] [IsScalarTower k (Polynomial k ⧸ xIdeal (k := k)) M] +@@ -439,7 +401,7 @@ theorem finrank_residue_eq_finrank_k + /-- **Abstract inertia-degree-one criterion at `(X)`.** For an *arbitrary* prime `P` of the + `Sinf` carrier lying over `xIdeal := (X)`, if the structure algebra map + `(Polynomial k ⧸ (X)) → (carrier ⧸ P)` (`≅ k → κ(P)`) is surjective, then the inertia +-degree `inertiaDeg' (X) P` equals `1`. This is the field-agnostic, `CoordinateRing`-free, ++degree `P.inertiaDeg (Polynomial k)` equals `1`. This is the field-agnostic, `CoordinateRing`-free, + `IsAlgClosed`-free criterion for any prime over `(X)`. -/ + theorem Sinf.inertiaDeg_eq_one_of_algebraMap_surjective + {L : Type*} [Field L] [Algebra k L] {f : L} +@@ -455,31 +417,26 @@ theorem Sinf.inertiaDeg_eq_one_of_algebraMap_surjective + (algebraMap (Polynomial k ⧸ xIdeal (k := k)) (data.carrier ⧸ P))) : + letI := data.commRing + letI := data.algPoly +- Ideal.inertiaDeg' (xIdeal (k := k)) P = 1 := by +- letI := data.commRing +- letI := data.algPoly +- letI := data.isDomain +- letI := data.moduleFinite +- haveI hmax : (xIdeal (k := k)).IsMaximal := xIdeal_isMaximal +- letI : Algebra (Polynomial k ⧸ xIdeal (k := k)) (data.carrier ⧸ P) := ++ P.inertiaDeg (Polynomial k) = 1 := by ++ let := data.commRing ++ let := data.algPoly ++ let := data.isDomain ++ let := data.moduleFinite ++ have hmax : (xIdeal (k := k)).IsMaximal := xIdeal_isMaximal ++ let : Algebra (Polynomial k ⧸ xIdeal (k := k)) (data.carrier ⧸ P) := + Ideal.Quotient.algebraQuotientOfLEComap + (Ideal.LiesOver.over (p := xIdeal (k := k)) (P := P)).le +- rw [Ideal.inertiaDeg'_algebraMap] ++ let : P.IsMaximal := Ideal.isMaximal_of_isIntegral_of_isMaximal_under (R := Polynomial k) P (by ++ simpa only [← Ideal.over_def P (xIdeal (k := k))] using (xIdeal_isMaximal (k := k))) ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (xIdeal (k := k)) P] + refine le_antisymm ?_ ?_ + · refine finrank_le_one (1 : data.carrier ⧸ P) fun w ↦ ?_ + obtain ⟨c, hc⟩ := h_surj w + exact ⟨c, by rwa [Algebra.algebraMap_eq_smul_one] at hc⟩ +- · have hpos := Ideal.inertiaDeg'_pos (xIdeal (k := k)) P +- rwa [Ideal.inertiaDeg'_algebraMap] at hpos +- +-/-- **Closing corollary (abstract form).** The function-field degree +-`[L : k(f)]` over the Sinf data equals the weighted pole-divisor degree +-`Σ_P (−ord_P f) · f_P` (with `f_P = inertiaDeg' xIdeal P`). This is the +-abstract form of the `[K(C) : k(f)] = Σ_{P pole of f} (−ord_P f) · [κ(P) : +-k]` identity; Worker B's PoleDivisorFallback specialisation substitutes +-`L = K(E)`, `f = γ*x_gen`, and converts `inertiaDeg'` to `[κ(P) : k]` +-using `inertiaDeg_eq_finrank_kappa` plus the `quotientXAlgEquiv` +-`Polynomial k ⧸ xIdeal ≃ k`. -/ ++ · exact Nat.succ_le_of_lt (Module.finrank_pos : ++ 0 < Module.finrank (Polynomial k ⧸ xIdeal (k := k)) (data.carrier ⧸ P)) ++ ++ + theorem finrank_eq_weighted_poleDegree_of_nonconstant + {L : Type*} [Field L] [Algebra k L] (f : L) [Fact (Transcendental k f⁻¹)] + [Module.Finite (FractionRing (Polynomial k)) (LinfAt (k := k) f)] +@@ -490,16 +447,16 @@ theorem finrank_eq_weighted_poleDegree_of_nonconstant + Module.finrank (FractionRing (Polynomial k)) (LinfAt (k := k) f) = + ∑ P ∈ IsDedekindDomain.primesOverFinset (xIdeal (k := k)) data.carrier, + (-(data.ordAt P)).toNat * +- Ideal.inertiaDeg' (xIdeal (k := k)) P := by +- letI := data.commRing +- letI := data.algPoly +- letI := data.isDomain +- letI := data.isDedekindDomain +- letI := data.algLinfAt +- letI := data.isFractionRing +- letI := data.isScalarTower +- letI := data.moduleFinite +- letI := data.isTorsionFree ++ P.inertiaDeg (Polynomial k) := by ++ let := data.commRing ++ let := data.algPoly ++ let := data.isDomain ++ let := data.isDedekindDomain ++ let := data.algLinfAt ++ let := data.isFractionRing ++ let := data.isScalarTower ++ let := data.moduleFinite ++ let := data.isTorsionFree + have h := finrank_eq_sum_ramificationIdx_mul_inertiaDeg + (k := k) (L := L) f data + rw [← h] +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Transcendence.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Transcendence.lean +index bdce413c5..a6490d166 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Transcendence.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Transcendence.lean +@@ -16,19 +16,6 @@ that a nonconstant curve map `φ : C₁ → C₂` induces a finite extension + `K(C₁) / φ*(K(C₂))`: the range of `φ.pullback` is an intermediate ring + containing the algebraic structure of `F[x]`, and transitivity does the rest. + +-This closes the *first piece* of the infrastructure needed for +-T-II-INFRA-B-009 (Silverman II.2.4(a), `CurveMap.pullback_image_finite_codim`). +-The full finiteness still requires transcendence-degree theory, which +-mathlib provides via `IsTranscendenceBasis`/`trdeg` but whose bridge to our +-subalgebra setting (`Algebra.adjoin F {C.coordX}`) needs additional +-typeclass-plumbing. That bridge is tracked as a follow-up. +- +-## Main results +- +-- `SmoothPlaneCurve.isAlgebraic_polynomialX_functionField`: `F(C)` is +- algebraic over `F[X]` (instance). Consequence of +- `IsLocalization.isAlgebraic` + `Algebra.IsAlgebraic.of_finite` + transitivity. +- + ## References + + * [Silverman, *The Arithmetic of Elliptic Curves*], II.1, II.2.4 +@@ -49,29 +36,19 @@ algebraic over the base), `F(x) → F(C)` is algebraic (finite of rank 2), and + algebraicness is transitive. -/ + instance isAlgebraic_polynomialX_functionField : + Algebra.IsAlgebraic (Polynomial F) C.FunctionField := by +- haveI : Algebra.IsAlgebraic (Polynomial F) (FractionRing (Polynomial F)) := ++ have : Algebra.IsAlgebraic (Polynomial F) (FractionRing (Polynomial F)) := + IsLocalization.isAlgebraic _ (nonZeroDivisors _) +- haveI : Algebra.IsAlgebraic (FractionRing (Polynomial F)) C.FunctionField := ++ have : Algebra.IsAlgebraic (FractionRing (Polynomial F)) C.FunctionField := + Algebra.IsAlgebraic.of_finite _ _ + exact Algebra.IsAlgebraic.trans (R := Polynomial F) + (S := FractionRing (Polynomial F)) (A := C.FunctionField) + +-/-- Every element of `F(C)` is integral over `F[X]`: since `F[X]` is a field +-(well, an integral domain), integrality and algebraicness coincide over it +-only for the algebraic case when the ring is a field. Here, since `F[X]` +-is an ID and `F(C)` is a domain, we can state integrality directly. +- +-**Remark**: `F[X]` is NOT a field, so `IsAlgebraic` and `IsIntegral` over +-`F[X]` are distinct notions in general; however, an element of `F(C)` that +-is a root of any nonzero polynomial over `F[X]` is a root of SOME monic +-polynomial (divide by the leading coefficient after clearing denominators +-in the fraction field). We don't need this strengthening for the main +-application. -/ ++/-- The function field is integral over the fraction field of the polynomial ring. -/ + instance isIntegral_fracPolynomialX_functionField : + Algebra.IsIntegral (FractionRing (Polynomial F)) C.FunctionField := by + exact (Algebra.IsAlgebraic.of_finite (FractionRing (Polynomial F)) C.FunctionField).isIntegral + +-/-! ### T-II-1-005: Uniformizer is not a `p`-th power in char `p > 0` -/ ++ + + /-- **Silverman Exercise II.2.15 (⇐), char-`p` half**: if `t ∈ F(C)` is a + uniformizer at some smooth point `P`, then `t` is not a `p`-th power in +@@ -103,7 +80,7 @@ theorem notMem_pthPowers_of_uniformizer {p : ℕ} (hp : 1 < p) + `F(C)` is finite over `Frac(F[X]) = F(x)`, so trdeg = 1 by additivity of + transcendence degree across the tower `F → F[X] → F(x) → F(C)`. -/ + +-/-- **trdeg F K(E) = 1 (axiom-clean)**: the function field of a smooth ++/-- **trdeg F K(E) = 1**: the function field of a smooth + plane curve has transcendence degree 1 over the base field. + + Tower computation: `trdeg F (Polynomial F) = 1` (mathlib's +@@ -113,11 +90,11 @@ Tower computation: `trdeg F (Polynomial F) = 1` (mathlib's + `FiniteOverKx`). Apply `trdeg_add_eq` twice. -/ + theorem functionField_trdeg_eq_one : Algebra.trdeg F C.FunctionField = 1 := by + have h_fund : Algebra.trdeg F (FractionRing (Polynomial F)) = 1 := by +- haveI : Algebra.IsAlgebraic (Polynomial F) (FractionRing (Polynomial F)) := ++ have : Algebra.IsAlgebraic (Polynomial F) (FractionRing (Polynomial F)) := + IsLocalization.isAlgebraic _ (nonZeroDivisors _) + rw [← trdeg_add_eq F (Polynomial F) (A := FractionRing (Polynomial F)), + Polynomial.trdeg_of_isDomain, trdeg_eq_zero, add_zero] +- haveI : Algebra.IsAlgebraic (FractionRing (Polynomial F)) C.FunctionField := ++ have : Algebra.IsAlgebraic (FractionRing (Polynomial F)) C.FunctionField := + Algebra.IsAlgebraic.of_finite _ _ + rw [← trdeg_add_eq F (FractionRing (Polynomial F)) (A := C.FunctionField), h_fund, + trdeg_eq_zero, add_zero] +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/AlgebraicNonNegOrd.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/AlgebraicNonNegOrd.lean +index c599cad55..ad80470ae 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/AlgebraicNonNegOrd.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/AlgebraicNonNegOrd.lean +@@ -84,7 +84,7 @@ theorem ord_P_nonneg_of_isAlgebraic + · rw [hf, ord_P_zero]; exact le_top + · have hv : C.pointValuation P f ≠ 0 := (C.pointValuation P).ne_zero_iff.mpr hf + simp only [ord_P] +- rw [dif_neg hv, show (0 : WithTop ℤ) = ((0 : ℤ) : WithTop ℤ) from rfl, ++ rw [dite_eq_right hv, show (0 : WithTop ℤ) = ((0 : ℤ) : WithTop ℤ) from rfl, + WithTop.coe_le_coe] + -- The order is `-toAdd (unzero hv)`, so `≤ 1` for the valuation becomes + -- `toAdd (unzero hv) ≤ toAdd 1 = 0`, giving `0 ≤ -toAdd (unzero hv)`. +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/Infinity.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/Infinity.lean +index bf9827ace..e8e5e12b2 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/Infinity.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/Infinity.lean +@@ -22,25 +22,21 @@ with the classical values + ordAtInfty(x) = -2, ordAtInfty(y) = -3. + ``` + +-Rather than building a local ring at infinity and extracting the valuation +-from its DVR structure (the approach outlined in the Phase-D ticket +-`T-II-INFRA-D-001`), this file defines `ordAtInfty` algebraically via the +-algebra norm `N : F(C) → F(x)`: ++The order at infinity is defined algebraically using the norm ++`N : F(C) → F(x)`: + + ``` + ordAtInfty(f) := - intDegree (N(f)) ∈ ℤ ∪ {∞}. + ``` + +-The rationale is that for a degree-2 extension of `F(x)`, ramified only at +-the place at infinity of `ℙ¹_F` with ramification index 2 and residue ++The rationale is that when the unique place of a degree-2 extension of `F(x)` above ++the place at infinity of `ℙ¹_F` has ramification index 2 and residue + degree 1, the valuation at the unique place of `F(C)` above infinity is + related to the ℙ¹-valuation of the norm by the classical formula + `v_K(N(f)) = f_w · w(f)` with `f_w = 1`. Concretely, + `ordAtInfty(f) = ordAtInfty(N(f))` where the right-hand side is the order at + infinity on `F(x)`, computed by `- intDegree`. + +-This closes (partial form) ticket `T-II-INFRA-D-002`. +- + ## References + + * [Silverman, *The Arithmetic of Elliptic Curves*], IV.1 (for +@@ -87,7 +83,7 @@ noncomputable def ordAtInfty (f : C.FunctionField) : WithTop ℤ := + if f = 0 then ⊤ + else ((- RatFunc.intDegree (C.normAsRatFunc f) : ℤ) : WithTop ℤ) + +-@[simp] theorem ordAtInfty_zero : C.ordAtInfty 0 = ⊤ := if_pos rfl ++@[simp] theorem ordAtInfty_zero : C.ordAtInfty 0 = ⊤ := ite_eq_left rfl + + theorem ordAtInfty_eq_top_iff (f : C.FunctionField) : + C.ordAtInfty f = ⊤ ↔ f = 0 := by +@@ -98,7 +94,7 @@ theorem ordAtInfty_eq_top_iff (f : C.FunctionField) : + + theorem ordAtInfty_of_ne {f : C.FunctionField} (hf : f ≠ 0) : + C.ordAtInfty f = (- RatFunc.intDegree (C.normAsRatFunc f) : ℤ) := +- if_neg hf ++ ite_eq_right hf + + /-- Multiplicativity of `ordAtInfty`: for nonzero `f, g`, + `ordAtInfty(f · g) = ordAtInfty(f) + ordAtInfty(g)`. -/ +@@ -950,7 +946,7 @@ private theorem degree_sub_C_leadingCoeff_div_mul_lt {n d : Polynomial F} + have h_deg : n.degree = (Polynomial.C lam * d).degree := by + rw [Polynomial.degree_C_mul hlam_ne, Polynomial.degree_eq_natDegree hn, + Polynomial.degree_eq_natDegree hd, h_eq] +- exact Polynomial.degree_sub_lt h_deg hn h_lc ++ exact Polynomial.degree_sub_lt_left h_deg hn h_lc + + private theorem ratFunc_exists_C_sub_intDegree_neg {r : RatFunc F} + (hr : r.intDegree ≤ 0) : +@@ -1056,13 +1052,13 @@ theorem ordAtInftyVal_eq_exp_neg_ordAtInfty {f : C.FunctionField} (hf : f ≠ 0) + have : (n : WithTop ℤ) = ((- RatFunc.intDegree (C.normAsRatFunc f) : ℤ) : WithTop ℤ) := + hn.symm.trans hN + have hni : n = - RatFunc.intDegree (C.normAsRatFunc f) := by exact_mod_cast this +- rw [ordAtInftyVal, if_neg hf, hni, neg_neg] ++ rw [ordAtInftyVal, ite_eq_right hf, hni, neg_neg] + +-@[simp] theorem ordAtInftyVal_zero : C.ordAtInftyVal 0 = 0 := if_pos rfl ++@[simp] theorem ordAtInftyVal_zero : C.ordAtInftyVal 0 = 0 := ite_eq_left rfl + + theorem ordAtInftyVal_ne_zero {f : C.FunctionField} (hf : f ≠ 0) : + C.ordAtInftyVal f ≠ 0 := by +- rw [ordAtInftyVal, if_neg hf]; exact WithZero.exp_ne_zero ++ rw [ordAtInftyVal, ite_eq_right hf]; exact WithZero.exp_ne_zero + + @[simp] theorem ordAtInftyVal_one : C.ordAtInftyVal (1 : C.FunctionField) = 1 := by + rw [C.ordAtInftyVal_eq_exp_neg_ordAtInfty one_ne_zero C.ordAtInfty_one, neg_zero, +@@ -1325,7 +1321,7 @@ theorem smoothPoint_x_preimage_finite (a : F) : + (t := {y : F | (C.fiberQuadratic a).IsRoot y}) + (fun _ hP ↦ C.fiberQuadratic_isRoot_of_smoothPoint hP) + (fun _ hP₁ _ hP₂ hy ↦ SmoothPoint.ext (hP₁.trans hP₂.symm) hy) +- (Polynomial.finite_setOf_isRoot (C.fiberQuadratic_ne_zero a)) ++ (Polynomial.finite_setOfPred_isRoot (C.fiberQuadratic_ne_zero a)) + + /-- The x-projection preimage of a finite set of `x`-values is finite. In + particular, `{P : C.SmoothPoint | P.x ∈ roots f}` is finite for any nonzero +@@ -1460,7 +1456,7 @@ theorem pointValuation_algebraMap_le_one (u : C.CoordinateRing) + exact IsDedekindDomain.HeightOneSpectrum.valuation_le_one + (IsDiscreteValuationRing.maximalIdeal (C.localRingAt P)) _ + +-/-- **Step (B'') foundational structural lemma (one direction)**: every ++/-- every + element of `C.localRingAt P` (after embedding into `K(C)`) has valuation + ≤ 1 at `P`. Direct from `IsDedekindDomain.HeightOneSpectrum.valuation_le_one` + applied at the localRingAt level (the localRing is a DVR, hence a Dedekind +@@ -1472,7 +1468,7 @@ theorem pointValuation_algebraMap_localRingAt_le_one + exact IsDedekindDomain.HeightOneSpectrum.valuation_le_one + (IsDiscreteValuationRing.maximalIdeal (C.localRingAt P)) x + +-/-- **Step (B'') foundational structural lemma (converse direction)**: every ++/-- every + element of `K(C)` with valuation ≤ 1 at `P` lifts to an element of + `C.localRingAt P`. Together with the easy direction, this characterises + the `algebraMap (localRingAt P) → KE` image as exactly +@@ -1533,7 +1529,7 @@ theorem exists_mul_algebraMap_eq_of_pointValuation_le_one + exact h2 + + +-/-- **Step (B'') foundational structural identification (biconditional)**: ++/-- + combines `pointValuation_algebraMap_localRingAt_le_one` and + `mem_localRingAt_image_of_pointValuation_le_one` into the canonical iff form. + This characterises the `algebraMap (localRingAt P) → KE` image as exactly +@@ -1552,7 +1548,7 @@ theorem ord_P_eq_zero_iff_pointValuation_eq_one (C : SmoothPlaneCurve F) + C.ord_P P f = 0 ↔ C.pointValuation P f = 1 := by + have hv : C.pointValuation P f ≠ 0 := (C.pointValuation P).ne_zero_iff.mpr hf + simp only [ord_P] +- rw [dif_neg hv] ++ rw [dite_eq_right hv] + constructor + · intro h + have h_nat : -((WithZero.unzero hv).toAdd : ℤ) = 0 := by exact_mod_cast h +@@ -1599,7 +1595,7 @@ theorem finite_setOf_mem_maximalIdealAt {u : C.CoordinateRing} (hu : u ≠ 0) : + hu ((Algebra.norm_eq_zero_iff (R := Polynomial F)).mp h) + refine (C.smoothPoint_x_preimage_finite_of_set + {a : F | (Algebra.norm (Polynomial F) u).IsRoot a} +- (Polynomial.finite_setOf_isRoot hNu_ne)).subset ?_ ++ (Polynomial.finite_setOfPred_isRoot hNu_ne)).subset ?_ + intro P (hP : u ∈ C.maximalIdealAt P) + rw [← hpq, C.mem_maximalIdealAt_iff_eval_zero P p q] at hP + change (Algebra.norm (Polynomial F) u).IsRoot P.x +@@ -1647,7 +1643,7 @@ theorem finite_setOf_ord_P_nonzero {f : C.FunctionField} (hf : f ≠ 0) : + (C.finite_setOf_ord_P_nonzero_of_coordinateRing hv_ne)).subset ?_ + intro P hP + by_contra h_both +- simp only [Set.mem_union, Set.mem_setOf_eq, not_or, not_not] at h_both ++ simp only [Set.mem_union, Set.mem_ofPred_eq, not_or, not_not] at h_both + obtain ⟨hu0, hv0⟩ := h_both + have hord : C.ord_P P + (algebraMap C.CoordinateRing C.FunctionField u) = +@@ -1658,8 +1654,7 @@ theorem finite_setOf_ord_P_nonzero {f : C.FunctionField} (hf : f ≠ 0) : + exact hP hord.symm + + /-- **Silverman II.1.2, Part 1**: a nonzero function on a smooth plane curve +-has zeros and poles at only finitely many smooth points. This is an alias +-for `finite_setOf_ord_P_nonzero` matching the ticket statement. -/ ++has zeros and poles at only finitely many smooth points. -/ + theorem finite_zeros_poles (f : C.FunctionField) (hf : f ≠ 0) : + {P : C.SmoothPoint | C.ord_P P f ≠ 0}.Finite := + C.finite_setOf_ord_P_nonzero hf +@@ -1668,16 +1663,6 @@ theorem finite_zeros_poles (f : C.FunctionField) (hf : f ≠ 0) : + if `f ∈ F(C)` has nonnegative order at infinity AND lies in the coordinate + ring, then `f` is the image of a constant from `F`. + +-This is the best form provable with our current infrastructure. The full +-"no-affine-poles ⟹ in CoordinateRing" step is the integral-closure +-property of smooth curves: for a smooth Weierstrass curve `[C.toAffine.IsElliptic]`, +-`C.CoordinateRing` is a Dedekind domain, hence integrally closed, and any +-`f ∈ F(C)` with `ord_P f ≥ 0` at every closed point is automatically in +-`C.CoordinateRing`. Without the `IsElliptic` hypothesis (or an equivalent +-smoothness assumption), singular points can have local rings that don't +-align with the global coordinate ring structure, and the integral-closure +-step requires genuinely new algebra-of-curves infrastructure. +- + Reference: Silverman II.1.2, second part; Hartshorne I.6.12. -/ + theorem const_of_no_poles_of_coordinateRing (f : C.FunctionField) + (h_coord : ∃ u : C.CoordinateRing, +@@ -1691,9 +1676,9 @@ theorem const_of_no_poles_of_coordinateRing (f : C.FunctionField) + exact (IsScalarTower.algebraMap_apply F C.CoordinateRing + C.FunctionField c).symm + +-/-- **IC-006 (Silverman II.1.2, Part 2, prime-indexed)**: if `f ∈ F(C)` has ++/-- **Silverman II.1.2, Part 2, prime-indexed**: if `f ∈ F(C)` has + nonnegative valuation at every nonzero prime of `C.CoordinateRing` **and** at +-infinity, then `f` is constant. Combines IC-006's Dedekind-Liouville bridge ++infinity, then `f` is constant. Combines the Dedekind-Liouville bridge + `mem_coordinateRing_of_valuation_le_one` with the CoordinateRing-form + algebraic Liouville `const_of_no_poles_of_coordinateRing`. -/ + theorem const_of_no_poles_of_valuation_of_ordAtInfty +@@ -1705,7 +1690,7 @@ theorem const_of_no_poles_of_valuation_of_ordAtInfty + C.const_of_no_poles_of_coordinateRing f + (C.mem_coordinateRing_of_valuation_le_one f h_primes) h_inf + +-/-- **IC-006 (integrality-based Liouville)**: if `f ∈ F(C)` is integral over ++/-- **Integrality-based Liouville**: if `f ∈ F(C)` is integral over + `F[X]` **and** has nonnegative order at infinity, then `f` is constant. + This is the cleanest consequence of `IsIntegrallyClosed C.CoordinateRing`: + integrality over `F[X]` lifts `f` into `C.CoordinateRing`, and then +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/NoFinitePolesBridge.lean b/projects/HasseWeil/HasseWeil/Foundation/Curves/Valuation/NoFinitePolesBridge.lean +index 0b44dea28cc6d4c4dd158920e7563ca5babef0db..966395e5596ce0a1deb52980a2031a07e846aa7d 100644 +GIT binary patch +delta 3411 +zcmb7G&yN&E6wdAge5EE9}B};;=g2BWeOl^0~bYXW_Q`NJ} +zaG7{9o}G(&(UVt6CZ3IFPnvk)WQc!)Cr^H_s;B4Yq8_KG>ect&_r34EzrR}grg(U5 +z>C9F)k4mL;OZ%!!DA&|hxhf?UI+ZpEwzMIU4|dM4Ez#iDCF)<1vHVo!aS&;3VwDS= +zH7f5kNRSa6N~F}TqEaI4Y)mSQjFgpWFW66HPO79`nd-b_snk>^lE#sn9GO%mIx?i2 +znbu`LA<+gz2B`AV0){ct7CMjldLmUPDVv)AH!71hq+9rA{At<~Y1d)2BsxY)mvq2y +zPW+?WjKYp009_=y__?c5puRAYkbXCkG41voUMn&gq&h<4v9ghoC`ld96(^+YGTW8L +zCaS>gnJnEAMv+rnr>Wkz)HXVEr^a!jL>Lh@OKH>tmjeN)pb;Mw>rALT41)J$TN;^1 +z@*)j>e=2;YLEGEm`S3zGJa+icL!WH!Nzukpe6DoQeBjAte<{kp}Kz +z%XB2Zup!+*R0xGN@?6xQ$vzs6cFmJ6}M2xN6^pJf{sF?x@c +z)bt+K^d43iT}V^*E&^R`OqJV>Q}DQ5BG%c~7^1l90S0U<04o=EPy;=MrX!d4;vOG9 +zq!*X}HJM7f|3ORKj(Mpd9^a)kWDBS>?Oa>wUG~!3MwQ$)=vZNPRcQn~Va~n-xVNBt +zU0o`?L-Kwp^VmNnM|!M0dq2Uv7?;=SIUM{DY;gB1?8C8fGmwKjGVo4aCFEwos0n7w +zDkL|pYAcbc%;Zr3XXj?~7<~Kk=~KP|otf{6Tv;?gNo+j>b?SxT@iTv}EQZYUqMDNI +zS5JmNA@DLWy4y)~w{(ou3iKtSabwqvU8?4)qb%?l*R|I*AC~9ORA0d#IElgWGpmF3 +zwIf4n^bZYApMPnI2l&aU@jYww4F;D}Ylq&X8?7+d;L(^%3y*rzEUygJNVpp&N%(J?SMZk40ddm*Kd*jDLeH@zzULB?mwfxf8+63XZlD-7stf|}ZOMYI^x@f^bM*L&FX`-!b06dGO>9y(Rf=O73}qYZ#%tm0m|W{Yu-7%Q6qZBOG^-Sq(k3PS$%8!_bAN2q`w#WA1_0BT0 +zwreCX5)$gAT!sU;@^b|VWF)vzkT{3t!hs8dE241d8Qz=Ob=Igtimb?rM@h=`j%%lplD1#bX63`LxXDpWhF +z%RzQIE{lML4PH@9R9P7Ip&ClfYhGROuvUabu}Ft35i){GA6i^RJcL+^DA6ElJW2$v +z)DYk=u=#!fJ&`maX>z#8LMb#fls~N>d1-AKj^nDM^k3k^Mzf>AEX*7-*C%!j +zHgHqi3BwAjwx}d`3$$4bB7&f-B^J~VfGLh&)OgJCBTB#`)kV+}Ypya?6A=qV(kB#B +z@wTVg9i&NRoy+wTDI=C^ +zTvv%kSvU7q_8kle9|L7uj%f28H*fElJ6VLI1ZP!YquZR+BlSk%{^88Gbp~O8`rYSAV4+wUOD}Ue^ +zy{wbSwp4Lb=yu79(95m$;mU|LIxX#-u)0ZQZ3P6V{RHXD?S8Z-RH7x=T$?#u96R#?*wZ6f;$a^?nSAsW$QR(Ih(M#-Nf!|{J`*uc +z8UCdzuR$I4oM74cdcksoLt%c}b8vX);ky%$tfs=rY7b3u;Xs+lXm=9SDO!Pu&>?iz +zqEb#f9^xeoD0-4U1dCV`PByHN^vMX!=TrNKTYJ_XDr}hRvj?Z`I_x8uujUtCpx%O@ +z*}Z{BpbWgxh@s&$xRZQN#ACG*LC;W~ZEGxe?Qb_ff~6n6fn(5GMhs*`L_^TRUv83C +z=qrDCb^oh7uASc=4U}Noi(GBUCRzcRT8`^6u{v}aV$b*sj}5Q`Zh5ID+C0)|m@IS? +zMk=o}9G7|rr$1+?tV+J>@pgsRob*#P=&lm!$&P%07GP;zgxH-n`ZtZ5x&Qb-b8wnU +z_Y=A59NhzGvMx8f7MIO)i}%lL}$4$InfcRxyuqqYJ_2djUC2@SpS`;M!b!a^DlK8>v=37lGE4owFgc=C75# +z&;OsX`S6l8Nee19L~mPiMYB0MceRM~@CHYUx)d&{Ae?^_C9c{Ldej0g10%jIh +z6uBd!G{g#{7tFg)9UlI2>gP#w@lwhBdgjBydMA!Cd@XqmF40|S=XS~j4NO0}KySxv +zrb1vzy3gHbcX`wbtz}iPgrl(Nm;g;HN=GIm*wK_oFR&QV3PwUL<0RP>4Ev<@3e!9lxs%$o +ziwR`P42~Sy+48$A41906bs;GXFJ8J;xPIBadve2@iMQ@zA|2dOGK^_Bdjr`9xg7Jd +zw*tEE{BC@9pd@e_YQP!307$S)K^o0eXFig>^e$U4ir?IwoE=z6IS W.toAffine.FunctionField + + omit [DecidableEq F] in +-/-- `pointValuation P f = exp (-n)` from `ord_P P f = n` (for `f ≠ 0`). Curve-side +-mirror of `ordAtInftyValuation_eq_exp_neg_of_ordAtInfty_eq`, kept local to avoid an +-import of `Hasse.L6Witnesses`. -/ ++/-- `pointValuation P f = exp (-n)` follows from `ord_P P f = n` for `f ≠ 0`. -/ + theorem pointValuation_eq_exp_neg_of_ord_P_eq {C : Curves.SmoothPlaneCurve F} {P : C.SmoothPoint} + {f : C.FunctionField} {n : ℤ} (hf : f ≠ 0) (hn : C.ord_P P f = (n : WithTop ℤ)) : + C.pointValuation P f = WithZero.exp (-n) := by + have hv : C.pointValuation P f ≠ 0 := (C.pointValuation P).ne_zero_iff.mpr hf + have hord : C.ord_P P f = ((-(WithZero.unzero hv).toAdd : ℤ) : WithTop ℤ) := by + simp only [Curves.SmoothPlaneCurve.ord_P] +- rw [dif_neg hv] ++ rw [dite_eq_right hv] + have hneq : n = -(WithZero.unzero hv).toAdd := by exact_mod_cast (hord.symm.trans hn).symm + rw [hneq, neg_neg, WithZero.exp, ofAdd_toAdd, WithZero.coe_unzero] + +@@ -84,8 +62,8 @@ theorem valuation_aeval_eq_exp (w : Valuation KE (WithZero (Multiplicative ℤ)) + intro i + rw [Algebra.smul_def, map_mul, map_pow, hu, ← WithZero.exp_nsmul] + by_cases hci : p.coeff i = 0 +- · rw [if_pos hci, hci, RingHom.map_zero, map_zero, zero_mul] +- · rw [if_neg hci, hc _ hci, one_mul] ++ · rw [ite_eq_left hci, hci, RingHom.map_zero, map_zero, zero_mul] ++ · rw [ite_eq_right hci, hc _ hci, one_mul] + congr 1 + rw [nsmul_eq_mul] + ring +@@ -97,13 +75,13 @@ theorem valuation_aeval_eq_exp (w : Valuation KE (WithZero (Multiplicative ℤ)) + refine (Valuation.map_sum_eq_of_lt w (Finset.self_mem_range_succ n) ?_).trans ?_ + · intro i hi + rw [Finset.mem_sdiff, Finset.mem_range, Finset.mem_singleton] at hi +- rw [h_term i, h_term n, if_neg h_lead_ne] ++ rw [h_term i, h_term n, ite_eq_right h_lead_ne] + by_cases hci : p.coeff i = 0 +- · rw [if_pos hci] ++ · rw [ite_eq_left hci] + exact lt_of_le_of_ne zero_le (Ne.symm WithZero.exp_ne_zero) +- · rw [if_neg hci, WithZero.exp_lt_exp] ++ · rw [ite_eq_right hci, WithZero.exp_lt_exp] + omega +- · rw [h_term n, if_neg h_lead_ne] ++ · rw [h_term n, ite_eq_right h_lead_ne] + + omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `algebraMap (Polynomial F) K(E)` is `aeval x_gen` (both are the F-algebra hom +@@ -277,10 +255,11 @@ theorem ordAtInftyValuation_basis_summands_distinct {r₁ r₂ : FractionRing (P + intro h_eq + omega + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + set_option backward.isDefEq.respectTransparency.types false in + /-- **Value on the coordinate function `y`.** A valuation `w` with `w y_gen = exp 3` + agrees with `ordAtInftyValuation` on `coordYInFunctionField` (which is `y_gen`): +-both equal `exp (-3)`. -/ ++both equal `exp 3`. -/ + private theorem valuation_coordYInFunctionField_eq_ordAtInftyValuation + (w : Valuation KE (WithZero (Multiplicative ℤ))) (hy : w (y_gen W) = WithZero.exp 3) : + w (W_smooth W).coordYInFunctionField = +@@ -359,6 +338,7 @@ private theorem eq_ordAtInftyValuation_of_agree_fracPolyX_coordY + exact valuation_eq_add_of_eq_of_eq_of_distinct W w (W_smooth W).ordAtInftyValuation + (h_rat p) hβc_agree (ordAtInftyValuation_basis_summands_distinct W h_not_both) + ++omit [W.toAffine.IsElliptic] in + /-- **Valuation determined by `x_gen`, `y_gen`.** A `ℤᵐ⁰`-valued valuation `w` on + `K(E)` with `w x_gen = exp 2`, `w y_gen = exp 3`, and trivial on `F^×` equals + `ordAtInftyValuation`. The decomposition `f = α + β·coordY` (`α, β ∈ F(x)`) plus +@@ -372,8 +352,9 @@ theorem eq_ordAtInftyValuation_of_x_y (w : Valuation KE (WithZero (Multiplicativ + (valuation_algebraMap_fracPolyX_eq_ordAtInftyValuation W w hx hc) + (valuation_coordYInFunctionField_eq_ordAtInftyValuation W w hy) + ++omit [W.toAffine.IsElliptic] in + /-- `ord_P (-T) (τ_T x_gen) = -2`, uniformly across 2-torsion and non-2-torsion +-`T = (xk, yk)`. Dispatches to the two shipped cases. -/ ++`T = (xk, yk)`. -/ + theorem ord_P_negSmoothPoint_translateX_xy_eq_neg_two + (xk yk : F) (h_ns : W.toAffine.Nonsingular xk yk) : + (W_smooth W).ord_P (negSmoothPoint W xk yk h_ns) +@@ -382,6 +363,7 @@ theorem ord_P_negSmoothPoint_translateX_xy_eq_neg_two + · exact ord_P_translateX_xy_eq_neg_two_at_2tor W xk yk h_ns h + · exact ord_P_translateX_xy_eq_neg_two_of_non_2_tor W xk yk h_ns h + ++omit [W.toAffine.IsElliptic] in + /-- `ord_P (-T) (τ_T y_gen) = -3`, uniformly across 2-torsion and non-2-torsion. -/ + theorem ord_P_negSmoothPoint_translateY_xy_eq_neg_three + (xk yk : F) (h_ns : W.toAffine.Nonsingular xk yk) : +@@ -461,11 +443,8 @@ theorem ord_P_negSmoothPoint_translateAlgEquivOfPoint_eq_ordAtInfty_some + rw [hm, hn] + exact_mod_cast neg_injective h_at_f + +-/-- **Unconditional discharge of `IsTranslateOrdAtInftyCompatible`.** For a finite +-smooth point `P` and a group element `k` with `P + k = O` (so `P = -k`), the +-translation pullback `τ_k` carries the order at `P` to the order at infinity: +-`ord_P P (τ_k f) = ordAtInfty f` for all `f`. Gates the Weil-pairing divisor +-transport. -/ ++/-- For a finite smooth point `P` and a group element `k` with `P + k = O`, ++translation pullback satisfies `ord_P P (τ_k f) = ordAtInfty f` for every `f`. -/ + theorem isTranslateOrdAtInftyCompatible_translateAlgEquivOfPoint + (P : (W_smooth W).SmoothPoint) (k : (W_smooth W).toAffine.Point) + (h_zero : P.toAffinePoint + k = Affine.Point.zero) : +diff --git a/projects/HasseWeil/HasseWeil/Foundation/EC/TranslateValuation.lean b/projects/HasseWeil/HasseWeil/Foundation/EC/TranslateValuation.lean +index 0fbf76569d790458fadca970039cf32598f16d3b..8fbe28c64fdb18776583e7ad48fb72d1d909f59c 100644 +GIT binary patch +delta 113 +zcmcckfaA%1jt!d_H~(RbV>B!+PAyhQ&d)7KEXhpD%*iaNRLDr=YRz^_cI$YZ+^qJR))JIH9oa4z9=(2qojGB^7eVkjK8Xo1-H+g$GBx8 +E0DZwO_W%F@ + +diff --git a/projects/HasseWeil/HasseWeil/Foundation/EC/Translation.lean b/projects/HasseWeil/HasseWeil/Foundation/EC/Translation.lean +index c135cb1b2..798b434d7 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/EC/Translation.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/EC/Translation.lean +@@ -6,43 +6,17 @@ Authors: Chris Birkbeck + import HasseWeil.Foundation.AdditionPullback + + /-! +-# Translation by a base-field point on K(E) ++# Translation by a base-field point on the function field + +-For an elliptic curve `W` over `F` and a point `(xk, yk) ∈ W(F)` (= a base-field +-solution of the Weierstrass equation), translation by `k = (xk, yk)` lifts +-to a K-algebra automorphism `τ_k : K(E) ≃ₐ[F] K(E)` defined by: ++Translation by a point `k = (xk, yk)` of an elliptic curve acts on its ++function field through the addition formulas. The slope is ++`(y_gen − yk) / (x_gen − xk)`, and the translated coordinate functions ++are obtained from this slope by `addX` and `addY`. The coordinate-ring ++homomorphism extends to the function field when the evaluation map is ++injective. Kernel translations preserve pullbacks along isogenies, ++relating the point kernel to function-field automorphisms. + +-* `τ_k(x_gen) = (W_KE).addX(x_gen, xk, slope_k)` where +- `slope_k = (y_gen - yk) / (x_gen - xk)`. +-* `τ_k(y_gen) = (W_KE).addY(x_gen, xk, y_gen, slope_k)`. +- +-This is the substantive Galois-correspondence content for elliptic +-isogenies (Silverman III.4.10(a)): for an isogeny `α : E → E`, the kernel +-of `α` (as an additive subgroup of `E.Point`) acts on `K(E₁)/α*K(E₂)` as +-the Galois group, and the bijection `α.kernel ≃ Aut(K(E)/α*K(E))` sends +-each kernel element `k` to the translation automorphism `τ_k`. +- +-This file constructs the translation algebra hom directly via the addition +-formula on coordinates, paralleling +-`HasseWeil/AdditionPullback.lean`'s `addPullbackAlgHom_negFrobenius` +-construction. +- +-## Foundational definitions +- +-The translation construction is parallel to `addPullback_x` / `addPullback_y` +-but with the second point a base-field constant rather than `α.pullback`. +- +-* `translateSlope_xy xk yk` — slope from `(x_gen, y_gen)` to `(xk, yk)`. +-* `translateX_xy xk yk` — x-coord of `P_gen + (xk, yk)`. +-* `translateY_xy xk yk` — y-coord of `P_gen + (xk, yk)`. +- +-These are foundational K(E)-elements; the algebra-hom construction (analog +-of `addPullbackAlgHom`) requires the `AddNonInverse` and injectivity +-witnesses. +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, III.4.10(a). ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.4.10(a). + -/ + + open WeierstrassCurve +@@ -293,6 +267,7 @@ noncomputable def translateAlgHom (xk yk : F) (h_eq : W.toAffine.Equation xk yk) + (translateCoordAlgHom_injective_of_baseHom_inj W xk yk h_eq hxy hxinj) + + omit [DecidableEq F] in ++omit [W.toAffine.IsElliptic] in + /-- A pole of `translateX_xy` at infinity forces non-constancy: if + `ordAtInfty (translateX_xy) < 0` then `translateX_xy` is not `algebraMap F KE c` + for any `c : F`. -/ +@@ -329,6 +304,7 @@ theorem translateBaseHom_injective_of_transcendental (xk yk : F) + exact transcendental_iff_injective.mp h_trans + + omit [DecidableEq F] in ++omit [W.toAffine.IsElliptic] in + private theorem ordAtInfty_sub_const_of_neg_aux {g : KE} {n : ℤ} (hn : n < 0) + (hg : (W_smooth W).ordAtInfty g = ((n : ℤ) : WithTop ℤ)) (c : F) : + (W_smooth W).ordAtInfty (g - algebraMap F KE c) = ((n : ℤ) : WithTop ℤ) := by +@@ -339,7 +315,7 @@ private theorem ordAtInfty_sub_const_of_neg_aux {g : KE} {n : ℤ} (hn : n < 0) + rw [hg, ordAtInfty_algebraMap_F_nonzero W hc] + exact_mod_cast hn + +-omit [DecidableEq F] in ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- For any `xk ∈ F`, `ord(x_gen - xk) = -2`, since the constant `xk` has + nonnegative order while `x_gen` has order `-2`. -/ + theorem ord_x_gen_sub_const (xk : F) : +@@ -370,7 +346,7 @@ theorem translateSlope_xy_eq (xk yk : F) : + intro h_eq + exact x_gen_sub_const_ne_zero W xk (sub_eq_zero.mpr h_eq) + +-omit [DecidableEq F] in ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord(y_gen - yk) = -3` for any `yk : F`. -/ + theorem ord_y_gen_sub_const (yk : F) : + (W_smooth W).ordAtInfty (y_gen W - algebraMap F KE yk) = +@@ -378,9 +354,9 @@ theorem ord_y_gen_sub_const (yk : F) : + classical + exact ordAtInfty_sub_const_of_neg_aux W (by norm_num) (ordAtInfty_y_gen W) yk + +-omit [DecidableEq F] in +-/-- `ord(translateSlope_xy) = -1` for non-zero `xk` (so the slope is in secant +-form). -/ ++omit [DecidableEq F] [W.toAffine.IsElliptic] in ++/-- The translation slope has order `−1` at infinity, as the quotient ++of coordinate differences of orders `−3` and `−2`. -/ + theorem ord_translateSlope_xy (xk yk : F) : + (W_smooth W).ordAtInfty (translateSlope_xy W xk yk) = + ((-1 : ℤ) : WithTop ℤ) := by +diff --git a/projects/HasseWeil/HasseWeil/Foundation/EC/TranslationOrd.lean b/projects/HasseWeil/HasseWeil/Foundation/EC/TranslationOrd.lean +index cea73bd37ab5ea56657974cbcf2551bdc8ca43c8..d6dda63fd0bbf1363e9aa0b34f4b582268277efa 100644 +GIT binary patch +delta 10891 +zcmbta4U8PuUDxc4-DVn_#<9c2ahzu*jh$rooJ-U;y@WJQAi*W>ozqi-DAn!U?%TVG +zXJ^hcv%b5Mu#E&X6;!3U&{4yO+Nx@men5&zhSCyb2_ZFw8X<&S2~;%#3JMS+N}xm$ +z{Qm#<-hAxtotq*>if?w_d;gE$|M&lR^P9i6=i9$>*)yNFK5&23@d6RWT^T205aNF# +zjlD1lyws0Ef&aWv$RO}nQ@_6xa;sw|ODN_fwIs$XGT-64Ad%mtmny5=5&~taynV%4O(xMyg|{#e#a3 +z-;`ak-s(g!i645Y6rCtc#`NLVgR$&zQtg4k}!OQh)e +zG8lHJUAKAw+0`4QQ9p`TSNx=p9RrB#b^8!MV1JzPf`M`XoxuhH+Y+%*4Lap} +zx4mA3!a70$PTzdx(W#~~B}W27q;4rUkO^5C(TzYObNu(SH@>yz;lqFSZMy~0RK#xW +z;Zmwi@5`6(O(qMpe^_%=?f9mqXU4B0iSd&(x4%W#_$g? +zPsU7F{FnpOV_ujRn~g8*Kl|xFf9g<8$-DmTJ&m_6jDR5f-TB59Ckg;v#NA>9G9^wc +zxXF&~vo1fo{>py{dok=~r}kK%rhnv@UT(ea{ul{Rq1`M$Xx+E-eH;{~U7 +zXysR|S^qG#dG^(V+0!3wyd}T%*R8Kw`13&a+LPAR`9FT#y3F2mF6_(x^2)}WayzSO)Litn&_$eeTt0<^i{z1}He1N~!;U&&c +z!sIgsxq8GY#MCi5#VGimqyhq-M-BviFUv0H6ZdGV#dXYt+*7>CrW=;F>4ck~{6l+}HBn8N)}!Xet7)s<**hMw4`tJTZST)-{kpxY +zVa;b>KkOVhUVRFynR~ +zkAZ4kXh_Q#n(`4Lr=&uIG1=7s(KHtgQM93Y4HVd?#ZOap$1YHwD!j7|j?|lQCDpqq +zCrg(akB%#(MRpIB2S8{F)>2d*fPmah`NMx|U&F>)MYX%+8}N*rmxwhV^_$rOhIicu +zix`BQmDNd#nw`j=&aDgBMsd{f;+Sa`s4y}PQI4a^nHM(+yuo!J{^m#Rrr|@-Q6(9p1#--`hM+!i!EWa7_zSybU9*+3b&O>n|CYUXrXKa~#X~fkdBnb+ +zV)0P^$LHuAuk80Wh7U+sjeA-0Y~4SmD^iYe +z-Fs?KT8V-#T#U^}mQfH+i+QA3ZVR{})2)UAL}dZMrO*rr#S)vL0WtZR_f~>0$I)OF +zeYWg_082d81*+(&+Ptb<>J;q}q(vPRa~xCU%E}Vcc2yo3->c+A74;})pSxi1YlI7A +zN6vfThtZamnx*6-)V2zOm6#<^q*lwaWU$1`O_9n~WF}l^YD)BO5HEh@vtow3{W4u- +zr(dx5X5ah+`;s~Hd#P@_hf#y60LwLqa$y8D1>5Ej578=2!aG(o*5STq1I{sFfOd^ +zjUsdlgwMKlr#AgENkiN^gu_MRk@%jBsYt +zf!m9MAX)gKjI$bk6O*3e~MKIsZ$h}jH8b0RP-*Dbs=`7A!&cltNHhtlykzFfBDw$km)*@c0g{Y-GnjV&K +z8)Fu)70C|xQT8FD;%r!jnFv!N;EvN4Q?SVR~Kn#^>pGZjkH0Z?xU| +zHo|uqzvEDTDLZ;fJu&yG(0;0j7)xNHnHOVBub(b>>SW>0D=93vrCri`B +zdLo563foX78(*WrQL$ICU`q-nT&s%;sG@MajQfe|^s_F;SQ}bqwjWibTaC+A52C2a +zw9%ysH8~I|N3)MkJC|m^I^#T=@4mvh!n&Uv%{s6xRTe5NTC-o-c9(^DS-Vo

  • nO +zIpus!ryoV9U72)Zx{?A5R5w(GH&q>&O3;v`94O&6Me|)BYb6qHsgf!=xo0f7PnQAI +zW}s#f>Cn`?iYssfllp32NDXBdJH~xAmju@Q7_ +zW7^Oc-FHgLIpMO~#!-tPqn<86#P(`3 +zWIu4kk@mz98X!Ar-Wrb-<|ADZm)q~0rxG$T-6vwDRgi)CR>H7*uUnU!U +z-HK;sL%xQt6#Ecq=!a*36AxoCeQ7>2aN-*cec__FuU#Z_9H}8a1DSkMIS<8+7eixQ +zQN+!1aL++`O2*+(>e-&4dv%I(W;+xQ8#r0ZhE6~U*G6&h3n&^E9&MM`$co13DqCBD +zf{d7Z5CpQ@TJk!l>Nlede=TEs!-d6hc9X{$;7EPzR`PgD=~eS_!B>KZD~7dNV$5UN +zEB|HhJyCTVGG1kZ$K+F3Zq$2qYXaq%iHYpwZ5WE}zQe(6`&bnbEn_fLkcRN+GK;K1 +zmkcFJ%)m>d6vz_|41;@u(_zf{z1?v1yJ9!@Uh#m-8#yCIP+^v_0xYR;-o%_BZSw +z&+gr4?at5L>9iWR-eaaZW>8u^hG(ROMGTg*>yJ6_+&wlOo60|R%vrZ8B@d_sUm_Ty +z<;J}hQxu$A_!98|I9I0k%=`61D(b0VNN%S>JsHr&olJ&gjDpbE;6;L|a9iOPAAMqse^>Jwi2N#uXusa;?cZOfkZ0K<6r0<{do*D(34q)COlb>-0UlhPBZ`Tob#GJ +zd%_fUx`v7I(GaK@k%{0?w&Ac-RVIanX&bZuJ>eY6{`q~*t|7<@V_up(pX7dzxWXP-&3^%M)oI2^4C9%8lz=d-B;O;-qls6mk#K5b~Rc^{eb5hRA93Vo6Y2Zx9GfTAAch|cKtKH*>JLr@^^KeXB)vA +z*;M%wMF=C5ScrUS45q(gK!<`hpo8Lxe9E)lg3bx3*{2?HuFVez&X=wHkne|wnq +z&VS~#^WAOBL6r?KHAi<=WlY{#dL3LWqI07tEl3X4HL9`l0=bBA-V5iVy-NoDvi2G3 +z>mOQ3l@K=M4_uNo_W4^IbTXLn0^}T}K)G=!VO|YCjetcVkFt|){J6<24TRH6UDS3< +z8`m)btJ4VkEidk@_Q`$KUaP W.toAffine.FunctionField + noncomputable def formalU : PowerSeries F := + PowerSeries.mk (fun n ↦ formalW_coeff W (n + 3)) + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The constant coefficient of `formalU` is 1. -/ + @[simp] theorem formalU_constantCoeff : + @PowerSeries.constantCoeff F _ (formalU W) = 1 := by + rw [← PowerSeries.coeff_zero_eq_constantCoeff_apply, formalU, PowerSeries.coeff_mk, + zero_add, formalW_coeff_three] + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalU W` is a unit in `F⟦X⟧`. -/ + theorem formalU_isUnit : IsUnit (formalU W) := by + rw [PowerSeries.isUnit_iff_constantCoeff] +@@ -92,16 +46,19 @@ theorem formalU_isUnit : IsUnit (formalU W) := by + noncomputable def formalU_inv : PowerSeries F := + PowerSeries.invOfUnit (formalU W) 1 + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalU * formalU_inv = 1` in `F⟦X⟧`. -/ + @[simp] theorem formalU_mul_inv : formalU W * formalU_inv W = 1 := + PowerSeries.mul_invOfUnit (formalU W) 1 + (by rw [formalU_constantCoeff]; rfl) + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalU_inv * formalU = 1` in `F⟦X⟧`. -/ + @[simp] theorem formalU_inv_mul : formalU_inv W * formalU W = 1 := + PowerSeries.invOfUnit_mul (formalU W) 1 + (by rw [formalU_constantCoeff]; rfl) + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The constant coefficient of `formalU_inv` is 1. -/ + @[simp] theorem formalU_inv_constantCoeff : + @PowerSeries.constantCoeff F _ (formalU_inv W) = 1 := by +@@ -131,6 +88,7 @@ In `LaurentSeries F`, `formalX W` has order `-2` and `formalY W` has order `-3`. + These follow because `formalU_inv W` has order `0` (constant coeff = 1) and + `single (-2) 1` resp. `single (-3) 1` have orders `-2` resp. `-3`. -/ + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `ofPowerSeries ℤ F (formalU_inv W)` is nonzero in `LaurentSeries F`. -/ + theorem ofPowerSeries_formalU_inv_ne_zero : + (HahnSeries.ofPowerSeries ℤ F (formalU_inv W) : LaurentSeries F) ≠ 0 := by +@@ -144,12 +102,14 @@ theorem ofPowerSeries_formalU_inv_ne_zero : + rw [h] at h_nonzero + exact one_ne_zero h_nonzero.symm + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalX W ≠ 0`. -/ + theorem formalX_ne_zero : formalX W ≠ 0 := by + rw [formalX] + exact mul_ne_zero (HahnSeries.single_ne_zero one_ne_zero) + (ofPowerSeries_formalU_inv_ne_zero W) + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalY W ≠ 0`. -/ + theorem formalY_ne_zero : formalY W ≠ 0 := by + rw [formalY] +@@ -157,6 +117,7 @@ theorem formalY_ne_zero : formalY W ≠ 0 := by + rw [ne_eq, neg_eq_zero] + exact HahnSeries.single_ne_zero one_ne_zero + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `ofPowerSeries ℤ F (formalU_inv W)` has `orderTop = 0`. This is because the + series has constant coefficient 1, so its order is ≤ 0; and all coefficients + at negative indices vanish (since `ofPowerSeries` embeds `ℕ ↪ ℤ`), so its order +@@ -177,10 +138,11 @@ theorem ofPowerSeries_formalU_inv_orderTop : + rw [HahnSeries.le_orderTop_iff_forall] + intro n hn + have : ((formalU_inv W : PowerSeries F) : LaurentSeries F).coeff n = 0 := by +- rw [PowerSeries.coeff_coe, if_pos]; exact_mod_cast hn ++ rw [PowerSeries.coeff_coe, ite_eq_left]; exact_mod_cast hn + exact this + exact le_antisymm h_le h_ge + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `formalX W` has `orderTop = -2` in `LaurentSeries F`. -/ + theorem formalX_orderTop : + (formalX W).orderTop = ((-2 : ℤ) : WithTop ℤ) := by +@@ -188,6 +150,7 @@ theorem formalX_orderTop : + ofPowerSeries_formalU_inv_orderTop] + rfl + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `formalY W` has `orderTop = -3` in `LaurentSeries F`. -/ + theorem formalY_orderTop : + (formalY W).orderTop = ((-3 : ℤ) : WithTop ℤ) := by +@@ -204,6 +167,7 @@ has leading coefficient `-1`. These come from expanding the definitions: + `formalX = single(-2,1) · (lifted u_inv)` with `(lifted u_inv).leadingCoeff = 1` + (since `u_inv` has constant coefficient `1`). -/ + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- The leading coefficient of the lifted `formalU_inv` is `1` (its constant + coefficient as a power series). -/ + theorem ofPowerSeries_formalU_inv_leadingCoeff : +@@ -222,12 +186,14 @@ theorem ofPowerSeries_formalU_inv_leadingCoeff : + rw [hS, this, PowerSeries.coeff_zero_eq_constantCoeff_apply] + exact formalU_inv_constantCoeff W + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `formalX W` has leading coefficient `1`. -/ + theorem formalX_leadingCoeff : + (formalX W).leadingCoeff = 1 := by + rw [formalX, HahnSeries.leadingCoeff_mul, HahnSeries.leadingCoeff_of_single, + ofPowerSeries_formalU_inv_leadingCoeff, mul_one] + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `formalY W` has leading coefficient `-1`. -/ + theorem formalY_leadingCoeff : + (formalY W).leadingCoeff = -1 := by +@@ -244,9 +210,8 @@ Weierstrass equation `y² + a₁xy + a₃y - x³ - ... - a₆ = 0` after substit + So the proof of `formalXY_weierstrass` is essentially: state the recurrence, + clear denominators in the field `LaurentSeries F`, and conclude via the recurrence. -/ + +--- The Silverman IV.1.1 recurrence `formalW_recurrence` is now proved in +--- `HasseWeil/FormalGroup.lean` and used directly here. + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalW W ≠ 0` because its coefficient at index 3 is 1. -/ + theorem formalW_ne_zero : formalW W ≠ 0 := by + intro h +@@ -258,6 +223,7 @@ theorem formalW_ne_zero : formalW W ≠ 0 := by + rw [this] at h3 + exact one_ne_zero h3 + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `HahnSeries.ofPowerSeries ℤ F (formalW W) ≠ 0` in `LaurentSeries F`. -/ + theorem lifted_formalW_ne_zero : + HahnSeries.ofPowerSeries ℤ F (formalW W) ≠ 0 := by +@@ -265,6 +231,7 @@ theorem lifted_formalW_ne_zero : + exact formalW_ne_zero W + (HahnSeries.ofPowerSeries_injective (h.trans (map_zero _).symm)) + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalW = X^3 * formalU` as `PowerSeries F`. -/ + theorem formalW_eq_X3_mul_U : + formalW W = PowerSeries.X ^ 3 * formalU W := by +@@ -282,7 +249,7 @@ theorem formalW_eq_X3_mul_U : + rw [hLHS] + -- RHS: (X^3 * formalU).coeff n = 0 for n < 3 + rw [PowerSeries.coeff_X_pow_mul'] +- rw [if_neg (by omega : ¬ 3 ≤ n)] ++ rw [ite_eq_right (by omega : ¬ 3 ≤ n)] + · push Not at hn + obtain ⟨m, rfl⟩ := Nat.exists_eq_add_of_le hn + rw [add_comm 3 m, PowerSeries.coeff_X_pow_mul] +@@ -290,11 +257,12 @@ theorem formalW_eq_X3_mul_U : + rw [show formalU W = PowerSeries.mk (fun n ↦ formalW_coeff W (n + 3)) from rfl, + PowerSeries.coeff_mk] + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `formalW W` has `PowerSeries.order` equal to 3 (since `formalW = X^3 * formalU` + and `formalU` is a unit). -/ + theorem formalW_ps_order : (formalW W).order = 3 := by + rw [formalW_eq_X3_mul_U, PowerSeries.order_mul, PowerSeries.order_X_pow, +- PowerSeries.order_zero_of_unit (formalU_isUnit W)] ++ PowerSeries.order_zero_of_isUnit (formalU_isUnit W)] + rfl + + omit [DecidableEq F] in +@@ -335,6 +303,7 @@ private theorem formalW_recurrence_lift : + HahnSeries.ofPowerSeries_X] at h + exact h + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Helper: `formalY W * lifted_formalW W = -1` in `LaurentSeries F`. -/ + private theorem formalY_mul_formalW : + formalY W * HahnSeries.ofPowerSeries ℤ F (formalW W) = -1 := by +@@ -355,6 +324,7 @@ private theorem formalY_mul_formalW : + _ = -(1 : LaurentSeries F) * 1 := by rw [h1, h2] + _ = -1 := by ring + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Helper: `formalX W * lifted_formalW W = single 1 1` in `LaurentSeries F`. -/ + private theorem formalX_mul_formalW : + formalX W * HahnSeries.ofPowerSeries ℤ F (formalW W) = +@@ -377,12 +347,14 @@ private theorem formalX_mul_formalW : + _ = HahnSeries.single (1 : ℤ) (1 : F) * 1 := by rw [h1, h2] + _ = HahnSeries.single (1 : ℤ) (1 : F) := mul_one _ + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `formalY W = -1 / lifted_formalW W` in `LaurentSeries F`. -/ + theorem formalY_eq_div : + formalY W = -1 / HahnSeries.ofPowerSeries ℤ F (formalW W) := by + rw [eq_div_iff (lifted_formalW_ne_zero W)] + exact formalY_mul_formalW W + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `formalX W = (single 1 1) / lifted_formalW W` in `LaurentSeries F`. -/ + theorem formalX_eq_div : + formalX W = HahnSeries.single (1 : ℤ) (1 : F) / +@@ -390,6 +362,7 @@ theorem formalX_eq_div : + rw [eq_div_iff (lifted_formalW_ne_zero W)] + exact formalX_mul_formalW W + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `(formalX W, formalY W)` satisfies the Weierstrass equation of `W` over `F`, + interpreted as an identity in `LaurentSeries F`. + +@@ -445,6 +418,7 @@ noncomputable def localParam : KE := + + /- `x_gen_ne_zero` HOISTED to `Foundation/MulByIntPullback.lean` (#7621). -/ + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The local parameter is nonzero in `K(E)`. -/ + theorem localParam_ne_zero : localParam W ≠ 0 := by + simp only [localParam] +@@ -470,16 +444,19 @@ through `AdjoinRoot.lift` and `IsLocalization.lift`. -/ + noncomputable def localExpand_inner : Polynomial F →+* LaurentSeries F := + Polynomial.eval₂RingHom (algebraMap F (LaurentSeries F)) (formalX W) + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The inner ring hom sends `Polynomial.X` to `formalX W`. -/ + @[simp] theorem localExpand_inner_X : + localExpand_inner W Polynomial.X = formalX W := by + simp [localExpand_inner] + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The inner ring hom sends constants to their algebra image. -/ + @[simp] theorem localExpand_inner_C (a : F) : + localExpand_inner W (Polynomial.C a) = algebraMap F (LaurentSeries F) a := by + simp [localExpand_inner] + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- The Weierstrass polynomial, evaluated via the inner ring hom at `formalY W`, + vanishes. This is `formalXY_weierstrass` expressed in terms of `Polynomial.eval₂`. -/ + private theorem localExpand_weierstrass_eval : +@@ -505,11 +482,13 @@ private noncomputable def localExpand_coordHom : + W.toAffine.CoordinateRing →+* LaurentSeries F := + AdjoinRoot.lift (localExpand_inner W) (formalY W) (localExpand_weierstrass_eval W) + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- The coordinate ring lift sends `AdjoinRoot.root` to `formalY W`. -/ + @[simp] private theorem localExpand_coordHom_root : + localExpand_coordHom W (AdjoinRoot.root W.toAffine.polynomial) = formalY W := by + simp [localExpand_coordHom, AdjoinRoot.lift_root] + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `(formalX W ^ n).orderTop = -2 * n` in `LaurentSeries F` (for `n : ℕ`). -/ + theorem formalX_pow_orderTop (n : ℕ) : + ((formalX W) ^ n).orderTop = ((-2 * n : ℤ) : WithTop ℤ) := by +@@ -526,6 +505,7 @@ theorem formalX_pow_orderTop (n : ℕ) : + push_cast + ring + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `(formalX W ^ n).leadingCoeff = 1` in `LaurentSeries F` (for `n : ℕ`). -/ + theorem formalX_pow_leadingCoeff (n : ℕ) : + ((formalX W) ^ n).leadingCoeff = 1 := by +@@ -536,6 +516,7 @@ theorem formalX_pow_leadingCoeff (n : ℕ) : + | succ k ih => + rw [pow_succ, HahnSeries.leadingCoeff_mul, ih, formalX_leadingCoeff, mul_one] + ++omit [W.toAffine.IsElliptic] in + /-- Auxiliary: for a polynomial `p : F[X]` with `p ≠ 0`, the image + `localExpand_inner W p` has `orderTop = -2 * p.natDegree` in `LaurentSeries F`. + +@@ -588,6 +569,7 @@ theorem localExpand_inner_orderTop_eq {p : Polynomial F} (hp : p ≠ 0) : + nlinarith + exact (HahnSeries.orderTop_add_eq_right h_lt).trans hB_ord + ++omit [W.toAffine.IsElliptic] in + /-- Auxiliary: for a nonzero polynomial `p : F[X]`, `localExpand_inner W p ≠ 0`. -/ + theorem localExpand_inner_ne_zero_of_ne_zero {p : Polynomial F} (hp : p ≠ 0) : + localExpand_inner W p ≠ 0 := by +@@ -596,6 +578,7 @@ theorem localExpand_inner_ne_zero_of_ne_zero {p : Polynomial F} (hp : p ≠ 0) : + rw [h, HahnSeries.orderTop_zero] at horder + exact absurd horder WithTop.top_ne_coe + ++omit [W.toAffine.IsElliptic] in + /-- Auxiliary: for a polynomial `p : F[X]` with `p ≠ 0`, the image + `localExpand_inner W p` has leading coefficient equal to `p.leadingCoeff`. + +@@ -653,6 +636,7 @@ theorem localExpand_inner_leadingCoeff {p : Polynomial F} (hp : p ≠ 0) : + nlinarith + rw [HahnSeries.leadingCoeff_add_eq_right h_lt, hB_lead, ← hDecomp] + ++omit [W.toAffine.IsElliptic] in + /-- Auxiliary: `(localExpand_inner W q) * formalY W` has odd `orderTop` + (`= -2 * natDegree q - 3`) when `q ≠ 0`. -/ + theorem localExpand_inner_mul_formalY_orderTop +@@ -663,6 +647,7 @@ theorem localExpand_inner_mul_formalY_orderTop + ← WithTop.coe_add] + rfl + ++omit [W.toAffine.IsElliptic] in + /-- The coordinate ring lift is injective. + + **Proof (Silverman IV.1)**: We use `exists_smul_basis_eq` to write any +@@ -738,20 +723,11 @@ private theorem localExpand_coordHom_injective : + rw [Affine.CoordinateRing.smul, Polynomial.C_0, map_zero, zero_mul, zero_add, + Affine.CoordinateRing.smul, Polynomial.C_0, map_zero, zero_mul] + +-/-- The **local expansion** ring hom `K(E) → LaurentSeries F`, sending `x_gen ↦ +- formalX W` and `y_gen ↦ formalY W`. +- +-The construction: +-1. Build the inner ring hom `i : F[X] →+* LaurentSeries F` sending `X ↦ formalX W`. +-2. Lift to `R = AdjoinRoot W.polynomial = F[X][Y]/(W) →+* LaurentSeries F` via +- `AdjoinRoot.lift` with root `formalY W`, using `formalXY_weierstrass` for +- the evaluation condition. +-3. Extend to `K(E) = FractionRing R →+* LaurentSeries F` via `IsFractionRing.lift`, +- using that the coordinate ring lift is injective (source is a domain, target +- is a field, and the map is nonzero — sends `1` to `1`). -/ ++ + noncomputable def localExpand : KE →+* LaurentSeries F := + IsFractionRing.lift (localExpand_coordHom_injective W) + ++omit [W.toAffine.IsElliptic] in + /-- `localExpand` sends `x_gen` to `formalX W`. -/ + @[simp] theorem localExpand_x_gen : localExpand W (x_gen W) = formalX W := by + simp only [localExpand, x_gen] +@@ -761,11 +737,13 @@ noncomputable def localExpand : KE →+* LaurentSeries F := + ((AdjoinRoot.of W.toAffine.polynomial) Polynomial.X) = formalX W + simp [localExpand_coordHom, AdjoinRoot.lift_of, localExpand_inner] + ++omit [W.toAffine.IsElliptic] in + /-- `localExpand` sends `y_gen` to `formalY W`. -/ + @[simp] theorem localExpand_y_gen : localExpand W (y_gen W) = formalY W := by + simp only [localExpand, y_gen] + rw [IsFractionRing.lift_algebraMap, localExpand_coordHom_root] + ++omit [W.toAffine.IsElliptic] in + /-- `localExpand` is an `F`-algebra hom. -/ + theorem localExpand_algebraMap (a : F) : + localExpand W (algebraMap F KE a) = +@@ -781,6 +759,7 @@ theorem localExpand_algebraMap (a : F) : + simp [localExpand_coordHom, AdjoinRoot.lift_of, localExpand_inner, + LaurentSeries.algebraMap_apply, HahnSeries.ofPowerSeries_C] + ++omit [W.toAffine.IsElliptic] in + /-- `localExpand` agrees with the inner ring hom `localExpand_inner` on the image + of `F[X]` in `K(E)`: `localExpand (algebraMap (Polynomial F) KE p) = + localExpand_inner W p`. Both factor the algebra map through the coordinate ring +@@ -795,6 +774,7 @@ theorem localExpand_algebraMap_polynomial (p : Polynomial F) : + localExpand_inner W p + simp [localExpand_coordHom, AdjoinRoot.lift_of] + ++omit [W.toAffine.IsElliptic] in + /-- The `orderTop` of the local expansion of `algebraMap (Polynomial F) KE p` for a + nonzero polynomial `p` is `-2 · natDegree p`. This is `localExpand_inner_orderTop_eq` + transported through `localExpand_algebraMap_polynomial`. -/ +@@ -804,6 +784,7 @@ theorem orderTop_localExpand_algebraMap_polynomial {p : Polynomial F} (hp : p + rw [localExpand_algebraMap_polynomial] + exact localExpand_inner_orderTop_eq W hp + ++omit [W.toAffine.IsElliptic] in + /-- `localExpand` sends `localParam W` to the variable `t` of `LaurentSeries F`. + This is the key compatibility: the local parameter expands to the formal variable. -/ + theorem localExpand_localParam : +diff --git a/projects/HasseWeil/HasseWeil/Foundation/MulByIntPullback.lean b/projects/HasseWeil/HasseWeil/Foundation/MulByIntPullback.lean +index f41767ca5..e2383c638 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/MulByIntPullback.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/MulByIntPullback.lean +@@ -368,7 +368,7 @@ private lemma aeval_x_gen (p : Polynomial F) : + Polynomial.aeval_X_left_apply] + + -- The `Subalgebra F KE` scalar-tower instances and the `aeval` defeq steps below need the +--- relaxed transparency; this is a defeq setting, not a heartbeat budget. ++ + /- `mulByInt_x W n = Φ_n(x_gen) / ΨSq_n(x_gen)` is transcendental over `F` for `n ≠ 0`. + + The proof uses the integral closure approach: if `mulByInt_x` were algebraic over `F`, +@@ -382,7 +382,7 @@ private lemma mulByInt_x_transcendental (n : ℤ) (hn : n ≠ 0) : + intro h_alg + apply x_gen_transcendental W + set S : Subalgebra F KE := Algebra.adjoin F ({mulByInt_x W n} : Set KE) with hS_def +- haveI hS_alg : Algebra.IsAlgebraic F S := ++ have hS_alg : Algebra.IsAlgebraic F S := + (Subalgebra.isAlgebraic_iff S).mp + (Algebra.isAlgebraic_adjoin_singleton_iff.mpr h_alg) + have hmem : mulByInt_x W n ∈ S := Algebra.subset_adjoin (Set.mem_singleton _) +@@ -448,10 +448,8 @@ private lemma norm_smul_basis_ne_zero (p q : Polynomial F) (hq : q ≠ 0) : + (not_le.mpr (WithBot.bot_lt_iff_ne_bot.mpr this)) + + omit [W.toAffine.IsElliptic] in +-/-- The image in `R = F[C]` of the `F[X]`-norm of the basis element `r' = p•1 + q•Y` +-factors as `r' * conj_r`, where `conj_r` is the `F[X]`-conjugate class. Extracted as its +-own lemma so it elaborates in a light context (the `coe_norm_smul_basis` rewrite and the +-ring-hom bookkeeping are heartbeat-heavy inside the main injectivity proof). -/ ++ ++ + private lemma algebraMap_norm_smul_basis_eq (p q : Polynomial F) : + algebraMap (Polynomial F) R (Algebra.norm (Polynomial F) + (p • (1 : R) + q • Affine.CoordinateRing.mk W.toAffine Polynomial.X)) = +diff --git a/projects/HasseWeil/HasseWeil/Foundation/OmegaCoeffMulByIntFiniteField.lean b/projects/HasseWeil/HasseWeil/Foundation/OmegaCoeffMulByIntFiniteField.lean +index a61618eea..51a6ac743 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/OmegaCoeffMulByIntFiniteField.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/OmegaCoeffMulByIntFiniteField.lean +@@ -8,35 +8,35 @@ import HasseWeil.HasseBound.Primitives + import HasseWeil.Foundation.EC.MulByIntAddRecurrence + + /-! +-# Silverman III.5.3: `a_{[m]} = m` via curve-side additivity (Route B assembly) ++# Pullback coefficients of integer multiplication + +-Builds on **RB-ω4** (`kaehler_D_addPullback_x_eq_one_add_smul_omega`, the Silverman III.5.2 +-collapse) to assemble `omegaPullbackCoeff (mulByInt m) = m` WITHOUT the EDS Wronskian and WITHOUT +-the formal-group correspondence. ++The addition formula for the invariant differential gives ++`a_{id+α} = 1 + a_α` and `a_{α+β} = a_α + a_β`. The multiplication-coordinate ++recurrence then proves `a_{[m]} = m` for nonzero integers by induction and ++negation. In positive characteristic, multiplication by the characteristic ++has zero differential coefficient. Over a finite field, the same holds for ++multiplication by its cardinality and supplies the differential input to ++Verschiebung factorization. + +-* **RB-ADD** (`omegaPullbackCoeff_addIsog_id`): +- `omegaPullbackCoeff (id ⊞ α) = 1 + omegaPullbackCoeff α`. +-* **RB-ID/SUM/IND**: `id ⊞ [m] = [m+1]`, induction → `omegaPullbackCoeff (mulByInt m) = m`. +- +-This is Silverman III.5.2 `(φ+ψ)*ω = φ*ω + ψ*ω` specialised to `φ = id`, then III.5.3's induction. ++References: Silverman, *The Arithmetic of Elliptic Curves*, III.5.2–3. + -/ + + open WeierstrassCurve + + namespace HasseWeil + +-variable {K : Type*} [Field K] [Fintype K] [DecidableEq K] ++variable {K : Type*} [Field K] [DecidableEq K] + (W : WeierstrassCurve K) [W.toAffine.IsElliptic] + + local notation "KE" => W.toAffine.FunctionField + local notation "R" => W.toAffine.CoordinateRing + +-/-- **RB-ADD** (Silverman III.5.2, `φ = id` case): for the genuine sum isogeny `σ = id ⊞ α` ++/-- Silverman III.5.2 for addition with the identity: for the genuine sum isogeny `σ = id ⊞ α` + (built via `addIsog` on the pair `(id, α)`), the omega-pullback coefficient is `1 + a_α`. + + Proof: by uniqueness in the 1-dimensional Kähler module. `omegaPullbackCoeff_spec` gives + `a_σ • ω = (α*u of σ)⁻¹ • D(σ*x)`. Now `σ*x = addPullback_x α` and `α*u of σ = u₃ := +-2·addPullback_y + a₁·addPullback_x + a₃`, while RB-ω4 says `D(addPullback_x α) = u₃ · (1+a_α) · ω`. ++2·addPullback_y + a₁·addPullback_x + a₃`, while the addition identity says `D(addPullback_x α) = u₃ · (1+a_α) · ω`. + So `a_σ • ω = u₃⁻¹ · u₃ · (1+a_α) · ω = (1+a_α) · ω`, hence `a_σ = 1 + a_α`. -/ + theorem omegaPullbackCoeff_addIsog_id + (α : Isogeny W.toAffine W.toAffine) +@@ -115,21 +115,16 @@ theorem omegaPullbackCoeff_addIsog_pair + kaehler_D_addPullback_x_pair_eq_smul_omega W α₁ α₂ h_ne, smul_smul, + inv_mul_cancel₀ hu3_ne, one_smul] + +--- **RB-ID core** (`addPullback_xy_mulByInt_eq_succ`, the Silverman III.5.3 addition recurrence +--- `P ⊞ [m]P = [m+1]P`) lives in `HasseWeil.EC.MulByIntAddRecurrence` (minimal imports, to skirt the +--- `(W_KE W).toAffine.Point` ℤ-smul instance diamond — see `SK-ROUTEB-SMUL-DIAMOND` there). It is +--- imported above and consumed by RB-IND below. +- +-/-- **RB chord step** (Silverman III.5.3 recurrence at the differential level): for `k ≥ 2`, ++/-- The Silverman III.5.3 recurrence at the differential level: for `k ≥ 2`, + `a_{[k+1]} = 1 + a_{[k]}`. + + Proof. By uniqueness in the 1-dimensional Kähler module. `omegaPullbackCoeff_spec` gives + `a_{[k+1]} • ω = (α*u of [k+1])⁻¹ • D([k+1]*x)`. Now: +-* `[k+1]*x = mulByInt_x (k+1) = addPullback_x [k]` (RB-ID), so `D([k+1]*x) = D(addPullback_x [k])`. +-* RB-ω4 (α = `[k]`, with `x_gen ≠ [k]*x` since `k ≥ 2`): ++* `[k+1]*x = mulByInt_x (k+1) = addPullback_x [k]` (the multiplication-coordinate recurrence), so `D([k+1]*x) = D(addPullback_x [k])`. ++* The differential addition identity (α = `[k]`, with `x_gen ≠ [k]*x` since `k ≥ 2`): + `D(addPullback_x [k]) = u₃ • ((1 + a_{[k]}) • ω)` + where `u₃ = 2·addPullback_y [k] + a₁·addPullback_x [k] + a₃`. +-* RB-ID rewrites `addPullback_x/y [k] = mulByInt_x/y (k+1)`, so `u₃ = α*u of [k+1]` (definitionally, ++* The coordinate recurrence rewrites `addPullback_x/y [k] = mulByInt_x/y (k+1)`, so `u₃ = α*u of [k+1]` (definitionally, + via `alpha_star_u_mulByInt`). + + Hence `a_{[k+1]} • ω = u₃⁻¹ • (u₃ • (1 + a_{[k]}) • ω) = (1 + a_{[k]}) • ω`. -/ +@@ -142,15 +137,15 @@ theorem omegaPullbackCoeff_mulByInt_succ (k : ℤ) (hk2 : 2 ≤ k) : + have hx_ne : x_gen W ≠ mulByInt_x W k := by + rw [← mulByInt_x_one W] + exact mulByInt_x_ne_mulByInt_x W 1 k one_ne_zero hk0 (by omega) (by omega) +- -- `[k]*x = mulByInt_x k`, so RB-ω4's hypothesis `x_gen ≠ [k]*x` is `hx_ne`. ++ -- `[k]*x = mulByInt_x k`, so the differential addition hypothesis `x_gen ≠ [k]*x` is `hx_ne`. + have hkx : (mulByInt W.toAffine k).pullback (x_gen W) = mulByInt_x W k := + mulByInt_pullback_x W k hk0 + have hx_ne_pb : x_gen W ≠ (mulByInt W.toAffine k).pullback (x_gen W) := by + rw [hkx]; exact hx_ne +- -- RB-ID: `addPullback_x/y [k] = mulByInt_x/y (k+1)`. ++ -- The coordinate recurrence: `addPullback_x/y [k] = mulByInt_x/y (k+1)`. + obtain ⟨hAx, hAy⟩ := addPullback_xy_mulByInt_eq_succ W k hk0 hk1 hx_ne + -- `α*u of [k+1] = u₃ := 2·addPullback_y [k] + a₁·addPullback_x [k] + a₃` +- -- (def + RB-ID + alpha_star_u_mulByInt). ++ -- (by the coordinate recurrence and alpha_star_u_mulByInt). + have hu : alpha_star_u W (mulByInt W.toAffine (k + 1)) + = 2 * addPullback_y W (mulByInt W.toAffine k) + + algebraMap K KE W.a₁ * addPullback_x W (mulByInt W.toAffine k) +@@ -159,7 +154,7 @@ theorem omegaPullbackCoeff_mulByInt_succ (k : ℤ) (hk2 : 2 ≤ k) : + have hu3_ne : 2 * addPullback_y W (mulByInt W.toAffine k) + + algebraMap K KE W.a₁ * addPullback_x W (mulByInt W.toAffine k) + algebraMap K KE W.a₃ ≠ 0 := + hu ▸ alpha_star_u_ne_zero W (mulByInt W.toAffine (k + 1)) +- -- `[k+1]*x = addPullback_x [k]` (mulByInt_pullback_x + RB-ID). ++ -- `[k+1]*x = addPullback_x [k]` (by mulByInt_pullback_x and the coordinate recurrence). + have hpx : (mulByInt W.toAffine (k + 1)).pullback + (algebraMap R KE (algebraMap (Polynomial K) R Polynomial.X)) + = addPullback_x W (mulByInt W.toAffine k) := by +@@ -169,7 +164,7 @@ theorem omegaPullbackCoeff_mulByInt_succ (k : ℤ) (hk2 : 2 ≤ k) : + kaehler_D_addPullback_x_eq_one_add_smul_omega W (mulByInt W.toAffine k) hx_ne_pb, smul_smul, + inv_mul_cancel₀ hu3_ne, one_smul] + +-/-- `a_{[n]} = n` for all `n ≥ 2`, by `Int.leInduction` from the axiom-clean base case `n = 2` ++/-- `a_{[n]} = n` for all `n ≥ 2`, by `Int.leInduction` from the base case `n = 2` + (`omegaPullbackCoeff_mulByInt_two`), with step `k ≥ 2 ⟹ k+1` via the chord step + `omegaPullbackCoeff_mulByInt_succ`. -/ + theorem omegaPullbackCoeff_mulByInt_ge_two (n : ℤ) (hn : 2 ≤ n) : +@@ -180,7 +175,7 @@ theorem omegaPullbackCoeff_mulByInt_ge_two (n : ℤ) (hn : 2 ≤ n) : + rw [omegaPullbackCoeff_mulByInt_succ W k hk2, ih, Int.cast_add, Int.cast_one, map_add, + map_one, add_comm] + +-/-- **RB-IND** (Silverman III.5.3, positive case): `a_{[n]} = n` for all `n ≥ 1`. Combines the ++/-- Silverman III.5.3 for positive integers: `a_{[n]} = n` for all `n ≥ 1`. Combines the + `n = 1` case (`[1] = id`, `a_id = 1`) with `omegaPullbackCoeff_mulByInt_ge_two`. -/ + theorem omegaPullbackCoeff_mulByInt_pos (n : ℤ) (hn : 1 ≤ n) : + omegaPullbackCoeff W (mulByInt W.toAffine n) = algebraMap K KE n := by +@@ -188,8 +183,7 @@ theorem omegaPullbackCoeff_mulByInt_pos (n : ℤ) (hn : 1 ≤ n) : + · subst h1; rw [mulByInt_one_eq_id, omegaPullbackCoeff_id, Int.cast_one, map_one] + · exact omegaPullbackCoeff_mulByInt_ge_two W n (by omega) + +-omit [Fintype K] in +-/-- **RB negation**: `a_{[-n]} = -a_{[n]}` for `n ≠ 0`. The `[-n]`-pullback of `x_gen` ++/-- Negation of the multiplication differential coefficient: `a_{[-n]} = -a_{[n]}` for `n ≠ 0`. The `[-n]`-pullback of `x_gen` + agrees with the `[n]`-pullback (`mulByInt_x_neg`), while `α*u` flips sign + (`negY`-symmetry of `mulByInt_y`), so the spec equation flips sign and uniqueness + gives the result. -/ +@@ -219,9 +213,9 @@ theorem omegaPullbackCoeff_mulByInt_neg (n : ℤ) (hn : n ≠ 0) : + congr 1 + exact (omegaPullbackCoeff_spec W (mulByInt W.toAffine n)).symm + +-/-- **RB-IND (Silverman III.5.3)**, integer form: `a_{[n]} = n` for all `n ≠ 0`, by the chord-step +-induction (positive `n`) and the negation symmetry (negative `n`). Reroutes +-`omegaPullbackCoeff_mulByInt` off the (still partial) EDS Wronskian. -/ ++/-- Silverman III.5.3 for all nonzero integers: `a_{[n]} = n`. ++Positive integers follow by the chord recurrence and negative integers by ++negation symmetry. -/ + theorem omegaPullbackCoeff_mulByInt_routeB (n : ℤ) (hn : n ≠ 0) : + omegaPullbackCoeff W (mulByInt W.toAffine n) = algebraMap K KE n := by + rcases lt_or_gt_of_ne hn with hneg | hpos +@@ -233,21 +227,17 @@ theorem omegaPullbackCoeff_mulByInt_routeB (n : ℤ) (hn : n ≠ 0) : + · -- n > 0: direct from the positive induction. + exact omegaPullbackCoeff_mulByInt_pos W n (by omega) + +-/-- **Pillar B endpoint (wronskian-free, formal-group-free)**: in characteristic `p`, `[p]*ω = 0`, +-i.e. `a_{[p]} = (p : K) = 0`. The axiom-clean Route B replacement for the formal-group +-`omegaPullbackCoeff_mulByInt_p_eq_zero_via_formalGroup` and the wronskian +-`omegaPullbackCoeff_mulByInt`. Direct from `omegaPullbackCoeff_mulByInt_routeB` +-+ `CharP.cast_eq_zero`. -/ ++/-- In characteristic `p`, multiplication by `p` has zero differential ++coefficient, since its coefficient is the image of `p` in the base field. -/ + theorem omegaPullbackCoeff_mulByInt_p_eq_zero_routeB (p : ℕ) [CharP K p] (hp : p ≠ 0) : + omegaPullbackCoeff W (mulByInt W.toAffine (p : ℤ)) = 0 := by + rw [omegaPullbackCoeff_mulByInt_routeB W (p : ℤ) (by exact_mod_cast hp), + show ((p : ℤ) : K) = 0 from by rw [Int.cast_natCast]; exact CharP.cast_eq_zero K p, map_zero] + +-/-- **Pillar B endpoint at `q = #K`** (`[q]*ω = 0`): over the finite field `K`, the ω-pullback +-coefficient of `[q]` vanishes, since `a_{[q]} = (q : K) = 0` (`#K = char^n`). Axiom-clean via +-`omegaPullbackCoeff_mulByInt_routeB`; this is the `q`-th-root input to the Verschiebung +-factorisation `[q] = V ∘ Frob`. -/ +-theorem omegaPullbackCoeff_mulByInt_card_eq_zero : ++/-- Over a finite field, multiplication by its cardinality has zero ++differential coefficient. This is the differential input to the Verschiebung ++factorization `[q] = V ∘ Frob`. -/ ++theorem omegaPullbackCoeff_mulByInt_card_eq_zero [Fintype K] : + omegaPullbackCoeff W (mulByInt W.toAffine (Fintype.card K : ℤ)) = 0 := by + rw [omegaPullbackCoeff_mulByInt_routeB W (Fintype.card K : ℤ) + (by exact_mod_cast Fintype.card_ne_zero), +diff --git a/projects/HasseWeil/HasseWeil/Foundation/OmegaPullbackCoeff.lean b/projects/HasseWeil/HasseWeil/Foundation/OmegaPullbackCoeff.lean +index 61150a90c..a51582216 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/OmegaPullbackCoeff.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/OmegaPullbackCoeff.lean +@@ -24,7 +24,7 @@ With `a_α ∈ F`: + - Additivity: `a_{α+β} = a_α + a_β` (from Silverman III.5.2) + - `a_{[n]} = n` (from Silverman III.5.3) + +-## Implementation ++## Kähler differential construction + + The pullback `α*(ω)` in the Kähler differential module Ω[K(E)/F] is computed as: + `α*(ω) = D(α*(x)) · α*(u)⁻¹` +@@ -98,11 +98,9 @@ theorem omegaPullbackCoeff_spec (α : Isogeny W.toAffine W.toAffine) : + (α.pullback + (algebraMap R KE (algebraMap (Polynomial F) R Polynomial.X))))).choose_spec + +--- Chain rule for `omegaPullbackCoeff`. The chain rule `a_{α∘β} = a_α · a_β` holds when `a_α` +--- is in the base field `F` (so that `β*(a_α) = a_α`); for the Silverman convention `a_α ∈ F` +--- always holds (Silverman III.5.5). It is proved abstractly as `omegaPullbackCoeff_comp_of_base` +--- in `HasseWeil/InvariantDifferentialPullback.lean`; not restated here to avoid a naming clash. +--- For `α = [n]` we get `a_{[n]} = n ∈ F`, which is what the Hasse bound needs. ++-- The chain rule `a_{α∘β} = a_α · a_β` holds when `a_α` lies in the base ++-- field, so that the pullback by `β` fixes it. For multiplication by `n`, the ++-- differential coefficient is `n`, as in Silverman III.5.3. + + /-- Uniqueness of the omega-based pullback coefficient: in the 1-dimensional Kähler module, + if `c₁ • ω = c₂ • ω` then `c₁ = c₂` (since `ω ≠ 0` and `KE` is a field). -/ +@@ -124,7 +122,7 @@ theorem mulByInt_pullback_x (n : ℤ) (hn : n ≠ 0) : + (mulByInt W.toAffine n).pullback + (algebraMap R KE (algebraMap (Polynomial F) R Polynomial.X)) = + mulByInt_x W n := by +- have hpb : (mulByInt W.toAffine n).pullback = mulByInt_pullbackAlgHom W n hn := dif_neg hn ++ have hpb : (mulByInt W.toAffine n).pullback = mulByInt_pullbackAlgHom W n hn := dite_eq_right hn + rw [hpb] + change mulByInt_pullbackRingHom W n hn + (algebraMap R KE (algebraMap (Polynomial F) R Polynomial.X)) = _ +@@ -140,7 +138,7 @@ theorem mulByInt_pullback_y (n : ℤ) (hn : n ≠ 0) : + (mulByInt W.toAffine n).pullback + (algebraMap R KE (AdjoinRoot.root W.toAffine.polynomial)) = + mulByInt_y W n := by +- have hpb : (mulByInt W.toAffine n).pullback = mulByInt_pullbackAlgHom W n hn := dif_neg hn ++ have hpb : (mulByInt W.toAffine n).pullback = mulByInt_pullbackAlgHom W n hn := dite_eq_right hn + rw [hpb] + change mulByInt_pullbackRingHom W n hn + (algebraMap R KE (AdjoinRoot.root W.toAffine.polynomial)) = _ +@@ -331,11 +329,6 @@ private lemma wronskian_X_mul_sub (f q : Polynomial F) : + simp [Polynomial.derivative_sub, Polynomial.derivative_mul, Polynomial.derivative_X] + ring + +--- The auxiliary ring identity `wronskian_aux_three` has been moved to +--- `HasseWeil/WronskianAux.lean` (together with `wronskian_aux_four`) to isolate +--- its expensive elaboration. It is reused unchanged from there. +- +--- Case m=3: proved via `wronskian_aux_three` from `HasseWeil/WronskianAux.lean`. + -- The key insight: both LHS and RHS factor through Ψ₃, and after cancellation + -- the identity reduces to wronskian_aux_three (a tractable ring computation). + omit [DecidableEq F] [W.toAffine.IsElliptic] in +@@ -371,10 +364,7 @@ private lemma wronskian_Φ_ΨSq_three : + + -- Silverman III.3.7 auxiliary: verified ring identity for m=4. + -- Only expands to b₂, b₄, b₆, b₈ (not a₁..a₆) keeping the ring computation tractable. +--- The auxiliary ring identity `wronskian_aux_four` has been moved to +--- `HasseWeil/WronskianAux.lean` to isolate its ~57 GB ring elaboration. + +--- Case m=4: proved via `wronskian_aux_four` from `HasseWeil/WronskianAux.lean`. + -- After applying wronskian_X_mul_sub to restructure the Wronskian, + -- and expanding preΨ(8) via preΨ_even(4)/preΨ_odd(2)/preΨ_even(3), + -- the goal matches wronskian_aux_four exactly (up to 1-simplification). +@@ -420,96 +410,6 @@ private lemma wronskian_Φ_ΨSq_four : + simp only [Polynomial.C_ofNat] at haux ⊢ + linear_combination haux + +-omit [DecidableEq F] [W.toAffine.IsElliptic] in +-/-- The polynomial Wronskian identity for non-negative integers, by **strong induction**. +- +- Base cases `m = 0,1,2` use direct computation; `m = 3,4` use the factored ring identities +- (`wronskian_aux_three`, `wronskian_aux_four`). For `m = n+5` the proof is by strong induction: +- the induction hypothesis `ih` provides the identity at **all** smaller indices `k < m`. +- +- ## Status of the `m ≥ 5` inductive step +- +- The inductive step is the elliptic-divisibility-sequence (EDS) Wronskian recursion. Writing +- `p k := W.preΨ k` and `s := W.Ψ₂Sq`, and `W(k) := Φ_k' ΨSq_k − Φ_k ΨSq_k'`, the target is +- `W(k) = k · p(2k)`. The two halving recursions that drive the induction are (both verified by +- computer algebra against the actual division polynomials): +- +- * **Even step.** `W(2m) = 2 · complEDS₂(2m) · W(m)`, where +- `complEDS₂(2m) = p(2m-1)² p(2m+2) − p(2m-2) p(2m+1)²`. Combined with the induction hypothesis +- `W(m) = m · p(2m)` and `p(4m) = complEDS₂(2m) · p(2m)` (mathlib's `preNormEDS_mul_complEDS₂`) +- this collapses to `W(2m) = 2m · p(4m)`, i.e. the claim at `2m`. Both `m` and `m±1 < 2m`. +- * **Odd step.** The analogous reduction of `W(2m+1)` to `W(m)` and `W(m+1)`. +- +- The irreducible algebraic content of *each* halving step is the **EDS addition formula** +- (Ward's relation), verified by CAS in the exact form +- `p(i+j) p(i-j) = Aᵢ · p(i+1) p(i-1) p(j)² − Aⱼ · p(j+1) p(j-1) p(i)²`, +- with `Aᵢ = s²` iff (`i` odd and `j` even) else `1`, and `Aⱼ = s²` iff (`i` even and `j` odd) +- else `1`. Its `j = 2` specialisation is the Somos‑4 relation +- `p(m+2) p(m-2) = (Even m ? 1 : s²) · p(m+1) p(m-1) − Ψ₃ · p(m)²`. +- +- The even step `W(2m) = 2·complEDS₂(2m)·W(m)` is **not** a free-ring identity in the consecutive +- `preΨ` values alone — it is provably *false* without further relations, and is *not* closed by +- Somos‑4 together with the Weierstrass `b`-relation either: it genuinely requires the addition +- formula at general index `j`. Mathlib does not currently provide the EDS addition formula +- (only the duplication recursions `preΨ_even`/`preΨ_odd`), so closing this step needs that +- formula to be developed first. The `WronskianAux` `m = 3,4` proofs avoid it only because, at +- fixed small index, the difference factors through the single `b`-relation with an explicitly +- computed multiplier; +- that multiplier grows with the index, so the same device does not generalise. +- +- An **axiom-clean** alternative is available downstream of this file via the function field: +- the field-general Route-B chord induction `omegaCoeff_mulByInt` +- (`HasseWeil/RouteBGeneral.lean`) proves the differential statement `[n]*ω = n·ω` +- (Silverman III.5.3) over any field, with no EDS Wronskian; it cannot be imported here (it +- depends transitively on this file), but every former geometric consumer of the Wronskian +- (`Hasse/Separability.lean`, `PullbackCoeff.lean`) now routes through it, so this `sorry` is +- **consumer-free**. The polynomial identity itself also has an axiom-clean downstream proof: +- `wronskian_Φ_ΨSq_general` (`EC/WronskianGeneral.lean`). -/ +-private lemma wronskian_Φ_ΨSq_nat (m : ℕ) : +- Polynomial.derivative (W.Φ (m : ℤ)) * W.ΨSq (m : ℤ) - +- W.Φ (m : ℤ) * Polynomial.derivative (W.ΨSq (m : ℤ)) = +- Polynomial.C ((m : ℤ) : F) * W.preΨ (2 * (m : ℤ)) := by +- induction m using Nat.strong_induction_on with +- | _ m ih => +- -- `ih : ∀ k < m, (the identity at k)` — the strong induction hypothesis. +- match m, ih with +- | 0, _ => exact wronskian_Φ_ΨSq_zero W +- | 1, _ => exact_mod_cast wronskian_Φ_ΨSq_one W +- | 2, _ => exact_mod_cast wronskian_Φ_ΨSq_two W +- | 3, _ => exact_mod_cast wronskian_Φ_ΨSq_three W +- | 4, _ => exact_mod_cast wronskian_Φ_ΨSq_four W +- | (n + 5), ih => +- -- General case `m = n+5 ≥ 5`. The induction hypothesis `ih k hk` gives the identity at +- -- every `k < n+5`, in particular at the halves `⌊(n+5)/2⌋`, `⌈(n+5)/2⌉` needed by the EDS +- -- Wronskian recursion (even/odd halving step). The single missing ingredient is the EDS +- -- addition formula (see the docstring above); supplying it closes this step via +- -- `linear_combination` of the induction hypothesis at the halves with the +- -- addition-formula / Somos‑4 instances. +- sorry +- +-omit [DecidableEq F] [W.toAffine.IsElliptic] in +-/-- The division polynomial Wronskian identity: +- `Φ_n' · ΨSq_n - Φ_n · ΨSq_n' = n · preΨ(2n)` as polynomials in `F[X]`. +- +- Reference: Silverman Exercise III.3.7. +- +- Proved by reducing to the natural number case via `wronskian_Φ_ΨSq_neg_of` +- (negation symmetry) and `wronskian_Φ_ΨSq_nat` (positive case by induction). -/ +-theorem wronskian_Φ_ΨSq (n : ℤ) : +- Polynomial.derivative (W.Φ n) * W.ΨSq n - W.Φ n * Polynomial.derivative (W.ΨSq n) = +- Polynomial.C (n : F) * W.preΨ (2 * n) := by +- rcases lt_or_ge n 0 with hneg | hpos +- · -- n < 0: use negation symmetry on the positive case +- have hm : (0 : ℤ) ≤ -n := by omega +- obtain ⟨m, hm_eq⟩ := Int.eq_ofNat_of_zero_le hm +- have hn_eq : n = -(m : ℤ) := by omega +- rw [hn_eq] +- exact wronskian_Φ_ΨSq_neg_of W (wronskian_Φ_ΨSq_nat W m) +- · -- n ≥ 0: directly from wronskian_Φ_ΨSq_nat +- obtain ⟨m, hm_eq⟩ := Int.eq_ofNat_of_zero_le hpos +- subst hm_eq +- exact wronskian_Φ_ΨSq_nat W m +- + omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `Φ_ff` and `ΨSq_ff` factor through `algebraMap (Polynomial F) KE`. -/ + private lemma Φ_ff_eq_algebraMap_poly (n : ℤ) : +@@ -527,7 +427,7 @@ private lemma ΨSq_ff_eq_algebraMap_poly (n : ℤ) : + This is the polynomial shadow of the third division polynomial `ω_n` and follows from the + geometric facts `preΨ(2n)·u = ψ_n·ψc_n` (i.e. `ψ_{2n} = ψ_n·ψc_n`, `ψc_spec_ff`) and + `α*(u) = ψc_n/ψ_n³` (`ω_spec_ff`), together with `ΨSq_ff = ψ_n²` (`ψ_ff_sq_eq`). It does **not** +- use the division-polynomial Wronskian, so it is axiom-clean and can be combined with the ++ use the division-polynomial Wronskian, and can be combined with the + chord-recursion `omegaPullbackCoeff_mulByInt_routeB` downstream to recover the polynomial + Wronskian. -/ + theorem preΨ_two_mul_u_eq_ΨSq_sq_mul_alpha_star_u (n : ℤ) (hn : n ≠ 0) : +@@ -543,7 +443,7 @@ theorem preΨ_two_mul_u_eq_ΨSq_sq_mul_alpha_star_u (n : ℤ) (hn : n ≠ 0) : + have h_preΨ_u : algebraMap (Polynomial F) KE (W.preΨ (2 * n)) * u_gen W = ψn * ψcn := by + rw [hψn_def, hψcn_def, ψc_spec_ff W n, Affine.CoordinateRing.mk_ψ (W := W.toAffine) (2 * n)] + have hΨ_eq : W.Ψ (2 * n) = Polynomial.C (W.preΨ (2 * n)) * W.ψ₂ := by +- rw [WeierstrassCurve.Ψ, if_pos (even_two_mul n)] ++ rw [WeierstrassCurve.Ψ, ite_eq_left (even_two_mul n)] + rw [hΨ_eq, map_mul, map_mul, + show W.ψ₂ = W.toAffine.polynomialY from rfl, mk_polynomialY_eq_u_gen W] + rfl +@@ -578,8 +478,7 @@ theorem preΨ_two_mul_u_eq_ΨSq_sq_mul_alpha_star_u (n : ℤ) (hn : n ≠ 0) : + - mk(polynomialY) = u_gen in K(E) + + Taking `hpoly` as a hypothesis lets specific values of `n` (e.g. `n = 2`) be +- discharged from the axiom-clean per-value polynomial lemmas +- (`wronskian_Φ_ΨSq_two`, …), independently of the general `wronskian_Φ_ΨSq`. ++ discharged from the per-value polynomial identities such as `wronskian_Φ_ΨSq_two`. + Reference: Silverman Exercise III.3.7, III.5.3 -/ + theorem divPoly_wronskian_identity_of_poly (n : ℤ) (hn : n ≠ 0) + (hpoly : Polynomial.derivative (W.Φ n) * W.ΨSq n - +@@ -618,7 +517,7 @@ theorem divPoly_wronskian_identity_of_poly (n : ℤ) (hn : n ≠ 0) + have h_preΨ_u : algebraMap (Polynomial F) KE (W.preΨ (2 * n)) * u_gen W = ψn * ψcn := by + rw [hψn_def, hψcn_def, ψc_spec_ff W n, Affine.CoordinateRing.mk_ψ (W := W.toAffine) (2 * n)] + have hΨ_eq : W.Ψ (2 * n) = Polynomial.C (W.preΨ (2 * n)) * W.ψ₂ := by +- rw [WeierstrassCurve.Ψ, if_pos (even_two_mul n)] ++ rw [WeierstrassCurve.Ψ, ite_eq_left (even_two_mul n)] + rw [hΨ_eq, map_mul, map_mul, + show W.ψ₂ = W.toAffine.polynomialY from rfl, mk_polynomialY_eq_u_gen W] + rfl +@@ -646,20 +545,6 @@ theorem divPoly_wronskian_identity_of_poly (n : ℤ) (hn : n ≠ 0) + h_preΨ_u, h_alpha_u, show ΨSq_ff W n = ψn ^ 2 from (ψ_ff_sq_eq W n).symm] + field_simp + +-/-- The division polynomial Wronskian identity in K(E) (general `n`), via the +- general polynomial-level identity `wronskian_Φ_ΨSq`. +- Reference: Silverman Exercise III.3.7, III.5.3 -/ +-theorem divPoly_wronskian_identity (n : ℤ) (hn : n ≠ 0) : +- (algebraMap (Polynomial F) KE (Polynomial.derivative (W.Φ n)) * +- ΨSq_ff W n - +- Φ_ff W n * +- algebraMap (Polynomial F) KE (Polynomial.derivative (W.ΨSq n))) * +- u_gen W = +- algebraMap F KE n * +- ΨSq_ff W n ^ 2 * +- alpha_star_u W (mulByInt W.toAffine n) := +- divPoly_wronskian_identity_of_poly W n hn (wronskian_Φ_ΨSq (W := W) n) +- + -- Chain rule for `D` on polynomial images in K(E), using `Derivation.comp_aeval_eq`: for + -- `p : F[X]` and `a ∈ KE`, `D(aeval a p) = aeval a (derivative p) • D(a)`. + +@@ -695,8 +580,7 @@ theorem D_poly_eval (p : Polynomial F) : + via the quotient rule and chain rule for the universal derivation. + + Taking `hpoly` as a hypothesis lets specific values of `n` be discharged from +- the axiom-clean per-value polynomial lemmas (`wronskian_Φ_ΨSq_two`, …), +- independently of the general `wronskian_Φ_ΨSq`. -/ ++ the per-value polynomial identities such as `wronskian_Φ_ΨSq_two`. -/ + theorem omegaPullbackCoeff_mulByInt_of_poly (n : ℤ) (hn : n ≠ 0) + (hpoly : Polynomial.derivative (W.Φ n) * W.ΨSq n - + W.Φ n * Polynomial.derivative (W.ΨSq n) = +@@ -768,7 +652,7 @@ theorem omegaPullbackCoeff_mulByInt_of_poly (n : ℤ) (hn : n ≠ 0) + + This is the converse of `omegaPullbackCoeff_mulByInt_of_poly`'s final algebra: the spec + `a • ω = α*(u)⁻¹ • D(α*x)` together with `a = n` and the chain/quotient rule for `D` gives the +- scalar identity `(Φ' Ψ − Φ Ψ') · u = n · Ψ² · α*u` in K(E). Fed the axiom-clean ++ scalar identity `(Φ' Ψ − Φ Ψ') · u = n · Ψ² · α*u` in K(E). Given the + `omegaPullbackCoeff_mulByInt_routeB` (downstream), it recovers the K(E) Wronskian — and then, + via the bridge `preΨ_two_mul_u_eq_ΨSq_sq_mul_alpha_star_u` and injectivity of + `algebraMap (Polynomial F) KE`, the **polynomial** Wronskian — without the EDS addition +@@ -843,30 +727,10 @@ theorem divPoly_wronskian_identity_of_omega (n : ℤ) (hn : n ≠ 0) + -- Goal is already in the `set` names `Φ, Ψ, Φ', Ψ', u, αu`; `hfin` matches up to symmetry. + linear_combination -hfin + +-/-- For [n], the omega-based pullback coefficient is n (general `n`, via the +- general polynomial-level Wronskian identity `wronskian_Φ_ΨSq`). +- Silverman III.5.3, IV.2.3. +- +- NOTE: this routing through `wronskian_Φ_ΨSq` inherits its `sorryAx` taint +- (the `m ≥ 5` branch of `wronskian_Φ_ΨSq_nat`). The **axiom-clean, field-general** +- proof of the same statement, via the Route-B chord recurrence (Silverman +- III.5.2/3 at the differential level), is `HasseWeil.omegaCoeff_mulByInt` in +- `HasseWeil/RouteBGeneral.lean`. That module cannot be imported here (its chord +- step lives downstream of this file), so the replacement cannot be applied in +- place — instead all former consumers (`Hasse/Separability.lean`, +- `PullbackCoeff.lean`) now route through `omegaCoeff_mulByInt`, leaving this +- theorem (and its Wronskian `sorry`) **consumer-free**. -/ +-theorem omegaPullbackCoeff_mulByInt (n : ℤ) (hn : n ≠ 0) : +- omegaPullbackCoeff W (mulByInt W.toAffine n) = algebraMap F KE n := +- omegaPullbackCoeff_mulByInt_of_poly W n hn (wronskian_Φ_ΨSq (W := W) n) +- +-/-- **Axiom-clean base case `[2]`**: `omegaPullbackCoeff W (mulByInt 2) = 2`. +- +- Uses the per-value polynomial Wronskian lemma `wronskian_Φ_ΨSq_two` (a direct +- `ring` computation, axiom-clean) through `omegaPullbackCoeff_mulByInt_of_poly`, +- so it does NOT depend on the general `wronskian_Φ_ΨSq` (whose `m ≥ 5` branch +- is unproved). Seeds the Route-B chord induction (`m ≥ 3` follows from the +- chord step `omegaPullbackCoeff_mulByInt_succ`). -/ ++/-- The differential coefficient of multiplication by two is two. ++ ++ The per-value polynomial identity `wronskian_Φ_ΨSq_two` gives the base case ++ for the differential chord recurrence. -/ + theorem omegaPullbackCoeff_mulByInt_two : + omegaPullbackCoeff W (mulByInt W.toAffine 2) = algebraMap F KE (2 : ℤ) := + omegaPullbackCoeff_mulByInt_of_poly W 2 (by norm_num) +diff --git a/projects/HasseWeil/HasseWeil/Foundation/OrdAtInftyBridge.lean b/projects/HasseWeil/HasseWeil/Foundation/OrdAtInftyBridge.lean +index 78be88908..b82e10035 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/OrdAtInftyBridge.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/OrdAtInftyBridge.lean +@@ -8,28 +8,13 @@ import HasseWeil.Foundation.OmegaPullbackCoeff + import HasseWeil.Foundation.Curves.Valuation.Infinity + + /-! +-# Bridge from `W.toAffine` to `SmoothPlaneCurve` for `ordAtInfty` ++# Orders at infinity of generic Weierstrass coordinates + +-This file provides the minimal bridge needed to apply worker-I's +-`ordAtInfty` infrastructure (in `HasseWeil/Curves/Infinity.lean`) to the +-generic-point framework used by `MulByIntPullback.lean` and +-`AdditionPullback.lean`. +- +-Concretely: given `W : WeierstrassCurve F` with `W.toAffine.IsElliptic`, +-we wrap `W.toAffine` as a `SmoothPlaneCurve F` and re-export the +-`ordAtInfty` results for `x_gen W` and `y_gen W` (and the +-basefield-algebraMap) in a directly usable form. +- +-The downstream consumer is the witness-parametric pole argument +-`addPullback_x_ne_const_of_pole` (`AdditionPullback.lean`), whose pole +-witnesses are supplied per-isogeny (e.g. in `AdditionPullback/Frobenius.lean`). +- +-## Main results +- +-* `W_smooth W : SmoothPlaneCurve F` — the bridge wrapper. +-* `ordAtInfty_x_gen` — `ord_∞(x_gen) = -2`. +-* `ordAtInfty_y_gen` — `ord_∞(y_gen) = -3`. +-* `ordAtInfty_algebraMap_F_nonzero` — constants from `F` have `ord_∞ = 0`. ++For an elliptic Weierstrass curve `W`, the generic coordinates have orders ++`ord_∞(x_gen W) = -2` and `ord_∞(y_gen W) = -3`. Nonzero base-field constants ++have order zero. Scalar-tower identities relate the division polynomials in ++the coordinate ring and function field, giving the pole orders of the ++multiplication-by-integer pullbacks, including the inseparable case. + + ## References + +@@ -45,19 +30,21 @@ variable (W : WeierstrassCurve F) [W.toAffine.IsElliptic] + + local notation "KE" => W.toAffine.FunctionField + +-/-- Wrap `W.toAffine` as a `SmoothPlaneCurve F` so that worker-I's +-`ordAtInfty` infrastructure applies. -/ ++/-- The smooth plane curve associated to the affine Weierstrass equation. -/ + noncomputable def W_smooth : SmoothPlaneCurve F := + ⟨W.toAffine⟩ + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- The affine curve underlying the `SmoothPlaneCurve` wrapper is `W`. -/ + @[simp] theorem W_smooth_toAffine : (W_smooth W).toAffine = W.toAffine := rfl + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- The function field of the SmoothPlaneCurve wrapper equals `KE` + definitionally (both are `W.toAffine.FunctionField`). -/ + @[simp] theorem W_smooth_functionField : + (W_smooth W).FunctionField = KE := rfl + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- The `coordX` of the wrapper matches our `x_gen W` at the function-field + level. Both are `algebraMap (Polynomial F) KE Polynomial.X`. -/ + theorem coordX_W_smooth_eq_x_gen : (W_smooth W).coordX = x_gen W := by +@@ -67,12 +54,14 @@ theorem coordX_W_smooth_eq_x_gen : (W_smooth W).coordX = x_gen W := by + rw [← IsScalarTower.algebraMap_apply (Polynomial F) W.toAffine.CoordinateRing KE] + rfl + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord_∞(x_gen W) = -2` — Silverman II.1 / IV.1 for the generic x. -/ + theorem ordAtInfty_x_gen : + (W_smooth W).ordAtInfty (x_gen W) = ((-2 : ℤ) : WithTop ℤ) := by + rw [← coordX_W_smooth_eq_x_gen] + exact (W_smooth W).ordAtInfty_coordX + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- The `coordY` of the wrapper matches our `y_gen W` at the function-field + level. Both are the image of `AdjoinRoot.root W.polynomial` under the + algebraMap to `KE`. The `basis_one` lemma identifies +@@ -82,12 +71,14 @@ theorem coordY_W_smooth_eq_y_gen : (W_smooth W).coordY = y_gen W := by + rw [Affine.CoordinateRing.basis_one] + rfl + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord_∞(y_gen W) = -3` — Silverman II.1 / IV.1 for the generic y. -/ + theorem ordAtInfty_y_gen : + (W_smooth W).ordAtInfty (y_gen W) = ((-3 : ℤ) : WithTop ℤ) := by + rw [← coordY_W_smooth_eq_y_gen] + exact (W_smooth W).ordAtInfty_coordY + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord_∞(algebraMap F KE c) = 0` for nonzero `c : F`. Direct corollary of + `SmoothPlaneCurve.ordAtInfty_algebraMap_F_nonzero` applied to `W_smooth W`. -/ + theorem ordAtInfty_algebraMap_F_nonzero {c : F} (hc : c ≠ 0) : +@@ -96,9 +87,7 @@ theorem ordAtInfty_algebraMap_F_nonzero {c : F} (hc : c ≠ 0) : + + /-! ### Powers of generators -/ + +-/- `x_gen_ne_zero` / `y_gen_ne_zero` HOISTED to `Foundation/MulByIntPullback.lean` next to +-the defs (#7621) — they were declared BOTH here and in `LocalExpansion.lean` (same names, +-same namespace), so no module could import both files without an environment clash. -/ ++ + + omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `y_gen W` and `(W_smooth W).coordYInFunctionField` are the same element of +@@ -110,12 +99,13 @@ theorem y_gen_eq_coordYInFunctionField : + /-- `mulByInt_y W n ≠ 0` for `n ≠ 0`: it is the image of `y_gen ≠ 0` under the + field embedding `[n]^*`. -/ + theorem mulByInt_y_ne_zero (n : ℤ) (hn : n ≠ 0) : mulByInt_y W n ≠ 0 := by +- have hpb : (mulByInt W.toAffine n).pullback = mulByInt_pullbackAlgHom W n hn := dif_neg hn ++ have hpb : (mulByInt W.toAffine n).pullback = mulByInt_pullbackAlgHom W n hn := dite_eq_right hn + have h : mulByInt_pullbackAlgHom W n hn (y_gen W) = mulByInt_y W n := + hpb ▸ mulByInt_pullback_y W n hn + rw [← h] + exact (map_ne_zero (mulByInt_pullbackAlgHom W n hn)).mpr (y_gen_ne_zero W) + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord_∞(x_gen^n) = n • (-2)`. -/ + theorem ordAtInfty_x_gen_pow (n : ℕ) : + (W_smooth W).ordAtInfty (x_gen W ^ n) = n • ((-2 : ℤ) : WithTop ℤ) := by +@@ -124,6 +114,7 @@ theorem ordAtInfty_x_gen_pow (n : ℕ) : + rw [ordAtInfty_x_gen] at h + exact h + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord_∞(y_gen^n) = n • (-3)`. -/ + theorem ordAtInfty_y_gen_pow (n : ℕ) : + (W_smooth W).ordAtInfty (y_gen W ^ n) = n • ((-3 : ℤ) : WithTop ℤ) := by +@@ -140,6 +131,7 @@ Both `Φ_ff W n` and `ΨSq_ff W n` are defined as + This bridges to `ordAtInfty_algebraMap_polynomial_of_ne_zero` for the + ord computation. -/ + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `Φ_ff W n = algebraMap (Polynomial F) KE (W.Φ n)` via the scalar tower + `F[X] → CoordinateRing → FunctionField`. -/ + theorem Φ_ff_eq_algebraMap_polynomial (n : ℤ) : +@@ -147,6 +139,7 @@ theorem Φ_ff_eq_algebraMap_polynomial (n : ℤ) : + (IsScalarTower.algebraMap_apply + (Polynomial F) W.toAffine.CoordinateRing KE (W.Φ n)).symm + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ΨSq_ff W n = algebraMap (Polynomial F) KE (W.ΨSq n)` via the scalar tower + `F[X] → CoordinateRing → FunctionField`. -/ + theorem ΨSq_ff_eq_algebraMap_polynomial (n : ℤ) : +@@ -159,6 +152,7 @@ theorem ΨSq_ff_eq_algebraMap_polynomial (n : ℤ) : + Direct from the tower bridge + `ordAtInfty_algebraMap_polynomial_of_ne_zero` + + mathlib's `natDegree_Φ` / `natDegree_ΨSq`. -/ + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord_∞(Φ_ff W n) = -2 · n.natAbs²`. -/ + theorem ordAtInfty_Φ_ff (n : ℤ) : + (W_smooth W).ordAtInfty (Φ_ff W n) = +@@ -171,6 +165,7 @@ theorem ordAtInfty_Φ_ff (n : ℤ) : + push_cast + ring_nf + ++omit [DecidableEq F] [W.toAffine.IsElliptic] in + /-- `ord_∞(ΨSq_ff W n) = -2 · (n.natAbs² - 1)` for `(n : F) ≠ 0`. -/ + theorem ordAtInfty_ΨSq_ff (n : ℤ) (hnF : (n : F) ≠ 0) : + (W_smooth W).ordAtInfty (ΨSq_ff W n) = +@@ -203,6 +198,7 @@ private theorem algebraMap_polynomial_KE_injective : + Affine.CoordinateRing.algebraMap_poly_injective + + omit [DecidableEq F] in ++omit [W.toAffine.IsElliptic] in + /-- `Φ_ff W n ≠ 0` for any n. Direct from `W.Φ_ne_zero` + algebraMap injectivity. -/ + theorem Φ_ff_ne_zero (n : ℤ) : Φ_ff W n ≠ 0 := by + classical +@@ -211,12 +207,14 @@ theorem Φ_ff_ne_zero (n : ℤ) : Φ_ff W n ≠ 0 := by + exact W.Φ_ne_zero n + (algebraMap_polynomial_KE_injective W (h.trans (map_zero _).symm)) + ++omit [DecidableEq F] in + /-- `mulByInt_x W n ≠ 0` for `n ≠ 0`. Direct from `Φ_ff_ne_zero` and + `ΨSq_ff_ne_zero`. -/ + theorem mulByInt_x_ne_zero (n : ℤ) (hn : n ≠ 0) : mulByInt_x W n ≠ 0 := by + simp only [mulByInt_x] + exact div_ne_zero (Φ_ff_ne_zero W n) (ΨSq_ff_ne_zero W hn) + ++omit [DecidableEq F] in + /-- `ord_∞(mulByInt_x W n) = -2` for `n ≠ 0` and `(n : F) ≠ 0`. + + Direct from `ordAtInfty_Φ_ff`, `ordAtInfty_ΨSq_ff`, and division: the +@@ -250,6 +248,7 @@ theorem ordAtInfty_mulByInt_x (n : ℤ) (hn : n ≠ 0) (hnF : (n : F) ≠ 0) : + congr 1 + ring] + ++omit [DecidableEq F] in + /-- **Unconditional pole of `mulByInt_x W n`**: `ord_∞(mulByInt_x W n) < 0` for + every `n ≠ 0`, with **no** `(n : F) ≠ 0` hypothesis. + +@@ -262,8 +261,7 @@ numerator therefore strictly out-degrees the denominator, so the ratio + `Φ_ff / ΨSq_ff` has a pole at `O`: + `ord = -2·natAbs² - (-2·natDegree (ΨSq n)) ≤ -2·natAbs² + 2(natAbs² - 1) = -2 < 0`. + +-This is exactly the brick needed for the V-side "summand reduces to `O`" facts, +-where the Frobenius factor `r·q` lands in the inseparable regime. -/ ++-/ + theorem ordAtInfty_mulByInt_x_neg (n : ℤ) (hn : n ≠ 0) : + (W_smooth W).ordAtInfty (mulByInt_x W n) < 0 := by + classical +@@ -304,6 +302,7 @@ theorem ordAtInfty_mulByInt_x_neg (n : ℤ) (hn : n ≠ 0) : + -- Transport `h_int` across the `WithTop ℤ` coercions. + exact_mod_cast h_int + ++omit [DecidableEq F] in + /-- **`ord_∞(mulByInt_x W n)` is an explicit even value `≤ -2`** for every `n ≠ 0`, with **no** + `(n : F) ≠ 0` hypothesis — so it holds in the *inseparable* case `(n : F) = 0` (e.g. `n = r` with + `p ∣ r`). +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Ramification.lean b/projects/HasseWeil/HasseWeil/Foundation/Ramification.lean +index 8a1dfaa9c..d72959809 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Ramification.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Ramification.lean +@@ -6,7 +6,9 @@ Authors: Chris Birkbeck + import Mathlib.Algebra.Polynomial.SpecificDegree + import Mathlib.FieldTheory.IntermediateField.Algebraic + import Mathlib.FieldTheory.SeparableDegree +-import Mathlib.NumberTheory.RamificationInertia.Basic ++import Mathlib.RingTheory.RamificationInertia.Basic ++import Mathlib.NumberTheory.RamificationInertia.Inertia ++import Mathlib.NumberTheory.RamificationInertia.Ramification + import Mathlib.RingTheory.Algebraic.Integral + import Mathlib.RingTheory.Artinian.Ring + import Mathlib.RingTheory.DedekindDomain.Basic +@@ -25,61 +27,6 @@ import Mathlib.RingTheory.Polynomial.GaussLemma + import HasseWeil.Isogeny.FunctionField + import HasseWeil.Foundation.Valuation + +-/-! +-# Ramification Theory for Elliptic Curve Isogenies +- +-We connect mathlib's `Ideal.ramificationIdx'` and `Ideal.inertiaDeg'` to the +-theory of elliptic curve isogenies, specializing the general framework from +-`Mathlib.NumberTheory.RamificationInertia` to coordinate ring extensions. +- +-For an isogeny `φ : E₁ → E₂`, the pullback `φ* : K(E₂) →ₐ[F] K(E₁)` restricts to +-a ring homomorphism on coordinate rings. The ramification index `e_P(φ)` at a +-prime `P` of `R₁ = K[E₁]` is `Ideal.ramificationIdx' (φ*.restrict) p P` where +-`p = φ*⁻¹(P)` is the prime of `R₂ = K[E₂]` below `P`. +- +-## Main results +- +-* `HasseWeil.coordinateRing_isDedekindDomain`: the coordinate ring of an elliptic curve +- is a Dedekind domain. Proved via `IsIntegralClosure.isDedekindDomain`: the coordinate +- ring `R = F[X][Y]/(W)` is the integral closure of the PID `F[X]` in the function field +- `K(E) = Frac(R)`, and `K(E)/F(X)` is a finite separable extension of degree 2. +-* `HasseWeil.coordinateRing_isIntegrallyClosed`: the coordinate ring is integrally closed +- in its fraction field, via `IsIntegrallyClosed.of_localization_maximal` together with +- principality of the maximal ideal at every localization. +-* `HasseWeil.coordinateRing_dimensionLEOne`: the coordinate ring has Krull dimension at +- most 1 (every nonzero prime is maximal), from the principal ideal theorem. +- +-## Strategy +- +-The `IsIntegralClosure.isDedekindDomain` route shows that `CoordinateRing` is the integral +-closure of the PID `F[X]` in the function field. The key steps: +- +-1. **`F[X]` is Dedekind**: it is a PID, hence Dedekind (automatic from mathlib). +-2. **`CoordinateRing` is integrally closed**: via `IsIntegrallyClosed.of_localization_maximal`, +- each localization at a nonzero maximal ideal `P` is a DVR (hence integrally closed). The +- DVR property follows from the TFAE for Noetherian local domains of dimension `≤ 1` with a +- principal maximal ideal; principality (`maximalIdeal_isPrincipal_of_nonsingular`) uses +- nonsingularity at each closed point (`Δ ≠ 0`), via the Jacobian identity and a case split +- on the characteristic. +-3. **`CoordinateRing` is the integral closure of `F[X]` in `FunctionField`**: elements +- integral over `F[X]` are integral over `CoordinateRing` (by `tower_top`), hence lie in +- `CoordinateRing` (by step 2 and `isIntegrallyClosed_iff`). +-4. **`FunctionField / FractionRing(F[X])` is finite** of degree 2. +-5. **`FunctionField / FractionRing(F[X])` is separable**: from `finSepDegree` dividing 2 and +- the existence of a separable root (the Weierstrass polynomial has nonzero Y-derivative). +-6. **Apply `IsIntegralClosure.isDedekindDomain`**: combines all the above. +- +-## Implementation notes +- +-This file is open infrastructure for the full isogeny ramification theory (the degree-sum +-formula `deg φ = Σ e_P · f_P`, unramifiedness of separable isogenies, and equal fibre sizes +-from translation invariance are not yet formalised here). The Dedekind-domain results it +-provides are complete and axiom-clean. +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], II.2, III.4.10 +--/ + + open WeierstrassCurve Polynomial Ideal IntermediateField + open scoped Polynomial.Bivariate nonZeroDivisors IntermediateField +@@ -157,8 +104,8 @@ private lemma nonsingular_at_maximal (E : Affine F) [E.IsElliptic] + (P : Ideal E.CoordinateRing) (hPmax : P.IsMaximal) : + AdjoinRoot.mk E.polynomial E.polynomialX ∉ P ∨ + AdjoinRoot.mk E.polynomial E.polynomialY ∉ P := by +- letI : P.IsPrime := hPmax.isPrime +- haveI : Field (E.CoordinateRing ⧸ P) := Ideal.Quotient.field P ++ let : P.IsPrime := hPmax.isPrime ++ have : Field (E.CoordinateRing ⧸ P) := Ideal.Quotient.field P + let φ : F →+* (E.CoordinateRing ⧸ P) := + (Ideal.Quotient.mk P).comp ((AdjoinRoot.of E.polynomial).comp C) + let x₀ := (Ideal.Quotient.mk P) (AdjoinRoot.mk E.polynomial (C X)) +@@ -178,8 +125,8 @@ private lemma nonsingular_at_maximal (E : Affine F) [E.IsElliptic] + exact Ideal.Quotient.eq_zero_iff_mem.mpr hmem) + + -- The mathlib `Algebra (Polynomial F) E.CoordinateRing` instance is `noncomputable`, so the +--- synthesizer cannot derive `Module` within `maxSynthPendingDepth = 3`. These explicit `Module`, +--- `Module.Finite`, and `Module.IsTorsionFree` instances let downstream synthesis find them. ++ ++ + noncomputable instance instModulePolynomialCoordinateRing (E : Affine F) : + Module (Polynomial F) E.CoordinateRing := + @Algebra.toModule _ _ _ _ (Affine.CoordinateRing.instAlgebraPolynomial) +@@ -190,7 +137,7 @@ noncomputable instance instModuleFinitePolynomialCoordinateRing (E : Affine F) : + + noncomputable instance instIsTorsionFreePolynomialCoordinateRing (E : Affine F) [E.IsElliptic] : + Module.IsTorsionFree (Polynomial F) E.CoordinateRing := +- @AdjoinRoot.noZeroSMulDivisors_of_prime_of_degree_ne_zero (Polynomial F) _ E.polynomial _ ++ @AdjoinRoot.isTorsionFree_of_prime_of_degree_ne_zero (Polynomial F) _ E.polynomial _ + (Irreducible.prime Affine.irreducible_polynomial) + (by rw [Affine.degree_polynomial]; exact two_ne_zero) + +@@ -455,11 +402,11 @@ private lemma isReduced_quotient_of_polyY_notMem (E : Affine F) [E.IsElliptic] + (P.comap (algebraMap (Polynomial F) E.CoordinateRing))) + rw [h_rad.radical] at h; exact h ▸ Ideal.radical_isRadical _ + rw [Ideal.isRadical_iff_quotient_reduced] +- haveI : (P.comap (algebraMap (Polynomial F) E.CoordinateRing)).IsMaximal := ++ have : (P.comap (algebraMap (Polynomial F) E.CoordinateRing)).IsMaximal := + Ideal.IsPrime.isMaximal (Ideal.IsPrime.comap _) hp_ne_bot + set p := P.comap (algebraMap (Polynomial F) E.CoordinateRing) with hp_def +- letI kfield : Field (F[X] ⧸ p) := Ideal.Quotient.field p +- haveI : IsDomain (F[X] ⧸ p) := kfield.isDomain ++ let kfield : Field (F[X] ⧸ p) := Ideal.Quotient.field p ++ have : IsDomain (F[X] ⧸ p) := kfield.isDomain + set φ : F[X] →+* (F[X] ⧸ p) := Ideal.Quotient.mk p with hφ_def + set Wbar := E.polynomial.map φ with hWbar_def + have hequiv := AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot p E.polynomial +@@ -485,11 +432,11 @@ private theorem maximalIdeal_isPrincipal_case_polyY_notMem (E : Affine F) [E.IsE + (P : Ideal E.CoordinateRing) (hPbot : P ≠ ⊥) (hPmax : P.IsMaximal) + (hY : AdjoinRoot.mk E.polynomial E.polynomialY ∉ P) : + (Ideal.map (algebraMap E.CoordinateRing (Localization.AtPrime P)) P).IsPrincipal := by +- letI := hPmax.isPrime +- haveI := IsLocalization.isNoetherianRing P.primeCompl (Localization.AtPrime P) inferInstance ++ let := hPmax.isPrime ++ have := IsLocalization.isNoetherianRing P.primeCompl (Localization.AtPrime P) inferInstance + set g := algebraMap (Polynomial F) E.CoordinateRing with hg_def + set p := P.comap g with hp_def +- haveI : Algebra.IsIntegral (Polynomial F) E.CoordinateRing := ++ have : Algebra.IsIntegral (Polynomial F) E.CoordinateRing := + Algebra.IsIntegral.of_finite (Polynomial F) E.CoordinateRing + suffices h : Ideal.map (algebraMap E.CoordinateRing (Localization.AtPrime P)) P = + Ideal.map (algebraMap E.CoordinateRing (Localization.AtPrime P)) (Ideal.map g p) by +@@ -502,7 +449,7 @@ private theorem maximalIdeal_isPrincipal_case_polyY_notMem (E : Affine F) [E.IsE + have hg_inj : Function.Injective g := coordinateRing_algebraMap_injective E + have hp_ne_bot : p ≠ ⊥ := by + intro hp_bot; rw [hp_def] at hp_bot +- exact hPbot (eq_bot_of_comap_eq_bot hp_bot) ++ exact hPbot (eq_bot_of_under_eq_bot (R := Polynomial F) hp_bot) + have hJ_ne_top : J ≠ ⊤ := by + intro hJ_top + have : Ideal.map f P = ⊤ := +@@ -510,16 +457,16 @@ private theorem maximalIdeal_isPrincipal_case_polyY_notMem (E : Affine F) [E.IsE + rw [Localization.AtPrime.map_eq_maximalIdeal] at this + exact (IsLocalRing.maximalIdeal.isMaximal + (R := Localization.AtPrime P)).ne_top this +- haveI : Nontrivial (Localization.AtPrime P ⧸ J) := ++ have : Nontrivial (Localization.AtPrime P ⧸ J) := + Ideal.Quotient.nontrivial_iff.mpr hJ_ne_top +- haveI : IsLocalRing (Localization.AtPrime P ⧸ J) := ++ have : IsLocalRing (Localization.AtPrime P ⧸ J) := + IsLocalRing.of_surjective' (Ideal.Quotient.mk J) Ideal.Quotient.mk_surjective +- haveI : Ring.DimensionLEOne (Localization.AtPrime P) := ++ have : Ring.DimensionLEOne (Localization.AtPrime P) := + Ring.DimensionLEOne.localization (Localization.AtPrime P) + P.primeCompl_le_nonZeroDivisors +- haveI : Ring.KrullDimLE 0 (Localization.AtPrime P ⧸ J) := ++ have : Ring.KrullDimLE 0 (Localization.AtPrime P ⧸ J) := + krullDimLE_zero_quotient_of_polyY_notMem E P J g hg_inj p hp_ne_bot hJ_def +- haveI : IsReduced (Localization.AtPrime P ⧸ J) := ++ have : IsReduced (Localization.AtPrime P ⧸ J) := + isReduced_quotient_of_polyY_notMem E P J g hg_def p hp_def hp_ne_bot hY hJ_def + exact @Ring.KrullDimLE.isField_of_isReduced _ _ ‹_› ‹_› ‹_› + · -- `J ≤ P.map f` follows from `p.map g ≤ P` (`map_comap_le`). +@@ -584,8 +531,8 @@ private lemma YminusAlpha_sq_mem_of_char2_square (E : Affine F) [E.IsElliptic] + (h_cubic_factor : X ^ 3 + C E.a₂ * X ^ 2 + C E.a₄ * X + C E.a₆ - C δ = (X - C x₀) * w₃) + (hα : α ^ 2 = δ) : + (AdjoinRoot.mk E.polynomial (Y - C (C α))) ^ 2 ∈ P := by +- haveI hCharP_FX : CharP F[X] 2 := Polynomial.charP +- haveI hCharP_FXY : CharP F[X][Y] 2 := Polynomial.charP ++ have hCharP_FX : CharP F[X] 2 := Polynomial.charP ++ have hCharP_FXY : CharP F[X][Y] 2 := Polynomial.charP + have h_two_FX : (2 : F[X]) = 0 := by exact_mod_cast CharP.cast_eq_zero F[X] 2 + have h_two_FXY : (2 : F[X][Y]) = 0 := by exact_mod_cast CharP.cast_eq_zero F[X][Y] 2 + have h_step : (AdjoinRoot.mk E.polynomial (Y - C (C α))) ^ 2 = +@@ -649,7 +596,7 @@ private theorem maximalIdeal_isPrincipal_case_char2_ordinary_square (E : Affine + (h_cubic_factor : X ^ 3 + C E.a₂ * X ^ 2 + C E.a₄ * X + C E.a₆ - C δ = (X - C x₀) * w₃) + (hα : α ^ 2 = δ) : + (Ideal.map (algebraMap E.CoordinateRing (Localization.AtPrime P)) P).IsPrincipal := by +- letI := hPmax.isPrime ++ let := hPmax.isPrime + -- `(x₀, α)` satisfies `E.Equation` (α² + (a₁x₀+a₃)α = δ = α²) and is smooth (`Δ ≠ 0`). + have h_eq : E.Equation x₀ α := by + rw [Affine.equation_iff] +@@ -674,7 +621,7 @@ private theorem maximalIdeal_isPrincipal_case_char2_ordinary_square (E : Affine + have h_P_eq : P = pointIdeal E x₀ α := + (Ideal.IsMaximal.eq_of_le (pointIdeal_isMaximal E h_ns) hPmax.ne_top h_pointIdeal_le).symm + subst h_P_eq +- haveI : IsDiscreteValuationRing (Localization.AtPrime (pointIdeal E x₀ α)) := ++ have : IsDiscreteValuationRing (Localization.AtPrime (pointIdeal E x₀ α)) := + HasseWeil.localRing_isDVR E h_ns + rw [Localization.AtPrime.map_eq_maximalIdeal] + exact IsDiscreteValuationRing.toIsPrincipalIdealRing.principal _ +@@ -931,10 +878,10 @@ private theorem maximalIdeal_isPrincipal_case_char2_ordinary_nonsquare + (hc_in_p : c ∈ P.comap (algebraMap (Polynomial F) E.CoordinateRing)) + (h_sq : ∀ α : F, α ^ 2 ≠ δ) : + (Ideal.map (algebraMap E.CoordinateRing (Localization.AtPrime P)) P).IsPrincipal := by +- letI := hPmax.isPrime +- -- `f_quad = X² + C δ` is irreducible (δ not a square); build `proj = lift i_hom (root f_quad)`. ++ let := hPmax.isPrime ++ + set f_quad : Polynomial F := (Polynomial.X : Polynomial F) ^ 2 + Polynomial.C δ with hf_quad_def +- haveI hFact : Fact (Irreducible f_quad) := ++ have hFact : Fact (Irreducible f_quad) := + ⟨X_sq_add_C_irreducible_of_not_square δ h2 h_sq⟩ + set i_hom : F[X] →+* AdjoinRoot f_quad := + (AdjoinRoot.of f_quad).comp (Polynomial.evalRingHom x₀) with hi_hom_def +@@ -985,7 +932,7 @@ private lemma comap_eq_span_c_of_char2_ordinary (E : Affine F) [E.IsElliptic] + exact h_a1 h_coeff_1.symm + have hp_ne_bot : p ≠ ⊥ := fun hbot ↦ hc_ne_zero (by + rw [hbot, Ideal.mem_bot] at hc_in_p; exact hc_in_p) +- haveI : p.IsMaximal := Ring.DimensionLEOne.maximalOfPrime hp_ne_bot (Ideal.IsPrime.comap _) ++ have : p.IsMaximal := Ring.DimensionLEOne.maximalOfPrime hp_ne_bot (Ideal.IsPrime.comap _) + exact maximal_eq_span_of_mem_linear p (IsPrincipalIdealRing.principal p) c hc_ne_zero + (by rw [hc_def]; exact Polynomial.natDegree_linear h_a1) hc_in_p + +@@ -1032,9 +979,9 @@ private theorem maximalIdeal_isPrincipal_case_char2_ordinary (E : Affine F) [E.I + (h4 : (4 : F) = 0) (h_a1 : E.a₁ ≠ 0) + (hY : AdjoinRoot.mk E.polynomial E.polynomialY ∈ P) : + (Ideal.map (algebraMap E.CoordinateRing (Localization.AtPrime P)) P).IsPrincipal := by +- letI := hPmax.isPrime ++ let := hPmax.isPrime + have h2 : (2 : F) = 0 := two_eq_zero_of_four_eq_zero h4 +- haveI hCharP : CharP F 2 := ++ have hCharP : CharP F 2 := + (CharP.charP_iff_prime_eq_zero Nat.prime_two).mpr h2 + -- `polyY = C c` with `c = a₁X + a₃`, so `c ∈ p`, and `p = span {c}`. + set c : F[X] := C E.a₁ * X + C E.a₃ with hc_def +@@ -1088,7 +1035,7 @@ private theorem polynomialY_notMem_of_char2_a1_eq_zero (E : Affine F) [E.IsEllip + have h2sq_eq : (2 : F) ^ 2 = 4 := by ring + rw [h2sq_eq]; exact h4 + exact pow_eq_zero_iff (by omega : 2 ≠ 0) |>.mp h2sq +- haveI hCharP : CharP F 2 := ++ have hCharP : CharP F 2 := + (CharP.charP_iff_prime_eq_zero Nat.prime_two).mpr h2 + have hΔ : E.Δ ≠ 0 := fun h ↦ not_isUnit_zero (h ▸ IsElliptic.isUnit (W := E)) + have ha3_ne : E.a₃ ≠ 0 := by +@@ -1256,14 +1203,14 @@ private theorem maximalIdeal_isPrincipal_case_charNe2 (E : Affine F) [E.IsEllipt + (hY : AdjoinRoot.mk E.polynomial E.polynomialY ∈ P) + (hX : AdjoinRoot.mk E.polynomial E.polynomialX ∉ P) : + (Ideal.map (algebraMap E.CoordinateRing (Localization.AtPrime P)) P).IsPrincipal := by +- letI := hPmax.isPrime ++ let := hPmax.isPrime + set g := algebraMap (Polynomial F) E.CoordinateRing with hg_def + set p := P.comap g with hp_def + set f := algebraMap E.CoordinateRing (Localization.AtPrime P) with hf_def +- have hp_ne_bot : p ≠ ⊥ := fun hp_bot ↦ hPbot (eq_bot_of_comap_eq_bot hp_bot) +- haveI hp_maximal : p.IsMaximal := ++ have hp_ne_bot : p ≠ ⊥ := fun hp_bot ↦ hPbot (eq_bot_of_under_eq_bot (R := Polynomial F) hp_bot) ++ have hp_maximal : p.IsMaximal := + Ring.DimensionLEOne.maximalOfPrime hp_ne_bot (Ideal.IsPrime.comap _) +- haveI hp_principal : p.IsPrincipal := IsPrincipalIdealRing.principal p ++ have hp_principal : p.IsPrincipal := IsPrincipalIdealRing.principal p + have h2 : (2 : F) ≠ 0 := fun h2zero ↦ h4 (by + have : (4 : F) = 2 * 2 := by norm_num + rw [this, h2zero]; ring) +@@ -1302,15 +1249,15 @@ private theorem maximalIdeal_isPrincipal_case_charNe2 (E : Affine F) [E.IsEllipt + rw [map_eq_span_of_charNe2 E P π hY hmkCπ_in_span hP_le_span] + exact ⟨⟨_, rfl⟩⟩ + +--- Reduces to a clean case-dispatch over the closed-point geometry: each branch is a leaf lemma ++ + -- above (`..._case_polyY_notMem`, char-2 supersingular/ordinary, char-≠2 Jacobian). + private theorem maximalIdeal_isPrincipal_of_nonsingular (E : Affine F) [E.IsElliptic] + (P : Ideal E.CoordinateRing) (_ : P ≠ ⊥) (hPmax : P.IsMaximal) : + (IsLocalRing.maximalIdeal (Localization.AtPrime P)).IsPrincipal := by +- letI := hPmax.isPrime ++ let := hPmax.isPrime + -- The maximal ideal `m = P.map f` (`f = algebraMap R R_P`); reduce to principality of `P.map f`. + rw [← Localization.AtPrime.map_eq_maximalIdeal] +- -- Dispatch on the closed-point geometry. Each leaf lemma handles one configuration. ++ + by_cases hY : AdjoinRoot.mk E.polynomial E.polynomialY ∉ P + · -- `mk(polynomialY) ∉ P`: the squarefree-quotient leaf lemma. + exact maximalIdeal_isPrincipal_case_polyY_notMem E P ‹P ≠ ⊥› hPmax hY +@@ -1325,21 +1272,21 @@ private theorem maximalIdeal_isPrincipal_of_nonsingular (E : Affine F) [E.IsElli + · -- Char ≠ 2: Jacobian factorisation of the Y-discriminant. + exact maximalIdeal_isPrincipal_case_charNe2 E P ‹P ≠ ⊥› hPmax h4 hY hX + +-/-- The coordinate ring of an elliptic curve is integrally closed in its fraction field. -/ ++ + instance coordinateRing_isIntegrallyClosed (E : Affine F) [E.IsElliptic] : + IsIntegrallyClosed E.CoordinateRing := by + apply IsIntegrallyClosed.of_localization_maximal + intro P hP0 hPmax +- haveI := IsLocalization.isNoetherianRing P.primeCompl (Localization.AtPrime P) inferInstance +- haveI : Ring.DimensionLEOne (Localization.AtPrime P) := ++ have := IsLocalization.isNoetherianRing P.primeCompl (Localization.AtPrime P) inferInstance ++ have : Ring.DimensionLEOne (Localization.AtPrime P) := + Ring.DimensionLEOne.localization (Localization.AtPrime P) P.primeCompl_le_nonZeroDivisors +- haveI : IsPrincipalIdealRing (Localization.AtPrime P) := ++ have : IsPrincipalIdealRing (Localization.AtPrime P) := + ((tfae_of_isNoetherianRing_of_isLocalRing_of_isDomain + (Localization.AtPrime P)).out 5 1).mp + (maximalIdeal_isPrincipal_of_nonsingular E P hP0 hPmax) + exact UniqueFactorizationMonoid.instIsIntegrallyClosed + +--- Typeclass synthesis over the tower F[X] → CoordinateRing → FunctionField needs more budget. ++ + noncomputable instance coordinateRing_isIntegralClosure (E : Affine F) [E.IsElliptic] : + IsIntegralClosure E.CoordinateRing (Polynomial F) E.FunctionField where + algebraMap_injective _ _ h := +@@ -1385,24 +1332,24 @@ private theorem root_aeval_polynomial_map (E : Affine F) [E.IsElliptic] : + simp [IsScalarTower.algebraMap_apply (Polynomial F) E.CoordinateRing E.FunctionField] } + + -- The separability proof reasons over two cases via finSepDegree; typeclass +--- synthesis for the tower through FractionRing F[X] needs more budget. ++ + noncomputable instance functionField_isSeparable (E : Affine F) [E.IsElliptic] : + Algebra.IsSeparable (FractionRing (Polynomial F)) E.FunctionField := by + set K := FractionRing (Polynomial F) + -- `finSepDegree K L ∣ finrank K L = 2` and `≠ 1` (as `y` is separable), so it equals `finrank`. + have h_dvd := Field.finSepDegree_dvd_finrank K E.FunctionField +- haveI : FiniteDimensional K E.FunctionField := functionField_finiteDimensional E ++ have : FiniteDimensional K E.FunctionField := functionField_finiteDimensional E + have h_fr : Module.finrank K E.FunctionField = 2 := by +- haveI : Algebra.IsAlgebraic (Polynomial F) E.CoordinateRing := ++ have : Algebra.IsAlgebraic (Polynomial F) E.CoordinateRing := + (Algebra.IsIntegral.of_finite (Polynomial F) E.CoordinateRing).isAlgebraic + change Module.finrank (FractionRing (Polynomial F)) E.FunctionField = 2 +- rw [Algebra.IsAlgebraic.finrank_of_isFractionRing (Polynomial F) ++ rw [IsFractionRing.finrank_eq (Polynomial F) + (FractionRing (Polynomial F)) E.CoordinateRing E.FunctionField, + Module.finrank_eq_card_basis (Affine.CoordinateRing.basis E), Fintype.card_fin] + rw [h_fr] at h_dvd + have h_not_1 : Field.finSepDegree K E.FunctionField ≠ 1 := by + intro h1 +- haveI := isPurelyInseparable_of_finSepDegree_eq_one h1 ++ have := isPurelyInseparable_of_finSepDegree_eq_one h1 + set y : E.FunctionField := + algebraMap E.CoordinateRing E.FunctionField (AdjoinRoot.root E.polynomial) + have hy_int : IsIntegral K y := IsIntegral.of_finite _ _ +@@ -1446,8 +1393,7 @@ instance coordinateRing_isDedekindDomain (E : Affine F) [E.IsElliptic] : + IsIntegralClosure.isDedekindDomain (Polynomial F) (FractionRing (Polynomial F)) + E.FunctionField E.CoordinateRing + +-/-- The coordinate ring of an elliptic curve is integrally closed (consequence of being +-a Dedekind domain). -/ ++ + instance isIntegrallyClosed_coordinateRing (E : Affine F) [E.IsElliptic] : + IsIntegrallyClosed E.CoordinateRing := + inferInstance +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Valuation.lean b/projects/HasseWeil/HasseWeil/Foundation/Valuation.lean +index 7750f062d..5ec611dcc 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Valuation.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Valuation.lean +@@ -239,7 +239,7 @@ theorem localRing_isDVR {x₀ y₀ : F} (h : W.Nonsingular x₀ y₀) : + let P := pointIdeal W x₀ y₀ + haveI : P.IsPrime := (pointIdeal_isMaximal W h).isPrime + IsDiscreteValuationRing (Localization.AtPrime P) := by +- intro P; letI : P.IsPrime := (pointIdeal_isMaximal W h).isPrime ++ intro P; let : P.IsPrime := (pointIdeal_isMaximal W h).isPrime + let f := algebraMap W.CoordinateRing (Localization.AtPrime P) + -- Nonsingularity: WLOG polynomialY.evalEval x₀ y₀ ≠ 0 + -- (The other case swaps X↔Y roles; we handle the Y case.) +@@ -274,7 +274,7 @@ theorem localRing_isDVR {x₀ y₀ : F} (h : W.Nonsingular x₀ y₀) : + (M := P.primeCompl) _ P.primeCompl_le_nonZeroDivisors)] at hbot + exact (Affine.CoordinateRing.XClass_ne_zero (W' := W) (x := x₀)) + (eq_bot_iff.mp hbot (subset_span (Set.mem_insert _ _))) +- haveI : IsPrincipalIdealRing (Localization.AtPrime P) := ++ have : IsPrincipalIdealRing (Localization.AtPrime P) := + ((tfae_of_isNoetherianRing_of_isLocalRing_of_isDomain + (Localization.AtPrime P)).out 5 1).mp hprincipal + exact ⟨hne⟩ +@@ -306,7 +306,7 @@ theorem localRing_isDVR {x₀ y₀ : F} (h : W.Nonsingular x₀ y₀) : + (M := P.primeCompl) _ P.primeCompl_le_nonZeroDivisors)] at hbot + exact (Affine.CoordinateRing.XClass_ne_zero (W' := W) (x := x₀)) + (eq_bot_iff.mp hbot (subset_span (Set.mem_insert _ _))) +- haveI : IsPrincipalIdealRing (Localization.AtPrime P) := ++ have : IsPrincipalIdealRing (Localization.AtPrime P) := + ((tfae_of_isNoetherianRing_of_isLocalRing_of_isDomain + (Localization.AtPrime P)).out 5 1).mp hprincipal + exact ⟨hne⟩ +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Verschiebung/Genuine.lean b/projects/HasseWeil/HasseWeil/Foundation/Verschiebung/Genuine.lean +index 16c9844e05e8a3a4e84977c4344686797b691a85..cdf52885c82d916e7b1c8e267acd875b4c7fe0ab 100644 +GIT binary patch +delta 6150 +zcma)Ae~c7o8P42M3e$opJt$z?uLb3f-tBRu5kp%Q3WW2l0$wRdC^I|z?e14*XZB`h +zx!d~3wp1(H)*npb5)+#y))W0Rj;;;kBRMKHuNjfQ!*4~Kd8x)C4wZh8wB6s~kI0zGs^ARVm7LO}WkZ%f=lo;rLz{1q~;{N{vwA +z+hMa-lTpwVei={wprkxIlA_*l-Jao0-;z`QI!@1q$*01_XC|So_R8)y#pE9$^%k}X)b$hlGzmh{=!%*$5*CvNre$MkMfBn)yz24L#H5Sqfpo-3J&zlr)4Tl +zys%MA0n0xoL`w~48+cqy0Qe`kfW%TRB<^`GLSMg^R5>AtF5^nc +zWKhQ6ecwItiO1K+{)b*)b2RY%a$(o5&an?)GH1}0kvM%&I;uqcKeQm`&LCcMdTL5M +z;!3n6YFLugy^sVy2s`i0zPx7BV>+=MW=iGpCiMb{q(W*MvF?7s>(o`AQ0Dh +z5F4RW6^mdQ?FYj2%N%4dt(OWkRm)1ch_7Z>z-K#tzx#f-(&*5MIhtkVlmoIA72ivPNJ7pt>w0NWK%Z)D6l_1H^8fWCuo=yZAo$gtH} +zFHAwV>i!}SVu?1brL*Xg1mULsKR)2_xt8U14Ri#{1?70<(-&?%N1FR67?P6}^ND9JZH|AqZcV)Vi_`IoFMO->o6o#xbi(KS(Y2<4z>*TgKldbuTIKJtFn9NN_HTYfp=Z1@N{I +z0k}X~PkNdlHKoaxvKmN-K4Z!BBV9zTS}0Z@I{c7}f9+|ikSArH8(*Sa6s(hGhw5ZcoS9w)*)<+ef&nH%Ao-hoUd@w!fJeuLrPBpWt3=Xx`}M9 +zMg7|hej^8goHJV11L;UAHHivV*9S#11b&&lNZ5kQP1*~^J?|?zLkU|rDsUREjqz2l +zOFgv+)?9Vc7QI(&-@aWOmoUX_H2_Qzhb7dtR>R0ZG!bu~YN#f3wCF<_l-IfISKk|n +zugz}j{QTE{+Suw_hJq#+PRAkIJa446tY{Jl8brbxKY12!PoAQ`CoB=7XkocY>Ci%t +zONC(%nGZu&V?LCa7QYR>e;IU~6k9WT@>=-(75*F%#9#W`rgu%Ji_>6kn(eO~FgEVc +zwoTV5IZ^=NG+jQigzab68=D?AUEcwgbUMWW9j(lorE3!eGOW{S3Gvqbkk2Jknn4MY +zy+bgLv{TdZo3mS6q_Z`BqD_^$nLBPwl2uMu1Ae@o7PRzJ9n(}VCcS4BjgIzT26@7; +zaYo`yLT3Nx(w +zi>PqIGQhDj6oWWZHt9-Q8g$W4tppm6j1_R>qldm0fbwF+Y^GGCPZuumSJ_2D{MOs| +zwx>@Tx3!-zjSZd4?~JV4NQKssW!D+)ua6p+2#Jr*CuApGL2qFHDdn+0MdVN~x{*MO +zF`a#3eS!?gvJ%mVlI{IRa4$sQ>05>goh$AGuy*cV#SS8vSRBSnc4SkNndfb{!BU4* +zaY=%llv5D<$%E0p)^2VH5Ja53e&JbIU}>YjVacEuJqrb;G|ldxZ#Nz=4C|{~jIsFI +ze>QYy*Bf)AvHi|_yWfAeaqH^#8=H-9uY^d~z0-&$GI9{TZypkx{43)`n&+EGJZ7?U;*Gb8(yOS!CZa49fMZjuHdQoM1-xTSmRVdM6ZZAfs1 +zN}}kxk{i4B5u-NR{q3CL81YYz-nojH(thJnV=J5-hLwv8D%|{eWDU}3WR8DQxgZY& +zIK5v23l3vA4dE7hy=5Tb^n+Z?!7DiGI2tMU_j+z<3e+cyn4nqnZ|z<@ZG6fYNpjdW +zG>3v2KQl4b23yv)AAG{NXZURc5oGW}Ne9Fz(f}eNmSB2qmG@pdE+&~ 1` — Silverman III.6.2 step +- +-The substantive content is the **Frobenius factorisation** of `[p^k]`: +-`[p^k] = π_{p^k} ∘ V_{p^k}` on the curve, pulled back to +-`[p^k]^* = V_{p^k}^* ∘ π_{p^k}^*` on the function field, where +-`π_{p^k}^* x = x^{p^k}`. This forces `[p^k]^* x = (V_{p^k}^* x)^{p^k}`, +-i.e., `[p^k]^* x` is a `p^k`-th power in `K(E)`. Equivalently +-`Φ_{p^k}, Ψ_{p^k}² ∈ R[X^{p^k}]`. +- +-### Polynomial-side recurrence approach (Worker C's stream) +- +-The polynomial-side argument avoids constructing `V_{p^k}`. The chain: +-1. Base case `k = 1`: `Φ_p, Ψ_p² ∈ R[X^p]` — shipped (`Φ_two_mem_expand_two_charP`, +- `Φ_three_mem_expand_three_charP`, etc.) for `p = 2, 3`. +-2. Sub-step (function-field level): `[p^k]^* x ∈ R(x^{p^k})` — derivable +- inductively from base + ring-hom properties of `[p]^*`. +-3. Polynomial extraction: from `[p^k]^* x = Φ_{p^k}/Ψ_{p^k}² ∈ R(x^{p^k})`, +- conclude `Φ_{p^k}, Ψ_{p^k}² ∈ R[X^{p^k}]`. +- +-Step 3 requires **coprimality of `Φ_{p^k}` and `Ψ_{p^k}²`** as polynomials +-in `R[X]`. Mathlib provides this for the curve case via +-`WeierstrassCurve.Φ.coprime_ΨSq` or analogous (Silverman III.6 background). +-Step 2 is reasonable to formalise from the base case via induction on `k`. +- +-### The missing recurrence +- +-Direct propagation `Φ_{p^k} → Φ_{p^{k+1}}` via division-polynomial recurrence +-needs the **multiplication-by-p formula**: +-`preΨ (p · m) = F(preΨ_{m-?}, ..., preΨ_{m+?})` for prime `p` and any `m`. +- +-Mathlib provides the **doubling+adding-one** recurrences: +-* `WeierstrassCurve.preΨ_even (m) : preΨ (2m) = ...` +-* `WeierstrassCurve.preΨ_odd (m) : preΨ (2m+1) = ...` +- +-For `p = 2`, `2m` is `p · m`, so the doubling formula is the multiplication-by-2 +-recurrence directly. For `p ≥ 3`, multiplication-by-`p` is **not** doubling +-and requires a derived formula. The classical derivation iterates the +-doubling+add-one chain `p` times, but the resulting polynomial identity is +-sympy-territory complexity for each odd prime. +- +-The general formula is in Silverman §III.6 / Sutherland Lecture 6 (modern +-treatment) but is not in mathlib. Shipping it for arbitrary prime `p` +-requires either: +-* A general recurrence proof from `preΨ_even`/`preΨ_odd` via induction +- on the binary expansion of `p · m` (~200 LOC of polynomial manipulation +- + sympy-verified per-prime multipliers). +-* A direct port of the bivariate recurrence `Ψ_{m+n} Ψ_{m-n} = ...` +- (Silverman Exercise 3.7) — ~50 LOC of polynomial identities, then derive +- multiplication-by-`p` as `m + (p-1)·m`. +- +-### What's shipped here +- +-The polynomial-side propagation building blocks are in place: +-* `pow_mem_expand_charP`, `pow_pow_mem_expand_pow_charP` — `f^(p^n) ∈ expand`-range. +-* `pow_pow_mem_expand_pow_succ_of_expand_charP` — `f ∈ expand p` → +- `f^(p^k) ∈ expand (p^(k+1))`. Used in the inductive step's +- Frobenius-cycle argument. +-* `expand_pow_map_iterateFrobenius` — equational form +- `expand (p^n) (f.map iterateFrobenius) = f^(p^n)`. +- +-The next concrete sub-piece (deferred to the multiplication-by-p recurrence +-port): the full propagation theorem +-`Φ_p_pow_mul_p_mem_expand_charP : Φ_{p^k} ∈ expand (p^k) → Φ_{p^{k+1}} ∈ expand (p^{k+1})`. -/ ++/-! ### Propagation to powers of the characteristic ++ ++The Frobenius factorization of multiplication by `p^k` implies that the ++pulled-back coordinates are `p^k`-th powers. On the polynomial side this ++corresponds to membership of the coprime division-polynomial numerator and ++denominator in `R[X^(p^k)]`. Powers and iterated Frobenius give the expansion ++identities used to propagate this membership. ++-/ + + + end GenericExpand +diff --git a/projects/HasseWeil/HasseWeil/Foundation/Verschiebung/UniversalQthRootWitness.lean b/projects/HasseWeil/HasseWeil/Foundation/Verschiebung/UniversalQthRootWitness.lean +index c7790ab47..43c07c0ea 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/Verschiebung/UniversalQthRootWitness.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/Verschiebung/UniversalQthRootWitness.lean +@@ -8,50 +8,26 @@ import HasseWeil.Foundation.Verschiebung.VerschiebungIsDualOfFrobenius + import HasseWeil.Foundation.Verschiebung.Route2Universal + + /-! +-# The universal q-th-root witness (general characteristic) — Route B +- +-This file discharges, for an arbitrary finite field `K` (`q = #K = p^k`, +-`p = char K`), the **universal q-th-root witness** +- +-``` +-h_qth_root : ∀ z, ∃ g, g ^ q = [q]* z +-``` +- +-(`[q]*` the pullback of the multiplication-by-q isogeny on `K(E)`), and feeds +-it through the proven reducer `verschiebungIsog_isDualOf_frobenius_of_qth_root_witness` +-to obtain `verschiebung_isDualOf_frobenius_general` — the GAP-QF keystone. +- +-## Strategy (uniform in `p`, no per-prime polynomial witnesses) +- +-The keystone reduces (via `mulByInt_q_pullback_fieldRange_subset_frobenius_of_xy_witness` +-and `functionField_eq_intermediateField_adjoin_xy`) to two generator facts: +- +-* `[q]* x_gen ∈ R` and `[q]* y_gen ∈ R`, where `R = (frobeniusIsog W).pullback.range = K(E)^q`. +- +-Both are obtained from the **Kähler differential** kernel theorem +-`kaehlerD_eq_zero_iff_mem_pth_powers` (`ker D = K(E)^p`, char `p`) and the +-**separability** of `K(E)/K(x_gen)` (`functionField_isSeparable`), with no +-characteristic-specific polynomial computation: +- +-* **x-side base** `[p]* x_gen ∈ adjoin K {x_gen^p}`: `[p]* x_gen` is rational in +- `x_gen` (so lies in `K(x_gen)`) and has `D([p]* x_gen) = 0` +- (`D_mulByInt_p_pullback_x_gen_eq_zero`), hence is a `p`-th power `g^p` with +- `g ∈ K(E)`; since `K(E)/K(x_gen)` is separable, the purely-inseparable element +- `g` lies in `K(x_gen)`, so `[p]* x_gen = g^p ∈ adjoin K {x_gen^p}`. The +- existing induction `mulByInt_pow_pullback_x_gen_mem_adjoin_pow_of_base`-style +- bootstrap (re-derived here taking the Kähler base) lifts this to +- `[q]* x_gen ∈ adjoin K {x_gen^q} ⊆ R`. +-* **y-side** `[q]* y_gen ∈ R`: `y_gen` satisfies the separable Weierstrass +- quadratic over `K(x_gen)`; applying `[q]*` gives that `[q]* y_gen` is a root of +- a **separable** quadratic over `R` (its discriminant is `([q]*(2y+a₁x+a₃))² ≠ 0`, +- using injectivity of `[q]*` and `2y+a₁x+a₃ ≠ 0`), with coefficients in `R` +- (because `[q]* x_gen ∈ R`). So `[q]* y_gen` is separable over `R`; as `K(E)/R` +- is purely inseparable (`frobeniusIsog_intermediateField_isPurelyInseparable`), +- `[q]* y_gen ∈ R`. ++# Universal `q`-th roots of multiplication pullbacks ++ ++For a finite field `K` of cardinality `q = p^k`, every multiplication pullback ++`[q]* z` on `K(E)` is a `q`-th power. The resulting image inclusion in Frobenius ++pullback constructs the dual of Frobenius. ++ ++It suffices to show that `[q]* x` and `[q]* y` lie in the Frobenius image ++`R = K(E)^q`. The Kähler differential of `[p]* x` vanishes, so it is a `p`-th ++power `g^p`. Since `K(E)/K(x)` is separable and `[p]* x ∈ K(x)`, the purely ++inseparable element `g` lies in `K(x)`. Induction gives ++`[q]* x ∈ K(x^q) ⊆ R`. ++ ++The Weierstrass equation then makes `[q]* y` separable over `R`: the pulled-back ++quadratic has nonzero derivative at `[q]* y`, since `[q]*` is injective and ++`2y + a₁x + a₃ ≠ 0`. As `K(E)/R` is purely inseparable, `[q]* y` belongs to `R`. ++The argument applies in every characteristic. + + ## References + +-* Silverman, *The Arithmetic of Elliptic Curves*, II.2.12, III.5.5, III.6.2. ++* Silverman, *The Arithmetic of Elliptic Curves*, II.2.12, III.5.5, and III.6.2. + -/ + + open WeierstrassCurve +@@ -71,10 +47,10 @@ omit [Fintype K] [DecidableEq K] in + theorem mem_fractionRing_range_of_pow_mem (p : ℕ) [Fact p.Prime] [CharP K p] + (g : KE) (hg : g ^ p ∈ (algebraMap Mff KE).range) : + g ∈ (algebraMap Mff KE).range := by +- haveI : Algebra.IsSeparable Mff KE := functionField_isSeparable W.toAffine +- haveI : CharP (Polynomial K) p := inferInstance +- haveI : CharP Mff p := inferInstance +- haveI : ExpChar Mff p := ExpChar.prime Fact.out ++ have : Algebra.IsSeparable Mff KE := functionField_isSeparable W.toAffine ++ have : CharP (Polynomial K) p := inferInstance ++ have : CharP Mff p := inferInstance ++ have : ExpChar Mff p := ExpChar.prime Fact.out + have hsep : IsSeparable Mff g := Algebra.IsSeparable.isSeparable Mff g + have hsd1 : (minpoly Mff g).natSepDegree = 1 := by + rw [minpoly.natSepDegree_eq_one_iff_pow_mem p] +@@ -93,7 +69,7 @@ the scalar-tower factoring of the structure map through `M = FractionRing K[X]`. + theorem algebraMap_polynomial_eq_fractionRing (q : Polynomial K) : + algebraMap (Polynomial K) KE q = + algebraMap Mff KE (algebraMap (Polynomial K) Mff q) := by +- haveI : IsScalarTower (Polynomial K) Mff KE := functionField_isScalarTower W.toAffine ++ have : IsScalarTower (Polynomial K) Mff KE := functionField_isScalarTower W.toAffine + rw [← IsScalarTower.algebraMap_apply] + + omit [Fintype K] [DecidableEq K] in +@@ -158,7 +134,7 @@ theorem mulByInt_p_pullback_x_gen_mem_adjoin_pow_routeB + (p : ℕ) [Fact p.Prime] [CharP K p] : + (mulByInt W.toAffine (p : ℤ)).pullback (x_gen W) ∈ + IntermediateField.adjoin K ({x_gen W ^ p} : Set KE) := by +- haveI : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p ++ have : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p + have hp_ne : (p : ℤ) ≠ 0 := by exact_mod_cast (Fact.out : p.Prime).pos.ne' + have hD := D_mulByInt_p_pullback_x_gen_eq_zero W p + obtain ⟨g, hg⟩ := (kaehlerD_eq_zero_iff_mem_pth_powers W p _).mp hD +@@ -175,8 +151,8 @@ theorem mulByInt_p_pullback_x_gen_mem_adjoin_pow_routeB + exact adjoin_simple_pow_le_adjoin_simple_pow p (x_gen W) g hg_mem + + omit [Fintype K] in +-/-- `[p ^ (k+1)]` factors as `[p ^ k] ∘ [p]` (shared scaffolding for the x- and +-y-side `p^k`-power inductions). -/ ++/-- `[p ^ (k+1)]` factors as `[p ^ k] ∘ [p]` (the common composition identity in the x- and ++y-coordinate `p^k`-power inductions). -/ + private theorem mulByInt_pow_succ_comp (p : ℕ) [Fact p.Prime] (k : ℕ) : + mulByInt W.toAffine ((p ^ (k + 1) : ℕ) : ℤ) = + (mulByInt W.toAffine ((p ^ k : ℕ) : ℤ)).comp +@@ -195,7 +171,7 @@ theorem mulByInt_pow_pullback_x_gen_mem_adjoin_pow_routeB + (p : ℕ) [Fact p.Prime] [CharP K p] : + ∀ k, (mulByInt W.toAffine ((p ^ k : ℕ) : ℤ)).pullback (x_gen W) ∈ + IntermediateField.adjoin K ({x_gen W ^ (p ^ k : ℕ)} : Set KE) := by +- haveI : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p ++ have : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p + intro k + induction k with + | zero => exact mulByInt_pow_zero_pullback_x_gen_mem_adjoin_pow W p +@@ -355,7 +331,7 @@ theorem mulByInt_p_pullback_y_gen_mem_adjoin_pair_pow + (p : ℕ) [Fact p.Prime] [CharP K p] : + (mulByInt W.toAffine (p : ℤ)).pullback (y_gen W) ∈ + IntermediateField.adjoin K ({x_gen W ^ p, y_gen W ^ p} : Set KE) := by +- haveI : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p ++ have : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p + obtain ⟨h, hh⟩ := (kaehlerD_eq_zero_iff_mem_pth_powers W p _).mp + (D_mulByInt_p_pullback_y_gen_eq_zero W p) + have hh_mem : h ∈ IntermediateField.adjoin K ({x_gen W, y_gen W} : Set KE) := by +@@ -369,7 +345,7 @@ theorem mulByInt_pow_pullback_y_gen_mem_adjoin_pair_pow + (p : ℕ) [Fact p.Prime] [CharP K p] : + ∀ k, (mulByInt W.toAffine ((p ^ k : ℕ) : ℤ)).pullback (y_gen W) ∈ + IntermediateField.adjoin K ({x_gen W ^ (p ^ k : ℕ), y_gen W ^ (p ^ k : ℕ)} : Set KE) := by +- haveI : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p ++ have : CharP KE p := charP_of_injective_algebraMap (algebraMap K KE).injective p + intro k + induction k with + | zero => +@@ -450,8 +426,8 @@ theorem qth_root_witness_general : + g ^ Fintype.card K = + (mulByInt W.toAffine ((Fintype.card K : ℕ) : ℤ)).pullback z := by + obtain ⟨p, hCharP, ⟨n, _⟩, hp_prime, _⟩ := FiniteField.card' K +- haveI : Fact p.Prime := ⟨hp_prime⟩ +- haveI := hCharP ++ have : Fact p.Prime := ⟨hp_prime⟩ ++ have := hCharP + exact qth_root_witness_of_charP W p + + /-- **The GAP-QF keystone (general characteristic)**: the Verschiebung is the dual of +diff --git a/projects/HasseWeil/HasseWeil/Foundation/WallA/VSideDual.lean b/projects/HasseWeil/HasseWeil/Foundation/WallA/VSideDual.lean +index e5247f095..049bee4e1 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/WallA/VSideDual.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/WallA/VSideDual.lean +@@ -8,47 +8,16 @@ import HasseWeil.HasseBound.SumTrace + import HasseWeil.Foundation.Verschiebung.Genuine + + /-! +-# Wall A — the V-side dual route to the signed III.6.3 degree identity +- +-This file assembles the **V-side genuine isogeny** `β_dual = r·V − s` (built on the +-Verschiebung `V`, mirroring the π-side genuine `β = r·π − s`) into the pivot-chain scaffold +-shipped in `HasseWeil.GapSpines`, in order to drive +- +- `deg(r·π − s) = q·r² − t·r·s + s²` (the Wall-A keystone; its unconditional sorried form +- `genuineIsogSmulSub_degree_eq_signed` was retired 2026-06-11 — the witness-parametric +- `genuineIsogSmulSub_degree_eq_signed_via_walls` is the shipped form). +- +-## What is proved here, unconditionally +- +-* `isogeny_isGenuineWith_pointMap` — **any** isogeny `φ` is `IsGenuineWith` the geometric action +- `Affine.Point.map φ.pullback` on `(W_KE).Point`. This is the clean, general form of the +- "the pullback is the comorphism of a geometric map" non-vacuity check (`map_some`). +-* `betaDualV` — the V-side genuine isogeny `r·V − s`, constructed via the genuine-sum combinator +- `addIsog` applied to the Verschiebung (so **`addIsog` does generalise to `V`** — the V-side +- pole/injectivity bricks already live in `Verschiebung/Genuine.lean`). +-* `betaDualV_toAddMonoidHom_sub` — the point-map of `betaDualV` is `r·V − s·id` +- (`h_beta_dual_hom`), using `V.toAddMonoidHom = [q]` (`verschiebungIsog_of_witness`). +-* `betaDualV_isDual_pi` — `IsDualOf V π` (`h_isDual_V_pi`), from `verschiebung_dual_exists`'s +- underlying witness. +-* `genuineIsogSmulSub_degree_eq_signed_closed` — the **closing lemma**: it constructs `V` and +- `β_dual = r·V − s` internally, discharges `h_isDual_V_pi`, `h_beta_dual_hom`, `h_beta_pos`, and +- reduces the Wall-A keystone to exactly the three *standing dual residuals* (the genuine III.6.1 / +- III.6.2 content the project has not yet shipped unconditionally): +- +- 1. `h_sum_trace` : `π + V = [t]` (the trace relation, Silverman III.6.2(b); itself the +- output of `sum_trace_frobenius_witness` modulo `IsDualOf (1−V) (1−π)`); +- 2. `h_pullback_eq`: the full-isogeny **comorphism** identity `(β_dual ∘ β)* = [N]*` (the +- "double-Vieta" pullback match — the geometrically irreducible content); +- 3. `h_isDual_pair`: `IsDualOf β_dual β` (Silverman III.6.1 for the genuine pair). +- +- Everything else is internal; this is the honest reduction of Wall A to the standing dual +- residuals, composed through `genuineIsogSmulSub_degree_eq_signed_of_full_pivot_chain`. +- +-The unconditional statement (the former bare-`sorry` +-`GapSpines.genuineIsogSmulSub_degree_eq_signed`, deleted 2026-06-11 with the legacy skeleton +-chain) would require the three residuals above unconditionally (the project has not +-shipped `IsDualOf (1−V) (1−π)` nor the double-Vieta pullback identity); this +-witness-parametric closing lemma is the live form. ++# Verschiebung and the signed degree identity ++ ++Let `π` be Frobenius, `V` its dual, and `t` its trace. The isogeny `r V - s` ++provides the dual candidate for `r π - s`. Their point maps, a trace relation, ++a composition pullback identity, and a duality witness imply the signed degree ++formula `deg(r π - s) = q r² - t r s + s²`, under the stated nonvanishing hypotheses. ++ ++The trace, pullback, and duality identities remain explicit mathematical inputs. ++The construction also identifies the geometric action associated with any isogeny ++pullback at the generic point. + + ## References + +@@ -64,14 +33,11 @@ namespace WallA + variable {K : Type*} [Field K] [Fintype K] [DecidableEq K] + variable (W : WeierstrassCurve K) [W.toAffine.IsElliptic] [Fintype W.toAffine.Point] + +-/-! ### A general genuineness witness: any isogeny is genuine with `map pullback` ++/-! ### Geometric action of an isogeny pullback + +-`IsGenuineWith φ g` (`GapSpines`) only constrains the geometric action `g` at the generic point +-`P_gen = (x_gen, y_gen)`: it asks `g P_gen = some (φ.pullback x_gen) (φ.pullback y_gen)`. For the +-**canonical** action `Affine.Point.map (W' := W) φ.pullback` this is exactly `Affine.Point.map_some` +-applied to `genericPoint = some x_gen y_gen _`. So genuineness with the canonical action holds for +-*every* isogeny, with no hypotheses — this is the clean non-vacuity form (it confirms `IsGenuine` +-is satisfied by any genuine geometric isogeny, the pullback being its comorphism). -/ ++For the canonical action `Affine.Point.map φ.pullback`, evaluation at the generic ++point is `some (φ* x) (φ* y)`. This supplies `IsGenuineWith` for every isogeny. ++-/ + omit [Fintype K] [Fintype W.toAffine.Point] in + theorem isogeny_isGenuineWith_pointMap (φ : Isogeny W.toAffine W.toAffine) : + IsGenuineWith W φ (WeierstrassCurve.Affine.Point.map (W' := W) φ.pullback) := by +@@ -86,14 +52,14 @@ omit [Fintype K] [Fintype W.toAffine.Point] in + theorem isogeny_isGenuine (φ : Isogeny W.toAffine W.toAffine) : IsGenuine W φ := + ⟨_, isogeny_isGenuineWith_pointMap W φ⟩ + +-/-! ### The Verschiebung as a concrete `V` with `IsDualOf V π` ++/-! ### Verschiebung duality + +-We pin a single concrete Verschiebung witness, `verschiebungV`, from the connected (axiom-clean +-modulo the upstream `[q] = V ∘ π` factorisation) inclusion `mulByInt_q_pullback_subset_frobenius`. +-Its `IsDualOf V π` is `verschiebung_dual_exists`'s underlying witness, and its point map is the +-`[q]`-point map (`verschiebungIsog_of_witness.toAddMonoidHom = (mulByInt q).toAddMonoidHom`). -/ ++The image inclusion `Im([q]*) ⊆ Im(π*)` constructs a Verschiebung `V` dual to ++Frobenius. On rational points over the finite field, Frobenius is the identity, ++so the point map of `V` is multiplication by `q`. ++-/ + +-/-- The inclusion `Im([q]*) ⊆ Im(π*)` (Silverman II.2.11/III.6.2), the connected witness. -/ ++/-- The image inclusion `Im([q]*) ⊆ Im(π*)`. See Silverman II.2.11 and III.6.2. -/ + noncomputable abbrev hSubset (hq : 2 ≤ Fintype.card K) : + (mulByInt W.toAffine ((Fintype.card K : ℕ) : ℤ)).pullback.range ≤ + (frobeniusIsog W).pullback.range := +@@ -104,11 +70,13 @@ noncomputable def verschiebungV (hq : 2 ≤ Fintype.card K) : + Isogeny W.toAffine W.toAffine := + verschiebungIsog_of_witness W (hSubset W hq) + +-/-- `IsDualOf V π` for the concrete Verschiebung (`h_isDual_V_pi`, Silverman III.6.1 Case 2). -/ ++omit [Fintype W.toAffine.Point] in ++/-- The concrete Verschiebung is dual to Frobenius. See Silverman III.6.1. -/ + theorem verschiebungV_isDual (hq : 2 ≤ Fintype.card K) : + IsDualOf W.toAffine (verschiebungV W hq) (frobeniusIsog W) := + verschiebungIsog_of_witness_isDualOf_frobenius W (hSubset W hq) + ++omit [Fintype W.toAffine.Point] in + /-- The point map of the concrete Verschiebung is the `[q]`-point map (`= q • ·`). Frobenius on + `F_q`-rational points is the identity, so the dual `V` (`V ∘ π = [q]`) must carry the `[q]`-point + map. -/ +@@ -117,12 +85,12 @@ map. -/ + (mulByInt W.toAffine ((Fintype.card K : ℕ) : ℤ)).toAddMonoidHom := + rfl + +-/-! ### The V-side genuine isogeny `β_dual = r·V − s` ++/-! ### The isogeny `r V - s` + +-This is `addIsog` of the genuine pair `(V.zsmul r, [−s])` — the **exact mirror** of the π-side +-`genuineIsogSmulSub = addIsog (π.zsmul r, [−s])`. So `addIsog` *does* generalise to `V`: the V-side +-non-inverse / injectivity / pole bricks are the ones shipped in `Verschiebung/Genuine.lean` +-(`genuineIsogSmulSubV_universal_unconditional`). Its point map is `r·V + (−s) = r·V − s`. -/ ++The addition construction applied to `(V.zsmul r, [-s])` gives an isogeny with ++point map `r V - s id`, using the distinct-coordinate and pole identities for ++Verschiebung. ++-/ + + /-- The V-side genuine isogeny `r·V − s` on the concrete Verschiebung `V`. -/ + noncomputable def betaDualV (hq : 2 ≤ Fintype.card K) +@@ -131,6 +99,7 @@ noncomputable def betaDualV (hq : 2 ≤ Fintype.card K) + genuineIsogSmulSubV_universal_unconditional W (verschiebungV W hq) + (verschiebungV_isDual W hq) r s hr hs hrK hsK + ++omit [Fintype W.toAffine.Point] in + /-- The point map of `betaDualV` is `r·V − s·id` (`h_beta_dual_hom`). + + `betaDualV.toAddMonoidHom = (V.zsmul r) + [−s]`, and `(V.zsmul r) = [r] ∘ V`, so pointwise this is +@@ -150,28 +119,19 @@ theorem betaDualV_toAddMonoidHom_sub (hq : 2 ≤ Fintype.card K) + AddMonoidHom.id_apply, Isogeny.zsmul_apply, mulByInt_apply] + rw [neg_smul, sub_eq_add_neg] + +-/-! ### The Wall-A keystone, reduced to the standing dual residuals +- +-`genuineIsogSmulSub_degree_eq_signed_closed` is the live, witness-parametric form of the Wall-A +-keystone (whose unconditional sorried form was deleted 2026-06-11). It constructs the concrete +-Verschiebung +-`V` and the V-side genuine isogeny `β_dual = r·V − s` internally, discharges the three *structural* +-pivot inputs (`h_isDual_V_pi`, `h_beta_dual_hom`, `h_beta_pos`), and reduces the keystone to exactly +-the three **standing dual residuals** plus the nonvanishing of `N`: +- +-* `h_sum_trace` — the trace relation `π + V = [t]` (Silverman III.6.2(b); the output of +- `sum_trace_frobenius_witness` once `IsDualOf (1−V) (1−π)` ships); +-* `h_pullback_eq` — the comorphism identity `(β_dual ∘ β)* = [N]*` (the double-Vieta pullback match, +- the geometrically irreducible content of Wall A — equivalently, that `β_dual ∘ β` is genuine with +- the `[N]` action; see `GapSpines.genuine_dual_comp_eq_mulByInt_of_isGenuineWith`); +-* `h_isDual_pair` — `IsDualOf β_dual β` (Silverman III.6.1 for the genuine pair); +-* `h_N_ne` — `N = q·r² − t·r·s + s² ≠ 0` (automatic in the Hasse assembly: `β_dual ∘ β = [N]` +- forces `deg β · deg β_dual = N²`, so `N ≠ 0`; carried here as a hypothesis). +- +-The composition is `genuineIsogSmulSub_degree_eq_signed_of_full_pivot_chain` (GapSpines), with the +-internally-built `V = verschiebungV`, `β_dual = betaDualV`. This is the honest reduction of Wall A: +-the only inputs are the genuine III.6.1/III.6.2 facts the project has not yet shipped +-unconditionally. -/ ++/-! ### The signed degree identity ++ ++For `β = r π - s` and `β_dual = r V - s`, assume: ++ ++* the trace relation `π + V = [t]` on points; ++* the pullback identity `(β_dual ∘ β)* = [N]*`, where `N = q r² - t r s + s²`; ++* the duality relation `IsDualOf β_dual β`; ++* `N ≠ 0`. ++ ++These inputs, together with the constructed point map of `β_dual` and positivity ++of the degree of `β`, give `deg β = N`. See Silverman III.6.1–III.6.3. ++-/ ++omit [Fintype W.toAffine.Point] in + theorem genuineIsogSmulSub_degree_eq_signed_closed (hq : 2 ≤ Fintype.card K) + (r s : ℤ) (hr : r ≠ 0) (hs : s ≠ 0) (hrK : (r : K) ≠ 0) (hsK : (s : K) ≠ 0) + (h_sum_trace : (frobeniusIsog W).toAddMonoidHom + (verschiebungV W hq).toAddMonoidHom = +diff --git a/projects/HasseWeil/HasseWeil/Foundation/WronskianAux.lean b/projects/HasseWeil/HasseWeil/Foundation/WronskianAux.lean +index 2c92295af..6cd2db847 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/WronskianAux.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/WronskianAux.lean +@@ -1,120 +1,32 @@ ++import HasseWeil.Foundation.WronskianAux.Prefix + /- + Copyright (c) 2026 Chris Birkbeck. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Chris Birkbeck + -/ +-import Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic +-import Mathlib.Algebra.Polynomial.Derivation +-import HasseWeil.Foundation.WronskianAux.CNorm +- +-/-! +-# Wronskian identities for Weierstrass division polynomials +- +-Two auxiliary polynomial identities used in the proof of the division-polynomial +-Wronskian identity (Silverman III.3 Exercise 3.7): +- +-* `wronskian_aux_three` — the `m = 3` case. +-* `wronskian_aux_four` — the `m = 4` case. +- +-## Strategy +- +-Both identities are pure polynomial identities in `R[X]` that hold because of +-`b_relation : 4·b₈ = b₂·b₆ - b₄²`. Concretely, `LHS - RHS` factors as +-`M(X) · (4b₈ - b₂b₆ + b₄²)` in `ℤ[b₂,b₄,b₆,b₈,X]` for an explicit polynomial +-`M`. The multipliers `M` were computed by dividing the expanded difference by +-`(4b₈ - b₂b₆ + b₄²)` over `ℤ[b₂,b₄,b₆,b₈]` (with `b₈` as the leading variable); +-see `scripts/compute_multipliers.py`. +- +-The proof uses `linear_combination M · h_P` where `h_P` is `b_relation` lifted +-to `R[X]`. The `C`-normalization lemmas imported from `CNorm.lean` handle the +-`C (Nat.cast n : R)` vs `C (OfNat.ofNat n : R)` atomization issue that +-otherwise blocks `ring` from closing the residual. +- +-Resource usage (vs original): +- +-* `wronskian_aux_three`: default `maxHeartbeats 200000` (was 32M, 160× reduction). +-* `wronskian_aux_four`: `maxHeartbeats 350000` (was 64M, ~180× reduction; measured +- minimum — 300000 fails). See TODO below for reducing to default. +- +-TODO (cleanup): reduce `wronskian_aux_four` `maxHeartbeats` to 200K (default). +- +-The 350K is required because `ring` must normalize a single degree-30 polynomial +-identity against the degree-26 multiplier `M`; the `evalMulProd` step in ring's +-normalization exceeds 300K heartbeats. Options to fit default: +- +-* Coefficient-wise approach via `Polynomial.ext_iff_natDegree_le`: works for +- `coeff 0` at default (using `eval 0` trick, which is a ring hom), but +- `Polynomial.coeff_mul` on nested products (`Ψ₃^3`, `preΨ₄ * Ψ₂Sq^2`, etc.) +- makes simp hit `max_steps` for `coeff i > 0`. Over arbitrary `CommRing R`, +- `(derivative^i p).eval 0 = i! · coeff i p` can't be inverted (no division). +-* New tactic: bounded-degree coefficient extraction avoiding simp's antidiagonal +- explosion — doesn't exist in mathlib yet. +-* Formalize in the quotient ring `ℤ[b₂,b₄,b₆,b₈] / (4b₈ - b₂b₆ + b₄²)` where +- `b_relation` becomes a ring identity — would work on 3 atoms instead of 4, +- smaller ring work, likely fits default. Requires building the quotient. +-* Manual algebraic split of m=4 into smaller sub-identities — research-level +- mathematical work. +- +-RAM usage: ~1-2 GB (was ~57 GB, ~30× reduction). +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, III.3 Exercise 3.7. +--/ +- + open WeierstrassCurve Polynomial +- + namespace HasseWeil +- + variable {R : Type*} [CommRing R] (W : WeierstrassCurve R) + +--- `b_relation` lifted to an equality in `R[X]`. The `C`-distributed statement shape is +--- load-bearing: the `wronskian_aux_*` proofs below pass this to `linear_combination`, +--- whose `ring` normalization treats each `C _` application as an atom. +-private lemma b_relation_poly : +- ((4 : R[X]) * Polynomial.C W.b₈ : R[X]) = +- Polynomial.C W.b₂ * Polynomial.C W.b₆ - Polynomial.C W.b₄ ^ 2 := by +- simpa [Polynomial.C_ofNat] using congrArg Polynomial.C W.b_relation +- +-/-- Wronskian auxiliary identity, `m = 3` case (Silverman III.3.7). +-`4·Ψ₃³ + 2·preΨ₄·Ψ₂Sq·Ψ₃' − (preΨ₄·Ψ₂Sq)'·Ψ₃ +-= 3·preΨ₄·Ψ₂Sq² − 3·preΨ₄²`. ++lemma wronskian_derivative_three : Polynomial.derivative W.Ψ₃ = 3 * W.Ψ₂Sq := by ++ simp only [Ψ₃, Ψ₂Sq, Polynomial.derivative_add, Polynomial.derivative_mul, ++ Polynomial.derivative_pow, Polynomial.derivative_X, Polynomial.derivative_C, ++ Polynomial.derivative_ofNat, Polynomial.C_mul, ++ Polynomial.C_ofNat, Nat.cast_ofNat] ++ ring + +-Multiplier: `M = b₈² + 4b₆b₈·X + 6b₄b₈·X² + 4b₂b₈·X³ + (b₂b₆ + 34b₈)·X⁴ +- + 36b₆·X⁵ + 18b₄·X⁶ + 4b₂·X⁷ + 9·X⁸`. -/ +-lemma wronskian_aux_three : +- 4 * W.Ψ₃ ^ 3 + 2 * W.preΨ₄ * W.Ψ₂Sq * Polynomial.derivative W.Ψ₃ - +- Polynomial.derivative (W.preΨ₄ * W.Ψ₂Sq) * W.Ψ₃ = +- Polynomial.C 3 * W.preΨ₄ * W.Ψ₂Sq ^ 2 - Polynomial.C 3 * W.preΨ₄ ^ 2 := by ++lemma wronskian_three_derivative_two : ++ W.Ψ₃ * Polynomial.derivative W.Ψ₂Sq = 2 * W.preΨ₄ + 2 * W.Ψ₂Sq ^ 2 := by + linear_combination (norm := ( +- simp only [Ψ₃, preΨ₄, Ψ₂Sq, +- Polynomial.derivative_add, Polynomial.derivative_sub, +- Polynomial.derivative_mul, Polynomial.derivative_pow, Polynomial.derivative_X, +- Polynomial.derivative_C, Polynomial.derivative_ofNat, +- Polynomial.C_add, Polynomial.C_sub, Polynomial.C_mul, Polynomial.C_pow, +- Polynomial.C_ofNat, Nat.cast_ofNat] +- ring)) +- (Polynomial.C (W.b₈ ^ 2) +- + Polynomial.C (4 * W.b₆ * W.b₈) * Polynomial.X +- + Polynomial.C (6 * W.b₄ * W.b₈) * Polynomial.X ^ 2 +- + Polynomial.C (4 * W.b₂ * W.b₈) * Polynomial.X ^ 3 +- + Polynomial.C (W.b₂ * W.b₆ + 34 * W.b₈) * Polynomial.X ^ 4 +- + Polynomial.C (36 * W.b₆) * Polynomial.X ^ 5 +- + Polynomial.C (18 * W.b₄) * Polynomial.X ^ 6 +- + Polynomial.C (4 * W.b₂) * Polynomial.X ^ 7 +- + Polynomial.C 9 * Polynomial.X ^ 8) * b_relation_poly W +- +--- Measured minimum (2026-07-16, #7205): 300000 fails at `synthesize pending MVars` +--- (ring's normalization of the degree-30 residual), 350000 passes. Removal attempts: +--- default budget and a type-ascribed multiplier both time out — the structural fix is the +--- quotient-ring route documented above (producer/decompose work). +-set_option maxHeartbeats 350000 in +-/-- Wronskian auxiliary identity, `m = 4` case (Silverman III.3.7). +- +-Multiplier `M(X)` is a degree-26 polynomial in `W.b₂, W.b₄, W.b₆, W.b₈` with +-integer coefficients, computed offline by polynomial division of `LHS - RHS` +-by `(4b₈ - b₂b₆ + b₄²)` over `ℤ[b₂, b₄, b₆, b₈]`. See +-`scripts/compute_multipliers.py` for the derivation. -/ ++ simp only [Ψ₃, preΨ₄, Ψ₂Sq, Polynomial.derivative_add, Polynomial.derivative_mul, ++ Polynomial.derivative_pow, Polynomial.derivative_X, Polynomial.derivative_C, ++ Polynomial.derivative_ofNat, Polynomial.C_sub, ++ Polynomial.C_mul, Polynomial.C_pow, Polynomial.C_ofNat, Nat.cast_ofNat] ++ ring)) (-2 * Polynomial.X ^ 2) * wronskian_b_relation_poly W ++ ++/-- The fourth Wronskian identity follows from the third identity and the two ++small derivative relations above. This factorization avoids expansion of the ++original degree-26 multiplier. -/ + lemma wronskian_aux_four : + (W.preΨ₄ ^ 2 * W.Ψ₂Sq) ^ 2 - + (Polynomial.derivative (W.Ψ₃ * (W.preΨ₄ * W.Ψ₂Sq ^ 2 - W.Ψ₃ ^ 3)) * +@@ -126,315 +38,12 @@ lemma wronskian_aux_four : + (W.Ψ₃ * ((W.preΨ₄ * W.Ψ₂Sq ^ 2 - W.Ψ₃ ^ 3) - W.preΨ₄ ^ 2)) - + W.preΨ₄ * (W.preΨ₄ * W.Ψ₂Sq ^ 2 - W.Ψ₃ ^ 3) ^ 2) := by + linear_combination (norm := ( +- simp only [Ψ₃, preΨ₄, Ψ₂Sq, +- Polynomial.derivative_mul, Polynomial.derivative_pow, +- Polynomial.derivative_add, Polynomial.derivative_sub, +- Polynomial.derivative_X, Polynomial.derivative_C, Polynomial.derivative_ofNat, +- Polynomial.C_mul, Polynomial.C_sub, Polynomial.C_add, Polynomial.C_pow, +- Polynomial.C_neg, Polynomial.C_ofNat, Nat.cast_ofNat] ++ simp only [Polynomial.derivative_mul, Polynomial.derivative_sub, ++ Polynomial.derivative_pow, Polynomial.C_ofNat, Nat.cast_ofNat] + ring)) +- (Polynomial.C (-W.b₆ ^ 6 * W.b₈ ^ 2 + (-2 * W.b₆ ^ 2 * W.b₈ ^ 5) +- + 2 * W.b₄ * W.b₈ ^ 6 +- + (-W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 4) +- + 2 * W.b₄ * W.b₆ ^ 4 * W.b₈ ^ 3) +- + Polynomial.C (-26 * W.b₆ ^ 3 * W.b₈ ^ 4 + (-4 * W.b₆ ^ 7 * W.b₈) +- + 2 * W.b₂ * W.b₈ ^ 6 +- + (-4 * W.b₄ ^ 3 * W.b₆ * W.b₈ ^ 4) +- + 2 * W.b₂ * W.b₆ ^ 4 * W.b₈ ^ 3 +- + 2 * W.b₄ * W.b₆ ^ 5 * W.b₈ ^ 2 +- + 6 * W.b₄ ^ 2 * W.b₆ ^ 3 * W.b₈ ^ 3 +- + 24 * W.b₄ * W.b₆ * W.b₈ ^ 5 +- + (-2 * W.b₂ * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 4)) * Polynomial.X +- + Polynomial.C (-4 * W.b₆ ^ 8 + 20 * W.b₈ ^ 6 + (-108 * W.b₆ ^ 4 * W.b₈ ^ 3) +- + (-4 * W.b₄ ^ 4 * W.b₈ ^ 4) + 28 * W.b₄ ^ 2 * W.b₈ ^ 5 +- + (-W.b₂ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 4) +- + (-18 * W.b₄ * W.b₆ ^ 6 * W.b₈) +- + (-2 * W.b₄ ^ 3 * W.b₆ ^ 2 * W.b₈ ^ 3) +- + 6 * W.b₂ * W.b₆ ^ 5 * W.b₈ ^ 2 +- + 26 * W.b₂ * W.b₆ * W.b₈ ^ 5 +- + 27 * W.b₄ ^ 2 * W.b₆ ^ 4 * W.b₈ ^ 2 +- + 54 * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 4 +- + (-10 * W.b₂ * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 4) +- + 6 * W.b₂ * W.b₄ * W.b₆ ^ 3 * W.b₈ ^ 3) * Polynomial.X ^ 2 +- + Polynomial.C (-196 * W.b₆ ^ 5 * W.b₈ ^ 2 + (-28 * W.b₄ * W.b₆ ^ 7) +- + 280 * W.b₆ * W.b₈ ^ 5 +- + (-96 * W.b₄ * W.b₆ ^ 3 * W.b₈ ^ 3) +- + (-16 * W.b₄ ^ 4 * W.b₆ * W.b₈ ^ 3) +- + (-16 * W.b₄ ^ 2 * W.b₆ ^ 5 * W.b₈) +- + (-12 * W.b₂ * W.b₄ ^ 3 * W.b₈ ^ 4) +- + 40 * W.b₂ * W.b₄ * W.b₈ ^ 5 +- + 52 * W.b₄ ^ 3 * W.b₆ ^ 3 * W.b₈ ^ 2 +- + 96 * W.b₂ * W.b₆ ^ 2 * W.b₈ ^ 4 +- + 156 * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 4 +- + (-16 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 3) +- + (-8 * W.b₂ ^ 2 * W.b₄ * W.b₆ * W.b₈ ^ 4) +- + 44 * W.b₂ * W.b₄ * W.b₆ ^ 4 * W.b₈ ^ 2) * Polynomial.X ^ 3 +- + Polynomial.C (-136 * W.b₆ ^ 6 * W.b₈ + (-76 * W.b₄ ^ 2 * W.b₆ ^ 6) +- + (-9 * W.b₂ * W.b₆ ^ 7) +- + (-8 * W.b₄ ^ 5 * W.b₈ ^ 3) + 12 * W.b₂ ^ 2 * W.b₈ ^ 5 +- + 48 * W.b₄ ^ 3 * W.b₈ ^ 4 + 356 * W.b₄ * W.b₈ ^ 5 +- + 1374 * W.b₆ ^ 2 * W.b₈ ^ 4 + (-508 * W.b₄ * W.b₆ ^ 4 * W.b₈ ^ 2) +- + (-13 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₈ ^ 4) +- + (-2 * W.b₂ ^ 3 * W.b₆ * W.b₈ ^ 4) +- + 11 * W.b₂ ^ 2 * W.b₆ ^ 4 * W.b₈ ^ 2 +- + 28 * W.b₄ ^ 4 * W.b₆ ^ 2 * W.b₈ ^ 2 +- + 30 * W.b₄ ^ 3 * W.b₆ ^ 4 * W.b₈ +- + 128 * W.b₂ * W.b₆ ^ 3 * W.b₈ ^ 3 +- + 216 * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 3 +- + (-52 * W.b₂ * W.b₄ ^ 3 * W.b₆ * W.b₈ ^ 3) +- + (-20 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 3) +- + 30 * W.b₂ * W.b₄ * W.b₆ ^ 5 * W.b₈ +- + 81 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 3 * W.b₈ ^ 2 +- + 240 * W.b₂ * W.b₄ * W.b₆ * W.b₈ ^ 4) * Polynomial.X ^ 4 +- + Polynomial.C (-2 * W.b₆ ^ 7 + (-100 * W.b₄ ^ 3 * W.b₆ ^ 5) + 188 * W.b₂ * W.b₈ ^ 5 +- + 3056 * W.b₆ ^ 3 * W.b₈ ^ 3 + (-468 * W.b₄ * W.b₆ ^ 5 * W.b₈) +- + (-410 * W.b₄ ^ 2 * W.b₆ ^ 3 * W.b₈ ^ 2) +- + (-46 * W.b₂ * W.b₄ * W.b₆ ^ 6) +- + (-28 * W.b₂ * W.b₆ ^ 4 * W.b₈ ^ 2) +- + (-24 * W.b₂ * W.b₄ ^ 4 * W.b₈ ^ 3) +- + (-6 * W.b₂ ^ 3 * W.b₄ * W.b₈ ^ 4) +- + (-6 * W.b₂ ^ 3 * W.b₆ ^ 2 * W.b₈ ^ 3) +- + 14 * W.b₂ ^ 2 * W.b₆ ^ 5 * W.b₈ +- + 56 * W.b₄ ^ 4 * W.b₆ ^ 3 * W.b₈ +- + 64 * W.b₂ * W.b₄ ^ 2 * W.b₈ ^ 4 +- + 68 * W.b₂ ^ 2 * W.b₆ * W.b₈ ^ 4 +- + 248 * W.b₄ ^ 3 * W.b₆ * W.b₈ ^ 3 + 3168 * W.b₄ * W.b₆ * W.b₈ ^ 4 +- + (-58 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 3) +- + 24 * W.b₂ * W.b₄ ^ 3 * W.b₆ ^ 2 * W.b₈ ^ 2 +- + 24 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 3 * W.b₈ ^ 2 +- + 122 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 4 * W.b₈ +- + 528 * W.b₂ * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 3) * Polynomial.X ^ 5 +- + Polynomial.C (664 * W.b₈ ^ 5 + (-W.b₂ ^ 4 * W.b₈ ^ 4) + (-64 * W.b₄ ^ 4 * W.b₆ ^ 4) +- + (-6 * W.b₂ ^ 2 * W.b₆ ^ 6) + 116 * W.b₄ * W.b₆ ^ 6 +- + 116 * W.b₄ ^ 4 * W.b₈ ^ 3 + 1500 * W.b₄ ^ 2 * W.b₈ ^ 4 +- + 2572 * W.b₆ ^ 4 * W.b₈ ^ 2 + (-W.b₂ ^ 3 * W.b₆ ^ 3 * W.b₈ ^ 2) +- + (-758 * W.b₄ ^ 2 * W.b₆ ^ 4 * W.b₈) +- + (-110 * W.b₂ * W.b₆ ^ 5 * W.b₈) +- + (-106 * W.b₄ ^ 3 * W.b₆ ^ 2 * W.b₈ ^ 2) +- + (-85 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 5) +- + (-26 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₈ ^ 3) +- + 12 * W.b₂ ^ 2 * W.b₄ * W.b₈ ^ 4 +- + 24 * W.b₄ ^ 5 * W.b₆ ^ 2 * W.b₈ +- + 168 * W.b₂ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 3 +- + 1610 * W.b₂ * W.b₆ * W.b₈ ^ 4 +- + 10544 * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 3 +- + (-27 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 2) +- + (-26 * W.b₂ ^ 3 * W.b₄ * W.b₆ * W.b₈ ^ 3) +- + (-20 * W.b₂ * W.b₄ ^ 4 * W.b₆ * W.b₈ ^ 2) +- + 76 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 4 * W.b₈ +- + 78 * W.b₂ * W.b₄ * W.b₆ ^ 3 * W.b₈ ^ 2 +- + 156 * W.b₂ * W.b₄ ^ 3 * W.b₆ ^ 3 * W.b₈ +- + 484 * W.b₂ * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 3) * Polynomial.X ^ 6 +- + Polynomial.C (-336 * W.b₆ ^ 5 * W.b₈ + (-16 * W.b₄ ^ 5 * W.b₆ ^ 3) +- + (-4 * W.b₂ ^ 3 * W.b₈ ^ 4) + 48 * W.b₂ * W.b₆ ^ 6 +- + 516 * W.b₄ ^ 2 * W.b₆ ^ 5 + 6552 * W.b₆ * W.b₈ ^ 4 +- + (-1032 * W.b₄ ^ 3 * W.b₆ ^ 3 * W.b₈) +- + (-68 * W.b₂ * W.b₄ ^ 3 * W.b₆ ^ 4) +- + (-20 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 5) +- + (-12 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₈ ^ 3) +- + (-4 * W.b₂ ^ 4 * W.b₆ * W.b₈ ^ 3) +- + 12 * W.b₂ ^ 3 * W.b₆ ^ 4 * W.b₈ +- + 80 * W.b₂ ^ 2 * W.b₆ ^ 3 * W.b₈ ^ 2 +- + 212 * W.b₄ ^ 4 * W.b₆ * W.b₈ ^ 2 +- + 304 * W.b₂ * W.b₄ ^ 3 * W.b₈ ^ 3 + 1272 * W.b₂ * W.b₄ * W.b₈ ^ 4 +- + 5552 * W.b₂ * W.b₆ ^ 2 * W.b₈ ^ 3 +- + 11312 * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 3 +- + 12336 * W.b₄ * W.b₆ ^ 3 * W.b₈ ^ 2 +- + (-472 * W.b₂ * W.b₄ * W.b₆ ^ 4 * W.b₈) +- + (-44 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₆ * W.b₈ ^ 2) +- + (-28 * W.b₂ ^ 3 * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 2) +- + 64 * W.b₂ * W.b₄ ^ 4 * W.b₆ ^ 2 * W.b₈ +- + 108 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 2 +- + 116 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ ^ 3 * W.b₈ +- + 240 * W.b₂ ^ 2 * W.b₄ * W.b₆ * W.b₈ ^ 3) * Polynomial.X ^ 7 +- + Polynomial.C (-883 * W.b₆ ^ 6 + (-W.b₂ ^ 3 * W.b₆ ^ 5) + 198 * W.b₄ ^ 5 * W.b₈ ^ 2 +- + 216 * W.b₂ ^ 2 * W.b₈ ^ 4 + 790 * W.b₄ ^ 3 * W.b₆ ^ 4 +- + 4720 * W.b₄ ^ 3 * W.b₈ ^ 3 + 5526 * W.b₄ * W.b₈ ^ 4 +- + 26236 * W.b₆ ^ 2 * W.b₈ ^ 3 + (-918 * W.b₄ ^ 4 * W.b₆ ^ 2 * W.b₈) +- + (-270 * W.b₄ * W.b₆ ^ 4 * W.b₈) +- + (-70 * W.b₂ ^ 2 * W.b₆ ^ 4 * W.b₈) +- + (-22 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ ^ 4) +- + (-20 * W.b₂ * W.b₄ ^ 4 * W.b₆ ^ 3) +- + (-6 * W.b₂ ^ 4 * W.b₆ ^ 2 * W.b₈ ^ 2) +- + (-2 * W.b₂ ^ 4 * W.b₄ * W.b₈ ^ 3) +- + 32 * W.b₂ ^ 3 * W.b₆ * W.b₈ ^ 3 +- + 300 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₈ ^ 3 +- + 354 * W.b₂ * W.b₄ * W.b₆ ^ 5 + 7316 * W.b₂ * W.b₆ ^ 3 * W.b₈ ^ 2 +- + 21030 * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 2 +- + (-1346 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 3 * W.b₈) +- + (-33 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 2) +- + 30 * W.b₂ ^ 3 * W.b₄ * W.b₆ ^ 3 * W.b₈ +- + 54 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₆ ^ 2 * W.b₈ +- + 72 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 2 +- + 588 * W.b₂ * W.b₄ ^ 3 * W.b₆ * W.b₈ ^ 2 +- + 10848 * W.b₂ * W.b₄ * W.b₆ * W.b₈ ^ 3) * Polynomial.X ^ 8 +- + Polynomial.C (-4494 * W.b₄ * W.b₆ ^ 5 + 62 * W.b₂ ^ 2 * W.b₆ ^ 5 +- + 506 * W.b₄ ^ 4 * W.b₆ ^ 3 +- + 1870 * W.b₂ * W.b₈ ^ 4 + 47004 * W.b₆ ^ 3 * W.b₈ ^ 2 +- + (-312 * W.b₄ ^ 5 * W.b₆ * W.b₈) +- + (-8 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₆ ^ 3) +- + (-2 * W.b₂ ^ 3 * W.b₄ * W.b₆ ^ 4) +- + (-2 * W.b₂ ^ 3 * W.b₆ ^ 2 * W.b₈ ^ 2) +- + 2 * W.b₂ ^ 4 * W.b₆ ^ 3 * W.b₈ +- + 136 * W.b₂ ^ 3 * W.b₄ * W.b₈ ^ 3 +- + 550 * W.b₂ * W.b₄ ^ 4 * W.b₈ ^ 2 +- + 706 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 4 +- + 1610 * W.b₄ ^ 2 * W.b₆ ^ 3 * W.b₈ +- + 2042 * W.b₂ * W.b₆ ^ 4 * W.b₈ +- + 2344 * W.b₂ ^ 2 * W.b₆ * W.b₈ ^ 3 +- + 7136 * W.b₂ * W.b₄ ^ 2 * W.b₈ ^ 3 +- + 18064 * W.b₄ ^ 3 * W.b₆ * W.b₈ ^ 2 +- + 49456 * W.b₄ * W.b₆ * W.b₈ ^ 3 +- + (-1592 * W.b₂ * W.b₄ ^ 3 * W.b₆ ^ 2 * W.b₈) +- + (-600 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 3 * W.b₈) +- + (-10 * W.b₂ ^ 4 * W.b₄ * W.b₆ * W.b₈ ^ 2) +- + 18 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ +- + 546 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 2 +- + 21708 * W.b₂ * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 2) * Polynomial.X ^ 9 +- + Polynomial.C (3532 * W.b₈ ^ 4 + (-9537 * W.b₄ ^ 2 * W.b₆ ^ 4) +- + (-936 * W.b₂ * W.b₆ ^ 5) +- + 24 * W.b₂ ^ 4 * W.b₈ ^ 3 + 114 * W.b₄ ^ 5 * W.b₆ ^ 2 +- + 6304 * W.b₄ ^ 4 * W.b₈ ^ 2 + 27864 * W.b₄ ^ 2 * W.b₈ ^ 3 +- + 35644 * W.b₆ ^ 4 * W.b₈ + (-W.b₂ ^ 5 * W.b₆ * W.b₈ ^ 2) +- + (-W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₆ ^ 3) +- + (-98 * W.b₂ ^ 3 * W.b₆ ^ 3 * W.b₈) +- + 192 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 4 +- + 532 * W.b₂ * W.b₄ ^ 3 * W.b₆ ^ 3 +- + 578 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₈ ^ 2 +- + 3608 * W.b₂ ^ 2 * W.b₄ * W.b₈ ^ 3 +- + 4818 * W.b₂ ^ 2 * W.b₆ ^ 2 * W.b₈ ^ 2 +- + 5778 * W.b₄ ^ 3 * W.b₆ ^ 2 * W.b₈ +- + 19028 * W.b₂ * W.b₆ * W.b₈ ^ 3 +- + 131228 * W.b₄ * W.b₆ ^ 2 * W.b₈ ^ 2 +- + (-966 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈) +- + (-598 * W.b₂ * W.b₄ ^ 4 * W.b₆ * W.b₈) +- + 2 * W.b₂ ^ 4 * W.b₄ * W.b₆ ^ 2 * W.b₈ +- + 222 * W.b₂ ^ 3 * W.b₄ * W.b₆ * W.b₈ ^ 2 +- + 6986 * W.b₂ * W.b₄ * W.b₆ ^ 3 * W.b₈ +- + 26712 * W.b₂ * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 2) * Polynomial.X ^ 10 +- + Polynomial.C (8884 * W.b₆ ^ 5 + (-9916 * W.b₄ ^ 3 * W.b₆ ^ 3) +- + 12 * W.b₂ ^ 3 * W.b₆ ^ 4 +- + 640 * W.b₂ ^ 3 * W.b₈ ^ 3 + 36848 * W.b₆ * W.b₈ ^ 3 +- + (-4596 * W.b₂ * W.b₄ * W.b₆ ^ 4) +- + 36 * W.b₂ ^ 4 * W.b₆ * W.b₈ ^ 2 +- + 132 * W.b₂ * W.b₄ ^ 4 * W.b₆ ^ 2 +- + 180 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ ^ 3 +- + 288 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₈ ^ 2 +- + 1968 * W.b₂ ^ 2 * W.b₆ ^ 3 * W.b₈ +- + 6096 * W.b₄ ^ 4 * W.b₆ * W.b₈ +- + 11592 * W.b₂ * W.b₄ ^ 3 * W.b₈ ^ 2 +- + 24400 * W.b₂ * W.b₄ * W.b₈ ^ 3 +- + 49728 * W.b₂ * W.b₆ ^ 2 * W.b₈ ^ 2 +- + 124416 * W.b₄ * W.b₆ ^ 3 * W.b₈ +- + 134568 * W.b₄ ^ 2 * W.b₆ * W.b₈ ^ 2 +- + (-408 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₆ * W.b₈) +- + (-240 * W.b₂ ^ 3 * W.b₄ * W.b₆ ^ 2 * W.b₈) +- + 12480 * W.b₂ ^ 2 * W.b₄ * W.b₆ * W.b₈ ^ 2 +- + 13560 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈) * Polynomial.X ^ 11 +- + Polynomial.C (-4902 * W.b₄ ^ 4 * W.b₆ ^ 2 + (-545 * W.b₂ ^ 2 * W.b₆ ^ 4) +- + 1932 * W.b₄ ^ 5 * W.b₈ + 5736 * W.b₂ ^ 2 * W.b₈ ^ 3 +- + 35344 * W.b₄ * W.b₆ ^ 4 + 45144 * W.b₄ * W.b₈ ^ 3 +- + 46752 * W.b₄ ^ 3 * W.b₈ ^ 2 + 105356 * W.b₆ ^ 2 * W.b₈ ^ 2 +- + (-7315 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 3) +- + (-18 * W.b₂ ^ 4 * W.b₆ ^ 2 * W.b₈) +- + 18 * W.b₂ ^ 3 * W.b₄ * W.b₆ ^ 3 +- + 50 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₆ ^ 2 +- + 68 * W.b₂ ^ 4 * W.b₄ * W.b₈ ^ 2 +- + 1960 * W.b₂ ^ 3 * W.b₆ * W.b₈ ^ 2 +- + 7602 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₈ ^ 2 +- + 45016 * W.b₂ * W.b₆ ^ 3 * W.b₈ +- + 173648 * W.b₄ ^ 2 * W.b₆ ^ 2 * W.b₈ +- + (-118 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₆ * W.b₈) +- + 7284 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 2 * W.b₈ +- + 12548 * W.b₂ * W.b₄ ^ 3 * W.b₆ * W.b₈ +- + 107360 * W.b₂ * W.b₄ * W.b₆ * W.b₈ ^ 2) * Polynomial.X ^ 12 +- + Polynomial.C (-912 * W.b₄ ^ 5 * W.b₆ + 6 * W.b₂ ^ 5 * W.b₈ ^ 2 +- + 12024 * W.b₂ * W.b₆ ^ 4 +- + 20232 * W.b₂ * W.b₈ ^ 3 + 59770 * W.b₄ ^ 2 * W.b₆ ^ 3 +- + 112576 * W.b₆ ^ 3 * W.b₈ + (-4656 * W.b₂ * W.b₄ ^ 3 * W.b₆ ^ 2) +- + (-1600 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 3) +- + 6 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₆ ^ 2 +- + 1206 * W.b₂ ^ 3 * W.b₆ ^ 2 * W.b₈ +- + 2124 * W.b₂ ^ 3 * W.b₄ * W.b₈ ^ 2 +- + 3892 * W.b₂ * W.b₄ ^ 4 * W.b₈ +- + 22208 * W.b₂ ^ 2 * W.b₆ * W.b₈ ^ 2 +- + 54192 * W.b₂ * W.b₄ ^ 2 * W.b₈ ^ 2 +- + 108840 * W.b₄ ^ 3 * W.b₆ * W.b₈ +- + 217088 * W.b₄ * W.b₆ * W.b₈ ^ 2 +- + (-12 * W.b₂ ^ 4 * W.b₄ * W.b₆ * W.b₈) +- + 8514 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ * W.b₈ +- + 128256 * W.b₂ * W.b₄ * W.b₆ ^ 2 * W.b₈) * Polynomial.X ^ 13 +- + Polynomial.C (24720 * W.b₈ ^ 3 + 39812 * W.b₆ ^ 4 + (-69 * W.b₂ ^ 3 * W.b₆ ^ 3) +- + 210 * W.b₂ ^ 4 * W.b₈ ^ 2 + 24836 * W.b₄ ^ 4 * W.b₈ +- + 51722 * W.b₄ ^ 3 * W.b₆ ^ 2 + 101464 * W.b₄ ^ 2 * W.b₈ ^ 2 +- + (-1395 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ ^ 2) +- + (-1026 * W.b₂ * W.b₄ ^ 4 * W.b₆) +- + 2946 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₈ +- + 20544 * W.b₂ ^ 2 * W.b₄ * W.b₈ ^ 2 +- + 24296 * W.b₂ ^ 2 * W.b₆ ^ 2 * W.b₈ +- + 40930 * W.b₂ * W.b₄ * W.b₆ ^ 3 +- + 85700 * W.b₂ * W.b₆ * W.b₈ ^ 2 + 308736 * W.b₄ * W.b₆ ^ 2 * W.b₈ +- + 2394 * W.b₂ ^ 3 * W.b₄ * W.b₆ * W.b₈ +- + 116300 * W.b₂ * W.b₄ ^ 2 * W.b₆ * W.b₈) * Polynomial.X ^ 14 +- + Polynomial.C (2472 * W.b₂ ^ 3 * W.b₈ ^ 2 + 7232 * W.b₂ ^ 2 * W.b₆ ^ 3 +- + 22172 * W.b₄ ^ 4 * W.b₆ + 108016 * W.b₆ * W.b₈ ^ 2 +- + 132592 * W.b₄ * W.b₆ ^ 3 + (-380 * W.b₂ ^ 2 * W.b₄ ^ 3 * W.b₆) +- + (-100 * W.b₂ ^ 3 * W.b₄ * W.b₆ ^ 2) +- + 236 * W.b₂ ^ 4 * W.b₆ * W.b₈ +- + 1060 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₈ +- + 33232 * W.b₂ * W.b₄ ^ 3 * W.b₈ +- + 50972 * W.b₂ * W.b₄ ^ 2 * W.b₆ ^ 2 +- + 72816 * W.b₂ * W.b₄ * W.b₈ ^ 2 +- + 110896 * W.b₂ * W.b₆ ^ 2 * W.b₈ +- + 263536 * W.b₄ ^ 2 * W.b₆ * W.b₈ +- + 40912 * W.b₂ ^ 2 * W.b₄ * W.b₆ * W.b₈) * Polynomial.X ^ 15 +- + Polynomial.C (3710 * W.b₄ ^ 5 + 8 * W.b₂ ^ 4 * W.b₆ ^ 2 +- + 12320 * W.b₂ ^ 2 * W.b₈ ^ 2 +- + 43908 * W.b₂ * W.b₆ ^ 3 + 70896 * W.b₄ ^ 3 * W.b₈ +- + 85422 * W.b₄ * W.b₈ ^ 2 +- + 149190 * W.b₆ ^ 2 * W.b₈ + 157539 * W.b₄ ^ 2 * W.b₆ ^ 2 +- + (-37 * W.b₂ ^ 3 * W.b₄ ^ 2 * W.b₆) +- + 182 * W.b₂ ^ 4 * W.b₄ * W.b₈ +- + 4632 * W.b₂ ^ 3 * W.b₆ * W.b₈ +- + 16268 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₈ +- + 16744 * W.b₂ ^ 2 * W.b₄ * W.b₆ ^ 2 +- + 27268 * W.b₂ * W.b₄ ^ 3 * W.b₆ +- + 175520 * W.b₂ * W.b₄ * W.b₆ * W.b₈) * Polynomial.X ^ 16 +- + Polynomial.C (65230 * W.b₆ ^ 3 + 12 * W.b₂ ^ 5 * W.b₈ + 1794 * W.b₂ ^ 3 * W.b₆ ^ 2 +- + 5302 * W.b₂ * W.b₄ ^ 4 + 27230 * W.b₂ * W.b₈ ^ 2 +- + 79828 * W.b₄ ^ 3 * W.b₆ +- + 6 * W.b₂ ^ 4 * W.b₄ * W.b₆ + 3432 * W.b₂ ^ 3 * W.b₄ * W.b₈ +- + 12422 * W.b₂ ^ 2 * W.b₄ ^ 2 * W.b₆ +- + 27992 * W.b₂ ^ 2 * W.b₆ * W.b₈ +- + 66496 * W.b₂ * W.b₄ ^ 2 * W.b₈ + 97734 * W.b₂ * W.b₄ * W.b₆ ^ 2 +- + 223992 * W.b₄ * W.b₆ * W.b₈) * Polynomial.X ^ 17 +- + Polynomial.C (14684 * W.b₄ ^ 4 + 21868 * W.b₈ ^ 2 + W.b₂ ^ 5 * W.b₆ +- + 264 * W.b₂ ^ 4 * W.b₈ +- + 2982 * W.b₂ ^ 2 * W.b₄ ^ 3 + 14687 * W.b₂ ^ 2 * W.b₆ ^ 2 +- + 81548 * W.b₄ ^ 2 * W.b₈ + 139902 * W.b₄ * W.b₆ ^ 2 +- + 2466 * W.b₂ ^ 3 * W.b₄ * W.b₆ + 20136 * W.b₂ ^ 2 * W.b₄ * W.b₈ +- + 67922 * W.b₂ * W.b₆ * W.b₈ +- + 70114 * W.b₂ * W.b₄ ^ 2 * W.b₆) * Polynomial.X ^ 18 +- + Polynomial.C (180 * W.b₂ ^ 4 * W.b₆ + 824 * W.b₂ ^ 3 * W.b₄ ^ 2 +- + 1984 * W.b₂ ^ 3 * W.b₈ +- + 16324 * W.b₂ * W.b₄ ^ 3 + 40320 * W.b₂ * W.b₆ ^ 2 +- + 57464 * W.b₆ * W.b₈ +- + 97500 * W.b₄ ^ 2 * W.b₆ + 20040 * W.b₂ ^ 2 * W.b₄ * W.b₆ +- + 47624 * W.b₂ * W.b₄ * W.b₈) * Polynomial.X ^ 19 +- + Polynomial.C (22160 * W.b₄ ^ 3 + 36374 * W.b₆ ^ 2 + 112 * W.b₂ ^ 4 * W.b₄ +- + 1874 * W.b₂ ^ 3 * W.b₆ + 6675 * W.b₂ ^ 2 * W.b₄ ^ 2 +- + 6828 * W.b₂ ^ 2 * W.b₈ +- + 39492 * W.b₄ * W.b₈ +- + 54192 * W.b₂ * W.b₄ * W.b₆) * Polynomial.X ^ 20 +- + Polynomial.C (6 * W.b₂ ^ 5 + 1194 * W.b₂ ^ 3 * W.b₄ + 7420 * W.b₂ ^ 2 * W.b₆ +- + 11068 * W.b₂ * W.b₈ + 17840 * W.b₂ * W.b₄ ^ 2 +- + 48224 * W.b₄ * W.b₆) * Polynomial.X ^ 21 +- + Polynomial.C (79 * W.b₂ ^ 4 + 6872 * W.b₈ + 15692 * W.b₄ ^ 2 +- + 4724 * W.b₂ ^ 2 * W.b₄ +- + 12978 * W.b₂ * W.b₆) * Polynomial.X ^ 22 +- + Polynomial.C (412 * W.b₂ ^ 3 + 8440 * W.b₆ + 8216 * W.b₂ * W.b₄) * Polynomial.X ^ 23 +- + Polynomial.C (1064 * W.b₂ ^ 2 + 5306 * W.b₄) * Polynomial.X ^ 24 +- + Polynomial.C (1362 * W.b₂) * Polynomial.X ^ 25 +- + Polynomial.C 692 * Polynomial.X ^ 26) * b_relation_poly W ++ (2 * W.Ψ₃ ^ 3 * W.preΨ₄ - W.preΨ₄ ^ 2 * W.Ψ₂Sq ^ 2) * wronskian_aux_three W + ++ (W.preΨ₄ ^ 3 * W.Ψ₂Sq ^ 3) * wronskian_derivative_three W + ++ (W.Ψ₃ ^ 3 * W.preΨ₄ ^ 2 - 2 * W.preΨ₄ ^ 3 * W.Ψ₂Sq ^ 2) * ++ wronskian_three_derivative_two W + + end HasseWeil +diff --git a/projects/HasseWeil/HasseWeil/Foundation/WronskianAux/CNorm.lean b/projects/HasseWeil/HasseWeil/Foundation/WronskianAux/CNorm.lean +index 4dee067bc..528b604a5 100644 +--- a/projects/HasseWeil/HasseWeil/Foundation/WronskianAux/CNorm.lean ++++ b/projects/HasseWeil/HasseWeil/Foundation/WronskianAux/CNorm.lean +@@ -1,25 +1,11 @@ + import Mathlib.Algebra.Polynomial.Basic + + /-! +-# C-normalization simp set for polynomial ring tactics ++# Normalization of polynomial coefficients + +-`Polynomial.derivative_pow` produces `C ((n : ℕ) : R) * p^(n-1) * derivative p`, +-where `((n : ℕ) : R)` is `Nat.cast n`. On the other side of an identity, +-`Polynomial.C` is often applied to literals `(n : R)` which use `OfNat.ofNat`. +-`ring` sees `C (Nat.cast n : R)` and `C (OfNat.ofNat n : R)` as distinct atoms, +-blocking cancellation. +- +-The pair `Nat.cast_ofNat` (already `@[simp]` in mathlib) plus +-`Polynomial.C_ofNat` (not `@[simp]`) normalizes every `C k` for numeric `k` to +-the polynomial literal `(k : Polynomial R)`. `Polynomial.C_ofNat` must be +-explicitly included in `simp only` at call sites; this file just documents the +-intended usage. +- +-Typical use: +-``` +-simp only [..., Polynomial.C_ofNat, Polynomial.C_mul, Polynomial.C_sub, +- Polynomial.C_pow, Polynomial.C_add, ...] +-``` +-(`Nat.cast_ofNat` fires automatically since it is `@[simp]` — `simp only` +-actually does not pick it up, so include it too for safety.) ++`Polynomial.derivative_pow` introduces coefficients of the form ++`Polynomial.C (Nat.cast n : R)`. Numerical coefficients may instead be written ++with `OfNat.ofNat`, which polynomial ring normalization can treat as a distinct ++atom. Explicit simplification by `Nat.cast_ofNat` and `Polynomial.C_ofNat` ++identifies both forms with the corresponding polynomial numeral. + -/ +diff --git a/projects/HasseWeil/HasseWeil/Foundation/WronskianAux/Prefix.lean b/projects/HasseWeil/HasseWeil/Foundation/WronskianAux/Prefix.lean +new file mode 100644 +index 000000000..b1df73ddd +--- /dev/null ++++ b/projects/HasseWeil/HasseWeil/Foundation/WronskianAux/Prefix.lean +@@ -0,0 +1,62 @@ ++import Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic ++import Mathlib.Algebra.Polynomial.Derivation ++import Mathlib.Tactic.LinearCombination ++import HasseWeil.Foundation.WronskianAux.CNorm ++ ++ ++/- ++Copyright (c) 2026 Chris Birkbeck. All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Chris Birkbeck ++-/ ++ ++/-! ++# Third Wronskian identity ++ ++The third division-polynomial Wronskian identity follows from the Weierstrass ++coefficient relation. Its polynomial multiplier has degree eight. ++-/ ++ ++open WeierstrassCurve Polynomial ++ ++namespace HasseWeil ++ ++variable {R : Type*} [CommRing R] (W : WeierstrassCurve R) ++ ++-- The Weierstrass coefficient relation lifted to the polynomial ring, with ++-- coefficient maps distributed for polynomial normalization. ++lemma wronskian_b_relation_poly : ++ ((4 : R[X]) * Polynomial.C W.b₈ : R[X]) = ++ Polynomial.C W.b₂ * Polynomial.C W.b₆ - Polynomial.C W.b₄ ^ 2 := by ++ simpa [Polynomial.C_ofNat] using congrArg Polynomial.C W.b_relation ++ ++/-- Wronskian auxiliary identity, `m = 3` case (Silverman III.3.7). ++`4·Ψ₃³ + 2·preΨ₄·Ψ₂Sq·Ψ₃' − (preΨ₄·Ψ₂Sq)'·Ψ₃ ++= 3·preΨ₄·Ψ₂Sq² − 3·preΨ₄²`. ++ ++Multiplier: `M = b₈² + 4b₆b₈·X + 6b₄b₈·X² + 4b₂b₈·X³ + (b₂b₆ + 34b₈)·X⁴ ++ + 36b₆·X⁵ + 18b₄·X⁶ + 4b₂·X⁷ + 9·X⁸`. -/ ++lemma wronskian_aux_three : ++ 4 * W.Ψ₃ ^ 3 + 2 * W.preΨ₄ * W.Ψ₂Sq * Polynomial.derivative W.Ψ₃ - ++ Polynomial.derivative (W.preΨ₄ * W.Ψ₂Sq) * W.Ψ₃ = ++ Polynomial.C 3 * W.preΨ₄ * W.Ψ₂Sq ^ 2 - Polynomial.C 3 * W.preΨ₄ ^ 2 := by ++ linear_combination (norm := ( ++ simp only [Ψ₃, preΨ₄, Ψ₂Sq, ++ Polynomial.derivative_add, Polynomial.derivative_sub, ++ Polynomial.derivative_mul, Polynomial.derivative_pow, Polynomial.derivative_X, ++ Polynomial.derivative_C, Polynomial.derivative_ofNat, ++ Polynomial.C_add, Polynomial.C_sub, Polynomial.C_mul, Polynomial.C_pow, ++ Polynomial.C_ofNat, Nat.cast_ofNat] ++ ring)) ++ (Polynomial.C (W.b₈ ^ 2) ++ + Polynomial.C (4 * W.b₆ * W.b₈) * Polynomial.X ++ + Polynomial.C (6 * W.b₄ * W.b₈) * Polynomial.X ^ 2 ++ + Polynomial.C (4 * W.b₂ * W.b₈) * Polynomial.X ^ 3 ++ + Polynomial.C (W.b₂ * W.b₆ + 34 * W.b₈) * Polynomial.X ^ 4 ++ + Polynomial.C (36 * W.b₆) * Polynomial.X ^ 5 ++ + Polynomial.C (18 * W.b₄) * Polynomial.X ^ 6 ++ + Polynomial.C (4 * W.b₂) * Polynomial.X ^ 7 ++ + Polynomial.C 9 * Polynomial.X ^ 8) * wronskian_b_relation_poly W ++ ++ ++end HasseWeil +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/Infrastructure.lean b/projects/HasseWeil/HasseWeil/HasseBound/Infrastructure.lean +index 9facfb997176c5ac380d29e70848729672edc3fd..8c198b73959a7180a7e5398bfbe82ea2777afe6b 100644 +GIT binary patch +delta 2643 +zcmaJ@ZHN_B7-sHj!hk6$mLKUG;^Nw!yRH*r>&*IHM1?##LO9-Dj4?3|gq +zd#$*d1x3);5sJcemo&-BWd8J{K&U_Vp(|}vWGF&lko}ShEa*KmcV_QOiXxZs%=^CQ +zd7qCt_HoPEliDZR9rbmNLtUR*Pz;#mQ_hScC61j1n^vjd9+=Dq{81vT2Gl0Zr#>Y@ +z*LRf3P49ppuIZTt>QKK1rdJ9ocsvVRsN)b1T#qt~x~7wq7FfG(>q&8oS6nWzI%iPi +zUL|l$0U~f+rv^SYqs*q3=@T0^m_iU3qCO)+G!2#0yEqcF7)ecO@kQdI*nn^@X*SC`*@d&esSS9O=9^9CP?(Xi~iYxo&%B-%SP?NYG +z=S9H3y}6EDhiVZ$UhnY&VKflna>{(e;sNuM@oI7iURy+c0iGETXhf%=%q#fEbIVjz +z!fW?EqitL_>=P!UODG_*PYe;lj(t2Hl*)~3xPjvoOzWv=NpaJP=|Y4gL+ryRmQ2rt +z*Ve#P9C>tnwj6E0OU_u9t3w`KC=cp-yAikZ`4HAjm%3h505x^abrfoZG3EU<~fhm~;UPK{xC +z#I=mPWt{CJ9>@RpXcbRZ$tu;-Dx*LwA0GRXP}qkuyfB$ZJG`^ca_Nf1J~2vpP47*se;&T +zz~h0pm!LgV8-!FSdt@-69yT4hQK0W0ZBaNu)D +z)e`=@o>WOc(qKX$Tz!v4an@};fXmg+I1X}d!zz# +zY;d8xNaxFyrB->-8xMc=AI^jy4fSa9>b^blcr8B_AqS8jj)Q!1-#ksn=by`~Pv4MR +zpIyC75f%E@qm9&D0-O4q`HH$k@*q?WMVZRWFScnA(wE=Q$OEsu8G5hI(L(L@F)e$$ +z8dezv0?N3Q0+}zLm#s6D@>7@2L3sVpzoE=ab-&qla5F +zSmn=mLA&Qx@5#rG&dWBpH599=rlU*=Su(Kn{K2Jb+uG2YmTqesz;dTY7HeI%D%XuR +zwzMZXJ?TDKWep4ldf*Y*hK1zldxz!GV=twi@BsAXb3X4xPh=$5Es|tRvF}V(O&p@4 +z4S6Sz9AD57yppTyU^;O8$3)t&$U18{^T>&RwZ*rZSur1-D)3B4!pS+ylzk}vS|*x^ +z+A~)2NePYABd&)6V18sMc!fjZh`C;6bZpN`2bLKbU&P}9ceghX-5WLPMqZrC2{A`J +zz%z>6!3;)ALbFr_)Kj-{8p8yqH$Lsv>YWV7h&=#r7i&~yvgHISs??ito|Q15TueDq +zbkH$S{;8f(8*zA@b$iJ=&S(-3?u +zJK;Hz6({+r3tW$AxYKPM1Buae(Pa4W%()gVO4vAE@0=3ZvNJwc&cATHBl%cLnkkAm +z?uM-UpU9S@-<@p=>oq+wekl*|QWLe99pINw8v2G!k>>H2$j#q+B>6~@zkUC=oc6=Q +F{{V?d-7EkA + +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/PointCount.lean b/projects/HasseWeil/HasseWeil/HasseBound/PointCount.lean +index e004de056..c8fa5b0d3 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/PointCount.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/PointCount.lean +@@ -149,7 +149,7 @@ theorem card_kernel_eq_pointCount_of_kernel_eq_top + + /-- **Sub-helper III-4-015-S3** (fiber witness via degree = pointCount): + under separability + `β.degree = pointCount`, the fiber witness for the +-Hasse bound consumer ships axiom-clean. ++Hasse bound consumer exists. + + Proof chain: + 1. `β.degree = pointCount` (input). +@@ -215,7 +215,7 @@ omit [Fintype K] in + given `Aut(K(E₁)/α*K(E₂)) ≃ α.kernel` (the substantive Galois-correspondence + content for elliptic isogenies) and a witness for `Nat.card Aut = α.degree` + (the IsGalois card_aut_eq_finrank applied to our specific algebra), derive +-`Nat.card α.kernel = α.degree` axiom-clean. ++`Nat.card α.kernel = α.degree` . + + Reduces the III.4.10(a) wall to two named witnesses: + 1. `Nat.card Aut = α.degree` (IsGalois + finrank). +@@ -263,9 +263,9 @@ theorem card_aut_eq_degree_of_isGalois + W.toAffine.FunctionField _ _ β.toAlgebra.toModule) : + Nat.card (@AlgEquiv W.toAffine.FunctionField W.toAffine.FunctionField + W.toAffine.FunctionField _ _ _ β.toAlgebra β.toAlgebra) = β.degree := by +- letI := β.toAlgebra +- haveI := hgal +- haveI := hfin ++ let := β.toAlgebra ++ have := hgal ++ have := hfin + exact IsGalois.card_aut_eq_finrank W.toAffine.FunctionField W.toAffine.FunctionField + + /-- **Sub-helper III-4-015-S9** (full chain: IsGalois + bijection → fiber witness): +@@ -275,7 +275,7 @@ final closing-arc consumer. Takes: + - Aut ≃ β.kernel bijection (the substantive Galois-correspondence content). + + Produces the fiber witness used by the historical witness-parametric +-Hasse-bound route, axiom-clean. ++Hasse-bound route, . + + The cascade reduces T-III-4-015 to two named witnesses via this consumer: + 1. `IsGalois (α*K(E₂)) K(E₁)` (Mathlib has the structure; needs Normal). +@@ -346,7 +346,7 @@ theorem fiber_witness_via_inverse_witnesses + (aut_kernel_equiv_of_inverse_witnesses W β _ forward inverse + h_left_inv h_right_inv) + +-/-- **Forward map at k = 0** (axiom-clean): the translation by 0 is the identity ++/-- **Forward map at k = 0** (): the translation by 0 is the identity + algebra automorphism. -/ + noncomputable def aut_of_kernel_zero + {F : Type*} [Field F] [DecidableEq F] +@@ -354,7 +354,7 @@ noncomputable def aut_of_kernel_zero + W.toAffine.FunctionField ≃ₐ[F] W.toAffine.FunctionField := + AlgEquiv.refl + +-/-- **Forward map at k = 0 is the identity** (axiom-clean). -/ ++/-- **Forward map at k = 0 is the identity** (). -/ + @[simp] theorem aut_of_kernel_zero_apply + {F : Type*} [Field F] [DecidableEq F] + (W : WeierstrassCurve F) [W.toAffine.IsElliptic] +@@ -362,21 +362,9 @@ noncomputable def aut_of_kernel_zero + aut_of_kernel_zero W f = f := + rfl + +-/-- **Substantive partial forward-map construction** (Sub-helper III-4-015-S12): +-the forward map for the substantive cases requires the curve-translation +-algebra automorphism `τ_k : K(E) ≃ₐ[F] K(E)` defined by +-`τ_k(x_gen) = x-coord(P_gen + k)` and `τ_k(y_gen) = y-coord(P_gen + k)`. +- +-Construction parallels Worker A's `addPullbackAlgHom_negFrobenius`: +-1. Define `τ_k` via the addition formula (`addX`, `addY`). +-2. Show it's a K-algebra hom (well-defined modulo Weierstrass). +-3. Show it has inverse `τ_(-k)` (since τ is a group action). +-4. For k ∈ β.kernel, show `τ_k` fixes `β.pullback`'s image. +- +-This sub-helper takes the substantive `τ_k` AS A WITNESS — a precise +-statement of what's needed beyond what's currently in mathlib. The +-construction itself is ~200-300 LOC of `addCoordAlgHom`-style infrastructure +-applied to the translation map. -/ ++/-- A kernel-indexed family of translation algebra automorphisms. ++For a kernel point `k`, translation by `k` fixes the image of the pullback; ++the family is supplied as an explicit witness. -/ + noncomputable def aut_of_kernel_construction_witness + (β : Isogeny W.toAffine W.toAffine) + (translation_at : β.kernel → +@@ -400,7 +388,7 @@ noncomputable def kernelTranslateForward + kernelTranslateForward W β ⟨0, h_zero_mem⟩ = AlgEquiv.refl := rfl + + /-- **Layer 2 forward map under `β.toAlgebra`** (witness-parametric). +-Takes Worker A's `translateAlgEquivOfPoint W k.val` (an F-AlgEquiv) and ++Takes `translateAlgEquivOfPoint W k.val` (an F-AlgEquiv) and + the covariance identity `τ_k ∘ β.pullback = β.pullback` (provided as + hypothesis), and produces the `K(E)`-AlgEquiv (under `β.toAlgebra`) + consumed by the S10 bijection. -/ +@@ -425,7 +413,7 @@ noncomputable def kernelTranslateForwardAsAut + W.toAffine.FunctionField _ _ _ β.toAlgebra β.toAlgebra) := + fun k ↦ kernelTranslateAsAut W β k (h_invariance_family k) + +-/-- **`kernelTranslateAsAut` at `k = 0`** is the identity AlgEquiv (axiom-clean). ++/-- **`kernelTranslateAsAut` at `k = 0`** is the identity AlgEquiv (). + The `h_invariance` hypothesis at k = 0 is automatic since `τ_0 = refl`. -/ + @[simp] theorem kernelTranslateAsAut_zero + (β : Isogeny W.toAffine W.toAffine) +@@ -436,7 +424,7 @@ The `h_invariance` hypothesis at k = 0 is automatic since `τ_0 = refl`. -/ + kernelTranslateAsAut W β ⟨0, h_zero_mem⟩ h_invariance = + @AlgEquiv.refl W.toAffine.FunctionField W.toAffine.FunctionField + _ _ β.toAlgebra := by +- letI := β.toAlgebra ++ let := β.toAlgebra + apply AlgEquiv.ext + intro f + change translateAlgEquivOfPoint W (0 : W.toAffine.Point) f = f +@@ -474,6 +462,7 @@ omit [DecidableEq F] [W.toAffine.IsElliptic] in + (x : W.toAffine.FunctionField) : + x ∈ algHomFieldEqualizer W f g ↔ f x = g x := Iff.rfl + ++omit [DecidableEq F] in + /-- **Two `F`-AlgHoms `K(E) → K(E)` agreeing on `x_gen`, `y_gen` are equal**: + `K(E)` is generated over `F` by `x_gen` and `y_gen`. -/ + theorem algHom_ext_of_eq_on_xy [Fintype F] +@@ -553,7 +542,7 @@ theorem kernel_pullback_invariance_id + rw [translateAlgEquivOfPoint_zero] + rfl + +-/-- **`SMulCommClass` for Worker A's master action**: the translation ++/-- **Commuting scalar multiplication for the translation action**: the translation + action commutes with `F`-scalar multiplication because every + `translateAlgEquivOfPoint W k` is an F-AlgEquiv (hence F-linear). -/ + instance translateMulSemiringAction_smulCommClass : +@@ -564,7 +553,7 @@ instance translateMulSemiringAction_smulCommClass : + rw [Algebra.smul_def, Algebra.smul_def, map_mul, AlgEquiv.commutes] + + /-- **Restricted action**: `Multiplicative β.kernel` acts on `K(E)` via +-the inclusion `β.kernel → E.Point` composed with Worker A's master action ++the inclusion `β.kernel → E.Point` composed with the translation action + `translateMulSemiringAction`. -/ + noncomputable instance kernelMulSemiringAction + (β : Isogeny W.toAffine W.toAffine) : +@@ -632,12 +621,12 @@ theorem xy_family_zero + (β.pullback (y_gen W)) = β.pullback (y_gen W)) := + ⟨rfl, rfl⟩ + +-/-- **Layer 2 closure (witness-parametric on finrank match)**: under the ++/-- **Fixed-field equality from a rank equality**: under the + xy-covariance family + finrank equality, `β.pullback.fieldRange = + FixedPoints.intermediateField (Multiplicative β.kernel)`. + + Direct application of `IntermediateField.eq_of_le_of_finrank_eq'` to the +-forward inclusion (just shipped) plus the finrank-match witness. -/ ++forward inclusion plus the finrank-match witness. -/ + theorem pullback_fieldRange_eq_fixedField_of_finrank_match [Fintype F] + (β : Isogeny W.toAffine W.toAffine) + [hfindim : FiniteDimensional ↥β.pullback.fieldRange W.toAffine.FunctionField] +@@ -659,11 +648,11 @@ theorem pullback_fieldRange_eq_fixedField_of_finrank_match [Fintype F] + (pullback_fieldRange_le_fixedField_of_xy_family W β h_xy_family) + h_finrank_match + +-/-- **Layer 2 closure (Artin-machinery sourced)**: the finrank match ++/-- **Fixed-field equality from Artin's theorem**: the finrank match + witness can be sourced from Mathlib's `FixedPoints.finrank_eq_card` (which +-gives `[K(E) : FixedPoints] = |G|` axiom-clean from Faithful + Fintype) and ++gives `[K(E) : FixedPoints] = |G|` from Faithful + Fintype) and + the cardinality match `|β.kernel| = β.degree` (Silverman III.4.10(b), +-T-V-1-003 / V.1.3) plus the intrinsic relation ++V.1.3) plus the intrinsic relation + `[K(E) : β.pullback.fieldRange] = β.degree` (witness-parametric below). + + This is the **packaged Artin-route closure**: takes the Hasse-content card +@@ -707,11 +696,10 @@ theorem faithfulSMul_kernel_of_translate_inj + + /-- **`FaithfulSMul` (UNCONDITIONAL)**: discharges the witness in + `faithfulSMul_kernel_of_translate_inj` using +-`translateAlgEquivOfPoint_injective` (just shipped in `EC/TranslationOrd`). ++`translateAlgEquivOfPoint_injective` . + + Direct corollary: for any isogeny β over a finite field, the restricted +-action `kernelMulSemiringAction β` is faithful axiom-clean. This collapses +-the FaithfulSMul witness in the Layer-2 cascade — combined with finiteness ++action `kernelMulSemiringAction β` is faithful . Combined with finiteness + of β.kernel (over finite F), Mathlib's Artin machinery + (`FixedPoints.finrank_eq_card`) applies unconditionally. -/ + instance faithfulSMul_kernel +@@ -730,10 +718,10 @@ closure given the cardinality match `Fintype.card β.kernel = β.degree` + theorem finrank_pullback_fieldRange_eq_degree + (β : Isogeny W.toAffine W.toAffine) : + Module.finrank ↥β.pullback.fieldRange W.toAffine.FunctionField = β.degree := by +- letI inst1 : Algebra W.toAffine.FunctionField W.toAffine.FunctionField := β.toAlgebra +- letI inst_im : Algebra ↥β.pullback.fieldRange W.toAffine.FunctionField := ++ let inst1 : Algebra W.toAffine.FunctionField W.toAffine.FunctionField := β.toAlgebra ++ let inst_im : Algebra ↥β.pullback.fieldRange W.toAffine.FunctionField := + IntermediateField.toAlgebra _ +- letI mod_im : Module ↥β.pullback.fieldRange W.toAffine.FunctionField := ++ let mod_im : Module ↥β.pullback.fieldRange W.toAffine.FunctionField := + inst_im.toModule + change @Module.finrank ↥β.pullback.fieldRange W.toAffine.FunctionField _ _ mod_im = + β.degree +@@ -758,7 +746,7 @@ theorem finrank_pullback_fieldRange_eq_degree + exact (Algebra.finrank_eq_of_equiv_equiv i j h_compat).symm + + /-- **Layer 2 closure (UNCONDITIONAL on the intrinsic part)**: combines +-`pullback_fieldRange_eq_fixedField_of_finrank_match` with the just-shipped ++`pullback_fieldRange_eq_fixedField_of_finrank_match` with the + intrinsic finrank relation, leaving only the Hasse-content cardinality + match `Nat.card β.kernel = β.degree` as a witness. + +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/PoleDivisorFallback.lean b/projects/HasseWeil/HasseWeil/HasseBound/PoleDivisorFallback.lean +index 6c96651f4795880dc78a3532568e069e75c9f7d2..cc60cff7787880be5b3c3d19acf7c586481df8fa 100644 +GIT binary patch +delta 1398 +zcmaize{54#6vuP!>)P%i;@HNvI?EjcWp-m@#vX|aO7X*9>aTvBwdElvf41^%Bu^{&2kRwp!B?Qr$%Y#4-*{HxlMOve +zVJ^zVwn`cbl=4GQY;)1>!}au+mSr3_Kj&CN?d9)m|J{|_QR8eGO-oyaT`O${KoENeo4kz6A6TaT6=^v$1*)~t#uBT3~p_kQ%kd>S(Hjo +z9W6S(*Ga=xF~!ZBcwJ=5A^Y>wJ3R&RV34M!r)_g?dMy6uk|lbrEBD_ewN9?(J9|yw +z-G|SwqEoLF(i8I@mRbf*erWa}(Ef9)S?WcQm$3o7^vxev(($*vnRxX_z6Ys2oojt- +zdEc3sl4bJN$u&wAg=ycJ;q2JHXVF1$@bPn-opu@@y;zbb7n^wM;%h+1zI~KU6oHS8 +zRY4Vlic^h`NuV!Da8+$T)ae@-!?L@ev5Q@19j3ze3XkeP|S-?7Dz2 +zn9T8rYoCMPA^N|B&z$113-GCveKQSJqWm)a4MHw^5qo|HNY>xH8ps5C&57y +zG6})Peqv%v?mNOH62u{*6H~KD5Vv<>4O^zB#{)zU65Y}wxFewltgxYD5=&^2xN7J9 +zmm{;KLW|V=E6$KLnW=|x(&{vgM5q&ot+@POvU;3sP`9TSHaTjNI5GE=c-quGJ84KY +z*7RUH5HL(Bj2e2-hH8-zX*V@BZkdUIm5>pvWxCVT>ZlRv(&g)yE#zmBhADbgC0t}2~@5`h{X~C^j$8k=nJBuyqpoqcYxTp4;{%}zs^7iiS`&8{-6AJ5gYm$z83Gl +Hfdc3sx_cCT + +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/PoleDivisorTwoTorsion.lean b/projects/HasseWeil/HasseWeil/HasseBound/PoleDivisorTwoTorsion.lean +index 25f0c6948..31fbb612c 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/PoleDivisorTwoTorsion.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/PoleDivisorTwoTorsion.lean +@@ -6,49 +6,20 @@ Authors: Chris Birkbeck + import HasseWeil.HasseBound.PoleDivisorFallback + + /-! +-# Bridge at `addPullbackNumerator_negFrobenius` for 2-torsion (T-T21-2TORSION-BRIDGE) +- +-The non-2-torsion bridge `bridge_at_addPullbackNumerator_negFrobenius_of_non_2_tor` +-(`PoleDivisorFallback.lean:2353`) goes through `bridge_at_x_gen_of_non_2_tor` +-(`PoleDivisorFallback.lean:606`), which uses +-`ord_P_translateX_xy_eq_neg_two_of_non_2_tor` (`EC/TranslationOrd.lean:1379`) +-as the substantive `= -2` identity at `−T` (with `T` non-2-torsion). +- +-This file ships the **2-torsion analogue**: +-`ord_P (translateX_xy W xT yT) = -2` at the smooth point `−T = T` (where +-`−T = T` modulo `Nonsingular`-prop-irrelevance for 2-torsion), and +-propagates it to the base bridges and the full +-`bridge_at_addPullbackNumerator_negFrobenius` at 2-torsion. +- +-The chain is: +- +-* `ord_P_x_gen_sub_const_ge_two_at_2tor` — `ord_P (x_gen − xk) ≥ 2` from the +- curve identity `(y − yk)·A = (x − xk)·(B − a₁·yk)` at 2-torsion T with +- `ord_P (y − yk) = 1`, `ord_P A ≥ 1`, `ord_P (B − a₁·yk) = 0`. +-* `ord_P_A_eq_one_at_2tor` — `ord_P A = 1` exactly via strict comparison +- `ord_P (y − yk) = 1 < 2 ≤ ord_P (a₁·(x − xk))` in `A = (y − yk) + a₁·(x − xk)`. +-* `ord_P_translateSlope_xy_eq_neg_one_at_2tor` — `ord_P slope = −1` exactly +- via `slope = (B − a₁·yk) / A` with `ord = 0 − 1 = −1`. +-* `ord_P_translateX_xy_eq_neg_two_at_2tor` — `ord_P translateX_xy = −2` +- exactly via `translateX_xy = slope² + rest` with strict comparison. +-* `bridge_at_x_gen_of_2_tor` — bridge `ord_P (τ_{−T} x_gen) = ord_∞ x_gen`. +-* `bridge_at_x_gen_pow_card_of_2_tor` — bridge for `x_gen^q`. +-* `bridge_at_y_gen_of_2_tor` and `bridge_at_y_gen_pow_card_of_2_tor` — +- y-side analogues, derived via `translateY_xy` analysis. +-* `bridge_at_addPullbackNumerator_negFrobenius_of_2_tor` — the full Num +- bridge at 2-torsion via the dominant-T7 strict comparison. +- +-After this lands, the chain `T21 → T22 → T23 → T24` (L6 closer) is +-unblocked: `support_card_eq_pointCount_of_two_torsion_ord_witness` +-(`L6Witnesses.lean:497`) consumes the 2-torsion ord witness, and the +-T22 composer becomes unconditional. +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, II.1, III.2. +-* `tickets/hasse/T-T21-2TORSION-BRIDGE.md` — the spawned sub-ticket. +-* `EC/TranslationOrd.lean:2566+` — the 2-torsion `A`-factorisation and +- per-piece order bounds. ++# Orders of translated coordinates at smooth two-torsion points ++ ++At a smooth two-torsion point `T`, the curve identity ++`(y − y_T)A = (x − x_T)(B − a₁y_T)` gives `ord_T(x − x_T) ≥ 2`. ++The factorization `A = (y − y_T) + a₁(x − x_T)` then gives `ord_T A = 1`, ++so the translation slope has order `-1`. Strict comparison in the addition ++formulas yields orders `-2` and `-3` for the translated x- and y-coordinates. ++ ++These coordinate orders identify local orders after translation with orders at ++infinity, including powers, products, and the reduced addition numerator for ++negative Frobenius. In that numerator the term `x · (π*x)²`, of order `-2-4q`, ++strictly dominates the other terms. ++ ++References: Silverman, *The Arithmetic of Elliptic Curves*, II.1 and III.2. + -/ + + open WeierstrassCurve HasseWeil.Curves +@@ -76,7 +47,7 @@ private lemma pi_y_gen_ne_zero_aux (hq : 2 ≤ Fintype.card K) : + rw [ordAtInfty_negFrobeniusIsog_pullback_y_gen W hq] at h_top + exact WithTop.coe_ne_top h_top + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **`ord_P (x_gen − xk) ≥ 2` at smooth 2-torsion `T`** via the curve + identity `(y − yk)·A = (x − xk)·(B − a₁·yk)` and the ord facts at + 2-torsion. -/ +@@ -117,7 +88,9 @@ theorem ord_P_x_gen_sub_const_ge_two_at_2tor (xk yk : K) + (y_gen W + algebraMap K KE yk + + algebraMap K KE W.a₁ * x_gen W + algebraMap K KE W.a₃)) := by + rw [h_LHS_mul, h_yd_ord] +- exact add_le_add (le_refl _) h_A_ge ++ calc ++ ((2 : ℤ) : WithTop ℤ) = ((1 : ℤ) : WithTop ℤ) + ((1 : ℤ) : WithTop ℤ) := by norm_num ++ _ ≤ _ := add_le_add le_rfl h_A_ge + have h_RHS_ord : ((2 : ℤ) : WithTop ℤ) ≤ (W_smooth W).ord_P P + ((x_gen W - algebraMap K KE xk) * + (x_gen W ^ 2 + x_gen W * algebraMap K KE xk + +@@ -143,7 +116,7 @@ theorem ord_P_x_gen_sub_const_ge_two_at_2tor (xk yk : K) + rw [h_mul_eq, h_Bma_ord, add_zero] at h_RHS_ord + exact h_RHS_ord + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **`ord_P A = 1` exactly at smooth 2-torsion `T`** via strict comparison + `ord_P (y − yk) = 1 < 2 ≤ ord_P (a₁·(x − xk))` in the factorisation + `A = (y − yk) + a₁·(x − xk)`. -/ +@@ -185,7 +158,7 @@ theorem ord_P_A_eq_one_at_2tor (xk yk : K) + have h_add := SmoothPlaneCurve.ord_P_add_eq_of_lt h_strict + exact h_add.trans h_yd_ord + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **`ord_P slope = -1` exactly at smooth 2-torsion `T`** via + `slope = (B − a₁·yk) / A` with `ord = 0 − 1 = −1` (using the + sharpened `ord_P A = 1`). -/ +@@ -233,7 +206,7 @@ theorem ord_P_translateSlope_xy_eq_neg_one_at_2tor (xk yk : K) + rw [h_mul, h_inv, h_Bma_ord, h_A_ord, zero_add] + rfl + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **`ord_P (translateX_xy) = -2` exactly at smooth 2-torsion `T`**: + `translateX_xy = slope² + (a₁·slope − a₂ − x_gen − xk)`. With + `ord_P slope = −1` exactly, `ord_P (slope²) = −2`, and the rest has +@@ -383,7 +356,7 @@ theorem ord_T_translateAlgEquivOfPoint_neg_x_gen_eq_neg_two_at_2tor (xT yT : K) + omit [Fintype K] in + /-- **Bridge at `f = x_gen` for 2-torsion `T`** (clean version): the analog of + `bridge_at_x_gen_of_non_2_tor` for 2-torsion. Composes the 2-torsion `ord_T` +-value with the shipped `ordAtInfty_x_gen = -2`. -/ ++value with the `ordAtInfty_x_gen = -2`. -/ + theorem bridge_at_x_gen_of_2_tor (xT yT : K) + (h_ns : W.toAffine.Nonsingular xT yT) (h_2_tor : yT = W.toAffine.negY xT yT) : + (W_smooth W).ord_P (⟨xT, yT, h_ns⟩ : (W_smooth W).SmoothPoint) +@@ -474,7 +447,7 @@ theorem bridge_at_x_gen_sub_negFrobeniusIsog_pullback_x_gen_of_2_tor (xT yT : K) + exact bridge_at_x_gen_sub_x_gen_pow_card_of_2_tor W xT yT h_ns h_2_tor hq + + /-- **Bridge at `(x_gen - (negFrob).pullback x_gen)^2` (slope-denominator squared)** +-for 2-torsion `T`. Pow on the just-shipped bridge for `x_gen - negFrob.pullback x_gen`. ++for 2-torsion `T`. Pow on the bridge for `x_gen - negFrob.pullback x_gen`. + Mirrors `bridge_at_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq_of_non_2_tor`. -/ + theorem bridge_at_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq_of_2_tor (xT yT : K) + (h_ns : W.toAffine.Nonsingular xT yT) (h_2_tor : yT = W.toAffine.negY xT yT) +@@ -492,7 +465,7 @@ theorem bridge_at_x_gen_sub_negFrobeniusIsog_pullback_x_gen_sq_of_2_tor (xT yT : + W xT yT h_ns h_2_tor hq) 2 + + /-- **Bridge at `((negFrob).pullback x_gen)^2` for 2-torsion `T`**: pow on +-the just-shipped bridge for `(negFrob).pullback x_gen`. Mirrors the non-2-tor ++the bridge for `(negFrob).pullback x_gen`. Mirrors the non-2-tor + version (`bridge_at_negFrobeniusIsog_pullback_x_gen_sq_of_non_2_tor`). -/ + theorem bridge_at_negFrobeniusIsog_pullback_x_gen_sq_of_2_tor (xT yT : K) + (h_ns : W.toAffine.Nonsingular xT yT) (h_2_tor : yT = W.toAffine.negY xT yT) : +@@ -525,7 +498,7 @@ theorem bridge_at_x_gen_mul_negFrobeniusIsog_pullback_x_gen_sq_of_2_tor (xT yT : + (bridge_at_negFrobeniusIsog_pullback_x_gen_sq_of_2_tor W xT yT h_ns h_2_tor) + + /-- **Bridge at T6 = `x_gen² · (negFrob).pullback x_gen`** for 2-torsion `T`: +-mul on bridges for `x_gen²` (pow) and `(negFrob).pullback x_gen` (shipped). -/ ++mul on bridges for `x_gen²` (pow) and `(negFrob).pullback x_gen` . -/ + theorem bridge_at_x_gen_sq_mul_negFrobeniusIsog_pullback_x_gen_of_2_tor (xT yT : K) + (h_ns : W.toAffine.Nonsingular xT yT) (h_2_tor : yT = W.toAffine.negY xT yT) : + (W_smooth W).ord_P (⟨xT, yT, h_ns⟩ : (W_smooth W).SmoothPoint) +@@ -563,11 +536,10 @@ theorem bridge_at_x_gen_mul_negFrobeniusIsog_pullback_x_gen_of_2_tor (xT yT : K) + (bridge_at_x_gen_of_2_tor W xT yT h_ns h_2_tor) + (bridge_at_negFrobeniusIsog_pullback_x_gen_of_2_tor W xT yT h_ns h_2_tor) + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **`ord_P (x_gen − xk) = 2` EXACTLY at smooth 2-torsion `T`** via the curve + identity `(y − yk)·A = (x − xk)·(B − a₁·yk)` with the EXACT `ord_P A = 1` +-(shipped at `ord_P_A_eq_one_at_2tor`) and `ord_P (B − a₁·yk) = 0` (shipped at +-`ord_P_B_minus_a1_yk_eq_zero_at_2tor`). Tightens the shipped `≥ 2` to equality. -/ ++(given by `ord_P_A_eq_one_at_2tor`) and `ord_P (B − a₁·yk) = 0` (given by `ord_P_B_minus_a1_yk_eq_zero_at_2tor`). Tightens the `≥ 2` to equality. -/ + theorem ord_P_x_gen_sub_const_eq_two_at_2tor (xk yk : K) + (h_ns : W.toAffine.Nonsingular xk yk) (h_2_tor : yk = W.toAffine.negY xk yk) : + (W_smooth W).ord_P (negSmoothPoint W xk yk h_ns) +@@ -631,10 +603,9 @@ theorem ord_P_x_gen_sub_const_eq_two_at_2tor (xk yk : K) + rw [h_mul_eq, h_Bma_ord, add_zero] at h_RHS_ord + exact h_RHS_ord + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Nonnegativity of `ord_P` of the `T3` coefficient `yd·(a₂ + 2x + xk') − a₁²·yd`, given the basic +-order data. Extracted from `ord_P_translateY_xy_eq_neg_three_at_2tor` to keep its per-term `ord_P` +-bound bookkeeping under the default heartbeat budget. -/ ++order data. -/ + theorem ord_P_translateY_T3_coef_nonneg + {P : (W_smooth W).SmoothPoint} {yd a1 a2 xk' : KE} + (h_yd_ord : (W_smooth W).ord_P P yd = ((1 : ℤ) : WithTop ℤ)) +@@ -717,8 +688,7 @@ theorem ord_P_translateY_T3_coef_nonneg + + omit [Fintype K] [DecidableEq K] [W.toAffine.IsElliptic] in + /-- Nonnegativity of `ord_P` of the `T4` coefficient `−y + a₁·(a₂ + x + xk') − a₃`, given the basic +-order data. Extracted from `ord_P_translateY_xy_eq_neg_three_at_2tor` to keep its per-term `ord_P` +-bound bookkeeping under the default heartbeat budget. -/ ++order data. -/ + theorem ord_P_translateY_T4_coef_nonneg + {P : (W_smooth W).SmoothPoint} {a1 a2 a3 xk' : KE} + (h_xg_nn : (0 : WithTop ℤ) ≤ (W_smooth W).ord_P P (x_gen W)) +@@ -779,9 +749,9 @@ theorem ord_P_translateY_T4_coef_nonneg + SmoothPlaneCurve.ord_P_add_le (P := P) _ _ + exact (le_min h12' h_neg_a3_nn).trans h123 + +-omit [Fintype K] in ++omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Nonnegativity of `ord_P (y_gen)`: the generic `y`-coordinate has no pole at any smooth point, +-since its `pointValuation` is `≤ 1`. Extracted from `ord_P_translateY_xy_eq_neg_three_at_2tor`. -/ ++since its `pointValuation` is `≤ 1`. -/ + private theorem ord_P_y_gen_nonneg {P : (W_smooth W).SmoothPoint} : + (0 : WithTop ℤ) ≤ (W_smooth W).ord_P P (y_gen W) := by + by_cases hf : y_gen W = 0 +@@ -794,7 +764,7 @@ private theorem ord_P_y_gen_nonneg {P : (W_smooth W).SmoothPoint} : + have hv : (W_smooth W).pointValuation P (y_gen W) ≠ 0 := + ((W_smooth W).pointValuation P).ne_zero_iff.mpr hf + simp only [SmoothPlaneCurve.ord_P] +- rw [dif_neg hv] ++ rw [dite_eq_right hv] + rw [show (0 : WithTop ℤ) = ((0 : ℤ) : WithTop ℤ) from rfl, + WithTop.coe_le_coe] + have h_unz_le : WithZero.unzero hv ≤ 1 := by +@@ -807,9 +777,9 @@ private theorem ord_P_y_gen_nonneg {P : (W_smooth W).SmoothPoint} : + rw [h1] at h2; exact h2 + omega + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The `T2` term `-(2·a₁·yd²·xd)` has `ord_P ≥ 4` at 2-torsion, given `ord_P yd = 1`, +-`ord_P xd = 2` and `ord_P a₁ ≥ 0`. Extracted from `ord_P_translateY_xy_eq_neg_three_at_2tor`. -/ ++`ord_P xd = 2` and `ord_P a₁ ≥ 0`. -/ + private theorem ord_P_translateY_T2_term_ge_four + {P : (W_smooth W).SmoothPoint} {a1 yd xd : KE} + (h_yd_sq : (W_smooth W).ord_P P (yd ^ 2) = ((2 : ℤ) : WithTop ℤ)) +@@ -857,10 +827,9 @@ private theorem ord_P_translateY_T2_term_ge_four + (((2 : ℤ) : WithTop ℤ) + ((2 : ℤ) : WithTop ℤ)) := + add_le_add h_2a1_nn (le_refl _) + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The `T3` term `(yd·(a₂ + 2x + xk') - a₁²·yd)·xd²` has `ord_P ≥ 4` at 2-torsion: the +-coefficient is nonnegative (`ord_P_translateY_T3_coef_nonneg`) and `ord_P xd² = 4`. Extracted from +-`ord_P_translateY_xy_eq_neg_three_at_2tor`. -/ ++coefficient is nonnegative (`ord_P_translateY_T3_coef_nonneg`) and `ord_P xd² = 4`. -/ + private theorem ord_P_translateY_T3_term_ge_four + {P : (W_smooth W).SmoothPoint} {a1 a2 yd xd xk' : KE} + (h_yd_ord : (W_smooth W).ord_P P yd = ((1 : ℤ) : WithTop ℤ)) +@@ -889,8 +858,7 @@ private theorem ord_P_translateY_T3_term_ge_four + + omit [Fintype K] [DecidableEq K] [W.toAffine.IsElliptic] in + /-- The `T4` term `(-y + a₁·(a₂ + x + xk') - a₃)·xd³` has `ord_P ≥ 6` at 2-torsion: the +-coefficient is nonnegative (`ord_P_translateY_T4_coef_nonneg`) and `ord_P xd³ = 6`. Extracted from +-`ord_P_translateY_xy_eq_neg_three_at_2tor`. -/ ++coefficient is nonnegative (`ord_P_translateY_T4_coef_nonneg`) and `ord_P xd³ = 6`. -/ + private theorem ord_P_translateY_T4_term_ge_six + {P : (W_smooth W).SmoothPoint} {a1 a2 a3 xd xk' : KE} + (h_xd_cube_eq : (W_smooth W).ord_P P (xd ^ 3) = ((6 : ℤ) : WithTop ℤ)) +@@ -920,8 +888,7 @@ private theorem ord_P_translateY_T4_term_ge_six + + omit [Fintype K] [DecidableEq K] [W.toAffine.IsElliptic] in + /-- Extract `ord_P f = -3` from `ord_P (f · g) = 3` and `ord_P g = 6`: since `f · g` has finite +-order, `f ≠ 0`, so `ord_P f` is a finite integer `k` with `k + 6 = 3`. Extracted from +-`ord_P_translateY_xy_eq_neg_three_at_2tor` (with `g = xd³`). -/ ++order, `f ≠ 0`, so `ord_P f` is a finite integer `k` with `k + 6 = 3`. -/ + private theorem ord_P_eq_neg_three_of_mul_eq_three + {P : (W_smooth W).SmoothPoint} {f g : KE} + (h_LHS_ord : (W_smooth W).ord_P P (f * g) = ((3 : ℤ) : WithTop ℤ)) +@@ -949,8 +916,7 @@ private theorem ord_P_eq_neg_three_of_mul_eq_three + + omit [Fintype K] [DecidableEq K] [W.toAffine.IsElliptic] in + /-- A four-term sum `d + (A + (B + C))` has `ord_P` equal to that of its dominant term `d` when +-`ord_P d = 3` and each of `A`, `B`, `C` has `ord_P ≥ 4`. Extracted from +-`ord_P_translateY_xy_eq_neg_three_at_2tor`. -/ ++`ord_P d = 3` and each of `A`, `B`, `C` has `ord_P ≥ 4`. -/ + private theorem ord_P_dominant_sum_eq_three + {P : (W_smooth W).SmoothPoint} {d A B C : KE} + (h_d : (W_smooth W).ord_P P d = ((3 : ℤ) : WithTop ℤ)) +@@ -969,15 +935,14 @@ private theorem ord_P_dominant_sum_eq_three + exact lt_of_lt_of_le (by exact_mod_cast (show (3 : ℤ) < 4 by norm_num)) h_ABC + exact (SmoothPlaneCurve.ord_P_add_eq_of_lt h_strict).trans h_d + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **`ord_P (translateY_xy) = -3` at smooth 2-torsion `T`** via the algebraic + identity `translateY_xy_mul_cube_eq` and the 2-tor ord values +-`ord_P (yd) = 1` (shipped at `ord_P_y_gen_sub_negY_const_eq_one_of_2_tor`) +-+ `ord_P (xd) = 2` exactly (shipped at `ord_P_x_gen_sub_const_eq_two_at_2tor`). ++`ord_P (yd) = 1` (given by `ord_P_y_gen_sub_negY_const_eq_one_of_2_tor`) +++ `ord_P (xd) = 2` exactly (given by `ord_P_x_gen_sub_const_eq_two_at_2tor`). + At 2-tor the RHS dominant is `-yd³` with ord = 3, all other RHS terms have + ord ≥ 4 (strict); LHS = `translateY · xd³` has ord = `ord(translateY) + 6`, +-forcing `ord(translateY) = -3`. Mirrors the non-2-tor proof at +-`EC/TranslationOrd.lean:1536`. -/ ++forcing `ord(translateY) = -3`. Mirrors the non-2-tor proof at -/ + theorem ord_P_translateY_xy_eq_neg_three_at_2tor (xk yk : K) + (h_ns : W.toAffine.Nonsingular xk yk) (h_2_tor : yk = W.toAffine.negY xk yk) : + (W_smooth W).ord_P (negSmoothPoint W xk yk h_ns) +@@ -1072,11 +1037,7 @@ theorem ord_P_translateY_xy_eq_neg_three_at_2tor (xk yk : K) + -- ord_P translateY + 6 = 3 ⟹ ord_P translateY = -3. + exact ord_P_eq_neg_three_of_mul_eq_three W h_LHS_ord h_xd_cube_eq + +-/-- **Type abbreviation for the y-side substantive value at 2-torsion T**: +-`ord_P (translateY_xy) = -3` at the negated point. This is the single +-substantive witness the y-side chain reduces to. +- +-⟶ Now DISCHARGEABLE via `ord_P_translateY_xy_eq_neg_three_at_2tor` (just shipped). -/ ++/-- The y-coordinate after translation has order `-3` at the negated point. -/ + abbrev TwoTorYValueWitness (xT yT : K) (h_ns : W.toAffine.Nonsingular xT yT) : Prop := + (W_smooth W).ord_P + (negSmoothPoint W xT (W.toAffine.negY xT yT) +@@ -1084,7 +1045,7 @@ abbrev TwoTorYValueWitness (xT yT : K) (h_ns : W.toAffine.Nonsingular xT yT) : P + (translateY_xy W xT (W.toAffine.negY xT yT)) = + ((-3 : ℤ) : WithTop ℤ) + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- **Discharge `TwoTorYValueWitness` from the substantive y-side lemma**: at smooth + 2-torsion `T`, the y-side ord = -3 value follows directly from + `ord_P_translateY_xy_eq_neg_three_at_2tor` applied at the negated coordinates. -/ +@@ -1222,7 +1183,7 @@ theorem bridge_at_y_gen_of_2_tor (xT yT : K) + (twoTorYValueWitness_discharge W xT yT h_ns h_2_tor) + + /-- **Bridge at `f = y_gen^q` for 2-torsion `T` (UNCONDITIONAL)**: pow on the +-just-shipped unconditional y-side base bridge. -/ ++the y-coordinate order identity. -/ + theorem bridge_at_y_gen_pow_card_of_2_tor (xT yT : K) + (h_ns : W.toAffine.Nonsingular xT yT) (h_2_tor : yT = W.toAffine.negY xT yT) : + (W_smooth W).ord_P (⟨xT, yT, h_ns⟩ : (W_smooth W).SmoothPoint) +@@ -1246,7 +1207,7 @@ theorem bridge_at_y_gen_sub_y_gen_pow_card_of_2_tor (xT yT : K) + (twoTorYValueWitness_discharge W xT yT h_ns h_2_tor) hq + + /-- **Bridge at `(negFrob).pullback y_gen` for 2-torsion `T` (UNCONDITIONAL)**: +-mirrors `bridge_at_negFrobeniusIsog_pullback_y_gen_of_non_2_tor` (`PoleDivisorFallback.lean:1034`) ++mirrors `bridge_at_negFrobeniusIsog_pullback_y_gen_of_non_2_tor` + using the now-unconditional 2-tor y-side bridges. The pullback expands as + `-y_gen^q - a₁·x_gen^q - a₃`; strict-comparison isolates `-y_gen^q` with ord `-3q` + as the dominant term. -/ +@@ -1393,7 +1354,7 @@ theorem bridge_at_negFrobeniusIsog_pullback_y_gen_of_2_tor (xT yT : K) + (Conditional.ordAtInfty_neg_y_gen_pow_card_lt_rest W hq) + + /-- **Bridge at T1 = `a₄ · (x_gen + (negFrob).pullback x_gen)` for 2-torsion `T` (UNCONDITIONAL)**: +-const_mul on the strict-add bridge (already shipped). -/ ++const_mul on the strict-add bridge (proved). -/ + theorem bridge_at_T1_a4_x_add_pi_x_of_2_tor (xT yT : K) + (h_ns : W.toAffine.Nonsingular xT yT) (h_2_tor : yT = W.toAffine.negY xT yT) + (hq : 2 ≤ Fintype.card K) : +@@ -1719,7 +1680,7 @@ under `hq`, **UNCONDITIONAL**. + Mirror of `bridge_at_addPullbackNumerator_negFrobenius_of_non_2_tor`: apply + `ord_P_translateAlgEquivOfPoint_sum_dominant` with dom = T7 (x · π·x², + ord = -2-4q) and the same seven other terms; the per-term bridges are the +-2-torsion versions just shipped, and the strict-comparison framework is ++2-torsion versions proved, and the strict-comparison framework is + identical because the `ordAtInfty_T*_ge` bounds are universal in T. -/ + theorem bridge_at_addPullbackNumerator_negFrobenius_of_2_tor (xT yT : K) + (h_ns : W.toAffine.Nonsingular xT yT) (h_2_tor : yT = W.toAffine.negY xT yT) +@@ -1811,7 +1772,7 @@ theorem bridge_at_addPullbackNumerator_negFrobenius_of_2_tor (xT yT : K) + /-- **Bridge at `addPullback_x W (negFrobeniusIsog W)`** for 2-torsion T + under `hq`, **UNCONDITIONAL**. Discharges the + `bridge_at_addPullback_x_negFrobenius_of_bridge_at_Num` Conditional consumer +-with the just-shipped 2-tor Num bridge. ++with the 2-tor Num bridge. + + Note: `bridge_at_addPullback_x_negFrobenius_of_bridge_at_Num` requires a + non-2-torsion hypothesis only for its appeal to +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/Primitives.lean b/projects/HasseWeil/HasseWeil/HasseBound/Primitives.lean +index 7b7c9f9bdd2de81fd56ed1658ddd95a0088e6cef..bc3351f74e8f72d1c306fa97c7af59533db0a65e 100644 +GIT binary patch +delta 9240 +zcmb_iZH!!18P0ACttZiz#2Q*kIZYdxS!QN;+foo%bSVWEO1o+6R^+4i&diyeL+{)> +zz4y-UPNUocNdXOrxtOR41pFicJ#+nBf)OVl1*P$ij|hTAh_dJh3ggg4X#rbwrqL4 +z+A=Naw+q~~tGp@~r02N2Vws*NJjM>z1$TwlvV0FeEz^%haMR~Uglh|nHyvr?w(sz! +zD;t8#sxU2&OB*5s{P4xRYg&-$cr8~H81CD?thITwWm#pja>V0KP3e(QYf<`jJ_lVZ +zbt%d%dp=T7xDwl_ICfR~(y<}ecg>23g!)o=B~D65J1G>^R+2rK&8F2R)x?5u+q_aY +z@wN}49xw_&z539G?L0SK7S{6d@Mg2(lx4oaIG>rBDeVZ4ub$kmP|}d)3+nn6xSz{v +zitF^$TxqfdVLp`cL=)?jEvN-71Td^|W0Dv7nd3%2-21U_1pAa-)O!j7A+xTqD?&pFrCeW{Bo^wyF|igGOHE5wq|fW^rUQj=xx~UJKhX)MZ7qx& +z#cc+UUg9+k9|1++_CPfcK;VaD25#UjJk2CDlr|j26B@aB;WUKr%1Yw8^jxE5ncQm% +z?A?;bgcndK_;r9EFTGe7HiPMM2lFu2J{XDsbj^mW$%;vSjCHDFi40~;k{#hc29!Cx +zFSkUmU>_xR0FHA&TF|Fq+Hk$nq +zGVBXjL&+#NDu|-M9uht!-fdq>ACqBm%lAJ+rtDDywv0`}6+&cL#I8hsE}K}lCWTcE +zf4=n(yQ5W895b@Cqmm~^xpatGO5w!#mEmtc{k?#6iK4Nnb6Js)j2)d~ELt$tm|`9g +z(X$APputv}NHhY~saoPU#t~*(7HX2$s?;fksk%}(5n6auR$I{qxj2ec9PNUo8z;j- +zZo@nRTN5-<+Kq$NSbp&9TpXU|HT;|6wgIu#7K{rulY4Z%H|WmOR=KJ0)Jj4koG7ka +zP5x#=&2S{QuJgO%H6!bI?#u~}P|wXeR@-(O$P4_IPHueDkXzy5iLr6U#*3TzmMxhY +z7?oxf<*Le2X+`OzDi^NV`PG2lDe`GvLk)9Wc}%AgI3H4yFDX6hE9Evfjv7G1bz1ZF +z%nD7{S%6Fg1j7SG#Ifr*zDkukhJ>XuHEgbM?3Q~$nn7g4oEIh58NcfHBkc1wlBw%q +z*WszD3-?0XY)NU+OkG+L-5lsZ*# +zk(F&Rudg6SI97{pMpbjp(EI}SP2_U})wjSc;p5Z&1}`I8BSOLfSS(B@0mXeto-xOl +zAN*#3$_>Z4{pg(r*BQ^q&5iM6`MZwl%lM4CH%)AV+@BUG@RmoPDGgOp^>wZ6238k< +z=y6*m(gkp|6rOQnZi%*D-B~0*H+_bMNIwo`rszNVjJ3m`)i#Dd*tfp(%ylE@Uq74K +zrm2C+0v~AytLe0rc{%}wh0pEZ*qONbmGf0fh_6$*jF9KB4B51p0$y=Y(xi>*4`$hC +z!9)gJ-S%p5Amwsk3wG6Xt69-$81Py^Wqrv|mBVPm$*J}Vi9D3B%NA-Y9-2cqqe`ln +zq3BH(%qU%xOW3yoyxIr$YP!<2eGmacB?f`L?`Cxh0%raqSU!Li)neIPUpd0Fs{tihgW*8KHXk1A +z+;e+4ddEz(9+GSKg1l*gw`&`J;2xNf?g1vb1*{0h>})>#&PV{Q(6h`78%d6c@tmQ9 +zKJsj`U)H-3Tb|cKn?f0*TYEfa$ST+&v9BWK47DBQTH2=uC>mtYMumzAx9P)SRYh)> +zcrOSnMm+@qE|w95bQ^6_H8YCB>pY`^qXMr|nG>1@Om=4o+E<31nby20yC$zY4g7JN +zD2$DQX8Niy_rq6WGe}V=DU@9CH!ajaM**Bo%^%lflydX7T%~iW_MKI?QZx*JDzia? +zIwz|IUi<*RRKBz+e0^z6__@}a@ZsBK_)1`ePd>XUyylMS@R2WH+SzclJn~WanNx$C +zr8*@hAa5oOHgp=^zej>;-BD!>oFN*DgJhwOA}}LXr*jlbLP=S+>>xB$vxdI3x2uup +zYEo{`&5pD1?y6v>-{$>GYmXV=9;qSN`{>%eZne6L()YAAf0NVbTpK(yiXv=#zT2w! +zDwcYJkk?$NfoM>Pvp)zm>8|)J8-kgfO-wSihAxOvFB_B1OX!*IxQyE|1#WoT{hQGu +z4eVRpMk14l~AS0#LgP1doUSZo@UB3MM^fLjD~o +zwWGiTZK3*Bppv84C+8!v6%<+&Xc`Dn(xginR^8Wu&Xle|eBScJC7n0FR>m&%a6{>+ +zhBC^<)lfmt7YyG;9;b$Ol3zxoT>Vy5pY%)vMM`-sGw5z~t?zj)1_Z0CWm=7q%eK;X +zV7~LQwIjid9y7%pSaF%T%s?q|Hr-doHlcl+s3imamYX!biHH%QGgu&6LoZN~fi7Fc +zfics_5$t)s{FM_Nzrb!NVf;EwF4T^@ydcKjGf}4^3XU|;6Z9#uN^~ba5A~=m3bYZC +z#c19^6|D`6NB-jpjC~R^#!);4+B01fYb{$lzUm=+FxC^VZXQKQk;B9s8O{gZIR@gH +zaAet_@d1d?Ko~l2e|t)k84{HtjHK;Agi)UK98GPnKzu!u=BWKn!9fLsr9cREvlvBN +z(^-TsWKvw`;1latDn|8Tlpt(B3MD4KyME>TZt7}P2zFU7$~G{IrlT345(kKTA=U-k +zz#Par7d`!`qEB(DPO=Im))YXp0yQm!i>6j_@=mE>FB8-gu2}F;Zpw@xC3bL+Jug3x +z#GttG9!-qz!;d9&Rp51*oW+biND8@je50M`<2;u>N1>%g0D9`^=^&(l^#rCqs>4-d +zJF{R{S-RC2$01&?Xzj(%-m`LdYNA?_N1|2Iz>3QQ48|CSlF9+euF*&=e962hAauLC +zzeFJHK{Hd2)u@zeCyoYK+NtBfB_fwD3mnss*X^sI*HlTNSvw61frzS9pS6oB&bcLP +zer60pkE9}ty)=QqQ_&Ot<0l)g+^xmy{LyFhXr-=&s6;Ip;j1UNbRK@8z2ZYkXd9hZ +zPg*O2TTLIw1OQm6c}Ou_)Usa9vuc^vMH +z{o?Ua>O;`h>)|@gW2ovihlGz7Jg#JDO%CF@0T~lvkekg@X*|kj5(VHhFlSd;xXYm@q-|P^qG2jYBSaOobCck{18q1$uZS24(Lrp7jzmyGumwV +zIAB!gA8ndKYi1e6Ud+aT4#`l9W9<#J_$+Q>L-QC?Hj|+q3%8z~3@2W@IT*g1x-qYOj6x5Inqn`eW|RZR +z3be{N9zuGN&`AL%ueHeiXnCdPIEG)!vQ-(5y}owr +zYQ?{{moCqoT;jxu2IO`{HZehsOznkN{^{}X)SIiqEq|W9diMeycE(_53>_tWWpA`< +ziN$G`+Th`D{&?YS@#r!!L6;-p=n6exG%SeM?{#^~HhRO#`Sh=shfghkOKJJw8+(fx +zf9Q1woi?*}3b&ozawIhtjth$2hq+8Eo5V!w^IBD$IIDK0+wq6k30=-3Z}WAt3CyWK +z@o>%A%SKpu_1O*6yl&!fTFd1spoTeRUn>Q0kPpJse|x%f>dk+Rg#Y>bTO$XUIq+lUh~< +zJwgLRkN8*wp6&|JO`zt0CE+-ZVhx8pI5J4}ZP}6o;j_By_^A(+*cVUKjY +zPX+n(V|@9cC;3ENT{8;|!7b^R;#k(E(7jWjCfOV=ftkL?Z7673gZyW*v?H#tbilI( +zhg{TdSv;$B!>I}@YXA2L#C#Q)sEcUaz>25%QjTWDlX>;y^vQgHwoXklk#xGg#*oA@ +zXfB8&gCR9YklMFy7A&5EMcM!Jmfb}39TQ|5q(4n7flT7KVhNNJ +zMpUC_)lp=8kSPppikiaEWxE@GK65^ug5#SRTmSoFu&WD%B2B8bO;lSGL5uC)9rw3J +zPBj`+d;%Qphtzf4511#2u|3V>dz0PwFcXHKLa-0AhkY^}!y@;?2QCI9#usP$l~ACB +zzj|lu-t_Q(8fW*>JeMj>^3{j|uV?pg6=P$3pBmA)?QqAri3>`&a3EHJGzi=0Cf1>* +Rs55!BCGGRbU?={!^Zyl&|9Joa + +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/SepDegreeEqPointCount.lean b/projects/HasseWeil/HasseWeil/HasseBound/SepDegreeEqPointCount.lean +index b0f7c26f8594ff8704015e2653ececd9d147c830..fcdb5384128782484b7f84f20c3c1e14fb287923 100644 +GIT binary patch +delta 1421 +zcmaKs&x;gC6vvs-_@fCT5z&jwOJ>CxogNt!4I38^>jq&^7M0B@acX+rOqX_7HC5H~ +z10j=BPTuO6z3R!3NRvYX@#t~If5U@E&v{kdGhs!9fuXyr-uu?)eZTc$v3L8=Ms0B) +zGp5)eK^Wp#Ap#RaFfoG2(*Y`wBT&q6DOduTDCX6;y;f}`amRHuN +z9iLa$2_BGeZD?zXq!b32$SFiJ&7?-aS(fmKo3e8oGR4ztNNU_UoeU=-lxm17i07Fk +z3L14AxG3dIl|rtOEao}|Nx0}EGi49Ef8w1zeDX>0>g3-w`~0hW +zi{Nq?dM=;xUPXoQjL32aOx$*6QK;RtbIrw=Y)WG{s8SqqN4)efVM2-rts2a|%H;ve +zDV;btCcAg~S+RR|z5c(h(iqe~%@gJ=DI%V+BwQw;LSL;|*_2G33lmgxEqhZ^4n~>g +z)nBI4PuTg!<@)p|gKeL!{ZZ_;KGf~|Z;sgQ#+`Gp0b4OsJJ5p+HZ~#lPXR#8CTL$a +zp4+GEZ|%?LCwEt%S0chnc`4C(@Z%U&$Zj*j>>MbFHwbsAO$- +zLHKm~OrkQJRnF9_oJ7n=B5|g#g5q}vKIL=|(TznEROxufgR)!Zr0P(CZ^If-v!t4; +zyZ9(?gnVThqSY-PbbqTCjjKoMr=WSy5!#W-T*#EuZP_cLYsYKFzt?}Q6VBC~YRN{2)9t6}5oq#TK<0dw!* +z$w@b_e4e>OqNg$-ou2H13_AS)rb<2~Ocx3v$4Ji2K~`eCo11F>w1&WVFR#gbp8Yyu +zKv=0%mR0Jiw>E4}yE6;T6-E2O^pCpMZ?MyH$R3)h2Evh`!e&2gY@9yAY@N{IyxDQ> +zloChEH*L+0)AuA&?g`8=j{G>wY?=N2^r5`~twfHyufl&9b{Cj;s23ANN&KU7jH;q6 +zvooloz1OI6rI`((pk&p|Y+G(7m{V4^C7B0St#laoJ-@~*Sz83=Ryv8|-&phZO`b&a +z*;lp=F<4W9x&N(K2ZGbgKl(<0n3q1B2j=F^H3Q?0XnO`M +zH&1;!ILSQt`PsgL&oooMbf)pvG&p@DMlQC_89-t&ix(8Y6S2+lUfG?q8b-$!zzh7< +zBB8bwKUTmC(Fm#cJ}&l+lLoO8HY+qO;`XU-R!9{Em`kq3@C?1V +z7~Z3npTHiPvjlc0Im5MzrYn9r9f6U2rwq+~2c)fs;k-iuS0b=wF=XfWp%2qc$h~JKOl!yEx^kv(ho5c`1~?-06#njm-Tq(sFmv# +z?w^MnCBAMk&P=4vrFft9mBpu3qL{a*9>t0kf)`BnSX39(jVekFG2PaU>~m`Mip~`A +z6=4?N1rrsYXA}!*ObrV&C8T=lVyi-*Hob4yx!6?Z)7%24E}#k?`_<(FO_)_Rj*e7K +zwyYNjSAMldb;l$g@F`B6lmcr`zZiafeKNET>eu2}e09gIdVWpmh^|1ol(g +zOE?_q>uq>|#qI~w6}Re_?*`<0wn(dU+)u-=I+9_RQnLHr+;iVYc-U=3sbY%qAIJiQJM+{dRTQNYFtI{ +z?!sZTVGj<1Dmu0s|N5;ya*dY`4dLcqOEmfK;NPO%o_GlJ>{>a>i&!aLco7R`6c^ip +z)ToV$r&w^fuG_s(iCe1+2=aRs&98)YabgEGpP1X#k+^KSM|4sLc2dJ*$Y|SnOyh;e +z@oH=W_M|1rCvl;5m77n&e_|p}`3nwC;OsQ+=^!8ReA=ge_xwgUlYXXRA%@ +zN*aCyvmH#l=FfEDKIB~&u?bRH;e3mZ<(e-N5a+ZwEN9ck%lM-k(xZV_L|T hf ?_, hc⟩ + simpa [h] using hc + ++omit [DecidableEq F] in + /-- If `τ g / g` has trivial projective divisor, then `τ g` is a nonzero scalar multiple + of `g`. -/ + theorem pairing_const_of_transport [IsAlgClosed F] [W.IsElliptic] +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorPullback.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorPullback.lean +index aa75199b4..8789a8842 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorPullback.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorPullback.lean +@@ -10,55 +10,23 @@ import HasseWeil.HasseBound.WeilPairing.SigmaBridge + import HasseWeil.HasseBound.WeilPairing.TorsionGeometric + + /-! +-# Divisor-pullback functoriality for the separable multiplication-by-`ℓ` isogeny ++# Divisor pullback for multiplication by `ℓ` + +-For a separable isogeny `φ = [ℓ]` (`(ℓ : F) ≠ 0`, `[IsAlgClosed F]`) and a nonzero rational +-function `h ∈ K(E)`, the divisor of the pulled-back function `φ.pullback h` equals the geometric +-pullback of `div h`: +-``` +-divisorOf (φ.pullback h) = pullback-of-divisor (divisorOf h). +-``` +-Because `[ℓ]` is **separable** (unramified — every fibre is étale, multiplicity `1`), the pullback +-of a single place `(Q)` is the multiplicity-free fibre sum `Σ_{φP=Q} (P)` (the repo's +-`pullbackDiv`, `WeilPairing/Pullback.lean`). The geometric heart is the per-place +-**unramified order-transport** +-``` +-ord_P (φ.pullback h) = ord_{φ(P)} (h) (no ramification factor `e_P > 1`), +-``` +-which, summed over all places, yields the divisor identity. This is Silverman III.4.10c / +-III.8.1–2 in divisor language: the geometric content of the separability of `[ℓ]`. +- +-## Architecture +- +-* **Item 1 — the core (`OrdTransport` / `ordTransport_mulByInt`).** The per-place transport +- `ord_P P (φ.pullback h) = (ord of h at φ(P))` is the deep geometric unramifiedness statement. +- It is the exact isogeny analogue of the translation order-transport proven in +- `EC/TranslateValuation.lean` + `EC/TranslateOrdInfty.lean` (≈5000 lines): a valuation on `K(E)` +- pinned by its values on `x_gen`, `y_gen`. For an isogeny the base values +- `ord_P P (φ.pullback x_gen)`, `ord_P P (φ.pullback y_gen)` are the `ℓ`-division-polynomial orders, +- whose computation is the genuine ramification content. We **isolate** this as the named predicate +- `OrdTransport` (a per-`(P, φ)` hypothesis bundling the projective place transport) and prove the +- full divisor assembly on top of it. +- +-* **Item 2 — the assembly (`projectiveDivisorOf_pullback_eq_pullbackDivisor`).** Given the core +- for every place, the projective divisor of `φ.pullback h` equals the fibre-pullback of the +- projective divisor of `h`. This is a pure `Finsupp` computation: every coefficient matches by +- the core, and the supports are related by the (finite) fibre structure. Fully proven modulo the +- core. +- +-* **Item 3 — the pairing-facing corollaries.** `pullback_divisorOf_eq_of_divisorOf_eq` (the +- shape bilinearity-in-`T` and nondegeneracy consume) and the III.8.1 relation +- `weilFunction_pow_mem_pullback_range`-style statement, parametric on the core. +- +-Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.4.10c, III.8.1, III.8.2. ++For a separable multiplication-by-`ℓ` isogeny over an algebraically closed field, ++the geometric pullback of a place is the multiplicity-free fiber sum. ++The per-place hypothesis `OrdTransport` expresses the unramified order identity ++`ord_P (φ*h) = ord_{φ(P)} h`, including the projective place at infinity. ++Summing these identities over all places identifies the projective divisor of ++`φ*h` with the fiber pullback of the divisor of `h`. ++ ++References: Silverman, *The Arithmetic of Elliptic Curves*, III.4.10c, ++III.8.1, and III.8.2. + -/ + + open WeierstrassCurve HasseWeil.Curves + + namespace HasseWeil.WeilPairing.DivisorPullback + +-set_option linter.unusedSectionVars false +- + variable {F : Type*} [Field F] [DecidableEq F] {W : WeierstrassCurve.Affine F} [W.IsElliptic] + + /-- Local abbreviation for the function field `K(E)` (`= (⟨W⟩ : SmoothPlaneCurve F).FunctionField`), +@@ -70,6 +38,7 @@ local notation3 "KE" => W.toAffine.FunctionField + noncomputable def projOrdAt (f : (⟨W⟩ : SmoothPlaneCurve F).FunctionField) (Q : W.Point) : ℤ := + (⟨W⟩ : SmoothPlaneCurve F).projectiveDivisorOf f Q.toProjectiveSmoothPoint + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W] in + theorem projOrdAt_some (f : (⟨W⟩ : SmoothPlaneCurve F).FunctionField) {x y : F} + (h : W.Nonsingular x y) : + projOrdAt f (Affine.Point.some x y h) = +@@ -77,6 +46,7 @@ theorem projOrdAt_some (f : (⟨W⟩ : SmoothPlaneCurve F).FunctionField) {x y : + rw [projOrdAt, Affine.Point.toProjectiveSmoothPoint_some, + (⟨W⟩ : SmoothPlaneCurve F).projectiveDivisorOf_apply_affine f ⟨x, y, h⟩] + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W] in + theorem projOrdAt_zero (f : (⟨W⟩ : SmoothPlaneCurve F).FunctionField) : + projOrdAt f (0 : W.Point) = ((⟨W⟩ : SmoothPlaneCurve F).ordAtInfty f).untopD 0 := by + rw [projOrdAt, Affine.Point.toProjectiveSmoothPoint_zero, +@@ -107,7 +77,7 @@ theorem coeff_affine_pullback_eq {φ : Isogeny W W} + + /-- **The fibre-pullback of a projective divisor** under a point-map endomorphism with finite + kernel: `φ*(D) = Σ_v D(v) · pullbackDiv(v)`, the `ℤ`-linear extension of the multiplicity-free +-fibre pullback `pullbackDiv` (`WeilPairing/Pullback.lean`) over the (projective) places of `D`. ++fibre pullback `pullbackDiv` over the (projective) places of `D`. + The place at infinity pulls back to `pullbackDiv f h 0 = Σ_{φP=O}(P)` (the kernel). -/ + noncomputable def pullbackDivisor (f : W.Point →+ W.Point) (hf : Finite f.ker) + (D : ProjectiveDivisor (⟨W⟩ : SmoothPlaneCurve F)) : +@@ -154,10 +124,10 @@ theorem pullbackDiv_apply (f : W.Point →+ W.Point) (hf : Finite f.ker) + (Q : W.Point) (w : ProjectiveSmoothPoint (⟨W⟩ : SmoothPlaneCurve F)) : + pullbackDiv f hf Q w = if f w.toAffinePoint = Q then 1 else 0 := by + classical +- letI : Fintype {R : W.Point // f R = Q} := @Fintype.ofFinite _ (fiber_finite f hf Q) ++ let : Fintype {R : W.Point // f R = Q} := @Fintype.ofFinite _ (fiber_finite f hf Q) + rw [pullbackDiv, Finsupp.finsetSum_apply] + by_cases hwQ : f w.toAffinePoint = Q +- · rw [if_pos hwQ] ++ · rw [ite_eq_left hwQ] + have hwproj : (⟨w.toAffinePoint, hwQ⟩ : {R : W.Point // f R = Q}).val.toProjectiveSmoothPoint = + w := Affine.Point.toAffinePoint_toProjectiveSmoothPoint w + rw [Finset.sum_eq_single (⟨w.toAffinePoint, hwQ⟩ : {R : W.Point // f R = Q})] +@@ -173,7 +143,7 @@ theorem pullbackDiv_apply (f : W.Point →+ W.Point) (hf : Finite f.ker) + exact Subtype.ext hRval + · intro hni + exact absurd (Finset.mem_univ _) hni +- · rw [if_neg hwQ] ++ · rw [ite_eq_right hwQ] + refine Finset.sum_eq_zero (fun R _ ↦ ?_) + rw [Finsupp.single_eq_of_ne] + intro hcontra +@@ -209,9 +179,9 @@ theorem pullbackDivisor_apply (f : W.Point →+ W.Point) (hf : Finite f.ker) + intro v _ + rw [Finsupp.coe_smul, Pi.smul_apply, pullbackDiv_apply, smul_eq_mul] + by_cases hv : f w.toAffinePoint = v.toAffinePoint +- · rw [if_pos hv, mul_one, if_pos] ++ · rw [ite_eq_left hv, mul_one, ite_eq_left] + rw [hv, Affine.Point.toAffinePoint_toProjectiveSmoothPoint] +- · rw [if_neg hv, mul_zero, if_neg] ++ · rw [ite_eq_right hv, mul_zero, ite_eq_right] + intro hcontra + apply hv + have := congrArg ProjectiveSmoothPoint.toAffinePoint hcontra +@@ -219,8 +189,8 @@ theorem pullbackDivisor_apply (f : W.Point →+ W.Point) (hf : Finite f.ker) + rw [Finset.sum_congr rfl hterm, + Finset.sum_ite_eq D.support (f w.toAffinePoint).toProjectiveSmoothPoint (fun v ↦ D v)] + by_cases hmem : (f w.toAffinePoint).toProjectiveSmoothPoint ∈ D.support +- · rw [if_pos hmem] +- · rw [if_neg hmem, Finsupp.notMem_support_iff.mp hmem] ++ · rw [ite_eq_left hmem] ++ · rw [ite_eq_right hmem, Finsupp.notMem_support_iff.mp hmem] + + /-- **The per-place core, projective form.** For the isogeny `φ`, the coefficient of + `projectiveDivisorOf (φ.pullback h)` at the projective place `w` equals the coefficient of +@@ -336,7 +306,7 @@ theorem inftyOrdTransport_mulByInt (ℓ : ℤ) (hℓ : ℓ ≠ 0) (hℓF : (ℓ + rw [hm, hn, WithTop.untopD_coe, WithTop.untopD_coe] + omega + +-/-- **Comap-valuation identity, affine-image case** (proven, axiom-clean). The comap of ++/-- **Comap-valuation identity, affine-image case** . The comap of + `pointValuation P` along `[ℓ].pullback` equals `pointValuation` at the affine image smooth point + `⟨x, y, h_ns⟩`. This is the unramifiedness of `[ℓ]` at an affine image (Silverman III.4.10c). -/ + theorem comap_pointValuation_mulByInt_eq_affine [IsAlgClosed F] (ℓ : ℤ) (hℓ : (ℓ : F) ≠ 0) +@@ -529,8 +499,7 @@ Hence `φ.pullback f_T` and `g_T^ℓ` have the *same* divisor, so they differ by + (`Constancy`): the relation `f_T ∘ [ℓ] = c · g_T^ℓ` that nondegeneracy consumes. + + Parametric on the per-place core `ProjOrdTransport [ℓ]` (`= projOrdTransport_mulByInt`), and on the +-finiteness of `ker[ℓ]` (the caller supplies `mulByInt_ker_finite`, keeping this file decoupled from +-`Pairing.lean`/`TorsionCardEll`). The conclusion's right side is exactly `ℓ • (div g_T)`. -/ ++finiteness of `ker[ℓ]`. The conclusion's right side is exactly `ℓ • (div g_T)`. -/ + theorem projectiveDivisorOf_pullback_weilFunction (ℓ : ℤ) + [hker : Finite (mulByInt W ℓ).toAddMonoidHom.ker] (hcore : ProjOrdTransport (mulByInt W ℓ)) + (T : W.Point) {fT : (⟨W⟩ : SmoothPlaneCurve F).FunctionField} +@@ -573,7 +542,7 @@ divisor the Abel–Jacobi divisor `D = (T₁+T₂) − (T₁) − (T₂) + (O)`, + they differ by a constant. + + Parametric on the per-place core `ProjOrdTransport [ℓ]` (`= projOrdTransport_mulByInt`) and the +-finiteness of `ker[ℓ]` (caller-supplied, decoupling this file from `Pairing.lean`). -/ ++finiteness of `ker[ℓ]`. -/ + theorem projectiveDivisorOf_pullback_bilinFunction (ℓ : ℤ) + [hker : Finite (mulByInt W ℓ).toAddMonoidHom.ker] (hcore : ProjOrdTransport (mulByInt W ℓ)) + (T₁ T₂ : W.Point) {k : (⟨W⟩ : SmoothPlaneCurve F).FunctionField} +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorTranslate.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorTranslate.lean +index 5aa369762..ba8eced54 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorTranslate.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/DivisorTranslate.lean +@@ -11,7 +11,7 @@ import HasseWeil.HasseBound.WeilPairing.WeilFunction + /-! + # Divisor transport under translation + +-This file proves the projective divisor transport facts for translation by a ++We prove the projective divisor transport facts for translation by a + point on a Weierstrass curve, as used in the Weil pairing construction. + + ## Main definitions +@@ -38,8 +38,6 @@ namespace HasseWeil + + open HasseWeil.WeilPairing + +-set_option linter.unusedSectionVars false +- + variable {F : Type*} [Field F] [DecidableEq F] + variable (W : WeierstrassCurve F) [W.toAffine.IsElliptic] + +@@ -53,6 +51,7 @@ noncomputable def placeTranslate (S : W.toAffine.Point) : + ((Equiv.addRight S).trans + (WeierstrassCurve.Affine.Point.equivProjectiveSmoothPoint (W := W.toAffine))) + ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + theorem placeTranslate_apply (S : W.toAffine.Point) + (v : ProjectiveSmoothPoint (W_smooth W)) : + placeTranslate W S v = +@@ -60,6 +59,7 @@ theorem placeTranslate_apply (S : W.toAffine.Point) + (v.toAffinePoint + S) := by + rfl + ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + @[simp] theorem placeTranslate_affine (S : W.toAffine.Point) + (P : (W_smooth W).SmoothPoint) : + placeTranslate W S (ProjectiveSmoothPoint.affine P) = +@@ -68,6 +68,7 @@ theorem placeTranslate_apply (S : W.toAffine.Point) + rw [placeTranslate_apply] + rfl + ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + @[simp] theorem placeTranslate_infinity (S : W.toAffine.Point) : + placeTranslate W S ProjectiveSmoothPoint.infinity = + S.toProjectiveSmoothPoint := by +@@ -75,6 +76,7 @@ theorem placeTranslate_apply (S : W.toAffine.Point) + change (((0 : W.toAffine.Point) + S)).toProjectiveSmoothPoint = _ + rw [zero_add] + ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Translation by `O` is the identity place permutation. -/ + @[simp] theorem placeTranslate_zero : + placeTranslate W (0 : W.toAffine.Point) = Equiv.refl _ := by +@@ -89,13 +91,16 @@ noncomputable def ordProj (v : ProjectiveSmoothPoint (W_smooth W)) + | ProjectiveSmoothPoint.affine P => (W_smooth W).ord_P P f + | ProjectiveSmoothPoint.infinity => (W_smooth W).ordAtInfty f + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + @[simp] theorem ordProj_affine (P : (W_smooth W).SmoothPoint) (f : KE) : + ordProj W (ProjectiveSmoothPoint.affine P) f = (W_smooth W).ord_P P f := rfl + ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + @[simp] theorem ordProj_infinity (f : KE) : + ordProj W ProjectiveSmoothPoint.infinity f = (W_smooth W).ordAtInfty f := rfl + + set_option backward.isDefEq.respectTransparency.types false in ++omit [DecidableEq F] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The coefficient of `projectiveDivisorOf f` at `v` is `(ordProj v f).untopD 0`. -/ + theorem projectiveDivisorOf_apply_ordProj (f : KE) + (v : ProjectiveSmoothPoint (W_smooth W)) : +@@ -119,6 +124,7 @@ theorem ord_P_translate (P : (W_smooth W).SmoothPoint) + · exact translate_ord_eq_all_nonzero W P xk yk h_ns h f hf + + set_option backward.isDefEq.respectTransparency.types false in ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + /-- If `P + S` is finite, `placeTranslate W S (affine P)` is the translated affine place. -/ + theorem placeTranslate_affine_of_isSome (S : (W_smooth W).toAffine.Point) + (P : (W_smooth W).SmoothPoint) +@@ -132,6 +138,7 @@ theorem placeTranslate_affine_of_isSome (S : (W_smooth W).toAffine.Point) + P S h).symm + + set_option backward.isDefEq.respectTransparency.types false in ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + /-- When `P + S = O` (the translate hits infinity), the place + `placeTranslate W S (affine P)` is the place at infinity. -/ + theorem placeTranslate_affine_eq_infinity (S : (W_smooth W).toAffine.Point) +@@ -283,6 +290,7 @@ theorem projectiveDivisorOf_translate_div_eq_zero_of_invariant + _ = 0 := by rw [hself, sub_self] + + set_option backward.isDefEq.respectTransparency.types false in ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The `toAffinePoint` of a translated place is `w.toAffinePoint + S`. -/ + theorem placeTranslate_toAffinePoint (S : (W_smooth W).toAffine.Point) + (w : ProjectiveSmoothPoint (W_smooth W)) : +@@ -299,7 +307,7 @@ theorem pullbackDiv_apply (f : W.toAffine.Point →+ W.toAffine.Point) + (w : ProjectiveSmoothPoint (W_smooth W)) : + pullbackDiv (W := W.toAffine) f hker Q w = + if f w.toAffinePoint = Q then (1 : ℤ) else 0 := by +- letI : Fintype {P : W.toAffine.Point // f P = Q} := ++ let : Fintype {P : W.toAffine.Point // f P = Q} := + @Fintype.ofFinite _ (fiber_finite f hker Q) + rw [pullbackDiv, Finset.sum_apply'] + simp only [Finsupp.single_apply] +@@ -314,19 +322,19 @@ theorem pullbackDiv_apply (f : W.toAffine.Point →+ W.toAffine.Point) + rw [hPeq, + WeierstrassCurve.Affine.Point.toAffinePoint_toProjectiveSmoothPoint] + by_cases hQ : f w.toAffinePoint = Q +- · rw [if_pos hQ, Finset.sum_eq_single (⟨w.toAffinePoint, hQ⟩ : ++ · rw [ite_eq_left hQ, Finset.sum_eq_single (⟨w.toAffinePoint, hQ⟩ : + {P : W.toAffine.Point // f P = Q})] +- · rw [if_pos ((hkey w.toAffinePoint).mpr rfl)] ++ · rw [ite_eq_left ((hkey w.toAffinePoint).mpr rfl)] + · rintro ⟨P, hP⟩ _ hne +- rw [if_neg] ++ rw [ite_eq_right] + intro hPw + exact hne (Subtype.ext ((hkey P).mp hPw)) + · intro h + exact absurd (Finset.mem_univ _) h +- · rw [if_neg hQ] ++ · rw [ite_eq_right hQ] + apply Finset.sum_eq_zero + rintro ⟨P, hP⟩ _ +- rw [if_neg] ++ rw [ite_eq_right] + intro hPw + exact hQ (by + rw [← (hkey P).mp hPw] +@@ -366,6 +374,7 @@ theorem equivMapDomain_placeTranslate_pullbackDiv (S : (W_smooth W).toAffine.Poi + rw [Finsupp.equivMapDomain_symm_apply] + exact pullbackDiv_placeTranslate_apply_general W S f hker Q w + ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + /-- `equivMapDomain` fixes a divisor invariant under `placeTranslate W S`. -/ + theorem equivMapDomain_placeTranslate_symm_eq_self + (S : (W_smooth W).toAffine.Point) +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Fiber.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Fiber.lean +index 2d0e9d56e..5a54b5281 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Fiber.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Fiber.lean +@@ -6,20 +6,6 @@ Authors: Chris Birkbeck + import Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point + import Mathlib.Tactic + +-/-! +-# Route 2A — fibres of point-map endomorphisms as kernel cosets (keystone foundation) +- +-The multiplicity-free geometric divisor pullback `β*((Q)) = Σ_{βP=Q} (P)` (separable case, used by +-both the Weil-pairing construction and the separable adjoint, Silverman III.8) is summed over the +-**fibre** `{P : βP = Q}`. This file ships the group-theoretic foundation: a fibre of a point-map +-endomorphism is a coset of the kernel, hence finite when the kernel is finite. +- +-This is the point-map (`AddMonoidHom`) form of the project's `EC.Isogeny` fibre machinery — the +-level at which the Weil pairing and the pullback divisor operate. +- +-Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.4 (fibres of an isogeny are cosets of +-the kernel). +--/ + + namespace HasseWeil.WeilPairing + +@@ -29,8 +15,7 @@ open WeierstrassCurve + + variable {F : Type*} [Field F] [DecidableEq F] {W : WeierstrassCurve.Affine F} [W.IsElliptic] + +-/-- **Fibre as a kernel coset.** Given `f P₀ = Q`, the fibre `{P : f P = Q}` is in canonical +-bijection with `ker f` via `P ↦ P − P₀`. -/ ++ + def fiberEquivKer (f : W.Point →+ W.Point) {P₀ Q : W.Point} (hP₀ : f P₀ = Q) : + {P : W.Point // f P = Q} ≃ f.ker where + toFun := fun ⟨P, hP⟩ => ⟨P - P₀, by rw [AddMonoidHom.mem_ker, map_sub, hP, hP₀, sub_self]⟩ +@@ -38,16 +23,15 @@ def fiberEquivKer (f : W.Point →+ W.Point) {P₀ Q : W.Point} (hP₀ : f P₀ + left_inv := fun ⟨P, hP⟩ => by simp + right_inv := fun ⟨T, hT⟩ => by simp + +-/-- **Fibres are finite when the kernel is.** -/ ++ + theorem fiber_finite (f : W.Point →+ W.Point) (h : Finite f.ker) (Q : W.Point) : + Finite {P : W.Point // f P = Q} := by + rcases Classical.em (∃ P₀, f P₀ = Q) with ⟨P₀, hP₀⟩ | hempty + · exact Finite.of_equiv _ (fiberEquivKer f hP₀).symm +- · haveI : IsEmpty {P : W.Point // f P = Q} := ⟨fun ⟨P, hP⟩ => hempty ⟨P, hP⟩⟩ ++ · have : IsEmpty {P : W.Point // f P = Q} := ⟨fun ⟨P, hP⟩ => hempty ⟨P, hP⟩⟩ + infer_instance + +-/-- **Fibre cardinality = kernel cardinality** (for a nonempty fibre). The constant fibre size that +-makes `deg = #ker` for a separable isogeny (Silverman III.4.10c). -/ ++ + theorem fiber_card_eq_ker_card (f : W.Point →+ W.Point) {P₀ Q : W.Point} (hP₀ : f P₀ = Q) : + Nat.card {P : W.Point // f P = Q} = Nat.card f.ker := + Nat.card_eq_of_bijective _ (fiberEquivKer f hP₀).bijective +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobMatrixData.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobMatrixData.lean +index 30cf18d00..7da5769f2 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobMatrixData.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobMatrixData.lean +@@ -9,7 +9,7 @@ import HasseWeil.Isogeny.BaseChange.Basic + /-! + # Frobenius matrix data over the algebraic closure + +-This file supplies the per-`ℓ` Frobenius-matrix determinant data used by ++The per-`ℓ` Frobenius-matrix determinant data give the hypotheses of + `hasse_bound_via_weil_pairing`, after base-changing `E/K` to `AlgebraicClosure K`. + + ## Main definitions +@@ -29,10 +29,6 @@ This file supplies the per-`ℓ` Frobenius-matrix determinant data used by + * Silverman, *The Arithmetic of Elliptic Curves*, III.8.1 (the pairing + Galois equivariance), + III.8.6 (`det φ_ℓ = deg φ`), V.1.1 / V.2.3.1 (the Hasse bound assembly). + +-## Name-clash note +- +-`pullbackDivisor_kappaDivisor` is declared in both `HfactLemma.lean` and `PairingNondeg.lean`. +-This file imports neither directly, so no clash arises and no rename is needed. + -/ + + open WeierstrassCurve Real Matrix +@@ -155,7 +151,7 @@ theorem frob_det_residual_baseChange + (1 - M).det = ((Fintype.card K + 1 - + isogTrace (frobeniusIsog W) (isogOneSub_negFrobenius W hq) : ℤ) : ZMod ℓ) ∧ + ((r' : ZMod ℓ) • M - (s' : ZMod ℓ) • 1).det = (deg r' s' : ZMod ℓ) := by +- letI : Fact ℓ.Prime := ⟨hℓp⟩ ++ let : Fact ℓ.Prime := ⟨hℓp⟩ + obtain ⟨hπ, h1, hrs⟩ := hsc + have hDd : ((deg r' s').toNat : ℤ) = deg r' s' := Int.toNat_of_nonneg (hdeg_nonneg r' s') + exact frob_det_residual_of_weil_scaling (W.baseChange L) ℓ hℓF +@@ -193,7 +189,7 @@ theorem hres_of_baseChange_scalings + (1 - M).det = ((Fintype.card K + 1 - + isogTrace (frobeniusIsog W) (isogOneSub_negFrobenius W hq) : ℤ) : ZMod ℓ) ∧ + ((r' : ZMod ℓ) • M - (s' : ZMod ℓ) • 1).det = (deg r' s' : ZMod ℓ) := by +- haveI : CharP L p := charP_of_injective_algebraMap (FaithfulSMul.algebraMap_injective K L) p ++ have : CharP L p := charP_of_injective_algebraMap (FaithfulSMul.algebraMap_injective K L) p + obtain ⟨hFrob, hOneSub, hPencil⟩ := hscale + intro r' s' hps ℓ hℓp hℓne + have hℓF : (ℓ : L) ≠ 0 := +@@ -218,7 +214,7 @@ theorem hres_of_baseChange_scalings_coprime + (1 - M).det = ((Fintype.card K + 1 - + isogTrace (frobeniusIsog W) (isogOneSub_negFrobenius W hq) : ℤ) : ZMod ℓ) ∧ + ((r' : ZMod ℓ) • M - (s' : ZMod ℓ) • 1).det = (deg r' s' : ZMod ℓ) := by +- haveI : CharP L p := charP_of_injective_algebraMap (FaithfulSMul.algebraMap_injective K L) p ++ have : CharP L p := charP_of_injective_algebraMap (FaithfulSMul.algebraMap_injective K L) p + obtain ⟨hFrob, hOneSub, hPencil⟩ := hscale + intro r' s' hpr hps ℓ hℓp hℓne + have hℓF : (ℓ : L) ≠ 0 := +@@ -238,16 +234,16 @@ theorem hasse_bound_unconditional_of_baseChange_scalings + |(↑(pointCount W.toAffine) - ↑(Fintype.card K) - 1 : ℝ)| ≤ + 2 * Real.sqrt (Fintype.card K : ℝ) := by + obtain ⟨p, hCharP, ⟨n, _hn⟩, hp_prime, hcard⟩ := FiniteField.card' K +- haveI : Fact p.Prime := ⟨hp_prime⟩ +- haveI : CharP K p := hCharP +- haveI : Fact (Fintype.card K = p ^ (n : ℕ)) := ⟨hcard⟩ ++ have : Fact p.Prime := ⟨hp_prime⟩ ++ have : CharP K p := hCharP ++ have : Fact (Fintype.card K = p ^ (n : ℕ)) := ⟨hcard⟩ + have hpchar : ringChar K = p := by rw [ringChar.eq_iff]; exact hCharP +- haveI : ExpChar (AlgebraicClosure K) p := ++ have : ExpChar (AlgebraicClosure K) p := + haveI : CharP (AlgebraicClosure K) p := + charP_of_injective_algebraMap + (FaithfulSMul.algebraMap_injective K (AlgebraicClosure K)) p + ExpChar.prime hp_prime +- haveI : (W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic := inferInstance ++ have : (W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic := inferInstance + exact hasse_bound_via_weil_pairing W hq deg hdeg_nonneg + (hres_of_baseChange_scalings W p (n : ℕ) (AlgebraicClosure K) hq deg hdeg_nonneg hpchar + (hscale p (n : ℕ) ⟨hp_prime⟩ hCharP ⟨hcard⟩)) +@@ -261,16 +257,16 @@ theorem hasse_bound_unconditional_of_baseChange_scalings_coprime + |(↑(pointCount W.toAffine) - ↑(Fintype.card K) - 1 : ℝ)| ≤ + 2 * Real.sqrt (Fintype.card K : ℝ) := by + obtain ⟨p, hCharP, ⟨n, _hn⟩, hp_prime, hcard⟩ := FiniteField.card' K +- haveI : Fact p.Prime := ⟨hp_prime⟩ +- haveI : CharP K p := hCharP +- haveI : Fact (Fintype.card K = p ^ (n : ℕ)) := ⟨hcard⟩ ++ have : Fact p.Prime := ⟨hp_prime⟩ ++ have : CharP K p := hCharP ++ have : Fact (Fintype.card K = p ^ (n : ℕ)) := ⟨hcard⟩ + have hpchar : ringChar K = p := by rw [ringChar.eq_iff]; exact hCharP +- haveI : ExpChar (AlgebraicClosure K) p := ++ have : ExpChar (AlgebraicClosure K) p := + haveI : CharP (AlgebraicClosure K) p := + charP_of_injective_algebraMap + (FaithfulSMul.algebraMap_injective K (AlgebraicClosure K)) p + ExpChar.prime hp_prime +- haveI : (W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic := inferInstance ++ have : (W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic := inferInstance + exact hasse_bound_via_weil_pairing_both W hq deg hdeg_nonneg + (hres_of_baseChange_scalings_coprime W p (n : ℕ) (AlgebraicClosure K) hq deg + hdeg_nonneg hpchar +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobeniusDivisorGalois.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobeniusDivisorGalois.lean +index a5cecf0c5..2cc3630be 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobeniusDivisorGalois.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobeniusDivisorGalois.lean +@@ -14,7 +14,7 @@ import HasseWeil.Foundation.Curves.Valuation.NoFinitePolesBridge + /-! + # Divisor Galois descent for the arithmetic Frobenius `σ` of `K̄(E)` + +-This file applies the abstract divisor-Galois-descent engine (`DivisorGalois.lean`) to the concrete ++Divisor Galois descent for the concrete + arithmetic Frobenius `σ = frobeniusFunctionFieldEquiv W` of the function field `K̄(E)`, proving the + affine order transport + +@@ -112,19 +112,19 @@ theorem pointValuation_frobeniusFunctionFieldEquiv + (frobeniusFunctionFieldEquiv W g) = + (⟨(W.baseChange (AlgebraicClosure K)).toAffine⟩ : + SmoothPlaneCurve (AlgebraicClosure K)).pointValuation Q g := by +- haveI hMell : ((W.baseChange (AlgebraicClosure K)).map ++ have hMell : ((W.baseChange (AlgebraicClosure K)).map + (coeffFrobEquiv (K := K) : + AlgebraicClosure K →+* AlgebraicClosure K)).toAffine.IsElliptic := by + rw [map_coeffFrobEquiv_eq W]; infer_instance +- haveI hMic : IsIntegrallyClosed (⟨((W.baseChange (AlgebraicClosure K)).map ++ have hMic : IsIntegrallyClosed (⟨((W.baseChange (AlgebraicClosure K)).map + (coeffFrobEquiv (K := K) : AlgebraicClosure K →+* AlgebraicClosure K)).toAffine⟩ : + SmoothPlaneCurve (AlgebraicClosure K)).CoordinateRing := by + rw [map_coeffFrobEquiv_eq W]; infer_instance +- haveI hMdd : IsDedekindDomain (⟨((W.baseChange (AlgebraicClosure K)).map ++ have hMdd : IsDedekindDomain (⟨((W.baseChange (AlgebraicClosure K)).map + (coeffFrobEquiv (K := K) : AlgebraicClosure K →+* AlgebraicClosure K)).toAffine⟩ : + SmoothPlaneCurve (AlgebraicClosure K)).CoordinateRing := + SmoothPlaneCurve.isDedekindDomain_coordinateRing _ +- haveI hEdd : IsDedekindDomain (⟨(W.baseChange (AlgebraicClosure K)).toAffine⟩ : ++ have hEdd : IsDedekindDomain (⟨(W.baseChange (AlgebraicClosure K)).toAffine⟩ : + SmoothPlaneCurve (AlgebraicClosure K)).CoordinateRing := + SmoothPlaneCurve.isDedekindDomain_coordinateRing _ + rw [frobeniusFunctionFieldEquiv, RingEquiv.trans_apply, ffFrobCast, +@@ -144,9 +144,8 @@ theorem pointValuation_frobeniusFunctionFieldEquiv + (by rw [pointOnMapped_x, hPx]) (by rw [pointOnMapped_y, hPy])).symm) g + + /- The order-at-infinity transport `ordAtInfty (σ g) = ordAtInfty g`: the arithmetic Frobenius `σ` +-fixes the place at infinity. Mirrors `OrdAtInftyBaseChange.lean` (the base-change `ord_∞` +-transport), replacing the injective `algebraMap K L` by the coefficient Frobenius `coeffFrobEquiv` +-(also injective). -/ ++fixes the place at infinity. Injectivity of the coefficient Frobenius identifies the ++orders of the corresponding norm polynomials. -/ + + /-- `crFrobEquiv` (= `CoordinateRing.map e`) on the `K̄[X]`-basis decomposition `p • 1 + q • y`: + it sends the coefficients `p, q` through `Polynomial.map e` and fixes the basis `{1, y}`. +@@ -305,7 +304,7 @@ omit [DecidableEq K] [W.toAffine.IsElliptic] + ((FiniteField.frobeniusAlgEquivOfAlgebraic K (AlgebraicClosure K)).symm P.y) = P.y + rw [AlgEquiv.coe_ringEquiv, AlgEquiv.apply_symm_apply] + +-omit [W.toAffine.IsElliptic] [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] in ++omit [W.toAffine.IsElliptic] [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] [DecidableEq K] in + /-- **`π̄` recovers `P` from its inverse-Frobenius point** (at the affine-point level): + `geomFrobeniusPointFun (geomFrobSmoothPointInv P).toAffinePoint = P.toAffinePoint`. -/ + theorem geomFrobeniusPointFun_geomFrobSmoothPointInv +@@ -341,6 +340,7 @@ open HasseWeil + + omit [W.toAffine.IsElliptic] in + set_option backward.isDefEq.respectTransparency false in ++omit [DecidableEq K] in + /-- **The fibre-divisor place comparison** (the combinatorial heart of σ-naturality). The + coefficient of the fibre divisor `[ℓ]^*(π̄T)` at an affine place `P` equals the coefficient of + `[ℓ]^*(T)` at the inverse-Frobenius place `geomFrobSmoothPointInv P`, because +@@ -382,6 +382,7 @@ theorem pullbackDiv_geomFrobInv_eq (ℓ : ℤ) (hℓ : (ℓ : AlgebraicClosure K + + omit [W.toAffine.IsElliptic] in + set_option backward.isDefEq.respectTransparency false in ++omit [DecidableEq K] in + /-- **The fibre-divisor place comparison at infinity**: + `pullbackDiv [ℓ] (π̄T) ∞ = pullbackDiv [ℓ] T ∞` (both equal `if 0 = Q`, and `0 = π̄T ⟺ 0 = T` since + π̄ is injective with `π̄ 0 = 0`). -/ +@@ -500,7 +501,7 @@ theorem frobeniusFunctionFieldEquiv_weilFunction_eq_smul + (W.baseChange (AlgebraicClosure K)).toAffine.FunctionField c * + weilFunction (W.baseChange (AlgebraicClosure K)) ℓ hℓ + (HasseWeil.geomFrobeniusPoint W T) hπT := by +- haveI hEdd : IsDedekindDomain (⟨(W.baseChange (AlgebraicClosure K)).toAffine⟩ : ++ have hEdd : IsDedekindDomain (⟨(W.baseChange (AlgebraicClosure K)).toAffine⟩ : + SmoothPlaneCurve (AlgebraicClosure K)).CoordinateRing := + SmoothPlaneCurve.isDedekindDomain_coordinateRing _ + set gT := weilFunction (W.baseChange (AlgebraicClosure K)) ℓ hℓ T hT with hgT +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobeniusGenericCovariance.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/FrobeniusGenericCovariance.lean +index 2e94ad5e465c6dada76ce68439b6c5d25480b4c3..86c212da5910eadae69fd7f1828430aaa2ee4c24 100644 +GIT binary patch +delta 1209 +zcmb7E&1(}u6eq1;EL8eQOKs)RT1+t6QYk70LHr~Zv6$RS+nwxAvIDy_o0-|Py%>dF +zyeWJ0YPT-f7?!fp8C)21U82(&hoHYY=sCDh_CIqQtbq*&?JGr&}397Lo?F;Xzx3VXPT% +zAZ8&w#t9CK#4eQzcA54;OTtw^G!xu3mb5M;(qS#CEa&iGrvmvp@`jBaq*#EvkbS`o +zWP`}^hp(VgaBRzZLF?E7Wm$s?3y^o1ER2;#R#Qsla@oFP-|V~`d!Ng71$sI$+dfvu +zw#wQlBxximlGoJhYImkgP@^u1Q8crfaVw?VAS97>EOx&OTGdxL(7uQpKFT}~oZ=uZ +zGl5CTd?hAAz +zjgVoWfJ9NS4+TR}k&s%_80m`;9~t>fg(eOed6kSVLA5xcjq!!ReO<3Q8 +z&1B{JVsbP-m3$~(8m{^@*|;*>J{>VKkftt>GXi%iW>v&utUKuiFb`d1df#&LBxul@ +zB+p0$dxh;L<_Ig7`=$KecC+B5=vS_OI@e3bg~d7Bs>j?l;Vh-rb;VIOJm-VFac~MC +z`F?G-GrIKd;>_Rt8Ml^8C3up&9-2<SBl89v}V#6%nlU + +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/HfactLemma.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/HfactLemma.lean +index 66737344a..5d4f80a0a 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/HfactLemma.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/HfactLemma.lean +@@ -9,57 +9,21 @@ import HasseWeil.HasseBound.WeilPairing.Constancy + import HasseWeil.Pic0.PicDual + + /-! +-# The separable divisor factorisation `hfact` (Silverman III.8.2 / III.6.1b) ++# Divisor factorization for the separable Weil-pairing adjoint + +-This file discharges the **divisor factorisation hypothesis** `hfact` of +-`HasseWeil.WeilPairing.weilPairing_adjoint_core` (the separable adjoint, Silverman III.8.2): for a +-separable isogeny `φ : E → E`, the Weil functions `g_T = weilFunction W ℓ T`, `g_U = weilFunction +-W ℓ U` (with `U = picDual φ T = φ̂ T`), and an appropriate `k ∈ K(E)`, +-``` +-φ^* g_T = c · (g_U · ([ℓ]^* k)) for some c ∈ Fˣ. +-``` ++Let `g_T` and `g_U` be Weil functions, and suppose the projective-divisor class ++identity `φ*((T) − (O)) ∼ (U) − (O)` holds. Divisor pullback functoriality and ++commutation with multiplication by `ℓ` then give ++`div(φ*g_T) = div(g_U · ([ℓ]*k))` for a suitable function `k`. ++Functions with the same projective divisor differ by a nonzero base-field ++constant, so `φ*g_T = c · g_U · ([ℓ]*k)`. + +-## The mathematics (Silverman III.8.2 proof, divisor language) +- +-Write `div g_T = [ℓ]^*((T) − (O))` (`weilFunction_divisor`, the fibre-difference divisor). Then +- +-* `div(φ^* g_T) = φ^*(div g_T) = φ^*([ℓ]^*((T) − (O)))` — the divisor-pullback functoriality +- `div(φ^* h) = φ^*(div h)` for the separable `φ` (`DivisorPullback.ProjOrdTransport φ`, the +- analogue of `projOrdTransport_mulByInt` for `[ℓ]`); +-* `φ^* ∘ [ℓ]^* = [ℓ]^* ∘ φ^*` on divisors (the function-field shadow of `[ℓ] ∘ φ = φ ∘ [ℓ]`, which +- holds for *any* additive point maps: `[ℓ]` commutes with every homomorphism) — proven here as +- `pullbackDivisor_comm`; +-* the **`picDual` divisor-class identity** (Silverman III.6.1b, the genuine separability content) +- `φ^*((T) − (O)) ∼ (U) − (O)` with `U = φ̂ T`, i.e. `φ^*(kappaDivisor T) − kappaDivisor U` is +- principal `= div k₀` — isolated below as the single minimal hypothesis `PicDualDivisorClass φ` +- (a projective-divisor avatar of `PicDual.Naturality`, see the residual note). +- +-Combining: `div(φ^* g_T) = [ℓ]^*(φ^*(kappaDivisor T)) = [ℓ]^*(kappaDivisor U + div k₀) = div(g_U) + +-div([ℓ]^* k₀) = div(g_U · [ℓ]^* k₀)`. Two functions with the same projective divisor differ by a +-nonzero constant `c ∈ Fˣ` (`Constancy.const_unit_of_projectiveDivisorOf_eq_zero`), which is exactly +-`hfact`. +- +-## The isolated minimal residual `PicDualDivisorClass` +- +-The decisive ingredient is the divisor-class identity `φ^*((T) − (O)) ∼ (φ̂ T) − (O)` *expressed in +-the projective-divisor model* `ProjectiveDivisor` (where `weilFunction_divisor`/`hfact` speak), +-namely `(⟨W⟩).ProjIsPrincipal (pullbackDivisor φ (kappaDivisor T) − kappaDivisor (φ̂ T))`. +- +-This is the **honest frontier**: `picDual = κ⁻¹ ∘ classMap ∘ κ` is defined in the *affine ideal +-class group* model `ClassGroup R` (`PicDual.lean`), where `classMap = ClassGroup.map` is the ideal +-extension `𝔪 ↦ 𝔪·𝒪` — Silverman's divisor pullback `φ^*`. But `hfact` lives in the *projective +-divisor* model `PicProj₀`/`projectiveDivisorOf`. The two `Pic⁰(E)` models are connected by `κ` +-(the canonical `E ≅ Pic⁰(E)` of III.3.4), but the repo carries no bridge `ClassGroup.map ↔ +-pullbackDivisor`; building it is exactly the `comap`-vs-`relNorm` (residue-degree) bookkeeping that +-`PicDual.Naturality` documents as carried per-isogeny data. We therefore isolate the divisor-class +-identity as the one minimal hypothesis `PicDualDivisorClass φ ch hinj hfin`, dischargeable per +-isogeny just as `ProjOrdTransport`/`Naturality` are throughout the project, and prove the *entire* +-`hfact` factorisation on top of it. +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, III.6.1 (the dual isogeny, `φ̂ = κ⁻¹ ∘ φ^* ∘ κ`), +- III.8.2 (Prop 8.2, the separable adjoint via the multiplicity-free pullback). ++The projective-divisor class identity is an explicit hypothesis. The ideal-class ++definition of `picDual` uses extension of ideals in the affine coordinate ring; ++identifying it with projective divisor pullback requires compatibility of those ++two models of `Pic⁰`. The factorization proofs retain this compatibility input. ++ ++References: Silverman, *The Arithmetic of Elliptic Curves*, III.6.1 and III.8.2. + -/ + + open WeierstrassCurve HasseWeil.Curves +@@ -68,8 +32,6 @@ namespace HasseWeil.WeilPairing + + open HasseWeil HasseWeil.WeilPairing.DivisorPullback + +-set_option linter.unusedSectionVars false +- + variable {F : Type*} [Field F] [DecidableEq F] + variable (W : WeierstrassCurve F) [W.toAffine.IsElliptic] + [IsIntegrallyClosed (⟨W.toAffine⟩ : SmoothPlaneCurve F).CoordinateRing] +@@ -78,13 +40,14 @@ local notation "KE" => W.toAffine.FunctionField + + /-! ### Commutation of fibre-pullback divisors `φ^* ∘ ψ^* = (ψ ∘ φ)^*` + +-The fibre-pullback `pullbackDivisor f` (`DivisorPullback.lean`) transports a coefficient along the ++The fibre-pullback `pullbackDivisor f` transports a coefficient along the + point map `f`: `(pullbackDivisor f D) w = D (f w)` (`pullbackDivisor_apply`). Hence two such + pullbacks compose by composing the point maps in the *opposite* order: + `pullbackDivisor f (pullbackDivisor g D) w = D (g (f w))`. We only need the special case where the + two maps **commute** as point endomorphisms (`g ∘ f = f ∘ g`), which is automatic when one of them + is `[ℓ]` (multiplication-by-`ℓ` commutes with every additive hom). -/ + ++omit [IsIntegrallyClosed (⟨W.toAffine⟩ : SmoothPlaneCurve F).CoordinateRing] in + /-- **Fibre-pullback divisors of commuting point maps commute.** If `f g : E.Point →+ E.Point` + commute (`g.comp f = f.comp g` — automatic when one is `[ℓ]`), then their fibre-pullback divisor + operators commute: `pullbackDivisor f (pullbackDivisor g D) = pullbackDivisor g (pullbackDivisor f +@@ -110,11 +73,10 @@ theorem pullbackDivisor_comm {f g : W.toAffine.Point →+ W.toAffine.Point} + `pullbackDivisor [ℓ] (kappaDivisor T)` of the Abel–Jacobi divisor `(T) − (O) = kappaDivisor T` + (`pullbackDivisor` distributes over the difference of the two `single`s; `∞.toAffinePoint = O`). -/ + ++omit [IsIntegrallyClosed (⟨W.toAffine⟩ : SmoothPlaneCurve F).CoordinateRing] in + /-- **The fibre-pullback of `(T) − (O)` is `[ℓ]^*(T) − [ℓ]^*(O)`** (= `div g_T`). The fibre-pullback + `pullbackDivisor [ℓ]` of `kappaDivisor T = (T) − (O)` equals `pullbackDiv [ℓ] T − pullbackDiv [ℓ] +-O`. (Local copy of `PairingNondeg.pullbackDivisor_kappaDivisor`, kept here to avoid the import; +-named `…_local` to avoid the cross-file name clash with the `PairingNondeg` copy, so that downstream +-files importing both `HfactLemma` and `DetDeg`/`PairingNondeg` — e.g. `SeparableScaling` — compile.) ++O`. + -/ + theorem pullbackDivisor_kappaDivisor_local (ℓ : ℤ) + [hker : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker] (T : W.toAffine.Point) : +@@ -135,7 +97,7 @@ theorem weilFunction_divisor_eq_pullbackDivisor_kappaDivisor [IsAlgClosed F] + (⟨W.toAffine⟩ : SmoothPlaneCurve F).projectiveDivisorOf (weilFunction W ℓ hℓ T hT) = + pullbackDivisor (W := W.toAffine) (mulByInt W.toAffine ℓ).toAddMonoidHom + (mulByInt_ker_finite W ℓ hℓ) (Curves.kappaDivisor W.toAffine T) := by +- haveI : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ ++ have : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ + rw [show (⟨W.toAffine⟩ : SmoothPlaneCurve F).projectiveDivisorOf (weilFunction W ℓ hℓ T hT) = + (W_smooth W).projectiveDivisorOf (weilFunction W ℓ hℓ T hT) from rfl, + weilFunction_divisor W ℓ hℓ T hT, pullbackDivisor_kappaDivisor_local W ℓ T] +@@ -146,7 +108,7 @@ theorem weilFunction_divisor_eq_pullbackDivisor_kappaDivisor [IsAlgClosed F] + fibre-pullback `φ^*((T) − (O))` is *linearly equivalent* to `(φ̂ T) − (O)` (with `φ̂ = picDual φ`), + i.e. their difference `pullbackDivisor φ (kappaDivisor T) − kappaDivisor (φ̂ T)` is principal. This + is the one ingredient that cannot be assembled from the project's *projective*-model API: `picDual` +-is built from the *affine* ideal-class-group divisor pullback `classMap` (`PicDual.lean`), and the ++is built from the *affine* ideal-class-group divisor pullback `classMap`, and the + ClassGroup↔ProjectiveDivisor bridge is the carried `PicDual.Naturality` data (the `comap`-vs- + `relNorm`/residue-degree bookkeeping). Everything else in `hfact` is proven on top of this. -/ + +@@ -209,7 +171,7 @@ theorem hfact_projectiveDivisorOf_eq (ℓ : ℤ) (hℓ : (ℓ : F) ≠ 0) + (φ.pullback (weilFunction W ℓ hℓ T hT)) = + (⟨W.toAffine⟩ : SmoothPlaneCurve F).projectiveDivisorOf + (weilFunction W ℓ hℓ U hU * (mulByInt W.toAffine ℓ).pullback k₀) := by +- haveI hker : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ ++ have hker : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ + have hcoreℓ : ProjOrdTransport (mulByInt W.toAffine ℓ) := projOrdTransport_mulByInt ℓ hℓ + set κT := Curves.kappaDivisor W.toAffine T + set κU := Curves.kappaDivisor W.toAffine U with hκU +@@ -274,7 +236,7 @@ theorem hfact_of_picDualDivisorClass (ℓ : ℤ) (hℓ : (ℓ : F) ≠ 0) + (weilFunction W ℓ hℓ ((φ.picDual ch hinj hfin) T) + (by rw [← map_zsmul, hT, map_zero]) * + (mulByInt W.toAffine ℓ).pullback k) := by +- haveI : IsDedekindDomain (⟨W.toAffine⟩ : SmoothPlaneCurve F).CoordinateRing := inferInstance ++ have : IsDedekindDomain (⟨W.toAffine⟩ : SmoothPlaneCurve F).CoordinateRing := inferInstance + have hU : ℓ • (φ.picDual ch hinj hfin) T = 0 := by rw [← map_zsmul, hT, map_zero] + -- The Abel–Jacobi function `k₀` of the `picDual` divisor-class identity, and its divisor. + obtain ⟨k₀, hk₀_ne, hk₀_div⟩ := hpd T +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/OneSubDualDivisor.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/OneSubDualDivisor.lean +index d3000b32d30e10c2b46fc50f6a717384d41259f1..4a6db4566facbd1bd32e68b7dfa22044d93fa66b 100644 +GIT binary patch +delta 1573 +zcmah}&5ImG6lXU0vBl!9n;17SA1|6U)7smxCJt^e=w(9&1Xr^dNKEXS?waW`-BoQ> +z^@KUdBqRm}5wvpfAd89@5g}wedGL@wAREDpm!Ny|;vXOcebv3QnZywRe)+a`{kxid?Ab^BxS%P>Hc-$kr;4^x23*Sy6FowXOEvnzc7w*#K2Q-uuH?Hc +zGQ7(`s+cKa6csv`%J^U}9ouQQ2anr3hxWW(?#_zT@I2*AlbCfBV;WjL2%kC66s%tj +z185pB2~(^s6<#mmBEl_H028syq{{=R-d$ZEo%&0C5s=pq9iGhw*tK?eb82-h#y*RP&? +zu8zO3;=#s;pF#a~&-36IxSsJfzP$J~tb{&jNy1w{;GWMB3T`;FiRvtN==eii(4v|_ +zlu*$@y4r6*xLDR)zZim%4kt}JtfeTAAWEe!6!Y;M*HEgXSV|3-!Y8g)Mc`J;r5yIt +z<+(o3^0Zf87fGcUiXmbyI&g~dbRnl)xd$E56#s*gfJh2$RDm)|0fk27BeKT4i#||J +z29#TJVIZTqh6~&zvM}h2NTT#yP{S6mwtabWcIr*mMim9BM~I!BJ_3h>BR({n&7cu1 +z)?40i{X(7M8Y|nI(?8W#2OrOTGGVX1c+h^Z{hFN)o)|3c_wo`{=2+UkI=^FoUZg3~8l86p=6HR?b2Rd>>A`RQjY+J#*0?e;$d~?@oU3pH8f=7p +zbh!Qd#BTfO>HYo9qZQ>2GdCI`X1Ub7BxooDL6W-Yn3C#JpqLt3Rvt?=IIktWT%vl8 +zV~Q3Z;kg_iFbB5ghoJt|Y&l1wG9~%iN0Fc0T}|H@9}xTJnSC=SdD>+vLr1+8ECz?Y +z!R+yq6T8N>1+Hm(_rzSktz=eVsT406AoY8t#>?m70NxKw7x~bE|1#-=fbZqSUL2wE +zfJ=WM=xuJ)*BVc~f~t`JQpHJyBR$08{88Ei`P&SQaPZA*zfK)+O^+pH7y^!zoe#i& +z$@$kiYL`wo`_4k>xXcB`#ubY>^CjeAHBtAOs0tIO)i@jZa3SFswqb%~y~EzaC simp only [hax, hay] + +-/-- **The base-changed `(1 − π)_{K̄}` point map is `id − geomFrobenius`** (= `oneSubGeomFrobHom`), +-over `L = AlgebraicClosure K`. Combines the constructional `toAddMonoidHom = id − π̄` +-(`oneSubFrobeniusIsogBaseChange_toAddMonoidHom`) with the linchpin `π̄ = geomFrobeniusPoint`. -/ ++omit [DecidableEq K] in ++/-- The base-changed `1 − π` point map is the difference of the identity and geometric ++Frobenius over the algebraic closure. -/ + theorem oneSubFrobeniusIsogBaseChange_toAddMonoidHom_eq_oneSubGeomFrobHom + [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] + (pullback_L : (W.baseChange (AlgebraicClosure K)).toAffine.FunctionField →ₐ[AlgebraicClosure K] +@@ -260,13 +205,9 @@ variable (p r : ℕ) [Fact p.Prime] [CharP K p] [Fact (Fintype.card K = p ^ r)] + + noncomputable local instance instDecEqAC' : DecidableEq (AlgebraicClosure K) := Classical.decEq _ + +-/-- **Witness 1 — `finiteKer`** (PROVED, axiom-clean): the kernel of `(1 − π)_{K̄}` is finite. +- +-Via the linchpin, `ker(id − π̄) = ker(oneSubGeomFrobHom)`, whose underlying set is the +-geometric-Frobenius fixed locus `= range(includePointBC)` (Step S2/S3 of +-`FrobeniusFixedPoint.lean`), +-i.e. the image of the **finite** point set `E(𝔽_q) = W.toAffine.Point` under the base-change +-inclusion — hence finite. -/ ++omit [DecidableEq K] in ++/-- The kernel of base-changed `1 − π` is finite: it is the geometric-Frobenius fixed locus, ++which is the image of the finite rational point set under base change. -/ + theorem oneSubFrobeniusIsogBaseChange_finiteKer + [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] + (pullback_L : (W.baseChange (AlgebraicClosure K)).toAffine.FunctionField →ₐ[AlgebraicClosure K] +@@ -281,9 +222,9 @@ theorem oneSubFrobeniusIsogBaseChange_finiteKer + rw [← hset] at hfin + exact hfin.to_subtype + +-/-- **`#ker(1 − π)_{K̄} = pointCount W`** (PROVED, axiom-clean). Via the linchpin the kernel is the +-geometric-Frobenius fixed locus, whose cardinality is the `𝔽_q`-rational point count +-(`ncard_ker_oneSubGeomFrobHom_eq_pointCount`). This is the *clean half* of `hkerdeg`. -/ ++omit [DecidableEq K] in ++/-- The cardinality of the kernel of base-changed `1 − π` equals the rational point count, ++by its identification with the geometric-Frobenius fixed locus. -/ + theorem oneSubFrobeniusIsogBaseChange_nat_card_ker_eq_pointCount + [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] + (pullback_L : (W.baseChange (AlgebraicClosure K)).toAffine.FunctionField →ₐ[AlgebraicClosure K] +@@ -299,16 +240,9 @@ theorem oneSubFrobeniusIsogBaseChange_nat_card_ker_eq_pointCount + rw [hcard, ncard_ker_oneSubGeomFrobHom_eq_pointCount] + rfl + +-/-- **Witness 3 — `hkerdeg`, reduced to V.1.3** (axiom-clean reduction). Given the degree identity +-`φ_L.degree = pointCount W` (Silverman V.1.3, `isogOneSub_negFrobenius_degree_eq_pointCount` +-base-changed through `hdeg_bc` — the project's known sharp residual), the separable degree match +-`#ker(1 − π)_{K̄} = φ_L.degree` follows from the *proved* clean count +-`#ker = pointCount`. +- +-The V.1.3 degree identity is taken as a hypothesis so this reduction is itself axiom-clean and the +-V.1.3 dependence is explicit (the caller supplies `hdeg_eq` from +-`(oneSubFrobeniusIsogBaseChange_degree_eq_of_finrankBaseChange W p r L hq).trans +- (isogOneSub_negFrobenius_degree_eq_pointCount W hq)` once `hq` is available). -/ ++omit [DecidableEq K] in ++/-- The degree identity of Silverman V.1.3, supplied as a hypothesis, identifies the ++kernel cardinality with the degree of the base-changed `1 − π` isogeny. -/ + theorem oneSubFrobeniusIsogBaseChange_hkerdeg_of_degree_eq_pointCount + [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] + (pullback_L : (W.baseChange (AlgebraicClosure K)).toAffine.FunctionField →ₐ[AlgebraicClosure K] +@@ -321,11 +255,9 @@ theorem oneSubFrobeniusIsogBaseChange_hkerdeg_of_degree_eq_pointCount + (oneSubFrobeniusIsogBaseChange W p r (AlgebraicClosure K) pullback_L).degree := by + rw [oneSubFrobeniusIsogBaseChange_nat_card_ker_eq_pointCount, hdeg_eq] + +-omit [Fintype W.toAffine.Point] in +-/-- **Witness 2 — `hsurj` from the dual composition `φ ∘ δ = [N]`** (axiom-clean reduction). For +-any `N` with `(N : K̄) ≠ 0`, surjectivity of `[N]` on `E(K̄)`-points (`mulByInt_point_surjective`) +-turns the dual composition `φ ∘ δ = [N]` into surjectivity of `φ`. This is the second consequence +-(alongside `hdc`) of bundling the divisor-pushforward dual as an `IsDualOf`. -/ ++omit [Fintype W.toAffine.Point] [DecidableEq K] in ++/-- A dual composition `φ ∘ δ = [N]`, with `N` nonzero in the algebraic closure, implies ++surjectivity of `φ` by surjectivity of multiplication by `N` (Silverman III.4.10). -/ + theorem oneSubFrobeniusIsogBaseChange_hsurj_of_self_comp_dual + [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] + (pullback_L : (W.baseChange (AlgebraicClosure K)).toAffine.FunctionField →ₐ[AlgebraicClosure K] +@@ -363,14 +295,10 @@ variable [(W.baseChange (AlgebraicClosure K)).toAffine.IsElliptic] + (⟨(W.baseChange (AlgebraicClosure K)).toAffine⟩ : SmoothPlaneCurve + (AlgebraicClosure K)).CoordinateRing] + +-/-- **Assemble `OneSubScalingData` over `K̄` from only the still-open witnesses.** +- +-Discharges `pullback_L` (concrete `oneSubFrobeniusPullback_L`), `hdeg_bc` (proved, no hypothesis), +-`finiteKer` (proved), `hkerdeg` (from the V.1.3 identity `hdeg_eq`), and `hsurj` (from the +-dual composition +-`hself` + `mulByInt_point_surjective`). The caller supplies only the genuinely-deep divisor-level +-residuals: the dual `δ` with *both* composition identities `hdc`/`hself` (an `IsDualOf`), the +-divisor-pullback functoriality `hproj`, and the translation covariance `hcomm'`. -/ ++/-- Scaling data over the algebraic closure constructed from the degree identity, both dual ++composition identities, divisor-pullback functoriality, and translation covariance. The ++geometric-Frobenius fixed locus supplies the finite kernel and its cardinality; the second ++dual composition supplies surjectivity. -/ + noncomputable def mkOneSubScalingDataConcrete_of_witnesses (hq : 2 ≤ Fintype.card K) + (hdeg_eq : + (oneSubFrobeniusIsogBaseChange W p r (AlgebraicClosure K) +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingNondeg.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingNondeg.lean +index 18c4b2749..327e9d223 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingNondeg.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingNondeg.lean +@@ -13,7 +13,7 @@ import HasseWeil.HasseBound.WeilPairing.TorsionCardEll + /-! + # Nondegeneracy of the Weil pairing + +-This file proves that the finite-level Weil pairing over an algebraically closed field is ++We prove that the finite-level Weil pairing over an algebraically closed field is + nondegenerate in its second argument. The proof uses surjectivity of multiplication on curve + points, injectivity of divisor pullback, the Galois fixed-field description, and Abel--Jacobi. + +@@ -154,7 +154,7 @@ theorem aut_eq_translate (ℓ : ℤ) (hℓ0 : ℓ ≠ 0) + (mulByInt W.toAffine ℓ).toAlgebra (mulByInt W.toAffine ℓ).toAlgebra) : + ∃ k : W.toAffine.Point, ℓ • k = 0 ∧ + ∀ z : KE, σ z = translateAlgEquivOfPoint W k z := by +- letI := (mulByInt W.toAffine ℓ).toAlgebra ++ let := (mulByInt W.toAffine ℓ).toAlgebra + have hcov := hcov_mulByInt_of_xy W ℓ hℓ0 (hxy_mulByInt W ℓ hℓ0) + set forward := kernelTranslateForwardAut W (mulByInt W.toAffine ℓ) hcov with hfwd_def + obtain ⟨k, hk_mem, hk_lift⟩ := hdesc_mulByInt W ℓ hℓ0 σ +@@ -183,10 +183,10 @@ theorem mem_pullback_range_of_translate_fixed (ℓ : ℤ) (hℓ : (ℓ : F) ≠ + translateAlgEquivOfPoint W S g = g) : + ∃ h : KE, (mulByInt W.toAffine ℓ).pullback h = g := by + have hℓ0 : ℓ ≠ 0 := by rintro rfl; norm_num at hℓ +- letI := (mulByInt W.toAffine ℓ).toAlgebra +- haveI hfin : @FiniteDimensional KE KE _ _ (mulByInt W.toAffine ℓ).toAlgebra.toModule := ++ let := (mulByInt W.toAffine ℓ).toAlgebra ++ have hfin : @FiniteDimensional KE KE _ _ (mulByInt W.toAffine ℓ).toAlgebra.toModule := + isogeny_finiteDimensional W (mulByInt W.toAffine ℓ) +- haveI hgal : @IsGalois KE _ KE _ (mulByInt W.toAffine ℓ).toAlgebra := ++ have hgal : @IsGalois KE _ KE _ (mulByInt W.toAffine ℓ).toAlgebra := + Isogeny.isGalois_of_isSeparable_and_normal (mulByInt W.toAffine ℓ) + (mulByInt_isSeparable W ℓ hℓ) (h_normal_mulByInt W ℓ hℓ0) + have hfix : ∀ σ : @AlgEquiv KE KE KE _ _ _ +@@ -217,7 +217,7 @@ theorem weilPairing_nondegenerate (ℓ : ℤ) (hℓ : (ℓ : F) ≠ 0) + (h_deg : ∀ S : W.toAffine.Point, (hS : ℓ • S = 0) → + weilPairing W ℓ hℓ S T hS hT = 1) : + T = 0 := by +- haveI hker : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ ++ have hker : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ + obtain ⟨h, hh⟩ := mem_pullback_range_of_translate_fixed W ℓ hℓ (fun S hS ↦ by + rw [weilPairing_translate W ℓ hℓ S T hS hT, h_deg S hS, map_one, one_mul]) + apply eq_zero_of_kappaDivisor_principal W +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingProps.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingProps.lean +index 403c142bc..70880d716 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingProps.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PairingProps.lean +@@ -9,9 +9,9 @@ import HasseWeil.HasseBound.WeilPairing.Pairing + /-! + # Weil-pairing properties: bilinearity in the second slot and alternating (Silverman III.8.1) + +-This file proves the two remaining structural properties of the finite-level Weil pairing +-`e_ℓ : E[ℓ] × E[ℓ] → F` (ticket `T-R2-PAIRING-PROPS`), over an algebraically closed field `F`, +-extending the slot-1 bilinearity `weilPairing_mul_left` from `Pairing.lean`: ++We prove bilinearity and alternation of the finite-level Weil pairing ++`e_ℓ : E[ℓ] × E[ℓ] → F`, over an algebraically closed field `F`, ++extending the slot-1 bilinearity `weilPairing_mul_left`: + + * `weilPairing_mul_right` — **bilinearity in the second slot** (Silverman III.8.1b): + `e_ℓ(S, T₁ + T₂) = e_ℓ(S, T₁) · e_ℓ(S, T₂)`. +@@ -112,7 +112,7 @@ theorem weilPairing_mul_right (ℓ : ℤ) (hℓ : (ℓ : F) ≠ 0) + weilPairing W ℓ hℓ S (T₁ + T₂) hS h₁₂ = + weilPairing W ℓ hℓ S T₁ hS hT₁ * weilPairing W ℓ hℓ S T₂ hS hT₂ := by + have hℓ0 : ℓ ≠ 0 := by rintro rfl; simp at hℓ +- haveI hker : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ ++ have hker : Finite (mulByInt W.toAffine ℓ).toAddMonoidHom.ker := mulByInt_ker_finite W ℓ hℓ + obtain ⟨k, hk_ne, hk_div⟩ := bilinDivisor_isPrincipal W T₁ T₂ + set u : KE := (mulByInt W.toAffine ℓ).pullback k + have hu_ne : u ≠ 0 := +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PencilDualDivisor.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/PencilDualDivisor.lean +index 5f516ab8e619e3cdfcf79eb728f53efdfb81a2c5..4401ef64fd20246d7f73d595ce01960cce1b673b 100644 +GIT binary patch +delta 2332 +zcmbVOzi%8x7}b$LF@+rj*nx1)hb%>V(%u>$k!`>fHjX7L6oIoq5sI_p-MPCVyR(~_ +zT^lQ)3z7u_M1iKEp`f5dLb?VzXebcE4ODdb188U|_-1zRhtFpdMOWNuc6R1{?|bik +z_sbWRuiyT@Uh(Uod_p!82^17dsieCRgOrJYN5ECmX5s*Rd2}DlP8WElV3#TeL5GSq +zgAP@YCR}6?)0FrUj_&_6PdZ7a#=j%*#Y1&ZI;9=lRPNORW7i* +zIl?zjTX2U-!6FE#47n&)sR#+8lZ?55zX8wI-!47XMN&Ep2^=2Sq5-lhSxmVA_I?`i +zfM>u3@o(5ZGz*$GXhsdCSRign1Vhq!!K%tre2ax3XqHPl>|6l=X_=pgw^)lwrazxr +z?^-}xTU*|e*KlZ!05~Dv!*)wZbJb}javv)xVB>Wm7K->HY6z{lVBWmyExzbbH>iPg +zj4D$$j7X_KP`jg*Mz0RJhGK3O{>pdws!_eoFivD}R^i_d(UK%o&x8VFFv5!A12~uU_sJ7C6njuV5ggc@*u^ +z;11BJ&2}Y)P7>osrX8+g7mC)Ri%`yT&x*r+XivG$B-2<=p-aoNtwi)UOS20eX)*>) +z9_=w1Q(yCbzyROoVmtn6@!2a%CAcfknWyXVJFD +zWM5e`vKZ$P_249`!Wg}2=aa{~rwErU)a%yA1K$o?HE5C%Pd|r^1RfzJmoZe!nDh|% +zbrX?3YX?snSJ`OoE@xJr|IejGGX%ioh_A<2)6uHDn6oi}y<2T;RP;wL{RAhGfq(Sz8-5=ew&uB>zWV87-5bXziZuv@7L9pi^SK~W +z5wbS2I3&H~*>XS7#PRgS*=G$ih+ZpIf>K45%=eXaS^}dl^&cyr>BA@A)W5#``y4q- +z85??SdA4gNOEEXcX)qRM=!1iSK7^I(Ku!I+agQCkrG0UB1yO=&%}!1cqwQnEV^tgs +z#+PJm90%wL9QNqFGHcFgp~R + +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Pullback.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Pullback.lean +index 6a6379829..9fe8fdd6a 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Pullback.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Pullback.lean +@@ -7,22 +7,16 @@ import HasseWeil.HasseBound.WeilPairing.Fiber + import HasseWeil.Foundation.Curves.Divisor.PicZero + + /-! +-# Route 2A — the multiplicity-free geometric divisor pullback (keystone) ++# Multiplicity-free geometric divisor pullback + +-For a **separable** point-map endomorphism `f` (étale fibres, `e = 1`), the pullback divisor is +-the mult-1 fibre sum `f*((Q)) = Σ_{fP=Q} (P)`. This is the central new object of the Weil-pairing +-route — the same divisor pullback Route 1 lacked, now in the multiplicity-free regime — used by +-both the pairing construction (`div g = [ℓ]*((T)) − [ℓ]*((O))`) and the separable adjoint +-(Silverman III.8.2's function `h`). +- +-This file ships the definition and its **degree**: `deg(f*((Q))) = #fibre = #ker f` (Silverman +-III.4.10c, the separable case). The `σ`-bridge and the addition-formula linkage are downstream. ++For a separable point-map endomorphism `f`, the pullback of `(Q)` is the sum ++of the points in its finite fibre, each with multiplicity one. Its degree ++is the cardinality of the kernel, as in Silverman III.4.10(c). This divisor ++also gives the geometric group sum used in the dual isogeny formula. + -/ + + namespace HasseWeil.WeilPairing + +-set_option linter.unusedSectionVars false +- + open WeierstrassCurve + + variable {F : Type*} [Field F] [DecidableEq F] {W : WeierstrassCurve.Affine F} [W.IsElliptic] +@@ -44,7 +38,7 @@ noncomputable def pullbackDiv (f : W.Point →+ W.Point) (h : Finite f.ker) (Q : + /-- **Degree of the mult-1 pullback** (Silverman III.4.10c, separable): `deg(f*((Q))) = #ker f`. -/ + theorem degree_pullbackDiv (f : W.Point →+ W.Point) (h : Finite f.ker) {P₀ Q : W.Point} + (hP₀ : f P₀ = Q) : (pullbackDiv f h Q).degree = Nat.card f.ker := by +- letI : Fintype {P : W.Point // f P = Q} := @Fintype.ofFinite _ (fiber_finite f h Q) ++ let : Fintype {P : W.Point // f P = Q} := @Fintype.ofFinite _ (fiber_finite f h Q) + rw [pullbackDiv, ← Curves.ProjectiveDivisor.degreeHom_apply, map_sum] + simp only [Curves.ProjectiveDivisor.degreeHom_apply, degree_single, Finset.sum_const, + Finset.card_univ, nsmul_eq_mul, mul_one] +@@ -55,7 +49,7 @@ fibre). The start of the III.6.1(b) `σ`-bridge `σ(f*((Q))−f*((O))) = f̂(Q)` + theorem projectiveDivisorSum_pullbackDiv (f : W.Point →+ W.Point) (h : Finite f.ker) (Q : W.Point) : + letI : Fintype {P : W.Point // f P = Q} := @Fintype.ofFinite _ (fiber_finite f h Q) + Curves.projectiveDivisorSum W (pullbackDiv f h Q) = ∑ P : {P : W.Point // f P = Q}, P.val := by +- letI : Fintype {P : W.Point // f P = Q} := @Fintype.ofFinite _ (fiber_finite f h Q) ++ let : Fintype {P : W.Point // f P = Q} := @Fintype.ofFinite _ (fiber_finite f h Q) + rw [pullbackDiv, ← Curves.projectiveDivisorSumHom_apply, map_sum] + refine Finset.sum_congr rfl (fun P _ => ?_) + rw [Curves.projectiveDivisorSumHom_apply, Curves.projectiveDivisorSum_single, one_zsmul, +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Scaling/FrobeniusGalois.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Scaling/FrobeniusGalois.lean +index ef66a86e649eed9ded1a96df6f25baa29b62948a..8e90832e3d316d0e2eae1846034a1632be1da6fb 100644 +GIT binary patch +delta 2327 +zcmai0%WoS+7?(qM4Si7ML87McMJahG_NEaRNK>JZ5EKGPRV@ld(4EZA+Cz7DoY}EM +zs8FcNg(I3P0>qg^B};HbJyhxesr(Jxd*c97k@#lD-r7l;+~SRQzVG)O|MqL?Ve8J) +zz#t*jx>;Etordti?GR)Py3Th8bXGHRvL|D*TQm4YUws>P@(YIOl}rWjh%O=Fq$!*B%T1O5wSmo*vUDV +zf6J4D)w$2M&GRST8<>sS%@Z4^=L>|;IT3P3-5IfxDZE1yiCjcfQ(}HterY&w;x+=0 +zqtJy|F}I!?+S?JxwzfPZ)bdK0Y*8ibPUU@+prlQOL-Z~*8-Rc)WHS4bD_QJZ_Pn5m +zUO=xEL9M!|P{b-as{7F_ojN`3INqn+ep~@*e+>6aXL^u9EYVcv_p{^gF1f!sW#}Aa +z*!dR4vp(_8D3c!G-gs6ApiM1PsTy^Wr%B5E)shRC?71k)jKoiDER-&8f|=FxAM4 +z!d)vERGUlB6u}Jm2a$+lt}t=n%w*SOb*c~pS0dMf9kr;Lyf$Gzc=@E63I1&V6U+~q +z_t(jpKBBuNL;Afq??^g?mwo=RC17RRL(!8&?&N+=zTNcZ>~$M)^@0FuJmU%-j+*xr +z6q>QO0xZ%)YXI^(&LO&v!V23nDXsC7;ED3{t?uO>-L1d}1LA~qBDorR)8(aqWKYbT +z!Eq-Hq^@Jt2}X+GFWFwPrL_0NQo?e&>0OATyP$^*{`&SOxPbL!Q)tcC8&vCzZZch& +zc4{NSJT%Y%nxmIG0u{-b#^?m(IOl?a)v-3a^!H%NA)h%Cc^OSv<0ywRcV8JX-!GAK +zzDoKwETfHOOGF&ZkIN$i0YUE#w;!$kTq>;?`r7d4Or~km-b4Fa4rq*Cc2@}+0#RF0 +zT~lCD;DzMlPn{VGlOC7)aa12yek_r<33|-lIFH>L3B{R4CW~|x*sy(l`D0Pz8vRZ^ +zU`|AyXL##D|;ro*VE#1s3|U +z3&l-h!*ZaF5x%)I0TahG#ISj^`ht1!ji=39AKt%Fc-mcJD3?9jhN8Fx&~xF`=98Ms +aLUGMSj%_Y;>+00`ZV?{k+VPiq@T6vr6iG88ur20KlN->H_wY89K*NgZ4$Y7ZuaKy5HIX`|83(`uaEna#|s +zTLoP8;6pEk(k(gWBZPnsfk3~3X+J{2&|44jDdg5SE6bK3%1Nu8x9|7o{ocI&b>AJ;#vrE?lW^=QL1hg+*FMvmA6ee{mpI~Fy7w|ECTOM*H +zia$3N`ynIlM-+j`GJ`F;gsV!|2(vXIv7eZ5$e5ts@Gsi6Ra!Gwct+)f;=}3jA +zQirBkP)LJR+5wsCjEtNgIEfooN9TR}K2IULnPrF!22fAmPw`QfjWC3{Pg)&xJDr%GXCI}FB`01{P)75 +zP6_e;R~Sj*H|6WcaOXRasyJ9`6c6X-2fK?aGt-I&2TNbfO+9?I{NTd!l=iGquS2cY +zDxNbKY<~LF>}I5u<5JmjAd_J@i~Uf5&pBmvESju1sV)@9!9sDl_HlE#b|ZVGposbM +zSni``-snghnnR`)g(!x1-5`TEwWAMbwu`?Sm#<8}4xl(`T=}*dGN475v>-$BG3pe3 +zzF>Us&gfDVja-n&L_|>#bJ|Se;h9aY@ZjF(uRrMT(EIm?hwiNL?3Bf~C&3BSr=MW8 +oq9vY+?Kdridc*sq4W^)rXIJNo-)bKf(0p3FY_1IcX?`;MKVysjBLDyZ + +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Scaling/Separable.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/Scaling/Separable.lean +index af497faf2bb3780fc6a0ffbb0e47d99a5a4bc929..887cec98266c9fc13bfc5a472077ef8e615afbe0 100644 +GIT binary patch +delta 850 +zcmY+C!E4k&6vk-}1p{h9gx1rez3g_=1*;UX6j|`#LQ&|Z2QQjw<|UanI}>LnyIn!H +z2U)x+2Jz%UFZEc7c&mEzBJTgtf55v4`jWM!-ZGQ-zVCa#H%DKme;rI8-k!=grxx!B +zqau_7jpKMR0^>VMNDG3aw89R+$A`yH^V)dSalJaM!{pd;x9UEGDoIq|K&VwWfBSlF +zfk_UQRJiDou7;2WR%!8=S)nBO^`Xc*YV)E9Wjt!BB$< +z2SP^q&kOTIlci}w5y9W01V27{Ww!+;L3CM!{~Af&^WDlH_ozM)7E+Cq65sP75CCQ^FXrm_`!%0i&comMHy@c_; +zzeY%dn8=>ZB#c868c7QQ_ktwj$gB5NNymd!(SJj0BrO{Y112EKG6JTftb|0^HZdd# +z8KAid9g*}<=U*;fUvQmvyWL!EuGCoFh4TAGbH%LyP7bTZr`cCmijBs1C*Nqi&p+Rt +nDZZ^ P.val) + (fun T => P₀ + (T : W.Point)) (fun P => ?_) + simp only [fiberEquivKer, Equiv.coe_fn_mk] +@@ -41,7 +39,7 @@ theorem sigma_pullbackDiv_sub (f : W.Point →+ W.Point) (h : Finite f.ker) {P + (hP₀ : f P₀ = Q) : + Curves.projectiveDivisorSum W (pullbackDiv f h Q) - + Curves.projectiveDivisorSum W (pullbackDiv f h 0) = Nat.card f.ker • P₀ := by +- letI : Fintype f.ker := @Fintype.ofFinite _ h ++ let : Fintype f.ker := @Fintype.ofFinite _ h + have hQ := projectiveDivisorSum_pullbackDiv f h Q + have hO := projectiveDivisorSum_pullbackDiv f h 0 + rw [hQ, hO, fiber_sum_eq_ker_sum f h hP₀, +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionKernelRational.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionKernelRational.lean +index 378e2e72b..f1d4ef6ca 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionKernelRational.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionKernelRational.lean +@@ -11,26 +11,19 @@ import HasseWeil.Foundation.EC.GenericPointZsmul + import HasseWeil.Foundation.EC.SeparableKernelTorsor + + /-! +-# Kernel-rationality of `[ℓ]` over `K̄` (Silverman III.4.10c) ++# Rationality of torsion kernels over an algebraically closed field + +-For the multiplication-by-`ℓ` isogeny `[ℓ] = mulByInt W.toAffine ℓ` over an algebraically closed +-field `F = K̄`, we discharge the two genuine-isogeny coherence inputs of the capstone +-`HasseWeil.card_kernel_eq_degree_of_separable_concrete` (`SeparableKernelTorsor.lean`): ++For a nonzero integer `ℓ`, every point in the kernel of multiplication ++by `ℓ` over an extension of an algebraically closed base field already ++comes from a torsion point over that base field. The division-polynomial ++identity makes its x-coordinate algebraic, and the Weierstrass equation ++then makes its y-coordinate algebraic. + +-* `hdesc_mulByInt` — the inverse-witness descent: every fibre `σ(P_gen) − P_gen` (`σ` an +- automorphism of `K(E)/[ℓ]*K(E)`) is an `F`-rational kernel point of `[ℓ]`. +-* `h_normal_mulByInt` — the function-field extension `K(E)/[ℓ]*K(E)` is normal. ++Consequently, automorphisms of `K(E)/[ℓ]*K(E)` differ from the generic ++point by rational kernel points. The minimal polynomials of the generic ++coordinates split in `K(E)`, proving normality of this extension. + +-Both rest on **kernel-rationality** (`kernelDescends_general`, specialised to +-`kernelOverKE_descends` at `L = K(E)`): over `K̄`, every point `Q` of `E` with coordinates in a +-field extension `L` that is killed by `[ℓ]` already descends to a `K̄`-rational `ℓ`-torsion point. +-The reason is the division-polynomial connection `[ℓ]Q = O ⟹ ψ_ℓ(x(Q), y(Q)) = 0 ⟹ Ψ²_ℓ(x(Q)) = 0`: +-the `x`-coordinate of `Q` is a root of the `ℓ`-division polynomial `Ψ²_ℓ`, whose coefficients lie +-in `K̄` (not just `L`); since `K̄` is algebraically closed, `Ψ²_ℓ` splits over `K̄`, so `x(Q)` is +-the image of a `K̄`-element. The `y`-coordinate then descends via the Weierstrass +-equation over `K̄`. +- +-Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.4.10c. ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.4.10(c). + -/ + + open WeierstrassCurve Polynomial +@@ -228,7 +221,7 @@ of `[ℓ]`. + + The geometric action `g` of `[ℓ]` on `(W_KE).Point` is multiplication-by-`ℓ` (`zsmulAddGroupHom ℓ`), + whose value at the generic point is `(mulByInt_x ℓ, mulByInt_y ℓ) = ([ℓ]*x_gen, [ℓ]*y_gen)` +-(`zsmul_genericPoint_eq` + `mulByInt_pullback_x/y`); this is the genuine data. The shipped ++(`zsmul_genericPoint_eq` + `mulByInt_pullback_x/y`); the generic-point identity. The lemma + `genericPointAct_mem_ker_g` then yields `g(σ P_gen) = g(P_gen)` — using `σ.commutes` (it fixes the + pullback range) and the equivariance `g ∘ (Point.map σ) = (Point.map σ) ∘ g`, which here is just + `map_zsmul`. Thus `ℓ • (σ P_gen − P_gen) = 0`, and `kernelOverKE_descends` produces the descended +@@ -241,7 +234,7 @@ theorem hdesc_mulByInt [IsAlgClosed F] (ℓ : ℤ) (hℓ : ℓ ≠ 0) : + liftPointToKE W k = + genericPointAct W (mulByInt W.toAffine ℓ) σ - genericPoint W := by + intro σ +- letI := (mulByInt W.toAffine ℓ).toAlgebra ++ let := (mulByInt W.toAffine ℓ).toAlgebra + set g : (W_KE W).toAffine.Point →+ (W_KE W).toAffine.Point := zsmulAddGroupHom ℓ + obtain ⟨hns, hsmul⟩ := zsmul_genericPoint_eq W ℓ hℓ + have hsmul' : ℓ • genericPoint W = +@@ -449,16 +442,15 @@ theorem minpoly_gen_splits_of_mem_range [IsAlgClosed F] (ℓ : ℤ) (_hℓ : ℓ + letI := (mulByInt W.toAffine ℓ).toAlgebra + Polynomial.Splits ((minpoly W.toAffine.FunctionField a).map + (algebraMap W.toAffine.FunctionField W.toAffine.FunctionField)) := by +- letI algB := (mulByInt W.toAffine ℓ).toAlgebra +- -- Re-pin the canonical `Algebra K(E) Ω` to use `Algebra.id` for the `[Algebra K(E) K(E)]` slot +- -- of `AlgebraicClosure.instAlgebra` (otherwise the ambient `letI := pullback` poisons it, making +- -- the proof's `algebraMap K(E) Ω` disagree with the one baked into `hmem`). +- letI stdΩ : Algebra W.toAffine.FunctionField (AlgebraicClosure W.toAffine.FunctionField) := ++ let algB := (mulByInt W.toAffine ℓ).toAlgebra ++ -- Use the standard embedding into the algebraic closure for the coordinate field, ++ -- while the base-field action on that coordinate field is the isogeny pullback. ++ let stdΩ : Algebra W.toAffine.FunctionField (AlgebraicClosure W.toAffine.FunctionField) := + @AlgebraicClosure.instAlgebra W.toAffine.FunctionField _ W.toAffine.FunctionField _ + (Algebra.id W.toAffine.FunctionField) +- haveI hfin : @FiniteDimensional W.toAffine.FunctionField W.toAffine.FunctionField ++ have hfin : @FiniteDimensional W.toAffine.FunctionField W.toAffine.FunctionField + _ _ algB.toModule := isogeny_finiteDimensional W (mulByInt W.toAffine ℓ) +- haveI halg : Algebra.IsAlgebraic W.toAffine.FunctionField W.toAffine.FunctionField := ++ have halg : Algebra.IsAlgebraic W.toAffine.FunctionField W.toAffine.FunctionField := + Algebra.IsAlgebraic.of_finite _ _ + -- `Ω = AlgebraicClosure K(E)` is made a *base*-algebra via the ring hom `algebraMap ∘ pullback`, + -- supplied *inline* to the abstract criterion (never a scope instance, so the standard +@@ -486,7 +478,7 @@ theorem minpoly_gen_splits_of_mem_range [IsAlgClosed F] (ℓ : ℤ) (_hℓ : ℓ + rfl + -- Build the `F`-algHom `g` by restricting scalars along `F → B`, using the inline scalar tower + -- `F → B → Ω` (`of_algHom` for `(algebraMap) ∘ pullback`); supplied `@`-explicitly. +- haveI htower : @IsScalarTower F W.toAffine.FunctionField ++ have htower : @IsScalarTower F W.toAffine.FunctionField + (AlgebraicClosure W.toAffine.FunctionField) _ + (((algebraMap W.toAffine.FunctionField (AlgebraicClosure W.toAffine.FunctionField)).comp + (mulByInt W.toAffine ℓ).pullback.toRingHom).toAlgebra).toSMul _ := +@@ -537,11 +529,11 @@ once the two generator minimal polynomials do (`mulByInt_genCoords_minpoly_split + theorem h_normal_mulByInt [IsAlgClosed F] (ℓ : ℤ) (hℓ : ℓ ≠ 0) : + letI := (mulByInt W.toAffine ℓ).toAlgebra + Normal W.toAffine.FunctionField W.toAffine.FunctionField := by +- letI := (mulByInt W.toAffine ℓ).toAlgebra +- haveI hfin : @FiniteDimensional W.toAffine.FunctionField W.toAffine.FunctionField ++ let := (mulByInt W.toAffine ℓ).toAlgebra ++ have hfin : @FiniteDimensional W.toAffine.FunctionField W.toAffine.FunctionField + _ _ (mulByInt W.toAffine ℓ).toAlgebra.toModule := + isogeny_finiteDimensional W (mulByInt W.toAffine ℓ) +- haveI halg : Algebra.IsAlgebraic W.toAffine.FunctionField W.toAffine.FunctionField := ++ have halg : Algebra.IsAlgebraic W.toAffine.FunctionField W.toAffine.FunctionField := + Algebra.IsAlgebraic.of_finite _ _ + obtain ⟨hsx, hsy⟩ := mulByInt_genCoords_minpoly_splits W ℓ hℓ + refine normal_iff.mpr fun z ↦ ⟨(halg.isAlgebraic z).isIntegral, ?_⟩ +diff --git a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionModule.lean b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionModule.lean +index e011591e1..dcc33eba4 100644 +--- a/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionModule.lean ++++ b/projects/HasseWeil/HasseWeil/HasseBound/WeilPairing/TorsionModule.lean +@@ -10,27 +10,16 @@ import Mathlib.FieldTheory.Finiteness + import Mathlib.LinearAlgebra.Dimension.Free + + /-! +-# `E[ℓ] ≅ (ZMod ℓ)²` — the geometric `ℓ`-torsion as a 2-dimensional `ZMod ℓ`-vector space ++# The two-dimensional module of prime torsion points + +-For `ℓ` prime and `F` algebraically closed with `(ℓ : F) ≠ 0` (i.e. `ℓ ≠ char F`), the geometric +-`ℓ`-torsion `E[ℓ] = W.toAffine[(ℓ : ℤ)]` is a 2-dimensional vector space over the field `ZMod ℓ`. ++For a prime `ℓ` different from the characteristic of an algebraically ++closed field, the geometric torsion subgroup `E[ℓ]` has cardinality ++`ℓ²`. Since every element is killed by `ℓ`, it is a vector space over ++`ZMod ℓ`. The finite-vector-space cardinality formula gives dimension ++two, hence a basis indexed by `Fin 2` and an identification with ++`Fin 2 → ZMod ℓ`. + +-This builds on the axiom-clean cardinality theorem +-`HasseWeil.WeilPairing.TorsionGeometric.card_torsion_ell` (`#E[ℓ] = ℓ²`, Silverman III.6.4(a)) +-and packages the structure-theoretic consequences: +- +-* `card_torsion_ell_nat` — `Nat.card E[ℓ] = ℓ²` (no `ℤ`-coercion); +-* `torsion_ell_finite` — `E[ℓ]` is finite; +-* the `Module (ZMod ℓ)` structure on `E[ℓ]` (every element is killed by `ℓ`), via +- `AddCommGroup.zmodModule`; +-* `finrank_torsion_ell` — `finrank (ZMod ℓ) E[ℓ] = 2`, via `Module.natCard_eq_pow_finrank`; +-* `torsion_ell_basis` — a `Basis (Fin 2) (ZMod ℓ) E[ℓ]`, via `Module.finBasisOfFinrankEq`; +-* `torsion_ell_linearEquiv` — `E[ℓ] ≃ₗ[ZMod ℓ] (Fin 2 → ZMod ℓ)`, via `Basis.equivFun`. +- +-These are the structures the downstream mod-`ℓ` Galois representation +-`ρ_ℓ : End(E) → GL₂(ZMod ℓ)` consumes. +- +-Reference: Silverman III.6.4(a), III.7. ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.6.4(a), III.7. + -/ + + open WeierstrassCurve +@@ -97,13 +86,13 @@ theorem torsion_ell_finite : Finite W.toAffine[(ℓ : ℤ)] := by + forces `ℓ^finrank = ℓ²`, hence `finrank = 2` since `ℓ ≥ 2`. -/ + theorem finrank_torsion_ell : + Module.finrank (ZMod ℓ) W.toAffine[(ℓ : ℤ)] = 2 := by +- haveI := torsion_ell_finite W ℓ hℓF ++ have := torsion_ell_finite W ℓ hℓF + have hcard : Nat.card W.toAffine[(ℓ : ℤ)] + = Nat.card (ZMod ℓ) ^ Module.finrank (ZMod ℓ) W.toAffine[(ℓ : ℤ)] := + Module.natCard_eq_pow_finrank + rw [card_torsion_ell_nat W ℓ hℓF] at hcard + have hZcard : Nat.card (ZMod ℓ) = ℓ := by +- haveI : NeZero ℓ := ⟨hℓ.out.pos.ne'⟩ ++ have : NeZero ℓ := ⟨hℓ.out.pos.ne'⟩ + rw [Nat.card_eq_fintype_card, ZMod.card] + rw [hZcard] at hcard + -- `ℓ ^ 2 = ℓ ^ finrank`, and `ℓ ≥ 2`, so the exponents agree. +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/BaseChange/Basic.lean b/projects/HasseWeil/HasseWeil/Isogeny/BaseChange/Basic.lean +index 5e7b88094453689a80fefbc79c4a6dcb9032a838..e2365c39fcec4a07f8b7e2aac47dfbd1ec0b90ad 100644 +GIT binary patch +delta 481 +zcmX^2mhsOf#tjvWlTF!QZ@$9$o-sB*H?u?`+9fqPGbJ%8C)Kr3!7WxHIy^NqwWzqH +zD6zQMxwNP(RnN27H76&tpd>R{A^cHOBVi>?u?m@alN)&DHb3BANMma@H}GC(+$=39 +z!8Ey1v}W^jNllK;b}DHCo1d8f;1b95VK&HZn{PWkXT&La&?Sa>bGz4C7Mv=K{jam( +zl;jLkV!|n@6)}ZRo(qSwxb$^(6|}S_CuGZP*2>v~+mxqy0!+*bRtl2^!=)#S6mHu5 +Iw)i0v0F`R9Hvj+t + +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/BaseChange/Concrete.lean b/projects/HasseWeil/HasseWeil/Isogeny/BaseChange/Concrete.lean +index a56daff33..930b5c5e6 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/BaseChange/Concrete.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/BaseChange/Concrete.lean +@@ -6,72 +6,23 @@ Authors: Chris Birkbeck + import HasseWeil.HasseBound.WeilPairing.Scaling.OneSub + + /-! +-# Concrete base-change of a function-field pullback (CoordHom-free) ++# Base change of function-field pullbacks + +-For a smooth plane curve `C / F` and an `F`-algebra extension `L` with `L/F` algebraic, the +-function-field scalar-extension iso `K(C_L) ≅ L ⊗_F K(C)` is **already** available, axiom-clean, in +-`HasseWeil/Curves/CurveMapBaseChange.lean`: ++For an algebraic field extension `L/F`, the canonical scalar-extension ++isomorphism `Φ : L ⊗[F] K(C) ≃ₐ[L] K(C_L)` transports a function-field ++endomorphism `f` to `Φ ∘ (id_L ⊗ f) ∘ Φ⁻¹`. + +-* `functionField_tensor_locBaseChange L : (L ⊗ K(C)) ≃ₐ[L] FractionRing (L ⊗ C.CR)`, +-* `functionField_baseChange_fracEquiv L : FractionRing (L ⊗ C.CR) ≃ₐ[L] K(C_L)`. ++The type synonym `Twist f` carries the scalar action through `f`. An ++explicit tensor-product linear equivalence identifies its base change ++with `Twist (id_L ⊗ f)`, proving preservation of the twisted module rank ++and hence of the degree of the pullback. + +-Composing them gives the iso `Φ : (L ⊗ K(C)) ≃ₐ[L] K(C_L)` (`tensorFunctionFieldEquiv`). ++For `1 - π`, this constructs the base-changed pullback and its degree ++identity. The scaling data retain explicit hypotheses for the geometric ++kernel, divisor transport, duality, surjectivity and translation covariance. + +-This file uses `Φ` to **construct** the base-change of an arbitrary function-field `F`-algebra hom +-`f : K(C) →ₐ[F] K(C)` — *no `CoordHom` required* — as the conjugate +- +- `baseChangePullback f := Φ ∘ (id_L ⊗ f) ∘ Φ⁻¹ : K(C_L) →ₐ[L] K(C_L)`, +- +-an honest `L`-algebra hom (`Algebra.TensorProduct.map (AlgHom.id L) f` is the `L`-linear scalar +-extension of the `F`-linear `f`, conjugated by the `L`-algebra equiv `Φ`). +- +-The payoff (`oneSubFrobeniusPullback_L`) is the concrete `pullback_L` field of `OneSubScalingData` +-for the separable genuine isogeny `1 − π`, whose pullback has poles at the affine kernel so admits +-**no** `CoordHom` — hence the whole CoordHom-free route. +- +-## Degree preservation +- +-`finrank_baseChangePullback_eq_finrank_lTensorMap` reduces the degree of the conjugate +-`baseChangePullback f` (as an `Isogeny`, via `Isogeny.degree_eq_of_finrank_eq`) to the `finrank` of +-the *scalar extension* `id_L ⊗ f` over `L ⊗ K(C)`, by transporting the finrank along the `L`-algebra +-equiv `Φ` (`Algebra.finrank_eq_of_equiv_equiv`). This **conjugation step is proved here in full**. +- +-The remaining equality `finrank_{L ⊗ K(C), via id_L ⊗ f}(L ⊗ K(C)) = finrank_{K(C), via f} K(C)` +-is the curve-free **base-change-of-finrank** content; it is **proved here in full** as +-`finrankBaseChange`, by realizing the `f`-twisted self-module `K(C)` as the type synonym `Twist f` +-and exhibiting `(L ⊗ K(C)) ⊗_{K(C)} Twist f ≃ₗ[L ⊗ K(C)] Twist (id_L ⊗ f)` (so +-`Module.finrank_baseChange` applies). Hence `baseChangePullback_finrank_eq` (and the degree +-preservation it feeds) carries **no** finrank hypothesis. +- +-## What this file discharges for `OneSubScalingData` +- +-`mkOneSubScalingDataConcrete` assembles a full `OneSubScalingData` for the genuine `1 − π` base +-change in which: +- +-* `pullback_L` is **constructed** as the concrete `oneSubFrobeniusPullback_L` (the conjugate +- `Φ ∘ (id_L ⊗ (1−π).pullback) ∘ Φ⁻¹`) — *no longer a raw input* (axiom-clean); +-* `hdeg_bc` is **fully discharged** by the proved conjugation step +- `finrank_baseChangePullback_eq_finrank_lTensorMap` chained with the proved curve-free +- `finrankBaseChange` — no carried hypothesis. +- +-The remaining inputs are exactly the genuinely-deep **K̄-level geometric** residuals, each stated +-against the concrete pullback: +- +-* `finiteKer` — finiteness of `ker(1 − π)_{K̄}` (a separable isogeny has finite kernel over `K̄`); +-* `hproj` — `ProjOrdTransport` (multiplicity-free divisor pullback); +-* `δ`/`hdc` — the divisor-pushforward dual `1 − V̄` and Silverman III.6.2(a) `δ ∘ φ = [#ker φ]`; +-* `hsurj` — surjectivity over `K̄` (Silverman III.4.10a); +-* `hkerdeg` — the separable degree match `#ker = deg` (Silverman III.4.10c); +-* `hcomm'` — the translation covariance (Silverman III.8.2). +- +-These are the genuine geometric content of the base-changed separable isogeny; the project ships no +-concrete base-change of a non-Frobenius isogeny's *point map* (only the witness-parametric +-`mkBaseChange`), so they remain carried (cf. `ProjOrdTransport`/`Naturality` elsewhere). +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, II.2.11 (degree under base change), +- III.4.10a/c, III.6.2(a), III.8.2, III.8.6.1. ++References: Silverman, *The Arithmetic of Elliptic Curves*, II.2.11, ++III.4.10, III.6.2(a), and III.8.2–6. + -/ + + open WeierstrassCurve HasseWeil.Curves +@@ -149,8 +100,7 @@ local notation "lTM" => Algebra.TensorProduct.map (AlgHom.id L L) f + attribute [local instance] Algebra.TensorProduct.rightAlgebra + + /-- `eFwd` is surjective, from its action on pure tensors (`heFwd`) and the section `eInv` +-(`heInv`). Stated with the forward/inverse maps as opaque parameters so it elaborates within the +-default heartbeat budget. -/ ++(`heInv`). The forward and inverse maps are explicit parameters. -/ + private theorem twistLTensor_surjective [Module A (Twist (lTM))] + [IsScalarTower A (L ⊗[F] A) (Twist (lTM))] + (eFwd : ((L ⊗[F] A) ⊗[A] (Twist f)) →ₗ[L ⊗[F] A] (Twist (lTM))) +@@ -164,7 +114,6 @@ private theorem twistLTensor_surjective [Module A (Twist (lTM))] + refine ⟨eInv (Twist.toB (lTM) z), ?_⟩ + apply Twist.toB_injective (lTM) + induction (Twist.toB (lTM) z) with +- | zero => simp only [map_zero]; rfl + | add x y hx hy => + rw [map_add, map_add, Twist.toB_add] + rw [show Twist.toB (lTM) (eFwd (eInv x)) = x from hx, +@@ -176,7 +125,7 @@ private theorem twistLTensor_surjective [Module A (Twist (lTM))] + Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul] + + /-- `eInv ∘ toB ∘ eFwd = id`, from the action on pure tensors. The left inverse, giving +-injectivity of `eFwd`. Forward/inverse maps are opaque parameters for heartbeat budget. -/ ++injectivity of `eFwd`. The forward and inverse maps are explicit parameters. -/ + private theorem twistLTensor_leftInverse [Module A (Twist (lTM))] + [IsScalarTower A (L ⊗[F] A) (Twist (lTM))] + (eFwd : ((L ⊗[F] A) ⊗[A] (Twist f)) →ₗ[L ⊗[F] A] (Twist (lTM))) +@@ -188,14 +137,9 @@ private theorem twistLTensor_leftInverse [Module A (Twist (lTM))] + ∀ t : (L ⊗[F] A) ⊗[A] (Twist f), eInv (Twist.toB (lTM) (eFwd t)) = t := by + intro t + induction t with +- | zero => rw [map_zero (f := eFwd), show Twist.toB (lTM) 0 = 0 from rfl, +- map_zero (f := eInv)] + | add x y hx hy => rw [map_add (f := eFwd), Twist.toB_add, map_add (f := eInv), hx, hy] + | tmul w m => + induction w with +- | zero => +- rw [TensorProduct.zero_tmul, map_zero (f := eFwd), +- show Twist.toB (lTM) 0 = 0 from rfl, map_zero (f := eInv)] + | add x y hx hy => + rw [TensorProduct.add_tmul, map_add (f := eFwd), Twist.toB_add, map_add (f := eInv), + hx, hy] +@@ -222,9 +166,9 @@ equals the `A`-module finrank of `A` via `f`. Proved by exhibiting the `L ⊗ A + private theorem finrank_lTensorMap_eq_finrank : + @Module.finrank (L ⊗[F] A) (L ⊗[F] A) _ _ (lTM).toRingHom.toAlgebra.toModule = + @Module.finrank A A _ _ f.toRingHom.toAlgebra.toModule := by +- letI iA_TwL : Module A (Twist (lTM)) := ++ let iA_TwL : Module A (Twist (lTM)) := + Module.compHom (Twist (lTM)) (algebraMap A (L ⊗[F] A)) +- haveI iA_TwL_tower : IsScalarTower A (L ⊗[F] A) (Twist (lTM)) := ++ have iA_TwL_tower : IsScalarTower A (L ⊗[F] A) (Twist (lTM)) := + SMul.comp.isScalarTower (algebraMap A (L ⊗[F] A)) + let l : (Twist f) →ₗ[A] (Twist (lTM)) := + { toFun := fun m ↦ Twist.ofB (lTM) (1 ⊗ₜ[F] Twist.toB f m) +@@ -292,8 +236,7 @@ variable (L : Type*) [Field L] [Algebra F L] [Algebra.IsAlgebraic F L] + + /-- **The function-field scalar-extension iso** `Φ : (L ⊗_F K(C)) ≃ₐ[L] K(C_L)`, the composite of + `functionField_tensor_locBaseChange` (`L ⊗ K(C) ≅ FractionRing (L ⊗ C.CR)`) and +-`functionField_baseChange_fracEquiv` (`FractionRing (L ⊗ C.CR) ≅ K(C_L)`). Both are shipped +-axiom-clean in `CurveMapBaseChange.lean`. -/ ++`functionField_baseChange_fracEquiv` (`FractionRing (L ⊗ C.CR) ≅ K(C_L)`). These are the canonical tensor and fraction-field identifications. -/ + noncomputable def tensorFunctionFieldEquiv : + letI := C.isDomain_tensorCoordRing L + (L ⊗[F] C.toAffine.FunctionField) ≃ₐ[L] (C.baseChange L).toAffine.FunctionField := +@@ -307,7 +250,7 @@ noncomputable def lTensorMap (f : C.toAffine.FunctionField →ₐ[F] C.toAffine. + (L ⊗[F] C.toAffine.FunctionField) →ₐ[L] (L ⊗[F] C.toAffine.FunctionField) := + Algebra.TensorProduct.map (AlgHom.id L L) f + +-set_option linter.unusedSectionVars false in ++omit [Algebra.IsAlgebraic F L] in + @[simp] theorem lTensorMap_tmul + (f : C.toAffine.FunctionField →ₐ[F] C.toAffine.FunctionField) (l : L) + (u : C.toAffine.FunctionField) : +@@ -355,10 +298,10 @@ theorem finrank_baseChangePullback_eq_finrank_lTensorMap + (baseChangePullback C L f).toRingHom.toAlgebra.toModule = + @Module.finrank (L ⊗[F] C.toAffine.FunctionField) (L ⊗[F] C.toAffine.FunctionField) _ _ + (lTensorMap C L f).toRingHom.toAlgebra.toModule := by +- letI := C.isDomain_tensorCoordRing L +- letI algBcp : Algebra (C.baseChange L).toAffine.FunctionField ++ let := C.isDomain_tensorCoordRing L ++ let algBcp : Algebra (C.baseChange L).toAffine.FunctionField + (C.baseChange L).toAffine.FunctionField := (baseChangePullback C L f).toRingHom.toAlgebra +- letI algLt : Algebra (L ⊗[F] C.toAffine.FunctionField) (L ⊗[F] C.toAffine.FunctionField) := ++ let algLt : Algebra (L ⊗[F] C.toAffine.FunctionField) (L ⊗[F] C.toAffine.FunctionField) := + (lTensorMap C L f).toRingHom.toAlgebra + refine Algebra.finrank_eq_of_equiv_equiv (tensorFunctionFieldEquiv C L).symm.toRingEquiv + (tensorFunctionFieldEquiv C L).symm.toRingEquiv ?_ +@@ -380,7 +323,7 @@ def FinrankBaseChange (f : C.toAffine.FunctionField →ₐ[F] C.toAffine.Functio + @Module.finrank C.toAffine.FunctionField C.toAffine.FunctionField _ _ + f.toRingHom.toAlgebra.toModule + +-set_option linter.unusedSectionVars false in ++omit [Algebra.IsAlgebraic F L] in + /-- **The base-change-of-finrank fact, proved (curve-free).** For an `F`-algebra endomorphism `f` + of the field `K(C)`, base change along `F → L` preserves the degree of the (injective) field + endomorphism: `[L ⊗ K(C) : (id_L ⊗ f)(L ⊗ K(C))] = [K(C) : f(K(C))]`. -/ +@@ -422,7 +365,7 @@ noncomputable def oneSubFrobeniusPullback_L (hq : 2 ≤ Fintype.card K) : + + /-- **Degree preservation for the concrete `1 − π` base change** (curve-free, fully discharged). + Chains the proved conjugation step (inside `baseChangePullback_finrank_eq`, which now invokes the +-proved `finrankBaseChange`) into the shipped witness-parametric ++proved `finrankBaseChange`) into the corresponding + `oneSubFrobeniusIsogBaseChange_degree_eq_of_finrank`. This **discharges the `hdeg_bc` field** of + `OneSubScalingData` with no carried `FinrankBaseChange` hypothesis. -/ + theorem oneSubFrobeniusIsogBaseChange_degree_eq_of_finrankBaseChange (hq : 2 ≤ Fintype.card K) : +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/Basic.lean b/projects/HasseWeil/HasseWeil/Isogeny/Basic.lean +index 01ae90e29..fc74956a0 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/Basic.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/Basic.lean +@@ -45,7 +45,7 @@ image of `x` has poles at the `n`-torsion). + The current `pullback_ordAtInfty_nonneg` field captures "morphism is defined at + the basepoint" (regular functions pull back to regular functions). It does not + strictly capture `φ(O) = O` — that would require the strict-positive form +-`0 < ord_∞ f → 0 < ord_∞ pullback f`. A future refinement may strengthen this. ++`0 < ord_∞ f → 0 < ord_∞ pullback f`. + + ## References + +@@ -296,6 +296,7 @@ noncomputable def Isogeny.frobenius : Isogeny W W where + · rw [(⟨W⟩ : Curves.SmoothPlaneCurve K).ordAtInfty_pow hf] + exact nsmul_nonneg h _ + ++omit [DecidableEq K] in + @[simp] theorem Isogeny.frobenius_pullback (f : W.FunctionField) : + (Isogeny.frobenius W).toCurveMap.pullback f = f ^ Fintype.card K := + congr_fun (FiniteField.coe_frobeniusAlgHom (K := K) (R := W.FunctionField)) f +@@ -313,12 +314,14 @@ noncomputable def Isogeny.frobeniusCoordHom : + (FiniteField.frobeniusAlgHom K W.CoordinateRing u) + simp only [FiniteField.coe_frobeniusAlgHom, map_pow] + ++omit [DecidableEq K] in + /-- The Frobenius isogeny has degree `q := #K`. Inherits from + `HasseWeil.frobenius_finrank_functionField`. Reference: Silverman III.4.6. -/ + @[simp] theorem Isogeny.frobenius_degree : + (Isogeny.frobenius W).degree = Fintype.card K := + HasseWeil.frobenius_finrank_functionField K W + ++omit [DecidableEq K] in + /-- **Frobenius coordinate-evaluation step.** Evaluating a pulled-back + coordinate-ring element `r` through the Frobenius coordinate hom at a smooth + point `(x, y)` equals the `q`-th power (`q := #K`) of the plain evaluation: +@@ -336,6 +339,7 @@ private theorem Isogeny.frobenius_evalAtPullback {x y : K} + ⟨x, y, h⟩ (FiniteField.frobeniusAlgHom K W.CoordinateRing r) = _ + simp only [FiniteField.coe_frobeniusAlgHom, map_pow] + ++omit [DecidableEq K] in + /-- The Frobenius isogeny acts as the **identity** on `K`-rational points: for + any `(x, y) ∈ W(K)`, Frobenius sends `(x, y) ↦ (x^q, y^q) = (x, y)` since + `x^q = x` for all `x ∈ K` by `FiniteField.pow_card`. The basepoint is +@@ -383,23 +387,17 @@ end Frobenius + + /-! ### Multiplication-by-`n` isogeny + +-The endomorphism `[n] : E → E` is constructed via the function-field pullback +-`mulByInt_pullbackAlgHom` from `HasseWeil/MulByIntPullback.lean` (built from +-division polynomials). ++The endomorphism `[n] : E → E` is constructed from the division-polynomial ++function-field pullback `mulByInt_pullbackAlgHom`. + +-The basepoint condition `pullback_ordAtInfty_nonneg` for `[n]` is genuinely +-non-trivial — it requires the ramification-theoretic fact that +-`ord_∞([n]*f) = e · ord_∞(f)` for some positive integer `e` (the local +-ramification index of `[n]` at `O`). For now we expose this as an explicit +-hypothesis (`mulByIntOfBasepoint`); a follow-up ticket will discharge it via +-the existing `mulByInt_finrank` infrastructure or a dedicated valuation +-extension argument. ++The construction `mulByIntOfBasepoint` takes an explicit hypothesis that the ++pullback preserves functions regular at infinity. The corresponding local ++ramification formula is `ord_∞([n]*f) = e · ord_∞(f)` with positive ramification ++index `e`. + +-Note that `[n]` does *not* admit a `coordHom` witness in the affine model — +-its pullback of `x` is `Φ_n / Ψ_n²`, a fraction with poles at the +-`n`-torsion. Hence `Isogeny.toPointMap` cannot be invoked for `mulByInt` +-directly via the affine route; this is the design reason for separating +-`coordHom` from the structure. -/ ++For `n ≥ 2`, the pullback of `x` is `Φ_n / Ψ_n²`, with poles at the `n`-torsion. ++Thus this projective morphism does not generally induce a map of affine ++coordinate rings. -/ + + section MulByInt + +@@ -428,6 +426,7 @@ noncomputable def Isogeny.mulByIntOfBasepoint {n : ℤ} (hn : n ≠ 0) + toCurveMap := { pullback := HasseWeil.mulByInt_pullbackAlgHom W n hn } + pullback_ordAtInfty_nonneg := h_basepoint + ++omit [DecidableEq F] in + @[simp] theorem Isogeny.mulByIntOfBasepoint_pullback {n : ℤ} (hn : n ≠ 0) + (h_basepoint : MulByIntBasepoint W hn) (f : W.FunctionField) : + (Isogeny.mulByIntOfBasepoint W hn h_basepoint).toCurveMap.pullback f = +@@ -435,48 +434,14 @@ noncomputable def Isogeny.mulByIntOfBasepoint {n : ℤ} (hn : n ≠ 0) + + end MulByInt + +-/-! ### Universal group-homomorphism property: bundled `WithHom` isogenies ++/-! ### Bundled group-homomorphism property + +-This is the working framework for **Silverman III.4.8** (every isogeny is a +-group homomorphism). Silverman's argument uses `Pic⁰(E) ≅ E` and the +-contravariant functoriality of the Picard variety on morphisms; alternative +-routes go via the formal group of `E` or direct addition-formula computation. ++The `WithHom` structure bundles an isogeny with an affine coordinate-ring map ++and a proof of `AddHomProperty`. Identity, composition and Frobenius preserve ++this data, yielding additive homomorphisms on rational points. + +-In our setup, the unconditional theorem is genuinely hard — it reduces to one +-of those upstream infrastructures, none of which are fully in the project yet. +-Instead, we package the **closure under standard constructions**: any isogeny +-built from `id`, `compose`, and `frobenius` automatically carries an +-`AddHomProperty`, hence a bundled `AddMonoidHom` on points. +- +-The `WithHom` bundle below is the canonical recipient of these closure +-operations. Future extensions (mulByInt, neg, dual, factor-through-Frobenius, +-…) should provide their own `WithHom` instances by discharging the +-`AddHomProperty` witness. +- +-## Proof routes for the universal version +- +-Silverman's three known routes for the universal Silverman III.4.8: +- +-1. **Pic⁰ route** (Silverman III.4.8 proper). Uses +- `σ : Pic⁰(E) ≅ E` (Silverman III.3.4) — gated on `T-III-3-004` in this +- project. The induced pullback `φ_* : Pic⁰(E₁) → Pic⁰(E₂)` is a hom by +- functoriality, and the diagram with σ commutes when `φ(O) = O`. +- +-2. **Formal-group route** (deformation argument). An isogeny pulls back to a +- formal-group hom on `Ê`. The hom property holds on the formal neighborhood +- of `O`, then extends to all of `E` by translation invariance and density. +- Requires the bridge `HasseWeil.Isogeny → HasseWeil.FormalGroupHom`, not yet +- built. +- +-3. **Addition-formula route** (direct computation). Use the explicit +- `Affine.addX/addY` formulas; show that any `F`-algebra hom on `K(E)` that +- restricts to coord rings preserves these (an algebra-homs-respect-rational- +- functions argument). Requires `addPullbackAlgHom` from +- `HasseWeil/AdditionPullback.lean` (currently has 3 transcendence sorries). +- +-All three reduce the universal claim to upstream infrastructure that is +-modular: once any one route's gates are filled, `silvermanIII48_via_` +-can be added as a one-liner taking the upstream output as a witness. -/ ++Silverman III.4.8 proves the group-homomorphism property for isogenies using ++`Pic⁰(E) ≅ E` and the functoriality of the Picard variety. -/ + + namespace Isogeny + +@@ -627,23 +592,6 @@ noncomputable def Isogeny.WithHom.frobenius + show (Isogeny.frobenius W).toPointMap (Isogeny.frobeniusCoordHom W) P = P + exact Isogeny.frobenius_toPointMap W P + +-/-! ### Future extensions (mulByInt, neg, dual) +- +-For each of the following, providing a `WithHom` instance requires both a +-coord-ring lift (often non-trivial) and the `AddHomProperty` proof: +- +-* `mulByInt n` for `n ≥ 2`: the affine coord-ring lift doesn't naturally +- exist (image of `x` is `Φₙ/Ψₙ²`, with poles at the `n`-torsion). Resolution +- requires a localization-based `CoordHom` or a projective coord model. +- +-* `neg` (the `[-1]` isogeny): `(x, y) ↦ (x, -y - a₁x - a₃)`. Has a clean +- affine coord-ring lift via `Affine.negY`. The `AddHomProperty` is +- `-(P+Q) = -P + -Q`, which holds by `neg_add` on the abelian group `W.Point`. +- Construction is straightforward in principle but requires explicit +- `AlgHom` building from the negY formula on the function field. + +-* `dual α`: requires the existence-uniqueness of the dual isogeny +- (Silverman III.6.1), gated on either Pic⁰ or kernel/factorization +- infrastructure (`T-III-6-001` in the project ticket board). -/ + + end HasseWeil.EC +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/ClassGroup.lean b/projects/HasseWeil/HasseWeil/Isogeny/ClassGroup.lean +index 9b2003a2e..5d5eaceb9 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/ClassGroup.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/ClassGroup.lean +@@ -8,59 +8,12 @@ import HasseWeil.Foundation.Ramification + import HasseWeil.Pic0.ClassGroupNorm + + /-! +-# The isogeny ↔ class-group bridge (reusable Pic⁰ infrastructure) ++An injective finite coordinate-ring pullback associated to an elliptic-curve ++endomorphism induces extension and relative-norm maps on the ideal class group. ++Their composite raises each class to the coordinate-ring extension degree. ++A compatible fraction-field tower identifies this degree with the isogeny degree. + +-This file packages, for an endomorphism `α : Isogeny E E` of an elliptic curve `E`, the data and +-lemmas needed to push `α` down to the ideal class group `ClassGroup E.CoordinateRing` and recover +-the dual relation `α̂ ∘ α = [deg α]` at the level of `ClassGroup`. +- +-The function-field pullback `α.pullback : E.FunctionField →ₐ[F] E.FunctionField` does **not** in +-general restrict to the coordinate ring `R := E.CoordinateRing` (this is the +-integrality-preservation content of Silverman III.3.4, deliberately *not* discharged here). We +-therefore carry the restriction as **data**, an `Isogeny.CoordHom`, mirroring +-`Curves.CurveMap.CoordHom`. +- +-The deep obligations are carried as **hypotheses** (witness-parametric), not discharged universally: +- +-* injectivity of the coordinate-ring restriction (`hinj`), giving `FaithfulSMul`/`IsTorsionFree`; +-* finiteness of `R` over itself through the restriction (`Module.Finite`), giving the `ClassGroup` +- norm/extension maps and matching `α.degree` to the coordinate-ring `finrank`. +- +-These are instantiable per isogeny (e.g. Frobenius, multiplication-by-`n`); the universal versions +-are separate, flagged-deep tickets. +- +-## Main definitions +- +-* `HasseWeil.Isogeny.CoordHom`: the coordinate-ring restriction witness for `α : Isogeny E E`. +-* `HasseWeil.Isogeny.CoordHom.toAlgebra`: the induced `R`-algebra structure on `R`. +-* `HasseWeil.Isogeny.classNorm` / `Isogeny.classMap`: the relative norm / extension maps on +- `ClassGroup R` induced by a `CoordHom`. +- +-## Main results +- +-* `HasseWeil.Isogeny.degree_eq_finrank_coordinateRing_of_tower_eq`: `α.degree` equals the +- coordinate-ring `finrank` of `ch.toAlgebra`, given a fraction-field tower witness for the +- `ch`-twisted coordinate ring (witness-parametric, to sidestep a same-type instance diamond — see +- the lemma's docstring). +-* `HasseWeil.Isogeny.classNorm_comp_classMap`: `classNorm (classMap c) = c ^ (finrank R R)` — the +- class-group shadow of `α̂ ∘ α = [deg α]`, exponent as the coordinate-ring degree. +-* `HasseWeil.Isogeny.classNorm_comp_classMap_degree`: the same with exponent `α.degree` (combines +- the previous two; carries the tower witness as hypotheses). +- +-## Design note +- +-The function-field pullback restricted to coordinate rings and lifted back to the fraction field +-gives, on the *same* carriers `R` and `FF`, a *non-identity* algebra structure. Several would-be +-"auto-derived" scalar towers (`R → R → FF`, `R → FF → FF`) are therefore **false** as stated with +-the canonical base action, and `finrank_of_isFractionRing` cannot be applied with `S = R`, +-`S' = FF` literally (the `IsFractionRing` typeclass cannot distinguish the canonical inclusion from +-the twisted map). The deep obligations (injectivity `hinj`, finiteness `Module.Finite`, and the +-fraction-field tower witness for the degree bridge) are consequently carried as **hypotheses**; +-they are instantiable per isogeny (Frobenius, multiplication-by-`n`). +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], III.3.4, III.4, III.6. ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, III.3.4. + -/ + + open WeierstrassCurve Polynomial +@@ -146,7 +99,7 @@ noncomputable def classNorm (ch : α.CoordHom) (hinj : Function.Injective ch.toA + haveI hfinI : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin + haveI htfI : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := + ch.isTorsionFree hinj +- @ClassGroup.relNorm E.CoordinateRing E.CoordinateRing _ _ _ _ _ _ _ _ ch.toAlgebra hfinI htfI ++ @ClassGroup.relNorm E.CoordinateRing E.CoordinateRing _ _ _ _ ch.toAlgebra hfinI htfI + + /-- The **extension map on the class group** induced by `α : Isogeny E E` and a coordinate-ring + restriction witness `ch`, with the finiteness obligation carried as a hypothesis. +@@ -160,7 +113,7 @@ noncomputable def classMap (ch : α.CoordHom) (hinj : Function.Injective ch.toAl + haveI : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin + haveI htfI : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := + ch.isTorsionFree hinj +- @ClassGroup.map E.CoordinateRing E.CoordinateRing _ _ _ _ _ _ ch.toAlgebra htfI ++ @ClassGroup.map E.CoordinateRing E.CoordinateRing _ _ _ _ ch.toAlgebra htfI + + /-- **Function-field ↔ coordinate-ring degree bridge (witness-parametric `_of_tower_eq` form).** + +@@ -168,23 +121,11 @@ The function-field degree `α.degree` equals the coordinate-ring degree + `Module.finrank R R` (with `R` carrying `ch.toAlgebra`), *given* a fraction-field tower witness for + the `ch`-twisted coordinate ring. + +-The deep obstruction (see the file-level note and the round report) is a genuine **same-type +-instance diamond**: `Algebra.IsAlgebraic.finrank_of_isFractionRing` needs the source/target rings +-`R, S` and their fraction fields `R', S'` to be *distinguishable type pairs* so that +-`IsFractionRing R R'` and `IsFractionRing S S'` can coexist with the canonical inclusion (for `R'`) +-and the `ch`-twisted map (for the `S → S'` tower) respectively. With `S = R` and `S' = R' = FF` +-*literally*, Lean's instance resolution cannot keep the two `Algebra R FF` structures apart, even +-though the required equation `α.pullback (algebraMap R FF r) = algebraMap R FF (ch.toAlgHom r)` is +-exactly `ch.compat`. +- +-We therefore expose the bridge witness-parametrically: the caller supplies a *distinct nominal copy* +-`S` of the `ch`-twisted coordinate ring together with its fraction field `S'` (a copy of +-`E.FunctionField` carrying `α.toAlgebra`), the standard fraction-field tower instances, and the two +-`Module.finrank`-transfer equalities `hSR`, `hS'FF` (each a `LinearEquiv.finrank_eq` away once the +-copies are chosen). These are dischargeable per isogeny (Frobenius, multiplication-by-`n`). +- +-The conclusion is then a one-line application of `finrank_of_isFractionRing` between the four +-distinct type slots `R, FF, S, S'`. -/ ++The coordinate-ring algebra induced by the endomorphism differs from the ++canonical algebra on the same carrier. Distinct nominal copies `S` and `S'` ++represent the twisted coordinate ring and its fraction field. Compatible ++scalar towers and the rank-transfer equalities `hSR` and `hS'FF` allow the ++fraction-field rank theorem to compare their degrees. -/ + theorem degree_eq_finrank_coordinateRing_of_tower_eq (ch : α.CoordHom) + (S : Type*) [CommRing S] [Algebra E.CoordinateRing S] + [FaithfulSMul E.CoordinateRing S] [Algebra.IsAlgebraic E.CoordinateRing S] [NoZeroDivisors S] +@@ -197,7 +138,7 @@ theorem degree_eq_finrank_coordinateRing_of_tower_eq (ch : α.CoordHom) + (hS'FF : @Module.finrank E.FunctionField S' _ _ _ = α.degree) : + α.degree = @Module.finrank E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := by + rw [← hSR, ← hS'FF] +- exact Algebra.IsAlgebraic.finrank_of_isFractionRing E.CoordinateRing E.FunctionField S S' ++ exact IsFractionRing.finrank_eq E.CoordinateRing E.FunctionField S S' + + /-- **The class-group dual relation (coordinate-ring `finrank` form).** + +@@ -209,17 +150,17 @@ the `ch.toAlgebra` structure): + This is the class-group shadow of `α̂ ∘ α = [deg α]`, with the exponent expressed as the + coordinate-ring degree. To express the exponent as `α.degree` (the function-field degree), compose + with `degree_eq_finrank_coordinateRing_of_tower_eq` (the function-field ↔ coordinate-ring degree +-bridge, separately flagged). -/ ++bridge). -/ + theorem classNorm_comp_classMap (ch : α.CoordHom) (hinj : Function.Injective ch.toAlgHom) + (hfin : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule) + (c : ClassGroup E.CoordinateRing) : + α.classNorm ch hinj hfin (α.classMap ch hinj hfin c) = + c ^ @Module.finrank E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := by +- letI := ch.toAlgebra +- haveI hfinI : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin +- haveI htfI : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := ++ let := ch.toAlgebra ++ have hfinI : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin ++ have htfI : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := + ch.isTorsionFree hinj +- exact @ClassGroup.relNorm_comp_map E.CoordinateRing E.CoordinateRing _ _ _ _ _ _ _ _ ++ exact @ClassGroup.relNorm_comp_map E.CoordinateRing E.CoordinateRing _ _ _ _ + ch.toAlgebra hfinI htfI c + + /-- **The class-group dual relation (`α.degree` form).** +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/FormalSeries.lean b/projects/HasseWeil/HasseWeil/Isogeny/FormalSeries.lean +index 0cabc394abc4ca7608ba92b737cb85363078b59b..dcd6e5526f0503f078f119bafd1bb4a80e1148f6 100644 +GIT binary patch +delta 8683 +zcmbtaZHygN8P06CYnk#T+wHc1a7x>-OLuQ6ZH*SIEv2gq3oUdhl&0y-z4zREN9NAl +z&dlBI@-=`MP=in==KdgjC{Z!~K`+UM!~`VP9~u=CqyJP0nt)M(A8H~oKJRn +zS`@;^%sq3?`}w@@`<(vdxq*kDU-@Ex-=yQs*nwkvk*GSgnhc~DIkp>`=5#}fnjbW6 +zSA;TfWGMWausz{~eqDNV_^OdeY?yar30C^TDb*Dc$XyXccBdHq6> +z{IlzI*~IYg&$P$ +z%J!=KO(4Uz8#!Jb3ua|trlQgpcgw&R72gXZ(k_y5&@3snD!#1MoQi|v^r56*AYD6> +z>hN@*$mdhSitXBgD9?%6hEr+KyIe=R62TN6FI?K1B>`j3Z4q`Lg*@4U%pr`{4oPf0 +zyAUNZGf7Fc#F!o&lwnC6YL`RUq#Zdp!SRxJ-Jw|2VTaJPt5vcH48~@L0bMu)Viwh- +z%^a`VuJ8u%r)ZMB=uDemK_}ZY9WRn~8Km~f97JEYeEcYyb_@HkjTd +z8`_bEI8L@C{^dm_b06$4Pqgv>F8rGNt|((;uI0m`AzaXGhY|U#A_H}p7Uf!#y#p(R +zu_()ER!T1yEfluvds0+=;rWoO*>dMt)`}m%+AZI!lC9GKgRfIX)A*jUAv=_uvE8<^ +zid_#R#F=#>cD5EATYI(G@i<6fxr*OJlp-TMGYtT1V&sldYrJfSh+u2mn3%KJ`;gTo +z^VHi-oJ6rksY5b4K^6l7pGmg2ncD=S-YPjUD>B?A4mrt$Io1u$odd(lJ;l7>_)h-N +zw=Q}2!gFKnu62g-SsCR4*s3JWFe)4_>d^7`mlZKNI#TF4VXD{%8pCHuDuVS$uwX*$Rd>`Yx&o) +zwDbvl0p!Y3O&gaW3;;!;mr6dK=DjPMO&d|tom{hXMV}LPli{7K&Lg}+j49!||GK<3 +z)YtZs*3)ZOh7G$V6MyKEiq%auUX$^+k=~XP0uFhVpT2eP@Q{Fkb=gQmAd(bwFtiE^JC+Rm3haVU4jB +zt%@a(v8VyO>0(SVlLx2P0L;mWH77vAB2HXMCDb&f2R4mnf`RRaN2X_3gw +zOtb8GjF-ri@vWx0b$lGCf^2QV6=@tqggX@Zsb@!)c5Oii1}ak|^{G;F%OfH=FtM)t +z_1jv;Sr~rR?R{sl?D;i!oW-i-vLl<$;>f8ZGb{E^s6I)1m1B;gS6467EX3tugyoI} +zah}|H?BbD11L!=C+(Ca8iLl*NmI!-WfXL@2fbd(F#0(NM1k?r52~pa^w(fRz6^nBw +z9gEAKj#HV3gWM`@;QF)pDXSoP#{-YXsxD>+5|%9PEC5id=_91lQEoyrBxp6HJ`aEj +zwVjF-vwqvHGV%ZyR2|WcC+B^Z7aV`F9TWo?ozgVyt$`hRR+c0_oRAi=uq7)_O?3sj +zpY3Ut%wotlWHXdNk}R+_nrkH8p2aoJB1BIm)*)b;`w2sf^~&x%ai1~#WZ$afWbNFf +z^{4(g@9Zk*!OBtqx*V9lisaD;Mbvc`9+je5a#0Jg7@|Y7=Ck{#F=rfYqi4|`AQZZiIwXX +z#EzD2E;$i?W!WFQ{n1YcmjCrPci*@&Mja@W0f^FDPYW(G%}M2&IUY)E3_08yp$%U4 +zn?irw(`TD$K-OXfi-ltZ1_uxQcmQwpXw72`DovK<7(xpZj*9v;ZwrZ1CHVVRaR9g@+n<( +zG3=^3&H69Ki?knMCp3Jw+P&qGm-@C&Eiq2!0fmEDH9(i|VSkt4ZS7tbf(9@`8I_^M +z5%tUpqUK+j{O5rSx-Wk1_XB1mkINIsU0I8gWyStMW#%=i;5!Bpc +zst;jnru|&*OX3C2ECQNT$*srcZ~Qi%NcGg^OHaLw2|e-JxhQOhER3urrw#qkdR12 +zDiJ-osN2#7FEdyY)=_WEwqpq4iIJn;u`zLU+p$qh4OIV&ou$gfdG+1YIXWD^=J$?S+(lw>+Blak@_YXc(+O?e6c~`&O +zitaC-xp&q7@qJSN?zg*ZUbw$03?&(h +zQy>en)V53vFmj|zP35f{z(|gPo$${10q;%JgA1Z003bMltd_)WGyx*HoiI6dddL{- +zobrwJDX9lRt5^kYEwiVoNh4h;R7xMtxT+Nc9(OE^bFVhL0SlVK^3l*Sx{qC%1x2%jV2!?4b)e2)|Tb-WuZ*`sm8CazkAS +z+9CjN#h|QJ7}Z!z5`BotoTw{a`MJ^WH=QW?!KI@6_g4qbiFG#$zFdzXL;*IA6RBru +z{}ZpZbmZ`ORg6kxwspW#{dq=~S(A!>w?t05G9z_f&X>XB-4}lL&ia+iVs$%j{i?qo +z1O7~M*V`MfCZWaAf(iB!1yh;~_q(psieR?eOOd}96Qd`OA$yX?-v04Ld9dkV?B4Uv +z>AvL6A6?un|8>^||I4nMyRUxGzI5!P$di10!{DHGw>6GDN*QfdG3mTDIv=k$`UgJh +zc0--ya^rV&ZL!EL$=*M&nSWFmj~iFz>BQ8srp{4D78cIVjaL{qD!X@{y23cPPN#h# +z7#WH>ug)0j=Fi_~JigYL?wk_Fa7>*YF@$^pQxXRNm~*fF5Eb;~Yh7*?(Q#1s>~g-L +zNSfBj)nnU6t(2fGT&$2}*-gb6E>dtcg4xEYqFJWP7g28WnG@WIhC#m_nRHhogBeXus}8(S +z@-!YOOx#PwiuiR6^qL?fM5#+qoe|+e2CV?c>!|JG7l-L!BIc1;4geU#2%*k3;EVA!PE1asQz)P&+MMV5hdZH73))wM={;~)9cbBBy?o@aZwd#Sg%xLO_Ki^lN$ +z!_&q~tM#%?^Ls4gjXwP-<~LW2%Bt*f4Xz=mG^dwKsx?batr$E+l~esj;Y{YsUC6d! +z@Gb%GYgV}AX3P`fKO(Y~yb?QjYLUrY%hauCPz`7hC!_HIdjZJ7I@`j5W +zEES`uH7GzgKSH6{d{f>ih^U$DA(|5VB;wgraUu}r!b +z*$2L2rpps;!Op4sjG*$^1au +z*kGJLO=<-`Bt;(^cHRpSh*LAh&a_yRB4hjf%QMEa{ppKi_ZZt3e3U%#^4iYs`;1G5 +zEptoJu^RT0c>c=yf8S$F^{Gwfr|vh*{=qE#a|oC}@{sYDzH|KAabU?!ve}vZvhhKD +zu*bfXL3XMl1%kS(Scb@^OSWEaFTa#Yz0*T)6A4^!Gn0SAJ?vll74nyPQ#6MZ8Xz|L +zk0jIszugk9JzElsr6$Me$jw3tgFj&**AuXrD4!exJ!ev=E6xshRB>@b52r#9{MmvL +zM62eX=Z+Yx%aDR=V>P$u4(KnArZ~R3Q87Po^)UnRv~P!v6hIkj4qH( +R2C9z#kg;-JJZ5ZK@n1s&V=w>! + +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/FunctionField.lean b/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/FunctionField.lean +index 6c27d435c..f83025581 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/FunctionField.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/FunctionField.lean +@@ -15,43 +15,6 @@ import Mathlib.RingTheory.IsTensorProduct + import HasseWeil.Foundation.Auxiliary.Universal + import HasseWeil.Isogeny.FunctionField + +-/-! +-# The Frobenius Isogeny via Function Fields +- +-We construct the q-th power Frobenius as a concrete isogeny `π : E → E` using the +-function field pullback `π* : K(E) →ₐ[K] K(E)` given by `x ↦ x^q`. +- +-## Main Definitions +- +-* `HasseWeil.frobeniusIsogeny`: The Frobenius as a `PullbackIsogeny K W W`, with pullback +- given by `frobeniusAlgHom K K(E)`. +- +-## Main Results +- +-* `HasseWeil.frobeniusIsogeny_degree`: The Frobenius isogeny has degree `q = #K`. +-* `HasseWeil.frobeniusIsogeny_pow_mem_fieldRange`: pure inseparability of `K(E) / K(E)^q` +- (Silverman II.2.11(b)), stated as a power-membership fact. +-* `HasseWeil.frobeniusIsogeny_pullback_range`: the pullback image is exactly the `q`-th +- powers in `K(E)` (Silverman II.2.11(a)). +- +-## Implementation notes +- +-The degree `[K(E) : K(E)^q] = q` is obtained from the tower law. Writing `x` for the image +-of `X` in the coordinate ring, so `K(E) = K(x, y)`: +- +-* `[K(E) : K(x)] = 2` and `[K(E)^q : K(x^q)] = 2` (the Weierstrass equation is the minimal +- polynomial of `y` over `K(x)`, and of `y^q` over `K(x^q)`); +-* `[K(x) : K(x^q)] = q` (computed via `RatFunc.finrank_eq_max_natDegree`, after identifying +- the Frobenius range in `RatFunc K` with `K⟮X^q⟯`); +-* the tower law gives `[K(E) : K(E)^q] · 2 = 2 · q`, hence `[K(E) : K(E)^q] = q`. +- +-The Frobenius-twisted `Module.finrank` is reduced to the plain field extension `[K(E) : K(E)^q]` +-via `Algebra.finrank_eq_of_equiv_equiv`. +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*][silverman2009], III.4.6, II.2.11 +--/ + + open WeierstrassCurve FiniteField + open scoped Polynomial +@@ -98,7 +61,7 @@ private theorem frobenius_finrank_eq_fieldRange_finrank : + (frobeniusAlgHom K W.toAffine.FunctionField).toRingHom x + simp [AlgEquiv.ofInjective_apply] + +-/-- Explicit module instance: `K[X]` acts on `CoordinateRing` via the algebra structure. -/ ++ + noncomputable instance coordinateRing_module : + Module K[X] W.toAffine.CoordinateRing := + @Algebra.toModule K[X] W.toAffine.CoordinateRing _ _ inferInstance +@@ -107,7 +70,7 @@ instance coordinateRing_finite : Module.Finite K[X] W.toAffine.CoordinateRing := + Module.Finite.of_basis (Affine.CoordinateRing.basis W.toAffine) + + omit [DecidableEq K] [Fintype K] [W.toAffine.IsElliptic] in +-/-- The coordinate ring `K[x, y]/(W)` is a free `K[X]`-module of rank `2` (Silverman II.2). -/ ++ + theorem finrank_coordinateRing_eq_two : + Module.finrank K[X] W.toAffine.CoordinateRing = 2 := + (Module.finrank_eq_card_basis (Affine.CoordinateRing.basis W.toAffine)).trans +@@ -206,7 +169,7 @@ private theorem frobenius_fieldRange_ratFunc : + obtain ⟨p, r, _hr, rfl⟩ : ∃ p r : K[X], algebraMap K[X] (RatFunc K) r ≠ 0 ∧ + g = algebraMap K[X] (RatFunc K) p / algebraMap K[X] (RatFunc K) r := + ⟨g.num, g.denom, RatFunc.algebraMap_ne_zero g.denom_ne_zero, g.num_div_denom.symm⟩ +- simp only [div_pow, ← map_pow, ← FiniteField.expand_card (K := K)] ++ simp only [div_pow, ← map_pow, ← FiniteField.Polynomial.expand_card (K := K)] + have hmem : ∀ f : K[X], algebraMap K[X] (RatFunc K) (Polynomial.expand K q f) ∈ A := by + intro f + have h_amap : ∀ g : K[X], +@@ -340,8 +303,8 @@ private theorem finrank_over_frobenius_image : + lia + + omit [DecidableEq K] [W.toAffine.IsElliptic] in +-/-- **Core algebraic fact**: `[K(E) : K(E)^q] = q`, where the module structure on `K(E)` over +-itself is via the `q`-th power Frobenius (Silverman II.2.11(a)). -/ ++ ++ + theorem frobenius_finrank_functionField : + @Module.finrank W.toAffine.FunctionField W.toAffine.FunctionField _ _ + (frobeniusAlgHom K W.toAffine.FunctionField).toRingHom.toAlgebra.toModule = +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/OrdAtInfty.lean b/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/OrdAtInfty.lean +index 166040c82..a3a20a730 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/OrdAtInfty.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/Frobenius/OrdAtInfty.lean +@@ -10,23 +10,19 @@ import HasseWeil.Foundation.EC.GenericPointZsmul + import HasseWeil.Foundation.EC.MulByIntBaseCase + + /-! +-# Frobenius-specialized addition-pullback ord-at-infinity computations ++# Orders at infinity for Frobenius addition + +-For `α = frobeniusIsog W` (the Frobenius endomorphism over a finite field +-`K` with `q = #K ≥ 2`), we compute the order at infinity of the addition- +-formula slope and related quantities. These are the building blocks for the +-pole bound `ord_∞(addPullback_x W (frobeniusIsog W)) ≤ -2`, which closes +-Sorry 1 of `HasseWeil/AdditionPullback.lean` for the case actually used by +-HOLE D in the unconditional Hasse-Weil bound. ++For Frobenius `π` over a finite field of size `q`, the coordinate differences ++have orders `−2q` and `−3q`, so their slope has order `−q`. Clearing the ++addition-formula denominator and reducing by the Weierstrass equation gives ++the precise coordinate pole orders. + +-## Main lemmas ++The same arguments apply to negative Frobenius and the pencil `r·π − s·id`. ++Curve-negation invariance places the summed x-coordinate in `K(x)`; its pole ++then proves transcendence and the injectivity required for the function-field ++pullback. + +-* `ordAtInfty_addSlope_frobenius`: `ord_∞(L) = -q` where `L = addSlope W π`. +-* `ordAtInfty_addSlope_sq_frobenius`: `ord_∞(L²) = -2q`. +- +-## References +- +-* Silverman, *The Arithmetic of Elliptic Curves*, IV.1 (orders at infinity). ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, IV.1. + -/ + + open WeierstrassCurve HasseWeil.Curves +@@ -64,7 +60,7 @@ theorem addSlope_frobenius_eq : + simp only [addSlope] + exact Affine.slope_of_X_ne (x_gen_ne_frobeniusIsog_pullback_x_gen W) + +-/-- `ord_∞(x_gen − π·x) = -2q` (sign-flipped form of the previously-shipped ++/-- `ord_∞(x_gen − π·x) = -2q` (sign-flipped form of the corresponding + `ordAtInfty_frobeniusIsog_pullback_x_gen_sub_x_gen`). -/ + theorem ordAtInfty_x_gen_sub_frobeniusIsog_pullback_x_gen : + (W_smooth W).ordAtInfty (x_gen W - (frobeniusIsog W).pullback (x_gen W)) = +@@ -98,7 +94,7 @@ theorem x_gen_sub_frobeniusIsog_pullback_x_gen_ne_zero : + exact WithTop.coe_ne_top h_top + + /-- **`ord_∞(addSlope W π) = -q`** where `q = #K`. Direct from +-`ordAtInfty_div_of_ord_eq` with the shipped sub-ord lemmas. -/ ++`ordAtInfty_div_of_ord_eq` with the sub-ord lemmas. -/ + theorem ordAtInfty_addSlope_frobenius : + (W_smooth W).ordAtInfty (addSlope W (frobeniusIsog W)) = + ((-(Fintype.card K : ℤ)) : WithTop ℤ) := by +@@ -131,9 +127,8 @@ theorem ordAtInfty_addSlope_sq_frobenius : + push_cast + ring + +-/-- **Witness-parametric Sorry 1 closure for the Frobenius case** (Path Y): +-given a pole hypothesis on `addPullback_x W (frobeniusIsog W)`, derive False +-from `addPullback_x = algebraMap K _ c`. -/ ++/-- A pole of the Frobenius addition x-coordinate rules out every constant ++ value in the base field. -/ + theorem addPullback_x_ne_const_frobenius_of_pole + (hxy : AddNonInverse W (frobeniusIsog W)) + (h_pole : +@@ -142,7 +137,7 @@ theorem addPullback_x_ne_const_frobenius_of_pole + False := + addPullback_x_ne_const_of_pole hxy c h_pole hc + +-/-! ### Path X-prime: pole bound for q ≥ 3 with cancellation witness ++/-! ### pole bound for q ≥ 3 with cancellation witness + + `addPullback_x = L² + a₁L - a₂ - x_gen - π·x`. Regroup as + `(L² - π·x) + (a₁L - a₂ - x_gen)`. The right group has ord exactly `-q` +@@ -231,26 +226,14 @@ private theorem ordAtInfty_add_le_neg_two {A B : KE} (hq : 3 ≤ Fintype.card K) + have : (3 : ℤ) ≤ (Fintype.card K : ℤ) := by exact_mod_cast hq + linarith + +-/-- **Pole bound for q ≥ 3 with cancellation witness** (Path X-prime, +-**SUPERSEDED**): `ord_∞(addPullback_x W π) ≤ -2`, given the structural +-witness `ord(L² - π·x) ≠ -q`. +- +-**Status: SUPERSEDED.** The hypothesised witness is unprovable when +-`a₁ ≠ 0`. Direct term-by-term ord arithmetic on the `(y - π·y)² +-- π·x · (x - π·x)²` numerator shows that the term `-a₁·π·x·π·y` at +-ord `-5q` is the unique smallest (when `a₁ ≠ 0`), forcing +-`ord(L² - π·x) = -q` exactly. So `lt_or_gt_of_ne h_witness` cannot +-be applied: the witness is false in the case it is supposed to discharge. +- +-The replacement is the direct numerator-of-`addPullback_x` analysis +-shipped below as `addPullbackNumerator_frobenius`, which sidesteps the +-`L² - π·x` regrouping entirely. The lemmas immediately below are kept +-for now to preserve a stable API in case downstream callers reference +-them, but should not be used to close Sorry 1. +- +-The witness-parametric form remains formally true (vacuously, since +-the witness premise is unsatisfiable in the relevant case) but yields +-no usable closure. -/ ++/-- A pole bound under the additional cancellation witness ++ `ord(L² − π·x) ≠ −q`. ++ ++ When `a₁ ≠ 0`, direct numerator comparison forces ++ `ord(L² − π·x) = −q`: the term `−a₁·π·x·π·y` has uniquely minimal ++ order `−5q`. Thus the extra witness excludes that situation. The ++ reduced-numerator argument gives the coordinate pole without this ++ witness. -/ + theorem addPullback_x_pole_frobenius_of_lc_witness + (hq : 3 ≤ Fintype.card K) + (ha1 : W.toAffine.a₁ ≠ 0) (ha2 : W.toAffine.a₂ ≠ 0) +@@ -286,7 +269,7 @@ theorem addPullback_x_pole_frobenius_of_lc_witness + ordAtInfty_a1L_minus_a2_minus_xgen_frobenius W hq ha1 ha2 + exact ordAtInfty_add_le_neg_two W hq h_ord_B h_witness + +-/-- **Sorry 1 closure for Frobenius case (q ≥ 3)** with leading-coefficient ++/-- **Nonconstancy from the coordinate pole for Frobenius case (q ≥ 3)** with leading-coefficient + witness. Composes the pole bound with `addPullback_x_ne_const_frobenius_of_pole`. -/ + theorem addPullback_x_ne_const_frobenius_q_ge_3_of_witness + (hq : 3 ≤ Fintype.card K) +@@ -305,36 +288,19 @@ theorem addPullback_x_ne_const_frobenius_q_ge_3_of_witness + exact_mod_cast (by norm_num : (-2 : ℤ) < 0) + exact addPullback_x_ne_const_frobenius_of_pole W hxy h_pole c hc + +-/-! ### Direct numerator approach (replaces the broken `_lc_witness` path) +- +-The witness `ord(L² - π·x) ≠ -q` is unprovable because `ord(L² - π·x) = -q` +-exactly when `a₁ ≠ 0` (the case of interest). Instead we work directly with +-the numerator of `addPullback_x · (x - π·x)²`. +- +-Multiplying the addition formula `addPullback_x = L² + a₁·L - a₂ - x_gen - π·x` +-through by `(x - π·x)²` (using `L = (y - π·y)/(x - π·x)`) yields the polynomial- +-shaped element +- +-``` +-T₁ + T₂ - T₃ +- with T₁ = (y_gen - π·y)², +- T₂ = a₁ · (x_gen - π·x) · (y_gen - π·y), +- T₃ = (x_gen - π·x)² · (a₂ + x_gen + π·x). +-``` ++/-! ### Clearing the addition denominator + +-The `ord_∞` values, for `q ≥ 2`: ++Multiplying `L² + a₁L − a₂ − x − π·x` by `(x − π·x)²` gives ++`T₁ + T₂ − T₃`, with ++`T₁ = (y − π·y)²`, `T₂ = a₁(x − π·x)(y − π·y)` and ++`T₃ = (x − π·x)²(a₂ + x + π·x)`. ++Their orders are `−6q`, `−5q` (when `a₁ ≠ 0`) and `−6q`. + +-| term | ord | +-|------|------| +-| `T₁` | `-6q` | +-| `T₂` | `-5q` (when `a₁ ≠ 0`) | +-| `T₃` | `-6q` | +- +-The leading-coefficient analysis at `-6q` (deferred to a follow-up session) +-gives `lc(T₁) + lc(-T₃) = 2·c_x^{3q} ≠ 0` in characteristic `≠ 2`, hence +-`ord(T₁ + T₂ - T₃) = -6q` and `ord(addPullback_x) = -6q + 4q = -2q < 0`. +- +-These lemmas ship the term-ord half of the analysis. -/ ++The Weierstrass equation reduces this numerator so that `x(π·x)²`, of ++order `−2 − 4q`, strictly dominates the remaining terms. Since the ++squared denominator has order `−4q`, the summed x-coordinate has order ++`−2`, in every characteristic. ++-/ + + /-- The denominator `y_gen − π·y` is nonzero (its ord is finite). -/ + theorem y_gen_sub_frobeniusIsog_pullback_y_gen_ne_zero : +@@ -396,7 +362,7 @@ theorem addPullbackNumerator_frobenius_eq : + ring + + /-- **`ord_∞(T₁) = -6q`** where `T₁ = (y_gen − π·y)²` and `q = #K`. +-Direct from `ordAtInfty_pow_of_ord_eq` applied to the shipped ++Direct from `ordAtInfty_pow_of_ord_eq` applied to + `ordAtInfty_y_gen_sub_frobeniusIsog_pullback_y_gen`. -/ + theorem ordAtInfty_T1_frobenius : + (W_smooth W).ordAtInfty +@@ -411,7 +377,7 @@ theorem ordAtInfty_T1_frobenius : + ring + + /-- **`ord_∞(T₂) = -5q`** where `T₂ = a₁·(x_gen − π·x)·(y_gen − π·y)` +-and `a₁ ≠ 0`. Multiplicativity of `ord_∞` plus the shipped sub-ord lemmas. -/ ++and `a₁ ≠ 0`. Multiplicativity of `ord_∞` plus the sub-ord lemmas. -/ + theorem ordAtInfty_T2_frobenius (ha₁ : W.toAffine.a₁ ≠ 0) : + (W_smooth W).ordAtInfty + (algebraMap K KE W.toAffine.a₁ * +@@ -551,7 +517,7 @@ a polynomial-shaped expression whose unique smallest-order term is + `x_gen · (π·x)²` at order `-2 - 4q`. + + This reduction yields `ord_∞(addPullback_x) = -2` (independent of q!), +-which immediately closes Sorry 1 for `q ≥ 3` in **any characteristic** ++which immediately closes the nonconstancy condition for `q ≥ 3` in **any characteristic** + (the `x_gen · (π·x)²` term has coefficient `1`, never vanishing). -/ + + /-- The Weierstrass-reduced form of `addPullbackNumerator_frobenius`. +@@ -651,7 +617,7 @@ than `x_gen · (π·x)²` has `ord_∞ ≥ -3 - 3q`. The dominant term has + `ord_∞ = -2 - 4q`. Since `-3 - 3q > -2 - 4q` for `q ≥ 2`, strict + non-archimedean additivity gives `ord(reduced) = -2 - 4q`. -/ + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Helper: `ord(algebraMap c · f) ≥ ord(f)`. The `algebraMap K KE c` + factor never makes the order more negative — when `c = 0` the product + is zero (ord `⊤`), and when `c ≠ 0` the algebraMap value has ord 0. -/ +@@ -860,6 +826,7 @@ private lemma ord_a4_mul_x_add_pi_x_ge (hq : 2 ≤ Fintype.card K) : + rw [ord_x_gen_add_pi_x_eq W hq] + exact WithTop.coe_le_coe.mpr h_int + ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Helper: `ord_∞(2 · a₆) ≥ -3 - 3q` for `q ≥ 2`. -/ + private lemma ord_two_mul_a6_ge (hq : 2 ≤ Fintype.card K) : + (((-3 - 3 * (Fintype.card K : ℤ)) : ℤ) : WithTop ℤ) ≤ +@@ -1020,7 +987,7 @@ theorem ordAtInfty_addPullbackNumerator_reduced_frobenius_eq + ((W_smooth W).ordAtInfty_add_eq_of_lt (ord_dom_lt_rest W hq)).trans + (ord_x_gen_mul_pi_x_sq_eq W) + +-/-! ### Sorry 1 closure for Frobenius case (q ≥ 2, any characteristic) -/ ++/-! ### Nonconstancy from the coordinate pole for Frobenius case (q ≥ 2, any characteristic) -/ + + /-- **`ord_∞(addPullback_x W π) = -2`** for `q ≥ 2` (any characteristic). + +@@ -1061,7 +1028,7 @@ theorem ord_addPullback_x_frobenius (hq : 2 ≤ Fintype.card K) : + congr 1 + ring + +-/-- **Sorry 1 closure for the Frobenius case** (`q ≥ 2`, any characteristic): ++/-- **Nonconstancy from the coordinate pole for the Frobenius case** (`q ≥ 2`, any characteristic): + `addPullback_x W (frobeniusIsog W)` is not the image of any constant `c ∈ K`. + + Direct from `ord_addPullback_x_frobenius` (which gives `ord = -2 < 0`, +@@ -1074,44 +1041,21 @@ theorem addPullback_x_ne_const_frobenius + rw [ord_addPullback_x_frobenius W hq] + exact_mod_cast (by norm_num : (-2 : ℤ) < 0) + +-/-- **Inequality wrapper** for `ord_addPullback_x_frobenius`. +- +-Some downstream consumers (CLOSE-A-1 ticket spec) want the `≤ -2` form +-rather than the equality. Trivial corollary. -/ ++/-- The Frobenius addition x-coordinate has order at most minus two. -/ + theorem ordAtInfty_addPullback_x_frobenius_le_neg_two + (hq : 2 ≤ Fintype.card K) : + (W_smooth W).ordAtInfty (addPullback_x W (frobeniusIsog W)) ≤ + ((-2 : ℤ) : WithTop ℤ) := + (ord_addPullback_x_frobenius W hq).le + +-/-! ### `negFrobeniusIsog`: the `−π` isogeny (HOLE-D-bound work, Day 1) +- +-For HOLE D, we ultimately need the addition-pullback for `1 − π`, which +-is `id + α` with `α = −π`. The `−π` isogeny is constructed as the +-composition `[-1] ∘ π` via the existing `Isogeny.comp` and `mulByInt _ (-1)`. +- +-By `Isogeny.comp_algebraMap_eq`, the resulting pullback is +-`f ↦ frobeniusIsog.pullback (mulByInt _ (-1)).pullback f`. For the two +-generators: +-* `(negFrobeniusIsog W).pullback (x_gen W)` reduces to +- `(frobeniusIsog W).pullback (x_gen W) = π·x_gen` (since `[-1]` fixes +- `x_gen`). +-* `(negFrobeniusIsog W).pullback (y_gen W)` reduces to +- `(frobeniusIsog W).pullback (negY x_gen y_gen) = +- (frobeniusIsog W).pullback (-y_gen - a₁·x_gen - a₃)`. By Frobenius +- being a ring hom and `a_i^q = a_i` in `K = F_q`, this equals +- `-π·y_gen - a₁·π·x_gen - a₃` in any characteristic (in char 2 the +- signs are no-ops). +- +-Both pullbacks have the same `ord_∞` as the Frobenius case (`-2q` and +-`-3q` respectively), so the term-ord chain shipped earlier in this file +-templates over to `negFrobeniusIsog` with name-prefix swaps. The reduced- +-numerator analysis (Weierstrass identity certificate) also carries +-forward, since `(π·x_gen, negY π·x π·y)` is on the curve by `equation_neg`. +- +-This file ships only the structural definition tonight. The Day 2 work +-(ord lemmas + pullback formulas + Sorry 1 closure for `α = -π`) is +-factored separately and reuses the existing helpers verbatim. -/ ++/-! ### Negative Frobenius ++ ++The isogeny `−π` is the composition `[-1] ∘ π`. Its pullback sends ++`x` to `π·x` and `y` to `−π·y − a₁·π·x − a₃`, in every characteristic. ++These coordinates have orders `−2q` and `−3q`. The Weierstrass equation ++for the negated point gives the corresponding reduced-numerator pole ++calculation for `1 − π`. ++-/ + + /-- The `-π` isogeny as `[-1] ∘ π`, via `Isogeny.comp` of the existing + `mulByInt _ (-1)` and `frobeniusIsog W` isogenies. -/ +@@ -1131,6 +1075,7 @@ theorem negFrobeniusIsog_toAddMonoidHom_apply (P : W.toAffine.Point) : + rw [mulByInt_apply] + exact (neg_one_zsmul _).trans rfl + ++omit [Fintype K] in + /-- The `[-1]`-pullback sends `y_gen` to `negY x_gen y_gen = -y_gen − a₁·x_gen + − a₃` (the curve-negation formula). + +@@ -1188,7 +1133,7 @@ theorem negFrobeniusIsog_pullback_y_gen : + simp only [map_sub, map_neg, map_mul, + AlgHom.commutes (frobeniusIsog W).pullback] + +-/-! ### `ord_∞` lemmas for the negFrobeniusIsog pullbacks (Day 2 first half) ++/-! ### `ord_∞` lemmas for the negFrobeniusIsog pullbacks + + With the pullback formulas in place, the ord values match the Frobenius + case: +@@ -1265,7 +1210,7 @@ theorem ordAtInfty_negFrobeniusIsog_pullback_y_gen + exact ordAtInfty_sub_eq_of_coe_lt_le W h_lt_q h_neg_πy + (a1_pi_x_plus_a3_ge_neg_two_q W hq) + +-/-! ### addPullbackNumerator for negFrobenius (Day 2 second half opener) ++/-! ### addPullbackNumerator for negFrobenius + + Mirrors the Frobenius numerator + reduction identity, with `α = negFrobeniusIsog W` + instead of `α = frobeniusIsog W`. The (u, v) point used in the reduction is +@@ -1640,7 +1585,7 @@ theorem ordAtInfty_addPullbackNumerator_reduced_negFrobenius_eq + ((W_smooth W).ordAtInfty_add_eq_of_lt (ord_dom_lt_negFrob_rest W hq)).trans + (ord_x_gen_mul_negFrob_pi_x_sq_eq W) + +-/-! ### Sorry 1 closure for the negFrobenius case (Day 2 final) ++/-! ### Nonconstancy from the coordinate pole for the negFrobenius case + + `ord(addPullback_x W (-π)) = -2` follows by dividing the reduced numerator + (ord = -2 - 4q) through `(x_gen − negFrob.pb x_gen)²` (ord = -4q). Then +@@ -1740,12 +1685,11 @@ theorem ord_addPullback_x_negFrobenius (hq : 2 ≤ Fintype.card K) : + congr 1 + ring + +-/-- **Sorry 1 closure for the negFrobenius case** (`q ≥ 2`, any characteristic): ++/-- **Nonconstancy from the coordinate pole for the negFrobenius case** (`q ≥ 2`, any characteristic): + `addPullback_x W (negFrobeniusIsog W)` is not the image of any constant `c ∈ K`. + + Direct from `ord_addPullback_x_negFrobenius` (which gives `ord = -2 < 0`, +-a pole) plus `addPullback_x_ne_const_of_pole`. This is the closure needed +-for HOLE D's `1 − π` use case (since `1 − π = id + (-π)`). -/ ++a pole) plus `addPullback_x_ne_const_of_pole`. For `1 − π`, the addition formula is `id + (−π)`. -/ + theorem addPullback_x_ne_const_negFrobenius + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) (c : K) +@@ -1754,11 +1698,7 @@ theorem addPullback_x_ne_const_negFrobenius + rw [ord_addPullback_x_negFrobenius W hq] + exact_mod_cast (by norm_num : (-2 : ℤ) < 0) + +-/-- **Inequality wrapper** for `ord_addPullback_x_negFrobenius`. +- +-Companion to `ordAtInfty_addPullback_x_frobenius_le_neg_two` for the +-`−π` (negFrobenius) case — the load-bearing case for HOLE D's `1 − π` +-analysis. Trivial corollary of the equality form. -/ ++/-- The Frobenius addition x-coordinate has order at most minus two. -/ + theorem ordAtInfty_addPullback_x_negFrobenius_le_neg_two + (hq : 2 ≤ Fintype.card K) : + (W_smooth W).ordAtInfty (addPullback_x W (negFrobeniusIsog W)) ≤ +@@ -1838,7 +1778,7 @@ private theorem ord_RHS_lower_ge_neg_four_negFrobenius + exact ord_add_ge_of_both_ge W + (ord_add_ge_of_both_ge W h_a₂_term h_a₄_term) h_a₆_term + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Helper: `ord(a₆) ≥ 0` (where `a₆` is a constant in K, viewed in KE). -/ + private theorem ord_a₆_ge_zero : + (0 : WithTop ℤ) ≤ (W_smooth W).ordAtInfty +@@ -2181,66 +2121,25 @@ theorem ord_addPullback_y_negFrobenius (hq : 2 ≤ Fintype.card K) : + have h_m_eq : m = -3 := by omega + exact_mod_cast h_m_eq + +-/-! ### Day 3a: addPullbackAlgHom for the negFrobenius case +- +-The existing `addPullbackAlgHom W α hxy hinj` construction +-(`HasseWeil.AdditionPullback`) is generic over `α`. For HOLE D we want +-this for `α = negFrobeniusIsog W`. The injectivity input +-`hinj : Function.Injective (addCoordAlgHom hxy)` was generically +-provided by a sorry-bearing `addCoordAlgHom_injective` chain (general-`α` +-transcendence of `addPullback_x` resting on an open III.3.6 pole witness) — +-that chain has since been **removed**; only the witness-parametric and +-negFrobenius forms remain. +- +-We ship `addPullbackAlgHom_negFrobenius_of_inj` as a **witness-parametric +-form** taking the (axiom-clean) injectivity proof as a hypothesis. +-Discharging this hypothesis axiom-clean for `α = negFrobeniusIsog W` +-requires one of: +- +-1. Closing Sorry 2 + Sorry 3 generically (~350 LOC, mathlib `minpoly` +- machinery). +- +-2. A negFrobenius-specific σ-invariance argument: prove +- `(mulByInt W (-1)).pullback (addPullback_x W (negFrobeniusIsog W)) +- = addPullback_x W (negFrobeniusIsog W)`. This says addPullback_x is +- fixed by the curve-negation involution `σ : K(E) → K(E)`. By Galois +- theory (K(E) over K(x) is degree-2, σ generates the Galois group), +- σ-fixed elements lie in `K(x) = F(x_gen)`, which discharges the +- `px ∉ F(x_gen)` case of the transcendence argument for the +- negFrobenius case. Then `addPullback_x_ne_const_negFrobenius` +- closes Case 1, completing the chain. +- +-Path 2 is more focused (~100-200 LOC) and closes only what HOLE D +-needs. The σ-invariance lemma proof structure: apply +-`(mulByInt W (-1)).pullback` to the addX formula +-`addPullback_x = L² + a₁L − a₂ − x_gen − π·x`, distribute the AlgHom +-over operations, substitute known values: +-* `(mulByInt W (-1)).pullback x_gen = x_gen` (`mulByInt_pullback_x_neg_one`). +-* `(mulByInt W (-1)).pullback y_gen = −y_gen − a₁·x_gen − a₃` +- (`mulByInt_pullback_y_neg_one`). +-* `(mulByInt W (-1)).pullback (π·x_gen) = π·x_gen` (since `π·x_gen +- = x_gen^q` and AlgHom preserves powers and fixes `x_gen`). +-* `(mulByInt W (-1)).pullback (π·y_gen) = -π·y - a₁·π·x - a₃` (via +- Frobenius distributing over `−y − a₁·x − a₃` in char p, with +- `a^q = a` in `K = F_q`). +- +-Substituting and using `(σ(L_neg)+L_neg) = -a₁` (a curve-arithmetic +-identity, computable via `field_simp; ring` after the algebra-hom +-rewrites), we get `σ(L_neg² + a₁·L_neg) = L_neg² + a₁·L_neg`. The +-remaining terms in addPullback_x (`a₂`, `x_gen`, `π·x_gen`) are all +-σ-fixed. So addPullback_x is σ-invariant. ∎ -/ +- +-/-- Witness-parametric `addPullbackAlgHom` for `α = negFrobeniusIsog W`, +-parametric on the `addCoordAlgHom hxy`-injectivity hypothesis. Once +-that hypothesis is dischargeable axiom-clean (via Path 2 above or +-Sorry 2 + Sorry 3 closure), the resulting algebra-hom feeds the +-`isogOneSub` placeholder replacement and closes HOLE D. -/ ++/-! ### Injectivity of the negative-Frobenius addition pullback ++ ++Curve negation fixes `x` and sends `y` to `−y − a₁x − a₃`. Applying it to ++the negative-Frobenius slope gives `σ(L) + L = −a₁`, hence fixes ++`L² + a₁L` and the summed x-coordinate. The fixed field is `K(x)`. ++An algebraic element of this rational function field is constant, whereas ++the summed x-coordinate has a pole. It is therefore transcendental over ++`K`, which proves injectivity of its polynomial evaluation homomorphism ++and then of the coordinate-ring homomorphism. ++-/ ++ ++/-- The function-field addition pullback for negative Frobenius, given ++ injectivity of the coordinate-ring homomorphism. -/ + noncomputable def addPullbackAlgHom_negFrobenius_of_inj + (hxy : AddNonInverse W (negFrobeniusIsog W)) + (hinj : Function.Injective (addCoordAlgHom hxy)) : KE →ₐ[K] KE := + addPullbackAlgHom hxy hinj + +-/-! ### σ-invariance lemmas (Path 2 to discharge `hinj` axiom-clean) -/ ++/-! ### Curve-negation invariance -/ + + /-- **σ-invariance Step 1**: + `σ(π·y_gen) = (negFrobeniusIsog W).pullback (y_gen W)` where +@@ -2360,7 +2259,7 @@ theorem addPullback_x_negFrobenius_sigma_invariant : + + /-! ### Galois group identification: {1, σ} on K(E)/K(x) + +-Day 3a-final opener. To deduce that σ-fixed elements lie in K(x), we ++To deduce that σ-fixed elements lie in K(x), we + need to know that {1, σ} is the full Galois group of K(E)/K(x). + + The two structural facts: +@@ -2370,6 +2269,7 @@ The two structural facts: + + Combined with `[K(E) : K(x)] = 2`, this is the full Galois group. -/ + ++omit [Fintype K] in + /-- **σ has order 2**: `(mulByInt W (-1)).pullback.comp (mulByInt W (-1)).pullback + = AlgHom.id`. The Galois-group order-2 statement, derived from the isogeny + identity `[-1] ∘ [-1] = [1]` (`mulByInt_comp_eq_mul`) plus +@@ -2395,6 +2295,7 @@ theorem mulByInt_neg_one_pullback_comp_self : + from rfl] at h_pb + rw [h_pb, mulByInt_one_pullback_eq_id] + ++omit [Fintype K] in + /-- **σ ∘ σ = id pointwise**: for any `z ∈ KE`, + `(mulByInt W (-1)).pullback ((mulByInt W (-1)).pullback z) = z`. -/ + theorem mulByInt_neg_one_pullback_pow_two_apply (z : KE) : +@@ -2413,6 +2314,7 @@ forces non-triviality). In characteristic 2 we need the discriminant: a curve + with `a₁ = a₃ = 0` would have `Δ = 0` (by `Δ_of_char_two`), contradicting + `[IsElliptic]`. -/ + ++omit [Fintype K] in + /-- **σ ≠ id in characteristic 2**: the curve-negation involution + `σ = (mulByInt W (-1)).pullback` does not fix `y_gen`. + +@@ -2481,6 +2383,7 @@ private lemma two_K_eq_zero_of_two_fractionRing + rw [map_zero, map_ofNat] + exact h + ++omit [Fintype K] in + /-- **σ ≠ id in characteristic ≠ 2**: in char ≠ 2, the curve-negation involution + σ does not fix `y_gen`. + +@@ -2515,6 +2418,7 @@ theorem mulByInt_neg_one_pullback_y_gen_ne_y_gen_char_ne_two + obtain ⟨_, hq_zero⟩ := (W_smooth W).decomp_zero_iff h_zero_smul + exact h2 (two_K_eq_zero_of_two_fractionRing hq_zero) + ++omit [Fintype K] in + /-- **σ ≠ id (unified)**: in any characteristic, the curve-negation involution + `σ = (mulByInt W (-1)).pullback` does not fix `y_gen`. + +@@ -2525,7 +2429,7 @@ theorem mulByInt_neg_one_pullback_y_gen_ne_y_gen : + (mulByInt W.toAffine (-1)).pullback (y_gen W) ≠ y_gen W := by + by_cases h2 : (2 : K) = 0 + · -- Char 2 case via `[CharP K 2]` derived from `h2`. +- haveI : CharP K 2 := CharTwo.of_one_ne_zero_of_two_eq_zero one_ne_zero h2 ++ have : CharP K 2 := CharTwo.of_one_ne_zero_of_two_eq_zero one_ne_zero h2 + exact mulByInt_neg_one_pullback_y_gen_ne_y_gen_char_two W + · -- Char ≠ 2 case directly. + exact mulByInt_neg_one_pullback_y_gen_ne_y_gen_char_ne_two W h2 +@@ -2535,6 +2439,7 @@ theorem mulByInt_neg_one_pullback_y_gen_ne_y_gen : + A small first piece toward σ-fixed → K(x): σ commutes with the constant + embedding `K → K(E)`. -/ + ++omit [Fintype K] in + /-- σ fixes the image of `K → K(E)`: for any `c : K`, + `σ(algebraMap c) = algebraMap c`. Immediate from σ being a `K`-algebra hom. -/ + @[simp] theorem mulByInt_neg_one_pullback_algebraMap_K (c : K) : +@@ -2542,6 +2447,7 @@ embedding `K → K(E)`. -/ + algebraMap K KE c := + AlgHom.commutes (mulByInt W.toAffine (-1)).pullback c + ++omit [Fintype K] in + /-- σ fixes `algebraMap (Polynomial K) KE p` for any polynomial `p`. + Using `algebraMap p = aeval x_gen p` (via algebra-hom uniqueness on the + generator `X ↦ x_gen`) plus σ commutes with `aeval` and σ fixes `x_gen`. -/ +@@ -2566,6 +2472,7 @@ theorem mulByInt_neg_one_pullback_algebraMap_polyK (p : Polynomial K) : + simpa using this + rw [h_eval, ← Polynomial.aeval_algHom_apply, mulByInt_pullback_x_neg_one] + ++omit [Fintype K] in + /-- σ fixes the image of `Frac(K[X]) → K(E)`: for any `r ∈ Frac(K[X])`, + `σ(algebraMap r) = algebraMap r`. Lifts `mulByInt_neg_one_pullback_algebraMap_polyK` + via `IsLocalization.surj` denominator clearing. -/ +@@ -2598,6 +2505,7 @@ theorem mulByInt_neg_one_pullback_algebraMap_kx + + /-! ### Path 2 Step 3 Piece 3b: σ acts on coordY -/ + ++omit [Fintype K] in + /-- σ acts on `y_gen` as `-y_gen - a₁·x - a₃`. (Re-statement of + `mulByInt_pullback_y_neg_one` for use with the basis decomposition machinery.) -/ + theorem mulByInt_neg_one_pullback_y_gen_eq : +@@ -2608,6 +2516,7 @@ theorem mulByInt_neg_one_pullback_y_gen_eq : + + /-! ### Path 2 Step 3 Piece 3c helpers -/ + ++omit [Fintype K] [DecidableEq K] in + /-- The polynomial `a₁ X + a₃` is nonzero in characteristic 2 for an elliptic + curve. If it were zero, then `a₁ = a₃ = 0`, and `Δ_of_char_two` would give + `Δ = 0`, contradicting `[IsElliptic]`. -/ +@@ -2625,6 +2534,7 @@ theorem a₁X_plus_a₃_ne_zero_char_two [CharP K 2] : + rw [WeierstrassCurve.Δ_of_char_two, h_a1, h_a3]; ring + exact W.toAffine.isUnit_Δ.ne_zero h_delta + ++omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Image of the polynomial `a₁ X + a₃` under `K[X] → KE`: equals + `a₁ · x_gen + a₃` in `KE`. -/ + theorem algebraMap_a₁X_plus_a₃ : +@@ -2642,6 +2552,7 @@ theorem algebraMap_a₁X_plus_a₃ : + intro c; rw [Polynomial.C_eq_algebraMap, ← IsScalarTower.algebraMap_apply] + rw [map_add, map_mul, h_C, h_C, h_x_alg] + ++omit [Fintype K] [DecidableEq K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The image of `a₁ X + a₃` under the composite `K[X] → Frac(K[X]) → KE` equals + `a₁ · x_gen + a₃` in `KE`. Lifts `algebraMap_a₁X_plus_a₃` along the scalar tower + `K[X] → Frac(K[X]) → KE`. -/ +@@ -2665,6 +2576,7 @@ private lemma smul_one_add_smul_y_gen_eq_algebraMap + algebraMap (FractionRing (Polynomial K)) KE b * y_gen W := by + simp only [Algebra.smul_def, mul_one] + ++omit [Fintype K] in + /-- σ acting on an `algebraMap`-decomposition: applying `σ = (mulByInt W (-1)).pullback` + to `algebraMap a + (algebraMap b) · y_gen` gives + `algebraMap a + (algebraMap b) · (-y_gen - a₁·x - a₃)`, since σ fixes the +@@ -2684,6 +2596,7 @@ private lemma mulByInt_neg_one_pullback_algebraMap_add_algebraMap_mul_y_gen + mulByInt_neg_one_pullback_algebraMap_kx, + mulByInt_neg_one_pullback_y_gen_eq] + ++omit [Fintype K] in + /-- Helper for Piece 3c: the σ-equation as a vanishing `{1, Y}`-decomposition. + + If `f = a • 1 + b • Y` is fixed by `σ = (mulByInt W (-1)).pullback`, then applying +@@ -2719,6 +2632,7 @@ private lemma sigma_fixed_decomp_coeffs_vanish {a b : FractionRing (Polynomial K + map_mul, map_mul, algebraMap_fractionRing_a₁X_plus_a₃ W, map_ofNat] + linear_combination -h_combine + ++omit [Fintype K] in + /-- Helper for Piece 3c: char-split forcing `b = 0`. + + From the two vanishing coefficients of `sigma_fixed_decomp_coeffs_vanish`, +@@ -2733,7 +2647,7 @@ private lemma eq_zero_of_mul_a₁X_plus_a₃_and_two_mul_eq_zero + (hqb : 2 * b = 0) : b = 0 := by + by_cases h2 : (2 : K) = 0 + · -- Char 2: `a₁ X + a₃ ≠ 0`, so `b · (a₁X+a₃) = 0` forces `b = 0`. +- haveI : CharP K 2 := CharTwo.of_one_ne_zero_of_two_eq_zero one_ne_zero h2 ++ have : CharP K 2 := CharTwo.of_one_ne_zero_of_two_eq_zero one_ne_zero h2 + have h_bXf_ne : algebraMap (Polynomial K) (FractionRing (Polynomial K)) + (Polynomial.C W.toAffine.a₁ * Polynomial.X + Polynomial.C W.toAffine.a₃) ≠ 0 := + fun h_eq ↦ a₁X_plus_a₃_ne_zero_char_two W +@@ -2756,6 +2670,7 @@ the image of `Frac(K[X]) → K(E)`. Combines the σ-action on the basis + decomposition `{1, Y}` (Pieces 0/1/2/3b) with `decomp_zero_iff` and a + char-split. -/ + ++omit [Fintype K] in + /-- **Path 2 Step 3 Piece 3c**: If `f ∈ KE` is fixed by `σ`, then + `f` is in the image of `algebraMap (Frac K[X]) KE`. + +@@ -2796,18 +2711,18 @@ theorem addPullback_x_negFrobenius_in_KX_image : + sigma_fixed_implies_in_KX_image W _ + (addPullback_x_negFrobenius_sigma_invariant W) + +-/-! ### Path 2 Steps 4+5: addPullback_x_negFrobenius is transcendental ++/-! ### addPullback_x_negFrobenius is transcendental + +-The consumer of `addPullback_x_negFrobenius_in_KX_image`. Combines that ++Apply `addPullback_x_negFrobenius_in_KX_image`. Combines that + witness with `algebraic_in_fracRing_eq_const` (algebraic-closure-of-K-in-K(x)) + and `addPullback_x_ne_const_negFrobenius` (the non-constancy lemma) to +-discharge transcendence axiom-clean for the `α = -π` case. -/ ++prove transcendence for the `α = -π` case. -/ + +-/-- **Path 2 Step 4+5 (axiom-clean closure of Sorry 2 for α = -π)**: ++/-- **Transcendence for negative Frobenius**: + `addPullback_x W (negFrobeniusIsog W)` is transcendental over `K`. + + Proof outline: +-* By `addPullback_x_negFrobenius_in_KX_image` (Piece 3d): there exists ++* By `addPullback_x_negFrobenius_in_KX_image`: there exists + `r : Frac(K[X])` with `addPullback_x = algebraMap _ KE r`. + * If `addPullback_x` were algebraic over `K`, so would `r` be (since + `algebraMap _ KE` is injective and pulls back transcendence). +@@ -2836,18 +2751,15 @@ theorem addPullback_x_transcendental_negFrobenius + rw [hr, hc, ← IsScalarTower.algebraMap_apply K (FractionRing (Polynomial K)) KE] + exact addPullback_x_ne_const_negFrobenius W hq hxy c hc' + +-/-! ### Day 3b: addCoordAlgHom injectivity for the negFrobenius case ++/-! ### Coordinate-ring injectivity from transcendence + +-Consumer of `addPullback_x_transcendental_negFrobenius` (Steps 4+5). Uses the +-witness-parametric `addCoordAlgHom_injective_of_baseHom_inj` with the +-unconditional base-hom injectivity below (the sorry-bearing generic +-`addBaseHom_injective` has been removed). -/ ++Transcendence of the summed x-coordinate gives injectivity of polynomial ++evaluation, and the integral coordinate-ring extension gives injectivity ++of the coordinate homomorphism. ++-/ + +-/-- **Day 3b helper**: `addBaseHom W (negFrobeniusIsog W)` is injective. +-Axiom-clean negFrobenius base-hom injectivity: rewrites the base-hom as +-`Polynomial.aeval (addPullback_x W (negFrob W))` (`addBaseHom_eq_aeval`) +-and applies `transcendental_iff_injective` to the unconditional +-`addPullback_x_transcendental_negFrobenius`. -/ ++/-- Transcendence of the negative-Frobenius addition x-coordinate makes its ++ polynomial evaluation homomorphism injective. -/ + theorem addBaseHom_injective_negFrobenius + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) : +@@ -2856,15 +2768,8 @@ theorem addBaseHom_injective_negFrobenius + exact transcendental_iff_injective.mp + (addPullback_x_transcendental_negFrobenius W hq hxy) + +-/-- **Day 3b**: `addCoordAlgHom` for `α = negFrobeniusIsog W` is injective. +-One-line consumer of `addCoordAlgHom_injective_of_baseHom_inj` and +-`addBaseHom_injective_negFrobenius`. Closes one of the three sorries in HOLE D's +-downstream chain axiom-clean. +- +-Together with `addPullback_x_transcendental_negFrobenius` and Path 2 Step 3, +-the negFrobenius `addCoordAlgHom`-injectivity is now fully +-unconditional — the input needed by `addPullbackAlgHom_negFrobenius_of_inj` +-to build a non-witness-parametric `addPullbackAlgHom_negFrobenius`. -/ ++/-- The negative-Frobenius addition coordinate-ring homomorphism is ++ injective, by injectivity of its polynomial restriction. -/ + theorem addCoordAlgHom_injective_negFrobenius + (hq : 2 ≤ Fintype.card K) + (hxy : AddNonInverse W (negFrobeniusIsog W)) : +@@ -2872,15 +2777,14 @@ theorem addCoordAlgHom_injective_negFrobenius + addCoordAlgHom_injective_of_baseHom_inj hxy + (addBaseHom_injective_negFrobenius W hq hxy) + +-/-! ### Day 3c Piece A: AddNonInverse witness + specialized addPullbackAlgHom ++/-! ### The function-field pullback of `1 − π` + +-The negFrobenius variant of `addPullbackAlgHom` requires both +-`AddNonInverse W (negFrobeniusIsog W)` and the corresponding injectivity +-of `addCoordAlgHom`. Both are dischargeable axiom-clean: the non-inverse +-condition reduces to `x_gen ≠ π·x_gen` (different orders at infinity), +-and injectivity is `addCoordAlgHom_injective_negFrobenius` (c8b4b66). -/ ++The identity and negative-Frobenius x-coordinates differ because their ++orders differ. Together with coordinate-ring injectivity, this constructs ++the addition pullback on the function field. ++-/ + +-/-- **Day 3c Piece A.1**: `AddNonInverse W (negFrobeniusIsog W)` holds ++/-- **Non-inverse coordinates**: `AddNonInverse W (negFrobeniusIsog W)` holds + unconditionally. The negation hypothesis would require `x_gen W = π·x_gen` + (the first conjunct), which contradicts + `x_gen_ne_frobeniusIsog_pullback_x_gen` (their orders at infinity differ). -/ +@@ -2890,11 +2794,8 @@ theorem negFrobeniusIsog_addNonInverse : + rw [negFrobeniusIsog_pullback_x_gen] at h_x + exact x_gen_ne_frobeniusIsog_pullback_x_gen W h_x + +-/-- **Day 3c Piece A.2**: Specialized `addPullbackAlgHom` for `α = negFrobenius`, +-discharging both `AddNonInverse` (via `negFrobeniusIsog_addNonInverse`) and +-`addCoordAlgHom`-injectivity (via `addCoordAlgHom_injective_negFrobenius`) +-axiom-clean. The unconditional algebra hom corresponding to the rational +-map `P ↦ P + (-π)(P) = P - π(P)` (i.e., `1 - π` on rational points). -/ ++/-- The function-field pullback of `P ↦ P − π(P)`, constructed from the ++ non-inverse coordinate witness and the injective coordinate map. -/ + noncomputable def addPullbackAlgHom_negFrobenius + (hq : 2 ≤ Fintype.card K) : KE →ₐ[K] KE := + addPullbackAlgHom_negFrobenius_of_inj W +@@ -2902,22 +2803,14 @@ noncomputable def addPullbackAlgHom_negFrobenius + (addCoordAlgHom_injective_negFrobenius W hq + (negFrobeniusIsog_addNonInverse W)) + +-/-! ### Day 3c Piece B: isogOneSub_negFrobenius (replacement for the placeholder) ++/-! ### The isogeny `1 − π` + +-The unconditional `1 − π` isogeny: pullback from `addPullbackAlgHom_negFrobenius` +-(real addition pullback for `id + (-π)`), rational-point map from +-`(AddMonoidHom.id _) - (frobeniusIsog W).toAddMonoidHom`. Replaces the +-`isogOneSub (frobeniusIsog W)` placeholder (whose pullback was `AlgHom.id`) +-with the mathematically correct pullback. -/ +- +-/-- **Day 3c Piece B**: The isogeny `1 − π` with the unconditional addition-formula +-pullback. Built from `addPullbackAlgHom_negFrobenius` (the pullback for +-`id + (−π) = 1 − π`) and the standard rational-point map +-`(AddMonoidHom.id _) - (frobeniusIsog W).toAddMonoidHom`. ++Its function-field pullback is the addition-formula pullback for ++`id + (−π)`, and its point map is `id − π`. ++-/ + +-Mathematically this is `1 − π` with the correct pullback that the placeholder +-`isogOneSub (frobeniusIsog W)` lacks (it uses `AlgHom.id` as a stub). HOLE D +-wire-up consumes this directly via `Isogeny.toAlgebra`/`degree`. -/ ++/-- The isogeny `1 − π` with its addition-formula function-field pullback ++ and the point map `id − π`. -/ + noncomputable def isogOneSub_negFrobenius + (hq : 2 ≤ Fintype.card K) : Isogeny W.toAffine W.toAffine where + pullback := addPullbackAlgHom_negFrobenius W hq +@@ -2932,20 +2825,12 @@ noncomputable def isogOneSub_negFrobenius + (isogOneSub_negFrobenius W hq).toAddMonoidHom = + (AddMonoidHom.id _) - (frobeniusIsog W).toAddMonoidHom := rfl + +-/-! ### Day 3c Piece C — REMOVED (2026-05-28 placeholder grind) + +-The bridge lemma `isogOneSub_negFrobenius_toAddMonoidHom_eq_oneSubFrobeniusIsog` +-(genuine `1−π` and the placeholder agree on `toAddMonoidHom`) existed only to +-transfer the placeholder's rational-point API to the genuine isogeny. All +-consumers now prove their kernel/point-map facts directly on +-`isogOneSub_negFrobenius` (its `toAddMonoidHom = id − frob`, frob's point map +-is the identity), so the bridge is no longer needed and has been deleted as +-part of removing the placeholder `oneSubFrobeniusIsog`. -/ + +-/-! ### D3b base: `AddNonInversePair` for `(zsmul 1 π, mulByInt (-1))` ++/-! ### `AddNonInversePair` for `(zsmul 1 π, mulByInt (-1))` + + The `(r, s) = (1, 1)` specialisation of the genuine `(zsmul r π, mulByInt (-s))` +-family that D3b/D4 will assemble into `genuineIsogSmulSub r s`. Both pullbacks ++family defining `genuineIsogSmulSub r s`. Both pullbacks + reduce on x-coord to `x_gen W` and `x_gen W ^ q` respectively via + `mulByInt_x_one` / `mulByInt_x_neg` / `frobeniusIsog_pullback_apply`; the + mismatch is `x_gen_ne_frobeniusIsog_pullback_x_gen`. -/ +@@ -2977,12 +2862,12 @@ theorem AddNonInversePair_zsmul_one_frobenius_mulByInt_neg_one : + rw [frobeniusIsog_pullback_apply] at hne + exact hne h.symm + +-/-! ### D3b general consumer: AddNonInversePair for `(zsmul r π, mulByInt -s)` ++/-! ### Non-inverse coordinate pairs: AddNonInversePair for `(zsmul r π, mulByInt -s)` + + Generalises the (1, 1) base case to arbitrary `(r, s) ≠ 0` (with `(r : K) ≠ 0` + and `(s : K) ≠ 0`). The x-coord pullbacks are `(mulByInt_x r)^q` (LHS) and + `mulByInt_x (-s)` (RHS); their orders at infinity are `-2q` and `-2` respectively +-(via `ordAtInfty_mulByInt_x` from `OrdAtInftyBridge.lean:207` and ++(via `ordAtInfty_mulByInt_x` for the coordinate pole and + `ordAtInfty_pow`). For `q ≥ 2`, these are unequal, so the pullbacks are + unequal — Silverman III.6 reflection of Frobenius pole-multiplication. -/ + +@@ -3043,7 +2928,7 @@ theorem AddNonInversePair_zsmul_frobenius_mulByInt_neg + exact_mod_cast Fintype.one_lt_card_iff_nontrivial.mpr inferInstance + linarith + +-/-! ### D3c step 1: σ-action on `(mulByInt n)` pullbacks (generic in `n ≠ 0`) ++/-! ### σ-action on `(mulByInt n)` pullbacks (generic in `n ≠ 0`) + + For any nonzero `n`, σ commutes with `(mulByInt n).pullback`: their composition + on `x_gen` is `(mulByInt (-n)).pullback x_gen = mulByInt_x W (-n) = mulByInt_x W n`, +@@ -3064,6 +2949,7 @@ private theorem mulByInt_comp_mulByInt_neg_one + (by simpa using neg_ne_zero.mpr hn) + rw [h]; congr 1; ring + ++omit [Fintype K] in + /-- **σ.pb fixes `(mulByInt n).pb x_gen`** for `n ≠ 0`. By `mulByInt` + commutativity, `σ.pb ([n].pb x_gen) = ([n].comp σ).pb x_gen + = (mulByInt (-n)).pb x_gen = mulByInt_x W (-n) = mulByInt_x W n` (the last by +@@ -3080,6 +2966,7 @@ theorem sigma_mulByInt_pullback_x_eq (n : ℤ) (hn : n ≠ 0) : + rw [mulByInt_pullback_x W (-n) (neg_ne_zero.mpr hn), mulByInt_x_neg] + exact (mulByInt_pullback_x W n hn).symm + ++omit [Fintype K] in + /-- **σ.pb on `(mulByInt n).pb y_gen`** for `n ≠ 0`. Same composition path + as the x-version but using `mulByInt_y_neg`: the σ-image is + `negY (mulByInt_x n) (mulByInt_y n) = -mulByInt_y n - a₁·mulByInt_x n - a₃`. -/ +@@ -3117,7 +3004,7 @@ theorem sigma_mulByInt_pullback_y_eq (n : ℤ) (hn : n ≠ 0) : + simp only [WeierstrassCurve.Affine.negY] + rfl + +-/-! ### D3c step 2: σ-action on `(zsmul r π).pb` ++/-! ### σ-action on `(zsmul r π).pb` + + For `α₁ = (frobeniusIsog W).zsmul r = (mulByInt r).comp π`, the σ-action + follows from `sigma_mulByInt_pullback_x_eq` / `_y_eq` plus σ commuting +@@ -3176,13 +3063,14 @@ theorem sigma_zsmul_frobenius_pullback_y_eq (r : ℤ) (hr : r ≠ 0) : + simp only [map_sub, map_neg, map_mul, + AlgHom.commutes (frobeniusIsog W).pullback] + +-/-! ### D3c step 3: x-ne mismatch witness for `(zsmul r π, mulByInt -s)` ++/-! ### x-ne mismatch witness for `(zsmul r π, mulByInt -s)` + + Extracted from `AddNonInversePair_zsmul_frobenius_mulByInt_neg`'s internal + proof: the x-coord pullbacks differ at `ord_∞` (`-2q` vs `-2`). Used + directly as the `h_x_ne` argument to the generic + `addPullback_x_pair_sigma_invariant`. -/ + ++omit [DecidableEq K] in + /-- The `ord_∞` contradiction behind the `x`-coord mismatch: `(mulByInt_x W r)^|K|` + (order `-2q`) cannot equal `mulByInt_x W (-s)` (order `-2`), since `|K|·(-2) = -2` + would force `|K| ≤ 1`. -/ +@@ -3224,16 +3112,16 @@ theorem zsmul_frobenius_pullback_x_ne_mulByInt_neg_pullback_x + rw [zsmul_frobenius_pullback_x_gen W r hr, mulByInt_neg_pullback_x_gen W s hs] + exact mulByInt_x_pow_card_ne_mulByInt_x_neg W r s hr hrK hs hsK + +-/-! ### D3c step 4: σ-invariance specialised + K(x) image ++/-! ### σ-invariance specialised + K(x) image + + Specialise `addPullback_x_pair_sigma_invariant` to + `(α₁, α₂) = (zsmul r π, mulByInt -s)` using the four σ-symmetry helpers +-shipped above, then chain with `sigma_fixed_implies_in_KX_image` to extract ++above, then chain with `sigma_fixed_implies_in_KX_image` to extract + the K(x) image. -/ + + /-- **σ-invariance of `addPullback_x_pair (zsmul r π, mulByInt -s)`**. + Specialisation of the generic `addPullback_x_pair_sigma_invariant` for +-the family used by D3c/D4. -/ ++this pencil family. -/ + theorem addPullback_x_pair_zsmul_frobenius_mulByInt_neg_sigma_invariant + (r s : ℤ) (hr : r ≠ 0) (hs : s ≠ 0) + (hrK : (r : K) ≠ 0) (hsK : (s : K) ≠ 0) : +@@ -3262,7 +3150,7 @@ theorem addPullback_x_pair_zsmul_frobenius_mulByInt_neg_in_KX_image + (addPullback_x_pair_zsmul_frobenius_mulByInt_neg_sigma_invariant + W r s hr hs hrK hsK) + +-/-! ### D3c step 5: ord helpers for `(zsmul r π).pb x_gen` and ++/-! ### ord helpers for `(zsmul r π).pb x_gen` and + `(mulByInt -s).pb x_gen` + + Concrete ord values needed by the pole-bound argument: `(zsmul r π).pb x_gen +@@ -3302,6 +3190,7 @@ theorem ordAtInfty_zsmul_frobenius_pullback_x_gen + push_cast + rfl + ++omit [Fintype K] in + /-- `ord_∞((mulByInt (-s)).pb x_gen) = -2` for `s ≠ 0` with `(s : K) ≠ 0`. + Direct from `(mulByInt -s).pb x_gen = mulByInt_x W (-s)` plus + `ordAtInfty_mulByInt_x`. -/ +@@ -3361,7 +3250,7 @@ private lemma ordAtInfty_mulByInt_x_mul_y (r : ℤ) {M m : ℤ} + refine ((W_smooth W).ordAtInfty_mul hX_ne hY_ne).trans ?_ + rw [hX_ord, hm]; push_cast; rfl + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- For `M < 0` the right-hand side of the Weierstrass equation is dominated by `X³`, so + `ord_∞(X³ + a₂·X² + a₄·X + a₆) = 3M` where `M = ord_∞(mulByInt_x W r)`. Repeated strict + non-archimedean additivity: `3M < 2M < M < 0`, so each successive `aᵢ·Xⁱ` term has strictly larger +@@ -3434,7 +3323,7 @@ private lemma mulByInt_y_ne_zero_of_weierstrass_lhs_ord (r : ℤ) {M : ℤ} + (congrArg (W_smooth W).ordAtInfty h_zero).trans (W_smooth W).ordAtInfty_zero + exact WithTop.top_ne_coe (h_ord_eq.symm.trans h_lhs_ord) + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- The halving lower bound `2m ≤ 3M`, where `m = ord_∞(mulByInt_y W r)` and `M = ord_∞(mulByInt_x W + r)`. If instead `2m ≥ 3M + 1`, every Weierstrass LHS term (`Y²`, `a₁·X·Y`, `a₃·Y`) would have order + `≥ 3M + 1`, so the LHS order would be `≥ 3M + 1`, contradicting `ord(LHS) = 3M`. -/ +@@ -3477,7 +3366,7 @@ private lemma two_mul_ordAtInfty_mulByInt_y_le (r : ℤ) {M m : ℤ} (hM_neg : M + have : (3 * M + 1 : ℤ) ≤ 3 * M := by exact_mod_cast h_lhs_ge + omega + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- When `m < M` and `m < 0` (which hold once `2m ≤ 3M` with `M < 0`), the term `Y²` strictly + dominates the other two Weierstrass LHS terms, so `ord_∞(Y² + a₁·X·Y + a₃·Y) = 2m`, where `m = + ord_∞(mulByInt_y W r)`. -/ +@@ -3520,6 +3409,7 @@ private lemma ordAtInfty_mulByInt_weierstrass_lhs_eq (r : ℤ) {M m : ℤ} + refine (((W_smooth W).ordAtInfty_add_eq_of_lt h_a3y_gt').trans h_inner_eq).trans ?_ + exact hY_sq_ord + ++omit [Fintype K] in + /-- **`ord_∞(mulByInt_y W r) = 3M/2`** for `r ≠ 0`, where `M = ord_∞(mulByInt_x W r)` is the + (even, `≤ -2`) `x`-order — **no** `(r : K) ≠ 0` hypothesis. The curve point + `(mulByInt_x W r, mulByInt_y W r)` satisfies the Weierstrass equation +@@ -3563,13 +3453,14 @@ theorem ordAtInfty_mulByInt_y_eq_of_x + rw [hm, h_target] + exact_mod_cast (by omega : m = 3 * M₂) + +-/-! ### D3c step 6: ord helpers for `mulByInt_y` and the y-pullbacks ++/-! ### ord helpers for `mulByInt_y` and the y-pullbacks + + To compute `ord_∞` of the pair `addPullback_x`, we need ord values for + the y-coordinate pullbacks: `ord((zsmul r π).pb y_gen) = -3q` and + `ord((mulByInt -s).pb y_gen) = -3`. These chain through + `ord(mulByInt_y W r) = -3` (curve-equation argument with x-ord = -2). -/ + ++omit [Fintype K] in + /-- **`ord_∞(mulByInt_y W r) = -3`** for `r ≠ 0` with `(r : K) ≠ 0`. + The `(mulByInt_x W r, mulByInt_y W r)` curve point has `ord(mulByInt_x) = -2`, + so the curve equation `Y² + a₁·X·Y + a₃·Y = X³ + ...` forces +@@ -3624,6 +3515,7 @@ theorem ordAtInfty_zsmul_frobenius_pullback_y_gen + push_cast + rfl + ++omit [Fintype K] in + /-- `ord_∞((mulByInt -s).pb y_gen) = -3` for `s ≠ 0` with `(s : K) ≠ 0`. + Direct from `(mulByInt -s).pb y_gen = mulByInt_y W (-s)` plus + `ordAtInfty_mulByInt_y_eq_neg_three`. -/ +@@ -3701,7 +3593,7 @@ theorem ordAtInfty_zsmul_frobenius_pullback_y_gen_of_x + rw [h_eq] + exact ((W_smooth W).ord_pow_concrete hY_ne ((3 * M) / 2) (Fintype.card K) hY_ord) + +-/-! ### D3c step 7: ord helpers for the pair differences ++/-! ### ord helpers for the pair differences + + The slope `L = (Y₁ - Y₂) / (X₁ - X₂)` requires ord of the differences: + `ord(α₁(x) - α₂(x)) = -2q` (α₁(x) dominates, ord = -2q < -2 = ord(α₂(x))), +@@ -3754,7 +3646,7 @@ theorem zsmul_frobenius_sub_mulByInt_neg_x_ne_zero + rw [ordAtInfty_zsmul_frobenius_sub_mulByInt_neg_x W r s hr hs hrK hsK] at h_top + exact WithTop.coe_ne_top h_top + +-/-! ### D3c step 8: numerator + reduced form for the pair (zsmul r π, mulByInt -s) ++/-! ### numerator + reduced form for the pair (zsmul r π, mulByInt -s) + + Mirror of `addPullbackNumerator_negFrobenius` and `_reduced` for the pair + version. The numerator is `(X₁-X₂)² · addPullback_x_pair` (cleared of the +@@ -3830,7 +3722,7 @@ private theorem weierstrass_relation_pullback (α : Isogeny W.toAffine W.toAffin + `addPullbackNumerator_negFrobenius_eq_reduced`, with both Weierstrass + equations applied via `linear_combination h_α₁ + h_α₂`. -/ + theorem addPullbackNumerator_pair_zsmul_frobenius_mulByInt_neg_eq_reduced +- (r s : ℤ) (hr : r ≠ 0) (hs : s ≠ 0) : ++ (r s : ℤ) (_hr : r ≠ 0) (_hs : s ≠ 0) : + addPullbackNumerator_pair_zsmul_frobenius_mulByInt_neg W r s = + addPullbackNumerator_reduced_pair_zsmul_frobenius_mulByInt_neg W r s := by + have h_α₁ := weierstrass_relation_pullback W ((frobeniusIsog W).zsmul r) +@@ -3885,7 +3777,7 @@ theorem addPullbackNumerator_pair_zsmul_frobenius_mulByInt_neg_eq + field_simp + ring + +-/-! ### D3c step 9: `ord(reduced_pair) = -4q - 2` ++/-! ### `ord(reduced_pair) = -4q - 2` + + Mirror of `ordAtInfty_addPullbackNumerator_reduced_negFrobenius_eq` for + the pair version. Dominant term: `α₁(x)² · α₂(x)` (ord = -4q-2). All +@@ -3914,6 +3806,7 @@ private lemma zsmul_frobenius_pullback_x_gen_ne_zero + rw [ordAtInfty_zsmul_frobenius_pullback_x_gen W r hr hrK] at h_top + exact WithTop.coe_ne_top h_top + ++omit [Fintype K] in + /-- `(mulByInt -s).pb y_gen ≠ 0` for `s ≠ 0` with `(s : K) ≠ 0`. -/ + private lemma mulByInt_neg_pullback_y_gen_ne_zero + (s : ℤ) (hs : s ≠ 0) (hsK : (s : K) ≠ 0) : +@@ -3925,6 +3818,7 @@ private lemma mulByInt_neg_pullback_y_gen_ne_zero + rw [ordAtInfty_mulByInt_neg_pullback_y_gen W s hs hsK] at h_top + exact WithTop.coe_ne_top h_top + ++omit [Fintype K] in + /-- `(mulByInt -s).pb x_gen ≠ 0` for `s ≠ 0` with `(s : K) ≠ 0`. -/ + private lemma mulByInt_neg_pullback_x_gen_ne_zero + (s : ℤ) (hs : s ≠ 0) (hsK : (s : K) ≠ 0) : +@@ -4120,6 +4014,7 @@ private lemma ord_zsmul_frobenius_mulByInt_neg_rest_term_a₄_ge + exact_mod_cast (by linarith : + (-3 * (Fintype.card K : ℤ) - 3 : ℤ) ≤ -2 * (Fintype.card K : ℤ)) + ++omit [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Rest term 2: `ord(2 · a₆) ≥ -3q - 3`. The constant `a₆` has order `≥ 0` (or `⊤` if + zero), which clears `-3q - 3`; `ord_two_mul_ge` handles the `2·` factor in any + characteristic. -/ +@@ -4385,7 +4280,7 @@ theorem ord_addPullback_x_pair_zsmul_frobenius_mulByInt_neg + (-4 * (Fintype.card K : ℤ)) h_num_ord h_den_ord).trans ?_ + congr 1; ring + +-/-! ### D3c: the `y`-coordinate `∞`-order for the pair `(zsmul r π, mulByInt -s)` ++/-! ### the `y`-coordinate `∞`-order for the pair `(zsmul r π, mulByInt -s)` + + The pair analogue of `ord_addPullback_y_negFrobenius = -3`. The proof is the *same* + Weierstrass-equation argument: from `ord_∞(addPullback_x_pair) = -2` and the curve equation +@@ -4400,7 +4295,7 @@ private theorem ord_addPullback_x_sq_pair_zsmul_frobenius_mulByInt_neg + (W_smooth W).ordAtInfty + (addPullback_x_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) ^ 2) = + ((-4 : ℤ) : WithTop ℤ) := by +- haveI : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic ++ have : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic + have hX_ne : addPullback_x_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) ≠ 0 := + fun h ↦ WithTop.coe_ne_top + (((W_smooth W).ordAtInfty_eq_top_iff _).mpr h ▸ +@@ -4415,7 +4310,7 @@ private theorem ord_addPullback_x_cube_pair_zsmul_frobenius_mulByInt_neg + (W_smooth W).ordAtInfty + (addPullback_x_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) ^ 3) = + ((-6 : ℤ) : WithTop ℤ) := by +- haveI : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic ++ have : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic + have hX_ne : addPullback_x_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) ≠ 0 := + fun h ↦ WithTop.coe_ne_top + (((W_smooth W).ordAtInfty_eq_top_iff _).mpr h ▸ +@@ -4435,7 +4330,7 @@ private theorem ord_RHS_pair_zsmul_frobenius_mulByInt_neg + addPullback_x_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) + + algebraMap K KE W.toAffine.a₆) = + ((-6 : ℤ) : WithTop ℤ) := by +- haveI : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic ++ have : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic + set X := addPullback_x_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) with hX + have h_X3 : (W_smooth W).ordAtInfty (X ^ 3) = ((-6 : ℤ) : WithTop ℤ) := + ord_addPullback_x_cube_pair_zsmul_frobenius_mulByInt_neg W r s hr hs hrK hsK +@@ -4525,7 +4420,7 @@ private theorem addPullback_y_pair_zsmul_frobenius_mulByInt_neg_ne_zero + (h_ord_eq.symm.trans + (ord_weierstrass_lhs_pair_zsmul_frobenius_mulByInt_neg W r s hr hs hrK hsK)) + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Order-arithmetic helper (step (a)): if `ord(LHS) = -6`, the y-order `m` of the Weierstrass LHS + satisfies `m ≤ -3`. Otherwise all three summands would have order `≥ -4`, forcing `ord(LHS) ≥ -4`, + contradicting `-6`. Purely generic in `X`, `Y`, `m` and the per-term order data. -/ +@@ -4558,7 +4453,7 @@ private theorem ord_y_le_neg_three_of_weierstrass_lhs_ord {X Y : KE} {m : ℤ} + have h46 : (-4 : ℤ) ≤ -6 := by exact_mod_cast h_lhs_ge + omega + +-omit [Fintype K] in ++omit [Fintype K] [WeierstrassCurve.IsElliptic W.toAffine] in + /-- Order-arithmetic helper (step (b)): when `m ≤ -3`, the `Y²` term strictly dominates both the + `a₁·X·Y` and `a₃·Y` terms (`2m < -2 + m` and `2m < m`), so the order of the Weierstrass LHS equals + `ord(Y²)`. Purely generic in `X`, `Y`, `m` and the per-term order data. -/ +@@ -4603,7 +4498,7 @@ theorem ord_addPullback_y_pair_zsmul_frobenius_mulByInt_neg + (W_smooth W).ordAtInfty + ((addPullback_y_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s))) : KE) = + ((-3 : ℤ) : WithTop ℤ) := by +- haveI : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic ++ have : (W_smooth W).toAffine.IsElliptic := inferInstanceAs W.toAffine.IsElliptic + set X := addPullback_x_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) with hX + set Y := addPullback_y_pair ((frobeniusIsog W).zsmul r) (mulByInt W.toAffine (-s)) with hY + have hX_ne : X ≠ 0 := +@@ -4633,21 +4528,13 @@ theorem ord_addPullback_y_pair_zsmul_frobenius_mulByInt_neg + have h_2m : (2 * m : ℤ) = -6 := by exact_mod_cast h_lhs_ord + rw [hm]; exact_mod_cast (by omega : m = -3) + +-/-! ### D4: pole-bound-parametric `genuineIsogSmulSub` ++/-! ### The pencil `r·π − s·id` + +-Worker D consumes `genuineIsogSmulSub r s` for the genuine `r·π - s·id` +-isogeny. The constructor needs: +-1. The `AddNonInversePair` witness — shipped axiom-clean as +- `AddNonInversePair_zsmul_frobenius_mulByInt_neg`. +-2. `addCoordAlgHomPair`-injectivity — reducible (via base-hom + transcendence +- chain) to a pole bound `ord_∞ < 0` on the pair pullback x-coord. +- +-We ship the **pole-bound-parametric** form. The pole bound discharges +-axiom-clean via the same numerator/denominator/Weierstrass-reduction +-chain as `ord_addPullback_x_negFrobenius` (the (1,1) base case here), +-mirrored to the pair version with α₁(x)²·α₂(x) as the dominant term +-(ord = -4q-2). Worker D supplies the pole bound (or waits for the +-follow-up axiom-clean discharge). -/ ++Different coordinate orders provide the non-inverse-pair witness. ++A pole of the summed x-coordinate gives polynomial and coordinate-ring ++injectivity through curve-negation invariance and its `K(x)` image. ++These facts construct the pencil isogeny's function-field pullback. ++-/ + + /-- **Witness-parametric base-hom injectivity** for the + `(zsmul r π, mulByInt -s)` family: takes the pole bound hypothesis +@@ -4713,17 +4600,9 @@ theorem addCoordAlgHomPair_injective_zsmul_frobenius_mulByInt_neg_of_pole + (addBaseHomPair_injective_zsmul_frobenius_mulByInt_neg_of_pole + W r s hr hs hrK hsK h_pole) + +-/-- **D4: genuine `r·π - s·id` isogeny constructor (pole-bound-parametric)**. +- +-The genuine `r·π - s·id` isogeny with the *real* function-field pullback +-(replacing the `AlgHom.id` placeholder of `Endomorphism.lean`'s +-`isogSmulSub`). On rational points equals +-`(zsmul r π).toAddMonoidHom + (mulByInt -s).toAddMonoidHom`. +- +-Worker D in `DegreeQuadraticForm.lean` consumes this as the `r·π - s·id` +-isogeny family. The pole bound discharges axiom-clean via the same +-numerator chain as `ord_addPullback_x_negFrobenius` (the (1,1) base +-case), mirrored to the pair version. -/ ++/-- The isogeny `r·π − s·id`, given the pole of its addition x-coordinate. ++ Its function-field pullback comes from the addition formulas, and its ++ point map is `(r·π) + (−s·id)`. -/ + noncomputable def genuineIsogSmulSub_of_pole + (r s : ℤ) (hr : r ≠ 0) (hs : s ≠ 0) + (hrK : (r : K) ≠ 0) (hsK : (s : K) ≠ 0) +@@ -4747,12 +4626,11 @@ noncomputable def genuineIsogSmulSub_of_pole + (mulByInt W.toAffine (-s)).toAddMonoidHom := + rfl + +-/-! ### D4 unconditional: `genuineIsogSmulSub` ++/-! ### Constructing the pencil from its coordinate pole + +-With `ord_addPullback_x_pair_zsmul_frobenius_mulByInt_neg = -2 < 0` +-discharged axiom-clean, the witness-parametric `genuineIsogSmulSub_of_pole` +-becomes unconditional. The unconditional form is what Worker D consumes +-in `DegreeQuadraticForm.lean` for the polarisation. -/ ++The addition x-coordinate has order `−2`, hence a pole. This supplies ++the injectivity witness for the function-field pullback of `r·π − s·id`. ++-/ + + /-- The pole bound `ord_∞ < 0` discharges from + `ord_addPullback_x_pair_zsmul_frobenius_mulByInt_neg = -2`. -/ +@@ -4765,11 +4643,9 @@ private theorem h_pole_discharge + rw [ord_addPullback_x_pair_zsmul_frobenius_mulByInt_neg W r s hr hs hrK hsK] + exact_mod_cast (by norm_num : (-2 : ℤ) < 0) + +-/-- **D4 (unconditional)**: the genuine `r·π - s·id` isogeny for +-`r, s ≠ 0` with `(r : K), (s : K) ≠ 0`. Pullback is the *real* +-function-field pullback; on rational points equals +-`r · π + (-s) · id = r · π - s · id`. Worker D in +-`DegreeQuadraticForm.lean` consumes this directly. -/ ++/-- The isogeny `r·π − s·id` when the two integers and their base-field ++ images are nonzero. Its pullback is the addition-formula pullback, ++ and its point map is `r·π − s·id`. -/ + noncomputable def genuineIsogSmulSub + (r s : ℤ) (hr : r ≠ 0) (hs : s ≠ 0) + (hrK : (r : K) ≠ 0) (hsK : (s : K) ≠ 0) : +@@ -4785,7 +4661,7 @@ noncomputable def genuineIsogSmulSub + (mulByInt W.toAffine (-s)).toAddMonoidHom := + rfl + +-/-! ### D4 inseparable: the `p ∣ r` pole bound `ord_∞(addPullback_x_pair) = -2` ++/-! ### Inseparable pencil: the `p ∣ r` pole bound `ord_∞(addPullback_x_pair) = -2` + + For the **inseparable** pencil summand `r·π` (when `p ∣ r`, so `(r : K) = 0`), the `x`-pole of + `α₁ = (frobeniusIsog).zsmul r` is `ord_∞(α₁^* x_gen) = q·M` with +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/FunctionField.lean b/projects/HasseWeil/HasseWeil/Isogeny/FunctionField.lean +index 390492635..fba307a06 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/FunctionField.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/FunctionField.lean +@@ -7,30 +7,6 @@ import Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point + import Mathlib.LinearAlgebra.Dimension.Finrank + import Mathlib.LinearAlgebra.Basis.VectorSpace + +-/-! +-# Isogenies via Function Field Extensions +- +-We define isogenies between elliptic curves as injective `K`-algebra homomorphisms +-on function fields, following Silverman III.4. The degree of an isogeny is the degree +-of the corresponding field extension. +- +-## Main Definitions +- +-* `HasseWeil.Isogeny`: An isogeny from `E₁` to `E₂`, represented as an injective +- `K`-algebra homomorphism `K(E₂) →ₐ[K] K(E₁)` on function fields. +-* `HasseWeil.Isogeny.degree`: The degree `[K(E₁) : φ*K(E₂)]`. +- +-## Design Note +- +-The degree is defined as `Module.finrank K(E₂) K(E₁)` where `K(E₁)` is given a +-`K(E₂)`-algebra structure via the pullback `φ* : K(E₂) →ₐ[F] K(E₁)`. This avoids +-working with subalgebra ranges and makes the tower law (degree multiplicativity) +-a direct application of `Module.finrank_mul_finrank`. +- +-## References +- +-* [Silverman, *The Arithmetic of Elliptic Curves*], III.4 +--/ + + open WeierstrassCurve Polynomial + +@@ -49,8 +25,7 @@ namespace PullbackIsogeny + variable {F : Type*} [Field F] + variable {W₁ W₂ W₃ : Affine F} [W₁.IsElliptic] [W₂.IsElliptic] [W₃.IsElliptic] + +-/-- The pullback of an isogeny is injective: any algebra homomorphism from a field +- is injective because the kernel of a ring homomorphism from a field is trivial. -/ ++ + theorem pullback_injective (φ : PullbackIsogeny F W₁ W₂) : + Function.Injective φ.pullback := + φ.pullback.toRingHom.injective +@@ -61,8 +36,7 @@ noncomputable def toAlgebra (φ : PullbackIsogeny F W₁ W₂) : + Algebra W₂.FunctionField W₁.FunctionField := + φ.pullback.toRingHom.toAlgebra + +-/-- The degree of an isogeny, defined as `[K(E₁) : K(E₂)]` where `K(E₁)` is +- a `K(E₂)`-module via the pullback. -/ ++ + noncomputable def degree (φ : PullbackIsogeny F W₁ W₂) : ℕ := + @Module.finrank W₂.FunctionField W₁.FunctionField _ _ φ.toAlgebra.toModule + +@@ -81,12 +55,12 @@ theorem comp_algebraMap_eq (ψ : PullbackIsogeny F W₂ W₃) (φ : PullbackIsog + theorem comp_degree (ψ : PullbackIsogeny F W₂ W₃) (φ : PullbackIsogeny F W₁ W₂) : + (ψ.comp φ).degree = φ.degree * ψ.degree := by + simp only [degree] +- letI inst₁ : Algebra W₂.FunctionField W₁.FunctionField := φ.toAlgebra +- letI inst₂ : Algebra W₃.FunctionField W₂.FunctionField := ψ.toAlgebra +- letI inst₃ : Algebra W₃.FunctionField W₁.FunctionField := (ψ.comp φ).toAlgebra +- haveI : IsScalarTower W₃.FunctionField W₂.FunctionField W₁.FunctionField := ++ let inst₁ : Algebra W₂.FunctionField W₁.FunctionField := φ.toAlgebra ++ let inst₂ : Algebra W₃.FunctionField W₂.FunctionField := ψ.toAlgebra ++ let inst₃ : Algebra W₃.FunctionField W₁.FunctionField := (ψ.comp φ).toAlgebra ++ have : IsScalarTower W₃.FunctionField W₂.FunctionField W₁.FunctionField := + IsScalarTower.of_algebraMap_eq fun x => rfl +- haveI : Module.Free W₂.FunctionField W₁.FunctionField := ++ have : Module.Free W₂.FunctionField W₁.FunctionField := + Module.Free.of_divisionRing _ _ + rw [mul_comm] + exact (Module.finrank_mul_finrank +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/GroupHom/PicZero.lean b/projects/HasseWeil/HasseWeil/Isogeny/GroupHom/PicZero.lean +index 1b98e70eec533a4bac61cd0a445abb7372a63eea..603d41e1f0ecdaf549903d24babfdd67af8baf36 100644 +GIT binary patch +delta 1063 +zcmaKr&x#X45XO;}tTYJXNkOGBxBnCWi2d$O*V=*_F< +z0mL^5Nnq?e||E*d~UkuOl_es6@Sha9z!S)C`TQ*wF|cP +z#mKnBsA{yxc);@Abe;iuP^Pjn(6B@}q)?>JyF)COZ)cCBGDCt&TFAbB$@;Kg)V`6{ +zd95%{Pb}zIz-U>5HKc=&vJ%Gs*oy*bibn5yQ!AaUFgP~A%T;xmRD{DINqfN8wj@QN +zJW3-cQj;&DH+CNFx!*$1f&&NS&G%OXZKAkNj)~NYHsts$3;@-Kzf4C +zBdptRW9$p@3`gitE4&4>$DRJ{P3PNw8sCfKV@|w6lkPn0LXKXc&N-)a)^-@wesv;I +z99hF&JO>sE8ImuSntj-S#m~*bg@eJ`Gj}@T_a&t9hlEk`MQ$;>&ERUc+ukc +z*EY?O+mmNogKb#8{|H-8x3k6Gl}{VfNLC`Qck+kgTN{gxeZ}SDlCh3f^fsdLY!TQz +zr$7^a9ko~-qvfH&FaAA$5NpdKVzX=4Z$9ioq=@e+)}dha7Oh~?jn@fVfy0g9P3;se +J&fhq=_!|#HjPn2h + +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/Kernel.lean b/projects/HasseWeil/HasseWeil/Isogeny/Kernel.lean +index 2b2b0f7f5..f46fb56a6 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/Kernel.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/Kernel.lean +@@ -7,36 +7,6 @@ import HasseWeil.Foundation.Basic + import Mathlib.FieldTheory.Galois.Basic + import Mathlib.FieldTheory.SeparableDegree + +-/-! +-# Kernel of an Isogeny +- +-For an isogeny `φ : E₁ → E₂`, we collect the structural facts about `ker φ` +-as an `AddSubgroup` of `E₁.Point`. These are foundational for the dual +-isogeny construction (Silverman III.6) and the Hasse bound (V.1). +- +-## Main definitions +- +-* `Isogeny.kernel φ` — the kernel of `φ.toAddMonoidHom`, viewed as an +- `AddSubgroup` of `W₁.Point`. A thin wrapper around `AddMonoidHom.ker`. +-* `Isogeny.IsSeparable φ` — separability of the induced field extension. +- +-## Deep results (not yet proved) +- +-The following correspond to tickets `T-III-4-011/012/015`; they require +-substantial infrastructure (finiteness of fibers for finite morphisms of +-smooth curves, and the Galois theory of `K(E₁)/φ*K(E₂)`) and are deferred. +- +-* **Silverman III.4.10(a)** — nonzero isogeny has finite kernel. +-* **Silverman III.4.10(b)** — `#ker φ ≤ deg_s φ ≤ deg φ`. +-* **Silverman III.4.10(c)** — equality when `φ` is separable. +- +-Once available, these unblock the dual isogeny chain (T-III-6-001 etc.). +- +-## References +- +-* [J Silverman, *The Arithmetic of Elliptic Curves*][silverman2009], III.4.10. +- +--/ + + open WeierstrassCurve + +@@ -47,7 +17,7 @@ variable {W₁ W₂ : Affine F} [W₁.IsElliptic] [W₂.IsElliptic] + + namespace Isogeny + +-/-- The kernel of an isogeny `φ`, as an `AddSubgroup` of `W₁.Point`. -/ ++ + noncomputable def kernel (φ : Isogeny W₁ W₂) : AddSubgroup W₁.Point := + φ.toAddMonoidHom.ker + +@@ -58,25 +28,20 @@ noncomputable def kernel (φ : Isogeny W₁ W₂) : AddSubgroup W₁.Point := + @[simp] theorem zero_mem_kernel (φ : Isogeny W₁ W₂) : (0 : W₁.Point) ∈ φ.kernel := + (φ.kernel).zero_mem + +-/-- The kernel is preserved by composition (fiberwise): `ker φ ⊆ ker (ψ ∘ φ)`. -/ ++ + theorem kernel_comp_le {W₃ : Affine F} [W₃.IsElliptic] (ψ : Isogeny W₂ W₃) + (φ : Isogeny W₁ W₂) : φ.kernel ≤ (ψ.comp φ).kernel := by + intro P hP + simp only [mem_kernel_iff, comp_apply] at hP ⊢ + rw [hP, map_zero] + +-/-- **T-III-4-011 witness form**: If the fiber `φ⁻¹({0})` (as a subtype +- of `W₁.Point`) is finite, then `φ.kernel` is a finite additive subgroup. + +- The hypothesis `h_fiber` is a specific case of T-II-2-002 (finite fibers +- for nonconstant morphisms of smooth curves) applied to the fiber over `0`. +- Full unconditional version awaits that foundational curve-theory result. -/ + theorem kernel_finite_of_fiber_finite (φ : Isogeny W₁ W₂) + (h_fiber : Finite {P : W₁.Point // φ.toAddMonoidHom P = 0}) : + Finite φ.kernel := + Finite.of_equiv _ (Equiv.subtypeEquivRight (mem_kernel_iff φ)).symm + +-/-- `ker [1] = ⊥` (trivial kernel, since [1] is the identity on points). -/ ++ + @[simp] theorem kernel_mulByInt_one {W : WeierstrassCurve F} [W.toAffine.IsElliptic] : + (mulByInt W.toAffine 1).kernel = ⊥ := by + ext P +@@ -108,8 +73,7 @@ theorem mem_kernel_comp_of_mem_kernel {W₃ : Affine F} [W₃.IsElliptic] + (hP : P ∈ φ.kernel) : P ∈ (ψ.comp φ).kernel := + kernel_comp_le ψ φ hP + +-/-- If `ψ` has trivial kernel, `ker (ψ ∘ φ) = ker φ`: applying a "monomorphic" +- post-composition doesn't enlarge the kernel. -/ ++ + theorem kernel_comp_of_kernel_eq_bot {W₃ : Affine F} [W₃.IsElliptic] + {ψ : Isogeny W₂ W₃} (hψ : ψ.kernel = ⊥) (φ : Isogeny W₁ W₂) : + (ψ.comp φ).kernel = φ.kernel := by +@@ -123,9 +87,7 @@ theorem kernel_comp_of_kernel_eq_bot {W₃ : Affine F} [W₃.IsElliptic] + · intro h + rw [h, map_zero] + +-/-- **Kernel finiteness over finite fields (unconditional)**: when `W₁.Point` +- is finite (e.g., for an elliptic curve over a finite field), every kernel +- is automatically finite. -/ ++ + instance kernel_finite_of_point_finite [Finite W₁.Point] (φ : Isogeny W₁ W₂) : + Finite φ.kernel := + inferInstance +@@ -135,15 +97,12 @@ theorem kernel_card_le_point_card [Finite W₁.Point] (φ : Isogeny W₁ W₂) : + Nat.card φ.kernel ≤ Nat.card W₁.Point := + Nat.card_le_card_of_injective _ (Subtype.val_injective) + +-/-- **Lagrange for kernel**: over a finite field, `#ker φ ∣ #W₁.Point` +- (subgroup cardinality divides group cardinality). -/ ++ + theorem kernel_card_dvd_point_card [Finite W₁.Point] (φ : Isogeny W₁ W₂) : + Nat.card φ.kernel ∣ Nat.card W₁.Point := + AddSubgroup.card_addSubgroup_dvd_card φ.kernel + +-/-- **Kernel of sum** (for AddSubgroup inclusion): `ker φ ∩ ker ψ ≤ ker (φ + ψ)`, +- where `(φ + ψ)` is a hypothetical isogeny with summed action. +- (Purely algebraic: if φ(P) = 0 and ψ(P) = 0, then φ(P) + ψ(P) = 0.) -/ ++ + theorem kernel_inf_le_kernel_of_sum (φ ψ : Isogeny W₁ W₂) + (σ : Isogeny W₁ W₂) (hσ : σ.toAddMonoidHom = φ.toAddMonoidHom + ψ.toAddMonoidHom) : + φ.kernel ⊓ ψ.kernel ≤ σ.kernel := by +@@ -151,7 +110,7 @@ theorem kernel_inf_le_kernel_of_sum (φ ψ : Isogeny W₁ W₂) + simp only [AddSubgroup.mem_inf, mem_kernel_iff] at hP + simp only [mem_kernel_iff, hσ, AddMonoidHom.add_apply, hP.1, hP.2, add_zero] + +-/-- An isogeny has trivial kernel iff its toAddMonoidHom is injective. -/ ++ + theorem kernel_eq_bot_iff_injective (φ : Isogeny W₁ W₂) : + φ.kernel = ⊥ ↔ Function.Injective φ.toAddMonoidHom := + AddMonoidHom.ker_eq_bot_iff φ.toAddMonoidHom +@@ -161,23 +120,20 @@ theorem id_toAddMonoidHom_injective : + Function.Injective (Isogeny.id W₁).toAddMonoidHom := + Function.injective_id + +-/-- `ker (ψ ∘ φ) = φ⁻¹(ker ψ)` (as an AddSubgroup): the kernel of a composition +- is the preimage of the outer kernel. -/ ++ + theorem kernel_comp_eq_comap {W₃ : Affine F} [W₃.IsElliptic] + (ψ : Isogeny W₂ W₃) (φ : Isogeny W₁ W₂) : + (ψ.comp φ).kernel = ψ.kernel.comap φ.toAddMonoidHom := by + ext P + simp [mem_kernel_iff] + +-/-- For a nonzero isogeny with finite kernel, the action of the kernel on +- any nonempty fiber is transitive. I.e., `φ⁻¹(Q) = P₀ + ker φ` as sets +- (when `φ(P₀) = Q`). -/ ++ + theorem fiber_eq_coset (φ : Isogeny W₁ W₂) + {P₀ : W₁.Point} {Q : W₂.Point} (hP₀ : φ.toAddMonoidHom P₀ = Q) : + {P : W₁.Point | φ.toAddMonoidHom P = Q} = + {P : W₁.Point | ∃ T ∈ φ.kernel, P = P₀ + T} := by + ext P +- simp only [Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq] + constructor + · intro hP + refine ⟨P - P₀, ?_, by abel⟩ +@@ -193,10 +149,7 @@ theorem mem_fiber_iff_sub_mem_kernel (φ : Isogeny W₁ W₂) + φ.toAddMonoidHom P = Q ↔ P - P₀ ∈ φ.kernel := by + rw [mem_kernel_iff, map_sub, hP₀, sub_eq_zero] + +-/-- **Fiber cardinality = kernel cardinality** (via coset structure): the +- fiber `φ⁻¹(Q)` of a nonempty fiber (with `P₀ ∈ φ⁻¹(Q)`) has the same +- cardinality as `ker φ`. This is the group-theoretic content of the +- fiber-cardinality formula (before invoking any ramification theory). -/ ++ + noncomputable def fiberEquivKernel (φ : Isogeny W₁ W₂) + {P₀ : W₁.Point} {Q : W₂.Point} (hP₀ : φ.toAddMonoidHom P₀ = Q) : + {P : W₁.Point // φ.toAddMonoidHom P = Q} ≃ φ.kernel where +@@ -213,12 +166,11 @@ theorem fiber_finite_of_kernel_finite (φ : Isogeny W₁ W₂) + Finite {P : W₁.Point // φ.toAddMonoidHom P = Q} := by + rcases Classical.em (∃ P₀, φ.toAddMonoidHom P₀ = Q) with ⟨P₀, hP₀⟩ | h_empty + · exact Finite.of_equiv _ (fiberEquivKernel φ hP₀).symm +- · haveI : IsEmpty {P : W₁.Point // φ.toAddMonoidHom P = Q} := ++ · have : IsEmpty {P : W₁.Point // φ.toAddMonoidHom P = Q} := + ⟨fun ⟨P, hP⟩ ↦ h_empty ⟨P, hP⟩⟩ + infer_instance + +-/-- **Bijection of nonempty fibers**: any two nonempty fibers of `φ` are in +- bijection. (They're both cosets of the kernel, hence have the same size.) -/ ++ + noncomputable def fiberEquivFiber (φ : Isogeny W₁ W₂) + {P₀ : W₁.Point} {Q : W₂.Point} (hP₀ : φ.toAddMonoidHom P₀ = Q) + {P₁ : W₁.Point} {Q' : W₂.Point} (hP₁ : φ.toAddMonoidHom P₁ = Q') : +@@ -226,21 +178,12 @@ noncomputable def fiberEquivFiber (φ : Isogeny W₁ W₂) + {P : W₁.Point // φ.toAddMonoidHom P = Q'} := + (fiberEquivKernel φ hP₀).trans (fiberEquivKernel φ hP₁).symm + +-/-- **T-III-4-015 step 1** (kernel-as-fiber-over-zero): the kernel of an +- isogeny is in canonical bijection with the fiber over the identity point. +- Direct specialization of `fiberEquivKernel` to `Q = 0` (image of `P₀ = 0`). + +- This is the foundational set-theoretic identification: `φ.kernel ≃ φ⁻¹(0)`. +- Combined with `fiber_card_eq_kernel_card` (which generalizes to any `Q` in +- image), this gives the standard isogeny-fiber result that connects the +- kernel cardinality to the fiber structure. -/ + noncomputable def kernel_equiv_fiber_zero (φ : Isogeny W₁ W₂) : + φ.kernel ≃ {P : W₁.Point // φ.toAddMonoidHom P = 0} := + (fiberEquivKernel φ (by simp : φ.toAddMonoidHom 0 = 0)).symm + +-/-- **Corollary** (kernel-cardinality = fiber-zero-cardinality): when the kernel +- is finite, the cardinality of the fiber over zero equals the cardinality of +- the kernel. Direct from `kernel_equiv_fiber_zero`. -/ ++ + theorem kernel_card_eq_fiber_zero_card (φ : Isogeny W₁ W₂) + [Finite φ.kernel] : + Nat.card φ.kernel = Nat.card {P : W₁.Point // φ.toAddMonoidHom P = 0} := +@@ -253,7 +196,7 @@ theorem fiber_card_eq_kernel_card (φ : Isogeny W₁ W₂) + Nat.card {P : W₁.Point // φ.toAddMonoidHom P = Q} = Nat.card φ.kernel := + Nat.card_congr (fiberEquivKernel φ hP₀) + +-/-- The kernel of the identity isogeny is trivial. -/ ++ + @[simp] theorem kernel_id : (Isogeny.id W₁).kernel = ⊥ := by + ext P + simp [mem_kernel_iff, id_toAddMonoidHom] +@@ -308,15 +251,7 @@ theorem fiber_card_eq_sepDegree_of_witness (φ : Isogeny W₁ W₂) + rw [← fiber_card_eq_kernel_card φ rfl (P₀ := P₀_wit)] + exact h_wit + +-/-- **Hasse-bound shortcut**: if `|ker φ| = φ.sepDegree` (a finite-field +- fact that can be proved directly without going through the generic +- II.2.6(b) fiber-size theorem), then the fiber over `φ(0)` (i.e. the +- kernel) provides the fiber witness used by the historical witness-parametric +- Hasse-bound route. + +- Reduces T-II-2-009's "existential fiber-size = sepDegree" witness to the +- simpler `|ker| = sepDegree` fact, which is directly accessible for +- separable isogenies over finite fields via the V.1 chain. -/ + theorem fiber_witness_of_ker_card_eq_sepDegree (φ : Isogeny W₁ W₂) + [Finite φ.kernel] + (h_ker_sep : Nat.card φ.kernel = φ.sepDegree) : +@@ -327,13 +262,7 @@ theorem fiber_witness_of_ker_card_eq_sepDegree (φ : Isogeny W₁ W₂) + rw [fiber_card_eq_kernel_card φ (P₀ := 0) (Q := φ.toAddMonoidHom 0) rfl, + h_ker_sep] + +-/-- **T-III-4-015 step 2 closer** (witness-parametric): given a witness that +-the fiber over zero has cardinality `φ.sepDegree`, the kernel cardinality +-equals `φ.sepDegree`. Direct from `kernel_card_eq_fiber_zero_card`. + +-The witness `h_fiber_card_zero` is the SUBSTANTIVE content of Silverman +-III.4.10/12 specialized to fiber over zero: for separable isogenies, every +-fiber has cardinality = sepDegree. -/ + theorem kernel_card_eq_sepDegree_of_fiber_zero_witness (φ : Isogeny W₁ W₂) + [h_ker : Finite φ.kernel] + (h_fiber_card_zero : +@@ -341,9 +270,7 @@ theorem kernel_card_eq_sepDegree_of_fiber_zero_witness (φ : Isogeny W₁ W₂) + Nat.card φ.kernel = φ.sepDegree := by + rw [kernel_card_eq_fiber_zero_card φ, h_fiber_card_zero] + +-/-- **T-III-4-015 witness form for separable isogenies**: If `φ` is +- separable and has a finite kernel, and at least one fiber has +- cardinality = `sepDegree`, then `#ker φ = deg φ`. -/ ++ + theorem card_kernel_eq_degree_of_separable_witness (φ : Isogeny W₁ W₂) + [h_ker : Finite φ.kernel] (hsep : φ.IsSeparable) + (hfin : @FiniteDimensional W₂.FunctionField W₁.FunctionField _ _ +@@ -385,16 +312,7 @@ theorem sepDegree_eq_card_emb (φ : Isogeny W₁ W₂) : + AlgebraicClosure W₁.FunctionField) := + rfl + +-/-- **R2 reduction brick** (Silverman III.4.10c, embeddings half): for a +-separable, finite-dimensional isogeny `φ`, if the **embedding count equals the +-kernel count** — `φ.sepDegree = #ker φ`, i.e. +-`#(K(E₁) →ₐ[φ*K(E₂)] Ω) = #ker φ` — then `#ker φ = deg φ`. + +-This is the clean compositional consumer for the embeddings-classification +-route: `#ker φ = sepDegree φ` (hypothesis) `= deg φ` (separability, via +-`isSeparable_iff_sepDegree_eq_degree`). The substantive content is delegated +-to the hypothesis `h_count`, which is exactly the embedding↔kernel bijection +-`Emb ≃ ker φ`. -/ + theorem card_kernel_eq_degree_of_sepDegree_eq_card_kernel (φ : Isogeny W₁ W₂) + (hsep : φ.IsSeparable) + (hfin : @FiniteDimensional W₂.FunctionField W₁.FunctionField _ _ +@@ -491,9 +409,9 @@ theorem card_aut_eq_degree_of_isGalois (φ : Isogeny W₁ W₂) + (hgal : @IsGalois W₂.FunctionField _ W₁.FunctionField _ φ.toAlgebra) : + Nat.card (@AlgEquiv W₂.FunctionField W₁.FunctionField W₁.FunctionField _ _ _ + φ.toAlgebra φ.toAlgebra) = φ.degree := by +- letI := φ.toAlgebra +- haveI := hfin +- haveI := hgal ++ let := φ.toAlgebra ++ have := hfin ++ have := hgal + exact IsGalois.card_aut_eq_finrank W₂.FunctionField W₁.FunctionField + + /-- **T-III-4-015 step 4** (IsGalois from Separable + Normal): given the +@@ -510,7 +428,7 @@ theorem isGalois_of_separable_and_normal (φ : Isogeny W₁ W₂) + (h_normal : letI := φ.toAlgebra + Normal W₂.FunctionField W₁.FunctionField) : + @IsGalois W₂.FunctionField _ W₁.FunctionField _ φ.toAlgebra := by +- letI := φ.toAlgebra ++ let := φ.toAlgebra + exact isGalois_iff.mpr ⟨h_sep, h_normal⟩ + + /-- **T-III-4-015 step 4b** (IsGalois from Isogeny.IsSeparable + Normal): +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/OmegaCoeffViaFormalGroup.lean b/projects/HasseWeil/HasseWeil/Isogeny/OmegaCoeffViaFormalGroup.lean +index b4f3c844a3d84552f61642e618d4c4c2e3ea997f..ee9bf1a49bf89477daa167de9f0698966a7944f9 100644 +GIT binary patch +delta 6076 +zcmaJ_3v?9K89x7pfD9!Vfq;T=Av}_hT?h~L1ffMFCGrXq6h+KVcJJnV~qaRa|Lk=&EPeaL;?f429`E^~RjYaDxGP0r(Bd=1)Q$58kDx<436OCh$K%21hNRMJ= +z?Bz>goPBo()Lce-GE@@^@zpdL1UDVL1%3UP@tWY&c5L>yZ +zm639K4??!t`z5a>1gg-exP-ePNz(?UB%X^CR1;N1eE1RpA@G-@kxam!6u^lwaBAzevDtR^VR +zUksy0($J3E78q#DEJcHGRTrtMlH<<{^9Ekp&`4TaTVrzstT61FPV}+aPFgyz;#$7f +zL+|M~`|)5Rrp;6@iLdRN*0ipph0G%@b!)rusc|iTuRlvnw=;d%r~==%t}QMuj^qDm +z2JfJ@cueAV2f+|v2|ZvYsFp4-;kRzM@2y=dASD0-}$698%%*HdkL#VWxwcwh^H +zGTwy}HpPX5E!pRfPK?4tro=87*il782b+|bD!Pr7LVT`p1s-$a&YfhYcThN1yf8>| +z@F9HIgm;Fs&nHx|r>+?0JYT(R!1-LOoU9lnAX^!#8#L=Q)Vx$#ST0BlVa&1K4`(5H +z-~p$hz~eEDOtHb|voEDH-)a&!_!`gt9LuV0cEEXU_!Vh};}SuQ;+3&S(G><=pH~cO +zO7ScjV;h+fj}dNSk9SdpAOkeA*T+w&5jf%j%T<#C$FdlysT9~}Rdr)mqYi$IaRG#` +zUi9<8meCz4T~+lSlc2jjTt-FeDOt0h46^+nBqCX~gRbvTY06^%ocLk*_0P4&h2F1* +zlFnEpqpg#q>Cq@z;2E@$bLD8+Gm1zHXETX}BAxD=gsf>g9;zdSa6;4bmN4m=$%DZoLZyH(fk`6kjh+<5F$TFd{ +z$5|>!u+0+YUv9puse*KY>D)wY%2*0`iAQY4Xi5b>4>n?c6(Qam&B>VkF}rkANzWC8 +z8#qHCVT&>bVJ`rL|0SpzBYw)oC4Qk24o;7JG8kZ($0dvrx`EeQid7bTJa|xM +z>vgA9QdmyJ2znLcVFIbGtqrnW-t>s5n6CR3hg*tMQX|0%BSD3M8_^ijm)h4WZvsPk +z)te|dXw=KZXybeq^A{pnF|o{}Nx$OYjwnf_m^xO6y+p8Mpan$P(FZ25lMghrO$X;N +zi|wwA%NMw8XDNW4{YZtbfX?HeRwxAz%lHLqidyX<7AnoWJ^5w0iU~a_n%XJw +zj}mwc^0*MSDR(|@4oE9iR^f_9t8fNo_#O^{y^;5L0Y6G-@+0?*AHE5!#CW01CGcXH +zvtzOF4I%=qvsPQjGnF&t$6LX9-yL1SrW_dOv>j-JQcYBhZO&NqE(r>W2_4tos5Q4}Mjj`!27z0m4 +z+>bAW-wd*65@@hLoD5?})_E(hCRf+jlLnGJar5Tn8oPE1d|s8Rmk9o;^S?Dsg+=a$ +zsW5(6s3f(wUIf1#5~@kv?u+5+$e2mnop125p0V(^n%YnEv +z20iw_m%)tD@m4R1#sX@Id+F4jzZ{OjBo*eYX4BV5L1{ +zB^>YPrVFlw{WjE~5+7X&V=80q$P)>b;v|8SduRe-P}Q3n#WyT{!EMJ(yeb}Zo7cc> +zs10ulS9+oS_Knv-18RKa8mO!+w0h-Opi?*xau@`qhbYiEbMb}!%|#^MYMnV3;iVte +zi^XGn238df6~oW=bxWZ->6slnFt1AS`{{5zUKN`in}y-X^;7i(B5%pz9T^qrR8>;g +zMdS_545(yi+%zz#-AtEqf%4abo7qbtUQ0vaz)+XgG#_j+M< +zg}eNl@F2MF-UK_qez*@NxQF`SS+IBC2t({$x4`>it$kt>6x>@j!w7FL4#m2u{rB78 +zV!QTsxYUl{4sW`b-T_AkxzTUKsR3eBg-R{^8xKLV?LGu6-N9Qx8pPl0?Rk$tpMCHV +z__h1k_rW;h$VVT8mtEy?7y&h_LYyix=#oX#m&Wa1ZHJrOD|WzA?Pc81JRf-yRtL{h_CTBe?B2Ks?u``C;@s4xoJG(XN|r|bZrBo|4%tZO +zd8fibDys&SlfBp}B)V|w*1eI^(gVjSKgG$Kav}rWQ1^}nJkyBSQ{6V)Y-3ZgPDbT(mW5#RDUrcMh{t= +z!OY*0TUY!>H{g7ZwBSE6?1uf%-p9JS){wj{eDD@i%vDM@r_vR?5$nK=g2&;&rmI5; +zQ9Sj;Z9D7g?DQrWAM?bkk72{#saqYo!CQYz&yi*IF=QqkN6a05ufI&A?jN230Q(aM +z=DQdD5bg@9Z$8oFc1}~A4@LR37H>^sAkb_l_Ieow2j1LUXRhF(jgt<)L*WIu(k-jp +yaelL1tZoC2D656B?$&UMTvcAm+OQu++M`@}%f+X`Al}{RPv9K?am}+ZEb@O<2dy*! + +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/OrdTransport.lean b/projects/HasseWeil/HasseWeil/Isogeny/OrdTransport.lean +index 25e8c912a..3e6fa927e 100644 +--- a/projects/HasseWeil/HasseWeil/Isogeny/OrdTransport.lean ++++ b/projects/HasseWeil/HasseWeil/Isogeny/OrdTransport.lean +@@ -6,34 +6,25 @@ Authors: Chris Birkbeck + import HasseWeil.Foundation.EC.TranslateOrdInfty + + /-! +-# General DVR order-transport along a field hom (Silverman II.2.5, the unramified case) ++# Unramified order transport along a field homomorphism + +-This file isolates the *purely valuation-theoretic* core of the order-transport +-`ord_P (φ g) = ord_Q g` for an injective field homomorphism `φ : K(C) → K(C)` and a pair of smooth +-points `P` (source) and `Q` (target). It is the abstract DVR-transport step (Step 1 of the +-divisor-pullback brief): once one knows ++Let `φ : E → K(C)` be a field homomorphism and `P` a smooth point of `C`. ++Suppose the comap of the point valuation at `P` is equivalent to a surjective ++integer-valued valuation `v_Q` on `E`. If `ord_P (φ t) = 1` for one element `t`, ++the comap is also surjective, and the equivalent normalized valuations are equal. + +-* **(same place)** the comap valuation `(pointValuation Q).comap φ` is `Valuation.IsEquiv` to +- `pointValuation P` — i.e. `φ` carries the valuation ring of `Q` onto that of `P`; and +-* **(unramified, `e = 1`)** `ord_P (φ t) = 1` for a *single* uniformizer `t` at `Q`, ++The equivalence expresses equality of places, or valuation rings; the order-one ++condition fixes the ramification index to `1`. Together these give ++`ord_P (φ g) = ord_Q g` for every `g`. + +-the value-precise identity `ord_P (φ g) = ord_Q g` holds for **all** `g` (no ramification factor). +-The two inputs are genuinely independent: the first is "same place / same valuation ring", the +-second is the normalization `e = 1` (the ramification index), which for `[ℓ]` is the geometric +-content of separability. +- +-The main export is `comap_pointValuation_eq_of_isEquiv_of_ord_eq_one`, plus the small valuation glue +-lemmas it rests on (`Fintype`-free; the `[Fintype K]`-scoped versions they were derived from lived +-in `Hasse/L6Witnesses.lean`, which no longer exists, so these are now the only copies). +- +-Reference: Silverman, *The Arithmetic of Elliptic Curves*, II.2.5–2.6, III.4.10c. ++Reference: Silverman, *The Arithmetic of Elliptic Curves*, II.2.5–2.6 and III.4.10c. + -/ + + open WeierstrassCurve HasseWeil.Curves + + namespace HasseWeil + +-variable {F : Type*} [Field F] [DecidableEq F] ++variable {F : Type*} [Field F] + + /-- A `ℤᵐ⁰`-valued valuation on a field is surjective as soon as some element takes the value + `exp (-1)`: the negative powers of that element realise every `exp (-n)`, and `0 ↦ 0`. Shared core +@@ -143,8 +134,7 @@ Let `φ : E → K(C)` be a ring hom from a field `E`, `P` a smooth point of `C`, + then `(pointValuation P).comap φ = v_Q` *as valuations* (not merely equivalent). Reading off `ord`, + this yields `ord_P (φ g) = ord_Q g` for all `g` with no ramification factor. + +-This packages Step 1 of the divisor-pullback brief: the entire affine/infinity order-transport for +-a separable isogeny reduces to discharging the two displayed inputs. -/ ++The two hypotheses separate equality of valuation rings from the order normalization. -/ + theorem comap_pointValuation_eq_of_isEquiv_of_ord_eq_one + {E : Type*} [Field E] (φ : E →+* C.FunctionField) (P : C.SmoothPoint) + (v_Q : _root_.Valuation E (WithZero (Multiplicative ℤ))) (hv_Q : Function.Surjective v_Q) +diff --git a/projects/HasseWeil/HasseWeil/Isogeny/SeparableWitnessReductions.lean b/projects/HasseWeil/HasseWeil/Isogeny/SeparableWitnessReductions.lean +index a8ca2af446a345ac435d9f954c6af5b621ff0cba..7f04d3fd4cc31b5fb8d41b6bcd3ca5f5abba841c 100644 +GIT binary patch +delta 2578 +zcmb_e&u<$=6qb`BwG&W5B_X0x`brgIBYT^KHX;!@K~jZCEszKVRp^d)$Ig)58E0lU +zjg63VsG|1Da)3jnUbw&oVZSbwl^dMkb3fZcK7}G-uHcP +zzxlQB;BMjDy+Zp9xkVMH!eeFFU`nt6G;cAW!Ur9zkC_+oEgm&N)2EOxg&6=;Nb3Ou)pKlD6ZPyu?N}(xy2M70uAb{swnr`-~|%%FcY6bjSC(z +z{9%D#CYXXL?o}F+iwGh`g$`)Mr2wy2HSn+zU?KS<48<@}6Kb)*@};QQfWQJ4G7&js +zDbk>rjuda(`w+=)^SLY<0cfPbZG)nV6vUeOz=iGm8Vw}Z#G`>1XVqbT^FjuvN0rY7 +z4G=^JR#FJL`Bw%Z+bXnoEK)SzVd~TcOJ{HewO$^Sl-+oxQ&7<|)5Srk# +zx?&8|m128dtSkUGtD-0;IVh&ZC*r4y(&aa=-*7E=-qANel% +z@`Zb=s|aA7$&lfYJfP{A3`aypzNV=-j3XR<+J2566xm|mxBLOipE=?t17{}M4w%r? +zH=u6eMH<4&(7yIR7*5>%JGWM#xWD_+E6^&zJlLxuo_?~w3oD=E +zp=%PJNPcizE-9|?00j~bA)00^IEPX)H12eMzxYF;u$p{zshGSxc6OpnsMc|4dg3UV +z!+Pv%FnMS6T%pt%8Xp>Huja;JIg+U$)o_h(r|?1}4uUH6HUOWmGl#4iPUjh#7j%_* +z6g3Af_PK$LPo~b2(<)#tL&ay29jOwmSfXaAwnSLxyBso@f-Eu`k5R9KX+a01e6&9&{c#KcBuLLmt7+H<`zM+`>63~yx;g4;2}0P025KG~M(_<{sr}^GlWmTk?R8x* +zQ&Jbhu1{}AOlaft#)#M^+EccHj4+Ru05A0nFm>ZfUCFp{$Rd-o%fp?*!q-nd;TB`7 +z_W&a0*5ku%(R{R468>HP9BEE!9U7(&``z4dB#0IY*$;B +zv1k9u!?n>7>@9Px%(SjJQKF{KPj&tX<4Qw^J9^sm7eSMTeHU +zi=QT6z~k=`hMU*dTx;gZgf~8G|J89tn9qR2-$D3R-$V1&;BKp?0POgs!S+dFIHs?SMns6v} +zn-IvP#C8lM&Z(d3riKD?i9=1zqYuZCAx)scx}EA~R(~MJ +zRq71upnQ)Y*MPH4q>p*Y0N3@<4ud49ouZzDp~0Z3a3!;88(CcH#v&0^)1^dn5}6cg +zhLN>R)9xeRWo9pRQkvC7Iyz#rV{L6in`ZO2+3K|;HaFJRntPfTn?1CN-zj#^GJ;uSd!l7J%o{`Slhk^t +zoU-^T@H=mLSngc>^!4-4BSuzhBAVns*tBMrrE9OkE&RDQ9Quppco>uzFD_XHkJjZU_&7a +zByeX`u35P+%%8fxUha-R8j_Xwdmz8v`62MV`gy*?Xb|YSm3%y%FPGDIK^$m+$)c(S +zCWcMwiN|k&+8TTy3l|ChoD#Y=jUz<&Pz5`F8y7OU&n=B$h|W0g)5`ZJ+xY|R=mgSmuR>Hv7DgJ&V3l08_C(3l5iX)6P8Oj& +zG1veN{HR$aH``S(BE+%uxX?%!KXH$Zbj&ZiMTy2=*KgvBcU8+%+m|Wl5OH-Z)bR8A +z41R9cUi8$>@~vmWVa`uakPp6C163+T$wN!2&J3;Fq<5?n?+?HX>HO>@-1vWYWYr^B +znGv~o_vd9Ra<_R;sheVy;JuSF>@uFCxo*4ajj;~*j(oEuoiWc|(t~}EiVp{XNcQvc +z@F+w6`oIUpIKOC0v(={-< +zD)G8AljZmRylu2CoqVP`v~a{|J@ge~z|WqWByT_a!YDw=v*-R^^7S>6zxnu$(l1KU +zEf@Y(9NvwWR+dit(wxj?_Q_BG0sQj6_hTv?lE3=Azrx>94!gp_84G)$UBt%0)G2B} +zxugq+AQ}3>3%Tjmt|oey-!%@N4+@K4cyOX0p9Ir@$Bh-LviMuijQ7Xf2q#10Z?*8J +zpe=ne4TiSW!EOHcZ-T#q_(eS|^`D#te}qXRHi>)qzymYIdo!RcXk0-XQ{8LI$lXiz +z_G_JQuJ~aT>cz{AP${Y#VUU08_FDeR+J*f5+T~*FH(;R;G5Bc2mLqCf;pIX})c50L +zB*8|3(>HCqIJEPtj+;p}V>#=T6istAB64d@VVpdM?!_0nc|~$(CTmMgNdMKrnqnrYW>5H!@I-4Id1>O&9EKH +zn@MA1S7MFWGzhc&El;zeSW4;Pef8cr8Q3USe;VUKn +zhCR?zRHGswJ+u!h%L=;I`Dn$0qIaciy=XoGr-y0OS*zdqOE_LE7#W+ynh&7Dzw|rU +zQ7W#ShD+kE_hCyB<1o$LLolmY%;8ID>)^-mo^nw%)a8gn7vTnf!aw1;kbmGJRENdW +N7opyde+tJ#{{ctriJ1TZ + +diff --git a/projects/HasseWeil/HasseWeil/Pic0/ClassGroupNorm.lean b/projects/HasseWeil/HasseWeil/Pic0/ClassGroupNorm.lean +index a3e70337f..dec8deca0 100644 +--- a/projects/HasseWeil/HasseWeil/Pic0/ClassGroupNorm.lean ++++ b/projects/HasseWeil/HasseWeil/Pic0/ClassGroupNorm.lean +@@ -4,7 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Chris Birkbeck + -/ + import Mathlib.LinearAlgebra.FreeModule.Norm +-import Mathlib.NumberTheory.RamificationInertia.Basic ++import Mathlib.RingTheory.RamificationInertia.Basic ++import Mathlib.NumberTheory.RamificationInertia.Inertia ++import Mathlib.NumberTheory.RamificationInertia.Ramification ++import Mathlib.RingTheory.Ideal.Norm.AbsNorm ++import Mathlib.RingTheory.SimpleModule.Basic + import Mathlib.RingTheory.ClassGroup.Basic + import Mathlib.RingTheory.Ideal.Norm.RelNorm + import Mathlib.RingTheory.Localization.AtPrime.Extension +@@ -33,8 +37,8 @@ open scoped nonZeroDivisors + namespace HasseWeil + + variable {R S : Type*} +-variable [CommRing R] [IsDomain R] [IsIntegrallyClosed R] [IsDedekindDomain R] +-variable [CommRing S] [IsDomain S] [IsIntegrallyClosed S] [IsDedekindDomain S] ++variable [CommRing R] [IsDedekindDomain R] ++variable [CommRing S] [IsDedekindDomain S] + variable [Algebra R S] [Module.Finite R S] [Module.IsTorsionFree R S] + + /-- The relative norm of an integral ideal, packaged as a homomorphism of `nonZeroDivisors` +@@ -74,14 +78,14 @@ theorem mk0CompRelNorm0_eq_of_mk0_eq {I J : (Ideal S)⁰} + -- Provide the (deliberately non-instance) lift algebra on the fraction fields, so that + -- `Algebra.intNorm_ne_zero` (which assumes `FiniteDimensional (FractionRing R) (FractionRing S)`) + -- is available. +- letI : Algebra (FractionRing R) (FractionRing S) := ++ let : Algebra (FractionRing R) (FractionRing S) := + FractionRing.liftAlgebra R (FractionRing S) +- haveI : IsScalarTower R (FractionRing R) (FractionRing S) := ++ have : IsScalarTower R (FractionRing R) (FractionRing S) := + FractionRing.isScalarTower_liftAlgebra R (FractionRing S) +- haveI : IsLocalization (Algebra.algebraMapSubmonoid S R⁰) (FractionRing S) := ++ have : IsLocalization (Algebra.algebraMapSubmonoid S R⁰) (FractionRing S) := + IsIntegralClosure.isLocalization R (FractionRing R) (FractionRing S) S +- haveI : IsScalarTower R S (FractionRing S) := IsScalarTower.of_algebraMap_eq fun _ ↦ rfl +- haveI : FiniteDimensional (FractionRing R) (FractionRing S) := ++ have : IsScalarTower R S (FractionRing S) := IsScalarTower.of_algebraMap_eq fun _ ↦ rfl ++ have : FiniteDimensional (FractionRing R) (FractionRing S) := + Module.Finite.of_isLocalization R S R⁰ + rw [ClassGroup.mk0_eq_mk0_iff] at h + obtain ⟨x, y, hx, hy, hxy⟩ := h +@@ -177,30 +181,21 @@ transports `e`, `f` across the localisation, leaving only the relative-norm/loca + compatibility — see the residual note after `Ideal.relNorm_eq_under_of_inertiaDeg_one`.) -/ + + -- The `S/R` fraction-field tower + residue-degree `finrank` bookkeeping need elaboration room. +-/-- **`relNorm 𝔪 = p ^ inertiaDeg' p 𝔪` over a local base extension, unconditionally** (no +-`PerfectField`). For a **local** Dedekind domain `S` (a DVR) module-finite over a Dedekind domain +-`R`, with `𝔪 = IsLocalRing.maximalIdeal S` lying over a maximal `p ≠ ⊥` of `R`, the relative norm +-of `𝔪` is `p ^ inertiaDeg' p 𝔪`. +- +-Proof (see the section note): `p · S = 𝔪^e` (unique prime, via +-`Ideal.map_algebraMap_eq_finset_prod_pow` + `IsLocalRing.primesOver_eq`); applying `relNorm` and +-`Ideal.relNorm_algebraMap` gives `(relNorm 𝔪)^e = p^{e·f}` using +-`Ideal.ramificationIdx_mul_inertiaDeg_of_isLocalRing` (`e·f = [Frac S : Frac R]`); writing +-`relNorm 𝔪 = p^s` (`Ideal.exists_relNorm_eq_pow_of_isPrime`) and cancelling the prime power +-(`pow_injective_of_not_isUnit`) pins `s = f`. **No separability / Galois / `PerfectField`.** -/ ++ ++ + theorem Ideal.relNorm_maximalIdeal_eq_pow_inertiaDeg_of_isLocalRing + {R S : Type*} +- [CommRing R] [IsDomain R] [IsIntegrallyClosed R] [IsDedekindDomain R] +- [CommRing S] [IsDomain S] [IsIntegrallyClosed S] [IsDedekindDomain S] [IsLocalRing S] ++ [CommRing R] [IsDedekindDomain R] ++ [CommRing S] [IsDedekindDomain S] [IsLocalRing S] + [Algebra R S] [Module.Finite R S] [Module.IsTorsionFree R S] + {p : Ideal R} [p.IsMaximal] (hp0 : p ≠ ⊥) + [(IsLocalRing.maximalIdeal S).LiesOver p] : + Ideal.relNorm R (IsLocalRing.maximalIdeal S) = +- p ^ p.inertiaDeg' (IsLocalRing.maximalIdeal S) := by ++ p ^ (IsLocalRing.maximalIdeal S).inertiaDeg R := by + set m := IsLocalRing.maximalIdeal S with hm + set e := Ideal.ramificationIdx' p m with he_def +- set f := p.inertiaDeg' m with hf_def +- haveI : m.IsMaximal := IsLocalRing.maximalIdeal.isMaximal S ++ set f := m.inertiaDeg R with hf_def ++ have : m.IsMaximal := IsLocalRing.maximalIdeal.isMaximal S + have he0 : e ≠ 0 := Ideal.IsDedekindDomain.ramificationIdx'_ne_zero_of_liesOver m hp0 + -- `p · S = 𝔪^e` (the *unique* prime over `p`, so the factorisation is a single term). + have hmap : Ideal.map (algebraMap R S) p = m ^ e := by +@@ -217,15 +212,23 @@ theorem Ideal.relNorm_maximalIdeal_eq_pow_inertiaDeg_of_isLocalRing + (by rw [← IsLocalRing.primesOver_eq S hp0, ← Set.mem_toFinset]; exact hb)) hne + · intro h + exact absurd (by rw [Set.mem_toFinset, IsLocalRing.primesOver_eq S hp0]; rfl) h +- -- `e · f = [Frac S : Frac R]` (the fundamental identity; *no* separability hypothesis). +- letI : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R _ +- haveI : IsScalarTower R (FractionRing R) (FractionRing S) := +- FractionRing.isScalarTower_liftAlgebra R _ +- haveI : IsScalarTower R S (FractionRing S) := IsScalarTower.of_algebraMap_eq fun _ ↦ rfl +- -- `relNorm_algebraMap`'s exponent is `finrank R S`, so transport `e·f` down the fraction fields. +- have hef : e * f = Module.finrank R S := +- (Ideal.ramificationIdx_mul_inertiaDeg_of_isLocalRing S (FractionRing R) (FractionRing S) +- hp0).trans (IsFractionRing.finrank_eq R (FractionRing R) S (FractionRing S)) ++ have hef : e * f = Module.finrank R S := by ++ classical ++ let : Unique (p.primesOver S) := ++ { default := ⟨m, by ++ rw [IsLocalRing.primesOver_eq S hp0] ++ exact Set.mem_singleton m⟩ ++ uniq q := Subtype.ext (by ++ have hq : (q : Ideal S) ∈ ({m} : Set (Ideal S)) := by ++ simpa only [IsLocalRing.primesOver_eq S hp0] using q.2 ++ exact Set.mem_singleton_iff.mp hq) } ++ have h := Ideal.sum_ramification_inertia_eq_finrank p S ++ have hd : ((default : p.primesOver S) : Ideal S) = m := by ++ have hq : ((default : p.primesOver S) : Ideal S) ∈ ({m} : Set (Ideal S)) := by ++ simpa only [IsLocalRing.primesOver_eq S hp0] using (default : p.primesOver S).2 ++ exact Set.mem_singleton_iff.mp hq ++ simpa only [Fintype.sum_unique, hd, ++ ← Ideal.ramificationIdx'_eq_ramificationIdx p m hp0] using h + -- `(relNorm 𝔪)^e = relNorm(𝔪^e) = relNorm(p · S) = p^{[Frac S:Frac R]} = p^{e·f}`. + have h3 : (Ideal.relNorm R m) ^ e = p ^ (e * f) := by + rw [← map_pow, ← hmap, Ideal.relNorm_algebraMap, hef] +@@ -233,7 +236,7 @@ theorem Ideal.relNorm_maximalIdeal_eq_pow_inertiaDeg_of_isLocalRing + obtain ⟨s, hs⟩ := Ideal.exists_relNorm_eq_pow_of_isPrime m p + rw [hs, ← pow_mul] at h3 + have hpr : Prime p := (Ideal.prime_iff_isPrime hp0).mpr inferInstance +- have hse : s * e = e * f := pow_injective_of_not_isUnit hpr.not_unit hpr.ne_zero h3 ++ have hse : s * e = e * f := pow_injective_of_not_isUnit hpr.not_isUnit hpr.ne_zero h3 + have hsf : s = f := + Nat.eq_of_mul_eq_mul_right (Nat.pos_of_ne_zero he0) (by rw [hse]; ring) + rw [hs, hsf] +@@ -245,16 +248,15 @@ collapses (`pow_one`) and `p = 𝔪.under R`, giving `relNorm R 𝔪 = 𝔪.unde + S) 𝔪`) with **no** separability hypothesis. -/ + theorem Ideal.relNorm_maximalIdeal_eq_under_of_inertiaDeg_one_of_isLocalRing + {R S : Type*} +- [CommRing R] [IsDomain R] [IsIntegrallyClosed R] [IsDedekindDomain R] +- [CommRing S] [IsDomain S] [IsIntegrallyClosed S] [IsDedekindDomain S] [IsLocalRing S] ++ [CommRing R] [IsDedekindDomain R] ++ [CommRing S] [IsDedekindDomain S] [IsLocalRing S] + [Algebra R S] [Module.Finite R S] [Module.IsTorsionFree R S] + (hp0 : (IsLocalRing.maximalIdeal S).under R ≠ ⊥) +- (hf : Ideal.inertiaDeg' ((IsLocalRing.maximalIdeal S).under R) +- (IsLocalRing.maximalIdeal S) = 1) : ++ (hf : (IsLocalRing.maximalIdeal S).inertiaDeg R = 1) : + Ideal.relNorm R (IsLocalRing.maximalIdeal S) = (IsLocalRing.maximalIdeal S).under R := by +- haveI : ((IsLocalRing.maximalIdeal S).under R).IsMaximal := ++ have : ((IsLocalRing.maximalIdeal S).under R).IsMaximal := + Ideal.IsMaximal.under R (IsLocalRing.maximalIdeal S) +- haveI : (IsLocalRing.maximalIdeal S).LiesOver ((IsLocalRing.maximalIdeal S).under R) := ++ have : (IsLocalRing.maximalIdeal S).LiesOver ((IsLocalRing.maximalIdeal S).under R) := + Ideal.over_under _ + rw [Ideal.relNorm_maximalIdeal_eq_pow_inertiaDeg_of_isLocalRing hp0, hf, pow_one] + +@@ -271,19 +273,10 @@ The key observation is that `Algebra.intNorm A B x` is defined as the restrictio + `B`, not on the integral model `B`. Hence two integral models `B`, `B'` of the same field extension + have the same `intNorm`, and therefore the same `relNorm` on corresponding ideals. -/ + +-/-- **`intNorm` depends only on the common fraction field.** If `B` and `B'` are integrally closed +-domains, both integral over `A` and both having `L` as a common fraction field over `K = Frac A` +-(with `B → B'` compatible), then `intNorm A B x = intNorm A B' (algebraMap B B' x)`. + +-This is `Algebra.algebraMap_intNorm` (`algebraMap A K (intNorm A B x) = norm K (algebraMap B L x)`) +-applied to both `B` and `B'` with the **same** ambient field `L`: the two field norms coincide +-because `algebraMap B L = algebraMap B' L ∘ algebraMap B B'` (the scalar tower `B → B' → L`). +-No module-finiteness of `B'` over `A` is required (only finiteness at the fraction-field level +-`[FiniteDimensional K L]`), which is why this survives the passage to a non-finite localisation. -/ + theorem intNorm_eq_intNorm_of_common_fractionField + {A K L B B' : Type*} +- [CommRing A] [IsDomain A] [IsIntegrallyClosed A] +- [Field K] [Algebra A K] [IsFractionRing A K] ++ [CommRing A] [IsDomain A] [IsIntegrallyClosed A] [Field K] [Algebra A K] [IsFractionRing A K] + [Field L] [Algebra K L] [Algebra A L] [IsScalarTower A K L] [FiniteDimensional K L] + [CommRing B] [IsDomain B] [IsIntegrallyClosed B] [Algebra A B] [Algebra.IsIntegral A B] + [Module.IsTorsionFree A B] [Algebra B L] [IsScalarTower A B L] [IsIntegralClosure B A L] +@@ -297,32 +290,17 @@ theorem intNorm_eq_intNorm_of_common_fractionField + congr 1 + rw [← IsScalarTower.algebraMap_apply B B' L] + +-/-- **`relNorm` is unchanged under top-localisation of a principal prime.** If `B` is a Dedekind +-**PID** (e.g. the semilocal localisation `Sₚ`), `Q` a principal ideal of `B`, and `B'` an +-integrally closed domain sharing the fraction field `L = Frac B`, then +-`relNorm A Q = relNorm A (Q.map (B → B'))`. +- +-The proof writes `Q = span{π}` (principal), so `relNorm A Q = span{intNorm A B π}` and +-`relNorm A (Q.map) = span{intNorm A B' (algebraMap π)}` (`relNorm_singleton`, `Ideal.map_span`), +-and the two generators agree by `intNorm_eq_intNorm_of_common_fractionField`. +- +-**Caveat.** `Ideal.relNorm A B'` is only well-typed under `[Module.Finite A B']` (mathlib's +-`relNorm`/`spanNorm` carry this in their definition). This is exactly why this bridge does **not** +-discharge the general-base residual: the intended `B' = Localization.AtPrime Q` (a DVR isolating one +-of several primes over `p`) is **not** module-finite over `A = Rₚ` when several primes lie over `p`, +-so the right-hand side is ill-typed there. It applies when finiteness is preserved — e.g. when `Q` +-is the *unique* prime over `p` (`finite_of_primesOver_eq_singleton`), which is the already-handled +-local case `Ideal.relNorm_maximalIdeal_eq_pow_inertiaDeg_of_isLocalRing`. -/ ++ + theorem relNorm_eq_relNorm_localization + {A K L B B' : Type*} +- [CommRing A] [IsDomain A] [IsIntegrallyClosed A] [IsDedekindDomain A] ++ [CommRing A] [IsDedekindDomain A] + [Field K] [Algebra A K] [IsFractionRing A K] + [Field L] [Algebra K L] [Algebra A L] [IsScalarTower A K L] [FiniteDimensional K L] +- [CommRing B] [IsDomain B] [IsIntegrallyClosed B] [IsDedekindDomain B] ++ [CommRing B] [IsDedekindDomain B] + [Algebra A B] [Algebra.IsIntegral A B] [Module.Finite A B] + [Module.IsTorsionFree A B] [Algebra B L] [IsScalarTower A B L] [IsIntegralClosure B A L] + [IsPrincipalIdealRing B] +- [CommRing B'] [IsDomain B'] [IsIntegrallyClosed B'] [IsDedekindDomain B'] ++ [CommRing B'] [IsDedekindDomain B'] + [Algebra A B'] [Algebra.IsIntegral A B'] [Module.Finite A B'] [Module.IsTorsionFree A B'] + [Algebra B' L] [IsScalarTower A B' L] [IsIntegralClosure B' A L] + [Algebra B B'] [IsScalarTower A B B'] [IsScalarTower B B' L] +@@ -351,8 +329,7 @@ This reduces the `PerfectField` gate to the **single** residual stated in + hypothesis `hlocal` — the per-prime relative norm over a DVR base (see the residual note after + `Ideal.relNorm_eq_under_of_inertiaDeg_one`). -/ + +-omit [IsDomain R] [IsIntegrallyClosed R] [IsDedekindDomain R] [IsDomain S] +- [IsIntegrallyClosed S] [IsDedekindDomain S] [Module.IsTorsionFree R S] in ++omit [IsDedekindDomain R] [IsDedekindDomain S] [Module.IsTorsionFree R S] in + /-- **The extension of `𝔭` to a localisation away from `𝔭.under` is `⊤`.** If the maximal prime + `q` of `R` differs from `p = P.under R`, then `p ⊄ q`, so an element `a ∈ p ⊆ P` lands outside `q`, + hence becomes a unit in `Sₚ = Localization (algebraMapSubmonoid S q.primeCompl)`; since +@@ -361,7 +338,7 @@ of `relNorm_eq_under_of_localized`.) -/ + theorem map_eq_top_of_under_ne (P : Ideal S) (q : Ideal R) [hq : q.IsMaximal] [P.IsMaximal] + (hne : P.under R ≠ q) : + P.map (algebraMap S (Localization (Algebra.algebraMapSubmonoid S q.primeCompl))) = ⊤ := by +- haveI : (P.under R).IsMaximal := Ideal.IsMaximal.under R P ++ have : (P.under R).IsMaximal := Ideal.IsMaximal.under R P + obtain ⟨a, hap, haq⟩ : ∃ a, a ∈ P.under R ∧ a ∉ q := by + by_contra h; push Not at h + exact hne (((Ideal.IsMaximal.under R P).eq_of_le hq.ne_top h)) +@@ -374,7 +351,7 @@ theorem map_eq_top_of_under_ne (P : Ideal S) (q : Ideal R) [hq : q.IsMaximal] [P + exact (P.map _).eq_top_of_isUnit_mem (Ideal.mem_map_of_mem _ haP) hunit ▸ Submodule.mem_top + + -- The semilocal `Sₚ` Dedekind/finite/torsion-free instance bundle over the DVR `Rₚ` pushes instance +--- synthesis (e.g. `IsDomain Sₚ`) past the default budget at statement elaboration. ++ + /-- **The relative norm localises (top + bottom) at a maximal prime `q` of `R`.** Pushing + `relNorm R P` along `R → Rₚ := Localization.AtPrime q` equals the relative norm over `Rₚ` of the + extension of `P` to the semilocal `Sₚ = Localization (algebraMapSubmonoid S q.primeCompl)`. +@@ -417,8 +394,8 @@ theorem relNorm_eq_under_of_localized (P : Ideal S) [P.IsMaximal] (hP : P ≠ + (P.map (algebraMap S (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)))) + = IsLocalRing.maximalIdeal (Localization.AtPrime (P.under R))) : + Ideal.relNorm R P = P.under R := by +- haveI : (P.under R).IsMaximal := Ideal.IsMaximal.under R P +- haveI hpne : NeZero (P.under R) := ⟨Ideal.under_ne_bot R hP⟩ ++ have : (P.under R).IsMaximal := Ideal.IsMaximal.under R P ++ have hpne : NeZero (P.under R) := ⟨Ideal.under_ne_bot R hP⟩ + have hnotfield : ¬ IsField R := + Ring.not_isField_of_ne_of_ne (Ideal.under_ne_bot R hP) (Ideal.IsMaximal.ne_top inferInstance) + refine Ideal.eq_of_localization_maximal (fun q hq ↦ ?_) +@@ -426,39 +403,15 @@ theorem relNorm_eq_under_of_localized (P : Ideal S) [P.IsMaximal] (hP : P ≠ + · subst hqp + rw [relNorm_map_localization P (P.under R), hlocal, + Localization.AtPrime.map_eq_maximalIdeal] +- · haveI : NeZero q := ⟨Ring.ne_bot_of_isMaximal_of_not_isField hq hnotfield⟩ ++ · have : NeZero q := ⟨Ring.ne_bot_of_isMaximal_of_not_isField hq hnotfield⟩ + rw [relNorm_map_localization P q, map_eq_top_of_under_ne P q hqp, Ideal.relNorm_top, + IsLocalization.AtPrime.map_eq_top_of_not_le _ (fun hle ↦ hqp + ((Ideal.IsMaximal.under R P).eq_of_le hq.ne_top hle))] + +-/-! #### The per-prime relative norm over a DVR base — the `PerfectField`-free residual, **CLOSED** +- +-The single remaining input of `relNorm_eq_under_of_localized` — the per-prime relative norm +-`relNorm Rₚ 𝔮 = maximalIdeal Rₚ` over a **DVR** base `Rₚ` at residue degree one — is discharged +-here, +-**without `PerfectField`**, via the **module-length** route (no residue *field* structure on the +-base, +-so no `Field (Rₚ ⧸ m)` instance diamond). +- +-The engine is the `Rₚ`-module-length identity over a **PID** base (`Rₚ` is a DVR, hence a PID): +-for a nonzero principal `Q = (π)` of a free-finite `Rₚ`-algebra `Sₚ`, +- +- `length_{Rₚ}(Sₚ ⧸ Q) = length_{Rₚ}(Rₚ ⧸ relNorm Rₚ Q)` (`relNorm_length_eq_span`), +- +-proved by Smith normal form (`Ideal.quotientEquivPiSpan` is `Rₚ`-linear) + additivity of the order +-of +-vanishing (`Ring.ord_mul`, `Ideal.relNorm_singleton`, `Algebra.intNorm_eq_norm`, +-`associated_norm_prod_smith`). When `f = inertiaDeg' = 1`, `Sₚ ⧸ Q` is a **simple** `Rₚ`-module +-(`isSimpleModule_quot_of_inertiaDeg_one`: the residue algebra map `Rₚ → Sₚ ⧸ Q` is onto, so +-`Sₚ ⧸ Q ≃ₗ[Rₚ] Rₚ ⧸ m`), hence `length = 1`; the identity then forces `Rₚ ⧸ relNorm Rₚ Q` to be +-simple, +-i.e. `relNorm Rₚ Q` maximal, i.e. `= m` (`IsLocalRing.eq_maximalIdeal`). **No Galois, no +-`PerfectField`.** -/ + + /-- **Additivity of the order of vanishing over a finite product** (`Ring.ord_mul`, iterated). For + nonzero `cᵢ` in a commutative domain, `ord (∏ cᵢ) = ∑ ord cᵢ`. -/ +-theorem Ring.ord_finset_prod {A : Type*} [CommRing A] [IsDomain A] +- {ι : Type*} (s : Finset ι) (c : ι → A) (hc : ∀ i ∈ s, c i ≠ 0) : ++theorem Ring.ord_finset_prod {A : Type*} [CommRing A] [IsDomain A] {ι : Type*} (s : Finset ι) (c : ι → A) (hc : ∀ i ∈ s, c i ≠ 0) : + Ring.ord A (∏ i ∈ s, c i) = ∑ i ∈ s, Ring.ord A (c i) := by + classical + induction s using Finset.induction with +@@ -469,18 +422,11 @@ theorem Ring.ord_finset_prod {A : Type*} [CommRing A] [IsDomain A] + rw [mem_nonZeroDivisors_iff_ne_zero] + exact Finset.prod_ne_zero_iff.mpr (fun i hi ↦ hc i (Finset.mem_insert_of_mem hi)) + +-/-- **Norm–length identity over a PID base.** For a free-finite algebra `Sₚ` over a PID `Rₚ` +-(integrally closed domains), and a nonzero element `π`, the `Rₚ`-module length of `Sₚ ⧸ (π)` equals +-the `Rₚ`-module length of `Rₚ ⧸ relNorm Rₚ (π)`. + +-Proof: `relNorm Rₚ (π) = (Algebra.norm Rₚ π)` (`relNorm_singleton`, `intNorm_eq_norm`), whose order +-of vanishing is `∑ᵢ length(Rₚ ⧸ (cᵢ))` for the Smith coefficients `cᵢ` +-(`associated_norm_prod_smith`, `Ring.ord_finset_prod`, `Ring.ord = length(·⧸·)`); the same sum is +-`length(Sₚ ⧸ (π))` by the `Rₚ`-linear `Ideal.quotientEquivPiSpan` + `length_pi_of_fintype`. -/ + theorem relNorm_length_eq_span + {Rp Sp : Type*} + [CommRing Rp] [IsDomain Rp] [IsPrincipalIdealRing Rp] [IsIntegrallyClosed Rp] +- [CommRing Sp] [IsDomain Sp] [IsIntegrallyClosed Sp] [IsDedekindDomain Sp] ++ [CommRing Sp] [IsDedekindDomain Sp] + [Algebra Rp Sp] [Module.Finite Rp Sp] [Module.IsTorsionFree Rp Sp] + (π : Sp) (hπ0 : π ≠ 0) : + Module.length Rp (Rp ⧸ Ideal.relNorm Rp (Ideal.span {π})) = +@@ -510,30 +456,23 @@ theorem relNorm_length_eq_span + -- The explicit residue-field algebra structure (built on the `Ideal.Quotient.field`-derived + -- semiring + -- via `algebraQuotientOfLEComap`) keeps the surjectivity/`finrank` bookkeeping in elaboration +--- budget ++ + -- *without* the `algebraOfLiesOver` instance-diamond (which carries free metavariables). +-/-- **`Sₚ ⧸ Q` is a simple `Rₚ`-module at residue degree one** (the diamond-free `f = 1` input). For +-a maximal ideal `Q` of `Sₚ` lying over a maximal `m` of `Rₚ` with `inertiaDeg' m Q = 1`, the residue +-algebra map `Rₚ → Sₚ ⧸ Q` is **surjective** with kernel `m` (the residue extension is trivial), so +-`Sₚ ⧸ Q ≃ₗ[Rₚ] Rₚ ⧸ m`, a simple `Rₚ`-module. +- +-Diamond-free: the residue `Field (Rₚ ⧸ m)` and the residue algebra `Algebra (Rₚ ⧸ m) (Sₚ ⧸ Q)` are +-introduced together by `algebraQuotientOfLEComap` on the **same** field-derived semiring, so the +-`FiniteDimensional`/`finrank` synthesis never disagrees with `inertiaDeg'`'s +-`Module (Rₚ ⧸ m) (Sₚ ⧸ Q)`. -/ ++ ++ + theorem isSimpleModule_quot_of_inertiaDeg_one + {Rp Sp : Type*} [CommRing Rp] [CommRing Sp] [Algebra Rp Sp] + (Q : Ideal Sp) [hQ : Q.IsMaximal] (m : Ideal Rp) [hm : m.IsMaximal] +- [hlo : Q.LiesOver m] (hf : Ideal.inertiaDeg' m Q = 1) : ++ [hlo : Q.LiesOver m] (hf : Q.inertiaDeg Rp = 1) : + IsSimpleModule Rp (Sp ⧸ Q) := by +- letI : Field (Rp ⧸ m) := Ideal.Quotient.field m +- letI alg : Algebra (Rp ⧸ m) (Sp ⧸ Q) := ++ let : Field (Rp ⧸ m) := Ideal.Quotient.field m ++ let alg : Algebra (Rp ⧸ m) (Sp ⧸ Q) := + Ideal.Quotient.algebraQuotientOfLEComap (le_of_eq (Q.over_def m)) +- haveI hst : IsScalarTower Rp (Rp ⧸ m) (Sp ⧸ Q) := IsScalarTower.of_algebraMap_eq' rfl ++ have hst : IsScalarTower Rp (Rp ⧸ m) (Sp ⧸ Q) := IsScalarTower.of_algebraMap_eq' rfl + have hfr : Module.finrank (Rp ⧸ m) (Sp ⧸ Q) = 1 := by +- rw [← Ideal.inertiaDeg'_algebraMap m Q]; exact hf +- haveI : Nontrivial (Sp ⧸ Q) := Ideal.Quotient.nontrivial_iff.mpr hQ.ne_top +- haveI : FiniteDimensional (Rp ⧸ m) (Sp ⧸ Q) := Module.finite_of_finrank_eq_succ hfr ++ rw [← Ideal.inertiaDeg_eq_of_isMaximal m Q]; exact hf ++ have : Nontrivial (Sp ⧸ Q) := Ideal.Quotient.nontrivial_iff.mpr hQ.ne_top ++ have : FiniteDimensional (Rp ⧸ m) (Sp ⧸ Q) := Module.finite_of_finrank_eq_succ hfr + have hsurj' : Function.Surjective (algebraMap (Rp ⧸ m) (Sp ⧸ Q)) := by + have hinj : Function.Injective (Algebra.linearMap (Rp ⧸ m) (Sp ⧸ Q)) := + (algebraMap (Rp ⧸ m) (Sp ⧸ Q)).injective +@@ -556,32 +495,23 @@ theorem isSimpleModule_quot_of_inertiaDeg_one + exact ⟨m, hm, ⟨(LinearMap.quotKerEquivOfSurjective _ hsurjRp).symm.trans + (Submodule.quotEquivOfEq _ _ hker)⟩⟩ + +--- The module-length chain over the DVR base (Smith + `Ring.ord` additivity + simplicity) needs ++ + -- room. +-/-- **The per-prime relative norm over a DVR base at residue degree one** (the `PerfectField`-free +-residual, **CLOSED**). For a DVR `Rₚ` (a local PID), a Dedekind PID `Sₚ` free-finite torsion-free +-over `Rₚ`, and a nonzero maximal ideal `Q` of `Sₚ` lying over `m = maximalIdeal Rₚ` with +-`inertiaDeg' m Q = 1`, the relative norm `relNorm Rₚ Q = m`. +- +-Proof (module-length, **no** residue-field instance, **no** Galois/`PerfectField`): +-`Sₚ ⧸ Q` is `Rₚ`-simple (`isSimpleModule_quot_of_inertiaDeg_one`), so `length_{Rₚ}(Sₚ ⧸ Q) = 1`; the +-norm–length identity `relNorm_length_eq_span` transports this to +-`length_{Rₚ}(Rₚ ⧸ relNorm Rₚ Q) = 1`, +-making `Rₚ ⧸ relNorm Rₚ Q` simple, i.e. `relNorm Rₚ Q` maximal, hence `= m` +-(`IsLocalRing.eq_maximalIdeal`). -/ ++ ++ + theorem relNorm_eq_maximalIdeal_of_inertiaDeg_one + {Rp Sp : Type*} + [CommRing Rp] [IsDomain Rp] [IsPrincipalIdealRing Rp] [IsIntegrallyClosed Rp] [IsLocalRing Rp] +- [CommRing Sp] [IsDomain Sp] [IsIntegrallyClosed Sp] [IsDedekindDomain Sp] ++ [CommRing Sp] [IsDedekindDomain Sp] + [IsPrincipalIdealRing Sp] + [Algebra Rp Sp] [Module.Finite Rp Sp] [Module.IsTorsionFree Rp Sp] + (Q : Ideal Sp) [hQ : Q.IsMaximal] (hQ0 : Q ≠ ⊥) + [hlo : Q.LiesOver (IsLocalRing.maximalIdeal Rp)] +- (hf : Ideal.inertiaDeg' (IsLocalRing.maximalIdeal Rp) Q = 1) : ++ (hf : Q.inertiaDeg Rp = 1) : + Ideal.relNorm Rp Q = IsLocalRing.maximalIdeal Rp := by + set m := IsLocalRing.maximalIdeal Rp with hm +- haveI : m.IsMaximal := IsLocalRing.maximalIdeal.isMaximal Rp +- haveI hsimp : IsSimpleModule Rp (Sp ⧸ Q) := isSimpleModule_quot_of_inertiaDeg_one Q m hf ++ have : m.IsMaximal := IsLocalRing.maximalIdeal.isMaximal Rp ++ have hsimp : IsSimpleModule Rp (Sp ⧸ Q) := isSimpleModule_quot_of_inertiaDeg_one Q m hf + have hlen1 : Module.length Rp (Sp ⧸ Q) = 1 := Module.length_eq_one Rp (Sp ⧸ Q) + obtain ⟨π, hπ⟩ := (IsPrincipalIdealRing.principal Q).principal + have hπ0 : π ≠ 0 := by rintro rfl; apply hQ0; rw [hπ]; simp +@@ -595,8 +525,7 @@ theorem relNorm_eq_maximalIdeal_of_inertiaDeg_one + exact IsLocalRing.eq_maximalIdeal hmax + + -- The abstract `Rₚ`/`Sₚ` localisation instance bundle (in the binders) needs synthesis room. +-omit [IsIntegrallyClosed R] [IsDedekindDomain R] [IsDomain S] [IsIntegrallyClosed S] +- [IsDedekindDomain S] [Module.Finite R S] [Module.IsTorsionFree R S] in ++omit [IsDedekindDomain S] [Module.Finite R S] [Module.IsTorsionFree R S] in + /-- **The per-prime relative norm at residue degree one, general semilocal `Rₚ`/`Sₚ`.** The + hypothesis `hlocal` of `relNorm_eq_under_of_localized`, stated over abstract localisation data + `Rₚ`/`Sₚ` (so the expensive concrete-`Localization` instances are deferred): for a maximal `P` of +@@ -608,83 +537,58 @@ The prime/maximal/`LiesOver`/`inertiaDeg'`-transport facts for `P·Sₚ` come fr + `relNorm_eq_maximalIdeal_of_inertiaDeg_one`. -/ + theorem relNorm_map_eq_maximalIdeal_general + (p : Ideal R) [hp : p.IsMaximal] (hp0 : p ≠ ⊥) +- (Rp : Type*) [CommRing Rp] [IsDomain Rp] [IsIntegrallyClosed Rp] [IsDedekindDomain Rp] ++ (Rp : Type*) [CommRing Rp] [IsDedekindDomain Rp] + [IsPrincipalIdealRing Rp] [Algebra R Rp] [IsLocalization.AtPrime Rp p] [IsLocalRing Rp] + [Module.IsTorsionFree R Rp] +- (Sp : Type*) [CommRing Sp] [IsDomain Sp] [IsIntegrallyClosed Sp] [IsDedekindDomain Sp] ++ (Sp : Type*) [CommRing Sp] [IsDedekindDomain Sp] + [IsPrincipalIdealRing Sp] [Algebra S Sp] + [IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sp] + [Algebra Rp Sp] [Module.Finite Rp Sp] [Module.IsTorsionFree Rp Sp] + [Algebra R Sp] [IsScalarTower R S Sp] [IsScalarTower R Rp Sp] + (P : Ideal S) [hPmax : P.IsMaximal] [hPp : P.LiesOver p] +- (hf : Ideal.inertiaDeg' p P = 1) : ++ (hf : P.inertiaDeg R = 1) : + Ideal.relNorm Rp (P.map (algebraMap S Sp)) = IsLocalRing.maximalIdeal Rp := by +- haveI hQprime : (P.map (algebraMap S Sp)).IsPrime := ++ have hQprime : (P.map (algebraMap S Sp)).IsPrime := + IsLocalization.AtPrime.isPrime_map_of_liesOver S p Sp P +- haveI hQlo : (P.map (algebraMap S Sp)).LiesOver (IsLocalRing.maximalIdeal Rp) := ++ have hQlo : (P.map (algebraMap S Sp)).LiesOver (IsLocalRing.maximalIdeal Rp) := + IsLocalization.AtPrime.liesOver_map_of_liesOver p Rp Sp P + have hm0 : IsLocalRing.maximalIdeal Rp ≠ ⊥ := by + rw [← IsLocalization.AtPrime.map_eq_maximalIdeal p Rp] + exact Ideal.map_ne_bot_of_ne_bot hp0 + have hQ0 : (P.map (algebraMap S Sp)) ≠ ⊥ := Ideal.ne_bot_of_liesOver_of_ne_bot hm0 _ +- haveI hQmax : (P.map (algebraMap S Sp)).IsMaximal := ++ have hQmax : (P.map (algebraMap S Sp)).IsMaximal := + Ring.DimensionLEOne.maximalOfPrime hQ0 hQprime +- rw [Ideal.inertiaDeg'_eq_inertiaDeg] at hf +- have hfQ : Ideal.inertiaDeg' (IsLocalRing.maximalIdeal Rp) (P.map (algebraMap S Sp)) = 1 := by +- rw [Ideal.inertiaDeg'_eq_inertiaDeg, +- IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg p Rp Sp P] ++ have hfQ : (P.map (algebraMap S Sp)).inertiaDeg Rp = 1 := by ++ rw [IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg p Rp Sp P] + exact hf + exact relNorm_eq_maximalIdeal_of_inertiaDeg_one (P.map (algebraMap S Sp)) hQ0 hfQ + + -- The concrete semilocal `Sₚ` / DVR `Rₚ` localisation instance bundle is expensive to synthesise. +-/-- **`relNorm 𝔭 = comap 𝔭` for a maximal prime of residue degree one** (Silverman III.4.10(a), +-`f = 1`; ideal form). For a maximal ideal `P` of `S` with `inertiaDeg' (P.under R) P = 1`, the +-relative norm `Ideal.relNorm R P` equals the contraction `P.under R = comap (algebraMap R S) P`. +- +-This is reduced (no `PerfectField`) to the per-prime DVR-base norm via the global→semilocal +-`relNorm_eq_under_of_localized`; see the body and `relNorm_map_eq_maximalIdeal_general`. +- +-**Unconditional — no `PerfectField`.** Mathlib's `Ideal.relNorm_eq_pow_of_isMaximal` +-(`relNorm 𝔭 = 𝔭.under^f`) is gated on `[PerfectField (FractionRing R)]` (its proof reduces to the +-**Galois** case), which fails for a function field over a finite base. That hypothesis is *not* +-mathematically necessary at `f = 1` (standard `e · f` theory, Silverman III.4.10), and is now +-removed: the global→semilocal reduction `relNorm_eq_under_of_localized` reduces +-`relNorm R P = P.under R` to the **single** semilocal per-prime input +- +- `relNorm Rₚ (P·Sₚ) = maximalIdeal Rₚ` (`Rₚ = Localization.AtPrime p`, `Sₚ = semilocal loc. S`), +- +-which `relNorm_map_eq_maximalIdeal_general` discharges via the **module-length** route over the DVR +-base (`relNorm_eq_maximalIdeal_of_inertiaDeg_one` ← `relNorm_length_eq_span` + +-`isSimpleModule_quot_of_inertiaDeg_one`) — no Galois, no `PerfectField`, and **no** `Field (Rₚ ⧸ m)` +-instance diamond (the length is taken over the DVR `Rₚ`, never the residue field). The inertia +-degree transports across the localisation via `IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg`. +- +-(The shipped local-base specialisation +-`Ideal.relNorm_maximalIdeal_eq_under_of_inertiaDeg_one_of_isLocalRing` is now subsumed for the +-general base; it is retained as a lighter-weight `IsLocalRing` form.) -/ ++ ++ + theorem Ideal.relNorm_eq_under_of_inertiaDeg_one + {P : Ideal S} [hPmax : P.IsMaximal] (hP : P ≠ ⊥) +- (hf : Ideal.inertiaDeg' (P.under R) P = 1) : ++ (hf : P.inertiaDeg R = 1) : + Ideal.relNorm R P = P.under R := by +- letI hnz := NeZero.mk (Ideal.under_ne_bot R hP) +- haveI hpmax : (P.under R).IsMaximal := Ideal.IsMaximal.under R P +- haveI : P.LiesOver (P.under R) := Ideal.over_under P +- -- Pre-establish the heavy semilocal `Sₚ` / DVR `Rₚ` instances so the discharge stays in budget. +- haveI iDed : IsDedekindDomain ++ let hnz := NeZero.mk (Ideal.under_ne_bot R hP) ++ have hpmax : (P.under R).IsMaximal := Ideal.IsMaximal.under R P ++ have : P.LiesOver (P.under R) := Ideal.over_under P ++ ++ have iDed : IsDedekindDomain + (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)) := inferInstance +- haveI iPID : IsPrincipalIdealRing ++ have iPID : IsPrincipalIdealRing + (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)) := inferInstance +- haveI iFin : Module.Finite (Localization.AtPrime (P.under R)) ++ have iFin : Module.Finite (Localization.AtPrime (P.under R)) + (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)) := inferInstance +- haveI iTF : Module.IsTorsionFree (Localization.AtPrime (P.under R)) ++ have iTF : Module.IsTorsionFree (Localization.AtPrime (P.under R)) + (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)) := inferInstance +- haveI iIC : IsIntegrallyClosed ++ have iIC : IsIntegrallyClosed + (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)) := inferInstance +- haveI iST2 : IsScalarTower R (Localization.AtPrime (P.under R)) ++ have iST2 : IsScalarTower R (Localization.AtPrime (P.under R)) + (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)) := inferInstance +- haveI iST3 : IsScalarTower R S ++ have iST3 : IsScalarTower R S + (Localization (Algebra.algebraMapSubmonoid S (P.under R).primeCompl)) := inferInstance +- haveI iTFr : Module.IsTorsionFree R (Localization.AtPrime (P.under R)) := inferInstance ++ have iTFr : Module.IsTorsionFree R (Localization.AtPrime (P.under R)) := inferInstance + refine relNorm_eq_under_of_localized P hP ?_ + exact relNorm_map_eq_maximalIdeal_general (P.under R) (Ideal.under_ne_bot R hP) + (Localization.AtPrime (P.under R)) +@@ -696,81 +600,47 @@ contraction `comap (algebraMap R S) P` (which is nonzero by `Ideal.under_ne_bot` + `(Ideal R)⁰`. -/ + theorem relNorm0_eq_comap_of_inertiaDeg_one + (P : (Ideal S)⁰) [hPmax : (P : Ideal S).IsMaximal] +- (hf : Ideal.inertiaDeg' ((P : Ideal S).under R) (P : Ideal S) = 1) : ++ (hf : (P : Ideal S).inertiaDeg R = 1) : + (relNorm0 (R := R) (S := S) P : Ideal R) = + Ideal.comap (algebraMap R S) (P : Ideal S) := + Ideal.relNorm_eq_under_of_inertiaDeg_one (R := R) (S := S) + (mem_nonZeroDivisors_iff_ne_zero.mp P.2) hf + +-/-- **`class(relNorm 𝔭) = class(comap 𝔭)` for a maximal prime of residue degree one** +-(Silverman III.4.10(a), `f = 1`; class-group form). The `ClassGroup.mk0` class of `relNorm0 P` is +-the class of the contraction `comap (algebraMap R S) P`. + +-This is the residue-degree-`1` content that bridges the divisor pushforward `φ_* = relNorm` +-(`classNorm`) with the set-theoretic point image `comap` (the shipped `toClass_toPointMap`), pinning +-the `Pic⁰` naturality `hnat` at a rational point. The `comap`-nonzero membership proof is supplied +-via `Ideal.under_ne_bot`. -/ + theorem ClassGroup.mk0_relNorm0_eq_mk0_comap_of_inertiaDeg_one + (P : (Ideal S)⁰) [hPmax : (P : Ideal S).IsMaximal] +- (hf : Ideal.inertiaDeg' ((P : Ideal S).under R) (P : Ideal S) = 1) ++ (hf : (P : Ideal S).inertiaDeg R = 1) + (hcomap : Ideal.comap (algebraMap R S) (P : Ideal S) ∈ (Ideal R)⁰) : + ClassGroup.mk0 (relNorm0 (R := R) (S := S) P) = + ClassGroup.mk0 (⟨Ideal.comap (algebraMap R S) (P : Ideal S), hcomap⟩ : (Ideal R)⁰) := + congrArg ClassGroup.mk0 (Subtype.ext (relNorm0_eq_comap_of_inertiaDeg_one (R := R) (S := S) P hf)) + +-/-! ### `inertiaDeg' = 1` at a residue-degree-one prime, for an `F`-algebra self-map `R →ₐ[F] R` + +-The residue/inertia degree `f = inertiaDeg' (M.under R) M = finrank (R ⧸ M.under R) (R ⧸ M)` is `1` +-whenever the residue field `R ⧸ M` is *one-dimensional over the ground field `F`* (an `F`-rational +-point: `R ⧸ M ≅ F`). This is Silverman III.4.10(a) `f = 1`: at a rational point the inseparability +-of an `F`-algebra self-map `g : R →ₐ[F] R` (e.g. Frobenius) lives entirely in the **ramification** +-`e`, never in `f`. +- +-The proof is **diamond-free** (it does *not* invoke `finrank_mul_finrank`, which is what blocks the +-`Module.Free` "Piece 9" route in `Curves/GenericFiber.lean`): it bounds +-`finrank (R ⧸ M.under R) (R ⧸ M) ≤ 1` directly by surjectivity of the residue-field algebra map. +-That surjectivity holds because `g` is an `F`-algebra hom — so it fixes the image of `F`, and +-`algebraMap F (R ⧸ M)` is already surjective when `finrank F (R ⧸ M) = 1`; hence every residue class +-is hit by a *constant* `algebraMap F (R ⧸ M.under R) c`. Positivity (`finrank ≥ 1`) is +-`Module.finrank_pos` (the residue extension is finite + nontrivial). ++-- The residue-field `finrank` bookkeeping (surjectivity bound + tower) needs more elaboration room. + +-`g` need only be *module-finite over itself through `g`* (`hfin`) for `M.under R` to be maximal +-(going-up / `Algebra.IsIntegral.of_finite`); this is exactly the `Module.Finite` witness an +-`Isogeny.CoordHom` already carries. -/ + +--- The twisted self-algebra `R →[g] R` pushes instance synthesis past the default budget. +--- The residue-field `finrank` bookkeeping (surjectivity bound + tower) needs more elaboration room. +-/-- **`inertiaDeg' = 1` at a rational point, for an `F`-algebra self-map** (Silverman III.4.10(a), +-`f = 1`). For an `F`-algebra `R`, an `F`-algebra hom `g : R →ₐ[F] R` that is module-finite over +-itself through `g`, and a maximal ideal `M` whose residue field is one-dimensional over `F` +-(`finrank F (R ⧸ M) = 1`, the `F`-rational condition), the inertia degree of `M.under R` (the +-contraction `comap g M`) under `M` is `1`. +- +-Diamond-free (no `finrank_mul_finrank`): see the section note. This is the missing `f = 1` input +-that, via `Ideal.relNorm_eq_under_of_inertiaDeg_one`, collapses `relNorm 𝔪 = comap 𝔪` at rational +-points — the residue-degree content of the `Pic⁰` naturality `hnat`. -/ + theorem Ideal.inertiaDeg_under_eq_one_of_algHom_of_residueField_finrank_one + {F : Type*} [Field F] {R : Type*} [CommRing R] [Algebra F R] (g : R →ₐ[F] R) + (hfin : @Module.Finite R R _ _ g.toRingHom.toAlgebra.toModule) + (M : Ideal R) [hM : M.IsMaximal] + (hres : Module.finrank F (R ⧸ M) = 1) : + letI : Algebra R R := g.toRingHom.toAlgebra +- Ideal.inertiaDeg' (M.under R) M = 1 := by +- letI inst : Algebra R R := g.toRingHom.toAlgebra +- haveI instFin : @Module.Finite R R _ _ inst.toModule := hfin +- haveI : @Algebra.IsIntegral R R _ _ inst := ++ M.inertiaDeg R = 1 := by ++ let inst : Algebra R R := g.toRingHom.toAlgebra ++ have instFin : @Module.Finite R R _ _ inst.toModule := hfin ++ have : @Algebra.IsIntegral R R _ _ inst := + @Algebra.IsIntegral.of_finite R R _ _ inst instFin + -- The twisted self-algebra is a scalar tower over `F`: `g` fixes the image of `F`. +- haveI hst : @IsScalarTower F R R _ inst.toSMul _ := ++ have hst : @IsScalarTower F R R _ inst.toSMul _ := + @IsScalarTower.of_algebraMap_eq F R R _ _ _ _ inst _ fun c ↦ by + change algebraMap F R c = g.toRingHom (algebraMap F R c) + rw [show g.toRingHom (algebraMap F R c) = g (algebraMap F R c) from rfl, AlgHom.commutes] +- haveI : M.LiesOver (M.under R) := Ideal.over_under M +- haveI hmax : (M.under R).IsMaximal := Ideal.IsMaximal.under R M +- haveI : Field (R ⧸ M.under R) := Ideal.Quotient.field _ +- rw [Ideal.inertiaDeg'_algebraMap] +- haveI : Nontrivial (R ⧸ M) := Ideal.Quotient.nontrivial_iff.mpr hM.ne_top +- haveI : FiniteDimensional F (R ⧸ M) := Module.finite_of_finrank_eq_succ hres ++ have : M.LiesOver (M.under R) := Ideal.over_under M ++ have hmax : (M.under R).IsMaximal := Ideal.IsMaximal.under R M ++ have : Field (R ⧸ M.under R) := Ideal.Quotient.field _ ++ rw [Ideal.inertiaDeg_eq_of_isMaximal (M.under R) M] ++ have : Nontrivial (R ⧸ M) := Ideal.Quotient.nontrivial_iff.mpr hM.ne_top ++ have : FiniteDimensional F (R ⧸ M) := Module.finite_of_finrank_eq_succ hres + -- `algebraMap F (R ⧸ M)` is surjective: injective `F`-linear map between equal (= 1) finrank. + have hFsurj : Function.Surjective (algebraMap F (R ⧸ M)) := by + have hinj : Function.Injective (Algebra.linearMap F (R ⧸ M)) := +@@ -785,7 +655,7 @@ theorem Ideal.inertiaDeg_under_eq_one_of_algHom_of_residueField_finrank_one + obtain ⟨c₀, hc₀⟩ := hFsurj w + exact ⟨algebraMap F (R ⧸ M.under R) c₀, by + rw [← IsScalarTower.algebraMap_apply F (R ⧸ M.under R) (R ⧸ M), hc₀]⟩ +- haveI hfinMod : Module.Finite (R ⧸ M.under R) (R ⧸ M) := ++ have hfinMod : Module.Finite (R ⧸ M.under R) (R ⧸ M) := + Module.Finite.of_surjective (Algebra.linearMap (R ⧸ M.under R) (R ⧸ M)) + (by intro w; obtain ⟨c, hc⟩ := hsurj w; exact ⟨c, hc⟩) + have h_le : Module.finrank (R ⧸ M.under R) (R ⧸ M) ≤ 1 := +@@ -805,23 +675,6 @@ theorem ClassGroup.relNorm_mul (a b : ClassGroup S) : + ClassGroup.relNorm (R := R) a * ClassGroup.relNorm (R := R) b := + map_mul _ a b + +-/-! +-## The class-group extension (pullback) map and the dual relation +- +-We now build the *extension* direction `ClassGroup R →* ClassGroup S`, induced by +-`Ideal.map (algebraMap R S)` (extend an ideal of `R` to `S`), by exactly the same descent +-technique used for `relNorm`. Composing the relative norm with the extension recovers raising to +-the `n`-th power, where `n = [Frac S : Frac R] = Module.finrank R S` +-(`ClassGroup.relNorm_comp_map`). This is the class-group shadow of the dual-isogeny relation +-`α̂ ∘ α = [deg α]`. +- +-The whole arithmetic core +-`Ideal.relNorm R (Ideal.map (algebraMap R S) I) = I ^ n` +-is already available in mathlib as `Ideal.relNorm_algebraMap` (proved by localising at maximal +-ideals and reducing to `Algebra.norm_algebraMap`); in particular it needs **no** +-separability/Galois/`PerfectField` hypothesis, so the ramification–inertia route is not needed +-here. +--/ + + /-- The extension of an integral ideal, packaged as a homomorphism of `nonZeroDivisors` monoids + `(Ideal R)⁰ →* (Ideal S)⁰`, using that `Ideal.map (algebraMap R S)` sends nonzero ideals to nonzero +@@ -844,12 +697,12 @@ noncomputable def map0 : (Ideal R)⁰ →* (Ideal S)⁰ where + noncomputable def mk0CompMap0 : (Ideal R)⁰ →* ClassGroup S := + (ClassGroup.mk0 (R := S)).comp map0 + +-omit [IsIntegrallyClosed R] [IsDedekindDomain R] [IsIntegrallyClosed S] [Module.Finite R S] in ++omit [Module.Finite R S] in + @[simp] + theorem mk0CompMap0_apply (I : (Ideal R)⁰) : + mk0CompMap0 (S := S) I = ClassGroup.mk0 (map0 I) := rfl + +-omit [IsIntegrallyClosed R] [IsIntegrallyClosed S] [Module.Finite R S] in ++omit [Module.Finite R S] in + /-- Well-definedness of the descent: if two integral ideals of `R` have the same class in + `ClassGroup R`, their extensions have the same class in `ClassGroup S`. + +@@ -893,7 +746,7 @@ noncomputable def ClassGroup.map : ClassGroup R →* ClassGroup S where + Function.surjInv_eq ClassGroup.mk0_surjective, + Function.surjInv_eq ClassGroup.mk0_surjective] + +-omit [IsIntegrallyClosed R] [IsIntegrallyClosed S] [Module.Finite R S] in ++omit [Module.Finite R S] in + /-- The defining computation of `ClassGroup.map` on an integral representative: the extension of the + class of `I` is the class of `Ideal.map (algebraMap R S) I` (which lies in `(Ideal S)⁰` by + `Ideal.map_eq_bot_iff_of_injective`, here packaged as `map0 I`). -/ +@@ -903,39 +756,24 @@ theorem ClassGroup.map_mk0 (I : (Ideal R)⁰) : + refine (mk0CompMap0_eq_of_mk0_eq ?_).trans (mk0CompMap0_apply I) + rw [Function.surjInv_eq ClassGroup.mk0_surjective] + +-omit [IsIntegrallyClosed R] [IsIntegrallyClosed S] [Module.Finite R S] in ++omit [Module.Finite R S] in + /-- `map_one` sanity check: the extension of the trivial class is trivial. -/ + theorem ClassGroup.map_one : ClassGroup.map (R := R) (S := S) 1 = 1 := + _root_.map_one _ + +-omit [IsIntegrallyClosed R] [IsIntegrallyClosed S] [Module.Finite R S] in ++omit [Module.Finite R S] in + /-- `map_mul` sanity check: the extension map is multiplicative. -/ + theorem ClassGroup.map_mul (a b : ClassGroup R) : + ClassGroup.map (S := S) (a * b) = + ClassGroup.map (S := S) a * ClassGroup.map (S := S) b := + _root_.map_mul _ a b + +-/-- The **ideal-level arithmetic core** of the dual relation: the relative norm of the extension of +-an integral ideal `I` of `R` is `I ^ n`, where `n = Module.finrank R S`. + +-Since mathlib moved `Ideal.relNorm_algebraMap`'s exponent from +-`Module.finrank (FractionRing R) (FractionRing S)` to `Module.finrank R S`, this is now *literally* +-that lemma — the fraction-field transport it used to perform is gone. Kept as the name the +-class-group descent below cites; a cleanup pass can inline it. -/ + theorem Ideal.relNorm_map_algebraMap (I : Ideal R) : + Ideal.relNorm R (Ideal.map (algebraMap R S) I) = I ^ Module.finrank R S := + Ideal.relNorm_algebraMap S I + +-/-- **The target: the dual relation at the class-group level.** +- +-The composite of the class-group extension map with the relative norm is raising to the `n`-th +-power, where `n = Module.finrank R S = [Frac S : Frac R]`: +-`relNorm (map c) = c ^ n` for every `c : ClassGroup R`. This is the arithmetic core, on ideal +-classes, of `α̂ ∘ α = [deg α]`. + +-The proof picks an integral representative `c = mk0 I` (`ClassGroup.mk0_surjective`), computes both +-descents with `ClassGroup.map_mk0` and `ClassGroup.relNorm_mk0`, and reduces to the ideal-level +-identity `Ideal.relNorm_map_algebraMap`. Compatibility of `mk0` with `(· ^ n)` is `map_pow`. -/ + theorem ClassGroup.relNorm_comp_map (c : ClassGroup R) : + ClassGroup.relNorm (ClassGroup.map (S := S) c) = c ^ Module.finrank R S := by + obtain ⟨I, rfl⟩ := ClassGroup.mk0_surjective c +diff --git a/projects/HasseWeil/HasseWeil/Pic0/PicDual.lean b/projects/HasseWeil/HasseWeil/Pic0/PicDual.lean +index d0543c22f..40854d96f 100644 +--- a/projects/HasseWeil/HasseWeil/Pic0/PicDual.lean ++++ b/projects/HasseWeil/HasseWeil/Pic0/PicDual.lean +@@ -8,68 +8,22 @@ import HasseWeil.Pic0.ToClassSurjective + import HasseWeil.Foundation.Basic + + /-! +-# The Pic⁰ dual isogeny and the dual relation `α ∘ α̂ = [deg α]` (Silverman III.6.1) +- +-For an endomorphism `α : Isogeny E E` of an elliptic curve `E`, equipped with a coordinate-ring +-restriction witness `ch : α.CoordHom` (the comorphism `α* : R → R` on `R := E.CoordinateRing`), +-this file builds the **Pic⁰ dual** as a point endomorphism and proves the dual relation, following +-**Silverman, *The Arithmetic of Elliptic Curves*, III.6.1** *to the letter*. +- +-## Silverman III.6.1 (verified against the in-repo PDF, book p.80–82) +- +-Let `κ : E ≅ Pic⁰(E)`, `P ↦ class of `(P) − (O)``. Silverman III.6.1(b) **defines** the dual via +-the **divisor pullback** `φ*` (II.3.6/II.3.7): +- +-``` +- κ φ* κ⁻¹ +- φ̂ : E ───→ Pic⁰(E) ───→ Pic⁰(E) ───→ E , +-``` +- +-i.e. `φ̂ = κ⁻¹ ∘ φ* ∘ κ`, where `φ* : Pic⁰(E) → Pic⁰(E)` is the **pullback** of divisor classes +-`(Q) ↦ Σ_{P ↦ Q} e_φ(P)·(P)` (Silverman II.3, book p.29). At the level of the affine ideal class +-group `Pic⁰(E) ≅ ClassGroup R`, this pullback is the **ideal extension** `𝔪_Q ↦ 𝔪_Q·𝒪 = ∏ 𝔓^{e}`, +-which is exactly the shipped `HasseWeil.Isogeny.classMap` (= `HasseWeil.ClassGroup.map`). +- +-The companion **divisor pushforward** `φ_*` (II.3.6/II.3.7), `(P) ↦ (φP)`, is at the ideal level the +-**relative norm** `𝔓 ↦ 𝔮^{f}`, the shipped `HasseWeil.Isogeny.classNorm` (= `ClassGroup.relNorm`). +-Silverman II.3.6(e) gives `φ_* ∘ φ* = [deg φ]` on `Pic⁰`; its shipped shadow is +-`HasseWeil.Isogeny.classNorm_comp_classMap` (`classNorm (classMap c) = c ^ finrank R R`). +- +-## Main definitions +- +-* `HasseWeil.Isogeny.picDual` — `φ̂ = κ⁻¹ ∘ classMap ∘ κ` as a point endomorphism `E.Point →+ +- E.Point` (the III.6.1(b) construction; `classMap` = extension = the divisor pullback `φ*`). +-* `HasseWeil.Isogeny.picPushforward` — `κ⁻¹ ∘ classNorm ∘ κ`, the κ-transport of the divisor +- pushforward `φ_*` (= `classNorm` = relative norm). +- +-## Main results +- +-* `HasseWeil.Isogeny.picPushforward_comp_picDual` / `..._degree` — **unconditional** (modulo the +- carried `CoordHom`/`Module.Finite`/tower witnesses): the κ-transport of Silverman II.3.6(e), +- `picPushforward ∘ picDual = [finrank R R]` (resp. `= [α.degree]`), as `AddMonoidHom`s. +-* `HasseWeil.Isogeny.toAddMonoidHom_comp_picDual` — **the III.6.1 target** `α ∘ α̂ = [deg α]` +- (`α.toAddMonoidHom.comp α.picDual = [α.degree]`), carrying the III.3.4 **naturality** of `κ` on +- the point map (`hnat : κ ∘ α = classNorm ∘ κ`) as a witness-parametric hypothesis. +-* `HasseWeil.Isogeny.picDual_comp_toAddMonoidHom` — the companion `α̂ ∘ α = [deg α]` +- (III.6.2(a) order), under the same naturality witness. +- +-## Why the III.3.4 naturality is a *carried hypothesis*, not derived +- +-The unconditional results above tie `picDual` to `picPushforward` (both κ-transports), with **no** +-extra input. Identifying `picPushforward` with the *actual* point map `α.toAddMonoidHom` is the +-**III.3.4 naturality** `κ ∘ α = classNorm ∘ κ` (i.e. `κ₂(αP) = φ_*κ₁(P)`). As documented in +-`HasseWeil/Pic0/ToClassFunctorial.lean`, the point-map ↔ ideal-map link the shipped API exposes is +-the **`comap`** (set-theoretic point image), which on a prime `𝔓 / 𝔮` gives `𝔮`, whereas the +-pushforward `φ_* = relNorm` gives `𝔮^{f}` — they differ by the **inertia/residue degree** `f`. +-Bridging them is exactly the ramification bookkeeping `relNorm (comap …) = (·)^?` +-(`relNorm_eq_pow_of_isMaximal`, needing `PerfectField (FractionRing R)`), the III.3.4 content the +-`Isogeny` carries as *independent data*. It is therefore taken as a hypothesis here (dischargeable +-per isogeny: Frobenius, multiplication-by-`n`), keeping every theorem `#print axioms`-clean. ++# The Picard dual isogeny ++ ++For an elliptic-curve endomorphism `α` with a coordinate-ring comorphism, ++transporting ideal extension along `κ : E ≃ Pic⁰(E)` defines the Picard dual. ++Transporting the relative ideal norm defines the point-group pushforward. ++The norm–extension identity gives `picPushforward ∘ picDual = [deg α]`. ++Under the naturality relation between the point map and `κ`, this yields ++`α ∘ α̂ = [deg α]`; surjectivity gives the companion relation by cancellation. ++ ++At rational points, residue degree one identifies the relative ideal norm ++with contraction. This proves the corresponding naturality reduction ++without a perfectness assumption on the function field. + + ## References + +-* [Silverman, *The Arithmetic of Elliptic Curves*], II.3.6–3.7 (divisor pullback/pushforward, +- `φ_*φ* = [deg]`), III.3.4 (functoriality of `E ≅ Pic⁰(E)`), III.6.1 (the dual isogeny). ++* [Silverman, *The Arithmetic of Elliptic Curves*], II.3.6–3.7, III.3.4, III.6.1. + -/ + + open WeierstrassCurve Polynomial +@@ -114,7 +68,7 @@ Silverman's **divisor pullback** `φ* : Pic⁰(E) → Pic⁰(E)`. This is *exac + definition `φ̂ = κ₁⁻¹ ∘ φ* ∘ κ₂`. + + The `CoordHom` witness `ch`, injectivity `hinj`, and finiteness `hfin` are the data/hypotheses the +-shipped `classMap` requires (carried, not discharged universally — instantiable per isogeny). -/ ++`classMap` requires (carried, not discharged universally — instantiable per isogeny). -/ + noncomputable def picDual (ch : α.CoordHom) (hinj : Function.Injective ch.toAlgHom) + (hfin : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule) : + E.Point →+ E.Point := +@@ -188,7 +142,7 @@ theorem classTransport_comp_eq + + /-! ### The dual relation `φ_* ∘ φ* = [deg]`, transported to the point group + +-Silverman II.3.6(e): `φ_* ∘ φ* = [deg φ]` on `Pic⁰(E)`. Its shipped class-group shadow is ++Silverman II.3.6(e): `φ_* ∘ φ* = [deg φ]` on `Pic⁰(E)`. Its class-group shadow is + `classNorm_comp_classMap` (`classNorm (classMap c) = c ^ finrank R R`). We transport it across `κ` + to obtain `picPushforward ∘ picDual = [finrank R R]` as point endomorphisms — **unconditionally** + (beyond the carried `CoordHom`/`Module.Finite` witnesses the `classMap`/`classNorm` already need). +@@ -196,7 +150,7 @@ The `α.degree` form follows from the degree bridge `classNorm_comp_classMap_deg + + /-- **κ-transport of `φ_* ∘ φ* = [deg]` (coordinate-ring `finrank` form).** + +-`picPushforward ∘ picDual = [finrank R R]` as point endomorphisms, the κ-conjugate of the shipped ++`picPushforward ∘ picDual = [finrank R R]` as point endomorphisms, the κ-conjugate of the + class-group identity `classNorm (classMap c) = c ^ finrank R R` (= Silverman II.3.6(e) + `φ_* ∘ φ* = [deg]`). Unconditional beyond the carried `CoordHom`/`Module.Finite` witnesses. + +@@ -210,7 +164,7 @@ theorem picPushforward_comp_picDual (ch : α.CoordHom) (hinj : Function.Injectiv + ((@Module.finrank E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule : ℕ) : + ℤ))).toAddMonoidHom := + -- `picPushforward ∘ picDual = classTransport classNorm ∘ classTransport classMap`, and +- -- `classNorm (classMap c) = c ^ finrank` is the shipped `classNorm_comp_classMap`. ++ -- `classNorm (classMap c) = c ^ finrank` is the `classNorm_comp_classMap`. + classTransport_comp_eq (α.classMap ch hinj hfin) (α.classNorm ch hinj hfin) _ + (α.classNorm_comp_classMap ch hinj hfin) + +@@ -238,19 +192,12 @@ theorem picPushforward_comp_picDual_degree (ch : α.CoordHom) + congr 2 + exact_mod_cast (α.degree_eq_finrank_coordinateRing_of_tower_eq ch S S' hSR hS'FF).symm + +-/-! ### The III.6.1 target `α ∘ α̂ = [deg α]` on the point group ++/-! ### The dual relation on the point group + +-The unconditional `picPushforward_comp_picDual` ties `picDual` to `picPushforward`. To reach the +-brief's target `α ∘ α̂ = [deg α]` — with the *actual* point map `α.toAddMonoidHom` — we additionally +-need the **Silverman III.3.4 naturality** of `κ` on the point map: that under `κ`, the point map +-`α.toAddMonoidHom` corresponds to the divisor pushforward `φ_*` (= `classNorm`). In the κ-conjugate +-form, this is exactly `α.toAddMonoidHom = α.picPushforward …`. +- +-As documented in `HasseWeil/Pic0/ToClassFunctorial.lean`, the shipped point-map ↔ ideal-map link is +-the **`comap`** (set-theoretic point image), which differs from `φ_* = relNorm` by the residue +-degree; bridging them is the III.3.4 ramification bookkeeping the `Isogeny` carries as independent +-data. We therefore take the naturality as a witness-parametric hypothesis (dischargeable per +-isogeny), keeping the result `#print axioms`-clean. -/ ++The relation between the Picard dual and Picard pushforward yields the ++point-group dual relation under the naturality condition ++`κ (α P) = classNorm (κ P)`. The relative norm differs from contraction by the ++residue degree; for rational points this degree is one. -/ + + /-- **The III.3.4 naturality witness, raw form**: under `κ = toClassEquiv'`, the point map of `α` + corresponds to the relative-norm class map `classNorm` (the divisor pushforward `φ_*`): +@@ -279,44 +226,14 @@ theorem toAddMonoidHom_eq_picPushforward_iff (ch : α.CoordHom) + rw [picPushforward_apply, ← h P, + (WeierstrassCurve.Affine.Point.toClassEquiv' (W := E)).symm_apply_apply] + +-/-! #### Isolating the `hnat` residual to the rational-point ideal identity (`comap = relNorm`) +- +-`Naturality` is structurally a **carried datum**: an abstract `Isogeny E E` stores its `pullback` +-and `toAddMonoidHom` as *independent* fields (`HasseWeil/Basic.lean`), with no derivation linking +-the point map to the comorphism `ch` — so `hnat` cannot be proved in general, only verified per +-isogeny where both fields are explicit (Frobenius, mult-by-`n`). +- +-What we *can* ship axiom-clean is the exact reduction of the **right-hand side** of `Naturality` to +-a concrete ideal class. The RHS `classNorm (κ P)` for a rational point `P = (x, y)` is the `mk0` +-class of the **relative norm** `relNorm (maximalIdealAt P) = relNorm ⟨X − x, Y − y⟩` (Silverman's +-divisor pushforward `φ_*`). Combined with the shipped `ToClassFunctorial.toClass_toPointMap` +-(whose ideal is the **`comap`** `α*⁻¹(maximalIdealAt P)`), this pins the *entire* remaining content +-of `hnat` to the single residue-degree identity +- +-``` +-class (relNorm (maximalIdealAt P)) = class (comap α* (maximalIdealAt P)) (rational P) +-``` +- +-which holds because a rational point has residue degree `f = 1`, so `relNorm 𝔪_P = 𝔪_P ∩ R = +-comap α* 𝔪_P` (for `f = 1`, `relNorm 𝔭 = (comap 𝔭)^f = comap 𝔭`). Mathlib has no +-`relNorm = (comap)^{inertiaDeg'}` lemma (and the project's `inertiaDeg' = 1`-at-smooth-points +-computation is `Module.Free`-diamond-blocked, see `Curves/GenericFiber.lean` Piece 9), so this last +-step stays a per-isogeny obligation; the lemma below is the bridge that *reduces to it*. -/ +- +-/-- **The `classNorm`/`κ` side of `Naturality`, evaluated at a rational point (axiom-clean +-bridge).** +- +-For a rational point `P = (x, y)` (a mathlib `Point.some`), the value of the relative-norm class map +-`classNorm` on `κ P = toClassEquiv' P` is the `mk0` class of the **relative ideal norm** of the +-maximal ideal `XYIdeal E x (C y) = ⟨X − x, Y − y⟩` at `P` (= Silverman's divisor pushforward `φ_*`, +-packaged as `relNorm0`). This unfolds the *right-hand side* of the III.3.4 naturality predicate +-`Naturality` at `Point.some`, reducing the whole `hnat` obligation to the ideal-class identity +-`class (relNorm 𝔪_P) = class (comap α* 𝔪_P)` against the shipped `toClass_toPointMap` (the +-`comap` form) — exactly the residue-degree-`1` content (see the section note). +- +-Proof: `κ (some) = toClass (some) = mk (XYIdeal' h) = mk0 ⟨XYIdeal, _⟩` (the project's +-`mk0_eq_mk_XYIdeal'` bridge), then `ClassGroup.relNorm_mk0` computes the norm on the integral +-representative. -/ ++/-! #### Naturality at rational points ++ ++For a rational point `P`, `classNorm (κ P)` is represented by the relative ++norm of its maximal ideal. Residue degree one identifies this norm with the ++contraction under the coordinate-ring comorphism. Thus naturality reduces ++to agreement between the given point map and the contracted ideal class. -/ ++ ++/-- The relative-norm class map on a rational point is represented by the relative norm of its maximal ideal. -/ + theorem classNorm_toClassEquiv'_some (ch : α.CoordHom) (hinj : Function.Injective ch.toAlgHom) + (hfin : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule) + {x y : F} (h : E.Nonsingular x y) +@@ -331,9 +248,9 @@ theorem classNorm_toClassEquiv'_some (ch : α.CoordHom) (hinj : Function.Injecti + ch.isTorsionFree hinj + ClassGroup.mk0 (HasseWeil.relNorm0 (R := E.CoordinateRing) (S := E.CoordinateRing) + ⟨WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y), hmem⟩) := by +- letI := ch.toAlgebra +- haveI : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin +- haveI : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := ++ let := ch.toAlgebra ++ have : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin ++ have : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := + ch.isTorsionFree hinj + rw [WeierstrassCurve.Affine.Point.toClassEquiv'_apply, + WeierstrassCurve.Affine.Point.toClass_some, +@@ -341,23 +258,11 @@ theorem classNorm_toClassEquiv'_some (ch : α.CoordHom) (hinj : Function.Injecti + show HasseWeil.ClassGroup.relNorm (ClassGroup.mk0 _) = _ + rw [HasseWeil.ClassGroup.relNorm_mk0] + +-/-! #### Discharging `hnat`: the residue-degree-`1` (`comap = relNorm`) step at rational points +- +-Combining the shipped `classNorm_toClassEquiv'_some` (the `relNorm0` form of the `Naturality` RHS) +-with the residue-degree bridge of `ClassGroupNorm` (`relNorm 𝔪 = comap 𝔪` at `inertiaDeg' = 1`, the +-`inertiaDeg' = 1` itself supplied **diamond-free** by +-`Ideal`.`inertiaDeg_under_eq_one_of_algHom_…`), +-we reduce the entire `hnat`/`Naturality` obligation to the **point-map ↔ `comap` agreement** — that +-the actual point map `α.toAddMonoidHom` sends `(x, y)` to a point whose `κ`-class is the contraction +-`comap α* 𝔪_{(x,y)}` (Silverman III.3.4, the `comap` form shipped as `toClass_toPointMap`). ++/-! #### The residue-degree-one norm identity + +-The residue-degree step needs `PerfectField (FractionRing R) = PerfectField K(E)` (the hypothesis of +-mathlib's `Ideal.relNorm_eq_pow_of_isMaximal`). This holds for perfect base fields (e.g. `char 0`, +-or algebraically closed of characteristic `0`). **Honest residual:** for a function field over a +-*finite* field `K(E)` is *imperfect*, so this last `relNorm = comap` step is not covered by the +-mathlib lemma there; pinning the exponent without `PerfectField`/Galois would require a degree-count +-adaptation of the project's `relNorm_maximalIdealAt` (`Curves/NormValuation.lean`) to the twisted +-`R →[α*] R` extension. Everything *below* the `PerfectField` hypothesis is unconditional. -/ ++The rational-point residue field has rank one over the base field. The ++class-group norm identity at residue degree one then identifies relative ++norm with contraction, without assuming the function field is perfect. -/ + + /-- **The `comap α* 𝔪_P` ideal is a nonzero divisor** (carried side condition for the `mk0` class). + For a rational point `P = (x, y)`, the contraction `comap α* (XYIdeal E x (C y))` of the (nonzero) +@@ -371,36 +276,16 @@ theorem comap_XYIdeal_mem_nonZeroDivisors (ch : α.CoordHom) + Ideal.comap ch.toAlgHom.toRingHom + (WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y)) ∈ + (Ideal E.CoordinateRing)⁰ := by +- letI := ch.toAlgebra +- haveI : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin +- haveI : Algebra.IsIntegral E.CoordinateRing E.CoordinateRing := ++ let := ch.toAlgebra ++ have : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin ++ have : Algebra.IsIntegral E.CoordinateRing E.CoordinateRing := + Algebra.IsIntegral.of_finite _ _ + have hbot : WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y) ≠ ⊥ := + mem_nonZeroDivisors_iff_ne_zero.mp hmem + exact mem_nonZeroDivisors_iff_ne_zero.mpr + (Ideal.under_ne_bot (A := E.CoordinateRing) (B := E.CoordinateRing) hbot) + +-/-- **The `classNorm`/`comap` identity at a rational point (residue degree `1`) — UNCONDITIONAL.** +- +-For a rational point `P = (x, y)` and a coordinate-ring restriction `ch`, the relative-norm class +-`classNorm0 (XYIdeal E x (C y))` (the `Naturality` RHS, via `classNorm_toClassEquiv'_some`) equals +-the class of the **contraction** `comap α* (XYIdeal E x (C y))` — Silverman's divisor pushforward +-`φ_*` collapses to the set-theoretic point image at a rational point, where the residue degree +-`f = 1`. +- +-**`PerfectField`-free.** Mathlib's `Ideal.relNorm_eq_pow_of_isMaximal` is gated on +-`[PerfectField (FractionRing R)]` (its proof reduces to the Galois case, which fails for a function +-field over a finite base), but that hypothesis is *not* needed at `f = 1`: the shipped +-`ClassGroup.mk0_relNorm0_eq_mk0_comap_of_inertiaDeg_one` (`ClassGroupNorm.lean`) discharges +-`relNorm 𝔪 = comap 𝔪` from `inertiaDeg' = 1` alone via the module-length / DVR-base route, with +-**no** +-`PerfectField`. This removes the previous `[PerfectField E.FunctionField]` hypothesis. +- +-Proof: `XYIdeal` is maximal (`quotientXYIdealEquiv`) with residue field `F` (so `finrank F (R/𝔪) = +-1`), hence `inertiaDeg' (𝔪.under R) 𝔪 = 1` +-(`Ideal.inertiaDeg_under_eq_one_of_algHom_of_residueField_finrank_one`, diamond-free); then +-`ClassGroup.mk0_relNorm0_eq_mk0_comap_of_inertiaDeg_one` (`relNorm 𝔪 = comap 𝔪` under `f = 1`, +-unconditional) finishes. -/ ++/-- At a rational point, residue degree one identifies the relative-norm ideal class with the contracted ideal class. -/ + theorem mk0_relNorm0_XYIdeal_eq_mk0_comap + (ch : α.CoordHom) (hinj : Function.Injective ch.toAlgHom) + (hfin : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule) +@@ -419,18 +304,16 @@ theorem mk0_relNorm0_XYIdeal_eq_mk0_comap + ClassGroup.mk0 (⟨Ideal.comap ch.toAlgHom.toRingHom + (WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y)), hcomap⟩ : + (Ideal E.CoordinateRing)⁰) := by +- letI := ch.toAlgebra +- haveI : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin +- haveI : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := ++ let := ch.toAlgebra ++ have : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := hfin ++ have : @Module.IsTorsionFree E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule := + ch.isTorsionFree hinj +- haveI hMmax : (WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y)).IsMaximal := ++ have hMmax : (WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y)).IsMaximal := + Ideal.Quotient.maximal_of_isField _ + ((WeierstrassCurve.Affine.CoordinateRing.quotientXYIdealEquiv h.1).toRingEquiv.isField + (Field.toIsField F)) +- have hf : Ideal.inertiaDeg' +- ((WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y)).under +- E.CoordinateRing) +- (WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x (Polynomial.C y)) = 1 := ++ have hf : (WeierstrassCurve.Affine.CoordinateRing.XYIdeal E x ++ (Polynomial.C y)).inertiaDeg E.CoordinateRing = 1 := + Ideal.inertiaDeg_under_eq_one_of_algHom_of_residueField_finrank_one ch.toAlgHom hfin _ + (WeierstrassCurve.Affine.Point.finrank_quotient_XYIdeal_eq_one h.1) + exact ClassGroup.mk0_relNorm0_eq_mk0_comap_of_inertiaDeg_one +@@ -484,21 +367,7 @@ theorem Naturality_of_toClassEquiv'_some_eq_relNorm0 + rw [classNorm_toClassEquiv'_some ch hinj hfin h hmem] + exact hpoint x y h hmem + +-/-- **Discharging `hnat` from point-map ↔ `comap` agreement (residue degree `1`) — UNCONDITIONAL.** +- +-The `Naturality` predicate `hnat` holds whenever, for every rational point `P = (x, y)`, the actual +-point map `α.toAddMonoidHom` sends `(x, y)` to a point whose `κ`-class is the contraction +-`comap α* 𝔪_{(x,y)}` (the `comap` form of Silverman III.3.4 — exactly what `toClass_toPointMap` +-supplies for a *geometric* isogeny whose point map is `toPointMap`). This is the precise reduction +-of `hnat` to its remaining content: the `relNorm`-vs-`comap` gap is closed here by the residue +-identity `mk0_relNorm0_XYIdeal_eq_mk0_comap`, which is now **`PerfectField`-free** (it routes +-through +-the shipped `ClassGroup.mk0_relNorm0_eq_mk0_comap_of_inertiaDeg_one`, valid at `f = 1` with no +-`PerfectField`). **No `PerfectField E.FunctionField` hypothesis** — the only residual is the +-point-map ↔ `comap` agreement `hpoint`, i.e. Silverman III.3.4 for the *actual* point map (supplied +-per isogeny by `toClass_toPointMap` whenever the point map is the geometric `toPointMap`). +- +-The basepoint case is automatic (`κ 0 = 0 = ofMul (classNorm 1)`). -/ ++/-- Agreement of the point map with contracted rational-point ideal classes implies naturality of the Picard identification. -/ + theorem Naturality_of_toClassEquiv'_some_eq_comap + (ch : α.CoordHom) (hinj : Function.Injective ch.toAlgHom) + (hfin : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule) +@@ -536,25 +405,7 @@ theorem Naturality_of_toClassEquiv'_some_eq_comap + mk0_relNorm0_XYIdeal_eq_mk0_comap ch hinj hfin h hmem hcomap] + exact hpoint x y h hcomap + +-/-- **UNCONDITIONAL `Naturality` from a `CoordHom` (Silverman III.3.4) — the `hnat` discharge.** +- +-Given a coordinate-ring restriction `ch : α.CoordHom` and the **single genuine residual** that the +-actual point map `α.toAddMonoidHom` realises the III.3.4 *set-theoretic point image* — i.e. for each +-rational `(x, y)` the `κ`-class of `α.toAddMonoidHom (x, y)` is the contraction `comap α* 𝔪_{(x,y)}` +-(`hpoint`, exactly what the shipped `toClass_toPointMap` supplies for an isogeny whose point map is +-the geometric `toPointMap`) — the full naturality `α.Naturality ch hinj hfin` holds. +- +-This is the **unconditional** wiring requested for the Route-C `hnat` discharge: it threads the +-divisor-pushforward RHS (`classNorm_toClassEquiv'_some`) through the residue-degree-`1` +-identity `relNorm 𝔪 = comap 𝔪`, now **`PerfectField`-free** (`mk0_relNorm0_XYIdeal_eq_mk0_comap` → +-`ClassGroup.mk0_relNorm0_eq_mk0_comap_of_inertiaDeg_one`, `inertiaDeg' = 1` from +-`Ideal.inertiaDeg_under_eq_one_of_algHom_of_residueField_finrank_one`). The `relNorm`-vs-`comap` +-residue bookkeeping is *fully discharged*; the only carried datum is `hpoint`, the point-map ↔ +-`comap` agreement (Silverman III.3.4 for the actual point map), which is the genuine per-isogeny / +-base-change content (CoordHom data) — **not** a `PerfectField`/Galois obligation. +- +-Identical statement to `Naturality_of_toClassEquiv'_some_eq_comap`; provided under the +-`naturality_of_coordHom` name the Route-C assembly consumes. -/ ++/-- Naturality follows from the coordinate-ring comorphism and its agreement with the rational-point map. -/ + theorem naturality_of_coordHom + (ch : α.CoordHom) (hinj : Function.Injective ch.toAlgHom) + (hfin : @Module.Finite E.CoordinateRing E.CoordinateRing _ _ ch.toAlgebra.toModule) +@@ -617,7 +468,7 @@ for `β = φ + ψ`. At the point level, with the III.3.4 naturality + composite `picDual ∘ α.toAddMonoidHom` is `κ⁻¹ ∘ (classMap ∘ classNorm) ∘ κ`. + + **Honest scope note.** This is `φ* ∘ φ_*` (extension after norm) — the **opposite** order to the +-shipped `classNorm_comp_classMap` (`classNorm ∘ classMap = φ_* ∘ φ*`). The two orders are *not* ++`classNorm_comp_classMap` (`classNorm ∘ classMap = φ_* ∘ φ*`). The two orders are *not* + interchangeable from commutativity of `ClassGroup` alone (`f(g c) = g(f c)` needs `f ∘ g = g ∘ f` + as maps, not a commutative codomain), and mathlib provides only `relNorm_algebraMap` + (`relNorm ∘ map`), **not** `map ∘ relNorm = (·)^n`. The reverse-order class identity +@@ -664,6 +515,7 @@ theorem comp_eq_mulByInt_of_comp_eq_of_surjective + -- `g (f (g Q)) = g (m • Q) = m • g Q`, and the RHS `[m] (g Q) = m • g Q`. + rw [hf, g.map_zsmul, mulByInt_apply] + ++omit [WeierstrassCurve.IsElliptic E] in + /-- **Right-cancellation of a surjective additive point endomorphism (Silverman II.2.3, equality + form).** If `g : E.Point →+ E.Point` is **surjective** and two maps `f₁, f₂` agree after + post-composition with `g` (i.e. `f₁ ∘ g = f₂ ∘ g`), then `f₁ = f₂`. This is the abstract content of +@@ -730,9 +582,9 @@ theorem picDual_comp_toAddMonoidHom_of_surjective_degree (ch : α.CoordHom) + Silverman III.6.1(a)/III.6.2 states the dual is **unique**: `φ̂` is the *only* `δ` with + `δφ = [deg φ]`. The proof is right-cancellation of the surjective (nonconstant) `φ`. We give the + point-map form: +-from `(picDual α) ∘ α = [deg α]` (the shipped `picDual_comp_toAddMonoidHom_of_surjective`) and any ++from `(picDual α) ∘ α = [deg α]` (the `picDual_comp_toAddMonoidHom_of_surjective`) and any + hypothetical `β` with `β ∘ α = [deg α]`, the surjection `α` cancels on the right to force +-`picDual α = β`. Specialising `β` to the κ-transport of a *shipped* dual isogeny (e.g. the ++`picDual α = β`. Specialising `β` to the κ-transport of a dual isogeny (e.g. the + Verschiebung `V` of Frobenius `π`, with `V ∘ π = [q]` from `IsDualOf V π`) **identifies `picDual π` + with `V`** — the milestone "Pic⁰ dual of Frobenius = Verschiebung". -/ + +@@ -796,26 +648,23 @@ theorem picDual_eq_of_comp_toAddMonoidHom_eq_degree (ch : α.CoordHom) + ((picDual_comp_toAddMonoidHom_of_surjective_degree ch hinj hfin hnat hsurjDual + S S' hSR hS'FF).trans hβ.symm) + +-/-! #### Non-circular `picDual` of a *single* isogeny whose degree is independently known ++/-! #### Duals of isogenies with independently known degrees + +-The III.6.1(a) uniqueness `picDual_eq_of_comp_toAddMonoidHom_eq_degree` identifies `picDual α` with +-any point map `δ` satisfying `δ ∘ α = [deg α]` — **non-circularly whenever `deg α` is known +-independently** of the Pic⁰ chain. Two such cases, used to seed the dual algebra for `rπ − s`: ++The uniqueness statement in Silverman III.6.1(a) identifies `picDual α` with ++any point map `δ` satisfying `δ ∘ α = [deg α]`. For Frobenius, its degree ++is the field cardinality `q` and the composition with Verschiebung is `[q]`. ++For scalar multiplication `[n]`, the degree is `n²` and self-composition is ++`[n²]`. + +-* **`picDual π = V`** (Frobenius dual = Verschiebung), where `deg π = #K = q` is shipped +- (`frobeniusIsog_degree`) and `V ∘ π = [q]` comes from `IsDualOf V π`. +-* **`picDual [n] = [n]`** (scalar self-dual, III.6.2(b)/(d)), where `deg [n] = n²` and +- `[n] ∘ [n] = [n²]` are shipped (`mulByInt_degree`, `mulByInt_comp_eq_mul`). +- +-Both are genuinely non-circular: the degree of a *single* Frobenius / scalar is shipped, unlike +-`deg(rπ − s)` (which is the Route-C conclusion). They are the seeds for the dual-additivity step +-`picDual(rπ − s) = rV − s` — whose *combination* nonetheless needs III.6.2(c) (see the note in +-`RouteCGeometric.lean`). -/ ++These degree calculations identify the individual duals without assuming ++the degree formula for `rπ − s`. The further formula ++`picDual(rπ − s) = rV − s` requires dual additivity, Silverman III.6.2(c). ++-/ + + /-- **`picDual α = δ` when `δ ∘ α = [d]` and `α.degree = d` (degree given as data, non-circular).** + +-The III.6.1(a) uniqueness specialised to an *explicit integer degree* `d`: if `α.degree = d` (an +-**independently-shipped** degree, e.g. `frobeniusIsog_degree`, `mulByInt_degree`) and a point map ++The III.6.1(a) uniqueness specialised to an *explicit integer degree* `d`: if `α.degree = d` (a ++**known** degree, e.g. `frobeniusIsog_degree`, `mulByInt_degree`) and a point map + `δ` satisfies `δ ∘ α = [d]`, then `picDual α = δ`. This is the non-circular seed form (it does not + route through the Pic⁰ push-pull degree, only through the *given* `d`). -/ + theorem picDual_eq_of_comp_toAddMonoidHom_eq_of_degree_eq (ch : α.CoordHom) +@@ -847,11 +696,11 @@ The III.6.2(b) dual-of-composition `(φ∘ψ)^ = ψ̂∘φ̂` specialised to `r + `picDual_eq_of_comp_toAddMonoidHom_eq_of_degree_eq` with the **independently-known** degree + `deg(r • α) = deg α · r²` (`Isogeny.zsmul_degree` / `mulByInt_degree`) and the composite + `(r • δ) ∘ (r • α) = r² • (δ ∘ α) = r² • [deg α] = [r² · deg α]`, where `δ` is the dual value of `α` +-(any point map with `δ ∘ α = [deg α]`, e.g. the κ-transport of a shipped `IsDualOf` partner). ++(any point map with `δ ∘ α = [deg α]`, e.g. the κ-transport of a `IsDualOf` partner). + +-This is **non-circular**: it routes only through the *given* degree `deg α` (independently shipped ++This is **non-circular**: it routes only through the *given* degree `deg α` (independently + for a single Frobenius / scalar / `α`), never through the Pic⁰ push-pull degree of `r • α`. It is +-the generic engine behind the Route-C seed `picDual(rπ) = rV` (take `α = π`, `δ = V`, ++the generic engine behind the dual-additivity seed `picDual(rπ) = rV` (take `α = π`, `δ = V`, + `deg π = #K = q`). + + Residuals: the per-`(r • α)` CoordHom data (`chr` + the two surjectivities + tower `(S, S')`), +@@ -898,10 +747,10 @@ theorem picDual_zsmul_eq_zsmul_of_comp_eq + exact picDual_eq_of_comp_toAddMonoidHom_eq_of_degree_eq chr hinjr hfinr hnatr hsurjDualr + hsurjr S S' hSR hS'FF hdeg hcomp + +-/-- **`picDual(r • α) = r • α̂` from a shipped `IsDualOf` partner (route-2 seed, `IsDualOf` form).** ++/-- **`picDual(r • α) = r • α̂` from a `IsDualOf` partner (route-2 seed, `IsDualOf` form).** + + As `picDual_zsmul_eq_zsmul_of_comp_eq`, but taking the dual value of `α` in the *full-isogeny* +-`IsDualOf δ_isog α` form (`δ_isog ∘ α = [deg α]`), which is how the Route-C Vieta bundle supplies it ++`IsDualOf δ_isog α` form (`δ_isog ∘ α = [deg α]`), which is how the dual-additivity Vieta bundle supplies it + (e.g. `IsDualOf V π`). Concludes `picDual(r • α) = r • δ_isog` at the point-map level. -/ + theorem picDual_zsmul_eq_zsmul_of_isDual + {α δ_isog : Isogeny E E} (r : ℤ) (hr : r ≠ 0) +@@ -932,10 +781,10 @@ The Silverman III.8 trace relation `α + α̂ = [tr α]` *determines* `α̂` onc + `δ` satisfies the *same* relation `α + δ = [tr α]`: subtract `α` to get `α̂ = [tr α] − α = δ`. This + is a pure point-group cancellation (no degree, no uniqueness, **non-circular**). + +-It is the final algebraic step of the Route-C dual-additivity output `picDual(rπ−s) = rV − s`: with ++It is the final algebraic step of the dual-additivity dual-additivity output `picDual(rπ−s) = rV − s`: with + `α = rπ − s`, the irreducible input `htrace_dual` is III.8 for `α` (equivalently III.6.2(c) + additivity, since `tr(rπ−s) = r·t − 2s`), while the candidate identity `htrace_delta` +-(`α + (rV − s) = [r·t − 2s]`) is derived *non-circularly* from the shipped `π + V = [t]`. This ++(`α + (rV − s) = [r·t − 2s]`) is derived *non-circularly* from the `π + V = [t]`. This + lemma performs the subtraction generically. -/ + theorem picDual_eq_of_trace_relations (ch : α.CoordHom) + (hinj : Function.Injective ch.toAlgHom) +@@ -958,7 +807,7 @@ maps).** + The point-map identity `(r·π − s) + (r·V − s) = [r·t − 2s]` for abstract endomorphisms `π, V` of + `E.Point` satisfying `π + V = [t]` (the Frobenius trace relation). This is the **non-circular** + half +-of the Route-C dual-additivity output: pointwise ++of the dual-additivity dual-additivity output: pointwise + `r·π P − s·P + r·V P − s·P = r·(π P + V P) − 2s·P = r·(t·P) − 2s·P = (r·t − 2s)·P`. + + It carries no `picDual` and no degree — pure point-group algebra from `hsum` — and is the candidate +@@ -990,8 +839,8 @@ Pic⁰ dual `picDual α` equals `r·V − s` — *provided* the Silverman III.8 + `htrace_dual` is the **single irreducible residual** (Silverman III.8 for `α`, equivalently + III.6.2(c) additivity since `tr α = r·t − 2s`); everything else — the candidate trace half + `smul_sub_add_smul_sub_eq_mulByInt` — is **non-circular** from `hsum`. This is the engine that +-discharges the Route-C `hpicval` (take `α = rπ − s`, `π = π.toAddMonoidHom`, `V = V.toAddMonoidHom`; +-`hbeta` is the `rfl`-true `genuineIsogSmulSub_toAddMonoidHom`-shape and `hsum` the shipped ++discharges the dual-additivity `hpicval` (take `α = rπ − s`, `π = π.toAddMonoidHom`, `V = V.toAddMonoidHom`; ++`hbeta` is the `rfl`-true `genuineIsogSmulSub_toAddMonoidHom`-shape and `hsum` the + `π + V = [t]`). The per-piece `picDual` values `picDual π = V`, `picDual(rπ) = rV`, + `picDual [n] = [n]` (the non-circular seeds) are exactly what `htrace_dual` decomposes into. -/ + theorem picDual_eq_smul_sub_of_sum_trace (ch : α.CoordHom) +diff --git a/projects/HasseWeil/HasseWeil/Pic0/ToClassSurjective.lean b/projects/HasseWeil/HasseWeil/Pic0/ToClassSurjective.lean +index 31ceaa04d..e7193a4aa 100644 +--- a/projects/HasseWeil/HasseWeil/Pic0/ToClassSurjective.lean ++++ b/projects/HasseWeil/HasseWeil/Pic0/ToClassSurjective.lean +@@ -9,88 +9,6 @@ import Mathlib.RingTheory.OrderOfVanishing.Basic + import Mathlib.RingTheory.Polynomial.DegreeLT + import HasseWeil.Foundation.Ramification + +-/-! +-# Surjectivity of `Point.toClass` and the isomorphism `E ≅ Pic⁰(E)` (affine model) +- +-For a Weierstrass curve `W : WeierstrassCurve.Affine F` over a field `F`, mathlib provides the +-group homomorphism +- +-``` +-WeierstrassCurve.Affine.Point.toClass : W.Point →+ Additive (ClassGroup W.CoordinateRing) +-``` +- +-(`Mathlib/AlgebraicGeometry/EllipticCurve/Affine/Point.lean`) sending the point at infinity to `0` +-and an affine point `P = (x, y)` to the class of the fractional ideal `⟨X - x, Y - y⟩`. Mathlib +-proves this is **injective** (`WeierstrassCurve.Affine.Point.toClass_injective`), realising +-`W.Point` as a subgroup of the affine ideal class group. It does **not** prove surjectivity. +- +-This file packages the surjectivity. The statement that every ideal class is the class of some +-`XYIdeal'` (or trivial) is the genus-1 divisor-reduction theorem: on a smooth genus-1 curve every +-degree-0 divisor class is represented by `(P) - (O)`. We isolate that statement as the +-predicate `ClassRepresentableByPoints W` and prove that it is *equivalent* to surjectivity of +-`toClass`, and that surjectivity packages into the group isomorphism +-`W.Point ≃+ Additive (ClassGroup W.CoordinateRing)`. +- +-## Main definitions +- +-* `WeierstrassCurve.Affine.Point.ClassRepresentableByPoints`: the predicate that every element of +- `ClassGroup W.CoordinateRing` is trivial or the class of `XYIdeal' h` for a nonsingular point. +-* `WeierstrassCurve.Affine.Point.ClassReducesToCodimLEOne`: the genus-1 reduction input — every +- nonzero integral ideal class has a representative of `F`-codimension `≤ 1`. This is now **proved +- unconditionally** (`classReducesToCodimLEOne_holds`). +-* `WeierstrassCurve.Affine.Point.toClassEquiv'`: the **unconditional** group isomorphism +- `W.Point ≃+ Additive (ClassGroup W.CoordinateRing)` for `[W.IsElliptic]`, built from injectivity + +- the unconditional surjectivity `toClass_surjective'`. +- +-## Main results +- +-The **norm-degree dictionary** (the surjectivity counterpart of mathlib's `natDegree_norm_ne_one`, +-which powers `toClass_injective`), all axiom-clean: +- +-* `eq_XYIdeal_of_finrank_quotient_eq_one`: every nonzero ideal `I` with `finrank F (R/I) = 1` is +- the point ideal `XYIdeal W x (C y)` of a (necessarily nonsingular, under `[W.IsElliptic]`) point. +-* `mk0_eq_one_of_finrank_quotient_eq_zero` and +- `mk0_eq_mk_XYIdeal'_of_finrank_quotient_eq_one`: the two codimension endpoints, identifying +- codimension `0` (resp. `1`) ideals with the trivial class (resp. a point class). +-* `integralIdealRepresentableByPoints_of_classReducesToCodimLEOne` and +- `toClass_surjective_of_classReducesToCodimLEOne`: the codimension reduction predicate implies the +- integral-ideal reduction, hence surjectivity of `toClass` (using the now axiom-clean Dedekind +- instance `HasseWeil.coordinateRing_isDedekindDomain`). +- +-and the unconditional headline results: +- +-* `toClass_surjective'`: **unconditional** surjectivity of `toClass` for `[W.IsElliptic]`. +-* `toClassEquiv'`: the **unconditional** isomorphism `W.Point ≃+ Pic⁰(E)`. +- +-## Implementation notes +- +-The full unconditional surjectivity reduces, via three landed and axiom-clean ingredients, to the +-genus-1 codimension reduction `ClassReducesToCodimLEOne`, which is **now also proved**. +- +-1. `IsDedekindDomain W.CoordinateRing` is **available and axiom-clean** via +- `HasseWeil.coordinateRing_isDedekindDomain` (imported here), which fires under `[W.IsElliptic]`. +- +-2. **The ring-theoretic codimension infrastructure** (field-agnostic, no `[Fintype F]`): +- * `finiteDimensional_quotient_of_ne_bot`: every nonzero ideal has finite `F`-codimension. +- * `finrank_quotient_smul`: codimension additivity for multiplication by a *principal* ideal. +- * `finrank_quotient_mul`: the **general** codimension additivity +- `finrank F (R ⧸ I·J) = finrank F (R ⧸ I) + finrank F (R ⧸ J)` for arbitrary nonzero `I, J`, +- via the short exact sequence `0 → I/(I·J) → R/(I·J) → R/I → 0` +- (`Submodule.quotientQuotientEquivQuotient` + `Submodule.finrank_quotient_add_finrank`) and the +- invertible-ideal kernel isomorphism `quotIdealMulEquiv : I/(I·J) ≃ R/J` built from mathlib's +- `FractionalIdeal.quotientEquiv`. +- +-3. **The genus-1 reduction proper**, `classReducesToCodimLEOne_holds`: every nonzero integral ideal +- class has a representative of `F`-codimension `≤ 1` (Riemann–Roch for `g = 1`). Proved from the +- concrete Riemann–Roch inequality `exists_mem_norm_natDegree_le` (every nonzero ideal `I` has a +- nonzero element of norm degree `≤ finrank F (R ⧸ I) + 1`, by an exact `F`-dimension count using +- `CoordinateRing.degree_norm_smul_basis` and rank–nullity) plus the general additivity (2): from a +- small-norm element of a representative of the inverse class, the Dedekind factorisation +- `(a) = I'·J` yields a codimension-`≤ 1` representative of the class. +- +-Everything in this file is `#print axioms`-clean (`[propext, Classical.choice, Quot.sound]`), +-including the unconditional `toClass_surjective'` and `toClassEquiv'`. +--/ + + open Polynomial Module + +@@ -240,10 +158,8 @@ theorem eq_of_le_of_finrank_quotient_eq {I J : Ideal W.CoordinateRing} (hJI : J + exact (Submodule.Quotient.mk_eq_zero _).mp hr0 + + omit [DecidableEq F] in +-/-- **An `F`-algebra hom `R → F` from a codimension-1 quotient.** If `R/I` is 1-dimensional over the +-field `F`, then `algebraMap F (R/I)` is an isomorphism, and composing its inverse with the quotient +-map gives an `F`-algebra hom `φ : R →ₐ[F] F` whose kernel is exactly `I`. Evaluating `φ` at the +-images of `X` and `Y` will produce the point. -/ ++ ++ + theorem exists_algHom_ker_eq_of_finrank_quotient_eq_one (I : Ideal W.CoordinateRing) + [Nontrivial (W.CoordinateRing ⧸ I)] + (hfin : Module.finrank F (W.CoordinateRing ⧸ I) = 1) : +@@ -289,8 +205,8 @@ theorem equation_of_algHom (φ : W.CoordinateRing →ₐ[F] F) : + exact heq.symm + + omit [DecidableEq F] in +-/-- The images of `X - x` and `Y - y` in `R` lie in the kernel of `φ` whenever +-`x = φ(X̄)` and `y = φ(Ȳ)`. -/ ++ ++ + theorem algHom_XClass_eq_zero (φ : W.CoordinateRing →ₐ[F] F) : + φ (CoordinateRing.XClass W (φ (CoordinateRing.mk W (C X)))) = 0 := by + set x := φ (CoordinateRing.mk W (C X)) with hx +@@ -303,7 +219,7 @@ theorem algHom_XClass_eq_zero (φ : W.CoordinateRing →ₐ[F] F) : + rw [Algebra.algebraMap_self_apply, sub_self] + + omit [DecidableEq F] in +-/-- The image of `Y - y` in `R` lies in the kernel of `φ` whenever `y = φ(Ȳ)`. -/ ++ + theorem algHom_YClass_eq_zero (φ : W.CoordinateRing →ₐ[F] F) : + φ (CoordinateRing.YClass W (C (φ (CoordinateRing.mk W Y)))) = 0 := by + set y := φ (CoordinateRing.mk W Y) with hy +@@ -328,9 +244,9 @@ theorem eq_XYIdeal_of_finrank_quotient_eq_one [W.IsElliptic] (I : Ideal W.Coordi + set y := φ (CoordinateRing.mk W Y) with hy + have hEq : W.Equation x y := equation_of_algHom φ + have hNS : W.Nonsingular x y := (equation_iff_nonsingular).mp hEq +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ CoordinateRing.XYIdeal W x (C y)) := ++ have : FiniteDimensional F (W.CoordinateRing ⧸ CoordinateRing.XYIdeal W x (C y)) := + finiteDimensional_quotient_XYIdeal hEq +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ I) := ++ have : FiniteDimensional F (W.CoordinateRing ⧸ I) := + Module.finite_of_finrank_eq_succ hfin + refine ⟨x, y, hNS, ?_⟩ + have hsub : CoordinateRing.XYIdeal W x (C y) ≤ I := by +@@ -352,9 +268,7 @@ theorem finiteDimensional_quotient_of_ne_bot [W.IsElliptic] (I : Ideal W.Coordin + classical + exact Module.Finite.equiv (Ideal.quotientEquivDirectSum F (CoordinateRing.basis W) hI).symm + +-/-- **The degree of an ideal of `F[X]`.** For an ideal `J` of the PID `F[X]`, the natural degree of +-its monic generator. On `⊥` it is `0`; on a nonzero ideal `⟨g⟩` it is `g.natDegree`. This packages +-the codimension `finrank F (F[X] ⧸ J)` purely polynomially. -/ ++ + noncomputable def idealNatDegree (J : Ideal F[X]) : ℕ := + (Submodule.IsPrincipal.generator J).natDegree + +@@ -422,10 +336,10 @@ theorem finrank_quotient_eq_sum_smithCoeffs [W.IsElliptic] (I : Ideal W.Coordina + Module.finrank F (W.CoordinateRing ⧸ I) + = ∑ i, (Ideal.smithCoeffs (CoordinateRing.basis W) I hI i).natDegree := by + classical +- haveI hFree : ∀ i, Module.Free F ++ have hFree : ∀ i, Module.Free F + (F[X] ⧸ Ideal.span ({Ideal.smithCoeffs (CoordinateRing.basis W) I hI i} : Set F[X])) := + fun i ↦ inferInstance +- haveI hFin : ∀ i, Module.Finite F ++ have hFin : ∀ i, Module.Finite F + (F[X] ⧸ Ideal.span ({Ideal.smithCoeffs (CoordinateRing.basis W) I hI i} : Set F[X])) := + fun i ↦ inferInstance + rw [Ideal.finrank_quotient_eq_sum (I := I) (hI := hI) F (CoordinateRing.basis W)] +@@ -443,12 +357,8 @@ theorem smul_ideal_eq_span_mul (a : W.CoordinateRing) (I : Ideal W.CoordinateRin + · rintro ⟨z, hz, rfl⟩; exact ⟨z, hz, by rw [smul_eq_mul]⟩ + + omit [DecidableEq F] in +-/-- **Codimension additivity for multiplication by a principal ideal.** For a nonzero `a ∈ R` and a +-nonzero ideal `I`, `finrank F (R ⧸ ⟨a⟩·I) = finrank F (R ⧸ I) + finrank F (R ⧸ ⟨a⟩)`. This is the +-additivity of `F`-codimension along the multiplication-by-`a` short exact sequence +-`R ⧸ I → R ⧸ (a•I) → R ⧸ ⟨a⟩` (`Ideal.mulQuot`/`Ideal.quotOfMul`, restricted to `F`-linear maps and +-fed to `Module.length_eq_add_of_exact`, with `Module.length F = finrank F` over the field `F`). +-It is the special case of the genus-1 norm-degree additivity for a principal factor. -/ ++ ++ + theorem finrank_quotient_smul [W.IsElliptic] {a : W.CoordinateRing} (ha : a ≠ 0) + (I : Ideal W.CoordinateRing) (hI : I ≠ ⊥) : + Module.finrank F (W.CoordinateRing ⧸ (a • I)) = +@@ -459,17 +369,17 @@ theorem finrank_quotient_smul [W.IsElliptic] {a : W.CoordinateRing} (ha : a ≠ + have haspan : Ideal.span ({a} : Set W.CoordinateRing) ≠ ⊥ := by + rwa [Ne, Ideal.span_singleton_eq_bot] + have haI : a • I ≠ ⊥ := by rw [smul_ideal_eq_span_mul]; exact mul_ne_zero haspan hI +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ I) := finiteDimensional_quotient_of_ne_bot _ hI +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ Ideal.span ({a} : Set W.CoordinateRing)) := ++ have : FiniteDimensional F (W.CoordinateRing ⧸ I) := finiteDimensional_quotient_of_ne_bot _ hI ++ have : FiniteDimensional F (W.CoordinateRing ⧸ Ideal.span ({a} : Set W.CoordinateRing)) := + finiteDimensional_quotient_of_ne_bot _ haspan +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ (a • I)) := ++ have : FiniteDimensional F (W.CoordinateRing ⧸ (a • I)) := + finiteDimensional_quotient_of_ne_bot _ haI + have hlen := Module.length_eq_add_of_exact + ((Ideal.mulQuot a I).restrictScalars F) ((Ideal.quotOfMul a I).restrictScalars F) + (Ideal.mulQuot_injective I hanz) (Ideal.quotOfMul_surjective I) + (Ideal.exact_mulQuot_quotOfMul I) + rw [Module.length_eq_finrank, Module.length_eq_finrank, Module.length_eq_finrank, +- ← Nat.cast_add, ENat.coe_inj] at hlen ++ ← Nat.cast_add, ENat.natCast_inj] at hlen + exact hlen + + omit [DecidableEq F] in +@@ -554,10 +464,8 @@ private noncomputable def quotEquivOneCoeIdealQuot_aux [W.IsElliptic] {J : Ideal + exact hry + + omit [DecidableEq F] in +-/-- **The invertible-ideal quotient isomorphism `I/(I·J) ≃ R/J`.** For nonzero ideals `I, J` of the +-(Dedekind) coordinate ring `R`, the `R`-module quotient of the ideal `I` (viewed as a submodule of +-`R`) by its submodule `I·J` is `R`-linearly isomorphic to `R/J`; this holds because `I` is +-invertible. -/ ++ ++ + noncomputable def quotIdealMulEquiv [W.IsElliptic] {I J : Ideal W.CoordinateRing} + (hI : I ≠ ⊥) (hJ : J ≠ ⊥) : + ((I : Submodule W.CoordinateRing W.CoordinateRing) ⧸ +@@ -582,23 +490,17 @@ noncomputable def quotIdealMulEquiv [W.IsElliptic] {I J : Ideal W.CoordinateRing + (eqe.trans (quotEquivOneCoeIdealQuot_aux hinj).symm) + + omit [DecidableEq F] in +-/-- **General codimension additivity.** For arbitrary nonzero ideals `I, J` of +-`R := W.CoordinateRing`, +-`finrank F (R ⧸ I·J) = finrank F (R ⧸ I) + finrank F (R ⧸ J)`. This upgrades `finrank_quotient_smul` +-(the principal-factor case) to all factors, via the short exact sequence +-`0 → I/(I·J) → R/(I·J) → R/I → 0` (`Submodule.quotientQuotientEquivQuotient` + +-`Submodule.finrank_quotient_add_finrank`) together with the invertible-ideal kernel identification +-`I/(I·J) ≃ R/J` (`quotIdealMulEquiv`). It is the genus-1 norm-degree additivity in `F`-codimension +-form. -/ ++ ++ + theorem finrank_quotient_mul [W.IsElliptic] {I J : Ideal W.CoordinateRing} + (hI : I ≠ ⊥) (hJ : J ≠ ⊥) : + Module.finrank F (W.CoordinateRing ⧸ (I * J)) = + Module.finrank F (W.CoordinateRing ⧸ I) + Module.finrank F (W.CoordinateRing ⧸ J) := by + have hIJ : I * J ≠ ⊥ := mul_ne_zero hI hJ +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ (I * J)) := ++ have : FiniteDimensional F (W.CoordinateRing ⧸ (I * J)) := + finiteDimensional_quotient_of_ne_bot _ hIJ +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ I) := finiteDimensional_quotient_of_ne_bot _ hI +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ J) := finiteDimensional_quotient_of_ne_bot _ hJ ++ have : FiniteDimensional F (W.CoordinateRing ⧸ I) := finiteDimensional_quotient_of_ne_bot _ hI ++ have : FiniteDimensional F (W.CoordinateRing ⧸ J) := finiteDimensional_quotient_of_ne_bot _ hJ + have hIJ_le : I * J ≤ I := Ideal.mul_le_left + set M : Submodule (W.CoordinateRing) (W.CoordinateRing ⧸ (I * J)) := + Submodule.map (Submodule.mkQ (I * J)) +@@ -620,7 +522,7 @@ theorem finrank_quotient_mul [W.IsElliptic] {I J : Ideal W.CoordinateRing} + have e3 : (LinearMap.range g) ≃ₗ[R] M := LinearEquiv.ofEq _ _ hrange + exact ((Submodule.quotEquivOfEq _ _ hker.symm).trans (g.quotKerEquivRange.trans e3)).symm + have eM : M ≃ₗ[W.CoordinateRing] (W.CoordinateRing ⧸ J) := e2a.trans (quotIdealMulEquiv hI hJ) +- haveI : FiniteDimensional F M := (eM.restrictScalars F).symm.finiteDimensional ++ have : FiniteDimensional F M := (eM.restrictScalars F).symm.finiteDimensional + have key : Module.finrank F ((W.CoordinateRing ⧸ (I * J)) ⧸ (M.restrictScalars F)) + + Module.finrank F (M.restrictScalars F) = Module.finrank F (W.CoordinateRing ⧸ (I * J)) := + Submodule.finrank_quotient_add_finrank (M.restrictScalars F) +@@ -666,7 +568,7 @@ theorem mk0_eq_mk_XYIdeal'_of_finrank_quotient_eq_one [W.IsElliptic] (J : Ideal + (hfin : Module.finrank F (W.CoordinateRing ⧸ J) = 1) : + ∃ (x y : F) (h : W.Nonsingular x y), + ClassGroup.mk0 ⟨J, hmem⟩ = ClassGroup.mk W.FunctionField (CoordinateRing.XYIdeal' h) := by +- haveI : Nontrivial (W.CoordinateRing ⧸ J) := Module.nontrivial_of_finrank_eq_succ hfin ++ have : Nontrivial (W.CoordinateRing ⧸ J) := Module.nontrivial_of_finrank_eq_succ hfin + obtain ⟨x, y, h, hJ⟩ := eq_XYIdeal_of_finrank_quotient_eq_one J hfin + have hmem' : CoordinateRing.XYIdeal W x (C y) ∈ (Ideal W.CoordinateRing)⁰ := hJ ▸ hmem + refine ⟨x, y, h, ?_⟩ +@@ -723,10 +625,7 @@ private theorem two_nsmul_degree_le' {p : F[X]} {n : ℕ} (hp : p.degree < (n : + rw [nsmul_eq_mul]; push_cast; ring, Nat.cast_le] + lia + +-/-- **The basis-combination map** `(p, q) ↦ p · 1 + q · Ȳ`, restricted to polynomials of bounded +-degree (`degreeLT F a × degreeLT F b`), as an `F`-linear map into `R`. Its image is the space of +-elements whose norm degree we can control; its kernel intersected with the codimension count gives +-the Riemann–Roch element. -/ ++ + noncomputable def basisCombMap (W : WeierstrassCurve.Affine F) (a b : ℕ) : + (Polynomial.degreeLT F a × Polynomial.degreeLT F b) →ₗ[F] W.CoordinateRing where + toFun pq := (pq.1 : F[X]) • (1 : W.CoordinateRing) + (pq.2 : F[X]) • (CoordinateRing.basis W 1) +@@ -780,19 +679,15 @@ theorem basisCombMap_ne_zero {a b : ℕ} (pq : Polynomial.degreeLT F a × Polyno + exact Prod.ext (Subtype.ext hp) (Subtype.ext hq) + + omit [DecidableEq F] in +-/-- **The genus-1 Riemann–Roch inequality (concrete form).** Every nonzero ideal `I` of +-`R := W.CoordinateRing` contains a nonzero element `a` with `(Algebra.norm F[X] a).natDegree ≤ +-finrank F (R ⧸ I) + 1`. This is `ℓ(D) ≥ deg D` for `g = 1` made explicit, proved by the exact +-`F`-dimension count: the bounded-degree basis combinations form an `F`-subspace of dimension +-`ℓ + 1 > ℓ = finrank F (R ⧸ I)`, so rank–nullity for its composite into `R ⧸ I` forces a nonzero +-kernel element. No finiteness of `F` is needed (`F[X]` is Euclidean). -/ ++ ++ + theorem exists_mem_norm_natDegree_le [W.IsElliptic] (I : Ideal W.CoordinateRing) (hI : I ≠ ⊥) : + ∃ a ∈ I, a ≠ 0 ∧ + (Algebra.norm F[X] a).natDegree ≤ Module.finrank F (W.CoordinateRing ⧸ I) + 1 := by + classical + set R := W.CoordinateRing + set ℓ := Module.finrank F (R ⧸ I) with hℓ +- haveI : FiniteDimensional F (R ⧸ I) := finiteDimensional_quotient_of_ne_bot _ hI ++ have : FiniteDimensional F (R ⧸ I) := finiteDimensional_quotient_of_ne_bot _ hI + obtain ⟨da, hda⟩ : ∃ da, da = (ℓ + 1) / 2 + 1 := ⟨_, rfl⟩ + obtain ⟨db, hdb⟩ : ∃ db, db = ℓ / 2 := ⟨_, rfl⟩ + set ψ : (Polynomial.degreeLT F da × Polynomial.degreeLT F db) →ₗ[F] (R ⧸ I) := +@@ -809,7 +704,7 @@ theorem exists_mem_norm_natDegree_le [W.IsElliptic] (I : Ideal W.CoordinateRing) + have hrange_le : Module.finrank F (LinearMap.range ψ) ≤ ℓ := + le_trans (Submodule.finrank_le _) (le_of_eq hℓ.symm) + have hker_pos : 0 < Module.finrank F (LinearMap.ker ψ) := by lia +- haveI : Nontrivial (LinearMap.ker ψ) := Module.nontrivial_of_finrank_pos hker_pos ++ have : Nontrivial (LinearMap.ker ψ) := Module.nontrivial_of_finrank_pos hker_pos + obtain ⟨z, hz⟩ := exists_ne (0 : LinearMap.ker ψ) + set pq := (z : Polynomial.degreeLT F da × Polynomial.degreeLT F db) with hpq + have hpq_ne : pq ≠ 0 := fun h ↦ hz (Subtype.ext h) +@@ -873,7 +768,7 @@ theorem classReducesToCodimLEOne_holds [W.IsElliptic] : + rw [hI', inv_inv] at hmk0 + rcases Nat.le_one_iff_eq_zero_or_eq_one.mp hfinle with h0 | h1 + · left +- haveI : FiniteDimensional F (W.CoordinateRing ⧸ J) := ++ have : FiniteDimensional F (W.CoordinateRing ⧸ J) := + finiteDimensional_quotient_of_ne_bot _ (mem_nonZeroDivisors_iff_ne_zero.mp hJmem) + have hone : ClassGroup.mk0 ⟨J, hJmem⟩ = 1 := + mk0_eq_one_of_finrank_quotient_eq_zero J hJmem h0 diff --git a/lean/patches/AbsorptionCutoff-lean4341.patch b/lean/patches/AbsorptionCutoff-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..6bf8b9b8ae5bf6eed37d3c73d9fd3e659f5bd942 --- /dev/null +++ b/lean/patches/AbsorptionCutoff-lean4341.patch @@ -0,0 +1,111 @@ +diff --git a/AbsorptionCutoff/Supercritical/Renewal.lean b/AbsorptionCutoff/Supercritical/Renewal.lean +index be4e8d0..84e0b74 100644 +--- a/AbsorptionCutoff/Supercritical/Renewal.lean ++++ b/AbsorptionCutoff/Supercritical/Renewal.lean +@@ -599,7 +599,7 @@ theorem exists_pos_le_norm_one_sub_charFun {μ : Measure ℝ} [IsProbabilityMeas + have ht₀ne : t₀ ≠ 0 := by + intro h + have h' := ht₀K.2 +- simp only [Set.mem_setOf_eq, h, abs_zero] at h' ++ simp only [Set.mem_ofPred_eq, h, abs_zero] at h' + linarith + have hpos : 0 < ‖1 - charFun μ t₀‖ := by + rw [norm_pos_iff, sub_ne_zero] +@@ -1246,7 +1246,7 @@ theorem tendsto_driNorm_tail {g : ℝ → ℝ≥0∞} (hg : driNorm g ≠ ∞) : + have hkey := hS (Finset.Icc (-(N : ℤ)) (N : ℤ)) hsub + have hset : {k : ℤ | (N : ℤ) < |k|} = ((Finset.Icc (-(N : ℤ)) (N : ℤ) : Finset ℤ) : Set ℤ)ᶜ := by + ext k +- simp only [Set.mem_setOf_eq, Set.mem_compl_iff, Finset.coe_Icc, Set.mem_Icc] ++ simp only [Set.mem_ofPred_eq, Set.mem_compl_iff, Finset.coe_Icc, Set.mem_Icc] + rw [← not_le, abs_le] + rw [hset, ← tsum_subtype] + exact hkey +@@ -1431,7 +1431,7 @@ theorem exists_hasCompactSupport_driNorm_sub_lt {z : ℝ → ℂ} (hz : Continuo + exact ENNReal.ofReal_le_one.2 (cutoff_le_one M x) + · refine lt_of_le_of_lt (ENNReal.tsum_le_tsum fun k => ?_) hN + by_cases hk : (N : ℤ) < |k| +- · rw [Set.indicator_apply, if_pos (show k ∈ {k : ℤ | (N : ℤ) < |k|} from hk)] ++ · rw [Set.indicator_apply, ite_eq_left (show k ∈ {k : ℤ | (N : ℤ) < |k|} from hk)] + refine cellSup_mono (fun x => ?_) k + rw [show z x - (cutoff M x : ℂ) * z x = ((1 - cutoff M x : ℝ) : ℂ) * z x by push_cast; ring, + enorm_mul] +@@ -1439,7 +1439,7 @@ theorem exists_hasCompactSupport_driNorm_sub_lt {z : ℝ → ℂ} (hz : Continuo + rw [← ofReal_norm, Complex.norm_real, Real.norm_eq_abs, + abs_of_nonneg (by linarith [cutoff_le_one M x])] + exact ENNReal.ofReal_le_one.2 (by linarith [cutoff_nonneg M x]) +- · rw [Set.indicator_apply, if_neg (show k ∉ {k : ℤ | (N : ℤ) < |k|} from hk), ++ · rw [Set.indicator_apply, ite_eq_right (show k ∉ {k : ℤ | (N : ℤ) < |k|} from hk), + nonpos_iff_eq_zero] + refine iSup₂_eq_bot.2 fun x hx => ?_ + obtain ⟨h1, h2⟩ := abs_le.1 (not_lt.1 hk) +diff --git a/AbsorptionCutoff/Supercritical/RenewalApprox.lean b/AbsorptionCutoff/Supercritical/RenewalApprox.lean +index a394d70..d4094ca 100644 +--- a/AbsorptionCutoff/Supercritical/RenewalApprox.lean ++++ b/AbsorptionCutoff/Supercritical/RenewalApprox.lean +@@ -295,7 +295,7 @@ theorem exists_forall_norm_smoothed_sub_le {w : ℝ → ℂ} (hwc : Continuous w + · have h2M : ‖w (x - u) - w x‖ ≤ 2 * M := + le_trans (norm_sub_le _ _) (by linarith [hM (x - u), hM x]) + have : Set.indicator {u : ℝ | δ < |u|} (smoothKernel a) u = smoothKernel a u := by +- rw [Set.indicator_apply, if_pos (show u ∈ {u : ℝ | δ < |u|} from hu)] ++ rw [Set.indicator_apply, ite_eq_left (show u ∈ {u : ℝ | δ < |u|} from hu)] + rw [hg] + simp only [this] + nlinarith [mul_nonneg hε.le hK0] +@@ -309,7 +309,7 @@ theorem exists_forall_norm_smoothed_sub_le {w : ℝ → ℂ} (hwc : Continuous w + rw [dist_eq_norm] at this + linarith + have : Set.indicator {u : ℝ | δ < |u|} (smoothKernel a) u = 0 := by +- rw [Set.indicator_apply, if_neg (show u ∉ {u : ℝ | δ < |u|} from hu)] ++ rw [Set.indicator_apply, ite_eq_right (show u ∉ {u : ℝ | δ < |u|} from hu)] + rw [hg] + simp only [this] + nlinarith +diff --git a/lakefile.toml b/lakefile.toml +index 34acdfc..1a2b828 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,26 +4,26 @@ keywords = ["math"] + defaultTargets = ["AbsorptionCutoff"] + + [leanOptions] +-pp.unicode.fun = true # pretty-prints `fun a ↦ b` ++pp.unicode.fun = true + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true + maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" +- ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[require]] + name = "checkdecls" + git = "https://github.com/PatrickMassot/checkdecls.git" +-[[lean_lib]] +-name = "AbsorptionCutoff" + +-# Mathlib-only comparator surface. Kept out of `defaultTargets` so a plain +-# `lake build` never elaborates the intentional statement-level `sorry` that +-# each `Challenge.lean` ends with. Build it with `lake build Audit`. + [[lean_lib]] +-name = "Audit" +-globs = ["Audit", "Audit.+"] ++name = "AbsorptionCutoff" ++globs = [ ++ "AbsorptionCutoff.Supercritical.Renewal", ++ "AbsorptionCutoff.Supercritical.RenewalAbel", ++ "AbsorptionCutoff.Supercritical.RenewalKernel", ++ "AbsorptionCutoff.Supercritical.RenewalSinc", ++ "AbsorptionCutoff.Supercritical.RenewalApprox" ++] +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f49..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/ClassFieldTheory-lean4341.patch b/lean/patches/ClassFieldTheory-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..bff9ccd8bcec226f594d0d2c359becebf06150b8 --- /dev/null +++ b/lean/patches/ClassFieldTheory-lean4341.patch @@ -0,0 +1,31757 @@ +diff --git a/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusGeometry.lean b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusGeometry.lean +index ba13223..d57b89f 100644 +--- a/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusGeometry.lean ++++ b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusGeometry.lean +@@ -4,19 +4,12 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.MainNaturality +-import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.DoubleCosetOrbitGeometry + +-set_option autoImplicit false ++import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.MainTransferNormOrbitMk + +-/-! +-# Transfer--norm Frobenius geometry + +-For a finite Galois extension and an intermediate field, this module builds the +-Frobenius-side subgroup and orbit equivalences used in transfer--norm +-naturality. The reusable orbit and double-coset constructions are isolated in +-`DoubleCosetOrbitGeometry`. +--/ ++set_option autoImplicit false ++ + + universe u + +@@ -35,424 +28,9 @@ section transferFrobeniusGeometry + + variable {G : Type u} [Group G] [TopologicalSpace G] + +-/-- The absolute group of an intermediate field, identified with its +-literal copy inside the absolute group of the base field. -/ +-noncomputable def transferNormNaturalityIntermediateAbsoluteEquiv +- (K K' : ClosedSubgroup G) +- (hK'K : K'.toSubgroup ≤ K.toSubgroup) : +- K'.toSubgroup ≃* extensionSubgroup K K' hK'K := +- MulEquiv.ofBijective +- ((Subgroup.inclusion hK'K).codRestrict +- (extensionSubgroup K K' hK'K) (fun k' => k'.2)) +- ⟨fun _ _ h => Subtype.ext (congrArg (fun z => z.1.1) h), by +- rintro ⟨k, hk'⟩ +- let k' : K'.toSubgroup := ⟨k.1, hk'⟩ +- exact ⟨k', Subtype.ext rfl⟩⟩ +- +-/-- The absolute intermediate-field equivalence evaluates by the underlying transfer map. -/ +-@[simp] +-theorem transferNormNaturalityIntermediateAbsoluteEquiv_apply +- (K K' : ClosedSubgroup G) +- (hK'K : K'.toSubgroup ≤ K.toSubgroup) +- (k' : K'.toSubgroup) : +- ((transferNormNaturalityIntermediateAbsoluteEquiv K K' hK'K k').1 : G) = k'.1 := +- rfl +- +-/-- Normality of `L | K` restricts to every intermediate field `K'`. -/ +-theorem transferNormNaturality_intermediateExtension_normal +- (K K' L : ClosedSubgroup G) +- (hLK' : L.toSubgroup ≤ K'.toSubgroup) +- (hK'K : K'.toSubgroup ≤ K.toSubgroup) +- [hLnormal : (extensionSubgroup K L (hLK'.trans hK'K)).Normal] : +- (extensionSubgroup K' L hLK').Normal := by +- have hcomap : extensionSubgroup K' L hLK' = +- (extensionSubgroup K L (hLK'.trans hK'K)).comap +- (Subgroup.inclusion hK'K) := by +- ext k' +- rw [Subgroup.mem_comap, mem_extensionSubgroup_iff, +- mem_extensionSubgroup_iff] +- rfl +- rw [hcomap] +- exact hLnormal.comap (Subgroup.inclusion hK'K) + + namespace DegreeData + +-/-- The restriction map on the infinite Frobenius quotients is injective +-when the top field is unchanged. -/ +-theorem transferNormNaturalityFrobeniusTowerMap_injective +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : +- Function.Injective +- (D.finiteReciprocityNaturalityFrobeniusTowerMap +- E.base.field E.field.field L L +- (hL.trans E.below) hL E.below le_rfl) := by +- intro x y +- refine QuotientGroup.induction_on x ?_ +- intro k' +- refine QuotientGroup.induction_on y ?_ +- intro l' h +- apply QuotientGroup.eq.mpr +- have hmem : +- (Subgroup.inclusion E.below k')⁻¹ * Subgroup.inclusion E.below l' ∈ +- D.extensionInertiaWithin E.base.field L (hL.trans E.below) := +- QuotientGroup.eq.mp h +- constructor +- · apply (mem_extensionSubgroup_iff E.field.field L hL (k'⁻¹ * l')).2 +- have hG := (mem_extensionSubgroup_iff E.base.field L +- (hL.trans E.below) +- ((Subgroup.inclusion E.below k')⁻¹ * +- Subgroup.inclusion E.below l')).1 hmem.1 +- simpa using hG +- · have hI := hmem.2 +- change D.degree (((Subgroup.inclusion E.below k')⁻¹ * +- Subgroup.inclusion E.below l' : E.base.field.toSubgroup) : G) = 1 at hI +- change D.degree ((k'⁻¹ * l' : E.field.field.toSubgroup) : G) = 1 +- exact hI +- +-/-- The copy of `G(\widetilde L/K')` inside +-`G(\widetilde L/K)`. This is the subgroup `H` used in the classical +-double-coset proof of transfer--norm naturality. -/ +-def transferNormNaturalityFrobeniusIntermediateSubgroup +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : +- Subgroup (E.base.field.toSubgroup ⧸ +- D.extensionInertiaWithin E.base.field L (hL.trans E.below)) := +- (D.finiteReciprocityNaturalityFrobeniusTowerMap +- E.base.field E.field.field L L +- (hL.trans E.below) hL E.below le_rfl).range +- +-/-- The subgroup above is also the image of `G_K'` under the quotient +-projection `G_K → G(\widetilde L/K)`. -/ +-theorem transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : +- D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL = +- (extensionSubgroup E.base.field E.field.field E.below).map +- (QuotientGroup.mk' +- (D.extensionInertiaWithin E.base.field L +- (hL.trans E.below))) := by +- ext q +- constructor +- · rintro ⟨x, rfl⟩ +- refine QuotientGroup.induction_on x ?_ +- intro k' +- refine ⟨Subgroup.inclusion E.below k', ?_, rfl⟩ +- exact k'.2 +- · rintro ⟨k, hk', rfl⟩ +- let k' : E.field.field.toSubgroup := ⟨k.1, hk'⟩ +- refine ⟨QuotientGroup.mk k', ?_⟩ +- change QuotientGroup.mk (Subgroup.inclusion E.below k') = +- QuotientGroup.mk k +- rfl +- +-/-- Quotient projection maps the literal absolute subgroup belonging to +-`K'` onto its copy `H` inside `G(\widetilde L/K)`. -/ +-noncomputable def transferNormNaturalityIntermediateToFrobeniusSubgroup +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : +- extensionSubgroup E.base.field E.field.field E.below →* +- D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL := by +- refine ((QuotientGroup.mk' +- (D.extensionInertiaWithin E.base.field L (hL.trans E.below))).comp +- (extensionSubgroup E.base.field E.field.field E.below).subtype).codRestrict +- (D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL) ?_ +- intro m +- change QuotientGroup.mk m.1 ∈ +- D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL +- rw [D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map +- E L hL] +- exact ⟨m.1, m.2, rfl⟩ +- +-/-- The map from the intermediate quotient onto the Frobenius subgroup is surjective. -/ +-theorem transferNormNaturalityIntermediateToFrobeniusSubgroup_surjective +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : +- Function.Surjective +- (D.transferNormNaturalityIntermediateToFrobeniusSubgroup +- E L hL) := by +- intro h +- have hh : h.1 ∈ +- (extensionSubgroup E.base.field E.field.field E.below).map +- (QuotientGroup.mk' +- (D.extensionInertiaWithin E.base.field L (hL.trans E.below))) := by +- rw [← D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map +- E L hL] +- exact h.2 +- obtain ⟨m, hm, hval⟩ := hh +- refine ⟨⟨m, hm⟩, ?_⟩ +- apply Subtype.ext +- unfold transferNormNaturalityIntermediateToFrobeniusSubgroup +- simpa only [MonoidHom.codRestrict_apply, MonoidHom.comp_apply, +- Subgroup.subtype_apply] using hval +- +-/-- The intermediate-to-Frobenius map has the stated value on each representative. -/ +-@[simp] +-theorem transferNormNaturalityIntermediateToFrobeniusSubgroup_apply +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] +- (m : extensionSubgroup E.base.field E.field.field E.below) : +- (D.transferNormNaturalityIntermediateToFrobeniusSubgroup +- E L hL m).1 = +- (QuotientGroup.mk m.1 : E.base.field.toSubgroup ⧸ +- D.extensionInertiaWithin E.base.field L (hL.trans E.below)) := by +- rfl +- +-/-- The canonical coset equivalence from `G_K/G_Σ` to +-`G(\widetilde L/K)/Γ` intertwines the two copies of the `K'`-action. -/ +-theorem frobeniusFixedCosetClosureEquiv_equivariant +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] +- (σ : D.FrobeniusElements E.base L (hL.trans E.below)) +- (m : extensionSubgroup E.base.field E.field.field E.below) +- (x : E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field +- (D.frobeniusFixedField E.base L (hL.trans E.below) σ) +- (D.frobeniusFixedField_le E.base L (hL.trans E.below) σ)) : +- D.frobeniusFixedCosetClosureEquiv E.base L (hL.trans E.below) σ (m • x) = +- (D.transferNormNaturalityIntermediateToFrobeniusSubgroup +- E L hL m) • +- D.frobeniusFixedCosetClosureEquiv E.base L +- (hL.trans E.below) σ x := by +- refine Quotient.inductionOn' x ?_ +- intro k +- change QuotientGroup.mk (QuotientGroup.mk (m.1 * k)) = +- QuotientGroup.mk +- ((D.transferNormNaturalityIntermediateToFrobeniusSubgroup +- E L hL m).1 * QuotientGroup.mk k) +- rw [D.transferNormNaturalityIntermediateToFrobeniusSubgroup_apply] +- rfl +- +-/-- Restriction from the infinite Frobenius quotient onto the finite +-Galois quotient is surjective. -/ +-theorem transferNormNaturalityExtensionRestriction_surjective +- (D : DegreeData G) +- (K L : ClosedSubgroup G) +- (hLK : L.toSubgroup ≤ K.toSubgroup) +- [hLnormal : (extensionSubgroup K L hLK).Normal] : +- Function.Surjective (D.extensionRestriction K L hLK) := by +- intro q +- refine QuotientGroup.induction_on q ?_ +- intro k +- exact ⟨QuotientGroup.mk k, rfl⟩ +- +-/-- The kernel of restriction to `G(L/K)` is contained in the subgroup +-coming from `G(\widetilde L/K')`. -/ +-theorem transferNormNaturalityExtensionRestriction_ker_le_intermediate +- (D : DegreeData G) [IsTopologicalGroup G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : +- (D.extensionRestriction E.base.field L (hL.trans E.below)).ker ≤ +- D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL := by +- rw [D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map +- E L hL] +- intro q hq +- revert hq +- refine QuotientGroup.induction_on q ?_ +- intro k hk +- change D.extensionRestriction E.base.field L (hL.trans E.below) +- (QuotientGroup.mk k) = 1 at hk +- rw [D.extensionRestriction_mk] at hk +- have hkL : k ∈ +- extensionSubgroup E.base.field L (hL.trans E.below) := by +- exact QuotientGroup.eq_one_iff k |>.1 hk +- have hkK' : k ∈ +- extensionSubgroup E.base.field E.field.field E.below := by +- apply (mem_extensionSubgroup_iff +- E.base.field E.field.field E.below k).2 +- exact hL ((mem_extensionSubgroup_iff E.base.field L +- (hL.trans E.below) k).1 hkL) +- exact ⟨k, hkK', rfl⟩ +- +-/-- `H` has finite index in `G(\widetilde L/K)`, with no normality +-assumption on the intermediate extension `K'/K`. -/ +-theorem transferNormNaturalityFrobeniusIntermediateFiniteIndex +- (D : DegreeData G) [IsTopologicalGroup G] +- (R : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ R.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup R.base.field L (hL.trans R.below)).Normal] +- [hL'normal : (extensionSubgroup R.field.field L hL).Normal] : +- (D.transferNormNaturalityFrobeniusIntermediateSubgroup R L hL).FiniteIndex := by +- rw [D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map +- R L hL] +- let I := D.extensionInertiaWithin R.base.field L (hL.trans R.below) +- let M := extensionSubgroup R.base.field R.field.field R.below +- have hIM : I ≤ M := by +- intro k hk +- apply (mem_extensionSubgroup_iff +- R.base.field R.field.field R.below k).2 +- exact hL ((mem_extensionSubgroup_iff R.base.field L +- (hL.trans R.below) k).1 hk.1) +- let p := QuotientGroup.mk' I +- have hker : p.ker ≤ M := by +- simpa [p] using hIM +- let : M.FiniteIndex := Subgroup.finiteIndex_of_finite_quotient +- rw [Subgroup.finiteIndex_iff, +- M.index_map_eq (QuotientGroup.mk'_surjective I) hker] +- exact Subgroup.FiniteIndex.index_ne_zero +- +-/-- The copy of `G(\widetilde L/K')` is closed in +-`G(\widetilde L/K)`. -/ +-theorem transferNormNaturalityFrobeniusIntermediate_isClosed +- (D : DegreeData G) [IsTopologicalGroup G] [CompactSpace G] [T2Space G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : +- IsClosed (D.transferNormNaturalityFrobeniusIntermediateSubgroup +- E L hL : Set +- (E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L +- (hL.trans E.below))) := by +- let : CompactSpace E.field.field.toSubgroup := +- isCompact_iff_compactSpace.mp E.field.field.isClosed'.isCompact +- let : IsClosed +- (D.extensionInertiaWithin E.field.field L hL : +- Set E.field.field.toSubgroup) := +- D.extensionInertiaWithin_isClosed E.field L hL +- let : IsClosed (D.extensionInertiaWithin E.base.field L +- (hL.trans E.below) : Set E.base.field.toSubgroup) := +- D.extensionInertiaWithin_isClosed E.base L (hL.trans E.below) +- let f := D.finiteReciprocityNaturalityFrobeniusTowerMapContinuous +- E.base.field E.field.field L L +- (hL.trans E.below) hL E.below le_rfl +- change IsClosed (Set.range f) +- have hrange : Set.range f = Set.range f.toContinuousMap := by +- ext y +- constructor <;> rintro ⟨x, rfl⟩ <;> exact ⟨x, rfl⟩ +- rw [hrange] +- simpa only [Set.image_univ] using +- (isCompact_univ.image f.continuous).isClosed +- +-/-- The transfer-orbit index set +-`⟨σ⟩ \ G(\widetilde L/K) / H` is canonically the norm double-coset +-index set `G_K' \ G_K / G_Σ`. The equivalence is inversion of double +-cosets, followed by passage from powers of `σ` to their closure `Γ` and +-the canonical identification `G_K/G_Σ ≃ G(\widetilde L/K)/Γ`. -/ +-noncomputable def transferNormNaturalityTransferNormOrbitEquiv +- (D : DegreeData G) [IsTopologicalGroup G] [CompactSpace G] [T2Space G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] +- (σ : D.FrobeniusElements E.base L (hL.trans E.below)) : +- Quotient (orbitRel (Subgroup.zpowers σ.1) +- ((E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L +- (hL.trans E.below)) ⧸ +- D.transferNormNaturalityFrobeniusIntermediateSubgroup +- E L hL)) ≃ +- Quotient (orbitRel +- (extensionSubgroup E.base.field E.field.field E.below) +- (E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field +- (D.frobeniusFixedField E.base L (hL.trans E.below) σ) +- (D.frobeniusFixedField_le E.base L +- (hL.trans E.below) σ))) := by +- let P := E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L +- (hL.trans E.below) +- let H := D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL +- let M := extensionSubgroup E.base.field E.field.field E.below +- let Γ := D.frobeniusClosure E.base L (hL.trans E.below) σ +- let S := D.frobeniusFixedField E.base L (hL.trans E.below) σ +- let hSK := D.frobeniusFixedField_le E.base L (hL.trans E.below) σ +- let f : M →* H := D.transferNormNaturalityIntermediateToFrobeniusSubgroup +- E L hL +- let e := D.frobeniusFixedCosetClosureEquiv +- E.base L (hL.trans E.below) σ +- letI : H.FiniteIndex := +- D.transferNormNaturalityFrobeniusIntermediateFiniteIndex E L hL +- have hHclosed : IsClosed (H : Set P) := +- D.transferNormNaturalityFrobeniusIntermediate_isClosed E L hL +- have hΓ : +- (closedSubgroupGenerated ({σ.1} : Set P)).toSubgroup = Γ.toSubgroup := by +- simp [Γ, DegreeData.frobeniusClosure] +- let eΓ : P ⧸ (closedSubgroupGenerated ({σ.1} : Set P)).toSubgroup ≃ +- P ⧸ Γ.toSubgroup := Subgroup.quotientEquivOfEq hΓ +- have heΓ (h : H) +- (x : P ⧸ (closedSubgroupGenerated ({σ.1} : Set P)).toSubgroup) : +- eΓ (h • x) = h • eΓ x := by +- refine Quotient.inductionOn' x ?_ +- intro p +- rfl +- let eΓorbit := orbitQuotientEquivOfSurjectiveEquivariant +- (MonoidHom.id H) Function.surjective_id eΓ heΓ +- have hf : Function.Surjective f := +- D.transferNormNaturalityIntermediateToFrobeniusSubgroup_surjective +- E L hL +- have he (m : M) +- (x : E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field S hSK) : +- e (m • x) = f m • e x := by +- exact D.frobeniusFixedCosetClosureEquiv_equivariant +- E L hL σ m x +- let eAction := orbitQuotientEquivOfSurjectiveEquivariant f hf e he +- exact (orbitQuotientSwapEquiv (Subgroup.zpowers σ.1) H).trans +- ((orbitQuotientClosedCyclicEquiv H hHclosed σ.1).trans +- (eΓorbit.trans eAction.symm)) +- +-/-- The transfer-norm orbit equivalence sends quotient representatives to their norm orbits. -/ +-@[simp] +-theorem transferNormNaturalityTransferNormOrbitEquiv_mk +- (D : DegreeData G) [IsTopologicalGroup G] [CompactSpace G] [T2Space G] +- (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) +- (hL : L.toSubgroup ≤ E.field.field.toSubgroup) +- [hLnormal : +- (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] +- [hL'normal : (extensionSubgroup E.field.field L hL).Normal] +- (σ : D.FrobeniusElements E.base L (hL.trans E.below)) +- (k : E.base.field.toSubgroup) : +- D.transferNormNaturalityTransferNormOrbitEquiv E L hL σ +- (Quotient.mk'' (QuotientGroup.mk +- (QuotientGroup.mk k : E.base.field.toSubgroup ⧸ +- D.extensionInertiaWithin E.base.field L (hL.trans E.below)) : +- (E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L +- (hL.trans E.below)) ⧸ +- D.transferNormNaturalityFrobeniusIntermediateSubgroup +- E L hL)) = +- Quotient.mk'' (QuotientGroup.mk k⁻¹ : +- E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field +- (D.frobeniusFixedField E.base L (hL.trans E.below) σ) +- (D.frobeniusFixedField_le E.base L +- (hL.trans E.below) σ)) := by +- unfold transferNormNaturalityTransferNormOrbitEquiv +- simp only [Equiv.trans_apply, orbitQuotientSwapEquiv_mk, +- orbitQuotientClosedCyclicEquiv_mk, +- orbitQuotientEquivOfSurjectiveEquivariant_mk, +- orbitQuotientEquivOfSurjectiveEquivariant_symm_mk, +- Subgroup.quotientEquivOfEq_mk] +- apply congrArg Quotient.mk'' +- exact (D.frobeniusFixedCosetClosureEquiv E.base L +- (hL.trans E.below) σ).symm_apply_apply (QuotientGroup.mk k⁻¹) +- + /-- On the classical chosen transfer representative `t`, the preceding + equivalence is literally the norm orbit represented by `t⁻¹`. -/ + theorem transferNormNaturalityTransferNormOrbitEquiv_apply +diff --git a/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusRestriction.lean b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusRestriction.lean +new file mode 100644 +index 0000000..4f8dc8c +--- /dev/null ++++ b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusRestriction.lean +@@ -0,0 +1,142 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.MainTransferFrobeniusSubgroup ++ ++ ++set_option autoImplicit false ++ ++ ++universe u ++ ++namespace ClassFormation ++ ++open KummerTheory ++open CyclicCohomology ++open CategoryTheory ++ ++noncomputable section ++ ++open scoped BigOperators ++open MulAction ++ ++section transferFrobeniusGeometry ++ ++variable {G : Type u} [Group G] [TopologicalSpace G] ++ ++ ++namespace DegreeData ++ ++/-- Restriction from the infinite Frobenius quotient onto the finite ++Galois quotient is surjective. -/ ++theorem transferNormNaturalityExtensionRestriction_surjective ++ (D : DegreeData G) ++ (K L : ClosedSubgroup G) ++ (hLK : L.toSubgroup ≤ K.toSubgroup) ++ [hLnormal : (extensionSubgroup K L hLK).Normal] : ++ Function.Surjective (D.extensionRestriction K L hLK) := by ++ intro q ++ refine QuotientGroup.induction_on q ?_ ++ intro k ++ exact ⟨QuotientGroup.mk k, rfl⟩ ++ ++ ++theorem transferNormNaturalityExtensionRestriction_ker_le_intermediate ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : ++ (D.extensionRestriction E.base.field L (hL.trans E.below)).ker ≤ ++ D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL := by ++ rw [D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map ++ E L hL] ++ intro q hq ++ revert hq ++ refine QuotientGroup.induction_on q ?_ ++ intro k hk ++ change D.extensionRestriction E.base.field L (hL.trans E.below) ++ (QuotientGroup.mk k) = 1 at hk ++ rw [D.extensionRestriction_mk] at hk ++ have hkL : k ∈ ++ extensionSubgroup E.base.field L (hL.trans E.below) := by ++ exact QuotientGroup.eq_one_iff k |>.1 hk ++ have hkK' : k ∈ ++ extensionSubgroup E.base.field E.field.field E.below := by ++ apply (mem_extensionSubgroup_iff ++ E.base.field E.field.field E.below k).2 ++ exact hL ((mem_extensionSubgroup_iff E.base.field L ++ (hL.trans E.below) k).1 hkL) ++ exact ⟨k, hkK', rfl⟩ ++ ++/-- `H` has finite index in `G(\widetilde L/K)`, with no normality ++assumption on the intermediate extension `K'/K`. -/ ++theorem transferNormNaturalityFrobeniusIntermediateFiniteIndex ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (R : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ R.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup R.base.field L (hL.trans R.below)).Normal] ++ [hL'normal : (extensionSubgroup R.field.field L hL).Normal] : ++ (D.transferNormNaturalityFrobeniusIntermediateSubgroup R L hL).FiniteIndex := by ++ rw [D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map ++ R L hL] ++ let I := D.extensionInertiaWithin R.base.field L (hL.trans R.below) ++ let M := extensionSubgroup R.base.field R.field.field R.below ++ have hIM : I ≤ M := by ++ intro k hk ++ apply (mem_extensionSubgroup_iff ++ R.base.field R.field.field R.below k).2 ++ exact hL ((mem_extensionSubgroup_iff R.base.field L ++ (hL.trans R.below) k).1 hk.1) ++ let p := QuotientGroup.mk' I ++ have hker : p.ker ≤ M := by ++ simpa [p] using hIM ++ let : M.FiniteIndex := Subgroup.finiteIndex_of_finite_quotient ++ rw [Subgroup.finiteIndex_iff, ++ M.index_map_eq (QuotientGroup.mk'_surjective I) hker] ++ exact Subgroup.FiniteIndex.index_ne_zero ++ ++/-- The copy of `G(\widetilde L/K')` is closed in ++`G(\widetilde L/K)`. -/ ++theorem transferNormNaturalityFrobeniusIntermediate_isClosed ++ (D : DegreeData G) [IsTopologicalGroup G] [CompactSpace G] [T2Space G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : ++ IsClosed (D.transferNormNaturalityFrobeniusIntermediateSubgroup ++ E L hL : Set ++ (E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L ++ (hL.trans E.below))) := by ++ let : CompactSpace E.field.field.toSubgroup := ++ isCompact_iff_compactSpace.mp E.field.field.isClosed'.isCompact ++ let : IsClosed ++ (D.extensionInertiaWithin E.field.field L hL : ++ Set E.field.field.toSubgroup) := ++ D.extensionInertiaWithin_isClosed E.field L hL ++ let : IsClosed (D.extensionInertiaWithin E.base.field L ++ (hL.trans E.below) : Set E.base.field.toSubgroup) := ++ D.extensionInertiaWithin_isClosed E.base L (hL.trans E.below) ++ let f := D.finiteReciprocityNaturalityFrobeniusTowerMapContinuous ++ E.base.field E.field.field L L ++ (hL.trans E.below) hL E.below le_rfl ++ change IsClosed (Set.range f) ++ have hrange : Set.range f = Set.range f.toContinuousMap := by ++ ext y ++ constructor <;> rintro ⟨x, rfl⟩ <;> exact ⟨x, rfl⟩ ++ rw [hrange] ++ simpa only [Set.image_univ] using ++ (isCompact_univ.image f.continuous).isClosed ++ ++ ++end DegreeData ++end transferFrobeniusGeometry ++end ++end ClassFormation +diff --git a/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusSubgroup.lean b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusSubgroup.lean +new file mode 100644 +index 0000000..d46fda8 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferFrobeniusSubgroup.lean +@@ -0,0 +1,249 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.MainNaturality ++import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.DoubleCosetOrbitGeometry ++ ++ ++set_option autoImplicit false ++ ++ ++universe u ++ ++namespace ClassFormation ++ ++open KummerTheory ++open CyclicCohomology ++open CategoryTheory ++ ++noncomputable section ++ ++open scoped BigOperators ++open MulAction ++ ++section transferFrobeniusGeometry ++ ++variable {G : Type u} [Group G] [TopologicalSpace G] ++ ++/-- The absolute group of an intermediate field, identified with its ++literal copy inside the absolute group of the base field. -/ ++noncomputable def transferNormNaturalityIntermediateAbsoluteEquiv ++ (K K' : ClosedSubgroup G) ++ (hK'K : K'.toSubgroup ≤ K.toSubgroup) : ++ K'.toSubgroup ≃* extensionSubgroup K K' hK'K := ++ MulEquiv.ofBijective ++ ((Subgroup.inclusion hK'K).codRestrict ++ (extensionSubgroup K K' hK'K) (fun k' => k'.2)) ++ ⟨fun _ _ h => Subtype.ext (congrArg (fun z => z.1.1) h), by ++ rintro ⟨k, hk'⟩ ++ let k' : K'.toSubgroup := ⟨k.1, hk'⟩ ++ exact ⟨k', Subtype.ext rfl⟩⟩ ++ ++/-- The absolute intermediate-field equivalence evaluates by the underlying transfer map. -/ ++@[simp] ++theorem transferNormNaturalityIntermediateAbsoluteEquiv_apply ++ (K K' : ClosedSubgroup G) ++ (hK'K : K'.toSubgroup ≤ K.toSubgroup) ++ (k' : K'.toSubgroup) : ++ ((transferNormNaturalityIntermediateAbsoluteEquiv K K' hK'K k').1 : G) = k'.1 := ++ rfl ++ ++/-- Normality of `L | K` restricts to every intermediate field `K'`. -/ ++theorem transferNormNaturality_intermediateExtension_normal ++ (K K' L : ClosedSubgroup G) ++ (hLK' : L.toSubgroup ≤ K'.toSubgroup) ++ (hK'K : K'.toSubgroup ≤ K.toSubgroup) ++ [hLnormal : (extensionSubgroup K L (hLK'.trans hK'K)).Normal] : ++ (extensionSubgroup K' L hLK').Normal := by ++ have hcomap : extensionSubgroup K' L hLK' = ++ (extensionSubgroup K L (hLK'.trans hK'K)).comap ++ (Subgroup.inclusion hK'K) := by ++ ext k' ++ rw [Subgroup.mem_comap, mem_extensionSubgroup_iff, ++ mem_extensionSubgroup_iff] ++ rfl ++ rw [hcomap] ++ exact hLnormal.comap (Subgroup.inclusion hK'K) ++ ++namespace DegreeData ++ ++/-- The restriction map on the infinite Frobenius quotients is injective ++when the top field is unchanged. -/ ++theorem transferNormNaturalityFrobeniusTowerMap_injective ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : ++ Function.Injective ++ (D.finiteReciprocityNaturalityFrobeniusTowerMap ++ E.base.field E.field.field L L ++ (hL.trans E.below) hL E.below le_rfl) := by ++ intro x y ++ refine QuotientGroup.induction_on x ?_ ++ intro k' ++ refine QuotientGroup.induction_on y ?_ ++ intro l' h ++ apply QuotientGroup.eq.mpr ++ have hmem : ++ (Subgroup.inclusion E.below k')⁻¹ * Subgroup.inclusion E.below l' ∈ ++ D.extensionInertiaWithin E.base.field L (hL.trans E.below) := ++ QuotientGroup.eq.mp h ++ constructor ++ · apply (mem_extensionSubgroup_iff E.field.field L hL (k'⁻¹ * l')).2 ++ have hG := (mem_extensionSubgroup_iff E.base.field L ++ (hL.trans E.below) ++ ((Subgroup.inclusion E.below k')⁻¹ * ++ Subgroup.inclusion E.below l')).1 hmem.1 ++ simpa using hG ++ · have hI := hmem.2 ++ change D.degree (((Subgroup.inclusion E.below k')⁻¹ * ++ Subgroup.inclusion E.below l' : E.base.field.toSubgroup) : G) = 1 at hI ++ change D.degree ((k'⁻¹ * l' : E.field.field.toSubgroup) : G) = 1 ++ exact hI ++ ++/-- The copy of `G(\widetilde L/K')` inside ++`G(\widetilde L/K)`. This is the subgroup `H` used in the classical ++double-coset proof of transfer--norm naturality. -/ ++def transferNormNaturalityFrobeniusIntermediateSubgroup ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : ++ Subgroup (E.base.field.toSubgroup ⧸ ++ D.extensionInertiaWithin E.base.field L (hL.trans E.below)) := ++ (D.finiteReciprocityNaturalityFrobeniusTowerMap ++ E.base.field E.field.field L L ++ (hL.trans E.below) hL E.below le_rfl).range ++ ++/-- The subgroup above is also the image of `G_K'` under the quotient ++projection `G_K → G(\widetilde L/K)`. -/ ++theorem transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : ++ D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL = ++ (extensionSubgroup E.base.field E.field.field E.below).map ++ (QuotientGroup.mk' ++ (D.extensionInertiaWithin E.base.field L ++ (hL.trans E.below))) := by ++ ext q ++ constructor ++ · rintro ⟨x, rfl⟩ ++ refine QuotientGroup.induction_on x ?_ ++ intro k' ++ refine ⟨Subgroup.inclusion E.below k', ?_, rfl⟩ ++ exact k'.2 ++ · rintro ⟨k, hk', rfl⟩ ++ let k' : E.field.field.toSubgroup := ⟨k.1, hk'⟩ ++ refine ⟨QuotientGroup.mk k', ?_⟩ ++ change QuotientGroup.mk (Subgroup.inclusion E.below k') = ++ QuotientGroup.mk k ++ rfl ++ ++/-- Quotient projection maps the literal absolute subgroup belonging to ++`K'` onto its copy `H` inside `G(\widetilde L/K)`. -/ ++noncomputable def transferNormNaturalityIntermediateToFrobeniusSubgroup ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : ++ extensionSubgroup E.base.field E.field.field E.below →* ++ D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL := by ++ refine ((QuotientGroup.mk' ++ (D.extensionInertiaWithin E.base.field L (hL.trans E.below))).comp ++ (extensionSubgroup E.base.field E.field.field E.below).subtype).codRestrict ++ (D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL) ?_ ++ intro m ++ change QuotientGroup.mk m.1 ∈ ++ D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL ++ rw [D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map ++ E L hL] ++ exact ⟨m.1, m.2, rfl⟩ ++ ++/-- The map from the intermediate quotient onto the Frobenius subgroup is surjective. -/ ++theorem transferNormNaturalityIntermediateToFrobeniusSubgroup_surjective ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] : ++ Function.Surjective ++ (D.transferNormNaturalityIntermediateToFrobeniusSubgroup ++ E L hL) := by ++ intro h ++ have hh : h.1 ∈ ++ (extensionSubgroup E.base.field E.field.field E.below).map ++ (QuotientGroup.mk' ++ (D.extensionInertiaWithin E.base.field L (hL.trans E.below))) := by ++ rw [← D.transferNormNaturalityFrobeniusIntermediateSubgroup_eq_map ++ E L hL] ++ exact h.2 ++ obtain ⟨m, hm, hval⟩ := hh ++ refine ⟨⟨m, hm⟩, ?_⟩ ++ apply Subtype.ext ++ unfold transferNormNaturalityIntermediateToFrobeniusSubgroup ++ simpa only [MonoidHom.codRestrict_apply, MonoidHom.comp_apply, ++ Subgroup.subtype_apply] using hval ++ ++/-- The intermediate-to-Frobenius map has the stated value on each representative. -/ ++@[simp] ++theorem transferNormNaturalityIntermediateToFrobeniusSubgroup_apply ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] ++ (m : extensionSubgroup E.base.field E.field.field E.below) : ++ (D.transferNormNaturalityIntermediateToFrobeniusSubgroup ++ E L hL m).1 = ++ (QuotientGroup.mk m.1 : E.base.field.toSubgroup ⧸ ++ D.extensionInertiaWithin E.base.field L (hL.trans E.below)) := by ++ rfl ++ ++/-- The canonical coset equivalence from `G_K/G_Σ` to ++`G(\widetilde L/K)/Γ` intertwines the two copies of the `K'`-action. -/ ++theorem frobeniusFixedCosetClosureEquiv_equivariant ++ (D : DegreeData G) [IsTopologicalGroup G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] ++ (σ : D.FrobeniusElements E.base L (hL.trans E.below)) ++ (m : extensionSubgroup E.base.field E.field.field E.below) ++ (x : E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field ++ (D.frobeniusFixedField E.base L (hL.trans E.below) σ) ++ (D.frobeniusFixedField_le E.base L (hL.trans E.below) σ)) : ++ D.frobeniusFixedCosetClosureEquiv E.base L (hL.trans E.below) σ (m • x) = ++ (D.transferNormNaturalityIntermediateToFrobeniusSubgroup ++ E L hL m) • ++ D.frobeniusFixedCosetClosureEquiv E.base L ++ (hL.trans E.below) σ x := by ++ refine Quotient.inductionOn' x ?_ ++ intro k ++ change QuotientGroup.mk (QuotientGroup.mk (m.1 * k)) = ++ QuotientGroup.mk ++ ((D.transferNormNaturalityIntermediateToFrobeniusSubgroup ++ E L hL m).1 * QuotientGroup.mk k) ++ rw [D.transferNormNaturalityIntermediateToFrobeniusSubgroup_apply] ++ rfl ++ ++ ++end DegreeData ++end transferFrobeniusGeometry ++end ++end ClassFormation +diff --git a/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferNormOrbitEquiv.lean b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferNormOrbitEquiv.lean +new file mode 100644 +index 0000000..5ce3d85 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferNormOrbitEquiv.lean +@@ -0,0 +1,107 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.MainTransferFrobeniusRestriction ++ ++ ++set_option autoImplicit false ++ ++ ++universe u ++ ++namespace ClassFormation ++ ++open KummerTheory ++open CyclicCohomology ++open CategoryTheory ++ ++noncomputable section ++ ++open scoped BigOperators ++open MulAction ++ ++section transferFrobeniusGeometry ++ ++variable {G : Type u} [Group G] [TopologicalSpace G] ++ ++ ++namespace DegreeData ++ ++/-- The transfer-orbit index set ++`⟨σ⟩ \ G(\widetilde L/K) / H` is canonically the norm double-coset ++index set `G_K' \ G_K / G_Σ`. The equivalence is inversion of double ++cosets, followed by passage from powers of `σ` to their closure `Γ` and ++the canonical identification `G_K/G_Σ ≃ G(\widetilde L/K)/Γ`. -/ ++noncomputable def transferNormNaturalityTransferNormOrbitEquiv ++ (D : DegreeData G) [IsTopologicalGroup G] [CompactSpace G] [T2Space G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] ++ (σ : D.FrobeniusElements E.base L (hL.trans E.below)) : ++ Quotient (orbitRel (Subgroup.zpowers σ.1) ++ ((E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L ++ (hL.trans E.below)) ⧸ ++ D.transferNormNaturalityFrobeniusIntermediateSubgroup ++ E L hL)) ≃ ++ Quotient (orbitRel ++ (extensionSubgroup E.base.field E.field.field E.below) ++ (E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field ++ (D.frobeniusFixedField E.base L (hL.trans E.below) σ) ++ (D.frobeniusFixedField_le E.base L ++ (hL.trans E.below) σ))) := by ++ let P := E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L ++ (hL.trans E.below) ++ let H := D.transferNormNaturalityFrobeniusIntermediateSubgroup E L hL ++ let M := extensionSubgroup E.base.field E.field.field E.below ++ let Γ := D.frobeniusClosure E.base L (hL.trans E.below) σ ++ let S := D.frobeniusFixedField E.base L (hL.trans E.below) σ ++ let hSK := D.frobeniusFixedField_le E.base L (hL.trans E.below) σ ++ let f : M →* H := D.transferNormNaturalityIntermediateToFrobeniusSubgroup ++ E L hL ++ let e := D.frobeniusFixedCosetClosureEquiv ++ E.base L (hL.trans E.below) σ ++ letI : H.FiniteIndex := ++ D.transferNormNaturalityFrobeniusIntermediateFiniteIndex E L hL ++ have hHclosed : IsClosed (H : Set P) := ++ D.transferNormNaturalityFrobeniusIntermediate_isClosed E L hL ++ have hΓ : ++ (closedSubgroupGenerated ({σ.1} : Set P)).toSubgroup = Γ.toSubgroup := by ++ simp only [Γ, DegreeData.frobeniusClosure, Set.range_const] ++ let eΓ : P ⧸ (closedSubgroupGenerated ({σ.1} : Set P)).toSubgroup ≃ ++ P ⧸ Γ.toSubgroup := Subgroup.quotientEquivOfEq hΓ ++ have heΓ (h : H) ++ (x : P ⧸ (closedSubgroupGenerated ({σ.1} : Set P)).toSubgroup) : ++ eΓ (h • x) = h • eΓ x := by ++ refine Quotient.inductionOn' x ?_ ++ intro p ++ change eΓ (QuotientGroup.mk (h.val * p)) = h • eΓ (QuotientGroup.mk p) ++ simp only [eΓ, Subgroup.quotientEquivOfEq_mk] ++ rfl ++ let eΓorbit := orbitQuotientEquivOfSurjectiveEquivariant ++ (MonoidHom.id H) Function.surjective_id eΓ heΓ ++ have hf : Function.Surjective f := ++ D.transferNormNaturalityIntermediateToFrobeniusSubgroup_surjective ++ E L hL ++ have he (m : M) ++ (x : E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field S hSK) : ++ e (m • x) = f m • e x := by ++ exact D.frobeniusFixedCosetClosureEquiv_equivariant ++ E L hL σ m x ++ let eAction := orbitQuotientEquivOfSurjectiveEquivariant f hf e he ++ exact (orbitQuotientSwapEquiv (Subgroup.zpowers σ.1) H).trans ++ ((orbitQuotientClosedCyclicEquiv H hHclosed σ.1).trans ++ (eΓorbit.trans eAction.symm)) ++ ++ ++end DegreeData ++ ++end transferFrobeniusGeometry ++end ++ ++end ClassFormation +diff --git a/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferNormOrbitMk.lean b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferNormOrbitMk.lean +new file mode 100644 +index 0000000..0e23056 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/AbstractClassFieldTheory/Reciprocity/Construction/MainTransferNormOrbitMk.lean +@@ -0,0 +1,74 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Construction.MainTransferNormOrbitEquiv ++ ++ ++set_option autoImplicit false ++ ++ ++universe u ++ ++namespace ClassFormation ++ ++open KummerTheory ++open CyclicCohomology ++open CategoryTheory ++ ++noncomputable section ++ ++open scoped BigOperators ++open MulAction ++ ++section transferFrobeniusGeometry ++ ++variable {G : Type u} [Group G] [TopologicalSpace G] ++ ++ ++namespace DegreeData ++ ++/-- The transfer-norm orbit equivalence sends quotient representatives to their norm orbits. -/ ++@[simp] ++theorem transferNormNaturalityTransferNormOrbitEquiv_mk ++ (D : DegreeData G) [IsTopologicalGroup G] [CompactSpace G] [T2Space G] ++ (E : FiniteResidueAbstractExtension D) (L : ClosedSubgroup G) ++ (hL : L.toSubgroup ≤ E.field.field.toSubgroup) ++ [hLnormal : ++ (extensionSubgroup E.base.field L (hL.trans E.below)).Normal] ++ [hL'normal : (extensionSubgroup E.field.field L hL).Normal] ++ (σ : D.FrobeniusElements E.base L (hL.trans E.below)) ++ (k : E.base.field.toSubgroup) : ++ D.transferNormNaturalityTransferNormOrbitEquiv E L hL σ ++ (Quotient.mk'' (QuotientGroup.mk ++ (QuotientGroup.mk k : E.base.field.toSubgroup ⧸ ++ D.extensionInertiaWithin E.base.field L (hL.trans E.below)) : ++ (E.base.field.toSubgroup ⧸ D.extensionInertiaWithin E.base.field L ++ (hL.trans E.below)) ⧸ ++ D.transferNormNaturalityFrobeniusIntermediateSubgroup ++ E L hL)) = ++ Quotient.mk'' (QuotientGroup.mk k⁻¹ : ++ E.base.field.toSubgroup ⧸ extensionSubgroup E.base.field ++ (D.frobeniusFixedField E.base L (hL.trans E.below) σ) ++ (D.frobeniusFixedField_le E.base L ++ (hL.trans E.below) σ)) := by ++ unfold transferNormNaturalityTransferNormOrbitEquiv ++ simp only [Equiv.trans_apply, orbitQuotientSwapEquiv_mk, ++ orbitQuotientClosedCyclicEquiv_mk, ++ orbitQuotientEquivOfSurjectiveEquivariant_mk, ++ orbitQuotientEquivOfSurjectiveEquivariant_symm_mk, ++ Subgroup.quotientEquivOfEq_mk] ++ apply congrArg Quotient.mk'' ++ exact (D.frobeniusFixedCosetClosureEquiv E.base L ++ (hL.trans E.below) σ).symm_apply_apply (QuotientGroup.mk k⁻¹) ++ ++ ++end DegreeData ++ ++end transferFrobeniusGeometry ++end ++ ++end ClassFormation +diff --git a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/AdeleBaseChange.lean b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/AdeleBaseChange.lean +index fa7f215..d8d918e 100644 +--- a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/AdeleBaseChange.lean ++++ b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/AdeleBaseChange.lean +@@ -7,15 +7,9 @@ Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + import ClassFieldTheory.AlgebraicNumberTheory.Idele.BaseChange + import ClassFieldTheory.AlgebraicNumberTheory.Completion.AdicCompletionComparison + +-set_option autoImplicit false + +-/-! +-# Scalar extension from relative to ordinary adeles ++set_option autoImplicit false + +-This file upgrades the relative-to-ordinary idele comparison to the +-underlying adele rings. The additive structure is needed to transport +-determinant norms in a field tower. +--/ + + open scoped NumberField TensorProduct RestrictedProduct + open NumberField IsDedekindDomain +diff --git a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/Idele/NormTopology/ExtensionBehavior.lean b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/Idele/NormTopology/ExtensionBehavior.lean +index 2e624da..f838ee6 100644 +--- a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/Idele/NormTopology/ExtensionBehavior.lean ++++ b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/Idele/NormTopology/ExtensionBehavior.lean +@@ -6,6 +6,7 @@ Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + + import ClassFieldTheory.AlgebraicNumberTheory.Idele.NormTopology.FiniteNormArithmetic + ++ + set_option autoImplicit false + + /-! +@@ -40,12 +41,20 @@ private theorem infinitePlaceCompletionMap_isometry + Isometry + (NumberField.LiesOver.completionMap + (v := v₀) (w := W)) := by +- unfold NumberField.LiesOver.completionMap +- exact +- (InfinitePlace.Completion.isometryEquivCompletion W).symm.isometry.comp +- ((UniformSpace.Completion.isometry_mapRingHom +- (InfinitePlace.LiesOver.isometry_algebraMap W v₀)).comp +- (InfinitePlace.Completion.isometryEquivCompletion v₀).isometry) ++ apply AddMonoidHomClass.isometry_of_norm ++ (NumberField.LiesOver.completionMap (v := v₀) (w := W)) ++ intro x ++ refine InfinitePlace.Completion.induction_on v₀ x ++ (isClosed_eq ++ (continuous_norm.comp NumberField.LiesOver.continuous_completionMap) ++ continuous_norm) ?_ ++ intro a ++ rw [NumberField.LiesOver.completionMap_coe] ++ have h := (InfinitePlace.LiesOver.isometry_algebraMap W v₀).norm_map_of_map_zero ++ (map_zero (algebraMap (WithAbs v₀.1) (WithAbs W.1))) a ++ simp only [InfinitePlace.Completion.norm_coe, WithAbs.norm_eq_apply_ofAbs, ++ WithAbs.equiv_apply, InfinitePlace.coe_apply] at h ⊢ ++ with_reducible exact h + + omit [NumberField L] in + /-- Mapping a unit along an infinite-place completion map preserves its +diff --git a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/Ideal.lean b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/Ideal.lean +index d626883..6255279 100644 +--- a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/Ideal.lean ++++ b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/Ideal.lean +@@ -4,23 +4,12 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.AlgebraicNumberTheory.RayClass.Topology +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.LocallyCompact +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.PrincipalNorm +-import ValuedFieldTheory.Valuation.AbsoluteValue.Theory.AbsoluteValues +-import Mathlib.NumberTheory.NumberField.Completion.InfinitePlace +-import Mathlib.Topology.Algebra.IsOpenUnits +-import Mathlib.Topology.Algebra.Ring.Compact + +-set_option autoImplicit false ++import ClassFieldTheory.AlgebraicNumberTheory.RayClass.IdealApproximation + +-/-! +-# Ideals prime to a ray-class modulus + +-This file defines the subgroup of fractional ideals prime to a modulus, +-connects it with the corresponding finite-idele higher-unit conditions, and +-develops the approximation maps used in ray-class ideal constructions. +--/ ++set_option autoImplicit false ++ + + open scoped NumberField WithZero Classical + open NumberField IsDedekindDomain +@@ -32,690 +21,6 @@ variable {K : Type*} [Field K] [NumberField K] + + namespace RayClass + +-/-- Fractional ideals having valuation zero at every finite prime in the +-support of the modulus. -/ +-def primeToModulusIdeals (m : Modulus K) : +- Subgroup (FractionalIdealGroup K) where +- carrier := {I | ∀ v, v ∈ m.finitePart.support → +- FractionalIdeal.count K v +- (I : FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = 0} +- one_mem' v _ := FractionalIdeal.count_one K v +- mul_mem' {I J} hI hJ v hv := by +- rw [Units.val_mul, +- FractionalIdeal.count_mul K v (Units.ne_zero I) (Units.ne_zero J), +- hI v hv, hJ v hv, add_zero] +- inv_mem' {I} hI v hv := by +- rw [Units.val_inv_eq_inv_val, FractionalIdeal.count_inv K v, +- hI v hv, neg_zero] +- +-@[simp] +-theorem mem_primeToModulusIdeals_iff +- (m : Modulus K) (I : FractionalIdealGroup K) : +- I ∈ primeToModulusIdeals m ↔ +- ∀ v, v ∈ m.finitePart.support → +- FractionalIdeal.count K v +- (I : FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = 0 := +- Iff.rfl +- +-/-- A finite prime outside the support of `m`, regarded as an element of +-the group of fractional ideals prime to `m`. -/ +-def primeToModulusIdeal +- (m : Modulus K) +- (v : HeightOneSpectrum (𝓞 K)) +- (hv : v ∉ m.finitePart.support) : +- primeToModulusIdeals m := +- ⟨FractionalIdealGroup.prime v, by +- intro w hw +- have hwv : w ≠ v := by +- intro h +- exact hv (h ▸ hw) +- change +- FractionalIdeal.count K w +- (v.asIdeal : +- FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = +- 0 +- exact +- FractionalIdeal.count_maximal_coprime +- K w hwv.symm⟩ +- +-/-- Coercing a prime outside the modulus support recovers its prime +-fractional ideal. -/ +-@[simp] +-theorem primeToModulusIdeal_coe +- (m : Modulus K) +- (v : HeightOneSpectrum (𝓞 K)) +- (hv : v ∉ m.finitePart.support) : +- (primeToModulusIdeal m v hv : +- FractionalIdealGroup K) = +- FractionalIdealGroup.prime v := +- rfl +- +-/-- Finite ideles satisfying the higher-unit condition at every prime in +-the support of the modulus. -/ +-def finitePrimeToModulusSubgroup (m : Modulus K) : +- Subgroup (FiniteIdeleGroup K) where +- carrier := {a | ∀ v, v ∈ m.finitePart.support → +- a v ∈ localHigherUnitGroup v (m.finitePart v)} +- one_mem' v _ := (localHigherUnitGroup v (m.finitePart v)).one_mem +- mul_mem' ha hb v hv := +- (localHigherUnitGroup v (m.finitePart v)).mul_mem (ha v hv) (hb v hv) +- inv_mem' ha v hv := +- (localHigherUnitGroup v (m.finitePart v)).inv_mem (ha v hv) +- +-/-- Ideles satisfying the infinite positivity and finite higher-unit +-conditions of a modulus. -/ +-def idelePrimeToModulusSubgroup (m : Modulus K) : +- Subgroup (IdeleGroup K) := +- m.infiniteCongruenceSubgroup.prod +- (finitePrimeToModulusSubgroup m) +- +-theorem localHigherUnitGroup_le_integralUnits +- (v : HeightOneSpectrum (𝓞 K)) (n : ℕ) : +- localHigherUnitGroup v n ≤ +- (v.adicCompletionIntegers K).units := by +- intro x hx +- rw [mem_localHigherUnitGroup_iff] at hx +- obtain ⟨y, rfl, _⟩ := hx +- exact y.property +- +-theorem fractionalIdeal_mem_primeToModulusIdeals +- (m : Modulus K) (a : IdeleGroup K) +- (ha : a ∈ idelePrimeToModulusSubgroup m) : +- IdeleGroup.fractionalIdeal a ∈ primeToModulusIdeals m := by +- intro v hv +- change FractionalIdeal.count K v +- (((FractionalIdealGroup.factorization (K := K)) +- (FiniteIdeleGroup.valuationVector a.2) : +- FractionalIdealGroup K) : +- FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = 0 +- rw [FractionalIdealGroup.count_factorization, +- FiniteIdeleGroup.valuationVector_apply] +- apply (FiniteIdeleGroup.localOrder_eq_zero_iff v (a.2 v)).2 +- exact localHigherUnitGroup_le_integralUnits v (m.finitePart v) (ha.2 v hv) +- +-/-- The fractional-ideal map restricted to ideles prime to a modulus. -/ +-def primeToIdealMap (m : Modulus K) : +- idelePrimeToModulusSubgroup m →* +- primeToModulusIdeals m where +- toFun a := +- ⟨IdeleGroup.fractionalIdeal a, +- fractionalIdeal_mem_primeToModulusIdeals m a a.property⟩ +- map_one' := by +- apply Subtype.ext +- exact map_one _ +- map_mul' a b := by +- apply Subtype.ext +- exact map_mul _ _ _ +- +-/-- A finite idele with a prescribed valuation vector away from the +-support of a modulus and value one on its support. -/ +-def valuationVectorSectionPrimeTo +- (m : Modulus K) +- (e : HeightOneSpectrum (𝓞 K) →₀ ℤ) : +- FiniteIdeleGroup K := +- ⟨fun v => +- if v ∈ m.finitePart.support then 1 +- else FiniteIdeleGroup.chosenLocalOrderSection v (e v), by +- filter_upwards +- [m.finitePart.support.eventually_cofinite_notMem, +- e.support.eventually_cofinite_notMem] with v hvm he +- simp only [hvm, ↓reduceIte] +- apply (FiniteIdeleGroup.localOrder_eq_zero_iff v _).1 +- rw [FiniteIdeleGroup.localOrder_chosenLocalOrderSection, +- Finsupp.notMem_support_iff.mp he]⟩ +- +-theorem valuationVector_valuationVectorSectionPrimeTo +- (m : Modulus K) +- (e : HeightOneSpectrum (𝓞 K) →₀ ℤ) +- (he : ∀ v, v ∈ m.finitePart.support → e v = 0) : +- FiniteIdeleGroup.valuationVector +- (valuationVectorSectionPrimeTo m e) = +- Multiplicative.ofAdd e := by +- apply Multiplicative.ext +- ext v +- rw [FiniteIdeleGroup.valuationVector_apply] +- by_cases hv : v ∈ m.finitePart.support +- · change +- (FiniteIdeleGroup.localOrder v +- (if v ∈ m.finitePart.support then 1 +- else FiniteIdeleGroup.chosenLocalOrderSection v (e v))).toAdd = +- e v +- rw [ite_eq_left hv, map_one] +- exact (he v hv).symm +- · change +- (FiniteIdeleGroup.localOrder v +- (if v ∈ m.finitePart.support then 1 +- else FiniteIdeleGroup.chosenLocalOrderSection v (e v))).toAdd = +- e v +- rw [ite_eq_right hv, +- FiniteIdeleGroup.localOrder_chosenLocalOrderSection] +- +-theorem primeToIdealMap_surjective (m : Modulus K) : +- Function.Surjective (primeToIdealMap m) := by +- intro I +- let e : HeightOneSpectrum (𝓞 K) →₀ ℤ := +- FractionalIdealGroup.countVector (I : FractionalIdealGroup K) +- have he : ∀ v, v ∈ m.finitePart.support → e v = 0 := by +- intro v hv +- exact I.property v hv +- let a : IdeleGroup K := +- (1, valuationVectorSectionPrimeTo m e) +- have ha : a ∈ idelePrimeToModulusSubgroup m := by +- constructor +- · exact m.infiniteCongruenceSubgroup.one_mem +- · intro v hv +- change +- (if v ∈ m.finitePart.support then 1 +- else FiniteIdeleGroup.chosenLocalOrderSection v (e v)) ∈ +- localHigherUnitGroup v (m.finitePart v) +- rw [ite_eq_left hv] +- exact (localHigherUnitGroup v (m.finitePart v)).one_mem +- refine ⟨⟨a, ha⟩, ?_⟩ +- apply Subtype.ext +- apply FractionalIdealGroup.ext_count +- intro v +- change FractionalIdeal.count K v +- (((FractionalIdealGroup.factorization (K := K)) +- (FiniteIdeleGroup.valuationVector +- (valuationVectorSectionPrimeTo m e)) : +- FractionalIdealGroup K) : +- FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = +- FractionalIdeal.count K v +- ((I : FractionalIdealGroup K) : +- FractionalIdeal (nonZeroDivisors (𝓞 K)) K) +- rw [valuationVector_valuationVectorSectionPrimeTo m e he, +- FractionalIdealGroup.count_factorization] +- exact FractionalIdealGroup.countVector_apply I v +- +-theorem ideleCongruenceSubgroup_le_primeTo +- (m : Modulus K) : +- m.ideleCongruenceSubgroup ≤ +- idelePrimeToModulusSubgroup m := by +- intro a ha +- exact ⟨ha.1, fun v _ => ha.2 v⟩ +- +-/-- The congruence subgroup, viewed inside the subgroup of ideles prime +-to the modulus. -/ +-def congruenceSubgroupInPrimeTo (m : Modulus K) : +- Subgroup (idelePrimeToModulusSubgroup m) := +- m.ideleCongruenceSubgroup.subgroupOf +- (idelePrimeToModulusSubgroup m) +- +-theorem primeToIdealMap_ker (m : Modulus K) : +- (primeToIdealMap m).ker = +- congruenceSubgroupInPrimeTo m := by +- ext a +- constructor +- · intro ha +- have hintegral : +- (a : IdeleGroup K) ∈ +- IdeleGroup.integralAtFinitePlaces (K := K) := by +- rw [← IdeleGroup.fractionalIdeal_ker, +- MonoidHom.mem_ker] +- exact congrArg Subtype.val +- (MonoidHom.mem_ker.mp ha) +- constructor +- · exact a.property.1 +- · intro v +- by_cases hv : v ∈ m.finitePart.support +- · exact a.property.2 v hv +- · rw [Finsupp.notMem_support_iff.mp hv, +- localHigherUnitGroup_zero] +- exact hintegral v +- · intro ha +- apply MonoidHom.mem_ker.mpr +- apply Subtype.ext +- change IdeleGroup.fractionalIdeal (a : IdeleGroup K) = 1 +- rw [← MonoidHom.mem_ker, +- IdeleGroup.fractionalIdeal_ker] +- intro v +- exact localHigherUnitGroup_le_integralUnits v (m.finitePart v) (ha.2 v) +- +-/-- The quotient of ideles prime to a modulus by the congruence subgroup, +-identified with fractional ideals prime to the modulus. -/ +-def quotientCongruenceEquivPrimeToIdeals (m : Modulus K) : +- idelePrimeToModulusSubgroup m ⧸ +- congruenceSubgroupInPrimeTo m ≃* +- primeToModulusIdeals m := by +- rw [← primeToIdealMap_ker m] +- exact QuotientGroup.quotientKerEquivOfSurjective +- (primeToIdealMap m) (primeToIdealMap_surjective m) +- +-/-- Principal ideles satisfying the modulus conditions, considered inside +-`I_K^(m)`. -/ +-def principalSubgroupInPrimeTo (m : Modulus K) : +- Subgroup (idelePrimeToModulusSubgroup m) := +- Subgroup.comap (idelePrimeToModulusSubgroup m).subtype +- (IdeleGroup.principalSubgroup K) +- +-/-- Principal ideals generated by a totally positive element congruent to +-one modulo the finite modulus. -/ +-def principalRayIdealSubgroup (m : Modulus K) : +- Subgroup (primeToModulusIdeals m) := +- Subgroup.map (primeToIdealMap m) +- (principalSubgroupInPrimeTo m) +- +-theorem mem_principalRayIdealSubgroup_iff +- (m : Modulus K) (I : primeToModulusIdeals m) : +- I ∈ principalRayIdealSubgroup m ↔ +- ∃ x : Kˣ, +- ∃ _hx : IdeleGroup.principalIdele K x ∈ +- idelePrimeToModulusSubgroup m, +- toPrincipalIdeal (𝓞 K) K x = +- (I : FractionalIdealGroup K) := by +- constructor +- · rintro ⟨a, ha, hmap⟩ +- obtain ⟨x, hx⟩ := ha +- refine ⟨x, ?_, ?_⟩ +- · rw [hx] +- exact a.property +- · have hval := congrArg Subtype.val hmap +- change IdeleGroup.fractionalIdeal (a : IdeleGroup K) = +- (I : FractionalIdealGroup K) at hval +- rw [← IdeleGroup.fractionalIdeal_principalIdele] +- exact (congrArg (IdeleGroup.fractionalIdeal (K := K)) hx).trans hval +- · rintro ⟨x, hx, hideal⟩ +- let a : idelePrimeToModulusSubgroup m := +- ⟨IdeleGroup.principalIdele K x, hx⟩ +- have ha : a ∈ principalSubgroupInPrimeTo m := by +- change IdeleGroup.principalIdele K x ∈ +- IdeleGroup.principalSubgroup K +- exact ⟨x, rfl⟩ +- refine ⟨a, ha, ?_⟩ +- apply Subtype.ext +- change IdeleGroup.fractionalIdeal +- (IdeleGroup.principalIdele K x) = +- (I : FractionalIdealGroup K) +- rw [IdeleGroup.fractionalIdeal_principalIdele, hideal] +- +-/-- The ideal-theoretic ray class group `J_K^m / P_K^m`. -/ +-abbrev IdealRayClassGroup (m : Modulus K) := +- primeToModulusIdeals m ⧸ principalRayIdealSubgroup m +- +-/-- The canonical projection from ideles prime to the modulus to the +-ideal-theoretic ray class group. -/ +-def idealRayProjection (m : Modulus K) : +- idelePrimeToModulusSubgroup m →* +- IdealRayClassGroup m := +- (QuotientGroup.mk' (principalRayIdealSubgroup m)).comp +- (primeToIdealMap m) +- +-/-- The subgroup generated by congruence ideles and principal ideles +-inside the ideles prime to a modulus. -/ +-def raySubgroupInPrimeTo (m : Modulus K) : +- Subgroup (idelePrimeToModulusSubgroup m) := +- congruenceSubgroupInPrimeTo m ⊔ +- principalSubgroupInPrimeTo m +- +-theorem idealRayProjection_surjective (m : Modulus K) : +- Function.Surjective (idealRayProjection m) := by +- intro c +- obtain ⟨I, rfl⟩ := +- QuotientGroup.mk'_surjective +- (principalRayIdealSubgroup m) c +- obtain ⟨a, rfl⟩ := primeToIdealMap_surjective m I +- exact ⟨a, rfl⟩ +- +-theorem idealRayProjection_ker (m : Modulus K) : +- (idealRayProjection m).ker = +- raySubgroupInPrimeTo m := by +- ext a +- constructor +- · intro ha +- change QuotientGroup.mk' +- (principalRayIdealSubgroup m) +- (primeToIdealMap m a) = 1 at ha +- rw [QuotientGroup.mk'_apply, +- QuotientGroup.eq_one_iff] at ha +- obtain ⟨p, hp, hpa⟩ := ha +- let n : idelePrimeToModulusSubgroup m := a * p⁻¹ +- have hn : n ∈ congruenceSubgroupInPrimeTo m := by +- rw [← primeToIdealMap_ker m, MonoidHom.mem_ker] +- change primeToIdealMap m (a * p⁻¹) = 1 +- rw [map_mul, map_inv, hpa] +- simp +- rw [raySubgroupInPrimeTo, Subgroup.mem_sup] +- refine ⟨n, hn, p, hp, ?_⟩ +- dsimp [n] +- group +- · intro ha +- rw [raySubgroupInPrimeTo, Subgroup.mem_sup] at ha +- obtain ⟨n, hn, p, hp, rfl⟩ := ha +- change QuotientGroup.mk' +- (principalRayIdealSubgroup m) +- (primeToIdealMap m (n * p)) = 1 +- rw [map_mul] +- have hn' : primeToIdealMap m n = 1 := +- MonoidHom.mem_ker.mp +- ((primeToIdealMap_ker m).symm ▸ hn) +- rw [hn', one_mul] +- rw [QuotientGroup.mk'_apply, +- QuotientGroup.eq_one_iff] +- exact ⟨p, hp, rfl⟩ +- +-/-- The quotient of ideles prime to the modulus by the full ray subgroup, +-identified with the ideal-theoretic ray class group. -/ +-def quotientRaySubgroupEquivIdealRayClassGroup +- (m : Modulus K) : +- idelePrimeToModulusSubgroup m ⧸ +- raySubgroupInPrimeTo m ≃* +- IdealRayClassGroup m := +- (QuotientGroup.quotientMulEquivOfEq +- (idealRayProjection_ker m).symm).trans +- (QuotientGroup.quotientKerEquivOfSurjective +- (idealRayProjection m) +- (idealRayProjection_surjective m)) +- +-/-- The quotient equivalence induced by the ideal-ray projection evaluates on +-the class of a prime-to-modulus idele as the original projection. -/ +-@[simp] +-theorem quotientRaySubgroupEquivIdealRayClassGroup_mk +- (m : Modulus K) (a : idelePrimeToModulusSubgroup m) : +- quotientRaySubgroupEquivIdealRayClassGroup m +- (QuotientGroup.mk' (raySubgroupInPrimeTo m) a) = +- idealRayProjection m a := by +- rw [quotientRaySubgroupEquivIdealRayClassGroup, +- MulEquiv.trans_apply, QuotientGroup.mk'_apply, +- QuotientGroup.quotientMulEquivOfEq_mk] +- exact QuotientGroup.kerLift_mk (idealRayProjection m) a +- +-/-! ### Simultaneous approximation at the places in a modulus -/ +- +-/-- The finite primes in `m`, together with all infinite places. -/ +-abbrev ApproximationPlace (m : Modulus K) := +- (↥m.finitePart.support) ⊕ InfinitePlace K +- +-/-- The absolute value represented by an approximation place. -/ +-abbrev approximationAbsoluteValue (m : Modulus K) : +- ApproximationPlace m → AbsoluteValue K ℝ +- | Sum.inl v => NumberField.HeightOneSpectrum.adicAbv K v.1 +- | Sum.inr w => w.1 +- +-theorem adicAbv_isNontrivial +- (v : HeightOneSpectrum (𝓞 K)) : +- (NumberField.HeightOneSpectrum.adicAbv K v).IsNontrivial := by +- obtain ⟨x, hxv, hx0⟩ := +- Submodule.exists_mem_ne_zero_of_ne_bot v.ne_bot +- refine ⟨algebraMap (𝓞 K) K x, ?_, ?_⟩ +- · exact (FaithfulSMul.algebraMap_eq_zero_iff (𝓞 K) K).not.mpr hx0 +- · apply ne_of_lt +- rw [← FinitePlace.norm_embedding] +- exact (FinitePlace.norm_lt_one_iff_mem (K := K) v x).2 hxv +- +-theorem adicAbv_not_isEquiv_of_ne +- {v w : HeightOneSpectrum (𝓞 K)} (hvw : v ≠ w) : +- ¬ (NumberField.HeightOneSpectrum.adicAbv K v).IsEquiv +- (NumberField.HeightOneSpectrum.adicAbv K w) := by +- intro h +- have hnotle : ¬ v.asIdeal ≤ w.asIdeal := by +- intro hvw_le +- have htop_le : (⊤ : Ideal (𝓞 K)) ≤ w.asIdeal := by +- rw [← (v.isCoprime_of_ne w hvw).sup_eq] +- exact sup_le hvw_le le_rfl +- exact w.isPrime.ne_top (top_unique htop_le) +- obtain ⟨x, hxv, hxw⟩ := Set.not_subset.mp hnotle +- have hvlt : +- NumberField.HeightOneSpectrum.adicAbv K v +- (algebraMap (𝓞 K) K x) < 1 := by +- rw [← FinitePlace.norm_embedding] +- exact (FinitePlace.norm_lt_one_iff_mem (K := K) v x).2 hxv +- have hweq : +- NumberField.HeightOneSpectrum.adicAbv K w +- (algebraMap (𝓞 K) K x) = 1 := by +- rw [← FinitePlace.norm_embedding] +- exact (FinitePlace.norm_eq_one_iff_notMem (K := K) w x).2 hxw +- exact (ne_of_lt hvlt) (h.eq_one_iff.mpr hweq) +- +-theorem adicAbv_not_isEquiv_infinitePlace +- (v : HeightOneSpectrum (𝓞 K)) (w : InfinitePlace K) : +- ¬ (NumberField.HeightOneSpectrum.adicAbv K v).IsEquiv w.1 := by +- intro h +- have hle : +- w.1 ((2 : ℕ) : K) ≤ 1 := +- h.le_one_iff.mp +- (NumberField.HeightOneSpectrum.adicAbv_natCast_le_one K v 2) +- have hw : +- w.1 ((2 : ℕ) : K) = (2 : ℝ) := +- NumberField.InfinitePlace.map_natCast w 2 +- have hfalse : (2 : ℝ) ≤ 1 := hw ▸ hle +- norm_num at hfalse +- +-theorem approximationAbsoluteValue_isNontrivial +- (m : Modulus K) : +- ∀ i, (approximationAbsoluteValue m i).IsNontrivial +- | Sum.inl v => by +- change +- (NumberField.HeightOneSpectrum.adicAbv K v.1).IsNontrivial +- exact adicAbv_isNontrivial v.1 +- | Sum.inr w => by +- change w.1.IsNontrivial +- exact w.isNontrivial +- +-theorem approximationAbsoluteValue_pairwise +- (m : Modulus K) : +- Pairwise fun i j => +- ¬ (approximationAbsoluteValue m i).IsEquiv +- (approximationAbsoluteValue m j) := by +- intro i j hij +- cases i with +- | inl v => +- cases j with +- | inl w => +- apply adicAbv_not_isEquiv_of_ne +- intro hvw +- apply hij +- exact congrArg Sum.inl (Subtype.ext hvw) +- | inr w => +- exact adicAbv_not_isEquiv_infinitePlace v.1 w +- | inr v => +- cases j with +- | inl w => +- exact fun h => +- adicAbv_not_isEquiv_infinitePlace w.1 v h.symm +- | inr w => +- intro h +- apply hij +- congr +- change v.1.IsEquiv w.1 at h +- exact +- (InfinitePlace.eq_iff_isEquiv (K := K)).mpr h +- +-/-- The corresponding product of local completions. -/ +-abbrev approximationCompletion (m : Modulus K) : +- ApproximationPlace m → Type _ +- | Sum.inl v => v.1.adicCompletion K +- | Sum.inr w => w.Completion +- +-noncomputable instance approximationCompletionTopologicalSpace +- (m : Modulus K) (i : ApproximationPlace m) : +- TopologicalSpace (approximationCompletion m i) := by +- cases i <;> simp only [approximationCompletion] <;> infer_instance +- +-/-- Coordinatewise completion of the valued copies of `K`. -/ +-def approximationCompletionMap (m : Modulus K) : +- ∀ i : ApproximationPlace m, +- WithAbs (approximationAbsoluteValue m i) → +- approximationCompletion m i +- | Sum.inl v => +- fun x => +- FinitePlace.embedding v.1 +- (WithAbs.equiv +- (NumberField.HeightOneSpectrum.adicAbv K v.1) x) +- | Sum.inr w => fun x => (x : w.Completion) +- +-theorem denseRange_finiteApproximationCompletionMap +- (v : HeightOneSpectrum (𝓞 K)) : +- DenseRange +- (fun x : +- WithAbs (NumberField.HeightOneSpectrum.adicAbv K v) => +- FinitePlace.embedding v +- (WithAbs.equiv +- (NumberField.HeightOneSpectrum.adicAbv K v) x)) := by +- have hrange : +- Set.range +- (fun x : +- WithAbs (NumberField.HeightOneSpectrum.adicAbv K v) => +- FinitePlace.embedding v +- (WithAbs.equiv +- (NumberField.HeightOneSpectrum.adicAbv K v) x)) = +- Set.range (algebraMap K (v.adicCompletion K)) := by +- ext y +- constructor +- · rintro ⟨x, rfl⟩ +- exact +- ⟨WithAbs.equiv +- (NumberField.HeightOneSpectrum.adicAbv K v) x, rfl⟩ +- · rintro ⟨x, rfl⟩ +- refine +- ⟨(WithAbs.equiv +- (NumberField.HeightOneSpectrum.adicAbv K v)).symm x, ?_⟩ +- rfl +- rw [DenseRange, hrange] +- exact v.denseRange_algebraMap K +- +-theorem continuous_finiteApproximationCompletionMap +- (v : HeightOneSpectrum (𝓞 K)) : +- Continuous +- (fun x : +- WithAbs (NumberField.HeightOneSpectrum.adicAbv K v) => +- FinitePlace.embedding v +- (WithAbs.equiv +- (NumberField.HeightOneSpectrum.adicAbv K v) x)) := by +- apply Isometry.continuous +- apply Isometry.of_dist_eq +- intro x y +- rw [dist_eq_norm, dist_eq_norm, ← map_sub, +- FinitePlace.norm_embedding] +- rfl +- +-theorem denseRange_approximationCompletionMap +- (m : Modulus K) : +- ∀ i, DenseRange (approximationCompletionMap m i) +- | Sum.inl v => denseRange_finiteApproximationCompletionMap v.1 +- | Sum.inr w => +- NumberField.InfinitePlace.Completion.denseRange_coe w +- +-theorem continuous_approximationCompletionMap +- (m : Modulus K) : +- ∀ i, Continuous (approximationCompletionMap m i) +- | Sum.inl v => continuous_finiteApproximationCompletionMap v.1 +- | Sum.inr w => +- NumberField.InfinitePlace.Completion.continuous_coe w +- +-/-- The diagonal embedding into the finite product of the relevant +-completions. -/ +-def approximationEmbedding (m : Modulus K) : +- K → (i : ApproximationPlace m) → approximationCompletion m i := +- (Pi.map (approximationCompletionMap m)) ∘ +- algebraMap K +- ((i : ApproximationPlace m) → +- WithAbs (approximationAbsoluteValue m i)) +- +-@[simp] +-theorem approximationEmbedding_finite +- (m : Modulus K) (x : K) (v : ↥m.finitePart.support) : +- approximationEmbedding m x (Sum.inl v) = +- FinitePlace.embedding v.1 x := +- rfl +- +-@[simp] +-theorem approximationEmbedding_infinite +- (m : Modulus K) (x : K) (w : InfinitePlace K) : +- approximationEmbedding m x (Sum.inr w) = +- (x : w.Completion) := +- rfl +- +-theorem denseRange_approximationEmbedding (m : Modulus K) : +- DenseRange (approximationEmbedding m) := by +- exact +- (DenseRange.piMap +- (denseRange_approximationCompletionMap m)).comp +- (AbsoluteValue.denseRange_algebraMap_pi +- (approximationAbsoluteValue_isNontrivial m) +- (approximationAbsoluteValue_pairwise m)) +- (.piMap (continuous_approximationCompletionMap m)) +- +-/-- The open set of field elements whose ratio with a fixed unit lies in +-a prescribed open unit set. -/ +-def unitRatioSet +- {F : Type*} [Field F] (a : Fˣ) (U : Subgroup Fˣ) : +- Set F := +- Units.val '' (fun y : Fˣ => a * y⁻¹) ⁻¹' (U : Set Fˣ) +- +-/-- The unit-ratio set associated to an open set of units is open. -/ +-theorem isOpen_unitRatioSet +- {F : Type*} [Field F] [TopologicalSpace F] +- [IsTopologicalRing F] [ContinuousInv₀ F] [T1Space F] +- (a : Fˣ) (U : Subgroup Fˣ) +- (hU : IsOpen (U : Set Fˣ)) : +- IsOpen (unitRatioSet a U) := by +- apply IsOpenUnits.isOpenEmbedding_unitsVal.isOpenMap +- exact hU.preimage (continuous_const.mul continuous_inv) +- +-/-- The value of the distinguished unit belongs to its unit-ratio set. -/ +-theorem val_mem_unitRatioSet +- {F : Type*} [Field F] (a : Fˣ) (U : Subgroup Fˣ) : +- (a : F) ∈ unitRatioSet a U := by +- exact ⟨a, by simp, rfl⟩ +- +-/-- The open local conditions that make `a / x` prime to `m`. -/ +-def approximationTarget (m : Modulus K) (a : IdeleGroup K) : +- ∀ i : ApproximationPlace m, Set (approximationCompletion m i) +- | Sum.inl v => +- unitRatioSet (a.2 v.1) +- (localHigherUnitGroup v.1 (m.finitePart v.1)) +- | Sum.inr w => +- unitRatioSet +- (ContinuousMulEquiv.piUnits a.1 w) +- (m.localInfiniteCongruenceSubgroup w) +- +-theorem isOpen_approximationTarget +- (m : Modulus K) (a : IdeleGroup K) : +- ∀ i, IsOpen (approximationTarget m a i) +- | Sum.inl v => by +- change IsOpen +- (unitRatioSet (a.2 v.1) +- (localHigherUnitGroup v.1 (m.finitePart v.1))) +- exact isOpen_unitRatioSet _ _ +- (isOpen_localHigherUnitGroup v.1 (m.finitePart v.1)) +- | Sum.inr w => by +- change IsOpen +- (unitRatioSet +- (ContinuousMulEquiv.piUnits a.1 w) +- (m.localInfiniteCongruenceSubgroup w)) +- apply isOpen_unitRatioSet _ _ +- classical +- by_cases hw : w.IsReal +- · by_cases hmem : (⟨w, hw⟩ : RealPlace K) ∈ m.infinitePart +- · rw [Modulus.localInfiniteCongruenceSubgroup, +- dite_eq_left hw, dite_eq_left hmem] +- exact isOpen_infinitePositiveSubgroup w +- · rw [Modulus.localInfiniteCongruenceSubgroup, +- dite_eq_left hw, dite_eq_right hmem] +- exact isOpen_univ +- · rw [Modulus.localInfiniteCongruenceSubgroup, dite_eq_right hw] +- exact isOpen_univ +- +-/-- The given idele itself lies in the product of its approximation +-neighborhoods. -/ +-def approximationTargetPoint +- (m : Modulus K) (a : IdeleGroup K) : +- (i : ApproximationPlace m) → approximationCompletion m i +- | Sum.inl v => (a.2 v.1 : v.1.adicCompletion K) +- | Sum.inr w => +- (ContinuousMulEquiv.piUnits a.1 w : w.Completion) +- +-theorem approximationTargetPoint_mem +- (m : Modulus K) (a : IdeleGroup K) : +- approximationTargetPoint m a ∈ +- Set.univ.pi (approximationTarget m a) := by +- intro i _hi +- cases i with +- | inl v => +- exact val_mem_unitRatioSet _ _ +- | inr w => +- exact val_mem_unitRatioSet _ _ +- + /-- Weak approximation in the precise open local cosets required by the + modulus. -/ + theorem exists_principal_quotient_mem_primeTo +diff --git a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/IdealApproximation.lean b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/IdealApproximation.lean +new file mode 100644 +index 0000000..168aa31 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/IdealApproximation.lean +@@ -0,0 +1,322 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.AlgebraicNumberTheory.RayClass.IdealGroups ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped NumberField WithZero Classical ++open NumberField IsDedekindDomain ++ ++noncomputable section ++ ++ ++variable {K : Type*} [Field K] [NumberField K] ++ ++namespace RayClass ++ ++/-! ### Simultaneous approximation at the places in a modulus -/ ++ ++/-- The finite primes in `m`, together with all infinite places. -/ ++abbrev ApproximationPlace (m : Modulus K) := ++ (↥m.finitePart.support) ⊕ InfinitePlace K ++ ++/-- The absolute value represented by an approximation place. -/ ++abbrev approximationAbsoluteValue (m : Modulus K) : ++ ApproximationPlace m → AbsoluteValue K ℝ ++ | Sum.inl v => NumberField.HeightOneSpectrum.adicAbv K v.1 ++ | Sum.inr w => w.1 ++ ++theorem adicAbv_isNontrivial ++ (v : HeightOneSpectrum (𝓞 K)) : ++ (NumberField.HeightOneSpectrum.adicAbv K v).IsNontrivial := by ++ obtain ⟨x, hxv, hx0⟩ := ++ Submodule.exists_mem_ne_zero_of_ne_bot v.ne_bot ++ refine ⟨algebraMap (𝓞 K) K x, ?_, ?_⟩ ++ · exact (FaithfulSMul.algebraMap_eq_zero_iff (𝓞 K) K).not.mpr hx0 ++ · apply ne_of_lt ++ rw [← FinitePlace.norm_embedding] ++ exact (FinitePlace.norm_lt_one_iff_mem (K := K) v x).2 hxv ++ ++theorem adicAbv_not_isEquiv_of_ne ++ {v w : HeightOneSpectrum (𝓞 K)} (hvw : v ≠ w) : ++ ¬ (NumberField.HeightOneSpectrum.adicAbv K v).IsEquiv ++ (NumberField.HeightOneSpectrum.adicAbv K w) := by ++ intro h ++ have hnotle : ¬ v.asIdeal ≤ w.asIdeal := by ++ intro hvw_le ++ have htop_le : (⊤ : Ideal (𝓞 K)) ≤ w.asIdeal := by ++ rw [← (v.isCoprime_of_ne w hvw).sup_eq] ++ exact sup_le hvw_le le_rfl ++ exact w.isPrime.ne_top (top_unique htop_le) ++ obtain ⟨x, hxv, hxw⟩ := Set.not_subset.mp hnotle ++ have hvlt : ++ NumberField.HeightOneSpectrum.adicAbv K v ++ (algebraMap (𝓞 K) K x) < 1 := by ++ rw [← FinitePlace.norm_embedding] ++ exact (FinitePlace.norm_lt_one_iff_mem (K := K) v x).2 hxv ++ have hweq : ++ NumberField.HeightOneSpectrum.adicAbv K w ++ (algebraMap (𝓞 K) K x) = 1 := by ++ rw [← FinitePlace.norm_embedding] ++ exact (FinitePlace.norm_eq_one_iff_notMem (K := K) w x).2 hxw ++ exact (ne_of_lt hvlt) (h.eq_one_iff.mpr hweq) ++ ++theorem adicAbv_not_isEquiv_infinitePlace ++ (v : HeightOneSpectrum (𝓞 K)) (w : InfinitePlace K) : ++ ¬ (NumberField.HeightOneSpectrum.adicAbv K v).IsEquiv w.1 := by ++ intro h ++ have hle : ++ w.1 ((2 : ℕ) : K) ≤ 1 := ++ h.le_one_iff.mp ++ (NumberField.HeightOneSpectrum.adicAbv_natCast_le_one K v 2) ++ have hw : ++ w.1 ((2 : ℕ) : K) = (2 : ℝ) := ++ NumberField.InfinitePlace.map_natCast w 2 ++ have hfalse : (2 : ℝ) ≤ 1 := hw ▸ hle ++ norm_num at hfalse ++ ++theorem approximationAbsoluteValue_isNontrivial ++ (m : Modulus K) : ++ ∀ i, (approximationAbsoluteValue m i).IsNontrivial ++ | Sum.inl v => by ++ change ++ (NumberField.HeightOneSpectrum.adicAbv K v.1).IsNontrivial ++ exact adicAbv_isNontrivial v.1 ++ | Sum.inr w => by ++ change w.1.IsNontrivial ++ exact w.isNontrivial ++ ++theorem approximationAbsoluteValue_pairwise ++ (m : Modulus K) : ++ Pairwise fun i j => ++ ¬ (approximationAbsoluteValue m i).IsEquiv ++ (approximationAbsoluteValue m j) := by ++ intro i j hij ++ cases i with ++ | inl v => ++ cases j with ++ | inl w => ++ apply adicAbv_not_isEquiv_of_ne ++ intro hvw ++ apply hij ++ exact congrArg Sum.inl (Subtype.ext hvw) ++ | inr w => ++ exact adicAbv_not_isEquiv_infinitePlace v.1 w ++ | inr v => ++ cases j with ++ | inl w => ++ exact fun h => ++ adicAbv_not_isEquiv_infinitePlace w.1 v h.symm ++ | inr w => ++ intro h ++ apply hij ++ congr ++ change v.1.IsEquiv w.1 at h ++ exact ++ (InfinitePlace.eq_iff_isEquiv (K := K)).mpr h ++ ++/-- The corresponding product of local completions. -/ ++abbrev approximationCompletion (m : Modulus K) : ++ ApproximationPlace m → Type _ ++ | Sum.inl v => v.1.adicCompletion K ++ | Sum.inr w => w.Completion ++ ++noncomputable instance approximationCompletionTopologicalSpace ++ (m : Modulus K) (i : ApproximationPlace m) : ++ TopologicalSpace (approximationCompletion m i) := by ++ cases i <;> simp only [approximationCompletion] <;> infer_instance ++ ++/-- Coordinatewise completion of the valued copies of `K`. -/ ++def approximationCompletionMap (m : Modulus K) : ++ ∀ i : ApproximationPlace m, ++ WithAbs (approximationAbsoluteValue m i) → ++ approximationCompletion m i ++ | Sum.inl v => ++ fun x => ++ FinitePlace.embedding v.1 ++ (WithAbs.equiv ++ (NumberField.HeightOneSpectrum.adicAbv K v.1) x) ++ | Sum.inr w => fun x => (x : w.Completion) ++ ++theorem denseRange_finiteApproximationCompletionMap ++ (v : HeightOneSpectrum (𝓞 K)) : ++ DenseRange ++ (fun x : ++ WithAbs (NumberField.HeightOneSpectrum.adicAbv K v) => ++ FinitePlace.embedding v ++ (WithAbs.equiv ++ (NumberField.HeightOneSpectrum.adicAbv K v) x)) := by ++ have hrange : ++ Set.range ++ (fun x : ++ WithAbs (NumberField.HeightOneSpectrum.adicAbv K v) => ++ FinitePlace.embedding v ++ (WithAbs.equiv ++ (NumberField.HeightOneSpectrum.adicAbv K v) x)) = ++ Set.range (algebraMap K (v.adicCompletion K)) := by ++ ext y ++ constructor ++ · rintro ⟨x, rfl⟩ ++ exact ++ ⟨WithAbs.equiv ++ (NumberField.HeightOneSpectrum.adicAbv K v) x, rfl⟩ ++ · rintro ⟨x, rfl⟩ ++ refine ++ ⟨(WithAbs.equiv ++ (NumberField.HeightOneSpectrum.adicAbv K v)).symm x, ?_⟩ ++ rfl ++ rw [DenseRange, hrange] ++ exact v.denseRange_algebraMap K ++ ++theorem continuous_finiteApproximationCompletionMap ++ (v : HeightOneSpectrum (𝓞 K)) : ++ Continuous ++ (fun x : ++ WithAbs (NumberField.HeightOneSpectrum.adicAbv K v) => ++ FinitePlace.embedding v ++ (WithAbs.equiv ++ (NumberField.HeightOneSpectrum.adicAbv K v) x)) := by ++ apply Isometry.continuous ++ apply Isometry.of_dist_eq ++ intro x y ++ rw [dist_eq_norm, dist_eq_norm, ← map_sub, ++ FinitePlace.norm_embedding] ++ rfl ++ ++theorem denseRange_approximationCompletionMap ++ (m : Modulus K) : ++ ∀ i, DenseRange (approximationCompletionMap m i) ++ | Sum.inl v => denseRange_finiteApproximationCompletionMap v.1 ++ | Sum.inr w => ++ NumberField.InfinitePlace.Completion.denseRange_coe w ++ ++theorem continuous_approximationCompletionMap ++ (m : Modulus K) : ++ ∀ i, Continuous (approximationCompletionMap m i) ++ | Sum.inl v => continuous_finiteApproximationCompletionMap v.1 ++ | Sum.inr w => ++ NumberField.InfinitePlace.Completion.continuous_coe w ++ ++/-- The diagonal embedding into the finite product of the relevant ++completions. -/ ++def approximationEmbedding (m : Modulus K) : ++ K → (i : ApproximationPlace m) → approximationCompletion m i := ++ (Pi.map (approximationCompletionMap m)) ∘ ++ algebraMap K ++ ((i : ApproximationPlace m) → ++ WithAbs (approximationAbsoluteValue m i)) ++ ++@[simp] ++theorem approximationEmbedding_finite ++ (m : Modulus K) (x : K) (v : ↥m.finitePart.support) : ++ approximationEmbedding m x (Sum.inl v) = ++ FinitePlace.embedding v.1 x := ++ rfl ++ ++@[simp] ++theorem approximationEmbedding_infinite ++ (m : Modulus K) (x : K) (w : InfinitePlace K) : ++ approximationEmbedding m x (Sum.inr w) = ++ (x : w.Completion) := ++ rfl ++ ++theorem denseRange_approximationEmbedding (m : Modulus K) : ++ DenseRange (approximationEmbedding m) := by ++ exact ++ (DenseRange.piMap ++ (denseRange_approximationCompletionMap m)).comp ++ (AbsoluteValue.denseRange_algebraMap_pi ++ (approximationAbsoluteValue_isNontrivial m) ++ (approximationAbsoluteValue_pairwise m)) ++ (.piMap (continuous_approximationCompletionMap m)) ++ ++/-- The open set of field elements whose ratio with a fixed unit lies in ++a prescribed open unit set. -/ ++def unitRatioSet ++ {F : Type*} [Field F] (a : Fˣ) (U : Subgroup Fˣ) : ++ Set F := ++ Units.val '' (fun y : Fˣ => a * y⁻¹) ⁻¹' (U : Set Fˣ) ++ ++/-- The unit-ratio set associated to an open set of units is open. -/ ++theorem isOpen_unitRatioSet ++ {F : Type*} [Field F] [TopologicalSpace F] ++ [IsTopologicalRing F] [ContinuousInv₀ F] [T1Space F] ++ (a : Fˣ) (U : Subgroup Fˣ) ++ (hU : IsOpen (U : Set Fˣ)) : ++ IsOpen (unitRatioSet a U) := by ++ apply IsOpenUnits.isOpenEmbedding_unitsVal.isOpenMap ++ exact hU.preimage (continuous_const.mul continuous_inv) ++ ++/-- The value of the distinguished unit belongs to its unit-ratio set. -/ ++theorem val_mem_unitRatioSet ++ {F : Type*} [Field F] (a : Fˣ) (U : Subgroup Fˣ) : ++ (a : F) ∈ unitRatioSet a U := by ++ exact ⟨a, by simp, rfl⟩ ++ ++/-- The open local conditions that make `a / x` prime to `m`. -/ ++def approximationTarget (m : Modulus K) (a : IdeleGroup K) : ++ ∀ i : ApproximationPlace m, Set (approximationCompletion m i) ++ | Sum.inl v => ++ unitRatioSet (a.2 v.1) ++ (localHigherUnitGroup v.1 (m.finitePart v.1)) ++ | Sum.inr w => ++ unitRatioSet ++ (ContinuousMulEquiv.piUnits a.1 w) ++ (m.localInfiniteCongruenceSubgroup w) ++ ++theorem isOpen_approximationTarget ++ (m : Modulus K) (a : IdeleGroup K) : ++ ∀ i, IsOpen (approximationTarget m a i) ++ | Sum.inl v => by ++ change IsOpen ++ (unitRatioSet (a.2 v.1) ++ (localHigherUnitGroup v.1 (m.finitePart v.1))) ++ exact isOpen_unitRatioSet _ _ ++ (isOpen_localHigherUnitGroup v.1 (m.finitePart v.1)) ++ | Sum.inr w => by ++ change IsOpen ++ (unitRatioSet ++ (ContinuousMulEquiv.piUnits a.1 w) ++ (m.localInfiniteCongruenceSubgroup w)) ++ apply isOpen_unitRatioSet _ _ ++ classical ++ by_cases hw : w.IsReal ++ · by_cases hmem : (⟨w, hw⟩ : RealPlace K) ∈ m.infinitePart ++ · rw [Modulus.localInfiniteCongruenceSubgroup, ++ dite_eq_left hw, dite_eq_left hmem] ++ exact isOpen_infinitePositiveSubgroup w ++ · rw [Modulus.localInfiniteCongruenceSubgroup, ++ dite_eq_left hw, dite_eq_right hmem] ++ exact isOpen_univ ++ · rw [Modulus.localInfiniteCongruenceSubgroup, dite_eq_right hw] ++ exact isOpen_univ ++ ++/-- The given idele itself lies in the product of its approximation ++neighborhoods. -/ ++def approximationTargetPoint ++ (m : Modulus K) (a : IdeleGroup K) : ++ (i : ApproximationPlace m) → approximationCompletion m i ++ | Sum.inl v => (a.2 v.1 : v.1.adicCompletion K) ++ | Sum.inr w => ++ (ContinuousMulEquiv.piUnits a.1 w : w.Completion) ++ ++theorem approximationTargetPoint_mem ++ (m : Modulus K) (a : IdeleGroup K) : ++ approximationTargetPoint m a ∈ ++ Set.univ.pi (approximationTarget m a) := by ++ intro i _hi ++ cases i with ++ | inl v => ++ exact val_mem_unitRatioSet _ _ ++ | inr w => ++ exact val_mem_unitRatioSet _ _ ++ ++ ++end RayClass +diff --git a/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/IdealGroups.lean b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/IdealGroups.lean +new file mode 100644 +index 0000000..2b15f82 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/AlgebraicNumberTheory/RayClass/IdealGroups.lean +@@ -0,0 +1,417 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.AlgebraicNumberTheory.RayClass.Topology ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.LocallyCompact ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.PrincipalNorm ++import ValuedFieldTheory.Valuation.AbsoluteValue.Theory.AbsoluteValues ++import Mathlib.NumberTheory.NumberField.Completion.InfinitePlace ++import Mathlib.Topology.Algebra.IsOpenUnits ++import Mathlib.Topology.Algebra.Ring.Compact ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped NumberField WithZero Classical ++open NumberField IsDedekindDomain ++ ++noncomputable section ++ ++ ++variable {K : Type*} [Field K] [NumberField K] ++ ++namespace RayClass ++ ++/-- Fractional ideals having valuation zero at every finite prime in the ++support of the modulus. -/ ++def primeToModulusIdeals (m : Modulus K) : ++ Subgroup (FractionalIdealGroup K) where ++ carrier := {I | ∀ v, v ∈ m.finitePart.support → ++ FractionalIdeal.count K v ++ (I : FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = 0} ++ one_mem' v _ := FractionalIdeal.count_one K v ++ mul_mem' {I J} hI hJ v hv := by ++ rw [Units.val_mul, ++ FractionalIdeal.count_mul K v (Units.ne_zero I) (Units.ne_zero J), ++ hI v hv, hJ v hv, add_zero] ++ inv_mem' {I} hI v hv := by ++ rw [Units.val_inv_eq_inv_val, FractionalIdeal.count_inv K v, ++ hI v hv, neg_zero] ++ ++@[simp] ++theorem mem_primeToModulusIdeals_iff ++ (m : Modulus K) (I : FractionalIdealGroup K) : ++ I ∈ primeToModulusIdeals m ↔ ++ ∀ v, v ∈ m.finitePart.support → ++ FractionalIdeal.count K v ++ (I : FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = 0 := ++ Iff.rfl ++ ++/-- A finite prime outside the support of `m`, regarded as an element of ++the group of fractional ideals prime to `m`. -/ ++def primeToModulusIdeal ++ (m : Modulus K) ++ (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ m.finitePart.support) : ++ primeToModulusIdeals m := ++ ⟨FractionalIdealGroup.prime v, by ++ intro w hw ++ have hwv : w ≠ v := by ++ intro h ++ exact hv (h ▸ hw) ++ change ++ FractionalIdeal.count K w ++ (v.asIdeal : ++ FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = ++ 0 ++ exact ++ FractionalIdeal.count_maximal_coprime ++ K w hwv.symm⟩ ++ ++/-- Coercing a prime outside the modulus support recovers its prime ++fractional ideal. -/ ++@[simp] ++theorem primeToModulusIdeal_coe ++ (m : Modulus K) ++ (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ m.finitePart.support) : ++ (primeToModulusIdeal m v hv : ++ FractionalIdealGroup K) = ++ FractionalIdealGroup.prime v := ++ rfl ++ ++/-- Finite ideles satisfying the higher-unit condition at every prime in ++the support of the modulus. -/ ++def finitePrimeToModulusSubgroup (m : Modulus K) : ++ Subgroup (FiniteIdeleGroup K) where ++ carrier := {a | ∀ v, v ∈ m.finitePart.support → ++ a v ∈ localHigherUnitGroup v (m.finitePart v)} ++ one_mem' v _ := (localHigherUnitGroup v (m.finitePart v)).one_mem ++ mul_mem' ha hb v hv := ++ (localHigherUnitGroup v (m.finitePart v)).mul_mem (ha v hv) (hb v hv) ++ inv_mem' ha v hv := ++ (localHigherUnitGroup v (m.finitePart v)).inv_mem (ha v hv) ++ ++/-- Ideles satisfying the infinite positivity and finite higher-unit ++conditions of a modulus. -/ ++def idelePrimeToModulusSubgroup (m : Modulus K) : ++ Subgroup (IdeleGroup K) := ++ m.infiniteCongruenceSubgroup.prod ++ (finitePrimeToModulusSubgroup m) ++ ++theorem localHigherUnitGroup_le_integralUnits ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ) : ++ localHigherUnitGroup v n ≤ ++ (v.adicCompletionIntegers K).units := by ++ intro x hx ++ rw [mem_localHigherUnitGroup_iff] at hx ++ obtain ⟨y, rfl, _⟩ := hx ++ exact y.property ++ ++theorem fractionalIdeal_mem_primeToModulusIdeals ++ (m : Modulus K) (a : IdeleGroup K) ++ (ha : a ∈ idelePrimeToModulusSubgroup m) : ++ IdeleGroup.fractionalIdeal a ∈ primeToModulusIdeals m := by ++ intro v hv ++ change FractionalIdeal.count K v ++ (((FractionalIdealGroup.factorization (K := K)) ++ (FiniteIdeleGroup.valuationVector a.2) : ++ FractionalIdealGroup K) : ++ FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = 0 ++ rw [FractionalIdealGroup.count_factorization, ++ FiniteIdeleGroup.valuationVector_apply] ++ apply (FiniteIdeleGroup.localOrder_eq_zero_iff v (a.2 v)).2 ++ exact localHigherUnitGroup_le_integralUnits v (m.finitePart v) (ha.2 v hv) ++ ++/-- The fractional-ideal map restricted to ideles prime to a modulus. -/ ++def primeToIdealMap (m : Modulus K) : ++ idelePrimeToModulusSubgroup m →* ++ primeToModulusIdeals m where ++ toFun a := ++ ⟨IdeleGroup.fractionalIdeal a, ++ fractionalIdeal_mem_primeToModulusIdeals m a a.property⟩ ++ map_one' := by ++ apply Subtype.ext ++ exact map_one _ ++ map_mul' a b := by ++ apply Subtype.ext ++ exact map_mul _ _ _ ++ ++/-- A finite idele with a prescribed valuation vector away from the ++support of a modulus and value one on its support. -/ ++def valuationVectorSectionPrimeTo ++ (m : Modulus K) ++ (e : HeightOneSpectrum (𝓞 K) →₀ ℤ) : ++ FiniteIdeleGroup K := ++ ⟨fun v => ++ if v ∈ m.finitePart.support then 1 ++ else FiniteIdeleGroup.chosenLocalOrderSection v (e v), by ++ filter_upwards ++ [m.finitePart.support.eventually_cofinite_notMem, ++ e.support.eventually_cofinite_notMem] with v hvm he ++ simp only [hvm, ↓reduceIte] ++ apply (FiniteIdeleGroup.localOrder_eq_zero_iff v _).1 ++ rw [FiniteIdeleGroup.localOrder_chosenLocalOrderSection, ++ Finsupp.notMem_support_iff.mp he]⟩ ++ ++theorem valuationVector_valuationVectorSectionPrimeTo ++ (m : Modulus K) ++ (e : HeightOneSpectrum (𝓞 K) →₀ ℤ) ++ (he : ∀ v, v ∈ m.finitePart.support → e v = 0) : ++ FiniteIdeleGroup.valuationVector ++ (valuationVectorSectionPrimeTo m e) = ++ Multiplicative.ofAdd e := by ++ apply Multiplicative.ext ++ ext v ++ rw [FiniteIdeleGroup.valuationVector_apply] ++ by_cases hv : v ∈ m.finitePart.support ++ · change ++ (FiniteIdeleGroup.localOrder v ++ (if v ∈ m.finitePart.support then 1 ++ else FiniteIdeleGroup.chosenLocalOrderSection v (e v))).toAdd = ++ e v ++ rw [ite_eq_left hv, map_one] ++ exact (he v hv).symm ++ · change ++ (FiniteIdeleGroup.localOrder v ++ (if v ∈ m.finitePart.support then 1 ++ else FiniteIdeleGroup.chosenLocalOrderSection v (e v))).toAdd = ++ e v ++ rw [ite_eq_right hv, ++ FiniteIdeleGroup.localOrder_chosenLocalOrderSection] ++ ++theorem primeToIdealMap_surjective (m : Modulus K) : ++ Function.Surjective (primeToIdealMap m) := by ++ intro I ++ let e : HeightOneSpectrum (𝓞 K) →₀ ℤ := ++ FractionalIdealGroup.countVector (I : FractionalIdealGroup K) ++ have he : ∀ v, v ∈ m.finitePart.support → e v = 0 := by ++ intro v hv ++ exact I.property v hv ++ let a : IdeleGroup K := ++ (1, valuationVectorSectionPrimeTo m e) ++ have ha : a ∈ idelePrimeToModulusSubgroup m := by ++ constructor ++ · exact m.infiniteCongruenceSubgroup.one_mem ++ · intro v hv ++ change ++ (if v ∈ m.finitePart.support then 1 ++ else FiniteIdeleGroup.chosenLocalOrderSection v (e v)) ∈ ++ localHigherUnitGroup v (m.finitePart v) ++ rw [ite_eq_left hv] ++ exact (localHigherUnitGroup v (m.finitePart v)).one_mem ++ refine ⟨⟨a, ha⟩, ?_⟩ ++ apply Subtype.ext ++ apply FractionalIdealGroup.ext_count ++ intro v ++ change FractionalIdeal.count K v ++ (((FractionalIdealGroup.factorization (K := K)) ++ (FiniteIdeleGroup.valuationVector ++ (valuationVectorSectionPrimeTo m e)) : ++ FractionalIdealGroup K) : ++ FractionalIdeal (nonZeroDivisors (𝓞 K)) K) = ++ FractionalIdeal.count K v ++ ((I : FractionalIdealGroup K) : ++ FractionalIdeal (nonZeroDivisors (𝓞 K)) K) ++ rw [valuationVector_valuationVectorSectionPrimeTo m e he, ++ FractionalIdealGroup.count_factorization] ++ exact FractionalIdealGroup.countVector_apply I v ++ ++theorem ideleCongruenceSubgroup_le_primeTo ++ (m : Modulus K) : ++ m.ideleCongruenceSubgroup ≤ ++ idelePrimeToModulusSubgroup m := by ++ intro a ha ++ exact ⟨ha.1, fun v _ => ha.2 v⟩ ++ ++/-- The congruence subgroup, viewed inside the subgroup of ideles prime ++to the modulus. -/ ++def congruenceSubgroupInPrimeTo (m : Modulus K) : ++ Subgroup (idelePrimeToModulusSubgroup m) := ++ m.ideleCongruenceSubgroup.subgroupOf ++ (idelePrimeToModulusSubgroup m) ++ ++theorem primeToIdealMap_ker (m : Modulus K) : ++ (primeToIdealMap m).ker = ++ congruenceSubgroupInPrimeTo m := by ++ ext a ++ constructor ++ · intro ha ++ have hintegral : ++ (a : IdeleGroup K) ∈ ++ IdeleGroup.integralAtFinitePlaces (K := K) := by ++ rw [← IdeleGroup.fractionalIdeal_ker, ++ MonoidHom.mem_ker] ++ exact congrArg Subtype.val ++ (MonoidHom.mem_ker.mp ha) ++ constructor ++ · exact a.property.1 ++ · intro v ++ by_cases hv : v ∈ m.finitePart.support ++ · exact a.property.2 v hv ++ · rw [Finsupp.notMem_support_iff.mp hv, ++ localHigherUnitGroup_zero] ++ exact hintegral v ++ · intro ha ++ apply MonoidHom.mem_ker.mpr ++ apply Subtype.ext ++ change IdeleGroup.fractionalIdeal (a : IdeleGroup K) = 1 ++ rw [← MonoidHom.mem_ker, ++ IdeleGroup.fractionalIdeal_ker] ++ intro v ++ exact localHigherUnitGroup_le_integralUnits v (m.finitePart v) (ha.2 v) ++ ++/-- The quotient of ideles prime to a modulus by the congruence subgroup, ++identified with fractional ideals prime to the modulus. -/ ++def quotientCongruenceEquivPrimeToIdeals (m : Modulus K) : ++ idelePrimeToModulusSubgroup m ⧸ ++ congruenceSubgroupInPrimeTo m ≃* ++ primeToModulusIdeals m := by ++ rw [← primeToIdealMap_ker m] ++ exact QuotientGroup.quotientKerEquivOfSurjective ++ (primeToIdealMap m) (primeToIdealMap_surjective m) ++ ++/-- Principal ideles satisfying the modulus conditions, considered inside ++`I_K^(m)`. -/ ++def principalSubgroupInPrimeTo (m : Modulus K) : ++ Subgroup (idelePrimeToModulusSubgroup m) := ++ Subgroup.comap (idelePrimeToModulusSubgroup m).subtype ++ (IdeleGroup.principalSubgroup K) ++ ++/-- Principal ideals generated by a totally positive element congruent to ++one modulo the finite modulus. -/ ++def principalRayIdealSubgroup (m : Modulus K) : ++ Subgroup (primeToModulusIdeals m) := ++ Subgroup.map (primeToIdealMap m) ++ (principalSubgroupInPrimeTo m) ++ ++theorem mem_principalRayIdealSubgroup_iff ++ (m : Modulus K) (I : primeToModulusIdeals m) : ++ I ∈ principalRayIdealSubgroup m ↔ ++ ∃ x : Kˣ, ++ ∃ _hx : IdeleGroup.principalIdele K x ∈ ++ idelePrimeToModulusSubgroup m, ++ toPrincipalIdeal (𝓞 K) K x = ++ (I : FractionalIdealGroup K) := by ++ constructor ++ · rintro ⟨a, ha, hmap⟩ ++ obtain ⟨x, hx⟩ := ha ++ refine ⟨x, ?_, ?_⟩ ++ · rw [hx] ++ exact a.property ++ · have hval := congrArg Subtype.val hmap ++ change IdeleGroup.fractionalIdeal (a : IdeleGroup K) = ++ (I : FractionalIdealGroup K) at hval ++ rw [← IdeleGroup.fractionalIdeal_principalIdele] ++ exact (congrArg (IdeleGroup.fractionalIdeal (K := K)) hx).trans hval ++ · rintro ⟨x, hx, hideal⟩ ++ let a : idelePrimeToModulusSubgroup m := ++ ⟨IdeleGroup.principalIdele K x, hx⟩ ++ have ha : a ∈ principalSubgroupInPrimeTo m := by ++ change IdeleGroup.principalIdele K x ∈ ++ IdeleGroup.principalSubgroup K ++ exact ⟨x, rfl⟩ ++ refine ⟨a, ha, ?_⟩ ++ apply Subtype.ext ++ change IdeleGroup.fractionalIdeal ++ (IdeleGroup.principalIdele K x) = ++ (I : FractionalIdealGroup K) ++ rw [IdeleGroup.fractionalIdeal_principalIdele, hideal] ++ ++/-- The ideal-theoretic ray class group `J_K^m / P_K^m`. -/ ++abbrev IdealRayClassGroup (m : Modulus K) := ++ primeToModulusIdeals m ⧸ principalRayIdealSubgroup m ++ ++/-- The canonical projection from ideles prime to the modulus to the ++ideal-theoretic ray class group. -/ ++def idealRayProjection (m : Modulus K) : ++ idelePrimeToModulusSubgroup m →* ++ IdealRayClassGroup m := ++ (QuotientGroup.mk' (principalRayIdealSubgroup m)).comp ++ (primeToIdealMap m) ++ ++/-- The subgroup generated by congruence ideles and principal ideles ++inside the ideles prime to a modulus. -/ ++def raySubgroupInPrimeTo (m : Modulus K) : ++ Subgroup (idelePrimeToModulusSubgroup m) := ++ congruenceSubgroupInPrimeTo m ⊔ ++ principalSubgroupInPrimeTo m ++ ++theorem idealRayProjection_surjective (m : Modulus K) : ++ Function.Surjective (idealRayProjection m) := by ++ intro c ++ obtain ⟨I, rfl⟩ := ++ QuotientGroup.mk'_surjective ++ (principalRayIdealSubgroup m) c ++ obtain ⟨a, rfl⟩ := primeToIdealMap_surjective m I ++ exact ⟨a, rfl⟩ ++ ++theorem idealRayProjection_ker (m : Modulus K) : ++ (idealRayProjection m).ker = ++ raySubgroupInPrimeTo m := by ++ ext a ++ constructor ++ · intro ha ++ change QuotientGroup.mk' ++ (principalRayIdealSubgroup m) ++ (primeToIdealMap m a) = 1 at ha ++ rw [QuotientGroup.mk'_apply, ++ QuotientGroup.eq_one_iff] at ha ++ obtain ⟨p, hp, hpa⟩ := ha ++ let n : idelePrimeToModulusSubgroup m := a * p⁻¹ ++ have hn : n ∈ congruenceSubgroupInPrimeTo m := by ++ rw [← primeToIdealMap_ker m, MonoidHom.mem_ker] ++ change primeToIdealMap m (a * p⁻¹) = 1 ++ rw [map_mul, map_inv, hpa] ++ simp ++ rw [raySubgroupInPrimeTo, Subgroup.mem_sup] ++ refine ⟨n, hn, p, hp, ?_⟩ ++ dsimp [n] ++ group ++ · intro ha ++ rw [raySubgroupInPrimeTo, Subgroup.mem_sup] at ha ++ obtain ⟨n, hn, p, hp, rfl⟩ := ha ++ change QuotientGroup.mk' ++ (principalRayIdealSubgroup m) ++ (primeToIdealMap m (n * p)) = 1 ++ rw [map_mul] ++ have hn' : primeToIdealMap m n = 1 := ++ MonoidHom.mem_ker.mp ++ ((primeToIdealMap_ker m).symm ▸ hn) ++ rw [hn', one_mul] ++ rw [QuotientGroup.mk'_apply, ++ QuotientGroup.eq_one_iff] ++ exact ⟨p, hp, rfl⟩ ++ ++/-- The quotient of ideles prime to the modulus by the full ray subgroup, ++identified with the ideal-theoretic ray class group. -/ ++def quotientRaySubgroupEquivIdealRayClassGroup ++ (m : Modulus K) : ++ idelePrimeToModulusSubgroup m ⧸ ++ raySubgroupInPrimeTo m ≃* ++ IdealRayClassGroup m := ++ (QuotientGroup.quotientMulEquivOfEq ++ (idealRayProjection_ker m).symm).trans ++ (QuotientGroup.quotientKerEquivOfSurjective ++ (idealRayProjection m) ++ (idealRayProjection_surjective m)) ++ ++/-- The quotient equivalence induced by the ideal-ray projection evaluates on ++the class of a prime-to-modulus idele as the original projection. -/ ++@[simp] ++theorem quotientRaySubgroupEquivIdealRayClassGroup_mk ++ (m : Modulus K) (a : idelePrimeToModulusSubgroup m) : ++ quotientRaySubgroupEquivIdealRayClassGroup m ++ (QuotientGroup.mk' (raySubgroupInPrimeTo m) a) = ++ idealRayProjection m a := by ++ rw [quotientRaySubgroupEquivIdealRayClassGroup, ++ MulEquiv.trans_apply, QuotientGroup.mk'_apply, ++ QuotientGroup.quotientMulEquivOfEq_mk] ++ exact QuotientGroup.kerLift_mk (idealRayProjection m) a ++ ++ ++end RayClass +diff --git a/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassIdealModulusProjection.lean b/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassIdealModulusProjection.lean +index e37e3df..415463a 100644 +--- a/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassIdealModulusProjection.lean ++++ b/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassIdealModulusProjection.lean +@@ -90,7 +90,7 @@ private theorem rayCongruent_of_le + · intro v hv + exact hx.2 v (hmn.2 hv) + +-private theorem rayPrimeToIdeals_antitone ++theorem rayPrimeToIdeals_antitone + {K : Type u} [Field K] [NumberField K] + {m n : RayClassModulus K} (hmn : m ≤ n) : + rayClassPrimeToIdeals n ≤ rayClassPrimeToIdeals m := by +diff --git a/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassOfFinitePrime.lean b/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassOfFinitePrime.lean +index a3e9746..d8d3db5 100644 +--- a/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassOfFinitePrime.lean ++++ b/Lean4/ClassFieldTheory/Definitions/ConductorsAndRayClassFields/RayClassOfFinitePrime.lean +@@ -9,6 +9,7 @@ import ClassFieldTheory.Definitions.ConductorsAndRayClassFields.OrdinaryRayClass + import ClassFieldTheory.Definitions.ConductorsAndRayClassFields.RayClassGroup + import ClassFieldTheory.Definitions.FrobeniusAndHilbertClassFields.FinitePrimeFractionalIdeal + ++ + set_option autoImplicit false + + /-! +@@ -24,7 +25,7 @@ namespace ClassFieldTheory + + universe u + +-private lemma finitePrimeFractionalIdeal_mem_primeTo ++lemma finitePrimeFractionalIdeal_mem_primeTo + {K : Type u} [Field K] [NumberField K] + (m : RayClassModulus K) + (v : HeightOneSpectrum (𝓞 K)) +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocity.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocity.lean +index 053f2b7..e213e03 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocity.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocity.lean +@@ -4,158 +4,18 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.RayClassFieldRealization +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.ArithmeticNormalization ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ArithmeticRayClassFieldReciprocityNormResidue + + set_option autoImplicit false +- +-/-! +-# Arithmetic reciprocity for actual ray class fields +- +-This is the canonical topological isomorphism +-`Gal(Kᵐ/K) ≃ₜ* C_K/C_Kᵐ` with arithmetic Frobenius +-normalization. It uses the actual selected ray class field, its exact +-idèle norm range, the finite Krull topology, and the native ray-class +-quotient topology. +--/ +- + open scoped Classical NumberField +- + noncomputable section +- + namespace GlobalClassFieldTheory + namespace GlobalClassFields +- + open NumberField + open Reciprocity +- +-private theorem arithmeticRayClassIdeleClassGroupIsMulCommutative +- {F : Type} [Field F] [NumberField F] : +- IsMulCommutative (IdeleClassGroup F) := +- ⟨⟨fun a b => mul_comm a b⟩⟩ +- + attribute [local instance] arithmeticRayClassIdeleClassGroupIsMulCommutative +- + variable {K : Type} [Field K] [NumberField K] + +-/-- Arithmetic reciprocity followed by transport between equal norm +-quotients sends a norm-residue symbol to its represented quotient class. -/ +-private theorem +- arithmeticReciprocity_quotientMulEquivOfEq_globalNormResidue +- {F E : Type} [Field F] [NumberField F] +- [Field E] [NumberField E] [Algebra F E] +- [FiniteDimensional F E] [IsAbelianGalois F E] +- (H : Subgroup (IdeleClassGroup F)) +- (h : (_root_.ideleClassNorm F E).range = H) +- (c : IdeleClassGroup F) : +- QuotientGroup.quotientMulEquivOfEq h +- (arithmeticGlobalReciprocityContinuousMulEquiv F E +- (arithmeticGlobalNormResidueMonoidHom F E c)) = +- QuotientGroup.mk' H c := by +- let e := arithmeticGlobalReciprocityContinuousMulEquiv F E +- let q := +- QuotientGroup.mk' +- (_root_.ideleClassNorm F E).range c +- have hsymm : +- e.symm q = arithmeticGlobalNormResidueMonoidHom F E c := +- arithmeticGlobalReciprocityContinuousMulEquiv_symm_mk F E c +- have he : +- e (arithmeticGlobalNormResidueMonoidHom F E c) = q := by +- calc +- e (arithmeticGlobalNormResidueMonoidHom F E c) = +- e (e.symm q) := +- congrArg (fun σ => e σ) hsymm.symm +- _ = q := e.apply_symm_apply q +- calc +- QuotientGroup.quotientMulEquivOfEq h +- (arithmeticGlobalReciprocityContinuousMulEquiv F E +- (arithmeticGlobalNormResidueMonoidHom F E c)) = +- QuotientGroup.quotientMulEquivOfEq h q := +- congrArg (fun x => QuotientGroup.quotientMulEquivOfEq h x) he +- _ = QuotientGroup.mk' H c := +- QuotientGroup.quotientMulEquivOfEq_mk h c +- +-/-- Arithmetic global reciprocity for the actual selected ray class +-field, bundled with both native topologies. -/ +-noncomputable def +- arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup +- (m : RayClass.Modulus K) : +- Gal((rayClassField K m) / K) ≃ₜ* +- RayClass.RayClassGroup m := by +- letI normQuotientDiscreteTopology : DiscreteTopology +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm +- K (rayClassField K m)).range) := +- ideleClassNormQuotient_discreteTopology +- K (rayClassField K m) +- letI rayClassGroupDiscreteTopology : DiscreteTopology +- (RayClass.RayClassGroup m) := +- QuotientGroup.discreteTopology +- (RayClass.isOpen_congruenceSubgroup m) +- let quotientTransport : +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm +- K (rayClassField K m)).range) ≃ₜ* +- RayClass.RayClassGroup m := +- { QuotientGroup.quotientMulEquivOfEq +- (rayClassField_ideleClassNorm_range_over_original +- (K := K) m) with +- continuous_toFun := continuous_of_discreteTopology +- continuous_invFun := continuous_of_discreteTopology } +- exact +- (arithmeticGlobalReciprocityContinuousMulEquiv +- K (rayClassField K m)).trans +- quotientTransport +- +-/-- Pointwise evaluation of arithmetic ray-class reciprocity separates +-global reciprocity from the transport between the equal norm quotients. -/ +-private theorem +- arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup_apply +- (m : RayClass.Modulus K) +- (σ : Gal((rayClassField K m) / K)) : +- arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup +- (K := K) m σ = +- QuotientGroup.quotientMulEquivOfEq +- (rayClassField_ideleClassNorm_range_over_original +- (K := K) m) +- (arithmeticGlobalReciprocityContinuousMulEquiv +- K (rayClassField K m) σ) := by +- rfl +- +-/-- Arithmetic ray-class reciprocity sends the arithmetic global +-norm-residue symbol of an idèle class to its literal ray class. -/ +-@[simp] +-theorem +- arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup_globalNormResidue +- (m : RayClass.Modulus K) +- (c : IdeleClassGroup K) : +- arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup +- (K := K) m +- (arithmeticGlobalNormResidueMonoidHom +- K (rayClassField K m) c) = +- QuotientGroup.mk' +- (RayClass.Modulus.congruenceSubgroup m) c := by +- calc +- arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup +- (K := K) m +- (arithmeticGlobalNormResidueMonoidHom +- K (rayClassField K m) c) = +- QuotientGroup.quotientMulEquivOfEq +- (rayClassField_ideleClassNorm_range_over_original +- (K := K) m) +- (arithmeticGlobalReciprocityContinuousMulEquiv +- K (rayClassField K m) +- (arithmeticGlobalNormResidueMonoidHom +- K (rayClassField K m) c)) := +- arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup_apply +- (K := K) m _ +- _ = QuotientGroup.mk' +- (RayClass.Modulus.congruenceSubgroup m) c := +- arithmeticReciprocity_quotientMulEquivOfEq_globalNormResidue +- (RayClass.Modulus.congruenceSubgroup m) +- (rayClassField_ideleClassNorm_range_over_original +- (K := K) m) c +- + /-- Inverse arithmetic ray reciprocity sends a represented ray class + back to the arithmetic global norm-residue symbol. -/ + @[simp] +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityBase.lean +new file mode 100644 +index 0000000..6519cd0 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityBase.lean +@@ -0,0 +1,112 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.RayClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.ArithmeticNormalization ++ ++ ++set_option autoImplicit false ++ ++/-! ++# Arithmetic reciprocity for actual ray class fields ++ ++This is the canonical topological isomorphism ++`Gal(Kᵐ/K) ≃ₜ* C_K/C_Kᵐ` with arithmetic Frobenius ++normalization. It uses the actual selected ray class field, its exact ++idèle norm range, the finite Krull topology, and the native ray-class ++quotient topology. ++-/ ++ ++open scoped Classical NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace GlobalClassFields ++ ++open NumberField ++open Reciprocity ++ ++theorem arithmeticRayClassIdeleClassGroupIsMulCommutative ++ {F : Type} [Field F] [NumberField F] : ++ IsMulCommutative (IdeleClassGroup F) := ++ ⟨⟨fun a b => mul_comm a b⟩⟩ ++ ++attribute [local instance] arithmeticRayClassIdeleClassGroupIsMulCommutative ++ ++variable {K : Type} [Field K] [NumberField K] ++ ++/-- Arithmetic reciprocity followed by transport between equal norm ++quotients sends a norm-residue symbol to its represented quotient class. -/ ++theorem ++ arithmeticReciprocity_quotientMulEquivOfEq_globalNormResidue ++ {F E : Type} [Field F] [NumberField F] ++ [Field E] [NumberField E] [Algebra F E] ++ [FiniteDimensional F E] [IsAbelianGalois F E] ++ (H : Subgroup (IdeleClassGroup F)) ++ (h : (_root_.ideleClassNorm F E).range = H) ++ (c : IdeleClassGroup F) : ++ QuotientGroup.quotientMulEquivOfEq h ++ (arithmeticGlobalReciprocityContinuousMulEquiv F E ++ (arithmeticGlobalNormResidueMonoidHom F E c)) = ++ QuotientGroup.mk' H c := by ++ let e := arithmeticGlobalReciprocityContinuousMulEquiv F E ++ let q := ++ QuotientGroup.mk' ++ (_root_.ideleClassNorm F E).range c ++ have hsymm : ++ e.symm q = arithmeticGlobalNormResidueMonoidHom F E c := ++ arithmeticGlobalReciprocityContinuousMulEquiv_symm_mk F E c ++ have he : ++ e (arithmeticGlobalNormResidueMonoidHom F E c) = q := by ++ calc ++ e (arithmeticGlobalNormResidueMonoidHom F E c) = ++ e (e.symm q) := ++ congrArg (fun σ => e σ) hsymm.symm ++ _ = q := e.apply_symm_apply q ++ calc ++ QuotientGroup.quotientMulEquivOfEq h ++ (arithmeticGlobalReciprocityContinuousMulEquiv F E ++ (arithmeticGlobalNormResidueMonoidHom F E c)) = ++ QuotientGroup.quotientMulEquivOfEq h q := ++ congrArg (fun x => QuotientGroup.quotientMulEquivOfEq h x) he ++ _ = QuotientGroup.mk' H c := ++ QuotientGroup.quotientMulEquivOfEq_mk h c ++ ++/-- Arithmetic global reciprocity for the actual selected ray class ++field, bundled with both native topologies. -/ ++noncomputable def ++ arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup ++ (m : RayClass.Modulus K) : ++ Gal((rayClassField K m) / K) ≃ₜ* ++ RayClass.RayClassGroup m := by ++ letI normQuotientDiscreteTopology : DiscreteTopology ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm ++ K (rayClassField K m)).range) := ++ ideleClassNormQuotient_discreteTopology ++ K (rayClassField K m) ++ letI rayClassGroupDiscreteTopology : DiscreteTopology ++ (RayClass.RayClassGroup m) := ++ QuotientGroup.discreteTopology ++ (RayClass.isOpen_congruenceSubgroup m) ++ let quotientTransport : ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm ++ K (rayClassField K m)).range) ≃ₜ* ++ RayClass.RayClassGroup m := ++ { QuotientGroup.quotientMulEquivOfEq ++ (rayClassField_ideleClassNorm_range_over_original ++ (K := K) m) with ++ continuous_toFun := continuous_of_discreteTopology ++ continuous_invFun := continuous_of_discreteTopology } ++ exact ++ (arithmeticGlobalReciprocityContinuousMulEquiv ++ K (rayClassField K m)).trans ++ quotientTransport ++ ++end GlobalClassFields ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityEvaluation.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityEvaluation.lean +new file mode 100644 +index 0000000..41d3435 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityEvaluation.lean +@@ -0,0 +1,51 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ArithmeticRayClassFieldReciprocityBase ++ ++set_option autoImplicit false ++open scoped Classical NumberField ++noncomputable section ++namespace GlobalClassFieldTheory ++namespace GlobalClassFields ++open NumberField ++open Reciprocity ++attribute [local instance] arithmeticRayClassIdeleClassGroupIsMulCommutative ++private theorem mulEquiv_toEquiv_apply ++ {A B : Type*} [Mul A] [Mul B] ++ (e : A ≃* B) (x : A) : e.toEquiv x = e x := by rfl ++ ++private theorem continuousMulEquiv_toMulEquiv_apply ++ {A B : Type*} [TopologicalSpace A] [TopologicalSpace B] [Mul A] [Mul B] ++ (e : A ≃ₜ* B) (x : A) : e.toMulEquiv x = e x := by rfl ++ ++variable {K : Type} [Field K] [NumberField K] ++ ++ ++/-- Evaluation of ray class reciprocity is global reciprocity transported ++through the equality of the ray norm subgroup and the idele norm range. -/ ++theorem ++ arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup_apply ++ (m : RayClass.Modulus K) ++ (σ : Gal((rayClassField K m) / K)) : ++ arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup ++ (K := K) m σ = ++ QuotientGroup.quotientMulEquivOfEq ++ (rayClassField_ideleClassNorm_range_over_original ++ (K := K) m) ++ (arithmeticGlobalReciprocityContinuousMulEquiv ++ K (rayClassField K m) σ) := by ++ simp only [arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup, ++ ContinuousMulEquiv.trans, MulEquiv.trans, Equiv.trans, ++ ContinuousMulEquiv.coe_mk, MulEquiv.coe_mk, Equiv.coe_fn_mk, ++ Function.comp_apply, ++ mulEquiv_toEquiv_apply] ++ have h := continuousMulEquiv_toMulEquiv_apply ++ (arithmeticGlobalReciprocityContinuousMulEquiv K (rayClassField K m)) σ ++ with_reducible exact congrArg (fun q => QuotientGroup.quotientMulEquivOfEq (rayClassField_ideleClassNorm_range_over_original (K := K) m) q) h ++ ++end GlobalClassFields ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityNormResidue.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityNormResidue.lean +new file mode 100644 +index 0000000..ce8c03e +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/ArithmeticRayClassFieldReciprocityNormResidue.lean +@@ -0,0 +1,54 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ArithmeticRayClassFieldReciprocityEvaluation ++ ++set_option autoImplicit false ++open scoped Classical NumberField ++noncomputable section ++namespace GlobalClassFieldTheory ++namespace GlobalClassFields ++open NumberField ++open Reciprocity ++attribute [local instance] arithmeticRayClassIdeleClassGroupIsMulCommutative ++variable {K : Type} [Field K] [NumberField K] ++ ++/-- Arithmetic ray-class reciprocity sends the arithmetic global ++norm-residue symbol of an idèle class to its literal ray class. -/ ++@[simp] ++theorem ++ arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup_globalNormResidue ++ (m : RayClass.Modulus K) ++ (c : IdeleClassGroup K) : ++ arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup ++ (K := K) m ++ (arithmeticGlobalNormResidueMonoidHom ++ K (rayClassField K m) c) = ++ QuotientGroup.mk' ++ (RayClass.Modulus.congruenceSubgroup m) c := by ++ calc ++ arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup ++ (K := K) m ++ (arithmeticGlobalNormResidueMonoidHom ++ K (rayClassField K m) c) = ++ QuotientGroup.quotientMulEquivOfEq ++ (rayClassField_ideleClassNorm_range_over_original ++ (K := K) m) ++ (arithmeticGlobalReciprocityContinuousMulEquiv ++ K (rayClassField K m) ++ (arithmeticGlobalNormResidueMonoidHom ++ K (rayClassField K m) c)) := ++ arithmeticRayClassFieldGaloisContinuousMulEquivRayClassGroup_apply ++ (K := K) m _ ++ _ = QuotientGroup.mk' ++ (RayClass.Modulus.congruenceSubgroup m) c := ++ arithmeticReciprocity_quotientMulEquivOfEq_globalNormResidue ++ (RayClass.Modulus.congruenceSubgroup m) ++ (rayClassField_ideleClassNorm_range_over_original ++ (K := K) m) c ++ ++end GlobalClassFields ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActual.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActual.lean +index 11beea0..7ab1c83 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActual.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActual.lean +@@ -4,106 +4,17 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldReciprocity.Transport +-import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.BigHilbertClassFieldNaturality +-import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldComparison + +-set_option autoImplicit false +- +-/-! +-# Big Hilbert reciprocity over the realized base field +- +-This leaf specializes the shared reciprocity transport to the actual base +-field of the selected big Hilbert class field. +--/ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldReciprocity.BigActualEquiv + ++set_option autoImplicit false + open scoped Classical IsMulCommutative NumberField +- + noncomputable section +- + namespace GlobalClassFieldTheory + namespace GlobalClassFields +- + open Reciprocity +- + variable {K : Type} [Field K] [NumberField K] +- +-local instance +- bigHilbertClassFieldReciprocityIdeleClassGroupIsMulCommutative +- {F : Type} [Field F] [NumberField F] : +- IsMulCommutative (IdeleClassGroup F) := +- hilbertClassFieldReciprocityIdeleClassGroupIsMulCommutative +- +-/-- The actual norm range of the selected big Hilbert class field is +-the intrinsic big-Hilbert norm subgroup of its actual base field. -/ +-theorem bigHilbertClassField_ideleClassNorm_range_eq_intrinsic : +- (_root_.ideleClassNorm +- (bigHilbertClassFieldBase K) +- (bigHilbertClassField K)).range = +- bigHilbertClassFieldNormSubgroup +- (K := bigHilbertClassFieldBase K) := by +- rw [bigHilbertClassField_ideleClassNorm_range] +- exact +- bigHilbertClassFieldNormSubgroup_map_ideleClassCongr +- (bigHilbertClassFieldBaseEquiv (K := K)) +- +-/-- Global reciprocity identifies the genuine Galois group of the +-selected big Hilbert class field with the narrow ideal class group of +-the original number field. -/ +-private noncomputable def bigHilbertClassFieldReciprocityData : +- {e : Gal((bigHilbertClassField K) / +- (bigHilbertClassFieldBase K)) ≃* +- RayClass.NarrowClassGroup K // +- ∀ c : IdeleClassGroup (bigHilbertClassFieldBase K), +- e (globalNormResidueMonoidHom +- (bigHilbertClassFieldBase K) +- (bigHilbertClassField K) c) = +- bigHilbertNarrowClassGroupCongr +- (bigHilbertClassFieldBaseEquiv (K := K)).symm +- (bigHilbertClassFieldQuotientEquivNarrowClassGroup +- (K := bigHilbertClassFieldBase K) +- (QuotientGroup.mk' +- (bigHilbertClassFieldNormSubgroup +- (K := bigHilbertClassFieldBase K)) c))} := by +- let d := hilbertClassFieldGlobalReciprocityTransportData +- (bigHilbertClassFieldNormSubgroup +- (K := bigHilbertClassFieldBase K)) +- (bigHilbertClassField_ideleClassNorm_range_eq_intrinsic +- (K := K)) +- ((bigHilbertClassFieldQuotientEquivNarrowClassGroup +- (K := bigHilbertClassFieldBase K)).trans +- (bigHilbertNarrowClassGroupCongr +- (bigHilbertClassFieldBaseEquiv (K := K)).symm)) +- refine ⟨d.1, ?_⟩ +- intro c +- exact d.2 c +- +-/-- The reciprocity equivalence from the actual big Hilbert Galois group +-to the narrow class group of the original number field. -/ +-noncomputable def bigHilbertClassFieldGaloisEquivNarrowClassGroup : +- Gal((bigHilbertClassField K) / +- (bigHilbertClassFieldBase K)) ≃* +- RayClass.NarrowClassGroup K := +- (bigHilbertClassFieldReciprocityData (K := K)).1 +- +-/-- Under big-Hilbert reciprocity, the actual global norm-residue +-symbol is the narrow ideal class of its idèle-class representative, +-transported back to the original number field. -/ +-@[simp] +-theorem bigHilbertClassFieldGaloisEquivNarrowClassGroup_globalNormResidue +- (c : IdeleClassGroup (bigHilbertClassFieldBase K)) : +- bigHilbertClassFieldGaloisEquivNarrowClassGroup (K := K) +- (globalNormResidueMonoidHom +- (bigHilbertClassFieldBase K) +- (bigHilbertClassField K) c) = +- bigHilbertNarrowClassGroupCongr +- (bigHilbertClassFieldBaseEquiv (K := K)).symm +- (bigHilbertClassFieldQuotientEquivNarrowClassGroup +- (K := bigHilbertClassFieldBase K) +- (QuotientGroup.mk' +- (bigHilbertClassFieldNormSubgroup +- (K := bigHilbertClassFieldBase K)) c)) := by +- exact (bigHilbertClassFieldReciprocityData (K := K)).2 c ++attribute [local instance] bigHilbertClassFieldReciprocityIdeleClassGroupIsMulCommutative + + /-- Representative form of big-Hilbert reciprocity: the global + norm-residue symbol of an actual idèle maps to its narrow ideal +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActualData.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActualData.lean +new file mode 100644 +index 0000000..4dd276f +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActualData.lean +@@ -0,0 +1,84 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldReciprocity.Transport ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.BigHilbertClassFieldNaturality ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldComparison ++ ++ ++set_option autoImplicit false ++ ++/-! ++# Big Hilbert reciprocity over the realized base field ++ ++This leaf specializes the shared reciprocity transport to the actual base ++field of the selected big Hilbert class field. ++-/ ++ ++open scoped Classical IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace GlobalClassFields ++ ++open Reciprocity ++ ++variable {K : Type} [Field K] [NumberField K] ++ ++local instance ++ bigHilbertClassFieldReciprocityIdeleClassGroupIsMulCommutative ++ {F : Type} [Field F] [NumberField F] : ++ IsMulCommutative (IdeleClassGroup F) := ++ hilbertClassFieldReciprocityIdeleClassGroupIsMulCommutative ++ ++/-- The actual norm range of the selected big Hilbert class field is ++the intrinsic big-Hilbert norm subgroup of its actual base field. -/ ++theorem bigHilbertClassField_ideleClassNorm_range_eq_intrinsic : ++ (_root_.ideleClassNorm ++ (bigHilbertClassFieldBase K) ++ (bigHilbertClassField K)).range = ++ bigHilbertClassFieldNormSubgroup ++ (K := bigHilbertClassFieldBase K) := by ++ rw [bigHilbertClassField_ideleClassNorm_range] ++ exact ++ bigHilbertClassFieldNormSubgroup_map_ideleClassCongr ++ (bigHilbertClassFieldBaseEquiv (K := K)) ++ ++/-- Global reciprocity identifies the genuine Galois group of the ++selected big Hilbert class field with the narrow ideal class group of ++the original number field. -/ ++noncomputable def bigHilbertClassFieldReciprocityData : ++ {e : Gal((bigHilbertClassField K) / ++ (bigHilbertClassFieldBase K)) ≃* ++ RayClass.NarrowClassGroup K // ++ ∀ c : IdeleClassGroup (bigHilbertClassFieldBase K), ++ e (globalNormResidueMonoidHom ++ (bigHilbertClassFieldBase K) ++ (bigHilbertClassField K) c) = ++ bigHilbertNarrowClassGroupCongr ++ (bigHilbertClassFieldBaseEquiv (K := K)).symm ++ (bigHilbertClassFieldQuotientEquivNarrowClassGroup ++ (K := bigHilbertClassFieldBase K) ++ (QuotientGroup.mk' ++ (bigHilbertClassFieldNormSubgroup ++ (K := bigHilbertClassFieldBase K)) c))} := by ++ let d := hilbertClassFieldGlobalReciprocityTransportData ++ (bigHilbertClassFieldNormSubgroup ++ (K := bigHilbertClassFieldBase K)) ++ (bigHilbertClassField_ideleClassNorm_range_eq_intrinsic ++ (K := K)) ++ ((bigHilbertClassFieldQuotientEquivNarrowClassGroup ++ (K := bigHilbertClassFieldBase K)).trans ++ (bigHilbertNarrowClassGroupCongr ++ (bigHilbertClassFieldBaseEquiv (K := K)).symm)) ++ refine ⟨d.1, ?_⟩ ++ intro c ++ exact d.2 c ++ ++ ++end GlobalClassFields ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActualEquiv.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActualEquiv.lean +new file mode 100644 +index 0000000..19f756c +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/GlobalClassFields/HilbertClassFieldReciprocity/BigActualEquiv.lean +@@ -0,0 +1,48 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldReciprocity.BigActualData ++ ++set_option autoImplicit false ++open scoped Classical IsMulCommutative NumberField ++noncomputable section ++namespace GlobalClassFieldTheory ++namespace GlobalClassFields ++open Reciprocity ++variable {K : Type} [Field K] [NumberField K] ++attribute [local instance] bigHilbertClassFieldReciprocityIdeleClassGroupIsMulCommutative ++ ++/-- The reciprocity equivalence from the actual big Hilbert Galois group ++to the narrow class group of the original number field. -/ ++noncomputable def bigHilbertClassFieldGaloisEquivNarrowClassGroup : ++ Gal((bigHilbertClassField K) / ++ (bigHilbertClassFieldBase K)) ≃* ++ RayClass.NarrowClassGroup K := ++ (bigHilbertClassFieldReciprocityData (K := K)).1 ++ ++/-- Under big-Hilbert reciprocity, the actual global norm-residue ++symbol is the narrow ideal class of its idèle-class representative, ++transported back to the original number field. -/ ++@[simp] ++theorem bigHilbertClassFieldGaloisEquivNarrowClassGroup_globalNormResidue ++ (c : IdeleClassGroup (bigHilbertClassFieldBase K)) : ++ bigHilbertClassFieldGaloisEquivNarrowClassGroup (K := K) ++ (globalNormResidueMonoidHom ++ (bigHilbertClassFieldBase K) ++ (bigHilbertClassField K) c) = ++ bigHilbertNarrowClassGroupCongr ++ (bigHilbertClassFieldBaseEquiv (K := K)).symm ++ (bigHilbertClassFieldQuotientEquivNarrowClassGroup ++ (K := bigHilbertClassFieldBase K) ++ (QuotientGroup.mk' ++ (bigHilbertClassFieldNormSubgroup ++ (K := bigHilbertClassFieldBase K)) c)) := by ++ exact (bigHilbertClassFieldReciprocityData (K := K)).2 c ++ ++ ++end GlobalClassFields ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/RationalFiniteNormTransfer/Representatives.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/RationalFiniteNormTransfer/Representatives.lean +index a5d0b1a..45c9a3e 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/RationalFiniteNormTransfer/Representatives.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/RationalFiniteNormTransfer/Representatives.lean +@@ -6,6 +6,7 @@ Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + + import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.RationalFiniteNormTransfer.FieldSpine + ++ + set_option autoImplicit false + + /-! +@@ -56,7 +57,8 @@ noncomputable def rationalFiniteNormTransferAbstractRepresentative + [hfinite : Finite + (K.toSubgroup ⧸ extensionSubgroup K L hLK)] + (a : KummerTheory.ambientFixedAddSubgroup +- rationalIdeleClassRepresentation K) := by ++ rationalIdeleClassRepresentation K) : ++ rationalFiniteNormTransferExtensionIdeleClass K L hLK := by + letI hLfinite := RationalFiniteNormTransferInternal.absoluteFinite + K L hLK (hKfinite := hKfinite) (hfinite := hfinite) + let E := abstractRelativeFixedField ℚ (SeparableClosure ℚ) hLK +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalization.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalization.lean +index 0ce4c1f..63f8f94 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalization.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalization.lean +@@ -4,188 +4,18 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.PrincipalIdealTheorem +-import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.PrincipalIdealTransfer +-import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerUnramified ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertPrincipalizationClassGroup + + set_option autoImplicit false +- +-/-! +-# Principalization in the selected small Hilbert class field +- +-The selected second small Hilbert class field is Galois over the +-canonical fixed-field copy of the original base, and its maximal +-abelian intermediate field is the selected first small Hilbert class +-field. Witt transfer therefore places every idele class extended from +-that fixed-field copy in the norm range from the second stage. +-Functoriality of actual idele extension along the degree-one +-identification of the original field with its fixed-field copy gives +-the same range inclusion for idele classes extended from the original +-field itself. +- +-The exact second-stage norm subgroup is the intrinsic small-Hilbert +-subgroup, so the genuine map from the original field on small-Hilbert +-quotients is trivial. Its naturality with extension of ideal classes +-then gives the class-group, integral-ideal, and fractional-ideal forms +-of principalization over the original number field. +--/ +- + open scoped Classical IsMulCommutative NumberField +- + noncomputable section +- + namespace GlobalClassFieldTheory + namespace IdealClassFieldTheory +- +-open ClassFormation +-open GlobalClassFields +-open KummerTheory +-open LocalClassFieldTheory +-open Reciprocity +- +-local instance +- smallHilbertPrincipalization_ideleClassGroupIsMulCommutative +- {F : Type} [Field F] [NumberField F] : +- IsMulCommutative (IdeleClassGroup F) := +- ⟨⟨fun a b => mul_comm a b⟩⟩ +- +-local instance +- smallHilbertPrincipalization_ideleClassSubgroupNormal +- {F : Type} [Field F] [NumberField F] +- (N : Subgroup (IdeleClassGroup F)) : N.Normal := +- N.normal_of_isMulCommutative +- +-local instance +- smallHilbertPrincipalization_smallHilbertQuotientGroup +- {F : Type} [Field F] [NumberField F] : +- Group +- (IdeleClassGroup F ⧸ +- smallHilbertClassFieldNormSubgroup (K := F)) := +- QuotientGroup.Quotient.group +- (smallHilbertClassFieldNormSubgroup (K := F)) +- +-local instance +- smallHilbertPrincipalization_smallHilbertQuotientOne +- {F : Type} [Field F] [NumberField F] : +- One +- (IdeleClassGroup F ⧸ +- smallHilbertClassFieldNormSubgroup (K := F)) := +- ⟨(smallHilbertPrincipalization_smallHilbertQuotientGroup +- (F := F)).one⟩ +- ++open ClassFormation GlobalClassFields KummerTheory LocalClassFieldTheory Reciprocity ++attribute [local instance] smallHilbertPrincipalization_ideleClassGroupIsMulCommutative ++ smallHilbertPrincipalization_ideleClassSubgroupNormal + variable (K : Type) [Field K] [NumberField K] + +-private theorem smallHilbertClassFieldIdeleExtensionMap_apply_eq_one +- (q : IdeleClassGroup K ⧸ +- smallHilbertClassFieldNormSubgroup (K := K)) : +- smallHilbertClassFieldIdeleExtensionMap +- K (smallHilbertClassField K) q = +- (1 : IdeleClassGroup (smallHilbertClassField K) ⧸ +- smallHilbertClassFieldNormSubgroup +- (K := smallHilbertClassField K)) := by +- induction q using QuotientGroup.induction_on with +- | _ c => +- change +- smallHilbertClassFieldIdeleExtensionMap +- K (smallHilbertClassField K) +- (QuotientGroup.mk' +- (smallHilbertClassFieldNormSubgroup (K := K)) c) = +- 1 +- have hcontainment := +- smallHilbertClassField_ideleClassExtension_range_le_secondNormRange K +- unfold smallHilbertClassFieldSecondNormRangeContainment at hcontainment +- have hmembership : +- ideleClassExtension K (smallHilbertClassField K) c ∈ +- smallHilbertClassFieldNormSubgroup +- (K := smallHilbertClassField K) := +- hcontainment ⟨c, rfl⟩ +- calc +- smallHilbertClassFieldIdeleExtensionMap +- K (smallHilbertClassField K) +- (QuotientGroup.mk' +- (smallHilbertClassFieldNormSubgroup (K := K)) c) = +- QuotientGroup.mk' +- (smallHilbertClassFieldNormSubgroup +- (K := smallHilbertClassField K)) +- (ideleClassExtension K (smallHilbertClassField K) c) := +- smallHilbertClassFieldIdeleExtensionMap_mk' +- K (smallHilbertClassField K) c +- _ = 1 := +- (QuotientGroup.eq_one_iff +- (ideleClassExtension K (smallHilbertClassField K) c)).2 +- hmembership +- +-/-- The map induced by genuine idele extension from the original +-number field on the two small-Hilbert reciprocity quotients is +-trivial. -/ +-theorem smallHilbertClassFieldIdeleExtensionMap_eq_one : +- @Eq +- ((IdeleClassGroup K ⧸ +- smallHilbertClassFieldNormSubgroup (K := K)) →* +- (IdeleClassGroup (smallHilbertClassField K) ⧸ +- smallHilbertClassFieldNormSubgroup +- (K := smallHilbertClassField K))) +- (smallHilbertClassFieldIdeleExtensionMap +- K (smallHilbertClassField K)) +- (1 : +- (IdeleClassGroup K ⧸ +- smallHilbertClassFieldNormSubgroup (K := K)) →* +- (IdeleClassGroup (smallHilbertClassField K) ⧸ +- smallHilbertClassFieldNormSubgroup +- (K := smallHilbertClassField K))) := by +- apply MonoidHom.ext +- intro q +- simpa only [MonoidHom.one_apply] using +- smallHilbertClassFieldIdeleExtensionMap_apply_eq_one K q +- +-private theorem smallHilbertClassFieldClassGroupExtension_apply_eq_one +- (c : ClassGroup (𝓞 K)) : +- ClassGroup.extendedHom +- (𝓞 K) (𝓞 (smallHilbertClassField K)) c = +- (1 : ClassGroup (𝓞 (smallHilbertClassField K))) := by +- obtain ⟨q, rfl⟩ := +- (smallHilbertClassFieldQuotientEquivClassGroup +- (K := K)).surjective c +- have hidele := +- smallHilbertClassFieldIdeleExtensionMap_apply_eq_one K q +- have hnaturality := +- smallHilbertClassFieldIdeleExtensionMap_naturality +- K (smallHilbertClassField K) q +- calc +- ClassGroup.extendedHom +- (𝓞 K) (𝓞 (smallHilbertClassField K)) +- (smallHilbertClassFieldQuotientEquivClassGroup (K := K) q) = +- smallHilbertClassFieldQuotientEquivClassGroup +- (K := smallHilbertClassField K) +- (smallHilbertClassFieldIdeleExtensionMap +- K (smallHilbertClassField K) q) := +- hnaturality.symm +- _ = smallHilbertClassFieldQuotientEquivClassGroup +- (K := smallHilbertClassField K) 1 := +- congrArg +- (smallHilbertClassFieldQuotientEquivClassGroup +- (K := smallHilbertClassField K)) hidele +- _ = 1 := +- (smallHilbertClassFieldQuotientEquivClassGroup +- (K := smallHilbertClassField K)).map_one +- +-/-- Extension of ideal classes from a number field to its selected +-small Hilbert class field is the trivial homomorphism. This follows +-directly from the naturality equality identifying actual idele +-extension with actual extension of ideal classes. -/ +-theorem smallHilbertClassFieldClassGroupExtension_eq_one : +- @Eq +- (ClassGroup (𝓞 K) →* +- ClassGroup (𝓞 (smallHilbertClassField K))) +- (ClassGroup.extendedHom +- (𝓞 K) (𝓞 (smallHilbertClassField K))) +- (1 : ClassGroup (𝓞 K) →* +- ClassGroup (𝓞 (smallHilbertClassField K))) := by +- apply MonoidHom.ext +- intro c +- simpa only [MonoidHom.one_apply] using +- smallHilbertClassFieldClassGroupExtension_apply_eq_one K c +- + /-- Every ideal of a number field becomes principal after extension + to the selected small Hilbert class field. -/ + theorem allIdealsBecomePrincipalInSmallHilbertClassField : +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationBase.lean +new file mode 100644 +index 0000000..ae72e33 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationBase.lean +@@ -0,0 +1,91 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.PrincipalIdealTheorem ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.PrincipalIdealTransfer ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerUnramified ++ ++ ++set_option autoImplicit false ++ ++/-! ++# Principalization in the selected small Hilbert class field ++ ++The selected second small Hilbert class field is Galois over the ++canonical fixed-field copy of the original base, and its maximal ++abelian intermediate field is the selected first small Hilbert class ++field. Witt transfer therefore places every idele class extended from ++that fixed-field copy in the norm range from the second stage. ++Functoriality of actual idele extension along the degree-one ++identification of the original field with its fixed-field copy gives ++the same range inclusion for idele classes extended from the original ++field itself. ++ ++The exact second-stage norm subgroup is the intrinsic small-Hilbert ++subgroup, so the genuine map from the original field on small-Hilbert ++quotients is trivial. Its naturality with extension of ideal classes ++then gives the class-group, integral-ideal, and fractional-ideal forms ++of principalization over the original number field. ++-/ ++ ++open scoped Classical IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace IdealClassFieldTheory ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open LocalClassFieldTheory ++open Reciprocity ++ ++local instance ++ smallHilbertPrincipalization_ideleClassGroupIsMulCommutative ++ {F : Type} [Field F] [NumberField F] : ++ IsMulCommutative (IdeleClassGroup F) := ++ ⟨⟨fun a b => mul_comm a b⟩⟩ ++ ++local instance ++ smallHilbertPrincipalization_ideleClassSubgroupNormal ++ {F : Type} [Field F] [NumberField F] ++ (N : Subgroup (IdeleClassGroup F)) : N.Normal := ++ N.normal_of_isMulCommutative ++ ++/-- A generic field-extension form keeps the class-field construction opaque. -/ ++theorem smallHilbertExtension_trivial_of_range ++ (K L : Type) [Field K] [NumberField K] [Field L] [NumberField L] ++ [Algebra K L] [FiniteDimensional K L] ++ (h : (ideleClassExtension K L).range ≤ ++ smallHilbertClassFieldNormSubgroup (K := L)) ++ (q : IdeleClassGroup K ⧸ smallHilbertClassFieldNormSubgroup (K := K)) : ++ smallHilbertClassFieldIdeleExtensionMap K L q = 1 := by ++ refine QuotientGroup.induction_on q ?_ ++ intro c ++ exact (smallHilbertClassFieldIdeleExtensionMap_mk' K L c).trans ++ ((QuotientGroup.eq_one_iff (ideleClassExtension K L c)).mpr (h ⟨c, rfl⟩)) ++ ++variable (K : Type) [Field K] [NumberField K] ++ ++/-- Extension to the small Hilbert class field sends each reciprocity ++quotient class to the identity class. -/ ++theorem smallHilbertClassFieldIdeleExtensionMap_apply_eq_one ++ (q : IdeleClassGroup K ⧸ ++ smallHilbertClassFieldNormSubgroup (K := K)) : ++ smallHilbertClassFieldIdeleExtensionMap ++ K (smallHilbertClassField K) q = ++ (1 : IdeleClassGroup (smallHilbertClassField K) ⧸ ++ smallHilbertClassFieldNormSubgroup ++ (K := smallHilbertClassField K)) := by ++ have hcontainment := ++ smallHilbertClassField_ideleClassExtension_range_le_secondNormRange K ++ unfold smallHilbertClassFieldSecondNormRangeContainment at hcontainment ++ exact smallHilbertExtension_trivial_of_range K (smallHilbertClassField K) ++ hcontainment q ++ ++end IdealClassFieldTheory ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationClassGroup.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationClassGroup.lean +new file mode 100644 +index 0000000..7889495 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationClassGroup.lean +@@ -0,0 +1,68 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertPrincipalizationIdele ++ ++set_option autoImplicit false ++open scoped Classical IsMulCommutative NumberField ++noncomputable section ++namespace GlobalClassFieldTheory ++namespace IdealClassFieldTheory ++open ClassFormation GlobalClassFields KummerTheory LocalClassFieldTheory Reciprocity ++attribute [local instance] smallHilbertPrincipalization_ideleClassGroupIsMulCommutative ++ smallHilbertPrincipalization_ideleClassSubgroupNormal ++variable (K : Type) [Field K] [NumberField K] ++ ++private theorem smallHilbertClassFieldClassGroupExtension_apply_eq_one ++ (c : ClassGroup (𝓞 K)) : ++ ClassGroup.extendedHom ++ (𝓞 K) (𝓞 (smallHilbertClassField K)) c = ++ (1 : ClassGroup (𝓞 (smallHilbertClassField K))) := by ++ obtain ⟨q, rfl⟩ := ++ (smallHilbertClassFieldQuotientEquivClassGroup ++ (K := K)).surjective c ++ have hidele := ++ smallHilbertClassFieldIdeleExtensionMap_apply_eq_one K q ++ have hnaturality := ++ smallHilbertClassFieldIdeleExtensionMap_naturality ++ K (smallHilbertClassField K) q ++ calc ++ ClassGroup.extendedHom ++ (𝓞 K) (𝓞 (smallHilbertClassField K)) ++ (smallHilbertClassFieldQuotientEquivClassGroup (K := K) q) = ++ smallHilbertClassFieldQuotientEquivClassGroup ++ (K := smallHilbertClassField K) ++ (smallHilbertClassFieldIdeleExtensionMap ++ K (smallHilbertClassField K) q) := ++ hnaturality.symm ++ _ = smallHilbertClassFieldQuotientEquivClassGroup ++ (K := smallHilbertClassField K) 1 := ++ congrArg ++ (smallHilbertClassFieldQuotientEquivClassGroup ++ (K := smallHilbertClassField K)) hidele ++ _ = 1 := ++ (smallHilbertClassFieldQuotientEquivClassGroup ++ (K := smallHilbertClassField K)).map_one ++ ++/-- Extension of ideal classes from a number field to its selected ++small Hilbert class field is the trivial homomorphism. This follows ++directly from the naturality equality identifying actual idele ++extension with actual extension of ideal classes. -/ ++theorem smallHilbertClassFieldClassGroupExtension_eq_one : ++ @Eq ++ (ClassGroup (𝓞 K) →* ++ ClassGroup (𝓞 (smallHilbertClassField K))) ++ (ClassGroup.extendedHom ++ (𝓞 K) (𝓞 (smallHilbertClassField K))) ++ (1 : ClassGroup (𝓞 K) →* ++ ClassGroup (𝓞 (smallHilbertClassField K))) := by ++ apply MonoidHom.ext ++ intro c ++ simpa only [MonoidHom.one_apply] using ++ smallHilbertClassFieldClassGroupExtension_apply_eq_one K c ++ ++end IdealClassFieldTheory ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationIdele.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationIdele.lean +new file mode 100644 +index 0000000..e11bcfb +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertPrincipalizationIdele.lean +@@ -0,0 +1,43 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertPrincipalizationBase ++ ++set_option autoImplicit false ++open scoped Classical IsMulCommutative NumberField ++noncomputable section ++namespace GlobalClassFieldTheory ++namespace IdealClassFieldTheory ++open ClassFormation GlobalClassFields KummerTheory LocalClassFieldTheory Reciprocity ++attribute [local instance] smallHilbertPrincipalization_ideleClassGroupIsMulCommutative ++ smallHilbertPrincipalization_ideleClassSubgroupNormal ++variable (K : Type) [Field K] [NumberField K] ++ ++/-- The map induced by genuine idele extension from the original ++number field on the two small-Hilbert reciprocity quotients is ++trivial. -/ ++theorem smallHilbertClassFieldIdeleExtensionMap_eq_one : ++ @Eq ++ ((IdeleClassGroup K ⧸ ++ smallHilbertClassFieldNormSubgroup (K := K)) →* ++ (IdeleClassGroup (smallHilbertClassField K) ⧸ ++ smallHilbertClassFieldNormSubgroup ++ (K := smallHilbertClassField K))) ++ (smallHilbertClassFieldIdeleExtensionMap ++ K (smallHilbertClassField K)) ++ (1 : ++ (IdeleClassGroup K ⧸ ++ smallHilbertClassFieldNormSubgroup (K := K)) →* ++ (IdeleClassGroup (smallHilbertClassField K) ⧸ ++ smallHilbertClassFieldNormSubgroup ++ (K := smallHilbertClassField K))) := by ++ apply MonoidHom.ext ++ intro q ++ simpa only [MonoidHom.one_apply] using ++ smallHilbertClassFieldIdeleExtensionMap_apply_eq_one K q ++ ++end IdealClassFieldTheory ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealization.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealization.lean +index 3edfd94..f01c3d8 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealization.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealization.lean +@@ -4,28 +4,10 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldRealization +-import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerConjugation +-import Mathlib.Data.Rat.Cast.Defs + +-set_option autoImplicit false +- +-/-! +-# Actual realization of the two-stage small Hilbert tower +- +-The first small Hilbert class field is the actual finite abelian +-subextension selected in `HilbertClassFieldRealization`. Over its actual +-fixed field, the closed finite-index small-Hilbert norm subgroup has a +-finite Galois norm neighbourhood. We embed that neighbourhood in the +-rational separable closure compatibly with the already chosen first +-stage. Finite abelian classification then selects the second small +-Hilbert class field over the literal first-stage subgroup. ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerRealizationSecond + +-The compatibility of the embedding is essential: an unrelated chosen +-copy of the middle number field would produce a class field over a +-conjugate closed subgroup rather than over the first-stage subgroup +-itself. +--/ ++set_option autoImplicit false + + open scoped Classical NumberField + +@@ -43,33 +25,10 @@ open LocalClassFieldTheory + open RamificationTheory + open Reciprocity + +-/-- The ordinary idèle-class operations used by the two-stage transport, +-fixed at the canonical principal-subgroup quotient. -/ +-@[instance_reducible] +-private noncomputable def smallHilbertTowerIdeleClassCommGroup +- (F : Type) [Field F] [NumberField F] : +- CommGroup (IdeleClassGroup F) := +- QuotientGroup.Quotient.commGroup (IdeleGroup.principalSubgroup F) + + attribute [local instance] smallHilbertTowerIdeleClassCommGroup +- +-private theorem addSubgroup_comap_symm_eq_map +- {A B : Type*} [AddGroup A] [AddGroup B] +- (H : AddSubgroup A) (e : A ≃+ B) : +- H.comap e.symm.toAddMonoidHom = +- H.map e.toAddMonoidHom := by +- exact (AddSubgroup.map_equiv_eq_comap_symm e H).symm +- +-private noncomputable abbrev +- closedFiniteIndexNormAmbientCanonicalBaseAlgebra +- (F : Type) [Field F] [NumberField F] +- (H : Subgroup (IdeleClassGroup F)) +- (hclosed : IsClosed (H : Set (IdeleClassGroup F))) +- [H.FiniteIndex] : +- Algebra F +- (closedFiniteIndexClassFieldNormAmbient +- (K := F) H hclosed) := +- inferInstance ++ smallHilbertTowerNormAmbientAlgebra ++ smallHilbertTowerNormAmbientIsGalois + + section RationalFixedField + +@@ -78,758 +37,9 @@ variable + (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) + (L : FiniteAbelianSubextension K.field) + +-private noncomputable abbrev smallHilbertTowerMiddleFiniteAbstractField : +- FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- { field := L.field +- finite := by +- let : Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- K.field (le_baseField K.field)) := +- K.finite +- let : Finite +- (K.field.toSubgroup ⧸ +- extensionSubgroup K.field L.field L.below) := +- L.finite +- exact +- FiniteGaloisSubextension.finite_extension_trans +- L.below (le_baseField K.field) } +- +-local notation "E" => +- abstractFixedField ℚ (SeparableClosure ℚ) L.field +- +-local notation "N" => +- smallHilbertClassFieldNormAmbient E +- +-private noncomputable instance +- smallHilbertTowerMiddleAbstractQuotientFinite : +- Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- L.field (le_baseField L.field)) := +- (smallHilbertTowerMiddleFiniteAbstractField K L).finite +- +-private noncomputable instance +- smallHilbertTowerMiddleFiniteDimensional : +- FiniteDimensional ℚ E := +- abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) L.field inferInstance +- +-private noncomputable instance +- smallHilbertTowerMiddleNumberField : +- NumberField E := +- NumberField.of_module_finite ℚ E +- +-/-- The canonical small-Hilbert subgroup over the literal middle field. +-This typed endpoint avoids repeatedly reducing the finite-abstract-field +-package merely to recover its `field = L.field` projection. -/ +-noncomputable def smallHilbertTowerMiddleNormSubgroup : +- AddSubgroup +- (ambientFixedAddSubgroup +- rationalIdeleClassRepresentation L.field) := +- (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup.comap +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom +- +-/-- The typed `comap` endpoint is the canonical transported `map` endpoint. +-This uses only the generic additive equivalence law. -/ +-theorem smallHilbertTowerMiddleNormSubgroup_eq_map : +- smallHilbertTowerMiddleNormSubgroup K L = +- (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup.map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).toAddMonoidHom := by +- exact addSubgroup_comap_symm_eq_map +- (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup +- (rationalAbstractFixedFieldIdeleClassEquivFixed L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)) +- +-@[reducible] +-private noncomputable def +- smallHilbertTowerNormAmbientAlgebra : +- Algebra E N := +- closedFiniteIndexNormAmbientCanonicalBaseAlgebra E +- (smallHilbertClassFieldNormSubgroup (K := E)) +- (smallHilbertClassFieldNormSubgroup_isClosed (K := E)) +- +-attribute [local instance] smallHilbertTowerNormAmbientAlgebra +- +-@[reducible] +-private noncomputable def +- smallHilbertTowerNormAmbientSMul : +- SMul E N := +- Algebra.toSMul +- (self := smallHilbertTowerNormAmbientAlgebra K L) +- +-@[reducible] +-private noncomputable def +- smallHilbertTowerNormAmbientModule : +- Module E N := +- @Algebra.toModule E N _ _ +- (smallHilbertTowerNormAmbientAlgebra K L) +- +-private theorem +- smallHilbertTowerNormAmbientScalarTower : +- @IsScalarTower ℚ E N +- (Algebra.toSMul (R := ℚ) (A := E)) +- (smallHilbertTowerNormAmbientSMul K L) +- (Algebra.toSMul (R := ℚ) (A := N)) := by +- exact IsScalarTower.of_algebraMap_eq' +- (R := ℚ) (S := E) (A := N) +- (RingHom.ext_rat (algebraMap ℚ N) +- ((algebraMap E N).comp (algebraMap ℚ E))) +- +-private noncomputable def +- smallHilbertTowerNormAmbientAlgHom : +- E →ₐ[ℚ] N := +- { toRingHom := algebraMap E N +- commutes' := fun r => +- (RingHom.congr_fun +- (RingHom.ext_rat +- ((algebraMap E N).comp (algebraMap ℚ E)) +- (algebraMap ℚ N)) r) } +- +-private theorem smallHilbertTowerNormAmbientAlgHom_apply +- (x : E) : +- smallHilbertTowerNormAmbientAlgHom K L x = +- algebraMap E N x := by +- rfl +- +-private theorem +- smallHilbertTowerNormAmbientIsGalois : +- IsGalois E N := by +- unfold smallHilbertClassFieldNormAmbient +- closedFiniteIndexClassFieldNormAmbient +- exact +- closedFiniteIndexNormAmbientIsGalois +- (smallHilbertClassFieldNormSubgroup (K := E)) +- (smallHilbertClassFieldNormSubgroup_isClosed (K := E)) +- +-attribute [local instance] smallHilbertTowerNormAmbientIsGalois +- +-private noncomputable def +- smallHilbertNormNeighborhoodForwardAlignment : +- SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := by +- let j₀ : N →ₐ[ℚ] SeparableClosure ℚ := +- numberFieldSeparableClosureEmbedding N +- let i₀ : E →ₐ[ℚ] SeparableClosure ℚ := +- j₀.comp (smallHilbertTowerNormAmbientAlgHom K L) +- exact +- AlgEquiv.ofBijective +- (i₀.liftNormal (SeparableClosure ℚ)) +- (AlgHom.normal_bijective +- ℚ (SeparableClosure ℚ) (SeparableClosure ℚ) _) +- +-/-- The separable-closure automorphism which aligns an arbitrary chosen +-embedding of the norm-neighbourhood field with the already embedded +-middle field. -/ +-private noncomputable def +- smallHilbertNormNeighborhoodAlignment : +- SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := +- (smallHilbertNormNeighborhoodForwardAlignment K L).symm +- +-@[simp] +-private theorem smallHilbertNormNeighborhoodForwardAlignment_apply +- (x : E) : +- smallHilbertNormNeighborhoodForwardAlignment K L +- (x : SeparableClosure ℚ) = +- (numberFieldSeparableClosureEmbedding N) +- (algebraMap E N x) := by +- let j₀ : N →ₐ[ℚ] SeparableClosure ℚ := +- numberFieldSeparableClosureEmbedding N +- let i₀ : E →ₐ[ℚ] SeparableClosure ℚ := +- j₀.comp (smallHilbertTowerNormAmbientAlgHom K L) +- dsimp only [smallHilbertNormNeighborhoodForwardAlignment, +- AlgEquiv.ofBijective_apply] +- calc +- _ = i₀ x := by +- simpa only [IntermediateField.algebraMap_apply, +- Algebra.algebraMap_self, RingHom.id_apply] using +- i₀.liftNormal_commutes (SeparableClosure ℚ) x +- _ = j₀ (algebraMap E N x) := by +- change +- j₀ (smallHilbertTowerNormAmbientAlgHom K L x) = +- j₀ (algebraMap E N x) +- exact congrArg j₀ +- (smallHilbertTowerNormAmbientAlgHom_apply K L x) +- +-/-- A controlled embedding of the concrete finite Galois norm +-neighbourhood. Its restriction to the middle field is the literal +-inclusion of that fixed field in `SeparableClosure ℚ`. -/ +-private noncomputable def +- smallHilbertNormNeighborhoodEmbedding : +- N →ₐ[ℚ] SeparableClosure ℚ := +- (smallHilbertNormNeighborhoodAlignment K L).toAlgHom.comp +- (numberFieldSeparableClosureEmbedding N) +- +-@[simp] +-private theorem smallHilbertNormNeighborhoodEmbedding_algebraMap +- (x : E) : +- smallHilbertNormNeighborhoodEmbedding K L +- (algebraMap E N x) = +- (x : SeparableClosure ℚ) := by +- change +- (smallHilbertNormNeighborhoodForwardAlignment K L).symm +- ((numberFieldSeparableClosureEmbedding N) +- (algebraMap E N x)) = +- (x : SeparableClosure ℚ) +- rw [← smallHilbertNormNeighborhoodForwardAlignment_apply K L x] +- exact +- (smallHilbertNormNeighborhoodForwardAlignment K L).symm_apply_apply _ +- +-private abbrev smallHilbertNormNeighborhoodEmbeddedBase : +- ClosedSubgroup +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange +- ((smallHilbertNormNeighborhoodEmbedding K L).comp +- (smallHilbertTowerNormAmbientAlgHom K L))) +- +-private abbrev smallHilbertNormNeighborhoodEmbeddedField : +- ClosedSubgroup +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange +- (smallHilbertNormNeighborhoodEmbedding K L)) +- +-private theorem smallHilbertNormNeighborhoodEmbeddedField_le_base : +- (smallHilbertNormNeighborhoodEmbeddedField K L).toSubgroup ≤ +- (smallHilbertNormNeighborhoodEmbeddedBase K L).toSubgroup := by +- change +- (AlgHom.fieldRange +- (smallHilbertNormNeighborhoodEmbedding K L)).fixingSubgroup ≤ +- (AlgHom.fieldRange +- ((smallHilbertNormNeighborhoodEmbedding K L).comp +- (smallHilbertTowerNormAmbientAlgHom K L))).fixingSubgroup +- apply +- (AlgHom.fieldRange +- ((smallHilbertNormNeighborhoodEmbedding K L).comp +- (smallHilbertTowerNormAmbientAlgHom K L))).fixingSubgroup_le +- exact +- AlgHom.range_comp_le_range +- (smallHilbertTowerNormAmbientAlgHom K L) +- (smallHilbertNormNeighborhoodEmbedding K L) +- +-private theorem smallHilbertNormNeighborhoodEmbeddedBase_eq : +- smallHilbertNormNeighborhoodEmbeddedBase K L = L.field := by +- have hi : +- (smallHilbertNormNeighborhoodEmbedding K L).comp +- (smallHilbertTowerNormAmbientAlgHom K L) = +- (abstractFixedField ℚ (SeparableClosure ℚ) L.field).val := by +- apply AlgHom.ext +- intro x +- change smallHilbertNormNeighborhoodEmbedding K L +- (smallHilbertTowerNormAmbientAlgHom K L x) = (x : SeparableClosure ℚ) +- rw [smallHilbertTowerNormAmbientAlgHom_apply K L x] +- exact smallHilbertNormNeighborhoodEmbedding_algebraMap K L x +- change +- closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange +- ((smallHilbertNormNeighborhoodEmbedding K L).comp +- (smallHilbertTowerNormAmbientAlgHom K L))) = +- L.field +- rw [hi, IntermediateField.fieldRange_val] +- exact +- closedFixingSubgroup_abstractFixedField_eq +- ℚ (SeparableClosure ℚ) L.field +- +-private noncomputable def +- smallHilbertNormNeighborhoodSeparableClosureEquiv : +- let j := smallHilbertNormNeighborhoodEmbedding K L +- let i := j.comp (smallHilbertTowerNormAmbientAlgHom K L) +- let : Algebra E (SeparableClosure ℚ) := +- i.toRingHom.toAlgebra +- SeparableClosure E ≃ₐ[E] SeparableClosure ℚ := by +- intro j i alg +- let : @IsScalarTower ℚ E (SeparableClosure ℚ) +- (Algebra.toSMul (R := ℚ) (A := E)) +- alg.toSMul +- (Algebra.toSMul (R := ℚ) (A := SeparableClosure ℚ)) := +- IsScalarTower.of_algebraMap_eq' i.comp_algebraMap.symm +- let : IsSepClosure E (SeparableClosure ℚ) := +- ⟨IsSepClosure.sep_closed ℚ, +- Algebra.isSeparable_tower_top_of_isSeparable +- ℚ E (SeparableClosure ℚ)⟩ +- exact +- IsSepClosure.equiv E +- (SeparableClosure E) (SeparableClosure ℚ) +- +-private noncomputable def +- smallHilbertFiniteGaloisNormNeighborhoodRaw : +- FiniteGaloisSubextension +- (smallHilbertNormNeighborhoodEmbeddedBase K L) := by +- let : @IsScalarTower ℚ E N +- (Algebra.toSMul (R := ℚ) (A := E)) +- (smallHilbertTowerNormAmbientSMul K L) +- (Algebra.toSMul (R := ℚ) (A := N)) := +- smallHilbertTowerNormAmbientScalarTower K L +- let j : N →ₐ[ℚ] SeparableClosure ℚ := +- smallHilbertNormNeighborhoodEmbedding K L +- let i : E →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ E N) +- let B : ClosedSubgroup (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- closedFixingSubgroup ℚ (SeparableClosure ℚ) i.fieldRange +- let T : ClosedSubgroup (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- smallHilbertNormNeighborhoodEmbeddedField K L +- have hTB : T.toSubgroup ≤ B.toSubgroup := by +- change j.fieldRange.fixingSubgroup ≤ i.fieldRange.fixingSubgroup +- apply i.fieldRange.fixingSubgroup_le +- exact AlgHom.range_comp_le_range (IsScalarTower.toAlgHom ℚ E N) j +- let raw : FiniteGaloisSubextension B := { +- field := T +- below := hTB +- normal := ambientEmbeddedExtensionSubgroup_normal ℚ E N j +- (smallHilbertNormNeighborhoodSeparableClosureEquiv K L) +- finite := ambientEmbeddedExtensionQuotient_finite ℚ E N j +- (smallHilbertNormNeighborhoodSeparableClosureEquiv K L) } +- have hi : IsScalarTower.toAlgHom ℚ E N = +- smallHilbertTowerNormAmbientAlgHom K L := by +- apply AlgHom.ext +- intro x +- exact (IsScalarTower.toAlgHom_apply ℚ E N x).trans +- (smallHilbertTowerNormAmbientAlgHom_apply K L x).symm +- have hB : B = smallHilbertNormNeighborhoodEmbeddedBase K L := +- congrArg +- (fun f : E →ₐ[ℚ] N => +- closedFixingSubgroup ℚ (SeparableClosure ℚ) (j.comp f).fieldRange) hi +- exact hB ▸ raw +- +-private noncomputable def rebaseFiniteGaloisSubextension +- {G : Type} [Group G] [TopologicalSpace G] +- {B B' : ClosedSubgroup G} (h : B = B') +- (P : FiniteGaloisSubextension B) : +- FiniteGaloisSubextension B' := +- h ▸ P +- +-@[simp] +-private theorem rebaseFiniteGaloisSubextension_field +- {G : Type} [Group G] [TopologicalSpace G] +- {B B' : ClosedSubgroup G} (h : B = B') +- (P : FiniteGaloisSubextension B) : +- (rebaseFiniteGaloisSubextension h P).field = P.field := by +- cases h +- rfl +- +-private theorem +- rebaseRationalFiniteGaloisSubextension_fixedField_eq +- {B B' : ClosedSubgroup +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} +- (h : B = B') (P : FiniteGaloisSubextension B) : +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (rebaseFiniteGaloisSubextension h P).below).restrictScalars ℚ = +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- P.below).restrictScalars ℚ := by +- cases h +- rfl +- +-/-- An actual finite Galois norm neighbourhood over the literal +-first-stage subgroup. It is produced by the finite-index Kummer +-construction and the controlled embedding above. -/ +-noncomputable def smallHilbertFiniteGaloisNormNeighborhood : +- FiniteGaloisSubextension L.field := +- rebaseFiniteGaloisSubextension +- (smallHilbertNormNeighborhoodEmbeddedBase_eq K L) +- (smallHilbertFiniteGaloisNormNeighborhoodRaw K L) +- +-/-- The abstract norm subgroup of the chosen neighbourhood, pinned to the +-literal middle-field carrier. -/ +-noncomputable def smallHilbertFiniteGaloisNormNeighborhoodNormSubgroup : +- AddSubgroup +- (ambientFixedAddSubgroup +- rationalIdeleClassRepresentation L.field) := +- (smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup +- rationalIdeleClassRepresentation +- +-private noncomputable abbrev +- smallHilbertFiniteGaloisNormNeighborhoodTopField : Type := +- abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (smallHilbertFiniteGaloisNormNeighborhood K L).below +- +-local notation "E₂" => +- smallHilbertFiniteGaloisNormNeighborhoodTopField K L +- +-private noncomputable instance +- smallHilbertFiniteGaloisNormNeighborhoodQuotientFinite : +- Finite +- (L.field.toSubgroup ⧸ +- extensionSubgroup L.field +- (smallHilbertFiniteGaloisNormNeighborhood K L).field +- (smallHilbertFiniteGaloisNormNeighborhood K L).below) := +- (smallHilbertFiniteGaloisNormNeighborhood K L).finite +- +-private noncomputable instance +- smallHilbertFiniteGaloisNormNeighborhoodFiniteDimensional : +- FiniteDimensional E E₂ := +- abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) L.field +- (smallHilbertFiniteGaloisNormNeighborhood K L).field +- (smallHilbertFiniteGaloisNormNeighborhood K L).below +- inferInstance inferInstance +- +-private noncomputable instance +- smallHilbertFiniteGaloisNormNeighborhoodScalarTower : +- IsScalarTower ℚ E E₂ := +- IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) +- +-private noncomputable instance +- smallHilbertFiniteGaloisNormNeighborhoodAbsoluteFiniteDimensional : +- FiniteDimensional ℚ E₂ := +- FiniteDimensional.trans ℚ E E₂ +- +-private noncomputable instance +- smallHilbertFiniteGaloisNormNeighborhoodNumberField : +- NumberField E₂ := +- NumberField.of_module_finite ℚ E₂ +- +-private noncomputable instance +- smallHilbertFiniteGaloisNormNeighborhoodIsGalois : +- IsGalois E E₂ := +- abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) L.field +- (smallHilbertFiniteGaloisNormNeighborhood K L).field +- (smallHilbertFiniteGaloisNormNeighborhood K L).below +- (smallHilbertFiniteGaloisNormNeighborhood K L).normal +- +-private theorem +- smallHilbertFiniteGaloisNormNeighborhood_fixedField_eq_range : +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (smallHilbertFiniteGaloisNormNeighborhood K L).below).restrictScalars ℚ = +- AlgHom.fieldRange +- (smallHilbertNormNeighborhoodEmbedding K L) := by +- rw [show +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (smallHilbertFiniteGaloisNormNeighborhood K L).below).restrictScalars ℚ = +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (smallHilbertFiniteGaloisNormNeighborhoodRaw K L).below).restrictScalars ℚ +- from +- rebaseRationalFiniteGaloisSubextension_fixedField_eq +- (smallHilbertNormNeighborhoodEmbeddedBase_eq K L) +- (smallHilbertFiniteGaloisNormNeighborhoodRaw K L)] +- exact +- InfiniteGalois.fixedField_fixingSubgroup +- (AlgHom.fieldRange +- (smallHilbertNormNeighborhoodEmbedding K L)) +- +-private noncomputable def +- smallHilbertFiniteGaloisNormNeighborhoodTopEquiv : +- N ≃ₐ[ℚ] +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (smallHilbertFiniteGaloisNormNeighborhood K L).below).restrictScalars ℚ := +- (smallHilbertNormNeighborhoodEmbedding K L).equivFieldRange.trans +- (IntermediateField.equivOfEq +- (smallHilbertFiniteGaloisNormNeighborhood_fixedField_eq_range +- K L).symm) +- +-@[simp] +-private theorem +- smallHilbertFiniteGaloisNormNeighborhoodTopEquiv_algebraMap +- (x : E) : +- smallHilbertFiniteGaloisNormNeighborhoodTopEquiv K L +- (algebraMap E N x) = +- algebraMap E +- E₂ x := by +- apply Subtype.ext +- change +- smallHilbertNormNeighborhoodEmbedding K L +- (algebraMap E N x) = +- (x : SeparableClosure ℚ) +- exact smallHilbertNormNeighborhoodEmbedding_algebraMap K L x +- +-private noncomputable def +- smallHilbertFiniteGaloisNormNeighborhoodRelativeTopEquiv : +- N ≃ₐ[E] E₂ := { +- smallHilbertFiniteGaloisNormNeighborhoodTopEquiv K L with +- commutes' := fun x => +- smallHilbertFiniteGaloisNormNeighborhoodTopEquiv_algebraMap +- K L x } +- +-private theorem +- smallHilbertFiniteGaloisNormNeighborhood_ordinaryNorm_le : +- (_root_.ideleClassNorm E N).range ≤ +- smallHilbertClassFieldNormSubgroup (K := E) := by +- simpa only [smallHilbertClassFieldNormAmbient] using +- (closedFiniteIndexClassFieldNormAmbient_normRange_le +- (K := E) (smallHilbertClassFieldNormSubgroup (K := E)) +- (smallHilbertClassFieldNormSubgroup_isClosed (K := E))) +- +-private theorem +- smallHilbertFiniteGaloisNormNeighborhood_ordinaryNormRange_eq : +- (_root_.ideleClassNorm E N).range = +- (_root_.ideleClassNorm E E₂).range := by +- simpa only [ordinaryIdeleClassNorm_range_eq_relative] using +- (ideleClassNorm_range_algEquiv +- (K := E) +- (smallHilbertFiniteGaloisNormNeighborhoodRelativeTopEquiv +- K L)).symm +- +-private theorem +- smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq : +- ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup +- rationalIdeleClassRepresentation).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = +- (_root_.ideleClassNorm E E₂).range.toAddSubgroup := by +- change +- (finiteNormSubgroup rationalIdeleClassRepresentation +- L.field +- (smallHilbertFiniteGaloisNormNeighborhood K L).field +- (smallHilbertFiniteGaloisNormNeighborhood K L).below).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = +- (_root_.ideleClassNorm E E₂).range.toAddSubgroup +- exact +- (map_rationalFiniteNormSubgroup_eq_ordinaryIdeleClassNormRange_concrete +- L.field +- (smallHilbertFiniteGaloisNormNeighborhood K L).field +- (smallHilbertFiniteGaloisNormNeighborhood K L).below +- (smallHilbertFiniteGaloisNormNeighborhood K L).normal) +- +-/-- The abstract norm map lands directly in the ordinary norm range of the +-chosen neighbourhood. Composing the two named subgroup equalities here +-keeps downstream membership proofs pointwise. -/ +-private theorem +- smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq_ordinaryNormRange : +- ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup +- rationalIdeleClassRepresentation).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = +- (_root_.ideleClassNorm E N).range.toAddSubgroup := +- (smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq K L).trans +- (congrArg Subgroup.toAddSubgroup +- (smallHilbertFiniteGaloisNormNeighborhood_ordinaryNormRange_eq K L).symm) +- +-/-- Pointwise form of the combined norm-range equality. -/ +-private theorem +- smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_mem_ordinaryNormRange +- (a : Additive (IdeleClassGroup E)) +- (ha : +- a ∈ ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup +- rationalIdeleClassRepresentation).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom) : +- a ∈ (_root_.ideleClassNorm E N).range.toAddSubgroup := +- (le_of_eq +- (smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq_ordinaryNormRange +- K L)) ha +- +-/-- The actual finite Galois norm neighbourhood has abstract norm +-subgroup contained in the canonical small-Hilbert subgroup of the +-middle fixed field. This is the source-producing norm-topology input; +-no norm-openness premise is assumed. -/ +-theorem smallHilbertFiniteGaloisNormNeighborhood_normSubgroup_le : +- ∀ a : ambientFixedAddSubgroup +- rationalIdeleClassRepresentation L.field, +- a ∈ smallHilbertFiniteGaloisNormNeighborhoodNormSubgroup K L → +- a ∈ smallHilbertTowerMiddleNormSubgroup K L := by +- intro a ha +- change +- a ∈ (smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup +- rationalIdeleClassRepresentation at ha +- have haMap : +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm a ∈ +- ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup +- rationalIdeleClassRepresentation).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom := +- ⟨a, ha, rfl⟩ +- have haOrdinary : +- (rationalAbstractFixedFieldIdeleClassEquivFixed L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm a ∈ +- (_root_.ideleClassNorm E N).range.toAddSubgroup := +- smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_mem_ordinaryNormRange +- K L _ haMap +- exact smallHilbertFiniteGaloisNormNeighborhood_ordinaryNorm_le K L haOrdinary +- +-/-- The canonical small-Hilbert subgroup of the actual middle fixed +-field is open in the genuine norm topology. -/ +-theorem smallHilbertNormSubgroupInRationalClassFormation_isNormOpen : +- IsNormOpen rationalIdeleClassRepresentation L.field +- (smallHilbertTowerMiddleNormSubgroup K L : +- Set +- (ambientFixedAddSubgroup +- rationalIdeleClassRepresentation L.field)) := by +- rw [normTopology_addSubgroup_isOpen_iff] +- refine +- ⟨smallHilbertFiniteGaloisNormNeighborhood K L, ?_⟩ +- change +- smallHilbertFiniteGaloisNormNeighborhoodNormSubgroup K L ≤ +- smallHilbertTowerMiddleNormSubgroup K L +- exact smallHilbertFiniteGaloisNormNeighborhood_normSubgroup_le K L +- +-/-- The second small Hilbert class field as an actual finite abelian +-subextension of the literal first-stage field. -/ +-noncomputable def secondSmallHilbertClassFieldSubextension : +- FiniteAbelianSubextension L.field := by +- let H : FiniteAbelianSubextension.NormOpenAddSubgroup +- rationalIdeleClassRepresentation L.field := +- ⟨smallHilbertTowerMiddleNormSubgroup K L, +- smallHilbertNormSubgroupInRationalClassFormation_isNormOpen K L⟩ +- exact +- Classical.choose +- (FiniteAbelianSubextension.normSubgroupMap_surjective +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (smallHilbertTowerMiddleFiniteAbstractField K L) H) +- +-/-- The second-stage extension realizes exactly the canonical +-small-Hilbert norm subgroup of the actual middle field. -/ +-@[simp] +-theorem secondSmallHilbertClassFieldSubextension_normSubgroup : +- (secondSmallHilbertClassFieldSubextension K L).normSubgroup +- rationalIdeleClassRepresentation = +- smallHilbertTowerMiddleNormSubgroup K L := by +- let H : FiniteAbelianSubextension.NormOpenAddSubgroup +- rationalIdeleClassRepresentation L.field := +- ⟨smallHilbertTowerMiddleNormSubgroup K L, +- smallHilbertNormSubgroupInRationalClassFormation_isNormOpen K L⟩ +- have h := +- Classical.choose_spec +- (FiniteAbelianSubextension.normSubgroupMap_surjective +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (smallHilbertTowerMiddleFiniteAbstractField K L) H) +- exact congrArg Subtype.val h +- +-private noncomputable abbrev secondSmallHilbertClassFieldTopField : Type := +- abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (secondSmallHilbertClassFieldSubextension K L).below +- +-local notation "T₂" => secondSmallHilbertClassFieldTopField K L +- +-private noncomputable instance +- secondSmallHilbertClassFieldSubextensionQuotientFinite : +- Finite +- (L.field.toSubgroup ⧸ +- extensionSubgroup L.field +- (secondSmallHilbertClassFieldSubextension K L).field +- (secondSmallHilbertClassFieldSubextension K L).below) := +- (secondSmallHilbertClassFieldSubextension K L).finite +- +-private noncomputable instance +- secondSmallHilbertClassFieldTopFiniteDimensional : +- FiniteDimensional E T₂ := +- abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) L.field +- (secondSmallHilbertClassFieldSubextension K L).field +- (secondSmallHilbertClassFieldSubextension K L).below +- inferInstance inferInstance +- +-private noncomputable instance +- secondSmallHilbertClassFieldTopScalarTower : +- IsScalarTower ℚ E T₂ := +- IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) +- +-private noncomputable instance +- secondSmallHilbertClassFieldTopAbsoluteFiniteDimensional : +- FiniteDimensional ℚ T₂ := +- FiniteDimensional.trans ℚ E T₂ +- +-private noncomputable instance +- secondSmallHilbertClassFieldTopNumberField : +- NumberField T₂ := +- NumberField.of_module_finite ℚ T₂ +- +-private noncomputable instance +- secondSmallHilbertClassFieldTopIsGalois : +- IsGalois E T₂ := +- abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) L.field +- (secondSmallHilbertClassFieldSubextension K L).field +- (secondSmallHilbertClassFieldSubextension K L).below +- (secondSmallHilbertClassFieldSubextension K L).normal +- +-private theorem +- secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_actualNormRange : +- ((secondSmallHilbertClassFieldSubextension K L).normSubgroup +- rationalIdeleClassRepresentation).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = +- (_root_.ideleClassNorm E T₂).range.toAddSubgroup := by +- change +- (finiteNormSubgroup rationalIdeleClassRepresentation +- L.field +- (secondSmallHilbertClassFieldSubextension K L).field +- (secondSmallHilbertClassFieldSubextension K L).below).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = +- (_root_.ideleClassNorm E T₂).range.toAddSubgroup +- exact +- map_rationalFiniteNormSubgroup_eq_ordinaryIdeleClassNormRange_concrete +- L.field +- (secondSmallHilbertClassFieldSubextension K L).field +- (secondSmallHilbertClassFieldSubextension K L).below +- (secondSmallHilbertClassFieldSubextension K L).normal +- +-private theorem +- secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_smallHilbertNormSubgroup : +- ((secondSmallHilbertClassFieldSubextension K L).normSubgroup +- rationalIdeleClassRepresentation).map +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = +- (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup := by +- let e : Additive (IdeleClassGroup E) ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation L.field := +- rationalAbstractFixedFieldIdeleClassEquivFixed L.field +- (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L) +- let H : AddSubgroup (Additive (IdeleClassGroup E)) := +- (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup +- let back : AddSubgroup +- (ambientFixedAddSubgroup rationalIdeleClassRepresentation L.field) → +- AddSubgroup (Additive (IdeleClassGroup E)) := +- fun n => n.map e.symm.toAddMonoidHom +- have hNorm : +- back ((secondSmallHilbertClassFieldSubextension K L).normSubgroup +- rationalIdeleClassRepresentation) = +- back (smallHilbertTowerMiddleNormSubgroup K L) := +- congrArg back (secondSmallHilbertClassFieldSubextension_normSubgroup K L) +- have hCancel : back (smallHilbertTowerMiddleNormSubgroup K L) = H := +- AddSubgroup.map_comap_eq_self_of_surjective e.symm.surjective H +- exact hNorm.trans hCancel +- +-/-- The actual second small Hilbert class field has exactly the intrinsic +-small-Hilbert norm range over the literal middle fixed field. -/ +-@[simp] +-theorem secondSmallHilbertClassFieldSubextension_ideleClassNorm_range : +- (_root_.ideleClassNorm E T₂).range = +- smallHilbertClassFieldNormSubgroup (K := E) := by +- apply Subgroup.toAddSubgroup.injective +- exact +- (secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_actualNormRange +- K L).symm.trans +- (secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_smallHilbertNormSubgroup +- K L) + +-/-- Compatibility of the typed middle endpoint with the canonical endpoint +-used by the conjugation API. -/ +-theorem smallHilbertTowerMiddleNormSubgroup_eq_conjugationEndpoint : +- smallHilbertTowerMiddleNormSubgroup K L = +- smallHilbertNormSubgroupInRationalClassFormation +- (L.toFiniteGaloisExtension.toFiniteAbstractFieldExtension).field := by +- have hField : +- (L.toFiniteGaloisExtension.toFiniteAbstractFieldExtension).field.field = +- L.field := by +- rfl +- unfold smallHilbertNormSubgroupInRationalClassFormation +- cases hField +- exact smallHilbertTowerMiddleNormSubgroup_eq_map K L ++local notation "E" => abstractFixedField ℚ (SeparableClosure ℚ) L.field ++local notation "N" => smallHilbertClassFieldNormAmbient E + + end RationalFixedField + +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationBase.lean +new file mode 100644 +index 0000000..31a4787 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationBase.lean +@@ -0,0 +1,278 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.HilbertClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerConjugation ++import Mathlib.Data.Rat.Cast.Defs ++ ++ ++set_option autoImplicit false ++ ++/-! ++# Actual realization of the two-stage small Hilbert tower ++ ++The first small Hilbert class field is the actual finite abelian ++subextension selected in `HilbertClassFieldRealization`. Over its actual ++fixed field, the closed finite-index small-Hilbert norm subgroup has a ++finite Galois norm neighbourhood. We embed that neighbourhood in the ++rational separable closure compatibly with the already chosen first ++stage. Finite abelian classification then selects the second small ++Hilbert class field over the literal first-stage subgroup. ++ ++The compatibility of the embedding is essential: an unrelated chosen ++copy of the middle number field would produce a class field over a ++conjugate closed subgroup rather than over the first-stage subgroup ++itself. ++-/ ++ ++open scoped Classical NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace IdealClassFieldTheory ++ ++open AlgebraicNumberTheory ++open ClassFormation ++open CyclicCohomology ++open GlobalClassFields ++open KummerTheory ++open LocalClassFieldTheory ++open RamificationTheory ++open Reciprocity ++ ++/-- The ordinary idèle-class operations used by the two-stage transport, ++fixed at the canonical principal-subgroup quotient. -/ ++@[instance_reducible] ++noncomputable def smallHilbertTowerIdeleClassCommGroup ++ (F : Type) [Field F] [NumberField F] : ++ CommGroup (IdeleClassGroup F) := ++ QuotientGroup.Quotient.commGroup (IdeleGroup.principalSubgroup F) ++ ++attribute [local instance] smallHilbertTowerIdeleClassCommGroup ++ ++private theorem addSubgroup_comap_symm_eq_map ++ {A B : Type*} [AddGroup A] [AddGroup B] ++ (H : AddSubgroup A) (e : A ≃+ B) : ++ H.comap e.symm.toAddMonoidHom = ++ H.map e.toAddMonoidHom := by ++ exact (AddSubgroup.map_equiv_eq_comap_symm e H).symm ++ ++private noncomputable abbrev ++ closedFiniteIndexNormAmbientCanonicalBaseAlgebra ++ (F : Type) [Field F] [NumberField F] ++ (H : Subgroup (IdeleClassGroup F)) ++ (hclosed : IsClosed (H : Set (IdeleClassGroup F))) ++ [H.FiniteIndex] : ++ Algebra F ++ (closedFiniteIndexClassFieldNormAmbient ++ (K := F) H hclosed) := ++ inferInstance ++ ++section RationalFixedField ++ ++variable ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (L : FiniteAbelianSubextension K.field) ++ ++/-- The finite abstract field attached to the intermediate field of the ++finite abelian extension, with finiteness obtained by transitivity. -/ ++noncomputable abbrev smallHilbertTowerMiddleFiniteAbstractField : ++ FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ { field := L.field ++ finite := by ++ let : Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ K.field (le_baseField K.field)) := ++ K.finite ++ let : Finite ++ (K.field.toSubgroup ⧸ ++ extensionSubgroup K.field L.field L.below) := ++ L.finite ++ exact ++ FiniteGaloisSubextension.finite_extension_trans ++ L.below (le_baseField K.field) } ++ ++local notation "E" => ++ abstractFixedField ℚ (SeparableClosure ℚ) L.field ++ ++local notation "N" => ++ smallHilbertClassFieldNormAmbient E ++ ++noncomputable instance ++ smallHilbertTowerMiddleAbstractQuotientFinite : ++ Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ L.field (le_baseField L.field)) := ++ (smallHilbertTowerMiddleFiniteAbstractField K L).finite ++ ++private noncomputable instance ++ smallHilbertTowerMiddleFiniteDimensional : ++ FiniteDimensional ℚ E := ++ abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) L.field inferInstance ++ ++private noncomputable instance ++ smallHilbertTowerMiddleNumberField : ++ NumberField E := ++ NumberField.of_module_finite ℚ E ++ ++ ++/-- The small Hilbert norm subgroup of the intermediate number field, ++transported to its ambient fixed idele-class representation. -/ ++noncomputable def smallHilbertTowerMiddleNormSubgroup : ++ AddSubgroup ++ (ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation L.field) := ++ (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup.comap ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom ++ ++/-- The typed `comap` endpoint is the canonical transported `map` endpoint. ++This uses only the generic additive equivalence law. -/ ++theorem smallHilbertTowerMiddleNormSubgroup_eq_map : ++ smallHilbertTowerMiddleNormSubgroup K L = ++ (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup.map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).toAddMonoidHom := by ++ exact addSubgroup_comap_symm_eq_map ++ (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup ++ (rationalAbstractFixedFieldIdeleClassEquivFixed L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)) ++ ++/-- The algebra structure of the intermediate field on its small Hilbert ++class-field norm ambient. -/ ++@[reducible] ++noncomputable def ++ smallHilbertTowerNormAmbientAlgebra : ++ Algebra E N := ++ closedFiniteIndexNormAmbientCanonicalBaseAlgebra E ++ (smallHilbertClassFieldNormSubgroup (K := E)) ++ (smallHilbertClassFieldNormSubgroup_isClosed (K := E)) ++ ++attribute [local instance] smallHilbertTowerNormAmbientAlgebra ++ ++/-- Scalar multiplication of the intermediate field on its small Hilbert ++class-field norm ambient. -/ ++@[reducible] ++noncomputable def ++ smallHilbertTowerNormAmbientSMul : ++ SMul E N := ++ Algebra.toSMul ++ (self := smallHilbertTowerNormAmbientAlgebra K L) ++ ++@[reducible] ++private noncomputable def ++ smallHilbertTowerNormAmbientModule : ++ Module E N := ++ @Algebra.toModule E N _ _ ++ (smallHilbertTowerNormAmbientAlgebra K L) ++ ++theorem ++ smallHilbertTowerNormAmbientScalarTower : ++ @IsScalarTower ℚ E N ++ (Algebra.toSMul (R := ℚ) (A := E)) ++ (smallHilbertTowerNormAmbientSMul K L) ++ (Algebra.toSMul (R := ℚ) (A := N)) := by ++ exact IsScalarTower.of_algebraMap_eq' ++ (R := ℚ) (S := E) (A := N) ++ (RingHom.ext_rat (algebraMap ℚ N) ++ ((algebraMap E N).comp (algebraMap ℚ E))) ++ ++/-- The rational algebra embedding of the intermediate field into its ++small Hilbert class-field norm ambient. -/ ++noncomputable def ++ smallHilbertTowerNormAmbientAlgHom : ++ E →ₐ[ℚ] N := ++ { toRingHom := algebraMap E N ++ commutes' := fun r => ++ (RingHom.congr_fun ++ (RingHom.ext_rat ++ ((algebraMap E N).comp (algebraMap ℚ E)) ++ (algebraMap ℚ N)) r) } ++ ++theorem smallHilbertTowerNormAmbientAlgHom_apply ++ (x : E) : ++ smallHilbertTowerNormAmbientAlgHom K L x = ++ algebraMap E N x := by ++ rfl ++ ++theorem ++ smallHilbertTowerNormAmbientIsGalois : ++ IsGalois E N := by ++ unfold smallHilbertClassFieldNormAmbient ++ closedFiniteIndexClassFieldNormAmbient ++ exact ++ closedFiniteIndexNormAmbientIsGalois ++ (smallHilbertClassFieldNormSubgroup (K := E)) ++ (smallHilbertClassFieldNormSubgroup_isClosed (K := E)) ++ ++attribute [local instance] smallHilbertTowerNormAmbientIsGalois ++ ++/-- The separable-closure automorphism extending the induced embedding ++of the intermediate field into the norm-neighborhood field. -/ ++noncomputable def ++ smallHilbertNormNeighborhoodForwardAlignment : ++ SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := by ++ let j₀ : N →ₐ[ℚ] SeparableClosure ℚ := ++ numberFieldSeparableClosureEmbedding N ++ let i₀ : E →ₐ[ℚ] SeparableClosure ℚ := ++ j₀.comp (smallHilbertTowerNormAmbientAlgHom K L) ++ exact ++ AlgEquiv.ofBijective ++ (i₀.liftNormal (SeparableClosure ℚ)) ++ (AlgHom.normal_bijective ++ ℚ (SeparableClosure ℚ) (SeparableClosure ℚ) _) ++ ++/-- The separable-closure automorphism which aligns an arbitrary chosen ++embedding of the norm-neighbourhood field with the already embedded ++middle field. -/ ++noncomputable def ++ smallHilbertNormNeighborhoodAlignment : ++ SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := ++ (smallHilbertNormNeighborhoodForwardAlignment K L).symm ++ ++@[simp] ++theorem smallHilbertNormNeighborhoodForwardAlignment_apply ++ (x : E) : ++ smallHilbertNormNeighborhoodForwardAlignment K L ++ (x : SeparableClosure ℚ) = ++ (numberFieldSeparableClosureEmbedding N) ++ (algebraMap E N x) := by ++ let j₀ : N →ₐ[ℚ] SeparableClosure ℚ := ++ numberFieldSeparableClosureEmbedding N ++ let i₀ : E →ₐ[ℚ] SeparableClosure ℚ := ++ j₀.comp (smallHilbertTowerNormAmbientAlgHom K L) ++ dsimp only [smallHilbertNormNeighborhoodForwardAlignment, ++ AlgEquiv.ofBijective_apply] ++ calc ++ _ = i₀ x := by ++ simpa only [IntermediateField.algebraMap_apply, ++ Algebra.algebraMap_self, RingHom.id_apply] using ++ i₀.liftNormal_commutes (SeparableClosure ℚ) x ++ _ = j₀ (algebraMap E N x) := by ++ change ++ j₀ (smallHilbertTowerNormAmbientAlgHom K L x) = ++ j₀ (algebraMap E N x) ++ exact congrArg j₀ ++ (smallHilbertTowerNormAmbientAlgHom_apply K L x) ++ ++ ++end RationalFixedField ++end IdealClassFieldTheory ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationEmbedding.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationEmbedding.lean +new file mode 100644 +index 0000000..b76d2bd +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationEmbedding.lean +@@ -0,0 +1,190 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerRealizationBase ++ ++set_option autoImplicit false ++ ++open scoped Classical NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace IdealClassFieldTheory ++ ++open AlgebraicNumberTheory ++open ClassFormation ++open CyclicCohomology ++open GlobalClassFields ++open KummerTheory ++open LocalClassFieldTheory ++open RamificationTheory ++open Reciprocity ++ ++ ++attribute [local instance] smallHilbertTowerIdeleClassCommGroup ++ smallHilbertTowerNormAmbientAlgebra ++ smallHilbertTowerNormAmbientIsGalois ++ ++section RationalFixedField ++ ++variable ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (L : FiniteAbelianSubextension K.field) ++ ++ ++local notation "E" => abstractFixedField ℚ (SeparableClosure ℚ) L.field ++local notation "N" => smallHilbertClassFieldNormAmbient E ++ ++/-- A controlled embedding of the concrete finite Galois norm ++neighbourhood. Its restriction to the middle field is the literal ++inclusion of that fixed field in `SeparableClosure ℚ`. -/ ++noncomputable def ++ smallHilbertNormNeighborhoodEmbedding : ++ N →ₐ[ℚ] SeparableClosure ℚ := ++ (smallHilbertNormNeighborhoodAlignment K L).toAlgHom.comp ++ (numberFieldSeparableClosureEmbedding N) ++ ++@[simp] ++theorem smallHilbertNormNeighborhoodEmbedding_algebraMap ++ (x : E) : ++ smallHilbertNormNeighborhoodEmbedding K L ++ (algebraMap E N x) = ++ (x : SeparableClosure ℚ) := by ++ change ++ (smallHilbertNormNeighborhoodForwardAlignment K L).symm ++ ((numberFieldSeparableClosureEmbedding N) ++ (algebraMap E N x)) = ++ (x : SeparableClosure ℚ) ++ rw [← smallHilbertNormNeighborhoodForwardAlignment_apply K L x] ++ exact ++ (smallHilbertNormNeighborhoodForwardAlignment K L).symm_apply_apply _ ++ ++private abbrev smallHilbertNormNeighborhoodEmbeddedBase : ++ ClosedSubgroup ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange ++ ((smallHilbertNormNeighborhoodEmbedding K L).comp ++ (smallHilbertTowerNormAmbientAlgHom K L))) ++ ++private abbrev smallHilbertNormNeighborhoodEmbeddedField : ++ ClosedSubgroup ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange ++ (smallHilbertNormNeighborhoodEmbedding K L)) ++ ++private theorem smallHilbertNormNeighborhoodEmbeddedField_le_base : ++ (smallHilbertNormNeighborhoodEmbeddedField K L).toSubgroup ≤ ++ (smallHilbertNormNeighborhoodEmbeddedBase K L).toSubgroup := by ++ change ++ (AlgHom.fieldRange ++ (smallHilbertNormNeighborhoodEmbedding K L)).fixingSubgroup ≤ ++ (AlgHom.fieldRange ++ ((smallHilbertNormNeighborhoodEmbedding K L).comp ++ (smallHilbertTowerNormAmbientAlgHom K L))).fixingSubgroup ++ apply ++ (AlgHom.fieldRange ++ ((smallHilbertNormNeighborhoodEmbedding K L).comp ++ (smallHilbertTowerNormAmbientAlgHom K L))).fixingSubgroup_le ++ exact ++ AlgHom.range_comp_le_range ++ (smallHilbertTowerNormAmbientAlgHom K L) ++ (smallHilbertNormNeighborhoodEmbedding K L) ++ ++theorem smallHilbertNormNeighborhoodEmbeddedBase_eq : ++ smallHilbertNormNeighborhoodEmbeddedBase K L = L.field := by ++ have hi : ++ (smallHilbertNormNeighborhoodEmbedding K L).comp ++ (smallHilbertTowerNormAmbientAlgHom K L) = ++ (abstractFixedField ℚ (SeparableClosure ℚ) L.field).val := by ++ apply AlgHom.ext ++ intro x ++ change smallHilbertNormNeighborhoodEmbedding K L ++ (smallHilbertTowerNormAmbientAlgHom K L x) = (x : SeparableClosure ℚ) ++ rw [smallHilbertTowerNormAmbientAlgHom_apply K L x] ++ exact smallHilbertNormNeighborhoodEmbedding_algebraMap K L x ++ change ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange ++ ((smallHilbertNormNeighborhoodEmbedding K L).comp ++ (smallHilbertTowerNormAmbientAlgHom K L))) = ++ L.field ++ rw [hi, IntermediateField.fieldRange_val] ++ exact ++ closedFixingSubgroup_abstractFixedField_eq ++ ℚ (SeparableClosure ℚ) L.field ++ ++private noncomputable def ++ smallHilbertNormNeighborhoodSeparableClosureEquiv : ++ let j := smallHilbertNormNeighborhoodEmbedding K L ++ let i := j.comp (smallHilbertTowerNormAmbientAlgHom K L) ++ let : Algebra E (SeparableClosure ℚ) := ++ i.toRingHom.toAlgebra ++ SeparableClosure E ≃ₐ[E] SeparableClosure ℚ := by ++ intro j i alg ++ let : @IsScalarTower ℚ E (SeparableClosure ℚ) ++ (Algebra.toSMul (R := ℚ) (A := E)) ++ alg.toSMul ++ (Algebra.toSMul (R := ℚ) (A := SeparableClosure ℚ)) := ++ IsScalarTower.of_algebraMap_eq' i.comp_algebraMap.symm ++ let : IsSepClosure E (SeparableClosure ℚ) := ++ ⟨IsSepClosure.sep_closed ℚ, ++ Algebra.isSeparable_tower_top_of_isSeparable ++ ℚ E (SeparableClosure ℚ)⟩ ++ exact ++ IsSepClosure.equiv E ++ (SeparableClosure E) (SeparableClosure ℚ) ++ ++/-- The finite Galois extension given by the embedded small Hilbert ++norm-neighborhood field over the embedded intermediate field. -/ ++noncomputable def ++ smallHilbertFiniteGaloisNormNeighborhoodRaw : ++ FiniteGaloisSubextension ++ (smallHilbertNormNeighborhoodEmbeddedBase K L) := by ++ let : @IsScalarTower ℚ E N ++ (Algebra.toSMul (R := ℚ) (A := E)) ++ (smallHilbertTowerNormAmbientSMul K L) ++ (Algebra.toSMul (R := ℚ) (A := N)) := ++ smallHilbertTowerNormAmbientScalarTower K L ++ let j : N →ₐ[ℚ] SeparableClosure ℚ := ++ smallHilbertNormNeighborhoodEmbedding K L ++ let i : E →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ E N) ++ let B : ClosedSubgroup (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) i.fieldRange ++ let T : ClosedSubgroup (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ smallHilbertNormNeighborhoodEmbeddedField K L ++ have hTB : T.toSubgroup ≤ B.toSubgroup := by ++ change j.fieldRange.fixingSubgroup ≤ i.fieldRange.fixingSubgroup ++ apply i.fieldRange.fixingSubgroup_le ++ exact AlgHom.range_comp_le_range (IsScalarTower.toAlgHom ℚ E N) j ++ let raw : FiniteGaloisSubextension B := { ++ field := T ++ below := hTB ++ normal := ambientEmbeddedExtensionSubgroup_normal ℚ E N j ++ (smallHilbertNormNeighborhoodSeparableClosureEquiv K L) ++ finite := ambientEmbeddedExtensionQuotient_finite ℚ E N j ++ (smallHilbertNormNeighborhoodSeparableClosureEquiv K L) } ++ have hi : IsScalarTower.toAlgHom ℚ E N = ++ smallHilbertTowerNormAmbientAlgHom K L := by ++ apply AlgHom.ext ++ intro x ++ exact (IsScalarTower.toAlgHom_apply ℚ E N x).trans ++ (smallHilbertTowerNormAmbientAlgHom_apply K L x).symm ++ have hB : B = smallHilbertNormNeighborhoodEmbeddedBase K L := ++ congrArg ++ (fun f : E →ₐ[ℚ] N => ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) (j.comp f).fieldRange) hi ++ exact hB ▸ raw ++ ++ ++end RationalFixedField ++end IdealClassFieldTheory ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationNorm.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationNorm.lean +new file mode 100644 +index 0000000..7c2a69a +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationNorm.lean +@@ -0,0 +1,272 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerRealizationEmbedding ++ ++set_option autoImplicit false ++ ++open scoped Classical NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace IdealClassFieldTheory ++ ++open AlgebraicNumberTheory ++open ClassFormation ++open CyclicCohomology ++open GlobalClassFields ++open KummerTheory ++open LocalClassFieldTheory ++open RamificationTheory ++open Reciprocity ++ ++ ++attribute [local instance] smallHilbertTowerIdeleClassCommGroup ++ smallHilbertTowerNormAmbientAlgebra ++ smallHilbertTowerNormAmbientIsGalois ++ ++section RationalFixedField ++ ++variable ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (L : FiniteAbelianSubextension K.field) ++ ++ ++local notation "E" => abstractFixedField ℚ (SeparableClosure ℚ) L.field ++local notation "N" => smallHilbertClassFieldNormAmbient E ++ ++private noncomputable def rebaseFiniteGaloisSubextension ++ {G : Type} [Group G] [TopologicalSpace G] ++ {B B' : ClosedSubgroup G} (h : B = B') ++ (P : FiniteGaloisSubextension B) : ++ FiniteGaloisSubextension B' := ++ h ▸ P ++ ++@[simp] ++private theorem rebaseFiniteGaloisSubextension_field ++ {G : Type} [Group G] [TopologicalSpace G] ++ {B B' : ClosedSubgroup G} (h : B = B') ++ (P : FiniteGaloisSubextension B) : ++ (rebaseFiniteGaloisSubextension h P).field = P.field := by ++ cases h ++ rfl ++ ++private theorem ++ rebaseRationalFiniteGaloisSubextension_fixedField_eq ++ {B B' : ClosedSubgroup ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} ++ (h : B = B') (P : FiniteGaloisSubextension B) : ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (rebaseFiniteGaloisSubextension h P).below).restrictScalars ℚ = ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ P.below).restrictScalars ℚ := by ++ cases h ++ rfl ++ ++/-- An actual finite Galois norm neighbourhood over the literal ++first-stage subgroup. It is produced by the finite-index Kummer ++construction and the controlled embedding above. -/ ++noncomputable def smallHilbertFiniteGaloisNormNeighborhood : ++ FiniteGaloisSubextension L.field := ++ rebaseFiniteGaloisSubextension ++ (smallHilbertNormNeighborhoodEmbeddedBase_eq K L) ++ (smallHilbertFiniteGaloisNormNeighborhoodRaw K L) ++ ++ ++/-- The norm subgroup of the small Hilbert norm-neighborhood extension ++in the ambient fixed idele-class representation. -/ ++noncomputable def smallHilbertFiniteGaloisNormNeighborhoodNormSubgroup : ++ AddSubgroup ++ (ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation L.field) := ++ (smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup ++ rationalIdeleClassRepresentation ++ ++/-- The relative fixed field realizing the top field of the small ++Hilbert norm-neighborhood extension. -/ ++noncomputable abbrev ++ smallHilbertFiniteGaloisNormNeighborhoodTopField : Type := ++ abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below ++ ++local notation "E₂" => ++ smallHilbertFiniteGaloisNormNeighborhoodTopField K L ++ ++private noncomputable instance ++ smallHilbertFiniteGaloisNormNeighborhoodQuotientFinite : ++ Finite ++ (L.field.toSubgroup ⧸ ++ extensionSubgroup L.field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below) := ++ (smallHilbertFiniteGaloisNormNeighborhood K L).finite ++ ++private noncomputable instance ++ smallHilbertFiniteGaloisNormNeighborhoodFiniteDimensional : ++ FiniteDimensional E E₂ := ++ abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) L.field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below ++ inferInstance inferInstance ++ ++private noncomputable instance ++ smallHilbertFiniteGaloisNormNeighborhoodScalarTower : ++ IsScalarTower ℚ E E₂ := ++ IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) ++ ++private noncomputable instance ++ smallHilbertFiniteGaloisNormNeighborhoodAbsoluteFiniteDimensional : ++ FiniteDimensional ℚ E₂ := ++ FiniteDimensional.trans ℚ E E₂ ++ ++private noncomputable instance ++ smallHilbertFiniteGaloisNormNeighborhoodNumberField : ++ NumberField E₂ := ++ NumberField.of_module_finite ℚ E₂ ++ ++private noncomputable instance ++ smallHilbertFiniteGaloisNormNeighborhoodIsGalois : ++ IsGalois E E₂ := ++ abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) L.field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below ++ (smallHilbertFiniteGaloisNormNeighborhood K L).normal ++ ++private theorem ++ smallHilbertFiniteGaloisNormNeighborhood_fixedField_eq_range : ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below).restrictScalars ℚ = ++ AlgHom.fieldRange ++ (smallHilbertNormNeighborhoodEmbedding K L) := by ++ rw [show ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below).restrictScalars ℚ = ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (smallHilbertFiniteGaloisNormNeighborhoodRaw K L).below).restrictScalars ℚ ++ from ++ rebaseRationalFiniteGaloisSubextension_fixedField_eq ++ (smallHilbertNormNeighborhoodEmbeddedBase_eq K L) ++ (smallHilbertFiniteGaloisNormNeighborhoodRaw K L)] ++ exact ++ InfiniteGalois.fixedField_fixingSubgroup ++ (AlgHom.fieldRange ++ (smallHilbertNormNeighborhoodEmbedding K L)) ++ ++private noncomputable def ++ smallHilbertFiniteGaloisNormNeighborhoodTopEquiv : ++ N ≃ₐ[ℚ] ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below).restrictScalars ℚ := ++ (smallHilbertNormNeighborhoodEmbedding K L).equivFieldRange.trans ++ (IntermediateField.equivOfEq ++ (smallHilbertFiniteGaloisNormNeighborhood_fixedField_eq_range ++ K L).symm) ++ ++@[simp] ++private theorem ++ smallHilbertFiniteGaloisNormNeighborhoodTopEquiv_algebraMap ++ (x : E) : ++ smallHilbertFiniteGaloisNormNeighborhoodTopEquiv K L ++ (algebraMap E N x) = ++ algebraMap E ++ E₂ x := by ++ apply Subtype.ext ++ change ++ smallHilbertNormNeighborhoodEmbedding K L ++ (algebraMap E N x) = ++ (x : SeparableClosure ℚ) ++ exact smallHilbertNormNeighborhoodEmbedding_algebraMap K L x ++ ++private noncomputable def ++ smallHilbertFiniteGaloisNormNeighborhoodRelativeTopEquiv : ++ N ≃ₐ[E] E₂ := { ++ smallHilbertFiniteGaloisNormNeighborhoodTopEquiv K L with ++ commutes' := fun x => ++ smallHilbertFiniteGaloisNormNeighborhoodTopEquiv_algebraMap ++ K L x } ++ ++theorem ++ smallHilbertFiniteGaloisNormNeighborhood_ordinaryNorm_le : ++ (_root_.ideleClassNorm E N).range ≤ ++ smallHilbertClassFieldNormSubgroup (K := E) := by ++ simpa only [smallHilbertClassFieldNormAmbient] using ++ (closedFiniteIndexClassFieldNormAmbient_normRange_le ++ (K := E) (smallHilbertClassFieldNormSubgroup (K := E)) ++ (smallHilbertClassFieldNormSubgroup_isClosed (K := E))) ++ ++private theorem ++ smallHilbertFiniteGaloisNormNeighborhood_ordinaryNormRange_eq : ++ (_root_.ideleClassNorm E N).range = ++ (_root_.ideleClassNorm E E₂).range := by ++ simpa only [ordinaryIdeleClassNorm_range_eq_relative] using ++ (ideleClassNorm_range_algEquiv ++ (K := E) ++ (smallHilbertFiniteGaloisNormNeighborhoodRelativeTopEquiv ++ K L)).symm ++ ++private theorem ++ smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq : ++ ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup ++ rationalIdeleClassRepresentation).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = ++ (_root_.ideleClassNorm E E₂).range.toAddSubgroup := by ++ change ++ (finiteNormSubgroup rationalIdeleClassRepresentation ++ L.field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = ++ (_root_.ideleClassNorm E E₂).range.toAddSubgroup ++ exact ++ (map_rationalFiniteNormSubgroup_eq_ordinaryIdeleClassNormRange_concrete ++ L.field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).field ++ (smallHilbertFiniteGaloisNormNeighborhood K L).below ++ (smallHilbertFiniteGaloisNormNeighborhood K L).normal) ++ ++/-- The abstract norm map lands directly in the ordinary norm range of the ++chosen neighbourhood. Composing the two named subgroup equalities here ++keeps downstream membership proofs pointwise. -/ ++private theorem ++ smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq_ordinaryNormRange : ++ ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup ++ rationalIdeleClassRepresentation).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = ++ (_root_.ideleClassNorm E N).range.toAddSubgroup := ++ (smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq K L).trans ++ (congrArg Subgroup.toAddSubgroup ++ (smallHilbertFiniteGaloisNormNeighborhood_ordinaryNormRange_eq K L).symm) ++ ++/-- Pointwise form of the combined norm-range equality. -/ ++theorem ++ smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_mem_ordinaryNormRange ++ (a : Additive (IdeleClassGroup E)) ++ (ha : ++ a ∈ ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup ++ rationalIdeleClassRepresentation).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom) : ++ a ∈ (_root_.ideleClassNorm E N).range.toAddSubgroup := ++ (le_of_eq ++ (smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_eq_ordinaryNormRange ++ K L)) ha ++ ++ ++end RationalFixedField ++end IdealClassFieldTheory ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationSecond.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationSecond.lean +new file mode 100644 +index 0000000..768d9b0 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/IdealClassFieldTheory/SmallHilbertTowerRealizationSecond.lean +@@ -0,0 +1,256 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.IdealClassFieldTheory.SmallHilbertTowerRealizationNorm ++ ++set_option autoImplicit false ++ ++open scoped Classical NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace IdealClassFieldTheory ++ ++open AlgebraicNumberTheory ++open ClassFormation ++open CyclicCohomology ++open GlobalClassFields ++open KummerTheory ++open LocalClassFieldTheory ++open RamificationTheory ++open Reciprocity ++ ++ ++attribute [local instance] smallHilbertTowerIdeleClassCommGroup ++ smallHilbertTowerNormAmbientAlgebra ++ smallHilbertTowerNormAmbientIsGalois ++ ++section RationalFixedField ++ ++variable ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (L : FiniteAbelianSubextension K.field) ++ ++ ++local notation "E" => abstractFixedField ℚ (SeparableClosure ℚ) L.field ++local notation "N" => smallHilbertClassFieldNormAmbient E ++ ++local notation "E₂" => smallHilbertFiniteGaloisNormNeighborhoodTopField K L ++ ++/-- The actual finite Galois norm neighbourhood has abstract norm ++subgroup contained in the canonical small-Hilbert subgroup of the ++middle fixed field. This is the source-producing norm-topology input; ++no norm-openness premise is assumed. -/ ++theorem smallHilbertFiniteGaloisNormNeighborhood_normSubgroup_le : ++ ∀ a : ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation L.field, ++ a ∈ smallHilbertFiniteGaloisNormNeighborhoodNormSubgroup K L → ++ a ∈ smallHilbertTowerMiddleNormSubgroup K L := by ++ intro a ha ++ change ++ a ∈ (smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup ++ rationalIdeleClassRepresentation at ha ++ have haMap : ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm a ∈ ++ ((smallHilbertFiniteGaloisNormNeighborhood K L).normSubgroup ++ rationalIdeleClassRepresentation).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom := ++ ⟨a, ha, rfl⟩ ++ have haOrdinary : ++ (rationalAbstractFixedFieldIdeleClassEquivFixed L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm a ∈ ++ (_root_.ideleClassNorm E N).range.toAddSubgroup := ++ smallHilbertFiniteGaloisNormNeighborhood_abstractNormMap_mem_ordinaryNormRange ++ K L _ haMap ++ exact smallHilbertFiniteGaloisNormNeighborhood_ordinaryNorm_le K L haOrdinary ++ ++/-- The canonical small-Hilbert subgroup of the actual middle fixed ++field is open in the genuine norm topology. -/ ++theorem smallHilbertNormSubgroupInRationalClassFormation_isNormOpen : ++ IsNormOpen rationalIdeleClassRepresentation L.field ++ (smallHilbertTowerMiddleNormSubgroup K L : ++ Set ++ (ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation L.field)) := by ++ rw [normTopology_addSubgroup_isOpen_iff] ++ refine ++ ⟨smallHilbertFiniteGaloisNormNeighborhood K L, ?_⟩ ++ change ++ smallHilbertFiniteGaloisNormNeighborhoodNormSubgroup K L ≤ ++ smallHilbertTowerMiddleNormSubgroup K L ++ exact smallHilbertFiniteGaloisNormNeighborhood_normSubgroup_le K L ++ ++/-- The second small Hilbert class field as an actual finite abelian ++subextension of the literal first-stage field. -/ ++noncomputable def secondSmallHilbertClassFieldSubextension : ++ FiniteAbelianSubextension L.field := by ++ let H : FiniteAbelianSubextension.NormOpenAddSubgroup ++ rationalIdeleClassRepresentation L.field := ++ ⟨smallHilbertTowerMiddleNormSubgroup K L, ++ smallHilbertNormSubgroupInRationalClassFormation_isNormOpen K L⟩ ++ exact ++ Classical.choose ++ (FiniteAbelianSubextension.normSubgroupMap_surjective ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (smallHilbertTowerMiddleFiniteAbstractField K L) H) ++ ++/-- The second-stage extension realizes exactly the canonical ++small-Hilbert norm subgroup of the actual middle field. -/ ++@[simp] ++theorem secondSmallHilbertClassFieldSubextension_normSubgroup : ++ (secondSmallHilbertClassFieldSubextension K L).normSubgroup ++ rationalIdeleClassRepresentation = ++ smallHilbertTowerMiddleNormSubgroup K L := by ++ let H : FiniteAbelianSubextension.NormOpenAddSubgroup ++ rationalIdeleClassRepresentation L.field := ++ ⟨smallHilbertTowerMiddleNormSubgroup K L, ++ smallHilbertNormSubgroupInRationalClassFormation_isNormOpen K L⟩ ++ have h := ++ Classical.choose_spec ++ (FiniteAbelianSubextension.normSubgroupMap_surjective ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (smallHilbertTowerMiddleFiniteAbstractField K L) H) ++ exact congrArg Subtype.val h ++ ++private noncomputable abbrev secondSmallHilbertClassFieldTopField : Type := ++ abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (secondSmallHilbertClassFieldSubextension K L).below ++ ++local notation "T₂" => secondSmallHilbertClassFieldTopField K L ++ ++private noncomputable instance ++ secondSmallHilbertClassFieldSubextensionQuotientFinite : ++ Finite ++ (L.field.toSubgroup ⧸ ++ extensionSubgroup L.field ++ (secondSmallHilbertClassFieldSubextension K L).field ++ (secondSmallHilbertClassFieldSubextension K L).below) := ++ (secondSmallHilbertClassFieldSubextension K L).finite ++ ++private noncomputable instance ++ secondSmallHilbertClassFieldTopFiniteDimensional : ++ FiniteDimensional E T₂ := ++ abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) L.field ++ (secondSmallHilbertClassFieldSubextension K L).field ++ (secondSmallHilbertClassFieldSubextension K L).below ++ inferInstance inferInstance ++ ++private noncomputable instance ++ secondSmallHilbertClassFieldTopScalarTower : ++ IsScalarTower ℚ E T₂ := ++ IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) ++ ++private noncomputable instance ++ secondSmallHilbertClassFieldTopAbsoluteFiniteDimensional : ++ FiniteDimensional ℚ T₂ := ++ FiniteDimensional.trans ℚ E T₂ ++ ++private noncomputable instance ++ secondSmallHilbertClassFieldTopNumberField : ++ NumberField T₂ := ++ NumberField.of_module_finite ℚ T₂ ++ ++private noncomputable instance ++ secondSmallHilbertClassFieldTopIsGalois : ++ IsGalois E T₂ := ++ abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) L.field ++ (secondSmallHilbertClassFieldSubextension K L).field ++ (secondSmallHilbertClassFieldSubextension K L).below ++ (secondSmallHilbertClassFieldSubextension K L).normal ++ ++private theorem ++ secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_actualNormRange : ++ ((secondSmallHilbertClassFieldSubextension K L).normSubgroup ++ rationalIdeleClassRepresentation).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = ++ (_root_.ideleClassNorm E T₂).range.toAddSubgroup := by ++ change ++ (finiteNormSubgroup rationalIdeleClassRepresentation ++ L.field ++ (secondSmallHilbertClassFieldSubextension K L).field ++ (secondSmallHilbertClassFieldSubextension K L).below).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = ++ (_root_.ideleClassNorm E T₂).range.toAddSubgroup ++ exact ++ map_rationalFiniteNormSubgroup_eq_ordinaryIdeleClassNormRange_concrete ++ L.field ++ (secondSmallHilbertClassFieldSubextension K L).field ++ (secondSmallHilbertClassFieldSubextension K L).below ++ (secondSmallHilbertClassFieldSubextension K L).normal ++ ++private theorem ++ secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_smallHilbertNormSubgroup : ++ ((secondSmallHilbertClassFieldSubextension K L).normSubgroup ++ rationalIdeleClassRepresentation).map ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L)).symm.toAddMonoidHom = ++ (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup := by ++ let e : Additive (IdeleClassGroup E) ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation L.field := ++ rationalAbstractFixedFieldIdeleClassEquivFixed L.field ++ (hfinite := smallHilbertTowerMiddleAbstractQuotientFinite K L) ++ let H : AddSubgroup (Additive (IdeleClassGroup E)) := ++ (smallHilbertClassFieldNormSubgroup (K := E)).toAddSubgroup ++ let back : AddSubgroup ++ (ambientFixedAddSubgroup rationalIdeleClassRepresentation L.field) → ++ AddSubgroup (Additive (IdeleClassGroup E)) := ++ fun n => n.map e.symm.toAddMonoidHom ++ have hNorm : ++ back ((secondSmallHilbertClassFieldSubextension K L).normSubgroup ++ rationalIdeleClassRepresentation) = ++ back (smallHilbertTowerMiddleNormSubgroup K L) := ++ congrArg back (secondSmallHilbertClassFieldSubextension_normSubgroup K L) ++ have hCancel : back (smallHilbertTowerMiddleNormSubgroup K L) = H := ++ AddSubgroup.map_comap_eq_self_of_surjective e.symm.surjective H ++ exact hNorm.trans hCancel ++ ++/-- The actual second small Hilbert class field has exactly the intrinsic ++small-Hilbert norm range over the literal middle fixed field. -/ ++@[simp] ++theorem secondSmallHilbertClassFieldSubextension_ideleClassNorm_range : ++ (_root_.ideleClassNorm E T₂).range = ++ smallHilbertClassFieldNormSubgroup (K := E) := by ++ apply Subgroup.toAddSubgroup.injective ++ exact ++ (secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_actualNormRange ++ K L).symm.trans ++ (secondSmallHilbertClassFieldSubextension_abstractNormMap_eq_smallHilbertNormSubgroup ++ K L) ++ ++/-- Compatibility of the typed middle endpoint with the canonical endpoint ++used by the conjugation API. -/ ++theorem smallHilbertTowerMiddleNormSubgroup_eq_conjugationEndpoint : ++ smallHilbertTowerMiddleNormSubgroup K L = ++ smallHilbertNormSubgroupInRationalClassFormation ++ (L.toFiniteGaloisExtension.toFiniteAbstractFieldExtension).field := by ++ have hField : ++ (L.toFiniteGaloisExtension.toFiniteAbstractFieldExtension).field.field = ++ L.field := by ++ rfl ++ unfold smallHilbertNormSubgroupInRationalClassFormation ++ cases hField ++ exact smallHilbertTowerMiddleNormSubgroup_eq_map K L ++ ++ ++end RationalFixedField ++end IdealClassFieldTheory ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidue.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidue.lean +index 8984e0a..3f1f8ad 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidue.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidue.lean +@@ -4,24 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidue ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.AbstractFixedFieldGlobalNormResidueFixedFields + +-set_option autoImplicit false +- +-/-! +-# Global norm residue on actual fixed fields + +-An abstract finite abelian subextension of the rational absolute Galois +-group determines an actual finite abelian extension between its two +-fixed number fields. This file transports the abstract norm-residue +-symbol directly to the ordinary idele-class norm quotient of those +-fixed fields. ++set_option autoImplicit false + +-Keeping this construction in one ambient separable closure is essential +-for the norm--restriction diagrams: no independently chosen embedding of +-either field is introduced. +--/ + + open scoped IsMulCommutative NumberField + open NumberField +@@ -38,1460 +25,26 @@ open AlgebraicNumberTheory + open LocalClassFieldTheory + open RamificationTheory + +-/-- The algebra structure on the rational separable closure induced by a +-specified rational field embedding. It is deliberately not an instance: +-different embeddings of the same field need not induce definitionally equal +-algebra structures. -/ +-@[reducible] +-noncomputable def rationalEmbeddingSeparableClosureAlgebra +- {F : Type} [Field F] [Algebra ℚ F] +- (i : F →ₐ[ℚ] SeparableClosure ℚ) : +- Algebra F (SeparableClosure ℚ) := +- i.toRingHom.toAlgebra +- +-/-- Two rational embeddings of the same number field into the fixed +-rational separable closure differ by an automorphism of that +-separable closure. -/ +-theorem exists_numberFieldEmbeddingComparisonAutomorphism +- {F : Type} [Field F] [NumberField F] +- (i j : F →ₐ[ℚ] SeparableClosure ℚ) : +- ∃ σ : SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ, +- ∀ x : F, σ (i x) = j x := by +- let hAlgebra : Algebra F (SeparableClosure ℚ) := +- rationalEmbeddingSeparableClosureAlgebra i +- let hScalarTower : IsScalarTower ℚ F (SeparableClosure ℚ) := +- IsScalarTower.of_algebraMap_eq' i.comp_algebraMap.symm +- let hSeparable : Algebra.IsSeparable F (SeparableClosure ℚ) := +- Algebra.isSeparable_tower_top_of_isSeparable +- ℚ F (SeparableClosure ℚ) +- obtain ⟨φ, hφ⟩ := +- (IsSepClosed.surjective_domRestrict_of_isSeparable +- (K := ℚ) (L := F) +- (M := SeparableClosure ℚ) +- (E := SeparableClosure ℚ)) j +- let σ : SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := +- AlgEquiv.ofBijective φ +- (Normal.toIsAlgebraic.algHom_bijective₂ +- φ (AlgHom.id ℚ (SeparableClosure ℚ))).1 +- refine ⟨σ, ?_⟩ +- intro x +- have hx := +- congrArg (fun ψ : F →ₐ[ℚ] SeparableClosure ℚ => ψ x) hφ +- exact hx +- +-/-- The canonical comparison automorphism between two rational +-embeddings of one number field into the fixed separable closure. -/ +-noncomputable def numberFieldEmbeddingComparisonAutomorphism +- {F : Type} [Field F] [NumberField F] +- (i j : F →ₐ[ℚ] SeparableClosure ℚ) : +- SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := +- Classical.choose +- (exists_numberFieldEmbeddingComparisonAutomorphism i j) +- +-/-- The comparison automorphism carries the first embedded copy of the +-number field to the second one pointwise. -/ +-@[simp] +-theorem numberFieldEmbeddingComparisonAutomorphism_apply +- {F : Type} [Field F] [NumberField F] +- (i j : F →ₐ[ℚ] SeparableClosure ℚ) +- (x : F) : +- numberFieldEmbeddingComparisonAutomorphism i j (i x) = +- j x := +- Classical.choose_spec +- (exists_numberFieldEmbeddingComparisonAutomorphism i j) x +- +-/-- Conjugating the fixing subgroup of one embedded copy of a number +-field by the comparison automorphism gives the fixing subgroup of the +-other embedded copy. -/ +-theorem conjugateClosedFixingSubgroup_embeddingRange +- {F : Type} [Field F] [NumberField F] +- (i j : F →ₐ[ℚ] SeparableClosure ℚ) : +- conjugateClosedSubgroup +- (RamificationTheory.closedFixingSubgroup +- ℚ (SeparableClosure ℚ) i.fieldRange) +- (numberFieldEmbeddingComparisonAutomorphism j i) = +- RamificationTheory.closedFixingSubgroup +- ℚ (SeparableClosure ℚ) j.fieldRange := by +- let s := +- numberFieldEmbeddingComparisonAutomorphism j i +- ext τ +- change +- τ ∈ conjugateClosedSubgroup +- (closedFixingSubgroup ℚ (SeparableClosure ℚ) i.fieldRange) s ↔ +- τ ∈ closedFixingSubgroup ℚ (SeparableClosure ℚ) j.fieldRange +- rw [conjugateClosedSubgroup_mem] +- change +- s * τ * s⁻¹ ∈ i.fieldRange.fixingSubgroup ↔ +- τ ∈ j.fieldRange.fixingSubgroup +- rw [IntermediateField.mem_fixingSubgroup_iff, +- IntermediateField.mem_fixingSubgroup_iff] +- constructor +- · intro h x hx +- rcases hx with ⟨y, rfl⟩ +- have hi := h (i y) ⟨y, rfl⟩ +- have hs : +- s (j y) = i y := +- numberFieldEmbeddingComparisonAutomorphism_apply j i y +- change s (τ (s.symm (i y))) = i y at hi +- have hpre : s.symm (i y) = j y := by +- rw [← hs, s.symm_apply_apply] +- rw [hpre, ← hs] at hi +- exact s.injective hi +- · intro h x hx +- rcases hx with ⟨y, rfl⟩ +- have hj := h (j y) ⟨y, rfl⟩ +- have hs : +- s (j y) = i y := +- numberFieldEmbeddingComparisonAutomorphism_apply j i y +- change s (τ (s.symm (i y))) = i y +- have hpre : s.symm (i y) = j y := by +- rw [← hs, s.symm_apply_apply] +- rw [hpre, hj, hs] +- +-section EmbeddedNumberFieldRealization +- +-local instance numberFieldEmbeddedIdeleClassGroupIsMulCommutative +- {F : Type} [Field F] [NumberField F] +- : IsMulCommutative (IdeleClassGroup F) := +- ⟨⟨fun a b => mul_comm a b⟩⟩ +- +-local instance numberFieldEmbeddedIdeleClassSubgroupNormal +- {F : Type} [Field F] [NumberField F] +- (N : Subgroup (IdeleClassGroup F)) : N.Normal := +- N.normal_of_isMulCommutative +- +-variable +- (K L : Type) [Field K] [NumberField K] +- [Field L] [NumberField L] [Algebra K L] +- +-/-- The lower embedding obtained by restricting an explicitly supplied +-embedding of the top field into the rational separable closure. -/ +-noncomputable def numberFieldEmbeddedLowerEmbedding +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- K →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ K L) +- +-/-- The exact algebra structure on the rational separable closure induced by +-the lower embedding of an explicitly embedded number-field tower. Keeping +-this as a reducible definition lets every use of the associated separable- +-closure equivalence share one definitionally identical algebra structure. -/ +-@[reducible] +-noncomputable def numberFieldEmbeddedSeparableClosureAlgebra +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Algebra K (SeparableClosure ℚ) := +- rationalEmbeddingSeparableClosureAlgebra +- (numberFieldEmbeddedLowerEmbedding K L j) +- +-/-- The fixing subgroup of the explicitly embedded lower field. -/ +-abbrev numberFieldEmbeddedBaseSubgroup +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- ClosedSubgroup +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedLowerEmbedding K L j).fieldRange +- +-/-- The fixing subgroup of the explicitly embedded top field. -/ +-abbrev numberFieldEmbeddedTopSubgroup +- (_K L : Type) [Field L] [NumberField L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- ClosedSubgroup +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- closedFixingSubgroup ℚ (SeparableClosure ℚ) j.fieldRange +- +-/-- The top fixing subgroup lies in the lower fixing subgroup. -/ +-theorem numberFieldEmbeddedTopSubgroup_le_baseSubgroup +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- (numberFieldEmbeddedTopSubgroup K L j).toSubgroup ≤ +- (numberFieldEmbeddedBaseSubgroup K L j).toSubgroup := by +- change +- j.fieldRange.fixingSubgroup ≤ +- (numberFieldEmbeddedLowerEmbedding K L j).fieldRange.fixingSubgroup +- apply +- (numberFieldEmbeddedLowerEmbedding K L j).fieldRange.fixingSubgroup_le +- intro x hx +- rcases hx with ⟨y, rfl⟩ +- exact ⟨algebraMap K L y, rfl⟩ +- +-/-- The separable closure of the actual lower field, identified with +-the rational separable closure carrying the algebra structure induced +-by an explicit compatible embedding. -/ +-noncomputable def numberFieldEmbeddedSeparableClosureEquiv +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- letI : Algebra K (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra K L j +- SeparableClosure K ≃ₐ[K] SeparableClosure ℚ := by +- letI : Algebra K (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra K L j +- letI hScalarTower : IsScalarTower ℚ K (SeparableClosure ℚ) := +- IsScalarTower.of_algebraMap_eq' +- (numberFieldEmbeddedLowerEmbedding K L j).comp_algebraMap.symm +- letI hseparable : Algebra.IsSeparable K (SeparableClosure ℚ) := +- Algebra.isSeparable_tower_top_of_isSeparable +- ℚ K (SeparableClosure ℚ) +- letI hSepClosure : IsSepClosure K (SeparableClosure ℚ) := +- ⟨IsSepClosure.sep_closed ℚ, hseparable⟩ +- exact +- IsSepClosure.equiv K +- (SeparableClosure K) (SeparableClosure ℚ) +- +-/-- The relative subgroup arising from an explicit compatible +-number-field embedding is normal. -/ +-theorem numberFieldEmbeddedExtensionSubgroup_normal +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).Normal := by +- let i := numberFieldEmbeddedLowerEmbedding K L j +- let hAlgebra : Algebra K (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra K L j +- let e := numberFieldEmbeddedSeparableClosureEquiv K L j +- change +- (CyclicCohomology.extensionSubgroup +- (closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange i)) +- (closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange j)) _).Normal +- exact ambientEmbeddedExtensionSubgroup_normal ℚ K L j e +- +-/-- The normality witness for an explicitly embedded tower, registered at +-the precise subgroup used by the downstream quotient constructions. -/ +-noncomputable local instance +- numberFieldEmbeddedExtensionSubgroupNormal +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K L j +- +-/-- The relative quotient arising from an explicit compatible +-number-field embedding is finite. -/ +-theorem numberFieldEmbeddedExtensionQuotient_finite +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Finite +- ((numberFieldEmbeddedBaseSubgroup K L j).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := by +- let i := numberFieldEmbeddedLowerEmbedding K L j +- let hAlgebra : Algebra K (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra K L j +- let e := numberFieldEmbeddedSeparableClosureEquiv K L j +- change +- Finite +- ((closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange i)).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange i)) +- (closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange j)) _) +- exact ambientEmbeddedExtensionQuotient_finite ℚ K L j e +- +-/-- The relative-index witness for an explicitly embedded tower, registered +-at the exact quotient consumed by `FiniteNormQuotient`. -/ +-noncomputable local instance +- numberFieldEmbeddedExtensionQuotientFinite +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Finite +- ((numberFieldEmbeddedBaseSubgroup K L j).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := +- numberFieldEmbeddedExtensionQuotient_finite K L j +- +-/-- The finite abstract field determined by the lower member of an +-explicitly embedded number-field tower. -/ +-noncomputable abbrev numberFieldEmbeddedFiniteAbstractField +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) where +- field := numberFieldEmbeddedBaseSubgroup K L j +- finite := by +- simpa only [numberFieldEmbeddedBaseSubgroup] using +- (ambientEmbeddedAbsoluteQuotientFinite +- ℚ K (numberFieldEmbeddedLowerEmbedding K L j)) +- +-/-- The absolute-index witness for the lower member of an explicitly embedded +-tower, registered at its specialized quotient type. -/ +-noncomputable local instance +- numberFieldEmbeddedAbsoluteQuotientFinite +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (numberFieldEmbeddedBaseSubgroup K L j) +- (le_baseField +- (numberFieldEmbeddedBaseSubgroup K L j))) := +- (numberFieldEmbeddedFiniteAbstractField K L j).finite +- +-/-- The finite Galois subextension determined by an explicitly embedded +-number-field tower. -/ +-noncomputable abbrev numberFieldEmbeddedFiniteGaloisSubextension +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteGaloisSubextension +- (numberFieldEmbeddedBaseSubgroup K L j) where +- field := numberFieldEmbeddedTopSubgroup K L j +- below := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j +- normal := numberFieldEmbeddedExtensionSubgroup_normal K L j +- finite := numberFieldEmbeddedExtensionQuotient_finite K L j +- +-/-- Shared finite-dimensional data for the fixed field of the lower subgroup +-in an explicitly embedded number-field tower. -/ +-noncomputable local instance +- numberFieldEmbeddedAbstractFixedFieldFiniteDimensional +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteDimensional ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) := +- abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedAbsoluteQuotientFinite K L j) +- +-/-- Shared relative finite-dimensional data for the two fixed fields of an +-explicitly embedded number-field tower. -/ +-noncomputable local instance +- numberFieldEmbeddedAbstractRelativeFixedFieldFiniteDimensional +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteDimensional +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := +- abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) +- (numberFieldEmbeddedAbsoluteQuotientFinite K L j) +- (numberFieldEmbeddedExtensionQuotientFinite K L j) +- +-local instance numberFieldEmbeddedAbstractFixedFieldScalarTower +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- IsScalarTower ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := +- IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) +- +-noncomputable local instance +- numberFieldEmbeddedAbstractRelativeFixedFieldAbsoluteFiniteDimensional +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteDimensional ℚ +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := +- FiniteDimensional.trans ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) +- +-noncomputable local instance +- numberFieldEmbeddedAbstractFixedFieldNumberField +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- NumberField +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) := +- NumberField.of_module_finite ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) +- +-noncomputable local instance +- numberFieldEmbeddedAbstractRelativeFixedFieldNumberField +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- NumberField +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := +- NumberField.of_module_finite ℚ +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) +- +-noncomputable local instance +- numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsFiniteDimensional +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteDimensional ℚ +- ((abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).restrictScalars ℚ) := by +- change FiniteDimensional ℚ +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) +- infer_instance +- +-noncomputable local instance +- numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsNumberField +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- NumberField +- ((abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).restrictScalars ℚ) := +- NumberField.of_module_finite ℚ _ +- +-noncomputable local instance +- numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsAlgebra +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Algebra +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) +- ((abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).restrictScalars ℚ) := +- (IntermediateField.inclusion +- (abstractFixedField_le ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j))).toRingHom.toAlgebra +- +-noncomputable local instance +- numberFieldEmbeddedAbstractRelativeFixedFieldIsGalois +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- IsGalois +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := +- abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) +- (numberFieldEmbeddedExtensionSubgroupNormal K L j) +- +-/-- The quotient of the two explicitly embedded fixing subgroups is +-the actual relative Galois group. -/ +-noncomputable def +- numberFieldEmbeddedExtensionQuotientEquivGaloisGroup +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- (numberFieldEmbeddedFiniteGaloisSubextension K L j).extensionQuotient ≃* +- Gal(L / K) := by +- let i := numberFieldEmbeddedLowerEmbedding K L j +- letI hAlgebra : Algebra K (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra K L j +- let e := numberFieldEmbeddedSeparableClosureEquiv K L j +- let H₀ := +- closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange i) +- let J₀ := +- closedFixingSubgroup ℚ (SeparableClosure ℚ) +- (AlgHom.fieldRange j) +- let hJH : J₀.toSubgroup ≤ H₀.toSubgroup := by +- change j.fieldRange.fixingSubgroup ≤ i.fieldRange.fixingSubgroup +- apply i.fieldRange.fixingSubgroup_le +- intro x hx +- rcases hx with ⟨y, rfl⟩ +- exact ⟨algebraMap K L y, rfl⟩ +- letI : (CyclicCohomology.extensionSubgroup H₀ J₀ hJH).Normal := +- ambientEmbeddedExtensionSubgroup_normal ℚ K L j e +- change +- (H₀.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H₀ J₀ hJH) ≃* +- Gal(L / K) +- exact ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ K L j e +- +-/-- The original lower field is canonically equivalent to the fixed +-field of its explicitly embedded fixing subgroup. -/ +-noncomputable def numberFieldEmbeddedAbstractBaseFieldEquiv +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- K ≃ₐ[ℚ] +- abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j) := +- (numberFieldEmbeddedLowerEmbedding K L j).equivFieldRange.trans +- (IntermediateField.equivOfEq +- (InfiniteGalois.fixedField_fixingSubgroup +- (numberFieldEmbeddedLowerEmbedding K L j).fieldRange).symm) +- +-/-- The original top field is canonically equivalent to the relative +-fixed field of its explicitly embedded fixing subgroup. -/ +-noncomputable def numberFieldEmbeddedAbstractTopFieldEquiv +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- L ≃ₐ[ℚ] +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup +- K L j)).restrictScalars ℚ := +- j.equivFieldRange.trans +- (IntermediateField.equivOfEq +- (InfiniteGalois.fixedField_fixingSubgroup j.fieldRange).symm) +- +-/-- The two explicit fixed-field equivalences commute with the tower +-algebra maps. -/ +-@[simp] +-theorem numberFieldEmbeddedAbstractFieldEquiv_algebraMap +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (x : K) : +- numberFieldEmbeddedAbstractTopFieldEquiv K L j +- (algebraMap K L x) = +- algebraMap +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L j)) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j x) := by +- apply Subtype.ext +- rfl +- +-/-- The ordinary idele class group of the explicitly embedded lower +-field, transported to the fixed part of the rational absolute +-idele-class representation. -/ +-noncomputable def numberFieldEmbeddedIdeleClassEquivAmbientFixed +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Additive (IdeleClassGroup K) ≃+ +- ambientFixedAddSubgroup +- rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) := by +- let H := numberFieldEmbeddedBaseSubgroup K L j +- exact +- (MulEquiv.toAdditive +- (ideleClassCongr +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j))).trans +- (rationalAbstractFixedFieldIdeleClassEquivFixed H) +- +-/-- The abstract finite norm quotient of an explicitly embedded tower +-is its genuine ordinary idele-class norm quotient. -/ +-noncomputable def +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteNormQuotient rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ≃+ +- Additive +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) := by +- let hnormal := +- numberFieldEmbeddedExtensionSubgroupNormal K L j +- let H := numberFieldEmbeddedBaseSubgroup K L j +- let J := numberFieldEmbeddedTopSubgroup K L j +- let hJH := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j +- let fixedFieldEquiv := +- rationalFiniteNormQuotientEquivIdeleClassNormQuotient +- H J hJH hnormal +- let actualFieldEquiv := +- ordinaryIdeleClassNormQuotientCongrOfAlgEquiv +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) +- (numberFieldEmbeddedAbstractTopFieldEquiv K L j) +- (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) +- exact +- fixedFieldEquiv.trans +- (MulEquiv.toAdditive actualFieldEquiv.symm) +- +-private theorem numberFieldEmbeddedOrdinaryNormQuotientCongr_symm_mk +- {K₀ L₀ K₁ L₁ : Type} +- [Field K₀] [NumberField K₀] +- [Field L₀] [NumberField L₀] [Algebra K₀ L₀] +- [Field K₁] [NumberField K₁] +- [Field L₁] [NumberField L₁] [Algebra K₁ L₁] +- (eK : K₀ ≃ₐ[ℚ] K₁) +- (eL : L₀ ≃ₐ[ℚ] L₁) +- (h : ∀ x : K₀, +- eL (algebraMap K₀ L₀ x) = +- algebraMap K₁ L₁ (eK x)) +- (c : IdeleClassGroup K₁) : +- (ordinaryIdeleClassNormQuotientCongrOfAlgEquiv eK eL h).symm +- (QuotientGroup.mk' +- (_root_.ideleClassNorm K₁ L₁).range c) = +- QuotientGroup.mk' +- (_root_.ideleClassNorm K₀ L₀).range +- ((ideleClassCongr eK).symm c) := by +- let e := ordinaryIdeleClassNormQuotientCongrOfAlgEquiv eK eL h +- apply e.injective +- rw [e.apply_symm_apply, +- ordinaryIdeleClassNormQuotientCongrOfAlgEquiv_mk, +- MulEquiv.apply_symm_apply] +- +-private noncomputable def numberFieldEmbeddedFiniteNormClassPublicValue +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- Additive +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) := +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient +- K L j +- (finiteNormClass rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) +- a) +- +-private noncomputable def numberFieldEmbeddedFiniteNormClassExpectedValue +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- Additive +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) := +- Additive.ofMul +- (QuotientGroup.mk' +- (_root_.ideleClassNorm K L).range +- (Additive.toMul +- ((numberFieldEmbeddedIdeleClassEquivAmbientFixed K L j).symm a))) +- +-private noncomputable def +- numberFieldEmbeddedFiniteNormClassDirectComparisonValue +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- Additive +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) := by +- let hnormal := +- numberFieldEmbeddedExtensionSubgroupNormal K L j +- let H := numberFieldEmbeddedBaseSubgroup K L j +- let J := numberFieldEmbeddedTopSubgroup K L j +- let hJH := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j +- let fixedFieldEquiv := +- rationalFiniteNormQuotientEquivIdeleClassNormQuotient +- H J hJH hnormal +- let actualFieldEquiv := +- ordinaryIdeleClassNormQuotientCongrOfAlgEquiv +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) +- (numberFieldEmbeddedAbstractTopFieldEquiv K L j) +- (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) +- exact +- MulEquiv.toAdditive actualFieldEquiv.symm +- (fixedFieldEquiv +- (finiteNormClass rationalIdeleClassRepresentation +- H J hJH a)) +- +-private theorem +- numberFieldEmbeddedFiniteNormClassPublicValue_eq_directComparison +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- numberFieldEmbeddedFiniteNormClassPublicValue K L j a = +- numberFieldEmbeddedFiniteNormClassDirectComparisonValue K L j a := by +- unfold numberFieldEmbeddedFiniteNormClassPublicValue +- unfold numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient +- unfold numberFieldEmbeddedFiniteNormClassDirectComparisonValue +- rfl +- +-private noncomputable def numberFieldEmbeddedActualNormClassRepresentativeValue +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- Additive +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) := by +- let H := numberFieldEmbeddedBaseSubgroup K L j +- let hJH := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j +- let F := abstractFixedField ℚ (SeparableClosure ℚ) H +- let E := abstractRelativeFixedField ℚ (SeparableClosure ℚ) hJH +- let actualFieldEquiv := +- ordinaryIdeleClassNormQuotientCongrOfAlgEquiv +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) +- (numberFieldEmbeddedAbstractTopFieldEquiv K L j) +- (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) +- exact +- Additive.ofMul +- (actualFieldEquiv.symm +- (QuotientGroup.mk' +- (_root_.ideleClassNorm F E).range +- (Additive.toMul +- ((rationalAbstractFixedFieldIdeleClassEquivFixed H).symm a)))) +- +-private theorem +- numberFieldEmbeddedFiniteNormClassDirectComparison_eq_actualValue +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- numberFieldEmbeddedFiniteNormClassDirectComparisonValue K L j a = +- numberFieldEmbeddedActualNormClassRepresentativeValue K L j a := by +- let hnormal := numberFieldEmbeddedExtensionSubgroupNormal K L j +- let H := numberFieldEmbeddedBaseSubgroup K L j +- let J := numberFieldEmbeddedTopSubgroup K L j +- let hJH := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j +- let actualFieldEquiv := +- ordinaryIdeleClassNormQuotientCongrOfAlgEquiv +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) +- (numberFieldEmbeddedAbstractTopFieldEquiv K L j) +- (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) +- have hfixed := +- rationalFiniteNormQuotientEquivIdeleClassNormQuotient_finiteNormClass +- H J hJH hnormal a +- unfold numberFieldEmbeddedFiniteNormClassDirectComparisonValue +- unfold numberFieldEmbeddedActualNormClassRepresentativeValue +- exact congrArg (MulEquiv.toAdditive actualFieldEquiv.symm) hfixed +- +-private theorem numberFieldEmbeddedActualNormClassRepresentativeValue_eq_expected +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- numberFieldEmbeddedActualNormClassRepresentativeValue K L j a = +- numberFieldEmbeddedFiniteNormClassExpectedValue K L j a := by +- let H := numberFieldEmbeddedBaseSubgroup K L j +- let hJH := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j +- let F := abstractFixedField ℚ (SeparableClosure ℚ) H +- let E := abstractRelativeFixedField ℚ (SeparableClosure ℚ) hJH +- let actualFieldEquiv := +- ordinaryIdeleClassNormQuotientCongrOfAlgEquiv +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) +- (numberFieldEmbeddedAbstractTopFieldEquiv K L j) +- (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) +- let c : IdeleClassGroup F := +- Additive.toMul +- ((rationalAbstractFixedFieldIdeleClassEquivFixed H).symm a) +- unfold numberFieldEmbeddedActualNormClassRepresentativeValue +- unfold numberFieldEmbeddedFiniteNormClassExpectedValue +- change +- Additive.ofMul +- (actualFieldEquiv.symm +- (QuotientGroup.mk' +- (_root_.ideleClassNorm F E).range c)) = +- Additive.ofMul +- (QuotientGroup.mk' +- (_root_.ideleClassNorm K L).range +- ((ideleClassCongr +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j)).symm c)) +- exact +- congrArg Additive.ofMul +- (numberFieldEmbeddedOrdinaryNormQuotientCongr_symm_mk +- (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) +- (numberFieldEmbeddedAbstractTopFieldEquiv K L j) +- (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) c) +- +-/-- On a finite norm-class representative, the explicit fixed-field +-comparison is the genuine ordinary idele-class quotient. -/ +-@[simp] +-theorem +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_finiteNormClass +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j)) : +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient K L j +- (finiteNormClass rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) a) = +- Additive.ofMul +- (QuotientGroup.mk' +- (_root_.ideleClassNorm K L).range +- (Additive.toMul +- ((numberFieldEmbeddedIdeleClassEquivAmbientFixed K L j).symm a))) := by +- change +- numberFieldEmbeddedFiniteNormClassPublicValue K L j a = +- numberFieldEmbeddedFiniteNormClassExpectedValue K L j a +- exact +- (numberFieldEmbeddedFiniteNormClassPublicValue_eq_directComparison +- K L j a).trans +- ((numberFieldEmbeddedFiniteNormClassDirectComparison_eq_actualValue +- K L j a).trans +- (numberFieldEmbeddedActualNormClassRepresentativeValue_eq_expected +- K L j a)) +- +-/-- On an ordinary idele class, the explicit fixed-part realization +-followed by the abstract finite norm-class map is the genuine quotient +-class modulo the ordinary idele-class norm. -/ +-@[simp] +-theorem +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass +- [FiniteDimensional K L] [IsGalois K L] +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (c : IdeleClassGroup K) : +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient K L j +- (finiteNormClass rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K L j (Additive.ofMul c))) = +- Additive.ofMul +- (QuotientGroup.mk' +- (_root_.ideleClassNorm K L).range c) := by +- simpa only [AddEquiv.symm_apply_apply, toMul_ofMul] using +- (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_finiteNormClass +- K L j +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K L j (Additive.ofMul c))) +- +-variable [FiniteDimensional K L] [IsAbelianGalois K L] +- +-/-- The abelianized quotient of the explicitly embedded tower is the +-actual abelian Galois group. -/ +-noncomputable def +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Additive +- (Abelianization +- (numberFieldEmbeddedFiniteGaloisSubextension K L j).extensionQuotient) ≃+ +- Additive Gal(L / K) := +- MulEquiv.toAdditive +- ((MulEquiv.abelianizationCongr +- (numberFieldEmbeddedExtensionQuotientEquivGaloisGroup K L j)).trans +- (Abelianization.equivOfComm : +- Gal(L / K) ≃* +- Abelianization Gal(L / K)).symm) +- +-/-- The actual global norm-residue equivalence constructed from an +-explicit compatible embedding of a finite abelian number-field +-extension into the rational separable closure. -/ +-noncomputable def globalNormResidueEquivOfEmbedding +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- Additive +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) ≃+ +- Additive Gal(L / K) := by +- let eNorm : +- FiniteNormQuotient rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ≃+ +- Additive +- (Abelianization +- (numberFieldEmbeddedFiniteGaloisSubextension K L j).extensionQuotient) := +- rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K L j) +- (numberFieldEmbeddedFiniteGaloisSubextension K L j) +- exact +- (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient +- K L j).symm.trans +- (eNorm.trans +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L j)) +- +-/-- The explicit-embedding norm-residue equivalence on a finite norm class. -/ +-theorem globalNormResidueEquivOfEmbedding_finiteNormClass +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (x : FiniteNormQuotient rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) : +- globalNormResidueEquivOfEmbedding K L j +- (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient +- K L j x) = +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup K L j +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K L j) +- (numberFieldEmbeddedFiniteGaloisSubextension K L j) x) := by +- simp only [globalNormResidueEquivOfEmbedding, AddEquiv.trans_apply, +- AddEquiv.symm_apply_apply] +- +-/-- The global norm-residue homomorphism obtained from an explicit +-compatible embedding. -/ +-noncomputable def globalNormResidueMonoidHomOfEmbedding +- (j : L →ₐ[ℚ] SeparableClosure ℚ) : +- IdeleClassGroup K →* Gal(L / K) := by +- let e : +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) ≃* +- Gal(L / K) := +- AddEquiv.toMultiplicative +- (globalNormResidueEquivOfEmbedding K L j) +- exact +- e.toMonoidHom.comp +- (QuotientGroup.mk' +- (_root_.ideleClassNorm K L).range) +- +-/-- Evaluation of the explicit-embedding global norm-residue map is +-the abstract norm-residue symbol evaluated on the corresponding genuine +-fixed-part finite norm class. -/ +-@[simp] +-theorem globalNormResidueMonoidHomOfEmbedding_apply +- (j : L →ₐ[ℚ] SeparableClosure ℚ) +- (c : IdeleClassGroup K) : +- globalNormResidueMonoidHomOfEmbedding K L j c = +- Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L j +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K L j) +- (numberFieldEmbeddedFiniteGaloisSubextension K L j) +- (finiteNormClass rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup K L j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K L j (Additive.ofMul c))))) := by +- have hclass := +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass +- K L j c +- change +- Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L j +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K L j) +- (numberFieldEmbeddedFiniteGaloisSubextension K L j) +- ((numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient +- K L j).symm +- (Additive.ofMul +- (QuotientGroup.mk' +- (_root_.ideleClassNorm K L).range c))))) = +- _ +- rw [← hclass, +- (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient +- K L j).symm_apply_apply] +- +-omit [FiniteDimensional K L] [IsAbelianGalois K L] in +-/-- The ambient-fixed idèle-class transport for the standard embedding is +-the same map as the transport for an explicitly supplied embedding. This +-comparison is kept at the transport boundary, before forming norm quotients +-or applying reciprocity. -/ +-theorem numberFieldTowerIdeleClassEquivAmbientFixed_eq_embedded_standard : +- numberFieldTowerIdeleClassEquivAmbientFixed K L = +- numberFieldEmbeddedIdeleClassEquivAmbientFixed K L +- (numberFieldSeparableClosureEmbedding L) := by +- let j := numberFieldSeparableClosureEmbedding L +- have hBase : +- numberFieldTowerAbstractBaseFieldEquiv K L = +- numberFieldEmbeddedAbstractBaseFieldEquiv K L j := by +- rfl +- unfold numberFieldTowerIdeleClassEquivAmbientFixed +- numberFieldEmbeddedIdeleClassEquivAmbientFixed +- rw [hBase] +- dsimp only +- congr 1 +- +-/- At the chosen embedding, both constructions use the same fixed tower and +-abstract reciprocity data. We compare their values on the particular fixed +-idele class needed below; the two implementations of the finite norm-quotient +-equivalence are deliberately not compared as dependent structures. -/ +-private theorem numberFieldTowerNormResidueValue_eq_embedded_standard +- (c : IdeleClassGroup K) : +- numberFieldTowerAbelianizedExtensionQuotientEquivGaloisGroup K L +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldTowerReciprocityFiniteAbstractField K L) +- (numberFieldTowerFiniteGaloisSubextension K L) +- (finiteNormClass rationalIdeleClassRepresentation +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L) +- (numberFieldTowerIdeleClassEquivAmbientFixed K L (Additive.ofMul c)))) = +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L (numberFieldSeparableClosureEmbedding L) +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K L +- (numberFieldSeparableClosureEmbedding L)) +- (numberFieldEmbeddedFiniteGaloisSubextension K L +- (numberFieldSeparableClosureEmbedding L)) +- (finiteNormClass rationalIdeleClassRepresentation +- (numberFieldEmbeddedBaseSubgroup K L +- (numberFieldSeparableClosureEmbedding L)) +- (numberFieldEmbeddedTopSubgroup K L +- (numberFieldSeparableClosureEmbedding L)) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L +- (numberFieldSeparableClosureEmbedding L)) +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed K L +- (numberFieldSeparableClosureEmbedding L) (Additive.ofMul c)))) := by +- have hIdeleClassEquiv : +- numberFieldTowerIdeleClassEquivAmbientFixed K L = +- numberFieldEmbeddedIdeleClassEquivAmbientFixed K L +- (numberFieldSeparableClosureEmbedding L) := by +- exact numberFieldTowerIdeleClassEquivAmbientFixed_eq_embedded_standard K L +- have hFiniteAbstractField : +- numberFieldTowerReciprocityFiniteAbstractField K L = +- numberFieldEmbeddedFiniteAbstractField K L +- (numberFieldSeparableClosureEmbedding L) := by +- rfl +- have hSubextension : +- numberFieldTowerFiniteGaloisSubextension K L = +- numberFieldEmbeddedFiniteGaloisSubextension K L +- (numberFieldSeparableClosureEmbedding L) := by +- rfl +- have hGaloisComparison : +- numberFieldTowerAbelianizedExtensionQuotientEquivGaloisGroup K L = +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L (numberFieldSeparableClosureEmbedding L) := by +- rfl +- simp only [← hGaloisComparison] +- cases hFiniteAbstractField +- cases hSubextension +- rw [← hIdeleClassEquiv] +- rfl +- +-/-- At the standard embedding, the two global norm-residue equivalences +-agree on the actual norm quotient. The comparison is extensional: it uses +-surjectivity of the quotient map and the established evaluation formulas, +-not definitional equality of the two quotient constructions. -/ +-theorem globalNormResidueEquiv_eq_ofEmbedding_standard : +- globalNormResidueEquiv K L = +- globalNormResidueEquivOfEmbedding K L +- (numberFieldSeparableClosureEmbedding L) := by +- apply AddEquiv.ext +- intro q +- obtain ⟨c, hc⟩ := +- QuotientGroup.mk'_surjective +- (_root_.ideleClassNorm K L).range (Additive.toMul q) +- have hq : +- Additive.ofMul +- (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c) = q := +- Additive.toMul.injective hc +- rw [← hq] +- have hTower := +- numberFieldTowerFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass +- K L c +- have hEmbedded := +- numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass +- K L (numberFieldSeparableClosureEmbedding L) c +- conv_lhs => +- rw [← hTower, globalNormResidueEquiv_finiteNormClass] +- conv_rhs => +- rw [← hEmbedded, globalNormResidueEquivOfEmbedding_finiteNormClass] +- exact numberFieldTowerNormResidueValue_eq_embedded_standard K L c +- +-/-- The existing global norm-residue map is the explicit-embedding +-construction for the standard chosen embedding of the top field. -/ +-theorem globalNormResidueMonoidHom_eq_ofEmbedding_standard : +- globalNormResidueMonoidHom K L = +- globalNormResidueMonoidHomOfEmbedding K L +- (numberFieldSeparableClosureEmbedding L) := by +- apply MonoidHom.ext +- intro c +- apply Additive.toMul.injective +- change +- globalNormResidueEquiv K L +- (Additive.ofMul +- (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c)) = +- globalNormResidueEquivOfEmbedding K L +- (numberFieldSeparableClosureEmbedding L) +- (Additive.ofMul +- (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c)) +- exact congrArg +- (fun e : +- Additive +- (IdeleClassGroup K ⧸ +- (_root_.ideleClassNorm K L).range) ≃+ +- Additive (Gal(L / K)) => +- e (Additive.ofMul +- (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c))) +- (globalNormResidueEquiv_eq_ofEmbedding_standard K L) +- +-end EmbeddedNumberFieldRealization +- +-section EmbeddedNumberFieldRestriction +- +-variable +- (K K' L L' : Type) +- [Field K] [NumberField K] +- [Field K'] [NumberField K'] +- [Field L] [NumberField L] +- [Field L'] [NumberField L'] +- [Algebra K K'] [Algebra K L] [Algebra K L'] +- [Algebra K' L'] [Algebra L L'] +- [IsScalarTower K K' L'] [IsScalarTower K L L'] +- +-/-- A compatible common embedding reverses the inclusion of the two base +-fields into an inclusion of their fixing subgroups. -/ +-theorem numberFieldEmbeddedBaseSubgroup_le_of_tower +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- let jLower : L →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ L L') +- (numberFieldEmbeddedBaseSubgroup K' L' j).toSubgroup ≤ +- (numberFieldEmbeddedBaseSubgroup K L jLower).toSubgroup := by +- dsimp only +- change +- (numberFieldEmbeddedLowerEmbedding K' L' j).fieldRange.fixingSubgroup ≤ +- (numberFieldEmbeddedLowerEmbedding K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).fieldRange.fixingSubgroup +- apply +- (numberFieldEmbeddedLowerEmbedding K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).fieldRange.fixingSubgroup_le +- intro x hx +- rcases hx with ⟨y, rfl⟩ +- refine ⟨algebraMap K K' y, ?_⟩ +- change +- j (algebraMap K' L' (algebraMap K K' y)) = +- j (algebraMap L L' (algebraMap K L y)) +- rw [← IsScalarTower.algebraMap_apply K K' L', +- ← IsScalarTower.algebraMap_apply K L L'] +- +-omit [Field K] [NumberField K] +- [Field K'] [NumberField K'] +- [Algebra K K'] [Algebra K L] [Algebra K L'] [Algebra K' L'] +- [IsScalarTower K K' L'] [IsScalarTower K L L'] in +-/-- A compatible common embedding reverses the inclusion of the two top +-fields into an inclusion of their fixing subgroups. -/ +-theorem numberFieldEmbeddedTopSubgroup_le_of_tower +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- let jLower : L →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ L L') +- (numberFieldEmbeddedTopSubgroup K' L' j).toSubgroup ≤ +- (numberFieldEmbeddedTopSubgroup K L jLower).toSubgroup := by +- dsimp only +- change +- j.fieldRange.fixingSubgroup ≤ +- (j.comp +- (IsScalarTower.toAlgHom ℚ L L')).fieldRange.fixingSubgroup +- apply +- (j.comp +- (IsScalarTower.toAlgHom ℚ L L')).fieldRange.fixingSubgroup_le +- intro x hx +- rcases hx with ⟨y, rfl⟩ +- exact ⟨algebraMap L L' y, rfl⟩ +- +-end EmbeddedNumberFieldRestriction +- + variable + (K : FiniteAbstractField + (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) + (L : FiniteAbelianSubextension K.field) + +-local instance abstractFixedFieldBaseQuotientFinite : +- Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- K.field (le_baseField K.field)) := +- K.finite +- +-local instance abstractFixedFieldRelativeQuotientFinite : +- Finite +- (K.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup K.field L.field L.below) := +- L.finite +- +-local instance abstractFixedFieldRelativeQuotientIsMulCommutative : +- IsMulCommutative L.extensionQuotient := +- L.commutative + +-noncomputable local instance abstractFixedFieldFiniteDimensional : +- FiniteDimensional ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) := +- abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) K.field K.finite +- +-noncomputable local instance abstractRelativeFixedFieldFiniteDimensional : +- FiniteDimensional +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) := +- abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- K.field L.field L.below K.finite L.finite +- +-local instance abstractFixedFieldRelativeScalarTower : +- IsScalarTower ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) := +- IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) +- +-noncomputable local instance abstractRelativeFixedFieldAbsoluteFiniteDimensional : +- FiniteDimensional ℚ +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) := +- FiniteDimensional.trans ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) +- +-noncomputable local instance abstractFixedFieldNumberField : +- NumberField +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) := +- NumberField.of_module_finite ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) +- +-/-- The lower fixed idèle-class group is commutative. Naming the mixin +-before the public quotient declarations avoids delayed normality synthesis +-inside their definition bodies. -/ +-local instance +- abstractFixedFieldIdeleClassGroupIsMulCommutative : +- IsMulCommutative +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field)) := +- ⟨⟨fun a b => mul_comm a b⟩⟩ +- +-noncomputable local instance abstractRelativeFixedFieldNumberField : +- NumberField +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) := +- NumberField.of_module_finite ℚ +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) +- +-/-- Use the same explicit Galois witness as the fixed-field quotient +-comparison. Deriving it through `IsAbelianGalois` produces an equivalent +-but much larger dependent instance path. -/ +-noncomputable local instance +- abstractRelativeFixedFieldIsGalois : +- IsGalois +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) := +- abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) +- K.field L.field L.below L.normal +- +-noncomputable local instance abstractRelativeFixedFieldIsAbelianGalois : +- IsAbelianGalois +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) := +- finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois L +- +-/-- Use one opaque normality witness for the actual fixed-field norm range. +-This keeps every occurrence of its quotient group on the same instance path. -/ +-local instance +- abstractFixedFieldIdeleClassNormRangeNormal : +- ((_root_.ideleClassNorm +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below)).range).Normal := by +- infer_instance +- +-/-- The abelianized abstract extension quotient is the actual Galois +-group of the corresponding pair of fixed fields. -/ +-noncomputable def +- abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below +- Additive +- (Abelianization +- (FiniteGaloisSubextension.extensionQuotient +- L.toFiniteGaloisExtension)) ≃+ +- Additive (Gal(E / F)) := by +- dsimp only +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below +- let e : +- L.extensionQuotient ≃* +- Gal(E / F) := +- L.extensionQuotientMulEquiv.trans +- (abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) +- K.field L.field L.below L.normal) +- exact +- MulEquiv.toAdditive +- ((Abelianization.equivOfComm : +- L.extensionQuotient ≃* +- Abelianization L.extensionQuotient).symm.trans e) +- +-/-- The actual fixed-field global norm-residue equivalence +- +-`C_F / N_{E/F} C_E ≃ Gal(E/F)` +- +-attached to an abstract finite abelian subextension in the rational +-absolute class formation. -/ +-noncomputable def abstractFixedFieldGlobalNormResidueEquiv : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below +- Additive +- (IdeleClassGroup F ⧸ +- (_root_.ideleClassNorm F E).range) ≃+ +- Additive (Gal(E / F)) := by +- dsimp only +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below +- let eNorm : +- FiniteNormQuotient rationalIdeleClassRepresentation +- K.field L.field L.below ≃+ +- Additive +- (Abelianization L.toFiniteGaloisExtension.extensionQuotient) := +- rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- K L.toFiniteGaloisExtension +- exact +- (rationalFiniteNormQuotientEquivIdeleClassNormQuotient +- K.field L.field L.below L.normal).symm.trans +- (eNorm.trans +- (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup +- K L)) +- +-/-- The abstract finite norm-residue equivalence with its dependent source +-instance fixed to the public finite norm quotient. -/ +-private noncomputable def abstractFixedFieldFiniteNormResidueGaloisEquiv : +- FiniteNormQuotient rationalIdeleClassRepresentation +- K.field L.field L.below ≃+ +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field))) := by +- letI : AddCommGroup +- (FiniteNormQuotient rationalIdeleClassRepresentation +- K.field L.field L.below) := +- finiteNormQuotientAddCommGroup rationalIdeleClassRepresentation +- K.field L.field L.below +- exact +- @AddEquiv.trans +- (FiniteNormQuotient rationalIdeleClassRepresentation +- K.field L.field L.below) +- (Additive +- (Abelianization +- L.toFiniteGaloisExtension.extensionQuotient)) +- (Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) K.field)))) +- inferInstance inferInstance inferInstance +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- K L.toFiniteGaloisExtension) +- (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup +- K L) +- +-/-- The abstract norm-residue symbol on the fixed part of the rational +-absolute idele-class representation, with its value transported to the +-actual Galois group of the two fixed fields. This is the form consumed +-directly by the abstract norm--restriction naturality theorem. -/ +-noncomputable def ambientFixedGlobalNormResidueAddMonoidHom : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below +- ambientFixedAddSubgroup +- rationalIdeleClassRepresentation K.field →+ +- Additive (Gal(E / F)) := by +- dsimp only +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below +- exact +- (abstractFixedFieldFiniteNormResidueGaloisEquiv K L).toAddMonoidHom.comp +- (finiteNormClassHom rationalIdeleClassRepresentation +- K.field L.field L.below) +- +-/-- The ordinary idele class group of the lower fixed field, transported +-to the fixed part of the rational absolute idele-class representation. -/ +-private noncomputable def abstractFixedFieldIdeleClassToAmbientFixedMonoidHom : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- IdeleClassGroup F →* +- Multiplicative +- (ambientFixedAddSubgroup +- rationalIdeleClassRepresentation K.field) := +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- K.field).toAddMonoidHom.toMultiplicativeRight +- +-/-- The actual norm-residue homomorphism on the ordinary idele class +-group of the lower fixed field, constructed without choosing a second +-field embedding. -/ +-noncomputable def abstractFixedFieldGlobalNormResidueMonoidHom : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) L.below +- IdeleClassGroup F →* Gal(E / F) := +- (ambientFixedGlobalNormResidueAddMonoidHom K L).toMultiplicative.comp +- (abstractFixedFieldIdeleClassToAmbientFixedMonoidHom K) +- +-/-- Pointwise form of the ambient fixed-part norm-residue homomorphism. -/ +-private theorem ambientFixedGlobalNormResidueAddMonoidHom_apply +- (a : +- ambientFixedAddSubgroup +- rationalIdeleClassRepresentation K.field) : +- ambientFixedGlobalNormResidueAddMonoidHom K L a = +- abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup +- K L +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- K L.toFiniteGaloisExtension +- (finiteNormClass rationalIdeleClassRepresentation +- K.field L.field L.below a)) := by +- change +- abstractFixedFieldFiniteNormResidueGaloisEquiv K L +- (finiteNormClass rationalIdeleClassRepresentation +- K.field L.field L.below a) = _ +- rfl +- +-/-- Pointwise form of the transported fixed-field norm-residue homomorphism. -/ +-private theorem abstractFixedFieldGlobalNormResidueMonoidHom_apply : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) K.field +- ∀ c : IdeleClassGroup F, +- abstractFixedFieldGlobalNormResidueMonoidHom K L c = +- Additive.toMul +- (ambientFixedGlobalNormResidueAddMonoidHom K L +- ((rationalAbstractFixedFieldIdeleClassEquivFixed K.field) +- (Additive.ofMul c))) := by +- dsimp only +- intro c +- rfl +- +-/-- Transporting an ordinary fixed-field idele class to the ambient +-fixed part and applying the abstract norm-residue map gives exactly the +-actual fixed-field norm-residue value. -/ +-@[simp] +-theorem abstractFixedFieldGlobalNormResidueMonoidHom_fixed_apply +- (a : +- ambientFixedAddSubgroup +- rationalIdeleClassRepresentation K.field) : +- abstractFixedFieldGlobalNormResidueMonoidHom K L +- (Additive.toMul +- ((rationalAbstractFixedFieldIdeleClassEquivFixed +- K.field).symm a)) = +- Additive.toMul +- (ambientFixedGlobalNormResidueAddMonoidHom K L a) := by +- rw [abstractFixedFieldGlobalNormResidueMonoidHom_apply] +- change +- Additive.toMul +- (ambientFixedGlobalNormResidueAddMonoidHom K L +- ((rationalAbstractFixedFieldIdeleClassEquivFixed K.field) +- ((rationalAbstractFixedFieldIdeleClassEquivFixed +- K.field).symm a))) = +- Additive.toMul +- (ambientFixedGlobalNormResidueAddMonoidHom K L a) +- rw [(rationalAbstractFixedFieldIdeleClassEquivFixed +- K.field).apply_symm_apply] ++attribute [local instance] ++ abstractFixedFieldBaseQuotientFinite ++ abstractFixedFieldRelativeQuotientFinite ++ abstractFixedFieldRelativeQuotientIsMulCommutative ++ abstractFixedFieldFiniteDimensional ++ abstractRelativeFixedFieldFiniteDimensional ++ abstractFixedFieldRelativeScalarTower ++ abstractRelativeFixedFieldAbsoluteFiniteDimensional ++ abstractFixedFieldNumberField ++ abstractFixedFieldIdeleClassGroupIsMulCommutative ++ abstractRelativeFixedFieldNumberField ++ abstractRelativeFixedFieldIsGalois ++ abstractRelativeFixedFieldIsAbelianGalois ++ abstractFixedFieldIdeleClassNormRangeNormal + + /-- The ambient fixed-part reciprocity value vanishes precisely when its + finite norm class vanishes. -/ +@@ -1644,8 +197,7 @@ theorem abstractFixedFieldGlobalNormResidueMonoidHom_surjective : + rw [abstractFixedFieldGlobalNormResidueMonoidHom_fixed_apply, ha] + rfl + +-/-- The kernel of the fixed-field global norm-residue homomorphism is +-the genuine ordinary idele-class norm range. -/ ++ + @[simp] + theorem abstractFixedFieldGlobalNormResidueMonoidHom_ker : + (abstractFixedFieldGlobalNormResidueMonoidHom K L).ker = +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueEmbeddedReciprocity.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueEmbeddedReciprocity.lean +new file mode 100644 +index 0000000..c07e4ec +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueEmbeddedReciprocity.lean +@@ -0,0 +1,386 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.AbstractFixedFieldGlobalNormResidueNormClasses ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++section EmbeddedNumberFieldRealization ++ ++variable ++ (K L : Type) [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ ++ ++attribute [local instance] ++ numberFieldEmbeddedIdeleClassGroupIsMulCommutative ++ numberFieldEmbeddedIdeleClassSubgroupNormal ++ numberFieldEmbeddedExtensionSubgroupNormal ++ numberFieldEmbeddedExtensionQuotientFinite ++ numberFieldEmbeddedAbsoluteQuotientFinite ++ numberFieldEmbeddedAbstractFixedFieldFiniteDimensional ++ numberFieldEmbeddedAbstractRelativeFixedFieldFiniteDimensional ++ numberFieldEmbeddedAbstractFixedFieldScalarTower ++ numberFieldEmbeddedAbstractRelativeFixedFieldAbsoluteFiniteDimensional ++ numberFieldEmbeddedAbstractFixedFieldNumberField ++ numberFieldEmbeddedAbstractRelativeFixedFieldNumberField ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsFiniteDimensional ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsNumberField ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsAlgebra ++ numberFieldEmbeddedAbstractRelativeFixedFieldIsGalois ++ ++variable [FiniteDimensional K L] [IsAbelianGalois K L] ++ ++/-- The abelianized quotient of the explicitly embedded tower is the ++actual abelian Galois group. -/ ++noncomputable def ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Additive ++ (Abelianization ++ (numberFieldEmbeddedFiniteGaloisSubextension K L j).extensionQuotient) ≃+ ++ Additive Gal(L / K) := ++ MulEquiv.toAdditive ++ ((MulEquiv.abelianizationCongr ++ (numberFieldEmbeddedExtensionQuotientEquivGaloisGroup K L j)).trans ++ (Abelianization.equivOfComm : ++ Gal(L / K) ≃* ++ Abelianization Gal(L / K)).symm) ++ ++/-- The actual global norm-residue equivalence constructed from an ++explicit compatible embedding of a finite abelian number-field ++extension into the rational separable closure. -/ ++noncomputable def globalNormResidueEquivOfEmbedding ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Additive ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) ≃+ ++ Additive Gal(L / K) := by ++ let eNorm : ++ FiniteNormQuotient rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ≃+ ++ Additive ++ (Abelianization ++ (numberFieldEmbeddedFiniteGaloisSubextension K L j).extensionQuotient) := ++ rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K L j) ++ (numberFieldEmbeddedFiniteGaloisSubextension K L j) ++ exact ++ (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient ++ K L j).symm.trans ++ (eNorm.trans ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L j)) ++ ++/-- The explicit-embedding norm-residue equivalence on a finite norm class. -/ ++theorem globalNormResidueEquivOfEmbedding_finiteNormClass ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (x : FiniteNormQuotient rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) : ++ globalNormResidueEquivOfEmbedding K L j ++ (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient ++ K L j x) = ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup K L j ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K L j) ++ (numberFieldEmbeddedFiniteGaloisSubextension K L j) x) := by ++ simp only [globalNormResidueEquivOfEmbedding, AddEquiv.trans_apply, ++ AddEquiv.symm_apply_apply] ++ ++/-- The global norm-residue homomorphism obtained from an explicit ++compatible embedding. -/ ++noncomputable def globalNormResidueMonoidHomOfEmbedding ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ IdeleClassGroup K →* Gal(L / K) := by ++ let e : ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) ≃* ++ Gal(L / K) := ++ AddEquiv.toMultiplicative ++ (globalNormResidueEquivOfEmbedding K L j) ++ exact ++ e.toMonoidHom.comp ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm K L).range) ++ ++/-- Evaluation of the explicit-embedding global norm-residue map is ++the abstract norm-residue symbol evaluated on the corresponding genuine ++fixed-part finite norm class. -/ ++@[simp] ++theorem globalNormResidueMonoidHomOfEmbedding_apply ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (c : IdeleClassGroup K) : ++ globalNormResidueMonoidHomOfEmbedding K L j c = ++ Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L j ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K L j) ++ (numberFieldEmbeddedFiniteGaloisSubextension K L j) ++ (finiteNormClass rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K L j (Additive.ofMul c))))) := by ++ have hclass := ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass ++ K L j c ++ change ++ Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L j ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K L j) ++ (numberFieldEmbeddedFiniteGaloisSubextension K L j) ++ ((numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient ++ K L j).symm ++ (Additive.ofMul ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm K L).range c))))) = ++ _ ++ rw [← hclass, ++ (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient ++ K L j).symm_apply_apply] ++ ++omit [FiniteDimensional K L] [IsAbelianGalois K L] in ++ ++ ++theorem numberFieldTowerIdeleClassEquivAmbientFixed_eq_embedded_standard : ++ numberFieldTowerIdeleClassEquivAmbientFixed K L = ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed K L ++ (numberFieldSeparableClosureEmbedding L) := by ++ let j := numberFieldSeparableClosureEmbedding L ++ have hBase : ++ numberFieldTowerAbstractBaseFieldEquiv K L = ++ numberFieldEmbeddedAbstractBaseFieldEquiv K L j := by ++ rfl ++ unfold numberFieldTowerIdeleClassEquivAmbientFixed ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ rw [hBase] ++ dsimp only ++ congr 1 ++ ++/- At the chosen embedding, both constructions use the same fixed tower and ++abstract reciprocity data. We compare their values on the particular fixed ++idele class needed below; the two implementations of the finite norm-quotient ++equivalence are deliberately not compared as dependent structures. -/ ++private theorem numberFieldTowerNormResidueValue_eq_embedded_standard ++ (c : IdeleClassGroup K) : ++ numberFieldTowerAbelianizedExtensionQuotientEquivGaloisGroup K L ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldTowerReciprocityFiniteAbstractField K L) ++ (numberFieldTowerFiniteGaloisSubextension K L) ++ (finiteNormClass rationalIdeleClassRepresentation ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L) ++ (numberFieldTowerIdeleClassEquivAmbientFixed K L (Additive.ofMul c)))) = ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L (numberFieldSeparableClosureEmbedding L) ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K L ++ (numberFieldSeparableClosureEmbedding L)) ++ (numberFieldEmbeddedFiniteGaloisSubextension K L ++ (numberFieldSeparableClosureEmbedding L)) ++ (finiteNormClass rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L ++ (numberFieldSeparableClosureEmbedding L)) ++ (numberFieldEmbeddedTopSubgroup K L ++ (numberFieldSeparableClosureEmbedding L)) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L ++ (numberFieldSeparableClosureEmbedding L)) ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed K L ++ (numberFieldSeparableClosureEmbedding L) (Additive.ofMul c)))) := by ++ have hIdeleClassEquiv : ++ numberFieldTowerIdeleClassEquivAmbientFixed K L = ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed K L ++ (numberFieldSeparableClosureEmbedding L) := by ++ exact numberFieldTowerIdeleClassEquivAmbientFixed_eq_embedded_standard K L ++ have hFiniteAbstractField : ++ numberFieldTowerReciprocityFiniteAbstractField K L = ++ numberFieldEmbeddedFiniteAbstractField K L ++ (numberFieldSeparableClosureEmbedding L) := by ++ rfl ++ have hSubextension : ++ numberFieldTowerFiniteGaloisSubextension K L = ++ numberFieldEmbeddedFiniteGaloisSubextension K L ++ (numberFieldSeparableClosureEmbedding L) := by ++ rfl ++ have hGaloisComparison : ++ numberFieldTowerAbelianizedExtensionQuotientEquivGaloisGroup K L = ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L (numberFieldSeparableClosureEmbedding L) := by ++ rfl ++ simp only [← hGaloisComparison] ++ cases hFiniteAbstractField ++ cases hSubextension ++ rw [← hIdeleClassEquiv] ++ rfl ++ ++/-- At the standard embedding, the two global norm-residue equivalences ++agree on the actual norm quotient. The comparison is extensional: it uses ++surjectivity of the quotient map and the established evaluation formulas, ++not definitional equality of the two quotient constructions. -/ ++theorem globalNormResidueEquiv_eq_ofEmbedding_standard : ++ globalNormResidueEquiv K L = ++ globalNormResidueEquivOfEmbedding K L ++ (numberFieldSeparableClosureEmbedding L) := by ++ apply AddEquiv.ext ++ intro q ++ obtain ⟨c, hc⟩ := ++ QuotientGroup.mk'_surjective ++ (_root_.ideleClassNorm K L).range (Additive.toMul q) ++ have hq : ++ Additive.ofMul ++ (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c) = q := ++ Additive.toMul.injective hc ++ rw [← hq] ++ have hTower := ++ numberFieldTowerFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass ++ K L c ++ have hEmbedded := ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass ++ K L (numberFieldSeparableClosureEmbedding L) c ++ conv_lhs => ++ rw [← hTower, globalNormResidueEquiv_finiteNormClass] ++ conv_rhs => ++ rw [← hEmbedded, globalNormResidueEquivOfEmbedding_finiteNormClass] ++ exact numberFieldTowerNormResidueValue_eq_embedded_standard K L c ++ ++/-- The existing global norm-residue map is the explicit-embedding ++construction for the standard chosen embedding of the top field. -/ ++theorem globalNormResidueMonoidHom_eq_ofEmbedding_standard : ++ globalNormResidueMonoidHom K L = ++ globalNormResidueMonoidHomOfEmbedding K L ++ (numberFieldSeparableClosureEmbedding L) := by ++ apply MonoidHom.ext ++ intro c ++ apply Additive.toMul.injective ++ change ++ globalNormResidueEquiv K L ++ (Additive.ofMul ++ (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c)) = ++ globalNormResidueEquivOfEmbedding K L ++ (numberFieldSeparableClosureEmbedding L) ++ (Additive.ofMul ++ (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c)) ++ exact congrArg ++ (fun e : ++ Additive ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) ≃+ ++ Additive (Gal(L / K)) => ++ e (Additive.ofMul ++ (QuotientGroup.mk' (_root_.ideleClassNorm K L).range c))) ++ (globalNormResidueEquiv_eq_ofEmbedding_standard K L) ++ ++end EmbeddedNumberFieldRealization ++ ++section EmbeddedNumberFieldRestriction ++ ++variable ++ (K K' L L' : Type) ++ [Field K] [NumberField K] ++ [Field K'] [NumberField K'] ++ [Field L] [NumberField L] ++ [Field L'] [NumberField L'] ++ [Algebra K K'] [Algebra K L] [Algebra K L'] ++ [Algebra K' L'] [Algebra L L'] ++ [IsScalarTower K K' L'] [IsScalarTower K L L'] ++ ++/-- A compatible common embedding reverses the inclusion of the two base ++fields into an inclusion of their fixing subgroups. -/ ++theorem numberFieldEmbeddedBaseSubgroup_le_of_tower ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ let jLower : L →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ L L') ++ (numberFieldEmbeddedBaseSubgroup K' L' j).toSubgroup ≤ ++ (numberFieldEmbeddedBaseSubgroup K L jLower).toSubgroup := by ++ dsimp only ++ change ++ (numberFieldEmbeddedLowerEmbedding K' L' j).fieldRange.fixingSubgroup ≤ ++ (numberFieldEmbeddedLowerEmbedding K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).fieldRange.fixingSubgroup ++ apply ++ (numberFieldEmbeddedLowerEmbedding K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).fieldRange.fixingSubgroup_le ++ intro x hx ++ rcases hx with ⟨y, rfl⟩ ++ refine ⟨algebraMap K K' y, ?_⟩ ++ change ++ j (algebraMap K' L' (algebraMap K K' y)) = ++ j (algebraMap L L' (algebraMap K L y)) ++ rw [← IsScalarTower.algebraMap_apply K K' L', ++ ← IsScalarTower.algebraMap_apply K L L'] ++ ++omit [Field K] [NumberField K] ++ [Field K'] [NumberField K'] ++ [Algebra K K'] [Algebra K L] [Algebra K L'] [Algebra K' L'] ++ [IsScalarTower K K' L'] [IsScalarTower K L L'] in ++/-- A compatible common embedding reverses the inclusion of the two top ++fields into an inclusion of their fixing subgroups. -/ ++theorem numberFieldEmbeddedTopSubgroup_le_of_tower ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ let jLower : L →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ L L') ++ (numberFieldEmbeddedTopSubgroup K' L' j).toSubgroup ≤ ++ (numberFieldEmbeddedTopSubgroup K L jLower).toSubgroup := by ++ dsimp only ++ change ++ j.fieldRange.fixingSubgroup ≤ ++ (j.comp ++ (IsScalarTower.toAlgHom ℚ L L')).fieldRange.fixingSubgroup ++ apply ++ (j.comp ++ (IsScalarTower.toAlgHom ℚ L L')).fieldRange.fixingSubgroup_le ++ intro x hx ++ rcases hx with ⟨y, rfl⟩ ++ exact ⟨algebraMap L L' y, rfl⟩ ++ ++end EmbeddedNumberFieldRestriction ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueEmbeddings.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueEmbeddings.lean +new file mode 100644 +index 0000000..2451e8f +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueEmbeddings.lean +@@ -0,0 +1,586 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidue ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++/-- The algebra structure on the rational separable closure induced by a ++specified rational field embedding. It is deliberately not an instance: ++different embeddings of the same field need not induce definitionally equal ++algebra structures. -/ ++@[reducible] ++noncomputable def rationalEmbeddingSeparableClosureAlgebra ++ {F : Type} [Field F] [Algebra ℚ F] ++ (i : F →ₐ[ℚ] SeparableClosure ℚ) : ++ Algebra F (SeparableClosure ℚ) := ++ i.toRingHom.toAlgebra ++ ++/-- Two rational embeddings of the same number field into the fixed ++rational separable closure differ by an automorphism of that ++separable closure. -/ ++theorem exists_numberFieldEmbeddingComparisonAutomorphism ++ {F : Type} [Field F] [NumberField F] ++ (i j : F →ₐ[ℚ] SeparableClosure ℚ) : ++ ∃ σ : SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ, ++ ∀ x : F, σ (i x) = j x := by ++ let hAlgebra : Algebra F (SeparableClosure ℚ) := ++ rationalEmbeddingSeparableClosureAlgebra i ++ let hScalarTower : IsScalarTower ℚ F (SeparableClosure ℚ) := ++ IsScalarTower.of_algebraMap_eq' i.comp_algebraMap.symm ++ let hSeparable : Algebra.IsSeparable F (SeparableClosure ℚ) := ++ Algebra.isSeparable_tower_top_of_isSeparable ++ ℚ F (SeparableClosure ℚ) ++ obtain ⟨φ, hφ⟩ := ++ (IsSepClosed.surjective_domRestrict_of_isSeparable ++ (K := ℚ) (L := F) ++ (M := SeparableClosure ℚ) ++ (E := SeparableClosure ℚ)) j ++ let σ : SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := ++ AlgEquiv.ofBijective φ ++ (Normal.toIsAlgebraic.algHom_bijective₂ ++ φ (AlgHom.id ℚ (SeparableClosure ℚ))).1 ++ refine ⟨σ, ?_⟩ ++ intro x ++ have hx := ++ congrArg (fun ψ : F →ₐ[ℚ] SeparableClosure ℚ => ψ x) hφ ++ exact hx ++ ++/-- The canonical comparison automorphism between two rational ++embeddings of one number field into the fixed separable closure. -/ ++noncomputable def numberFieldEmbeddingComparisonAutomorphism ++ {F : Type} [Field F] [NumberField F] ++ (i j : F →ₐ[ℚ] SeparableClosure ℚ) : ++ SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ := ++ Classical.choose ++ (exists_numberFieldEmbeddingComparisonAutomorphism i j) ++ ++/-- The comparison automorphism carries the first embedded copy of the ++number field to the second one pointwise. -/ ++@[simp] ++theorem numberFieldEmbeddingComparisonAutomorphism_apply ++ {F : Type} [Field F] [NumberField F] ++ (i j : F →ₐ[ℚ] SeparableClosure ℚ) ++ (x : F) : ++ numberFieldEmbeddingComparisonAutomorphism i j (i x) = ++ j x := ++ Classical.choose_spec ++ (exists_numberFieldEmbeddingComparisonAutomorphism i j) x ++ ++/-- Conjugating the fixing subgroup of one embedded copy of a number ++field by the comparison automorphism gives the fixing subgroup of the ++other embedded copy. -/ ++theorem conjugateClosedFixingSubgroup_embeddingRange ++ {F : Type} [Field F] [NumberField F] ++ (i j : F →ₐ[ℚ] SeparableClosure ℚ) : ++ conjugateClosedSubgroup ++ (RamificationTheory.closedFixingSubgroup ++ ℚ (SeparableClosure ℚ) i.fieldRange) ++ (numberFieldEmbeddingComparisonAutomorphism j i) = ++ RamificationTheory.closedFixingSubgroup ++ ℚ (SeparableClosure ℚ) j.fieldRange := by ++ let s := ++ numberFieldEmbeddingComparisonAutomorphism j i ++ ext τ ++ change ++ τ ∈ conjugateClosedSubgroup ++ (closedFixingSubgroup ℚ (SeparableClosure ℚ) i.fieldRange) s ↔ ++ τ ∈ closedFixingSubgroup ℚ (SeparableClosure ℚ) j.fieldRange ++ rw [conjugateClosedSubgroup_mem] ++ change ++ s * τ * s⁻¹ ∈ i.fieldRange.fixingSubgroup ↔ ++ τ ∈ j.fieldRange.fixingSubgroup ++ rw [IntermediateField.mem_fixingSubgroup_iff, ++ IntermediateField.mem_fixingSubgroup_iff] ++ constructor ++ · intro h x hx ++ rcases hx with ⟨y, rfl⟩ ++ have hi := h (i y) ⟨y, rfl⟩ ++ have hs : ++ s (j y) = i y := ++ numberFieldEmbeddingComparisonAutomorphism_apply j i y ++ change s (τ (s.symm (i y))) = i y at hi ++ have hpre : s.symm (i y) = j y := by ++ rw [← hs, s.symm_apply_apply] ++ rw [hpre, ← hs] at hi ++ exact s.injective hi ++ · intro h x hx ++ rcases hx with ⟨y, rfl⟩ ++ have hj := h (j y) ⟨y, rfl⟩ ++ have hs : ++ s (j y) = i y := ++ numberFieldEmbeddingComparisonAutomorphism_apply j i y ++ change s (τ (s.symm (i y))) = i y ++ have hpre : s.symm (i y) = j y := by ++ rw [← hs, s.symm_apply_apply] ++ rw [hpre, hj, hs] ++ ++section EmbeddedNumberFieldRealization ++ ++local instance numberFieldEmbeddedIdeleClassGroupIsMulCommutative ++ {F : Type} [Field F] [NumberField F] ++ : IsMulCommutative (IdeleClassGroup F) := ++ ⟨⟨fun a b => mul_comm a b⟩⟩ ++ ++local instance numberFieldEmbeddedIdeleClassSubgroupNormal ++ {F : Type} [Field F] [NumberField F] ++ (N : Subgroup (IdeleClassGroup F)) : N.Normal := ++ N.normal_of_isMulCommutative ++ ++variable ++ (K L : Type) [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ ++/-- The lower embedding obtained by restricting an explicitly supplied ++embedding of the top field into the rational separable closure. -/ ++noncomputable def numberFieldEmbeddedLowerEmbedding ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ K →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ K L) ++ ++/-- The exact algebra structure on the rational separable closure induced by ++the lower embedding of an explicitly embedded number-field tower. Keeping ++this as a reducible definition lets every use of the associated separable- ++closure equivalence share one definitionally identical algebra structure. -/ ++@[reducible] ++noncomputable def numberFieldEmbeddedSeparableClosureAlgebra ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Algebra K (SeparableClosure ℚ) := ++ rationalEmbeddingSeparableClosureAlgebra ++ (numberFieldEmbeddedLowerEmbedding K L j) ++ ++/-- The fixing subgroup of the explicitly embedded lower field. -/ ++abbrev numberFieldEmbeddedBaseSubgroup ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ ClosedSubgroup ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedLowerEmbedding K L j).fieldRange ++ ++/-- The fixing subgroup of the explicitly embedded top field. -/ ++abbrev numberFieldEmbeddedTopSubgroup ++ (_K L : Type) [Field L] [NumberField L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ ClosedSubgroup ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) j.fieldRange ++ ++/-- The top fixing subgroup lies in the lower fixing subgroup. -/ ++theorem numberFieldEmbeddedTopSubgroup_le_baseSubgroup ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ (numberFieldEmbeddedTopSubgroup K L j).toSubgroup ≤ ++ (numberFieldEmbeddedBaseSubgroup K L j).toSubgroup := by ++ change ++ j.fieldRange.fixingSubgroup ≤ ++ (numberFieldEmbeddedLowerEmbedding K L j).fieldRange.fixingSubgroup ++ apply ++ (numberFieldEmbeddedLowerEmbedding K L j).fieldRange.fixingSubgroup_le ++ intro x hx ++ rcases hx with ⟨y, rfl⟩ ++ exact ⟨algebraMap K L y, rfl⟩ ++ ++/-- The separable closure of the actual lower field, identified with ++the rational separable closure carrying the algebra structure induced ++by an explicit compatible embedding. -/ ++noncomputable def numberFieldEmbeddedSeparableClosureEquiv ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ letI : Algebra K (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra K L j ++ SeparableClosure K ≃ₐ[K] SeparableClosure ℚ := by ++ letI : Algebra K (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra K L j ++ letI hScalarTower : IsScalarTower ℚ K (SeparableClosure ℚ) := ++ IsScalarTower.of_algebraMap_eq' ++ (numberFieldEmbeddedLowerEmbedding K L j).comp_algebraMap.symm ++ letI hseparable : Algebra.IsSeparable K (SeparableClosure ℚ) := ++ Algebra.isSeparable_tower_top_of_isSeparable ++ ℚ K (SeparableClosure ℚ) ++ letI hSepClosure : IsSepClosure K (SeparableClosure ℚ) := ++ ⟨IsSepClosure.sep_closed ℚ, hseparable⟩ ++ exact ++ IsSepClosure.equiv K ++ (SeparableClosure K) (SeparableClosure ℚ) ++ ++/-- The relative subgroup arising from an explicit compatible ++number-field embedding is normal. -/ ++theorem numberFieldEmbeddedExtensionSubgroup_normal ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).Normal := by ++ let i := numberFieldEmbeddedLowerEmbedding K L j ++ let hAlgebra : Algebra K (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra K L j ++ let e := numberFieldEmbeddedSeparableClosureEquiv K L j ++ change ++ (CyclicCohomology.extensionSubgroup ++ (closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange i)) ++ (closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange j)) _).Normal ++ exact ambientEmbeddedExtensionSubgroup_normal ℚ K L j e ++ ++/-- The normality witness for an explicitly embedded tower, registered at ++the precise subgroup used by the downstream quotient constructions. -/ ++noncomputable local instance ++ numberFieldEmbeddedExtensionSubgroupNormal ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K L j ++ ++/-- The relative quotient arising from an explicit compatible ++number-field embedding is finite. -/ ++theorem numberFieldEmbeddedExtensionQuotient_finite ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Finite ++ ((numberFieldEmbeddedBaseSubgroup K L j).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := by ++ let i := numberFieldEmbeddedLowerEmbedding K L j ++ let hAlgebra : Algebra K (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra K L j ++ let e := numberFieldEmbeddedSeparableClosureEquiv K L j ++ change ++ Finite ++ ((closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange i)).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange i)) ++ (closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange j)) _) ++ exact ambientEmbeddedExtensionQuotient_finite ℚ K L j e ++ ++/-- The relative-index witness for an explicitly embedded tower, registered ++at the exact quotient consumed by `FiniteNormQuotient`. -/ ++noncomputable local instance ++ numberFieldEmbeddedExtensionQuotientFinite ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Finite ++ ((numberFieldEmbeddedBaseSubgroup K L j).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := ++ numberFieldEmbeddedExtensionQuotient_finite K L j ++ ++/-- The finite abstract field determined by the lower member of an ++explicitly embedded number-field tower. -/ ++noncomputable abbrev numberFieldEmbeddedFiniteAbstractField ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) where ++ field := numberFieldEmbeddedBaseSubgroup K L j ++ finite := by ++ simpa only [numberFieldEmbeddedBaseSubgroup] using ++ (ambientEmbeddedAbsoluteQuotientFinite ++ ℚ K (numberFieldEmbeddedLowerEmbedding K L j)) ++ ++/-- The absolute-index witness for the lower member of an explicitly embedded ++tower, registered at its specialized quotient type. -/ ++noncomputable local instance ++ numberFieldEmbeddedAbsoluteQuotientFinite ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (le_baseField ++ (numberFieldEmbeddedBaseSubgroup K L j))) := ++ (numberFieldEmbeddedFiniteAbstractField K L j).finite ++ ++/-- The finite Galois subextension determined by an explicitly embedded ++number-field tower. -/ ++noncomputable abbrev numberFieldEmbeddedFiniteGaloisSubextension ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteGaloisSubextension ++ (numberFieldEmbeddedBaseSubgroup K L j) where ++ field := numberFieldEmbeddedTopSubgroup K L j ++ below := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j ++ normal := numberFieldEmbeddedExtensionSubgroup_normal K L j ++ finite := numberFieldEmbeddedExtensionQuotient_finite K L j ++ ++/-- Shared finite-dimensional data for the fixed field of the lower subgroup ++in an explicitly embedded number-field tower. -/ ++noncomputable local instance ++ numberFieldEmbeddedAbstractFixedFieldFiniteDimensional ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteDimensional ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) := ++ abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedAbsoluteQuotientFinite K L j) ++ ++/-- Shared relative finite-dimensional data for the two fixed fields of an ++explicitly embedded number-field tower. -/ ++noncomputable local instance ++ numberFieldEmbeddedAbstractRelativeFixedFieldFiniteDimensional ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteDimensional ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := ++ abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ++ (numberFieldEmbeddedAbsoluteQuotientFinite K L j) ++ (numberFieldEmbeddedExtensionQuotientFinite K L j) ++ ++local instance numberFieldEmbeddedAbstractFixedFieldScalarTower ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ IsScalarTower ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := ++ IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) ++ ++noncomputable local instance ++ numberFieldEmbeddedAbstractRelativeFixedFieldAbsoluteFiniteDimensional ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteDimensional ℚ ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := ++ FiniteDimensional.trans ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) ++ ++noncomputable local instance ++ numberFieldEmbeddedAbstractFixedFieldNumberField ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ NumberField ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) := ++ NumberField.of_module_finite ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) ++ ++noncomputable local instance ++ numberFieldEmbeddedAbstractRelativeFixedFieldNumberField ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ NumberField ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := ++ NumberField.of_module_finite ℚ ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) ++ ++noncomputable local instance ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsFiniteDimensional ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteDimensional ℚ ++ ((abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).restrictScalars ℚ) := by ++ change FiniteDimensional ℚ ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) ++ infer_instance ++ ++noncomputable local instance ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsNumberField ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ NumberField ++ ((abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).restrictScalars ℚ) := ++ NumberField.of_module_finite ℚ _ ++ ++noncomputable local instance ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsAlgebra ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Algebra ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) ++ ((abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)).restrictScalars ℚ) := ++ (IntermediateField.inclusion ++ (abstractFixedField_le ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j))).toRingHom.toAlgebra ++ ++noncomputable local instance ++ numberFieldEmbeddedAbstractRelativeFixedFieldIsGalois ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ IsGalois ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) := ++ abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ++ (numberFieldEmbeddedExtensionSubgroupNormal K L j) ++ ++/-- The quotient of the two explicitly embedded fixing subgroups is ++the actual relative Galois group. -/ ++noncomputable def ++ numberFieldEmbeddedExtensionQuotientEquivGaloisGroup ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ (numberFieldEmbeddedFiniteGaloisSubextension K L j).extensionQuotient ≃* ++ Gal(L / K) := by ++ let i := numberFieldEmbeddedLowerEmbedding K L j ++ letI hAlgebra : Algebra K (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra K L j ++ let e := numberFieldEmbeddedSeparableClosureEquiv K L j ++ let H₀ := ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange i) ++ let J₀ := ++ closedFixingSubgroup ℚ (SeparableClosure ℚ) ++ (AlgHom.fieldRange j) ++ let hJH : J₀.toSubgroup ≤ H₀.toSubgroup := by ++ change j.fieldRange.fixingSubgroup ≤ i.fieldRange.fixingSubgroup ++ apply i.fieldRange.fixingSubgroup_le ++ intro x hx ++ rcases hx with ⟨y, rfl⟩ ++ exact ⟨algebraMap K L y, rfl⟩ ++ letI : (CyclicCohomology.extensionSubgroup H₀ J₀ hJH).Normal := ++ ambientEmbeddedExtensionSubgroup_normal ℚ K L j e ++ change ++ (H₀.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H₀ J₀ hJH) ≃* ++ Gal(L / K) ++ exact ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ K L j e ++ ++/-- The original lower field is canonically equivalent to the fixed ++field of its explicitly embedded fixing subgroup. -/ ++noncomputable def numberFieldEmbeddedAbstractBaseFieldEquiv ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ K ≃ₐ[ℚ] ++ abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j) := ++ (numberFieldEmbeddedLowerEmbedding K L j).equivFieldRange.trans ++ (IntermediateField.equivOfEq ++ (InfiniteGalois.fixedField_fixingSubgroup ++ (numberFieldEmbeddedLowerEmbedding K L j).fieldRange).symm) ++ ++/-- The original top field is canonically equivalent to the relative ++fixed field of its explicitly embedded fixing subgroup. -/ ++noncomputable def numberFieldEmbeddedAbstractTopFieldEquiv ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ L ≃ₐ[ℚ] ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup ++ K L j)).restrictScalars ℚ := ++ j.equivFieldRange.trans ++ (IntermediateField.equivOfEq ++ (InfiniteGalois.fixedField_fixingSubgroup j.fieldRange).symm) ++ ++/-- The two explicit fixed-field equivalences commute with the tower ++algebra maps. -/ ++@[simp] ++theorem numberFieldEmbeddedAbstractFieldEquiv_algebraMap ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (x : K) : ++ numberFieldEmbeddedAbstractTopFieldEquiv K L j ++ (algebraMap K L x) = ++ algebraMap ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L j)) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j)) ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j x) := by ++ apply Subtype.ext ++ rfl ++ ++/-- The ordinary idele class group of the explicitly embedded lower ++field, transported to the fixed part of the rational absolute ++idele-class representation. -/ ++noncomputable def numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ Additive (IdeleClassGroup K) ≃+ ++ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) := by ++ let H := numberFieldEmbeddedBaseSubgroup K L j ++ exact ++ (MulEquiv.toAdditive ++ (ideleClassCongr ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j))).trans ++ (rationalAbstractFixedFieldIdeleClassEquivFixed H) ++ ++/-- The abstract finite norm quotient of an explicitly embedded tower ++is its genuine ordinary idele-class norm quotient. -/ ++noncomputable def ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteNormQuotient rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ≃+ ++ Additive ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) := by ++ let hnormal := ++ numberFieldEmbeddedExtensionSubgroupNormal K L j ++ let H := numberFieldEmbeddedBaseSubgroup K L j ++ let J := numberFieldEmbeddedTopSubgroup K L j ++ let hJH := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j ++ let fixedFieldEquiv := ++ rationalFiniteNormQuotientEquivIdeleClassNormQuotient ++ H J hJH hnormal ++ let actualFieldEquiv := ++ ordinaryIdeleClassNormQuotientCongrOfAlgEquiv ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractTopFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) ++ exact ++ fixedFieldEquiv.trans ++ (MulEquiv.toAdditive actualFieldEquiv.symm) ++ ++ ++end EmbeddedNumberFieldRealization ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueFixedFields.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueFixedFields.lean +new file mode 100644 +index 0000000..7520ff3 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueFixedFields.lean +@@ -0,0 +1,359 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.AbstractFixedFieldGlobalNormResidueEmbeddedReciprocity ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++ ++variable ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (L : FiniteAbelianSubextension K.field) ++ ++local instance abstractFixedFieldBaseQuotientFinite : ++ Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ K.field (le_baseField K.field)) := ++ K.finite ++ ++local instance abstractFixedFieldRelativeQuotientFinite : ++ Finite ++ (K.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup K.field L.field L.below) := ++ L.finite ++ ++local instance abstractFixedFieldRelativeQuotientIsMulCommutative : ++ IsMulCommutative L.extensionQuotient := ++ L.commutative ++ ++noncomputable local instance abstractFixedFieldFiniteDimensional : ++ FiniteDimensional ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) := ++ abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) K.field K.finite ++ ++noncomputable local instance abstractRelativeFixedFieldFiniteDimensional : ++ FiniteDimensional ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) := ++ abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ K.field L.field L.below K.finite L.finite ++ ++local instance abstractFixedFieldRelativeScalarTower : ++ IsScalarTower ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) := ++ IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) ++ ++noncomputable local instance abstractRelativeFixedFieldAbsoluteFiniteDimensional : ++ FiniteDimensional ℚ ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) := ++ FiniteDimensional.trans ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) ++ ++noncomputable local instance abstractFixedFieldNumberField : ++ NumberField ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) := ++ NumberField.of_module_finite ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) ++ ++/-- The lower fixed idèle-class group is commutative. Naming the mixin ++before the public quotient declarations avoids delayed normality synthesis ++inside their definition bodies. -/ ++local instance ++ abstractFixedFieldIdeleClassGroupIsMulCommutative : ++ IsMulCommutative ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field)) := ++ ⟨⟨fun a b => mul_comm a b⟩⟩ ++ ++noncomputable local instance abstractRelativeFixedFieldNumberField : ++ NumberField ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) := ++ NumberField.of_module_finite ℚ ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) ++ ++/-- Use the same explicit Galois witness as the fixed-field quotient ++comparison. Deriving it through `IsAbelianGalois` produces an equivalent ++but much larger dependent instance path. -/ ++noncomputable local instance ++ abstractRelativeFixedFieldIsGalois : ++ IsGalois ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) := ++ abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) ++ K.field L.field L.below L.normal ++ ++noncomputable local instance abstractRelativeFixedFieldIsAbelianGalois : ++ IsAbelianGalois ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) := ++ finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois L ++ ++/-- Use one opaque normality witness for the actual fixed-field norm range. ++This keeps every occurrence of its quotient group on the same instance path. -/ ++local instance ++ abstractFixedFieldIdeleClassNormRangeNormal : ++ ((_root_.ideleClassNorm ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below)).range).Normal := by ++ infer_instance ++ ++/-- The abelianized abstract extension quotient is the actual Galois ++group of the corresponding pair of fixed fields. -/ ++noncomputable def ++ abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below ++ Additive ++ (Abelianization ++ (FiniteGaloisSubextension.extensionQuotient ++ L.toFiniteGaloisExtension)) ≃+ ++ Additive (Gal(E / F)) := by ++ dsimp only ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below ++ let e : ++ L.extensionQuotient ≃* ++ Gal(E / F) := ++ L.extensionQuotientMulEquiv.trans ++ (abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) ++ K.field L.field L.below L.normal) ++ exact ++ MulEquiv.toAdditive ++ ((Abelianization.equivOfComm : ++ L.extensionQuotient ≃* ++ Abelianization L.extensionQuotient).symm.trans e) ++ ++/-- The actual fixed-field global norm-residue equivalence ++ ++`C_F / N_{E/F} C_E ≃ Gal(E/F)` ++ ++attached to an abstract finite abelian subextension in the rational ++absolute class formation. -/ ++noncomputable def abstractFixedFieldGlobalNormResidueEquiv : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below ++ Additive ++ (IdeleClassGroup F ⧸ ++ (_root_.ideleClassNorm F E).range) ≃+ ++ Additive (Gal(E / F)) := by ++ dsimp only ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below ++ let eNorm : ++ FiniteNormQuotient rationalIdeleClassRepresentation ++ K.field L.field L.below ≃+ ++ Additive ++ (Abelianization L.toFiniteGaloisExtension.extensionQuotient) := ++ rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ K L.toFiniteGaloisExtension ++ exact ++ (rationalFiniteNormQuotientEquivIdeleClassNormQuotient ++ K.field L.field L.below L.normal).symm.trans ++ (eNorm.trans ++ (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup ++ K L)) ++ ++/-- The abstract finite norm-residue equivalence with its dependent source ++instance fixed to the public finite norm quotient. -/ ++noncomputable def abstractFixedFieldFiniteNormResidueGaloisEquiv : ++ FiniteNormQuotient rationalIdeleClassRepresentation ++ K.field L.field L.below ≃+ ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field))) := by ++ letI : AddCommGroup ++ (FiniteNormQuotient rationalIdeleClassRepresentation ++ K.field L.field L.below) := ++ finiteNormQuotientAddCommGroup rationalIdeleClassRepresentation ++ K.field L.field L.below ++ exact ++ @AddEquiv.trans ++ (FiniteNormQuotient rationalIdeleClassRepresentation ++ K.field L.field L.below) ++ (Additive ++ (Abelianization ++ L.toFiniteGaloisExtension.extensionQuotient)) ++ (Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) K.field)))) ++ inferInstance inferInstance inferInstance ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ K L.toFiniteGaloisExtension) ++ (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup ++ K L) ++ ++/-- The abstract norm-residue symbol on the fixed part of the rational ++absolute idele-class representation, with its value transported to the ++actual Galois group of the two fixed fields. This is the form consumed ++directly by the abstract norm--restriction naturality theorem. -/ ++noncomputable def ambientFixedGlobalNormResidueAddMonoidHom : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below ++ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation K.field →+ ++ Additive (Gal(E / F)) := by ++ dsimp only ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below ++ exact ++ (abstractFixedFieldFiniteNormResidueGaloisEquiv K L).toAddMonoidHom.comp ++ (finiteNormClassHom rationalIdeleClassRepresentation ++ K.field L.field L.below) ++ ++/-- The ordinary idele class group of the lower fixed field, transported ++to the fixed part of the rational absolute idele-class representation. -/ ++private noncomputable def abstractFixedFieldIdeleClassToAmbientFixedMonoidHom : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ IdeleClassGroup F →* ++ Multiplicative ++ (ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation K.field) := ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ K.field).toAddMonoidHom.toMultiplicativeRight ++ ++/-- The actual norm-residue homomorphism on the ordinary idele class ++group of the lower fixed field, constructed without choosing a second ++field embedding. -/ ++noncomputable def abstractFixedFieldGlobalNormResidueMonoidHom : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) L.below ++ IdeleClassGroup F →* Gal(E / F) := ++ (ambientFixedGlobalNormResidueAddMonoidHom K L).toMultiplicative.comp ++ (abstractFixedFieldIdeleClassToAmbientFixedMonoidHom K) ++ ++/-- Pointwise form of the ambient fixed-part norm-residue homomorphism. -/ ++theorem ambientFixedGlobalNormResidueAddMonoidHom_apply ++ (a : ++ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation K.field) : ++ ambientFixedGlobalNormResidueAddMonoidHom K L a = ++ abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup ++ K L ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ K L.toFiniteGaloisExtension ++ (finiteNormClass rationalIdeleClassRepresentation ++ K.field L.field L.below a)) := by ++ change ++ abstractFixedFieldFiniteNormResidueGaloisEquiv K L ++ (finiteNormClass rationalIdeleClassRepresentation ++ K.field L.field L.below a) = _ ++ rfl ++ ++/-- Pointwise form of the transported fixed-field norm-residue homomorphism. -/ ++private theorem abstractFixedFieldGlobalNormResidueMonoidHom_apply : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) K.field ++ ∀ c : IdeleClassGroup F, ++ abstractFixedFieldGlobalNormResidueMonoidHom K L c = ++ Additive.toMul ++ (ambientFixedGlobalNormResidueAddMonoidHom K L ++ ((rationalAbstractFixedFieldIdeleClassEquivFixed K.field) ++ (Additive.ofMul c))) := by ++ dsimp only ++ intro c ++ rfl ++ ++/-- Transporting an ordinary fixed-field idele class to the ambient ++fixed part and applying the abstract norm-residue map gives exactly the ++actual fixed-field norm-residue value. -/ ++@[simp] ++theorem abstractFixedFieldGlobalNormResidueMonoidHom_fixed_apply ++ (a : ++ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation K.field) : ++ abstractFixedFieldGlobalNormResidueMonoidHom K L ++ (Additive.toMul ++ ((rationalAbstractFixedFieldIdeleClassEquivFixed ++ K.field).symm a)) = ++ Additive.toMul ++ (ambientFixedGlobalNormResidueAddMonoidHom K L a) := by ++ rw [abstractFixedFieldGlobalNormResidueMonoidHom_apply] ++ change ++ Additive.toMul ++ (ambientFixedGlobalNormResidueAddMonoidHom K L ++ ((rationalAbstractFixedFieldIdeleClassEquivFixed K.field) ++ ((rationalAbstractFixedFieldIdeleClassEquivFixed ++ K.field).symm a))) = ++ Additive.toMul ++ (ambientFixedGlobalNormResidueAddMonoidHom K L a) ++ rw [(rationalAbstractFixedFieldIdeleClassEquivFixed ++ K.field).apply_symm_apply] ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueNormClasses.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueNormClasses.lean +new file mode 100644 +index 0000000..9a8db28 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/AbstractFixedFieldGlobalNormResidueNormClasses.lean +@@ -0,0 +1,294 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.AbstractFixedFieldGlobalNormResidueEmbeddings ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++section EmbeddedNumberFieldRealization ++ ++variable ++ (K L : Type) [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ ++ ++attribute [local instance] ++ numberFieldEmbeddedIdeleClassGroupIsMulCommutative ++ numberFieldEmbeddedIdeleClassSubgroupNormal ++ numberFieldEmbeddedExtensionSubgroupNormal ++ numberFieldEmbeddedExtensionQuotientFinite ++ numberFieldEmbeddedAbsoluteQuotientFinite ++ numberFieldEmbeddedAbstractFixedFieldFiniteDimensional ++ numberFieldEmbeddedAbstractRelativeFixedFieldFiniteDimensional ++ numberFieldEmbeddedAbstractFixedFieldScalarTower ++ numberFieldEmbeddedAbstractRelativeFixedFieldAbsoluteFiniteDimensional ++ numberFieldEmbeddedAbstractFixedFieldNumberField ++ numberFieldEmbeddedAbstractRelativeFixedFieldNumberField ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsFiniteDimensional ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsNumberField ++ numberFieldEmbeddedAbstractRelativeFixedFieldRestrictScalarsAlgebra ++ numberFieldEmbeddedAbstractRelativeFixedFieldIsGalois ++ ++private theorem numberFieldEmbeddedOrdinaryNormQuotientCongr_symm_mk ++ {K₀ L₀ K₁ L₁ : Type} ++ [Field K₀] [NumberField K₀] ++ [Field L₀] [NumberField L₀] [Algebra K₀ L₀] ++ [Field K₁] [NumberField K₁] ++ [Field L₁] [NumberField L₁] [Algebra K₁ L₁] ++ (eK : K₀ ≃ₐ[ℚ] K₁) ++ (eL : L₀ ≃ₐ[ℚ] L₁) ++ (h : ∀ x : K₀, ++ eL (algebraMap K₀ L₀ x) = ++ algebraMap K₁ L₁ (eK x)) ++ (c : IdeleClassGroup K₁) : ++ (ordinaryIdeleClassNormQuotientCongrOfAlgEquiv eK eL h).symm ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm K₁ L₁).range c) = ++ QuotientGroup.mk' ++ (_root_.ideleClassNorm K₀ L₀).range ++ ((ideleClassCongr eK).symm c) := by ++ let e := ordinaryIdeleClassNormQuotientCongrOfAlgEquiv eK eL h ++ apply e.injective ++ rw [e.apply_symm_apply, ++ ordinaryIdeleClassNormQuotientCongrOfAlgEquiv_mk, ++ MulEquiv.apply_symm_apply] ++ ++private noncomputable def numberFieldEmbeddedFiniteNormClassPublicValue ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ Additive ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) := ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient ++ K L j ++ (finiteNormClass rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ++ a) ++ ++private noncomputable def numberFieldEmbeddedFiniteNormClassExpectedValue ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ Additive ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) := ++ Additive.ofMul ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm K L).range ++ (Additive.toMul ++ ((numberFieldEmbeddedIdeleClassEquivAmbientFixed K L j).symm a))) ++ ++private noncomputable def ++ numberFieldEmbeddedFiniteNormClassDirectComparisonValue ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ Additive ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) := by ++ let hnormal := ++ numberFieldEmbeddedExtensionSubgroupNormal K L j ++ let H := numberFieldEmbeddedBaseSubgroup K L j ++ let J := numberFieldEmbeddedTopSubgroup K L j ++ let hJH := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j ++ let fixedFieldEquiv := ++ rationalFiniteNormQuotientEquivIdeleClassNormQuotient ++ H J hJH hnormal ++ let actualFieldEquiv := ++ ordinaryIdeleClassNormQuotientCongrOfAlgEquiv ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractTopFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) ++ exact ++ MulEquiv.toAdditive actualFieldEquiv.symm ++ (fixedFieldEquiv ++ (finiteNormClass rationalIdeleClassRepresentation ++ H J hJH a)) ++ ++private theorem ++ numberFieldEmbeddedFiniteNormClassPublicValue_eq_directComparison ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ numberFieldEmbeddedFiniteNormClassPublicValue K L j a = ++ numberFieldEmbeddedFiniteNormClassDirectComparisonValue K L j a := by ++ unfold numberFieldEmbeddedFiniteNormClassPublicValue ++ unfold numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient ++ unfold numberFieldEmbeddedFiniteNormClassDirectComparisonValue ++ rfl ++ ++private noncomputable def numberFieldEmbeddedActualNormClassRepresentativeValue ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ Additive ++ (IdeleClassGroup K ⧸ ++ (_root_.ideleClassNorm K L).range) := by ++ let H := numberFieldEmbeddedBaseSubgroup K L j ++ let hJH := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j ++ let F := abstractFixedField ℚ (SeparableClosure ℚ) H ++ let E := abstractRelativeFixedField ℚ (SeparableClosure ℚ) hJH ++ let actualFieldEquiv := ++ ordinaryIdeleClassNormQuotientCongrOfAlgEquiv ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractTopFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) ++ exact ++ Additive.ofMul ++ (actualFieldEquiv.symm ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm F E).range ++ (Additive.toMul ++ ((rationalAbstractFixedFieldIdeleClassEquivFixed H).symm a)))) ++ ++private theorem ++ numberFieldEmbeddedFiniteNormClassDirectComparison_eq_actualValue ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ numberFieldEmbeddedFiniteNormClassDirectComparisonValue K L j a = ++ numberFieldEmbeddedActualNormClassRepresentativeValue K L j a := by ++ let hnormal := numberFieldEmbeddedExtensionSubgroupNormal K L j ++ let H := numberFieldEmbeddedBaseSubgroup K L j ++ let J := numberFieldEmbeddedTopSubgroup K L j ++ let hJH := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j ++ let actualFieldEquiv := ++ ordinaryIdeleClassNormQuotientCongrOfAlgEquiv ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractTopFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) ++ have hfixed := ++ rationalFiniteNormQuotientEquivIdeleClassNormQuotient_finiteNormClass ++ H J hJH hnormal a ++ unfold numberFieldEmbeddedFiniteNormClassDirectComparisonValue ++ unfold numberFieldEmbeddedActualNormClassRepresentativeValue ++ exact congrArg (MulEquiv.toAdditive actualFieldEquiv.symm) hfixed ++ ++private theorem numberFieldEmbeddedActualNormClassRepresentativeValue_eq_expected ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ numberFieldEmbeddedActualNormClassRepresentativeValue K L j a = ++ numberFieldEmbeddedFiniteNormClassExpectedValue K L j a := by ++ let H := numberFieldEmbeddedBaseSubgroup K L j ++ let hJH := numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j ++ let F := abstractFixedField ℚ (SeparableClosure ℚ) H ++ let E := abstractRelativeFixedField ℚ (SeparableClosure ℚ) hJH ++ let actualFieldEquiv := ++ ordinaryIdeleClassNormQuotientCongrOfAlgEquiv ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractTopFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) ++ let c : IdeleClassGroup F := ++ Additive.toMul ++ ((rationalAbstractFixedFieldIdeleClassEquivFixed H).symm a) ++ unfold numberFieldEmbeddedActualNormClassRepresentativeValue ++ unfold numberFieldEmbeddedFiniteNormClassExpectedValue ++ change ++ Additive.ofMul ++ (actualFieldEquiv.symm ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm F E).range c)) = ++ Additive.ofMul ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm K L).range ++ ((ideleClassCongr ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j)).symm c)) ++ exact ++ congrArg Additive.ofMul ++ (numberFieldEmbeddedOrdinaryNormQuotientCongr_symm_mk ++ (numberFieldEmbeddedAbstractBaseFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractTopFieldEquiv K L j) ++ (numberFieldEmbeddedAbstractFieldEquiv_algebraMap K L j) c) ++ ++/-- On a finite norm-class representative, the explicit fixed-field ++comparison is the genuine ordinary idele-class quotient. -/ ++@[simp] ++theorem ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_finiteNormClass ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (a : ambientFixedAddSubgroup rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j)) : ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient K L j ++ (finiteNormClass rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) a) = ++ Additive.ofMul ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm K L).range ++ (Additive.toMul ++ ((numberFieldEmbeddedIdeleClassEquivAmbientFixed K L j).symm a))) := by ++ change ++ numberFieldEmbeddedFiniteNormClassPublicValue K L j a = ++ numberFieldEmbeddedFiniteNormClassExpectedValue K L j a ++ exact ++ (numberFieldEmbeddedFiniteNormClassPublicValue_eq_directComparison ++ K L j a).trans ++ ((numberFieldEmbeddedFiniteNormClassDirectComparison_eq_actualValue ++ K L j a).trans ++ (numberFieldEmbeddedActualNormClassRepresentativeValue_eq_expected ++ K L j a)) ++ ++/-- On an ordinary idele class, the explicit fixed-part realization ++followed by the abstract finite norm-class map is the genuine quotient ++class modulo the ordinary idele-class norm. -/ ++@[simp] ++theorem ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_ideleClass ++ [FiniteDimensional K L] [IsGalois K L] ++ (j : L →ₐ[ℚ] SeparableClosure ℚ) ++ (c : IdeleClassGroup K) : ++ numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient K L j ++ (finiteNormClass rationalIdeleClassRepresentation ++ (numberFieldEmbeddedBaseSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup K L j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L j) ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K L j (Additive.ofMul c))) = ++ Additive.ofMul ++ (QuotientGroup.mk' ++ (_root_.ideleClassNorm K L).range c) := by ++ simpa only [AddEquiv.symm_apply_apply, toMul_ofMul] using ++ (numberFieldEmbeddedFiniteNormQuotientEquivIdeleClassNormQuotient_finiteNormClass ++ K L j ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K L j (Additive.ofMul c))) ++ ++ ++end EmbeddedNumberFieldRealization ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtin.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtin.lean +index d3e6e51..75c1574 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtin.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtin.lean +@@ -4,26 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicIdeleClassValuation +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.InfiniteGlobalArtin +-import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.MaximalUnramifiedReciprocity ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicAbstractFixedFieldArtinComparison + +-set_option autoImplicit false +- +-/-! +-# Cyclotomic Artin coordinates over abstract fixed fields + +-The cyclotomic degree datum on the rational absolute Galois group has +-an actual maximal-unramified field over every finite abstract fixed +-field. This file identifies its genuine Galois group with +-`Multiplicative ZHat`, using the normalized degree map, and supplies +-the abelian Galois structure needed by the actual infinite global +-Artin homomorphism. ++set_option autoImplicit false + +-These constructions are the source side of the comparison between +-abstract finite reciprocity and the chosen local-factor product. No +-reciprocity comparison is assumed in their definitions. +--/ + + open scoped IsMulCommutative NumberField + +@@ -35,2336 +20,11 @@ namespace Reciprocity + open ClassFormation + open KummerTheory + +-/-- Keep this module on the rational algebra structures used by the +-cyclotomic fixed-field API. Generic intermediate-field instances are +-propositionally equal here but not definitionally interchangeable. -/ +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra : +- Algebra ℚ (SeparableClosure ℚ) := +- DivisionRing.toRatAlgebra +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra : +- Algebra ℚ rationalCyclotomicZHatField := +- DivisionRing.toRatAlgebra +- +-/-- Cyclotomic field inertia is contained in the original abstract +-field subgroup. -/ +-theorem rationalCyclotomicFieldInertia_le +- (H : ClosedSubgroup +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- (rationalCyclotomicDegreeData.fieldInertia H).toSubgroup ≤ +- H.toSubgroup := by +- intro σ hσ +- exact hσ.1 +- +-/-- Viewing cyclotomic field inertia inside its ambient field subgroup +-gives exactly the kernel of normalized degree. -/ +-theorem extensionSubgroup_rationalCyclotomicFieldInertia +- (H : ClosedSubgroup +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- CyclicCohomology.extensionSubgroup H +- (rationalCyclotomicDegreeData.fieldInertia H) +- (rationalCyclotomicFieldInertia_le H) = +- rationalCyclotomicDegreeData.fieldInertiaWithin H := by +- ext σ +- rw [ +- mem_extensionSubgroup_iff, +- rationalCyclotomicDegreeData.mem_fieldInertiaWithin_iff, +- rationalCyclotomicDegreeData.mem_fieldInertia_iff] +- exact and_iff_right σ.2 +- +-/-- The actual Galois group of the cyclotomic maximal-unramified +-extension of an abstract fixed field, in its normalized `ZHat` +-coordinate. -/ +-noncomputable def abstractFixedFieldCyclotomicGalEquivZHat +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) ≃* +- Multiplicative ZHat := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- let qField : +- H.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI ≃* +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) := +- LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- let qInertia : +- H.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI ≃* +- H.field.toSubgroup ⧸ +- rationalCyclotomicDegreeData.fieldInertiaWithin H.field := +- QuotientGroup.quotientMulEquivOfEq +- (extensionSubgroup_rationalCyclotomicFieldInertia H.field) +- exact +- qField.symm.trans +- (qInertia.trans +- (rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData))) +- +-/-- On an absolute-Galois representative fixing the lower field, the +-actual cyclotomic Galois coordinate is its normalized degree. -/ +-@[simp] +-theorem abstractFixedFieldCyclotomicGalEquivZHat_extensionClass +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (σ : H.field.toSubgroup) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- abstractFixedFieldCyclotomicGalEquivZHat H +- (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- (QuotientGroup.mk σ)) = +- rationalCyclotomicDegreeData.normalizedDegree +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData) σ := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- let qField := +- LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- change +- (rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData)) +- (QuotientGroup.quotientMulEquivOfEq +- (extensionSubgroup_rationalCyclotomicFieldInertia H.field) +- (qField.symm (qField (QuotientGroup.mk σ)))) = +- rationalCyclotomicDegreeData.normalizedDegree +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData) σ +- rw [qField.symm_apply_apply] +- rfl +- +-/-- Quotient-level evaluation of the actual cyclotomic Galois +-coordinate. -/ +-@[simp] +-theorem abstractFixedFieldCyclotomicGalEquivZHat_quotientClass +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (q : +- H.field.toSubgroup ⧸ +- rationalCyclotomicDegreeData.fieldInertiaWithin H.field) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- let qInertia : +- H.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI ≃* +- H.field.toSubgroup ⧸ +- rationalCyclotomicDegreeData.fieldInertiaWithin H.field := +- QuotientGroup.quotientMulEquivOfEq +- (extensionSubgroup_rationalCyclotomicFieldInertia H.field) +- abstractFixedFieldCyclotomicGalEquivZHat H +- (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- (qInertia.symm q)) = +- rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData) q := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- let qField := +- LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- let qInertia : +- H.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI ≃* +- H.field.toSubgroup ⧸ +- rationalCyclotomicDegreeData.fieldInertiaWithin H.field := +- QuotientGroup.quotientMulEquivOfEq +- (extensionSubgroup_rationalCyclotomicFieldInertia H.field) +- change +- (rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData)) +- (qInertia +- (qField.symm +- (qField (qInertia.symm q)))) = +- rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData) q +- rw [qField.symm_apply_apply, qInertia.apply_symm_apply] +- +-/-- The extension fixed by cyclotomic field inertia is an actual +-abelian Galois extension of the lower abstract fixed field. -/ +-theorem abstractFixedFieldCyclotomic_isAbelianGalois +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- IsAbelianGalois +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- let : IsGalois +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) := +- LocalClassFieldTheory.abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- let e := +- abstractFixedFieldCyclotomicGalEquivZHat H +- exact +- { is_comm.comm := by +- intro σ τ +- apply e.injective +- simpa only [map_mul] using mul_comm (e σ) (e τ) } +- +-/-- The rational cyclotomic `ZHat`-field embedded in the actual +-maximal-unramified compositum of an abstract fixed field. -/ +-noncomputable def +- rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- rationalCyclotomicZHatField →ₐ[ℚ] +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let J := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- have hTJ : +- rationalCyclotomicZHatField ≤ J := by +- change +- rationalCyclotomicZHatField ≤ +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- rw [ +- rationalCyclotomicDegreeData_fixedField_fieldInertia] +- exact le_sup_right +- exact IntermediateField.inclusion hTJ +- +-noncomputable instance +- abstractFixedFieldCyclotomicCompositum_algebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- Algebra rationalCyclotomicZHatField +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) := +- ((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H).toRingHom).toAlgebra +- +-instance abstractFixedFieldCyclotomicCompositum_scalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- IsScalarTower ℚ rationalCyclotomicZHatField +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) := +- IsScalarTower.of_algebraMap_eq' +- ((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H).comp_algebraMap).symm +- +-instance abstractFixedFieldCyclotomicCompositum_baseScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- IsScalarTower ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- apply IsScalarTower.of_algebraMap_eq +- intro x +- apply Subtype.ext +- rfl +- +-/-- Restriction from the actual maximal-unramified compositum of an +-abstract fixed field to the rational cyclotomic factor. -/ +-noncomputable def abstractFixedFieldCyclotomicRestriction +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) →* +- Gal(rationalCyclotomicZHatField / ℚ) := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- exact +- IntermediateField.restrictRestrictAlgEquivMapHom +- ℚ rationalCyclotomicZHatField +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) +- +-/-- On a quotient representative, cyclotomic restriction of the +-actual relative automorphism is ordinary restriction of the same +-ambient absolute-Galois automorphism. -/ +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal : +- Normal ℚ rationalCyclotomicZHatField := +- rationalCyclotomicZHatField_isNormal +- +-@[simp] +-theorem abstractFixedFieldCyclotomicRestriction_extensionClass +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (σ : H.field.toSubgroup) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- abstractFixedFieldCyclotomicRestriction H +- (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- (QuotientGroup.mk σ)) = +- AlgEquiv.restrictNormalHom +- rationalCyclotomicZHatField σ.1 := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- let τ := +- LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- (QuotientGroup.mk' +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) hI) +- σ) +- apply AlgEquiv.ext +- intro x +- apply Subtype.ext +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- have hrestrict : +- algebraMap rationalCyclotomicZHatField U +- ((abstractFixedFieldCyclotomicRestriction H τ) x) = +- τ (algebraMap rationalCyclotomicZHatField U x) := by +- change +- algebraMap rationalCyclotomicZHatField U +- ((AlgEquiv.restrictNormal +- (MulSemiringAction.toAlgEquiv ℚ U τ) +- rationalCyclotomicZHatField) x) = +- (MulSemiringAction.toAlgEquiv ℚ U τ) +- (algebraMap rationalCyclotomicZHatField U x) +- exact +- AlgEquiv.restrictNormal_commutes +- (MulSemiringAction.toAlgEquiv ℚ U τ) +- rationalCyclotomicZHatField x +- have halgebraMap_eq_embedding +- (z : rationalCyclotomicZHatField) : +- algebraMap rationalCyclotomicZHatField U z = +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H z : U) := by +- rfl +- have hembedding_coe +- (z : rationalCyclotomicZHatField) : +- (((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H z : U) : SeparableClosure ℚ)) = +- (z : SeparableClosure ℚ) := by +- rfl +- have halgebraMap_coe +- (z : rationalCyclotomicZHatField) : +- ((algebraMap rationalCyclotomicZHatField U z : U) : +- SeparableClosure ℚ) = +- (z : SeparableClosure ℚ) := by +- rw [halgebraMap_eq_embedding] +- exact hembedding_coe z +- have hambient := +- LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup_mk_apply_val +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal σ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H x) +- calc +- (((abstractFixedFieldCyclotomicRestriction H τ) x : +- rationalCyclotomicZHatField) : +- SeparableClosure ℚ) = +- ((τ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H x) : +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) : +- SeparableClosure ℚ) := by +- calc +- (((abstractFixedFieldCyclotomicRestriction H τ) x : +- rationalCyclotomicZHatField) : SeparableClosure ℚ) = +- ((algebraMap rationalCyclotomicZHatField U +- ((abstractFixedFieldCyclotomicRestriction H τ) x) : U) : +- SeparableClosure ℚ) := +- (halgebraMap_coe +- ((abstractFixedFieldCyclotomicRestriction H τ) x)).symm +- _ = ((τ (algebraMap rationalCyclotomicZHatField U x) : U) : +- SeparableClosure ℚ) := +- congrArg (fun y : U => (y : SeparableClosure ℚ)) hrestrict +- _ = ((τ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H x) : U) : SeparableClosure ℚ) := by +- rw [halgebraMap_eq_embedding] +- _ = σ.1 (x : SeparableClosure ℚ) := by +- calc +- ((τ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H x) : U) : SeparableClosure ℚ) = +- σ.1 +- ((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H x : U) : SeparableClosure ℚ) := by +- simpa only [τ, U] using hambient.symm +- _ = σ.1 (x : SeparableClosure ℚ) := by +- rw [hembedding_coe] +- _ = +- (((AlgEquiv.restrictNormalHom +- rationalCyclotomicZHatField σ.1) x : +- rationalCyclotomicZHatField) : +- SeparableClosure ℚ) := by +- exact +- (AlgEquiv.restrictNormal_commutes +- σ.1 rationalCyclotomicZHatField x).symm +- +-/-- Raw cyclotomic restriction is residue-degree multiplication of +-the normalized actual Galois coordinate. -/ +-theorem +- abstractFixedFieldCyclotomicRestriction_coordinate +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (τ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) : +- Multiplicative.toAdd +- (rationalCyclotomicZHatFieldGalEquivZHat +- (abstractFixedFieldCyclotomicRestriction H τ)) = +- (H.residueDegree rationalCyclotomicDegreeData : ℕ) • +- Multiplicative.toAdd +- (abstractFixedFieldCyclotomicGalEquivZHat H τ) := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let hnormal : +- (CyclicCohomology.extensionSubgroup H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI).Normal := by +- rw [extensionSubgroup_rationalCyclotomicFieldInertia] +- infer_instance +- let qField := +- LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) H.field +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- hI hnormal +- obtain ⟨q, rfl⟩ := qField.surjective τ +- refine Quotient.inductionOn' q ?_ +- intro σ +- rw [ +- abstractFixedFieldCyclotomicRestriction_extensionClass, +- abstractFixedFieldCyclotomicGalEquivZHat_extensionClass] +- exact +- (rationalCyclotomicDegreeData.residueDegree_nsmul_normalizedDegree +- (H.toFiniteResidueAbstractField +- rationalCyclotomicDegreeData) σ).symm +- +-/-- The canonical compositum of an abstract fixed field with a finite +-layer of the rational cyclotomic `ZHat`-extension. -/ +-def abstractFixedFieldCyclotomicFiniteCompositum +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IntermediateField ℚ (SeparableClosure ℚ) := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field ⊔ +- IntermediateField.lift E.toIntermediateField +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteCompositum_finiteDimensional +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- FiniteDimensional ℚ +- (abstractFixedFieldCyclotomicFiniteCompositum H E) := by +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- let : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- let : FiniteDimensional ℚ +- (IntermediateField.lift E.toIntermediateField) := +- ((IntermediateField.liftAlgEquiv +- E.toIntermediateField).toLinearEquiv).finiteDimensional +- exact IntermediateField.finiteDimensional_sup +- F (IntermediateField.lift E.toIntermediateField) +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteCompositum_numberField +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- NumberField +- (abstractFixedFieldCyclotomicFiniteCompositum H E) := +- NumberField.of_module_finite ℚ +- (abstractFixedFieldCyclotomicFiniteCompositum H E) +- +-/-- The lower abstract fixed field embedded into its finite +-cyclotomic compositum. -/ +-noncomputable def +- abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field →ₐ[ℚ] +- abstractFixedFieldCyclotomicFiniteCompositum H E := +- IntermediateField.inclusion +- (show +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field ≤ +- abstractFixedFieldCyclotomicFiniteCompositum H E from +- le_sup_left) +- +-/-- The fixed field attached to a finite abstract field is a number +-field. Keeping this as the single file-local instance makes it +-available while later theorem binders are elaborated. -/ +-noncomputable local instance +- abstractFixedFieldCyclotomic_numberField +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- NumberField +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) := by +- let : FiniteDimensional ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- exact +- NumberField.of_module_finite ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- +-/-- A finite rational cyclotomic layer embedded into its compositum +-with the abstract fixed field. -/ +-noncomputable def +- abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- E →ₐ[ℚ] +- abstractFixedFieldCyclotomicFiniteCompositum H E := +- (IntermediateField.inclusion +- (show +- IntermediateField.lift E.toIntermediateField ≤ +- abstractFixedFieldCyclotomicFiniteCompositum H E from +- le_sup_right)).comp +- (IntermediateField.liftAlgEquiv E.toIntermediateField).toAlgHom +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteCompositum_baseAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteCompositum H E) := +- RingHom.toAlgebra +- (AlgHom.toRingHom +- (abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding H E)) +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteCompositum_layerAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra E +- (abstractFixedFieldCyclotomicFiniteCompositum H E) := +- RingHom.toAlgebra +- (AlgHom.toRingHom +- (abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding H E)) +- +-/-- The finite-layer action induced by its explicit embedding into the +-finite compositum. -/ +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteCompositum_layerSMul +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- SMul E +- (abstractFixedFieldCyclotomicFiniteCompositum H E) := +- Algebra.toSMul +- (self := +- abstractFixedFieldCyclotomicFiniteCompositum_layerAlgebra H E) +- +-instance +- abstractFixedFieldCyclotomicFiniteCompositum_baseScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteCompositum H E) := +- IsScalarTower.of_algebraMap_eq' +- (AlgHom.comp_algebraMap +- (abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding H E)).symm +- +-instance +- abstractFixedFieldCyclotomicFiniteCompositum_layerScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower ℚ E +- (abstractFixedFieldCyclotomicFiniteCompositum H E) := +- IsScalarTower.of_algebraMap_eq' +- (AlgHom.comp_algebraMap +- (abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding H E)).symm +- +-/-- Inclusion of the finite cyclotomic compositum into the actual +-maximal-unramified compositum. -/ +-noncomputable def +- abstractFixedFieldCyclotomicFiniteCompositumInclusion +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- abstractFixedFieldCyclotomicFiniteCompositum H E →ₐ[ℚ] +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let J := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicDegreeData.fieldInertia H.field) +- have hle : +- abstractFixedFieldCyclotomicFiniteCompositum H E ≤ J := by +- dsimp only [J] +- rw [ +- rationalCyclotomicDegreeData_fixedField_fieldInertia H.field] +- exact +- sup_le_sup le_rfl +- (IntermediateField.lift_le E.toIntermediateField) +- exact IntermediateField.inclusion hle +- +-/-- The same finite-compositum inclusion over the lower abstract fixed +-field. -/ +-noncomputable def +- abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- abstractFixedFieldCyclotomicFiniteCompositum H E →ₐ[ +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field] +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI := by +- let f := +- abstractFixedFieldCyclotomicFiniteCompositumInclusion H E +- exact +- { f.toRingHom with +- commutes' := by +- intro x +- rfl } +- +-/-- The finite cyclotomic compositum as an intermediate field of the +-actual maximal-unramified extension. -/ +-noncomputable def abstractFixedFieldCyclotomicFiniteLayer +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- IntermediateField +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) := +- (abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase H E).fieldRange +- +-/-- The base algebra on the finite field range, obtained from the +-explicit base embedding followed by the field-range equivalence. -/ +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- RingHom.toAlgebra +- ((AlgHom.toRingHom +- (AlgEquiv.toAlgHom +- (AlgHom.equivFieldRange +- (abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase +- H E)))).comp +- (AlgHom.toRingHom +- (abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding H E))) +- +-/-- The scalar action belonging to the canonical base algebra on the +-finite field range. -/ +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_baseSMul +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- SMul +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- Algebra.toSMul +- (self := abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra H E) +- +-/-- The module structure belonging to the canonical base algebra on +-the finite field range. -/ +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_baseModule +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Module +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- @Algebra.toModule +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- _ _ +- (abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra H E) +- +-/-- The field-range equivalence rebuilt over the explicit base +-algebras. Its underlying ring equivalence is the canonical one. -/ +-noncomputable def +- abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- abstractFixedFieldCyclotomicFiniteCompositum H E ≃ₐ[ +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field] +- abstractFixedFieldCyclotomicFiniteLayer H E := +- AlgEquiv.ofRingEquiv +- (f := +- (AlgHom.equivFieldRange +- (abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase +- H E)).toRingEquiv) +- (fun _ => rfl) +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_finiteDimensional +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- FiniteDimensional +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- (abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer +- H E).toLinearEquiv.finiteDimensional +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_numberField +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- NumberField +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- NumberField.of_module_finite +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsAbelianGalois +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let : IsAbelianGalois +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- exact +- IsAbelianGalois.of_algHom +- ((abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase +- H E).comp +- (AlgEquiv.toAlgHom +- (AlgEquiv.symm +- (abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer +- H E)))) +- +-instance +- abstractFixedFieldCyclotomicFiniteLayer_baseScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) := by +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- apply IsScalarTower.of_algebraMap_eq +- intro x +- apply Subtype.ext +- change +- algebraMap ℚ +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) x = +- algebraMap +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) +- (algebraMap ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) x) +- exact +- IsScalarTower.algebraMap_apply +- ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) x +- +-/-- The finite rational layer embedded into its corresponding +-intermediate field over the abstract fixed field. -/ +-noncomputable def +- abstractFixedFieldCyclotomicFiniteLayerEmbedding +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- E →ₐ[ℚ] +- abstractFixedFieldCyclotomicFiniteLayer H E := by +- exact +- (AlgEquiv.toAlgHom +- (AlgEquiv.restrictScalars ℚ +- (abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer +- H E))).comp +- (abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding H E) +- +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra E +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- RingHom.toAlgebra +- (AlgHom.toRingHom +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E)) +- +-/-- The finite-layer action on its actual image in the relative fixed +-field. -/ +-noncomputable instance +- abstractFixedFieldCyclotomicFiniteLayer_layerSMul +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- SMul E +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- Algebra.toSMul +- (self := abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra H E) +- +-instance +- abstractFixedFieldCyclotomicFiniteLayer_layerScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower ℚ E +- (abstractFixedFieldCyclotomicFiniteLayer H E) := +- IsScalarTower.of_algebraMap_eq' +- (AlgHom.comp_algebraMap +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E)).symm +- +-/-- The finite cyclotomic layer as an object of the finite-Galois +-inverse system of the actual maximal-unramified extension. -/ +-@[reducible] +-noncomputable def +- abstractFixedFieldCyclotomicFiniteGaloisLayer +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- FiniteGaloisIntermediateField +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field)) where +- toIntermediateField := +- abstractFixedFieldCyclotomicFiniteLayer H E +- finiteDimensional := +- abstractFixedFieldCyclotomicFiniteLayer_finiteDimensional H E +- isGalois := +- (abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois H E).toIsGalois +- +-/-- The explicit base algebra on a finite cyclotomic layer is the canonical +-intermediate-field inclusion used by the finite Galois inverse system. -/ +-theorem abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra_eq_algebra' +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra H E = +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E).algebra' := by +- apply Algebra.algebra_ext +- intro x +- apply Subtype.ext +- rfl +- +-/-- The finite Galois layer uses its canonical inclusion into the full +-relative fixed field for the upper scalar action. -/ +-instance +- abstractFixedFieldCyclotomicFiniteGaloisLayer_scalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E).toIntermediateField +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field)) := by +- let i : +- (abstractFixedFieldCyclotomicFiniteGaloisLayer +- H E).toIntermediateField →ₐ[ +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field] +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) := +- { (abstractFixedFieldCyclotomicFiniteGaloisLayer +- H E).toIntermediateField.val.toRingHom with +- commutes' := by +- intro x +- rfl } +- exact +- IsScalarTower.of_algebraMap_eq' +- (AlgHom.comp_algebraMap i).symm +- +-/-- The canonical inclusion of the finite cyclotomic layer into the +-full abstract-fixed-field compositum. -/ +-private noncomputable def +- abstractFixedFieldCyclotomicFiniteLayerInclusion +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- abstractFixedFieldCyclotomicFiniteLayer H E →ₐ[ +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field] +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) := +- IntermediateField.val +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- +-/-- The two embeddings of a finite rational cyclotomic layer into the +-full abstract-fixed-field compositum agree. -/ +-private theorem +- abstractFixedFieldCyclotomicFiniteLayerEmbedding_inclusion +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- (z : E) : +- abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E z) = +- rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H +- (z : rationalCyclotomicZHatField) := by +- exact Subtype.ext rfl +- +-/-- Restriction to `E` commutes pointwise with the restriction from the +-full rational cyclotomic tower. -/ +-private theorem +- restrictNormalHom_abstractFixedFieldCyclotomicRestriction_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- [Normal ℚ E] +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) +- (z : E) : +- ((AlgEquiv.restrictNormalHom E +- (abstractFixedFieldCyclotomicRestriction H σ)) z : +- rationalCyclotomicZHatField) = +- (abstractFixedFieldCyclotomicRestriction H σ) +- (z : rationalCyclotomicZHatField) := by +- exact +- AlgEquiv.restrictNormal_commutes +- (abstractFixedFieldCyclotomicRestriction H σ) E z +- +-/-- The raw cyclotomic restriction commutes with the canonical embedding +-of the full rational cyclotomic tower. -/ +-private theorem +- abstractFixedFieldCyclotomicRestriction_embedding_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) +- (z : rationalCyclotomicZHatField) : +- rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H +- (abstractFixedFieldCyclotomicRestriction H σ z) = +- σ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H z) := by +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) +- exact +- AlgEquiv.restrictNormal_commutes +- (MulSemiringAction.toAlgEquiv ℚ U σ) +- rationalCyclotomicZHatField z +- +-/-- Restriction to the finite compositum layer commutes with its +-canonical inclusion into the full compositum. -/ +-private theorem +- restrictNormalHom_abstractFixedFieldCyclotomicFiniteLayer_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- [Normal +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E)] +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) +- (z : abstractFixedFieldCyclotomicFiniteLayer H E) : +- abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteLayer H E) σ z) = +- σ (abstractFixedFieldCyclotomicFiniteLayerInclusion H E z) := by +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) +- let P : IntermediateField F U := +- abstractFixedFieldCyclotomicFiniteLayer H E +- exact +- AlgEquiv.restrictNormal_commutes +- (MulSemiringAction.toAlgEquiv F U σ) P z +- +-/-- Restricting the finite-compositum action further to `E` commutes +-with the explicit embedding of `E` into that finite layer. -/ +-private theorem +- abstractFixedFieldCyclotomicFiniteLayerEmbedding_restrict_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- [Normal ℚ E] +- [Normal +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E)] +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) +- (z : E) : +- abstractFixedFieldCyclotomicFiniteLayerEmbedding H E +- (IntermediateField.restrictRestrictAlgEquivMapHom +- ℚ E +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteLayer H E) σ) z) = +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteLayer H E) σ) +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E z) := by +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) +- let P : IntermediateField F U := +- abstractFixedFieldCyclotomicFiniteLayer H E +- exact +- AlgEquiv.restrictNormal_commutes +- (MulSemiringAction.toAlgEquiv ℚ P +- (AlgEquiv.restrictNormalHom P σ)) E z +- +-/-- The left finite-level restriction, after both canonical embeddings into +-the full compositum, is the action of `σ` on the cyclotomic embedding. -/ +-private theorem +- restrictNormalHom_abstractFixedFieldCyclotomicRestriction_left_embedded +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- [Normal ℚ E] +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) +- (x : E) : +- abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E +- (AlgEquiv.restrictNormalHom E +- (abstractFixedFieldCyclotomicRestriction H σ) x)) = +- σ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H +- (x : rationalCyclotomicZHatField)) := by +- calc +- abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E +- (AlgEquiv.restrictNormalHom E +- (abstractFixedFieldCyclotomicRestriction H σ) x)) = +- rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H +- (((AlgEquiv.restrictNormalHom E +- (abstractFixedFieldCyclotomicRestriction H σ) x) : +- rationalCyclotomicZHatField)) := +- abstractFixedFieldCyclotomicFiniteLayerEmbedding_inclusion H E _ +- _ = rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H +- (abstractFixedFieldCyclotomicRestriction H σ +- (x : rationalCyclotomicZHatField)) := +- congrArg +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H) +- (restrictNormalHom_abstractFixedFieldCyclotomicRestriction_apply +- H E σ x) +- _ = σ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H (x : rationalCyclotomicZHatField)) := +- abstractFixedFieldCyclotomicRestriction_embedding_apply +- H σ (x : rationalCyclotomicZHatField) +- +-/-- The right finite-level restriction, after both canonical embeddings into +-the full compositum, is the same action of `σ`. -/ +-private theorem +- restrictNormalHom_abstractFixedFieldCyclotomicRestriction_right_embedded +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- [Normal ℚ E] +- [Normal +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E)] +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) +- (x : E) : +- abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E +- (IntermediateField.restrictRestrictAlgEquivMapHom +- ℚ E +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteLayer H E) σ) x)) = +- σ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H +- (x : rationalCyclotomicZHatField)) := by +- calc +- abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E +- (IntermediateField.restrictRestrictAlgEquivMapHom +- ℚ E +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteLayer H E) σ) x)) = +- abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- ((AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteLayer H E) σ) +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E x)) := +- congrArg +- (abstractFixedFieldCyclotomicFiniteLayerInclusion H E) +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding_restrict_apply +- H E σ x) +- _ = σ +- (abstractFixedFieldCyclotomicFiniteLayerInclusion H E +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E x)) := +- restrictNormalHom_abstractFixedFieldCyclotomicFiniteLayer_apply +- H E σ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E x) +- _ = σ +- (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum +- H (x : rationalCyclotomicZHatField)) := +- congrArg σ +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding_inclusion H E x) +- +-/-- Pointwise form of finite-layer restriction compatibility. -/ +-private theorem +- restrictNormalHom_abstractFixedFieldCyclotomicRestriction_pointwise +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- [Normal ℚ E] +- [Normal +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E)] +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) +- (x : E) : +- AlgEquiv.restrictNormalHom E +- (abstractFixedFieldCyclotomicRestriction H σ) x = +- IntermediateField.restrictRestrictAlgEquivMapHom +- ℚ E +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteLayer H E) σ) x := by +- apply +- (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E).injective +- apply +- (abstractFixedFieldCyclotomicFiniteLayerInclusion H E).injective +- exact +- (restrictNormalHom_abstractFixedFieldCyclotomicRestriction_left_embedded +- H E σ x).trans +- (restrictNormalHom_abstractFixedFieldCyclotomicRestriction_right_embedded +- H E σ x).symm +- +-/-- Restricting through a finite layer commutes with restriction from +-the full abstract-fixed-field compositum. -/ +-theorem +- restrictNormalHom_abstractFixedFieldCyclotomicRestriction +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- (σ : +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) : +- letI : Normal ℚ E := E.isGalois.to_normal +- AlgEquiv.restrictNormalHom E +- (abstractFixedFieldCyclotomicRestriction H σ) = +- IntermediateField.restrictRestrictAlgEquivMapHom +- ℚ E +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- σ) := by +- let : Normal ℚ E := E.isGalois.to_normal +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) +- let T := rationalCyclotomicZHatField +- let P : IntermediateField F U := +- abstractFixedFieldCyclotomicFiniteLayer H E +- let : Algebra T U := +- abstractFixedFieldCyclotomicCompositum_algebra H +- let : IsScalarTower ℚ T U := +- abstractFixedFieldCyclotomicCompositum_scalarTower H +- let : Algebra E P := +- abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra H E +- let : IsScalarTower ℚ E P := +- abstractFixedFieldCyclotomicFiniteLayer_layerScalarTower H E +- let : IsAbelianGalois F P := by +- change IsAbelianGalois F +- (abstractFixedFieldCyclotomicFiniteLayer H E) +- exact +- abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois H E +- let : Normal F P := IsGalois.to_normal +- apply AlgEquiv.ext +- intro x +- exact +- restrictNormalHom_abstractFixedFieldCyclotomicRestriction_pointwise +- H E σ x +- +-section FiniteCoordinateHelpers +- +-/-- Opaque three-step equality composition used to keep large dependent +-finite-level coordinates out of endpoint proof normalization. -/ +-private theorem cyclotomicAbstractFixedFieldArtin_eqTransThree +- {α : Type} {a b c d : α} +- (hab : a = b) (hbc : b = c) (hcd : c = d) : +- a = d := +- hab.trans (hbc.trans hcd) +- +-private abbrev cyclotomicAbstractFixedFieldArtinCoordinateBase +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- +-private abbrev cyclotomicAbstractFixedFieldArtinCoordinateRelative +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (rationalCyclotomicFieldInertia_le H.field) +- +-private abbrev cyclotomicAbstractFixedFieldArtinCoordinateLayer +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IntermediateField +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := +- abstractFixedFieldCyclotomicFiniteLayer H E +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- Algebra ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) := +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H).algebra' +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateBaseFiniteDimensional +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- FiniteDimensional ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- NumberField +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) := +- NumberField.of_module_finite ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateBaseSeparableAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- Algebra +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (SeparableClosure ℚ) := +- IntermediateField.toAlgebra +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateRelativeAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- Algebra +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H).algebra' +- +-local instance +- cyclotomicAbstractFixedFieldArtinCoordinateRelativeScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- IsScalarTower ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := +- abstractFixedFieldCyclotomicCompositum_baseScalarTower H +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateRelativeIsAbelianGalois +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : +- IsAbelianGalois +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateAlgebra +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra ℚ E := +- E.toIntermediateField.algebra' +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateNumberField +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- NumberField E := +- NumberField.of_module_finite ℚ E +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateIsAbelianGalois +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsAbelianGalois ℚ E := +- IsAbelianGalois.of_algHom E.toIntermediateField.val +- +-local instance +- cyclotomicAbstractFixedFieldArtinCoordinateNormal +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Normal ℚ E := +- E.isGalois.to_normal +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E).algebra' +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := +- DivisionRing.toRatAlgebra +- +-local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := by +- let hI := rationalCyclotomicFieldInertia_le H.field +- apply IsScalarTower.of_algebraMap_eq +- intro x +- apply Subtype.ext +- change +- algebraMap ℚ +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) x = +- algebraMap +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) +- (algebraMap ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) x) +- exact +- IsScalarTower.algebraMap_apply +- ℚ +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI) x +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- NumberField +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) := +- abstractFixedFieldCyclotomicFiniteLayer_numberField H E +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra E +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := +- abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra H E +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerSMul +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- SMul E +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := +- abstractFixedFieldCyclotomicFiniteLayer_layerSMul H E +- +-local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower ℚ E +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := +- abstractFixedFieldCyclotomicFiniteLayer_layerScalarTower H E +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerRelativeAlgebra +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Algebra +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := +- IntermediateField.toAlgebra +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) +- +-local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerRelativeScalarTower +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsScalarTower +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := +- abstractFixedFieldCyclotomicFiniteGaloisLayer_scalarTower H E +- +-noncomputable local instance +- cyclotomicAbstractFixedFieldArtinCoordinateLayerIsAbelianGalois +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- IsAbelianGalois +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := +- abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois H E +- +-/-- The full abstract Artin symbol whose finite coordinates are compared +-below. Naming this endpoint keeps its relative fixed-field data opaque. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinAbstractEndpoint +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : +- Gal(rationalCyclotomicZHatField / ℚ) := +- abstractFixedFieldCyclotomicRestriction H +- (infiniteGlobalArtinMonoidHom +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) a) +- +-/-- The rational norm Artin symbol serving as the other full endpoint. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinRationalEndpoint +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : +- Gal(rationalCyclotomicZHatField / ℚ) := +- rationalCyclotomicZHatGlobalArtin +- (IdeleGroup.norm ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) a) +- +-/-- The finite restriction map packaged together with its pointwise Artin +-naturality law. The map is inferred from the generic hom-level theorem, so +-no concrete instance tower is compared after the opaque boundary. -/ +-private noncomputable def cyclotomicAbstractFixedFieldArtinCoordinateMapData +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- {f : Gal(abstractFixedFieldCyclotomicFiniteGaloisLayer H E / +- cyclotomicAbstractFixedFieldArtinCoordinateBase H) →* +- Gal(E / ℚ) // +- f.comp +- (@globalArtinMonoidHomOfNumberField +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- (inferInstance : Field +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField H) +- (inferInstance : Field +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E)) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerIsAbelianGalois H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField H E)) = +- (globalArtinMonoidHom (K := ℚ) (L := E)).comp +- (IdeleGroup.norm ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H))} := by +- have hnat := +- @globalArtinMonoidHomOfNumberField_norm_restriction +- ℚ E +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- inferInstance inferInstance +- inferInstance +- (cyclotomicAbstractFixedFieldArtinCoordinateNumberField E) +- (cyclotomicAbstractFixedFieldArtinCoordinateAlgebra E) +- (cyclotomicAbstractFixedFieldArtinCoordinateIsAbelianGalois E) +- inferInstance +- (cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField H) +- inferInstance +- (cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra H) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerIsAbelianGalois H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField H E) +- exact +- ⟨(@AlgEquiv.restrictNormalHom +- ℚ inferInstance +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- inferInstance +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) +- E inferInstance +- (cyclotomicAbstractFixedFieldArtinCoordinateAlgebra E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateNormal E)).comp +- (@AlgEquiv.restrictScalarsHom +- ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- inferInstance inferInstance inferInstance +- (cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra H) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower H E)), +- hnat⟩ +- +-/-- The fixed restriction map from the relative finite layer to one rational +-cyclotomic coordinate. -/ +-private noncomputable def cyclotomicAbstractFixedFieldArtinCoordinateMap +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Gal(abstractFixedFieldCyclotomicFiniteGaloisLayer H E / +- cyclotomicAbstractFixedFieldArtinCoordinateBase H) →* +- Gal(E / ℚ) := +- (cyclotomicAbstractFixedFieldArtinCoordinateMapData H E).1 +- +-/-- Naturality of the named coordinate map, kept at the hom level so later +-pointwise rewrites match the opaque map without unfolding its data package. -/ +-private theorem cyclotomicAbstractFixedFieldArtinCoordinateMap_naturality +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- (cyclotomicAbstractFixedFieldArtinCoordinateMap H E).comp +- (globalArtinMonoidHom +- (K := cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (L := abstractFixedFieldCyclotomicFiniteGaloisLayer H E)) = +- (globalArtinMonoidHom (K := ℚ) (L := E)).comp +- (IdeleGroup.norm ℚ +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) := +- (cyclotomicAbstractFixedFieldArtinCoordinateMapData H E).2 +- +-/-- Pointwise identification of the named coordinate map with the concrete +-two-stage restriction used by the abstract fixed-field comparison. -/ +-private theorem cyclotomicAbstractFixedFieldArtinCoordinateMap_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) +- (σ : Gal(abstractFixedFieldCyclotomicFiniteGaloisLayer H E / +- cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : +- cyclotomicAbstractFixedFieldArtinCoordinateMap H E σ = +- @IntermediateField.restrictRestrictAlgEquivMapHom +- ℚ E +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- inferInstance inferInstance inferInstance inferInstance +- (cyclotomicAbstractFixedFieldArtinCoordinateAlgebra E) +- (cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra H) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateNormal E) σ := +- rfl +- +-/-- The relative projection, common rational finite value, and rational +-infinite projection, with both comparison steps packaged by the generic +-provider before this concrete tower becomes opaque. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinCoordinateBridgeData +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) := +- @compRestrictNormalHomInfiniteGlobalArtinRationalCyclotomicDataOfNumberField +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) +- (inferInstance : Field +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField H) +- (inferInstance : Field +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H)) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelativeAlgebra H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelativeIsAbelianGalois H) +- a +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField H E) +- E +- (cyclotomicAbstractFixedFieldArtinCoordinateNumberField E) +- (cyclotomicAbstractFixedFieldArtinCoordinateIsAbelianGalois E) +- (cyclotomicAbstractFixedFieldArtinCoordinateMap H E) +- (cyclotomicAbstractFixedFieldArtinCoordinateMap_naturality H E) +- +-/-- The abstract endpoint after projection to one finite coordinate. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinAbstractCoordinate +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Gal(E / ℚ) := +- AlgEquiv.restrictNormalHom E +- (cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a) +- +-/-- The relative infinite Artin symbol, restricted to a finite layer and +-then mapped to the corresponding rational coordinate. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Gal(E / ℚ) := +- (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.1 +- +-/-- The finite relative Artin symbol mapped to one rational coordinate. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinFiniteCoordinate +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Gal(E / ℚ) := +- (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.2.1 +- +-/-- The finite rational Artin coordinate of the idele norm. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinRationalCoordinate +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Gal(E / ℚ) := +- (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.2.1 +- +-/-- Naturality of the finite global Artin map at the concrete cyclotomic +-coordinate. -/ +-private theorem +- cyclotomicAbstractFixedFieldArtinCoordinateNaturality +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- cyclotomicAbstractFixedFieldArtinFiniteCoordinate H a E = +- cyclotomicAbstractFixedFieldArtinRationalCoordinate H a E := by +- rfl +- +-/-- The rational endpoint after projection to one finite coordinate. -/ +-private noncomputable def +- cyclotomicAbstractFixedFieldArtinRationalEndpointCoordinate +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- Gal(E / ℚ) := +- (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.2.2 +- +-/-- The abstract restriction map projected to the concrete finite layer. -/ +-private theorem +- cyclotomicAbstractFixedFieldArtinCoordinateRestriction +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- cyclotomicAbstractFixedFieldArtinAbstractCoordinate H a E = +- cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate H a E := by +- calc +- cyclotomicAbstractFixedFieldArtinAbstractCoordinate H a E = +- AlgEquiv.restrictNormalHom E +- (cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a) := rfl +- _ = cyclotomicAbstractFixedFieldArtinCoordinateMap H E +- (AlgEquiv.restrictNormalHom +- (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) +- (infiniteGlobalArtinMonoidHom +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) a)) := +- (restrictNormalHom_abstractFixedFieldCyclotomicRestriction +- H E +- (infiniteGlobalArtinMonoidHom +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H) +- (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) a)).trans +- (cyclotomicAbstractFixedFieldArtinCoordinateMap_apply H E _).symm +- _ = cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate H a E := rfl +- +-/-- Restricting the infinite relative Artin symbol supplies exactly the +-finite Artin coordinate. -/ +-private theorem +- cyclotomicAbstractFixedFieldArtinCoordinateLayerProjection +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate H a E = +- cyclotomicAbstractFixedFieldArtinFiniteCoordinate H a E := +- (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).2.1 +- +-/-- The rational cyclotomic Artin map projected to the same finite +-coordinate. -/ +-private theorem +- cyclotomicAbstractFixedFieldArtinCoordinateRationalProjection +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- cyclotomicAbstractFixedFieldArtinRationalEndpointCoordinate H a E = +- cyclotomicAbstractFixedFieldArtinFiniteCoordinate H a E := by +- exact +- (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).2.2.symm +- +-/-- Equality of the two full endpoints at one opaque finite coordinate. -/ +-private theorem +- cyclotomicAbstractFixedFieldArtinFiniteCoordinateComparison +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) +- (E : +- FiniteGaloisIntermediateField +- ℚ rationalCyclotomicZHatField) : +- AlgEquiv.restrictNormalHom E +- (cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a) = +- AlgEquiv.restrictNormalHom E +- (cyclotomicAbstractFixedFieldArtinRationalEndpoint H a) := by +- change +- cyclotomicAbstractFixedFieldArtinAbstractCoordinate H a E = +- cyclotomicAbstractFixedFieldArtinRationalEndpointCoordinate H a E +- exact +- cyclotomicAbstractFixedFieldArtin_eqTransThree +- (cyclotomicAbstractFixedFieldArtinCoordinateRestriction H a E) +- (cyclotomicAbstractFixedFieldArtinCoordinateLayerProjection H a E) +- (cyclotomicAbstractFixedFieldArtinCoordinateRationalProjection +- H a E).symm +- +-/-- The finite-coordinate comparison assembled in the rational cyclotomic +-inverse limit. -/ +-private theorem +- abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtin_inverseLimit +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : +- IdeleGroup +- (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : +- cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a = +- cyclotomicAbstractFixedFieldArtinRationalEndpoint H a := by +- apply +- (InfiniteGalois.continuousMulEquivToLimit +- ℚ rationalCyclotomicZHatField).injective +- apply Subtype.ext +- funext Eop +- exact +- cyclotomicAbstractFixedFieldArtinFiniteCoordinateComparison +- H a Eop.unop +- +-end FiniteCoordinateHelpers +- +-/-- The actual infinite global Artin map on an abstract fixed field +-restricts to the rational cyclotomic Artin map of the ordinary idele +-norm. -/ +-@[simp] +-theorem +- abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtinMonoidHom +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : +- IdeleGroup +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) : +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- letI : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- letI : NumberField F := +- NumberField.of_module_finite ℚ F +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- letI : IsAbelianGalois F U := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- abstractFixedFieldCyclotomicRestriction H +- (infiniteGlobalArtinMonoidHom F U a) = +- rationalCyclotomicZHatGlobalArtin +- (IdeleGroup.norm ℚ F a) := by +- exact +- abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtin_inverseLimit +- H a +- +-/-- In the normalized actual Galois coordinate, the infinite global +-Artin symbol is exactly the normalized cyclotomic idele value. -/ +-theorem +- abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : +- IdeleGroup +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) : +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- letI : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- letI : NumberField F := +- NumberField.of_module_finite ℚ F +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- letI : IsAbelianGalois F U := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- Multiplicative.toAdd +- (abstractFixedFieldCyclotomicGalEquivZHat H +- (infiniteGlobalArtinMonoidHom F U a)) = +- normalizedCyclotomicZHatIdeleValue F +- (Additive.ofMul a) := by +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- let : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- let : NumberField F := +- NumberField.of_module_finite ℚ F +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- let : IsAbelianGalois F U := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- apply +- zHatMulNat_injective +- (H.residueDegree rationalCyclotomicDegreeData).pos +- calc +- (H.residueDegree rationalCyclotomicDegreeData : ℕ) • +- Multiplicative.toAdd +- (abstractFixedFieldCyclotomicGalEquivZHat H +- (infiniteGlobalArtinMonoidHom F U a)) = +- Multiplicative.toAdd +- (rationalCyclotomicZHatFieldGalEquivZHat +- (abstractFixedFieldCyclotomicRestriction H +- (infiniteGlobalArtinMonoidHom F U a))) := by +- exact +- (abstractFixedFieldCyclotomicRestriction_coordinate H +- (infiniteGlobalArtinMonoidHom F U a)).symm +- _ = +- Multiplicative.toAdd +- (rationalCyclotomicZHatFieldGalEquivZHat +- (rationalCyclotomicZHatGlobalArtin +- (IdeleGroup.norm ℚ F a))) := by +- rw [ +- abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtinMonoidHom] +- _ = +- cyclotomicZHatNormComposite F +- (Additive.ofMul a) := by +- rfl +- _ = +- cyclotomicZHatIntersectionDegree F • +- normalizedCyclotomicZHatIdeleValue F +- (Additive.ofMul a) := by +- exact +- (cyclotomicZHatIntersectionDegree_nsmul_normalizedIdeleValue +- F (Additive.ofMul a)).symm +- _ = +- (H.residueDegree rationalCyclotomicDegreeData : ℕ) • +- normalizedCyclotomicZHatIdeleValue F +- (Additive.ofMul a) := by +- rw [ +- cyclotomicZHatIntersectionDegree_abstractFixedField_eq_residueDegree +- H] +- +-/-- Representative form of the actual cyclotomic Artin-coordinate +-identity after descent of the normalized value to the idele class +-group. -/ +-theorem +- abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom_mk +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (a : +- IdeleGroup +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)) : +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- letI : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- letI : NumberField F := +- NumberField.of_module_finite ℚ F +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- letI : IsAbelianGalois F U := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- Multiplicative.toAdd +- (abstractFixedFieldCyclotomicGalEquivZHat H +- (infiniteGlobalArtinMonoidHom F U a)) = +- normalizedCyclotomicZHatIdeleClassValueContinuous F +- (Additive.ofMul +- (QuotientGroup.mk' +- (IdeleGroup.principalSubgroup F) a)) := by +- have hSeparableClosureAlgebra : +- cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra = +- rationalSeparableClosureAlgebra := +- Subsingleton.elim _ _ +- cases hSeparableClosureAlgebra +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- let : IsAbelianGalois F U := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- calc +- Multiplicative.toAdd +- (abstractFixedFieldCyclotomicGalEquivZHat H +- (infiniteGlobalArtinMonoidHom F U a)) = +- normalizedCyclotomicZHatIdeleValue F +- (Additive.ofMul a) := +- abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom +- H a +- _ = +- normalizedCyclotomicZHatIdeleClassValueContinuous F +- (Additive.ofMul +- (QuotientGroup.mk' +- (IdeleGroup.principalSubgroup F) a)) := +- (normalizedCyclotomicZHatIdeleClassValueContinuous_mk +- (K := F) a).symm +- +-/-- The genuine infinite global Artin symbol of the cyclotomic +-maximal-unramified extension kills every principal idele of the +-abstract fixed field. -/ +-@[simp] +-theorem +- infiniteGlobalArtinMonoidHom_abstractFixedFieldCyclotomic_principalIdele +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (x : +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field)ˣ) : +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- letI : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- letI : NumberField F := +- NumberField.of_module_finite ℚ F +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- letI : IsAbelianGalois F U := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- infiniteGlobalArtinMonoidHom F U +- (IdeleGroup.principalIdele F x) = +- 1 := by +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H.field +- let : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- let : NumberField F := +- NumberField.of_module_finite ℚ F +- let hI := +- rationalCyclotomicFieldInertia_le H.field +- let U := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hI +- let : IsAbelianGalois F U := +- abstractFixedFieldCyclotomic_isAbelianGalois H +- have hcoord : +- Multiplicative.toAdd +- (abstractFixedFieldCyclotomicGalEquivZHat H +- (infiniteGlobalArtinMonoidHom F U +- (IdeleGroup.principalIdele F x))) = 0 := +- (abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom +- H (IdeleGroup.principalIdele F x)).trans +- (normalizedCyclotomicZHatIdeleValue_principalIdele_eq_zero F x) +- apply (abstractFixedFieldCyclotomicGalEquivZHat H).injective +- rw [map_one] +- apply Multiplicative.ext +- exact hcoord.trans toAdd_one.symm ++attribute [local instance] ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal ++ abstractFixedFieldCyclotomic_numberField + + /-- The genuine cyclotomic maximal-unramified Artin map descended to + the idele class group of an abstract fixed field. -/ +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinBase.lean +new file mode 100644 +index 0000000..dc971fc +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinBase.lean +@@ -0,0 +1,545 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicIdeleClassValuation ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.InfiniteGlobalArtin ++import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.MaximalUnramifiedReciprocity ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open KummerTheory ++ ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra : ++ Algebra ℚ (SeparableClosure ℚ) := ++ DivisionRing.toRatAlgebra ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra : ++ Algebra ℚ rationalCyclotomicZHatField := ++ DivisionRing.toRatAlgebra ++ ++/-- Cyclotomic field inertia is contained in the original abstract ++field subgroup. -/ ++theorem rationalCyclotomicFieldInertia_le ++ (H : ClosedSubgroup ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ (rationalCyclotomicDegreeData.fieldInertia H).toSubgroup ≤ ++ H.toSubgroup := by ++ intro σ hσ ++ exact hσ.1 ++ ++ ++theorem extensionSubgroup_rationalCyclotomicFieldInertia ++ (H : ClosedSubgroup ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ CyclicCohomology.extensionSubgroup H ++ (rationalCyclotomicDegreeData.fieldInertia H) ++ (rationalCyclotomicFieldInertia_le H) = ++ rationalCyclotomicDegreeData.fieldInertiaWithin H := by ++ ext σ ++ rw [ ++ mem_extensionSubgroup_iff, ++ rationalCyclotomicDegreeData.mem_fieldInertiaWithin_iff, ++ rationalCyclotomicDegreeData.mem_fieldInertia_iff] ++ exact and_iff_right σ.2 ++ ++/-- The actual Galois group of the cyclotomic maximal-unramified ++extension of an abstract fixed field, in its normalized `ZHat` ++coordinate. -/ ++noncomputable def abstractFixedFieldCyclotomicGalEquivZHat ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ≃* ++ Multiplicative ZHat := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ let qField : ++ H.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI ≃* ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) := ++ LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ let qInertia : ++ H.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI ≃* ++ H.field.toSubgroup ⧸ ++ rationalCyclotomicDegreeData.fieldInertiaWithin H.field := ++ QuotientGroup.quotientMulEquivOfEq ++ (extensionSubgroup_rationalCyclotomicFieldInertia H.field) ++ exact ++ qField.symm.trans ++ (qInertia.trans ++ (rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData))) ++ ++/-- On an absolute-Galois representative fixing the lower field, the ++actual cyclotomic Galois coordinate is its normalized degree. -/ ++@[simp] ++theorem abstractFixedFieldCyclotomicGalEquivZHat_extensionClass ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (σ : H.field.toSubgroup) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ abstractFixedFieldCyclotomicGalEquivZHat H ++ (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ (QuotientGroup.mk σ)) = ++ rationalCyclotomicDegreeData.normalizedDegree ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData) σ := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ let qField := ++ LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ change ++ (rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData)) ++ (QuotientGroup.quotientMulEquivOfEq ++ (extensionSubgroup_rationalCyclotomicFieldInertia H.field) ++ (qField.symm (qField (QuotientGroup.mk σ)))) = ++ rationalCyclotomicDegreeData.normalizedDegree ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData) σ ++ rw [qField.symm_apply_apply] ++ rfl ++ ++/-- Quotient-level evaluation of the actual cyclotomic Galois ++coordinate. -/ ++@[simp] ++theorem abstractFixedFieldCyclotomicGalEquivZHat_quotientClass ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (q : ++ H.field.toSubgroup ⧸ ++ rationalCyclotomicDegreeData.fieldInertiaWithin H.field) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ let qInertia : ++ H.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI ≃* ++ H.field.toSubgroup ⧸ ++ rationalCyclotomicDegreeData.fieldInertiaWithin H.field := ++ QuotientGroup.quotientMulEquivOfEq ++ (extensionSubgroup_rationalCyclotomicFieldInertia H.field) ++ abstractFixedFieldCyclotomicGalEquivZHat H ++ (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ (qInertia.symm q)) = ++ rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData) q := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ let qField := ++ LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ let qInertia : ++ H.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI ≃* ++ H.field.toSubgroup ⧸ ++ rationalCyclotomicDegreeData.fieldInertiaWithin H.field := ++ QuotientGroup.quotientMulEquivOfEq ++ (extensionSubgroup_rationalCyclotomicFieldInertia H.field) ++ change ++ (rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData)) ++ (qInertia ++ (qField.symm ++ (qField (qInertia.symm q)))) = ++ rationalCyclotomicDegreeData.maximalUnramifiedDegreeEquiv ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData) q ++ rw [qField.symm_apply_apply, qInertia.apply_symm_apply] ++ ++/-- The extension fixed by cyclotomic field inertia is an actual ++abelian Galois extension of the lower abstract fixed field. -/ ++theorem abstractFixedFieldCyclotomic_isAbelianGalois ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ IsAbelianGalois ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ let : IsGalois ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) := ++ LocalClassFieldTheory.abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ let e := ++ abstractFixedFieldCyclotomicGalEquivZHat H ++ exact ++ { is_comm.comm := by ++ intro σ τ ++ apply e.injective ++ simpa only [map_mul] using mul_comm (e σ) (e τ) } ++ ++/-- The rational cyclotomic `ZHat`-field embedded in the actual ++maximal-unramified compositum of an abstract fixed field. -/ ++noncomputable def ++ rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ rationalCyclotomicZHatField →ₐ[ℚ] ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let J := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ have hTJ : ++ rationalCyclotomicZHatField ≤ J := by ++ change ++ rationalCyclotomicZHatField ≤ ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ rw [ ++ rationalCyclotomicDegreeData_fixedField_fieldInertia] ++ exact le_sup_right ++ exact IntermediateField.inclusion hTJ ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicCompositum_algebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ Algebra rationalCyclotomicZHatField ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) := ++ ((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H).toRingHom).toAlgebra ++ ++instance abstractFixedFieldCyclotomicCompositum_scalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ IsScalarTower ℚ rationalCyclotomicZHatField ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) := ++ IsScalarTower.of_algebraMap_eq' ++ ((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H).comp_algebraMap).symm ++ ++instance abstractFixedFieldCyclotomicCompositum_baseScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ IsScalarTower ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ apply IsScalarTower.of_algebraMap_eq ++ intro x ++ apply Subtype.ext ++ rfl ++ ++/-- Restriction from the actual maximal-unramified compositum of an ++abstract fixed field to the rational cyclotomic factor. -/ ++noncomputable def abstractFixedFieldCyclotomicRestriction ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) →* ++ Gal(rationalCyclotomicZHatField / ℚ) := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ exact ++ IntermediateField.restrictRestrictAlgEquivMapHom ++ ℚ rationalCyclotomicZHatField ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) ++ ++/-- On a quotient representative, cyclotomic restriction of the ++actual relative automorphism is ordinary restriction of the same ++ambient absolute-Galois automorphism. -/ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal : ++ Normal ℚ rationalCyclotomicZHatField := ++ rationalCyclotomicZHatField_isNormal ++ ++@[simp] ++theorem abstractFixedFieldCyclotomicRestriction_extensionClass ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (σ : H.field.toSubgroup) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ abstractFixedFieldCyclotomicRestriction H ++ (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ (QuotientGroup.mk σ)) = ++ AlgEquiv.restrictNormalHom ++ rationalCyclotomicZHatField σ.1 := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ let τ := ++ LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ (QuotientGroup.mk' ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) hI) ++ σ) ++ apply AlgEquiv.ext ++ intro x ++ apply Subtype.ext ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ have hrestrict : ++ algebraMap rationalCyclotomicZHatField U ++ ((abstractFixedFieldCyclotomicRestriction H τ) x) = ++ τ (algebraMap rationalCyclotomicZHatField U x) := by ++ change ++ algebraMap rationalCyclotomicZHatField U ++ ((AlgEquiv.restrictNormal ++ (MulSemiringAction.toAlgEquiv ℚ U τ) ++ rationalCyclotomicZHatField) x) = ++ (MulSemiringAction.toAlgEquiv ℚ U τ) ++ (algebraMap rationalCyclotomicZHatField U x) ++ exact ++ AlgEquiv.restrictNormal_commutes ++ (MulSemiringAction.toAlgEquiv ℚ U τ) ++ rationalCyclotomicZHatField x ++ have halgebraMap_eq_embedding ++ (z : rationalCyclotomicZHatField) : ++ algebraMap rationalCyclotomicZHatField U z = ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H z : U) := by ++ rfl ++ have hembedding_coe ++ (z : rationalCyclotomicZHatField) : ++ (((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H z : U) : SeparableClosure ℚ)) = ++ (z : SeparableClosure ℚ) := by ++ rfl ++ have halgebraMap_coe ++ (z : rationalCyclotomicZHatField) : ++ ((algebraMap rationalCyclotomicZHatField U z : U) : ++ SeparableClosure ℚ) = ++ (z : SeparableClosure ℚ) := by ++ rw [halgebraMap_eq_embedding] ++ exact hembedding_coe z ++ have hambient := ++ LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup_mk_apply_val ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal σ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H x) ++ calc ++ (((abstractFixedFieldCyclotomicRestriction H τ) x : ++ rationalCyclotomicZHatField) : ++ SeparableClosure ℚ) = ++ ((τ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H x) : ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) : ++ SeparableClosure ℚ) := by ++ calc ++ (((abstractFixedFieldCyclotomicRestriction H τ) x : ++ rationalCyclotomicZHatField) : SeparableClosure ℚ) = ++ ((algebraMap rationalCyclotomicZHatField U ++ ((abstractFixedFieldCyclotomicRestriction H τ) x) : U) : ++ SeparableClosure ℚ) := ++ (halgebraMap_coe ++ ((abstractFixedFieldCyclotomicRestriction H τ) x)).symm ++ _ = ((τ (algebraMap rationalCyclotomicZHatField U x) : U) : ++ SeparableClosure ℚ) := ++ congrArg (fun y : U => (y : SeparableClosure ℚ)) hrestrict ++ _ = ((τ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H x) : U) : SeparableClosure ℚ) := by ++ rw [halgebraMap_eq_embedding] ++ _ = σ.1 (x : SeparableClosure ℚ) := by ++ calc ++ ((τ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H x) : U) : SeparableClosure ℚ) = ++ σ.1 ++ ((rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H x : U) : SeparableClosure ℚ) := by ++ simpa only [τ, U] using hambient.symm ++ _ = σ.1 (x : SeparableClosure ℚ) := by ++ rw [hembedding_coe] ++ _ = ++ (((AlgEquiv.restrictNormalHom ++ rationalCyclotomicZHatField σ.1) x : ++ rationalCyclotomicZHatField) : ++ SeparableClosure ℚ) := by ++ exact ++ (AlgEquiv.restrictNormal_commutes ++ σ.1 rationalCyclotomicZHatField x).symm ++ ++/-- Raw cyclotomic restriction is residue-degree multiplication of ++the normalized actual Galois coordinate. -/ ++theorem ++ abstractFixedFieldCyclotomicRestriction_coordinate ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (τ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) : ++ Multiplicative.toAdd ++ (rationalCyclotomicZHatFieldGalEquivZHat ++ (abstractFixedFieldCyclotomicRestriction H τ)) = ++ (H.residueDegree rationalCyclotomicDegreeData : ℕ) • ++ Multiplicative.toAdd ++ (abstractFixedFieldCyclotomicGalEquivZHat H τ) := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let hnormal : ++ (CyclicCohomology.extensionSubgroup H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI).Normal := by ++ rw [extensionSubgroup_rationalCyclotomicFieldInertia] ++ infer_instance ++ let qField := ++ LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) H.field ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ hI hnormal ++ obtain ⟨q, rfl⟩ := qField.surjective τ ++ refine Quotient.inductionOn' q ?_ ++ intro σ ++ rw [ ++ abstractFixedFieldCyclotomicRestriction_extensionClass, ++ abstractFixedFieldCyclotomicGalEquivZHat_extensionClass] ++ exact ++ (rationalCyclotomicDegreeData.residueDegree_nsmul_normalizedDegree ++ (H.toFiniteResidueAbstractField ++ rationalCyclotomicDegreeData) σ).symm ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinComparison.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinComparison.lean +new file mode 100644 +index 0000000..0788ef1 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinComparison.lean +@@ -0,0 +1,273 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicAbstractFixedFieldArtinCoordinates ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open KummerTheory ++ ++attribute [local instance] ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal ++ abstractFixedFieldCyclotomic_numberField ++ ++/-- The actual infinite global Artin map on an abstract fixed field ++restricts to the rational cyclotomic Artin map of the ordinary idele ++norm. -/ ++@[simp] ++theorem ++ abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtinMonoidHom ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : ++ IdeleGroup ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) : ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ letI : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ letI : NumberField F := ++ NumberField.of_module_finite ℚ F ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ letI : IsAbelianGalois F U := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ abstractFixedFieldCyclotomicRestriction H ++ (infiniteGlobalArtinMonoidHom F U a) = ++ rationalCyclotomicZHatGlobalArtin ++ (IdeleGroup.norm ℚ F a) := by ++ exact ++ abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtin_inverseLimit ++ H a ++ ++/-- In the normalized actual Galois coordinate, the infinite global ++Artin symbol is exactly the normalized cyclotomic idele value. -/ ++theorem ++ abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : ++ IdeleGroup ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) : ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ letI : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ letI : NumberField F := ++ NumberField.of_module_finite ℚ F ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ letI : IsAbelianGalois F U := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ Multiplicative.toAdd ++ (abstractFixedFieldCyclotomicGalEquivZHat H ++ (infiniteGlobalArtinMonoidHom F U a)) = ++ normalizedCyclotomicZHatIdeleValue F ++ (Additive.ofMul a) := by ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ let : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ let : NumberField F := ++ NumberField.of_module_finite ℚ F ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ let : IsAbelianGalois F U := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ apply ++ zHatMulNat_injective ++ (H.residueDegree rationalCyclotomicDegreeData).pos ++ calc ++ (H.residueDegree rationalCyclotomicDegreeData : ℕ) • ++ Multiplicative.toAdd ++ (abstractFixedFieldCyclotomicGalEquivZHat H ++ (infiniteGlobalArtinMonoidHom F U a)) = ++ Multiplicative.toAdd ++ (rationalCyclotomicZHatFieldGalEquivZHat ++ (abstractFixedFieldCyclotomicRestriction H ++ (infiniteGlobalArtinMonoidHom F U a))) := by ++ exact ++ (abstractFixedFieldCyclotomicRestriction_coordinate H ++ (infiniteGlobalArtinMonoidHom F U a)).symm ++ _ = ++ Multiplicative.toAdd ++ (rationalCyclotomicZHatFieldGalEquivZHat ++ (rationalCyclotomicZHatGlobalArtin ++ (IdeleGroup.norm ℚ F a))) := by ++ rw [ ++ abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtinMonoidHom] ++ _ = ++ cyclotomicZHatNormComposite F ++ (Additive.ofMul a) := by ++ rfl ++ _ = ++ cyclotomicZHatIntersectionDegree F • ++ normalizedCyclotomicZHatIdeleValue F ++ (Additive.ofMul a) := by ++ exact ++ (cyclotomicZHatIntersectionDegree_nsmul_normalizedIdeleValue ++ F (Additive.ofMul a)).symm ++ _ = ++ (H.residueDegree rationalCyclotomicDegreeData : ℕ) • ++ normalizedCyclotomicZHatIdeleValue F ++ (Additive.ofMul a) := by ++ rw [ ++ cyclotomicZHatIntersectionDegree_abstractFixedField_eq_residueDegree ++ H] ++ ++/-- Representative form of the actual cyclotomic Artin-coordinate ++identity after descent of the normalized value to the idele class ++group. -/ ++theorem ++ abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom_mk ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : ++ IdeleGroup ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) : ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ letI : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ letI : NumberField F := ++ NumberField.of_module_finite ℚ F ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ letI : IsAbelianGalois F U := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ Multiplicative.toAdd ++ (abstractFixedFieldCyclotomicGalEquivZHat H ++ (infiniteGlobalArtinMonoidHom F U a)) = ++ normalizedCyclotomicZHatIdeleClassValueContinuous F ++ (Additive.ofMul ++ (QuotientGroup.mk' ++ (IdeleGroup.principalSubgroup F) a)) := by ++ have hSeparableClosureAlgebra : ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra = ++ rationalSeparableClosureAlgebra := ++ Subsingleton.elim _ _ ++ cases hSeparableClosureAlgebra ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ let : IsAbelianGalois F U := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ calc ++ Multiplicative.toAdd ++ (abstractFixedFieldCyclotomicGalEquivZHat H ++ (infiniteGlobalArtinMonoidHom F U a)) = ++ normalizedCyclotomicZHatIdeleValue F ++ (Additive.ofMul a) := ++ abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom ++ H a ++ _ = ++ normalizedCyclotomicZHatIdeleClassValueContinuous F ++ (Additive.ofMul ++ (QuotientGroup.mk' ++ (IdeleGroup.principalSubgroup F) a)) := ++ (normalizedCyclotomicZHatIdeleClassValueContinuous_mk ++ (K := F) a).symm ++ ++/-- The genuine infinite global Artin symbol of the cyclotomic ++maximal-unramified extension kills every principal idele of the ++abstract fixed field. -/ ++@[simp] ++theorem ++ infiniteGlobalArtinMonoidHom_abstractFixedFieldCyclotomic_principalIdele ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (x : ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)ˣ) : ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ letI : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ letI : NumberField F := ++ NumberField.of_module_finite ℚ F ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ letI : IsAbelianGalois F U := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ infiniteGlobalArtinMonoidHom F U ++ (IdeleGroup.principalIdele F x) = ++ 1 := by ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ let : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ let : NumberField F := ++ NumberField.of_module_finite ℚ F ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI ++ let : IsAbelianGalois F U := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ have hcoord : ++ Multiplicative.toAdd ++ (abstractFixedFieldCyclotomicGalEquivZHat H ++ (infiniteGlobalArtinMonoidHom F U ++ (IdeleGroup.principalIdele F x))) = 0 := ++ (abstractFixedFieldCyclotomicGalEquivZHat_infiniteGlobalArtinMonoidHom ++ H (IdeleGroup.principalIdele F x)).trans ++ (normalizedCyclotomicZHatIdeleValue_principalIdele_eq_zero F x) ++ apply (abstractFixedFieldCyclotomicGalEquivZHat H).injective ++ rw [map_one] ++ apply Multiplicative.ext ++ exact hcoord.trans toAdd_one.symm ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinCompositum.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinCompositum.lean +new file mode 100644 +index 0000000..1295a7e +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinCompositum.lean +@@ -0,0 +1,257 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicAbstractFixedFieldArtinBase ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open KummerTheory ++ ++attribute [local instance] ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal ++ ++/-- The canonical compositum of an abstract fixed field with a finite ++layer of the rational cyclotomic `ZHat`-extension. -/ ++def abstractFixedFieldCyclotomicFiniteCompositum ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IntermediateField ℚ (SeparableClosure ℚ) := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ⊔ ++ IntermediateField.lift E.toIntermediateField ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteCompositum_finiteDimensional ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ FiniteDimensional ℚ ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) := by ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ let : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ let : FiniteDimensional ℚ ++ (IntermediateField.lift E.toIntermediateField) := ++ ((IntermediateField.liftAlgEquiv ++ E.toIntermediateField).toLinearEquiv).finiteDimensional ++ exact IntermediateField.finiteDimensional_sup ++ F (IntermediateField.lift E.toIntermediateField) ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteCompositum_numberField ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ NumberField ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) := ++ NumberField.of_module_finite ℚ ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) ++ ++/-- The lower abstract fixed field embedded into its finite ++cyclotomic compositum. -/ ++noncomputable def ++ abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field →ₐ[ℚ] ++ abstractFixedFieldCyclotomicFiniteCompositum H E := ++ IntermediateField.inclusion ++ (show ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ≤ ++ abstractFixedFieldCyclotomicFiniteCompositum H E from ++ le_sup_left) ++ ++ ++noncomputable local instance ++ abstractFixedFieldCyclotomic_numberField ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ NumberField ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) := by ++ let : FiniteDimensional ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ exact ++ NumberField.of_module_finite ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ ++/-- A finite rational cyclotomic layer embedded into its compositum ++with the abstract fixed field. -/ ++noncomputable def ++ abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ E →ₐ[ℚ] ++ abstractFixedFieldCyclotomicFiniteCompositum H E := ++ (IntermediateField.inclusion ++ (show ++ IntermediateField.lift E.toIntermediateField ≤ ++ abstractFixedFieldCyclotomicFiniteCompositum H E from ++ le_sup_right)).comp ++ (IntermediateField.liftAlgEquiv E.toIntermediateField).toAlgHom ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteCompositum_baseAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) := ++ RingHom.toAlgebra ++ (AlgHom.toRingHom ++ (abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding H E)) ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteCompositum_layerAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra E ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) := ++ RingHom.toAlgebra ++ (AlgHom.toRingHom ++ (abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding H E)) ++ ++/-- The finite-layer action induced by its explicit embedding into the ++finite compositum. -/ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteCompositum_layerSMul ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ SMul E ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) := ++ Algebra.toSMul ++ (self := ++ abstractFixedFieldCyclotomicFiniteCompositum_layerAlgebra H E) ++ ++instance ++ abstractFixedFieldCyclotomicFiniteCompositum_baseScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) := ++ IsScalarTower.of_algebraMap_eq' ++ (AlgHom.comp_algebraMap ++ (abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding H E)).symm ++ ++instance ++ abstractFixedFieldCyclotomicFiniteCompositum_layerScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ℚ E ++ (abstractFixedFieldCyclotomicFiniteCompositum H E) := ++ IsScalarTower.of_algebraMap_eq' ++ (AlgHom.comp_algebraMap ++ (abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding H E)).symm ++ ++/-- Inclusion of the finite cyclotomic compositum into the actual ++maximal-unramified compositum. -/ ++noncomputable def ++ abstractFixedFieldCyclotomicFiniteCompositumInclusion ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ abstractFixedFieldCyclotomicFiniteCompositum H E →ₐ[ℚ] ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let J := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicDegreeData.fieldInertia H.field) ++ have hle : ++ abstractFixedFieldCyclotomicFiniteCompositum H E ≤ J := by ++ dsimp only [J] ++ rw [ ++ rationalCyclotomicDegreeData_fixedField_fieldInertia H.field] ++ exact ++ sup_le_sup le_rfl ++ (IntermediateField.lift_le E.toIntermediateField) ++ exact IntermediateField.inclusion hle ++ ++/-- The same finite-compositum inclusion over the lower abstract fixed ++field. -/ ++noncomputable def ++ abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ abstractFixedFieldCyclotomicFiniteCompositum H E →ₐ[ ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field] ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI := by ++ let f := ++ abstractFixedFieldCyclotomicFiniteCompositumInclusion H E ++ exact ++ { f.toRingHom with ++ commutes' := by ++ intro x ++ rfl } ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinCoordinates.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinCoordinates.lean +new file mode 100644 +index 0000000..64ed13e +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinCoordinates.lean +@@ -0,0 +1,668 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicAbstractFixedFieldArtinFiniteRestriction ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open KummerTheory ++ ++attribute [local instance] ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal ++ abstractFixedFieldCyclotomic_numberField ++ ++section FiniteCoordinateHelpers ++ ++/-- Opaque three-step equality composition used to keep large dependent ++finite-level coordinates out of endpoint proof normalization. -/ ++private theorem cyclotomicAbstractFixedFieldArtin_eqTransThree ++ {α : Type} {a b c d : α} ++ (hab : a = b) (hbc : b = c) (hcd : c = d) : ++ a = d := ++ hab.trans (hbc.trans hcd) ++ ++private abbrev cyclotomicAbstractFixedFieldArtinCoordinateBase ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ ++private abbrev cyclotomicAbstractFixedFieldArtinCoordinateRelative ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) ++ ++private abbrev cyclotomicAbstractFixedFieldArtinCoordinateLayer ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IntermediateField ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := ++ abstractFixedFieldCyclotomicFiniteLayer H E ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ Algebra ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H).algebra' ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateBaseFiniteDimensional ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ FiniteDimensional ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ NumberField ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) := ++ NumberField.of_module_finite ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateBaseSeparableAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ Algebra ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (SeparableClosure ℚ) := ++ IntermediateField.toAlgebra ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateRelativeAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ Algebra ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H).algebra' ++ ++local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateRelativeScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ IsScalarTower ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := ++ abstractFixedFieldCyclotomicCompositum_baseScalarTower H ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateRelativeIsAbelianGalois ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) : ++ IsAbelianGalois ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateAlgebra ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra ℚ E := ++ E.toIntermediateField.algebra' ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateNumberField ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ NumberField E := ++ NumberField.of_module_finite ℚ E ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateIsAbelianGalois ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsAbelianGalois ℚ E := ++ IsAbelianGalois.of_algHom E.toIntermediateField.val ++ ++local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateNormal ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Normal ℚ E := ++ E.isGalois.to_normal ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E).algebra' ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := ++ DivisionRing.toRatAlgebra ++ ++local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := by ++ let hI := rationalCyclotomicFieldInertia_le H.field ++ apply IsScalarTower.of_algebraMap_eq ++ intro x ++ apply Subtype.ext ++ change ++ algebraMap ℚ ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) x = ++ algebraMap ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) ++ (algebraMap ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) x) ++ exact ++ IsScalarTower.algebraMap_apply ++ ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) x ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ NumberField ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) := ++ abstractFixedFieldCyclotomicFiniteLayer_numberField H E ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra E ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := ++ abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra H E ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerSMul ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ SMul E ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := ++ abstractFixedFieldCyclotomicFiniteLayer_layerSMul H E ++ ++local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ℚ E ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := ++ abstractFixedFieldCyclotomicFiniteLayer_layerScalarTower H E ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerRelativeAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := ++ IntermediateField.toAlgebra ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) ++ ++local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerRelativeScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) := ++ abstractFixedFieldCyclotomicFiniteGaloisLayer_scalarTower H E ++ ++noncomputable local instance ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerIsAbelianGalois ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsAbelianGalois ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayer H E) := ++ abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois H E ++ ++/-- The full abstract Artin symbol whose finite coordinates are compared ++below. Naming this endpoint keeps its relative fixed-field data opaque. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinAbstractEndpoint ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : ++ Gal(rationalCyclotomicZHatField / ℚ) := ++ abstractFixedFieldCyclotomicRestriction H ++ (infiniteGlobalArtinMonoidHom ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) a) ++ ++/-- The rational norm Artin symbol serving as the other full endpoint. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinRationalEndpoint ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : ++ Gal(rationalCyclotomicZHatField / ℚ) := ++ rationalCyclotomicZHatGlobalArtin ++ (IdeleGroup.norm ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) a) ++ ++ ++private noncomputable def cyclotomicAbstractFixedFieldArtinCoordinateMapData ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ {f : Gal(abstractFixedFieldCyclotomicFiniteGaloisLayer H E / ++ cyclotomicAbstractFixedFieldArtinCoordinateBase H) →* ++ Gal(E / ℚ) // ++ f.comp ++ (@globalArtinMonoidHomOfNumberField ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ (inferInstance : Field ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField H) ++ (inferInstance : Field ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E)) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerIsAbelianGalois H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField H E)) = ++ (globalArtinMonoidHom (K := ℚ) (L := E)).comp ++ (IdeleGroup.norm ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H))} := by ++ have hnat := ++ @globalArtinMonoidHomOfNumberField_norm_restriction ++ ℚ E ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ inferInstance inferInstance ++ inferInstance ++ (cyclotomicAbstractFixedFieldArtinCoordinateNumberField E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateAlgebra E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateIsAbelianGalois E) ++ inferInstance ++ (cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField H) ++ inferInstance ++ (cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerIsAbelianGalois H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField H E) ++ exact ++ ⟨(@AlgEquiv.restrictNormalHom ++ ℚ inferInstance ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ inferInstance ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) ++ E inferInstance ++ (cyclotomicAbstractFixedFieldArtinCoordinateAlgebra E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateNormal E)).comp ++ (@AlgEquiv.restrictScalarsHom ++ ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ inferInstance inferInstance inferInstance ++ (cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower H E)), ++ hnat⟩ ++ ++/-- The fixed restriction map from the relative finite layer to one rational ++cyclotomic coordinate. -/ ++private noncomputable def cyclotomicAbstractFixedFieldArtinCoordinateMap ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Gal(abstractFixedFieldCyclotomicFiniteGaloisLayer H E / ++ cyclotomicAbstractFixedFieldArtinCoordinateBase H) →* ++ Gal(E / ℚ) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateMapData H E).1 ++ ++ ++private theorem cyclotomicAbstractFixedFieldArtinCoordinateMap_naturality ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ (cyclotomicAbstractFixedFieldArtinCoordinateMap H E).comp ++ (globalArtinMonoidHom ++ (K := cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (L := abstractFixedFieldCyclotomicFiniteGaloisLayer H E)) = ++ (globalArtinMonoidHom (K := ℚ) (L := E)).comp ++ (IdeleGroup.norm ℚ ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateMapData H E).2 ++ ++/-- Pointwise identification of the named coordinate map with the concrete ++two-stage restriction used by the abstract fixed-field comparison. -/ ++private theorem cyclotomicAbstractFixedFieldArtinCoordinateMap_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ (σ : Gal(abstractFixedFieldCyclotomicFiniteGaloisLayer H E / ++ cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : ++ cyclotomicAbstractFixedFieldArtinCoordinateMap H E σ = ++ @IntermediateField.restrictRestrictAlgEquivMapHom ++ ℚ E ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ inferInstance inferInstance inferInstance inferInstance ++ (cyclotomicAbstractFixedFieldArtinCoordinateAlgebra E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateBaseAlgebra H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerRatAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseAlgebra H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerScalarTower H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerBaseScalarTower H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateNormal E) σ := ++ rfl ++ ++/-- The relative projection, common rational finite value, and rational ++infinite projection, with both comparison steps packaged by the generic ++provider before this concrete tower becomes opaque. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinCoordinateBridgeData ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) := ++ @compRestrictNormalHomInfiniteGlobalArtinRationalCyclotomicDataOfNumberField ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) ++ (inferInstance : Field ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (cyclotomicAbstractFixedFieldArtinCoordinateBaseNumberField H) ++ (inferInstance : Field ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H)) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelativeAlgebra H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelativeIsAbelianGalois H) ++ a ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerNumberField H E) ++ E ++ (cyclotomicAbstractFixedFieldArtinCoordinateNumberField E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateIsAbelianGalois E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateMap H E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateMap_naturality H E) ++ ++/-- The abstract endpoint after projection to one finite coordinate. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinAbstractCoordinate ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Gal(E / ℚ) := ++ AlgEquiv.restrictNormalHom E ++ (cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a) ++ ++/-- The relative infinite Artin symbol, restricted to a finite layer and ++then mapped to the corresponding rational coordinate. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Gal(E / ℚ) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.1 ++ ++/-- The finite relative Artin symbol mapped to one rational coordinate. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinFiniteCoordinate ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Gal(E / ℚ) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.2.1 ++ ++/-- The finite rational Artin coordinate of the idele norm. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinRationalCoordinate ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Gal(E / ℚ) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.2.1 ++ ++/-- Naturality of the finite global Artin map at the concrete cyclotomic ++coordinate. -/ ++private theorem ++ cyclotomicAbstractFixedFieldArtinCoordinateNaturality ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ cyclotomicAbstractFixedFieldArtinFiniteCoordinate H a E = ++ cyclotomicAbstractFixedFieldArtinRationalCoordinate H a E := by ++ rfl ++ ++/-- The rational endpoint after projection to one finite coordinate. -/ ++private noncomputable def ++ cyclotomicAbstractFixedFieldArtinRationalEndpointCoordinate ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Gal(E / ℚ) := ++ (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).1.2.2 ++ ++/-- The abstract restriction map projected to the concrete finite layer. -/ ++private theorem ++ cyclotomicAbstractFixedFieldArtinCoordinateRestriction ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ cyclotomicAbstractFixedFieldArtinAbstractCoordinate H a E = ++ cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate H a E := by ++ calc ++ cyclotomicAbstractFixedFieldArtinAbstractCoordinate H a E = ++ AlgEquiv.restrictNormalHom E ++ (cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a) := rfl ++ _ = cyclotomicAbstractFixedFieldArtinCoordinateMap H E ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ (infiniteGlobalArtinMonoidHom ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) a)) := ++ (restrictNormalHom_abstractFixedFieldCyclotomicRestriction ++ H E ++ (infiniteGlobalArtinMonoidHom ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRelative H) a)).trans ++ (cyclotomicAbstractFixedFieldArtinCoordinateMap_apply H E _).symm ++ _ = cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate H a E := rfl ++ ++/-- Restricting the infinite relative Artin symbol supplies exactly the ++finite Artin coordinate. -/ ++private theorem ++ cyclotomicAbstractFixedFieldArtinCoordinateLayerProjection ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ cyclotomicAbstractFixedFieldArtinRestrictedLayerCoordinate H a E = ++ cyclotomicAbstractFixedFieldArtinFiniteCoordinate H a E := ++ (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).2.1 ++ ++/-- The rational cyclotomic Artin map projected to the same finite ++coordinate. -/ ++private theorem ++ cyclotomicAbstractFixedFieldArtinCoordinateRationalProjection ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ cyclotomicAbstractFixedFieldArtinRationalEndpointCoordinate H a E = ++ cyclotomicAbstractFixedFieldArtinFiniteCoordinate H a E := by ++ exact ++ (cyclotomicAbstractFixedFieldArtinCoordinateBridgeData H a E).2.2.symm ++ ++/-- Equality of the two full endpoints at one opaque finite coordinate. -/ ++private theorem ++ cyclotomicAbstractFixedFieldArtinFiniteCoordinateComparison ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ AlgEquiv.restrictNormalHom E ++ (cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a) = ++ AlgEquiv.restrictNormalHom E ++ (cyclotomicAbstractFixedFieldArtinRationalEndpoint H a) := by ++ change ++ cyclotomicAbstractFixedFieldArtinAbstractCoordinate H a E = ++ cyclotomicAbstractFixedFieldArtinRationalEndpointCoordinate H a E ++ exact ++ cyclotomicAbstractFixedFieldArtin_eqTransThree ++ (cyclotomicAbstractFixedFieldArtinCoordinateRestriction H a E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateLayerProjection H a E) ++ (cyclotomicAbstractFixedFieldArtinCoordinateRationalProjection ++ H a E).symm ++ ++/-- The finite-coordinate comparison assembled in the rational cyclotomic ++inverse limit. -/ ++theorem ++ abstractFixedFieldCyclotomicRestriction_infiniteGlobalArtin_inverseLimit ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (a : ++ IdeleGroup ++ (cyclotomicAbstractFixedFieldArtinCoordinateBase H)) : ++ cyclotomicAbstractFixedFieldArtinAbstractEndpoint H a = ++ cyclotomicAbstractFixedFieldArtinRationalEndpoint H a := by ++ apply ++ (InfiniteGalois.continuousMulEquivToLimit ++ ℚ rationalCyclotomicZHatField).injective ++ apply Subtype.ext ++ funext Eop ++ exact ++ cyclotomicAbstractFixedFieldArtinFiniteCoordinateComparison ++ H a Eop.unop ++ ++end FiniteCoordinateHelpers ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinFiniteLayer.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinFiniteLayer.lean +new file mode 100644 +index 0000000..0ee433c +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinFiniteLayer.lean +@@ -0,0 +1,298 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicAbstractFixedFieldArtinCompositum ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open KummerTheory ++ ++attribute [local instance] ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal ++ abstractFixedFieldCyclotomic_numberField ++ ++/-- The finite cyclotomic compositum as an intermediate field of the ++actual maximal-unramified extension. -/ ++noncomputable def abstractFixedFieldCyclotomicFiniteLayer ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ IntermediateField ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) := ++ (abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase H E).fieldRange ++ ++/-- The base algebra on the finite field range, obtained from the ++explicit base embedding followed by the field-range equivalence. -/ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ RingHom.toAlgebra ++ ((AlgHom.toRingHom ++ (AlgEquiv.toAlgHom ++ (AlgHom.equivFieldRange ++ (abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase ++ H E)))).comp ++ (AlgHom.toRingHom ++ (abstractFixedFieldCyclotomicFiniteCompositumBaseEmbedding H E))) ++ ++/-- The scalar action belonging to the canonical base algebra on the ++finite field range. -/ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_baseSMul ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ SMul ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ Algebra.toSMul ++ (self := abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra H E) ++ ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_baseModule ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Module ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ @Algebra.toModule ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ _ _ ++ (abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra H E) ++ ++/-- The field-range equivalence rebuilt over the explicit base ++algebras. Its underlying ring equivalence is the canonical one. -/ ++noncomputable def ++ abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ abstractFixedFieldCyclotomicFiniteCompositum H E ≃ₐ[ ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field] ++ abstractFixedFieldCyclotomicFiniteLayer H E := ++ AlgEquiv.ofRingEquiv ++ (f := ++ (AlgHom.equivFieldRange ++ (abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase ++ H E)).toRingEquiv) ++ (fun _ => rfl) ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_finiteDimensional ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ FiniteDimensional ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ (abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer ++ H E).toLinearEquiv.finiteDimensional ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_numberField ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ NumberField ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ NumberField.of_module_finite ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsAbelianGalois ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ let : IsAbelianGalois ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) := ++ abstractFixedFieldCyclotomic_isAbelianGalois H ++ exact ++ IsAbelianGalois.of_algHom ++ ((abstractFixedFieldCyclotomicFiniteCompositumInclusionOverBase ++ H E).comp ++ (AlgEquiv.toAlgHom ++ (AlgEquiv.symm ++ (abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer ++ H E)))) ++ ++instance ++ abstractFixedFieldCyclotomicFiniteLayer_baseScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := by ++ let hI := ++ rationalCyclotomicFieldInertia_le H.field ++ apply IsScalarTower.of_algebraMap_eq ++ intro x ++ apply Subtype.ext ++ change ++ algebraMap ℚ ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) x = ++ algebraMap ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) ++ (algebraMap ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) x) ++ exact ++ IsScalarTower.algebraMap_apply ++ ℚ ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hI) x ++ ++/-- The finite rational layer embedded into its corresponding ++intermediate field over the abstract fixed field. -/ ++noncomputable def ++ abstractFixedFieldCyclotomicFiniteLayerEmbedding ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ E →ₐ[ℚ] ++ abstractFixedFieldCyclotomicFiniteLayer H E := by ++ exact ++ (AlgEquiv.toAlgHom ++ (AlgEquiv.restrictScalars ℚ ++ (abstractFixedFieldCyclotomicFiniteCompositumEquivFiniteLayer ++ H E))).comp ++ (abstractFixedFieldCyclotomicFiniteCompositumLayerEmbedding H E) ++ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ Algebra E ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ RingHom.toAlgebra ++ (AlgHom.toRingHom ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E)) ++ ++/-- The finite-layer action on its actual image in the relative fixed ++field. -/ ++noncomputable instance ++ abstractFixedFieldCyclotomicFiniteLayer_layerSMul ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ SMul E ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ Algebra.toSMul ++ (self := abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra H E) ++ ++instance ++ abstractFixedFieldCyclotomicFiniteLayer_layerScalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ℚ E ++ (abstractFixedFieldCyclotomicFiniteLayer H E) := ++ IsScalarTower.of_algebraMap_eq' ++ (AlgHom.comp_algebraMap ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E)).symm ++ ++/-- The finite cyclotomic layer as an object of the finite-Galois ++inverse system of the actual maximal-unramified extension. -/ ++@[reducible] ++noncomputable def ++ abstractFixedFieldCyclotomicFiniteGaloisLayer ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ FiniteGaloisIntermediateField ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field)) where ++ toIntermediateField := ++ abstractFixedFieldCyclotomicFiniteLayer H E ++ finiteDimensional := ++ abstractFixedFieldCyclotomicFiniteLayer_finiteDimensional H E ++ isGalois := ++ (abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois H E).toIsGalois ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinFiniteRestriction.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinFiniteRestriction.lean +new file mode 100644 +index 0000000..bcfbbc2 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/CyclotomicAbstractFixedFieldArtinFiniteRestriction.lean +@@ -0,0 +1,462 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicAbstractFixedFieldArtinFiniteLayer ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open KummerTheory ++ ++attribute [local instance] ++ cyclotomicAbstractFixedFieldArtin_separableClosureAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldAlgebra ++ cyclotomicAbstractFixedFieldArtin_cyclotomicZHatFieldNormal ++ abstractFixedFieldCyclotomic_numberField ++ ++/-- The explicit base algebra on a finite cyclotomic layer is the canonical ++intermediate-field inclusion used by the finite Galois inverse system. -/ ++theorem abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra_eq_algebra' ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ abstractFixedFieldCyclotomicFiniteLayer_baseAlgebra H E = ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E).algebra' := by ++ apply Algebra.algebra_ext ++ intro x ++ apply Subtype.ext ++ rfl ++ ++/-- The finite Galois layer uses its canonical inclusion into the full ++relative fixed field for the upper scalar action. -/ ++instance ++ abstractFixedFieldCyclotomicFiniteGaloisLayer_scalarTower ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ IsScalarTower ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E).toIntermediateField ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field)) := by ++ let i : ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer ++ H E).toIntermediateField →ₐ[ ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field] ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) := ++ { (abstractFixedFieldCyclotomicFiniteGaloisLayer ++ H E).toIntermediateField.val.toRingHom with ++ commutes' := by ++ intro x ++ rfl } ++ exact ++ IsScalarTower.of_algebraMap_eq' ++ (AlgHom.comp_algebraMap i).symm ++ ++/-- The canonical inclusion of the finite cyclotomic layer into the ++full abstract-fixed-field compositum. -/ ++private noncomputable def ++ abstractFixedFieldCyclotomicFiniteLayerInclusion ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) : ++ abstractFixedFieldCyclotomicFiniteLayer H E →ₐ[ ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field] ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) := ++ IntermediateField.val ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ ++/-- The two embeddings of a finite rational cyclotomic layer into the ++full abstract-fixed-field compositum agree. -/ ++private theorem ++ abstractFixedFieldCyclotomicFiniteLayerEmbedding_inclusion ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ (z : E) : ++ abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E z) = ++ rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H ++ (z : rationalCyclotomicZHatField) := by ++ exact Subtype.ext rfl ++ ++/-- Restriction to `E` commutes pointwise with the restriction from the ++full rational cyclotomic tower. -/ ++private theorem ++ restrictNormalHom_abstractFixedFieldCyclotomicRestriction_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ [Normal ℚ E] ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) ++ (z : E) : ++ ((AlgEquiv.restrictNormalHom E ++ (abstractFixedFieldCyclotomicRestriction H σ)) z : ++ rationalCyclotomicZHatField) = ++ (abstractFixedFieldCyclotomicRestriction H σ) ++ (z : rationalCyclotomicZHatField) := by ++ exact ++ AlgEquiv.restrictNormal_commutes ++ (abstractFixedFieldCyclotomicRestriction H σ) E z ++ ++/-- The raw cyclotomic restriction commutes with the canonical embedding ++of the full rational cyclotomic tower. -/ ++private theorem ++ abstractFixedFieldCyclotomicRestriction_embedding_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) ++ (z : rationalCyclotomicZHatField) : ++ rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H ++ (abstractFixedFieldCyclotomicRestriction H σ z) = ++ σ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H z) := by ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) ++ exact ++ AlgEquiv.restrictNormal_commutes ++ (MulSemiringAction.toAlgEquiv ℚ U σ) ++ rationalCyclotomicZHatField z ++ ++/-- Restriction to the finite compositum layer commutes with its ++canonical inclusion into the full compositum. -/ ++private theorem ++ restrictNormalHom_abstractFixedFieldCyclotomicFiniteLayer_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ [Normal ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E)] ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) ++ (z : abstractFixedFieldCyclotomicFiniteLayer H E) : ++ abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteLayer H E) σ z) = ++ σ (abstractFixedFieldCyclotomicFiniteLayerInclusion H E z) := by ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) ++ let P : IntermediateField F U := ++ abstractFixedFieldCyclotomicFiniteLayer H E ++ exact ++ AlgEquiv.restrictNormal_commutes ++ (MulSemiringAction.toAlgEquiv F U σ) P z ++ ++/-- Restricting the finite-compositum action further to `E` commutes ++with the explicit embedding of `E` into that finite layer. -/ ++private theorem ++ abstractFixedFieldCyclotomicFiniteLayerEmbedding_restrict_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ [Normal ℚ E] ++ [Normal ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E)] ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) ++ (z : E) : ++ abstractFixedFieldCyclotomicFiniteLayerEmbedding H E ++ (IntermediateField.restrictRestrictAlgEquivMapHom ++ ℚ E ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteLayer H E) σ) z) = ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteLayer H E) σ) ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E z) := by ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) ++ let P : IntermediateField F U := ++ abstractFixedFieldCyclotomicFiniteLayer H E ++ exact ++ AlgEquiv.restrictNormal_commutes ++ (MulSemiringAction.toAlgEquiv ℚ P ++ (AlgEquiv.restrictNormalHom P σ)) E z ++ ++/-- The left finite-level restriction, after both canonical embeddings into ++the full compositum, is the action of `σ` on the cyclotomic embedding. -/ ++private theorem ++ restrictNormalHom_abstractFixedFieldCyclotomicRestriction_left_embedded ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ [Normal ℚ E] ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) ++ (x : E) : ++ abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E ++ (AlgEquiv.restrictNormalHom E ++ (abstractFixedFieldCyclotomicRestriction H σ) x)) = ++ σ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H ++ (x : rationalCyclotomicZHatField)) := by ++ calc ++ abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E ++ (AlgEquiv.restrictNormalHom E ++ (abstractFixedFieldCyclotomicRestriction H σ) x)) = ++ rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H ++ (((AlgEquiv.restrictNormalHom E ++ (abstractFixedFieldCyclotomicRestriction H σ) x) : ++ rationalCyclotomicZHatField)) := ++ abstractFixedFieldCyclotomicFiniteLayerEmbedding_inclusion H E _ ++ _ = rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H ++ (abstractFixedFieldCyclotomicRestriction H σ ++ (x : rationalCyclotomicZHatField)) := ++ congrArg ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H) ++ (restrictNormalHom_abstractFixedFieldCyclotomicRestriction_apply ++ H E σ x) ++ _ = σ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H (x : rationalCyclotomicZHatField)) := ++ abstractFixedFieldCyclotomicRestriction_embedding_apply ++ H σ (x : rationalCyclotomicZHatField) ++ ++/-- The right finite-level restriction, after both canonical embeddings into ++the full compositum, is the same action of `σ`. -/ ++private theorem ++ restrictNormalHom_abstractFixedFieldCyclotomicRestriction_right_embedded ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ [Normal ℚ E] ++ [Normal ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E)] ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) ++ (x : E) : ++ abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E ++ (IntermediateField.restrictRestrictAlgEquivMapHom ++ ℚ E ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteLayer H E) σ) x)) = ++ σ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum H ++ (x : rationalCyclotomicZHatField)) := by ++ calc ++ abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E ++ (IntermediateField.restrictRestrictAlgEquivMapHom ++ ℚ E ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteLayer H E) σ) x)) = ++ abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ ((AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteLayer H E) σ) ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E x)) := ++ congrArg ++ (abstractFixedFieldCyclotomicFiniteLayerInclusion H E) ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding_restrict_apply ++ H E σ x) ++ _ = σ ++ (abstractFixedFieldCyclotomicFiniteLayerInclusion H E ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E x)) := ++ restrictNormalHom_abstractFixedFieldCyclotomicFiniteLayer_apply ++ H E σ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E x) ++ _ = σ ++ (rationalCyclotomicZHatFieldEmbeddingInAbstractFixedFieldCompositum ++ H (x : rationalCyclotomicZHatField)) := ++ congrArg σ ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding_inclusion H E x) ++ ++/-- Pointwise form of finite-layer restriction compatibility. -/ ++private theorem ++ restrictNormalHom_abstractFixedFieldCyclotomicRestriction_pointwise ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ [Normal ℚ E] ++ [Normal ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E)] ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) ++ (x : E) : ++ AlgEquiv.restrictNormalHom E ++ (abstractFixedFieldCyclotomicRestriction H σ) x = ++ IntermediateField.restrictRestrictAlgEquivMapHom ++ ℚ E ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteLayer H E) σ) x := by ++ apply ++ (abstractFixedFieldCyclotomicFiniteLayerEmbedding H E).injective ++ apply ++ (abstractFixedFieldCyclotomicFiniteLayerInclusion H E).injective ++ exact ++ (restrictNormalHom_abstractFixedFieldCyclotomicRestriction_left_embedded ++ H E σ x).trans ++ (restrictNormalHom_abstractFixedFieldCyclotomicRestriction_right_embedded ++ H E σ x).symm ++ ++/-- Restricting through a finite layer commutes with restriction from ++the full abstract-fixed-field compositum. -/ ++theorem ++ restrictNormalHom_abstractFixedFieldCyclotomicRestriction ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (E : ++ FiniteGaloisIntermediateField ++ ℚ rationalCyclotomicZHatField) ++ (σ : ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field)) : ++ letI : Normal ℚ E := E.isGalois.to_normal ++ AlgEquiv.restrictNormalHom E ++ (abstractFixedFieldCyclotomicRestriction H σ) = ++ IntermediateField.restrictRestrictAlgEquivMapHom ++ ℚ E ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field) ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ (AlgEquiv.restrictNormalHom ++ (abstractFixedFieldCyclotomicFiniteGaloisLayer H E) ++ σ) := by ++ let : Normal ℚ E := E.isGalois.to_normal ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field ++ let U := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (rationalCyclotomicFieldInertia_le H.field) ++ let T := rationalCyclotomicZHatField ++ let P : IntermediateField F U := ++ abstractFixedFieldCyclotomicFiniteLayer H E ++ let : Algebra T U := ++ abstractFixedFieldCyclotomicCompositum_algebra H ++ let : IsScalarTower ℚ T U := ++ abstractFixedFieldCyclotomicCompositum_scalarTower H ++ let : Algebra E P := ++ abstractFixedFieldCyclotomicFiniteLayer_layerAlgebra H E ++ let : IsScalarTower ℚ E P := ++ abstractFixedFieldCyclotomicFiniteLayer_layerScalarTower H E ++ let : IsAbelianGalois F P := by ++ change IsAbelianGalois F ++ (abstractFixedFieldCyclotomicFiniteLayer H E) ++ exact ++ abstractFixedFieldCyclotomicFiniteLayer_isAbelianGalois H E ++ let : Normal F P := IsGalois.to_normal ++ apply AlgEquiv.ext ++ intro x ++ exact ++ restrictNormalHom_abstractFixedFieldCyclotomicRestriction_pointwise ++ H E σ x ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/FiniteGaloisRealizationCore.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/FiniteGaloisRealizationCore.lean +index 73951e8..edb78f8 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/FiniteGaloisRealizationCore.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/FiniteGaloisRealizationCore.lean +@@ -15,6 +15,7 @@ import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.FixedField + import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.FixedFieldIntrinsicReciprocity.BaseComparison.IntrinsicBaseEquivalence + import ValuedFieldTheory.Valuation.Completion.AbsoluteValueExtensions + ++ + set_option autoImplicit false + + /-! +@@ -431,9 +432,16 @@ noncomputable def numberFieldTowerSeparableClosureToBaseSubgroup : + (numberFieldTowerBaseSubgroup K L).toSubgroup := by + let _ : Algebra K (SeparableClosure ℚ) := + numberFieldTowerSeparableClosureBaseAlgebra K L +- refine ++ exact + { toFun := fun σ => +- ⟨AlgEquiv.restrictScalars ℚ σ, ?_⟩ ++ ⟨AlgEquiv.restrictScalars ℚ σ, by ++ change ++ AlgEquiv.restrictScalars ℚ σ ∈ ++ (numberFieldTowerBaseField K L).fixingSubgroup ++ rw [IntermediateField.mem_fixingSubgroup_iff] ++ intro x hx ++ obtain ⟨y, rfl⟩ := hx ++ exact σ.commutes y⟩ + map_one' := by + apply Subtype.ext + rfl +@@ -441,13 +449,6 @@ noncomputable def numberFieldTowerSeparableClosureToBaseSubgroup : + intro σ τ + apply Subtype.ext + rfl } +- change +- AlgEquiv.restrictScalars ℚ σ ∈ +- (numberFieldTowerBaseField K L).fixingSubgroup +- rw [IntermediateField.mem_fixingSubgroup_iff] +- intro x hx +- obtain ⟨y, rfl⟩ := hx +- exact σ.commutes y + + /-- The compatible `K`-absolute Galois group is exactly the fixing + subgroup of the embedded copy of `K` inside the rational absolute +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalHilbertSymbol/FinitePlaceFiniteSupport.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalHilbertSymbol/FinitePlaceFiniteSupport.lean +index 9f029f0..a47f31b 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalHilbertSymbol/FinitePlaceFiniteSupport.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalHilbertSymbol/FinitePlaceFiniteSupport.lean +@@ -6,6 +6,8 @@ Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + + import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalHilbertSymbol.FinitePlaceCharacterComparison + import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.FiniteIdeleArtin ++import Mathlib.Algebra.FiniteSupport.Basic ++ + + set_option autoImplicit false + +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturality.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturality.lean +index 974d793..dfea338 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturality.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturality.lean +@@ -4,19 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.AbstractFixedFieldGlobalNormResidue +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.TowerAlgEquivNaturality ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityTowerNorm + +-set_option autoImplicit false + +-/-! +-# Naturality of the global norm-residue symbol ++set_option autoImplicit false + +-This file records the same-base restriction specialization of abstract +-norm-residue naturality in the rational absolute class formation. All +-closed subgroups remain in one fixed separable-closure ambient, so the +-statement is directly usable by fixed-field overextension arguments. +--/ + + open scoped IsMulCommutative + +@@ -34,2834 +26,11 @@ open RamificationTheory + + universe u + +-@[instance_reducible] +-private noncomputable def naturalityIdeleClassCommGroup +- (F : Type) [Field F] [NumberField F] : CommGroup (IdeleClassGroup F) := +- QuotientGroup.Quotient.commGroup (IdeleGroup.principalSubgroup F) +- +-attribute [local instance] naturalityIdeleClassCommGroup +- +-local instance ideleClassGroupIsMulCommutative +- {F : Type} [Field F] [NumberField F] +- : IsMulCommutative (IdeleClassGroup F) := +- ⟨⟨fun a b => mul_comm a b⟩⟩ +- +-local instance ideleClassSubgroupNormal +- {F : Type} [Field F] [NumberField F] +- (N : Subgroup (IdeleClassGroup F)) : N.Normal := +- N.normal_of_isMulCommutative +- +- +-/-- Two finite Galois subextensions with the same underlying closed subgroup +-are equal; the remaining structure fields are proof-irrelevant. -/ +-private theorem finiteGaloisSubextension_eq_of_field_eq +- {G : Type u} [Group G] [TopologicalSpace G] +- {K : ClosedSubgroup G} +- (A B : FiniteGaloisSubextension K) +- (h : A.field = B.field) : +- A = B := by +- cases A with +- | mk A hA nA fA => +- cases B with +- | mk B hB nB fB => +- dsimp only at h +- cases h +- rfl +- +-/-- Rebase a finite Galois subextension along equality of its bundled base. +-The field equality is the only data component; the remaining fields are +-proof-irrelevant. -/ +-private theorem finiteGaloisSubextension_transport_eq_of_field_eq +- {G : Type u} [Group G] [TopologicalSpace G] +- {A B : FiniteAbstractField G} +- (hAB : A = B) +- (P : FiniteGaloisSubextension A.field) +- (Q : FiniteGaloisSubextension B.field) +- (hfield : P.field = Q.field) : +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField G => +- FiniteGaloisSubextension X.field) +- hAB) +- P = Q := by +- cases hAB +- exact finiteGaloisSubextension_eq_of_field_eq P Q hfield +- +-/-- Transporting an additive equivalence between rational ambient fixed +-subgroups does not change the underlying direct-limit class. -/ +-private theorem rationalAmbientFixedAddEquiv_transport_apply_val +- {A B : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} +- (hAB : A = B) +- {X : Type} [AddGroup X] +- (e : X ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation A.field) +- (x : X) : +- ((Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- X ≃+ ambientFixedAddSubgroup +- rationalIdeleClassRepresentation Y.field) +- hAB) +- e x).1) = +- (e x).1 := by +- cases hAB +- rfl +- +-/-- Changing only the bundled subgroup of an additive subgroup element +-does not change its value in the ambient group. -/ +-private theorem addSubgroupCongr_apply_val +- {A : Type} [AddGroup A] +- {H K : AddSubgroup A} +- (h : H = K) (x : H) : +- ((AddEquiv.addSubgroupCongr h x).1 : A) = x.1 := by +- cases h +- rfl +- +-/-- Transporting an idele class along a field equality and the corresponding +-algebra equivalence leaves its rational direct-limit representative fixed. -/ +-private theorem rationalIdeleClassEquivFixed_congr_apply_val +- {A B : IntermediateField ℚ (SeparableClosure ℚ)} +- [FiniteDimensional ℚ A] [FiniteDimensional ℚ B] +- (h : A = B) +- (e : B ≃ₐ[ℚ] A) +- (he : e.trans (IntermediateField.equivOfEq h) = +- (AlgEquiv.refl : B ≃ₐ[ℚ] B)) +- (c : Additive (IdeleClassGroup B)) : +- ((rationalIdeleClassEquivFixed A) +- (MulEquiv.toAdditive (ideleClassCongr e) c)).1 = +- ((rationalIdeleClassEquivFixed B) c).1 := by +- cases h +- have he' : e = AlgEquiv.refl := by +- apply AlgEquiv.ext +- intro x +- have hx := DFunLike.congr_fun he x +- change e x = x at hx +- exact hx +- rw [he'] +- have hc : +- MulEquiv.toAdditive +- (ideleClassCongr (AlgEquiv.refl : A ≃ₐ[ℚ] A)) c = c := by +- cases c with +- | ofMul c => +- exact congrArg Additive.ofMul (ideleClassCongr_refl c) +- rw [hc] +- +-/-- Transporting the target intermediate field of a base-field equivalence +-preserves its rational fixed-part representative. -/ +-private theorem rationalIdeleClassEquivFixed_transport_baseEquiv_val +- {T : Type} [Field T] [NumberField T] +- {A B : IntermediateField ℚ (SeparableClosure ℚ)} +- [FiniteDimensional ℚ A] [FiniteDimensional ℚ B] +- (h : A = B) (e : T ≃ₐ[ℚ] B) +- (c : IdeleClassGroup T) : +- ((rationalIdeleClassEquivFixed A) +- (Additive.ofMul +- (ideleClassCongr (K := T) (M := A) +- (e.trans (IntermediateField.equivOfEq h).symm) c))).1 = +- ((rationalIdeleClassEquivFixed B) +- (Additive.ofMul (ideleClassCongr (K := T) (M := B) e c))).1 := by +- cases h +- have he : +- e.trans (IntermediateField.equivOfEq (rfl : A = A)).symm = e := by +- ext x +- rfl +- rw [he] +- +-/-- Equality of the lower and upper closed subgroups transports the raw +-extension quotient without exposing dependent rewrites to clients. -/ +-private def extensionQuotientMulEquivOfEq +- {G : Type u} [Group G] [TopologicalSpace G] +- {H H' J J' : ClosedSubgroup G} +- (hH : H = H') (hJ : J = J') +- (hJH : J.toSubgroup ≤ H.toSubgroup) +- (hJH' : J'.toSubgroup ≤ H'.toSubgroup) +- [(CyclicCohomology.extensionSubgroup H J hJH).Normal] +- [(CyclicCohomology.extensionSubgroup H' J' hJH').Normal] : +- (H.toSubgroup ⧸ CyclicCohomology.extensionSubgroup H J hJH) ≃* +- (H'.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H' J' hJH') := by +- cases hH +- cases hJ +- exact MulEquiv.refl _ +- +-/-- The quotient transport sends a quotient representative to the same +-ambient group element, rebundled in the equal lower subgroup. -/ +-@[simp] +-private theorem extensionQuotientMulEquivOfEq_mk +- {G : Type u} [Group G] [TopologicalSpace G] +- {H H' J J' : ClosedSubgroup G} +- (hH : H = H') (hJ : J = J') +- (hJH : J.toSubgroup ≤ H.toSubgroup) +- (hJH' : J'.toSubgroup ≤ H'.toSubgroup) +- [(CyclicCohomology.extensionSubgroup H J hJH).Normal] +- [(CyclicCohomology.extensionSubgroup H' J' hJH').Normal] +- (σ : H.toSubgroup) : +- extensionQuotientMulEquivOfEq hH hJ hJH hJH' +- (QuotientGroup.mk σ) = +- QuotientGroup.mk +- ((MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup hH)) σ) := by +- cases hH +- cases hJ +- rfl +- +-/-- Rebundling an element along equality of closed subgroups preserves its +-underlying ambient group element. -/ +-private theorem closedSubgroupCongr_apply_val +- {G : Type u} [Group G] [TopologicalSpace G] +- {H H' : ClosedSubgroup G} +- (hH : H = H') (σ : H.toSubgroup) : +- (((MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup hH)) σ).1 : G) = σ.1 := by +- cases hH +- rfl +- +-/-- Rebase an abelianized extension-quotient equivalence together with its +-finite abstract base. -/ +-private def abelianizedExtensionQuotientAddEquiv_transportBase +- {G : Type u} [Group G] [TopologicalSpace G] +- {A B : FiniteAbstractField G} +- (hAB : A = B) +- (P : FiniteGaloisSubextension A.field) +- {X : Type} [AddGroup X] +- (e : Additive (Abelianization P.extensionQuotient) ≃+ X) : +- Additive +- (Abelianization +- (Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField G => +- FiniteGaloisSubextension Y.field) +- hAB) +- P).extensionQuotient) ≃+ X := by +- cases hAB +- exact e +- +-/-- Rebase an abelianized equivalence along equality of finite Galois +-subextensions over a fixed abstract base. -/ +-private def abelianizedExtensionQuotientAddEquiv_transportExtension +- {G : Type u} [Group G] [TopologicalSpace G] +- {K : ClosedSubgroup G} +- {P Q : FiniteGaloisSubextension K} +- (hPQ : P = Q) +- {X : Type} [AddGroup X] +- (e : Additive (Abelianization P.extensionQuotient) ≃+ X) : +- Additive (Abelianization Q.extensionQuotient) ≃+ X := by +- cases hPQ +- exact e +- +-/-- The explicit quotient equivalence induced by rebasing a finite Galois +-subextension. -/ +-private def extensionQuotientMulEquiv_transportFiniteGalois +- {G : Type u} [Group G] [TopologicalSpace G] +- {A B : FiniteAbstractField G} +- (hAB : A = B) +- (P : FiniteGaloisSubextension A.field) +- {Q : FiniteGaloisSubextension B.field} +- (hPQ : +- Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField G => +- FiniteGaloisSubextension Y.field) +- hAB) +- P = Q) : +- Q.extensionQuotient ≃* P.extensionQuotient := by +- cases hAB +- cases hPQ +- exact MulEquiv.refl _ +- +-/-- Quotient rebasing sends a canonical representative to the same ambient +-group element rebundled in the old base subgroup. -/ +-@[simp] +-private theorem extensionQuotientMulEquiv_transportFiniteGalois_mk +- {G : Type u} [Group G] [TopologicalSpace G] +- {A B : FiniteAbstractField G} +- (hAB : A = B) +- (P : FiniteGaloisSubextension A.field) +- {Q : FiniteGaloisSubextension B.field} +- (hPQ : +- Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField G => +- FiniteGaloisSubextension Y.field) +- hAB) +- P = Q) +- (σ : B.field.toSubgroup) : +- extensionQuotientMulEquiv_transportFiniteGalois hAB P hPQ +- (Q.extensionQuotientMk σ) = +- P.extensionQuotientMk +- ((MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup +- (congrArg FiniteAbstractField.field hAB).symm)) σ) := by +- cases hAB +- cases hPQ +- rfl +- +-/-- Abelianization commutes with simultaneous transport of the abstract base +-and its finite Galois subextension. -/ +-private theorem abelianizedCanonicalEquiv_transportFiniteGalois +- {G : Type u} [Group G] [TopologicalSpace G] +- {A B : FiniteAbstractField G} +- (hAB : A = B) +- (P : FiniteGaloisSubextension A.field) +- {Q : FiniteGaloisSubextension B.field} +- (hPQ : +- Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField G => +- FiniteGaloisSubextension Y.field) +- hAB) +- P = Q) +- {X : Type} [CommGroup X] +- (e : P.extensionQuotient ≃* X) : +- abelianizedExtensionQuotientAddEquiv_transportExtension hPQ +- (abelianizedExtensionQuotientAddEquiv_transportBase +- hAB P +- (MulEquiv.toAdditive +- (e.abelianizationCongr.trans +- (Abelianization.equivOfComm : X ≃* Abelianization X).symm))) = +- MulEquiv.toAdditive +- (((extensionQuotientMulEquiv_transportFiniteGalois +- hAB P hPQ).trans e).abelianizationCongr.trans +- (Abelianization.equivOfComm : X ≃* Abelianization X).symm) := by +- cases hAB +- cases hPQ +- rfl +- +-/-- Package the entire rational finite norm-residue evaluation so that its +-dependent base, extension, quotient and comparison maps move together. -/ +-private def rationalFiniteNormResidueValue +- (K : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (L : FiniteGaloisSubextension K.field) +- {C X : Type} [AddGroup C] [AddGroup X] +- (eIdele : C ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation K.field) +- (eGalois : Additive (Abelianization L.extensionQuotient) ≃+ X) +- (c : C) : X := by +- letI : +- Finite +- (K.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- K.field L.field L.below) := +- L.finite +- exact +- eGalois +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- K L +- (finiteNormClass rationalIdeleClassRepresentation +- K.field L.field L.below (eIdele c))) +- +-/-- The packaged norm-residue value is invariant under rebasing the finite +-abstract field together with all dependent data. -/ +-private theorem rationalFiniteNormResidueValue_transportBase +- {A B : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} +- (hAB : A = B) +- (P : FiniteGaloisSubextension A.field) +- {C X : Type} [AddGroup C] [AddGroup X] +- (eIdele : C ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation A.field) +- (eGalois : Additive (Abelianization P.extensionQuotient) ≃+ X) +- (c : C) : +- rationalFiniteNormResidueValue A P eIdele eGalois c = +- rationalFiniteNormResidueValue B +- (Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension Y.field) +- hAB) +- P) +- (Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- C ≃+ ambientFixedAddSubgroup +- rationalIdeleClassRepresentation Y.field) +- hAB) +- eIdele) +- (abelianizedExtensionQuotientAddEquiv_transportBase +- hAB P eGalois) +- c := by +- cases hAB +- rfl +- +-/-- The packaged norm-residue value is invariant under equality of the finite +-Galois subextension. -/ +-private theorem rationalFiniteNormResidueValue_transportExtension +- (K : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- {P Q : FiniteGaloisSubextension K.field} +- (hPQ : P = Q) +- {C X : Type} [AddGroup C] [AddGroup X] +- (eIdele : C ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation K.field) +- (eGalois : Additive (Abelianization P.extensionQuotient) ≃+ X) +- (c : C) : +- rationalFiniteNormResidueValue K P eIdele eGalois c = +- rationalFiniteNormResidueValue K Q eIdele +- (abelianizedExtensionQuotientAddEquiv_transportExtension +- hPQ eGalois) +- c := by +- cases hPQ +- rfl +- +-/-- Evaluation of the canonical abelianization comparison induced by a +-multiplicative equivalence into a commutative group. -/ +-private theorem abelianizationCongrToComm_apply +- {Q R : Type*} [Group Q] [CommGroup R] +- (e : Q ≃* R) (q : Q) : +- MulEquiv.toAdditive +- (e.abelianizationCongr.trans +- (Abelianization.equivOfComm : R ≃* Abelianization R).symm) +- (Additive.ofMul (Abelianization.of q)) = +- Additive.ofMul (e q) := by +- apply Additive.toMul.injective +- change +- (Abelianization.equivOfComm : R ≃* Abelianization R).symm +- (e.abelianizationCongr (Abelianization.of q)) = e q +- rw [abelianizationCongr_of] +- exact +- (Abelianization.equivOfComm : R ≃* Abelianization R).symm_apply_apply _ +- +-/-- Evaluation of the canonical quotient from the abelianization of a +-commutative group. -/ +-private theorem commutativeAbelianizationEquiv_apply +- {Q R : Type*} [CommGroup Q] [Group R] +- (e : Q ≃* R) (q : Q) : +- MulEquiv.toAdditive +- ((Abelianization.equivOfComm : Q ≃* Abelianization Q).symm.trans e) +- (Additive.ofMul (Abelianization.of q)) = +- Additive.ofMul (e q) := by +- apply Additive.toMul.injective +- change +- e ((Abelianization.equivOfComm : Q ≃* Abelianization Q).symm +- (Abelianization.of q)) = e q +- exact congrArg e +- ((Abelianization.equivOfComm : Q ≃* Abelianization Q).symm_apply_apply q) +- +-section AbstractFixedFieldInclusion +- +-variable +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- +-local instance naturalityAbstractFixedFieldBaseQuotientFinite : +- Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- H.field (le_baseField H.field)) := +- H.finite +- +-local instance naturalityAbstractFixedFieldRelativeQuotientFinite : +- Finite +- (H.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H.field P.field P.below) := +- P.finite +- +-noncomputable local instance +- naturalityAbstractFixedFieldFiniteDimensional : +- FiniteDimensional ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) := +- abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) H.field H.finite +- +-noncomputable local instance +- naturalityAbstractRelativeFixedFieldFiniteDimensional : +- FiniteDimensional +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) := +- abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- H.field P.field P.below H.finite P.finite +- +-local instance naturalityAbstractFixedFieldRelativeScalarTower : +- IsScalarTower ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) := +- IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) +- +-noncomputable local instance +- naturalityAbstractRelativeFixedFieldAbsoluteFiniteDimensional : +- FiniteDimensional ℚ +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) := +- FiniteDimensional.trans ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) +- +-noncomputable local instance naturalityAbstractFixedFieldNumberField : +- NumberField +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) := +- NumberField.of_module_finite ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- +-noncomputable local instance +- naturalityAbstractRelativeFixedFieldNumberField : +- NumberField +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) := +- NumberField.of_module_finite ℚ +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) +- +-/-- Use the same direct fixed-field Galois witness as the intrinsic +-norm-residue construction. This prevents the dependent Galois-group type +-from being synthesized through a second `IsAbelianGalois` instance path. -/ +-noncomputable local instance +- naturalityAbstractRelativeFixedFieldIsGalois : +- IsGalois +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) := +- abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) +- H.field P.field P.below P.normal +- +-noncomputable local instance +- naturalityAbstractRelativeFixedFieldIsAbelianGalois : +- IsAbelianGalois +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) := +- finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P +- +-/-- The lower subgroup obtained from the canonical inclusion of an abstract +-fixed-field tower is the original lower closed subgroup. -/ +-private theorem +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- numberFieldEmbeddedBaseSubgroup F E j = H.field := by +- dsimp only +- have hi : +- numberFieldEmbeddedLowerEmbedding +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) +- ((abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ) = +- (abstractFixedField +- ℚ (SeparableClosure ℚ) H.field).val := by +- ext x +- rfl +- have hRange : +- (numberFieldEmbeddedLowerEmbedding +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) +- ((abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ)).fieldRange = +- abstractFixedField ℚ (SeparableClosure ℚ) H.field := by +- ext x +- constructor +- · rintro ⟨y, rfl⟩ +- change +- numberFieldEmbeddedLowerEmbedding +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field) +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) +- ((abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ) y ∈ +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- rw [hi] +- exact y.property +- · intro hx +- refine ⟨⟨x, hx⟩, ?_⟩ +- rw [hi] +- rfl +- rw [numberFieldEmbeddedBaseSubgroup, hRange] +- exact +- closedFixingSubgroup_abstractFixedField_eq +- ℚ (SeparableClosure ℚ) H.field +- +-/-- The upper subgroup obtained from the canonical inclusion of an abstract +-fixed-field tower is the original upper closed subgroup. -/ +-private theorem +- numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- numberFieldEmbeddedTopSubgroup F E j = P.field := by +- dsimp only +- rw [numberFieldEmbeddedTopSubgroup] +- have hjRangeSelf : +- ((abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ).fieldRange = +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below).restrictScalars ℚ := by +- ext x +- constructor +- · rintro ⟨y, rfl⟩ +- exact y.property +- · intro hx +- exact ⟨⟨x, hx⟩, rfl⟩ +- have hjRange : +- ((abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ).fieldRange = +- abstractFixedField ℚ (SeparableClosure ℚ) P.field := by +- exact hjRangeSelf.trans +- (IntermediateField.extendScalars_restrictScalars +- (abstractFixedField_le +- ℚ (SeparableClosure ℚ) P.below)) +- rw [hjRange] +- exact +- closedFixingSubgroup_abstractFixedField_eq +- ℚ (SeparableClosure ℚ) P.field +- +-/-- Transport a packaged rational norm-residue value directly from an equal +-abstract base to the finite Galois extension underlying `P`. Keeping the two +-dependent transports in their own declaration prevents their elaboration cost +-from accumulating in the main fixed-field comparison theorem. -/ +-private theorem rationalFiniteNormResidueValue_transportToAbstractExtension +- {A : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} +- (hAH : A = H) +- (L : FiniteGaloisSubextension A.field) +- (hLP : +- Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension Y.field) +- hAH) +- L = +- P.toFiniteGaloisExtension) +- {C X : Type} [AddGroup C] [AddGroup X] +- (eIdele : C ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation A.field) +- (eGalois : Additive (Abelianization L.extensionQuotient) ≃+ X) +- (c : C) : +- rationalFiniteNormResidueValue A L eIdele eGalois c = +- rationalFiniteNormResidueValue H P.toFiniteGaloisExtension +- (Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- C ≃+ ambientFixedAddSubgroup +- rationalIdeleClassRepresentation Y.field) +- hAH) +- eIdele) +- (abelianizedExtensionQuotientAddEquiv_transportExtension hLP +- (abelianizedExtensionQuotientAddEquiv_transportBase +- hAH L eGalois)) +- c := by +- calc +- _ = rationalFiniteNormResidueValue H +- (Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension Y.field) +- hAH) +- L) +- (Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- C ≃+ ambientFixedAddSubgroup +- rationalIdeleClassRepresentation Y.field) +- hAH) +- eIdele) +- (abelianizedExtensionQuotientAddEquiv_transportBase hAH L eGalois) +- c := +- rationalFiniteNormResidueValue_transportBase +- (A := A) (B := H) (C := C) (X := X) +- hAH L eIdele eGalois c +- _ = _ := +- rationalFiniteNormResidueValue_transportExtension +- (K := H) +- (P := Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension Y.field) +- hAH) +- L) +- (Q := P.toFiniteGaloisExtension) (C := C) (X := X) +- hLP +- (Eq.mp +- (congrArg +- (fun Y : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- C ≃+ ambientFixedAddSubgroup +- rationalIdeleClassRepresentation Y.field) +- hAH) +- eIdele) +- (abelianizedExtensionQuotientAddEquiv_transportBase hAH L eGalois) +- c +- +-/-- The packaged value at the literal fixed-field realization is the ambient +-fixed-part norm-residue homomorphism evaluated at the same idele class. -/ +-private theorem rationalFiniteNormResidueValue_abstractFixedField_eq_ambient +- (c : IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) : +- rationalFiniteNormResidueValue H P.toFiniteGaloisExtension +- (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) +- (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P) +- (Additive.ofMul c) = +- ambientFixedGlobalNormResidueAddMonoidHom H P +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- H.field (Additive.ofMul c)) := by +- let eRec := +- rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- H P.toFiniteGaloisExtension +- let eGal := +- abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P +- change +- eGal +- (eRec +- (finiteNormClass rationalIdeleClassRepresentation +- H.field P.field P.below +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- H.field (Additive.ofMul c)))) = +- eGal +- (eRec +- (finiteNormClass rationalIdeleClassRepresentation +- H.field P.field P.below +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- H.field (Additive.ofMul c)))) +- rfl +- +-/-- The packaged norm-residue value for the literal fixed-field realization +-is the intrinsic abstract fixed-field norm-residue value. -/ +-private theorem rationalFiniteNormResidueValue_abstractFixedField_apply +- (c : IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) : +- Additive.toMul +- (rationalFiniteNormResidueValue H P.toFiniteGaloisExtension +- (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) +- (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup +- H P) +- (Additive.ofMul c)) = +- abstractFixedFieldGlobalNormResidueMonoidHom H P c := by +- let a := +- rationalAbstractFixedFieldIdeleClassEquivFixed +- H.field (Additive.ofMul c) +- have hAbstract := +- abstractFixedFieldGlobalNormResidueMonoidHom_fixed_apply H P a +- calc +- _ = Additive.toMul +- (ambientFixedGlobalNormResidueAddMonoidHom H P +- (rationalAbstractFixedFieldIdeleClassEquivFixed +- H.field (Additive.ofMul c))) := by +- exact congrArg Additive.toMul +- (rationalFiniteNormResidueValue_abstractFixedField_eq_ambient +- (H := H) (P := P) c) +- _ = _ := by +- simpa only [a, AddEquiv.symm_apply_apply, toMul_ofMul] using +- hAbstract.symm +- +-/-- The finite abstract field reconstructed from the literal fixed-field +-inclusion is the original packaged abstract field. Keeping this structure +-equality separate avoids repeatedly rebuilding all of its proof fields. -/ +-private theorem +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- numberFieldEmbeddedFiniteAbstractField F E j = H := by +- dsimp only +- exact FiniteAbstractField.eq_of_field_eq _ _ +- (numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P) +- +-/-- Pointwise specification of the idele-class comparison after transporting +-the explicitly embedded abstract field to the canonical packaged field. The +-transport is kept at the value boundary, so clients never compare the two +-dependent additive equivalences themselves. -/ +-private theorem +- numberFieldEmbeddedIdeleClassEquivAmbientFixed_transport_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (c : Additive +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- Additive (IdeleClassGroup F) ≃+ +- ambientFixedAddSubgroup +- rationalIdeleClassRepresentation X.field) +- hHEmbedded) +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j) c = +- rationalAbstractFixedFieldIdeleClassEquivFixed H.field c := by +- dsimp only +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- have hHEmbedded : +- numberFieldEmbeddedFiniteAbstractField F E j = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- have hFixedBase : +- abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup F E j) = F := +- congrArg +- (abstractFixedField ℚ (SeparableClosure ℚ)) hBase +- let eBase : F ≃ₐ[ℚ] F := +- (numberFieldEmbeddedAbstractBaseFieldEquiv F E j).trans +- (IntermediateField.equivOfEq hFixedBase) +- have heBase : +- eBase = (AlgEquiv.refl : F ≃ₐ[ℚ] F) := by +- apply AlgEquiv.ext +- intro x +- apply Subtype.ext +- change x.1 = x.1 +- rfl +- let hEmbeddedQuotientFinite := +- numberFieldEmbeddedAbsoluteQuotientFinite F E j +- let hEmbeddedFixedFiniteDimensional := +- numberFieldEmbeddedAbstractFixedFieldFiniteDimensional F E j +- apply Subtype.ext +- rw [rationalAmbientFixedAddEquiv_transport_apply_val +- hHEmbedded +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j) c] +- dsimp only [numberFieldEmbeddedIdeleClassEquivAmbientFixed] +- simp only [AddEquiv.trans_apply] +- change +- ((rationalIdeleClassEquivFixed +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup F E j))) +- (MulEquiv.toAdditive +- (ideleClassCongr +- (numberFieldEmbeddedAbstractBaseFieldEquiv F E j)) c)).1 = +- ((rationalIdeleClassEquivFixed F) c).1 +- exact rationalIdeleClassEquivFixed_congr_apply_val +- hFixedBase +- (numberFieldEmbeddedAbstractBaseFieldEquiv F E j) +- heBase c +- +-/-- Transporting the finite Galois subextension reconstructed from the literal +-fixed-field inclusion recovers the canonical subextension packaged by `P`. +-This is the sole dependent structure equality used by the later quotient +-comparisons. -/ +-private theorem +- numberFieldEmbeddedFiniteGaloisSubextension_transport_eq +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- let hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension X.field) +- hHEmbedded) +- PEmbedded = +- P.toFiniteGaloisExtension := by +- dsimp only +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- exact finiteGaloisSubextension_transport_eq_of_field_eq +- hHEmbedded PEmbedded P.toFiniteGaloisExtension +- (numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P) +- +-/-- Opaque endpoint for the extension-quotient comparison supplied by the +-literal embedding. Its domain is already the canonical quotient of `P`, so +-no client has to reconstruct the two subgroup transports. -/ +-private noncomputable def +- abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- P.toFiniteGaloisExtension.extensionQuotient ≃* +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- have hTop : +- numberFieldEmbeddedTopSubgroup F E j = P.field := +- numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P +- letI hAlgebra : Algebra F (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra F E j +- let eSep := +- numberFieldEmbeddedSeparableClosureEquiv F E j +- letI hEmbeddedExtensionNormal : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal F E j +- exact +- P.toFiniteGaloisExtension.extensionQuotientMulEquiv.trans +- ((extensionQuotientMulEquivOfEq +- hBase.symm hTop.symm P.below +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).trans +- (ambientEmbeddedExtensionQuotientEquivGaloisGroup +- ℚ F E j eSep)) +- +-/-- Opaque canonical endpoint for the same quotient, obtained directly from +-the abstract fixed-field realization. -/ +-private noncomputable def +- abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- P.toFiniteGaloisExtension.extensionQuotient ≃* +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by +- exact +- P.toFiniteGaloisExtension.extensionQuotientMulEquiv.trans +- (abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) +- H.field P.field P.below P.normal) +- +-/-- Pointwise opaque endpoint of the embedded quotient equivalence. -/ +-private noncomputable def +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) : +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := +- abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv H P q +- +-/-- Pointwise opaque endpoint of the canonical quotient equivalence. -/ +-private noncomputable def +- abstractFixedFieldInclusionCanonicalExtensionQuotientValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) : +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := +- abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv H P q +- +-/-- Fully applied ambient value of the embedded quotient endpoint. -/ +-private noncomputable def +- abstractFixedFieldInclusionEmbeddedExtensionQuotientApplyVal +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := +- (abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q x : +- SeparableClosure ℚ) +- +-/-- Fully applied ambient value of the canonical quotient endpoint. -/ +-private noncomputable def +- abstractFixedFieldInclusionCanonicalExtensionQuotientApplyVal +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := +- (abstractFixedFieldInclusionCanonicalExtensionQuotientValue H P q x : +- SeparableClosure ℚ) +- +-/-- The ambient Galois value attached to a representative of the canonical +-quotient, packaged behind a literal result type. -/ +-private noncomputable def +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) : +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- letI hAlgebra : Algebra F (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra F E j +- let eSep := +- numberFieldEmbeddedSeparableClosureEquiv F E j +- letI hEmbeddedExtensionNormal : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal F E j +- let σEmbedded : +- (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := +- (MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ +- exact +- ambientEmbeddedExtensionQuotientEquivGaloisGroup +- ℚ F E j eSep (QuotientGroup.mk σEmbedded) +- +-/-- Fully applied ambient value of the packaged representative endpoint. -/ +-private noncomputable def +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := +- (abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue H P σ x : +- SeparableClosure ℚ) +- +-/-- Ambient action of the representative after rebundling it in the embedded +-base subgroup. -/ +-private noncomputable def +- abstractFixedFieldInclusionRebasedAutomorphismApplyVal +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- let σEmbedded : +- (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := +- (MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ +- exact σEmbedded.1.1 (x : SeparableClosure ℚ) +- +-/-- The embedded quotient endpoint sends a canonical representative to the +-packaged ambient value above. -/ +-private theorem +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue_mk +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) : +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P +- (P.toFiniteGaloisExtension.extensionQuotientMk σ) = +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue H P σ := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- have hTop : +- numberFieldEmbeddedTopSubgroup F E j = P.field := +- numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P +- let hAlgebra : Algebra F (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra F E j +- let eSep := +- numberFieldEmbeddedSeparableClosureEquiv F E j +- let hEmbeddedExtensionNormal : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal F E j +- simp only [ +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue, +- abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv, +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue, +- MulEquiv.trans_apply, +- FiniteGaloisSubextension.extensionQuotientMk_apply] +- exact congrArg +- (ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ F E j eSep) +- (extensionQuotientMulEquivOfEq_mk +- hBase.symm hTop.symm P.below +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j) σ) +- +-/-- The packaged ambient endpoint evaluates to the action of the rebundled +-representative. -/ +-private theorem +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal_eq_rebased +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal H P σ x = +- abstractFixedFieldInclusionRebasedAutomorphismApplyVal H P σ x := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- let hAlgebra : Algebra F (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra F E j +- let eSep := +- numberFieldEmbeddedSeparableClosureEquiv F E j +- let hEmbeddedExtensionNormal : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal F E j +- let σEmbedded : +- (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := +- (MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ +- have hmk := +- ambientEmbeddedExtensionQuotientEquivGaloisGroup_mk_apply +- ℚ F E j eSep σEmbedded x +- change +- (ambientEmbeddedExtensionQuotientEquivGaloisGroup +- ℚ F E j eSep (QuotientGroup.mk σEmbedded) x : +- SeparableClosure ℚ) = +- σEmbedded.1.1 (x : SeparableClosure ℚ) at hmk +- simpa only [ +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal, +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue, +- abstractFixedFieldInclusionRebasedAutomorphismApplyVal] using hmk +- +-/-- Rebundling the representative does not change its action in the ambient +-separable closure. -/ +-private theorem +- abstractFixedFieldInclusionRebasedAutomorphismApplyVal_eq +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : +- abstractFixedFieldInclusionRebasedAutomorphismApplyVal H P σ x = +- σ.1.1 (x : SeparableClosure ℚ) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- let σEmbedded : +- (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := +- (MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ +- have hσEmbedded : +- (σEmbedded.1 : SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) = σ.1 := +- closedSubgroupCongr_apply_val hBase.symm σ +- change σEmbedded.1.1 (x : SeparableClosure ℚ) = _ +- rw [hσEmbedded] +- +-/-- The packaged ambient representative acts by the original automorphism on +-the underlying separable-closure value. -/ +-private theorem +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal H P σ x = +- σ.1.1 (x : SeparableClosure ℚ) := by +- exact +- (abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal_eq_rebased +- H P σ x).trans +- (abstractFixedFieldInclusionRebasedAutomorphismApplyVal_eq H P σ x) +- +-/-- Evaluation of the embedded quotient endpoint on a canonical quotient +-representative, stated only in the ambient separable closure. -/ +-private theorem +- abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv_mk_val +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : +- abstractFixedFieldInclusionEmbeddedExtensionQuotientApplyVal H P +- (P.toFiniteGaloisExtension.extensionQuotientMk σ) x = +- σ.1.1 (x : SeparableClosure ℚ) := by +- calc +- _ = abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal +- H P σ x := by +- exact congrArg +- (fun g => (g x : SeparableClosure ℚ)) +- (abstractFixedFieldInclusionEmbeddedExtensionQuotientValue_mk +- H P σ) +- _ = _ := +- abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue_apply +- H P σ x +- +-/-- Evaluation of the canonical abstract quotient endpoint on a quotient +-representative, again exposed only through its ambient value. -/ +-private theorem +- abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv_mk_val +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) +- (x : abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) : +- abstractFixedFieldInclusionCanonicalExtensionQuotientApplyVal H P +- (P.toFiniteGaloisExtension.extensionQuotientMk σ) x = +- σ.1.1 (x : SeparableClosure ℚ) := by +- simp only [ +- abstractFixedFieldInclusionCanonicalExtensionQuotientApplyVal, +- abstractFixedFieldInclusionCanonicalExtensionQuotientValue, +- abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv, +- MulEquiv.trans_apply, +- FiniteGaloisSubextension.extensionQuotientMk_apply] +- exact +- (abstractExtensionQuotientEquivGaloisGroup_mk_apply_val +- ℚ (SeparableClosure ℚ) +- H.field P.field P.below P.normal σ x).symm +- +-/-- The embedded and canonical quotient endpoints agree on each quotient +-class. This pointwise boundary is intentionally weaker than equality of the +-dependent `MulEquiv` structures. -/ +-private theorem +- abstractFixedFieldInclusionExtensionQuotientEquiv_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) : +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q = +- abstractFixedFieldInclusionCanonicalExtensionQuotientValue H P q := by +- refine P.toFiniteGaloisExtension.extensionQuotient_inductionOn +- (motive := fun q => +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q = +- abstractFixedFieldInclusionCanonicalExtensionQuotientValue H P q) +- q ?_ +- intro σ +- apply AlgEquiv.ext +- intro x +- apply Subtype.ext +- exact +- (abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv_mk_val +- H P σ x).trans +- (abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv_mk_val +- H P σ x).symm +- +-/-- Opaque quotient endpoint obtained by transporting the explicitly embedded +-finite Galois subextension back to the canonical package. -/ +-private noncomputable def +- abstractFixedFieldInclusionTransportedExtensionQuotientEquiv +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- P.toFiniteGaloisExtension.extensionQuotient ≃* +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- have hPEmbedded : +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension X.field) +- hHEmbedded) +- PEmbedded = +- P.toFiniteGaloisExtension := +- numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P +- exact +- (extensionQuotientMulEquiv_transportFiniteGalois +- hHEmbedded PEmbedded hPEmbedded).trans +- (numberFieldEmbeddedExtensionQuotientEquivGaloisGroup F E j) +- +-/-- Pointwise opaque endpoint of the transported quotient equivalence. -/ +-private noncomputable def +- abstractFixedFieldInclusionTransportedExtensionQuotientValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) : +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := +- abstractFixedFieldInclusionTransportedExtensionQuotientEquiv H P q +- +-/-- Transporting a canonical representative of the embedded finite Galois +-package preserves its Galois value. -/ +-private theorem +- abstractFixedFieldInclusionTransportedExtensionQuotientValue_mk +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (σ : H.field.toSubgroup) : +- abstractFixedFieldInclusionTransportedExtensionQuotientValue H P +- (P.toFiniteGaloisExtension.extensionQuotientMk σ) = +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P +- (P.toFiniteGaloisExtension.extensionQuotientMk σ) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hBase : +- numberFieldEmbeddedBaseSubgroup F E j = H.field := +- numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P +- have hTop : +- numberFieldEmbeddedTopSubgroup F E j = P.field := +- numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- have hPEmbedded : +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension X.field) +- hHEmbedded) +- PEmbedded = +- P.toFiniteGaloisExtension := +- numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P +- let hAlgebra : Algebra F (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra F E j +- let eSep := +- numberFieldEmbeddedSeparableClosureEquiv F E j +- let hEmbeddedExtensionNormal : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup F E j) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal F E j +- have hFieldEq : +- (congrArg FiniteAbstractField.field hHEmbedded).symm = hBase.symm := +- Subsingleton.elim _ _ +- simp only [ +- abstractFixedFieldInclusionTransportedExtensionQuotientValue, +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue, +- abstractFixedFieldInclusionTransportedExtensionQuotientEquiv, +- abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv, +- MulEquiv.trans_apply, +- extensionQuotientMulEquiv_transportFiniteGalois_mk, +- FiniteGaloisSubextension.extensionQuotientMk_apply, +- numberFieldEmbeddedExtensionQuotientEquivGaloisGroup] +- rw [hFieldEq] +- change +- ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ F E j eSep +- (QuotientGroup.mk +- ((MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ)) = _ +- exact +- (congrArg +- (ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ F E j eSep) +- (extensionQuotientMulEquivOfEq_mk +- hBase.symm hTop.symm P.below +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j) σ)).symm +- +-/-- Transporting the embedded finite Galois package preserves the value of +-its extension-quotient comparison. -/ +-private theorem +- abstractFixedFieldInclusionTransportedExtensionQuotientEquiv_apply +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) : +- abstractFixedFieldInclusionTransportedExtensionQuotientValue H P q = +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q := by +- refine P.toFiniteGaloisExtension.extensionQuotient_inductionOn +- (motive := fun q => +- abstractFixedFieldInclusionTransportedExtensionQuotientValue H P q = +- abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q) +- q ?_ +- intro σ +- exact abstractFixedFieldInclusionTransportedExtensionQuotientValue_mk +- H P σ +- +-/-- Opaque abelianized equivalence obtained by transporting the explicitly +-embedded finite Galois package to the canonical one. -/ +-private noncomputable def +- abstractFixedFieldInclusionTransportedAbelianizedEquiv +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- Additive +- (Abelianization +- P.toFiniteGaloisExtension.extensionQuotient) ≃+ +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- have hPEmbedded : +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension X.field) +- hHEmbedded) +- PEmbedded = +- P.toFiniteGaloisExtension := +- numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P +- exact +- abelianizedExtensionQuotientAddEquiv_transportExtension hPEmbedded +- (abelianizedExtensionQuotientAddEquiv_transportBase +- hHEmbedded PEmbedded +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- F E j)) +- +-/-- Canonical abelianization comparison built from the already transported +-opaque extension-quotient endpoint. -/ +-private noncomputable def +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- Additive +- (Abelianization +- P.toFiniteGaloisExtension.extensionQuotient) ≃+ +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by +- let Q := +- Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) +- exact +- MulEquiv.toAdditive +- ((MulEquiv.abelianizationCongr +- (abstractFixedFieldInclusionTransportedExtensionQuotientEquiv H P)).trans +- (Abelianization.equivOfComm : Q ≃* Abelianization Q).symm) +- +-/-- Pointwise opaque value of the transported abelianized equivalence. -/ +-private noncomputable def +- abstractFixedFieldInclusionTransportedAbelianizedValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (z : Additive +- (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := +- abstractFixedFieldInclusionTransportedAbelianizedEquiv H P z +- +-/-- Pointwise opaque value of the canonical abelianization comparison built +-from the transported quotient endpoint. -/ +-private noncomputable def +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (z : Additive +- (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv H P z +- +-/-- Pointwise opaque value of the intrinsic abstract fixed-field +-abelianization comparison. -/ +-private noncomputable def +- abstractFixedFieldInclusionCanonicalAbelianizedValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (z : Additive +- (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := +- abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P z +- +-/-- The transported abelianized endpoint agrees pointwise with the canonical +-abelianization comparison built from the transported quotient endpoint. -/ +-private theorem +- abstractFixedFieldInclusionTransportedAbelianizedValue_eq_canonical +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (z : Additive +- (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : +- abstractFixedFieldInclusionTransportedAbelianizedValue H P z = +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue +- H P z := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- have hPEmbedded : +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension X.field) +- hHEmbedded) +- PEmbedded = +- P.toFiniteGaloisExtension := +- numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P +- let qEmbedded : PEmbedded.extensionQuotient ≃* Gal(E / F) := +- numberFieldEmbeddedExtensionQuotientEquivGaloisGroup F E j +- have hCanonical : +- abstractFixedFieldInclusionTransportedAbelianizedEquiv H P = +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv +- H P := by +- simpa only [ +- abstractFixedFieldInclusionTransportedAbelianizedEquiv, +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv, +- abstractFixedFieldInclusionTransportedExtensionQuotientEquiv, +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup, +- qEmbedded] using +- (abelianizedCanonicalEquiv_transportFiniteGalois +- hHEmbedded PEmbedded hPEmbedded qEmbedded) +- exact DFunLike.congr_fun hCanonical z +- +-/-- On an abelianization representative, the transported canonical endpoint +-is the additive value of the transported quotient endpoint. -/ +-private theorem +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_of +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) : +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue H P +- (Additive.ofMul (Abelianization.of q)) = +- Additive.ofMul +- (abstractFixedFieldInclusionTransportedExtensionQuotientValue +- H P q) := by +- simpa only [ +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue, +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv, +- abstractFixedFieldInclusionTransportedExtensionQuotientValue] using +- (abelianizationCongrToComm_apply +- (abstractFixedFieldInclusionTransportedExtensionQuotientEquiv H P) q) +- +-/-- On the same representative, the intrinsic fixed-field endpoint is the +-additive value of the canonical quotient endpoint. -/ +-private theorem +- abstractFixedFieldInclusionCanonicalAbelianizedValue_of +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (q : P.toFiniteGaloisExtension.extensionQuotient) : +- abstractFixedFieldInclusionCanonicalAbelianizedValue H P +- (Additive.ofMul (Abelianization.of q)) = +- Additive.ofMul +- (abstractFixedFieldInclusionCanonicalExtensionQuotientValue +- H P q) := by +- let hRawQuotientCommGroup : +- CommGroup P.toFiniteGaloisExtension.extensionQuotient := +- { (inferInstance : +- Group P.toFiniteGaloisExtension.extensionQuotient) with +- mul_comm := P.commutative.is_comm.comm } +- let qAbstractRaw := +- abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv H P +- change +- MulEquiv.toAdditive +- ((Abelianization.equivOfComm : +- P.toFiniteGaloisExtension.extensionQuotient ≃* +- Abelianization +- P.toFiniteGaloisExtension.extensionQuotient).symm.trans +- qAbstractRaw) +- (Additive.ofMul (Abelianization.of q)) = +- Additive.ofMul (qAbstractRaw q) +- exact commutativeAbelianizationEquiv_apply qAbstractRaw q +- +-/-- The canonical abelianization comparison built after transport agrees +-pointwise with the intrinsic abstract fixed-field comparison. -/ +-private theorem +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_eq +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (z : Additive +- (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue H P z = +- abstractFixedFieldInclusionCanonicalAbelianizedValue H P z := by +- let q : P.toFiniteGaloisExtension.extensionQuotient := +- Quotient.out z.toMul +- have hz : Additive.ofMul (Abelianization.of q) = z := by +- apply Additive.ext +- exact Quotient.out_eq' z.toMul +- rw [← hz] +- calc +- _ = Additive.ofMul +- (abstractFixedFieldInclusionTransportedExtensionQuotientValue +- H P q) := +- abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_of +- H P q +- _ = Additive.ofMul +- (abstractFixedFieldInclusionEmbeddedExtensionQuotientValue +- H P q) := +- congrArg Additive.ofMul +- (abstractFixedFieldInclusionTransportedExtensionQuotientEquiv_apply +- H P q) +- _ = Additive.ofMul +- (abstractFixedFieldInclusionCanonicalExtensionQuotientValue +- H P q) := +- congrArg Additive.ofMul +- (abstractFixedFieldInclusionExtensionQuotientEquiv_apply H P q) +- _ = _ := +- (abstractFixedFieldInclusionCanonicalAbelianizedValue_of H P q).symm +- +-/-- The transported abelianized equivalence agrees pointwise with the +-intrinsic abstract fixed-field Galois comparison. -/ +-private theorem +- abstractFixedFieldInclusionTransportedAbelianizedValue_eq +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (z : Additive +- (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : +- abstractFixedFieldInclusionTransportedAbelianizedValue H P z = +- abstractFixedFieldInclusionCanonicalAbelianizedValue H P z := +- (abstractFixedFieldInclusionTransportedAbelianizedValue_eq_canonical +- H P z).trans +- (abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_eq +- H P z) +- +-/-- Opaque packaged norm-residue value before transporting the explicitly +-embedded abstract field and finite Galois package. -/ +-private noncomputable def +- abstractFixedFieldInclusionEmbeddedNormResidueValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (c : Additive +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- exact +- rationalFiniteNormResidueValue HEmbedded PEmbedded +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j) +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- F E j) +- c +- +-/-- Opaque packaged value after transporting both dependent structures to +-the canonical `H` and `P` endpoints. -/ +-private noncomputable def +- abstractFixedFieldInclusionTransportedNormResidueValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (c : Additive +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- let eIdeleEmbedded := +- numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j +- let eIdeleOverH : +- Additive (IdeleClassGroup F) ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation H.field := +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- Additive (IdeleClassGroup F) ≃+ +- ambientFixedAddSubgroup +- rationalIdeleClassRepresentation X.field) +- hHEmbedded) +- eIdeleEmbedded +- exact +- rationalFiniteNormResidueValue H P.toFiniteGaloisExtension +- eIdeleOverH +- (abstractFixedFieldInclusionTransportedAbelianizedEquiv H P) +- c +- +-/-- Opaque intrinsic packaged norm-residue value at the canonical endpoints. -/ +-private noncomputable def +- abstractFixedFieldInclusionCanonicalNormResidueValue +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (c : Additive +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : +- Additive +- (Gal( +- (abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below) / +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := +- rationalFiniteNormResidueValue H P.toFiniteGaloisExtension +- (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) +- (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P) +- c +- +-/-- Simultaneous transport of the embedded abstract field and finite Galois +-package sends the embedded norm-residue value to the transported endpoint. -/ +-private theorem +- abstractFixedFieldInclusionEmbeddedNormResidueValue_eq_transported +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (c : Additive +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : +- abstractFixedFieldInclusionEmbeddedNormResidueValue H P c = +- abstractFixedFieldInclusionTransportedNormResidueValue H P c := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- let PEmbedded : FiniteGaloisSubextension HEmbedded.field := +- numberFieldEmbeddedFiniteGaloisSubextension F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- have hPEmbedded : +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- FiniteGaloisSubextension X.field) +- hHEmbedded) +- PEmbedded = +- P.toFiniteGaloisExtension := +- numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P +- let eIdeleEmbedded := +- numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j +- let eGaloisEmbedded := +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup F E j +- simpa only [ +- abstractFixedFieldInclusionEmbeddedNormResidueValue, +- abstractFixedFieldInclusionTransportedNormResidueValue, +- abstractFixedFieldInclusionTransportedAbelianizedEquiv, +- eIdeleEmbedded, +- eGaloisEmbedded] using +- (rationalFiniteNormResidueValue_transportToAbstractExtension +- (H := H) (P := P) +- (A := HEmbedded) +- (C := Additive (IdeleClassGroup F)) +- (X := Additive Gal(E / F)) +- hHEmbedded PEmbedded hPEmbedded +- eIdeleEmbedded eGaloisEmbedded c) +- +-/-- A packaged finite norm-residue value depends only on the value of its +-idele comparison at the chosen input and the value of its Galois comparison +-at the resulting norm class. -/ +-private theorem rationalFiniteNormResidueValue_congr_apply +- (K : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (L : FiniteGaloisSubextension K.field) +- {C X : Type} [AddGroup C] [AddGroup X] +- (eIdele eIdele' : C ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation K.field) +- (eGalois eGalois' : +- Additive (Abelianization L.extensionQuotient) ≃+ X) +- (c : C) +- (heIdele : eIdele c = eIdele' c) +- (heGalois : ∀ z, eGalois z = eGalois' z) : +- rationalFiniteNormResidueValue K L eIdele eGalois c = +- rationalFiniteNormResidueValue K L eIdele' eGalois' c := by +- unfold rationalFiniteNormResidueValue +- rw [heIdele] +- exact heGalois _ +- +-/-- The transported packaged value is the intrinsic canonical packaged value; +-only the idele input and the eventual abelianized value are compared. -/ +-private theorem +- abstractFixedFieldInclusionTransportedNormResidueValue_eq_canonical +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (c : Additive +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : +- abstractFixedFieldInclusionTransportedNormResidueValue H P c = +- abstractFixedFieldInclusionCanonicalNormResidueValue H P c := by +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- let HEmbedded := +- numberFieldEmbeddedFiniteAbstractField F E j +- have hHEmbedded : HEmbedded = H := +- numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P +- let eIdeleEmbedded := +- numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j +- let eIdeleOverH : +- Additive (IdeleClassGroup F) ≃+ +- ambientFixedAddSubgroup rationalIdeleClassRepresentation H.field := +- Eq.mp +- (congrArg +- (fun X : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => +- Additive (IdeleClassGroup F) ≃+ +- ambientFixedAddSubgroup +- rationalIdeleClassRepresentation X.field) +- hHEmbedded) +- eIdeleEmbedded +- simpa only [ +- abstractFixedFieldInclusionTransportedNormResidueValue, +- abstractFixedFieldInclusionCanonicalNormResidueValue, +- eIdeleEmbedded, +- eIdeleOverH] using +- (rationalFiniteNormResidueValue_congr_apply +- H P.toFiniteGaloisExtension +- eIdeleOverH +- (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) +- (abstractFixedFieldInclusionTransportedAbelianizedEquiv H P) +- (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P) +- c +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed_transport_apply H P c) +- (fun z => abstractFixedFieldInclusionTransportedAbelianizedValue_eq +- H P z)) +- +-/-- The explicitly embedded and intrinsic packaged norm-residue values agree. -/ +-private theorem +- abstractFixedFieldInclusionEmbeddedNormResidueValue_eq +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) +- (c : Additive +- (IdeleClassGroup +- (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : +- abstractFixedFieldInclusionEmbeddedNormResidueValue H P c = +- abstractFixedFieldInclusionCanonicalNormResidueValue H P c := +- (abstractFixedFieldInclusionEmbeddedNormResidueValue_eq_transported +- H P c).trans +- (abstractFixedFieldInclusionTransportedNormResidueValue_eq_canonical +- H P c) +- +-/-- For the literal fixed fields attached to an abstract finite abelian +-extension, the norm-residue map obtained from their canonical inclusion in +-the rational separable closure is the intrinsic fixed-field norm-residue +-map. -/ +-theorem +- globalNormResidueMonoidHomOfEmbedding_abstractFixedFieldInclusion +- (H : FiniteAbstractField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- (P : FiniteAbelianSubextension H.field) : +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H.field +- let E := +- abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- globalNormResidueMonoidHomOfEmbedding F E j = +- abstractFixedFieldGlobalNormResidueMonoidHom H P := by +- dsimp only +- apply MonoidHom.ext +- intro c +- rw [globalNormResidueMonoidHomOfEmbedding_apply] +- change +- Additive.toMul +- (abstractFixedFieldInclusionEmbeddedNormResidueValue +- H P (Additive.ofMul c)) = +- abstractFixedFieldGlobalNormResidueMonoidHom H P c +- calc +- _ = Additive.toMul +- (abstractFixedFieldInclusionCanonicalNormResidueValue +- H P (Additive.ofMul c)) := +- congrArg Additive.toMul +- (abstractFixedFieldInclusionEmbeddedNormResidueValue_eq +- H P (Additive.ofMul c)) +- _ = _ := by +- simpa only [abstractFixedFieldInclusionCanonicalNormResidueValue] using +- (rationalFiniteNormResidueValue_abstractFixedField_apply +- (H := H) (P := P) c) +- +-end AbstractFixedFieldInclusion +- +-section EmbeddedNumberFieldRestriction +- +-variable +- (K K' L L' : Type) +- [Field K] [NumberField K] +- [Field K'] [NumberField K'] +- [Field L] [NumberField L] +- [Field L'] [NumberField L'] +- [Algebra K K'] [Algebra K L] [Algebra K L'] +- [Algebra K' L'] [Algebra L L'] +- [IsScalarTower K K' L'] [IsScalarTower K L L'] +- +- +-/-- Rebracketing the compatible tower does not change its embedded lower +-fixing subgroup. -/ +-private theorem numberFieldEmbeddedBaseSubgroup_baseChange_eq +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j) = +- numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')) := by +- have hi : +- numberFieldEmbeddedLowerEmbedding K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j) = +- numberFieldEmbeddedLowerEmbedding K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')) := by +- ext x +- simp only [numberFieldEmbeddedLowerEmbedding, AlgHom.comp_apply, +- IsScalarTower.coe_toAlgHom'] +- rw [← IsScalarTower.algebraMap_apply K K' L', +- ← IsScalarTower.algebraMap_apply K L L'] +- simp only [numberFieldEmbeddedBaseSubgroup, hi] +- +-omit [Field K] [NumberField K] +- [Algebra K K'] [Algebra K L'] [IsScalarTower K K' L'] in +-/-- The top subgroup of the rebracketed base-change tower is the embedded +-fixing subgroup of the intermediate field. -/ +-private theorem numberFieldEmbeddedTopSubgroup_baseChange_eq +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- numberFieldEmbeddedTopSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j) = +- numberFieldEmbeddedBaseSubgroup K' L' j := by +- rfl +- +-/-- Reidentify the two presentations of the embedded lower fixing subgroup +-without transporting dependent subgroup data through an equality. -/ +-private noncomputable def numberFieldEmbeddedBaseChangeBaseEquiv +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- (numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup ≃* +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup := +- MulEquiv.subgroupCongr +- (congrArg ClosedSubgroup.toSubgroup +- (numberFieldEmbeddedBaseSubgroup_baseChange_eq K K' L L' j)) +- +-/-- Under the identity equivalence of the two lower fixing subgroups, the +-relative subgroup for the base change is exactly the target presentation. -/ +-private theorem numberFieldEmbeddedBaseChangeExtensionSubgroup_map_eq +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)) +- (numberFieldEmbeddedTopSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j))).map +- (numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j).toMonoidHom = +- CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) := by +- let e := numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j +- have hTop : +- (numberFieldEmbeddedTopSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup = +- (numberFieldEmbeddedBaseSubgroup K' L' j).toSubgroup := +- congrArg ClosedSubgroup.toSubgroup +- (numberFieldEmbeddedTopSubgroup_baseChange_eq +- (K := K) (K' := K') (L' := L') j) +- ext x +- constructor +- · rintro ⟨y, hy, rfl⟩ +- change +- ((e y : +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup) : +- SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) ∈ +- (numberFieldEmbeddedBaseSubgroup K' L' j).toSubgroup +- dsimp only [e, numberFieldEmbeddedBaseChangeBaseEquiv] +- rw [MulEquiv.subgroupCongr_apply, ← hTop] +- exact hy +- · intro hx +- refine ⟨e.symm x, ?_, e.apply_symm_apply x⟩ +- change +- (((e.symm x : +- (numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup) : +- SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) ∈ +- (numberFieldEmbeddedTopSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup) +- dsimp only [e, numberFieldEmbeddedBaseChangeBaseEquiv] +- rw [MulEquiv.subgroupCongr_symm_apply, hTop] +- exact hx +- +-/-- Normality of the relative subgroup between the two embedded base fields +-in a finite Galois base change. -/ +-private theorem numberFieldEmbeddedBaseChangeExtensionSubgroup_normal +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)).Normal := by +- let e := numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j +- have hNormal := +- (numberFieldEmbeddedExtensionSubgroup_normal K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).map +- e.toMonoidHom e.surjective +- rw [numberFieldEmbeddedBaseChangeExtensionSubgroup_map_eq +- K K' L L' j] at hNormal +- exact hNormal +- +-noncomputable local instance +- numberFieldEmbeddedBaseChangeExtensionSubgroupNormal +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- (CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)).Normal := +- numberFieldEmbeddedBaseChangeExtensionSubgroup_normal K K' L L' j +- +-/-- Finiteness of the relative quotient between the two embedded base fields +-in a finite Galois base change. -/ +-private theorem numberFieldEmbeddedBaseChangeExtensionQuotient_finite +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- Finite +- ((numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := by +- let e := numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j +- let N := +- CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)) +- (numberFieldEmbeddedTopSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)) +- (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)) +- let M := +- CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) +- let hNNormal : N.Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j) +- let hMNormal : M.Normal := +- numberFieldEmbeddedBaseChangeExtensionSubgroup_normal K K' L L' j +- let hNFinite : +- Finite +- ((numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup ⧸ N) := +- numberFieldEmbeddedExtensionQuotient_finite K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j) +- have hmap : N.map e.toMonoidHom = M := +- numberFieldEmbeddedBaseChangeExtensionSubgroup_map_eq K K' L L' j +- have hle : N ≤ M.comap e.toMonoidHom := by +- rw [← hmap] +- exact Subgroup.le_comap_map e.toMonoidHom N +- let f : +- ((numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup ⧸ N) →* +- ((numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ M) := +- QuotientGroup.map N M e.toMonoidHom hle +- have hmk : Function.Surjective +- (QuotientGroup.mk ∘ e : +- (numberFieldEmbeddedBaseSubgroup K K' +- (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup → +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ M) := +- QuotientGroup.mk_surjective.comp e.surjective +- have hsurj : Function.Surjective f := +- QuotientGroup.map_surjective_of_surjective +- (N := N) M e.toMonoidHom hmk hle +- exact Finite.of_surjective f hsurj +- +-noncomputable local instance +- numberFieldEmbeddedBaseChangeExtensionQuotientFinite +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- Finite +- ((numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := +- numberFieldEmbeddedBaseChangeExtensionQuotient_finite K K' L L' j +- +-/-- Reuse the canonical absolute fixed-field witness for the lower embedded +-tower. The base-change relative witness below needs this exact instance path +-when forming the absolute finite-dimensional tower. -/ +-noncomputable local instance +- numberFieldEmbeddedBaseChangeBaseFixedFieldFiniteDimensional +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteDimensional ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')))) := +- numberFieldEmbeddedAbstractFixedFieldFiniteDimensional K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')) +- +-noncomputable local instance +- numberFieldEmbeddedBaseChangeRelativeFixedFieldFiniteDimensional +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteDimensional +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')))) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := +- abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) +- (numberFieldEmbeddedAbsoluteQuotientFinite K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseChangeExtensionQuotientFinite K K' L L' j) +- +-local instance +- numberFieldEmbeddedBaseChangeRelativeFixedFieldScalarTower +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- IsScalarTower ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')))) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := +- IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) +- +-noncomputable local instance +- numberFieldEmbeddedBaseChangeRelativeFixedFieldAbsoluteFiniteDimensional +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- FiniteDimensional ℚ +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := +- FiniteDimensional.trans ℚ +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')))) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) +- +-noncomputable local instance +- numberFieldEmbeddedBaseChangeRelativeFixedFieldNumberField +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- NumberField +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := +- NumberField.of_module_finite ℚ +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) +- +-noncomputable local instance +- numberFieldEmbeddedBaseChangeRelativeFixedFieldIsGalois +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- IsGalois +- (abstractFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')))) +- (abstractRelativeFixedField ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := +- abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) +- (numberFieldEmbeddedBaseSubgroup K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L'))) +- (numberFieldEmbeddedBaseSubgroup K' L' j) +- (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) +- (numberFieldEmbeddedBaseChangeExtensionSubgroupNormal K K' L L' j) +- +-/-- In one common rational-separable-closure realization, the canonical +-quotient-to-Galois comparisons intertwine abstract restriction with +-ordinary restriction of the actual number-field automorphisms. -/ +-theorem +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup_restriction +- [FiniteDimensional K L] [IsAbelianGalois K L] +- [FiniteDimensional K' L'] [IsAbelianGalois K' L'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) +- (z : +- Abelianization +- (numberFieldEmbeddedFiniteGaloisSubextension +- K' L' j).extensionQuotient) : +- let jLower : L →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ L L') +- let H := +- numberFieldEmbeddedBaseSubgroup K L jLower +- let H' := +- numberFieldEmbeddedBaseSubgroup K' L' j +- let J := +- numberFieldEmbeddedTopSubgroup K L jLower +- let J' := +- numberFieldEmbeddedTopSubgroup K' L' j +- let hH'H := +- numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j +- let hJ'J := +- numberFieldEmbeddedTopSubgroup_le_of_tower K K' L L' j +- let hJH := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L jLower +- let hJ'H' := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup K' L' j +- letI _ : +- (CyclicCohomology.extensionSubgroup H J hJH).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K L jLower +- letI _ : +- (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K' L' j +- ((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)) +- (Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K' L' j (Additive.ofMul z))) = +- Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L jLower +- (MonoidHom.toAdditive +- (normResidueNaturalityAbelianizedRestriction +- H H' J J' +- hJH hJ'H' +- hH'H hJ'J) +- (Additive.ofMul z))) := by +- dsimp only +- let jLower : L →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ L L') +- let H := +- numberFieldEmbeddedBaseSubgroup K L jLower +- let H' := +- numberFieldEmbeddedBaseSubgroup K' L' j +- let J := +- numberFieldEmbeddedTopSubgroup K L jLower +- let J' := +- numberFieldEmbeddedTopSubgroup K' L' j +- let hH'H := +- numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j +- let hJ'J := +- numberFieldEmbeddedTopSubgroup_le_of_tower K K' L L' j +- let hJH := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup +- K L jLower +- let hJ'H' := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup +- K' L' j +- let hLowerNormal : +- (CyclicCohomology.extensionSubgroup H J hJH).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K L jLower +- let hUpperNormal : +- (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K' L' j +- let qLower := +- numberFieldEmbeddedExtensionQuotientEquivGaloisGroup +- K L jLower +- let qUpper := +- numberFieldEmbeddedExtensionQuotientEquivGaloisGroup +- K' L' j +- let qLowerRaw : +- (H.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H J hJH) ≃* +- Gal(L / K) := by +- exact +- { qLower.toEquiv with +- map_mul' := fun x y => qLower.map_mul x y } +- let qUpperRaw : +- (H'.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H' J' hJ'H') ≃* +- Gal(L' / K') := by +- exact +- { qUpper.toEquiv with +- map_mul' := fun x y => qUpper.map_mul x y } +- let restrictActual : +- Gal(L' / K') →* Gal(L / K) := +- (AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K) +- obtain ⟨q, rfl⟩ := +- QuotientGroup.mk_surjective z +- obtain ⟨σ, rfl⟩ := +- (numberFieldEmbeddedFiniteGaloisSubextension +- K' L' j).extensionQuotientMk_surjective q +- change +- restrictActual +- ((Abelianization.equivOfComm (H := Gal(L' / K'))).symm +- (qUpperRaw.abelianizationCongr +- (Abelianization.of (QuotientGroup.mk σ)))) = +- (Abelianization.equivOfComm (H := Gal(L / K))).symm +- (qLowerRaw.abelianizationCongr +- (normResidueNaturalityAbelianizedRestriction +- H H' J J' hJH hJ'H' hH'H hJ'J +- (Abelianization.of (QuotientGroup.mk σ)))) +- rw [normResidueNaturalityAbelianizedRestriction_of_mk, +- abelianizationCongr_of, abelianizationCongr_of] +- change +- restrictActual (qUpperRaw (QuotientGroup.mk σ)) = +- qLowerRaw +- (QuotientGroup.mk (Subgroup.inclusion hH'H σ)) +- apply AlgEquiv.ext +- intro x +- apply jLower.injective +- let hUpperAlgebra : Algebra K' (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra K' L' j +- let eUpper := +- numberFieldEmbeddedSeparableClosureEquiv K' L' j +- let hLowerAlgebra : Algebra K (SeparableClosure ℚ) := +- numberFieldEmbeddedSeparableClosureAlgebra K L jLower +- let eLower := +- numberFieldEmbeddedSeparableClosureEquiv K L jLower +- calc +- jLower +- (restrictActual +- (qUpperRaw (QuotientGroup.mk σ)) x) = +- j +- ((qUpperRaw (QuotientGroup.mk σ)) +- (algebraMap L L' x)) := by +- exact congrArg j +- (AlgEquiv.restrictNormal_commutes +- ((AlgEquiv.restrictScalarsHom K) +- (qUpperRaw (QuotientGroup.mk σ))) +- L x) +- _ = σ.1.1 +- (j (algebraMap L L' x)) := by +- exact +- ambientEmbeddedExtensionQuotientEquivGaloisGroup_mk_apply +- ℚ K' L' j eUpper σ (algebraMap L L' x) +- _ = (Subgroup.inclusion hH'H σ).1.1 +- (jLower x) := rfl +- _ = jLower +- (qLowerRaw +- (QuotientGroup.mk +- (Subgroup.inclusion hH'H σ)) x) := by +- exact +- (ambientEmbeddedExtensionQuotientEquivGaloisGroup_mk_apply +- ℚ K L jLower eLower +- (Subgroup.inclusion hH'H σ) x).symm +- +-/-- In a compatible common embedding, the fixed-part relative norm +-between two (Galois-related) base fields is the genuine ordinary +-idele-class norm. -/ +-theorem numberFieldEmbeddedIdeleClassEquivAmbientFixed_relativeNorm +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) +- (c : IdeleClassGroup K') : +- let jLower : L →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ L L') +- let H := +- numberFieldEmbeddedBaseSubgroup K L jLower +- let H' := +- numberFieldEmbeddedBaseSubgroup K' L' j +- let hH'H := +- numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j +- letI _ : Finite +- (H.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H H' hH'H) := +- numberFieldEmbeddedBaseChangeExtensionQuotientFinite +- K K' L L' j +- relativeNorm rationalIdeleClassRepresentation H H' hH'H +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K' L' j (Additive.ofMul c)) = +- numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K L jLower +- (Additive.ofMul (_root_.ideleClassNorm K K' c)) := by +- intro jLower H H' +- let hH'H := +- numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j +- let hnormal := +- numberFieldEmbeddedBaseChangeExtensionSubgroupNormal K K' L L' j +- let F := +- abstractFixedField ℚ (SeparableClosure ℚ) H +- let E := +- abstractRelativeFixedField ℚ (SeparableClosure ℚ) hH'H +- let _ : +- (CyclicCohomology.extensionSubgroup H H' hH'H).Normal := +- hnormal +- let _ : +- Finite +- (H.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H H' hH'H) := +- numberFieldEmbeddedBaseChangeExtensionQuotientFinite +- K K' L L' j +- let _ : +- Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- H (le_baseField H)) := +- numberFieldEmbeddedAbsoluteQuotientFinite K L jLower +- let _ : NumberField F := +- numberFieldEmbeddedAbstractFixedFieldNumberField K L jLower +- let _ : NumberField E := +- numberFieldEmbeddedBaseChangeRelativeFixedFieldNumberField +- K K' L L' j +- let _ : FiniteDimensional ℚ (E.restrictScalars ℚ) := by +- change FiniteDimensional ℚ E +- exact +- numberFieldEmbeddedBaseChangeRelativeFixedFieldAbsoluteFiniteDimensional +- K K' L L' j +- let _ : NumberField +- (abstractFixedField ℚ (SeparableClosure ℚ) H') := +- numberFieldEmbeddedAbstractFixedFieldNumberField K' L' j +- have hE : +- E.restrictScalars ℚ = +- abstractFixedField ℚ (SeparableClosure ℚ) H' := +- IntermediateField.extendScalars_restrictScalars +- (abstractFixedField_le +- ℚ (SeparableClosure ℚ) hH'H) +- let eRel : +- E ≃ₐ[ℚ] +- abstractFixedField ℚ (SeparableClosure ℚ) H' := +- IntermediateField.equivOfEq hE +- let eK : +- K ≃ₐ[ℚ] F := +- numberFieldEmbeddedAbstractBaseFieldEquiv K L jLower +- let eK'Base : +- K' ≃ₐ[ℚ] +- abstractFixedField ℚ (SeparableClosure ℚ) H' := +- numberFieldEmbeddedAbstractBaseFieldEquiv K' L' j +- let eK' : K' ≃ₐ[ℚ] E := +- eK'Base.trans eRel.symm +- have hcompat (x : K) : +- eK' (algebraMap K K' x) = +- algebraMap F E (eK x) := by +- apply eRel.injective +- apply Subtype.ext +- change +- j (algebraMap K' L' (algebraMap K K' x)) = +- j (algebraMap L L' (algebraMap K L x)) +- rw [← IsScalarTower.algebraMap_apply K K' L', +- ← IsScalarTower.algebraMap_apply K L L'] +- have hupper : +- rationalAbstractRelativeFixedFieldIdeleClassEquivFixed +- H H' hH'H +- (Additive.ofMul (ideleClassCongr eK' c)) = +- numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K' L' j (Additive.ofMul c) := by +- apply Subtype.ext +- change +- ((rationalIdeleClassEquivFixed (E.restrictScalars ℚ)) +- (Additive.ofMul (ideleClassCongr eK' c))).1 = +- ((rationalIdeleClassEquivFixed +- (abstractFixedField ℚ (SeparableClosure ℚ) H')) +- (Additive.ofMul (ideleClassCongr eK'Base c))).1 +- exact rationalIdeleClassEquivFixed_transport_baseEquiv_val +- (T := K') (A := E.restrictScalars ℚ) +- (B := abstractFixedField ℚ (SeparableClosure ℚ) H') hE eK'Base c +- have hrelative := +- rationalAbstractRelativeFixedFieldIdeleClassEquivFixed_relativeNorm +- H H' hH'H hnormal +- (Additive.ofMul (ideleClassCongr eK' c)) +- change +- relativeNorm rationalIdeleClassRepresentation H H' hH'H +- (rationalAbstractRelativeFixedFieldIdeleClassEquivFixed +- H H' hH'H +- (Additive.ofMul (ideleClassCongr eK' c))) = +- rationalAbstractFixedFieldIdeleClassEquivFixed H +- (Additive.ofMul +- (_root_.ideleClassNorm F E +- (ideleClassCongr eK' c))) +- at hrelative +- calc +- relativeNorm rationalIdeleClassRepresentation H H' hH'H +- (numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K' L' j (Additive.ofMul c)) = +- relativeNorm rationalIdeleClassRepresentation H H' hH'H +- (rationalAbstractRelativeFixedFieldIdeleClassEquivFixed +- H H' hH'H (Additive.ofMul (ideleClassCongr eK' c))) := +- congrArg (relativeNorm rationalIdeleClassRepresentation H H' hH'H) +- hupper.symm +- _ = rationalAbstractFixedFieldIdeleClassEquivFixed H +- (Additive.ofMul +- (_root_.ideleClassNorm F E (ideleClassCongr eK' c))) := hrelative +- _ = numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K L jLower (Additive.ofMul (_root_.ideleClassNorm K K' c)) := by +- change +- rationalAbstractFixedFieldIdeleClassEquivFixed H +- (Additive.ofMul +- (_root_.ideleClassNorm F E (ideleClassCongr eK' c))) = +- rationalAbstractFixedFieldIdeleClassEquivFixed H +- (Additive.ofMul +- (ideleClassCongr eK (_root_.ideleClassNorm K K' c))) +- apply congrArg (rationalAbstractFixedFieldIdeleClassEquivFixed H) +- apply congrArg Additive.ofMul +- exact +- (ideleClassCongr_ideleClassNorm +- (K := K) (K' := F) (L := K') (L' := E) eK eK' hcompat c).symm +- +-/-- For one common compatible embedding of a Galois base-change +-diamond, the genuine global norm-residue maps commute with ordinary +-idele-class norm and actual restriction of automorphisms. -/ +-theorem globalNormResidueMonoidHomOfEmbedding_norm_restriction +- [FiniteDimensional K L] [IsAbelianGalois K L] +- [FiniteDimensional K' L'] [IsAbelianGalois K' L'] +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) : +- let jLower : L →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ L L') +- ((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)).comp +- (globalNormResidueMonoidHomOfEmbedding K' L' j) = +- (globalNormResidueMonoidHomOfEmbedding K L jLower).comp +- (_root_.ideleClassNorm K K') := by +- dsimp only +- let jLower : L →ₐ[ℚ] SeparableClosure ℚ := +- j.comp (IsScalarTower.toAlgHom ℚ L L') +- let H := +- numberFieldEmbeddedBaseSubgroup K L jLower +- let H' := +- numberFieldEmbeddedBaseSubgroup K' L' j +- let J := +- numberFieldEmbeddedTopSubgroup K L jLower +- let J' := +- numberFieldEmbeddedTopSubgroup K' L' j +- let hJH := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L jLower +- let hJ'H' := +- numberFieldEmbeddedTopSubgroup_le_baseSubgroup K' L' j +- let hH'H := +- numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j +- let hJ'J := +- numberFieldEmbeddedTopSubgroup_le_of_tower K K' L L' j +- let _ : +- (CyclicCohomology.extensionSubgroup H J hJH).Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K L jLower +- let _ : +- Finite +- (H.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H J hJH) := +- numberFieldEmbeddedExtensionQuotient_finite K L jLower +- let _ : +- (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal := +- numberFieldEmbeddedExtensionSubgroup_normal K' L' j +- let _ : +- Finite +- (H'.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H' J' hJ'H') := +- numberFieldEmbeddedExtensionQuotient_finite K' L' j +- let hHH'finite := +- numberFieldEmbeddedBaseChangeExtensionQuotientFinite K K' L L' j +- let T : +- FiniteAbstractFieldExtension +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := +- { field := numberFieldEmbeddedFiniteAbstractField K' L' j +- base := numberFieldEmbeddedFiniteAbstractField K L jLower +- below := hH'H +- finiteQuotient := hHH'finite } +- let hTBaseNormal : +- (CyclicCohomology.extensionSubgroup +- T.base.field J hJH).Normal := by +- change +- (CyclicCohomology.extensionSubgroup H J hJH).Normal +- exact numberFieldEmbeddedExtensionSubgroup_normal K L jLower +- let hTBaseFinite : +- Finite +- (T.base.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- T.base.field J hJH) := by +- change +- Finite +- (H.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H J hJH) +- exact numberFieldEmbeddedExtensionQuotient_finite K L jLower +- let hTFieldNormal : +- (CyclicCohomology.extensionSubgroup +- T.field.field J' hJ'H').Normal := by +- change +- (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal +- exact numberFieldEmbeddedExtensionSubgroup_normal K' L' j +- let hTFieldFinite : +- Finite +- (T.field.field.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup +- T.field.field J' hJ'H') := by +- change +- Finite +- (H'.toSubgroup ⧸ +- CyclicCohomology.extensionSubgroup H' J' hJ'H') +- exact numberFieldEmbeddedExtensionQuotient_finite K' L' j +- let restrictActual : +- Gal(L' / K') →* Gal(L / K) := +- (AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K) +- apply MonoidHom.ext +- intro c +- let a := +- numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K' L' j (Additive.ofMul c) +- have hnat := +- DegreeData.normResidueNaturality_norm_restriction +- (D := rationalCyclotomicDegreeData) +- (A := rationalIdeleClassRepresentation) +- (v := rationalCyclotomicIdeleClassValuationData) +- (hcf := rationalIdeleClassRepresentation_satisfiesClassFieldAxiom) +- (T := T) (L := J) (L' := J') +- (hLnormal := hTBaseNormal) +- (hL'normal := hTFieldNormal) +- (hLKfinite := hTBaseFinite) +- (hL'K'finite := hTFieldFinite) +- hJH hJ'H' hJ'J +- have hnatc := +- DFunLike.congr_fun hnat +- (finiteNormClass rationalIdeleClassRepresentation +- H' J' hJ'H' a) +- change _ = +- rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- T.base +- { field := J +- below := hJH +- normal := hTBaseNormal +- finite := hTBaseFinite } +- (finiteReciprocityNaturalityNormMap +- rationalIdeleClassRepresentation +- T.base.field T.field.field J J' +- hJH hJ'H' T.below hJ'J +- (finiteNormClass rationalIdeleClassRepresentation +- T.field.field J' hJ'H' a)) at hnatc +- rw [finiteReciprocityNaturalityNormMap_finiteNormClass] +- at hnatc +- have hnorm : +- relativeNorm rationalIdeleClassRepresentation +- H H' hH'H a = +- numberFieldEmbeddedIdeleClassEquivAmbientFixed +- K L jLower +- (Additive.ofMul (_root_.ideleClassNorm K K' c)) := +- numberFieldEmbeddedIdeleClassEquivAmbientFixed_relativeNorm +- K K' L L' j c +- calc +- restrictActual +- (globalNormResidueMonoidHomOfEmbedding K' L' j c) = +- restrictActual +- (Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K' L' j +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K' L' j) +- (numberFieldEmbeddedFiniteGaloisSubextension K' L' j) +- (finiteNormClass rationalIdeleClassRepresentation +- H' J' hJ'H' a)))) := by +- rw [globalNormResidueMonoidHomOfEmbedding_apply] +- _ = +- Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L jLower +- (MonoidHom.toAdditive +- (normResidueNaturalityAbelianizedRestriction +- H H' J J' hJH hJ'H' hH'H hJ'J) +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K' L' j) +- (numberFieldEmbeddedFiniteGaloisSubextension K' L' j) +- (finiteNormClass rationalIdeleClassRepresentation +- H' J' hJ'H' a)))) := by +- exact +- numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup_restriction +- K K' L L' j _ +- _ = +- Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L jLower +- (rationalCyclotomicDegreeData.normResidueSymbol +- rationalIdeleClassRepresentation +- rationalCyclotomicIdeleClassValuationData +- rationalIdeleClassRepresentation_satisfiesClassFieldAxiom +- (numberFieldEmbeddedFiniteAbstractField K L jLower) +- (numberFieldEmbeddedFiniteGaloisSubextension K L jLower) +- (finiteNormClass rationalIdeleClassRepresentation +- H J hJH +- (relativeNorm rationalIdeleClassRepresentation +- H H' hH'H a)))) := by +- exact congrArg +- (fun z => +- Additive.toMul +- (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup +- K L jLower z)) +- hnatc +- _ = +- globalNormResidueMonoidHomOfEmbedding K L jLower +- (_root_.ideleClassNorm K K' c) := by +- rw [hnorm, +- ← globalNormResidueMonoidHomOfEmbedding_apply] + +-end EmbeddedNumberFieldRestriction ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal + + variable + {G : IntegralRepGroupType} [Group G] [TopologicalSpace G] +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityAbelianValues.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityAbelianValues.lean +new file mode 100644 +index 0000000..b6abdd5 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityAbelianValues.lean +@@ -0,0 +1,429 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityExtensionValues ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++section AbstractFixedFieldInclusion ++ ++variable ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ naturalityAbstractFixedFieldBaseQuotientFinite ++ naturalityAbstractFixedFieldRelativeQuotientFinite ++ naturalityAbstractFixedFieldFiniteDimensional ++ naturalityAbstractRelativeFixedFieldFiniteDimensional ++ naturalityAbstractFixedFieldRelativeScalarTower ++ naturalityAbstractRelativeFixedFieldAbsoluteFiniteDimensional ++ naturalityAbstractFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldIsGalois ++ naturalityAbstractRelativeFixedFieldIsAbelianGalois ++ ++ ++/-- The additive equivalence from the abelianized extension quotient to the ++Galois group of the relative fixed field, transported through its embedding. -/ ++noncomputable def ++ abstractFixedFieldInclusionTransportedAbelianizedEquiv ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ Additive ++ (Abelianization ++ P.toFiniteGaloisExtension.extensionQuotient) ≃+ ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ have hPEmbedded : ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension X.field) ++ hHEmbedded) ++ PEmbedded = ++ P.toFiniteGaloisExtension := ++ numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P ++ exact ++ abelianizedExtensionQuotientAddEquiv_transportExtension hPEmbedded ++ (abelianizedExtensionQuotientAddEquiv_transportBase ++ hHEmbedded PEmbedded ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ F E j)) ++ ++/-- Canonical abelianization comparison built from the already transported ++opaque extension-quotient endpoint. -/ ++private noncomputable def ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ Additive ++ (Abelianization ++ P.toFiniteGaloisExtension.extensionQuotient) ≃+ ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by ++ let Q := ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) ++ exact ++ MulEquiv.toAdditive ++ ((MulEquiv.abelianizationCongr ++ (abstractFixedFieldInclusionTransportedExtensionQuotientEquiv H P)).trans ++ (Abelianization.equivOfComm : Q ≃* Abelianization Q).symm) ++ ++/-- Pointwise opaque value of the transported abelianized equivalence. -/ ++private noncomputable def ++ abstractFixedFieldInclusionTransportedAbelianizedValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (z : Additive ++ (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := ++ abstractFixedFieldInclusionTransportedAbelianizedEquiv H P z ++ ++/-- Pointwise opaque value of the canonical abelianization comparison built ++from the transported quotient endpoint. -/ ++private noncomputable def ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (z : Additive ++ (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv H P z ++ ++/-- Pointwise opaque value of the intrinsic abstract fixed-field ++abelianization comparison. -/ ++private noncomputable def ++ abstractFixedFieldInclusionCanonicalAbelianizedValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (z : Additive ++ (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := ++ abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P z ++ ++/-- The transported abelianized endpoint agrees pointwise with the canonical ++abelianization comparison built from the transported quotient endpoint. -/ ++private theorem ++ abstractFixedFieldInclusionTransportedAbelianizedValue_eq_canonical ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (z : Additive ++ (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : ++ abstractFixedFieldInclusionTransportedAbelianizedValue H P z = ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue ++ H P z := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ have hPEmbedded : ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension X.field) ++ hHEmbedded) ++ PEmbedded = ++ P.toFiniteGaloisExtension := ++ numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P ++ let qEmbedded : PEmbedded.extensionQuotient ≃* Gal(E / F) := ++ numberFieldEmbeddedExtensionQuotientEquivGaloisGroup F E j ++ have hCanonical : ++ abstractFixedFieldInclusionTransportedAbelianizedEquiv H P = ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv ++ H P := by ++ simpa only [ ++ abstractFixedFieldInclusionTransportedAbelianizedEquiv, ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv, ++ abstractFixedFieldInclusionTransportedExtensionQuotientEquiv, ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup, ++ qEmbedded] using ++ (abelianizedCanonicalEquiv_transportFiniteGalois ++ hHEmbedded PEmbedded hPEmbedded qEmbedded) ++ exact DFunLike.congr_fun hCanonical z ++ ++/-- On an abelianization representative, the transported canonical endpoint ++is the additive value of the transported quotient endpoint. -/ ++private theorem ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_of ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) : ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue H P ++ (Additive.ofMul (Abelianization.of q)) = ++ Additive.ofMul ++ (abstractFixedFieldInclusionTransportedExtensionQuotientValue ++ H P q) := by ++ simpa only [ ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue, ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedEquiv, ++ abstractFixedFieldInclusionTransportedExtensionQuotientValue] using ++ (abelianizationCongrToComm_apply ++ (abstractFixedFieldInclusionTransportedExtensionQuotientEquiv H P) q) ++ ++/-- On the same representative, the intrinsic fixed-field endpoint is the ++additive value of the canonical quotient endpoint. -/ ++private theorem ++ abstractFixedFieldInclusionCanonicalAbelianizedValue_of ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) : ++ abstractFixedFieldInclusionCanonicalAbelianizedValue H P ++ (Additive.ofMul (Abelianization.of q)) = ++ Additive.ofMul ++ (abstractFixedFieldInclusionCanonicalExtensionQuotientValue ++ H P q) := by ++ let hRawQuotientCommGroup : ++ CommGroup P.toFiniteGaloisExtension.extensionQuotient := ++ { (inferInstance : ++ Group P.toFiniteGaloisExtension.extensionQuotient) with ++ mul_comm := P.commutative.is_comm.comm } ++ let qAbstractRaw := ++ abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv H P ++ change ++ MulEquiv.toAdditive ++ ((Abelianization.equivOfComm : ++ P.toFiniteGaloisExtension.extensionQuotient ≃* ++ Abelianization ++ P.toFiniteGaloisExtension.extensionQuotient).symm.trans ++ qAbstractRaw) ++ (Additive.ofMul (Abelianization.of q)) = ++ Additive.ofMul (qAbstractRaw q) ++ exact commutativeAbelianizationEquiv_apply qAbstractRaw q ++ ++/-- The canonical abelianization comparison built after transport agrees ++pointwise with the intrinsic abstract fixed-field comparison. -/ ++private theorem ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_eq ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (z : Additive ++ (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue H P z = ++ abstractFixedFieldInclusionCanonicalAbelianizedValue H P z := by ++ let q : P.toFiniteGaloisExtension.extensionQuotient := ++ Quotient.out z.toMul ++ have hz : Additive.ofMul (Abelianization.of q) = z := by ++ apply Additive.ext ++ exact Quotient.out_eq' z.toMul ++ rw [← hz] ++ calc ++ _ = Additive.ofMul ++ (abstractFixedFieldInclusionTransportedExtensionQuotientValue ++ H P q) := ++ abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_of ++ H P q ++ _ = Additive.ofMul ++ (abstractFixedFieldInclusionEmbeddedExtensionQuotientValue ++ H P q) := ++ congrArg Additive.ofMul ++ (abstractFixedFieldInclusionTransportedExtensionQuotientEquiv_apply ++ H P q) ++ _ = Additive.ofMul ++ (abstractFixedFieldInclusionCanonicalExtensionQuotientValue ++ H P q) := ++ congrArg Additive.ofMul ++ (abstractFixedFieldInclusionExtensionQuotientEquiv_apply H P q) ++ _ = _ := ++ (abstractFixedFieldInclusionCanonicalAbelianizedValue_of H P q).symm ++ ++/-- The transported abelianized equivalence agrees pointwise with the ++intrinsic abstract fixed-field Galois comparison. -/ ++theorem ++ abstractFixedFieldInclusionTransportedAbelianizedValue_eq ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (z : Additive ++ (Abelianization P.toFiniteGaloisExtension.extensionQuotient)) : ++ abstractFixedFieldInclusionTransportedAbelianizedValue H P z = ++ abstractFixedFieldInclusionCanonicalAbelianizedValue H P z := ++ (abstractFixedFieldInclusionTransportedAbelianizedValue_eq_canonical ++ H P z).trans ++ (abstractFixedFieldInclusionTransportedCanonicalAbelianizedValue_eq ++ H P z) ++ ++ ++/-- The norm-residue value of an idele class in the Galois group of the ++relative fixed field, computed through the embedded number-field realization. -/ ++noncomputable def ++ abstractFixedFieldInclusionEmbeddedNormResidueValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (c : Additive ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ exact ++ rationalFiniteNormResidueValue HEmbedded PEmbedded ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j) ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ F E j) ++ c ++ ++/-- Opaque packaged value after transporting both dependent structures to ++the canonical `H` and `P` endpoints. -/ ++noncomputable def ++ abstractFixedFieldInclusionTransportedNormResidueValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (c : Additive ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ let eIdeleEmbedded := ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j ++ let eIdeleOverH : ++ Additive (IdeleClassGroup F) ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation H.field := ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ Additive (IdeleClassGroup F) ≃+ ++ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation X.field) ++ hHEmbedded) ++ eIdeleEmbedded ++ exact ++ rationalFiniteNormResidueValue H P.toFiniteGaloisExtension ++ eIdeleOverH ++ (abstractFixedFieldInclusionTransportedAbelianizedEquiv H P) ++ c ++ ++/-- Opaque intrinsic packaged norm-residue value at the canonical endpoints. -/ ++noncomputable def ++ abstractFixedFieldInclusionCanonicalNormResidueValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (c : Additive ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : ++ Additive ++ (Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) := ++ rationalFiniteNormResidueValue H P.toFiniteGaloisExtension ++ (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) ++ (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P) ++ c ++ ++ ++end AbstractFixedFieldInclusion ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityEmbeddedValues.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityEmbeddedValues.lean +new file mode 100644 +index 0000000..2f5a677 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityEmbeddedValues.lean +@@ -0,0 +1,396 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityFixedBase ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++section AbstractFixedFieldInclusion ++ ++variable ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ naturalityAbstractFixedFieldBaseQuotientFinite ++ naturalityAbstractFixedFieldRelativeQuotientFinite ++ naturalityAbstractFixedFieldFiniteDimensional ++ naturalityAbstractRelativeFixedFieldFiniteDimensional ++ naturalityAbstractFixedFieldRelativeScalarTower ++ naturalityAbstractRelativeFixedFieldAbsoluteFiniteDimensional ++ naturalityAbstractFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldIsGalois ++ naturalityAbstractRelativeFixedFieldIsAbelianGalois ++ ++/-- The finite abstract field reconstructed from the literal fixed-field ++inclusion is the original packaged abstract field. Keeping this structure ++equality separate avoids repeatedly rebuilding all of its proof fields. -/ ++theorem ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ numberFieldEmbeddedFiniteAbstractField F E j = H := by ++ dsimp only ++ exact FiniteAbstractField.eq_of_field_eq _ _ ++ (numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P) ++ ++ ++theorem ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed_transport_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (c : Additive ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ Additive (IdeleClassGroup F) ≃+ ++ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation X.field) ++ hHEmbedded) ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j) c = ++ rationalAbstractFixedFieldIdeleClassEquivFixed H.field c := by ++ dsimp only ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ have hHEmbedded : ++ numberFieldEmbeddedFiniteAbstractField F E j = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ have hFixedBase : ++ abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup F E j) = F := ++ congrArg ++ (abstractFixedField ℚ (SeparableClosure ℚ)) hBase ++ let eBase : F ≃ₐ[ℚ] F := ++ (numberFieldEmbeddedAbstractBaseFieldEquiv F E j).trans ++ (IntermediateField.equivOfEq hFixedBase) ++ have heBase : ++ eBase = (AlgEquiv.refl : F ≃ₐ[ℚ] F) := by ++ apply AlgEquiv.ext ++ intro x ++ apply Subtype.ext ++ change x.1 = x.1 ++ rfl ++ let hEmbeddedQuotientFinite := ++ numberFieldEmbeddedAbsoluteQuotientFinite F E j ++ let hEmbeddedFixedFiniteDimensional := ++ numberFieldEmbeddedAbstractFixedFieldFiniteDimensional F E j ++ apply Subtype.ext ++ rw [rationalAmbientFixedAddEquiv_transport_apply_val ++ hHEmbedded ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j) c] ++ dsimp only [numberFieldEmbeddedIdeleClassEquivAmbientFixed] ++ simp only [AddEquiv.trans_apply] ++ change ++ ((rationalIdeleClassEquivFixed ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup F E j))) ++ (MulEquiv.toAdditive ++ (ideleClassCongr ++ (numberFieldEmbeddedAbstractBaseFieldEquiv F E j)) c)).1 = ++ ((rationalIdeleClassEquivFixed F) c).1 ++ exact rationalIdeleClassEquivFixed_congr_apply_val ++ hFixedBase ++ (numberFieldEmbeddedAbstractBaseFieldEquiv F E j) ++ heBase c ++ ++/-- Transporting the finite Galois subextension reconstructed from the literal ++fixed-field inclusion recovers the canonical subextension packaged by `P`. ++This is the sole dependent structure equality used by the later quotient ++comparisons. -/ ++theorem ++ numberFieldEmbeddedFiniteGaloisSubextension_transport_eq ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ let hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension X.field) ++ hHEmbedded) ++ PEmbedded = ++ P.toFiniteGaloisExtension := by ++ dsimp only ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ exact finiteGaloisSubextension_transport_eq_of_field_eq ++ hHEmbedded PEmbedded P.toFiniteGaloisExtension ++ (numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P) ++ ++/-- Opaque endpoint for the extension-quotient comparison supplied by the ++literal embedding. Its domain is already the canonical quotient of `P`, so ++no client has to reconstruct the two subgroup transports. -/ ++noncomputable def ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ P.toFiniteGaloisExtension.extensionQuotient ≃* ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ have hTop : ++ numberFieldEmbeddedTopSubgroup F E j = P.field := ++ numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P ++ letI hAlgebra : Algebra F (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra F E j ++ let eSep := ++ numberFieldEmbeddedSeparableClosureEquiv F E j ++ letI hEmbeddedExtensionNormal : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal F E j ++ exact ++ P.toFiniteGaloisExtension.extensionQuotientMulEquiv.trans ++ ((extensionQuotientMulEquivOfEq ++ hBase.symm hTop.symm P.below ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).trans ++ (ambientEmbeddedExtensionQuotientEquivGaloisGroup ++ ℚ F E j eSep)) ++ ++/-- Opaque canonical endpoint for the same quotient, obtained directly from ++the abstract fixed-field realization. -/ ++noncomputable def ++ abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ P.toFiniteGaloisExtension.extensionQuotient ≃* ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by ++ exact ++ P.toFiniteGaloisExtension.extensionQuotientMulEquiv.trans ++ (abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) ++ H.field P.field P.below P.normal) ++ ++/-- Pointwise opaque endpoint of the embedded quotient equivalence. -/ ++noncomputable def ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) : ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv H P q ++ ++/-- Pointwise opaque endpoint of the canonical quotient equivalence. -/ ++noncomputable def ++ abstractFixedFieldInclusionCanonicalExtensionQuotientValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) : ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := ++ abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv H P q ++ ++/-- Fully applied ambient value of the embedded quotient endpoint. -/ ++noncomputable def ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientApplyVal ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := ++ (abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q x : ++ SeparableClosure ℚ) ++ ++/-- Fully applied ambient value of the canonical quotient endpoint. -/ ++noncomputable def ++ abstractFixedFieldInclusionCanonicalExtensionQuotientApplyVal ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := ++ (abstractFixedFieldInclusionCanonicalExtensionQuotientValue H P q x : ++ SeparableClosure ℚ) ++ ++/-- The ambient Galois value attached to a representative of the canonical ++quotient, packaged behind a literal result type. -/ ++noncomputable def ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) : ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ letI hAlgebra : Algebra F (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra F E j ++ let eSep := ++ numberFieldEmbeddedSeparableClosureEquiv F E j ++ letI hEmbeddedExtensionNormal : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal F E j ++ let σEmbedded : ++ (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := ++ (MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ ++ exact ++ ambientEmbeddedExtensionQuotientEquivGaloisGroup ++ ℚ F E j eSep (QuotientGroup.mk σEmbedded) ++ ++/-- Fully applied ambient value of the packaged representative endpoint. -/ ++noncomputable def ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := ++ (abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue H P σ x : ++ SeparableClosure ℚ) ++ ++/-- Ambient action of the representative after rebundling it in the embedded ++base subgroup. -/ ++noncomputable def ++ abstractFixedFieldInclusionRebasedAutomorphismApplyVal ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : SeparableClosure ℚ := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ let σEmbedded : ++ (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := ++ (MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ ++ exact σEmbedded.1.1 (x : SeparableClosure ℚ) ++ ++ ++end AbstractFixedFieldInclusion ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityExtensionValues.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityExtensionValues.lean +new file mode 100644 +index 0000000..def7569 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityExtensionValues.lean +@@ -0,0 +1,419 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityEmbeddedValues ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++section AbstractFixedFieldInclusion ++ ++variable ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ naturalityAbstractFixedFieldBaseQuotientFinite ++ naturalityAbstractFixedFieldRelativeQuotientFinite ++ naturalityAbstractFixedFieldFiniteDimensional ++ naturalityAbstractRelativeFixedFieldFiniteDimensional ++ naturalityAbstractFixedFieldRelativeScalarTower ++ naturalityAbstractRelativeFixedFieldAbsoluteFiniteDimensional ++ naturalityAbstractFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldIsGalois ++ naturalityAbstractRelativeFixedFieldIsAbelianGalois ++ ++/-- The embedded quotient endpoint sends a canonical representative to the ++packaged ambient value above. -/ ++private theorem ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue_mk ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) : ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P ++ (P.toFiniteGaloisExtension.extensionQuotientMk σ) = ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue H P σ := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ have hTop : ++ numberFieldEmbeddedTopSubgroup F E j = P.field := ++ numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P ++ let hAlgebra : Algebra F (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra F E j ++ let eSep := ++ numberFieldEmbeddedSeparableClosureEquiv F E j ++ let hEmbeddedExtensionNormal : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal F E j ++ simp only [ ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue, ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv, ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue, ++ MulEquiv.trans_apply, ++ FiniteGaloisSubextension.extensionQuotientMk_apply] ++ exact congrArg ++ (ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ F E j eSep) ++ (extensionQuotientMulEquivOfEq_mk ++ hBase.symm hTop.symm P.below ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j) σ) ++ ++/-- The packaged ambient endpoint evaluates to the action of the rebundled ++representative. -/ ++private theorem ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal_eq_rebased ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal H P σ x = ++ abstractFixedFieldInclusionRebasedAutomorphismApplyVal H P σ x := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ let hAlgebra : Algebra F (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra F E j ++ let eSep := ++ numberFieldEmbeddedSeparableClosureEquiv F E j ++ let hEmbeddedExtensionNormal : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal F E j ++ let σEmbedded : ++ (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := ++ (MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ ++ have hmk := ++ ambientEmbeddedExtensionQuotientEquivGaloisGroup_mk_apply ++ ℚ F E j eSep σEmbedded x ++ change ++ (ambientEmbeddedExtensionQuotientEquivGaloisGroup ++ ℚ F E j eSep (QuotientGroup.mk σEmbedded) x : ++ SeparableClosure ℚ) = ++ σEmbedded.1.1 (x : SeparableClosure ℚ) at hmk ++ simpa only [ ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal, ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue, ++ abstractFixedFieldInclusionRebasedAutomorphismApplyVal] using hmk ++ ++/-- Rebundling the representative does not change its action in the ambient ++separable closure. -/ ++private theorem ++ abstractFixedFieldInclusionRebasedAutomorphismApplyVal_eq ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : ++ abstractFixedFieldInclusionRebasedAutomorphismApplyVal H P σ x = ++ σ.1.1 (x : SeparableClosure ℚ) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ let σEmbedded : ++ (numberFieldEmbeddedBaseSubgroup F E j).toSubgroup := ++ (MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ ++ have hσEmbedded : ++ (σEmbedded.1 : SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) = σ.1 := ++ closedSubgroupCongr_apply_val hBase.symm σ ++ change σEmbedded.1.1 (x : SeparableClosure ℚ) = _ ++ rw [hσEmbedded] ++ ++/-- The packaged ambient representative acts by the original automorphism on ++the underlying separable-closure value. -/ ++private theorem ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal H P σ x = ++ σ.1.1 (x : SeparableClosure ℚ) := by ++ exact ++ (abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal_eq_rebased ++ H P σ x).trans ++ (abstractFixedFieldInclusionRebasedAutomorphismApplyVal_eq H P σ x) ++ ++/-- Evaluation of the embedded quotient endpoint on a canonical quotient ++representative, stated only in the ambient separable closure. -/ ++private theorem ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv_mk_val ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientApplyVal H P ++ (P.toFiniteGaloisExtension.extensionQuotientMk σ) x = ++ σ.1.1 (x : SeparableClosure ℚ) := by ++ calc ++ _ = abstractFixedFieldInclusionAmbientEmbeddedQuotientMkApplyVal ++ H P σ x := by ++ exact congrArg ++ (fun g => (g x : SeparableClosure ℚ)) ++ (abstractFixedFieldInclusionEmbeddedExtensionQuotientValue_mk ++ H P σ) ++ _ = _ := ++ abstractFixedFieldInclusionAmbientEmbeddedQuotientMkValue_apply ++ H P σ x ++ ++/-- Evaluation of the canonical abstract quotient endpoint on a quotient ++representative, again exposed only through its ambient value. -/ ++private theorem ++ abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv_mk_val ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) ++ (x : abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) : ++ abstractFixedFieldInclusionCanonicalExtensionQuotientApplyVal H P ++ (P.toFiniteGaloisExtension.extensionQuotientMk σ) x = ++ σ.1.1 (x : SeparableClosure ℚ) := by ++ simp only [ ++ abstractFixedFieldInclusionCanonicalExtensionQuotientApplyVal, ++ abstractFixedFieldInclusionCanonicalExtensionQuotientValue, ++ abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv, ++ MulEquiv.trans_apply, ++ FiniteGaloisSubextension.extensionQuotientMk_apply] ++ exact ++ (abstractExtensionQuotientEquivGaloisGroup_mk_apply_val ++ ℚ (SeparableClosure ℚ) ++ H.field P.field P.below P.normal σ x).symm ++ ++ ++theorem ++ abstractFixedFieldInclusionExtensionQuotientEquiv_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) : ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q = ++ abstractFixedFieldInclusionCanonicalExtensionQuotientValue H P q := by ++ refine P.toFiniteGaloisExtension.extensionQuotient_inductionOn ++ (motive := fun q => ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q = ++ abstractFixedFieldInclusionCanonicalExtensionQuotientValue H P q) ++ q ?_ ++ intro σ ++ apply AlgEquiv.ext ++ intro x ++ apply Subtype.ext ++ exact ++ (abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv_mk_val ++ H P σ x).trans ++ (abstractFixedFieldInclusionCanonicalExtensionQuotientEquiv_mk_val ++ H P σ x).symm ++ ++ ++/-- The extension quotient identified with the Galois group of the corresponding ++relative fixed field, after transporting the embedded field structures. -/ ++noncomputable def ++ abstractFixedFieldInclusionTransportedExtensionQuotientEquiv ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ P.toFiniteGaloisExtension.extensionQuotient ≃* ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ have hPEmbedded : ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension X.field) ++ hHEmbedded) ++ PEmbedded = ++ P.toFiniteGaloisExtension := ++ numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P ++ exact ++ (extensionQuotientMulEquiv_transportFiniteGalois ++ hHEmbedded PEmbedded hPEmbedded).trans ++ (numberFieldEmbeddedExtensionQuotientEquivGaloisGroup F E j) ++ ++/-- Pointwise opaque endpoint of the transported quotient equivalence. -/ ++noncomputable def ++ abstractFixedFieldInclusionTransportedExtensionQuotientValue ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) : ++ Gal( ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) / ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) := ++ abstractFixedFieldInclusionTransportedExtensionQuotientEquiv H P q ++ ++ ++private theorem ++ abstractFixedFieldInclusionTransportedExtensionQuotientValue_mk ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (σ : H.field.toSubgroup) : ++ abstractFixedFieldInclusionTransportedExtensionQuotientValue H P ++ (P.toFiniteGaloisExtension.extensionQuotientMk σ) = ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P ++ (P.toFiniteGaloisExtension.extensionQuotientMk σ) := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hBase : ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion H P ++ have hTop : ++ numberFieldEmbeddedTopSubgroup F E j = P.field := ++ numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion H P ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ have hPEmbedded : ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension X.field) ++ hHEmbedded) ++ PEmbedded = ++ P.toFiniteGaloisExtension := ++ numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P ++ let hAlgebra : Algebra F (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra F E j ++ let eSep := ++ numberFieldEmbeddedSeparableClosureEquiv F E j ++ let hEmbeddedExtensionNormal : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup F E j) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j)).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal F E j ++ have hFieldEq : ++ (congrArg FiniteAbstractField.field hHEmbedded).symm = hBase.symm := ++ Subsingleton.elim _ _ ++ simp only [ ++ abstractFixedFieldInclusionTransportedExtensionQuotientValue, ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue, ++ abstractFixedFieldInclusionTransportedExtensionQuotientEquiv, ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientEquiv, ++ MulEquiv.trans_apply, ++ extensionQuotientMulEquiv_transportFiniteGalois_mk, ++ FiniteGaloisSubextension.extensionQuotientMk_apply, ++ numberFieldEmbeddedExtensionQuotientEquivGaloisGroup] ++ rw [hFieldEq] ++ change ++ ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ F E j eSep ++ (QuotientGroup.mk ++ ((MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup hBase.symm)) σ)) = _ ++ exact ++ (congrArg ++ (ambientEmbeddedExtensionQuotientEquivGaloisGroup ℚ F E j eSep) ++ (extensionQuotientMulEquivOfEq_mk ++ hBase.symm hTop.symm P.below ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup F E j) σ)).symm ++ ++ ++theorem ++ abstractFixedFieldInclusionTransportedExtensionQuotientEquiv_apply ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (q : P.toFiniteGaloisExtension.extensionQuotient) : ++ abstractFixedFieldInclusionTransportedExtensionQuotientValue H P q = ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q := by ++ refine P.toFiniteGaloisExtension.extensionQuotient_inductionOn ++ (motive := fun q => ++ abstractFixedFieldInclusionTransportedExtensionQuotientValue H P q = ++ abstractFixedFieldInclusionEmbeddedExtensionQuotientValue H P q) ++ q ?_ ++ intro σ ++ exact abstractFixedFieldInclusionTransportedExtensionQuotientValue_mk ++ H P σ ++ ++ ++end AbstractFixedFieldInclusion ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityFixedBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityFixedBase.lean +new file mode 100644 +index 0000000..d3a9bb0 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityFixedBase.lean +@@ -0,0 +1,376 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityTransports ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ ++section AbstractFixedFieldInclusion ++ ++variable ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ ++local instance naturalityAbstractFixedFieldBaseQuotientFinite : ++ Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ H.field (le_baseField H.field)) := ++ H.finite ++ ++local instance naturalityAbstractFixedFieldRelativeQuotientFinite : ++ Finite ++ (H.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H.field P.field P.below) := ++ P.finite ++ ++noncomputable local instance ++ naturalityAbstractFixedFieldFiniteDimensional : ++ FiniteDimensional ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) := ++ abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) H.field H.finite ++ ++noncomputable local instance ++ naturalityAbstractRelativeFixedFieldFiniteDimensional : ++ FiniteDimensional ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) := ++ abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ H.field P.field P.below H.finite P.finite ++ ++local instance naturalityAbstractFixedFieldRelativeScalarTower : ++ IsScalarTower ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) := ++ IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) ++ ++noncomputable local instance ++ naturalityAbstractRelativeFixedFieldAbsoluteFiniteDimensional : ++ FiniteDimensional ℚ ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) := ++ FiniteDimensional.trans ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) ++ ++noncomputable local instance naturalityAbstractFixedFieldNumberField : ++ NumberField ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) := ++ NumberField.of_module_finite ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ ++noncomputable local instance ++ naturalityAbstractRelativeFixedFieldNumberField : ++ NumberField ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) := ++ NumberField.of_module_finite ℚ ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) ++ ++/-- Use the same direct fixed-field Galois witness as the intrinsic ++norm-residue construction. This prevents the dependent Galois-group type ++from being synthesized through a second `IsAbelianGalois` instance path. -/ ++noncomputable local instance ++ naturalityAbstractRelativeFixedFieldIsGalois : ++ IsGalois ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) := ++ abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) ++ H.field P.field P.below P.normal ++ ++noncomputable local instance ++ naturalityAbstractRelativeFixedFieldIsAbelianGalois : ++ IsAbelianGalois ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) := ++ finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P ++ ++/-- The lower subgroup obtained from the canonical inclusion of an abstract ++fixed-field tower is the original lower closed subgroup. -/ ++theorem ++ numberFieldEmbeddedBaseSubgroup_abstractFixedFieldInclusion ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ numberFieldEmbeddedBaseSubgroup F E j = H.field := by ++ dsimp only ++ have hi : ++ numberFieldEmbeddedLowerEmbedding ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) ++ ((abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ) = ++ (abstractFixedField ++ ℚ (SeparableClosure ℚ) H.field).val := by ++ ext x ++ rfl ++ have hRange : ++ (numberFieldEmbeddedLowerEmbedding ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) ++ ((abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ)).fieldRange = ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field := by ++ ext x ++ constructor ++ · rintro ⟨y, rfl⟩ ++ change ++ numberFieldEmbeddedLowerEmbedding ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field) ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below) ++ ((abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ) y ∈ ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ rw [hi] ++ exact y.property ++ · intro hx ++ refine ⟨⟨x, hx⟩, ?_⟩ ++ rw [hi] ++ rfl ++ rw [numberFieldEmbeddedBaseSubgroup, hRange] ++ exact ++ closedFixingSubgroup_abstractFixedField_eq ++ ℚ (SeparableClosure ℚ) H.field ++ ++/-- The upper subgroup obtained from the canonical inclusion of an abstract ++fixed-field tower is the original upper closed subgroup. -/ ++theorem ++ numberFieldEmbeddedTopSubgroup_abstractFixedFieldInclusion ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ numberFieldEmbeddedTopSubgroup F E j = P.field := by ++ dsimp only ++ rw [numberFieldEmbeddedTopSubgroup] ++ have hjRangeSelf : ++ ((abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ).fieldRange = ++ (abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below).restrictScalars ℚ := by ++ ext x ++ constructor ++ · rintro ⟨y, rfl⟩ ++ exact y.property ++ · intro hx ++ exact ⟨⟨x, hx⟩, rfl⟩ ++ have hjRange : ++ ((abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below).val.restrictScalars ℚ).fieldRange = ++ abstractFixedField ℚ (SeparableClosure ℚ) P.field := by ++ exact hjRangeSelf.trans ++ (IntermediateField.extendScalars_restrictScalars ++ (abstractFixedField_le ++ ℚ (SeparableClosure ℚ) P.below)) ++ rw [hjRange] ++ exact ++ closedFixingSubgroup_abstractFixedField_eq ++ ℚ (SeparableClosure ℚ) P.field ++ ++/-- Transport a packaged rational norm-residue value directly from an equal ++abstract base to the finite Galois extension underlying `P`. Keeping the two ++dependent transports in their own declaration prevents their elaboration cost ++from accumulating in the main fixed-field comparison theorem. -/ ++theorem rationalFiniteNormResidueValue_transportToAbstractExtension ++ {A : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} ++ (hAH : A = H) ++ (L : FiniteGaloisSubextension A.field) ++ (hLP : ++ Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension Y.field) ++ hAH) ++ L = ++ P.toFiniteGaloisExtension) ++ {C X : Type} [AddGroup C] [AddGroup X] ++ (eIdele : C ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation A.field) ++ (eGalois : Additive (Abelianization L.extensionQuotient) ≃+ X) ++ (c : C) : ++ rationalFiniteNormResidueValue A L eIdele eGalois c = ++ rationalFiniteNormResidueValue H P.toFiniteGaloisExtension ++ (Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ C ≃+ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation Y.field) ++ hAH) ++ eIdele) ++ (abelianizedExtensionQuotientAddEquiv_transportExtension hLP ++ (abelianizedExtensionQuotientAddEquiv_transportBase ++ hAH L eGalois)) ++ c := by ++ calc ++ _ = rationalFiniteNormResidueValue H ++ (Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension Y.field) ++ hAH) ++ L) ++ (Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ C ≃+ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation Y.field) ++ hAH) ++ eIdele) ++ (abelianizedExtensionQuotientAddEquiv_transportBase hAH L eGalois) ++ c := ++ rationalFiniteNormResidueValue_transportBase ++ (A := A) (B := H) (C := C) (X := X) ++ hAH L eIdele eGalois c ++ _ = _ := ++ rationalFiniteNormResidueValue_transportExtension ++ (K := H) ++ (P := Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension Y.field) ++ hAH) ++ L) ++ (Q := P.toFiniteGaloisExtension) (C := C) (X := X) ++ hLP ++ (Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ C ≃+ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation Y.field) ++ hAH) ++ eIdele) ++ (abelianizedExtensionQuotientAddEquiv_transportBase hAH L eGalois) ++ c ++ ++/-- The packaged value at the literal fixed-field realization is the ambient ++fixed-part norm-residue homomorphism evaluated at the same idele class. -/ ++private theorem rationalFiniteNormResidueValue_abstractFixedField_eq_ambient ++ (c : IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) : ++ rationalFiniteNormResidueValue H P.toFiniteGaloisExtension ++ (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) ++ (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P) ++ (Additive.ofMul c) = ++ ambientFixedGlobalNormResidueAddMonoidHom H P ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ H.field (Additive.ofMul c)) := by ++ let eRec := ++ rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ H P.toFiniteGaloisExtension ++ let eGal := ++ abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P ++ change ++ eGal ++ (eRec ++ (finiteNormClass rationalIdeleClassRepresentation ++ H.field P.field P.below ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ H.field (Additive.ofMul c)))) = ++ eGal ++ (eRec ++ (finiteNormClass rationalIdeleClassRepresentation ++ H.field P.field P.below ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ H.field (Additive.ofMul c)))) ++ rfl ++ ++/-- The packaged norm-residue value for the literal fixed-field realization ++is the intrinsic abstract fixed-field norm-residue value. -/ ++theorem rationalFiniteNormResidueValue_abstractFixedField_apply ++ (c : IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field)) : ++ Additive.toMul ++ (rationalFiniteNormResidueValue H P.toFiniteGaloisExtension ++ (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) ++ (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup ++ H P) ++ (Additive.ofMul c)) = ++ abstractFixedFieldGlobalNormResidueMonoidHom H P c := by ++ let a := ++ rationalAbstractFixedFieldIdeleClassEquivFixed ++ H.field (Additive.ofMul c) ++ have hAbstract := ++ abstractFixedFieldGlobalNormResidueMonoidHom_fixed_apply H P a ++ calc ++ _ = Additive.toMul ++ (ambientFixedGlobalNormResidueAddMonoidHom H P ++ (rationalAbstractFixedFieldIdeleClassEquivFixed ++ H.field (Additive.ofMul c))) := by ++ exact congrArg Additive.toMul ++ (rationalFiniteNormResidueValue_abstractFixedField_eq_ambient ++ (H := H) (P := P) c) ++ _ = _ := by ++ simpa only [a, AddEquiv.symm_apply_apply, toMul_ofMul] using ++ hAbstract.symm ++ ++ ++end AbstractFixedFieldInclusion ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityFixedComparison.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityFixedComparison.lean +new file mode 100644 +index 0000000..ce523c2 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityFixedComparison.lean +@@ -0,0 +1,237 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityAbelianValues ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++section AbstractFixedFieldInclusion ++ ++variable ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ naturalityAbstractFixedFieldBaseQuotientFinite ++ naturalityAbstractFixedFieldRelativeQuotientFinite ++ naturalityAbstractFixedFieldFiniteDimensional ++ naturalityAbstractRelativeFixedFieldFiniteDimensional ++ naturalityAbstractFixedFieldRelativeScalarTower ++ naturalityAbstractRelativeFixedFieldAbsoluteFiniteDimensional ++ naturalityAbstractFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldNumberField ++ naturalityAbstractRelativeFixedFieldIsGalois ++ naturalityAbstractRelativeFixedFieldIsAbelianGalois ++ ++ ++private theorem ++ abstractFixedFieldInclusionEmbeddedNormResidueValue_eq_transported ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (c : Additive ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : ++ abstractFixedFieldInclusionEmbeddedNormResidueValue H P c = ++ abstractFixedFieldInclusionTransportedNormResidueValue H P c := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ let PEmbedded : FiniteGaloisSubextension HEmbedded.field := ++ numberFieldEmbeddedFiniteGaloisSubextension F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ have hPEmbedded : ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension X.field) ++ hHEmbedded) ++ PEmbedded = ++ P.toFiniteGaloisExtension := ++ numberFieldEmbeddedFiniteGaloisSubextension_transport_eq H P ++ let eIdeleEmbedded := ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j ++ let eGaloisEmbedded := ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup F E j ++ simpa only [ ++ abstractFixedFieldInclusionEmbeddedNormResidueValue, ++ abstractFixedFieldInclusionTransportedNormResidueValue, ++ abstractFixedFieldInclusionTransportedAbelianizedEquiv, ++ eIdeleEmbedded, ++ eGaloisEmbedded] using ++ (rationalFiniteNormResidueValue_transportToAbstractExtension ++ (H := H) (P := P) ++ (A := HEmbedded) ++ (C := Additive (IdeleClassGroup F)) ++ (X := Additive Gal(E / F)) ++ hHEmbedded PEmbedded hPEmbedded ++ eIdeleEmbedded eGaloisEmbedded c) ++ ++/-- A packaged finite norm-residue value depends only on the value of its ++idele comparison at the chosen input and the value of its Galois comparison ++at the resulting norm class. -/ ++private theorem rationalFiniteNormResidueValue_congr_apply ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (L : FiniteGaloisSubextension K.field) ++ {C X : Type} [AddGroup C] [AddGroup X] ++ (eIdele eIdele' : C ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation K.field) ++ (eGalois eGalois' : ++ Additive (Abelianization L.extensionQuotient) ≃+ X) ++ (c : C) ++ (heIdele : eIdele c = eIdele' c) ++ (heGalois : ∀ z, eGalois z = eGalois' z) : ++ rationalFiniteNormResidueValue K L eIdele eGalois c = ++ rationalFiniteNormResidueValue K L eIdele' eGalois' c := by ++ unfold rationalFiniteNormResidueValue ++ rw [heIdele] ++ exact heGalois _ ++ ++/-- The transported packaged value is the intrinsic canonical packaged value; ++only the idele input and the eventual abelianized value are compared. -/ ++private theorem ++ abstractFixedFieldInclusionTransportedNormResidueValue_eq_canonical ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (c : Additive ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : ++ abstractFixedFieldInclusionTransportedNormResidueValue H P c = ++ abstractFixedFieldInclusionCanonicalNormResidueValue H P c := by ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ let HEmbedded := ++ numberFieldEmbeddedFiniteAbstractField F E j ++ have hHEmbedded : HEmbedded = H := ++ numberFieldEmbeddedFiniteAbstractField_abstractFixedFieldInclusion H P ++ let eIdeleEmbedded := ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed F E j ++ let eIdeleOverH : ++ Additive (IdeleClassGroup F) ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation H.field := ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ Additive (IdeleClassGroup F) ≃+ ++ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation X.field) ++ hHEmbedded) ++ eIdeleEmbedded ++ simpa only [ ++ abstractFixedFieldInclusionTransportedNormResidueValue, ++ abstractFixedFieldInclusionCanonicalNormResidueValue, ++ eIdeleEmbedded, ++ eIdeleOverH] using ++ (rationalFiniteNormResidueValue_congr_apply ++ H P.toFiniteGaloisExtension ++ eIdeleOverH ++ (rationalAbstractFixedFieldIdeleClassEquivFixed H.field) ++ (abstractFixedFieldInclusionTransportedAbelianizedEquiv H P) ++ (abstractFixedFieldAbelianizedExtensionQuotientEquivGaloisGroup H P) ++ c ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed_transport_apply H P c) ++ (fun z => abstractFixedFieldInclusionTransportedAbelianizedValue_eq ++ H P z)) ++ ++/-- The explicitly embedded and intrinsic packaged norm-residue values agree. -/ ++private theorem ++ abstractFixedFieldInclusionEmbeddedNormResidueValue_eq ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) ++ (c : Additive ++ (IdeleClassGroup ++ (abstractFixedField ℚ (SeparableClosure ℚ) H.field))) : ++ abstractFixedFieldInclusionEmbeddedNormResidueValue H P c = ++ abstractFixedFieldInclusionCanonicalNormResidueValue H P c := ++ (abstractFixedFieldInclusionEmbeddedNormResidueValue_eq_transported ++ H P c).trans ++ (abstractFixedFieldInclusionTransportedNormResidueValue_eq_canonical ++ H P c) ++ ++/-- For the literal fixed fields attached to an abstract finite abelian ++extension, the norm-residue map obtained from their canonical inclusion in ++the rational separable closure is the intrinsic fixed-field norm-residue ++map. -/ ++theorem ++ globalNormResidueMonoidHomOfEmbedding_abstractFixedFieldInclusion ++ (H : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (P : FiniteAbelianSubextension H.field) : ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H.field ++ let E := ++ abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ globalNormResidueMonoidHomOfEmbedding F E j = ++ abstractFixedFieldGlobalNormResidueMonoidHom H P := by ++ dsimp only ++ apply MonoidHom.ext ++ intro c ++ rw [globalNormResidueMonoidHomOfEmbedding_apply] ++ change ++ Additive.toMul ++ (abstractFixedFieldInclusionEmbeddedNormResidueValue ++ H P (Additive.ofMul c)) = ++ abstractFixedFieldGlobalNormResidueMonoidHom H P c ++ calc ++ _ = Additive.toMul ++ (abstractFixedFieldInclusionCanonicalNormResidueValue ++ H P (Additive.ofMul c)) := ++ congrArg Additive.toMul ++ (abstractFixedFieldInclusionEmbeddedNormResidueValue_eq ++ H P (Additive.ofMul c)) ++ _ = _ := by ++ simpa only [abstractFixedFieldInclusionCanonicalNormResidueValue] using ++ (rationalFiniteNormResidueValue_abstractFixedField_apply ++ (H := H) (P := P) c) ++ ++end AbstractFixedFieldInclusion ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerBase.lean +new file mode 100644 +index 0000000..dcad422 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerBase.lean +@@ -0,0 +1,339 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityFixedComparison ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ ++section EmbeddedNumberFieldRestriction ++ ++variable ++ (K K' L L' : Type) ++ [Field K] [NumberField K] ++ [Field K'] [NumberField K'] ++ [Field L] [NumberField L] ++ [Field L'] [NumberField L'] ++ [Algebra K K'] [Algebra K L] [Algebra K L'] ++ [Algebra K' L'] [Algebra L L'] ++ [IsScalarTower K K' L'] [IsScalarTower K L L'] ++ ++ ++/-- Rebracketing the compatible tower does not change its embedded lower ++fixing subgroup. -/ ++private theorem numberFieldEmbeddedBaseSubgroup_baseChange_eq ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j) = ++ numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')) := by ++ have hi : ++ numberFieldEmbeddedLowerEmbedding K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j) = ++ numberFieldEmbeddedLowerEmbedding K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')) := by ++ ext x ++ simp only [numberFieldEmbeddedLowerEmbedding, AlgHom.comp_apply, ++ IsScalarTower.coe_toAlgHom'] ++ rw [← IsScalarTower.algebraMap_apply K K' L', ++ ← IsScalarTower.algebraMap_apply K L L'] ++ simp only [numberFieldEmbeddedBaseSubgroup, hi] ++ ++omit [Field K] [NumberField K] ++ [Algebra K K'] [Algebra K L'] [IsScalarTower K K' L'] in ++/-- The top subgroup of the rebracketed base-change tower is the embedded ++fixing subgroup of the intermediate field. -/ ++private theorem numberFieldEmbeddedTopSubgroup_baseChange_eq ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ numberFieldEmbeddedTopSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j) = ++ numberFieldEmbeddedBaseSubgroup K' L' j := by ++ rfl ++ ++/-- Reidentify the two presentations of the embedded lower fixing subgroup ++without transporting dependent subgroup data through an equality. -/ ++private noncomputable def numberFieldEmbeddedBaseChangeBaseEquiv ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ (numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup ≃* ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup := ++ MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup ++ (numberFieldEmbeddedBaseSubgroup_baseChange_eq K K' L L' j)) ++ ++/-- Under the identity equivalence of the two lower fixing subgroups, the ++relative subgroup for the base change is exactly the target presentation. -/ ++private theorem numberFieldEmbeddedBaseChangeExtensionSubgroup_map_eq ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)) ++ (numberFieldEmbeddedTopSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j))).map ++ (numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j).toMonoidHom = ++ CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) := by ++ let e := numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j ++ have hTop : ++ (numberFieldEmbeddedTopSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup = ++ (numberFieldEmbeddedBaseSubgroup K' L' j).toSubgroup := ++ congrArg ClosedSubgroup.toSubgroup ++ (numberFieldEmbeddedTopSubgroup_baseChange_eq ++ (K := K) (K' := K') (L' := L') j) ++ ext x ++ constructor ++ · rintro ⟨y, hy, rfl⟩ ++ change ++ ((e y : ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup) : ++ SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) ∈ ++ (numberFieldEmbeddedBaseSubgroup K' L' j).toSubgroup ++ dsimp only [e, numberFieldEmbeddedBaseChangeBaseEquiv] ++ rw [MulEquiv.subgroupCongr_apply, ← hTop] ++ exact hy ++ · intro hx ++ refine ⟨e.symm x, ?_, e.apply_symm_apply x⟩ ++ change ++ (((e.symm x : ++ (numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup) : ++ SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) ∈ ++ (numberFieldEmbeddedTopSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup) ++ dsimp only [e, numberFieldEmbeddedBaseChangeBaseEquiv] ++ rw [MulEquiv.subgroupCongr_symm_apply, hTop] ++ exact hx ++ ++/-- Normality of the relative subgroup between the two embedded base fields ++in a finite Galois base change. -/ ++private theorem numberFieldEmbeddedBaseChangeExtensionSubgroup_normal ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)).Normal := by ++ let e := numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j ++ have hNormal := ++ (numberFieldEmbeddedExtensionSubgroup_normal K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).map ++ e.toMonoidHom e.surjective ++ rw [numberFieldEmbeddedBaseChangeExtensionSubgroup_map_eq ++ K K' L L' j] at hNormal ++ exact hNormal ++ ++noncomputable local instance ++ numberFieldEmbeddedBaseChangeExtensionSubgroupNormal ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ (CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)).Normal := ++ numberFieldEmbeddedBaseChangeExtensionSubgroup_normal K K' L L' j ++ ++/-- Finiteness of the relative quotient between the two embedded base fields ++in a finite Galois base change. -/ ++private theorem numberFieldEmbeddedBaseChangeExtensionQuotient_finite ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ Finite ++ ((numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := by ++ let e := numberFieldEmbeddedBaseChangeBaseEquiv K K' L L' j ++ let N := ++ CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)) ++ (numberFieldEmbeddedTopSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)) ++ (numberFieldEmbeddedTopSubgroup_le_baseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)) ++ let M := ++ CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) ++ let hNNormal : N.Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j) ++ let hMNormal : M.Normal := ++ numberFieldEmbeddedBaseChangeExtensionSubgroup_normal K K' L L' j ++ let hNFinite : ++ Finite ++ ((numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup ⧸ N) := ++ numberFieldEmbeddedExtensionQuotient_finite K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j) ++ have hmap : N.map e.toMonoidHom = M := ++ numberFieldEmbeddedBaseChangeExtensionSubgroup_map_eq K K' L L' j ++ have hle : N ≤ M.comap e.toMonoidHom := by ++ rw [← hmap] ++ exact Subgroup.le_comap_map e.toMonoidHom N ++ let f : ++ ((numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup ⧸ N) →* ++ ((numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ M) := ++ QuotientGroup.map N M e.toMonoidHom hle ++ have hmk : Function.Surjective ++ (QuotientGroup.mk ∘ e : ++ (numberFieldEmbeddedBaseSubgroup K K' ++ (numberFieldEmbeddedLowerEmbedding K' L' j)).toSubgroup → ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ M) := ++ QuotientGroup.mk_surjective.comp e.surjective ++ have hsurj : Function.Surjective f := ++ QuotientGroup.map_surjective_of_surjective ++ (N := N) M e.toMonoidHom hmk hle ++ exact Finite.of_surjective f hsurj ++ ++noncomputable local instance ++ numberFieldEmbeddedBaseChangeExtensionQuotientFinite ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ Finite ++ ((numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := ++ numberFieldEmbeddedBaseChangeExtensionQuotient_finite K K' L L' j ++ ++/-- Reuse the canonical absolute fixed-field witness for the lower embedded ++tower. The base-change relative witness below needs this exact instance path ++when forming the absolute finite-dimensional tower. -/ ++noncomputable local instance ++ numberFieldEmbeddedBaseChangeBaseFixedFieldFiniteDimensional ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteDimensional ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')))) := ++ numberFieldEmbeddedAbstractFixedFieldFiniteDimensional K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')) ++ ++noncomputable local instance ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldFiniteDimensional ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteDimensional ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')))) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := ++ abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) ++ (numberFieldEmbeddedAbsoluteQuotientFinite K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseChangeExtensionQuotientFinite K K' L L' j) ++ ++local instance ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldScalarTower ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ IsScalarTower ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')))) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := ++ IsScalarTower.of_algebraMap_eq' (RingHom.ext_rat _ _) ++ ++noncomputable local instance ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldAbsoluteFiniteDimensional ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ FiniteDimensional ℚ ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := ++ FiniteDimensional.trans ℚ ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')))) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) ++ ++noncomputable local instance ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldNumberField ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ NumberField ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := ++ NumberField.of_module_finite ℚ ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) ++ ++noncomputable local instance ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldIsGalois ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ IsGalois ++ (abstractFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')))) ++ (abstractRelativeFixedField ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j)) := ++ abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) ++ (numberFieldEmbeddedBaseSubgroup K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L'))) ++ (numberFieldEmbeddedBaseSubgroup K' L' j) ++ (numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j) ++ (numberFieldEmbeddedBaseChangeExtensionSubgroupNormal K K' L L' j) ++ ++ ++end EmbeddedNumberFieldRestriction ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerNorm.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerNorm.lean +new file mode 100644 +index 0000000..a0d887a +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerNorm.lean +@@ -0,0 +1,261 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityTowerRestriction ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++section EmbeddedNumberFieldRestriction ++ ++variable ++ (K K' L L' : Type) ++ [Field K] [NumberField K] ++ [Field K'] [NumberField K'] ++ [Field L] [NumberField L] ++ [Field L'] [NumberField L'] ++ [Algebra K K'] [Algebra K L] [Algebra K L'] ++ [Algebra K' L'] [Algebra L L'] ++ [IsScalarTower K K' L'] [IsScalarTower K L L'] ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ numberFieldEmbeddedBaseChangeExtensionSubgroupNormal ++ numberFieldEmbeddedBaseChangeExtensionQuotientFinite ++ numberFieldEmbeddedBaseChangeBaseFixedFieldFiniteDimensional ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldFiniteDimensional ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldScalarTower ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldAbsoluteFiniteDimensional ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldNumberField ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldIsGalois ++ ++/-- For one common compatible embedding of a Galois base-change ++diamond, the genuine global norm-residue maps commute with ordinary ++idele-class norm and actual restriction of automorphisms. -/ ++theorem globalNormResidueMonoidHomOfEmbedding_norm_restriction ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ [FiniteDimensional K' L'] [IsAbelianGalois K' L'] ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) : ++ let jLower : L →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ L L') ++ ((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)).comp ++ (globalNormResidueMonoidHomOfEmbedding K' L' j) = ++ (globalNormResidueMonoidHomOfEmbedding K L jLower).comp ++ (_root_.ideleClassNorm K K') := by ++ dsimp only ++ let jLower : L →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ L L') ++ let H := ++ numberFieldEmbeddedBaseSubgroup K L jLower ++ let H' := ++ numberFieldEmbeddedBaseSubgroup K' L' j ++ let J := ++ numberFieldEmbeddedTopSubgroup K L jLower ++ let J' := ++ numberFieldEmbeddedTopSubgroup K' L' j ++ let hJH := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L jLower ++ let hJ'H' := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup K' L' j ++ let hH'H := ++ numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j ++ let hJ'J := ++ numberFieldEmbeddedTopSubgroup_le_of_tower K K' L L' j ++ let _ : ++ (CyclicCohomology.extensionSubgroup H J hJH).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K L jLower ++ let _ : ++ Finite ++ (H.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H J hJH) := ++ numberFieldEmbeddedExtensionQuotient_finite K L jLower ++ let _ : ++ (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K' L' j ++ let _ : ++ Finite ++ (H'.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H' J' hJ'H') := ++ numberFieldEmbeddedExtensionQuotient_finite K' L' j ++ let hHH'finite := ++ numberFieldEmbeddedBaseChangeExtensionQuotientFinite K K' L L' j ++ let T : ++ FiniteAbstractFieldExtension ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) := ++ { field := numberFieldEmbeddedFiniteAbstractField K' L' j ++ base := numberFieldEmbeddedFiniteAbstractField K L jLower ++ below := hH'H ++ finiteQuotient := hHH'finite } ++ let hTBaseNormal : ++ (CyclicCohomology.extensionSubgroup ++ T.base.field J hJH).Normal := by ++ change ++ (CyclicCohomology.extensionSubgroup H J hJH).Normal ++ exact numberFieldEmbeddedExtensionSubgroup_normal K L jLower ++ let hTBaseFinite : ++ Finite ++ (T.base.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ T.base.field J hJH) := by ++ change ++ Finite ++ (H.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H J hJH) ++ exact numberFieldEmbeddedExtensionQuotient_finite K L jLower ++ let hTFieldNormal : ++ (CyclicCohomology.extensionSubgroup ++ T.field.field J' hJ'H').Normal := by ++ change ++ (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal ++ exact numberFieldEmbeddedExtensionSubgroup_normal K' L' j ++ let hTFieldFinite : ++ Finite ++ (T.field.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ T.field.field J' hJ'H') := by ++ change ++ Finite ++ (H'.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H' J' hJ'H') ++ exact numberFieldEmbeddedExtensionQuotient_finite K' L' j ++ let restrictActual : ++ Gal(L' / K') →* Gal(L / K) := ++ (AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K) ++ apply MonoidHom.ext ++ intro c ++ let a := ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K' L' j (Additive.ofMul c) ++ have hnat := ++ DegreeData.normResidueNaturality_norm_restriction ++ (D := rationalCyclotomicDegreeData) ++ (A := rationalIdeleClassRepresentation) ++ (v := rationalCyclotomicIdeleClassValuationData) ++ (hcf := rationalIdeleClassRepresentation_satisfiesClassFieldAxiom) ++ (T := T) (L := J) (L' := J') ++ (hLnormal := hTBaseNormal) ++ (hL'normal := hTFieldNormal) ++ (hLKfinite := hTBaseFinite) ++ (hL'K'finite := hTFieldFinite) ++ hJH hJ'H' hJ'J ++ have hnatc := ++ DFunLike.congr_fun hnat ++ (finiteNormClass rationalIdeleClassRepresentation ++ H' J' hJ'H' a) ++ change _ = ++ rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ T.base ++ { field := J ++ below := hJH ++ normal := hTBaseNormal ++ finite := hTBaseFinite } ++ (finiteReciprocityNaturalityNormMap ++ rationalIdeleClassRepresentation ++ T.base.field T.field.field J J' ++ hJH hJ'H' T.below hJ'J ++ (finiteNormClass rationalIdeleClassRepresentation ++ T.field.field J' hJ'H' a)) at hnatc ++ rw [finiteReciprocityNaturalityNormMap_finiteNormClass] ++ at hnatc ++ have hnorm : ++ relativeNorm rationalIdeleClassRepresentation ++ H H' hH'H a = ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K L jLower ++ (Additive.ofMul (_root_.ideleClassNorm K K' c)) := ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed_relativeNorm ++ K K' L L' j c ++ calc ++ restrictActual ++ (globalNormResidueMonoidHomOfEmbedding K' L' j c) = ++ restrictActual ++ (Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K' L' j ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K' L' j) ++ (numberFieldEmbeddedFiniteGaloisSubextension K' L' j) ++ (finiteNormClass rationalIdeleClassRepresentation ++ H' J' hJ'H' a)))) := by ++ rw [globalNormResidueMonoidHomOfEmbedding_apply] ++ _ = ++ Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L jLower ++ (MonoidHom.toAdditive ++ (normResidueNaturalityAbelianizedRestriction ++ H H' J J' hJH hJ'H' hH'H hJ'J) ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K' L' j) ++ (numberFieldEmbeddedFiniteGaloisSubextension K' L' j) ++ (finiteNormClass rationalIdeleClassRepresentation ++ H' J' hJ'H' a)))) := by ++ exact ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup_restriction ++ K K' L L' j _ ++ _ = ++ Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L jLower ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ (numberFieldEmbeddedFiniteAbstractField K L jLower) ++ (numberFieldEmbeddedFiniteGaloisSubextension K L jLower) ++ (finiteNormClass rationalIdeleClassRepresentation ++ H J hJH ++ (relativeNorm rationalIdeleClassRepresentation ++ H H' hH'H a)))) := by ++ exact congrArg ++ (fun z => ++ Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L jLower z)) ++ hnatc ++ _ = ++ globalNormResidueMonoidHomOfEmbedding K L jLower ++ (_root_.ideleClassNorm K K' c) := by ++ rw [hnorm, ++ ← globalNormResidueMonoidHomOfEmbedding_apply] ++ ++end EmbeddedNumberFieldRestriction ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerRestriction.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerRestriction.lean +new file mode 100644 +index 0000000..16ee169 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTowerRestriction.lean +@@ -0,0 +1,372 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalNormResidueNaturalityTowerBase ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++ ++section EmbeddedNumberFieldRestriction ++ ++variable ++ (K K' L L' : Type) ++ [Field K] [NumberField K] ++ [Field K'] [NumberField K'] ++ [Field L] [NumberField L] ++ [Field L'] [NumberField L'] ++ [Algebra K K'] [Algebra K L] [Algebra K L'] ++ [Algebra K' L'] [Algebra L L'] ++ [IsScalarTower K K' L'] [IsScalarTower K L L'] ++ ++attribute [local instance] ++ naturalityIdeleClassCommGroup ++ ideleClassGroupIsMulCommutative ++ ideleClassSubgroupNormal ++ numberFieldEmbeddedBaseChangeExtensionSubgroupNormal ++ numberFieldEmbeddedBaseChangeExtensionQuotientFinite ++ numberFieldEmbeddedBaseChangeBaseFixedFieldFiniteDimensional ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldFiniteDimensional ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldScalarTower ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldAbsoluteFiniteDimensional ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldNumberField ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldIsGalois ++ ++/-- In one common rational-separable-closure realization, the canonical ++quotient-to-Galois comparisons intertwine abstract restriction with ++ordinary restriction of the actual number-field automorphisms. -/ ++theorem ++ numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup_restriction ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ [FiniteDimensional K' L'] [IsAbelianGalois K' L'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) ++ (z : ++ Abelianization ++ (numberFieldEmbeddedFiniteGaloisSubextension ++ K' L' j).extensionQuotient) : ++ let jLower : L →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ L L') ++ let H := ++ numberFieldEmbeddedBaseSubgroup K L jLower ++ let H' := ++ numberFieldEmbeddedBaseSubgroup K' L' j ++ let J := ++ numberFieldEmbeddedTopSubgroup K L jLower ++ let J' := ++ numberFieldEmbeddedTopSubgroup K' L' j ++ let hH'H := ++ numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j ++ let hJ'J := ++ numberFieldEmbeddedTopSubgroup_le_of_tower K K' L L' j ++ let hJH := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup K L jLower ++ let hJ'H' := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup K' L' j ++ letI _ : ++ (CyclicCohomology.extensionSubgroup H J hJH).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K L jLower ++ letI _ : ++ (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K' L' j ++ ((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)) ++ (Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K' L' j (Additive.ofMul z))) = ++ Additive.toMul ++ (numberFieldEmbeddedAbelianizedExtensionQuotientEquivGaloisGroup ++ K L jLower ++ (MonoidHom.toAdditive ++ (normResidueNaturalityAbelianizedRestriction ++ H H' J J' ++ hJH hJ'H' ++ hH'H hJ'J) ++ (Additive.ofMul z))) := by ++ dsimp only ++ let jLower : L →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ L L') ++ let H := ++ numberFieldEmbeddedBaseSubgroup K L jLower ++ let H' := ++ numberFieldEmbeddedBaseSubgroup K' L' j ++ let J := ++ numberFieldEmbeddedTopSubgroup K L jLower ++ let J' := ++ numberFieldEmbeddedTopSubgroup K' L' j ++ let hH'H := ++ numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j ++ let hJ'J := ++ numberFieldEmbeddedTopSubgroup_le_of_tower K K' L L' j ++ let hJH := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup ++ K L jLower ++ let hJ'H' := ++ numberFieldEmbeddedTopSubgroup_le_baseSubgroup ++ K' L' j ++ let hLowerNormal : ++ (CyclicCohomology.extensionSubgroup H J hJH).Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K L jLower ++ let hUpperNormal : ++ (CyclicCohomology.extensionSubgroup H' J' hJ'H').Normal := ++ numberFieldEmbeddedExtensionSubgroup_normal K' L' j ++ let qLower := ++ numberFieldEmbeddedExtensionQuotientEquivGaloisGroup ++ K L jLower ++ let qUpper := ++ numberFieldEmbeddedExtensionQuotientEquivGaloisGroup ++ K' L' j ++ let qLowerRaw : ++ (H.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H J hJH) ≃* ++ Gal(L / K) := by ++ exact ++ { qLower.toEquiv with ++ map_mul' := fun x y => qLower.map_mul x y } ++ let qUpperRaw : ++ (H'.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H' J' hJ'H') ≃* ++ Gal(L' / K') := by ++ exact ++ { qUpper.toEquiv with ++ map_mul' := fun x y => qUpper.map_mul x y } ++ let restrictActual : ++ Gal(L' / K') →* Gal(L / K) := ++ (AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K) ++ obtain ⟨q, rfl⟩ := ++ QuotientGroup.mk_surjective z ++ obtain ⟨σ, rfl⟩ := ++ (numberFieldEmbeddedFiniteGaloisSubextension ++ K' L' j).extensionQuotientMk_surjective q ++ change ++ restrictActual ++ ((Abelianization.equivOfComm (H := Gal(L' / K'))).symm ++ (qUpperRaw.abelianizationCongr ++ (Abelianization.of (QuotientGroup.mk σ)))) = ++ (Abelianization.equivOfComm (H := Gal(L / K))).symm ++ (qLowerRaw.abelianizationCongr ++ (normResidueNaturalityAbelianizedRestriction ++ H H' J J' hJH hJ'H' hH'H hJ'J ++ (Abelianization.of (QuotientGroup.mk σ)))) ++ rw [normResidueNaturalityAbelianizedRestriction_of_mk, ++ abelianizationCongr_of, abelianizationCongr_of] ++ change ++ restrictActual (qUpperRaw (QuotientGroup.mk σ)) = ++ qLowerRaw ++ (QuotientGroup.mk (Subgroup.inclusion hH'H σ)) ++ apply AlgEquiv.ext ++ intro x ++ apply jLower.injective ++ let hUpperAlgebra : Algebra K' (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra K' L' j ++ let eUpper := ++ numberFieldEmbeddedSeparableClosureEquiv K' L' j ++ let hLowerAlgebra : Algebra K (SeparableClosure ℚ) := ++ numberFieldEmbeddedSeparableClosureAlgebra K L jLower ++ let eLower := ++ numberFieldEmbeddedSeparableClosureEquiv K L jLower ++ calc ++ jLower ++ (restrictActual ++ (qUpperRaw (QuotientGroup.mk σ)) x) = ++ j ++ ((qUpperRaw (QuotientGroup.mk σ)) ++ (algebraMap L L' x)) := by ++ exact congrArg j ++ (AlgEquiv.restrictNormal_commutes ++ ((AlgEquiv.restrictScalarsHom K) ++ (qUpperRaw (QuotientGroup.mk σ))) ++ L x) ++ _ = σ.1.1 ++ (j (algebraMap L L' x)) := by ++ exact ++ ambientEmbeddedExtensionQuotientEquivGaloisGroup_mk_apply ++ ℚ K' L' j eUpper σ (algebraMap L L' x) ++ _ = (Subgroup.inclusion hH'H σ).1.1 ++ (jLower x) := rfl ++ _ = jLower ++ (qLowerRaw ++ (QuotientGroup.mk ++ (Subgroup.inclusion hH'H σ)) x) := by ++ exact ++ (ambientEmbeddedExtensionQuotientEquivGaloisGroup_mk_apply ++ ℚ K L jLower eLower ++ (Subgroup.inclusion hH'H σ) x).symm ++ ++/-- In a compatible common embedding, the fixed-part relative norm ++between two (Galois-related) base fields is the genuine ordinary ++idele-class norm. -/ ++theorem numberFieldEmbeddedIdeleClassEquivAmbientFixed_relativeNorm ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) ++ (c : IdeleClassGroup K') : ++ let jLower : L →ₐ[ℚ] SeparableClosure ℚ := ++ j.comp (IsScalarTower.toAlgHom ℚ L L') ++ let H := ++ numberFieldEmbeddedBaseSubgroup K L jLower ++ let H' := ++ numberFieldEmbeddedBaseSubgroup K' L' j ++ let hH'H := ++ numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j ++ letI _ : Finite ++ (H.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H H' hH'H) := ++ numberFieldEmbeddedBaseChangeExtensionQuotientFinite ++ K K' L L' j ++ relativeNorm rationalIdeleClassRepresentation H H' hH'H ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K' L' j (Additive.ofMul c)) = ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K L jLower ++ (Additive.ofMul (_root_.ideleClassNorm K K' c)) := by ++ intro jLower H H' ++ let hH'H := ++ numberFieldEmbeddedBaseSubgroup_le_of_tower K K' L L' j ++ let hnormal := ++ numberFieldEmbeddedBaseChangeExtensionSubgroupNormal K K' L L' j ++ let F := ++ abstractFixedField ℚ (SeparableClosure ℚ) H ++ let E := ++ abstractRelativeFixedField ℚ (SeparableClosure ℚ) hH'H ++ let _ : ++ (CyclicCohomology.extensionSubgroup H H' hH'H).Normal := ++ hnormal ++ let _ : ++ Finite ++ (H.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H H' hH'H) := ++ numberFieldEmbeddedBaseChangeExtensionQuotientFinite ++ K K' L L' j ++ let _ : ++ Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ H (le_baseField H)) := ++ numberFieldEmbeddedAbsoluteQuotientFinite K L jLower ++ let _ : NumberField F := ++ numberFieldEmbeddedAbstractFixedFieldNumberField K L jLower ++ let _ : NumberField E := ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldNumberField ++ K K' L L' j ++ let _ : FiniteDimensional ℚ (E.restrictScalars ℚ) := by ++ change FiniteDimensional ℚ E ++ exact ++ numberFieldEmbeddedBaseChangeRelativeFixedFieldAbsoluteFiniteDimensional ++ K K' L L' j ++ let _ : NumberField ++ (abstractFixedField ℚ (SeparableClosure ℚ) H') := ++ numberFieldEmbeddedAbstractFixedFieldNumberField K' L' j ++ have hE : ++ E.restrictScalars ℚ = ++ abstractFixedField ℚ (SeparableClosure ℚ) H' := ++ IntermediateField.extendScalars_restrictScalars ++ (abstractFixedField_le ++ ℚ (SeparableClosure ℚ) hH'H) ++ let eRel : ++ E ≃ₐ[ℚ] ++ abstractFixedField ℚ (SeparableClosure ℚ) H' := ++ IntermediateField.equivOfEq hE ++ let eK : ++ K ≃ₐ[ℚ] F := ++ numberFieldEmbeddedAbstractBaseFieldEquiv K L jLower ++ let eK'Base : ++ K' ≃ₐ[ℚ] ++ abstractFixedField ℚ (SeparableClosure ℚ) H' := ++ numberFieldEmbeddedAbstractBaseFieldEquiv K' L' j ++ let eK' : K' ≃ₐ[ℚ] E := ++ eK'Base.trans eRel.symm ++ have hcompat (x : K) : ++ eK' (algebraMap K K' x) = ++ algebraMap F E (eK x) := by ++ apply eRel.injective ++ apply Subtype.ext ++ change ++ j (algebraMap K' L' (algebraMap K K' x)) = ++ j (algebraMap L L' (algebraMap K L x)) ++ rw [← IsScalarTower.algebraMap_apply K K' L', ++ ← IsScalarTower.algebraMap_apply K L L'] ++ have hupper : ++ rationalAbstractRelativeFixedFieldIdeleClassEquivFixed ++ H H' hH'H ++ (Additive.ofMul (ideleClassCongr eK' c)) = ++ numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K' L' j (Additive.ofMul c) := by ++ apply Subtype.ext ++ change ++ ((rationalIdeleClassEquivFixed (E.restrictScalars ℚ)) ++ (Additive.ofMul (ideleClassCongr eK' c))).1 = ++ ((rationalIdeleClassEquivFixed ++ (abstractFixedField ℚ (SeparableClosure ℚ) H')) ++ (Additive.ofMul (ideleClassCongr eK'Base c))).1 ++ exact rationalIdeleClassEquivFixed_transport_baseEquiv_val ++ (T := K') (A := E.restrictScalars ℚ) ++ (B := abstractFixedField ℚ (SeparableClosure ℚ) H') hE eK'Base c ++ have hrelative := ++ rationalAbstractRelativeFixedFieldIdeleClassEquivFixed_relativeNorm ++ H H' hH'H hnormal ++ (Additive.ofMul (ideleClassCongr eK' c)) ++ change ++ relativeNorm rationalIdeleClassRepresentation H H' hH'H ++ (rationalAbstractRelativeFixedFieldIdeleClassEquivFixed ++ H H' hH'H ++ (Additive.ofMul (ideleClassCongr eK' c))) = ++ rationalAbstractFixedFieldIdeleClassEquivFixed H ++ (Additive.ofMul ++ (_root_.ideleClassNorm F E ++ (ideleClassCongr eK' c))) ++ at hrelative ++ calc ++ relativeNorm rationalIdeleClassRepresentation H H' hH'H ++ (numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K' L' j (Additive.ofMul c)) = ++ relativeNorm rationalIdeleClassRepresentation H H' hH'H ++ (rationalAbstractRelativeFixedFieldIdeleClassEquivFixed ++ H H' hH'H (Additive.ofMul (ideleClassCongr eK' c))) := ++ congrArg (relativeNorm rationalIdeleClassRepresentation H H' hH'H) ++ hupper.symm ++ _ = rationalAbstractFixedFieldIdeleClassEquivFixed H ++ (Additive.ofMul ++ (_root_.ideleClassNorm F E (ideleClassCongr eK' c))) := hrelative ++ _ = numberFieldEmbeddedIdeleClassEquivAmbientFixed ++ K L jLower (Additive.ofMul (_root_.ideleClassNorm K K' c)) := by ++ change ++ rationalAbstractFixedFieldIdeleClassEquivFixed H ++ (Additive.ofMul ++ (_root_.ideleClassNorm F E (ideleClassCongr eK' c))) = ++ rationalAbstractFixedFieldIdeleClassEquivFixed H ++ (Additive.ofMul ++ (ideleClassCongr eK (_root_.ideleClassNorm K K' c))) ++ apply congrArg (rationalAbstractFixedFieldIdeleClassEquivFixed H) ++ apply congrArg Additive.ofMul ++ exact ++ (ideleClassCongr_ideleClassNorm ++ (K := K) (K' := F) (L := K') (L' := E) eK eK' hcompat c).symm ++ ++ ++end EmbeddedNumberFieldRestriction ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTransports.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTransports.lean +new file mode 100644 +index 0000000..5a39a62 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/GlobalNormResidueNaturalityTransports.lean +@@ -0,0 +1,445 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.AbstractFixedFieldGlobalNormResidue ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.TowerAlgEquivNaturality ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open ClassFormation ++open GlobalClassFields ++open KummerTheory ++open AlgebraicNumberTheory ++open LocalClassFieldTheory ++open RamificationTheory ++ ++universe u ++ ++/-- The commutative group structure on the quotient of ideles by principal ideles. -/ ++@[instance_reducible] ++noncomputable def naturalityIdeleClassCommGroup ++ (F : Type) [Field F] [NumberField F] : CommGroup (IdeleClassGroup F) := ++ QuotientGroup.Quotient.commGroup (IdeleGroup.principalSubgroup F) ++ ++attribute [local instance] naturalityIdeleClassCommGroup ++ ++local instance ideleClassGroupIsMulCommutative ++ {F : Type} [Field F] [NumberField F] ++ : IsMulCommutative (IdeleClassGroup F) := ++ ⟨⟨fun a b => mul_comm a b⟩⟩ ++ ++local instance ideleClassSubgroupNormal ++ {F : Type} [Field F] [NumberField F] ++ (N : Subgroup (IdeleClassGroup F)) : N.Normal := ++ N.normal_of_isMulCommutative ++ ++ ++/-- Two finite Galois subextensions with the same underlying closed subgroup ++are equal; the remaining structure fields are proof-irrelevant. -/ ++private theorem finiteGaloisSubextension_eq_of_field_eq ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {K : ClosedSubgroup G} ++ (A B : FiniteGaloisSubextension K) ++ (h : A.field = B.field) : ++ A = B := by ++ cases A with ++ | mk A hA nA fA => ++ cases B with ++ | mk B hB nB fB => ++ dsimp only at h ++ cases h ++ rfl ++ ++/-- Rebase a finite Galois subextension along equality of its bundled base. ++The field equality is the only data component; the remaining fields are ++proof-irrelevant. -/ ++theorem finiteGaloisSubextension_transport_eq_of_field_eq ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {A B : FiniteAbstractField G} ++ (hAB : A = B) ++ (P : FiniteGaloisSubextension A.field) ++ (Q : FiniteGaloisSubextension B.field) ++ (hfield : P.field = Q.field) : ++ Eq.mp ++ (congrArg ++ (fun X : FiniteAbstractField G => ++ FiniteGaloisSubextension X.field) ++ hAB) ++ P = Q := by ++ cases hAB ++ exact finiteGaloisSubextension_eq_of_field_eq P Q hfield ++ ++/-- Transporting an additive equivalence between rational ambient fixed ++subgroups does not change the underlying direct-limit class. -/ ++theorem rationalAmbientFixedAddEquiv_transport_apply_val ++ {A B : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} ++ (hAB : A = B) ++ {X : Type} [AddGroup X] ++ (e : X ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation A.field) ++ (x : X) : ++ ((Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ X ≃+ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation Y.field) ++ hAB) ++ e x).1) = ++ (e x).1 := by ++ cases hAB ++ rfl ++ ++/-- Changing only the bundled subgroup of an additive subgroup element ++does not change its value in the ambient group. -/ ++private theorem addSubgroupCongr_apply_val ++ {A : Type} [AddGroup A] ++ {H K : AddSubgroup A} ++ (h : H = K) (x : H) : ++ ((AddEquiv.addSubgroupCongr h x).1 : A) = x.1 := by ++ cases h ++ rfl ++ ++/-- Transporting an idele class along a field equality and the corresponding ++algebra equivalence leaves its rational direct-limit representative fixed. -/ ++theorem rationalIdeleClassEquivFixed_congr_apply_val ++ {A B : IntermediateField ℚ (SeparableClosure ℚ)} ++ [FiniteDimensional ℚ A] [FiniteDimensional ℚ B] ++ (h : A = B) ++ (e : B ≃ₐ[ℚ] A) ++ (he : e.trans (IntermediateField.equivOfEq h) = ++ (AlgEquiv.refl : B ≃ₐ[ℚ] B)) ++ (c : Additive (IdeleClassGroup B)) : ++ ((rationalIdeleClassEquivFixed A) ++ (MulEquiv.toAdditive (ideleClassCongr e) c)).1 = ++ ((rationalIdeleClassEquivFixed B) c).1 := by ++ cases h ++ have he' : e = AlgEquiv.refl := by ++ apply AlgEquiv.ext ++ intro x ++ have hx := DFunLike.congr_fun he x ++ change e x = x at hx ++ exact hx ++ rw [he'] ++ have hc : ++ MulEquiv.toAdditive ++ (ideleClassCongr (AlgEquiv.refl : A ≃ₐ[ℚ] A)) c = c := by ++ cases c with ++ | ofMul c => ++ exact congrArg Additive.ofMul (ideleClassCongr_refl c) ++ rw [hc] ++ ++/-- Transporting the target intermediate field of a base-field equivalence ++preserves its rational fixed-part representative. -/ ++theorem rationalIdeleClassEquivFixed_transport_baseEquiv_val ++ {T : Type} [Field T] [NumberField T] ++ {A B : IntermediateField ℚ (SeparableClosure ℚ)} ++ [FiniteDimensional ℚ A] [FiniteDimensional ℚ B] ++ (h : A = B) (e : T ≃ₐ[ℚ] B) ++ (c : IdeleClassGroup T) : ++ ((rationalIdeleClassEquivFixed A) ++ (Additive.ofMul ++ (ideleClassCongr (K := T) (M := A) ++ (e.trans (IntermediateField.equivOfEq h).symm) c))).1 = ++ ((rationalIdeleClassEquivFixed B) ++ (Additive.ofMul (ideleClassCongr (K := T) (M := B) e c))).1 := by ++ cases h ++ have he : ++ e.trans (IntermediateField.equivOfEq (rfl : A = A)).symm = e := by ++ ext x ++ rfl ++ rw [he] ++ ++/-- Equality of the lower and upper closed subgroups transports the raw ++extension quotient without exposing dependent rewrites to clients. -/ ++def extensionQuotientMulEquivOfEq ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {H H' J J' : ClosedSubgroup G} ++ (hH : H = H') (hJ : J = J') ++ (hJH : J.toSubgroup ≤ H.toSubgroup) ++ (hJH' : J'.toSubgroup ≤ H'.toSubgroup) ++ [(CyclicCohomology.extensionSubgroup H J hJH).Normal] ++ [(CyclicCohomology.extensionSubgroup H' J' hJH').Normal] : ++ (H.toSubgroup ⧸ CyclicCohomology.extensionSubgroup H J hJH) ≃* ++ (H'.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup H' J' hJH') := by ++ cases hH ++ cases hJ ++ exact MulEquiv.refl _ ++ ++/-- The quotient transport sends a quotient representative to the same ++ambient group element, rebundled in the equal lower subgroup. -/ ++@[simp] ++theorem extensionQuotientMulEquivOfEq_mk ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {H H' J J' : ClosedSubgroup G} ++ (hH : H = H') (hJ : J = J') ++ (hJH : J.toSubgroup ≤ H.toSubgroup) ++ (hJH' : J'.toSubgroup ≤ H'.toSubgroup) ++ [(CyclicCohomology.extensionSubgroup H J hJH).Normal] ++ [(CyclicCohomology.extensionSubgroup H' J' hJH').Normal] ++ (σ : H.toSubgroup) : ++ extensionQuotientMulEquivOfEq hH hJ hJH hJH' ++ (QuotientGroup.mk σ) = ++ QuotientGroup.mk ++ ((MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup hH)) σ) := by ++ cases hH ++ cases hJ ++ rfl ++ ++/-- Rebundling an element along equality of closed subgroups preserves its ++underlying ambient group element. -/ ++theorem closedSubgroupCongr_apply_val ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {H H' : ClosedSubgroup G} ++ (hH : H = H') (σ : H.toSubgroup) : ++ (((MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup hH)) σ).1 : G) = σ.1 := by ++ cases hH ++ rfl ++ ++/-- Rebase an abelianized extension-quotient equivalence together with its ++finite abstract base. -/ ++def abelianizedExtensionQuotientAddEquiv_transportBase ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {A B : FiniteAbstractField G} ++ (hAB : A = B) ++ (P : FiniteGaloisSubextension A.field) ++ {X : Type} [AddGroup X] ++ (e : Additive (Abelianization P.extensionQuotient) ≃+ X) : ++ Additive ++ (Abelianization ++ (Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField G => ++ FiniteGaloisSubextension Y.field) ++ hAB) ++ P).extensionQuotient) ≃+ X := by ++ cases hAB ++ exact e ++ ++/-- Rebase an abelianized equivalence along equality of finite Galois ++subextensions over a fixed abstract base. -/ ++def abelianizedExtensionQuotientAddEquiv_transportExtension ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {K : ClosedSubgroup G} ++ {P Q : FiniteGaloisSubextension K} ++ (hPQ : P = Q) ++ {X : Type} [AddGroup X] ++ (e : Additive (Abelianization P.extensionQuotient) ≃+ X) : ++ Additive (Abelianization Q.extensionQuotient) ≃+ X := by ++ cases hPQ ++ exact e ++ ++/-- The explicit quotient equivalence induced by rebasing a finite Galois ++subextension. -/ ++def extensionQuotientMulEquiv_transportFiniteGalois ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {A B : FiniteAbstractField G} ++ (hAB : A = B) ++ (P : FiniteGaloisSubextension A.field) ++ {Q : FiniteGaloisSubextension B.field} ++ (hPQ : ++ Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField G => ++ FiniteGaloisSubextension Y.field) ++ hAB) ++ P = Q) : ++ Q.extensionQuotient ≃* P.extensionQuotient := by ++ cases hAB ++ cases hPQ ++ exact MulEquiv.refl _ ++ ++/-- Quotient rebasing sends a canonical representative to the same ambient ++group element rebundled in the old base subgroup. -/ ++@[simp] ++theorem extensionQuotientMulEquiv_transportFiniteGalois_mk ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {A B : FiniteAbstractField G} ++ (hAB : A = B) ++ (P : FiniteGaloisSubextension A.field) ++ {Q : FiniteGaloisSubextension B.field} ++ (hPQ : ++ Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField G => ++ FiniteGaloisSubextension Y.field) ++ hAB) ++ P = Q) ++ (σ : B.field.toSubgroup) : ++ extensionQuotientMulEquiv_transportFiniteGalois hAB P hPQ ++ (Q.extensionQuotientMk σ) = ++ P.extensionQuotientMk ++ ((MulEquiv.subgroupCongr ++ (congrArg ClosedSubgroup.toSubgroup ++ (congrArg FiniteAbstractField.field hAB).symm)) σ) := by ++ cases hAB ++ cases hPQ ++ rfl ++ ++/-- Abelianization commutes with simultaneous transport of the abstract base ++and its finite Galois subextension. -/ ++theorem abelianizedCanonicalEquiv_transportFiniteGalois ++ {G : Type u} [Group G] [TopologicalSpace G] ++ {A B : FiniteAbstractField G} ++ (hAB : A = B) ++ (P : FiniteGaloisSubextension A.field) ++ {Q : FiniteGaloisSubextension B.field} ++ (hPQ : ++ Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField G => ++ FiniteGaloisSubextension Y.field) ++ hAB) ++ P = Q) ++ {X : Type} [CommGroup X] ++ (e : P.extensionQuotient ≃* X) : ++ abelianizedExtensionQuotientAddEquiv_transportExtension hPQ ++ (abelianizedExtensionQuotientAddEquiv_transportBase ++ hAB P ++ (MulEquiv.toAdditive ++ (e.abelianizationCongr.trans ++ (Abelianization.equivOfComm : X ≃* Abelianization X).symm))) = ++ MulEquiv.toAdditive ++ (((extensionQuotientMulEquiv_transportFiniteGalois ++ hAB P hPQ).trans e).abelianizationCongr.trans ++ (Abelianization.equivOfComm : X ≃* Abelianization X).symm) := by ++ cases hAB ++ cases hPQ ++ rfl ++ ++ ++/-- The finite norm-residue value, transported from the rational idele-class ++representation and the abelianized extension quotient to the groups `C` and `X`. -/ ++def rationalFiniteNormResidueValue ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ (L : FiniteGaloisSubextension K.field) ++ {C X : Type} [AddGroup C] [AddGroup X] ++ (eIdele : C ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation K.field) ++ (eGalois : Additive (Abelianization L.extensionQuotient) ≃+ X) ++ (c : C) : X := by ++ letI : ++ Finite ++ (K.field.toSubgroup ⧸ ++ CyclicCohomology.extensionSubgroup ++ K.field L.field L.below) := ++ L.finite ++ exact ++ eGalois ++ (rationalCyclotomicDegreeData.normResidueSymbol ++ rationalIdeleClassRepresentation ++ rationalCyclotomicIdeleClassValuationData ++ rationalIdeleClassRepresentation_satisfiesClassFieldAxiom ++ K L ++ (finiteNormClass rationalIdeleClassRepresentation ++ K.field L.field L.below (eIdele c))) ++ ++/-- The packaged norm-residue value is invariant under rebasing the finite ++abstract field together with all dependent data. -/ ++theorem rationalFiniteNormResidueValue_transportBase ++ {A B : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)} ++ (hAB : A = B) ++ (P : FiniteGaloisSubextension A.field) ++ {C X : Type} [AddGroup C] [AddGroup X] ++ (eIdele : C ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation A.field) ++ (eGalois : Additive (Abelianization P.extensionQuotient) ≃+ X) ++ (c : C) : ++ rationalFiniteNormResidueValue A P eIdele eGalois c = ++ rationalFiniteNormResidueValue B ++ (Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ FiniteGaloisSubextension Y.field) ++ hAB) ++ P) ++ (Eq.mp ++ (congrArg ++ (fun Y : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) => ++ C ≃+ ambientFixedAddSubgroup ++ rationalIdeleClassRepresentation Y.field) ++ hAB) ++ eIdele) ++ (abelianizedExtensionQuotientAddEquiv_transportBase ++ hAB P eGalois) ++ c := by ++ cases hAB ++ rfl ++ ++/-- The packaged norm-residue value is invariant under equality of the finite ++Galois subextension. -/ ++theorem rationalFiniteNormResidueValue_transportExtension ++ (K : FiniteAbstractField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ {P Q : FiniteGaloisSubextension K.field} ++ (hPQ : P = Q) ++ {C X : Type} [AddGroup C] [AddGroup X] ++ (eIdele : C ≃+ ++ ambientFixedAddSubgroup rationalIdeleClassRepresentation K.field) ++ (eGalois : Additive (Abelianization P.extensionQuotient) ≃+ X) ++ (c : C) : ++ rationalFiniteNormResidueValue K P eIdele eGalois c = ++ rationalFiniteNormResidueValue K Q eIdele ++ (abelianizedExtensionQuotientAddEquiv_transportExtension ++ hPQ eGalois) ++ c := by ++ cases hPQ ++ rfl ++ ++/-- Evaluation of the canonical abelianization comparison induced by a ++multiplicative equivalence into a commutative group. -/ ++theorem abelianizationCongrToComm_apply ++ {Q R : Type*} [Group Q] [CommGroup R] ++ (e : Q ≃* R) (q : Q) : ++ MulEquiv.toAdditive ++ (e.abelianizationCongr.trans ++ (Abelianization.equivOfComm : R ≃* Abelianization R).symm) ++ (Additive.ofMul (Abelianization.of q)) = ++ Additive.ofMul (e q) := by ++ apply Additive.toMul.injective ++ change ++ (Abelianization.equivOfComm : R ≃* Abelianization R).symm ++ (e.abelianizationCongr (Abelianization.of q)) = e q ++ rw [abelianizationCongr_of] ++ exact ++ (Abelianization.equivOfComm : R ≃* Abelianization R).symm_apply_apply _ ++ ++/-- Evaluation of the canonical quotient from the abelianization of a ++commutative group. -/ ++theorem commutativeAbelianizationEquiv_apply ++ {Q R : Type*} [CommGroup Q] [Group R] ++ (e : Q ≃* R) (q : Q) : ++ MulEquiv.toAdditive ++ ((Abelianization.equivOfComm : Q ≃* Abelianization Q).symm.trans e) ++ (Additive.ofMul (Abelianization.of q)) = ++ Additive.ofMul (e q) := by ++ apply Additive.toMul.injective ++ change ++ e ((Abelianization.equivOfComm : Q ≃* Abelianization Q).symm ++ (Abelianization.of q)) = e q ++ exact congrArg e ++ ((Abelianization.equivOfComm : Q ≃* Abelianization Q).symm_apply_apply q) ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitAbstractFixedField.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitAbstractFixedField.lean +index 08f2620..a101f78 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitAbstractFixedField.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitAbstractFixedField.lean +@@ -7,6 +7,7 @@ Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.IdeleClassDirectLimitFixedPoints + import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.AbstractFixedFieldNorm + ++ + set_option autoImplicit false + + /-! +@@ -202,7 +203,7 @@ theorem rationalIdeleClassEquivBaseFixed_coe + E (RelativeIdeleGroup.classInclusion ℚ E c)) + exact Eq.trans h0 (Eq.trans h1 (Eq.trans h2 (Eq.trans h3 h4))) + +-private noncomputable instance ++private noncomputable instance abstractFixedFieldNumberField + (K : ClosedSubgroup + (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) + [hfinite : Finite +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitCore.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitCore.lean +index 870927a..7f759bc 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitCore.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/IdeleClassDirectLimitCore.lean +@@ -9,6 +9,7 @@ import GaloisCohomology.Cyclic.NormKernelVanishing + import Mathlib.Algebra.Colimit.DirectLimit + import Mathlib.FieldTheory.Galois.Profinite + ++ + set_option autoImplicit false + + /-! +@@ -107,19 +108,19 @@ noncomputable instance rationalFiniteGaloisIdeleClassMulDistribMulAction + (RelativeIdeleGroup.ClassGroup ℚ E) := + rationalAbsoluteGaloisIdeleClassAction E + +-private instance ++private instance classGroupMonoid + (E : FiniteGaloisIntermediateField ℚ (SeparableClosure ℚ)) : + Monoid (RelativeIdeleGroup.ClassGroup ℚ E) := + inferInstance + +-private noncomputable instance : ++private noncomputable instance actionFamily : + ∀ E : FiniteGaloisIntermediateField ℚ (SeparableClosure ℚ), + MulDistribMulAction + (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) + (RelativeIdeleGroup.ClassGroup ℚ E) := + fun E => rationalAbsoluteGaloisIdeleClassAction E + +-private noncomputable instance : ++private noncomputable instance smulFamily : + ∀ E : FiniteGaloisIntermediateField ℚ (SeparableClosure ℚ), + SMul + (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ) +@@ -366,7 +367,7 @@ theorem rationalRelativeIdeleClassEmbedding_comp + (rationalRelativeAdeleEmbedding_comp hEF hFH + (a : RelativeAdeleRing ℚ E))) + +-private noncomputable instance : ++private noncomputable instance transitionDirectedSystem : + DirectedSystem + (fun E : FiniteGaloisIntermediateField ℚ (SeparableClosure ℚ) => + RelativeIdeleGroup.ClassGroup ℚ E) +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryField.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryField.lean +index c1e5ac0..1a80072 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryField.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryField.lean +@@ -1,1901 +1,2 @@ +-/- +-Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. +-Released under Apache 2.0 license as described in the file LICENSE. +-Authors: Naganori Yamaguchi (assisted by OpenAI Codex) +--/ +- +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicCyclicData +-import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicUnramifiedLocalGlobalCompatibility +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.Extension.OnePlaceBaseNorm +- +-set_option autoImplicit false +- +-/-! +-# The finite p-adic auxiliary field +- +-This module realizes the simultaneous finite/cyclotomic lift as an actual +-number field and proves the subgroup and intermediate-field identities +-needed by the auxiliary-field argument. +--/ +- +-open scoped IsMulCommutative NumberField +-open AlgebraicNumberTheory IsDedekindDomain NumberField +-open IdeleGroup RelativeIdeleGroup +-open AlgebraicNumberTheory.Valuations +-open HilbertRamification +-open CyclicCohomology +-open KummerTheory ClassFormation +- +-noncomputable section +- +-namespace GlobalClassFieldTheory +-namespace Reciprocity +- +-open GlobalClassFields +- +-variable +- {K L : Type} +- [Field K] [NumberField K] +- [Field L] [NumberField L] [Algebra K L] +- [FiniteDimensional K L] [IsAbelianGalois K L] +- +-local instance (p : Nat.Primes) : Fact p.1.Prime := +- ⟨p.2⟩ +- +-attribute [local instance] +- rationalSeparableClosureAlgebra +- +-local instance finitePadicAuxiliaryExtensionNormal : +- (extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L)).Normal := +- numberFieldTowerExtensionSubgroup_normal K L +- +-local instance finitePadicAuxiliaryExtensionQuotientFinite : +- Finite +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) := +- numberFieldTowerExtensionQuotient_finite K L +- +-noncomputable local instance finitePadicAuxiliaryExtensionQuotientIsMulCommutative : +- IsMulCommutative +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) := by +- let e : +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) ≃* +- Gal(L / K) := +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- exact +- { is_comm := +- ⟨fun x y => by +- apply e.injective +- rw [map_mul, map_mul] +- exact +- (inferInstance : +- IsMulCommutative (Gal(L / K))).is_comm.comm +- (e x) (e y)⟩ } +- +-/-- The concrete auxiliary fixed field attached to a simultaneous +-finite/cyclotomic lift. -/ +-noncomputable def numberFieldTowerFinitePadicCyclicFixedField +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- IntermediateField ℚ (SeparableClosure ℚ) := by +- exact +- IntermediateField.fixedField +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ).toSubgroup +- +-/-- A nonzero-degree lift produces a genuine number field: its +-concrete fixed field is finite over `ℚ`. -/ +-theorem numberFieldTowerFinitePadicCyclicFixedField_finiteDimensional +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hτ : +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ ≠ +- 1) : +- FiniteDimensional ℚ +- (numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ) := by +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let F := +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ +- apply +- (InfiniteGalois.isOpen_iff_finite +- (K := SeparableClosure ℚ) F).1 +- change IsOpen +- (IntermediateField.fixedField S.toSubgroup).fixingSubgroup.carrier +- rw [InfiniteGalois.fixingSubgroup_fixedField S] +- exact +- numberFieldTowerFinitePadicCyclicFixedSubgroup_isOpen +- (K := K) (L := L) p τ hτ +- +-/-- The compatible embedded copy of `K` lies in every auxiliary +-cyclic fixed field. -/ +-theorem numberFieldTowerBaseField_le_finitePadicCyclicFixedField +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- numberFieldTowerBaseField K L ≤ +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ := by +- intro x hx +- change x ∈ IntermediateField.fixedField +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ).toSubgroup +- rw [IntermediateField.mem_fixedField_iff] +- intro σ hσ +- change +- σ ∈ +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ).toSubgroup at hσ +- obtain ⟨u, hu, rfl⟩ := hσ +- exact +- (IntermediateField.mem_fixingSubgroup_iff +- (numberFieldTowerBaseField K L) u.1).1 u.2 x hx +- +-/-- The compatible embedding of the original base field into the +-genuine auxiliary fixed field. -/ +-noncomputable def numberFieldTowerFinitePadicAuxiliaryBaseEmbedding +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- K →ₐ[ℚ] +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ) := by +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ) +- exact +- (numberFieldTowerLowerEmbedding K L).codRestrict F.toSubalgebra +- (fun x => +- numberFieldTowerBaseField_le_finitePadicCyclicFixedField +- (K := K) (L := L) p τ ⟨x, rfl⟩) +- +-/-- Coercing the auxiliary base embedding recovers the fixed lower embedding +-into the rational separable closure. -/ +-@[simp] +-theorem numberFieldTowerFinitePadicAuxiliaryBaseEmbedding_coe +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (x : K) : +- ((numberFieldTowerFinitePadicAuxiliaryBaseEmbedding +- (K := K) (L := L) p τ x : +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ)) : +- SeparableClosure ℚ) = +- numberFieldTowerLowerEmbedding K L x := by +- rfl +- +-/-- The compatible copy of the original top field lies in the +-auxiliary compositum fixed field. -/ +-theorem numberFieldTowerTopField_mem_finitePadicAuxiliaryTopField +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- {x : SeparableClosure ℚ} +- (hx : x ∈ numberFieldInRationalSeparableClosure L) : +- x ∈ +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below := by +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let T := +- numberFieldTowerTopSubgroup L +- change x ∈ IntermediateField.fixedField +- (S.toSubgroup ⊓ T.toSubgroup) +- rw [IntermediateField.mem_fixedField_iff] +- intro σ hσ +- have hσT : σ ∈ T.toSubgroup := +- hσ.2 +- change +- σ ∈ +- (numberFieldInRationalSeparableClosure L).fixingSubgroup +- at hσT +- exact +- (IntermediateField.mem_fixingSubgroup_iff +- (numberFieldInRationalSeparableClosure L) σ).1 +- hσT x hx +- +-/-- The compatible embedding of the original top field into the +-auxiliary compositum fixed field. -/ +-noncomputable def numberFieldTowerFinitePadicAuxiliaryTopEmbedding +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- L →ₐ[ℚ] +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below := by +- let E := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below +- exact +- (numberFieldSeparableClosureEmbedding L).codRestrict +- (E.restrictScalars ℚ).toSubalgebra +- (fun x => +- numberFieldTowerTopField_mem_finitePadicAuxiliaryTopField +- (K := K) (L := L) p τ ⟨x, rfl⟩) +- +-/-- Coercing the auxiliary top embedding recovers the chosen top-field +-embedding into the rational separable closure. -/ +-@[simp] +-theorem numberFieldTowerFinitePadicAuxiliaryTopEmbedding_coe +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (x : L) : +- ((numberFieldTowerFinitePadicAuxiliaryTopEmbedding +- (K := K) (L := L) p τ x : +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) : +- SeparableClosure ℚ) = +- numberFieldSeparableClosureEmbedding L x := by +- rfl +- +-/-- The compatible base and top embeddings form the actual +-base-change square inside the rational separable closure. -/ +-theorem numberFieldTowerFinitePadicAuxiliaryEmbedding_algebraMap +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (x : K) : +- ((numberFieldTowerFinitePadicAuxiliaryTopEmbedding +- (K := K) (L := L) p τ (algebraMap K L x) : +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) : +- SeparableClosure ℚ) = +- ((numberFieldTowerFinitePadicAuxiliaryBaseEmbedding +- (K := K) (L := L) p τ x : +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ)) : +- SeparableClosure ℚ) := by +- rfl +- +-noncomputable instance +- numberFieldTowerFinitePadicAuxiliary_baseAlgebra +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- Algebra K +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ)) := by +- exact +- (numberFieldTowerFinitePadicAuxiliaryBaseEmbedding +- (K := K) (L := L) p τ).toRingHom.toAlgebra +- +-instance +- numberFieldTowerFinitePadicAuxiliary_baseRatScalarTower +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- IsScalarTower ℚ K +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ)) := by +- exact +- IsScalarTower.of_algebraMap_eq' +- (numberFieldTowerFinitePadicAuxiliaryBaseEmbedding +- (K := K) (L := L) p τ).comp_algebraMap.symm +- +-noncomputable instance +- numberFieldTowerFinitePadicAuxiliary_topAlgebra +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- Algebra L +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) := by +- exact +- (numberFieldTowerFinitePadicAuxiliaryTopEmbedding +- (K := K) (L := L) p τ).toRingHom.toAlgebra +- +-instance +- numberFieldTowerFinitePadicAuxiliary_topRatScalarTower +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- IsScalarTower ℚ L +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) := by +- exact +- IsScalarTower.of_algebraMap_eq' +- (numberFieldTowerFinitePadicAuxiliaryTopEmbedding +- (K := K) (L := L) p τ).comp_algebraMap.symm +- +-noncomputable instance +- numberFieldTowerFinitePadicAuxiliary_originalBaseTopAlgebra +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- Algebra K +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) := by +- exact +- ((numberFieldTowerFinitePadicAuxiliaryTopEmbedding +- (K := K) (L := L) p τ).comp +- (IsScalarTower.toAlgHom ℚ K L)).toRingHom.toAlgebra +- +-instance +- numberFieldTowerFinitePadicAuxiliary_originalTopScalarTower +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- IsScalarTower K L +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) := by +- exact IsScalarTower.of_algebraMap_eq' rfl +- +-instance +- numberFieldTowerFinitePadicAuxiliary_baseTopScalarTower +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- IsScalarTower K +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ)) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) := by +- apply IsScalarTower.of_algebraMap_eq' +- apply RingHom.ext +- intro x +- apply Subtype.ext +- exact +- numberFieldTowerFinitePadicAuxiliaryEmbedding_algebraMap +- (K := K) (L := L) p τ x +- +-/-- The genuine auxiliary fixed field is Galois over the original +-base field through the compatible embedding above. -/ +-theorem numberFieldTowerFinitePadicAuxiliaryBase_isGalois +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- IsGalois K +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ)) := by +- let H := +- numberFieldTowerBaseSubgroup K L +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let hSH := +- numberFieldTowerFinitePadicCyclicFixedSubgroup_le_baseSubgroup +- (K := K) (L := L) p τ +- let B := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) H +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let FB := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hSH +- let auxiliaryBaseAlgebra : Algebra B FB := +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) hSH).algebra +- let auxiliaryBaseGalois : IsGalois B FB := +- LocalClassFieldTheory.abstractRelativeFixedField_isGalois +- ℚ (SeparableClosure ℚ) H S hSH +- (numberFieldTowerFinitePadicCyclicFixedSubgroup_extension_normal +- (K := K) (L := L) p τ) +- let eK := +- numberFieldTowerAbstractBaseFieldEquiv K L +- refine +- @IsGalois.of_equiv_equiv +- B FB _ _ auxiliaryBaseAlgebra +- K F _ _ +- (numberFieldTowerFinitePadicAuxiliary_baseAlgebra +- (K := K) (L := L) p τ) +- auxiliaryBaseGalois +- eK.symm.toRingEquiv (RingEquiv.refl F) ?_ +- apply RingHom.ext +- intro x +- apply Subtype.ext +- change +- ((eK (eK.symm x) : B) : SeparableClosure ℚ) = +- (x : SeparableClosure ℚ) +- exact +- congrArg Subtype.val (eK.apply_symm_apply x) +- +-/-- The distinguished absolute lift, regarded as an element of the +-auxiliary base subgroup. -/ +-noncomputable def numberFieldTowerFinitePadicAuxiliarySubgroupLift +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ).toSubgroup := +- ⟨τ.1, +- numberFieldTowerFinitePadicCyclicFixedSubgroup_generator_mem +- (K := K) (L := L) p τ⟩ +- +-/-- The actual automorphism of the auxiliary compositum induced by +-the distinguished simultaneous finite/cyclotomic lift. -/ +-noncomputable def numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- let P := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- Gal( +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below / +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S) := by +- dsimp only +- let P := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let σS := +- numberFieldTowerFinitePadicAuxiliarySubgroupLift +- (K := K) (L := L) p τ +- exact +- LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup +- ℚ (SeparableClosure ℚ) +- S P.field P.below +- P.toFiniteGaloisExtension.normal +- (QuotientGroup.mk' +- (extensionSubgroup +- S P.field P.below) +- σS) +- +-/-- On the common separable closure, the auxiliary automorphism acts +-by the original distinguished ambient lift. -/ +-theorem numberFieldTowerFinitePadicAuxiliaryAutomorphism_apply_val +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (x : +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) : +- ((numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ x : +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) : +- SeparableClosure ℚ) = +- τ.1 (x : SeparableClosure ℚ) := by +- let P := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let σS := +- numberFieldTowerFinitePadicAuxiliarySubgroupLift +- (K := K) (L := L) p τ +- exact +- (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup_mk_apply_val +- ℚ (SeparableClosure ℚ) +- S P.field P.below +- P.toFiniteGaloisExtension.normal σS x).symm +- +-/-- Restricting the auxiliary automorphism through the actual +-base-change square recovers the finite quotient coordinate of the +-distinguished lift. -/ +-theorem numberFieldTowerFinitePadicAuxiliaryAutomorphism_restriction +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- ((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)) +- (numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ) = +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) := by +- let E := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below +- let σE := +- numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ +- apply AlgEquiv.ext +- intro x +- apply (numberFieldSeparableClosureEmbedding L).injective +- calc +- numberFieldSeparableClosureEmbedding L +- (((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)) σE x) = +- ((σE (algebraMap L E x) : E) : +- SeparableClosure ℚ) := by +- exact congrArg Subtype.val +- (AlgEquiv.restrictNormal_commutes +- ((AlgEquiv.restrictScalarsHom K) σE) L x) +- _ = τ.1 (numberFieldSeparableClosureEmbedding L x) := by +- rw [ +- numberFieldTowerFinitePadicAuxiliaryAutomorphism_apply_val +- (K := K) (L := L) p τ] +- rfl +- _ = +- numberFieldSeparableClosureEmbedding L +- (numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) x) := by +- exact +- (numberFieldTowerExtensionQuotientEquivGaloisGroup_mk_apply +- (K := K) (L := L) τ x).symm +- +-/-- Restriction of the chosen separable-closure place to the genuine +-auxiliary base field. This is an exact extension of the original +-finite place of `K`, not merely an equivalent valuation. -/ +-noncomputable def +- numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- AbsoluteValueExtension +- (NumberField.HeightOneSpectrum.adicAbv K v) +- (LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ)) := by +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ) +- let wΩ := +- numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v (chosenFinitePlaceExtension (L := L) v) +- refine +- ⟨wΩ.1.comp (f := F.val.toRingHom) F.val.injective, ?_⟩ +- intro x +- change +- wΩ.1 (numberFieldTowerLowerEmbedding K L x) = +- NumberField.HeightOneSpectrum.adicAbv K v x +- exact wΩ.2 x +- +-/-- Restriction of the same separable-closure place to the genuine +-auxiliary compositum. Its restriction to `K` agrees exactly with the +-original normalized finite absolute value. -/ +-noncomputable def +- numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- AbsoluteValueExtension +- (NumberField.HeightOneSpectrum.adicAbv K v) +- (LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) := by +- let E := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below +- let wΩ := +- numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v (chosenFinitePlaceExtension (L := L) v) +- refine +- ⟨wΩ.1.comp (f := E.val.toRingHom) E.val.injective, ?_⟩ +- intro x +- change +- wΩ.1 (numberFieldTowerLowerEmbedding K L x) = +- NumberField.HeightOneSpectrum.adicAbv K v x +- exact wΩ.2 x +- +-/-- The centre of the restricted place on the auxiliary compositum +-lies above the centre of the same place on the auxiliary base field. -/ +-theorem +- numberFieldTowerFinitePadicAuxiliaryTopPlace_below +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hτ : +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ ≠ +- 1) : +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let P := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let E := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- letI hHfinite : Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- S (le_baseField S)) := +- (numberFieldTowerFinitePadicAuxiliaryAbstractField +- (K := K) (L := L) p τ hτ).finite +- letI hPfinite : Finite +- (S.toSubgroup ⧸ +- extensionSubgroup S P.field P.below) := +- P.finite +- letI _ : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) S hHfinite +- letI _ : FiniteDimensional F E := +- LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- S P.field P.below hHfinite hPfinite +- letI _ : IsScalarTower ℚ F E := +- IsScalarTower.of_algebraMap_eq' rfl +- letI _ : FiniteDimensional ℚ E := +- FiniteDimensional.trans ℚ F E +- letI _ : NumberField F := +- NumberField.of_module_finite ℚ F +- letI _ : NumberField E := +- NumberField.of_module_finite ℚ E +- letI _ : Algebra K F := +- numberFieldTowerFinitePadicAuxiliary_baseAlgebra +- (K := K) (L := L) p τ +- finitePlaceBelow (K := F) +- (finitePlaceExtensionCentre +- (K := K) (L := E) v +- (numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ)) = +- finitePlaceExtensionCentre +- (K := K) (L := F) v +- (numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension +- (K := K) (L := L) v p τ) := by +- dsimp only +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let P := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let E := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let hHfinite : Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- S (le_baseField S)) := +- (numberFieldTowerFinitePadicAuxiliaryAbstractField +- (K := K) (L := L) p τ hτ).finite +- let hPfinite : Finite +- (S.toSubgroup ⧸ +- extensionSubgroup S P.field P.below) := +- P.finite +- let auxiliaryBaseFiniteDimensional : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) S hHfinite +- let auxiliaryTopFiniteDimensional : FiniteDimensional F E := +- LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- S P.field P.below hHfinite hPfinite +- let auxiliaryScalarTower : IsScalarTower ℚ F E := +- IsScalarTower.of_algebraMap_eq' rfl +- let auxiliaryAbsoluteFiniteDimensional : FiniteDimensional ℚ E := +- FiniteDimensional.trans ℚ F E +- let auxiliaryBaseNumberField : NumberField F := +- NumberField.of_module_finite ℚ F +- let auxiliaryTopNumberField : NumberField E := +- NumberField.of_module_finite ℚ E +- let auxiliaryOriginalBaseAlgebra : Algebra K F := +- numberFieldTowerFinitePadicAuxiliary_baseAlgebra +- (K := K) (L := L) p τ +- let wF := +- numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension +- (K := K) (L := L) v p τ +- let wE := +- numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ +- apply HeightOneSpectrum.ext +- ext x +- change +- algebraMap (𝓞 F) (𝓞 E) x ∈ +- finitePlaceExtensionCentreIdeal +- (K := K) (L := E) v wE ↔ +- x ∈ +- finitePlaceExtensionCentreIdeal +- (K := K) (L := F) v wF +- rw [ +- mem_finitePlaceExtensionCentreIdeal_iff, +- mem_finitePlaceExtensionCentreIdeal_iff] +- rfl +- +-/-- Evaluation of the distinguished auxiliary automorphism through the +-restricted top-field place. Isolating this coercion calculation prevents the +-whole decomposition-group proof from normalizing the fixed-field tower. -/ +-private opaque +- numberFieldTowerFinitePadicAuxiliaryTopPlace_automorphism_apply +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : +- let P := numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let E := LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let wE := numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ +- let σE := numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ +- ∀ x : E, +- wE.1 (σE x) = +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v (chosenFinitePlaceExtension (L := L) v)).1 +- (τ.1 (x : SeparableClosure ℚ)) := by +- let : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- dsimp only +- intro x +- change +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v (chosenFinitePlaceExtension (L := L) v)).1 +- ((numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ x : +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) +- (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ).below) : SeparableClosure ℚ) = _ +- rw [ +- numberFieldTowerFinitePadicAuxiliaryAutomorphism_apply_val +- (K := K) (L := L) p τ] +- +-/-- The distinguished auxiliary automorphism preserves the top-field place +-obtained by restricting the original separable-closure place. -/ +-private opaque numberFieldTowerFinitePadicAuxiliaryAutomorphism_mem_topPlaceDecomposition +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hdecomposition : +- letI : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ +- absoluteValueDecompositionGroup K +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v (chosenFinitePlaceExtension (L := L) v)).1) : +- let S := numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let F := LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let wE := numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ +- let σE := numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ +- σE ∈ absoluteValueDecompositionGroup F wE.1 := by +- let : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- dsimp only at hdecomposition ⊢ +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let wE := +- numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ +- let σE := +- numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ +- intro x +- change +- wE.1 (σE x) < 1 ↔ +- wE.1 x < 1 +- rw [ +- numberFieldTowerFinitePadicAuxiliaryTopPlace_automorphism_apply +- (K := K) (L := L) v p τ x, +- show +- wE.1 x = +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v +- (chosenFinitePlaceExtension (L := L) v)).1 +- (x : SeparableClosure ℚ) from rfl] +- exact hdecomposition (x : SeparableClosure ℚ) +- +-/-- The restricted top-field place and the chosen extension above its centre +-have the same decomposition group. -/ +-private opaque numberFieldTowerFinitePadicAuxiliaryTopDecompositionGroup_eq_chosen +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hτ : +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ ≠ 1) : +- let S := numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let P := numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let F := LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let E := LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- letI hHfinite : Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- S (le_baseField S)) := +- (numberFieldTowerFinitePadicAuxiliaryAbstractField +- (K := K) (L := L) p τ hτ).finite +- letI hPfinite : Finite +- (S.toSubgroup ⧸ extensionSubgroup S P.field P.below) := P.finite +- letI : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) S hHfinite +- letI : FiniteDimensional F E := +- LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) S P.field P.below hHfinite hPfinite +- letI : IsScalarTower ℚ F E := IsScalarTower.of_algebraMap_eq' rfl +- letI : FiniteDimensional ℚ E := FiniteDimensional.trans ℚ F E +- letI : NumberField F := NumberField.of_module_finite ℚ F +- letI : NumberField E := NumberField.of_module_finite ℚ E +- letI : IsAbelianGalois F E := +- GlobalClassFields.finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P +- letI : Algebra K F := +- numberFieldTowerFinitePadicAuxiliary_baseAlgebra +- (K := K) (L := L) p τ +- let wF := numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension +- (K := K) (L := L) v p τ +- let wE := numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ +- let V := finitePlaceExtensionCentre (K := K) (L := F) v wF +- absoluteValueDecompositionGroup F wE.1 = +- absoluteValueDecompositionGroup F +- (chosenFinitePlaceExtension (L := E) V).1 := by +- dsimp only +- let H := +- numberFieldTowerFinitePadicAuxiliaryAbstractField +- (K := K) (L := L) p τ hτ +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let P := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let E := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- let hHfinite : Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- S (le_baseField S)) := +- H.finite +- let hPfinite : Finite +- (S.toSubgroup ⧸ extensionSubgroup S P.field P.below) := +- P.finite +- let : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) S hHfinite +- let : FiniteDimensional F E := +- LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) S P.field P.below hHfinite hPfinite +- let : IsScalarTower ℚ F E := IsScalarTower.of_algebraMap_eq' rfl +- let : FiniteDimensional ℚ E := FiniteDimensional.trans ℚ F E +- let : NumberField F := NumberField.of_module_finite ℚ F +- let : NumberField E := NumberField.of_module_finite ℚ E +- let : IsAbelianGalois F E := +- GlobalClassFields.finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P +- let : Algebra K F := +- numberFieldTowerFinitePadicAuxiliary_baseAlgebra +- (K := K) (L := L) p τ +- let wF := +- numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension +- (K := K) (L := L) v p τ +- let wE := +- numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ +- let V := finitePlaceExtensionCentre (K := K) (L := F) v wF +- let W := finitePlaceExtensionCentre (K := K) (L := E) v wE +- let Wover : +- {W' : HeightOneSpectrum (𝓞 E) // +- finitePlaceBelow (K := F) W' = V} := +- ⟨W, +- numberFieldTowerFinitePadicAuxiliaryTopPlace_below +- (K := K) (L := L) v p τ hτ⟩ +- let wFE : +- AbsoluteValueExtension +- (NumberField.HeightOneSpectrum.adicAbv F V) E := +- (finitePlaceExtensionEquivAbove +- (K := F) (L := E) V).symm Wover +- have hwFEcentre : +- finitePlaceExtensionCentre +- (K := F) (L := E) V wFE = +- W := by +- exact +- congrArg Subtype.val +- ((finitePlaceExtensionEquivAbove +- (K := F) (L := E) V).apply_symm_apply Wover) +- have hwEquiv : wE.1.IsEquiv wFE.1 := by +- apply +- finitePlaceExtensions_isEquiv_of_centres_eq +- (F := K) (M := F) v V wE wFE +- exact hwFEcentre.symm +- calc +- absoluteValueDecompositionGroup F wE.1 = +- absoluteValueDecompositionGroup F wFE.1 := +- absoluteValueDecompositionGroup_eq_of_absoluteValue_isEquiv +- (F := F) wE.1 wFE.1 hwEquiv +- _ = +- absoluteValueDecompositionGroup F +- (chosenFinitePlaceExtension (L := E) V).1 := +- absoluteValueDecompositionGroup_eq_of_exactExtensions_of_isMulCommutative +- (F := F) +- (NumberField.HeightOneSpectrum.adicAbv F V) +- (RayClass.adicAbv_isNontrivial V) +- wFE +- (chosenFinitePlaceExtension (L := E) V) +- +-/-- Pointwise form of norm/restriction naturality. Keeping the function +-equality and its coercion normalization in this small declaration prevents +-the auxiliary-field witness construction below from repeatedly elaborating +-the full pair of composite homomorphisms. -/ +-private theorem globalNormResidueMonoidHomOfEmbedding_norm_restriction_apply +- (K K' L L' : Type) +- [Field K] [NumberField K] +- [Field K'] [NumberField K'] +- [Field L] [NumberField L] +- [Field L'] [NumberField L'] +- [Algebra K K'] [Algebra K L] [Algebra K L'] +- [Algebra K' L'] [Algebra L L'] +- [IsScalarTower K K' L'] [IsScalarTower K L L'] +- [FiniteDimensional K L] [IsAbelianGalois K L] +- [FiniteDimensional K' L'] [IsAbelianGalois K' L'] +- [FiniteDimensional K K'] [IsGalois K K'] +- (j : L' →ₐ[ℚ] SeparableClosure ℚ) +- (c : IdeleClassGroup K') : +- ((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)) +- (globalNormResidueMonoidHomOfEmbedding K' L' j c) = +- globalNormResidueMonoidHomOfEmbedding K L +- (j.comp (IsScalarTower.toAlgHom ℚ L L')) +- (_root_.ideleClassNorm K K' c) := by +- exact +- DFunLike.congr_fun +- (globalNormResidueMonoidHomOfEmbedding_norm_restriction +- (K := K) (L := L) (K' := K') (L' := L') j) c +- +- +- +-/-- The auxiliary-field construction produces a lower local unit +-whose chosen local Artin value and global norm-residue value are both +-the finite quotient coordinate of the distinguished lift. -/ +-opaque numberFieldTowerFinitePadicAuxiliaryLocalGlobalRepresentative +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hτ : +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ ≠ 1) +- (hdecomposition : +- letI : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ +- absoluteValueDecompositionGroup K +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v (chosenFinitePlaceExtension (L := L) v)).1) +- (n : ℕ) (hn : 0 < n) +- (hdegree : +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ = +- (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n) +- (hprimaryQuotient : +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ ∈ +- CommGroup.primaryComponent +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) +- p.1) : +- {z : (v.adicCompletion K)ˣ // +- chosenFinitePlaceArtinMonoidHom (K := K) (L := L) v z = +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) ∧ +- globalNormResidueMonoidHom K L +- (IdeleGroup.finitePlaceIdeleClass v z) = +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ)} := by +- let H := +- numberFieldTowerFinitePadicAuxiliaryAbstractField +- (K := K) (L := L) p τ hτ +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let P := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension +- (K := K) (L := L) p τ +- let F := +- LocalClassFieldTheory.abstractFixedField +- ℚ (SeparableClosure ℚ) S +- let E := +- LocalClassFieldTheory.abstractRelativeFixedField +- ℚ (SeparableClosure ℚ) P.below +- letI hHfinite : Finite +- ((baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ +- extensionSubgroup +- (baseField +- (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) +- S (le_baseField S)) := +- H.finite +- letI hPfinite : Finite +- (S.toSubgroup ⧸ extensionSubgroup S P.field P.below) := +- P.finite +- letI auxiliaryBaseNumberField : NumberField F := by +- let : FiniteDimensional ℚ F := +- LocalClassFieldTheory.abstractFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) S hHfinite +- exact NumberField.of_module_finite ℚ F +- letI auxiliaryTopNumberField : NumberField E := by +- let : FiniteDimensional F E := +- LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional +- ℚ (SeparableClosure ℚ) +- S P.field P.below hHfinite hPfinite +- exact NumberField.of_module_finite F E +- letI auxiliaryAbelianGalois : IsAbelianGalois F E := +- GlobalClassFields.finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P +- letI auxiliaryOriginalBaseAlgebra : Algebra K F := +- numberFieldTowerFinitePadicAuxiliary_baseAlgebra +- (K := K) (L := L) p τ +- letI auxiliaryOriginalTopAlgebra : Algebra L E := +- numberFieldTowerFinitePadicAuxiliary_topAlgebra +- (K := K) (L := L) p τ +- letI auxiliaryOriginalBaseTopAlgebra : Algebra K E := +- numberFieldTowerFinitePadicAuxiliary_originalBaseTopAlgebra +- (K := K) (L := L) p τ +- letI auxiliaryOriginalTopScalarTower : IsScalarTower K L E := +- numberFieldTowerFinitePadicAuxiliary_originalTopScalarTower +- (K := K) (L := L) p τ +- letI auxiliaryBaseTopScalarTower : IsScalarTower K F E := +- numberFieldTowerFinitePadicAuxiliary_baseTopScalarTower +- (K := K) (L := L) p τ +- letI auxiliaryOriginalBaseGalois : IsGalois K F := +- numberFieldTowerFinitePadicAuxiliaryBase_isGalois +- (K := K) (L := L) p τ +- let auxiliaryOriginalTopAlgHom : L →ₐ[ℚ] E := +- numberFieldTowerFinitePadicAuxiliaryTopEmbedding +- (K := K) (L := L) p τ +- let wF := +- numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension +- (K := K) (L := L) v p τ +- let wE := +- numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension +- (K := K) (L := L) v p τ +- let V := +- finitePlaceExtensionCentre +- (K := K) (L := F) v wF +- have hVbelow : finitePlaceBelow (K := K) V = v := +- finitePlaceBelow_finitePlaceExtensionCentre +- (K := K) (L := F) v wF +- let Vover : +- {V' : HeightOneSpectrum (𝓞 F) // +- finitePlaceBelow (K := K) V' = v} := +- ⟨V, hVbelow⟩ +- letI auxiliaryCompletionAlgebra : +- Algebra (v.adicCompletion K) (V.adicCompletion F) := +- (finitePlaceAdicCompletionMap K F v Vover).toAlgebra +- let σE : Gal(E / F) := +- numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ +- have hσtop : +- σE ∈ absoluteValueDecompositionGroup F wE.1 := +- numberFieldTowerFinitePadicAuxiliaryAutomorphism_mem_topPlaceDecomposition +- (K := K) (L := L) v p τ hdecomposition +- have hgroup := +- numberFieldTowerFinitePadicAuxiliaryTopDecompositionGroup_eq_chosen +- (K := K) (L := L) v p τ hτ +- have hσchosen : +- σE ∈ absoluteValueDecompositionGroup F +- (chosenFinitePlaceExtension (L := E) V).1 := by +- rw [← hgroup] +- exact hσtop +- have hRange : +- σE ∈ (chosenFinitePlaceArtinMonoidHom +- (K := F) (L := E) V).range := by +- rw [chosenFinitePlaceArtinMonoidHom_range (K := F) (L := E) V] +- exact hσchosen +- let y : (V.adicCompletion F)ˣ := Classical.choose hRange +- have hy : +- chosenFinitePlaceArtinMonoidHom (K := F) (L := E) V y = +- numberFieldTowerFinitePadicAuxiliaryAutomorphism +- (K := K) (L := L) p τ := +- Classical.choose_spec hRange +- let z : (v.adicCompletion K)ˣ := +- LocalFieldTheory.normUnits +- (v.adicCompletion K) (V.adicCompletion F) y +- have hz : +- z = LocalFieldTheory.normUnits +- (v.adicCompletion K) (V.adicCompletion F) y := by +- rfl +- let σK : Gal(L / K) := +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) +- let restriction : Gal(E / F) →* Gal(L / K) := +- (AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K) +- have hrestrict : restriction σE = σK := +- numberFieldTowerFinitePadicAuxiliaryAutomorphism_restriction +- (K := K) (L := L) p τ +- have hlocal : +- chosenFinitePlaceArtinMonoidHom (K := K) (L := L) v z = +- σK := by +- rw [hz] +- have hnat := +- DFunLike.congr_fun +- (chosenFinitePlaceArtinMonoidHom_norm_restriction_of_below_eq +- (K := K) (L := L) (K' := F) (L' := E) +- v V hVbelow) y +- calc +- chosenFinitePlaceArtinMonoidHom (K := K) (L := L) v +- (LocalFieldTheory.normUnits +- (v.adicCompletion K) (V.adicCompletion F) y) = +- restriction +- (chosenFinitePlaceArtinMonoidHom (K := F) (L := E) V y) := by +- simpa only [ +- MonoidHom.coe_comp, Function.comp_apply, restriction] +- using hnat.symm +- _ = restriction σE := congrArg restriction hy +- _ = σK := hrestrict +- let j : E →ₐ[ℚ] SeparableClosure ℚ := +- E.val.restrictScalars ℚ +- have hjLower : +- j.comp auxiliaryOriginalTopAlgHom = +- AlgebraicNumberTheory.numberFieldSeparableClosureEmbedding L := by +- apply AlgHom.ext +- intro a +- exact +- numberFieldTowerFinitePadicAuxiliaryTopEmbedding_coe +- (K := K) (L := L) p τ a +- have hPUnramified : +- P.toFiniteGaloisExtension.IsUnramified +- rationalCyclotomicDegreeData := +- numberFieldTowerFinitePadicAuxiliaryCompositumSubextension_isUnramified +- (K := K) (L := L) p τ n hn hdegree hprimaryQuotient +- have hcompat : +- (globalNormResidueMonoidHomOfEmbedding F E j).comp +- (IdeleGroup.finitePlaceIdeleClass V) = +- chosenFinitePlaceArtinMonoidHom (K := F) (L := E) V := +- globalNormResidueMonoidHomOfEmbedding_comp_finitePlaceIdeleClass_of_abstractFixedFieldUnramified +- H P hPUnramified V +- have hupper : +- globalNormResidueMonoidHomOfEmbedding F E j +- (IdeleGroup.finitePlaceIdeleClass V y) = +- σE := +- (congrArg +- (fun φ : (V.adicCompletion F)ˣ →* Gal(E / F) => φ y) +- hcompat).trans hy +- have hnormClass : +- _root_.ideleClassNorm K F +- (IdeleGroup.finitePlaceIdeleClass V y) = +- IdeleGroup.finitePlaceIdeleClass v z := by +- rw [hz] +- simpa only [Vover] using +- (IdeleGroup.ideleClassNorm_finitePlaceIdeleClass_eq_normUnits +- (K := K) (L := F) v Vover y) +- have hglobal : +- globalNormResidueMonoidHom K L +- (IdeleGroup.finitePlaceIdeleClass v z) = +- σK := by +- calc +- globalNormResidueMonoidHom K L +- (IdeleGroup.finitePlaceIdeleClass v z) = +- globalNormResidueMonoidHom K L +- (_root_.ideleClassNorm K F +- (IdeleGroup.finitePlaceIdeleClass V y)) := +- congrArg (globalNormResidueMonoidHom K L) hnormClass.symm +- _ = globalNormResidueMonoidHomOfEmbedding K L +- (j.comp auxiliaryOriginalTopAlgHom) +- (_root_.ideleClassNorm K F +- (IdeleGroup.finitePlaceIdeleClass V y)) := by +- rw [hjLower, +- ← globalNormResidueMonoidHom_eq_ofEmbedding_standard] +- _ = ((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)) +- (globalNormResidueMonoidHomOfEmbedding F E j +- (IdeleGroup.finitePlaceIdeleClass V y)) := by +- apply Eq.symm +- apply +- globalNormResidueMonoidHomOfEmbedding_norm_restriction_apply +- _ = ((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)) σE := +- congrArg +- ((AlgEquiv.restrictNormalHom L).comp +- (AlgEquiv.restrictScalarsHom K)) hupper +- _ = restriction σE := rfl +- _ = σK := hrestrict +- exact ⟨z, hlocal, hglobal⟩ +- +- +-/-- Every genuine finite-place decomposition automorphism has a +-compatible embedded absolute lift with the same finite quotient class +-and positive integral cyclotomic `p`-adic degree. -/ +-theorem exists_numberFieldTowerFinitePadicLift_of_finitePlace +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (σ : +- absoluteValueDecompositionGroup K +- (chosenFinitePlaceExtension (L := L) v).1) : +- letI _ : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- letI _ : Algebra L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureTopAlgebra L +- letI _ : IsScalarTower K L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureScalarTower K L +- ∃ τ : (numberFieldTowerBaseSubgroup K L).toSubgroup, +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) = +- σ.1 ∧ +- (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ +- absoluteValueDecompositionGroup K +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v +- (chosenFinitePlaceExtension (L := L) v)).1 ∧ +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ ≠ +- 1 ∧ +- ∃ n : ℕ, 0 < n ∧ +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ = +- (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by +- let : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- let : Algebra L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureTopAlgebra L +- let : IsScalarTower K L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureScalarTower K L +- obtain ⟨τΩ, hτΩrestrict, n, hn, hτΩdegree⟩ := +- exists_finitePlaceSeparableClosureLift_with_positivePadicCyclotomicDegree +- (K := K) (L := L) v p σ +- let τ : +- (numberFieldTowerBaseSubgroup K L).toSubgroup := +- numberFieldTowerSeparableClosureEquivBaseSubgroup +- K L τΩ.1 +- have hfinite : +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) = +- σ.1 := by +- change +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (QuotientGroup.mk +- (numberFieldTowerSeparableClosureEquivBaseSubgroup +- K L τΩ.1)) = +- σ.1 +- rw [ +- numberFieldTowerExtensionQuotientEquivGaloisGroup_mk_baseSubgroupEquiv] +- exact congrArg Subtype.val hτΩrestrict +- have hdegree : +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ = +- (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by +- exact hτΩdegree +- have hdecomposition : +- (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ +- absoluteValueDecompositionGroup K +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v +- (chosenFinitePlaceExtension (L := L) v)).1 := by +- simpa only [τ, MulEquiv.symm_apply_apply] using τΩ.2 +- refine +- ⟨τ, hfinite, hdecomposition, ?_, n, hn, hdegree⟩ +- rw [hdegree] +- exact +- PadicInt.multiplicative_positiveNatDegree_ne_one +- p.1 n hn +- +-/-- Generation of the actual finite Galois group transports back +-through the compatible finite quotient coordinate. -/ +-theorem +- numberFieldTowerFiniteQuotientCoordinate_generates_of_galoisGenerator +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (σ : Gal(L / K)) +- (hτσ : +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) = +- σ) +- (hσ : Subgroup.closure ({σ} : Set (Gal(L / K))) = ⊤) : +- Subgroup.closure +- ({numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ} : +- Set +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = +- ⊤ := by +- let e := +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- let q : +- (numberFieldTowerFiniteGaloisSubextension +- K L).extensionQuotient := +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ +- have hq : e.toMonoidHom q = σ := by +- exact hτσ +- change +- Subgroup.closure +- ({q} : +- Set +- (numberFieldTowerFiniteGaloisSubextension +- K L).extensionQuotient) = +- ⊤ +- apply Subgroup.map_injective (f := e.toMonoidHom) e.injective +- rw [MonoidHom.map_closure, Set.image_singleton, +- hq, hσ, +- Subgroup.map_top_of_surjective e.toMonoidHom e.surjective] +- +-/-- If the finite quotient coordinate of a lift generates the whole +-finite Galois quotient, then its cyclic preimage together with the +-top-field subgroup generates the whole embedded absolute Galois +-group. -/ +-theorem +- numberFieldTowerFinitePadicCyclicPreimage_sup_extensionSubgroup_eq_top +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hgenerate : +- Subgroup.closure +- ({numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ} : +- Set +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = +- ⊤) : +- (numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ⊔ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L) = +- ⊤ := by +- let H := +- numberFieldTowerBaseSubgroup K L +- let N := +- extensionSubgroup +- H +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L) +- let Q := H.toSubgroup ⧸ N +- let P := +- numberFieldTowerFinitePadicImage +- (K := K) (L := L) p +- let coordinate := +- numberFieldTowerFinitePadicCoordinate +- (K := K) (L := L) p +- let rangeRestriction := +- numberFieldTowerFinitePadicRangeRestriction +- (K := K) (L := L) p +- let γ : P.toSubgroup := +- rangeRestriction τ +- let Γ := +- ClassFormation.padicCyclicClosure γ +- let finiteProjection : +- P.toSubgroup →* +- Q := +- (MonoidHom.fst Q +- (Multiplicative ℤ_[p.1])).comp +- P.toSubgroup.subtype +- have hprojection : +- Γ.toSubgroup.map finiteProjection = ⊤ := by +- apply top_unique +- rw [← hgenerate] +- apply (Subgroup.closure_le _).2 +- intro q hq +- rw [Set.mem_singleton_iff] at hq +- subst q +- refine +- ⟨γ, +- (ClassFormation.padicCyclicClosureGenerator γ).2, +- ?_⟩ +- rfl +- have hquotientSurjective : +- ∀ q : Q, +- ∃ u : H.toSubgroup, +- u ∈ +- (numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ∧ +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) u = +- q := by +- intro q +- have hq : +- q ∈ Γ.toSubgroup.map finiteProjection := by +- rw [hprojection] +- trivial +- obtain ⟨z, hzΓ, hzq⟩ := hq +- obtain ⟨u, hu⟩ := +- numberFieldTowerFinitePadicRangeRestriction_surjective +- (K := K) (L := L) p z +- refine ⟨u, ?_, ?_⟩ +- · change rangeRestriction u ∈ Γ.toSubgroup +- rw [hu] +- exact hzΓ +- · calc +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) u = +- finiteProjection (rangeRestriction u) := rfl +- _ = finiteProjection z := congrArg finiteProjection hu +- _ = q := hzq +- apply top_unique +- intro h _ +- obtain ⟨u, huU, huq⟩ := +- hquotientSurjective +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) h) +- let k : H.toSubgroup := +- h * u⁻¹ +- have hkN : k ∈ N := by +- apply (QuotientGroup.eq_one_iff (N := N) k).mp +- change +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) (h * u⁻¹) = +- 1 +- rw [map_mul, map_inv, huq, mul_inv_cancel] +- have hkSup : +- k ∈ +- (numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ⊔ +- N := +- (le_sup_right : +- N ≤ +- (numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ⊔ N) hkN +- have huSup : +- u ∈ +- (numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ⊔ +- N := +- (le_sup_left : +- (numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ≤ +- (numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ⊔ N) huU +- have hku : +- k * u = h := by +- simp only [k, inv_mul_cancel_right] +- rw [← hku] +- exact +- ((numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ).toSubgroup ⊔ N).mul_mem +- hkSup huSup +- +-/-- Ambient form of the generation statement: the auxiliary cyclic +-fixed subgroup together with the subgroup fixing `L` generates the +-subgroup fixing `K`. -/ +-theorem +- numberFieldTowerFinitePadicCyclicFixedSubgroup_sup_topSubgroup +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hgenerate : +- Subgroup.closure +- ({numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ} : +- Set +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = +- ⊤) : +- (numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ).toSubgroup ⊔ +- (numberFieldTowerTopSubgroup L).toSubgroup = +- (numberFieldTowerBaseSubgroup K L).toSubgroup := by +- let H := +- numberFieldTowerBaseSubgroup K L +- let T := +- numberFieldTowerTopSubgroup L +- let N := +- extensionSubgroup +- H T +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L) +- let U := +- numberFieldTowerFinitePadicCyclicPreimage +- (K := K) (L := L) p τ +- have hrelative : +- U.toSubgroup ⊔ N = ⊤ := +- numberFieldTowerFinitePadicCyclicPreimage_sup_extensionSubgroup_eq_top +- (K := K) (L := L) p τ hgenerate +- have hNmap : +- N.map H.toSubgroup.subtype = +- T.toSubgroup := by +- exact +- Subgroup.map_subgroupOf_eq_of_le +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L) +- change +- U.toSubgroup.map H.toSubgroup.subtype ⊔ +- T.toSubgroup = +- H.toSubgroup +- rw [← hNmap, ← Subgroup.map_sup, +- hrelative, ← MonoidHom.range_eq_map, +- H.toSubgroup.range_subtype] +- +-/-- The concrete auxiliary fixed field is linearly disjoint from `L` +-over the compatible embedded copy of `K`. -/ +-theorem +- numberFieldTowerFinitePadicCyclicFixedField_inf_topField +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (hgenerate : +- Subgroup.closure +- ({numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ} : +- Set +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = +- ⊤) : +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ ⊓ +- numberFieldInRationalSeparableClosure L = +- numberFieldTowerBaseField K L := by +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let T := +- numberFieldTowerTopSubgroup L +- let H := +- numberFieldTowerBaseSubgroup K L +- change +- IntermediateField.fixedField S.toSubgroup ⊓ +- numberFieldInRationalSeparableClosure L = +- numberFieldTowerBaseField K L +- rw [ +- ← InfiniteGalois.fixedField_fixingSubgroup +- (numberFieldInRationalSeparableClosure L), +- ← InfiniteGalois.fixedField_fixingSubgroup +- (numberFieldTowerBaseField K L)] +- change +- IntermediateField.fixedField S.toSubgroup ⊓ +- IntermediateField.fixedField T.toSubgroup = +- IntermediateField.fixedField H.toSubgroup +- rw [ +- ← IntermediateField.fixedField_sup_eq_inf, +- numberFieldTowerFinitePadicCyclicFixedSubgroup_sup_topSubgroup +- (K := K) (L := L) p τ hgenerate] +- +-/-- If the finite quotient coordinate is `p`-primary, adjoining the +-actual rational `p`-primary cyclotomic field to the auxiliary fixed +-field contains the compatible copy of `L`. +- +-This is the field-theoretic conclusion of the simultaneous +-finite/cyclotomic lift: the intersection of the two fixing subgroups +-already fixes `L`, hence their fixed-field compositum contains `L`. -/ +-theorem +- numberFieldTowerTopField_le_finitePadicCyclicFixedField_sup_padicCyclotomicField +- (p : Nat.Primes) +- (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) +- (n : ℕ) (hn : 0 < n) +- (hdegree : +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ = +- (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n) +- (hprimary : +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ ∈ +- CommGroup.primaryComponent +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) +- p.1) : +- numberFieldInRationalSeparableClosure L ≤ +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ ⊔ +- rationalCyclotomicPadicField p := by +- let S := +- numberFieldTowerFinitePadicCyclicFixedSubgroup +- (K := K) (L := L) p τ +- let T := +- numberFieldTowerTopSubgroup L +- let F := +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ +- let C : @IntermediateField ℚ (SeparableClosure ℚ) _ _ +- rationalSeparableClosureAlgebra := +- rationalCyclotomicPadicField p +- have hfixing : +- (F ⊔ C).fixingSubgroup ≤ +- T.toSubgroup := by +- change +- (IntermediateField.fixedField S.toSubgroup ⊔ C).fixingSubgroup ≤ +- T.toSubgroup +- rw [ +- IntermediateField.fixingSubgroup_sup, +- InfiniteGalois.fixingSubgroup_fixedField S] +- intro σ hσ +- apply +- numberFieldTowerFinitePadicCyclicFixedSubgroup_inf_absolutePadicKernel_le_topSubgroup +- (K := K) (L := L) p τ n hn hdegree hprimary +- refine ⟨hσ.1, ?_⟩ +- let : Algebra ℚ rationalCyclotomicZHatField := +- rationalCyclotomicZHatField.algebra' +- let : @Normal ℚ rationalCyclotomicZHatField _ _ +- rationalCyclotomicZHatField.algebra' := +- rationalCyclotomicZHatField_normal +- let E := +- rationalCyclotomicPadicFieldWithinZHat p +- change +- rationalCyclotomicPadicCoordinate p +- (rationalAbsoluteGaloisRestrictionToCyclotomicZHat σ) = +- 1 +- have hr : +- rationalAbsoluteGaloisRestrictionToCyclotomicZHat σ ∈ +- E.fixingSubgroup := by +- rw [IntermediateField.mem_fixingSubgroup_iff] +- intro x hx +- apply Subtype.ext +- have hfix : +- σ x.1 = x.1 := +- (IntermediateField.mem_fixingSubgroup_iff +- (IntermediateField.lift E) σ).1 hσ.2 x.1 +- ((IntermediateField.mem_lift x).2 hx) +- exact +- (AlgEquiv.restrictNormal_commutes +- σ rationalCyclotomicZHatField x).trans hfix +- rw [rationalCyclotomicPadicFieldWithinZHat_fixingSubgroup] +- at hr +- exact hr +- rw [ +- ← InfiniteGalois.fixedField_fixingSubgroup +- (numberFieldInRationalSeparableClosure L)] +- change +- IntermediateField.fixedField T.toSubgroup ≤ +- F ⊔ C +- rw [ +- ← InfiniteGalois.fixedField_fixingSubgroup +- (F ⊔ C)] +- exact +- IntermediateField.fixedField_le hfixing +- +-/-- For a finite-place automorphism generating `Gal(L/K)`, construct +-the genuine auxiliary number field used in the cyclotomic reduction. +- +-The field is finite over `ℚ`, contains the compatible copy of `K`, and +-has intersection with the compatible copy of `L` exactly equal to that +-copy of `K`. Its defining lift has the prescribed local restriction +-and positive integral cyclotomic `p`-adic degree. -/ +-theorem exists_finitePlaceCyclotomicAuxiliaryFixedField +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (σ : +- absoluteValueDecompositionGroup K +- (chosenFinitePlaceExtension (L := L) v).1) +- (hσ : +- Subgroup.closure +- ({σ.1} : Set (Gal(L / K))) = +- ⊤) : +- letI _ : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- letI _ : Algebra L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureTopAlgebra L +- letI _ : IsScalarTower K L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureScalarTower K L +- ∃ τ : (numberFieldTowerBaseSubgroup K L).toSubgroup, +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) = +- σ.1 ∧ +- (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ +- absoluteValueDecompositionGroup K +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v +- (chosenFinitePlaceExtension (L := L) v)).1 ∧ +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ ≠ +- 1 ∧ +- FiniteDimensional ℚ +- (numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ) ∧ +- numberFieldTowerBaseField K L ≤ +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ ∧ +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ ⊓ +- numberFieldInRationalSeparableClosure L = +- numberFieldTowerBaseField K L ∧ +- ∃ n : ℕ, 0 < n ∧ +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ = +- (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by +- let : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- let : Algebra L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureTopAlgebra L +- let : IsScalarTower K L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureScalarTower K L +- obtain +- ⟨τ, hτσ, hτdecomposition, hτdegree, +- n, hn, hdegree⟩ := +- exists_numberFieldTowerFinitePadicLift_of_finitePlace +- (K := K) (L := L) v p σ +- have hgenerate := +- numberFieldTowerFiniteQuotientCoordinate_generates_of_galoisGenerator +- (K := K) (L := L) τ σ.1 hτσ hσ +- refine +- ⟨τ, hτσ, hτdecomposition, hτdegree, +- numberFieldTowerFinitePadicCyclicFixedField_finiteDimensional +- (K := K) (L := L) p τ hτdegree, +- numberFieldTowerBaseField_le_finitePadicCyclicFixedField +- (K := K) (L := L) p τ, +- numberFieldTowerFinitePadicCyclicFixedField_inf_topField +- (K := K) (L := L) p τ hgenerate, +- n, hn, hdegree⟩ +- +-/-- A `p`-primary local generator admits a genuine auxiliary number +-field whose compositum with the rational `p`-primary cyclotomic field +-contains `L`. +- +-Besides the field containment, the construction records the two +-properties needed for descent: the auxiliary field meets `L` exactly +-in `K`, and the chosen absolute lift has positive integral +-cyclotomic degree. -/ +-theorem exists_finitePlacePrimaryCyclotomicAuxiliaryFixedField +- (v : HeightOneSpectrum (𝓞 K)) +- (p : Nat.Primes) +- (σ : +- absoluteValueDecompositionGroup K +- (chosenFinitePlaceExtension (L := L) v).1) +- (hgenerate : +- Subgroup.closure +- ({σ.1} : Set (Gal(L / K))) = +- ⊤) +- (hprimary : +- σ.1 ∈ +- CommGroup.primaryComponent +- (Gal(L / K)) p.1) : +- letI _ : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- letI _ : Algebra L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureTopAlgebra L +- letI _ : IsScalarTower K L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureScalarTower K L +- ∃ τ : (numberFieldTowerBaseSubgroup K L).toSubgroup, +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- (numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ) = +- σ.1 ∧ +- (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ +- absoluteValueDecompositionGroup K +- (numberFieldTowerFinitePlaceExtensionToSeparableClosure +- K L v +- (chosenFinitePlaceExtension (L := L) v)).1 ∧ +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ ≠ +- 1 ∧ +- FiniteDimensional ℚ +- (numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ) ∧ +- numberFieldTowerBaseField K L ≤ +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ ∧ +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ ⊓ +- numberFieldInRationalSeparableClosure L = +- numberFieldTowerBaseField K L ∧ +- numberFieldInRationalSeparableClosure L ≤ +- numberFieldTowerFinitePadicCyclicFixedField +- (K := K) (L := L) p τ ⊔ +- rationalCyclotomicPadicField p ∧ +- ∃ n : ℕ, 0 < n ∧ +- numberFieldTowerBaseSubgroupPadicCyclotomicDegree +- (K := K) (L := L) p τ = +- (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by +- let : Algebra K (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureBaseAlgebra K L +- let : Algebra L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureTopAlgebra L +- let : IsScalarTower K L (SeparableClosure ℚ) := +- numberFieldTowerSeparableClosureScalarTower K L +- obtain +- ⟨τ, hτσ, hτdecomposition, hτdegree, +- hfinite, hbase, hintersection, +- n, hn, hdegree⟩ := +- exists_finitePlaceCyclotomicAuxiliaryFixedField +- (K := K) (L := L) v p σ hgenerate +- have hprimaryQuotient : +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ ∈ +- CommGroup.primaryComponent +- ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ +- extensionSubgroup +- (numberFieldTowerBaseSubgroup K L) +- (numberFieldTowerTopSubgroup L) +- (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) +- p.1 := by +- obtain ⟨m, hm⟩ := hprimary +- refine ⟨m, ?_⟩ +- let e := +- numberFieldTowerExtensionQuotientEquivGaloisGroup K L +- let q := +- numberFieldTowerFiniteQuotientCoordinate +- (K := K) (L := L) τ +- let N : ℕ := p.1 ^ m +- have hq : e q = σ.1 := by +- exact hτσ +- have hmN : σ.1 ^ N = 1 := by +- exact hm +- change q ^ N = 1 +- apply e.injective +- calc +- e (q ^ N) = (e q) ^ N := by +- exact map_pow e q N +- _ = σ.1 ^ N := by rw [hq] +- _ = 1 := hmN +- _ = e 1 := (map_one e).symm +- have hcontainment := +- numberFieldTowerTopField_le_finitePadicCyclicFixedField_sup_padicCyclotomicField +- (K := K) (L := L) p τ n hn hdegree +- hprimaryQuotient +- exact +- ⟨τ, hτσ, hτdecomposition, hτdegree, +- hfinite, hbase, hintersection, +- hcontainment, n, hn, hdegree⟩ +- +-end Reciprocity +-end GlobalClassFieldTheory ++/- Declaration-preserving split of the original source. See the immutable source-split receipt. -/ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicAuxiliaryFieldExistence +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldAutomorphisms.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldAutomorphisms.lean +new file mode 100644 +index 0000000..05e27fe +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldAutomorphisms.lean +@@ -0,0 +1,593 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicAuxiliaryFieldBase ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicCyclicData ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicUnramifiedLocalGlobalCompatibility ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.Extension.OnePlaceBaseNorm ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open AlgebraicNumberTheory IsDedekindDomain NumberField ++open IdeleGroup RelativeIdeleGroup ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open CyclicCohomology ++open KummerTheory ClassFormation ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open GlobalClassFields ++ ++variable ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ ++ ++local instance splitFactPrimeAutomorphisms (p : Nat.Primes) : Fact p.1.Prime := ⟨p.2⟩ ++ ++attribute [local instance] ++ rationalSeparableClosureAlgebra ++ finitePadicAuxiliaryExtensionNormal ++ finitePadicAuxiliaryExtensionQuotientFinite ++ finitePadicAuxiliaryExtensionQuotientIsMulCommutative ++ ++/-- The distinguished absolute lift, regarded as an element of the ++auxiliary base subgroup. -/ ++noncomputable def numberFieldTowerFinitePadicAuxiliarySubgroupLift ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ).toSubgroup := ++ ⟨τ.1, ++ numberFieldTowerFinitePadicCyclicFixedSubgroup_generator_mem ++ (K := K) (L := L) p τ⟩ ++ ++/-- The actual automorphism of the auxiliary compositum induced by ++the distinguished simultaneous finite/cyclotomic lift. -/ ++noncomputable def numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ let P := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ Gal( ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below / ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S) := by ++ dsimp only ++ let P := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let σS := ++ numberFieldTowerFinitePadicAuxiliarySubgroupLift ++ (K := K) (L := L) p τ ++ exact ++ LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup ++ ℚ (SeparableClosure ℚ) ++ S P.field P.below ++ P.toFiniteGaloisExtension.normal ++ (QuotientGroup.mk' ++ (extensionSubgroup ++ S P.field P.below) ++ σS) ++ ++/-- On the common separable closure, the auxiliary automorphism acts ++by the original distinguished ambient lift. -/ ++theorem numberFieldTowerFinitePadicAuxiliaryAutomorphism_apply_val ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (x : ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) : ++ ((numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ x : ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) : ++ SeparableClosure ℚ) = ++ τ.1 (x : SeparableClosure ℚ) := by ++ let P := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let σS := ++ numberFieldTowerFinitePadicAuxiliarySubgroupLift ++ (K := K) (L := L) p τ ++ exact ++ (LocalClassFieldTheory.abstractExtensionQuotientEquivGaloisGroup_mk_apply_val ++ ℚ (SeparableClosure ℚ) ++ S P.field P.below ++ P.toFiniteGaloisExtension.normal σS x).symm ++ ++/-- Restricting the auxiliary automorphism through the actual ++base-change square recovers the finite quotient coordinate of the ++distinguished lift. -/ ++theorem numberFieldTowerFinitePadicAuxiliaryAutomorphism_restriction ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ ((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)) ++ (numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ) = ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) := by ++ let E := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below ++ let σE := ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ ++ apply AlgEquiv.ext ++ intro x ++ apply (numberFieldSeparableClosureEmbedding L).injective ++ calc ++ numberFieldSeparableClosureEmbedding L ++ (((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)) σE x) = ++ ((σE (algebraMap L E x) : E) : ++ SeparableClosure ℚ) := by ++ exact congrArg Subtype.val ++ (AlgEquiv.restrictNormal_commutes ++ ((AlgEquiv.restrictScalarsHom K) σE) L x) ++ _ = τ.1 (numberFieldSeparableClosureEmbedding L x) := by ++ rw [ ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism_apply_val ++ (K := K) (L := L) p τ] ++ rfl ++ _ = ++ numberFieldSeparableClosureEmbedding L ++ (numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) x) := by ++ exact ++ (numberFieldTowerExtensionQuotientEquivGaloisGroup_mk_apply ++ (K := K) (L := L) τ x).symm ++ ++/-- Restriction of the chosen separable-closure place to the genuine ++auxiliary base field. This is an exact extension of the original ++finite place of `K`, not merely an equivalent valuation. -/ ++noncomputable def ++ numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ AbsoluteValueExtension ++ (NumberField.HeightOneSpectrum.adicAbv K v) ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ)) := by ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ) ++ let wΩ := ++ numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v (chosenFinitePlaceExtension (L := L) v) ++ refine ++ ⟨wΩ.1.comp (f := F.val.toRingHom) F.val.injective, ?_⟩ ++ intro x ++ change ++ wΩ.1 (numberFieldTowerLowerEmbedding K L x) = ++ NumberField.HeightOneSpectrum.adicAbv K v x ++ exact wΩ.2 x ++ ++/-- Restriction of the same separable-closure place to the genuine ++auxiliary compositum. Its restriction to `K` agrees exactly with the ++original normalized finite absolute value. -/ ++noncomputable def ++ numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ AbsoluteValueExtension ++ (NumberField.HeightOneSpectrum.adicAbv K v) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) := by ++ let E := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below ++ let wΩ := ++ numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v (chosenFinitePlaceExtension (L := L) v) ++ refine ++ ⟨wΩ.1.comp (f := E.val.toRingHom) E.val.injective, ?_⟩ ++ intro x ++ change ++ wΩ.1 (numberFieldTowerLowerEmbedding K L x) = ++ NumberField.HeightOneSpectrum.adicAbv K v x ++ exact wΩ.2 x ++ ++/-- The centre of the restricted place on the auxiliary compositum ++lies above the centre of the same place on the auxiliary base field. -/ ++theorem ++ numberFieldTowerFinitePadicAuxiliaryTopPlace_below ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hτ : ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ ≠ ++ 1) : ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let P := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let E := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ letI hHfinite : Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ S (le_baseField S)) := ++ (numberFieldTowerFinitePadicAuxiliaryAbstractField ++ (K := K) (L := L) p τ hτ).finite ++ letI hPfinite : Finite ++ (S.toSubgroup ⧸ ++ extensionSubgroup S P.field P.below) := ++ P.finite ++ letI _ : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) S hHfinite ++ letI _ : FiniteDimensional F E := ++ LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ S P.field P.below hHfinite hPfinite ++ letI _ : IsScalarTower ℚ F E := ++ IsScalarTower.of_algebraMap_eq' rfl ++ letI _ : FiniteDimensional ℚ E := ++ FiniteDimensional.trans ℚ F E ++ letI _ : NumberField F := ++ NumberField.of_module_finite ℚ F ++ letI _ : NumberField E := ++ NumberField.of_module_finite ℚ E ++ letI _ : Algebra K F := ++ numberFieldTowerFinitePadicAuxiliary_baseAlgebra ++ (K := K) (L := L) p τ ++ finitePlaceBelow (K := F) ++ (finitePlaceExtensionCentre ++ (K := K) (L := E) v ++ (numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ)) = ++ finitePlaceExtensionCentre ++ (K := K) (L := F) v ++ (numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension ++ (K := K) (L := L) v p τ) := by ++ dsimp only ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let P := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let E := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let hHfinite : Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ S (le_baseField S)) := ++ (numberFieldTowerFinitePadicAuxiliaryAbstractField ++ (K := K) (L := L) p τ hτ).finite ++ let hPfinite : Finite ++ (S.toSubgroup ⧸ ++ extensionSubgroup S P.field P.below) := ++ P.finite ++ let auxiliaryBaseFiniteDimensional : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) S hHfinite ++ let auxiliaryTopFiniteDimensional : FiniteDimensional F E := ++ LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ S P.field P.below hHfinite hPfinite ++ let auxiliaryScalarTower : IsScalarTower ℚ F E := ++ IsScalarTower.of_algebraMap_eq' rfl ++ let auxiliaryAbsoluteFiniteDimensional : FiniteDimensional ℚ E := ++ FiniteDimensional.trans ℚ F E ++ let auxiliaryBaseNumberField : NumberField F := ++ NumberField.of_module_finite ℚ F ++ let auxiliaryTopNumberField : NumberField E := ++ NumberField.of_module_finite ℚ E ++ let auxiliaryOriginalBaseAlgebra : Algebra K F := ++ numberFieldTowerFinitePadicAuxiliary_baseAlgebra ++ (K := K) (L := L) p τ ++ let wF := ++ numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension ++ (K := K) (L := L) v p τ ++ let wE := ++ numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ ++ apply HeightOneSpectrum.ext ++ ext x ++ change ++ algebraMap (𝓞 F) (𝓞 E) x ∈ ++ finitePlaceExtensionCentreIdeal ++ (K := K) (L := E) v wE ↔ ++ x ∈ ++ finitePlaceExtensionCentreIdeal ++ (K := K) (L := F) v wF ++ rw [ ++ mem_finitePlaceExtensionCentreIdeal_iff, ++ mem_finitePlaceExtensionCentreIdeal_iff] ++ rfl ++ ++/-- Evaluation of the distinguished auxiliary automorphism through the ++restricted top-field place. Isolating this coercion calculation prevents the ++whole decomposition-group proof from normalizing the fixed-field tower. -/ ++public opaque ++ numberFieldTowerFinitePadicAuxiliaryTopPlace_automorphism_apply ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ let P := numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let E := LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let wE := numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ ++ let σE := numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ ++ ∀ x : E, ++ wE.1 (σE x) = ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v (chosenFinitePlaceExtension (L := L) v)).1 ++ (τ.1 (x : SeparableClosure ℚ)) := by ++ let : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ dsimp only ++ intro x ++ change ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v (chosenFinitePlaceExtension (L := L) v)).1 ++ ((numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ x : ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) : SeparableClosure ℚ) = _ ++ rw [ ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism_apply_val ++ (K := K) (L := L) p τ] ++ ++/-- The distinguished auxiliary automorphism preserves the top-field place ++obtained by restricting the original separable-closure place. -/ ++public opaque numberFieldTowerFinitePadicAuxiliaryAutomorphism_mem_topPlaceDecomposition ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hdecomposition : ++ letI : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ ++ absoluteValueDecompositionGroup K ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v (chosenFinitePlaceExtension (L := L) v)).1) : ++ let S := numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let F := LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let wE := numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ ++ let σE := numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ ++ σE ∈ absoluteValueDecompositionGroup F wE.1 := by ++ let : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ dsimp only at hdecomposition ⊢ ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let wE := ++ numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ ++ let σE := ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ ++ intro x ++ change ++ wE.1 (σE x) < 1 ↔ ++ wE.1 x < 1 ++ rw [ ++ numberFieldTowerFinitePadicAuxiliaryTopPlace_automorphism_apply ++ (K := K) (L := L) v p τ x, ++ show ++ wE.1 x = ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v ++ (chosenFinitePlaceExtension (L := L) v)).1 ++ (x : SeparableClosure ℚ) from rfl] ++ exact hdecomposition (x : SeparableClosure ℚ) ++ ++/-- The restricted top-field place and the chosen extension above its centre ++have the same decomposition group. -/ ++public opaque numberFieldTowerFinitePadicAuxiliaryTopDecompositionGroup_eq_chosen ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hτ : ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ ≠ 1) : ++ let S := numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let P := numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let F := LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let E := LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ letI hHfinite : Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ S (le_baseField S)) := ++ (numberFieldTowerFinitePadicAuxiliaryAbstractField ++ (K := K) (L := L) p τ hτ).finite ++ letI hPfinite : Finite ++ (S.toSubgroup ⧸ extensionSubgroup S P.field P.below) := P.finite ++ letI : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) S hHfinite ++ letI : FiniteDimensional F E := ++ LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) S P.field P.below hHfinite hPfinite ++ letI : IsScalarTower ℚ F E := IsScalarTower.of_algebraMap_eq' rfl ++ letI : FiniteDimensional ℚ E := FiniteDimensional.trans ℚ F E ++ letI : NumberField F := NumberField.of_module_finite ℚ F ++ letI : NumberField E := NumberField.of_module_finite ℚ E ++ letI : IsAbelianGalois F E := ++ GlobalClassFields.finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P ++ letI : Algebra K F := ++ numberFieldTowerFinitePadicAuxiliary_baseAlgebra ++ (K := K) (L := L) p τ ++ let wF := numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension ++ (K := K) (L := L) v p τ ++ let wE := numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ ++ let V := finitePlaceExtensionCentre (K := K) (L := F) v wF ++ absoluteValueDecompositionGroup F wE.1 = ++ absoluteValueDecompositionGroup F ++ (chosenFinitePlaceExtension (L := E) V).1 := by ++ dsimp only ++ let H := ++ numberFieldTowerFinitePadicAuxiliaryAbstractField ++ (K := K) (L := L) p τ hτ ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let P := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let E := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ let hHfinite : Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ S (le_baseField S)) := ++ H.finite ++ let hPfinite : Finite ++ (S.toSubgroup ⧸ extensionSubgroup S P.field P.below) := ++ P.finite ++ let : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) S hHfinite ++ let : FiniteDimensional F E := ++ LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) S P.field P.below hHfinite hPfinite ++ let : IsScalarTower ℚ F E := IsScalarTower.of_algebraMap_eq' rfl ++ let : FiniteDimensional ℚ E := FiniteDimensional.trans ℚ F E ++ let : NumberField F := NumberField.of_module_finite ℚ F ++ let : NumberField E := NumberField.of_module_finite ℚ E ++ let : IsAbelianGalois F E := ++ GlobalClassFields.finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P ++ let : Algebra K F := ++ numberFieldTowerFinitePadicAuxiliary_baseAlgebra ++ (K := K) (L := L) p τ ++ let wF := ++ numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension ++ (K := K) (L := L) v p τ ++ let wE := ++ numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ ++ let V := finitePlaceExtensionCentre (K := K) (L := F) v wF ++ let W := finitePlaceExtensionCentre (K := K) (L := E) v wE ++ let Wover : ++ {W' : HeightOneSpectrum (𝓞 E) // ++ finitePlaceBelow (K := F) W' = V} := ++ ⟨W, ++ numberFieldTowerFinitePadicAuxiliaryTopPlace_below ++ (K := K) (L := L) v p τ hτ⟩ ++ let wFE : ++ AbsoluteValueExtension ++ (NumberField.HeightOneSpectrum.adicAbv F V) E := ++ (finitePlaceExtensionEquivAbove ++ (K := F) (L := E) V).symm Wover ++ have hwFEcentre : ++ finitePlaceExtensionCentre ++ (K := F) (L := E) V wFE = ++ W := by ++ exact ++ congrArg Subtype.val ++ ((finitePlaceExtensionEquivAbove ++ (K := F) (L := E) V).apply_symm_apply Wover) ++ have hwEquiv : wE.1.IsEquiv wFE.1 := by ++ apply ++ finitePlaceExtensions_isEquiv_of_centres_eq ++ (F := K) (M := F) v V wE wFE ++ exact hwFEcentre.symm ++ calc ++ absoluteValueDecompositionGroup F wE.1 = ++ absoluteValueDecompositionGroup F wFE.1 := ++ absoluteValueDecompositionGroup_eq_of_absoluteValue_isEquiv ++ (F := F) wE.1 wFE.1 hwEquiv ++ _ = ++ absoluteValueDecompositionGroup F ++ (chosenFinitePlaceExtension (L := E) V).1 := ++ absoluteValueDecompositionGroup_eq_of_exactExtensions_of_isMulCommutative ++ (F := F) ++ (NumberField.HeightOneSpectrum.adicAbv F V) ++ (RayClass.adicAbv_isNontrivial V) ++ wFE ++ (chosenFinitePlaceExtension (L := E) V) ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldBase.lean +new file mode 100644 +index 0000000..2c56707 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldBase.lean +@@ -0,0 +1,433 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicCyclicData ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicUnramifiedLocalGlobalCompatibility ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.Extension.OnePlaceBaseNorm ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open AlgebraicNumberTheory IsDedekindDomain NumberField ++open IdeleGroup RelativeIdeleGroup ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open CyclicCohomology ++open KummerTheory ClassFormation ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open GlobalClassFields ++ ++variable ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ ++local instance (p : Nat.Primes) : Fact p.1.Prime := ++ ⟨p.2⟩ ++ ++attribute [local instance] ++ rationalSeparableClosureAlgebra ++ ++local instance finitePadicAuxiliaryExtensionNormal : ++ (extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L)).Normal := ++ numberFieldTowerExtensionSubgroup_normal K L ++ ++local instance finitePadicAuxiliaryExtensionQuotientFinite : ++ Finite ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) := ++ numberFieldTowerExtensionQuotient_finite K L ++ ++noncomputable local instance finitePadicAuxiliaryExtensionQuotientIsMulCommutative : ++ IsMulCommutative ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) := by ++ let e : ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) ≃* ++ Gal(L / K) := ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ exact ++ { is_comm := ++ ⟨fun x y => by ++ apply e.injective ++ rw [map_mul, map_mul] ++ exact ++ (inferInstance : ++ IsMulCommutative (Gal(L / K))).is_comm.comm ++ (e x) (e y)⟩ } ++ ++/-- The concrete auxiliary fixed field attached to a simultaneous ++finite/cyclotomic lift. -/ ++noncomputable def numberFieldTowerFinitePadicCyclicFixedField ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ IntermediateField ℚ (SeparableClosure ℚ) := by ++ exact ++ IntermediateField.fixedField ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ).toSubgroup ++ ++/-- A nonzero-degree lift produces a genuine number field: its ++concrete fixed field is finite over `ℚ`. -/ ++theorem numberFieldTowerFinitePadicCyclicFixedField_finiteDimensional ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hτ : ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ ≠ ++ 1) : ++ FiniteDimensional ℚ ++ (numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ) := by ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let F := ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ++ apply ++ (InfiniteGalois.isOpen_iff_finite ++ (K := SeparableClosure ℚ) F).1 ++ change IsOpen ++ (IntermediateField.fixedField S.toSubgroup).fixingSubgroup.carrier ++ rw [InfiniteGalois.fixingSubgroup_fixedField S] ++ exact ++ numberFieldTowerFinitePadicCyclicFixedSubgroup_isOpen ++ (K := K) (L := L) p τ hτ ++ ++/-- The compatible embedded copy of `K` lies in every auxiliary ++cyclic fixed field. -/ ++theorem numberFieldTowerBaseField_le_finitePadicCyclicFixedField ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ numberFieldTowerBaseField K L ≤ ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ := by ++ intro x hx ++ change x ∈ IntermediateField.fixedField ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ).toSubgroup ++ rw [IntermediateField.mem_fixedField_iff] ++ intro σ hσ ++ change ++ σ ∈ ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ).toSubgroup at hσ ++ obtain ⟨u, hu, rfl⟩ := hσ ++ exact ++ (IntermediateField.mem_fixingSubgroup_iff ++ (numberFieldTowerBaseField K L) u.1).1 u.2 x hx ++ ++/-- The compatible embedding of the original base field into the ++genuine auxiliary fixed field. -/ ++noncomputable def numberFieldTowerFinitePadicAuxiliaryBaseEmbedding ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ K →ₐ[ℚ] ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ) := by ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ) ++ exact ++ (numberFieldTowerLowerEmbedding K L).codRestrict F.toSubalgebra ++ (fun x => ++ numberFieldTowerBaseField_le_finitePadicCyclicFixedField ++ (K := K) (L := L) p τ ⟨x, rfl⟩) ++ ++/-- Coercing the auxiliary base embedding recovers the fixed lower embedding ++into the rational separable closure. -/ ++@[simp] ++theorem numberFieldTowerFinitePadicAuxiliaryBaseEmbedding_coe ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (x : K) : ++ ((numberFieldTowerFinitePadicAuxiliaryBaseEmbedding ++ (K := K) (L := L) p τ x : ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ)) : ++ SeparableClosure ℚ) = ++ numberFieldTowerLowerEmbedding K L x := by ++ rfl ++ ++/-- The compatible copy of the original top field lies in the ++auxiliary compositum fixed field. -/ ++theorem numberFieldTowerTopField_mem_finitePadicAuxiliaryTopField ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ {x : SeparableClosure ℚ} ++ (hx : x ∈ numberFieldInRationalSeparableClosure L) : ++ x ∈ ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below := by ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let T := ++ numberFieldTowerTopSubgroup L ++ change x ∈ IntermediateField.fixedField ++ (S.toSubgroup ⊓ T.toSubgroup) ++ rw [IntermediateField.mem_fixedField_iff] ++ intro σ hσ ++ have hσT : σ ∈ T.toSubgroup := ++ hσ.2 ++ change ++ σ ∈ ++ (numberFieldInRationalSeparableClosure L).fixingSubgroup ++ at hσT ++ exact ++ (IntermediateField.mem_fixingSubgroup_iff ++ (numberFieldInRationalSeparableClosure L) σ).1 ++ hσT x hx ++ ++/-- The compatible embedding of the original top field into the ++auxiliary compositum fixed field. -/ ++noncomputable def numberFieldTowerFinitePadicAuxiliaryTopEmbedding ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ L →ₐ[ℚ] ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below := by ++ let E := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below ++ exact ++ (numberFieldSeparableClosureEmbedding L).codRestrict ++ (E.restrictScalars ℚ).toSubalgebra ++ (fun x => ++ numberFieldTowerTopField_mem_finitePadicAuxiliaryTopField ++ (K := K) (L := L) p τ ⟨x, rfl⟩) ++ ++/-- Coercing the auxiliary top embedding recovers the chosen top-field ++embedding into the rational separable closure. -/ ++@[simp] ++theorem numberFieldTowerFinitePadicAuxiliaryTopEmbedding_coe ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (x : L) : ++ ((numberFieldTowerFinitePadicAuxiliaryTopEmbedding ++ (K := K) (L := L) p τ x : ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) : ++ SeparableClosure ℚ) = ++ numberFieldSeparableClosureEmbedding L x := by ++ rfl ++ ++/-- The compatible base and top embeddings form the actual ++base-change square inside the rational separable closure. -/ ++theorem numberFieldTowerFinitePadicAuxiliaryEmbedding_algebraMap ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (x : K) : ++ ((numberFieldTowerFinitePadicAuxiliaryTopEmbedding ++ (K := K) (L := L) p τ (algebraMap K L x) : ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) : ++ SeparableClosure ℚ) = ++ ((numberFieldTowerFinitePadicAuxiliaryBaseEmbedding ++ (K := K) (L := L) p τ x : ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ)) : ++ SeparableClosure ℚ) := by ++ rfl ++ ++noncomputable instance ++ numberFieldTowerFinitePadicAuxiliary_baseAlgebra ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ Algebra K ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ)) := by ++ exact ++ (numberFieldTowerFinitePadicAuxiliaryBaseEmbedding ++ (K := K) (L := L) p τ).toRingHom.toAlgebra ++ ++instance ++ numberFieldTowerFinitePadicAuxiliary_baseRatScalarTower ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ IsScalarTower ℚ K ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ)) := by ++ exact ++ IsScalarTower.of_algebraMap_eq' ++ (numberFieldTowerFinitePadicAuxiliaryBaseEmbedding ++ (K := K) (L := L) p τ).comp_algebraMap.symm ++ ++noncomputable instance ++ numberFieldTowerFinitePadicAuxiliary_topAlgebra ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ Algebra L ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) := by ++ exact ++ (numberFieldTowerFinitePadicAuxiliaryTopEmbedding ++ (K := K) (L := L) p τ).toRingHom.toAlgebra ++ ++instance ++ numberFieldTowerFinitePadicAuxiliary_topRatScalarTower ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ IsScalarTower ℚ L ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) := by ++ exact ++ IsScalarTower.of_algebraMap_eq' ++ (numberFieldTowerFinitePadicAuxiliaryTopEmbedding ++ (K := K) (L := L) p τ).comp_algebraMap.symm ++ ++noncomputable instance ++ numberFieldTowerFinitePadicAuxiliary_originalBaseTopAlgebra ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ Algebra K ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) := by ++ exact ++ ((numberFieldTowerFinitePadicAuxiliaryTopEmbedding ++ (K := K) (L := L) p τ).comp ++ (IsScalarTower.toAlgHom ℚ K L)).toRingHom.toAlgebra ++ ++instance ++ numberFieldTowerFinitePadicAuxiliary_originalTopScalarTower ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ IsScalarTower K L ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) := by ++ exact IsScalarTower.of_algebraMap_eq' rfl ++ ++instance ++ numberFieldTowerFinitePadicAuxiliary_baseTopScalarTower ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ IsScalarTower K ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ)) ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ).below) := by ++ apply IsScalarTower.of_algebraMap_eq' ++ apply RingHom.ext ++ intro x ++ apply Subtype.ext ++ exact ++ numberFieldTowerFinitePadicAuxiliaryEmbedding_algebraMap ++ (K := K) (L := L) p τ x ++ ++/-- The genuine auxiliary fixed field is Galois over the original ++base field through the compatible embedding above. -/ ++theorem numberFieldTowerFinitePadicAuxiliaryBase_isGalois ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) : ++ IsGalois K ++ (LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ)) := by ++ let H := ++ numberFieldTowerBaseSubgroup K L ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let hSH := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup_le_baseSubgroup ++ (K := K) (L := L) p τ ++ let B := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) H ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let FB := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hSH ++ let auxiliaryBaseAlgebra : Algebra B FB := ++ (LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) hSH).algebra ++ let auxiliaryBaseGalois : IsGalois B FB := ++ LocalClassFieldTheory.abstractRelativeFixedField_isGalois ++ ℚ (SeparableClosure ℚ) H S hSH ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup_extension_normal ++ (K := K) (L := L) p τ) ++ let eK := ++ numberFieldTowerAbstractBaseFieldEquiv K L ++ refine ++ @IsGalois.of_equiv_equiv ++ B FB _ _ auxiliaryBaseAlgebra ++ K F _ _ ++ (numberFieldTowerFinitePadicAuxiliary_baseAlgebra ++ (K := K) (L := L) p τ) ++ auxiliaryBaseGalois ++ eK.symm.toRingEquiv (RingEquiv.refl F) ?_ ++ apply RingHom.ext ++ intro x ++ apply Subtype.ext ++ change ++ ((eK (eK.symm x) : B) : SeparableClosure ℚ) = ++ (x : SeparableClosure ℚ) ++ exact ++ congrArg Subtype.val (eK.apply_symm_apply x) ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldExistence.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldExistence.lean +new file mode 100644 +index 0000000..87681a2 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldExistence.lean +@@ -0,0 +1,234 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicAuxiliaryFieldFixedFields ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicCyclicData ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicUnramifiedLocalGlobalCompatibility ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.Extension.OnePlaceBaseNorm ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open AlgebraicNumberTheory IsDedekindDomain NumberField ++open IdeleGroup RelativeIdeleGroup ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open CyclicCohomology ++open KummerTheory ClassFormation ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open GlobalClassFields ++ ++variable ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ ++ ++local instance splitFactPrimeExistence (p : Nat.Primes) : Fact p.1.Prime := ⟨p.2⟩ ++ ++attribute [local instance] ++ rationalSeparableClosureAlgebra ++ finitePadicAuxiliaryExtensionNormal ++ finitePadicAuxiliaryExtensionQuotientFinite ++ finitePadicAuxiliaryExtensionQuotientIsMulCommutative ++ ++ ++/-- For a finite-place automorphism generating `Gal(L/K)`, construct ++the genuine auxiliary number field used in the cyclotomic reduction. ++ ++The field is finite over `ℚ`, contains the compatible copy of `K`, and ++has intersection with the compatible copy of `L` exactly equal to that ++copy of `K`. Its defining lift has the prescribed local restriction ++and positive integral cyclotomic `p`-adic degree. -/ ++theorem exists_finitePlaceCyclotomicAuxiliaryFixedField ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (σ : ++ absoluteValueDecompositionGroup K ++ (chosenFinitePlaceExtension (L := L) v).1) ++ (hσ : ++ Subgroup.closure ++ ({σ.1} : Set (Gal(L / K))) = ++ ⊤) : ++ letI _ : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ letI _ : Algebra L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureTopAlgebra L ++ letI _ : IsScalarTower K L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureScalarTower K L ++ ∃ τ : (numberFieldTowerBaseSubgroup K L).toSubgroup, ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) = ++ σ.1 ∧ ++ (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ ++ absoluteValueDecompositionGroup K ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v ++ (chosenFinitePlaceExtension (L := L) v)).1 ∧ ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ ≠ ++ 1 ∧ ++ FiniteDimensional ℚ ++ (numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ) ∧ ++ numberFieldTowerBaseField K L ≤ ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ∧ ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ⊓ ++ numberFieldInRationalSeparableClosure L = ++ numberFieldTowerBaseField K L ∧ ++ ∃ n : ℕ, 0 < n ∧ ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ = ++ (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by ++ let : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ let : Algebra L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureTopAlgebra L ++ let : IsScalarTower K L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureScalarTower K L ++ obtain ++ ⟨τ, hτσ, hτdecomposition, hτdegree, ++ n, hn, hdegree⟩ := ++ exists_numberFieldTowerFinitePadicLift_of_finitePlace ++ (K := K) (L := L) v p σ ++ have hgenerate := ++ numberFieldTowerFiniteQuotientCoordinate_generates_of_galoisGenerator ++ (K := K) (L := L) τ σ.1 hτσ hσ ++ refine ++ ⟨τ, hτσ, hτdecomposition, hτdegree, ++ numberFieldTowerFinitePadicCyclicFixedField_finiteDimensional ++ (K := K) (L := L) p τ hτdegree, ++ numberFieldTowerBaseField_le_finitePadicCyclicFixedField ++ (K := K) (L := L) p τ, ++ numberFieldTowerFinitePadicCyclicFixedField_inf_topField ++ (K := K) (L := L) p τ hgenerate, ++ n, hn, hdegree⟩ ++ ++/-- A `p`-primary local generator admits a genuine auxiliary number ++field whose compositum with the rational `p`-primary cyclotomic field ++contains `L`. ++ ++Besides the field containment, the construction records the two ++properties needed for descent: the auxiliary field meets `L` exactly ++in `K`, and the chosen absolute lift has positive integral ++cyclotomic degree. -/ ++theorem exists_finitePlacePrimaryCyclotomicAuxiliaryFixedField ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (σ : ++ absoluteValueDecompositionGroup K ++ (chosenFinitePlaceExtension (L := L) v).1) ++ (hgenerate : ++ Subgroup.closure ++ ({σ.1} : Set (Gal(L / K))) = ++ ⊤) ++ (hprimary : ++ σ.1 ∈ ++ CommGroup.primaryComponent ++ (Gal(L / K)) p.1) : ++ letI _ : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ letI _ : Algebra L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureTopAlgebra L ++ letI _ : IsScalarTower K L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureScalarTower K L ++ ∃ τ : (numberFieldTowerBaseSubgroup K L).toSubgroup, ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) = ++ σ.1 ∧ ++ (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ ++ absoluteValueDecompositionGroup K ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v ++ (chosenFinitePlaceExtension (L := L) v)).1 ∧ ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ ≠ ++ 1 ∧ ++ FiniteDimensional ℚ ++ (numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ) ∧ ++ numberFieldTowerBaseField K L ≤ ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ∧ ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ⊓ ++ numberFieldInRationalSeparableClosure L = ++ numberFieldTowerBaseField K L ∧ ++ numberFieldInRationalSeparableClosure L ≤ ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ⊔ ++ rationalCyclotomicPadicField p ∧ ++ ∃ n : ℕ, 0 < n ∧ ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ = ++ (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by ++ let : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ let : Algebra L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureTopAlgebra L ++ let : IsScalarTower K L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureScalarTower K L ++ obtain ++ ⟨τ, hτσ, hτdecomposition, hτdegree, ++ hfinite, hbase, hintersection, ++ n, hn, hdegree⟩ := ++ exists_finitePlaceCyclotomicAuxiliaryFixedField ++ (K := K) (L := L) v p σ hgenerate ++ have hprimaryQuotient : ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ ∈ ++ CommGroup.primaryComponent ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) ++ p.1 := by ++ obtain ⟨m, hm⟩ := hprimary ++ refine ⟨m, ?_⟩ ++ let e := ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ let q := ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ ++ let N : ℕ := p.1 ^ m ++ have hq : e q = σ.1 := by ++ exact hτσ ++ have hmN : σ.1 ^ N = 1 := by ++ exact hm ++ change q ^ N = 1 ++ apply e.injective ++ calc ++ e (q ^ N) = (e q) ^ N := by ++ exact map_pow e q N ++ _ = σ.1 ^ N := by rw [hq] ++ _ = 1 := hmN ++ _ = e 1 := (map_one e).symm ++ have hcontainment := ++ numberFieldTowerTopField_le_finitePadicCyclicFixedField_sup_padicCyclotomicField ++ (K := K) (L := L) p τ n hn hdegree ++ hprimaryQuotient ++ exact ++ ⟨τ, hτσ, hτdecomposition, hτdegree, ++ hfinite, hbase, hintersection, ++ hcontainment, n, hn, hdegree⟩ ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldFixedFields.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldFixedFields.lean +new file mode 100644 +index 0000000..1ed247d +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldFixedFields.lean +@@ -0,0 +1,420 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicAuxiliaryFieldNormRestriction ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicCyclicData ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicUnramifiedLocalGlobalCompatibility ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.Extension.OnePlaceBaseNorm ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open AlgebraicNumberTheory IsDedekindDomain NumberField ++open IdeleGroup RelativeIdeleGroup ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open CyclicCohomology ++open KummerTheory ClassFormation ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open GlobalClassFields ++ ++variable ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ ++ ++local instance splitFactPrimeFixedFields (p : Nat.Primes) : Fact p.1.Prime := ⟨p.2⟩ ++ ++attribute [local instance] ++ rationalSeparableClosureAlgebra ++ finitePadicAuxiliaryExtensionNormal ++ finitePadicAuxiliaryExtensionQuotientFinite ++ finitePadicAuxiliaryExtensionQuotientIsMulCommutative ++ ++/-- Generation of the actual finite Galois group transports back ++through the compatible finite quotient coordinate. -/ ++theorem ++ numberFieldTowerFiniteQuotientCoordinate_generates_of_galoisGenerator ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (σ : Gal(L / K)) ++ (hτσ : ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) = ++ σ) ++ (hσ : Subgroup.closure ({σ} : Set (Gal(L / K))) = ⊤) : ++ Subgroup.closure ++ ({numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ} : ++ Set ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = ++ ⊤ := by ++ let e := ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ let q : ++ (numberFieldTowerFiniteGaloisSubextension ++ K L).extensionQuotient := ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ ++ have hq : e.toMonoidHom q = σ := by ++ exact hτσ ++ change ++ Subgroup.closure ++ ({q} : ++ Set ++ (numberFieldTowerFiniteGaloisSubextension ++ K L).extensionQuotient) = ++ ⊤ ++ apply Subgroup.map_injective (f := e.toMonoidHom) e.injective ++ rw [MonoidHom.map_closure, Set.image_singleton, ++ hq, hσ, ++ Subgroup.map_top_of_surjective e.toMonoidHom e.surjective] ++ ++/-- If the finite quotient coordinate of a lift generates the whole ++finite Galois quotient, then its cyclic preimage together with the ++top-field subgroup generates the whole embedded absolute Galois ++group. -/ ++theorem ++ numberFieldTowerFinitePadicCyclicPreimage_sup_extensionSubgroup_eq_top ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hgenerate : ++ Subgroup.closure ++ ({numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ} : ++ Set ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = ++ ⊤) : ++ (numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ⊔ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L) = ++ ⊤ := by ++ let H := ++ numberFieldTowerBaseSubgroup K L ++ let N := ++ extensionSubgroup ++ H ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L) ++ let Q := H.toSubgroup ⧸ N ++ let P := ++ numberFieldTowerFinitePadicImage ++ (K := K) (L := L) p ++ let coordinate := ++ numberFieldTowerFinitePadicCoordinate ++ (K := K) (L := L) p ++ let rangeRestriction := ++ numberFieldTowerFinitePadicRangeRestriction ++ (K := K) (L := L) p ++ let γ : P.toSubgroup := ++ rangeRestriction τ ++ let Γ := ++ ClassFormation.padicCyclicClosure γ ++ let finiteProjection : ++ P.toSubgroup →* ++ Q := ++ (MonoidHom.fst Q ++ (Multiplicative ℤ_[p.1])).comp ++ P.toSubgroup.subtype ++ have hprojection : ++ Γ.toSubgroup.map finiteProjection = ⊤ := by ++ apply top_unique ++ rw [← hgenerate] ++ apply (Subgroup.closure_le _).2 ++ intro q hq ++ rw [Set.mem_singleton_iff] at hq ++ subst q ++ refine ++ ⟨γ, ++ (ClassFormation.padicCyclicClosureGenerator γ).2, ++ ?_⟩ ++ rfl ++ have hquotientSurjective : ++ ∀ q : Q, ++ ∃ u : H.toSubgroup, ++ u ∈ ++ (numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ∧ ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) u = ++ q := by ++ intro q ++ have hq : ++ q ∈ Γ.toSubgroup.map finiteProjection := by ++ rw [hprojection] ++ trivial ++ obtain ⟨z, hzΓ, hzq⟩ := hq ++ obtain ⟨u, hu⟩ := ++ numberFieldTowerFinitePadicRangeRestriction_surjective ++ (K := K) (L := L) p z ++ refine ⟨u, ?_, ?_⟩ ++ · change rangeRestriction u ∈ Γ.toSubgroup ++ rw [hu] ++ exact hzΓ ++ · calc ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) u = ++ finiteProjection (rangeRestriction u) := rfl ++ _ = finiteProjection z := congrArg finiteProjection hu ++ _ = q := hzq ++ apply top_unique ++ intro h _ ++ obtain ⟨u, huU, huq⟩ := ++ hquotientSurjective ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) h) ++ let k : H.toSubgroup := ++ h * u⁻¹ ++ have hkN : k ∈ N := by ++ apply (QuotientGroup.eq_one_iff (N := N) k).mp ++ change ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) (h * u⁻¹) = ++ 1 ++ rw [map_mul, map_inv, huq, mul_inv_cancel] ++ have hkSup : ++ k ∈ ++ (numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ⊔ ++ N := ++ (le_sup_right : ++ N ≤ ++ (numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ⊔ N) hkN ++ have huSup : ++ u ∈ ++ (numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ⊔ ++ N := ++ (le_sup_left : ++ (numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ≤ ++ (numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ⊔ N) huU ++ have hku : ++ k * u = h := by ++ simp only [k, inv_mul_cancel_right] ++ rw [← hku] ++ exact ++ ((numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ).toSubgroup ⊔ N).mul_mem ++ hkSup huSup ++ ++/-- Ambient form of the generation statement: the auxiliary cyclic ++fixed subgroup together with the subgroup fixing `L` generates the ++subgroup fixing `K`. -/ ++theorem ++ numberFieldTowerFinitePadicCyclicFixedSubgroup_sup_topSubgroup ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hgenerate : ++ Subgroup.closure ++ ({numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ} : ++ Set ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = ++ ⊤) : ++ (numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ).toSubgroup ⊔ ++ (numberFieldTowerTopSubgroup L).toSubgroup = ++ (numberFieldTowerBaseSubgroup K L).toSubgroup := by ++ let H := ++ numberFieldTowerBaseSubgroup K L ++ let T := ++ numberFieldTowerTopSubgroup L ++ let N := ++ extensionSubgroup ++ H T ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L) ++ let U := ++ numberFieldTowerFinitePadicCyclicPreimage ++ (K := K) (L := L) p τ ++ have hrelative : ++ U.toSubgroup ⊔ N = ⊤ := ++ numberFieldTowerFinitePadicCyclicPreimage_sup_extensionSubgroup_eq_top ++ (K := K) (L := L) p τ hgenerate ++ have hNmap : ++ N.map H.toSubgroup.subtype = ++ T.toSubgroup := by ++ exact ++ Subgroup.map_subgroupOf_eq_of_le ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L) ++ change ++ U.toSubgroup.map H.toSubgroup.subtype ⊔ ++ T.toSubgroup = ++ H.toSubgroup ++ rw [← hNmap, ← Subgroup.map_sup, ++ hrelative, ← MonoidHom.range_eq_map, ++ H.toSubgroup.range_subtype] ++ ++/-- The concrete auxiliary fixed field is linearly disjoint from `L` ++over the compatible embedded copy of `K`. -/ ++theorem ++ numberFieldTowerFinitePadicCyclicFixedField_inf_topField ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hgenerate : ++ Subgroup.closure ++ ({numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ} : ++ Set ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L))) = ++ ⊤) : ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ⊓ ++ numberFieldInRationalSeparableClosure L = ++ numberFieldTowerBaseField K L := by ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let T := ++ numberFieldTowerTopSubgroup L ++ let H := ++ numberFieldTowerBaseSubgroup K L ++ change ++ IntermediateField.fixedField S.toSubgroup ⊓ ++ numberFieldInRationalSeparableClosure L = ++ numberFieldTowerBaseField K L ++ rw [ ++ ← InfiniteGalois.fixedField_fixingSubgroup ++ (numberFieldInRationalSeparableClosure L), ++ ← InfiniteGalois.fixedField_fixingSubgroup ++ (numberFieldTowerBaseField K L)] ++ change ++ IntermediateField.fixedField S.toSubgroup ⊓ ++ IntermediateField.fixedField T.toSubgroup = ++ IntermediateField.fixedField H.toSubgroup ++ rw [ ++ ← IntermediateField.fixedField_sup_eq_inf, ++ numberFieldTowerFinitePadicCyclicFixedSubgroup_sup_topSubgroup ++ (K := K) (L := L) p τ hgenerate] ++ ++/-- If the finite quotient coordinate is `p`-primary, adjoining the ++actual rational `p`-primary cyclotomic field to the auxiliary fixed ++field contains the compatible copy of `L`. ++ ++This is the field-theoretic conclusion of the simultaneous ++finite/cyclotomic lift: the intersection of the two fixing subgroups ++already fixes `L`, hence their fixed-field compositum contains `L`. -/ ++theorem ++ numberFieldTowerTopField_le_finitePadicCyclicFixedField_sup_padicCyclotomicField ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (n : ℕ) (hn : 0 < n) ++ (hdegree : ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ = ++ (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n) ++ (hprimary : ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ ∈ ++ CommGroup.primaryComponent ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) ++ p.1) : ++ numberFieldInRationalSeparableClosure L ≤ ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ⊔ ++ rationalCyclotomicPadicField p := by ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let T := ++ numberFieldTowerTopSubgroup L ++ let F := ++ numberFieldTowerFinitePadicCyclicFixedField ++ (K := K) (L := L) p τ ++ let C : @IntermediateField ℚ (SeparableClosure ℚ) _ _ ++ rationalSeparableClosureAlgebra := ++ rationalCyclotomicPadicField p ++ have hfixing : ++ (F ⊔ C).fixingSubgroup ≤ ++ T.toSubgroup := by ++ change ++ (IntermediateField.fixedField S.toSubgroup ⊔ C).fixingSubgroup ≤ ++ T.toSubgroup ++ rw [ ++ IntermediateField.fixingSubgroup_sup, ++ InfiniteGalois.fixingSubgroup_fixedField S] ++ intro σ hσ ++ apply ++ numberFieldTowerFinitePadicCyclicFixedSubgroup_inf_absolutePadicKernel_le_topSubgroup ++ (K := K) (L := L) p τ n hn hdegree hprimary ++ refine ⟨hσ.1, ?_⟩ ++ let : Algebra ℚ rationalCyclotomicZHatField := ++ rationalCyclotomicZHatField.algebra' ++ let : @Normal ℚ rationalCyclotomicZHatField _ _ ++ rationalCyclotomicZHatField.algebra' := ++ rationalCyclotomicZHatField_normal ++ let E := ++ rationalCyclotomicPadicFieldWithinZHat p ++ change ++ rationalCyclotomicPadicCoordinate p ++ (rationalAbsoluteGaloisRestrictionToCyclotomicZHat σ) = ++ 1 ++ have hr : ++ rationalAbsoluteGaloisRestrictionToCyclotomicZHat σ ∈ ++ E.fixingSubgroup := by ++ rw [IntermediateField.mem_fixingSubgroup_iff] ++ intro x hx ++ apply Subtype.ext ++ have hfix : ++ σ x.1 = x.1 := ++ (IntermediateField.mem_fixingSubgroup_iff ++ (IntermediateField.lift E) σ).1 hσ.2 x.1 ++ ((IntermediateField.mem_lift x).2 hx) ++ exact ++ (AlgEquiv.restrictNormal_commutes ++ σ rationalCyclotomicZHatField x).trans hfix ++ rw [rationalCyclotomicPadicFieldWithinZHat_fixingSubgroup] ++ at hr ++ exact hr ++ rw [ ++ ← InfiniteGalois.fixedField_fixingSubgroup ++ (numberFieldInRationalSeparableClosure L)] ++ change ++ IntermediateField.fixedField T.toSubgroup ≤ ++ F ⊔ C ++ rw [ ++ ← InfiniteGalois.fixedField_fixingSubgroup ++ (F ⊔ C)] ++ exact ++ IntermediateField.fixedField_le hfixing ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldNormRestriction.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldNormRestriction.lean +new file mode 100644 +index 0000000..c7daa65 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/LocalGlobalArtinCompatibility/FinitePadicAuxiliaryFieldNormRestriction.lean +@@ -0,0 +1,411 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicAuxiliaryFieldAutomorphisms ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.LocalGlobalArtinCompatibility.FinitePadicCyclicData ++import ClassFieldTheory.GlobalClassFieldTheory.GlobalClassFields.ClassFieldRealization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.CyclotomicUnramifiedLocalGlobalCompatibility ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.Extension.OnePlaceBaseNorm ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped IsMulCommutative NumberField ++open AlgebraicNumberTheory IsDedekindDomain NumberField ++open IdeleGroup RelativeIdeleGroup ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open CyclicCohomology ++open KummerTheory ClassFormation ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open GlobalClassFields ++ ++variable ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [NumberField L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ ++ ++local instance splitFactPrimeNormRestriction (p : Nat.Primes) : Fact p.1.Prime := ⟨p.2⟩ ++ ++attribute [local instance] ++ rationalSeparableClosureAlgebra ++ finitePadicAuxiliaryExtensionNormal ++ finitePadicAuxiliaryExtensionQuotientFinite ++ finitePadicAuxiliaryExtensionQuotientIsMulCommutative ++ ++/-- Pointwise form of norm/restriction naturality. Keeping the function ++equality and its coercion normalization in this small declaration prevents ++the auxiliary-field witness construction below from repeatedly elaborating ++the full pair of composite homomorphisms. -/ ++private theorem globalNormResidueMonoidHomOfEmbedding_norm_restriction_apply ++ (K K' L L' : Type) ++ [Field K] [NumberField K] ++ [Field K'] [NumberField K'] ++ [Field L] [NumberField L] ++ [Field L'] [NumberField L'] ++ [Algebra K K'] [Algebra K L] [Algebra K L'] ++ [Algebra K' L'] [Algebra L L'] ++ [IsScalarTower K K' L'] [IsScalarTower K L L'] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ [FiniteDimensional K' L'] [IsAbelianGalois K' L'] ++ [FiniteDimensional K K'] [IsGalois K K'] ++ (j : L' →ₐ[ℚ] SeparableClosure ℚ) ++ (c : IdeleClassGroup K') : ++ ((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)) ++ (globalNormResidueMonoidHomOfEmbedding K' L' j c) = ++ globalNormResidueMonoidHomOfEmbedding K L ++ (j.comp (IsScalarTower.toAlgHom ℚ L L')) ++ (_root_.ideleClassNorm K K' c) := by ++ exact ++ DFunLike.congr_fun ++ (globalNormResidueMonoidHomOfEmbedding_norm_restriction ++ (K := K) (L := L) (K' := K') (L' := L') j) c ++ ++ ++/-- The auxiliary-field construction produces a lower local unit ++whose chosen local Artin value and global norm-residue value are both ++the finite quotient coordinate of the distinguished lift. -/ ++opaque numberFieldTowerFinitePadicAuxiliaryLocalGlobalRepresentative ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (τ : (numberFieldTowerBaseSubgroup K L).toSubgroup) ++ (hτ : ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ ≠ 1) ++ (hdecomposition : ++ letI : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ ++ absoluteValueDecompositionGroup K ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v (chosenFinitePlaceExtension (L := L) v)).1) ++ (n : ℕ) (hn : 0 < n) ++ (hdegree : ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ = ++ (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n) ++ (hprimaryQuotient : ++ numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ ∈ ++ CommGroup.primaryComponent ++ ((numberFieldTowerBaseSubgroup K L).toSubgroup ⧸ ++ extensionSubgroup ++ (numberFieldTowerBaseSubgroup K L) ++ (numberFieldTowerTopSubgroup L) ++ (numberFieldTowerTopSubgroup_le_baseSubgroup K L)) ++ p.1) : ++ {z : (v.adicCompletion K)ˣ // ++ chosenFinitePlaceArtinMonoidHom (K := K) (L := L) v z = ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) ∧ ++ globalNormResidueMonoidHom K L ++ (IdeleGroup.finitePlaceIdeleClass v z) = ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ)} := by ++ let H := ++ numberFieldTowerFinitePadicAuxiliaryAbstractField ++ (K := K) (L := L) p τ hτ ++ let S := ++ numberFieldTowerFinitePadicCyclicFixedSubgroup ++ (K := K) (L := L) p τ ++ let P := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension ++ (K := K) (L := L) p τ ++ let F := ++ LocalClassFieldTheory.abstractFixedField ++ ℚ (SeparableClosure ℚ) S ++ let E := ++ LocalClassFieldTheory.abstractRelativeFixedField ++ ℚ (SeparableClosure ℚ) P.below ++ letI hHfinite : Finite ++ ((baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)).toSubgroup ⧸ ++ extensionSubgroup ++ (baseField ++ (SeparableClosure ℚ ≃ₐ[ℚ] SeparableClosure ℚ)) ++ S (le_baseField S)) := ++ H.finite ++ letI hPfinite : Finite ++ (S.toSubgroup ⧸ extensionSubgroup S P.field P.below) := ++ P.finite ++ letI auxiliaryBaseNumberField : NumberField F := by ++ let : FiniteDimensional ℚ F := ++ LocalClassFieldTheory.abstractFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) S hHfinite ++ exact NumberField.of_module_finite ℚ F ++ letI auxiliaryTopNumberField : NumberField E := by ++ let : FiniteDimensional F E := ++ LocalClassFieldTheory.abstractRelativeFixedField_finiteDimensional ++ ℚ (SeparableClosure ℚ) ++ S P.field P.below hHfinite hPfinite ++ exact NumberField.of_module_finite F E ++ letI auxiliaryAbelianGalois : IsAbelianGalois F E := ++ GlobalClassFields.finiteAbelianSubextensionAbstractRelativeFixedFieldIsAbelianGalois P ++ letI auxiliaryOriginalBaseAlgebra : Algebra K F := ++ numberFieldTowerFinitePadicAuxiliary_baseAlgebra ++ (K := K) (L := L) p τ ++ letI auxiliaryOriginalTopAlgebra : Algebra L E := ++ numberFieldTowerFinitePadicAuxiliary_topAlgebra ++ (K := K) (L := L) p τ ++ letI auxiliaryOriginalBaseTopAlgebra : Algebra K E := ++ numberFieldTowerFinitePadicAuxiliary_originalBaseTopAlgebra ++ (K := K) (L := L) p τ ++ letI auxiliaryOriginalTopScalarTower : IsScalarTower K L E := ++ numberFieldTowerFinitePadicAuxiliary_originalTopScalarTower ++ (K := K) (L := L) p τ ++ letI auxiliaryBaseTopScalarTower : IsScalarTower K F E := ++ numberFieldTowerFinitePadicAuxiliary_baseTopScalarTower ++ (K := K) (L := L) p τ ++ letI auxiliaryOriginalBaseGalois : IsGalois K F := ++ numberFieldTowerFinitePadicAuxiliaryBase_isGalois ++ (K := K) (L := L) p τ ++ let auxiliaryOriginalTopAlgHom : L →ₐ[ℚ] E := ++ numberFieldTowerFinitePadicAuxiliaryTopEmbedding ++ (K := K) (L := L) p τ ++ let wF := ++ numberFieldTowerFinitePadicAuxiliaryBasePlaceExtension ++ (K := K) (L := L) v p τ ++ let wE := ++ numberFieldTowerFinitePadicAuxiliaryTopPlaceExtension ++ (K := K) (L := L) v p τ ++ let V := ++ finitePlaceExtensionCentre ++ (K := K) (L := F) v wF ++ have hVbelow : finitePlaceBelow (K := K) V = v := ++ finitePlaceBelow_finitePlaceExtensionCentre ++ (K := K) (L := F) v wF ++ let Vover : ++ {V' : HeightOneSpectrum (𝓞 F) // ++ finitePlaceBelow (K := K) V' = v} := ++ ⟨V, hVbelow⟩ ++ letI auxiliaryCompletionAlgebra : ++ Algebra (v.adicCompletion K) (V.adicCompletion F) := ++ (finitePlaceAdicCompletionMap K F v Vover).toAlgebra ++ let σE : Gal(E / F) := ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ ++ have hσtop : ++ σE ∈ absoluteValueDecompositionGroup F wE.1 := ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism_mem_topPlaceDecomposition ++ (K := K) (L := L) v p τ hdecomposition ++ have hgroup := ++ numberFieldTowerFinitePadicAuxiliaryTopDecompositionGroup_eq_chosen ++ (K := K) (L := L) v p τ hτ ++ have hσchosen : ++ σE ∈ absoluteValueDecompositionGroup F ++ (chosenFinitePlaceExtension (L := E) V).1 := by ++ rw [← hgroup] ++ exact hσtop ++ have hRange : ++ σE ∈ (chosenFinitePlaceArtinMonoidHom ++ (K := F) (L := E) V).range := by ++ rw [chosenFinitePlaceArtinMonoidHom_range (K := F) (L := E) V] ++ exact hσchosen ++ let y : (V.adicCompletion F)ˣ := Classical.choose hRange ++ have hy : ++ chosenFinitePlaceArtinMonoidHom (K := F) (L := E) V y = ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism ++ (K := K) (L := L) p τ := ++ Classical.choose_spec hRange ++ let z : (v.adicCompletion K)ˣ := ++ LocalFieldTheory.normUnits ++ (v.adicCompletion K) (V.adicCompletion F) y ++ have hz : ++ z = LocalFieldTheory.normUnits ++ (v.adicCompletion K) (V.adicCompletion F) y := by ++ rfl ++ let σK : Gal(L / K) := ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) ++ let restriction : Gal(E / F) →* Gal(L / K) := ++ (AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K) ++ have hrestrict : restriction σE = σK := ++ numberFieldTowerFinitePadicAuxiliaryAutomorphism_restriction ++ (K := K) (L := L) p τ ++ have hlocal : ++ chosenFinitePlaceArtinMonoidHom (K := K) (L := L) v z = ++ σK := by ++ rw [hz] ++ have hnat := ++ DFunLike.congr_fun ++ (chosenFinitePlaceArtinMonoidHom_norm_restriction_of_below_eq ++ (K := K) (L := L) (K' := F) (L' := E) ++ v V hVbelow) y ++ calc ++ chosenFinitePlaceArtinMonoidHom (K := K) (L := L) v ++ (LocalFieldTheory.normUnits ++ (v.adicCompletion K) (V.adicCompletion F) y) = ++ restriction ++ (chosenFinitePlaceArtinMonoidHom (K := F) (L := E) V y) := by ++ simpa only [ ++ MonoidHom.coe_comp, Function.comp_apply, restriction] ++ using hnat.symm ++ _ = restriction σE := congrArg restriction hy ++ _ = σK := hrestrict ++ let j : E →ₐ[ℚ] SeparableClosure ℚ := ++ E.val.restrictScalars ℚ ++ have hjLower : ++ j.comp auxiliaryOriginalTopAlgHom = ++ AlgebraicNumberTheory.numberFieldSeparableClosureEmbedding L := by ++ apply AlgHom.ext ++ intro a ++ exact ++ numberFieldTowerFinitePadicAuxiliaryTopEmbedding_coe ++ (K := K) (L := L) p τ a ++ have hPUnramified : ++ P.toFiniteGaloisExtension.IsUnramified ++ rationalCyclotomicDegreeData := ++ numberFieldTowerFinitePadicAuxiliaryCompositumSubextension_isUnramified ++ (K := K) (L := L) p τ n hn hdegree hprimaryQuotient ++ have hcompat : ++ (globalNormResidueMonoidHomOfEmbedding F E j).comp ++ (IdeleGroup.finitePlaceIdeleClass V) = ++ chosenFinitePlaceArtinMonoidHom (K := F) (L := E) V := ++ globalNormResidueMonoidHomOfEmbedding_comp_finitePlaceIdeleClass_of_abstractFixedFieldUnramified ++ H P hPUnramified V ++ have hupper : ++ globalNormResidueMonoidHomOfEmbedding F E j ++ (IdeleGroup.finitePlaceIdeleClass V y) = ++ σE := ++ (congrArg ++ (fun φ : (V.adicCompletion F)ˣ →* Gal(E / F) => φ y) ++ hcompat).trans hy ++ have hnormClass : ++ _root_.ideleClassNorm K F ++ (IdeleGroup.finitePlaceIdeleClass V y) = ++ IdeleGroup.finitePlaceIdeleClass v z := by ++ rw [hz] ++ simpa only [Vover] using ++ (IdeleGroup.ideleClassNorm_finitePlaceIdeleClass_eq_normUnits ++ (K := K) (L := F) v Vover y) ++ have hglobal : ++ globalNormResidueMonoidHom K L ++ (IdeleGroup.finitePlaceIdeleClass v z) = ++ σK := by ++ calc ++ globalNormResidueMonoidHom K L ++ (IdeleGroup.finitePlaceIdeleClass v z) = ++ globalNormResidueMonoidHom K L ++ (_root_.ideleClassNorm K F ++ (IdeleGroup.finitePlaceIdeleClass V y)) := ++ congrArg (globalNormResidueMonoidHom K L) hnormClass.symm ++ _ = globalNormResidueMonoidHomOfEmbedding K L ++ (j.comp auxiliaryOriginalTopAlgHom) ++ (_root_.ideleClassNorm K F ++ (IdeleGroup.finitePlaceIdeleClass V y)) := by ++ rw [hjLower, ++ ← globalNormResidueMonoidHom_eq_ofEmbedding_standard] ++ _ = ((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)) ++ (globalNormResidueMonoidHomOfEmbedding F E j ++ (IdeleGroup.finitePlaceIdeleClass V y)) := by ++ apply Eq.symm ++ apply ++ globalNormResidueMonoidHomOfEmbedding_norm_restriction_apply ++ _ = ((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)) σE := ++ congrArg ++ ((AlgEquiv.restrictNormalHom L).comp ++ (AlgEquiv.restrictScalarsHom K)) hupper ++ _ = restriction σE := rfl ++ _ = σK := hrestrict ++ exact ⟨z, hlocal, hglobal⟩ ++ ++ ++/-- Every genuine finite-place decomposition automorphism has a ++compatible embedded absolute lift with the same finite quotient class ++and positive integral cyclotomic `p`-adic degree. -/ ++theorem exists_numberFieldTowerFinitePadicLift_of_finitePlace ++ (v : HeightOneSpectrum (𝓞 K)) ++ (p : Nat.Primes) ++ (σ : ++ absoluteValueDecompositionGroup K ++ (chosenFinitePlaceExtension (L := L) v).1) : ++ letI _ : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ letI _ : Algebra L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureTopAlgebra L ++ letI _ : IsScalarTower K L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureScalarTower K L ++ ∃ τ : (numberFieldTowerBaseSubgroup K L).toSubgroup, ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) = ++ σ.1 ∧ ++ (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ ++ absoluteValueDecompositionGroup K ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v ++ (chosenFinitePlaceExtension (L := L) v)).1 ∧ ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ ≠ ++ 1 ∧ ++ ∃ n : ℕ, 0 < n ∧ ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ = ++ (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by ++ let : Algebra K (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureBaseAlgebra K L ++ let : Algebra L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureTopAlgebra L ++ let : IsScalarTower K L (SeparableClosure ℚ) := ++ numberFieldTowerSeparableClosureScalarTower K L ++ obtain ⟨τΩ, hτΩrestrict, n, hn, hτΩdegree⟩ := ++ exists_finitePlaceSeparableClosureLift_with_positivePadicCyclotomicDegree ++ (K := K) (L := L) v p σ ++ let τ : ++ (numberFieldTowerBaseSubgroup K L).toSubgroup := ++ numberFieldTowerSeparableClosureEquivBaseSubgroup ++ K L τΩ.1 ++ have hfinite : ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (numberFieldTowerFiniteQuotientCoordinate ++ (K := K) (L := L) τ) = ++ σ.1 := by ++ change ++ numberFieldTowerExtensionQuotientEquivGaloisGroup K L ++ (QuotientGroup.mk ++ (numberFieldTowerSeparableClosureEquivBaseSubgroup ++ K L τΩ.1)) = ++ σ.1 ++ rw [ ++ numberFieldTowerExtensionQuotientEquivGaloisGroup_mk_baseSubgroupEquiv] ++ exact congrArg Subtype.val hτΩrestrict ++ have hdegree : ++ numberFieldTowerBaseSubgroupPadicCyclotomicDegree ++ (K := K) (L := L) p τ = ++ (Multiplicative.ofAdd (1 : ℤ_[p.1])) ^ n := by ++ exact hτΩdegree ++ have hdecomposition : ++ (numberFieldTowerSeparableClosureEquivBaseSubgroup K L).symm τ ∈ ++ absoluteValueDecompositionGroup K ++ (numberFieldTowerFinitePlaceExtensionToSeparableClosure ++ K L v ++ (chosenFinitePlaceExtension (L := L) v)).1 := by ++ simpa only [τ, MulEquiv.symm_apply_apply] using τΩ.2 ++ refine ++ ⟨τ, hfinite, hdecomposition, ?_, n, hn, hdegree⟩ ++ rw [hdegree] ++ exact ++ PadicInt.multiplicative_positiveNatDegree_ne_one ++ p.1 n hn ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityBase.lean +new file mode 100644 +index 0000000..e5057a1 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityBase.lean +@@ -0,0 +1,488 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalHilbertSymbol.FinitePlaceCharacterComparison ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.FiniteIdeleArtin ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.HilbertProductFormula ++import ClassFieldTheory.AlgebraicNumberTheory.PowerResidueSymbols.Ideal ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.NormApproximation.FinitePlaces ++import Mathlib.NumberTheory.Padics.HeightOneSpectrum ++import ValuedFieldTheory.LocalField.DiscreteValuationField.PadicField ++import ClassFieldTheory.AlgebraicNumberTheory.QuadraticReciprocity ++import ClassFieldTheory.AlgebraicNumberTheory.RayClass.Rational ++import ClassFieldTheory.LocalClassFieldTheory.Kummer.PowerResidueTameFormula ++import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.IdealQuotients ++import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.IdealToCompletion ++import ValuedFieldTheory.Valuation.Completion.ExtensionInvariants ++import ClassFieldTheory.KummerTheory.Concrete.SimpleExtensionLocalBehavior ++import ClassFieldTheory.KummerTheory.Concrete.SUnitPreparation.FiniteRadicalSupport ++import ClassFieldTheory.LocalClassFieldTheory.Finite.CyclotomicNorm.PrincipalUnits ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped BigOperators Classical NumberField NumberTheorySymbols ValuativeRel WithZero ++open NumberField IsDedekindDomain ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open KummerTheory ++open AlgebraicNumberTheory.PowerResidueSymbols ++open LocalClassFieldTheory.Kummer ++open LocalFieldTheory ++open LocalFieldTheory.IsNonarchimedeanLocalField ++ ++variable (K : Type) [Field K] [NumberField K] ++ ++/-- Equality for the valuation used to define a valuative relation transports ++to equality in the relation's canonical value group. -/ ++theorem canonicalValuation_eq_of_valuation_eq ++ {R Γ : Type*} [Ring R] [LinearOrderedCommGroupWithZero Γ] ++ (v : Valuation R Γ) (x y : R) (hxy : v x = v y) : ++ letI : ValuativeRel R := ValuativeRel.ofValuation v ++ ValuativeRel.valuation R x = ValuativeRel.valuation R y := by ++ let : ValuativeRel R := ValuativeRel.ofValuation v ++ change ++ ValuativeRel.ValueGroupWithZero.mk x 1 = ++ ValuativeRel.ValueGroupWithZero.mk y 1 ++ rw [ValuativeRel.ValueGroupWithZero.mk_eq_mk] ++ constructor ++ · change v (x * (1 : R)) ≤ v (y * (1 : R)) ++ simpa only [mul_one] using hxy.le ++ · change v (y * (1 : R)) ≤ v (x * (1 : R)) ++ simpa only [mul_one] using hxy.ge ++ ++/-- The bounded-natural-number form of nonarchimedeanness for a finite-place ++absolute value. Naming this bridge keeps all completion residue constructions ++on one proof-irrelevant provider. -/ ++private theorem finitePlaceAdicAbv_nonarchimedeanAbsoluteValue ++ (v : HeightOneSpectrum (𝓞 K)) : ++ LubinTate.Valuations.NonarchimedeanAbsoluteValue ++ (HeightOneSpectrum.adicAbv K v) := ++ (AbsoluteValue.isNonarchimedean_iff_bounded_nat ++ (HeightOneSpectrum.adicAbv K v)).1 ++ (HeightOneSpectrum.isNonarchimedean_adicAbv K v) ++ ++/-- Finite-field power-residue symbols commute with a field equivalence. ++The statement is made on underlying units so it can be reused with every ++roots-of-unity transport occurring below. -/ ++theorem finiteFieldPowerResidueSymbol_unitsMap_ringEquiv ++ {k l : Type*} [Field k] [Field l] [Fintype k] [Fintype l] ++ (e : k ≃+* l) (n : ℕ+) ++ (hnk : (n : ℕ) ∣ Fintype.card k - 1) ++ (hnl : (n : ℕ) ∣ Fintype.card l - 1) ++ (u : kˣ) : ++ Units.map e.toMonoidHom ++ ((AlgebraicNumberTheory.PowerResidueSymbols.finiteFieldPowerResidueSymbol ++ k n hnk u : ++ rootsOfUnity (n : ℕ) k) : kˣ) = ++ ((AlgebraicNumberTheory.PowerResidueSymbols.finiteFieldPowerResidueSymbol ++ l n hnl ++ (Units.map e.toMonoidHom u) : ++ rootsOfUnity (n : ℕ) l) : lˣ) := by ++ rw [ ++ AlgebraicNumberTheory.PowerResidueSymbols.finiteFieldPowerResidueSymbol_apply, ++ AlgebraicNumberTheory.PowerResidueSymbols.finiteFieldPowerResidueSymbol_apply, ++ map_pow] ++ rw [Fintype.card_congr e.toEquiv] ++ ++/-- The residue field of a finite-place completion is canonically the ++prime-ideal residue field. The construction passes through the localization ++at the prime and then through the residue equivalence induced by completion. -/ ++noncomputable def finitePlacePrimeResidueEquivLocalResidue ++ (v : HeightOneSpectrum (𝓞 K)) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ (𝓞 K ⧸ v.asIdeal) ≃+* 𝓀[C] := by ++ let a := HeightOneSpectrum.adicAbv K v ++ let ha : LubinTate.Valuations.NonarchimedeanAbsoluteValue a := ++ finitePlaceAdicAbv_nonarchimedeanAbsoluteValue K v ++ let C := a.Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ let V := LubinTate.Valuations.exponentialValuationSubring ++ (AlgebraicNumberTheory.Valuations.absoluteValueExponentialValuation a ha) ++ let aC := AbsoluteValue.completionAbsoluteValue a ++ let haC : LubinTate.Valuations.NonarchimedeanAbsoluteValue aC := ++ (AbsoluteValue.isNonarchimedean_iff_bounded_nat aC).1 ++ (AbsoluteValue.completionAbsoluteValue_isNonarchimedean a ++ ((AbsoluteValue.isNonarchimedean_iff_bounded_nat a).2 ha)) ++ let VC := LubinTate.Valuations.exponentialValuationSubring ++ (AlgebraicNumberTheory.Valuations.absoluteValueExponentialValuation aC haC) ++ let Rv := v.valuationSubringAtPrime K ++ letI : IsLocalRing Rv := ++ IsLocalization.AtPrime.isLocalRing Rv v.asIdeal ++ have hBase : Rv.toSubring = V := by ++ ext x ++ rw [AlgebraicNumberTheory.Valuations.mem_absoluteValueExponentialSubring_iff] ++ change x ∈ v.valuationSubringAtPrime K ↔ _ ++ rw [v.valuationSubringAtPrime_eq_valuationSubring] ++ change v.valuation K x ≤ 1 ↔ a x ≤ 1 ++ rw [HeightOneSpectrum.adicAbv_def] ++ exact_mod_cast ++ (WithZeroMulInt.toNNReal_le_one_iff ++ (HeightOneSpectrum.one_lt_absNorm_nnreal v)).symm ++ let eBase : Rv ≃+* V := RingEquiv.subringCongr hBase ++ have hCompletion : VC = 𝒪[C] := by ++ ext x ++ rw [AlgebraicNumberTheory.Valuations.mem_absoluteValueExponentialSubring_iff] ++ change ‖x‖ ≤ 1 ↔ x ∈ 𝒪[C] ++ exact ++ (finitePlaceCompletion_mem_integers_iff_norm_le_one ++ a (HeightOneSpectrum.isNonarchimedean_adicAbv K v) x).symm ++ let eCompletionRing : VC ≃+* 𝒪[C] := ++ RingEquiv.subringCongr hCompletion ++ let eIdeal : (𝓞 K ⧸ v.asIdeal) ≃+* v.asIdeal.ResidueField := ++ RingEquiv.ofBijective ++ (algebraMap (𝓞 K ⧸ v.asIdeal) v.asIdeal.ResidueField) ++ v.asIdeal.bijective_algebraMap_quotient_residueField ++ let eLocalization : Localization.AtPrime v.asIdeal ≃ₐ[𝓞 K] Rv := ++ IsLocalization.algEquiv v.asIdeal.primeCompl _ _ ++ exact ++ eIdeal |>.trans ++ (IsLocalRing.ResidueField.mapEquiv eLocalization.toRingEquiv) |>.trans ++ (IsLocalRing.ResidueField.mapEquiv eBase) |>.trans ++ (AlgebraicNumberTheory.Valuations.completionResidueEquiv a ha) |>.trans ++ (IsLocalRing.ResidueField.mapEquiv eCompletionRing) ++ ++/-- The image of an algebraic integer in the valuation ring of a finite-place ++completion. -/ ++noncomputable def finitePlaceIntegralCompletionElement ++ (v : HeightOneSpectrum (𝓞 K)) (x : 𝓞 K) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ 𝒪[C] := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ exact ⟨algebraMap K C (x : K), by ++ rw [finitePlaceCompletion_mem_integers_iff_norm_le_one ++ (HeightOneSpectrum.adicAbv K v) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv K v)] ++ calc ++ ‖algebraMap K C (x : K)‖ = ++ HeightOneSpectrum.adicAbv K v (x : K) := ++ AbsoluteValue.completionAbsoluteValue_coe ++ (HeightOneSpectrum.adicAbv K v) (x : K) ++ _ ≤ 1 := ++ v.adicAbv_coe_le_one ++ (HeightOneSpectrum.one_lt_absNorm_nnreal v) x⟩ ++ ++/-- The finite-place integral element has the expected underlying completion ++value. -/ ++@[simp] ++theorem finitePlaceIntegralCompletionElement_coe ++ (v : HeightOneSpectrum (𝓞 K)) (x : 𝓞 K) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ (finitePlaceIntegralCompletionElement K v x : C) = ++ algebraMap K C (x : K) := ++ rfl ++ ++/-- The finite-place residue equivalence sends the class of an algebraic ++integer to the residue of its canonical image in the completion. -/ ++@[simp] ++theorem finitePlacePrimeResidueEquivLocalResidue_mk ++ (v : HeightOneSpectrum (𝓞 K)) (x : 𝓞 K) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ finitePlacePrimeResidueEquivLocalResidue K v ++ (Ideal.Quotient.mk v.asIdeal x) = ++ IsLocalRing.residue 𝒪[C] ++ (finitePlaceIntegralCompletionElement K v x) := by ++ simp only [finitePlacePrimeResidueEquivLocalResidue, ++ finitePlaceIntegralCompletionElement, RingEquiv.trans_apply] ++ rw [RingEquiv.ofBijective_apply, ++ Ideal.algebraMap_quotient_residueField_mk] ++ rw [IsScalarTower.algebraMap_apply ++ (NumberField.RingOfIntegers K) (Localization.AtPrime v.asIdeal)] ++ rw [IsLocalRing.ResidueField.algebraMap_eq] ++ simp only [IsLocalRing.ResidueField.mapEquiv_apply, ++ IsLocalRing.ResidueField.map_residue] ++ rw [AlgebraicNumberTheory.Valuations.completionResidueEquiv_residue] ++ simp only [IsLocalRing.ResidueField.map_residue] ++ congr 1 ++ apply Subtype.ext ++ change ++ algebraMap K (HeightOneSpectrum.adicAbv K v).Completion ++ (((IsLocalization.algEquiv v.asIdeal.primeCompl ++ (Localization.AtPrime v.asIdeal) ++ (v.valuationSubringAtPrime K)) ++ (algebraMap (𝓞 K) (Localization.AtPrime v.asIdeal) x) : ++ v.valuationSubringAtPrime K) : K) = ++ algebraMap K (HeightOneSpectrum.adicAbv K v).Completion (x : K) ++ rw [AlgEquiv.commutes] ++ rw [IsScalarTower.algebraMap_apply ++ (NumberField.RingOfIntegers K) (v.valuationSubringAtPrime K)] ++ rfl ++ ++/-- A nonzero algebraic integer, regarded as a global field unit. -/ ++def nonzeroIntegralFieldUnit (x : 𝓞 K) (hx : x ≠ 0) : Kˣ := ++ Units.mk0 (x : K) (by ++ intro hxK ++ apply hx ++ apply Subtype.ext ++ exact hxK) ++ ++omit [NumberField K] in ++@[simp] ++theorem nonzeroIntegralFieldUnit_coe (x : 𝓞 K) (hx : x ≠ 0) : ++ ((nonzeroIntegralFieldUnit K x hx : Kˣ) : K) = (x : K) := ++ rfl ++ ++/-- An algebraic integer avoiding a prime ideal, regarded as a nonzero ++element of the global field. -/ ++noncomputable def primeAvoidingIntegralFieldUnit ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : Kˣ := ++ nonzeroIntegralFieldUnit K x (by ++ intro hx0 ++ apply hx ++ rw [hx0] ++ exact Ideal.zero_mem _) ++ ++omit [NumberField K] in ++@[simp] ++theorem primeAvoidingIntegralFieldUnit_coe ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : ++ ((primeAvoidingIntegralFieldUnit K v x hx : Kˣ) : K) = (x : K) := ++ rfl ++ ++/-- An algebraic integer nonzero modulo `v`, regarded as a unit of the ++valuation ring of the finite-place completion. -/ ++noncomputable def finitePlaceIntegralCompletionUnit ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ 𝒪[C]ˣ := by ++ let a := HeightOneSpectrum.adicAbv K v ++ let C := a.Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ let y : C := algebraMap K C (x : K) ++ have hyNorm : ‖y‖ = 1 := by ++ calc ++ ‖y‖ = a (x : K) := ++ AbsoluteValue.completionAbsoluteValue_coe a (x : K) ++ _ = ‖NumberField.FinitePlace.embedding v (x : K)‖ := ++ (NumberField.FinitePlace.norm_embedding v (x : K)).symm ++ _ = 1 := ++ (NumberField.FinitePlace.norm_eq_one_iff_notMem K v x).2 hx ++ have hyNe : y ≠ 0 := by ++ intro hy ++ rw [hy, norm_zero] at hyNorm ++ exact zero_ne_one hyNorm ++ let yIntegral : 𝒪[C] := ⟨y, by ++ rw [finitePlaceCompletion_mem_integers_iff_norm_le_one ++ a (HeightOneSpectrum.isNonarchimedean_adicAbv K v)] ++ exact hyNorm.le⟩ ++ let yInvIntegral : 𝒪[C] := ⟨y⁻¹, by ++ rw [finitePlaceCompletion_mem_integers_iff_norm_le_one ++ a (HeightOneSpectrum.isNonarchimedean_adicAbv K v), ++ norm_inv, hyNorm, inv_one]⟩ ++ exact { ++ val := yIntegral ++ inv := yInvIntegral ++ val_inv := by ++ apply Subtype.ext ++ exact mul_inv_cancel₀ hyNe ++ inv_val := by ++ apply Subtype.ext ++ exact inv_mul_cancel₀ hyNe } ++ ++/-- Forgetting the integral-unit structure recovers the ordinary image of ++the algebraic integer in the finite-place completion. -/ ++@[simp] ++theorem finitePlaceIntegralCompletionUnit_coe ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ (((finitePlaceIntegralCompletionUnit K v x hx : 𝒪[C]ˣ) : 𝒪[C]) : C) = ++ algebraMap K C (x : K) := by ++ rfl ++ ++/-- The completion image of a prime-avoiding algebraic integer is the field ++unit underlying its canonical valuation-ring unit. -/ ++theorem finitePlaceHilbert_completionUnit_primeAvoidingIntegralFieldUnit ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ finitePlaceHilbert_completionUnit K v ++ (primeAvoidingIntegralFieldUnit K v x hx) = ++ integerUnitsToFieldUnits C ++ (finitePlaceIntegralCompletionUnit K v x hx) := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ let : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ let : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ dsimp only ++ apply Units.ext ++ change ++ algebraMap K C (x : K) = ++ (((finitePlaceIntegralCompletionUnit K v x hx : 𝒪[C]ˣ) : ++ 𝒪[C]) : C) ++ exact (finitePlaceIntegralCompletionUnit_coe K v x hx).symm ++ ++/-- As an element of the completion valuation ring, the lifted unit is the ++canonical lifted algebraic integer. -/ ++@[simp] ++theorem finitePlaceIntegralCompletionUnit_val ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ (finitePlaceIntegralCompletionUnit K v x hx : 𝒪[C]) = ++ finitePlaceIntegralCompletionElement K v x := by ++ dsimp only ++ apply Subtype.ext ++ exact finitePlaceIntegralCompletionUnit_coe K v x hx ++ ++/-- Reduction of the canonical completion unit agrees with reduction modulo ++the corresponding global prime ideal. -/ ++theorem finitePlace_integerUnitsToResidueUnits_integralUnit ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ integerUnitsToResidueUnits C ++ (finitePlaceIntegralCompletionUnit K v x hx) = ++ Units.map ++ (finitePlacePrimeResidueEquivLocalResidue K v).toMonoidHom ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealResidueUnit ++ K v x hx) := by ++ dsimp only ++ apply Units.ext ++ change ++ IsLocalRing.residue 𝒪[(HeightOneSpectrum.adicAbv K v).Completion] ++ (finitePlaceIntegralCompletionUnit K v x hx : ++ 𝒪[(HeightOneSpectrum.adicAbv K v).Completion]) = ++ finitePlacePrimeResidueEquivLocalResidue K v ++ (Ideal.Quotient.mk v.asIdeal x) ++ simpa only [finitePlaceIntegralCompletionUnit_val] using ++ (finitePlacePrimeResidueEquivLocalResidue_mk K v x).symm ++ ++/-- The canonical inclusion from integral roots of unity into the common ++field-valued group used by the global Hilbert symbols. -/ ++def integralRootsOfUnityToNthRoots ++ (n : ℕ) : ++ rootsOfUnity n (𝓞 K) →* nthRootsSubgroup K n where ++ toFun z := ++ ⟨Units.map (algebraMap (𝓞 K) K).toMonoidHom z.1, by ++ calc ++ Units.map (algebraMap (𝓞 K) K).toMonoidHom z.1 ^ n = ++ Units.map (algebraMap (𝓞 K) K).toMonoidHom (z.1 ^ n) := ++ (map_pow ++ (Units.map (algebraMap (𝓞 K) K).toMonoidHom) z.1 n).symm ++ _ = 1 := by rw [z.2, map_one]⟩ ++ map_one' := by ++ apply Subtype.ext ++ exact map_one (Units.map (algebraMap (𝓞 K) K).toMonoidHom) ++ map_mul' := by ++ intro z w ++ apply Subtype.ext ++ exact map_mul ++ (Units.map (algebraMap (𝓞 K) K).toMonoidHom) z.1 w.1 ++ ++omit [NumberField K] in ++/-- The integral-root inclusion is the underlying unit map. -/ ++@[simp] ++theorem integralRootsOfUnityToNthRoots_apply ++ (n : ℕ) (z : rootsOfUnity n (𝓞 K)) : ++ (integralRootsOfUnityToNthRoots K n z).1 = ++ Units.map (algebraMap (𝓞 K) K).toMonoidHom z.1 := ++ rfl ++ ++omit [NumberField K] in ++/-- The integral-to-field inclusion is injective on roots of unity. -/ ++theorem integralRootsOfUnityToNthRoots_injective ++ (n : ℕ) : ++ Function.Injective (integralRootsOfUnityToNthRoots K n) := by ++ intro z w h ++ apply Subtype.ext ++ apply ++ (Units.map_injective ++ (f := (algebraMap (𝓞 K) K).toMonoidHom) ++ RingOfIntegers.coe_injective) ++ exact congrArg Subtype.val h ++ ++/-- Reduction after embedding an integral global root of unity into a ++finite-place completion is the transport of reduction modulo the ++corresponding prime ideal. -/ ++theorem finitePlace_localNthRootsReduction_integralRoots ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (z : rootsOfUnity (n : ℕ) (𝓞 K)) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ (localNthRootsReduction C n ++ (nthRootsSubgroupMap K C (n : ℕ) ++ (integralRootsOfUnityToNthRoots K (n : ℕ) z))).1 = ++ Units.map ++ (finitePlacePrimeResidueEquivLocalResidue K v).toMonoidHom ++ (AlgebraicNumberTheory.PowerResidueSymbols.rootsOfUnityReduction ++ K v (n : ℕ) z).1 := by ++ dsimp only ++ apply Units.ext ++ change ++ IsLocalRing.residue 𝒪[(HeightOneSpectrum.adicAbv K v).Completion] ++ (nthRootIntegerUnit ++ (HeightOneSpectrum.adicAbv K v).Completion n ++ (nthRootsSubgroupMap K ++ (HeightOneSpectrum.adicAbv K v).Completion (n : ℕ) ++ (integralRootsOfUnityToNthRoots K (n : ℕ) z)) : ++ 𝒪[(HeightOneSpectrum.adicAbv K v).Completion]) = ++ finitePlacePrimeResidueEquivLocalResidue K v ++ (Ideal.Quotient.mk v.asIdeal (z.1 : 𝓞 K)) ++ rw [finitePlacePrimeResidueEquivLocalResidue_mk] ++ congr 1 ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityCorrection.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityCorrection.lean +new file mode 100644 +index 0000000..83cbaaa +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityCorrection.lean +@@ -0,0 +1,452 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.PowerResidueReciprocityLocalSymbols ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalHilbertSymbol.FinitePlaceCharacterComparison ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.FiniteIdeleArtin ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.HilbertProductFormula ++import ClassFieldTheory.AlgebraicNumberTheory.PowerResidueSymbols.Ideal ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.NormApproximation.FinitePlaces ++import Mathlib.NumberTheory.Padics.HeightOneSpectrum ++import ValuedFieldTheory.LocalField.DiscreteValuationField.PadicField ++import ClassFieldTheory.AlgebraicNumberTheory.QuadraticReciprocity ++import ClassFieldTheory.AlgebraicNumberTheory.RayClass.Rational ++import ClassFieldTheory.LocalClassFieldTheory.Kummer.PowerResidueTameFormula ++import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.IdealQuotients ++import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.IdealToCompletion ++import ValuedFieldTheory.Valuation.Completion.ExtensionInvariants ++import ClassFieldTheory.KummerTheory.Concrete.SimpleExtensionLocalBehavior ++import ClassFieldTheory.KummerTheory.Concrete.SUnitPreparation.FiniteRadicalSupport ++import ClassFieldTheory.LocalClassFieldTheory.Finite.CyclotomicNorm.PrincipalUnits ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped BigOperators Classical NumberField NumberTheorySymbols ValuativeRel WithZero ++open NumberField IsDedekindDomain ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open KummerTheory ++open AlgebraicNumberTheory.PowerResidueSymbols ++open LocalClassFieldTheory.Kummer ++open LocalFieldTheory ++open LocalFieldTheory.IsNonarchimedeanLocalField ++ ++variable (K : Type) [Field K] [NumberField K] ++/-- Prime avoidance is the common special case of the integral valuation ++formula used for numerator units. -/ ++theorem finitePlaceNormalizedValuation_primeAvoidingIntegralFieldUnit ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ∉ v.asIdeal) : ++ finitePlaceNormalizedValuation K v ++ (primeAvoidingIntegralFieldUnit K v x hx) = ++ -(AlgebraicNumberTheory.PowerResidueSymbols.idealPrimeMultiplicity K v (Ideal.span {x}) : ℤ) := by ++ let hx0 : x ≠ 0 := by ++ intro hxzero ++ apply hx ++ rw [hxzero] ++ exact Ideal.zero_mem _ ++ change finitePlaceNormalizedValuation K v ++ (nonzeroIntegralFieldUnit K x hx0) = _ ++ exact finitePlaceNormalizedValuation_nonzeroIntegralFieldUnit K v x hx0 ++ ++/-- Integral form of the finite-place comparison: the exponent is the ++Dedekind multiplicity in the principal denominator ideal. -/ ++theorem finitePlaceHilbertSymbol_integral_eq_primeIdealPowerResidueFactor ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a b : 𝓞 K) (ha0 : a ≠ 0) (hb0 : b ≠ 0) ++ (ha : a ∉ v.asIdeal) : ++ finitePlaceHilbertSymbol K n hnK hmu v ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0) = ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha) ^ ++ AlgebraicNumberTheory.PowerResidueSymbols.idealPrimeMultiplicity K v (Ideal.span {b}) := by ++ have haUnits : ++ nonzeroIntegralFieldUnit K a ha0 = ++ primeAvoidingIntegralFieldUnit K v a ha := by ++ apply Units.ext ++ rfl ++ rw [haUnits, ++ finitePlaceHilbertSymbol_eq_primeIdealPowerResidueFactor ++ K n hnK hmu v hv hcoprime a ha ++ (nonzeroIntegralFieldUnit K b hb0), ++ finitePlaceNormalizedValuation_nonzeroIntegralFieldUnit] ++ simp only [neg_neg, zpow_natCast] ++ ++/-- Finite-place Hilbert symbols inherit skew symmetry from the local ++Hilbert symbol in the canonical completion. -/ ++theorem finitePlaceHilbertSymbol_skew ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (v : HeightOneSpectrum (𝓞 K)) (a b : Kˣ) : ++ finitePlaceHilbertSymbol K n hnK hmu v a b = ++ (finitePlaceHilbertSymbol K n hnK hmu v b a)⁻¹ := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ let : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ let : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ apply nthRootsSubgroupMap_injective K C (n : ℕ) ++ rw [map_inv, ++ finitePlaceHilbertSymbol_map_eq_localHilbertSymbol, ++ finitePlaceHilbertSymbol_map_eq_localHilbertSymbol] ++ exact ++ localHilbertSymbol_skew C n ++ (finitePlaceHilbert_natCast_ne_zero K n hnK v) ++ (finitePlaceHilbert_primitiveRoots_nonempty K n hmu v) ++ (finitePlaceHilbert_completionUnit K v a) ++ (finitePlaceHilbert_completionUnit K v b) ++ ++/-- If two nonzero algebraic integers are both units at a finite place, the ++corresponding finite-place Hilbert symbol is trivial. -/ ++theorem finitePlaceHilbertSymbol_integral_units_eq_one ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (a b : 𝓞 K) (ha0 : a ≠ 0) (hb0 : b ≠ 0) ++ (ha : a ∉ v.asIdeal) (hb : b ∉ v.asIdeal) : ++ finitePlaceHilbertSymbol K n hnK hmu v ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0) = 1 := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ let : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ let : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ apply nthRootsSubgroupMap_injective K C (n : ℕ) ++ rw [map_one, finitePlaceHilbertSymbol_map_eq_localHilbertSymbol] ++ have haUnits : ++ finitePlaceHilbert_completionUnit K v ++ (nonzeroIntegralFieldUnit K a ha0) = ++ integerUnitsToFieldUnits C ++ (finitePlaceIntegralCompletionUnit K v a ha) := by ++ apply Units.ext ++ change ++ algebraMap K C (a : K) = ++ (((finitePlaceIntegralCompletionUnit K v a ha : 𝒪[C]ˣ) : ++ 𝒪[C]) : C) ++ exact (finitePlaceIntegralCompletionUnit_coe K v a ha).symm ++ have hbUnits : ++ finitePlaceHilbert_completionUnit K v ++ (nonzeroIntegralFieldUnit K b hb0) = ++ integerUnitsToFieldUnits C ++ (finitePlaceIntegralCompletionUnit K v b hb) := by ++ apply Units.ext ++ change ++ algebraMap K C (b : K) = ++ (((finitePlaceIntegralCompletionUnit K v b hb : 𝒪[C]ˣ) : ++ 𝒪[C]) : C) ++ exact (finitePlaceIntegralCompletionUnit_coe K v b hb).symm ++ unfold finitePlaceLocalHilbertSymbol ++ rw [haUnits, hbUnits] ++ exact ++ localHilbertSymbol_integerUnit_integerUnit_eq_one C n ++ (finitePlace_natCast_valuation_eq_one_of_not_mem_exponent K n v hv) ++ (finitePlaceHilbert_primitiveRoots_nonempty K n hmu v) ++ (finitePlaceIntegralCompletionUnit K v a ha) ++ (finitePlaceIntegralCompletionUnit K v b hb) ++ ++/-- Primewise comparison between the tame finite-place Hilbert factor and ++the quotient of the two ideal power-residue factors. -/ ++theorem powerResidueAwayFromExponentFiniteFactor_integral_eq_idealFactors ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : 𝓞 K) (ha0 : a ≠ 0) (hb0 : b ≠ 0) ++ (hcoprimeA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → ++ (Ideal.absNorm P.asIdeal).Coprime (n : ℕ)) ++ (hcoprimeB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → ++ (Ideal.absNorm P.asIdeal).Coprime (n : ℕ)) ++ (haB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → a ∉ P.asIdeal) ++ (hbA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → b ∉ P.asIdeal) ++ (hAwayA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → ++ P ∉ powerResidueExponentFinitePlaces K n) ++ (hAwayB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → ++ P ∉ powerResidueExponentFinitePlaces K n) ++ (P : HeightOneSpectrum (𝓞 K)) : ++ (if P ∈ powerResidueExponentFinitePlaces K n then ++ 1 ++ else ++ finitePlaceHilbertSymbol K n hnK hmu P ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0)) = ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueFactor K (Ideal.span {b}) n hmu a ++ hcoprimeB haB P) * ++ (integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueFactor K (Ideal.span {a}) n hmu b ++ hcoprimeA hbA P))⁻¹ := by ++ by_cases hPExponent : P ∈ powerResidueExponentFinitePlaces K n ++ · have hPA : ¬ P.asIdeal ∣ Ideal.span {a} := by ++ intro hPA ++ exact (hAwayA P hPA) hPExponent ++ have hPB : ¬ P.asIdeal ∣ Ideal.span {b} := by ++ intro hPB ++ exact (hAwayB P hPB) hPExponent ++ simp only [ite_eq_left hPExponent, idealPowerResidueFactor, ++ dite_eq_right hPA, dite_eq_right hPB, map_one, inv_one, mul_one] ++ · rw [ite_eq_right hPExponent] ++ by_cases hPB : P.asIdeal ∣ Ideal.span {b} ++ · have haP : a ∉ P.asIdeal := haB P hPB ++ have hPA : ¬ P.asIdeal ∣ Ideal.span {a} := by ++ intro hPA ++ apply haP ++ rw [← Ideal.dvd_span_singleton] ++ exact hPA ++ rw [finitePlaceHilbertSymbol_integral_eq_primeIdealPowerResidueFactor ++ K n hnK hmu P (hAwayB P hPB) (hcoprimeB P hPB) ++ a b ha0 hb0 haP] ++ simp only [idealPowerResidueFactor, dite_eq_left hPB, dite_eq_right hPA, ++ map_pow, map_one, inv_one, mul_one] ++ · by_cases hPA : P.asIdeal ∣ Ideal.span {a} ++ · have hbP : b ∉ P.asIdeal := hbA P hPA ++ rw [finitePlaceHilbertSymbol_skew K n hnK hmu] ++ rw [finitePlaceHilbertSymbol_integral_eq_primeIdealPowerResidueFactor ++ K n hnK hmu P (hAwayA P hPA) (hcoprimeA P hPA) ++ b a hb0 ha0 hbP] ++ simp only [idealPowerResidueFactor, dite_eq_right hPB, dite_eq_left hPA, ++ map_pow, map_one, one_mul] ++ · have haP : a ∉ P.asIdeal := by ++ intro haMem ++ apply hPA ++ rw [Ideal.dvd_span_singleton] ++ exact haMem ++ have hbP : b ∉ P.asIdeal := by ++ intro hbMem ++ apply hPB ++ rw [Ideal.dvd_span_singleton] ++ exact hbMem ++ rw [finitePlaceHilbertSymbol_integral_units_eq_one ++ K n hnK hmu P hPExponent a b ha0 hb0 haP hbP] ++ simp only [idealPowerResidueFactor, dite_eq_right hPB, dite_eq_right hPA, ++ map_one, inv_one, mul_one] ++ ++/-- A concrete finite set containing every finite place where a local ++power-residue factor of `a` and `b` may be nontrivial. Its exponent part is ++the exact set of prime divisors of `(n)`. -/ ++noncomputable def powerResidueBadFinitePlaces ++ (n : ℕ+) (a b : Kˣ) : ++ Finset (HeightOneSpectrum (𝓞 K)) := ++ (chosenUnitFiniteSupport (K := K) a ∪ ++ chosenUnitFiniteSupport (K := K) b) ∪ ++ powerResidueExponentFinitePlaces K n ++ ++/-- The explicit bad-place correction in power-residue reciprocity. Every ++factor already lies in the common group `nthRootsSubgroup K n`. -/ ++noncomputable def powerResidueBadPlaceCorrection ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) : ++ nthRootsSubgroup K (n : ℕ) := ++ (∏ v : InfinitePlace K, ++ infinitePlaceHilbertSymbol K n v a b) * ++ (∏ v ∈ powerResidueExponentFinitePlaces K n, ++ finitePlaceHilbertSymbol K n hnK hmu v a b) ++ ++private theorem valuation_eq_one_of_not_mem_chosenUnitFiniteSupport ++ (x : Kˣ) (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ chosenUnitFiniteSupport (K := K) x) : ++ v.valuation K (x : K) = 1 := ++ (mem_SUnitGroup_iff (K := K) ++ (chosenUnitFiniteSupport (K := K) x) x).mp ++ (mem_sUnitGroup_chosenUnitFiniteSupport (K := K) x) v hv ++ ++/-- The finite-place Hilbert symbol is trivial when the exponent and both ++global arguments are units at this place. -/ ++theorem finitePlaceHilbertSymbol_eq_one_of_valuation_eq_one ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) (v : HeightOneSpectrum (𝓞 K)) ++ (hva : v.valuation K (a : K) = 1) ++ (hvb : v.valuation K (b : K) = 1) ++ (hvn : v.valuation K ((n : ℕ) : K) = 1) : ++ finitePlaceHilbertSymbol K n hnK hmu v a b = 1 := by ++ let L := chosenSimpleKummerExtension K n hnK b ++ let : FiniteDimensional K L := ++ chosenSimpleKummerExtension_finiteDimensional K n hnK b ++ let : IsAbelianGalois K L := ++ chosenSimpleKummerExtension_isAbelianGalois K n hnK hmu b ++ let : NumberField L := NumberField.of_module_finite K L ++ have haIntegral : ++ IdeleGroup.finiteComponent v (IdeleGroup.principalIdele K a) ∈ ++ (v.adicCompletionIntegers K).units := by ++ rw [HeightOneSpectrum.adicCompletionIntegers.mem_units_iff_valued_eq_one] ++ rw [IdeleGroup.finiteComponent_principalIdele, ++ HeightOneSpectrum.valuedAdicCompletion_eq_valuation'] ++ exact hva ++ have hUnramified : ++ Algebra.IsUnramifiedAt (𝓞 K) ++ (finitePlaceExtensionCentre ++ (K := K) (L := L) v ++ (chosenFinitePlaceExtension (L := L) v)).asIdeal := by ++ apply ++ chosenSimpleKummerExtension_isUnramifiedAt_at_all_finitePlacesAbove_of_valuation_eq_one ++ (K := K) n hnK hmu b v hvb hvn ++ exact ++ finitePlaceBelow_finitePlaceExtensionCentre ++ (K := K) (L := L) v ++ (chosenFinitePlaceExtension (L := L) v) ++ have hArtin : ++ chosenFinitePlaceArtinMonoidHom (K := K) (L := L) v ++ (IdeleGroup.finiteComponent v (IdeleGroup.principalIdele K a)) = 1 := ++ chosenFinitePlaceArtinMonoidHom_eq_one_of_integral_of_unramifiedAt ++ (K := K) (L := L) v (IdeleGroup.principalIdele K a) ++ haIntegral hUnramified ++ rw [← finitePlaceKummerRootCharacter_localGlobal K n hnK hmu v a b] ++ unfold finitePlaceKummerRootCharacter ++ unfold finitePlaceKummerRootCharacterOfExtension ++ have hcomponent : ++ (IdeleGroup.finiteComponent v (IdeleGroup.principalIdele K a) : ++ (v.adicCompletion K)ˣ) = ++ Units.map (algebraMap K (v.adicCompletion K)).toMonoidHom a := by ++ apply Units.ext ++ calc ++ ((IdeleGroup.finiteComponent v (IdeleGroup.principalIdele K a) : ++ (v.adicCompletion K)ˣ) : v.adicCompletion K) = ++ ((a : K) : v.adicCompletion K) := ++ IdeleGroup.finiteComponent_principalIdele a v ++ _ = algebraMap K (v.adicCompletion K) (a : K) := by ++ symm ++ have hmap := congrFun ++ (IsDedekindDomain.HeightOneSpectrum.algebraMap_adicCompletion ++ (R := 𝓞 K) (S := K) (K := K) (v := v)) (a : K) ++ simpa using hmap ++ rw [hcomponent] at hArtin ++ unfold chosenFinitePlaceArtinMonoidHom at hArtin ++ dsimp only at hArtin ⊢ ++ rw [hArtin, map_one, map_one] ++ ++/-- Outside the concrete bad-place set, the finite-place Hilbert factor is ++trivial. -/ ++theorem finitePlaceHilbertSymbol_eq_one_of_not_mem_powerResidueBadFinitePlaces ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ powerResidueBadFinitePlaces K n a b) : ++ finitePlaceHilbertSymbol K n hnK hmu v a b = 1 := by ++ have hvaSupport : v ∉ chosenUnitFiniteSupport (K := K) a := by ++ intro hva ++ apply hv ++ exact Finset.mem_union_left _ (Finset.mem_union_left _ hva) ++ have hvbSupport : v ∉ chosenUnitFiniteSupport (K := K) b := by ++ intro hvb ++ apply hv ++ exact Finset.mem_union_left _ (Finset.mem_union_right _ hvb) ++ have hvnSupport : ++ v ∉ powerResidueExponentFinitePlaces K n := by ++ intro hvn ++ apply hv ++ exact Finset.mem_union_right _ hvn ++ have hva : v.valuation K (a : K) = 1 := ++ valuation_eq_one_of_not_mem_chosenUnitFiniteSupport K a v hvaSupport ++ have hvb : v.valuation K (b : K) = 1 := ++ valuation_eq_one_of_not_mem_chosenUnitFiniteSupport K b v hvbSupport ++ have hvn : v.valuation K ((n : ℕ) : K) = 1 := by ++ have hvnNotDvd : ++ ¬ v.asIdeal ∣ powerResidueExponentIdeal K n := by ++ simpa only [mem_powerResidueExponentFinitePlaces_iff] using hvnSupport ++ have hvnNotMem : ((n : ℕ) : 𝓞 K) ∉ v.asIdeal := by ++ intro hvnMem ++ apply hvnNotDvd ++ rw [powerResidueExponentIdeal, Ideal.dvd_span_singleton] ++ exact hvnMem ++ simpa only [map_natCast] using ++ (v.valuation_eq_one_iff_notMem (K := K) ++ (r := ((n : ℕ) : 𝓞 K))).2 hvnNotMem ++ exact finitePlaceHilbertSymbol_eq_one_of_valuation_eq_one ++ K n hnK hmu a b v hva hvb hvn ++ ++/-- The multiplicative support of the finite-place Hilbert factors is ++contained in the explicit power-residue bad-place set. -/ ++theorem finitePlaceHilbertSymbol_mulSupport_subset_powerResidueBadFinitePlaces ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) : ++ Function.mulSupport ++ (fun v : HeightOneSpectrum (𝓞 K) => ++ finitePlaceHilbertSymbol K n hnK hmu v a b) ⊆ ++ (powerResidueBadFinitePlaces K n a b : ++ Set (HeightOneSpectrum (𝓞 K))) := by ++ intro v hv ++ change finitePlaceHilbertSymbol K n hnK hmu v a b ≠ 1 at hv ++ change v ∈ powerResidueBadFinitePlaces K n a b ++ by_contra hvBad ++ exact hv ++ (finitePlaceHilbertSymbol_eq_one_of_not_mem_powerResidueBadFinitePlaces ++ K n hnK hmu a b v hvBad) ++ ++/-- The finite-place Hilbert `finprod` is the ordinary product over the ++explicit bad-place set. -/ ++theorem finitePlaceHilbertSymbol_finprod_eq_prod_powerResidueBadFinitePlaces ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) : ++ (∏ᶠ v : HeightOneSpectrum (𝓞 K), ++ finitePlaceHilbertSymbol K n hnK hmu v a b) = ++ ∏ v ∈ powerResidueBadFinitePlaces K n a b, ++ finitePlaceHilbertSymbol K n hnK hmu v a b := by ++ rw [finprod_eq_prod_of_mulSupport_subset _ ++ (finitePlaceHilbertSymbol_mulSupport_subset_powerResidueBadFinitePlaces ++ K n hnK hmu a b)] ++ ++/-- Finite-set form of the Hilbert product formula: the product over all ++explicitly bad finite places is the inverse of the infinite-place product. -/ ++theorem powerResidueBadFinitePlaces_product_eq_infinitePlaceProduct_inv ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) : ++ (∏ v ∈ powerResidueBadFinitePlaces K n a b, ++ finitePlaceHilbertSymbol K n hnK hmu v a b) = ++ (∏ v : InfinitePlace K, ++ infinitePlaceHilbertSymbol K n v a b)⁻¹ := by ++ have hproduct := ++ hilbertSymbol_allPlaces_product_eq_one K n hnK hmu a b ++ rw [ ++ finitePlaceHilbertSymbol_finprod_eq_prod_powerResidueBadFinitePlaces] ++ at hproduct ++ exact (eq_inv_iff_mul_eq_one).2 (by ++ simpa only [mul_comm] using hproduct) ++ ++/-- The product of the finite-place Hilbert factors away from primes dividing ++the exponent. C1 identifies this term with the quotient of the two ideal ++power-residue symbols; the remaining factors are exactly the correction. -/ ++noncomputable def powerResidueAwayFromExponentFiniteProduct ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) : ++ nthRootsSubgroup K (n : ℕ) := ++ ∏ᶠ v : HeightOneSpectrum (𝓞 K), ++ if v ∈ powerResidueExponentFinitePlaces K n then ++ 1 ++ else ++ finitePlaceHilbertSymbol K n hnK hmu v a b ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityGlobal.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityGlobal.lean +new file mode 100644 +index 0000000..8a60735 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityGlobal.lean +@@ -0,0 +1,416 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.PowerResidueReciprocityCorrection ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalHilbertSymbol.FinitePlaceCharacterComparison ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.FiniteIdeleArtin ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.HilbertProductFormula ++import ClassFieldTheory.AlgebraicNumberTheory.PowerResidueSymbols.Ideal ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.NormApproximation.FinitePlaces ++import Mathlib.NumberTheory.Padics.HeightOneSpectrum ++import ValuedFieldTheory.LocalField.DiscreteValuationField.PadicField ++import ClassFieldTheory.AlgebraicNumberTheory.QuadraticReciprocity ++import ClassFieldTheory.AlgebraicNumberTheory.RayClass.Rational ++import ClassFieldTheory.LocalClassFieldTheory.Kummer.PowerResidueTameFormula ++import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.IdealQuotients ++import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.IdealToCompletion ++import ValuedFieldTheory.Valuation.Completion.ExtensionInvariants ++import ClassFieldTheory.KummerTheory.Concrete.SimpleExtensionLocalBehavior ++import ClassFieldTheory.KummerTheory.Concrete.SUnitPreparation.FiniteRadicalSupport ++import ClassFieldTheory.LocalClassFieldTheory.Finite.CyclotomicNorm.PrincipalUnits ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped BigOperators Classical NumberField NumberTheorySymbols ValuativeRel WithZero ++open NumberField IsDedekindDomain ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open KummerTheory ++open AlgebraicNumberTheory.PowerResidueSymbols ++open LocalClassFieldTheory.Kummer ++open LocalFieldTheory ++open LocalFieldTheory.IsNonarchimedeanLocalField ++ ++variable (K : Type) [Field K] [NumberField K] ++/-- The complete tame finite-place product for two nonzero algebraic ++integers is the quotient of the two ideal power-residue symbols. -/ ++theorem powerResidueAwayFromExponentFiniteProduct_integral_eq_idealSymbol_div ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : 𝓞 K) (ha0 : a ≠ 0) (hb0 : b ≠ 0) ++ (hcoprimeA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → ++ (Ideal.absNorm P.asIdeal).Coprime (n : ℕ)) ++ (hcoprimeB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → ++ (Ideal.absNorm P.asIdeal).Coprime (n : ℕ)) ++ (haB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → a ∉ P.asIdeal) ++ (hbA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → b ∉ P.asIdeal) ++ (hAwayA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → ++ P ∉ powerResidueExponentFinitePlaces K n) ++ (hAwayB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → ++ P ∉ powerResidueExponentFinitePlaces K n) : ++ powerResidueAwayFromExponentFiniteProduct K n hnK hmu ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0) = ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {b}) ++ (ideal_span_singleton_ne_zero K hb0) ++ n hmu a hcoprimeB haB) * ++ (integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {a}) ++ (ideal_span_singleton_ne_zero K ha0) ++ n hmu b hcoprimeA hbA))⁻¹ := by ++ let IA : Ideal (𝓞 K) := Ideal.span {a} ++ let IB : Ideal (𝓞 K) := Ideal.span {b} ++ have hIA : IA ≠ 0 := by ++ dsimp only [IA] ++ exact ideal_span_singleton_ne_zero K ha0 ++ have hIB : IB ≠ 0 := by ++ dsimp only [IB] ++ exact ideal_span_singleton_ne_zero K hb0 ++ let fB : HeightOneSpectrum (𝓞 K) → nthRootsSubgroup K (n : ℕ) := ++ fun P => integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueFactor K IB n hmu a hcoprimeB haB P) ++ let fA : HeightOneSpectrum (𝓞 K) → nthRootsSubgroup K (n : ℕ) := ++ fun P => integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueFactor K IA n hmu b hcoprimeA hbA P) ++ have hfB : Function.HasFiniteMulSupport fB := ++ (idealPowerResidueFactor_hasFiniteMulSupport ++ K IB hIB n hmu a hcoprimeB haB).subset (by ++ intro P hP ++ change fB P ≠ 1 at hP ++ change idealPowerResidueFactor K IB n hmu a hcoprimeB haB P ≠ 1 ++ intro hOne ++ exact hP (by simp only [fB, hOne, map_one])) ++ have hfA : Function.HasFiniteMulSupport fA := ++ (idealPowerResidueFactor_hasFiniteMulSupport ++ K IA hIA n hmu b hcoprimeA hbA).subset (by ++ intro P hP ++ change fA P ≠ 1 at hP ++ change idealPowerResidueFactor K IA n hmu b hcoprimeA hbA P ≠ 1 ++ intro hOne ++ exact hP (by simp only [fA, hOne, map_one])) ++ have hfAInv : ++ Function.HasFiniteMulSupport (fun P => (fA P)⁻¹) := ++ hfA.subset (by ++ intro P hP ++ change (fA P)⁻¹ ≠ 1 at hP ++ change fA P ≠ 1 ++ intro hOne ++ exact hP (by rw [hOne, inv_one])) ++ let invHom : nthRootsSubgroup K (n : ℕ) →* ++ nthRootsSubgroup K (n : ℕ) := invMonoidHom ++ have hfinprodInv : ++ (∏ᶠ P : HeightOneSpectrum (𝓞 K), (fA P)⁻¹) = ++ (∏ᶠ P : HeightOneSpectrum (𝓞 K), fA P)⁻¹ := by ++ change (∏ᶠ P : HeightOneSpectrum (𝓞 K), invHom (fA P)) = ++ invHom (∏ᶠ P : HeightOneSpectrum (𝓞 K), fA P) ++ exact (MonoidHom.map_finprod invHom hfA).symm ++ calc ++ powerResidueAwayFromExponentFiniteProduct K n hnK hmu ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0) = ++ ∏ᶠ P : HeightOneSpectrum (𝓞 K), fB P * (fA P)⁻¹ := by ++ apply finprod_congr ++ intro P ++ simpa only [fA, fB, IA, IB] using ++ powerResidueAwayFromExponentFiniteFactor_integral_eq_idealFactors ++ K n hnK hmu a b ha0 hb0 hcoprimeA hcoprimeB haB hbA ++ hAwayA hAwayB P ++ _ = (∏ᶠ P : HeightOneSpectrum (𝓞 K), fB P) * ++ (∏ᶠ P : HeightOneSpectrum (𝓞 K), (fA P)⁻¹) := ++ finprod_mul_distrib hfB hfAInv ++ _ = (∏ᶠ P : HeightOneSpectrum (𝓞 K), fB P) * ++ (∏ᶠ P : HeightOneSpectrum (𝓞 K), fA P)⁻¹ := by ++ rw [hfinprodInv] ++ _ = integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K IB hIB n hmu a hcoprimeB haB) * ++ (integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K IA hIA n hmu b hcoprimeA hbA))⁻¹ := by ++ rw [idealPowerResidueSymbol_eq_finprod, ++ idealPowerResidueSymbol_eq_finprod] ++ rw [MonoidHom.map_finprod ++ (integralRootsOfUnityToNthRoots K (n : ℕ)) ++ (idealPowerResidueFactor_hasFiniteMulSupport ++ K IB hIB n hmu a hcoprimeB haB), ++ MonoidHom.map_finprod ++ (integralRootsOfUnityToNthRoots K (n : ℕ)) ++ (idealPowerResidueFactor_hasFiniteMulSupport ++ K IA hIA n hmu b hcoprimeA hbA)] ++ _ = integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {b}) ++ (ideal_span_singleton_ne_zero K hb0) ++ n hmu a hcoprimeB haB) * ++ (integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {a}) ++ (ideal_span_singleton_ne_zero K ha0) ++ n hmu b hcoprimeA hbA))⁻¹ := by ++ rfl ++ ++/-- Split the full finite-place product into exponent-prime factors and the ++product away from the exponent. -/ ++theorem finitePlaceHilbertSymbol_finprod_eq_exponent_product_mul_away ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) : ++ (∏ᶠ v : HeightOneSpectrum (𝓞 K), ++ finitePlaceHilbertSymbol K n hnK hmu v a b) = ++ (∏ v ∈ powerResidueExponentFinitePlaces K n, ++ finitePlaceHilbertSymbol K n hnK hmu v a b) * ++ powerResidueAwayFromExponentFiniteProduct K n hnK hmu a b := by ++ let exponentFactor : HeightOneSpectrum (𝓞 K) → ++ nthRootsSubgroup K (n : ℕ) := fun v => ++ if v ∈ powerResidueExponentFinitePlaces K n then ++ finitePlaceHilbertSymbol K n hnK hmu v a b ++ else ++ 1 ++ let awayFactor : HeightOneSpectrum (𝓞 K) → ++ nthRootsSubgroup K (n : ℕ) := fun v => ++ if v ∈ powerResidueExponentFinitePlaces K n then ++ 1 ++ else ++ finitePlaceHilbertSymbol K n hnK hmu v a b ++ have hExponentSupport : ++ Function.mulSupport exponentFactor ⊆ ++ (powerResidueExponentFinitePlaces K n : ++ Set (HeightOneSpectrum (𝓞 K))) := by ++ intro v hv ++ change exponentFactor v ≠ 1 at hv ++ change v ∈ powerResidueExponentFinitePlaces K n ++ by_contra hvExponent ++ exact hv (by simp only [exponentFactor, ite_eq_right hvExponent]) ++ have hExponentFinite : Function.HasFiniteMulSupport exponentFactor := by ++ rw [Function.HasFiniteMulSupport] ++ exact ++ (powerResidueExponentFinitePlaces K n).finite_toSet.subset ++ hExponentSupport ++ have hAwayFinite : Function.HasFiniteMulSupport awayFactor := by ++ rw [Function.HasFiniteMulSupport] ++ exact ++ (finitePlaceHilbertSymbol_hasFiniteMulSupport K n hnK hmu a b).subset ++ (by ++ intro v hv ++ change awayFactor v ≠ 1 at hv ++ change finitePlaceHilbertSymbol K n hnK hmu v a b ≠ 1 ++ by_contra hvOne ++ exact hv (by simp only [awayFactor, hvOne, ite_self])) ++ have hPointwise : ++ (fun v : HeightOneSpectrum (𝓞 K) => ++ finitePlaceHilbertSymbol K n hnK hmu v a b) = ++ fun v => exponentFactor v * awayFactor v := by ++ funext v ++ by_cases hv : v ∈ powerResidueExponentFinitePlaces K n ++ · simp only [exponentFactor, awayFactor, ite_eq_left hv, mul_one] ++ · simp only [exponentFactor, awayFactor, ite_eq_right hv, one_mul] ++ have hExponentProduct : ++ (∏ᶠ v : HeightOneSpectrum (𝓞 K), exponentFactor v) = ++ ∏ v ∈ powerResidueExponentFinitePlaces K n, ++ finitePlaceHilbertSymbol K n hnK hmu v a b := by ++ rw [finprod_eq_prod_of_mulSupport_subset exponentFactor hExponentSupport] ++ apply Finset.prod_congr rfl ++ intro v hv ++ simp only [exponentFactor, ite_eq_left hv] ++ calc ++ (∏ᶠ v : HeightOneSpectrum (𝓞 K), ++ finitePlaceHilbertSymbol K n hnK hmu v a b) = ++ ∏ᶠ v : HeightOneSpectrum (𝓞 K), ++ exponentFactor v * awayFactor v := by ++ rw [hPointwise] ++ _ = (∏ᶠ v : HeightOneSpectrum (𝓞 K), exponentFactor v) * ++ (∏ᶠ v : HeightOneSpectrum (𝓞 K), awayFactor v) := ++ finprod_mul_distrib hExponentFinite hAwayFinite ++ _ = (∏ v ∈ powerResidueExponentFinitePlaces K n, ++ finitePlaceHilbertSymbol K n hnK hmu v a b) * ++ (∏ᶠ v : HeightOneSpectrum (𝓞 K), awayFactor v) := by ++ rw [hExponentProduct] ++ _ = (∏ v ∈ powerResidueExponentFinitePlaces K n, ++ finitePlaceHilbertSymbol K n hnK hmu v a b) * ++ powerResidueAwayFromExponentFiniteProduct K n hnK hmu a b := by ++ rfl ++ ++/-- General Hilbert-product core of power-residue reciprocity. The complete ++finite product away from the exponent is the inverse of the explicit product ++of all infinite-place factors and all exponent-prime factors. -/ ++theorem powerResidueAwayFromExponentFiniteProduct_eq_badPlaceCorrection_inv ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : Kˣ) : ++ powerResidueAwayFromExponentFiniteProduct K n hnK hmu a b = ++ (powerResidueBadPlaceCorrection K n hnK hmu a b)⁻¹ := by ++ have hproduct := ++ hilbertSymbol_allPlaces_product_eq_one K n hnK hmu a b ++ rw [finitePlaceHilbertSymbol_finprod_eq_exponent_product_mul_away] ++ at hproduct ++ exact (eq_inv_iff_mul_eq_one).2 (by ++ unfold powerResidueBadPlaceCorrection ++ simpa only [mul_assoc, mul_comm, mul_left_comm] using hproduct) ++ ++/-- General ideal power-residue reciprocity with the explicit product of ++infinite and exponent-prime Hilbert factors as correction. -/ ++theorem idealPowerResidueSymbol_reciprocity_with_bad_place_correction ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (a b : 𝓞 K) (ha0 : a ≠ 0) (hb0 : b ≠ 0) ++ (hcoprimeA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → ++ (Ideal.absNorm P.asIdeal).Coprime (n : ℕ)) ++ (hcoprimeB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → ++ (Ideal.absNorm P.asIdeal).Coprime (n : ℕ)) ++ (haB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → a ∉ P.asIdeal) ++ (hbA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → b ∉ P.asIdeal) ++ (hAwayA : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {a} → ++ P ∉ powerResidueExponentFinitePlaces K n) ++ (hAwayB : ++ ∀ P : HeightOneSpectrum (𝓞 K), ++ P.asIdeal ∣ Ideal.span {b} → ++ P ∉ powerResidueExponentFinitePlaces K n) : ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {b}) ++ (ideal_span_singleton_ne_zero K hb0) ++ n hmu a hcoprimeB haB) = ++ (powerResidueBadPlaceCorrection K n hnK hmu ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0))⁻¹ * ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {a}) ++ (ideal_span_singleton_ne_zero K ha0) ++ n hmu b hcoprimeA hbA) := by ++ let symbolAB := integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {b}) ++ (ideal_span_singleton_ne_zero K hb0) ++ n hmu a hcoprimeB haB) ++ let symbolBA := integralRootsOfUnityToNthRoots K (n : ℕ) ++ (idealPowerResidueSymbol K (Ideal.span {a}) ++ (ideal_span_singleton_ne_zero K ha0) ++ n hmu b hcoprimeA hbA) ++ let correction := powerResidueBadPlaceCorrection K n hnK hmu ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0) ++ have hIdeal := ++ powerResidueAwayFromExponentFiniteProduct_integral_eq_idealSymbol_div ++ K n hnK hmu a b ha0 hb0 hcoprimeA hcoprimeB haB hbA ++ hAwayA hAwayB ++ have hCorrection := ++ powerResidueAwayFromExponentFiniteProduct_eq_badPlaceCorrection_inv ++ K n hnK hmu ++ (nonzeroIntegralFieldUnit K a ha0) ++ (nonzeroIntegralFieldUnit K b hb0) ++ have hQuotient : symbolAB * symbolBA⁻¹ = correction⁻¹ := by ++ rw [← hIdeal, hCorrection] ++ change symbolAB = correction⁻¹ * symbolBA ++ calc ++ symbolAB = (symbolAB * symbolBA⁻¹) * symbolBA := by ++ simp only [mul_assoc, inv_mul_cancel, mul_one] ++ _ = correction⁻¹ * symbolBA := by rw [hQuotient] ++ ++/-! ## Quadratic specialization over the rational field -/ ++ ++open AlgebraicNumberTheory.PowerResidueSymbols ++ ++local instance rationalPrimeFact (p : Nat.Primes) : Fact p.1.Prime := ++ ⟨p.2⟩ ++ ++/-- The rational field contains the primitive square root of unity `-1`. ++This is the canonical source of the primitive-root input in the quadratic ++specialization; no root is chosen downstream. -/ ++theorem rationalQuadraticPrimitiveRoots_nonempty : ++ (primitiveRoots 2 ℚ).Nonempty := by ++ refine ⟨-1, (mem_primitiveRoots (by decide)).2 ?_⟩ ++ exact IsPrimitiveRoot.neg_one 0 (by decide) ++ ++/-- The residue field at the rational prime over `p` is canonically `ZMod p`. ++The construction first transports the prime ideal through ++`Rat.ringOfIntegersEquiv` and then uses the standard integer quotient. -/ ++noncomputable def rationalPrimeResidueEquivZMod ++ (p : Nat.Primes) : ++ (𝓞 ℚ ⧸ (RayClass.rationalPrime p).asIdeal) ≃+* ZMod p.1 := by ++ have hIntEquiv : ++ Rat.IsIntegralClosure.intEquiv (𝓞 ℚ) = ++ Rat.ringOfIntegersEquiv := by ++ ext x ++ exact Rat.IsIntegralClosure.intEquiv_apply_eq_ringOfIntegersEquiv x ++ have hmap : ++ Ideal.span {(p.1 : ℤ)} = ++ (RayClass.rationalPrime p).asIdeal.map ++ Rat.ringOfIntegersEquiv := by ++ simpa only [RayClass.natGenerator_rationalPrime, hIntEquiv] using ++ (Rat.HeightOneSpectrum.span_natGenerator ++ (RayClass.rationalPrime p)) ++ exact ++ (Ideal.quotientEquiv ++ (RayClass.rationalPrime p).asIdeal ++ (Ideal.span {(p.1 : ℤ)}) ++ Rat.ringOfIntegersEquiv hmap).trans ++ (Int.quotientSpanNatEquivZMod p.1) ++ ++/-- The rational residue-field equivalence sends an integral residue class to ++the corresponding integer class modulo `p`. -/ ++@[simp] ++theorem rationalPrimeResidueEquivZMod_mk ++ (p : Nat.Primes) (a : 𝓞 ℚ) : ++ rationalPrimeResidueEquivZMod p ++ (Ideal.Quotient.mk (RayClass.rationalPrime p).asIdeal a) = ++ (Rat.ringOfIntegersEquiv a : ZMod p.1) := by ++ rw [rationalPrimeResidueEquivZMod, RingEquiv.trans_apply] ++ have hmk ++ (hIJ : ++ Ideal.span {(p.1 : ℤ)} = ++ (RayClass.rationalPrime p).asIdeal.map ++ Rat.ringOfIntegersEquiv) : ++ Ideal.quotientEquiv ++ (RayClass.rationalPrime p).asIdeal ++ (Ideal.span {(p.1 : ℤ)}) ++ Rat.ringOfIntegersEquiv hIJ ++ (Ideal.Quotient.mk (RayClass.rationalPrime p).asIdeal a) = ++ Ideal.Quotient.mk (Ideal.span {(p.1 : ℤ)}) ++ (Rat.ringOfIntegersEquiv a) := ++ Ideal.quotientEquiv_mk ++ (RayClass.rationalPrime p).asIdeal ++ (Ideal.span {(p.1 : ℤ)}) ++ Rat.ringOfIntegersEquiv hIJ a ++ have hquot : ++ ((Int.quotientSpanNatEquivZMod p.1 : ++ (ℤ ⧸ Ideal.span {(p.1 : ℤ)}) →+* ZMod p.1).comp ++ (Ideal.Quotient.mk (Ideal.span {(p.1 : ℤ)}))) = ++ Int.castRingHom (ZMod p.1) := ++ Int.quotientSpanNatEquivZMod_comp_Quotient_mk p.1 ++ calc ++ _ = Int.quotientSpanNatEquivZMod p.1 ++ (Ideal.Quotient.mk (Ideal.span {(p.1 : ℤ)}) ++ (Rat.ringOfIntegersEquiv a)) := ++ congrArg (Int.quotientSpanNatEquivZMod p.1) (hmk _) ++ _ = _ := congrArg ++ (fun f : ℤ →+* ZMod p.1 => f (Rat.ringOfIntegersEquiv a)) hquot ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityLocalSymbols.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityLocalSymbols.lean +new file mode 100644 +index 0000000..92d5938 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/PowerResidueReciprocityLocalSymbols.lean +@@ -0,0 +1,557 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.PowerResidueReciprocityBase ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.GlobalHilbertSymbol.FinitePlaceCharacterComparison ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.FiniteIdeleArtin ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.HilbertProductFormula ++import ClassFieldTheory.AlgebraicNumberTheory.PowerResidueSymbols.Ideal ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.NormApproximation.FinitePlaces ++import Mathlib.NumberTheory.Padics.HeightOneSpectrum ++import ValuedFieldTheory.LocalField.DiscreteValuationField.PadicField ++import ClassFieldTheory.AlgebraicNumberTheory.QuadraticReciprocity ++import ClassFieldTheory.AlgebraicNumberTheory.RayClass.Rational ++import ClassFieldTheory.LocalClassFieldTheory.Kummer.PowerResidueTameFormula ++import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.IdealQuotients ++import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.IdealToCompletion ++import ValuedFieldTheory.Valuation.Completion.ExtensionInvariants ++import ClassFieldTheory.KummerTheory.Concrete.SimpleExtensionLocalBehavior ++import ClassFieldTheory.KummerTheory.Concrete.SUnitPreparation.FiniteRadicalSupport ++import ClassFieldTheory.LocalClassFieldTheory.Finite.CyclotomicNorm.PrincipalUnits ++ ++ ++set_option autoImplicit false ++ ++ ++open scoped BigOperators Classical NumberField NumberTheorySymbols ValuativeRel WithZero ++open NumberField IsDedekindDomain ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++open KummerTheory ++open AlgebraicNumberTheory.PowerResidueSymbols ++open LocalClassFieldTheory.Kummer ++open LocalFieldTheory ++open LocalFieldTheory.IsNonarchimedeanLocalField ++ ++variable (K : Type) [Field K] [NumberField K] ++/-- The integral principal ideal generated by the exponent. -/ ++def powerResidueExponentIdeal (n : ℕ+) : Ideal (𝓞 K) := ++ Ideal.span {((n : ℕ) : 𝓞 K)} ++ ++/-- The exponent ideal is nonzero in a number field. -/ ++theorem powerResidueExponentIdeal_ne_zero (n : ℕ+) : ++ powerResidueExponentIdeal K n ≠ 0 := by ++ change Ideal.span {((n : ℕ) : 𝓞 K)} ≠ ⊥ ++ exact Ideal.span_singleton_eq_bot.not.mpr ++ (Nat.cast_ne_zero.mpr n.ne_zero) ++ ++omit [NumberField K] in ++theorem ideal_span_singleton_ne_zero ++ {x : 𝓞 K} (hx : x ≠ 0) : Ideal.span {x} ≠ 0 := ++ Submodule.span_singleton_eq_bot.mp.mt hx ++ ++/-- The finite places dividing the exponent. These, together with all ++infinite places, are precisely the correction places in the reciprocity ++formula once the two principal denominator supports are removed. -/ ++noncomputable def powerResidueExponentFinitePlaces ++ (n : ℕ+) : Finset (HeightOneSpectrum (𝓞 K)) := ++ (Ideal.finite_factors ++ (powerResidueExponentIdeal_ne_zero K n)).toFinset ++ ++/-- Membership in the exponent-place support is divisibility by the exponent ++ideal. -/ ++@[simp] ++theorem mem_powerResidueExponentFinitePlaces_iff ++ (n : ℕ+) (v : HeightOneSpectrum (𝓞 K)) : ++ v ∈ powerResidueExponentFinitePlaces K n ↔ ++ v.asIdeal ∣ powerResidueExponentIdeal K n := ++ Set.Finite.mem_toFinset ++ (Ideal.finite_factors ++ (powerResidueExponentIdeal_ne_zero K n)) ++ ++/-- At a finite place not dividing the exponent, the exponent is a unit in ++the canonical completion. -/ ++theorem finitePlace_natCast_valuation_eq_one_of_not_mem_exponent ++ (n : ℕ+) (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ ValuativeRel.valuation C ((n : ℕ) : C) = 1 := by ++ dsimp only ++ let : IsUltrametricDist ++ (HeightOneSpectrum.adicAbv K v).Completion := ++ finitePlaceArtinCompletionIsUltrametricDist ++ (HeightOneSpectrum.adicAbv K v) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv K v) ++ have hvNotDvd : ++ ¬ v.asIdeal ∣ powerResidueExponentIdeal K n := by ++ simpa only [mem_powerResidueExponentFinitePlaces_iff] using hv ++ have hvNotMem : ((n : ℕ) : 𝓞 K) ∉ v.asIdeal := by ++ intro hvMem ++ apply hvNotDvd ++ rw [powerResidueExponentIdeal, Ideal.dvd_span_singleton] ++ exact hvMem ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ have hNorm : ‖((n : ℕ) : C)‖ = 1 := by ++ calc ++ ‖((n : ℕ) : C)‖ = ++ ‖algebraMap K C (((n : ℕ) : K))‖ := by rw [map_natCast] ++ _ = HeightOneSpectrum.adicAbv K v (((n : ℕ) : K)) := ++ AbsoluteValue.completionAbsoluteValue_coe ++ (HeightOneSpectrum.adicAbv K v) (((n : ℕ) : K)) ++ _ = ‖NumberField.FinitePlace.embedding v (((n : ℕ) : K))‖ := ++ (NumberField.FinitePlace.norm_embedding v (((n : ℕ) : K))).symm ++ _ = 1 := ++ (NumberField.FinitePlace.norm_eq_one_iff_notMem K v ++ (((n : ℕ) : 𝓞 K))).2 hvNotMem ++ let vCNorm := NormedField.valuation (K := C) ++ let : vCNorm.Compatible := Valuation.Compatible.ofValuation vCNorm ++ have hnCNorm : vCNorm ((n : ℕ) : C) = 1 := by ++ change ‖((n : ℕ) : C)‖₊ = 1 ++ exact NNReal.eq (by simpa using hNorm) ++ exact ++ (ValuativeRel.isEquiv vCNorm (ValuativeRel.valuation C)) ++ |>.eq_one_iff_eq_one.mp hnCNorm ++ ++private noncomputable def finitePlaceLocalTamePowerResidueSymbolValue ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ nthRootsSubgroup (HeightOneSpectrum.adicAbv K v).Completion (n : ℕ) := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ exact localTamePowerResidueSymbol C n ++ (finitePlace_natCast_valuation_eq_one_of_not_mem_exponent K n v hv) ++ (finitePlaceHilbert_primitiveRoots_nonempty K n hmu v) ++ (finitePlaceIntegralCompletionUnit K v a ha) ++ ++private noncomputable def finitePlaceLocalTamePowerResidueSymbolFieldValue ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ (HeightOneSpectrum.adicAbv K v).Completion := ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ ((localTamePowerResidueSymbol C n ++ (finitePlace_natCast_valuation_eq_one_of_not_mem_exponent K n v hv) ++ (finitePlaceHilbert_primitiveRoots_nonempty K n hmu v) ++ (finitePlaceIntegralCompletionUnit K v a ha)).1 : C) ++ ++private noncomputable def finitePlacePrimeIdealPowerResidueIntegralRoot ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ rootsOfUnity (n : ℕ) (𝓞 K) := ++ AlgebraicNumberTheory.PowerResidueSymbols.primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha ++ ++private noncomputable def finitePlacePrimeIdealPowerResidueGlobalRoot ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : nthRootsSubgroup K (n : ℕ) := ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (finitePlacePrimeIdealPowerResidueIntegralRoot K v n hmu hcoprime a ha) ++ ++private noncomputable def finitePlacePrimeIdealPowerResidueFactorValue ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ nthRootsSubgroup (HeightOneSpectrum.adicAbv K v).Completion (n : ℕ) := ++ nthRootsSubgroupMap K (HeightOneSpectrum.adicAbv K v).Completion (n : ℕ) ++ (finitePlacePrimeIdealPowerResidueGlobalRoot K v n hmu hcoprime a ha) ++ ++private noncomputable def finitePlacePrimeIdealPowerResidueFactorFieldValue ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ (HeightOneSpectrum.adicAbv K v).Completion := ++ (((nthRootsSubgroupMap K ++ (HeightOneSpectrum.adicAbv K v).Completion (n : ℕ)) ++ (finitePlacePrimeIdealPowerResidueGlobalRoot K v n hmu hcoprime a ha)).1 : ++ (HeightOneSpectrum.adicAbv K v).Completion) ++ ++private noncomputable def finitePlaceLocalTamePowerResidueSymbolResidueValue ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ 𝓀[C] := by ++ dsimp only ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ letI : Fintype 𝓀[C] := Fintype.ofFinite _ ++ have hnLocal : (n : ℕ) ∣ Fintype.card 𝓀[C] - 1 := by ++ rw [← Nat.card_eq_fintype_card] ++ exact dvd_residueCard_sub_one_of_primitiveRoots C n ++ (finitePlace_natCast_valuation_eq_one_of_not_mem_exponent K n v hv) ++ (finitePlaceHilbert_primitiveRoots_nonempty K n hmu v) ++ exact ++ (((AlgebraicNumberTheory.PowerResidueSymbols.finiteFieldPowerResidueSymbol ++ 𝓀[C] n hnLocal ++ (integerUnitsToResidueUnits C ++ (finitePlaceIntegralCompletionUnit K v a ha)) : ++ rootsOfUnity (n : ℕ) 𝓀[C]).1 : 𝓀[C]ˣ) : 𝓀[C]) ++ ++private noncomputable def finitePlacePrimeIdealPowerResidueFactorResidueValue ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ 𝓀[C] := by ++ dsimp only ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ exact ++ (((localNthRootsReduction C n ++ (nthRootsSubgroupMap K C (n : ℕ) ++ (integralRootsOfUnityToNthRoots K (n : ℕ) ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha)))).1 : 𝓀[C]ˣ) : 𝓀[C]) ++ ++/-- The tame symbol in a finite-place completion is the image of the ++prime-ideal power-residue symbol. All comparisons are canonical: the only ++place hypothesis says that the place does not divide the exponent. -/ ++private theorem finitePlaceLocalTamePowerResidueSymbol_residueValue_eq ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ finitePlaceLocalTamePowerResidueSymbolResidueValue K v n hmu hv a ha = ++ finitePlacePrimeIdealPowerResidueFactorResidueValue ++ K v n hmu hcoprime a ha := by ++ unfold finitePlaceLocalTamePowerResidueSymbolResidueValue ++ unfold finitePlacePrimeIdealPowerResidueFactorResidueValue ++ dsimp only ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ let : ValuativeRel C := finitePlaceLocalArtinCompletionValuativeRel v ++ let : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ let : Field (𝓞 K ⧸ v.asIdeal) := Ideal.Quotient.field v.asIdeal ++ let : Fintype (𝓞 K ⧸ v.asIdeal) := Fintype.ofFinite _ ++ let : Fintype 𝓀[C] := Fintype.ofFinite _ ++ let hnC := finitePlace_natCast_valuation_eq_one_of_not_mem_exponent K n v hv ++ let hmuC := finitePlaceHilbert_primitiveRoots_nonempty K n hmu v ++ have hnPrime : ++ (n : ℕ) ∣ Fintype.card (𝓞 K ⧸ v.asIdeal) - 1 := by ++ rw [AlgebraicNumberTheory.PowerResidueSymbols.card_primeIdealResidueField K v] ++ exact ++ AlgebraicNumberTheory.PowerResidueSymbols.dvd_absNorm_sub_one_of_primitiveRoots ++ K v n hmu hcoprime ++ have hnLocal : (n : ℕ) ∣ Fintype.card 𝓀[C] - 1 := by ++ rw [← Nat.card_eq_fintype_card] ++ exact dvd_residueCard_sub_one_of_primitiveRoots C n hnC hmuC ++ rw [finitePlace_localNthRootsReduction_integralRoots] ++ rw [← AlgebraicNumberTheory.PowerResidueSymbols.rootsOfUnityReductionEquiv_apply ++ K v n hmu hcoprime, ++ AlgebraicNumberTheory.PowerResidueSymbols.rootsOfUnityReductionEquiv_primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha] ++ rw [finitePlace_integerUnitsToResidueUnits_integralUnit] ++ exact congrArg (fun u : 𝓀[C]ˣ => (u : 𝓀[C])) ++ (finiteFieldPowerResidueSymbol_unitsMap_ringEquiv ++ (finitePlacePrimeResidueEquivLocalResidue K v) ++ n hnPrime hnLocal ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealResidueUnit ++ K v a ha)).symm ++ ++private theorem finitePlaceLocalTamePowerResidueSymbolFieldValue_eq_primeIdealValue ++ (v : HeightOneSpectrum (𝓞 K)) (n : ℕ+) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) : ++ @Eq (HeightOneSpectrum.adicAbv K v).Completion ++ (finitePlaceLocalTamePowerResidueSymbolFieldValue K v n hmu hv a ha) ++ (finitePlacePrimeIdealPowerResidueFactorFieldValue ++ K v n hmu hcoprime a ha) := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ let : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ let : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ let hnC := ++ finitePlace_natCast_valuation_eq_one_of_not_mem_exponent K n v hv ++ let hmuC := finitePlaceHilbert_primitiveRoots_nonempty K n hmu v ++ unfold finitePlaceLocalTamePowerResidueSymbolFieldValue ++ unfold finitePlacePrimeIdealPowerResidueFactorFieldValue ++ unfold finitePlacePrimeIdealPowerResidueGlobalRoot ++ unfold finitePlacePrimeIdealPowerResidueIntegralRoot ++ have hRoots : ++ localTamePowerResidueSymbol C n hnC hmuC ++ (finitePlaceIntegralCompletionUnit K v a ha) = ++ nthRootsSubgroupMap K C (n : ℕ) ++ (integralRootsOfUnityToNthRoots K (n : ℕ) ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha)) := by ++ apply (localNthRootsReductionEquiv C n hnC hmuC).injective ++ rw [localNthRootsReductionEquiv_localTamePowerResidueSymbol] ++ apply Subtype.ext ++ apply Units.ext ++ have hResidue := finitePlaceLocalTamePowerResidueSymbol_residueValue_eq ++ K v n hmu hcoprime hv a ha ++ unfold finitePlaceLocalTamePowerResidueSymbolResidueValue at hResidue ++ unfold finitePlacePrimeIdealPowerResidueFactorResidueValue at hResidue ++ dsimp only at hResidue ++ exact hResidue ++ exact congrArg (fun q : nthRootsSubgroup C (n : ℕ) => (q.1 : C)) hRoots ++ ++/-- The normalized additive valuation of a global field unit in the ++canonical completion at a finite place. -/ ++noncomputable def finitePlaceNormalizedValuation ++ (v : HeightOneSpectrum (𝓞 K)) (x : Kˣ) : ℤ := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ letI : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ letI : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ exact valuationMap C ++ (Additive.ofMul (finitePlaceHilbert_completionUnit K v x)) ++ ++/-- Away from the exponent, a finite-place Hilbert factor with integral-unit ++first entry is the prime-ideal power-residue symbol raised to the negative ++normalized valuation of the second entry. -/ ++theorem finitePlaceHilbertSymbol_eq_primeIdealPowerResidueFactor_zpow ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) (b : Kˣ) : ++ finitePlaceHilbertSymbol K n hnK hmu v ++ (primeAvoidingIntegralFieldUnit K v a ha) b = ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha) ^ ++ (-finitePlaceNormalizedValuation K v b) := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ let : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ let : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ let hnC := ++ finitePlace_natCast_valuation_eq_one_of_not_mem_exponent K n v hv ++ let hmuC := finitePlaceHilbert_primitiveRoots_nonempty K n hmu v ++ let bC := finitePlaceHilbert_completionUnit K v b ++ apply nthRootsSubgroupMap_injective K C (n : ℕ) ++ rw [finitePlaceHilbertSymbol_map_eq_localHilbertSymbol] ++ change ++ localHilbertSymbol C n ++ (finitePlaceHilbert_natCast_ne_zero K n hnK v) hmuC ++ (finitePlaceHilbert_completionUnit K v ++ (primeAvoidingIntegralFieldUnit K v a ha)) bC = ++ nthRootsSubgroupMap K C (n : ℕ) ++ (integralRootsOfUnityToNthRoots K (n : ℕ) ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha) ^ ++ (-finitePlaceNormalizedValuation K v b)) ++ rw [finitePlaceHilbert_completionUnit_primeAvoidingIntegralFieldUnit] ++ rw [localHilbertSymbol_tame_formula C n hnC hmuC] ++ change ++ finitePlaceLocalTamePowerResidueSymbolValue K v n hmu hv a ha ^ ++ (-finitePlaceNormalizedValuation K v b) = _ ++ have hBase : ++ finitePlaceLocalTamePowerResidueSymbolValue K v n hmu hv a ha = ++ finitePlacePrimeIdealPowerResidueFactorValue ++ K v n hmu hcoprime a ha := by ++ apply Subtype.ext ++ apply Units.ext ++ simpa only [finitePlaceLocalTamePowerResidueSymbolValue, ++ finitePlacePrimeIdealPowerResidueFactorValue, ++ finitePlaceLocalTamePowerResidueSymbolFieldValue, ++ finitePlacePrimeIdealPowerResidueFactorFieldValue] using ++ finitePlaceLocalTamePowerResidueSymbolFieldValue_eq_primeIdealValue ++ K v n hmu hcoprime hv a ha ++ rw [hBase] ++ unfold finitePlacePrimeIdealPowerResidueFactorValue ++ unfold finitePlacePrimeIdealPowerResidueGlobalRoot ++ unfold finitePlacePrimeIdealPowerResidueIntegralRoot ++ rw [map_zpow] ++ ++/-- Endpoint form of the finite-place local/global power-residue comparison. -/ ++theorem finitePlaceHilbertSymbol_eq_primeIdealPowerResidueFactor ++ (n : ℕ+) (hnK : ((n : ℕ) : K) ≠ 0) ++ (hmu : (primitiveRoots (n : ℕ) K).Nonempty) ++ (v : HeightOneSpectrum (𝓞 K)) ++ (hv : v ∉ powerResidueExponentFinitePlaces K n) ++ (hcoprime : (Ideal.absNorm v.asIdeal).Coprime (n : ℕ)) ++ (a : 𝓞 K) (ha : a ∉ v.asIdeal) (b : Kˣ) : ++ finitePlaceHilbertSymbol K n hnK hmu v ++ (primeAvoidingIntegralFieldUnit K v a ha) b = ++ integralRootsOfUnityToNthRoots K (n : ℕ) ++ (AlgebraicNumberTheory.PowerResidueSymbols.primeIdealPowerResidueSymbol ++ K v n hmu hcoprime a ha) ^ ++ (-finitePlaceNormalizedValuation K v b) := ++ finitePlaceHilbertSymbol_eq_primeIdealPowerResidueFactor_zpow ++ K n hnK hmu v hv hcoprime a ha b ++ ++/-- The Dedekind prime multiplicity is the exponent occurring in the ++integer-valued adic valuation. -/ ++theorem intValuation_eq_exp_neg_idealPrimeMultiplicity ++ (v : HeightOneSpectrum (𝓞 K)) (x : 𝓞 K) (hx : x ≠ 0) : ++ v.intValuation x = ++ WithZero.exp ++ (-(AlgebraicNumberTheory.PowerResidueSymbols.idealPrimeMultiplicity K v (Ideal.span {x}) : ℤ)) := by ++ rw [v.intValuation_if_neg hx] ++ rfl ++ ++/-- For an integral element, the normalized valuation in the canonical ++finite-place completion is the negative multiplicity of the prime in its ++principal ideal. -/ ++theorem finitePlaceNormalizedValuation_nonzeroIntegralFieldUnit ++ (v : HeightOneSpectrum (𝓞 K)) ++ (x : 𝓞 K) (hx : x ≠ 0) : ++ finitePlaceNormalizedValuation K v ++ (nonzeroIntegralFieldUnit K x hx) = ++ -(AlgebraicNumberTheory.PowerResidueSymbols.idealPrimeMultiplicity K v (Ideal.span {x}) : ℤ) := by ++ let C := (HeightOneSpectrum.adicAbv K v).Completion ++ let : ValuativeRel C := ++ finitePlaceLocalArtinCompletionValuativeRel v ++ let : IsNonarchimedeanLocalField C := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v ++ let : IsUltrametricDist C := ++ finitePlaceArtinCompletionIsUltrametricDist ++ (HeightOneSpectrum.adicAbv K v) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv K v) ++ let m := AlgebraicNumberTheory.PowerResidueSymbols.idealPrimeMultiplicity K v (Ideal.span {x}) ++ let πData := chosenFinitePlaceCompletionIntegralUniformizer v ++ have hπIrreducible : Irreducible πData.completionInteger := by ++ rw [IsDiscreteValuationRing.irreducible_iff_uniformizer] ++ let completionDVF : ++ ValuationTheory.DiscreteValuationField.DVF C := ++ { ValueGroup := ValuativeRel.ValueGroupWithZero C ++ valuation := ValuativeRel.valuation C } ++ exact ++ completionDVF.maximalIdeal_eq_span_uniformizer ++ πData.completionInteger_isUniformizer ++ let πC : Cˣ := ++ Units.mk0 (πData.completionInteger : C) ++ πData.completionInteger_isUniformizer.ne_zero ++ let xC : Cˣ := ++ finitePlaceHilbert_completionUnit K v ++ (nonzeroIntegralFieldUnit K x hx) ++ have hIntX : ++ v.intValuation x = WithZero.exp (-(m : ℤ)) := by ++ exact intValuation_eq_exp_neg_idealPrimeMultiplicity K v x hx ++ have hIntPiPow : ++ v.intValuation (πData.integer ^ m) = ++ WithZero.exp (-(m : ℤ)) := by ++ rw [map_pow, πData.intValuation_eq_exp_neg_one] ++ calc ++ WithZero.exp (-1 : ℤ) ^ m = ++ WithZero.exp (m • (-1 : ℤ)) := ++ (WithZero.exp_nsmul m (-1 : ℤ)).symm ++ _ = WithZero.exp (-(m : ℤ)) := by simp ++ have hnormX : ++ ‖(xC : C)‖ = ++ (WithZeroMulInt.toNNReal ++ (HeightOneSpectrum.absNorm_ne_zero v) ++ (WithZero.exp (-(m : ℤ))) : ℝ) := by ++ change ‖algebraMap K C (x : K)‖ = _ ++ calc ++ ‖algebraMap K C (x : K)‖ = ++ HeightOneSpectrum.adicAbv K v (x : K) := ++ AbsoluteValue.completionAbsoluteValue_coe ++ (HeightOneSpectrum.adicAbv K v) (x : K) ++ _ = _ := by ++ rw [HeightOneSpectrum.adicAbv_def, ++ HeightOneSpectrum.valuation_of_algebraMap, hIntX] ++ have hnormPiPow : ++ ‖((πC ^ m : Cˣ) : C)‖ = ++ (WithZeroMulInt.toNNReal ++ (HeightOneSpectrum.absNorm_ne_zero v) ++ (WithZero.exp (-(m : ℤ))) : ℝ) := by ++ have hπC : ++ (πC : C) = algebraMap K C (πData.integer : K) := by ++ exact πData.coe_completionInteger ++ have hπCPow : ++ ((πC ^ m : Cˣ) : C) = ++ algebraMap K C (((πData.integer ^ m : 𝓞 K) : K)) := by ++ have hIntegerPow : ++ (((πData.integer ^ m : 𝓞 K) : K)) = ++ (πData.integer : K) ^ m := by ++ exact map_pow (algebraMap (𝓞 K) K) πData.integer m ++ rw [Units.val_pow_eq_pow_val, hπC, hIntegerPow, map_pow] ++ calc ++ ‖((πC ^ m : Cˣ) : C)‖ = ++ ‖algebraMap K C ((πData.integer ^ m : 𝓞 K) : K)‖ := ++ congrArg norm hπCPow ++ _ = HeightOneSpectrum.adicAbv K v ++ ((πData.integer ^ m : 𝓞 K) : K) := ++ AbsoluteValue.completionAbsoluteValue_coe ++ (HeightOneSpectrum.adicAbv K v) ++ ((πData.integer ^ m : 𝓞 K) : K) ++ _ = ++ (WithZeroMulInt.toNNReal ++ (HeightOneSpectrum.absNorm_ne_zero v) ++ (WithZero.exp (-(m : ℤ))) : ℝ) := by ++ rw [HeightOneSpectrum.adicAbv_def, ++ HeightOneSpectrum.valuation_of_algebraMap, hIntPiPow] ++ have hraw : ++ ValuativeRel.valuation C (xC : C) = ++ ValuativeRel.valuation C ((πC ^ m : Cˣ) : C) := by ++ apply canonicalValuation_eq_of_valuation_eq ++ (v := NormedField.valuation (K := C)) ++ apply NNReal.eq ++ simpa only [NormedField.valuation_apply, coe_nnnorm] using ++ hnormX.trans hnormPiPow.symm ++ have hValuationMap : ++ valuationMap C (Additive.ofMul xC) = ++ valuationMap C (Additive.ofMul (πC ^ m)) := by ++ rw [valuationMap_apply, valuationMap_apply] ++ unfold IsNonarchimedeanLocalField.v ++ congr 2 ++ exact congrArg ++ (_root_.IsNonarchimedeanLocalField.valueGroupWithZeroIsoInt C) hraw ++ have hπCValuation : ++ valuationMap C (Additive.ofMul πC) = -1 := by ++ rw [valuationMap_apply] ++ exact ++ v_integerRingIrreducibleFieldUnit C πData.completionInteger ++ hπIrreducible πC rfl ++ calc ++ finitePlaceNormalizedValuation K v ++ (nonzeroIntegralFieldUnit K x hx) = ++ valuationMap C (Additive.ofMul xC) := rfl ++ _ = valuationMap C (Additive.ofMul (πC ^ m)) := hValuationMap ++ _ = (m : ℤ) * valuationMap C (Additive.ofMul πC) := by ++ rw [valuationMap_ofMul_pow] ++ _ = -(m : ℤ) := by rw [hπCValuation]; simp ++ _ = -(AlgebraicNumberTheory.PowerResidueSymbols.idealPrimeMultiplicity K v (Ideal.span {x}) : ℤ) := rfl ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtin.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtin.lean +index 8c5d33f..4536b7d 100644 +--- a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtin.lean ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtin.lean +@@ -4,69 +4,13 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Naganori Yamaguchi (assisted by OpenAI Codex) + -/ + +-import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.CompletionToIdeal +-import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.IdealToCompletion +-import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.LocalNorm +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.AlgEquiv +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.BaseChange +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.Core +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.NormComparison +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.NormalClosureNorm +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.Tower +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.TowerAlgEquivNaturality +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.TowerBaseChange +-import ClassFieldTheory.AlgebraicNumberTheory.Idele.Relative.FinitePlaceTensorNorm +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlace +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicLocalization +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalPrimeFactorization +-import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalPrincipalLocalUnit +-import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.SemilinearNaturality +-import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.UnramifiedNormalization +-import ClassFieldTheory.LocalClassFieldTheory.LubinTateApplication.PadicMultiplicativeArtinComparison +-import ValuedFieldTheory.LocalField.DiscreteValuationField.PadicValuationComparison +-import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.UnramifiedFrobenius +-import ValuedFieldTheory.LocalField.Padic.Cyclotomic.TotallyRamified.EisensteinPolynomial +-import Mathlib.NumberTheory.NumberField.Cyclotomic.Galois ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlaceArtinPrincipal + +-set_option autoImplicit false +- +-/-! +-# Finite-place Artin symbols in rational cyclotomic levels + +-At a rational prime away from the cyclotomic level, the chosen completed +-extension is unramified. Its normalized local Artin map is therefore the +-arithmetic Frobenius raised to the local valuation. The genuine primitive +-root in the localized cyclotomic level identifies the image of arithmetic +-Frobenius under the global cyclotomic character with the residue prime. +--/ ++set_option autoImplicit false + + open scoped Classical NNReal NumberField ValuativeRel + open NumberField IsDedekindDomain +- +-noncomputable section +- +-namespace GlobalClassFieldTheory +-namespace Reciprocity +- +--- Specializing the generic finite-place comparison to `ℚ` must retain its +--- `Algebra.id` owner rather than selecting the competing rational-field +--- instance introduced after specialization. +-@[reducible] noncomputable local instance +- rationalFinitePlaceCompletionRatAlgebra +- (v : HeightOneSpectrum (𝓞 ℚ)) : +- Algebra ℚ (HeightOneSpectrum.adicAbv ℚ v).Completion := by +- letI : Algebra ℚ ℚ := Algebra.id ℚ +- let hWith : Algebra ℚ +- (WithAbs (HeightOneSpectrum.adicAbv ℚ v)) := +- WithAbs.instAlgebra _ +- let hUniform : UniformContinuousConstSMul ℚ +- (WithAbs (HeightOneSpectrum.adicAbv ℚ v)) := +- WithAbs.instUniformContinuousConstSMulReal _ +- exact +- @UniformSpace.Completion.algebra +- (WithAbs (HeightOneSpectrum.adicAbv ℚ v)) _ _ _ _ +- ℚ _ hWith hUniform +- + open AlgebraicNumberTheory.Valuations + open HilbertRamification + open LocalClassFieldTheory +@@ -75,2260 +19,54 @@ open LocalFieldTheory.DiscreteValuationField + open LocalFieldTheory.DiscreteValuationField.Examples.Qp + open LubinTate + +-private theorem mappedAbelianLocalArtin_eq_frobenius_zpow +- {F E G : Type} +- [Field F] [ValuativeRel F] [TopologicalSpace F] +- [IsNonarchimedeanLocalField F] +- [Field E] [ValuativeRel E] [UniformSpace E] [IsUniformAddGroup E] +- [IsNonarchimedeanLocalField E] +- [Algebra F E] [FiniteDimensional F E] [IsAbelianGalois F E] +- [Valuation.HasExtension +- (ValuativeRel.valuation F) (ValuativeRel.valuation E)] +- [IsNonarchimedeanLocalField.IsUnramifiedValuedExtension F E] +- [Group G] +- (f : (E ≃ₐ[F] E) →* G) (x : Fˣ) : +- f (LocalClassFieldTheory.abelianLocalArtinMonoidHom F E x) = +- (f (arithmeticFrobeniusOfUnramifiedValuation F E)) ^ +- IsNonarchimedeanLocalField.valuationMap F +- (Additive.ofMul x) := by +- rw [LocalClassFieldTheory.abelianLocalArtinMonoidHom_eq_frobenius_zpow, +- map_zpow] +- +-local instance (q : Nat.Primes) : Fact q.1.Prime := +- ⟨q.2⟩ +- +-local instance (m : ℕ+) : NeZero (m : ℕ) := +- ⟨m.ne_zero⟩ +- +-noncomputable local instance +- rationalCyclotomicLevelFiniteDimensional +- (m : ℕ+) : +- FiniteDimensional ℚ +- (KummerTheory.rationalCyclotomicLevel m) := +- IsCyclotomicExtension.finiteDimensional +- {(m : ℕ)} ℚ (KummerTheory.rationalCyclotomicLevel m) +- +-noncomputable local instance +- rationalCyclotomicLevelIsAbelianGalois +- (m : ℕ+) : +- IsAbelianGalois ℚ +- (KummerTheory.rationalCyclotomicLevel m) := by +- have : IsGalois ℚ +- (KummerTheory.rationalCyclotomicLevel m) := +- inferInstance +- let e := +- IsCyclotomicExtension.Rat.galEquivZMod +- (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) +- exact +- { is_comm.comm σ τ := by +- apply e.injective +- simp only [map_mul] +- exact mul_comm _ _ } +- +-@[reducible] +-noncomputable local instance rationalFinitePlaceBaseNontriviallyNormedField +- (q : Nat.Primes) : +- NontriviallyNormedField +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion := +- absoluteValueExtension_completionNontriviallyNormedField +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)) +- (RayClass.adicAbv_isNontrivial +- (RayClass.rationalPrime q)) +- +-noncomputable local instance rationalFinitePlaceBaseLocallyCompactSpace +- (q : Nat.Primes) : +- LocallyCompactSpace +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion := +- AbsoluteValue.Completion.locallyCompactSpace +- (finitePlaceCompletionBaseMap_isometry +- (RayClass.rationalPrime q)) +- +-noncomputable local instance rationalFinitePlaceBaseIsUltrametricDist +- (q : Nat.Primes) : +- IsUltrametricDist +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion := +- finitePlaceArtinCompletionIsUltrametricDist +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)) +- (HeightOneSpectrum.isNonarchimedean_adicAbv +- ℚ (RayClass.rationalPrime q)) +- +-@[reducible] +-noncomputable local instance rationalFinitePlaceBaseValued +- (q : Nat.Primes) : +- Valued +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion ℝ≥0 := +- finitePlaceArtinCompletionValued +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)) +- (HeightOneSpectrum.isNonarchimedean_adicAbv +- ℚ (RayClass.rationalPrime q)) +- +-@[reducible] +-noncomputable local instance rationalFinitePlaceBaseValuativeRel +- (q : Nat.Primes) : +- ValuativeRel +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion := +- finitePlaceLocalArtinCompletionValuativeRel +- (K := ℚ) (RayClass.rationalPrime q) +- +-noncomputable local instance +- rationalFinitePlaceBaseValuationIsNontrivial +- (q : Nat.Primes) : +- (Valued.v : +- Valuation +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- ℝ≥0).IsNontrivial := +- (inferInstance : +- (NormedField.valuation +- (K := +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion)).IsNontrivial) +- +-noncomputable local instance rationalFinitePlaceBaseValuationCompatible +- (q : Nat.Primes) : +- (Valued.v : +- Valuation +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- ℝ≥0).Compatible := +- Valuation.Compatible.ofValuation _ +- +-noncomputable local instance +- rationalFinitePlaceBaseValuativeRelIsNontrivial +- (q : Nat.Primes) : +- ValuativeRel.IsNontrivial +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion := +- (ValuativeRel.isNontrivial_iff_isNontrivial +- (Valued.v : +- Valuation +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- ℝ≥0)).2 inferInstance +- +-noncomputable local instance rationalFinitePlaceBaseIsValuativeTopology +- (q : Nat.Primes) : +- IsValuativeTopology +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion := +- isValuativeTopology_of_valued_ofValuation +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion ℝ≥0 +- +-noncomputable local instance +- rationalFinitePlaceBaseIsNonarchimedeanLocalField +- (q : Nat.Primes) : +- IsNonarchimedeanLocalField +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion := +- finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField +- (K := ℚ) (RayClass.rationalPrime q) +- +-/-! Named compatibility witnesses used by the ramified-prime and ray-norm +-modules. They are not installed as a duplicate module-level instance family; +-the canonical instances above already provide the same data. -/ +- +-/-- Rational cyclotomic levels are finite-dimensional over `ℚ`. -/ +-theorem rationalCyclotomicPrincipalPrimeLevelFiniteDimensional +- (m : ℕ+) : +- FiniteDimensional ℚ (KummerTheory.rationalCyclotomicLevel m) := +- rationalCyclotomicLevelFiniteDimensional m +- +-/-- Rational cyclotomic levels are abelian Galois extensions of `ℚ`. -/ +-theorem rationalCyclotomicPrincipalPrimeLevelIsAbelianGalois +- (m : ℕ+) : +- IsAbelianGalois ℚ (KummerTheory.rationalCyclotomicLevel m) := +- rationalCyclotomicLevelIsAbelianGalois m +- +-/-- The canonical nontrivially normed field structure on the completion of +-`ℚ` at the rational prime `p`, exposed for principal-prime constructions. -/ +-@[reducible] +-noncomputable def rationalPrimeFactorCompletionNontriviallyNormedField +- (p : Nat.Primes) : +- NontriviallyNormedField +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion := +- rationalFinitePlaceBaseNontriviallyNormedField p +- +-/-- The completion of `ℚ` at `p` is locally compact. -/ +-theorem rationalPrimeFactorCompletionLocallyCompactSpace +- (p : Nat.Primes) : +- LocallyCompactSpace +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion := +- rationalFinitePlaceBaseLocallyCompactSpace p +- +-/-- The completion of `ℚ` at `p` carries its canonical ultrametric distance. -/ +-theorem rationalPrimeFactorCompletionIsUltrametricDist +- (p : Nat.Primes) : +- IsUltrametricDist +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion := +- rationalFinitePlaceBaseIsUltrametricDist p +- +-/-- The canonical `ℝ≥0`-valued structure on the completion of `ℚ` at `p`. -/ +-@[reducible] +-noncomputable def rationalPrimeFactorCompletionValued +- (p : Nat.Primes) : +- Valued +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion ℝ≥0 := +- rationalFinitePlaceBaseValued p +- +-/-- The valuative relation induced by the canonical valuation on the +-completion of `ℚ` at `p`. -/ +-@[reducible] +-noncomputable def rationalPrimeFactorCompletionValuativeRel +- (p : Nat.Primes) : +- ValuativeRel +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion := +- rationalFinitePlaceBaseValuativeRel p +- +-/-- The canonical valuation on the completion of `ℚ` at `p` is nontrivial. -/ +-theorem rationalPrimeFactorCompletionValuationIsNontrivial +- (p : Nat.Primes) : +- (Valued.v : Valuation +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion ℝ≥0).IsNontrivial := +- rationalFinitePlaceBaseValuationIsNontrivial p +- +-/-- The canonical valuation on the completion of `ℚ` at `p` is compatible +-with its field structure. -/ +-theorem rationalPrimeFactorCompletionValuationCompatible +- (p : Nat.Primes) : +- (Valued.v : Valuation +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion ℝ≥0).Compatible := +- rationalFinitePlaceBaseValuationCompatible p +- +-/-- The canonical valuative relation on the completion at `p` is nontrivial. -/ +-theorem rationalPrimeFactorCompletionValuativeRelIsNontrivial +- (p : Nat.Primes) : +- ValuativeRel.IsNontrivial +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion := +- rationalFinitePlaceBaseValuativeRelIsNontrivial p +- +-/-- The completion topology at `p` is induced by its canonical valuation. -/ +-theorem rationalPrimeFactorCompletionIsValuativeTopology +- (p : Nat.Primes) : +- IsValuativeTopology +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion := +- rationalFinitePlaceBaseIsValuativeTopology p +- +-/-- The completion of `ℚ` at `p` is a nonarchimedean local field. -/ +-theorem rationalPrimeFactorCompletionIsNonarchimedeanLocalField +- (p : Nat.Primes) : +- IsNonarchimedeanLocalField +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion := +- rationalFinitePlaceBaseIsNonarchimedeanLocalField p +- +-/-- The positive conductor of the `n`-th ramified cyclotomic level at +-`p`. -/ +-def rationalCyclotomicPrincipalPrimeModulus +- (p : Nat.Primes) (n : ℕ) : ℕ+ := +- ⟨p.1 ^ (n + 1), pow_pos p.2.pos (n + 1)⟩ +- +-/-- The rational finite-place completion used at the prime `p`. -/ +-abbrev RationalCyclotomicPrincipalPrimeCompletion +- (p : Nat.Primes) := +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion +- +-/-- The chosen localized cyclotomic field at level `p ^ (n + 1)`. -/ +-abbrev RationalCyclotomicPrincipalPrimeLocalizedLevel +- (p : Nat.Primes) (n : ℕ) := +- rationalCyclotomicLocalizedCompletion +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p) +- +-/-- The standard multiplicative Lubin--Tate field at level `n`. -/ +-abbrev RationalCyclotomicPrincipalPrimePadicLevel +- (p : Nat.Primes) (n : ℕ) := +- standardLubinTateLevelField +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n +- +-/-- The valuation ring of the absolute-value completion at `q`, identified +-with the standard p-adic integer ring `ℤ_q`. -/ +-noncomputable def rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- (q : Nat.Primes) : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion] ≃+* +- ℤ_[q.1] := by +- let v : HeightOneSpectrum (𝓞 ℚ) := +- RayClass.rationalPrime q +- let vQ := HeightOneSpectrum.adicAbv ℚ v +- let eConcreteIntegers : +- 𝒪[vQ.Completion] ≃+* +- v.adicCompletionIntegers ℚ := +- finitePlaceCompletionIntegerRingEquiv v +- exact +- eConcreteIntegers.trans +- (PadicInt.adicCompletionIntegersEquiv +- (𝓞 ℚ) q).symm.toRingEquiv +- +-/-- The absolute-value completion at the rational prime `q`, identified +-with the standard field `ℚ_q`. -/ +-noncomputable def rationalFinitePlaceCompletionRingEquivPadic +- (q : Nat.Primes) : +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion ≃+* +- ℚ_[q.1] := +- IsFractionRing.ringEquivOfRingEquiv +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) +- +-/-- The completion-to-`ℚ_q` equivalence respects the rational embedding. -/ +-theorem rationalFinitePlaceCompletionRingEquivPadic_algebraMap +- (q : Nat.Primes) (a : ℚ) : +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion a) = +- algebraMap ℚ ℚ_[q.1] a := by +- exact +- (rationalFinitePlaceCompletionRingEquivPadic q).toRingHom.map_rat_algebraMap a +- +-/-- The completion field equivalence and its restriction to valuation +-rings commute with the natural inclusions into the fields. -/ +-theorem rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe +- (q : Nat.Primes) +- (a : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion]) : +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion] +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion a) = +- algebraMap ℤ_[q.1] ℚ_[q.1] +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q a) := by +- exact +- (IsFractionRing.ringEquivOfRingEquiv_algebraMap +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) a) +- +-/-- The canonical rational-completion equivalence preserves the canonical +-valuations. -/ +-theorem +- rationalFinitePlaceCompletionRingEquivPadic_semilinearValuationCompatible +- (p : Nat.Primes) : +- SemilinearValuationCompatible +- (RationalCyclotomicPrincipalPrimeCompletion p) ℚ_[p.1] +- (rationalFinitePlaceCompletionRingEquivPadic p) := by +- let F := RationalCyclotomicPrincipalPrimeCompletion p +- let eK := rationalFinitePlaceCompletionRingEquivPadic p +- let : Algebra F ℚ_[p.1] := eK.toRingHom.toAlgebra +- change +- (ValuativeRel.valuation F).HasExtension +- (ValuativeRel.valuation ℚ_[p.1]) +- let eO := +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt p).trans +- (padicIntEquivValuationSubring p.1) +- have hChosen : +- (localCompleteDVF F).valuation.HasExtension +- (padicDVRValuation p.1) := by +- change +- (localCompleteDVF F).valuation.HasExtension +- (padicCompleteDVF p.1).valuation +- apply +- ValuationTheory.DiscreteValuationField.ValuedExtension.valuation_hasExtension_of_valuationSubring_equiv +- (localCompleteDVF F) +- (padicCompleteDVF p.1) +- eO +- intro z +- change +- algebraMap +- (padicDVRValuation p.1).valuationSubring ℚ_[p.1] +- (padicIntEquivValuationSubring p.1 +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- p z)) = +- rationalFinitePlaceCompletionRingEquivPadic p +- (algebraMap 𝒪[F] F z) +- symm +- calc +- rationalFinitePlaceCompletionRingEquivPadic p +- (algebraMap 𝒪[F] F z) = +- algebraMap ℤ_[p.1] ℚ_[p.1] +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- p z) := +- rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe +- p z +- _ = +- algebraMap +- (padicDVRValuation p.1).valuationSubring ℚ_[p.1] +- (padicIntEquivValuationSubring p.1 +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- p z)) := by +- rw [PadicInt.algebraMap_apply, +- ValuationSubring.algebraMap_apply] +- exact +- (padicIntEquivValuationSubring_coe p.1 +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- p z)).symm +- have hBase : +- (ValuativeRel.valuation F).HasExtension +- (padicDVRValuation p.1) := by +- rw [← localCompleteDVF_valuation_eq] +- exact hChosen +- refine +- { val_isEquiv_comap := ?_ } +- exact +- hBase.val_isEquiv_comap.trans +- ((padicDVRValuation_isEquiv_valuativeRelValuation +- p.1).comap (algebraMap F ℚ_[p.1])) +- +-/-- The rational prime, pulled back from `ℤ_q` to the valuation ring of +-the absolute-value completion at `q`. -/ +-noncomputable def rationalPrimeFinitePlaceInteger +- (q : Nat.Primes) : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion] := +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q).symm +- (q.1 : ℤ_[q.1]) +- +-/-- The pulled-back rational prime is irreducible in the completion +-valuation ring. -/ +-theorem rationalPrimeFinitePlaceInteger_irreducible +- (q : Nat.Primes) : +- Irreducible (rationalPrimeFinitePlaceInteger q) := by +- exact +- (MulEquiv.irreducible_iff +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- q).symm.toMulEquiv).2 +- ((PadicInt.prime_p : +- Prime (q.1 : ℤ_[q.1])).irreducible) +- +-/-- Coercing the pulled-back prime to the completion field gives the +-ordinary image of the rational number `q`. -/ +-theorem rationalPrimeFinitePlaceInteger_coe +- (q : Nat.Primes) : +- ((rationalPrimeFinitePlaceInteger q : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion]) : +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion) = +- algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (q.1 : ℚ) := by +- apply +- (rationalFinitePlaceCompletionRingEquivPadic q).injective +- change +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion] +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeFinitePlaceInteger q)) = +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (q.1 : ℚ)) +- calc +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion] +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeFinitePlaceInteger q)) = +- algebraMap ℤ_[q.1] ℚ_[q.1] +- ((rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) +- (rationalPrimeFinitePlaceInteger q)) := +- rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe +- q (rationalPrimeFinitePlaceInteger q) +- _ = (q.1 : ℚ_[q.1]) := by +- rw [rationalPrimeFinitePlaceInteger, +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- q).apply_symm_apply, +- PadicInt.algebraMap_apply, +- PadicInt.coe_natCast] +- _ = +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (q.1 : ℚ)) := by +- rw [ +- rationalFinitePlaceCompletionRingEquivPadic_algebraMap] +- norm_num +- +-/-- The rational prime as a field unit of its absolute-value completion. -/ +-noncomputable def rationalPrimeFinitePlaceFieldUnit +- (q : Nat.Primes) : +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completionˣ := +- Units.mk0 +- (rationalPrimeFinitePlaceInteger q : +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion) +- (by +- intro hzero +- exact +- (rationalPrimeFinitePlaceInteger_irreducible q).ne_zero +- (Subtype.ext hzero)) +- +-/-- In the inverse-standard local reciprocity normalization, the rational +-prime itself has normalized additive value `-1`. -/ +-theorem rationalPrimeFinitePlaceFieldUnit_valuationMap +- (q : Nat.Primes) : +- IsNonarchimedeanLocalField.valuationMap +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (Additive.ofMul +- (rationalPrimeFinitePlaceFieldUnit q)) = +- -1 := by +- simpa [IsNonarchimedeanLocalField.valuationMap_apply] using +- (LocalFieldTheory.v_integerRingIrreducibleFieldUnit +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeFinitePlaceInteger q) +- (rationalPrimeFinitePlaceInteger_irreducible q) +- (rationalPrimeFinitePlaceFieldUnit q) rfl) +- +-/-- The rational `q`-unit part of `x`, pulled back from `ℤ_qˣ` to the +-valuation ring of the absolute-value completion. -/ +-noncomputable def rationalPrimeUnitFinitePlaceIntegerUnit +- (x : ℚˣ) (q : Nat.Primes) : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion]ˣ := +- Units.map +- (rationalFinitePlaceCompletionIntegerRingEquivPadicInt +- q).symm.toMonoidHom +- (padicIntUnitOfRat q +- (rationalPrimeUnit x q : ℚ) +- (rationalPrimeUnit x q).ne_zero +- (padicValRat_rationalPrimeUnit x q)) +- +-/-- Forgetting the integrality proof from the pulled-back `q`-unit gives +-the ordinary image of the rational `q`-unit in the completion field. -/ +-theorem rationalPrimeUnitFinitePlaceIntegerUnit_coe +- (x : ℚˣ) (q : Nat.Primes) : +- (((rationalPrimeUnitFinitePlaceIntegerUnit x q : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion]ˣ) : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion]) : +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion) = +- algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeUnit x q : ℚ) := by +- apply +- (rationalFinitePlaceCompletionRingEquivPadic q).injective +- change +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion] +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeUnitFinitePlaceIntegerUnit x q : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion])) = +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeUnit x q : ℚ)) +- calc +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion] +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeUnitFinitePlaceIntegerUnit x q : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion])) = +- algebraMap ℤ_[q.1] ℚ_[q.1] +- ((rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) +- (rationalPrimeUnitFinitePlaceIntegerUnit x q : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion])) := +- rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe q +- (rationalPrimeUnitFinitePlaceIntegerUnit x q : +- 𝒪[(HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion]) +- _ = +- ((padicIntUnitOfRat q +- (rationalPrimeUnit x q : ℚ) +- (rationalPrimeUnit x q).ne_zero +- (padicValRat_rationalPrimeUnit x q) : +- ℤ_[q.1]) : ℚ_[q.1]) := by +- rw [rationalPrimeUnitFinitePlaceIntegerUnit] +- simp [PadicInt.algebraMap_apply] +- _ = ((rationalPrimeUnit x q : ℚ) : ℚ_[q.1]) := by +- rw [padicIntUnitOfRat_coe] +- _ = +- rationalFinitePlaceCompletionRingEquivPadic q +- (algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeUnit x q : ℚ)) := by +- rw [ +- rationalFinitePlaceCompletionRingEquivPadic_algebraMap] +- simp +- +-/-- The completion field unit underlying the pulled-back rational `q`-unit +-has normalized additive value zero. -/ +-theorem rationalPrimeUnitFinitePlaceField_valuationMap +- (x : ℚˣ) (q : Nat.Primes) : +- IsNonarchimedeanLocalField.valuationMap +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (Additive.ofMul +- (IsNonarchimedeanLocalField.integerUnitsToFieldUnits +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeUnitFinitePlaceIntegerUnit x q))) = +- 0 := by +- rw [IsNonarchimedeanLocalField.valuationMap_apply] +- exact +- IsNonarchimedeanLocalField.v_integerUnitsToFieldUnits +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (rationalPrimeUnitFinitePlaceIntegerUnit x q) +- +-/-- The rational prime `q`, regarded as a unit of `ℚ`. -/ +-def rationalPrimeGeneratorUnit (q : Nat.Primes) : ℚˣ := +- Units.mk0 (q.1 : ℚ) (by exact_mod_cast q.2.ne_zero) +- +-/-- The underlying rational number of the prime generator unit is `q`. -/ +-@[simp] +-theorem rationalPrimeGeneratorUnit_coe (q : Nat.Primes) : +- (rationalPrimeGeneratorUnit q : ℚ) = q.1 := +- rfl +- +-/-- Reattaching the removed `q`-power to the rational `q`-unit recovers +-the original rational field unit. -/ +-theorem rationalPrimeGeneratorUnit_zpow_mul_rationalPrimeUnit +- (x : ℚˣ) (q : Nat.Primes) : +- rationalPrimeGeneratorUnit q ^ +- padicValRat q.1 (x : ℚ) * +- rationalPrimeUnit x q = +- x := by +- rw [rationalPrimeGeneratorUnit, rationalPrimeUnit, +- ← mul_assoc, ← zpow_add] +- simp +- +-/-- The source unit in the absolute-value completion represented by the +-finite component of a rational principal idele. -/ +-noncomputable def rationalPrincipalFinitePlaceInput +- (x : ℚˣ) (q : Nat.Primes) : +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completionˣ := +- (finitePlaceCompletionUnitsContinuousMulEquiv +- (RayClass.rationalPrime q)).symm +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime q) +- (IdeleGroup.principalIdele ℚ x)) +- +-/-- The source unit represented by a principal finite component is the +-ordinary image of the rational field unit in the absolute-value +-completion. -/ +-theorem rationalPrincipalFinitePlaceInput_eq_algebraMap +- (x : ℚˣ) (q : Nat.Primes) : +- rationalPrincipalFinitePlaceInput x q = +- Units.map +- (algebraMap ℚ +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion).toMonoidHom +- x := by +- apply Units.ext +- let v : HeightOneSpectrum (𝓞 ℚ) := +- RayClass.rationalPrime q +- let vQ := HeightOneSpectrum.adicAbv ℚ v +- let component : (v.adicCompletion ℚ)ˣ := +- IdeleGroup.finiteComponent v +- (IdeleGroup.principalIdele ℚ x) +- apply (finitePlaceCompletionRingEquiv v).injective +- change +- finitePlaceCompletionRingEquiv v +- (rationalPrincipalFinitePlaceInput x q : vQ.Completion) = +- finitePlaceCompletionRingEquiv v +- (algebraMap ℚ vQ.Completion (x : ℚ)) +- have hCompletion : +- finitePlaceCompletionRingEquiv v +- (rationalPrincipalFinitePlaceInput x q : +- vQ.Completion) = +- (component : v.adicCompletion ℚ) := by +- have hUnits := +- congrArg Units.val +- ((finitePlaceCompletionUnitsContinuousMulEquiv v).apply_symm_apply +- component) +- exact hUnits +- have hComponent : +- (component : v.adicCompletion ℚ) = +- algebraMap ℚ (v.adicCompletion ℚ) (x : ℚ) := by +- apply (Padic.adicCompletionEquiv (𝓞 ℚ) q).symm.injective +- calc +- (Padic.adicCompletionEquiv (𝓞 ℚ) q).symm +- (component : v.adicCompletion ℚ) = +- algebraMap ℚ ℚ_[q.1] (x : ℚ) := by +- dsimp only [component] +- rw [IdeleGroup.finiteComponent_principalIdele] +- exact +- (Padic.adicCompletionEquiv +- (𝓞 ℚ) q).symm.commutes (x : ℚ) +- _ = (Padic.adicCompletionEquiv (𝓞 ℚ) q).symm +- (algebraMap ℚ (v.adicCompletion ℚ) (x : ℚ)) := by +- symm +- exact +- (Padic.adicCompletionEquiv +- (𝓞 ℚ) q).symm.commutes (x : ℚ) +- calc +- finitePlaceCompletionRingEquiv v +- (rationalPrincipalFinitePlaceInput x q : +- vQ.Completion) = +- (component : v.adicCompletion ℚ) := hCompletion +- _ = algebraMap ℚ (v.adicCompletion ℚ) (x : ℚ) := hComponent +- _ = finitePlaceCompletionRingEquiv v +- (algebraMap ℚ vQ.Completion (x : ℚ)) := by +- symm +- exact +- (finitePlaceCompletionAlgEquiv (K := ℚ) v).commutes (x : ℚ) +- +-/-- The normalized local exponent of a rational principal finite +-component is the negative of the usual `q`-adic exponent. The minus sign +-records the inverse-standard local reciprocity convention in which a +-prime element has normalized value `-1`. -/ +-theorem rationalPrincipalFiniteComponent_valuationMap +- (x : ℚˣ) (q : Nat.Primes) : +- IsNonarchimedeanLocalField.valuationMap +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (Additive.ofMul +- ((finitePlaceCompletionUnitsContinuousMulEquiv +- (RayClass.rationalPrime q)).symm +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime q) +- (IdeleGroup.principalIdele ℚ x)))) = +- -padicValRat q.1 (x : ℚ) := by +- let F := +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- let embed : ℚˣ →* Fˣ := +- Units.map (algebraMap ℚ F).toMonoidHom +- let primeUnit : Fˣ := +- rationalPrimeFinitePlaceFieldUnit q +- let integralUnit : 𝒪[F]ˣ := +- rationalPrimeUnitFinitePlaceIntegerUnit x q +- let unitPart : Fˣ := +- IsNonarchimedeanLocalField.integerUnitsToFieldUnits +- F integralUnit +- have hInput : +- rationalPrincipalFinitePlaceInput x q = +- embed x := by +- exact rationalPrincipalFinitePlaceInput_eq_algebraMap x q +- have hPrime : +- embed (rationalPrimeGeneratorUnit q) = +- primeUnit := by +- apply Units.ext +- exact +- (rationalPrimeFinitePlaceInteger_coe q).symm +- have hUnit : +- embed (rationalPrimeUnit x q) = +- unitPart := by +- apply Units.ext +- exact +- (rationalPrimeUnitFinitePlaceIntegerUnit_coe +- x q).symm +- change +- IsNonarchimedeanLocalField.valuationMap F +- (Additive.ofMul +- (rationalPrincipalFinitePlaceInput x q)) = +- -padicValRat q.1 (x : ℚ) +- rw [hInput] +- conv_lhs => +- rw [← rationalPrimeGeneratorUnit_zpow_mul_rationalPrimeUnit +- x q] +- rw [map_mul, map_zpow, hPrime, hUnit, +- IsNonarchimedeanLocalField.valuationMap_ofMul_mul, +- IsNonarchimedeanLocalField.valuationMap_ofMul_zpow, +- rationalPrimeFinitePlaceFieldUnit_valuationMap, +- rationalPrimeUnitFinitePlaceField_valuationMap] +- ring +- +-/-- The principal finite component of the rational prime itself has +-normalized local exponent `-1`. -/ +-theorem rationalPrimePrincipalFiniteComponent_valuationMap +- (q : Nat.Primes) : +- IsNonarchimedeanLocalField.valuationMap +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime q)).Completion +- (Additive.ofMul +- ((finitePlaceCompletionUnitsContinuousMulEquiv +- (RayClass.rationalPrime q)).symm +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime q) +- (IdeleGroup.principalIdele ℚ +- (rationalPrimeGeneratorUnit q))))) = +- -1 := by +- rw [rationalPrincipalFiniteComponent_valuationMap, +- rationalPrimeGeneratorUnit_coe, +- padicValRat.self q.2.one_lt] +- +-/-- A cyclotomic automorphism which raises the selected primitive root to +-the `q`-th power has cyclotomic character equal to the residue-prime unit. -/ +-private theorem rationalCyclotomicLevel_galEquivZMod_eq_unitOfCoprime +- (m : ℕ+) (q : Nat.Primes) +- (hq : ¬ q.1 ∣ (m : ℕ)) +- (σ : KummerTheory.rationalCyclotomicLevel m ≃ₐ[ℚ] +- KummerTheory.rationalCyclotomicLevel m) +- (hσ : +- σ (rationalCyclotomicLevelPrimitiveRoot m) = +- rationalCyclotomicLevelPrimitiveRoot m ^ q.1) : +- IsCyclotomicExtension.Rat.galEquivZMod +- (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ = +- ZMod.unitOfCoprime q.1 +- (q.2.coprime_iff_not_dvd.mpr hq) := by +- let ζ := rationalCyclotomicLevelPrimitiveRoot m +- have hζ : IsPrimitiveRoot ζ (m : ℕ) := +- rationalCyclotomicLevelPrimitiveRoot_isPrimitiveRoot m +- have hCharacterRoot : +- σ ζ = +- ζ ^ +- (IsCyclotomicExtension.Rat.galEquivZMod +- (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ).val.val := +- IsCyclotomicExtension.Rat.galEquivZMod_apply_of_pow_eq +- (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ +- hζ.pow_eq_one +- have hPowers : +- ζ ^ +- (IsCyclotomicExtension.Rat.galEquivZMod +- (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ).val.val = +- ζ ^ q.1 := +- hCharacterRoot.symm.trans hσ +- rw [(hζ.isOfFinOrder m.ne_zero).pow_inj_mod, +- ← hζ.eq_orderOf, +- ← ZMod.natCast_eq_natCast_iff', +- ZMod.natCast_val] at hPowers +- apply Units.ext +- simpa using hPowers +- +-private abbrev rationalCyclotomicArtinPlace (q : Nat.Primes) : +- HeightOneSpectrum (𝓞 ℚ) := +- RayClass.rationalPrime q +- +-private abbrev rationalCyclotomicArtinBaseAbv (q : Nat.Primes) : +- AbsoluteValue ℚ ℝ := +- HeightOneSpectrum.adicAbv ℚ (rationalCyclotomicArtinPlace q) +- +-private abbrev rationalCyclotomicArtinLevel (m : ℕ+) := +- KummerTheory.rationalCyclotomicLevel m +- +-private abbrev rationalCyclotomicArtinExtension +- (m : ℕ+) (q : Nat.Primes) : +- AbsoluteValueExtension +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinLevel m) := +- chosenFinitePlaceExtension +- (L := rationalCyclotomicArtinLevel m) +- (rationalCyclotomicArtinPlace q) +- +-private abbrev rationalCyclotomicArtinLocalizedField +- (m : ℕ+) (q : Nat.Primes) := +- AlgebraicNumberTheory.Valuations.LocalizedCompletion +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q) +- +-@[reducible] +-noncomputable local instance rationalCyclotomicArtinExtensionAlgebra +- (m : ℕ+) (q : Nat.Primes) : +- Algebra ℚ +- (rationalCyclotomicArtinExtension m q).1.Completion := +- AbsoluteValue.extensionCompletionAlgebra +- (K := ℚ) (rationalCyclotomicArtinExtension m q).1 +- +-@[reducible] +-noncomputable local instance rationalCyclotomicArtinExtensionSMul +- (m : ℕ+) (q : Nat.Primes) : +- SMul ℚ +- (rationalCyclotomicArtinExtension m q).1.Completion := +- (rationalCyclotomicArtinExtensionAlgebra m q).toSMul +- +-@[reducible] +-noncomputable local instance +- rationalCyclotomicArtinCompletionAlgebra +- (m : ℕ+) (q : Nat.Primes) : +- Algebra (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinExtension m q).1.Completion := +- AbsoluteValue.completionAlgebra +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q).1 +- (rationalCyclotomicArtinExtension m q).2 +- +-@[reducible] +-noncomputable local instance rationalCyclotomicArtinLocalizedAlgebra +- (m : ℕ+) (q : Nat.Primes) : +- Algebra (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinLocalizedField m q) := +- finitePlaceLocalArtinLocalizedAlgebra +- (K := ℚ) (L := rationalCyclotomicArtinLevel m) +- (rationalCyclotomicArtinPlace q) +- (rationalCyclotomicArtinExtension m q) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedGlobalAlgebra +- (m : ℕ+) (q : Nat.Primes) : +- Algebra ℚ (rationalCyclotomicArtinLocalizedField m q) := +- LocalClassFieldTheory.localizedCompletionGlobalAlgebra +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedGlobalSMul +- (m : ℕ+) (q : Nat.Primes) : +- SMul ℚ (rationalCyclotomicArtinLocalizedField m q) := +- (rationalCyclotomicArtinLocalizedGlobalAlgebra m q).toSMul +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedScalarTower +- (m : ℕ+) (q : Nat.Primes) : +- IsScalarTower ℚ +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinLocalizedField m q) := by +- constructor +- intro r x y +- simp only [Algebra.smul_def, map_mul, eq_ratCast, +- map_ratCast, mul_assoc] +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedFiniteDimensional +- (m : ℕ+) (q : Nat.Primes) : +- FiniteDimensional +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinLocalizedField m q) := +- finitePlaceLocalArtinFiniteDimensional +- (K := ℚ) (L := rationalCyclotomicArtinLevel m) +- (rationalCyclotomicArtinPlace q) +- (rationalCyclotomicArtinExtension m q) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIsAbelianGalois +- (m : ℕ+) (q : Nat.Primes) : +- IsAbelianGalois +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinLocalizedField m q) := +- finitePlaceLocalArtinIsAbelianGalois +- (K := ℚ) (L := rationalCyclotomicArtinLevel m) +- (rationalCyclotomicArtinPlace q) +- (rationalCyclotomicArtinExtension m q) +- (inferInstance : +- FiniteDimensional ℚ (rationalCyclotomicArtinLevel m)) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIsSeparable +- (m : ℕ+) (q : Nat.Primes) : +- Algebra.IsSeparable +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinLocalizedField m q) := +- (rationalCyclotomicArtinLocalizedIsAbelianGalois m q).toIsGalois.to_isSeparable +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIsCyclotomic +- (m : ℕ+) (q : Nat.Primes) : +- IsCyclotomicExtension {(m : ℕ)} +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinLocalizedField m q) := +- rationalCyclotomicLevel_localizedCompletion_isCyclotomicExtension +- m (rationalCyclotomicArtinPlace q) +- +-noncomputable local instance +- rationalCyclotomicArtinExtensionFiniteDimensional +- (m : ℕ+) (q : Nat.Primes) : +- FiniteDimensional +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinExtension m q).1.Completion := +- completionModuleFinite +- (rationalCyclotomicArtinBaseAbv q) +- (RayClass.adicAbv_isNontrivial +- (rationalCyclotomicArtinPlace q)) +- (rationalCyclotomicArtinExtension m q) +- +-noncomputable local instance +- rationalCyclotomicArtinExtensionContinuousSMul +- (m : ℕ+) (q : Nat.Primes) : +- ContinuousSMul +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinExtension m q).1.Completion := +- continuousSMul_of_algebraMap _ _ +- (AbsoluteValue.completionMap_isometry +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q).1 +- (rationalCyclotomicArtinExtension m q).2).continuous +- +-noncomputable local instance +- rationalCyclotomicArtinExtensionLocallyCompact +- (m : ℕ+) (q : Nat.Primes) : +- LocallyCompactSpace +- (rationalCyclotomicArtinExtension m q).1.Completion := +- LocallyCompactSpace.of_finiteDimensional_of_complete +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinExtension m q).1.Completion +- +-private noncomputable def +- rationalCyclotomicArtinLocalizedEquivCompletion +- (m : ℕ+) (q : Nat.Primes) : +- rationalCyclotomicArtinLocalizedField m q ≃ᵢ +- (rationalCyclotomicArtinExtension m q).1.Completion := +- { toEquiv := +- (localizedCompletionEquivCompletion +- (rationalCyclotomicArtinBaseAbv q) +- (RayClass.adicAbv_isNontrivial +- (rationalCyclotomicArtinPlace q)) +- (rationalCyclotomicArtinExtension m q)).toEquiv +- isometry_toFun := +- Isometry.of_dist_eq fun _ _ => rfl } +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedLocallyCompact +- (m : ℕ+) (q : Nat.Primes) : +- LocallyCompactSpace +- (rationalCyclotomicArtinLocalizedField m q) := +- ((rationalCyclotomicArtinLocalizedEquivCompletion m q).toHomeomorph.locallyCompactSpace_iff).2 +- inferInstance +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIsUltrametricDist +- (m : ℕ+) (q : Nat.Primes) : +- IsUltrametricDist +- (rationalCyclotomicArtinLocalizedField m q) := +- localizedCompletionIsUltrametricDist +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q) +- (HeightOneSpectrum.isNonarchimedean_adicAbv +- ℚ (rationalCyclotomicArtinPlace q)) +- +-noncomputable local instance rationalCyclotomicArtinLocalizedValued +- (m : ℕ+) (q : Nat.Primes) : +- Valued (rationalCyclotomicArtinLocalizedField m q) ℝ≥0 := +- localizedCompletionFinitePlaceValued +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q) +- (HeightOneSpectrum.isNonarchimedean_adicAbv +- ℚ (rationalCyclotomicArtinPlace q)) +- +-@[reducible] +-noncomputable local instance +- rationalCyclotomicArtinLocalizedValuativeRel +- (m : ℕ+) (q : Nat.Primes) : +- ValuativeRel (rationalCyclotomicArtinLocalizedField m q) := +- localizedCompletionFinitePlaceValuativeRel +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q) +- (HeightOneSpectrum.isNonarchimedean_adicAbv +- ℚ (rationalCyclotomicArtinPlace q)) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedValuationCompatible +- (m : ℕ+) (q : Nat.Primes) : +- (Valued.v : Valuation +- (rationalCyclotomicArtinLocalizedField m q) ℝ≥0).Compatible := +- Valuation.Compatible.ofValuation _ +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedValuationHasExtension +- (m : ℕ+) (q : Nat.Primes) : +- Valuation.HasExtension +- (ValuativeRel.valuation +- (rationalCyclotomicArtinBaseAbv q).Completion) +- (ValuativeRel.valuation +- (rationalCyclotomicArtinLocalizedField m q)) := +- localizedCompletionValuationHasExtension +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q) +- (HeightOneSpectrum.isNonarchimedean_adicAbv +- ℚ (rationalCyclotomicArtinPlace q)) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedValuationIsNontrivial +- (m : ℕ+) (q : Nat.Primes) : +- (ValuativeRel.valuation +- (rationalCyclotomicArtinLocalizedField m q)).IsNontrivial := +- Valuation.IsNontrivial.of_hasExtension +- (ValuativeRel.valuation +- (rationalCyclotomicArtinBaseAbv q).Completion) +- (ValuativeRel.valuation +- (rationalCyclotomicArtinLocalizedField m q)) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedValuativeRelIsNontrivial +- (m : ℕ+) (q : Nat.Primes) : +- ValuativeRel.IsNontrivial +- (rationalCyclotomicArtinLocalizedField m q) := +- (ValuativeRel.isNontrivial_iff_isNontrivial +- (ValuativeRel.valuation +- (rationalCyclotomicArtinLocalizedField m q))).2 inferInstance +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIsValuativeTopology +- (m : ℕ+) (q : Nat.Primes) : +- IsValuativeTopology +- (rationalCyclotomicArtinLocalizedField m q) := +- isValuativeTopology_of_valued_ofValuation +- (rationalCyclotomicArtinLocalizedField m q) ℝ≥0 +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIsNonarchimedeanLocalField +- (m : ℕ+) (q : Nat.Primes) : +- IsNonarchimedeanLocalField +- (rationalCyclotomicArtinLocalizedField m q) := +- { toIsValuativeTopology := inferInstance +- toLocallyCompactSpace := inferInstance +- toIsNontrivial := inferInstance } +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIntegerAlgebra +- (m : ℕ+) (q : Nat.Primes) : +- Algebra +- 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] +- (rationalCyclotomicArtinLocalizedField m q) := +- Algebra.ofSubsemiring +- 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIsIntegralClosure +- (m : ℕ+) (q : Nat.Primes) : +- IsIntegralClosure +- 𝒪[rationalCyclotomicArtinLocalizedField m q] +- 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] +- (rationalCyclotomicArtinLocalizedField m q) := +- localizedCompletionIsIntegralClosureWithExtension +- (rationalCyclotomicArtinBaseAbv q) +- (rationalCyclotomicArtinExtension m q) +- (RayClass.adicAbv_isNontrivial +- (rationalCyclotomicArtinPlace q)) +- (HeightOneSpectrum.isNonarchimedean_adicAbv +- ℚ (rationalCyclotomicArtinPlace q)) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedIntegerModuleFinite +- (m : ℕ+) (q : Nat.Primes) : +- Module.Finite +- 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] +- 𝒪[rationalCyclotomicArtinLocalizedField m q] := +- integerRing_moduleFinite_of_isIntegralClosure +- (rationalCyclotomicArtinBaseAbv q).Completion +- (rationalCyclotomicArtinLocalizedField m q) +- +-section RationalCyclotomicPrincipalPrime +- +-/-! ## Ramified prime-power transport +- +-This section reuses the canonical finite-place Artin tower above. In +-particular, it introduces no parallel completion/localization instance tower. -/ +- +-noncomputable local instance +- rationalCyclotomicPrincipalPrimeLevelIsCyclotomicExtension +- (p : Nat.Primes) (n : ℕ) : +- IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ +- (KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) := by +- change +- IsCyclotomicExtension +- {(rationalCyclotomicPrincipalPrimeModulus p n : ℕ)} ℚ +- (KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- exact +- KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension +- (rationalCyclotomicPrincipalPrimeModulus p n) +- +-private abbrev rationalCyclotomicPrincipalPrimePlace +- (p : Nat.Primes) : HeightOneSpectrum (𝓞 ℚ) := +- rationalCyclotomicArtinPlace p +- +-private abbrev rationalCyclotomicPrincipalPrimeLevel +- (m : ℕ+) := +- rationalCyclotomicArtinLevel m +- +-private abbrev rationalCyclotomicPrincipalPrimeExtension +- (m : ℕ+) (p : Nat.Primes) := +- rationalCyclotomicArtinExtension m p +- +-/-- The `ℚ_[p]`-algebra structure on the localized cyclotomic completion, +-transported through the canonical comparison with the `p`-adic completion. -/ +-@[reducible] +-noncomputable def +- rationalCyclotomicPrincipalPrimeLocalizedPadicAlgebra +- (m : ℕ+) (p : Nat.Primes) : +- Algebra ℚ_[p.1] +- (rationalCyclotomicLocalizedCompletion m +- (RayClass.rationalPrime p)) := +- ((algebraMap +- (HeightOneSpectrum.adicAbv ℚ +- (RayClass.rationalPrime p)).Completion +- (rationalCyclotomicLocalizedCompletion m +- (RayClass.rationalPrime p))).comp +- (rationalFinitePlaceCompletionRingEquivPadic p).symm.toRingHom).toAlgebra +- +-@[reducible] +-noncomputable local instance +- rationalCyclotomicArtinLocalizedPadicAlgebra +- (m : ℕ+) (p : Nat.Primes) : +- Algebra ℚ_[p.1] (rationalCyclotomicArtinLocalizedField m p) := +- rationalCyclotomicPrincipalPrimeLocalizedPadicAlgebra m p +- +-private noncomputable def rationalFinitePlaceCompletionAlgEquivPadic +- (p : Nat.Primes) : +- (rationalCyclotomicArtinBaseAbv p).Completion ≃ₐ[ℚ] ℚ_[p.1] := +- AlgEquiv.ofRingEquiv +- (f := rationalFinitePlaceCompletionRingEquivPadic p) +- (rationalFinitePlaceCompletionRingEquivPadic_algebraMap p) +- +-noncomputable local instance +- rationalCyclotomicArtinLocalizedPadicScalarTower +- (m : ℕ+) (p : Nat.Primes) : +- IsScalarTower ℚ ℚ_[p.1] +- (rationalCyclotomicArtinLocalizedField m p) := by +- constructor +- intro r x y +- simp only [Algebra.smul_def, map_mul, eq_ratCast, +- map_ratCast, mul_assoc] +- +-private theorem rationalCyclotomicArtin_padic_algebraMap +- (m : ℕ+) (p : Nat.Primes) : +- algebraMap (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField m p) = +- (algebraMap ℚ_[p.1] +- (rationalCyclotomicArtinLocalizedField m p)) ∘ +- (rationalFinitePlaceCompletionAlgEquivPadic p) := by +- funext a +- change +- algebraMap (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField m p) a = +- algebraMap (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField m p) +- ((rationalFinitePlaceCompletionRingEquivPadic p).symm +- (rationalFinitePlaceCompletionRingEquivPadic p a)) +- exact +- congrArg +- (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField m p)) +- ((rationalFinitePlaceCompletionRingEquivPadic p).symm_apply_apply a).symm +- +-private theorem rationalCyclotomicArtin_algebraAdjoin_restrictScalars +- (m : ℕ+) (p : Nat.Primes) : +- (Algebra.adjoin (rationalCyclotomicArtinBaseAbv p).Completion +- ({rationalCyclotomicLocalizedPrimitiveRoot m +- (rationalCyclotomicArtinPlace p)} : +- Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ = +- (Algebra.adjoin ℚ_[p.1] +- ({rationalCyclotomicLocalizedPrimitiveRoot m +- (rationalCyclotomicArtinPlace p)} : +- Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ := by +- exact +- Algebra.restrictScalars_adjoin_of_algEquiv +- (E := rationalCyclotomicArtinLocalizedField m p) +- (rationalFinitePlaceCompletionAlgEquivPadic p) +- (rationalCyclotomicArtin_padic_algebraMap m p) +- ({rationalCyclotomicLocalizedPrimitiveRoot m +- (rationalCyclotomicArtinPlace p)} : +- Set (rationalCyclotomicArtinLocalizedField m p)) +- +-private theorem +- rationalCyclotomicArtin_baseAlgebraAdjoin_restrict_eq_top +- (m : ℕ+) (p : Nat.Primes) : +- (Algebra.adjoin (rationalCyclotomicArtinBaseAbv p).Completion +- ({rationalCyclotomicLocalizedPrimitiveRoot m +- (rationalCyclotomicArtinPlace p)} : +- Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ = +- (⊤ : Subalgebra (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ := by +- have hRoot : IsPrimitiveRoot +- (show rationalCyclotomicArtinLocalizedField m p from +- rationalCyclotomicLocalizedPrimitiveRoot m +- (rationalCyclotomicArtinPlace p)) +- (m : ℕ) := +- rationalCyclotomicLocalizedPrimitiveRoot_isPrimitiveRoot +- m (rationalCyclotomicArtinPlace p) +- have hTop : +- Algebra.adjoin (rationalCyclotomicArtinBaseAbv p).Completion +- ({rationalCyclotomicLocalizedPrimitiveRoot m +- (rationalCyclotomicArtinPlace p)} : +- Set (rationalCyclotomicArtinLocalizedField m p)) = ⊤ := +- IsCyclotomicExtension.adjoin_primitive_root_eq_top +- (A := (rationalCyclotomicArtinBaseAbv p).Completion) +- (B := rationalCyclotomicArtinLocalizedField m p) hRoot +- exact congrArg +- (fun A : Subalgebra (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField m p) => A.restrictScalars ℚ) +- hTop +- +-private theorem rationalCyclotomicArtin_restrictScalars_top_base_eq_padic +- (m : ℕ+) (p : Nat.Primes) : +- (⊤ : Subalgebra (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ = +- (⊤ : Subalgebra ℚ_[p.1] +- (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ := +- (Subalgebra.restrictScalars_top ℚ).trans +- (Subalgebra.restrictScalars_top ℚ).symm +- +-private theorem +- rationalCyclotomicArtin_padicAlgebraAdjoin_restrict_eq_top +- (m : ℕ+) (p : Nat.Primes) : +- (Algebra.adjoin ℚ_[p.1] +- ({rationalCyclotomicLocalizedPrimitiveRoot m +- (rationalCyclotomicArtinPlace p)} : +- Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ = +- (⊤ : Subalgebra ℚ_[p.1] +- (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ := by +- exact +- (rationalCyclotomicArtin_algebraAdjoin_restrictScalars m p).symm.trans +- ((rationalCyclotomicArtin_baseAlgebraAdjoin_restrict_eq_top m p).trans +- (rationalCyclotomicArtin_restrictScalars_top_base_eq_padic m p)) ++noncomputable section + +-/-- The finite-dimensional instance for the standard multiplicative level, +-named once so all consumers use the same proof term. -/ +-theorem rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional +- (p : Nat.Primes) (n : ℕ) : +- FiniteDimensional ℚ_[p.1] +- (standardLubinTateLevelField +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) := +- standardLubinTateLevelField_finiteDimensional +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n ++namespace GlobalClassFieldTheory ++namespace Reciprocity + + attribute [local instance] +- rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional +- +-noncomputable local instance +- rationalCyclotomicPrincipalPrimePadicLevelIsAbelianGalois +- (p : Nat.Primes) (n : ℕ) : +- IsAbelianGalois ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n) := +- standardLubinTateLevelField_isAbelianGalois +- (padicLocalField p.1) +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n +- +-@[reducible] +-noncomputable local instance rationalPrimeFactorCompletionPadicAlgebra +- (p : Nat.Primes) : +- Algebra (RationalCyclotomicPrincipalPrimeCompletion p) ℚ_[p.1] := +- (rationalFinitePlaceCompletionRingEquivPadic p).toRingHom.toAlgebra +- +-/-- The genuine multiplicative Lubin--Tate level is generated by its +-primitive `p ^ (n + 1)`-st root of unity. -/ +-theorem padicMultiplicativePrimitiveRoot_adjoin_eq_top +- (p : ℕ) [Fact p.Prime] (n : ℕ) : +- let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p +- let T := standardLubinTateLevelField hπ n +- Algebra.adjoin ℚ_[p] +- ({padicMultiplicativePrimitiveRoot p n} : Set T) = +- ⊤ := by +- let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p +- let T := standardLubinTateLevelField hπ n +- let ζ : T := padicMultiplicativePrimitiveRoot p n +- let m := p ^ (n + 1) +- let : NeZero m := +- ⟨pow_ne_zero _ (Fact.out : Nat.Prime p).ne_zero⟩ +- let : FiniteDimensional ℚ_[p] T := +- standardLubinTateLevelField_finiteDimensional hπ n +- have hζ : IsPrimitiveRoot ζ m := by +- simpa only [ζ, m] using +- padicMultiplicativePrimitiveRoot_isPrimitiveRoot p n +- let A : IntermediateField ℚ_[p] T := +- IntermediateField.adjoin ℚ_[p] {ζ} +- let : IsCyclotomicExtension {m} ℚ_[p] A := +- hζ.intermediateField_adjoin_isCyclotomicExtension ℚ_[p] +- have hAfin : +- Module.finrank ℚ_[p] A = Nat.totient m := by +- exact +- IsCyclotomicExtension.finrank A +- (by +- simpa only [m] using +- padicCyclotomicPolynomial_irreducible_prime_pow_succ +- p n) +- have hTfin : +- Module.finrank ℚ_[p] T = Nat.totient m := by +- rw [standardLubinTateLevelField_finrank hπ n] +- have hcard : +- Nat.card (padicLocalField p).residueField = p := by +- simpa [padicLocalField] using +- padicCompleteDVF_residueField_card p +- rw [hcard, Nat.totient_prime_pow +- (Fact.out : Nat.Prime p) (Nat.succ_pos n)] +- simp [Nat.mul_comm] +- have hAeq : A = ⊤ := by +- apply IntermediateField.eq_of_le_of_finrank_eq le_top +- simpa using hAfin.trans hTfin.symm +- calc +- Algebra.adjoin ℚ_[p] {ζ} = A.toSubalgebra := by +- exact +- (IntermediateField.adjoin_toSubalgebra +- ({ζ} : Set T)).symm +- _ = (⊤ : IntermediateField ℚ_[p] T).toSubalgebra := +- congrArg IntermediateField.toSubalgebra hAeq +- _ = ⊤ := rfl +- +-/-- The standard multiplicative Lubin--Tate level is the actual +-`p ^ (n + 1)`-cyclotomic extension of `ℚ_p`. -/ +-theorem padicMultiplicativeLevel_isCyclotomicExtension +- (p : ℕ) [Fact p.Prime] (n : ℕ) : +- let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p +- let T := standardLubinTateLevelField hπ n +- IsCyclotomicExtension {p ^ (n + 1)} ℚ_[p] T := by +- let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p +- let T := standardLubinTateLevelField hπ n +- exact +- padic_isCyclotomicExtension_of_primitiveRoot_adjoin_eq_top +- (padicMultiplicativePrimitiveRoot p n) +- (padicMultiplicativePrimitiveRoot_isPrimitiveRoot p n) +- (padicMultiplicativePrimitiveRoot_adjoin_eq_top p n) +- +-private theorem +- rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_isPrimitiveRoot +- (p : Nat.Primes) (n : ℕ) : +- IsPrimitiveRoot +- (rationalCyclotomicLocalizedPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) +- (p.1 ^ (n + 1)) := by +- change +- IsPrimitiveRoot +- (rationalCyclotomicLocalizedPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) +- (rationalCyclotomicPrincipalPrimeModulus p n : ℕ) +- exact +- rationalCyclotomicLocalizedPrimitiveRoot_isPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p) +- +-private theorem +- rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_adjoin_eq_top +- (p : Nat.Primes) (n : ℕ) : +- Algebra.adjoin ℚ_[p.1] +- ({rationalCyclotomicLocalizedPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (rationalCyclotomicArtinPlace p)} : +- Set (rationalCyclotomicArtinLocalizedField +- (rationalCyclotomicPrincipalPrimeModulus p n) p)) = +- ⊤ := by +- exact +- (Subalgebra.restrictScalars_injective ℚ) +- (rationalCyclotomicArtin_padicAlgebraAdjoin_restrict_eq_top +- (rationalCyclotomicPrincipalPrimeModulus p n) p) +- +-private theorem +- rationalCyclotomicPrincipalPrimeLocalizedLevel_isCyclotomicExtension +- (p : Nat.Primes) (n : ℕ) : +- IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ_[p.1] +- (rationalCyclotomicArtinLocalizedField +- (rationalCyclotomicPrincipalPrimeModulus p n) p) := by +- exact +- padic_isCyclotomicExtension_of_primitiveRoot_adjoin_eq_top +- (rationalCyclotomicLocalizedPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (rationalCyclotomicArtinPlace p)) +- (rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_isPrimitiveRoot +- p n) +- (rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_adjoin_eq_top +- p n) +- +-/-- The chosen localized global cyclotomic level, transported over the +-completion equivalence, is the standard multiplicative Lubin--Tate level. -/ +-noncomputable def rationalCyclotomicLocalizedCompletionPadicAlgEquiv +- (p : Nat.Primes) (n : ℕ) : +- rationalCyclotomicArtinLocalizedField +- (rationalCyclotomicPrincipalPrimeModulus p n) p ≃ₐ[ℚ_[p.1]] +- RationalCyclotomicPrincipalPrimePadicLevel p n := by +- letI : IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ_[p.1] +- (rationalCyclotomicArtinLocalizedField +- (rationalCyclotomicPrincipalPrimeModulus p n) p) := +- rationalCyclotomicPrincipalPrimeLocalizedLevel_isCyclotomicExtension p n +- letI : IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n) := +- padicMultiplicativeLevel_isCyclotomicExtension p.1 n +- exact +- IsCyclotomicExtension.algEquiv +- {p.1 ^ (n + 1)} ℚ_[p.1] +- (rationalCyclotomicArtinLocalizedField +- (rationalCyclotomicPrincipalPrimeModulus p n) p) +- (RationalCyclotomicPrincipalPrimePadicLevel p n) +- +-/-! ## The ramified principal finite-place factor -/ +- +-private theorem +- rationalCyclotomicPrincipalPrime_galEquivZMod_eq_of_action +- (p : Nat.Primes) (n : ℕ) +- (sigma : Gal( +- rationalCyclotomicPrincipalPrimeLevel +- (rationalCyclotomicPrincipalPrimeModulus p n) / ℚ)) +- (a : (ZMod (p.1 ^ (n + 1)))ˣ) +- (haction : +- sigma (rationalCyclotomicLevelPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n)) = +- rationalCyclotomicLevelPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n) ^ a.val.val) : +- IsCyclotomicExtension.Rat.galEquivZMod +- (p.1 ^ (n + 1)) +- (rationalCyclotomicPrincipalPrimeLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (hK := +- KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension +- (rationalCyclotomicPrincipalPrimeModulus p n)) sigma = +- a := by +- let m := rationalCyclotomicPrincipalPrimeModulus p n +- let L := rationalCyclotomicPrincipalPrimeLevel m +- let zeta : L := rationalCyclotomicLevelPrimitiveRoot m +- have hzeta : IsPrimitiveRoot zeta (p.1 ^ (n + 1)) := by +- change +- IsPrimitiveRoot +- (rationalCyclotomicLevelPrimitiveRoot m) (m : ℕ) +- exact rationalCyclotomicLevelPrimitiveRoot_isPrimitiveRoot m +- change +- IsCyclotomicExtension.Rat.galEquivZMod +- (p.1 ^ (n + 1)) L +- (hK := +- KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension m) +- sigma = a +- let c := +- IsCyclotomicExtension.Rat.galEquivZMod +- (p.1 ^ (n + 1)) L +- (hK := +- KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension m) +- sigma +- have hc : +- sigma zeta = zeta ^ c.val.val := +- IsCyclotomicExtension.Rat.galEquivZMod_apply_of_pow_eq +- (hK := +- KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension m) +- (p.1 ^ (n + 1)) L sigma hzeta.pow_eq_one +- have hpowers : +- zeta ^ c.val.val = zeta ^ a.val.val := +- hc.symm.trans haction +- rw [(hzeta.isOfFinOrder m.ne_zero).pow_inj_mod, +- ← hzeta.eq_orderOf, +- ← ZMod.natCast_eq_natCast_iff'] at hpowers +- change +- (c.val.val : ZMod (p.1 ^ (n + 1))) = +- (a.val.val : ZMod (p.1 ^ (n + 1))) at hpowers +- have hValues : c.val = a.val := by +- calc +- c.val = (c.val.val : ZMod (p.1 ^ (n + 1))) := +- (ZMod.natCast_zmod_val c.val).symm +- _ = (a.val.val : ZMod (p.1 ^ (n + 1))) := hpowers +- _ = a.val := ZMod.natCast_zmod_val a.val +- change c = a +- apply Units.ext +- exact hValues +- +-/-- The chosen finite-place Artin map factors through any extension identified +-with the chosen one. -/ +-theorem chosenFinitePlaceArtinMonoidHom_apply_factor_of_extension_eq +- {K L : Type} +- [Field K] [NumberField K] +- [Field L] [Algebra K L] +- [FiniteDimensional K L] [IsAbelianGalois K L] +- (v : HeightOneSpectrum (𝓞 K)) +- (w : AbsoluteValueExtension +- (HeightOneSpectrum.adicAbv K v) L) +- (hw : chosenFinitePlaceExtension (L := L) v = w) +- (x : (v.adicCompletion K)ˣ) : +- chosenFinitePlaceArtinMonoidHom +- (K := K) (L := L) v x = +- finitePlaceLocalToGlobalMonoidHom +- (K := K) (L := L) v w +- (finitePlaceLocalArtinMonoidHom +- (K := K) (L := L) v w x) := by +- subst w +- exact +- congrArg +- (fun f : (v.adicCompletion K)ˣ →* (L ≃ₐ[K] L) => f x) +- (finitePlaceArtinMonoidHomOfExtension_factor +- (K := K) (L := L) v +- (chosenFinitePlaceExtension (L := L) v)) +- +-private theorem +- chosenFinitePlaceArtinMonoidHom_apply_factor_of_extension_eq_at +- {K L : Type} +- [Field K] [NumberField K] +- [Field L] [Algebra K L] +- [FiniteDimensional K L] [IsAbelianGalois K L] +- (v : HeightOneSpectrum (𝓞 K)) +- (w : AbsoluteValueExtension +- (HeightOneSpectrum.adicAbv K v) L) +- (hw : chosenFinitePlaceExtension (L := L) v = w) +- (x : (v.adicCompletion K)ˣ) (z : L) : +- chosenFinitePlaceArtinMonoidHom +- (K := K) (L := L) v x z = +- finitePlaceLocalToGlobalMonoidHom +- (K := K) (L := L) v w +- (finitePlaceLocalArtinMonoidHom +- (K := K) (L := L) v w x) z := by +- exact +- congrArg (fun sigma : Gal(L / K) => sigma z) +- (chosenFinitePlaceArtinMonoidHom_apply_factor_of_extension_eq +- (K := K) (L := L) v w hw x) +- +-private theorem finitePlaceLocalToGlobalMonoidHom_apply_pow_of_localized_action +- {K L : Type} +- [Field K] [NumberField K] +- [Field L] [Algebra K L] +- [FiniteDimensional K L] [IsAbelianGalois K L] +- (v : HeightOneSpectrum (𝓞 K)) +- (w : AbsoluteValueExtension +- (HeightOneSpectrum.adicAbv K v) L) +- (sigma : +- let vK := HeightOneSpectrum.adicAbv K v +- let E := LocalizedCompletion vK w +- letI : Algebra vK.Completion E := +- finitePlaceLocalArtinLocalizedAlgebra v w +- Gal(E / vK.Completion)) +- (z : L) +- (zLocal : +- let vK := HeightOneSpectrum.adicAbv K v +- LocalizedCompletion vK w) +- (e : ℕ) +- (hLocalization : +- let vK := HeightOneSpectrum.adicAbv K v +- let E := LocalizedCompletion vK w +- letI : Algebra vK.Completion E := +- finitePlaceLocalArtinLocalizedAlgebra v w +- let eLoc : L →+* E := +- AbsoluteValue.toAlgebraicLocalization vK w.1 w.2 +- eLoc z = zLocal) +- (hlocal : sigma zLocal = zLocal ^ e) : +- finitePlaceLocalToGlobalMonoidHom +- (K := K) (L := L) v w sigma z = z ^ e := by +- let vK := HeightOneSpectrum.adicAbv K v +- let hvK : vK.IsNontrivial := RayClass.adicAbv_isNontrivial v +- let E := LocalizedCompletion vK w +- let : Algebra vK.Completion E := +- finitePlaceLocalArtinLocalizedAlgebra v w +- let eD : absoluteValueDecompositionGroup K w.1 ≃* Gal(E / vK.Completion) := +- decompositionGroupEquivAlgebraicLocalizationAut vK hvK w +- let eLoc : L →+* E := +- AbsoluteValue.toAlgebraicLocalization vK w.1 w.2 +- let delta : absoluteValueDecompositionGroup K w.1 := eD.symm sigma +- have hDecomposition : eD delta = sigma := eD.apply_symm_apply sigma +- apply eLoc.injective +- calc +- eLoc (finitePlaceLocalToGlobalMonoidHom +- (K := K) (L := L) v w sigma z) = +- eD delta (eLoc z) := +- (localizationRamificationGroups_decompositionGroupEquiv_toLocalization +- vK hvK w delta z).symm +- _ = sigma (eLoc z) := +- congrArg (fun tau : Gal(E / vK.Completion) => tau (eLoc z)) +- hDecomposition +- _ = sigma zLocal := +- congrArg (fun y : E => sigma y) hLocalization +- _ = zLocal ^ e := hlocal +- _ = (eLoc z) ^ e := +- congrArg (fun y : E => y ^ e) hLocalization.symm +- _ = eLoc (z ^ e) := (map_pow eLoc z e).symm +- +-private theorem map_primitiveRoot_eq_pow_of_eq_pow +- {M : Type} [CommRing M] [IsDomain M] +- (f : M →* M) (zeta rho : M) (order exponent : ℕ) +- [NeZero order] +- (hzeta : IsPrimitiveRoot zeta order) +- (hrho : IsPrimitiveRoot rho order) +- (hf : f zeta = zeta ^ exponent) : +- f rho = rho ^ exponent := by +- obtain ⟨j, -, hj⟩ := +- hzeta.eq_pow_of_pow_eq_one hrho.pow_eq_one +- calc +- f rho = f (zeta ^ j) := congrArg f hj.symm +- _ = (f zeta) ^ j := map_pow f zeta j +- _ = (zeta ^ exponent) ^ j := congrArg (fun z => z ^ j) hf +- _ = zeta ^ (exponent * j) := (pow_mul zeta exponent j).symm +- _ = zeta ^ (j * exponent) := +- congrArg (fun e : ℕ => zeta ^ e) (Nat.mul_comm exponent j) +- _ = (zeta ^ j) ^ exponent := pow_mul zeta j exponent +- _ = rho ^ exponent := congrArg (fun z => z ^ exponent) hj +- +-private theorem finitePlaceLocalArtinMonoidHom_apply_semilinear +- {K L K' L' : Type} +- [Field K] [NumberField K] +- [Field L] [Algebra K L] +- [hKLfinite : FiniteDimensional K L] [IsAbelianGalois K L] +- [Field K'] [ValuativeRel K'] [TopologicalSpace K'] +- [IsNonarchimedeanLocalField K'] +- [Field L'] [Algebra K' L'] +- [FiniteDimensional K' L'] [IsAbelianGalois K' L'] +- (v : HeightOneSpectrum (𝓞 K)) +- (w : AbsoluteValueExtension +- (HeightOneSpectrum.adicAbv K v) L) +- (eK : (HeightOneSpectrum.adicAbv K v).Completion ≃+* K') +- (eL : LocalizedCompletion +- (HeightOneSpectrum.adicAbv K v) w ≃+* L') +- (hcomm : ∀ y : (HeightOneSpectrum.adicAbv K v).Completion, +- eL (@algebraMap +- (HeightOneSpectrum.adicAbv K v).Completion +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) +- _ _ (finitePlaceLocalArtinLocalizedAlgebra v w) y) = +- algebraMap K' L' (eK y)) +- (hExt : SemilinearValuationCompatible +- (HeightOneSpectrum.adicAbv K v).Completion K' eK) +- (x : (v.adicCompletion K)ˣ) +- (z : LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) : +- eL (finitePlaceLocalArtinMonoidHom +- (K := K) (L := L) v w x z) = +- LocalClassFieldTheory.abelianLocalArtinMonoidHom K' L' +- (Units.map eK.toMonoidHom +- (finitePlaceLocalArtinInput v x)) (eL z) := by +- calc +- eL (finitePlaceLocalArtinMonoidHom +- (K := K) (L := L) v w x z) = +- eL ((@LocalClassFieldTheory.abelianLocalArtinMonoidHom +- (HeightOneSpectrum.adicAbv K v).Completion +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) +- (inferInstance : Field +- (HeightOneSpectrum.adicAbv K v).Completion) +- (inferInstance : Field +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w)) +- (finitePlaceLocalArtinLocalizedAlgebra v w) +- (finitePlaceLocalArtinCompletionValuativeRel v) +- (inferInstance : TopologicalSpace +- (HeightOneSpectrum.adicAbv K v).Completion) +- (finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v) +- (finitePlaceLocalArtinFiniteDimensional v w) +- (finitePlaceLocalArtinIsAbelianGalois v w hKLfinite) +- (finitePlaceLocalArtinInput v x)) z) := +- congrArg eL +- (finitePlaceLocalArtinMonoidHom_apply_normalized_at +- (K := K) (L := L) v w x z) +- _ = LocalClassFieldTheory.abelianLocalArtinMonoidHom K' L' +- (Units.map eK.toMonoidHom +- (finitePlaceLocalArtinInput v x)) (eL z) := +- @abelianLocalArtinMonoidHom_semilinear_action +- (HeightOneSpectrum.adicAbv K v).Completion K' +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) L' +- (inferInstance : Field +- (HeightOneSpectrum.adicAbv K v).Completion) +- (finitePlaceLocalArtinCompletionValuativeRel v) +- (inferInstance : TopologicalSpace +- (HeightOneSpectrum.adicAbv K v).Completion) +- (finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v) +- (inferInstance : Field K') +- (inferInstance : ValuativeRel K') +- (inferInstance : TopologicalSpace K') +- (inferInstance : IsNonarchimedeanLocalField K') +- (inferInstance : Field +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w)) +- (inferInstance : Field L') +- (finitePlaceLocalArtinLocalizedAlgebra v w) +- (inferInstance : Algebra K' L') +- (finitePlaceLocalArtinFiniteDimensional v w) +- (finitePlaceLocalArtinIsAbelianGalois v w hKLfinite) +- (inferInstance : FiniteDimensional K' L') +- (inferInstance : IsAbelianGalois K' L') +- eK eL hcomm hExt (finitePlaceLocalArtinInput v x) z +- +-/-- If a semilinearly identified target local Artin value is trivial, then the +-corresponding global finite-place Artin value is trivial. This generic bridge +-keeps concrete completion and localization instance towers out of downstream +-proof terms. -/ +-theorem finitePlaceArtinMonoidHomOfExtension_eq_one_of_semilinear +- {K L K' L' : Type} +- [Field K] [NumberField K] +- [Field L] [Algebra K L] +- [hKLfinite : FiniteDimensional K L] [IsAbelianGalois K L] +- [Field K'] [ValuativeRel K'] [TopologicalSpace K'] +- [IsNonarchimedeanLocalField K'] +- [Field L'] [Algebra K' L'] +- [FiniteDimensional K' L'] [IsAbelianGalois K' L'] +- (v : HeightOneSpectrum (𝓞 K)) +- (w : AbsoluteValueExtension +- (HeightOneSpectrum.adicAbv K v) L) +- (eK : (HeightOneSpectrum.adicAbv K v).Completion ≃+* K') +- (eL : LocalizedCompletion +- (HeightOneSpectrum.adicAbv K v) w ≃+* L') +- (hcomm : ∀ y : (HeightOneSpectrum.adicAbv K v).Completion, +- eL (@algebraMap +- (HeightOneSpectrum.adicAbv K v).Completion +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) +- _ _ (finitePlaceLocalArtinLocalizedAlgebra v w) y) = +- algebraMap K' L' (eK y)) +- (hExt : SemilinearValuationCompatible +- (HeightOneSpectrum.adicAbv K v).Completion K' eK) +- (x : (v.adicCompletion K)ˣ) +- (htrivial : +- LocalClassFieldTheory.abelianLocalArtinMonoidHom K' L' +- (Units.map eK.toMonoidHom +- (finitePlaceLocalArtinInput v x)) = 1) : +- finitePlaceArtinMonoidHomOfExtension +- (K := K) (L := L) v w x = 1 := by +- rw [finitePlaceArtinMonoidHomOfExtension_factor, +- MonoidHom.comp_apply] +- have hlocal : +- finitePlaceLocalArtinMonoidHom +- (K := K) (L := L) v w x = 1 := by +- rw [finitePlaceLocalArtinMonoidHom_apply_normalized] +- exact +- @abelianLocalArtinMonoidHom_eq_one_of_semilinear +- (HeightOneSpectrum.adicAbv K v).Completion K' +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) L' +- (inferInstance : Field +- (HeightOneSpectrum.adicAbv K v).Completion) +- (finitePlaceLocalArtinCompletionValuativeRel v) +- (inferInstance : TopologicalSpace +- (HeightOneSpectrum.adicAbv K v).Completion) +- (finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v) +- (inferInstance : Field K') +- (inferInstance : ValuativeRel K') +- (inferInstance : TopologicalSpace K') +- (inferInstance : IsNonarchimedeanLocalField K') +- (inferInstance : Field +- (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w)) +- (inferInstance : Field L') +- (finitePlaceLocalArtinLocalizedAlgebra v w) +- (inferInstance : Algebra K' L') +- (finitePlaceLocalArtinFiniteDimensional v w) +- (finitePlaceLocalArtinIsAbelianGalois v w hKLfinite) +- (inferInstance : FiniteDimensional K' L') +- (inferInstance : IsAbelianGalois K' L') +- eK eL hcomm hExt (finitePlaceLocalArtinInput v x) htrivial +- rw [hlocal, map_one] +- +-private noncomputable def rationalCyclotomicPrincipalPrimeLocalizedRoot +- (p : Nat.Primes) (n : ℕ) : +- rationalCyclotomicArtinLocalizedField +- (rationalCyclotomicPrincipalPrimeModulus p n) p := +- rationalCyclotomicLocalizedPrimitiveRoot +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p) +- +-private noncomputable def rationalCyclotomicPrincipalPrimeResidueUnit +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- (ZMod (p.1 ^ (n + 1)))ˣ := +- Units.map +- (PadicInt.toZModPow (p := p.1) (n + 1)).toMonoidHom +- (padicIntUnitOfRat p +- (rationalPrimeUnit x p : ℚ) +- (rationalPrimeUnit x p).ne_zero +- (padicValRat_rationalPrimeUnit x p)) +- +-private theorem rationalCyclotomicPrincipalPrime_localizedBase_commutes +- (p : Nat.Primes) (n : ℕ) +- (y : (rationalCyclotomicArtinBaseAbv p).Completion) : +- rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion +- (rationalCyclotomicArtinLocalizedField +- (rationalCyclotomicPrincipalPrimeModulus p n) p) y) = +- algebraMap ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n) +- (rationalFinitePlaceCompletionRingEquivPadic p y) := by +- let m := rationalCyclotomicPrincipalPrimeModulus p n +- let E := rationalCyclotomicArtinLocalizedField m p +- let eL := rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- have hy : +- algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E y = +- algebraMap ℚ_[p.1] E +- (rationalFinitePlaceCompletionRingEquivPadic p y) := by +- change +- algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E y = +- algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E +- ((rationalFinitePlaceCompletionRingEquivPadic p).symm +- (rationalFinitePlaceCompletionRingEquivPadic p y)) +- exact +- (congrArg +- (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E) +- ((rationalFinitePlaceCompletionRingEquivPadic p).symm_apply_apply y)).symm +- calc +- eL (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E y) = +- eL (algebraMap ℚ_[p.1] E +- (rationalFinitePlaceCompletionRingEquivPadic p y)) := +- congrArg eL hy +- _ = algebraMap ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n) +- (rationalFinitePlaceCompletionRingEquivPadic p y) := +- eL.commutes (rationalFinitePlaceCompletionRingEquivPadic p y) +- +-/-- Specialized ramified-prime bridge from the standard `p`-adic Artin value +-to the canonical global finite-place Artin value. The localized completion +-and all of its dependent instances remain private to this provider. -/ +-theorem +- rationalCyclotomicPrincipalPrime_finitePlaceArtinOfExtension_eq_one_of_padic +- (p : Nat.Primes) (n : ℕ) +- (x : ((RayClass.rationalPrime p).adicCompletion ℚ)ˣ) +- (htrivial : +- abelianLocalArtinMonoidHom ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n) +- (Units.map +- (rationalFinitePlaceCompletionRingEquivPadic p).toMonoidHom +- (finitePlaceLocalArtinInput (RayClass.rationalPrime p) x)) = 1) : +- finitePlaceArtinMonoidHomOfExtension +- (K := ℚ) +- (L := KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (RayClass.rationalPrime p) +- (rationalCyclotomicChosenFinitePlaceExtension +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) x = 1 := by +- exact +- finitePlaceArtinMonoidHomOfExtension_eq_one_of_semilinear +- (K := ℚ) +- (L := KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (K' := ℚ_[p.1]) +- (L' := RationalCyclotomicPrincipalPrimePadicLevel p n) +- (RayClass.rationalPrime p) +- (rationalCyclotomicChosenFinitePlaceExtension +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) +- (rationalFinitePlaceCompletionRingEquivPadic p) +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n).toRingEquiv +- (rationalCyclotomicPrincipalPrime_localizedBase_commutes p n) +- (rationalFinitePlaceCompletionRingEquivPadic_semilinearValuationCompatible p) +- x htrivial +- +-private theorem +- padicMultiplicativePrimitiveRoot_rationalPrimeUnitParameterGaloisAction +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- standardLubinTateUnitParameterEquivGal +- (padicLocalField p.1) +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n +- (standardLubinTateUnitParameterClass +- (padicLocalField p.1) n +- (rationalPrimeUnitValuationSubringUnit x p)) +- (padicMultiplicativePrimitiveRoot p.1 n) = +- padicMultiplicativePrimitiveRoot p.1 n ^ +- (PadicInt.toZModPow (p := p.1) (n + 1) +- (padicIntUnitOfRat p +- (rationalPrimeUnit x p : ℚ) +- (rationalPrimeUnit x p).ne_zero +- (padicValRat_rationalPrimeUnit x p) : ℤ_[p.1])).val := by +- let uZ : ℤ_[p.1]ˣ := +- padicIntUnitOfRat p +- (rationalPrimeUnit x p : ℚ) +- (rationalPrimeUnit x p).ne_zero +- (padicValRat_rationalPrimeUnit x p) +- let u : (padicLocalField p.1).valuationSubringˣ := +- Units.map (padicIntEquivValuationSubring p.1).toMonoidHom uZ +- have huRational : +- rationalPrimeUnitValuationSubringUnit x p = u := by +- rfl +- have huPreimage : +- (padicIntEquivValuationSubring p.1).symm +- ((u : (padicLocalField p.1).valuationSubringˣ) : +- (padicLocalField p.1).valuationSubring) = +- (uZ : ℤ_[p.1]) := by +- change +- (padicIntEquivValuationSubring p.1).symm +- (padicIntEquivValuationSubring p.1 (uZ : ℤ_[p.1])) = +- (uZ : ℤ_[p.1]) +- exact +- (padicIntEquivValuationSubring p.1).symm_apply_apply +- (uZ : ℤ_[p.1]) +- have hAction := +- padicMultiplicativePrimitiveRoot_unitParameterGaloisAction +- p.1 n u +- rw [huPreimage] at hAction +- rw [huRational] +- exact hAction +- +-private noncomputable def rationalCyclotomicPrincipalPrimePadicTargetArtin +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- Gal(RationalCyclotomicPrincipalPrimePadicLevel p n / ℚ_[p.1]) := +- @LocalClassFieldTheory.abelianLocalArtinMonoidHom +- ℚ_[p.1] (RationalCyclotomicPrincipalPrimePadicLevel p n) +- (inferInstance : Field ℚ_[p.1]) +- (inferInstance : Field +- (RationalCyclotomicPrincipalPrimePadicLevel p n)) +- (inferInstance : Algebra ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n)) +- (inferInstance : ValuativeRel ℚ_[p.1]) +- (inferInstance : TopologicalSpace ℚ_[p.1]) +- (inferInstance : IsNonarchimedeanLocalField ℚ_[p.1]) +- (rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n) +- (standardLubinTateLevelField_isAbelianGalois +- (padicLocalField p.1) +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) +- (Units.map +- (rationalFinitePlaceCompletionRingEquivPadic p).toMonoidHom +- (rationalPrincipalFinitePlaceInput x p)) +- +-private noncomputable def +- rationalCyclotomicPrincipalPrimePadicUnitParameterArtin +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- Gal(RationalCyclotomicPrincipalPrimePadicLevel p n / ℚ_[p.1]) := +- standardLubinTateUnitParameterEquivGal +- (padicLocalField p.1) +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n +- (standardLubinTateUnitParameterClass +- (padicLocalField p.1) n +- (rationalPrimeUnitValuationSubringUnit x p)) +- +-private theorem +- rationalCyclotomicPrincipalPrime_padicTargetArtin_eq_unitParameter +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- rationalCyclotomicPrincipalPrimePadicTargetArtin p n x = +- rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x := by +- let T := RationalCyclotomicPrincipalPrimePadicLevel p n +- let eK := rationalFinitePlaceCompletionRingEquivPadic p +- let : FiniteDimensional ℚ_[p.1] T := +- rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n +- let hpi := padicMultiplicativeLubinTateSeries_isUniformizer p.1 +- let : IsAbelianGalois ℚ_[p.1] T := +- standardLubinTateLevelField_isAbelianGalois +- (padicLocalField p.1) hpi n +- have hsource : +- Units.map eK.toMonoidHom (rationalPrincipalFinitePlaceInput x p) = +- Units.map (algebraMap ℚ ℚ_[p.1]).toMonoidHom x := by +- rw [rationalPrincipalFinitePlaceInput_eq_algebraMap] +- apply Units.ext +- exact rationalFinitePlaceCompletionRingEquivPadic_algebraMap p (x : ℚ) +- change +- LocalClassFieldTheory.abelianLocalArtinMonoidHom ℚ_[p.1] T +- (Units.map eK.toMonoidHom +- (rationalPrincipalFinitePlaceInput x p)) = +- standardLubinTateUnitParameterEquivGal +- (padicLocalField p.1) hpi n +- (standardLubinTateUnitParameterClass +- (padicLocalField p.1) n +- (rationalPrimeUnitValuationSubringUnit x p)) +- rw [hsource] +- rw [ +- padicMultiplicativeAbelianLocalArtin_eq_uniformizerUnitPart, +- rationalPadicFieldUnit_uniformizerUnitPart, +- padicMultiplicativeAbelianLocalArtin_eq_unitParameter] +- +-private theorem +- rationalCyclotomicPrincipalPrime_padicArtin_action_eq_unitParameter +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- (@LocalClassFieldTheory.abelianLocalArtinMonoidHom +- ℚ_[p.1] (RationalCyclotomicPrincipalPrimePadicLevel p n) +- (inferInstance : Field ℚ_[p.1]) +- (inferInstance : Field +- (RationalCyclotomicPrincipalPrimePadicLevel p n)) +- (inferInstance : Algebra ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n)) +- (inferInstance : ValuativeRel ℚ_[p.1]) +- (inferInstance : TopologicalSpace ℚ_[p.1]) +- (inferInstance : IsNonarchimedeanLocalField ℚ_[p.1]) +- (rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n) +- (standardLubinTateLevelField_isAbelianGalois +- (padicLocalField p.1) +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) +- (Units.map +- (rationalFinitePlaceCompletionRingEquivPadic p).toMonoidHom +- (finitePlaceLocalArtinInput +- (K := ℚ) (RayClass.rationalPrime p) +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime p) +- (IdeleGroup.principalIdele ℚ x))))) +- ((rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n).toRingEquiv +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) = +- rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := by +- let eK := rationalFinitePlaceCompletionRingEquivPadic p +- have hInput : +- finitePlaceLocalArtinInput +- (K := ℚ) (RayClass.rationalPrime p) +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime p) +- (IdeleGroup.principalIdele ℚ x)) = +- rationalPrincipalFinitePlaceInput x p := by +- rfl +- have hMapped : +- Units.map eK.toMonoidHom +- (finitePlaceLocalArtinInput +- (K := ℚ) (RayClass.rationalPrime p) +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime p) +- (IdeleGroup.principalIdele ℚ x))) = +- Units.map eK.toMonoidHom +- (rationalPrincipalFinitePlaceInput x p) := +- congrArg (Units.map eK.toMonoidHom) hInput +- calc +- _ = rationalCyclotomicPrincipalPrimePadicTargetArtin p n x +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := by +- exact congrArg +- (fun uQp => +- (@LocalClassFieldTheory.abelianLocalArtinMonoidHom +- ℚ_[p.1] (RationalCyclotomicPrincipalPrimePadicLevel p n) +- (inferInstance : Field ℚ_[p.1]) +- (inferInstance : Field +- (RationalCyclotomicPrincipalPrimePadicLevel p n)) +- (inferInstance : Algebra ℚ_[p.1] +- (RationalCyclotomicPrincipalPrimePadicLevel p n)) +- (inferInstance : ValuativeRel ℚ_[p.1]) +- (inferInstance : TopologicalSpace ℚ_[p.1]) +- (inferInstance : IsNonarchimedeanLocalField ℚ_[p.1]) +- (rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n) +- (standardLubinTateLevelField_isAbelianGalois +- (padicLocalField p.1) +- (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) +- uQp) +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n))) +- hMapped +- _ = rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := +- congrArg +- (fun tau => tau +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n))) +- (rationalCyclotomicPrincipalPrime_padicTargetArtin_eq_unitParameter +- p n x) +- +-private theorem +- rationalCyclotomicPrincipalPrime_padicUnitParameterArtin_action +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) = +- (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) ^ +- (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val := by +- let m := rationalCyclotomicPrincipalPrimeModulus p n +- let E := rationalCyclotomicArtinLocalizedField m p +- let T := RationalCyclotomicPrincipalPrimePadicLevel p n +- let eL : E ≃ₐ[ℚ_[p.1]] T := +- rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- let zetaE : E := rationalCyclotomicPrincipalPrimeLocalizedRoot p n +- let tau : Gal(T / ℚ_[p.1]) := +- rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x +- let a := rationalCyclotomicPrincipalPrimeResidueUnit p n x +- let zetaT : T := padicMultiplicativePrimitiveRoot p.1 n +- have hzetaE : IsPrimitiveRoot zetaE (p.1 ^ (n + 1)) := by +- change +- IsPrimitiveRoot +- (rationalCyclotomicLocalizedPrimitiveRoot m +- (RayClass.rationalPrime p)) (m : ℕ) +- exact +- rationalCyclotomicLocalizedPrimitiveRoot_isPrimitiveRoot +- m (RayClass.rationalPrime p) +- have hrho : IsPrimitiveRoot (eL zetaE) (p.1 ^ (n + 1)) := +- hzetaE.map_of_injective eL.injective +- have hzetaT : IsPrimitiveRoot zetaT (p.1 ^ (n + 1)) := +- padicMultiplicativePrimitiveRoot_isPrimitiveRoot p.1 n +- have htauZetaT : tau zetaT = zetaT ^ a.val.val := +- padicMultiplicativePrimitiveRoot_rationalPrimeUnitParameterGaloisAction +- p n x +- exact +- map_primitiveRoot_eq_pow_of_eq_pow +- tau.toMonoidHom zetaT (eL zetaE) +- (p.1 ^ (n + 1)) a.val.val hzetaT hrho htauZetaT +- +-private theorem rationalCyclotomicPrincipalPrime_localArtin_action +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- finitePlaceLocalArtinMonoidHom +- (K := ℚ) +- (L := KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (RayClass.rationalPrime p) +- (rationalCyclotomicChosenFinitePlaceExtension +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime p) +- (IdeleGroup.principalIdele ℚ x)) +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) = +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) ^ +- (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val := by +- let eL := rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n +- apply eL.injective +- calc +- _ = _ := +- finitePlaceLocalArtinMonoidHom_apply_semilinear +- (K := ℚ) +- (L := KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (K' := ℚ_[p.1]) +- (L' := RationalCyclotomicPrincipalPrimePadicLevel p n) +- (RayClass.rationalPrime p) +- (rationalCyclotomicChosenFinitePlaceExtension +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) +- (rationalFinitePlaceCompletionRingEquivPadic p) +- eL.toRingEquiv +- (rationalCyclotomicPrincipalPrime_localizedBase_commutes p n) +- (rationalFinitePlaceCompletionRingEquivPadic_semilinearValuationCompatible +- p) +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime p) +- (IdeleGroup.principalIdele ℚ x)) +- (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) +- _ = rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x +- (eL (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := +- rationalCyclotomicPrincipalPrime_padicArtin_action_eq_unitParameter +- p n x +- _ = (eL (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) ^ +- (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val := +- rationalCyclotomicPrincipalPrime_padicUnitParameterArtin_action p n x +- _ = eL ((rationalCyclotomicPrincipalPrimeLocalizedRoot p n) ^ +- (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val) := +- (map_pow eL (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) +- (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val).symm +- +-/-- The finite-place Artin symbol at the ramified prime, in its canonical +-local-to-global factored form. Keeping this specialization opaque prevents its +-dependent local/global instance tower from being unfolded downstream. -/ +-noncomputable def rationalCyclotomicPrincipalPrimeChosenArtin +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n) ≃ₐ[ℚ] +- KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n) := +- finitePlaceLocalToGlobalMonoidHom +- (K := ℚ) +- (L := KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (RayClass.rationalPrime p) +- (rationalCyclotomicChosenFinitePlaceExtension +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) +- (finitePlaceLocalArtinMonoidHom +- (K := ℚ) +- (L := KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (RayClass.rationalPrime p) +- (rationalCyclotomicChosenFinitePlaceExtension +- (rationalCyclotomicPrincipalPrimeModulus p n) +- (RayClass.rationalPrime p)) +- (IdeleGroup.finiteComponent +- (RayClass.rationalPrime p) +- (IdeleGroup.principalIdele ℚ x))) +- +-/-- At the ramified prime, the cyclotomic character of the chosen finite-place +-Artin symbol is the direct reduction of the rational `p`-adic unit. -/ +-theorem galEquivZMod_chosenFinitePlaceArtinMonoidHom_principal_at_prime +- (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : +- IsCyclotomicExtension.Rat.galEquivZMod +- (p.1 ^ (n + 1)) +- (KummerTheory.rationalCyclotomicLevel +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (hK := +- KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension +- (rationalCyclotomicPrincipalPrimeModulus p n)) +- (rationalCyclotomicPrincipalPrimeChosenArtin p n x) = +- Units.map +- (PadicInt.toZModPow (p := p.1) (n + 1)).toMonoidHom +- (padicIntUnitOfRat p +- (rationalPrimeUnit x p : ℚ) +- (rationalPrimeUnit x p).ne_zero +- (padicValRat_rationalPrimeUnit x p)) := by +- change _ = rationalCyclotomicPrincipalPrimeResidueUnit p n x +- apply rationalCyclotomicPrincipalPrime_galEquivZMod_eq_of_action p n +- simp only [rationalCyclotomicPrincipalPrimeChosenArtin] +- apply finitePlaceLocalToGlobalMonoidHom_apply_pow_of_localized_action +- (zLocal := rationalCyclotomicPrincipalPrimeLocalizedRoot p n) +- · rfl +- · exact rationalCyclotomicPrincipalPrime_localArtin_action p n x +- +-end RationalCyclotomicPrincipalPrime ++ rationalFinitePlaceCompletionRatAlgebra ++ primeFact ++ levelNeZero ++ rationalCyclotomicLevelFiniteDimensional ++ rationalCyclotomicLevelIsAbelianGalois ++ rationalFinitePlaceBaseNontriviallyNormedField ++ rationalFinitePlaceBaseLocallyCompactSpace ++ rationalFinitePlaceBaseIsUltrametricDist ++ rationalFinitePlaceBaseValued ++ rationalFinitePlaceBaseValuativeRel ++ rationalFinitePlaceBaseValuationIsNontrivial ++ rationalFinitePlaceBaseValuationCompatible ++ rationalFinitePlaceBaseValuativeRelIsNontrivial ++ rationalFinitePlaceBaseIsValuativeTopology ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField ++ rationalCyclotomicArtinExtensionAlgebra ++ rationalCyclotomicArtinExtensionSMul ++ rationalCyclotomicArtinCompletionAlgebra ++ rationalCyclotomicArtinLocalizedAlgebra ++ rationalCyclotomicArtinLocalizedGlobalAlgebra ++ rationalCyclotomicArtinLocalizedGlobalSMul ++ rationalCyclotomicArtinLocalizedScalarTower ++ rationalCyclotomicArtinLocalizedFiniteDimensional ++ rationalCyclotomicArtinLocalizedIsAbelianGalois ++ rationalCyclotomicArtinLocalizedIsSeparable ++ rationalCyclotomicArtinLocalizedIsCyclotomic ++ rationalCyclotomicArtinExtensionFiniteDimensional ++ rationalCyclotomicArtinExtensionContinuousSMul ++ rationalCyclotomicArtinExtensionLocallyCompact ++ rationalCyclotomicArtinLocalizedLocallyCompact ++ rationalCyclotomicArtinLocalizedIsUltrametricDist ++ rationalCyclotomicArtinLocalizedValued ++ rationalCyclotomicArtinLocalizedValuativeRel ++ rationalCyclotomicArtinLocalizedValuationCompatible ++ rationalCyclotomicArtinLocalizedValuationHasExtension ++ rationalCyclotomicArtinLocalizedValuationIsNontrivial ++ rationalCyclotomicArtinLocalizedValuativeRelIsNontrivial ++ rationalCyclotomicArtinLocalizedIsValuativeTopology ++ rationalCyclotomicArtinLocalizedIsNonarchimedeanLocalField ++ rationalCyclotomicArtinLocalizedIntegerAlgebra ++ rationalCyclotomicArtinLocalizedIsIntegralClosure ++ rationalCyclotomicArtinLocalizedIntegerModuleFinite + + private theorem rationalCyclotomicArtinUnramified + (m : ℕ+) (q : Nat.Primes) +@@ -2440,8 +178,9 @@ noncomputable def rationalCyclotomicArtinLocalExponent + (rationalCyclotomicArtinBaseAbv q).Completion + (Additive.ofMul (rationalCyclotomicArtinLocalInput q x)) + +-/-- The chosen finite-place Artin value in a rational cyclotomic level, with +-the completion and Galois instance arguments frozen at the provider boundary. -/ ++ ++/-- The Galois automorphism of the rational cyclotomic extension at level `m` ++assigned to the nonzero `q`-adic input by the chosen finite-place Artin map. -/ + noncomputable def rationalCyclotomicChosenFinitePlaceArtinValue + (m : ℕ+) (q : Nat.Primes) + (x : ((RayClass.rationalPrime q).adicCompletion ℚ)ˣ) : +@@ -2484,7 +223,12 @@ private theorem rationalCyclotomicArtinLocalArtin_eq + (rationalCyclotomicArtinLevel m))) + (finitePlaceLocalArtinInput + (K := ℚ) (rationalCyclotomicArtinPlace q) x) := by +- rfl ++ unfold rationalCyclotomicArtinLocalArtin ++ have h := finitePlaceLocalArtinMonoidHom_apply_normalized ++ (K := ℚ) (L := rationalCyclotomicArtinLevel m) ++ (rationalCyclotomicArtinPlace q) ++ (rationalCyclotomicArtinExtension m q) x ++ with_reducible exact h + + private theorem rationalCyclotomicChosenArithmeticFrobenius_eq_lift + (m : ℕ+) (q : Nat.Primes) +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinAction.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinAction.lean +new file mode 100644 +index 0000000..fd14a9f +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinAction.lean +@@ -0,0 +1,438 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlaceArtinTransport ++ ++ ++set_option autoImplicit false ++ ++open scoped Classical NNReal NumberField ValuativeRel ++open NumberField IsDedekindDomain ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open LocalClassFieldTheory ++open LocalFieldTheory ++open LocalFieldTheory.DiscreteValuationField ++open LocalFieldTheory.DiscreteValuationField.Examples.Qp ++open LubinTate ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++section RationalCyclotomicPrincipalPrime ++ ++attribute [local instance] ++ rationalFinitePlaceCompletionRatAlgebra ++ primeFact ++ levelNeZero ++ rationalCyclotomicLevelFiniteDimensional ++ rationalCyclotomicLevelIsAbelianGalois ++ rationalFinitePlaceBaseNontriviallyNormedField ++ rationalFinitePlaceBaseLocallyCompactSpace ++ rationalFinitePlaceBaseIsUltrametricDist ++ rationalFinitePlaceBaseValued ++ rationalFinitePlaceBaseValuativeRel ++ rationalFinitePlaceBaseValuationIsNontrivial ++ rationalFinitePlaceBaseValuationCompatible ++ rationalFinitePlaceBaseValuativeRelIsNontrivial ++ rationalFinitePlaceBaseIsValuativeTopology ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField ++ rationalCyclotomicArtinExtensionAlgebra ++ rationalCyclotomicArtinExtensionSMul ++ rationalCyclotomicArtinCompletionAlgebra ++ rationalCyclotomicArtinLocalizedAlgebra ++ rationalCyclotomicArtinLocalizedGlobalAlgebra ++ rationalCyclotomicArtinLocalizedGlobalSMul ++ rationalCyclotomicArtinLocalizedScalarTower ++ rationalCyclotomicArtinLocalizedFiniteDimensional ++ rationalCyclotomicArtinLocalizedIsAbelianGalois ++ rationalCyclotomicArtinLocalizedIsSeparable ++ rationalCyclotomicArtinLocalizedIsCyclotomic ++ rationalCyclotomicArtinExtensionFiniteDimensional ++ rationalCyclotomicArtinExtensionContinuousSMul ++ rationalCyclotomicArtinExtensionLocallyCompact ++ rationalCyclotomicArtinLocalizedLocallyCompact ++ rationalCyclotomicArtinLocalizedIsUltrametricDist ++ rationalCyclotomicArtinLocalizedValued ++ rationalCyclotomicArtinLocalizedValuativeRel ++ rationalCyclotomicArtinLocalizedValuationCompatible ++ rationalCyclotomicArtinLocalizedValuationHasExtension ++ rationalCyclotomicArtinLocalizedValuationIsNontrivial ++ rationalCyclotomicArtinLocalizedValuativeRelIsNontrivial ++ rationalCyclotomicArtinLocalizedIsValuativeTopology ++ rationalCyclotomicArtinLocalizedIsNonarchimedeanLocalField ++ rationalCyclotomicArtinLocalizedIntegerAlgebra ++ rationalCyclotomicArtinLocalizedIsIntegralClosure ++ rationalCyclotomicArtinLocalizedIntegerModuleFinite ++ rationalCyclotomicPrincipalPrimeLevelIsCyclotomicExtension ++ rationalCyclotomicArtinLocalizedPadicAlgebra ++ rationalCyclotomicArtinLocalizedPadicScalarTower ++ rationalCyclotomicPrincipalPrimePadicLevelIsAbelianGalois ++ rationalPrimeFactorCompletionPadicAlgebra ++ rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional ++ ++/-- If a semilinearly identified target local Artin value is trivial, then the ++corresponding global finite-place Artin value is trivial. This generic bridge ++keeps concrete completion and localization instance towers out of downstream ++proof terms. -/ ++theorem finitePlaceArtinMonoidHomOfExtension_eq_one_of_semilinear ++ {K L K' L' : Type} ++ [Field K] [NumberField K] ++ [Field L] [Algebra K L] ++ [hKLfinite : FiniteDimensional K L] [IsAbelianGalois K L] ++ [Field K'] [ValuativeRel K'] [TopologicalSpace K'] ++ [IsNonarchimedeanLocalField K'] ++ [Field L'] [Algebra K' L'] ++ [FiniteDimensional K' L'] [IsAbelianGalois K' L'] ++ (v : HeightOneSpectrum (𝓞 K)) ++ (w : AbsoluteValueExtension ++ (HeightOneSpectrum.adicAbv K v) L) ++ (eK : (HeightOneSpectrum.adicAbv K v).Completion ≃+* K') ++ (eL : LocalizedCompletion ++ (HeightOneSpectrum.adicAbv K v) w ≃+* L') ++ (hcomm : ∀ y : (HeightOneSpectrum.adicAbv K v).Completion, ++ eL (@algebraMap ++ (HeightOneSpectrum.adicAbv K v).Completion ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) ++ _ _ (finitePlaceLocalArtinLocalizedAlgebra v w) y) = ++ algebraMap K' L' (eK y)) ++ (hExt : SemilinearValuationCompatible ++ (HeightOneSpectrum.adicAbv K v).Completion K' eK) ++ (x : (v.adicCompletion K)ˣ) ++ (htrivial : ++ LocalClassFieldTheory.abelianLocalArtinMonoidHom K' L' ++ (Units.map eK.toMonoidHom ++ (finitePlaceLocalArtinInput v x)) = 1) : ++ finitePlaceArtinMonoidHomOfExtension ++ (K := K) (L := L) v w x = 1 := by ++ rw [finitePlaceArtinMonoidHomOfExtension_factor, ++ MonoidHom.comp_apply] ++ have hlocal : ++ finitePlaceLocalArtinMonoidHom ++ (K := K) (L := L) v w x = 1 := by ++ rw [finitePlaceLocalArtinMonoidHom_apply_normalized] ++ exact ++ @abelianLocalArtinMonoidHom_eq_one_of_semilinear ++ (HeightOneSpectrum.adicAbv K v).Completion K' ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) L' ++ (inferInstance : Field ++ (HeightOneSpectrum.adicAbv K v).Completion) ++ (finitePlaceLocalArtinCompletionValuativeRel v) ++ (inferInstance : TopologicalSpace ++ (HeightOneSpectrum.adicAbv K v).Completion) ++ (finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v) ++ (inferInstance : Field K') ++ (inferInstance : ValuativeRel K') ++ (inferInstance : TopologicalSpace K') ++ (inferInstance : IsNonarchimedeanLocalField K') ++ (inferInstance : Field ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w)) ++ (inferInstance : Field L') ++ (finitePlaceLocalArtinLocalizedAlgebra v w) ++ (inferInstance : Algebra K' L') ++ (finitePlaceLocalArtinFiniteDimensional v w) ++ (finitePlaceLocalArtinIsAbelianGalois v w hKLfinite) ++ (inferInstance : FiniteDimensional K' L') ++ (inferInstance : IsAbelianGalois K' L') ++ eK eL hcomm hExt (finitePlaceLocalArtinInput v x) htrivial ++ rw [hlocal, map_one] ++ ++/-- The chosen primitive cyclotomic root in the localized prime-power extension. -/ ++noncomputable def rationalCyclotomicPrincipalPrimeLocalizedRoot ++ (p : Nat.Primes) (n : ℕ) : ++ rationalCyclotomicArtinLocalizedField ++ (rationalCyclotomicPrincipalPrimeModulus p n) p := ++ rationalCyclotomicLocalizedPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p) ++ ++/-- The residue modulo `p^(n+1)` of the `p`-adic unit part of a rational unit. -/ ++noncomputable def rationalCyclotomicPrincipalPrimeResidueUnit ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ (ZMod (p.1 ^ (n + 1)))ˣ := ++ Units.map ++ (PadicInt.toZModPow (p := p.1) (n + 1)).toMonoidHom ++ (padicIntUnitOfRat p ++ (rationalPrimeUnit x p : ℚ) ++ (rationalPrimeUnit x p).ne_zero ++ (padicValRat_rationalPrimeUnit x p)) ++ ++theorem rationalCyclotomicPrincipalPrime_localizedBase_commutes ++ (p : Nat.Primes) (n : ℕ) ++ (y : (rationalCyclotomicArtinBaseAbv p).Completion) : ++ rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField ++ (rationalCyclotomicPrincipalPrimeModulus p n) p) y) = ++ algebraMap ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (rationalFinitePlaceCompletionRingEquivPadic p y) := by ++ let m := rationalCyclotomicPrincipalPrimeModulus p n ++ let E := rationalCyclotomicArtinLocalizedField m p ++ let eL := rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ have hy : ++ algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E y = ++ algebraMap ℚ_[p.1] E ++ (rationalFinitePlaceCompletionRingEquivPadic p y) := by ++ change ++ algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E y = ++ algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E ++ ((rationalFinitePlaceCompletionRingEquivPadic p).symm ++ (rationalFinitePlaceCompletionRingEquivPadic p y)) ++ exact ++ (congrArg ++ (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E) ++ ((rationalFinitePlaceCompletionRingEquivPadic p).symm_apply_apply y)).symm ++ calc ++ eL (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion E y) = ++ eL (algebraMap ℚ_[p.1] E ++ (rationalFinitePlaceCompletionRingEquivPadic p y)) := ++ congrArg eL hy ++ _ = algebraMap ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (rationalFinitePlaceCompletionRingEquivPadic p y) := ++ eL.commutes (rationalFinitePlaceCompletionRingEquivPadic p y) ++ ++/-- Specialized ramified-prime bridge from the standard `p`-adic Artin value ++to the canonical global finite-place Artin value. The localized completion ++and all of its dependent instances remain private to this provider. -/ ++theorem ++ rationalCyclotomicPrincipalPrime_finitePlaceArtinOfExtension_eq_one_of_padic ++ (p : Nat.Primes) (n : ℕ) ++ (x : ((RayClass.rationalPrime p).adicCompletion ℚ)ˣ) ++ (htrivial : ++ abelianLocalArtinMonoidHom ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (Units.map ++ (rationalFinitePlaceCompletionRingEquivPadic p).toMonoidHom ++ (finitePlaceLocalArtinInput (RayClass.rationalPrime p) x)) = 1) : ++ finitePlaceArtinMonoidHomOfExtension ++ (K := ℚ) ++ (L := KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (RayClass.rationalPrime p) ++ (rationalCyclotomicChosenFinitePlaceExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) x = 1 := by ++ exact ++ finitePlaceArtinMonoidHomOfExtension_eq_one_of_semilinear ++ (K := ℚ) ++ (L := KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (K' := ℚ_[p.1]) ++ (L' := RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (RayClass.rationalPrime p) ++ (rationalCyclotomicChosenFinitePlaceExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) ++ (rationalFinitePlaceCompletionRingEquivPadic p) ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n).toRingEquiv ++ (rationalCyclotomicPrincipalPrime_localizedBase_commutes p n) ++ (rationalFinitePlaceCompletionRingEquivPadic_semilinearValuationCompatible p) ++ x htrivial ++ ++theorem ++ padicMultiplicativePrimitiveRoot_rationalPrimeUnitParameterGaloisAction ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ standardLubinTateUnitParameterEquivGal ++ (padicLocalField p.1) ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n ++ (standardLubinTateUnitParameterClass ++ (padicLocalField p.1) n ++ (rationalPrimeUnitValuationSubringUnit x p)) ++ (padicMultiplicativePrimitiveRoot p.1 n) = ++ padicMultiplicativePrimitiveRoot p.1 n ^ ++ (PadicInt.toZModPow (p := p.1) (n + 1) ++ (padicIntUnitOfRat p ++ (rationalPrimeUnit x p : ℚ) ++ (rationalPrimeUnit x p).ne_zero ++ (padicValRat_rationalPrimeUnit x p) : ℤ_[p.1])).val := by ++ let uZ : ℤ_[p.1]ˣ := ++ padicIntUnitOfRat p ++ (rationalPrimeUnit x p : ℚ) ++ (rationalPrimeUnit x p).ne_zero ++ (padicValRat_rationalPrimeUnit x p) ++ let u : (padicLocalField p.1).valuationSubringˣ := ++ Units.map (padicIntEquivValuationSubring p.1).toMonoidHom uZ ++ have huRational : ++ rationalPrimeUnitValuationSubringUnit x p = u := by ++ rfl ++ have huPreimage : ++ (padicIntEquivValuationSubring p.1).symm ++ ((u : (padicLocalField p.1).valuationSubringˣ) : ++ (padicLocalField p.1).valuationSubring) = ++ (uZ : ℤ_[p.1]) := by ++ change ++ (padicIntEquivValuationSubring p.1).symm ++ (padicIntEquivValuationSubring p.1 (uZ : ℤ_[p.1])) = ++ (uZ : ℤ_[p.1]) ++ exact ++ (padicIntEquivValuationSubring p.1).symm_apply_apply ++ (uZ : ℤ_[p.1]) ++ have hAction := ++ padicMultiplicativePrimitiveRoot_unitParameterGaloisAction ++ p.1 n u ++ rw [huPreimage] at hAction ++ rw [huRational] ++ exact hAction ++ ++private noncomputable def rationalCyclotomicPrincipalPrimePadicTargetArtin ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ Gal(RationalCyclotomicPrincipalPrimePadicLevel p n / ℚ_[p.1]) := ++ @LocalClassFieldTheory.abelianLocalArtinMonoidHom ++ ℚ_[p.1] (RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (inferInstance : Field ℚ_[p.1]) ++ (inferInstance : Field ++ (RationalCyclotomicPrincipalPrimePadicLevel p n)) ++ (inferInstance : Algebra ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n)) ++ (inferInstance : ValuativeRel ℚ_[p.1]) ++ (inferInstance : TopologicalSpace ℚ_[p.1]) ++ (inferInstance : IsNonarchimedeanLocalField ℚ_[p.1]) ++ (rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n) ++ (standardLubinTateLevelField_isAbelianGalois ++ (padicLocalField p.1) ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) ++ (Units.map ++ (rationalFinitePlaceCompletionRingEquivPadic p).toMonoidHom ++ (rationalPrincipalFinitePlaceInput x p)) ++ ++/-- The cyclotomic Galois automorphism corresponding to the unit parameter of `x` ++under the standard Lubin–Tate equivalence. -/ ++noncomputable def ++ rationalCyclotomicPrincipalPrimePadicUnitParameterArtin ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ Gal(RationalCyclotomicPrincipalPrimePadicLevel p n / ℚ_[p.1]) := ++ standardLubinTateUnitParameterEquivGal ++ (padicLocalField p.1) ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n ++ (standardLubinTateUnitParameterClass ++ (padicLocalField p.1) n ++ (rationalPrimeUnitValuationSubringUnit x p)) ++ ++private theorem ++ rationalCyclotomicPrincipalPrime_padicTargetArtin_eq_unitParameter ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ rationalCyclotomicPrincipalPrimePadicTargetArtin p n x = ++ rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x := by ++ let T := RationalCyclotomicPrincipalPrimePadicLevel p n ++ let eK := rationalFinitePlaceCompletionRingEquivPadic p ++ let : FiniteDimensional ℚ_[p.1] T := ++ rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n ++ let hpi := padicMultiplicativeLubinTateSeries_isUniformizer p.1 ++ let : IsAbelianGalois ℚ_[p.1] T := ++ standardLubinTateLevelField_isAbelianGalois ++ (padicLocalField p.1) hpi n ++ have hsource : ++ Units.map eK.toMonoidHom (rationalPrincipalFinitePlaceInput x p) = ++ Units.map (algebraMap ℚ ℚ_[p.1]).toMonoidHom x := by ++ rw [rationalPrincipalFinitePlaceInput_eq_algebraMap] ++ apply Units.ext ++ exact rationalFinitePlaceCompletionRingEquivPadic_algebraMap p (x : ℚ) ++ change ++ LocalClassFieldTheory.abelianLocalArtinMonoidHom ℚ_[p.1] T ++ (Units.map eK.toMonoidHom ++ (rationalPrincipalFinitePlaceInput x p)) = ++ standardLubinTateUnitParameterEquivGal ++ (padicLocalField p.1) hpi n ++ (standardLubinTateUnitParameterClass ++ (padicLocalField p.1) n ++ (rationalPrimeUnitValuationSubringUnit x p)) ++ rw [hsource] ++ rw [ ++ padicMultiplicativeAbelianLocalArtin_eq_uniformizerUnitPart, ++ rationalPadicFieldUnit_uniformizerUnitPart, ++ padicMultiplicativeAbelianLocalArtin_eq_unitParameter] ++ ++theorem ++ rationalCyclotomicPrincipalPrime_padicArtin_action_eq_unitParameter ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ (@LocalClassFieldTheory.abelianLocalArtinMonoidHom ++ ℚ_[p.1] (RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (inferInstance : Field ℚ_[p.1]) ++ (inferInstance : Field ++ (RationalCyclotomicPrincipalPrimePadicLevel p n)) ++ (inferInstance : Algebra ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n)) ++ (inferInstance : ValuativeRel ℚ_[p.1]) ++ (inferInstance : TopologicalSpace ℚ_[p.1]) ++ (inferInstance : IsNonarchimedeanLocalField ℚ_[p.1]) ++ (rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n) ++ (standardLubinTateLevelField_isAbelianGalois ++ (padicLocalField p.1) ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) ++ (Units.map ++ (rationalFinitePlaceCompletionRingEquivPadic p).toMonoidHom ++ (finitePlaceLocalArtinInput ++ (K := ℚ) (RayClass.rationalPrime p) ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime p) ++ (IdeleGroup.principalIdele ℚ x))))) ++ ((rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n).toRingEquiv ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) = ++ rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := by ++ let eK := rationalFinitePlaceCompletionRingEquivPadic p ++ have hInput : ++ finitePlaceLocalArtinInput ++ (K := ℚ) (RayClass.rationalPrime p) ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime p) ++ (IdeleGroup.principalIdele ℚ x)) = ++ rationalPrincipalFinitePlaceInput x p := by ++ rfl ++ have hMapped : ++ Units.map eK.toMonoidHom ++ (finitePlaceLocalArtinInput ++ (K := ℚ) (RayClass.rationalPrime p) ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime p) ++ (IdeleGroup.principalIdele ℚ x))) = ++ Units.map eK.toMonoidHom ++ (rationalPrincipalFinitePlaceInput x p) := ++ congrArg (Units.map eK.toMonoidHom) hInput ++ calc ++ _ = rationalCyclotomicPrincipalPrimePadicTargetArtin p n x ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := by ++ exact congrArg ++ (fun uQp => ++ (@LocalClassFieldTheory.abelianLocalArtinMonoidHom ++ ℚ_[p.1] (RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (inferInstance : Field ℚ_[p.1]) ++ (inferInstance : Field ++ (RationalCyclotomicPrincipalPrimePadicLevel p n)) ++ (inferInstance : Algebra ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n)) ++ (inferInstance : ValuativeRel ℚ_[p.1]) ++ (inferInstance : TopologicalSpace ℚ_[p.1]) ++ (inferInstance : IsNonarchimedeanLocalField ℚ_[p.1]) ++ (rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional p n) ++ (standardLubinTateLevelField_isAbelianGalois ++ (padicLocalField p.1) ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) ++ uQp) ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n))) ++ hMapped ++ _ = rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := ++ congrArg ++ (fun tau => tau ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n))) ++ (rationalCyclotomicPrincipalPrime_padicTargetArtin_eq_unitParameter ++ p n x) ++ ++ ++end RationalCyclotomicPrincipalPrime ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinBase.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinBase.lean +new file mode 100644 +index 0000000..3646afc +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinBase.lean +@@ -0,0 +1,924 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.CompletionToIdeal ++import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.IdealToCompletion ++import ClassFieldTheory.AlgebraicNumberTheory.Completion.UnramifiedComparison.LocalNorm ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.AlgEquiv ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.BaseChange ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.Core ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.NormComparison ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.NormalClosureNorm ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.Tower ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.TowerAlgEquivNaturality ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.ClassGroup.TowerBaseChange ++import ClassFieldTheory.AlgebraicNumberTheory.Idele.Relative.FinitePlaceTensorNorm ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlace ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicLocalization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalPrimeFactorization ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalPrincipalLocalUnit ++import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.SemilinearNaturality ++import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.UnramifiedNormalization ++import ClassFieldTheory.LocalClassFieldTheory.LubinTateApplication.PadicMultiplicativeArtinComparison ++import ValuedFieldTheory.LocalField.DiscreteValuationField.PadicValuationComparison ++import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.UnramifiedFrobenius ++import ValuedFieldTheory.LocalField.Padic.Cyclotomic.TotallyRamified.EisensteinPolynomial ++import Mathlib.NumberTheory.NumberField.Cyclotomic.Galois ++ ++ ++set_option autoImplicit false ++ ++/-! ++# Finite-place Artin symbols in rational cyclotomic levels ++ ++At a rational prime away from the cyclotomic level, the chosen completed ++extension is unramified. Its normalized local Artin map is therefore the ++arithmetic Frobenius raised to the local valuation. The genuine primitive ++root in the localized cyclotomic level identifies the image of arithmetic ++Frobenius under the global cyclotomic character with the residue prime. ++-/ ++ ++open scoped Classical NNReal NumberField ValuativeRel ++open NumberField IsDedekindDomain ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++-- Specializing the generic finite-place comparison to `ℚ` must retain its ++-- `Algebra.id` owner rather than selecting the competing rational-field ++-- instance introduced after specialization. ++@[reducible] noncomputable local instance ++ rationalFinitePlaceCompletionRatAlgebra ++ (v : HeightOneSpectrum (𝓞 ℚ)) : ++ Algebra ℚ (HeightOneSpectrum.adicAbv ℚ v).Completion := by ++ letI : Algebra ℚ ℚ := Algebra.id ℚ ++ let hWith : Algebra ℚ ++ (WithAbs (HeightOneSpectrum.adicAbv ℚ v)) := ++ WithAbs.instAlgebra _ ++ let hUniform : UniformContinuousConstSMul ℚ ++ (WithAbs (HeightOneSpectrum.adicAbv ℚ v)) := ++ WithAbs.instUniformContinuousConstSMulReal _ ++ exact ++ @UniformSpace.Completion.algebra ++ (WithAbs (HeightOneSpectrum.adicAbv ℚ v)) _ _ _ _ ++ ℚ _ hWith hUniform ++ ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open LocalClassFieldTheory ++open LocalFieldTheory ++open LocalFieldTheory.DiscreteValuationField ++open LocalFieldTheory.DiscreteValuationField.Examples.Qp ++open LubinTate ++ ++theorem mappedAbelianLocalArtin_eq_frobenius_zpow ++ {F E G : Type} ++ [Field F] [ValuativeRel F] [TopologicalSpace F] ++ [IsNonarchimedeanLocalField F] ++ [Field E] [ValuativeRel E] [UniformSpace E] [IsUniformAddGroup E] ++ [IsNonarchimedeanLocalField E] ++ [Algebra F E] [FiniteDimensional F E] [IsAbelianGalois F E] ++ [Valuation.HasExtension ++ (ValuativeRel.valuation F) (ValuativeRel.valuation E)] ++ [IsNonarchimedeanLocalField.IsUnramifiedValuedExtension F E] ++ [Group G] ++ (f : (E ≃ₐ[F] E) →* G) (x : Fˣ) : ++ f (LocalClassFieldTheory.abelianLocalArtinMonoidHom F E x) = ++ (f (arithmeticFrobeniusOfUnramifiedValuation F E)) ^ ++ IsNonarchimedeanLocalField.valuationMap F ++ (Additive.ofMul x) := by ++ rw [LocalClassFieldTheory.abelianLocalArtinMonoidHom_eq_frobenius_zpow, ++ map_zpow] ++ ++local instance primeFact (q : Nat.Primes) : Fact q.1.Prime := ++ ⟨q.2⟩ ++ ++local instance levelNeZero (m : ℕ+) : NeZero (m : ℕ) := ++ ⟨m.ne_zero⟩ ++ ++noncomputable local instance ++ rationalCyclotomicLevelFiniteDimensional ++ (m : ℕ+) : ++ FiniteDimensional ℚ ++ (KummerTheory.rationalCyclotomicLevel m) := ++ IsCyclotomicExtension.finiteDimensional ++ {(m : ℕ)} ℚ (KummerTheory.rationalCyclotomicLevel m) ++ ++noncomputable local instance ++ rationalCyclotomicLevelIsAbelianGalois ++ (m : ℕ+) : ++ IsAbelianGalois ℚ ++ (KummerTheory.rationalCyclotomicLevel m) := by ++ have : IsGalois ℚ ++ (KummerTheory.rationalCyclotomicLevel m) := ++ inferInstance ++ let e := ++ IsCyclotomicExtension.Rat.galEquivZMod ++ (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) ++ exact ++ { is_comm.comm σ τ := by ++ apply e.injective ++ simp only [map_mul] ++ exact mul_comm _ _ } ++ ++@[reducible] ++noncomputable local instance rationalFinitePlaceBaseNontriviallyNormedField ++ (q : Nat.Primes) : ++ NontriviallyNormedField ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion := ++ absoluteValueExtension_completionNontriviallyNormedField ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)) ++ (RayClass.adicAbv_isNontrivial ++ (RayClass.rationalPrime q)) ++ ++noncomputable local instance rationalFinitePlaceBaseLocallyCompactSpace ++ (q : Nat.Primes) : ++ LocallyCompactSpace ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion := ++ AbsoluteValue.Completion.locallyCompactSpace ++ (finitePlaceCompletionBaseMap_isometry ++ (RayClass.rationalPrime q)) ++ ++noncomputable local instance rationalFinitePlaceBaseIsUltrametricDist ++ (q : Nat.Primes) : ++ IsUltrametricDist ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion := ++ finitePlaceArtinCompletionIsUltrametricDist ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv ++ ℚ (RayClass.rationalPrime q)) ++ ++@[reducible] ++noncomputable local instance rationalFinitePlaceBaseValued ++ (q : Nat.Primes) : ++ Valued ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ℝ≥0 := ++ finitePlaceArtinCompletionValued ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv ++ ℚ (RayClass.rationalPrime q)) ++ ++@[reducible] ++noncomputable local instance rationalFinitePlaceBaseValuativeRel ++ (q : Nat.Primes) : ++ ValuativeRel ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion := ++ finitePlaceLocalArtinCompletionValuativeRel ++ (K := ℚ) (RayClass.rationalPrime q) ++ ++noncomputable local instance ++ rationalFinitePlaceBaseValuationIsNontrivial ++ (q : Nat.Primes) : ++ (Valued.v : ++ Valuation ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ ℝ≥0).IsNontrivial := ++ (inferInstance : ++ (NormedField.valuation ++ (K := ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion)).IsNontrivial) ++ ++noncomputable local instance rationalFinitePlaceBaseValuationCompatible ++ (q : Nat.Primes) : ++ (Valued.v : ++ Valuation ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ ℝ≥0).Compatible := ++ Valuation.Compatible.ofValuation _ ++ ++noncomputable local instance ++ rationalFinitePlaceBaseValuativeRelIsNontrivial ++ (q : Nat.Primes) : ++ ValuativeRel.IsNontrivial ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion := ++ (ValuativeRel.isNontrivial_iff_isNontrivial ++ (Valued.v : ++ Valuation ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ ℝ≥0)).2 inferInstance ++ ++noncomputable local instance rationalFinitePlaceBaseIsValuativeTopology ++ (q : Nat.Primes) : ++ IsValuativeTopology ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion := ++ isValuativeTopology_of_valued_ofValuation ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ℝ≥0 ++ ++noncomputable local instance ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField ++ (q : Nat.Primes) : ++ IsNonarchimedeanLocalField ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion := ++ finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField ++ (K := ℚ) (RayClass.rationalPrime q) ++ ++ ++/-- Rational cyclotomic levels are finite-dimensional over `ℚ`. -/ ++theorem rationalCyclotomicPrincipalPrimeLevelFiniteDimensional ++ (m : ℕ+) : ++ FiniteDimensional ℚ (KummerTheory.rationalCyclotomicLevel m) := ++ rationalCyclotomicLevelFiniteDimensional m ++ ++/-- Rational cyclotomic levels are abelian Galois extensions of `ℚ`. -/ ++theorem rationalCyclotomicPrincipalPrimeLevelIsAbelianGalois ++ (m : ℕ+) : ++ IsAbelianGalois ℚ (KummerTheory.rationalCyclotomicLevel m) := ++ rationalCyclotomicLevelIsAbelianGalois m ++ ++/-- The canonical nontrivially normed field structure on the completion of ++`ℚ` at the rational prime `p`, exposed for principal-prime constructions. -/ ++@[reducible] ++noncomputable def rationalPrimeFactorCompletionNontriviallyNormedField ++ (p : Nat.Primes) : ++ NontriviallyNormedField ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion := ++ rationalFinitePlaceBaseNontriviallyNormedField p ++ ++/-- The completion of `ℚ` at `p` is locally compact. -/ ++theorem rationalPrimeFactorCompletionLocallyCompactSpace ++ (p : Nat.Primes) : ++ LocallyCompactSpace ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion := ++ rationalFinitePlaceBaseLocallyCompactSpace p ++ ++/-- The completion of `ℚ` at `p` carries its canonical ultrametric distance. -/ ++theorem rationalPrimeFactorCompletionIsUltrametricDist ++ (p : Nat.Primes) : ++ IsUltrametricDist ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion := ++ rationalFinitePlaceBaseIsUltrametricDist p ++ ++/-- The canonical `ℝ≥0`-valued structure on the completion of `ℚ` at `p`. -/ ++@[reducible] ++noncomputable def rationalPrimeFactorCompletionValued ++ (p : Nat.Primes) : ++ Valued ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion ℝ≥0 := ++ rationalFinitePlaceBaseValued p ++ ++/-- The valuative relation induced by the canonical valuation on the ++completion of `ℚ` at `p`. -/ ++@[reducible] ++noncomputable def rationalPrimeFactorCompletionValuativeRel ++ (p : Nat.Primes) : ++ ValuativeRel ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion := ++ rationalFinitePlaceBaseValuativeRel p ++ ++/-- The canonical valuation on the completion of `ℚ` at `p` is nontrivial. -/ ++theorem rationalPrimeFactorCompletionValuationIsNontrivial ++ (p : Nat.Primes) : ++ (Valued.v : Valuation ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion ℝ≥0).IsNontrivial := ++ rationalFinitePlaceBaseValuationIsNontrivial p ++ ++/-- The canonical valuation on the completion of `ℚ` at `p` is compatible ++with its field structure. -/ ++theorem rationalPrimeFactorCompletionValuationCompatible ++ (p : Nat.Primes) : ++ (Valued.v : Valuation ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion ℝ≥0).Compatible := ++ rationalFinitePlaceBaseValuationCompatible p ++ ++/-- The canonical valuative relation on the completion at `p` is nontrivial. -/ ++theorem rationalPrimeFactorCompletionValuativeRelIsNontrivial ++ (p : Nat.Primes) : ++ ValuativeRel.IsNontrivial ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion := ++ rationalFinitePlaceBaseValuativeRelIsNontrivial p ++ ++/-- The completion topology at `p` is induced by its canonical valuation. -/ ++theorem rationalPrimeFactorCompletionIsValuativeTopology ++ (p : Nat.Primes) : ++ IsValuativeTopology ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion := ++ rationalFinitePlaceBaseIsValuativeTopology p ++ ++/-- The completion of `ℚ` at `p` is a nonarchimedean local field. -/ ++theorem rationalPrimeFactorCompletionIsNonarchimedeanLocalField ++ (p : Nat.Primes) : ++ IsNonarchimedeanLocalField ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion := ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField p ++ ++/-- The positive conductor of the `n`-th ramified cyclotomic level at ++`p`. -/ ++def rationalCyclotomicPrincipalPrimeModulus ++ (p : Nat.Primes) (n : ℕ) : ℕ+ := ++ ⟨p.1 ^ (n + 1), pow_pos p.2.pos (n + 1)⟩ ++ ++/-- The rational finite-place completion used at the prime `p`. -/ ++abbrev RationalCyclotomicPrincipalPrimeCompletion ++ (p : Nat.Primes) := ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion ++ ++/-- The chosen localized cyclotomic field at level `p ^ (n + 1)`. -/ ++abbrev RationalCyclotomicPrincipalPrimeLocalizedLevel ++ (p : Nat.Primes) (n : ℕ) := ++ rationalCyclotomicLocalizedCompletion ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p) ++ ++/-- The standard multiplicative Lubin--Tate field at level `n`. -/ ++abbrev RationalCyclotomicPrincipalPrimePadicLevel ++ (p : Nat.Primes) (n : ℕ) := ++ standardLubinTateLevelField ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n ++ ++/-- The valuation ring of the absolute-value completion at `q`, identified ++with the standard p-adic integer ring `ℤ_q`. -/ ++noncomputable def rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ (q : Nat.Primes) : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion] ≃+* ++ ℤ_[q.1] := by ++ let v : HeightOneSpectrum (𝓞 ℚ) := ++ RayClass.rationalPrime q ++ let vQ := HeightOneSpectrum.adicAbv ℚ v ++ let eConcreteIntegers : ++ 𝒪[vQ.Completion] ≃+* ++ v.adicCompletionIntegers ℚ := ++ finitePlaceCompletionIntegerRingEquiv v ++ exact ++ eConcreteIntegers.trans ++ (PadicInt.adicCompletionIntegersEquiv ++ (𝓞 ℚ) q).symm.toRingEquiv ++ ++/-- The absolute-value completion at the rational prime `q`, identified ++with the standard field `ℚ_q`. -/ ++noncomputable def rationalFinitePlaceCompletionRingEquivPadic ++ (q : Nat.Primes) : ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ≃+* ++ ℚ_[q.1] := ++ IsFractionRing.ringEquivOfRingEquiv ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) ++ ++/-- The completion-to-`ℚ_q` equivalence respects the rational embedding. -/ ++theorem rationalFinitePlaceCompletionRingEquivPadic_algebraMap ++ (q : Nat.Primes) (a : ℚ) : ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion a) = ++ algebraMap ℚ ℚ_[q.1] a := by ++ exact ++ (rationalFinitePlaceCompletionRingEquivPadic q).toRingHom.map_rat_algebraMap a ++ ++/-- The completion field equivalence and its restriction to valuation ++rings commute with the natural inclusions into the fields. -/ ++theorem rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe ++ (q : Nat.Primes) ++ (a : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion]) : ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion] ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion a) = ++ algebraMap ℤ_[q.1] ℚ_[q.1] ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q a) := by ++ exact ++ (IsFractionRing.ringEquivOfRingEquiv_algebraMap ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) a) ++ ++/-- The canonical rational-completion equivalence preserves the canonical ++valuations. -/ ++theorem ++ rationalFinitePlaceCompletionRingEquivPadic_semilinearValuationCompatible ++ (p : Nat.Primes) : ++ SemilinearValuationCompatible ++ (RationalCyclotomicPrincipalPrimeCompletion p) ℚ_[p.1] ++ (rationalFinitePlaceCompletionRingEquivPadic p) := by ++ let F := RationalCyclotomicPrincipalPrimeCompletion p ++ let eK := rationalFinitePlaceCompletionRingEquivPadic p ++ let : Algebra F ℚ_[p.1] := eK.toRingHom.toAlgebra ++ change ++ (ValuativeRel.valuation F).HasExtension ++ (ValuativeRel.valuation ℚ_[p.1]) ++ let eO := ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt p).trans ++ (padicIntEquivValuationSubring p.1) ++ have hChosen : ++ (localCompleteDVF F).valuation.HasExtension ++ (padicDVRValuation p.1) := by ++ change ++ (localCompleteDVF F).valuation.HasExtension ++ (padicCompleteDVF p.1).valuation ++ apply ++ ValuationTheory.DiscreteValuationField.ValuedExtension.valuation_hasExtension_of_valuationSubring_equiv ++ (localCompleteDVF F) ++ (padicCompleteDVF p.1) ++ eO ++ intro z ++ change ++ algebraMap ++ (padicDVRValuation p.1).valuationSubring ℚ_[p.1] ++ (padicIntEquivValuationSubring p.1 ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ p z)) = ++ rationalFinitePlaceCompletionRingEquivPadic p ++ (algebraMap 𝒪[F] F z) ++ symm ++ calc ++ rationalFinitePlaceCompletionRingEquivPadic p ++ (algebraMap 𝒪[F] F z) = ++ algebraMap ℤ_[p.1] ℚ_[p.1] ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ p z) := ++ rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe ++ p z ++ _ = ++ algebraMap ++ (padicDVRValuation p.1).valuationSubring ℚ_[p.1] ++ (padicIntEquivValuationSubring p.1 ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ p z)) := by ++ rw [PadicInt.algebraMap_apply, ++ ValuationSubring.algebraMap_apply] ++ exact ++ (padicIntEquivValuationSubring_coe p.1 ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ p z)).symm ++ have hBase : ++ (ValuativeRel.valuation F).HasExtension ++ (padicDVRValuation p.1) := by ++ rw [← localCompleteDVF_valuation_eq] ++ exact hChosen ++ refine ++ { val_isEquiv_comap := ?_ } ++ exact ++ hBase.val_isEquiv_comap.trans ++ ((padicDVRValuation_isEquiv_valuativeRelValuation ++ p.1).comap (algebraMap F ℚ_[p.1])) ++ ++/-- The rational prime, pulled back from `ℤ_q` to the valuation ring of ++the absolute-value completion at `q`. -/ ++noncomputable def rationalPrimeFinitePlaceInteger ++ (q : Nat.Primes) : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion] := ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt q).symm ++ (q.1 : ℤ_[q.1]) ++ ++/-- The pulled-back rational prime is irreducible in the completion ++valuation ring. -/ ++theorem rationalPrimeFinitePlaceInteger_irreducible ++ (q : Nat.Primes) : ++ Irreducible (rationalPrimeFinitePlaceInteger q) := by ++ exact ++ (MulEquiv.irreducible_iff ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ q).symm.toMulEquiv).2 ++ ((PadicInt.prime_p : ++ Prime (q.1 : ℤ_[q.1])).irreducible) ++ ++/-- Coercing the pulled-back prime to the completion field gives the ++ordinary image of the rational number `q`. -/ ++theorem rationalPrimeFinitePlaceInteger_coe ++ (q : Nat.Primes) : ++ ((rationalPrimeFinitePlaceInteger q : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion]) : ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion) = ++ algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (q.1 : ℚ) := by ++ apply ++ (rationalFinitePlaceCompletionRingEquivPadic q).injective ++ change ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion] ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeFinitePlaceInteger q)) = ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (q.1 : ℚ)) ++ calc ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion] ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeFinitePlaceInteger q)) = ++ algebraMap ℤ_[q.1] ℚ_[q.1] ++ ((rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) ++ (rationalPrimeFinitePlaceInteger q)) := ++ rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe ++ q (rationalPrimeFinitePlaceInteger q) ++ _ = (q.1 : ℚ_[q.1]) := by ++ rw [rationalPrimeFinitePlaceInteger, ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ q).apply_symm_apply, ++ PadicInt.algebraMap_apply, ++ PadicInt.coe_natCast] ++ _ = ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (q.1 : ℚ)) := by ++ rw [ ++ rationalFinitePlaceCompletionRingEquivPadic_algebraMap] ++ norm_num ++ ++/-- The rational prime as a field unit of its absolute-value completion. -/ ++noncomputable def rationalPrimeFinitePlaceFieldUnit ++ (q : Nat.Primes) : ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completionˣ := ++ Units.mk0 ++ (rationalPrimeFinitePlaceInteger q : ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion) ++ (by ++ intro hzero ++ exact ++ (rationalPrimeFinitePlaceInteger_irreducible q).ne_zero ++ (Subtype.ext hzero)) ++ ++/-- In the inverse-standard local reciprocity normalization, the rational ++prime itself has normalized additive value `-1`. -/ ++theorem rationalPrimeFinitePlaceFieldUnit_valuationMap ++ (q : Nat.Primes) : ++ IsNonarchimedeanLocalField.valuationMap ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (Additive.ofMul ++ (rationalPrimeFinitePlaceFieldUnit q)) = ++ -1 := by ++ simpa [IsNonarchimedeanLocalField.valuationMap_apply] using ++ (LocalFieldTheory.v_integerRingIrreducibleFieldUnit ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeFinitePlaceInteger q) ++ (rationalPrimeFinitePlaceInteger_irreducible q) ++ (rationalPrimeFinitePlaceFieldUnit q) rfl) ++ ++/-- The rational `q`-unit part of `x`, pulled back from `ℤ_qˣ` to the ++valuation ring of the absolute-value completion. -/ ++noncomputable def rationalPrimeUnitFinitePlaceIntegerUnit ++ (x : ℚˣ) (q : Nat.Primes) : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion]ˣ := ++ Units.map ++ (rationalFinitePlaceCompletionIntegerRingEquivPadicInt ++ q).symm.toMonoidHom ++ (padicIntUnitOfRat q ++ (rationalPrimeUnit x q : ℚ) ++ (rationalPrimeUnit x q).ne_zero ++ (padicValRat_rationalPrimeUnit x q)) ++ ++/-- Forgetting the integrality proof from the pulled-back `q`-unit gives ++the ordinary image of the rational `q`-unit in the completion field. -/ ++theorem rationalPrimeUnitFinitePlaceIntegerUnit_coe ++ (x : ℚˣ) (q : Nat.Primes) : ++ (((rationalPrimeUnitFinitePlaceIntegerUnit x q : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion]ˣ) : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion]) : ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion) = ++ algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeUnit x q : ℚ) := by ++ apply ++ (rationalFinitePlaceCompletionRingEquivPadic q).injective ++ change ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion] ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeUnitFinitePlaceIntegerUnit x q : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion])) = ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeUnit x q : ℚ)) ++ calc ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion] ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeUnitFinitePlaceIntegerUnit x q : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion])) = ++ algebraMap ℤ_[q.1] ℚ_[q.1] ++ ((rationalFinitePlaceCompletionIntegerRingEquivPadicInt q) ++ (rationalPrimeUnitFinitePlaceIntegerUnit x q : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion])) := ++ rationalFinitePlaceCompletionIntegerRingEquivPadicInt_coe q ++ (rationalPrimeUnitFinitePlaceIntegerUnit x q : ++ 𝒪[(HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion]) ++ _ = ++ ((padicIntUnitOfRat q ++ (rationalPrimeUnit x q : ℚ) ++ (rationalPrimeUnit x q).ne_zero ++ (padicValRat_rationalPrimeUnit x q) : ++ ℤ_[q.1]) : ℚ_[q.1]) := by ++ rw [rationalPrimeUnitFinitePlaceIntegerUnit] ++ simp [PadicInt.algebraMap_apply] ++ _ = ((rationalPrimeUnit x q : ℚ) : ℚ_[q.1]) := by ++ rw [padicIntUnitOfRat_coe] ++ _ = ++ rationalFinitePlaceCompletionRingEquivPadic q ++ (algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeUnit x q : ℚ)) := by ++ rw [ ++ rationalFinitePlaceCompletionRingEquivPadic_algebraMap] ++ simp ++ ++/-- The completion field unit underlying the pulled-back rational `q`-unit ++has normalized additive value zero. -/ ++theorem rationalPrimeUnitFinitePlaceField_valuationMap ++ (x : ℚˣ) (q : Nat.Primes) : ++ IsNonarchimedeanLocalField.valuationMap ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (Additive.ofMul ++ (IsNonarchimedeanLocalField.integerUnitsToFieldUnits ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeUnitFinitePlaceIntegerUnit x q))) = ++ 0 := by ++ rw [IsNonarchimedeanLocalField.valuationMap_apply] ++ exact ++ IsNonarchimedeanLocalField.v_integerUnitsToFieldUnits ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (rationalPrimeUnitFinitePlaceIntegerUnit x q) ++ ++/-- The rational prime `q`, regarded as a unit of `ℚ`. -/ ++def rationalPrimeGeneratorUnit (q : Nat.Primes) : ℚˣ := ++ Units.mk0 (q.1 : ℚ) (by exact_mod_cast q.2.ne_zero) ++ ++/-- The underlying rational number of the prime generator unit is `q`. -/ ++@[simp] ++theorem rationalPrimeGeneratorUnit_coe (q : Nat.Primes) : ++ (rationalPrimeGeneratorUnit q : ℚ) = q.1 := ++ rfl ++ ++/-- Reattaching the removed `q`-power to the rational `q`-unit recovers ++the original rational field unit. -/ ++theorem rationalPrimeGeneratorUnit_zpow_mul_rationalPrimeUnit ++ (x : ℚˣ) (q : Nat.Primes) : ++ rationalPrimeGeneratorUnit q ^ ++ padicValRat q.1 (x : ℚ) * ++ rationalPrimeUnit x q = ++ x := by ++ rw [rationalPrimeGeneratorUnit, rationalPrimeUnit, ++ ← mul_assoc, ← zpow_add] ++ simp ++ ++/-- The source unit in the absolute-value completion represented by the ++finite component of a rational principal idele. -/ ++noncomputable def rationalPrincipalFinitePlaceInput ++ (x : ℚˣ) (q : Nat.Primes) : ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completionˣ := ++ (finitePlaceCompletionUnitsContinuousMulEquiv ++ (RayClass.rationalPrime q)).symm ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime q) ++ (IdeleGroup.principalIdele ℚ x)) ++ ++/-- The source unit represented by a principal finite component is the ++ordinary image of the rational field unit in the absolute-value ++completion. -/ ++theorem rationalPrincipalFinitePlaceInput_eq_algebraMap ++ (x : ℚˣ) (q : Nat.Primes) : ++ rationalPrincipalFinitePlaceInput x q = ++ Units.map ++ (algebraMap ℚ ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion).toMonoidHom ++ x := by ++ apply Units.ext ++ let v : HeightOneSpectrum (𝓞 ℚ) := ++ RayClass.rationalPrime q ++ let vQ := HeightOneSpectrum.adicAbv ℚ v ++ let component : (v.adicCompletion ℚ)ˣ := ++ IdeleGroup.finiteComponent v ++ (IdeleGroup.principalIdele ℚ x) ++ apply (finitePlaceCompletionRingEquiv v).injective ++ change ++ finitePlaceCompletionRingEquiv v ++ (rationalPrincipalFinitePlaceInput x q : vQ.Completion) = ++ finitePlaceCompletionRingEquiv v ++ (algebraMap ℚ vQ.Completion (x : ℚ)) ++ have hCompletion : ++ finitePlaceCompletionRingEquiv v ++ (rationalPrincipalFinitePlaceInput x q : ++ vQ.Completion) = ++ (component : v.adicCompletion ℚ) := by ++ have hUnits := ++ congrArg Units.val ++ ((finitePlaceCompletionUnitsContinuousMulEquiv v).apply_symm_apply ++ component) ++ exact hUnits ++ have hComponent : ++ (component : v.adicCompletion ℚ) = ++ algebraMap ℚ (v.adicCompletion ℚ) (x : ℚ) := by ++ apply (Padic.adicCompletionEquiv (𝓞 ℚ) q).symm.injective ++ calc ++ (Padic.adicCompletionEquiv (𝓞 ℚ) q).symm ++ (component : v.adicCompletion ℚ) = ++ algebraMap ℚ ℚ_[q.1] (x : ℚ) := by ++ dsimp only [component] ++ rw [IdeleGroup.finiteComponent_principalIdele] ++ exact ++ (Padic.adicCompletionEquiv ++ (𝓞 ℚ) q).symm.commutes (x : ℚ) ++ _ = (Padic.adicCompletionEquiv (𝓞 ℚ) q).symm ++ (algebraMap ℚ (v.adicCompletion ℚ) (x : ℚ)) := by ++ symm ++ exact ++ (Padic.adicCompletionEquiv ++ (𝓞 ℚ) q).symm.commutes (x : ℚ) ++ calc ++ finitePlaceCompletionRingEquiv v ++ (rationalPrincipalFinitePlaceInput x q : ++ vQ.Completion) = ++ (component : v.adicCompletion ℚ) := hCompletion ++ _ = algebraMap ℚ (v.adicCompletion ℚ) (x : ℚ) := hComponent ++ _ = finitePlaceCompletionRingEquiv v ++ (algebraMap ℚ vQ.Completion (x : ℚ)) := by ++ symm ++ exact ++ (finitePlaceCompletionAlgEquiv (K := ℚ) v).commutes (x : ℚ) ++ ++/-- The normalized local exponent of a rational principal finite ++component is the negative of the usual `q`-adic exponent. The minus sign ++records the inverse-standard local reciprocity convention in which a ++prime element has normalized value `-1`. -/ ++theorem rationalPrincipalFiniteComponent_valuationMap ++ (x : ℚˣ) (q : Nat.Primes) : ++ IsNonarchimedeanLocalField.valuationMap ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (Additive.ofMul ++ ((finitePlaceCompletionUnitsContinuousMulEquiv ++ (RayClass.rationalPrime q)).symm ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime q) ++ (IdeleGroup.principalIdele ℚ x)))) = ++ -padicValRat q.1 (x : ℚ) := by ++ let F := ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ let embed : ℚˣ →* Fˣ := ++ Units.map (algebraMap ℚ F).toMonoidHom ++ let primeUnit : Fˣ := ++ rationalPrimeFinitePlaceFieldUnit q ++ let integralUnit : 𝒪[F]ˣ := ++ rationalPrimeUnitFinitePlaceIntegerUnit x q ++ let unitPart : Fˣ := ++ IsNonarchimedeanLocalField.integerUnitsToFieldUnits ++ F integralUnit ++ have hInput : ++ rationalPrincipalFinitePlaceInput x q = ++ embed x := by ++ exact rationalPrincipalFinitePlaceInput_eq_algebraMap x q ++ have hPrime : ++ embed (rationalPrimeGeneratorUnit q) = ++ primeUnit := by ++ apply Units.ext ++ exact ++ (rationalPrimeFinitePlaceInteger_coe q).symm ++ have hUnit : ++ embed (rationalPrimeUnit x q) = ++ unitPart := by ++ apply Units.ext ++ exact ++ (rationalPrimeUnitFinitePlaceIntegerUnit_coe ++ x q).symm ++ change ++ IsNonarchimedeanLocalField.valuationMap F ++ (Additive.ofMul ++ (rationalPrincipalFinitePlaceInput x q)) = ++ -padicValRat q.1 (x : ℚ) ++ rw [hInput] ++ conv_lhs => ++ rw [← rationalPrimeGeneratorUnit_zpow_mul_rationalPrimeUnit ++ x q] ++ rw [map_mul, map_zpow, hPrime, hUnit, ++ IsNonarchimedeanLocalField.valuationMap_ofMul_mul, ++ IsNonarchimedeanLocalField.valuationMap_ofMul_zpow, ++ rationalPrimeFinitePlaceFieldUnit_valuationMap, ++ rationalPrimeUnitFinitePlaceField_valuationMap] ++ ring ++ ++/-- The principal finite component of the rational prime itself has ++normalized local exponent `-1`. -/ ++theorem rationalPrimePrincipalFiniteComponent_valuationMap ++ (q : Nat.Primes) : ++ IsNonarchimedeanLocalField.valuationMap ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime q)).Completion ++ (Additive.ofMul ++ ((finitePlaceCompletionUnitsContinuousMulEquiv ++ (RayClass.rationalPrime q)).symm ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime q) ++ (IdeleGroup.principalIdele ℚ ++ (rationalPrimeGeneratorUnit q))))) = ++ -1 := by ++ rw [rationalPrincipalFiniteComponent_valuationMap, ++ rationalPrimeGeneratorUnit_coe, ++ padicValRat.self q.2.one_lt] ++ ++/-- A cyclotomic automorphism which raises the selected primitive root to ++the `q`-th power has cyclotomic character equal to the residue-prime unit. -/ ++theorem rationalCyclotomicLevel_galEquivZMod_eq_unitOfCoprime ++ (m : ℕ+) (q : Nat.Primes) ++ (hq : ¬ q.1 ∣ (m : ℕ)) ++ (σ : KummerTheory.rationalCyclotomicLevel m ≃ₐ[ℚ] ++ KummerTheory.rationalCyclotomicLevel m) ++ (hσ : ++ σ (rationalCyclotomicLevelPrimitiveRoot m) = ++ rationalCyclotomicLevelPrimitiveRoot m ^ q.1) : ++ IsCyclotomicExtension.Rat.galEquivZMod ++ (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ = ++ ZMod.unitOfCoprime q.1 ++ (q.2.coprime_iff_not_dvd.mpr hq) := by ++ let ζ := rationalCyclotomicLevelPrimitiveRoot m ++ have hζ : IsPrimitiveRoot ζ (m : ℕ) := ++ rationalCyclotomicLevelPrimitiveRoot_isPrimitiveRoot m ++ have hCharacterRoot : ++ σ ζ = ++ ζ ^ ++ (IsCyclotomicExtension.Rat.galEquivZMod ++ (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ).val.val := ++ IsCyclotomicExtension.Rat.galEquivZMod_apply_of_pow_eq ++ (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ ++ hζ.pow_eq_one ++ have hPowers : ++ ζ ^ ++ (IsCyclotomicExtension.Rat.galEquivZMod ++ (m : ℕ) (KummerTheory.rationalCyclotomicLevel m) σ).val.val = ++ ζ ^ q.1 := ++ hCharacterRoot.symm.trans hσ ++ rw [(hζ.isOfFinOrder m.ne_zero).pow_inj_mod, ++ ← hζ.eq_orderOf, ++ ← ZMod.natCast_eq_natCast_iff', ++ ZMod.natCast_val] at hPowers ++ apply Units.ext ++ simpa using hPowers ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinPadic.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinPadic.lean +new file mode 100644 +index 0000000..b430bec +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinPadic.lean +@@ -0,0 +1,389 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlaceArtinTower ++ ++ ++set_option autoImplicit false ++ ++open scoped Classical NNReal NumberField ValuativeRel ++open NumberField IsDedekindDomain ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open LocalClassFieldTheory ++open LocalFieldTheory ++open LocalFieldTheory.DiscreteValuationField ++open LocalFieldTheory.DiscreteValuationField.Examples.Qp ++open LubinTate ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++attribute [local instance] ++ rationalFinitePlaceCompletionRatAlgebra ++ primeFact ++ levelNeZero ++ rationalCyclotomicLevelFiniteDimensional ++ rationalCyclotomicLevelIsAbelianGalois ++ rationalFinitePlaceBaseNontriviallyNormedField ++ rationalFinitePlaceBaseLocallyCompactSpace ++ rationalFinitePlaceBaseIsUltrametricDist ++ rationalFinitePlaceBaseValued ++ rationalFinitePlaceBaseValuativeRel ++ rationalFinitePlaceBaseValuationIsNontrivial ++ rationalFinitePlaceBaseValuationCompatible ++ rationalFinitePlaceBaseValuativeRelIsNontrivial ++ rationalFinitePlaceBaseIsValuativeTopology ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField ++ rationalCyclotomicArtinExtensionAlgebra ++ rationalCyclotomicArtinExtensionSMul ++ rationalCyclotomicArtinCompletionAlgebra ++ rationalCyclotomicArtinLocalizedAlgebra ++ rationalCyclotomicArtinLocalizedGlobalAlgebra ++ rationalCyclotomicArtinLocalizedGlobalSMul ++ rationalCyclotomicArtinLocalizedScalarTower ++ rationalCyclotomicArtinLocalizedFiniteDimensional ++ rationalCyclotomicArtinLocalizedIsAbelianGalois ++ rationalCyclotomicArtinLocalizedIsSeparable ++ rationalCyclotomicArtinLocalizedIsCyclotomic ++ rationalCyclotomicArtinExtensionFiniteDimensional ++ rationalCyclotomicArtinExtensionContinuousSMul ++ rationalCyclotomicArtinExtensionLocallyCompact ++ rationalCyclotomicArtinLocalizedLocallyCompact ++ rationalCyclotomicArtinLocalizedIsUltrametricDist ++ rationalCyclotomicArtinLocalizedValued ++ rationalCyclotomicArtinLocalizedValuativeRel ++ rationalCyclotomicArtinLocalizedValuationCompatible ++ rationalCyclotomicArtinLocalizedValuationHasExtension ++ rationalCyclotomicArtinLocalizedValuationIsNontrivial ++ rationalCyclotomicArtinLocalizedValuativeRelIsNontrivial ++ rationalCyclotomicArtinLocalizedIsValuativeTopology ++ rationalCyclotomicArtinLocalizedIsNonarchimedeanLocalField ++ rationalCyclotomicArtinLocalizedIntegerAlgebra ++ rationalCyclotomicArtinLocalizedIsIntegralClosure ++ rationalCyclotomicArtinLocalizedIntegerModuleFinite ++ ++section RationalCyclotomicPrincipalPrime ++ ++/-! ## Ramified prime-power transport ++ ++This section reuses the canonical finite-place Artin tower above. In ++particular, it introduces no parallel completion/localization instance tower. -/ ++ ++noncomputable local instance ++ rationalCyclotomicPrincipalPrimeLevelIsCyclotomicExtension ++ (p : Nat.Primes) (n : ℕ) : ++ IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ ++ (KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) := by ++ change ++ IsCyclotomicExtension ++ {(rationalCyclotomicPrincipalPrimeModulus p n : ℕ)} ℚ ++ (KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ exact ++ KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ ++private abbrev rationalCyclotomicPrincipalPrimePlace ++ (p : Nat.Primes) : HeightOneSpectrum (𝓞 ℚ) := ++ rationalCyclotomicArtinPlace p ++ ++/-- The cyclotomic extension of `ℚ` generated by roots of unity of the given positive level. -/ ++abbrev rationalCyclotomicPrincipalPrimeLevel ++ (m : ℕ+) := ++ rationalCyclotomicArtinLevel m ++ ++private abbrev rationalCyclotomicPrincipalPrimeExtension ++ (m : ℕ+) (p : Nat.Primes) := ++ rationalCyclotomicArtinExtension m p ++ ++/-- The `ℚ_[p]`-algebra structure on the localized cyclotomic completion, ++transported through the canonical comparison with the `p`-adic completion. -/ ++@[reducible] ++noncomputable def ++ rationalCyclotomicPrincipalPrimeLocalizedPadicAlgebra ++ (m : ℕ+) (p : Nat.Primes) : ++ Algebra ℚ_[p.1] ++ (rationalCyclotomicLocalizedCompletion m ++ (RayClass.rationalPrime p)) := ++ ((algebraMap ++ (HeightOneSpectrum.adicAbv ℚ ++ (RayClass.rationalPrime p)).Completion ++ (rationalCyclotomicLocalizedCompletion m ++ (RayClass.rationalPrime p))).comp ++ (rationalFinitePlaceCompletionRingEquivPadic p).symm.toRingHom).toAlgebra ++ ++@[reducible] ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedPadicAlgebra ++ (m : ℕ+) (p : Nat.Primes) : ++ Algebra ℚ_[p.1] (rationalCyclotomicArtinLocalizedField m p) := ++ rationalCyclotomicPrincipalPrimeLocalizedPadicAlgebra m p ++ ++private noncomputable def rationalFinitePlaceCompletionAlgEquivPadic ++ (p : Nat.Primes) : ++ (rationalCyclotomicArtinBaseAbv p).Completion ≃ₐ[ℚ] ℚ_[p.1] := ++ AlgEquiv.ofRingEquiv ++ (f := rationalFinitePlaceCompletionRingEquivPadic p) ++ (rationalFinitePlaceCompletionRingEquivPadic_algebraMap p) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedPadicScalarTower ++ (m : ℕ+) (p : Nat.Primes) : ++ IsScalarTower ℚ ℚ_[p.1] ++ (rationalCyclotomicArtinLocalizedField m p) := by ++ constructor ++ intro r x y ++ simp only [Algebra.smul_def, map_mul, eq_ratCast, ++ map_ratCast, mul_assoc] ++ ++private theorem rationalCyclotomicArtin_padic_algebraMap ++ (m : ℕ+) (p : Nat.Primes) : ++ algebraMap (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField m p) = ++ (algebraMap ℚ_[p.1] ++ (rationalCyclotomicArtinLocalizedField m p)) ∘ ++ (rationalFinitePlaceCompletionAlgEquivPadic p) := by ++ funext a ++ change ++ algebraMap (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField m p) a = ++ algebraMap (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField m p) ++ ((rationalFinitePlaceCompletionRingEquivPadic p).symm ++ (rationalFinitePlaceCompletionRingEquivPadic p a)) ++ exact ++ congrArg ++ (algebraMap (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField m p)) ++ ((rationalFinitePlaceCompletionRingEquivPadic p).symm_apply_apply a).symm ++ ++private theorem rationalCyclotomicArtin_algebraAdjoin_restrictScalars ++ (m : ℕ+) (p : Nat.Primes) : ++ (Algebra.adjoin (rationalCyclotomicArtinBaseAbv p).Completion ++ ({rationalCyclotomicLocalizedPrimitiveRoot m ++ (rationalCyclotomicArtinPlace p)} : ++ Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ = ++ (Algebra.adjoin ℚ_[p.1] ++ ({rationalCyclotomicLocalizedPrimitiveRoot m ++ (rationalCyclotomicArtinPlace p)} : ++ Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ := by ++ exact ++ Algebra.restrictScalars_adjoin_of_algEquiv ++ (E := rationalCyclotomicArtinLocalizedField m p) ++ (rationalFinitePlaceCompletionAlgEquivPadic p) ++ (rationalCyclotomicArtin_padic_algebraMap m p) ++ ({rationalCyclotomicLocalizedPrimitiveRoot m ++ (rationalCyclotomicArtinPlace p)} : ++ Set (rationalCyclotomicArtinLocalizedField m p)) ++ ++private theorem ++ rationalCyclotomicArtin_baseAlgebraAdjoin_restrict_eq_top ++ (m : ℕ+) (p : Nat.Primes) : ++ (Algebra.adjoin (rationalCyclotomicArtinBaseAbv p).Completion ++ ({rationalCyclotomicLocalizedPrimitiveRoot m ++ (rationalCyclotomicArtinPlace p)} : ++ Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ = ++ (⊤ : Subalgebra (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ := by ++ have hRoot : IsPrimitiveRoot ++ (show rationalCyclotomicArtinLocalizedField m p from ++ rationalCyclotomicLocalizedPrimitiveRoot m ++ (rationalCyclotomicArtinPlace p)) ++ (m : ℕ) := ++ rationalCyclotomicLocalizedPrimitiveRoot_isPrimitiveRoot ++ m (rationalCyclotomicArtinPlace p) ++ have hTop : ++ Algebra.adjoin (rationalCyclotomicArtinBaseAbv p).Completion ++ ({rationalCyclotomicLocalizedPrimitiveRoot m ++ (rationalCyclotomicArtinPlace p)} : ++ Set (rationalCyclotomicArtinLocalizedField m p)) = ⊤ := ++ IsCyclotomicExtension.adjoin_primitive_root_eq_top ++ (A := (rationalCyclotomicArtinBaseAbv p).Completion) ++ (B := rationalCyclotomicArtinLocalizedField m p) hRoot ++ exact congrArg ++ (fun A : Subalgebra (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField m p) => A.restrictScalars ℚ) ++ hTop ++ ++private theorem rationalCyclotomicArtin_restrictScalars_top_base_eq_padic ++ (m : ℕ+) (p : Nat.Primes) : ++ (⊤ : Subalgebra (rationalCyclotomicArtinBaseAbv p).Completion ++ (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ = ++ (⊤ : Subalgebra ℚ_[p.1] ++ (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ := ++ (Subalgebra.restrictScalars_top ℚ).trans ++ (Subalgebra.restrictScalars_top ℚ).symm ++ ++private theorem ++ rationalCyclotomicArtin_padicAlgebraAdjoin_restrict_eq_top ++ (m : ℕ+) (p : Nat.Primes) : ++ (Algebra.adjoin ℚ_[p.1] ++ ({rationalCyclotomicLocalizedPrimitiveRoot m ++ (rationalCyclotomicArtinPlace p)} : ++ Set (rationalCyclotomicArtinLocalizedField m p))).restrictScalars ℚ = ++ (⊤ : Subalgebra ℚ_[p.1] ++ (rationalCyclotomicArtinLocalizedField m p)).restrictScalars ℚ := by ++ exact ++ (rationalCyclotomicArtin_algebraAdjoin_restrictScalars m p).symm.trans ++ ((rationalCyclotomicArtin_baseAlgebraAdjoin_restrict_eq_top m p).trans ++ (rationalCyclotomicArtin_restrictScalars_top_base_eq_padic m p)) ++ ++/-- The finite-dimensional instance for the standard multiplicative level, ++named once so all consumers use the same proof term. -/ ++theorem rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional ++ (p : Nat.Primes) (n : ℕ) : ++ FiniteDimensional ℚ_[p.1] ++ (standardLubinTateLevelField ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n) := ++ standardLubinTateLevelField_finiteDimensional ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n ++ ++attribute [local instance] ++ rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional ++ ++noncomputable local instance ++ rationalCyclotomicPrincipalPrimePadicLevelIsAbelianGalois ++ (p : Nat.Primes) (n : ℕ) : ++ IsAbelianGalois ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n) := ++ standardLubinTateLevelField_isAbelianGalois ++ (padicLocalField p.1) ++ (padicMultiplicativeLubinTateSeries_isUniformizer p.1) n ++ ++@[reducible] ++noncomputable local instance rationalPrimeFactorCompletionPadicAlgebra ++ (p : Nat.Primes) : ++ Algebra (RationalCyclotomicPrincipalPrimeCompletion p) ℚ_[p.1] := ++ (rationalFinitePlaceCompletionRingEquivPadic p).toRingHom.toAlgebra ++ ++/-- The genuine multiplicative Lubin--Tate level is generated by its ++primitive `p ^ (n + 1)`-st root of unity. -/ ++theorem padicMultiplicativePrimitiveRoot_adjoin_eq_top ++ (p : ℕ) [Fact p.Prime] (n : ℕ) : ++ let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p ++ let T := standardLubinTateLevelField hπ n ++ Algebra.adjoin ℚ_[p] ++ ({padicMultiplicativePrimitiveRoot p n} : Set T) = ++ ⊤ := by ++ let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p ++ let T := standardLubinTateLevelField hπ n ++ let ζ : T := padicMultiplicativePrimitiveRoot p n ++ let m := p ^ (n + 1) ++ let : NeZero m := ++ ⟨pow_ne_zero _ (Fact.out : Nat.Prime p).ne_zero⟩ ++ let : FiniteDimensional ℚ_[p] T := ++ standardLubinTateLevelField_finiteDimensional hπ n ++ have hζ : IsPrimitiveRoot ζ m := by ++ simpa only [ζ, m] using ++ padicMultiplicativePrimitiveRoot_isPrimitiveRoot p n ++ let A : IntermediateField ℚ_[p] T := ++ IntermediateField.adjoin ℚ_[p] {ζ} ++ let : IsCyclotomicExtension {m} ℚ_[p] A := ++ hζ.intermediateField_adjoin_isCyclotomicExtension ℚ_[p] ++ have hAfin : ++ Module.finrank ℚ_[p] A = Nat.totient m := by ++ exact ++ IsCyclotomicExtension.finrank A ++ (by ++ simpa only [m] using ++ padicCyclotomicPolynomial_irreducible_prime_pow_succ ++ p n) ++ have hTfin : ++ Module.finrank ℚ_[p] T = Nat.totient m := by ++ rw [standardLubinTateLevelField_finrank hπ n] ++ have hcard : ++ Nat.card (padicLocalField p).residueField = p := by ++ simpa [padicLocalField] using ++ padicCompleteDVF_residueField_card p ++ rw [hcard, Nat.totient_prime_pow ++ (Fact.out : Nat.Prime p) (Nat.succ_pos n)] ++ simp [Nat.mul_comm] ++ have hAeq : A = ⊤ := by ++ apply IntermediateField.eq_of_le_of_finrank_eq le_top ++ simpa using hAfin.trans hTfin.symm ++ calc ++ Algebra.adjoin ℚ_[p] {ζ} = A.toSubalgebra := by ++ exact ++ (IntermediateField.adjoin_toSubalgebra ++ ({ζ} : Set T)).symm ++ _ = (⊤ : IntermediateField ℚ_[p] T).toSubalgebra := ++ congrArg IntermediateField.toSubalgebra hAeq ++ _ = ⊤ := rfl ++ ++/-- The standard multiplicative Lubin--Tate level is the actual ++`p ^ (n + 1)`-cyclotomic extension of `ℚ_p`. -/ ++theorem padicMultiplicativeLevel_isCyclotomicExtension ++ (p : ℕ) [Fact p.Prime] (n : ℕ) : ++ let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p ++ let T := standardLubinTateLevelField hπ n ++ IsCyclotomicExtension {p ^ (n + 1)} ℚ_[p] T := by ++ let hπ := padicMultiplicativeLubinTateSeries_isUniformizer p ++ let T := standardLubinTateLevelField hπ n ++ exact ++ padic_isCyclotomicExtension_of_primitiveRoot_adjoin_eq_top ++ (padicMultiplicativePrimitiveRoot p n) ++ (padicMultiplicativePrimitiveRoot_isPrimitiveRoot p n) ++ (padicMultiplicativePrimitiveRoot_adjoin_eq_top p n) ++ ++private theorem ++ rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_isPrimitiveRoot ++ (p : Nat.Primes) (n : ℕ) : ++ IsPrimitiveRoot ++ (rationalCyclotomicLocalizedPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) ++ (p.1 ^ (n + 1)) := by ++ change ++ IsPrimitiveRoot ++ (rationalCyclotomicLocalizedPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) ++ (rationalCyclotomicPrincipalPrimeModulus p n : ℕ) ++ exact ++ rationalCyclotomicLocalizedPrimitiveRoot_isPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p) ++ ++private theorem ++ rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_adjoin_eq_top ++ (p : Nat.Primes) (n : ℕ) : ++ Algebra.adjoin ℚ_[p.1] ++ ({rationalCyclotomicLocalizedPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (rationalCyclotomicArtinPlace p)} : ++ Set (rationalCyclotomicArtinLocalizedField ++ (rationalCyclotomicPrincipalPrimeModulus p n) p)) = ++ ⊤ := by ++ exact ++ (Subalgebra.restrictScalars_injective ℚ) ++ (rationalCyclotomicArtin_padicAlgebraAdjoin_restrict_eq_top ++ (rationalCyclotomicPrincipalPrimeModulus p n) p) ++ ++theorem ++ rationalCyclotomicPrincipalPrimeLocalizedLevel_isCyclotomicExtension ++ (p : Nat.Primes) (n : ℕ) : ++ IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ_[p.1] ++ (rationalCyclotomicArtinLocalizedField ++ (rationalCyclotomicPrincipalPrimeModulus p n) p) := by ++ exact ++ padic_isCyclotomicExtension_of_primitiveRoot_adjoin_eq_top ++ (rationalCyclotomicLocalizedPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (rationalCyclotomicArtinPlace p)) ++ (rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_isPrimitiveRoot ++ p n) ++ (rationalCyclotomicPrincipalPrimeLocalizedPrimitiveRoot_adjoin_eq_top ++ p n) ++ ++ ++end RationalCyclotomicPrincipalPrime ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinPrincipal.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinPrincipal.lean +new file mode 100644 +index 0000000..43c227c +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinPrincipal.lean +@@ -0,0 +1,228 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlaceArtinAction ++ ++ ++set_option autoImplicit false ++ ++open scoped Classical NNReal NumberField ValuativeRel ++open NumberField IsDedekindDomain ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open LocalClassFieldTheory ++open LocalFieldTheory ++open LocalFieldTheory.DiscreteValuationField ++open LocalFieldTheory.DiscreteValuationField.Examples.Qp ++open LubinTate ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++section RationalCyclotomicPrincipalPrime ++ ++attribute [local instance] ++ rationalFinitePlaceCompletionRatAlgebra ++ primeFact ++ levelNeZero ++ rationalCyclotomicLevelFiniteDimensional ++ rationalCyclotomicLevelIsAbelianGalois ++ rationalFinitePlaceBaseNontriviallyNormedField ++ rationalFinitePlaceBaseLocallyCompactSpace ++ rationalFinitePlaceBaseIsUltrametricDist ++ rationalFinitePlaceBaseValued ++ rationalFinitePlaceBaseValuativeRel ++ rationalFinitePlaceBaseValuationIsNontrivial ++ rationalFinitePlaceBaseValuationCompatible ++ rationalFinitePlaceBaseValuativeRelIsNontrivial ++ rationalFinitePlaceBaseIsValuativeTopology ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField ++ rationalCyclotomicArtinExtensionAlgebra ++ rationalCyclotomicArtinExtensionSMul ++ rationalCyclotomicArtinCompletionAlgebra ++ rationalCyclotomicArtinLocalizedAlgebra ++ rationalCyclotomicArtinLocalizedGlobalAlgebra ++ rationalCyclotomicArtinLocalizedGlobalSMul ++ rationalCyclotomicArtinLocalizedScalarTower ++ rationalCyclotomicArtinLocalizedFiniteDimensional ++ rationalCyclotomicArtinLocalizedIsAbelianGalois ++ rationalCyclotomicArtinLocalizedIsSeparable ++ rationalCyclotomicArtinLocalizedIsCyclotomic ++ rationalCyclotomicArtinExtensionFiniteDimensional ++ rationalCyclotomicArtinExtensionContinuousSMul ++ rationalCyclotomicArtinExtensionLocallyCompact ++ rationalCyclotomicArtinLocalizedLocallyCompact ++ rationalCyclotomicArtinLocalizedIsUltrametricDist ++ rationalCyclotomicArtinLocalizedValued ++ rationalCyclotomicArtinLocalizedValuativeRel ++ rationalCyclotomicArtinLocalizedValuationCompatible ++ rationalCyclotomicArtinLocalizedValuationHasExtension ++ rationalCyclotomicArtinLocalizedValuationIsNontrivial ++ rationalCyclotomicArtinLocalizedValuativeRelIsNontrivial ++ rationalCyclotomicArtinLocalizedIsValuativeTopology ++ rationalCyclotomicArtinLocalizedIsNonarchimedeanLocalField ++ rationalCyclotomicArtinLocalizedIntegerAlgebra ++ rationalCyclotomicArtinLocalizedIsIntegralClosure ++ rationalCyclotomicArtinLocalizedIntegerModuleFinite ++ rationalCyclotomicPrincipalPrimeLevelIsCyclotomicExtension ++ rationalCyclotomicArtinLocalizedPadicAlgebra ++ rationalCyclotomicArtinLocalizedPadicScalarTower ++ rationalCyclotomicPrincipalPrimePadicLevelIsAbelianGalois ++ rationalPrimeFactorCompletionPadicAlgebra ++ rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional ++ ++private theorem ++ rationalCyclotomicPrincipalPrime_padicUnitParameterArtin_action ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) = ++ (rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) ^ ++ (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val := by ++ let m := rationalCyclotomicPrincipalPrimeModulus p n ++ let E := rationalCyclotomicArtinLocalizedField m p ++ let T := RationalCyclotomicPrincipalPrimePadicLevel p n ++ let eL : E ≃ₐ[ℚ_[p.1]] T := ++ rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ let zetaE : E := rationalCyclotomicPrincipalPrimeLocalizedRoot p n ++ let tau : Gal(T / ℚ_[p.1]) := ++ rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x ++ let a := rationalCyclotomicPrincipalPrimeResidueUnit p n x ++ let zetaT : T := padicMultiplicativePrimitiveRoot p.1 n ++ have hzetaE : IsPrimitiveRoot zetaE (p.1 ^ (n + 1)) := by ++ change ++ IsPrimitiveRoot ++ (rationalCyclotomicLocalizedPrimitiveRoot m ++ (RayClass.rationalPrime p)) (m : ℕ) ++ exact ++ rationalCyclotomicLocalizedPrimitiveRoot_isPrimitiveRoot ++ m (RayClass.rationalPrime p) ++ have hrho : IsPrimitiveRoot (eL zetaE) (p.1 ^ (n + 1)) := ++ hzetaE.map_of_injective eL.injective ++ have hzetaT : IsPrimitiveRoot zetaT (p.1 ^ (n + 1)) := ++ padicMultiplicativePrimitiveRoot_isPrimitiveRoot p.1 n ++ have htauZetaT : tau zetaT = zetaT ^ a.val.val := ++ padicMultiplicativePrimitiveRoot_rationalPrimeUnitParameterGaloisAction ++ p n x ++ exact ++ map_primitiveRoot_eq_pow_of_eq_pow ++ tau.toMonoidHom zetaT (eL zetaE) ++ (p.1 ^ (n + 1)) a.val.val hzetaT hrho htauZetaT ++ ++private theorem rationalCyclotomicPrincipalPrime_localArtin_action ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ finitePlaceLocalArtinMonoidHom ++ (K := ℚ) ++ (L := KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (RayClass.rationalPrime p) ++ (rationalCyclotomicChosenFinitePlaceExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime p) ++ (IdeleGroup.principalIdele ℚ x)) ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) = ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) ^ ++ (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val := by ++ let eL := rationalCyclotomicLocalizedCompletionPadicAlgEquiv p n ++ apply eL.injective ++ calc ++ _ = _ := ++ finitePlaceLocalArtinMonoidHom_apply_semilinear ++ (K := ℚ) ++ (L := KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (K' := ℚ_[p.1]) ++ (L' := RationalCyclotomicPrincipalPrimePadicLevel p n) ++ (RayClass.rationalPrime p) ++ (rationalCyclotomicChosenFinitePlaceExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) ++ (rationalFinitePlaceCompletionRingEquivPadic p) ++ eL.toRingEquiv ++ (rationalCyclotomicPrincipalPrime_localizedBase_commutes p n) ++ (rationalFinitePlaceCompletionRingEquivPadic_semilinearValuationCompatible ++ p) ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime p) ++ (IdeleGroup.principalIdele ℚ x)) ++ (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) ++ _ = rationalCyclotomicPrincipalPrimePadicUnitParameterArtin p n x ++ (eL (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) := ++ rationalCyclotomicPrincipalPrime_padicArtin_action_eq_unitParameter ++ p n x ++ _ = (eL (rationalCyclotomicPrincipalPrimeLocalizedRoot p n)) ^ ++ (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val := ++ rationalCyclotomicPrincipalPrime_padicUnitParameterArtin_action p n x ++ _ = eL ((rationalCyclotomicPrincipalPrimeLocalizedRoot p n) ^ ++ (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val) := ++ (map_pow eL (rationalCyclotomicPrincipalPrimeLocalizedRoot p n) ++ (rationalCyclotomicPrincipalPrimeResidueUnit p n x).val.val).symm ++ ++/-- The finite-place Artin symbol at the ramified prime, in its canonical ++local-to-global factored form. Keeping this specialization opaque prevents its ++dependent local/global instance tower from being unfolded downstream. -/ ++noncomputable def rationalCyclotomicPrincipalPrimeChosenArtin ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n) ≃ₐ[ℚ] ++ KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n) := ++ finitePlaceLocalToGlobalMonoidHom ++ (K := ℚ) ++ (L := KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (RayClass.rationalPrime p) ++ (rationalCyclotomicChosenFinitePlaceExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) ++ (finitePlaceLocalArtinMonoidHom ++ (K := ℚ) ++ (L := KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (RayClass.rationalPrime p) ++ (rationalCyclotomicChosenFinitePlaceExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n) ++ (RayClass.rationalPrime p)) ++ (IdeleGroup.finiteComponent ++ (RayClass.rationalPrime p) ++ (IdeleGroup.principalIdele ℚ x))) ++ ++/-- At the ramified prime, the cyclotomic character of the chosen finite-place ++Artin symbol is the direct reduction of the rational `p`-adic unit. -/ ++theorem galEquivZMod_chosenFinitePlaceArtinMonoidHom_principal_at_prime ++ (p : Nat.Primes) (n : ℕ) (x : ℚˣ) : ++ IsCyclotomicExtension.Rat.galEquivZMod ++ (p.1 ^ (n + 1)) ++ (KummerTheory.rationalCyclotomicLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (hK := ++ KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (rationalCyclotomicPrincipalPrimeChosenArtin p n x) = ++ Units.map ++ (PadicInt.toZModPow (p := p.1) (n + 1)).toMonoidHom ++ (padicIntUnitOfRat p ++ (rationalPrimeUnit x p : ℚ) ++ (rationalPrimeUnit x p).ne_zero ++ (padicValRat_rationalPrimeUnit x p)) := by ++ change _ = rationalCyclotomicPrincipalPrimeResidueUnit p n x ++ apply rationalCyclotomicPrincipalPrime_galEquivZMod_eq_of_action p n ++ simp only [rationalCyclotomicPrincipalPrimeChosenArtin] ++ apply finitePlaceLocalToGlobalMonoidHom_apply_pow_of_localized_action ++ (zLocal := rationalCyclotomicPrincipalPrimeLocalizedRoot p n) ++ · rfl ++ · exact rationalCyclotomicPrincipalPrime_localArtin_action p n x ++ ++end RationalCyclotomicPrincipalPrime ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinTower.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinTower.lean +new file mode 100644 +index 0000000..77efaa0 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinTower.lean +@@ -0,0 +1,357 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlaceArtinBase ++ ++ ++set_option autoImplicit false ++ ++open scoped Classical NNReal NumberField ValuativeRel ++open NumberField IsDedekindDomain ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open LocalClassFieldTheory ++open LocalFieldTheory ++open LocalFieldTheory.DiscreteValuationField ++open LocalFieldTheory.DiscreteValuationField.Examples.Qp ++open LubinTate ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++attribute [local instance] ++ rationalFinitePlaceCompletionRatAlgebra ++ primeFact ++ levelNeZero ++ rationalCyclotomicLevelFiniteDimensional ++ rationalCyclotomicLevelIsAbelianGalois ++ rationalFinitePlaceBaseNontriviallyNormedField ++ rationalFinitePlaceBaseLocallyCompactSpace ++ rationalFinitePlaceBaseIsUltrametricDist ++ rationalFinitePlaceBaseValued ++ rationalFinitePlaceBaseValuativeRel ++ rationalFinitePlaceBaseValuationIsNontrivial ++ rationalFinitePlaceBaseValuationCompatible ++ rationalFinitePlaceBaseValuativeRelIsNontrivial ++ rationalFinitePlaceBaseIsValuativeTopology ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField ++ ++/-- The finite place of `ℚ` determined by the rational prime `q`. -/ ++abbrev rationalCyclotomicArtinPlace (q : Nat.Primes) : ++ HeightOneSpectrum (𝓞 ℚ) := ++ RayClass.rationalPrime q ++ ++/-- The `q`-adic absolute value on `ℚ` used for the finite-place Artin map. -/ ++abbrev rationalCyclotomicArtinBaseAbv (q : Nat.Primes) : ++ AbsoluteValue ℚ ℝ := ++ HeightOneSpectrum.adicAbv ℚ (rationalCyclotomicArtinPlace q) ++ ++/-- The rational cyclotomic extension at the positive level `m`. -/ ++abbrev rationalCyclotomicArtinLevel (m : ℕ+) := ++ KummerTheory.rationalCyclotomicLevel m ++ ++/-- A chosen extension of the `q`-adic absolute value to the cyclotomic field. -/ ++abbrev rationalCyclotomicArtinExtension ++ (m : ℕ+) (q : Nat.Primes) : ++ AbsoluteValueExtension ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinLevel m) := ++ chosenFinitePlaceExtension ++ (L := rationalCyclotomicArtinLevel m) ++ (rationalCyclotomicArtinPlace q) ++ ++/-- The local completion of the cyclotomic field at the chosen place above `q`. -/ ++abbrev rationalCyclotomicArtinLocalizedField ++ (m : ℕ+) (q : Nat.Primes) := ++ AlgebraicNumberTheory.Valuations.LocalizedCompletion ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q) ++ ++@[reducible] ++noncomputable local instance rationalCyclotomicArtinExtensionAlgebra ++ (m : ℕ+) (q : Nat.Primes) : ++ Algebra ℚ ++ (rationalCyclotomicArtinExtension m q).1.Completion := ++ AbsoluteValue.extensionCompletionAlgebra ++ (K := ℚ) (rationalCyclotomicArtinExtension m q).1 ++ ++@[reducible] ++noncomputable local instance rationalCyclotomicArtinExtensionSMul ++ (m : ℕ+) (q : Nat.Primes) : ++ SMul ℚ ++ (rationalCyclotomicArtinExtension m q).1.Completion := ++ (rationalCyclotomicArtinExtensionAlgebra m q).toSMul ++ ++@[reducible] ++noncomputable local instance ++ rationalCyclotomicArtinCompletionAlgebra ++ (m : ℕ+) (q : Nat.Primes) : ++ Algebra (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinExtension m q).1.Completion := ++ AbsoluteValue.completionAlgebra ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q).1 ++ (rationalCyclotomicArtinExtension m q).2 ++ ++@[reducible] ++noncomputable local instance rationalCyclotomicArtinLocalizedAlgebra ++ (m : ℕ+) (q : Nat.Primes) : ++ Algebra (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinLocalizedField m q) := ++ finitePlaceLocalArtinLocalizedAlgebra ++ (K := ℚ) (L := rationalCyclotomicArtinLevel m) ++ (rationalCyclotomicArtinPlace q) ++ (rationalCyclotomicArtinExtension m q) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedGlobalAlgebra ++ (m : ℕ+) (q : Nat.Primes) : ++ Algebra ℚ (rationalCyclotomicArtinLocalizedField m q) := ++ LocalClassFieldTheory.localizedCompletionGlobalAlgebra ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedGlobalSMul ++ (m : ℕ+) (q : Nat.Primes) : ++ SMul ℚ (rationalCyclotomicArtinLocalizedField m q) := ++ (rationalCyclotomicArtinLocalizedGlobalAlgebra m q).toSMul ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedScalarTower ++ (m : ℕ+) (q : Nat.Primes) : ++ IsScalarTower ℚ ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinLocalizedField m q) := by ++ constructor ++ intro r x y ++ simp only [Algebra.smul_def, map_mul, eq_ratCast, ++ map_ratCast, mul_assoc] ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedFiniteDimensional ++ (m : ℕ+) (q : Nat.Primes) : ++ FiniteDimensional ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinLocalizedField m q) := ++ finitePlaceLocalArtinFiniteDimensional ++ (K := ℚ) (L := rationalCyclotomicArtinLevel m) ++ (rationalCyclotomicArtinPlace q) ++ (rationalCyclotomicArtinExtension m q) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIsAbelianGalois ++ (m : ℕ+) (q : Nat.Primes) : ++ IsAbelianGalois ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinLocalizedField m q) := ++ finitePlaceLocalArtinIsAbelianGalois ++ (K := ℚ) (L := rationalCyclotomicArtinLevel m) ++ (rationalCyclotomicArtinPlace q) ++ (rationalCyclotomicArtinExtension m q) ++ (inferInstance : ++ FiniteDimensional ℚ (rationalCyclotomicArtinLevel m)) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIsSeparable ++ (m : ℕ+) (q : Nat.Primes) : ++ Algebra.IsSeparable ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinLocalizedField m q) := ++ (rationalCyclotomicArtinLocalizedIsAbelianGalois m q).toIsGalois.to_isSeparable ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIsCyclotomic ++ (m : ℕ+) (q : Nat.Primes) : ++ IsCyclotomicExtension {(m : ℕ)} ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinLocalizedField m q) := ++ rationalCyclotomicLevel_localizedCompletion_isCyclotomicExtension ++ m (rationalCyclotomicArtinPlace q) ++ ++noncomputable local instance ++ rationalCyclotomicArtinExtensionFiniteDimensional ++ (m : ℕ+) (q : Nat.Primes) : ++ FiniteDimensional ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinExtension m q).1.Completion := ++ completionModuleFinite ++ (rationalCyclotomicArtinBaseAbv q) ++ (RayClass.adicAbv_isNontrivial ++ (rationalCyclotomicArtinPlace q)) ++ (rationalCyclotomicArtinExtension m q) ++ ++noncomputable local instance ++ rationalCyclotomicArtinExtensionContinuousSMul ++ (m : ℕ+) (q : Nat.Primes) : ++ ContinuousSMul ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinExtension m q).1.Completion := ++ continuousSMul_of_algebraMap _ _ ++ (AbsoluteValue.completionMap_isometry ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q).1 ++ (rationalCyclotomicArtinExtension m q).2).continuous ++ ++noncomputable local instance ++ rationalCyclotomicArtinExtensionLocallyCompact ++ (m : ℕ+) (q : Nat.Primes) : ++ LocallyCompactSpace ++ (rationalCyclotomicArtinExtension m q).1.Completion := ++ LocallyCompactSpace.of_finiteDimensional_of_complete ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinExtension m q).1.Completion ++ ++private noncomputable def ++ rationalCyclotomicArtinLocalizedEquivCompletion ++ (m : ℕ+) (q : Nat.Primes) : ++ rationalCyclotomicArtinLocalizedField m q ≃ᵢ ++ (rationalCyclotomicArtinExtension m q).1.Completion := ++ { toEquiv := ++ (localizedCompletionEquivCompletion ++ (rationalCyclotomicArtinBaseAbv q) ++ (RayClass.adicAbv_isNontrivial ++ (rationalCyclotomicArtinPlace q)) ++ (rationalCyclotomicArtinExtension m q)).toEquiv ++ isometry_toFun := ++ Isometry.of_dist_eq fun _ _ => rfl } ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedLocallyCompact ++ (m : ℕ+) (q : Nat.Primes) : ++ LocallyCompactSpace ++ (rationalCyclotomicArtinLocalizedField m q) := ++ ((rationalCyclotomicArtinLocalizedEquivCompletion m q).toHomeomorph.locallyCompactSpace_iff).2 ++ inferInstance ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIsUltrametricDist ++ (m : ℕ+) (q : Nat.Primes) : ++ IsUltrametricDist ++ (rationalCyclotomicArtinLocalizedField m q) := ++ localizedCompletionIsUltrametricDist ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv ++ ℚ (rationalCyclotomicArtinPlace q)) ++ ++noncomputable local instance rationalCyclotomicArtinLocalizedValued ++ (m : ℕ+) (q : Nat.Primes) : ++ Valued (rationalCyclotomicArtinLocalizedField m q) ℝ≥0 := ++ localizedCompletionFinitePlaceValued ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv ++ ℚ (rationalCyclotomicArtinPlace q)) ++ ++@[reducible] ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedValuativeRel ++ (m : ℕ+) (q : Nat.Primes) : ++ ValuativeRel (rationalCyclotomicArtinLocalizedField m q) := ++ localizedCompletionFinitePlaceValuativeRel ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv ++ ℚ (rationalCyclotomicArtinPlace q)) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedValuationCompatible ++ (m : ℕ+) (q : Nat.Primes) : ++ (Valued.v : Valuation ++ (rationalCyclotomicArtinLocalizedField m q) ℝ≥0).Compatible := ++ Valuation.Compatible.ofValuation _ ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedValuationHasExtension ++ (m : ℕ+) (q : Nat.Primes) : ++ Valuation.HasExtension ++ (ValuativeRel.valuation ++ (rationalCyclotomicArtinBaseAbv q).Completion) ++ (ValuativeRel.valuation ++ (rationalCyclotomicArtinLocalizedField m q)) := ++ localizedCompletionValuationHasExtension ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv ++ ℚ (rationalCyclotomicArtinPlace q)) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedValuationIsNontrivial ++ (m : ℕ+) (q : Nat.Primes) : ++ (ValuativeRel.valuation ++ (rationalCyclotomicArtinLocalizedField m q)).IsNontrivial := ++ Valuation.IsNontrivial.of_hasExtension ++ (ValuativeRel.valuation ++ (rationalCyclotomicArtinBaseAbv q).Completion) ++ (ValuativeRel.valuation ++ (rationalCyclotomicArtinLocalizedField m q)) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedValuativeRelIsNontrivial ++ (m : ℕ+) (q : Nat.Primes) : ++ ValuativeRel.IsNontrivial ++ (rationalCyclotomicArtinLocalizedField m q) := ++ (ValuativeRel.isNontrivial_iff_isNontrivial ++ (ValuativeRel.valuation ++ (rationalCyclotomicArtinLocalizedField m q))).2 inferInstance ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIsValuativeTopology ++ (m : ℕ+) (q : Nat.Primes) : ++ IsValuativeTopology ++ (rationalCyclotomicArtinLocalizedField m q) := ++ isValuativeTopology_of_valued_ofValuation ++ (rationalCyclotomicArtinLocalizedField m q) ℝ≥0 ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIsNonarchimedeanLocalField ++ (m : ℕ+) (q : Nat.Primes) : ++ IsNonarchimedeanLocalField ++ (rationalCyclotomicArtinLocalizedField m q) := ++ { toIsValuativeTopology := inferInstance ++ toLocallyCompactSpace := inferInstance ++ toIsNontrivial := inferInstance } ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIntegerAlgebra ++ (m : ℕ+) (q : Nat.Primes) : ++ Algebra ++ 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] ++ (rationalCyclotomicArtinLocalizedField m q) := ++ Algebra.ofSubsemiring ++ 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIsIntegralClosure ++ (m : ℕ+) (q : Nat.Primes) : ++ IsIntegralClosure ++ 𝒪[rationalCyclotomicArtinLocalizedField m q] ++ 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] ++ (rationalCyclotomicArtinLocalizedField m q) := ++ localizedCompletionIsIntegralClosureWithExtension ++ (rationalCyclotomicArtinBaseAbv q) ++ (rationalCyclotomicArtinExtension m q) ++ (RayClass.adicAbv_isNontrivial ++ (rationalCyclotomicArtinPlace q)) ++ (HeightOneSpectrum.isNonarchimedean_adicAbv ++ ℚ (rationalCyclotomicArtinPlace q)) ++ ++noncomputable local instance ++ rationalCyclotomicArtinLocalizedIntegerModuleFinite ++ (m : ℕ+) (q : Nat.Primes) : ++ Module.Finite ++ 𝒪[(rationalCyclotomicArtinBaseAbv q).Completion] ++ 𝒪[rationalCyclotomicArtinLocalizedField m q] := ++ integerRing_moduleFinite_of_isIntegralClosure ++ (rationalCyclotomicArtinBaseAbv q).Completion ++ (rationalCyclotomicArtinLocalizedField m q) ++ ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinTransport.lean b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinTransport.lean +new file mode 100644 +index 0000000..666b029 +--- /dev/null ++++ b/Lean4/ClassFieldTheory/GlobalClassFieldTheory/Reciprocity/RationalCyclotomicFinitePlaceArtinTransport.lean +@@ -0,0 +1,375 @@ ++/- ++Copyright (c) 2026 Naganori Yamaguchi (https://github.com/n-yamaguchi-0729). All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Naganori Yamaguchi (assisted by OpenAI Codex) ++-/ ++ ++import ClassFieldTheory.GlobalClassFieldTheory.Reciprocity.RationalCyclotomicFinitePlaceArtinPadic ++ ++ ++set_option autoImplicit false ++ ++open scoped Classical NNReal NumberField ValuativeRel ++open NumberField IsDedekindDomain ++open AlgebraicNumberTheory.Valuations ++open HilbertRamification ++open LocalClassFieldTheory ++open LocalFieldTheory ++open LocalFieldTheory.DiscreteValuationField ++open LocalFieldTheory.DiscreteValuationField.Examples.Qp ++open LubinTate ++ ++noncomputable section ++ ++namespace GlobalClassFieldTheory ++namespace Reciprocity ++ ++section RationalCyclotomicPrincipalPrime ++ ++attribute [local instance] ++ rationalFinitePlaceCompletionRatAlgebra ++ primeFact ++ levelNeZero ++ rationalCyclotomicLevelFiniteDimensional ++ rationalCyclotomicLevelIsAbelianGalois ++ rationalFinitePlaceBaseNontriviallyNormedField ++ rationalFinitePlaceBaseLocallyCompactSpace ++ rationalFinitePlaceBaseIsUltrametricDist ++ rationalFinitePlaceBaseValued ++ rationalFinitePlaceBaseValuativeRel ++ rationalFinitePlaceBaseValuationIsNontrivial ++ rationalFinitePlaceBaseValuationCompatible ++ rationalFinitePlaceBaseValuativeRelIsNontrivial ++ rationalFinitePlaceBaseIsValuativeTopology ++ rationalFinitePlaceBaseIsNonarchimedeanLocalField ++ rationalCyclotomicArtinExtensionAlgebra ++ rationalCyclotomicArtinExtensionSMul ++ rationalCyclotomicArtinCompletionAlgebra ++ rationalCyclotomicArtinLocalizedAlgebra ++ rationalCyclotomicArtinLocalizedGlobalAlgebra ++ rationalCyclotomicArtinLocalizedGlobalSMul ++ rationalCyclotomicArtinLocalizedScalarTower ++ rationalCyclotomicArtinLocalizedFiniteDimensional ++ rationalCyclotomicArtinLocalizedIsAbelianGalois ++ rationalCyclotomicArtinLocalizedIsSeparable ++ rationalCyclotomicArtinLocalizedIsCyclotomic ++ rationalCyclotomicArtinExtensionFiniteDimensional ++ rationalCyclotomicArtinExtensionContinuousSMul ++ rationalCyclotomicArtinExtensionLocallyCompact ++ rationalCyclotomicArtinLocalizedLocallyCompact ++ rationalCyclotomicArtinLocalizedIsUltrametricDist ++ rationalCyclotomicArtinLocalizedValued ++ rationalCyclotomicArtinLocalizedValuativeRel ++ rationalCyclotomicArtinLocalizedValuationCompatible ++ rationalCyclotomicArtinLocalizedValuationHasExtension ++ rationalCyclotomicArtinLocalizedValuationIsNontrivial ++ rationalCyclotomicArtinLocalizedValuativeRelIsNontrivial ++ rationalCyclotomicArtinLocalizedIsValuativeTopology ++ rationalCyclotomicArtinLocalizedIsNonarchimedeanLocalField ++ rationalCyclotomicArtinLocalizedIntegerAlgebra ++ rationalCyclotomicArtinLocalizedIsIntegralClosure ++ rationalCyclotomicArtinLocalizedIntegerModuleFinite ++ rationalCyclotomicPrincipalPrimeLevelIsCyclotomicExtension ++ rationalCyclotomicArtinLocalizedPadicAlgebra ++ rationalCyclotomicArtinLocalizedPadicScalarTower ++ rationalCyclotomicPrincipalPrimePadicLevelIsAbelianGalois ++ rationalPrimeFactorCompletionPadicAlgebra ++ rationalCyclotomicPrincipalPrimePadicLevelFiniteDimensional ++ ++/-- The chosen localized global cyclotomic level, transported over the ++completion equivalence, is the standard multiplicative Lubin--Tate level. -/ ++noncomputable def rationalCyclotomicLocalizedCompletionPadicAlgEquiv ++ (p : Nat.Primes) (n : ℕ) : ++ rationalCyclotomicArtinLocalizedField ++ (rationalCyclotomicPrincipalPrimeModulus p n) p ≃ₐ[ℚ_[p.1]] ++ RationalCyclotomicPrincipalPrimePadicLevel p n := by ++ letI : IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ_[p.1] ++ (rationalCyclotomicArtinLocalizedField ++ (rationalCyclotomicPrincipalPrimeModulus p n) p) := ++ rationalCyclotomicPrincipalPrimeLocalizedLevel_isCyclotomicExtension p n ++ letI : IsCyclotomicExtension {p.1 ^ (n + 1)} ℚ_[p.1] ++ (RationalCyclotomicPrincipalPrimePadicLevel p n) := ++ padicMultiplicativeLevel_isCyclotomicExtension p.1 n ++ exact ++ IsCyclotomicExtension.algEquiv ++ {p.1 ^ (n + 1)} ℚ_[p.1] ++ (rationalCyclotomicArtinLocalizedField ++ (rationalCyclotomicPrincipalPrimeModulus p n) p) ++ (RationalCyclotomicPrincipalPrimePadicLevel p n) ++ ++/-! ## The ramified principal finite-place factor -/ ++ ++theorem ++ rationalCyclotomicPrincipalPrime_galEquivZMod_eq_of_action ++ (p : Nat.Primes) (n : ℕ) ++ (sigma : Gal( ++ rationalCyclotomicPrincipalPrimeLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n) / ℚ)) ++ (a : (ZMod (p.1 ^ (n + 1)))ˣ) ++ (haction : ++ sigma (rationalCyclotomicLevelPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n)) = ++ rationalCyclotomicLevelPrimitiveRoot ++ (rationalCyclotomicPrincipalPrimeModulus p n) ^ a.val.val) : ++ IsCyclotomicExtension.Rat.galEquivZMod ++ (p.1 ^ (n + 1)) ++ (rationalCyclotomicPrincipalPrimeLevel ++ (rationalCyclotomicPrincipalPrimeModulus p n)) ++ (hK := ++ KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension ++ (rationalCyclotomicPrincipalPrimeModulus p n)) sigma = ++ a := by ++ let m := rationalCyclotomicPrincipalPrimeModulus p n ++ let L := rationalCyclotomicPrincipalPrimeLevel m ++ let zeta : L := rationalCyclotomicLevelPrimitiveRoot m ++ have hzeta : IsPrimitiveRoot zeta (p.1 ^ (n + 1)) := by ++ change ++ IsPrimitiveRoot ++ (rationalCyclotomicLevelPrimitiveRoot m) (m : ℕ) ++ exact rationalCyclotomicLevelPrimitiveRoot_isPrimitiveRoot m ++ change ++ IsCyclotomicExtension.Rat.galEquivZMod ++ (p.1 ^ (n + 1)) L ++ (hK := ++ KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension m) ++ sigma = a ++ let c := ++ IsCyclotomicExtension.Rat.galEquivZMod ++ (p.1 ^ (n + 1)) L ++ (hK := ++ KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension m) ++ sigma ++ have hc : ++ sigma zeta = zeta ^ c.val.val := ++ IsCyclotomicExtension.Rat.galEquivZMod_apply_of_pow_eq ++ (hK := ++ KummerTheory.rationalCyclotomicLevel_isCyclotomicExtension m) ++ (p.1 ^ (n + 1)) L sigma hzeta.pow_eq_one ++ have hpowers : ++ zeta ^ c.val.val = zeta ^ a.val.val := ++ hc.symm.trans haction ++ rw [(hzeta.isOfFinOrder m.ne_zero).pow_inj_mod, ++ ← hzeta.eq_orderOf, ++ ← ZMod.natCast_eq_natCast_iff'] at hpowers ++ change ++ (c.val.val : ZMod (p.1 ^ (n + 1))) = ++ (a.val.val : ZMod (p.1 ^ (n + 1))) at hpowers ++ have hValues : c.val = a.val := by ++ calc ++ c.val = (c.val.val : ZMod (p.1 ^ (n + 1))) := ++ (ZMod.natCast_zmod_val c.val).symm ++ _ = (a.val.val : ZMod (p.1 ^ (n + 1))) := hpowers ++ _ = a.val := ZMod.natCast_zmod_val a.val ++ change c = a ++ apply Units.ext ++ exact hValues ++ ++/-- The chosen finite-place Artin map factors through any extension identified ++with the chosen one. -/ ++theorem chosenFinitePlaceArtinMonoidHom_apply_factor_of_extension_eq ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ (v : HeightOneSpectrum (𝓞 K)) ++ (w : AbsoluteValueExtension ++ (HeightOneSpectrum.adicAbv K v) L) ++ (hw : chosenFinitePlaceExtension (L := L) v = w) ++ (x : (v.adicCompletion K)ˣ) : ++ chosenFinitePlaceArtinMonoidHom ++ (K := K) (L := L) v x = ++ finitePlaceLocalToGlobalMonoidHom ++ (K := K) (L := L) v w ++ (finitePlaceLocalArtinMonoidHom ++ (K := K) (L := L) v w x) := by ++ subst w ++ exact ++ congrArg ++ (fun f : (v.adicCompletion K)ˣ →* (L ≃ₐ[K] L) => f x) ++ (finitePlaceArtinMonoidHomOfExtension_factor ++ (K := K) (L := L) v ++ (chosenFinitePlaceExtension (L := L) v)) ++ ++private theorem ++ chosenFinitePlaceArtinMonoidHom_apply_factor_of_extension_eq_at ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ (v : HeightOneSpectrum (𝓞 K)) ++ (w : AbsoluteValueExtension ++ (HeightOneSpectrum.adicAbv K v) L) ++ (hw : chosenFinitePlaceExtension (L := L) v = w) ++ (x : (v.adicCompletion K)ˣ) (z : L) : ++ chosenFinitePlaceArtinMonoidHom ++ (K := K) (L := L) v x z = ++ finitePlaceLocalToGlobalMonoidHom ++ (K := K) (L := L) v w ++ (finitePlaceLocalArtinMonoidHom ++ (K := K) (L := L) v w x) z := by ++ exact ++ congrArg (fun sigma : Gal(L / K) => sigma z) ++ (chosenFinitePlaceArtinMonoidHom_apply_factor_of_extension_eq ++ (K := K) (L := L) v w hw x) ++ ++theorem finitePlaceLocalToGlobalMonoidHom_apply_pow_of_localized_action ++ {K L : Type} ++ [Field K] [NumberField K] ++ [Field L] [Algebra K L] ++ [FiniteDimensional K L] [IsAbelianGalois K L] ++ (v : HeightOneSpectrum (𝓞 K)) ++ (w : AbsoluteValueExtension ++ (HeightOneSpectrum.adicAbv K v) L) ++ (sigma : ++ let vK := HeightOneSpectrum.adicAbv K v ++ let E := LocalizedCompletion vK w ++ letI : Algebra vK.Completion E := ++ finitePlaceLocalArtinLocalizedAlgebra v w ++ Gal(E / vK.Completion)) ++ (z : L) ++ (zLocal : ++ let vK := HeightOneSpectrum.adicAbv K v ++ LocalizedCompletion vK w) ++ (e : ℕ) ++ (hLocalization : ++ let vK := HeightOneSpectrum.adicAbv K v ++ let E := LocalizedCompletion vK w ++ letI : Algebra vK.Completion E := ++ finitePlaceLocalArtinLocalizedAlgebra v w ++ let eLoc : L →+* E := ++ AbsoluteValue.toAlgebraicLocalization vK w.1 w.2 ++ eLoc z = zLocal) ++ (hlocal : sigma zLocal = zLocal ^ e) : ++ finitePlaceLocalToGlobalMonoidHom ++ (K := K) (L := L) v w sigma z = z ^ e := by ++ let vK := HeightOneSpectrum.adicAbv K v ++ let hvK : vK.IsNontrivial := RayClass.adicAbv_isNontrivial v ++ let E := LocalizedCompletion vK w ++ let : Algebra vK.Completion E := ++ finitePlaceLocalArtinLocalizedAlgebra v w ++ let eD : absoluteValueDecompositionGroup K w.1 ≃* Gal(E / vK.Completion) := ++ decompositionGroupEquivAlgebraicLocalizationAut vK hvK w ++ let eLoc : L →+* E := ++ AbsoluteValue.toAlgebraicLocalization vK w.1 w.2 ++ let delta : absoluteValueDecompositionGroup K w.1 := eD.symm sigma ++ have hDecomposition : eD delta = sigma := eD.apply_symm_apply sigma ++ apply eLoc.injective ++ calc ++ eLoc (finitePlaceLocalToGlobalMonoidHom ++ (K := K) (L := L) v w sigma z) = ++ eD delta (eLoc z) := ++ (localizationRamificationGroups_decompositionGroupEquiv_toLocalization ++ vK hvK w delta z).symm ++ _ = sigma (eLoc z) := ++ congrArg (fun tau : Gal(E / vK.Completion) => tau (eLoc z)) ++ hDecomposition ++ _ = sigma zLocal := ++ congrArg (fun y : E => sigma y) hLocalization ++ _ = zLocal ^ e := hlocal ++ _ = (eLoc z) ^ e := ++ congrArg (fun y : E => y ^ e) hLocalization.symm ++ _ = eLoc (z ^ e) := (map_pow eLoc z e).symm ++ ++theorem map_primitiveRoot_eq_pow_of_eq_pow ++ {M : Type} [CommRing M] [IsDomain M] ++ (f : M →* M) (zeta rho : M) (order exponent : ℕ) ++ [NeZero order] ++ (hzeta : IsPrimitiveRoot zeta order) ++ (hrho : IsPrimitiveRoot rho order) ++ (hf : f zeta = zeta ^ exponent) : ++ f rho = rho ^ exponent := by ++ obtain ⟨j, -, hj⟩ := ++ hzeta.eq_pow_of_pow_eq_one hrho.pow_eq_one ++ calc ++ f rho = f (zeta ^ j) := congrArg f hj.symm ++ _ = (f zeta) ^ j := map_pow f zeta j ++ _ = (zeta ^ exponent) ^ j := congrArg (fun z => z ^ j) hf ++ _ = zeta ^ (exponent * j) := (pow_mul zeta exponent j).symm ++ _ = zeta ^ (j * exponent) := ++ congrArg (fun e : ℕ => zeta ^ e) (Nat.mul_comm exponent j) ++ _ = (zeta ^ j) ^ exponent := pow_mul zeta j exponent ++ _ = rho ^ exponent := congrArg (fun z => z ^ exponent) hj ++ ++theorem finitePlaceLocalArtinMonoidHom_apply_semilinear ++ {K L K' L' : Type} ++ [Field K] [NumberField K] ++ [Field L] [Algebra K L] ++ [hKLfinite : FiniteDimensional K L] [IsAbelianGalois K L] ++ [Field K'] [ValuativeRel K'] [TopologicalSpace K'] ++ [IsNonarchimedeanLocalField K'] ++ [Field L'] [Algebra K' L'] ++ [FiniteDimensional K' L'] [IsAbelianGalois K' L'] ++ (v : HeightOneSpectrum (𝓞 K)) ++ (w : AbsoluteValueExtension ++ (HeightOneSpectrum.adicAbv K v) L) ++ (eK : (HeightOneSpectrum.adicAbv K v).Completion ≃+* K') ++ (eL : LocalizedCompletion ++ (HeightOneSpectrum.adicAbv K v) w ≃+* L') ++ (hcomm : ∀ y : (HeightOneSpectrum.adicAbv K v).Completion, ++ eL (@algebraMap ++ (HeightOneSpectrum.adicAbv K v).Completion ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) ++ _ _ (finitePlaceLocalArtinLocalizedAlgebra v w) y) = ++ algebraMap K' L' (eK y)) ++ (hExt : SemilinearValuationCompatible ++ (HeightOneSpectrum.adicAbv K v).Completion K' eK) ++ (x : (v.adicCompletion K)ˣ) ++ (z : LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) : ++ eL (finitePlaceLocalArtinMonoidHom ++ (K := K) (L := L) v w x z) = ++ LocalClassFieldTheory.abelianLocalArtinMonoidHom K' L' ++ (Units.map eK.toMonoidHom ++ (finitePlaceLocalArtinInput v x)) (eL z) := by ++ calc ++ eL (finitePlaceLocalArtinMonoidHom ++ (K := K) (L := L) v w x z) = ++ eL ((@LocalClassFieldTheory.abelianLocalArtinMonoidHom ++ (HeightOneSpectrum.adicAbv K v).Completion ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) ++ (inferInstance : Field ++ (HeightOneSpectrum.adicAbv K v).Completion) ++ (inferInstance : Field ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w)) ++ (finitePlaceLocalArtinLocalizedAlgebra v w) ++ (finitePlaceLocalArtinCompletionValuativeRel v) ++ (inferInstance : TopologicalSpace ++ (HeightOneSpectrum.adicAbv K v).Completion) ++ (finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v) ++ (finitePlaceLocalArtinFiniteDimensional v w) ++ (finitePlaceLocalArtinIsAbelianGalois v w hKLfinite) ++ (finitePlaceLocalArtinInput v x)) z) := ++ congrArg eL ++ (finitePlaceLocalArtinMonoidHom_apply_normalized_at ++ (K := K) (L := L) v w x z) ++ _ = LocalClassFieldTheory.abelianLocalArtinMonoidHom K' L' ++ (Units.map eK.toMonoidHom ++ (finitePlaceLocalArtinInput v x)) (eL z) := ++ @abelianLocalArtinMonoidHom_semilinear_action ++ (HeightOneSpectrum.adicAbv K v).Completion K' ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w) L' ++ (inferInstance : Field ++ (HeightOneSpectrum.adicAbv K v).Completion) ++ (finitePlaceLocalArtinCompletionValuativeRel v) ++ (inferInstance : TopologicalSpace ++ (HeightOneSpectrum.adicAbv K v).Completion) ++ (finitePlaceLocalArtinCompletionIsNonarchimedeanLocalField v) ++ (inferInstance : Field K') ++ (inferInstance : ValuativeRel K') ++ (inferInstance : TopologicalSpace K') ++ (inferInstance : IsNonarchimedeanLocalField K') ++ (inferInstance : Field ++ (LocalizedCompletion (HeightOneSpectrum.adicAbv K v) w)) ++ (inferInstance : Field L') ++ (finitePlaceLocalArtinLocalizedAlgebra v w) ++ (inferInstance : Algebra K' L') ++ (finitePlaceLocalArtinFiniteDimensional v w) ++ (finitePlaceLocalArtinIsAbelianGalois v w hKLfinite) ++ (inferInstance : FiniteDimensional K' L') ++ (inferInstance : IsAbelianGalois K' L') ++ eK eL hcomm hExt (finitePlaceLocalArtinInput v x) z ++ ++ ++end RationalCyclotomicPrincipalPrime ++ ++end Reciprocity ++end GlobalClassFieldTheory +diff --git a/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FiniteResidueFinrankTransfer.lean b/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FiniteResidueFinrankTransfer.lean +index 1ff2c21..3705c23 100644 +--- a/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FiniteResidueFinrankTransfer.lean ++++ b/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FiniteResidueFinrankTransfer.lean +@@ -9,6 +9,7 @@ import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.FiniteResi + import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.ResidueExtension + import ValuedFieldTheory.Valuation.UniqueRing + ++ + set_option autoImplicit false + + namespace LocalClassFieldTheory +@@ -16,15 +17,6 @@ open CyclicCohomology RamificationTheory ClassFormation + + open LocalFieldTheory ValuationTheory + +-/-! +-# Finite local reciprocity: comparison of the two finite residue-field models +- +-The residue-action exact sequence presents the residue field of a +-finite fixed field intrinsically, inside the selected residue algebraic +-closure. The norm formula uses the literal residue field of the spectral +-valuation on that fixed field. This file compares those presentations by +-the uniqueness of the finite extension valuation. +--/ + + noncomputable section + +@@ -53,9 +45,27 @@ noncomputable def valuationSubringEquivDecompositionFieldOfEqTop + let eFZ : F ≃ₐ[F] Z := + (IntermediateField.botEquiv F Omega).symm.trans + (IntermediateField.equivOfEq hZ.symm) +- refine +- { toFun := fun x => ⟨eFZ (x : F), ?_⟩ +- invFun := fun z => ⟨eFZ.symm (z : Z), ?_⟩ ++ exact ++ { toFun := fun x => ⟨eFZ (x : F), by ++ change ((eFZ x : Z) : Omega) ∈ A ++ have he : ((eFZ x : Z) : Omega) = ++ algebraMap F Omega (x : F) := by ++ rfl ++ rw [he] ++ have hx : (x : F) ∈ A.comap (algebraMap F Omega) := by ++ rw [hC] ++ exact x.property ++ exact hx⟩ ++ invFun := fun z => ⟨eFZ.symm (z : Z), by ++ have hz : eFZ.symm (z : Z) ∈ A.comap (algebraMap F Omega) := by ++ change algebraMap F Omega (eFZ.symm (z : Z)) ∈ A ++ have he : algebraMap F Omega (eFZ.symm (z : Z)) = ++ ((z : Z) : Omega) := by ++ exact congrArg Subtype.val (eFZ.apply_symm_apply (z : Z)) ++ rw [he] ++ exact z.property ++ rw [hC] at hz ++ exact hz⟩ + left_inv := fun x => by + apply Subtype.ext + exact eFZ.symm_apply_apply (x : F) +@@ -68,24 +78,6 @@ noncomputable def valuationSubringEquivDecompositionFieldOfEqTop + map_mul' := fun x y => by + apply Subtype.ext + exact map_mul eFZ (x : F) (y : F) } +- · change ((eFZ x : Z) : Omega) ∈ A +- have he : ((eFZ x : Z) : Omega) = +- algebraMap F Omega (x : F) := by +- rfl +- rw [he] +- have hx : (x : F) ∈ A.comap (algebraMap F Omega) := by +- rw [hC] +- exact x.property +- exact hx +- · have hz : eFZ.symm (z : Z) ∈ A.comap (algebraMap F Omega) := by +- change algebraMap F Omega (eFZ.symm (z : Z)) ∈ A +- have he : algebraMap F Omega (eFZ.symm (z : Z)) = +- ((z : Z) : Omega) := by +- exact congrArg Subtype.val (eFZ.apply_symm_apply (z : Z)) +- rw [he] +- exact z.property +- rw [hC] at hz +- exact hz + + /-- The corresponding equivalence between literal and intrinsic residue + fields. -/ +diff --git a/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FixedFieldNormResidueNaturality.lean b/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FixedFieldNormResidueNaturality.lean +index 08eb9ea..dd20dc0 100644 +--- a/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FixedFieldNormResidueNaturality.lean ++++ b/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/FixedFieldNormResidueNaturality.lean +@@ -10,15 +10,9 @@ import ClassFieldTheory.LocalClassFieldTheory.Finite.LocalReciprocity.LocalHense + import ClassFieldTheory.AbstractClassFieldTheory.Reciprocity.Main + import Mathlib.FieldTheory.Galois.Notation + +-set_option autoImplicit false + +-/-! +-# Naturality of fixed-field norm-residue symbols ++set_option autoImplicit false + +-This file transports norm-restriction and transfer-inclusion naturality +-from the closed-subgroup class formation to actual fixed fields in a single +-Galois ambient field. +--/ + + noncomputable section + +@@ -521,7 +515,12 @@ theorem upperAbsoluteFinite + /-- The fixed-field norm-residue symbol for the lower horizontal extension, + induced by the canonical local class formation. -/ + noncomputable def lowerNormResidueSymbol +- (T : LocalFixedFieldNormRestrictionSquare k) := by ++ (T : LocalFixedFieldNormRestrictionSquare k) : ++ Additive (abstractFixedField k (SeparableClosure k) T.lowerBase)ˣ →+ ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ T.lowerTop_le_lowerBase / ++ abstractFixedField k (SeparableClosure k) T.lowerBase)) := by + letI := T.lowerNormal + letI := T.lowerFinite + letI := T.lowerAbsoluteFinite +@@ -534,7 +533,12 @@ noncomputable def lowerNormResidueSymbol + /-- The fixed-field norm-residue symbol for the upper horizontal extension, + induced by the canonical local class formation. -/ + noncomputable def upperNormResidueSymbol +- (T : LocalFixedFieldNormRestrictionSquare k) := by ++ (T : LocalFixedFieldNormRestrictionSquare k) : ++ Additive (abstractFixedField k (SeparableClosure k) T.upperBase)ˣ →+ ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ T.upperTop_le_upperBase / ++ abstractFixedField k (SeparableClosure k) T.upperBase)) := by + letI := T.upperNormal + letI := T.upperFinite + letI := upperAbsoluteFinite T +@@ -552,7 +556,15 @@ noncomputable def normUnits + + /-- Restriction between the abelianized actual relative Galois groups. -/ + noncomputable def abelianizedRestriction +- (T : LocalFixedFieldNormRestrictionSquare k) := by ++ (T : LocalFixedFieldNormRestrictionSquare k) : ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ T.upperTop_le_upperBase / ++ abstractFixedField k (SeparableClosure k) T.upperBase)) →+ ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ T.lowerTop_le_lowerBase / ++ abstractFixedField k (SeparableClosure k) T.lowerBase)) := by + letI := T.lowerNormal + letI := T.upperNormal + exact +@@ -681,7 +693,12 @@ theorem intermediateAbsoluteFinite + /-- The fixed-field norm-residue symbol for the total extension, induced by + the canonical local class formation. -/ + noncomputable def baseNormResidueSymbol +- (T : LocalFixedFieldTransferTower k) := by ++ (T : LocalFixedFieldTransferTower k) : ++ Additive (abstractFixedField k (SeparableClosure k) T.base)ˣ →+ ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ (T.top_le_intermediate.trans T.intermediate_le_base) / ++ abstractFixedField k (SeparableClosure k) T.base)) := by + letI := T.totalNormal + letI := T.totalFinite + letI := T.baseAbsoluteFinite +@@ -695,7 +712,12 @@ noncomputable def baseNormResidueSymbol + /-- The fixed-field norm-residue symbol after changing the base to the + intermediate fixed field, induced by the canonical local class formation. -/ + noncomputable def intermediateNormResidueSymbol +- (T : LocalFixedFieldTransferTower k) := by ++ (T : LocalFixedFieldTransferTower k) : ++ Additive (abstractFixedField k (SeparableClosure k) T.intermediate)ˣ →+ ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ T.top_le_intermediate / ++ abstractFixedField k (SeparableClosure k) T.intermediate)) := by + letI := intermediateNormal T + letI := intermediateFinite T + letI := intermediateAbsoluteFinite T +@@ -713,7 +735,15 @@ noncomputable def unitsInclusion + + /-- Transfer between the abelianized actual relative Galois groups. -/ + noncomputable def abelianizedTransfer +- (T : LocalFixedFieldTransferTower k) := by ++ (T : LocalFixedFieldTransferTower k) : ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ (T.top_le_intermediate.trans T.intermediate_le_base) / ++ abstractFixedField k (SeparableClosure k) T.base)) →+ ++ Additive (Abelianization ++ Gal(abstractRelativeFixedField k (SeparableClosure k) ++ T.top_le_intermediate / ++ abstractFixedField k (SeparableClosure k) T.intermediate)) := by + letI := T.totalNormal + letI := T.totalFinite + exact +diff --git a/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/LocalResidueDatum.lean b/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/LocalResidueDatum.lean +index bc7a1de..9da0120 100644 +--- a/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/LocalResidueDatum.lean ++++ b/Lean4/ClassFieldTheory/LocalClassFieldTheory/Finite/LocalReciprocity/LocalResidueDatum.lean +@@ -9,6 +9,7 @@ import ValuedFieldTheory.Valuation.DiscreteValuationField.FiniteIntegralClosure + import ValuedFieldTheory.Ramification.GaloisValuation.AbsoluteGalois.FiniteExtensionCorrespondence + import ValuedFieldTheory.LocalField.NonarchimedeanLocalField.FiniteExtensionCompleteDVF + ++ + set_option autoImplicit false + + namespace LocalClassFieldTheory +@@ -17,24 +18,6 @@ open ClassFormation + + open ValuationTheory RamificationTheory LocalFieldTheory + +-/-! +-# Finite local reciprocity: the local residue degree datum +- +-For a nonarchimedean local field `K`, this file makes the choices implicit in +-the construction explicit. The canonical local valuation is packaged as a complete +-DVF, Chevalley's theorem chooses an extension to `AlgebraicClosure K`, and +-that valuation is pulled back to `SeparableClosure K`. Finite-separable +-uniqueness shows that its decomposition subgroup is the whole Galois group. +-The residue field of the decomposition field is then identified with the +-finite residue field of `K`. +- +-The remaining step is topological: the reduction action is shown continuous +-for the two Krull topologies and is composed with the intrinsic finite-field +-degree map from `ResidueAlgebraicClosureDegree`. The selected residue field +-is algebraically closed because its extension to the residue of +-`AlgebraicClosure K` is purely inseparable and the selected residue field is +-perfect over the finite base residue field. +--/ + + noncomputable section + +@@ -187,9 +170,23 @@ private noncomputable def localBaseValuationSubringEquivDecompositionField : + let eKZ : K ≃ₐ[K] Z := + (IntermediateField.botEquiv K (SeparableClosure K)).symm.trans + (IntermediateField.equivOfEq hZ.symm) +- refine +- { toFun := fun x => ⟨eKZ (x : K), ?_⟩ +- invFun := fun z => ⟨eKZ.symm (z : Z), ?_⟩ ++ exact ++ { toFun := fun x => ⟨eKZ (x : K), by ++ change ((eKZ x : Z) : SeparableClosure K) ∈ A ++ have he : ((eKZ x : Z) : SeparableClosure K) = ++ algebraMap K (SeparableClosure K) (x : K) := by ++ rfl ++ rw [he] ++ exact (localSeparableValuationSubring_pullback K (x : K)).2 x.property⟩ ++ invFun := fun z => ⟨eKZ.symm (z : Z), by ++ change eKZ.symm (z : Z) ∈ ++ (localCompleteDVF K).valuation.valuationSubring ++ apply (localSeparableValuationSubring_pullback K (eKZ.symm (z : Z))).1 ++ have he : algebraMap K (SeparableClosure K) (eKZ.symm (z : Z)) = ++ ((z : Z) : SeparableClosure K) := by ++ exact congrArg Subtype.val (eKZ.apply_symm_apply (z : Z)) ++ rw [he] ++ exact z.property⟩ + left_inv := fun x => by + apply Subtype.ext + exact eKZ.symm_apply_apply (x : K) +@@ -202,20 +199,6 @@ private noncomputable def localBaseValuationSubringEquivDecompositionField : + map_mul' := fun x y => by + apply Subtype.ext + exact map_mul eKZ (x : K) (y : K) } +- · change ((eKZ x : Z) : SeparableClosure K) ∈ A +- have he : ((eKZ x : Z) : SeparableClosure K) = +- algebraMap K (SeparableClosure K) (x : K) := by +- rfl +- rw [he] +- exact (localSeparableValuationSubring_pullback K (x : K)).2 x.property +- · change eKZ.symm (z : Z) ∈ +- (localCompleteDVF K).valuation.valuationSubring +- apply (localSeparableValuationSubring_pullback K (eKZ.symm (z : Z))).1 +- have he : algebraMap K (SeparableClosure K) (eKZ.symm (z : Z)) = +- ((z : Z) : SeparableClosure K) := by +- exact congrArg Subtype.val (eKZ.apply_symm_apply (z : Z)) +- rw [he] +- exact z.property + + /-- The residue field in the residue-action exact sequence is canonically the finite residue + field of the original local field. -/ +diff --git a/Lean4/ClassFieldTheory/LubinTate/Padic/CompletedChangedUniformizerFixedField.lean b/Lean4/ClassFieldTheory/LubinTate/Padic/CompletedChangedUniformizerFixedField.lean +index c747c98..aa28793 100644 +--- a/Lean4/ClassFieldTheory/LubinTate/Padic/CompletedChangedUniformizerFixedField.lean ++++ b/Lean4/ClassFieldTheory/LubinTate/Padic/CompletedChangedUniformizerFixedField.lean +@@ -9,6 +9,7 @@ import ClassFieldTheory.LubinTate.Padic.CompletedChangedUniformizerPrimitive + import ClassFieldTheory.LubinTate.Padic.CompletedChangedUniformizerThetaFixed + import ClassFieldTheory.LubinTate.Padic.CompletedUnramifiedFrobeniusFixed + ++ + set_option autoImplicit false + + /-! +@@ -42,7 +43,8 @@ noncomputable def padicCompletedChangedUniformizerFrobeniusAlgEquiv + (u : (padicLocalField p).valuationSubringˣ) (n : ℕ) : + padicCompletedLevelField p n ≃ₐ[ℚ_[p]] + padicCompletedLevelField p n := +- AlgEquiv.ofRingEquiv (by ++ AlgEquiv.ofRingEquiv ++ (f := padicCompletedUnitFrobeniusLiftEquiv p n u⁻¹) (by + intro b + change + padicCompletedUnitFrobeniusLiftEquiv p n u⁻¹ +diff --git a/Lean4/GaloisCohomology/Cyclic/Herbrand/HerbrandLowDegree/Basic.lean b/Lean4/GaloisCohomology/Cyclic/Herbrand/HerbrandLowDegree/Basic.lean +index ea6356d..eb19ced 100644 +--- a/Lean4/GaloisCohomology/Cyclic/Herbrand/HerbrandLowDegree/Basic.lean ++++ b/Lean4/GaloisCohomology/Cyclic/Herbrand/HerbrandLowDegree/Basic.lean +@@ -14,6 +14,7 @@ import Mathlib.GroupTheory.OrderOfElement + import Mathlib.GroupTheory.QuotientGroup.Basic + import Mathlib.GroupTheory.SpecificGroups.Cyclic + ++ + set_option autoImplicit false + + namespace CyclicCohomology +@@ -34,8 +35,7 @@ namespace Herbrand + + universe uG uA uB uC + +-/-- Herbrand-quotient theory: the finite-group norm `N_G a = ∏ g, g • a` +-for a multiplicative `G`-module. -/ ++ + def tateNorm (G : Type uG) (A : Type uA) [Group G] [Fintype G] [CommGroup A] + [MulDistribMulAction G A] (a : A) : A := + ∏ g : G, g • a +@@ -92,9 +92,8 @@ theorem fixed_of_forall_mem_zpowers_of_sigmaMinusOne_eq_one + omit [Group G] [Fintype G] [CommGroup A] [CommGroup B] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- First-isomorphism cardinality source for finite exactness calculations: +-the cardinality of the source of a group homomorphism is the product of the +-cardinalities of its kernel and range. -/ ++ ++ + theorem monoidHom_card_eq_card_ker_mul_card_range + {X : Type uA} {Y : Type uB} [Group X] [Group Y] [Finite X] (f : X →* Y) : + Nat.card X = Nat.card (MonoidHom.ker f) * Nat.card (MonoidHom.range f) := by +@@ -128,9 +127,8 @@ theorem card_subgroupOf_eq_card + omit [Fintype G] [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- The multiplicative induced module from the trivial subgroup, represented +-as functions on `G` with the right-regular action. This is the concrete model +-used in the low-degree Herbrand comparison. -/ ++ ++ + @[reducible] def rightRegularFunctionMulDistribMulAction : + MulDistribMulAction G (G → B) where + smul g f := fun x => f (x * g) +@@ -255,7 +253,7 @@ def tateNormSubgroup (G : Type uG) (A : Type uA) [Group G] [Fintype G] [CommGrou + [MulDistribMulAction G A] : Subgroup A := + MonoidHom.range (tateNormHom (G := G) (A := A)) + +-/-- Herbrand-quotient theory: the norm kernel `{a | N_G a = 1}`. -/ ++ + def normKernelSubgroup (G : Type uG) (A : Type uA) [Group G] [Fintype G] [CommGroup A] + [MulDistribMulAction G A] : Subgroup A := + MonoidHom.ker (tateNormHom (G := G) (A := A)) +@@ -267,7 +265,7 @@ def augmentationSubgroup (G : Type uG) (A : Type uA) [Group G] [CommGroup A] + + omit [Fintype G] [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- If `σ` generates `G`, the kernel of `a ↦ a^(σ-1)` is the fixed subgroup. -/ ++ + theorem sigmaMinusOneHom_ker_eq_fixedSubgroup + (σ : G) (hgen : ∀ g : G, g ∈ Subgroup.zpowers σ) : + MonoidHom.ker (sigmaMinusOneHom (G := G) (A := A) σ) = fixedSubgroup G A := by +@@ -282,8 +280,8 @@ theorem sigmaMinusOneHom_ker_eq_fixedSubgroup + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- Finite-module source: the norm homomorphism factors the cardinality of +-`A` into norm-kernel and norm-image cardinalities. -/ ++ ++ + theorem card_eq_card_normKernelSubgroup_mul_card_tateNormSubgroup [Finite A] : + Nat.card A = Nat.card (normKernelSubgroup G A) * Nat.card (tateNormSubgroup G A) := by + simpa [normKernelSubgroup, tateNormSubgroup] using +@@ -291,9 +289,8 @@ theorem card_eq_card_normKernelSubgroup_mul_card_tateNormSubgroup [Finite A] : + + omit [Fintype G] [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- Finite-module source: for a cyclic generator `σ`, the coboundary +-homomorphism factors the cardinality of `A` into fixed and augmentation +-cardinalities. -/ ++ ++ + theorem card_eq_card_fixedSubgroup_mul_card_augmentationSubgroup + (σ : G) (hgen : ∀ g : G, g ∈ Subgroup.zpowers σ) [Finite A] : + Nat.card A = Nat.card (fixedSubgroup G A) * Nat.card (augmentationSubgroup G A σ) := by +@@ -304,8 +301,8 @@ theorem card_eq_card_fixedSubgroup_mul_card_augmentationSubgroup + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- Finite-module cardinality balance behind `h(G,A)=1`: for a finite cyclic +-group action, the product `#A^G · #I_G A` equals `#ker N_G · #N_G A`. -/ ++ ++ + theorem herbrand_finite_module_cardinality_balance + (σ : G) (hgen : ∀ g : G, g ∈ Subgroup.zpowers σ) [Finite A] : + Nat.card (fixedSubgroup G A) * Nat.card (augmentationSubgroup G A σ) = +@@ -380,7 +377,7 @@ def HerbrandH0.mk : fixedSubgroup G A →* HerbrandH0 G A := by + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- Canonical projection from the norm kernel to `H⁻¹(G,A)`. -/ ++ + def HerbrandHMinusOne.mk (σ : G) : + normKernelSubgroup G A →* HerbrandHMinusOne G A σ := by + unfold HerbrandHMinusOne +@@ -422,7 +419,7 @@ theorem HerbrandH0.mk_surjective : + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- Every degree-minus-one Herbrand class has a norm-kernel representative. -/ ++ + theorem HerbrandHMinusOne.mk_surjective (σ : G) : + Function.Surjective (HerbrandHMinusOne.mk (G := G) (A := A) σ) := by + intro q +@@ -458,8 +455,8 @@ theorem HerbrandH0.mk_eq_one_iff (a : fixedSubgroup G A) : + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- A norm-kernel representative gives the trivial degree-minus-one class +-exactly when it is an augmentation. -/ ++ ++ + @[simp] + theorem HerbrandHMinusOne.mk_eq_one_iff (σ : G) + (a : normKernelSubgroup G A) : +@@ -573,8 +570,8 @@ protected theorem HerbrandH0.inductionOn + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- Eliminate a degree-minus-one Herbrand class through an arbitrary +-norm-kernel representative and the canonical class map. -/ ++ ++ + protected theorem HerbrandHMinusOne.inductionOn (σ : G) + {motive : HerbrandHMinusOne G A σ → Prop} + (q : HerbrandHMinusOne G A σ) +@@ -649,7 +646,7 @@ def HerbrandH0.lift {M : Type*} [Group M] + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- Descend a homomorphism on the norm kernel through `H⁻¹(G,A)`. -/ ++ + def HerbrandHMinusOne.lift {M : Type*} [Group M] (σ : G) + (f : normKernelSubgroup G A →* M) + (h : (augmentationSubgroup G A σ).subgroupOf (normKernelSubgroup G A) ≤ +@@ -703,7 +700,7 @@ noncomputable instance herbrandHMinusOneFiniteOfFinite (σ : G) [Finite A] : + omit [Fintype G] [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- Fixed subgroup of the right-regular multiplicative induced module. -/ ++ + abbrev rightRegularFunctionFixedSubgroup : Subgroup (G → B) := by + letI := rightRegularFunctionMulDistribMulAction (G := G) (B := B) + exact fixedSubgroup G (G → B) +@@ -711,7 +708,7 @@ abbrev rightRegularFunctionFixedSubgroup : Subgroup (G → B) := by + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- Norm image subgroup of the right-regular multiplicative induced module. -/ ++ + abbrev rightRegularFunctionTateNormSubgroup : Subgroup (G → B) := by + letI := rightRegularFunctionMulDistribMulAction (G := G) (B := B) + exact tateNormSubgroup G (G → B) +@@ -719,8 +716,8 @@ abbrev rightRegularFunctionTateNormSubgroup : Subgroup (G → B) := by + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- `H⁰` of the right-regular multiplicative induced module. -/ +-def rightRegularFunctionHerbrandH0 := by ++ ++def rightRegularFunctionHerbrandH0 : Type (max uG uB) := by + letI := rightRegularFunctionMulDistribMulAction (G := G) (B := B) + exact HerbrandH0 G (G → B) + +@@ -737,7 +734,7 @@ noncomputable instance rightRegularFunctionHerbrandH0CommGroup : + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- Norm-kernel subgroup of the right-regular multiplicative induced module. -/ ++ + abbrev rightRegularFunctionNormKernelSubgroup : Subgroup (G → B) := by + letI := rightRegularFunctionMulDistribMulAction (G := G) (B := B) + exact normKernelSubgroup G (G → B) +@@ -745,7 +742,7 @@ abbrev rightRegularFunctionNormKernelSubgroup : Subgroup (G → B) := by + omit [Fintype G] [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- Augmentation subgroup of the right-regular multiplicative induced module. -/ ++ + abbrev rightRegularFunctionAugmentationSubgroup (σ : G) : Subgroup (G → B) := by + letI := rightRegularFunctionMulDistribMulAction (G := G) (B := B) + exact augmentationSubgroup G (G → B) σ +@@ -753,8 +750,8 @@ abbrev rightRegularFunctionAugmentationSubgroup (σ : G) : Subgroup (G → B) := + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- `H^{-1}` of the right-regular multiplicative induced module. -/ +-def rightRegularFunctionHerbrandHMinusOne (σ : G) := by ++ ++def rightRegularFunctionHerbrandHMinusOne (σ : G) : Type (max uG uB) := by + letI := rightRegularFunctionMulDistribMulAction (G := G) (B := B) + exact HerbrandHMinusOne G (G → B) σ + +@@ -791,7 +788,7 @@ theorem tateNorm_sigmaMinusOne_eq_one (σ : G) (a : A) : + _ = 1 := by + rw [hshift, Finset.prod_inv_distrib, mul_inv_cancel] + +-/-- The augmentation image lies in the norm kernel. -/ ++ + theorem augmentationSubgroup_le_normKernelSubgroup (σ : G) : + augmentationSubgroup G A σ ≤ normKernelSubgroup G A := by + intro a ha +@@ -858,9 +855,8 @@ theorem herbrandH0_subsingleton_iff_fixed_le_tateNormSubgroup : + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- A quotient-level criterion for vanishing of `H^{-1}`: if every norm-kernel +-element is an augmentation element, then the low-degree Herbrand `H^{-1}` +-quotient is a subsingleton. -/ ++ ++ + theorem herbrandHMinusOne_subsingleton_of_normKernel_le_augmentationSubgroup + (σ : G) (h : normKernelSubgroup G A ≤ augmentationSubgroup G A σ) : + Subsingleton (HerbrandHMinusOne G A σ) := by +@@ -879,8 +875,7 @@ theorem herbrandHMinusOne_subsingleton_of_normKernel_le_augmentationSubgroup + exact h a.2 + rw [hq, hr] + +-/-- Degree-minus-one Herbrand cohomology is trivial exactly when every +-norm-kernel element is an augmentation element. -/ ++ + theorem herbrandHMinusOne_subsingleton_iff_normKernel_le_augmentationSubgroup + (σ : G) : + Subsingleton (HerbrandHMinusOne G A σ) ↔ +@@ -986,8 +981,8 @@ theorem herbrandHMinusOne_subsingleton_of_mulEquiv + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- Membership in the right-regular norm kernel is the single product +-condition `∏ g, f g = 1`. -/ ++ ++ + theorem rightRegularFunction_mem_normKernelSubgroup_iff (f : G → B) : + f ∈ rightRegularFunctionNormKernelSubgroup (G := G) (B := B) ↔ + (∏ g : G, f g) = 1 := by +@@ -1031,9 +1026,8 @@ theorem rightRegularFunction_mem_normKernelSubgroup_iff (f : G → B) : + omit [Fintype G] [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- The partial primitive along the cyclic powers of `σ`. This is the +-candidate used to solve `b (x * σ) * (b x)⁻¹ = f x` on the right-regular +-induced module. -/ ++ ++ + def rightRegularCyclicPartialProduct (σ : G) (f : G → B) (i : ℕ) : B := + (Finset.range i).prod (fun k => f (σ ^ k)) + +@@ -1266,8 +1260,8 @@ theorem rightRegularCyclicPrimitive_mul_sigma_mul_inv_of_partialProduct_eq_one + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- A right-regular norm-kernel element has product `1` along one full cyclic +-enumeration by a generator. -/ ++ ++ + theorem rightRegularFunction_prod_powers_eq_one_of_mem_normKernel + (σ : G) (hgen : ∀ g : G, g ∈ Subgroup.zpowers σ) + {f : G → B} +@@ -1325,8 +1319,8 @@ theorem rightRegularFunction_mem_augmentationSubgroup_iff + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- Concrete `H^{-1}` source for the right-regular multiplicative induced +-module: every norm-kernel element is an augmentation element. -/ ++ ++ + theorem rightRegularFunction_normKernel_le_augmentationSubgroup + (σ : G) (hgen : ∀ g : G, g ∈ Subgroup.zpowers σ) : + rightRegularFunctionNormKernelSubgroup (G := G) (B := B) ≤ +@@ -1348,8 +1342,8 @@ theorem rightRegularFunction_normKernel_le_augmentationSubgroup + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- The `H^{-1}` quotient of the right-regular multiplicative induced module +-is trivial for a cyclic group generated by `σ`. -/ ++ ++ + theorem rightRegularFunction_herbrandHMinusOne_subsingleton + (σ : G) (hgen : ∀ g : G, g ∈ Subgroup.zpowers σ) : + Subsingleton (rightRegularFunctionHerbrandHMinusOne (G := G) (B := B) σ) := by +@@ -1362,8 +1356,8 @@ theorem rightRegularFunction_herbrandHMinusOne_subsingleton + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- Concrete `H⁰` source for induced modules: for the right-regular +-multiplicative induced module `G → B`, every fixed point is a norm. -/ ++ ++ + theorem rightRegularFunction_fixed_le_tateNormSubgroup : + rightRegularFunctionFixedSubgroup (G := G) (B := B) ≤ + rightRegularFunctionTateNormSubgroup (G := G) (B := B) := by +@@ -1420,8 +1414,8 @@ theorem rightRegularFunction_fixed_le_tateNormSubgroup : + omit [CommGroup A] [CommGroup C] + [MulDistribMulAction G A] [MulDistribMulAction G B] + [MulDistribMulAction G C] in +-/-- The `H⁰` quotient of the right-regular multiplicative induced module is +-trivial. This is the degree-zero half of the low-degree Herbrand comparison. -/ ++ ++ + theorem rightRegularFunction_herbrandH0_subsingleton : + Subsingleton (rightRegularFunctionHerbrandH0 (G := G) (B := B)) := by + let := rightRegularFunctionMulDistribMulAction (G := G) (B := B) +@@ -1677,8 +1671,8 @@ theorem card_normKernelSubgroup_eq_card_herbrandHMinusOne_mul_card_augmentationS + + omit [CommGroup B] [CommGroup C] + [MulDistribMulAction G B] [MulDistribMulAction G C] in +-/-- The two low-degree Herbrand quotients of a finite cyclic module have equal +-cardinality, the finite-module source for Herbrand-quotient multiplicativity. -/ ++ ++ + theorem herbrand_finite_module_card_eq + (σ : G) (hgen : ∀ g : G, g ∈ Subgroup.zpowers σ) [Finite A] : + Nat.card (HerbrandH0 G A) = Nat.card (HerbrandHMinusOne G A σ) := by +diff --git a/Lean4/ValuedFieldTheory/LocalField/Padic/UnitDecomposition.lean b/Lean4/ValuedFieldTheory/LocalField/Padic/UnitDecomposition.lean +index c3ea784..4f582bb 100644 +--- a/Lean4/ValuedFieldTheory/LocalField/Padic/UnitDecomposition.lean ++++ b/Lean4/ValuedFieldTheory/LocalField/Padic/UnitDecomposition.lean +@@ -12,14 +12,9 @@ import Mathlib.NumberTheory.Padics.ValuativeRel + import Mathlib.NumberTheory.Padics.ProperSpace + import Mathlib.GroupTheory.Torsion + +-set_option autoImplicit false + +-/-! +-# Unit decomposition of the p-adic integers ++set_option autoImplicit false + +-This file constructs the reusable topological decomposition of +-`ℤ_[p]ˣ` into its finite factor and its principal `p`-adic factor. +--/ + + open scoped Topology + +@@ -457,7 +452,7 @@ noncomputable def padicPrincipalData + rfl + have htop : directTopology = standardTopology := + hdirect.trans (padicPrincipalUnitDirectTopology_eq_standard p) +- let P := fun T : TopologicalSpace U => by ++ let P : TopologicalSpace U → Type := fun T => by + letI : TopologicalSpace U := T + exact Σ a : ℕ, + Multiplicative +diff --git a/lakefile.toml b/lakefile.toml +index ed5e179..5e8b720 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -10,8 +10,8 @@ relaxedAutoImplicit = false + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "5ed2965256430c3649e86755f9576b54eca72435" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "ClassFieldTheory.All" +diff --git a/lean-toolchain b/lean-toolchain +index 12359f9..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.34.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/PrimeNumberTheoremAnd-lean4341.patch b/lean/patches/PrimeNumberTheoremAnd-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..1e097c43b744be853859a0ba2aa2b5c533769c3e --- /dev/null +++ b/lean/patches/PrimeNumberTheoremAnd-lean4341.patch @@ -0,0 +1,39904 @@ +diff --git a/PrimeNumberTheoremAnd/Catalan.lean b/PrimeNumberTheoremAnd/Catalan.lean +new file mode 100644 +index 0000000..0c4ccd6 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan.lean +@@ -0,0 +1 @@ ++import PrimeNumberTheoremAnd.Catalan.Consequences +diff --git a/PrimeNumberTheoremAnd/Catalan/Consequences.lean b/PrimeNumberTheoremAnd/Catalan/Consequences.lean +new file mode 100644 +index 0000000..470ade9 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan/Consequences.lean +@@ -0,0 +1,68 @@ ++import Mathlib.Analysis.Asymptotics.SpecificAsymptotics ++import Mathlib.Analysis.SpecialFunctions.Log.Basic ++import PrimeNumberTheoremAnd.Catalan.Wiener ++ ++namespace CatalanPNT ++ ++open ZetaFivePNT ++ ++open ArithmeticFunction hiding log ++open Nat hiding log ++open _root_.Finset ++open BigOperators _root_.Filter _root_.Real _root_.Asymptotics ++open scoped Chebyshev ++ ++theorem WeakPNT' : Tendsto (fun N ↦ (∑ n ∈ Iic N, Λ n) / N) atTop (nhds 1) := by ++ have : (fun N ↦ (∑ n ∈ Iic N, Λ n) / N) = ++ (fun N ↦ (∑ n ∈ range N, Λ n)/N + Λ N / N) := by ++ ext N ++ have : N ∈ Iic N := mem_Iic.mpr (le_refl _) ++ rw [← Finset.sum_erase_add _ _ this, ← Nat.Iio_eq_range, Iic_erase] ++ exact add_div _ _ _ ++ rw [this, ← add_zero 1] ++ apply Tendsto.add WeakPNT ++ convert squeeze_zero (f := fun N ↦ Λ N / N) (g := fun N ↦ log N / N) (t₀ := atTop) ?_ ?_ ?_ ++ · intro N ++ exact div_nonneg vonMangoldt_nonneg (cast_nonneg N) ++ · intro N ++ exact div_le_div_of_nonneg_right vonMangoldt_le_log (cast_nonneg N) ++ simpa only [Function.comp_def, pow_one, one_mul, add_zero] using ++ (Real.tendsto_pow_log_div_mul_add_atTop 1 0 1 one_ne_zero).comp ++ tendsto_natCast_atTop_atTop ++ ++theorem WeakPNT'' : ψ ~[atTop] (fun x ↦ x) := by ++ rw [(by rfl : ψ = (fun x ↦ ψ x))] ++ simp_rw [Chebyshev.psi_eq_sum_Icc] ++ apply IsEquivalent.trans (v := fun x ↦ (⌊x⌋₊:ℝ)) ++ · rw [isEquivalent_iff_tendsto_one] ++ · convert Tendsto.comp WeakPNT' (tendsto_nat_floor_atTop (α := ℝ)) using 1 ++ ext x ++ rfl ++ rw [eventually_iff] ++ simp only [ne_eq, cast_eq_zero, floor_eq_zero, not_lt, mem_atTop_sets, ++ Set.mem_ofPred_eq] ++ use 1 ++ simp only [imp_self, implies_true] ++ exact Asymptotics.isEquivalent_nat_floor ++ ++theorem isLittleO_sqrt_mul_log : (fun x : ℝ ↦ x.sqrt * x.log) =o[atTop] _root_.id := by ++ have : (fun x : ℝ ↦ x.sqrt * x.log) =o[atTop] fun x ↦ x := by ++ refine (isLittleO_mul_iff_isLittleO_div ?_).mpr ?_ ++ · filter_upwards [eventually_gt_atTop 0] with x hx; exact (sqrt_ne_zero hx.le).mpr hx.ne' ++ · convert isLittleO_log_rpow_atTop (by norm_num : (0 : ℝ) < 1 / 2) using 2 with x ++ rw [div_sqrt, sqrt_eq_rpow] ++ exact this ++ ++theorem chebyshev_asymptotic : θ ~[atTop] id := by ++ rw [← sub_sub_self ψ θ] ++ refine WeakPNT''.sub_isLittleO ++ (IsBigO.trans_isLittleO (g := fun x ↦ 2 * x.sqrt * x.log) ?_ ?_) ++ · rw [isBigO_iff']; refine ⟨1, one_pos, ?_⟩ ++ simp only [one_mul, eventually_atTop] ++ exact ⟨2, fun x hx ↦ by ++ rw [Pi.sub_apply, norm_eq_abs, norm_eq_abs, abs_of_nonneg (by bound : 0 ≤ 2 * √x * log x)] ++ exact (abs_of_nonneg (sub_nonneg.mpr (Chebyshev.theta_le_psi x))).symm ▸ ++ Chebyshev.abs_psi_sub_theta_le_sqrt_mul_log (by linarith : 1 ≤ x)⟩ ++ · convert isLittleO_sqrt_mul_log.const_mul_left 2 using 1 <;> first | rfl | (funext x; ring) ++ ++end CatalanPNT +diff --git a/PrimeNumberTheoremAnd/Catalan/OrdinaryZetaContinuation.lean b/PrimeNumberTheoremAnd/Catalan/OrdinaryZetaContinuation.lean +new file mode 100644 +index 0000000..723a0e3 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan/OrdinaryZetaContinuation.lean +@@ -0,0 +1,92 @@ ++import PrimeNumberTheoremAnd.Catalan.OrdinaryZetaZeroFree ++import Mathlib.Analysis.Complex.RemovableSingularity ++ ++namespace CatalanPNT ++ ++noncomputable section ++ ++open Complex Filter Set ++open scoped Topology ++ ++namespace CatalanOrdinaryZeta ++ ++noncomputable def regularizedZeta : ℂ → ℂ := ++ Function.update (fun s ↦ (s - 1) * riemannZeta s) 1 1 ++ ++@[simp] theorem regularizedZeta_one : regularizedZeta 1 = 1 := by ++ simp only [regularizedZeta, Function.update_self] ++ ++theorem regularizedZeta_of_ne_one {s : ℂ} (hs : s ≠ 1) : ++ regularizedZeta s = (s - 1) * riemannZeta s := by ++ exact Function.update_of_ne hs .. ++ ++theorem regularizedZeta_ne_zero_at_one : regularizedZeta 1 ≠ 0 := by ++ rw [regularizedZeta_one] ++ exact one_ne_zero ++ ++theorem differentiable_regularizedZeta : Differentiable ℂ regularizedZeta := by ++ rw [← differentiableOn_univ, ++ ← differentiableOn_compl_singleton_and_continuousAt_iff (c := 1) Filter.univ_mem] ++ constructor ++ · refine DifferentiableOn.congr (f := fun s ↦ (s - 1) * riemannZeta s) ?_ ?_ ++ · intro s hs ++ exact ((differentiableAt_id.sub_const 1).mul ++ (differentiableAt_riemannZeta (Set.mem_sdiff_singleton.mp hs).2)).differentiableWithinAt ++ · intro s hs ++ exact regularizedZeta_of_ne_one (Set.mem_sdiff_singleton.mp hs).2 ++ · simpa only [regularizedZeta, continuousAt_update_same] using riemannZeta_residue_one ++ ++theorem deriv_regularizedZeta_of_ne_one {s : ℂ} (hs : s ≠ 1) : ++ deriv regularizedZeta s = ++ (s - 1) * deriv riemannZeta s + riemannZeta s := by ++ have hderiv : deriv regularizedZeta s = ++ deriv (fun w ↦ (w - 1) * riemannZeta w) s := by ++ refine eventuallyEq_iff_exists_mem.mpr ?_ |>.deriv_eq ++ exact ⟨_, isOpen_ne.mem_nhds hs, ++ fun _ hw ↦ regularizedZeta_of_ne_one (Set.mem_ofPred.mp hw)⟩ ++ rw [hderiv, deriv_fun_mul (by fun_prop) (differentiableAt_riemannZeta hs), ++ deriv_sub_const, deriv_id'', one_mul, add_comm] ++ ++theorem regularizedZeta_ne_zero_of_one_le_re {s : ℂ} (hs : 1 ≤ s.re) : ++ regularizedZeta s ≠ 0 := by ++ rcases eq_or_ne s 1 with rfl | hs₁ ++ · exact regularizedZeta_ne_zero_at_one ++ · rw [regularizedZeta_of_ne_one hs₁] ++ exact mul_ne_zero (sub_ne_zero.mpr hs₁) ++ (riemannZeta_ne_zero_of_one_le_re_of_ne_one hs hs₁) ++ ++noncomputable def vonMangoldtAux (s : ℂ) : ℂ := ++ -deriv regularizedZeta s / regularizedZeta s ++ ++theorem continuousOn_vonMangoldtAux : ++ ContinuousOn vonMangoldtAux {s | 1 ≤ s.re} := by ++ change ContinuousOn (fun s ↦ -deriv regularizedZeta s / regularizedZeta s) ++ {s | 1 ≤ s.re} ++ simp_rw [neg_div] ++ have h := differentiable_regularizedZeta ++ exact ((h.contDiff.continuous_deriv le_rfl).continuousOn.div ++ h.continuous.continuousOn fun s hs ↦ regularizedZeta_ne_zero_of_one_le_re hs).neg ++ ++theorem eqOn_vonMangoldtAux : ++ Set.EqOn vonMangoldtAux ++ (fun s ↦ LSeries (fun n ↦ (ArithmeticFunction.vonMangoldt n : ℂ)) s - 1 / (s - 1)) ++ {s | 1 < s.re} := by ++ intro s hs ++ change vonMangoldtAux s = ++ LSeries (fun n ↦ (ArithmeticFunction.vonMangoldt n : ℂ)) s - 1 / (s - 1) ++ have hs' : 1 < s.re := hs ++ have hs₁ : s ≠ 1 := by ++ rintro rfl ++ norm_num at hs' ++ have hz : riemannZeta s ≠ 0 := riemannZeta_ne_zero_of_one_lt_re hs' ++ unfold vonMangoldtAux ++ rw [deriv_regularizedZeta_of_ne_one hs₁, regularizedZeta_of_ne_one hs₁, ++ ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div hs'] ++ field_simp [sub_ne_zero.mpr hs₁, hz] ++ ring ++ ++end CatalanOrdinaryZeta ++ ++end ++ ++end CatalanPNT +diff --git a/PrimeNumberTheoremAnd/Catalan/OrdinaryZetaZeroFree.lean b/PrimeNumberTheoremAnd/Catalan/OrdinaryZetaZeroFree.lean +new file mode 100644 +index 0000000..e0f363f +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan/OrdinaryZetaZeroFree.lean +@@ -0,0 +1,175 @@ ++import Mathlib.Analysis.SpecialFunctions.Complex.LogBounds ++import Mathlib.Analysis.Complex.Asymptotics ++import Mathlib.Analysis.Asymptotics.Lemmas ++import Mathlib.NumberTheory.EulerProduct.DirichletLSeries ++ ++namespace CatalanPNT ++ ++open Complex Asymptotics Filter ++open scoped Topology ++ ++namespace CatalanOrdinaryZeta ++ ++private lemma re_log_comb_nonneg' {a : ℝ} (ha₀ : 0 ≤ a) (ha₁ : a < 1) ++ {z : ℂ} (hz : ‖z‖ = 1) : ++ 0 ≤ 3 * (-log (1 - a)).re + 4 * (-log (1 - a * z)).re + ++ (-log (1 - a * z ^ 2)).re := by ++ have hac₀ : ‖(a : ℂ)‖ < 1 := by ++ simp only [Complex.norm_of_nonneg ha₀, ha₁] ++ have hac₁ : ‖a * z‖ < 1 := by rwa [norm_mul, hz, mul_one] ++ have hac₂ : ‖a * z ^ 2‖ < 1 := by rwa [norm_mul, norm_pow, hz, one_pow, mul_one] ++ rw [← ((hasSum_re <| hasSum_taylorSeries_neg_log hac₀).mul_left 3).add ++ ((hasSum_re <| hasSum_taylorSeries_neg_log hac₁).mul_left 4) |>.add ++ (hasSum_re <| hasSum_taylorSeries_neg_log hac₂) |>.tsum_eq] ++ refine tsum_nonneg fun n ↦ ?_ ++ simp only [← ofReal_pow, div_natCast_re, ofReal_re, mul_pow, mul_re, ofReal_im, ++ zero_mul, sub_zero] ++ rcases n.eq_zero_or_pos with rfl | hn ++ · simp ++ · simp only [← mul_div_assoc, ← add_div] ++ refine div_nonneg ?_ n.cast_nonneg ++ rw [← pow_mul, pow_mul', sq, mul_re, ← sq, ← sq, ← sq_norm_sub_sq_re, norm_pow, hz] ++ convert! (show 0 ≤ 2 * a ^ n * ((z ^ n).re + 1) ^ 2 by positivity) using 1 ++ ring ++ ++private lemma re_log_comb_nonneg {n : ℕ} (hn : 2 ≤ n) {x : ℝ} (hx : 1 < x) ++ (y : ℝ) : ++ 0 ≤ 3 * (-log (1 - (n : ℂ) ^ (-x : ℂ))).re + ++ 4 * (-log (1 - (n : ℂ) ^ (-(x + I * y)))).re + ++ (-log (1 - (n : ℂ) ^ (-(x + 2 * I * y)))).re := by ++ let a : ℝ := (n : ℝ) ^ (-x) ++ let z : ℂ := (n : ℂ) ^ (-(I * y)) ++ have hn₀ : (n : ℂ) ≠ 0 := by exact_mod_cast (show n ≠ 0 by omega) ++ have ha₀ : 0 ≤ a := by dsimp [a]; positivity ++ have ha₁ : a < 1 := by ++ dsimp [a] ++ rw [Real.rpow_neg (Nat.cast_nonneg n), inv_lt_one_iff₀] ++ exact .inr <| Real.one_lt_rpow (mod_cast one_lt_two.trans_le hn) <| zero_lt_one.trans hx ++ have hz : ‖z‖ = 1 := by ++ dsimp [z] ++ rw [← ofReal_natCast, norm_cpow_eq_rpow_re_of_pos (mod_cast by omega)] ++ simp only [neg_re, mul_re, I_re, ofReal_re, zero_mul, I_im, ofReal_im, ++ mul_zero, sub_self, neg_zero, Real.rpow_zero] ++ have h₀ : (n : ℂ) ^ (-x : ℂ) = (a : ℂ) := by ++ dsimp [a] ++ simp only [ofReal_cpow n.cast_nonneg (-x), ofReal_natCast, ofReal_neg] ++ have h₁ : (n : ℂ) ^ (-(x + I * y)) = (a : ℂ) * z := by ++ dsimp [z] ++ rw [neg_add, cpow_add _ _ hn₀, h₀] ++ have h₂ : (n : ℂ) ^ (-(x + 2 * I * y)) = (a : ℂ) * z ^ 2 := by ++ dsimp [z] ++ rw [neg_add, cpow_add _ _ hn₀, h₀, ++ show -(2 * I * y) = (2 : ℕ) * -(I * y) by ring, cpow_nat_mul] ++ simpa only [h₀, h₁, h₂] using re_log_comb_nonneg' ha₀ ha₁ hz ++ ++private lemma summable_prime_log {s : ℂ} (hs : 1 < s.re) : ++ Summable (fun p : Nat.Primes ↦ -log (1 - (p : ℂ) ^ (-s))) := by ++ simpa only [riemannZetaSummandHom, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk] using! ++ (summable_riemannZetaSummand hs).of_norm.clog_one_sub.neg.subtype Nat.Prime ++ ++private lemma one_lt_re_one_add {x : ℝ} (hx : 0 < x) (y : ℝ) : ++ 1 < (1 + x : ℂ).re ∧ 1 < (1 + x + I * y).re ∧ ++ 1 < (1 + x + 2 * I * y).re := by ++ simp only [add_re, one_re, ofReal_re, lt_add_iff_pos_right, hx, mul_re, I_re, ++ zero_mul, I_im, ofReal_im, mul_zero, sub_self, add_zero, re_ofNat, im_ofNat, ++ mul_one, mul_im, and_self] ++ ++theorem norm_riemannZeta_product_ge_one {x : ℝ} (hx : 0 < x) (y : ℝ) : ++ 1 ≤ ‖riemannZeta (1 + x) ^ 3 * riemannZeta (1 + x + I * y) ^ 4 * ++ riemannZeta (1 + x + 2 * I * y)‖ := by ++ have ⟨h₀, h₁, h₂⟩ := one_lt_re_one_add hx y ++ have H₀ := summable_prime_log h₀ ++ have H₁ := summable_prime_log h₁ ++ have H₂ := summable_prime_log h₂ ++ have hsum₀ := (hasSum_re H₀.hasSum).summable.mul_left 3 ++ have hsum₁ := (hasSum_re H₁.hasSum).summable.mul_left 4 ++ have hsum₂ := (hasSum_re H₂.hasSum).summable ++ rw [← riemannZeta_eulerProduct_exp_log h₀, ← riemannZeta_eulerProduct_exp_log h₁, ++ ← riemannZeta_eulerProduct_exp_log h₂] ++ simp only [← exp_nat_mul, Nat.cast_ofNat, ← exp_add, norm_exp, add_re, mul_re, ++ re_ofNat, im_ofNat, zero_mul, sub_zero, Real.one_le_exp_iff] ++ rw [re_tsum H₀, re_tsum H₁, re_tsum H₂, ← tsum_mul_left, ← tsum_mul_left, ++ ← hsum₀.tsum_add hsum₁, ← (hsum₀.add hsum₁).tsum_add hsum₂] ++ simpa only [neg_add_rev, neg_re, ge_iff_le, add_re, one_re, ofReal_re, ++ ofReal_add, ofReal_one] using ++ tsum_nonneg (fun p : Nat.Primes ↦ re_log_comb_nonneg p.prop.two_le ++ (show 1 < 1 + x by linarith) y) ++ ++private lemma riemannZeta_isBigO_near_one_horizontal : ++ (fun x : ℝ ↦ riemannZeta (1 + x)) =O[𝓝[>] 0] fun x ↦ (1 : ℂ) / x := by ++ have : (fun w : ℂ ↦ riemannZeta (1 + w)) =O[𝓝[≠] 0] (1 / ·) := by ++ have H : Tendsto (fun w : ℂ ↦ w * riemannZeta (1 + w)) (𝓝[≠] 0) (𝓝 1) := by ++ convert! riemannZeta_residue_one.comp (f := fun w ↦ 1 + w) ?_ using 1 ++ · simp only [Function.comp_def, add_sub_cancel_left] ++ · simpa only [tendsto_iff_comap, Homeomorph.coe_addLeft, add_zero, ++ map_le_iff_le_comap] using ++ ((Homeomorph.addLeft (1 : ℂ)).map_punctured_nhds_eq 0).le ++ exact (isBigO_mul_iff_isBigO_div eventually_mem_nhdsWithin).mp <| H.isBigO_one ℂ ++ exact (isBigO_comp_ofReal_nhds_ne this).mono <| nhdsGT_le_nhdsNE 0 ++ ++private lemma one_add_I_mul_ne_one {y : ℝ} (hy : y ≠ 0) : 1 + I * y ≠ 1 := by ++ simpa only [ne_eq, add_eq_left, mul_eq_zero, I_ne_zero, ofReal_eq_zero, false_or] using hy ++ ++private lemma riemannZeta_isBigO_horizontal {y : ℝ} (hy : y ≠ 0) : ++ (fun x : ℝ ↦ riemannZeta (1 + x + I * y)) =O[𝓝[>] 0] ++ fun _ ↦ (1 : ℂ) := by ++ refine IsBigO.mono ?_ nhdsWithin_le_nhds ++ simp_rw [add_comm (1 : ℂ), add_assoc] ++ have := (differentiableAt_riemannZeta (one_add_I_mul_ne_one hy)).continuousAt ++ rw [← zero_add (1 + _)] at this ++ exact this.comp (f := fun x : ℝ ↦ x + (1 + I * y)) (x := 0) (by fun_prop) ++ |>.tendsto.isBigO_one ℂ ++ ++private lemma riemannZeta_isBigO_horizontal_of_eq_zero {y : ℝ} (hy : y ≠ 0) ++ (h : riemannZeta (1 + I * y) = 0) : ++ (fun x : ℝ ↦ riemannZeta (1 + x + I * y)) =O[𝓝[>] 0] ++ fun x : ℝ ↦ (x : ℂ) := by ++ simp_rw [add_comm (1 : ℂ), add_assoc] ++ have := (differentiableAt_riemannZeta (one_add_I_mul_ne_one hy)).hasDerivAt ++ rw [← zero_add (1 + _)] at this ++ simpa only [zero_add, h, sub_zero] using ++ (Complex.isBigO_comp_ofReal_nhds ++ (this.comp_add_const 0 _).differentiableAt.isBigO_sub) |>.mono nhdsWithin_le_nhds ++ ++private lemma riemannZeta_ne_zero_one_add_I_mul {t : ℝ} (ht : t ≠ 0) : ++ riemannZeta (1 + I * t) ≠ 0 := by ++ intro Hz ++ have ht₂ : 2 * t ≠ 0 := mul_ne_zero two_ne_zero ht ++ have help (x : ℝ) : ((1 / x) ^ 3 * x ^ 4 * 1 : ℂ) = x := by ++ rcases eq_or_ne x 0 with rfl | h ++ · rw [ofReal_zero, zero_pow (by omega), mul_zero, mul_one] ++ · rw [one_div, inv_pow, pow_succ _ 3, ← mul_assoc, ++ inv_mul_cancel₀ <| pow_ne_zero 3 (ofReal_ne_zero.mpr h), one_mul, mul_one] ++ have H₀ : (fun _ : ℝ ↦ (1 : ℝ)) =O[𝓝[>] 0] ++ fun x ↦ riemannZeta (1 + x) ^ 3 * riemannZeta (1 + x + I * t) ^ 4 * ++ riemannZeta (1 + x + 2 * I * t) := ++ IsBigO.of_bound' <| eventually_nhdsWithin_of_forall ++ fun _ hx ↦ (norm_one (α := ℝ)).symm ▸ (norm_riemannZeta_product_ge_one hx t) ++ have H := riemannZeta_isBigO_near_one_horizontal.pow 3 |>.mul <| ++ (riemannZeta_isBigO_horizontal_of_eq_zero ht Hz).pow 4 |>.mul <| ++ riemannZeta_isBigO_horizontal ht₂ ++ simp only [ofReal_mul, ofReal_ofNat, mul_left_comm I, ← mul_assoc, help] at H ++ replace H := (H₀.trans H).norm_right ++ simp only [norm_real] at H ++ exact isLittleO_irrefl (.of_forall (fun _ ↦ one_ne_zero)) <| ++ H.of_norm_right.trans_isLittleO <| isLittleO_id_one.mono nhdsWithin_le_nhds ++ ++theorem riemannZeta_ne_zero_of_re_eq_one_of_ne_one {s : ℂ} (hs : s.re = 1) ++ (hs₁ : s ≠ 1) : riemannZeta s ≠ 0 := by ++ have hs' : s = 1 + I * s.im := by ++ conv_lhs => rw [← re_add_im s, hs, ofReal_one, mul_comm] ++ have him : s.im ≠ 0 := by ++ intro h ++ apply hs₁ ++ rw [hs', h, ofReal_zero, mul_zero, add_zero] ++ exact hs'.symm ▸ riemannZeta_ne_zero_one_add_I_mul him ++ ++theorem riemannZeta_ne_zero_of_one_le_re_of_ne_one {s : ℂ} (hs : 1 ≤ s.re) ++ (hs₁ : s ≠ 1) : riemannZeta s ≠ 0 := by ++ rcases hs.eq_or_lt with h | h ++ · exact riemannZeta_ne_zero_of_re_eq_one_of_ne_one h.symm hs₁ ++ · exact _root_.riemannZeta_ne_zero_of_one_lt_re h ++ ++end CatalanOrdinaryZeta ++ ++end CatalanPNT +diff --git a/PrimeNumberTheoremAnd/Catalan/Wiener.lean b/PrimeNumberTheoremAnd/Catalan/Wiener.lean +new file mode 100644 +index 0000000..0a6b505 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan/Wiener.lean +@@ -0,0 +1,582 @@ ++import PrimeNumberTheoremAnd.Catalan.WienerBounds ++ ++namespace CatalanPNT ++ ++open ZetaFivePNT ++ ++open _root_.Real BigOperators ArithmeticFunction MeasureTheory _root_.Filter Set FourierTransform LSeries ++ _root_.Asymptotics SchwartzMap ++open Complex hiding log ++open scoped Topology ++open scoped ContDiff ++open scoped ComplexConjugate ++ ++variable {n : ℕ} {A a b c d u x y t σ' : ℝ} {ψ Ψ : ℝ → ℂ} {F G : ℂ → ℂ} {f : ℕ → ℂ} {𝕜 : Type} ++ [RCLike 𝕜] ++ ++attribute [local gcongr] norm_lt_norm_of_nonneg ++ ++theorem limiting_cor_schwartz (ψ : 𝓢(ℝ, ℂ)) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := ++ limiting_cor_W21 ψ hf hcheby hG hG' ++ ++theorem fourier_surjection_on_schwartz (f : 𝓢(ℝ, ℂ)) : ∃ g : 𝓢(ℝ, ℂ), 𝓕 g = f := by ++ refine ⟨𝓕⁻ f, ?_⟩ ++ exact FourierTransform.fourier_fourierInv_eq f ++ ++noncomputable def toSchwartz (f : ℝ → ℂ) (h1 : ContDiff ℝ ∞ f) ++ (h2 : HasCompactSupport f) : 𝓢(ℝ, ℂ) := ++ h2.toSchwartzMap h1 ++ ++@[simp] theorem toSchwartz_apply (f : ℝ → ℂ) {h1 h2 x} : SchwartzMap.mk f h1 h2 x = f x := rfl ++ ++theorem comp_exp_support0 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ ∀ᶠ x in 𝓝 0, Ψ x = 0 := ++ notMem_tsupport_iff_eventuallyEq.mp (fun h => lt_irrefl 0 <| mem_Ioi.mp (hplus h)) ++ ++theorem comp_exp_support1 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ ∀ᶠ x in atBot, Ψ (exp x) = 0 := ++ Real.tendsto_exp_atBot <| comp_exp_support0 hplus ++ ++theorem comp_exp_support2 {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) : ++ ∀ᶠ (x : ℝ) in atTop, (Ψ ∘ rexp) x = 0 := by ++ simp only [hasCompactSupport_iff_eventuallyEq, coclosedCompact_eq_cocompact, ++ cocompact_eq_atBot_atTop] at hsupp ++ exact Real.tendsto_exp_atTop hsupp.2 ++ ++theorem comp_exp_support {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : HasCompactSupport (Ψ ∘ rexp) := by ++ simp only [hasCompactSupport_iff_eventuallyEq, coclosedCompact_eq_cocompact, ++ cocompact_eq_atBot_atTop] ++ exact ⟨comp_exp_support1 hplus, comp_exp_support2 hsupp⟩ ++ ++theorem wiener_ikehara_smooth_aux (l0 : Continuous Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) (x : ℝ) (hx : 0 < x) : ++ ∫ (u : ℝ) in Ioi (-Real.log x), ↑(rexp u) * Ψ (rexp u) = ∫ (y : ℝ) in Ioi (1 / x), Ψ y := by ++ have l1 : ContinuousOn rexp (Ici (-Real.log x)) := by fun_prop ++ have l2 : Tendsto rexp atTop atTop := Real.tendsto_exp_atTop ++ have l3 t (_ : t ∈ Ioi (-log x)) : HasDerivWithinAt rexp (rexp t) (Ioi t) t := ++ (Real.hasDerivAt_exp t).hasDerivWithinAt ++ have l4 : ContinuousOn Ψ (rexp '' Ioi (-Real.log x)) := by fun_prop ++ have l5 : IntegrableOn Ψ (rexp '' Ici (-Real.log x)) volume := ++ (l0.integrable_of_hasCompactSupport hsupp).integrableOn ++ have l6 : IntegrableOn (fun x ↦ rexp x • (Ψ ∘ rexp) x) (Ici (-Real.log x)) volume := by ++ refine (Continuous.integrable_of_hasCompactSupport (by fun_prop) ?_).integrableOn ++ change HasCompactSupport (rexp • (Ψ ∘ rexp)) ++ exact (comp_exp_support hsupp hplus).smul_left ++ have := MeasureTheory.integral_deriv_smul_comp_Ioi l1 l2 l3 l4 l5 l6 ++ simpa [Real.exp_neg, Real.exp_log hx] using this ++ ++theorem wiener_ikehara_smooth_sub (h1 : Integrable Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ Tendsto (fun x ↦ (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ obtain ⟨ε, hε, hh⟩ := Metric.eventually_nhds_iff.mp <| comp_exp_support0 hplus ++ apply tendsto_nhds_of_eventually_eq ; filter_upwards [eventually_gt_atTop ε⁻¹] with x hxε ++ have l1 : Integrable (indicator (Ioi x⁻¹) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi ++ have l2 : Integrable (indicator (Ioi 0) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi ++ simp_rw [← MeasureTheory.integral_indicator measurableSet_Ioi, ← mul_sub, ← integral_sub l1 l2] ++ simp only [mul_eq_zero, ofReal_eq_zero] ++ right ++ apply MeasureTheory.integral_eq_zero_of_ae ++ apply Eventually.of_forall ++ intro t ++ simp only [Pi.zero_apply] ++ have hε' : 0 < ε⁻¹ := by positivity ++ have hx : 0 < x := by linarith ++ have hx' : 0 < x⁻¹ := by positivity ++ have hεx : x⁻¹ < ε := (inv_lt_comm₀ hε hx).mp hxε ++ have l3 : Ioi 0 = Ioc 0 x⁻¹ ∪ Ioi x⁻¹ := by ++ ext t ; simp only [mem_Ioi, mem_union, mem_Ioc] ; constructor <;> intro h ++ · simp [h, le_or_gt] ++ · cases h with ++ | inl h => exact h.1 ++ | inr h => exact hx'.trans h ++ have l4 : Disjoint (Ioc 0 x⁻¹) (Ioi x⁻¹) := by simp ++ have l5 := Set.indicator_union_of_disjoint l4 Ψ ++ rw [l3, l5] ++ simp only ++ rw [add_comm, sub_add_cancel_left] ++ by_cases ht : t ∈ Ioc 0 x⁻¹ ++ · simp only [ht, indicator_of_mem, neg_eq_zero] ++ apply hh ; simp only [mem_Ioc, dist_zero_right, norm_eq_abs] at ht ⊢ ++ apply hεx.trans_le' ++ rw [abs_le] ; constructor <;> linarith ++ simp [ht] ++ ++theorem wiener_ikehara_smooth (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x - A * ∫ y in Set.Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ let h (x : ℝ) : ℂ := rexp (2 * π * x) * Ψ (exp (2 * π * x)) ++ have h1 : ContDiff ℝ ∞ h := by ++ have : ContDiff ℝ ∞ (fun x : ℝ => (rexp (2 * π * x))) := (contDiff_const.mul contDiff_id).exp ++ exact (contDiff_ofReal.comp this).mul (hsmooth.comp this) ++ have h2 : HasCompactSupport h := by ++ have hπ : 2 * π ≠ 0 := by simp [pi_ne_zero] ++ have hh : HasCompactSupport (fun x : ℝ => Ψ (rexp (2 * π * x))) := by ++ simpa only [Function.comp_def, smul_eq_mul] using ++ (comp_exp_support hsupp hplus).comp_smul hπ ++ change HasCompactSupport ++ ((fun x : ℝ => (rexp (2 * π * x) : ℂ)) * fun x : ℝ => Ψ (rexp (2 * π * x))) ++ exact hh.mul_left ++ obtain ⟨g, hg⟩ := fourier_surjection_on_schwartz (toSchwartz h h1 h2) ++ have l1 {y} (hy : 0 < y) : y * Ψ y = 𝓕 g (1 / (2 * π) * Real.log y) := by ++ rw [hg] ++ change (y : ℂ) * Ψ y = h (1 / (2 * π) * Real.log y) ++ have harg : 2 * π * (1 / (2 * π) * Real.log y) = Real.log y := by ++ rw [← mul_assoc, mul_one_div_cancel (mul_ne_zero (by norm_num) pi_ne_zero), one_mul] ++ dsimp only [h] ++ rw [harg, Real.exp_log hy] ++ have key := limiting_cor_schwartz g hf hcheby hG hG' ++ have l2 : ∀ᶠ x in atTop, ∑' (n : ℕ), f n / ↑n * 𝓕 g (1 / (2 * π) * Real.log (↑n / x)) = ++ ∑' (n : ℕ), f n * Ψ (↑n / x) / x := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ congr ; ext n ++ by_cases hn : n = 0 ++ · simp [hn, (comp_exp_support0 hplus).self_of_nhds] ++ rw [← l1 (by positivity)] ++ have : (n : ℂ) ≠ 0 := by simpa using hn ++ have : (x : ℂ) ≠ 0 := by simpa using hx.ne.symm ++ simp only [ofReal_div, ofReal_natCast] ++ field_simp ++ have l3 : ∀ᶠ x in atTop, ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 g (u / (2 * π)) = ++ ↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ congr 1 ++ rw [hg] ++ change (∫ u in Ici (-Real.log x), h (u / (2 * π))) = ∫ y in Ioi x⁻¹, Ψ y ++ dsimp only [h] ++ have hscale : (2 : ℝ) * π ≠ 0 := mul_ne_zero (by norm_num) pi_ne_zero ++ have harg (u : ℝ) : 2 * π * (u / (2 * π)) = u := mul_div_cancel₀ u hscale ++ simp_rw [harg] ++ rw [MeasureTheory.integral_Ici_eq_integral_Ioi] ++ simpa only [one_div] using wiener_ikehara_smooth_aux hsmooth.continuous hsupp hplus x hx ++ have l4 : Tendsto (fun x => (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ exact wiener_ikehara_smooth_sub (hsmooth.continuous.integrable_of_hasCompactSupport hsupp) hplus ++ simpa [tsum_div_const] using (key.congr' <| EventuallyEq.sub l2 l3) |>.add l4 ++ ++theorem wiener_ikehara_smooth' (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x) atTop (nhds (A * ∫ y in Set.Ioi 0, Ψ y)) := ++ tendsto_sub_nhds_zero_iff.mp <| wiener_ikehara_smooth hf hcheby hG hG' hsmooth hsupp hplus ++ ++local instance coeRealFunctionComplex {E : Type*} : Coe (E → ℝ) (E → ℂ) := ++ ⟨fun f n => f n⟩ ++ ++@[norm_cast] ++theorem set_integral_ofReal {f : ℝ → ℝ} {s : Set ℝ} : ∫ x in s, (f x : ℂ) = ∫ x in s, f x := ++ integral_ofReal ++ ++theorem wiener_ikehara_smooth_real {f : ℕ → ℝ} {Ψ : ℝ → ℝ} ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x) atTop (nhds (A * ∫ y in Set.Ioi 0, Ψ y)) := by ++ let Ψ' := ofReal ∘ Ψ ++ have l1 : ContDiff ℝ ∞ Ψ' := contDiff_ofReal.comp hsmooth ++ have l2 : HasCompactSupport Ψ' := hsupp.comp_left rfl ++ have l3 : closure (Function.support Ψ') ⊆ Ioi 0 := by rwa [Function.support_comp_eq] ; simp ++ have key := (continuous_re.tendsto _).comp ++ (@wiener_ikehara_smooth' A Ψ G f hf hcheby hG hG' l1 l2 l3) ++ simp at key ; norm_cast at key ++ ++theorem interval_approx_inf (ha : 0 < a) (hab : a < b) : ++ ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ ++ closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ ++ ψ ≤ indicator (Ico a b) 1 ∧ b - a - ε ≤ ∫ y in Ioi 0, ψ y := by ++ have l1 : Iio ((b - a) / 3) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds <| by ++ rw [← sub_pos] at hab ++ positivity ++ filter_upwards [self_mem_nhdsWithin, l1] with ε (hε : 0 < ε) (hε' : ε < (b - a) / 3) ++ have l2 : a < a + ε / 2 := by simp [hε] ++ have l3 : b - ε / 2 < b := by simp [hε] ++ obtain ⟨ψ, h1, h2, h3, h4, h5⟩ := smooth_urysohn_support_Ioo l2 l3 ++ refine ⟨ψ, h1, h2, ?_, ?_, ?_⟩ ++ · simp [h5, hab.ne, Icc_subset_Ioi_iff hab.le, ha] ++ · exact h4.trans <| indicator_le_indicator_of_subset Ioo_subset_Ico_self (by simp) ++ · have l4 : 0 ≤ b - a - ε := by linarith ++ have l5 : Icc (a + ε / 2) (b - ε / 2) ⊆ Ioi 0 := by ++ intro t ht ++ simp only [mem_Icc, mem_Ioi] at ht ⊢ ++ exact ha.trans <| l2.trans_le <| ht.1 ++ have l6 : Icc (a + ε / 2) (b - ε / 2) ∩ Ioi 0 = Icc (a + ε / 2) (b - ε / 2) := ++ inter_eq_left.mpr l5 ++ have l7 : ∫ y in Ioi 0, indicator (Icc (a + ε / 2) (b - ε / 2)) 1 y = b - a - ε := by ++ simp only [measurableSet_Icc, integral_indicator_one, measureReal_restrict_apply, l6, ++ volume_real_Icc] ++ convert max_eq_left l4 using 1 ; ring_nf ++ have l8 : IntegrableOn ψ (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ rw [← l7] ; apply setIntegral_mono ?_ l8 h3 ++ rw [IntegrableOn, integrable_indicator_iff measurableSet_Icc] ++ apply IntegrableOn.mono ?_ subset_rfl Measure.restrict_le_self ++ apply integrableOn_const <;> ++ simp ++ ++theorem interval_approx_sup (ha : 0 < a) (hab : a < b) : ++ ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ ++ closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ ++ indicator (Ico a b) 1 ≤ ψ ∧ ∫ y in Ioi 0, ψ y ≤ b - a + ε := by ++ have l1 : Iio (a / 2) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds (by linarith) ++ filter_upwards [self_mem_nhdsWithin, l1] with ε (hε : 0 < ε) (hε' : ε < a / 2) ++ have l2 : a - ε / 2 < a := by linarith ++ have l3 : b < b + ε / 2 := by linarith ++ obtain ⟨ψ, h1, h2, h3, h4, h5⟩ := smooth_urysohn_support_Ioo l2 l3 ++ refine ⟨ψ, h1, h2, ?_, ?_, ?_⟩ ++ · have l4 : a - ε / 2 < b + ε / 2 := by linarith ++ have l5 : ε / 2 < a := by linarith ++ simp [h5, l4.ne, Icc_subset_Ioi_iff l4.le, l5] ++ · apply le_trans ?_ h3 ++ apply indicator_le_indicator_of_subset Ico_subset_Icc_self (by simp) ++ · have l4 : 0 ≤ b - a + ε := by linarith ++ have l5 : Ioo (a - ε / 2) (b + ε / 2) ⊆ Ioi 0 := by intro t ht ; simp at ht ⊢ ; linarith ++ have l6 : Ioo (a - ε / 2) (b + ε / 2) ∩ Ioi 0 = Ioo (a - ε / 2) (b + ε / 2) := ++ inter_eq_left.mpr l5 ++ have l7 : ∫ y in Ioi 0, indicator (Ioo (a - ε / 2) (b + ε / 2)) 1 y = b - a + ε := by ++ simp only [measurableSet_Ioo, integral_indicator_one, measureReal_restrict_apply, l6, ++ volume_real_Ioo] ++ convert max_eq_left l4 using 1 ; ring_nf ++ have l8 : IntegrableOn ψ (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ rw [← l7] ++ refine setIntegral_mono l8 ?_ h4 ++ rw [IntegrableOn, integrable_indicator_iff measurableSet_Ioo] ++ apply IntegrableOn.mono ?_ subset_rfl Measure.restrict_le_self ++ apply integrableOn_const <;> ++ simp ++ ++theorem WI_summable {f : ℕ → ℝ} {g : ℝ → ℝ} (hg : HasCompactSupport g) (hx : 0 < x) : ++ Summable (fun n => f n * g (n / x)) := by ++ obtain ⟨M, hM⟩ := hg.bddAbove.mono subset_closure ++ apply summable_of_hasFiniteSupport ++ unfold Function.HasFiniteSupport ++ simp only [Function.support_mul] ; apply Finite.inter_of_right ; rw [finite_iff_bddAbove] ++ exact ⟨Nat.ceil (M * x), fun i hi => by simpa using Nat.ceil_mono ((div_le_iff₀ hx).mp (hM hi))⟩ ++ ++theorem WI_sum_le {f : ℕ → ℝ} {g₁ g₂ : ℝ → ℝ} (hf : 0 ≤ f) (hg : g₁ ≤ g₂) (hx : 0 < x) ++ (hg₁ : HasCompactSupport g₁) (hg₂ : HasCompactSupport g₂) : ++ (∑' n, f n * g₁ (n / x)) / x ≤ (∑' n, f n * g₂ (n / x)) / x := by ++ apply div_le_div_of_nonneg_right ?_ hx.le ++ exact Summable.tsum_le_tsum (fun n => mul_le_mul_of_nonneg_left (hg _) (hf _)) ++ (WI_summable hg₁ hx) (WI_summable hg₂ hx) ++ ++theorem WI_sum_Iab_le {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hb : 0 < b) (hxb : 2 / b < x) : ++ (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by ++ have hb' : 0 < 2 / b := by positivity ++ have hx : 0 < x := by linarith ++ have hxb' : 2 < x * b := (div_lt_iff₀ hb).mp hxb ++ have l1 (i : ℕ) (hi : i ∉ Finset.range ⌈b * x⌉₊) : f i * indicator (Ico a b) 1 (i / x) = 0 := by ++ simp_all [le_div_iff₀ hx] ++ have l2 (i : ℕ) (_ : i ∈ Finset.range ⌈b * x⌉₊) : ++ f i * indicator (Ico a b) 1 (i / x) ≤ |f i| := by ++ rw [abs_eq_self.mpr (hpos _)] ++ convert_to _ ≤ f i * 1 ++ · ring ++ apply mul_le_mul_of_nonneg_left ?_ (hpos _) ++ by_cases hi : (i / x) ∈ (Ico a b) <;> simp [hi] ++ rw [tsum_eq_sum l1, div_le_iff₀ hx, mul_assoc, mul_assoc] ++ apply Finset.sum_le_sum l2 |>.trans ++ have := hcheby ⌈b * x⌉₊ ; simp only [norm_real, norm_eq_abs] at this ; apply this.trans ++ have : 0 ≤ C := by have := hcheby 1 ; simp only [cumsum, Finset.range_one, norm_real, ++ Finset.sum_singleton, Nat.cast_one, mul_one] at this ; exact (abs_nonneg _).trans this ++ refine mul_le_mul_of_nonneg_left ?_ this ++ apply (Nat.ceil_lt_add_one (by positivity)).le.trans ++ linarith ++ ++theorem WI_sum_Iab_le' {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hb : 0 < b) : ++ ∀ᶠ x : ℝ in atTop, (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by ++ filter_upwards [eventually_gt_atTop (2 / b)] with x hx using WI_sum_Iab_le hpos hcheby hb hx ++ ++theorem le_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[>] b, a ≤ c) : a ≤ b := by ++ exact ge_of_tendsto ++ (show Tendsto (fun c : ℝ => c) (𝓝[>] b) (𝓝 b) from nhdsWithin_le_nhds) h ++ ++theorem ge_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[<] b, c ≤ a) : b ≤ a := by ++ exact le_of_tendsto ++ (show Tendsto (fun c : ℝ => c) (𝓝[<] b) (𝓝 b) from nhdsWithin_le_nhds) h ++ ++theorem WI_tendsto_aux (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++ Tendsto (fun c => c / A - (b - a)) (𝓝[>] (A * (b - a))) (𝓝[>] 0) := by ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨A * ε, by positivity, ?_⟩ ++ intro x hx1 hx2 ++ constructor ++ · simpa [lt_div_iff₀' hA] ++ · simp only [Real.dist_eq, dist_zero_right, Real.norm_eq_abs] at hx2 ⊢ ++ have : |x / A - (b - a)| = |x - A * (b - a)| / A := by ++ rw [← abs_eq_self.mpr hA.le, ← abs_div, abs_eq_self.mpr hA.le] ; congr ; field_simp ++ rwa [this, div_lt_iff₀' hA] ++ ++theorem WI_tendsto_aux' (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++ Tendsto (fun c => (b - a) - c / A) (𝓝[<] (A * (b - a))) (𝓝[>] 0) := by ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨A * ε, by positivity, ?_⟩ ++ intro x hx1 hx2 ++ constructor ++ · simpa [div_lt_iff₀' hA] ++ · simp only [Real.dist_eq, dist_zero_right, norm_eq_abs] at hx2 ⊢ ++ have : |(b - a) - x / A| = |A * (b - a) - x| / A := by ++ rw [← abs_eq_self.mpr hA.le, ← abs_div, abs_eq_self.mpr hA.le] ; congr ; field_simp ++ rwa [this, div_lt_iff₀' hA, ← neg_sub, abs_neg] ++ ++theorem residue_nonneg {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm (fun n ↦ ↑(f n)) σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : EqOn G (fun s ↦ LSeries (fun n ↦ ↑(f n)) s - ↑A / (s - 1)) {s | 1 < s.re}) : ++ 0 ≤ A := by ++ let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x ++ have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by ++ filter_upwards [eventually_ge_atTop 0] with x hx ++ exact div_nonneg (tsum_nonneg (fun i => mul_nonneg (hpos _) (hg _))) hx ++ obtain ⟨ε, ψ, h1, h2, h3, h4, -⟩ := (interval_approx_sup zero_lt_one one_lt_two).exists ++ have key := @wiener_ikehara_smooth_real A G f ψ hf hcheby hG hG' h1 h2 h3 ++ have l2 : 0 ≤ ψ := by apply le_trans _ h4 ; apply indicator_nonneg ; simp ++ have l1 : ∀ᶠ x in atTop, 0 ≤ S ψ x := hSnonneg l2 ++ have l3 : 0 ≤ A * ∫ (y : ℝ) in Ioi 0, ψ y := ge_of_tendsto key l1 ++ have l4 : 0 < ∫ (y : ℝ) in Ioi 0, ψ y := by ++ have r1 : 0 ≤ᵐ[Measure.restrict volume (Ioi 0)] ψ := Eventually.of_forall l2 ++ have r2 : IntegrableOn (fun y ↦ ψ y) (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ have r3 : Ico 1 2 ⊆ Function.support ψ := by ++ intro x hx ; have := h4 x ; simp [hx] at this ⊢ ; linarith ++ have r4 : Ico 1 2 ⊆ Function.support ψ ∩ Ioi 0 := by ++ simp only [subset_inter_iff, r3, ++ true_and] ; apply Ico_subset_Icc_self.trans ; rw [Icc_subset_Ioi_iff] <;> linarith ++ have r5 : 1 ≤ volume ((Function.support fun y ↦ ψ y) ∩ Ioi 0) := by ++ convert volume.mono r4 ; norm_num ++ simpa [setIntegral_pos_iff_support_of_nonneg_ae r1 r2] using zero_lt_one.trans_le r5 ++ have := div_nonneg l3 l4.le ; field_simp at this ; exact this ++ ++theorem WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * (indicator (Ico a b) 1 (n / x))) / x) ++ atTop (nhds (A * (b - a))) := by ++ ++ by_cases hab : a = b ++ · simp [hab] ++ replace hb : a < b := lt_of_le_of_ne hb hab ; clear hab ++ ++ let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x ++ have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by ++ filter_upwards [eventually_ge_atTop 0] with x hx ++ refine div_nonneg ?_ hx ++ refine tsum_nonneg (fun i => mul_nonneg (hpos _) (hg _)) ++ have hA : 0 ≤ A := residue_nonneg hpos hf hcheby hG hG' ++ ++ let Iab : ℝ → ℝ := indicator (Ico a b) 1 ++ change Tendsto (S Iab) atTop (𝓝 (A * (b - a))) ++ have hIab : HasCompactSupport Iab := by ++ simpa [Iab, HasCompactSupport, tsupport, hb.ne] using isCompact_Icc ++ have Iab_nonneg : ∀ᶠ x : ℝ in atTop, 0 ≤ S Iab x := hSnonneg (indicator_nonneg (by simp)) ++ have Iab2 : IsBoundedUnder (· ≤ ·) atTop (S Iab) := by ++ obtain ⟨C, hC⟩ := hcheby ; exact ⟨C * 2 * b, WI_sum_Iab_le' hpos hC (by linarith)⟩ ++ have Iab3 : IsBoundedUnder (· ≥ ·) atTop (S Iab) := ⟨0, Iab_nonneg⟩ ++ have Iab0 : IsCoboundedUnder (· ≥ ·) atTop (S Iab) := Iab2.isCoboundedUnder_ge ++ have Iab1 : IsCoboundedUnder (· ≤ ·) atTop (S Iab) := Iab3.isCoboundedUnder_le ++ ++ have sup_le : limsup (S Iab) atTop ≤ A * (b - a) := by ++ have l_sup : ∀ᶠ ε in 𝓝[>] 0, limsup (S Iab) atTop ≤ A * (b - a + ε) := by ++ filter_upwards [interval_approx_sup ha hb] with ε happrox ++ rcases happrox with ⟨ψ, h1, h2, h3, h4, h6⟩ ++ have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 ++ have l6 : S Iab ≤ᶠ[atTop] S ψ := by ++ filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h4 hx hIab h2 ++ have l5 : IsBoundedUnder (· ≤ ·) atTop (S ψ) := l1.isBoundedUnder_le ++ have l3 : limsup (S Iab) atTop ≤ limsup (S ψ) atTop := limsup_le_limsup l6 Iab1 l5 ++ apply l3.trans ; rw [l1.limsup_eq] ; gcongr ++ obtain rfl | h := eq_or_ne A 0 ++ · simpa using l_sup ++ apply le_of_eventually_nhdsWithin ++ have key : 0 < A := lt_of_le_of_ne hA h.symm ++ filter_upwards [WI_tendsto_aux a b key l_sup] with x hx ++ simpa [mul_div_cancel₀ _ h] using hx ++ ++ have le_inf : A * (b - a) ≤ liminf (S Iab) atTop := by ++ have l_inf : ∀ᶠ ε in 𝓝[>] 0, A * (b - a - ε) ≤ liminf (S Iab) atTop := by ++ filter_upwards [interval_approx_inf ha hb] with ε happrox ++ rcases happrox with ⟨ψ, h1, h2, h3, h5, h6⟩ ++ have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 ++ have l2 : S ψ ≤ᶠ[atTop] S Iab := by ++ filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h5 hx h2 hIab ++ have l4 : IsBoundedUnder (· ≥ ·) atTop (S ψ) := l1.isBoundedUnder_ge ++ have l3 : liminf (S ψ) atTop ≤ liminf (S Iab) atTop := liminf_le_liminf l2 l4 Iab0 ++ apply le_trans ?_ l3 ; rw [l1.liminf_eq] ; gcongr ++ obtain rfl | h := eq_or_ne A 0 ++ · simpa using l_inf ++ apply ge_of_eventually_nhdsWithin ++ have key : 0 < A := lt_of_le_of_ne hA h.symm ++ filter_upwards [WI_tendsto_aux' a b key l_inf] with x hx ++ simpa [mul_div_cancel₀ _ h] using hx ++ ++ have : liminf (S Iab) atTop ≤ limsup (S Iab) atTop := liminf_le_limsup Iab2 Iab3 ++ refine tendsto_of_liminf_eq_limsup ?_ ?_ Iab2 Iab3 <;> linarith ++ ++theorem le_floor_mul_iff (hb : 0 ≤ b) (hx : 0 < x) : n ≤ ⌊b * x⌋₊ ↔ n / x ≤ b := by ++ rw [div_le_iff₀ hx, Nat.le_floor_iff] ; positivity ++ ++theorem lt_ceil_mul_iff (hx : 0 < x) : n < ⌈b * x⌉₊ ↔ n / x < b := by ++ rw [div_lt_iff₀ hx, Nat.lt_ceil] ++ ++theorem ceil_mul_le_iff (hx : 0 < x) : ⌈a * x⌉₊ ≤ n ↔ a ≤ n / x := by ++ rw [le_div_iff₀ hx, Nat.ceil_le] ++ ++theorem mem_Icc_iff_div (hb : 0 ≤ b) (hx : 0 < x) : ++ n ∈ Finset.Icc ⌈a * x⌉₊ ⌊b * x⌋₊ ↔ n / x ∈ Icc a b := by ++ rw [Finset.mem_Icc, mem_Icc, ceil_mul_le_iff hx, le_floor_mul_iff hb hx] ++ ++theorem mem_Ico_iff_div (hx : 0 < x) : n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊ ↔ n / x ∈ Ico a b := by ++ rw [Finset.mem_Ico, mem_Ico, ceil_mul_le_iff hx, lt_ceil_mul_iff hx] ++ ++theorem tsum_indicator {f : ℕ → ℝ} (hx : 0 < x) : ++ ∑' n, f n * (indicator (Ico a b) 1 (n / x)) = ∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n := by ++ have l1 : ∀ n ∉ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n * indicator (Ico a b) 1 (↑n / x) = 0 := by ++ simp [mem_Ico_iff_div hx] ; tauto ++ rw [tsum_eq_sum l1] ; apply Finset.sum_congr rfl ; simp only ++ [mem_Ico_iff_div hx] ; intro n hn ; simp [hn] ++ ++theorem WienerIkeharaInterval_discrete {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n) / x) ++ atTop (nhds (A * (b - a))) := by ++ apply (WienerIkeharaInterval hpos hf hcheby hG hG' ha hb).congr' ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ rw [tsum_indicator hx] ++ ++theorem WienerIkeharaInterval_discrete' {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun N : ℕ ↦ (∑ n ∈ Finset.Ico ⌈a * N⌉₊ ⌈b * N⌉₊, f n) / N) ++ atTop (nhds (A * (b - a))) := ++ WienerIkeharaInterval_discrete hpos hf hcheby hG hG' ha hb |>.comp tendsto_natCast_atTop_atTop ++ ++theorem tendsto_mul_ceil_div : ++ Tendsto (fun (p : ℝ × ℕ) => ⌈p.1 * p.2⌉₊ / (p.2 : ℝ)) (𝓝[>] 0 ×ˢ atTop) (𝓝 0) := by ++ rw [Metric.tendsto_nhds] ; intro δ hδ ++ have l1 : ∀ᶠ ε : ℝ in 𝓝[>] 0, ε ∈ Ioo 0 (δ / 2) := ++ inter_mem_nhdsWithin _ (Iio_mem_nhds (by positivity)) ++ have l2 : ∀ᶠ N : ℕ in atTop, 1 ≤ δ / 2 * N := by ++ apply Tendsto.eventually_ge_atTop ++ exact tendsto_natCast_atTop_atTop.const_mul_atTop (by positivity) ++ filter_upwards [l1.prod_mk l2] with p hp ++ rcases p with ⟨ε, N⟩ ++ rcases hp with ⟨⟨hε, h1⟩, h2⟩ ++ dsimp only at * ++ have l3 : 0 < (N : ℝ) := by ++ simp only [Nat.cast_pos, Nat.pos_iff_ne_zero] ; rintro rfl ; simp [zero_lt_one.not_ge] at h2 ++ have l5 : 0 ≤ ε * ↑N := by positivity ++ have l6 : ε * N ≤ δ / 2 * N := mul_le_mul h1.le le_rfl (by positivity) (by positivity) ++ simp only [dist_zero_right, norm_div, RCLike.norm_natCast, div_lt_iff₀ l3, gt_iff_lt] ++ convert (Nat.ceil_lt_add_one l5).trans_le (add_le_add l6 h2) using 1 ; ring ++ ++noncomputable def S (f : ℕ → 𝕜) (ε : ℝ) (N : ℕ) : 𝕜 := (∑ n ∈ Finset.Ico ⌈ε * N⌉₊ N, f n) / N ++ ++theorem S_sub_S {f : ℕ → 𝕜} {ε : ℝ} {N : ℕ} (hε : ε ≤ 1) : ++ S f 0 N - S f ε N = cumsum f ⌈ε * N⌉₊ / N := by ++ have r1 : Finset.range N = Finset.range ⌈ε * N⌉₊ ∪ Finset.Ico ⌈ε * N⌉₊ N := by ++ simp_rw [Finset.range_eq_Ico] ++ symm ++ apply Finset.Ico_union_Ico_eq_Ico (Nat.zero_le _) ++ simp only [Nat.ceil_le] ++ exact mul_le_of_le_one_left N.cast_nonneg hε ++ have r2 : Disjoint (Finset.range ⌈ε * N⌉₊) (Finset.Ico ⌈ε * N⌉₊ N) := by ++ rw [Finset.range_eq_Ico] ; apply Finset.Ico_disjoint_Ico_consecutive ++ simp [S, r1, Finset.sum_union r2, cumsum, add_div] ++ ++theorem tendsto_S_S_zero {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ TendstoUniformlyOnFilter (S f) (S f 0) (𝓝[>] 0) atTop := by ++ rw [Metric.tendstoUniformlyOnFilter_iff] ; intro δ hδ ++ obtain ⟨C, hC⟩ := hcheby ++ have l1 : ∀ᶠ (p : ℝ × ℕ) in 𝓝[>] 0 ×ˢ atTop, C * ⌈p.1 * p.2⌉₊ / p.2 < δ := by ++ have r1 := tendsto_mul_ceil_div.const_mul C ++ simp only [mul_div_assoc', mul_zero] at r1 ; exact r1 (Iio_mem_nhds hδ) ++ have : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) ++ filter_upwards [l1, Eventually.prod_inl this _] with p h1 h2 ++ rcases p with ⟨ε, N⟩ ++ have l2 : ‖cumsum f ⌈ε * ↑N⌉₊ / ↑N‖ ≤ C * ⌈ε * N⌉₊ / N := by ++ have r1 := hC ⌈ε * N⌉₊ ++ have r2 : 0 ≤ cumsum f ⌈ε * N⌉₊ := by apply cumsum_nonneg hpos ++ simp only [norm_real, norm_of_nonneg (hpos _), norm_div, ++ norm_of_nonneg r2, Real.norm_natCast] at r1 ⊢ ++ apply div_le_div_of_nonneg_right r1 (by positivity) ++ simpa [dist_eq_norm, ← S_sub_S h2.2] using l2.trans_lt h1 ++ ++theorem WienerIkeharaTheorem' {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun N => cumsum f N / N) atTop (𝓝 A) := by ++ convert_to Tendsto (S f 0) atTop (𝓝 A) ; · ext N ; simp [S, cumsum] ++ apply (tendsto_S_S_zero hpos hcheby).tendsto_of_eventually_tendsto ++ · have L0 : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) ++ apply eventually_of_mem L0 ++ · intro ε hε ++ convert WienerIkeharaInterval_discrete' hpos hf hcheby hG hG' hε.1 hε.2 using 1 ++ funext N ++ simp only [S, one_mul, Nat.ceil_natCast] ++ · have : Tendsto (fun ε : ℝ => ε) (𝓝[>] 0) (𝓝 0) := nhdsWithin_le_nhds ++ simpa using (this.const_sub 1).const_mul A ++ ++theorem vonMangoldt_cheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(Λ k : ℂ)‖) n ≤ C * n) := by ++ use Real.log 4 + 4 ++ intro N ++ by_cases! h : N = 0 ++ · simp [h, cumsum] ++ simp only [cumsum, norm_real, norm_eq_abs] ++ rw [Nat.range_eq_Icc_zero_sub_one _ h, (by simp : N - 1 = ⌊(N : ℝ) - 1⌋₊)] ++ simp_rw [abs_of_nonneg vonMangoldt_nonneg] ++ rw [← Chebyshev.psi_eq_sum_Icc] ++ grw [Chebyshev.psi_le_const_mul_self <| sub_nonneg_of_le <| Nat.one_le_cast_iff_ne_zero.mpr h] ++ gcongr ++ linarith ++ ++theorem WeakPNT : Tendsto (fun N ↦ cumsum Λ N / N) atTop (𝓝 1) := by ++ let F : ℂ → ℂ := CatalanOrdinaryZeta.vonMangoldtAux ++ have l1 (n : ℕ) : 0 ≤ Λ n := vonMangoldt_nonneg ++ have l2 s (hs : 1 < s.re) : F s = LSeries Λ s - 1 / (s - 1) := by ++ exact CatalanOrdinaryZeta.eqOn_vonMangoldtAux hs ++ have l3 : ContinuousOn F {s | 1 ≤ s.re} := ++ CatalanOrdinaryZeta.continuousOn_vonMangoldtAux ++ have l4 : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(Λ k : ℂ)‖) n ≤ C * n) := vonMangoldt_cheby ++ have l5 (σ' : ℝ) (hσ' : 1 < σ') : Summable (nterm Λ σ') := by ++ simpa only [← nterm_eq_norm_term] ++ using (@ArithmeticFunction.LSeriesSummable_vonMangoldt σ' hσ').norm ++ apply WienerIkeharaTheorem' l1 l5 l4 l3 l2 ++ ++end CatalanPNT +diff --git a/PrimeNumberTheoremAnd/Catalan/WienerBounds.lean b/PrimeNumberTheoremAnd/Catalan/WienerBounds.lean +new file mode 100644 +index 0000000..06122cf +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan/WienerBounds.lean +@@ -0,0 +1,582 @@ ++import PrimeNumberTheoremAnd.Catalan.WienerLimits ++ ++namespace CatalanPNT ++ ++open ZetaFivePNT ++ ++open _root_.Real BigOperators ArithmeticFunction MeasureTheory _root_.Filter Set FourierTransform LSeries ++ _root_.Asymptotics SchwartzMap ++open Complex hiding log ++open scoped Topology ++open scoped ContDiff ++open scoped ComplexConjugate ++ ++variable {n : ℕ} {A a b c d u x y t σ' : ℝ} {ψ Ψ : ℝ → ℂ} {F G : ℂ → ℂ} {f : ℕ → ℂ} {𝕜 : Type} ++ [RCLike 𝕜] ++ ++attribute [local gcongr] norm_lt_norm_of_nonneg ++ ++theorem smooth_urysohn (a b c d : ℝ) (h1 : a < b) (h3 : c < d) : ∃ Ψ : ℝ → ℝ, ++ (ContDiff ℝ ∞ Ψ) ∧ (HasCompactSupport Ψ) ∧ ++ Set.indicator (Set.Icc b c) 1 ≤ Ψ ∧ Ψ ≤ Set.indicator (Set.Ioo a d) 1 := by ++ obtain ⟨ψ, l1, l2, l3, l4, -⟩ := smooth_urysohn_support_Ioo h1 h3 ++ refine ⟨ψ, l1, l2, l3, l4⟩ ++ ++noncomputable def compactTruncation : trunc := by ++ choose ψ h1 h2 h3 h4 using smooth_urysohn (-2) (-1) (1) (2) (by linarith) (by linarith) ++ exact ⟨⟨ψ, h1.of_le (by norm_cast), h2⟩, h3, h4⟩ ++ ++theorem one_div_sub_one (n : ℕ) : 1 / (↑(n - 1) : ℝ) ≤ 2 / n := by ++ cases n with ++ | zero => simp ++ | succ n => ++ cases n with ++ | zero => simp ++ | succ n => norm_cast ; rw [div_le_div_iff₀] <;> simp [mul_add] <;> linarith ++ ++noncomputable def pp (a x : ℝ) : ℝ := a ^ 2 * (x + 1) ^ 2 + (1 - a) * (1 + a) ++ ++noncomputable def pp' (a x : ℝ) : ℝ := a ^ 2 * (2 * (x + 1)) ++ ++theorem pp_pos {a : ℝ} (ha : a ∈ Ioo (-1) 1) (x : ℝ) : 0 < pp a x := by ++ simp only [pp] ++ have : 0 < 1 - a := by linarith [ha.2] ++ have : 0 < 1 + a := by linarith [ha.1] ++ positivity ++ ++theorem pp_deriv (a x : ℝ) : HasDerivAt (pp a) (pp' a x) x := by ++ unfold pp pp' ++ simpa using hasDerivAt_id x |>.add_const 1 |>.pow 2 |>.const_mul _ ++ ++theorem pp_deriv_eq (a : ℝ) : deriv (pp a) = pp' a := by ++ ext x ; exact pp_deriv a x |>.deriv ++ ++theorem pp'_deriv (a x : ℝ) : HasDerivAt (pp' a) (a ^ 2 * 2) x := by ++ change HasDerivAt (fun y : ℝ => a ^ 2 * (2 * (y + 1))) (a ^ 2 * 2) x ++ convert hasDerivAt_id x |>.add_const 1 |>.const_mul 2 |>.const_mul (a ^ 2) ++ using 1 <;> first | rfl | ring ++ ++theorem pp'_deriv_eq (a : ℝ) : deriv (pp' a) = fun _ => a ^ 2 * 2 := by ++ ext x ; exact pp'_deriv a x |>.deriv ++ ++noncomputable def hh (a t : ℝ) : ℝ := (t * (1 + (a * log t) ^ 2))⁻¹ ++ ++noncomputable def hh' (a t : ℝ) : ℝ := - pp a (log t) * hh a t ^ 2 ++ ++theorem hh_nonneg (a : ℝ) {t : ℝ} (ht : 0 ≤ t) : 0 ≤ hh a t := by dsimp only [hh] ; positivity ++ ++theorem hh_le (a t : ℝ) (ht : 0 ≤ t) : |hh a t| ≤ t⁻¹ := by ++ by_cases h0 : t = 0 ++ · simp [hh, h0] ++ replace ht : 0 < t := lt_of_le_of_ne ht (by tauto) ++ unfold hh ++ rw [abs_inv, inv_le_inv₀ (by positivity) ht, abs_mul, abs_eq_self.mpr ht.le] ++ convert_to t * 1 ≤ _ ++ · simp ++ apply mul_le_mul le_rfl ?_ zero_le_one ht.le ++ rw [abs_eq_self.mpr (by positivity)] ++ simp only [le_add_iff_nonneg_right] ++ positivity ++ ++theorem hh_deriv (a : ℝ) {t : ℝ} (ht : t ≠ 0) : HasDerivAt (hh a) (hh' a t) t := by ++ have e1 : t * (1 + (a * log t) ^ 2) ≠ 0 := mul_ne_zero ht (_root_.ne_of_lt (by positivity)).symm ++ have l5 : HasDerivAt (fun t : ℝ => log t) t⁻¹ t := Real.hasDerivAt_log ht ++ have l4 : HasDerivAt (fun t : ℝ => a * log t) (a * t⁻¹) t := l5.const_mul _ ++ have l3 : HasDerivAt (fun t : ℝ => (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := by ++ convert l4.pow 2 using 1 ; ring ++ have l2 : HasDerivAt (fun t : ℝ => 1 + (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := ++ l3.const_add _ ++ have l1 : HasDerivAt (fun t : ℝ => t * (1 + (a * log t) ^ 2)) ++ (1 + 2 * a ^ 2 * log t + a ^ 2 * log t ^ 2) t := by ++ convert (hasDerivAt_id' t).mul l2 using 1; field_simp; ring ++ apply (l1.inv e1).congr_deriv ++ dsimp only [hh', pp, hh] ++ simp only [div_eq_mul_inv, inv_pow] ++ ring ++ ++theorem hh_continuous (a : ℝ) : ContinuousOn (hh a) (Ioi 0) := ++ fun t (ht : 0 < t) => (hh_deriv a ht.ne.symm).continuousAt.continuousWithinAt ++ ++theorem hh'_nonpos {a x : ℝ} (ha : a ∈ Ioo (-1) 1) : hh' a x ≤ 0 := by ++ have := pp_pos ha (log x) ++ simp only [hh', neg_mul, Left.neg_nonpos_iff, ge_iff_le] ++ positivity ++ ++theorem hh_antitone {a : ℝ} (ha : a ∈ Ioo (-1) 1) : AntitoneOn (hh a) (Ioi 0) := by ++ have l1 x (hx : x ∈ interior (Ioi 0)) : ++ HasDerivWithinAt (hh a) (hh' a x) (interior (Ioi 0)) x := by ++ have : x ≠ 0 := by contrapose! hx ; simp [hx] ++ exact (hh_deriv a this).hasDerivWithinAt ++ apply antitoneOn_of_hasDerivWithinAt_nonpos (convex_Ioi _) (hh_continuous _) l1 ++ (fun x _ => hh'_nonpos ha) ++ ++noncomputable def gg (x i : ℝ) : ℝ := 1 / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ++ ++theorem gg_of_hh {x : ℝ} (hx : x ≠ 0) (i : ℝ) : gg x i = x⁻¹ * hh (1 / (2 * π)) (i / x) := by ++ simp only [gg, hh] ++ field_simp ++ ++theorem gg_l1 {x : ℝ} (hx : 0 < x) (n : ℕ) : |gg x n| ≤ 1 / n := by ++ simp only [gg_of_hh hx.ne.symm, one_div, mul_inv_rev, abs_mul] ++ apply mul_le_mul le_rfl (hh_le _ _ (by positivity)) (by positivity) (by positivity) |>.trans ++ (le_of_eq ?_) ++ simp [abs_inv, abs_eq_self.mpr hx.le] ; field_simp ++ ++theorem gg_le_one (i : ℕ) : gg x i ≤ 1 := by ++ by_cases hi : i = 0 <;> simp only [gg, hi, CharP.cast_eq_zero, div_zero, one_div, mul_inv_rev, ++ zero_div, Real.log_zero, mul_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, ++ add_zero, inv_one, mul_one, zero_le_one] ++ have l1 : 1 ≤ (i : ℝ) := by simp ; omega ++ have l2 : 1 ≤ 1 + (π⁻¹ * 2⁻¹ * Real.log (↑i / x)) ^ 2 := by ++ simp only [le_add_iff_nonneg_right] ; positivity ++ rw [← mul_inv] ; apply inv_le_one_of_one_le₀ ; simpa using mul_le_mul l1 l2 zero_le_one (by simp) ++ ++theorem one_div_two_pi_mem_Ioo : 1 / (2 * π) ∈ Ioo (-1) 1 := by ++ constructor ++ · trans 0 ++ · linarith ++ · positivity ++ · rw [div_lt_iff₀ (by positivity)] ++ convert_to 1 * 1 < 2 * π ++ · simp ++ · simp ++ apply mul_lt_mul one_lt_two ?_ zero_lt_one zero_le_two ++ trans 2 ++ · exact one_le_two ++ · exact two_le_pi ++ ++theorem cancel_aux {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ ∑ i ∈ Finset.range n, f i * g i ≤ g (n - 1) * (C * n) + (C * (↑(n - 1 - 1) + 1) * g 0 ++ - C * (↑(n - 1 - 1) + 1) * g (n - 1) - ++ ((n - 1 - 1) • (C * g 0) - ∑ x ∈ Finset.range (n - 1 - 1), C * g (x + 1))) := by ++ have l1 (n : ℕ) : ++ (g n - g (n + 1)) * ∑ i ∈ Finset.range (n + 1), f i ≤ (g n - g (n + 1)) * (C * (n + 1)) := by ++ apply mul_le_mul le_rfl (by simpa only [cumsum, Nat.cast_add, Nat.cast_one] using hf' (n + 1)) ++ (Finset.sum_nonneg (fun i _ => hf i)) ?_ ++ simp only [sub_nonneg] ; apply hg' ; simp ++ have l2 (x : ℕ) : C * (↑(x + 1) + 1) - C * (↑x + 1) = C := by simp ; ring ++ have l3 (n : ℕ) : 0 ≤ cumsum f n := Finset.sum_nonneg (fun i _ => hf i) ++ convert_to ∑ i ∈ Finset.range n, (g i) • (f i) ≤ _ ++ · simp [mul_comm] ++ rw [Finset.sum_range_by_parts, sub_eq_add_neg, ← Finset.sum_neg_distrib] ++ simp_rw [← neg_smul, neg_sub, smul_eq_mul] ++ apply _root_.add_le_add ++ · exact mul_le_mul le_rfl (hf' n) (l3 n) (hg _) ++ · apply Finset.sum_le_sum (fun n _ => l1 n) |>.trans ++ convert_to ∑ i ∈ Finset.range (n - 1), (C * (↑i + 1)) • (g i - g (i + 1)) ≤ _ ++ · congr ; ext i ; simp ; ring ++ rw [Finset.sum_range_by_parts] ++ simp_rw [Finset.sum_range_sub', l2, smul_sub, smul_eq_mul, Finset.sum_sub_distrib, ++ Finset.sum_const, Finset.card_range] ++ apply le_of_eq ; ring_nf ++ ++theorem sum_range_succ (a : ℕ → ℝ) (n : ℕ) : ++ ∑ i ∈ Finset.range n, a (i + 1) = (∑ i ∈ Finset.range (n + 1), a i) - a 0 := by ++ have := Finset.sum_range_sub a n ++ rw [Finset.sum_sub_distrib, sub_eq_iff_eq_add] at this ++ rw [Finset.sum_range_succ, this] ; ring ++ ++theorem cancel_aux' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ ∑ i ∈ Finset.range n, f i * g i ≤ ++ C * n * g (n - 1) ++ + C * cumsum g (n - 1 - 1 + 1) ++ - C * (↑(n - 1 - 1) + 1) * g (n - 1) ++ := by ++ have := cancel_aux hf hg hf' hg' n ++ simp only [nsmul_eq_mul, ← Finset.mul_sum, sum_range_succ] at this ++ convert this using 1 ; unfold cumsum ; ring ++ ++theorem cancel_main {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) (hn : 2 ≤ n) : ++ cumsum (f * g) n ≤ C * cumsum g n := by ++ change (∑ i ∈ Finset.range n, f i * g i) ≤ C * cumsum g n ++ refine (cancel_aux' hf hg hf' hg' n).trans_eq ?_ ++ have hindex : n - 1 - 1 + 1 = n - 1 := by omega ++ have hcast : (n : ℝ) = ↑(n - 1) + 1 := by ++ exact_mod_cast (show n = (n - 1) + 1 by omega) ++ have hcast' : (↑(n - 1 - 1) : ℝ) + 1 = ↑(n - 1) := by ++ exact_mod_cast hindex ++ have hsum : cumsum g n = cumsum g (n - 1) + g (n - 1) := by ++ conv_lhs => rw [show n = (n - 1) + 1 by omega] ++ exact cumsum_succ (n - 1) ++ rw [hindex, hcast', hcast, hsum] ++ ring ++ ++theorem cancel_main' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hf0 : f 0 = 0) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ cumsum (f * g) n ≤ C * cumsum g n := by ++ cases n with ++ | zero => simp [cumsum] ++ | succ n => ++ cases n with ++ | zero => ++ have hC : 0 ≤ C := by simpa [cumsum, hf0] using hf' 1 ++ simpa [cumsum, hf0] using mul_nonneg hC (hg 0) ++ | succ n => exact cancel_main hf hg hf' hg' (n + 2) (by omega) ++ ++theorem sum_le_integral {x₀ : ℝ} {f : ℝ → ℝ} {n : ℕ} (hf : AntitoneOn f (Ioc x₀ (x₀ + n))) ++ (hfi : IntegrableOn f (Icc x₀ (x₀ + n))) : ++ (∑ i ∈ Finset.range n, f (x₀ + ↑(i + 1))) ≤ ∫ x in x₀..x₀ + n, f x := by ++ cases n with simp only [Nat.cast_add, Nat.cast_one, CharP.cast_eq_zero, add_zero, ++ lt_self_iff_false, not_false_eq_true, ++ Ioc_eq_empty, Finset.range_zero, Nat.cast_add, Nat.cast_one, Finset.sum_empty, ++ intervalIntegral.integral_same, le_refl] at hf ⊢ ++ | succ n => ++ have : Finset.range (n + 1) = {0} ∪ Finset.Ico 1 (n + 1) := by ++ ext i ; by_cases hi : i = 0 <;> simp [hi] ; omega ++ simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, ++ lt_add_iff_pos_left, add_pos_iff, zero_lt_one, or_true, and_true, not_false_eq_true, ++ Finset.sum_insert, CharP.cast_eq_zero, zero_add, ge_iff_le] ++ have l4 : IntervalIntegrable f volume x₀ (x₀ + 1) := by ++ apply IntegrableOn.intervalIntegrable ++ simp only [le_add_iff_nonneg_right, zero_le_one, uIcc_of_le] ++ apply hfi.mono_set ++ apply Icc_subset_Icc le_rfl ++ simp ++ have l5 x (hx : x ∈ Ioc x₀ (x₀ + 1)) : (fun x ↦ f (x₀ + 1)) x ≤ f x := by ++ rcases hx with ⟨hx1, hx2⟩ ++ refine hf ⟨hx1, by linarith⟩ ⟨by linarith, by linarith⟩ hx2 ++ have l6 : ∫ x in x₀..x₀ + 1, f (x₀ + 1) = f (x₀ + 1) := by simp ++ have l1 : f (x₀ + 1) ≤ ∫ x in x₀..x₀ + 1, f x := by ++ rw [← l6] ++ apply intervalIntegral.integral_mono_on_of_le_Ioo (by linarith) (by simp) l4 ++ intro x hx ++ exact l5 x ⟨hx.1, hx.2.le⟩ ++ have l2 : AntitoneOn (fun x ↦ f (x₀ + x)) (Icc 1 ↑(n + 1)) := by ++ intro u hu v hv huv ++ have hu1 := hu.1 ++ have hv2 := hv.2 ++ push_cast at hv2 ++ refine hf ⟨?_, ?_⟩ ⟨?_, ?_⟩ ?_ <;> linarith ++ have l3 := @AntitoneOn.sum_le_integral_Ico 1 (n + 1) (fun x => f (x₀ + x)) (by simp) ++ (by simpa using l2) ++ simp only [Nat.cast_add, Nat.cast_one, intervalIntegral.integral_comp_add_left] at l3 ++ convert _root_.add_le_add l1 l3 ++ have := @intervalIntegral.integral_comp_mul_add ℝ _ _ 1 (n + 1) 1 f one_ne_zero x₀ ++ rw [intervalIntegral.integral_add_adjacent_intervals] ++ · exact l4 ++ · apply IntegrableOn.intervalIntegrable ++ simp only [add_le_add_iff_left, le_add_iff_nonneg_left, Nat.cast_nonneg, uIcc_of_le] ++ apply hfi.mono_set ++ apply Icc_subset_Icc ++ · linarith ++ · simp ++ ++theorem hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ (IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0)) ∧ ++ (∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π) := by ++ rw [integrableOn_Ici_iff_integrableOn_Ioi] ++ simp only [hh] ++ let g (x : ℝ) := (a * c / b) * Real.arctan (b * log (x / c)) ++ let g₀ (x : ℝ) := if x = 0 then ((a * c / b) * (- (π / 2))) else g x ++ let g' (x : ℝ) := a * (x / c * (1 + (b * Real.log (x / c)) ^ 2))⁻¹ ++ have l3 (x) (hx : 0 < x) : HasDerivAt Real.log x⁻¹ x := by apply Real.hasDerivAt_log (by linarith) ++ have l4 (x) : HasDerivAt (fun t => t / c) (1 / c) x := (hasDerivAt_id x).div_const c ++ have l2 (x) (hx : 0 < x) : HasDerivAt (fun t => log (t / c)) x⁻¹ x := by ++ have hcomp := (l3 (x / c) (by positivity)).comp x (l4 x) ++ convert hcomp using 1 ++ · rfl ++ · field_simp [hc.ne', hx.ne'] ++ have l5 (x) (hx : 0 < x) := (l2 x hx).const_mul b ++ have l1 (x) (hx : 0 < x) := (l5 x hx).arctan ++ have l6 (x) (hx : 0 < x) : HasDerivAt g (g' x) x := by ++ convert (l1 x hx).const_mul (a * c / b) using 1 ++ simp only [g'] ++ field_simp ++ have key (x) (hx : 0 < x) : HasDerivAt g₀ (g' x) x := by ++ apply (l6 x hx).congr_of_eventuallyEq ++ apply eventually_of_mem <| Ioi_mem_nhds hx ++ intro y (hy : 0 < y) ++ simp [g₀, hy.ne.symm] ++ have k1 : Tendsto g₀ atTop (𝓝 ((a * c / b) * (π / 2))) := by ++ have : g =ᶠ[atTop] g₀ := by ++ apply eventually_of_mem (Ioi_mem_atTop 0) ++ intro y (hy : 0 < y) ++ simp [g₀, hy.ne.symm] ++ apply Tendsto.congr' this ++ apply Tendsto.const_mul ++ apply (tendsto_arctan_atTop.mono_right nhdsWithin_le_nhds).comp ++ apply Tendsto.const_mul_atTop hb ++ apply tendsto_log_atTop.comp ++ apply Tendsto.atTop_div_const hc ++ apply tendsto_id ++ have k2 : Tendsto g₀ (𝓝[>] 0) (𝓝 (g₀ 0)) := by ++ have : g =ᶠ[𝓝[>] 0] g₀ := by ++ apply eventually_of_mem self_mem_nhdsWithin ++ intro x (hx : 0 < x) ; simp [g₀, hx.ne.symm] ++ simp only [g₀] ++ apply Tendsto.congr' this ++ apply Tendsto.const_mul ++ apply (tendsto_arctan_atBot.mono_right nhdsWithin_le_nhds).comp ++ apply Tendsto.const_mul_atBot hb ++ apply tendsto_log_nhdsGT_zero.comp ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨c * ε, by positivity, fun x hx1 hx2 => ⟨?_, ?_⟩⟩ ++ · simp only [mem_Ioi] at hx1 ⊢ ; positivity ++ · simp only [dist_zero_right, norm_eq_abs, norm_div, abs_eq_self.mpr hc.le] at hx2 ⊢ ++ rwa [div_lt_iff₀ hc, mul_comm] ++ have k3 : ContinuousWithinAt g₀ (Ici 0) 0 := by ++ rw [Metric.continuousWithinAt_iff] ++ rw [Metric.tendsto_nhdsWithin_nhds] at k2 ++ intro ε hε ++ obtain ⟨δ, hδ, hδx⟩ := k2 ε hε ++ refine ⟨δ, hδ, ?_⟩ ++ intro x hx hdist ++ change 0 ≤ x at hx ++ rcases lt_or_eq_of_le hx with hx | hx ++ · exact hδx hx hdist ++ · subst x ++ simpa only [dist_self] using hε ++ have k4 : ∀ x ∈ Ioi 0, 0 ≤ g' x := by ++ intro x (hx : 0 < x) ; simp only [mul_inv_rev, inv_div, g'] ; positivity ++ constructor ++ · convert_to IntegrableOn g' _ ++ exact integrableOn_Ioi_deriv_of_nonneg k3 key k4 k1 ++ · have := integral_Ioi_of_hasDerivAt_of_nonneg k3 key k4 k1 ++ simp only [mul_inv_rev, inv_div, mul_neg, ↓reduceIte, sub_neg_eq_add, g', g₀] at this ⊢ ++ convert this using 1 ; field_simp ; ring ++ ++theorem hh_integrable (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0) := ++ hh_integrable_aux ha hb hc |>.1 ++ ++theorem hh_integral (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ ∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π := ++ hh_integrable_aux ha hb hc |>.2 ++ ++theorem hh_integral' : ∫ t in Ioi 0, hh (1 / (2 * π)) t = 2 * π ^ 2 := by ++ have := hh_integral (a := 1) (b := 1 / (2 * π)) (c := 1) ++ (by positivity) (by positivity) (by positivity) ++ convert this using 1 <;> simp ; ring ++ ++theorem bound_sum_log {C : ℝ} (hf0 : f 0 = 0) ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ ++ C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by ++ let ggg (i : ℕ) : ℝ := if i = 0 then 1 else gg x i ++ have l0 : x ≠ 0 := by linarith ++ have l1 i : 0 ≤ ggg i := by by_cases hi : i = 0 <;> simp only [gg, one_div, mul_inv_rev, hi, ++ ↓reduceIte, zero_le_one, ggg] ; positivity ++ have l2 : Antitone ggg := by ++ intro i j hij ; by_cases hi : i = 0 <;> by_cases hj : j = 0 <;> simp only [hj, ↓reduceIte, hi, ++ le_refl, ggg] ++ · exact gg_le_one _ ++ · omega ++ · simp only [gg_of_hh l0] ++ gcongr ++ apply hh_antitone one_div_two_pi_mem_Ioo ++ · simp only [mem_Ioi] ; positivity ++ · simp only [mem_Ioi] ; positivity ++ · gcongr ++ have l3 : 0 ≤ C := by simpa [cumsum, hf0] using hf 1 ++ have l4 : 0 ≤ ∫ (t : ℝ) in Ioi 0, hh (π⁻¹ * 2⁻¹) t := ++ setIntegral_nonneg measurableSet_Ioi (fun x hx => hh_nonneg _ (LT.lt.le hx)) ++ have l5 {n : ℕ} : AntitoneOn (fun t ↦ x⁻¹ * hh (1 / (2 * π)) (t / x)) (Ioc 0 n) := by ++ intro u hu v hv huv ++ have hu1 := hu.1 ++ have hv1 := hv.1 ++ simp only ++ apply mul_le_mul le_rfl ?_ (hh_nonneg _ (by positivity)) (by positivity) ++ apply hh_antitone one_div_two_pi_mem_Ioo (by simp only [mem_Ioi] ; positivity) ++ (by simp only [mem_Ioi] ; positivity) ++ apply (div_le_div_iff_of_pos_right (by positivity)).mpr huv ++ have l6 {n : ℕ} : IntegrableOn (fun t ↦ x⁻¹ * hh (π⁻¹ * 2⁻¹) (t / x)) (Icc 0 n) volume := by ++ apply IntegrableOn.mono_set ++ (hh_integrable (by positivity) (by positivity) (by positivity)) Icc_subset_Ici_self ++ apply Real.tsum_le_of_sum_range_le (fun n => by positivity) ; intro n ++ convert_to ∑ i ∈ Finset.range n, ‖f i‖ * ggg i ≤ _ ++ · congr ; ext i ++ by_cases hi : i = 0 ++ · simp [hi, hf0] ++ · simp only [gg, hi, ↓reduceIte, ggg] ++ field_simp ++ apply cancel_main' (fun _ => norm_nonneg _) (by simp [hf0]) l1 hf l2 n |>.trans ++ gcongr ; simp only [cumsum, gg_of_hh l0, one_div, mul_inv_rev, ggg] ++ by_cases hn : n = 0 ++ · simp only [hn, Finset.range_zero, Finset.sum_empty] ; positivity ++ replace hn : 0 < n := by omega ++ have : Finset.range n = {0} ∪ Finset.Ico 1 n := by ++ ext i ; simp ; by_cases hi : i = 0 <;> simp [hi, hn] ; omega ++ simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, ++ false_and, not_false_eq_true, Finset.sum_insert, ↓reduceIte, add_le_add_iff_left, ge_iff_le] ++ convert_to ∑ x_1 ∈ Finset.Ico 1 n, x⁻¹ * hh (π⁻¹ * 2⁻¹) (↑x_1 / x) ≤ _ ++ · apply Finset.sum_congr rfl (fun i hi => ?_) ++ simp at hi ++ have : i ≠ 0 := by omega ++ simp [this] ++ simp_rw [Finset.sum_Ico_eq_sum_range, add_comm 1] ++ have := @sum_le_integral 0 (fun t => x⁻¹ * hh (π⁻¹ * 2⁻¹) (t / x)) (n - 1) ++ (by simpa using l5) (by simpa using l6) ++ simp only [zero_add] at this ++ apply this.trans ++ rw [@intervalIntegral.integral_comp_div ℝ _ _ 0 ↑(n - 1) x (fun t => x⁻¹ * hh (π⁻¹ * 2⁻¹) (t)) l0] ++ simp only [zero_div, intervalIntegral.integral_const_mul, smul_eq_mul, ← mul_assoc, ++ mul_inv_cancel₀ l0, one_mul] ++ have : (0 : ℝ) ≤ ↑(n - 1) / x := by positivity ++ rw [intervalIntegral.intervalIntegral_eq_integral_uIoc] ++ simp only [this, ↓reduceIte, uIoc_of_le, smul_eq_mul, one_mul, ge_iff_le] ++ apply integral_mono_measure ++ · apply Measure.restrict_mono Ioc_subset_Ioi_self le_rfl ++ · apply eventually_of_mem (self_mem_ae_restrict measurableSet_Ioi) ++ intro x (hx : 0 < x) ++ apply hh_nonneg _ hx.le ++ · have h := (@hh_integrable 1 (1 / (2 * π)) 1 (by positivity) (by positivity) (by positivity)) ++ have h' := h.mono_set Ioi_subset_Ici_self ++ unfold IntegrableOn at h' ++ apply h'.congr ++ exact Eventually.of_forall (fun t => by simp) ++ ++theorem bound_sum_log0 {C : ℝ} ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ ++ C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by ++ let f0 i := if i = 0 then 0 else f i ++ have l1 : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f0 k : ℂ)‖) n ≤ C * n) := by ++ intro n ; refine Finset.sum_le_sum (fun i _ => ?_) |>.trans (hf n) ++ by_cases hi : i = 0 <;> simp [hi, f0] ++ have l2 i : ‖f i‖ / i = ‖f0 i‖ / i := by by_cases hi : i = 0 <;> simp [hi, f0] ++ simp_rw [l2] ; apply bound_sum_log rfl l1 hx ++ ++theorem bound_sum_log' {C : ℝ} ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ C * (1 + 2 * π ^ 2) := by ++ simpa only [hh_integral'] using bound_sum_log0 hf hx ++ ++variable (f x) in ++theorem summable_fourier_aux (ψ : W21) (i : ℕ) : ++ ‖f i / i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (i / x))‖ ≤ ++ W21.norm ψ * (‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹) := by ++ convert mul_le_mul_of_nonneg_left (decay_bounds_key ψ (1 / (2 * π) * log (i / x))) ++ (norm_nonneg (f i / i)) using 1 ++ · simp ++ · change _ = _ * (W21.norm ψ * _) ++ simp only [W21.norm, mul_inv_rev, one_div, Complex.norm_div, RCLike.norm_natCast] ++ ring ++ ++theorem summable_fourier (x : ℝ) (hx : 0 < x) (ψ : W21) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by ++ have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by ++ simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) ++ have l6 := summable_fourier_aux x f ψ ++ exact Summable.of_nonneg_of_le (fun _ => norm_nonneg _) l6 ++ (by simpa using l5.const_smul (W21.norm ψ)) ++ ++theorem bound_I1 (x : ℝ) (hx : 0 < x) (ψ : W21) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ ++ W21.norm ψ • ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ := by ++ have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by ++ simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) ++ have l6 := summable_fourier_aux x f ψ ++ have l1 : Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by ++ exact summable_fourier x hx ψ hcheby ++ apply (norm_tsum_le_tsum_norm l1).trans ++ change (∑' i, ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) ++ (1 / (2 * π) * Real.log (↑i / x))‖) ≤ W21.norm ψ * _ ++ rw [← tsum_mul_left] ++ exact Summable.tsum_mono l1 (l5.mul_left (W21.norm ψ)) l6 ++ ++theorem bound_I1' {C : ℝ} (x : ℝ) (hx : 1 ≤ x) (ψ : W21) ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ ++ W21.norm ψ * C * (1 + 2 * π ^ 2) := by ++ apply bound_I1 x (by linarith) ψ ⟨_, hcheby⟩ |>.trans ++ rw [smul_eq_mul, mul_assoc] ++ apply mul_le_mul le_rfl (bound_sum_log' hcheby hx) ?_ W21.norm_nonneg ++ apply tsum_nonneg (fun i => by positivity) ++ ++theorem bound_I2 (x : ℝ) (ψ : W21) : ++ ‖∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ W21.norm ψ * (2 * π ^ 2) := by ++ have key a : ‖𝓕 (ψ : ℝ → ℂ) (a / (2 * π))‖ ≤ W21.norm ψ * (1 + (a / (2 * π)) ^ 2)⁻¹ := ++ decay_bounds_key ψ _ ++ have twopi : 0 ≤ 2 * π := by simp [pi_nonneg] ++ have l3 : Integrable (fun a ↦ (1 + (a / (2 * π)) ^ 2)⁻¹) := ++ integrable_inv_one_add_sq.comp_div (by norm_num [pi_ne_zero]) ++ have l2 : IntegrableOn (fun i ↦ W21.norm ψ * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-Real.log x)) := by ++ exact (l3.const_mul _).integrableOn ++ have l1 : IntegrableOn (fun i ↦ ‖𝓕 (ψ : ℝ → ℂ) (i / (2 * π))‖) (Ici (-Real.log x)) := by ++ refine ((l3.const_mul (W21.norm ψ)).mono' ?_ ?_).integrableOn ++ · apply Continuous.aestronglyMeasurable ; fun_prop ++ · simp only [norm_norm, key] ; simp ++ have l5 : 0 ≤ᵐ[volume] fun a ↦ (1 + (a / (2 * π)) ^ 2)⁻¹ := by ++ apply Eventually.of_forall ; intro x ; positivity ++ refine (norm_integral_le_integral_norm _).trans <| (setIntegral_mono l1 l2 key).trans ?_ ++ rw [integral_const_mul] ; gcongr ++ · apply W21.norm_nonneg ++ refine (setIntegral_le_integral l3 l5).trans ?_ ++ rw [Measure.integral_comp_div (fun x => (1 + x ^ 2)⁻¹) (2 * π)] ++ simp [abs_eq_self.mpr twopi] ; ring_nf ; rfl ++ ++theorem bound_main {C : ℝ} (A : ℂ) (x : ℝ) (hx : 1 ≤ x) (ψ : W21) ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ ++ W21.norm ψ * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2)) := by ++ have l1 := bound_I1' x hx ψ hcheby ++ have l2 := mul_le_mul (le_refl ‖A‖) (bound_I2 x ψ) (by positivity) (by positivity) ++ apply norm_sub_le _ _ |>.trans ; rw [norm_mul] ++ convert _root_.add_le_add l1 l2 using 1 ; ring ++ ++theorem limiting_cor_W21 (ψ : W21) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by ++ ++ let S1 x (ψ : ℝ → ℂ) := ∑' (n : ℕ), f n / ↑n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑n / x)) ++ let S2 x (ψ : ℝ → ℂ) := ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) ++ let S x ψ := S1 x ψ - S2 x ψ ; change Tendsto (fun x ↦ S x ψ) atTop (𝓝 0) ++ ++ obtain g := compactTruncation ++ let Ψ R := g.scale R * ψ ++ have key R : Tendsto (fun x ↦ S x (Ψ R)) atTop (𝓝 0) := limiting_cor (Ψ R) hf hcheby hG hG' ++ ++ obtain ⟨C, hcheby⟩ := hcheby ++ have hC : 0 ≤ C := by ++ have : ‖f 0‖ ≤ C := by simpa [cumsum] using hcheby 1 ++ have : 0 ≤ ‖f 0‖ := by positivity ++ linarith ++ have key2 : Tendsto (fun R ↦ W21.norm (ψ - Ψ R)) atTop (𝓝 0) := W21_approximation ψ g ++ simp_rw [Metric.tendsto_nhds] at key key2 ⊢ ; intro ε hε ++ let M := C * (1 + 2 * π ^ 2) + ‖(A : ℂ)‖ * (2 * π ^ 2) ++ obtain ⟨R, hRψ⟩ := (key2 ((ε / 2) / (1 + M)) (by positivity)).exists ++ simp only [dist_zero_right, Real.norm_eq_abs, abs_eq_self.mpr W21.norm_nonneg] at hRψ key ++ ++ filter_upwards [eventually_ge_atTop 1, key R (ε / 2) (by positivity)] with x hx key ++ ++ have key3 : ‖S x (ψ - Ψ R)‖ < ε / 2 := by ++ have hbound := @bound_main f C A x hx (ψ - Ψ R) hcheby ++ change ‖S x (⇑ψ - ⇑(Ψ R))‖ ≤ W21.norm (⇑ψ - ⇑(Ψ R)) * M at hbound ++ apply hbound.trans_lt ++ calc ++ W21.norm (⇑ψ - ⇑(Ψ R)) * M ≤ W21.norm (⇑ψ - ⇑(Ψ R)) * (1 + M) := ++ mul_le_mul_of_nonneg_left (by linarith) W21.norm_nonneg ++ _ < ε / 2 := (lt_div_iff₀ (show 0 < 1 + M by positivity)).mp hRψ ++ ++ have S1_sub_1 x : 𝓕 (⇑ψ - ⇑(Ψ R)) x = 𝓕 (ψ : ℝ → ℂ) x - 𝓕 ⇑(Ψ R) x := ++ F_sub ψ.hf (Ψ R : W21).hf x ++ have S1_sub : S1 x (ψ - Ψ R) = S1 x ψ - S1 x (Ψ R) := by ++ simp only [one_div, mul_inv_rev, S1_sub_1, mul_sub, S1] ; apply Summable.tsum_sub ++ · have := summable_fourier x (by positivity) ψ ⟨_, hcheby⟩ ++ rw [summable_norm_iff] at this ++ simpa using this ++ · have hsum := summable_fourier x (by positivity) (Ψ R : W21) ⟨_, hcheby⟩ ++ rw [summable_norm_iff] at hsum ++ simpa only [W21.ofCS2, one_div, mul_inv_rev] using hsum ++ have S2_sub : S2 x (ψ - Ψ R) = S2 x ψ - S2 x (Ψ R) := by ++ simp only [S1_sub_1, S2] ; rw [integral_sub] ++ · ring ++ · exact CatalanPNT.W21.integrable_fourier ψ (by positivity) |>.restrict ++ · exact CatalanPNT.W21.integrable_fourier (Ψ R : W21) (by positivity) |>.restrict ++ have S_sub : S x (ψ - Ψ R) = S x ψ - S x (Ψ R) := by simp [S, S1_sub, S2_sub] ; ring ++ simpa [S_sub, Ψ] using norm_add_le _ _ |>.trans_lt (_root_.add_lt_add key3 key) ++ ++end CatalanPNT +diff --git a/PrimeNumberTheoremAnd/Catalan/WienerFourier.lean b/PrimeNumberTheoremAnd/Catalan/WienerFourier.lean +new file mode 100644 +index 0000000..491332b +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan/WienerFourier.lean +@@ -0,0 +1,332 @@ ++import Mathlib.Analysis.Fourier.RiemannLebesgueLemma ++import Mathlib.Analysis.Normed.Group.Tannery ++import Mathlib.Analysis.SumIntegralComparisons ++import Mathlib.NumberTheory.Chebyshev ++import PrimeNumberTheoremAnd.Catalan.OrdinaryZetaContinuation ++import Mathlib.NumberTheory.MulChar.Lemmas ++import PrimeNumberTheoremAnd.ZetaFive.Fourier ++import PrimeNumberTheoremAnd.ZetaFive.SmoothExistence ++import Mathlib.Analysis.Convolution ++import Mathlib.MeasureTheory.Group.Circle ++ ++namespace CatalanPNT ++ ++open ZetaFivePNT ++ ++open Real BigOperators ArithmeticFunction MeasureTheory Filter Set FourierTransform LSeries ++ Asymptotics SchwartzMap ++open Complex hiding log ++open scoped Topology ++open scoped ContDiff ++open scoped ComplexConjugate ++ ++variable {n : ℕ} {A a b c d u x y t σ' : ℝ} {ψ Ψ : ℝ → ℂ} {F G : ℂ → ℂ} {f : ℕ → ℂ} {𝕜 : Type} ++ [RCLike 𝕜] ++ ++noncomputable ++def nterm (f : ℕ → ℂ) (σ' : ℝ) (n : ℕ) : ℝ := if n = 0 then 0 else ‖f n‖ / n ^ σ' ++ ++theorem nterm_eq_norm_term {f : ℕ → ℂ} : nterm f σ' n = ‖term f σ' n‖ := by ++ by_cases h : n = 0 <;> simp [nterm, term, h] ++ ++theorem norm_term_eq_nterm_re (s : ℂ) : ++ ‖term f s n‖ = nterm f (s.re) n := by ++ simpa only [nterm] using LSeries.norm_term_eq f s n ++ ++theorem hf_coe1 (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hσ : 1 < σ') : ++ ∑' i, (‖term f σ' i‖₊ : ENNReal) ≠ ⊤ := by ++ simp_rw [ENNReal.tsum_coe_ne_top_iff_summable_coe, ← norm_toNNReal] ++ norm_cast ++ apply Summable.toNNReal ++ convert hf σ' hσ with i ++ simp [nterm_eq_norm_term] ++ ++attribute [fun_prop] Real.continuous_fourierChar ++ ++theorem first_fourier_aux1 (hψ : AEMeasurable ψ) {x : ℝ} (n : ℕ) : AEMeasurable fun (u : ℝ) ↦ ++ (‖fourierChar (-(u * ((1 : ℝ) / ((2 : ℝ) * π) * (n / x).log))) • ψ u‖ₑ : ENNReal) := by ++ fun_prop ++ ++theorem first_fourier_aux2a : ++ (2 : ℂ) * π * -(y * (1 / (2 * π) * Real.log ((n) / x))) = -(y * ((n) / x).log) := by ++ calc ++ _ = -(y * (((2 : ℂ) * π) / (2 * π) * Real.log ((n) / x))) := by ring ++ _ = _ := by rw [div_self (by norm_num), one_mul] ++ ++theorem first_fourier_aux2 (hx : 0 < x) (n : ℕ) : ++ term f σ' n * 𝐞 (-(y * (1 / (2 * π) * Real.log (n / x)))) • ψ y = ++ term f (σ' + y * I) n • (ψ y * x ^ (y * I)) := by ++ by_cases hn : n = 0 ++ · simp [term, hn] ++ simp only [term, hn, ↓reduceIte] ++ calc ++ _ = (f n * (cexp ((2 * π * -(y * (1 / (2 * π) * Real.log (n / x)))) * I) / ++ ↑((n : ℝ) ^ σ'))) • ψ y := by ++ rw [Circle.smul_def, fourierChar_apply, ofReal_cpow (by norm_num)] ++ simp only [one_div, mul_inv_rev, mul_neg, ofReal_neg, ofReal_mul, ofReal_ofNat, ofReal_inv, ++ neg_mul, smul_eq_mul, ofReal_natCast] ++ ring ++ _ = (f n * (x ^ (y * I) / n ^ (σ' + y * I))) • ψ y := by ++ congr 2 ++ have l1 : 0 < (n : ℝ) := by simpa using Nat.pos_iff_ne_zero.mpr hn ++ have l2 : (x : ℂ) ≠ 0 := by simp [hx.ne.symm] ++ have l3 : (n : ℂ) ≠ 0 := by simp [hn] ++ rw [Real.rpow_def_of_pos l1, Complex.cpow_def_of_ne_zero l2, Complex.cpow_def_of_ne_zero l3] ++ push_cast ++ simp_rw [← Complex.exp_sub] ++ congr 1 ++ rw [first_fourier_aux2a, Real.log_div l1.ne.symm hx.ne.symm] ++ push_cast ++ rw [Complex.ofReal_log hx.le] ++ ring ++ _ = _ := by simp ; group ++ ++theorem first_fourier (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hsupp : Integrable ψ) (hx : 0 < x) (hσ : 1 < σ') : ++ ∑' n : ℕ, term f σ' n * (𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))) = ++ ∫ t : ℝ, LSeries f (σ' + t * I) * ψ t * x ^ (t * I) := by ++ calc ++ _ = ∑' n, term f σ' n * ∫ (v : ℝ), 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ simp only [Real.fourier_eq] ++ simp only [one_div, mul_inv_rev, RCLike.inner_apply', conj_trivial] ++ _ = ∑' n, ∫ (v : ℝ), term f σ' n * 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ simp [integral_const_mul] ++ _ = ∫ (v : ℝ), ∑' n, term f σ' n * 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ refine (integral_tsum ?_ ?_).symm ++ · refine fun _ ↦ AEMeasurable.aestronglyMeasurable ?_ ++ have := hsupp.aemeasurable ++ fun_prop ++ · simp only [enorm_mul] ++ simp_rw [lintegral_const_mul'' _ (first_fourier_aux1 hsupp.aemeasurable _)] ++ calc ++ _ = (∑' (i : ℕ), ‖term f σ' i‖ₑ) * ∫⁻ (a : ℝ), ‖ψ a‖ₑ ∂volume := by ++ simp [ENNReal.tsum_mul_right, enorm_eq_nnnorm] ++ _ ≠ ⊤ := ENNReal.mul_ne_top (hf_coe1 hf hσ) ++ (ne_top_of_lt hsupp.2) ++ _ = _ := by ++ congr 1; ext y ++ simp_rw [mul_assoc (LSeries _ _), ← smul_eq_mul (a := (LSeries _ _)), LSeries] ++ rw [← Summable.tsum_smul_const] ++ · simp_rw [first_fourier_aux2 hx] ++ · apply Summable.of_norm ++ convert hf σ' hσ with n ++ rw [norm_term_eq_nterm_re] ++ simp ++ ++@[continuity] ++theorem continuous_multiplicative_ofAdd : Continuous (⇑Multiplicative.ofAdd : ℝ → ℝ) := ⟨fun _ ↦ id⟩ ++ ++attribute [fun_prop] measurable_coe_nnreal_ennreal ++ ++theorem second_fourier_integrable_aux1a (hσ : 1 < σ') : ++ IntegrableOn (fun (x : ℝ) ↦ cexp (-((x : ℂ) * ((σ' : ℂ) - 1)))) (Ici (-Real.log x)) := by ++ norm_cast ++ suffices IntegrableOn (fun (x : ℝ) ↦ (rexp (-(x * (σ' - 1))))) (Ici (-x.log)) _ from this.ofReal ++ simp_rw [fun (a x : ℝ) ↦ (by ring : -(x * a) = -a * x)] ++ rw [integrableOn_Ici_iff_integrableOn_Ioi] ++ apply exp_neg_integrableOn_Ioi ++ linarith ++ ++theorem second_fourier_integrable_aux1 (hcont : Measurable ψ) (hsupp : Integrable ψ) (hσ : 1 < σ') : ++ let ν : Measure (ℝ × ℝ) := (volume.restrict (Ici (-Real.log x))).prod volume ++ Integrable (Function.uncurry fun (u : ℝ) (a : ℝ) ↦ ((rexp (-u * (σ' - 1))) : ℂ) • ++ (𝐞 (Multiplicative.ofAdd (-(a * (u / (2 * π))))) : ℂ) • ψ a) ν := by ++ intro ν ++ constructor ++ · apply Measurable.aestronglyMeasurable ++ change Measurable (fun p : ℝ × ℝ => ++ (rexp (-p.1 * (σ' - 1)) : ℂ) * ++ ((fourierChar (-(p.2 * (p.1 / (2 * π)))) : ℂ) * ψ p.2)) ++ fun_prop ++ · let f1 : ℝ → ENNReal := fun a1 ↦ ‖cexp (-(↑a1 * (↑σ' - 1)))‖ₑ ++ let f2 : ℝ → ENNReal := fun a2 ↦ ‖ψ a2‖ₑ ++ suffices ∫⁻ (a : ℝ × ℝ), f1 a.1 * f2 a.2 ∂ν < ⊤ by ++ simpa [hasFiniteIntegral_iff_enorm, enorm_eq_nnnorm, Function.uncurry] ++ refine (lintegral_prod_mul ?_ ?_).trans_lt ?_ <;> try fun_prop ++ exact ENNReal.mul_lt_top (second_fourier_integrable_aux1a hσ).2 hsupp.2 ++ ++theorem second_fourier_integrable_aux2 (hσ : 1 < σ') : ++ IntegrableOn (fun (u : ℝ) ↦ cexp ((1 - ↑σ' - ↑t * I) * ↑u)) (Ioi (-Real.log x)) := by ++ refine (integrable_norm_iff (Measurable.aestronglyMeasurable <| by fun_prop)).mp ?_ ++ suffices IntegrableOn (fun a ↦ rexp (-(σ' - 1) * a)) (Ioi (-x.log)) _ by simpa [Complex.norm_exp] ++ apply exp_neg_integrableOn_Ioi ++ linarith ++ ++theorem second_fourier_aux (hx : 0 < x) : ++ -(cexp (-((1 - ↑σ' - ↑t * I) * ↑(Real.log x))) / (1 - ↑σ' - ↑t * I)) = ++ ↑(x ^ (σ' - 1)) * (↑σ' + ↑t * I - 1)⁻¹ * ↑x ^ (↑t * I) := by ++ calc ++ _ = cexp (↑(Real.log x) * ((↑σ' - 1) + ↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [← div_neg]; ring_nf ++ _ = (x ^ ((↑σ' - 1) + ↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [Complex.cpow_def_of_ne_zero (ofReal_ne_zero.mpr (ne_of_gt hx)), Complex.ofReal_log hx.le] ++ _ = (x ^ ((σ' : ℂ) - 1)) * (x ^ (↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [Complex.cpow_add _ _ (ofReal_ne_zero.mpr (ne_of_gt hx))] ++ _ = _ := by rw [ofReal_cpow hx.le]; push_cast; ring ++ ++theorem second_fourier (hcont : Measurable ψ) (hsupp : Integrable ψ) ++ {x σ' : ℝ} (hx : 0 < x) (hσ : 1 < σ') : ++ ∫ u in Ici (-log x), Real.exp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ (x^(σ' - 1) : ℝ) * ∫ t, (1 / (σ' + t * I - 1)) * ψ t * x^(t * I) ∂ volume := by ++ conv in ↑(rexp _) * _ => { rw [Real.fourier_real_eq, ← smul_eq_mul, ← integral_smul] } ++ rw [MeasureTheory.integral_integral_swap] ++ swap ++ · exact second_fourier_integrable_aux1 hcont hsupp hσ ++ rw [← integral_const_mul] ++ congr 1; ext t ++ simp_rw [Circle.smul_def, smul_eq_mul, Real.fourierChar_apply, ++ ← mul_assoc, integral_mul_const] ++ rw [mul_right_comm _ (ψ t) _] ++ congr 1 ++ push_cast ++ simp_rw [← Complex.exp_add] ++ have (u : ℝ) : ++ -↑u * (↑σ' - 1) + 2 * ↑π * -(↑t * (↑u / (2 * ↑π))) * I = (1 - σ' - t * I) * u := calc ++ _ = -↑u * (↑σ' - 1) + (2 * ↑π) / (2 * ↑π) * -(↑t * ↑u) * I := by ring ++ _ = -↑u * (↑σ' - 1) + 1 * -(↑t * ↑u) * I := by rw [div_self (by norm_num)] ++ _ = _ := by ring ++ simp_rw [this] ++ let c : ℂ := (1 - ↑σ' - ↑t * I) ++ have : c ≠ 0 := by simp [Complex.ext_iff, c, sub_ne_zero.mpr hσ.ne] ++ let f' (u : ℝ) := cexp (c * u) ++ let f := fun (u : ℝ) ↦ (f' u) / c ++ have hderiv : ∀ u ∈ Ici (-Real.log x), HasDerivAt f (f' u) u := by ++ intro u _ ++ rw [show f' u = cexp (c * u) * (c * 1) / c by simp only [f']; field_simp] ++ exact (hasDerivAt_id' u).ofReal_comp.const_mul c |>.cexp.div_const c ++ have hf : Tendsto f atTop (𝓝 0) := by ++ apply tendsto_zero_iff_norm_tendsto_zero.mpr ++ suffices Tendsto (fun (x : ℝ) ↦ ‖cexp (c * ↑x)‖ / ‖c‖) atTop (𝓝 (0 / ‖c‖)) by ++ simpa [f, f'] using this ++ apply Filter.Tendsto.div_const ++ suffices Tendsto (· * (1 - σ')) atTop atBot by simpa [Complex.norm_exp, mul_comm (1 - σ'), c] ++ exact Tendsto.atTop_mul_const_of_neg (by linarith) fun ⦃s⦄ h ↦ h ++ rw [integral_Ici_eq_integral_Ioi, ++ integral_Ioi_of_hasDerivAt_of_tendsto' hderiv (second_fourier_integrable_aux2 hσ) hf] ++ simpa [f, f'] using second_fourier_aux hx ++ ++theorem one_add_sq_pos (u : ℝ) : 0 < 1 + u ^ 2 := zero_lt_one.trans_le (by simpa using sq_nonneg u) ++ ++theorem decay_bounds_key (f : W21) (u : ℝ) : ‖𝓕 (f : ℝ → ℂ) u‖ ≤ ‖f‖ * (1 + u ^ 2)⁻¹ := by ++ have l1 : 0 < 1 + u ^ 2 := one_add_sq_pos _ ++ have l2 : 1 + u ^ 2 = ‖(1 : ℂ) + u ^ 2‖ := by ++ norm_cast ; simp only [Real.norm_eq_abs, abs_eq_self.2 l1.le] ++ have l3 : ‖1 / ((4 : ℂ) * ↑π ^ 2)‖ ≤ (4 * π ^ 2)⁻¹ := by simp ++ have key := fourierIntegral_self_add_deriv_deriv f u ++ simp only [Function.iterate_succ _ 1, Function.iterate_one, Function.comp_apply] at key ++ rw [F_sub f.hf (f.hf''.const_mul (1 / (4 * ↑π ^ 2)))] at key ++ rw [← div_eq_mul_inv, le_div_iff₀ l1, mul_comm, l2, ← norm_mul, key, sub_eq_add_neg] ++ apply norm_add_le _ _ |>.trans ++ change _ ≤ W21.norm _ ++ rw [norm_neg, F_mul, norm_mul, W21.norm] ++ gcongr <;> apply VectorFourier.norm_fourierIntegral_le_integral_norm ++ ++theorem decay_bounds_aux {f : ℝ → ℂ} (hf : AEStronglyMeasurable f volume) ++ (h : ∀ t, ‖f t‖ ≤ A * (1 + t ^ 2)⁻¹) : ++ ∫ t, ‖f t‖ ≤ π * A := by ++ have l1 : Integrable (fun x ↦ A * (1 + x ^ 2)⁻¹) := integrable_inv_one_add_sq.const_mul A ++ simp_rw [← integral_univ_inv_one_add_sq, mul_comm, ← integral_const_mul] ++ exact integral_mono (l1.mono' hf (Eventually.of_forall h)).norm l1 h ++ ++theorem decay_bounds_W21 (f : W21) (hA : ∀ t, ‖f t‖ ≤ A / (1 + t ^ 2)) ++ (hA' : ∀ t, ‖deriv (deriv f) t‖ ≤ A / (1 + t ^ 2)) (u) : ++ ‖𝓕 (f : ℝ → ℂ) u‖ ≤ (π + 1 / (4 * π)) * A / (1 + u ^ 2) := by ++ have l0 : 1 * (4 * π)⁻¹ * A = (4 * π ^ 2)⁻¹ * (π * A) := by field_simp ++ have l1 : ∫ (v : ℝ), ‖f v‖ ≤ π * A := by ++ apply decay_bounds_aux f.continuous.aestronglyMeasurable ++ simp_rw [← div_eq_mul_inv] ; exact hA ++ have l2 : ∫ (v : ℝ), ‖deriv (deriv f) v‖ ≤ π * A := by ++ apply decay_bounds_aux f.deriv.deriv.continuous.aestronglyMeasurable ++ simp_rw [← div_eq_mul_inv] ; exact hA' ++ apply decay_bounds_key f u |>.trans ++ change W21.norm _ * _ ≤ _ ++ simp_rw [W21.norm, div_eq_mul_inv, add_mul, l0] ; gcongr ++ ++theorem decay_bounds (ψ : CS 2 ℂ) (hA : ∀ t, ‖ψ t‖ ≤ A / (1 + t ^ 2)) ++ (hA' : ∀ t, ‖deriv^[2] ψ t‖ ≤ A / (1 + t ^ 2)) : ++ ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ (π + 1 / (4 * π)) * A / (1 + u ^ 2) := by ++ exact decay_bounds_W21 ψ hA hA' u ++ ++theorem decay_bounds_cor_aux (ψ : CS 2 ℂ) : ∃ C : ℝ, ∀ u, ‖ψ u‖ ≤ C / (1 + u ^ 2) := by ++ have l1 : HasCompactSupport (fun u : ℝ => ((1 + u ^ 2) : ℝ) * ψ u) := by exact ψ.h2.mul_left ++ have := ψ.h1.continuous ++ obtain ⟨C, hC⟩ := l1.exists_bound_of_continuous (by fun_prop) ++ refine ⟨C, fun u => ?_⟩ ++ specialize hC u ++ simp only [norm_mul, Complex.norm_real, norm_of_nonneg (one_add_sq_pos u).le] at hC ++ rwa [le_div_iff₀' (one_add_sq_pos _)] ++ ++theorem decay_bounds_cor (ψ : W21) : ++ ∃ C : ℝ, ∀ u, ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by ++ simpa only [div_eq_mul_inv] using ⟨_, decay_bounds_key ψ⟩ ++ ++@[continuity, fun_prop] theorem continuous_FourierIntegral (ψ : W21) : Continuous (𝓕 (ψ : ℝ → ℂ)) := ++ VectorFourier.fourierIntegral_continuous continuous_fourierChar ++ (by simp only [innerₗ_apply_apply, RCLike.inner_apply', conj_trivial, continuous_mul]) ++ ψ.hf ++ ++theorem W21.integrable_fourier (ψ : W21) (hc : c ≠ 0) : ++ Integrable fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c) := by ++ have l1 (C) : Integrable (fun u ↦ C / (1 + (u / c) ^ 2)) volume := by ++ simpa only [div_eq_mul_inv] using (integrable_inv_one_add_sq.comp_div hc).const_mul C ++ have l2 : AEStronglyMeasurable (fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c)) volume := by ++ apply Continuous.aestronglyMeasurable ; fun_prop ++ obtain ⟨C, h⟩ := decay_bounds_cor ψ ++ apply @Integrable.mono' ℝ ℂ _ volume _ _ (fun u => C / (1 + (u / c) ^ 2)) (l1 C) l2 ?_ ++ apply Eventually.of_forall (fun x => h _) ++ ++theorem continuous_LSeries_aux (hf : Summable (nterm f σ')) : ++ Continuous fun x : ℝ => LSeries f (σ' + x * I) := by ++ have l1 i : Continuous fun x : ℝ ↦ term f (σ' + x * I) i := by ++ by_cases h : i = 0 ++ · simpa [h] using continuous_const ++ · simpa [h] using continuous_const.div₀ (continuous_const.cpow (by fun_prop) (by simp [h])) ++ (fun x => by simp [h]) ++ have l2 n (x : ℝ) : ‖term f (σ' + x * I) n‖ = nterm f σ' n := by ++ simpa using norm_term_eq_nterm_re (f := f) (n := n) (σ' + x * I) ++ exact continuous_tsum l1 hf (fun n x => le_of_eq (l2 n x)) ++ ++theorem limiting_fourier_aux (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) (σ' : ℝ) ++ (hσ' : 1 < σ') : ++ ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * (x ^ (1 - σ') : ℝ) * ∫ u in Ici (- log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) ++ (u / (2 * π)) = ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I) := by ++ have hint : Integrable ψ := ψ.h1.continuous.integrable_of_hasCompactSupport ψ.h2 ++ have l3 : 0 < x := zero_lt_one.trans_le hx ++ have l1 (σ') (hσ' : 1 < σ') := first_fourier hf hint l3 hσ' ++ have l2 (σ') (hσ' : 1 < σ') := second_fourier ψ.h1.continuous.measurable hint l3 hσ' ++ have l8 : Continuous fun t : ℝ ↦ (x : ℂ) ^ (t * I) := ++ continuous_const.cpow (continuous_ofReal.mul continuous_const) (by simp [l3]) ++ have l6 : Continuous fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by ++ apply ((continuous_LSeries_aux (hf _ hσ')).mul ψ.h1.continuous).mul l8 ++ have l4 : Integrable fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by ++ exact l6.integrable_of_hasCompactSupport ψ.h2.mul_left.mul_right ++ have e2 (u : ℝ) : σ' + u * I - 1 ≠ 0 := by ++ intro h ; have := congr_arg Complex.re h ; simp at this ; linarith ++ have l7 : Continuous fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * ++ (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ simp only [one_div, ← mul_assoc] ++ refine ((continuous_const.mul <| Continuous.inv₀ ?_ e2).mul ψ.h1.continuous).mul l8 ++ fun_prop ++ have l5 : Integrable fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * ++ (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ apply l7.integrable_of_hasCompactSupport ++ exact ψ.h2.mul_left.mul_right.mul_left.mul_left ++ simp_rw [l1 σ' hσ', l2 σ' hσ', ← integral_const_mul, ← integral_sub l4 l5] ++ apply integral_congr_ae ++ apply Eventually.of_forall ++ intro u ++ have e1 : 1 < ((σ' : ℂ) + (u : ℂ) * I).re := by simp [hσ'] ++ simp_rw [hG' e1, sub_mul, ← mul_assoc] ++ simp only [one_div, sub_right_inj, mul_eq_mul_right_iff, cpow_eq_zero_iff, ofReal_eq_zero, ne_eq, ++ mul_eq_zero, I_ne_zero, or_false] ++ left ; left ++ field_simp [e2] ++ norm_cast ++ simp [mul_assoc, ← rpow_add l3] ++ ++end CatalanPNT +diff --git a/PrimeNumberTheoremAnd/Catalan/WienerLimits.lean b/PrimeNumberTheoremAnd/Catalan/WienerLimits.lean +new file mode 100644 +index 0000000..fa60fec +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Catalan/WienerLimits.lean +@@ -0,0 +1,620 @@ ++import PrimeNumberTheoremAnd.Catalan.WienerFourier ++ ++namespace CatalanPNT ++ ++open ZetaFivePNT ++ ++open Real BigOperators ArithmeticFunction MeasureTheory Filter Set FourierTransform LSeries ++ Asymptotics SchwartzMap ++open Complex hiding log ++open scoped Topology ++open scoped ContDiff ++open scoped ComplexConjugate ++ ++variable {n : ℕ} {A a b c d u x y t σ' : ℝ} {ψ Ψ : ℝ → ℂ} {F G : ℂ → ℂ} {f : ℕ → ℂ} {𝕜 : Type} ++ [RCLike 𝕜] ++ ++section nabla ++ ++variable {α E : Type*} [OfNat α 1] [Add α] [Sub α] {u : α → ℂ} ++ ++def cumsum [AddCommMonoid E] (u : ℕ → E) (n : ℕ) : E := ∑ i ∈ Finset.range n, u i ++ ++def nabla [Sub E] (u : α → E) (n : α) : E := u (n + 1) - u n ++ ++def nnabla [Sub E] (u : α → E) (n : α) : E := u n - u (n + 1) ++ ++def shift (u : α → E) (n : α) : E := u (n + 1) ++ ++@[simp] theorem cumsum_zero [AddCommMonoid E] {u : ℕ → E} : cumsum u 0 = 0 := by simp [cumsum] ++ ++theorem cumsum_succ [AddCommMonoid E] {u : ℕ → E} (n : ℕ) : ++ cumsum u (n + 1) = cumsum u n + u n := by ++ simp [cumsum, Finset.sum_range_succ] ++ ++@[simp] theorem nabla_cumsum [AddCommGroup E] {u : ℕ → E} : nabla (cumsum u) = u := by ++ ext n ; simp [nabla, cumsum, Finset.range_add_one] ++ ++theorem neg_cumsum [AddCommGroup E] {u : ℕ → E} : -(cumsum u) = cumsum (-u) := ++ funext (fun n => by simp [cumsum]) ++ ++theorem cumsum_nonneg {u : ℕ → ℝ} (hu : 0 ≤ u) : 0 ≤ cumsum u := ++ fun _ => Finset.sum_nonneg (fun i _ => hu i) ++ ++omit [Sub α] in ++theorem neg_nabla [Ring E] {u : α → E} : -(nabla u) = nnabla u := by ext n ; simp [nabla, nnabla] ++ ++omit [Sub α] in ++@[simp] theorem nabla_mul [Ring E] {u : α → E} {c : E} : ++ nabla (fun n => c * u n) = c • nabla u := by ++ ext n ; simp [nabla, mul_sub] ++ ++omit [Sub α] in ++@[simp] theorem nnabla_mul [Ring E] {u : α → E} {c : E} : ++ nnabla (fun n => c * u n) = c • nnabla u := by ++ ext n ; simp [nnabla, mul_sub] ++ ++theorem nnabla_cast (u : ℝ → E) [Sub E] : nnabla u ∘ ((↑) : ℕ → ℝ) = nnabla (u ∘ (↑)) := by ++ ext n ; simp [nnabla] ++ ++end nabla ++ ++theorem Finset.sum_shift_front {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++ cumsum u (n + 1) = u 0 + cumsum (shift u) n := by ++ simp_rw [add_comm n, cumsum, _root_.Finset.sum_range_add, ++ _root_.Finset.sum_range_one, add_comm 1] ; rfl ++ ++theorem Finset.sum_shift_front' {E : Type*} [Ring E] {u : ℕ → E} : ++ shift (cumsum u) = (fun _ => u 0) + cumsum (shift u) := by ++ ext n ; apply Finset.sum_shift_front ++ ++theorem Finset.sum_shift_back {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++ cumsum u (n + 1) = cumsum u n + u n := by ++ simp [cumsum, Finset.range_add_one, add_comm] ++ ++theorem Finset.sum_shift_back' {E : Type*} [Ring E] {u : ℕ → E} : ++ shift (cumsum u) = cumsum u + u := by ++ ext n ; apply Finset.sum_shift_back ++ ++theorem summation_by_parts {E : Type*} [Ring E] {a A b : ℕ → E} (ha : a = nabla A) {n : ℕ} : ++ cumsum (a * b) (n + 1) = A (n + 1) * b n - A 0 * b 0 - ++ cumsum (shift A * fun i => (b (i + 1) - b i)) n := by ++ have l1 : ∑ x ∈ Finset.range (n + 1), A (x + 1) * b x = ∑ x ∈ Finset.range n, ++ A (x + 1) * b x + A (n + 1) * b n := ++ Finset.sum_shift_back ++ have l2 : ∑ x ∈ Finset.range (n + 1), A x * b x = A 0 * b 0 + ∑ x ∈ Finset.range n, ++ A (x + 1) * b (x + 1) := ++ Finset.sum_shift_front ++ simp only [cumsum, ha, Pi.mul_apply, nabla, sub_mul, Finset.sum_sub_distrib, l1, l2, shift, ++ mul_sub] ++ abel ++ ++theorem summation_by_parts' {E : Type*} [Ring E] {a b : ℕ → E} {n : ℕ} : ++ cumsum (a * b) (n + 1) = cumsum a (n + 1) * b n - cumsum (shift (cumsum a) * nabla b) n := by ++ change cumsum (a * b) (n + 1) = cumsum a (n + 1) * b n - ++ cumsum (shift (cumsum a) * (fun i : ℕ => b (i + 1) - b i)) n ++ simpa using summation_by_parts (a := a) (b := b) (A := cumsum a) (by simp) ++ ++theorem summation_by_parts'' {E : Type*} [Ring E] {a b : ℕ → E} : ++ shift (cumsum (a * b)) = shift (cumsum a) * b - cumsum (shift (cumsum a) * nabla b) := by ++ ext n ; apply summation_by_parts' ++ ++theorem summable_iff_bounded {u : ℕ → ℝ} (hu : 0 ≤ u) : ++ Summable u ↔ BoundedAtFilter atTop (cumsum u) := by ++ have l1 : (cumsum u =O[atTop] 1) ↔ _ := isBigO_one_nat_atTop_iff ++ have l2 n : ‖cumsum u n‖ = cumsum u n := by simpa using cumsum_nonneg hu n ++ simp only [BoundedAtFilter, l1, l2] ++ constructor <;> intro h <;> rcases h with ⟨C, h1⟩ ++ · exact ⟨C, fun n => sum_le_hasSum _ (fun i _ => hu i) h1⟩ ++ · exact summable_of_sum_range_le hu h1 ++ ++theorem Filter.EventuallyEq.summable {u v : ℕ → ℝ} (h : u =ᶠ[atTop] v) (hu : Summable v) : ++ Summable u := ++ summable_of_isBigO_nat hu h.isBigO ++ ++theorem summable_congr_ae {u v : ℕ → ℝ} (huv : u =ᶠ[atTop] v) : Summable u ↔ Summable v := by ++ exact ⟨CatalanPNT.Filter.EventuallyEq.summable huv.symm, ++ CatalanPNT.Filter.EventuallyEq.summable huv⟩ ++ ++theorem BoundedAtFilter.add_const {u : ℕ → ℝ} {c : ℝ} : ++ BoundedAtFilter atTop (fun n => u n + c) ↔ BoundedAtFilter atTop u := by ++ have : u = fun n => (u n + c) + (-c) := by ext n ; ring ++ simp only [BoundedAtFilter] ++ constructor <;> intro h ++ on_goal 1 => rw [this] ++ all_goals { exact h.add (const_boundedAtFilter _ _) } ++ ++theorem BoundedAtFilter.comp_add {u : ℕ → ℝ} {N : ℕ} : ++ BoundedAtFilter atTop (fun n => u (n + N)) ↔ BoundedAtFilter atTop u := by ++ simp only [BoundedAtFilter, isBigO_iff, norm_eq_abs, Pi.one_apply, one_mem, ++ CStarRing.norm_of_mem_unitary, mul_one, eventually_atTop] ++ constructor <;> intro hbound <;> rcases hbound with ⟨C, n₀, h⟩ <;> use C ++ · refine ⟨n₀ + N, fun n hn => ?_⟩ ++ obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le' (m := N) (n := n) (by grind) ++ exact h _ <| Nat.add_le_add_iff_right.mp hn ++ · exact ⟨n₀, fun n hn => h _ (by grind)⟩ ++ ++theorem summable_iff_bounded' {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, 0 ≤ u n) : ++ Summable u ↔ BoundedAtFilter atTop (cumsum u) := by ++ obtain ⟨N, hu⟩ := eventually_atTop.mp hu ++ have e2 : cumsum (fun i ↦ u (i + N)) = fun n => cumsum u (n + N) - cumsum u N := by ++ ext n ; simp_rw [cumsum, add_comm _ N, Finset.sum_range_add] ; ring ++ rw [← summable_nat_add_iff N, summable_iff_bounded (fun n => hu _ <| Nat.le_add_left N n), e2] ++ simp_rw [sub_eq_add_neg, BoundedAtFilter.add_const, BoundedAtFilter.comp_add] ++ ++theorem bounded_of_shift {u : ℕ → ℝ} (h : BoundedAtFilter atTop (shift u)) : ++ BoundedAtFilter atTop u := by ++ simp only [BoundedAtFilter, isBigO_iff, eventually_atTop] at h ⊢ ++ obtain ⟨C, N, hC⟩ := h ++ refine ⟨C, N + 1, fun n hn => ?_⟩ ++ simp only [shift] at hC ++ have r1 : n - 1 ≥ N := Nat.le_sub_one_of_lt hn ++ have r2 : n - 1 + 1 = n := Nat.sub_add_cancel (by omega) ++ simpa [r2] using hC (n - 1) r1 ++ ++theorem dirichlet_test' {a b : ℕ → ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) ++ (hAb : BoundedAtFilter atTop (shift (cumsum a) * b)) (hbb : ∀ᶠ n in atTop, b (n + 1) ≤ b n) ++ (h : Summable (shift (cumsum a) * nnabla b)) : Summable (a * b) := by ++ have l1 : ∀ᶠ n in atTop, 0 ≤ (shift (cumsum a) * nnabla b) n := by ++ filter_upwards [hbb] with n hb ++ exact mul_nonneg (by simpa [shift] using cumsum_nonneg ha (n + 1)) (sub_nonneg.mpr hb) ++ rw [summable_iff_bounded (mul_nonneg ha hb)] ++ rw [summable_iff_bounded' l1] at h ++ apply bounded_of_shift ++ simpa only [summation_by_parts'', sub_eq_add_neg, neg_cumsum, ← mul_neg, neg_nabla] ++ using hAb.add h ++ ++theorem exists_antitone_of_eventually {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, u (n + 1) ≤ u n) : ++ ∃ v : ℕ → ℝ, range v ⊆ range u ∧ Antitone v ∧ v =ᶠ[atTop] u := by ++ obtain ⟨N, hN⟩ := eventually_atTop.mp hu ++ let v (n : ℕ) := u (if n < N then N else n) ++ refine ⟨v, ?_, ?_, ?_⟩ ++ · intro x hx ++ rcases hx with ⟨n, hn⟩ ++ exact ⟨if n < N then N else n, hn⟩ ++ · refine antitone_nat_of_succ_le (fun n => ?_) ++ by_cases h : n < N ++ · by_cases h' : n + 1 < N <;> simp [v, h, h'] ++ have : n + 1 = N := by linarith ++ simp [this] ++ · have : ¬(n + 1 < N) := by linarith ++ simp only [this, ↓reduceIte, h, ge_iff_le, v] ; apply hN ; linarith ++ · have : ∀ᶠ n in atTop, ¬(n < N) := by simpa using ⟨N, fun b hb => by linarith⟩ ++ filter_upwards [this] with n hn ; simp [v, hn] ++ ++theorem summable_inv_mul_log_sq : Summable (fun n : ℕ => (n * (Real.log n) ^ 2)⁻¹) := by ++ let u (n : ℕ) := (n * (Real.log n) ^ 2)⁻¹ ++ have l7 : ∀ᶠ n : ℕ in atTop, 1 ≤ Real.log n := ++ tendsto_atTop.mp (tendsto_log_atTop.comp tendsto_natCast_atTop_atTop) 1 ++ have l8 : ∀ᶠ n : ℕ in atTop, 1 ≤ n := eventually_ge_atTop 1 ++ have l9 : ∀ᶠ n in atTop, u (n + 1) ≤ u n := by ++ filter_upwards [l7, l8] with n l2 l8; dsimp [u]; gcongr <;> simp ++ obtain ⟨v, l1, l2, l3⟩ := exists_antitone_of_eventually l9 ++ rw [summable_congr_ae l3.symm] ++ have l4 (n : ℕ) : 0 ≤ v n := by obtain ⟨k, hk⟩ := l1 ⟨n, rfl⟩ ; rw [← hk] ; positivity ++ apply (summable_condensed_iff_of_nonneg l4 (fun _ _ _ a ↦ l2 a)).mp ++ suffices this : ∀ᶠ k : ℕ in atTop, 2 ^ k * v (2 ^ k) = ((k : ℝ) ^ 2)⁻¹ * ((Real.log 2) ^ 2)⁻¹ by ++ exact (summable_congr_ae this).mpr <| (Real.summable_nat_pow_inv.mpr one_lt_two).mul_right _ ++ have l5 : ∀ᶠ k in atTop, v (2 ^ k) = u (2 ^ k) := ++ l3.comp_tendsto <| tendsto_pow_atTop_atTop_of_one_lt Nat.le.refl ++ filter_upwards [l5, l8] with k l5 l8 ++ simp only [l5, mul_inv_rev, Nat.cast_pow, Nat.cast_ofNat, log_pow, u] ++ field_simp ++ ++theorem tendsto_mul_add_atTop {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ Tendsto (fun x => a * x + b) atTop atTop := ++ tendsto_atTop_add_const_right _ b (tendsto_id.const_mul_atTop ha) ++ ++theorem isLittleO_const_of_tendsto_atTop {α : Type*} [Preorder α] (a : ℝ) {f : α → ℝ} ++ (hf : Tendsto f atTop atTop) : (fun _ => a) =o[atTop] f := by ++ simp [tendsto_norm_atTop_atTop.comp hf] ++ ++theorem isLittleO_mul_add_sq (a b : ℝ) : (fun x => a * x + b) =o[atTop] (fun x => x ^ 2) := by ++ apply IsLittleO.add ++ · apply IsLittleO.const_mul_left ; simpa using isLittleO_pow_pow_atTop_of_lt (𝕜 := ℝ) one_lt_two ++ · apply isLittleO_const_of_tendsto_atTop _ <| tendsto_pow_atTop (by linarith) ++ ++theorem log_mul_add_isBigO_log {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ (fun x => Real.log (a * x + b)) =O[atTop] Real.log := by ++ apply IsBigO.of_bound (2 : ℕ) ++ have l2 : ∀ᶠ x : ℝ in atTop, 0 ≤ log x := tendsto_atTop.mp tendsto_log_atTop 0 ++ have l3 : ∀ᶠ x : ℝ in atTop, 0 ≤ log (a * x + b) := ++ tendsto_atTop.mp (tendsto_log_atTop.comp (tendsto_mul_add_atTop ha b)) 0 ++ have l5 : ∀ᶠ x : ℝ in atTop, 1 ≤ a * x + b := tendsto_atTop.mp (tendsto_mul_add_atTop ha b) 1 ++ have l1 : ∀ᶠ x : ℝ in atTop, a * x + b ≤ x ^ 2 := by ++ filter_upwards [(isLittleO_mul_add_sq a b).eventuallyLE, l5] with x r2 l5 ++ simpa [abs_eq_self.mpr (zero_le_one.trans l5)] using r2 ++ filter_upwards [l1, l2, l3, l5] with x l1 l2 l3 l5 ++ simpa [abs_eq_self.mpr l2, abs_eq_self.mpr l3, Real.log_pow] using ++ Real.log_le_log (by linarith) l1 ++ ++theorem isBigO_log_mul_add {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ Real.log =O[atTop] (fun x => Real.log (a * x + b)) := by ++ convert (log_mul_add_isBigO_log (b := -b / a) (inv_pos.mpr ha)).comp_tendsto ++ (tendsto_mul_add_atTop (b := b) ha) using 1 ++ · ext x ++ simp only [Function.comp_apply] ++ congr ++ field_simp ++ simp ++ · rfl ++ ++theorem log_isbigo_log_div {d : ℝ} (hb : 0 < d) : ++ (fun n ↦ Real.log n) =O[atTop] (fun n ↦ Real.log (n / d)) := by ++ convert isBigO_log_mul_add (inv_pos.mpr hb) 0 using 1; simp only [add_zero]; field_simp ++ ++theorem Asymptotics.IsBigO.add_isLittleO_right {f g : ℝ → ℝ} (h : g =o[atTop] f) : ++ f =O[atTop] (f + g) := by ++ exact h.right_isBigO_add' ++ ++theorem Asymptotics.IsBigO.sq {α : Type*} [Preorder α] {f g : α → ℝ} (h : f =O[atTop] g) : ++ (fun n ↦ f n ^ 2) =O[atTop] (fun n => g n ^ 2) := ++ h.pow 2 ++ ++theorem log_sq_isbigo_mul {a b : ℝ} (hb : 0 < b) : ++ (fun x ↦ Real.log x ^ 2) =O[atTop] (fun x ↦ a + Real.log (x / b) ^ 2) := by ++ apply (CatalanPNT.Asymptotics.IsBigO.sq (log_isbigo_log_div hb)).trans ++ simp_rw [add_comm a] ++ refine CatalanPNT.Asymptotics.IsBigO.add_isLittleO_right <| ++ isLittleO_const_of_tendsto_atTop _ ?_ ++ exact (tendsto_pow_atTop two_ne_zero).comp <| ++ tendsto_log_atTop.comp <| tendsto_id.atTop_div_const hb ++ ++theorem log_add_div_isBigO_log (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ (fun x ↦ Real.log ((x + a) / b)) =O[atTop] fun x ↦ Real.log x := by ++ convert log_mul_add_isBigO_log (inv_pos.mpr hb) (a / b) using 3 ; ring ++ ++theorem log_add_one_sub_log_le {x : ℝ} (hx : 0 < x) : nabla Real.log x ≤ x⁻¹ := by ++ rw [nabla, ← Real.log_div (by linarith) hx.ne'] ++ calc ++ _ ≤ (x + 1) / x - 1 := Real.log_le_sub_one_of_pos (by positivity) ++ _ = x⁻¹ := by field_simp; ring ++ ++theorem nabla_log_main : nabla Real.log =O[atTop] fun x ↦ 1 / x := by ++ apply IsBigO.of_bound 1 ++ filter_upwards [eventually_gt_atTop 0] with x l1 ++ have l2 : log x ≤ log (x + 1) := log_le_log l1 (by linarith) ++ simpa [nabla, abs_eq_self.mpr l1.le, abs_eq_self.mpr (sub_nonneg.mpr l2)] using ++ log_add_one_sub_log_le l1 ++ ++theorem nabla_log {b : ℝ} (hb : 0 < b) : ++ nabla (fun x => Real.log (x / b)) =O[atTop] (fun x => 1 / x) := by ++ refine EventuallyEq.trans_isBigO ?_ nabla_log_main ++ filter_upwards [eventually_gt_atTop 0] with x l2 ++ rw [nabla, log_div (by linarith) (by linarith), log_div l2.ne.symm (by linarith), nabla] ; ring ++ ++theorem nnabla_mul_log_sq (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ nabla (fun x => x * (a + Real.log (x / b) ^ 2)) =O[atTop] (fun x => Real.log x ^ 2) := by ++ have l1 : nabla (fun n => n * (a + Real.log (n / b) ^ 2)) = fun n => ++ a + Real.log ((n + 1) / b) ^ 2 + ++ (n * (Real.log ((n + 1) / b) ^ 2 - Real.log (n / b) ^ 2)) := by ++ ext n ; simp [nabla] ; ring ++ have l2 := (isLittleO_const_of_tendsto_atTop a ++ ((tendsto_pow_atTop two_ne_zero).comp tendsto_log_atTop)).isBigO ++ have l3 := CatalanPNT.Asymptotics.IsBigO.sq (log_add_div_isBigO_log 1 hb) ++ have l4 : (fun x => Real.log ((x + 1) / b) + Real.log (x / b)) =O[atTop] Real.log := by ++ simpa using (log_add_div_isBigO_log _ hb).add (log_add_div_isBigO_log 0 hb) ++ have e2 : (fun x : ℝ => x * (Real.log x * (1 / x))) =ᶠ[atTop] Real.log := by ++ filter_upwards [eventually_ge_atTop 1] with x hx using by field_simp ++ have l5 : (fun n ↦ n * (Real.log n * (1 / n))) =O[atTop] (fun n ↦ (Real.log n) ^ 2) := ++ e2.trans_isBigO ++ (by simpa [Function.comp_def] using ++ (isLittleO_mul_add_sq 1 0).isBigO.comp_tendsto Real.tendsto_log_atTop) ++ simp_rw [l1, _root_.sq_sub_sq] ++ exact ((l2.add l3).add (isBigO_refl (·) atTop |>.mul (l4.mul (nabla_log hb)) |>.trans l5)) ++ ++theorem nnabla_bound_aux1 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ Tendsto (fun x => x * (a + Real.log (x / b) ^ 2)) atTop atTop := ++ tendsto_id.atTop_mul_atTop₀ <| tendsto_atTop_add_const_left _ _ <| ++ (tendsto_pow_atTop two_ne_zero).comp <| tendsto_log_atTop.comp <| tendsto_id.atTop_div_const hb ++ ++theorem nnabla_bound_aux2 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ ∀ᶠ x in atTop, 0 < x * (a + Real.log (x / b) ^ 2) := ++ (nnabla_bound_aux1 a hb).eventually (eventually_gt_atTop 0) ++ ++theorem Real.log_eventually_gt_atTop (a : ℝ) : ++ ∀ᶠ x in atTop, a < Real.log x := ++ Real.tendsto_log_atTop.eventually (eventually_gt_atTop a) ++ ++@[local gcongr] ++theorem norm_lt_norm_of_nonneg (x y : ℝ) (hx : 0 ≤ x) (hxy : x ≤ y) : ++ ‖x‖ ≤ ‖y‖ := by ++ simp_rw [Real.norm_eq_abs] ++ apply abs_le_abs hxy ++ linarith ++ ++theorem nnabla_bound_aux {x : ℝ} (hx : 0 < x) : ++ nnabla (fun n ↦ 1 / (n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2))) =O[atTop] ++ (fun n ↦ 1 / (Real.log n ^ 2 * n ^ 2)) := by ++ let d n : ℝ := n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2) ++ change (fun x_1 ↦ nnabla (fun n ↦ 1 / d n) x_1) =O[atTop] _ ++ have l2 : ∀ᶠ n in atTop, 0 < d n := (nnabla_bound_aux2 ((2 * π) ^ 2) hx) ++ have l3 : ∀ᶠ n in atTop, 0 < d (n + 1) := ++ (tendsto_atTop_add_const_right atTop (1 : ℝ) tendsto_id).eventually l2 ++ have l1 : ∀ᶠ n : ℝ in atTop, ++ nnabla (fun n ↦ 1 / d n) n = (d (n + 1) - d n) * (d n)⁻¹ * (d (n + 1))⁻¹ := by ++ filter_upwards [l2, l3] with n l2 l3 ++ rw [nnabla, one_div, one_div, inv_sub_inv l2.ne.symm l3.ne.symm, div_eq_mul_inv, mul_inv, ++ mul_assoc] ++ have l4 : (fun n => (d n)⁻¹) =O[atTop] (fun n => (n * (Real.log n) ^ 2)⁻¹) := by ++ apply IsBigO.inv_rev ++ · refine (isBigO_refl _ _).mul <| (log_sq_isbigo_mul hx) ++ · filter_upwards [Real.log_eventually_gt_atTop 0, eventually_gt_atTop 0] with x hx hx' ++ rw [← not_imp_not] ++ intro _ ++ positivity ++ have l5 : (fun n => (d (n + 1))⁻¹) =O[atTop] (fun n => (n * (Real.log n) ^ 2)⁻¹) := by ++ refine IsBigO.trans ?_ l4 ++ rw [isBigO_iff]; use 1 ++ have e3 : ∀ᶠ n in atTop, d n ≤ d (n + 1) := by ++ filter_upwards [eventually_ge_atTop x] with n hn ++ have e2 : 1 ≤ n / x := (one_le_div hx).mpr hn ++ have : 0 ≤ n := hx.le.trans hn ++ simp only [d] ++ gcongr <;> simp [Real.log_nonneg, *] ++ filter_upwards [l2, l3, e3] with n e1 e2 e3 ++ simp_rw [one_mul] ++ gcongr ++ have l6 : (fun n => d (n + 1) - d n) =O[atTop] (fun n => (Real.log n) ^ 2) := by ++ change nabla (fun n : ℝ => n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2)) ++ =O[atTop] (fun n => (Real.log n) ^ 2) ++ exact nnabla_mul_log_sq ((2 * π) ^ 2) hx ++ apply EventuallyEq.trans_isBigO l1 ++ apply ((l6.mul l4).mul l5).trans_eventuallyEq ++ filter_upwards [eventually_ge_atTop 2, Real.log_eventually_gt_atTop 0] with n hn hn' ++ field_simp ++ ++theorem nnabla_bound (C : ℝ) {x : ℝ} (hx : 0 < x) : ++ nnabla (fun n => C / (1 + (Real.log (n / x) / (2 * π)) ^ 2) / n) =O[atTop] ++ (fun n => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by ++ field_simp ++ simp only [div_eq_mul_inv, mul_inv, nnabla_mul, one_mul] ++ apply IsBigO.const_mul_left ++ simpa [div_eq_mul_inv, mul_pow, mul_comm] using nnabla_bound_aux hx ++ ++theorem cheby.bigO (h : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ cumsum (‖f ·‖) =O[atTop] ((↑) : ℕ → ℝ) := by ++ have l1 : 0 ≤ cumsum (‖f ·‖) := cumsum_nonneg (fun _ => norm_nonneg _) ++ obtain ⟨C, hC⟩ := h ++ apply isBigO_of_le' (c := C) atTop ++ intro n ++ rw [Real.norm_eq_abs, abs_eq_self.mpr (l1 n)] ++ simpa using hC n ++ ++theorem limiting_fourier_lim1_aux ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hx : 0 < x) (C : ℝ) (hC : 0 ≤ C) : ++ Summable fun n ↦ ‖f n‖ / ↑n * (C / (1 + (1 / (2 * π) * Real.log (↑n / x)) ^ 2)) := by ++ let a (n : ℕ) := (C / (1 + (Real.log (↑n / x) / (2 * π)) ^ 2) / ↑n) ++ replace hcheby := cheby.bigO hcheby ++ have l1 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n : ℕ => (↑(n + 1) : ℝ)) := ++ hcheby.comp_tendsto <| tendsto_add_atTop_nat 1 ++ have l2 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n => (n : ℝ)) := ++ l1.trans ++ (by simpa using (isBigO_refl _ _).add <| isBigO_iff.mpr ⟨1, by simpa using ⟨1, by tauto⟩⟩) ++ have l5 : BoundedAtFilter atTop (fun n : ℕ => C / (1 + (Real.log (↑n / x) / (2 * π)) ^ 2)) := by ++ simp only [BoundedAtFilter] ++ field_simp ++ apply isBigO_of_le' (c := C) ; intro n ++ have : 0 ≤ 2 ^ 2 * π ^ 2 + Real.log (n / x) ^ 2 := by positivity ++ simp only [norm_div, norm_mul, norm_eq_abs, abs_eq_self.mpr hC, norm_pow, ++ abs_eq_self.mpr pi_nonneg, abs_eq_self.mpr this, Pi.one_apply, one_mem, ++ CStarRing.norm_of_mem_unitary, mul_one, ge_iff_le, Nat.abs_ofNat] ++ apply div_le_of_le_mul₀ this hC ++ rw [mul_add, ← mul_assoc] ++ apply le_add_of_le_of_nonneg le_rfl ++ positivity ++ have l3 : a =O[atTop] (fun n => 1 / (n : ℝ)) := by ++ convert IsBigO.mul l5 (isBigO_refl (fun n : ℕ => 1 / (n : ℝ)) _) using 1 ++ · ext n ++ simp [a, div_eq_mul_inv] ++ · ext n ++ simp ++ have l4 : nnabla a =O[atTop] (fun n : ℕ => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by ++ convert (nnabla_bound C hx).natCast_atTop ; simp [nnabla, a] ++ simp_rw [div_mul_eq_mul_div, mul_div_assoc, one_mul] ++ apply dirichlet_test' ++ · intro n ; exact norm_nonneg _ ++ · intro n ; positivity ++ · apply (l2.mul l3).trans_eventuallyEq ++ apply eventually_of_mem (Ici_mem_atTop 1) ++ intro x (hx : 1 ≤ x) ++ have : x ≠ 0 := Nat.one_le_iff_ne_zero.mp hx ++ simp [this] ++ · have : ∀ᶠ n : ℕ in atTop, x ≤ n := by simpa using eventually_ge_atTop ⌈x⌉₊ ++ filter_upwards [this] with n hn ++ have e1 : 0 < (n : ℝ) := by linarith ++ have e2 : 1 ≤ n / x := (one_le_div hx).mpr hn ++ have e3 := Nat.le_succ n ++ gcongr ++ refine div_nonneg (Real.log_nonneg e2) (by norm_num [pi_nonneg]) ++ · apply summable_of_isBigO_nat summable_inv_mul_log_sq ++ apply (l2.mul l4).trans_eventuallyEq ++ apply eventually_of_mem (Ici_mem_atTop 2) ++ intro x (hx : 2 ≤ x) ++ have : (x : ℝ) ≠ 0 := by simp ; linarith ++ have : Real.log x ≠ 0 := by ++ have ll : 2 ≤ (x : ℝ) := by simp [hx] ++ simp ++ grind ++ field_simp ++ ++theorem limiting_fourier_lim1 ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (ψ : W21) (hx : 0 < x) : ++ Tendsto (fun σ' : ℝ ↦ ++ ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x))) (𝓝[>] 1) ++ (𝓝 (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x)))) := by ++ obtain ⟨C, hC⟩ := decay_bounds_cor ψ ++ have : 0 ≤ C := by simpa using (norm_nonneg _).trans (hC 0) ++ refine tendsto_tsum_of_dominated_convergence ++ (limiting_fourier_lim1_aux hcheby hx C this) (fun n => ?_) ?_ ++ · apply Tendsto.mul_const ++ by_cases h : n = 0 <;> simp only [term, h, ↓reduceIte, CharP.cast_eq_zero, div_zero, ++ tendsto_const_nhds_iff] ++ refine tendsto_const_nhds.div ?_ (by simp [h]) ++ simpa using ((continuous_ofReal.tendsto 1).mono_left nhdsWithin_le_nhds).const_cpow ++ · rw [eventually_nhdsWithin_iff] ++ apply Eventually.of_forall ++ intro σ' (hσ' : 1 < σ') n ++ rw [norm_mul, ← nterm_eq_norm_term] ++ refine mul_le_mul ?_ (hC _) (norm_nonneg _) (div_nonneg (norm_nonneg _) (Nat.cast_nonneg _)) ++ by_cases h : n = 0 <;> simp only [nterm, h, ↓reduceIte, CharP.cast_eq_zero, div_zero, le_refl] ++ have : 1 ≤ (n : ℝ) := by exact_mod_cast (show 1 ≤ n by omega) ++ refine div_le_div₀ (norm_nonneg _) le_rfl (by simpa [Nat.pos_iff_ne_zero]) ?_ ++ simpa using Real.rpow_le_rpow_of_exponent_le this hσ'.le ++ ++theorem limiting_fourier_lim2_aux (x : ℝ) (C : ℝ) : ++ Integrable (fun t ↦ max |x| 1 * (C / (1 + (t / (2 * π)) ^ 2))) ++ (Measure.restrict volume (Ici (-Real.log x))) := by ++ simp_rw [div_eq_mul_inv C] ++ exact (((integrable_inv_one_add_sq.comp_div ++ (by simp [pi_ne_zero])).const_mul _).const_mul _).restrict ++ ++theorem limiting_fourier_lim2 (A : ℝ) (ψ : W21) (hx : 1 ≤ x) : ++ Tendsto (fun σ' ↦ A * ↑(x ^ (1 - σ')) * ++ ∫ u in Ici (-Real.log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) ++ (𝓝[>] 1) (𝓝 (A * ∫ u in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)))) := by ++ obtain ⟨C, hC⟩ := decay_bounds_cor ψ ++ apply Tendsto.mul ++ · suffices h : Tendsto (fun σ' : ℝ ↦ ofReal (x ^ (1 - σ'))) (𝓝[>] 1) (𝓝 1) by ++ simpa using h.const_mul ↑A ++ suffices h : Tendsto (fun σ' : ℝ ↦ x ^ (1 - σ')) (𝓝[>] 1) (𝓝 1) from ++ (continuous_ofReal.tendsto 1).comp h ++ have : Tendsto (fun σ' : ℝ ↦ σ') (𝓝 1) (𝓝 1) := fun _ a ↦ a ++ have : Tendsto (fun σ' : ℝ ↦ 1 - σ') (𝓝[>] 1) (𝓝 0) := ++ tendsto_nhdsWithin_of_tendsto_nhds (by simpa using this.const_sub 1) ++ simpa using tendsto_const_nhds.rpow this (Or.inl (zero_lt_one.trans_le hx).ne.symm) ++ · refine tendsto_integral_filter_of_dominated_convergence _ ?_ ?_ ++ (limiting_fourier_lim2_aux x C) ?_ ++ · apply Eventually.of_forall ; intro σ' ++ apply Continuous.aestronglyMeasurable ++ have := continuous_FourierIntegral ψ ++ continuity ++ · apply eventually_of_mem (U := Ioo 1 2) ++ · apply Ioo_mem_nhdsGT_of_mem ; simp ++ · intro σ' hσ ++ have h1 := hσ.1 ++ have h2 := hσ.2 ++ rw [ae_restrict_iff' measurableSet_Ici] ++ apply Eventually.of_forall ++ intro t (ht : - Real.log x ≤ t) ++ rw [norm_mul] ++ have hdom_nonneg : 0 ≤ max |x| 1 := by ++ exact (abs_nonneg x).trans (le_max_left _ _) ++ refine mul_le_mul ?_ (hC _) (norm_nonneg _) hdom_nonneg ++ simp only [neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_sub, ofReal_one, norm_exp, ++ neg_re, mul_re, ofReal_re, sub_re, one_re, ofReal_im, sub_im, one_im, sub_self, mul_zero, ++ sub_zero] ++ have : -Real.log x * (σ' - 1) ≤ t * (σ' - 1) := mul_le_mul_of_nonneg_right ht (by linarith) ++ have : -(t * (σ' - 1)) ≤ Real.log x * (σ' - 1) := by simpa using neg_le_neg this ++ have := Real.exp_monotone this ++ apply this.trans ++ have l1 : σ' - 1 ≤ 1 := by linarith ++ have : 0 ≤ Real.log x := Real.log_nonneg hx ++ have := mul_le_mul_of_nonneg_left l1 this ++ refine (Real.exp_monotone this).trans ?_ ++ have hxabs : |x| = x := abs_of_nonneg (zero_le_one.trans hx) ++ calc ++ Real.exp (Real.log x * 1) = |x| := by ++ simpa [mul_one, hxabs] using (Real.exp_log (zero_lt_one.trans_le hx)) ++ _ ≤ max |x| 1 := le_max_left _ _ ++ · apply Eventually.of_forall ++ intro x ++ suffices h : Tendsto (fun n ↦ ((rexp (-x * (n - 1))) : ℂ)) (𝓝[>] 1) (𝓝 1) by ++ simpa using h.mul_const _ ++ apply Tendsto.mono_left ?_ nhdsWithin_le_nhds ++ suffices h : Continuous (fun n ↦ ((rexp (-x * (n - 1))) : ℂ)) by simpa using h.tendsto 1 ++ continuity ++ ++theorem limiting_fourier_lim3 (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : ++ Tendsto (fun σ' : ℝ ↦ ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I)) (𝓝[>] 1) ++ (𝓝 (∫ t : ℝ, G (1 + t * I) * ψ t * x ^ (t * I))) := by ++ by_cases hh : tsupport ψ = ∅ ++ · simp [tsupport_eq_empty_iff.mp hh] ++ obtain ⟨a₀, ha₀⟩ := Set.nonempty_iff_ne_empty.mpr hh ++ let S : Set ℂ := reProdIm (Icc 1 2) (tsupport ψ) ++ have l1 : IsCompact S := by ++ refine Metric.isCompact_iff_isClosed_bounded.mpr ⟨?_, ?_⟩ ++ · exact isClosed_Icc.reProdIm (isClosed_tsupport ψ) ++ · exact (Metric.isBounded_Icc 1 2).reProdIm ψ.h2.isBounded ++ have l2 : S ⊆ {s : ℂ | 1 ≤ s.re} := fun z hz => (mem_reProdIm.mp hz).1.1 ++ have l3 : ContinuousOn (‖G ·‖) S := (hG.mono l2).norm ++ have l4 : S.Nonempty := ⟨1 + a₀ * I, by simp [S, mem_reProdIm, ha₀]⟩ ++ obtain ⟨z, -, hmax⟩ := l1.exists_isMaxOn l4 l3 ++ let MG := ‖G z‖ ++ let bound (a : ℝ) : ℝ := MG * ‖ψ a‖ ++ apply tendsto_integral_filter_of_dominated_convergence (bound := bound) ++ · apply eventually_of_mem (U := Icc 1 2) (Icc_mem_nhdsGT_of_mem (by simp)) ; intro u hu ++ apply Continuous.aestronglyMeasurable ++ apply Continuous.mul ++ · exact (hG.comp_continuous (by fun_prop) (by simp [hu.1])).mul ψ.h1.continuous ++ · apply Continuous.const_cpow (by fun_prop) ; simp ; linarith ++ · apply eventually_of_mem (U := Icc 1 2) (Icc_mem_nhdsGT_of_mem (by simp)) ++ intro u hu ++ apply Eventually.of_forall ; intro v ++ by_cases h : v ∈ tsupport ψ ++ · have r1 : u + v * I ∈ S := by simp [S, mem_reProdIm, hu.1, hu.2, h] ++ have r2 := isMaxOn_iff.mp hmax _ r1 ++ have r4 : (x : ℂ) ≠ 0 := by simp ; linarith ++ have r5 : arg x = 0 := by simp [arg_eq_zero_iff] ; linarith ++ have r3 : ‖(x : ℂ) ^ (v * I)‖ = 1 := by simp [norm_cpow_of_ne_zero r4, r5] ++ simp_rw [norm_mul, r3, mul_one] ++ exact mul_le_mul_of_nonneg_right r2 (norm_nonneg _) ++ · have : v ∉ Function.support ψ := fun a ↦ h (subset_tsupport ψ a) ++ simp at this ; simp [this, bound] ++ · suffices h : Continuous bound by exact h.integrable_of_hasCompactSupport ψ.h2.norm.mul_left ++ have := ψ.h1.continuous ; fun_prop ++ · apply Eventually.of_forall ; intro t ++ apply Tendsto.mul_const ++ apply Tendsto.mul_const ++ refine (hG (1 + t * I) (by simp)).tendsto.comp <| tendsto_nhdsWithin_iff.mpr ⟨?_, ?_⟩ ++ · exact ((continuous_ofReal.tendsto _).add tendsto_const_nhds).mono_left nhdsWithin_le_nhds ++ · exact eventually_nhdsWithin_of_forall (fun x (hx : 1 < x) => by simp [hx.le]) ++ ++theorem limiting_fourier (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : ++ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ ∫ (t : ℝ), (G (1 + t * I)) * (ψ t) * x ^ (t * I) := by ++ have l1 := limiting_fourier_lim1 hcheby ψ (by linarith) ++ have l2 := limiting_fourier_lim2 A ψ hx ++ have l3 := limiting_fourier_lim3 hG ψ hx ++ apply tendsto_nhds_unique_of_eventuallyEq (l1.sub l2) l3 ++ simpa [eventuallyEq_nhdsWithin_iff, W21.ofCS2] using ++ Eventually.of_forall (limiting_fourier_aux hG' hf ψ hx) ++ ++theorem limiting_cor_aux {f : ℝ → ℂ} : ++ Tendsto (fun x : ℝ ↦ ∫ t, f t * x ^ (t * I)) atTop (𝓝 0) := by ++ have l1 : ∀ᶠ x : ℝ in atTop, ∀ t : ℝ, x ^ (t * I) = exp (log x * t * I) := by ++ filter_upwards [eventually_ne_atTop 0, eventually_ge_atTop 0] with x hx hx' t ++ rw [Complex.cpow_def_of_ne_zero (ofReal_ne_zero.mpr hx), ofReal_log hx'] ; ring_nf ++ have l2 : ∀ᶠ x : ℝ in atTop, ∫ t, f t * x ^ (t * I) = ∫ t, f t * exp (log x * t * I) := by ++ filter_upwards [l1] with x hx ++ refine integral_congr_ae (Eventually.of_forall (fun x => by simp [hx])) ++ simp_rw [tendsto_congr' l2] ++ convert_to Tendsto (fun x => 𝓕 f (-Real.log x / (2 * π))) atTop (𝓝 0) ++ · funext x ++ rw [Real.fourier_real_eq_integral_exp_smul] ++ apply integral_congr_ae ++ filter_upwards [] with t ++ have hphase : -2 * π * t * (-Real.log x / (2 * π)) = Real.log x * t := by ++ field_simp ++ rw [hphase, ofReal_mul, smul_eq_mul] ++ exact mul_comm _ _ ++ refine (Real.zero_at_infty_fourier f).comp <| Tendsto.mono_right ?_ _root_.atBot_le_cocompact ++ exact (tendsto_neg_atBot_iff.mpr tendsto_log_atTop).atBot_mul_const (inv_pos.mpr two_pi_pos) ++ ++theorem limiting_cor (ψ : CS 2 ℂ) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by ++ apply limiting_cor_aux.congr' ++ filter_upwards [eventually_ge_atTop 1] with x hx using ++ limiting_fourier hcheby hG hG' hf ψ hx |>.symm ++ ++end CatalanPNT +diff --git a/PrimeNumberTheoremAnd/Erdos970.lean b/PrimeNumberTheoremAnd/Erdos970.lean +new file mode 100644 +index 0000000..2137759 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970.lean +@@ -0,0 +1,19 @@ ++import PrimeNumberTheoremAnd.Erdos970.Auxiliary ++import PrimeNumberTheoremAnd.Erdos970.Consequences ++import PrimeNumberTheoremAnd.Erdos970.Defs ++import PrimeNumberTheoremAnd.Erdos970.EulerMaclaurin ++import PrimeNumberTheoremAnd.Erdos970.Fourier ++import PrimeNumberTheoremAnd.Erdos970.HadamardSupport ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Algebra.Notation.Support ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Analysis.Asymptotics.Asymptotics ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Analysis.SpecialFunctions.Log.Basic ++import PrimeNumberTheoremAnd.Erdos970.MellinCalculus ++import PrimeNumberTheoremAnd.Erdos970.MertensClassical ++import PrimeNumberTheoremAnd.Erdos970.Rectangle ++import PrimeNumberTheoremAnd.Erdos970.ResidueCalcOnRectangles ++import PrimeNumberTheoremAnd.Erdos970.SmoothExistence ++import PrimeNumberTheoremAnd.Erdos970.Sobolev ++import PrimeNumberTheoremAnd.Erdos970.Tactic.AdditiveCombination ++import PrimeNumberTheoremAnd.Erdos970.Wiener ++import PrimeNumberTheoremAnd.Erdos970.ZetaBounds ++import PrimeNumberTheoremAnd.Erdos970.ZetaConj +diff --git a/PrimeNumberTheoremAnd/Erdos970/Auxiliary.lean b/PrimeNumberTheoremAnd/Erdos970/Auxiliary.lean +new file mode 100644 +index 0000000..0273e54 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Auxiliary.lean +@@ -0,0 +1,71 @@ ++import Mathlib.Analysis.Complex.RealDeriv ++import Mathlib.Analysis.InnerProductSpace.Basic ++ ++namespace Erdos970 ++ ++namespace Complex ++ ++open _root_.Complex ++ ++lemma hasDerivAt_ofReal (x : ℝ) : HasDerivAt ofReal 1 x := ++ HasDerivAt.ofReal_comp <| hasDerivAt_id x ++ ++lemma deriv_ofReal (x : ℝ) : deriv ofReal x = 1 := ++ (hasDerivAt_ofReal x).deriv ++ ++lemma differentiableAt_ofReal (x : ℝ) : DifferentiableAt ℝ ofReal x := ++ (hasDerivAt_ofReal x).differentiableAt ++ ++end Complex ++ ++lemma DifferentiableAt.comp_ofReal {e : ℂ → ℂ} {z : ℝ} (hf : DifferentiableAt ℂ e z) : ++ DifferentiableAt ℝ (fun x : ℝ ↦ e x) z := ++ hf.hasDerivAt.comp_ofReal.differentiableAt ++ ++lemma deriv.comp_ofReal {e : ℂ → ℂ} {z : ℝ} (hf : DifferentiableAt ℂ e z) : ++ deriv (fun x : ℝ ↦ e x) z = deriv e z := ++ hf.hasDerivAt.comp_ofReal.deriv ++ ++lemma Differentiable.comp_ofReal {e : ℂ → ℂ} (h : Differentiable ℂ e) : ++ Differentiable ℝ (fun x : ℝ ↦ e x) := ++ fun _ ↦ DifferentiableAt.comp_ofReal h.differentiableAt ++ ++lemma DifferentiableAt.ofReal_comp {z : ℝ} {f : ℝ → ℝ} (hf : DifferentiableAt ℝ f z) : ++ DifferentiableAt ℝ (fun (y : ℝ) ↦ (f y : ℂ)) z := ++ hf.hasDerivAt.ofReal_comp.differentiableAt ++ ++lemma Differentiable.ofReal_comp {f : ℝ → ℝ} (hf : Differentiable ℝ f) : ++ Differentiable ℝ (fun (y : ℝ) ↦ (f y : ℂ)) := ++ fun _ ↦ DifferentiableAt.ofReal_comp hf.differentiableAt ++ ++open _root_.Complex ContinuousLinearMap in ++lemma HasDerivAt.of_hasDerivAt_ofReal_comp {z : ℝ} {f : ℝ → ℝ} {u : ℂ} ++ (hf : HasDerivAt (fun y ↦ (f y : ℂ)) u z) : ++ ∃ u' : ℝ, u = u' ∧ HasDerivAt f u' z := by ++ lift u to ℝ ++ · have H := (imCLM.hasFDerivAt.comp z hf.hasFDerivAt).hasDerivAt.deriv ++ simp only [Function.comp_def, imCLM_apply, ofReal_im, deriv_const] at H ++ rwa [eq_comm, comp_apply, imCLM_apply, toSpanSingleton_apply_one] at H ++ refine ⟨u, rfl, ?_⟩ ++ convert! (reCLM.hasFDerivAt.comp z hf.hasFDerivAt).hasDerivAt ++ rw [comp_apply, toSpanSingleton_apply_one, reCLM_apply, ofReal_re] ++ ++lemma DifferentiableAt.ofReal_comp_iff {z : ℝ} {f : ℝ → ℝ} : ++ DifferentiableAt ℝ (fun (y : ℝ) ↦ (f y : ℂ)) z ↔ DifferentiableAt ℝ f z := by ++ refine ⟨fun H ↦ ?_, ofReal_comp⟩ ++ obtain ⟨u, _, hu₂⟩ := HasDerivAt.of_hasDerivAt_ofReal_comp H.hasDerivAt ++ exact HasDerivAt.differentiableAt hu₂ ++ ++lemma Differentiable.ofReal_comp_iff {f : ℝ → ℝ} : ++ Differentiable ℝ (fun (y : ℝ) ↦ (f y : ℂ)) ↔ Differentiable ℝ f := ++ forall_congr' fun _ ↦ DifferentiableAt.ofReal_comp_iff ++ ++lemma deriv.ofReal_comp {z : ℝ} {f : ℝ → ℝ} : ++ deriv (fun (y : ℝ) ↦ (f y : ℂ)) z = deriv f z := by ++ by_cases hf : DifferentiableAt ℝ f z ++ · exact hf.hasDerivAt.ofReal_comp.deriv ++ · have hf' := mt DifferentiableAt.ofReal_comp_iff.mp hf ++ rw [deriv_zero_of_not_differentiableAt hf, deriv_zero_of_not_differentiableAt hf', ++ Complex.ofReal_zero] ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Consequences.lean b/PrimeNumberTheoremAnd/Erdos970/Consequences.lean +new file mode 100644 +index 0000000..4a72e0e +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Consequences.lean +@@ -0,0 +1,2293 @@ ++import Mathlib.NumberTheory.Harmonic.Bounds ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Analysis.SpecialFunctions.Log.Basic ++import PrimeNumberTheoremAnd.Erdos970.Defs ++import PrimeNumberTheoremAnd.Erdos970.Wiener ++ ++namespace Erdos970 ++ ++ ++open ArithmeticFunction hiding log ++open Nat hiding log ++open _root_.Finset _root_.Erdos970.Finset ++open BigOperators _root_.Filter _root_.Erdos970.Filter _root_.Real _root_.Erdos970.Real ++open Classical _root_.Asymptotics _root_.Erdos970.Asymptotics MeasureTheory intervalIntegral ++open scoped ArithmeticFunction.Moebius ArithmeticFunction.Omega Chebyshev ++ ++open _root_.Set in ++lemma Set.Ico_subset_Ico_of_Icc_subset_Icc {a b c d : ℝ} (h : Set.Icc a b ⊆ Set.Icc c d) : ++ Set.Ico a b ⊆ Set.Ico c d := by ++ intro z hz ++ have hz' := Set.Ico_subset_Icc_self.trans h hz ++ have hcd : c ≤ d := by ++ contrapose! hz' ++ rw [Icc_eq_empty_of_lt hz'] ++ exact notMem_empty _ ++ simp only [Set.mem_Ico, Set.mem_Icc] at * ++ refine ⟨hz'.1, hz'.2.eq_or_lt.resolve_left ?_⟩ ++ rintro rfl ++ apply hz.2.not_ge ++ have := h <| right_mem_Icc.mpr (hz.1.trans hz.2.le) ++ simp only [Set.mem_Icc] at this ++ exact this.2 ++ ++lemma th43_b (x : ℝ) (hx : 2 ≤ x) : ++ Nat.primeCounting ⌊x⌋₊ = ++ θ x / log x + ∫ t in Set.Icc 2 x, θ t / (t * (Real.log t) ^ 2) := by ++ rw [integral_Icc_eq_integral_Ioc, ← intervalIntegral.integral_of_le hx] ++ exact Chebyshev.primeCounting_eq_theta_div_log_add_integral hx ++ ++lemma finsum_range_eq_sum_range {R : Type*} [AddCommMonoid R] {f : ArithmeticFunction R} (x : ℝ) : ++ ∑ᶠ (n : ℕ) (_: n < x), f n = ∑ n ∈ range ⌈x⌉₊, f n := by ++ apply finsum_cond_eq_sum_of_cond_iff f ++ intros ++ simp only [mem_range] ++ exact Iff.symm Nat.lt_ceil ++ ++lemma finsum_range_eq_sum_range' {R : Type*} [AddCommMonoid R] {f : ArithmeticFunction R} ++ (x : ℝ) : ∑ᶠ (n : ℕ) (_ : n ≤ x), f n = ∑ n ∈ Iic ⌊x⌋₊, f n := by ++ apply finsum_cond_eq_sum_of_cond_iff f ++ intro n h ++ simp only [mem_Iic] ++ exact Iff.symm <| Nat.le_floor_iff' ++ fun (hc : n = 0) ↦ (h : f n ≠ 0) <| (congrArg f hc).trans ArithmeticFunction.map_zero ++ ++lemma log2_pos : 0 < log 2 := by ++ rw [Real.log_pos_iff zero_le_two] ++ exact one_lt_two ++ ++theorem Asymptotics.IsEquivalent.add_isLittleO' {α : Type*} {β : Type*} [NormedAddCommGroup β] ++ {u : α → β} {v : α → β} {w : α → β} {l : Filter α} ++ (huv : Asymptotics.IsEquivalent l u v) (hwu : (w - u) =o[l] v) : ++ Asymptotics.IsEquivalent l w v := by ++ rw [← add_sub_cancel u w] ++ exact huv.add_isLittleO hwu ++ ++theorem Asymptotics.IsEquivalent.add_isLittleO'' {α : Type*} {β : Type*} [NormedAddCommGroup β] ++ {u : α → β} {v : α → β} {w : α → β} {l : Filter α} ++ (huv : Asymptotics.IsEquivalent l u v) (hwu : (u - w) =o[l] v) : ++ Asymptotics.IsEquivalent l w v := by ++ rw [← sub_sub_self u w] ++ exact huv.sub_isLittleO hwu ++ ++theorem WeakPNT' : Tendsto (fun N ↦ (∑ n ∈ Iic N, Λ n) / N) atTop (nhds 1) := by ++ have : (fun N ↦ (∑ n ∈ Iic N, Λ n) / N) = ++ (fun N ↦ (∑ n ∈ range N, Λ n)/N + Λ N / N) := by ++ ext N ++ have : N ∈ Iic N := mem_Iic.mpr (le_refl _) ++ rw [← Finset.sum_erase_add _ _ this, ← Nat.Iio_eq_range, Iic_erase] ++ exact add_div _ _ _ ++ ++ rw [this, ← add_zero 1] ++ apply Tendsto.add WeakPNT ++ convert squeeze_zero (f := fun N ↦ Λ N / N) (g := fun N ↦ log N / N) (t₀ := atTop) ?_ ?_ ?_ ++ · intro N ++ exact div_nonneg vonMangoldt_nonneg (cast_nonneg N) ++ · intro N ++ exact div_le_div_of_nonneg_right vonMangoldt_le_log (cast_nonneg N) ++ have := Real.tendsto_pow_log_div_pow_atTop 1 1 Real.zero_lt_one ++ simp only [rpow_one] at this ++ exact Tendsto.comp this tendsto_natCast_atTop_atTop ++ ++theorem WeakPNT'' : ψ ~[atTop] (fun x ↦ x) := by ++ rw [(by rfl : ψ = (fun x ↦ ψ x))] ++ simp_rw [Chebyshev.psi_eq_sum_Icc] ++ apply IsEquivalent.trans (v := fun x ↦ (⌊x⌋₊:ℝ)) ++ · rw [isEquivalent_iff_tendsto_one] ++ · convert! Tendsto.comp WeakPNT' tendsto_nat_floor_atTop ++ infer_instance ++ rw [eventually_iff] ++ simp only [ne_eq, cast_eq_zero, floor_eq_zero, not_lt, mem_atTop_sets, ++ Set.mem_ofPred_eq] ++ use 1 ++ simp only [imp_self, implies_true] ++ apply IsLittleO.isEquivalent ++ rw [← isLittleO_neg_left] ++ apply IsLittleO.of_bound ++ intro ε hε ++ simp only [Pi.sub_apply, neg_sub, norm_eq_abs, eventually_atTop] ++ use ε⁻¹ ++ intro b hb ++ have hb' : 0 ≤ b := le_of_lt (lt_of_lt_of_le (inv_pos_of_pos hε) hb) ++ rw [abs_of_nonneg, abs_of_nonneg hb'] ++ · apply LE.le.trans _ ((inv_le_iff_one_le_mul₀' hε).mp hb) ++ linarith [Nat.lt_floor_add_one b] ++ rw [sub_nonneg] ++ exact floor_le hb' ++ ++lemma isLittleO_sqrt_mul_log : (fun x : ℝ ↦ x.sqrt * x.log) =o[atTop] _root_.id := by ++ have : (fun x : ℝ ↦ x.sqrt * x.log) =o[atTop] fun x ↦ x := by ++ refine (isLittleO_mul_iff_isLittleO_div ?_).mpr ?_ ++ · filter_upwards [eventually_gt_atTop 0] with x hx; exact (sqrt_ne_zero hx.le).mpr hx.ne' ++ · convert! isLittleO_log_rpow_atTop (by norm_num : (0 : ℝ) < 1 / 2) using 2 with x ++ rw [div_sqrt, sqrt_eq_rpow] ++ exact this ++ ++lemma tendsto_floor_add_one_div_self : Tendsto (fun x : ℝ ↦ (⌊x⌋₊ + 1 : ℝ) / x) atTop (nhds 1) := by ++ have h := Asymptotics.isEquivalent_nat_floor (R := ℝ) ++ have h' : IsEquivalent atTop (fun x : ℝ ↦ (⌊x⌋₊ : ℝ) + 1) _root_.id := ++ h.add_isLittleO (isLittleO_const_id_atTop 1) ++ rwa [isEquivalent_iff_tendsto_one ++ (by filter_upwards [eventually_gt_atTop 0] with x hx a; simp only [_root_.id] at a; linarith)] at h' ++ ++lemma isTheta_self_div_const {c : ℝ} (hc : c ≠ 0) : (fun x : ℝ ↦ x) =Θ[atTop] fun x ↦ x / c := by ++ have : (fun x : ℝ ↦ x / c) = fun x ↦ c⁻¹ * x := by ext x; ring ++ exact this ▸ (isTheta_const_mul_left (inv_ne_zero hc)).mpr (isTheta_refl ..) |>.symm ++ ++lemma filter_prime_Iic_eq_Icc (n : ℕ) : filter Prime (Iic n) = filter Prime (Icc 1 n) := by ++ ext p; simp only [mem_filter, mem_Iic, mem_Icc, and_congr_left_iff] ++ exact fun hp ↦ ⟨fun h ↦ ⟨hp.one_lt.le, h⟩, fun ⟨_, h⟩ ↦ h⟩ ++ ++lemma Icc_zero_eq_insert (n : ℕ) : Icc 0 n = insert 0 (Icc 1 n) := by ++ ext m; simp [mem_Icc]; omega ++ ++theorem chebyshev_asymptotic : θ ~[atTop] id := by ++ refine Asymptotics.IsEquivalent.add_isLittleO'' WeakPNT'' ++ (IsBigO.trans_isLittleO (g := fun x ↦ 2 * x.sqrt * x.log) ?_ ?_) ++ · rw [isBigO_iff']; refine ⟨1, one_pos, ?_⟩ ++ simp only [one_mul, eventually_atTop] ++ exact ⟨2, fun x hx ↦ by ++ rw [Pi.sub_apply, norm_eq_abs, norm_eq_abs, abs_of_nonneg (by bound : 0 ≤ 2 * √x * log x)] ++ exact (abs_of_nonneg (sub_nonneg.mpr (Chebyshev.theta_le_psi x))).symm ▸ ++ Chebyshev.abs_psi_sub_theta_le_sqrt_mul_log (by linarith : 1 ≤ x)⟩ ++ · simpa only [mul_assoc] using! isLittleO_sqrt_mul_log.const_mul_left 2 ++ ++theorem chebyshev_asymptotic_finsum : ++ (fun x ↦ ∑ᶠ (p : ℕ) (_ : p ≤ x) (_ : Nat.Prime p), log p) ~[atTop] fun x ↦ x := by ++ have hReal : ++ (fun x : ℝ ↦ ∑ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x) (_ : p.Prime), log (p : ℝ)) ~[atTop] ++ fun x ↦ x := by ++ have h x : ∑ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x) (_ : p.Prime), log (p : ℝ) = θ x := by ++ rw [Chebyshev.theta_eq_sum_Icc] ++ have hfin : {p : ℕ | (p : ℝ) ≤ x ∧ p.Prime}.Finite := ++ (Iic ⌊x⌋₊).finite_toSet.subset fun p ⟨hpx, _⟩ ↦ mem_Iic.mpr (Nat.le_floor hpx) ++ calc ∑ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x) (_ : p.Prime), log (p : ℝ) ++ = ∑ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x ∧ p.Prime), log (p : ℝ) := ++ finsum_congr fun p ↦ by by_cases hp : p.Prime <;> simp [hp] ++ _ = ∑ p ∈ hfin.toFinset, log (p : ℝ) := finsum_mem_eq_finite_toFinset_sum _ hfin ++ _ = _ := sum_congr (by ext p; simp only [Set.Finite.mem_toFinset, Set.mem_ofPred_eq, ++ mem_filter, mem_Icc, and_congr_left_iff]; exact fun hp ↦ ++ ⟨fun hpx ↦ ⟨Nat.zero_le _, Nat.le_floor hpx⟩, fun ⟨_, hpn⟩ ↦ ++ (le_or_gt 0 x).elim ++ (fun hx ↦ (Nat.floor_le hx).trans' (Nat.cast_le.mpr hpn)) fun hx ↦ ++ absurd (Nat.le_zero.mp (Nat.floor_eq_zero.mpr (hx.trans_le zero_le_one) ▸ hpn)) ++ hp.ne_zero⟩) (fun _ _ ↦ rfl) ++ have heq : ++ (fun x : ℝ ↦ ∑ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x) (_ : p.Prime), log (p : ℝ)) =ᶠ[atTop] θ := ++ Filter.Eventually.of_forall h ++ exact chebyshev_asymptotic.congr_left heq.symm ++ simp only [IsEquivalent, ++ show (fun n : ℕ ↦ ∑ᶠ (p : ℕ) (_ : p ≤ n) (_ : p.Prime), log (p : ℝ)) = ++ (fun x : ℝ ↦ ∑ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x) (_ : p.Prime), log (p : ℝ)) ∘ Nat.cast ++ from funext fun _ ↦ finsum_congr fun _ ↦ by simp] ++ exact hReal.isLittleO.comp_tendsto tendsto_natCast_atTop_atTop ++ ++theorem chebyshev_asymptotic' : ++ ∃ (f : ℝ → ℝ), ++ (∀ ε > (0 : ℝ), (f =o[atTop] fun t ↦ ε * t)) ∧ ++ (∀ (x : ℝ), 2 ≤ x → IntegrableOn f (Set.Icc 2 x)) ∧ ++ ∀ (x : ℝ), θ x = x + f x := by ++ have H := chebyshev_asymptotic ++ rw [IsEquivalent, isLittleO_iff] at H ++ let f := (fun x ↦ θ x - x) ++ have integrable (x : ℝ) (hx : 2 ≤ x) : IntegrableOn f (Set.Icc 2 x) := by ++ rw [IntegrableOn] ++ refine Integrable.sub ?_ (ContinuousOn.integrableOn_Icc (continuousOn_id' _)) ++ refine Chebyshev.integrableOn_theta_div_id_mul_log_sq x |>.mul_continuousOn (g' := fun t => t * log t ^ 2) ++ (ContinuousOn.mul (continuousOn_id' _) (ContinuousOn.pow (continuousOn_log |>.mono <| by ++ rintro t ⟨ht1, _⟩ ++ simp only [Set.mem_compl_iff, Set.mem_singleton_iff] ++ linarith) 2)) isCompact_Icc |>.congr_fun_ae ?_ ++ simp only [measurableSet_Icc, ae_restrict_eq, EventuallyEq, eventually_inf_principal] ++ refine .of_forall fun t ⟨ht1, _⟩ => ?_ ++ rw [div_mul_cancel₀] ++ simpa only [ne_eq, _root_.mul_eq_zero, OfNat.ofNat_ne_zero, not_false_eq_true, pow_eq_zero_iff, ++ log_eq_zero, or_self_left, not_or] using ⟨by linarith, by linarith, by linarith⟩ ++ refine ⟨f, fun ε hε ↦ ?_, integrable, ?_⟩ ++ · rw [isLittleO_iff] ++ intro c hc ++ specialize @H (c * ε) (mul_pos hc hε) ++ simp only [Pi.sub_apply, norm_eq_abs, mul_assoc, eventually_atTop, norm_mul, ++ abs_of_pos hε, f] at H ⊢ ++ exact H ++ refine fun r => by simp [f] ++ ++theorem chebyshev_asymptotic'' : ++ ∃ (f : ℝ → ℝ), ++ (∀ ε > (0 : ℝ), (f =o[atTop] fun _ ↦ ε)) ∧ ++ (∀ (x : ℝ), 2 ≤ x → IntegrableOn f (Set.Icc 2 x)) ∧ ++ ∀ x > (0 : ℝ), θ x = x + x * (f x) := by ++ obtain ⟨f, hf1, inte, hf2⟩ := chebyshev_asymptotic' ++ refine ⟨fun t => f t / t, fun ε hε ↦ ?_, ?_, ?_⟩ ++ · simp only [isLittleO_iff, norm_eq_abs, norm_mul, eventually_atTop, ++ norm_div] at hf1 ⊢ ++ intro r hr ++ replace hf1 := hf1 ε hε ++ obtain ⟨N, hN⟩ := hf1 hr ++ use |N| + 1 ++ intro x hx ++ have hx' : |N| + 1 ≤ |x| := by rwa [abs_of_nonneg (a := x) (le_trans (by positivity) hx)] ++ rw [div_le_iff₀ (lt_of_lt_of_le (by positivity) hx'), mul_assoc] ++ exact hN x (le_trans (le_trans (le_abs_self N) (by linarith)) hx) ++ ++ · intro x hx ++ refine inte x hx |>.mul_continuousOn (g' := fun t : ℝ => t⁻¹) ++ (continuousOn_inv₀ |>.mono <| by ++ rintro t ⟨ht1, _⟩ ++ simp only [Set.mem_compl_iff, Set.mem_singleton_iff] ++ linarith) isCompact_Icc |>.congr_fun_ae <| .of_forall <| by simp [div_eq_mul_inv] ++ intro x hx ++ rw [hf2, mul_div_cancel₀] ++ linarith ++ ++theorem primorial_bounds : ++ ∃ E : ℝ → ℝ, E =o[atTop] (fun x ↦ x) ∧ ++ ∀ x : ℝ, ∏ p ∈ (Iic ⌊x⌋₊).filter Nat.Prime, p = exp (x + E x) := by ++ use (fun x ↦ ∑ p ∈ (filter Nat.Prime (Iic ⌊x⌋₊)), log p - x) ++ constructor ++ · exact Asymptotics.IsEquivalent.isLittleO chebyshev_asymptotic ++ intro x ++ simp only [cast_prod, add_sub_cancel, exp_sum] ++ apply Finset.prod_congr rfl ++ intros x hx ++ rw[Real.exp_log] ++ rw[Finset.mem_filter] at hx ++ norm_cast ++ exact Nat.Prime.pos hx.right ++ ++theorem primorial_bounds_finprod : ++ ∃ E : ℝ → ℝ, E =o[atTop] (fun x ↦ x) ∧ ++ ∀ x : ℝ, ∏ᶠ (p : ℕ) (_ : p ≤ x) (_ : Nat.Prime p), p = exp (x + E x) := by ++ obtain ⟨E, hE, hprod⟩ := primorial_bounds ++ refine ⟨E, hE, fun x ↦ ?_⟩ ++ have hfin : {p : ℕ | (p : ℝ) ≤ x ∧ p.Prime}.Finite := ++ (Iic ⌊x⌋₊).finite_toSet.subset fun p ⟨hpx, _⟩ ↦ mem_Iic.mpr <| le_floor hpx ++ have heq : ∏ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x) (_ : p.Prime), p = ++ ∏ p ∈ (Iic ⌊x⌋₊).filter Prime, p := by ++ calc ∏ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x) (_ : p.Prime), p ++ = ∏ᶠ (p : ℕ) (_ : (p : ℝ) ≤ x ∧ p.Prime), p := ++ finprod_congr fun p ↦ by by_cases hp : p.Prime <;> simp [hp] ++ _ = ∏ p ∈ hfin.toFinset, p := finprod_mem_eq_finite_toFinset_prod _ hfin ++ _ = _ := prod_congr (by ext p; simp only [Set.Finite.mem_toFinset, Set.mem_ofPred_eq, ++ mem_filter, mem_Iic, and_congr_left_iff]; exact fun hp ↦ ++ ⟨le_floor, fun hpn ↦ (le_or_gt 0 x).elim ++ (fun hx ↦ (Nat.floor_le hx).trans' (cast_le.mpr hpn)) fun hx ↦ ++ absurd (le_zero.mp (floor_eq_zero.mpr (hx.trans_le zero_le_one) ▸ hpn)) ++ hp.ne_zero⟩) (fun _ _ ↦ rfl) ++ simp only [heq, hprod] ++ ++lemma continuousOn_log0 : ++ ContinuousOn (fun x ↦ -1 / (x * log x ^ 2)) {0, 1, -1}ᶜ := by ++ refine fun t ht ↦ ContinuousAt.continuousWithinAt ?_ ++ fun_prop (disch := simp_all) ++ ++lemma continuousOn_log1 : ContinuousOn (fun x ↦ (log x ^ 2)⁻¹ * x⁻¹) {0, 1, -1}ᶜ := by ++ refine fun t ht ↦ ContinuousAt.continuousWithinAt ?_ ++ fun_prop (disch := simp_all) ++ ++lemma integral_log_inv (a b : ℝ) (ha : 2 ≤ a) (hb : a ≤ b) : ++ ∫ t in a..b, (log t)⁻¹ = ++ ((log b)⁻¹ * b) - ((log a)⁻¹ * a) + ++ ∫ t in a..b, ((log t)^2)⁻¹ := by ++ rw [le_iff_lt_or_eq] at hb ++ rcases hb with hb | rfl; swap ++ · simp only [intervalIntegral.integral_same, sub_self, add_zero] ++ · have := intervalIntegral.integral_mul_deriv_eq_deriv_mul ++ (u := fun x => (log x)⁻¹) ++ (u' := fun x => -1 / (x * (log x)^2)) ++ (v := fun x => x) ++ (v' := fun _ => 1) (a := a) (b := b) ++ (fun x hx => by ++ rw [Set.uIcc_eq_union, Set.Icc_eq_empty (lt_iff_not_ge |>.1 hb), Set.union_empty] at hx ++ obtain ⟨hx1, _⟩ := hx ++ rw [show (-1 / (x * log x ^ 2)) = (-1 / log x ^ 2) * (x⁻¹) by ++ rw [mul_comm x]; field_simp] ++ apply HasDerivAt.comp ++ (h := fun t => log t) (h₂ := fun t => t⁻¹) (x := x) ++ · simpa using! HasDerivAt.inv (c := fun t : ℝ => t) (c' := 1) (x := log x) ++ (hasDerivAt_id' (log x)) ++ (by simp only [ne_eq, log_eq_zero, not_or]; refine ⟨?_, ?_, ?_⟩ <;> linarith) ++ · apply hasDerivAt_log; linarith) ++ (fun x _ => hasDerivAt_id' x) ++ (by ++ rw [intervalIntegrable_iff_integrableOn_Icc_of_le (le_of_lt hb)] ++ apply ContinuousOn.integrableOn_Icc ++ refine continuousOn_log0.mono fun x hx ↦ ?_ ++ simp only [Set.mem_Icc, Set.mem_compl_iff, Set.mem_insert_iff, Set.mem_singleton_iff, ++ not_or] at hx ⊢ ++ refine ⟨?_, ?_, ?_⟩ <;> linarith) ++ (by ++ constructor <;> ++ apply MeasureTheory.integrable_const) ++ simp only [mul_one] at this ++ rw [this] ++ simp_rw [neg_div, neg_mul] ++ rw [sub_eq_add_neg] ++ congr 1 ++ rw [intervalIntegral.integral_of_le (le_of_lt hb), ++ intervalIntegral.integral_of_le (le_of_lt hb), ++ ← MeasureTheory.integral_neg] ++ simp_rw [neg_neg] ++ refine integral_congr_ae ?_ ++ · rw [ae_restrict_eq, eventuallyEq_inf_principal_iff] ++ · refine .of_forall fun x hx => ?_ ++ simp only [Set.mem_Ioc, one_div, mul_inv_rev, mul_assoc] at hx ⊢ ++ rw [inv_mul_cancel₀, mul_one] ++ linarith ++ exact measurableSet_Ioc ++ ++lemma integral_log_inv' (a b : ℝ) (ha : 2 ≤ a) (hb : a ≤ b) : ++ ∫ t in Set.Icc a b, (log t)⁻¹ = ++ ((log b)⁻¹ * b) - ((log a)⁻¹ * a) + ++ ∫ t in Set.Icc a b, ((log t)^2)⁻¹ := by ++ have := integral_log_inv a b ha hb ++ simp only [intervalIntegral.intervalIntegral_eq_integral_uIoc, ite_eq_left hb, Set.uIoc_of_le hb, ++ smul_eq_mul, one_mul] at this ++ rw [integral_Icc_eq_integral_Ioc, integral_Icc_eq_integral_Ioc] ++ rw [this] ++ ++lemma integral_log_inv'' (a b : ℝ) (ha : 2 ≤ a) (hb : a ≤ b) : ++ (log a)⁻¹ * a + ∫ t in Set.Icc a b, (log t)⁻¹ = ++ ((log b)⁻¹ * b) + ∫ t in Set.Icc a b, ((log t)^2)⁻¹ := by ++ rw [integral_log_inv' a b ha hb] ++ group ++ ++lemma integral_log_inv_pos (x : ℝ) (hx : 2 < x) : ++ 0 < ∫ t in Set.Icc 2 x, (log t)⁻¹ := by ++ classical ++ rw [MeasureTheory.integral_pos_iff_support_of_nonneg_ae] ++ · simp only [Function.support_inv, measurableSet_Icc, Measure.restrict_apply'] ++ rw [show Function.support log ∩ Set.Icc 2 x = Set.Icc 2 x by ++ rw [Set.inter_eq_right] ++ intro t ht ++ simp only [Set.mem_Icc, Function.mem_support, ne_eq, log_eq_zero, not_or] at ht ⊢ ++ exact ⟨by linarith, by linarith, by linarith⟩] ++ simpa ++ · simp only [measurableSet_Icc, ae_restrict_eq, EventuallyLE, eventually_inf_principal] ++ refine .of_forall fun t (ht : _ ∧ _) => ?_ ++ simpa only [Pi.zero_apply, inv_nonneg] using log_nonneg (by linarith) ++ · apply ContinuousOn.integrableOn_Icc ++ apply ContinuousOn.inv₀ ++ · exact (continuousOn_log).mono <| by aesop ++ ++ · rintro t ⟨ht, -⟩ ++ simp only [ne_eq, log_eq_zero, not_or] ++ exact ⟨by linarith, by linarith, by linarith⟩ ++ ++lemma integral_log_inv_ne_zero (x : ℝ) (hx : 2 < x) : ++ ∫ t in Set.Icc 2 x, (log t)⁻¹ ≠ 0 := by ++ have := integral_log_inv_pos x hx ++ linarith ++ ++lemma pi_asymp_aux (x : ℝ) (hx : 2 ≤ x) : Nat.primeCounting ⌊x⌋₊ = ++ (log x)⁻¹ * θ x + ∫ t in Set.Icc 2 x, θ t * (t * log t ^ 2)⁻¹ := by ++ rw [th43_b _ hx] ++ simp_rw [div_eq_mul_inv, Chebyshev.theta_eq_sum_Icc] ++ ring_nf! ++ ++theorem pi_asymp'' : ++ (fun x => ((Nat.primeCounting ⌊x⌋₊ : ℝ) / ∫ t in Set.Icc 2 x, 1 / log t) - (1 : ℝ)) =o[atTop] ++ fun _ => (1 : ℝ) := by ++ obtain ⟨f, hf, f_int, hf'⟩ := chebyshev_asymptotic'' ++ have eq1 : ∀ᶠ (x : ℝ) in atTop, ++ ⌊x⌋₊.primeCounting = ++ (log x)⁻¹ * (x + x * f x) + ++ (∫ t in Set.Icc 2 x, ++ (t + t * f t) * (t * log t ^ 2)⁻¹) := by ++ filter_upwards [eventually_ge_atTop 2] with x hx ++ rw [pi_asymp_aux x hx, hf' x (by linarith)] ++ congr 1 ++ apply setIntegral_congr_fun measurableSet_Icc fun t ht ↦ ?_ ++ rw [hf' t (by grind)] ++ ++ replace eq1 : ++ ∀ᶠ (x : ℝ) in atTop, ++ ⌊x⌋₊.primeCounting = ++ (log x)⁻¹ * (x + x * f x) + ++ ((∫ t in Set.Icc 2 x, (log t ^ 2)⁻¹) + ++ (∫ t in Set.Icc 2 x, (f t) * (log t ^ 2)⁻¹)) := by ++ filter_upwards [eq1, eventually_ge_atTop 2] with x eq1 hx ++ rw [eq1] ++ congr ++ simp_rw [mul_inv_rev, add_mul] ++ rw [MeasureTheory.integral_add] ++ · congr 1 ++ all_goals ++ apply setIntegral_congr_fun measurableSet_Icc fun t ht ↦ ?_ ++ field [show t ≠ 0 by grind] ++ · apply IntegrableOn.mul_continuousOn ++ (hg := ContinuousOn.integrableOn_Icc <| continuousOn_id' _) ++ (hK := isCompact_Icc) ++ apply continuousOn_log1.mono ?_ ++ intro y h ++ simp only [Set.mem_Icc, Set.mem_compl_iff, Set.mem_insert_iff, ++ Set.mem_singleton_iff, not_or] at h ⊢ ++ exact ⟨by linarith, by linarith, by linarith⟩ ++ · rw [show (fun t ↦ t * f t * ((log t ^ 2)⁻¹ * t⁻¹)) = ++ fun t ↦ f t * (t * (log t ^ 2)⁻¹ * t⁻¹) by ext; ring] ++ apply IntegrableOn.mul_continuousOn (hK := isCompact_Icc) ++ · apply f_int x (by linarith) ++ · simp_rw [mul_assoc] ++ refine ContinuousOn.mul (continuousOn_id' (Set.Icc 2 x)) ?_ ++ apply continuousOn_log1.mono ?_ ++ intro y h ++ simp only [Set.mem_Icc, Set.mem_compl_iff, Set.mem_insert_iff, ++ Set.mem_singleton_iff, not_or] at h ⊢ ++ exact ⟨by linarith, by linarith, by linarith⟩ ++ ++ simp_rw [mul_add] at eq1 ++ simp_rw [show ∀ (x : ℝ), ++ (log x)⁻¹ * x + (log x)⁻¹ * (x * f x) + ++ ((∫ (t : ℝ) in Set.Icc 2 x, (log t ^ 2)⁻¹) + ++ ∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹) = ++ ((log x)⁻¹ * x + (∫ (t : ℝ) in Set.Icc 2 x, (log t ^ 2)⁻¹)) + ++ ((log x)⁻¹ * (x * f x) + ++ ∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹) ++ by intros; ring] at eq1 ++ ++ replace eq1 : ++ ∃ (C : ℝ), ∀ᶠ (x : ℝ) in atTop, ++ ⌊x⌋₊.primeCounting = ++ (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ ((log x)⁻¹ * (x * f x) + ++ ∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹) + ++ C := by ++ use ((log 2)⁻¹ * 2) ++ filter_upwards [eq1, eventually_ge_atTop 2] with x eq1 hx ++ rw [eq1, ← integral_log_inv'' _ _ (by rfl) hx] ++ ring ++ replace eq1 : ++ ∃ (C : ℝ), ∀ᶠ (x : ℝ) in atTop, ++ (⌊x⌋₊.primeCounting / ∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) - 1 = ++ ((log x)⁻¹ * (x * f x) / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ (∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹) / ++ (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹)) + ++ C / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) := by ++ obtain ⟨C, hC⟩ := eq1 ++ use C ++ filter_upwards [hC, eventually_gt_atTop 2] with x hC hx ++ rw [hC] ++ field [integral_log_inv_ne_zero] ++ simp_rw [isLittleO_iff] at hf ++ choose C hC using eq1 ++ simp_rw [← one_div] at hC ++ apply isLittleO_congr hC (by rfl) |>.mpr ++ have ineq1 (ε : ℝ) (hε : 0 < ε) (c : ℝ) (hc : 0 < c) : ∀ᶠ(x : ℝ) in atTop, ++ (log x)⁻¹ * x * |f x| ≤ c * ε * ((log x)⁻¹ * x) := by ++ filter_upwards [eventually_ge_atTop 2, hf ε hε hc] with x hx hM ++ simp only [norm_eq_abs] at hM ++ rw [abs_of_pos hε] at hM ++ rw [mul_comm (c * ε)] ++ gcongr ++ bound ++ have int_flog {a b : ℝ} (ha: 2 ≤ a) (hb : 2 ≤ b) : ++ IntegrableOn (fun t ↦ |f t| * (log t ^ 2)⁻¹) (Set.Icc a b) volume := by ++ apply IntegrableOn.mul_continuousOn ++ · apply Integrable.abs <| f_int b hb |>.mono (Set.Icc_subset_Icc_left ha) (by rfl) ++ · refine ContinuousOn.inv₀ (ContinuousOn.pow (continuousOn_log |>.mono ?_) 2) ?_ ++ · simp ++ grind ++ · intro t ht ++ simp only [Set.mem_Icc, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, ++ pow_eq_zero_iff, log_eq_zero, not_or] at ht ⊢ ++ exact ⟨by linarith, by linarith, by linarith⟩ ++ · exact isCompact_Icc ++ have int_inv_log_sq {a b : ℝ} (ha : 2 ≤ a) (hb : 2 ≤ b) : ++ IntegrableOn (fun t ↦ (log t ^ 2)⁻¹) (Set.Icc a b) volume := by ++ refine ContinuousOn.integrableOn_Icc <| ++ ContinuousOn.inv₀ (ContinuousOn.pow (continuousOn_log |>.mono ?_) 2) ?_ ++ · grind ++ · intro t ht ++ simp only [Set.mem_Icc, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, ++ pow_eq_zero_iff, log_eq_zero, not_or] at ht ⊢ ++ exact ⟨by linarith, by linarith, by linarith⟩ ++ simp_rw [eventually_atTop] at hf ++ choose M hM using hf ++ have ineq2 (ε : ℝ) (hε : 0 < ε) (c : ℝ) (hc : 0 < c) : ++ ∃ (D : ℝ), ++ ∀ᶠ (x : ℝ) in atTop, ++ |∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹| ≤ ++ c * ε * ((∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) - (log x)⁻¹ * x) + D := by ++ use (((∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), |f t| * (log t ^ 2)⁻¹) - ++ c * ε * ∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), (log t ^ 2)⁻¹) + ++ c * ε * ((log 2)⁻¹ * 2)) ++ filter_upwards [eventually_gt_atTop (max 2 (M ε hε hc))] with x hx ++ calc _ ++ _ ≤ ∫ (t : ℝ) in Set.Icc 2 x, |f t * (log t ^ 2)⁻¹| := ++ norm_integral_le_integral_norm fun a ↦ f a * (log a ^ 2)⁻¹ ++ _ = ∫ (t : ℝ) in Set.Icc 2 x, |f t| * (log t ^ 2)⁻¹ := by ++ apply setIntegral_congr_fun measurableSet_Icc fun t ht ↦ ?_ ++ rw [abs_mul, abs_of_nonneg (a := (log t ^ 2)⁻¹)] ++ norm_num ++ apply pow_nonneg ++ exact log_nonneg <| by grind ++ _ = (∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), ++ |f t| * (log t ^ 2)⁻¹) + ++ (∫ (t : ℝ) in Set.Icc (max 2 (M ε hε hc)) x, ++ |f t| * (log t ^ 2)⁻¹) := by ++ rw [← setIntegral_union₀, Set.Icc_union_Icc_eq_Icc (le_max_left ..) hx.le] ++ · rw [AEDisjoint, Set.Icc_inter_Icc_eq_singleton (le_max_left ..) hx.le, volume_singleton] ++ · simp only [measurableSet_Icc, MeasurableSet.nullMeasurableSet] ++ · apply int_flog (by rfl) (le_max_left ..) ++ · apply int_flog (le_max_left ..) (le_trans (le_max_left ..) hx.le) ++ _ ≤ (∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), ++ |f t| * (log t ^ 2)⁻¹) + ++ (∫ (t : ℝ) in Set.Icc (max 2 (M ε hε hc)) x, ++ (c * ε) * (log t ^ 2)⁻¹) := by ++ gcongr 1 ++ apply setIntegral_mono_on ++ · apply int_flog (le_max_left ..) (le_trans (le_max_left ..) hx.le) ++ · rw [IntegrableOn, integrable_const_mul_iff] ++ · apply int_inv_log_sq (le_max_left ..) (le_trans (le_max_left ..) hx.le) ++ · simp only [isUnit_iff_ne_zero, ne_eq, _root_.mul_eq_zero, not_or] ++ exact ⟨by linarith, by linarith⟩ ++ · exact measurableSet_Icc ++ · intro t ht ++ simp only [Set.mem_Icc, sup_le_iff] at ht ++ apply mul_le_mul_of_nonneg_right ++ · refine hM ε hε hc t ht.1.2 |>.trans ?_ ++ simp only [norm_eq_abs, abs_of_pos hε, le_refl] ++ · norm_num ++ refine pow_nonneg (log_nonneg <| by linarith) 2 ++ _ = (∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), ++ |f t| * (log t ^ 2)⁻¹) + ++ ((c * ε) * ∫ (t : ℝ) in Set.Icc (max 2 (M ε hε hc)) x, (log t ^ 2)⁻¹) := by ++ congr 1 ++ exact integral_const_mul (c * ε) _ ++ _ = (∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), ++ |f t| * (log t ^ 2)⁻¹) + ++ ((c * ε) * ++ ((∫ (t : ℝ) in Set.Icc (max 2 (M ε hε hc)) x, (log t ^ 2)⁻¹) + ++ ((∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), (log t ^ 2)⁻¹)) - ++ ((∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), (log t ^ 2)⁻¹)))) := by ++ ring ++ _ = (∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), ++ |f t| * (log t ^ 2)⁻¹) + ++ ((c * ε) * ++ ((∫ (t : ℝ) in Set.Icc 2 x, (log t ^ 2)⁻¹) - ++ ((∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), (log t ^ 2)⁻¹)))) := by ++ congr 3 ++ rw [add_comm, ← setIntegral_union₀, Set.Icc_union_Icc_eq_Icc (le_max_left ..) hx.le] ++ · rw [AEDisjoint, Set.Icc_inter_Icc_eq_singleton (le_max_left ..) hx.le, ++ volume_singleton] ++ · simp only [measurableSet_Icc, MeasurableSet.nullMeasurableSet] ++ · apply int_inv_log_sq (by rfl) (le_max_left ..) ++ · apply int_inv_log_sq (le_max_left ..) (le_trans (le_max_left ..) hx.le) ++ _ = ((c * ε) * (∫ (t : ℝ) in Set.Icc 2 x, (log t ^ 2)⁻¹)) + ++ ((∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), ++ |f t| * (log t ^ 2)⁻¹) - ++ (c * ε) * (∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), (log t ^ 2)⁻¹)) := by ++ ring ++ _ = ((c * ε) * ((∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ ((log 2)⁻¹ * 2) - ((log x)⁻¹ * x))) + ++ ((∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), ++ |f t| * (log t ^ 2)⁻¹) - ++ (c * ε) * (∫ (t : ℝ) in Set.Icc 2 (max 2 (M ε hε hc)), (log t ^ 2)⁻¹)) := by ++ congr 2 ++ rw [integral_log_inv' _ _ (by rfl)] ++ · ring ++ · simp only [max_lt_iff] at hx ++ linarith ++ _ = _ := by ring ++ choose D hD using ineq2 ++ ++ have ineq4 (const : ℝ) (ε : ℝ) (hε : 0 < ε) : ++ ∀ᶠ x in atTop, |const / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹)| ≤ 1/2 * ε := by ++ obtain rfl|hconst := eq_or_ne const 0 ++ · filter_upwards with x ++ simp[hε.le] ++ have ineq (x : ℝ) (hx : 2 < x) := ++ calc (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) ++ _ ≥ (∫ (_ : ℝ) in Set.Icc 2 x, (log x)⁻¹) := by ++ apply setIntegral_mono_on (integrable_const _) ++ · refine ContinuousOn.integrableOn_Icc <| ++ ContinuousOn.inv₀ (continuousOn_log |>.mono ?_) ?_ ++ · simp only [Set.subset_compl_singleton_iff, Set.mem_Icc, not_and, not_le, ++ isEmpty_Prop, ofNat_pos, IsEmpty.forall_iff] ++ · intro t ht ++ simp only [Set.mem_Icc, ne_eq, log_eq_zero, not_or] at ht ⊢ ++ exact ⟨by linarith, by linarith, by linarith⟩ ++ · exact measurableSet_Icc ++ · intro t ⟨ht1, ht2⟩ ++ gcongr ++ bound ++ _ = (x - 2) * (log x)⁻¹ := by ++ rw [MeasureTheory.integral_const] ++ simp only [MeasurableSet.univ, Measure.restrict_apply, Set.univ_inter, volume_Icc, ++ smul_eq_mul, mul_eq_mul_right_iff, ENNReal.toReal_ofReal_eq_iff, sub_nonneg, ++ inv_eq_zero, log_eq_zero, Measure.real] ++ refine Or.inl (le_of_lt hx) ++ ++ simp_rw [abs_div] ++ have ineq (x : ℝ) (hx : 2 < x) : ++ |const| / |∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹| ≤ ++ |const| / ((x - 2) * (log x)⁻¹) := by ++ apply div_le_div₀ (abs_nonneg _) (by rfl) ++ · apply mul_pos ++ · linarith ++ · norm_num ++ rw [Real.log_pos_iff] ++ · linarith ++ · linarith ++ · rw [abs_of_pos (integral_log_inv_pos _ hx)] ++ exact ineq x hx ++ have ineq (x : ℝ) (hx : 2 < x) : ++ |const| / |∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹| ≤ ++ |const| * (log x / ((x - 2))) := by ++ refine ineq x hx |>.trans <| le_of_eq ?_ ++ field_simp ++ have lim := Real.tendsto_pow_log_div_mul_add_atTop 1 (-2) 1 (by norm_num) ++ simp only [pow_one, one_mul, ← sub_eq_add_neg] at lim ++ rw [tendsto_atTop_nhds] at lim ++ specialize lim (Metric.ball 0 ((1/2) * ε / |const| : ℝ)) (by ++ simp only [Metric.mem_ball, dist_self] ++ apply _root_.div_pos ++ · linarith ++ · simpa only [abs_pos, ne_eq]) Metric.isOpen_ball ++ obtain ⟨M, hM⟩ := lim ++ rw [eventually_atTop] ++ refine ⟨max 3 M, ?_⟩ ++ intro x hx ++ simp only [Metric.mem_ball, dist_zero_right, max_le_iff, norm_eq_abs] at hM hx ++ refine ineq x (by linarith) |>.trans ?_ ++ specialize hM x hx.2 ++ rw [abs_of_nonneg (by ++ apply div_nonneg ++ · refine log_nonneg (by linarith) ++ · linarith)] at hM ++ have ineq' : |const| * (log x / (x - 2)) < |const| * ((1/2) * ε / |const|) := by ++ rw [mul_lt_mul_iff_right₀] ++ · exact hM ++ · simpa only [abs_pos, ne_eq] ++ rw [mul_div_cancel₀] at ineq' ++ · refine le_of_lt ineq' ++ · simpa only [ne_eq, abs_eq_zero] ++ rw [isLittleO_iff] ++ intro ε hε ++ specialize ineq4 (|D ε hε (1/2) (by linarith)| + |C|) ε hε ++ simp only [one_div, norm_eq_abs, norm_one, mul_one] ++ filter_upwards [eventually_gt_atTop 2, ineq4, ineq1 ε hε (1 / 2) (by norm_num), ++ hD ε hε (1 / 2) (by norm_num)] with x hx hB ineq1 hD ++ have := integral_log_inv_pos x (by linarith) |>.le ++ calc _ ++ _ ≤ |((log x)⁻¹ * (x * f x) / ∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹)| + ++ |(∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹) / ++ ∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹| + ++ |C / ∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹| := by ++ apply abs_add_three ++ _ = |(log x)⁻¹ * (x * f x)| / |∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹| + ++ |(∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹)| / ++ |∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹| + ++ |C| / |∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹| := by ++ rw [abs_div, abs_div, abs_div] ++ _ = |(log x)⁻¹ * (x * f x)| / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ |(∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹)| / ++ (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ |C| / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) := by ++ repeat rw [abs_of_pos <| integral_log_inv_pos _ (by linarith)] ++ _ = ((log x)⁻¹ * x * |f x|) / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ |(∫ (t : ℝ) in Set.Icc 2 x, f t * (log t ^ 2)⁻¹)| / ++ (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ |C| / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) := by ++ congr ++ rw [abs_mul, abs_mul, abs_of_nonneg (by bound), abs_of_nonneg (by linarith), mul_assoc] ++ _ ≤ ((1/2) * ε * ((log x)⁻¹ * x)) / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ ((1/2) * ε * ((∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) - (log x)⁻¹ * x) + ++ D ε hε (1/2) (by linarith)) / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ |C| / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) := by ++ gcongr ++ _ = ((1/2) * ε * (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹)) / ++ (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) + ++ (D ε hε (1/2) (by linarith) + |C|) / (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) := by ++ ring ++ _ = (1/2) * ε + (D ε hε (1/2) (by linarith) + |C|) / ++ (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) := by ++ congr 1 ++ rw [mul_div_assoc, div_self, mul_one] ++ apply integral_log_inv_ne_zero ++ linarith ++ _ ≤ (1/2) * ε + (|D ε hε (1/2) (by linarith)| + |C|) / ++ (∫ (t : ℝ) in Set.Icc 2 x, (log t)⁻¹) := by ++ gcongr ++ apply le_abs_self ++ _ ≤ (1/2) * ε + (1/2) * ε := by ++ rw [abs_div, abs_of_nonneg, abs_of_pos (a := ∫ _ in _, _)] at hB ++ · gcongr ++ · apply integral_log_inv_pos; linarith ++ · positivity ++ _ = ε := by ++ field ++ ++theorem pi_asymp : ++ ∃ c : ℝ → ℝ, c =o[atTop] (fun _ ↦ (1 : ℝ)) ∧ ++ ∀ᶠ (x : ℝ) in atTop, ++ Nat.primeCounting ⌊x⌋₊ = (1 + c x) * ∫ t in (2 : ℝ)..x, 1 / (log t) := by ++ refine ⟨_, pi_asymp'', ?_⟩ ++ filter_upwards [eventually_ge_atTop 3] with x hx ++ rw [intervalIntegral.integral_of_le (by linarith), ++ ← MeasureTheory.integral_Icc_eq_integral_Ioc] ++ field [(integral_log_inv_pos x (by linarith)).ne'] ++ ++lemma inv_div_log_asy : ∃ c, ∀ᶠ (x : ℝ) in atTop, ++ ∫ (t : ℝ) in Set.Icc 2 x, 1 / log t ^ 2 ≤ c * (x / log x ^ 2) := by ++ have := Chebyshev.integral_one_div_log_sq_isBigO ++ rw [isBigO_iff] at this ++ obtain ⟨c, hc⟩ := this ++ use c ++ filter_upwards [hc, eventually_ge_atTop 2] with x hc hx ++ rw [integral_Icc_eq_integral_Ioc, ← intervalIntegral.integral_of_le hx] ++ apply le_trans (by apply le_norm_self) ++ nth_rewrite 2 [norm_of_nonneg (by positivity)] at hc ++ exact hc ++ ++lemma integral_log_inv_pialt (x : ℝ) (hx : 4 ≤ x) : ∫ (t : ℝ) in Set.Icc 2 x, 1 / log t = ++ x / log x - 2 / log 2 + ∫ (t : ℝ) in Set.Icc 2 x, 1 / (log t) ^ 2 := by ++ have := integral_log_inv 2 x (by norm_num) (by linarith) ++ rw [MeasureTheory.integral_Icc_eq_integral_Ioc, ++ ← intervalIntegral.integral_of_le (by linarith [hx]), ++ MeasureTheory.integral_Icc_eq_integral_Ioc, ++ ← intervalIntegral.integral_of_le (by linarith [hx]), ++ ← mul_one_div, one_div, ← mul_one_div, one_div] ++ simp only [one_div, this, mul_comm] ++ ++lemma integral_div_log_asymptotic : ∃ c : ℝ → ℝ, c =o[atTop] (fun _ ↦ (1:ℝ)) ∧ ++ ∀ᶠ (x : ℝ) in atTop, ∫ t in Set.Icc 2 x, 1 / (log t) = (1 + c x) * x / (log x) := by ++ obtain ⟨c, hc⟩ := inv_div_log_asy ++ use fun x => ((∫ (t : ℝ) in Set.Icc 2 x, 1 / log t ^ 2) - 2 / log 2) * log x / x ++ constructor ++ · simp_rw [mul_div_assoc, mul_comm] ++ apply isLittleO_mul_iff_isLittleO_div _|>.mpr ++ · simp_rw [one_div_div] ++ apply IsLittleO.sub ++ · apply IsBigO.trans_isLittleO (g := (fun x ↦ x / log x ^ 2)) ++ · rw [isBigO_iff] ++ use c ++ filter_upwards [eventually_ge_atTop 2, hc] with x hx hc ++ simp only [norm_eq_abs] ++ rwa [abs_of_nonneg, abs_of_nonneg] ++ · bound ++ · apply setIntegral_nonneg measurableSet_Icc fun t ht ↦ (by bound) ++ apply isLittleO_of_tendsto ++ · simp ++ apply tendsto_log_atTop.inv_tendsto_atTop.congr' ++ filter_upwards [eventually_ne_atTop 0] with x hx ++ simp only [Pi.inv_apply] ++ field ++ apply isLittleO_mul_iff_isLittleO_div _|>.mp ++ · conv => arg 2; ext; rw [mul_comm] ++ apply IsLittleO.const_mul_left isLittleO_log_id_atTop ++ · filter_upwards [eventually_ge_atTop 2] with x hx ++ simp; grind ++ filter_upwards [eventually_ge_atTop 2] with x hx ++ simp ++ grind ++ · filter_upwards [eventually_ge_atTop 4] with x hx ++ rw [integral_log_inv_pialt x hx] ++ field [show log x ≠ 0 by simp; grind] ++ ++theorem pi_alt : ∃ c : ℝ → ℝ, c =o[atTop] (fun _ ↦ (1 : ℝ)) ∧ ++ ∀ x : ℝ, Nat.primeCounting ⌊x⌋₊ = (1 + c x) * x / log x := by ++ obtain ⟨f, hf, h⟩ := pi_asymp ++ obtain ⟨f', hf', h'⟩ := integral_div_log_asymptotic ++ use (fun x => (log x / x) * ⌊x⌋₊.primeCounting - 1) ++ constructor ++ · apply IsLittleO.congr' (f₁ := (fun x ↦ f x + f x * f' x + f' x)) _ _ (by rfl) ++ · apply IsLittleO.add _ hf' ++ apply IsLittleO.add hf ++ convert! hf.mul hf' ++ ring ++ · filter_upwards [eventually_ge_atTop 2, h, h'] with x hx h h' ++ rw [h, intervalIntegral.integral_of_le hx, ← integral_Icc_eq_integral_Ioc, h'] ++ have : log x ≠ 0 := by simp; grind ++ field ++ · intro x ++ obtain rfl|hx := eq_or_ne x 0 ++ · simp ++ obtain rfl|hx := eq_or_ne x 1 ++ · simp ++ obtain rfl|hx := eq_or_ne x (-1 : ℝ) ++ · simp ++ norm_num ++ have : log x ≠ 0 := by simp_all ++ field ++ ++theorem pi_alt' : ++ (fun (x : ℝ) ↦ (primeCounting ⌊x⌋₊ : ℝ)) ~[atTop] (fun x ↦ x / log x) := by ++ obtain ⟨f, ⟨hf1, hf2⟩⟩ := pi_alt ++ simp_rw [hf2, IsEquivalent] ++ have : ((fun x ↦ (1 + f x) * x / log x) - fun x ↦ x / log x) = ++ (fun x ↦ f x * x / log x) := by ++ ext ++ simp ++ ring ++ rw [this] ++ convert hf1.mul_isBigO (f₂ := (fun x ↦ x / log x)) (g₂ := (fun x ↦ x /log x)) ++ (isBigO_refl ..) using 2 ++ all_goals ring ++ ++lemma pi_nth_prime (n : ℕ) : ++ primeCounting (nth_prime n) = n + 1 := by ++ rw [primeCounting, primeCounting', count_nth_succ_of_infinite infinite_setOfPred_prime] ++ ++lemma tendsto_nth_prime_atTop : Tendsto nth_prime atTop atTop := ++ nth_strictMono infinite_setOfPred_prime |>.tendsto_atTop ++ ++lemma pi_nth_prime_asymp : ++ (fun n ↦ (nth_prime n) / (log (nth_prime n))) ~[atTop] (fun (n : ℕ) ↦ (n : ℝ)) := by ++ trans (fun (n : ℕ) ↦ ( n + 1 : ℝ)) ++ · have : Tendsto (fun n ↦ ((nth_prime n) : ℝ)) atTop atTop := by ++ apply tendsto_natCast_atTop_iff.mpr tendsto_nth_prime_atTop ++ convert! pi_alt'.comp_tendsto this |>.symm ++ simp only [Function.comp_apply, floor_natCast] ++ rw [pi_nth_prime] ++ norm_cast ++ · apply IsEquivalent.add_isLittleO (by rfl) ++ exact isLittleO_const_id_atTop (1 : ℝ) |>.natCast_atTop ++ ++lemma log_nth_prime_asymp : (fun n ↦ log (nth_prime n)) ~[atTop] (fun n ↦ log n) := by ++ have := pi_nth_prime_asymp.log tendsto_natCast_atTop_atTop ++ · apply IsEquivalent.trans _ this ++ apply IsEquivalent.congr_right (v := (fun n ↦ log (nth_prime n) - log (log (nth_prime n)))) ++ swap ++ · filter_upwards with n ++ rw [log_div] ++ · exact_mod_cast prime_nth_prime n |>.ne_zero ++ · apply log_ne_zero.mpr ⟨?_, ?_, ?_⟩ ++ <;> norm_cast<;> linarith [prime_nth_prime n |>.two_le] ++ symm ++ apply IsEquivalent.sub_isLittleO (by rfl) ++ apply IsLittleO.comp_tendsto isLittleO_log_id_atTop ++ have : Tendsto (fun n ↦ ((nth_prime n) : ℝ)) atTop atTop := by ++ apply tendsto_natCast_atTop_iff.mpr tendsto_nth_prime_atTop ++ apply tendsto_log_atTop.comp this ++ ++lemma nth_prime_asymp : (fun n ↦ ((nth_prime n) : ℝ)) ~[atTop] (fun n ↦ n * log n) := by ++ have := pi_nth_prime_asymp.mul log_nth_prime_asymp ++ convert! this using 1 ++ ext n ++ simp only [Pi.mul_apply] ++ have : log (nth_prime n) ≠ 0 :=by ++ apply log_ne_zero.mpr ⟨?_, ?_, ?_⟩ ++ <;> norm_cast<;> linarith [prime_nth_prime n |>.two_le] ++ field ++ ++theorem pn_asymptotic : ∃ c : ℕ → ℝ, c =o[atTop] (fun _ ↦ (1 : ℝ)) ∧ ++ ∀ n : ℕ, n > 1 → nth_prime n = (1 + c n) * n * log n := by ++ let c : ℕ → ℝ := fun n ↦ (nth_prime n) / (n * log n) - 1 ++ refine ⟨c, ?_, ?_⟩ ++ swap ++ · intro n hn ++ have : log n ≠ 0 := by rw [Real.log_ne_zero]; rify at hn; grind ++ simp [c] ++ field_simp ++ apply isLittleO_of_tendsto ++ · simp ++ simp only [div_one] ++ unfold c ++ have := isEquivalent_iff_tendsto_one ?_|>.mp nth_prime_asymp ++ swap ++ · filter_upwards [eventually_ge_atTop 2] with n hn ++ simp ++ norm_cast ++ grind ++ convert! this.add_const (-1 : ℝ) using 2 ++ norm_num ++ ++theorem pn_pn_plus_one : ∃ c : ℕ → ℝ, c =o[atTop] (fun _ ↦ (1 : ℝ)) ∧ ++ ∀ n : ℕ, nth_prime (n + 1) - nth_prime n = (c n) * nth_prime n := by ++ use (fun n => (nth_prime (n+1) - nth_prime n) / nth_prime n) ++ refine ⟨?_, ?_⟩ ++ · obtain ⟨k, k_o1, p_n_eq⟩ := pn_asymptotic ++ simp only [isLittleO_one_iff] ++ rw [Filter.tendsto_congr' (f₂ := fun n ↦ ++ ((1 + k (n+1))*(n+1)*log (n+1) - (1 + k n)*n*log n) / ((1 + k n)*n*log n))] ++ swap ++ · simp only [EventuallyEq, eventually_atTop] ++ use 2; intro n hn ++ rw [p_n_eq n (by linarith), p_n_eq (n+1) (by linarith)] ++ grind ++ simp_rw [sub_div] ++ have zero_eq_minus: (0 : ℝ) = 1 - 1 := by ++ simp ++ rw [zero_eq_minus] ++ apply Filter.Tendsto.sub ++ · conv => ++ arg 1 ++ intro n ++ equals ((1 + k (n + 1)) / (1 + k n) ) * ((↑n + 1) * log (↑n + 1) / (↑n * log ↑n)) => ++ field_simp ++ nth_rw 6 [← (one_mul 1)] ++ apply Filter.Tendsto.mul ++ · have one_div: nhds 1 = nhds ((1: ℝ) / 1) := by simp ++ rw [one_div] ++ apply Filter.Tendsto.div ++ · nth_rw 3 [← (AddMonoid.add_zero 1)] ++ apply Filter.Tendsto.add ++ · simp ++ · rw [Filter.tendsto_add_atTop_iff_nat] ++ rw [Asymptotics.isLittleO_iff_tendsto] at k_o1 ++ · simp only [div_one] at k_o1 ++ exact k_o1 ++ · simp ++ · nth_rw 2 [← (AddMonoid.add_zero 1)] ++ apply Filter.Tendsto.add ++ · simp ++ · rw [Asymptotics.isLittleO_iff_tendsto] at k_o1 ++ · simp only [div_one] at k_o1 ++ exact k_o1 ++ · simp ++ ++ simp ++ · conv => ++ arg 1 ++ intro x ++ equals ((↑x + 1) / x) * (log (↑x + 1) / (log ↑x)) => ++ field_simp ++ nth_rw 3 [← (one_mul 1)] ++ apply Filter.Tendsto.mul ++ · simp_rw [add_div] ++ nth_rw 2 [← (AddMonoid.add_zero 1)] ++ apply Filter.Tendsto.add ++ · rw [← Filter.tendsto_add_atTop_iff_nat 1] ++ field_simp ++ simp ++ · simp only [one_div] ++ exact tendsto_inv_atTop_nhds_zero_nat ++ · have log_eq: ∀ (n: ℕ), log (↑n + 1) = log ↑n + log (1 + 1/n) := by ++ intro n ++ by_cases n_eq_zero: n = 0 ++ · simp [n_eq_zero] ++ · calc ++ _ = log (n * (1 + 1 / n)) := by field_simp ++ _ = log n + log (1 + 1/n) := by ++ rw [Real.log_mul] ++ · simpa ++ · simp only [one_div, ne_eq] ++ positivity ++ ++ simp_rw [log_eq] ++ simp_rw [add_div] ++ nth_rw 3 [← (AddMonoid.add_zero 1)] ++ apply Filter.Tendsto.add ++ · rw [← Filter.tendsto_add_atTop_iff_nat 2] ++ have log_not_zero: ∀ n: ℕ, log (n + 2) ≠ 0 := by ++ intro n ++ simp only [ne_eq, log_eq_zero, not_or] ++ refine ⟨?_, ?_, ?_⟩ ++ · norm_cast ++ · norm_cast ++ simp ++ · norm_cast ++ simp [log_not_zero] ++ · rw [← Filter.tendsto_add_atTop_iff_nat 2] ++ apply squeeze_zero (g := fun (n: ℕ) => (log 2 / log (n + 2))) ++ · intro n ++ have log_plus_nonzero: 0 ≤ log (1 + 1 / ↑(n + 2)) := by ++ apply log_nonneg ++ simp only [cast_add, cast_ofNat, one_div, le_add_iff_nonneg_right, inv_nonneg] ++ norm_cast ++ simp only [le_add_iff_nonneg_left, _root_.zero_le] ++ exact div_nonneg log_plus_nonzero (log_natCast_nonneg (n + 2)) ++ · intro n ++ norm_cast ++ have log_le_2: log (1 + 1 / ↑(n + 2)) ≤ log 2 := by ++ apply Real.log_le_log ++ · positivity ++ · have two_eq_one_plus_one: (2 : ℝ) = 1 + 1 := by ++ norm_num ++ rw [two_eq_one_plus_one] ++ simp only [cast_add, cast_ofNat, one_div, add_le_add_iff_left, ge_iff_le] ++ apply inv_le_one_of_one_le₀ ++ linarith ++ ++ rw [div_le_div_iff_of_pos_right] ++ · exact log_le_2 ++ · apply Real.log_pos ++ norm_cast ++ simp ++ · apply Filter.Tendsto.div_atTop (l := atTop) (a := log 2) ++ · simp ++ · norm_cast ++ have shift_fn := ++ Filter.tendsto_add_atTop_iff_nat (f := fun n => log (n)) (l := atTop) 2 ++ rw [shift_fn] ++ apply Filter.Tendsto.comp Real.tendsto_log_atTop ++ exact tendsto_natCast_atTop_atTop ++ ++ · have eventually_nonzero: ∃ t, t > 2 ∧ ∀ n, 1 + k (n + t) ≠ 0 := by ++ rw [Asymptotics.isLittleO_iff_tendsto] at k_o1 ++ · rw [NormedAddGroup.tendsto_nhds_zero] at k_o1 ++ specialize k_o1 ((1 : ℝ) / 2) ++ simp only [one_div, gt_iff_lt, inv_pos, ofNat_pos, div_one, norm_eq_abs, eventually_atTop, forall_const] at k_o1 ++ obtain ⟨a, ha⟩ := k_o1 ++ use (a + 3) ++ refine ⟨by simp, ?_⟩ ++ intro n ++ specialize ha (n + (a + 3)) ++ have a_le_plus: a ≤ n + (a + 3) := by omega ++ simp only [a_le_plus, forall_const] at ha ++ ++ by_contra! ++ rw [add_eq_zero_iff_eq_neg] at this ++ rw [← abs_neg] at ha ++ rw [← this] at ha ++ simp only [abs_one] at ha ++ have two_inv_lt := inv_lt_one_of_one_lt₀ (a := (2 : ℝ)) (by simp) ++ linarith ++ · simp ++ ++ obtain ⟨t, t_gt_2, ht⟩ := eventually_nonzero ++ rw [← Filter.tendsto_add_atTop_iff_nat t] ++ have denom_nonzero: ∀ n, ((1 + k (n + t)) * ↑(n + t) * log ↑(n + t)) ≠ 0 := by ++ intro n ++ simp only [cast_add, ne_eq, _root_.mul_eq_zero, log_eq_zero, not_or] ++ refine ⟨⟨?_, ?_⟩, ?_, ?_⟩ ++ · exact ht n ++ · norm_cast ++ omega ++ · norm_cast ++ omega ++ · refine ⟨?_, by norm_cast⟩ ++ norm_cast ++ omega ++ conv => ++ arg 1 ++ intro n ++ rw [div_self (denom_nonzero n)] ++ simp ++ · intro n ++ have nth_nonzero: nth_prime n ≠ 0 := by ++ exact Nat.Prime.ne_zero (prime_nth_prime n) ++ simp [nth_nonzero] ++ ++lemma prime_in_gap' (a b : ℕ) (h : a.primeCounting < b.primeCounting) ++ : ∃ (p : ℕ), p.Prime ∧ (a + 1) ≤ p ∧ p < (b + 1) := by ++ obtain ⟨p, hp, pp⟩ := exists_of_count_lt_count h ++ exact ⟨p, pp, hp.left, hp.right⟩ ++ ++lemma prime_in_gap (a b : ℝ) (ha : 0 < a) ++ (h : ⌊a⌋₊.primeCounting < ⌊b⌋₊.primeCounting) ++ : ∃(p : ℕ), p.Prime ∧ a < p ∧ p ≤ b := by ++ ++ have hab : ⌊a⌋₊ < ⌊b⌋₊ := Monotone.reflect_lt Nat.monotone_primeCounting h ++ obtain ⟨w, h, ha, hb⟩ := prime_in_gap' ⌊a⌋₊ ⌊b⌋₊ h ++ refine ⟨w, h, lt_of_floor_lt ha, ?_⟩ ++ have : a < b := by ++ by_contra h ++ cases lt_or_eq_of_le <| le_of_not_gt h with ++ | inl hh => linarith [floor_le_floor <| le_of_lt hh] ++ | inr hh => ++ rw [hh] at hab ++ rwa [←lt_self_iff_false ⌊a⌋₊] ++ by_contra h ++ have : ⌊b⌋₊ < w := floor_lt (by linarith) |>.mpr (lt_of_not_ge h) ++ have : ⌊b⌋₊ + 1 ≤ w := by linarith ++ linarith ++ ++lemma bound_f_second_term (f : ℝ → ℝ) (hf : Tendsto f atTop (nhds 0)) (δ : ℝ) (hδ : δ > 0) : ++ ∀ᶠ x : ℝ in atTop, (1 + f x) < (1 + δ) := by ++ have bound_one_plus_f: ∀ y: ℝ, ∀ z: ℝ, |f y| < z → 1 + (f y) < 1 + z := by ++ intro y z hf ++ by_cases f_pos: 0 < f y ++ · rw [abs_of_pos f_pos] at hf ++ linarith ++ · rw [not_lt] at f_pos ++ rw [abs_of_nonpos f_pos] at hf ++ linarith ++ ++ have f_small := NormedAddGroup.tendsto_nhds_zero.mp hf δ hδ ++ simp only [norm_eq_abs, eventually_atTop] at f_small ++ obtain ⟨p, hp⟩ := f_small ++ ++ let a := ((max 1 p) : ℝ) ++ have ha: ∀ b: ℝ, a ≤ b → |f b| < δ := by ++ intro b hb ++ have b_ge_p: p ≤ b := by ++ have a_ge_p: p ≤ a := by simp [a] ++ linarith ++ exact hp b b_ge_p ++ ++ rw [Filter.eventually_atTop] ++ ++ use a ++ intro b hb ++ exact bound_one_plus_f b δ (ha b (by linarith)) ++ ++lemma bound_f_first_term {ε : ℝ} (hε : 0 < ε) (f : ℝ → ℝ) ++ (hf : Tendsto f atTop (nhds 0)) (δ : ℝ) (hδ : δ > 0) : ++ ∀ᶠ x: ℝ in atTop, (1 + f ((1 + ε) * x)) > (1 - δ) := by ++ have bound_one_plus_f: ∀ y: ℝ, ∀ z: ℝ, |f y| < z → 1 + (f y) > 1 - z := by ++ intro y z hf ++ by_cases f_pos: 0 < f y ++ · rw [abs_of_pos f_pos] at hf ++ linarith ++ · rw [not_lt] at f_pos ++ rw [abs_of_nonpos f_pos] at hf ++ linarith ++ ++ have f_small := NormedAddGroup.tendsto_nhds_zero.mp hf δ hδ ++ simp only [norm_eq_abs, eventually_atTop] at f_small ++ obtain ⟨p, hp⟩ := f_small ++ ++ let a := ((max 1 p) : ℝ) ++ have ha: ∀ b: ℝ, a ≤ b → |f b| < δ := by ++ intro b hb ++ have b_ge_p: p ≤ b := by ++ have a_ge_p: p ≤ a := by simp [a] ++ linarith ++ exact hp b b_ge_p ++ ++ rw [Filter.eventually_atTop] ++ ++ use a ++ intro b hb ++ ++ have a_pos: 0 < a := by ++ simp [a] ++ ++ have pos_mul: ∀ x y z : ℝ, 0 < x → 0 < y → 1 < z → x ≤ y → x < y * z := by ++ intro x y z _ hy hz hlt ++ have y_lt: y < y * z := by ++ exact (lt_mul_iff_one_lt_right hy).mpr hz ++ linarith ++ ++ have mul_increase: a ≤ (1 + ε) * b := by ++ simp only [ a] at hb ++ have a_le := pos_mul a b (1 + ε) a_pos (by linarith) (by linarith) (by linarith) ++ linarith ++ ++ exact bound_one_plus_f ((1 + ε) * b) δ (ha ((1 + ε) * b) mul_increase) ++ ++lemma smaller_terms {ε : ℝ} (hε : 0 < ε) (f : ℝ → ℝ) (hf : Tendsto f atTop (nhds 0)) (δ : ℝ) ++ (hδ : δ > 0) : ++ ∀ᶠ x : ℝ in atTop, (1 - δ) * ((1 + ε) * x / (Real.log ((1 + ε) * x))) < ++ (1 + f ((1 + ε) * x)) * ((1 + ε) * x / (Real.log ((1 + ε) * x))) := by ++ have first_term := bound_f_first_term hε f hf δ hδ ++ simp only [gt_iff_lt, eventually_atTop] at first_term ++ obtain ⟨p, hp⟩ := first_term ++ simp only [eventually_atTop] ++ let a := max p 1 ++ have ha: ∀ (b : ℝ), a ≤ b → 1 - δ < 1 + f ((1 + ε) * b) := by ++ intro b hb ++ have a_ge_p: p ≤ a := by ++ simp [a] ++ specialize hp b (by linarith) ++ exact hp ++ use a ++ intro b hb ++ rw [mul_lt_mul_iff_left₀] ++ · exact ha b hb ++ · simp only [sup_le_iff, a] at hb ++ have b_ge_one: 1 ≤ b := hb.2 ++ have log_pos: Real.log ((1 + ε) *b) > 0 := by ++ have one_pplus_pos: 1 < (1 + ε) := by linarith ++ refine (Real.log_pos_iff ?_).mpr ?_ ++ · positivity ++ · exact one_lt_mul_of_lt_of_le one_pplus_pos b_ge_one ++ ++ positivity ++ ++lemma second_smaller_terms (f : ℝ → ℝ) (hf : Tendsto f atTop (nhds 0)) (δ : ℝ) (hδ : δ > 0) : ++ ∀ᶠ x : ℝ in atTop, ++ (1 + δ) * (x / Real.log x) > (1 + f x) * (x / Real.log x) := by ++ have first_term := bound_f_second_term f hf δ hδ ++ ++ simp only [_root_.add_lt_add_iff_left, eventually_atTop] at first_term ++ obtain ⟨p, hp⟩ := first_term ++ simp only [gt_iff_lt, eventually_atTop] ++ let a := max p 2 ++ have ha: ∀ (b : ℝ), a ≤ b → 1 + δ > 1 + f ( b) := by ++ intro b hb ++ have a_ge_p: p <= a := by simp [a] ++ specialize hp b (by linarith) ++ linarith ++ use a ++ intro b hb ++ specialize ha b hb ++ have rhs_nonzero: b / log ( b) > 0 := by ++ simp only [sup_le_iff, a] at hb ++ obtain ⟨_, hb2⟩ := hb ++ have log_pos: Real.log (b) > 0 := by ++ refine (Real.log_pos_iff ?_).mpr ?_ ++ · positivity ++ · linarith ++ positivity ++ rw [mul_lt_mul_iff_left₀] ++ · exact ha ++ · linarith ++ ++lemma x_log_x_atTop : Filter.Tendsto (fun x => x / Real.log x) Filter.atTop Filter.atTop := by ++ have inv_log_x_div := Filter.Tendsto.comp (f := fun x => Real.log x / x) (g := fun x => x⁻¹) ++ (x := Filter.atTop) (y := (nhdsWithin 0 (Set.Ioi 0))) (z := Filter.atTop) ?_ ?_ ++ · simp_rw [Function.comp_def, inv_div] at inv_log_x_div ++ exact inv_log_x_div ++ · exact tendsto_inv_nhdsGT_zero (𝕜 := ℝ) ++ · rw [tendsto_nhdsWithin_iff] ++ refine ⟨?_, ?_⟩ ++ · have log_div_x := Real.tendsto_pow_log_div_mul_add_atTop 1 0 1 (by simp) ++ simp only [pow_one, one_mul, add_zero] at log_div_x ++ exact log_div_x ++ · simp only [Set.mem_Ioi, eventually_atTop] ++ use 2 ++ intro x hx ++ have log_pos: 0 < Real.log x := by ++ refine (Real.log_pos_iff ?_).mpr ?_ <;> linarith ++ positivity ++ ++lemma tendsto_by_squeeze (ε : ℝ) (hε : ε > 0) : ++ Tendsto (fun (x : ℝ) => (Nat.primeCounting ⌊(1 + ε) * x⌋₊ : ℝ) - ++ (Nat.primeCounting ⌊x⌋₊ : ℝ)) atTop atTop := by ++ obtain ⟨c, hc, pi_x_eq⟩ := pi_alt ++ rw [Asymptotics.isLittleO_iff_tendsto (by simp)] at hc ++ conv => ++ arg 1 ++ intro x ++ rw [pi_x_eq] ++ rw [pi_x_eq] ++ simp only [div_one] at hc ++ ++ let d: ℝ := ε/(2*(2 + ε)) ++ have hd: 0 < d := by positivity ++ have first_helper := smaller_terms hε c hc (d) hd ++ have second_helper := second_smaller_terms c hc d hd ++ ++ apply Filter.tendsto_atTop_mono' (f₁ := fun x => ( ++ ((1 - d) * ((1 + ε) * x / log ((1 + ε) * x))) ++ - ++ ((1 + d) * (x / log x))) ++ ) ++ · rw [Filter.EventuallyLE] ++ ++ simp only [eventually_atTop] at first_helper ++ simp only [gt_iff_lt, eventually_atTop] at second_helper ++ ++ obtain ⟨a1, ha1⟩ := first_helper ++ obtain ⟨a2, ha2⟩ := second_helper ++ ++ simp only [eventually_atTop] ++ ++ use (max a1 a2) ++ intro b hb ++ ++ have lt_compare: ∀ a b c d : ℝ, a < c ∧ b > d → a - b ≤ c - d := by ++ intro a b c d h_lt ++ obtain ⟨a_lt, b_gt⟩ := h_lt ++ linarith ++ ++ apply lt_compare ++ simp only [ sup_le_iff] at hb ++ specialize ha1 b hb.1 ++ specialize ha2 b hb.2 ++ field_simp ++ field_simp at ha1 ha2 ++ exact ⟨ha1, ha2⟩ ++ · rw [← Filter.tendsto_comp_val_Ioi_atTop (a := 1)] ++ have log_split: ∀ x: Set.Ioi 1, x.val / log ((1 + ε) * x.val) = ++ x.val / (log (1 + ε) + log (x.val)) := by ++ intro x ++ have x_ge_one: 1 < x.val := Set.mem_Ioi.mp x.property ++ rw [Real.log_mul (by linarith) (by linarith)] ++ ++ have log_factor: ∀ x: Set.Ioi 1, x.val / (log (1 + ε) + log (x.val)) = ++ x.val / ((1 + (log (1 + ε)/(log x.val))) * (log x.val)) := by ++ intro x ++ have : log (x.val) ≠ 0 := by ++ have pos := Real.log_pos x.property ++ linarith ++ field_simp ++ rw [add_comm] ++ ++ conv at log_factor => ++ intro x ++ rhs ++ rw [div_mul_eq_div_mul_one_div] ++ ++ conv => ++ arg 1 ++ intro x ++ lhs ++ rw [mul_div_assoc] ++ rw [log_split x] ++ ++ conv => ++ arg 1 ++ intro x ++ lhs ++ rw [log_factor] ++ ++ suffices Tendsto (fun x : Set.Ioi (1 : ℝ) ↦ (1 - d) * ((1 + ε) * x) / ++ ((1 + log (1 + ε) / log x) * log x) - (1 + d) * x / log x) atTop atTop by ++ field_simp at this ⊢ ++ exact this ++ conv => ++ arg 1 ++ intro x ++ rw [sub_eq_add_neg] ++ rw [← neg_div] ++ rw [div_add_div] ++ · skip ++ tactic => ++ simp only [ne_eq, _root_.mul_eq_zero, log_eq_zero, not_or] ++ have x_pos := x.property ++ simp_rw [Set.Ioi, Set.mem_ofPred_eq] at x_pos ++ refine ⟨?_, by linarith, by linarith, by linarith⟩ ++ have log_num_pos: 0 < log (1 + ε) := by ++ exact Real.log_pos (by linarith) ++ have log_denom_pos: 0 < log x := by ++ exact Real.log_pos x.property ++ positivity ++ tactic => ++ have pos := Real.log_pos (x.property) ++ linarith ++ ++ conv => ++ arg 1 ++ intro x ++ equals ↑x * (log ↑x * ((1 + ε) * (1 - d)) - ++ (1 + log (1 + ε) / log ↑x) * ((1 + d) * log ↑x)) / ++ (log ↑x * ((1 + log (1 + ε) / log ↑x) * log ↑x)) => ++ ring ++ ++ simp only [mul_div_mul_comm] ++ conv => ++ arg 1 ++ intro x ++ rw [mul_comm] ++ ++ apply Filter.Tendsto.pos_mul_atTop (C := (1 + ε) * (1 - d) - (1 + d)) ++ · simp only [d, sub_pos] ++ field_simp ++ ring_nf ++ rw [add_assoc] ++ rw [add_lt_add_iff_left] ++ apply lt_of_sub_pos ++ ring_nf ++ positivity ++ · conv => ++ arg 1 ++ intro x ++ lhs ++ rhs ++ equals (log x.val) * ((1 + log (1 + ε) / log ↑x) * ((1 + d))) => ++ ring ++ ++ simp_rw [← mul_sub] ++ conv => ++ arg 1 ++ intro x ++ rhs ++ rw [mul_comm] ++ ++ simp only [mul_div_mul_comm] ++ conv => ++ arg 1 ++ intro x ++ lhs ++ equals 1 => ++ have log_pos := Real.log_pos x.property ++ field_simp ++ ++ simp only [one_mul] ++ conv => ++ arg 3 ++ equals nhds (((1 + ε) * (1 - d) - (1 + d)) / 1) => simp ++ ++ apply Filter.Tendsto.div ++ · apply Filter.Tendsto.sub ++ · simp ++ · conv => ++ arg 3 ++ equals nhds (1 * (1 + d)) => simp ++ apply Filter.Tendsto.mul ++ · conv => ++ arg 3 ++ equals nhds (1 + 0) => simp ++ apply Filter.Tendsto.add ++ · simp ++ · apply Filter.Tendsto.div_atTop (a := log (1 + ε)) ++ · simp ++ · simp only [tendsto_comp_val_Ioi_atTop] ++ exact tendsto_log_atTop ++ · simp ++ · conv => ++ arg 3 ++ equals nhds (1 + 0) => simp ++ apply Filter.Tendsto.add ++ · simp ++ · apply Filter.Tendsto.div_atTop (a := log (1 + ε)) ++ · simp ++ · simp only [tendsto_comp_val_Ioi_atTop] ++ exact tendsto_log_atTop ++ · simp ++ · let x_div_log (x: ℝ) := x / Real.log x ++ conv => ++ arg 1 ++ equals (fun (x : Set.Ioi 1) => x_div_log x.val) => rfl ++ ++ rw [Filter.tendsto_comp_val_Ioi_atTop (a := 1)] ++ exact x_log_x_atTop ++ ++theorem prime_between {ε : ℝ} (hε : 0 < ε) : ++ ∀ᶠ x : ℝ in atTop, ∃ p : ℕ, Nat.Prime p ∧ x < p ∧ p < (1 + ε) * x := by ++ have squeeze := tendsto_by_squeeze (ε/2) (by linarith) ++ rw [Filter.tendsto_iff_forall_eventually_mem] at squeeze ++ specialize squeeze (Set.Ici 1) (by exact Ici_mem_atTop 1) ++ simp only [Set.mem_Ici, eventually_atTop] at squeeze ++ obtain ⟨a, ha⟩ := squeeze ++ rw [eventually_atTop] ++ use (max a 1) ++ intro b hb ++ rw [sup_le_iff] at hb ++ specialize ha b hb.1 ++ ++ have val_lt : (⌊b⌋₊.primeCounting : ℝ) < ⌊(1 + ε/2) * b⌋₊.primeCounting := by linarith ++ norm_cast at val_lt ++ ++ have jump := prime_in_gap b ((1 + ε/2) * b) (by linarith) val_lt ++ obtain ⟨p, hp, b_lt_p, p_le⟩ := jump ++ have p_lt: p < (1 + ε) * b := by ++ linarith ++ use p ++ ++theorem sum_mobius_div_self_le (N : ℕ) : |∑ n ∈ range N, μ n / (n : ℚ)| ≤ 1 := by ++ cases N with ++ | zero => simp only [range_zero, sum_empty, abs_zero, zero_le_one] ++ | succ N => ++ ++ obtain rfl | hN := N.eq_zero_or_pos ++ · simp ++ ++ have h_sum : 1 = (∑ d ∈ range (N + 1), (μ d / d : ℚ)) * N - ∑ d ∈ range (N + 1), ++ μ d * Int.fract (N / d : ℚ) := calc ++ (1 : ℚ) = ∑ m ∈ Ioc 0 N, ∑ d ∈ m.divisors, μ d := by ++ have (x : ℕ) (hx : x ∈ Ioc 0 N) : ∑ d ∈ divisors x, μ d = if x = 1 then 1 else 0 := by ++ rw [mem_Ioc] at hx ++ rw [← coe_mul_zeta_apply, moebius_mul_coe_zeta, one_apply] ++ rw [sum_congr rfl this] ++ simp [hN.ne'] ++ _ = ∑ d ∈ range (N + 1), μ d * (N / d : ℕ) := by ++ simp_rw [← coe_mul_zeta_apply, ArithmeticFunction.sum_Ioc_mul_zeta_eq_sum] ++ rw [range_eq_Ico, ← Finset.insert_Ico_add_one_left_eq_Ico (add_one_pos _), ++ sum_insert (by simp), Ico_add_one_add_one_eq_Ioc] ++ simp ++ _ = ∑ d ∈ range (N + 1), (μ d : ℚ) * ⌊(N / d : ℚ)⌋ := by ++ simp_rw [Rat.floor_natCast_div_natCast] ++ simp [← Int.natCast_ediv] ++ _ = (∑ d ∈ range (N + 1), (μ d / d : ℚ)) * N - ∑ d ∈ range (N + 1), ++ μ d * Int.fract (N / d : ℚ) := by ++ simp_rw [sum_mul, ← sum_sub_distrib, mul_comm_div, ← mul_sub, Int.self_sub_fract] ++ rw [eq_sub_iff_add_eq, eq_comm, ← eq_div_iff (by norm_num [Nat.pos_iff_ne_zero.mp hN])] at h_sum ++ ++ have hf' (d : ℕ) : |Int.fract ((N : ℚ) / d)| < 1 := by ++ rw [abs_of_nonneg (Int.fract_nonneg _)] ++ exact Int.fract_lt_one _ ++ have h_bound : |∑ d ∈ range (N + 1), μ d * Int.fract ((N : ℚ) / d)| ≤ N - 1 := by ++ ++ rw [range_eq_Ico, ← Finset.insert_Ico_add_one_left_eq_Ico (by simp), sum_insert (by simp), ++ ArithmeticFunction.map_zero, Int.cast_zero, zero_mul, zero_add, ++ Finset.Ico_add_one_right_eq_Icc, zero_add] ++ ++ rw [← Ico_insert_right hN, sum_insert (by simp), div_self (by simp; grind), Int.fract_one, ++ mul_zero, zero_add] ++ ++ have (d : ℕ) : |μ d * Int.fract ((N : ℚ) / d)| ≤ 1 := by ++ rw [abs_mul, ← one_mul 1] ++ refine mul_le_mul ?_ (hf' _).le (abs_nonneg _) zero_le_one ++ norm_cast ++ exact abs_moebius_le_one ++ apply (abs_sum_le_sum_abs _ _).trans ++ apply (sum_le_sum fun d _ ↦ this d).trans ++ simp [cast_sub (one_le_iff_ne_zero.mpr hN.ne')] ++ ++ rw [h_sum, abs_le] ++ rw [abs_le, neg_sub] at h_bound ++ constructor ++ <;> simp only [le_div_iff₀, div_le_iff₀, cast_pos.mpr hN] ++ <;> linarith [h_bound.left] ++ ++lemma sum_mobius_mul_floor (x : ℝ) (hx : 1 ≤ x) : ++ ∑ n ∈ Iic ⌊x⌋₊, (ArithmeticFunction.moebius n : ℝ) * (⌊x/n⌋ : ℝ) = 1 := by ++ norm_cast ++ convert ArithmeticFunction.sum_Ioc_mul_zeta_eq_sum μ ⌊x⌋₊ |>.symm using 1 ++ · rw [Iic_eq_Icc, bot_eq_zero, ← add_sum_Ioc_eq_sum_Icc (by simp)] ++ simp only [ArithmeticFunction.map_zero, CharP.cast_eq_zero, div_zero, Int.floor_zero, mul_zero, ++ zero_add, Int.natCast_ediv] ++ refine sum_congr rfl fun n hn ↦ ?_ ++ congr ++ norm_cast ++ rw [← floor_div_natCast, Int.natCast_floor_eq_floor] ++ positivity ++ · simpa [moebius_mul_coe_zeta, one_apply] ++ ++noncomputable def mu_log : ArithmeticFunction ℝ := ++ ⟨(fun n ↦ μ n * ArithmeticFunction.log n), (by simp)⟩ ++ ++lemma mu_log_apply (n : ℕ) : mu_log n = μ n * ArithmeticFunction.log n := by ++ rfl ++ ++lemma mu_log_mul_zeta : mu_log * ArithmeticFunction.zeta = -Λ := by ++ ext n ++ rw [coe_mul_zeta_apply] ++ simp_rw [mu_log_apply] ++ rw [sum_moebius_mul_log_eq] ++ rfl ++ ++lemma mu_log_eq_mu_mul_neg_lambda : mu_log = μ * -Λ := by ++ rw [← mu_log_mul_zeta, mul_comm, mul_assoc, coe_zeta_mul_coe_moebius, mul_one] ++ ++lemma sum_mu_Lambda (x : ℝ) : ∑ n ∈ Iic ⌊x⌋₊, (μ n : ℝ) * log n = - ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Psi (x/k) := by ++ rw [Iic_eq_Icc, bot_eq_zero, ← add_sum_Ioc_eq_sum_Icc (by simp), ← add_sum_Ioc_eq_sum_Icc (by simp)] ++ simp only [ArithmeticFunction.map_zero, Int.cast_zero, CharP.cast_eq_zero, log_zero, mul_zero, ++ zero_add, div_zero, zero_mul] ++ simp_rw [← log_apply, ← mu_log_apply, mu_log_eq_mu_mul_neg_lambda] ++ rw [sum_Ioc_mul_eq_sum_sum, ← sum_neg_distrib] ++ refine sum_congr rfl fun n hn ↦ ?_ ++ simp_rw [ArithmeticFunction.neg_apply, sum_neg_distrib] ++ ring_nf ++ congr 2 ++ unfold Psi ++ congr ++ rw [← floor_div_natCast] ++ rfl ++ ++lemma M_log_identity (x : ℝ) (hx : 1 ≤ x) : M x * log x = ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * (log (x/k) - Psi (x/k)) := by ++ have h_log_identity : ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log (x / k) = (∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ)) * Real.log x - ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log k := by ++ rw [Finset.sum_mul _ _ _] ++ rw [← Finset.sum_sub_distrib] ; refine Finset.sum_congr rfl fun i hi => ?_ ; by_cases hi' : i = 0 <;> simp +decide [*, Real.log_div, ne_of_gt (zero_lt_one.trans_le hx)] ; ring ++ generalize_proofs at * ++ have h_log_identity' : ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log k = -∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Psi (x / k) := by ++ convert sum_mu_Lambda x using 1 ++ have h_psi_identity : ++ (∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Psi (x / k)) = ++ -∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log k := by ++ simpa [neg_neg] using (congrArg Neg.neg h_log_identity').symm ++ unfold M ++ symm ++ calc ++ (∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * (Real.log (x / k) - Psi (x / k))) = ++ (∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log (x / k)) - ++ ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Psi (x / k) := by ++ simp [mul_sub, Finset.sum_sub_distrib] ++ _ = ((∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ)) * Real.log x - ++ ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log k) - ++ ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Psi (x / k) := by ++ simp [h_log_identity] ++ _ = ((∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ)) * Real.log x - ++ ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log k) - ++ (-∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log k) := by ++ simp [h_psi_identity] ++ _ = (∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ)) * Real.log x := by ring ++ ++noncomputable def R (x : ℝ) : ℝ := Psi x - x ++ ++lemma R_isLittleO : R =o[atTop] id := by ++ have h_pnt : (fun x => Psi x - x) =o[atTop] (fun x => x) := by ++ have h_psi : (fun x => Psi x) ~[atTop] (fun x => x) := by ++ simpa [Psi] using! WeakPNT'' ++ exact h_psi ++ convert! h_pnt using 1 ++ ++lemma sum_mobius_div_isBigO : (fun x : ℝ => ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * (x / k)) =O[atTop] id := by ++ have h_abs : ∀ x : ℝ, 1 ≤ x → |∑ n ∈ Iic ⌊x⌋₊, (μ n : ℝ) / n| ≤ 1 := by ++ intros x hx ++ have h_sum : ∑ n ∈ Finset.Iic ⌊x⌋₊, (μ n : ℝ) / n = ∑ n ∈ Finset.range (⌊x⌋₊ + 1), (μ n : ℝ) / n := by ++ rw [Finset.range_eq_Ico] ; rfl ++ have := sum_mobius_div_self_le (⌊x⌋₊ + 1) ; simp_all +decide [Finset.sum_range_succ'] ++ norm_cast at * ++ rw [Asymptotics.isBigO_iff] ++ use 1; filter_upwards [Filter.eventually_ge_atTop 1] with x hx; simp_all +decide [div_eq_mul_inv, mul_assoc, mul_comm] ++ simpa only [← Finset.mul_sum _ _ _, abs_mul] using mul_le_of_le_one_right (abs_nonneg x) (h_abs x hx) ++ ++lemma sum_log_div_isBigO : (fun x : ℝ => ∑ k ∈ Iic ⌊x⌋₊, log (x / k)) =O[atTop] id := by ++ have h_sum_log : ∀ x : ℝ, 1 ≤ x → |∑ k ∈ Finset.Iic ⌊x⌋₊, Real.log (x / k)| ≤ 2 * x := by ++ have h_sum_log_le_x : ∀ x : ℝ, 1 ≤ x → ∑ k ∈ Finset.Icc 1 ⌊x⌋₊, Real.log (x / k) ≤ x := by ++ intro x hx ++ have h_sum_log : ∑ k ∈ Finset.Icc 1 ⌊x⌋₊, Real.log (x / (k : ℝ)) ≤ Real.log (x ^ ⌊x⌋₊ / Nat.factorial ⌊x⌋₊) := by ++ rw [← Real.log_prod] ++ · norm_num [Finset.prod_div_distrib] ++ erw [← Nat.cast_prod, Finset.prod_Ico_id_eq_factorial] ++ · exact fun n hn => div_ne_zero (by positivity) (Nat.cast_ne_zero.mpr <| by linarith [Finset.mem_Icc.mp hn]) ++ have h_exp_bound : x ^ ⌊x⌋₊ / Nat.factorial ⌊x⌋₊ ≤ Real.exp x := by ++ have h_term : x ^ ⌊x⌋₊ / (⌊x⌋₊! : ℝ) ≤ ∑' k : ℕ, x ^ k / (k ! : ℝ) := by ++ exact Summable.le_tsum (show Summable _ from Real.summable_pow_div_factorial x) ⌊x⌋₊ (fun _ _ => by positivity) ++ simpa [Real.exp_eq_exp_ℝ, NormedSpace.exp_eq_tsum_div] using h_term ++ exact h_sum_log.trans (Real.log_le_iff_le_exp (by positivity) |>.2 h_exp_bound) ++ intros x hx ++ have h_sum_eq : ∑ k ∈ Finset.Iic ⌊x⌋₊, Real.log (x / k) = ∑ k ∈ Finset.Icc 1 ⌊x⌋₊, Real.log (x / k) := by ++ erw [Finset.sum_Ico_eq_sub _ _] <;> norm_num ++ erw [Finset.sum_Ico_eq_sub _ _] <;> norm_num ++ rw [abs_of_nonneg] <;> linarith [h_sum_log_le_x x hx, show 0 ≤ ∑ k ∈ Finset.Icc 1 ⌊x⌋₊, Real.log (x / k) from Finset.sum_nonneg fun _ _ => Real.log_nonneg <| by rw [le_div_iff₀ <| Nat.cast_pos.mpr <| by linarith [Finset.mem_Icc.mp ‹_›]] ; linarith [Nat.floor_le <| show 0 ≤ x by linarith, show (↑‹ℕ› : ℝ) ≤ ⌊x⌋₊ by exact_mod_cast Finset.mem_Icc.mp ‹_› |>.2]] ++ rw [Asymptotics.isBigO_iff] ++ exact ⟨2, Filter.eventually_atTop.mpr ⟨1, fun x hx => le_trans (h_sum_log x hx) (by norm_num [abs_of_nonneg (by linarith : 0 ≤ x)])⟩⟩ ++ ++lemma R_locally_bounded (K : ℝ) (hK : 0 ≤ K) : ∃ C, ∀ y ∈ Set.Icc 0 K, |R y| ≤ C := by ++ have hR_bounded : BddAbove (Set.image (fun y => |R y|) (Set.Icc 0 K)) := by ++ have hR_bounded : ∀ y ∈ Set.Icc 0 K, |R y| ≤ ∑ p ∈ Iic ⌊K⌋₊, log p + K := by ++ intro y hy ++ simp only [R, Psi, Chebyshev.psi_eq_sum_Icc] ++ refine abs_sub_le_iff.mpr ⟨?_, ?_⟩ ++ · refine le_trans (sub_le_self _ hy.1) ?_ ++ refine le_trans (Finset.sum_le_sum_of_subset_of_nonneg (Finset.Iic_subset_Iic.mpr <| Nat.floor_mono hy.2) fun ?_ ?_ ?_ => ?_) ?_ ++ · exact vonMangoldt_nonneg ++ · refine le_add_of_le_of_nonneg (Finset.sum_le_sum fun i hi => ?_) hK ++ exact vonMangoldt_le_log ++ · refine le_trans ?_ (le_add_of_nonneg_left ?_) ++ · exact le_trans (sub_le_self _ <| Finset.sum_nonneg fun _ _ => by exact_mod_cast ArithmeticFunction.vonMangoldt_nonneg) hy.2 ++ · exact Finset.sum_nonneg fun _ _ => Real.log_natCast_nonneg _ ++ exact ⟨_, Set.forall_mem_image.2 hR_bounded⟩ ++ exact ⟨hR_bounded.choose, fun y hy => hR_bounded.choose_spec <| Set.mem_image_of_mem _ hy⟩ ++ ++lemma sum_bounded_of_linear_bound {f : ℝ → ℝ} {ε C : ℝ} (hε : 0 ≤ ε) (hC : 0 ≤ C) (h : ∀ y, 1 ≤ y → |f y| ≤ ε * y + C) (x : ℝ) (hx : 1 ≤ x) : ++ ∑ k ∈ Icc 1 ⌊x⌋₊, |f (x / k)| ≤ ε * x * (log x + 1) + C * x := by ++ have h_sum_bound : ∑ k ∈ Finset.Icc 1 ⌊x⌋₊, |f (x / k)| ≤ ε * x * ∑ k ∈ Finset.Icc 1 ⌊x⌋₊, (1 / (k : ℝ)) + C * ⌊x⌋₊ := by ++ have h_sum_bound : ∀ k ∈ Finset.Icc 1 ⌊x⌋₊, |f (x / k)| ≤ ε * x / k + C := by ++ exact fun k hk => by simpa only [mul_div_assoc] using! h (x / k) (by rw [le_div_iff₀ (Nat.cast_pos.mpr <| Finset.mem_Icc.mp hk |>.1)] ; nlinarith [Nat.floor_le (show 0 ≤ x by positivity), show (k : ℝ) ≤ ⌊x⌋₊ by exact_mod_cast Finset.mem_Icc.mp hk |>.2]) ++ convert! Finset.sum_le_sum h_sum_bound using 1 ; norm_num [div_eq_mul_inv, Finset.mul_sum _ _ _, Finset.sum_add_distrib, mul_comm] ++ have h_harmonic : ∀ n : ℕ, 1 ≤ n → ∑ k ∈ Finset.Icc 1 n, (1 / (k : ℝ)) ≤ Real.log n + 1 := by ++ intro n _hn ++ have h := harmonic_le_one_add_log n ++ simpa [harmonic_eq_sum_Icc, Rat.cast_sum, Rat.cast_inv, Rat.cast_natCast, ++ one_div, add_comm, add_left_comm, add_assoc] using h ++ have h_harmonic_x : ++ ∑ k ∈ Finset.Icc 1 ⌊x⌋₊, (1 / (k : ℝ)) ≤ Real.log x + 1 := by ++ refine (h_harmonic _ <| Nat.floor_pos.mpr hx).trans ?_ ++ have hlog : Real.log (⌊x⌋₊ : ℝ) ≤ Real.log x := by ++ refine Real.log_le_log (Nat.cast_pos.mpr <| Nat.floor_pos.mpr hx) ?_ ++ exact Nat.floor_le (by positivity) ++ simpa using add_le_add_right hlog 1 ++ have h_term1 : ε * x * (∑ k ∈ Finset.Icc 1 ⌊x⌋₊, (1 / (k : ℝ))) ≤ ε * x * (Real.log x + 1) := by ++ refine mul_le_mul_of_nonneg_left h_harmonic_x ?_ ++ exact mul_nonneg hε (by positivity) ++ have h_term2 : C * (⌊x⌋₊ : ℝ) ≤ C * x := by ++ refine mul_le_mul_of_nonneg_left ?_ hC ++ exact Nat.floor_le (by positivity) ++ exact h_sum_bound.trans (add_le_add h_term1 h_term2) ++ ++lemma sum_abs_R_isLittleO : (fun x : ℝ => ∑ k ∈ Iic ⌊x⌋₊, |R (x / k)|) =o[atTop] (fun x => x * log x) := by ++ have h_eps : ∀ ε > 0, ∃ x₀ : ℝ, ∀ x ≥ x₀, (∑ k ∈ Finset.Icc 1 ⌊x⌋₊, |R (x / k)|) ≤ ε * x * Real.log x := by ++ intro ε hε_pos ++ obtain ⟨A, hA⟩ : ∃ A : ℝ, 0 < A ∧ ∀ y ≥ A, |R y| ≤ (ε / 2) * y := by ++ have := R_isLittleO ++ rw [Asymptotics.isLittleO_iff] at this ++ norm_num at * ++ exact Exists.elim (this (half_pos hε_pos)) fun A hA => ⟨Max.max A 1, by positivity, fun y hy => by simpa only [abs_of_nonneg (by linarith [le_max_right A 1] : 0 ≤ y)] using hA y (le_trans (le_max_left A 1) hy)⟩ ++ obtain ⟨C_A, hC_A⟩ : ∃ C_A : ℝ, ∀ y ∈ Set.Icc 0 A, |R y| ≤ C_A := by ++ exact ⟨_, fun y hy => R_locally_bounded A hA.1.le |> Classical.choose_spec |> fun h => h y hy⟩ ++ have h_sum_bound : ∀ x ≥ max A 2, (∑ k ∈ Finset.Icc 1 ⌊x⌋₊, |R (x / k)|) ≤ (ε / 2) * x * (Real.log x + 1) + C_A * x := by ++ intros x hx ++ have h_sum_bound : ∀ y ≥ 1, |R y| ≤ (ε / 2) * y + C_A := by ++ intros y hy ++ by_cases hyA : y ≥ A ++ · exact le_add_of_le_of_nonneg (hA.right y hyA) (by ++ exact le_trans (abs_nonneg _) (hC_A 0 ⟨by norm_num, by linarith⟩)) ++ · exact le_add_of_nonneg_of_le (by ++ positivity) (hC_A y ⟨by ++ linarith, by ++ linarith⟩) ++ have := sum_bounded_of_linear_bound (show 0 ≤ ε / 2 by positivity) (show 0 ≤ C_A by exact le_trans (abs_nonneg _) (hC_A 0 ⟨by norm_num, by linarith⟩)) (fun y hy => h_sum_bound y hy) x (by linarith [le_max_right A 2]) ; aesop ++ obtain ⟨x₀, hx₀⟩ : ∃ x₀ : ℝ, ∀ x ≥ x₀, (ε / 2) * (Real.log x + 1) + C_A ≤ ε * Real.log x := by ++ exact ⟨Real.exp (2 * (C_A / ε + 1)), fun x hx => by nlinarith [Real.log_exp (2 * (C_A / ε + 1)), Real.log_le_log (by positivity) hx, mul_div_cancel₀ C_A hε_pos.ne']⟩ ++ exact ⟨Max.max x₀ (Max.max A 2), fun x hx => le_trans (h_sum_bound x (le_trans (le_max_right _ _) hx)) (by nlinarith [hx₀ x (le_trans (le_max_left _ _) hx), le_max_right x₀ (Max.max A 2), le_max_left x₀ (Max.max A 2), le_max_right A 2, le_max_left A 2, Real.log_nonneg (show x ≥ 1 by linarith [le_max_right x₀ (Max.max A 2), le_max_left x₀ (Max.max A 2), le_max_right A 2, le_max_left A 2])])⟩ ++ rw [Asymptotics.isLittleO_iff_tendsto'] ++ · have h_sum_eq : ∀ x : ℝ, x ≥ 1 → (∑ k ∈ Finset.Iic ⌊x⌋₊, |R (x / k)|) = (∑ k ∈ Finset.Icc 1 ⌊x⌋₊, |R (x / k)|) := by ++ intro x hx ++ have h0 : (0 : ℕ) ∈ Finset.Iic ⌊x⌋₊ := by simp [Finset.mem_Iic] ++ have hI : (Finset.Iic ⌊x⌋₊).erase 0 = Finset.Icc 1 ⌊x⌋₊ := by ++ ext n ++ simp [Finset.mem_Iic, Finset.mem_Icc, Nat.one_le_iff_ne_zero, and_comm] ++ rw [← Finset.sum_erase_add (Finset.Iic ⌊x⌋₊) (fun k => |R (x / k)|) h0] ++ simp [hI, R, Psi, Chebyshev.psi_eq_sum_Icc] ++ rw [Metric.tendsto_nhds] ++ simp +zetaDelta only [gt_iff_lt, ge_iff_le, dist_zero_right, norm_div, norm_eq_abs, norm_mul, ++ eventually_atTop] at * ++ intro ε hε; obtain ⟨x₀, hx₀⟩ := h_eps (ε / 2) (half_pos hε) ; use Max.max x₀ 2; intro x hx; rw [abs_of_nonneg (Finset.sum_nonneg fun _ _ => abs_nonneg _), abs_of_nonneg (by linarith [le_max_right x₀ 2]), abs_of_nonneg (Real.log_nonneg (by linarith [le_max_right x₀ 2]))] ; rw [div_lt_iff₀] <;> nlinarith [hx₀ x (le_trans (le_max_left x₀ 2) hx), Real.log_pos (by linarith [le_max_right x₀ 2] : 1 < x), mul_pos (by linarith [le_max_right x₀ 2] : 0 < x) (Real.log_pos (by linarith [le_max_right x₀ 2] : 1 < x)), h_sum_eq x (by linarith [le_max_right x₀ 2])] ++ · filter_upwards [Filter.eventually_gt_atTop 1] with x hx hx' using absurd hx' (by nlinarith [Real.log_pos hx]) ++ ++lemma R_linear_bound (ε : ℝ) (hε : 0 < ε) : ∃ C, 0 ≤ C ∧ ∀ y, 1 ≤ y → |R y| ≤ ε * y + C := by ++ obtain ⟨A, hA⟩ : ∃ A : ℝ, 0 < A ∧ ∀ y : ℝ, A ≤ y → |R y| ≤ ε * y := by ++ have := R_isLittleO.def hε ++ rw [Filter.eventually_atTop] at this; rcases this with ⟨A, hA⟩ ; exact ⟨Max.max A 1, by positivity, fun y hy => by simpa [abs_of_nonneg (show 0 ≤ y by linarith [le_max_right A 1])] using hA y (le_trans (le_max_left A 1) hy)⟩ ++ obtain ⟨CA, hCA⟩ : ∃ CA : ℝ, ∀ y ∈ Set.Icc 0 A, |R y| ≤ CA := by ++ exact R_locally_bounded A hA.1.le |> fun ⟨CA, hCA⟩ => ⟨CA, fun y hy => hCA y hy⟩ ++ exact ⟨Max.max CA 0, by positivity, fun y hy => if hy' : y ≤ A then le_trans (hCA y ⟨by linarith, by linarith⟩) (by linarith [le_max_left CA 0, le_max_right CA 0, show 0 ≤ ε * y by nlinarith]) else le_trans (hA.2 y (by linarith)) (by linarith [le_max_left CA 0, le_max_right CA 0, show 0 ≤ ε * y by nlinarith])⟩ ++ ++lemma sum_abs_R_isLittleO' : (fun x : ℝ => ∑ k ∈ Iic ⌊x⌋₊, |R (x / k)|) =o[atTop] (fun x => x * log x) := by ++ apply sum_abs_R_isLittleO ++ ++lemma M_isLittleO : M =o[atTop] id := by ++ have h_identity : ∀ x ≥ 1, M x * Real.log x = ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * (Real.log (x / k) - Psi (x / k)) := by ++ exact fun x a => M_log_identity x a ++ have h_term1 : (fun x => ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log (x / k)) =O[atTop] id := by ++ have h_abs : ∀ x ≥ 1, |∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log (x / k)| ≤ ∑ k ∈ Iic ⌊x⌋₊, Real.log (x / k) := by ++ intros x hx ++ have h_abs : ∀ k ∈ Iic ⌊x⌋₊, |(μ k : ℝ) * Real.log (x / k)| ≤ Real.log (x / k) := by ++ intros k hk ++ have h_abs : |(μ k : ℝ)| ≤ 1 := by ++ norm_num [ArithmeticFunction.moebius] ++ split_ifs <;> norm_num ++ by_cases hk0 : k = 0 ++ · rw [hk0] ; norm_num [ArithmeticFunction.map_zero, Nat.cast_zero, Real.log_zero, div_zero, abs_zero] ++ · have hx_pos : 0 < x := by positivity ++ have hk_pos : 0 < (k : ℝ) := by positivity ++ rw [Real.log_div hx_pos.ne' hk_pos.ne'] ++ simp only [abs_mul, ge_iff_le] ++ simp_all only [ge_iff_le, mem_Iic] ++ exact le_trans (mul_le_of_le_one_left (abs_nonneg _) h_abs) (by rw [abs_of_nonneg] ; exact sub_nonneg_of_le <| Real.log_le_log hk_pos (Nat.cast_le.mpr hk |>.trans (Nat.floor_le hx_pos.le))) ++ exact le_trans (Finset.abs_sum_le_sum_abs _ _) (Finset.sum_le_sum h_abs) ++ have h_sum_log : (fun x => ∑ k ∈ Iic ⌊x⌋₊, Real.log (x / k)) =O[atTop] id := by ++ convert sum_log_div_isBigO using 1 ++ rw [Asymptotics.isBigO_iff] at * ++ exact ⟨h_sum_log.choose, by filter_upwards [h_sum_log.choose_spec, Filter.eventually_ge_atTop 1] with x hx₁ hx₂ using le_trans (h_abs x hx₂) (le_trans (le_abs_self _) hx₁)⟩ ++ have h_term2 : (fun x => ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * (x / k)) =O[atTop] id := by ++ convert sum_mobius_div_isBigO using 1 ++ have h_term3 : (fun x => ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * R (x / k)) =o[atTop] (fun x => x * Real.log x) := by ++ have h_abs : ∀ x ≥ 1, |∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * R (x / k)| ≤ ∑ k ∈ Iic ⌊x⌋₊, |R (x / k)| := by ++ intros x hx ++ have h_abs : ∀ k ∈ Iic ⌊x⌋₊, |(μ k : ℝ) * R (x / k)| ≤ |R (x / k)| := by ++ norm_num [abs_mul] ++ intro k hk; exact mul_le_of_le_one_left (abs_nonneg _) (mod_cast by exact abs_moebius_le_one) ++ exact le_trans (Finset.abs_sum_le_sum_abs _ _) (Finset.sum_le_sum h_abs) ++ have h_sum_abs_R : (fun x => ∑ k ∈ Iic ⌊x⌋₊, |R (x / k)|) =o[atTop] (fun x => x * Real.log x) := by ++ exact sum_abs_R_isLittleO ++ rw [Asymptotics.isLittleO_iff] at * ++ intro c hc; filter_upwards [h_sum_abs_R hc, Filter.eventually_ge_atTop 1] with x hx₁ hx₂; exact le_trans (h_abs x hx₂) (le_trans (le_abs_self _) hx₁) ++ have h_combined : (fun x => M x * Real.log x) =o[atTop] (fun x => x * Real.log x) := by ++ have h_combined : (fun x => M x * Real.log x) = (fun x => ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * Real.log (x / k)) - (fun x => ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * (x / k)) - (fun x => ∑ k ∈ Iic ⌊x⌋₊, (μ k : ℝ) * R (x / k)) := by ++ ext x; by_cases hx : 1 ≤ x <;> simp_all +decide only [ge_iff_le, mul_sub, sum_sub_distrib, not_le, Pi.sub_apply] ++ · simp +decide [sub_sub, mul_sub, Finset.sum_sub_distrib, Psi, R] ++ · unfold M R; norm_num [Nat.floor_eq_zero.mpr hx] ++ norm_num [Finset.Iic_eq_Icc] ++ rw [h_combined] ++ refine Asymptotics.IsLittleO.sub ?_ h_term3 ++ refine Asymptotics.IsLittleO.sub ?_ ?_ ++ · refine h_term1.trans_isLittleO ?_ ++ rw [Asymptotics.isLittleO_iff_tendsto'] <;> norm_num ++ · norm_num [← div_div] ++ exact le_trans (Filter.Tendsto.div_atTop (tendsto_const_nhds.congr' (by filter_upwards [Filter.eventually_ne_atTop 0] with x hx; aesop)) (Real.tendsto_log_atTop)) (by norm_num) ++ · exact ⟨2, by rintro x hx (rfl | rfl | rfl) <;> norm_num at hx⟩ ++ · refine h_term2.trans_isLittleO ?_ ++ rw [Asymptotics.isLittleO_iff_tendsto'] <;> norm_num ++ · norm_num [← div_div] ++ exact le_trans (Filter.Tendsto.div_atTop (tendsto_const_nhds.congr' (by filter_upwards [Filter.eventually_ne_atTop 0] with x hx; aesop)) (Real.tendsto_log_atTop)) (by norm_num) ++ · exact ⟨2, by rintro x hx (rfl | rfl | rfl) <;> linarith⟩ ++ rw [Asymptotics.isLittleO_iff_tendsto'] at * ++ · refine h_combined.congr' (by filter_upwards [Filter.eventually_gt_atTop 1] with x hx using by rw [mul_div_mul_right _ _ (ne_of_gt <| Real.log_pos hx)] ; rfl) ++ · filter_upwards [Filter.eventually_gt_atTop 1] with x hx hx' using absurd hx' <| ne_of_gt <| mul_pos (by positivity) <| Real.log_pos hx ++ · filter_upwards [Filter.eventually_gt_atTop 1] with x hx hx' using by nlinarith [Real.log_pos hx] ++ · filter_upwards [Filter.eventually_gt_atTop 0] with x hx hx' using absurd hx' hx.ne' ++ ++lemma M_isLittleO' : M =o[atTop] id := by ++ exact M_isLittleO ++ ++theorem mu_pnt : (fun x : ℝ ↦ ∑ n ∈ range ⌊x⌋₊, μ n) =o[atTop] fun x ↦ x := by ++ have h_moebius_sum : (fun x : ℝ => ∑ n ∈ Finset.range ⌊x⌋₊, (μ n : ℝ)) =o[atTop] (fun x : ℝ => x) := by ++ have h_bound : (fun x : ℝ => ∑ n ∈ Finset.range ⌊x⌋₊, (μ n : ℝ)) =o[atTop] (fun x : ℝ => x) := by ++ have h_sum : (fun x : ℝ => ∑ n ∈ Finset.range (⌊x⌋₊ + 1), (μ n : ℝ)) =o[atTop] (fun x : ℝ => x) := by ++ have h_moebius_sum : (fun x : ℝ => ∑ n ∈ Finset.Iic ⌊x⌋₊, (μ n : ℝ)) =o[atTop] (fun x : ℝ => x) := by ++ convert! M_isLittleO using 1 ++ simpa only [Finset.range_eq_Ico] using! h_moebius_sum ++ have h_mu_floor : (fun x : ℝ => (μ ⌊x⌋₊ : ℝ)) =o[atTop] (fun x : ℝ => x) := by ++ rw [Asymptotics.isLittleO_iff_tendsto'] <;> norm_num ++ · refine squeeze_zero_norm (a := fun x : ℝ => 1 / |x|) ?_ ?_ ++ · intro x; norm_num [abs_div] ++ exact mul_le_of_le_one_left (by positivity) (mod_cast by exact abs_moebius_le_one) ++ · exact tendsto_const_nhds.div_atTop (tendsto_norm_atTop_atTop) ++ · exact ⟨1, by intros; linarith⟩ ++ simpa [Finset.sum_range_succ] using h_sum.sub h_mu_floor ++ convert h_bound using 1 ++ rw [Asymptotics.isLittleO_iff] at * ++ simp_all +decide [Norm.norm] ++ ++lemma lambda_eq_sum_sq_dvd_mu (n : ℕ) (hn : n ≠ 0) : ++ ((-1 : ℝ) ^ (Ω n)) = ∑ d ∈ (Icc 1 n).filter (fun d => d^2 ∣ n), (μ (n / d^2) : ℝ) := by ++ set a : ℕ → ℕ := fun p => Nat.factorization n p with ha ++ have hn_factor : n = ∏ p ∈ Nat.primeFactors n, p ^ a p := by ++ exact Eq.symm ( Nat.prod_factorization_pow_eq_self hn ); ++ have h_sum_factor : (∑ d ∈ Finset.filter (fun d => d^2 ∣ n) (Finset.Icc 1 n), (μ (n / d^2) : ℝ)) = (∏ p ∈ Nat.primeFactors n, (∑ d ∈ Finset.range (a p / 2 + 1), (μ (p^(a p - 2 * d)) : ℝ))) := by ++ have h_mult : ∀ {m n : ℕ}, Nat.gcd m n = 1 → (∑ d ∈ Finset.filter (fun d => d^2 ∣ m * n) (Finset.Icc 1 (m * n)), (μ (m * n / d^2) : ℝ)) = (∑ d ∈ Finset.filter (fun d => d^2 ∣ m) (Finset.Icc 1 m), (μ (m / d^2) : ℝ)) * (∑ d ∈ Finset.filter (fun d => d^2 ∣ n) (Finset.Icc 1 n), (μ (n / d^2) : ℝ)) := by ++ intros m n h_coprime ++ have h_filter : Finset.filter (fun d => d^2 ∣ m * n) (Finset.Icc 1 (m * n)) = Finset.image (fun (d : ℕ × ℕ) => d.1 * d.2) (Finset.filter (fun d => d^2 ∣ m) (Finset.Icc 1 m) ×ˢ Finset.filter (fun d => d^2 ∣ n) (Finset.Icc 1 n)) := by ++ ext d ++ simp only [mem_filter, mem_Icc, mem_image, mem_product, Prod.exists] ++ constructor ++ · intro h ++ obtain ⟨d1, d2, hd1, hd2, hd⟩ : ∃ d1 d2 : ℕ, d1^2 ∣ m ∧ d2^2 ∣ n ∧ d = d1 * d2 := by ++ have h_factor : d^2 ∣ m * n → ∃ d1 d2 : ℕ, d1^2 ∣ m ∧ d2^2 ∣ n ∧ d = d1 * d2 := by ++ intro h_div ++ obtain ⟨d1, d2, hd1, hd2, hd⟩ : ∃ d1 d2 : ℕ, d1 ∣ m ∧ d2 ∣ n ∧ d = d1 * d2 := by ++ exact Exists.imp ( by tauto ) ( Nat.dvd_mul.mp ( dvd_of_mul_left_dvd h_div ) ); ++ refine ⟨ d1, d2, ?_, ?_, hd ⟩ ++ · apply Nat.Coprime.dvd_of_dvd_mul_right ++ · exact Nat.Coprime.pow_left 2 (Nat.Coprime.coprime_dvd_left hd1 h_coprime) ++ · exact dvd_trans (pow_dvd_pow_of_dvd (hd.symm ▸ dvd_mul_right _ _) 2) h_div ++ · subst hd ++ apply Nat.Coprime.dvd_of_dvd_mul_left ++ · exact Nat.Coprime.pow_left _ (Nat.Coprime.symm <| Nat.Coprime.coprime_dvd_right hd2 h_coprime) ++ · exact dvd_trans ⟨d1 ^ 2, by ring⟩ h_div ++ exact h_factor h.2; ++ refine ⟨ d1, d2, ?_, ?_ ⟩ <;> norm_num [ hd ] ++ exact ⟨ ⟨ ⟨ Nat.pos_of_ne_zero ( by rintro rfl; linarith ), Nat.le_of_dvd ( Nat.pos_of_ne_zero ( by rintro rfl; linarith ) ) ( dvd_of_mul_left_dvd hd1 ) ⟩, hd1 ⟩, ⟨ Nat.pos_of_ne_zero ( by rintro rfl; linarith ), Nat.le_of_dvd ( Nat.pos_of_ne_zero ( by rintro rfl; linarith ) ) ( dvd_of_mul_left_dvd hd2 ) ⟩, hd2 ⟩; ++ · intro h ++ rcases h with ⟨ a, b, ⟨ ⟨ ⟨ ha₁, ha₂ ⟩, ha₃ ⟩, ⟨ ⟨ hb₁, hb₂ ⟩, hb₃ ⟩ ⟩, rfl ⟩ ; exact ⟨ ⟨ by nlinarith, by nlinarith ⟩, by convert Nat.mul_dvd_mul ha₃ hb₃ using 1 ; ring ⟩ ; ++ rw [ h_filter, Finset.sum_image ]; ++ · rw [ Finset.sum_product, Finset.sum_mul ]; ++ simp +decide only [Finset.mul_sum _ _ _]; ++ refine Finset.sum_congr rfl fun x hx => Finset.sum_congr rfl fun y hy => ?_ ++ rw [show m * n / (x * y) ^ 2 = (m / x ^ 2) * (n / y ^ 2) by ++ have hx' : x ^ 2 ∣ m := by ++ simpa only [sq] using (Finset.mem_filter.mp hx).2 ++ have hy' : y ^ 2 ∣ n := by ++ simpa only [sq] using (Finset.mem_filter.mp hy).2 ++ simpa [mul_pow, mul_assoc, mul_left_comm, mul_comm] using ++ (Nat.div_mul_div_comm (a := m) (b := x ^ 2) (c := n) (d := y ^ 2) hx' hy').symm] ++ norm_cast ++ apply ArithmeticFunction.IsMultiplicative.map_mul_of_coprime; ++ · exact ArithmeticFunction.isMultiplicative_moebius; ++ · exact Nat.Coprime.coprime_dvd_left ( Nat.div_dvd_of_dvd <| Finset.mem_filter.mp hx |>.2 ) <| Nat.Coprime.coprime_dvd_right ( Nat.div_dvd_of_dvd <| Finset.mem_filter.mp hy |>.2 ) h_coprime; ++ · intros x hx y hy; simp +contextual only [ne_eq, coe_product, coe_filter, mem_Icc, Set.mem_prod, Set.mem_ofPred_eq] at *; ++ intro hxy ++ have h_eq1 : x.1 = y.1 := by ++ exact Nat.dvd_antisymm ( by exact Nat.Coprime.dvd_of_dvd_mul_right ( show Nat.Coprime ( x.1 ) ( y.2 ) from Nat.Coprime.coprime_dvd_left ( dvd_of_mul_left_dvd hx.1.2 ) <| Nat.Coprime.coprime_dvd_right ( dvd_of_mul_left_dvd hy.2.2 ) h_coprime ) <| hxy.symm ▸ dvd_mul_right _ _ ) ( by exact Nat.Coprime.dvd_of_dvd_mul_right ( show Nat.Coprime ( y.1 ) ( x.2 ) from Nat.Coprime.coprime_dvd_left ( dvd_of_mul_left_dvd hy.1.2 ) <| Nat.Coprime.coprime_dvd_right ( dvd_of_mul_left_dvd hx.2.2 ) h_coprime ) <| hxy.symm ▸ dvd_mul_right _ _ ) ++ have h_eq2 : x.2 = y.2 := by ++ nlinarith ++ exact Prod.ext h_eq1 h_eq2; ++ have h_prod : (∑ d ∈ Finset.filter (fun d => d^2 ∣ n) (Finset.Icc 1 n), (μ (n / d^2) : ℝ)) = (∏ p ∈ Nat.primeFactors n, (∑ d ∈ Finset.filter (fun d => d^2 ∣ p^(a p)) (Finset.Icc 1 (p^(a p))), (μ (p^(a p) / d^2) : ℝ))) := by ++ have h_prod : ∀ {S : Finset ℕ}, (∀ p ∈ S, Nat.Prime p) → (∑ d ∈ Finset.filter (fun d => d^2 ∣ ∏ p ∈ S, p^(a p)) (Finset.Icc 1 (∏ p ∈ S, p^(a p))), (μ ((∏ p ∈ S, p^(a p)) / d^2) : ℝ)) = (∏ p ∈ S, (∑ d ∈ Finset.filter (fun d => d^2 ∣ p^(a p)) (Finset.Icc 1 (p^(a p))), (μ (p^(a p) / d^2) : ℝ))) := by ++ intro S hS; induction S using Finset.induction <;> norm_num at *; ++ · norm_num [ Finset.sum_filter ]; ++ · rw [ Finset.prod_insert ‹_›, h_mult ]; ++ · rw [ Finset.prod_insert ‹_›, ‹ ( ∀ p ∈ _, Nat.Prime p ) → ∑ d ∈ Finset.Icc 1 ( ∏ p ∈ _, p ^ a p ) with d ^ 2 ∣ ∏ p ∈ _, p ^ a p, ( μ ( ( ∏ p ∈ _, p ^ a p ) / d ^ 2 ) : ℝ ) = ∏ p ∈ _, ∑ d ∈ Finset.Icc 1 ( p ^ a p ) with d ^ 2 ∣ p ^ a p, ( μ ( p ^ a p / d ^ 2 ) : ℝ ) › hS.2 ]; ++ · exact Nat.Coprime.prod_right fun p hp => Nat.coprime_pow_primes _ _ hS.1 ( hS.2 p hp ) <| by rintro rfl; exact ‹¬_› hp; ++ convert h_prod fun p hp => Nat.prime_of_mem_primeFactors hp; ++ have h_divisors : ∀ p ∈ Nat.primeFactors n, Finset.filter (fun d => d^2 ∣ p^(a p)) (Finset.Icc 1 (p^(a p))) = Finset.image (fun k => p^k) (Finset.Icc 0 (a p / 2)) := by ++ intro p hp ++ ext d ++ simp only [mem_filter, mem_Icc, mem_image, _root_.zero_le, true_and] ++ constructor; ++ · intro hd; ++ have : d ∣ p ^ a p := dvd_of_mul_left_dvd hd.2; ( rw [ Nat.dvd_prime_pow ( Nat.prime_of_mem_primeFactors hp ) ] at this; obtain ⟨ k, hk ⟩ := this; use k; simp +decide only [ hk, and_true ] at hd ⊢; ); ++ rw [ Nat.le_div_iff_mul_le zero_lt_two ] ; rw [ ← pow_mul ] at hd ; exact Nat.le_of_not_lt fun h => absurd ( Nat.le_of_dvd ( pow_pos ( Nat.pos_of_mem_primeFactors hp ) _ ) hd.2 ) ( by exact not_le_of_gt ( pow_lt_pow_right₀ ( Nat.Prime.one_lt ( Nat.prime_of_mem_primeFactors hp ) ) ( by linarith ) ) ) ; ++ · rintro ⟨ k, hk₁, rfl ⟩ ; exact ⟨ ⟨ Nat.one_le_pow _ _ ( Nat.pos_of_mem_primeFactors hp ), Nat.pow_le_pow_right ( Nat.pos_of_mem_primeFactors hp ) ( by omega ) ⟩, by rw [ ← pow_mul ] ; exact pow_dvd_pow _ ( by omega ) ⟩ ; ++ rw [ h_prod, Finset.prod_congr rfl ]; ++ intro p hp; rw [ show ( Finset.filter ( fun d => d ^ 2 ∣ p ^ a p ) ( Finset.Icc 1 ( p ^ a p ) ) ) = Finset.image ( fun k => p ^ k ) ( Finset.Icc 0 ( a p / 2 ) ) from h_divisors p hp ] ; rw [ Finset.sum_image ] <;> norm_num [ pow_mul', Nat.div_eq_of_lt ] ; ++ · rw [Finset.range_eq_Ico, ← Order.succ_eq_add_one, Finset.Ico_succ_right_eq_Icc] ++ refine Finset.sum_congr rfl ?_ ++ intro x hx ++ rw [← pow_mul', Nat.mul_comm] ++ have hx_pos : 0 < p ^ (x * 2) := pow_pos (Nat.pos_of_mem_primeFactors hp) _ ++ have hx_eq : p ^ a p = p ^ (a p - x * 2) * p ^ (x * 2) := by ++ rw [← pow_add, Nat.sub_add_cancel (by linarith [Finset.mem_Icc.mp hx, Nat.div_mul_le_self (a p) 2])] ++ rw [Nat.div_eq_of_eq_mul_left hx_pos hx_eq] ++ · exact fun x hx y hy hxy => Nat.pow_right_injective ( Nat.Prime.one_lt ( Nat.prime_of_mem_primeFactors hp ) ) hxy; ++ have h_inner_sum : ∀ p ∈ Nat.primeFactors n, (∑ d ∈ Finset.range (a p / 2 + 1), (μ (p^(a p - 2 * d)) : ℝ)) = (-1 : ℝ) ^ (a p) := by ++ intro p hp ++ have h_inner_sum_cases : ∀ d ∈ Finset.range (a p / 2 + 1), (μ (p^(a p - 2 * d)) : ℝ) = if a p - 2 * d = 0 then 1 else if a p - 2 * d = 1 then -1 else 0 := by ++ simp +zetaDelta only [ne_eq, mem_primeFactors, mem_range] at * ++ intro d hd ++ rcases k : (n.factorization p - 2 * d) with (_ | _ | k) ++ · simp +decide only [pow_zero, isUnit_iff_eq_one, IsUnit.squarefree, moebius_apply_of_squarefree, Int.reduceNeg, ++ cardFactors_one, Int.cast_one, ↓reduceIte] ++ · simp +decide only [zero_add, pow_one, ↓reduceIte] ++ norm_num [hp.1, ArithmeticFunction.moebius] ++ exact hp.1.squarefree ++ · simp +decide only [Nat.add_eq_zero_iff, and_false, and_self, ↓reduceIte, Nat.add_eq_right, Int.cast_eq_zero] ++ exact ++ ArithmeticFunction.moebius_eq_zero_of_not_squarefree ++ (by rw [Nat.squarefree_pow_iff] <;> norm_num [hp.1.ne_one, hp.1.ne_zero]) ++ rw [ Finset.sum_congr rfl h_inner_sum_cases ] ; norm_num [ Finset.sum_ite ] ; rcases Nat.even_or_odd' ( a p ) with ⟨ k, hk | hk ⟩ <;> norm_num [ hk, pow_add, pow_mul ] ++ · ring_nf ++ norm_num [ show ∀ x : ℕ, k * 2 - x * 2 = 0 ↔ x ≥ k by intro x; exact ⟨ fun hx => by contrapose! hx; exact Nat.ne_of_gt <| Nat.sub_pos_of_lt <| by linarith, fun hx => Nat.sub_eq_zero_of_le <| by linarith ⟩ ]; ++ have h_first : ++ Finset.filter (fun x => k ≤ x) (Finset.range (k + 1)) = {k} := by ++ ext x ++ simp ++ omega ++ have h_second : ++ Finset.filter (fun x => k * 2 - x * 2 = 1) ++ (Finset.filter (fun x => ¬2 * k - 2 * x = 0) (Finset.range (k + 1))) = ∅ := by ++ ext x ++ simp ++ omega ++ rw [h_first, h_second] ++ norm_num ++ · ring_nf ++ norm_num [ Nat.add_div ]; ++ rw [ Finset.card_eq_zero.mpr ] <;> norm_num; ++ · rw [ Finset.card_eq_one ] ; use k ; ext x ; norm_num ; omega; ++ · intros; omega; ++ rw [ h_sum_factor, Finset.prod_congr rfl h_inner_sum ]; ++ rw [ Finset.prod_pow_eq_pow_sum ]; ++ rw [ ArithmeticFunction.cardFactors_apply ]; ++ rw [ ← Multiset.coe_card, ← Multiset.toFinset_sum_count_eq ]; ++ norm_num +zetaDelta [Nat.primeFactorsList_count_eq] ++ ++lemma sum_lambda_eq_sum_mu_div_sq (N : ℕ) : ++ ∑ n ∈ Finset.Icc 1 N, ((-1 : ℝ) ^ (Ω n)) = ++ ∑ d ∈ Finset.Icc 1 (Nat.sqrt N), ∑ k ∈ Finset.Icc 1 (N / d^2), (μ k : ℝ) := by ++ have h_sum_rewrite : ∑ n ∈ Finset.Icc 1 N, (-1 : ℝ) ^ (Ω n) = ∑ n ∈ Finset.Icc 1 N, ∑ d ∈ (Finset.Icc 1 N).filter (fun d => d^2 ∣ n), (μ (n / d^2) : ℝ) := by ++ have h_sum_rewrite : ∀ n ∈ Finset.Icc 1 N, (-1 : ℝ) ^ (Ω n) = ∑ d ∈ (Finset.Icc 1 N).filter (fun d => d^2 ∣ n), (μ (n / d^2) : ℝ) := by ++ intro n hn ++ have h_lambda_eq : ((-1 : ℝ) ^ (Ω n)) = ∑ d ∈ (Finset.Icc 1 n).filter (fun d => d^2 ∣ n), (μ (n / d^2) : ℝ) := by ++ convert lambda_eq_sum_sq_dvd_mu n ( by linarith [ Finset.mem_Icc.mp hn ] ) using 1; ++ rw [ h_lambda_eq, Finset.sum_subset ]; ++ · exact fun x hx => Finset.mem_filter.mpr ⟨ Finset.mem_Icc.mpr ⟨ Finset.mem_Icc.mp ( Finset.mem_filter.mp hx |>.1 ) |>.1, by linarith [ Finset.mem_Icc.mp ( Finset.mem_filter.mp hx |>.1 ) |>.2, Finset.mem_Icc.mp hn |>.2 ] ⟩, Finset.mem_filter.mp hx |>.2 ⟩; ++ · simp +zetaDelta only [mem_Icc, mem_filter, not_and, and_imp, Int.cast_eq_zero] at * ++ exact fun x hx₁ hx₂ hx₃ hx₄ => False.elim <| hx₄ hx₁ ( by nlinarith [ Nat.le_of_dvd ( by linarith ) hx₃ ] ) hx₃; ++ exact Finset.sum_congr rfl h_sum_rewrite; ++ rw [ h_sum_rewrite, Finset.sum_sigma' ]; ++ have h_reindex : ∑ x ∈ (Finset.Icc 1 N).sigma fun (n : ℕ) => {d ∈ Finset.Icc 1 N | d ^ 2 ∣ n}, (μ (x.fst / x.snd ^ 2) : ℝ) = ∑ d ∈ Finset.Icc 1 (Nat.sqrt N), ∑ k ∈ Finset.Icc 1 (N / d ^ 2), (μ k : ℝ) := by ++ have : Finset.filter (fun x => x.snd ^ 2 ∣ x.fst) (Finset.Icc 1 N ×ˢ Finset.Icc 1 N) = Finset.biUnion (Finset.Icc 1 (Nat.sqrt N)) (fun d => Finset.image (fun k => (d ^ 2 * k, d)) (Finset.Icc 1 (N / d ^ 2))) := by ++ ext ⟨n, d⟩ ++ simp only [Finset.mem_filter, Finset.mem_product, Finset.mem_Icc, Finset.mem_biUnion, Finset.mem_image, Prod.mk.injEq] ++ constructor ++ · intro ⟨⟨⟨hn1, hn2⟩, hd1, hd2⟩, hdiv⟩ ++ exact ⟨d, ⟨hd1, by rw [Nat.le_sqrt]; nlinarith [Nat.le_of_dvd (by linarith) hdiv]⟩, n / d ^ 2, ⟨Nat.div_pos (Nat.le_of_dvd (by linarith) hdiv) (by nlinarith), Nat.div_le_div_right hn2⟩, Nat.mul_div_cancel' hdiv, rfl⟩ ++ · rintro ⟨a, ⟨ha₁, ha₂⟩, b, ⟨hb₁, hb₂⟩, hn, hd⟩ ++ rw [← hn, ← hd] ++ exact ⟨⟨⟨by nlinarith, by nlinarith [Nat.div_mul_le_self N (a ^ 2)]⟩, ha₁, by nlinarith [Nat.sqrt_le N]⟩, dvd_mul_right _ _⟩ ++ rw [ Finset.sum_sigma' ]; ++ apply Finset.sum_bij (fun x _ => ⟨x.snd, x.fst / x.snd ^ 2⟩); ++ · simp_all +decide only [Finset.ext_iff, mem_filter, mem_product, mem_Icc, mem_biUnion, mem_image, Prod.forall, ++ Prod.mk.injEq, ↓existsAndEq, and_true, exists_and_left, mem_sigma, true_and, and_imp] ++ exact fun x hx₁ hx₂ hx₃ hx₄ hx₅ => ⟨ by nlinarith [ Nat.le_of_dvd ( by linarith ) hx₅, Nat.lt_succ_sqrt N ], Nat.div_pos ( Nat.le_of_dvd ( by linarith ) hx₅ ) ( by positivity ), Nat.div_le_div_right hx₂ ⟩; ++ · simp +contextual [ Finset.mem_sigma, Finset.mem_filter ]; ++ aesop; ++ · simp +zetaDelta only [mem_sigma, mem_Icc, mem_filter, exists_prop, Sigma.exists, and_imp] at * ++ exact fun b hb₁ hb₂ hb₃ hb₄ => ⟨ b.fst ^ 2 * b.snd, b.fst, ⟨ ⟨ by nlinarith, by nlinarith [ Nat.div_mul_le_self N ( b.fst ^ 2 ) ] ⟩, ⟨ by nlinarith, by nlinarith [ Nat.div_mul_le_self N ( b.fst ^ 2 ) ] ⟩, by norm_num ⟩, by simp +decide [ Nat.mul_div_cancel_left _ ( by nlinarith : 0 < b.fst ^ 2 ) ] ⟩; ++ · aesop; ++ convert h_reindex using 1 ++ ++lemma sum_mu_div_sq_isLittleO : (fun N : ℕ ↦ ∑ d ∈ Finset.Icc 1 (Nat.sqrt N), ∑ k ∈ Finset.Icc 1 (N / d^2), (μ k : ℝ)) =o[atTop] (fun N ↦ (N : ℝ)) := by ++ have h_sum_rewrite : ∀ N : ℕ, (∑ d ∈ Finset.Icc 1 (Nat.sqrt N), (∑ k ∈ Finset.Icc 1 (N / d^2), (μ k : ℝ))) = (∑ d ∈ Finset.Icc 1 (Nat.sqrt N), (M (N / d^2) : ℝ)) := by ++ intro N ++ simp only [M] ++ refine Finset.sum_congr rfl ?_ ++ intro x hx ++ erw [ Finset.sum_Ico_eq_sub _ ] <;> norm_num [ Finset.sum_range_succ' ]; ++ rw [ show ⌊ ( N : ℝ ) / x ^ 2⌋₊ = N / x ^ 2 from Nat.floor_eq_iff ( by positivity ) |>.2 ⟨ by rw [ le_div_iff₀ ( by norm_cast; nlinarith [ Finset.mem_Icc.mp hx ] ) ] ; norm_cast; linarith [ Nat.div_mul_le_self N ( x ^ 2 ) ], by rw [ div_lt_iff₀ ( by norm_cast; nlinarith [ Finset.mem_Icc.mp hx ] ) ] ; norm_cast; linarith [ Nat.div_add_mod N ( x ^ 2 ), Nat.mod_lt N ( show x ^ 2 > 0 by nlinarith [ Finset.mem_Icc.mp hx ] ) ] ⟩ ] ; erw [ Finset.sum_Ico_eq_sub _ ] <;> norm_num [ Finset.sum_range_succ' ] ; ++ have h_bound : ∀ ε > 0, ∃ N₀ : ℕ, ∀ N ≥ N₀, ∀ d ∈ Finset.Icc 1 (Nat.sqrt N), |M (N / d^2)| ≤ ε * (N / d^2) + N₀ := by ++ have h_bound : ∀ ε > 0, ∃ C : ℝ, ∀ x : ℝ, 1 ≤ x → |M x| ≤ ε * x + C := by ++ have h_bound : ∀ ε > 0, ∃ C : ℝ, ∀ x : ℝ, 1 ≤ x → |M x| ≤ ε * x + C := by ++ intro ε hε ++ have := M_isLittleO' ++ rw [ Asymptotics.isLittleO_iff ] at this; ++ norm_num +zetaDelta at *; ++ obtain ⟨ a, ha ⟩ := this hε; ++ obtain ⟨C, hC⟩ : ∃ C : ℝ, ∀ x ∈ Set.Icc 1 a, |M x| ≤ C := by ++ have h_bounded : BddAbove (Set.image (fun x => |M x|) (Set.Icc 1 a)) := by ++ have h_bounded : BddAbove (Set.image (fun x => |∑ n ∈ Finset.Iic ⌊x⌋₊, (μ n : ℝ)|) (Set.Icc 1 a)) := by ++ have h_finite : Set.Finite (Set.image (fun x => ⌊x⌋₊) (Set.Icc 1 a)) := by ++ exact Set.finite_iff_bddAbove.mpr ⟨ ⌊a⌋₊, Set.forall_mem_image.mpr fun x hx => Nat.floor_mono hx.2 ⟩ ++ have h_bounded : BddAbove (Set.image (fun n : ℕ => |∑ k ∈ Finset.Iic n, (μ k : ℝ)|) (Set.image (fun x => ⌊x⌋₊) (Set.Icc 1 a))) := by ++ exact Set.Finite.bddAbove <| h_finite.image _; ++ exact ⟨ h_bounded.choose, Set.forall_mem_image.2 fun x hx => h_bounded.choose_spec <| Set.mem_image_of_mem _ <| Set.mem_image_of_mem _ hx ⟩; ++ convert! h_bounded using 1; ++ exact ⟨ h_bounded.choose, fun x hx => h_bounded.choose_spec ⟨ x, hx, rfl ⟩ ⟩; ++ exact ⟨ Max.max C 0, fun x hx => if hx' : x ≤ a then le_trans ( hC x ⟨ hx, hx' ⟩ ) ( le_max_left _ _ ) |> le_trans <| le_add_of_nonneg_left <| by positivity else le_trans ( ha x <| le_of_not_ge hx' ) <| by rw [ abs_of_nonneg <| by linarith ] ; exact le_add_of_nonneg_right <| by positivity ⟩; ++ assumption; ++ intro ε hε ++ obtain ⟨C, hC⟩ := h_bound ε hε ++ refine ⟨⌈C⌉₊ + 1, ?_⟩ ++ intro N hN d hd ++ specialize hC (N / d ^ 2) ++ rcases eq_or_ne d 0 with rfl | hd0 ++ · simp_all +decide only [gt_iff_lt, ge_iff_le, mem_Icc, _root_.zero_le, and_true] ++ · simp_all +decide only [gt_iff_lt, ge_iff_le, mem_Icc, ne_eq, cast_add, cast_one] ++ exact ++ le_trans ++ (hC <| ++ by ++ rw [le_div_iff₀ <| by positivity] ++ nlinarith [show (d : ℝ) ^ 2 ≤ N by norm_cast; nlinarith [Nat.sqrt_le N]]) ++ (by linarith [Nat.le_ceil C]) ++ have h_sum_bound : ∀ ε > 0, ∃ N₀ : ℕ, ∀ N ≥ N₀, |∑ d ∈ Finset.Icc 1 (Nat.sqrt N), M (N / d^2)| ≤ ε * N * (∑' k : ℕ, (1 : ℝ) / (k^2)) + N₀ * Nat.sqrt N := by ++ intros ε hε_pos ++ obtain ⟨N₀, hN₀⟩ := h_bound ε hε_pos ++ use N₀ ++ intro N hN ++ have h_sum_bound : |∑ d ∈ Finset.Icc 1 (Nat.sqrt N), M (N / d^2)| ≤ ∑ d ∈ Finset.Icc 1 (Nat.sqrt N), (ε * (N / d^2) + N₀) := by ++ exact le_trans ( Finset.abs_sum_le_sum_abs _ _ ) ( Finset.sum_le_sum fun x hx => hN₀ N hN x hx ); ++ refine le_trans h_sum_bound ?_; ++ norm_num [ Finset.sum_add_distrib, Finset.mul_sum _ _ _, mul_assoc, mul_comm, mul_left_comm, div_eq_mul_inv ]; ++ rw [ ← Finset.mul_sum _ _ _, ← Finset.mul_sum _ _ _ ]; ++ exact mul_le_mul_of_nonneg_left ( mul_le_mul_of_nonneg_left ( Summable.sum_le_tsum ( Finset.Icc 1 N.sqrt ) ( fun _ _ => by positivity ) ( by simp ) ) ( Nat.cast_nonneg _ ) ) hε_pos.le; ++ rw [ Asymptotics.isLittleO_iff ]; ++ intro c hc ++ obtain ⟨ε, hε_pos, hε⟩ : ∃ ε > 0, ε * (∑' k : ℕ, (1 : ℝ) / (k^2)) < c / 2 := by ++ exact ⟨ ( c / 2 ) / ( ∑' k : ℕ, 1 / ( k : ℝ ) ^ 2 + 1 ), div_pos ( half_pos hc ) ( add_pos_of_nonneg_of_pos ( tsum_nonneg fun _ => by positivity ) zero_lt_one ), by rw [ div_mul_eq_mul_div, div_lt_iff₀ ] <;> nlinarith [ show 0 ≤ ∑' k : ℕ, 1 / ( k : ℝ ) ^ 2 from tsum_nonneg fun _ => by positivity ] ⟩; ++ obtain ⟨ N₀, hN₀ ⟩ := h_sum_bound ε hε_pos; ++ obtain ⟨N₁, hN₁⟩ : ∃ N₁ : ℕ, ∀ N ≥ N₁, N₀ * Nat.sqrt N ≤ (c / 2) * N := by ++ have h_sqrt_growth : ∃ N₁ : ℕ, ∀ N ≥ N₁, (N₀ : ℝ) * Real.sqrt N ≤ (c / 2) * N := by ++ have h_sqrt_bound : Filter.Tendsto (fun N : ℕ => (N₀ : ℝ) * Real.sqrt N / N) Filter.atTop (nhds 0) := by ++ simpa [ mul_div_assoc, Real.sqrt_div_self ] using tendsto_const_nhds.mul ( tendsto_inv_atTop_nhds_zero_nat.sqrt ) ++ exact Filter.eventually_atTop.mp ( h_sqrt_bound.eventually ( gt_mem_nhds <| show 0 < c / 2 by positivity ) ) |> fun ⟨ N₁, hN₁ ⟩ ↦ ⟨ N₁ + 1, fun N hN ↦ by have := hN₁ N ( by linarith ) ; rw [ div_lt_iff₀ ] at this <;> nlinarith [ show ( N : ℝ ) ≥ N₁ + 1 by exact_mod_cast hN ] ⟩; ++ exact ⟨ h_sqrt_growth.choose, fun N hN => le_trans ( mul_le_mul_of_nonneg_left ( Real.le_sqrt_of_sq_le <| mod_cast Nat.sqrt_le' _ ) <| Nat.cast_nonneg _ ) <| h_sqrt_growth.choose_spec N hN ⟩; ++ filter_upwards [ Filter.eventually_ge_atTop N₀, Filter.eventually_ge_atTop N₁ ] with N hN₀' hN₁' using by rw [ Real.norm_of_nonneg ( Nat.cast_nonneg _ ) ] ; rw [ h_sum_rewrite ] ; exact le_trans ( hN₀ _ hN₀' ) ( by nlinarith [ hN₁ _ hN₁', show ( N : ℝ ) ≥ 0 by positivity ] ) ; ++ ++theorem lambda_pnt : (fun x : ℝ ↦ ∑ n ∈ range ⌊x⌋₊, (-1)^(Ω n)) =o[atTop] fun x ↦ x := by ++ have h_lambda_pnt : (fun N : ℕ => ∑ n ∈ Finset.range N, (-1 : ℝ) ^ (Nat.factorization n).sum (fun p k => k)) =o[Filter.atTop] (fun N : ℕ => (N : ℝ)) := by ++ have h_lambda_pnt : (fun N : ℕ => ∑ n ∈ Finset.Icc 1 N, (-1 : ℝ) ^ (Nat.factorization n).sum (fun p k => k)) =o[Filter.atTop] (fun N : ℕ => (N : ℝ)) := by ++ have h_lambda_pnt : (fun N : ℕ => ∑ d ∈ Finset.Icc 1 (Nat.sqrt N), ∑ k ∈ Finset.Icc 1 (N / d^2), (μ k : ℝ)) =o[Filter.atTop] (fun N : ℕ => (N : ℝ)) := by ++ exact sum_mu_div_sq_isLittleO ++ convert h_lambda_pnt using 2; ++ convert sum_lambda_eq_sum_mu_div_sq _; ++ exact Eq.symm cardFactors_eq_sum_factorization ++ have h_lambda_pnt : (fun N : ℕ => ∑ n ∈ Finset.range (N + 1), (-1 : ℝ) ^ (Nat.factorization n).sum (fun p k => k)) =o[Filter.atTop] (fun N : ℕ => (N : ℝ)) := by ++ rw [ Asymptotics.isLittleO_iff_tendsto' ] at * <;> norm_num at *; ++ · convert h_lambda_pnt.add ( show Filter.Tendsto ( fun x : ℕ => ( 1 : ℝ ) / x ) Filter.atTop ( nhds 0 ) from tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop ) using 2 <;> norm_num [ Finset.sum_Ico_eq_sum_range ]; ++ erw [ Finset.sum_Ico_eq_sub _ _ ] <;> norm_num [ Finset.sum_range_succ' ] ; ring_nf; ++ · exact ⟨ 1, by aesop ⟩; ++ · exact ⟨ 1, by aesop ⟩; ++ simp_all +decide only [Finset.sum_range_succ] ++ have := h_lambda_pnt.sub ( show ( fun N : ℕ => ( -1 : ℝ ) ^ N.factorization.sum fun p k => k ) =o[Filter.atTop] fun N : ℕ => ( N : ℝ ) from ?_ ); ++ · aesop; ++ · rw [ Asymptotics.isLittleO_iff_tendsto' ] <;> norm_num; ++ · exact tendsto_zero_iff_norm_tendsto_zero.mpr ( by simpa using tendsto_inv_atTop_nhds_zero_nat ); ++ · exact ⟨ 1, fun n hn => by positivity ⟩; ++ have h_floor : (fun x : ℝ => ∑ n ∈ Finset.range ⌊x⌋₊, (-1 : ℝ) ^ (Nat.factorization n).sum (fun p k => k)) =o[Filter.atTop] (fun x : ℝ => (⌊x⌋₊ : ℝ)) := by ++ rw [ Asymptotics.isLittleO_iff_tendsto' ] at * <;> norm_num at *; ++ · exact h_lambda_pnt.comp <| tendsto_nat_floor_atTop; ++ · exact ⟨ 1, by aesop ⟩; ++ · exact ⟨ 1, by intros; linarith ⟩; ++ rw [ Asymptotics.isLittleO_iff ] at *; ++ intro c hc ++ filter_upwards [h_floor (half_pos hc), Filter.eventually_gt_atTop 1] with x hx₁ hx₂ ++ refine le_trans ?_ (le_trans hx₁ ?_) ++ · norm_num [ Norm.norm ]; ++ convert le_rfl using 2; ++ congr! 2; ++ exact Eq.symm cardFactors_eq_sum_factorization ++ · norm_num [ abs_of_nonneg, Nat.floor_le, hx₂.le ]; ++ rw [ abs_of_nonneg ( by positivity ) ] ; nlinarith [ Nat.floor_le ( by positivity : 0 ≤ x ) ] ++ ++lemma sum_mobius_floor (x : ℝ) (hx : 1 ≤ x) : ∑ n ∈ Icc 1 ⌊x⌋₊, (μ n : ℝ) * ⌊x / n⌋ = 1 := by ++ classical ++ have h := sum_mobius_mul_floor x hx ++ have h0 : (0 : ℕ) ∈ Iic ⌊x⌋₊ := by simp [Finset.mem_Iic] ++ have hI : (Iic ⌊x⌋₊).erase 0 = Icc 1 ⌊x⌋₊ := by ++ ext n ++ simp [Finset.mem_Iic, Finset.mem_Icc, Nat.one_le_iff_ne_zero, and_comm] ++ rw [← Finset.sum_erase_add (Iic ⌊x⌋₊) (fun n => (μ n : ℝ) * (⌊x / n⌋ : ℝ)) h0] at h ++ simpa [hI] using h ++ ++lemma sum_mobius_floor_tail_isLittleO (K : ℕ) (hK : 0 < K) : ++ (fun x : ℝ => ∑ n ∈ Finset.Ioc ⌊x/K⌋₊ ⌊x⌋₊, (μ n : ℝ) * (⌊x / (n : ℝ)⌋ : ℝ)) =o[atTop] fun x => x := by ++ have h_group : ∀ x : ℝ, x ≥ 1 → ∑ n ∈ Finset.Ioc ⌊x / (K : ℝ)⌋₊ ⌊x⌋₊, (μ n : ℝ) * ⌊x / n⌋ = ∑ k ∈ Finset.Ico 1 K, k * (∑ n ∈ Finset.Ioc ⌊x / (k + 1 : ℝ)⌋₊ ⌊x / (k : ℝ)⌋₊, (μ n : ℝ)) := by ++ intro x hx ++ have h_group : ∑ n ∈ Finset.Ioc ⌊x / (K : ℝ)⌋₊ ⌊x⌋₊, (μ n : ℝ) * ⌊x / n⌋ = ∑ k ∈ Finset.Ico 1 K, ∑ n ∈ Finset.Ioc ⌊x / (k + 1 : ℝ)⌋₊ ⌊x / (k : ℝ)⌋₊, (μ n : ℝ) * k := by ++ have h_group : Finset.Ioc ⌊x / (K : ℝ)⌋₊ ⌊x⌋₊ = Finset.biUnion (Finset.Ico 1 K) (fun k => Finset.Ioc (⌊x / (k + 1 : ℝ)⌋₊) (⌊x / (k : ℝ)⌋₊)) := by ++ ext n ++ simp only [mem_Ioc, mem_biUnion, mem_Ico] ++ constructor ++ · intro hn ++ refine ⟨⌊x / n⌋₊, ?_, ?_, ?_⟩ ++ all_goals generalize_proofs at * ++ · rw [Nat.floor_lt', div_lt_iff₀] <;> norm_num <;> try linarith [show (n : ℝ) ≥ 1 by norm_cast; linarith] ++ exact ⟨by rw [le_div_iff₀ (Nat.cast_pos.mpr <| by linarith)] ; nlinarith [Nat.floor_le (show 0 ≤ x by linarith), Nat.lt_floor_add_one x, show (n : ℝ) ≤ ⌊x⌋₊ by exact_mod_cast hn.2], by rw [Nat.floor_lt (by positivity)] at *; rw [div_lt_iff₀ (by positivity)] at *; norm_num at *; linarith⟩ ++ · rw [Nat.floor_lt', div_lt_iff₀] <;> norm_num <;> try linarith [Nat.lt_floor_add_one (x / n)] ++ nlinarith [Nat.lt_floor_add_one (x / n), show (n : ℝ) ≥ 1 by norm_cast; linarith, div_mul_cancel₀ x (show (n : ℝ) ≠ 0 by norm_cast; linarith)] ++ · refine Nat.le_floor ?_ ++ rw [le_div_iff₀] <;> norm_num ++ · exact le_trans (mul_le_mul_of_nonneg_left (Nat.floor_le (by positivity)) (Nat.cast_nonneg _)) (by rw [mul_div_cancel₀ _ (Nat.cast_ne_zero.mpr <| by linarith)]) ++ · exact Nat.floor_pos.mpr (by rw [le_div_iff₀ (Nat.cast_pos.mpr <| pos_of_gt hn.1)] ; nlinarith [Nat.floor_le (show 0 ≤ x by positivity), Nat.lt_floor_add_one x, show (n : ℝ) ≤ ⌊x⌋₊ by exact_mod_cast hn.2, div_mul_cancel₀ x (show (K : ℝ) ≠ 0 by positivity)]) ++ · field_simp ++ rintro ⟨a, ⟨ha₁, ha₂⟩, ha₃, ha₄⟩ ++ refine ⟨lt_of_le_of_lt ?_ ha₃, ha₄.trans ?_⟩ ++ · gcongr ; norm_cast ++ · exact Nat.floor_mono <| div_le_self (by positivity) <| mod_cast ha₁ ++ rw [h_group, Finset.sum_biUnion] ++ · refine Finset.sum_congr rfl fun k hk => Finset.sum_congr rfl fun n hn => ?_ ++ simp +zetaDelta only [ge_iff_le, mem_Ico, mem_Ioc, mul_eq_mul_left_iff, Int.cast_eq_zero] at * ++ rw [Nat.floor_lt (by positivity), Nat.le_floor_iff (by positivity)] at * ++ exact Or.inl <| mod_cast Int.floor_eq_iff.mpr ⟨by rw [le_div_iff₀ <| Nat.cast_pos.mpr <| Nat.pos_of_ne_zero <| by rintro rfl; norm_num at hn; linarith [show x / (k + 1 : ℝ) > 0 by positivity]] ; norm_num; nlinarith [show (k : ℝ) ≥ 1 by norm_cast; linarith, div_mul_cancel₀ x (show (k : ℝ) ≠ 0 by norm_cast; linarith), div_mul_cancel₀ x (show (k + 1 : ℝ) ≠ 0 by positivity)], by rw [div_lt_iff₀ <| Nat.cast_pos.mpr <| Nat.pos_of_ne_zero <| by rintro rfl; norm_num at hn; linarith [show x / (k + 1 : ℝ) > 0 by positivity]] ; norm_num; nlinarith [show (k : ℝ) ≥ 1 by norm_cast; linarith, div_mul_cancel₀ x (show (k : ℝ) ≠ 0 by norm_cast; linarith), div_mul_cancel₀ x (show (k + 1 : ℝ) ≠ 0 by positivity)]⟩ ++ · intros k hk l hl hkl; simp_all +decide [Finset.disjoint_left] ++ field_simp ++ intro a ha₁ ha₂ ha₃; contrapose! hkl ++ rw [Nat.le_floor_iff (by positivity), Nat.floor_lt (by positivity)] at * ++ rw [div_lt_iff₀ (by positivity), le_div_iff₀ (by norm_cast; linarith)] at * ++ exact Nat.le_antisymm (Nat.le_of_lt_succ <| by { rw [← @Nat.cast_lt ℝ] ; push_cast; nlinarith }) (Nat.le_of_lt_succ <| by { rw [← @Nat.cast_lt ℝ] ; push_cast; nlinarith }) ++ simpa only [mul_comm, Finset.mul_sum _ _ _] using h_group ++ have h_M_x_over_k : ∀ k : ℕ, 1 ≤ k → k < K → (fun x : ℝ => ∑ n ∈ Finset.Ioc ⌊x / (k + 1 : ℝ)⌋₊ ⌊x / (k : ℝ)⌋₊, (μ n : ℝ)) =o[atTop] (fun x => x) := by ++ have h_M : (fun x : ℝ => ∑ n ∈ Finset.Icc 1 ⌊x⌋₊, (μ n : ℝ)) =o[atTop] (fun x => x) := by ++ have h_M : (fun x : ℝ => ∑ n ∈ Finset.range ⌊x⌋₊, (μ n : ℝ)) =o[atTop] (fun x => x) := by ++ refine Asymptotics.IsLittleO.of_norm_left ?_ ++ simpa only [← Int.norm_cast_real, Int.cast_sum] using mu_pnt.norm_left ++ have h_M : (fun x : ℝ => ∑ n ∈ Finset.range (⌊x⌋₊ + 1), (μ n : ℝ)) =o[atTop] (fun x => x) := by ++ simp_all +decide only [ge_iff_le, Finset.sum_range_succ] ++ refine h_M.add ?_ ++ rw [Asymptotics.isLittleO_iff_tendsto] <;> norm_num ++ refine squeeze_zero_norm' (a := fun x : ℝ => 1 / |x|) ?_ ?_ ++ · norm_num [abs_div] ++ exact ⟨1, fun x hx => mul_le_of_le_one_left (by positivity) (mod_cast by exact abs_moebius_le_one)⟩ ++ · exact tendsto_const_nhds.div_atTop (tendsto_norm_atTop_atTop) ++ convert! h_M.sub (show (fun x : ℝ => (μ 0 : ℝ)) =o[Filter.atTop] fun x : ℝ => x from ?_) using 2 <;> norm_num [Finset.sum_range_succ'] ++ erw [Finset.sum_Ico_eq_sub _ _] <;> norm_num [Finset.sum_range_succ'] ++ intros k hk_pos hk_lt_K ++ have h_M_x_over_k : (fun x : ℝ => ∑ n ∈ Finset.Ioc ⌊x / (k + 1 : ℝ)⌋₊ ⌊x / (k : ℝ)⌋₊, (μ n : ℝ)) = (fun x : ℝ => ∑ n ∈ Finset.Icc 1 ⌊x / (k : ℝ)⌋₊, (μ n : ℝ)) - (fun x : ℝ => ∑ n ∈ Finset.Icc 1 ⌊x / (k + 1 : ℝ)⌋₊, (μ n : ℝ)) := by ++ ext x ++ simp only [Pi.sub_apply] ++ rw [eq_sub_iff_add_eq'] ++ simp only [show Finset.Icc (1 : ℕ) (⌊x / (↑k + 1)⌋₊) = Finset.Ioc (0 : ℕ) (⌊x / (↑k + 1)⌋₊) by ++ simpa using (Finset.Icc_add_one_left_eq_Ioc (a := (0 : ℕ)) (b := ⌊x / (↑k + 1)⌋₊)), ++ show Finset.Icc (1 : ℕ) (⌊x / ↑k⌋₊) = Finset.Ioc (0 : ℕ) (⌊x / ↑k⌋₊) by ++ simpa using (Finset.Icc_add_one_left_eq_Ioc (a := (0 : ℕ)) (b := ⌊x / ↑k⌋₊))] ++ rw [Finset.sum_Ioc_consecutive] <;> norm_num ++ ++ by_cases hx : 0 ≤ x <;> simp_all +decide only [ge_iff_le, floor_div_natCast, not_le] ++ · rw [Nat.le_div_iff_mul_le (by positivity)] ++ exact Nat.le_floor <| by push_cast; nlinarith [Nat.floor_le (show 0 ≤ x / (k + 1) by positivity), Nat.lt_floor_add_one (x / (k + 1)), mul_div_cancel₀ x (by positivity : (k + 1 : ℝ) ≠ 0)] ++ · rw [Nat.floor_of_nonpos (div_nonpos_of_nonpos_of_nonneg hx.le (by positivity)), Nat.floor_of_nonpos hx.le] ; norm_num ++ rw [h_M_x_over_k] ++ refine Asymptotics.IsLittleO.sub ?_ ?_ ++ · field_simp ++ refine h_M.comp_tendsto (Filter.tendsto_id.atTop_mul_const (by positivity)) |> fun h => h.trans_isBigO ?_ ++ exact Asymptotics.isBigO_iff.mpr ⟨(k : ℝ) ⁻¹, Filter.eventually_atTop.mpr ⟨1, fun x hx => by simp +decide ; ring_nf; norm_num [show k ≠ 0 by linarith]⟩⟩ ++ · have := h_M.comp_tendsto (show Filter.Tendsto (fun x : ℝ => x / (k + 1)) Filter.atTop Filter.atTop from Filter.tendsto_id.atTop_div_const (by positivity)) ++ rw [Asymptotics.isLittleO_iff] at * ++ intro c hc; filter_upwards [this (show 0 < c * (k + 1) by positivity), Filter.eventually_gt_atTop 0] with x hx₁ hx₂; simp_all +decide only [ge_iff_le, norm_eq_abs, eventually_atTop, Function.comp_apply, norm_div, cast_nonneg, ++ zero_le_one, add_nonneg, abs_of_nonneg] ++ exact hx₁.trans (by rw [mul_assoc, mul_div_cancel₀ _ (by positivity)]) ++ have h_sum_o_x : (fun x : ℝ => ∑ k ∈ Finset.Ico 1 K, (k : ℝ) * (∑ n ∈ Finset.Ioc ⌊x / (k + 1 : ℝ)⌋₊ ⌊x / (k : ℝ)⌋₊, (μ n : ℝ))) =o[atTop] (fun x => x) := by ++ rw [Asymptotics.isLittleO_iff_tendsto'] ++ · have h_sum_little_o : ∀ k ∈ Finset.Ico 1 K, Filter.Tendsto (fun x : ℝ => (∑ n ∈ Finset.Ioc ⌊x / (k + 1 : ℝ)⌋₊ ⌊x / (k : ℝ)⌋₊, (μ n : ℝ)) / x) Filter.atTop (nhds 0) := by ++ intro k hk; specialize h_M_x_over_k k (Finset.mem_Ico.mp hk |>.1) (Finset.mem_Ico.mp hk |>.2) ; rw [Asymptotics.isLittleO_iff_tendsto'] at h_M_x_over_k <;> aesop ++ simpa [Finset.sum_div _ _ _, mul_div_assoc] using tendsto_finsetSum _ fun k hk => h_sum_little_o k hk |> Filter.Tendsto.const_mul _ ++ · filter_upwards [Filter.eventually_gt_atTop 0] with x hx hx' using absurd hx' hx.ne' ++ exact h_sum_o_x.congr' ++ (by filter_upwards [Filter.eventually_ge_atTop 1] with x hx using by rw [h_group x hx]) ++ (by norm_num) ++ ++lemma sum_mobius_div_approx (x : ℝ) (K : ℕ) (hK : 0 < K) (hx : 1 ≤ x) : ++ |x * (∑ n ∈ Icc 1 ⌊x/K⌋₊, (μ n : ℝ) / n) - 1| ≤ x/K + |∑ n ∈ Ioc ⌊x/K⌋₊ ⌊x⌋₊, (μ n : ℝ) * (⌊x / (n : ℝ)⌋ : ℝ)| := by ++ have h_split : ∑ n ∈ Finset.Icc 1 ⌊x⌋₊, (μ n : ℝ) * ⌊x / (n : ℝ)⌋ = (∑ n ∈ Finset.Icc 1 ⌊x / (K : ℝ)⌋₊, (μ n : ℝ) * ⌊x / (n : ℝ)⌋) + (∑ n ∈ Finset.Ioc ⌊x / (K : ℝ)⌋₊ ⌊x⌋₊, (μ n : ℝ) * ⌊x / (n : ℝ)⌋) := by ++ erw [Finset.sum_Ioc_consecutive] <;> norm_num ++ · rfl ++ · exact Nat.floor_mono <| div_le_self (by positivity) <| mod_cast hK ++ have h_floor : ∑ n ∈ Finset.Icc 1 ⌊x / (K : ℝ)⌋₊, (μ n : ℝ) * ⌊x / (n : ℝ)⌋ = x * ∑ n ∈ Finset.Icc 1 ⌊x / (K : ℝ)⌋₊, (μ n : ℝ) / (n : ℝ) - ∑ n ∈ Finset.Icc 1 ⌊x / (K : ℝ)⌋₊, (μ n : ℝ) * (x / (n : ℝ) - ⌊x / (n : ℝ)⌋) := by ++ rw [Finset.mul_sum _ _ _] ; rw [← Finset.sum_sub_distrib] ; exact Finset.sum_congr rfl fun _ _ => by ring ++ have h_bound : |∑ n ∈ Finset.Icc 1 ⌊x / (K : ℝ)⌋₊, (μ n : ℝ) * (x / (n : ℝ) - ⌊x / (n : ℝ)⌋)| ≤ ⌊x / (K : ℝ)⌋₊ := by ++ have h_bound : ∀ n ∈ Finset.Icc 1 ⌊x / (K : ℝ)⌋₊, |(μ n : ℝ) * (x / (n : ℝ) - ⌊x / (n : ℝ)⌋)| ≤ 1 := by ++ norm_num [abs_mul] ++ exact fun n hn₁ hn₂ => ++ (mul_le_of_le_one_left (abs_nonneg _) ++ (mod_cast by exact abs_moebius_le_one)).trans ++ (abs_le.mpr ⟨by linarith [Int.fract_nonneg (x / n)], ++ by linarith [Int.fract_lt_one (x / n)]⟩) ++ exact le_trans (Finset.abs_sum_le_sum_abs _ _) (le_trans (Finset.sum_le_sum h_bound) (by norm_num)) ++ have h_sum_floor : ∑ n ∈ Finset.Icc 1 ⌊x⌋₊, (μ n : ℝ) * ⌊x / (n : ℝ)⌋ = 1 := by ++ convert sum_mobius_floor x hx using 1 ++ cases abs_cases (x * ∑ n ∈ Finset.Icc 1 ⌊x / (K : ℝ) ⌋₊, (μ n : ℝ) / n - 1) <;> cases abs_cases (∑ n ∈ Finset.Ioc ⌊x / (K : ℝ) ⌋₊ ⌊x⌋₊, (μ n : ℝ) * ⌊x / (n : ℝ) ⌋) <;> linarith [abs_le.mp h_bound, Nat.floor_le (show 0 ≤ x / (K : ℝ) by positivity), Nat.lt_floor_add_one (x / (K : ℝ))] ++ ++theorem mu_pnt_alt : (fun x : ℝ ↦ ∑ n ∈ range ⌊x⌋₊, (μ n : ℝ) / n) =o[atTop] fun _ ↦ (1 : ℝ) := by ++ rw [Asymptotics.isLittleO_iff_tendsto'] <;> norm_num ++ have h_sum_zero : Filter.Tendsto (fun x : ℝ => ∑ n ∈ Finset.Icc 1 ⌊x⌋₊, (μ n : ℝ) / n) Filter.atTop (nhds 0) := by ++ set S : ℝ → ℝ := fun y => ∑ n ∈ Finset.Icc 1 ⌊y⌋₊, (μ n : ℝ) / n ++ have h_bound : ∀ K : ℕ, 0 < K → ∀ x : ℝ, 1 ≤ x → |S (x / K)| ≤ 1 / K + 1 / x + |∑ n ∈ Finset.Ioc ⌊x / K⌋₊ ⌊x⌋₊, (μ n : ℝ) * (⌊x / (n : ℝ)⌋ : ℝ)| / x := by ++ intros K hK x hx ++ have h_approx : |x * S (x / K) - 1| ≤ x / K + |∑ n ∈ Finset.Ioc ⌊x / K⌋₊ ⌊x⌋₊, (μ n : ℝ) * (⌊x / (n : ℝ)⌋ : ℝ)| := by ++ convert sum_mobius_div_approx x K hK hx using 1 ++ rw [abs_le] at * ++ ring_nf at * ++ constructor <;> nlinarith [inv_pos.2 (by positivity : 0 < x), mul_inv_cancel₀ (by positivity : x ≠ 0), abs_nonneg (∑ n ∈ Finset.Ioc ⌊ (K : ℝ) ⁻¹ * x⌋₊ ⌊x⌋₊, (μ n : ℝ) * ⌊x * (n : ℝ) ⁻¹⌋)] ++ have h_tail_zero : ∀ K : ℕ, 0 < K → Filter.Tendsto (fun x : ℝ => |∑ n ∈ Finset.Ioc ⌊x / K⌋₊ ⌊x⌋₊, (μ n : ℝ) * (⌊x / (n : ℝ)⌋ : ℝ)| / x) Filter.atTop (nhds 0) := by ++ intro K hK ++ have h_tail_zero : Filter.Tendsto (fun x : ℝ => |∑ n ∈ Finset.Ioc ⌊x / K⌋₊ ⌊x⌋₊, (μ n : ℝ) * (⌊x / (n : ℝ)⌋ : ℝ)| / x) Filter.atTop (nhds 0) := by ++ have := sum_mobius_floor_tail_isLittleO K hK ++ rw [Asymptotics.isLittleO_iff_tendsto'] at this ++ · simpa [abs_div] using this.abs.congr' (by filter_upwards [Filter.eventually_gt_atTop 0] with x hx using by rw [abs_div, abs_of_nonneg hx.le]) ++ · filter_upwards [Filter.eventually_gt_atTop 0] with x hx hx' using absurd hx' hx.ne' ++ convert h_tail_zero using 1 ++ have h_eps : ∀ ϵ > 0, ∃ Y : ℝ, ∀ y ≥ Y, |S y| < ϵ := by ++ intros ϵ hϵ_pos ++ obtain ⟨K, hK_pos, hK⟩ : ∃ K : ℕ, 0 < K ∧ 1 / (K : ℝ) < ϵ / 3 := by ++ exact ⟨⌊ϵ⁻¹ * 3⌋₊ + 1, Nat.succ_pos _, by rw [div_lt_iff₀] <;> push_cast <;> nlinarith [Nat.lt_floor_add_one (ϵ⁻¹ * 3), mul_inv_cancel₀ hϵ_pos.ne']⟩ ++ obtain ⟨Y, hY⟩ : ∃ Y : ℝ, ∀ x ≥ Y, |S (x / K)| < ϵ := by ++ have h_tail_zero : Filter.Tendsto (fun x : ℝ => 1 / (K : ℝ) + 1 / x + |∑ n ∈ Finset.Ioc ⌊x / K⌋₊ ⌊x⌋₊, (μ n : ℝ) * (⌊x / (n : ℝ)⌋ : ℝ)| / x) Filter.atTop (nhds (1 / (K : ℝ))) := by ++ simpa using Filter.Tendsto.add (tendsto_const_nhds.add (tendsto_inv_atTop_zero)) (h_tail_zero K hK_pos) ++ exact Filter.eventually_atTop.mp (h_tail_zero.eventually (gt_mem_nhds <| by linarith)) |> fun ⟨Y, hY⟩ ↦ ⟨Max.max Y 1, fun x hx ↦ lt_of_le_of_lt (h_bound K hK_pos x <| le_trans (le_max_right _ _) hx) <| hY x <| le_trans (le_max_left _ _) hx⟩ ++ use Y / K; intros y hy; specialize hY (y * K) (by nlinarith [show (K : ℝ) ≥ 1 by norm_cast, div_mul_cancel₀ Y (by positivity : (K : ℝ) ≠ 0)]) ; simp_all +decide [ne_of_gt] ++ exact Metric.tendsto_atTop.mpr fun ε hε => by simpa using h_eps ε hε ++ have h_sum_zero : Filter.Tendsto (fun x : ℝ => ∑ n ∈ Finset.range (⌊x⌋₊ + 1), (μ n : ℝ) / n) Filter.atTop (nhds 0) := by ++ convert h_sum_zero using 2 ; erw [Finset.sum_Ico_eq_sub _ _] <;> norm_num [Finset.sum_range_succ'] ++ simpa [Finset.sum_range_succ] using h_sum_zero.sub (show Filter.Tendsto (fun x : ℝ => (μ ⌊x⌋₊ : ℝ) / ⌊x⌋₊) Filter.atTop (nhds 0) from tendsto_zero_iff_norm_tendsto_zero.mpr <| squeeze_zero (fun _ => by positivity) (fun x => by simpa using div_le_div_of_nonneg_right (show |(μ ⌊x⌋₊ : ℝ)| ≤ 1 from mod_cast by { unfold ArithmeticFunction.moebius; aesop }) <| Nat.cast_nonneg _) <| tendsto_inv_atTop_zero.comp <| tendsto_natCast_atTop_atTop.comp <| tendsto_nat_floor_atTop) ++ ++theorem chebyshev_asymptotic_pnt ++ {q : ℕ} {a : ℕ} (hq : q ≥ 1) (ha : a.Coprime q) (ha' : a < q) : ++ (fun x ↦ ∑ p ∈ filter Nat.Prime (Iic ⌊x⌋₊), if p % q = a then log p else 0) ~[atTop] ++ fun x ↦ x / q.totient := by ++ let ψ_aq : ℝ → ℝ := fun x ↦ ∑ n ∈ Icc 1 ⌊x⌋₊, if n % q = a then Λ n else 0 ++ have htot_pos : (0 : ℝ) < q.totient := cast_pos.mpr (totient_pos.mpr hq) ++ have hψ_equiv : ψ_aq ~[atTop] fun x ↦ x / q.totient := by ++ have hW := WeakPNT_AP hq ha ha' ++ simp only [cumsum, ← Iio_eq_range] at hW ++ have hψ_eq x : ψ_aq x = ∑ n ∈ Iio (⌊x⌋₊ + 1), if n % q = a then Λ n else 0 := by ++ simp only [ψ_aq, show Icc 1 ⌊x⌋₊ = (Iio (⌊x⌋₊ + 1)).filter (1 ≤ ·) by ++ ext n; simp [mem_Icc, mem_filter]; tauto, sum_filter] ++ refine sum_congr rfl fun n _ ↦ ?_ ++ by_cases hn : 1 ≤ n <;> simp only [hn, ↓reduceIte] ++ push Not at hn; interval_cases n; simp ++ refine (isEquivalent_iff_tendsto_one ?_).mpr ?_ ++ · filter_upwards [eventually_ge_atTop 1] with x hx; exact div_ne_zero (by linarith) htot_pos.ne' ++ have hlim1 : Tendsto (fun x : ℝ ↦ (∑ n ∈ Iio (⌊x⌋₊ + 1), if n % q = a then Λ n else 0) / ++ (⌊x⌋₊ + 1 : ℝ)) atTop (nhds (1 / q.totient)) := by ++ have heq : (fun x : ℝ ↦ (∑ n ∈ Iio (⌊x⌋₊ + 1), if n % q = a then Λ n else 0) / ++ (⌊x⌋₊ + 1 : ℝ)) = (fun N ↦ (∑ n ∈ Iio N, if n % q = a then Λ n else 0) / N) ∘ ++ (fun x : ℝ ↦ ⌊x⌋₊ + 1) := by ext x; simp [Function.comp_apply] ++ exact heq ▸ hW.comp ((tendsto_add_atTop_nat 1).comp tendsto_nat_floor_atTop) ++ have hgoal_eq : (ψ_aq / fun x ↦ x / (q.totient : ℝ)) = ++ fun x ↦ ψ_aq x / x * q.totient := by ext x; simp only [Pi.div_apply, div_div_eq_mul_div]; ring ++ rw [hgoal_eq, show (1 : ℝ) = 1 / q.totient * 1 * q.totient by field_simp] ++ refine Tendsto.mul ?_ tendsto_const_nhds ++ have heq' : (fun x ↦ ψ_aq x / x) =ᶠ[atTop] ++ fun x ↦ (∑ n ∈ Iio (⌊x⌋₊ + 1), if n % q = a then Λ n else 0) / (⌊x⌋₊ + 1 : ℝ) * ((⌊x⌋₊ + 1 : ℝ) / x) := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ simp only [hψ_eq]; field_simp ++ exact Tendsto.congr' heq'.symm (hlim1.mul tendsto_floor_add_one_div_self) ++ refine Asymptotics.IsEquivalent.add_isLittleO'' hψ_equiv ++ (IsBigO.trans_isLittleO (g := fun x ↦ 2 * x.sqrt * x.log) ?_ ?_) ++ · rw [isBigO_iff']; refine ⟨1, one_pos, eventually_atTop.mpr ⟨2, fun x hx ↦ ?_⟩⟩ ++ simp only [Pi.sub_apply, norm_eq_abs, one_mul] ++ have hdiff_nonneg : 0 ≤ ψ_aq x - ∑ p ∈ filter Nat.Prime (Iic ⌊x⌋₊), if p % q = a then log p else 0 := by ++ simp only [ψ_aq, sub_nonneg] ++ calc (∑ p ∈ filter Nat.Prime (Iic ⌊x⌋₊), if p % q = a then log p else (0 : ℝ)) ++ ≤ ∑ p ∈ filter Nat.Prime (Iic ⌊x⌋₊), if p % q = a then Λ p else (0 : ℝ) := ++ sum_le_sum fun p hp ↦ by split_ifs <;> simp [vonMangoldt_apply_prime (mem_filter.mp hp).2] ++ _ ≤ ∑ n ∈ Icc 1 ⌊x⌋₊, if n % q = a then Λ n else (0 : ℝ) := ++ sum_le_sum_of_subset_of_nonneg ++ (fun p hp ↦ by simp only [mem_filter, mem_Iic, mem_Icc] at hp ⊢; exact ⟨hp.2.one_lt.le, hp.1⟩) ++ (fun n _ _ ↦ by split_ifs <;> [exact vonMangoldt_nonneg; rfl]) ++ have hdiff_le : ψ_aq x - (∑ p ∈ filter Nat.Prime (Iic ⌊x⌋₊), if p % q = a then log p else (0 : ℝ)) ≤ ψ x - θ x := by ++ simp only [ψ_aq, Chebyshev.psi_eq_sum_Icc, Chebyshev.theta_eq_sum_Icc] ++ conv_rhs => rw [Icc_zero_eq_insert, sum_insert (by simp : (0 : ℕ) ∉ Icc 1 ⌊x⌋₊), ++ show Λ 0 = 0 by simp only [ArithmeticFunction.map_zero], zero_add, ++ show filter Nat.Prime (insert 0 (Icc 1 ⌊x⌋₊)) = filter Nat.Prime (Icc 1 ⌊x⌋₊) by ++ simp [filter_insert, Nat.not_prime_zero]] ++ rw [filter_prime_Iic_eq_Icc, ← sum_filter_add_sum_filter_not (Icc 1 ⌊x⌋₊) Nat.Prime, ++ show (∑ p ∈ filter Nat.Prime (Icc 1 ⌊x⌋₊), if p % q = a then log p else (0 : ℝ)) = ++ ∑ p ∈ filter Nat.Prime (Icc 1 ⌊x⌋₊), if p % q = a then Λ p else (0 : ℝ) from ++ sum_congr rfl fun p hp ↦ by simp only [mem_filter] at hp; split_ifs <;> simp [vonMangoldt_apply_prime hp.2], ++ ← sum_filter_add_sum_filter_not (Icc 1 ⌊x⌋₊) Nat.Prime, ++ show (∑ p ∈ filter Nat.Prime (Icc 1 ⌊x⌋₊), Λ p) = ∑ p ∈ filter Nat.Prime (Icc 1 ⌊x⌋₊), log p from ++ sum_congr rfl fun p hp ↦ vonMangoldt_apply_prime (mem_filter.mp hp).2] ++ have h1 : (∑ n ∈ (Icc 1 ⌊x⌋₊).filter (¬Nat.Prime ·), if n % q = a then Λ n else (0 : ℝ)) ≤ ++ ∑ n ∈ (Icc 1 ⌊x⌋₊).filter (¬Nat.Prime ·), Λ n := ++ sum_le_sum fun n _ ↦ by split_ifs <;> [exact le_refl _; exact vonMangoldt_nonneg] ++ linarith ++ rw [abs_of_nonneg hdiff_nonneg, abs_of_nonneg (by bound)] ++ exact hdiff_le.trans ((le_abs_self _).trans (Chebyshev.abs_psi_sub_theta_le_sqrt_mul_log (by linarith))) ++ · simpa only [mul_assoc] using ++ (isLittleO_sqrt_mul_log.const_mul_left 2).trans_isTheta (isTheta_self_div_const htot_pos.ne') ++ ++theorem dirichlet_thm {q : ℕ} {a : ℕ} (hq : q ≥ 1) (ha : Nat.Coprime a q) (ha' : a < q) : ++ Infinite { p // p.Prime ∧ p % q = a } := by ++ have : {p | p.Prime ∧ p % q = a}.Infinite := by ++ have : {p | p.Prime ∧ p ≡ a [MOD q]}.Infinite := by ++ have := @infinite_setOfPred_prime_and_eq_mod ++ specialize @this q <| NeZero.of_pos hq ++ simp_all only [isUnit_iff_exists_inv, forall_exists_index, ← ZMod.natCast_eq_natCast_iff] ++ exact this (IsUnit.exists_right_inv (show IsUnit (a : ZMod q) from by ++ rwa [ZMod.isUnit_iff_coprime])).choose (IsUnit.exists_right_inv (show IsUnit (a : ZMod q) ++ from by rwa [ZMod.isUnit_iff_coprime])).choose_spec ++ exact this.mono fun p hp ↦ ⟨hp.1, by simpa [ModEq, mod_eq_of_lt ha'] using hp.2⟩ ++ exact Set.infinite_coe_iff.mpr this ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Defs.lean b/PrimeNumberTheoremAnd/Erdos970/Defs.lean +new file mode 100644 +index 0000000..e595955 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Defs.lean +@@ -0,0 +1,201 @@ ++import PrimeNumberTheoremAnd.Erdos970.Fourier ++import Mathlib.NumberTheory.Chebyshev ++ ++namespace Erdos970 ++ ++open ArithmeticFunction hiding log ++open Nat hiding log ++open Finset Topology ++open BigOperators Filter Real Classical Asymptotics ++open MeasureTheory intervalIntegral ++open scoped ArithmeticFunction.Moebius ++open scoped ArithmeticFunction.Omega Chebyshev ++ ++noncomputable abbrev nth_prime (n : ℕ) : ℕ := ++ Nat.nth Nat.Prime n ++ ++noncomputable abbrev nth_prime' (n : ℕ) : ℕ := ++ Nat.nth Nat.Prime (n - 1) ++ ++noncomputable abbrev Psi (x : ℝ) : ℝ := ψ x ++ ++noncomputable def M (x : ℝ) : ℝ := ++ ∑ n ∈ Iic ⌊x⌋₊, (μ n : ℝ) ++ ++noncomputable abbrev nth_prime_gap (n : ℕ) : ℕ := ++ nth_prime (n + 1) - nth_prime n ++ ++def prime_gap_record (p g : ℕ) : Prop := ++ ∃ n, nth_prime n = p ∧ nth_prime_gap n = g ∧ ++ ∀ k, nth_prime k < p → nth_prime_gap k < g ++ ++open Classical in ++ ++noncomputable def first_gap (g : ℕ) : ℕ := ++ if h : ∃ n, nth_prime_gap n = g then ++ nth_prime (Nat.find h) ++ else 0 ++ ++def first_gap_record (g P : ℕ) : Prop := ++ first_gap g = P ∧ ++ ∀ g' ∈ Finset.Ico 1 g, ++ Even g' ∨ g' = 1 → first_gap g' ∈ Set.Ico 1 P ++ ++def HasPrimeInInterval (x h : ℝ) : Prop := ++ ∃ p : ℕ, Nat.Prime p ∧ x < p ∧ p ≤ x + h ++ ++def HasPrimeInInterval.log_thm (X₀ : ℝ) (k : ℝ) := ++ ∀ x ≥ X₀, HasPrimeInInterval x (x / (log x) ^ k) ++ ++noncomputable def pi (x : ℝ) : ℝ := ++ Nat.primeCounting ⌊x⌋₊ ++ ++noncomputable def pi_star (x : ℝ) : ℝ := ++ ∑' (k : ℕ), pi (x ^ (1 / (k + 1 : ℝ))) / (k + 1 : ℝ) ++ ++noncomputable def li (x : ℝ) : ℝ := ++ lim ((𝓝[>] (0 : ℝ)).map (fun ε ↦ ++ ∫ t in Set.diff (Set.Ioc 0 x) (Set.Ioo (1 - ε) (1 + ε)), ++ 1 / log t)) ++ ++noncomputable def Li (x : ℝ) : ℝ := ∫ t in 2..x, 1 / log t ++ ++noncomputable def Eψ (x : ℝ) : ℝ := |ψ x - x| / x ++ ++noncomputable def admissible_bound (A B C R : ℝ) (x : ℝ) := ++ A * (log x / R) ^ B * exp (-C * (log x / R) ^ ((1 : ℝ) / (2 : ℝ))) ++ ++def Eψ.classicalBound (A B C R x₀ : ℝ) : Prop := ++ ∀ x ≥ x₀, Eψ x ≤ admissible_bound A B C R x ++ ++def Eψ.bound (ε x₀ : ℝ) : Prop := ∀ x ≥ x₀, Eψ x ≤ ε ++ ++def Eψ.numericalBound (x₀ : ℝ) (ε : ℝ → ℝ) : Prop := ++ Eψ.bound (ε x₀) x₀ ++ ++noncomputable def Eπ (x : ℝ) : ℝ := ++ |pi x - Li x| / (x / log x) ++ ++noncomputable def Eπ_star (x : ℝ) : ℝ := ++ |pi_star x - Li x| / (x / log x) ++ ++noncomputable def Eθ (x : ℝ) : ℝ := |θ x - x| / x ++ ++def Eθ.classicalBound (A B C R x₀ : ℝ) : Prop := ++ ∀ x ≥ x₀, Eθ x ≤ admissible_bound A B C R x ++ ++def Eθ.numericalBound (x₀ : ℝ) (ε : ℝ → ℝ) : Prop := ++ ∀ x ≥ x₀, Eθ x ≤ ε x₀ ++ ++def Eπ.classicalBound (A B C R x₀ : ℝ) : Prop := ++ ∀ x ≥ x₀, Eπ x ≤ admissible_bound A B C R x ++ ++def Eπ.bound (ε x₀ : ℝ) : Prop := ∀ x ≥ x₀, Eπ x ≤ ε ++ ++def Eπ.numericalBound (x₀ : ℝ) (ε : ℝ → ℝ) : Prop := ++ Eπ.bound (ε x₀) x₀ ++ ++def Eπ.vinogradovBound (A B C x₀ : ℝ) : Prop := ++ ∀ x ≥ x₀, Eπ x ≤ ++ A * (log x) ^ B * exp (-C * (log x) ^ ((3 : ℝ) / 5) / (log (log x)) ^ ((1 : ℝ) / 5)) ++ ++def Eπ_star.classicalBound (A B C R x₀ : ℝ) : Prop := ++ ∀ x ≥ x₀, Eπ_star x ≤ admissible_bound A B C R x ++ ++def Eπ_star.bound (ε x₀ : ℝ) : Prop := ++ ∀ x ≥ x₀, Eπ_star x ≤ ε ++ ++def Eπ_star.numericalBound (x₀ : ℝ) (ε : ℝ → ℝ) : Prop := ++ Eπ_star.bound (ε x₀) x₀ ++ ++def Eπ_star.vinogradovBound (A B C x₀ : ℝ) : Prop := ++ ∀ x ≥ x₀, Eπ_star x ≤ ++ A * (log x) ^ B * exp (-C * (log x) ^ ((3 : ℝ) / 5) / (log (log x)) ^ ((1 : ℝ) / 5)) ++ ++lemma admissible_bound.mono ++ (A B C R : ℝ) (hA : 0 < A) (hB : 0 < B) ++ (hC : 0 < C) (hR : 0 < R) : ++ AntitoneOn (admissible_bound A B C R) ++ (Set.Ici (exp (R * (2 * B / C) ^ 2))) := by ++ intro a ha b _ hab ++ simp only [admissible_bound, mul_assoc] ++ have hua : (2 * B / C) ^ 2 ≤ log a / R := by ++ rw [le_div_iff₀ hR, mul_comm ((2 * B / C) ^ 2), ← log_exp (R * (2 * B / C) ^ 2)] ++ exact log_le_log (exp_pos _) (Set.mem_Ici.mp ha) ++ have huab : log a / R ≤ log b / R := ++ div_le_div_of_nonneg_right ++ (log_le_log ((exp_pos _).trans_le (Set.mem_Ici.mp ha)) hab) hR.le ++ have hua₀ : 0 < log a / R := ++ lt_of_lt_of_le (by positivity) hua ++ apply mul_le_mul_of_nonneg_left _ hA.le ++ rw [rpow_def_of_pos (hua₀.trans_le huab), rpow_def_of_pos hua₀, ++ ← exp_add, ← exp_add, exp_le_exp] ++ let sa := (log a / R) ^ ((1 : ℝ) / 2) ++ let sb := (log b / R) ^ ((1 : ℝ) / 2) ++ rw [show log (log b / R) = 2 * log sb from by ++ grind [log_rpow (hua₀.trans_le huab) ((1 : ℝ) / 2)], ++ show log (log a / R) = 2 * log sa from by ++ grind [log_rpow hua₀ ((1 : ℝ) / 2)]] ++ have hsab : sa ≤ sb := ++ rpow_le_rpow (le_trans (by positivity) hua) huab (by positivity) ++ have : 2 * B / C ≤ sa := by ++ rw [show (2 * B / C : ℝ) = ((2 * B / C) ^ 2) ^ ((1 : ℝ) / 2) from by ++ rw [← rpow_natCast _ 2, ← rpow_mul (by positivity)] ++ norm_num [rpow_one]] ++ exact rpow_le_rpow (by positivity) hua (by positivity) ++ suffices h : AntitoneOn (fun t ↦ 2 * B * log t - C * t) (Set.Ici (2 * B / C)) by ++ grind [h (Set.mem_Ici.mpr this) (Set.mem_Ici.mpr (this.trans hsab)) hsab] ++ apply antitoneOn_of_deriv_nonpos (convex_Ici _) ++ · exact ((continuousOn_const.mul (continuousOn_log.mono fun t ht ↦ ++ ne_of_gt ((div_pos (by positivity) hC).trans_le ht))).sub ++ (continuousOn_const.mul continuousOn_id)) ++ · intro t ht ++ rw [interior_Ici] at ht ++ exact (((hasDerivAt_log ((div_pos (by positivity) hC).trans ht).ne').const_mul _).sub ++ ((hasDerivAt_id t).const_mul C)).differentiableAt.differentiableWithinAt ++ · intro t ht ++ rw [interior_Ici] at ht ++ have hdt : HasDerivAt (fun t ↦ 2 * B * log t - C * t) (2 * B * t⁻¹ - C * 1) t := ++ ((hasDerivAt_log ((div_pos (by positivity) hC).trans ht).ne').const_mul _).sub ++ ((hasDerivAt_id t).const_mul C) ++ rw [hdt.deriv, mul_one, sub_nonpos, ← div_eq_mul_inv, ++ div_le_iff₀ ((div_pos (by positivity) hC).trans ht)] ++ linarith [(div_lt_iff₀ hC).mp ht, mul_comm C t] ++ ++lemma Eψ.classicalBound.to_numericalBound ++ (A B C R x₀ x₁ : ℝ) (hA : 0 < A) (hB : 0 < B) ++ (hC : 0 < C) (hR : 0 < R) ++ (hEψ : Eψ.classicalBound A B C R x₀) ++ (hx₁ : x₁ ≥ max x₀ (Real.exp (R * (2 * B / C) ^ 2))) : ++ Eψ.numericalBound x₁ (fun x ↦ admissible_bound A B C R x) := ++ fun x hx ↦ ++ le_trans (hEψ x (le_trans (le_max_left ..) (le_trans hx₁ hx))) ++ (admissible_bound.mono A B C R hA hB hC hR ++ (Set.mem_Ici.mpr (le_trans (le_max_right ..) hx₁)) ++ (Set.mem_Ici.mpr (le_trans (le_max_right ..) (le_trans hx₁ hx))) hx) ++ ++lemma Eθ.classicalBound.to_numericalBound ++ (A B C R x₀ x₁ : ℝ) (hA : 0 < A) (hB : 0 < B) ++ (hC : 0 < C) (hR : 0 < R) ++ (hEθ : Eθ.classicalBound A B C R x₀) ++ (hx₁ : x₁ ≥ max x₀ (Real.exp (R * (2 * B / C) ^ 2))) : ++ Eθ.numericalBound x₁ (fun x ↦ admissible_bound A B C R x) := ++ fun x hx ↦ ++ le_trans (hEθ x (le_trans (le_max_left ..) (le_trans hx₁ hx))) ++ (admissible_bound.mono A B C R hA hB hC hR ++ (Set.mem_Ici.mpr (le_trans (le_max_right ..) hx₁)) ++ (Set.mem_Ici.mpr (le_trans (le_max_right ..) (le_trans hx₁ hx))) hx) ++ ++lemma Eπ.classicalBound.to_numericalBound ++ (A B C R x₀ x₁ : ℝ) (hA : 0 < A) (hB : 0 < B) ++ (hC : 0 < C) (hR : 0 < R) ++ (hEπ : Eπ.classicalBound A B C R x₀) ++ (hx₁ : x₁ ≥ max x₀ (Real.exp (R * (2 * B / C) ^ 2))) : ++ Eπ.numericalBound x₁ (fun x ↦ admissible_bound A B C R x) := ++ fun x hx ↦ ++ le_trans (hEπ x (le_trans (le_max_left ..) (le_trans hx₁ hx))) ++ (admissible_bound.mono A B C R hA hB hC hR ++ (Set.mem_Ici.mpr (le_trans (le_max_right ..) hx₁)) ++ (Set.mem_Ici.mpr (le_trans (le_max_right ..) (le_trans hx₁ hx))) hx) ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/EulerMaclaurin.lean b/PrimeNumberTheoremAnd/Erdos970/EulerMaclaurin.lean +new file mode 100644 +index 0000000..ecfb419 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/EulerMaclaurin.lean +@@ -0,0 +1,75 @@ ++import Mathlib.NumberTheory.AbelSummation ++ ++namespace Erdos970 ++ ++open Finset Interval MeasureTheory ++ ++variable {𝕜 : Type*} [RCLike 𝕜] {f : ℝ → 𝕜} {a b : ℝ} ++ ++noncomputable def B1 (x : ℝ) : ℝ := x - ⌊x⌋₊ - 1 / 2 ++ ++@[fun_prop] ++lemma aestronglyMeasurable_B1 : AEStronglyMeasurable B1 := by ++ unfold B1 ++ fun_prop ++ ++lemma abs_B1_le_half {x : ℝ} (hx : 0 ≤ x) : |B1 x| ≤ 1 / 2 := by ++ unfold B1 ++ refine abs_le.mpr ⟨?_, ?_⟩ ++ · grind [Nat.floor_le hx] ++ · grind [Nat.lt_succ_floor x] ++ ++lemma integral_deriv_mul_add_const (c : 𝕜) (hab : a ≤ b) (h_int : IntervalIntegrable (deriv f) volume a b) ++ (hf_diff : ∀ t ∈ Set.Icc a b, DifferentiableAt ℝ f t) : ++ ∫ t in a..b, (t + c) * deriv f t = (b + c) * f b - (a + c) * f a - ∫ t in a..b, f t := by ++ rw [← Set.uIcc_of_le hab] at hf_diff ++ have : ∀ t ∈ [[a, b]], HasDerivAt (fun (t : ℝ) ↦ t + c) 1 t := by ++ intro t ht ++ simp only [hasDerivAt_add_const_iff] ++ convert! ContinuousLinearMap.hasDerivAt (RCLike.ofRealCLM (K := 𝕜)) using 1 ++ simp ++ replace hf_diff := fun t ht ↦ (hf_diff t ht).hasDerivAt ++ rw [intervalIntegral.integral_mul_deriv_eq_deriv_mul this hf_diff (by simp) h_int] ++ simp ++ ++lemma intervalIntegrable_deriv_mul_B1 (ha : 0 ≤ a) (hab : a ≤ b) (h_cont : ContinuousOn (deriv f) [[a, b]]) : ++ IntervalIntegrable (fun t ↦ deriv f t * B1 t) volume a b := by ++ refine IntervalIntegrable.continuousOn_mul ?_ h_cont ++ rw [intervalIntegrable_iff'] ++ apply MeasureTheory.Measure.integrableOn_of_bounded (by simp) (by fun_prop) (M := 1 / 2) ++ filter_upwards [self_mem_ae_restrict (by measurability)] with x hx ++ rw [Set.uIcc_of_le hab, Set.mem_Icc] at hx ++ norm_cast ++ exact abs_B1_le_half (by linarith) ++ ++lemma integral_deriv_mul_floor_add_one (ha : 0 ≤ a) (hab : a ≤ b) ++ (hf_diff : ∀ t ∈ Set.Icc a b, DifferentiableAt ℝ f t) (h_cont : ContinuousOn (deriv f) [[a, b]]) : ++ ∫ t in a..b, deriv f t * (⌊t⌋₊ + 1) = (b + 1 / 2) * f b - (a + 1 / 2) * f a - (∫ t in a..b, f t) - ∫ t in a..b, deriv f t * B1 t := by ++ calc ++ _ = ∫ t in a..b, (deriv f t * (t + 1 / 2) -deriv f t * B1 t) := by ++ congr ++ ext ++ simp only [B1] ++ push_cast ++ ring ++ _ = (∫ t in a..b, deriv f t * (t + 1 / 2)) - ∫ t in a..b, deriv f t * B1 t := by ++ exact intervalIntegral.integral_sub (ContinuousOn.intervalIntegrable (by fun_prop)) (intervalIntegrable_deriv_mul_B1 ha hab h_cont) ++ _ = _ := by ++ conv => lhs; arg 1; arg 1; ext; rw [mul_comm] ++ rw [integral_deriv_mul_add_const _ hab h_cont.intervalIntegrable hf_diff] ++ ++theorem sum_eq_integral_add_integral_deriv (ha : 0 ≤ a) (hab : a ≤ b) ++ (hf_diff : ∀ t ∈ Set.Icc a b, DifferentiableAt ℝ f t) ++ (h_cont : ContinuousOn (deriv f) [[a, b]]) : ++ ∑ k ∈ Ioc ⌊a⌋₊ ⌊b⌋₊, f k = ++ f a * B1 a - f b * B1 b + (∫ t in a..b, f t) + ∫ t in a..b, deriv f t * B1 t := by ++ have := sum_mul_eq_sub_sub_integral_mul (fun _ ↦ 1) ha hab hf_diff (Set.uIcc_of_le hab ▸ h_cont).integrableOn_Icc ++ simp only [mul_one, sum_const, Nat.card_Icc, tsub_zero, nsmul_eq_mul, Nat.cast_add, ++ Nat.cast_one] at this ++ rw [this, ← intervalIntegral.integral_of_le hab] ++ rw [integral_deriv_mul_floor_add_one ha hab hf_diff h_cont] ++ unfold B1 ++ push_cast ++ ring ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Fourier.lean b/PrimeNumberTheoremAnd/Erdos970/Fourier.lean +new file mode 100644 +index 0000000..32fe27c +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Fourier.lean +@@ -0,0 +1,181 @@ ++import Mathlib.Analysis.Distribution.SchwartzSpace.Deriv ++import Mathlib.MeasureTheory.Integral.IntegralEqImproper ++import Mathlib.Topology.ContinuousMap.Bounded.Basic ++import Mathlib.Order.Filter.ZeroAndBoundedAtFilter ++import Mathlib.Analysis.Fourier.FourierTransformDeriv ++import PrimeNumberTheoremAnd.Erdos970.Sobolev ++ ++namespace Erdos970 ++ ++open FourierTransform Real Complex MeasureTheory Filter Topology BoundedContinuousFunction ++ SchwartzMap VectorFourier BigOperators ++ ++local instance {E : Type*} : Coe (E → ℝ) (E → ℂ) := ⟨fun f n => f n⟩ ++ ++section lemmas ++ ++@[simp] ++theorem nnnorm_eq_of_mem_circle (z : Circle) : ‖z.val‖₊ = 1 := NNReal.coe_eq_one.mp (by simp) ++ ++@[simp] ++theorem nnnorm_circle_smul (z : Circle) (s : ℂ) : ‖z • s‖₊ = ‖s‖₊ := by ++ simp [show z • s = z.val * s from rfl] ++ ++noncomputable def e (u : ℝ) : ℝ →ᵇ ℂ where ++ toFun v := 𝐞 (-v * u) ++ map_bounded' := ++ ⟨2, fun x y => (dist_le_norm_add_norm _ _).trans (by simp [one_add_one_eq_two])⟩ ++ ++@[simp] lemma e_apply (u : ℝ) (v : ℝ) : e u v = 𝐞 (-v * u) := rfl ++ ++theorem hasDerivAt_e {u x : ℝ} : HasDerivAt (e u) (-2 * π * u * I * e u x) x := by ++ have l2 : HasDerivAt (fun v => -v * u) (-u) x := by ++ simpa only [neg_mul_comm] using hasDerivAt_mul_const (-u) ++ convert! (hasDerivAt_fourierChar (-x * u)).scomp x l2 using 1 ++ change _ = ((-u : ℝ) : ℂ) * _ ++ simp ; ring ++ ++lemma fourierIntegral_deriv_aux2 (e : ℝ →ᵇ ℂ) {f : ℝ → ℂ} (hf : Integrable f) : ++ Integrable (⇑e * f) := ++ hf.bdd_mul e.continuous.aestronglyMeasurable (ae_of_all _ e.norm_coe_le_norm) ++ ++@[simp] lemma F_neg {f : ℝ → ℂ} {u : ℝ} : 𝓕 (fun x => -f x) u = - 𝓕 f u := by ++ simp [fourier_eq, integral_neg] ++ ++@[simp] lemma F_add {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : ++ 𝓕 (fun x => f x + g x) x = 𝓕 f x + 𝓕 g x := by ++ have : Continuous fun p : ℝ × ℝ ↦ ((innerₗ ℝ) p.1) p.2 := continuous_inner ++ have := fourierIntegral_add continuous_fourierChar this hf hg ++ exact congr_fun this x ++ ++@[simp] lemma F_sub {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : ++ 𝓕 (fun x => f x - g x) x = 𝓕 f x - 𝓕 g x := by ++ simpa [sub_eq_add_neg, Pi.neg_def] using F_add hf hg.neg x ++ ++@[simp] lemma F_mul {f : ℝ → ℂ} {c : ℂ} {u : ℝ} : ++ 𝓕 (fun x => c * f x) u = c * 𝓕 f u := by ++ exact congr_fun (VectorFourier.fourierIntegral_const_smul 𝐞 _ _ f c) u ++ ++end lemmas ++ ++theorem fourierIntegral_self_add_deriv_deriv (f : W21) (u : ℝ) : ++ (1 + u ^ 2) * 𝓕 (f : ℝ → ℂ) u = ++ 𝓕 (fun u : ℝ => (f u - (1 / (4 * π ^ 2)) * deriv^[2] f u : ℂ)) u := by ++ have l1 : Integrable (fun x => (((π : ℂ) ^ 2)⁻¹ * 4⁻¹) * deriv (deriv f) x) := by ++ apply Integrable.const_mul ; simpa [iteratedDeriv_succ] using f.integrable le_rfl ++ have l4 : Differentiable ℝ f := f.differentiable ++ have l5 : Differentiable ℝ (deriv f) := f.deriv.differentiable ++ simp [f.hf, l1, add_mul, Real.fourier_deriv f.hf' l5 f.hf'', Real.fourier_deriv f.hf l4 f.hf'] ++ field_simp [pi_ne_zero] ; ring_nf ; simp ++ ++@[simp] lemma deriv_ofReal : deriv ofReal = fun _ => 1 := by ++ ext x ; exact ((hasDerivAt_id x).ofReal_comp).deriv ++ ++lemma tendsto_intervalIntegral_zero_of_uniform_norm_bound ++ {f : ℝ → ℝ → ℂ} {lo hi : ℝ} {B : ℝ → ℝ} ++ (hB : Filter.Tendsto (fun T : ℝ => B T * |hi - lo|) Filter.atTop (nhds 0)) ++ (hf : ∀ᶠ T in Filter.atTop, ∀ x ∈ Set.uIoc lo hi, ‖f T x‖ ≤ B T) : ++ Filter.Tendsto (fun T : ℝ => ∫ x in lo..hi, f T x) Filter.atTop (nhds 0) := by ++ rw [tendsto_zero_iff_norm_tendsto_zero] ++ refine squeeze_zero' (Eventually.of_forall fun T => norm_nonneg _) ?_ hB ++ filter_upwards [hf] with T hT ++ exact intervalIntegral.norm_integral_le_of_norm_le_const (fun x hx => hT x hx) ++ ++lemma tendsto_const_mul_log_add_two_div_add_two_atTop (K : ℝ) : ++ Filter.Tendsto (fun T : ℝ => K * (Real.log (T + 2) / (T + 2))) ++ Filter.atTop (nhds 0) := by ++ have h0 : Filter.Tendsto (fun x : ℝ => Real.log x / x) Filter.atTop (nhds 0) := by ++ simpa using (Real.tendsto_pow_log_div_mul_add_atTop 1 0 1 (by norm_num : (1 : ℝ) ≠ 0)) ++ have hshift : Filter.Tendsto (fun T : ℝ => Real.log (T + 2) / (T + 2)) ++ Filter.atTop (nhds 0) := by ++ have := h0.comp (tendsto_atTop_add_const_right Filter.atTop 2 tendsto_id) ++ simpa [Function.comp_def] using this ++ simpa using hshift.const_mul K ++ ++lemma norm_fourier_le_integral_deriv_div ++ (g : ℝ → ℂ) (hg : Integrable g) (hdiff : Differentiable ℝ g) ++ (hg' : Integrable (deriv g)) {w : ℝ} (hw : w ≠ 0) : ++ ‖𝓕 g w‖ ≤ (∫ x, ‖deriv g x‖ ∂volume) / ((2 * Real.pi) * |w|) := by ++ have hmul : ++ 𝓕 (deriv g) w = (2 * Real.pi * Complex.I * (w : ℂ)) * 𝓕 g w := by ++ have h := congrFun (Real.fourier_deriv hg hdiff hg') w ++ simpa [smul_eq_mul, mul_assoc] using h ++ have h_fourier : ++ ‖𝓕 (deriv g) w‖ ≤ ∫ x, ‖deriv g x‖ ∂volume := by ++ exact VectorFourier.norm_fourierIntegral_le_integral_norm 𝐞 volume (innerₗ ℝ) ++ (deriv g) w ++ have hleft : ++ ((2 * Real.pi) * |w|) * ‖𝓕 g w‖ = ++ ‖(2 * Real.pi * Complex.I * (w : ℂ)) * 𝓕 g w‖ := by ++ have htwopi : ‖(2 * ↑Real.pi : ℂ)‖ = 2 * Real.pi := by ++ rw [norm_mul, Complex.norm_two, Complex.norm_of_nonneg Real.pi_pos.le] ++ have hwc : ‖(w : ℂ)‖ = |w| := by rw [norm_real, Real.norm_eq_abs] ++ rw [norm_mul, norm_mul, norm_mul, htwopi, norm_I, hwc] ++ ring ++ have hmain : ((2 * Real.pi) * |w|) * ‖𝓕 g w‖ ≤ ∫ x, ‖deriv g x‖ ∂volume := by ++ rw [hleft, ← hmul] ++ exact h_fourier ++ have hpos : 0 < (2 * Real.pi) * |w| := by ++ positivity ++ exact (le_div_iff₀ hpos).mpr (by simpa [mul_comm, mul_left_comm, mul_assoc] using hmain) ++ ++lemma norm_oscillatory_integral_le_integral_deriv_div ++ (g : ℝ → ℂ) (hg : Integrable g) (hdiff : Differentiable ℝ g) ++ (hg' : Integrable (deriv g)) {T : ℝ} (hT : 0 < T) : ++ ‖∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume‖ ≤ ++ (∫ x, ‖deriv g x‖ ∂volume) / T := by ++ have hw : -T / (2 * Real.pi) ≠ 0 := by ++ exact div_ne_zero (neg_ne_zero.mpr hT.ne') (mul_ne_zero two_ne_zero Real.pi_ne_zero) ++ have hfourier := norm_fourier_le_integral_deriv_div g hg hdiff hg' hw ++ have heq : ++ (∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume) = ++ 𝓕 g (-T / (2 * Real.pi)) := by ++ rw [Real.fourier_real_eq_integral_exp_smul] ++ apply integral_congr_ae ++ filter_upwards with y ++ rw [smul_eq_mul] ++ rw [mul_comm (g y)] ++ congr 1 ++ congr 1 ++ push_cast ++ field_simp [Real.pi_ne_zero] ++ rw [heq] ++ refine hfourier.trans_eq ?_ ++ congr 1 ++ have hden : (2 * Real.pi) * |-T / (2 * Real.pi)| = T := by ++ have htwopi_pos : 0 < 2 * Real.pi := by positivity ++ have hneg : -T / (2 * Real.pi) < 0 := div_neg_of_neg_of_pos (neg_neg_of_pos hT) htwopi_pos ++ rw [abs_of_neg hneg] ++ field_simp [Real.pi_ne_zero] ++ rw [hden] ++ ++lemma norm_oscillatory_integral_le_integral_deriv_div_abs ++ (g : ℝ → ℂ) (hg : Integrable g) (hdiff : Differentiable ℝ g) ++ (hg' : Integrable (deriv g)) {T : ℝ} (hT : T ≠ 0) : ++ ‖∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume‖ ≤ ++ (∫ x, ‖deriv g x‖ ∂volume) / |T| := by ++ have hw : -T / (2 * Real.pi) ≠ 0 := by ++ exact div_ne_zero (neg_ne_zero.mpr hT) (mul_ne_zero two_ne_zero Real.pi_ne_zero) ++ have hfourier := norm_fourier_le_integral_deriv_div g hg hdiff hg' hw ++ have heq : ++ (∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume) = ++ 𝓕 g (-T / (2 * Real.pi)) := by ++ rw [Real.fourier_real_eq_integral_exp_smul] ++ apply integral_congr_ae ++ filter_upwards with y ++ rw [smul_eq_mul] ++ rw [mul_comm (g y)] ++ congr 1 ++ congr 1 ++ push_cast ++ field_simp [Real.pi_ne_zero] ++ rw [heq] ++ refine hfourier.trans_eq ?_ ++ congr 1 ++ have hden : (2 * Real.pi) * |-T / (2 * Real.pi)| = |T| := by ++ have htwopi_pos : 0 < 2 * Real.pi := by positivity ++ rw [abs_div, abs_neg, abs_of_pos htwopi_pos] ++ field_simp [Real.pi_ne_zero] ++ rw [hden] ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/HadamardSupport.lean b/PrimeNumberTheoremAnd/Erdos970/HadamardSupport.lean +new file mode 100644 +index 0000000..8c19850 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/HadamardSupport.lean +@@ -0,0 +1,6805 @@ ++import Mathlib ++ ++namespace Erdos970 ++ ++section HadamardAssemblyScope ++ ++section HadamardSourceScope00 ++ ++open scoped BigOperators ++ ++namespace Real ++ ++open _root_.Real ++ ++lemma pow_div_one_sub_le_two_mul {r : ℝ} (hr : 0 ≤ r) (hrhalf : r ≤ 1 / 2) (m : ℕ) : ++ r ^ (m + 1) / (1 - r) ≤ 2 * r ^ (m + 1) := by ++ have hpow : 0 ≤ r ^ (m + 1) := pow_nonneg hr _ ++ have hhalf' : (1 / 2 : ℝ) ≤ 1 - r := by linarith ++ calc ++ r ^ (m + 1) / (1 - r) ≤ r ^ (m + 1) / (1 / 2 : ℝ) := by ++ exact div_le_div_of_nonneg_left hpow (by positivity) hhalf' ++ _ = 2 * r ^ (m + 1) := by ring ++ ++end Real ++ ++namespace Complex ++ ++open _root_.Complex ++ ++open scoped BigOperators in ++ ++lemma neg_log_one_sub_eq_tsum {z : ℂ} (hz : ‖z‖ < 1) : ++ -log (1 - z) = ∑' n : ℕ, z ^ (n + 1) / (n + 1) := by ++ have h := hasSum_taylorSeries_neg_log hz ++ rw [← h.tsum_eq, h.summable.tsum_eq_zero_add] ++ simp only [pow_zero, Nat.cast_zero, div_zero, zero_add, Nat.cast_add, Nat.cast_one] ++ ++noncomputable ++def partialLogSum (m : ℕ) (z : ℂ) : ℂ := ++ -logTaylor (m + 1) (-z) ++ ++@[simp] ++lemma partialLogSum_zero (z : ℂ) : partialLogSum 0 z = 0 := by ++ simp [partialLogSum, logTaylor_succ, logTaylor_zero] ++ ++@[simp] ++lemma partialLogSum_at_zero (m : ℕ) : partialLogSum m 0 = 0 := by ++ simp [partialLogSum, logTaylor_at_zero] ++ ++lemma logTaylor_succ_neg (n : ℕ) (z : ℂ) : ++ logTaylor (n + 1) (-z) = logTaylor n (-z) - z ^ n / n := by ++ rw [logTaylor_succ, Pi.add_apply] ++ have hsign : (-1 : ℂ) ^ (n + 1) * (-z) ^ n = -z ^ n := by ++ have hzpow : (-z) ^ n = (((-1 : ℂ) * z) ^ n) := by simp ++ rw [hzpow, mul_pow, ← mul_assoc, ← pow_add] ++ have hpow : (-1 : ℂ) ^ (n + 1 + n) = (-1 : ℂ) := by ++ rw [show n + 1 + n = 2 * n + 1 by omega, pow_add, pow_mul] ++ norm_num ++ rw [hpow] ++ ring ++ rw [show (-1 : ℂ) ^ (n + 1) * (-z) ^ n / n = -(z ^ n / n) by ++ rw [hsign] ++ ring] ++ abel ++ ++lemma logTaylor_neg_eq_neg_sum (m : ℕ) (z : ℂ) : ++ logTaylor (m + 1) (-z) = -∑ k ∈ Finset.range m, z ^ (k + 1) / (k + 1) := by ++ induction m with ++ | zero => ++ simp [logTaylor_succ, logTaylor_zero] ++ | succ m hm => ++ rw [logTaylor_succ_neg, hm, Finset.sum_range_succ] ++ have hcast : ((m + 1 : ℕ) : ℂ) = (1 + (m : ℂ)) := by ++ simp [Nat.cast_add, Nat.cast_one, add_comm] ++ rw [hcast] ++ ring_nf ++ ++lemma partialLogSum_eq_sum (m : ℕ) (z : ℂ) : ++ partialLogSum m z = ∑ k ∈ Finset.range m, z ^ (k + 1) / (k + 1) := by ++ simpa [partialLogSum] using congrArg Neg.neg (logTaylor_neg_eq_neg_sum m z) ++ ++lemma hasDerivAt_partialLogSum (m : ℕ) (z : ℂ) : ++ HasDerivAt (partialLogSum m) (∑ j ∈ Finset.range m, z ^ j) z := by ++ cases m with ++ | zero => ++ have hzero : partialLogSum 0 = fun _ : ℂ ↦ (0 : ℂ) := by ++ funext w ++ exact partialLogSum_zero w ++ simpa [hzero] using (hasDerivAt_const z (c := (0 : ℂ))) ++ | succ m => ++ have hsum : ++ (∑ j ∈ Finset.range (m + 1), z ^ j) = ++ ∑ j ∈ Finset.range (m + 1), (-1) ^ j * (-z) ^ j := by ++ refine Finset.sum_congr rfl ?_ ++ intro j hj ++ symm ++ calc ++ (-1 : ℂ) ^ j * (-z) ^ j = (-1 : ℂ) ^ j * (((-1 : ℂ) * z) ^ j) := by simp ++ _ = ((-1 : ℂ) ^ j * (-1 : ℂ) ^ j) * z ^ j := by rw [mul_pow]; ring ++ _ = z ^ j := by ++ rw [← pow_add, show j + j = 2 * j by omega, pow_mul] ++ norm_num ++ rw [hsum] ++ simpa [partialLogSum] using! ++ (((hasDerivAt_logTaylor (m + 1) (-z)).comp z (hasDerivAt_neg z)).neg) ++ ++lemma differentiable_partialLogSum (m : ℕ) : ++ Differentiable ℂ (fun z : ℂ => partialLogSum m z) := by ++ intro z ++ exact (hasDerivAt_partialLogSum m z).differentiableAt ++ ++noncomputable ++def logTail (m : ℕ) (z : ℂ) : ℂ := ++ ∑' k, z ^ (m + 1 + k) / (m + 1 + k) ++ ++lemma summable_logTail {z : ℂ} (hz : ‖z‖ < 1) (m : ℕ) : ++ Summable (fun k => z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)) := by ++ have h_geom : Summable (fun k : ℕ => ‖z‖ ^ k) := ++ summable_geometric_of_lt_one (norm_nonneg z) hz ++ refine Summable.of_norm_bounded (g := fun k => ‖z‖ ^ k) h_geom ?_ ++ intro k ++ rw [norm_div, norm_pow] ++ have h1 : (1 : ℝ) ≤ (m + 1 + k : ℝ) := by ++ have : (0 : ℝ) ≤ (m + k : ℝ) := by positivity ++ nlinarith ++ have hnorm : ‖(↑m + 1 + ↑k : ℂ)‖ = (m + 1 + k : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (m + 1 + k)) ++ rw [hnorm] ++ calc ++ ‖z‖ ^ (m + 1 + k) / (m + 1 + k : ℝ) ≤ ‖z‖ ^ (m + 1 + k) := by ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) h1 ++ _ = ‖z‖ ^ (m + 1) * ‖z‖ ^ k := by rw [pow_add] ++ _ ≤ 1 * ‖z‖ ^ k := by ++ refine mul_le_mul_of_nonneg_right ?_ (pow_nonneg (norm_nonneg z) k) ++ exact pow_le_one₀ (norm_nonneg z) (le_of_lt hz) ++ _ = ‖z‖ ^ k := one_mul _ ++ ++lemma norm_logTail_le {z : ℂ} (hz : ‖z‖ < 1) (m : ℕ) : ++ ‖logTail m z‖ ≤ ‖z‖ ^ (m + 1) / (1 - ‖z‖) := by ++ dsimp only [logTail] ++ have h_rhs_summable : Summable (fun k => ‖z‖ ^ (m + 1 + k)) := by ++ simpa [pow_add] using ++ (summable_geometric_of_lt_one (norm_nonneg z) hz).mul_left (‖z‖ ^ (m + 1)) ++ have h_norm_summable : Summable (fun k => ‖z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)‖) := by ++ refine Summable.of_nonneg_of_le (fun _ => norm_nonneg _) ?_ h_rhs_summable ++ intro k ++ rw [norm_div, norm_pow] ++ have hnorm : ‖(↑m + 1 + ↑k : ℂ)‖ = (m + 1 + k : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (m + 1 + k)) ++ rw [hnorm] ++ have hm : 1 ≤ (m + 1 + k : ℝ) := by ++ have : (0 : ℝ) ≤ (m + k : ℝ) := by positivity ++ nlinarith ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) hm ++ calc ++ ‖∑' k, z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)‖ ++ ≤ ∑' k, ‖z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)‖ := ++ norm_tsum_le_tsum_norm h_norm_summable ++ _ ≤ ∑' k, ‖z‖ ^ (m + 1 + k) := by ++ refine h_norm_summable.tsum_le_tsum ?_ h_rhs_summable ++ intro k ++ rw [norm_div, norm_pow] ++ have hm : 1 ≤ (m + 1 + k : ℝ) := by ++ have : (0 : ℝ) ≤ (m + k : ℝ) := by positivity ++ nlinarith ++ have hnorm : ‖(↑m + 1 + ↑k : ℂ)‖ = (m + 1 + k : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (m + 1 + k)) ++ rw [hnorm] ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) hm ++ _ = ‖z‖ ^ (m + 1) / (1 - ‖z‖) := by ++ have h_eq : ++ (fun k => ‖z‖ ^ (m + 1 + k)) = fun k => ‖z‖ ^ (m + 1) * ‖z‖ ^ k := by ++ ext k ++ rw [pow_add] ++ rw [h_eq, tsum_mul_left] ++ have h_geom := hasSum_geometric_of_lt_one (norm_nonneg z) hz ++ rw [h_geom.tsum_eq, div_eq_mul_inv] ++ ++lemma norm_logTail_le_two_mul_norm_pow {z : ℂ} (hz : ‖z‖ < 1) (hzhalf : ‖z‖ ≤ 1 / 2) (m : ℕ) : ++ ‖logTail m z‖ ≤ 2 * ‖z‖ ^ (m + 1) := ++ (norm_logTail_le hz m).trans (Real.pow_div_one_sub_le_two_mul (norm_nonneg z) hzhalf m) ++ ++lemma norm_partialLogSum_le_nat_mul_max_one_norm_pow (m : ℕ) (z : ℂ) : ++ ‖partialLogSum m z‖ ≤ (m : ℝ) * max 1 (‖z‖ ^ m) := by ++ have hsum : ++ ‖partialLogSum m z‖ ≤ ∑ k ∈ Finset.range m, ‖z ^ (k + 1) / (k + 1)‖ := by ++ rw [partialLogSum_eq_sum] ++ exact norm_sum_le _ _ ++ have hterm : ∀ k ∈ Finset.range m, ‖z ^ (k + 1) / (k + 1)‖ ≤ max 1 (‖z‖ ^ m) := by ++ intro k hk ++ rw [norm_div, norm_pow] ++ have hk1 : (1 : ℝ) ≤ (k : ℝ) + 1 := by ++ have hk1_nat : (1 : ℕ) ≤ k + 1 := Nat.succ_le_succ (Nat.zero_le k) ++ exact_mod_cast hk1_nat ++ have hdenom : ‖((k : ℂ) + 1)‖ = (k : ℝ) + 1 := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (k + 1)) ++ have hk_le : k + 1 ≤ m := Nat.succ_le_iff.2 (Finset.mem_range.1 hk) ++ have hpow_le : ‖z‖ ^ (k + 1) ≤ max 1 (‖z‖ ^ m) := by ++ have hz0 : 0 ≤ ‖z‖ := norm_nonneg z ++ by_cases hz1 : ‖z‖ ≤ (1 : ℝ) ++ · have : ‖z‖ ^ (k + 1) ≤ 1 := by exact pow_le_one₀ hz0 hz1 ++ exact this.trans (le_max_left _ _) ++ · have hz1' : (1 : ℝ) ≤ ‖z‖ := le_of_lt (lt_of_not_ge hz1) ++ have : ‖z‖ ^ (k + 1) ≤ ‖z‖ ^ m := pow_le_pow_right₀ hz1' hk_le ++ exact this.trans (le_max_right _ _) ++ calc ++ ‖z‖ ^ (k + 1) / ‖((k : ℂ) + 1)‖ = ‖z‖ ^ (k + 1) / ((k : ℝ) + 1) := by simp [hdenom] ++ _ ≤ ‖z‖ ^ (k + 1) := by ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) hk1 ++ _ ≤ max 1 (‖z‖ ^ m) := hpow_le ++ have hsum_le : ++ (∑ k ∈ Finset.range m, ‖z ^ (k + 1) / (k + 1)‖) ≤ ++ ∑ _k ∈ Finset.range m, max 1 (‖z‖ ^ m) := ++ Finset.sum_le_sum (fun k hk => hterm k hk) ++ have hcard : ∑ _k ∈ Finset.range m, max 1 (‖z‖ ^ m) = (m : ℝ) * max 1 (‖z‖ ^ m) := by ++ simp [Finset.sum_const] ++ exact hsum.trans (hsum_le.trans_eq hcard) ++ ++lemma neg_log_one_sub_eq_partialLogSum_add_logTail {z : ℂ} (hz : ‖z‖ < 1) (m : ℕ) : ++ -log (1 - z) = partialLogSum m z + logTail m z := by ++ let f : ℕ → ℂ := fun k ↦ z ^ (k + 1) / ((k : ℂ) + 1) ++ have h_summable : Summable f := by ++ simpa [f, Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (summable_logTail hz 0) ++ have h_decomp := h_summable.sum_add_tsum_nat_add m ++ rw [neg_log_one_sub_eq_tsum hz, partialLogSum_eq_sum, ← h_decomp] ++ congr 1 ++ dsimp only [logTail] ++ refine tsum_congr fun k ↦ ?_ ++ simp only [f, Nat.cast_add] ++ ring_nf ++ ++end Complex ++end HadamardSourceScope00 ++ ++section HadamardSourceScope01 ++ ++noncomputable section ++ ++namespace Complex ++ ++open _root_.Complex ++ ++variable {z : ℂ} ++ ++@[bound] ++theorem neg_norm_le_re (z : ℂ) : -‖z‖ ≤ z.re := ++ neg_le_of_abs_le (abs_re_le_norm z) ++ ++lemma norm_inv_pow_le_one_of_one_le_norm (u : ℂ) (n : ℕ) (hu : (1 : ℝ) ≤ ‖u‖) : ++ ‖(u ^ n)⁻¹‖ ≤ 1 := by ++ have hge : (1 : ℝ) ≤ ‖u ^ n‖ := by ++ rw [Complex.norm_pow] ++ exact one_le_pow₀ hu ++ calc ‖(u ^ n)⁻¹‖ = ‖(1 : ℂ) / u ^ n‖ := by rw [inv_eq_one_div] ++ _ = 1 / ‖u ^ n‖ := by ++ have hone : ‖(1 : ℂ)‖ = (1 : ℝ) := by simp ++ rw [Complex.norm_div, hone] ++ _ ≤ 1 := by simpa [one_div] using inv_le_one_of_one_le₀ hge ++ ++end Complex ++end ++end HadamardSourceScope01 ++ ++section HadamardSourceScope02 ++ ++noncomputable section ++ ++open scoped BigOperators ++open Set ++ ++namespace Complex ++ ++open _root_.Complex ++ ++def weierstrassFactor (m : ℕ) (z : ℂ) : ℂ := ++ (1 - z) * exp (partialLogSum m z) ++ ++lemma weierstrassFactor_def (m : ℕ) (z : ℂ) : ++ weierstrassFactor m z = (1 - z) * exp (partialLogSum m z) := by ++ simp [weierstrassFactor] ++ ++@[simp] ++lemma weierstrassFactor_at_zero (m : ℕ) : weierstrassFactor m 0 = 1 := by ++ simp [weierstrassFactor, partialLogSum_at_zero] ++ ++lemma weierstrassFactor_eq_zero_iff (m : ℕ) (z : ℂ) : ++ weierstrassFactor m z = 0 ↔ z = 1 := by ++ constructor ++ · intro hz ++ rw [weierstrassFactor] at hz ++ rcases mul_eq_zero.mp hz with h1 | h2 ++ · exact (sub_eq_zero.mp h1).symm ++ · exact absurd h2 (exp_ne_zero _) ++ · rintro rfl ++ simp [weierstrassFactor] ++ ++lemma weierstrassFactor_ne_zero_iff (m : ℕ) (z : ℂ) : ++ weierstrassFactor m z ≠ 0 ↔ z ≠ 1 := by ++ simpa [ne_eq] using (not_congr (weierstrassFactor_eq_zero_iff (m := m) (z := z))) ++ ++lemma weierstrassFactor_ne_zero_of_ne_one (m : ℕ) {z : ℂ} (hz : z ≠ 1) : ++ weierstrassFactor m z ≠ 0 := ++ (weierstrassFactor_ne_zero_iff (m := m) (z := z)).2 hz ++ ++lemma differentiable_weierstrassFactor (m : ℕ) : ++ Differentiable ℂ (fun z : ℂ => weierstrassFactor m z) := by ++ simpa [weierstrassFactor] using! ++ ((differentiable_const (c := (1 : ℂ))).sub differentiable_id).mul ++ (differentiable_exp.comp (differentiable_partialLogSum m)) ++ ++theorem analyticOrderAt_weierstrassFactor_div_self (m : ℕ) {a : ℂ} (ha : a ≠ 0) : ++ analyticOrderAt (fun z : ℂ => weierstrassFactor m (z / a)) a = (1 : ℕ∞) := by ++ set F : ℂ → ℂ := fun z => weierstrassFactor m (z / a) ++ have hF : AnalyticAt ℂ F a := by ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / a) := by ++ simp [div_eq_mul_inv] ++ have hdiff : Differentiable ℂ F := (differentiable_weierstrassFactor m).comp hdiv ++ exact Differentiable.analyticAt (f := F) hdiff a ++ let g : ℂ → ℂ := fun z => (-a⁻¹) * Complex.exp (partialLogSum m (z / a)) ++ have hg : AnalyticAt ℂ g a := by ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / a) := by ++ simp [div_eq_mul_inv] ++ have hpls : Differentiable ℂ (fun z : ℂ => partialLogSum m (z / a)) := ++ (differentiable_partialLogSum m).comp hdiv ++ have hexp : Differentiable ℂ (fun z : ℂ => Complex.exp (partialLogSum m (z / a))) := ++ (Complex.differentiable_exp).comp hpls ++ have hdiffg : Differentiable ℂ g := by ++ simpa [g] using hexp.const_mul (-a⁻¹ : ℂ) ++ exact Differentiable.analyticAt (f := g) hdiffg a ++ have hg0 : g a ≠ 0 := by ++ have hconst : (-a⁻¹ : ℂ) ≠ 0 := by simp [ha] ++ have hexp0 : Complex.exp (partialLogSum m (a / a)) ≠ 0 := ++ Complex.exp_ne_zero (partialLogSum m (a / a)) ++ simpa [g] using mul_ne_zero hconst hexp0 ++ refine (hF.analyticOrderAt_eq_natCast (n := 1)).2 ?_ ++ refine ⟨g, hg, hg0, ?_⟩ ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ have hlin : (1 - z / a) = (z - a) * (-a⁻¹) := by ++ have h1 : (1 : ℂ) = a * a⁻¹ := by simp [ha] ++ simp [div_eq_mul_inv, h1] ++ ring ++ simp only [F, g, pow_one, smul_eq_mul] ++ rw [weierstrassFactor_def] ++ simp [hlin, mul_assoc] ++ ++lemma weierstrassFactor_eq_exp_neg_tail (m : ℕ) {z : ℂ} (hz : ‖z‖ < 1) (hz1 : z ≠ 1) : ++ weierstrassFactor m z = exp (-logTail m z) := by ++ unfold weierstrassFactor ++ have hz_ne_1 : 1 - z ≠ 0 := sub_ne_zero.mpr hz1.symm ++ rw [← exp_log hz_ne_1, ← Complex.exp_add] ++ have hsum : log (1 - z) + partialLogSum m z = -logTail m z := by ++ have hdecomp := neg_log_one_sub_eq_partialLogSum_add_logTail hz m ++ calc ++ log (1 - z) + partialLogSum m z ++ = log (1 - z) + (partialLogSum m z + logTail m z) - logTail m z := by ring ++ _ = log (1 - z) + (-log (1 - z)) - logTail m z := by rw [hdecomp] ++ _ = -logTail m z := by ring ++ simp [hsum] ++ ++theorem weierstrassFactor_sub_one_pow_bound {m : ℕ} {z : ℂ} (hz : ‖z‖ ≤ 1 / 2) : ++ ‖weierstrassFactor m z - 1‖ ≤ 4 * ‖z‖ ^ (m + 1) := by ++ by_cases hm : m = 0 ++ · subst hm ++ have hmain : ‖(1 - z) - 1‖ ≤ 4 * ‖z‖ ^ 1 := by ++ have h : (1 - z) - 1 = -z := by ring ++ calc ++ ‖(1 - z) - 1‖ = ‖-z‖ := by simp [h] ++ _ = ‖z‖ := norm_neg z ++ _ = ‖z‖ ^ 1 := by simp ++ _ ≤ 4 * ‖z‖ ^ 1 := by nlinarith [pow_nonneg (norm_nonneg z) 1] ++ simpa [weierstrassFactor] using hmain ++ · have hz_lt : ‖z‖ < 1 := lt_of_le_of_lt hz (by norm_num) ++ by_cases hz1 : z = 1 ++ · exfalso; rw [hz1] at hz; norm_num at hz ++ have h_eq : weierstrassFactor m z = exp (-logTail m z) := ++ weierstrassFactor_eq_exp_neg_tail m hz_lt hz1 ++ rw [h_eq] ++ have h_tail_bound := norm_logTail_le_two_mul_norm_pow hz_lt hz m ++ have hw_le_one : ‖-logTail m z‖ ≤ 1 := by ++ simp only [norm_neg] ++ have : ‖logTail m z‖ ≤ 1 := by ++ have hm_pos : 0 < m := Nat.pos_of_ne_zero hm ++ have h2 : 2 ≤ m + 1 := by ++ exact Nat.succ_le_succ (Nat.succ_le_iff.2 hm_pos) ++ have hpow : (‖z‖ ^ (m + 1)) ≤ (‖z‖ ^ 2) := by ++ have hz1' : ‖z‖ ≤ 1 := by nlinarith [hz] ++ have hz0' : 0 ≤ ‖z‖ := norm_nonneg z ++ exact pow_le_pow_of_le_one hz0' hz1' h2 ++ have hmul : 2 * ‖z‖ ^ (m + 1) ≤ 2 * ‖z‖ ^ 2 := by gcongr ++ have hsq : 2 * ‖z‖ ^ 2 ≤ 1 := by ++ have hz0 : 0 ≤ ‖z‖ := norm_nonneg z ++ have hz_sq : ‖z‖ ^ 2 ≤ (1 / 2 : ℝ) ^ 2 := pow_le_pow_left₀ hz0 hz 2 ++ nlinarith ++ exact (h_tail_bound.trans hmul).trans hsq ++ linarith ++ have h_exp_sub_one : ‖exp (-logTail m z) - 1‖ ≤ 2 * ‖-logTail m z‖ := ++ Complex.norm_exp_sub_one_le hw_le_one ++ simp only [norm_neg] at h_exp_sub_one ++ calc ++ ‖exp (-logTail m z) - 1‖ ≤ 2 * ‖logTail m z‖ := h_exp_sub_one ++ _ ≤ 2 * (2 * ‖z‖ ^ (m + 1)) := by gcongr ++ _ = 4 * ‖z‖ ^ (m + 1) := by ring ++ ++lemma log_norm_weierstrassFactor_ge_log_norm_one_sub_sub (m : ℕ) (z : ℂ) : ++ Real.log ‖1 - z‖ - ‖partialLogSum m z‖ ≤ Real.log ‖weierstrassFactor m z‖ := by ++ by_cases hz1 : z = (1 : ℂ) ++ · subst hz1 ++ simp [weierstrassFactor] ++ set S : ℂ := partialLogSum m z ++ have hS : weierstrassFactor m z = (1 - z) * Complex.exp S := by ++ simp [weierstrassFactor, S] ++ have hnorm_pos : 0 < ‖(1 : ℂ) - z‖ := ++ norm_pos_iff.mpr (sub_ne_zero.mpr (Ne.symm hz1)) ++ have hlog : ++ Real.log ‖weierstrassFactor m z‖ = Real.log ‖1 - z‖ + S.re := by ++ have hne : ‖(1 : ℂ) - z‖ ≠ 0 := ne_of_gt hnorm_pos ++ calc ++ Real.log ‖weierstrassFactor m z‖ ++ = Real.log (‖(1 : ℂ) - z‖ * ‖Complex.exp S‖) := by ++ simp [hS] ++ _ = Real.log ‖(1 : ℂ) - z‖ + Real.log ‖Complex.exp S‖ := by ++ simpa using (Real.log_mul hne (ne_of_gt (by simp))) ++ _ = Real.log ‖(1 : ℂ) - z‖ + S.re := by ++ simp [Complex.norm_exp, Real.log_exp] ++ _ = Real.log ‖1 - z‖ + S.re := by simp [sub_eq_add_neg, add_comm] ++ have hre : S.re ≥ -‖S‖ := Complex.neg_norm_le_re S ++ have : Real.log ‖weierstrassFactor m z‖ ≥ Real.log ‖1 - z‖ - ‖S‖ := by ++ linarith [hlog, hre] ++ simpa [S] using this ++ ++lemma log_norm_weierstrassFactor_ge_neg_two_pow {m : ℕ} {z : ℂ} (hz : ‖z‖ ≤ (1 / 2 : ℝ)) : ++ (-2 : ℝ) * ‖z‖ ^ (m + 1) ≤ Real.log ‖weierstrassFactor m z‖ := by ++ have hz_lt : ‖z‖ < (1 : ℝ) := lt_of_le_of_lt hz (by norm_num) ++ have hz1 : z ≠ (1 : ℂ) := by ++ intro h ++ have : (1 : ℝ) ≤ (1 / 2 : ℝ) := by ++ simpa [h] using hz ++ norm_num at this ++ have hEq : weierstrassFactor m z = Complex.exp (-logTail m z) := ++ weierstrassFactor_eq_exp_neg_tail m hz_lt hz1 ++ have hlog : ++ Real.log ‖weierstrassFactor m z‖ = (-logTail m z).re := by ++ simp [hEq, Complex.norm_exp, Real.log_exp] ++ have hre : (-logTail m z).re ≥ -‖logTail m z‖ := by ++ simpa [norm_neg] using Complex.neg_norm_le_re (-logTail m z) ++ have htail := norm_logTail_le_two_mul_norm_pow hz_lt hz m ++ have : (-logTail m z).re ≥ (-2 : ℝ) * ‖z‖ ^ (m + 1) := by ++ calc ++ (-logTail m z).re ≥ -‖logTail m z‖ := hre ++ _ ≥ (-2 : ℝ) * ‖z‖ ^ (m + 1) := by ++ nlinarith [htail] ++ simpa [hlog, mul_assoc, mul_left_comm, mul_comm] using this ++ ++end Complex ++end ++end HadamardSourceScope02 ++ ++section HadamardSourceScope03 ++ ++noncomputable section ++ ++open Filter Topology ++ ++namespace Complex ++ ++open _root_.Complex ++ ++theorem logDeriv_weierstrassFactor_one_div {a z : ℂ} (ha : a ≠ 0) (hz : z ≠ a) : ++ logDeriv (fun w : ℂ => weierstrassFactor 1 (w / a)) z = ++ 1 / (z - a) + 1 / a := by ++ have hE : ++ (fun w : ℂ => weierstrassFactor 1 (w / a)) = ++ fun w : ℂ => (1 - w / a) * exp (w / a) := by ++ ext w ++ simp [weierstrassFactor_def, partialLogSum_eq_sum] ++ have hf : (1 - z / a) ≠ 0 := by ++ intro hzero ++ have hdiv : z / a = 1 := by ++ exact (sub_eq_zero.mp hzero).symm ++ exact hz ((div_eq_one_iff_eq ha).1 hdiv) ++ rw [hE, logDeriv_fun_mul z hf (exp_ne_zero (z / a)) (by fun_prop) (by fun_prop)] ++ have hleft : logDeriv (fun w : ℂ => 1 - w / a) z = 1 / (z - a) := by ++ rw [logDeriv_apply] ++ have hderiv : deriv (fun w : ℂ => 1 - w / a) z = -(1 / a) := by ++ simp [one_div] ++ rw [hderiv] ++ have haz : -z + a ≠ 0 := by ++ simpa [sub_eq_add_neg, add_comm] using sub_ne_zero.mpr (Ne.symm hz) ++ field_simp [ha, sub_ne_zero.mpr hz, haz] ++ have haz' : a - z ≠ 0 := sub_ne_zero.mpr (Ne.symm hz) ++ have hza : z - a = -(a - z) := by ring ++ rw [hza] ++ field_simp [haz'] ++ have hright : logDeriv (fun w : ℂ => exp (w / a)) z = 1 / a := by ++ rw [logDeriv_apply] ++ have hderiv : deriv (fun w : ℂ => exp (w / a)) z = ++ exp (z / a) * (1 / a) := by ++ simp [one_div] ++ rw [hderiv] ++ field_simp [exp_ne_zero (z / a)] ++ rw [hleft, hright] ++ ++end Complex ++end ++end HadamardSourceScope03 ++ ++section HadamardSourceScope04 ++ ++open Filter Topology Set ++ ++namespace MeromorphicOn ++ ++open _root_.MeromorphicOn ++ ++variable {𝕜 : Type*} [NontriviallyNormedField 𝕜] {U K : Set 𝕜} {z : 𝕜} ++ {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] ++ ++lemma divisor_support_inter_compact_finite (f : 𝕜 → E) {U K : Set 𝕜} ++ (hK : IsCompact K) (hKU : K ⊆ U) : ++ (K ∩ (MeromorphicOn.divisor f U).support).Finite := by ++ classical ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have hloc : ++ ∀ x ∈ K, ∃ V : Set 𝕜, V ∈ 𝓝 x ∧ Set.Finite (V ∩ D.support) := by ++ intro x hxK ++ rcases D.supportLocallyFiniteWithinDomain x (hKU hxK) with ⟨V, hV, hfin⟩ ++ exact ⟨V, hV, hfin⟩ ++ choose V hVnhds hVfin using hloc ++ rcases hK.elim_nhds_subcover' (U := fun x hx => V x hx) (hU := fun x hx => hVnhds x hx) with ++ ⟨t, ht⟩ ++ have hsub : ++ K ∩ D.support ⊆ ⋃ x ∈ t, (V (x : 𝕜) x.2 ∩ D.support) := by ++ intro y hy ++ rcases hy with ⟨hyK, hyS⟩ ++ have hycov : y ∈ ⋃ x ∈ t, V (x : 𝕜) x.2 := ht hyK ++ rcases Set.mem_iUnion.1 hycov with ⟨x, hycov'⟩ ++ rcases Set.mem_iUnion.1 hycov' with ⟨hxT, hyV⟩ ++ refine Set.mem_iUnion.2 ⟨x, Set.mem_iUnion.2 ?_⟩ ++ exact ⟨hxT, ⟨hyV, hyS⟩⟩ ++ have hfinU : Set.Finite (⋃ x ∈ t, (V (x : 𝕜) x.2 ∩ D.support)) := by ++ classical ++ refine (t.finite_toSet).biUnion ?_ ++ intro x hx ++ simpa using (hVfin (x : 𝕜) x.2) ++ exact hfinU.subset hsub ++ ++end MeromorphicOn ++end HadamardSourceScope04 ++ ++section HadamardSourceScope05 ++ ++open Set ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++def divisorZeroIndex (f : ℂ → ℂ) (U : Set ℂ) : Type := ++ Σ z : ℂ, Fin (Int.toNat (MeromorphicOn.divisor f U z)) ++ ++abbrev divisorZeroIndex₀ (f : ℂ → ℂ) (U : Set ℂ) : Type := ++ {p : divisorZeroIndex f U // p.1 ≠ 0} ++ ++abbrev divisorZeroIndex₀Val {f : ℂ → ℂ} {U : Set ℂ} (p : divisorZeroIndex₀ f U) : ℂ := ++ p.1.1 ++ ++@[simp] ++lemma divisorZeroIndex₀Val_ne_zero {f : ℂ → ℂ} {U : Set ℂ} (p : divisorZeroIndex₀ f U) : ++ divisorZeroIndex₀Val p ≠ 0 := p.2 ++ ++@[simp] ++lemma divisorZeroIndex₀Val_mem_divisor_support {f : ℂ → ℂ} {U : Set ℂ} ++ (p : divisorZeroIndex₀ f U) : ++ MeromorphicOn.divisor f U (divisorZeroIndex₀Val p) ≠ 0 := by ++ have hn : ++ Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p)) ≠ 0 := by ++ intro h0 ++ have q0 : Fin 0 := by ++ simpa [divisorZeroIndex₀Val, h0] using p.1.2 ++ exact Fin.elim0 q0 ++ intro hdiv ++ have : Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p)) = 0 := by ++ simp [hdiv] ++ exact hn this ++ ++noncomputable def divisorCanonicalProduct (m : ℕ) (f : ℂ → ℂ) (U : Set ℂ) (z : ℂ) : ℂ := ++ ∏' p : divisorZeroIndex₀ f U, weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ ++@[simp] ++lemma divisorCanonicalProduct_zero (m : ℕ) (f : ℂ → ℂ) (U : Set ℂ) : ++ divisorCanonicalProduct m f U 0 = 1 := by ++ simp [divisorCanonicalProduct] ++ ++end Complex.Hadamard ++end HadamardSourceScope05 ++ ++section HadamardSourceScope06 ++ ++namespace Complex ++ ++open _root_.Complex ++ ++section UniformMul ++ ++theorem _root_.Erdos970.TendstoUniformlyOn.mul_left_bounded {ι : Type*} {p : Filter ι} {K : Set ℂ} ++ {F : ι → ℂ → ℂ} {f : ℂ → ℂ} {h : ℂ → ℂ} ++ (hF : TendstoUniformlyOn F f p K) (hh : ∃ C, ∀ z ∈ K, ‖h z‖ ≤ C) : ++ TendstoUniformlyOn (fun n z => h z * F n z) (fun z => h z * f z) p K := by ++ intro u hu ++ rcases Metric.mem_uniformity_dist.1 hu with ⟨ε, hεpos, hεu⟩ ++ rcases hh with ⟨C, hC⟩ ++ set C' : ℝ := max C 1 ++ have hC'pos : 0 < C' := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hC' : ∀ z ∈ K, ‖h z‖ ≤ C' := fun z hz => le_trans (hC z hz) (le_max_left _ _) ++ have hv : {p : ℂ × ℂ | dist p.1 p.2 < ε / C'} ∈ uniformity ℂ := ++ Metric.mem_uniformity_dist.2 ⟨ε / C', div_pos hεpos hC'pos, fun _ _ hab => hab⟩ ++ have hF' : ∀ᶠ n in p, ∀ z : ℂ, z ∈ K → dist (f z) (F n z) < ε / C' := hF _ hv ++ filter_upwards [hF'] with n hn z hzK ++ have hn' : ‖f z - F n z‖ < ε / C' := by simpa [dist_eq_norm] using hn z hzK ++ have hle : ‖h z‖ * ‖f z - F n z‖ ≤ C' * ‖f z - F n z‖ := ++ mul_le_mul_of_nonneg_right (hC' z hzK) (norm_nonneg _) ++ have hlt : C' * ‖f z - F n z‖ < C' * (ε / C') := mul_lt_mul_of_pos_left hn' hC'pos ++ have hnorm : ++ ‖h z * f z - h z * F n z‖ = ‖h z‖ * ‖f z - F n z‖ := by ++ calc ++ ‖h z * f z - h z * F n z‖ = ‖h z * (f z - F n z)‖ := by simp [mul_sub] ++ _ = ‖h z‖ * ‖f z - F n z‖ := by simp ++ have hdist : dist (h z * f z) (h z * F n z) < ε := by ++ rw [dist_eq_norm, hnorm] ++ have hlt' : ‖h z‖ * ‖f z - F n z‖ < ε := by ++ calc ++ ‖h z‖ * ‖f z - F n z‖ ≤ C' * ‖f z - F n z‖ := hle ++ _ < C' * (ε / C') := hlt ++ _ = ε := by field_simp [hC'pos.ne'] ++ exact hlt' ++ exact hεu hdist ++ ++end UniformMul ++ ++end Complex ++end HadamardSourceScope06 ++ ++section HadamardSourceScope07 ++ ++open Filter _root_.Function _root_.Complex _root_.Erdos970.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++lemma finite_divisorZeroIndex₀_subtype_norm_le {f : ℂ → ℂ} {U : Set ℂ} (B : ℝ) ++ (hBU : Metric.closedBall (0 : ℂ) B ⊆ U) : ++ Finite {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ B} := by ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have hK : IsCompact (Metric.closedBall (0 : ℂ) B) := isCompact_closedBall _ _ ++ have hpts0 : ((Metric.closedBall (0 : ℂ) B) ∩ D.support).Finite := ++ MeromorphicOn.divisor_support_inter_compact_finite (f := f) (U := U) ++ (K := Metric.closedBall (0 : ℂ) B) hK hBU ++ set pts : Set ℂ := ((Metric.closedBall (0 : ℂ) B) ∩ D.support) \ {0} ++ have hpts : pts.Finite := hpts0.sdiff ++ let : Fintype pts := hpts.fintype ++ let T : Type := Σ z : pts, Fin (Int.toNat (D z.1)) ++ have : Finite T := by infer_instance ++ let F : ++ {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ B} → T := fun p => ++ ⟨⟨divisorZeroIndex₀Val p.1, by ++ have hball : divisorZeroIndex₀Val p.1 ∈ Metric.closedBall (0 : ℂ) B := by ++ simpa [Metric.mem_closedBall, dist_zero_right] using p.2 ++ have hsupport : divisorZeroIndex₀Val p.1 ∈ D.support := by ++ have hne_toNat : ++ Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p.1)) ≠ 0 := by ++ intro h0 ++ have hpfin : ++ Fin (Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p.1))) := by ++ simpa [D] using p.1.1.2 ++ have : Fin 0 := by simpa [h0] using hpfin ++ exact Fin.elim0 this ++ have hne_D : D (divisorZeroIndex₀Val p.1) ≠ 0 := by ++ intro hD0 ++ apply hne_toNat ++ simp [D, hD0] ++ simp [D, Function.locallyFinsuppWithin.support, Function.support] ++ have hne0 : divisorZeroIndex₀Val p.1 ≠ 0 := divisorZeroIndex₀Val_ne_zero p.1 ++ exact ⟨⟨hball, hsupport⟩, by simp [Set.mem_singleton_iff]⟩⟩, ++ p.1.1.2⟩ ++ refine Finite.of_injective F ?_ ++ intro p q hpq ++ apply Subtype.ext ++ apply Subtype.ext ++ have h' := (Sigma.mk.inj_iff.1 hpq) ++ have hz : divisorZeroIndex₀Val p.1 = divisorZeroIndex₀Val q.1 := congrArg Subtype.val h'.1 ++ apply (Sigma.mk.inj_iff).2 ++ refine ⟨hz, ?_⟩ ++ exact h'.2 ++ ++lemma divisorZeroIndex₀_norm_le_finite {f : ℂ → ℂ} {U : Set ℂ} (B : ℝ) ++ (hBU : Metric.closedBall (0 : ℂ) B ⊆ U) : ++ ({p : divisorZeroIndex₀ f U | ‖divisorZeroIndex₀Val p‖ ≤ B} : Set _).Finite := by ++ let s : Set (divisorZeroIndex₀ f U) := {p | ‖divisorZeroIndex₀Val p‖ ≤ B} ++ have : Finite (↥s) := ++ finite_divisorZeroIndex₀_subtype_norm_le (f := f) (U := U) B hBU ++ exact Set.toFinite s ++ ++lemma norm_div_le_half_of_norm_le_of_two_mul_lt {z a : ℂ} {R : ℝ} ++ (hR : 0 < R) (hz : ‖z‖ ≤ R) (ha : (2 * R : ℝ) < ‖a‖) : ++ ‖z / a‖ ≤ (1 / 2 : ℝ) := by ++ have h2R_pos : 0 < (2 * R : ℝ) := by nlinarith [hR] ++ have hinv : ‖a‖⁻¹ < (2 * R)⁻¹ := by ++ simpa [one_div] using one_div_lt_one_div_of_lt h2R_pos ha ++ have hmul_le : ‖z‖ * ‖a‖⁻¹ ≤ R * ‖a‖⁻¹ := ++ mul_le_mul_of_nonneg_right hz (inv_nonneg.2 (norm_nonneg a)) ++ have hmul_lt : R * ‖a‖⁻¹ < R * (2 * R)⁻¹ := ++ mul_lt_mul_of_pos_left hinv hR ++ have hRhalf : R * (2 * R)⁻¹ = (1 / 2 : ℝ) := by ++ have hRne : (R : ℝ) ≠ 0 := hR.ne' ++ rw [show R * (2 * R)⁻¹ = R / (2 * R) by simp [div_eq_mul_inv]] ++ field_simp [hRne] ++ have hnorm : ‖z / a‖ = ‖z‖ * ‖a‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ exact le_of_lt <| by ++ calc ++ ‖z / a‖ = ‖z‖ * ‖a‖⁻¹ := hnorm ++ _ ≤ R * ‖a‖⁻¹ := hmul_le ++ _ < R * (2 * R)⁻¹ := hmul_lt ++ _ = (1 / 2 : ℝ) := hRhalf ++ ++theorem summable_logDerivTerms_divisorZeroIndex₀_of_summable_inv_sq ++ {f : ℂ → ℂ} {z : ℂ} ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ))) ++ (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ 1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := by ++ let R : ℝ := max ‖z‖ 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hzle : ‖z‖ ≤ R := le_max_left _ _ ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (2 * R) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ)) ++ have hu : Summable u := h_sum.mul_left (2 * R) ++ refine hu.of_norm_bounded_eventually ?_ ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ++ 2 * R} : Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite ++ (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ filter_upwards [h_big] with p hp ++ let a : ℂ := divisorZeroIndex₀Val p ++ have ha0 : a ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ have hza0 : z - a ≠ 0 := sub_ne_zero.mpr (hz p) ++ have hterm : 1 / (z - a) + 1 / a = z / (a * (z - a)) := by ++ field_simp [ha0, hza0] ++ ring ++ have htri : ‖a‖ ≤ ‖z‖ + ‖z - a‖ := by ++ have hraw : ‖a‖ ≤ ‖z‖ + ‖a - z‖ := by ++ have h := norm_add_le z (a - z) ++ simpa [a, sub_eq_add_neg, add_assoc, add_left_comm, add_comm] using h ++ simpa [norm_sub_rev] using hraw ++ have hza_lower : ‖a‖ / 2 ≤ ‖z - a‖ := by ++ nlinarith [htri, hzle, hp] ++ have hnorm : ‖1 / (z - a) + 1 / a‖ ≤ (2 * R) * (‖a‖⁻¹ ^ (2 : ℕ)) := by ++ rw [hterm, norm_div, norm_mul] ++ have ha_norm_pos : 0 < ‖a‖ := norm_pos_iff.mpr ha0 ++ have hza_norm_pos : 0 < ‖z - a‖ := norm_pos_iff.mpr hza0 ++ rw [div_eq_mul_inv] ++ calc ++ ‖z‖ * (‖a‖ * ‖z - a‖)⁻¹ ++ = ‖z‖ * ‖a‖⁻¹ * ‖z - a‖⁻¹ := by ++ field_simp [ha_norm_pos.ne', hza_norm_pos.ne'] ++ _ ≤ R * ‖a‖⁻¹ * ‖z - a‖⁻¹ := by ++ gcongr ++ _ ≤ R * ‖a‖⁻¹ * (2 * ‖a‖⁻¹) := by ++ gcongr ++ have hhalf_pos : 0 < ‖a‖ / 2 := by positivity ++ have hinv : ‖z - a‖⁻¹ ≤ (‖a‖ / 2)⁻¹ := by ++ simpa [one_div] using one_div_le_one_div_of_le hhalf_pos hza_lower ++ have hhalf_inv : (‖a‖ / 2)⁻¹ = 2 * ‖a‖⁻¹ := by field_simp [ha_norm_pos.ne'] ++ simpa [hhalf_inv] using hinv ++ _ = (2 * R) * (‖a‖⁻¹ ^ (2 : ℕ)) := by ring ++ simpa [u, a] using hnorm ++ ++theorem hasProdUniformlyOn_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) {K : Set ℂ} (hK : IsCompact K) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) K := by ++ rcases (isBounded_iff_forall_norm_le.1 hK.isBounded) with ⟨R0, hR0⟩ ++ set R : ℝ := max R0 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hnormK : ∀ z ∈ K, ‖z‖ ≤ R := fun z hzK => le_trans (hR0 z hzK) (le_max_left _ _) ++ let g : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1 ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (4 * R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) ++ have hu : Summable u := h_sum.mul_left (4 * R ^ (m + 1)) ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ 2 * R} : ++ Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ have hBound : ++ ∀ᶠ p in Filter.cofinite, ∀ z ∈ K, ‖g p z‖ ≤ u p := by ++ filter_upwards [h_big] with p hp z hzK ++ have hzle : ‖z‖ ≤ R := hnormK z hzK ++ have hz_div : ‖z / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := by ++ exact norm_div_le_half_of_norm_le_of_two_mul_lt hRpos hzle hp ++ have hE : ++ ‖weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1‖ ≤ ++ 4 * ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) := ++ weierstrassFactor_sub_one_pow_bound (m := m) (z := z / divisorZeroIndex₀Val p) hz_div ++ have hz_pow : ++ ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) ≤ ++ (R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ have : ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ rw [this] ++ have : (‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹) ^ (m + 1) = ++ ‖z‖ ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simp [mul_pow] ++ rw [this] ++ have hzle_pow : ‖z‖ ^ (m + 1) ≤ R ^ (m + 1) := ++ pow_le_pow_left₀ (norm_nonneg z) hzle (m + 1) ++ gcongr ++ dsimp [g, u] ++ nlinarith [hE, hz_pow] ++ have hcts : ∀ p, ContinuousOn (g p) K := by ++ intro p ++ have hcontE : Continuous (fun z : ℂ => weierstrassFactor m z) := ++ (differentiable_weierstrassFactor m).continuous ++ have hdiv : Continuous fun z : ℂ => z / divisorZeroIndex₀Val p := by ++ simpa [div_eq_mul_inv] using! (continuous_id.mul continuous_const) ++ have hcont : Continuous fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) := ++ hcontE.comp hdiv ++ simpa only [g] using hcont.continuousOn.fun_sub continuous_const.continuousOn ++ have hprod : ++ HasProdUniformlyOn (fun p z ↦ 1 + g p z) (fun z ↦ ∏' p, (1 + g p z)) K := by ++ simpa using ++ Summable.hasProdUniformlyOn_one_add (f := g) (u := u) (K := K) hK hu hBound hcts ++ simpa [g, divisorCanonicalProduct, sub_eq_add_neg, add_assoc, add_left_comm, add_comm] ++ using! hprod ++ ++theorem hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (Set.univ : Set ℂ) := by ++ refine hasProdLocallyUniformlyOn_of_forall_compact ++ (f := fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (g := divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (s := (Set.univ : Set ℂ)) isOpen_univ ?_ ++ intro K hKU hK ++ simpa using ++ (hasProdUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) (K := K) hK h_sum) ++ ++theorem differentiableOn_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ DifferentiableOn ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) (Set.univ : Set ℂ) := by ++ have hloc : ++ TendstoLocallyUniformlyOn ++ (fun (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) => ++ ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop (Set.univ : Set ℂ) := by ++ simpa [HasProdLocallyUniformlyOn] using ++ (hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum) ++ have hF : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in Filter.atTop, ++ DifferentiableOn ℂ ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (Set.univ : Set ℂ) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro s ++ have hdiff : ++ Differentiable ℂ ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) := by ++ let F : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hF' : ∀ p ∈ s, Differentiable ℂ (F p) := by ++ intro p hp ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / divisorZeroIndex₀Val p) := by ++ have : Differentiable ℂ (fun z : ℂ => z * ((divisorZeroIndex₀Val p)⁻¹)) := ++ (differentiable_id : Differentiable ℂ (fun z : ℂ => z)).mul_const ++ ((divisorZeroIndex₀Val p)⁻¹) ++ simp [div_eq_mul_inv] ++ exact (differentiable_weierstrassFactor m).comp hdiv ++ simpa [F] using (Differentiable.fun_finsetProd (𝕜 := ℂ) (f := F) (u := s) hF') ++ simpa using hdiff.differentiableOn ++ have : (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))).NeBot := ++ Filter.atTop_neBot ++ exact hloc.differentiableOn hF isOpen_univ ++ ++theorem differentiableAt_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) (z : ℂ) : ++ DifferentiableAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := ++ ((differentiableOn_divisorCanonicalProduct_univ m f h_sum) z (by simp)).differentiableAt ++ (by simp) ++ ++theorem logDeriv_divisorCanonicalProduct_one_eq_tsum ++ {f : ℂ → ℂ} {z : ℂ} ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ))) ++ (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) ++ (hprod_ne : divisorCanonicalProduct 1 f (Set.univ : Set ℂ) z ≠ 0) : ++ logDeriv (divisorCanonicalProduct 1 f (Set.univ : Set ℂ)) z = ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p w => weierstrassFactor 1 (w / divisorZeroIndex₀Val p) ++ have hf : ∀ p, Φ p z ≠ 0 := by ++ intro p ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ refine weierstrassFactor_ne_zero_of_ne_one 1 ?_ ++ intro h ++ exact hz p ((div_eq_one_iff_eq hp0).1 h) ++ have hd : ∀ p, DifferentiableOn ℂ (Φ p) (Set.univ : Set ℂ) := by ++ intro p ++ have hdiv : Differentiable ℂ (fun w : ℂ => w / divisorZeroIndex₀Val p) := by ++ have : Differentiable ℂ (fun w : ℂ => w * ((divisorZeroIndex₀Val p)⁻¹)) := ++ (differentiable_id : Differentiable ℂ (fun w : ℂ => w)).mul_const ++ ((divisorZeroIndex₀Val p)⁻¹) ++ simp [div_eq_mul_inv] ++ exact ((differentiable_weierstrassFactor 1).comp hdiv).differentiableOn ++ have hm' : Summable fun p => logDeriv (Φ p) z := by ++ have hm : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ 1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := ++ summable_logDerivTerms_divisorZeroIndex₀_of_summable_inv_sq h_sum hz ++ refine hm.congr ?_ ++ intro p ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ simpa [Φ] using ++ (Complex.logDeriv_weierstrassFactor_one_div ++ (a := divisorZeroIndex₀Val p) (z := z) hp0 (hz p)).symm ++ have htend : MultipliableLocallyUniformlyOn Φ (Set.univ : Set ℂ) := by ++ have hprod := hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ ++ (m := 1) (f := f) h_sum ++ simpa [Φ, divisorCanonicalProduct] using hprod.multipliableLocallyUniformlyOn ++ have hnez : (∏' p, Φ p z) ≠ 0 := by ++ simpa [Φ, divisorCanonicalProduct] using hprod_ne ++ have hlog : logDeriv (∏' p, Φ p ·) z = ∑' p, logDeriv (Φ p) z := ++ logDeriv_tprod_eq_tsum (s := (Set.univ : Set ℂ)) isOpen_univ (by simp) ++ hf hd hm' htend hnez ++ calc ++ logDeriv (divisorCanonicalProduct 1 f (Set.univ : Set ℂ)) z ++ = ∑' p, logDeriv (Φ p) z := by ++ simpa [Φ, divisorCanonicalProduct] using! hlog ++ _ = ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := by ++ refine tsum_congr fun p => ?_ ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ simpa [Φ] using ++ Complex.logDeriv_weierstrassFactor_one_div ++ (a := divisorZeroIndex₀Val p) (z := z) hp0 (hz p) ++ ++end Complex.Hadamard ++end HadamardSourceScope07 ++ ++section HadamardSourceScope09 ++ ++noncomputable section ++ ++open Set ++open scoped Topology BigOperators ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++lemma divisor_univ_eq_analyticOrderNatAt_int {f : ℂ → ℂ} (hf : Differentiable ℂ f) (z : ℂ) : ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) z = (analyticOrderNatAt f z : ℤ) := by ++ have hmero : MeromorphicOn f (Set.univ : Set ℂ) := by ++ intro w hw ++ exact (Differentiable.analyticAt (f := f) hf w).meromorphicAt ++ simp only ++ [MeromorphicOn.divisor_apply hmero (by simp : z ∈ (Set.univ : Set ℂ)), analyticOrderNatAt] ++ have han : AnalyticAt ℂ f z := Differentiable.analyticAt (f := f) hf z ++ cases h : analyticOrderAt f z with ++ | top => ++ simp [han.meromorphicOrderAt_eq, h] ++ | coe n => ++ simp [han.meromorphicOrderAt_eq, h] ++ ++theorem divisorZeroIndex₀_fiber_finite (f : ℂ → ℂ) (z₀ : ℂ) : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | divisorZeroIndex₀Val p = z₀} : ++ Set _).Finite := by ++ have hsub : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | divisorZeroIndex₀Val p = z₀} : Set _) ++ ⊆ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ‖z₀‖} : ++ Set _) := by ++ intro p hp ++ have : divisorZeroIndex₀Val p = z₀ := hp ++ simp [this] ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ‖z₀‖} : ++ Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) ‖z₀‖ ⊆ (Set.univ : Set ℂ) := by simp ++ simpa using (divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) ++ (B := ‖z₀‖) this) ++ exact hfin.subset hsub ++ ++def divisorZeroIndex₀FiberFinset (f : ℂ → ℂ) (z₀ : ℂ) : ++ Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ (divisorZeroIndex₀_fiber_finite (f := f) z₀).toFinset ++ ++@[simp] ++lemma mem_divisorZeroIndex₀FiberFinset (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ↔ divisorZeroIndex₀Val p = z₀ := by ++ simp [divisorZeroIndex₀FiberFinset] ++ ++theorem eventually_atTop_subset_fiberFinset ++ (f : ℂ → ℂ) (z₀ : ℂ) : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s := by ++ refine (Filter.eventually_atTop.2 ?_) ++ refine ⟨divisorZeroIndex₀FiberFinset (f := f) z₀, ?_⟩ ++ intro s hs ++ exact hs ++ ++lemma divisorZeroIndex₀FiberFinset_card_eq_toNat_divisor (f : ℂ → ℂ) {z₀ : ℂ} (hz₀ : z₀ ≠ 0) : ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = ++ Int.toNat (MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀) := by ++ let S : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := {p | divisorZeroIndex₀Val p = z₀} ++ have hS : S.Finite := divisorZeroIndex₀_fiber_finite (f := f) z₀ ++ set n : ℕ := Int.toNat (MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀) ++ have hcard : Nat.card S = n := by ++ classical ++ have : Fintype S := hS.fintype ++ ++ let e : S ≃ Fin n := ++ { toFun := by ++ intro x ++ rcases x with ⟨p, hp⟩ ++ rcases p with ⟨⟨z, q⟩, hz⟩ ++ have hzEq : z = z₀ := by simpa [divisorZeroIndex₀Val] using! hp ++ subst hzEq ++ simpa [n] using q ++ invFun := by ++ intro q ++ refine ⟨⟨⟨z₀, ?_⟩, hz₀⟩, ?_⟩ ++ · simpa [n] using q ++ · simp [S, divisorZeroIndex₀Val] ++ left_inv := by ++ rintro ⟨p, hp⟩ ++ rcases p with ⟨⟨z, q⟩, hz⟩ ++ have hzEq : z = z₀ := by simpa [divisorZeroIndex₀Val] using! hp ++ subst hzEq ++ (ext; rfl) ++ right_inv := by ++ intro q ++ rfl } ++ have h := Nat.card_congr (α := S) (β := Fin n) e ++ simpa using (h.trans (by simp)) ++ have hSncard : S.ncard = n := by ++ simpa [Nat.card_coe_set_eq] using hcard ++ have hto : hS.toFinset = divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ rfl ++ have htoFinset : S.ncard = (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ have h' : S.ncard = hS.toFinset.card := Set.ncard_eq_toFinset_card S hS ++ simpa [hto] using h' ++ exact htoFinset.symm.trans hSncard ++ ++lemma divisorZeroIndex₀FiberFinset_card_eq_analyticOrderNatAt ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) {z₀ : ℂ} (hz₀ : z₀ ≠ 0) : ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = analyticOrderNatAt f z₀ := by ++ have hdiv : ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀ = (analyticOrderNatAt f z₀ : ℤ) := ++ divisor_univ_eq_analyticOrderNatAt_int (f := f) hf z₀ ++ have htoNat : Int.toNat (MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀) = ++ analyticOrderNatAt f z₀ := by ++ simp [hdiv] ++ exact (divisorZeroIndex₀FiberFinset_card_eq_toNat_divisor (f := f) (z₀ := z₀) hz₀).trans htoNat ++ ++lemma not_mem_divisorZeroIndex₀FiberFinset_iff_val_ne ++ {f : ℂ → ℂ} (z₀ : ℂ) (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ p ∉ divisorZeroIndex₀FiberFinset (f := f) z₀ ↔ divisorZeroIndex₀Val p ≠ z₀ := by ++ simp [mem_divisorZeroIndex₀FiberFinset] ++ ++end Complex.Hadamard ++end ++end HadamardSourceScope09 ++ ++section HadamardSourceScope10 ++ ++open Filter _root_.Function _root_.Complex _root_.Erdos970.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++noncomputable def divisorComplementFactor ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) : ℂ := by ++ classical ++ exact if p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ ++@[simp] ++theorem divisorComplementFactor_eq_one_of_mem ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) ++ (hp : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀) : ++ divisorComplementFactor m f z₀ p z = 1 := by ++ classical ++ simp [divisorComplementFactor, hp] ++ ++@[simp] ++theorem divisorComplementFactor_eq_weierstrassFactor_of_not_mem ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) ++ (hp : p ∉ divisorZeroIndex₀FiberFinset (f := f) z₀) : ++ divisorComplementFactor m f z₀ p z = ++ weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ classical ++ simp [divisorComplementFactor, hp] ++ ++lemma divisorComplementFactor_def ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) : ++ divisorComplementFactor m f z₀ p z = ++ if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ classical ++ by_cases h : divisorZeroIndex₀Val p = z₀ ++ · have hp : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ simpa [mem_divisorZeroIndex₀FiberFinset] using h ++ simp [divisorComplementFactor_eq_one_of_mem, hp, h] ++ · have hp : p ∉ divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ intro hmem ++ exact h ((mem_divisorZeroIndex₀FiberFinset f z₀ p).1 hmem) ++ simp [divisorComplementFactor_eq_weierstrassFactor_of_not_mem, hp, h] ++ ++noncomputable def divisorPartialProduct (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) : ℂ := ++ ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ ++theorem differentiable_weierstrassFactor_divisorZeroIndex₀ (m : ℕ) {f : ℂ → ℂ} ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ Differentiable ℂ (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p)) := by ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / divisorZeroIndex₀Val p) := by ++ simp [div_eq_mul_inv] ++ exact (differentiable_weierstrassFactor m).comp hdiv ++ ++theorem differentiable_divisorPartialProduct (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ Differentiable ℂ (divisorPartialProduct m f s) := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hΦ : ∀ p ∈ s, Differentiable ℂ (Φ p) := by ++ intro p _hp ++ exact differentiable_weierstrassFactor_divisorZeroIndex₀ m p ++ simpa [divisorPartialProduct, Φ] using! ++ (Differentiable.fun_finsetProd (𝕜 := ℂ) (f := Φ) (u := s) hΦ) ++ ++theorem analyticAt_divisorPartialProduct (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z₀ : ℂ) : ++ AnalyticAt ℂ (divisorPartialProduct m f s) z₀ := ++ (differentiable_divisorPartialProduct m f s).analyticAt z₀ ++ ++noncomputable def divisorComplementPartialProduct ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) : ℂ := ++ ∏ p ∈ s, divisorComplementFactor m f z₀ p z ++ ++@[simp] ++lemma divisorComplementPartialProduct_def ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) : ++ divisorComplementPartialProduct m f z₀ s z = ++ ∏ p ∈ s, if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ simp [divisorComplementPartialProduct, divisorComplementFactor, ++ mem_divisorZeroIndex₀FiberFinset] ++ ++theorem differentiable_divisorComplementPartialProduct ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ Differentiable ℂ (divisorComplementPartialProduct m f z₀ s) := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => divisorComplementFactor m f z₀ p z ++ have hΦ : ∀ p ∈ s, Differentiable ℂ (Φ p) := by ++ intro p _hp ++ by_cases hpF : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ · have hΦp : Φ p = fun _ => (1 : ℂ) := by ++ ext z ++ simp only [Φ, divisorComplementFactor_eq_one_of_mem m f z₀ p z hpF] ++ rw [hΦp] ++ exact differentiable_const (1 : ℂ) ++ · have hΦp : Φ p = fun z => weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ ext z ++ simp only [Φ, divisorComplementFactor_eq_weierstrassFactor_of_not_mem m f z₀ p z hpF] ++ rw [hΦp] ++ exact differentiable_weierstrassFactor_divisorZeroIndex₀ m p ++ have hEq : (fun z : ℂ => ∏ p ∈ s, Φ p z) = ++ divisorComplementPartialProduct m f z₀ s := by ++ ext z ++ simp [Φ, divisorComplementPartialProduct] ++ have : Differentiable ℂ (fun z : ℂ => ∏ p ∈ s, Φ p z) := by ++ simpa using (Differentiable.fun_finsetProd (𝕜 := ℂ) (f := Φ) (u := s) hΦ) ++ simpa [hEq] using this ++ ++noncomputable def divisorComplementCanonicalProduct ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) (z : ℂ) : ℂ := ++ ∏' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), divisorComplementFactor m f z₀ p z ++ ++theorem hasProdUniformlyOn_divisorComplementCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) {K : Set ℂ} (hK : IsCompact K) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdUniformlyOn (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ divisorComplementFactor m f z₀ p z) (divisorComplementCanonicalProduct m f z₀) ++ K := by ++ rcases (isBounded_iff_forall_norm_le.1 hK.isBounded) with ⟨R0, hR0⟩ ++ set R : ℝ := max R0 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hnormK : ∀ z ∈ K, ‖z‖ ≤ R := fun z hzK => le_trans (hR0 z hzK) (le_max_left _ _) ++ let term : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := fun p z => ++ divisorComplementFactor m f z₀ p z ++ let g : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := fun p z => term p z - 1 ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (4 * R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) ++ have hu : Summable u := h_sum.mul_left (4 * R ^ (m + 1)) ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ 2 * R} : ++ Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ have hBound : ++ ∀ᶠ p in Filter.cofinite, ∀ z ∈ K, ‖g p z‖ ≤ u p := by ++ filter_upwards [h_big] with p hp z hzK ++ by_cases hpF : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ · have hval : divisorZeroIndex₀Val p = z₀ := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z₀) p).1 hpF ++ have hu0 : 0 ≤ u p := by ++ dsimp [u] ++ refine mul_nonneg ?_ ?_ ++ · nlinarith [pow_nonneg (show 0 ≤ R from le_of_lt hRpos) (m + 1)] ++ · exact pow_nonneg (inv_nonneg.2 (norm_nonneg _)) (m + 1) ++ simp [g, term, divisorComplementFactor, hval, hu0, sub_eq_add_neg] ++ · have hzle : ‖z‖ ≤ R := hnormK z hzK ++ have hz_div : ‖z / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := by ++ have h2R_pos : 0 < (2 * R : ℝ) := by nlinarith [hRpos] ++ have hinv : ‖divisorZeroIndex₀Val p‖⁻¹ < (2 * R)⁻¹ := by ++ simpa [one_div] using (one_div_lt_one_div_of_lt h2R_pos hp) ++ have hmul_le : ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ ≤ R * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ refine mul_le_mul_of_nonneg_right hzle ?_ ++ exact inv_nonneg.2 (norm_nonneg _) ++ have hmul_lt : R * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ mul_lt_mul_of_pos_left hinv hRpos ++ have hlt : ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ lt_of_le_of_lt hmul_le hmul_lt ++ have hRhalf : R * (2 * R)⁻¹ = (1 / 2 : ℝ) := by ++ have hRne : (R : ℝ) ≠ 0 := hRpos.ne' ++ have : R * (2 * R)⁻¹ = R / (2 * R) := by simp [div_eq_mul_inv] ++ rw [this] ++ field_simp [hRne] ++ have hnorm : ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ have hzlt : ‖z / divisorZeroIndex₀Val p‖ < (1 / 2 : ℝ) := by ++ calc ++ ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := hnorm ++ _ < R * (2 * R)⁻¹ := hlt ++ _ = (1 / 2 : ℝ) := hRhalf ++ exact le_of_lt hzlt ++ have hE : ‖weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1‖ ≤ ++ 4 * ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) := ++ weierstrassFactor_sub_one_pow_bound (m := m) (z := z / divisorZeroIndex₀Val p) hz_div ++ have hz_pow : ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) ≤ ++ (R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ have : ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ rw [this] ++ have : (‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹) ^ (m + 1) = ++ ‖z‖ ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simp [mul_pow] ++ rw [this] ++ have hzle_pow : ‖z‖ ^ (m + 1) ≤ R ^ (m + 1) := ++ pow_le_pow_left₀ (norm_nonneg z) hzle (m + 1) ++ gcongr ++ dsimp [g, term, u] ++ simp [divisorComplementFactor, hpF] at * ++ nlinarith [hE, hz_pow] ++ have hcts : ∀ p, ContinuousOn (g p) K := by ++ intro p ++ by_cases hpF : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ · have hval : divisorZeroIndex₀Val p = z₀ := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z₀) p).1 hpF ++ simpa [g, term, divisorComplementFactor, hval, sub_eq_add_neg, add_assoc, add_left_comm, ++ add_comm] using ++ (continuousOn_const : ContinuousOn (fun _ : ℂ => (0 : ℂ)) K) ++ · have hvalne : divisorZeroIndex₀Val p ≠ z₀ := ++ (not_mem_divisorZeroIndex₀FiberFinset_iff_val_ne (f := f) z₀ p).1 hpF ++ have hcontE : Continuous (fun z : ℂ => weierstrassFactor m z) := ++ (differentiable_weierstrassFactor m).continuous ++ have hdiv : Continuous fun z : ℂ => z / divisorZeroIndex₀Val p := by ++ simpa [div_eq_mul_inv] using! (continuous_id.mul continuous_const) ++ have hcont : Continuous fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) := ++ hcontE.comp hdiv ++ have : ContinuousOn (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1) K := ++ (hcont.continuousOn.sub continuous_const.continuousOn) ++ simpa [g, term, divisorComplementFactor, mem_divisorZeroIndex₀FiberFinset, hvalne] using this ++ have hprod : ++ HasProdUniformlyOn (fun p z ↦ 1 + g p z) (fun z ↦ ∏' p, (1 + g p z)) K := by ++ simpa using ++ Summable.hasProdUniformlyOn_one_add (f := g) (u := u) (K := K) hK hu hBound hcts ++ have hterm : ++ HasProdUniformlyOn (fun p z ↦ term p z) (fun z ↦ ∏' p, term p z) K := by ++ simpa [g, sub_eq_add_neg, add_assoc, add_left_comm, add_comm] using hprod ++ refine hterm.congr_right ?_ ++ intro z hz ++ simp [term, divisorComplementCanonicalProduct, divisorComplementFactor] ++ ++theorem hasProdLocallyUniformlyOn_divisorComplementCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ divisorComplementFactor m f z₀ p z) ++ (divisorComplementCanonicalProduct m f z₀) ++ (Set.univ : Set ℂ) := by ++ refine hasProdLocallyUniformlyOn_of_forall_compact ++ (f := fun p z => divisorComplementFactor m f z₀ p z) ++ (g := divisorComplementCanonicalProduct m f z₀) (s := (Set.univ : Set ℂ)) ++ isOpen_univ ?_ ++ intro K hKU hK ++ simpa using ++ (hasProdUniformlyOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) (z₀ := z₀) ++ (K := K) hK h_sum) ++ ++theorem tendstoLocallyUniformlyOn_divisorComplementPartialProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := by ++ have hprod : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ divisorComplementFactor m f z₀ p z) ++ (divisorComplementCanonicalProduct m f z₀) ++ (Set.univ : Set ℂ) := ++ hasProdLocallyUniformlyOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) ++ (z₀ := z₀) h_sum ++ have h : ++ TendstoLocallyUniformlyOn ++ (fun (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) => ++ ∏ p ∈ s, ++ if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := by ++ simpa [HasProdLocallyUniformlyOn, divisorComplementFactor, mem_divisorZeroIndex₀FiberFinset] ++ using hprod ++ refine h.congr (G := fun s z => divisorComplementPartialProduct m f z₀ s z) ?_ ++ intro s z hz ++ simp [divisorComplementPartialProduct_def] ++ ++theorem differentiableOn_divisorComplementCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ DifferentiableOn ℂ (divisorComplementCanonicalProduct m f z₀) (Set.univ : Set ℂ) := by ++ have hloc : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := ++ tendstoLocallyUniformlyOn_divisorComplementPartialProduct_univ (m := m) (f := f) ++ (z₀ := z₀) h_sum ++ have hF : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in Filter.atTop, ++ DifferentiableOn ℂ (divisorComplementPartialProduct m f z₀ s) (Set.univ : Set ℂ) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro s ++ exact (differentiable_divisorComplementPartialProduct m f z₀ s).differentiableOn ++ have : (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))).NeBot := ++ Filter.atTop_neBot ++ exact hloc.differentiableOn hF isOpen_univ ++ ++lemma divisorPartialProduct_eq_fiber_mul_complement_of_subset ++ (m : ℕ) (f : ℂ → ℂ) (z₀ z : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hs : divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s) : ++ divisorPartialProduct m f s z = ++ divisorPartialProduct m f (divisorZeroIndex₀FiberFinset (f := f) z₀) z * ++ divisorComplementPartialProduct m f z₀ s z := by ++ classical ++ let fiber : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ let P : divisorZeroIndex₀ f (Set.univ : Set ℂ) → Prop := fun p => p ∈ fiber ++ let term : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := ++ fun p => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hfilter : s.filter P = fiber := by ++ ext p ++ constructor ++ · intro hp ++ exact (Finset.mem_filter.mp hp).2 ++ · intro hp ++ exact Finset.mem_filter.mpr ⟨hs hp, hp⟩ ++ have hsplit : ++ (∏ p ∈ s with P p, term p) * (∏ p ∈ s with ¬ P p, term p) = ∏ p ∈ s, term p := by ++ simpa [term] using ++ (Finset.prod_filter_mul_prod_filter_not (s := s) (p := P) (f := term)) ++ have hP : (∏ p ∈ s with P p, term p) = divisorPartialProduct m f fiber z := by ++ have hg : ∀ x ∈ s \ fiber, (if x ∈ fiber then term x else (1 : ℂ)) = 1 := by ++ intro x hx ++ have hxnot : x ∉ fiber := (Finset.mem_sdiff.mp hx).2 ++ simp [hxnot] ++ have hfg : ++ ∀ x ∈ fiber, term x = (if x ∈ fiber then term x else (1 : ℂ)) := by ++ intro x hx ++ simp [hx] ++ have hsub := (Finset.prod_subset_one_on_sdiff (s₁ := fiber) (s₂ := s) ++ (f := term) (g := fun x => if x ∈ fiber then term x else (1 : ℂ)) hs hg hfg) ++ simpa [divisorPartialProduct, term, P, fiber, Finset.prod_filter] using hsub.symm ++ have hnotP : (∏ p ∈ s with ¬ P p, term p) = divisorComplementPartialProduct m f z₀ s z := by ++ simp [divisorComplementPartialProduct, divisorComplementFactor, term, P, fiber, ++ Finset.prod_filter, mem_divisorZeroIndex₀FiberFinset] ++ have hsplit' : ∏ p ∈ s, term p = (∏ p ∈ s with P p, term p) * (∏ p ∈ s with ¬ P p, term p) := ++ hsplit.symm ++ calc ++ divisorPartialProduct m f s z ++ = ∏ p ∈ s, term p := by simp [divisorPartialProduct, term] ++ _ = (∏ p ∈ s with P p, term p) * (∏ p ∈ s with ¬ P p, term p) := hsplit' ++ _ = divisorPartialProduct m f fiber z * divisorComplementPartialProduct m f z₀ s z := by ++ simp [hP, hnotP, fiber] ++ ++end Complex.Hadamard ++end HadamardSourceScope10 ++ ++section HadamardSourceScope11 ++ ++noncomputable section ++ ++open _root_.Complex _root_.Erdos970.Complex Filter _root_.Function Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++theorem analyticOrderAt_finset_prod_weierstrassFactor_divisorZeroIndex₀ ++ (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z₀ : ℂ) : ++ analyticOrderAt (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ z₀ = ((s.filter (fun p => divisorZeroIndex₀Val p = z₀)).card : ℕ∞) := by ++ classical ++ refine Finset.induction_on s ?base ?step ++ · simp [analyticOrderAt_eq_zero] ++ · intro p s hp hs ++ by_cases hEq : divisorZeroIndex₀Val p = z₀ ++ · have hp0 : divisorZeroIndex₀Val p ≠ 0 := p.property ++ have han_fac : ++ AnalyticAt ℂ (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p)) z₀ := by ++ exact (differentiable_weierstrassFactor_divisorZeroIndex₀ m p).analyticAt z₀ ++ have han_rest : AnalyticAt ℂ (fun z : ℂ => ∏ q ∈ s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ := by ++ simpa [divisorPartialProduct] using! analyticAt_divisorPartialProduct m f s z₀ ++ let fac : ℂ → ℂ := fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ let rest : ℂ → ℂ := fun z : ℂ => ∏ q ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val q) ++ have hmul : ++ analyticOrderAt (fac * rest) z₀ = ++ analyticOrderAt fac z₀ + analyticOrderAt rest z₀ := by ++ simpa [fac, rest] using (analyticOrderAt_mul (z₀ := z₀) han_fac han_rest) ++ have hcard : ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) (insert p s)).card = ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) s).card + 1 := by ++ simp [hEq, hp, Finset.filter_insert] ++ have hfac : analyticOrderAt fac z₀ = (1 : ℕ∞) := by ++ simpa [fac, hEq] using ++ (analyticOrderAt_weierstrassFactor_div_self (m := m) (a := divisorZeroIndex₀Val p) hp0) ++ have hrest : analyticOrderAt rest z₀ = ((s.filter ++ (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simpa [rest] using hs ++ have hcongr : ++ (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m (z / divisorZeroIndex₀Val q)) ++ =ᶠ[𝓝 z₀] (fac * rest) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ simp [fac, rest, Finset.prod_insert, hp, Pi.mul_apply] ++ calc ++ analyticOrderAt (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ = analyticOrderAt (fac * rest) z₀ := by ++ simpa using (analyticOrderAt_congr hcongr) ++ _ = analyticOrderAt fac z₀ + analyticOrderAt rest z₀ := hmul ++ _ = (1 : ℕ∞) + ((s.filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simp [hfac, hrest] ++ _ = (((insert p s).filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simp [hcard, Nat.add_comm] ++ · have han_fac : ++ AnalyticAt ℂ (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p)) z₀ := by ++ exact (differentiable_weierstrassFactor_divisorZeroIndex₀ m p).analyticAt z₀ ++ have hfac0 : analyticOrderAt (fun z : ℂ => weierstrassFactor m ++ (z / divisorZeroIndex₀Val p)) z₀ = 0 := by ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := p.property ++ have hval : weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) ≠ 0 := by ++ have : (z₀ / divisorZeroIndex₀Val p) ≠ 1 := by ++ intro h1 ++ have : z₀ = divisorZeroIndex₀Val p := by ++ have : z₀ = (z₀ / divisorZeroIndex₀Val p) * (divisorZeroIndex₀Val p) := by ++ simp [div_eq_mul_inv] ++ simpa [h1, div_eq_mul_inv, hp0] using this ++ exact hEq (this.symm) ++ exact (weierstrassFactor_ne_zero_iff m (z₀ / divisorZeroIndex₀Val p)).2 this ++ simpa using (han_fac.analyticOrderAt_eq_zero).2 (by simpa using hval) ++ have hcard : ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) (insert p s)).card = ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) s).card := by ++ simp [hEq, Finset.filter_insert] ++ have han_rest : AnalyticAt ℂ (fun z : ℂ => ∏ q ∈ s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ := by ++ simpa [divisorPartialProduct] using! analyticAt_divisorPartialProduct m f s z₀ ++ let fac : ℂ → ℂ := fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ let rest : ℂ → ℂ := fun z : ℂ => ∏ q ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val q) ++ have hmul : ++ analyticOrderAt (fac * rest) z₀ = ++ analyticOrderAt fac z₀ + analyticOrderAt rest z₀ := by ++ simpa [fac, rest] using (analyticOrderAt_mul (z₀ := z₀) han_fac han_rest) ++ have hcongr : ++ (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m (z / divisorZeroIndex₀Val q)) ++ =ᶠ[𝓝 z₀] (fac * rest) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ simp [fac, rest, Finset.prod_insert, hp, Pi.mul_apply] ++ calc ++ analyticOrderAt (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ ++ = analyticOrderAt (fac * rest) z₀ := by ++ simpa using (analyticOrderAt_congr hcongr) ++ _ = analyticOrderAt rest z₀ := by ++ calc ++ analyticOrderAt (fac * rest) z₀ = analyticOrderAt fac z₀ + ++ analyticOrderAt rest z₀ := hmul ++ _ = analyticOrderAt rest z₀ := by ++ have hfac0' : analyticOrderAt fac z₀ = 0 := by ++ simpa [fac] using hfac0 ++ simp [hfac0'] ++ _ = ((s.filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simpa [rest] using hs ++ _ = (((insert p s).filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simpa using congrArg (fun n : ℕ => (n : ℕ∞)) hcard.symm ++ ++theorem analyticOrderAt_partialProduct_eq_fiberCard_of_subset ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hs : divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s) : ++ analyticOrderAt ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ z₀ = ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ have h := ++ analyticOrderAt_finset_prod_weierstrassFactor_divisorZeroIndex₀ ++ (m := m) (f := f) (s := s) (z₀ := z₀) ++ have hfilter : ++ s.filter (fun p => divisorZeroIndex₀Val p = z₀) = ++ divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ ext p ++ constructor ++ · intro hp' ++ have hpv : divisorZeroIndex₀Val p = z₀ := (Finset.mem_filter.mp hp').2 ++ simpa [mem_divisorZeroIndex₀FiberFinset] using hpv ++ · intro hp_fiber ++ have hpv : divisorZeroIndex₀Val p = z₀ := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z₀) p).1 hp_fiber ++ have hps : p ∈ s := hs (by simpa [mem_divisorZeroIndex₀FiberFinset] using hpv) ++ exact Finset.mem_filter.2 ⟨hps, hpv⟩ ++ simpa [hfilter] using h ++ ++theorem exists_analyticAt_eq_pow_smul_of_partialProduct_contains_fiber ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hs : divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s) : ++ ∃ g : ℂ → ℂ, ++ AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ =ᶠ[𝓝 z₀] ++ fun z : ℂ => (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card • g z := by ++ let F : ℂ → ℂ := fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hF_ana : AnalyticAt ℂ F z₀ := by ++ simpa [F, divisorPartialProduct] using! analyticAt_divisorPartialProduct m f s z₀ ++ have hOrder : ++ analyticOrderAt F z₀ = ++ ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ simpa [F] using ++ (analyticOrderAt_partialProduct_eq_fiberCard_of_subset (m := m) ++ (f := f) (z₀ := z₀) (s := s) hs) ++ refine (hF_ana.analyticOrderAt_eq_natCast (n := (divisorZeroIndex₀FiberFinset ++ (f := f) z₀).card)).1 ?_ ++ simp [hOrder] ++ ++end Complex.Hadamard ++end ++end HadamardSourceScope11 ++ ++section HadamardSourceScope12 ++ ++open Filter _root_.Function _root_.Complex _root_.Erdos970.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++theorem tendstoLocallyUniformlyOn_divisorPartialProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => divisorPartialProduct m f s) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop ++ (Set.univ : Set ℂ) := by ++ have hprod : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (Set.univ : Set ℂ) := ++ hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ simpa [HasProdLocallyUniformlyOn, divisorPartialProduct] using! hprod ++ ++theorem tendstoUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) (k : ℕ) {K : Set ℂ} (hK : IsCompact K) (hKz : ∀ z ∈ K, z ≠ z₀) : ++ TendstoUniformlyOn ++ (fun s z => (divisorPartialProduct m f s z) / (z - z₀) ^ k) ++ (fun z => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ k) ++ (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))) ++ K := by ++ have hloc : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => divisorPartialProduct m f s) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop ++ K := ++ (tendstoLocallyUniformlyOn_divisorPartialProduct_univ (m := m) (f := f) h_sum).mono ++ (by intro z hz; simp) ++ have hunif : ++ TendstoUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => divisorPartialProduct m f s) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop ++ K := ++ (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hK).1 hloc ++ let h : ℂ → ℂ := fun z => ((z - z₀) ^ k)⁻¹ ++ have hh : ∃ C, ∀ z ∈ K, ‖h z‖ ≤ C := by ++ have hcont : ContinuousOn h K := by ++ have hpow : ContinuousOn (fun z : ℂ => (z - z₀) ^ k) K := by ++ fun_prop ++ refine hpow.inv₀ ?_ ++ intro z hz ++ have hz0 : z - z₀ ≠ 0 := sub_ne_zero.mpr (hKz z hz) ++ exact pow_ne_zero k hz0 ++ have hKimg : IsCompact (h '' K) := hK.image_of_continuousOn hcont ++ rcases (isBounded_iff_forall_norm_le.1 hKimg.isBounded) with ⟨C, hC⟩ ++ refine ⟨C, ?_⟩ ++ intro z hz ++ exact hC (h z) ⟨z, hz, rfl⟩ ++ have hunif' := ++ (TendstoUniformlyOn.mul_left_bounded (p := (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f ++ (Set.univ : Set ℂ))))) ++ (K := K) ++ (F := fun s z => divisorPartialProduct m f s z) ++ (f := fun z => divisorCanonicalProduct m f (Set.univ : Set ℂ) z) ++ (h := h) ++ hunif hh) ++ simpa [h, div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using hunif' ++ ++theorem tendstoLocallyUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) (k : ℕ) : ++ TendstoLocallyUniformlyOn ++ (fun s z => (divisorPartialProduct m f s z) / (z - z₀) ^ k) ++ (fun z => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ k) ++ (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))) ++ ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hopen : IsOpen ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hset : ((Set.univ : Set ℂ) \ {z₀}) = ({z₀} : Set ℂ)ᶜ := by ++ ext z ++ simp ++ simp [hset] ++ refine (tendstoLocallyUniformlyOn_iff_forall_isCompact hopen).2 ?_ ++ intro K hKsub hK ++ have hKz : ∀ z ∈ K, z ≠ z₀ := by ++ intro z hzK ++ have : z ∈ (Set.univ : Set ℂ) \ {z₀} := hKsub hzK ++ exact by simpa [Set.mem_sdiff, Set.mem_singleton_iff] using this.2 ++ exact tendstoUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m := m) (f := f) h_sum (z₀ := z₀) (k := k) (hK := hK) hKz ++ ++open Filter ++ ++theorem exists_ball_eq_divisorCanonicalProduct_div_pow_eq ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ ∃ ε > 0, ∃ u : ℂ → ℂ, AnalyticAt ℂ u z₀ ∧ ++ u z₀ ≠ 0 ∧ ++ ∀ z : ℂ, z ∈ Metric.ball z₀ ε → z ≠ z₀ → ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = ++ (divisorComplementCanonicalProduct m f z₀ z) * u z := by ++ let fiber : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ have hfib : ∃ u : ℂ → ℂ, AnalyticAt ℂ u z₀ ∧ u z₀ ≠ 0 ∧ ++ (fun z : ℂ => divisorPartialProduct m f fiber z) =ᶠ[𝓝 z₀] ++ fun z : ℂ => (z - z₀) ^ fiber.card • u z := by ++ simpa [fiber, divisorPartialProduct] using ++ (exists_analyticAt_eq_pow_smul_of_partialProduct_contains_fiber (m := m) (f := f) (z₀ := z₀) ++ (s := fiber) (by rfl : fiber ⊆ fiber)) ++ rcases hfib with ⟨u, huA, hu0, huEq⟩ ++ have hmem : {z : ℂ | divisorPartialProduct m f fiber z = ++ (z - z₀) ^ fiber.card • u z} ∈ 𝓝 z₀ := huEq ++ rcases Metric.mem_nhds_iff.1 hmem with ⟨ε, hε, hball⟩ ++ refine ⟨ε, hε, u, huA, hu0, ?_⟩ ++ have hq : ++ TendstoLocallyUniformlyOn (fun s z => (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card) ++ (fun z => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ fiber.card) ++ (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))) ++ ((Set.univ : Set ℂ) \ {z₀}) := ++ tendstoLocallyUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀) (k := fiber.card) ++ have hcomp : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := ++ tendstoLocallyUniformlyOn_divisorComplementPartialProduct_univ (m := m) (f := f) ++ (z₀ := z₀) h_sum ++ intro z hz hzne ++ have hz' : z ∈ ((Set.univ : Set ℂ) \ {z₀}) := by ++ refine ⟨by simp, ?_⟩ ++ simpa [Set.mem_singleton_iff] using hzne ++ have hF : Tendsto (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card) (Filter.atTop : Filter _) ++ (𝓝 ((divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ fiber.card)) := ++ hq.tendsto_at hz' ++ have hG0 : Tendsto (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s z) (Filter.atTop : Filter _) ++ (𝓝 (divisorComplementCanonicalProduct m f z₀ z)) := ++ hcomp.tendsto_at (by simp : z ∈ (Set.univ : Set ℂ)) ++ have hG : Tendsto (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ (divisorComplementPartialProduct m f z₀ s z) * u z) (Filter.atTop : Filter _) ++ (𝓝 ((divisorComplementCanonicalProduct m f z₀ z) * u z)) := ++ (hG0.mul tendsto_const_nhds) ++ have hsub : ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ fiber ⊆ s := eventually_atTop_subset_fiberFinset (f := f) z₀ ++ have heq_eventually : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card ++ = (divisorComplementPartialProduct m f z₀ s z) * u z := by ++ filter_upwards [hsub] with s hs ++ have hsplit : ++ divisorPartialProduct m f s z = ++ divisorPartialProduct m f fiber z * divisorComplementPartialProduct m f z₀ s z := by ++ simpa [fiber] using ++ (divisorPartialProduct_eq_fiber_mul_complement_of_subset (m := m) (f := f) (z₀ := z₀) ++ (z := z) (s := s) hs) ++ have hfibz : ++ divisorPartialProduct m f fiber z = (z - z₀) ^ fiber.card • u z := by ++ exact hball hz ++ have hzpow : (z - z₀) ^ fiber.card ≠ 0 := ++ pow_ne_zero _ (sub_ne_zero.mpr hzne) ++ set a : ℂ := (z - z₀) ^ fiber.card ++ have ha : a ≠ 0 := by simpa [a] using hzpow ++ set c : ℂ := divisorComplementPartialProduct m f z₀ s z with hc ++ rw [hsplit, hfibz, smul_eq_mul] ++ calc ++ ((a * u z) * c) / a ++ = (a * (u z * c)) / a := by simp [mul_assoc] ++ _ = u z * c := by ++ simpa [mul_assoc] using (mul_div_cancel_left₀ (u z * c) ha) ++ _ = c * u z := by ac_rfl ++ _ = (divisorComplementPartialProduct m f z₀ s z) * u z := by ++ simp [c] ++ have hG' : ++ Tendsto ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card) ++ (Filter.atTop : Filter _) ++ (𝓝 ((divisorComplementCanonicalProduct m f z₀ z) * u z)) := by ++ have heq' : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ (divisorComplementPartialProduct m f z₀ s z) * u z ++ = (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card := by ++ filter_upwards [heq_eventually] with s hs ++ exact hs.symm ++ exact (hG.congr' heq') ++ exact tendsto_nhds_unique hF hG' ++ ++theorem bddAbove_norm_divisorCanonicalProduct_div_pow_puncturedBall ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ∃ r > 0, BddAbove (norm ∘ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) '' ++ ((Metric.ball z₀ r) \ {z₀})) := by ++ rcases exists_ball_eq_divisorCanonicalProduct_div_pow_eq (m := m) (f := f) (h_sum := h_sum) ++ (z₀ := z₀) with ⟨ε, hε, u, huA, hu0, hEq⟩ ++ have huC : ContinuousAt u z₀ := huA.continuousAt ++ have hpre : {z : ℂ | ‖u z - u z₀‖ < 1} ∈ 𝓝 z₀ := by ++ have : u ⁻¹' Metric.ball (u z₀) (1 : ℝ) ∈ 𝓝 z₀ := ++ huC.preimage_mem_nhds (Metric.ball_mem_nhds (u z₀) (by norm_num)) ++ simpa [Metric.ball, dist_eq_norm, Set.preimage] using this ++ rcases Metric.mem_nhds_iff.1 hpre with ⟨r0, hr0pos, hr0sub⟩ ++ set r : ℝ := min (ε / 2) r0 ++ have hrpos : 0 < r := lt_min (by nlinarith [hε]) hr0pos ++ have hr_lt_ε : r < ε := lt_of_le_of_lt (min_le_left _ _) (by nlinarith [hε]) ++ have huBound : ∀ z ∈ Metric.ball z₀ r, ‖u z‖ ≤ ‖u z₀‖ + 1 := by ++ intro z hz ++ have hz0 : z ∈ Metric.ball z₀ r0 := by ++ have : r ≤ r0 := min_le_right _ _ ++ exact Metric.ball_subset_ball this hz ++ have hdiff : ‖u z - u z₀‖ < 1 := hr0sub hz0 ++ have htri : ‖u z‖ ≤ ‖u z - u z₀‖ + ‖u z₀‖ := by ++ simpa [sub_eq_add_neg, add_assoc] using ++ (norm_add_le (u z - u z₀) (u z₀)) ++ have : ‖u z‖ ≤ 1 + ‖u z₀‖ := le_trans htri (by nlinarith [le_of_lt hdiff]) ++ nlinarith [this] ++ have hdiffC : ++ DifferentiableOn ℂ (divisorComplementCanonicalProduct m f z₀) (Set.univ : Set ℂ) := ++ differentiableOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) (z₀ := z₀) h_sum ++ have hcontC : ContinuousOn (divisorComplementCanonicalProduct m f z₀) (Metric.closedBall z₀ r) := ++ (hdiffC.continuousOn).mono (by intro z hz; simp) ++ have hK : IsCompact (Metric.closedBall z₀ r) := isCompact_closedBall _ _ ++ rcases (isBounded_iff_forall_norm_le.1 (hK.image_of_continuousOn hcontC).isBounded) with ⟨C, hC⟩ ++ refine ⟨r, hrpos, ⟨C * (‖u z₀‖ + 1), ?_⟩⟩ ++ rintro _ ⟨z, hzset, rfl⟩ ++ rcases hzset with ⟨hzr, hzne⟩ ++ have hz_in_ε : z ∈ Metric.ball z₀ ε := Metric.ball_subset_ball hr_lt_ε.le hzr ++ have hz_ne : z ≠ z₀ := by simpa [Set.mem_singleton_iff] using hzne ++ have hq : ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card ++ = divisorComplementCanonicalProduct m f z₀ z * u z := ++ hEq z hz_in_ε hz_ne ++ have hCz : ‖divisorComplementCanonicalProduct m f z₀ z‖ ≤ C := by ++ have hzK : z ∈ Metric.closedBall z₀ r := Metric.mem_closedBall.2 (le_of_lt hzr) ++ exact hC _ ⟨z, hzK, rfl⟩ ++ have huZ : ‖u z‖ ≤ ‖u z₀‖ + 1 := huBound z hzr ++ have hCnonneg : 0 ≤ C := le_trans (norm_nonneg _) hCz ++ have hmul : ‖divisorComplementCanonicalProduct m f z₀ z * u z‖ ≤ C * (‖u z₀‖ + 1) := by ++ calc ++ ‖divisorComplementCanonicalProduct m f z₀ z * u z‖ ++ = ‖divisorComplementCanonicalProduct m f z₀ z‖ * ‖u z‖ := by simp ++ _ ≤ C * (‖u z₀‖ + 1) := by ++ exact mul_le_mul hCz huZ (norm_nonneg _) hCnonneg ++ simpa [Function.comp, hq] using hmul ++ ++theorem divisorComplementCanonicalProduct_ne_zero_at ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ divisorComplementCanonicalProduct m f z₀ z₀ ≠ 0 := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := ++ fun p => if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := fun p => Φ p - 1 ++ have hΦ_ne : ∀ p, Φ p ≠ 0 := by ++ intro p ++ by_cases hp : divisorZeroIndex₀Val p = z₀ ++ · simp [Φ, hp] ++ · have hval : divisorZeroIndex₀Val p ≠ z₀ := hp ++ have hz : z₀ / divisorZeroIndex₀Val p ≠ (1 : ℂ) := by ++ intro h ++ by_cases hp0 : divisorZeroIndex₀Val p = 0 ++ · have : z₀ / divisorZeroIndex₀Val p = (0 : ℂ) := by simp [hp0] ++ have h01 := h ++ rw [this] at h01 ++ exact (show False from (by simpa using (show (0 : ℂ) ≠ (1 : ℂ) from by simp) h01)) ++ · have : z₀ = divisorZeroIndex₀Val p := (div_eq_one_iff_eq hp0).1 h ++ exact hval this.symm ++ have hE : weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) ≠ 0 := by ++ intro h0 ++ have : z₀ / divisorZeroIndex₀Val p = (1 : ℂ) := ++ (weierstrassFactor_eq_zero_iff (m := m) (z := z₀ / divisorZeroIndex₀Val p)).1 h0 ++ exact hz this ++ simp [Φ, hp, hE] ++ have hz0_le : ‖z₀‖ ≤ max ‖z₀‖ 1 := le_max_left _ _ ++ set R : ℝ := max ‖z₀‖ 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (4 * R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) ++ have hu : Summable u := h_sum.mul_left (4 * R ^ (m + 1)) ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ++ 2 * R} : Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ have hBound : ++ ∀ᶠ p in Filter.cofinite, ‖a p‖ ≤ u p := by ++ filter_upwards [h_big] with p hp ++ have ha_pos : 0 < ‖divisorZeroIndex₀Val p‖ := lt_trans (by nlinarith [hRpos]) hp ++ have hz_div : ‖z₀ / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := by ++ have h2R_pos : 0 < (2 * R : ℝ) := by nlinarith [hRpos] ++ have hinv : ‖divisorZeroIndex₀Val p‖⁻¹ < (2 * R)⁻¹ := by ++ simpa [one_div] using (one_div_lt_one_div_of_lt h2R_pos hp) ++ have hmul_le : ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ ≤ R * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ refine mul_le_mul_of_nonneg_right ?_ (inv_nonneg.2 (norm_nonneg _)) ++ exact hz0_le ++ have hmul_lt : R * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ mul_lt_mul_of_pos_left hinv hRpos ++ have hlt : ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ lt_of_le_of_lt hmul_le hmul_lt ++ have hRhalf : R * (2 * R)⁻¹ = (1 / 2 : ℝ) := by ++ have hRne : (R : ℝ) ≠ 0 := hRpos.ne' ++ have : R * (2 * R)⁻¹ = R / (2 * R) := by simp [div_eq_mul_inv] ++ rw [this] ++ field_simp [hRne] ++ have hnorm : ‖z₀ / divisorZeroIndex₀Val p‖ = ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ have hzlt : ‖z₀ / divisorZeroIndex₀Val p‖ < (1 / 2 : ℝ) := by ++ calc ++ ‖z₀ / divisorZeroIndex₀Val p‖ = ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := hnorm ++ _ < R * (2 * R)⁻¹ := hlt ++ _ = (1 / 2 : ℝ) := hRhalf ++ exact le_of_lt hzlt ++ have hE : ++ ‖weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) - 1‖ ≤ ++ 4 * ‖z₀ / divisorZeroIndex₀Val p‖ ^ (m + 1) := ++ weierstrassFactor_sub_one_pow_bound (m := m) (z := z₀ / divisorZeroIndex₀Val p) hz_div ++ have hz_pow : ++ ‖z₀ / divisorZeroIndex₀Val p‖ ^ (m + 1) ≤ ++ (R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ have : ‖z₀ / divisorZeroIndex₀Val p‖ = ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ rw [this] ++ have : (‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹) ^ (m + 1) = ++ ‖z₀‖ ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simp [mul_pow] ++ rw [this] ++ have hzle_pow : ‖z₀‖ ^ (m + 1) ≤ R ^ (m + 1) := ++ pow_le_pow_left₀ (norm_nonneg z₀) hz0_le (m + 1) ++ gcongr ++ have hp_ne : divisorZeroIndex₀Val p ≠ z₀ := by ++ intro h ++ have : ‖divisorZeroIndex₀Val p‖ ≤ R := by ++ simp [h, R] ++ exact (not_lt_of_ge this) (lt_trans (by nlinarith [hRpos]) hp) ++ have ha : ‖a p‖ = ‖weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) - 1‖ := by ++ simp [a, Φ, hp_ne, sub_eq_add_neg] ++ calc ++ ‖a p‖ = ‖weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) - 1‖ := ha ++ _ ≤ 4 * ‖z₀ / divisorZeroIndex₀Val p‖ ^ (m + 1) := by ++ simpa [sub_eq_add_neg, add_comm] using hE ++ _ ≤ 4 * (R ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) := by ++ gcongr ++ _ = u p := by ++ simp [u, mul_assoc, mul_comm] ++ have hsum_norm : Summable (fun p => ‖a p‖) := by ++ refine (Summable.of_norm_bounded_eventually (E := ℝ) (f := fun p => ‖a p‖) (g := u) hu ?_) ++ filter_upwards [hBound] with p hp ++ simpa [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg (a p))] using hp ++ have htprod_ne : ++ (∏' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (1 + a p)) ≠ 0 := ++ tprod_one_add_ne_zero_of_summable (R := ℂ) (f := a) (hf := fun p => by ++ simpa [a, Φ, add_sub_cancel] using hΦ_ne p) hsum_norm ++ have : (∏' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (1 + a p)) = ++ divisorComplementCanonicalProduct m f z₀ z₀ := by ++ simp [a, Φ, divisorComplementCanonicalProduct, divisorComplementFactor_def] ++ exact by ++ intro h0 ++ exact htprod_ne (by simpa [this] using h0) ++ ++end Complex.Hadamard ++end HadamardSourceScope12 ++ ++section HadamardSourceScope13 ++ ++open Filter _root_.Function _root_.Complex _root_.Erdos970.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++theorem differentiableOn_divisorPartialProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) (k : ℕ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ DifferentiableOn ℂ (fun z : ℂ => (divisorPartialProduct m f s z) / (z - z₀) ^ k) ++ ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hdiff_prod : DifferentiableOn ℂ (divisorPartialProduct m f s) (Set.univ : Set ℂ) := by ++ exact (differentiable_divisorPartialProduct m f s).differentiableOn ++ have hdiff_den : DifferentiableOn ℂ (fun z : ℂ => (z - z₀) ^ k) ((Set.univ : Set ℂ) \ {z₀}) := by ++ have : Differentiable ℂ (fun z : ℂ => (z - z₀) ^ k) := by ++ fun_prop ++ exact this.differentiableOn ++ by_cases hk : k = 0 ++ · subst hk ++ simpa [pow_zero] using! (hdiff_prod.mono (by intro z hz; exact hz.1)) ++ · have hne : ∀ z ∈ ((Set.univ : Set ℂ) \ {z₀}), (fun z : ℂ => (z - z₀) ^ k) z ≠ 0 := by ++ intro z hz ++ have hz' : z ≠ z₀ := by ++ simpa [Set.mem_sdiff, Set.mem_singleton_iff] using hz.2 ++ exact pow_ne_zero _ (sub_ne_zero.mpr hz') ++ have hdiff_inv : ++ DifferentiableOn ℂ (fun z : ℂ => ((z - z₀) ^ k)⁻¹) ((Set.univ : Set ℂ) \ {z₀}) := ++ hdiff_den.inv hne ++ simpa [div_eq_mul_inv] using! (hdiff_prod.mono (by intro z hz; exact hz.1)).mul hdiff_inv ++ ++theorem differentiableOn_divisorCanonicalProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) (k : ℕ) : DifferentiableOn ℂ ++ (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ k) ++ ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hopen : IsOpen ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hset : ((Set.univ : Set ℂ) \ {z₀}) = ({z₀} : Set ℂ)ᶜ := by ++ ext z; simp ++ simp [hset] ++ have hconv := ++ tendstoLocallyUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m := m) (f := f) h_sum (z₀ := z₀) (k := k) ++ refine hconv.differentiableOn ?_ hopen ++ refine Filter.Eventually.of_forall ?_ ++ intro s ++ exact differentiableOn_divisorPartialProduct_div_pow_sub (m := m) (f := f) (z₀ := z₀) (k := k) s ++ ++theorem differentiableOn_update_limUnder_divisorCanonicalProduct_div_pow ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ∃ r > 0, DifferentiableOn ℂ (Function.update ++ (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) z₀ ++ (limUnder (𝓝[≠] z₀) (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card))) ++ (Metric.ball z₀ r) := by ++ rcases bddAbove_norm_divisorCanonicalProduct_div_pow_puncturedBall (m := m) (f := f) ++ (h_sum := h_sum) (z₀ := z₀) with ⟨r, hrpos, hbdd⟩ ++ refine ⟨r, hrpos, ?_⟩ ++ have hnhds : Metric.ball z₀ r ∈ 𝓝 z₀ := Metric.ball_mem_nhds z₀ hrpos ++ have hdiff : DifferentiableOn ℂ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ ((Metric.ball z₀ r) \ {z₀}) := by ++ have hglob := ++ differentiableOn_divisorCanonicalProduct_div_pow_sub ++ (m := m) (f := f) h_sum (z₀ := z₀) ++ (k := (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ refine hglob.mono ?_ ++ intro z hz ++ exact ⟨by simp, hz.2⟩ ++ have hb : BddAbove (norm ∘ (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) '' ++ ((Metric.ball z₀ r) \ {z₀})) := hbdd ++ simpa using ++ (Complex.differentiableOn_update_limUnder_of_bddAbove (f := fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ (s := Metric.ball z₀ r) (c := z₀) hnhds hdiff hb) ++ ++theorem analyticAt_update_limUnder_divisorCanonicalProduct_div_pow ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : AnalyticAt ℂ (Function.update (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) z₀ ++ (limUnder (𝓝[≠] z₀) (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card))) ++ z₀ := by ++ rcases ++ differentiableOn_update_limUnder_divisorCanonicalProduct_div_pow ++ (m := m) (f := f) h_sum (z₀ := z₀) with ⟨r, hrpos, hdiff⟩ ++ let g : ℂ → ℂ := ++ Function.update ++ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ z₀ ++ (limUnder (𝓝[≠] z₀) fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ have hcont : ContinuousAt g z₀ := ++ (hdiff.differentiableAt (Metric.ball_mem_nhds z₀ hrpos)).continuousAt ++ have hd : ++ ∀ᶠ z in 𝓝[≠] z₀, DifferentiableAt ℂ g z := by ++ have hballWithin : Metric.ball z₀ r ∈ 𝓝[≠] z₀ := by ++ refine mem_nhdsWithin_iff_exists_mem_nhds_inter.2 ?_ ++ refine ⟨Metric.ball z₀ r, Metric.ball_mem_nhds z₀ hrpos, ?_⟩ ++ intro z hz ++ exact hz.1 ++ filter_upwards [hballWithin] with z hz ++ exact (hdiff z hz).differentiableAt (Metric.isOpen_ball.mem_nhds hz) ++ simpa [g] using Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt hd hcont ++ ++theorem exists_analyticAt_divisorCanonicalProduct_quotient ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ ∃ q : ℂ → ℂ, ++ AnalyticAt ℂ q z₀ ∧ ++ q z₀ = ++ limUnder (𝓝[≠] z₀) (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ∧ ++ ∀ z : ℂ, z ≠ z₀ → ++ q z = ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ let q : ℂ → ℂ := ++ Function.update ++ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ z₀ ++ (limUnder (𝓝[≠] z₀) fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ refine ⟨q, ?_, ?_, ?_⟩ ++ · simpa [q] using ++ analyticAt_update_limUnder_divisorCanonicalProduct_div_pow ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀) ++ · simp [q] ++ · intro z hz ++ simp [q, Function.update_of_ne hz] ++ ++theorem analyticOrderNatAt_divisorCanonicalProduct_eq_fiber_card ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ set k : ℕ := (divisorZeroIndex₀FiberFinset (f := f) z₀).card ++ let F : ℂ → ℂ := divisorCanonicalProduct m f (Set.univ : Set ℂ) ++ let q0 : ℂ → ℂ := fun z => F z / (z - z₀) ^ k ++ rcases exists_analyticAt_divisorCanonicalProduct_quotient ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀) with ++ ⟨q, hqA, hq_self, hq_ne⟩ ++ have hdiff_univ : DifferentiableOn ℂ F (Set.univ : Set ℂ) := ++ differentiableOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ have han : AnalyticAt ℂ F z₀ := by ++ refine (Complex.analyticAt_iff_eventually_differentiableAt).2 ?_ ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ have : DifferentiableWithinAt ℂ F (Set.univ : Set ℂ) z := hdiff_univ z (by simp) ++ exact this.differentiableAt (by simp) ++ rcases ++ exists_ball_eq_divisorCanonicalProduct_div_pow_eq (m := m) (f := f) (h_sum := h_sum) ++ (z₀ := z₀) ++ with ⟨ε, hε, u, huA, hu0, hEq⟩ ++ let g : ℂ → ℂ := fun z => (divisorComplementCanonicalProduct m f z₀ z) * u z ++ have hcompDiff : DifferentiableOn ℂ (divisorComplementCanonicalProduct m f z₀) ++ (Set.univ : Set ℂ) := ++ differentiableOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) (z₀ := z₀) h_sum ++ have hcompCont : ContinuousAt (divisorComplementCanonicalProduct m f z₀) z₀ := ++ (hcompDiff z₀ (by simp)).differentiableAt (by simp) |>.continuousAt ++ have hgCont : ContinuousAt g z₀ := (hcompCont.mul huA.continuousAt) ++ have hg0 : g z₀ ≠ 0 := by ++ have hcomp0 : divisorComplementCanonicalProduct m f z₀ z₀ ≠ 0 := ++ divisorComplementCanonicalProduct_ne_zero_at (m := m) (f := f) (z₀ := z₀) h_sum ++ exact mul_ne_zero hcomp0 hu0 ++ have hne_mem : ∀ᶠ z in 𝓝[≠] z₀, z ∈ (({z₀} : Set ℂ)ᶜ) := ++ Filter.eventually_of_mem ++ (self_mem_nhdsWithin : (({z₀} : Set ℂ)ᶜ) ∈ 𝓝[≠] z₀) (fun _ hz => hz) ++ have hne : ∀ᶠ z in 𝓝[≠] z₀, z ≠ z₀ := by ++ filter_upwards [hne_mem] with z hz ++ simpa [Set.mem_compl_singleton_iff] using hz ++ have ht_q0 : Tendsto q0 (𝓝[≠] z₀) (𝓝 (g z₀)) := by ++ have hball : ∀ᶠ z in 𝓝[≠] z₀, z ∈ Metric.ball z₀ ε := ++ Filter.eventually_of_mem ++ (mem_nhdsWithin_of_mem_nhds (Metric.ball_mem_nhds z₀ hε)) (fun _ hz => hz) ++ have heq : q0 =ᶠ[𝓝[≠] z₀] g := by ++ filter_upwards [hball, hne] with z hz hzne ++ have hq := hEq z hz hzne ++ simpa [q0, F, k, g, smul_eq_mul] using hq ++ exact (hgCont.continuousWithinAt.tendsto.congr' heq.symm) ++ have hlim : limUnder (𝓝[≠] z₀) q0 = g z₀ := ht_q0.limUnder_eq ++ have hq0 : q z₀ ≠ 0 := by ++ have hq_self' : q z₀ = limUnder (𝓝[≠] z₀) q0 := by ++ simpa [q0, F, k] using hq_self ++ have : q z₀ = g z₀ := hq_self'.trans hlim ++ exact this.symm ▸ hg0 ++ have heq_punct : (fun z : ℂ => F z) =ᶠ[𝓝[≠] z₀] fun z : ℂ => (z - z₀) ^ k • q z := by ++ filter_upwards [hne] with z hz ++ have hzpow : (z - z₀) ^ k ≠ 0 := pow_ne_zero _ (sub_ne_zero.mpr hz) ++ have hq : q z = q0 z := by simpa [q0, F, k] using hq_ne z hz ++ have hmul : (z - z₀) ^ k * q0 z = F z := by ++ calc ++ (z - z₀) ^ k * q0 z ++ = (((z - z₀) ^ k) * F z) / ((z - z₀) ^ k) := by ++ simp [q0, div_eq_mul_inv, mul_assoc] ++ _ = F z := by ++ simpa [mul_assoc] using (mul_div_cancel_left₀ (F z) hzpow) ++ have : F z = (z - z₀) ^ k * q z := by ++ calc ++ F z = (z - z₀) ^ k * q0 z := hmul.symm ++ _ = (z - z₀) ^ k * q z := by simp [hq] ++ simpa [smul_eq_mul] using this ++ have hcontF : ContinuousAt F z₀ := ++ (hdiff_univ z₀ (by simp)).differentiableAt (by simp) |>.continuousAt ++ have hcontq : ContinuousAt q z₀ := hqA.continuousAt ++ have h_at_z0 : F z₀ = (z₀ - z₀) ^ k • q z₀ := by ++ have ht1 : Tendsto F (𝓝[≠] z₀) (𝓝 (F z₀)) := hcontF.continuousWithinAt.tendsto ++ have hpow : ++ Tendsto (fun z : ℂ => (z - z₀) ^ k) (𝓝[≠] z₀) (𝓝 ((z₀ - z₀) ^ k)) := ++ ((continuousAt_id.sub continuousAt_const).pow k).continuousWithinAt.tendsto ++ have ht2 : ++ Tendsto (fun z : ℂ => (z - z₀) ^ k • q z) (𝓝[≠] z₀) ++ (𝓝 ((z₀ - z₀) ^ k • q z₀)) := ++ hpow.mul (hcontq.continuousWithinAt.tendsto) ++ have ht2' : Tendsto F (𝓝[≠] z₀) (𝓝 ((z₀ - z₀) ^ k • q z₀)) := ++ ht2.congr' heq_punct.symm ++ exact tendsto_nhds_unique ht1 ht2' ++ have hfac : ∀ᶠ z in 𝓝 z₀, F z = (z - z₀) ^ k • q z := by ++ have hball1 : Metric.ball z₀ 1 ∈ 𝓝 z₀ := Metric.ball_mem_nhds z₀ (by norm_num) ++ have hball1' : ∀ᶠ z in 𝓝 z₀, z ∈ Metric.ball z₀ 1 := ++ Filter.eventually_of_mem hball1 (fun _ hz => hz) ++ filter_upwards [hball1'] with z _hz ++ by_cases hz0 : z = z₀ ++ · subst hz0 ++ simpa using h_at_z0 ++ · have hzpow : (z - z₀) ^ k ≠ 0 := pow_ne_zero _ (sub_ne_zero.mpr hz0) ++ have hq : q z = q0 z := by simpa [q0, F, k] using hq_ne z hz0 ++ have hmul : (z - z₀) ^ k * q0 z = F z := by ++ calc ++ (z - z₀) ^ k * q0 z ++ = (((z - z₀) ^ k) * F z) / ((z - z₀) ^ k) := by ++ simp [q0, div_eq_mul_inv, mul_assoc] ++ _ = F z := by ++ simpa [mul_assoc] using (mul_div_cancel_left₀ (F z) hzpow) ++ have : F z = (z - z₀) ^ k * q z := by ++ calc ++ F z = (z - z₀) ^ k * q0 z := hmul.symm ++ _ = (z - z₀) ^ k * q z := by simp [hq] ++ simpa [smul_eq_mul] using this ++ have hk' : analyticOrderAt F z₀ = k := ++ (han.analyticOrderAt_eq_natCast (n := k)).2 ⟨q, hqA, hq0, hfac⟩ ++ have hkNat : analyticOrderNatAt F z₀ = k := by ++ simp [analyticOrderNatAt, hk'] ++ simpa [F, k] using hkNat ++ ++theorem analyticOrderNatAt_divisorCanonicalProduct_eq_analyticOrderNatAt ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ {z₀ : ℂ} (hz₀ : z₀ ≠ 0) : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ analyticOrderNatAt f z₀ := by ++ have hcp : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card := ++ analyticOrderNatAt_divisorCanonicalProduct_eq_fiber_card (m := m) (f := f) (h_sum := h_sum) ++ (z₀ := z₀) ++ have hfib : ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = analyticOrderNatAt f z₀ := ++ divisorZeroIndex₀FiberFinset_card_eq_analyticOrderNatAt (hf := hf) (z₀ := z₀) hz₀ ++ simpa [hfib] using hcp ++ ++end Complex.Hadamard ++end HadamardSourceScope13 ++ ++section HadamardSourceScope14 ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++open scoped Topology ++open Set ++ ++lemma analyticOrderAt_ne_top_of_exists_ne_zero {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) : ++ ∀ z : ℂ, analyticOrderAt f z ≠ ⊤ := by ++ rcases hnot with ⟨z1, hz1⟩ ++ have hf_an : AnalyticOnNhd ℂ f (Set.univ : Set ℂ) := by ++ intro z hz ++ exact (Differentiable.analyticAt (f := f) hf z) ++ have hz1_not_top : analyticOrderAt f z1 ≠ ⊤ := by ++ have : analyticOrderAt f z1 = 0 := ++ (hf.analyticAt z1).analyticOrderAt_eq_zero.2 hz1 ++ simp [this] ++ intro z ++ exact AnalyticOnNhd.analyticOrderAt_ne_top_of_isPreconnected (hf := hf_an) ++ (U := (Set.univ : Set ℂ)) (x := z1) (y := z) (by simpa using isPreconnected_univ) ++ (by simp) (by simp) hz1_not_top ++ ++lemma no_zero_on_sphere_of_forall_val_norm_ne ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ {B r : ℝ} (hrpos : 0 < r) (hBr : r ≤ B) (hr_not : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖ ≤ B → r ≠ ‖divisorZeroIndex₀Val p‖) : ++ ∀ u : ℂ, ‖u‖ = r → f u ≠ 0 := by ++ intro u hur ++ have hu0 : u ≠ 0 := by ++ intro hu0 ++ subst hu0 ++ have : (0 : ℝ) = r := by simpa using hur ++ exact (ne_of_gt hrpos) this.symm ++ intro hfu0 ++ have hnotTop : analyticOrderAt f u ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (f := f) hf hnot u ++ have hord_ne0 : analyticOrderNatAt f u ≠ 0 := by ++ intro h0 ++ have hEN : (analyticOrderNatAt f u : ENat) = 0 := by simp [h0] ++ have hAt0 : analyticOrderAt f u = 0 := by ++ have hcast : (analyticOrderNatAt f u : ENat) = analyticOrderAt f u := ++ Nat.cast_analyticOrderNatAt (f := f) (z₀ := u) hnotTop ++ simpa [hcast] using hEN ++ have han : AnalyticAt ℂ f u := Differentiable.analyticAt (f := f) hf u ++ exact ((han.analyticOrderAt_eq_zero).1 hAt0) hfu0 ++ have hcard_pos : 0 < (divisorZeroIndex₀FiberFinset (f := f) u).card := by ++ have hcard := ++ divisorZeroIndex₀FiberFinset_card_eq_analyticOrderNatAt (hf := hf) (z₀ := u) hu0 ++ have : 0 < analyticOrderNatAt f u := Nat.pos_of_ne_zero hord_ne0 ++ simpa [hcard] using this ++ rcases Finset.card_pos.mp hcard_pos with ⟨p, hp⟩ ++ have hpval : divisorZeroIndex₀Val p = u := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := u) p).1 hp ++ have hpB : ‖divisorZeroIndex₀Val p‖ ≤ B := by ++ have : ‖divisorZeroIndex₀Val p‖ = r := by simp [hpval, hur] ++ simpa [this] using hBr ++ have : r ≠ ‖divisorZeroIndex₀Val p‖ := hr_not p hpB ++ exact this (by simp [hpval, hur]) ++ ++theorem analyticOrderAt_divisorCanonicalProduct_eq_fiber_card ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ let F : ℂ → ℂ := divisorCanonicalProduct m f (Set.univ : Set ℂ) ++ have hNat : ++ analyticOrderNatAt F z₀ = (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ simpa [F] using ++ (analyticOrderNatAt_divisorCanonicalProduct_eq_fiber_card ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀)) ++ have hdiffOn : DifferentiableOn ℂ F (Set.univ : Set ℂ) := by ++ simpa [F] using differentiableOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ have hdiff : Differentiable ℂ F := by ++ intro z ++ exact (hdiffOn z (by simp)).differentiableAt (by simp) ++ have hnotTop : analyticOrderAt F z₀ ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hdiff) ++ ⟨0, by simp [F, divisorCanonicalProduct_zero]⟩ z₀ ++ have hcast : (analyticOrderNatAt F z₀ : ℕ∞) = analyticOrderAt F z₀ := ++ Nat.cast_analyticOrderNatAt (f := F) (z₀ := z₀) hnotTop ++ have hNatCast : ++ (analyticOrderNatAt F z₀ : ℕ∞) = ++ ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ simp [hNat] ++ simpa [F, hcast] using hNatCast ++ ++theorem divisorCanonicalProduct_ne_zero_of_forall_ne ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ {z : ℂ} (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) : ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) z ≠ 0 := by ++ let F : ℂ → ℂ := divisorCanonicalProduct m f (Set.univ : Set ℂ) ++ have hfiber_empty : divisorZeroIndex₀FiberFinset (f := f) z = ∅ := by ++ ext p ++ constructor ++ · intro hp ++ exact False.elim (hz p ((mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z) p).1 hp).symm) ++ · intro hp ++ simp at hp ++ have horder : ++ analyticOrderAt F z = (0 : ℕ∞) := by ++ have h := ++ analyticOrderAt_divisorCanonicalProduct_eq_fiber_card ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z) ++ simpa [F, hfiber_empty] using h ++ have han : AnalyticAt ℂ F z := by ++ refine (Complex.analyticAt_iff_eventually_differentiableAt).2 ?_ ++ refine Filter.Eventually.of_forall ?_ ++ intro w ++ exact (((differentiableOn_divisorCanonicalProduct_univ m f h_sum) w ++ (by simp)).differentiableAt (by simp)) ++ exact (han.analyticOrderAt_eq_zero).1 horder ++ ++theorem logDeriv_divisorCanonicalProduct_one_eq_tsum_of_forall_ne ++ {f : ℂ → ℂ} {z : ℂ} ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ))) ++ (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) : ++ logDeriv (divisorCanonicalProduct 1 f (Set.univ : Set ℂ)) z = ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := ++ logDeriv_divisorCanonicalProduct_one_eq_tsum h_sum hz ++ (divisorCanonicalProduct_ne_zero_of_forall_ne 1 f h_sum hz) ++ ++end Hadamard ++end Complex ++end HadamardSourceScope14 ++ ++section HadamardSourceScope16 ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++open Filter Topology Set _root_.Complex _root_.Erdos970.Complex ++ ++open scoped BigOperators Topology ++ ++noncomputable def hadamardDenom (m : ℕ) (f : ℂ → ℂ) (z : ℂ) : ℂ := ++ z ^ (analyticOrderNatAt f 0) * divisorCanonicalProduct m f (Set.univ : Set ℂ) z ++ ++theorem differentiable_divisorCanonicalProduct_univ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ intro z ++ have hdiffOn : ++ DifferentiableOn ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) (Set.univ : Set ℂ) := ++ differentiableOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ exact (hdiffOn z (by simp)).differentiableAt (by simp) ++ ++theorem analyticAt_divisorCanonicalProduct_univ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) (z : ℂ) : ++ AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := ++ (differentiable_divisorCanonicalProduct_univ m f h_sum).analyticAt z ++ ++theorem differentiable_hadamardDenom (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ Differentiable ℂ (hadamardDenom m f) := by ++ have hcprod : Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ exact differentiable_divisorCanonicalProduct_univ m f h_sum ++ simpa [hadamardDenom] using! (differentiable_id.pow (analyticOrderNatAt f 0)).mul hcprod ++ ++theorem hadamardDenom_ne_zero_at {m : ℕ} {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) {z : ℂ} (hz : f z ≠ 0) : hadamardDenom m f z ≠ 0 := by ++ have hf_not_top : ∀ w : ℂ, analyticOrderAt f w ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hf) hnot ++ have han_f : AnalyticAt ℂ f z := hf.analyticAt z ++ have horder_f : analyticOrderNatAt f z = 0 := by ++ have : analyticOrderAt f z = 0 := (han_f.analyticOrderAt_eq_zero).2 hz ++ have hcast : (analyticOrderNatAt f z : ℕ∞) = analyticOrderAt f z := ++ Nat.cast_analyticOrderNatAt (f := f) (z₀ := z) (hf_not_top z) ++ have : (analyticOrderNatAt f z : ℕ∞) = 0 := by simp [hcast, this] ++ exact_mod_cast this ++ have han_cprod : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := by ++ exact analyticAt_divisorCanonicalProduct_univ m f h_sum z ++ by_cases hz0 : z = 0 ++ · subst hz0 ++ have hord0 : analyticOrderNatAt f 0 = 0 := by simpa using horder_f ++ simp [hadamardDenom, hord0, divisorCanonicalProduct_zero] ++ · have hp : z ^ (analyticOrderNatAt f 0) ≠ 0 := pow_ne_zero _ hz0 ++ have hcprod_order : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z = 0 := by ++ simpa [horder_f] using ++ (analyticOrderNatAt_divisorCanonicalProduct_eq_analyticOrderNatAt (m := m) (hf := hf) ++ (h_sum := h_sum) (z₀ := z) hz0) ++ have hcprod_ne : divisorCanonicalProduct m f (Set.univ : Set ℂ) z ≠ 0 := by ++ have hcprod_entire : ++ Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ exact differentiable_divisorCanonicalProduct_univ m f h_sum ++ have hcprod_not_top : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hcprod_entire) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ z ++ have hcprod_cast : ++ (analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z : ℕ∞) = ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := ++ Nat.cast_analyticOrderNatAt ++ (f := divisorCanonicalProduct m f (Set.univ : Set ℂ)) (z₀ := z) hcprod_not_top ++ have : analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z = 0 := by ++ have : ++ (analyticOrderNatAt ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z : ℕ∞) = 0 := by ++ exact_mod_cast hcprod_order ++ simp [hcprod_cast] at this ++ simpa using this ++ exact (han_cprod.analyticOrderAt_eq_zero).1 this ++ exact mul_ne_zero hp hcprod_ne ++ ++lemma analyticOrderNatAt_divisorCanonicalProduct_zero ++ (m : ℕ) (f : ℂ → ℂ) (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 = 0 := by ++ have hcprod_entire : ++ Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ exact differentiable_divisorCanonicalProduct_univ m f h_sum ++ have hcprod_not_top : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hcprod_entire) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ 0 ++ have hcprodA : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := ++ hcprod_entire.analyticAt 0 ++ have hcprod0 : divisorCanonicalProduct m f (Set.univ : Set ℂ) 0 ≠ 0 := by ++ simp [divisorCanonicalProduct_zero] ++ have : analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 = 0 := ++ (hcprodA.analyticOrderAt_eq_zero).2 hcprod0 ++ have hcast : ++ (analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 : ℕ∞) = ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := ++ Nat.cast_analyticOrderNatAt ++ (f := divisorCanonicalProduct m f (Set.univ : Set ℂ)) (z₀ := (0 : ℂ)) hcprod_not_top ++ have : ++ (analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 : ℕ∞) = ++ 0 := by ++ simp [hcast, this] ++ exact_mod_cast this ++ ++theorem analyticOrderNatAt_hadamardDenom_eq ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) (z : ℂ) : ++ analyticOrderNatAt (hadamardDenom m f) z = analyticOrderNatAt f z := by ++ by_cases hz0 : z = 0 ++ · subst hz0 ++ have hpowA : AnalyticAt ℂ (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 := by ++ simpa using! (analyticAt_id.pow (analyticOrderNatAt f 0)) ++ have hpow_not_top : ++ analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := (differentiable_id.pow (analyticOrderNatAt f 0))) ++ ⟨1, by simp⟩ 0 ++ have hcprodA : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := by ++ exact analyticAt_divisorCanonicalProduct_univ m f h_sum 0 ++ have hcprod0 : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 = 0 := ++ analyticOrderNatAt_divisorCanonicalProduct_zero (m := m) (f := f) h_sum ++ have hid0 : analyticOrderNatAt (fun z : ℂ => z) 0 = 1 := by ++ have hid_entire : Differentiable ℂ (fun z : ℂ => z) := differentiable_id ++ have hdiv : ++ (MeromorphicOn.divisor (fun z : ℂ => z) (Set.univ : Set ℂ)) 0 = ++ (analyticOrderNatAt (fun z : ℂ => z) 0 : ℤ) := by ++ simpa using ++ (divisor_univ_eq_analyticOrderNatAt_int ++ (f := fun z : ℂ => z) hid_entire 0) ++ have hdiv1 : (MeromorphicOn.divisor (fun z : ℂ => z) (Set.univ : Set ℂ)) 0 = 1 := by ++ simpa using ++ (MeromorphicOn.divisor_sub_const_self (z₀ := (0 : ℂ)) ++ (U := (Set.univ : Set ℂ)) (by simp)) ++ have : (analyticOrderNatAt (fun z : ℂ => z) 0 : ℤ) = 1 := by ++ simpa [hdiv] using hdiv1 ++ exact_mod_cast this ++ have hpow0 : ++ analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 = ++ analyticOrderNatAt f 0 := by ++ have hidA : AnalyticAt ℂ (fun z : ℂ => z) 0 := by ++ simpa [id] using! (analyticAt_id : AnalyticAt ℂ (id : ℂ → ℂ) 0) ++ simpa [hid0] using! (analyticOrderNatAt_pow (hf := hidA) (n := analyticOrderNatAt f 0)) ++ have hmul : ++ analyticOrderNatAt (hadamardDenom m f) 0 = ++ analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 + ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := by ++ have hcprod_not_top' : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := differentiable_divisorCanonicalProduct_univ m f h_sum) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ 0 ++ simpa [hadamardDenom] using! ++ analyticOrderNatAt_mul (hf := hpowA) (hg := hcprodA) ++ (hf' := hpow_not_top) (hg' := hcprod_not_top') ++ simp [hmul, hpow0, hcprod0] ++ · have hpowA : AnalyticAt ℂ (fun z : ℂ => z ^ analyticOrderNatAt f 0) z := by ++ simpa using! (analyticAt_id.pow (analyticOrderNatAt f 0)) ++ have hpow_not_top : ++ analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := (differentiable_id.pow (analyticOrderNatAt f 0))) ++ ⟨1, by simp⟩ z ++ have hpow0 : analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z = 0 := by ++ have hz' : (fun z : ℂ => z ^ analyticOrderNatAt f 0) z ≠ 0 := by ++ simp [hz0] ++ have : analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z = 0 := ++ ((hpowA).analyticOrderAt_eq_zero).2 hz' ++ have hcast : (analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z : ℕ∞) = ++ analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z := ++ Nat.cast_analyticOrderNatAt ++ (f := fun z : ℂ => z ^ analyticOrderNatAt f 0) (z₀ := z) hpow_not_top ++ have : (analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z : ℕ∞) = 0 := by ++ simp [hcast, this] ++ exact_mod_cast this ++ have hcprod_eq : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z = ++ analyticOrderNatAt f z := ++ analyticOrderNatAt_divisorCanonicalProduct_eq_analyticOrderNatAt ++ (m := m) (hf := hf) (h_sum := h_sum) (z₀ := z) hz0 ++ have hcprodA : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := by ++ exact analyticAt_divisorCanonicalProduct_univ m f h_sum z ++ have hcprod_not_top : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := differentiable_divisorCanonicalProduct_univ m f h_sum) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ z ++ have hmul : ++ analyticOrderNatAt (hadamardDenom m f) z = ++ analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z + ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := by ++ simpa [hadamardDenom] using! ++ analyticOrderNatAt_mul (hf := hpowA) (hg := hcprodA) ++ (hf' := hpow_not_top) (hg' := hcprod_not_top) ++ simp [hmul, hpow0, hcprod_eq] ++ ++theorem divisor_hadamardDenom_eq ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ) = ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) := by ++ ext z ++ have hden_entire : Differentiable ℂ (hadamardDenom m f) := ++ differentiable_hadamardDenom (m := m) f h_sum ++ have hf_entire : Differentiable ℂ f := hf ++ have hden : ++ (MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ)) z = ++ (analyticOrderNatAt (hadamardDenom m f) z : ℤ) := by ++ simpa using (divisor_univ_eq_analyticOrderNatAt_int (f := hadamardDenom m f) hden_entire z) ++ have hfz : ++ (MeromorphicOn.divisor f (Set.univ : Set ℂ)) z = ++ (analyticOrderNatAt f z : ℤ) := by ++ simpa using (divisor_univ_eq_analyticOrderNatAt_int (f := f) hf_entire z) ++ simp [hden, hfz, analyticOrderNatAt_hadamardDenom_eq (m := m) (hf := hf) (h_sum := h_sum) z] ++ ++theorem divisor_hadamardQuotient_eq_zero ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ MeromorphicOn.divisor (fun z : ℂ => f z / hadamardDenom m f z) (Set.univ : Set ℂ) = 0 := by ++ have hf_mero : MeromorphicOn f (Set.univ : Set ℂ) := by ++ intro z hz ++ exact (hf.analyticAt z).meromorphicAt ++ have hden_entire : Differentiable ℂ (hadamardDenom m f) := ++ differentiable_hadamardDenom (m := m) f h_sum ++ have hden_mero : MeromorphicOn (hadamardDenom m f) (Set.univ : Set ℂ) := by ++ intro z hz ++ exact (hden_entire.analyticAt z).meromorphicAt ++ rcases hnot with ⟨z1, hz1⟩ ++ have hden1 : hadamardDenom m f z1 ≠ 0 := ++ hadamardDenom_ne_zero_at (m := m) (f := f) hf ⟨z1, hz1⟩ h_sum hz1 ++ have hf_order_ne_top : ∀ z ∈ (Set.univ : Set ℂ), meromorphicOrderAt f z ≠ ⊤ := by ++ intro z hzU ++ have hz1_ne_top : meromorphicOrderAt f z1 ≠ ⊤ := by ++ have hfAt : MeromorphicAt f z1 := hf_mero z1 (by simp) ++ have hcont : ContinuousAt f z1 := (hf.differentiableAt).continuousAt ++ have hne_nhds : ∀ᶠ w in 𝓝 z1, f w ≠ 0 := ++ (hcont.ne_iff_eventually_ne continuousAt_const).1 hz1 ++ have hne_nhdsNE : ∀ᶠ w in 𝓝[≠] z1, f w ≠ 0 := ++ eventually_nhdsWithin_of_eventually_nhds hne_nhds ++ exact (meromorphicOrderAt_ne_top_iff_eventually_ne_zero (hf := hfAt)).2 hne_nhdsNE ++ exact MeromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected (hf := hf_mero) ++ (x := z1) (hU := isPreconnected_univ) (h₁x := by simp) (hy := by simp) hz1_ne_top ++ have hden_order_ne_top : ++ ∀ z ∈ (Set.univ : Set ℂ), meromorphicOrderAt (hadamardDenom m f) z ≠ ⊤ := by ++ intro z hzU ++ have hz1_ne_top : meromorphicOrderAt (hadamardDenom m f) z1 ≠ ⊤ := by ++ have hdenAt : MeromorphicAt (hadamardDenom m f) z1 := hden_mero z1 (by simp) ++ have hcont : ContinuousAt (hadamardDenom m f) z1 := ++ (hden_entire.differentiableAt).continuousAt ++ have hne_nhds : ∀ᶠ w in 𝓝 z1, hadamardDenom m f w ≠ 0 := ++ (hcont.ne_iff_eventually_ne continuousAt_const).1 hden1 ++ have hne_nhdsNE : ∀ᶠ w in 𝓝[≠] z1, hadamardDenom m f w ≠ 0 := ++ eventually_nhdsWithin_of_eventually_nhds hne_nhds ++ exact (meromorphicOrderAt_ne_top_iff_eventually_ne_zero (hf := hdenAt)).2 hne_nhdsNE ++ exact MeromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected (hf := hden_mero) ++ (x := z1) (hU := isPreconnected_univ) (h₁x := by simp) (hy := by simp) hz1_ne_top ++ have hinv_order_ne_top : ++ ∀ z ∈ (Set.univ : Set ℂ), ++ meromorphicOrderAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z ≠ ⊤ := by ++ intro z hzU ++ have hinv_mero : ++ MeromorphicOn (fun z : ℂ => (hadamardDenom m f z)⁻¹) (Set.univ : Set ℂ) := ++ hden_mero.inv ++ have hz1_ne_top : ++ meromorphicOrderAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 ≠ ⊤ := by ++ have hinvAt : MeromorphicAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 := ++ hinv_mero z1 (by simp) ++ have hcont_denom : ContinuousAt (hadamardDenom m f) z1 := ++ (hden_entire.differentiableAt).continuousAt ++ have hcont : ContinuousAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 := ++ hcont_denom.inv₀ hden1 ++ have hinv1 : (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 ≠ 0 := by ++ simpa using inv_ne_zero hden1 ++ have hne_nhds : ++ ∀ᶠ w in 𝓝 z1, (fun z : ℂ => (hadamardDenom m f z)⁻¹) w ≠ 0 := ++ (hcont.ne_iff_eventually_ne continuousAt_const).1 hinv1 ++ have hne_nhdsNE : ++ ∀ᶠ w in 𝓝[≠] z1, (fun z : ℂ => (hadamardDenom m f z)⁻¹) w ≠ 0 := ++ eventually_nhdsWithin_of_eventually_nhds hne_nhds ++ exact (meromorphicOrderAt_ne_top_iff_eventually_ne_zero (hf := hinvAt)).2 hne_nhdsNE ++ exact MeromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected (hf := hinv_mero) ++ (x := z1) (hU := isPreconnected_univ) (h₁x := by simp) (hy := by simp) hz1_ne_top ++ have hdiv_denom : MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ) = ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) := ++ divisor_hadamardDenom_eq (m := m) (hf := hf) (h_sum := h_sum) ++ calc ++ MeromorphicOn.divisor (fun z : ℂ => f z / hadamardDenom m f z) (Set.univ : Set ℂ) ++ = MeromorphicOn.divisor ++ (fun z : ℂ => f z * (hadamardDenom m f z)⁻¹) (Set.univ : Set ℂ) := by ++ simp [div_eq_mul_inv] ++ _ = MeromorphicOn.divisor f (Set.univ : Set ℂ) + ++ MeromorphicOn.divisor (fun z : ℂ => (hadamardDenom m f z)⁻¹) (Set.univ : Set ℂ) := by ++ simpa using (MeromorphicOn.divisor_fun_mul (U := (Set.univ : Set ℂ)) ++ (f₁ := f) (f₂ := fun z => (hadamardDenom m f z)⁻¹) hf_mero (hden_mero.inv) ++ hf_order_ne_top hinv_order_ne_top) ++ _ = MeromorphicOn.divisor f (Set.univ : Set ℂ) - ++ MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ) := by ++ simp [sub_eq_add_neg] ++ _ = 0 := by ++ simp [hdiv_denom] ++ ++theorem exists_entire_nonzero_hadamardQuotient ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ ∃ H : ℂ → ℂ, Differentiable ℂ H ∧ (∀ z, H z ≠ 0) ∧ ∀ z : ℂ, f z = ++ H z * z ^ (analyticOrderNatAt f 0) * divisorCanonicalProduct m f (Set.univ : Set ℂ) z := by ++ let denom : ℂ → ℂ := hadamardDenom m f ++ let q : ℂ → ℂ := fun z => f z / denom z ++ have hden_entire : Differentiable ℂ denom := ++ differentiable_hadamardDenom (m := m) f h_sum ++ have hq_mero : MeromorphicOn q (Set.univ : Set ℂ) := by ++ intro z hzU ++ have hf_m : MeromorphicAt f z := (hf.analyticAt z).meromorphicAt ++ have hden_m : MeromorphicAt denom z := (hden_entire.analyticAt z).meromorphicAt ++ simpa [q, denom, div_eq_mul_inv] using! (hf_m.mul hden_m.inv) ++ let H : ℂ → ℂ := toMeromorphicNFOn q (Set.univ : Set ℂ) ++ have hNF : MeromorphicNFOn H (Set.univ : Set ℂ) := ++ meromorphicNFOn_toMeromorphicNFOn q (Set.univ : Set ℂ) ++ have hdivH : MeromorphicOn.divisor H (Set.univ : Set ℂ) = 0 := by ++ have hdivq : MeromorphicOn.divisor q (Set.univ : Set ℂ) = 0 := ++ divisor_hadamardQuotient_eq_zero (m := m) (f := f) (hf := hf) ++ (hnot := hnot) (h_sum := h_sum) ++ simpa [H, hdivq] using ++ (MeromorphicOn.divisor_of_toMeromorphicNFOn ++ (f := q) (U := (Set.univ : Set ℂ)) hq_mero) ++ have hA : AnalyticOnNhd ℂ H (Set.univ : Set ℂ) := by ++ have : ++ (0 : Function.locallyFinsuppWithin (Set.univ : Set ℂ) ℤ) ≤ ++ MeromorphicOn.divisor H (Set.univ : Set ℂ) := by ++ simp [hdivH] ++ exact (MeromorphicNFOn.divisor_nonneg_iff_analyticOnNhd (h₁f := hNF)).1 (by simp [hdivH]) ++ have hH_entire : Differentiable ℂ H := by ++ intro z ++ exact (hA z (by simp)).differentiableAt ++ rcases hnot with ⟨z1, hz1⟩ ++ have hden1 : denom z1 ≠ 0 := ++ hadamardDenom_ne_zero_at (m := m) (f := f) hf ⟨z1, hz1⟩ h_sum hz1 ++ have hqA1 : AnalyticAt ℂ q z1 := by ++ have hdenA1 : AnalyticAt ℂ denom z1 := hden_entire.analyticAt z1 ++ exact (hf.analyticAt z1).div hdenA1 hden1 ++ have hqNF1 : MeromorphicNFAt q z1 := hqA1.meromorphicNFAt ++ have htoEq : toMeromorphicNFAt q z1 = q := (toMeromorphicNFAt_eq_self (f := q) (x := z1)).2 hqNF1 ++ have hH1 : H z1 = q z1 := by ++ have hx : z1 ∈ (Set.univ : Set ℂ) := by simp ++ have : toMeromorphicNFOn q (Set.univ : Set ℂ) z1 = toMeromorphicNFAt q z1 z1 := ++ (toMeromorphicNFOn_eq_toMeromorphicNFAt (f := q) (U := (Set.univ : Set ℂ)) hq_mero hx) ++ simpa [H, htoEq] using this ++ have hH1_ne : H z1 ≠ 0 := by ++ have : q z1 ≠ 0 := div_ne_zero hz1 hden1 ++ simpa [hH1] using this ++ have hH_not_top : ∀ z : ℂ, analyticOrderAt H z ≠ ⊤ := by ++ exact analyticOrderAt_ne_top_of_exists_ne_zero (hf := hH_entire) ⟨z1, hH1_ne⟩ ++ have hH_orderNat_zero : ∀ z : ℂ, analyticOrderNatAt H z = 0 := by ++ intro z ++ have hzdiv : ++ (MeromorphicOn.divisor H (Set.univ : Set ℂ)) z = (analyticOrderNatAt H z : ℤ) := by ++ simpa using (divisor_univ_eq_analyticOrderNatAt_int (f := H) hH_entire z) ++ have : (MeromorphicOn.divisor H (Set.univ : Set ℂ)) z = 0 := by ++ simp [hdivH] ++ have : (analyticOrderNatAt H z : ℤ) = 0 := by simpa [hzdiv] using this ++ exact_mod_cast this ++ have hH_ne : ∀ z : ℂ, H z ≠ 0 := by ++ intro z ++ have hcast : (analyticOrderNatAt H z : ℕ∞) = analyticOrderAt H z := ++ Nat.cast_analyticOrderNatAt (f := H) (z₀ := z) (hH_not_top z) ++ have : analyticOrderAt H z = 0 := by ++ have : (analyticOrderNatAt H z : ℕ∞) = 0 := by exact_mod_cast (hH_orderNat_zero z) ++ simpa [hcast] using this ++ exact ((hA z (by simp)).analyticOrderAt_eq_zero).1 this ++ have hfA : AnalyticOnNhd ℂ f (Set.univ : Set ℂ) := fun z hzU => hf.analyticAt z ++ have hdenA : AnalyticOnNhd ℂ denom (Set.univ : Set ℂ) := fun z hzU => hden_entire.analyticAt z ++ have hprodA : AnalyticOnNhd ℂ (fun z => H z * denom z) (Set.univ : Set ℂ) := ++ (hA.mul hdenA) ++ have hlocal : f =ᶠ[𝓝 z1] fun z => H z * denom z := by ++ have hden_ne : ∀ᶠ z in 𝓝 z1, denom z ≠ 0 := ++ (hden_entire.differentiableAt.continuousAt.ne_iff_eventually_ne continuousAt_const).1 hden1 ++ have hH_eq_q : H =ᶠ[𝓝 z1] q := by ++ have hx : z1 ∈ (Set.univ : Set ℂ) := by simp ++ have hloc : ++ toMeromorphicNFOn q (Set.univ : Set ℂ) =ᶠ[𝓝 z1] toMeromorphicNFAt q z1 := by ++ simpa [H] using (toMeromorphicNFOn_eq_toMeromorphicNFAt_on_nhds (f := q) ++ (U := (Set.univ : Set ℂ)) hq_mero hx) ++ simpa [H, htoEq] using hloc ++ filter_upwards [hden_ne, hH_eq_q] with z hzden hHz ++ have hcancel : q z * denom z = f z := by ++ dsimp [q] ++ field_simp [hzden] ++ calc ++ f z = q z * denom z := hcancel.symm ++ _ = H z * denom z := by simp [hHz] ++ have hglob : f = fun z => H z * denom z := ++ AnalyticOnNhd.eq_of_eventuallyEq (hf := hfA) (hg := hprodA) hlocal ++ refine ⟨H, hH_entire, hH_ne, ?_⟩ ++ intro z ++ have hglobz : f z = H z * denom z := congrArg (fun g => g z) hglob ++ simpa [denom, hadamardDenom, mul_assoc, mul_left_comm, mul_comm] using hglobz ++ ++end Complex.Hadamard ++end HadamardSourceScope16 ++ ++section HadamardSourceScope17 ++ ++open Filter _root_.Function _root_.MeromorphicOn _root_.Erdos970.MeromorphicOn Metric ++ _root_.Real _root_.Erdos970.Real Set ++ ++namespace Function.locallyFinsuppWithin ++ ++open _root_.Function.locallyFinsuppWithin ++ ++variable {E : Type*} [NormedAddCommGroup E] ++ ++lemma norm_le_abs_of_mem_toClosedBall_support {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} ++ (hz : z ∈ (toClosedBall r D).support) : ‖z‖ ≤ |r| := by ++ have hz_ball : z ∈ closedBall (0 : E) |r| := (toClosedBall r D).supportWithinDomain hz ++ simpa [mem_closedBall, dist_zero_right] using hz_ball ++ ++lemma toClosedBall_eval_eq_of_norm_le_abs {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} ++ (hz : ‖z‖ ≤ |r|) : toClosedBall r D z = D z := by ++ have hz_ball : z ∈ closedBall (0 : E) |r| := by ++ simpa [mem_closedBall, dist_zero_right] using hz ++ simpa using toClosedBall_eval_within (f := D) hz_ball ++ ++lemma mem_toClosedBall_support_of_mem_support_of_norm_le_abs ++ {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} (hzD : z ∈ D.support) (hzR : ‖z‖ ≤ |r|) : ++ z ∈ (toClosedBall r D).support := by ++ rw [Function.mem_support] ++ rw [toClosedBall_eval_eq_of_norm_le_abs hzR] ++ rwa [Function.mem_support] at hzD ++ ++lemma mem_support_of_mem_toClosedBall_support {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} ++ (hz : z ∈ (toClosedBall r D).support) : z ∈ D.support := by ++ have hnorm : ‖z‖ ≤ |r| := norm_le_abs_of_mem_toClosedBall_support hz ++ rw [Function.mem_support] at hz ⊢ ++ rw [toClosedBall_eval_eq_of_norm_le_abs hnorm] at hz ++ exact hz ++ ++noncomputable def massClosedBall₀ {E : Type*} [NormedAddCommGroup E] [ProperSpace E] ++ (D : locallyFinsupp E ℤ) (R : ℝ) : ℝ := by ++ classical ++ exact ++ (((finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).toFinset).filter ++ (fun z => z ≠ (0 : E))).sum fun z => (D z : ℝ) ++ ++end Function.locallyFinsuppWithin ++ ++namespace Function.locallyFinsuppWithin ++ ++open _root_.Function.locallyFinsuppWithin ++ ++theorem logCounting_divisor_eq_circleAverage_sub_const_of_differentiable ++ {R : ℝ} {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hR : R ≠ 0) : ++ logCounting (divisor f ⊤) R = ++ circleAverage (log ‖f ·‖) 0 R - log ‖meromorphicTrailingCoeffAt f 0‖ := by ++ have hmero : Meromorphic f := fun z => (hf.analyticAt z).meromorphicAt ++ simpa [top_eq_univ] using ++ logCounting_divisor_eq_circleAverage_sub_const (f := f) hmero hR ++ ++end Function.locallyFinsuppWithin ++end HadamardSourceScope17 ++ ++section HadamardSourceScope18 ++ ++namespace Real ++ ++open _root_.Real ++ ++theorem log_one_add_exp_le_add_log_two {x : ℝ} (hx : 0 ≤ x) : ++ log (1 + exp x) ≤ x + log 2 := by ++ have hexp_one : (1 : ℝ) ≤ exp x := by ++ simpa using (one_le_exp_iff.2 hx) ++ have hadd : 1 + exp x ≤ 2 * exp x := by linarith ++ have hlog : log (1 + exp x) ≤ log (2 * exp x) := ++ log_le_log (by positivity) hadd ++ calc ++ log (1 + exp x) ≤ log (2 * exp x) := hlog ++ _ = log 2 + x := by simp [log_mul, add_comm] ++ _ = x + log 2 := by ring ++ ++theorem log_one_add_le_add_log_two_of_le_exp {x y : ℝ} (hy : 0 ≤ y) (hx : 0 ≤ x) ++ (hxy : y ≤ exp x) : ++ log (1 + y) ≤ x + log 2 := by ++ have hpos : 0 < (1 : ℝ) + y := by linarith ++ have hle : (1 : ℝ) + y ≤ 1 + exp x := by linarith ++ exact (log_le_log hpos hle).trans (log_one_add_exp_le_add_log_two hx) ++ ++theorem le_exp_of_log_one_add_le {x y : ℝ} (hy : 0 ≤ y) (hxy : log (1 + y) ≤ x) : ++ y ≤ exp x := by ++ have hpos : 0 < (1 : ℝ) + y := by linarith ++ have hone : 1 + y ≤ exp x := (log_le_iff_le_exp hpos).1 hxy ++ linarith ++ ++theorem neg_posLog_inv_le_log (x : ℝ) : -log⁺ x⁻¹ ≤ log x := by ++ linarith [posLog_sub_posLog_inv (x := x), posLog_nonneg (x := x)] ++ ++end Real ++end HadamardSourceScope18 ++ ++section HadamardSourceScope20 ++ ++namespace Real ++ ++open _root_.Real ++ ++variable {α E : Type*} [SeminormedAddCommGroup E] ++ ++theorem log_norm_le_log_one_add_norm (w : E) : ++ Real.log ‖w‖ ≤ Real.log (1 + ‖w‖) := by ++ by_cases h0 : ‖w‖ = 0 ++ · simp [h0] ++ · have hpos : 0 < ‖w‖ := lt_of_le_of_ne (norm_nonneg w) (Ne.symm h0) ++ exact Real.log_le_log hpos (by linarith [norm_nonneg w]) ++ ++variable {F : Type*} [NormedAddCommGroup F] ++ ++theorem log_nonneg_mul_inv_norm_of_norm_le {z : F} {r : ℝ} (hz : ‖z‖ ≤ r) : ++ 0 ≤ Real.log (r * ‖z‖⁻¹) := by ++ by_cases hz0 : z = 0 ++ · simp [hz0] ++ · have hzpos : 0 < ‖z‖ := norm_pos_iff.2 hz0 ++ have : (1 : ℝ) ≤ r * ‖z‖⁻¹ := by ++ have : (1 : ℝ) ≤ r / ‖z‖ := (one_le_div hzpos).2 hz ++ simpa [div_eq_mul_inv] using this ++ exact Real.log_nonneg this ++ ++theorem log_two_le_log_two_mul_mul_inv_norm_of_norm_le {z : F} {R : ℝ} (hz0 : z ≠ 0) ++ (hz : ‖z‖ ≤ R) : ++ Real.log 2 ≤ Real.log ((2 * R) * ‖z‖⁻¹) := by ++ have hzpos : 0 < ‖z‖ := norm_pos_iff.2 hz0 ++ have hRdiv : (1 : ℝ) ≤ R / ‖z‖ := (one_le_div hzpos).2 hz ++ have hle2 : (2 : ℝ) ≤ (2 * R) * ‖z‖⁻¹ := by ++ have : (2 : ℝ) ≤ 2 * (R / ‖z‖) := by nlinarith ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using this ++ exact Real.log_le_log (by norm_num) hle2 ++ ++theorem norm_le_exp_mul_rpow_of_exponent_le ++ {f : α → E} {r : α → ℝ} {C ρ τ : ℝ} (hC : 0 ≤ C) (hr : ∀ x, 1 ≤ r x) (hρτ : ρ ≤ τ) ++ (hbound : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ ρ)) : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ) := by ++ intro x ++ refine (hbound x).trans (Real.exp_le_exp.2 ?_) ++ exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le (hr x) hρτ) hC ++ ++theorem norm_le_exp_mul_rpow_of_log_growth ++ {f : α → E} {r : α → ℝ} {C ρ τ : ℝ} (hC : 0 ≤ C) (hr : ∀ x, 1 ≤ r x) (hρτ : ρ ≤ τ) ++ (hlog : ∀ x, Real.log (1 + ‖f x‖) ≤ C * (r x) ^ ρ) : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ) := by ++ intro x ++ have hpow : (r x) ^ ρ ≤ (r x) ^ τ := ++ Real.rpow_le_rpow_of_exponent_le (hr x) hρτ ++ have hlogτ : Real.log (1 + ‖f x‖) ≤ C * (r x) ^ τ := ++ (hlog x).trans (mul_le_mul_of_nonneg_left hpow hC) ++ exact Real.le_exp_of_log_one_add_le (norm_nonneg (f x)) hlogτ ++ ++theorem log_growth_of_norm_le_exp_mul_rpow ++ {f : α → E} {r : α → ℝ} {C τ : ℝ} (hC : 0 < C) (hτ : 0 ≤ τ) ++ (hr : ∀ x, 1 ≤ r x) (hbound : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ)) : ++ ∃ C' > 0, ∀ x, Real.log (1 + ‖f x‖) ≤ C' * (r x) ^ τ := by ++ refine ⟨C + Real.log 2, by ++ have hlog2 : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) ++ linarith, ?_⟩ ++ intro x ++ have hX : (1 : ℝ) ≤ (r x) ^ τ := Real.one_le_rpow (hr x) hτ ++ have hB : 0 ≤ C * (r x) ^ τ := ++ mul_nonneg hC.le (Real.rpow_nonneg (le_trans zero_le_one (hr x)) _) ++ have hlog : ++ Real.log (1 + ‖f x‖) ≤ C * (r x) ^ τ + Real.log 2 := ++ Real.log_one_add_le_add_log_two_of_le_exp (norm_nonneg _) hB (hbound x) ++ have hlog2_nonneg : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) ++ nlinarith [hlog, hX, hlog2_nonneg] ++ ++theorem exists_norm_le_exp_mul_pow_of_rpow_bound ++ {f : α → E} {r : α → ℝ} {τ : ℝ} {n : ℕ} (hr : ∀ x, 1 ≤ r x) (hτn : τ < (n : ℝ)) ++ (hbound : ∃ C > 0, ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ)) : ++ ∃ C > 0, ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ n) := by ++ rcases hbound with ⟨C, hCpos, hC⟩ ++ have hweak : ++ ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ (n : ℝ)) := ++ norm_le_exp_mul_rpow_of_exponent_le ++ (f := f) (r := r) hCpos.le hr (le_of_lt hτn) hC ++ refine ⟨C, hCpos, ?_⟩ ++ intro x ++ have hpow : (r x) ^ (n : ℝ) = (r x) ^ n := Real.rpow_natCast (r x) n ++ simpa [hpow] using hweak x ++ ++theorem one_add_le_three_mul_one_add_of_le_two_mul_max {x r : ℝ} (hx : 0 ≤ x) ++ (hr : r ≤ 2 * max x 1) : 1 + r ≤ 3 * (1 + x) := by ++ have hmax : max x 1 ≤ 1 + x := max_le_iff.2 ⟨by linarith, by linarith⟩ ++ nlinarith ++ ++theorem exp_mul_rpow_le_exp_mul_rpow_of_le_mul ++ {A B x y τ : ℝ} (hA : 0 ≤ A) (hB : 0 ≤ B) (hx : 0 ≤ x) (hy : 0 ≤ y) ++ (hτ : 0 ≤ τ) (hxy : x ≤ B * y) : Real.exp (A * x ^ τ) ≤ Real.exp ((A * B ^ τ) * y ^ τ) := by ++ refine Real.exp_le_exp.2 ?_ ++ have hpow : x ^ τ ≤ (B * y) ^ τ := Real.rpow_le_rpow hx hxy hτ ++ have hsplit : (B * y) ^ τ = B ^ τ * y ^ τ := by ++ simpa using (Real.mul_rpow (x := B) (y := y) (z := τ) hB hy) ++ simpa [mul_assoc] using mul_le_mul_of_nonneg_left (hpow.trans_eq hsplit) hA ++ ++theorem exists_between_self_and_floor_add_one_same_floor {ρ : ℝ} (hρ : 0 ≤ ρ) : ++ ∃ τ : ℝ, ρ < τ ∧ τ < (Nat.floor ρ + 1 : ℝ) ∧ 0 ≤ τ ∧ Nat.floor τ = Nat.floor ρ := by ++ set m : ℕ := Nat.floor ρ ++ set τ : ℝ := (ρ + (m + 1 : ℝ)) / 2 ++ have hm : ρ < (m + 1 : ℝ) := by simpa [m] using Nat.lt_floor_add_one (a := ρ) ++ have hτ : ρ < τ := by dsimp [τ]; linarith ++ have hτ_lt : τ < (m + 1 : ℝ) := by dsimp [τ]; linarith ++ have hτ_nonneg : 0 ≤ τ := le_trans hρ (le_of_lt hτ) ++ have hfloorτ : Nat.floor τ = m := by ++ have hm_le_τ : (m : ℝ) ≤ τ := le_trans (Nat.floor_le hρ) (le_of_lt hτ) ++ have hτ_lt_m1 : τ < (m : ℝ) + 1 := by simpa [add_assoc, add_comm, add_left_comm] using hτ_lt ++ exact (Nat.floor_eq_iff hτ_nonneg).2 ⟨hm_le_τ, hτ_lt_m1⟩ ++ exact ⟨τ, hτ, by simpa [m] using hτ_lt, hτ_nonneg, by simpa [m] using hfloorτ⟩ ++ ++open Metric _root_.Complex _root_.Erdos970.Complex ++ ++theorem log_norm_le_of_log_one_add_growth_on_sphere {f : ℂ → ℂ} {C ρ R : ℝ} ++ (hC : ∀ z : ℂ, _root_.Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) {z : ℂ} ++ (hz : z ∈ sphere (0 : ℂ) |R|) : _root_.Real.log ‖f z‖ ≤ C * (1 + |R|) ^ ρ := by ++ have hz_norm : ‖z‖ = |R| := by ++ simpa [mem_sphere, dist_zero_right] using hz ++ simpa [hz_norm] using le_trans (log_norm_le_log_one_add_norm (f z)) (hC z) ++ ++end Real ++end HadamardSourceScope20 ++ ++section HadamardSourceScope21 ++ ++open Filter _root_.Function _root_.Erdos970.Function _root_.MeromorphicOn ++ _root_.Erdos970.MeromorphicOn Metric _root_.Real _root_.Erdos970.Real Set ++ ++namespace Function.locallyFinsuppWithin ++ ++open _root_.Function.locallyFinsuppWithin ++ ++theorem logCounting_divisor_le_of_log_growth {f : ℂ → ℂ} {ρ C : ℝ} (hf : Differentiable ℂ f) ++ (hC : ∀ z : ℂ, log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) {R : ℝ} (hR0 : 0 < R) : ++ logCounting (divisor f (Set.univ : Set ℂ)) R ++ ≤ C * (1 + |R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ have hR : R ≠ 0 := ne_of_gt hR0 ++ have hEq := ++ logCounting_divisor_eq_circleAverage_sub_const_of_differentiable (f := f) hf hR ++ have hf_sphere : MeromorphicOn f (sphere (0 : ℂ) |R|) := by ++ intro z hz ++ exact (hf.analyticAt z).meromorphicAt ++ have hInt : CircleIntegrable (fun z : ℂ => log ‖f z‖) 0 R := ++ MeromorphicOn.circleIntegrable_log_norm hf_sphere ++ have hbound_circle : ∀ z ∈ sphere (0 : ℂ) |R|, ++ log ‖f z‖ ≤ C * (1 + |R|) ^ ρ := by ++ intro z hz ++ exact log_norm_le_of_log_one_add_growth_on_sphere hC hz ++ have hCircleAvg_le : ++ circleAverage (fun z : ℂ => log ‖f z‖) 0 R ≤ C * (1 + |R|) ^ ρ := ++ circleAverage_mono_on_of_le_circle (c := (0 : ℂ)) (R := R) ++ (f := fun z => log ‖f z‖) hInt hbound_circle ++ calc ++ logCounting (divisor f (Set.univ : Set ℂ)) R ++ = circleAverage (fun z : ℂ => log ‖f z‖) 0 R ++ - log ‖meromorphicTrailingCoeffAt f 0‖ := by ++ simpa [top_eq_univ] using hEq ++ _ ≤ circleAverage (fun z : ℂ => log ‖f z‖) 0 R ++ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ have : ++ -log ‖meromorphicTrailingCoeffAt f 0‖ ++ ≤ |log ‖meromorphicTrailingCoeffAt f 0‖| := ++ neg_le_abs (log ‖meromorphicTrailingCoeffAt f 0‖) ++ linarith ++ _ ≤ C * (1 + |R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ nlinarith [hCircleAvg_le] ++ ++variable {E : Type*} [NormedAddCommGroup E] [ProperSpace E] ++ ++theorem log_two_mul_massClosedBall₀_le_logCounting {D : locallyFinsupp E ℤ} (hDnonneg : 0 ≤ D) ++ {R : ℝ} (hR : 1 ≤ R) : ++ (log 2) * massClosedBall₀ D R ≤ logCounting D (2 * R) := by ++ classical ++ have hR0 : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR ++ set r : ℝ := 2 * R ++ have hrpos : 0 < r := by dsimp [r]; nlinarith ++ let Dr := toClosedBall r D ++ have hDr_fin : Set.Finite Dr.support := Dr.finiteSupport (isCompact_closedBall (0 : E) |r|) ++ let F : Finset E := hDr_fin.toFinset ++ let SR : Finset E := ++ (finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).toFinset ++ let S : Finset E := SR.filter fun z => z ≠ (0 : E) ++ have hS_sub : S ⊆ F := by ++ intro z hzS ++ have hz_mem_SR : z ∈ SR := (Finset.mem_filter.1 hzS).1 ++ have hzR : z ∈ (toClosedBall R D).support := by ++ exact (finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).mem_toFinset.1 ++ hz_mem_SR ++ have hz_norm_le_R : ‖z‖ ≤ R := by ++ have := norm_le_abs_of_mem_toClosedBall_support hzR ++ simpa [abs_of_pos hR0] using this ++ have hz_norm_le_r : ‖z‖ ≤ |r| := by ++ have : ‖z‖ ≤ r := le_trans hz_norm_le_R (by dsimp [r]; nlinarith) ++ simpa [abs_of_pos hrpos] using this ++ have hzD : z ∈ D.support := mem_support_of_mem_toClosedBall_support hzR ++ have : z ∈ Dr.support := by ++ simpa [Dr] using ++ mem_toClosedBall_support_of_mem_support_of_norm_le_abs (D := D) (r := r) hzD hz_norm_le_r ++ exact hDr_fin.mem_toFinset.2 this ++ have hlogCounting : ++ logCounting D r ++ = (F.sum fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) + (D 0 : ℝ) * log r := by ++ have hsupp : Function.support (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) ⊆ F := by ++ intro z hz ++ have : Dr z ≠ 0 := by ++ by_contra h0 ++ simp [Function.mem_support, h0] at hz ++ have : z ∈ Dr.support := by simpa [Function.mem_support] using this ++ exact hDr_fin.mem_toFinset.2 this ++ simp [logCounting, Dr, r, ++ finsum_eq_sum_of_support_subset (f := fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) (s := F) hsupp] ++ have hsum_le : ++ (log 2) * (S.sum fun z => (D z : ℝ)) ++ ≤ F.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := by ++ have hterm_nonneg : ∀ z ∈ F, 0 ≤ (Dr z : ℝ) * log (r * ‖z‖⁻¹) := by ++ intro z hzF ++ have hz_sup : z ∈ Dr.support := hDr_fin.mem_toFinset.1 hzF ++ have hDz : 0 ≤ Dr z := by ++ have hDz' : 0 ≤ D z := hDnonneg z ++ have hDrz : Dr z = D z := ++ toClosedBall_eval_eq_of_norm_le_abs (norm_le_abs_of_mem_toClosedBall_support hz_sup) ++ simpa [hDrz] using hDz' ++ have hlog : 0 ≤ log (r * ‖z‖⁻¹) := by ++ have hzle : ‖z‖ ≤ r := by ++ have hnorm := norm_le_abs_of_mem_toClosedBall_support hz_sup ++ simpa [abs_of_pos hrpos] using hnorm ++ exact log_nonneg_mul_inv_norm_of_norm_le hzle ++ exact mul_nonneg (by exact_mod_cast hDz) hlog ++ have hsumSF : ++ S.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) ++ ≤ F.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := ++ Finset.sum_le_sum_of_subset_of_nonneg hS_sub (by ++ intro z hzF _; exact hterm_nonneg z hzF) ++ have hterm_ge : ∀ z ∈ S, (log 2) * (D z : ℝ) ≤ (Dr z : ℝ) * log (r * ‖z‖⁻¹) := by ++ intro z hzS ++ have hz0 : z ≠ (0 : E) := (Finset.mem_filter.1 hzS).2 ++ have hz_norm_le_R : ‖z‖ ≤ R := by ++ have hz_mem_SR : z ∈ SR := (Finset.mem_filter.1 hzS).1 ++ have hzRsup : z ∈ (toClosedBall R D).support := by ++ exact (finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).mem_toFinset.1 ++ hz_mem_SR ++ have hnorm := norm_le_abs_of_mem_toClosedBall_support hzRsup ++ simpa [abs_of_pos hR0] using hnorm ++ have hlog_le : log 2 ≤ log (r * ‖z‖⁻¹) := by ++ simpa [r] using log_two_le_log_two_mul_mul_inv_norm_of_norm_le hz0 hz_norm_le_R ++ have hDz_nonneg : 0 ≤ D z := hDnonneg z ++ have hz_in_ballr : z ∈ closedBall (0 : E) |r| := by ++ have : ‖z‖ ≤ r := le_trans hz_norm_le_R (by dsimp [r]; nlinarith) ++ simpa [mem_closedBall, dist_zero_right, abs_of_pos hrpos] using this ++ have hDrz : Dr z = D z := by ++ have hz_norm_le : ‖z‖ ≤ |r| := by ++ simpa [mem_closedBall, dist_zero_right] using hz_in_ballr ++ simpa [Dr] using toClosedBall_eval_eq_of_norm_le_abs (D := D) (r := r) (z := z) hz_norm_le ++ have : (log 2) * (D z : ℝ) ≤ (log (r * ‖z‖⁻¹)) * (D z : ℝ) := ++ mul_le_mul_of_nonneg_right hlog_le (by exact_mod_cast hDz_nonneg) ++ simpa [hDrz, mul_assoc, mul_left_comm, mul_comm] using this ++ calc ++ (log 2) * (S.sum fun z => (D z : ℝ)) ++ = S.sum (fun z => (log 2) * (D z : ℝ)) := by simp [Finset.mul_sum] ++ _ ≤ S.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := ++ Finset.sum_le_sum fun z hz => hterm_ge z hz ++ _ ≤ F.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := hsumSF ++ have hcenter_nonneg : 0 ≤ (D 0 : ℝ) * log r := by ++ have hD0 : 0 ≤ D 0 := hDnonneg 0 ++ have hlogr : 0 ≤ log r := log_nonneg (by nlinarith [hR]) ++ exact mul_nonneg (by exact_mod_cast hD0) hlogr ++ have : (log 2) * (S.sum fun z => (D z : ℝ)) ≤ logCounting D r := by ++ rw [hlogCounting] ++ nlinarith [hsum_le, hcenter_nonneg] ++ simpa [massClosedBall₀, r, S, SR] using this ++ ++theorem massClosedBall₀_divisor_le_of_log_growth {f : ℂ → ℂ} {ρ C : ℝ} ++ (hf : Differentiable ℂ f) ++ (hC : ∀ z : ℂ, log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) {R : ℝ} (hR : 1 ≤ R) : ++ massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R ++ ≤ (C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖|) / log 2 := by ++ have hR0 : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR ++ have hlog2pos : 0 < log 2 := log_pos (by norm_num : (1 : ℝ) < 2) ++ have hlow : ++ (log 2) * massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R ++ ≤ logCounting (divisor f (Set.univ : Set ℂ)) (2 * R) := ++ log_two_mul_massClosedBall₀_le_logCounting ++ (D := divisor f (Set.univ : Set ℂ)) ++ (MeromorphicOn.AnalyticOnNhd.divisor_nonneg ++ (hf.differentiableOn.analyticOnNhd isOpen_univ)) hR ++ have hupp : ++ logCounting (divisor f (Set.univ : Set ℂ)) (2 * R) ++ ≤ C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ have h2R0 : 0 < 2 * R := by nlinarith [hR0] ++ simpa using logCounting_divisor_le_of_log_growth (f := f) (ρ := ρ) (C := C) hf hC ++ (R := 2 * R) h2R0 ++ have hmul : ++ (log 2) * massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R ++ ≤ C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := ++ hlow.trans hupp ++ have hmul' : ++ massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R * log 2 ++ ≤ C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using hmul ++ exact (le_div_iff₀ hlog2pos).2 hmul' ++ ++end Function.locallyFinsuppWithin ++end HadamardSourceScope21 ++ ++section HadamardSourceScope22 ++ ++open Set ++ ++variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] ++ ++theorem Differentiable.divisor_nonneg {f : ℂ → E} (hf : Differentiable ℂ f) : ++ 0 ≤ MeromorphicOn.divisor f (univ : Set ℂ) := ++ MeromorphicOn.AnalyticOnNhd.divisor_nonneg (hf.differentiableOn.analyticOnNhd isOpen_univ) ++end HadamardSourceScope22 ++ ++section HadamardSourceScope23 ++ ++noncomputable section ++ ++open scoped BigOperators ++open Filter ++ ++namespace Real ++ ++open _root_.Real ++ ++lemma two_pow_floor_logb_le {x : ℝ} (hx : 1 ≤ x) : ++ (2 : ℝ) ^ (⌊Real.logb 2 x⌋₊ : ℝ) ≤ x := by ++ have hx0 : 0 < x := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hx ++ have hlog_nonneg : 0 ≤ Real.logb 2 x := ++ Real.logb_nonneg (b := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) hx ++ have hfloor_le : (⌊Real.logb 2 x⌋₊ : ℝ) ≤ Real.logb 2 x := by ++ simpa using (Nat.floor_le hlog_nonneg) ++ exact (Real.le_logb_iff_rpow_le (b := (2 : ℝ)) ++ (x := (⌊Real.logb 2 x⌋₊ : ℝ)) (y := x) ++ (by norm_num : (1 : ℝ) < 2) hx0).1 hfloor_le ++ ++lemma lt_two_pow_floor_logb_add_one {x : ℝ} (hx : 1 ≤ x) : ++ x < (2 : ℝ) ^ ((⌊Real.logb 2 x⌋₊ : ℝ) + 1) := by ++ have hx0 : 0 < x := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hx ++ have hlt : Real.logb 2 x < (⌊Real.logb 2 x⌋₊ : ℝ) + 1 := by ++ simpa using (Nat.lt_floor_add_one (Real.logb 2 x)) ++ exact (Real.logb_lt_iff_lt_rpow (b := (2 : ℝ)) (x := x) ++ (y := (⌊Real.logb 2 x⌋₊ : ℝ) + 1) ++ (by norm_num : (1 : ℝ) < 2) hx0).1 hlt ++ ++lemma dyadicShell_lower_bound {r0 x : ℝ} {k : ℕ} (hr0 : 0 < r0) (hx : r0 ≤ x) ++ (hk : ⌊Real.logb 2 (x / r0)⌋₊ = k) : ++ r0 * (2 : ℝ) ^ (k : ℝ) ≤ x := by ++ have hr0ne : r0 ≠ 0 := ne_of_gt hr0 ++ have hx1 : (1 : ℝ) ≤ x / r0 := by ++ have : r0 / r0 ≤ x / r0 := div_le_div_of_nonneg_right hx hr0.le ++ simpa [hr0ne] using this ++ have hle : (2 : ℝ) ^ (k : ℝ) ≤ x / r0 := by ++ have := Real.two_pow_floor_logb_le (x := x / r0) hx1 ++ simpa [hk] using this ++ have := mul_le_mul_of_nonneg_left hle hr0.le ++ have hxEq : r0 * (x / r0) = x := by ++ field_simp [hr0ne] ++ simpa [mul_assoc, hxEq] using this ++ ++lemma dyadicShell_upper_bound {r0 x : ℝ} {k : ℕ} (hr0 : 0 < r0) (hx : r0 ≤ x) ++ (hk : ⌊Real.logb 2 (x / r0)⌋₊ = k) : ++ x ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1) := by ++ have hr0ne : r0 ≠ 0 := ne_of_gt hr0 ++ have hx1 : (1 : ℝ) ≤ x / r0 := by ++ have : r0 / r0 ≤ x / r0 := div_le_div_of_nonneg_right hx hr0.le ++ simpa [hr0ne] using this ++ have hlt : x / r0 < (2 : ℝ) ^ ((k : ℝ) + 1) := by ++ have := Real.lt_two_pow_floor_logb_add_one (x := x / r0) hx1 ++ simpa [hk] using this ++ have := mul_lt_mul_of_pos_left hlt hr0 ++ have hxEq : r0 * (x / r0) = x := by ++ field_simp [hr0ne] ++ exact le_of_lt (by simpa [mul_assoc, hxEq] using this) ++ ++lemma exists_nat_le_two_pow (A : ℝ) : ++ ∃ k0 : ℕ, ∀ n ≥ k0, A ≤ (2 : ℝ) ^ n := by ++ have htend : Tendsto (fun n : ℕ => (2 : ℝ) ^ n) atTop atTop := ++ tendsto_pow_atTop_atTop_of_one_lt (r := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) ++ exact eventually_atTop.1 ((tendsto_atTop.1 htend) A) ++ ++lemma one_le_dyadicRadius_succ_of_inv_le_two_pow ++ {r0 : ℝ} {k0 kk : ℕ} (hr0 : 0 < r0) ++ (hk0 : ∀ n ≥ k0, (1 / r0 : ℝ) ≤ (2 : ℝ) ^ n) (hkk : k0 ≤ kk + 1) : ++ (1 : ℝ) ≤ r0 * (2 : ℝ) ^ ((kk : ℝ) + 1) := by ++ have hr0ne : r0 ≠ 0 := ne_of_gt hr0 ++ have hpow_nat : (1 / r0 : ℝ) ≤ (2 : ℝ) ^ (kk + 1) := hk0 (kk + 1) hkk ++ have hpow_rpow : (1 / r0 : ℝ) ≤ (2 : ℝ) ^ ((kk : ℝ) + 1) := by ++ have hcast : (2 : ℝ) ^ ((kk : ℝ) + 1) = (2 : ℝ) ^ (kk + 1) := by ++ calc ++ (2 : ℝ) ^ ((kk : ℝ) + 1) = (2 : ℝ) ^ ((kk + 1 : ℕ) : ℝ) := by ++ simp [Nat.cast_add, Nat.cast_one] ++ _ = (2 : ℝ) ^ (kk + 1) := by ++ simpa using (Real.rpow_natCast (2 : ℝ) (kk + 1)) ++ simpa [hcast] using hpow_nat ++ have : (r0 * (1 / r0) : ℝ) ≤ r0 * (2 : ℝ) ^ ((kk : ℝ) + 1) := ++ mul_le_mul_of_nonneg_left hpow_rpow hr0.le ++ simpa [one_div, hr0ne, mul_assoc] using this ++ ++lemma one_add_abs_two_mul_dyadicRadius_rpow_le {r0 ρ : ℝ} (k : ℕ) ++ (hr0 : 0 < r0) (hρ : 0 ≤ ρ) : ++ (1 + |2 * (r0 * (2 : ℝ) ^ ((k : ℝ) + 1))|) ^ ρ ++ ≤ (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ ρ) ^ k := by ++ let Rk : ℝ := r0 * (2 : ℝ) ^ ((k : ℝ) + 1) ++ have hRk' : |2 * Rk| = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := by ++ have hnonneg : 0 ≤ (2 : ℝ) * Rk := by ++ have : 0 ≤ Rk := by ++ dsimp [Rk] ++ exact mul_nonneg hr0.le (le_of_lt (Real.rpow_pos_of_pos (by norm_num) _)) ++ nlinarith ++ have hmul : (2 : ℝ) * Rk = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := by ++ dsimp [Rk] ++ calc ++ (2 : ℝ) * (r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) ++ = (2 * r0) * (2 : ℝ) ^ ((k : ℝ) + 1) := by ring ++ _ = (2 * r0) * ((2 : ℝ) ^ (k : ℝ) * (2 : ℝ) ^ (1 : ℝ)) := by ++ simp [Real.rpow_add, mul_assoc] ++ _ = (2 * r0) * ((2 : ℝ) ^ (k : ℝ) * 2) := by simp [Real.rpow_one] ++ _ = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := by ring ++ calc ++ |2 * Rk| = 2 * Rk := abs_of_nonneg hnonneg ++ _ = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := hmul ++ have hbase : ++ (1 + |2 * Rk|) ≤ (1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ) := by ++ have h1 : (1 : ℝ) ≤ (2 : ℝ) ^ (k : ℝ) := by ++ have : (1 : ℝ) ≤ (2 : ℝ) ^ (k : ℕ) := by ++ simpa using (one_le_pow₀ (by norm_num : (1 : ℝ) ≤ (2 : ℝ))) ++ simpa [Real.rpow_natCast] using this ++ have habs : ++ 1 + |2 * Rk| ≤ (2 : ℝ) ^ (k : ℝ) + (4 * r0) * (2 : ℝ) ^ (k : ℝ) := by ++ rw [hRk'] ++ simpa [add_assoc, add_left_comm, add_comm, mul_assoc, mul_left_comm, mul_comm] using ++ (add_le_add_right h1 ((4 * r0) * (2 : ℝ) ^ (k : ℝ))) ++ have hfac : ++ (2 : ℝ) ^ (k : ℝ) + (4 * r0) * (2 : ℝ) ^ (k : ℝ) ++ = (1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ) := by ++ ring ++ exact habs.trans (le_of_eq hfac) ++ have hRnonneg : 0 ≤ (1 + |2 * Rk|) := by linarith [abs_nonneg (2 * Rk)] ++ have : ++ (1 + |2 * Rk|) ^ ρ ≤ ((1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ)) ^ ρ := ++ Real.rpow_le_rpow hRnonneg hbase hρ ++ have hsplit : ++ ((1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ)) ^ ρ ++ = (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ (k : ℝ)) ^ ρ := by ++ have h1 : 0 ≤ (1 + 4 * r0) := by nlinarith [hr0.le] ++ have h2 : 0 ≤ (2 : ℝ) ^ (k : ℝ) := ++ le_of_lt (Real.rpow_pos_of_pos (by norm_num) _) ++ simpa using (Real.mul_rpow h1 h2 (z := ρ)) ++ have hpow : ((2 : ℝ) ^ (k : ℝ)) ^ ρ = ((2 : ℝ) ^ ρ) ^ k := by ++ have h2nonneg : (0 : ℝ) ≤ 2 := by norm_num ++ calc ++ ((2 : ℝ) ^ (k : ℝ)) ^ ρ = (2 : ℝ) ^ ((k : ℝ) * ρ) := by ++ simp [Real.rpow_mul] ++ _ = ((2 : ℝ) ^ ρ) ^ (k : ℝ) := by ++ simpa [mul_comm] using ++ (Real.rpow_mul (x := (2 : ℝ)) (y := ρ) (z := (k : ℝ)) h2nonneg) ++ _ = ((2 : ℝ) ^ ρ) ^ k := by ++ simp [Real.rpow_natCast] ++ calc ++ (1 + |2 * (r0 * (2 : ℝ) ^ ((k : ℝ) + 1))|) ^ ρ ++ = (1 + |2 * Rk|) ^ ρ := by rfl ++ _ ≤ ((1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ)) ^ ρ := this ++ _ = (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ (k : ℝ)) ^ ρ := hsplit ++ _ = (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ ρ) ^ k := by ++ simpa [mul_assoc] using congrArg (fun t => (1 + 4 * r0) ^ ρ * t) hpow ++ ++lemma tsum_inv_rpow_le_card_mul_of_lower_bound {α : Type*} [Fintype α] {a : α → ℝ} ++ {R τ : ℝ} (hR : 0 < R) (hτ : 0 < τ) (ha_nonneg : ∀ x, 0 ≤ a x) ++ (ha_lower : ∀ x, R ≤ a x) : ++ (∑' x : α, (a x)⁻¹ ^ τ) ≤ (Fintype.card α : ℝ) * (R⁻¹ ^ τ) := by ++ have hsum_le : ++ (∑ x : α, (a x)⁻¹ ^ τ) ≤ ∑ _x : α, R⁻¹ ^ τ := by ++ refine Finset.sum_le_sum ?_ ++ intro x _hx ++ have hinv : (a x)⁻¹ ≤ R⁻¹ := by ++ simpa using (inv_anti₀ hR (ha_lower x)) ++ exact Real.rpow_le_rpow (inv_nonneg.2 (ha_nonneg x)) hinv hτ.le ++ simpa [tsum_fintype, Finset.sum_const, nsmul_eq_mul, mul_comm] using hsum_le ++ ++lemma inv_dyadicRadius_rpow_eq (r0 τ : ℝ) (k : ℕ) (hr0 : 0 ≤ r0) : ++ (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ = ++ (r0⁻¹ : ℝ) ^ τ * ((2 : ℝ) ^ (-τ)) ^ k := by ++ have h2k_nonneg : 0 ≤ (2 : ℝ) ^ (k : ℝ) := ++ le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _) ++ calc ++ (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ = ++ (r0 * (2 : ℝ) ^ (k : ℝ)) ^ (-τ) := by ++ simpa using (Real.rpow_neg_eq_inv_rpow (r0 * (2 : ℝ) ^ (k : ℝ)) τ).symm ++ _ = r0 ^ (-τ) * (((2 : ℝ) ^ (k : ℝ)) ^ (-τ)) := by ++ simpa using (Real.mul_rpow hr0 h2k_nonneg (z := -τ)) ++ _ = (r0⁻¹ : ℝ) ^ τ * ((2 : ℝ) ^ (-τ)) ^ k := by ++ have hr0' : r0 ^ (-τ) = (r0⁻¹ : ℝ) ^ τ := by ++ simp [Real.rpow_neg_eq_inv_rpow] ++ have h2' : ((2 : ℝ) ^ (k : ℝ)) ^ (-τ) = ((2 : ℝ) ^ (-τ)) ^ k := by ++ have h2nonneg : (0 : ℝ) ≤ (2 : ℝ) := by norm_num ++ calc ++ ((2 : ℝ) ^ (k : ℝ)) ^ (-τ) = (2 : ℝ) ^ ((k : ℝ) * (-τ)) := by ++ exact (Real.rpow_mul (x := (2 : ℝ)) (y := (k : ℝ)) (z := -τ) ++ h2nonneg).symm ++ _ = (2 : ℝ) ^ ((-τ) * (k : ℝ)) := by ring_nf ++ _ = ((2 : ℝ) ^ (-τ)) ^ (k : ℝ) := by ++ exact Real.rpow_mul (x := (2 : ℝ)) (y := -τ) (z := (k : ℝ)) h2nonneg ++ _ = ((2 : ℝ) ^ (-τ)) ^ k := by ++ simp [Real.rpow_natCast] ++ calc ++ r0 ^ (-τ) * (((2 : ℝ) ^ (k : ℝ)) ^ (-τ)) ++ = (r0⁻¹ : ℝ) ^ τ * (((2 : ℝ) ^ (k : ℝ)) ^ (-τ)) := by ++ rw [hr0'] ++ _ = (r0⁻¹ : ℝ) ^ τ * ((2 : ℝ) ^ (-τ)) ^ k := by ++ rw [h2'] ++ ++lemma two_rpow_sub_eq_mul_neg (ρ τ : ℝ) : ++ (2 : ℝ) ^ (ρ - τ) = (2 : ℝ) ^ ρ * (2 : ℝ) ^ (-τ) := by ++ have h2pos : (0 : ℝ) < (2 : ℝ) := by norm_num ++ calc ++ (2 : ℝ) ^ (ρ - τ) = (2 : ℝ) ^ (ρ + (-τ)) := by ring_nf ++ _ = (2 : ℝ) ^ ρ * (2 : ℝ) ^ (-τ) := by ++ simp [Real.rpow_add h2pos] ++ ++lemma two_rpow_sub_pow_eq_mul_pow (ρ τ : ℝ) (k : ℕ) : ++ ((2 : ℝ) ^ (ρ - τ)) ^ k = ++ ((2 : ℝ) ^ ρ) ^ k * (((2 : ℝ) ^ (-τ)) ^ k) := by ++ simp [two_rpow_sub_eq_mul_neg, mul_pow] ++ ++lemma dyadic_growth_inv_term_eq (C L M r0 ρ τ : ℝ) (k : ℕ) (hr0 : 0 ≤ r0) : ++ ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ = (((C / L) * M) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (ρ - τ)) ^ k := by ++ have hrk_inv : ++ (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ = ++ (r0⁻¹ : ℝ) ^ τ * (((2 : ℝ) ^ (-τ)) ^ k) := ++ inv_dyadicRadius_rpow_eq r0 τ k hr0 ++ rw [hrk_inv, two_rpow_sub_pow_eq_mul_pow] ++ ac_rfl ++ ++lemma dyadic_trailing_inv_term_le (C L r0 τ : ℝ) (k : ℕ) (hr0 : 0 ≤ r0) : ++ (C / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ ≤ (((C / L) + 1) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (-τ)) ^ k := by ++ rw [inv_dyadicRadius_rpow_eq r0 τ k hr0] ++ have hcoeff : C / L ≤ C / L + 1 := by linarith ++ have hr0Inv_nonneg : 0 ≤ (r0⁻¹ : ℝ) ^ τ := ++ Real.rpow_nonneg (inv_nonneg.2 hr0) _ ++ have hmul : ++ (C / L) * ((r0⁻¹ : ℝ) ^ τ) ++ ≤ ((C / L) + 1) * ((r0⁻¹ : ℝ) ^ τ) := ++ mul_le_mul_of_nonneg_right hcoeff hr0Inv_nonneg ++ have hqpow_nonneg : 0 ≤ ((2 : ℝ) ^ (-τ)) ^ k := ++ pow_nonneg (le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _)) _ ++ have := mul_le_mul_of_nonneg_right hmul hqpow_nonneg ++ simpa [mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma dyadic_growth_mass_mul_inv_le_geometric {C L M X T Ctrail r0 ρ τ : ℝ} {k : ℕ} ++ (hL : 0 < L) (hC : 0 ≤ C) (hr0 : 0 ≤ r0) ++ (hX : X ≤ M * ((2 : ℝ) ^ ρ) ^ k) ++ (hT : T ≤ ((C * X + Ctrail) / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ)) : ++ T ≤ (((C / L) * M) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (ρ - τ)) ^ k ++ + (((Ctrail / L) + 1) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (-τ)) ^ k := by ++ have hmul : C * X ≤ C * (M * ((2 : ℝ) ^ ρ) ^ k) := ++ mul_le_mul_of_nonneg_left hX hC ++ have hnum : C * X + Ctrail ≤ C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail := ++ add_le_add hmul le_rfl ++ have hdiv : ++ (C * X + Ctrail) / L ≤ (C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail) / L := ++ div_le_div_of_nonneg_right hnum hL.le ++ have h2k_nonneg : 0 ≤ (2 : ℝ) ^ (k : ℝ) := ++ le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) (k : ℝ)) ++ have hrk_nonneg : 0 ≤ r0 * (2 : ℝ) ^ (k : ℝ) := ++ mul_nonneg hr0 h2k_nonneg ++ have hfactor_nonneg : 0 ≤ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) := ++ Real.rpow_nonneg (inv_nonneg.2 hrk_nonneg) τ ++ have hmul' := ++ mul_le_mul_of_nonneg_right hdiv hfactor_nonneg ++ have hdecomp : ++ ((C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail) / L) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ = ++ ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ + ((Ctrail / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ)) := by ++ let Y : ℝ := (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ ++ have : ++ ((C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail) / L) * Y ++ = ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * Y ++ + ((Ctrail / L) * Y) := by ++ ring ++ simpa [Y] ++ have hpre : ++ T ≤ ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ + ((Ctrail / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ)) := ++ hT.trans (hmul'.trans_eq hdecomp) ++ have hA := le_of_eq (dyadic_growth_inv_term_eq C L M r0 ρ τ k hr0) ++ have hB := dyadic_trailing_inv_term_le Ctrail L r0 τ k hr0 ++ exact hpre.trans (by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using add_le_add hA hB) ++ ++lemma two_geometric_shift_add (A B q qσ : ℝ) (k k0 : ℕ) : ++ A * q ^ (k + k0) + B * qσ ^ (k + k0) ++ = (A * q ^ k0) * q ^ k + (B * qσ ^ k0) * qσ ^ k := by ++ rw [pow_add, pow_add] ++ ac_rfl ++ ++end Real ++end ++end HadamardSourceScope23 ++ ++section HadamardSourceScope24 ++ ++noncomputable section ++ ++open Filter Topology Set _root_.Complex _root_.Erdos970.Complex ++open scoped BigOperators Topology ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++open scoped _root_.Real ++ ++noncomputable def divisorMassClosedBall₀ (f : ℂ → ℂ) (R : ℝ) : ℝ := ++ Function.locallyFinsuppWithin.massClosedBall₀ (MeromorphicOn.divisor f (Set.univ : Set ℂ)) R ++ ++lemma divisorMassClosedBall₀_le_of_growth {f : ℂ → ℂ} {ρ C : ℝ} ++ (hf : Differentiable ℂ f) ++ (hC : ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) ++ {R : ℝ} (hR : 1 ≤ R) : ++ divisorMassClosedBall₀ f R ++ ≤ (C * (1 + |2 * R|) ^ ρ + |Real.log ‖meromorphicTrailingCoeffAt f 0‖|) / ++ Real.log 2 := by ++ simpa [divisorMassClosedBall₀] using ++ (Function.locallyFinsuppWithin.massClosedBall₀_divisor_le_of_log_growth ++ (f := f) (ρ := ρ) (C := C) hf hC hR) ++ ++lemma exists_r0_le_norm_divisorZeroIndex₀Val {f : ℂ → ℂ} ++ (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) : ++ ∃ r0 : ℝ, 0 < r0 ∧ ++ ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖ := by ++ classical ++ set U : Set ℂ := (Set.univ : Set ℂ) ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have hDnonneg : 0 ≤ D := by ++ simpa [D, U] using (Differentiable.divisor_nonneg (f := f) hf) ++ have hzero : ∀ p : divisorZeroIndex₀ f U, f (divisorZeroIndex₀Val p) = 0 := by ++ intro p ++ set z : ℂ := divisorZeroIndex₀Val p ++ have hneTop : meromorphicOrderAt f z ≠ ⊤ := by ++ have hzAnal : AnalyticAt ℂ f z := hf.analyticAt z ++ have hzA : analyticOrderAt f z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (f := f) (hf := hf) hnot (z := z) ++ intro htop ++ have hm : meromorphicOrderAt f z = (analyticOrderAt f z).map (↑) := ++ hzAnal.meromorphicOrderAt_eq (𝕜 := ℂ) ++ cases h : analyticOrderAt f z with ++ | top => ++ exact hzA (by simp [h]) ++ | coe n => ++ have : (analyticOrderAt f z).map (↑) ≠ (⊤ : WithTop ℤ) := by ++ simp [h] ++ exact this (by simpa [hm] using htop) ++ have hmon : MeromorphicOn f U := by ++ intro w hw; exact (hf.analyticAt w).meromorphicAt ++ have hdiv : MeromorphicOn.divisor f U z = (meromorphicOrderAt f z).untop₀ := by ++ simpa [U] using (MeromorphicOn.divisor_apply (f := f) (U := U) (z := z) hmon (by aesop)) ++ have hDz : MeromorphicOn.divisor f U z ≠ 0 := by ++ have hzsup : z ∈ (MeromorphicOn.divisor f U).support := by ++ simp [z] ++ simpa [Function.mem_support] using hzsup ++ have hposZ : (0 : ℤ) < (meromorphicOrderAt f z).untop₀ := by ++ have hge0 : 0 ≤ (meromorphicOrderAt f z).untop₀ := by ++ have : 0 ≤ MeromorphicOn.divisor f U z := by ++ simpa [D, U, z] using hDnonneg z ++ simpa [hdiv] using this ++ have hne0 : (meromorphicOrderAt f z).untop₀ ≠ 0 := by ++ simpa [hdiv] using hDz ++ exact lt_of_le_of_ne hge0 (by simpa [eq_comm] using hne0) ++ have hpos : (0 : WithTop ℤ) < meromorphicOrderAt f z := by ++ have : (0 : WithTop ℤ) < ((meromorphicOrderAt f z).untop₀ : WithTop ℤ) := ++ WithTop.coe_lt_coe.2 hposZ ++ simpa [WithTop.coe_untop₀_of_ne_top hneTop] using this ++ have htend0 : Tendsto f (𝓝[≠] z) (𝓝 (0 : ℂ)) := ++ tendsto_zero_of_meromorphicOrderAt_pos (f := f) (x := z) hpos ++ have hcontz : ContinuousAt f z := (hf z).continuousAt ++ have htendz : Tendsto f (𝓝[≠] z) (𝓝 (f z)) := ++ (hcontz.tendsto.mono_left (nhdsWithin_le_nhds : 𝓝[≠] z ≤ 𝓝 z)) ++ exact tendsto_nhds_unique htendz htend0 ++ by_cases h0 : f 0 = 0 ++ · have hD0 : D 0 ≠ 0 := by ++ have hmero0 : MeromorphicAt f (0 : ℂ) := (hf.analyticAt 0).meromorphicAt ++ have hneTop0 : meromorphicOrderAt f (0 : ℂ) ≠ ⊤ := by ++ have hA0 : analyticOrderAt f (0 : ℂ) ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (f := f) (hf := hf) hnot (z := 0) ++ intro htop ++ have hm : meromorphicOrderAt f (0 : ℂ) = (analyticOrderAt f (0 : ℂ)).map (↑) := ++ (hf.analyticAt 0).meromorphicOrderAt_eq (𝕜 := ℂ) ++ cases h : analyticOrderAt f (0 : ℂ) with ++ | top => exact (hA0 h).elim ++ | coe n => ++ have : (analyticOrderAt f (0 : ℂ)).map (↑) ≠ (⊤ : WithTop ℤ) := by ++ simp [h] ++ exact this (by simpa [hm] using htop) ++ have htend0 : Tendsto f (𝓝[≠] (0 : ℂ)) (𝓝 (0 : ℂ)) := by ++ have hcont0 : ContinuousAt f (0 : ℂ) := (hf 0).continuousAt ++ have : Tendsto f (𝓝 (0 : ℂ)) (𝓝 (0 : ℂ)) := by simpa [h0] using hcont0.tendsto ++ exact this.mono_left (nhdsWithin_le_nhds : 𝓝[≠] (0 : ℂ) ≤ 𝓝 (0 : ℂ)) ++ have hpos0 : (0 : WithTop ℤ) < meromorphicOrderAt f (0 : ℂ) := ++ (tendsto_zero_iff_meromorphicOrderAt_pos hmero0).1 htend0 ++ have hpos0' : (0 : ℤ) < (meromorphicOrderAt f (0 : ℂ)).untop₀ := by ++ have : (0 : WithTop ℤ) < ((meromorphicOrderAt f (0 : ℂ)).untop₀ : WithTop ℤ) := by ++ simpa [WithTop.coe_untop₀_of_ne_top hneTop0] using hpos0 ++ simpa using (WithTop.coe_lt_coe.1 this) ++ have hdiv0 : D 0 = (meromorphicOrderAt f (0 : ℂ)).untop₀ := by ++ have hmon : MeromorphicOn f U := by ++ intro w hw; exact (hf.analyticAt w).meromorphicAt ++ simpa [D, U] using ++ (MeromorphicOn.divisor_apply (f := f) (U := U) (z := (0 : ℂ)) ++ hmon (by aesop)) ++ exact by ++ have : (meromorphicOrderAt f (0 : ℂ)).untop₀ ≠ 0 := ne_of_gt hpos0' ++ simpa [hdiv0] using this ++ have hmem0 : (0 : ℂ) ∈ D.support := by ++ simp [Function.mem_support, hD0] ++ have hdisc : IsDiscrete D.support := by ++ simpa [D] using (D.discreteSupport) ++ rcases Metric.exists_ball_inter_eq_singleton_of_mem_discrete hdisc hmem0 with ⟨r0, hr0pos, hr0⟩ ++ refine ⟨r0, hr0pos, ?_⟩ ++ intro p ++ have hp : divisorZeroIndex₀Val p ∈ D.support := by ++ simp [D, divisorZeroIndex₀Val_mem_divisor_support (f := f) (U := U) p] ++ have hnotBall : divisorZeroIndex₀Val p ∉ Metric.ball (0 : ℂ) r0 := by ++ intro hball ++ have : divisorZeroIndex₀Val p ∈ Metric.ball (0 : ℂ) r0 ∩ D.support := ⟨hball, hp⟩ ++ have : divisorZeroIndex₀Val p ∈ ({(0 : ℂ)} : Set ℂ) := by simp [hr0] at this ++ have : divisorZeroIndex₀Val p = 0 := by simp [Set.mem_singleton_iff] at this ++ exact (divisorZeroIndex₀Val_ne_zero p) this ++ have : r0 ≤ ‖divisorZeroIndex₀Val p‖ := by ++ have : ¬ ‖divisorZeroIndex₀Val p‖ < r0 := by ++ intro hlt ++ exact hnotBall (by simpa [Metric.mem_ball, dist_zero_right] using hlt) ++ exact le_of_not_gt this ++ exact this ++ · have hcont0 : ContinuousAt f (0 : ℂ) := (hf 0).continuousAt ++ have hne : ∀ᶠ z in 𝓝 (0 : ℂ), f z ≠ 0 := hcont0.eventually_ne h0 ++ rcases Metric.mem_nhds_iff.1 hne with ⟨r0, hr0pos, hr0⟩ ++ refine ⟨r0, hr0pos, ?_⟩ ++ intro p ++ have : ¬ ‖divisorZeroIndex₀Val p‖ < r0 := by ++ intro hlt ++ have hzball : divisorZeroIndex₀Val p ∈ Metric.ball (0 : ℂ) r0 := by ++ simpa [Metric.mem_ball, dist_zero_right] using hlt ++ have : f (divisorZeroIndex₀Val p) ≠ 0 := hr0 hzball ++ exact this (hzero p) ++ exact le_of_not_gt this ++ ++open scoped BigOperators ++ ++lemma card_ball_le_divisorMassClosedBall₀ ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) {R : ℝ} (hR : 0 < R) : ++ (Nat.card {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) // ‖divisorZeroIndex₀Val p‖ ≤ R} : ℝ) ++ ≤ divisorMassClosedBall₀ f R := by ++ set U : Set ℂ := (Set.univ : Set ℂ) ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have : ++ Fintype {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} := by ++ have : Finite {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} := by ++ have : Metric.closedBall (0 : ℂ) R ⊆ U := by simp [U] ++ simpa using (finite_divisorZeroIndex₀_subtype_norm_le (f := f) (U := U) (B := R) this) ++ exact Fintype.ofFinite _ ++ have hDnonneg : 0 ≤ D := by ++ simpa [D, U] using (Differentiable.divisor_nonneg (f := f) hf) ++ let SR : Finset ℂ := ++ (Function.locallyFinsuppWithin.finiteSupport (Function.locallyFinsuppWithin.toClosedBall R D) ++ (isCompact_closedBall (0 : ℂ) |R|)).toFinset ++ let S : Finset ℂ := SR.filter fun z : ℂ => z ≠ 0 ++ let T : Type := ++ Σ z : S, Fin (Int.toNat (D z.1)) ++ let φ : ++ {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} → T := fun p => ++ let z0 : ℂ := divisorZeroIndex₀Val p.1 ++ have hz0_memSR : z0 ∈ SR := by ++ have hz0_norm : ‖z0‖ ≤ |R| := by ++ have : ‖z0‖ ≤ R := p.2 ++ simpa [abs_of_pos hR] using this ++ have hz0_support : z0 ∈ (Function.locallyFinsuppWithin.toClosedBall R D).support := by ++ have hz0_suppD : z0 ∈ D.support := by ++ simp [z0, D] ++ exact Function.locallyFinsuppWithin.mem_toClosedBall_support_of_mem_support_of_norm_le_abs ++ hz0_suppD hz0_norm ++ exact (Set.Finite.mem_toFinset ++ (Function.locallyFinsuppWithin.finiteSupport ++ (Function.locallyFinsuppWithin.toClosedBall R D) ++ (isCompact_closedBall (0 : ℂ) |R|))).2 hz0_support ++ have hz0_ne0 : z0 ≠ 0 := divisorZeroIndex₀Val_ne_zero p.1 ++ have hz0_memS : z0 ∈ S := Finset.mem_filter.2 ⟨hz0_memSR, hz0_ne0⟩ ++ ⟨⟨z0, hz0_memS⟩, by ++ simpa [z0, divisorZeroIndex₀Val, D] using p.1.1.2⟩ ++ have hφ_inj : Function.Injective φ := by ++ intro p q hpq ++ have hσ := (Sigma.mk.inj_iff).1 hpq ++ have hzS : (φ p).1 = (φ q).1 := hσ.1 ++ have hz : divisorZeroIndex₀Val p.1 = divisorZeroIndex₀Val q.1 := by ++ simpa [φ] using congrArg Subtype.val hzS ++ apply Subtype.ext ++ apply Subtype.ext ++ apply Sigma.ext ++ · exact hz ++ · simpa [φ] using hσ.2 ++ have hcard_le : ++ Fintype.card {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} ≤ Fintype.card T := ++ Fintype.card_le_of_injective φ hφ_inj ++ have hT_card : ++ (Fintype.card T : ℝ) = ++ (S.sum fun z : ℂ => (Int.toNat (D z) : ℝ)) := by ++ have hNat : ++ Fintype.card T = ∑ z : S, Int.toNat (D z.1) := by ++ have h1 : ++ Fintype.card T = ∑ z : S, Fintype.card (Fin (Int.toNat (D z.1))) := by ++ change Fintype.card (Sigma (fun z : S => Fin (Int.toNat (D z.1)))) ++ = ∑ z : S, Fintype.card (Fin (Int.toNat (D z.1))) ++ exact (Fintype.card_sigma (ι := S) (α := fun z : S => Fin (Int.toNat (D z.1)))) ++ simpa using h1 ++ have hR : ++ (Fintype.card T : ℝ) = ∑ z : S, (Int.toNat (D z.1) : ℝ) := by ++ exact_mod_cast hNat ++ have hR' : ++ (Fintype.card T : ℝ) = S.attach.sum (fun z : S => (Int.toNat (D z.1) : ℝ)) := by ++ simpa [Finset.univ_eq_attach] using hR ++ calc ++ (Fintype.card T : ℝ) = S.attach.sum (fun z : S => (Int.toNat (D z.1) : ℝ)) := hR' ++ _ = S.sum (fun z : ℂ => (Int.toNat (D z) : ℝ)) := by ++ simpa using (Finset.sum_attach (s := S) (f := fun z : ℂ => (Int.toNat (D z) : ℝ))) ++ have htoNat_le : ∀ z ∈ S, (Int.toNat (D z) : ℝ) ≤ (D z : ℝ) := by ++ intro z hz ++ have hDz_nonneg : 0 ≤ D z := by simpa [D] using hDnonneg z ++ have hEqZ : ((Int.toNat (D z) : ℕ) : ℤ) = D z := by ++ simpa using (Int.toNat_of_nonneg hDz_nonneg) ++ have hEqR : (Int.toNat (D z) : ℝ) = (D z : ℝ) := by ++ exact_mod_cast hEqZ ++ exact le_of_eq hEqR ++ calc ++ (Nat.card {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} : ℝ) ++ = (Fintype.card {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} : ℝ) := by ++ simp [Nat.card_eq_fintype_card] ++ _ ≤ (Fintype.card T : ℝ) := by exact_mod_cast hcard_le ++ _ = S.sum (fun z : ℂ => (Int.toNat (D z) : ℝ)) := hT_card ++ _ ≤ S.sum (fun z : ℂ => (D z : ℝ)) := by ++ refine Finset.sum_le_sum ?_ ++ intro z hz ++ exact htoNat_le z hz ++ _ = divisorMassClosedBall₀ f R := by ++ rfl ++ ++lemma card_subtype_le_divisorMassClosedBall₀_of_norm_le ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ {s : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))} [Fintype s] ++ {R : ℝ} (hR : 0 < R) (hs : ∀ p : s, ‖divisorZeroIndex₀Val p.1‖ ≤ R) : ++ (Fintype.card s : ℝ) ≤ divisorMassClosedBall₀ f R := by ++ let Aball : Type := ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) // ‖divisorZeroIndex₀Val p‖ ≤ R} ++ have : Fintype Aball := by ++ have : Finite Aball := by ++ have : Metric.closedBall (0 : ℂ) R ⊆ (Set.univ : Set ℂ) := by simp ++ simpa [Aball] using ++ (finite_divisorZeroIndex₀_subtype_norm_le (f := f) (U := (Set.univ : Set ℂ)) ++ (B := R) this) ++ exact Fintype.ofFinite _ ++ have hinj : Function.Injective (fun p : s => (⟨p.1, hs p⟩ : Aball)) := by ++ intro p q hpq ++ apply Subtype.ext ++ exact congrArg (fun x : Aball => x.1) hpq ++ have hcard_le : Fintype.card s ≤ Fintype.card Aball := ++ Fintype.card_le_of_injective _ hinj ++ have hAball : (Nat.card Aball : ℝ) ≤ divisorMassClosedBall₀ f R := by ++ simpa [Aball] using card_ball_le_divisorMassClosedBall₀ (f := f) hf hR ++ calc ++ (Fintype.card s : ℝ) ≤ (Fintype.card Aball : ℝ) := by exact_mod_cast hcard_le ++ _ = (Nat.card Aball : ℝ) := by simp [Nat.card_eq_fintype_card] ++ _ ≤ divisorMassClosedBall₀ f R := hAball ++ ++lemma divisorZeroIndex₀_dyadicShell_upper_bound ++ {f : ℂ → ℂ} {r0 : ℝ} ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ {k : ℕ} {p : divisorZeroIndex₀ f (Set.univ : Set ℂ)} ++ (hp : ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k) : ++ ‖divisorZeroIndex₀Val p‖ ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1) := by ++ exact Real.dyadicShell_upper_bound (r0 := r0) (x := ‖divisorZeroIndex₀Val p‖) ++ hr0pos (hr0 p) hp ++ ++lemma divisorZeroIndex₀_dyadicShell_lower_bound ++ {f : ℂ → ℂ} {r0 : ℝ} ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ {k : ℕ} {p : divisorZeroIndex₀ f (Set.univ : Set ℂ)} ++ (hp : ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k) : ++ r0 * (2 : ℝ) ^ (k : ℝ) ≤ ‖divisorZeroIndex₀Val p‖ := by ++ exact Real.dyadicShell_lower_bound (r0 := r0) (x := ‖divisorZeroIndex₀Val p‖) ++ hr0pos (hr0 p) hp ++ ++lemma finite_divisorZeroIndex₀_dyadicShell ++ {f : ℂ → ℂ} {r0 : ℝ} ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ (k : ℕ) : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k} : Set _).Finite := by ++ have hsub : ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k} ⊆ ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1)} := by ++ intro p hp ++ exact divisorZeroIndex₀_dyadicShell_upper_bound hr0pos hr0 hp ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1)} : Set _).Finite := by ++ have : ++ Metric.closedBall (0 : ℂ) (r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) ⊆ ++ (Set.univ : Set ℂ) := by ++ simp ++ simpa using ++ (divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) ++ (B := r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) this) ++ exact hfin.subset hsub ++ ++lemma tsum_divisorZeroIndex₀_dyadicShell_inv_rpow_le_geometric_of_growth ++ {f : ℂ → ℂ} {ρ τ r0 Cgrow : ℝ} ++ (hρ : 0 ≤ ρ) (hτpos : 0 < τ) (hf : Differentiable ℂ f) ++ (hCgrow_pos : 0 < Cgrow) ++ (hCgrow : ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ Cgrow * (1 + ‖z‖) ^ ρ) ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ (k : ℕ) (hk_ge_one : 1 ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) : ++ let kfun : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℕ := ++ fun p => ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ ++ let S : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := {p | kfun p = k} ++ let Ctrail : ℝ := |Real.log ‖meromorphicTrailingCoeffAt f 0‖| ++ let A : ℝ := ((Cgrow / Real.log 2) * (1 + 4 * r0) ^ ρ) * (r0⁻¹) ^ τ ++ let B : ℝ := ((Ctrail / Real.log 2) + 1) * (r0⁻¹) ^ τ ++ let q : ℝ := (2 : ℝ) ^ (ρ - τ) ++ let qσ : ℝ := (2 : ℝ) ^ (-τ) ++ (∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ≤ A * q ^ k + B * qσ ^ k := by ++ classical ++ intro kfun S Ctrail A B q qσ ++ let rk : ℝ := r0 * (2 : ℝ) ^ (k : ℝ) ++ let Rk : ℝ := r0 * (2 : ℝ) ^ ((k : ℝ) + 1) ++ have hrk_pos : 0 < rk := mul_pos hr0pos (Real.rpow_pos_of_pos (by norm_num) _) ++ have hrk0 : 0 ≤ rk := le_of_lt hrk_pos ++ have : Finite S := by ++ simpa [S, kfun] using (finite_divisorZeroIndex₀_dyadicShell ++ (f := f) hr0pos hr0 k).to_subtype ++ have : Fintype S := Fintype.ofFinite S ++ have hk_upper : ∀ p : S, ‖divisorZeroIndex₀Val p.1‖ ≤ Rk := by ++ intro p ++ have hk' : kfun p.1 = k := p.2 ++ simpa [Rk, kfun] using ++ divisorZeroIndex₀_dyadicShell_upper_bound (f := f) hr0pos hr0 hk' ++ have hk_lower : ∀ p : S, rk ≤ ‖divisorZeroIndex₀Val p.1‖ := by ++ intro p ++ have hk' : kfun p.1 = k := p.2 ++ simpa [rk, kfun] using ++ divisorZeroIndex₀_dyadicShell_lower_bound (f := f) hr0pos hr0 hk' ++ have htsum_le : ++ (∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ++ ≤ (Fintype.card S : ℝ) * (rk⁻¹ ^ τ) := by ++ exact Real.tsum_inv_rpow_le_card_mul_of_lower_bound ++ (a := fun p : S => ‖divisorZeroIndex₀Val p.1‖) ++ hrk_pos hτpos (fun _ => norm_nonneg _) hk_lower ++ have hmass_le_growth : ++ divisorMassClosedBall₀ f Rk ++ ≤ (Cgrow * (1 + |2 * Rk|) ^ ρ + Ctrail) / (Real.log 2) := by ++ simpa [Ctrail, Rk] using ++ (divisorMassClosedBall₀_le_of_growth (f := f) (ρ := ρ) (C := Cgrow) hf hCgrow ++ (R := Rk) hk_ge_one) ++ have hcard_le_mass : ++ (Fintype.card S : ℝ) ≤ divisorMassClosedBall₀ f Rk := by ++ have hRk_pos : 0 < Rk := lt_of_lt_of_le (by norm_num) hk_ge_one ++ exact card_subtype_le_divisorMassClosedBall₀_of_norm_le (f := f) hf hRk_pos hk_upper ++ have htsum' : ++ (∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ++ ≤ ((Cgrow * (1 + |2 * Rk|) ^ ρ + Ctrail) / (Real.log 2)) * (rk⁻¹ ^ τ) := by ++ have hcard_le_growth : ++ (Fintype.card S : ℝ) ≤ ++ (Cgrow * (1 + |2 * Rk|) ^ ρ + Ctrail) / (Real.log 2) := ++ le_trans hcard_le_mass hmass_le_growth ++ exact le_trans htsum_le <| ++ mul_le_mul_of_nonneg_right hcard_le_growth (Real.rpow_nonneg (inv_nonneg.2 hrk0) τ) ++ have hpow_bound : ++ (1 + |2 * Rk|) ^ ρ ≤ (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ ρ) ^ k := by ++ simpa [Rk] using ++ Real.one_add_abs_two_mul_dyadicRadius_rpow_le (r0 := r0) (ρ := ρ) k hr0pos hρ ++ have hlog2pos : 0 < Real.log 2 := Real.log_pos (by norm_num : (1 : ℝ) < 2) ++ simpa [A, B, q, qσ, rk, Ctrail, mul_assoc, mul_left_comm, mul_comm] using ++ Real.dyadic_growth_mass_mul_inv_le_geometric ++ (C := Cgrow) (L := Real.log 2) (M := (1 + 4 * r0) ^ ρ) ++ (X := (1 + |2 * Rk|) ^ ρ) ++ (T := ∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ++ (Ctrail := Ctrail) (r0 := r0) (ρ := ρ) (τ := τ) (k := k) ++ hlog2pos hCgrow_pos.le hr0pos.le hpow_bound ++ (by simpa [rk] using htsum') ++ ++theorem summable_norm_inv_rpow_divisorZeroIndex₀_of_growth {f : ℂ → ℂ} {ρ τ : ℝ} ++ (hρ : 0 ≤ ρ) (hτ : ρ < τ) (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by ++ rcases hgrowth with ⟨Cgrow, hCgrow_pos, hCgrow⟩ ++ have hτpos : 0 < τ := lt_of_le_of_lt hρ hτ ++ rcases exists_r0_le_norm_divisorZeroIndex₀Val (f := f) hf hnot with ⟨r0, hr0pos, hr0⟩ ++ have hr0ne : (r0 : ℝ) ≠ 0 := ne_of_gt hr0pos ++ let kfun : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℕ := ++ fun p => ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ ++ let S : ℕ → Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ fun k => {p | kfun p = k} ++ have hS : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ∃! k : ℕ, p ∈ S k := by ++ intro p ++ refine ⟨kfun p, ?_, ?_⟩ ++ · simp [S] ++ · intro k hk ++ simpa [S] using hk.symm ++ have hnonneg : 0 ≤ fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ intro p ++ exact Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ have hSk_summable : ∀ k : ℕ, Summable fun p : S k => ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ intro k ++ have : Finite (S k) := by ++ simpa [S, kfun] using (finite_divisorZeroIndex₀_dyadicShell ++ (f := f) hr0pos hr0 k).to_subtype ++ exact Summable.of_finite ++ have hshell_summable : ++ Summable fun k : ℕ => ∑' p : S k, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ let q : ℝ := (2 : ℝ) ^ (ρ - τ) ++ let qσ : ℝ := (2 : ℝ) ^ (-τ) ++ have hq_nonneg : 0 ≤ q := le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _) ++ have hq_lt_one : q < 1 := ++ Real.rpow_lt_one_of_one_lt_of_neg (x := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) ++ (sub_neg.2 hτ) ++ have hqσ_nonneg : 0 ≤ qσ := le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _) ++ have hqσ_lt_one : qσ < 1 := ++ Real.rpow_lt_one_of_one_lt_of_neg (x := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) ++ (by simpa using (neg_neg_of_pos hτpos)) ++ have hgeom_q : Summable (fun k : ℕ => q ^ k) := ++ summable_geometric_of_lt_one hq_nonneg hq_lt_one ++ have hgeom_qσ : Summable (fun k : ℕ => qσ ^ k) := ++ summable_geometric_of_lt_one hqσ_nonneg hqσ_lt_one ++ let Ctrail : ℝ := |Real.log ‖meromorphicTrailingCoeffAt f 0‖| ++ let A : ℝ := ((Cgrow / Real.log 2) * (1 + 4 * r0) ^ ρ) * (r0⁻¹) ^ τ ++ let B : ℝ := ((Ctrail / Real.log 2) + 1) * (r0⁻¹) ^ τ ++ rcases Real.exists_nat_le_two_pow (1 / r0) with ⟨k0, hk0⟩ ++ let A0 : ℝ := A * q ^ k0 ++ let B0 : ℝ := B * qσ ^ k0 ++ have hmajor : Summable (fun k : ℕ => A0 * q ^ k + B0 * qσ ^ k) := ++ (hgeom_q.mul_left A0).add (hgeom_qσ.mul_left B0) ++ have hshell_summable_shift : ++ Summable fun k : ℕ => ∑' p : S (k + k0), ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ refine hmajor.of_nonneg_of_le ++ (fun k => by ++ have : ∀ p : S (k + k0), 0 ≤ ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ intro p; exact Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ exact tsum_nonneg this) ++ (fun k => by ++ let kk : ℕ := k + k0 ++ let Rk : ℝ := r0 * (2 : ℝ) ^ ((kk : ℝ) + 1) ++ have hRk_ge_one : (1 : ℝ) ≤ Rk := by ++ have hkk : k0 ≤ kk + 1 := by ++ simp [kk, Nat.add_assoc, Nat.add_comm] ++ simpa [Rk] using ++ Real.one_le_dyadicRadius_succ_of_inv_le_two_pow hr0pos hk0 hkk ++ have hmain : ++ (∑' p : S kk, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ≤ A * q ^ kk + B * qσ ^ kk := by ++ simpa [S, kfun, Ctrail, A, B, q, qσ] using ++ tsum_divisorZeroIndex₀_dyadicShell_inv_rpow_le_geometric_of_growth ++ (f := f) (ρ := ρ) (τ := τ) hρ hτpos hf hCgrow_pos hCgrow hr0pos hr0 kk hRk_ge_one ++ have : A * q ^ kk + B * qσ ^ kk = A0 * q ^ k + B0 * qσ ^ k := by ++ simpa [A0, B0, kk] using Real.two_geometric_shift_add A B q qσ k k0 ++ simpa [kk] using (hmain.trans_eq this) ++ ) ++ exact (summable_nat_add_iff k0).1 hshell_summable_shift ++ have hpart := ++ (summable_partition (f := fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) hnonneg (s := S) hS) ++ exact (hpart.2 ⟨hSk_summable, hshell_summable⟩) ++ ++theorem summable_norm_inv_pow_divisorZeroIndex₀_of_growth {f : ℂ → ℂ} {ρ : ℝ} ++ (hρ : 0 ≤ ρ) (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (Nat.floor ρ + 1)) := by ++ have hτ : ρ < (Nat.floor ρ + 1 : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one] using (Nat.lt_floor_add_one (a := ρ)) ++ have hs := ++ summable_norm_inv_rpow_divisorZeroIndex₀_of_growth (f := f) (ρ := ρ) ++ (τ := (Nat.floor ρ + 1 : ℝ)) hρ hτ hf hnot hgrowth ++ exact hs.congr fun p => by ++ have hcast : ((Nat.floor ρ : ℝ) + 1) = ((Nat.floor ρ + 1 : ℕ) : ℝ) := by ++ norm_num ++ rw [hcast, Real.rpow_natCast] ++ ++end Complex.Hadamard ++end ++end HadamardSourceScope24 ++ ++section HadamardSourceScope25 ++ ++namespace Complex ++ ++open _root_.Complex ++ ++variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] ++ ++theorem norm_le_of_mem_ball_of_forall_sphere_norm_le {f : ℂ → F} {r C : ℝ} {z : ℂ} ++ (hd : Differentiable ℂ f) (hrpos : 0 < r) ++ (hz : z ∈ Metric.ball (0 : ℂ) r) (hsphere : ∀ u : ℂ, ‖u‖ = r → ‖f u‖ ≤ C) : ++ ‖f z‖ ≤ C := by ++ let U : Set ℂ := Metric.ball (0 : ℂ) r ++ have hfront : ∀ u ∈ frontier U, ‖f u‖ ≤ C := by ++ intro u hu ++ have hur : ‖u‖ = r := by ++ have hfront' : frontier (Metric.ball (0 : ℂ) r) = Metric.sphere (0 : ℂ) r := by ++ simpa using (frontier_ball (x := (0 : ℂ)) (r := r) (ne_of_gt hrpos)) ++ have : u ∈ Metric.sphere (0 : ℂ) r := by simpa [U, hfront'] using hu ++ simpa [Metric.mem_sphere, dist_zero_right] using this ++ exact hsphere u hur ++ exact norm_le_of_forall_mem_frontier_norm_le (f := f) (U := U) Metric.isBounded_ball ++ hd.diffContOnCl hfront (subset_closure hz) ++ ++end Complex ++end HadamardSourceScope25 ++ ++section HadamardSourceScope26 ++ ++namespace Complex ++ ++open _root_.Complex ++namespace CartanBound ++ ++open _root_.Real _root_.Erdos970.Real MeasureTheory intervalIntegral ++open scoped Topology ENNReal ++ ++private lemma neg_log_le_sqrt_two_div {x : ℝ} (hx : 0 < x) (hxle : x ≤ 1) : ++ -Real.log x ≤ Real.sqrt (2 / x) := by ++ have hx0 : 0 ≤ x := le_of_lt hx ++ have ht : 0 ≤ -Real.log x := by ++ have : Real.log x ≤ 0 := Real.log_nonpos hx0 hxle ++ linarith ++ have hsq_div_two_le_exp : ∀ {t : ℝ}, 0 ≤ t → t ^ 2 / 2 ≤ Real.exp t := by ++ intro t ht ++ let g : ℝ → ℝ := fun u => Real.exp u - u ^ 2 / 2 ++ have hg_cont : ContinuousOn g (Set.Ici (0 : ℝ)) := by ++ have : Continuous g := by fun_prop ++ simpa using this.continuousOn ++ have hg_diff : DifferentiableOn ℝ g (interior (Set.Ici (0 : ℝ))) := by ++ intro u hu ++ have : DifferentiableAt ℝ g u := by fun_prop ++ exact this.differentiableWithinAt ++ have hg'_nonneg : ∀ u ∈ interior (Set.Ici (0 : ℝ)), 0 ≤ deriv g u := by ++ intro u hu ++ have hu0 : 0 < u := by simpa [interior_Ici] using hu ++ have hderiv : deriv g u = Real.exp u - u := by ++ have hExp : HasDerivAt Real.exp (Real.exp u) u := Real.hasDerivAt_exp u ++ have hpow2 : HasDerivAt (fun z : ℝ => z ^ 2) (2 * u) u := by ++ simpa using! ((hasDerivAt_id u).pow 2) ++ have hpow2_div : HasDerivAt (fun z : ℝ => z ^ 2 / 2) u u := by ++ simpa using (hpow2.div_const (2 : ℝ)) ++ have hG : HasDerivAt g (Real.exp u - u) u := by ++ simpa [g] using! hExp.sub hpow2_div ++ exact hG.deriv ++ have hu_le : u ≤ Real.exp u := by ++ have h1 : u + 1 ≤ Real.exp u := Real.add_one_le_exp u ++ exact (le_trans (le_add_of_nonneg_right (by norm_num)) h1) ++ have : 0 ≤ Real.exp u - u := sub_nonneg.2 hu_le ++ simpa [hderiv] using this ++ have hg_mono : MonotoneOn g (Set.Ici (0 : ℝ)) := ++ monotoneOn_of_deriv_nonneg (D := Set.Ici (0 : ℝ)) (hD := convex_Ici 0) ++ hg_cont hg_diff hg'_nonneg ++ have hg0 : g 0 = 1 := by simp [g] ++ have hle : g 0 ≤ g t := hg_mono (by simp) (by simpa [Set.mem_Ici] using ht) ht ++ have : (1 : ℝ) ≤ Real.exp t - t ^ 2 / 2 := by simpa [g, hg0] using hle ++ linarith ++ have hmain : (-Real.log x) ^ 2 / 2 ≤ Real.exp (-Real.log x) := hsq_div_two_le_exp ht ++ have hexp : Real.exp (-Real.log x) = x⁻¹ := by simp [Real.exp_neg, Real.exp_log hx] ++ have hsq2 : (-Real.log x) ^ 2 ≤ 2 * Real.exp (-Real.log x) := by nlinarith [hmain] ++ have hsq' : (-Real.log x) ^ 2 ≤ 2 / x := by simpa [hexp, div_eq_mul_inv, mul_assoc] using hsq2 ++ have hy : 0 ≤ 2 / x := div_nonneg (by norm_num) (le_of_lt hx) ++ exact (Real.le_sqrt ht hy).2 hsq' ++ ++lemma posLog_log_one_div_abs_one_sub_le_sqrt {t : ℝ} : ++ Real.posLog (1 / |1 - t|) ≤ Real.sqrt (2 / |1 - t|) := by ++ by_cases ht : |1 - t| ≤ 1 ++ · by_cases h0 : |1 - t| = 0 ++ · have : t = 1 := by ++ have : 1 - t = 0 := by simpa [abs_eq_zero] using h0 ++ linarith ++ subst this ++ simp ++ · have hpos : 0 < |1 - t| := lt_of_le_of_ne (abs_nonneg _) (Ne.symm h0) ++ have hle : -Real.log |1 - t| ≤ Real.sqrt (2 / |1 - t|) := ++ neg_log_le_sqrt_two_div (x := |1 - t|) hpos ht ++ have hlog : Real.log (1 / |1 - t|) = -Real.log |1 - t| := by simp [Real.log_inv] ++ have hnonneg : 0 ≤ Real.log (1 / |1 - t|) := by ++ exact Real.log_nonneg ((one_le_div hpos).2 ht) ++ have hmax : Real.posLog (1 / |1 - t|) = Real.log (1 / |1 - t|) := ++ max_eq_right hnonneg ++ calc ++ Real.posLog (1 / |1 - t|) = Real.log (1 / |1 - t|) := hmax ++ _ = -Real.log |1 - t| := hlog ++ _ ≤ Real.sqrt (2 / |1 - t|) := hle ++ · have hlt : 1 < |1 - t| := lt_of_not_ge ht ++ have hle0 : Real.log (1 / |1 - t|) ≤ 0 := by ++ have hpos : 0 < |1 - t| := lt_trans (by norm_num) hlt ++ have : (1 / |1 - t| : ℝ) ≤ 1 := (div_le_one hpos).2 (le_of_lt hlt) ++ exact le_trans (Real.log_le_log (by positivity) this) (by simp) ++ have hmax : Real.posLog (1 / |1 - t|) = 0 := max_eq_left hle0 ++ have hrhs : 0 ≤ Real.sqrt (2 / |1 - t|) := by ++ exact Real.sqrt_nonneg _ ++ rw [hmax] ++ exact hrhs ++ ++noncomputable def φ (t : ℝ) : ℝ := ++ log⁺ (1 / |1 - t|) ++ ++lemma measurable_phi : Measurable φ := by ++ unfold φ ++ simpa [Real.posLog_def, Real.posLog] using ++ (by fun_prop : Measurable fun t : ℝ => max 0 (Real.log (1 / |1 - t|))) ++ ++lemma phi_le_log_two_of_le_half {t : ℝ} (ht : t ≤ (1 / 2 : ℝ)) : φ t ≤ Real.log 2 := by ++ have hnonneg : 0 ≤ (1 - t : ℝ) := by linarith ++ have hden : (1 / 2 : ℝ) ≤ |1 - t| := by ++ have : (1 / 2 : ℝ) ≤ (1 - t : ℝ) := by linarith ++ simpa [abs_of_nonneg hnonneg] using this ++ have hfrac : (1 / |1 - t| : ℝ) ≤ 2 := by ++ have hhalfpos : (0 : ℝ) < (1 / 2 : ℝ) := by norm_num ++ have := one_div_le_one_div_of_le hhalfpos hden ++ simpa [one_div, div_eq_mul_inv] using this ++ have hposLog : log⁺ (1 / |1 - t|) ≤ log⁺ (2 : ℝ) := ++ Real.posLog_le_posLog ((by trans (0 : ℝ); norm_num; positivity)) hfrac ++ have habs : (1 : ℝ) ≤ |(2 : ℝ)| := by ++ simp ++ have hposLog2 : (log⁺ (2 : ℝ)) = Real.log 2 := by ++ simpa using (Real.posLog_eq_log habs) ++ simpa [φ, hposLog2] using hposLog ++ ++lemma phi_eq_zero_of_one_le_abs_one_sub {t : ℝ} (ht : (1 : ℝ) ≤ |1 - t|) : φ t = 0 := by ++ have hpos : 0 < |1 - t| := lt_of_lt_of_le (by norm_num) ht ++ have hfrac : (1 / |1 - t| : ℝ) ≤ 1 := (div_le_one hpos).2 ht ++ have habs : |(1 / |1 - t| : ℝ)| ≤ 1 := by ++ have hnonneg : 0 ≤ (1 / |1 - t| : ℝ) := by positivity ++ simpa [abs_of_nonneg hnonneg] using hfrac ++ have : log⁺ (1 / |1 - t|) = 0 := (Real.posLog_eq_zero_iff _).2 habs ++ simpa [φ] using this ++ ++lemma φ_nonneg (t : ℝ) : 0 ≤ φ t := by ++ simpa [φ] using (Real.posLog_nonneg (x := (1 / |1 - t|))) ++ ++lemma φ_le_sqrt (t : ℝ) : φ t ≤ Real.sqrt (2 / |1 - t|) := by ++ simpa [φ, Real.posLog] using ++ posLog_log_one_div_abs_one_sub_le_sqrt (t := t) ++ ++lemma ae_restrict_norm_phi_le_of_forall_mem {A B : ℝ} (hAB : A ≤ B) {g : ℝ → ℝ} ++ (hg : ∀ t, 0 ≤ g t) (h : ∀ t ∈ Set.Icc A B, φ t ≤ g t) : ++ (fun t : ℝ => ‖φ t‖) ≤ᶠ[ae (volume.restrict (Set.uIoc A B))] fun t => ‖g t‖ := by ++ refine ++ MeasureTheory.ae_restrict_of_forall_mem (μ := (volume : MeasureTheory.Measure ℝ)) ++ (s := Set.uIoc A B) ++ (by simpa using (measurableSet_uIoc : MeasurableSet (Set.uIoc A B))) ?_ ++ intro t ht ++ have htIoc : t ∈ Set.Ioc A B := by ++ simpa [Set.uIoc_of_le hAB] using ht ++ have htIcc : t ∈ Set.Icc A B := ⟨le_of_lt htIoc.1, htIoc.2⟩ ++ have hle : φ t ≤ g t := h t htIcc ++ have hφ0 : 0 ≤ φ t := φ_nonneg t ++ have hg0 : 0 ≤ g t := hg t ++ simpa [Real.norm_eq_abs, abs_of_nonneg hφ0, abs_of_nonneg hg0] using hle ++ ++lemma log_norm_one_sub_div_ge_neg_phi {u a : ℂ} {r : ℝ} ++ (hur : ‖u‖ = r) (ha : a ≠ 0) (hr : r ≠ ‖a‖) : ++ Real.log ‖(1 : ℂ) - u / a‖ ≥ -φ (r / ‖a‖) := by ++ have ha_norm : 0 < ‖a‖ := norm_pos_iff.2 ha ++ have hnorm_eq : ‖(1 : ℂ) - u / a‖ = ‖a - u‖ / ‖a‖ := by ++ have : (1 : ℂ) - u / a = (a - u) / a := by ++ field_simp [ha] ++ calc ++ ‖(1 : ℂ) - u / a‖ = ‖(a - u) / a‖ := by simp [this] ++ _ = ‖a - u‖ / ‖a‖ := by simp ++ have hrev : |‖a‖ - ‖u‖| ≤ ‖a - u‖ := by ++ simpa using (abs_norm_sub_norm_le a u) ++ have hdiv : |‖a‖ - ‖u‖| / ‖a‖ ≤ ‖a - u‖ / ‖a‖ := ++ div_le_div_of_nonneg_right hrev (le_of_lt ha_norm) ++ have habs : |1 - (r / ‖a‖)| = |‖a‖ - ‖u‖| / ‖a‖ := by ++ have hu : ‖u‖ = r := hur ++ have ha0 : (‖a‖ : ℝ) ≠ 0 := ha_norm.ne' ++ have h1 : (1 : ℝ) - (r / ‖a‖) = (‖a‖ - r) / ‖a‖ := by ++ field_simp [ha0] ++ calc ++ |1 - (r / ‖a‖)| = |(‖a‖ - r) / ‖a‖| := by simp [h1] ++ _ = |‖a‖ - r| / ‖a‖ := by simp [abs_div, abs_of_pos ha_norm] ++ _ = |‖a‖ - ‖u‖| / ‖a‖ := by simp [hu] ++ have hnorm_ge : |1 - (r / ‖a‖)| ≤ ‖(1 : ℂ) - u / a‖ := by ++ have : |1 - (r / ‖a‖)| ≤ ‖a - u‖ / ‖a‖ := by ++ rw [habs] ++ exact hdiv ++ rwa [hnorm_eq] ++ have hx0 : 0 < |1 - (r / ‖a‖)| := by ++ have : (1 - (r / ‖a‖) : ℝ) ≠ 0 := by ++ intro h0 ++ have : r = ‖a‖ := by ++ have : r / ‖a‖ = (1 : ℝ) := by linarith ++ simpa using (div_eq_iff ha_norm.ne').1 this ++ exact hr this ++ have : |1 - (r / ‖a‖)| ≠ 0 := by ++ simpa [abs_eq_zero] using this ++ exact lt_of_le_of_ne (abs_nonneg _) (Ne.symm this) ++ have hlogx : ++ Real.log |1 - (r / ‖a‖)| ≥ -φ (r / ‖a‖) := by ++ have := Real.neg_posLog_inv_le_log (x := |1 - (r / ‖a‖)|) ++ simpa [φ, one_div, inv_inv, abs_sub_comm, sub_eq_add_neg] using this ++ have hlog_mono : ++ Real.log |1 - (r / ‖a‖)| ≤ Real.log ‖(1 : ℂ) - u / a‖ := ++ Real.log_le_log (by positivity) hnorm_ge ++ linarith [hlog_mono, hlogx] ++ ++noncomputable def K : ℝ := ++ ∫ (t : ℝ) in (1 / 4 : ℝ)..(4 : ℝ), Real.sqrt (2 / |1 - t|) ∂volume ++ ++lemma K_nonneg : 0 ≤ K := by ++ have hle : (1 / 4 : ℝ) ≤ (4 : ℝ) := by norm_num ++ have hnn : ∀ t ∈ Set.Icc (1 / 4 : ℝ) (4 : ℝ), 0 ≤ Real.sqrt (2 / |1 - t|) := by ++ intro _t _ht ++ exact Real.sqrt_nonneg _ ++ simpa [K] using (intervalIntegral.integral_nonneg ++ (μ := (volume : MeasureTheory.Measure ℝ)) hle hnn) ++ ++noncomputable def Cφ : ℝ := ++ Real.log 2 + 4 * K + 1 ++ ++lemma Cφ_pos : 0 < Cφ := by ++ have hlog : 0 < Real.log 2 := by ++ simpa using Real.log_pos (by norm_num : (1 : ℝ) < 2) ++ have hK : 0 ≤ K := K_nonneg ++ have : 0 < Real.log 2 + 4 * K := by nlinarith ++ have : 0 < Real.log 2 + 4 * K + 1 := by linarith ++ simpa [Cφ] using this ++ ++lemma intervalIntegrable_sqrt_two_div_abs_one_sub_Icc : ++ IntervalIntegrable ++ (fun t : ℝ => Real.sqrt (2 / |1 - t|)) ++ volume (1 / 4 : ℝ) (4 : ℝ) := by ++ let f : ℝ → ℝ := fun u => Real.sqrt (2 / |u|) ++ have hf0 : IntervalIntegrable f volume (0 : ℝ) (3 : ℝ) := by ++ have hpow : ++ IntervalIntegrable (fun u : ℝ => u ^ (- (2⁻¹ : ℝ))) volume (0 : ℝ) (3 : ℝ) := by ++ simpa using ++ (intervalIntegral.intervalIntegrable_rpow' (a := (0 : ℝ)) (b := (3 : ℝ)) ++ (r := (- (2⁻¹ : ℝ))) (by linarith : (-1 : ℝ) < - (2⁻¹ : ℝ))) ++ have hpow2 : ++ IntervalIntegrable (fun u : ℝ => Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ))) volume (0 : ℝ) (3 : ℝ) := ++ hpow.const_mul (Real.sqrt 2) ++ have hEq : ++ Set.EqOn f (fun u : ℝ => Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ))) (Set.uIoc (0 : ℝ) (3 : ℝ)) := by ++ intro u hu ++ have hu' : u ∈ Set.Ioc (0 : ℝ) (3 : ℝ) := by ++ simpa [Set.uIoc_of_le (show (0 : ℝ) ≤ 3 by norm_num)] using hu ++ have hu0 : 0 < u := hu'.1 ++ have hu0' : 0 ≤ u := le_of_lt hu0 ++ have habs : |u| = u := abs_of_nonneg hu0' ++ have : f u = Real.sqrt (2 / u) := by simp [f, habs] ++ calc ++ f u = Real.sqrt (2 / u) := this ++ _ = Real.sqrt 2 / Real.sqrt u := by simp ++ _ = Real.sqrt 2 * (Real.sqrt u)⁻¹ := by simp [div_eq_mul_inv] ++ _ = Real.sqrt 2 * (u ^ (2⁻¹ : ℝ))⁻¹ := by simp [Real.sqrt_eq_rpow] ++ _ = Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ)) := by ++ have h : (u ^ (2⁻¹ : ℝ))⁻¹ = u ^ (- (2⁻¹ : ℝ)) := by ++ simpa using (Real.rpow_neg hu0' (2⁻¹ : ℝ)).symm ++ simp [h] ++ exact ++ (IntervalIntegrable.congr (a := (0 : ℝ)) (b := (3 : ℝ)) ++ (μ := (volume : MeasureTheory.Measure ℝ)) ++ (f := fun u : ℝ => Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ))) (g := f) hEq.symm) ++ hpow2 ++ have hf0' : IntervalIntegrable f volume (0 : ℝ) (3 / 4 : ℝ) := ++ hf0.mono_set (by ++ intro u hu ++ have hsub : Set.uIcc (0 : ℝ) (3 / 4 : ℝ) ⊆ Set.uIcc (0 : ℝ) (3 : ℝ) := by ++ refine Set.uIcc_subset_uIcc ?_ ?_ ++ · simp ++ · have h0 : (0 : ℝ) ≤ (3 / 4 : ℝ) := by nlinarith ++ have h1 : (3 / 4 : ℝ) ≤ (3 : ℝ) := by nlinarith ++ exact (Set.mem_uIcc).2 (Or.inl ⟨h0, h1⟩) ++ exact hsub hu) ++ have hleft : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume (1 / 4 : ℝ) (1 : ℝ) := by ++ have htmp : ++ IntervalIntegrable (fun t : ℝ => f (1 - t)) volume (1 : ℝ) ((1 : ℝ) - (3 / 4 : ℝ)) := by ++ simpa using (hf0'.comp_sub_left (c := (1 : ℝ))) ++ have htmp' : ++ IntervalIntegrable (fun t : ℝ => f (1 - t)) volume ((1 : ℝ) - (3 / 4 : ℝ)) (1 : ℝ) := ++ htmp.symm ++ have hsub : ((1 : ℝ) - (3 / 4 : ℝ)) = (1 / 4 : ℝ) := by norm_num ++ have htmp'' : IntervalIntegrable (fun t : ℝ => f (1 - t)) volume (1 / 4 : ℝ) (1 : ℝ) := by ++ simpa [hsub] using htmp' ++ simpa [f] using htmp'' ++ have hright : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume (1 : ℝ) (4 : ℝ) := by ++ have htmp : ++ IntervalIntegrable (fun t : ℝ => f (t - 1)) volume (1 : ℝ) ((3 : ℝ) + (1 : ℝ)) := by ++ simpa using (hf0.comp_sub_right (c := (1 : ℝ))) ++ have hsub : ((3 : ℝ) + (1 : ℝ)) = (4 : ℝ) := by norm_num ++ have htmp' : IntervalIntegrable (fun t : ℝ => f (t - 1)) volume (1 : ℝ) (4 : ℝ) := by ++ simpa [hsub] using htmp ++ have hcongr : ++ Set.EqOn (fun t : ℝ => f (t - 1)) (fun t : ℝ => Real.sqrt (2 / |1 - t|)) ++ (Set.uIoc (1 : ℝ) (4 : ℝ)) := by ++ intro t _ht ++ simp [f, abs_sub_comm] ++ exact ++ (IntervalIntegrable.congr (a := (1 : ℝ)) (b := (4 : ℝ)) ++ (μ := (volume : MeasureTheory.Measure ℝ)) ++ (f := fun t : ℝ => f (t - 1)) (g := fun t : ℝ => Real.sqrt (2 / |1 - t|)) hcongr) ++ htmp' ++ exact hleft.trans hright ++ ++lemma phi_le_log_two_on_dyadic_of_le_quarter {A t : ℝ} (hA : A ≤ (1 / 4 : ℝ)) ++ (ht : t ∈ Set.Icc A (2 * A)) : ++ φ t ≤ Real.log 2 := by ++ have ht_le : t ≤ (1 / 2 : ℝ) := by ++ exact ht.2.trans (by nlinarith [hA]) ++ exact phi_le_log_two_of_le_half ht_le ++ ++lemma phi_eq_zero_of_two_le {t : ℝ} (ht : (2 : ℝ) ≤ t) : φ t = 0 := by ++ have hden : (1 : ℝ) ≤ |1 - t| := by ++ have : (1 : ℝ) ≤ t - 1 := by linarith ++ have : (1 : ℝ) ≤ |t - 1| := by ++ simpa [abs_of_nonneg (by linarith : 0 ≤ t - 1)] using this ++ simpa [abs_sub_comm] using this ++ exact phi_eq_zero_of_one_le_abs_one_sub hden ++ ++lemma intervalIntegrable_phi_dyadic_small {A : ℝ} (hA0 : 0 ≤ A) ++ (hA : A ≤ (1 / 4 : ℝ)) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hconst : IntervalIntegrable (fun _ : ℝ => (Real.log 2 : ℝ)) volume A (2 * A) := ++ intervalIntegrable_const ++ have hmeas : ++ AEStronglyMeasurable (fun t : ℝ => φ t) (volume.restrict (Set.uIoc A (2 * A))) := ++ (measurable_phi.aestronglyMeasurable : _) ++ have hdom : ++ (fun t : ℝ => ‖φ t‖) ≤ᶠ[ae (volume.restrict (Set.uIoc A (2 * A)))] ++ fun _ => ‖(Real.log 2 : ℝ)‖ := by ++ refine ae_restrict_norm_phi_le_of_forall_mem (A := A) (B := 2 * A) hA_le ++ (g := fun _ => (Real.log 2 : ℝ)) (hg := fun _ => ?_) ?_ ++ · simpa using (Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 2)) ++ · intro t ht ++ exact phi_le_log_two_on_dyadic_of_le_quarter hA ht ++ exact IntervalIntegrable.mono_fun hconst hmeas hdom ++ ++lemma intervalIntegrable_phi_dyadic_large {A : ℝ} (hA : (2 : ℝ) ≤ A) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hEq : Set.EqOn (fun t : ℝ => φ t) (fun _ => (0 : ℝ)) (Set.uIoc A (2 * A)) := by ++ intro t ht ++ have htIoc : t ∈ Set.Ioc A (2 * A) := by ++ simpa [Set.uIoc_of_le hA_le] using ht ++ exact phi_eq_zero_of_two_le (le_trans hA (le_of_lt htIoc.1)) ++ have hz : IntervalIntegrable (fun _ : ℝ => (0 : ℝ)) volume A (2 * A) := ++ intervalIntegrable_const ++ exact (IntervalIntegrable.congr (a := A) (b := (2 * A)) ++ (μ := (volume : MeasureTheory.Measure ℝ)) ++ (f := fun _ => (0 : ℝ)) (g := fun t => φ t) (by ++ intro t ht ++ simpa using (hEq (x := t) ht).symm)) hz ++ ++lemma intervalIntegrable_sqrt_two_div_abs_one_sub_dyadic_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume A (2 * A) := by ++ have hsqrt_big : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) ++ (volume : MeasureTheory.Measure ℝ) (1 / 4 : ℝ) (4 : ℝ) := ++ intervalIntegrable_sqrt_two_div_abs_one_sub_Icc ++ refine hsqrt_big.mono_set ?_ ++ refine Set.uIcc_subset_uIcc ?_ ?_ ++ · exact (Set.mem_uIcc).2 (Or.inl ⟨hA_lower, by nlinarith [hA_upper]⟩) ++ · exact (Set.mem_uIcc).2 (Or.inl ⟨by nlinarith [hA_lower], by nlinarith [hA_upper]⟩) ++ ++lemma intervalIntegrable_phi_dyadic_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ have hA_le : A ≤ 2 * A := by nlinarith [hA_lower] ++ have hsqrt : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume A (2 * A) := ++ intervalIntegrable_sqrt_two_div_abs_one_sub_dyadic_middle hA_lower hA_upper ++ have hmeas : ++ AEStronglyMeasurable (fun t : ℝ => φ t) (volume.restrict (Set.uIoc A (2 * A))) := ++ (measurable_phi.aestronglyMeasurable : _) ++ have hdom : ++ (fun t : ℝ => ‖φ t‖) ≤ᶠ[ae (volume.restrict (Set.uIoc A (2 * A)))] ++ fun t => ‖Real.sqrt (2 / |1 - t|)‖ := by ++ refine ae_restrict_norm_phi_le_of_forall_mem (A := A) (B := 2 * A) hA_le ++ (g := fun t => Real.sqrt (2 / |1 - t|)) (hg := fun _ => Real.sqrt_nonneg _) ?_ ++ intro t _ht ++ exact φ_le_sqrt t ++ exact IntervalIntegrable.mono_fun hsqrt hmeas hdom ++ ++lemma intervalIntegrable_phi_dyadic {A : ℝ} (hA : 0 ≤ A) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ by_cases hA0 : A = 0 ++ · subst hA0 ++ simp ++ cases le_total A (1 / 4 : ℝ) with ++ | inl hsmall => ++ exact intervalIntegrable_phi_dyadic_small hA hsmall ++ | inr hge_quarter => ++ cases le_total (2 : ℝ) A with ++ | inl hbig => ++ exact intervalIntegrable_phi_dyadic_large hbig ++ | inr hA_le_two => ++ exact intervalIntegrable_phi_dyadic_middle hge_quarter hA_le_two ++ ++lemma intervalIntegrable_phi_div {a R : ℝ} (ha : 0 < a) (hR : 0 ≤ R) : ++ IntervalIntegrable (fun r : ℝ => φ (r / a)) volume R (2 * R) := by ++ have ha0 : a ≠ 0 := ne_of_gt ha ++ have hRa_nonneg : 0 ≤ R / a := by ++ exact div_nonneg hR (le_of_lt ha) ++ have hφ : IntervalIntegrable φ volume (R / a) (2 * (R / a)) := ++ intervalIntegrable_phi_dyadic (A := (R / a)) hRa_nonneg ++ have := (hφ.comp_mul_right (c := (a⁻¹ : ℝ))) ++ have hupper : a * (R * (a⁻¹ * 2)) = (2 * R) := by ++ field_simp [ha0] ++ simpa [div_eq_mul_inv, ha0, hupper, mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma log_two_le_Cφ : Real.log 2 ≤ Cφ := by ++ dsimp [Cφ] ++ have hK : 0 ≤ K := K_nonneg ++ linarith [hK] ++ ++lemma four_mul_K_add_one_le_Cφ : (4 * K + 1 : ℝ) ≤ Cφ := by ++ dsimp [Cφ] ++ have hlog_nonneg : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) ++ linarith [hlog_nonneg] ++ ++lemma integral_phi_le_Cφ_mul_small {A : ℝ} (hA0 : 0 ≤ A) (hA : A ≤ (1 / 4 : ℝ)) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hφ_int : IntervalIntegrable φ volume A (2 * A) := ++ intervalIntegrable_phi_dyadic_small hA0 hA ++ have hconst : IntervalIntegrable (fun _ : ℝ => (Real.log 2 : ℝ)) volume A (2 * A) := ++ intervalIntegrable_const ++ have hle_int : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ++ ≤ ∫ (t : ℝ) in A..(2 * A), (Real.log 2 : ℝ) ∂volume := by ++ refine intervalIntegral.integral_mono_on (μ := (volume : MeasureTheory.Measure ℝ)) ++ hA_le hφ_int hconst ?_ ++ intro t ht ++ exact phi_le_log_two_on_dyadic_of_le_quarter hA ht ++ have hRHS : ++ (∫ (t : ℝ) in A..(2 * A), (Real.log 2 : ℝ) ∂volume) = A * Real.log 2 := by ++ simp [intervalIntegral.integral_const, sub_eq_add_neg, add_assoc, two_mul] ++ have hcoef : A * Real.log 2 ≤ Cφ * A := by ++ have := mul_le_mul_of_nonneg_left log_two_le_Cφ hA0 ++ simpa [mul_assoc, mul_left_comm, mul_comm] using this ++ exact le_trans (by simpa [hRHS] using hle_int) hcoef ++ ++lemma integral_phi_le_Cφ_mul_large {A : ℝ} (hA : (2 : ℝ) ≤ A) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hφ0 : Set.EqOn (fun t : ℝ => φ t) (fun _ => (0 : ℝ)) (Set.uIcc A (2 * A)) := by ++ intro t ht ++ have ht' : t ∈ Set.Icc A (2 * A) := by ++ simpa [Set.uIcc_of_le hA_le] using ht ++ exact phi_eq_zero_of_two_le (le_trans hA ht'.1) ++ have hzero : (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) = 0 := by ++ simpa using intervalIntegral.integral_congr (μ := (volume : MeasureTheory.Measure ℝ)) hφ0 ++ have hnonneg : (0 : ℝ) ≤ Cφ * A := mul_nonneg (le_of_lt Cφ_pos) (by linarith) ++ simpa [hzero] using hnonneg ++ ++lemma integral_sqrt_two_div_abs_one_sub_le_K_dyadic_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ (∫ (t : ℝ) in A..(2 * A), Real.sqrt (2 / |1 - t|) ∂volume) ≤ K := by ++ let s (t : ℝ) : ℝ := Real.sqrt (2 / |1 - t|) ++ have hA_le : A ≤ 2 * A := by nlinarith [hA_lower] ++ have hA_upper' : (2 * A : ℝ) ≤ 4 := by nlinarith [hA_upper] ++ have hsqrt_big : IntervalIntegrable s volume (1 / 4 : ℝ) (4 : ℝ) := by ++ simpa [s] using intervalIntegrable_sqrt_two_div_abs_one_sub_Icc ++ have hle_K : ++ (∫ (t : ℝ) in A..(2 * A), s t ∂volume) ++ ≤ ∫ (t : ℝ) in (1 / 4 : ℝ)..(4 : ℝ), s t ∂volume := by ++ refine intervalIntegral.integral_mono_interval (μ := (volume : MeasureTheory.Measure ℝ)) ++ (c := (1 / 4 : ℝ)) (d := (4 : ℝ)) (a := A) (b := (2 * A)) ++ hA_lower hA_le hA_upper' ?_ hsqrt_big ++ exact Filter.Eventually.of_forall (fun _t => Real.sqrt_nonneg _) ++ simpa [K, s] using hle_K ++ ++lemma K_le_four_mul_K_add_one_mul_of_quarter_le {A : ℝ} (hA : (1 / 4 : ℝ) ≤ A) : ++ K ≤ (4 * K + 1) * A := by ++ have hcoef : 1 ≤ 4 * A := by nlinarith [hA] ++ have hK : 0 ≤ K := K_nonneg ++ nlinarith [hK, hcoef] ++ ++lemma integral_phi_le_Cφ_mul_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ let s (t : ℝ) : ℝ := Real.sqrt (2 / |1 - t|) ++ have hA_le : A ≤ 2 * A := by nlinarith [hA_lower] ++ have hφ_int : IntervalIntegrable φ volume A (2 * A) := ++ intervalIntegrable_phi_dyadic_middle hA_lower hA_upper ++ have hsqrt : IntervalIntegrable s volume A (2 * A) := by ++ simpa [s] using ++ intervalIntegrable_sqrt_two_div_abs_one_sub_dyadic_middle hA_lower hA_upper ++ have hle_int : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ++ ≤ ∫ (t : ℝ) in A..(2 * A), s t ∂volume := by ++ refine intervalIntegral.integral_mono_on ++ (μ := (volume : MeasureTheory.Measure ℝ)) hA_le hφ_int hsqrt ?_ ++ intro t _ht ++ exact φ_le_sqrt t ++ have hsqrt_le : (∫ (t : ℝ) in A..(2 * A), s t ∂volume) ≤ (4 * K + 1) * A := by ++ have hK : (∫ (t : ℝ) in A..(2 * A), s t ∂volume) ≤ K := by ++ simpa [s] using integral_sqrt_two_div_abs_one_sub_le_K_dyadic_middle hA_lower hA_upper ++ exact le_trans hK (K_le_four_mul_K_add_one_mul_of_quarter_le hA_lower) ++ have hcoef : (4 * K + 1 : ℝ) * A ≤ Cφ * A := ++ mul_le_mul_of_nonneg_right four_mul_K_add_one_le_Cφ (by nlinarith [hA_lower]) ++ exact le_trans hle_int (le_trans hsqrt_le hcoef) ++ ++lemma integral_phi_le_Cφ_mul {A : ℝ} (hA : 0 ≤ A) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ by_cases hA0 : A = 0 ++ · subst hA0 ++ simp [Cφ, φ, K] ++ cases le_total A (1 / 4 : ℝ) with ++ | inl hsmall => ++ exact integral_phi_le_Cφ_mul_small hA hsmall ++ | inr hge_quarter => ++ cases le_total (2 : ℝ) A with ++ | inl hbig => ++ exact integral_phi_le_Cφ_mul_large hbig ++ | inr hA_le_two => ++ exact integral_phi_le_Cφ_mul_middle hge_quarter hA_le_two ++ ++open scoped BigOperators ++ ++lemma volume_Ioc_two_mul_ne_zero {R : ℝ} (hR : 0 < R) : ++ (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R)) ≠ 0 := by ++ have hpos : (0 : ℝ) < 2 * R - R := by nlinarith [hR] ++ simp [Real.volume_Ioc, ENNReal.ofReal_eq_zero, not_le_of_gt hpos] ++ ++lemma volume_Ioc_two_mul_diff_finset_ne_zero (bad : Finset ℝ) {R : ℝ} (hR : 0 < R) : ++ (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ≠ 0 := by ++ have hbad_meas : (volume : MeasureTheory.Measure ℝ) (bad : Set ℝ) = 0 := by ++ simpa using (bad.measure_zero (μ := (volume : MeasureTheory.Measure ℝ))) ++ have hdiff : ++ (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ++ = (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R)) := by ++ simpa [Set.sdiff_eq, Set.inter_assoc, Set.inter_left_comm, Set.inter_comm] using ++ (MeasureTheory.measure_sdiff_null (s := Set.Ioc R (2 * R)) (t := (bad : Set ℝ)) ++ hbad_meas) ++ simpa [hdiff] using volume_Ioc_two_mul_ne_zero hR ++ ++lemma restrict_volume_Ioc_two_mul_diff_finset_ne_zero (bad : Finset ℝ) {R : ℝ} (hR : 0 < R) : ++ (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ≠ 0 := by ++ have hsubset : Set.Ioc R (2 * R) \ (bad : Set ℝ) ⊆ Set.Ioc R (2 * R) := by ++ intro r hr ++ exact hr.1 ++ have hinter : ++ (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ∩ Set.Ioc R (2 * R) ++ = (Set.Ioc R (2 * R) \ (bad : Set ℝ)) := by ++ exact Set.inter_eq_left.mpr hsubset ++ simpa [MeasureTheory.Measure.restrict_apply, measurableSet_Ioc, hinter] using ++ volume_Ioc_two_mul_diff_finset_ne_zero bad hR ++ ++lemma integral_phi_div_le_Cφ_mul {a R : ℝ} (ha : 0 < a) (hR : 0 ≤ R) : ++ (∫ (r : ℝ) in R..(2 * R), φ (r / a) ∂volume) ≤ Cφ * R := by ++ have ha0 : a ≠ 0 := ne_of_gt ha ++ have hrew : ++ (∫ (r : ℝ) in R..(2 * R), φ (r / a) ∂volume) ++ = a * (∫ (t : ℝ) in (R / a)..(2 * R / a), φ t ∂volume) := by ++ simp [smul_eq_mul, mul_left_comm, mul_comm, div_eq_mul_inv, ha0] ++ rw [hrew] ++ have hA : 0 ≤ R / a := by ++ exact div_nonneg hR ha.le ++ have hle : (∫ (t : ℝ) in (R / a)..(2 * (R / a)), φ t ∂volume) ≤ Cφ * (R / a) := ++ integral_phi_le_Cφ_mul (A := R / a) hA ++ have hEq : (2 * R / a) = 2 * (R / a) := by ring ++ have hle' : ++ (∫ (t : ℝ) in (R / a)..(2 * R / a), φ t ∂volume) ≤ Cφ * (R / a) := by ++ simpa [hEq] using hle ++ have ha_nonneg : 0 ≤ a := ha.le ++ have := mul_le_mul_of_nonneg_left hle' ha_nonneg ++ have hRHS : a * (Cφ * (R / a)) = Cφ * R := by ++ field_simp [ha0] ++ simpa [hRHS, mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma intervalIntegrable_sum_mul_phi_div ++ {ι : Type} (s : Finset ι) (w : ι → ℝ) (a : ι → ℝ) ++ (ha : ∀ i ∈ s, 0 < a i) {R : ℝ} (hR : 0 ≤ R) : ++ IntervalIntegrable (∑ i ∈ s, fun r : ℝ => w i * φ (r / a i)) ++ volume R (2 * R) := by ++ refine IntervalIntegrable.sum (μ := volume) (a := R) (b := 2 * R) ++ (s := s) (f := fun i : ι => fun r : ℝ => w i * φ (r / a i)) ?_ ++ intro i hi ++ have hφi : IntervalIntegrable (fun r : ℝ => φ (r / a i)) volume R (2 * R) := ++ intervalIntegrable_phi_div (a := a i) (R := R) (ha i hi) hR ++ simpa [mul_assoc] using hφi.const_mul (w i) ++ ++lemma integral_sum_mul_phi_div_le_Cφ_mul_sum ++ {ι : Type} (s : Finset ι) (w : ι → ℝ) (a : ι → ℝ) ++ (hw : ∀ i ∈ s, 0 ≤ w i) (ha : ∀ i ∈ s, 0 < a i) {R : ℝ} (hR : 0 ≤ R) : ++ (∫ r in R..(2 * R), (∑ i ∈ s, fun r : ℝ => w i * φ (r / a i)) r ∂volume) ++ ≤ Cφ * (∑ i ∈ s, w i) * R := by ++ have hint : ∀ i ∈ s, IntervalIntegrable (fun r : ℝ => w i * φ (r / a i)) ++ volume R (2 * R) := by ++ intro i hi ++ have hφi : IntervalIntegrable (fun r : ℝ => φ (r / a i)) volume R (2 * R) := ++ intervalIntegrable_phi_div (a := a i) (R := R) (ha i hi) hR ++ simpa [mul_assoc] using hφi.const_mul (w i) ++ have hsum_int : ++ (∫ r in R..(2 * R), (∑ i ∈ s, fun r : ℝ => w i * φ (r / a i)) r ∂volume) ++ = ∑ i ∈ s, ∫ r in R..(2 * R), (fun r : ℝ => w i * φ (r / a i)) r ++ ∂volume := by ++ simpa using ++ (intervalIntegral.integral_finsetSum (μ := volume) (a := R) (b := 2 * R) ++ (s := s) (f := fun i : ι => fun r : ℝ => w i * φ (r / a i)) hint) ++ rw [hsum_int] ++ have hsum_le : ++ (∑ i ∈ s, ∫ r in R..(2 * R), (fun r : ℝ => w i * φ (r / a i)) r ∂volume) ++ ≤ ∑ i ∈ s, w i * (Cφ * R) := by ++ refine Finset.sum_le_sum ?_ ++ intro i hi ++ have hphi : ++ (∫ r in R..(2 * R), φ (r / a i) ∂volume) ≤ Cφ * R := ++ integral_phi_div_le_Cφ_mul (a := a i) (R := R) (ha i hi) hR ++ have := mul_le_mul_of_nonneg_left hphi (hw i hi) ++ simpa [mul_assoc, mul_left_comm, mul_comm] using this ++ refine le_trans hsum_le ?_ ++ have : (∑ i ∈ s, w i * (Cφ * R)) = Cφ * (∑ i ∈ s, w i) * R := by ++ calc ++ (∑ i ∈ s, w i * (Cφ * R)) = (∑ i ∈ s, w i) * (Cφ * R) := by ++ simp [Finset.sum_mul] ++ _ = Cφ * (∑ i ∈ s, w i) * R := by ++ ac_rfl ++ exact le_of_eq this ++ ++lemma exists_radius_Ioc_sum_mul_phi_div_le_Cφ_mul_sum_avoid ++ {ι : Type} (s : Finset ι) (w : ι → ℝ) (a : ι → ℝ) ++ (hw : ∀ i ∈ s, 0 ≤ w i) (ha : ∀ i ∈ s, 0 < a i) ++ (bad : Finset ℝ) {R : ℝ} (hR : 0 < R) : ++ ∃ r ∈ Set.Ioc R (2 * R), r ∉ bad ∧ ++ (∑ i ∈ s, w i * φ (r / a i)) ≤ Cφ * (∑ i ∈ s, w i) := by ++ by_contra hbad ++ have hforall : ++ ∀ r ∈ Set.Ioc R (2 * R), r ∉ bad → ++ Cφ * (∑ i ∈ s, w i) < (∑ i ∈ s, w i * φ (r / a i)) := by ++ intro r hr hrbad ++ have : ¬(∑ i ∈ s, w i * φ (r / a i)) ≤ Cφ * (∑ i ∈ s, w i) := by ++ intro hle ++ exact hbad ⟨r, hr, hrbad, hle⟩ ++ exact lt_of_not_ge this ++ let g : ℝ → ℝ := ∑ i ∈ s, fun r : ℝ => w i * φ (r / a i) ++ have hg_int : IntervalIntegrable g volume R (2 * R) := by ++ simpa [g] using intervalIntegrable_sum_mul_phi_div s w a ha hR.le ++ have hconst_int : ++ IntervalIntegrable (fun _r : ℝ => Cφ * (∑ i ∈ s, w i)) volume R (2 * R) := ++ intervalIntegrable_const ++ have hlt_meas : ++ (volume.restrict (Set.Ioc R (2 * R))) ++ {r | Cφ * (∑ i ∈ s, w i) < g r} ≠ 0 := by ++ have hall : Set.Ioc R (2 * R) \ (bad : Set ℝ) ⊆ {r | Cφ * (∑ i ∈ s, w i) < g r} := by ++ intro r hr ++ have hrIoc : r ∈ Set.Ioc R (2 * R) := hr.1 ++ have hrbad : r ∉ bad := by simpa using hr.2 ++ simpa [g] using hforall r hrIoc hrbad ++ have hle : ++ (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ++ ≤ (volume.restrict (Set.Ioc R (2 * R))) {r | Cφ * (∑ i ∈ s, w i) < g r} := ++ MeasureTheory.measure_mono hall ++ have hpos' : ++ (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ≠ 0 := by ++ exact restrict_volume_Ioc_two_mul_diff_finset_ne_zero bad hR ++ intro hzero ++ have : (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) = 0 := ++ le_antisymm (le_trans hle (le_of_eq hzero)) (by positivity) ++ exact hpos' this ++ have hlt_int : ++ (∫ r in R..(2 * R), (Cφ * (∑ i ∈ s, w i)) ∂volume) ++ < ∫ r in R..(2 * R), g r ∂volume := by ++ have hab : R ≤ 2 * R := by nlinarith [hR.le] ++ refine intervalIntegral.integral_lt_integral_of_ae_le_of_measure_setOfPred_lt_ne_zero (μ := volume) ++ (a := R) (b := 2 * R) (f := fun _ => (Cφ * (∑ i ∈ s, w i))) (g := g) ++ hab hconst_int hg_int ?_ hlt_meas ++ have hmem : ∀ᵐ r ∂ (volume.restrict (Set.Ioc R (2 * R))), r ∈ Set.Ioc R (2 * R) := ++ MeasureTheory.ae_restrict_mem (by simp) ++ have hnotBad : ++ ∀ᵐ r ∂ (volume.restrict (Set.Ioc R (2 * R))), r ∉ (bad : Set ℝ) := by ++ simpa using ++ (bad.finite_toSet.countable.ae_notMem (μ := (volume.restrict (Set.Ioc R (2 * R))))) ++ filter_upwards [hmem, hnotBad] with r hrIoc hrNotBad ++ have hrNotBad' : r ∉ bad := by simpa using hrNotBad ++ exact le_of_lt (by simpa [g] using hforall r hrIoc hrNotBad') ++ have hconst_eval : ++ (∫ r in R..(2 * R), (Cφ * (∑ i ∈ s, w i)) ∂volume) = Cφ * (∑ i ∈ s, w i) * R := by ++ simp [intervalIntegral.integral_const, sub_eq_add_neg, mul_comm] ++ ring ++ have hg_le : ++ (∫ r in R..(2 * R), g r ∂volume) ≤ Cφ * (∑ i ∈ s, w i) * R := by ++ simpa [g] using integral_sum_mul_phi_div_le_Cφ_mul_sum s w a hw ha hR.le ++ have : ¬(Cφ * (∑ i ∈ s, w i) * R < Cφ * (∑ i ∈ s, w i) * R) := lt_irrefl _ ++ have hcontra : Cφ * (∑ i ∈ s, w i) * R < Cφ * (∑ i ∈ s, w i) * R := by ++ have := hlt_int ++ simpa [hconst_eval] using (this.trans_le hg_le) ++ exact this hcontra ++ ++end CartanBound ++end Complex ++end HadamardSourceScope26 ++ ++section HadamardSourceScope27 ++ ++noncomputable section ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++open _root_.Complex _root_.Erdos970.Complex _root_.Real _root_.Erdos970.Real ++ ++lemma max_one_norm_div_pow_le_one_add_rpow ++ {m : ℕ} {τ r : ℝ} {u a : ℂ} ++ (hur : ‖u‖ = r) ++ (hmτ : (m : ℝ) ≤ τ) : ++ max 1 (‖u / a‖ ^ m) ≤ 1 + (r / ‖a‖) ^ τ := by ++ by_cases hx : ‖u / a‖ ≤ 1 ++ · have hpowm_le1 : ‖u / a‖ ^ m ≤ 1 := pow_le_one₀ (norm_nonneg (u / a)) hx ++ have hr0 : 0 ≤ r := by simpa [hur] using (norm_nonneg u) ++ have hbase : 0 ≤ r / ‖a‖ := div_nonneg hr0 (norm_nonneg a) ++ have hnonneg : 0 ≤ (r / ‖a‖) ^ τ := Real.rpow_nonneg hbase τ ++ have hle1 : (1 : ℝ) ≤ 1 + (r / ‖a‖) ^ τ := le_add_of_nonneg_right hnonneg ++ have hle2 : ‖u / a‖ ^ m ≤ 1 + (r / ‖a‖) ^ τ := hpowm_le1.trans hle1 ++ exact (max_le_iff).2 ⟨hle1, hle2⟩ ++ · have hx1 : 1 < ‖u / a‖ := lt_of_not_ge hx ++ have hpow : ++ (‖u / a‖ : ℝ) ^ (m : ℝ) ≤ (‖u / a‖ : ℝ) ^ τ := ++ Real.rpow_le_rpow_of_exponent_le (le_of_lt hx1) hmτ ++ have hpow' : ‖u / a‖ ^ m ≤ (‖u / a‖ : ℝ) ^ τ := by ++ simpa [Real.rpow_natCast] using hpow ++ have hmax_add : max 1 (‖u / a‖ ^ m) ≤ 1 + ‖u / a‖ ^ m := by ++ refine max_le (le_add_of_nonneg_right (by positivity)) (le_add_of_nonneg_left (by positivity)) ++ have : max 1 (‖u / a‖ ^ m) ≤ 1 + (‖u / a‖ : ℝ) ^ τ := ++ hmax_add.trans (by nlinarith [hpow']) ++ simpa [norm_div, hur] using this ++ ++lemma norm_inv_weierstrassFactor_le_exp_near ++ {m : ℕ} {τ r : ℝ} {u a : ℂ} ++ (hur : ‖u‖ = r) (ha : a ≠ 0) (hr : r ≠ ‖a‖) ++ (hmτ : (m : ℝ) ≤ τ) : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ ++ ≤ Real.exp (CartanBound.φ (r / ‖a‖) + (m : ℝ) * (1 + (r / ‖a‖) ^ τ)) := by ++ have hlog_one : ++ Real.log ‖(1 : ℂ) - u / a‖ ≥ -CartanBound.φ (r / ‖a‖) := ++ CartanBound.log_norm_one_sub_div_ge_neg_phi (hur := hur) (ha := ha) (hr := hr) ++ have hbase := ++ log_norm_weierstrassFactor_ge_log_norm_one_sub_sub (m := m) (z := (u / a)) ++ have hlogE : ++ Real.log ‖weierstrassFactor m (u / a)‖ ++ ≥ -CartanBound.φ (r / ‖a‖) - (m : ℝ) * max 1 (‖u / a‖ ^ m) := by ++ have hpls := ++ norm_partialLogSum_le_nat_mul_max_one_norm_pow m (u / a) ++ linarith [hbase, hlog_one, hpls] ++ have hmax : ++ max 1 (‖u / a‖ ^ m) ≤ 1 + (r / ‖a‖) ^ τ := ++ max_one_norm_div_pow_le_one_add_rpow (m := m) (τ := τ) (r := r) (u := u) (a := a) hur hmτ ++ have hneglog : ++ -Real.log ‖weierstrassFactor m (u / a)‖ ++ ≤ CartanBound.φ (r / ‖a‖) + (m : ℝ) * (1 + (r / ‖a‖) ^ τ) := by ++ have : -Real.log ‖weierstrassFactor m (u / a)‖ ++ ≤ CartanBound.φ (r / ‖a‖) + (m : ℝ) * max 1 (‖u / a‖ ^ m) := by ++ linarith [hlogE] ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ exact this.trans (by nlinarith [mul_le_mul_of_nonneg_left hmax hm0]) ++ have hpos : 0 < ‖weierstrassFactor m (u / a)‖ := by ++ have : weierstrassFactor m (u / a) ≠ 0 := by ++ intro h0 ++ have : u / a = (1 : ℂ) := (weierstrassFactor_eq_zero_iff m (u / a)).1 h0 ++ have : u = a := (div_eq_one_iff_eq ha).1 this ++ have : r = ‖a‖ := by simpa [this] using hur.symm ++ exact (hr this).elim ++ exact norm_pos_iff.2 this ++ have hEq : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ = ++ Real.exp (-Real.log ‖weierstrassFactor m (u / a)‖) := by ++ simp [norm_inv, Real.exp_neg, Real.exp_log hpos] ++ have := Real.exp_le_exp.2 hneglog ++ simpa [hEq] using this ++ ++lemma norm_inv_weierstrassFactor_le_exp_far ++ {m : ℕ} {τ r : ℝ} {u a : ℂ} ++ (hur : ‖u‖ = r) (ha : a ≠ 0) ++ (hz : ‖u / a‖ ≤ (1 / 2 : ℝ)) (hτ_le : τ ≤ (m + 1 : ℝ)) : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ ≤ Real.exp ((2 : ℝ) * (r / ‖a‖) ^ τ) := by ++ by_cases hu : u = 0 ++ · subst hu ++ have hr0 : r = 0 := by simpa [hur] using (norm_zero : ‖(0 : ℂ)‖ = 0) ++ subst hr0 ++ have h0 : 0 ≤ ((0 : ℝ) / ‖a‖) ^ τ := by ++ exact Real.rpow_nonneg (by positivity : (0 : ℝ) ≤ 0 / ‖a‖) τ ++ have h0' : 0 ≤ (2 : ℝ) * ((0 : ℝ) / ‖a‖) ^ τ := mul_nonneg (by norm_num) h0 ++ have hexp : (1 : ℝ) ≤ Real.exp ((2 : ℝ) * ((0 : ℝ) / ‖a‖) ^ τ) := ++ (Real.one_le_exp_iff).2 h0' ++ simpa using hexp ++ have hlogE := ++ log_norm_weierstrassFactor_ge_neg_two_pow (m := m) (z := (u / a)) hz ++ have hneglog : -Real.log ‖weierstrassFactor m (u / a)‖ ≤ (2 : ℝ) * (r / ‖a‖) ^ τ := by ++ have h1 : -Real.log ‖weierstrassFactor m (u / a)‖ ≤ (2 : ℝ) * ‖u / a‖ ^ (m + 1) := by ++ linarith [hlogE] ++ set x : ℝ := ‖u / a‖ ++ have hx1 : x ≤ 1 := le_trans (by simpa [x] using hz) (by norm_num) ++ have hxpos : 0 < x := by ++ simpa [x] using (norm_pos_iff.2 (div_ne_zero hu ha)) ++ have hτ_le' : τ ≤ ((m + 1 : ℕ) : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one] using hτ_le ++ have hpow_rpow : x ^ ((m + 1 : ℕ) : ℝ) ≤ x ^ τ := ++ Real.rpow_le_rpow_of_exponent_ge hxpos hx1 hτ_le' ++ have hpow : x ^ (m + 1) ≤ x ^ τ := by ++ simpa [← Real.rpow_natCast] using hpow_rpow ++ have h2x : (2 : ℝ) * x ^ (m + 1) ≤ (2 : ℝ) * x ^ τ := ++ mul_le_mul_of_nonneg_left hpow (by positivity) ++ have h2 : (2 : ℝ) * ‖u / a‖ ^ (m + 1) ≤ (2 : ℝ) * (‖u / a‖ : ℝ) ^ τ := by ++ simpa [x] using h2x ++ have h3 : (‖u‖ / ‖a‖) ^ τ = (r / ‖a‖) ^ τ := by ++ simp [hur] ++ exact (h1.trans h2).trans_eq (by simp [h3]) ++ have hpos : 0 < ‖weierstrassFactor m (u / a)‖ := by ++ have : weierstrassFactor m (u / a) ≠ 0 := by ++ intro h0 ++ have : u / a = (1 : ℂ) := (weierstrassFactor_eq_zero_iff m (u / a)).1 h0 ++ have : u = a := (div_eq_one_iff_eq ha).1 this ++ have : (‖u / a‖ : ℝ) = 1 := by simpa [this] using (by simp [ha]) ++ linarith [hz, this] ++ exact norm_pos_iff.2 this ++ have hEq : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ = ++ Real.exp (-Real.log ‖weierstrassFactor m (u / a)‖) := by ++ simp [norm_inv, Real.exp_neg, Real.exp_log hpos] ++ have := Real.exp_le_exp.2 hneglog ++ simpa [hEq] using this ++ ++end Complex.Hadamard ++end ++end HadamardSourceScope27 ++ ++section HadamardSourceScope28 ++ ++noncomputable section ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++open scoped BigOperators ++open Filter Finset _root_.Real _root_.Erdos970.Real Topology ++ ++section CartanFiniteSum ++ ++variable {α : Type*} ++ ++private lemma summable_ite_mem_finset [DecidableEq α] (s : Finset α) (u : α → ℝ) : ++ Summable (fun a => if a ∈ s then u a else 0) := ++ summable_of_ne_finset_zero (s := s) fun a ha => by simp [ite_eq_right ha] ++ ++private lemma tsum_ite_mem_finset [DecidableEq α] (s : Finset α) (u : α → ℝ) : ++ (∑' a, if a ∈ s then u a else 0) = ∑ a ∈ s, u a := by ++ classical ++ simpa [Finset.sum_ite] using ++ (hasSum_sum_of_ne_finset_zero (s := s) (f := fun a => if a ∈ s then u a else 0) ++ fun a ha => by simp [ite_eq_right ha]).tsum_eq ++ ++private lemma tsum_add_four (u₁ u₂ u₃ u₄ : α → ℝ) ++ (h₁ : Summable u₁) (h₂ : Summable u₂) (h₃ : Summable u₃) (h₄ : Summable u₄) : ++ tsum (fun a => ((u₁ a + u₂ a) + u₃ a) + u₄ a) ++ = tsum u₁ + tsum u₂ + tsum u₃ + tsum u₄ := by ++ calc ++ tsum (fun a => ((u₁ a + u₂ a) + u₃ a) + u₄ a) ++ = tsum (fun a => (u₁ a + u₂ a) + (u₃ a + u₄ a)) := by ++ simp [add_comm, add_left_comm] ++ _ = tsum (fun a => u₁ a + u₂ a) + tsum (fun a => u₃ a + u₄ a) := ++ Summable.tsum_add (h₁.add h₂) (h₃.add h₄) ++ _ = tsum u₁ + tsum u₂ + tsum u₃ + tsum u₄ := by ++ rw [Summable.tsum_add h₁ h₂, Summable.tsum_add h₃ h₄] ++ ring ++ ++end CartanFiniteSum ++ ++noncomputable def cartanProductConstant (m : ℕ) (τ Sτ : ℝ) : ℝ := ++ ((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 3) * (Sτ + 1) ++ ++lemma cartanProductConstant_nonneg {m : ℕ} {τ Sτ : ℝ} (hSτ : 0 ≤ Sτ) : ++ 0 ≤ cartanProductConstant m τ Sτ := by ++ have hS : 0 ≤ Sτ + 1 := by linarith ++ have hA : 0 ≤ (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 3 := by ++ have hCφ : 0 ≤ CartanBound.Cφ := le_of_lt CartanBound.Cφ_pos ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ have h4τ : 0 ≤ (4 : ℝ) ^ τ := by positivity ++ nlinarith [hCφ, hm0, h4τ] ++ simpa [cartanProductConstant] using mul_nonneg hA hS ++ ++lemma rpow_div_norm_divisorZeroIndex₀_eq ++ {f : ℂ → ℂ} {r τ : ℝ} (hr : 0 ≤ r) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ = ++ (r ^ τ) * ((‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) := by ++ have hp : 0 ≤ (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) := by positivity ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using ++ (Real.mul_rpow (x := r) (y := (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ)) (z := τ) hr hp) ++ ++lemma tsum_rpow_div_norm_divisorZeroIndex₀_eq ++ {f : ℂ → ℂ} {r τ : ℝ} (hr : 0 ≤ r) : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = (r ^ τ) * ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ calc ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ := by ++ refine tsum_congr ?_ ++ intro p ++ exact rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p ++ _ = (r ^ τ) * ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ simp [tsum_mul_left] ++ ++lemma tsum_two_mul_rpow_div_norm_divisorZeroIndex₀_le ++ {f : ℂ → ℂ} {r τ : ℝ} (hr : 0 ≤ r) (hτ_nonneg : 0 ≤ τ) : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (2 : ℝ) * (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ ≤ (2 : ℝ) * ((∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) + 1) * (1 + r) ^ τ := by ++ set Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have htsum : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (2 : ℝ) * (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = (2 : ℝ) * (r ^ τ) * Sτ := by ++ calc ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (2 : ℝ) * (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = (2 : ℝ) * ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ := by ++ simp [tsum_mul_left] ++ _ = (2 : ℝ) * ((r ^ τ) * Sτ) := by ++ rw [tsum_rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr] ++ _ = (2 : ℝ) * (r ^ τ) * Sτ := by ring ++ have hSτ_nonneg : 0 ≤ Sτ := ++ tsum_nonneg (fun _ => Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _) ++ have h1r : r ^ τ ≤ (1 + r) ^ τ := ++ Real.rpow_le_rpow (by positivity) (by linarith) hτ_nonneg ++ have hS : Sτ ≤ Sτ + 1 := by linarith ++ have hle : (r ^ τ) * Sτ ≤ (1 + r) ^ τ * (Sτ + 1) := ++ mul_le_mul h1r hS (by linarith) (by positivity) ++ rw [htsum] ++ have : (2 : ℝ) * (r ^ τ) * Sτ ≤ (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ nlinarith [hle] ++ simpa [Sτ, mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma sum_rpow_div_norm_divisorZeroIndex₀_le ++ {f : ℂ → ℂ} {r τ : ℝ} (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hr : 0 ≤ r) (hτ_nonneg : 0 ≤ τ) ++ (hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ (∑ p ∈ small, (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ ≤ ((∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) + 1) * (1 + r) ^ τ := by ++ set Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have hsum_inv : ++ (∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ≤ Sτ := by ++ have hnn : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ 0 ≤ (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ := by ++ intro p ++ positivity ++ simpa [Sτ] using ++ (Summable.sum_le_tsum (s := small) ++ (f := fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ++ (fun p _ => hnn p) hsumτ) ++ have hsum_eq : ++ ∑ p ∈ small, (r / ‖divisorZeroIndex₀Val p‖) ^ τ = ++ (r ^ τ) * ∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ := by ++ simp [rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr, Finset.mul_sum] ++ have h1r : r ^ τ ≤ (1 + r) ^ τ := ++ Real.rpow_le_rpow (by positivity) (by linarith) hτ_nonneg ++ have hS : (∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ≤ Sτ + 1 := by ++ linarith [hsum_inv] ++ have hle : ++ (r ^ τ) * (∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ++ ≤ (1 + r) ^ τ * (Sτ + 1) := ++ mul_le_mul h1r hS (by positivity) (by positivity) ++ simpa [Sτ, hsum_eq, mul_assoc, mul_left_comm, mul_comm] using hle ++ ++lemma add_four_le_add_two_mul_of_le {x₁ x₂ x₃ x₄ A B C : ℝ} ++ (h₁ : x₁ ≤ A) (h₂ : x₂ ≤ B) (h₃ : x₃ ≤ B) (h₄ : x₄ ≤ C) : ++ x₁ + x₂ + x₃ + x₄ ≤ A + 2 * B + C := by ++ nlinarith ++ ++lemma cartan_majorant_four_term_bound ++ {xφ x0 xm xt Cφ m q Y T : ℝ} ++ (hφ : xφ ≤ Cφ * q * Y * T) ++ (h0 : x0 ≤ m * q * Y * T) ++ (hm : xm ≤ m * q * Y * T) ++ (ht : xt ≤ (2 : ℝ) * Y * T) : ++ xφ + x0 + xm + xt ≤ (Cφ + (2 : ℝ) * m) * q * Y * T + (2 : ℝ) * Y * T := by ++ have h := ++ add_four_le_add_two_mul_of_le hφ h0 hm ht ++ have hring : ++ Cφ * (q * (Y * T)) + 2 * (m * (q * (Y * T))) + 2 * (Y * T) ++ = (Cφ + (2 : ℝ) * m) * (q * (Y * T)) + (2 : ℝ) * (Y * T) := by ++ ring ++ simpa [mul_assoc, hring] using h ++ ++lemma cartan_majorant_add_two_factor (A Y T : ℝ) : ++ A * Y * T + (2 : ℝ) * Y * T = ((A + 2) * Y) * T := by ++ ring ++ ++lemma cartan_majorant_pad_two_to_three {A S T : ℝ} (hS : 0 ≤ S + 1) (hT : 0 ≤ T) : ++ ((A + 2) * (S + 1)) * T ≤ ((A + 3) * (S + 1)) * T := by ++ have h : (A + 2) * (S + 1) ≤ (A + 3) * (S + 1) := by ++ nlinarith ++ exact mul_le_mul_of_nonneg_right h hT ++ ++lemma cartan_majorant_nonneg ++ {f : ℂ → ℂ} {m : ℕ} {τ r : ℝ} (hr : 0 ≤ r) ++ (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ letI : DecidableEq (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := Classical.decEq _ ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ ∀ p, 0 ≤ b p := by ++ classical ++ dsimp ++ intro p ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun q => ‖divisorZeroIndex₀Val q‖ ++ have hap : ap p = ‖divisorZeroIndex₀Val p‖ := rfl ++ by_cases hp : p ∈ small ++ · have hφ : 0 ≤ CartanBound.φ (r / ap p) := CartanBound.φ_nonneg (t := r / ap p) ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ have h1 : 0 ≤ (1 + (r / ap p) ^ τ) := by positivity ++ have : 0 ≤ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) := by ++ nlinarith [hφ, hm0, h1] ++ simpa [hap, hp, ap] using this ++ · have hbase : 0 ≤ r / ap p := div_nonneg hr (by positivity) ++ have hpow : 0 ≤ (r / ap p) ^ τ := Real.rpow_nonneg hbase τ ++ have : 0 ≤ (2 : ℝ) * (r / ap p) ^ τ := mul_nonneg (by norm_num) hpow ++ simpa [hap, hp, ap] using this ++ ++lemma cartan_majorant_summable ++ {f : ℂ → ℂ} {m : ℕ} {τ r : ℝ} (hr : 0 ≤ r) ++ (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ letI : DecidableEq (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := Classical.decEq _ ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ Summable b := by ++ classical ++ dsimp ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun q => ‖divisorZeroIndex₀Val q‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ have hb : Summable b := by ++ let b₁ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else 0 ++ let b₂ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then 0 else (2 : ℝ) * (r / ap p) ^ τ ++ have hb_decomp : b = fun p => b₁ p + b₂ p := by ++ funext p ++ by_cases hp : p ∈ small <;> simp [b, b₁, b₂, hp] ++ have hb₁ : Summable b₁ := by ++ simpa [b₁] using ++ summable_ite_mem_finset small ++ (fun p => CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ)) ++ have hb₂ : Summable b₂ := by ++ have hconst : ++ Summable (fun p => ++ (2 : ℝ) * (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) := ++ hsumτ.mul_left ((2 : ℝ) * (r ^ τ)) ++ refine Summable.of_nonneg_of_le ++ (fun p => by ++ by_cases hp : p ∈ small ++ · simp [b₂, hp] ++ · have : 0 ≤ (2 : ℝ) * (r / ap p) ^ τ := by positivity ++ simpa [b₂, hp] using this) ++ (fun p => ?_) hconst ++ by_cases hp : p ∈ small ++ · have : 0 ≤ (2 : ℝ) * (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by positivity ++ simpa [b₂, hp] using this ++ · have hrpow : (r / ap p) ^ τ = (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by ++ simpa [ap] using rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p ++ simp [b₂, hp, hrpow, mul_assoc, mul_left_comm, mul_comm] ++ simpa [hb_decomp] using hb₁.add hb₂ ++ refine hb.congr ?_ ++ intro p ++ by_cases hp : p ∈ small <;> simp [b, ap, hp] ++ ++lemma cartan_card_small_le ++ {f : ℂ → ℂ} {τ R : ℝ} (hRpos : 0 < R) (hτ_nonneg : 0 ≤ τ) ++ (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall : ∀ p ∈ small, ‖divisorZeroIndex₀Val p‖ ≤ 4 * R) ++ (hsumτ : ++ Summable ++ (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ (small.card : ℝ) ++ ≤ (4 * R) ^ τ ++ * ((∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) + 1) := by ++ classical ++ set Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have hsum_le : (∑ p ∈ small, ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) ≤ Sτ := by ++ have hnn : ++ ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ 0 ≤ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ intro p ++ exact Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ simpa [Sτ] using ++ (Summable.sum_le_tsum (s := small) ++ (f := fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) ++ (fun p _ => hnn p) hsumτ) ++ have hgeom_sum : ++ (small.card : ℝ) ≤ ∑ p ∈ small, (4 * R) ^ τ * ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ have hcard_eq : (small.card : ℝ) = ∑ p ∈ small, (1 : ℝ) := by simp ++ rw [hcard_eq] ++ refine Finset.sum_le_sum (fun p hp => ?_) ++ have hp_le : ‖divisorZeroIndex₀Val p‖ ≤ 4 * R := hsmall p hp ++ have hap : 0 < ‖divisorZeroIndex₀Val p‖ := ++ norm_pos_iff.2 (divisorZeroIndex₀Val_ne_zero p) ++ have hbase : (1 : ℝ) ≤ (4 * R) / ‖divisorZeroIndex₀Val p‖ := by ++ exact (le_div_iff₀ hap).2 (by simpa [mul_one] using hp_le) ++ have : (1 : ℝ) ≤ ((4 * R) / ‖divisorZeroIndex₀Val p‖) ^ τ := ++ Real.one_le_rpow hbase hτ_nonneg ++ have hdiv : ++ ((4 * R) / ‖divisorZeroIndex₀Val p‖) ^ τ = ++ (4 * R) ^ τ * (‖divisorZeroIndex₀Val p‖)⁻¹ ^ τ := by ++ have h4 : 0 ≤ (4 * R : ℝ) := by nlinarith [le_of_lt hRpos] ++ have ha : 0 ≤ (‖divisorZeroIndex₀Val p‖ : ℝ)⁻¹ := by positivity ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using ++ (Real.mul_rpow (x := (4 * R : ℝ)) ++ (y := (‖divisorZeroIndex₀Val p‖ : ℝ)⁻¹) (z := τ) h4 ha) ++ have : (1 : ℝ) ≤ (4 * R) ^ τ * ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ simpa [hdiv] using this ++ exact this ++ have hgeom : ++ (small.card : ℝ) ≤ (4 * R) ^ τ * (∑ p ∈ small, ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by ++ simpa [Finset.mul_sum] using hgeom_sum ++ have hsmall_le : (small.card : ℝ) ≤ (4 * R) ^ τ * Sτ := by ++ exact hgeom.trans (mul_le_mul_of_nonneg_left hsum_le (by positivity)) ++ have hS_le : (4 * R) ^ τ * Sτ ≤ (4 * R) ^ τ * (Sτ + 1) := by ++ refine mul_le_mul_of_nonneg_left ?_ (by positivity) ++ linarith ++ have : (small.card : ℝ) ≤ (4 * R) ^ τ * (Sτ + 1) := hsmall_le.trans hS_le ++ simpa [Sτ, add_comm, add_left_comm, add_assoc, mul_assoc] using this ++ ++lemma cartan_rpow_mul_le ++ {τ R r : ℝ} (hRpos : 0 < R) (hrpos : 0 < r) (hR_le_r : R ≤ r) (hτ_nonneg : 0 ≤ τ) : ++ (4 * R) ^ τ ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ := by ++ have hR_le_1r : R ≤ 1 + r := by linarith [hR_le_r, le_of_lt hrpos] ++ have hbase0 : 0 ≤ (4 * R : ℝ) := by nlinarith [le_of_lt hRpos] ++ have : (4 * R) ^ τ ≤ (4 * (1 + r)) ^ τ := by ++ refine Real.rpow_le_rpow hbase0 ?_ hτ_nonneg ++ nlinarith [hR_le_1r] ++ have hmul : (4 * (1 + r)) ^ τ = (4 : ℝ) ^ τ * (1 + r) ^ τ := by ++ have h4 : 0 ≤ (4 : ℝ) := by norm_num ++ have h1 : 0 ≤ (1 + r : ℝ) := by positivity ++ simpa [mul_assoc] using ++ (Real.mul_rpow (x := (4 : ℝ)) (y := (1 + r : ℝ)) (z := τ) h4 h1) ++ simpa [hmul] using this ++ ++open Classical in ++theorem cartan_sum_majorant_le ++ {f : ℂ → ℂ} {m : ℕ} {τ R r : ℝ} ++ (hRpos : 0 < R) ++ (hrpos : 0 < r) ++ (hR_le_r : R ≤ r) ++ (hτ_nonneg : 0 ≤ τ) ++ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall_fin : smallSet.Finite) ++ (hsmallSet : ++ smallSet = {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ 4 * R}) ++ (hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) ++ (hr_phi : ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ (∑ p ∈ small, CartanBound.φ (r / a p)) ≤ CartanBound.Cφ * (small.card : ℝ)) : ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ letI : DecidableEq (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := Classical.decEq _ ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ let Sτ : ℝ := ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ ∀ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)), ++ (∑ p ∈ s, b p) ≤ Cprod * (1 + r) ^ τ := by ++ classical ++ intro small ap b Sτ Cprod s ++ have hr : 0 ≤ r := le_of_lt hrpos ++ have hSτ_nonneg : 0 ≤ Sτ := ++ tsum_nonneg (fun _ => Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _) ++ have hsmall_mem : ∀ p, p ∈ small ↔ p ∈ smallSet := by ++ intro p ++ simp [small, hsmall_fin.mem_toFinset] ++ have hphi_sum : ++ (∑ p ∈ small, CartanBound.φ (r / ap p)) ≤ CartanBound.Cφ * (small.card : ℝ) := by ++ simpa [small, ap] using hr_phi ++ have hb_nonneg : ∀ p, 0 ≤ b p := by ++ simpa [ap, b] using (cartan_majorant_nonneg (f := f) (m := m) (τ := τ) (r := r) hr small) ++ have hb_summable : Summable b := by ++ simpa [ap, b] using ++ (cartan_majorant_summable (f := f) (m := m) (τ := τ) (r := r) hr small hsumτ) ++ have hsmall_norm : ∀ p ∈ small, ‖divisorZeroIndex₀Val p‖ ≤ 4 * R := by ++ intro p hp ++ have : p ∈ smallSet := (hsmall_mem p).1 hp ++ simpa [hsmallSet] using this ++ have hcard_le : (small.card : ℝ) ≤ (4 * R) ^ τ * (Sτ + 1) := by ++ simpa [Sτ, mul_assoc, add_assoc, add_left_comm, add_comm] using ++ (cartan_card_small_le (f := f) (τ := τ) (R := R) hRpos hτ_nonneg small hsmall_norm hsumτ) ++ have hpowR : (4 * R) ^ τ ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ := ++ cartan_rpow_mul_le (τ := τ) (R := R) (r := r) hRpos hrpos hR_le_r hτ_nonneg ++ have hcard_le' : (small.card : ℝ) ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ * (Sτ + 1) := by ++ have : (4 * R) ^ τ * (Sτ + 1) ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ * (Sτ + 1) := by ++ exact mul_le_mul_of_nonneg_right hpowR (by linarith [hSτ_nonneg]) ++ exact le_trans hcard_le this ++ have hb_tsum_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b p) ≤ Cprod * (1 + r) ^ τ := by ++ let bφ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then CartanBound.φ (r / ap p) else 0 ++ let b0 : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then (m : ℝ) else 0 ++ let bmτ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then (m : ℝ) * (r / ap p) ^ τ else 0 ++ let bt : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (2 : ℝ) * (r / ap p) ^ τ ++ have hb_pointwise : ∀ p, b p ≤ bφ p + b0 p + bmτ p + bt p := by ++ intro p ++ by_cases hp : p ∈ small ++ · have hbase : 0 ≤ r / ap p := div_nonneg hr (by positivity) ++ have hx : 0 ≤ (r / ap p) ^ τ := Real.rpow_nonneg hbase τ ++ have hpos : 0 ≤ (2 : ℝ) * (r / ap p) ^ τ := mul_nonneg (by norm_num) hx ++ simp [b, bφ, b0, bmτ, bt, hp] ++ nlinarith ++ · simp [b, bφ, b0, bmτ, bt, hp] ++ have hmaj_summ : Summable (fun p => bφ p + b0 p + bmτ p + bt p) := by ++ have hbφ_summ : Summable bφ := by ++ simpa [bφ] using summable_ite_mem_finset small (fun p => CartanBound.φ (r / ap p)) ++ have hb0_summ : Summable b0 := by ++ simpa [b0] using summable_ite_mem_finset small (fun _ => (m : ℝ)) ++ have hbmτ_summ : Summable bmτ := by ++ simpa [bmτ] using summable_ite_mem_finset small (fun p => (m : ℝ) * (r / ap p) ^ τ) ++ have hbt_summ : Summable bt := by ++ have hconst : Summable (fun p => ++ (2 : ℝ) * (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) := ++ hsumτ.mul_left ((2 : ℝ) * (r ^ τ)) ++ refine hconst.congr ?_ ++ intro p ++ simp [bt, ap, rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p, ++ mul_assoc, mul_left_comm, mul_comm] ++ have h' : Summable (fun p => bφ p + b0 p + (bmτ p + bt p)) := ++ (hbφ_summ.add hb0_summ).add (hbmτ_summ.add hbt_summ) ++ simpa [add_assoc] using h' ++ have htsum_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b p) ++ ≤ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p) := ++ (hasSum_le hb_pointwise hb_summable.hasSum hmaj_summ.hasSum) ++ have htsum_bφ : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ++ = ∑ p ∈ small, CartanBound.φ (r / ap p) := by ++ classical ++ simpa [bφ] using tsum_ite_mem_finset small (fun p => CartanBound.φ (r / ap p)) ++ have htsum_b0 : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ++ = (m : ℝ) * (small.card : ℝ) := by ++ classical ++ have : (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) = ∑ p ∈ small, (m : ℝ) := by ++ simpa [b0] using tsum_ite_mem_finset small (fun _ => (m : ℝ)) ++ simp [this, Finset.sum_const, nsmul_eq_mul, mul_comm] ++ have htsum_bmτ : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ = (m : ℝ) * ∑ p ∈ small, (r / ap p) ^ τ := by ++ classical ++ have : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ = ∑ p ∈ small, (m : ℝ) * (r / ap p) ^ τ := by ++ simpa [bmτ] using tsum_ite_mem_finset small (fun p => (m : ℝ) * (r / ap p) ^ τ) ++ simp [this, Finset.mul_sum] ++ have htsum_bt : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bt p) ++ ≤ (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [bt, ap, Sτ] using ++ tsum_two_mul_rpow_div_norm_divisorZeroIndex₀_le (f := f) (τ := τ) hr hτ_nonneg ++ have hsum_small_rpow_le : ++ (∑ p ∈ small, (r / ap p) ^ τ) ≤ (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [ap, Sτ] using ++ sum_rpow_div_norm_divisorZeroIndex₀_le (f := f) (τ := τ) small hr hτ_nonneg hsumτ ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ have hCφ : 0 ≤ CartanBound.Cφ := le_of_lt CartanBound.Cφ_pos ++ have hS : 0 ≤ Sτ + 1 := by linarith [hSτ_nonneg] ++ have htsum_majorant : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p)) ++ ≤ (((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 2) * (Sτ + 1)) ++ * (1 + r) ^ τ := by ++ have hφ_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ++ ≤ CartanBound.Cφ * (small.card : ℝ) := by ++ simpa [htsum_bφ] using hphi_sum ++ have hb0_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ++ ≤ (m : ℝ) * (small.card : ℝ) := by ++ simp [htsum_b0] ++ have hbmτ_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ≤ ++ (m : ℝ) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have h0 : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ ≤ (m : ℝ) * ((Sτ + 1) * (1 + r) ^ τ) := by ++ have hmul := mul_le_mul_of_nonneg_left hsum_small_rpow_le hm0 ++ ++ simpa [htsum_bmτ, mul_assoc, mul_left_comm, mul_comm] using hmul ++ have h1 : (1 : ℝ) ≤ (4 : ℝ) ^ τ := ++ Real.one_le_rpow (by norm_num) hτ_nonneg ++ have hscale : ++ (m : ℝ) * ((Sτ + 1) * (1 + r) ^ τ) ++ ≤ (m : ℝ) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have hnonneg : 0 ≤ (m : ℝ) * ((Sτ + 1) * (1 + r) ^ τ) := by ++ have : 0 ≤ (Sτ + 1) * (1 + r) ^ τ := by positivity ++ exact mul_nonneg hm0 this ++ simpa [mul_assoc, mul_left_comm, mul_comm] using (mul_le_mul_of_nonneg_right h1 hnonneg) ++ exact h0.trans hscale ++ have hbt_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bt p) ++ ≤ (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using htsum_bt ++ have hsplit : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p)) ++ = (∑' p, bφ p) + (∑' p, b0 p) + (∑' p, bmτ p) + (∑' p, bt p) := by ++ classical ++ have hbφ_summ : Summable bφ := by ++ simpa [bφ] using summable_ite_mem_finset small (fun p => CartanBound.φ (r / ap p)) ++ have hb0_summ : Summable b0 := by ++ simpa [b0] using summable_ite_mem_finset small (fun _ => (m : ℝ)) ++ have hbmτ_summ : Summable bmτ := by ++ simpa [bmτ] using summable_ite_mem_finset small (fun p => (m : ℝ) * (r / ap p) ^ τ) ++ have hbt_summ : Summable bt := by ++ have hconst : ++ Summable ++ (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ (2 : ℝ) * (r ^ τ) * ((‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ)) := ++ hsumτ.mul_left ((2 : ℝ) * (r ^ τ)) ++ refine hconst.congr ?_ ++ intro p ++ simp [bt, ap, rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p, ++ mul_assoc, mul_left_comm, mul_comm] ++ exact tsum_add_four bφ b0 bmτ bt hbφ_summ hb0_summ hbmτ_summ hbt_summ ++ have hcard_le'' : ++ (small.card : ℝ) ≤ (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using hcard_le' ++ have hφ_le' : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ≤ ++ CartanBound.Cφ * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have : CartanBound.Cφ * (small.card : ℝ) ≤ ++ CartanBound.Cφ * ((4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ) := ++ mul_le_mul_of_nonneg_left hcard_le'' hCφ ++ exact hφ_le.trans (by simpa [mul_assoc, mul_left_comm, mul_comm] using this) ++ have hb0_le' : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ≤ ++ (m : ℝ) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have : (m : ℝ) * (small.card : ℝ) ≤ (m : ℝ) * ((4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ) := ++ mul_le_mul_of_nonneg_left hcard_le'' hm0 ++ exact hb0_le.trans (by simpa [mul_assoc, mul_left_comm, mul_comm] using this) ++ have htsum_majorant' : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p)) ++ ≤ (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ ++ + (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ rw [hsplit] ++ set Y : ℝ := Sτ + 1 with hY ++ set T : ℝ := (1 + r) ^ τ with hT ++ have hφ_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ++ ≤ CartanBound.Cφ * (4 : ℝ) ^ τ * Y * T := by ++ simpa [hY, hT, mul_assoc] using hφ_le' ++ have hb0_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ++ ≤ (m : ℝ) * (4 : ℝ) ^ τ * Y * T := by ++ simpa [hY, hT, mul_assoc] using hb0_le' ++ have hbmτ_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ ≤ (m : ℝ) * (4 : ℝ) ^ τ * Y * T := by ++ simpa [hY, hT, mul_assoc] using hbmτ_le ++ have hbt_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bt p) ≤ (2 : ℝ) * Y * T := by ++ simpa [hY, hT, mul_assoc] using hbt_le ++ have hmain := ++ cartan_majorant_four_term_bound ++ (q := (4 : ℝ) ^ τ) hφ_leY hb0_leY hbmτ_leY hbt_leY ++ simpa [Y, T, add_assoc] using hmain ++ have hring : ++ (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ ++ + (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ ++ = (((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 2) * (Sτ + 1)) * (1 + r) ^ τ := by ++ exact cartan_majorant_add_two_factor ++ ((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ) (Sτ + 1) ((1 + r) ^ τ) ++ rw [← hring] ++ exact htsum_majorant' ++ have hCprod' : ++ (((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 2) * (Sτ + 1)) * (1 + r) ^ τ ++ ≤ Cprod * (1 + r) ^ τ := by ++ simpa [Cprod, cartanProductConstant, mul_assoc, mul_left_comm, mul_comm] using ++ cartan_majorant_pad_two_to_three ++ (A := (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ) ++ (S := Sτ) (T := (1 + r) ^ τ) hS (by positivity) ++ exact (le_trans (le_trans htsum_le htsum_majorant) hCprod') ++ have hsum_fin_le : ++ (∑ p ∈ s, b p) ≤ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b p) := by ++ simpa using ++ (Summable.sum_le_tsum (s := s) (f := b) (fun p _ => hb_nonneg p) hb_summable) ++ exact hsum_fin_le.trans hb_tsum_le ++ ++end Complex.Hadamard ++end ++end HadamardSourceScope28 ++ ++section HadamardSourceScope29 ++ ++noncomputable section ++ ++open scoped BigOperators ++open Filter Finset _root_.Real _root_.Erdos970.Real Topology ++ ++lemma Finset.prod_le_exp_sum {α : Type} (s : Finset α) (a : α → ℝ) (b : α → ℝ) ++ (ha : ∀ x ∈ s, 0 ≤ a x) (hab : ∀ x ∈ s, a x ≤ Real.exp (b x)) : ++ (∏ x ∈ s, a x) ≤ Real.exp (∑ x ∈ s, b x) := by ++ calc ++ (∏ x ∈ s, a x) ≤ ∏ x ∈ s, Real.exp (b x) := Finset.prod_le_prod₀ ha hab ++ _ = Real.exp (∑ x ∈ s, b x) := by ++ simpa using (Real.exp_sum (s := s) (f := b)).symm ++ ++lemma hasProd_le_of_prod_le_exp {α : Type} {f : α → ℝ} {a : ℝ} ++ (hf : HasProd f a (SummationFilter.unconditional α)) ++ {B : ℝ} (hB : ∀ s : Finset α, (∏ x ∈ s, f x) ≤ Real.exp B) : ++ a ≤ Real.exp B := ++ hasProd_le_of_prod_le (L := (SummationFilter.unconditional α)) hf hB ++ ++lemma hasProd_inv_unconditional {α : Type} {fac : α → ℂ} {F : ℂ} ++ (hfac : HasProd fac F (SummationFilter.unconditional α)) (hF : F ≠ 0) : ++ HasProd (fun x => (fac x)⁻¹) (F⁻¹) (SummationFilter.unconditional α) := by ++ change ++ Tendsto (fun s : Finset α => ∏ x ∈ s, (fac x)⁻¹) ++ (SummationFilter.unconditional α).filter (𝓝 (F⁻¹)) ++ have hprod : ++ Tendsto (fun s : Finset α => ∏ x ∈ s, fac x) ++ (SummationFilter.unconditional α).filter (𝓝 F) := by ++ simpa [HasProd] using hfac ++ have hinv : ++ Tendsto (fun s : Finset α => (∏ x ∈ s, fac x)⁻¹) ++ (SummationFilter.unconditional α).filter (𝓝 (F⁻¹)) := ++ hprod.inv₀ hF ++ refine hinv.congr' (Filter.Eventually.of_forall ?_) ++ intro s ++ simp [Finset.prod_inv_distrib] ++ ++lemma hasProd_norm_inv_unconditional {α : Type} {fac : α → ℂ} {F : ℂ} ++ (hfac : HasProd fac F (SummationFilter.unconditional α)) (hF : F ≠ 0) : ++ HasProd (fun x => ‖(fac x)⁻¹‖) ‖F⁻¹‖ (SummationFilter.unconditional α) := by ++ change ++ Tendsto (fun s : Finset α => ∏ x ∈ s, ‖(fac x)⁻¹‖) ++ (SummationFilter.unconditional α).filter (𝓝 ‖F⁻¹‖) ++ have hnorm := (hasProd_inv_unconditional hfac hF).norm ++ refine hnorm.congr' (Filter.Eventually.of_forall ?_) ++ intro s ++ simp [norm_inv, Finset.prod_inv_distrib] ++ ++lemma hasProd_norm_inv_le_exp_of_pointwise_le_exp {α : Type} {fac : α → ℂ} {F : ℂ} ++ (hfac : HasProd fac F (SummationFilter.unconditional α)) ++ (b : α → ℝ) (B : ℝ) ++ (hterm : ∀ x, ‖(fac x)⁻¹‖ ≤ Real.exp (b x)) ++ (hsum : ∀ s : Finset α, (∑ x ∈ s, b x) ≤ B) : ++ ‖F⁻¹‖ ≤ Real.exp B := by ++ by_cases hF : F = 0 ++ · subst hF ++ simpa using exp_nonneg B ++ have hnorm : ++ HasProd (fun x => ‖(fac x)⁻¹‖) ‖F⁻¹‖ (SummationFilter.unconditional α) := ++ hasProd_norm_inv_unconditional hfac hF ++ have hprod : ∀ s : Finset α, (∏ x ∈ s, ‖(fac x)⁻¹‖) ≤ Real.exp B := by ++ intro s ++ have h0 : ∀ x ∈ s, 0 ≤ ‖(fac x)⁻¹‖ := by intro _ _; positivity ++ have h1 : (∏ x ∈ s, ‖(fac x)⁻¹‖) ≤ Real.exp (∑ x ∈ s, b x) := by ++ refine Finset.prod_le_exp_sum s (a := fun x => ‖(fac x)⁻¹‖) (b := b) h0 ?_ ++ intro x hx ++ simpa using hterm x ++ have h2 : Real.exp (∑ x ∈ s, b x) ≤ Real.exp B := ++ Real.exp_le_exp.2 (hsum s) ++ exact h1.trans h2 ++ exact hasProd_le_of_prod_le_exp hnorm hprod ++end ++end HadamardSourceScope29 ++ ++section HadamardSourceScope30 ++ ++open Metric ++ ++namespace Complex ++ ++open _root_.Complex ++ ++theorem borelCaratheodory_zero_closedBall {f : ℂ → ℂ} {M r R : ℝ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ (hr : 0 < r) (hlt : r < R) (hM : 0 < M) (hf0 : f 0 = 0) ++ (hf_re : ∀ w, ‖w‖ ≤ R → (f w).re ≤ M) {z : ℂ} (hz : ‖z‖ ≤ r) : ++ ‖f z‖ ≤ 2 * M * r / (R - r) := by ++ have hR : 0 < R := lt_trans hr hlt ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) R := by ++ rw [Metric.mem_ball, dist_zero_right] ++ exact hz.trans_lt hlt ++ have hf_diff : DifferentiableOn ℂ f (Metric.ball (0 : ℂ) R) := by ++ intro w hw ++ have hw' : w ∈ Metric.closedBall (0 : ℂ) R := ball_subset_closedBall hw ++ exact (hf w hw').differentiableAt.differentiableWithinAt ++ have hf_map : Set.MapsTo f (Metric.ball (0 : ℂ) R) {w | w.re ≤ M} := by ++ intro w hw ++ simp only [Set.mem_ofPred_eq] ++ have hw' : ‖w‖ < R := by simpa [Metric.mem_ball, dist_zero_right] using hw ++ exact hf_re w hw'.le ++ have hbc := ++ borelCaratheodory_zero hM hf_diff hf_map hR hz_ball hf0 ++ have hzR : ‖z‖ < R := by ++ rw [Metric.mem_ball, dist_zero_right] at hz_ball ++ exact hz_ball ++ have hmono : ‖z‖ / (R - ‖z‖) ≤ r / (R - r) := by ++ have hrden : 0 < R - r := sub_pos.mpr hlt ++ have hden : 0 < R - ‖z‖ := sub_pos.mpr hzR ++ rw [div_le_div_iff₀ hden hrden] ++ nlinarith [hz, norm_nonneg z] ++ have hM' : 0 ≤ 2 * M := mul_nonneg (by norm_num) (le_of_lt hM) ++ calc ‖f z‖ ++ ≤ 2 * M * ‖z‖ / (R - ‖z‖) := hbc ++ _ ≤ 2 * M * (r / (R - r)) := by ++ simpa [mul_div_assoc] using mul_le_mul_of_nonneg_left hmono hM' ++ _ = 2 * M * r / (R - r) := by ring ++ ++end Complex ++end HadamardSourceScope30 ++ ++section HadamardSourceScope31 ++ ++noncomputable section ++ ++namespace Complex ++ ++open _root_.Complex ++namespace Hadamard ++ ++open _root_.Complex _root_.Erdos970.Complex _root_.Real _root_.Erdos970.Real ++ BigOperators _root_.Finset Set Filter Topology Metric ++ ++open scoped Topology ++ ++theorem zero_free_polynomial_growth_is_exp_poly {H : ℂ → ℂ} {n : ℕ} ++ (hH : Differentiable ℂ H) ++ (h_nonzero : ∀ z, H z ≠ 0) ++ (h_bound : ∃ C > 0, ∀ z, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ n)) : ++ ∃ P : Polynomial ℂ, P.natDegree ≤ n ∧ ∀ z, H z = Complex.exp (Polynomial.eval z P) := by ++ classical ++ rcases h_bound with ⟨C, hCpos, hC⟩ ++ let L : ℂ → ℂ := fun z => deriv H z / H z ++ have hderivH : Differentiable ℂ (deriv H) := by ++ intro z ++ exact ((hH.analyticAt z).deriv).differentiableAt ++ have hL : Differentiable ℂ L := by ++ simpa [L] using! (hderivH.div hH h_nonzero) ++ let h : ℂ → ℂ := fun z => Complex.wedgeIntegral (0 : ℂ) z L ++ have hh_deriv : ∀ z, HasDerivAt h (L z) z := by ++ intro z ++ let r : ℝ := ‖z‖ + 1 ++ have hrpos : 0 < r := by ++ dsimp [r]; linarith [norm_nonneg z] ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) r := by ++ have : dist z (0 : ℂ) < r := by simp [r, dist_zero_right] ++ simpa [Metric.mem_ball] using this ++ have hconserv : Complex.IsConservativeOn L (Metric.ball (0 : ℂ) r) := ++ (hL.differentiableOn).isConservativeOn ++ have hcont : ContinuousOn L (Metric.ball (0 : ℂ) r) := ++ hL.continuous.continuousOn ++ simpa [h, r] using hconserv.hasDerivAt_wedgeIntegral (f_cont := hcont) (hz := hz_ball) ++ have hh : Differentiable ℂ h := fun z => (hh_deriv z).differentiableAt ++ have hderiv_h : ∀ z, deriv h z = L z := fun z => (hh_deriv z).deriv ++ let k : ℂ → ℂ := fun z => h z + Complex.log (H 0) ++ have hk : Differentiable ℂ k := hh.add_const (Complex.log (H 0)) ++ have hk_exp : ∀ z, H z = Complex.exp (k z) := by ++ let F : ℂ → ℂ := fun z => Complex.exp (k z) / H z ++ have hF_deriv : ∀ z, deriv F z = 0 := by ++ intro z ++ have hH_has : HasDerivAt H (deriv H z) z := (hH z).hasDerivAt ++ have hk_has : HasDerivAt k (L z) z := by ++ have hh_has : HasDerivAt h (L z) z := hh_deriv z ++ simpa [k, L] using hh_has.add_const (Complex.log (H 0)) ++ have hExp : HasDerivAt (fun w => Complex.exp (k w)) (Complex.exp (k z) * L z) z := ++ (HasDerivAt.cexp hk_has) ++ have hDiv := (HasDerivAt.div hExp hH_has (h_nonzero z)) ++ have : ++ deriv F z = ++ ((Complex.exp (k z) * L z) * H z - Complex.exp (k z) * deriv H z) / (H z) ^ 2 := by ++ simpa [F] using! hDiv.deriv ++ rw [this] ++ have hnum : ++ (Complex.exp (k z) * L z) * H z - Complex.exp (k z) * deriv H z = 0 := by ++ dsimp [L] ++ field_simp [h_nonzero z] ++ ring ++ simp [hnum] ++ have hF_diff : Differentiable ℂ F := (hk.cexp).div hH h_nonzero ++ have hF_const : ∀ z, F z = F 0 := by ++ intro z ++ exact is_const_of_deriv_eq_zero hF_diff hF_deriv z 0 ++ have hF0 : F 0 = 1 := by ++ have hh0 : h 0 = 0 := by simp [h, Complex.wedgeIntegral] ++ have hk0 : k 0 = Complex.log (H 0) := by simp [k, hh0] ++ have hH0 : H 0 ≠ 0 := h_nonzero 0 ++ simp [F, hk0, Complex.exp_log hH0, hH0] ++ intro z ++ have : F z = 1 := by simpa [hF0] using (hF_const z) ++ have hHz : H z ≠ 0 := h_nonzero z ++ have : Complex.exp (k z) / H z = 1 := by simpa [F] using this ++ have : Complex.exp (k z) = H z := by ++ field_simp [hHz] at this ++ simpa using this ++ exact this.symm ++ have hk_re_bound : ∀ z, (k z).re ≤ C * (1 + ‖z‖) ^ n := by ++ intro z ++ have hHz : H z ≠ 0 := h_nonzero z ++ have hpos : 0 < ‖H z‖ := norm_pos_iff.mpr hHz ++ have hlog_le : Real.log ‖H z‖ ≤ C * (1 + ‖z‖) ^ n := by ++ have := Real.log_le_log hpos (hC z) ++ simpa [Real.log_exp] using this ++ have hlog_eq : Real.log ‖H z‖ = (k z).re := by ++ have : ‖H z‖ = Real.exp (k z).re := by ++ simpa [hk_exp z] using (Complex.norm_exp (k z)) ++ calc ++ Real.log ‖H z‖ = Real.log (Real.exp (k z).re) := by simp [this] ++ _ = (k z).re := by simp ++ simpa [hlog_eq] using hlog_le ++ have hk_iteratedDeriv_eq_zero : ∀ m : ℕ, n < m → iteratedDeriv m k 0 = 0 := by ++ intro m hm ++ have hm' : 0 < (m - n : ℕ) := Nat.sub_pos_of_lt hm ++ have hmne : m - n ≠ 0 := (Nat.pos_iff_ne_zero.1 hm') ++ let f : ℂ → ℂ := fun z => k z - k 0 ++ have hf : Differentiable ℂ f := hk.sub_const (k 0) ++ have hf0 : f 0 = 0 := by simp [f] ++ have hf_re_bound : ∀ R : ℝ, 0 < R → ++ ∀ z, ‖z‖ ≤ R → (f z).re ≤ C * (1 + R) ^ n + ‖k 0‖ := by ++ intro R hRpos z hzR ++ have hkz : (k z).re ≤ C * (1 + ‖z‖) ^ n := hk_re_bound z ++ have hkz' : (k z).re ≤ C * (1 + R) ^ n := by ++ have h1 : (1 + ‖z‖ : ℝ) ≤ 1 + R := by linarith ++ have hpow : (1 + ‖z‖ : ℝ) ^ n ≤ (1 + R) ^ n := ++ pow_le_pow_left₀ (by linarith [norm_nonneg z]) h1 n ++ exact hkz.trans (mul_le_mul_of_nonneg_left hpow (le_of_lt hCpos)) ++ have hRe0 : -(k 0).re ≤ ‖k 0‖ := by ++ have habs : |(k 0).re| ≤ ‖k 0‖ := Complex.abs_re_le_norm (k 0) ++ have hneg : -(k 0).re ≤ |(k 0).re| := by simpa using (neg_le_abs (k 0).re) ++ exact hneg.trans habs ++ have : (f z).re ≤ C * (1 + R) ^ n + ‖k 0‖ := by ++ have : (f z).re = (k z).re - (k 0).re := by simp [f, sub_eq_add_neg] ++ nlinarith [this, hkz', hRe0] ++ exact this ++ have hf_bound_on_ball : ∀ R : ℝ, 0 < R → ++ ∀ z, ‖z‖ ≤ R / 2 → ‖f z‖ ≤ 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ intro R hRpos z hz ++ have hR2pos : 0 < R / 2 := by nlinarith ++ have hlt : R / 2 < R := by nlinarith ++ have hMpos : 0 < (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ have : 0 ≤ C * (1 + R) ^ n := by ++ refine mul_nonneg (le_of_lt hCpos) ?_ ++ exact pow_nonneg (by linarith) _ ++ nlinarith [this, norm_nonneg (k 0)] ++ have hf_anal : AnalyticOnNhd ℂ f (Metric.closedBall 0 R) := by ++ intro w _hw ++ exact (hf.analyticAt w) ++ have hf_re : ∀ w, ‖w‖ ≤ R → (f w).re ≤ (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ intro w hw ++ have := hf_re_bound R hRpos w hw ++ linarith ++ have hf_bc := ++ borelCaratheodory_zero_closedBall (f := f) (r := R / 2) (R := R) ++ (M := (C * (1 + R) ^ n + ‖k 0‖ + 1)) ++ hf_anal hR2pos hlt hMpos hf0 hf_re (z := z) hz ++ have hconst : ++ 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) * (R / 2) / (R - R / 2) ++ = 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ field_simp [hRpos.ne'] ; ring ++ simpa [hconst] using hf_bc ++ have hCauchy : ∀ R : ℝ, 0 < R → ++ ‖iteratedDeriv m f 0‖ ≤ ++ (m.factorial : ℝ) * (2 * (C * (1 + R) ^ n + ‖k 0‖ + 1)) / (R / 2) ^ m := by ++ intro R hRpos ++ have hR2pos : 0 < R / 2 := by nlinarith ++ have hf_diffCont : DiffContOnCl ℂ f (Metric.ball (0 : ℂ) (R / 2)) := hf.diffContOnCl ++ have hbound_sphere : ++ ∀ z ∈ Metric.sphere (0 : ℂ) (R / 2), ++ ‖f z‖ ≤ 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ intro z hz ++ have hz' : ‖z‖ ≤ R / 2 := by ++ simpa [Metric.mem_sphere, dist_zero_right] using (le_of_eq hz) ++ exact hf_bound_on_ball R hRpos z hz' ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using ++ (Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le (n := m) (c := (0 : ℂ)) ++ (R := R / 2) (C := 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1)) ++ (hR := hR2pos) hf_diffCont hbound_sphere) ++ have hf_iter_eq : iteratedDeriv m f 0 = 0 := by ++ by_contra hne ++ have ha : 0 < ‖iteratedDeriv m f 0‖ := norm_pos_iff.2 hne ++ let RHS : ℝ → ℝ := fun R => ++ (m.factorial : ℝ) * (2 * (C * (1 + R) ^ n + ‖k 0‖ + 1)) / (R / 2) ^ m ++ have hle_RHS : ∀ R : ℝ, 0 < R → ‖iteratedDeriv m f 0‖ ≤ RHS R := by ++ intro R hRpos ++ simpa [RHS] using hCauchy R hRpos ++ have hRHS_tendsto : Tendsto RHS atTop (𝓝 0) := by ++ let K : ℝ := ‖k 0‖ + 1 ++ have hmpos : 0 < m := lt_of_le_of_lt (Nat.zero_le n) hm ++ have hm0 : m ≠ 0 := ne_of_gt hmpos ++ have hratio : Tendsto (fun R : ℝ => R ^ n / (R / 2) ^ m) atTop (𝓝 0) := by ++ have hident : ++ (fun R : ℝ => R ^ n / (R / 2) ^ m) = fun R : ℝ => (2 : ℝ) ^ m * (R ^ n / R ^ m) := by ++ funext R ++ simp [div_eq_mul_inv, mul_pow, mul_assoc, mul_comm] ++ have hmain : Tendsto (fun R : ℝ => R ^ n / R ^ m) atTop (𝓝 0) := by ++ have hp : m - n ≠ 0 := (Nat.pos_iff_ne_zero.1 (Nat.sub_pos_of_lt hm)) ++ have hmain' : Tendsto (fun R : ℝ => (R ^ (m - n))⁻¹) atTop (𝓝 0) := by ++ simpa using (tendsto_pow_neg_atTop (𝕜 := ℝ) (n := m - n) hp) ++ have hEq : (fun R : ℝ => (R ^ (m - n))⁻¹) =ᶠ[atTop] fun R : ℝ => R ^ n / R ^ m := by ++ have hEq' : (fun R : ℝ => R ^ n / R ^ m) =ᶠ[atTop] fun R : ℝ => (R ^ (m - n))⁻¹ := by ++ filter_upwards [eventually_ne_atTop (0 : ℝ)] with R hR ++ have hle : n ≤ m := le_of_lt hm ++ have hm_eq : n + (m - n) = m := Nat.add_sub_of_le hle ++ have hn0 : R ^ n ≠ 0 := pow_ne_zero n hR ++ calc ++ R ^ n / R ^ m = R ^ n / R ^ (n + (m - n)) := by simp [hm_eq] ++ _ = R ^ n * ((R ^ (m - n))⁻¹ * (R ^ n)⁻¹) := by ++ simp [pow_add, div_eq_mul_inv, mul_comm] ++ _ = (R ^ (m - n))⁻¹ := by ++ ring_nf ++ simp [hn0] ++ exact hEq'.symm ++ exact Filter.Tendsto.congr' hEq hmain' ++ have : Tendsto (fun R : ℝ => (2 : ℝ) ^ m * (R ^ n / R ^ m)) atTop (𝓝 ((2 : ℝ) ^ m * 0)) := ++ tendsto_const_nhds.mul hmain ++ simpa [hident] using this ++ have hinv : Tendsto (fun R : ℝ => ((R / 2) ^ m)⁻¹) atTop (𝓝 0) := by ++ have hdiv : Tendsto (fun R : ℝ => R / 2) atTop atTop := ++ (tendsto_id.atTop_div_const (r := (2 : ℝ)) (by norm_num : (0 : ℝ) < 2)) ++ have hpow : Tendsto (fun R : ℝ => (R / 2) ^ m) atTop atTop := ++ (Filter.tendsto_pow_atTop (α := ℝ) (n := m) hm0).comp hdiv ++ simpa using! hpow.inv_tendsto_atTop ++ have hdiv : Tendsto (fun R : ℝ => (1 + R) / R) atTop (𝓝 (1 : ℝ)) := by ++ have hinv' : Tendsto (fun R : ℝ => (R : ℝ)⁻¹) atTop (𝓝 (0 : ℝ)) := tendsto_inv_atTop_zero ++ have hadd : Tendsto (fun R : ℝ => (1 : ℝ) + (R : ℝ)⁻¹) atTop (𝓝 (1 : ℝ)) := by ++ simpa using (tendsto_const_nhds.add hinv') ++ have hEq : (fun R : ℝ => (1 + R) / R) =ᶠ[atTop] fun R : ℝ => (1 : ℝ) + (R : ℝ)⁻¹ := by ++ filter_upwards [eventually_ne_atTop (0 : ℝ)] with R hR ++ field_simp [hR]; ring ++ exact Filter.Tendsto.congr' hEq.symm hadd ++ have hdiv_pow : Tendsto (fun R : ℝ => ((1 + R) / R) ^ n) atTop (𝓝 (1 : ℝ)) := by ++ simpa using (hdiv.pow n) ++ have hone_add_ratio : ++ Tendsto (fun R : ℝ => (1 + R) ^ n / (R / 2) ^ m) atTop (𝓝 (0 : ℝ)) := by ++ have hEq : ++ (fun R : ℝ => (1 + R) ^ n / (R / 2) ^ m) ++ =ᶠ[atTop] fun R : ℝ => ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m) := by ++ filter_upwards [eventually_ne_atTop (0 : ℝ)] with R hR ++ have hRpow : (R ^ n : ℝ) ≠ 0 := pow_ne_zero n hR ++ have hident : ++ ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m) = (1 + R) ^ n / (R / 2) ^ m := by ++ calc ++ ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m) ++ = ((1 + R) ^ n / R ^ n) * (R ^ n / (R / 2) ^ m) := by ++ simp [div_pow] ++ _ = ((1 + R) ^ n * R ^ n) / (R ^ n * (R / 2) ^ m) := by ++ simp [div_mul_div_comm, mul_comm] ++ _ = ((1 + R) ^ n * R ^ n) / ((R / 2) ^ m * R ^ n) := by ++ simp [mul_comm] ++ _ = (1 + R) ^ n / (R / 2) ^ m := by ++ simpa [mul_assoc, mul_comm, mul_left_comm] using ++ (mul_div_mul_right (a := (1 + R) ^ n) (b := (R / 2) ^ m) hRpow) ++ exact hident.symm ++ have hmul : ++ Tendsto ++ (fun R : ℝ => ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m)) ++ atTop (𝓝 (0 : ℝ)) := by ++ simpa [mul_zero] using (hdiv_pow.mul hratio) ++ exact Filter.Tendsto.congr' hEq.symm hmul ++ have h1 : Tendsto (fun R : ℝ => C * ((1 + R) ^ n / (R / 2) ^ m)) atTop (𝓝 0) := by ++ simpa using (tendsto_const_nhds.mul hone_add_ratio) ++ have h2 : Tendsto (fun R : ℝ => K * ((R / 2) ^ m)⁻¹) atTop (𝓝 0) := by ++ simpa using (tendsto_const_nhds.mul hinv) ++ have hsum : ++ Tendsto ++ (fun R : ℝ => C * ((1 + R) ^ n / (R / 2) ^ m) + K * ((R / 2) ^ m)⁻¹) ++ atTop (𝓝 0) := by ++ simpa using (h1.add h2) ++ have hrew : ++ (fun R : ℝ => (C * (1 + R) ^ n + K) / (R / 2) ^ m) ++ = fun R : ℝ => C * ((1 + R) ^ n / (R / 2) ^ m) + K * ((R / 2) ^ m)⁻¹ := by ++ funext R ++ simp [div_eq_mul_inv, mul_add, mul_assoc, mul_comm] ++ have hbase : Tendsto (fun R : ℝ => (C * (1 + R) ^ n + K) / (R / 2) ^ m) atTop (𝓝 0) := by ++ simpa [hrew] using hsum ++ have hconst : ++ Tendsto (fun _ : ℝ => (m.factorial : ℝ) * (2 : ℝ)) atTop ++ (𝓝 ((m.factorial : ℝ) * (2 : ℝ))) := tendsto_const_nhds ++ have hmul : Tendsto (fun R : ℝ => ((m.factorial : ℝ) * (2 : ℝ)) * ++ ((C * (1 + R) ^ n + K) / (R / 2) ^ m)) atTop (𝓝 0) := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using (hconst.mul hbase) ++ have hRHS_rw : RHS = fun R : ℝ => ((m.factorial : ℝ) * (2 : ℝ)) * ++ ((C * (1 + R) ^ n + K) / (R / 2) ^ m) := by ++ funext R ++ dsimp [RHS, K] ++ ring_nf ++ simpa [hRHS_rw] using hmul ++ have hsmall : ∀ᶠ R in atTop, RHS R < ‖iteratedDeriv m f 0‖ / 2 := ++ (tendsto_order.1 hRHS_tendsto).2 _ (half_pos ha) ++ have hle_eventually : ∀ᶠ R in atTop, ‖iteratedDeriv m f 0‖ ≤ RHS R := by ++ filter_upwards [eventually_gt_atTop (0 : ℝ)] with R hRpos ++ exact hle_RHS R hRpos ++ rcases (hle_eventually.and hsmall).exists with ⟨R, hle, hlt⟩ ++ have : ‖iteratedDeriv m f 0‖ < ‖iteratedDeriv m f 0‖ := ++ (lt_of_le_of_lt hle hlt).trans (half_lt_self ha) ++ exact lt_irrefl _ this ++ have hmpos : 0 < m := lt_of_le_of_lt (Nat.zero_le n) hm ++ have hm0 : m ≠ 0 := ne_of_gt hmpos ++ have hkcd : ContDiffAt ℂ (↑m) k (0 : ℂ) := (hk.analyticAt 0).contDiffAt ++ have hccd : ContDiffAt ℂ (↑m) (fun _ : ℂ => k 0) (0 : ℂ) := contDiffAt_const ++ have hsub : ++ iteratedDeriv m f 0 = ++ iteratedDeriv m k 0 - iteratedDeriv m (fun _ : ℂ => k 0) 0 := by ++ simpa [f] using! (iteratedDeriv_sub (n := m) (x := (0 : ℂ)) hkcd hccd) ++ have hconst0 : iteratedDeriv m (fun _ : ℂ => k 0) 0 = 0 := by ++ simp [iteratedDeriv_const, hm0] ++ have hf_eq : iteratedDeriv m f 0 = iteratedDeriv m k 0 := by ++ simp [hsub, hconst0] ++ simpa [hf_eq] using hf_iter_eq ++ let P : Polynomial ℂ := ++ ∑ m ∈ Finset.range (n + 1), Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0) ++ have hPdeg : P.natDegree ≤ n := by ++ have hnat : ++ P.natDegree ≤ ++ Finset.fold max 0 ++ (fun m : ℕ => ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree) ++ (Finset.range (n + 1)) := by ++ simpa [P, Function.comp] using ++ (Polynomial.natDegree_sum_le (s := Finset.range (n + 1)) ++ (f := fun m : ℕ => ++ Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0))) ++ have hfold : ++ Finset.fold max 0 ++ (fun m : ℕ => ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree) ++ (Finset.range (n + 1)) ≤ n := by ++ refine (Finset.fold_max_le (f := fun m : ℕ => ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree) ++ (b := 0) (s := Finset.range (n + 1)) (c := n)).2 ?_ ++ refine ⟨Nat.zero_le n, ?_⟩ ++ intro m hm ++ have hmon : ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree ≤ m := ++ Polynomial.natDegree_monomial_le _ ++ have hm_le : m ≤ n := Nat.le_of_lt_succ (Finset.mem_range.1 hm) ++ exact hmon.trans hm_le ++ exact hnat.trans hfold ++ have hk_poly : ∀ z, k z = Polynomial.eval z P := by ++ intro z ++ have htaylor := Complex.taylorSeries_eq_of_entire' (c := (0 : ℂ)) (z := z) hk ++ have htail : ∀ m : ℕ, m ∉ Finset.range (n + 1) → ++ ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * (z - 0) ^ m) = 0 := by ++ intro m hm' ++ have hmgt : n < m := by ++ have : n + 1 ≤ m := Nat.le_of_not_lt (by simpa [Finset.mem_range] using hm') ++ exact Nat.lt_of_lt_of_le (Nat.lt_succ_self n) this ++ have hz : iteratedDeriv m k 0 = 0 := hk_iteratedDeriv_eq_zero m hmgt ++ simp [hz] ++ have htsum : ++ (∑' m : ℕ, (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * (z - 0) ^ m) ++ = ∑ m ∈ Finset.range (n + 1), (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * z ^ m := by ++ simpa [sub_zero] using (tsum_eq_sum (s := Finset.range (n + 1)) htail) ++ have hfinite : ++ k z = ∑ m ∈ Finset.range (n + 1), (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * z ^ m := by ++ calc ++ k z = ∑' m : ℕ, (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * (z - 0) ^ m := by ++ simpa using htaylor.symm ++ _ = _ := htsum ++ have hEval : ++ Polynomial.eval z P = ++ ∑ m ∈ Finset.range (n + 1), z ^ m * ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0) := by ++ classical ++ change Polynomial.eval₂ (RingHom.id ℂ) z P = _ ++ let φ : Polynomial ℂ →+* ℂ := Polynomial.eval₂RingHom (RingHom.id ℂ) z ++ change φ P = _ ++ simp [P, φ, Polynomial.eval₂_monomial, mul_comm] ++ have hfinite' : ++ k z = ∑ m ∈ Finset.range (n + 1), z ^ m * ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0) := by ++ simpa [mul_comm, mul_left_comm, mul_assoc] using hfinite ++ simpa [hEval] using hfinite' ++ refine ⟨P, hPdeg, ?_⟩ ++ intro z ++ have : H z = Complex.exp (k z) := by simp [hk_exp z] ++ simp [this, hk_poly z] ++ ++end Hadamard ++end Complex ++end ++end HadamardSourceScope31 ++ ++section HadamardSourceScope32 ++ ++noncomputable section ++ ++namespace Complex ++ ++open _root_.Complex ++namespace Hadamard ++ ++open _root_.Complex _root_.Erdos970.Complex _root_.Real _root_.Erdos970.Real ++ BigOperators _root_.Finset Set Filter Topology Metric ++ ++open scoped Topology ++ ++open Polynomial ++ ++private lemma exists_pow_eq_complex {n : ℕ} (hn : 0 < n) (w : ℂ) : ∃ z : ℂ, z ^ n = w := by ++ classical ++ by_cases hw : w = 0 ++ · subst hw ++ refine ⟨0, ?_⟩ ++ have hn0 : n ≠ 0 := Nat.ne_of_gt hn ++ simp [hn0] ++ · refine ⟨Complex.exp (Complex.log w / n), ?_⟩ ++ have hn0 : (n : ℂ) ≠ 0 := by ++ exact_mod_cast (Nat.ne_of_gt hn) ++ calc ++ (Complex.exp (Complex.log w / n)) ^ n ++ = Complex.exp ((n : ℂ) * (Complex.log w / n)) := by ++ simpa using (Complex.exp_nat_mul (Complex.log w / n) n).symm ++ _ = Complex.exp (Complex.log w) := by ++ have : (n : ℂ) * (Complex.log w / n) = Complex.log w := by ++ field_simp [hn0] ++ simp [this] ++ _ = w := by simpa using (Complex.exp_log hw) ++ ++private lemma mul_conj_div_norm (a : ℂ) (ha : a ≠ 0) : ++ a * ((starRingEnd ℂ) a / (‖a‖ : ℂ)) = (‖a‖ : ℂ) := by ++ have hnorm_pos : 0 < ‖a‖ := norm_pos_iff.mpr ha ++ have hnorm_ne : (‖a‖ : ℂ) ≠ 0 := by ++ exact_mod_cast (ne_of_gt hnorm_pos) ++ have hmul : a * (starRingEnd ℂ) a = (Complex.normSq a : ℂ) := ++ Complex.mul_conj a ++ have hcast : (Complex.normSq a : ℂ) = ((‖a‖ ^ 2 : ℝ) : ℂ) := by ++ exact_mod_cast (Complex.normSq_eq_norm_sq a) ++ have hdiv : ((‖a‖ ^ 2 : ℝ) : ℂ) / (‖a‖ : ℂ) = (‖a‖ : ℂ) := by ++ have : ((‖a‖ ^ 2 : ℝ) : ℂ) = (‖a‖ : ℂ) * (‖a‖ : ℂ) := by ++ simp [pow_two] ++ calc ++ ((‖a‖ ^ 2 : ℝ) : ℂ) / (‖a‖ : ℂ) ++ = ((‖a‖ : ℂ) * (‖a‖ : ℂ)) / (‖a‖ : ℂ) := by simp [this] ++ _ = (‖a‖ : ℂ) := by ++ field_simp [hnorm_ne] ++ calc ++ a * ((starRingEnd ℂ) a / (‖a‖ : ℂ)) ++ = (a * (starRingEnd ℂ) a) / (‖a‖ : ℂ) := by ++ simp [div_eq_mul_inv, mul_assoc] ++ _ = (Complex.normSq a : ℂ) / (‖a‖ : ℂ) := by simp [hmul] ++ _ = ((‖a‖ ^ 2 : ℝ) : ℂ) / (‖a‖ : ℂ) := by simp [hcast] ++ _ = (‖a‖ : ℂ) := hdiv ++ ++private lemma exists_z_norm_eq_re_eval_ge ++ (P : Polynomial ℂ) (hn : 0 < P.natDegree) : ++ ∃ R0 : ℝ, 0 < R0 ∧ ++ ∀ R : ℝ, R0 ≤ R → ++ ∃ z : ℂ, ‖z‖ = R ∧ ++ (‖P.leadingCoeff‖ / 2) * R ^ P.natDegree ≤ (P.eval z).re := by ++ classical ++ set n : ℕ := P.natDegree ++ have hn0 : 0 < n := hn ++ have hP0 : P ≠ 0 := by ++ intro h0 ++ simp [n, h0] at hn0 ++ have hLC : P.leadingCoeff ≠ 0 := Polynomial.leadingCoeff_ne_zero.mpr hP0 ++ set a : ℂ := P.leadingCoeff ++ have ha : a ≠ 0 := hLC ++ have hnorm_a_pos : 0 < ‖a‖ := norm_pos_iff.mpr ha ++ set wtarget : ℂ := (starRingEnd ℂ) a / (‖a‖ : ℂ) ++ have hwtarget_norm : ‖wtarget‖ = (1 : ℝ) := by ++ calc ++ ‖wtarget‖ = ‖(starRingEnd ℂ) a‖ / ‖(‖a‖ : ℂ)‖ := by ++ simp [wtarget] ++ _ = ‖a‖ / ‖a‖ := by simp ++ _ = (1 : ℝ) := by ++ field_simp [hnorm_a_pos.ne'] ++ rcases exists_pow_eq_complex (n := n) hn0 (w := wtarget) with ⟨w, hw⟩ ++ have hw_norm : ‖w‖ = (1 : ℝ) := by ++ have hpow : (‖w‖ : ℝ) ^ n = 1 := by ++ have := congrArg (fun z : ℂ => ‖z‖) hw ++ simpa [norm_pow, hwtarget_norm] using this ++ have hn0' : n ≠ 0 := Nat.ne_of_gt hn0 ++ exact (pow_eq_one_iff_of_nonneg (norm_nonneg w) hn0').1 hpow ++ set S : ℝ := ∑ i ∈ Finset.range n, ‖P.coeff i‖ ++ set R0 : ℝ := max 1 (2 * S / ‖a‖) ++ refine ⟨R0, ?_, ?_⟩ ++ · have : (0 : ℝ) < (1 : ℝ) := by norm_num ++ exact lt_of_lt_of_le this (le_max_left _ _) ++ · intro R hR ++ have hR_ge1 : (1 : ℝ) ≤ R := by ++ exact le_trans (le_max_left _ _) hR ++ have hR_nonneg : 0 ≤ R := le_trans (by norm_num) hR_ge1 ++ set z : ℂ := (R : ℂ) * w ++ have hz_norm : ‖z‖ = R := by ++ have : ‖z‖ = |R| * ‖w‖ := by ++ simp [z] ++ simp [this, hw_norm, abs_of_nonneg hR_nonneg] ++ have h_eval : P.eval z = ++ (∑ i ∈ Finset.range n, P.coeff i * z ^ i) + P.coeff n * z ^ n := by ++ have hsum : P.eval z = ∑ i ∈ Finset.range (n + 1), P.coeff i * z ^ i := by ++ have : P.natDegree + 1 = n + 1 := by simp [n] ++ simpa [this] using (Polynomial.eval_eq_sum_range (p := P) z) ++ have hsplit : ++ (∑ i ∈ Finset.range (n + 1), P.coeff i * z ^ i) ++ = (∑ i ∈ Finset.range n, P.coeff i * z ^ i) + P.coeff n * z ^ n := by ++ simpa using (Finset.sum_range_succ (f := fun i => P.coeff i * z ^ i) n) ++ exact hsum.trans hsplit ++ have h_lower_norm : ++ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ≤ S * R ^ (n - 1) := by ++ have h1 : ++ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ++ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ := by ++ simpa using (norm_sum_le (Finset.range n) (fun i => P.coeff i * z ^ i)) ++ have hterm : ∀ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ ≤ ‖P.coeff i‖ * R ^ (n - 1) := by ++ intro i hi ++ have hi_lt : i < n := Finset.mem_range.mp hi ++ have hi_le : i ≤ n - 1 := Nat.le_pred_of_lt hi_lt ++ have hzpow : ‖z‖ ^ i ≤ R ^ (n - 1) := by ++ have hmono : ‖z‖ ^ i ≤ ‖z‖ ^ (n - 1) := ++ pow_le_pow_right₀ (by simpa [hz_norm] using hR_ge1) hi_le ++ simpa [hz_norm] using hmono ++ calc ++ ‖P.coeff i * z ^ i‖ = ‖P.coeff i‖ * ‖z‖ ^ i := by ++ simp [norm_pow] ++ _ ≤ ‖P.coeff i‖ * R ^ (n - 1) := by ++ exact mul_le_mul_of_nonneg_left hzpow (norm_nonneg _) ++ have h2 : ++ ∑ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ ++ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i‖ * R ^ (n - 1) := by ++ exact Finset.sum_le_sum (fun i hi => hterm i hi) ++ have h3 : ++ (∑ i ∈ Finset.range n, ‖P.coeff i‖ * R ^ (n - 1)) ++ = (∑ i ∈ Finset.range n, ‖P.coeff i‖) * R ^ (n - 1) := by ++ simp [Finset.sum_mul] ++ have hsum_le : (∑ i ∈ Finset.range n, ‖P.coeff i‖) ≤ S := by ++ simp [S] ++ calc ++ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ++ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ := h1 ++ _ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i‖ * R ^ (n - 1) := h2 ++ _ = (∑ i ∈ Finset.range n, ‖P.coeff i‖) * R ^ (n - 1) := h3 ++ _ ≤ S * R ^ (n - 1) := by ++ exact mul_le_mul_of_nonneg_right hsum_le (pow_nonneg hR_nonneg _) ++ have h_lead_re : (P.coeff n * z ^ n).re = ‖a‖ * R ^ n := by ++ have hw_pow : w ^ n = wtarget := hw ++ have ha_mul : a * w ^ n = (‖a‖ : ℂ) := by ++ have : a * w ^ n = a * wtarget := by simp [hw_pow] ++ simpa [wtarget, a] using (this.trans (mul_conj_div_norm a ha)) ++ have hz_pow : z ^ n = ((R : ℂ) ^ n) * (w ^ n) := by ++ simp [z, mul_pow, mul_comm] ++ have hcoeffn : P.coeff n = a := by simp [a, n, Polynomial.coeff_natDegree] ++ have hreR : ∀ m : ℕ, (((R : ℂ) ^ m).re) = R ^ m := by ++ intro m ++ induction m with ++ | zero => simp ++ | succ m ih => ++ simp [pow_succ, ih, mul_re] ++ calc ++ (P.coeff n * z ^ n).re ++ = (a * z ^ n).re := by simp [hcoeffn] ++ _ = (a * (((R : ℂ) ^ n) * (w ^ n))).re := by simp [hz_pow] ++ _ = (((R : ℂ) ^ n) * (a * (w ^ n))).re := by ++ ring_nf ++ _ = (((R : ℂ) ^ n) * (‖a‖ : ℂ)).re := by simp [ha_mul] ++ _ = (((R : ℂ) ^ n).re) * ‖a‖ := by ++ simp [mul_re] ++ _ = (R ^ n) * ‖a‖ := by simp [hreR n] ++ _ = ‖a‖ * R ^ n := by ring ++ refine ⟨z, hz_norm, ?_⟩ ++ have hre_lower : (∑ i ∈ Finset.range n, P.coeff i * z ^ i).re ++ ≥ -‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := by ++ have habs : |(∑ i ∈ Finset.range n, P.coeff i * z ^ i).re| ++ ≤ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := ++ Complex.abs_re_le_norm _ ++ have := neg_le_of_abs_le habs ++ simpa using this ++ have hre_main : ++ (P.eval z).re ≥ (P.coeff n * z ^ n).re - ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := by ++ have : (P.eval z).re = ++ (∑ i ∈ Finset.range n, P.coeff i * z ^ i).re + (P.coeff n * z ^ n).re := by ++ simp [h_eval, add_comm] ++ linarith [this, hre_lower] ++ have hR_ge_R0 : R0 ≤ R := hR ++ have hR_ge : 2 * S / ‖a‖ ≤ R := le_trans (le_max_right _ _) hR_ge_R0 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR_ge1 ++ have hR_nonneg' : 0 ≤ R := le_of_lt hRpos ++ have hn_ge1 : 1 ≤ n := Nat.succ_le_of_lt hn0 ++ have hlower_le : S * R ^ (n - 1) ≤ (‖a‖ / 2) * R ^ n := by ++ have ha_pos : 0 < ‖a‖ := hnorm_a_pos ++ have hS_le : S ≤ (‖a‖ / 2) * R := by ++ have : 2 * S ≤ ‖a‖ * R := by ++ have := (mul_le_mul_of_nonneg_left hR_ge (by linarith [ha_pos.le] : (0 : ℝ) ≤ ‖a‖)) ++ have hne : (‖a‖ : ℝ) ≠ 0 := ne_of_gt ha_pos ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm, hne] using this ++ have : S ≤ (‖a‖ * R) / 2 := by linarith ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using this ++ have : S * R ^ (n - 1) ≤ (‖a‖ / 2) * R * R ^ (n - 1) := by ++ have hpow_nonneg : 0 ≤ R ^ (n - 1) := pow_nonneg hR_nonneg' _ ++ exact mul_le_mul_of_nonneg_right hS_le hpow_nonneg ++ have hRR : R * R ^ (n - 1) = R ^ n := by ++ have : n = (n - 1) + 1 := by ++ exact (Nat.sub_add_cancel hn_ge1).symm ++ rw [this, pow_succ] ++ ring_nf; grind ++ simpa [mul_assoc, hRR] using this ++ have hfinal_re : ++ (‖a‖ / 2) * R ^ n ≤ (P.eval z).re := by ++ have hlower' : ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ≤ (‖a‖ / 2) * R ^ n := by ++ exact h_lower_norm.trans hlower_le ++ have hlead : (P.coeff n * z ^ n).re = ‖a‖ * R ^ n := by simpa [a] using h_lead_re ++ have hre_main' : ++ (‖a‖ * R ^ n) - ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ≤ (P.eval z).re := by ++ simpa [hlead] using hre_main ++ have hsub : ++ (‖a‖ * R ^ n) - (‖a‖ / 2) * R ^ n ≤ ++ (‖a‖ * R ^ n) - ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := ++ sub_le_sub_left hlower' (‖a‖ * R ^ n) ++ have hsim : (‖a‖ * R ^ n) - (‖a‖ / 2) * R ^ n = (‖a‖ / 2) * R ^ n := by ring ++ have : (‖a‖ * R ^ n) - (‖a‖ / 2) * R ^ n ≤ (P.eval z).re := ++ hsub.trans hre_main' ++ simpa [hsim] using this ++ simpa [a, n] using hfinal_re ++ ++theorem natDegree_le_floor_of_growth_exp_eval ++ {ρ : ℝ} (hρ : 0 ≤ ρ) (P : Polynomial ℂ) ++ (hgrowth : ++ ∃ C > 0, ∀ z : ℂ, ++ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ P.natDegree ≤ Nat.floor ρ := by ++ classical ++ by_cases hdeg : P.natDegree = 0 ++ · simp [hdeg] ++ · have hnpos : 0 < P.natDegree := Nat.pos_of_ne_zero hdeg ++ rcases exists_z_norm_eq_re_eval_ge (P := P) hnpos with ⟨R0, hR0pos, hray⟩ ++ rcases hgrowth with ⟨C, hCpos, hC⟩ ++ have hLCpos : 0 < ‖P.leadingCoeff‖ := by ++ have hP0 : P ≠ 0 := by ++ intro h0 ++ simp [h0] at hdeg ++ have : P.leadingCoeff ≠ 0 := (Polynomial.leadingCoeff_ne_zero).2 hP0 ++ exact norm_pos_iff.2 this ++ let c : ℝ := ‖P.leadingCoeff‖ / 2 ++ have hcpos : 0 < c := by ++ have : (0 : ℝ) < (2 : ℝ) := by norm_num ++ exact (div_pos hLCpos this) ++ have hn_le_real : (P.natDegree : ℝ) ≤ ρ := by ++ by_contra hnlt ++ have hnlt' : ρ < (P.natDegree : ℝ) := lt_of_not_ge hnlt ++ let δ : ℝ := (P.natDegree : ℝ) - ρ ++ have hδ : 0 < δ := sub_pos.2 hnlt' ++ let K0 : ℝ := (C * (2 : ℝ) ^ ρ) / c ++ have hK0 : ∃ R1, ∀ R ≥ R1, K0 + 1 ≤ R ^ δ := by ++ have h : ∀ᶠ R in (atTop : Filter ℝ), K0 + 1 ≤ R ^ δ := ++ (tendsto_atTop.mp (tendsto_rpow_atTop hδ)) (K0 + 1) ++ rcases (eventually_atTop.1 h) with ⟨R1, hR1⟩ ++ exact ⟨R1, hR1⟩ ++ rcases hK0 with ⟨R1, hR1⟩ ++ set R : ℝ := max (max R0 1) R1 ++ have hR_ge_R0 : R0 ≤ R := le_trans (le_max_left _ _) (le_max_left _ _) ++ have hR_ge1 : (1 : ℝ) ≤ R := le_trans (le_max_right _ _) (le_max_left _ _) ++ have hR_ge_R1 : R1 ≤ R := le_max_right _ _ ++ have hR_pos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR_ge1 ++ have hRδ : K0 + 1 ≤ R ^ δ := hR1 R hR_ge_R1 ++ rcases hray R hR_ge_R0 with ⟨z, hz_norm, hz_re⟩ ++ have hlog_lower : ++ (P.eval z).re ≤ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) := by ++ have hpos : 0 < ‖Complex.exp (Polynomial.eval z P)‖ := by ++ simp ++ have hle : ++ ‖Complex.exp (Polynomial.eval z P)‖ ≤ ++ 1 + ‖Complex.exp (Polynomial.eval z P)‖ := by ++ linarith [norm_nonneg (Complex.exp (Polynomial.eval z P))] ++ have hlog_le : Real.log ‖Complex.exp (Polynomial.eval z P)‖ ++ ≤ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) := ++ Real.log_le_log hpos hle ++ have hlog_eq : Real.log ‖Complex.exp (Polynomial.eval z P)‖ = (P.eval z).re := by ++ simp [Complex.norm_exp] ++ simpa [hlog_eq] using hlog_le ++ have hlog_upper : ++ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) ≤ C * (1 + ‖z‖) ^ ρ := ++ hC z ++ have hmain : c * R ^ (P.natDegree : ℝ) ≤ C * (1 + R) ^ ρ := by ++ have hz_re' : c * R ^ P.natDegree ≤ (P.eval z).re := by ++ simpa [c] using hz_re ++ have hz_re'' : c * R ^ (P.natDegree : ℝ) ≤ (P.eval z).re := by ++ simpa [Real.rpow_natCast, c] using hz_re' ++ have : c * R ^ (P.natDegree : ℝ) ≤ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) := ++ hz_re''.trans hlog_lower ++ have : c * R ^ (P.natDegree : ℝ) ≤ C * (1 + ‖z‖) ^ ρ := ++ this.trans hlog_upper ++ simpa [hz_norm] using this ++ have h1R_le : (1 + R : ℝ) ≤ R * 2 := by linarith ++ have hpow1 : (1 + R : ℝ) ^ ρ ≤ (R * 2) ^ ρ := ++ Real.rpow_le_rpow (by linarith [hR_pos.le]) h1R_le hρ ++ have hR2 : (R * 2) ^ ρ = R ^ ρ * (2 : ℝ) ^ ρ := by ++ have hRnonneg : 0 ≤ R := le_of_lt hR_pos ++ have h2nonneg : 0 ≤ (2 : ℝ) := by norm_num ++ simpa [mul_assoc] using (Real.mul_rpow hRnonneg h2nonneg (z := ρ)) ++ have hmain' : c * R ^ (P.natDegree : ℝ) ≤ C * (R ^ ρ * (2 : ℝ) ^ ρ) := by ++ have := le_trans hmain (mul_le_mul_of_nonneg_left hpow1 (le_of_lt hCpos)) ++ simpa [hR2, mul_assoc, mul_left_comm, mul_comm] using this ++ have hRρ_pos : 0 < R ^ ρ := Real.rpow_pos_of_pos hR_pos _ ++ have hRρ_ne : (R ^ ρ : ℝ) ≠ 0 := ne_of_gt hRρ_pos ++ have hdiv : ++ (c * R ^ (P.natDegree : ℝ)) / (R ^ ρ) ≤ C * (2 : ℝ) ^ ρ := by ++ have h := ++ div_le_div_of_nonneg_right hmain' (le_of_lt hRρ_pos) ++ have hRhs : (C * (R ^ ρ * (2 : ℝ) ^ ρ)) / (R ^ ρ) = C * (2 : ℝ) ^ ρ := by ++ field_simp [hRρ_ne] ++ simpa [hRhs, mul_assoc, mul_left_comm, mul_comm] using h ++ have hRsub : R ^ δ = R ^ (P.natDegree : ℝ) / R ^ ρ := by ++ simpa [δ] using (Real.rpow_sub hR_pos (P.natDegree : ℝ) ρ) ++ have hRδ_le : c * (R ^ δ) ≤ C * (2 : ℝ) ^ ρ := by ++ have hLhs : c * (R ^ δ) = (c * R ^ (P.natDegree : ℝ)) / (R ^ ρ) := by ++ simp [hRsub, div_eq_mul_inv, mul_left_comm, mul_comm] ++ simpa [hLhs] using hdiv ++ have hRδ_le' : R ^ δ ≤ K0 := by ++ have : R ^ δ ≤ (C * (2 : ℝ) ^ ρ) / c := by ++ refine (le_div_iff₀ hcpos).2 ?_ ++ simpa [mul_assoc, mul_left_comm, mul_comm] using hRδ_le ++ simpa [K0] using this ++ have : K0 + 1 ≤ K0 := le_trans hRδ (le_trans hRδ_le' (le_rfl)) ++ exact (not_lt_of_ge this) (lt_add_of_pos_right _ (by norm_num : (0 : ℝ) < 1)) ++ exact (Nat.le_floor_iff hρ).2 hn_le_real ++ ++theorem natDegree_le_floor_of_exp_eval_norm_bound {τ : ℝ} (hτ : 0 ≤ τ) (P : Polynomial ℂ) ++ (hbound : ++ ∃ C > 0, ∀ z : ℂ, ++ ‖Complex.exp (Polynomial.eval z P)‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ)) : ++ P.natDegree ≤ Nat.floor τ := by ++ rcases hbound with ⟨C, hCpos, hC⟩ ++ have hlog_growth : ++ ∃ C > 0, ∀ z : ℂ, ++ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) ≤ C * (1 + ‖z‖) ^ τ := ++ Real.log_growth_of_norm_le_exp_mul_rpow ++ (f := fun z : ℂ => Complex.exp (Polynomial.eval z P)) ++ (r := fun z : ℂ => 1 + ‖z‖) hCpos hτ ++ (fun z => by linarith [norm_nonneg z]) hC ++ exact natDegree_le_floor_of_growth_exp_eval (ρ := τ) hτ P hlog_growth ++ ++end Hadamard ++end Complex ++end ++end HadamardSourceScope32 ++ ++section HadamardSourceScope33 ++ ++noncomputable section ++ ++open Set Filter Asymptotics ++open scoped Topology BigOperators ++ ++namespace Complex.Hadamard ++ ++open _root_.Complex ++ ++lemma no_zero_on_sphere_of_norm_image_avoid ++ {f : ℂ → ℂ} (hentire : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ {B r : ℝ} (hrpos : 0 < r) (hr_le_B : r ≤ B) ++ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (hsmall_fin : smallSet.Finite) ++ (hsmallSet : ++ smallSet = {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ B}) ++ (hr_not_bad : ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ r ∉ small.image a) : ++ ∀ u : ℂ, ‖u‖ = r → f u ≠ 0 := by ++ classical ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let bad : Finset ℝ := small.image a ++ have hr_not_bad' : r ∉ bad := by ++ simpa [bad, small, a] using hr_not_bad ++ have hr_not : ++ ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖ ≤ B → r ≠ ‖divisorZeroIndex₀Val p‖ := by ++ intro p hpB hEq ++ have hp_small : p ∈ small := by ++ have hp_mem : p ∈ smallSet := by ++ simpa [hsmallSet] using hpB ++ simpa [small] using (hsmall_fin.mem_toFinset.2 hp_mem) ++ have : r ∈ bad := Finset.mem_image.2 ⟨p, hp_small, by simpa [a] using hEq.symm⟩ ++ exact (hr_not_bad' this).elim ++ exact no_zero_on_sphere_of_forall_val_norm_ne (f := f) hentire hnot ++ (B := B) (r := r) hrpos hr_le_B hr_not ++ ++theorem norm_inv_hadamardDenominator_le_exp_on_cartan_circle ++ {f : ℂ → ℂ} {ρ τ : ℝ} {m : ℕ} ++ (hmρ : (m : ℝ) ≤ ρ) (hτ : ρ < τ) (hτ_lt : τ < (m + 1 : ℝ)) ++ (hτ_nonneg : 0 ≤ τ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (hsumτ : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ let Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ ∀ {R r : ℝ}, 0 < R → 1 ≤ R → R ≤ r → r ≤ 2 * R → ++ ∀ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall_fin : smallSet.Finite), ++ smallSet = ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ 4 * R} → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ r ∉ small.image a) → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ (∑ p ∈ small, (1 : ℝ) * CartanBound.φ (r / a p)) ≤ ++ CartanBound.Cφ * (small.card : ℝ)) → ++ ∀ u : ℂ, ‖u‖ = r → ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ Real.exp (Cprod * (1 + r) ^ τ) := by ++ classical ++ intro Sτ Cprod R r hRpos hRle hR_le_r hr_le_2R smallSet hsmall_fin ++ hsmallSet hr_not_bad hr_phi u hur ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let bad : Finset ℝ := small.image a ++ have hr_not_bad' : r ∉ bad := by ++ simpa [bad, small, a] using hr_not_bad ++ have hr1 : (1 : ℝ) ≤ r := le_trans hRle hR_le_r ++ have hpow_inv_le1 : ‖(u ^ analyticOrderNatAt f 0)⁻¹‖ ≤ 1 := ++ Complex.norm_inv_pow_le_one_of_one_le_norm u (analyticOrderNatAt f 0) (by simpa [hur] using hr1) ++ let fac : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := ++ fun p => weierstrassFactor m (u / divisorZeroIndex₀Val p) ++ have hloc : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (w : ℂ) => ++ weierstrassFactor m (w / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (Set.univ : Set ℂ) := ++ hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ have hprod : ++ HasProd fac (divisorCanonicalProduct m f (Set.univ : Set ℂ) u) := ++ hloc.hasProd (by simp : u ∈ (Set.univ : Set ℂ)) ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ have : DecidablePred (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => p ∈ small) := ++ Classical.decPred _ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if hp : p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ have hterm : ∀ p, ‖(fac p)⁻¹‖ ≤ Real.exp (b p) := by ++ intro p ++ by_cases hp : p ∈ small ++ · have hval_ne : r ≠ ap p := by ++ intro hEq ++ have : r ∈ bad := by ++ refine Finset.mem_image.2 ⟨p, hp, ?_⟩ ++ simp [ap, a, hEq] ++ exact (hr_not_bad' this).elim ++ have hval0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ have hmτ : (m : ℝ) ≤ τ := le_trans hmρ (le_of_lt hτ) ++ have hnear : ++ ‖(weierstrassFactor m (u / divisorZeroIndex₀Val p))⁻¹‖ ++ ≤ Real.exp (CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ)) := by ++ simpa [ap] using ++ (norm_inv_weierstrassFactor_le_exp_near (m := m) (τ := τ) (r := r) ++ (u := u) (a := divisorZeroIndex₀Val p) ++ (hur := hur) (ha := hval0) (hr := by simpa [ap] using hval_ne) hmτ) ++ simpa [fac, b, hp] using hnear ++ · have hlarge : (4 * R : ℝ) < ap p := by ++ have : ¬ap p ≤ 4 * R := by ++ intro hle ++ have : p ∈ small := by ++ have hp_mem : p ∈ smallSet := by ++ simpa [hsmallSet, ap] using hle ++ simpa [small] using (hsmall_fin.mem_toFinset.2 hp_mem) ++ exact hp this ++ exact lt_of_not_ge this ++ have hz' : ‖u / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := ++ norm_div_le_half_of_norm_le_of_two_mul_lt (z := u) (a := divisorZeroIndex₀Val p) ++ (R := 2 * R) (by nlinarith [hRpos]) (by rw [hur]; exact hr_le_2R) ++ (by nlinarith [hlarge]) ++ have hτ_le : τ ≤ (m + 1 : ℝ) := le_of_lt hτ_lt ++ have hfar : ++ ‖(weierstrassFactor m (u / divisorZeroIndex₀Val p))⁻¹‖ ≤ ++ Real.exp ((2 : ℝ) * (r / ap p) ^ τ) := by ++ simpa [ap] using ++ (norm_inv_weierstrassFactor_le_exp_far (m := m) (τ := τ) (r := r) ++ (u := u) (a := divisorZeroIndex₀Val p) ++ (hur := hur) (ha := divisorZeroIndex₀Val_ne_zero p) (hz := hz') hτ_le) ++ simpa [fac, b, hp] using hfar ++ have hb_le : ++ ∀ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)), ++ (∑ p ∈ s, b p) ≤ Cprod * (1 + r) ^ τ := by ++ intro s ++ simpa [small, ap, b, Sτ, Cprod, a, hsmallSet] using ++ (Complex.Hadamard.cartan_sum_majorant_le (f := f) (m := m) (τ := τ) (R := R) (r := r) ++ (hRpos := hRpos) (hrpos := lt_of_lt_of_le hRpos hR_le_r) ++ (hR_le_r := hR_le_r) (hτ_nonneg := hτ_nonneg) ++ (smallSet := smallSet) (hsmall_fin := hsmall_fin) (hsmallSet := hsmallSet) ++ (hsumτ := hsumτ) ++ (hr_phi := by ++ simpa [small, a, one_mul] using hr_phi) ++ s) ++ have hcprod_inv : ++ ‖(divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ≤ ++ Real.exp (Cprod * (1 + r) ^ τ) := by ++ refine hasProd_norm_inv_le_exp_of_pointwise_le_exp ++ (α := divisorZeroIndex₀ f (Set.univ : Set ℂ)) (fac := fac) ++ (F := divisorCanonicalProduct m f (Set.univ : Set ℂ) u) ++ hprod (b := b) (B := Cprod * (1 + r) ^ τ) ?_ ?_ ++ · exact hterm ++ · intro s ++ exact hb_le s ++ have hmul : ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ = ++ ‖(u ^ analyticOrderNatAt f 0)⁻¹‖ * ++ ‖(divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ := by ++ simp [mul_inv_rev, mul_comm] ++ rw [hmul] ++ have : ++ ‖(u ^ analyticOrderNatAt f 0)⁻¹‖ * ++ ‖(divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ 1 * Real.exp (Cprod * (1 + r) ^ τ) := ++ mul_le_mul hpow_inv_le1 hcprod_inv (by positivity) (by positivity) ++ simpa using this ++ ++theorem hadamardQuotient_norm_le_exp_on_cartan_circle ++ {f H : ℂ → ℂ} {ρ τ : ℝ} {m : ℕ} {Cf : ℝ} ++ (hmρ : (m : ℝ) ≤ ρ) (hτ : ρ < τ) (hτ_lt : τ < (m + 1 : ℝ)) ++ (hτ_nonneg : 0 ≤ τ) (hentire : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (hsumτ : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) ++ (hf_boundτ : ∀ z : ℂ, ‖f z‖ ≤ Real.exp (Cf * (1 + ‖z‖) ^ τ)) ++ (hfactor : ∀ z : ℂ, ++ f z = ++ H z * z ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) z) : ++ let Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ ∀ {R r : ℝ}, 0 < R → 1 ≤ R → R ≤ r → r ≤ 2 * R → 0 < r → ++ ∀ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall_fin : smallSet.Finite), ++ smallSet = ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ 4 * R} → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ r ∉ small.image a) → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ (∑ p ∈ small, (1 : ℝ) * CartanBound.φ (r / a p)) ≤ ++ CartanBound.Cφ * (small.card : ℝ)) → ++ ∀ u : ℂ, ‖u‖ = r → ‖H u‖ ≤ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ classical ++ intro Sτ Cprod R r hRpos hRle hR_le_r hr_le_2R hrpos smallSet hsmall_fin ++ hsmallSet hr_not_bad hr_phi u hur ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let bad : Finset ℝ := small.image a ++ have hr_not_bad' : r ∉ bad := by ++ simpa [bad, small, a] using hr_not_bad ++ have hden_eq : ++ f u = ++ H u * (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u) := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using (hfactor u) ++ have hfu_ne : f u ≠ 0 := by ++ have hr_le_4R : r ≤ 4 * R := by nlinarith [hr_le_2R, hRpos] ++ exact no_zero_on_sphere_of_norm_image_avoid (f := f) hentire hnot ++ (B := 4 * R) (r := r) hrpos hr_le_4R smallSet hsmall_fin hsmallSet ++ (by simpa [small, a] using hr_not_bad) u hur ++ have hden_ne : ++ (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u) ≠ 0 := by ++ intro hden0 ++ have : f u = 0 := by simpa [hden0] using hden_eq ++ exact hfu_ne this ++ have hHu : ++ H u = ++ f u / (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u) := by ++ exact eq_div_of_mul_eq hden_ne (Eq.symm hden_eq) ++ have hf_u : ‖f u‖ ≤ Real.exp (Cf * (1 + r) ^ τ) := by ++ simpa [hur] using hf_boundτ u ++ have hden_inv : ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ Real.exp (Cprod * (1 + r) ^ τ) := by ++ simpa [Sτ, Cprod] using ++ (norm_inv_hadamardDenominator_le_exp_on_cartan_circle ++ (f := f) (ρ := ρ) (τ := τ) (m := m) ++ hmρ hτ hτ_lt hτ_nonneg h_sum hsumτ ++ (R := R) (r := r) hRpos hRle hR_le_r hr_le_2R ++ smallSet hsmall_fin hsmallSet ++ (by simpa [small, a] using hr_not_bad) ++ (by simpa [small, a, one_mul] using hr_phi) ++ u hur) ++ have : ++ ‖H u‖ ≤ ++ ‖f u‖ * ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ := by ++ have : ++ ‖H u‖ = ++ ‖f u / ++ (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)‖ := by ++ simp [hHu] ++ simp [div_eq_mul_inv, norm_inv, this] ++ have hmul : ++ ‖f u‖ * ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ Real.exp (Cf * (1 + r) ^ τ) * Real.exp (Cprod * (1 + r) ^ τ) := ++ mul_le_mul hf_u hden_inv (by positivity) (by positivity) ++ have hexp : ++ Real.exp (Cf * (1 + r) ^ τ) * Real.exp (Cprod * (1 + r) ^ τ) ++ = Real.exp ((Cf + Cprod) * (1 + r) ^ τ) := by ++ simp [Real.exp_add, add_mul, add_comm] ++ have : ‖H u‖ ≤ Real.exp ((Cf + Cprod) * (1 + r) ^ τ) := ++ (this.trans hmul).trans_eq hexp ++ have hslack : ++ Real.exp ((Cf + Cprod) * (1 + r) ^ τ) ≤ ++ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ refine Real.exp_le_exp.2 ?_ ++ have hnn : 0 ≤ (1 + r) ^ τ := by positivity ++ nlinarith ++ exact this.trans hslack ++ ++theorem hadamardQuotient_norm_le_exp_rpow_of_growth {f H : ℂ → ℂ} {ρ τ : ℝ} {m : ℕ} ++ (hρ : 0 ≤ ρ) (hmρ : (m : ℝ) ≤ ρ) (hτ : ρ < τ) (hτ_lt : τ < (m + 1 : ℝ)) ++ (hτ_nonneg : 0 ≤ τ) (hentire : Differentiable ℂ f) (hH_entire : Differentiable ℂ H) ++ (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) ++ (hfactor : ∀ z : ℂ, ++ f z = ++ H z * z ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) z) : ++ ∃ C > 0, ∀ z : ℂ, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ) := by ++ rcases hgrowth with ⟨Cf, hCfpos, hCf⟩ ++ have hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := ++ summable_norm_inv_rpow_divisorZeroIndex₀_of_growth (f := f) (ρ := ρ) (τ := τ) ++ hρ hτ hentire hnot ⟨Cf, hCfpos, hCf⟩ ++ let Sτ : ℝ := ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have hSτ_nonneg : 0 ≤ Sτ := tsum_nonneg fun _ => ++ Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ have hCprod_nonneg : 0 ≤ Cprod := by ++ simpa [Cprod] using cartanProductConstant_nonneg (m := m) (τ := τ) hSτ_nonneg ++ have hf_boundτ : ∀ z : ℂ, ‖f z‖ ≤ Real.exp (Cf * (1 + ‖z‖) ^ τ) := ++ Real.norm_le_exp_mul_rpow_of_log_growth ++ (f := f) (r := fun z : ℂ => 1 + ‖z‖) (C := Cf) (ρ := ρ) (τ := τ) ++ hCfpos.le (fun z => by linarith [norm_nonneg z]) (le_of_lt hτ) hCf ++ refine ⟨(Cf + Cprod + 10) * (3 : ℝ) ^ τ, by ++ have h3τ : 0 < (3 : ℝ) ^ τ := by positivity ++ nlinarith [hCfpos, hCprod_nonneg, h3τ], ?_⟩ ++ intro z ++ let R : ℝ := max ‖z‖ 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num) (le_max_right _ _) ++ have hRle : (1 : ℝ) ≤ R := le_max_right _ _ ++ let smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ {p | ‖divisorZeroIndex₀Val p‖ ≤ 4 * R} ++ have hsmall_fin : smallSet.Finite := by ++ have : Metric.closedBall (0 : ℂ) (4 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ simpa [smallSet] using ++ (divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) ++ (B := 4 * R) this) ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ have ha_pos : ∀ p ∈ small, 0 < a p := by ++ intro p hp ++ exact norm_pos_iff.2 (divisorZeroIndex₀Val_ne_zero p) ++ let bad : Finset ℝ := small.image a ++ rcases CartanBound.exists_radius_Ioc_sum_mul_phi_div_le_Cφ_mul_sum_avoid ++ (s := small) (w := fun _ => (1 : ℝ)) (a := a) ++ (hw := by intro _ _; norm_num) (ha := ha_pos) (bad := bad) (R := R) hRpos with ++ ⟨r, hr_mem, hr_not_bad, hr_phi⟩ ++ have hR_le_r : R ≤ r := le_of_lt hr_mem.1 ++ have hr_le_2R : r ≤ 2 * R := hr_mem.2 ++ have hrpos : 0 < r := lt_of_lt_of_le hRpos hR_le_r ++ have hcircle : ++ ∀ u : ℂ, ‖u‖ = r → ‖H u‖ ≤ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ simpa [Sτ, Cprod] using ++ (hadamardQuotient_norm_le_exp_on_cartan_circle ++ (f := f) (H := H) (ρ := ρ) (τ := τ) (m := m) (Cf := Cf) ++ hmρ hτ hτ_lt hτ_nonneg hentire hnot h_sum hsumτ hf_boundτ hfactor ++ (R := R) (r := r) hRpos hRle hR_le_r hr_le_2R hrpos ++ smallSet hsmall_fin (by rfl) ++ (by simpa [small, a, bad] using hr_not_bad) ++ (by simpa [small, a, one_mul, Finset.sum_const, nsmul_eq_mul] using hr_phi)) ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) r := by ++ rw [Metric.mem_ball, dist_zero_right] ++ exact lt_of_le_of_lt (le_max_left _ _) hr_mem.1 ++ have hball : ++ ‖H z‖ ≤ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ exact Complex.norm_le_of_mem_ball_of_forall_sphere_norm_le hH_entire hrpos hz_ball hcircle ++ have hr_le_3 : 1 + r ≤ 3 * (1 + ‖z‖) := by ++ exact Real.one_add_le_three_mul_one_add_of_le_two_mul_max (norm_nonneg z) ++ (by simpa [R] using hr_le_2R) ++ have hmain : ++ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) ++ ≤ Real.exp (((Cf + Cprod + 10) * (3 : ℝ) ^ τ) * (1 + ‖z‖) ^ τ) := by ++ have hnn : 0 ≤ (Cf + Cprod + 10) := by nlinarith [le_of_lt hCfpos, hCprod_nonneg] ++ exact Real.exp_mul_rpow_le_exp_mul_rpow_of_le_mul hnn (by norm_num) ++ (by linarith [le_of_lt hrpos]) (by positivity) hτ_nonneg hr_le_3 ++ simpa [mul_assoc] using hball.trans hmain ++ ++theorem hadamard_factorization_of_growth {f : ℂ → ℂ} {ρ : ℝ} (hρ : 0 ≤ ρ) ++ (hentire : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ ∃ (P : Polynomial ℂ), ++ P.degree ≤ Nat.floor ρ ∧ ++ ∀ z : ℂ, ++ f z = ++ Complex.exp (Polynomial.eval z P) * ++ z ^ (analyticOrderNatAt f 0) * ++ divisorCanonicalProduct (Nat.floor ρ) f (Set.univ : Set ℂ) z := by ++ set m : ℕ := Nat.floor ρ ++ have h_sum : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simpa [m] using ++ (summable_norm_inv_pow_divisorZeroIndex₀_of_growth (f := f) (ρ := ρ) ++ hρ hentire hnot hgrowth) ++ rcases exists_entire_nonzero_hadamardQuotient (m := m) (f := f) hentire hnot h_sum with ++ ⟨H, hH_entire, hH_ne, hfactor⟩ ++ rcases Real.exists_between_self_and_floor_add_one_same_floor hρ with ++ ⟨τ, hτ, hτ_lt, hτ_nonneg, hfloorτ'⟩ ++ have hfloorτ : Nat.floor τ = m := by ++ simpa [m] using hfloorτ' ++ have hτ_lt_m : τ < (m + 1 : ℝ) := by ++ simpa [m] using hτ_lt ++ have hτ_lt_nat : τ < ((m + 1 : ℕ) : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one] using hτ_lt_m ++ have hmρ : (m : ℝ) ≤ ρ := by ++ have := Nat.floor_le hρ ++ simpa [m] using this ++ have hH_bound_rpow : ++ ∃ C > 0, ∀ z : ℂ, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ) := ++ hadamardQuotient_norm_le_exp_rpow_of_growth (f := f) (H := H) (ρ := ρ) (τ := τ) ++ (m := m) hρ hmρ hτ hτ_lt hτ_nonneg hentire hH_entire hnot h_sum hgrowth hfactor ++ have hH_growth_nat : ++ ∃ C > 0, ∀ z : ℂ, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ (m + 1)) := by ++ exact Real.exists_norm_le_exp_mul_pow_of_rpow_bound ++ (f := H) (r := fun z : ℂ => 1 + ‖z‖) ++ (fun z => by linarith [norm_nonneg z]) hτ_lt_nat hH_bound_rpow ++ rcases zero_free_polynomial_growth_is_exp_poly (H := H) (n := m + 1) ++ hH_entire hH_ne hH_growth_nat with ++ ⟨P, hPn, hHP⟩ ++ have hPnat : P.natDegree ≤ m := by ++ have hbound : ++ ∃ C > 0, ∀ z : ℂ, ++ ‖Complex.exp (Polynomial.eval z P)‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ) := by ++ rcases hH_bound_rpow with ⟨C, hCpos, hC⟩ ++ exact ⟨C, hCpos, fun z => by simpa [hHP z] using (hC z)⟩ ++ have := natDegree_le_floor_of_exp_eval_norm_bound hτ_nonneg P hbound ++ simpa [hfloorτ] using this ++ refine ⟨P, ?_, ?_⟩ ++ · have : P.degree ≤ m := Polynomial.degree_le_of_natDegree_le hPnat ++ simpa [m] using this ++ · intro z ++ have hH' : H z = Complex.exp (Polynomial.eval z P) := by simpa using (hHP z) ++ simpa [hH', mul_assoc, mul_left_comm, mul_comm, m] using (hfactor z) ++ ++end Complex.Hadamard ++end ++end HadamardSourceScope33 ++ ++end HadamardAssemblyScope ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Mathlib/Algebra/Notation/Support.lean b/PrimeNumberTheoremAnd/Erdos970/Mathlib/Algebra/Notation/Support.lean +new file mode 100644 +index 0000000..39dd03b +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Mathlib/Algebra/Notation/Support.lean +@@ -0,0 +1,17 @@ ++import Mathlib.Algebra.Notation.Support ++ ++namespace Erdos970 ++ ++namespace Function ++ ++variable {α : Type*} [Zero α] ++ ++theorem support_id : _root_.Function.support (id : α → α) = {0}ᶜ := by ++ ext; simp ++ ++theorem support_id' {α : Type*} [Zero α] : _root_.Function.support (fun x : α ↦ x) = {0}ᶜ := ++ support_id ++ ++end Function ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Mathlib/Analysis/Asymptotics/Asymptotics.lean b/PrimeNumberTheoremAnd/Erdos970/Mathlib/Analysis/Asymptotics/Asymptotics.lean +new file mode 100644 +index 0000000..1ef2299 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Mathlib/Analysis/Asymptotics/Asymptotics.lean +@@ -0,0 +1,42 @@ ++import Mathlib.Analysis.Asymptotics.Lemmas ++import Mathlib.Topology.Order.Compact ++ ++namespace Erdos970 ++ ++open Filter Topology ++ ++namespace Asymptotics ++ ++variable {α : Type*} {β : Type*} {E : Type*} {F : Type*} {G : Type*} {E' : Type*} ++ {F' : Type*} {G' : Type*} {E'' : Type*} {F'' : Type*} {G'' : Type*} {R : Type*} ++ {R' : Type*} {𝕜 : Type*} {𝕜' : Type*} ++ ++variable [Norm E] [Norm F] [Norm G] ++ ++variable [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] [SeminormedAddCommGroup G'] ++ [NormedAddCommGroup E''] [NormedAddCommGroup F''] [NormedAddCommGroup G''] [SeminormedRing R] ++ [SeminormedRing R'] ++ ++theorem isLittleO_const_id_cocompact [ProperSpace F''] ++ (c : E'') : (fun _x : F'' => c) =o[cocompact F''] id := ++ _root_.Asymptotics.isLittleO_const_left.2 <| Or.inr tendsto_norm_cocompact_atTop ++ ++theorem isLittleO_const_id_atTop2 [LinearOrder F''] [NoMaxOrder F''] [ClosedIciTopology F''] ++ [ProperSpace F''] (c : E'') : (fun _x : F'' => c) =o[atTop] id := ++ (isLittleO_const_id_cocompact c).mono atTop_le_cocompact ++ ++theorem isLittleO_const_id_atBot2 [LinearOrder F''] [NoMinOrder F''] [ClosedIicTopology F''] ++ [ProperSpace F''] (c : E'') : (fun _x : F'' => c) =o[atBot] id := ++ (isLittleO_const_id_cocompact c).mono atBot_le_cocompact ++ ++theorem _root_.Erdos970.Filter.Eventually.natCast {f : ℝ → Prop} (hf : ∀ᶠ x in atTop, f x) : ++ ∀ᶠ n : ℕ in atTop, f n := ++ tendsto_natCast_atTop_atTop.eventually hf ++ ++theorem IsBigO.natCast {f g : ℝ → E} (h : f =O[atTop] g) : ++ (fun n : ℕ => f n) =O[atTop] fun n : ℕ => g n := ++ h.comp_tendsto tendsto_natCast_atTop_atTop ++ ++end Asymptotics ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Mathlib/Analysis/SpecialFunctions/Log/Basic.lean b/PrimeNumberTheoremAnd/Erdos970/Mathlib/Analysis/SpecialFunctions/Log/Basic.lean +new file mode 100644 +index 0000000..b8b7136 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Mathlib/Analysis/SpecialFunctions/Log/Basic.lean +@@ -0,0 +1,20 @@ ++import Mathlib.Algebra.Order.Floor.Defs ++import Mathlib.Algebra.Order.Floor.Ring ++import Mathlib.Algebra.Order.Floor.Semiring ++import Mathlib.Analysis.SpecialFunctions.Log.Basic ++import Mathlib.Analysis.SpecialFunctions.Pow.Continuity ++ ++namespace Erdos970 ++ ++open Filter Real ++ ++theorem Real.tendsto_pow_log_div_pow_atTop (a : ℝ) (b : ℝ) (ha : 0 < a) : ++ Filter.Tendsto (fun x ↦ log x ^ b / x^a) Filter.atTop (nhds 0) := by ++ apply Asymptotics.isLittleO_iff_tendsto' _|>.mp <| isLittleO_log_rpow_rpow_atTop _ ha ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ intro h ++ rw [rpow_eq_zero hx.le ha.ne.symm] at h ++ exfalso ++ linarith ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/MellinCalculus.lean b/PrimeNumberTheoremAnd/Erdos970/MellinCalculus.lean +new file mode 100644 +index 0000000..12adb34 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/MellinCalculus.lean +@@ -0,0 +1,1024 @@ ++import Batteries.Tactic.Lemma ++import Mathlib.Algebra.GroupWithZero.Units.Basic ++import Mathlib.Analysis.MellinTransform ++import Mathlib.MeasureTheory.Integral.IntegrableOn ++import Mathlib.Tactic.Bound ++import Mathlib.Tactic.GCongr ++import PrimeNumberTheoremAnd.Erdos970.Auxiliary ++ ++namespace Erdos970 ++ ++open scoped ContDiff ++ ++ ++open _root_.Complex _root_.Topology _root_.Filter _root_.Real _root_.MeasureTheory ++ _root_.Set _root_.Function ++ ++theorem MeasureTheory.setIntegral_integral_swap {α : Type*} {β : Type*} {E : Type*} ++ [MeasurableSpace α] [MeasurableSpace β] {μ : MeasureTheory.Measure α} ++ {ν : MeasureTheory.Measure β} [NormedAddCommGroup E] ++ [MeasureTheory.SigmaFinite ν] [NormedSpace ℝ E] [MeasureTheory.SigmaFinite μ] ++ (f : α → β → E) {s : Set α} {t : Set β} ++ (hf : IntegrableOn (f.uncurry) (s ×ˢ t) (μ.prod ν)) : ++ (∫ (x : α) in s, ∫ (y : β) in t, f x y ∂ν ∂μ) ++ = ∫ (y : β) in t, ∫ (x : α) in s, f x y ∂μ ∂ν := by ++ apply integral_integral_swap ++ convert hf.integrable ++ exact Measure.prod_restrict s t ++ ++open Erdos970.Complex Erdos970.MeasureTheory ++ ++variable {𝕂 : Type*} [RCLike 𝕂] ++ ++lemma MeasureTheory.integral_comp_mul_right_I0i_haar ++ (f : ℝ → 𝕂) {a : ℝ} (ha : 0 < a) : ++ ∫ (y : ℝ) in Ioi 0, f (y * a) / y = ∫ (y : ℝ) in Ioi 0, f y / y := by ++ have := integral_comp_mul_right_Ioi (fun y ↦ f y / y) 0 ha ++ simp only [RCLike.ofReal_mul, zero_mul, eq_inv_smul_iff₀ (ne_of_gt ha)] at this ++ rw [← integral_smul] at this ++ rw [← this, setIntegral_congr_fun (by simp)] ++ intro _ _ ++ simp only [RCLike.real_smul_eq_coe_mul] ++ rw [mul_comm (a : 𝕂), div_mul, mul_div_assoc, div_self ?_, mul_one] ++ exact (RCLike.ofReal_ne_zero).mpr <| ne_of_gt ha ++ ++lemma MeasureTheory.integral_comp_mul_right_I0i_haar_real ++ (f : ℝ → ℝ) {a : ℝ} (ha : 0 < a) : ++ ∫ (y : ℝ) in Ioi 0, f (y * a) / y = ∫ (y : ℝ) in Ioi 0, f y / y := ++ MeasureTheory.integral_comp_mul_right_I0i_haar f ha ++ ++lemma MeasureTheory.integral_comp_mul_left_I0i_haar ++ (f : ℝ → 𝕂) {a : ℝ} (ha : 0 < a) : ++ ∫ (y : ℝ) in Ioi 0, f (a * y) / y = ∫ (y : ℝ) in Ioi 0, f y / y := by ++ convert integral_comp_mul_right_I0i_haar f ha using 5; ring ++ ++lemma MeasureTheory.integral_comp_rpow_I0i_haar_real (f : ℝ → ℝ) {p : ℝ} (hp : p ≠ 0) : ++ ∫ (y : ℝ) in Ioi 0, |p| * f (y ^ p) / y = ∫ (y : ℝ) in Ioi 0, f y / y := by ++ rw [← integral_comp_rpow_Ioi (fun y ↦ f y / y) hp, setIntegral_congr_fun (by simp)] ++ intro y hy ++ have ypos : 0 < y := mem_Ioi.mp hy ++ simp only [rpow_sub_one ypos.ne', smul_eq_mul] ++ field_simp ++ ++lemma MeasureTheory.integral_comp_inv_I0i_haar (f : ℝ → 𝕂) : ++ ∫ (y : ℝ) in Ioi 0, f (1 / y) / y = ∫ (y : ℝ) in Ioi 0, f y / y := by ++ have := integral_comp_rpow_Ioi (fun y ↦ f y / y) (p := -1) (by simp) ++ rw [← this, setIntegral_congr_fun (by simp)] ++ intro y hy ++ have : (y : 𝕂) ≠ 0 := (RCLike.ofReal_ne_zero).mpr <| LT.lt.ne' hy ++ simp only [abs_neg, abs_one, rpow_neg_one, map_inv₀, div_inv_eq_mul, ++ RCLike.real_smul_eq_coe_mul, RCLike.algebraMap_eq_ofReal] ++ ring_nf ++ simp [field] ++ ++lemma MeasureTheory.integral_comp_div_I0i_haar ++ (f : ℝ → 𝕂) {a : ℝ} (ha : 0 < a) : ++ ∫ (y : ℝ) in Ioi 0, f (a / y) / y = ∫ (y : ℝ) in Ioi 0, f y / y := by ++ calc ++ _ = ∫ (y : ℝ) in Ioi 0, f (a * y) / y := ?_ ++ _ = _ := integral_comp_mul_left_I0i_haar f ha ++ convert (integral_comp_inv_I0i_haar fun y ↦ f (a * (1 / y))).symm using 4 ++ · rw [mul_one_div] ++ · rw [one_div_one_div] ++ ++theorem Complex.ofReal_rpow {x : ℝ} (h : x > 0) (y : ℝ) : ++ (((x : ℝ) ^ (y : ℝ)) : ℝ) = (x : ℂ) ^ (y : ℂ) := by ++ rw [rpow_def_of_pos h, ofReal_exp, ofReal_mul, Complex.ofReal_log h.le, ++ Complex.cpow_def_of_ne_zero] ++ simp only [ne_eq, ofReal_eq_zero, ne_of_gt h, not_false_eq_true] ++ ++@[simp] ++lemma Function.support_abs {α : Type*} (f : α → 𝕂) : ++ (fun x ↦ ‖f x‖).support = f.support := by ++ simp only [support, ne_eq]; simp_rw [norm_ne_zero_iff] ++ ++@[simp] ++lemma Function.support_ofReal {f : ℝ → ℝ} : ++ (fun x ↦ ((f x) : ℂ)).support = f.support := by ++ apply Function.support_comp_eq (g := ofReal); simp ++ ++lemma Function.support_mul_subset_of_subset {s : Set ℝ} {f g : ℝ → 𝕂} ++ (fSupp : f.support ⊆ s) : (f * g).support ⊆ s := by ++ simp_rw [support_mul', inter_subset, subset_union_of_subset_right fSupp] ++ ++lemma Function.support_of_along_fiber_subset_subset {α β M : Type*} [Zero M] ++ {f : α × β → M} {s : Set α} {t : Set β} ++ (hx : ∀ (y : β), (fun x ↦ f (x, y)).support ⊆ s) ++ (hy : ∀ (x : α), (fun y ↦ f (x, y)).support ⊆ t) : ++ f.support ⊆ s ×ˢ t := by ++ intro ⟨x, y⟩ hxy ++ constructor ++ · exact hx y (by simp only [Function.mem_support, ne_eq] at hxy ⊢; exact hxy) ++ · exact hy x (by simp only [Function.mem_support, ne_eq] at hxy ⊢; exact hxy) ++ ++lemma Function.support_deriv_subset_Icc {a b : ℝ} {f : ℝ → 𝕂} ++ (fSupp : f.support ⊆ Set.Icc a b) : ++ (deriv f).support ⊆ Set.Icc a b := by ++ have := support_deriv_subset (f := fun x ↦ f x) ++ dsimp [tsupport] at this ++ have := subset_trans this <| closure_mono fSupp ++ rwa [closure_Icc] at this ++ ++lemma IntervalIntegral.integral_eq_integral_of_support_subset_Icc {a b : ℝ} {μ : Measure ℝ} ++ [NullSingletonClass μ] {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] ++ {f : ℝ → E} (h : f.support ⊆ Icc a b) : ++ ∫ x in a..b, f x ∂μ = ∫ x, f x ∂μ := by ++ rcases le_total a b with hab | hab ++ · rw [intervalIntegral.integral_of_le hab, ← integral_Icc_eq_integral_Ioc, ++ ← integral_indicator measurableSet_Icc, indicator_eq_self.2 h] ++ · by_cases hab2 : b = a ++ · rw [hab2] at h ⊢ ++ simp only [intervalIntegral.integral_same] ++ simp only [Icc_self] at h ++ have : ∫ (x : ℝ), f x ∂μ = ∫ (x : ℝ) in {a}, f x ∂μ := by ++ rw [ ← integral_indicator (by simp), indicator_eq_self.2 h] ++ rw [this, integral_singleton]; simp [Measure.real] ++ · rw [Icc_eq_empty_iff.mpr <| by exact fun x ↦ hab2 <| le_antisymm hab x, subset_empty_iff, ++ Function.support_eq_empty_iff] at h; simp [h] ++ ++lemma SetIntegral.integral_eq_integral_inter_of_support_subset {μ : Measure ℝ} ++ {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] ++ {s t : Set ℝ} {f : ℝ → E} (h : f.support ⊆ t) (ht : MeasurableSet t) : ++ ∫ x in s, f x ∂μ = ∫ x in s ∩ t, f x ∂μ := by ++ rw [← setIntegral_indicator ht, indicator_eq_self.2 h] ++ ++lemma SetIntegral.integral_eq_integral_inter_of_support_subset_Icc {a b} {μ : Measure ℝ} ++ {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] ++ {s : Set ℝ} {f : ℝ → E} (h : f.support ⊆ Icc a b) (hs : Icc a b ⊆ s) : ++ ∫ x in s, f x ∂μ = ∫ x in Icc a b, f x ∂μ := by ++ rw [SetIntegral.integral_eq_integral_inter_of_support_subset h measurableSet_Icc, ++ inter_eq_self_of_subset_right hs] ++ ++lemma intervalIntegral.norm_integral_le_of_norm_le_const' {a b C : ℝ} ++ {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] ++ {f : ℝ → E} (hab : a ≤ b) (h : ∀ x ∈ (Icc a b), ‖f x‖ ≤ C) : ++ ‖∫ x in a..b, f x‖ ≤ C * |b - a| := by ++ apply intervalIntegral.norm_integral_le_of_norm_le_const ++ exact fun x hx ↦ h x <| mem_Icc_of_Ioc <| uIoc_of_le hab ▸ hx ++ ++lemma Filter.TendstoAtZero_of_support_in_Icc {a b : ℝ} (f : ℝ → 𝕂) (ha : 0 < a) ++ (fSupp : f.support ⊆ Set.Icc a b) : ++ Tendsto f (𝓝[>]0) (𝓝 0) := by ++ apply Tendsto.comp (tendsto_nhds_of_eventually_eq ?_) tendsto_id ++ filter_upwards [Ioo_mem_nhdsGT ha] with c hc; replace hc := (mem_Ioo.mp hc).2 ++ have h : c ∉ Icc a b := fun h ↦ by linarith [mem_Icc.mp h] ++ convert mt (Function.support_subset_iff.mp fSupp c) h; simp ++ ++lemma Filter.TendstoAtTop_of_support_in_Icc {a b : ℝ} (f : ℝ → 𝕂) ++ (fSupp : f.support ⊆ Set.Icc a b) : ++ Tendsto f atTop (𝓝 0) := by ++ apply Tendsto.comp (tendsto_nhds_of_eventually_eq ?_) tendsto_id ++ filter_upwards [Ioi_mem_atTop b] with c hc; rw [mem_Ioi] at hc ++ have h : c ∉ Icc a b := fun h ↦ by linarith [mem_Icc.mp h] ++ convert mt (Function.support_subset_iff.mp fSupp c) h; simp ++ ++lemma Filter.BigO_zero_atZero_of_support_in_Icc {a b : ℝ} (f : ℝ → 𝕂) (ha : 0 < a) ++ (fSupp : f.support ⊆ Set.Icc a b) : ++ f =O[𝓝[>] 0] fun _ ↦ (0 : ℝ) := by ++ refine Eventually.isBigO ?_ ++ filter_upwards [Ioo_mem_nhdsGT (by linarith : (0 : ℝ) < a)] with c hc ++ refine norm_le_zero_iff.mpr <| Function.support_subset_iff'.mp fSupp c ?_ ++ exact fun h ↦ by linarith [mem_Icc.mp h, (mem_Ioo.mp hc).2] ++ ++lemma Filter.BigO_zero_atTop_of_support_in_Icc {a b : ℝ} (f : ℝ → 𝕂) ++ (fSupp : f.support ⊆ Set.Icc a b) : ++ f =O[atTop] fun _ ↦ (0 : ℝ) := by ++ refine Eventually.isBigO ?_ ++ filter_upwards [Ioi_mem_atTop b] with c hc; replace hc := mem_Ioi.mp hc ++ refine norm_le_zero_iff.mpr <| Function.support_subset_iff'.mp fSupp c ?_ ++ exact fun h ↦ by linarith [mem_Icc.mp h] ++ ++open Erdos970.Filter ++ ++lemma deriv.ofReal_comp' {f : ℝ → ℝ} : ++ deriv (fun x : ℝ ↦ (f x : ℂ)) = (fun x ↦ ((deriv f) x : ℂ)) := ++ funext fun _ ↦ deriv.ofReal_comp ++ ++lemma deriv.comp_ofReal' {e : ℂ → ℂ} (hf : Differentiable ℂ e) : ++ deriv (fun x : ℝ ↦ e x) = fun (x : ℝ) ↦ deriv e x := ++ funext fun _ ↦ deriv.comp_ofReal (hf.differentiableAt) ++ ++lemma PartialIntegration (f g : ℝ → ℂ) ++ (fDiff : DifferentiableOn ℝ f (Ioi 0)) ++ (gDiff : DifferentiableOn ℝ g (Ioi 0)) ++ (fDerivgInt : IntegrableOn (f * deriv g) (Ioi 0)) ++ (gDerivfInt : IntegrableOn (deriv f * g) (Ioi 0)) ++ (lim_at_zero : Tendsto (f * g) (𝓝[>] 0) (𝓝 0)) ++ (lim_at_inf : Tendsto (f * g) atTop (𝓝 0)) : ++ ∫ x in Ioi 0, f x * deriv g x = -∫ x in Ioi 0, deriv f x * g x := by ++ simpa using integral_Ioi_mul_deriv_eq_deriv_mul ++ (fun x hx ↦ fDiff.hasDerivAt (Ioi_mem_nhds hx)) ++ (fun x hx ↦ gDiff.hasDerivAt (Ioi_mem_nhds hx)) ++ fDerivgInt gDerivfInt lim_at_zero lim_at_inf ++ ++lemma PartialIntegration_of_support_in_Icc {a b : ℝ} (f g : ℝ → ℂ) (ha : 0 < a) ++ (h : a ≤ b) ++ (fSupp : f.support ⊆ Set.Icc a b) ++ (fDiff : DifferentiableOn ℝ f (Ioi 0)) ++ (gDiff : DifferentiableOn ℝ g (Ioi 0)) ++ (fderivCont : ContinuousOn (deriv f) (Ioi 0)) ++ (gderivCont : ContinuousOn (deriv g) (Ioi 0)) : ++ ∫ x in Ioi 0, f x * deriv g x = -∫ x in Ioi 0, deriv f x * g x := by ++ have Icc_sub : Icc a b ⊆ Ioi 0 := (Icc_subset_Ioi_iff h).mpr ha ++ have fderivSupp := Function.support_deriv_subset_Icc fSupp ++ have fgSupp : (f * g).support ⊆ Icc a b := Function.support_mul_subset_of_subset fSupp ++ have fDerivgInt : IntegrableOn (f * deriv g) (Ioi 0) := by ++ apply (integrableOn_iff_integrable_of_support_subset <| ++ Function.support_mul_subset_of_subset fSupp).mp ++ exact fDiff.continuousOn.mono Icc_sub |>.mul (gderivCont.mono Icc_sub) |>.integrableOn_Icc ++ have gDerivfInt : IntegrableOn (deriv f * g) (Ioi 0) := by ++ apply (integrableOn_iff_integrable_of_support_subset <| ++ Function.support_mul_subset_of_subset fderivSupp).mp ++ exact fderivCont.mono Icc_sub |>.mul (gDiff.continuousOn.mono Icc_sub) |>.integrableOn_Icc ++ have lim_at_zero : Tendsto (f * g) (𝓝[>]0) (𝓝 0) := ++ TendstoAtZero_of_support_in_Icc (f * g) ha fgSupp ++ have lim_at_inf : Tendsto (f * g) atTop (𝓝 0) := TendstoAtTop_of_support_in_Icc (f * g) fgSupp ++ apply PartialIntegration f g fDiff gDiff fDerivgInt gDerivfInt lim_at_zero lim_at_inf ++ ++local notation (name := mellintransform) "𝓜" => mellin ++ ++noncomputable def MellinConvolution (f g : ℝ → 𝕂) (x : ℝ) : 𝕂 := ++ ∫ y in Ioi 0, f y * g (x / y) / y ++ ++lemma MellinConvolutionSymmetric (f g : ℝ → 𝕂) {x : ℝ} (xpos : 0 < x) : ++ MellinConvolution f g x = MellinConvolution g f x := by ++ unfold MellinConvolution ++ calc ++ _ = ∫ y in Ioi 0, f (y * x) * g (1 / y) / y := ?_ ++ _ = _ := ?_ ++ · rw [← integral_comp_mul_right_I0i_haar (fun y ↦ f y * g (x / y)) xpos] ++ simp [div_mul_cancel_right₀ <| ne_of_gt xpos] ++ · convert (integral_comp_inv_I0i_haar fun y ↦ f (y * x) * g (1 / y)).symm using 3 ++ rw [one_div_one_div, mul_comm, mul_comm_div, one_mul] ++ ++open Pointwise in ++lemma support_MellinConvolution_subsets {f g : ℝ → 𝕂} {A B : Set ℝ} (hf : f.support ⊆ A) ++ (hg : g.support ⊆ B) : (MellinConvolution f g).support ⊆ A * B := by ++ rw [Function.support_subset_iff'] at hf hg ⊢ ++ intro x hx ++ unfold MellinConvolution ++ simp only [Set.mem_mul, not_exists, not_and] at hx ++ apply MeasureTheory.integral_eq_zero_of_ae ++ filter_upwards [ae_restrict_mem (by measurability)] ++ intro y hy ++ simp only [mem_Ioi] at hy ++ simp only [Pi.zero_apply, div_eq_zero_iff, mul_eq_zero, map_eq_zero] ++ left ++ by_cases hyA : y ∈ A ++ · right ++ apply hg ++ intro hxyB ++ apply hx _ hyA _ hxyB ++ field_simp ++ · left ++ apply hf _ hyA ++ ++open Pointwise in ++lemma support_MellinConvolution (f g : ℝ → 𝕂) : ++ (MellinConvolution f g).support ⊆ f.support * g.support := ++ support_MellinConvolution_subsets subset_rfl subset_rfl ++ ++ ++lemma MellinConvolutionTransform (f g : ℝ → ℂ) (s : ℂ) ++ (hf : IntegrableOn (fun x y ↦ f y * g (x / y) / (y : ℂ) * (x : ℂ) ^ (s - 1)).uncurry ++ (Ioi 0 ×ˢ Ioi 0)) : ++ 𝓜 (MellinConvolution f g) s = 𝓜 f s * 𝓜 g s := by ++ dsimp [mellin, MellinConvolution] ++ set f₁ : ℝ × ℝ → ℂ := ++ fun ⟨x, y⟩ ↦ f y * g (x / y) / (y : ℂ) * (x : ℂ) ^ (s - 1) ++ calc ++ _ = ∫ (x : ℝ) in Ioi 0, ∫ (y : ℝ) in Ioi 0, f₁ (x, y) := ?_ ++ _ = ∫ (y : ℝ) in Ioi 0, ∫ (x : ℝ) in Ioi 0, f₁ (x, y) := ++ setIntegral_integral_swap _ hf ++ _ = ∫ (y : ℝ) in Ioi 0, ∫ (x : ℝ) in Ioi 0, ++ f y * g (x / y) / ↑y * ↑x ^ (s - 1) := rfl ++ _ = ∫ (y : ℝ) in Ioi 0, ∫ (x : ℝ) in Ioi 0, ++ f y * g (x * y / y) / ↑y * ↑(x * y) ^ (s - 1) * y := ?_ ++ _ = ∫ (y : ℝ) in Ioi 0, ∫ (x : ℝ) in Ioi 0, ++ f y * ↑y ^ (s - 1) * (g x * ↑x ^ (s - 1)) := ?_ ++ _ = ∫ (y : ℝ) in Ioi 0, ++ f y * ↑y ^ (s - 1) * ∫ (x : ℝ) in Ioi 0, g x * ↑x ^ (s - 1) := ?_ ++ _ = _ := integral_mul_const _ _ ++ <;> try (rw [setIntegral_congr_fun (by simp)]; intro y hy; simp only [ofReal_mul]) ++ · simp only [integral_mul_const, f₁, mul_comm] ++ · simp only [integral_mul_const] ++ have := integral_comp_mul_right_Ioi ++ (fun x ↦ f y * g (x / y) / (y : ℂ) * (x : ℂ) ^ (s - 1)) 0 hy ++ have y_ne_zeroℂ : (y : ℂ) ≠ 0 := slitPlane_ne_zero (Or.inl hy) ++ field_simp at this ⊢ ++ simp only [ofReal_mul, one_div, mul_zero, real_smul, ofReal_inv, field] at this ⊢ ++ rw [← this] ++ field_simp ++ congr with x ++ ring_nf ++ · rw [setIntegral_congr_fun (by simp)] ++ intro x hx ++ have y_ne_zeroℝ : y ≠ 0 := ne_of_gt (mem_Ioi.mp hy) ++ have y_ne_zeroℂ : (y : ℂ) ≠ 0 := by exact_mod_cast y_ne_zeroℝ ++ field_simp ++ rw [mul_cpow_ofReal_nonneg hy.le hx.le] ++ ring ++ · apply integral_const_mul ++ · congr <;> ext <;> ring ++ ++lemma mem_within_strip (σ₁ σ₂ : ℝ) : ++ {s : ℂ | σ₁ ≤ s.re ∧ s.re ≤ σ₂} ∈ ++ 𝓟 {s | σ₁ ≤ s.re ∧ s.re ≤ σ₂} := ++ mem_principal_self _ ++ ++lemma MellinOfPsi_aux {ν : ℝ → ℝ} (diffν : ContDiff ℝ 1 ν) ++ (suppν : ν.support ⊆ Set.Icc (1 / 2) 2) ++ {s : ℂ} (hs : s ≠ 0) : ++ ∫ (x : ℝ) in Ioi 0, (ν x) * (x : ℂ) ^ (s - 1) = ++ - (1 / s) * ∫ (x : ℝ) in Ioi 0, (deriv ν x) * (x : ℂ) ^ s := by ++ let g (s : ℂ) := fun (x : ℝ) ↦ x ^ s / s ++ have gderiv {s : ℂ} (hs : s ≠ 0) {x: ℝ} (hx : x ∈ Ioi 0) : ++ deriv (g s) x = x ^ (s - 1) := by ++ have := HasDerivAt.cpow_const (c := s) (hasDerivAt_id (x : ℂ)) (Or.inl hx) ++ simp_rw [mul_one, id_eq] at this ++ rw [deriv_div_const, deriv.comp_ofReal (e := fun x ↦ x ^ s)] ++ · rw [this.deriv, mul_div_right_comm, div_self hs, one_mul] ++ · apply hasDerivAt_deriv_iff.mp ++ simp only [this.deriv, this] ++ calc ++ _ = ∫ (x : ℝ) in Ioi 0, ↑(ν x) * deriv (@g s) x := ?_ ++ _ = -∫ (x : ℝ) in Ioi 0, deriv (fun x ↦ ↑(ν x)) x * @g s x := ?_ ++ _ = -∫ (x : ℝ) in Ioi 0, deriv ν x * @g s x := ?_ ++ _ = -∫ (x : ℝ) in Ioi 0, deriv ν x * x ^ s / s := by simp only [mul_div, g] ++ _ = _ := ?_ ++ · rw [setIntegral_congr_fun (by simp)] ++ intro _ hx ++ simp only [gderiv hs hx] ++ · apply PartialIntegration_of_support_in_Icc (ν ·) (g s) ++ (a := 1 / 2) (b := 2) (by norm_num) (by norm_num) ++ · simpa only [Function.support_subset_iff, ne_eq, ofReal_eq_zero] ++ · exact (Differentiable.ofReal_comp_iff.mpr ++ (diffν.differentiable (by norm_num))).differentiableOn ++ · refine DifferentiableOn.div_const ?_ s ++ intro a ha ++ refine DifferentiableAt.comp_ofReal (e := fun x ↦ x ^ s) ?_ |>.differentiableWithinAt ++ apply differentiableAt_fun_id.cpow (differentiableAt_const s) <| by exact Or.inl ha ++ · simp only [deriv.ofReal_comp'] ++ exact continuous_ofReal.comp (diffν.continuous_deriv (by norm_num)) |>.continuousOn ++ · apply ContinuousOn.congr (f := fun (x : ℝ) ↦ (x : ℂ) ^ (s - 1)) ?_ ++ fun x hx ↦ gderiv hs hx ++ exact Continuous.continuousOn (by continuity) |>.cpow continuousOn_const (by simp) ++ · congr; funext; congr ++ apply (hasDerivAt_deriv_iff.mpr ?_).ofReal_comp.deriv ++ exact diffν.contDiffAt.differentiableAt (by norm_num) ++ · simp only [neg_mul, neg_inj] ++ conv => lhs; rhs; intro; rw [← mul_one_div, mul_comm] ++ rw [integral_const_mul] ++ ++lemma MellinOfPsi {ν : ℝ → ℝ} (diffν : ContDiff ℝ 1 ν) ++ (suppν : ν.support ⊆ Set.Icc (1 / 2) 2) : ++ ∃ C > 0, ∀ (σ₁ : ℝ) (_ : 0 < σ₁) (s : ℂ) (_ : σ₁ ≤ s.re) (_ : s.re ≤ 2), ++ ‖𝓜 (fun x ↦ (ν x : ℂ)) s‖ ≤ C * ‖s‖⁻¹ := by ++ let f := fun (x : ℝ) ↦ ‖deriv ν x‖ ++ have cont : ContinuousOn f (Icc (1 / 2) 2) := ++ (Continuous.comp (by continuity) <| diffν.continuous_deriv (by norm_num)).continuousOn ++ obtain ⟨a, _, max⟩ := isCompact_Icc.exists_isMaxOn (f := f) (by norm_num) cont ++ let σ₂ : ℝ := 2 ++ let C : ℝ := f a * 2 ^ σ₂ * (3 / 2) ++ have mainBnd : ∀ (σ₁ : ℝ), 0 < σ₁ → ∀ (s : ℂ), σ₁ ≤ s.re → s.re ≤ 2 → ++ ‖𝓜 (fun x ↦ (ν x : ℂ)) s‖ ≤ C * ‖s‖⁻¹ := by ++ intro σ₁ σ₁pos s hs₁ hs₂ ++ have s_ne_zero: s ≠ 0 := fun h ↦ by linarith [zero_re ▸ h ▸ hs₁] ++ simp only [mellin, f, MellinOfPsi_aux diffν suppν s_ne_zero, norm_mul, smul_eq_mul, mul_comm] ++ gcongr ++ · simp ++ calc ++ _ ≤ ∫ (x : ℝ) in Ioi 0, ‖(deriv ν x * (x : ℂ) ^ s)‖ := ?_ ++ _ = ∫ (x : ℝ) in Icc (1 / 2) 2, ‖(deriv ν x * (x : ℂ) ^ s)‖ := ?_ ++ _ ≤ ‖∫ (x : ℝ) in Icc (1 / 2) 2, ‖(deriv ν x * (x : ℂ) ^ s)‖‖ := ++ le_abs_self _ ++ _ ≤ _ := ?_ ++ · simp_rw [norm_integral_le_integral_norm] ++ · apply SetIntegral.integral_eq_integral_inter_of_support_subset_Icc ++ · simp only [Function.support_abs, Function.support_mul, Function.support_ofReal] ++ apply subset_trans (by apply inter_subset_left) <| Function.support_deriv_subset_Icc suppν ++ · exact (Icc_subset_Ioi_iff (by norm_num)).mpr (by norm_num) ++ · have := intervalIntegral.norm_integral_le_of_norm_le_const' (C := f a * 2 ^ σ₂) ++ (f := fun x ↦ f x * ‖(x : ℂ) ^ s‖) (a := (1 / 2 : ℝ)) ( b := 2) (by norm_num) ?_ ++ · simp only [Real.norm_eq_abs, norm_real, norm_mul] at this ⊢ ++ rwa [(by norm_num: |(2 : ℝ) - 1 / 2| = 3 / 2), ++ intervalIntegral.integral_of_le (by norm_num), ← integral_Icc_eq_integral_Ioc] at this ++ · intro x hx; ++ have f_bound := isMaxOn_iff.mp max x hx ++ have pow_bound : ‖(x : ℂ) ^ s‖ ≤ 2 ^ σ₂ := by ++ rw [norm_cpow_eq_rpow_re_of_pos (by linarith [mem_Icc.mp hx])] ++ have xpos : 0 ≤ x := by linarith [(mem_Icc.mp hx).1] ++ have h := rpow_le_rpow xpos (mem_Icc.mp hx).2 (by linarith : 0 ≤ s.re) ++ exact le_trans h <| rpow_le_rpow_of_exponent_le (by norm_num) hs₂ ++ convert! mul_le_mul f_bound pow_bound (norm_nonneg _) ?_ using 1 <;> simp [f] ++ have Cnonneg : 0 ≤ C := by ++ have hh := mainBnd 1 (by norm_num) ((3 : ℂ) / 2) (by norm_num) (by norm_num) ++ have hhh : 0 ≤ ‖𝓜 (fun x ↦ (ν x : ℂ)) ((3 : ℂ) / 2)‖ := by positivity ++ have hhhh : 0 < ‖(3 : ℂ) / 2‖⁻¹ := by norm_num ++ have := hhh.trans hh ++ exact (mul_nonneg_iff_of_pos_right hhhh).mp this ++ by_cases CeqZero : C = 0 ++ · refine ⟨1, by linarith, ?_⟩ ++ intro ε εpos s hs₁ hs₂ ++ have := mainBnd ε εpos s hs₁ hs₂ ++ rw [CeqZero, zero_mul] at this ++ have : 0 ≤ 1 * ‖s‖⁻¹ := by positivity ++ linarith ++ · exact ⟨C, lt_of_le_of_ne Cnonneg fun a ↦ CeqZero (id (Eq.symm a)), mainBnd⟩ ++ ++noncomputable def DeltaSpike (ν : ℝ → ℝ) (ε : ℝ) : ℝ → ℝ := ++ fun x ↦ ν (x ^ (1 / ε)) / ε ++ ++lemma DeltaSpikeMass {ν : ℝ → ℝ} (mass_one : ∫ x in Ioi 0, ν x / x = 1) {ε : ℝ} ++ (εpos : 0 < ε) : ∫ x in Ioi 0, ((DeltaSpike ν ε) x) / x = 1 := ++ calc ++ _ = ∫ (x : ℝ) in Ioi 0, (|1/ε| * x ^ (1 / ε - 1)) • ++ ((fun z ↦ (ν z) / z) (x ^ (1 / ε))) := by ++ apply setIntegral_congr_ae measurableSet_Ioi ++ filter_upwards with x hx ++ simp only [smul_eq_mul, abs_of_pos (one_div_pos.mpr εpos)] ++ symm; calc ++ _ = (ν (x ^ (1 / ε)) / x ^ (1 / ε)) * x ^ (1 / ε - 1) * (1 / ε) := by ring ++ _ = _ := by rw [rpow_sub hx, rpow_one] ++ _ = (ν (x ^ (1 / ε)) / x ^ (1 / ε) * x ^ (1 / ε) / x) * (1/ ε) := by ring ++ _ = _ := by rw [div_mul_cancel₀ _ (ne_of_gt (rpow_pos_of_pos hx (1/ε)))] ++ _ = (ν (x ^ (1 / ε)) / ε / x) := by ring ++ _ = 1 := by ++ rw [integral_comp_rpow_Ioi (fun z ↦ (ν z) / z), ← mass_one] ++ simp only [ne_eq, div_eq_zero_iff, one_ne_zero, εpos.ne', or_self, not_false_eq_true] ++ ++lemma DeltaSpikeSupport_aux {ν : ℝ → ℝ} {ε : ℝ} (εpos : 0 < ε) ++ (suppν : ν.support ⊆ Icc (1 / 2) 2) : ++ (fun x ↦ if x < 0 then 0 else DeltaSpike ν ε x).support ⊆ Icc (2 ^ (-ε)) (2 ^ ε) := by ++ unfold DeltaSpike ++ simp only [one_div, Function.support_subset_iff, ne_eq, ite_eq_left_iff, not_lt, div_eq_zero_iff, ++ not_forall, exists_prop, mem_Icc, and_imp] ++ intro x hx h; push Not at h ++ have := suppν <| Function.mem_support.mpr h.1 ++ simp only [one_div, mem_Icc] at this ++ have hl := (le_rpow_inv_iff_of_pos (by norm_num) hx εpos).mp this.1 ++ rw [inv_rpow (by norm_num) ε, ← rpow_neg (by norm_num)] at hl ++ refine ⟨hl, (rpow_inv_le_iff_of_pos ?_ (by norm_num) εpos).mp this.2⟩ ++ linarith [(by apply rpow_nonneg (by norm_num) : 0 ≤ (2 : ℝ) ^ (-ε))] ++ ++lemma DeltaSpikeSupport' {ν : ℝ → ℝ} {ε x : ℝ} (εpos : 0 < ε) (xnonneg : 0 ≤ x) ++ (suppν : ν.support ⊆ Icc (1 / 2) 2) : ++ DeltaSpike ν ε x ≠ 0 → x ∈ Icc (2 ^ (-ε)) (2 ^ ε) := by ++ intro h ++ have : (fun x ↦ if x < 0 then 0 else DeltaSpike ν ε x) x = DeltaSpike ν ε x := by ++ simp [xnonneg] ++ rw [← this] at h ++ exact (Function.support_subset_iff.mp <| DeltaSpikeSupport_aux εpos suppν) _ h ++ ++lemma DeltaSpikeSupport {ν : ℝ → ℝ} {ε x : ℝ} (εpos : 0 < ε) (xnonneg : 0 ≤ x) ++ (suppν : ν.support ⊆ Icc (1 / 2) 2) : ++ x ∉ Icc (2 ^ (-ε)) (2 ^ ε) → DeltaSpike ν ε x = 0 := by ++ contrapose!; exact DeltaSpikeSupport' εpos xnonneg suppν ++ ++@[fun_prop] ++lemma DeltaSpikeContinuous {ν : ℝ → ℝ} {ε : ℝ} (εpos : 0 < ε) ++ (diffν : ContDiff ℝ 1 ν) : Continuous (fun x ↦ DeltaSpike ν ε x) := by ++ apply diffν.continuous.comp (g := ν) _ |>.div_const ++ exact continuous_id.rpow_const fun _ ↦ Or.inr <| div_nonneg (by norm_num) εpos.le ++ ++lemma DeltaSpikeOfRealContinuous {ν : ℝ → ℝ} {ε : ℝ} (εpos : 0 < ε) ++ (diffν : ContDiff ℝ 1 ν) : Continuous (fun x ↦ (DeltaSpike ν ε x : ℂ)) := ++ continuous_ofReal.comp <| DeltaSpikeContinuous εpos diffν ++ ++ ++theorem MellinOfDeltaSpike (ν : ℝ → ℝ) {ε : ℝ} (εpos : ε > 0) (s : ℂ) : ++ 𝓜 (fun x ↦ (DeltaSpike ν ε x : ℂ)) s = 𝓜 (fun x ↦ (ν x : ℂ)) (ε * s) := by ++ unfold DeltaSpike ++ push_cast ++ rw [mellin_div_const, mellin_comp_rpow (fun x ↦ (ν x : ℂ)), abs_of_nonneg (by positivity)] ++ simp only [one_div, inv_inv, ofReal_inv, div_inv_eq_mul, real_smul] ++ rw [mul_div_cancel_left₀ _ (ne_zero_of_re_pos εpos)] ++ ring_nf ++ ++lemma MellinOfDeltaSpikeAt1 (ν : ℝ → ℝ) {ε : ℝ} (εpos : ε > 0) : ++ 𝓜 (fun x ↦ (DeltaSpike ν ε x : ℂ)) 1 = 𝓜 (fun x ↦ (ν x : ℂ)) ε := by ++ convert MellinOfDeltaSpike ν εpos 1; simp [mul_one] ++ ++lemma MellinOfDeltaSpikeAt1_asymp {ν : ℝ → ℝ} (diffν : ContDiff ℝ 1 ν) ++ (suppν : ν.support ⊆ Set.Icc (1 / 2) 2) ++ (mass_one : ∫ x in Set.Ioi 0, ν x / x = 1) : ++ (fun (ε : ℝ) ↦ (𝓜 (fun x ↦ (ν x : ℂ)) ε) - 1) =O[𝓝[>]0] id := by ++ have diff : DifferentiableWithinAt ℝ ++ (fun (ε : ℝ) ↦ 𝓜 (fun x ↦ (ν x : ℂ)) ε - 1) (Ioi 0) 0 := by ++ apply DifferentiableAt.differentiableWithinAt ++ simp only [(differentiableAt_const _).fun_sub_iff_left] ++ refine DifferentiableAt.comp_ofReal ?_ ++ refine mellin_differentiableAt_of_isBigO_rpow (a := 1) (b := -1) ?_ ?_ (by simp) ?_ (by simp) ++ · apply (Continuous.continuousOn ?_).locallyIntegrableOn (by simp) ++ have := diffν.continuous; continuity ++ · apply Asymptotics.IsBigO.trans_le (g' := fun _ ↦ (0 : ℝ)) ?_ (by simp) ++ apply BigO_zero_atTop_of_support_in_Icc (a := 1 / 2) (b := 2) ++ rwa [Erdos970.Function.support_ofReal (f := ν)] ++ · apply Asymptotics.IsBigO.trans_le (g' := fun _ ↦ (0 : ℝ)) ?_ (by simp) ++ apply BigO_zero_atZero_of_support_in_Icc (a := 1 / 2) (b := 2) (ha := (by norm_num)) ++ rwa [Erdos970.Function.support_ofReal (f := ν)] ++ have := ofReal_zero ▸ diff.isBigO_sub ++ simp only [sub_sub_sub_cancel_right, sub_zero] at this ++ convert! this using 1 ++ simp only [mellin, zero_sub, cpow_neg_one, smul_eq_mul] ++ funext ε ++ congr 1 ++ symm ++ calc (∫ (t : ℝ) in Ioi 0, (↑t)⁻¹ * ↑(ν t) : ℂ) ++ = ∫ (t : ℝ) in Ioi 0, ((ν t / t : ℝ) : ℂ) := ++ integral_congr_ae (Filter.Eventually.of_forall fun t => by push_cast; ring) ++ _ = ((∫ t in Ioi 0, ν t / t : ℝ) : ℂ) := integral_ofReal ++ _ = 1 := by rw [mass_one, ofReal_one] ++ ++lemma MellinOf1 (s : ℂ) (h : s.re > 0) : ++ 𝓜 ((fun x ↦ if 0 < x ∧ x ≤ 1 then 1 else 0)) s = 1 / s := by ++ convert (hasMellin_one_Ioc h).right ++ congr ++ ++noncomputable def Smooth1 (ν : ℝ → ℝ) (ε : ℝ) : ℝ → ℝ := ++ MellinConvolution (fun x ↦ if 0 < x ∧ x ≤ 1 then 1 else 0) (DeltaSpike ν ε) ++ ++lemma Smooth1_def_ite {ν : ℝ → ℝ} {ε x : ℝ} (xpos : 0 < x) : ++ Smooth1 ν ε x = MellinConvolution (fun x ↦ if 0 < x ∧ x ≤ 1 then 1 else 0) ++ (fun x ↦ if x < 0 then 0 else DeltaSpike ν ε x) x := by ++ unfold Smooth1 ++ rw [MellinConvolutionSymmetric _ _ xpos] ++ conv => lhs; rw [MellinConvolutionSymmetric _ _ xpos] ++ unfold MellinConvolution ++ apply MeasureTheory.integral_congr_ae ++ filter_upwards [MeasureTheory.ae_restrict_mem measurableSet_Ioi] ++ simp +contextual only [mem_Ioi, true_and, ite_mul, one_mul, zero_mul, RCLike.ofReal_real_eq_id, ++ id_eq, mul_ite, mul_zero] ++ intro y ypos ++ rw [eq_comm, ite_eq_right (by push Not; positivity)] ++ ++lemma Smooth1Properties_estimate {ε : ℝ} (εpos : 0 < ε) : ++ (1 - 2 ^ (-ε)) / ε < Real.log 2 := by ++ apply (div_lt_iff₀' εpos).mpr ++ have : 1 - 1 / (2 : ℝ) ^ ε = ((2 : ℝ) ^ ε - 1) / (2 : ℝ) ^ ε := by ++ rw [sub_div, div_self (by positivity)] ++ rw [← Real.log_rpow (by norm_num), rpow_neg (by norm_num), inv_eq_one_div (2 ^ ε), this] ++ set c := (2 : ℝ) ^ ε ++ have hc : 1 < c := by ++ rw [← rpow_zero (2 : ℝ)] ++ apply Real.rpow_lt_rpow_of_exponent_lt (by norm_num) εpos ++ apply (div_lt_iff₀' (by positivity)).mpr <| lt_sub_iff_add_lt'.mp ?_ ++ let f := (fun x ↦ x * Real.log x - x) ++ rw [(by simp [f] : -1 = f 1), (by simp [f] : c * Real.log c - c = f c)] ++ have mono: StrictMonoOn f <| Ici 1 := by ++ refine strictMonoOn_of_deriv_pos (convex_Ici _) ?_ ?_ ++ · apply continuousOn_id.mul (continuousOn_id.log ?_) |>.sub continuousOn_id ++ intro x hx; simp only [mem_Ici] at hx; simp only [id_eq, ne_eq]; linarith ++ · intro x hx; simp only [nonempty_Iio, interior_Ici', mem_Ioi] at hx ++ dsimp only [f] ++ rw [deriv_fun_sub, deriv_fun_mul, Real.deriv_log, deriv_id'', one_mul, mul_inv_cancel₀] ++ · simp [log_pos hx] ++ · linarith ++ · simp only [differentiableAt_fun_id] ++ · simp only [differentiableAt_log_iff, ne_eq]; linarith ++ · exact differentiableAt_fun_id.mul <| differentiableAt_fun_id.log (by linarith) ++ · simp only [differentiableAt_fun_id] ++ exact mono (by rw [mem_Ici]) (mem_Ici.mpr <| le_of_lt hc) hc ++ ++lemma Smooth1Properties_below_aux {x ε : ℝ} (hx : x ≤ 1 - Real.log 2 * ε) (εpos : 0 < ε) : ++ x < 2 ^ (-ε) := by ++ calc ++ x ≤ 1 - Real.log 2 * ε := hx ++ _ < 2 ^ (-ε) := ?_ ++ rw [sub_lt_iff_lt_add, add_comm, ← sub_lt_iff_lt_add] ++ exact (div_lt_iff₀ εpos).mp <| Smooth1Properties_estimate εpos ++ ++lemma Smooth1Properties_below {ν : ℝ → ℝ} (suppν : ν.support ⊆ Icc (1 / 2) 2) ++ (mass_one : ∫ x in Ioi 0, ν x / x = 1) : ++ ∃ (c : ℝ), 0 < c ∧ c = Real.log 2 ∧ ++ ∀ (ε x) (_ : 0 < ε), 0 < x → x ≤ 1 - c * ε → Smooth1 ν ε x = 1 := by ++ set c := Real.log 2; use c ++ refine ⟨log_pos (by norm_num), rfl, ?_⟩ ++ intro ε x εpos xpos hx ++ have hx2 := Smooth1Properties_below_aux hx εpos ++ rewrite [← DeltaSpikeMass mass_one εpos] ++ unfold Smooth1 MellinConvolution ++ calc ++ _ = ∫ (y : ℝ) in Ioi 0, ++ indicator (Ioc 0 1) (fun y ↦ DeltaSpike ν ε (x / y) / ↑y) y := ?_ ++ _ = ∫ (y : ℝ) in Ioi 0, DeltaSpike ν ε (x / y) / y := ?_ ++ _ = _ := integral_comp_div_I0i_haar (fun y ↦ DeltaSpike ν ε y) xpos ++ · rw [setIntegral_congr_fun (by simp)] ++ intro y hy ++ by_cases h : y ≤ 1 <;> simp [indicator, mem_Ioi.mp hy, h] ++ · rw [setIntegral_congr_fun (by simp)] ++ intro y hy ++ have : y ≠ 0 := by ++ rintro rfl ++ simp at hy ++ simp only [indicator_apply_eq_self, mem_Ioc, not_and, not_le, div_eq_zero_iff, this, or_false] ++ intro hy2; replace hy2 := hy2 <| mem_Ioi.mp hy ++ apply DeltaSpikeSupport εpos ?_ suppν ++ · simp only [mem_Icc, not_and, not_le]; intro ++ linarith [(by apply (div_lt_iff₀ (by linarith)).mpr; nlinarith : x / y < 2 ^ (-ε))] ++ · rw [le_div_iff₀ (by linarith), zero_mul]; exact xpos.le ++ ++lemma Smooth1Properties_above_aux {x ε : ℝ} (hx : 1 + (2 * Real.log 2) * ε ≤ x) ++ (hε : ε ∈ Ioo 0 1) : ++ 2 ^ ε < x := by ++ calc ++ x ≥ 1 + (2 * Real.log 2) * ε := hx ++ _ > 2 ^ ε := ?_ ++ refine lt_add_of_sub_left_lt <| (div_lt_iff₀ hε.1).mp ?_ ++ calc ++ 2 * Real.log 2 > 2 * (1 - 2 ^ (-ε)) / ε := ?_ ++ _ > 2 ^ ε * (1 - 2 ^ (-ε)) / ε := ?_ ++ _ = (2 ^ ε - 1) / ε := ?_ ++ · field_simp ++ exact Smooth1Properties_estimate hε.1 ++ · have : (2 : ℝ) ^ ε < 2 := by ++ have h := rpow_lt_rpow_of_exponent_lt (x := 2) (by norm_num) hε.2 ++ rwa [Real.rpow_one] at h ++ have pos: 0 < (1 - 2 ^ (-ε)) / ε := by ++ refine div_pos ?_ hε.1 ++ rw [sub_pos] ++ have h := rpow_lt_rpow_of_exponent_lt (x := 2) (by norm_num) (neg_lt_zero.mpr hε.1) ++ rwa [Real.rpow_zero] at h ++ have := (mul_lt_mul_iff_left₀ pos).mpr this ++ ring_nf at this ⊢ ++ exact this ++ · have : (2 : ℝ) ^ ε * (2 : ℝ) ^ (-ε) = (2 : ℝ) ^ (ε - ε) := by ++ rw [← rpow_add (by norm_num), add_neg_cancel, sub_self] ++ conv => lhs; lhs; ring_nf; rhs; simp [this] ++ ++lemma Smooth1Properties_above_aux2 {x y ε : ℝ} (hε : ε ∈ Ioo 0 1) (hy : y ∈ Ioc 0 1) ++ (hx2 : 2 ^ ε < x) : ++ 2 < (x / y) ^ (1 / ε) := by ++ obtain ⟨εpos, ε1⟩ := hε ++ obtain ⟨ypos, y1⟩ := hy ++ calc ++ _ > (2 ^ ε / y) ^ (1 / ε) := ?_ ++ _ = 2 / y ^ (1 / ε) := ?_ ++ _ ≥ 2 / y := ?_ ++ _ ≥ 2 := ?_ ++ · rw [gt_iff_lt, div_rpow, div_rpow, lt_div_iff₀, mul_comm_div, div_self, mul_one] ++ <;> try positivity ++ · exact rpow_lt_rpow (by positivity) hx2 (by positivity) ++ · exact LT.lt.le <| lt_trans (by positivity) hx2 ++ · rw [div_rpow, ← rpow_mul, mul_div_cancel₀ 1 <| ne_of_gt εpos, rpow_one] <;> positivity ++ · have : y ^ (1 / ε) ≤ y := by ++ nth_rewrite 2 [← rpow_one y] ++ exact rpow_le_rpow_of_exponent_ge ypos y1 (by linarith [one_lt_one_div εpos ε1]) ++ have pos : 0 < y ^ (1 / ε) := rpow_pos_of_pos ypos _ ++ rw [ge_iff_le, div_le_iff₀, div_mul_eq_mul_div, le_div_iff₀', mul_comm] <;> try linarith ++ · rw [ge_iff_le, le_div_iff₀ <| ypos]; exact (mul_le_iff_le_one_right zero_lt_two).mpr y1 ++ ++lemma Smooth1Properties_above {ν : ℝ → ℝ} (suppν : ν.support ⊆ Icc (1 / 2) 2) : ++ ∃ (c : ℝ), 0 < c ∧ c = 2 * Real.log 2 ∧ ++ ∀ (ε x) (_ : ε ∈ Ioo 0 1), 1 + c * ε ≤ x → Smooth1 ν ε x = 0 := by ++ set c := 2 * Real.log 2; use c ++ constructor ++ · simp only [c, zero_lt_two, mul_pos_iff_of_pos_left]; exact log_pos (by norm_num) ++ constructor ++ · rfl ++ intro ε x hε hx ++ have hx2 := Smooth1Properties_above_aux hx hε ++ unfold Smooth1 MellinConvolution ++ simp only [ite_mul, one_mul, zero_mul, RCLike.ofReal_real_eq_id, id_eq] ++ apply setIntegral_eq_zero_of_forall_eq_zero ++ intro y hy ++ have ypos := mem_Ioi.mp hy ++ by_cases y1 : y ≤ 1 ++ swap ++ · simp [ypos, y1] ++ simp only [mem_Ioi.mp hy, y1, and_self, ↓reduceIte, div_eq_zero_iff]; left ++ apply DeltaSpikeSupport hε.1 ?_ suppν ++ on_goal 1 => ++ simp only [mem_Icc, not_and, not_le] ++ on_goal 2 => ++ suffices h : 2 ^ ε < x / y by ++ linarith [(by apply rpow_pos_of_pos (by norm_num) : 0 < (2 : ℝ) ^ ε)] ++ all_goals ++ try intro ++ have : x / y = ((x / y) ^ (1 / ε)) ^ ε := by ++ rw [← rpow_mul] ++ simp only [one_div, inv_mul_cancel₀ (ne_of_gt hε.1), rpow_one] ++ apply div_nonneg_iff.mpr; left; ++ exact ⟨(le_trans (rpow_pos_of_pos (by norm_num) ε).le) hx2.le, ypos.le⟩ ++ rw [this] ++ refine rpow_lt_rpow (by norm_num) ?_ hε.1 ++ exact Smooth1Properties_above_aux2 hε ⟨ypos, y1⟩ hx2 ++ ++lemma DeltaSpikeNonNeg_of_NonNeg {ν : ℝ → ℝ} (νnonneg : ∀ x > 0, 0 ≤ ν x) ++ {x ε : ℝ} (xpos : 0 < x) (εpos : 0 < ε) : ++ 0 ≤ DeltaSpike ν ε x := by ++ dsimp [DeltaSpike] ++ have : 0 < x ^ (1 / ε) := by positivity ++ have : 0 ≤ ν (x ^ (1 / ε)) := νnonneg _ this ++ positivity ++ ++lemma MellinConvNonNeg_of_NonNeg {f g : ℝ → ℝ} (f_nonneg : ∀ x > 0, 0 ≤ f x) ++ (g_nonneg : ∀ x > 0, 0 ≤ g x) {x : ℝ} (xpos : 0 < x) : ++ 0 ≤ MellinConvolution f g x := by ++ dsimp [MellinConvolution] ++ apply MeasureTheory.setIntegral_nonneg ++ · exact measurableSet_Ioi ++ · intro y ypos; simp only [mem_Ioi] at ypos ++ have : 0 ≤ f y := f_nonneg _ ypos ++ have : 0 < x / y := by positivity ++ have : 0 ≤ g (x / y) := g_nonneg _ this ++ positivity ++ ++lemma Smooth1Nonneg {ν : ℝ → ℝ} (νnonneg : ∀ x > 0, 0 ≤ ν x) {ε x : ℝ} ++ (xpos : 0 < x) (εpos : 0 < ε) : 0 ≤ Smooth1 ν ε x := by ++ dsimp [Smooth1] ++ apply MellinConvNonNeg_of_NonNeg ?_ ?_ xpos ++ · intro y hy; by_cases h : y ≤ 1 <;> simp [h, hy] ++ · intro y ypos; exact DeltaSpikeNonNeg_of_NonNeg νnonneg ypos εpos ++ ++lemma Smooth1LeOne_aux {x ε : ℝ} {ν : ℝ → ℝ} (xpos : 0 < x) (εpos : 0 < ε) ++ (mass_one : ∫ x in Ioi 0, ν x / x = 1) : ++ ∫ (y : ℝ) in Ioi 0, ν ((x / y) ^ (1 / ε)) / ε / y = 1 := by ++ calc ++ _ = ∫ (y : ℝ) in Ioi 0, (ν (y ^ (1 / ε)) / ε) / y := ?_ ++ _ = ∫ (y : ℝ) in Ioi 0, ν y / y := ?_ ++ _ = 1 := mass_one ++ · have := integral_comp_div_I0i_haar (fun y ↦ ν ((x / y) ^ (1 / ε)) / ε) xpos ++ convert! this.symm using 1 ++ congr; funext y; congr; field_simp [mul_comm] ++ · have := integral_comp_rpow_I0i_haar_real (fun y ↦ ν y) (one_div_ne_zero εpos.ne') ++ rw [← this, abs_of_pos <| one_div_pos.mpr εpos] ++ field_simp ++ ++lemma Smooth1LeOne {ν : ℝ → ℝ} (νnonneg : ∀ x > 0, 0 ≤ ν x) ++ (mass_one : ∫ x in Ioi 0, ν x / x = 1) {ε : ℝ} (εpos : 0 < ε) {x : ℝ} (xpos : 0 < x) : ++ Smooth1 ν ε x ≤ 1 := by ++ unfold Smooth1 MellinConvolution DeltaSpike ++ have := Smooth1LeOne_aux xpos εpos mass_one ++ calc ++ _ = ∫ (y : ℝ) in Ioi 0, ++ (fun y ↦ if y ∈ Ioc 0 1 then 1 else 0) y * (ν ((x / y) ^ (1 / ε)) / ε / y) := ?_ ++ _ ≤ ∫ (y : ℝ) in Ioi 0, (ν ((x / y) ^ (1 / ε)) / ε) / y := ?_ ++ _ = 1 := this ++ · rw [setIntegral_congr_fun (by simp)] ++ simp only [ite_mul, one_mul, zero_mul, RCLike.ofReal_real_eq_id, id_eq, mem_Ioc] ++ intro y hy; aesop ++ · refine setIntegral_mono_on ?_ (integrable_of_integral_eq_one this) (by simp) ?_ ++ · refine integrable_of_integral_eq_one this |>.bdd_mul ?_ ++ (ae_of_all _ <| by aesop) ++ have : (fun x ↦ if 0 < x ∧ x ≤ 1 then 1 else 0) = ++ indicator (Ioc 0 1) (1 : ℝ → ℝ) := by ++ aesop ++ simp only [mem_Ioc, this, measurableSet_Ioc, aestronglyMeasurable_indicator_iff] ++ exact aestronglyMeasurable_one ++ · simp only [ite_mul, one_mul, zero_mul] ++ intro y hy ++ by_cases h : y ≤ 1 ++ · aesop ++ field_simp ++ simp only [mem_Ioc, h, and_false, ↓reduceIte, one_div, mul_zero] ++ simp only [mem_Ioi] at hy ++ apply div_nonneg ++ · apply νnonneg; exact rpow_pos_of_pos (div_pos xpos <| mem_Ioi.mp hy) _ ++ · positivity ++ ++lemma MellinOfSmooth1a {ν : ℝ → ℝ} (diffν : ContDiff ℝ 1 ν) ++ (suppν : ν.support ⊆ Icc (1 / 2) 2) ++ {ε : ℝ} (εpos : 0 < ε) {s : ℂ} (hs : 0 < s.re) : ++ 𝓜 (fun x ↦ (Smooth1 ν ε x : ℂ)) s = ++ s⁻¹ * 𝓜 (fun x ↦ (ν x : ℂ)) (ε * s) := by ++ let f' : ℝ → ℂ := fun x ↦ DeltaSpike ν ε x ++ let f : ℝ → ℂ := fun x ↦ DeltaSpike ν ε x / x ++ let g : ℝ → ℂ := fun x ↦ if 0 < x ∧ x ≤ 1 then 1 else 0 ++ let F : ℝ × ℝ → ℂ := Function.uncurry fun x y ↦ f y * g (x / y) * (x : ℂ) ^ (s - 1) ++ let S := {⟨x, y⟩ : ℝ × ℝ | 0 < x ∧ x ≤ y ∧ 2 ^ (-ε) ≤ y ∧ y ≤ 2 ^ ε} ++ let F' : ℝ × ℝ → ℂ := piecewise S (fun ⟨x, y⟩ ↦ f y * (x : ℂ) ^ (s - 1)) ++ (fun _ ↦ 0) ++ let Tx := Ioc 0 ((2 : ℝ) ^ ε) ++ let Ty := Icc ((2 : ℝ) ^ (-ε)) ((2 : ℝ) ^ ε) ++ ++ have Seq : S = (Tx ×ˢ Ty) ∩ {(x, y) : ℝ × ℝ | x ≤ y} := by ++ ext ⟨x, y⟩; constructor ++ · exact fun h ↦ ⟨⟨⟨h.1, le_trans h.2.1 h.2.2.2⟩, ⟨h.2.2.1, h.2.2.2⟩⟩, h.2.1⟩ ++ · exact fun h ↦ ⟨h.1.1.1, ⟨h.2, h.1.2.1, h.1.2.2⟩⟩ ++ have SsubI : S ⊆ Ioi 0 ×ˢ Ioi 0 := ++ fun z hz ↦ ⟨hz.1, lt_of_lt_of_le (by apply rpow_pos_of_pos; norm_num) hz.2.2.1⟩ ++ have SsubT: S ⊆ Tx ×ˢ Ty := by simp_rw [Seq, inter_subset_left] ++ have Smeas : MeasurableSet S := by ++ rw [Seq]; apply MeasurableSet.inter ?_ <| measurableSet_le measurable_fst measurable_snd ++ simp [measurableSet_prod, Tx, Ty] ++ ++ have int_F: IntegrableOn F (Ioi 0 ×ˢ Ioi 0) := by ++ apply IntegrableOn.congr_fun (f := F') ?_ ?_ (by simp [measurableSet_prod]); swap ++ · simp only [F, F', f, g, mul_ite, mul_one, mul_zero] ++ intro ⟨x, y⟩ hz ++ by_cases hS : ⟨x, y⟩ ∈ S <;> simp only [hS, piecewise] ++ <;> simp only [mem_prod, mem_Ioi, mem_ofPred_eq, not_and, not_le, S] at hz hS ++ · simp [div_pos hz.1 hz.2, (div_le_one hz.2).mpr hS.2.1] ++ · by_cases hxy : x / y ≤ 1 ++ swap ++ · simp [hxy] ++ have hy : y ∉ Icc (2 ^ (-ε)) (2 ^ ε) := by ++ simp only [mem_Icc, not_and, not_le]; exact hS hz.1 <| (div_le_one hz.2).mp hxy ++ simp [DeltaSpikeSupport εpos hz.2.le suppν hy] ++ · apply Integrable.piecewise Smeas ?_ integrableOn_zero ++ simp only [IntegrableOn, Measure.restrict_restrict_of_subset SsubI] ++ apply MeasureTheory.Integrable.mono_measure ?_ ++ · apply MeasureTheory.Measure.restrict_mono' SsubT.eventuallyLE le_rfl ++ change Integrable (fun x : ℝ × ℝ => f x.2 * (x.1 : ℂ) ^ (s - 1)) ++ (volume.restrict (Tx ×ˢ Ty)) ++ have : volume.restrict (Tx ×ˢ Ty) = (volume.restrict Tx).prod (volume.restrict Ty) := by ++ rw [Measure.prod_restrict, MeasureTheory.Measure.volume_eq_prod] ++ conv => rw [this]; lhs; intro; rw [mul_comm] ++ apply MeasureTheory.Integrable.mul_prod (f := fun x ↦ (x : ℂ) ^ (s - 1)) ++ (μ := Measure.restrict volume Tx) ++ · simp only [Tx] ++ rw [← IntegrableOn, integrableOn_Ioc_iff_integrableOn_Ioo, ++ intervalIntegral.integrableOn_Ioo_cpow_iff] ++ · simp [hs] ++ · apply rpow_pos_of_pos (by norm_num) ++ · apply (ContinuousOn.div ?_ ?_ ?_).integrableOn_compact isCompact_Icc ++ · exact (DeltaSpikeOfRealContinuous εpos diffν).continuousOn ++ · exact continuous_ofReal.continuousOn ++ · intro x hx; simp only [mem_Icc] at hx; simp only [ofReal_ne_zero] ++ linarith [(by apply rpow_pos_of_pos (by norm_num) : (0 : ℝ) < 2 ^ (-ε))] ++ ++ have : 𝓜 (MellinConvolution g f') s = 𝓜 g s * 𝓜 f' s := by ++ rw [mul_comm, ← MellinConvolutionTransform f' g s ++ (by convert int_F using 1; simp only [f', F, f]; field_simp)] ++ dsimp [mellin]; rw [setIntegral_congr_fun (by simp)] ++ intro x hx; simp_rw [MellinConvolutionSymmetric _ _ <| mem_Ioi.mp hx] ++ ++ convert! this using 1 ++ · congr; funext x; convert! integral_ofReal.symm ++ simp only [MellinConvolution, RCLike.ofReal_div, ite_mul, one_mul, zero_mul, @apply_ite ℝ ℂ, ++ algebraMap.coe_zero, g]; rfl ++ · rw [MellinOf1 s hs, MellinOfDeltaSpike ν εpos s] ++ simp ++ ++lemma MellinOfSmooth1b {ν : ℝ → ℝ} (diffν : ContDiff ℝ 1 ν) ++ (suppν : ν.support ⊆ Set.Icc (1 / 2) 2) : ++ ∃ (C : ℝ) (_ : 0 < C), ∀ (σ₁ : ℝ) (_ : 0 < σ₁) ++ (s) (_ : σ₁ ≤ s.re) (_ : s.re ≤ 2) (ε : ℝ) (_ : 0 < ε) (_ : ε < 1), ++ ‖𝓜 (fun x ↦ (Smooth1 ν ε x : ℂ)) s‖ ≤ C * (ε * ‖s‖ ^ 2)⁻¹ := by ++ obtain ⟨C, Cpos, hC⟩ := MellinOfPsi diffν suppν ++ refine ⟨C, Cpos, ?_⟩ ++ intro σ₁ σ₁pos s hs1 hs2 ε εpos ε_lt_one ++ rw [MellinOfSmooth1a diffν suppν εpos <| lt_of_le_of_lt' hs1 σ₁pos] ++ have hh1 : ε * σ₁ ≤ (ε * s).re := by ++ simp only [mul_re, ofReal_re, ofReal_im, zero_mul, sub_zero] ++ nlinarith ++ have hh2 : (ε * s).re ≤ 2 := by ++ simp only [mul_re, ofReal_re, ofReal_im, zero_mul, sub_zero] ++ nlinarith ++ calc ++ ‖s⁻¹ * 𝓜 (fun x ↦ (ν x : ℂ)) (ε * s)‖ = ++ ‖s⁻¹‖ * ‖𝓜 (fun x ↦ (ν x : ℂ)) (ε * s)‖ := by simp ++ _ ≤ ‖s⁻¹‖ * (C * (ε * ‖s‖)⁻¹) := by ++ gcongr ++ convert! hC (ε * σ₁) (by positivity) (ε * s) hh1 hh2 ++ simp [abs_eq_self.mpr εpos.le] ++ _ = C * (ε * ‖s‖ ^ 2)⁻¹ := by ++ simp only [norm_inv, mul_inv_rev] ++ ring ++ ++lemma MellinOfSmooth1c {ν : ℝ → ℝ} (diffν : ContDiff ℝ 1 ν) ++ (suppν : ν.support ⊆ Icc (1 / 2) 2) ++ (mass_one : ∫ x in Ioi 0, ν x / x = 1) : ++ (fun ε ↦ 𝓜 (fun x ↦ (Smooth1 ν ε x : ℂ)) 1 - 1) =O[𝓝[>]0] id := by ++ have h := MellinOfDeltaSpikeAt1_asymp diffν suppν mass_one ++ rw [Asymptotics.isBigO_iff] at h ⊢ ++ obtain ⟨c, hc⟩ := h ++ use c ++ filter_upwards [hc, Ioo_mem_nhdsGT (by linarith : (0 : ℝ) < 1)] with ε hε hε' ++ rw [MellinOfSmooth1a diffν suppν hε'.1 (s := 1) (by norm_num)] ++ simp only [inv_one, mul_one, one_mul, id_eq, Real.norm_eq_abs] ++ exact hε ++ ++lemma Smooth1ContinuousAt {SmoothingF : ℝ → ℝ} ++ (diffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ (SmoothingFpos : ∀ x > 0, 0 ≤ SmoothingF x) ++ (suppSmoothingF : SmoothingF.support ⊆ Icc (1 / 2) 2) ++ {ε : ℝ} (εpos : 0 < ε) {y : ℝ} (ypos : 0 < y) : ++ ContinuousAt (fun x ↦ Smooth1 SmoothingF ε x) y := by ++ apply ContinuousAt.congr ++ (f := (fun x ↦ MellinConvolution (DeltaSpike SmoothingF ε) ++ (fun x ↦ if 0 < x ∧ x ≤ 1 then 1 else 0) x)) _ ++ · filter_upwards [lt_mem_nhds ypos] with x hx ++ apply MellinConvolutionSymmetric _ _ hx ++ apply continuousAt_of_dominated (bound := (fun x ↦ 2 ^ ε * DeltaSpike SmoothingF ε x)) ++ · filter_upwards [lt_mem_nhds ypos] with x hx ++ apply Measurable.aestronglyMeasurable ++ apply Measurable.mul ++ · apply Measurable.mul ++ · exact Continuous.measurable <| DeltaSpikeContinuous εpos diffSmoothingF ++ · apply Measurable.ite _ (by fun_prop) (by fun_prop) ++ apply MeasurableSet.congr (s := Ici x) (by measurability) ++ ext a ++ constructor ++ · intro ha ++ have apos : 0 < a := lt_of_lt_of_le hx ha ++ constructor ++ · exact div_pos hx apos ++ · exact (div_le_one apos).mpr ha ++ · intro ha ++ have : 0 < a := (div_pos_iff_of_pos_left hx).mp ha.1 ++ exact (div_le_one this).mp ha.2 ++ · fun_prop ++ · filter_upwards [lt_mem_nhds ypos] with x hx ++ filter_upwards [ae_restrict_mem (by measurability)] with t ht ++ simp only [mul_ite, mul_one, mul_zero, RCLike.ofReal_real_eq_id, id_eq, norm_div, norm_eq_abs] ++ by_cases! h : DeltaSpike SmoothingF ε t = 0 ++ · simp [h] ++ have := DeltaSpikeSupport' εpos ht.le suppSmoothingF h ++ have dsnonneg : 0 ≤ DeltaSpike SmoothingF ε t := by ++ apply DeltaSpikeNonNeg_of_NonNeg <;> assumption ++ calc ++ _ ≤ |DeltaSpike SmoothingF ε t| / |t| := by ++ gcongr ++ · split_ifs with h ++ · apply le_refl ++ · exact dsnonneg ++ _ ≤ _ := by ++ rw [_root_.abs_of_nonneg dsnonneg, mul_comm, div_eq_mul_one_div, _root_.abs_of_pos ht] ++ gcongr ++ apply (one_div_le ht (by bound)).mpr ++ · convert this.1 using 1 ++ rw [div_eq_iff (by positivity), ← rpow_add (by norm_num), neg_add_cancel, rpow_zero] ++ · apply Integrable.const_mul ++ apply (integrable_indicator_iff (by measurability)).mp ++ apply (integrableOn_iff_integrable_of_support_subset (s := Icc (2 ^ (-ε)) (2 ^ ε)) _).mp ++ · apply ContinuousOn.integrableOn_compact isCompact_Icc ++ apply ContinuousOn.congr (f := DeltaSpike SmoothingF ε) ++ · apply Continuous.continuousOn ++ apply DeltaSpikeContinuous<;> assumption ++ · intro x hx ++ have : x ∈ Ioi 0 := by ++ apply mem_Ioi.mpr ++ apply lt_of_lt_of_le (by bound) hx.1 ++ rw [indicator, ite_eq_left this] ++ · unfold indicator ++ simp_rw [mem_Ioi] ++ apply Function.support_subset_iff.mpr ++ simp only [ne_eq, ite_eq_right_iff, Classical.not_imp, mem_Icc, and_imp] ++ intro x hx ++ apply DeltaSpikeSupport' εpos hx.le suppSmoothingF ++ · have : ∀ᵐ (a : ℝ) ∂volume.restrict (Ioi 0), a ≠ y := by ++ apply ae_iff.mpr ++ simp ++ filter_upwards [ae_restrict_mem (by measurability), this] with x hx hx2 ++ simp only [mem_Ioi] at hx ++ apply ContinuousAt.div_const ++ apply ContinuousAt.mul (by fun_prop) ++ have : (fun x_1 ↦ if 0 < x_1 / x ∧ x_1 / x ≤ 1 then 1 else 0) = ++ (Ioc 0 x).indicator (fun _ ↦ (1 : ℝ)) := by ++ ext t ++ unfold indicator ++ simp [div_pos_iff_of_pos_right, div_le_one₀, hx] ++ rw [this] ++ apply ContinuousOn.continuousAt_indicator (by fun_prop) ++ simp [frontier_Ioc hx, ypos.ne', hx2.symm] ++ ++lemma Smooth1MellinConvergent {Ψ : ℝ → ℝ} {ε : ℝ} (diffΨ : ContDiff ℝ 1 Ψ) ++ (suppΨ : Ψ.support ⊆ Icc (1 / 2) 2) (hε : ε ∈ Ioo 0 1) ++ (Ψnonneg : ∀ x > 0, 0 ≤ Ψ x) (mass_one : ∫ x in Ioi 0, Ψ x / x = 1) ++ {s : ℂ} (hs : 0 < s.re) : MellinConvergent (fun x ↦ (Smooth1 Ψ ε x : ℂ)) s := by ++ apply mellinConvergent_of_isBigO_rpow_exp zero_lt_one _ _ _ hs ++ · apply ContinuousOn.locallyIntegrableOn _ (by measurability) ++ apply continuousOn_of_forall_continuousAt ++ exact fun x hx ↦ Smooth1ContinuousAt diffΨ Ψnonneg suppΨ hε.1 hx |>.ofReal ++ · rw [Asymptotics.isBigO_iff] ++ use 1 ++ obtain ⟨c, cpos, ceq, hc⟩ := Smooth1Properties_above suppΨ ++ filter_upwards [eventually_ge_atTop (1 + c * ε)] with x hx ++ rw [hc _ _ hε hx] ++ simp only [ofReal_zero, norm_zero, neg_mul, one_mul, norm_eq_abs, abs_exp] ++ bound ++ · rw [Asymptotics.isBigO_iff] ++ use 1 ++ filter_upwards [eventually_mem_nhdsWithin] with x hx ++ simp only [norm_real, norm_eq_abs, neg_zero, rpow_zero, one_mem, CStarRing.norm_of_mem_unitary, ++ mul_one] ++ rw [_root_.abs_of_nonneg <| Smooth1Nonneg Ψnonneg hx hε.1] ++ exact Smooth1LeOne Ψnonneg mass_one hε.1 hx ++ ++lemma Smooth1MellinDifferentiable {Ψ : ℝ → ℝ} {ε : ℝ} (diffΨ : ContDiff ℝ 1 Ψ) ++ (suppΨ : Ψ.support ⊆ Icc (1 / 2) 2) (hε : ε ∈ Ioo 0 1) ++ (Ψnonneg : ∀ x > 0, 0 ≤ Ψ x) (mass_one : ∫ x in Ioi 0, Ψ x / x = 1) ++ {s : ℂ} (hs : 0 < s.re) : ++ DifferentiableAt ℂ (𝓜 (fun x ↦ (Smooth1 Ψ ε x : ℂ))) s := by ++ apply mellin_differentiableAt_of_isBigO_rpow_exp zero_lt_one _ _ _ hs ++ · apply ContinuousOn.locallyIntegrableOn _ (by measurability) ++ apply continuousOn_of_forall_continuousAt ++ exact fun x hx ↦ Smooth1ContinuousAt diffΨ Ψnonneg suppΨ hε.1 hx |>.ofReal ++ · rw [Asymptotics.isBigO_iff] ++ use 1 ++ obtain ⟨c, cpos, ceq, hc⟩ := Smooth1Properties_above suppΨ ++ filter_upwards [eventually_ge_atTop (1 + c * ε)] with x hx ++ rw [hc _ _ hε hx] ++ simp only [ofReal_zero, norm_zero, neg_mul, one_mul, norm_eq_abs, abs_exp] ++ bound ++ · rw [Asymptotics.isBigO_iff] ++ use 1 ++ filter_upwards [eventually_mem_nhdsWithin] with x hx ++ simp only [norm_real, norm_eq_abs, neg_zero, rpow_zero, one_mem, CStarRing.norm_of_mem_unitary, ++ mul_one] ++ rw [_root_.abs_of_nonneg <| Smooth1Nonneg Ψnonneg hx hε.1] ++ exact Smooth1LeOne Ψnonneg mass_one hε.1 hx ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/MertensClassical.lean b/PrimeNumberTheoremAnd/Erdos970/MertensClassical.lean +new file mode 100644 +index 0000000..8f3e823 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/MertensClassical.lean +@@ -0,0 +1,1982 @@ ++import Mathlib.Algebra.Order.Field.GeomSum ++import Mathlib.Analysis.SumIntegralComparisons ++import Mathlib.NumberTheory.Chebyshev ++import Mathlib.NumberTheory.Harmonic.EulerMascheroni ++import Mathlib.NumberTheory.LSeries.PrimesInAP ++import Mathlib.NumberTheory.LSeries.RiemannZeta ++import Mathlib.NumberTheory.Harmonic.GammaDeriv ++import Mathlib.Analysis.Asymptotics.Lemmas ++import Mathlib.Analysis.SpecialFunctions.Complex.Analytic ++import Mathlib.Analysis.SpecialFunctions.Integrability.LogMeromorphic ++import Mathlib.NumberTheory.EulerProduct.DirichletLSeries ++import Mathlib.NumberTheory.EulerProduct.ExpLog ++import Mathlib.Analysis.SpecialFunctions.Complex.LogBounds ++import Mathlib.Analysis.SpecialFunctions.Log.Summable ++import Mathlib.Algebra.Group.Submonoid.BigOperators ++import PrimeNumberTheoremAnd.Erdos970.EulerMaclaurin ++ ++namespace Erdos970 ++ ++theorem Filter.EventuallyEq.iff_eventually {α : Type _} {β : Type _} {l : Filter α} {f g : α → β} : f =ᶠ[l] g ↔ ∀ᶠ (x : α) in l, f x = g x := by rfl ++ ++namespace Real ++ ++open _root_.Real _root_.Filter _root_.Asymptotics ++ ++theorem inv_log_eq_o_one : (fun x ↦ 1 / log x) =o[atTop] (fun _ ↦ (1:ℝ)) := by ++ rw [isLittleO_one_iff] ++ convert tendsto_log_atTop.inv_tendsto_atTop using 1 ++ ext; simp ++ ++theorem one_eq_o_log_log : (fun _ ↦ (1:ℝ)) =o[atTop] (fun x ↦ log (log x)) := by ++ simp only [isLittleO_one_left_iff, norm_eq_abs] ++ exact tendsto_abs_atTop_atTop.comp (tendsto_log_atTop.comp tendsto_log_atTop) ++ ++end Real ++ ++section Issue1584 ++open _root_.MeasureTheory _root_.Set _root_.Filter _root_.Topology ++ ++private lemma integrableOn_log_mul_exp_neg : ++ IntegrableOn (fun v : ℝ => Real.log v * Real.exp (-v)) (Ioi 0) := by ++ rw [← Set.Ioc_union_Ioi_eq_Ioi (zero_le_one' ℝ), integrableOn_union] ++ constructor ++ · ++ have hlog : IntegrableOn (fun v : ℝ => Real.log v) (Ioc 0 1) volume := by ++ have := (intervalIntegral.intervalIntegrable_log' (a := 0) (b := 1)) ++ rwa [intervalIntegrable_iff_integrableOn_Ioc_of_le (zero_le_one' ℝ)] at this ++ apply Integrable.mono' hlog.norm ++ · apply (Measurable.aestronglyMeasurable ?_) ++ exact (Real.measurable_log.mul (Real.measurable_exp.comp measurable_neg)) ++ · filter_upwards [self_mem_ae_restrict measurableSet_Ioc] with v hv ++ rw [norm_mul, Real.norm_eq_abs, Real.norm_eq_abs] ++ have h1 : |Real.exp (-v)| = Real.exp (-v) := abs_of_pos (Real.exp_pos _) ++ have h2 : Real.exp (-v) ≤ 1 := Real.exp_le_one_iff.mpr (by linarith [hv.1]) ++ rw [h1] ++ nlinarith [abs_nonneg (Real.log v), Real.exp_pos (-v)] ++ · ++ have hexp : IntegrableOn (fun v : ℝ => (2 : ℝ) * Real.exp ((-1/2) * v)) (Ioi 1) volume := by ++ exact (integrableOn_exp_mul_Ioi (by norm_num : (-1/2 : ℝ) < 0) 1).const_mul 2 ++ apply Integrable.mono' hexp ++ · apply (Measurable.aestronglyMeasurable ?_) ++ exact (Real.measurable_log.mul (Real.measurable_exp.comp measurable_neg)) ++ · filter_upwards [self_mem_ae_restrict measurableSet_Ioi] with v hv ++ have hv1 : (1 : ℝ) ≤ v := le_of_lt hv ++ have hvpos : (0 : ℝ) < v := by linarith ++ rw [norm_mul, Real.norm_eq_abs, Real.norm_eq_abs] ++ have hlogabs : |Real.log v| = Real.log v := ++ abs_of_nonneg (Real.log_nonneg hv1) ++ have hexpabs : |Real.exp (-v)| = Real.exp (-v) := abs_of_pos (Real.exp_pos _) ++ rw [hlogabs, hexpabs] ++ ++ have hlogv : Real.log v ≤ v := (Real.log_le_sub_one_of_pos hvpos).trans (by linarith) ++ ++ have hvexp : v ≤ 2 * Real.exp (v/2) := by ++ have := Real.add_one_le_exp (v/2) ++ nlinarith [Real.exp_pos (v/2)] ++ ++ have hstep : Real.log v * Real.exp (-v) ≤ 2 * Real.exp (v/2) * Real.exp (-v) := by ++ apply mul_le_mul_of_nonneg_right (hlogv.trans hvexp) (le_of_lt (Real.exp_pos _)) ++ have heq : 2 * Real.exp (v/2) * Real.exp (-v) = 2 * Real.exp ((-1/2) * v) := by ++ rw [mul_assoc, ← Real.exp_add] ++ ring_nf ++ rw [heq] at hstep ++ exact hstep ++ ++private lemma integral_log_mul_exp_neg_eq_deriv_Gamma : ++ ∫ t in Ioi (0:ℝ), Real.log t * Real.exp (-t) = deriv Real.Gamma 1 := by ++ set I : ℝ := ∫ t in Ioi (0:ℝ), Real.log t * Real.exp (-t) with hI ++ ++ have h1 := Complex.hasDerivAt_GammaIntegral (s := (1 : ℂ)) (by norm_num) ++ ++ have hval : (∫ t : ℝ in Ioi 0, (↑t : ℂ) ^ ((1 : ℂ) - 1) * (↑(Real.log t) * ↑(Real.exp (-t)))) ++ = (I : ℂ) := by ++ have key : ∀ t : ℝ, (↑t : ℂ) ^ ((1 : ℂ) - 1) * (↑(Real.log t) * ↑(Real.exp (-t))) ++ = ((Real.log t * Real.exp (-t) : ℝ) : ℂ) := by ++ intro t ++ rw [sub_self, Complex.cpow_zero, one_mul, Complex.ofReal_mul] ++ simp_rw [key] ++ rw [integral_complex_ofReal, hI] ++ rw [hval] at h1 ++ ++ have h2 : HasDerivAt Complex.Gamma (I : ℂ) 1 := by ++ apply h1.congr_of_eventuallyEq ++ filter_upwards [(isOpen_lt continuous_const Complex.continuous_re).mem_nhds ++ (show (0:ℝ) < (1:ℂ).re by norm_num)] with z hz ++ exact Complex.Gamma_eq_integral hz ++ ++ have h3 := h2.real_of_complex ++ have h4 : HasDerivAt Real.Gamma I 1 := by ++ have hcongr : (fun x : ℝ => (Complex.Gamma ↑x).re) = Real.Gamma := by ++ funext x ++ rw [Complex.Gamma_ofReal, Complex.ofReal_re] ++ rw [hcongr, Complex.ofReal_re] at h3 ++ exact h3 ++ rw [← h4.deriv] ++ ++private theorem mul_integ_log_log_eq_aux (s : ℝ) (hs : 1 < s) : ++ (s - 1) * ∫ x in Ioi (1:ℝ), Real.log (Real.log x) * x ^ (-s) = ++ - Real.log (s - 1) + deriv Real.Gamma 1 := by ++ have hs0 : 0 < s - 1 := by linarith ++ set f : ℝ → ℝ := fun x => (s - 1) * Real.log x with hf_def ++ set f' : ℝ → ℝ := fun x => (s - 1) / x with hf'_def ++ set g : ℝ → ℝ := fun u => (Real.log u - Real.log (s - 1)) * Real.exp (-u) with hg_def ++ ++ have hf1 : f 1 = 0 := by simp [hf_def] ++ ++ have hf_cont : ContinuousOn f (Ici 1) := by ++ apply ContinuousOn.mul continuousOn_const ++ apply Real.continuousOn_log.mono ++ intro x hx ++ simp only [mem_Ici] at hx ++ simp only [Set.mem_compl_iff, Set.mem_singleton_iff] ++ linarith ++ ++ have hft : Tendsto f atTop atTop := by ++ apply Filter.Tendsto.const_mul_atTop hs0 ++ exact Real.tendsto_log_atTop ++ ++ have hff' : ∀ x ∈ Ioi (1:ℝ), HasDerivWithinAt f (f' x) (Ioi x) x := by ++ intro x hx ++ simp only [mem_Ioi] at hx ++ have hxne : x ≠ 0 := by linarith ++ have := (Real.hasDerivAt_log hxne).const_mul (s - 1) ++ have h2 : HasDerivAt f ((s - 1) * x⁻¹) x := this ++ have : (s - 1) * x⁻¹ = f' x := by rw [hf'_def]; field_simp ++ rw [this] at h2 ++ exact h2.hasDerivWithinAt ++ ++ have hmono : StrictMonoOn f (Ici 1) := by ++ intro a ha b hb hab ++ simp only [mem_Ici] at ha hb ++ apply mul_lt_mul_of_pos_left _ hs0 ++ exact Real.log_lt_log (by linarith) hab ++ have himg_Ioi : f '' Ioi 1 = Ioi 0 := by ++ ext y ++ simp only [Set.mem_image, mem_Ioi] ++ constructor ++ · rintro ⟨x, hx, rfl⟩ ++ have : 0 < Real.log x := Real.log_pos hx ++ positivity ++ · intro hy ++ refine ⟨Real.exp (y / (s - 1)), ?_, ?_⟩ ++ · exact Real.one_lt_exp_iff.mpr (div_pos hy hs0) ++ · rw [hf_def] ++ simp only [Real.log_exp] ++ field_simp ++ have himg_Ici : f '' Ici 1 = Ici 0 := by ++ ext y ++ simp only [Set.mem_image, mem_Ici] ++ constructor ++ · rintro ⟨x, hx, rfl⟩ ++ have : 0 ≤ Real.log x := Real.log_nonneg hx ++ rw [hf_def]; positivity ++ · intro hy ++ refine ⟨Real.exp (y / (s - 1)), ?_, ?_⟩ ++ · exact Real.one_le_exp_iff.mpr (div_nonneg hy hs0.le) ++ · rw [hf_def] ++ simp only [Real.log_exp] ++ field_simp ++ ++ have hg_cont : ContinuousOn g (f '' Ioi 1) := by ++ rw [himg_Ioi] ++ apply ContinuousOn.mul ++ · apply ContinuousOn.sub _ continuousOn_const ++ apply Real.continuousOn_log.mono ++ intro u hu ++ simp only [mem_Ioi] at hu ++ simp only [Set.mem_compl_iff, Set.mem_singleton_iff] ++ linarith ++ · exact (Real.continuous_exp.comp continuous_neg).continuousOn ++ ++ have hg1 : IntegrableOn g (f '' Ici 1) := by ++ rw [himg_Ici, integrableOn_Ici_iff_integrableOn_Ioi] ++ have e1 : IntegrableOn (fun u => Real.log u * Real.exp (-u)) (Ioi 0) := ++ integrableOn_log_mul_exp_neg ++ have e2 : IntegrableOn (fun u => Real.log (s - 1) * Real.exp (-u)) (Ioi 0) := ++ (integrableOn_exp_neg_Ioi 0).const_mul _ ++ have : g = fun u => Real.log u * Real.exp (-u) - Real.log (s - 1) * Real.exp (-u) := by ++ funext u; rw [hg_def]; ring ++ rw [this] ++ exact e1.sub e2 ++ ++ have hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) (Ici 1) := by ++ ++ have hff'_Ici : ∀ x ∈ Ici (1:ℝ), HasDerivWithinAt f (f' x) (Ici 1) x := by ++ intro x hx ++ simp only [mem_Ici] at hx ++ have hxne : x ≠ 0 := by linarith ++ have hd : HasDerivAt f ((s - 1) * x⁻¹) x := (Real.hasDerivAt_log hxne).const_mul (s - 1) ++ have heq : (s - 1) * x⁻¹ = f' x := by rw [hf'_def]; field_simp ++ rw [heq] at hd ++ exact hd.hasDerivWithinAt ++ ++ have hinj : InjOn f (Ici 1) := hmono.injOn ++ ++ have hiff := integrableOn_image_iff_integrableOn_abs_deriv_smul ++ (s := Ici (1:ℝ)) (f := f) (f' := f') measurableSet_Ici hff'_Ici hinj g ++ rw [hiff] at hg1 ++ ++ apply hg1.congr ++ filter_upwards [self_mem_ae_restrict measurableSet_Ici] with x hx ++ simp only [mem_Ici] at hx ++ have hxpos : (0:ℝ) < x := by linarith ++ have hf'pos : 0 < f' x := by rw [hf'_def]; positivity ++ simp only [smul_eq_mul, Function.comp, abs_of_pos hf'pos] ++ ring ++ ++ have hcov := integral_comp_mul_deriv_Ioi hf_cont hft hff' hg_cont hg1 hg2 ++ rw [hf1] at hcov ++ ++ have hrhs : ∫ u in Ioi (0:ℝ), g u = deriv Real.Gamma 1 - Real.log (s - 1) := by ++ have e1 : IntegrableOn (fun u => Real.log u * Real.exp (-u)) (Ioi 0) := ++ integrableOn_log_mul_exp_neg ++ have e2 : IntegrableOn (fun u => Real.log (s - 1) * Real.exp (-u)) (Ioi 0) := ++ (integrableOn_exp_neg_Ioi 0).const_mul _ ++ have hsplit : (fun u => g u) ++ = fun u => Real.log u * Real.exp (-u) - Real.log (s - 1) * Real.exp (-u) := by ++ funext u; rw [hg_def]; ring ++ rw [show (∫ u in Ioi (0:ℝ), g u) ++ = ∫ u in Ioi (0:ℝ), (Real.log u * Real.exp (-u) - Real.log (s - 1) * Real.exp (-u)) ++ from by rw [hsplit]] ++ rw [integral_sub e1 e2, integral_log_mul_exp_neg_eq_deriv_Gamma] ++ rw [integral_const_mul, integral_exp_neg_Ioi_zero, mul_one] ++ ++ have hlhs : ∫ x in Ioi (1:ℝ), (g ∘ f) x * f' x ++ = (s - 1) * ∫ x in Ioi (1:ℝ), Real.log (Real.log x) * x ^ (-s) := by ++ have hpt : ∀ x ∈ Ioi (1:ℝ), (g ∘ f) x * f' x ++ = (s - 1) * (Real.log (Real.log x) * x ^ (-s)) := by ++ intro x hx ++ simp only [mem_Ioi] at hx ++ have hxpos : (0:ℝ) < x := by linarith ++ have hlogpos : 0 < Real.log x := Real.log_pos hx ++ have hlogne : Real.log x ≠ 0 := ne_of_gt hlogpos ++ have hs1ne : s - 1 ≠ 0 := ne_of_gt hs0 ++ simp only [Function.comp, hf_def, hg_def, hf'_def] ++ ++ rw [Real.log_mul hs1ne hlogne] ++ ++ have hexp : Real.exp (-((s - 1) * Real.log x)) = x ^ (-(s - 1)) := by ++ rw [Real.rpow_def_of_pos hxpos] ++ ring_nf ++ rw [hexp] ++ ++ have hx1 : x ^ (-(s - 1)) * ((s - 1) / x) = (s - 1) * x ^ (-s) := by ++ rw [div_eq_mul_inv, ← Real.rpow_neg_one x] ++ rw [show x ^ (-(s - 1)) * ((s - 1) * x ^ (-1 : ℝ)) ++ = (s - 1) * (x ^ (-(s - 1)) * x ^ (-1 : ℝ)) by ring] ++ rw [← Real.rpow_add hxpos] ++ ring_nf ++ rw [show (Real.log (s - 1) + Real.log (Real.log x) - Real.log (s - 1)) ++ = Real.log (Real.log x) by ring] ++ linear_combination Real.log (Real.log x) * hx1 ++ rw [setIntegral_congr_fun measurableSet_Ioi hpt, integral_const_mul] ++ rw [hlhs, hrhs] at hcov ++ rw [hcov] ++ ring ++ ++end Issue1584 ++ ++namespace Mertens ++ ++open _root_.Real Erdos970.Real _root_.Finset _root_.Filter _root_.Asymptotics _root_.Topology ++open ArithmeticFunction hiding log ++ ++lemma sum_Ioc_one_eq_sum_Ioc_zero {f : ℕ → ℝ} {x : ℕ} (hx : 1 ≤ x) (hf : f 1 = 0) : ++ ∑ n ∈ Ioc 1 x, f n = ∑ n ∈ Ioc 0 x, f n := by ++ rw [(by rfl : Ioc 0 x = Icc 1 x), ← add_sum_Ioc_eq_sum_Icc hx] ++ simpa ++ ++theorem sum_log_eq {x : ℝ} (hx : 1 ≤ x) : ++ ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n = ++ x * log x - (x - ⌊x⌋₊ - 1 / 2) * log x - x + 1 + ∫ t in 1..x, (t - ⌊t⌋₊ - 1 / 2) / t := by ++ rw [← sum_Ioc_one_eq_sum_Ioc_zero (Nat.le_floor (by grind)) (by simp)] ++ have : 1 = ⌊(1 : ℝ)⌋₊ := by simp ++ nth_rw 1 [this] ++ rw [sum_eq_integral_add_integral_deriv (by norm_num) hx (fun _ _ ↦ (by fun_prop (disch := grind)))] ++ · simp only [log_one, B1, Nat.floor_one, Nat.cast_one, sub_self, zero_sub, ++ RCLike.ofReal_real_eq_id, id_eq, mul_neg, zero_mul, neg_zero, integral_log, mul_zero, sub_zero, ++ deriv_log'] ++ ring_nf ++ congr ++ ext ++ ring ++ · simp only [deriv_log', Set.uIcc_of_le hx] ++ fun_prop (disch := grind) ++ ++theorem sum_log_le {x : ℝ} (hx : 1 ≤ x) : ++ ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n ≤ x * log x := by ++ calc ++ _ ≤ ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log x := by ++ refine sum_le_sum fun n hn ↦ ?_ ++ simp only [mem_Ioc] at hn ++ exact log_le_log (by exact_mod_cast hn.1) (Nat.le_floor_iff (by linarith)|>.mp hn.2) ++ _ = ⌊x⌋₊ * log x := by simp ++ _ ≤ _ := by ++ gcongr ++ · exact log_nonneg hx ++ · exact Nat.floor_le (by linarith) ++ ++lemma integral_log_le {a b : ℝ} (ha : 1 ≤ a) (hab : a ≤ b) : ++ ∫ t in a..b, log t ≤ log b * (b - a) := by ++ apply le_of_abs_le ++ have : ∀ t ∈ Set.uIoc a b, ‖log t‖ ≤ log b := by ++ intro t ht ++ rw [Set.uIoc_of_le hab, Set.mem_Ioc] at ht ++ rw [norm_of_nonneg <| log_nonneg (by linarith)] ++ gcongr <;> linarith ++ grw [← norm_eq_abs, intervalIntegral.norm_integral_le_of_norm_le_const this, ++ abs_of_nonneg (by linarith)] ++ ++theorem sum_log_ge {x : ℝ} (hx : 1 ≤ x) : ++ ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n ≥ x * log x - 2 * x := by ++ have one_le_floor : 1 ≤ ⌊x⌋₊ := by simpa ++ calc ++ _ = ∑ n ∈ Icc 1 ⌊ x ⌋₊, log n := by rfl ++ _ = ∑ n ∈ Ico (1 + 1) (⌊ x ⌋₊ + 1), log n := by ++ rw [← add_sum_Ioc_eq_sum_Icc one_le_floor] ++ simp ++ rfl ++ _ = ∑ n ∈ Ico 1 ⌊ x ⌋₊, log ((n + 1 : ℕ)) := by ++ rw [← Finset.sum_Ico_add'] ++ _ ≥ ∫ t in 1..⌊x⌋₊, log t := by ++ convert MonotoneOn.integral_le_sum_Ico one_le_floor ?_|>.ge ++ · norm_cast ++ · exact StrictMonoOn.monotoneOn (strictMonoOn_log.mono fun y hy ↦ (by simp_all; linarith)) ++ _ = (∫ t in 1..x, log t) - ∫ t in ⌊x⌋₊..x, log t := by ++ nth_rw 3 [intervalIntegral.integral_symm] ++ rw [sub_neg_eq_add, intervalIntegral.integral_add_adjacent_intervals] <;> exact intervalIntegral.intervalIntegrable_log' ++ _ ≥ (∫ t in 1..x, log t) - log x := by ++ gcongr ++ grw [integral_log_le (by simpa) (Nat.floor_le (by linarith))] ++ nth_rw 2 [← mul_one (log x)] ++ gcongr ++ · exact log_nonneg hx ++ · linarith [Nat.lt_floor_add_one x] ++ _ ≥ x * log x - x - log x := by simp only [integral_log, log_one, mul_zero, sub_zero, ge_iff_le, ++ tsub_le_iff_right, sub_add_cancel, le_add_iff_nonneg_right, zero_le_one] ++ _ ≥ _ := by linarith [log_le_self (by linarith : 0 ≤ x)] ++ ++theorem sum_log_eq_log_factorial (x : ℝ) : ++ ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n = log (Nat.floor x).factorial := by ++ rw [←prod_Ico_id_eq_factorial, ←log_prod, prod_natCast] ++ · congr ++ intro x hx ++ simp at hx ⊢; grind ++ ++theorem sum_log_eq_sum_mangoldt {x : ℝ} : ++ ∑ n ∈ Ioc 0 ⌊x⌋₊, log n = ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d * ⌊x / d⌋₊ := by ++ have : ∀ n : ℕ, log n = (Λ * zeta) n := by simp [vonMangoldt_mul_zeta] ++ simp_rw [this, sum_Ioc_mul_zeta_eq_sum, ← Nat.floor_div_natCast] ++ ++noncomputable abbrev E₁Λ (x : ℝ) : ℝ := ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d - log x ++ ++theorem sum_mangoldt_div_eq (x : ℝ) : ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d = log x + E₁Λ x := by ++ grind ++ ++theorem E₁Λ.ge {x : ℝ} (hx : 1 ≤ x) : ++ E₁Λ x ≥ -2 := by ++ unfold E₁Λ ++ suffices x * ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d / d ≥ x * (log x - 2) by ++ linarith [le_of_mul_le_mul_left this (by linarith)] ++ calc ++ _ = ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d * (x / d) := by ++ rw [Finset.mul_sum] ++ ring_nf ++ _ ≥ ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d * ⌊x / d⌋₊ := by ++ gcongr ++ exact Nat.floor_le <| div_nonneg (by linarith) (by linarith) ++ _ ≥ x * log x - 2 * x := ++ sum_log_eq_sum_mangoldt ▸ sum_log_ge hx ++ _ = _ := by ring ++ ++theorem E₁Λ.le {x : ℝ} (hx : 1 ≤ x) : ++ E₁Λ x ≤ log 4 + 4 := by ++ unfold E₁Λ ++ suffices x * ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d / d ≤ x * (log x + log 4 + 4) by ++ linarith [le_of_mul_le_mul_left this (by linarith)] ++ calc ++ _ = ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d * (x / d) := by ++ rw [Finset.mul_sum] ++ ring_nf ++ _ ≤ ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d * (⌊x / d⌋₊ + 1) := by ++ gcongr ++ exact Nat.lt_floor_add_one _|>.le ++ _ = (∑ d ∈ Ioc 0 ⌊x⌋₊, log d) + ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d := by ++ simp_rw [mul_add, mul_one] ++ rw [Finset.sum_add_distrib, sum_log_eq_sum_mangoldt] ++ _ ≤ x * log x + (log 4 + 4) * x := by ++ gcongr ++ · exact sum_log_le hx ++ · exact Chebyshev.psi_le_const_mul_self (by linarith) ++ _ = _ := by ring ++ ++theorem sum_mangoldt_div_eq_log {x : ℝ} (hx : 1 ≤ x) : ++ |∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d - log x| ≤ log 4 + 4 := by ++ grind [E₁Λ.le hx, E₁Λ.ge hx, log_nonneg] ++ ++theorem E₁Λ.bounded' : ∃ c > 0, ∀ x ≥ 1, |E₁Λ x| ≤ c := by ++ exact ⟨log 4 + 4, (by positivity), fun x hx ↦ sum_mangoldt_div_eq_log hx⟩ ++ ++theorem E₁Λ.bounded : E₁Λ =O[atTop] (fun _ ↦ (1:ℝ)) := by ++ simp only [isBigO_iff, norm_eq_abs, norm_one, mul_one, ++ eventually_atTop] ++ exact ⟨log 4 + 4, 1, fun _ hx ↦ sum_mangoldt_div_eq_log hx⟩ ++ ++theorem one_eq_o_log : (fun _ ↦ (1:ℝ)) =o[atTop] (fun x ↦ log x) := by ++ simp only [isLittleO_one_left_iff, norm_eq_abs] ++ exact tendsto_abs_atTop_atTop.comp tendsto_log_atTop ++ ++theorem sum_mangoldt_div_eq_log' : ++ (fun x ↦ ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d) ~[atTop] (fun x ↦ log x) := by ++ apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log) ++ convert! E₁Λ.bounded using 1 ++ ++noncomputable abbrev E₁p (x : ℝ) : ℝ := ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p - log x ++ ++theorem sum_log_prime_div_eq (x : ℝ) : ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p = log x + E₁p x := by ++ grind ++ ++theorem E₁p.le_E₁Λ (x : ℝ) : ++ E₁p x ≤ E₁Λ x := by ++ unfold E₁p E₁Λ; rw [sum_filter] ++ gcongr with p _ ++ split_ifs with hp ++ · simp [vonMangoldt_apply_prime hp] ++ have : 0 ≤ Λ p := vonMangoldt_nonneg ++ positivity ++ ++theorem E₁p.le {x : ℝ} (hx : 1 ≤ x) : ++ E₁p x ≤ log 4 + 4 := by ++ linarith [E₁Λ.le hx, E₁p.le_E₁Λ x] ++ ++noncomputable abbrev E₁ : ℝ := ∑' p : ℕ, if p.Prime then (log p) / (p*(p-1)) else 0 ++ ++lemma E₁.summand_nonneg (p : ℕ) : 0 ≤ if p.Prime then (log p) / (p*(p-1)) else 0 := by ++ split_ifs with h ++ · refine div_nonneg (log_natCast_nonneg _) (mul_nonneg (Nat.cast_nonneg _) ?_) ++ suffices 1 ≤ (p : ℝ) by linarith ++ exact_mod_cast h.one_le ++ · rfl ++ ++theorem E₁.summable : Summable (fun p : ℕ ↦ if p.Prime then (log p) / (p*(p-1)) else 0) := by ++ refine (Real.summable_one_div_nat_rpow.mpr (by norm_num: 1 < (3 : ℝ) / 2)|>.const_div ++ 4).of_nonneg_of_le E₁.summand_nonneg fun n ↦ ?_ ++ split_ifs with h ++ · grw [Real.log_le_rpow_div (Nat.cast_nonneg _) (by norm_num : 0 < (1 : ℝ) / 2)] ++ · have denom : (n : ℝ) * ((n : ℝ) - 1) ≥ n ^ 2/ 2 := by ++ rw [sq, mul_div_assoc] ++ gcongr ++ suffices (n : ℝ) ≥ 2 by linarith ++ exact_mod_cast h.two_le ++ grw [denom] ++ · apply le_of_eq ++ rw [← Real.rpow_natCast] ++ field_simp ++ rw [mul_div_assoc, ← Real.rpow_sub (mod_cast h.pos)] ++ norm_num ++ rw [Real.rpow_neg (Nat.cast_nonneg _)] ++ field ++ · exact div_pos (pow_pos (mod_cast h.pos) _) (by norm_num) ++ · apply mul_nonneg (Nat.cast_nonneg _) ++ suffices 1 ≤ (n : ℝ) by linarith ++ exact_mod_cast h.one_le ++ · positivity ++ ++private lemma antitoneOn_log_div_sq : ++ AntitoneOn (fun t ↦ log (t + 2) / (t + 2) ^ 2) (Set.Ici 0) := by ++ apply antitoneOn_of_deriv_nonpos (convex_Ici 0) ++ · refine fun t ht ↦ ContinuousAt.continuousWithinAt ?_ ++ simp at ht ++ have : (t + 2) ≠ 0 := by simp; linarith ++ fun_prop (disch := grind) ++ · refine fun t ht ↦ DifferentiableAt.differentiableWithinAt ?_ ++ simp at ht ++ have : (t + 2) ^ 2 ≠ 0 := by simp; grind ++ fun_prop (disch := grind) ++ · intro t ht ++ simp at ht ++ rw [deriv_fun_div (by fun_prop (disch := grind)) (by fun_prop) (by simp; grind), deriv_comp_add_const, deriv_log] ++ simp ++ field_simp ++ simp only [mul_zero, tsub_le_iff_right, zero_add] ++ rw [← log_rpow (by linarith), ← log_exp 1, rpow_ofNat] ++ gcongr ++ nlinarith [exp_one_lt_three] ++ ++private lemma log_div_sq_nonneg : ++ ∀ t ∈ Set.Ioi 0, 0 ≤ log (t + 2) / (t + 2) ^ 2 := by ++ exact fun t ht ↦ div_nonneg (log_nonneg (by simp_all; linarith)) (by positivity) ++ ++private lemma log_div_sq_is_deriv : ++ ∀ x ∈ Set.Ici 0, HasDerivAt (fun t ↦ (-log (t + 2) - 1) / (t + 2)) (log (x + 2) / (x + 2) ^ 2) x := by ++ intro t ht ++ simp at ht ++ apply HasDerivAt.comp_add_const (f := (fun t ↦ (-log t - 1)/ t)) t 2 ++ convert! HasDerivAt.fun_div (c' := -1 / (t + 2)) (d' := (1 : ℝ)) _ _ _ using 1 ++ · field ++ · apply HasDerivAt.sub_const ++ convert! (hasDerivAt_log (by linarith : t + 2 ≠ 0)).neg using 1 ++ ring_nf ++ · exact hasDerivAt_id _ ++ · linarith ++ ++private lemma tendsto_antideriv_log_div_sq : ++ Tendsto (fun t ↦ (-log (t + 2) - 1) / (t + 2)) atTop (nhds 0) := by ++ have : Tendsto (fun (t : ℝ) ↦ t + 2) atTop atTop := by exact tendsto_atTop_add_const_right atTop 2 tendsto_id ++ apply Tendsto.comp (g := (fun t ↦ (-log t - 1) / t)) _ this ++ convert! Tendsto.sub (f := (fun t ↦ -log t / t)) (a := 0) _ tendsto_inv_atTop_zero using 1 ++ · ring_nf ++ · ring_nf ++ · convert! (Real.tendsto_pow_log_div_mul_add_atTop 1 0 1 (by linarith)).neg using 1 ++ · ext; ring ++ · simp ++ ++private lemma integrableOn_log_div_sq : ++ MeasureTheory.IntegrableOn (fun t ↦ log (t + 2) / (t + 2) ^ 2) (Set.Ioi 0) := by ++ exact MeasureTheory.integrableOn_Ioi_deriv_of_nonneg' log_div_sq_is_deriv log_div_sq_nonneg tendsto_antideriv_log_div_sq ++ ++private lemma integral_log_div_sq : ++ ∫ t in Set.Ioi 0, log (t + 2) / (t + 2) ^ 2 = (log 2 + 1) / 2 := by ++ rw [MeasureTheory.integral_Ioi_of_hasDerivAt_of_nonneg' log_div_sq_is_deriv log_div_sq_nonneg tendsto_antideriv_log_div_sq] ++ ring_nf ++ ++private lemma summable_log_div_sq : ++ Summable (fun (n : ℕ)↦ log (n + 3) / (n + 3) ^ 2) := by ++ let g : ℝ → ℝ := (fun n ↦ log (n + 2) / (n + 2) ^ 2) ++ suffices Summable (fun (n : ℕ) ↦ g n ) by ++ convert! summable_nat_add_iff 1|>.mpr this using 2 ++ unfold g ++ push_cast ++ ring_nf ++ exact antitoneOn_log_div_sq.summable_of_integrableOn_Ioi_zero integrableOn_log_div_sq log_div_sq_nonneg ++ ++private lemma sum_log_div_sq_le : ++ ∑' (n : ℕ), log (n + 3) / (n + 3) ^2 ≤ (log 2 + 1) / 2 := by ++ let g : ℝ → ℝ := (fun n ↦ log (n + 2) / (n + 2) ^ 2) ++ calc ++ _ = ∑' (n : ℕ), g (n + 1 : ℕ):= by ++ unfold g ++ congr ++ push_cast ++ ring_nf ++ _ ≤ ∫ x in Set.Ioi 0, g x := by ++ exact antitoneOn_log_div_sq.tsum_add_one_le_integral integrableOn_log_div_sq log_div_sq_nonneg ++ _ = _ := by ++ exact integral_log_div_sq ++ ++theorem E₁.le : E₁ ≤ (5 * log 2 + 3) / 4 := by ++ unfold E₁ ++ calc ++ _ = log 2 / 2 + ∑' (n : ℕ), if (n + 3).Prime then log (n + 3) / ((n + 3) * (n + 2)) else 0 := by ++ rw [← E₁.summable.sum_add_tsum_nat_add 3, (by rfl : range 3 = {0, 1, 2})] ++ simp [Nat.prime_two] ++ ring_nf ++ _ ≤ log 2 / 2 + ∑' (n : ℕ), (3 / 2) * (log (n + 3) / (n + 3) ^ 2) := by ++ gcongr with n ++ · convert! summable_nat_add_iff 3|>.mpr E₁.summable using 4 ++ · norm_cast ++ · push_cast; ring ++ · exact summable_log_div_sq.mul_left _ ++ · split_ifs with h ++ · grw [(by linarith : (n + 2 : ℝ) ≥ 2 * (n + 3) / 3)] ++ · field_simp ++ rfl ++ · exact log_nonneg (by grind) ++ · exact mul_nonneg (by norm_num) (div_nonneg (log_nonneg (by grind)) (by positivity)) ++ _ = log 2 / 2 + (3 / 2) * ∑' (n : ℕ), log (n + 3) / (n + 3) ^ 2 := by ++ rw [tsum_mul_left] ++ _ ≤ _ := by ++ grw [sum_log_div_sq_le] ++ ring_nf ++ rfl ++ ++theorem E₁.nonneg : E₁ ≥ 0 := ++ tsum_nonneg E₁.summand_nonneg ++ ++theorem E₁Λ.le_E₁p_add_E₁ {x : ℝ} (hx : 1 ≤ x) : ++ E₁Λ x ≤ E₁p x + E₁ := by ++ unfold E₁Λ E₁p ++ suffices ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d / d ≤ ∑ p ∈ Ioc 0 ⌊x⌋₊ with Nat.Prime p, log p / p + E₁ by linarith ++ simp_rw [vonMangoldt_apply, ite_div, zero_div, ← sum_filter, Chebyshev.sum_PrimePow_eq_sum_sum _ (by linarith)] ++ calc ++ _ = ∑ k ∈ Icc 1 ⌊log x / log 2⌋₊, ∑ p ∈ Ioc 0 ⌊x ^ (1 / (k : ℝ))⌋₊ with Nat.Prime p, log p / (p ^ k : ℕ) := by ++ refine sum_congr rfl fun k hk ↦ sum_congr rfl fun p hp ↦ ?_ ++ rw [Nat.Prime.pow_minFac (by simp_all) (by simp_all; linarith)] ++ _ ≤ ∑ k ∈ Icc 1 ⌊log x / log 2⌋₊, ∑ p ∈ Ioc 0 ⌊x⌋₊ with Nat.Prime p, log p / (p ^ k : ℕ) := by ++ gcongr with k hk ++ apply rpow_le_self_of_one_le hx ++ simp only [mem_Icc] at hk ++ exact div_le_one₀ (by norm_cast; linarith)|>.mpr (mod_cast hk.1) ++ _ ≤ ∑ k ∈ Icc 1 (max 1 ⌊log x / log 2⌋₊), ∑ p ∈ Ioc 0 ⌊x⌋₊ with Nat.Prime p, log p / (p ^ k : ℕ) := by ++ apply sum_le_sum_of_subset_of_nonneg ++ · gcongr ++ exact le_max_right .. ++ · exact fun _ _ _ ↦ sum_nonneg fun _ _ ↦ (by positivity) ++ _ = ∑ p ∈ Ioc 0 ⌊x⌋₊ with Nat.Prime p, (log p / p) + ∑ k ∈ Ioc 1 (max 1 ⌊log x / log 2⌋₊), ∑ p ∈ Ioc 0 ⌊x⌋₊ with Nat.Prime p, log p / (p ^ k : ℕ) := by ++ rw [← add_sum_Ioc_eq_sum_Icc (le_max_left ..)] ++ simp ++ _ ≤ _ := by ++ gcongr ++ rw [sum_comm] ++ conv => lhs; arg 2; ext p; arg 2; ext k; rw [← mul_one_div, Nat.cast_pow, ← one_div_pow] ++ simp_rw [← mul_sum] ++ calc ++ _ ≤ ∑ p ∈ Ioc 0 ⌊x⌋₊ with Nat.Prime p, log p / (p * (p - 1)) := by ++ gcongr with p hp ++ simp only [mem_filter, mem_Ioc] at hp ++ conv => rhs; rw [← mul_one_div] ++ gcongr ++ rw [(by rfl : Ioc 1 (max 1 ⌊log x / log 2⌋₊) = Ico 2 (max 1 ⌊log x / log 2⌋₊ + 1))] ++ grw [geom_sum_Ico_le_of_lt_one (by simp)] ++ · apply le_of_eq ++ have : (p : ℝ) ≠ 0 := by exact_mod_cast hp.1.1.ne.symm ++ field ++ · simpa using inv_lt_one_of_one_lt₀ (mod_cast hp.2.one_lt) ++ _ ≤ _ := by ++ rw [sum_filter] ++ exact E₁.summable.sum_le_tsum _ fun p hp ↦ E₁.summand_nonneg p ++ ++theorem E₁p.ge {x : ℝ} (hx : 1 ≤ x) : ++ E₁p x ≥ -2 - E₁ := by ++ linarith [E₁Λ.le_E₁p_add_E₁ hx, E₁Λ.ge hx] ++ ++theorem sum_log_prime_div_eq_log {x : ℝ} (hx : 1 ≤ x) : ++ |∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p - log x| ≤ log 4 + 4 := by ++ rw [abs_le'] ++ refine ⟨ E₁p.le hx, ?_ ⟩ ++ have : log 2 > 0 := by apply log_pos; norm_num ++ have : log 4 = 2 * log 2 := by rw [←Real.log_rpow (by norm_num)]; norm_num ++ grind [E₁p.ge hx, E₁.le] ++ ++theorem E₁p.bounded : ∃ c > 0, ∀ x ≥ 1, |E₁p x| ≤ c := by ++ exact ⟨log 4 + 4, (by positivity), fun _ hx ↦ sum_log_prime_div_eq_log hx⟩ ++ ++theorem sum_log_prime_div_eq_log' : E₁p =O[atTop] (fun _ ↦ (1:ℝ)) := by ++ simp only [isBigO_iff, norm_eq_abs, one_mem, CStarRing.norm_of_mem_unitary, mul_one, ++ eventually_atTop, E₁p] ++ exact ⟨ log 4 + 4, 1, fun _ ↦ sum_log_prime_div_eq_log ⟩ ++ ++theorem sum_log_prime_div_eq_log'' : (fun x ↦ ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p) ~[atTop] (fun x ↦ log x) := by ++ apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log) ++ convert! sum_log_prime_div_eq_log' using 1 ++ ++noncomputable abbrev γ : ℝ := (∫ t in Set.Ioi 2, E₁Λ t / (t * log t^2)) + 1 - log (log 2) ++ ++noncomputable abbrev E₂Λ (x : ℝ) : ℝ := ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) - log (log x) - γ ++ ++lemma sum_Ioc_one_eq_sum_Icc_zero {f : ℕ → ℝ} {x : ℕ} (hx : 1 ≤ x) (hf1 : f 1 = 0) (hf0 : f 0 = 0) : ++ ∑ n ∈ Ioc 1 x, f n = ∑ n ∈ Icc 0 x, f n := by ++ rw [sum_Ioc_one_eq_sum_Ioc_zero hx hf1, ← add_sum_Ioc_eq_sum_Icc (by linarith)] ++ simpa ++ ++private theorem sum_div_log_eq {x : ℝ} (hx : 2 ≤ x) (f : ℕ → ℝ) : ++ ∑ n ∈ Ioc 1 ⌊ x ⌋₊, f n / log n = ++ (∑ n ∈ Ioc 1 ⌊ x ⌋₊, f n) / log x + ∫ t in 2..x, (∑ n ∈ Ioc 1 ⌊ t ⌋₊, f n) / (t * log t^2) := by ++ let g : ℕ → ℝ := (fun n ↦ if n < 2 then 0 else f n) ++ trans ∑ n ∈ Icc 0 ⌊ x ⌋₊, (log n)⁻¹ * g n ++ · rw [← sum_Ioc_one_eq_sum_Icc_zero (Nat.le_floor (by grind)) (by simp) (by simp)] ++ refine sum_congr rfl fun n hn ↦ ?_ ++ have : ¬(n ≤ 1) := by simp_all ++ simp [g, this] ++ field ++ rw [sum_mul_eq_sub_integral_mul₁ g (f := (fun n ↦ (log n)⁻¹)) (by simp [g]) (by simp [g])] ++ · rw [intervalIntegral.integral_of_le hx, mul_comm, ← div_eq_mul_inv, ← sub_neg_eq_add] ++ simp_rw [deriv_inv_log] ++ congr 1 ++ · rw [← sum_Ioc_one_eq_sum_Icc_zero (Nat.le_floor (by grind)) (by simp [g]) (by simp [g])] ++ congr 1 ++ refine sum_congr rfl fun n hn ↦ ?_ ++ simp only [mem_Ioc] at hn ++ have : ¬(n ≤ 1) := by linarith ++ simp [g, this] ++ · rw [← MeasureTheory.integral_neg] ++ refine MeasureTheory.setIntegral_congr_fun (by measurability) fun t ht ↦ ?_ ++ simp only [Set.mem_Ioc] at ht ++ rw [← sum_Ioc_one_eq_sum_Icc_zero (Nat.le_floor (by grind)) (by simp [g]) (by simp [g])] ++ field_simp ++ congr 2 ++ refine sum_congr rfl fun n hn ↦ ?_ ++ simp only [mem_Ioc] at hn ++ have : ¬(n ≤ 1) := by linarith ++ simp [g, this] ++ · intro t ht ++ simp only [Set.mem_Icc] at ht ++ have : log t ≠ 0 := by simp; grind ++ fun_prop (disch := grind) ++ · refine ContinuousOn.integrableOn_Icc fun t ht ↦ ContinuousAt.continuousWithinAt ?_ ++ simp only [Set.mem_Icc] at ht ++ conv => arg 1; ext x; rw [deriv_inv_log] ++ have : log t ^2 ≠ 0 := by simp; grind ++ fun_prop (disch := grind) ++ ++private theorem integrable_const_div_mul_log_sq {x : ℝ} (c : ℝ) (hx : 2 ≤ x) : ++ MeasureTheory.IntegrableOn (fun x ↦ c / (x * log x ^ 2)) (Set.Ioi x) MeasureTheory.volume := by ++ conv => arg 1; ext t; rw [← mul_one_div] ++ apply MeasureTheory.Integrable.const_mul ++ refine MeasureTheory.integrableOn_Ioi_deriv_of_nonneg' ?_ ?_ tendsto_log_atTop.inv_tendsto_atTop.neg ++ · intro t ht ++ simp only [Set.mem_Ici] at ht ++ have : log t ≠ 0 := by simp; grind ++ have : DifferentiableAt ℝ (fun t ↦ -(log t)⁻¹) t := by ++ fun_prop (disch := grind) ++ convert! this.hasDerivAt using 1 ++ simp [deriv_inv_log] ++ field ++ · intro t ht ++ simp only [Set.mem_Ioi] at ht ++ exact one_div_nonneg.mpr <| mul_nonneg (by linarith) (sq_nonneg _) ++ ++attribute [fun_prop] measurable_from_top ++ ++private theorem integrable_E₁Λ_div_mul_log_sq {x : ℝ} (hx : 2 ≤ x) : ++ MeasureTheory.IntegrableOn (fun x ↦ E₁Λ x / (x * log x ^ 2)) (Set.Ioi x) MeasureTheory.volume := by ++ obtain ⟨c, hc1, hc2⟩ := E₁Λ.bounded' ++ apply MeasureTheory.Integrable.mono (integrable_const_div_mul_log_sq c hx) ++ · exact Measurable.aestronglyMeasurable (by fun_prop) ++ · filter_upwards [MeasureTheory.ae_restrict_mem (by measurability)] with t ht ++ simp only [Set.mem_Ioi] at ht ++ simp only [norm_div, norm_eq_abs, norm_mul, norm_pow, sq_abs, abs_of_pos hc1] ++ gcongr ++ exact hc2 t (by linarith) ++ ++private theorem integrable_E₁p_div_mul_log_sq {x : ℝ} (hx : 2 ≤ x) : ++ MeasureTheory.IntegrableOn (fun x ↦ E₁p x / (x * log x ^ 2)) (Set.Ioi x) MeasureTheory.volume := by ++ obtain ⟨c, hc1, hc2⟩ := E₁p.bounded ++ apply MeasureTheory.Integrable.mono (integrable_const_div_mul_log_sq c hx) ++ · exact Measurable.aestronglyMeasurable (by fun_prop) ++ · filter_upwards [MeasureTheory.ae_restrict_mem (by measurability)] with t ht ++ simp only [Set.mem_Ioi] at ht ++ simp only [norm_div, norm_eq_abs, norm_mul, norm_pow, sq_abs, abs_of_pos hc1] ++ gcongr ++ exact hc2 t (by linarith) ++ ++lemma deriv_log_log {x : ℝ} (hx : 1 < x) : ++ deriv (fun t ↦ log (log t)) x = 1 / (x * log x) := by ++ rw [deriv.log (differentiableAt_log (by linarith)) (by simp; grind), deriv_log] ++ field ++ ++lemma integral_one_div_mul_log {x : ℝ} (hx : 2 ≤ x) : ++ ∫ t in 2..x, 1 / (t * log t) = log (log x) - log (log 2) := by ++ rw [← intervalIntegral.integral_deriv_eq_sub (f := fun t ↦ log (log t))] ++ · refine intervalIntegral.integral_congr fun t ht ↦ ?_ ++ rw [deriv_log_log] ++ rw [Set.uIcc_of_le hx, Set.mem_Icc] at ht ++ linarith ++ · intro t ht ++ rw [Set.uIcc_of_le hx, Set.mem_Icc] at ht ++ have : log t ≠ 0 := by simp; grind ++ fun_prop (disch := grind) ++ · refine ContinuousOn.intervalIntegrable ?_ ++ apply ContinuousOn.congr (f := (fun t ↦ 1 / (t * log t))) ++ · refine fun t ht ↦ ContinuousAt.continuousWithinAt ?_ ++ rw [Set.uIcc_of_le hx, Set.mem_Icc] at ht ++ have : log t ≠ 0 := by simp; grind ++ fun_prop (disch := grind) ++ · intro t ht ++ rw [Set.uIcc_of_le hx, Set.mem_Icc] at ht ++ exact deriv_log_log (by linarith) ++ ++lemma intervalIntegrable_one_div_mul_log {x : ℝ} (hx : 2 ≤ x) : ++ IntervalIntegrable (fun t ↦ 1 / (t * log t)) MeasureTheory.volume 2 x := by ++ refine ContinuousOn.intervalIntegrable fun t ht ↦ ContinuousAt.continuousWithinAt ?_ ++ rw [Set.uIcc_of_le hx, Set.mem_Icc] at ht ++ have : log t ≠ 0 := by simp; grind ++ fun_prop (disch := grind) ++ ++theorem E₂Λ.eq {x : ℝ} (hx : 2 ≤ x) : ++ E₂Λ x = E₁Λ x / log x - ∫ t in Set.Ioi x, E₁Λ t / (t * log t^2) := by ++ unfold E₂Λ ++ rw [← sum_Ioc_one_eq_sum_Ioc_zero (Nat.le_floor (by grind)) (by simp)] ++ conv => lhs; arg 1; arg 1; arg 2; ext n; rw [(by field : Λ n / (n * log n) = (Λ n / n) / log n)] ++ rw [sum_div_log_eq hx] ++ rw [sum_Ioc_one_eq_sum_Ioc_zero (Nat.le_floor (by grind)) (by simp), sum_mangoldt_div_eq] ++ have : ∫ t in 2..x, (∑ n ∈ Ioc 1 ⌊t⌋₊, Λ n / n) / (t * log t ^ 2) = ∫ t in 2..x, (1 / (t * log t) + E₁Λ t / (t * log t ^ 2)) := by ++ refine intervalIntegral.integral_congr fun t ht ↦ ?_ ++ rw [Set.uIcc_of_le hx, Set.mem_Icc] at ht ++ rw [sum_Ioc_one_eq_sum_Ioc_zero (Nat.le_floor (by grind)) (by simp), sum_mangoldt_div_eq] ++ field ++ rw [this, intervalIntegral.integral_add] ++ · rw [integral_one_div_mul_log hx, add_div, div_self (by simp; grind)] ++ unfold γ ++ calc ++ _ = E₁Λ x / log x + (∫ (x : ℝ) in 2..x, E₁Λ x / (x * log x ^ 2)) - ++ ((∫ (t : ℝ) in Set.Ioi 2, E₁Λ t / (t * log t ^ 2))) := by ring ++ _ = _ := by ++ rw [← intervalIntegral.integral_interval_add_Ioi (integrable_E₁Λ_div_mul_log_sq (by rfl)) (integrable_E₁Λ_div_mul_log_sq hx)] ++ ring ++ · exact intervalIntegrable_one_div_mul_log hx ++ · rw [intervalIntegrable_iff, Set.uIoc_of_le hx] ++ exact integrable_E₁Λ_div_mul_log_sq (x := 2) (by rfl)|>.mono (by grind) (by rfl) ++ ++private theorem integ_div_mul_log_sq {x : ℝ} (c : ℝ) (hx : 2 ≤ x) : ++ ∫ t in Set.Ioi x, c / (t * log t^2) = c / log x := by ++ convert! MeasureTheory.integral_Ioi_of_hasDerivAt_of_tendsto' (m := 0) (f := fun x ↦ - c / log x) ?_ ++ (integrable_const_div_mul_log_sq c hx) ?_ using 1 ++ · grind ++ · intro t ht; simp at ht ++ convert! HasDerivAt.fun_div (hasDerivAt_const _ (-c)) (hasDerivAt_log (by linarith)) ?_ using 1 ++ · grind ++ simp; grind ++ convert! tendsto_log_atTop.inv_tendsto_atTop.const_mul (-c) using 1 ++ simp ++ ++theorem E₂Λ.abs_le {x : ℝ} (hx : 2 ≤ x) : ++ |E₂Λ x| ≤ (log 4 + 6) / log x := by ++ have : 0 < log x := by apply log_pos; linarith ++ rw [E₂Λ.eq hx, abs_le'] ++ constructor ++ · grw [E₁Λ.le (by linarith)] ++ have : ∫ t in Set.Ioi x, E₁Λ t / (t * log t^2) ≥ - 2 / log x := calc ++ _ ≥ ∫ t in Set.Ioi x, (-2) / (t * log t^2) := by ++ apply MeasureTheory.setIntegral_mono_on (integrable_const_div_mul_log_sq (-2) hx) ++ (integrable_E₁Λ_div_mul_log_sq hx) (by measurability) ++ intro y hy; simp at hy ++ have : 1 < y := by linarith ++ have : 0 < log y := log_pos this ++ gcongr; exact E₁Λ.ge (by linarith) ++ _ = _ := integ_div_mul_log_sq (-2) hx ++ grw [this] ++ grind ++ grw [E₁Λ.ge (by linarith)] ++ have : ∫ t in Set.Ioi x, E₁Λ t / (t * log t^2) ≤ (log 4 + 4) / log x := calc ++ _ ≤ ∫ t in Set.Ioi x, (log 4 + 4) / (t * log t^2) := by ++ apply MeasureTheory.setIntegral_mono_on (integrable_E₁Λ_div_mul_log_sq hx) ++ (integrable_const_div_mul_log_sq (log 4 + 4) hx) (by measurability) ++ intro y hy; simp at hy ++ have : 1 < y := by linarith ++ have : 0 < log y := log_pos this ++ gcongr; exact E₁Λ.le (by linarith) ++ _ = _ := integ_div_mul_log_sq (log 4 + 4) hx ++ grw [this] ++ grind ++ ++theorem E₂Λ.bound : E₂Λ =O[atTop] (fun x ↦ 1 / log x) := by ++ simp only [one_div, isBigO_iff, norm_eq_abs, norm_inv, eventually_atTop] ++ use log 4 + 6, 2 ++ intro x hx ++ convert E₂Λ.abs_le hx using 1 ++ have : 0 < log x := by apply log_pos; linarith ++ grind [abs_of_pos this] ++ ++theorem E₂Λ.bound' : E₂Λ =o[atTop] (fun _ ↦ (1:ℝ)) := E₂Λ.bound.trans_isLittleO inv_log_eq_o_one ++ ++theorem log_zeta_eq_sum (s : ℝ) (hs : 1 < s) : ++ log (riemannZeta (s:ℂ)).re = ∑' n, Λ n / (n^s * log n) := by ++ have hsc : (1 : ℝ) < ((s : ℂ)).re := by simpa using hs ++ ++ have hep := riemannZeta_eulerProduct_exp_log (s := (s : ℂ)) hsc ++ set S : ℂ := ∑' p : Nat.Primes, -Complex.log (1 - (p : ℂ) ^ (-(s : ℂ))) with hS ++ ++ have hcpow : ∀ p : Nat.Primes, (p : ℂ) ^ (-(s : ℂ)) = (((p : ℝ) ^ (-s) : ℝ) : ℂ) := by ++ intro p ++ rw [Complex.ofReal_cpow (by positivity)] ++ push_cast; ring_nf ++ ++ set z : Nat.Primes → ℝ := fun p => (p : ℝ) ^ (-s) with hz ++ ++ have hz_pos : ∀ p : Nat.Primes, 0 < z p := fun p => by ++ have : (0 : ℝ) < (p : ℝ) := by exact_mod_cast p.prop.pos ++ positivity ++ have hz_lt_one : ∀ p : Nat.Primes, z p < 1 := by ++ intro p ++ have hp1 : (1 : ℝ) < (p : ℝ) := by exact_mod_cast p.prop.one_lt ++ change (p : ℝ) ^ (-s) < 1 ++ rw [Real.rpow_neg (by positivity), inv_lt_one_iff₀] ++ right ++ exact (Real.one_lt_rpow_iff_of_pos (by positivity)).mpr (Or.inl ⟨hp1, by linarith⟩) ++ ++ have hterm : ∀ p : Nat.Primes, ++ -Complex.log (1 - (p : ℂ) ^ (-(s : ℂ))) = ((-Real.log (1 - z p) : ℝ) : ℂ) := by ++ intro p ++ rw [hcpow p] ++ have h1z : (0 : ℝ) < 1 - z p := by have := hz_lt_one p; linarith ++ rw [show (1 : ℂ) - ((z p : ℝ) : ℂ) = (((1 - z p : ℝ)) : ℂ) by push_cast; ring] ++ rw [← Complex.ofReal_log h1z.le] ++ push_cast; ring ++ ++ set Sr : ℝ := ∑' p : Nat.Primes, -Real.log (1 - z p) with hSr ++ have hSeq : S = (Sr : ℂ) := by ++ rw [hS, hSr, Complex.ofReal_tsum] ++ exact tsum_congr hterm ++ have hSim : S.im = 0 := by rw [hSeq]; exact Complex.ofReal_im _ ++ have hSre : S.re = Sr := by rw [hSeq]; exact Complex.ofReal_re _ ++ ++ have hlog_zeta : Complex.log (riemannZeta (s : ℂ)) = S := by ++ rw [← hep, Complex.log_exp (by rw [hSim]; exact neg_lt_zero.mpr Real.pi_pos) ++ (by rw [hSim]; exact Real.pi_pos.le)] ++ ++ have hkey : Real.log (riemannZeta (s : ℂ)).re = Sr := by ++ have hζim : (riemannZeta (s : ℂ)).im = 0 := riemannZeta_im_eq_zero_of_one_lt hs ++ have hζeq : riemannZeta (s : ℂ) = ((riemannZeta (s : ℂ)).re : ℂ) := by ++ apply Complex.ext <;> simp [hζim] ++ have : Real.log (riemannZeta (s : ℂ)).re ++ = (Complex.log (riemannZeta (s : ℂ))).re := by ++ conv_rhs => rw [hζeq] ++ rw [Complex.log_ofReal_re] ++ rw [this, hlog_zeta, hSre] ++ rw [hkey] ++ ++ have habs : ∀ p : Nat.Primes, |z p| < 1 := by ++ intro p ++ rw [abs_of_pos (hz_pos p)]; exact hz_lt_one p ++ have htaylor : ∀ p : Nat.Primes, ++ HasSum (fun n : ℕ => (z p) ^ (n + 1) / (n + 1)) (-Real.log (1 - z p)) := ++ fun p => hasSum_pow_div_log_of_abs_lt_one (habs p) ++ have hSr_double : Sr = ∑' (p : Nat.Primes) (n : ℕ), (z p) ^ (n + 1) / (n + 1) := by ++ rw [hSr] ++ exact tsum_congr fun p => ((htaylor p).tsum_eq).symm ++ ++ have hsummable_z : Summable z := Nat.Primes.summable_rpow.mpr (by linarith) ++ ++ have hsummable_prime : Summable (fun p : Nat.Primes => -Real.log (1 - z p)) := by ++ have := Real.summable_log_one_add_of_summable hsummable_z.neg ++ convert! this.neg using 1 ++ ++ have hg_nonneg : ∀ pk : Nat.Primes × ℕ, 0 ≤ (z pk.1) ^ (pk.2 + 1) / (pk.2 + 1) := by ++ intro pk; positivity [hz_pos pk.1] ++ have hsummable_g : Summable (fun pk : Nat.Primes × ℕ => (z pk.1) ^ (pk.2 + 1) / (pk.2 + 1)) := by ++ rw [summable_prod_of_nonneg hg_nonneg] ++ refine ⟨fun p => (htaylor p).summable, ?_⟩ ++ refine hsummable_prime.congr (fun p => ?_) ++ exact ((htaylor p).tsum_eq).symm ++ ++ have hpoint : ∀ (p : Nat.Primes) (n : ℕ), ++ Λ ((p : ℕ) ^ (n + 1)) / ++ ((((p : ℕ) ^ (n + 1) : ℕ) : ℝ) ^ s * Real.log (((p : ℕ) ^ (n + 1) : ℕ) : ℝ)) ++ = (z p) ^ (n + 1) / (n + 1) := by ++ intro p n ++ have hp1 : (1 : ℝ) < (p : ℝ) := by exact_mod_cast p.prop.one_lt ++ have hlogp : 0 < Real.log (p : ℝ) := Real.log_pos hp1 ++ rw [vonMangoldt_apply_pow (Nat.succ_ne_zero n), vonMangoldt_apply_prime p.prop] ++ have hcast : (((p : ℕ) ^ (n + 1) : ℕ) : ℝ) = (p : ℝ) ^ (n + 1) := by push_cast; ring ++ rw [hcast, Real.log_pow] ++ rw [show (z p) ^ (n + 1) = ((p : ℝ) ^ (n + 1)) ^ (-s) by ++ rw [hz]; rw [← Real.rpow_natCast ((p : ℝ) ^ (-s)) (n + 1), ++ ← Real.rpow_natCast ((p : ℝ)) (n + 1), ← Real.rpow_mul (by positivity), ++ ← Real.rpow_mul (by positivity)]; ring_nf] ++ rw [Real.rpow_neg (by positivity)] ++ field_simp ++ push_cast ++ ring ++ ++ set F : ℕ → ℝ := fun n => Λ n / ((n : ℝ) ^ s * Real.log n) with hF ++ ++ have hsupp : Function.support F ⊆ {n : ℕ | IsPrimePow n} := by ++ intro n hn ++ rw [Function.mem_support] at hn ++ simp only [Set.mem_ofPred_eq] ++ by_contra hpp ++ apply hn ++ simp only [hF, vonMangoldt_eq_zero_iff.mpr hpp, zero_div] ++ ++ have hprod_eq : (∑' pk : Nat.Primes × ℕ, (z pk.1) ^ (pk.2 + 1) / (pk.2 + 1)) ++ = ∑' m : {n : ℕ // IsPrimePow n}, F m.val := by ++ rw [← Equiv.tsum_eq Nat.Primes.prodNatEquiv (fun m : {n : ℕ // IsPrimePow n} => F m.val)] ++ apply tsum_congr ++ intro pk ++ rw [Nat.Primes.coe_prodNatEquiv_apply, hF] ++ exact (hpoint pk.1 pk.2).symm ++ ++ rw [hSr_double, ← hsummable_g.tsum_prod' (fun p => (htaylor p).summable), hprod_eq] ++ exact tsum_subtype_eq_of_support_subset hsupp ++ ++section ++open MeasureTheory Set ++ ++namespace LogZetaInteg ++ ++private noncomputable def c (d : ℕ) : ℝ := Λ d / (d * Real.log d) ++ ++private noncomputable def f (s : ℝ) (d : ℕ) (x : ℝ) : ℝ := ++ c d * (Set.Ici (d:ℝ)).indicator (fun x => x ^ (-s)) x ++ ++@[simp] private lemma c_zero : c 0 = 0 := by simp [c] ++@[simp] private lemma c_one : c 1 = 0 := by simp [c, vonMangoldt_apply_one] ++ ++private lemma c_nonneg (d : ℕ) : 0 ≤ c d := by ++ unfold c ++ rcases Nat.eq_zero_or_pos d with hd | hd ++ · subst hd; simp ++ · apply div_nonneg vonMangoldt_nonneg ++ have : (0:ℝ) ≤ (d:ℝ) := Nat.cast_nonneg d ++ have hlog : 0 ≤ Real.log d := Real.log_natCast_nonneg d ++ positivity ++ ++private lemma summable_log_rpow_div_rpow (a : ℝ) {s : ℝ} (hs : 1 < s) : ++ Summable (fun n : ℕ => (Real.log n) ^ a / (n:ℝ) ^ s) := by ++ have hε : (0:ℝ) < (s - 1) / 2 := by linarith ++ refine summable_of_isBigO_nat (g := fun n : ℕ => (n:ℝ) ^ ((s - 1) / 2 - s)) ?_ ?_ ++ · rw [Real.summable_nat_rpow]; linarith ++ · have ho : (fun x : ℝ => (Real.log x) ^ a) =O[atTop] (fun x : ℝ => x ^ ((s - 1) / 2)) := ++ (isLittleO_log_rpow_rpow_atTop a hε).isBigO ++ have hmul : (fun x : ℝ => (Real.log x) ^ a / x ^ s) ++ =O[atTop] (fun x : ℝ => x ^ ((s - 1) / 2) / x ^ s) := by ++ simpa only [div_eq_mul_inv] using ho.mul (isBigO_refl (fun x : ℝ => (x ^ s)⁻¹) atTop) ++ have heq : (fun x : ℝ => x ^ ((s - 1) / 2) / x ^ s) ++ =ᶠ[atTop] (fun x : ℝ => x ^ ((s - 1) / 2 - s)) := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ rw [← Real.rpow_sub hx] ++ exact (hmul.trans_eventuallyEq heq).natCast_atTop ++ ++private lemma summable_vonMangoldt_div_rpow (s : ℝ) (hs : 1 < s) : ++ Summable (fun n : ℕ => (Λ n : ℝ) / (n:ℝ) ^ s) := by ++ refine Summable.of_nonneg_of_le (fun n => div_nonneg vonMangoldt_nonneg (by positivity)) ?_ ++ (summable_log_rpow_div_rpow 1 hs) ++ intro n ++ rw [Real.rpow_one] ++ gcongr ++ exact vonMangoldt_le_log ++ ++private lemma summable_c_term (s : ℝ) (hs : 1 < s) : ++ Summable (fun d : ℕ => c d * ((d:ℝ) ^ (1 - s) / (s - 1))) := by ++ have hs1 : (0:ℝ) < s - 1 := by linarith ++ have hlog2 : (0:ℝ) < Real.log 2 := Real.log_pos (by norm_num) ++ ++ refine Summable.of_nonneg_of_le (fun d => ?_) (fun d => ?_) ++ ((summable_vonMangoldt_div_rpow s hs).mul_left (1 / (Real.log 2 * (s - 1)))) ++ · ++ refine mul_nonneg (c_nonneg d) (div_nonneg ?_ hs1.le) ++ rcases eq_or_ne (d:ℝ) 0 with hd | hd ++ · rw [hd, Real.zero_rpow (by linarith : (1 - s) ≠ 0)] ++ · positivity ++ · ++ rcases lt_or_ge d 2 with hd | hd ++ · have hc : c d = 0 := by interval_cases d <;> simp ++ rw [hc, zero_mul] ++ exact mul_nonneg (by positivity) (div_nonneg vonMangoldt_nonneg (by positivity)) ++ · have hd2 : (2:ℝ) ≤ (d:ℝ) := by exact_mod_cast hd ++ have hd0 : (0:ℝ) < (d:ℝ) := by linarith ++ have hlogge : Real.log 2 ≤ Real.log d := Real.log_le_log (by norm_num) hd2 ++ have hds : (0:ℝ) < (d:ℝ) ^ s := Real.rpow_pos_of_pos hd0 s ++ have hkey : c d * ((d:ℝ) ^ (1 - s) / (s - 1)) = Λ d / ((d:ℝ) ^ s * Real.log d * (s - 1)) := by ++ unfold c ++ rw [show (1 - s : ℝ) = -s + 1 by ring, Real.rpow_add hd0, Real.rpow_one, Real.rpow_neg hd0.le] ++ field_simp ++ ++ have hcb : (d:ℝ) ^ s * Real.log 2 * (s - 1) ≤ (d:ℝ) ^ s * Real.log d * (s - 1) := ++ mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hlogge hds.le) hs1.le ++ rw [hkey, show (1 / (Real.log 2 * (s - 1))) * ((Λ d : ℝ) / (d:ℝ) ^ s) ++ = Λ d / ((d:ℝ) ^ s * Real.log 2 * (s - 1)) from by field_simp] ++ exact div_le_div_of_nonneg_left vonMangoldt_nonneg (by positivity) hcb ++ ++theorem log_zeta_eq_integ_aux (s : ℝ) (hs : 1 < s) : ++ Real.log (riemannZeta (s:ℂ)).re = ++ (s - 1) * ∫ x in Set.Ioi 1, (Real.log (Real.log x) + γ + E₂Λ x) * x ^ (-s) := by ++ rw [Mertens.log_zeta_eq_sum s hs] ++ symm ++ have hstep1 : ∀ x ∈ Set.Ioi (1:ℝ), ++ (Real.log (Real.log x) + γ + E₂Λ x) * x ^ (-s) ++ = (∑ d ∈ Finset.Ioc 0 ⌊x⌋₊, c d) * x ^ (-s) := by ++ intro x hx ++ simp only [Mertens.E₂Λ, c] ++ ring ++ have hstep2 : ∀ x ∈ Set.Ioi (1:ℝ), ++ (Real.log (Real.log x) + γ + E₂Λ x) * x ^ (-s) = ∑' d : ℕ, f s d x := by ++ intro x hx ++ rw [hstep1 x hx] ++ simp only [f] ++ rw [Finset.sum_mul] ++ have hx0 : (0:ℝ) ≤ x := by have := hx; simp only [Set.mem_Ioi] at this; linarith ++ rw [tsum_eq_sum (s := Finset.Ioc 0 ⌊x⌋₊) ?_] ++ · apply Finset.sum_congr rfl ++ intro d hd ++ simp only [Finset.mem_Ioc] at hd ++ have hdx : (d:ℝ) ≤ x := by ++ rw [← Nat.le_floor_iff hx0]; exact hd.2 ++ rw [Set.indicator_of_mem (by simpa using hdx)] ++ · intro d hd ++ simp only [Finset.mem_Ioc, not_and, not_le] at hd ++ rcases Nat.eq_zero_or_pos d with hd0 | hd0 ++ · subst hd0; simp ++ · have hfloor : ⌊x⌋₊ < d := hd hd0 ++ have hdx : x < (d:ℝ) := by ++ rw [← Nat.floor_lt hx0]; exact hfloor ++ rw [Set.indicator_of_notMem (by simpa using not_le.mpr hdx)] ++ ring ++ rw [MeasureTheory.setIntegral_congr_fun measurableSet_Ioi hstep2] ++ have hperterm : ∀ d : ℕ, ∫ x in Set.Ioi (1:ℝ), f s d x = c d * ((d:ℝ) ^ (1 - s) / (s - 1)) := by ++ intro d ++ rcases Nat.eq_zero_or_pos d with hd0 | hd0 ++ · subst hd0; simp [f] ++ simp only [f] ++ rw [MeasureTheory.integral_const_mul, MeasureTheory.setIntegral_indicator measurableSet_Ici] ++ congr 1 ++ have hdR : (1:ℝ) ≤ (d:ℝ) := by exact_mod_cast hd0 ++ have hdR0 : (0:ℝ) < (d:ℝ) := by exact_mod_cast hd0 ++ set A : Set ℝ := Set.Ioi (1:ℝ) ∩ Set.Ici (d:ℝ) with hA ++ have hae : A =ᵐ[volume] Set.Ioi (d:ℝ) := by ++ have h1 : A =ᵐ[volume] (Set.Ici (1:ℝ) ∩ Set.Ici (d:ℝ) : Set ℝ) := ++ MeasureTheory.ae_eq_set_inter MeasureTheory.Ioi_ae_eq_Ici (ae_eq_refl _) ++ rw [Set.Ici_inter_Ici, max_eq_right hdR] at h1 ++ exact h1.trans MeasureTheory.Ioi_ae_eq_Ici.symm ++ rw [MeasureTheory.setIntegral_congr_set hae] ++ rw [integral_Ioi_rpow_of_lt (by linarith : (-s:ℝ) < -1) hdR0, ++ show (-s + 1 : ℝ) = 1 - s by ring] ++ have hs1 : (1 - s) ≠ 0 := by linarith ++ have hs2 : (s - 1) ≠ 0 := by linarith ++ field_simp ++ ring ++ have hint : ∀ d : ℕ, MeasureTheory.IntegrableOn (f s d) (Set.Ioi (1:ℝ)) := by ++ intro d ++ unfold f ++ apply MeasureTheory.Integrable.const_mul ++ rw [show MeasureTheory.Integrable ((Set.Ici (d:ℝ)).indicator fun x => x ^ (-s)) ++ (volume.restrict (Set.Ioi (1:ℝ))) ++ ↔ MeasureTheory.IntegrableOn ((Set.Ici (d:ℝ)).indicator fun x => x ^ (-s)) ++ (Set.Ioi (1:ℝ)) volume from Iff.rfl, ++ MeasureTheory.integrableOn_indicator_iff measurableSet_Ici] ++ apply MeasureTheory.IntegrableOn.mono_set ++ (integrableOn_Ioi_rpow_of_lt (by linarith : (-s:ℝ) < -1) (by norm_num : (0:ℝ) < 1/2)) ++ intro x hx ++ simp only [Set.mem_inter_iff, Set.mem_Ici, Set.mem_Ioi] at hx ⊢ ++ linarith [hx.2] ++ have hnorm_int : ∀ d : ℕ, ++ ∫ x in Set.Ioi (1:ℝ), ‖f s d x‖ = c d * ((d:ℝ) ^ (1 - s) / (s - 1)) := by ++ intro d ++ rw [← hperterm d] ++ apply MeasureTheory.setIntegral_congr_fun measurableSet_Ioi ++ intro x hx ++ simp only [Set.mem_Ioi] at hx ++ have hfnn : 0 ≤ f s d x := by ++ simp only [f] ++ apply mul_nonneg (c_nonneg d) ++ by_cases hxd : (d:ℝ) ≤ x ++ · rw [Set.indicator_of_mem (by simpa using hxd)] ++ exact le_of_lt (Real.rpow_pos_of_pos (by linarith) _) ++ · rw [Set.indicator_of_notMem (by simpa using hxd)] ++ change ‖f s d x‖ = f s d x ++ rw [Real.norm_eq_abs, abs_of_nonneg hfnn] ++ have hinterchange : ∫ x in Set.Ioi (1:ℝ), ∑' d : ℕ, f s d x ++ = ∑' d : ℕ, ∫ x in Set.Ioi (1:ℝ), f s d x := by ++ refine (MeasureTheory.integral_tsum_of_summable_integral_norm hint ?_).symm ++ apply (summable_c_term s hs).congr ++ intro d ++ exact (hnorm_int d).symm ++ rw [hinterchange] ++ simp_rw [hperterm] ++ rw [← tsum_mul_left] ++ apply tsum_congr ++ intro d ++ rcases Nat.eq_zero_or_pos d with hd0 | hd0 ++ · subst hd0; simp ++ · have hdR : (0:ℝ) < (d:ℝ) := by exact_mod_cast hd0 ++ have hsub : (d:ℝ) ^ (1 - s) = (d:ℝ) ^ (-s) * (d:ℝ) := by ++ rw [show (1 - s : ℝ) = -s + 1 by ring, Real.rpow_add hdR, Real.rpow_one] ++ have hs1 : s - 1 ≠ 0 := by linarith ++ have hneg : (d:ℝ) ^ (-s) = ((d:ℝ) ^ s)⁻¹ := by ++ rw [Real.rpow_neg (le_of_lt hdR)] ++ unfold c ++ rw [hsub, hneg] ++ field_simp ++ ++end LogZetaInteg ++end ++ ++private theorem log_zeta_eq_integ (s : ℝ) (hs : 1 < s) : ++ log (riemannZeta (s:ℂ)).re = (s - 1) * ∫ x in .Ioi 1, (log (log x) + γ + E₂Λ x) * x^(-s) := ++ LogZetaInteg.log_zeta_eq_integ_aux s hs ++ ++private theorem mul_integ_log_log_eq (s : ℝ) (hs : 1 < s) : ++ (s - 1) * ∫ x in .Ioi 1, log (log x) * x^(-s) = - log (s - 1) + deriv Gamma 1 := ++ mul_integ_log_log_eq_aux s hs ++ ++private theorem mul_integ_gamma_eq (s) (hs : 1 < s) : (s - 1) * ∫ x in .Ioi 1, γ * x^(-s) = γ := by ++ rw [MeasureTheory.integral_const_mul γ (· ^ (-s)), @integral_Ioi_rpow_of_lt (-s), one_rpow] <;> ++ grind ++ ++private theorem integrableOn_Ioi_mul_rpow_neg_of_abs_le ++ {c B a s : ℝ} (hc : 0 < c) (has : a + 1 < s) {f : ℝ → ℝ} (hf : Measurable f) ++ (hbound : ∀ x ∈ Set.Ioi c, |f x| ≤ B * x ^ a) : ++ MeasureTheory.IntegrableOn (fun x => f x * x ^ (-s)) (Set.Ioi c) := by ++ have hg : MeasureTheory.IntegrableOn (fun x => B * x ^ (a - s)) (Set.Ioi c) := ++ (integrableOn_Ioi_rpow_of_lt (by linarith : a - s < -1) hc).const_mul B ++ refine MeasureTheory.Integrable.mono' hg ++ (hf.mul (measurable_id.pow_const (-s))).aestronglyMeasurable ?_ ++ filter_upwards [MeasureTheory.ae_restrict_mem measurableSet_Ioi] with x hx ++ have hxpos : (0:ℝ) < x := hc.trans hx ++ have hxs : (0:ℝ) < x ^ (-s) := Real.rpow_pos_of_pos hxpos _ ++ rw [norm_mul, norm_eq_abs, norm_eq_abs, abs_of_pos hxs] ++ calc |f x| * x ^ (-s) ≤ B * x ^ a * x ^ (-s) := ++ mul_le_mul_of_nonneg_right (hbound x hx) hxs.le ++ _ = B * x ^ (a - s) := by rw [mul_assoc, ← Real.rpow_add hxpos, sub_eq_add_neg] ++ ++private theorem integrableOn_log_log_mul_rpow (s : ℝ) (hs : 1 < s) : ++ MeasureTheory.IntegrableOn (fun x => log (log x) * x ^ (-s)) (Set.Ioi 1) := by ++ rw [← Set.Ioc_union_Ioi_eq_Ioi (by norm_num : (1:ℝ) ≤ 2)] ++ apply MeasureTheory.IntegrableOn.union ++ · ++ have hll : MeasureTheory.IntegrableOn (fun x => log (log x)) (Set.Ioc 1 2) := by ++ have h : IntervalIntegrable (log ∘ log) MeasureTheory.volume 1 2 := by ++ apply MeromorphicOn.intervalIntegrable_log ++ intro x hx ++ rw [Set.uIcc_of_le (by norm_num : (1:ℝ) ≤ 2)] at hx ++ exact (analyticAt_log (by linarith [hx.1] : 0 < x)).meromorphicAt ++ exact (intervalIntegrable_iff_integrableOn_Ioc_of_le (by norm_num)).mp h ++ have hmul : MeasureTheory.IntegrableOn (fun x => x ^ (-s) * log (log x)) (Set.Ioc 1 2) := by ++ apply hll.bdd_mul (c := 1) ++ · fun_prop ++ · filter_upwards [MeasureTheory.ae_restrict_mem measurableSet_Ioc] with x hx ++ rw [norm_eq_abs, abs_of_nonneg (Real.rpow_nonneg (by linarith [hx.1] : (0:ℝ) ≤ x) _)] ++ calc x ^ (-s) ≤ (1:ℝ) ^ (-s) := ++ Real.rpow_le_rpow_of_nonpos (by norm_num) hx.1.le (by linarith) ++ _ = 1 := Real.one_rpow _ ++ simpa [mul_comm] using hmul ++ · ++ set ε := (s - 1) / 2 with hε ++ have hεpos : 0 < ε := by rw [hε]; linarith ++ refine integrableOn_Ioi_mul_rpow_neg_of_abs_le (a := ε) (B := 1 / ε + |log (log 2)|) ++ (by norm_num) (by rw [hε]; linarith) (Real.measurable_log.comp Real.measurable_log) ?_ ++ intro x hx ++ simp only [Set.mem_Ioi] at hx ++ have hx1 : (1:ℝ) ≤ x ^ ε := Real.one_le_rpow (by linarith) hεpos.le ++ have hlogx : 0 < log x := Real.log_pos (by linarith) ++ have hlog2 : 0 < log 2 := Real.log_pos (by norm_num) ++ have hmono : log 2 ≤ log x := Real.log_le_log (by norm_num) (by linarith) ++ have hub : log (log x) ≤ x ^ ε / ε := ++ calc log (log x) ≤ log x := (Real.log_le_sub_one_of_pos hlogx).trans (by linarith) ++ _ ≤ x ^ ε / ε := Real.log_le_rpow_div (by linarith) hεpos ++ have hlb : log (log 2) ≤ log (log x) := Real.log_le_log hlog2 hmono ++ have hxε : 0 ≤ x ^ ε / ε := by positivity ++ calc |log (log x)| ≤ x ^ ε / ε + |log (log 2)| := by ++ rw [abs_le] ++ exact ⟨by linarith [neg_abs_le (log (log 2))], ++ by linarith [abs_nonneg (log (log 2))]⟩ ++ _ ≤ (1 / ε + |log (log 2)|) * x ^ ε := by ++ have h2 : |log (log 2)| ≤ |log (log 2)| * x ^ ε := le_mul_of_one_le_right (abs_nonneg _) hx1 ++ have h1 : x ^ ε / ε = 1 / ε * x ^ ε := by ring ++ rw [add_mul]; linarith ++ ++private theorem integrableOn_γ_mul_rpow (s : ℝ) (hs : 1 < s) : ++ MeasureTheory.IntegrableOn (fun x => γ * x ^ (-s)) (Set.Ioi 1) := by ++ exact (integrableOn_Ioi_rpow_of_lt (by linarith : -s < -1) one_pos).const_mul γ ++ ++private theorem integrableOn_E₂Λ_mul_rpow (s : ℝ) (hs : 1 < s) : ++ MeasureTheory.IntegrableOn (fun x => E₂Λ x * x ^ (-s)) (Set.Ioi 1) := by ++ rw [← Set.Ioo_union_Ici_eq_Ioi (by norm_num : (1:ℝ) < 2)] ++ apply MeasureTheory.IntegrableOn.union ++ · ++ have hsub : Set.Ioo (1:ℝ) 2 ⊆ Set.Ioi 1 := fun x hx => hx.1 ++ have h1 := (integrableOn_γ_mul_rpow s hs).mono_set hsub ++ have h2 := (integrableOn_log_log_mul_rpow s hs).mono_set hsub ++ have hb : MeasureTheory.IntegrableOn ++ (fun x => -(log (log x) * x ^ (-s)) - γ * x ^ (-s)) (Set.Ioo 1 2) := ++ h2.neg.sub h1 ++ apply hb.congr_fun _ measurableSet_Ioo ++ intro x hx ++ simp only [Set.mem_Ioo] at hx ++ have hfloor : ⌊ x ⌋₊ = 1 := by ++ rw [Nat.floor_eq_iff (by linarith)] ++ exact ⟨by push_cast; linarith [hx.1], by push_cast; linarith [hx.2]⟩ ++ have hsum : (∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / ((d:ℝ) * log d)) = 0 := by rw [hfloor]; norm_num ++ change -(log (log x) * x ^ (-s)) - γ * x ^ (-s) ++ = (∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) - log (log x) - γ) * x ^ (-s) ++ rw [hsum]; ring ++ · ++ rw [integrableOn_Ici_iff_integrableOn_Ioi] ++ refine integrableOn_Ioi_mul_rpow_neg_of_abs_le (a := 0) (B := (log 4 + 6) / log 2) ++ (by norm_num) (by linarith) (by fun_prop) ?_ ++ intro x hx ++ simp only [Set.mem_Ioi] at hx ++ have hlog2 : 0 < log 2 := Real.log_pos (by norm_num) ++ have hc : 0 ≤ log 4 + 6 := by positivity ++ rw [Real.rpow_zero, mul_one] ++ have hb2 : (log 4 + 6) / log x ≤ (log 4 + 6) / log 2 := ++ div_le_div_of_nonneg_left hc hlog2 (Real.log_le_log (by norm_num) (le_of_lt hx)) ++ exact (E₂Λ.abs_le (le_of_lt hx)).trans hb2 ++ ++private theorem log_zeta_eq (s : ℝ) (hs : 1 < s) : ++ log (riemannZeta (s:ℂ)).re = - log (s - 1) + deriv Gamma 1 + γ + (s - 1) * ∫ x in Set.Ioi 1, E₂Λ x * x^(-s) := by ++ ++ rw [log_zeta_eq_integ s hs] ++ ++ have key : (∫ x in Set.Ioi 1, (log (log x) + γ + E₂Λ x) * x ^ (-s)) ++ = (∫ x in Set.Ioi 1, log (log x) * x ^ (-s)) ++ + (∫ x in Set.Ioi 1, γ * x ^ (-s)) ++ + (∫ x in Set.Ioi 1, E₂Λ x * x ^ (-s)) := by ++ rw [← MeasureTheory.integral_add (integrableOn_log_log_mul_rpow s hs) ++ (integrableOn_γ_mul_rpow s hs)] ++ rw [← MeasureTheory.integral_add (f := fun x => log (log x) * x ^ (-s) + γ * x ^ (-s)) ++ (g := fun x => E₂Λ x * x ^ (-s)) ++ ((integrableOn_log_log_mul_rpow s hs).add (integrableOn_γ_mul_rpow s hs)) ++ (integrableOn_E₂Λ_mul_rpow s hs)] ++ apply MeasureTheory.setIntegral_congr_fun measurableSet_Ioi ++ intro x _ ++ ring ++ ++ rw [key, mul_add, mul_add, mul_integ_log_log_eq s hs, mul_integ_gamma_eq s hs] ++ ++private lemma zeta_pole_mul_re_tendsto_one : ++ Filter.Tendsto (fun s : ℝ => (s - 1) * (riemannZeta (s : ℂ)).re) ++ (nhdsWithin 1 (Set.Ioi 1)) (nhds 1) := by ++ have hofReal : ++ Filter.Tendsto (fun s : ℝ => (s : ℂ)) (nhdsWithin 1 (Set.Ioi 1)) ++ (nhdsWithin (1 : ℂ) ({1} : Set ℂ)ᶜ) := by ++ refine tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ ?_ ?_ ++ · exact (Complex.continuous_ofReal.tendsto 1).mono_left nhdsWithin_le_nhds ++ · filter_upwards [self_mem_nhdsWithin] with s hs ++ exact Set.mem_compl_singleton_iff.mpr (by ++ norm_num ++ exact ne_of_gt (Set.mem_Ioi.mp hs)) ++ have hcomplex : ++ Filter.Tendsto (fun s : ℝ => ((s : ℂ) - 1) * riemannZeta (s : ℂ)) ++ (nhdsWithin 1 (Set.Ioi 1)) (nhds 1) := ++ riemannZeta_residue_one.comp hofReal ++ have hreal : ++ Filter.Tendsto ++ (fun s : ℝ => (((s : ℂ) - 1) * riemannZeta (s : ℂ)).re) ++ (nhdsWithin 1 (Set.Ioi 1)) (nhds (1 : ℝ)) := ++ (Complex.continuous_re.tendsto (1 : ℂ)).comp hcomplex ++ simpa [Complex.ofReal_sub, Complex.ofReal_mul] using hreal ++ ++private theorem log_zeta_limit : ++ Filter.Tendsto ++ (fun s : ℝ => Real.log (riemannZeta (s : ℂ)).re + Real.log (s - 1)) ++ (nhdsWithin 1 (Set.Ioi 1)) (nhds 0) := by ++ have hlog : ++ Filter.Tendsto ++ (fun s : ℝ => Real.log ((s - 1) * (riemannZeta (s : ℂ)).re)) ++ (nhdsWithin 1 (Set.Ioi 1)) (nhds (Real.log 1)) := ++ (Real.continuousAt_log (by norm_num : (1 : ℝ) ≠ 0)).tendsto.comp ++ zeta_pole_mul_re_tendsto_one ++ have hEq : ++ (fun s : ℝ => Real.log (riemannZeta (s : ℂ)).re + Real.log (s - 1)) ++ =ᶠ[nhdsWithin 1 (Set.Ioi 1)] ++ fun s : ℝ => Real.log ((s - 1) * (riemannZeta (s : ℂ)).re) := by ++ filter_upwards [self_mem_nhdsWithin] with s hs ++ have hspos : 0 < s - 1 := sub_pos.mpr (Set.mem_Ioi.mp hs) ++ have hzpos : 0 < (riemannZeta (s : ℂ)).re := ++ riemannZeta_re_pos_of_one_lt (Set.mem_Ioi.mp hs) ++ rw [Real.log_mul hspos.ne' hzpos.ne'] ++ ring ++ simpa using hlog.congr' (hEq.mono fun s hs => hs.symm) ++ ++section ++open MeasureTheory Set ++ ++private lemma measurable_E₂Λ : Measurable E₂Λ := by fun_prop ++ ++private lemma E₂Λ_eq_on_Ioo {x : ℝ} (hx : x ∈ Set.Ioo (1 : ℝ) 2) : ++ E₂Λ x = - log (log x) - γ := by ++ obtain ⟨h1, h2⟩ := hx ++ have hf : ⌊x⌋₊ = 1 := by ++ rw [Nat.floor_eq_iff (by linarith)] ++ exact ⟨by exact_mod_cast h1.le, by exact_mod_cast h2⟩ ++ unfold E₂Λ ++ rw [hf] ++ simp ++ ++private lemma abs_E₂Λ_le_on_Ioo {x : ℝ} (hx : x ∈ Set.Ioo (1 : ℝ) 2) : ++ |E₂Λ x| ≤ |log (x - 1)| + log 2 + |γ| := by ++ obtain ⟨hx1, hx2⟩ := hx ++ have hloglog : |log (log x)| ≤ |log (x - 1)| + log 2 := by ++ have hxpos : (0:ℝ) < x := by linarith ++ have hlogx_pos : 0 < log x := Real.log_pos hx1 ++ have hxm1 : 0 < x - 1 := by linarith ++ have hub : log x ≤ x - 1 := by have := Real.log_le_sub_one_of_pos hxpos; linarith ++ have hlb2 : (x - 1) / 2 ≤ log x := by ++ have h := Real.log_le_sub_one_of_pos (x := 1 / x) (by positivity) ++ rw [Real.log_div one_ne_zero (by positivity), Real.log_one] at h ++ simp only [zero_sub] at h ++ have h12 : (x - 1) / 2 ≤ 1 - 1 / x := by ++ rw [← sub_nonneg] ++ have e : (1 - 1 / x) - (x - 1) / 2 = (3 * x - 2 - x ^ 2) / (2 * x) := by field_simp; ring ++ rw [e]; exact div_nonneg (by nlinarith [hx1, hx2]) (by positivity) ++ linarith ++ have hupper : log (log x) ≤ log (x - 1) := Real.log_le_log hlogx_pos hub ++ have hlower : log (x - 1) - log 2 ≤ log (log x) := by ++ have := Real.log_le_log (show (0:ℝ) < (x - 1) / 2 by positivity) hlb2 ++ rwa [Real.log_div (by linarith) (by norm_num)] at this ++ have h2 : (0:ℝ) ≤ log 2 := Real.log_nonneg (by norm_num) ++ rw [abs_le] ++ exact ⟨by have := neg_abs_le (log (x - 1)); linarith, ++ by have := le_abs_self (log (x - 1)); linarith⟩ ++ rw [E₂Λ_eq_on_Ioo ⟨hx1, hx2⟩] ++ have htri : |(- log (log x) - γ)| ≤ |log (log x)| + |γ| := by ++ have h := abs_sub (-log (log x)) γ ++ rwa [abs_neg] at h ++ linarith ++ ++private lemma abs_E₂Λ_le_const {x : ℝ} (hx : 2 ≤ x) : ++ |E₂Λ x| ≤ (log 4 + 6) / log 2 := ++ (E₂Λ.abs_le hx).trans <| div_le_div_of_nonneg_left (by positivity) ++ (Real.log_pos (by norm_num)) (Real.log_le_log (by norm_num) hx) ++ ++private lemma integrableOn_log_sub_one_bound : ++ IntegrableOn (fun x => |log (x - 1)| + log 2 + |γ|) (Set.Ioo 1 2) volume := by ++ have hlog : IntegrableOn (fun x => |log (x - 1)|) (Set.Ioo 1 2) volume := by ++ have h0 : IntervalIntegrable (fun x => log x) volume 0 1 := ++ intervalIntegral.intervalIntegrable_log' ++ have h1 : IntervalIntegrable (fun x => log (x - 1)) volume (0 + 1) (1 + 1) := ++ h0.comp_sub_right 1 ++ norm_num at h1 ++ exact (h1.1.mono_set Set.Ioo_subset_Ioc_self).abs ++ have hc : IntegrableOn (fun _ : ℝ => log 2 + |γ|) (Set.Ioo (1 : ℝ) 2) volume := ++ integrableOn_const (measure_Ioo_lt_top).ne (by finiteness) ++ have hsum : IntegrableOn (fun x => |log (x - 1)| + (log 2 + |γ|)) (Set.Ioo 1 2) volume := ++ hlog.add hc ++ exact hsum.congr_fun (fun x _ => by ring) measurableSet_Ioo ++ ++private lemma integrableOn_E₂Λ_Ioo {X : ℝ} (_hX : 2 ≤ X) : ++ IntegrableOn E₂Λ (Set.Ioo 1 X) volume := by ++ have hsub : Set.Ioo (1 : ℝ) X ⊆ Set.Ioo 1 2 ∪ Set.Icc 2 X := by ++ intro x hx; simp only [Set.mem_Ioo, Set.mem_union, Set.mem_Icc] at * ++ rcases lt_or_ge x 2 with h | h ++ · exact Or.inl ⟨hx.1, h⟩ ++ · exact Or.inr ⟨h, hx.2.le⟩ ++ apply IntegrableOn.mono_set _ hsub ++ apply IntegrableOn.union ++ · have hg := integrableOn_log_sub_one_bound ++ refine Integrable.mono' hg measurable_E₂Λ.aestronglyMeasurable ?_ ++ filter_upwards [self_mem_ae_restrict measurableSet_Ioo] with x hx ++ rw [Real.norm_eq_abs]; exact abs_E₂Λ_le_on_Ioo hx ++ · refine Integrable.mono' (g := fun _ => (log 4 + 6) / log 2) ?_ ++ measurable_E₂Λ.aestronglyMeasurable ?_ ++ · exact integrableOn_const (by rw [Real.volume_Icc]; exact ENNReal.ofReal_ne_top) (by finiteness) ++ · filter_upwards [self_mem_ae_restrict measurableSet_Icc] with x hx ++ rw [Real.norm_eq_abs]; exact abs_E₂Λ_le_const hx.1 ++ ++private lemma sub_one_mul_integral_E₂Λ_tendsto : ++ Filter.Tendsto (fun s : ℝ => (s - 1) * ∫ x in Set.Ioi 1, E₂Λ x * x ^ (-s)) ++ (nhdsWithin 1 (Set.Ioi 1)) (nhds 0) := by ++ rw [Metric.tendsto_nhdsWithin_nhds] ++ intro ε hε ++ ++ obtain ⟨X₀, hX₀⟩ : ∃ X, ∀ x ≥ X, |E₂Λ x| ≤ ε / 2 := by ++ have := E₂Λ.bound'.def (by positivity : (0:ℝ) < ε / 2) ++ simp only [Real.norm_eq_abs, abs_one, mul_one] at this ++ rw [Filter.eventually_atTop] at this; exact this ++ set X := max X₀ 2 with hXdef ++ have hX2 : 2 ≤ X := le_max_right _ _ ++ have hXge : ∀ x ≥ X, |E₂Λ x| ≤ ε / 2 := fun x hx => hX₀ x (le_trans (le_max_left _ _) hx) ++ ++ set B := ∫ x in Set.Ioo 1 X, |E₂Λ x| with hBdef ++ have hB0 : 0 ≤ B := setIntegral_nonneg measurableSet_Ioo (fun x _ => abs_nonneg _) ++ refine ⟨min 1 (ε / 2 / (B + 1)), by positivity, ?_⟩ ++ intro s hs hdist ++ simp only [Set.mem_Ioi] at hs ++ rw [Real.dist_eq] at hdist ++ have hs1 : s - 1 < min 1 (ε / 2 / (B + 1)) := by ++ rw [abs_of_pos (by linarith)] at hdist; exact hdist ++ have hsm1 : 0 < s - 1 := by linarith ++ ++ have hintAbs : IntegrableOn (fun x => |E₂Λ x| * x ^ (-s)) (Set.Ioi 1) volume := by ++ have h2 : IntegrableOn (fun x => |E₂Λ x * x ^ (-s)|) (Set.Ioi 1) volume := ++ (integrableOn_E₂Λ_mul_rpow s hs).abs ++ refine h2.congr_fun ?_ measurableSet_Ioi ++ intro x hx; simp only [Set.mem_Ioi] at hx ++ change |E₂Λ x * x ^ (-s)| = |E₂Λ x| * x ^ (-s) ++ rw [abs_mul, abs_of_nonneg (Real.rpow_nonneg (by linarith) _)] ++ have hintAbsIoc : IntegrableOn (fun x => |E₂Λ x| * x ^ (-s)) (Set.Ioc 1 X) volume := ++ hintAbs.mono_set Set.Ioc_subset_Ioi_self ++ have hintAbsIoiX : IntegrableOn (fun x => |E₂Λ x| * x ^ (-s)) (Set.Ioi X) volume := ++ hintAbs.mono_set (Set.Ioi_subset_Ioi (by linarith)) ++ ++ have hsplit : ∫ x in Set.Ioi 1, |E₂Λ x| * x ^ (-s) = ++ (∫ x in Set.Ioc 1 X, |E₂Λ x| * x ^ (-s)) + ∫ x in Set.Ioi X, |E₂Λ x| * x ^ (-s) := by ++ have hu : Set.Ioi (1:ℝ) = Set.Ioc 1 X ∪ Set.Ioi X := ++ (Set.Ioc_union_Ioi_eq_Ioi (by linarith)).symm ++ rw [hu, setIntegral_union (Set.Ioc_disjoint_Ioi le_rfl) measurableSet_Ioi ++ (hintAbs.mono_set (by rw [hu]; exact Set.subset_union_left)) ++ (hintAbs.mono_set (by rw [hu]; exact Set.subset_union_right))] ++ ++ have hp1 : ∫ x in Set.Ioc 1 X, |E₂Λ x| * x ^ (-s) ≤ B := by ++ rw [hBdef] ++ have ha : IntegrableOn (fun x => |E₂Λ x|) (Set.Ioo 1 X) volume := (integrableOn_E₂Λ_Ioo hX2).abs ++ have habsIoc : IntegrableOn (fun x => |E₂Λ x|) (Set.Ioc 1 X) volume := ++ ha.congr_set_ae (Ioo_ae_eq_Ioc).symm ++ rw [← integral_Ioc_eq_integral_Ioo] ++ apply setIntegral_mono_on hintAbsIoc habsIoc measurableSet_Ioc ++ intro x hx ++ have hx1 : (1:ℝ) ≤ x := by have := hx.1; linarith ++ have hle1 : x ^ (-s) ≤ 1 := Real.rpow_le_one_of_one_le_of_nonpos hx1 (by linarith) ++ calc |E₂Λ x| * x ^ (-s) ≤ |E₂Λ x| * 1 := by gcongr ++ _ = |E₂Λ x| := mul_one _ ++ ++ have hp2 : ∫ x in Set.Ioi X, |E₂Λ x| * x ^ (-s) ≤ (ε / 2) * (X ^ (1 - s) / (s - 1)) := by ++ have hrpow_int : IntegrableOn (fun x : ℝ => x ^ (-s)) (Set.Ioi X) volume := ++ integrableOn_Ioi_rpow_of_lt (by linarith) (by linarith : (0:ℝ) < X) ++ have hval : ∫ x in Set.Ioi X, x ^ (-s) = X ^ (1 - s) / (s - 1) := by ++ rw [integral_Ioi_rpow_of_lt (by linarith) (by linarith : (0:ℝ) < X), ++ show -s + 1 = 1 - s by ring, show (1:ℝ) - s = -(s - 1) by ring] ++ rw [div_neg, neg_div, neg_neg] ++ rw [← hval, ← integral_const_mul] ++ apply setIntegral_mono_on hintAbsIoiX (hrpow_int.const_mul (ε / 2)) measurableSet_Ioi ++ intro x hx ++ have hxpos : (0:ℝ) < x := by simp only [Set.mem_Ioi] at hx; linarith ++ have hnn : 0 ≤ x ^ (-s) := Real.rpow_nonneg hxpos.le _ ++ have hb : |E₂Λ x| ≤ ε / 2 := hXge x (by simp only [Set.mem_Ioi] at hx; linarith) ++ gcongr ++ have hXpow : X ^ (1 - s) ≤ 1 := ++ Real.rpow_le_one_of_one_le_of_nonpos (by linarith) (by linarith) ++ ++ have hbound : (s - 1) * ∫ x in Set.Ioi 1, |E₂Λ x| * x ^ (-s) ≤ (s - 1) * B + ε / 2 := by ++ rw [hsplit, mul_add] ++ have ht2 : (s - 1) * ∫ x in Set.Ioi X, |E₂Λ x| * x ^ (-s) ≤ ε / 2 := by ++ calc (s - 1) * ∫ x in Set.Ioi X, |E₂Λ x| * x ^ (-s) ++ ≤ (s - 1) * ((ε / 2) * (X ^ (1 - s) / (s - 1))) := ++ mul_le_mul_of_nonneg_left hp2 hsm1.le ++ _ = (ε / 2) * X ^ (1 - s) := by ++ have hne : s - 1 ≠ 0 := by linarith ++ field_simp ++ _ ≤ (ε / 2) * 1 := by gcongr ++ _ = ε / 2 := mul_one _ ++ have ht1 : (s - 1) * ∫ x in Set.Ioc 1 X, |E₂Λ x| * x ^ (-s) ≤ (s - 1) * B := ++ mul_le_mul_of_nonneg_left hp1 hsm1.le ++ linarith ++ ++ have habs_le : |(s - 1) * ∫ x in Set.Ioi 1, E₂Λ x * x ^ (-s)| ++ ≤ (s - 1) * ∫ x in Set.Ioi 1, |E₂Λ x| * x ^ (-s) := by ++ rw [abs_mul, abs_of_pos hsm1] ++ gcongr ++ rw [← Real.norm_eq_abs] ++ refine (norm_integral_le_integral_norm _).trans_eq ?_ ++ refine setIntegral_congr_fun measurableSet_Ioi (fun x hx => ?_) ++ simp only [Set.mem_Ioi] at hx ++ change ‖E₂Λ x * x ^ (-s)‖ = |E₂Λ x| * x ^ (-s) ++ rw [Real.norm_eq_abs, abs_mul, abs_of_nonneg (Real.rpow_nonneg (by linarith) _)] ++ rw [Real.dist_eq, sub_zero] ++ ++ have hfin : (s - 1) * B + ε / 2 < ε := by ++ have hlt : s - 1 < ε / 2 / (B + 1) := lt_of_lt_of_le hs1 (min_le_right _ _) ++ have hBp : 0 < B + 1 := by linarith ++ have h1 : (s - 1) * B ≤ (s - 1) * (B + 1) := by nlinarith ++ have h2 : (s - 1) * (B + 1) < (ε / 2 / (B + 1)) * (B + 1) := mul_lt_mul_of_pos_right hlt hBp ++ have h3 : (ε / 2 / (B + 1)) * (B + 1) = ε / 2 := by field_simp ++ linarith ++ calc |(s - 1) * ∫ x in Set.Ioi 1, E₂Λ x * x ^ (-s)| ++ ≤ (s - 1) * ∫ x in Set.Ioi 1, |E₂Λ x| * x ^ (-s) := habs_le ++ _ ≤ (s - 1) * B + ε / 2 := hbound ++ _ < ε := hfin ++ ++end ++ ++theorem deriv_gamma_add_γ_eq_zero : deriv Gamma 1 + γ = 0 := by ++ ++ have key : ∀ s : ℝ, 1 < s → ++ (Real.log (riemannZeta (s:ℂ)).re + Real.log (s - 1)) ++ - (s - 1) * ∫ x in Set.Ioi 1, E₂Λ x * x ^ (-s) = deriv Gamma 1 + γ := by ++ intro s hs ++ have h := log_zeta_eq s hs ++ linarith ++ ++ have hconst : Filter.Tendsto ++ (fun s : ℝ => (Real.log (riemannZeta (s:ℂ)).re + Real.log (s - 1)) ++ - (s - 1) * ∫ x in Set.Ioi 1, E₂Λ x * x ^ (-s)) ++ (nhdsWithin 1 (Set.Ioi 1)) (nhds (deriv Gamma 1 + γ)) := by ++ refine Filter.Tendsto.congr' ?_ tendsto_const_nhds ++ filter_upwards [self_mem_nhdsWithin] with s hs ++ exact (key s hs).symm ++ ++ have hlim := log_zeta_limit.sub sub_one_mul_integral_E₂Λ_tendsto ++ rw [sub_zero] at hlim ++ exact tendsto_nhds_unique hconst hlim ++ ++theorem γ.eq_eulerMascheroni : γ = eulerMascheroniConstant := by ++ linarith [Real.eulerMascheroniConstant_eq_neg_deriv, deriv_gamma_add_γ_eq_zero] ++ ++theorem sum_mangoldt_div_log_eq (x : ℝ) : ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) = log (log x) + eulerMascheroniConstant + E₂Λ x := by ++ grind [γ.eq_eulerMascheroni] ++ ++theorem sum_mangoldt_div_log_eq_log_log : ∃ C, ∀ x, 2 ≤ x → ++ |∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) - log (log x)| ≤ C := by ++ use (log 4 + 6)/log 2 + |eulerMascheroniConstant| ++ intro x hx ++ rw [sum_mangoldt_div_log_eq] ++ calc ++ _ = |E₂Λ x + eulerMascheroniConstant| := by ring_nf ++ _ ≤ (log 4 + 6)/log x + |eulerMascheroniConstant| := by grw [abs_add_le, E₂Λ.abs_le hx] ++ _ ≤ _ := by gcongr ++ ++theorem sum_mangoldt_div_log_eq_log_log' : (fun x ↦ ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) - log (log x)) =O[atTop] (fun _ ↦ (1:ℝ)) := by ++ simp only [isBigO_iff, norm_eq_abs, one_mem, CStarRing.norm_of_mem_unitary, mul_one, ++ eventually_atTop] ++ obtain ⟨ C, _ ⟩ := sum_mangoldt_div_log_eq_log_log ++ use C, 2 ++ ++theorem sum_mangoldt_div_log_eq_log_log'' : (fun x ↦ ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d)) ~[atTop] (fun x ↦ log (log x)) := by ++ apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log_log) ++ convert! sum_mangoldt_div_log_eq_log_log' using 1 ++ ++noncomputable def M : ℝ := (∫ t in Set.Ioi 2, E₁p t / (t * log t^2)) + 1 - log (log 2) ++ ++theorem M.le : M ≤ (log 4 + 4) / log 2 + 1 - log (log 2) := calc ++ _ ≤ (∫ t in Set.Ioi 2, (log 4 + 4) / (t * log t^2)) + 1 - log (log 2) := by ++ unfold M; gcongr with x hx ++ · exact integrable_E₁p_div_mul_log_sq (by norm_num) ++ · exact integrable_const_div_mul_log_sq _ (by norm_num) ++ · measurability ++ · simp at hx; positivity ++ simp at hx; exact E₁p.le (by linarith) ++ _ = _ := by rw [integ_div_mul_log_sq _ (by norm_num)] ++ ++theorem M.ge : M ≥ (-2 - E₁) / log 2 + 1 - log (log 2) := calc ++ _ ≥ (∫ t in Set.Ioi 2, (-2 - E₁) / (t * log t^2)) + 1 - log (log 2) := by ++ unfold M; gcongr with x hx ++ · exact integrable_const_div_mul_log_sq _ (by norm_num) ++ · exact integrable_E₁p_div_mul_log_sq (by norm_num) ++ · measurability ++ · simp at hx; positivity ++ simp at hx; exact E₁p.ge (by linarith) ++ _ = _ := by rw [integ_div_mul_log_sq _ (by norm_num)] ++ ++noncomputable abbrev E₂p (x : ℝ) : ℝ := ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1:ℝ) / p - log (log x) - M ++ ++theorem sum_prime_div_eq (x : ℝ) : ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1:ℝ) / p = log (log x) + M + E₂p x := by ++ ring ++ ++theorem E₂p.eq {x : ℝ} (hx : 2 ≤ x) : ++ E₂p x = E₁p x / log x - ∫ t in Set.Ioi x, E₁p t / (t * log t^2) := by ++ unfold E₂p ++ rw [sum_filter, ← sum_Ioc_one_eq_sum_Ioc_zero (Nat.le_floor (by grind)) (by simp [Nat.not_prime_one])] ++ have (n : ℕ) : (if Nat.Prime n then (1 : ℝ) / n else 0) = (if Nat.Prime n then log n / n else 0) / log n := by ++ split_ifs with h ++ · have : log n ≠ 0 := by simp; grind [h.two_le] ++ field ++ · simp ++ simp_rw [this] ++ rw [sum_div_log_eq hx, sum_Ioc_one_eq_sum_Ioc_zero (Nat.le_floor (by grind)) (by simp), ← sum_filter] ++ rw [sum_log_prime_div_eq] ++ have : ∫ t in 2..x, (∑ n ∈ Ioc 1 ⌊t⌋₊, if Nat.Prime n then log ↑n / ↑n else 0) / (t * log t ^ 2) = ∫ t in 2..x, (1 / (t * log t) + E₁p t / (t * log t ^2)) := by ++ refine intervalIntegral.integral_congr fun t ht ↦ ?_ ++ rw [Set.uIcc_of_le hx, Set.mem_Icc] at ht ++ rw [sum_Ioc_one_eq_sum_Ioc_zero (Nat.le_floor (by grind)) (by simp), ← sum_filter, sum_log_prime_div_eq] ++ field ++ rw [this, intervalIntegral.integral_add] ++ · rw [integral_one_div_mul_log hx, add_div, div_self (by simp; grind)] ++ unfold M ++ calc ++ _ = E₁p x / log x + (∫ (x : ℝ) in 2..x, E₁p x / (x * log x ^ 2)) - ++ ((∫ (t : ℝ) in Set.Ioi 2, E₁p t / (t * log t ^ 2))) := by ring ++ _ = _ := by ++ rw [← intervalIntegral.integral_interval_add_Ioi (integrable_E₁p_div_mul_log_sq (by rfl)) (integrable_E₁p_div_mul_log_sq hx)] ++ ring ++ · exact intervalIntegrable_one_div_mul_log hx ++ · rw [intervalIntegrable_iff, Set.uIoc_of_le hx] ++ exact integrable_E₁p_div_mul_log_sq (x := 2) (by rfl)|>.mono (by grind) (by rfl) ++ ++theorem E₂p.abs_le {x : ℝ} (hx : 2 ≤ x) : ++ |E₂p x| ≤ (log 4 + 6 + E₁) / log x := by ++ have : 0 < log x := by apply log_pos; linarith ++ rw [E₂p.eq hx, abs_le'] ++ constructor ++ · grw [E₁p.le (by linarith)] ++ have : ∫ t in Set.Ioi x, E₁p t / (t * log t^2) ≥ (- 2 - E₁) / log x := calc ++ _ ≥ ∫ t in Set.Ioi x, (-2 - E₁) / (t * log t^2) := by ++ apply MeasureTheory.setIntegral_mono_on (integrable_const_div_mul_log_sq (-2 - E₁) hx) ++ (integrable_E₁p_div_mul_log_sq hx) (by measurability) ++ intro y hy; simp at hy ++ have : 1 < y := by linarith ++ have : 0 < log y := log_pos this ++ gcongr; exact E₁p.ge (by linarith) ++ _ = _ := integ_div_mul_log_sq (-2 - E₁) hx ++ grw [this] ++ grind ++ grw [E₁p.ge (by linarith)] ++ have : ∫ t in Set.Ioi x, E₁p t / (t * log t^2) ≤ (log 4 + 4) / log x := calc ++ _ ≤ ∫ t in Set.Ioi x, (log 4 + 4) / (t * log t^2) := by ++ apply MeasureTheory.setIntegral_mono_on (integrable_E₁p_div_mul_log_sq hx) ++ (integrable_const_div_mul_log_sq (log 4 + 4) hx) (by measurability) ++ intro y hy; simp at hy ++ have : 1 < y := by linarith ++ have : 0 < log y := log_pos this ++ gcongr; exact E₁p.le (by linarith) ++ _ = _ := integ_div_mul_log_sq (log 4 + 4) hx ++ grw [this] ++ grind ++ ++theorem E₂p.bound : E₂p =O[atTop] (fun x ↦ 1 / log x) := by ++ simp only [one_div, isBigO_iff, norm_eq_abs, norm_inv, eventually_atTop] ++ use log 4 + 6 + E₁, 2 ++ intro x hx ++ convert E₂p.abs_le hx using 1 ++ have : 0 < log x := by apply log_pos; linarith ++ grind [abs_of_pos this] ++ ++theorem E₂p.bound' : E₂p =o[atTop] (fun _ ↦ (1:ℝ)) := E₂p.bound.trans_isLittleO inv_log_eq_o_one ++ ++theorem sum_prime_div_eq_log_log : ∃ C, ∀ x, 2 ≤ x → ++ |∑ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1:ℝ) / p - log (log x)| ≤ C := by ++ use |M| + (log 4 + 6 + E₁) / log 2 ++ intro x hx ++ rw [sum_prime_div_eq] ++ calc ++ _ = |M + E₂p x| := by ring_nf ++ _ ≤ |M| + (log 4 + 6 + E₁) / log x := by grw [abs_add_le, E₂p.abs_le hx] ++ _ ≤ _ := by ++ gcongr ++ have : 0 < log 4 := by apply log_pos; norm_num ++ linarith [E₁.nonneg] ++ ++theorem sum_prime_div_eq_log_log' : (fun x ↦ ∑ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1:ℝ) / p - log (log x)) =O[atTop] (fun _ ↦ (1:ℝ)) := by ++ simp only [isBigO_iff, norm_eq_abs, one_mem, CStarRing.norm_of_mem_unitary, mul_one, ++ eventually_atTop] ++ obtain ⟨ C, hC ⟩ := sum_prime_div_eq_log_log ++ use C, 2 ++ ++theorem sum_prime_div_eq_log_log'' : (fun x ↦ ∑ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1:ℝ) / p) ~[atTop] (fun x ↦ log (log x)) := by ++ apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log_log) ++ convert! sum_prime_div_eq_log_log' using 1 ++ ++lemma HasSum_log_one_sub_one_div_prime {p : ℕ} (hp : p.Prime) : ++ HasSum (fun n : ℕ ↦ (-1 : ℝ) / (( n + 1) * p ^ (n + 1))) (log (1 - 1 / p)) := by ++ convert! Real.hasSum_pow_div_log_of_abs_lt_one (x := 1 / p) _|>.neg using 1 ++ · ext ++ rw [div_pow, one_pow, div_div] ++ ring ++ · ring ++ · simp only [one_div, abs_inv, Nat.abs_cast] ++ exact inv_lt_one_of_one_lt₀ (mod_cast hp.one_lt) ++ ++lemma E₂Λ_sub_E₂p_tendsto : ++ Tendsto (E₂Λ - E₂p) atTop (nhds 0) := by ++ exact isLittleO_one_iff ℝ|>.mp <| E₂Λ.bound'.sub E₂p.bound' ++ ++noncomputable abbrev M_eq_f (n : ℕ) := ++ if ¬n.Prime then Λ n /(n * log n) else 0 ++ ++lemma E₂Λ_sub_E₂p_eq (x : ℝ) : ++ E₂Λ x - E₂p x = ∑ n ∈ Ioc 0 ⌊x⌋₊, M_eq_f n - (γ - M) := by ++ calc ++ _ = ∑ n ∈ Ioc 0 ⌊x⌋₊, Λ n / (n * log n) - ∑ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1 : ℝ) / p - (γ - M) := by ring ++ _ = _ := by ++ rw [sum_filter, ← sum_sub_distrib] ++ congr ++ ext n ++ split_ifs with hn ++ · rw [vonMangoldt_apply_prime hn] ++ have : log n ≠ 0 := by simp; grind [hn.two_le] ++ field ++ · ring ++ ++lemma M_eq_f.sum_tendsto : ++ Tendsto (fun (x : ℝ) ↦ ∑ n ∈ Ioc 0 ⌊x⌋₊, M_eq_f n) atTop (nhds (γ - M)) := by ++ apply tendsto_sub_nhds_zero_iff.mp ++ convert E₂Λ_sub_E₂p_tendsto using 1 ++ ext ++ rw [← E₂Λ_sub_E₂p_eq] ++ simp ++ ++lemma M_eq_f.sum_tendsto' : ++ Tendsto (fun (N : ℕ) ↦ ∑ n ∈ range N, M_eq_f n) atTop (nhds (γ - M)) := by ++ have : Tendsto (fun (N : ℕ) ↦ (∑ n ∈ Ioc 0 ⌊(N : ℝ)⌋₊, M_eq_f n)) atTop (nhds (γ - M)) := M_eq_f.sum_tendsto.comp tendsto_natCast_atTop_atTop ++ simp_rw [Nat.floor_natCast] at this ++ apply (this.comp (tendsto_sub_atTop_nat 1)).congr' ++ filter_upwards [eventually_ge_atTop 1] with N hn ++ rw [Nat.range_eq_Icc_zero_sub_one, ← add_sum_Ioc_eq_sum_Icc] <;> grind ++ ++lemma M_eq_f.HasSum : ++ HasSum M_eq_f (γ - M) := by ++ refine hasSum_iff_tendsto_nat_of_nonneg (fun n ↦ ?_) _|>.mpr M_eq_f.sum_tendsto' ++ unfold M_eq_f ++ split_ifs with hn ++ · rfl ++ · exact div_nonneg vonMangoldt_nonneg (by positivity) ++ ++lemma M_eq_f.sum_primes : ++ ∑' (p : Nat.Primes), M_eq_f p = 0 := by ++ convert! tsum_zero with p ++ grind ++ ++lemma tsum_primes_eq_tsum_ite (f : ℕ → ℝ) : ++ ∑' (n : Nat.Primes), f n = ∑' (n : ℕ), if n.Prime then f n else 0 := by ++ convert! _root_.tsum_subtype Nat.Prime f using 2 ++ ext ++ simp [Set.indicator] ++ congr ++ ++lemma tsum_M_eq_f_eq_tsum : ++ -∑' (n : ℕ), M_eq_f n = ∑' p : ℕ, if p.Prime then log (1 - 1 / p) + 1 / p else 0 := by ++ rw [tsum_eq_tsum_primes_add_tsum_primes_of_support_subset_prime_powers M_eq_f.HasSum.summable ++ (fun n hn ↦ (by simp_all [vonMangoldt_ne_zero_iff])), M_eq_f.sum_primes, zero_add, ++ tsum_primes_eq_tsum_ite (fun p ↦ ∑' (k : ℕ), M_eq_f (p ^ (k + 2))), ← tsum_neg] ++ refine tsum_congr fun n ↦ ?_ ++ split_ifs with hn ++ · rw [← HasSum_log_one_sub_one_div_prime hn|>.tsum_eq, HasSum_log_one_sub_one_div_prime hn|>.summable.tsum_eq_zero_add] ++ simp only [ite_not, Nat.cast_pow, log_pow, Nat.cast_add, Nat.cast_ofNat, CharP.cast_eq_zero, ++ zero_add, pow_one, one_mul, Nat.cast_one, one_div] ++ trans -∑' (k : ℕ), (1 : ℝ) / ((k + 2) * n ^ (k + 2)) ++ · congr ++ ext k ++ have : ¬(Nat.Prime (n ^ (k + 2))) := by exact Nat.Prime.not_prime_pow (by grind) ++ simp only [this, ↓reduceIte, one_div, mul_inv_rev] ++ rw [vonMangoldt_apply_pow (by grind), vonMangoldt_apply_prime hn] ++ have : log n ≠ 0 := by simp; grind [hn.two_le] ++ field ++ · rw [← tsum_neg] ++ ring_nf ++ congr ++ ext ++ ring_nf ++ · ring ++ ++theorem M.eq : M = γ + ∑' p : ℕ, if p.Prime then log (1 - 1 / p) + 1 / p else 0 := by ++ rw [← tsum_M_eq_f_eq_tsum, M_eq_f.HasSum.tsum_eq] ++ ring ++ ++noncomputable def E₃ (x : ℝ) : ℝ := ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, log (1 - (1:ℝ) / p) + log (log x) + eulerMascheroniConstant ++ ++theorem prod_one_minus_div_prime_eq {x : ℝ} (hx : 1 < x) : ++ ∏ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1 - (1 : ℝ) / p) = ++ exp (-eulerMascheroniConstant) * exp (E₃ x) / log x := by ++ have hlog : 0 < log x := log_pos hx ++ have hpos : ∀ {p : ℕ}, p.Prime → (0 : ℝ) < 1 - 1 / p := fun {p} hp ↦ by ++ have : (2 : ℝ) ≤ p := mod_cast hp.two_le ++ grind [one_div_le_one_div_of_le two_pos this] ++ rw [E₃, exp_add, exp_add, exp_sum, exp_log hlog, exp_neg, ++ prod_congr rfl fun p hp ↦ exp_log (hpos (mem_filter.mp hp).2)] ++ field_simp ++ ++noncomputable abbrev M_eq_summand (p : ℕ) := if p.Prime then log (1 - 1 / p) + 1 / p else 0 ++ ++lemma M_eq_summand_bound (n : ℕ) : ++ |M_eq_summand n| ≤ 2 / n ^ 2 := by ++ unfold M_eq_summand ++ split_ifs with h ++ · trans 1 / n ^ 2 / (1 - 1 / n) ++ · convert abs_log_sub_add_sum_range_le (x := 1 / n) _ 1 using 1 ++ · rw [add_comm] ++ simp ++ · rw [abs_of_nonneg (by simp)] ++ ring ++ · simpa using inv_lt_one_of_one_lt₀ (mod_cast h.one_lt) ++ rw [(by ring : (2 : ℝ) / n ^ 2 = 1 / n ^ 2 / (1 / 2))] ++ gcongr ++ suffices (1 : ℝ) / n ≤ 1 / 2 by linarith ++ gcongr ++ exact_mod_cast h.two_le ++ · rw [abs_zero] ++ positivity ++ ++lemma M_eq_summable : Summable M_eq_summand := by ++ apply Summable.of_abs ++ exact Summable.of_nonneg_of_le (by simp) M_eq_summand_bound (Summable.const_div (by simp) _) ++ ++lemma tsum_M_eq_summand_eq : ++ ∑' (n : ℕ), M_eq_summand n = M - γ := by ++ rw [M.eq] ++ grind ++ ++lemma sum_one_div_sq_le {N : ℝ} (hN : 1 ≤ N) : ++ ∑' (n : ℕ), (1 : ℝ) / (n + N) ^ 2 ≤ 2 / N := by ++ grw [AntitoneOn.tsum_le_integral (f := (fun t ↦ 1 / (t + N) ^ 2))] ++ · have hd : ∀ x ∈ Set.Ici 0, HasDerivAt (fun t ↦ -1 / (t + N)) (1 / (x + N) ^ 2) x := by ++ intro t ht ++ convert! HasDerivAt.fun_div (d' := (1 : ℝ)) (hasDerivAt_const ..) _ _ using 1 ++ · ring ++ · simpa using hasDerivAt_id' t ++ · simp at ht ++ linarith ++ have lim : Tendsto (fun t ↦ -1 / (t + N)) atTop (nhds 0) := by ++ exact (tendsto_atTop_add_const_right atTop N tendsto_id).const_div_atTop _ ++ rw [MeasureTheory.integral_Ioi_of_hasDerivAt_of_nonneg' hd (fun _ _ ↦ (by positivity)) lim] ++ ring_nf ++ rw [mul_two] ++ gcongr ++ field_simp ++ exact hN ++ · unfold AntitoneOn ++ intro a ha b hb h ++ beta_reduce ++ simp at ha hb ++ gcongr ++ · convert! integrableOn_add_rpow_Ioi_of_lt (by norm_num : (-2 : ℝ) < -1) (by linarith : -N < 0) using 2 ++ simp ++ · exact fun _ _ ↦ (by positivity) ++ ++lemma sum_M_eq_summand_le {N : ℕ} (hN : 0 < N) : ++ |∑ n ∈ range N, M_eq_summand n - (M - γ)| ≤ 4 / N := by ++ rw [← tsum_M_eq_summand_eq, ← M_eq_summable.sum_add_tsum_nat_add N] ++ simp only [sub_add_cancel_left, abs_neg] ++ rw [← norm_eq_abs] ++ have summable := summable_nat_add_iff N|>.mpr M_eq_summable.norm ++ apply norm_tsum_le_tsum_norm summable|>.trans ++ apply Summable.tsum_le_tsum (fun _ ↦ M_eq_summand_bound _) summable _|>.trans ++ · conv => lhs; arg 1; ext; rw [← mul_one_div] ++ rw [tsum_mul_left] ++ push_cast ++ grw [sum_one_div_sq_le (mod_cast hN)] ++ ring_nf ++ rfl ++ · exact (summable_nat_add_iff N|>.mpr (summable_one_div_nat_pow.mpr one_lt_two))|>.const_div _ ++ ++lemma sum_M_eq_summand_le' {x : ℝ} (hx : 2 ≤ x) : ++ |∑ n ∈ Ioc 0 ⌊x⌋₊, M_eq_summand n - (M - γ)| ≤ 4 / x := by ++ have := sum_M_eq_summand_le (by grind : 0 < ⌊x⌋₊ + 1) ++ rw [Nat.range_eq_Icc_zero_sub_one _ (by grind), ← add_sum_Ioc_eq_sum_Icc (by grind), ++ (by simp : M_eq_summand 0 = 0), zero_add] at this ++ simp only [add_tsub_cancel_right, Nat.cast_add, Nat.cast_one] at this ++ grw [this] ++ gcongr ++ exact Nat.lt_floor_add_one _|>.le ++ ++theorem E₃.abs_le : ∃ C, ∀ x, 2 ≤ x → |E₃ x| ≤ C / log x := by ++ unfold E₃ ++ refine ⟨4 + (log 4 + 6 + E₁), fun x hx ↦ ?_⟩ ++ calc ++ _ = |(∑ n ∈ Ioc 0 ⌊x⌋₊, M_eq_summand n - (M - γ)) - E₂p x| := by ++ unfold E₂p ++ have (n : ℕ) : M_eq_summand n = (if n.Prime then log (1 - 1 / n) else 0) + (if n.Prime then (1 : ℝ) / n else 0) := by ++ unfold M_eq_summand ++ split_ifs ++ · rfl ++ · ring ++ simp_rw [this] ++ rw [sum_filter, sum_filter, sum_add_distrib, γ.eq_eulerMascheroni] ++ ring_nf ++ _ ≤ _ := by ++ grw [abs_sub, E₂p.abs_le hx, sum_M_eq_summand_le' hx] ++ have : 4 / x ≤ 4 / log x := by ++ gcongr ++ · exact log_pos (by linarith) ++ · exact log_le_self (by linarith) ++ grw [this] ++ rw [← add_div] ++ ++theorem E₃.bound : E₃ =O[atTop] (fun x ↦ 1 / log x) := by ++ simp only [isBigO_iff, norm_eq_abs, eventually_atTop] ++ obtain ⟨ C, hC ⟩ := E₃.abs_le ++ use C, 2 ++ convert hC using 3 with x hx ++ have : 0 < log x := by apply log_pos; linarith ++ have : 0 < 1 / log x := by positivity ++ grind [abs_of_pos this] ++ ++theorem E₃.bound' : E₃ =o[atTop] (fun _ ↦ (1:ℝ)) := E₃.bound.trans_isLittleO inv_log_eq_o_one ++ ++theorem E₃.bound'' : (fun x ↦ ∏ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1 - (1:ℝ) / p)) ~[atTop] (fun x ↦ exp (-eulerMascheroniConstant) / log x) := by ++ rw [isEquivalent_iff_tendsto_one] ++ · convert Tendsto.congr' ?_ (Tendsto.rexp ((isLittleO_one_iff ℝ).mp E₃.bound')) using 2 with x ++ · simp ++ simp only [Erdos970.Filter.EventuallyEq.iff_eventually, Pi.div_apply, eventually_atTop]; use 2; intro x hx ++ rw [prod_one_minus_div_prime_eq (by linarith)] ++ have : 0 < log x := by apply log_pos; linarith ++ field_simp ++ simp only [ne_eq, div_eq_zero_iff, exp_ne_zero, log_eq_zero, eventually_atTop]; use 2 ++ grind ++ ++theorem E₃.bound''' : (fun x ↦ ∏ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1 - (1:ℝ) / p) - exp (-eulerMascheroniConstant) / log x) =O[atTop] (fun x ↦ 1 / (log x)^2) := by ++ obtain ⟨c, hc⟩ := E₃.abs_le ++ rw [isBigO_iff] ++ refine ⟨exp (-eulerMascheroniConstant) * 2 * c, ?_⟩ ++ filter_upwards [eventually_ge_atTop 2, eventually_ge_atTop c.exp] with x hx hx2 ++ rw [prod_one_minus_div_prime_eq (by linarith)] ++ specialize hc x hx ++ rw [norm_eq_abs, norm_eq_abs] ++ calc ++ _ = |exp (-eulerMascheroniConstant) / log x * (exp (E₃ x) - 1)| := by ring_nf ++ _ = |exp (-eulerMascheroniConstant) / log x| * |exp (E₃ x) - 1| := by rw [abs_mul] ++ _ ≤ _ := by ++ have : |E₃ x| ≤ 1 := by ++ apply hc.trans ++ have := log_le_log (exp_pos _) hx2 ++ rw [log_exp] at this ++ apply div_le_one_iff.mpr <| Or.inl ⟨log_pos (by linarith), this⟩ ++ grw [abs_exp_sub_one_le this, hc] ++ apply le_of_eq ++ rw [abs_div, abs_div, abs_one, abs_of_nonneg (exp_nonneg _), abs_of_nonneg (log_nonneg (by linarith)), abs_of_nonneg (sq_nonneg _)] ++ ring ++ ++end Mertens ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Rectangle.lean b/PrimeNumberTheoremAnd/Erdos970/Rectangle.lean +new file mode 100644 +index 0000000..c87b920 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Rectangle.lean +@@ -0,0 +1,264 @@ ++import Mathlib.Analysis.Complex.Convex ++import Mathlib.Analysis.InnerProductSpace.Basic ++import Mathlib.Analysis.Normed.Order.Lattice ++import Mathlib.Order.Interval.Set.Monotone ++ ++namespace Erdos970 ++ ++open Complex Set Topology ++ ++open scoped Interval ++ ++variable {z w : ℂ} {c : ℝ} ++ ++namespace Rectangle ++ ++lemma symm : Rectangle z w = Rectangle w z := by ++ simp [Rectangle, uIcc_comm] ++ ++lemma symm_re : Rectangle (w.re + z.im * I) (z.re + w.im * I) = Rectangle z w := by ++ simp [Rectangle, uIcc_comm] ++ ++end Rectangle ++ ++def RectangleBorder (z w : ℂ) : Set ℂ := ++ [[z.re, w.re]] ×ℂ {z.im} ∪ {z.re} ×ℂ [[z.im, w.im]] ∪ ++ [[z.re, w.re]] ×ℂ {w.im} ∪ {w.re} ×ℂ [[z.im, w.im]] ++ ++def Square (p : ℂ) (c : ℝ) : Set ℂ := Rectangle (-c - c * I + p) (c + c * I + p) ++ ++lemma Square_apply (p : ℂ) (cpos : c > 0) : ++ Square p c = Icc (-c + p.re) (c + p.re) ×ℂ Icc (-c + p.im) (c + p.im) := by ++ rw [Square, Rectangle, uIcc_of_le (by simp; linarith), uIcc_of_le (by simp; linarith)] ++ simp ++ ++@[simp] ++theorem preimage_equivRealProdCLM_reProdIm (s t : Set ℝ) : ++ equivRealProdCLM.symm ⁻¹' (s ×ℂ t) = s ×ˢ t := ++ rfl ++ ++@[simp] ++theorem ContinuousLinearEquiv.coe_toLinearEquiv_symm {R : Type*} {S : Type*} [Semiring R] ++ [Semiring S] {σ : R →+* S} {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] ++ (M : Type*) [TopologicalSpace M] ++ [AddCommMonoid M] {M₂ : Type*} [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M] ++ [Module S M₂] (e : M ≃SL[σ] M₂) : ++ ⇑e.toLinearEquiv.symm = e.symm := ++ rfl ++ ++lemma segment_reProdIm_segment_eq_convexHull (z w : ℂ) : ++ [[z.re, w.re]] ×ℂ [[z.im, w.im]] = ++ convexHull ℝ {z, z.re + w.im * I, w.re + z.im * I, w} := by ++ simp_rw [← segment_eq_uIcc, ← convexHull_pair, ← convexHull_reProdIm, reProdIm] ++ exact congrArg _ <| Set.ext <| by simpa [Complex.ext_iff] using by tauto ++ ++lemma rectangle_in_convex {U : Set ℂ} (U_convex : Convex ℝ U) {z w : ℂ} (hz : z ∈ U) ++ (hw : w ∈ U) (hzw : (z.re + w.im * I) ∈ U) (hwz : (w.re + z.im * I) ∈ U) : ++ Rectangle z w ⊆ U := by ++ rw [Rectangle, segment_reProdIm_segment_eq_convexHull] ++ exact convexHull_min (by simp_all [insert_subset_iff]) U_convex ++ ++lemma mem_Rect {z w : ℂ} (zRe_lt_wRe : z.re ≤ w.re) (zIm_lt_wIm : z.im ≤ w.im) (p : ℂ) : ++ p ∈ Rectangle z w ↔ ++ z.re ≤ p.re ∧ p.re ≤ w.re ∧ z.im ≤ p.im ∧ p.im ≤ w.im := by ++ rw [Rectangle, uIcc_of_le zRe_lt_wRe, uIcc_of_le zIm_lt_wIm] ++ exact and_assoc ++ ++lemma square_neg (p : ℂ) (c : ℝ) : Square p (-c) = Square p c := by ++ simpa [Square] using! Rectangle.symm ++ ++theorem Set.left_not_mem_uIoo {a b : ℝ} : a ∉ Set.uIoo a b := ++ fun ⟨h1, h2⟩ ↦ (left_lt_sup.mp h2) (le_of_not_ge (inf_lt_left.mp h1)) ++ ++theorem Set.right_not_mem_uIoo {a b : ℝ} : b ∉ Set.uIoo a b := ++ fun ⟨h1, h2⟩ ↦ (right_lt_sup.mp h2) (le_of_not_ge (inf_lt_right.mp h1)) ++ ++theorem Set.ne_left_of_mem_uIoo {a b c : ℝ} (hc : c ∈ Set.uIoo a b) : c ≠ a := ++ fun h ↦ Set.left_not_mem_uIoo (h ▸ hc) ++ ++theorem Set.ne_right_of_mem_uIoo {a b c : ℝ} (hc : c ∈ Set.uIoo a b) : c ≠ b := ++ fun h ↦ Set.right_not_mem_uIoo (h ▸ hc) ++ ++lemma left_mem_rect (z w : ℂ) : z ∈ Rectangle z w := ⟨left_mem_uIcc, left_mem_uIcc⟩ ++ ++lemma right_mem_rect (z w : ℂ) : w ∈ Rectangle z w := ⟨right_mem_uIcc, right_mem_uIcc⟩ ++ ++lemma rect_subset_iff {z w z' w' : ℂ} : ++ Rectangle z' w' ⊆ Rectangle z w ↔ z' ∈ Rectangle z w ∧ w' ∈ Rectangle z w := by ++ use fun h ↦ ⟨h (left_mem_rect z' w'), h (right_mem_rect z' w')⟩ ++ intro ⟨⟨⟨hz're_ge, hz're_le⟩, ⟨hz'im_ge, hz'im_le⟩⟩, ++ ⟨⟨hw're_ge, hw're_le⟩, ⟨hw'im_ge, hw'im_le⟩⟩⟩ x ++ ⟨⟨hxre_ge, hxre_le⟩, ⟨hxim_ge, hxim_le⟩⟩ ++ refine ⟨⟨?_, ?_⟩, ⟨?_, ?_⟩⟩ ++ · exact (le_inf hz're_ge hw're_ge).trans hxre_ge ++ · exact (le_sup_iff.mp hxre_le).casesOn (fun h ↦ h.trans hz're_le) ++ (fun h ↦ h.trans hw're_le) ++ · exact (le_inf hz'im_ge hw'im_ge).trans hxim_ge ++ · exact (le_sup_iff.mp hxim_le).casesOn (fun h ↦ h.trans hz'im_le) ++ (fun h ↦ h.trans hw'im_le) ++ ++lemma RectSubRect {x₀ x₁ x₂ x₃ y₀ y₁ y₂ y₃ : ℝ} (x₀_le_x₁ : x₀ ≤ x₁) ++ (x₁_le_x₂ : x₁ ≤ x₂) (x₂_le_x₃ : x₂ ≤ x₃) (y₀_le_y₁ : y₀ ≤ y₁) ++ (y₁_le_y₂ : y₁ ≤ y₂) (y₂_le_y₃ : y₂ ≤ y₃) : ++ Rectangle (x₁ + y₁ * I) (x₂ + y₂ * I) ⊆ ++ Rectangle (x₀ + y₀ * I) (x₃ + y₃ * I) := by ++ rw [rect_subset_iff, mem_Rect, mem_Rect] ++ refine ⟨⟨?_, ?_, ?_, ?_⟩, ?_, ?_, ?_, ?_⟩ ++ all_goals simpa using by linarith ++ ++lemma RectSubRect' {z₀ z₁ z₂ z₃ : ℂ} (x₀_le_x₁ : z₀.re ≤ z₁.re) ++ (x₁_le_x₂ : z₁.re ≤ z₂.re) (x₂_le_x₃ : z₂.re ≤ z₃.re) ++ (y₀_le_y₁ : z₀.im ≤ z₁.im) (y₁_le_y₂ : z₁.im ≤ z₂.im) ++ (y₂_le_y₃ : z₂.im ≤ z₃.im) : ++ Rectangle z₁ z₂ ⊆ Rectangle z₀ z₃ := by ++ rw [← re_add_im z₀, ← re_add_im z₁, ← re_add_im z₂, ← re_add_im z₃] ++ exact RectSubRect x₀_le_x₁ x₁_le_x₂ x₂_le_x₃ y₀_le_y₁ y₁_le_y₂ y₂_le_y₃ ++ ++lemma rectangleBorder_subset_rectangle (z w : ℂ) : RectangleBorder z w ⊆ Rectangle z w := by ++ intro x hx ++ obtain ⟨⟨h | h⟩ | h⟩ | h := hx ++ · exact ⟨h.1, h.2 ▸ left_mem_uIcc⟩ ++ · exact ⟨h.1 ▸ left_mem_uIcc, h.2⟩ ++ · exact ⟨h.1, h.2 ▸ right_mem_uIcc⟩ ++ · exact ⟨h.1 ▸ right_mem_uIcc, h.2⟩ ++ ++lemma rectangle_disjoint_singleton {z w p : ℂ} ++ (h : (p.re < z.re ∧ p.re < w.re) ∨ (p.im < z.im ∧ p.im < w.im) ∨ ++ (z.re < p.re ∧ w.re < p.re) ∨ (z.im < p.im ∧ w.im < p.im)) : ++ Disjoint (Rectangle z w) {p} := by ++ refine disjoint_singleton_right.mpr (not_and_or.mpr ?_) ++ obtain h | h | h | h := h ++ · exact Or.inl (notMem_uIcc_of_lt h.1 h.2) ++ · exact Or.inr (notMem_uIcc_of_lt h.1 h.2) ++ · exact Or.inl (notMem_uIcc_of_gt h.1 h.2) ++ · exact Or.inr (notMem_uIcc_of_gt h.1 h.2) ++ ++lemma rectangleBorder_disjoint_singleton {z w p : ℂ} ++ (h : p.re ≠ z.re ∧ p.re ≠ w.re ∧ p.im ≠ z.im ∧ p.im ≠ w.im) : ++ Disjoint (RectangleBorder z w) {p} := by ++ refine disjoint_singleton_right.mpr ?_ ++ simp_rw [RectangleBorder, Set.mem_union, not_or] ++ exact ⟨⟨⟨fun hc ↦ h.2.2.1 hc.2, fun hc ↦ h.1 hc.1⟩, fun hc ↦ h.2.2.2 hc.2⟩, ++ fun hc ↦ h.2.1 hc.1⟩ ++ ++lemma rectangle_subset_punctured_rect {z₀ z₁ z₂ z₃ p : ℂ} ++ (hz : z₀.re ≤ z₁.re ∧ z₁.re ≤ z₂.re ∧ z₂.re ≤ z₃.re ∧ ++ z₀.im ≤ z₁.im ∧ z₁.im ≤ z₂.im ∧ z₂.im ≤ z₃.im) ++ (hp : (p.re < z₁.re ∧ p.re < z₂.re) ∨ (p.im < z₁.im ∧ p.im < z₂.im) ∨ ++ (z₁.re < p.re ∧ z₂.re < p.re) ∨ (z₁.im < p.im ∧ z₂.im < p.im)) : ++ Rectangle z₁ z₂ ⊆ Rectangle z₀ z₃ \ {p} := ++ Set.subset_sdiff.mpr ⟨by apply RectSubRect' <;> tauto, rectangle_disjoint_singleton hp⟩ ++ ++lemma rectangleBorder_subset_punctured_rect {z₀ z₁ z₂ z₃ p : ℂ} ++ (hz : z₀.re ≤ z₁.re ∧ z₁.re ≤ z₂.re ∧ z₂.re ≤ z₃.re ∧ ++ z₀.im ≤ z₁.im ∧ z₁.im ≤ z₂.im ∧ z₂.im ≤ z₃.im) ++ (hp : p.re ≠ z₁.re ∧ p.re ≠ z₂.re ∧ p.im ≠ z₁.im ∧ p.im ≠ z₂.im) : ++ RectangleBorder z₁ z₂ ⊆ Rectangle z₀ z₃ \ {p} := ++ Set.subset_sdiff.mpr ⟨ ++ (rectangleBorder_subset_rectangle _ _).trans (by apply RectSubRect' <;> tauto), ++ rectangleBorder_disjoint_singleton hp⟩ ++ ++lemma rectangle_mem_nhds_iff {z w p : ℂ} : ++ Rectangle z w ∈ 𝓝 p ↔ p ∈ (Set.uIoo z.re w.re) ×ℂ (Set.uIoo z.im w.im) := by ++ simp_rw [← mem_interior_iff_mem_nhds, Rectangle, Complex.interior_reProdIm, uIoo, uIcc, ++ interior_Icc] ++ ++lemma mapsTo_rectangle_left_re (z w : ℂ) : ++ MapsTo (fun (y : ℝ) => ↑z.re + ↑y * I) [[z.im, w.im]] (Rectangle z w) := ++ fun _ hx ↦ ⟨by simp, by simp [hx]⟩ ++ ++lemma mapsTo_rectangle_right_re (z w : ℂ) : ++ MapsTo (fun (y : ℝ) => ↑w.re + ↑y * I) [[z.im, w.im]] (Rectangle z w) := ++ fun _ hx ↦ ⟨by simp, by simp [hx]⟩ ++ ++lemma mapsTo_rectangle_left_im (z w : ℂ) : ++ MapsTo (fun (x : ℝ) => ↑x + z.im * I) [[z.re, w.re]] (Rectangle z w) := ++ fun _ hx ↦ ⟨by simp [hx], by simp⟩ ++ ++lemma mapsTo_rectangle_right_im (z w : ℂ) : ++ MapsTo (fun (x : ℝ) => ↑x + w.im * I) [[z.re, w.re]] (Rectangle z w) := ++ fun _ hx ↦ ⟨by simp [hx], by simp⟩ ++ ++lemma mapsTo_rectangleBorder_left_re (z w : ℂ) : ++ MapsTo (fun (y : ℝ) => ↑z.re + ↑y * I) [[z.im, w.im]] (RectangleBorder z w) := ++ (Set.mapsTo_image _ _).mono subset_rfl fun _ ↦ ++ by simp_all [verticalSegment_eq, RectangleBorder] ++ ++lemma mapsTo_rectangleBorder_right_re (z w : ℂ) : ++ MapsTo (fun (y : ℝ) => ↑w.re + ↑y * I) [[z.im, w.im]] (RectangleBorder z w) := ++ (Set.mapsTo_image _ _).mono subset_rfl fun _ ↦ ++ by simp_all [verticalSegment_eq, RectangleBorder] ++ ++lemma mapsTo_rectangleBorder_left_im (z w : ℂ) : ++ MapsTo (fun (x : ℝ) => ↑x + z.im * I) [[z.re, w.re]] (RectangleBorder z w) := ++ (Set.mapsTo_image _ _).mono subset_rfl fun _ ↦ ++ by simp_all [horizontalSegment_eq, RectangleBorder] ++ ++lemma mapsTo_rectangleBorder_right_im (z w : ℂ) : ++ MapsTo (fun (x : ℝ) => ↑x + w.im * I) [[z.re, w.re]] (RectangleBorder z w) := ++ (Set.mapsTo_image _ _).mono subset_rfl fun _ ↦ ++ by simp_all [horizontalSegment_eq, RectangleBorder] ++ ++lemma mapsTo_rectangle_left_re_NoP (z w : ℂ) {p : ℂ} ++ (pNotOnBorder : p ∉ RectangleBorder z w) : ++ MapsTo (fun (y : ℝ) => ↑z.re + ↑y * I) [[z.im, w.im]] (Rectangle z w \ {p}) := by ++ refine (mapsTo_rectangleBorder_left_re z w).mono_right (Set.subset_sdiff.mpr ?_) ++ exact ⟨rectangleBorder_subset_rectangle z w, disjoint_singleton_right.mpr pNotOnBorder⟩ ++ ++lemma mapsTo_rectangle_right_re_NoP (z w : ℂ) {p : ℂ} ++ (pNotOnBorder : p ∉ RectangleBorder z w) : ++ MapsTo (fun (y : ℝ) => ↑w.re + ↑y * I) [[z.im, w.im]] (Rectangle z w \ {p}) := by ++ refine (mapsTo_rectangleBorder_right_re z w).mono_right (Set.subset_sdiff.mpr ?_) ++ exact ⟨rectangleBorder_subset_rectangle z w, disjoint_singleton_right.mpr pNotOnBorder⟩ ++ ++lemma mapsTo_rectangle_left_im_NoP (z w : ℂ) {p : ℂ} ++ (pNotOnBorder : p ∉ RectangleBorder z w) : ++ MapsTo (fun (x : ℝ) => ↑x + z.im * I) [[z.re, w.re]] (Rectangle z w \ {p}) := by ++ refine (mapsTo_rectangleBorder_left_im z w).mono_right (Set.subset_sdiff.mpr ?_) ++ exact ⟨rectangleBorder_subset_rectangle z w, disjoint_singleton_right.mpr pNotOnBorder⟩ ++ ++lemma mapsTo_rectangle_right_im_NoP (z w : ℂ) {p : ℂ} ++ (pNotOnBorder : p ∉ RectangleBorder z w) : ++ MapsTo (fun (x : ℝ) => ↑x + w.im * I) [[z.re, w.re]] (Rectangle z w \ {p}) := by ++ refine (mapsTo_rectangleBorder_right_im z w).mono_right (Set.subset_sdiff.mpr ?_) ++ exact ⟨rectangleBorder_subset_rectangle z w, disjoint_singleton_right.mpr pNotOnBorder⟩ ++ ++theorem not_mem_rectangleBorder_of_rectangle_mem_nhds {z w p : ℂ} ++ (hp : Rectangle z w ∈ 𝓝 p) : ++ p ∉ RectangleBorder z w := by ++ refine Set.disjoint_right.mp (rectangleBorder_disjoint_singleton ?_) rfl ++ have h1 := rectangle_mem_nhds_iff.mp hp ++ exact ⟨Set.ne_left_of_mem_uIoo h1.1, Set.ne_right_of_mem_uIoo h1.1, ++ Set.ne_left_of_mem_uIoo h1.2, Set.ne_right_of_mem_uIoo h1.2⟩ ++ ++theorem Complex.nhds_hasBasis_square (p : ℂ) : (𝓝 p).HasBasis (0 < ·) (Square p ·) := by ++ suffices ++ (𝓝 p.re ×ˢ 𝓝 p.im).HasBasis (0 < ·) ++ (equivRealProdCLM.symm.toHomeomorph ⁻¹' Square p ·) ++ by simpa only [← nhds_prod_eq, Homeomorph.map_nhds_eq, Homeomorph.image_preimage] ++ using! this.map equivRealProdCLM.symm.toHomeomorph ++ apply ((nhds_basis_Icc_pos p.re).prod_same_index_mono (nhds_basis_Icc_pos p.im) ?_ ?_).congr ++ · intro; rfl ++ · intros ++ rw [← uIcc_of_lt (by linarith), ← uIcc_of_lt (by linarith)] ++ simpa [Square, Rectangle] using by ring_nf ++ all_goals exact (antitone_const_tsub.Icc (monotone_id.const_add _)).monotoneOn _ ++ ++lemma square_mem_nhds (p : ℂ) {c : ℝ} (hc : c ≠ 0) : ++ Square p c ∈ 𝓝 p := by ++ wlog hc_pos : 0 < c generalizing c with h ++ · rw [← square_neg] ++ exact h (neg_ne_zero.mpr hc) <| neg_pos.mpr <| hc.lt_of_le <| not_lt.mp hc_pos ++ exact (Complex.nhds_hasBasis_square p).mem_of_mem hc_pos ++ ++lemma square_subset_square {p : ℂ} {c₁ c₂ : ℝ} (hc₁ : 0 < c₁) (hc : c₁ ≤ c₂) : ++ Square p c₁ ⊆ Square p c₂ := by ++ apply RectSubRect' <;> simpa using by linarith ++ ++lemma SmallSquareInRectangle {z w p : ℂ} (pInRectInterior : Rectangle z w ∈ nhds p) : ++ ∀ᶠ (c : ℝ) in 𝓝[>]0, Square p c ⊆ Rectangle z w := by ++ obtain ⟨ε, hε0, hε⟩ := ((Complex.nhds_hasBasis_square p).1 _).mp pInRectInterior ++ filter_upwards [Ioo_mem_nhdsGT (hε0)] with _ ⟨hε'0, hε'⟩ ++ exact subset_trans (square_subset_square hε'0 hε'.le) hε ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/ResidueCalcOnRectangles.lean b/PrimeNumberTheoremAnd/Erdos970/ResidueCalcOnRectangles.lean +new file mode 100644 +index 0000000..b976da3 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/ResidueCalcOnRectangles.lean +@@ -0,0 +1,1074 @@ ++import Mathlib.Analysis.Complex.CauchyIntegral ++import Mathlib.Analysis.Complex.Convex ++import Mathlib.Analysis.Complex.RemovableSingularity ++import Mathlib.Analysis.SpecialFunctions.Integrals.Basic ++import Mathlib.Analysis.Meromorphic.NormalForm ++import PrimeNumberTheoremAnd.Erdos970.Rectangle ++import PrimeNumberTheoremAnd.Erdos970.Tactic.AdditiveCombination ++ ++namespace Erdos970 ++ ++open _root_.Complex BigOperators Nat Classical Real Topology Filter ++open _root_.Set MeasureTheory intervalIntegral Asymptotics ++ ++open scoped Interval ++ ++variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] {f g : ℂ → E} {z w p c A : ℂ} ++ {x x₁ x₂ y y₁ y₂ σ : ℝ} ++ ++noncomputable def HIntegral (f : ℂ → E) (x₁ x₂ y : ℝ) : E := ++ ∫ x in x₁..x₂, f (x + y * I) ++ ++noncomputable def VIntegral (f : ℂ → E) (x y₁ y₂ : ℝ) : E := ++ I • ∫ y in y₁..y₂, f (x + y * I) ++ ++noncomputable def HIntegral' (f : ℂ → E) (x₁ x₂ y : ℝ) : E := ++ (1 / (2 * π * I)) • HIntegral f x₁ x₂ y ++ ++noncomputable def VIntegral' (f : ℂ → E) (x y₁ y₂ : ℝ) : E := ++ (1 / (2 * π * I)) • VIntegral f x y₁ y₂ ++ ++lemma HIntegral_symm : ++ HIntegral f x₁ x₂ y = -HIntegral f x₂ x₁ y := integral_symm _ _ ++ ++lemma VIntegral_symm : ++ VIntegral f x y₁ y₂ = -VIntegral f x y₂ y₁ := by ++ simp_rw [VIntegral, integral_symm y₁ y₂, smul_neg, neg_neg] ++ ++noncomputable def RectangleIntegral (f : ℂ → E) (z w : ℂ) : E := ++ HIntegral f z.re w.re z.im - HIntegral f z.re w.re w.im + ++ VIntegral f w.re z.im w.im - VIntegral f z.re z.im w.im ++ ++noncomputable abbrev RectangleIntegral' (f : ℂ → E) (z w : ℂ) : E := ++ (1 / (2 * π * I)) • RectangleIntegral f z w ++ ++noncomputable def UpperUIntegral (f : ℂ → E) (σ σ' T : ℝ) : E := ++ HIntegral f σ σ' T + ++ I • (∫ y : ℝ in Ici T, f (σ' + y * I)) - ++ I • (∫ y : ℝ in Ici T, f (σ + y * I)) ++ ++noncomputable def LowerUIntegral (f : ℂ → E) (σ σ' T : ℝ) : E := ++ HIntegral f σ σ' (-T) - ++ I • (∫ y : ℝ in Iic (-T), f (σ' + y * I)) + ++ I • (∫ y : ℝ in Iic (-T), f (σ + y * I)) ++ ++noncomputable def VerticalIntegral (f : ℂ → E) (σ : ℝ) : E := ++ I • ∫ t : ℝ, f (σ + t * I) ++ ++noncomputable abbrev VerticalIntegral' (f : ℂ → E) (σ : ℝ) : E := ++ (1 / (2 * π * I)) • VerticalIntegral f σ ++ ++lemma verticalIntegral_split_three (a b : ℝ) ++ (hf : Integrable (fun t : ℝ ↦ f (σ + t * I))) : ++ VerticalIntegral f σ = ++ I • (∫ t in Iic a, f (σ + t * I)) + VIntegral f σ a b + ++ I • ∫ t in Ici b, f (σ + t * I) := by ++ simp_rw [VerticalIntegral, VIntegral, ← smul_add] ++ congr ++ rw [← integral_Iic_sub_Iic hf.restrict hf.restrict, add_sub_cancel, ++ integral_Iic_eq_integral_Iio, integral_Iio_add_Ici hf.restrict hf.restrict] ++ ++lemma DiffVertRect_eq_UpperLowerUs {σ σ' T : ℝ} ++ (f_int_σ : Integrable (fun (t : ℝ) ↦ f (σ + t * I))) ++ (f_int_σ' : Integrable (fun (t : ℝ) ↦ f (σ' + t * I))) : ++ VerticalIntegral f σ' - VerticalIntegral f σ - ++ RectangleIntegral f (σ - I * T) (σ' + I * T) = ++ UpperUIntegral f σ σ' T - LowerUIntegral f σ σ' T := by ++ rw [verticalIntegral_split_three (-T) T f_int_σ, verticalIntegral_split_three (-T) T f_int_σ'] ++ simp only [RectangleIntegral, UpperUIntegral, LowerUIntegral] ++ simp only [sub_re, mul_re, I_re, add_re, ofReal_re, I_im, ofReal_im, sub_im, mul_im, add_im] ++ ring_nf ++ abel ++ ++abbrev HolomorphicOn (f : ℂ → E) (s : Set ℂ) : Prop := ++ DifferentiableOn ℂ f s ++ ++theorem existsDifferentiableOn_of_bddAbove [CompleteSpace E] ++ {s : Set ℂ} {c : ℂ} (hc : s ∈ nhds c) ++ (hd : HolomorphicOn f (s \ {c})) ++ (hb : BddAbove (norm ∘ f '' (s \ {c}))) : ++ ∃ (g : ℂ → E), ++ HolomorphicOn g s ∧ Set.EqOn f g (s \ {c}) := ++ ⟨Function.update f c (limUnder (𝓝[{c}ᶜ] c) f), ++ differentiableOn_update_limUnder_of_bddAbove hc hd hb, ++ fun z hz ↦ if h : z = c then (hz.2 h).elim ++ else by simp [h]⟩ ++ ++theorem HolomorphicOn.vanishesOnRectangle [CompleteSpace E] ++ {U : Set ℂ} (f_holo : HolomorphicOn f U) ++ (hU : Rectangle z w ⊆ U) : ++ RectangleIntegral f z w = 0 := ++ integral_boundary_rect_eq_zero_of_differentiableOn f z w ++ (f_holo.mono hU) ++ ++theorem RectangleIntegral_congr (h : Set.EqOn f g (RectangleBorder z w)) : ++ RectangleIntegral f z w = RectangleIntegral g z w := by ++ unfold RectangleIntegral VIntegral ++ congrm ?_ - ?_ + I • ?_ - I • ?_ ++ all_goals refine integral_congr fun _ _ ↦ h ?_ ++ · exact Or.inl <| Or.inl <| Or.inl ⟨by simpa, by simp⟩ ++ · exact Or.inl <| Or.inr ⟨by simpa, by simp⟩ ++ · exact Or.inr ⟨by simp, by simpa⟩ ++ · exact Or.inl <| Or.inl <| Or.inr ⟨by simp, by simpa⟩ ++ ++theorem RectangleIntegral'_congr (h : Set.EqOn f g (RectangleBorder z w)) : ++ RectangleIntegral' f z w = RectangleIntegral' g z w := by ++ rw [RectangleIntegral', RectangleIntegral_congr h] ++ ++theorem rectangleIntegral_symm (f : ℂ → E) (z w : ℂ) : ++ RectangleIntegral f z w = RectangleIntegral f w z := by ++ simp_rw [RectangleIntegral, HIntegral, VIntegral, intervalIntegral.integral_symm w.re, ++ intervalIntegral.integral_symm w.im, sub_neg_eq_add, smul_neg, sub_neg_eq_add, ++ ← sub_eq_add_neg, neg_add_eq_sub, sub_add_eq_add_sub] ++ ++theorem rectangleIntegral_symm_re (f : ℂ → E) (z w : ℂ) : ++ RectangleIntegral f (w.re + z.im * I) (z.re + w.im * I) = -RectangleIntegral f z w := by ++ simp only [RectangleIntegral, add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, ++ mul_one, sub_self, add_zero, add_im, mul_im, zero_add, neg_sub, ← sub_eq_zero, sub_zero] ++ rw [HIntegral_symm (y := z.im), HIntegral_symm (y := w.im)] ++ abel ++ ++def RectangleBorderIntegrable (f : ℂ → E) (z w : ℂ) : Prop := ++ IntervalIntegrable (fun x => f (x + z.im * I)) volume z.re w.re ∧ ++ IntervalIntegrable (fun x => f (x + w.im * I)) volume z.re w.re ∧ ++ IntervalIntegrable (fun y => f (w.re + y * I)) volume z.im w.im ∧ ++ IntervalIntegrable (fun y => f (z.re + y * I)) volume z.im w.im ++ ++theorem RectangleBorderIntegrable.add {f g : ℂ → E} ++ (hf : RectangleBorderIntegrable f z w) (hg : RectangleBorderIntegrable g z w) : ++ RectangleIntegral (f + g) z w = RectangleIntegral f z w + RectangleIntegral g z w := by ++ dsimp [RectangleIntegral, HIntegral, VIntegral] ++ have h₁ := intervalIntegral.integral_add hf.1 hg.1 ++ have h₂ := intervalIntegral.integral_add hf.2.1 hg.2.1 ++ have h₃ := intervalIntegral.integral_add hf.2.2.1 hg.2.2.1 ++ have h₄ := intervalIntegral.integral_add hf.2.2.2 hg.2.2.2 ++ rw [h₁, h₂, h₃, h₄] ++ module ++ ++omit [NormedSpace ℂ E] in ++theorem ContinuousOn.rectangleBorder_integrable (hf : ContinuousOn f (RectangleBorder z w)) : ++ RectangleBorderIntegrable f z w := ++ ⟨(hf.comp (by fun_prop) (mapsTo_rectangleBorder_left_im z w)).intervalIntegrable, ++ (hf.comp (by fun_prop) (mapsTo_rectangleBorder_right_im z w)).intervalIntegrable, ++ (hf.comp (by fun_prop) (mapsTo_rectangleBorder_right_re z w)).intervalIntegrable, ++ (hf.comp (by fun_prop) (mapsTo_rectangleBorder_left_re z w)).intervalIntegrable⟩ ++ ++omit [NormedSpace ℂ E] in ++theorem ContinuousOn.rectangleBorderIntegrable (hf : ContinuousOn f (Rectangle z w)) : ++ RectangleBorderIntegrable f z w := ++ ContinuousOn.rectangleBorder_integrable (hf.mono (rectangleBorder_subset_rectangle z w)) ++ ++omit [NormedSpace ℂ E] in ++theorem ContinuousOn.rectangleBorderNoPIntegrable ++ (hf : ContinuousOn f (Rectangle z w \ {p})) (pNotOnBorder : p ∉ RectangleBorder z w) : ++ RectangleBorderIntegrable f z w := by ++ refine ContinuousOn.rectangleBorder_integrable (hf.mono (Set.subset_sdiff.mpr ?_)) ++ exact ⟨rectangleBorder_subset_rectangle z w, disjoint_singleton_right.mpr pNotOnBorder⟩ ++ ++theorem HolomorphicOn.rectangleBorderIntegrable' ++ (hf : HolomorphicOn f (Rectangle z w \ {p})) (hp : Rectangle z w ∈ nhds p) : ++ RectangleBorderIntegrable f z w := ++ ContinuousOn.rectangleBorderNoPIntegrable hf.continuousOn ++ (not_mem_rectangleBorder_of_rectangle_mem_nhds hp) ++ ++theorem HolomorphicOn.rectangleBorderIntegrable (hf : HolomorphicOn f (Rectangle z w)) : ++ RectangleBorderIntegrable f z w := ContinuousOn.rectangleBorderIntegrable hf.continuousOn ++ ++lemma RectangleIntegralHSplit {a x₀ x₁ y₀ y₁ : ℝ} ++ (f_int_x₀_a_bot : IntervalIntegrable (fun x => f (↑x + ↑y₀ * I)) volume x₀ a) ++ (f_int_a_x₁_bot : IntervalIntegrable (fun x => f (↑x + ↑y₀ * I)) volume a x₁) ++ (f_int_x₀_a_top : IntervalIntegrable (fun x => f (↑x + ↑y₁ * I)) volume x₀ a) ++ (f_int_a_x₁_top : IntervalIntegrable (fun x => f (↑x + ↑y₁ * I)) volume a x₁) : ++ RectangleIntegral f (x₀ + y₀ * I) (x₁ + y₁ * I) = ++ RectangleIntegral f (x₀ + y₀ * I) (a + y₁ * I) + ++ RectangleIntegral f (a + y₀ * I) (x₁ + y₁ * I) := by ++ dsimp [RectangleIntegral, HIntegral, VIntegral] ++ simp only [Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, ++ Complex.I_im, mul_one, mul_zero, add_zero, zero_add, sub_self] ++ have h₁ := integral_add_adjacent_intervals f_int_x₀_a_bot f_int_a_x₁_bot ++ have h₂ := integral_add_adjacent_intervals f_int_x₀_a_top f_int_a_x₁_top ++ have h₁' : ++ (∫ (x : ℝ) in x₀..a, f (↑x + ↑y₀ * I)) + ++ ∫ (x : ℝ) in a..x₁, f (↑y₀ * I + ↑x) = ++ ∫ (x : ℝ) in x₀..x₁, f (↑x + ↑y₀ * I) := by ++ simpa [add_comm] using h₁ ++ have h₂' : ++ (∫ (x : ℝ) in x₀..a, f (↑x + ↑y₁ * I)) + ++ ∫ (x : ℝ) in a..x₁, f (↑y₁ * I + ↑x) = ++ ∫ (x : ℝ) in x₀..x₁, f (↑x + ↑y₁ * I) := by ++ simpa [add_comm] using h₂ ++ rw [← h₁', ← h₂'] ++ have hcomm₁ : ++ ∫ (x : ℝ) in a..x₁, f (↑y₀ * I + ↑x) = ++ ∫ (x : ℝ) in a..x₁, f (↑x + ↑y₀ * I) := by ++ apply intervalIntegral.integral_congr ++ intro x _ ++ exact congrArg f (by ring) ++ have hcomm₂ : ++ ∫ (x : ℝ) in a..x₁, f (↑y₁ * I + ↑x) = ++ ∫ (x : ℝ) in a..x₁, f (↑x + ↑y₁ * I) := by ++ apply intervalIntegral.integral_congr ++ intro x _ ++ exact congrArg f (by ring) ++ rw [hcomm₁, hcomm₂] ++ abel ++ ++lemma RectangleIntegralHSplit' {a x₀ x₁ y₀ y₁ : ℝ} ++ (ha : a ∈ [[x₀, x₁]]) ++ (hf : RectangleBorderIntegrable f (↑x₀ + ↑y₀ * I) (↑x₁ + ↑y₁ * I)) : ++ RectangleIntegral f (x₀ + y₀ * I) (x₁ + y₁ * I) = ++ RectangleIntegral f (x₀ + y₀ * I) (a + y₁ * I) + ++ RectangleIntegral f (a + y₀ * I) (x₁ + y₁ * I) := ++ RectangleIntegralHSplit ++ (IntervalIntegrable.mono (by simpa using hf.1) (uIcc_subset_uIcc left_mem_uIcc ha) le_rfl) ++ (IntervalIntegrable.mono (by simpa using hf.1) (uIcc_subset_uIcc ha right_mem_uIcc) le_rfl) ++ (IntervalIntegrable.mono (by simpa using hf.2.1) (uIcc_subset_uIcc left_mem_uIcc ha) le_rfl) ++ (IntervalIntegrable.mono (by simpa using hf.2.1) (uIcc_subset_uIcc ha right_mem_uIcc) le_rfl) ++ ++lemma RectangleIntegralVSplit {b x₀ x₁ y₀ y₁ : ℝ} ++ (f_int_y₀_b_left : IntervalIntegrable (fun y => f (x₀ + y * I)) volume y₀ b) ++ (f_int_b_y₁_left : IntervalIntegrable (fun y => f (x₀ + y * I)) volume b y₁) ++ (f_int_y₀_b_right : IntervalIntegrable (fun y => f (x₁ + y * I)) volume y₀ b) ++ (f_int_b_y₁_right : IntervalIntegrable (fun y => f (x₁ + y * I)) volume b y₁) : ++ RectangleIntegral f (x₀ + y₀ * I) (x₁ + y₁ * I) = ++ RectangleIntegral f (x₀ + y₀ * I) (x₁ + b * I) + ++ RectangleIntegral f (x₀ + b * I) (x₁ + y₁ * I) := by ++ dsimp [RectangleIntegral, HIntegral, VIntegral] ++ simp only [Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, Complex.I_re, ++ Complex.I_im, mul_one, mul_zero, add_zero, zero_add, sub_self] ++ have h₁ := integral_add_adjacent_intervals f_int_y₀_b_left f_int_b_y₁_left ++ have h₂ := integral_add_adjacent_intervals f_int_y₀_b_right f_int_b_y₁_right ++ rw [← h₁, ← h₂] ++ module ++ ++lemma RectangleIntegralVSplit' {b x₀ x₁ y₀ y₁ : ℝ} ++ (hb : b ∈ [[y₀, y₁]]) ++ (hf : RectangleBorderIntegrable f (↑x₀ + ↑y₀ * I) (↑x₁ + ↑y₁ * I)) : ++ RectangleIntegral f (x₀ + y₀ * I) (x₁ + y₁ * I) = ++ RectangleIntegral f (x₀ + y₀ * I) (x₁ + b * I) + ++ RectangleIntegral f (x₀ + b * I) (x₁ + y₁ * I) := ++ RectangleIntegralVSplit ++ (IntervalIntegrable.mono (by simpa using hf.2.2.2) (uIcc_subset_uIcc left_mem_uIcc hb) le_rfl) ++ (IntervalIntegrable.mono (by simpa using hf.2.2.2) (uIcc_subset_uIcc hb right_mem_uIcc) le_rfl) ++ (IntervalIntegrable.mono (by simpa using hf.2.2.1) (uIcc_subset_uIcc left_mem_uIcc hb) le_rfl) ++ (IntervalIntegrable.mono (by simpa using hf.2.2.1) (uIcc_subset_uIcc hb right_mem_uIcc) le_rfl) ++ ++lemma RectanglePullToNhdOfPole' [CompleteSpace E] {z₀ z₁ z₂ z₃ p : ℂ} ++ (h_orientation : z₀.re ≤ z₃.re ∧ z₀.im ≤ z₃.im ∧ ++ z₁.re ≤ z₂.re ∧ z₁.im ≤ z₂.im) ++ (hp : Rectangle z₁ z₂ ∈ 𝓝 p) (hz : Rectangle z₁ z₂ ⊆ Rectangle z₀ z₃) ++ (fHolo : HolomorphicOn f (Rectangle z₀ z₃ \ {p})) : ++ RectangleIntegral f z₀ z₃ = RectangleIntegral f z₁ z₂ := by ++ obtain ⟨hz₀_re, hz₀_im, hz₁_re, hz₁_im⟩ := h_orientation ++ have := rect_subset_iff.mp hz ++ rw [Rectangle, uIcc_of_le hz₀_re, uIcc_of_le hz₀_im] at this ++ obtain ⟨⟨⟨_, _⟩, ⟨_, _⟩⟩, ⟨_, _⟩, ⟨_, _⟩⟩ := this ++ obtain ⟨⟨_, _⟩, ⟨_, _⟩⟩ := ++ (uIoo_of_le hz₁_re) ▸ (uIoo_of_le hz₁_im) ▸ rectangle_mem_nhds_iff.mp hp ++ obtain ⟨_, _, _, _⟩ := show ++ p.re < z₂.re ∧ p.re < z₃.re ∧ p.im < z₂.im ∧ p.im < z₃.im from ++ ⟨by linarith, by linarith, by linarith, by linarith⟩ ++ obtain ⟨_, _, _, _⟩ := show ++ z₀.re < p.re ∧ z₁.re < p.re ∧ z₀.im < p.im ∧ z₁.im < p.im from ++ ⟨by linarith, by linarith, by linarith, by linarith⟩ ++ have fCont := fHolo.continuousOn ++ have hbot : RectangleBorderIntegrable f (↑z₀.re + ↑z₀.im * I) ++ (↑z₃.re + ↑z₃.im * I) := ?_ ++ have htop : RectangleBorderIntegrable f (↑z₀.re + ↑z₁.im * I) ++ (↑z₃.re + ↑z₃.im * I) := ?_ ++ have hleft : RectangleBorderIntegrable f (↑z₀.re + ↑z₁.im * I) ++ (↑z₃.re + ↑z₂.im * I) := ?_ ++ have hright : RectangleBorderIntegrable f (↑z₁.re + ↑z₁.im * I) ++ (↑z₃.re + ↑z₂.im * I) := ?_ ++ all_goals try { ++ refine ContinuousOn.rectangleBorder_integrable ++ (fCont.mono (rectangleBorder_subset_punctured_rect ?_ ?_)) ++ · simp_all ++ · simpa using ⟨by linarith, by linarith, by linarith, by linarith⟩ ++ } ++ have hbot' : z₁.im ∈ [[z₀.im, z₃.im]] := ?_ ++ have htop' : z₂.im ∈ [[z₁.im, z₃.im]] := ?_ ++ have hleft' : z₁.re ∈ [[z₀.re, z₃.re]] := ?_ ++ have hright' : z₂.re ∈ [[z₁.re, z₃.re]] := ?_ ++ all_goals try { ++ rw [Set.uIcc_of_le] ++ constructor ++ all_goals assumption ++ } ++ have hbot'' : Rectangle (↑z₀.re + ↑z₀.im * I) (↑z₃.re + ↑z₁.im * I) ⊆ ++ Rectangle z₀ z₃ \ {p} := ?_ ++ have htop'' : Rectangle (↑z₀.re + ↑z₂.im * I) (↑z₃.re + ↑z₃.im * I) ⊆ ++ Rectangle z₀ z₃ \ {p} := ?_ ++ have hleft'' : Rectangle (↑z₀.re + ↑z₁.im * I) (↑z₁.re + ↑z₂.im * I) ⊆ ++ Rectangle z₀ z₃ \ {p} := ?_ ++ have hright'' : Rectangle (↑z₂.re + ↑z₁.im * I) (↑z₃.re + ↑z₂.im * I) ⊆ ++ Rectangle z₀ z₃ \ {p} := ?_ ++ all_goals try { apply rectangle_subset_punctured_rect <;> simp_all } ++ have h₁ := RectangleIntegralVSplit' hbot' hbot ++ have h₂ := fHolo.vanishesOnRectangle hbot'' ++ have h₃ := RectangleIntegralVSplit' htop' htop ++ have h₄ := fHolo.vanishesOnRectangle htop'' ++ have h₅ := RectangleIntegralHSplit' hleft' hleft ++ have h₆ := fHolo.vanishesOnRectangle hleft'' ++ have h₇ := RectangleIntegralHSplit' hright' hright ++ have h₈ := fHolo.vanishesOnRectangle hright'' ++ simp only [re_add_im] at * ++ additive_combination h₁ + h₂ + h₃ + h₄ + h₅ + h₆ + h₇ + h₈ ++ ++lemma RectanglePullToNhdOfPole [CompleteSpace E] {z w p : ℂ} ++ (zRe_lt_wRe : z.re ≤ w.re) (zIm_lt_wIm : z.im ≤ w.im) ++ (hp : Rectangle z w ∈ 𝓝 p) (fHolo : HolomorphicOn f (Rectangle z w \ {p})) : ++ ∀ᶠ (c : ℝ) in 𝓝[>]0, ++ RectangleIntegral f z w = RectangleIntegral f (-c - I * c + p) (c + I * c + p) := by ++ filter_upwards [Ioo_mem_nhdsGT zero_lt_one, SmallSquareInRectangle hp] ++ intro c ⟨cpos, _⟩ hc ++ simp_rw [mul_comm I] ++ exact RectanglePullToNhdOfPole' (by simp_all [cpos.le]) ++ (square_mem_nhds p (ne_of_gt cpos)) hc fHolo ++ ++lemma RectanglePullToNhdOfPole'' [CompleteSpace E] {z w p : ℂ} ++ (zRe_le_wRe : z.re ≤ w.re) (zIm_le_wIm : z.im ≤ w.im) ++ (pInRectInterior : Rectangle z w ∈ 𝓝 p) (fHolo : HolomorphicOn f (Rectangle z w \ {p})) : ++ ∀ᶠ (c : ℝ) in 𝓝[>]0, ++ RectangleIntegral' f z w = RectangleIntegral' f (-c - I * c + p) (c + I * c + p) := by ++ filter_upwards [RectanglePullToNhdOfPole zRe_le_wRe zIm_le_wIm pInRectInterior fHolo] with c h ++ simp_rw [RectangleIntegral', h] ++ ++theorem ResidueTheoremAtOrigin_aux1c (a b : ℝ) : ++ let f : ℝ → ℂ := fun y => (y + I)⁻¹ ++ IntervalIntegrable f volume a b := ++ (ContinuousOn.inv₀ (by fun_prop) ++ (by simp [Complex.ext_iff])).intervalIntegrable ++ ++theorem ResidueTheoremAtOrigin_aux1c' (a b : ℝ) : ++ let f : ℝ → ℂ := fun y => (y - I)⁻¹ ++ IntervalIntegrable f volume a b := ++ (ContinuousOn.inv₀ (by fun_prop) ++ (by simp [Complex.ext_iff])).intervalIntegrable ++ ++theorem ResidueTheoremAtOrigin_aux2c (a b : ℝ) : ++ let f : ℝ → ℂ := fun y => (1 + y * I)⁻¹ ++ IntervalIntegrable f volume a b := ++ (ContinuousOn.inv₀ (by fun_prop) ++ (by simp [Complex.ext_iff])).intervalIntegrable ++ ++theorem ResidueTheoremAtOrigin_aux2c' (a b : ℝ) : ++ let f : ℝ → ℂ := fun y => (-1 + y * I)⁻¹ ++ IntervalIntegrable f volume a b := ++ (ContinuousOn.inv₀ (by fun_prop) ++ (by simp [Complex.ext_iff])).intervalIntegrable ++ ++theorem RectangleIntegral.const_smul (f : ℂ → E) (z w c : ℂ) : ++ RectangleIntegral (fun s => c • f s) z w = c • RectangleIntegral f z w := by ++ simp [RectangleIntegral, HIntegral, VIntegral, smul_add, smul_sub, smul_smul, mul_comm] ++ ++theorem RectangleIntegral.const_mul' (f : ℂ → E) (z w c : ℂ) : ++ RectangleIntegral' (fun s => c • f s) z w = c • RectangleIntegral' f z w := by ++ simp [RectangleIntegral', RectangleIntegral.const_smul, smul_smul] ++ ring_nf ++ ++theorem RectangleIntegral.translate (f : ℂ → E) (z w p : ℂ) : ++ RectangleIntegral (fun s => f (s - p)) z w = RectangleIntegral f (z - p) (w - p) := by ++ simp_rw [RectangleIntegral, HIntegral, VIntegral, sub_re, sub_im, ++ ← intervalIntegral.integral_comp_sub_right] ++ congr <;> ext <;> congr 1 <;> simp [Complex.ext_iff] ++ ++theorem RectangleIntegral.translate' (f : ℂ → E) (z w p : ℂ) : ++ RectangleIntegral' (fun s => f (s - p)) z w = RectangleIntegral' f (z - p) (w - p) := by ++ simp_rw [RectangleIntegral', RectangleIntegral.translate] ++ ++lemma Complex.inv_re_add_im : (x + y * I)⁻¹ = (x - I * y) / (x ^ 2 + y ^ 2) := by ++ rw [Complex.inv_def, div_eq_mul_inv] ++ congr <;> simp [conj_ofReal, normSq] <;> ring ++ ++lemma sq_add_sq_ne_zero (hy : y ≠ 0) : x ^ 2 + y ^ 2 ≠ 0 := by ++ linarith [sq_nonneg x, sq_pos_iff.mpr hy] ++ ++lemma continuous_self_div_sq_add_sq (hy : y ≠ 0) : ++ Continuous fun x => x / (x ^ 2 + y ^ 2) := ++ continuous_id.div (continuous_id.pow 2 |>.add continuous_const) (fun _ => sq_add_sq_ne_zero hy) ++ ++lemma integral_self_div_sq_add_sq (hy : y ≠ 0) : ++ ∫ x in x₁..x₂, x / (x ^ 2 + y ^ 2) = ++ Real.log (x₂ ^ 2 + y ^ 2) / 2 - Real.log (x₁ ^ 2 + y ^ 2) / 2 := by ++ let f (x : ℝ) : ℝ := Real.log (x ^ 2 + y ^ 2) / 2 ++ have e1 {x} := HasDerivAt.add_const (y ^ 2) (by simpa using hasDerivAt_pow 2 x) ++ have e2 {x} : HasDerivAt f (x / (x ^ 2 + y ^ 2)) x := by ++ convert! (e1.log (sq_add_sq_ne_zero hy)).div_const 2 using 1 ++ field_simp ++ have e3 : deriv f = fun x => x / (x ^ 2 + y ^ 2) := funext (fun _ => e2.deriv) ++ have e4 : Continuous (deriv f) := by simpa only [e3] using continuous_self_div_sq_add_sq hy ++ simp_rw [← e2.deriv] ++ exact integral_deriv_eq_sub (fun _ _ => e2.differentiableAt) (e4.intervalIntegrable _ _) ++ ++lemma integral_const_div_sq_add_sq (hy : y ≠ 0) : ++ ∫ x in x₁..x₂, y / (x ^ 2 + y ^ 2) = arctan (x₂ / y) - arctan (x₁ / y) := by ++ nth_rewrite 1 [← div_mul_cancel₀ x₁ hy, ← div_mul_cancel₀ x₂ hy] ++ simp_rw [← mul_integral_comp_mul_right, ← intervalIntegral.integral_const_mul, ++ ← integral_one_div_one_add_sq] ++ exact integral_congr fun x _ => by ++ field_simp ++ ring ++ ++lemma integral_const_div_self_add_im (hy : y ≠ 0) : ++ ∫ x : ℝ in x₁..x₂, A / (x + y * I) = ++ A * (Real.log (x₂ ^ 2 + y ^ 2) / 2 - Real.log (x₁ ^ 2 + y ^ 2) / 2) - ++ A * I * (arctan (x₂ / y) - arctan (x₁ / y)) := by ++ have e1 {x : ℝ} : A / (x + y * I) = A * x / (x ^ 2 + y ^ 2) - A * I * y / (x ^ 2 + y ^ 2) := by ++ ring_nf ++ simp_rw [Complex.inv_re_add_im] ++ ring ++ have e2 : IntervalIntegrable (fun x ↦ A * x / (x ^ 2 + y ^ 2)) volume x₁ x₂ := by ++ apply Continuous.intervalIntegrable ++ simp_rw [mul_div_assoc] ++ norm_cast ++ exact continuous_const.mul (continuous_ofReal.comp (continuous_self_div_sq_add_sq hy)) ++ have e3 : IntervalIntegrable (fun x ↦ A * I * y / (x ^ 2 + y ^ 2)) volume x₁ x₂ := by ++ apply Continuous.intervalIntegrable ++ refine continuous_const.div (by fun_prop) (fun x => ?_) ++ norm_cast ++ exact sq_add_sq_ne_zero hy ++ simp_rw [integral_congr (fun _ _ => e1), integral_sub e2 e3, mul_div_assoc] ++ norm_cast ++ simp_rw [intervalIntegral.integral_const_mul, intervalIntegral.integral_ofReal, ++ integral_self_div_sq_add_sq hy, integral_const_div_sq_add_sq hy] ++ ++lemma integral_const_div_re_add_self (hx : x ≠ 0) : ++ ∫ y : ℝ in y₁..y₂, A / (x + y * I) = ++ A / I * (Real.log (y₂ ^ 2 + (-x) ^ 2) / 2 - Real.log (y₁ ^ 2 + (-x) ^ 2) / 2) - ++ A / I * I * (arctan (y₂ / -x) - arctan (y₁ / -x)) := by ++ have l1 {y : ℝ} : A / (x + y * I) = A / I / (y + ↑(-x) * I) := by ++ have e1 : x + y * I ≠ 0 := by ++ contrapose! hx ++ simpa using congr_arg re hx ++ have e2 : y + I * ↑(-x) ≠ 0 := by ++ contrapose! hx ++ simpa using congr_arg im hx ++ field_simp [*] ++ push_cast ++ ring_nf ++ simp ++ have l2 : -x ≠ 0 := by rwa [neg_ne_zero] ++ simp_rw [l1, integral_const_div_self_add_im l2] ++ ++lemma ResidueTheoremAtOrigin' {z w c : ℂ} ++ (h1 : z.re < 0) (h2 : z.im < 0) (h3 : 0 < w.re) (h4 : 0 < w.im) : ++ RectangleIntegral (fun s => c / s) z w = 2 * I * π * c := by ++ simp only [RectangleIntegral, HIntegral, VIntegral, smul_eq_mul] ++ rw [integral_const_div_re_add_self h1.ne, integral_const_div_re_add_self h3.ne.symm] ++ rw [integral_const_div_self_add_im h2.ne, integral_const_div_self_add_im h4.ne.symm] ++ have l1 : z.im * w.re⁻¹ = (w.re * z.im⁻¹)⁻¹ := by group ++ have l3 := arctan_inv_of_neg <| mul_neg_of_pos_of_neg h3 <| inv_lt_zero.mpr h2 ++ have l4 : w.im * z.re⁻¹ = (z.re * w.im⁻¹)⁻¹ := by group ++ have l6 := arctan_inv_of_neg <| mul_neg_of_neg_of_pos h1 <| inv_pos.mpr h4 ++ have r1 : z.im * z.re⁻¹ = (z.re * z.im⁻¹)⁻¹ := by group ++ have r3 := arctan_inv_of_pos <| mul_pos_of_neg_of_neg h1 <| inv_lt_zero.mpr h2 ++ have r4 : w.im * w.re⁻¹ = (w.re * w.im⁻¹)⁻¹ := by group ++ have r6 := arctan_inv_of_pos <| mul_pos h3 <| inv_pos.mpr h4 ++ ring_nf ++ simp only [one_div, inv_I, mul_neg, neg_mul, I_sq, neg_neg, arctan_neg, ofReal_neg, ++ sub_neg_eq_add] ++ rw [l1, l3, l4, l6, r1, r3, r4, r6] ++ ring_nf ++ simp only [I_sq, ofReal_sub, ofReal_mul, ofReal_ofNat, ofReal_div, ofReal_neg, ofReal_one] ++ ring_nf ++ ++theorem ResidueTheoremInRectangle ++ (zRe_le_wRe : z.re ≤ w.re) (zIm_le_wIm : z.im ≤ w.im) ++ (pInRectInterior : Rectangle z w ∈ 𝓝 p) : ++ RectangleIntegral' (fun s => c / (s - p)) z w = c := by ++ simp only [rectangle_mem_nhds_iff, uIoo_of_le zRe_le_wRe, uIoo_of_le zIm_le_wIm, ++ mem_reProdIm, mem_Ioo] at pInRectInterior ++ rw [RectangleIntegral.translate', RectangleIntegral'] ++ have : 1 / (2 * ↑π * I) * (2 * I * ↑π * c) = c := by ++ field_simp ++ rwa [ResidueTheoremAtOrigin'] ++ all_goals simp [*] ++ ++lemma ResidueTheoremAtOrigin : ++ RectangleIntegral' (fun s ↦ 1 / s) (-1 - I) (1 + I) = 1 := by ++ rw [RectangleIntegral', ResidueTheoremAtOrigin'] ++ all_goals simp [field] ++ ++lemma ResidueTheoremOnRectangleWithSimplePole {f g : ℂ → ℂ} {z w p A : ℂ} ++ (zRe_le_wRe : z.re ≤ w.re) (zIm_le_wIm : z.im ≤ w.im) ++ (pInRectInterior : Rectangle z w ∈ 𝓝 p) (gHolo : HolomorphicOn g (Rectangle z w)) ++ (principalPart : Set.EqOn (f - fun s ↦ A / (s - p)) g (Rectangle z w \ {p})) : ++ RectangleIntegral' f z w = A := by ++ have principalPart' : Set.EqOn f (g + (fun s ↦ A / (s - p))) (Rectangle z w \ {p}) := ++ fun s hs => by rw [Pi.add_apply, ← principalPart hs, Pi.sub_apply, sub_add_cancel] ++ have : Set.EqOn f (g + (fun s ↦ A / (s - p))) (RectangleBorder z w) := ++ principalPart'.mono <| Set.subset_sdiff.mpr ++ ⟨rectangleBorder_subset_rectangle z w, ++ disjoint_singleton_right.mpr ++ (not_mem_rectangleBorder_of_rectangle_mem_nhds pInRectInterior)⟩ ++ rw [RectangleIntegral'_congr this] ++ have t1 : RectangleBorderIntegrable g z w := ++ gHolo.rectangleBorderIntegrable ++ have t2 : HolomorphicOn (fun s ↦ A / (s - p)) (Rectangle z w \ {p}) := by ++ apply DifferentiableOn.mono (t := {p}ᶜ) ++ · apply DifferentiableOn.div ++ · exact differentiableOn_const _ ++ · exact DifferentiableOn.sub differentiableOn_id (differentiableOn_const _) ++ · exact fun x hx => by ++ rw [sub_ne_zero] ++ exact hx ++ · rintro s ⟨_, hs⟩ ++ exact hs ++ have t3 : RectangleBorderIntegrable (fun s ↦ A / (s - p)) z w := ++ HolomorphicOn.rectangleBorderIntegrable' t2 pInRectInterior ++ rw [RectangleIntegral', RectangleBorderIntegrable.add t1 t3, smul_add] ++ rw [gHolo.vanishesOnRectangle (by rfl), smul_zero, zero_add] ++ exact ResidueTheoremInRectangle zRe_le_wRe zIm_le_wIm pInRectInterior ++ ++lemma IsBigO_to_BddAbove {f : ℂ → ℂ} {p : ℂ} ++ (f_near_p : f =O[𝓝[≠] p] (1 : ℂ → ℂ)) : ++ ∃ U ∈ 𝓝 p, BddAbove (norm ∘ f '' (U \ {p})) := by ++ simp only [isBigO_iff, Pi.one_apply, one_mem, CStarRing.norm_of_mem_unitary, mul_one] at f_near_p ++ obtain ⟨c, hc⟩ := f_near_p ++ dsimp [Filter.Eventually, nhdsWithin] at hc ++ rw [mem_inf_principal'] at hc ++ obtain ⟨U, hU, ⟨U_is_open, p_in_U⟩⟩ := mem_nhds_iff.mp hc ++ use U ++ constructor ++ · exact IsOpen.mem_nhds U_is_open p_in_U ++ · refine bddAbove_def.mpr ?_ ++ use c ++ intro y hy ++ simp only [Function.comp_apply, mem_image, Set.mem_sdiff, mem_singleton_iff] at hy ++ obtain ⟨x, ⟨x_in_U, x_not_p⟩, fxy⟩ := hy ++ rw [← fxy] ++ simpa [x_not_p] using hU x_in_U ++ ++theorem BddAbove_on_rectangle_of_bdd_near {z w p : ℂ} {f : ℂ → ℂ} ++ (f_cont : ContinuousOn f (Rectangle z w \ {p})) ++ (f_near_p : f =O[𝓝[≠] p] (1 : ℂ → ℂ)) : ++ BddAbove (norm ∘ f '' (Rectangle z w \ {p})) := by ++ obtain ⟨V, V_in_nhds, V_prop⟩ := IsBigO_to_BddAbove f_near_p ++ rw [mem_nhds_iff] at V_in_nhds ++ obtain ⟨W, W_subset, W_open, p_in_W⟩ := V_in_nhds ++ set U := Rectangle z w ++ have : U \ {p} = (U \ W) ∪ ((U ∩ W) \ {p}) := by ++ ext x ++ simp only [Set.mem_sdiff, mem_singleton_iff, mem_union, mem_inter_iff] ++ constructor ++ · intro ⟨xu, x_not_p⟩ ++ tauto ++ · intro h ++ rcases h with ⟨h1, h2⟩ | ⟨⟨h1, h2⟩, h3⟩ ++ · refine ⟨h1, ?_⟩ ++ intro h ++ rw [← h] at p_in_W ++ exact h2 p_in_W ++ · tauto ++ rw [this, image_union] ++ apply BddAbove.union ++ · apply IsCompact.bddAbove_image ++ · apply IsCompact.diff _ W_open ++ exact IsCompact.reProdIm isCompact_uIcc isCompact_uIcc ++ · apply f_cont.norm.mono ++ apply Set.sdiff_subset_sdiff_right ++ simpa ++ · exact V_prop.mono ++ (image_mono <| Set.sdiff_subset_sdiff_left <| subset_trans inter_subset_right W_subset) ++ ++theorem ResidueTheoremOnRectangleWithSimplePole' {f : ℂ → ℂ} {z w p A : ℂ} ++ (zRe_le_wRe : z.re ≤ w.re) (zIm_le_wIm : z.im ≤ w.im) ++ (pInRectInterior : Rectangle z w ∈ 𝓝 p) (fHolo : HolomorphicOn f (Rectangle z w \ {p})) ++ (near_p : (f - (fun s ↦ A / (s - p))) =O[𝓝[≠] p] (1 : ℂ → ℂ)) : ++ RectangleIntegral' f z w = A := by ++ set g := f - (fun s ↦ A / (s - p)) ++ have gHolo : HolomorphicOn g (Rectangle z w \ {p}) := by ++ apply DifferentiableOn.sub fHolo ++ intro s hs ++ have : s - p ≠ 0 := sub_ne_zero.mpr hs.2 ++ exact DifferentiableWithinAt.div (by fun_prop) (by fun_prop) this ++ have := BddAbove_on_rectangle_of_bdd_near gHolo.continuousOn near_p ++ obtain ⟨h, ⟨hHolo, hEq⟩⟩ := existsDifferentiableOn_of_bddAbove pInRectInterior gHolo this ++ exact ResidueTheoremOnRectangleWithSimplePole zRe_le_wRe zIm_le_wIm pInRectInterior hHolo hEq ++ ++def HasSimplePolesOn (f : ℂ → ℂ) (s : Set ℂ) : Prop := ++ ∀ z ∈ s, (-1 : ℤ) ≤ meromorphicOrderAt f z ++ ++lemma HasSimplePolesOn.mono {f : ℂ → ℂ} {s t : Set ℂ} ++ (h : HasSimplePolesOn f t) (hst : s ⊆ t) : HasSimplePolesOn f s := by ++ intro z hz ++ exact h z (hst hz) ++ ++noncomputable def residue (f : ℂ → ℂ) (z₀ : ℂ) : ℂ := ++ Filter.limUnder (nhdsWithin z₀ {z₀}ᶜ) (fun z ↦ (z - z₀) * f z) ++ ++noncomputable def sumResiduesIn (f : ℂ → ℂ) (S : Set ℂ) : ℂ := ++ ∑' z : S, residue f z ++ ++lemma residue_eq_of_tendsto {f : ℂ → ℂ} {p c : ℂ} ++ (h : Filter.Tendsto (fun z ↦ (z - p) * f z) (nhdsWithin p {p}ᶜ) (nhds c)) : ++ residue f p = c := by ++ unfold residue ++ exact h.limUnder_eq ++ ++lemma residue_analyticAt_eq_zero {f : ℂ → ℂ} {p : ℂ} (hf : AnalyticAt ℂ f p) : ++ residue f p = 0 := by ++ apply residue_eq_of_tendsto ++ have hsub : Filter.Tendsto (fun z : ℂ ↦ z - p) (nhdsWithin p {p}ᶜ) (nhds 0) := ++ tendsto_sub_nhds_zero_iff.mpr (tendsto_id.mono_left nhdsWithin_le_nhds) ++ have hf' : Filter.Tendsto f (nhdsWithin p {p}ᶜ) (nhds (f p)) := ++ hf.continuousAt.continuousWithinAt.tendsto ++ simpa using hsub.mul hf' ++ ++lemma simplePole_sub_residue_isBigO_one {f : ℂ → ℂ} {p : ℂ} ++ (hf : MeromorphicAt f p) (hord : meromorphicOrderAt f p = (-1 : ℤ)) : ++ (f - (fun z ↦ residue f p / (z - p))) =O[nhdsWithin p {p}ᶜ] (1 : ℂ → ℂ) := by ++ obtain ⟨g, hg_analytic, hg_ne, hg_eq⟩ := (meromorphicOrderAt_eq_int_iff hf).1 hord ++ have hres : residue f p = g p := ++ residue_eq_of_tendsto (hg_analytic.continuousAt.continuousWithinAt.tendsto.congr' ++ (show (fun z ↦ (z - p) * f z) =ᶠ[nhdsWithin p {p}ᶜ] g from by ++ filter_upwards [hg_eq, self_mem_nhdsWithin] with z hz hz_ne ++ simp [hz, sub_ne_zero.mpr hz_ne]).symm) ++ have hdslope : (fun z ↦ (z - p)⁻¹ * (g z - g p)) =O[nhdsWithin p {p}ᶜ] (1 : ℂ → ℂ) := by ++ have hcont : ContinuousAt (dslope g p) p := ++ continuousAt_dslope_same.2 hg_analytic.differentiableAt ++ have hbig : dslope g p =O[nhds p] (1 : ℂ → ℂ) := ++ hcont.norm.isBoundedUnder_le.isBigO_one ℂ ++ have hbig_ne : dslope g p =O[nhdsWithin p {p}ᶜ] (1 : ℂ → ℂ) := ++ IsBigO.mono hbig inf_le_left ++ simpa [slope] using! hbig_ne.congr' (dslope_eventuallyEq_slope_nhdsNE (f := g) (a := p)) .rfl ++ refine hdslope.congr' ?_ .rfl ++ filter_upwards [hg_eq, self_mem_nhdsWithin] with z hz hz_ne ++ simp [hz, hres, div_eq_mul_inv, sub_eq_add_neg]; ring ++ ++private lemma intervalIntegral_congr_ae_of_codiscreteWithin_along_path ++ {f g : ℂ → ℂ} {R : Set ℂ} ++ (heq : {s : ℂ | f s = g s} ∈ Filter.codiscreteWithin R) ++ {a b : ℝ} {p : ℝ → ℂ} ++ (hp_an : AnalyticOnNhd ℝ p (Set.uIcc a b)) ++ (hp_nonconst : ∀ x ∈ Set.uIcc a b, ¬Filter.EventuallyConst p (nhds x)) ++ (hp_maps : Set.MapsTo p (Set.uIcc a b) R) : ++ ∫ x in a..b, f (p x) = ∫ x in a..b, g (p x) := by ++ refine intervalIntegral.integral_congr_ae_restrict (μ := volume) ?_ ++ apply ae_restrict_le_codiscreteWithin measurableSet_uIoc ++ change {x : ℝ | f (p x) = g (p x)} ∈ Filter.codiscreteWithin (Set.uIoc a b) ++ simpa [Set.preimage] using Filter.codiscreteWithin_mono Set.uIoc_subset_uIcc ++ (hp_an.preimage_mem_codiscreteWithin hp_nonconst ++ (Filter.codiscreteWithin_mono ++ (by intro s hs; rcases hs with ⟨x, hx, rfl⟩; exact hp_maps hx) heq)) ++ ++private lemma meromorphicOrderAt_eq_neg_one_of_simplePole ++ {f : ℂ → ℂ} {U : Set ℂ} {p : ℂ} ++ (hpU : p ∈ U) ++ (hf_simple : HasSimplePolesOn f U) ++ (hpneg : meromorphicOrderAt f p < 0) : ++ meromorphicOrderAt f p = (-1 : ℤ) := by ++ lift meromorphicOrderAt f p to ℤ using hpneg.ne_top with n hn ++ have hsimple : (-1 : ℤ) ≤ n := WithTop.coe_le_coe.mp (hn ▸ hf_simple p hpU) ++ have hneg : n < 0 := by exact_mod_cast hpneg ++ have hn1 : n = -1 := by omega ++ simp [hn1] ++ ++private lemma residue_toMeromorphicNFOn_eq_residue ++ {f : ℂ → ℂ} {U : Set ℂ} {p : ℂ} ++ (hpU : p ∈ U) ++ (hf_mero : MeromorphicOn f U) ++ (hf_simple : HasSimplePolesOn f U) ++ (hpneg : meromorphicOrderAt f p < 0) : ++ residue (toMeromorphicNFOn f U) p = residue f p := by ++ have hmero : MeromorphicAt f p := hf_mero p hpU ++ have h_exists : ∃ c, Filter.Tendsto (fun z : ℂ ↦ (z - p) * f z) (nhdsWithin p ({p}ᶜ)) (nhds c) := by ++ have hmul_mero : MeromorphicAt (fun z : ℂ ↦ (z - p) * f z) p := ++ (by fun_prop : MeromorphicAt (fun z : ℂ ↦ z - p) p).mul hmero ++ have hmul_nonneg : 0 ≤ meromorphicOrderAt (fun z : ℂ ↦ (z - p) * f z) p := by ++ change 0 ≤ meromorphicOrderAt ((fun z ↦ z - p) * f) p ++ rw [meromorphicOrderAt_mul (by fun_prop : MeromorphicAt (fun z : ℂ ↦ z - p) p) hmero, ++ meromorphicOrderAt_id_sub_const, ++ meromorphicOrderAt_eq_neg_one_of_simplePole hpU hf_simple hpneg] ++ norm_num ++ exact tendsto_nhds_of_meromorphicOrderAt_nonneg hmul_mero hmul_nonneg ++ have h_tendsto : Filter.Tendsto (fun z : ℂ ↦ (z - p) * f z) (nhdsWithin p ({p}ᶜ)) (nhds (residue f p)) := by ++ simpa [residue] using tendsto_nhds_limUnder h_exists ++ have h_eq : ++ (fun z ↦ (z - p) * toMeromorphicNFOn f U z) =ᶠ[nhdsWithin p ({p}ᶜ)] ++ (fun z ↦ (z - p) * f z) := by ++ filter_upwards [hf_mero.toMeromorphicNFOn_eq_self_on_nhdsNE hpU] with z hz ++ simp [hz] ++ exact residue_eq_of_tendsto ++ (h_tendsto.congr' h_eq.symm) ++ ++private lemma horizontalPath_not_eventuallyConst (h : ℝ) (x : ℝ) : ++ ¬Filter.EventuallyConst (fun r : ℝ ↦ (r : ℂ) + (h : ℂ) * Complex.I) (nhds x) := by ++ intro hc ++ obtain ⟨c, hc⟩ := Filter.eventuallyConst_iff_exists_eventuallyEq.1 hc ++ have hpath : HasDerivAt (fun r : ℝ ↦ (r : ℂ) + (h : ℂ) * Complex.I) 1 x := by ++ simpa using (Complex.ofRealCLM.hasDerivAt (x := x)).add_const ((h : ℂ) * Complex.I) ++ have hconst : HasDerivAt (fun r : ℝ ↦ (r : ℂ) + (h : ℂ) * Complex.I) 0 x := ++ (hasDerivAt_const x c).congr_of_eventuallyEq hc ++ exact one_ne_zero (hpath.unique hconst) ++ ++lemma verticalPath_not_eventuallyConst (r : ℝ) (x : ℝ) : ++ ¬Filter.EventuallyConst (fun y : ℝ ↦ (r : ℂ) + (y : ℂ) * Complex.I) (nhds x) := by ++ intro hc ++ obtain ⟨c, hc⟩ := Filter.eventuallyConst_iff_exists_eventuallyEq.1 hc ++ have hpath : HasDerivAt (fun y : ℝ ↦ (r : ℂ) + (y : ℂ) * Complex.I) Complex.I x := by ++ simpa using ((Complex.ofRealCLM.hasDerivAt (x := x)).mul_const Complex.I).const_add (r : ℂ) ++ have hconst : HasDerivAt (fun y : ℝ ↦ (r : ℂ) + (y : ℂ) * Complex.I) 0 x := ++ (hasDerivAt_const x c).congr_of_eventuallyEq hc ++ exact Complex.I_ne_zero (hpath.unique hconst) ++ ++private lemma HIntegral_congr_codiscreteWithin {f g : ℂ → ℂ} {R : Set ℂ} {a b c : ℝ} ++ (h_eq : {s : ℂ | f s = g s} ∈ Filter.codiscreteWithin R) ++ (hmaps : ∀ x ∈ Set.uIcc a b, (↑x + ↑c * Complex.I) ∈ R) : ++ HIntegral f a b c = HIntegral g a b c := by ++ unfold HIntegral ++ exact intervalIntegral_congr_ae_of_codiscreteWithin_along_path h_eq ++ (by intro x _; exact (Complex.ofRealCLM.analyticAt x).add analyticAt_const) ++ (fun x _ ↦ horizontalPath_not_eventuallyConst c x) hmaps ++ ++private lemma VIntegral_congr_codiscreteWithin {f g : ℂ → ℂ} {R : Set ℂ} {c a b : ℝ} ++ (h_eq : {s : ℂ | f s = g s} ∈ Filter.codiscreteWithin R) ++ (hmaps : ∀ y ∈ Set.uIcc a b, (↑c + ↑y * Complex.I) ∈ R) : ++ VIntegral f c a b = VIntegral g c a b := by ++ unfold VIntegral; simp only [smul_eq_mul]; congr 1 ++ exact intervalIntegral_congr_ae_of_codiscreteWithin_along_path h_eq ++ (by intro y _; exact analyticAt_const.add ((Complex.ofRealCLM.analyticAt y).mul analyticAt_const)) ++ (fun x _ ↦ verticalPath_not_eventuallyConst c x) hmaps ++ ++private lemma rectangleIntegral'_toMeromorphicNFOn_eq {f : ℂ → ℂ} {z w : ℂ} ++ (f_mero : MeromorphicOn f (Rectangle z w)) : ++ RectangleIntegral' f z w = RectangleIntegral' (toMeromorphicNFOn f (Rectangle z w)) z w := by ++ classical ++ let R : Set ℂ := Rectangle z w ++ let fNF : ℂ → ℂ := toMeromorphicNFOn f R ++ have h_eq : {s : ℂ | f s = fNF s} ∈ Filter.codiscreteWithin R := by ++ simpa [Filter.EventuallyEq, Filter.Eventually, fNF] using ++ (toMeromorphicNFOn_eqOn_codiscrete (f := f) (U := R) f_mero) ++ have hbot := HIntegral_congr_codiscreteWithin h_eq (by simpa [R] using! mapsTo_rectangle_left_im z w) ++ have htop := HIntegral_congr_codiscreteWithin h_eq (by simpa [R] using! mapsTo_rectangle_right_im z w) ++ have hright := VIntegral_congr_codiscreteWithin h_eq (by simpa [R] using! mapsTo_rectangle_right_re z w) ++ have hleft := VIntegral_congr_codiscreteWithin h_eq (by simpa [R] using! mapsTo_rectangle_left_re z w) ++ unfold RectangleIntegral'; congr 1; unfold RectangleIntegral ++ rw [hbot, htop, hright, hleft] ++ ++private lemma principalPart_meromorphicOn {R : Set ℂ} {polesFin : Finset ℂ} {c : ℂ → ℂ} : ++ MeromorphicOn (fun s ↦ ∑ p ∈ polesFin, c p / (s - p)) R := by ++ intro x _ ++ refine MeromorphicAt.fun_sum (G := fun p s ↦ c p / (s - p)) ?_ ++ intro p _ ++ exact (analyticAt_const.meromorphicAt.div ++ ((analyticAt_id.sub analyticAt_const).meromorphicAt)) ++ ++private lemma sub_principalPart_analyticAt_of_not_mem_poles ++ {f : ℂ → ℂ} {polesFin : Finset ℂ} {x : ℂ} ++ (h_nf : MeromorphicNFAt f x) ++ (hxnp : x ∉ polesFin) ++ (hxneg : 0 ≤ meromorphicOrderAt f x) : ++ AnalyticAt ℂ (f - fun s ↦ ∑ p ∈ polesFin, residue f p / (s - p)) x := by ++ have h_f_analytic : AnalyticAt ℂ f x := ++ h_nf.meromorphicOrderAt_nonneg_iff_analyticAt.1 hxneg ++ have h_principal_analytic : AnalyticAt ℂ (fun s ↦ ∑ p ∈ polesFin, residue f p / (s - p)) x := by ++ refine Finset.analyticAt_fun_sum polesFin ?_ ++ intro p hp ++ have hxp : x ≠ p := by ++ intro heq ++ subst heq ++ exact hxnp hp ++ have : AnalyticAt ℂ (fun z : ℂ ↦ residue f p / (z - p)) x := by ++ fun_prop (disch := exact sub_ne_zero.mpr hxp) ++ simpa using this ++ exact h_f_analytic.sub h_principal_analytic ++ ++private lemma meromorphicOrderAt_sub_principalPart_nonneg ++ {f : ℂ → ℂ} {polesFin : Finset ℂ} {p : ℂ} ++ (hpFin : p ∈ polesFin) ++ (h_mero : MeromorphicAt f p) ++ (h_ord : meromorphicOrderAt f p = -1) : ++ 0 ≤ meromorphicOrderAt (f - fun s ↦ ∑ q ∈ polesFin, residue f q / (s - q)) p := by ++ have hcore : (f - fun z ↦ residue f p / (z - p)) =O[nhdsWithin p ({p}ᶜ)] (1 : ℂ → ℂ) := by ++ exact simplePole_sub_residue_isBigO_one h_mero h_ord ++ let rest : ℂ → ℂ := fun z ↦ ∑ q ∈ polesFin.erase p, residue f q / (z - q) ++ have hrest_cont : ContinuousAt rest p := by ++ dsimp [rest] ++ refine tendsto_finsetSum _ (fun q hq ↦ ?_) ++ have hpq : p - q ≠ 0 := sub_ne_zero.mpr (Finset.mem_erase.mp hq).1.symm ++ have h_cont : ContinuousAt (fun z : ℂ ↦ residue f q / (z - q)) p := by ++ fun_prop (disch := exact hpq) ++ exact h_cont ++ have hrest : rest =O[nhdsWithin p ({p}ᶜ)] (1 : ℂ → ℂ) := by ++ have hbig : rest =O[nhds p] (1 : ℂ → ℂ) := ++ hrest_cont.norm.isBoundedUnder_le.isBigO_one ℂ ++ exact IsBigO.mono hbig inf_le_left ++ have hraw_big : (f - fun s ↦ ∑ q ∈ polesFin, residue f q / (s - q)) =O[nhdsWithin p ({p}ᶜ)] (1 : ℂ → ℂ) := by ++ have htmp : (fun z : ℂ ↦ (f z - residue f p / (z - p)) - rest z) =O[nhdsWithin p ({p}ᶜ)] (1 : ℂ → ℂ) := ++ hcore.sub hrest ++ have hdecomp : (f - fun s ↦ ∑ q ∈ polesFin, residue f q / (s - q)) = ++ (fun z : ℂ ↦ (f z - residue f p / (z - p)) - rest z) := by ++ funext z ++ dsimp [rest] ++ rw [← Finset.add_sum_erase (s := polesFin) (f := fun q ↦ residue f q / (z - q)) hpFin] ++ simp [sub_eq_add_neg, add_assoc, add_comm] ++ simpa [hdecomp, rest] using htmp ++ by_contra hneg ++ have hnorm : Filter.Tendsto (fun z : ℂ ↦ ‖(f - fun s ↦ ∑ q ∈ polesFin, residue f q / (s - q)) z‖) (nhdsWithin p ({p}ᶜ)) Filter.atTop := by ++ rw [tendsto_norm_atTop_iff_cobounded] ++ exact tendsto_cobounded_of_meromorphicOrderAt_neg (not_le.mp hneg) ++ exact (Filter.not_isBoundedUnder_of_tendsto_atTop hnorm) hraw_big.isBoundedUnder_le ++ ++private lemma holoPart_holomorphicOn {f : ℂ → ℂ} {z w : ℂ} ++ (f_mero : MeromorphicOn f (Rectangle z w)) ++ (f_simple_poles : HasSimplePolesOn f (Rectangle z w)) ++ (f_poles_finite : (Rectangle z w ∩ {z | meromorphicOrderAt f z < 0}).Finite) : ++ HolomorphicOn (toMeromorphicNFOn (toMeromorphicNFOn f (Rectangle z w) - ++ fun s ↦ ∑ p ∈ f_poles_finite.toFinset, residue (toMeromorphicNFOn f (Rectangle z w)) p / (s - p)) (Rectangle z w)) (Rectangle z w) := by ++ classical ++ let R := Rectangle z w ++ let poles := R ∩ {u | meromorphicOrderAt f u < 0} ++ let polesFin := f_poles_finite.toFinset ++ let fNF := toMeromorphicNFOn f R ++ let principalPart := fun s ↦ ∑ p ∈ polesFin, residue fNF p / (s - p) ++ let holoPart := toMeromorphicNFOn (fNF - principalPart) R ++ have h_fNF_mero : MeromorphicOn fNF R := by ++ simpa [fNF] using ++ (meromorphicNFOn_toMeromorphicNFOn (f := f) (U := R)).meromorphicOn ++ have h_principalPart_mero : MeromorphicOn principalPart R := principalPart_meromorphicOn ++ have h_raw_mero : MeromorphicOn (fNF - principalPart) R := h_fNF_mero.sub h_principalPart_mero ++ intro x hx ++ have h_raw_nonneg : 0 ≤ meromorphicOrderAt (fNF - principalPart) x := by ++ by_cases hxp : x ∈ poles ++ · have hpFin : x ∈ polesFin := by simpa [polesFin, poles] using hxp ++ have hord : meromorphicOrderAt f x = (-1 : ℤ) := ++ meromorphicOrderAt_eq_neg_one_of_simplePole hxp.1 f_simple_poles hxp.2 ++ have hordNF : meromorphicOrderAt fNF x = (-1 : ℤ) := by ++ rw [show meromorphicOrderAt fNF x = meromorphicOrderAt f x by ++ simpa [fNF] using ++ (meromorphicOrderAt_toMeromorphicNFOn (f := f) (U := R) f_mero hxp.1)] ++ exact hord ++ exact meromorphicOrderAt_sub_principalPart_nonneg hpFin (h_fNF_mero x hxp.1) hordNF ++ · have hxnp : x ∉ polesFin := by ++ intro h ++ exact hxp (by simpa [polesFin, poles] using h) ++ have h_fNF_nonneg : 0 ≤ meromorphicOrderAt fNF x := by ++ rw [show meromorphicOrderAt fNF x = meromorphicOrderAt f x by ++ simpa [fNF] using ++ (meromorphicOrderAt_toMeromorphicNFOn (f := f) (U := R) f_mero hx)] ++ exact le_of_not_gt fun hxneg => hxp ⟨hx, hxneg⟩ ++ have h_fNF_nf : MeromorphicNFAt fNF x := by ++ simpa [fNF] using ++ (meromorphicNFOn_toMeromorphicNFOn (f := f) (U := R) hx) ++ exact (sub_principalPart_analyticAt_of_not_mem_poles h_fNF_nf hxnp h_fNF_nonneg).meromorphicOrderAt_nonneg ++ have h_nf : MeromorphicNFAt holoPart x := by ++ simpa [holoPart] using ++ (meromorphicNFOn_toMeromorphicNFOn (f := fNF - principalPart) (U := R) hx) ++ have h_ord : ++ meromorphicOrderAt holoPart x = meromorphicOrderAt (fNF - principalPart) x := by ++ simpa [holoPart] using ++ (meromorphicOrderAt_toMeromorphicNFOn (f := fNF - principalPart) (U := R) h_raw_mero hx) ++ exact (h_nf.meromorphicOrderAt_nonneg_iff_analyticAt.1 (h_ord.symm ▸ h_raw_nonneg)).differentiableAt.differentiableWithinAt ++ ++private lemma principalPart_borderIntegrable {f : ℂ → ℂ} {z w : ℂ} ++ (f_no_poles_boundary : Disjoint (RectangleBorder z w) {z | meromorphicOrderAt f z < 0}) ++ (f_poles_finite : (Rectangle z w ∩ {z | meromorphicOrderAt f z < 0}).Finite) : ++ RectangleBorderIntegrable (fun s ↦ ∑ p ∈ f_poles_finite.toFinset, residue (toMeromorphicNFOn f (Rectangle z w)) p / (s - p)) z w := by ++ classical ++ let R := Rectangle z w ++ let poles := R ∩ {u | meromorphicOrderAt f u < 0} ++ let polesFin := f_poles_finite.toFinset ++ let fNF := toMeromorphicNFOn f R ++ let principalPart := fun s ↦ ∑ p ∈ polesFin, residue fNF p / (s - p) ++ refine ContinuousOn.rectangleBorder_integrable ?_ ++ refine continuousOn_finsetSum _ ?_ ++ intro p hp s hs ++ have hsp : s ≠ p := fun hsp => Set.disjoint_right.mp f_no_poles_boundary ++ ((by simpa [polesFin, poles] using hp : p ∈ poles).2) (hsp ▸ hs) ++ have : ContinuousAt (fun z : ℂ ↦ residue fNF p / (z - p)) s := by ++ fun_prop (disch := exact sub_ne_zero.mpr hsp) ++ exact this.continuousWithinAt ++ ++private lemma rectangle_mem_nhds_of_interior {z w p : ℂ} ++ (zRe_le_wRe : z.re ≤ w.re) (zIm_le_wIm : z.im ≤ w.im) ++ (hpR : p ∈ Rectangle z w) (hpnot : p ∉ RectangleBorder z w) : ++ Rectangle z w ∈ nhds p := by ++ rw [mem_Rect zRe_le_wRe zIm_le_wIm] at hpR ++ have hp_re_left : z.re < p.re := ++ lt_of_le_of_ne hpR.1 fun hEq => hpnot ++ (by simp [RectangleBorder, hEq, hpR.2.2.1, hpR.2.2.2, zIm_le_wIm, mem_reProdIm]) ++ have hp_re_right : p.re < w.re := ++ lt_of_le_of_ne hpR.2.1 fun hEq => hpnot ++ (by simp [RectangleBorder, hEq, hpR.2.2.1, hpR.2.2.2, zIm_le_wIm, mem_reProdIm]) ++ have hp_im_left : z.im < p.im := ++ lt_of_le_of_ne hpR.2.2.1 fun hEq => hpnot ++ (by simp [RectangleBorder, hEq, hpR.1, hpR.2.1, zRe_le_wRe, mem_reProdIm]) ++ have hp_im_right : p.im < w.im := ++ lt_of_le_of_ne hpR.2.2.2 fun hEq => hpnot ++ (by simp [RectangleBorder, hEq, hpR.1, hpR.2.1, zRe_le_wRe, mem_reProdIm]) ++ rw [rectangle_mem_nhds_iff, mem_reProdIm, Set.uIoo_of_le zRe_le_wRe, Set.uIoo_of_le zIm_le_wIm] ++ exact ⟨⟨hp_re_left, hp_re_right⟩, ⟨hp_im_left, hp_im_right⟩⟩ ++ ++private lemma sum_div_rectangleBorderIntegrable {z w : ℂ} {S : Finset ℂ} ++ (hS_disjoint : Disjoint (RectangleBorder z w) S) (c : ℂ → ℂ) : ++ RectangleBorderIntegrable (fun s ↦ ∑ p ∈ S, c p / (s - p)) z w := by ++ refine ContinuousOn.rectangleBorder_integrable ?_ ++ refine continuousOn_finsetSum _ ?_ ++ intro p hp s hs ++ have hsp : s ≠ p := fun hsp => Set.disjoint_right.mp hS_disjoint hp (hsp ▸ hs) ++ have : ContinuousAt (fun z : ℂ ↦ c p / (z - p)) s := by ++ fun_prop (disch := exact sub_ne_zero.mpr hsp) ++ exact this.continuousWithinAt ++ ++private lemma rectangleIntegral'_sum_div_sub {z w : ℂ} (zRe_le_wRe : z.re ≤ w.re) (zIm_le_wIm : z.im ≤ w.im) ++ {S : Finset ℂ} (hS_subset : (S : Set ℂ) ⊆ Rectangle z w) ++ (hS_disjoint : Disjoint (RectangleBorder z w) S) ++ (c : ℂ → ℂ) : ++ RectangleIntegral' (fun s ↦ ∑ p ∈ S, c p / (s - p)) z w = ∑ p ∈ S, c p := by ++ classical ++ have h_partial_border : ∀ (S' : Finset ℂ), S' ⊆ S → RectangleBorderIntegrable (fun s ↦ ∑ p ∈ S', c p / (s - p)) z w := by ++ intro S' hS' ++ exact sum_div_rectangleBorderIntegrable (Disjoint.mono_right hS' hS_disjoint) c ++ have h_term_integral : ∀ {p : ℂ}, p ∈ S → RectangleIntegral' (fun s ↦ c p / (s - p)) z w = c p := ++ fun {p} hp => ResidueTheoremInRectangle zRe_le_wRe zIm_le_wIm ++ (rectangle_mem_nhds_of_interior zRe_le_wRe zIm_le_wIm ++ (hS_subset hp) (Set.disjoint_right.mp hS_disjoint hp)) ++ have h_partial_integral : ++ ∀ (S' : Finset ℂ), S' ⊆ S → ++ RectangleIntegral' (fun s ↦ ∑ p ∈ S', c p / (s - p)) z w = ++ ∑ p ∈ S', c p := by ++ intro S' hS' ++ revert hS' ++ refine Finset.induction_on S' ?_ ?_ ++ · intro _ ++ simp [RectangleIntegral', RectangleIntegral, HIntegral, VIntegral] ++ · intro a S' ha ih hS' ++ obtain ⟨haFin, hSsub⟩ := Finset.insert_subset_iff.mp hS' ++ have hterm_border : ++ RectangleBorderIntegrable (fun s ↦ c a / (s - a)) z w := ++ by simpa using h_partial_border ({a} : Finset ℂ) (Finset.singleton_subset_iff.mpr haFin) ++ have hfun : ++ (fun s ↦ ∑ p ∈ insert a S', c p / (s - p)) = ++ (fun s ↦ c a / (s - a)) + ++ (fun s ↦ ∑ p ∈ S', c p / (s - p)) := by ++ funext s; simp [Finset.sum_insert, ha] ++ have h_add_primed : ++ RectangleIntegral' ((fun s ↦ c a / (s - a)) + (fun s ↦ ∑ p ∈ S', c p / (s - p))) z w = ++ RectangleIntegral' (fun s ↦ c a / (s - a)) z w + ++ RectangleIntegral' (fun s ↦ ∑ p ∈ S', c p / (s - p)) z w := by ++ unfold RectangleIntegral' ++ rw [RectangleBorderIntegrable.add hterm_border (h_partial_border S' hSsub), smul_add] ++ rw [hfun, h_add_primed, h_term_integral haFin, ih hSsub, Finset.sum_insert ha] ++ exact h_partial_integral S (by intro p hp; exact hp) ++ ++private lemma toMeromorphicNFOn_add_integral {f : ℂ → ℂ} {z w : ℂ} ++ (f_mero : MeromorphicOn f (Rectangle z w)) ++ (f_no_poles_boundary : Disjoint (RectangleBorder z w) {z | meromorphicOrderAt f z < 0}) ++ (f_poles_finite : (Rectangle z w ∩ {z | meromorphicOrderAt f z < 0}).Finite) ++ (f_simple_poles : HasSimplePolesOn f (Rectangle z w)) : ++ RectangleIntegral' (toMeromorphicNFOn f (Rectangle z w)) z w = ++ RectangleIntegral' (toMeromorphicNFOn (toMeromorphicNFOn f (Rectangle z w) - ++ fun s ↦ ∑ p ∈ f_poles_finite.toFinset, residue (toMeromorphicNFOn f (Rectangle z w)) p / (s - p)) (Rectangle z w)) z w + ++ RectangleIntegral' (fun s ↦ ∑ p ∈ f_poles_finite.toFinset, residue (toMeromorphicNFOn f (Rectangle z w)) p / (s - p)) z w := by ++ let R : Set ℂ := Rectangle z w ++ let poles : Set ℂ := R ∩ {u | meromorphicOrderAt f u < 0} ++ let polesFin : Finset ℂ := f_poles_finite.toFinset ++ let fNF : ℂ → ℂ := toMeromorphicNFOn f R ++ let principalPart : ℂ → ℂ := fun s ↦ ∑ p ∈ polesFin, residue fNF p / (s - p) ++ let holoPart : ℂ → ℂ := toMeromorphicNFOn (fNF - principalPart) R ++ have h_holoPart_border : RectangleBorderIntegrable holoPart z w := ++ (holoPart_holomorphicOn f_mero f_simple_poles f_poles_finite).rectangleBorderIntegrable ++ have h_fNF_eq : ++ Set.EqOn fNF (holoPart + principalPart) (RectangleBorder z w) := by ++ intro s hs ++ have hsR : s ∈ R := rectangleBorder_subset_rectangle z w hs ++ have hsnp : s ∉ poles := fun hsp => Set.disjoint_right.mp f_no_poles_boundary hsp.2 hs ++ have hraw_analytic : AnalyticAt ℂ (fNF - principalPart) s := by ++ have h_fNF_nonneg : 0 ≤ meromorphicOrderAt fNF s := by ++ rw [show meromorphicOrderAt fNF s = meromorphicOrderAt f s by ++ simpa [fNF] using ++ (meromorphicOrderAt_toMeromorphicNFOn (f := f) (U := R) f_mero hsR)] ++ exact le_of_not_gt fun hsneg => hsnp ⟨hsR, hsneg⟩ ++ exact sub_principalPart_analyticAt_of_not_mem_poles ++ (by simpa [fNF] using meromorphicNFOn_toMeromorphicNFOn (f := f) (U := R) hsR) ++ (fun h => hsnp (by simpa [polesFin, poles] using h)) ++ h_fNF_nonneg ++ have hs_eq : holoPart s = (fNF - principalPart) s := by ++ rw [show holoPart = toMeromorphicNFOn (fNF - principalPart) R by rfl] ++ have h_fNF_mero : MeromorphicOn fNF R := by ++ simpa [fNF] using (meromorphicNFOn_toMeromorphicNFOn (f := f) (U := R)).meromorphicOn ++ have hf_sub_mero : MeromorphicOn (fNF - principalPart) R := ++ h_fNF_mero.sub principalPart_meromorphicOn ++ rw [toMeromorphicNFOn_eq_toMeromorphicNFAt (f := fNF - principalPart) (U := R) hf_sub_mero hsR] ++ exact congr_fun (toMeromorphicNFAt_eq_self.2 hraw_analytic.meromorphicNFAt) s ++ calc ++ fNF s = (fNF - principalPart) s + principalPart s := by simp ++ _ = holoPart s + principalPart s := by rw [← hs_eq] ++ rw [RectangleIntegral'_congr h_fNF_eq, RectangleIntegral', ++ RectangleBorderIntegrable.add h_holoPart_border ++ (principalPart_borderIntegrable f_no_poles_boundary f_poles_finite), smul_add] ++ ++lemma RectangleIntegral'_eq_sumResiduesIn {f : ℂ → ℂ} {z w : ℂ} ++ (zRe_le_wRe : z.re ≤ w.re) (zIm_le_wIm : z.im ≤ w.im) ++ (f_mero : MeromorphicOn f (Rectangle z w)) ++ (f_no_poles_boundary : Disjoint (RectangleBorder z w) {z | meromorphicOrderAt f z < 0}) ++ (f_poles_finite : (Rectangle z w ∩ {z | meromorphicOrderAt f z < 0}).Finite) ++ (f_simple_poles : HasSimplePolesOn f (Rectangle z w)) : ++ RectangleIntegral' f z w = sumResiduesIn f (Rectangle z w ∩ {z | meromorphicOrderAt f z < 0}) := by ++ let R : Set ℂ := Rectangle z w ++ let poles : Set ℂ := R ∩ {u | meromorphicOrderAt f u < 0} ++ let polesFin : Finset ℂ := f_poles_finite.toFinset ++ let fNF : ℂ → ℂ := toMeromorphicNFOn f R ++ let principalPart : ℂ → ℂ := fun s ↦ ∑ p ∈ polesFin, residue fNF p / (s - p) ++ let holoPart : ℂ → ℂ := toMeromorphicNFOn (fNF - principalPart) R ++ have h_residue_congr : sumResiduesIn f poles = sumResiduesIn fNF poles := by ++ rw [sumResiduesIn, sumResiduesIn] ++ apply tsum_congr ++ intro p ++ exact (residue_toMeromorphicNFOn_eq_residue p.2.1 f_mero f_simple_poles p.2.2).symm ++ have h_principalPart_integral : RectangleIntegral' principalPart z w = sumResiduesIn fNF poles := by ++ have h_sum : RectangleIntegral' principalPart z w = ∑ p ∈ polesFin, residue fNF p := by ++ apply rectangleIntegral'_sum_div_sub zRe_le_wRe zIm_le_wIm ++ · intro p hp ++ dsimp [polesFin, poles, R] at hp ++ simp only [Finset.mem_coe, Set.Finite.mem_toFinset] at hp ++ exact hp.1 ++ · exact Disjoint.mono_right (by rw [f_poles_finite.coe_toFinset]; exact Set.inter_subset_right) f_no_poles_boundary ++ rw [h_sum] ++ have h_eq_poles : poles = ↑polesFin := by ++ dsimp [poles, polesFin, R] ++ exact f_poles_finite.coe_toFinset.symm ++ rw [sumResiduesIn, h_eq_poles, ++ tsum_fintype (f := fun p : (polesFin : Set ℂ) => residue fNF p), ++ ← Finset.sum_coe_sort polesFin]; rfl ++ calc ++ RectangleIntegral' f z w = RectangleIntegral' fNF z w := rectangleIntegral'_toMeromorphicNFOn_eq f_mero ++ _ = RectangleIntegral' holoPart z w + RectangleIntegral' principalPart z w := ++ toMeromorphicNFOn_add_integral f_mero f_no_poles_boundary f_poles_finite f_simple_poles ++ _ = 0 + sumResiduesIn fNF poles := by ++ rw [h_principalPart_integral] ++ rw [RectangleIntegral', ++ (holoPart_holomorphicOn f_mero f_simple_poles f_poles_finite).vanishesOnRectangle subset_rfl] ++ simp ++ _ = sumResiduesIn fNF poles := by simp ++ _ = sumResiduesIn f poles := h_residue_congr.symm ++ ++lemma residue_eq_zero_of_not_pole_of_meromorphicAt {F : ℂ → ℂ} {s : ℂ} ++ (hs_mero : MeromorphicAt F s) (hs_not_pole : 0 ≤ meromorphicOrderAt F s) : ++ residue F s = 0 := by ++ apply residue_eq_of_tendsto ++ obtain ⟨c, hc⟩ := tendsto_nhds_of_meromorphicOrderAt_nonneg hs_mero hs_not_pole ++ have hsub : Filter.Tendsto (fun z : ℂ ↦ z - s) (nhdsWithin s {s}ᶜ) (nhds 0) := ++ tendsto_sub_nhds_zero_iff.mpr (tendsto_id.mono_left nhdsWithin_le_nhds) ++ simpa using hsub.mul hc ++ ++lemma sumResiduesIn_inter_eq_of_set_eq {F : ℂ → ℂ} {Rn S2 P : Set ℂ} ++ (h_set_eq : Rn ∩ P = S2 ∩ P) ++ (h_residue_zero : ∀ s ∈ S2, s ∉ P → residue F s = 0) : ++ sumResiduesIn F (Rn ∩ P) = sumResiduesIn F S2 := by ++ rw [sumResiduesIn, sumResiduesIn, tsum_subtype, tsum_subtype] ++ apply tsum_congr ++ intro s ++ by_cases hs_S2 : s ∈ S2 ++ · by_cases hs_pole : s ∈ P ++ · have hs_rect_pole : s ∈ Rn ∩ P := h_set_eq.symm ▸ ⟨hs_S2, hs_pole⟩ ++ simp [hs_S2, hs_rect_pole] ++ · have hs_not_rect_pole : s ∉ Rn ∩ P := fun hs => hs_pole hs.2 ++ have hres0 : residue F s = 0 := h_residue_zero s hs_S2 hs_pole ++ simp [hs_S2, hs_not_rect_pole, hres0] ++ · have hs_not_rect_pole : s ∉ Rn ∩ P := fun hs => hs_S2 (h_set_eq ▸ hs).1 ++ simp [hs_S2, hs_not_rect_pole] ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/SmoothExistence.lean b/PrimeNumberTheoremAnd/Erdos970/SmoothExistence.lean +new file mode 100644 +index 0000000..74e2172 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/SmoothExistence.lean +@@ -0,0 +1,94 @@ ++import Batteries.Tactic.Lemma ++import Mathlib.Geometry.Manifold.PartitionOfUnity ++import Mathlib.Tactic.Bound ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Algebra.Notation.Support ++ ++namespace Erdos970 ++ ++ ++open MeasureTheory Set Real ++open scoped ContDiff ++ ++lemma smooth_urysohn_support_Ioo {a b c d : ℝ} (h1 : a < b) (h3 : c < d) : ++ ∃ Ψ : ℝ → ℝ, (ContDiff ℝ ∞ Ψ) ∧ (HasCompactSupport Ψ) ∧ ++ Set.indicator (Set.Icc b c) 1 ≤ Ψ ∧ Ψ ≤ Set.indicator (Set.Ioo a d) 1 ∧ ++ (Function.support Ψ = Set.Ioo a d) := by ++ have := exists_contMDiff_zero_iff_one_iff_of_isClosed (n := ⊤) ++ (modelWithCornersSelf ℝ ℝ) (s := Set.Iic a ∪ Set.Ici d) (t := Set.Icc b c) ++ (IsClosed.union isClosed_Iic isClosed_Ici) isClosed_Icc ++ (by ++ simp_rw [Set.disjoint_union_left, Set.disjoint_iff, Set.subset_def, ++ Set.mem_inter_iff, Set.mem_Iic, Set.mem_Icc, Set.mem_empty_iff_false, ++ and_imp, imp_false, not_le, Set.mem_Ici] ++ constructor <;> intros <;> linarith) ++ obtain ⟨Ψ, hΨSmooth, hΨrange, hΨ0, hΨ1⟩ := this ++ simp only [Set.mem_union, Set.mem_Iic, Set.mem_Ici, Set.mem_Icc] at * ++ use Ψ ++ simp only [range_subset_iff, mem_Icc] at hΨrange ++ refine ⟨ContMDiff.contDiff hΨSmooth, ?_, ?_, ?_, ?_⟩ ++ · apply HasCompactSupport.of_support_subset_isCompact (K := Set.Icc a d) isCompact_Icc ++ simp only [Function.support_subset_iff, ne_eq, mem_Icc, ← hΨ0, not_or] ++ bound ++ · apply Set.indicator_le' ++ · intro x hx ++ rw [hΨ1 x |>.mp, Pi.one_apply] ++ simpa using hx ++ · exact fun x _ ↦ (hΨrange x).1 ++ · intro x ++ apply Set.le_indicator_apply ++ · exact fun _ ↦ (hΨrange x).2 ++ · intro hx ++ rw [← hΨ0 x |>.mp] ++ simpa [-not_and, mem_Ioo, not_and_or, not_lt] using hx ++ · ext x ++ simp only [Function.mem_support, ne_eq, mem_Ioo, ← hΨ0, not_or, not_le] ++ ++lemma SmoothExistence : ++ ∃ (ν : ℝ → ℝ), (ContDiff ℝ ∞ ν) ∧ (∀ x, 0 ≤ ν x) ∧ ++ ν.support ⊆ Icc (1 / 2) 2 ∧ ∫ x in Ici 0, ν x / x = 1 := by ++ suffices h : ∃ (ν : ℝ → ℝ), (ContDiff ℝ ∞ ν) ∧ (∀ x, 0 ≤ ν x) ∧ ++ ν.support ⊆ Set.Icc (1 / 2) 2 ∧ 0 < ∫ x in Set.Ici 0, ν x / x by ++ obtain ⟨ν, hν, hνnonneg, hνsupp, hνpos⟩ := h ++ let c := (∫ x in Ici 0, ν x / x) ++ use fun y ↦ ν y / c ++ refine ⟨hν.div_const c, fun y ↦ div_nonneg (hνnonneg y) (le_of_lt hνpos), ?_, ?_⟩ ++ · rw [Function.support_div, Function.support_const (ne_of_lt hνpos).symm, inter_univ] ++ convert hνsupp ++ · simp only [div_right_comm _ c _, integral_div c, div_self <| ne_of_gt hνpos, c] ++ have := smooth_urysohn_support_Ioo (a := 1 / 2) (b := 1) (c := 3 / 2) (d := 2) ++ (by linarith) (by linarith) ++ obtain ⟨ν, hνContDiff, _, hν0, hν1, hνSupport⟩ := this ++ use ν, hνContDiff ++ unfold indicator at hν0 hν1 ++ simp only [mem_Icc, Pi.one_apply, Pi.le_def, mem_Ioo] at hν0 hν1 ++ simp only [hνSupport, subset_def, mem_Ioo, mem_Icc, and_imp] ++ split_ands ++ · exact fun x ↦ le_trans (by simp [apply_ite]) (hν0 x) ++ · exact fun y hy hy' ↦ ⟨by linarith, by linarith⟩ ++ · rw [integral_pos_iff_support_of_nonneg] ++ · simp only [Function.support_div, measurableSet_Ici, Measure.restrict_apply', ++ hνSupport, Function.support_id'] ++ have : (Ioo (1 / 2 : ℝ) 2 ∩ {0}ᶜ ∩ Ici 0) = Ioo (1 / 2) 2 := by ++ ext x ++ simp only [one_div, mem_inter_iff, mem_Ioo, mem_compl_iff, mem_singleton_iff, mem_Ici] ++ bound ++ simp only [this, volume_Ioo, ENNReal.ofReal_pos, sub_pos, gt_iff_lt] ++ linarith ++ · simp_rw [Pi.le_def, Pi.zero_apply] ++ intro y ++ by_cases h : y ∈ Function.support ν ++ · apply div_nonneg <| le_trans (by simp [apply_ite]) (hν0 y) ++ rw [hνSupport, mem_Ioo] at h ++ linarith [h.left] ++ · simp only [Function.mem_support, ne_eq, not_not] at h ++ simp [h] ++ · have : (fun x ↦ ν x / x).support ⊆ Icc (1 / 2) 2 := by ++ rw [Function.support_div, hνSupport] ++ exact (inter_subset_left).trans Ioo_subset_Icc_self ++ apply (integrableOn_iff_integrable_of_support_subset this).mp ++ apply ContinuousOn.integrableOn_compact isCompact_Icc ++ apply hνContDiff.continuous.continuousOn.div continuousOn_id ?_ ++ simp only [mem_Icc, ne_eq, and_imp, id_eq] ++ intros; linarith ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Sobolev.lean b/PrimeNumberTheoremAnd/Erdos970/Sobolev.lean +new file mode 100644 +index 0000000..3e83353 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Sobolev.lean +@@ -0,0 +1,360 @@ ++import Mathlib.Analysis.Calculus.Deriv.Support ++import Mathlib.Analysis.Distribution.SchwartzSpace.Deriv ++import Mathlib.Order.Filter.ZeroAndBoundedAtFilter ++ ++namespace Erdos970 ++ ++open Real Complex MeasureTheory Filter Topology BoundedContinuousFunction SchwartzMap BigOperators ++open scoped ContDiff ++ ++variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] {n : ℕ} ++ ++@[ext] structure CS (n : ℕ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] where ++ toFun : ℝ → E ++ h1 : ContDiff ℝ n toFun ++ h2 : HasCompactSupport toFun ++ ++structure trunc extends (CS 2 ℝ) where ++ h3 : (Set.Icc (-1) (1)).indicator 1 ≤ toFun ++ h4 : toFun ≤ Set.indicator (Set.Ioo (-2) (2)) 1 ++ ++structure W1 (n : ℕ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] where ++ toFun : ℝ → E ++ smooth : ContDiff ℝ n toFun ++ integrable : ∀ ⦃k⦄, k ≤ n → Integrable (iteratedDeriv k toFun) ++ ++abbrev W21 := W1 2 ℂ ++ ++section lemmas ++ ++noncomputable def funscale {E : Type*} (g : ℝ → E) (R x : ℝ) : E := g (R⁻¹ • x) ++ ++lemma contDiff_ofReal : ContDiff ℝ ∞ ofReal := by ++ have key x : HasDerivAt ofReal 1 x := hasDerivAt_id x |>.ofReal_comp ++ have key' : deriv ofReal = fun _ => 1 := by ext x ; exact (key x).deriv ++ refine contDiff_infty_iff_deriv.mpr ⟨fun x => (key x).differentiableAt, ?_⟩ ++ simpa [key'] using contDiff_const ++ ++omit [NormedSpace ℝ E] in ++lemma tendsto_funscale {f : ℝ → E} (hf : ContinuousAt f 0) (x : ℝ) : ++ Tendsto (fun R => funscale f R x) atTop (𝓝 (f 0)) := ++ hf.tendsto.comp (by simpa using tendsto_inv_atTop_zero.mul_const x) ++ ++end lemmas ++ ++namespace CS ++ ++variable {f : CS n E} {R x v : ℝ} ++ ++instance : CoeFun (CS n E) (fun _ => ℝ → E) where coe := CS.toFun ++ ++instance : Coe (CS n ℝ) (CS n ℂ) where coe f := ⟨fun x => f x, ++ contDiff_ofReal.of_le (mod_cast le_top) |>.comp f.h1, f.h2.comp_left (g := ofReal) rfl⟩ ++ ++def neg (f : CS n E) : CS n E where ++ toFun := -f ++ h1 := f.h1.neg ++ h2 := by simpa [HasCompactSupport, tsupport] using f.h2 ++ ++instance : Neg (CS n E) where neg := neg ++ ++@[simp] lemma neg_apply {x : ℝ} : (-f) x = - (f x) := rfl ++ ++def smul (R : ℝ) (f : CS n E) : CS n E := ⟨R • f, f.h1.const_smul R, f.h2.smul_left⟩ ++ ++instance : HSMul ℝ (CS n E) (CS n E) where hSMul := smul ++ ++@[simp] lemma smul_apply : (R • f) x = R • f x := rfl ++ ++lemma continuous (f : CS n E) : Continuous f := f.h1.continuous ++ ++noncomputable def deriv (f : CS (n + 1) E) : CS n E where ++ toFun := _root_.deriv f ++ h1 := (contDiff_succ_iff_deriv.mp f.h1).2.2 ++ h2 := f.h2.deriv ++ ++lemma hasDerivAt (f : CS (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := ++ (f.h1.differentiable (by simp)).differentiableAt.hasDerivAt ++ ++lemma deriv_apply {f : CS (n + 1) E} {x : ℝ} : f.deriv x = _root_.deriv f x := rfl ++ ++lemma deriv_smul {f : CS (n + 1) E} : (R • f).deriv = R • f.deriv := by ++ ext x ; exact (f.hasDerivAt x |>.const_smul R).deriv ++ ++noncomputable def scale (g : CS n E) (R : ℝ) : CS n E := by ++ by_cases h : R = 0 ++ · exact ⟨0, contDiff_const, by simp [HasCompactSupport, tsupport]⟩ ++ · refine ⟨fun x => funscale g R x, ?_, ?_⟩ ++ · exact g.h1.comp (contDiff_const_smul R⁻¹) ++ · exact g.h2.comp_smul (inv_ne_zero h) ++ ++lemma deriv_scale {f : CS (n + 1) E} : (f.scale R).deriv = R⁻¹ • f.deriv.scale R := by ++ ext v ; by_cases hR : R = 0 ++ · simp [hR, scale, deriv] ++ · simp only [scale, hR, ↓reduceDIte, smul_apply] ++ exact ((f.hasDerivAt (R⁻¹ • v)).scomp v ++ (by simpa using! (hasDerivAt_id v).const_smul R⁻¹)).deriv ++ ++lemma deriv_scale' {f : CS (n + 1) E} : ++ (f.scale R).deriv v = R⁻¹ • f.deriv (R⁻¹ • v) := by ++ rw [deriv_scale, smul_apply] ++ by_cases hR : R = 0 <;> simp [hR, scale, funscale] ++ ++lemma hasDerivAt_scale (f : CS (n + 1) E) (R x : ℝ) : ++ HasDerivAt (f.scale R) (R⁻¹ • _root_.deriv f (R⁻¹ • x)) x := by ++ convert hasDerivAt (f.scale R) x ; rw [deriv_scale'] ; rfl ++ ++lemma tendsto_scale (f : CS n E) (x : ℝ) : Tendsto (fun R => f.scale R x) atTop (𝓝 (f 0)) := by ++ apply (tendsto_funscale f.continuous.continuousAt x).congr' ++ filter_upwards [eventually_ne_atTop 0] with R hR ; simp [scale, hR] ++ ++lemma bounded : ∃ C, ∀ v, ‖f v‖ ≤ C := by ++ obtain ⟨x, hx⟩ := ++ (continuous_norm.comp f.continuous).exists_forall_ge_of_hasCompactSupport f.h2.norm ++ exact ⟨_, hx⟩ ++ ++end CS ++ ++namespace trunc ++ ++instance : CoeFun trunc (fun _ => ℝ → ℝ) where coe f := f.toFun ++ ++instance : Coe trunc (CS 2 ℝ) where coe := trunc.toCS ++ ++lemma nonneg (g : trunc) (x : ℝ) : 0 ≤ g x := (Set.indicator_nonneg (by simp) x).trans (g.h3 x) ++ ++lemma le_one (g : trunc) (x : ℝ) : g x ≤ 1 := ++ (g.h4 x).trans <| Set.indicator_le_self' (by simp) x ++ ++lemma zero (g : trunc) : g =ᶠ[𝓝 0] 1 := by ++ have : Set.Icc (-1) 1 ∈ 𝓝 (0 : ℝ) := by apply Icc_mem_nhds <;> linarith ++ exact eventually_of_mem this (fun x hx => le_antisymm (g.le_one x) (by simpa [hx] using g.h3 x)) ++ ++@[simp] lemma zero_at {g : trunc} : g 0 = 1 := g.zero.eq_of_nhds ++ ++end trunc ++ ++namespace W1 ++ ++instance : CoeFun (W1 n E) (fun _ => ℝ → E) where coe := W1.toFun ++ ++lemma continuous (f : W1 n E) : Continuous f := f.smooth.continuous ++ ++lemma differentiable (f : W1 (n + 1) E) : Differentiable ℝ f := ++ f.smooth.differentiable (by simp) ++ ++lemma iteratedDeriv_sub {f g : ℝ → E} (hf : ContDiff ℝ n f) (hg : ContDiff ℝ n g) : ++ iteratedDeriv n (f - g) = iteratedDeriv n f - iteratedDeriv n g := by ++ induction n generalizing f g with ++ | zero => rfl ++ | succ n ih => ++ have hf' : ContDiff ℝ n (deriv f) := hf.iterate_deriv' n 1 ++ have hg' : ContDiff ℝ n (deriv g) := hg.iterate_deriv' n 1 ++ have hfg : deriv (f - g) = deriv f - deriv g := by ++ ext x ; apply deriv_sub ++ · exact (hf.differentiable (by simp)).differentiableAt ++ · exact (hg.differentiable (by simp)).differentiableAt ++ simp_rw [iteratedDeriv_succ', ← ih hf' hg', hfg] ++ ++noncomputable def deriv (f : W1 (n + 1) E) : W1 n E where ++ toFun := _root_.deriv f ++ smooth := contDiff_succ_iff_deriv.mp f.smooth |>.2.2 ++ integrable k hk := by ++ simpa [iteratedDeriv_succ'] using f.integrable (Nat.succ_le_succ hk) ++ ++lemma hasDerivAt (f : W1 (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := ++ f.differentiable.differentiableAt.hasDerivAt ++ ++def sub (f g : W1 n E) : W1 n E where ++ toFun := f - g ++ smooth := f.smooth.sub g.smooth ++ integrable k hk := by ++ have hf : ContDiff ℝ k f := f.smooth.of_le (by simp [hk]) ++ have hg : ContDiff ℝ k g := g.smooth.of_le (by simp [hk]) ++ simpa [iteratedDeriv_sub hf hg] using (f.integrable hk).sub (g.integrable hk) ++ ++instance : Sub (W1 n E) where sub := sub ++ ++lemma integrable_iteratedDeriv_Schwarz {f : 𝓢(ℝ, ℂ)} : Integrable (iteratedDeriv n f) := by ++ induction n generalizing f with ++ | zero => exact f.integrable ++ | succ n ih => simpa [iteratedDeriv_succ'] using! ih (f := SchwartzMap.derivCLM ℝ ℂ f) ++ ++noncomputable def of_Schwartz (f : 𝓢(ℝ, ℂ)) : W1 n ℂ where ++ toFun := f ++ smooth := f.smooth n ++ integrable _ _ := integrable_iteratedDeriv_Schwarz ++ ++end W1 ++ ++namespace W21 ++ ++variable {f : W21} ++ ++noncomputable def norm (f : ℝ → ℂ) : ℝ := ++ (∫ v, ‖f v‖) + (4 * π ^ 2)⁻¹ * (∫ v, ‖deriv (deriv f) v‖) ++ ++lemma norm_nonneg {f : ℝ → ℂ} : 0 ≤ norm f := ++ add_nonneg (integral_nonneg (fun t => by simp)) ++ (mul_nonneg (by positivity) (integral_nonneg (fun t => by simp))) ++ ++noncomputable instance : Norm W21 where norm := norm ∘ W1.toFun ++ ++noncomputable instance : Coe 𝓢(ℝ, ℂ) W21 where coe := W1.of_Schwartz ++ ++def ofCS2 (f : CS 2 ℂ) : W21 := by ++ refine ⟨f, f.h1, fun k hk => ?_⟩ ; match k with ++ | 0 => exact f.h1.continuous.integrable_of_hasCompactSupport f.h2 ++ | 1 => simpa using (f.h1.continuous_deriv one_le_two).integrable_of_hasCompactSupport f.h2.deriv ++ | 2 => simpa [iteratedDeriv_succ] using ++ (f.h1.iterate_deriv' 0 2).continuous.integrable_of_hasCompactSupport f.h2.deriv.deriv ++ ++instance : Coe (CS 2 ℂ) W21 where coe := ofCS2 ++ ++instance : HMul (CS 2 ℂ) W21 (CS 2 ℂ) where ++ hMul g f := ⟨g * f, g.h1.mul f.smooth, g.h2.mul_right⟩ ++ ++instance : HMul (CS 2 ℝ) W21 (CS 2 ℂ) where hMul g f := (g : CS 2 ℂ) * f ++ ++lemma hf (f : W21) : Integrable f := f.integrable zero_le_two ++ ++lemma hf' (f : W21) : Integrable (deriv f) := by ++ simpa [iteratedDeriv_succ] using f.integrable one_le_two ++ ++lemma hf'' (f : W21) : Integrable (deriv (deriv f)) := by ++ simpa [iteratedDeriv_succ] using f.integrable le_rfl ++ ++end W21 ++ ++theorem W21_approximation (f : W21) (g : trunc) : ++ Tendsto (fun R => ‖f - (g.scale R * f : W21)‖) atTop (𝓝 0) := by ++ ++ let f' := f.deriv ++ let f'' := f'.deriv ++ let g' := (g : CS 2 ℝ).deriv ++ let g'' := g'.deriv ++ let h R v := 1 - g.scale R v ++ let h' R := - (g.scale R).deriv ++ let h'' R := - (g.scale R).deriv.deriv ++ ++ have ch {R} : Continuous (fun v => (h R v : ℂ)) := ++ continuous_ofReal.comp <| continuous_const.sub (CS.continuous _) ++ have ch' {R} : Continuous (fun v => (h' R v : ℂ)) := continuous_ofReal.comp (CS.continuous _) ++ have ch'' {R} : Continuous (fun v => (h'' R v : ℂ)) := continuous_ofReal.comp (CS.continuous _) ++ have dh R v : HasDerivAt (h R) (h' R v) v := by ++ convert! CS.hasDerivAt_scale (g : CS 2 ℝ) R v |>.const_sub 1 using 1 ++ simp [h', CS.deriv_scale', show g.deriv.toFun = deriv g.toFun from rfl] ++ have dh' R v : HasDerivAt (h' R) (h'' R v) v := ((g.scale R).deriv.hasDerivAt v).neg ++ have hh1 R v : |h R v| ≤ 1 := by ++ by_cases hR : R = 0 <;> ++ simp only [CS.scale, funscale, smul_eq_mul, hR, ↓reduceDIte, Pi.zero_apply, sub_zero, ++ abs_one, le_refl, h] ++ rw [abs_le] ; constructor <;> ++ linarith [g.le_one (R⁻¹ * v), g.nonneg (R⁻¹ * v)] ++ have vR v : Tendsto (fun R : ℝ => v * R⁻¹) atTop (𝓝 0) := by ++ simpa using tendsto_inv_atTop_zero.const_mul v ++ ++ convert_to Tendsto (fun R => W21.norm (fun v => h R v * f v)) atTop (𝓝 0) ++ · ext R ; change W21.norm _ = _ ; congr ; ext v ; simp [h, sub_mul] ; rfl ++ rw [show (0 : ℝ) = 0 + ((4 * π ^ 2)⁻¹ : ℝ) * 0 by simp] ++ refine Tendsto.add ?_ (Tendsto.const_mul _ ?_) ++ ++ · let F R v := ‖h R v * f v‖ ++ have eh v : ∀ᶠ R in atTop, h R v = 0 := by ++ filter_upwards [(vR v).eventually g.zero, eventually_ne_atTop 0] with R hR hR' ++ simp [h, hR, CS.scale, hR', funscale, mul_comm R⁻¹] ++ have e1 : ∀ᶠ (n : ℝ) in atTop, AEStronglyMeasurable (F n) volume := by ++ apply Eventually.of_forall ; intro R ++ exact (ch.mul f.continuous).norm.aestronglyMeasurable ++ have e2 : ∀ᶠ (n : ℝ) in atTop, ∀ᵐ (a : ℝ), ‖F n a‖ ≤ ‖f a‖ := by ++ apply Eventually.of_forall ; intro R ++ apply Eventually.of_forall ; intro v ++ simpa [F] using mul_le_mul (hh1 R v) le_rfl (by simp) zero_le_one ++ have e4 : ∀ᵐ (a : ℝ), Tendsto (fun n ↦ F n a) atTop (𝓝 0) := by ++ apply Eventually.of_forall ; intro v ++ apply tendsto_nhds_of_eventually_eq ; filter_upwards [eh v] with R hR ; simp [F, hR] ++ simpa [F] using tendsto_integral_filter_of_dominated_convergence _ e1 e2 f.hf.norm e4 ++ ++ · let F R v := ‖h'' R v * f v + 2 * h' R v * f' v + h R v * f'' v‖ ++ convert_to Tendsto (fun R ↦ ∫ (v : ℝ), F R v) atTop (𝓝 0) ++ · have this R v : ++ deriv (deriv (fun v => h R v * f v)) v = ++ h'' R v * f v + 2 * h' R v * f' v + h R v * f'' v := by ++ have df v : HasDerivAt f (f' v) v := f.hasDerivAt v ++ have df' v : HasDerivAt f' (f'' v) v := f'.hasDerivAt v ++ have l3 v : HasDerivAt (fun v => h R v * f v) (h' R v * f v + h R v * f' v) v := ++ (dh R v).ofReal_comp.mul (df v) ++ have l5 : HasDerivAt (fun v => h' R v * f v) (h'' R v * f v + h' R v * f' v) v := ++ (dh' R v).ofReal_comp.mul (df v) ++ have l7 : HasDerivAt (fun v => h R v * f' v) (h' R v * f' v + h R v * f'' v) v := ++ (dh R v).ofReal_comp.mul (df' v) ++ have d1 : deriv (fun v => h R v * f v) = fun v => h' R v * f v + h R v * f' v := ++ funext (fun v => (l3 v).deriv) ++ rw [d1] ; convert! (l5.add l7).deriv using 1 ; ring ++ simp_rw [this, F] ++ ++ obtain ⟨c1, mg'⟩ := g'.bounded ++ obtain ⟨c2, mg''⟩ := g''.bounded ++ let bound v := c2 * ‖f v‖ + 2 * c1 * ‖f' v‖ + ‖f'' v‖ ++ have e1 : ∀ᶠ (n : ℝ) in atTop, AEStronglyMeasurable (F n) volume := by ++ apply Eventually.of_forall ; intro R ; apply (Continuous.norm ?_).aestronglyMeasurable ++ exact ((ch''.mul f.continuous).add ((continuous_const.mul ch').mul f.deriv.continuous)).add ++ (ch.mul f.deriv.deriv.continuous) ++ have e2 : ∀ᶠ R in atTop, ∀ᵐ (a : ℝ), ‖F R a‖ ≤ bound a := by ++ have hc1 : ∀ᶠ R in atTop, ∀ v, |h' R v| ≤ c1 := by ++ filter_upwards [eventually_ge_atTop 1] with R hR v ++ have hR' : R ≠ 0 := by linarith ++ have : 0 ≤ R := by linarith ++ simp only [CS.deriv_scale, CS.neg_apply, CS.smul_apply, smul_eq_mul, abs_neg, abs_mul, ++ abs_inv, abs_eq_self.mpr this, ge_iff_le, h'] ++ simp only [CS.scale, hR', ↓reduceDIte, funscale, smul_eq_mul] ++ convert_to _ ≤ c1 * 1 ++ · simp ++ · rw [mul_comm] ++ apply mul_le_mul (mg' _) ++ (inv_le_of_inv_le₀ (by linarith) (by simpa using hR)) (by positivity) ++ exact (abs_nonneg _).trans (mg' 0) ++ have hc2 : ∀ᶠ R in atTop, ∀ v, |h'' R v| ≤ c2 := by ++ filter_upwards [eventually_ge_atTop 1] with R hR v ++ have e1 : 0 ≤ R := by linarith ++ have e2 : R⁻¹ ≤ 1 := inv_le_of_inv_le₀ (by linarith) (by simpa using hR) ++ have e3 : R ≠ 0 := by linarith ++ simp only [CS.deriv_scale, CS.deriv_smul, CS.neg_apply, CS.smul_apply, smul_eq_mul, abs_neg, ++ abs_mul, abs_inv, abs_eq_self.mpr e1, ge_iff_le, h''] ++ convert_to _ ≤ 1 * (1 * c2) ++ · simp ++ apply mul_le_mul e2 ?_ (by positivity) zero_le_one ++ apply mul_le_mul e2 ?_ (by positivity) zero_le_one ++ simp only [CS.scale, e3, ↓reduceDIte, funscale, smul_eq_mul] ; apply mg'' ++ filter_upwards [hc1, hc2] with R hc1 hc2 ++ apply Eventually.of_forall ; intro v ; specialize hc1 v ; specialize hc2 v ++ simp only [F, bound, norm_norm] ++ refine (norm_add_le _ _).trans ?_ ; apply add_le_add ++ · refine (norm_add_le _ _).trans ?_ ; apply add_le_add <;> simp only [Complex.norm_mul, ++ Complex.norm_ofNat, norm_real, norm_eq_abs] <;> gcongr ++ · simpa using mul_le_mul (hh1 R v) le_rfl (by simp) zero_le_one ++ have e3 : Integrable bound volume := ++ (((f.hf.norm).const_mul _).add ((f.hf'.norm).const_mul _)).add f.hf''.norm ++ have e4 : ∀ᵐ (a : ℝ), Tendsto (fun n ↦ F n a) atTop (𝓝 0) := by ++ apply Eventually.of_forall ; intro v ++ have evg' : g' =ᶠ[𝓝 0] 0 := by convert! ← g.zero.deriv ; exact deriv_const' _ ++ have evg'' : g'' =ᶠ[𝓝 0] 0 := by convert! ← evg'.deriv ; exact deriv_const' _ ++ refine tendsto_norm_zero.comp <| (ZeroAtFilter.add ?_ ?_).add ?_ ++ · have eh'' v : ∀ᶠ R in atTop, h'' R v = 0 := by ++ filter_upwards [(vR v).eventually evg'', eventually_ne_atTop 0] with R hR hR' ++ simp only [CS.deriv_scale, CS.deriv_smul, CS.neg_apply, CS.smul_apply, smul_eq_mul, ++ neg_eq_zero, mul_eq_zero, inv_eq_zero, hR', false_or, h''] ++ simp only [CS.scale, hR', ↓reduceDIte, funscale, smul_eq_mul, mul_comm R⁻¹] ++ exact hR ++ apply tendsto_nhds_of_eventually_eq ++ filter_upwards [eh'' v] with R hR ; simp [hR] ++ · have eh' v : ∀ᶠ R in atTop, h' R v = 0 := by ++ filter_upwards [(vR v).eventually evg'] with R hR ++ simp [g'] at hR ++ simp [h', CS.deriv_scale', mul_comm R⁻¹, hR] ++ apply tendsto_nhds_of_eventually_eq ++ filter_upwards [eh' v] with R hR ; simp [hR] ++ · simpa [h] using! ((g.tendsto_scale v).const_sub 1).ofReal.mul tendsto_const_nhds ++ simpa [F] using tendsto_integral_filter_of_dominated_convergence bound e1 e2 e3 e4 ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Tactic/AdditiveCombination.lean b/PrimeNumberTheoremAnd/Erdos970/Tactic/AdditiveCombination.lean +new file mode 100644 +index 0000000..f79890f +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Tactic/AdditiveCombination.lean +@@ -0,0 +1,90 @@ ++import Mathlib.Tactic.Abel ++import Mathlib.Tactic.LinearCombinationPrime ++ ++namespace Erdos970 ++ ++namespace Mathlib.Tactic.LinearCombinationPrime ++open _root_.Mathlib.Tactic.LinearCombinationPrime ++open Lean ++open Elab Meta Term ++ ++variable {α β : Type*} ++ ++theorem pf_smul_c [SMul α β] {a b : α} (p : a = b) (c : β) : a • c = b • c := p ▸ rfl ++theorem c_smul_pf [SMul α β] {b c : β} (p : b = c) (a : α) : a • b = a • c := p ▸ rfl ++theorem smul_pf [SMul α β] {a₁ b₁ : α} (p₁ : (a₁ : α) = b₁) {a₂ b₂ : β} (p₂ : a₂ = b₂) : ++ a₁ • a₂ = b₁ • b₂ := p₁ ▸ p₂ ▸ rfl ++ ++partial def expandAdditiveCombo (ty : Expr) (stx : Syntax.Term) : TermElabM Expanded := withRef stx do ++ match stx with ++ | `(($e)) => expandLinearCombo ty e ++ | `($e₁ + $e₂) => do ++ match ← expandAdditiveCombo ty e₁, ← expandAdditiveCombo ty e₂ with ++ | .const c₁, .const c₂ => .const <$> ``($c₁ + $c₂) ++ | .proof p₁, .const c₂ => .proof <$> ``(pf_add_c $p₁ $c₂) ++ | .const c₁, .proof p₂ => .proof <$> ``(c_add_pf $p₂ $c₁) ++ | .proof p₁, .proof p₂ => .proof <$> ``(add_pf $p₁ $p₂) ++ | `($e₁ - $e₂) => do ++ match ← expandAdditiveCombo ty e₁, ← expandAdditiveCombo ty e₂ with ++ | .const c₁, .const c₂ => .const <$> ``($c₁ - $c₂) ++ | .proof p₁, .const c₂ => .proof <$> ``(pf_sub_c $p₁ $c₂) ++ | .const c₁, .proof p₂ => .proof <$> ``(c_sub_pf $p₂ $c₁) ++ | .proof p₁, .proof p₂ => .proof <$> ``(sub_pf $p₁ $p₂) ++ | `(-$e) => do ++ match ← expandAdditiveCombo ty e with ++ | .const c => .const <$> `(-$c) ++ | .proof p => .proof <$> ``(neg_pf $p) ++ | `(← $e:term) => do ++ match ← expandAdditiveCombo ty e with ++ | .const c => return .const c ++ | .proof p => .proof <$> ``(Eq.symm $p) ++ | `($e₁ • $e₂) => do ++ match ← expandAdditiveCombo ty e₁, ← expandAdditiveCombo ty e₂ with ++ | .const c₁, .const c₂ => .const <$> ``($c₁ • $c₂) ++ | .proof p₁, .const c₂ => .proof <$> ``(pf_smul_c $p₁ $c₂) ++ | .const c₁, .proof p₂ => .proof <$> ``(c_smul_pf $p₂ $c₁) ++ | .proof p₁, .proof p₂ => .proof <$> ``(smul_pf $p₁ $p₂) ++ | e => ++ ++ withSynthesize do ++ ++ let c ← withSynthesizeLight <| Term.elabTerm e ty ++ if (← whnfR (← inferType c)).isEq then ++ .proof <$> c.toSyntax ++ else ++ .const <$> c.toSyntax ++ ++def elabAdditiveCombination (tk : Syntax) ++ (norm? : Option Syntax.Tactic) (exp? : Option Syntax.NumLit) (input : Option Syntax.Term) ++ (twoGoals := false) : Tactic.TacticM Unit := Tactic.withMainContext do ++ let some (ty, _) := (← (← Tactic.getMainGoal).getType').eq? | ++ throwError "'additive_combination' only proves equalities" ++ let p ← match input with ++ | none => `(Eq.refl 0) ++ | some e => ++ match ← expandAdditiveCombo ty e with ++ | .const c => `(Eq.refl $c) ++ | .proof p => pure p ++ let norm := norm?.getD (Unhygienic.run <| withRef tk `(tactic| ((try simp only [smul_add, smul_sub]); abel))) ++ Term.withoutErrToSorry <| Tactic.evalTactic <| ← withFreshMacroScope <| ++ if twoGoals then ++ `(tactic| ( ++ refine eq_trans₃ $p ?a ?b ++ case' a => $norm:tactic ++ case' b => $norm:tactic)) ++ else ++ match exp? with ++ | some n => ++ if n.getNat = 1 then `(tactic| (refine eq_of_add $p ?a; case' a => $norm:tactic)) ++ else `(tactic| (refine eq_of_add_pow $n $p ?a; case' a => $norm:tactic)) ++ | _ => `(tactic| (refine eq_of_add $p ?a; case' a => $norm:tactic)) ++ ++syntax (name := AdditiveCombination) "additive_combination" ++ (normStx)? (expStx)? (ppSpace colGt term)? : tactic ++elab_rules : tactic ++ | `(tactic| additive_combination%$tk $[(norm := $tac)]? $[(exp := $n)]? $(e)?) => ++ elabAdditiveCombination tk tac n e ++ ++end Mathlib.Tactic.LinearCombinationPrime ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/Wiener.lean b/PrimeNumberTheoremAnd/Erdos970/Wiener.lean +new file mode 100644 +index 0000000..3259e31 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/Wiener.lean +@@ -0,0 +1,3571 @@ ++import Mathlib.Analysis.Fourier.RiemannLebesgueLemma ++import Mathlib.Analysis.Normed.Group.Tannery ++import Mathlib.Analysis.SumIntegralComparisons ++import Mathlib.NumberTheory.Chebyshev ++import Mathlib.NumberTheory.LSeries.PrimesInAP ++import Mathlib.NumberTheory.MulChar.Lemmas ++import Mathlib.Topology.EMetricSpace.BoundedVariation ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Analysis.Asymptotics.Asymptotics ++import PrimeNumberTheoremAnd.Erdos970.Fourier ++import PrimeNumberTheoremAnd.Erdos970.SmoothExistence ++import Mathlib.Analysis.Convolution ++ ++namespace Erdos970 ++ ++ ++open Real BigOperators ArithmeticFunction MeasureTheory Filter Set FourierTransform LSeries ++ _root_.Asymptotics Erdos970.Asymptotics SchwartzMap ++open Complex hiding log ++open scoped Topology ++open scoped ContDiff ++open scoped ComplexConjugate ++ ++variable {n : ℕ} {A a b c d u x y t σ' : ℝ} {ψ Ψ : ℝ → ℂ} {F G : ℂ → ℂ} {f : ℕ → ℂ} {𝕜 : Type} ++ [RCLike 𝕜] ++ ++noncomputable ++def nterm (f : ℕ → ℂ) (σ' : ℝ) (n : ℕ) : ℝ := if n = 0 then 0 else ‖f n‖ / n ^ σ' ++ ++lemma nterm_eq_norm_term {f : ℕ → ℂ} : nterm f σ' n = ‖term f σ' n‖ := by ++ by_cases h : n = 0 <;> simp [nterm, term, h] ++ ++theorem norm_term_eq_nterm_re (s : ℂ) : ++ ‖term f s n‖ = nterm f (s.re) n := by ++ simp only [nterm, term, apply_ite (‖·‖), norm_zero, norm_div] ++ apply ite_congr rfl (fun _ ↦ rfl) ++ intro h ++ congr ++ refine norm_natCast_cpow_of_pos (by omega) s ++ ++lemma hf_coe1 (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hσ : 1 < σ') : ++ ∑' i, (‖term f σ' i‖₊ : ENNReal) ≠ ⊤ := by ++ simp_rw [ENNReal.tsum_coe_ne_top_iff_summable_coe, ← norm_toNNReal] ++ norm_cast ++ apply Summable.toNNReal ++ convert hf σ' hσ with i ++ simp [nterm_eq_norm_term] ++ ++instance instMeasurableSpace : MeasurableSpace Circle := ++ inferInstanceAs <| MeasurableSpace <| Subtype _ ++instance instBorelSpace : BorelSpace Circle := ++ inferInstanceAs <| BorelSpace <| Subtype (· ∈ Metric.sphere (0 : ℂ) 1) ++ ++attribute [fun_prop] Real.continuous_fourierChar ++ ++lemma first_fourier_aux1 (hψ : AEMeasurable ψ) {x : ℝ} (n : ℕ) : AEMeasurable fun (u : ℝ) ↦ ++ (‖fourierChar (-(u * ((1 : ℝ) / ((2 : ℝ) * π) * (n / x).log))) • ψ u‖ₑ : ENNReal) := by ++ fun_prop ++ ++lemma first_fourier_aux2a : ++ (2 : ℂ) * π * -(y * (1 / (2 * π) * Real.log ((n) / x))) = -(y * ((n) / x).log) := by ++ calc ++ _ = -(y * (((2 : ℂ) * π) / (2 * π) * Real.log ((n) / x))) := by ring ++ _ = _ := by rw [div_self (by norm_num), one_mul] ++ ++lemma first_fourier_aux2 (hx : 0 < x) (n : ℕ) : ++ term f σ' n * 𝐞 (-(y * (1 / (2 * π) * Real.log (n / x)))) • ψ y = ++ term f (σ' + y * I) n • (ψ y * x ^ (y * I)) := by ++ by_cases hn : n = 0 ++ · simp [term, hn] ++ simp only [term, hn, ↓reduceIte] ++ calc ++ _ = (f n * (cexp ((2 * π * -(y * (1 / (2 * π) * Real.log (n / x)))) * I) / ++ ↑((n : ℝ) ^ σ'))) • ψ y := by ++ rw [Circle.smul_def, fourierChar_apply, ofReal_cpow (by norm_num)] ++ simp only [one_div, mul_inv_rev, mul_neg, ofReal_neg, ofReal_mul, ofReal_ofNat, ofReal_inv, ++ neg_mul, smul_eq_mul, ofReal_natCast] ++ ring ++ _ = (f n * (x ^ (y * I) / n ^ (σ' + y * I))) • ψ y := by ++ congr 2 ++ have l1 : 0 < (n : ℝ) := by simpa using Nat.pos_iff_ne_zero.mpr hn ++ have l2 : (x : ℂ) ≠ 0 := by simp [hx.ne.symm] ++ have l3 : (n : ℂ) ≠ 0 := by simp [hn] ++ rw [Real.rpow_def_of_pos l1, Complex.cpow_def_of_ne_zero l2, Complex.cpow_def_of_ne_zero l3] ++ push_cast ++ simp_rw [← Complex.exp_sub] ++ congr 1 ++ rw [first_fourier_aux2a, Real.log_div l1.ne.symm hx.ne.symm] ++ push_cast ++ rw [Complex.ofReal_log hx.le] ++ ring ++ _ = _ := by simp ; group ++ ++ ++lemma first_fourier (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hsupp : Integrable ψ) (hx : 0 < x) (hσ : 1 < σ') : ++ ∑' n : ℕ, term f σ' n * (𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))) = ++ ∫ t : ℝ, LSeries f (σ' + t * I) * ψ t * x ^ (t * I) := by ++ ++ calc ++ _ = ∑' n, term f σ' n * ∫ (v : ℝ), 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ simp only [Real.fourier_eq] ++ simp only [one_div, mul_inv_rev, RCLike.inner_apply', conj_trivial] ++ _ = ∑' n, ∫ (v : ℝ), term f σ' n * 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ simp [integral_const_mul] ++ _ = ∫ (v : ℝ), ∑' n, term f σ' n * 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ refine (integral_tsum ?_ ?_).symm ++ · refine fun _ ↦ AEMeasurable.aestronglyMeasurable ?_ ++ have := hsupp.aemeasurable ++ fun_prop ++ · simp only [enorm_mul] ++ simp_rw [lintegral_const_mul'' _ (first_fourier_aux1 hsupp.aemeasurable _)] ++ calc ++ _ = (∑' (i : ℕ), ‖term f σ' i‖ₑ) * ∫⁻ (a : ℝ), ‖ψ a‖ₑ ∂volume := by ++ simp [ENNReal.tsum_mul_right, enorm_eq_nnnorm] ++ _ ≠ ⊤ := ENNReal.mul_ne_top (hf_coe1 hf hσ) ++ (ne_top_of_lt hsupp.2) ++ _ = _ := by ++ congr 1; ext y ++ simp_rw [mul_assoc (LSeries _ _), ← smul_eq_mul (a := (LSeries _ _)), LSeries] ++ rw [← Summable.tsum_smul_const] ++ · simp_rw [first_fourier_aux2 hx] ++ · apply Summable.of_norm ++ convert hf σ' hσ with n ++ rw [norm_term_eq_nterm_re] ++ simp ++ ++@[continuity] ++lemma continuous_multiplicative_ofAdd : Continuous (⇑Multiplicative.ofAdd : ℝ → ℝ) := ⟨fun _ ↦ id⟩ ++ ++attribute [fun_prop] measurable_coe_nnreal_ennreal ++ ++lemma second_fourier_integrable_aux1a (hσ : 1 < σ') : ++ IntegrableOn (fun (x : ℝ) ↦ cexp (-((x : ℂ) * ((σ' : ℂ) - 1)))) (Ici (-Real.log x)) := by ++ norm_cast ++ suffices IntegrableOn (fun (x : ℝ) ↦ (rexp (-(x * (σ' - 1))))) (Ici (-x.log)) _ from this.ofReal ++ simp_rw [fun (a x : ℝ) ↦ (by ring : -(x * a) = -a * x)] ++ rw [integrableOn_Ici_iff_integrableOn_Ioi] ++ apply exp_neg_integrableOn_Ioi ++ linarith ++ ++lemma second_fourier_integrable_aux1 (hcont : Measurable ψ) (hsupp : Integrable ψ) (hσ : 1 < σ') : ++ let ν : Measure (ℝ × ℝ) := (volume.restrict (Ici (-Real.log x))).prod volume ++ Integrable (Function.uncurry fun (u : ℝ) (a : ℝ) ↦ ((rexp (-u * (σ' - 1))) : ℂ) • ++ (𝐞 (Multiplicative.ofAdd (-(a * (u / (2 * π))))) : ℂ) • ψ a) ν := by ++ intro ν ++ constructor ++ · apply Measurable.aestronglyMeasurable ++ ++ simp only [neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_sub, ofReal_one, ++ Multiplicative.ofAdd, smul_eq_mul] ++ change Measurable (fun v : ℝ × ℝ => ++ cexp (-((v.1 : ℂ) * ((σ' : ℂ) - 1))) * ++ ((𝐞 (-(v.2 * (v.1 / (2 * π)))) : ℂ) * ψ v.2)) ++ fun_prop ++ · let f1 : ℝ → ENNReal := fun a1 ↦ ‖cexp (-(↑a1 * (↑σ' - 1)))‖ₑ ++ let f2 : ℝ → ENNReal := fun a2 ↦ ‖ψ a2‖ₑ ++ suffices ∫⁻ (a : ℝ × ℝ), f1 a.1 * f2 a.2 ∂ν < ⊤ by ++ simpa [hasFiniteIntegral_iff_enorm, enorm_eq_nnnorm, Function.uncurry] ++ refine (lintegral_prod_mul ?_ ?_).trans_lt ?_ <;> try fun_prop ++ exact ENNReal.mul_lt_top (second_fourier_integrable_aux1a hσ).2 hsupp.2 ++ ++lemma second_fourier_integrable_aux2 (hσ : 1 < σ') : ++ IntegrableOn (fun (u : ℝ) ↦ cexp ((1 - ↑σ' - ↑t * I) * ↑u)) (Ioi (-Real.log x)) := by ++ refine (integrable_norm_iff (Measurable.aestronglyMeasurable <| by fun_prop)).mp ?_ ++ suffices IntegrableOn (fun a ↦ rexp (-(σ' - 1) * a)) (Ioi (-x.log)) _ by simpa [Complex.norm_exp] ++ apply exp_neg_integrableOn_Ioi ++ linarith ++ ++lemma second_fourier_aux (hx : 0 < x) : ++ -(cexp (-((1 - ↑σ' - ↑t * I) * ↑(Real.log x))) / (1 - ↑σ' - ↑t * I)) = ++ ↑(x ^ (σ' - 1)) * (↑σ' + ↑t * I - 1)⁻¹ * ↑x ^ (↑t * I) := by ++ calc ++ _ = cexp (↑(Real.log x) * ((↑σ' - 1) + ↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [← div_neg]; ring_nf ++ _ = (x ^ ((↑σ' - 1) + ↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [Complex.cpow_def_of_ne_zero (ofReal_ne_zero.mpr (ne_of_gt hx)), Complex.ofReal_log hx.le] ++ _ = (x ^ ((σ' : ℂ) - 1)) * (x ^ (↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [Complex.cpow_add _ _ (ofReal_ne_zero.mpr (ne_of_gt hx))] ++ _ = _ := by rw [ofReal_cpow hx.le]; push_cast; ring ++ ++ ++lemma second_fourier (hcont : Measurable ψ) (hsupp : Integrable ψ) ++ {x σ' : ℝ} (hx : 0 < x) (hσ : 1 < σ') : ++ ∫ u in Ici (-log x), Real.exp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ (x^(σ' - 1) : ℝ) * ∫ t, (1 / (σ' + t * I - 1)) * ψ t * x^(t * I) ∂ volume := by ++ ++ conv in ↑(rexp _) * _ => { rw [Real.fourier_real_eq, ← smul_eq_mul, ← integral_smul] } ++ rw [MeasureTheory.integral_integral_swap] ++ swap ++ · exact second_fourier_integrable_aux1 hcont hsupp hσ ++ rw [← integral_const_mul] ++ congr 1; ext t ++ dsimp ++ ++ simp_rw [mul_smul_comm, ← smul_mul_assoc, integral_mul_const] ++ rw [fun (a b d : ℂ) ↦ show a * (b * (ψ t) * d) = (a * b * d) * ψ t by ring] ++ congr 1 ++ conv => ++ lhs ++ enter [2] ++ ext a ++ rw [Circle.smul_def, smul_eq_mul] ++ simp only [Real.fourierChar, Circle.exp] ++ change cexp ((↑(2 * π * -(t * (a / (2 * π)))) : ℂ) * I) * ++ (rexp (-a * (σ' - 1)) : ℂ) ++ push_cast ++ simp_rw [← Complex.exp_add] ++ have (u : ℝ) : ++ 2 * ↑π * -(↑t * (↑u / (2 * ↑π))) * I + -↑u * (↑σ' - 1) = (1 - σ' - t * I) * u := calc ++ _ = -↑u * (↑σ' - 1) + (2 * ↑π) / (2 * ↑π) * -(↑t * ↑u) * I := by ring ++ _ = -↑u * (↑σ' - 1) + 1 * -(↑t * ↑u) * I := by rw [div_self (by norm_num)] ++ _ = _ := by ring ++ simp_rw [this] ++ let c : ℂ := (1 - ↑σ' - ↑t * I) ++ have : c ≠ 0 := by simp [Complex.ext_iff, c, sub_ne_zero.mpr hσ.ne] ++ let f' (u : ℝ) := cexp (c * u) ++ let f := fun (u : ℝ) ↦ (f' u) / c ++ have hderiv : ∀ u ∈ Ici (-Real.log x), HasDerivAt f (f' u) u := by ++ intro u _ ++ rw [show f' u = cexp (c * u) * (c * 1) / c by simp only [f']; field_simp] ++ exact (hasDerivAt_id' u).ofReal_comp.const_mul c |>.cexp.div_const c ++ have hf : Tendsto f atTop (𝓝 0) := by ++ apply tendsto_zero_iff_norm_tendsto_zero.mpr ++ suffices Tendsto (fun (x : ℝ) ↦ ‖cexp (c * ↑x)‖ / ‖c‖) atTop (𝓝 (0 / ‖c‖)) by ++ simpa [f, f'] using this ++ apply Filter.Tendsto.div_const ++ suffices Tendsto (· * (1 - σ')) atTop atBot by simpa [Complex.norm_exp, mul_comm (1 - σ'), c] ++ exact Tendsto.atTop_mul_const_of_neg (by linarith) fun ⦃s⦄ h ↦ h ++ rw [integral_Ici_eq_integral_Ioi, ++ integral_Ioi_of_hasDerivAt_of_tendsto' hderiv (second_fourier_integrable_aux2 hσ) hf] ++ simpa [f, f'] using second_fourier_aux hx ++ ++lemma one_add_sq_pos (u : ℝ) : 0 < 1 + u ^ 2 := zero_lt_one.trans_le (by simpa using sq_nonneg u) ++ ++theorem prelim_decay (ψ : ℝ → ℂ) (u : ℝ) : ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ ∫ t, ‖ψ t‖ := ++ VectorFourier.norm_fourierIntegral_le_integral_norm .. ++ ++lemma decay_bounds_key (f : W21) (u : ℝ) : ‖𝓕 (f : ℝ → ℂ) u‖ ≤ ‖f‖ * (1 + u ^ 2)⁻¹ := by ++ have l1 : 0 < 1 + u ^ 2 := one_add_sq_pos _ ++ have l2 : 1 + u ^ 2 = ‖(1 : ℂ) + u ^ 2‖ := by ++ norm_cast ; simp only [Real.norm_eq_abs, abs_eq_self.2 l1.le] ++ have l3 : ‖1 / ((4 : ℂ) * ↑π ^ 2)‖ ≤ (4 * π ^ 2)⁻¹ := by simp ++ have key := fourierIntegral_self_add_deriv_deriv f u ++ simp only [Function.iterate_succ _ 1, Function.iterate_one, Function.comp_apply] at key ++ rw [F_sub f.hf (f.hf''.const_mul (1 / (4 * ↑π ^ 2)))] at key ++ rw [← div_eq_mul_inv, le_div_iff₀ l1, mul_comm, l2, ← norm_mul, key, sub_eq_add_neg] ++ apply norm_add_le _ _ |>.trans ++ change _ ≤ W21.norm _ ++ rw [norm_neg, F_mul, norm_mul, W21.norm] ++ gcongr <;> apply VectorFourier.norm_fourierIntegral_le_integral_norm ++ ++lemma decay_bounds_aux {f : ℝ → ℂ} (hf : AEStronglyMeasurable f volume) ++ (h : ∀ t, ‖f t‖ ≤ A * (1 + t ^ 2)⁻¹) : ++ ∫ t, ‖f t‖ ≤ π * A := by ++ have l1 : Integrable (fun x ↦ A * (1 + x ^ 2)⁻¹) := integrable_inv_one_add_sq.const_mul A ++ simp_rw [← integral_univ_inv_one_add_sq, mul_comm, ← integral_const_mul] ++ exact integral_mono (l1.mono' hf (Eventually.of_forall h)).norm l1 h ++ ++theorem decay_bounds_W21 (f : W21) (hA : ∀ t, ‖f t‖ ≤ A / (1 + t ^ 2)) ++ (hA' : ∀ t, ‖deriv (deriv f) t‖ ≤ A / (1 + t ^ 2)) (u) : ++ ‖𝓕 (f : ℝ → ℂ) u‖ ≤ (π + 1 / (4 * π)) * A / (1 + u ^ 2) := by ++ have l0 : 1 * (4 * π)⁻¹ * A = (4 * π ^ 2)⁻¹ * (π * A) := by field_simp ++ have l1 : ∫ (v : ℝ), ‖f v‖ ≤ π * A := by ++ apply decay_bounds_aux f.continuous.aestronglyMeasurable ++ simp_rw [← div_eq_mul_inv] ; exact hA ++ have l2 : ∫ (v : ℝ), ‖deriv (deriv f) v‖ ≤ π * A := by ++ apply decay_bounds_aux f.deriv.deriv.continuous.aestronglyMeasurable ++ simp_rw [← div_eq_mul_inv] ; exact hA' ++ apply decay_bounds_key f u |>.trans ++ change W21.norm _ * _ ≤ _ ++ simp_rw [W21.norm, div_eq_mul_inv, add_mul, l0] ; gcongr ++ ++lemma decay_bounds (ψ : CS 2 ℂ) (hA : ∀ t, ‖ψ t‖ ≤ A / (1 + t ^ 2)) ++ (hA' : ∀ t, ‖deriv^[2] ψ t‖ ≤ A / (1 + t ^ 2)) : ++ ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ (π + 1 / (4 * π)) * A / (1 + u ^ 2) := by ++ exact decay_bounds_W21 ψ hA hA' u ++ ++lemma decay_bounds_cor_aux (ψ : CS 2 ℂ) : ∃ C : ℝ, ∀ u, ‖ψ u‖ ≤ C / (1 + u ^ 2) := by ++ have l1 : HasCompactSupport (fun u : ℝ => ((1 + u ^ 2) : ℝ) * ψ u) := by exact ψ.h2.mul_left ++ have := ψ.h1.continuous ++ obtain ⟨C, hC⟩ := l1.exists_bound_of_continuous (by fun_prop) ++ refine ⟨C, fun u => ?_⟩ ++ specialize hC u ++ simp only [norm_mul, Complex.norm_real, norm_of_nonneg (one_add_sq_pos u).le] at hC ++ rwa [le_div_iff₀' (one_add_sq_pos _)] ++ ++lemma decay_bounds_cor (ψ : W21) : ++ ∃ C : ℝ, ∀ u, ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by ++ simpa only [div_eq_mul_inv] using ⟨_, decay_bounds_key ψ⟩ ++ ++@[continuity, fun_prop] lemma continuous_FourierIntegral (ψ : W21) : Continuous (𝓕 (ψ : ℝ → ℂ)) := ++ VectorFourier.fourierIntegral_continuous continuous_fourierChar ++ (by simp only [innerₗ_apply_apply, RCLike.inner_apply', conj_trivial, continuous_mul]) ++ ψ.hf ++ ++lemma W21.integrable_fourier (ψ : W21) (hc : c ≠ 0) : ++ Integrable fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c) := by ++ have l1 (C) : Integrable (fun u ↦ C / (1 + (u / c) ^ 2)) volume := by ++ simpa using! (integrable_inv_one_add_sq.comp_div hc).const_mul C ++ have l2 : AEStronglyMeasurable (fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c)) volume := by ++ apply Continuous.aestronglyMeasurable ; fun_prop ++ obtain ⟨C, h⟩ := decay_bounds_cor ψ ++ apply @Integrable.mono' ℝ ℂ _ volume _ _ (fun u => C / (1 + (u / c) ^ 2)) (l1 C) l2 ?_ ++ apply Eventually.of_forall (fun x => h _) ++ ++lemma continuous_LSeries_aux (hf : Summable (nterm f σ')) : ++ Continuous fun x : ℝ => LSeries f (σ' + x * I) := by ++ ++ have l1 i : Continuous fun x : ℝ ↦ term f (σ' + x * I) i := by ++ by_cases h : i = 0 ++ · simpa [h] using continuous_const ++ · simpa [h] using! continuous_const.div (continuous_const.cpow (by fun_prop) (by simp [h])) ++ (fun x => by simp [h]) ++ have l2 n (x : ℝ) : ‖term f (σ' + x * I) n‖ = nterm f σ' n := by ++ by_cases h : n = 0 ++ · simp [h, nterm] ++ · simp [h, nterm, cpow_add _ _ (Nat.cast_ne_zero.mpr h), ++ Complex.norm_natCast_cpow_of_pos (Nat.pos_of_ne_zero h)] ++ exact continuous_tsum l1 hf (fun n x => le_of_eq (l2 n x)) ++ ++lemma limiting_fourier_aux (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) (σ' : ℝ) ++ (hσ' : 1 < σ') : ++ ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * (x ^ (1 - σ') : ℝ) * ∫ u in Ici (- log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) ++ (u / (2 * π)) = ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I) := by ++ have hint : Integrable ψ := ψ.h1.continuous.integrable_of_hasCompactSupport ψ.h2 ++ have l3 : 0 < x := zero_lt_one.trans_le hx ++ have l1 (σ') (hσ' : 1 < σ') := first_fourier hf hint l3 hσ' ++ have l2 (σ') (hσ' : 1 < σ') := second_fourier ψ.h1.continuous.measurable hint l3 hσ' ++ have l8 : Continuous fun t : ℝ ↦ (x : ℂ) ^ (t * I) := ++ continuous_const.cpow (continuous_ofReal.mul continuous_const) (by simp [l3]) ++ have l6 : Continuous fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by ++ apply ((continuous_LSeries_aux (hf _ hσ')).mul ψ.h1.continuous).mul l8 ++ have l4 : Integrable fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by ++ exact l6.integrable_of_hasCompactSupport ψ.h2.mul_left.mul_right ++ have e2 (u : ℝ) : σ' + u * I - 1 ≠ 0 := by ++ intro h ; have := congr_arg Complex.re h ; simp at this ; linarith ++ have l7 : Continuous fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * ++ (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ simp only [one_div, ← mul_assoc] ++ refine ((continuous_const.mul <| Continuous.inv₀ ?_ e2).mul ψ.h1.continuous).mul l8 ++ fun_prop ++ have l5 : Integrable fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * ++ (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ apply l7.integrable_of_hasCompactSupport ++ exact ψ.h2.mul_left.mul_right.mul_left.mul_left ++ ++ simp_rw [l1 σ' hσ', l2 σ' hσ', ← integral_const_mul, ← integral_sub l4 l5] ++ apply integral_congr_ae ++ apply Eventually.of_forall ++ intro u ++ have e1 : 1 < ((σ' : ℂ) + (u : ℂ) * I).re := by simp [hσ'] ++ simp_rw [hG' e1, sub_mul, ← mul_assoc] ++ simp only [one_div, sub_right_inj, mul_eq_mul_right_iff, cpow_eq_zero_iff, ofReal_eq_zero, ne_eq, ++ mul_eq_zero, I_ne_zero, or_false] ++ left ; left ++ field_simp [e2] ++ norm_cast ++ simp [mul_assoc, ← rpow_add l3] ++ ++section nabla ++ ++variable {α E : Type*} [OfNat α 1] [Add α] [Sub α] {u : α → ℂ} ++ ++def cumsum [AddCommMonoid E] (u : ℕ → E) (n : ℕ) : E := ∑ i ∈ Finset.range n, u i ++ ++def nabla [Sub E] (u : α → E) (n : α) : E := u (n + 1) - u n ++ ++def nnabla [Sub E] (u : α → E) (n : α) : E := u n - u (n + 1) ++ ++def shift (u : α → E) (n : α) : E := u (n + 1) ++ ++@[simp] lemma cumsum_zero [AddCommMonoid E] {u : ℕ → E} : cumsum u 0 = 0 := by simp [cumsum] ++ ++lemma cumsum_succ [AddCommMonoid E] {u : ℕ → E} (n : ℕ) : ++ cumsum u (n + 1) = cumsum u n + u n := by ++ simp [cumsum, Finset.sum_range_succ] ++ ++@[simp] lemma nabla_cumsum [AddCommGroup E] {u : ℕ → E} : nabla (cumsum u) = u := by ++ ext n ; simp [nabla, cumsum, Finset.range_add_one] ++ ++lemma neg_cumsum [AddCommGroup E] {u : ℕ → E} : -(cumsum u) = cumsum (-u) := ++ funext (fun n => by simp [cumsum]) ++ ++lemma cumsum_nonneg {u : ℕ → ℝ} (hu : 0 ≤ u) : 0 ≤ cumsum u := ++ fun _ => Finset.sum_nonneg (fun i _ => hu i) ++ ++omit [Sub α] in ++lemma neg_nabla [Ring E] {u : α → E} : -(nabla u) = nnabla u := by ext n ; simp [nabla, nnabla] ++ ++omit [Sub α] in ++@[simp] lemma nabla_mul [Ring E] {u : α → E} {c : E} : nabla (fun n => c * u n) = c • nabla u := by ++ ext n ; simp [nabla, mul_sub] ++ ++omit [Sub α] in ++@[simp] lemma nnabla_mul [Ring E] {u : α → E} {c : E} : ++ nnabla (fun n => c * u n) = c • nnabla u := by ++ ext n ; simp [nnabla, mul_sub] ++ ++lemma nnabla_cast (u : ℝ → E) [Sub E] : nnabla u ∘ ((↑) : ℕ → ℝ) = nnabla (u ∘ (↑)) := by ++ ext n ; simp [nnabla] ++ ++end nabla ++ ++lemma Finset.sum_shift_front {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++ cumsum u (n + 1) = u 0 + cumsum (shift u) n := by ++ simp_rw [add_comm n, cumsum, _root_.Finset.sum_range_add, ++ _root_.Finset.sum_range_one, add_comm 1] ; rfl ++ ++lemma Finset.sum_shift_front' {E : Type*} [Ring E] {u : ℕ → E} : ++ shift (cumsum u) = (fun _ => u 0) + cumsum (shift u) := by ++ ext n ; apply Finset.sum_shift_front ++ ++lemma Finset.sum_shift_back {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++ cumsum u (n + 1) = cumsum u n + u n := by ++ simp [cumsum, Finset.range_add_one, add_comm] ++ ++lemma Finset.sum_shift_back' {E : Type*} [Ring E] {u : ℕ → E} : ++ shift (cumsum u) = cumsum u + u := by ++ ext n ; apply Finset.sum_shift_back ++ ++lemma summation_by_parts {E : Type*} [Ring E] {a A b : ℕ → E} (ha : a = nabla A) {n : ℕ} : ++ cumsum (a * b) (n + 1) = A (n + 1) * b n - A 0 * b 0 - ++ cumsum (shift A * fun i => (b (i + 1) - b i)) n := by ++ have l1 : ∑ x ∈ Finset.range (n + 1), A (x + 1) * b x = ∑ x ∈ Finset.range n, ++ A (x + 1) * b x + A (n + 1) * b n := ++ Finset.sum_shift_back ++ have l2 : ∑ x ∈ Finset.range (n + 1), A x * b x = A 0 * b 0 + ∑ x ∈ Finset.range n, ++ A (x + 1) * b (x + 1) := ++ Finset.sum_shift_front ++ simp only [cumsum, ha, Pi.mul_apply, nabla, sub_mul, Finset.sum_sub_distrib, l1, l2, shift, ++ mul_sub] ++ abel ++ ++lemma summation_by_parts' {E : Type*} [Ring E] {a b : ℕ → E} {n : ℕ} : ++ cumsum (a * b) (n + 1) = cumsum a (n + 1) * b n - cumsum (shift (cumsum a) * nabla b) n := by ++ simpa using! summation_by_parts (a := a) (b := b) (A := cumsum a) (by simp) ++ ++lemma summation_by_parts'' {E : Type*} [Ring E] {a b : ℕ → E} : ++ shift (cumsum (a * b)) = shift (cumsum a) * b - cumsum (shift (cumsum a) * nabla b) := by ++ ext n ; apply summation_by_parts' ++ ++lemma summable_iff_bounded {u : ℕ → ℝ} (hu : 0 ≤ u) : ++ Summable u ↔ BoundedAtFilter atTop (cumsum u) := by ++ have l1 : (cumsum u =O[atTop] 1) ↔ _ := isBigO_one_nat_atTop_iff ++ have l2 n : ‖cumsum u n‖ = cumsum u n := by simpa using cumsum_nonneg hu n ++ simp only [BoundedAtFilter, l1, l2] ++ constructor <;> intro ⟨C, h1⟩ ++ · exact ⟨C, fun n => sum_le_hasSum _ (fun i _ => hu i) h1⟩ ++ · exact summable_of_sum_range_le hu h1 ++ ++lemma Filter.EventuallyEq.summable {u v : ℕ → ℝ} (h : u =ᶠ[atTop] v) (hu : Summable v) : ++ Summable u := ++ summable_of_isBigO_nat hu h.isBigO ++ ++lemma summable_congr_ae {u v : ℕ → ℝ} (huv : u =ᶠ[atTop] v) : Summable u ↔ Summable v := by ++ exact ⟨Erdos970.Filter.EventuallyEq.summable huv.symm, ++ Erdos970.Filter.EventuallyEq.summable huv⟩ ++ ++lemma BoundedAtFilter.add_const {u : ℕ → ℝ} {c : ℝ} : ++ BoundedAtFilter atTop (fun n => u n + c) ↔ BoundedAtFilter atTop u := by ++ have : u = fun n => (u n + c) + (-c) := by ext n ; ring ++ simp only [BoundedAtFilter] ++ constructor <;> intro h ++ on_goal 1 => rw [this] ++ all_goals { exact h.add (const_boundedAtFilter _ _) } ++ ++lemma BoundedAtFilter.comp_add {u : ℕ → ℝ} {N : ℕ} : ++ BoundedAtFilter atTop (fun n => u (n + N)) ↔ BoundedAtFilter atTop u := by ++ simp only [BoundedAtFilter, isBigO_iff, norm_eq_abs, Pi.one_apply, ++ eventually_atTop] ++ constructor <;> intro ⟨C, n₀, h⟩ <;> use C ++ · refine ⟨n₀ + N, fun n hn => ?_⟩ ++ obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le' (m := N) (n := n) (by grind) ++ exact h _ <| Nat.add_le_add_iff_right.mp hn ++ · exact ⟨n₀, fun n hn => h _ (by grind)⟩ ++ ++lemma summable_iff_bounded' {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, 0 ≤ u n) : ++ Summable u ↔ BoundedAtFilter atTop (cumsum u) := by ++ obtain ⟨N, hu⟩ := eventually_atTop.mp hu ++ have e2 : cumsum (fun i ↦ u (i + N)) = fun n => cumsum u (n + N) - cumsum u N := by ++ ext n ; simp_rw [cumsum, add_comm _ N, Finset.sum_range_add] ; ring ++ rw [← summable_nat_add_iff N, summable_iff_bounded (fun n => hu _ <| Nat.le_add_left N n), e2] ++ simp_rw [sub_eq_add_neg, BoundedAtFilter.add_const, BoundedAtFilter.comp_add] ++ ++lemma bounded_of_shift {u : ℕ → ℝ} (h : BoundedAtFilter atTop (shift u)) : ++ BoundedAtFilter atTop u := by ++ simp only [BoundedAtFilter, isBigO_iff, eventually_atTop] at h ⊢ ++ obtain ⟨C, N, hC⟩ := h ++ refine ⟨C, N + 1, fun n hn => ?_⟩ ++ simp only [shift] at hC ++ have r1 : n - 1 ≥ N := Nat.le_sub_one_of_lt hn ++ have r2 : n - 1 + 1 = n := Nat.sub_add_cancel (by omega) ++ simpa [r2] using hC (n - 1) r1 ++ ++lemma dirichlet_test' {a b : ℕ → ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) ++ (hAb : BoundedAtFilter atTop (shift (cumsum a) * b)) (hbb : ∀ᶠ n in atTop, b (n + 1) ≤ b n) ++ (h : Summable (shift (cumsum a) * nnabla b)) : Summable (a * b) := by ++ have l1 : ∀ᶠ n in atTop, 0 ≤ (shift (cumsum a) * nnabla b) n := by ++ filter_upwards [hbb] with n hb ++ exact mul_nonneg (by ++ change 0 ≤ ∑ index ∈ Finset.range (n + 1), a index ++ exact Finset.sum_nonneg (fun index _ => ha index)) (sub_nonneg.mpr hb) ++ rw [summable_iff_bounded (mul_nonneg ha hb)] ++ rw [summable_iff_bounded' l1] at h ++ apply bounded_of_shift ++ simpa only [summation_by_parts'', sub_eq_add_neg, neg_cumsum, ← mul_neg, neg_nabla] ++ using hAb.add h ++ ++lemma exists_antitone_of_eventually {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, u (n + 1) ≤ u n) : ++ ∃ v : ℕ → ℝ, range v ⊆ range u ∧ Antitone v ∧ v =ᶠ[atTop] u := by ++ obtain ⟨N, hN⟩ := eventually_atTop.mp hu ++ let v (n : ℕ) := u (if n < N then N else n) ++ refine ⟨v, ?_, ?_, ?_⟩ ++ · exact fun x ⟨n, hn⟩ => ⟨if n < N then N else n, hn⟩ ++ · refine antitone_nat_of_succ_le (fun n => ?_) ++ by_cases h : n < N ++ · by_cases h' : n + 1 < N <;> simp [v, h, h'] ++ have : n + 1 = N := by linarith ++ simp [this] ++ · have : ¬(n + 1 < N) := by linarith ++ simp only [this, ↓reduceIte, h, ge_iff_le, v] ; apply hN ; linarith ++ · have : ∀ᶠ n in atTop, ¬(n < N) := by simpa using ⟨N, fun b hb => by linarith⟩ ++ filter_upwards [this] with n hn ; simp [v, hn] ++ ++lemma summable_inv_mul_log_sq : Summable (fun n : ℕ => (n * (Real.log n) ^ 2)⁻¹) := by ++ let u (n : ℕ) := (n * (Real.log n) ^ 2)⁻¹ ++ have l7 : ∀ᶠ n : ℕ in atTop, 1 ≤ Real.log n := ++ tendsto_atTop.mp (tendsto_log_atTop.comp tendsto_natCast_atTop_atTop) 1 ++ have l8 : ∀ᶠ n : ℕ in atTop, 1 ≤ n := eventually_ge_atTop 1 ++ have l9 : ∀ᶠ n in atTop, u (n + 1) ≤ u n := by ++ filter_upwards [l7, l8] with n l2 l8; dsimp [u]; gcongr <;> simp ++ obtain ⟨v, l1, l2, l3⟩ := exists_antitone_of_eventually l9 ++ rw [summable_congr_ae l3.symm] ++ have l4 (n : ℕ) : 0 ≤ v n := by obtain ⟨k, hk⟩ := l1 ⟨n, rfl⟩ ; rw [← hk] ; positivity ++ apply (summable_condensed_iff_of_nonneg l4 (fun _ _ _ a ↦ l2 a)).mp ++ suffices this : ∀ᶠ k : ℕ in atTop, 2 ^ k * v (2 ^ k) = ((k : ℝ) ^ 2)⁻¹ * ((Real.log 2) ^ 2)⁻¹ by ++ exact (summable_congr_ae this).mpr <| (Real.summable_nat_pow_inv.mpr one_lt_two).mul_right _ ++ have l5 : ∀ᶠ k in atTop, v (2 ^ k) = u (2 ^ k) := ++ l3.comp_tendsto <| tendsto_pow_atTop_atTop_of_one_lt Nat.le.refl ++ filter_upwards [l5, l8] with k l5 l8 ++ simp only [l5, mul_inv_rev, Nat.cast_pow, Nat.cast_ofNat, log_pow, u] ++ field_simp ++ ++lemma tendsto_mul_add_atTop {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ Tendsto (fun x => a * x + b) atTop atTop := ++ tendsto_atTop_add_const_right _ b (tendsto_id.const_mul_atTop ha) ++ ++lemma isLittleO_const_of_tendsto_atTop {α : Type*} [Preorder α] (a : ℝ) {f : α → ℝ} ++ (hf : Tendsto f atTop atTop) : (fun _ => a) =o[atTop] f := by ++ simp [tendsto_norm_atTop_atTop.comp hf] ++ ++lemma isBigO_pow_pow_of_le {m n : ℕ} (h : m ≤ n) : ++ (fun x : ℝ => x ^ m) =O[atTop] (fun x : ℝ => x ^ n) := by ++ apply IsBigO.of_bound 1 ++ filter_upwards [eventually_ge_atTop 1] with x l1 ++ simpa [abs_eq_self.mpr (zero_le_one.trans l1)] using pow_le_pow_right₀ l1 h ++ ++lemma isLittleO_mul_add_sq (a b : ℝ) : (fun x => a * x + b) =o[atTop] (fun x => x ^ 2) := by ++ apply IsLittleO.add ++ · apply IsLittleO.const_mul_left ; simpa using isLittleO_pow_pow_atTop_of_lt (𝕜 := ℝ) one_lt_two ++ · apply isLittleO_const_of_tendsto_atTop _ <| tendsto_pow_atTop (by linarith) ++ ++lemma log_mul_add_isBigO_log {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ (fun x => Real.log (a * x + b)) =O[atTop] Real.log := by ++ apply IsBigO.of_bound (2 : ℕ) ++ have l2 : ∀ᶠ x : ℝ in atTop, 0 ≤ log x := tendsto_atTop.mp tendsto_log_atTop 0 ++ have l3 : ∀ᶠ x : ℝ in atTop, 0 ≤ log (a * x + b) := ++ tendsto_atTop.mp (tendsto_log_atTop.comp (tendsto_mul_add_atTop ha b)) 0 ++ have l5 : ∀ᶠ x : ℝ in atTop, 1 ≤ a * x + b := tendsto_atTop.mp (tendsto_mul_add_atTop ha b) 1 ++ have l1 : ∀ᶠ x : ℝ in atTop, a * x + b ≤ x ^ 2 := by ++ filter_upwards [(isLittleO_mul_add_sq a b).eventuallyLE, l5] with x r2 l5 ++ simpa [abs_eq_self.mpr (zero_le_one.trans l5)] using r2 ++ filter_upwards [l1, l2, l3, l5] with x l1 l2 l3 l5 ++ simpa [abs_eq_self.mpr l2, abs_eq_self.mpr l3, Real.log_pow] using ++ Real.log_le_log (by linarith) l1 ++ ++lemma isBigO_log_mul_add {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ Real.log =O[atTop] (fun x => Real.log (a * x + b)) := by ++ convert! (log_mul_add_isBigO_log (b := -b / a) (inv_pos.mpr ha)).comp_tendsto ++ (tendsto_mul_add_atTop (b := b) ha) using 1 ++ ext x ++ simp only [Function.comp_apply] ++ congr ++ field_simp ++ simp ++ ++lemma log_isbigo_log_div {d : ℝ} (hb : 0 < d) : ++ (fun n ↦ Real.log n) =O[atTop] (fun n ↦ Real.log (n / d)) := by ++ convert isBigO_log_mul_add (inv_pos.mpr hb) 0 using 1; simp only [add_zero]; field_simp ++ ++lemma Asymptotics.IsBigO.add_isLittleO_right {f g : ℝ → ℝ} (h : g =o[atTop] f) : ++ f =O[atTop] (f + g) := by ++ rw [isLittleO_iff] at h ; specialize h (c := 2⁻¹) (by norm_num) ++ rw [isBigO_iff''] ++ refine ⟨2⁻¹, by norm_num, ?_⟩ ++ filter_upwards [h] with x h ++ simp only [norm_eq_abs, Pi.add_apply] at h ⊢ ++ calc _ = |f x| - 2⁻¹ * |f x| := by ring ++ _ ≤ |f x| - |g x| := by linarith ++ _ ≤ |(|f x| - |g x|)| := le_abs_self _ ++ _ ≤ _ := by rw [← sub_neg_eq_add, ← abs_neg (g x)] ; exact abs_abs_sub_abs_le (f x) (-g x) ++ ++lemma Asymptotics.IsBigO.sq {α : Type*} [Preorder α] {f g : α → ℝ} (h : f =O[atTop] g) : ++ (fun n ↦ f n ^ 2) =O[atTop] (fun n => g n ^ 2) := by ++ simpa [pow_two] using h.mul h ++ ++lemma log_sq_isbigo_mul {a b : ℝ} (hb : 0 < b) : ++ (fun x ↦ Real.log x ^ 2) =O[atTop] (fun x ↦ a + Real.log (x / b) ^ 2) := by ++ apply (Erdos970.Asymptotics.IsBigO.sq (log_isbigo_log_div hb)).trans ++ simp_rw [add_comm a] ++ refine IsBigO.add_isLittleO_right <| isLittleO_const_of_tendsto_atTop _ ?_ ++ exact (tendsto_pow_atTop two_ne_zero).comp <| ++ tendsto_log_atTop.comp <| tendsto_id.atTop_div_const hb ++ ++theorem log_add_div_isBigO_log (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ (fun x ↦ Real.log ((x + a) / b)) =O[atTop] fun x ↦ Real.log x := by ++ convert log_mul_add_isBigO_log (inv_pos.mpr hb) (a / b) using 3 ; ring ++ ++lemma log_add_one_sub_log_le {x : ℝ} (hx : 0 < x) : nabla Real.log x ≤ x⁻¹ := by ++ have l1 : ContinuousOn Real.log (Icc x (x + 1)) := by ++ apply continuousOn_log.mono ; intro t ⟨h1, _⟩ ; simp ; linarith ++ have l2 t (ht : t ∈ Ioo x (x + 1)) : HasDerivAt Real.log t⁻¹ t := ++ Real.hasDerivAt_log (by linarith [ht.1]) ++ obtain ⟨t, ⟨ht1, _⟩, htx⟩ := exists_hasDerivAt_eq_slope Real.log (·⁻¹) (by linarith) l1 l2 ++ simp only [add_sub_cancel_left, div_one] at htx ++ rw [nabla, ← htx, inv_le_inv₀ (by linarith) hx] ++ exact ht1.le ++ ++lemma nabla_log_main : nabla Real.log =O[atTop] fun x ↦ 1 / x := by ++ apply IsBigO.of_bound 1 ++ filter_upwards [eventually_gt_atTop 0] with x l1 ++ have l2 : log x ≤ log (x + 1) := log_le_log l1 (by linarith) ++ simpa [nabla, abs_eq_self.mpr l1.le, abs_eq_self.mpr (sub_nonneg.mpr l2)] using ++ log_add_one_sub_log_le l1 ++ ++lemma nabla_log {b : ℝ} (hb : 0 < b) : ++ nabla (fun x => Real.log (x / b)) =O[atTop] (fun x => 1 / x) := by ++ refine EventuallyEq.trans_isBigO ?_ nabla_log_main ++ filter_upwards [eventually_gt_atTop 0] with x l2 ++ rw [nabla, log_div (by linarith) (by linarith), log_div l2.ne.symm (by linarith), nabla] ; ring ++ ++lemma nnabla_mul_log_sq (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ nabla (fun x => x * (a + Real.log (x / b) ^ 2)) =O[atTop] (fun x => Real.log x ^ 2) := by ++ ++ have l1 : nabla (fun n => n * (a + Real.log (n / b) ^ 2)) = fun n => ++ a + Real.log ((n + 1) / b) ^ 2 + ++ (n * (Real.log ((n + 1) / b) ^ 2 - Real.log (n / b) ^ 2)) := by ++ ext n ; simp [nabla] ; ring ++ have l2 := (isLittleO_const_of_tendsto_atTop a ++ ((tendsto_pow_atTop two_ne_zero).comp tendsto_log_atTop)).isBigO ++ have l3 := Erdos970.Asymptotics.IsBigO.sq (log_add_div_isBigO_log 1 hb) ++ have l4 : (fun x => Real.log ((x + 1) / b) + Real.log (x / b)) =O[atTop] Real.log := by ++ simpa using (log_add_div_isBigO_log _ hb).add (log_add_div_isBigO_log 0 hb) ++ have e2 : (fun x : ℝ => x * (Real.log x * (1 / x))) =ᶠ[atTop] Real.log := by ++ filter_upwards [eventually_ge_atTop 1] with x hx using by field_simp ++ have l5 : (fun n ↦ n * (Real.log n * (1 / n))) =O[atTop] (fun n ↦ (Real.log n) ^ 2) := ++ e2.trans_isBigO ++ (by simpa using! (isLittleO_mul_add_sq 1 0).isBigO.comp_tendsto Real.tendsto_log_atTop) ++ ++ simp_rw [l1, _root_.sq_sub_sq] ++ exact ((l2.add l3).add (isBigO_refl (·) atTop |>.mul (l4.mul (nabla_log hb)) |>.trans l5)) ++ ++lemma nnabla_bound_aux1 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ Tendsto (fun x => x * (a + Real.log (x / b) ^ 2)) atTop atTop := ++ tendsto_id.atTop_mul_atTop₀ <| tendsto_atTop_add_const_left _ _ <| ++ (tendsto_pow_atTop two_ne_zero).comp <| tendsto_log_atTop.comp <| tendsto_id.atTop_div_const hb ++ ++lemma nnabla_bound_aux2 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ ∀ᶠ x in atTop, 0 < x * (a + Real.log (x / b) ^ 2) := ++ (nnabla_bound_aux1 a hb).eventually (eventually_gt_atTop 0) ++ ++lemma Real.log_eventually_gt_atTop (a : ℝ) : ++ ∀ᶠ x in atTop, a < Real.log x := ++ Real.tendsto_log_atTop.eventually (eventually_gt_atTop a) ++ ++@[local gcongr] ++theorem norm_lt_norm_of_nonneg (x y : ℝ) (hx : 0 ≤ x) (hxy : x ≤ y) : ++ ‖x‖ ≤ ‖y‖ := by ++ simp_rw [Real.norm_eq_abs] ++ apply abs_le_abs hxy ++ linarith ++ ++lemma nnabla_bound_aux {x : ℝ} (hx : 0 < x) : ++ nnabla (fun n ↦ 1 / (n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2))) =O[atTop] ++ (fun n ↦ 1 / (Real.log n ^ 2 * n ^ 2)) := by ++ ++ let d n : ℝ := n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2) ++ change (fun x_1 ↦ nnabla (fun n ↦ 1 / d n) x_1) =O[atTop] _ ++ ++ have l2 : ∀ᶠ n in atTop, 0 < d n := (nnabla_bound_aux2 ((2 * π) ^ 2) hx) ++ have l3 : ∀ᶠ n in atTop, 0 < d (n + 1) := ++ (tendsto_atTop_add_const_right atTop (1 : ℝ) tendsto_id).eventually l2 ++ have l1 : ∀ᶠ n : ℝ in atTop, ++ nnabla (fun n ↦ 1 / d n) n = (d (n + 1) - d n) * (d n)⁻¹ * (d (n + 1))⁻¹ := by ++ filter_upwards [l2, l3] with n l2 l3 ++ rw [nnabla, one_div, one_div, inv_sub_inv l2.ne.symm l3.ne.symm, div_eq_mul_inv, mul_inv, ++ mul_assoc] ++ ++ have l4 : (fun n => (d n)⁻¹) =O[atTop] (fun n => (n * (Real.log n) ^ 2)⁻¹) := by ++ apply IsBigO.inv_rev ++ · refine (isBigO_refl _ _).mul <| (log_sq_isbigo_mul hx) ++ · filter_upwards [Real.log_eventually_gt_atTop 0, eventually_gt_atTop 0] with x hx hx' ++ rw [← not_imp_not] ++ intro _ ++ positivity ++ have l5 : (fun n => (d (n + 1))⁻¹) =O[atTop] (fun n => (n * (Real.log n) ^ 2)⁻¹) := by ++ refine IsBigO.trans ?_ l4 ++ rw [isBigO_iff]; use 1 ++ have e3 : ∀ᶠ n in atTop, d n ≤ d (n + 1) := by ++ filter_upwards [eventually_ge_atTop x] with n hn ++ have e2 : 1 ≤ n / x := (one_le_div hx).mpr hn ++ have : 0 ≤ n := hx.le.trans hn ++ simp only [d] ++ gcongr <;> simp [Real.log_nonneg, *] ++ filter_upwards [l2, l3, e3] with n e1 e2 e3 ++ simp_rw [one_mul] ++ gcongr ++ ++ have l6 : (fun n => d (n + 1) - d n) =O[atTop] (fun n => (Real.log n) ^ 2) := by ++ simpa [d, nabla] using! (nnabla_mul_log_sq ((2 * π) ^ 2) hx) ++ ++ apply EventuallyEq.trans_isBigO l1 ++ ++ apply ((l6.mul l4).mul l5).trans_eventuallyEq ++ filter_upwards [eventually_ge_atTop 2, Real.log_eventually_gt_atTop 0] with n hn hn' ++ field_simp ++ ++lemma nnabla_bound (C : ℝ) {x : ℝ} (hx : 0 < x) : ++ nnabla (fun n => C / (1 + (Real.log (n / x) / (2 * π)) ^ 2) / n) =O[atTop] ++ (fun n => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by ++ field_simp ++ simp only [div_eq_mul_inv, mul_inv, nnabla_mul, one_mul] ++ apply IsBigO.const_mul_left ++ simpa [div_eq_mul_inv, mul_pow, mul_comm] using nnabla_bound_aux hx ++ ++def chebyWith (C : ℝ) (f : ℕ → ℂ) : Prop := ∀ n, cumsum (‖f ·‖) n ≤ C * n ++ ++def cheby (f : ℕ → ℂ) : Prop := ∃ C, chebyWith C f ++ ++lemma cheby.bigO (h : cheby f) : cumsum (‖f ·‖) =O[atTop] ((↑) : ℕ → ℝ) := by ++ have l1 : 0 ≤ cumsum (‖f ·‖) := cumsum_nonneg (fun _ => norm_nonneg _) ++ obtain ⟨C, hC⟩ := h ++ apply isBigO_of_le' (c := C) atTop ++ intro n ++ rw [Real.norm_eq_abs, abs_eq_self.mpr (l1 n)] ++ simpa using hC n ++ ++lemma limiting_fourier_lim1_aux (hcheby : cheby f) (hx : 0 < x) (C : ℝ) (hC : 0 ≤ C) : ++ Summable fun n ↦ ‖f n‖ / ↑n * (C / (1 + (1 / (2 * π) * Real.log (↑n / x)) ^ 2)) := by ++ ++ let a (n : ℕ) := (C / (1 + (Real.log (↑n / x) / (2 * π)) ^ 2) / ↑n) ++ replace hcheby := hcheby.bigO ++ ++ have l1 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n : ℕ => (↑(n + 1) : ℝ)) := ++ hcheby.comp_tendsto <| tendsto_add_atTop_nat 1 ++ have l2 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n => (n : ℝ)) := ++ l1.trans ++ (by simpa using (isBigO_refl _ _).add <| isBigO_iff.mpr ⟨1, by simpa using ⟨1, by tauto⟩⟩) ++ have l5 : BoundedAtFilter atTop (fun n : ℕ => C / (1 + (Real.log (↑n / x) / (2 * π)) ^ 2)) := by ++ simp only [BoundedAtFilter] ++ field_simp ++ apply isBigO_of_le' (c := C) ; intro n ++ have : 0 ≤ 2 ^ 2 * π ^ 2 + Real.log (n / x) ^ 2 := by positivity ++ simp only [norm_div, norm_mul, norm_eq_abs, abs_eq_self.mpr hC, norm_pow, ++ abs_eq_self.mpr pi_nonneg, abs_eq_self.mpr this, Pi.one_apply, one_mem, ++ CStarRing.norm_of_mem_unitary, mul_one, ge_iff_le, Nat.abs_ofNat] ++ apply div_le_of_le_mul₀ this hC ++ rw [mul_add, ← mul_assoc] ++ apply le_add_of_le_of_nonneg le_rfl ++ positivity ++ have l3 : a =O[atTop] (fun n => 1 / (n : ℝ)) := by ++ simpa [a] using! IsBigO.mul l5 (isBigO_refl (fun n : ℕ => 1 / (n : ℝ)) _) ++ have l4 : nnabla a =O[atTop] (fun n : ℕ => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by ++ convert Erdos970.Asymptotics.IsBigO.natCast (nnabla_bound C hx) ++ simp [nnabla, a] ++ ++ simp_rw [div_mul_eq_mul_div, mul_div_assoc, one_mul] ++ apply dirichlet_test' ++ · intro n ; exact norm_nonneg _ ++ · intro n ; positivity ++ · apply (l2.mul l3).trans_eventuallyEq ++ apply eventually_of_mem (Ici_mem_atTop 1) ++ intro x (hx : 1 ≤ x) ++ have : x ≠ 0 := Nat.one_le_iff_ne_zero.mp hx ++ simp [this] ++ · have : ∀ᶠ n : ℕ in atTop, x ≤ n := by simpa using eventually_ge_atTop ⌈x⌉₊ ++ filter_upwards [this] with n hn ++ have e1 : 0 < (n : ℝ) := by linarith ++ have e2 : 1 ≤ n / x := (one_le_div hx).mpr hn ++ have e3 := Nat.le_succ n ++ gcongr ++ refine div_nonneg (Real.log_nonneg e2) (by norm_num [pi_nonneg]) ++ · apply summable_of_isBigO_nat summable_inv_mul_log_sq ++ apply (l2.mul l4).trans_eventuallyEq ++ apply eventually_of_mem (Ici_mem_atTop 2) ++ intro x (hx : 2 ≤ x) ++ have : (x : ℝ) ≠ 0 := by simp ; linarith ++ have : Real.log x ≠ 0 := by ++ have ll : 2 ≤ (x : ℝ) := by simp [hx] ++ simp ++ grind ++ field_simp ++ ++theorem limiting_fourier_lim1 (hcheby : cheby f) (ψ : W21) (hx : 0 < x) : ++ Tendsto (fun σ' : ℝ ↦ ++ ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x))) (𝓝[>] 1) ++ (𝓝 (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x)))) := by ++ ++ obtain ⟨C, hC⟩ := decay_bounds_cor ψ ++ have : 0 ≤ C := by simpa using (norm_nonneg _).trans (hC 0) ++ refine tendsto_tsum_of_dominated_convergence ++ (limiting_fourier_lim1_aux hcheby hx C this) (fun n => ?_) ?_ ++ · apply Tendsto.mul_const ++ by_cases h : n = 0 <;> simp only [term, h, ↓reduceIte, CharP.cast_eq_zero, div_zero, ++ tendsto_const_nhds_iff] ++ refine tendsto_const_nhds.div ?_ (by simp [h]) ++ simpa using ((continuous_ofReal.tendsto 1).mono_left nhdsWithin_le_nhds).const_cpow ++ · rw [eventually_nhdsWithin_iff] ++ apply Eventually.of_forall ++ intro σ' (hσ' : 1 < σ') n ++ rw [norm_mul, ← nterm_eq_norm_term] ++ refine mul_le_mul ?_ (hC _) (norm_nonneg _) (div_nonneg (norm_nonneg _) (Nat.cast_nonneg _)) ++ by_cases h : n = 0 <;> simp only [nterm, h, ↓reduceIte, CharP.cast_eq_zero, div_zero, le_refl] ++ have : 1 ≤ (n : ℝ) := by simpa using! Nat.pos_iff_ne_zero.mpr h ++ refine div_le_div₀ (norm_nonneg _) le_rfl (by simpa [Nat.pos_iff_ne_zero]) ?_ ++ simpa using Real.rpow_le_rpow_of_exponent_le this hσ'.le ++ ++theorem limiting_fourier_lim2_aux (x : ℝ) (C : ℝ) : ++ Integrable (fun t ↦ max |x| 1 * (C / (1 + (t / (2 * π)) ^ 2))) ++ (Measure.restrict volume (Ici (-Real.log x))) := by ++ simp_rw [div_eq_mul_inv C] ++ exact (((integrable_inv_one_add_sq.comp_div ++ (by simp [pi_ne_zero])).const_mul _).const_mul _).restrict ++ ++theorem limiting_fourier_lim2 (A : ℝ) (ψ : W21) (hx : 1 ≤ x) : ++ Tendsto (fun σ' ↦ A * ↑(x ^ (1 - σ')) * ++ ∫ u in Ici (-Real.log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) ++ (𝓝[>] 1) (𝓝 (A * ∫ u in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)))) := by ++ ++ obtain ⟨C, hC⟩ := decay_bounds_cor ψ ++ apply Tendsto.mul ++ · suffices h : Tendsto (fun σ' : ℝ ↦ ofReal (x ^ (1 - σ'))) (𝓝[>] 1) (𝓝 1) by ++ simpa using h.const_mul ↑A ++ suffices h : Tendsto (fun σ' : ℝ ↦ x ^ (1 - σ')) (𝓝[>] 1) (𝓝 1) from ++ (continuous_ofReal.tendsto 1).comp h ++ have : Tendsto (fun σ' : ℝ ↦ σ') (𝓝 1) (𝓝 1) := fun _ a ↦ a ++ have : Tendsto (fun σ' : ℝ ↦ 1 - σ') (𝓝[>] 1) (𝓝 0) := ++ tendsto_nhdsWithin_of_tendsto_nhds (by simpa using this.const_sub 1) ++ simpa using tendsto_const_nhds.rpow this (Or.inl (zero_lt_one.trans_le hx).ne.symm) ++ · refine tendsto_integral_filter_of_dominated_convergence _ ?_ ?_ ++ (limiting_fourier_lim2_aux x C) ?_ ++ · apply Eventually.of_forall ; intro σ' ++ apply Continuous.aestronglyMeasurable ++ have := continuous_FourierIntegral ψ ++ continuity ++ · apply eventually_of_mem (U := Ioo 1 2) ++ · apply Ioo_mem_nhdsGT_of_mem ; simp ++ · intro σ' ⟨h1, h2⟩ ++ rw [ae_restrict_iff' measurableSet_Ici] ++ apply Eventually.of_forall ++ intro t (ht : - Real.log x ≤ t) ++ rw [norm_mul] ++ have hdom_nonneg : 0 ≤ max |x| 1 := by ++ exact (abs_nonneg x).trans (le_max_left _ _) ++ refine mul_le_mul ?_ (hC _) (norm_nonneg _) hdom_nonneg ++ simp only [neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_sub, ofReal_one, norm_exp, ++ neg_re, mul_re, ofReal_re, sub_re, one_re, ofReal_im, sub_im, one_im, sub_self, mul_zero, ++ sub_zero] ++ have : -Real.log x * (σ' - 1) ≤ t * (σ' - 1) := mul_le_mul_of_nonneg_right ht (by linarith) ++ have : -(t * (σ' - 1)) ≤ Real.log x * (σ' - 1) := by simpa using neg_le_neg this ++ have := Real.exp_monotone this ++ apply this.trans ++ have l1 : σ' - 1 ≤ 1 := by linarith ++ have : 0 ≤ Real.log x := Real.log_nonneg hx ++ have := mul_le_mul_of_nonneg_left l1 this ++ refine (Real.exp_monotone this).trans ?_ ++ have hxabs : |x| = x := abs_of_nonneg (zero_le_one.trans hx) ++ calc ++ Real.exp (Real.log x * 1) = |x| := by ++ simpa [mul_one, hxabs] using (Real.exp_log (zero_lt_one.trans_le hx)) ++ _ ≤ max |x| 1 := le_max_left _ _ ++ · apply Eventually.of_forall ++ intro x ++ suffices h : Tendsto (fun n ↦ ((rexp (-x * (n - 1))) : ℂ)) (𝓝[>] 1) (𝓝 1) by ++ simpa using h.mul_const _ ++ apply Tendsto.mono_left ?_ nhdsWithin_le_nhds ++ suffices h : Continuous (fun n ↦ ((rexp (-x * (n - 1))) : ℂ)) by simpa using h.tendsto 1 ++ continuity ++ ++theorem limiting_fourier_lim3 (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : ++ Tendsto (fun σ' : ℝ ↦ ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I)) (𝓝[>] 1) ++ (𝓝 (∫ t : ℝ, G (1 + t * I) * ψ t * x ^ (t * I))) := by ++ ++ by_cases hh : tsupport ψ = ∅ ++ · simp [tsupport_eq_empty_iff.mp hh] ++ obtain ⟨a₀, ha₀⟩ := Set.nonempty_iff_ne_empty.mpr hh ++ ++ let S : Set ℂ := reProdIm (Icc 1 2) (tsupport ψ) ++ have l1 : IsCompact S := by ++ refine Metric.isCompact_iff_isClosed_bounded.mpr ⟨?_, ?_⟩ ++ · exact isClosed_Icc.reProdIm (isClosed_tsupport ψ) ++ · exact (Metric.isBounded_Icc 1 2).reProdIm ψ.h2.isBounded ++ have l2 : S ⊆ {s : ℂ | 1 ≤ s.re} := fun z hz => (mem_reProdIm.mp hz).1.1 ++ have l3 : ContinuousOn (‖G ·‖) S := (hG.mono l2).norm ++ have l4 : S.Nonempty := ⟨1 + a₀ * I, by simp [S, mem_reProdIm, ha₀]⟩ ++ obtain ⟨z, -, hmax⟩ := l1.exists_isMaxOn l4 l3 ++ let MG := ‖G z‖ ++ let bound (a : ℝ) : ℝ := MG * ‖ψ a‖ ++ ++ apply tendsto_integral_filter_of_dominated_convergence (bound := bound) ++ · apply eventually_of_mem (U := Icc 1 2) (Icc_mem_nhdsGT_of_mem (by simp)) ; intro u hu ++ apply Continuous.aestronglyMeasurable ++ apply Continuous.mul ++ · exact (hG.comp_continuous (by fun_prop) (by simp [hu.1])).mul ψ.h1.continuous ++ · apply Continuous.const_cpow (by fun_prop) ; simp ; linarith ++ · apply eventually_of_mem (U := Icc 1 2) (Icc_mem_nhdsGT_of_mem (by simp)) ++ intro u hu ++ apply Eventually.of_forall ; intro v ++ by_cases h : v ∈ tsupport ψ ++ · have r1 : u + v * I ∈ S := by simp [S, mem_reProdIm, hu.1, hu.2, h] ++ have r2 := isMaxOn_iff.mp hmax _ r1 ++ have r4 : (x : ℂ) ≠ 0 := by simp ; linarith ++ have r5 : arg x = 0 := by simp [arg_eq_zero_iff] ; linarith ++ have r3 : ‖(x : ℂ) ^ (v * I)‖ = 1 := by simp [norm_cpow_of_ne_zero r4, r5] ++ simp_rw [norm_mul, r3, mul_one] ++ exact mul_le_mul_of_nonneg_right r2 (norm_nonneg _) ++ · have : v ∉ Function.support ψ := fun a ↦ h (subset_tsupport ψ a) ++ simp at this ; simp [this, bound] ++ ++ · suffices h : Continuous bound by exact h.integrable_of_hasCompactSupport ψ.h2.norm.mul_left ++ have := ψ.h1.continuous ; fun_prop ++ · apply Eventually.of_forall ; intro t ++ apply Tendsto.mul_const ++ apply Tendsto.mul_const ++ refine (hG (1 + t * I) (by simp)).tendsto.comp <| tendsto_nhdsWithin_iff.mpr ⟨?_, ?_⟩ ++ · exact ((continuous_ofReal.tendsto _).add tendsto_const_nhds).mono_left nhdsWithin_le_nhds ++ · exact eventually_nhdsWithin_of_forall (fun x (hx : 1 < x) => by simp [hx.le]) ++ ++lemma limiting_fourier (hcheby : cheby f) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : ++ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ ∫ (t : ℝ), (G (1 + t * I)) * (ψ t) * x ^ (t * I) := by ++ ++ have l1 := limiting_fourier_lim1 hcheby ψ (by linarith) ++ have l2 := limiting_fourier_lim2 A ψ hx ++ have l3 := limiting_fourier_lim3 hG ψ hx ++ apply tendsto_nhds_unique_of_eventuallyEq (l1.sub l2) l3 ++ simpa [eventuallyEq_nhdsWithin_iff] using! Eventually.of_forall (limiting_fourier_aux hG' hf ψ hx) ++ ++lemma limiting_cor_aux {f : ℝ → ℂ} : Tendsto (fun x : ℝ ↦ ∫ t, f t * x ^ (t * I)) atTop (𝓝 0) := by ++ ++ have l1 : ∀ᶠ x : ℝ in atTop, ∀ t : ℝ, x ^ (t * I) = exp (log x * t * I) := by ++ filter_upwards [eventually_ne_atTop 0, eventually_ge_atTop 0] with x hx hx' t ++ rw [Complex.cpow_def_of_ne_zero (ofReal_ne_zero.mpr hx), ofReal_log hx'] ; ring_nf ++ ++ have l2 : ∀ᶠ x : ℝ in atTop, ∫ t, f t * x ^ (t * I) = ∫ t, f t * exp (log x * t * I) := by ++ filter_upwards [l1] with x hx ++ refine integral_congr_ae (Eventually.of_forall (fun x => by simp [hx])) ++ ++ simp_rw [tendsto_congr' l2] ++ have hFourier (x : ℝ) : (∫ t, f t * exp (log x * t * I)) = ++ 𝓕 f (-Real.log x / (2 * π)) := by ++ rw [Real.fourier_real_eq_integral_exp_smul] ++ apply integral_congr_ae ++ filter_upwards [] with t ++ rw [smul_eq_mul, mul_comm _ (f t)] ++ congr 1 ++ congr 1 ++ push_cast ++ field_simp ++ simp_rw [hFourier] ++ refine (Real.zero_at_infty_fourier f).comp <| Tendsto.mono_right ?_ _root_.atBot_le_cocompact ++ exact (tendsto_neg_atBot_iff.mpr tendsto_log_atTop).atBot_mul_const (inv_pos.mpr two_pi_pos) ++ ++lemma limiting_cor (ψ : CS 2 ℂ) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hcheby : cheby f) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by ++ ++ apply limiting_cor_aux.congr' ++ filter_upwards [eventually_ge_atTop 1] with x hx using ++ limiting_fourier hcheby hG hG' hf ψ hx |>.symm ++ ++lemma smooth_urysohn (a b c d : ℝ) (h1 : a < b) (h3 : c < d) : ∃ Ψ : ℝ → ℝ, ++ (ContDiff ℝ ∞ Ψ) ∧ (HasCompactSupport Ψ) ∧ ++ Set.indicator (Set.Icc b c) 1 ≤ Ψ ∧ Ψ ≤ Set.indicator (Set.Ioo a d) 1 := by ++ ++ obtain ⟨ψ, l1, l2, l3, l4, -⟩ := smooth_urysohn_support_Ioo h1 h3 ++ refine ⟨ψ, l1, l2, l3, l4⟩ ++ ++noncomputable def exists_trunc : trunc := by ++ choose ψ h1 h2 h3 h4 using smooth_urysohn (-2) (-1) (1) (2) (by linarith) (by linarith) ++ exact ⟨⟨ψ, h1.of_le (by norm_cast), h2⟩, h3, h4⟩ ++ ++lemma one_div_sub_one (n : ℕ) : 1 / (↑(n - 1) : ℝ) ≤ 2 / n := by ++ match n with ++ | 0 => simp ++ | 1 => simp ++ | n + 2 => { norm_cast ; rw [div_le_div_iff₀] <;> simp [mul_add] <;> linarith } ++ ++lemma quadratic_pos (a b c x : ℝ) (ha : 0 < a) (hΔ : discrim a b c < 0) : ++ 0 < a * x ^ 2 + b * x + c := by ++ have l1 : a * x ^ 2 + b * x + c = a * (x + b / (2 * a)) ^ 2 - discrim a b c / (4 * a) := by ++ simp only [discrim]; field_simp; ring ++ have l2 : 0 < - discrim a b c := by linarith ++ rw [l1, sub_eq_add_neg, ← neg_div] ; positivity ++ ++noncomputable def pp (a x : ℝ) : ℝ := a ^ 2 * (x + 1) ^ 2 + (1 - a) * (1 + a) ++ ++noncomputable def pp' (a x : ℝ) : ℝ := a ^ 2 * (2 * (x + 1)) ++ ++lemma pp_pos {a : ℝ} (ha : a ∈ Ioo (-1) 1) (x : ℝ) : 0 < pp a x := by ++ simp only [pp] ++ have : 0 < 1 - a := by linarith [ha.2] ++ have : 0 < 1 + a := by linarith [ha.1] ++ positivity ++ ++lemma pp_deriv (a x : ℝ) : HasDerivAt (pp a) (pp' a x) x := by ++ unfold pp pp' ++ simpa using hasDerivAt_id x |>.add_const 1 |>.pow 2 |>.const_mul _ ++ ++lemma pp_deriv_eq (a : ℝ) : deriv (pp a) = pp' a := by ++ ext x ; exact pp_deriv a x |>.deriv ++ ++lemma pp'_deriv (a x : ℝ) : HasDerivAt (pp' a) (a ^ 2 * 2) x := by ++ simpa using! hasDerivAt_id x |>.add_const 1 |>.const_mul 2 |>.const_mul (a ^ 2) ++ ++lemma pp'_deriv_eq (a : ℝ) : deriv (pp' a) = fun _ => a ^ 2 * 2 := by ++ ext x ; exact pp'_deriv a x |>.deriv ++ ++noncomputable def hh (a t : ℝ) : ℝ := (t * (1 + (a * log t) ^ 2))⁻¹ ++ ++noncomputable def hh' (a t : ℝ) : ℝ := - pp a (log t) * hh a t ^ 2 ++ ++lemma hh_nonneg (a : ℝ) {t : ℝ} (ht : 0 ≤ t) : 0 ≤ hh a t := by dsimp only [hh] ; positivity ++ ++lemma hh_le (a t : ℝ) (ht : 0 ≤ t) : |hh a t| ≤ t⁻¹ := by ++ by_cases h0 : t = 0 ++ · simp [hh, h0] ++ replace ht : 0 < t := lt_of_le_of_ne ht (by tauto) ++ unfold hh ++ rw [abs_inv, inv_le_inv₀ (by positivity) ht, abs_mul, abs_eq_self.mpr ht.le] ++ convert_to! t * 1 ≤ _ ++ · simp ++ apply mul_le_mul le_rfl ?_ zero_le_one ht.le ++ rw [abs_eq_self.mpr (by positivity)] ++ simp only [le_add_iff_nonneg_right] ++ positivity ++ ++lemma hh_deriv (a : ℝ) {t : ℝ} (ht : t ≠ 0) : HasDerivAt (hh a) (hh' a t) t := by ++ have e1 : t * (1 + (a * log t) ^ 2) ≠ 0 := mul_ne_zero ht (_root_.ne_of_lt (by positivity)).symm ++ have l5 : HasDerivAt (fun t : ℝ => log t) t⁻¹ t := Real.hasDerivAt_log ht ++ have l4 : HasDerivAt (fun t : ℝ => a * log t) (a * t⁻¹) t := l5.const_mul _ ++ have l3 : HasDerivAt (fun t : ℝ => (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := by ++ convert! l4.pow 2 using 1 ; ring ++ have l2 : HasDerivAt (fun t : ℝ => 1 + (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := ++ l3.const_add _ ++ have l1 : HasDerivAt (fun t : ℝ => t * (1 + (a * log t) ^ 2)) ++ (1 + 2 * a ^ 2 * log t + a ^ 2 * log t ^ 2) t := by ++ convert! (hasDerivAt_id' t).mul l2 using 1; field_simp; ring ++ convert! l1.inv e1 using 1; simp only [hh', pp, hh]; field_simp; ring ++ ++lemma hh_continuous (a : ℝ) : ContinuousOn (hh a) (Ioi 0) := ++ fun t (ht : 0 < t) => (hh_deriv a ht.ne.symm).continuousAt.continuousWithinAt ++ ++lemma hh'_nonpos {a x : ℝ} (ha : a ∈ Ioo (-1) 1) : hh' a x ≤ 0 := by ++ have := pp_pos ha (log x) ++ simp only [hh', neg_mul, Left.neg_nonpos_iff, ge_iff_le] ++ positivity ++ ++lemma hh_antitone {a : ℝ} (ha : a ∈ Ioo (-1) 1) : AntitoneOn (hh a) (Ioi 0) := by ++ have l1 x (hx : x ∈ interior (Ioi 0)) : ++ HasDerivWithinAt (hh a) (hh' a x) (interior (Ioi 0)) x := by ++ have : x ≠ 0 := by contrapose! hx ; simp [hx] ++ exact (hh_deriv a this).hasDerivWithinAt ++ apply antitoneOn_of_hasDerivWithinAt_nonpos (convex_Ioi _) (hh_continuous _) l1 ++ (fun x _ => hh'_nonpos ha) ++ ++noncomputable def gg (x i : ℝ) : ℝ := 1 / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ++ ++lemma gg_of_hh {x : ℝ} (hx : x ≠ 0) (i : ℝ) : gg x i = x⁻¹ * hh (1 / (2 * π)) (i / x) := by ++ simp only [gg, hh] ++ field_simp ++ ++lemma gg_l1 {x : ℝ} (hx : 0 < x) (n : ℕ) : |gg x n| ≤ 1 / n := by ++ simp only [gg_of_hh hx.ne.symm, one_div, mul_inv_rev, abs_mul] ++ apply mul_le_mul le_rfl (hh_le _ _ (by positivity)) (by positivity) (by positivity) |>.trans ++ (le_of_eq ?_) ++ simp [abs_inv, abs_eq_self.mpr hx.le] ; field_simp ++ ++lemma gg_le_one (i : ℕ) : gg x i ≤ 1 := by ++ by_cases hi : i = 0 <;> simp only [gg, hi, CharP.cast_eq_zero, div_zero, one_div, mul_inv_rev, ++ zero_div, Real.log_zero, mul_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, ++ add_zero, inv_one, mul_one, zero_le_one] ++ have l1 : 1 ≤ (i : ℝ) := by simp ; omega ++ have l2 : 1 ≤ 1 + (π⁻¹ * 2⁻¹ * Real.log (↑i / x)) ^ 2 := by ++ simp only [le_add_iff_nonneg_right] ; positivity ++ rw [← mul_inv] ; apply inv_le_one_of_one_le₀ ; simpa using mul_le_mul l1 l2 zero_le_one (by simp) ++ ++lemma one_div_two_pi_mem_Ioo : 1 / (2 * π) ∈ Ioo (-1) 1 := by ++ constructor ++ · trans 0 ++ · linarith ++ · positivity ++ · rw [div_lt_iff₀ (by positivity)] ++ convert_to! 1 * 1 < 2 * π ++ · simp ++ · simp ++ apply mul_lt_mul one_lt_two ?_ zero_lt_one zero_le_two ++ trans 2 ++ · exact one_le_two ++ · exact two_le_pi ++ ++lemma sum_telescopic (a : ℕ → ℝ) (n : ℕ) : ∑ i ∈ Finset.range n, (a (i + 1) - a i) = a n - a 0 := by ++ apply Finset.sum_range_sub ++ ++lemma cancel_aux {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ ∑ i ∈ Finset.range n, f i * g i ≤ g (n - 1) * (C * n) + (C * (↑(n - 1 - 1) + 1) * g 0 ++ - C * (↑(n - 1 - 1) + 1) * g (n - 1) - ++ ((n - 1 - 1) • (C * g 0) - ∑ x ∈ Finset.range (n - 1 - 1), C * g (x + 1))) := by ++ ++ have l1 (n : ℕ) : ++ (g n - g (n + 1)) * ∑ i ∈ Finset.range (n + 1), f i ≤ (g n - g (n + 1)) * (C * (n + 1)) := by ++ apply mul_le_mul le_rfl (by simpa using! hf' (n + 1)) ++ (Finset.sum_nonneg (fun index _ => hf index)) ?_ ++ simp only [sub_nonneg] ; apply hg' ; simp ++ have l2 (x : ℕ) : C * (↑(x + 1) + 1) - C * (↑x + 1) = C := by simp ; ring ++ have l3 (n : ℕ) : 0 ≤ cumsum f n := Finset.sum_nonneg (fun index _ => hf index) ++ ++ convert_to ∑ i ∈ Finset.range n, (g i) • (f i) ≤ _ ++ · simp [mul_comm] ++ rw [Finset.sum_range_by_parts, sub_eq_add_neg, ← Finset.sum_neg_distrib] ++ simp_rw [← neg_smul, neg_sub, smul_eq_mul] ++ apply _root_.add_le_add ++ · exact mul_le_mul le_rfl (hf' n) (l3 n) (hg _) ++ · apply Finset.sum_le_sum (fun n _ => l1 n) |>.trans ++ convert_to! ∑ i ∈ Finset.range (n - 1), (C * (↑i + 1)) • (g i - g (i + 1)) ≤ _ ++ · congr ; ext i ; simp ; ring ++ rw [Finset.sum_range_by_parts] ++ simp_rw [Finset.sum_range_sub', l2, smul_sub, smul_eq_mul, Finset.sum_sub_distrib, ++ Finset.sum_const, Finset.card_range] ++ apply le_of_eq ; ring_nf ++ ++lemma sum_range_succ (a : ℕ → ℝ) (n : ℕ) : ++ ∑ i ∈ Finset.range n, a (i + 1) = (∑ i ∈ Finset.range (n + 1), a i) - a 0 := by ++ have := Finset.sum_range_sub a n ++ rw [Finset.sum_sub_distrib, sub_eq_iff_eq_add] at this ++ rw [Finset.sum_range_succ, this] ; ring ++ ++lemma cancel_aux' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ ∑ i ∈ Finset.range n, f i * g i ≤ ++ C * n * g (n - 1) ++ + C * cumsum g (n - 1 - 1 + 1) ++ - C * (↑(n - 1 - 1) + 1) * g (n - 1) ++ := by ++ have := cancel_aux hf hg hf' hg' n ++ simp only [nsmul_eq_mul, ← Finset.mul_sum, sum_range_succ] at this ++ convert this using 1 ; unfold cumsum ; ring ++ ++lemma cancel_main {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) (hn : 2 ≤ n) : ++ cumsum (f * g) n ≤ C * cumsum g n := by ++ convert! cancel_aux' hf hg hf' hg' n using 1 ++ match n with ++ | n + 2 => simp only [cumsum_succ] ; push_cast ; ring ++ ++lemma cancel_main' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hf0 : f 0 = 0) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ cumsum (f * g) n ≤ C * cumsum g n := by ++ match n with ++ | 0 => simp [cumsum] ++ | 1 => specialize hg 0 ; specialize hf' 1 ; simp only [cumsum, Finset.range_one, ++ Finset.sum_singleton, hf0, Nat.cast_one, mul_one, Pi.zero_apply, Pi.mul_apply, zero_mul, ++ ge_iff_le] at hf' hg ⊢ ; positivity ++ | n + 2 => convert! cancel_aux' hf hg hf' hg' (n + 2) using 1 ; simp [cumsum_succ] ; ring ++ ++theorem sum_le_integral {x₀ : ℝ} {f : ℝ → ℝ} {n : ℕ} (hf : AntitoneOn f (Ioc x₀ (x₀ + n))) ++ (hfi : IntegrableOn f (Icc x₀ (x₀ + n))) : ++ (∑ i ∈ Finset.range n, f (x₀ + ↑(i + 1))) ≤ ∫ x in x₀..x₀ + n, f x := by ++ ++ cases n with simp only [Nat.cast_add, Nat.cast_one, CharP.cast_eq_zero, add_zero, ++ lt_self_iff_false, not_false_eq_true, ++ Ioc_eq_empty, Finset.range_zero, Nat.cast_add, Nat.cast_one, Finset.sum_empty, ++ intervalIntegral.integral_same, le_refl] at hf ⊢ ++ | succ n => ++ have : Finset.range (n + 1) = {0} ∪ Finset.Ico 1 (n + 1) := by ++ ext i ; by_cases hi : i = 0 <;> simp [hi] ; omega ++ simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, ++ lt_add_iff_pos_left, add_pos_iff, zero_lt_one, or_true, and_true, not_false_eq_true, ++ Finset.sum_insert, CharP.cast_eq_zero, zero_add, ge_iff_le] ++ ++ have l4 : IntervalIntegrable f volume x₀ (x₀ + 1) := by ++ apply IntegrableOn.intervalIntegrable ++ simp only [le_add_iff_nonneg_right, zero_le_one, uIcc_of_le] ++ apply hfi.mono_set ++ apply Icc_subset_Icc le_rfl ++ simp ++ have l5 x (hx : x ∈ Ioc x₀ (x₀ + 1)) : (fun x ↦ f (x₀ + 1)) x ≤ f x := by ++ rcases hx with ⟨hx1, hx2⟩ ++ refine hf ⟨hx1, by linarith⟩ ⟨by linarith, by linarith⟩ hx2 ++ have l6 : ∫ x in x₀..x₀ + 1, f (x₀ + 1) = f (x₀ + 1) := by simp ++ ++ have l1 : f (x₀ + 1) ≤ ∫ x in x₀..x₀ + 1, f x := by ++ rw [← l6] ; apply intervalIntegral.integral_mono_ae_restrict (by linarith) (by simp) l4 ++ apply eventually_of_mem _ l5 ++ have : (Ioc x₀ (x₀ + 1))ᶜ ∩ Icc x₀ (x₀ + 1) = {x₀} := by simp [← sdiff_eq_compl_inter] ++ simp only [mem_ae_iff, Measure.restrict_apply measurableSet_Ioc.compl, this, ++ measure_singleton] ++ ++ have l2 : AntitoneOn (fun x ↦ f (x₀ + x)) (Icc 1 ↑(n + 1)) := by ++ intro u ⟨hu1, _⟩ v ⟨_, hv2⟩ huv ; push_cast at hv2 ++ refine hf ⟨?_, ?_⟩ ⟨?_, ?_⟩ ?_ <;> linarith ++ ++ have l3 := @AntitoneOn.sum_le_integral_Ico 1 (n + 1) (fun x => f (x₀ + x)) (by simp) ++ (by simpa using l2) ++ ++ simp only [Nat.cast_add, Nat.cast_one, intervalIntegral.integral_comp_add_left] at l3 ++ convert! _root_.add_le_add l1 l3 ++ ++ have := @intervalIntegral.integral_comp_mul_add ℝ _ _ 1 (n + 1) 1 f one_ne_zero x₀ ++ rw [intervalIntegral.integral_add_adjacent_intervals] ++ · exact l4 ++ · apply IntegrableOn.intervalIntegrable ++ simp only [add_le_add_iff_left, le_add_iff_nonneg_left, Nat.cast_nonneg, uIcc_of_le] ++ apply hfi.mono_set ++ apply Icc_subset_Icc ++ · linarith ++ · simp ++ ++lemma hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ (IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0)) ∧ ++ (∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π) := by ++ ++ rw [integrableOn_Ici_iff_integrableOn_Ioi] ++ simp only [hh] ++ ++ let g (x : ℝ) := (a * c / b) * Real.arctan (b * log (x / c)) ++ let g₀ (x : ℝ) := if x = 0 then ((a * c / b) * (- (π / 2))) else g x ++ let g' (x : ℝ) := a * (x / c * (1 + (b * Real.log (x / c)) ^ 2))⁻¹ ++ ++ have l3 (x) (hx : 0 < x) : HasDerivAt Real.log x⁻¹ x := by apply Real.hasDerivAt_log (by linarith) ++ have l4 (x) : HasDerivAt (fun t => t / c) (1 / c) x := (hasDerivAt_id x).div_const c ++ have l2 (x) (hx : 0 < x) : HasDerivAt (fun t => log (t / c)) x⁻¹ x := by ++ have := @HasDerivAt.comp _ _ _ _ _ _ (fun t => t / c) _ _ _ (l3 (x / c) (by positivity)) (l4 x) ++ convert! this using 1 ; field_simp ++ have l5 (x) (hx : 0 < x) := (l2 x hx).const_mul b ++ have l1 (x) (hx : 0 < x) := (l5 x hx).arctan ++ have l6 (x) (hx : 0 < x) : HasDerivAt g (g' x) x := by ++ convert! (l1 x hx).const_mul (a * c / b) using 1 ++ simp only [g'] ++ field_simp ++ have key (x) (hx : 0 < x) : HasDerivAt g₀ (g' x) x := by ++ apply (l6 x hx).congr_of_eventuallyEq ++ apply eventually_of_mem <| Ioi_mem_nhds hx ++ intro y (hy : 0 < y) ++ simp [g₀, hy.ne.symm] ++ ++ have k1 : Tendsto g₀ atTop (𝓝 ((a * c / b) * (π / 2))) := by ++ have : g =ᶠ[atTop] g₀ := by ++ apply eventually_of_mem (Ioi_mem_atTop 0) ++ intro y (hy : 0 < y) ++ simp [g₀, hy.ne.symm] ++ apply Tendsto.congr' this ++ apply Tendsto.const_mul ++ apply (tendsto_arctan_atTop.mono_right nhdsWithin_le_nhds).comp ++ apply Tendsto.const_mul_atTop hb ++ apply tendsto_log_atTop.comp ++ apply Tendsto.atTop_div_const hc ++ apply tendsto_id ++ ++ have k2 : Tendsto g₀ (𝓝[>] 0) (𝓝 (g₀ 0)) := by ++ have : g =ᶠ[𝓝[>] 0] g₀ := by ++ apply eventually_of_mem self_mem_nhdsWithin ++ intro x (hx : 0 < x) ; simp [g₀, hx.ne.symm] ++ simp only [g₀] ++ apply Tendsto.congr' this ++ apply Tendsto.const_mul ++ apply (tendsto_arctan_atBot.mono_right nhdsWithin_le_nhds).comp ++ apply Tendsto.const_mul_atBot hb ++ apply tendsto_log_nhdsGT_zero.comp ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨c * ε, by positivity, fun x hx1 hx2 => ⟨?_, ?_⟩⟩ ++ · simp only [mem_Ioi] at hx1 ⊢ ; positivity ++ · simp only [dist_zero_right, norm_eq_abs, norm_div, abs_eq_self.mpr hc.le] at hx2 ⊢ ++ rwa [div_lt_iff₀ hc, mul_comm] ++ ++ have k3 : ContinuousWithinAt g₀ (Ici 0) 0 := by ++ rw [Metric.continuousWithinAt_iff] ++ rw [Metric.tendsto_nhdsWithin_nhds] at k2 ++ intro epsilon hepsilon ++ obtain ⟨delta, hdelta, hbound⟩ := k2 epsilon hepsilon ++ refine ⟨delta, hdelta, ?_⟩ ++ intro point hpoint hdist ++ change 0 ≤ point at hpoint ++ rcases lt_or_eq_of_le hpoint with hpositive | hzero ++ · exact hbound hpositive hdist ++ · simp [g₀, hzero.symm, hepsilon] ++ ++ have k4 : ∀ x ∈ Ioi 0, 0 ≤ g' x := by ++ intro x (hx : 0 < x) ; simp only [mul_inv_rev, inv_div, g'] ; positivity ++ ++ constructor ++ · convert_to IntegrableOn g' _ ++ exact integrableOn_Ioi_deriv_of_nonneg k3 key k4 k1 ++ · have := integral_Ioi_of_hasDerivAt_of_nonneg k3 key k4 k1 ++ simp only [mul_inv_rev, inv_div, mul_neg, ↓reduceIte, sub_neg_eq_add, g', g₀] at this ⊢ ++ convert this using 1 ; field_simp ; ring ++ ++lemma hh_integrable (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0) := ++ hh_integrable_aux ha hb hc |>.1 ++ ++lemma hh_integral (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ ∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π := ++ hh_integrable_aux ha hb hc |>.2 ++ ++lemma hh_integral' : ∫ t in Ioi 0, hh (1 / (2 * π)) t = 2 * π ^ 2 := by ++ have := hh_integral (a := 1) (b := 1 / (2 * π)) (c := 1) ++ (by positivity) (by positivity) (by positivity) ++ convert this using 1 <;> simp ; ring ++ ++lemma bound_sum_log {C : ℝ} (hf0 : f 0 = 0) (hf : chebyWith C f) {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ ++ C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by ++ ++ let ggg (i : ℕ) : ℝ := if i = 0 then 1 else gg x i ++ ++ have l0 : x ≠ 0 := by linarith ++ have l1 i : 0 ≤ ggg i := by by_cases hi : i = 0 <;> simp only [gg, one_div, mul_inv_rev, hi, ++ ↓reduceIte, zero_le_one, ggg] ; positivity ++ have l2 : Antitone ggg := by ++ intro i j hij ; by_cases hi : i = 0 <;> by_cases hj : j = 0 <;> simp only [hj, ↓reduceIte, hi, ++ le_refl, ggg] ++ · exact gg_le_one _ ++ · omega ++ · simp only [gg_of_hh l0] ++ gcongr ++ apply hh_antitone one_div_two_pi_mem_Ioo ++ · simp only [mem_Ioi] ; positivity ++ · simp only [mem_Ioi] ; positivity ++ · gcongr ++ have l3 : 0 ≤ C := by simpa [cumsum, hf0] using hf 1 ++ ++ have l4 : 0 ≤ ∫ (t : ℝ) in Ioi 0, hh (π⁻¹ * 2⁻¹) t := ++ setIntegral_nonneg measurableSet_Ioi (fun x hx => hh_nonneg _ (LT.lt.le hx)) ++ ++ have l5 {n : ℕ} : AntitoneOn (fun t ↦ x⁻¹ * hh (1 / (2 * π)) (t / x)) (Ioc 0 n) := by ++ intro u ⟨hu1, _⟩ v ⟨hv1, _⟩ huv ++ simp only ++ apply mul_le_mul le_rfl ?_ (hh_nonneg _ (by positivity)) (by positivity) ++ apply hh_antitone one_div_two_pi_mem_Ioo (by simp only [mem_Ioi] ; positivity) ++ (by simp only [mem_Ioi] ; positivity) ++ apply (div_le_div_iff_of_pos_right (by positivity)).mpr huv ++ ++ have l6 {n : ℕ} : IntegrableOn (fun t ↦ x⁻¹ * hh (π⁻¹ * 2⁻¹) (t / x)) (Icc 0 n) volume := by ++ apply IntegrableOn.mono_set ++ (hh_integrable (by positivity) (by positivity) (by positivity)) Icc_subset_Ici_self ++ ++ apply Real.tsum_le_of_sum_range_le (fun n => by positivity) ; intro n ++ convert_to! ∑ i ∈ Finset.range n, ‖f i‖ * ggg i ≤ _ ++ · congr ; ext i ++ by_cases hi : i = 0 ++ · simp [hi, hf0] ++ · simp only [gg, hi, ↓reduceIte, ggg] ++ field_simp ++ ++ apply cancel_main' (fun _ => norm_nonneg _) (by simp [hf0]) l1 hf l2 n |>.trans ++ gcongr ; simp only [cumsum, gg_of_hh l0, one_div, mul_inv_rev, ggg] ++ ++ by_cases hn : n = 0 ++ · simp only [hn, Finset.range_zero, Finset.sum_empty] ; positivity ++ replace hn : 0 < n := by omega ++ have : Finset.range n = {0} ∪ Finset.Ico 1 n := by ++ ext i ; simp ; by_cases hi : i = 0 <;> simp [hi, hn] ; omega ++ simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, ++ false_and, not_false_eq_true, Finset.sum_insert, ↓reduceIte, add_le_add_iff_left, ge_iff_le] ++ convert_to! ∑ x_1 ∈ Finset.Ico 1 n, x⁻¹ * hh (π⁻¹ * 2⁻¹) (↑x_1 / x) ≤ _ ++ · apply Finset.sum_congr rfl (fun i hi => ?_) ++ simp at hi ++ have : i ≠ 0 := by omega ++ simp [this] ++ simp_rw [Finset.sum_Ico_eq_sum_range, add_comm 1] ++ have := @sum_le_integral 0 (fun t => x⁻¹ * hh (π⁻¹ * 2⁻¹) (t / x)) (n - 1) ++ (by simpa using l5) (by simpa using l6) ++ simp only [zero_add] at this ++ apply this.trans ++ rw [@intervalIntegral.integral_comp_div ℝ _ _ 0 ↑(n - 1) x (fun t => x⁻¹ * hh (π⁻¹ * 2⁻¹) (t)) l0] ++ simp only [zero_div, intervalIntegral.integral_const_mul, smul_eq_mul, ← mul_assoc, ++ mul_inv_cancel₀ l0, one_mul] ++ have : (0 : ℝ) ≤ ↑(n - 1) / x := by positivity ++ rw [intervalIntegral.intervalIntegral_eq_integral_uIoc] ++ simp only [this, ↓reduceIte, uIoc_of_le, smul_eq_mul, one_mul, ge_iff_le] ++ apply integral_mono_measure ++ · apply Measure.restrict_mono Ioc_subset_Ioi_self le_rfl ++ · apply eventually_of_mem (self_mem_ae_restrict measurableSet_Ioi) ++ intro x (hx : 0 < x) ++ apply hh_nonneg _ hx.le ++ · have := (@hh_integrable 1 (1 / (2 * π)) 1 (by positivity) (by positivity) (by positivity)) ++ simpa using! this.mono_set Ioi_subset_Ici_self ++ ++lemma bound_sum_log0 {C : ℝ} (hf : chebyWith C f) {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ ++ C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by ++ ++ let f0 i := if i = 0 then 0 else f i ++ have l1 : chebyWith C f0 := by ++ intro n ; refine Finset.sum_le_sum (fun i _ => ?_) |>.trans (hf n) ++ by_cases hi : i = 0 <;> simp [hi, f0] ++ have l2 i : ‖f i‖ / i = ‖f0 i‖ / i := by by_cases hi : i = 0 <;> simp [hi, f0] ++ simp_rw [l2] ; apply bound_sum_log rfl l1 hx ++ ++lemma bound_sum_log' {C : ℝ} (hf : chebyWith C f) {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ C * (1 + 2 * π ^ 2) := by ++ simpa only [hh_integral'] using bound_sum_log0 hf hx ++ ++variable (f x) in ++lemma summable_fourier_aux (ψ : W21) (i : ℕ) : ++ ‖f i / i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (i / x))‖ ≤ ++ W21.norm ψ * (‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹) := by ++ convert! mul_le_mul_of_nonneg_left (decay_bounds_key ψ (1 / (2 * π) * log (i / x))) ++ (norm_nonneg (f i / i)) using 1 ++ · simp ++ · change _ = _ * (W21.norm ψ * _) ++ simp only [W21.norm, mul_inv_rev, one_div, Complex.norm_div, RCLike.norm_natCast] ++ ring ++ ++lemma summable_fourier (x : ℝ) (hx : 0 < x) (ψ : W21) (hcheby : cheby f) : ++ Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by ++ have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by ++ simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) ++ have l6 := summable_fourier_aux x f ψ ++ exact Summable.of_nonneg_of_le (fun _ => norm_nonneg _) l6 ++ (by simpa using l5.const_smul (W21.norm ψ)) ++ ++lemma bound_I1 (x : ℝ) (hx : 0 < x) (ψ : W21) (hcheby : cheby f) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ ++ W21.norm ψ • ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ := by ++ ++ have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by ++ simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) ++ have l6 := summable_fourier_aux x f ψ ++ have l1 : Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by ++ exact summable_fourier x hx ψ hcheby ++ apply (norm_tsum_le_tsum_norm l1).trans ++ simpa only [← Summable.tsum_const_smul _ l5] using! ++ Summable.tsum_mono l1 (by simpa using l5.const_smul (W21.norm ψ)) l6 ++ ++lemma bound_I1' {C : ℝ} (x : ℝ) (hx : 1 ≤ x) (ψ : W21) (hcheby : chebyWith C f) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ ++ W21.norm ψ * C * (1 + 2 * π ^ 2) := by ++ ++ apply bound_I1 x (by linarith) ψ ⟨_, hcheby⟩ |>.trans ++ rw [smul_eq_mul, mul_assoc] ++ apply mul_le_mul le_rfl (bound_sum_log' hcheby hx) ?_ W21.norm_nonneg ++ apply tsum_nonneg (fun i => by positivity) ++ ++lemma bound_I2 (x : ℝ) (ψ : W21) : ++ ‖∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ W21.norm ψ * (2 * π ^ 2) := by ++ ++ have key a : ‖𝓕 (ψ : ℝ → ℂ) (a / (2 * π))‖ ≤ W21.norm ψ * (1 + (a / (2 * π)) ^ 2)⁻¹ := ++ decay_bounds_key ψ _ ++ have twopi : 0 ≤ 2 * π := by simp [pi_nonneg] ++ have l3 : Integrable (fun a ↦ (1 + (a / (2 * π)) ^ 2)⁻¹) := ++ integrable_inv_one_add_sq.comp_div (by norm_num [pi_ne_zero]) ++ have l2 : IntegrableOn (fun i ↦ W21.norm ψ * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-Real.log x)) := by ++ exact (l3.const_mul _).integrableOn ++ have l1 : IntegrableOn (fun i ↦ ‖𝓕 (ψ : ℝ → ℂ) (i / (2 * π))‖) (Ici (-Real.log x)) := by ++ refine ((l3.const_mul (W21.norm ψ)).mono' ?_ ?_).integrableOn ++ · apply Continuous.aestronglyMeasurable ; fun_prop ++ · simp only [norm_norm, key] ; simp ++ have l5 : 0 ≤ᵐ[volume] fun a ↦ (1 + (a / (2 * π)) ^ 2)⁻¹ := by ++ apply Eventually.of_forall ; intro x ; positivity ++ refine (norm_integral_le_integral_norm _).trans <| (setIntegral_mono l1 l2 key).trans ?_ ++ rw [integral_const_mul] ; gcongr ++ · apply W21.norm_nonneg ++ refine (setIntegral_le_integral l3 l5).trans ?_ ++ rw [Measure.integral_comp_div (fun x => (1 + x ^ 2)⁻¹) (2 * π)] ++ simp [abs_eq_self.mpr twopi] ; ring_nf ; rfl ++ ++lemma bound_main {C : ℝ} (A : ℂ) (x : ℝ) (hx : 1 ≤ x) (ψ : W21) ++ (hcheby : chebyWith C f) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ ++ W21.norm ψ * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2)) := by ++ ++ have l1 := bound_I1' x hx ψ hcheby ++ have l2 := mul_le_mul (le_refl ‖A‖) (bound_I2 x ψ) (by positivity) (by positivity) ++ apply norm_sub_le _ _ |>.trans ; rw [norm_mul] ++ convert _root_.add_le_add l1 l2 using 1 ; ring ++ ++lemma limiting_cor_W21 (ψ : W21) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by ++ ++ let S1 x (ψ : ℝ → ℂ) := ∑' (n : ℕ), f n / ↑n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑n / x)) ++ let S2 x (ψ : ℝ → ℂ) := ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) ++ let S x ψ := S1 x ψ - S2 x ψ ; change Tendsto (fun x ↦ S x ψ) atTop (𝓝 0) ++ ++ obtain g := exists_trunc ++ let Ψ R := g.scale R * ψ ++ have key R : Tendsto (fun x ↦ S x (Ψ R)) atTop (𝓝 0) := limiting_cor (Ψ R) hf hcheby hG hG' ++ ++ obtain ⟨C, hcheby⟩ := hcheby ++ have hC : 0 ≤ C := by ++ have : ‖f 0‖ ≤ C := by simpa [cumsum] using hcheby 1 ++ have : 0 ≤ ‖f 0‖ := by positivity ++ linarith ++ have key2 : Tendsto (fun R ↦ W21.norm (ψ - Ψ R)) atTop (𝓝 0) := W21_approximation ψ g ++ simp_rw [Metric.tendsto_nhds] at key key2 ⊢ ; intro ε hε ++ let M := C * (1 + 2 * π ^ 2) + ‖(A : ℂ)‖ * (2 * π ^ 2) ++ obtain ⟨R, hRψ⟩ := (key2 ((ε / 2) / (1 + M)) (by positivity)).exists ++ simp only [dist_zero_right, Real.norm_eq_abs, abs_eq_self.mpr W21.norm_nonneg] at hRψ key ++ ++ filter_upwards [eventually_ge_atTop 1, key R (ε / 2) (by positivity)] with x hx key ++ ++ have key3 : ‖S x (ψ - Ψ R)‖ < ε / 2 := by ++ have : ‖S x _‖ ≤ _ * M := @bound_main f C A x hx (ψ - Ψ R) hcheby ++ apply this.trans_lt ++ apply (mul_le_mul (d := 1 + M) le_rfl (by simp) (by positivity) W21.norm_nonneg).trans_lt ++ have : 0 < 1 + M := by positivity ++ convert! (mul_lt_mul_iff_left₀ this).mpr hRψ using 1 ; field_simp ++ ++ have S1_sub_1 x : 𝓕 (⇑ψ - ⇑(Ψ R)) x = 𝓕 (ψ : ℝ → ℂ) x - 𝓕 ⇑(Ψ R) x := by ++ have l1 : AEStronglyMeasurable (fun x_1 : ℝ ↦ cexp (-(2 * ↑π * (↑x_1 * ↑x) * I))) volume := by ++ refine (Continuous.mul ?_ continuous_const).neg.cexp.aestronglyMeasurable ++ apply continuous_const.mul <| contDiff_ofReal.continuous.mul continuous_const ++ simp only [Real.fourier_eq', neg_mul, RCLike.inner_apply', conj_trivial, ofReal_neg, ++ ofReal_mul, ofReal_ofNat, Pi.sub_apply, smul_eq_mul, mul_sub] ++ apply integral_sub ++ · apply ψ.hf.bdd_mul (c := 1) l1 ; simp [Complex.norm_exp] ++ · apply (Ψ R : W21) |>.hf |>.bdd_mul (c := 1) l1 ++ simp [Complex.norm_exp] ++ ++ have S1_sub : S1 x (ψ - Ψ R) = S1 x ψ - S1 x (Ψ R) := by ++ simp only [one_div, mul_inv_rev, S1_sub_1, mul_sub, S1] ; apply Summable.tsum_sub ++ · have := summable_fourier x (by positivity) ψ ⟨_, hcheby⟩ ++ rw [summable_norm_iff] at this ++ simpa using this ++ · have := summable_fourier x (by positivity) (Ψ R) ⟨_, hcheby⟩ ++ rw [summable_norm_iff] at this ++ simpa using! this ++ ++ have S2_sub : S2 x (ψ - Ψ R) = S2 x ψ - S2 x (Ψ R) := by ++ simp only [S1_sub_1, S2] ; rw [integral_sub] ++ · ring ++ · exact ψ.integrable_fourier (by positivity) |>.restrict ++ · exact (Ψ R : W21).integrable_fourier (by positivity) |>.restrict ++ ++ have S_sub : S x (ψ - Ψ R) = S x ψ - S x (Ψ R) := by simp [S, S1_sub, S2_sub] ; ring ++ simpa [S_sub, Ψ] using norm_add_le _ _ |>.trans_lt (_root_.add_lt_add key3 key) ++ ++lemma limiting_cor_schwartz (ψ : 𝓢(ℝ, ℂ)) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := ++ limiting_cor_W21 ψ hf hcheby hG hG' ++ ++lemma fourier_surjection_on_schwartz (f : 𝓢(ℝ, ℂ)) : ∃ g : 𝓢(ℝ, ℂ), 𝓕 g = f := by ++ refine ⟨𝓕⁻ f, ?_⟩ ++ exact FourierTransform.fourier_fourierInv_eq f ++ ++noncomputable def toSchwartz (f : ℝ → ℂ) (h1 : ContDiff ℝ ∞ f) ++ (h2 : HasCompactSupport f) : 𝓢(ℝ, ℂ) where ++ toFun := f ++ smooth' := h1 ++ decay' k n := by ++ have l1 : Continuous (fun x => ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖) := by ++ have : ContDiff ℝ ∞ (iteratedFDeriv ℝ n f) := h1.iteratedFDeriv_right (mod_cast le_top) ++ exact Continuous.mul (by continuity) this.continuous.norm ++ have l2 : HasCompactSupport (fun x ↦ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖) := ++ (h2.iteratedFDeriv _).norm.mul_left ++ simpa using l1.bounded_above_of_compact_support l2 ++ ++@[simp] lemma toSchwartz_apply (f : ℝ → ℂ) {h1 h2 x} : SchwartzMap.mk f h1 h2 x = f x := rfl ++ ++lemma comp_exp_support0 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ ∀ᶠ x in 𝓝 0, Ψ x = 0 := ++ notMem_tsupport_iff_eventuallyEq.mp (fun h => lt_irrefl 0 <| mem_Ioi.mp (hplus h)) ++ ++lemma comp_exp_support1 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ ∀ᶠ x in atBot, Ψ (exp x) = 0 := ++ Real.tendsto_exp_atBot <| comp_exp_support0 hplus ++ ++lemma comp_exp_support2 {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) : ++ ∀ᶠ (x : ℝ) in atTop, (Ψ ∘ rexp) x = 0 := by ++ simp only [hasCompactSupport_iff_eventuallyEq, coclosedCompact_eq_cocompact, ++ cocompact_eq_atBot_atTop] at hsupp ++ exact Real.tendsto_exp_atTop hsupp.2 ++ ++theorem comp_exp_support {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : HasCompactSupport (Ψ ∘ rexp) := by ++ simp only [hasCompactSupport_iff_eventuallyEq, coclosedCompact_eq_cocompact, ++ cocompact_eq_atBot_atTop] ++ exact ⟨comp_exp_support1 hplus, comp_exp_support2 hsupp⟩ ++ ++lemma wiener_ikehara_smooth_aux (l0 : Continuous Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) (x : ℝ) (hx : 0 < x) : ++ ∫ (u : ℝ) in Ioi (-Real.log x), ↑(rexp u) * Ψ (rexp u) = ∫ (y : ℝ) in Ioi (1 / x), Ψ y := by ++ ++ have l1 : ContinuousOn rexp (Ici (-Real.log x)) := by fun_prop ++ have l2 : Tendsto rexp atTop atTop := Real.tendsto_exp_atTop ++ have l3 t (_ : t ∈ Ioi (-log x)) : HasDerivWithinAt rexp (rexp t) (Ioi t) t := ++ (Real.hasDerivAt_exp t).hasDerivWithinAt ++ have l4 : ContinuousOn Ψ (rexp '' Ioi (-Real.log x)) := by fun_prop ++ have l5 : IntegrableOn Ψ (rexp '' Ici (-Real.log x)) volume := ++ (l0.integrable_of_hasCompactSupport hsupp).integrableOn ++ have l6 : IntegrableOn (fun x ↦ rexp x • (Ψ ∘ rexp) x) (Ici (-Real.log x)) volume := by ++ refine (Continuous.integrable_of_hasCompactSupport (by fun_prop) ?_).integrableOn ++ change HasCompactSupport (rexp • (Ψ ∘ rexp)) ++ exact (comp_exp_support hsupp hplus).smul_left ++ have := MeasureTheory.integral_deriv_smul_comp_Ioi l1 l2 l3 l4 l5 l6 ++ simpa [Real.exp_neg, Real.exp_log hx] using this ++ ++theorem wiener_ikehara_smooth_sub (h1 : Integrable Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ Tendsto (fun x ↦ (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ ++ obtain ⟨ε, hε, hh⟩ := Metric.eventually_nhds_iff.mp <| comp_exp_support0 hplus ++ apply tendsto_nhds_of_eventually_eq ; filter_upwards [eventually_gt_atTop ε⁻¹] with x hxε ++ ++ have l1 : Integrable (indicator (Ioi x⁻¹) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi ++ have l2 : Integrable (indicator (Ioi 0) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi ++ ++ simp_rw [← MeasureTheory.integral_indicator measurableSet_Ioi, ← mul_sub, ← integral_sub l1 l2] ++ simp only [mul_eq_zero, ofReal_eq_zero] ++ right ++ apply MeasureTheory.integral_eq_zero_of_ae ++ apply Eventually.of_forall ++ intro t ++ simp only [Pi.zero_apply] ++ ++ have hε' : 0 < ε⁻¹ := by positivity ++ have hx : 0 < x := by linarith ++ have hx' : 0 < x⁻¹ := by positivity ++ have hεx : x⁻¹ < ε := (inv_lt_comm₀ hε hx).mp hxε ++ ++ have l3 : Ioi 0 = Ioc 0 x⁻¹ ∪ Ioi x⁻¹ := by ++ ext t ; simp only [mem_Ioi, mem_union, mem_Ioc] ; constructor <;> intro h ++ · simp [h, le_or_gt] ++ · cases h with ++ | inl h => exact h.1 ++ | inr h => exact hx'.trans h ++ have l4 : Disjoint (Ioc 0 x⁻¹) (Ioi x⁻¹) := by simp ++ have l5 := Set.indicator_union_of_disjoint l4 Ψ ++ rw [l3, l5] ++ simp only ++ rw [add_comm, sub_add_cancel_left] ++ by_cases ht : t ∈ Ioc 0 x⁻¹ ++ · simp only [ht, indicator_of_mem, neg_eq_zero] ++ apply hh ; simp only [mem_Ioc, dist_zero_right, norm_eq_abs] at ht ⊢ ++ apply hεx.trans_le' ++ rw [abs_le] ; constructor <;> linarith ++ simp [ht] ++ ++lemma wiener_ikehara_smooth (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hcheby : cheby f) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x - A * ∫ y in Set.Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ ++ let h (x : ℝ) : ℂ := rexp (2 * π * x) * Ψ (exp (2 * π * x)) ++ have h1 : ContDiff ℝ ∞ h := by ++ have : ContDiff ℝ ∞ (fun x : ℝ => (rexp (2 * π * x))) := (contDiff_const.mul contDiff_id).exp ++ exact (contDiff_ofReal.comp this).mul (hsmooth.comp this) ++ have h2 : HasCompactSupport h := by ++ have : 2 * π ≠ 0 := by simp [pi_ne_zero] ++ simpa using! (comp_exp_support hsupp hplus).comp_smul this |>.mul_left ++ obtain ⟨g, hg⟩ := fourier_surjection_on_schwartz (toSchwartz h h1 h2) ++ ++ have l1 {y} (hy : 0 < y) : y * Ψ y = 𝓕 g (1 / (2 * π) * Real.log y) := by ++ simp only [one_div, mul_inv_rev, hg, toSchwartz, ofReal_exp, ofReal_mul, ofReal_ofNat, ++ toSchwartz_apply, ofReal_inv, h] ++ field_simp ++ norm_cast ++ rw [Real.exp_log hy] ++ ++ have key := limiting_cor_schwartz g hf hcheby hG hG' ++ ++ have l2 : ∀ᶠ x in atTop, ∑' (n : ℕ), f n / ↑n * 𝓕 g (1 / (2 * π) * Real.log (↑n / x)) = ++ ∑' (n : ℕ), f n * Ψ (↑n / x) / x := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ congr ; ext n ++ by_cases hn : n = 0 ++ · simp [hn, (comp_exp_support0 hplus).self_of_nhds] ++ rw [← l1 (by positivity)] ++ have : (n : ℂ) ≠ 0 := by simpa using hn ++ have : (x : ℂ) ≠ 0 := by simpa using hx.ne.symm ++ simp only [ofReal_div, ofReal_natCast] ++ field_simp ++ ++ have l3 : ∀ᶠ x in atTop, ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 g (u / (2 * π)) = ++ ↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ congr 1 ++ simp only [hg, toSchwartz, ofReal_exp, ofReal_mul, ofReal_ofNat, toSchwartz_apply, ++ ofReal_div, h] ++ norm_cast ; field_simp; norm_cast ++ rw [MeasureTheory.integral_Ici_eq_integral_Ioi] ++ exact wiener_ikehara_smooth_aux hsmooth.continuous hsupp hplus x hx ++ ++ have l4 : Tendsto (fun x => (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ exact wiener_ikehara_smooth_sub (hsmooth.continuous.integrable_of_hasCompactSupport hsupp) hplus ++ ++ simpa [tsum_div_const] using (key.congr' <| EventuallyEq.sub l2 l3) |>.add l4 ++ ++lemma wiener_ikehara_smooth' (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hcheby : cheby f) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x) atTop (nhds (A * ∫ y in Set.Ioi 0, Ψ y)) := ++ tendsto_sub_nhds_zero_iff.mp <| wiener_ikehara_smooth hf hcheby hG hG' hsmooth hsupp hplus ++ ++local instance {E : Type*} : Coe (E → ℝ) (E → ℂ) := ⟨fun f n => f n⟩ ++ ++@[norm_cast] ++theorem set_integral_ofReal {f : ℝ → ℝ} {s : Set ℝ} : ∫ x in s, (f x : ℂ) = ∫ x in s, f x := ++ integral_ofReal ++ ++lemma wiener_ikehara_smooth_real {f : ℕ → ℝ} {Ψ : ℝ → ℝ} ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x) atTop (nhds (A * ∫ y in Set.Ioi 0, Ψ y)) := by ++ ++ let Ψ' := ofReal ∘ Ψ ++ have l1 : ContDiff ℝ ∞ Ψ' := contDiff_ofReal.comp hsmooth ++ have l2 : HasCompactSupport Ψ' := hsupp.comp_left rfl ++ have l3 : closure (Function.support Ψ') ⊆ Ioi 0 := by rwa [Function.support_comp_eq] ; simp ++ have key := (continuous_re.tendsto _).comp ++ (@wiener_ikehara_smooth' A Ψ G f hf hcheby hG hG' l1 l2 l3) ++ simp at key ; norm_cast at key ++ ++lemma interval_approx_inf (ha : 0 < a) (hab : a < b) : ++ ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ ++ closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ ++ ψ ≤ indicator (Ico a b) 1 ∧ b - a - ε ≤ ∫ y in Ioi 0, ψ y := by ++ ++ have l1 : Iio ((b - a) / 3) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds <| by ++ rw [← sub_pos] at hab ++ positivity ++ filter_upwards [self_mem_nhdsWithin, l1] with ε (hε : 0 < ε) (hε' : ε < (b - a) / 3) ++ have l2 : a < a + ε / 2 := by simp [hε] ++ have l3 : b - ε / 2 < b := by simp [hε] ++ obtain ⟨ψ, h1, h2, h3, h4, h5⟩ := smooth_urysohn_support_Ioo l2 l3 ++ refine ⟨ψ, h1, h2, ?_, ?_, ?_⟩ ++ · simp [h5, hab.ne, Icc_subset_Ioi_iff hab.le, ha] ++ · exact h4.trans <| indicator_le_indicator_of_subset Ioo_subset_Ico_self (by simp) ++ · have l4 : 0 ≤ b - a - ε := by linarith ++ have l5 : Icc (a + ε / 2) (b - ε / 2) ⊆ Ioi 0 := by ++ intro t ht ++ simp only [mem_Icc, mem_Ioi] at ht ⊢ ++ exact ha.trans <| l2.trans_le <| ht.1 ++ have l6 : Icc (a + ε / 2) (b - ε / 2) ∩ Ioi 0 = Icc (a + ε / 2) (b - ε / 2) := ++ inter_eq_left.mpr l5 ++ have l7 : ∫ y in Ioi 0, indicator (Icc (a + ε / 2) (b - ε / 2)) 1 y = b - a - ε := by ++ simp only [measurableSet_Icc, integral_indicator_one, measureReal_restrict_apply, l6, ++ volume_real_Icc] ++ convert max_eq_left l4 using 1 ; ring_nf ++ have l8 : IntegrableOn ψ (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ rw [← l7] ; apply setIntegral_mono ?_ l8 h3 ++ rw [IntegrableOn, integrable_indicator_iff measurableSet_Icc] ++ apply IntegrableOn.mono ?_ subset_rfl Measure.restrict_le_self ++ apply integrableOn_const <;> ++ simp ++ ++lemma interval_approx_sup (ha : 0 < a) (hab : a < b) : ++ ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ ++ closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ ++ indicator (Ico a b) 1 ≤ ψ ∧ ∫ y in Ioi 0, ψ y ≤ b - a + ε := by ++ ++ have l1 : Iio (a / 2) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds (by linarith) ++ filter_upwards [self_mem_nhdsWithin, l1] with ε (hε : 0 < ε) (hε' : ε < a / 2) ++ have l2 : a - ε / 2 < a := by linarith ++ have l3 : b < b + ε / 2 := by linarith ++ obtain ⟨ψ, h1, h2, h3, h4, h5⟩ := smooth_urysohn_support_Ioo l2 l3 ++ refine ⟨ψ, h1, h2, ?_, ?_, ?_⟩ ++ · have l4 : a - ε / 2 < b + ε / 2 := by linarith ++ have l5 : ε / 2 < a := by linarith ++ simp [h5, l4.ne, Icc_subset_Ioi_iff l4.le, l5] ++ · apply le_trans ?_ h3 ++ apply indicator_le_indicator_of_subset Ico_subset_Icc_self (by simp) ++ · have l4 : 0 ≤ b - a + ε := by linarith ++ have l5 : Ioo (a - ε / 2) (b + ε / 2) ⊆ Ioi 0 := by intro t ht ; simp at ht ⊢ ; linarith ++ have l6 : Ioo (a - ε / 2) (b + ε / 2) ∩ Ioi 0 = Ioo (a - ε / 2) (b + ε / 2) := inter_eq_left.mpr l5 ++ have l7 : ∫ y in Ioi 0, indicator (Ioo (a - ε / 2) (b + ε / 2)) 1 y = b - a + ε := by ++ simp only [measurableSet_Ioo, integral_indicator_one, measureReal_restrict_apply, l6, ++ volume_real_Ioo] ++ convert max_eq_left l4 using 1 ; ring_nf ++ have l8 : IntegrableOn ψ (Ioi 0) volume := (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ rw [← l7] ++ refine setIntegral_mono l8 ?_ h4 ++ rw [IntegrableOn, integrable_indicator_iff measurableSet_Ioo] ++ apply IntegrableOn.mono ?_ subset_rfl Measure.restrict_le_self ++ apply integrableOn_const <;> ++ simp ++ ++lemma WI_summable {f : ℕ → ℝ} {g : ℝ → ℝ} (hg : HasCompactSupport g) (hx : 0 < x) : ++ Summable (fun n => f n * g (n / x)) := by ++ obtain ⟨M, hM⟩ := hg.bddAbove.mono subset_closure ++ apply summable_of_hasFiniteSupport ++ unfold Function.HasFiniteSupport ++ simp only [Function.support_mul] ; apply Finite.inter_of_right ; rw [finite_iff_bddAbove] ++ exact ⟨Nat.ceil (M * x), fun i hi => by simpa using Nat.ceil_mono ((div_le_iff₀ hx).mp (hM hi))⟩ ++ ++lemma WI_sum_le {f : ℕ → ℝ} {g₁ g₂ : ℝ → ℝ} (hf : 0 ≤ f) (hg : g₁ ≤ g₂) (hx : 0 < x) ++ (hg₁ : HasCompactSupport g₁) (hg₂ : HasCompactSupport g₂) : ++ (∑' n, f n * g₁ (n / x)) / x ≤ (∑' n, f n * g₂ (n / x)) / x := by ++ apply div_le_div_of_nonneg_right ?_ hx.le ++ exact Summable.tsum_le_tsum (fun n => mul_le_mul_of_nonneg_left (hg _) (hf _)) ++ (WI_summable hg₁ hx) (WI_summable hg₂ hx) ++ ++lemma WI_sum_Iab_le {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} (hcheby : chebyWith C f) (hb : 0 < b) (hxb : 2 / b < x) : ++ (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by ++ have hb' : 0 < 2 / b := by positivity ++ have hx : 0 < x := by linarith ++ have hxb' : 2 < x * b := (div_lt_iff₀ hb).mp hxb ++ have l1 (i : ℕ) (hi : i ∉ Finset.range ⌈b * x⌉₊) : f i * indicator (Ico a b) 1 (i / x) = 0 := by ++ simp_all [le_div_iff₀ hx] ++ have l2 (i : ℕ) (_ : i ∈ Finset.range ⌈b * x⌉₊) : f i * indicator (Ico a b) 1 (i / x) ≤ |f i| := by ++ rw [abs_eq_self.mpr (hpos _)] ++ convert_to _ ≤ f i * 1 ++ · ring ++ apply mul_le_mul_of_nonneg_left ?_ (hpos _) ++ by_cases hi : (i / x) ∈ (Ico a b) <;> simp [hi] ++ rw [tsum_eq_sum l1, div_le_iff₀ hx, mul_assoc, mul_assoc] ++ apply Finset.sum_le_sum l2 |>.trans ++ have := hcheby ⌈b * x⌉₊ ; simp only [norm_real, norm_eq_abs] at this ; apply this.trans ++ have : 0 ≤ C := by have := hcheby 1 ; simp only [cumsum, Finset.range_one, norm_real, ++ Finset.sum_singleton, Nat.cast_one, mul_one] at this ; exact (abs_nonneg _).trans this ++ refine mul_le_mul_of_nonneg_left ?_ this ++ apply (Nat.ceil_lt_add_one (by positivity)).le.trans ++ linarith ++ ++lemma WI_sum_Iab_le' {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} (hcheby : chebyWith C f) (hb : 0 < b) : ++ ∀ᶠ x : ℝ in atTop, (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by ++ filter_upwards [eventually_gt_atTop (2 / b)] with x hx using WI_sum_Iab_le hpos hcheby hb hx ++ ++lemma le_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[>] b, a ≤ c) : a ≤ b := by ++ apply le_of_forall_gt ; intro d hd ++ have key : ∀ᶠ c in 𝓝[>] b, c < d := by ++ apply eventually_of_mem (U := Iio d) ?_ (fun x hx => hx) ++ rw [mem_nhdsWithin] ++ refine ⟨Iio d, isOpen_Iio, hd, inter_subset_left⟩ ++ obtain ⟨x, h1, h2⟩ := (h.and key).exists ++ linarith ++ ++lemma ge_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[<] b, c ≤ a) : b ≤ a := by ++ apply le_of_forall_lt ; intro d hd ++ have key : ∀ᶠ c in 𝓝[<] b, c > d := by ++ apply eventually_of_mem (U := Ioi d) ?_ (fun x hx => hx) ++ rw [mem_nhdsWithin] ++ refine ⟨Ioi d, isOpen_Ioi, hd, inter_subset_left⟩ ++ obtain ⟨x, h1, h2⟩ := (h.and key).exists ++ linarith ++ ++lemma WI_tendsto_aux (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++ Tendsto (fun c => c / A - (b - a)) (𝓝[>] (A * (b - a))) (𝓝[>] 0) := by ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨A * ε, by positivity, ?_⟩ ++ intro x hx1 hx2 ++ constructor ++ · simpa [lt_div_iff₀' hA] ++ · simp only [Real.dist_eq, dist_zero_right, Real.norm_eq_abs] at hx2 ⊢ ++ have : |x / A - (b - a)| = |x - A * (b - a)| / A := by ++ rw [← abs_eq_self.mpr hA.le, ← abs_div, abs_eq_self.mpr hA.le] ; congr ; field_simp ++ rwa [this, div_lt_iff₀' hA] ++ ++lemma WI_tendsto_aux' (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++ Tendsto (fun c => (b - a) - c / A) (𝓝[<] (A * (b - a))) (𝓝[>] 0) := by ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨A * ε, by positivity, ?_⟩ ++ intro x hx1 hx2 ++ constructor ++ · simpa [div_lt_iff₀' hA] ++ · simp only [Real.dist_eq, dist_zero_right, norm_eq_abs] at hx2 ⊢ ++ have : |(b - a) - x / A| = |A * (b - a) - x| / A := by ++ rw [← abs_eq_self.mpr hA.le, ← abs_div, abs_eq_self.mpr hA.le] ; congr ; field_simp ++ rwa [this, div_lt_iff₀' hA, ← neg_sub, abs_neg] ++ ++theorem residue_nonneg {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm (fun n ↦ ↑(f n)) σ')) (hcheby : cheby fun n ↦ ↑(f n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) (hG' : EqOn G (fun s ↦ LSeries (fun n ↦ ↑(f n)) s - ↑A / (s - 1)) {s | 1 < s.re}) : 0 ≤ A := by ++ let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x ++ have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by ++ filter_upwards [eventually_ge_atTop 0] with x hx ++ exact div_nonneg (tsum_nonneg (fun i => mul_nonneg (hpos _) (hg _))) hx ++ obtain ⟨ε, ψ, h1, h2, h3, h4, -⟩ := (interval_approx_sup zero_lt_one one_lt_two).exists ++ have key := @wiener_ikehara_smooth_real A G f ψ hf hcheby hG hG' h1 h2 h3 ++ have l2 : 0 ≤ ψ := by apply le_trans _ h4 ; apply indicator_nonneg ; simp ++ have l1 : ∀ᶠ x in atTop, 0 ≤ S ψ x := hSnonneg l2 ++ have l3 : 0 ≤ A * ∫ (y : ℝ) in Ioi 0, ψ y := ge_of_tendsto key l1 ++ have l4 : 0 < ∫ (y : ℝ) in Ioi 0, ψ y := by ++ have r1 : 0 ≤ᵐ[Measure.restrict volume (Ioi 0)] ψ := Eventually.of_forall l2 ++ have r2 : IntegrableOn (fun y ↦ ψ y) (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ have r3 : Ico 1 2 ⊆ Function.support ψ := by intro x hx ; have := h4 x ; simp [hx] at this ⊢ ; linarith ++ have r4 : Ico 1 2 ⊆ Function.support ψ ∩ Ioi 0 := by ++ simp only [subset_inter_iff, r3, true_and] ; apply Ico_subset_Icc_self.trans ; rw [Icc_subset_Ioi_iff] <;> linarith ++ have r5 : 1 ≤ volume ((Function.support fun y ↦ ψ y) ∩ Ioi 0) := by convert! volume.mono r4 ; norm_num ++ simpa [setIntegral_pos_iff_support_of_nonneg_ae r1 r2] using! zero_lt_one.trans_le r5 ++ have := div_nonneg l3 l4.le ; field_simp at this ; exact this ++ ++lemma WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * (indicator (Ico a b) 1 (n / x))) / x) atTop (nhds (A * (b - a))) := by ++ ++ by_cases hab : a = b ++ · simp [hab] ++ replace hb : a < b := lt_of_le_of_ne hb hab ; clear hab ++ ++ let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x ++ have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by ++ filter_upwards [eventually_ge_atTop 0] with x hx ++ refine div_nonneg ?_ hx ++ refine tsum_nonneg (fun i => mul_nonneg (hpos _) (hg _)) ++ have hA : 0 ≤ A := residue_nonneg hpos hf hcheby hG hG' ++ ++ let Iab : ℝ → ℝ := indicator (Ico a b) 1 ++ change Tendsto (S Iab) atTop (𝓝 (A * (b - a))) ++ have hIab : HasCompactSupport Iab := by simpa [Iab, HasCompactSupport, tsupport, hb.ne] using isCompact_Icc ++ have Iab_nonneg : ∀ᶠ x : ℝ in atTop, 0 ≤ S Iab x := hSnonneg (indicator_nonneg (by simp)) ++ have Iab2 : IsBoundedUnder (· ≤ ·) atTop (S Iab) := by ++ obtain ⟨C, hC⟩ := hcheby ; exact ⟨C * 2 * b, WI_sum_Iab_le' hpos hC (by linarith)⟩ ++ have Iab3 : IsBoundedUnder (· ≥ ·) atTop (S Iab) := ⟨0, Iab_nonneg⟩ ++ have Iab0 : IsCoboundedUnder (· ≥ ·) atTop (S Iab) := Iab2.isCoboundedUnder_ge ++ have Iab1 : IsCoboundedUnder (· ≤ ·) atTop (S Iab) := Iab3.isCoboundedUnder_le ++ ++ have sup_le : limsup (S Iab) atTop ≤ A * (b - a) := by ++ have l_sup : ∀ᶠ ε in 𝓝[>] 0, limsup (S Iab) atTop ≤ A * (b - a + ε) := by ++ filter_upwards [interval_approx_sup ha hb] with ε ⟨ψ, h1, h2, h3, h4, h6⟩ ++ have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 ++ have l6 : S Iab ≤ᶠ[atTop] S ψ := by ++ filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h4 hx hIab h2 ++ have l5 : IsBoundedUnder (· ≤ ·) atTop (S ψ) := l1.isBoundedUnder_le ++ have l3 : limsup (S Iab) atTop ≤ limsup (S ψ) atTop := limsup_le_limsup l6 Iab1 l5 ++ apply l3.trans ; rw [l1.limsup_eq] ; gcongr ++ obtain rfl | h := eq_or_ne A 0 ++ · simpa using l_sup ++ apply le_of_eventually_nhdsWithin ++ have key : 0 < A := lt_of_le_of_ne hA h.symm ++ filter_upwards [WI_tendsto_aux a b key l_sup] with x hx ++ simpa [mul_div_cancel₀ _ h] using hx ++ ++ have le_inf : A * (b - a) ≤ liminf (S Iab) atTop := by ++ have l_inf : ∀ᶠ ε in 𝓝[>] 0, A * (b - a - ε) ≤ liminf (S Iab) atTop := by ++ filter_upwards [interval_approx_inf ha hb] with ε ⟨ψ, h1, h2, h3, h5, h6⟩ ++ have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 ++ have l2 : S ψ ≤ᶠ[atTop] S Iab := by ++ filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h5 hx h2 hIab ++ have l4 : IsBoundedUnder (· ≥ ·) atTop (S ψ) := l1.isBoundedUnder_ge ++ have l3 : liminf (S ψ) atTop ≤ liminf (S Iab) atTop := liminf_le_liminf l2 l4 Iab0 ++ apply le_trans ?_ l3 ; rw [l1.liminf_eq] ; gcongr ++ obtain rfl | h := eq_or_ne A 0 ++ · simpa using l_inf ++ apply ge_of_eventually_nhdsWithin ++ have key : 0 < A := lt_of_le_of_ne hA h.symm ++ filter_upwards [WI_tendsto_aux' a b key l_inf] with x hx ++ simpa [mul_div_cancel₀ _ h] using hx ++ ++ have : liminf (S Iab) atTop ≤ limsup (S Iab) atTop := liminf_le_limsup Iab2 Iab3 ++ refine tendsto_of_liminf_eq_limsup ?_ ?_ Iab2 Iab3 <;> linarith ++ ++lemma le_floor_mul_iff (hb : 0 ≤ b) (hx : 0 < x) : n ≤ ⌊b * x⌋₊ ↔ n / x ≤ b := by ++ rw [div_le_iff₀ hx, Nat.le_floor_iff] ; positivity ++ ++lemma lt_ceil_mul_iff (hx : 0 < x) : n < ⌈b * x⌉₊ ↔ n / x < b := by ++ rw [div_lt_iff₀ hx, Nat.lt_ceil] ++ ++lemma ceil_mul_le_iff (hx : 0 < x) : ⌈a * x⌉₊ ≤ n ↔ a ≤ n / x := by ++ rw [le_div_iff₀ hx, Nat.ceil_le] ++ ++lemma mem_Icc_iff_div (hb : 0 ≤ b) (hx : 0 < x) : n ∈ Finset.Icc ⌈a * x⌉₊ ⌊b * x⌋₊ ↔ n / x ∈ Icc a b := by ++ rw [Finset.mem_Icc, mem_Icc, ceil_mul_le_iff hx, le_floor_mul_iff hb hx] ++ ++lemma mem_Ico_iff_div (hx : 0 < x) : n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊ ↔ n / x ∈ Ico a b := by ++ rw [Finset.mem_Ico, mem_Ico, ceil_mul_le_iff hx, lt_ceil_mul_iff hx] ++ ++lemma tsum_indicator {f : ℕ → ℝ} (hx : 0 < x) : ++ ∑' n, f n * (indicator (Ico a b) 1 (n / x)) = ∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n := by ++ have l1 : ∀ n ∉ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n * indicator (Ico a b) 1 (↑n / x) = 0 := by ++ simp [mem_Ico_iff_div hx] ; tauto ++ rw [tsum_eq_sum l1] ; apply Finset.sum_congr rfl ; simp only [mem_Ico_iff_div hx] ; intro n hn ; simp [hn] ++ ++lemma WienerIkeharaInterval_discrete {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n) / x) atTop (nhds (A * (b - a))) := by ++ apply (WienerIkeharaInterval hpos hf hcheby hG hG' ha hb).congr' ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ rw [tsum_indicator hx] ++ ++lemma WienerIkeharaInterval_discrete' {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun N : ℕ ↦ (∑ n ∈ Finset.Ico ⌈a * N⌉₊ ⌈b * N⌉₊, f n) / N) atTop (nhds (A * (b - a))) := ++ WienerIkeharaInterval_discrete hpos hf hcheby hG hG' ha hb |>.comp tendsto_natCast_atTop_atTop ++ ++lemma tendsto_mul_ceil_div : ++ Tendsto (fun (p : ℝ × ℕ) => ⌈p.1 * p.2⌉₊ / (p.2 : ℝ)) (𝓝[>] 0 ×ˢ atTop) (𝓝 0) := by ++ rw [Metric.tendsto_nhds] ; intro δ hδ ++ have l1 : ∀ᶠ ε : ℝ in 𝓝[>] 0, ε ∈ Ioo 0 (δ / 2) := inter_mem_nhdsWithin _ (Iio_mem_nhds (by positivity)) ++ have l2 : ∀ᶠ N : ℕ in atTop, 1 ≤ δ / 2 * N := by ++ apply Tendsto.eventually_ge_atTop ++ exact tendsto_natCast_atTop_atTop.const_mul_atTop (by positivity) ++ filter_upwards [l1.prod_mk l2] with (ε, N) ⟨⟨hε, h1⟩, h2⟩ ; dsimp only at * ++ have l3 : 0 < (N : ℝ) := by ++ simp only [Nat.cast_pos, Nat.pos_iff_ne_zero] ; rintro rfl ; simp [zero_lt_one.not_ge] at h2 ++ have l5 : 0 ≤ ε * ↑N := by positivity ++ have l6 : ε * N ≤ δ / 2 * N := mul_le_mul h1.le le_rfl (by positivity) (by positivity) ++ simp only [dist_zero_right, norm_div, RCLike.norm_natCast, div_lt_iff₀ l3, gt_iff_lt] ++ convert (Nat.ceil_lt_add_one l5).trans_le (add_le_add l6 h2) using 1 ; ring ++ ++noncomputable def S (f : ℕ → 𝕜) (ε : ℝ) (N : ℕ) : 𝕜 := (∑ n ∈ Finset.Ico ⌈ε * N⌉₊ N, f n) / N ++ ++lemma S_sub_S {f : ℕ → 𝕜} {ε : ℝ} {N : ℕ} (hε : ε ≤ 1) : S f 0 N - S f ε N = cumsum f ⌈ε * N⌉₊ / N := by ++ have hceilN : ⌈ε * N⌉₊ ≤ N := by ++ simp only [Nat.ceil_le] ++ exact mul_le_of_le_one_left N.cast_nonneg hε ++ have r1 : Finset.range N = Finset.range ⌈ε * N⌉₊ ∪ Finset.Ico ⌈ε * N⌉₊ N := by ++ ext n ++ simp only [Finset.mem_range, Finset.mem_union, Finset.mem_Ico] ++ omega ++ have r2 : Disjoint (Finset.range ⌈ε * N⌉₊) (Finset.Ico ⌈ε * N⌉₊ N) := by ++ rw [Finset.range_eq_Ico] ; apply Finset.Ico_disjoint_Ico_consecutive ++ simp [S, r1, Finset.sum_union r2, cumsum, add_div] ++ ++lemma tendsto_S_S_zero {f : ℕ → ℝ} (hpos : 0 ≤ f) (hcheby : cheby f) : ++ TendstoUniformlyOnFilter (S f) (S f 0) (𝓝[>] 0) atTop := by ++ rw [Metric.tendstoUniformlyOnFilter_iff] ; intro δ hδ ++ obtain ⟨C, hC⟩ := hcheby ++ have l1 : ∀ᶠ (p : ℝ × ℕ) in 𝓝[>] 0 ×ˢ atTop, C * ⌈p.1 * p.2⌉₊ / p.2 < δ := by ++ have r1 := tendsto_mul_ceil_div.const_mul C ++ simp only [mul_div_assoc', mul_zero] at r1 ; exact r1 (Iio_mem_nhds hδ) ++ have : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) ++ filter_upwards [l1, Eventually.prod_inl this _] with (ε, N) h1 h2 ++ have l2 : ‖cumsum f ⌈ε * ↑N⌉₊ / ↑N‖ ≤ C * ⌈ε * N⌉₊ / N := by ++ have r1 := hC ⌈ε * N⌉₊ ++ have r2 : 0 ≤ cumsum f ⌈ε * N⌉₊ := by apply cumsum_nonneg hpos ++ simp only [norm_real, norm_of_nonneg (hpos _), norm_div, ++ norm_of_nonneg r2, Real.norm_natCast] at r1 ⊢ ++ apply div_le_div_of_nonneg_right r1 (by positivity) ++ simpa [← S_sub_S h2.2] using! l2.trans_lt h1 ++ ++theorem WienerIkeharaTheorem' {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun N => cumsum f N / N) atTop (𝓝 A) := by ++ ++ convert_to Tendsto (S f 0) atTop (𝓝 A) ; · ext N ; simp [S, cumsum] ++ apply (tendsto_S_S_zero hpos hcheby).tendsto_of_eventually_tendsto ++ · have L0 : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) ++ apply eventually_of_mem L0 ++ · intro ε hε ++ simpa using! WienerIkeharaInterval_discrete' hpos hf hcheby hG hG' hε.1 hε.2 ++ · have : Tendsto (fun ε : ℝ => ε) (𝓝[>] 0) (𝓝 0) := nhdsWithin_le_nhds ++ simpa using (this.const_sub 1).const_mul A ++ ++theorem vonMangoldt_cheby : cheby Λ := by ++ use Real.log 4 + 4 ++ intro N ++ by_cases! h : N = 0 ++ · simp [h, cumsum] ++ simp only [cumsum, norm_real, norm_eq_abs] ++ rw [Nat.range_eq_Icc_zero_sub_one _ h, (by simp : N - 1 = ⌊(N : ℝ) - 1⌋₊)] ++ simp_rw [abs_of_nonneg vonMangoldt_nonneg] ++ rw [← Chebyshev.psi_eq_sum_Icc] ++ grw [Chebyshev.psi_le_const_mul_self <| sub_nonneg_of_le <| Nat.one_le_cast_iff_ne_zero.mpr h] ++ gcongr ++ linarith ++ ++theorem WeakPNT : Tendsto (fun N ↦ cumsum Λ N / N) atTop (𝓝 1) := by ++ let F := vonMangoldt.LFunctionResidueClassAux (q := 1) 1 ++ have hnv := riemannZeta_ne_zero_of_one_le_re ++ have l1 (n : ℕ) : 0 ≤ Λ n := vonMangoldt_nonneg ++ have l2 s (hs : 1 < s.re) : F s = LSeries Λ s - 1 / (s - 1) := by ++ have := vonMangoldt.eqOn_LFunctionResidueClassAux (q := 1) isUnit_one hs ++ simp only [F, this, vonMangoldt.residueClass, Nat.totient_one, Nat.cast_one, inv_one, one_div, sub_left_inj] ++ apply LSeries_congr ++ intro n _ ++ simp only [ofReal_inj, indicator_apply_eq_self, mem_ofPred_eq] ++ exact fun hn ↦ absurd (Subsingleton.eq_one _) hn ++ have l3 : ContinuousOn F {s | 1 ≤ s.re} := vonMangoldt.continuousOn_LFunctionResidueClassAux 1 ++ have l4 : cheby Λ := vonMangoldt_cheby ++ have l5 (σ' : ℝ) (hσ' : 1 < σ') : Summable (nterm Λ σ') := by ++ simpa only [← nterm_eq_norm_term] using (@ArithmeticFunction.LSeriesSummable_vonMangoldt σ' hσ').norm ++ apply WienerIkeharaTheorem' l1 l5 l4 l3 l2 ++ ++section auto_cheby ++ ++variable {f : ℕ → ℝ} ++ ++lemma norm_x_cpow_it (x t : ℝ) (hx : 0 < x) : ‖(x : ℂ) ^ (t * I)‖ = 1 := by ++ rw [cpow_def_of_ne_zero <| ofReal_ne_zero.mpr hx.ne', ← ofReal_log hx.le] ++ convert norm_exp_ofReal_mul_I (t * x.log) using 2 ++ push_cast; ring_nf ++ ++lemma limiting_fourier_aux_gt_zero (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 0 < x) (σ' : ℝ) (hσ' : 1 < σ') : ++ ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * (x ^ (1 - σ') : ℝ) * ∫ u in Ici (- log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I) := by ++ have hint : Integrable ψ := ψ.h1.continuous.integrable_of_hasCompactSupport ψ.h2 ++ have l8 : Continuous fun t : ℝ ↦ (x : ℂ) ^ (t * I) := ++ continuous_const.cpow (continuous_ofReal.mul continuous_const) (by simp [hx]) ++ have l4 : Integrable fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := ++ (((continuous_LSeries_aux (hf _ hσ')).mul ψ.h1.continuous).mul l8).integrable_of_hasCompactSupport ++ ψ.h2.mul_left.mul_right ++ have e2 (u : ℝ) : σ' + u * I - 1 ≠ 0 := fun h ↦ by ++ have := congrArg Complex.re (sub_eq_zero.mp h); simp at this; linarith ++ have l5 : Integrable fun a ↦ A * ↑(x ^ (1 - σ')) * ++ (↑(x ^ (σ' - 1)) * (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ have : Continuous fun a ↦ A * ↑(x ^ (1 - σ')) * ++ (↑(x ^ (σ' - 1)) * (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ simp only [one_div, ← mul_assoc] ++ exact ((continuous_const.mul (Continuous.inv₀ (by fun_prop) e2)).mul ψ.h1.continuous).mul l8 ++ exact this.integrable_of_hasCompactSupport ψ.h2.mul_left.mul_right.mul_left.mul_left ++ simp_rw [first_fourier hf hint hx hσ', second_fourier ψ.h1.continuous.measurable hint hx hσ', ++ ← integral_const_mul, ← integral_sub l4 l5] ++ refine integral_congr_ae (.of_forall fun u ↦ ?_) ++ have e1 : 1 < ((σ' : ℂ) + (u : ℂ) * I).re := by simp [hσ'] ++ simp_rw [hG' e1, sub_mul, ← mul_assoc] ++ simp only [one_div, sub_right_inj, mul_eq_mul_right_iff, cpow_eq_zero_iff, ofReal_eq_zero, ne_eq, ++ mul_eq_zero, I_ne_zero, or_false] ++ field_simp [e2]; norm_cast; simp [mul_assoc, ← rpow_add hx] ++ ++theorem limiting_fourier_lim2_gt_zero (A : ℝ) (ψ : W21) (hx : 0 < x) : ++ Tendsto (fun σ' ↦ A * ↑(x ^ (1 - σ')) * ++ ∫ u in Ici (-Real.log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) ++ (𝓝[>] 1) (𝓝 (A * ∫ u in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)))) := by ++ obtain ⟨C, hC⟩ := decay_bounds_cor ψ ++ refine Tendsto.mul ?_ (tendsto_integral_filter_of_dominated_convergence _ ++ (.of_forall fun _ ↦ (by continuity : Continuous _).aestronglyMeasurable) ?_ ++ (limiting_fourier_lim2_aux x C) (.of_forall fun u ↦ ?_)) ++ · suffices Tendsto (fun σ' : ℝ ↦ x ^ (1 - σ')) (𝓝[>] 1) (𝓝 1) by ++ simpa using ((continuous_ofReal.tendsto 1).comp this).const_mul ↑A ++ have : Tendsto (fun σ' : ℝ ↦ 1 - σ') (𝓝[>] 1) (𝓝 0) := ++ tendsto_nhdsWithin_of_tendsto_nhds (by simpa using (continuous_id.tendsto (1 : ℝ)).const_sub 1) ++ simpa using tendsto_const_nhds.rpow this (Or.inl hx.ne') ++ · refine eventually_of_mem (Ioo_mem_nhdsGT_of_mem (by norm_num : (1 : ℝ) ∈ Set.Ico 1 2)) fun σ' hσ' ↦ ?_ ++ obtain ⟨h1, h2⟩ := hσ' ++ rw [ae_restrict_iff' measurableSet_Ici] ++ refine .of_forall fun t ht ↦ ?_ ++ simp only [norm_mul, neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_sub, ofReal_one, ++ norm_exp, neg_re, mul_re, ofReal_re, sub_re, one_re, ofReal_im, sub_im, one_im, ++ sub_self, mul_zero, sub_zero] ++ refine mul_le_mul ?_ (hC _) (norm_nonneg _) ((abs_nonneg x).trans (le_max_left _ _)) ++ have hα0 : 0 ≤ σ' - 1 := by linarith ++ have hα1 : σ' - 1 ≤ 1 := by linarith ++ have hmul1 : (-x.log) * (σ' - 1) ≤ t * (σ' - 1) := mul_le_mul_of_nonneg_right ht hα0 ++ calc Real.exp (-(t * (σ' - 1))) ++ ≤ Real.exp (x.log * (σ' - 1)) := Real.exp_monotone (by linarith) ++ _ ≤ max |x| 1 := by ++ by_cases hx1 : 1 ≤ x ++ · calc _ ≤ Real.exp x.log := ++ Real.exp_monotone (mul_le_of_le_one_right (Real.log_nonneg hx1) hα1) ++ _ = |x| := by rw [Real.exp_log hx, abs_of_pos hx] ++ _ ≤ _ := le_max_left _ _ ++ · calc _ ≤ 1 := (Real.exp_monotone (mul_nonpos_of_nonpos_of_nonneg ++ ((Real.log_neg_iff hx).2 (by linarith)).le hα0)).trans_eq Real.exp_zero ++ _ ≤ _ := le_max_right _ _ ++ · suffices Tendsto (fun n ↦ ((rexp (-u * (n - 1))) : ℂ)) (𝓝[>] 1) (𝓝 1) by simpa using this.mul_const _ ++ refine Tendsto.mono_left ?_ nhdsWithin_le_nhds ++ have : Continuous (fun n ↦ ((rexp (-u * (n - 1))) : ℂ)) := by continuity ++ simpa using this.tendsto 1 ++ ++theorem limiting_fourier_lim3_gt_zero ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 ℂ) (hx : 0 < x) : ++ Tendsto (fun σ' : ℝ ↦ ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I)) (𝓝[>] 1) ++ (𝓝 (∫ t : ℝ, G (1 + t * I) * ψ t * x ^ (t * I))) := by ++ by_cases hh : tsupport ψ = ∅ ++ · simp [tsupport_eq_empty_iff.mp hh] ++ obtain ⟨a₀, ha₀⟩ := Set.nonempty_iff_ne_empty.mpr hh ++ let S : Set ℂ := reProdIm (Icc 1 2) (tsupport ψ) ++ have l1 : IsCompact S := Metric.isCompact_iff_isClosed_bounded.mpr ++ ⟨isClosed_Icc.reProdIm (isClosed_tsupport ψ), (Metric.isBounded_Icc 1 2).reProdIm ψ.h2.isBounded⟩ ++ have l2 : S ⊆ {s : ℂ | 1 ≤ s.re} := fun z hz => (mem_reProdIm.mp hz).1.1 ++ obtain ⟨z, -, hmax⟩ := l1.exists_isMaxOn ⟨1 + a₀ * I, by simp [S, mem_reProdIm, ha₀]⟩ (hG.mono l2).norm ++ have hxC : (x : ℂ) ≠ 0 := ofReal_ne_zero.mpr hx.ne' ++ refine tendsto_integral_filter_of_dominated_convergence (bound := fun a ↦ ‖G z‖ * ‖ψ a‖) ++ (eventually_of_mem (Icc_mem_nhdsGT_of_mem (by norm_num : (1 : ℝ) ∈ Set.Ico 1 2)) fun u hu ↦ ++ ((hG.comp_continuous (by fun_prop) (by simp [hu.1])).mul ψ.h1.continuous).mul ++ (by simpa using Continuous.const_cpow (by fun_prop) (Or.inl hxC)) |>.aestronglyMeasurable) ++ (eventually_of_mem (Icc_mem_nhdsGT_of_mem (by norm_num : (1 : ℝ) ∈ Set.Ico 1 2)) fun u hu ↦ ++ .of_forall fun v ↦ ?_) ++ ((continuous_const.mul ψ.h1.continuous.norm).integrable_of_hasCompactSupport ψ.h2.norm.mul_left) ++ (.of_forall fun t ↦ ?_) ++ · by_cases h : v ∈ tsupport ψ ++ · simp_rw [norm_mul, norm_x_cpow_it x v hx, mul_one] ++ exact mul_le_mul_of_nonneg_right (isMaxOn_iff.mp hmax _ (by simp [S, mem_reProdIm, hu.1, hu.2, h])) (norm_nonneg _) ++ · have : v ∉ Function.support ψ := fun a ↦ h (subset_tsupport ψ a) ++ simp [Function.notMem_support.mp this] ++ · exact ((hG (1 + t * I) (by simp)).tendsto.comp <| tendsto_nhdsWithin_iff.mpr ++ ⟨((continuous_ofReal.tendsto _).add tendsto_const_nhds).mono_left nhdsWithin_le_nhds, ++ eventually_nhdsWithin_of_forall fun _ hx' ↦ by simp [(Set.mem_Ioi.mp hx').le]⟩).mul_const _ |>.mul_const _ ++ ++lemma tendsto_tsum_of_monotone_convergence ++ {β : Type*} {f : ℕ → β → ENNReal} {g : β → ENNReal} ++ (hmono : ∀ k, Monotone (fun n => f n k)) ++ (hlim : ∀ k, Tendsto (fun n => f n k) atTop (𝓝 (g k))) : ++ Tendsto (fun n => ∑' k, f n k) atTop (𝓝 (∑' k, g k)) := by ++ let : MeasurableSpace β := ⊤ ++ let μ : Measure β := Measure.count ++ have hg_iSup (k : β) : (⨆ n : ℕ, f n k) = g k := iSup_eq_of_tendsto (hmono k) (hlim k) ++ have h_tend_lint : Tendsto (fun n => ∫⁻ k, f n k ∂μ) atTop (𝓝 (∫⁻ k, (⨆ n, f n k) ∂μ)) := by ++ have hmeas : ∀ n, Measurable fun k : β => f n k := fun _ _ _ ↦ trivial ++ have hmono_fn : Monotone (fun n => fun k : β => f n k) := fun _ _ hnm k ↦ hmono k hnm ++ simpa [lintegral_iSup hmeas hmono_fn] using ++ tendsto_atTop_iSup fun _ _ hmn ↦ lintegral_mono fun k ↦ hmono k hmn ++ simpa [μ, lintegral_count, hg_iSup] using h_tend_lint ++ ++lemma tendsto_tsum_of_monotone_convergence_nhdsGT_one ++ {F : ℝ → ℕ → ℝ} ++ (hF_nonneg : ∀ σ n, 0 ≤ F σ n) ++ (hF_antitone : ∀ n, AntitoneOn (fun σ : ℝ => F σ n) (Set.Ioi (1 : ℝ))) ++ (hF_tend : ∀ n, Tendsto (fun σ : ℝ => F σ n) (𝓝[>] (1 : ℝ)) (𝓝 (F 1 n))) ++ (hSumm : ∀ σ, 1 < σ → Summable (fun n : ℕ => F σ n)) ++ (hbounded : ++ BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ : ℝ => (∑' n : ℕ, F σ n))) : ++ Tendsto (fun σ : ℝ => ∑' n : ℕ, F σ n) (𝓝[>] (1 : ℝ)) (𝓝 (∑' n : ℕ, F 1 n)) := by ++ let T : ℝ → ℝ := fun σ => ∑' n : ℕ, F σ n ++ have hT_antitone : AntitoneOn T (Set.Ioi (1 : ℝ)) := fun a ha b hb hab ↦ ++ (hSumm b hb).tsum_le_tsum_of_inj (fun n ↦ n) (fun _ _ h ↦ h) (fun c hc ↦ (hc ⟨c, rfl⟩).elim) ++ (fun n ↦ hF_antitone n ha hb hab) (hSumm a ha) ++ have hT_bdd : BddAbove (T '' Set.Ioi (1 : ℝ)) := by ++ obtain ⟨C, hC⟩ := isBigO_iff.1 hbounded ++ have hC' : ∀ᶠ σ : ℝ in 𝓝[>] (1 : ℝ), T σ ≤ C := by ++ filter_upwards [hC] with σ hσ ++ calc T σ ≤ |T σ| := le_abs_self _ ++ _ = ‖T σ‖ := (Real.norm_eq_abs _).symm ++ _ ≤ C * ‖(1 : ℝ → ℝ) σ‖ := hσ ++ _ = C := by simp ++ obtain ⟨U, hU, V, hV, hUV⟩ := Filter.mem_inf_iff_superset.1 hC' ++ obtain ⟨ε, hε, hball⟩ := Metric.mem_nhds_iff.1 hU ++ have hIoi_sub : Set.Ioi (1 : ℝ) ⊆ V := Filter.mem_principal.mp hV ++ have hUsub : U ∩ Set.Ioi (1 : ℝ) ⊆ {σ : ℝ | T σ ≤ C} := fun σ hσ ↦ hUV ⟨hσ.1, hIoi_sub hσ.2⟩ ++ have hσ0_Ioi : 1 + ε / 2 ∈ Set.Ioi (1 : ℝ) := by simp [half_pos hε] ++ have hσ0_leC : T (1 + ε / 2) ≤ C := ++ hUsub ⟨hball (by simp only [Metric.mem_ball, Real.dist_eq, add_sub_cancel_left, ++ abs_of_pos (half_pos hε)]; exact half_lt_self hε), hσ0_Ioi⟩ ++ refine ⟨C, ?_⟩ ++ rintro _ ⟨σ, hσIoi, rfl⟩ ++ by_cases hσlt : σ < 1 + ε / 2 ++ · exact hUsub ⟨hball (by ++ simp only [Metric.mem_ball, Real.dist_eq] ++ rw [abs_of_pos (sub_pos.2 (Set.mem_Ioi.mp hσIoi))] ++ linarith [half_lt_self hε]), hσIoi⟩ ++ · exact (hT_antitone hσ0_Ioi hσIoi (le_of_not_gt hσlt)).trans hσ0_leC ++ have hT_tend_sup : Tendsto T (𝓝[>] (1 : ℝ)) (𝓝 (sSup (T '' Set.Ioi (1 : ℝ)))) := ++ hT_antitone.tendsto_nhdsGT hT_bdd ++ let σseq : ℕ → ℝ := fun k => 1 + 1 / (k + 1 : ℝ) ++ have hσseq_mem (k) : σseq k ∈ Set.Ioi (1 : ℝ) := by ++ simp only [σseq, Set.mem_Ioi, lt_add_iff_pos_right] ++ positivity ++ have hσseq_tend_nhds : Tendsto σseq atTop (𝓝 (1 : ℝ)) := by ++ have : Tendsto (fun k : ℕ => (1 : ℝ) + ((k + 1 : ℕ) : ℝ)⁻¹) atTop (𝓝 ((1 : ℝ) + 0)) := ++ tendsto_const_nhds.add (tendsto_inv_atTop_nhds_zero_nat.comp (tendsto_add_atTop_nat 1)) ++ simp only [add_zero] at this ++ convert this using 1; ext k; simp [σseq, one_div] ++ have hσseq_tend_nhdsWithin : Tendsto σseq atTop (𝓝[>] (1 : ℝ)) := ++ tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ hσseq_tend_nhds ++ (.of_forall hσseq_mem) ++ have hσseq_antitone : Antitone σseq := fun k₁ k₂ hk ↦ by simp only [σseq]; gcongr ++ have hmono_seq (n) : Monotone (fun k => F (σseq k) n) := fun k₁ k₂ hk ↦ ++ hF_antitone n (hσseq_mem k₂) (hσseq_mem k₁) (hσseq_antitone hk) ++ have htend_seq (n) : Tendsto (fun k => F (σseq k) n) atTop (𝓝 (F 1 n)) := ++ (hF_tend n).comp hσseq_tend_nhdsWithin ++ have hTseq : Tendsto (fun k : ℕ => T (σseq k)) atTop (𝓝 (T 1)) := by ++ have hsum1 : Summable (fun n : ℕ => F (1 : ℝ) n) := by ++ obtain ⟨C, hC⟩ := hT_bdd ++ refine summable_of_sum_range_le (hF_nonneg 1) fun m ↦ le_of_tendsto ++ (tendsto_finsetSum _ fun i _ ↦ hF_tend i) ++ (eventually_of_mem self_mem_nhdsWithin fun σ hσ ↦ ++ ((hSumm σ hσ).sum_le_tsum _ (fun n _ ↦ hF_nonneg σ n)).trans (hC ⟨σ, hσ, rfl⟩)) ++ have hg_ne_top : (∑' n : ℕ, ENNReal.ofReal (F 1 n)) ≠ ⊤ := hsum1.tsum_ofReal_ne_top ++ have hENN : Tendsto (fun k => ∑' n, ENNReal.ofReal (F (σseq k) n)) atTop ++ (𝓝 (∑' n, ENNReal.ofReal (F 1 n))) := ++ tendsto_tsum_of_monotone_convergence (fun n _ _ hk ↦ ENNReal.ofReal_le_ofReal (hmono_seq n hk)) ++ (fun n ↦ ENNReal.tendsto_ofReal (htend_seq n)) ++ have hrew (σ) : (∑' n, ENNReal.ofReal (F σ n)).toReal = ∑' n, F σ n := by ++ rw [ENNReal.tsum_toReal_eq (fun n ↦ by simp)] ++ exact tsum_congr fun n ↦ by simp [hF_nonneg σ n] ++ simp only [T, ← hrew]; exact (ENNReal.tendsto_toReal hg_ne_top).comp hENN ++ have hsSup_eq : sSup (T '' Set.Ioi (1 : ℝ)) = T 1 := ++ tendsto_nhds_unique (hT_tend_sup.comp hσseq_tend_nhdsWithin) hTseq ++ simpa [T, hsSup_eq] using hT_tend_sup ++ ++lemma limiting_fourier_variant_lim1_aux ++ {f : ℕ → ℝ} {x : ℝ} (ψ : CS 2 ℂ) ++ (hpos : 0 ≤ f) ++ (hf : ∀ (σ : ℝ), 1 < σ → Summable (nterm f σ)) ++ (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) : ++ ∀ (σ : ℝ), 1 < σ → ++ Summable (fun n : ℕ => ++ (if n = 0 then 0 else f n / ((n : ℝ) ^ σ)) * ++ (𝓕 ψ.toFun (1 / (2 * π) * Real.log ((n : ℝ) / x))).re) := by ++ intro σ hσ ++ let y : ℕ → ℝ := fun n => (1 / (2 * π)) * Real.log ((n : ℝ) / x) ++ let W : ℕ → ℝ := fun n => (𝓕 ψ.toFun (y n)).re ++ let base : ℕ → ℝ := fun n => if n = 0 then 0 else f n / ((n : ℝ) ^ σ) ++ obtain ⟨C, hC⟩ := decay_bounds_cor (W21.ofCS2 ψ) ++ have hC_nonneg : 0 ≤ C := (norm_nonneg _).trans ((hC 0).trans (by simp)) ++ have hW_nonneg (n : ℕ) : 0 ≤ W n := (hψpos (y n)).1 ++ have hnorm_four (n : ℕ) : ‖𝓕 ψ.toFun (y n)‖ = W n := by ++ have him0 : (𝓕 ψ.toFun (y n)).im = 0 := (hψpos (y n)).2 ++ rw [show 𝓕 ψ.toFun (y n) = W n by exact Complex.ext rfl him0] ++ simp [abs_of_nonneg (hW_nonneg n)] ++ have hW_le_C (n : ℕ) : W n ≤ C := by ++ rw [← hnorm_four]; exact (hC (y n)).trans (div_le_self hC_nonneg (by nlinarith [sq_nonneg (y n)])) ++ have hbase_summ : Summable base := by ++ convert hf σ hσ using 1; ext n ++ by_cases hn : n = 0 <;> simp [nterm, base, hn, Real.norm_eq_abs, abs_of_nonneg (hpos n)] ++ refine (hbase_summ.mul_left C).of_norm_bounded fun n ↦ ?_ ++ by_cases hn : n = 0 ++ · simp [base, hn] ++ · have hnpos : 0 < (n : ℝ) := Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn) ++ have hbase_nonneg : 0 ≤ base n := by ++ simp only [base, hn, ite_false] ++ exact div_nonneg (hpos n) (Real.rpow_pos_of_pos hnpos σ).le ++ calc |base n * W n| = base n * W n := abs_of_nonneg (mul_nonneg hbase_nonneg (hW_nonneg n)) ++ _ ≤ base n * C := mul_le_mul_of_nonneg_left (hW_le_C n) hbase_nonneg ++ _ = C * base n := mul_comm _ _ ++ ++theorem limiting_fourier_variant_lim1 ++ {f : ℕ → ℝ} {x : ℝ} {ψ : CS 2 ℂ} ++ (hpos : 0 ≤ f) ++ (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) ++ (S : ℝ → ℂ) ++ (hSdef : ++ ∀ σ' : ℝ, ++ S σ' = ++ ∑' n : ℕ, ++ term (fun n ↦ (f n : ℂ)) (σ' : ℝ) n * ++ 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x))) ++ (hbounded : BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ' : ℝ => ‖S σ'‖)) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) : ++ Tendsto ++ (fun σ' : ℝ => ++ ∑' n : ℕ, ++ term (fun n ↦ (f n : ℂ)) (σ' : ℝ) n * ++ 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x))) ++ (𝓝[>] (1 : ℝ)) ++ (𝓝 ++ (∑' n : ℕ, ++ (f n : ℂ) / (n : ℂ) * ++ 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x)))) := by ++ ++ let y : ℕ → ℝ := fun n => (π⁻¹ * 2⁻¹) * Real.log ((n : ℝ) / x) ++ let w : ℕ → ℝ := fun n => (𝓕 ψ.toFun (y n)).re ++ ++ have hw_nonneg : ∀ n, 0 ≤ w n := by ++ intro n ++ exact (hψpos (y n)).1 ++ ++ have hFour_eq_ofReal : ∀ n, 𝓕 ψ.toFun (y n) = Complex.ofReal (w n) := by ++ intro n ++ have h := hψpos (y n) ++ refine Complex.ext ?_ ?_ ++ · simp [w] ++ · simp [w, h.2] ++ ++ let rterm : ℝ → ℕ → ℝ := ++ fun σ n => ++ if h0 : n = 0 then 0 else (f n) / ((n : ℝ) ^ σ) * (w n) ++ ++ have summand_eq_ofReal : ++ ∀ (σ : ℝ) (n : ℕ), ++ term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n) ++ = Complex.ofReal (rterm σ n) := by ++ intro σ n ++ by_cases hn : n = 0 ++ · subst hn ++ simp [rterm, y] ++ · have hnpos : (0 : ℝ) < (n : ℝ) := by ++ exact_mod_cast (Nat.pos_of_ne_zero hn) ++ have hn0 : 0 ≤ (n : ℝ) := le_of_lt hnpos ++ have hcpow : ++ ( (n : ℂ) ^ ((σ : ℝ) : ℂ) ) = ( ( (n : ℝ) ^ σ : ℝ) : ℂ ) := by ++ simpa using (Complex.ofReal_cpow hn0 σ).symm ++ have hpow_ne : ((n : ℝ) ^ σ) ≠ 0 := by ++ exact (ne_of_gt (Real.rpow_pos_of_pos hnpos σ)) ++ calc ++ term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n) ++ = ++ ((f n : ℂ) / ((n : ℂ) ^ ((σ : ℝ) : ℂ))) * ( (w n : ℝ) : ℂ ) := by ++ simp [term, LSeries.term, hn, hFour_eq_ofReal] ++ _ = ++ ((f n : ℂ) / (((n : ℝ) ^ σ : ℝ) : ℂ)) * ((w n : ℝ) : ℂ) := by ++ simp [hcpow] ++ _ = ++ (( (f n : ℝ) : ℂ) / (((n : ℝ) ^ σ : ℝ) : ℂ)) * ((w n : ℝ) : ℂ) := by ++ simp ++ _ = ++ ( ( (f n : ℝ) / ((n : ℝ) ^ σ) : ℝ) : ℂ ) * ((w n : ℝ) : ℂ) := by ++ simp [Complex.ofReal_div] ++ _ = ++ ( ( (f n : ℝ) / ((n : ℝ) ^ σ) * (w n) : ℝ ) : ℂ ) := by ++ simp [Complex.ofReal_mul] ++ _ = ++ Complex.ofReal (rterm σ n) := by ++ simp [rterm, hn] ++ ++ let T : ℝ → ℝ := fun σ => ∑' n, rterm σ n ++ ++ have tsum_eq_ofReal_T : ∀ σ : ℝ, ++ (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) ++ = Complex.ofReal (T σ) := by ++ intro σ ++ have hcongr : ++ (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) ++ = ∑' n : ℕ, (Complex.ofReal (rterm σ n)) := by ++ refine tsum_congr ?_ ++ intro n ++ simpa using (summand_eq_ofReal σ n) ++ ++ calc ++ (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) ++ = ∑' n : ℕ, (Complex.ofReal (rterm σ n)) := hcongr ++ _ = Complex.ofReal (∑' n : ℕ, rterm σ n) := by ++ simpa using (Complex.ofReal_tsum (fun n : ℕ => rterm σ n)).symm ++ _ = Complex.ofReal (T σ) := by rfl ++ ++ have hS_ofReal_T : ∀ σ : ℝ, S σ = Complex.ofReal (T σ) := by ++ intro σ ++ simpa [hSdef σ, y] using (tsum_eq_ofReal_T σ) ++ ++ have rterm_nonneg : ∀ σ n, 0 ≤ rterm σ n := by ++ intro σ n ++ by_cases hn : n = 0 ++ · subst hn; simp [rterm] ++ · have hf : 0 ≤ f n := hpos n ++ have hw : 0 ≤ w n := hw_nonneg n ++ have hnpos : 0 < (n : ℝ) := by ++ exact_mod_cast (Nat.pos_of_ne_zero hn) ++ have hden : 0 < (n : ℝ) ^ σ := Real.rpow_pos_of_pos hnpos σ ++ have : 0 ≤ (f n) / ((n : ℝ) ^ σ) := div_nonneg hf (le_of_lt hden) ++ simp [rterm, hn, mul_nonneg this hw] ++ ++ have T_nonneg : ∀ σ, 0 ≤ T σ := by ++ intro σ ++ exact tsum_nonneg (fun n => rterm_nonneg σ n) ++ ++ have hT_eq_normS : ∀ σ, T σ = ‖S σ‖ := by ++ intro σ ++ have := hS_ofReal_T σ ++ calc ++ T σ = ‖Complex.ofReal (T σ)‖ := by simp [abs_of_nonneg (T_nonneg σ)] ++ _ = ‖S σ‖ := by simp [this] ++ ++ have hboundedT : BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ : ℝ => T σ) := by ++ have : (fun σ : ℝ => T σ) = (fun σ : ℝ => ‖S σ‖) := by ++ funext σ; exact hT_eq_normS σ ++ simpa [this] using hbounded ++ ++ have rterm_antitone : ∀ n, AntitoneOn (fun σ => rterm σ n) (Set.Ioi 1) := by ++ intro n σ₁ hσ₁ σ₂ hσ₂ hσ₁₂ ++ by_cases hn : n = 0 ++ · subst hn; simp [rterm] ++ · have hf : 0 ≤ f n := hpos n ++ have hw : 0 ≤ w n := hw_nonneg n ++ have hnpos : 0 < (n : ℝ) := by exact_mod_cast (Nat.pos_of_ne_zero hn) ++ have hn1 : (1 : ℝ) ≤ (n : ℝ) := by ++ exact_mod_cast (Nat.one_le_iff_ne_zero.mpr hn) ++ have hpow : (n : ℝ) ^ σ₁ ≤ (n : ℝ) ^ σ₂ := ++ Real.rpow_le_rpow_of_exponent_le hn1 hσ₁₂ ++ have hinv : ++ (1 / ((n : ℝ) ^ σ₂)) ≤ (1 / ((n : ℝ) ^ σ₁)) := by ++ have hpos1 : 0 < (n : ℝ) ^ σ₁ := Real.rpow_pos_of_pos hnpos σ₁ ++ exact one_div_le_one_div_of_le hpos1 hpow ++ have hinv_inv : ((n : ℝ) ^ σ₂)⁻¹ ≤ ((n : ℝ) ^ σ₁)⁻¹ := by ++ simpa [one_div] using hinv ++ have hmul1 : ++ (f n) * (((n : ℝ) ^ σ₂)⁻¹) ≤ (f n) * (((n : ℝ) ^ σ₁)⁻¹) := ++ mul_le_mul_of_nonneg_left hinv_inv hf ++ have hmul2 : ++ ((f n) * (((n : ℝ) ^ σ₂)⁻¹)) * (w n) ++ ≤ ((f n) * (((n : ℝ) ^ σ₁)⁻¹)) * (w n) := ++ mul_le_mul_of_nonneg_right hmul1 hw ++ simpa [rterm, hn, div_eq_mul_inv, mul_assoc] using hmul2 ++ ++ have rterm_tend : ∀ n, Tendsto (fun σ : ℝ => rterm σ n) (𝓝[>] (1 : ℝ)) (𝓝 (rterm 1 n)) := by ++ intro n ++ have hterm : ++ Tendsto (fun σ : ℝ => term (fun n ↦ (f n : ℂ)) (σ : ℝ) n) ++ (𝓝[>] (1 : ℝ)) (𝓝 ((f n : ℂ) / (n : ℂ))) := by ++ by_cases hn : n = 0 ++ · subst hn ++ simp [term, LSeries.term] ++ · have hden : ++ Tendsto (fun σ : ℝ => ((n : ℂ) ^ ((σ : ℝ) : ℂ))) (𝓝[>] (1 : ℝ)) (𝓝 ((n : ℂ) ^ (1 : ℂ))) := by ++ simpa using ((continuous_ofReal.tendsto (1 : ℝ)).mono_left nhdsWithin_le_nhds).const_cpow ++ ++ have hden' : ++ Tendsto (fun σ : ℝ => ((n : ℂ) ^ ((σ : ℝ) : ℂ))) (𝓝[>] (1 : ℝ)) (𝓝 (n : ℂ)) := by ++ simpa using hden ++ ++ have hnC : (n : ℂ) ≠ 0 := by ++ exact_mod_cast hn ++ ++ have hterm : ++ Tendsto (fun σ : ℝ => term (fun n ↦ (f n : ℂ)) (σ : ℝ) n) ++ (𝓝[>] (1 : ℝ)) (𝓝 ((f n : ℂ) / (n : ℂ))) := by ++ have hnC : (n : ℂ) ≠ 0 := by ++ exact_mod_cast hn ++ simpa [term, LSeries.term, hn] using! ++ (tendsto_const_nhds.div hden' hnC) ++ exact hterm ++ ++ have hsummand : ++ Tendsto ++ (fun σ : ℝ => ++ term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) ++ (𝓝[>] (1 : ℝ)) ++ (𝓝 (((f n : ℂ) / (n : ℂ)) * 𝓕 ψ.toFun (y n))) := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using (hterm.mul_const (𝓕 ψ.toFun (y n))) ++ ++ have hre : ∀ σ, rterm σ n = ++ (term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)).re := by ++ intro σ ++ have := congrArg Complex.re (summand_eq_ofReal σ n) ++ simpa [Complex.ofReal_re] using this.symm ++ ++ have hRe : Tendsto ++ (fun σ : ℝ => ++ (term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)).re) ++ (𝓝[>] (1 : ℝ)) ++ (𝓝 ((((f n : ℂ) / (n : ℂ)) * 𝓕 ψ.toFun (y n)).re)) := ++ (continuous_re.tendsto _).comp hsummand ++ ++ have hlimit_re : ++ (f n / (n : ℝ)) * (𝓕 ψ.toFun (y n)).re = rterm 1 n := by ++ have h0 : ++ (term (fun n ↦ (f n : ℂ)) (1 : ℝ) n * 𝓕 ψ.toFun (y n)).re = rterm 1 n := by ++ have := congrArg Complex.re (summand_eq_ofReal (σ := (1 : ℝ)) n) ++ simpa [Complex.ofReal_re] using this ++ ++ by_cases hn : n = 0 ++ · subst hn ++ simp [rterm, y] ++ · have h1 : ++ (term (fun n ↦ (f n : ℂ)) (1 : ℝ) n * 𝓕 ψ.toFun (y n)).re ++ = (f n / (n : ℝ)) * (𝓕 ψ.toFun (y n)).re := by ++ simp [Complex.mul_re, term, LSeries.term, hn, y, ++ (hψpos (y n)).2] ++ ++ exact (h1.symm.trans h0) ++ ++ simpa [hre, hlimit_re] using hRe ++ ++ have hSumm_rterm : ∀ σ : ℝ, 1 < σ → Summable (fun n : ℕ => rterm σ n) := by ++ simpa [rterm] using limiting_fourier_variant_lim1_aux (ψ := ψ) ++ (f := f) (x := x) hpos hf hψpos ++ ++ have hT_tend : ++ Tendsto T (𝓝[>] (1 : ℝ)) (𝓝 (T 1)) := by ++ have : ++ Tendsto (fun σ : ℝ => ∑' n : ℕ, rterm σ n) ++ (𝓝[>] (1 : ℝ)) ++ (𝓝 (∑' n : ℕ, rterm (1 : ℝ) n)) := by ++ refine tendsto_tsum_of_monotone_convergence_nhdsGT_one ++ (F := rterm) ++ (hF_nonneg := rterm_nonneg) ++ (hF_antitone := rterm_antitone) ++ (hF_tend := rterm_tend) ++ (hSumm := hSumm_rterm) ++ (hbounded := hboundedT) ++ ++ simpa [T] using this ++ ++ have hToReal : ++ Tendsto (fun σ => Complex.ofReal (T σ)) (𝓝[>] (1 : ℝ)) (𝓝 (Complex.ofReal (T 1))) := ++ (continuous_ofReal.tendsto _).comp hT_tend ++ ++ have hsource : ++ (fun σ : ℝ => ++ ∑' n : ℕ, ++ term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) ++ = fun σ : ℝ => Complex.ofReal (T σ) := by ++ funext σ ++ exact (tsum_eq_ofReal_T σ) ++ ++ have hσ1 : ++ (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (↑(1:ℝ)) n * 𝓕 ψ.toFun (y n)) ++ = (↑(T 1) : ℂ) := ++ by simpa using (tsum_eq_ofReal_T (σ := (1:ℝ))) ++ have hterm1 : ++ ∀ n : ℕ, term (fun n ↦ (f n : ℂ)) (1 : ℂ) n = (f n : ℂ) / (n : ℂ) := by ++ intro n ++ by_cases hn : n = 0 ++ · subst hn ++ simp [term, LSeries.term] ++ · simp [term, LSeries.term, hn] ++ ++ have hrewrite : ++ (∑' n : ℕ, ++ term (fun n ↦ (f n : ℂ)) (1 : ℂ) n * 𝓕 ψ.toFun (y n)) ++ = ++ (∑' n : ℕ, ++ (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (y n)) := by ++ refine tsum_congr ?_ ++ intro n ++ simp [hterm1 n] ++ ++ have htarget : ++ (∑' n : ℕ, ++ (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (y n)) ++ = (↑(T 1) : ℂ) := by ++ exact (hrewrite.symm.trans hσ1) ++ ++ simpa [hsource, htarget, y] using hToReal ++ ++lemma limiting_fourier_variant ++ (hpos : 0 ≤ f) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (ψ : CS 2 ℂ) ++ (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) ++ (hx : 0 < x) : ++ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ ∫ (t : ℝ), (G (1 + t * I)) * (ψ t) * x ^ (t * I) := by ++ ++ have l2 := limiting_fourier_lim2_gt_zero (A := A) (x := x) ψ hx ++ have l3 := limiting_fourier_lim3_gt_zero (G := G) (x := x) hG ψ hx ++ ++ let S : ℝ → ℂ := fun σ' => ++ ∑' n : ℕ, ++ term (fun n ↦ (f n : ℂ)) σ' n * ++ 𝓕 ψ.toFun (1 / (2 * π) * Real.log ((n : ℝ) / x)) ++ let Pole : ℝ → ℂ := fun σ' => ++ (A : ℂ) * ((x ^ (1 - σ') : ℝ) : ℂ) * ++ ∫ u in Set.Ici (-Real.log x), ++ (rexp (-u * (σ' - 1)) : ℂ) * ++ 𝓕 (W21.ofCS2 ψ).toFun (u / (2 * π)) ++ let RHS : ℝ → ℂ := fun σ' => ++ ∫ t : ℝ, G (σ' + t * I) * ψ.toFun t * (x : ℂ) ^ (t * I) ++ ++ have haux : ++ (fun σ' : ℝ ↦ ++ ∑' (n : ℕ), ++ term (fun n ↦ (f n : ℂ)) (σ' : ℂ) n * ++ 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x)) ++ - (A : ℂ) * ((x ^ (1 - σ') : ℝ) : ℂ) * ++ ∫ (u : ℝ) in Ici (-Real.log x), ++ cexp (-( (u : ℂ) * ((σ' : ℂ) - 1))) * ++ 𝓕 (W21.ofCS2 ψ).toFun (u / (2 * π))) ++ =ᶠ[𝓝[>] (1 : ℝ)] ++ (fun σ' : ℝ ↦ ++ ∫ (t : ℝ), G ((σ' : ℂ) + (t : ℂ) * I) * ψ.toFun t * (x : ℂ) ^ ((t : ℂ) * I)) := by ++ rw [Filter.EventuallyEq] ++ ++ refine eventually_nhdsWithin_of_forall ?_ ++ intro σ' hσ' ++ have hσ' : (1 : ℝ) < σ' := by ++ simpa [Set.mem_Ioi] using hσ' ++ simpa using! (limiting_fourier_aux_gt_zero (G := G) (f := f) (A := A) hG' hf ψ hx σ' hσ') ++ ++ have haux' : ++ (fun σ' : ℝ => S σ') =ᶠ[𝓝[>] (1 : ℝ)] (fun σ' : ℝ => RHS σ' + Pole σ') := by ++ rw [Filter.EventuallyEq] at haux ⊢ ++ filter_upwards [haux] with σ' hσ' ++ have hσ'' : S σ' - Pole σ' = RHS σ' := by ++ simpa [S, Pole, RHS] using hσ' ++ have hadd : (S σ' - Pole σ') + Pole σ' = RHS σ' + Pole σ' := ++ congrArg (fun z : ℂ => z + Pole σ') hσ'' ++ simpa [sub_eq_add_neg, add_assoc, add_left_comm, add_comm] using hadd ++ ++ let Pole₁ : ℂ := (A : ℂ) * ∫ u in Set.Ici (-Real.log x), 𝓕 (W21.ofCS2 ψ).toFun (u / (2 * π)) ++ let RHS₁ : ℂ := ∫ t : ℝ, G (1 + (t : ℂ) * I) * ψ.toFun t * (x : ℂ) ^ ((t : ℂ) * I) ++ ++ have hRHS_le : ++ ∀ᶠ σ' : ℝ in 𝓝[>] (1 : ℝ), ‖RHS σ'‖ ≤ ‖RHS₁‖ + 1 := by ++ have hball : Metric.ball RHS₁ (1 : ℝ) ∈ 𝓝 RHS₁ := by ++ simpa using (Metric.ball_mem_nhds (x := RHS₁) (ε := (1 : ℝ)) (by norm_num)) ++ have hpre : {σ' : ℝ | RHS σ' ∈ Metric.ball RHS₁ (1 : ℝ)} ∈ (𝓝[>] (1 : ℝ)) := ++ l3 hball ++ filter_upwards [hpre] with σ' hmem ++ have hdist' : dist (RHS σ') RHS₁ < (1 : ℝ) := by ++ simpa [Metric.mem_ball] using hmem ++ have hdist : ‖RHS σ' - RHS₁‖ < (1 : ℝ) := by ++ simpa [dist_eq_norm] using hdist' ++ have htri : ‖RHS σ'‖ ≤ ‖RHS₁‖ + ‖RHS σ' - RHS₁‖ := by ++ have h := norm_add_le (RHS σ' - RHS₁) RHS₁ ++ simpa [sub_add_cancel, add_comm, add_left_comm, add_assoc] using h ++ have hle : ‖RHS₁‖ + ‖RHS σ' - RHS₁‖ ≤ ‖RHS₁‖ + (1 : ℝ) := by ++ exact add_le_add_right (le_of_lt hdist) ‖RHS₁‖ ++ exact htri.trans hle ++ ++ have hPole_le : ++ ∀ᶠ σ' : ℝ in 𝓝[>] (1 : ℝ), ‖Pole σ'‖ ≤ ‖Pole₁‖ + 1 := by ++ have hball : Metric.ball Pole₁ 1 ∈ 𝓝 Pole₁ := by ++ simpa using (Metric.ball_mem_nhds Pole₁ (by norm_num : (0 : ℝ) < 1)) ++ have hpre : {σ' : ℝ | Pole σ' ∈ Metric.ball Pole₁ 1} ∈ (𝓝[>] (1 : ℝ)) := l2 hball ++ filter_upwards [hpre] with σ' hmem ++ have hdist : ‖Pole σ' - Pole₁‖ < 1 := by ++ simpa [Metric.mem_ball, dist_eq_norm] using hmem ++ have htri : ‖Pole σ'‖ ≤ ‖Pole₁‖ + ‖Pole σ' - Pole₁‖ := by ++ have hdecomp : Pole σ' = Pole₁ + (Pole σ' - Pole₁) := by abel ++ have hnorm_eq : ‖Pole σ'‖ = ‖Pole₁ + (Pole σ' - Pole₁)‖ := by ++ simp [congrArg (fun z : ℂ => ‖z‖) hdecomp] ++ calc ++ ‖Pole σ'‖ = ‖Pole₁ + (Pole σ' - Pole₁)‖ := hnorm_eq ++ _ ≤ ‖Pole₁‖ + ‖Pole σ' - Pole₁‖ := norm_add_le _ _ ++ have hdist_le : ‖Pole σ' - Pole₁‖ ≤ 1 := le_of_lt hdist ++ have hsum : ‖Pole₁‖ + ‖Pole σ' - Pole₁‖ ≤ ‖Pole₁‖ + 1 := by ++ simpa [add_comm, add_left_comm, add_assoc] using (add_le_add_left hdist_le ‖Pole₁‖) ++ exact htri.trans hsum ++ ++ have hS_le : ++ ∀ᶠ σ' : ℝ in 𝓝[>] (1 : ℝ), ++ ‖S σ'‖ ≤ (‖RHS₁‖ + 1) + (‖Pole₁‖ + 1) := by ++ rw [Filter.EventuallyEq] at haux' ++ filter_upwards [haux', hRHS_le, hPole_le] with σ' hEq hR hP ++ calc ++ ‖S σ'‖ = ‖RHS σ' + Pole σ'‖ := by simp [hEq] ++ _ ≤ ‖RHS σ'‖ + ‖Pole σ'‖ := norm_add_le _ _ ++ _ ≤ (‖RHS₁‖ + 1) + (‖Pole₁‖ + 1) := by ++ exact add_le_add hR hP ++ ++ have hbounded : BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ' : ℝ => ‖S σ'‖) := by ++ let C : ℝ := ‖RHS₁‖ + 1 + (‖Pole₁‖ + 1) ++ simp only [BoundedAtFilter, Asymptotics.IsBigO, Asymptotics.IsBigOWith] ++ refine ⟨C, ?_⟩ ++ filter_upwards [hS_le] with σ' hσ' ++ simpa [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg (S σ'))] using hσ' ++ ++ have hcoef : (1 / (2 * π) : ℝ) = (π⁻¹ * 2⁻¹ : ℝ) := by field_simp [pi_ne_zero] ++ ++ have l1 := ++ limiting_fourier_variant_lim1 ++ (f := f) (x := x) (ψ := ψ) ++ hpos hψpos ++ (S := S) ++ (hSdef := by ++ intro σ ++ simp [S, hcoef] ) ++ hbounded ++ hf ++ have l1S : ++ Tendsto S (𝓝[>] (1 : ℝ)) ++ (𝓝 (∑' n : ℕ, (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (1 / (2 * π) * Real.log (↑n / x)))) := by ++ simpa [S, hcoef] using l1 ++ ++ have l12 : Tendsto (fun σ' : ℝ => S σ' - Pole σ') (𝓝[>] (1 : ℝ)) ++ (𝓝 ((∑' n : ℕ, (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (1 / (2 * π) * Real.log (↑n / x))) - Pole₁)) := ++ l1S.sub l2 ++ ++ have hPole : (Pole : ℝ → ℂ) =ᶠ[𝓝[>] (1 : ℝ)] Pole := by simp ++ have haux_sub : ++ (fun σ' : ℝ => S σ' - Pole σ') =ᶠ[𝓝[>] (1 : ℝ)] RHS := by ++ filter_upwards [haux'] with σ' hσ' ++ calc ++ S σ' - Pole σ' ++ = (RHS σ' + Pole σ') - Pole σ' := by simp [hσ'] ++ _ = RHS σ' := by simp ++ have hlim := ++ tendsto_nhds_unique_of_eventuallyEq (l1S.sub l2) l3 haux_sub ++ ++ simpa [Pole₁, RHS₁] using! hlim ++ ++lemma norm_mul_integral_Ici_le_integral_norm ++ (A : ℂ) (F : ℝ → ℂ) (a : ℝ) ++ (hF : IntegrableOn F (Set.Ici a)) ++ (hnorm : Integrable (fun u : ℝ => ‖F u‖)) : ++ ‖A * (∫ u in Set.Ici a, F u)‖ ≤ ‖A‖ * (∫ u : ℝ, ‖F u‖) := by ++ have hmul : ‖A * (∫ u in Set.Ici a, F u)‖ = ‖A‖ * ‖∫ u in Set.Ici a, F u‖ := by ++ simp ++ have hnormI : ++ ‖∫ u in Set.Ici a, F u‖ ≤ ∫ u in Set.Ici a, ‖F u‖ := by ++ have _ : Integrable F (Measure.restrict volume (Set.Ici a)) := hF ++ have h : ++ ‖∫ u, F u ∂Measure.restrict volume (Set.Ici a)‖ ++ ≤ ∫ u, ‖F u‖ ∂Measure.restrict volume (Set.Ici a) := ++ norm_integral_le_integral_norm (μ := Measure.restrict volume (Set.Ici a)) (f := F) ++ simpa using h ++ ++ have hdom : ++ (∫ u in Set.Ici a, ‖F u‖) ≤ ∫ u : ℝ, ‖F u‖ := by ++ have hEq : ++ (∫ u in Set.Ici a, ‖F u‖) = ++ ∫ u : ℝ, Set.indicator (Set.Ici a) (fun u => ‖F u‖) u := by ++ have h := (integral_indicator (μ := (volume : Measure ℝ)) ++ (s := Set.Ici a) (f := fun u => ‖F u‖)) ++ have h' := h measurableSet_Ici ++ simpa using h'.symm ++ have hind_int : ++ Integrable (Set.indicator (Set.Ici a) (fun u => ‖F u‖)) := ++ hnorm.indicator measurableSet_Ici ++ have hpoint : ++ Set.indicator (Set.Ici a) (fun u => ‖F u‖) ++ ≤ᵐ[volume] (fun u : ℝ => ‖F u‖) := by ++ filter_upwards with u ++ by_cases hu : u ∈ Set.Ici a ++ · simp [Set.indicator_of_mem hu] ++ · simp [Set.indicator_of_notMem hu] ++ have hmono := ++ integral_mono_ae (μ := (volume : Measure ℝ)) ++ hind_int hnorm hpoint ++ simpa [hEq] using hmono ++ ++ calc ++ ‖A * (∫ u in Set.Ici a, F u)‖ ++ = ‖A‖ * ‖∫ u in Set.Ici a, F u‖ := hmul ++ _ ≤ ‖A‖ * (∫ u in Set.Ici a, ‖F u‖) := ++ mul_le_mul_of_nonneg_left hnormI (by simp) ++ _ ≤ ‖A‖ * (∫ u : ℝ, ‖F u‖) := ++ mul_le_mul_of_nonneg_left hdom (by simp) ++ ++lemma fourier_decay_of_CS2 ++ (ψ : CS 2 ℂ) : ++ ∃ C : ℝ, ∀ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by ++ let ψ' : W21 := (ψ : W21) ++ obtain ⟨C, hC⟩ : ++ ∃ C : ℝ, ∀ u : ℝ, ‖𝓕 (ψ' : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by ++ simpa using (decay_bounds_cor (ψ := ψ')) ++ refine ⟨C, ?_⟩ ++ intro u ++ simpa [ψ'] using! (hC u) ++ ++lemma integrable_norm_fourier_scaled_of_CS2 ++ (ψ : CS 2 ℂ) : ++ Integrable (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by ++ obtain ⟨C, hdecay⟩ := fourier_decay_of_CS2 (ψ := ψ) ++ have hC_nonneg : 0 ≤ C := by ++ have h0 := hdecay 0 ++ have hnorm : 0 ≤ ‖𝓕 (ψ : ℝ → ℂ) 0‖ := norm_nonneg _ ++ have hC' : ‖𝓕 (ψ : ℝ → ℂ) 0‖ ≤ C := by simpa using h0 ++ exact hnorm.trans hC' ++ have hmaj_int : Integrable (fun u : ℝ => (C : ℝ) / (1 + (u / (2 * Real.pi))^2)) := by ++ have hbase : Integrable (fun u : ℝ => (1 + u ^ 2)⁻¹) := integrable_inv_one_add_sq ++ have hscale : ++ Integrable (fun u : ℝ => (1 + (u / (2 * Real.pi)) ^ 2)⁻¹) := ++ hbase.comp_div (by nlinarith [Real.pi_pos]) ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc, pow_two] using ++ hscale.const_mul C ++ have hle : ++ (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) ++ ≤ᵐ[volume] ++ (fun u : ℝ => (C : ℝ) / (1 + (u / (2 * Real.pi))^2)) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro u ++ simpa using (hdecay (u / (2 * Real.pi))) ++ have hle_norm : ++ (fun u : ℝ => ‖‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖‖) ++ ≤ᵐ[volume] ++ (fun u : ℝ => ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖) := by ++ refine hle.mono ?_ ++ intro u hu ++ have hden_pos : 0 < 1 + (u / (2 * Real.pi)) ^ 2 := by nlinarith ++ have hnonneg : 0 ≤ (C : ℝ) / (1 + (u / (2 * Real.pi))^2) := ++ div_nonneg hC_nonneg hden_pos.le ++ have hleft_nonneg : 0 ≤ ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖ := norm_nonneg _ ++ have hbound : ‖‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖‖ ≤ ++ (C : ℝ) / (1 + (u / (2 * Real.pi))^2) := by ++ simpa [Real.norm_eq_abs, abs_of_nonneg hleft_nonneg] using hu ++ have hC_abs : |C| = C := abs_of_nonneg hC_nonneg ++ have hden_abs : |1 + (u / (2 * Real.pi))^2| = 1 + (u / (2 * Real.pi))^2 := by ++ have : 0 ≤ 1 + (u / (2 * Real.pi))^2 := by nlinarith ++ simpa using abs_of_nonneg this ++ have hnorm : ++ ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖ = ++ (C : ℝ) / (1 + (u / (2 * Real.pi))^2) := by ++ have hrec : ++ ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖ = ++ |C| / |1 + (u / (2 * Real.pi))^2| := by ++ simp [Real.norm_eq_abs] ++ simp [hC_abs, hden_abs, hrec] ++ simpa [hnorm] using hbound ++ have hmaj_int_norm : ++ Integrable (fun u : ℝ => ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖) := ++ hmaj_int.norm ++ have hmeas : ++ AEStronglyMeasurable (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by ++ have hcont : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) u := by ++ simpa using! continuous_FourierIntegral (ψ : W21) ++ have hcont_scaled : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi)) := ++ hcont.comp (by continuity) ++ exact hcont_scaled.aestronglyMeasurable.norm ++ exact hmaj_int_norm.mono' hmeas hle_norm ++ ++lemma exists_bound_norm_G_on_tsupport ++ (hG : ContinuousOn G {s : ℂ | 1 ≤ s.re}) ++ (ψ : CS 2 ℂ) : ++ ∃ K : ℝ, ∀ t : ℝ, t ∈ tsupport (ψ : ℝ → ℂ) → ++ ‖G (1 + t * Complex.I)‖ ≤ K := by ++ let s : Set ℝ := tsupport (ψ : ℝ → ℂ) ++ have hscompact : IsCompact s := by ++ simpa [s] using (ψ.h2.isCompact : IsCompact (tsupport (ψ : ℝ → ℂ))) ++ have hphi_cont : Continuous (fun t : ℝ => (1 : ℂ) + t * Complex.I) := by continuity ++ have hphi_maps : ++ Set.MapsTo (fun t : ℝ => (1 : ℂ) + t * Complex.I) s {z : ℂ | 1 ≤ z.re} := by ++ intro t ht ++ simp ++ have hGcomp : ContinuousOn (fun t : ℝ => G ((1 : ℂ) + t * Complex.I)) s := ++ hG.comp hphi_cont.continuousOn hphi_maps ++ have hnorm_contOn : ContinuousOn (fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) s := hGcomp.norm ++ have hbdd : BddAbove ((fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) '' s) := ++ (hscompact.image_of_continuousOn hnorm_contOn).bddAbove ++ refine ⟨sSup ((fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) '' s), ?_⟩ ++ intro t ht ++ have : ‖G ((1 : ℂ) + t * Complex.I)‖ ∈ ++ (fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) '' s := ⟨t, ht, rfl⟩ ++ exact le_csSup hbdd this ++ ++lemma norm_integrand_le_K_mul_norm_psi ++ {x K : ℝ} ++ (hx : 0 < x) ++ (hK : ∀ t : ℝ, t ∈ Function.support ψ → ‖G (1 + t * Complex.I)‖ ≤ K) : ++ ∀ t : ℝ, ++ ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ ≤ K * ‖ψ t‖ := by ++ intro t ++ by_cases ht : t ∈ Function.support ψ ++ · have hxnorm : ‖((x : ℂ) ^ (t * Complex.I))‖ = 1 := norm_x_cpow_it x t hx ++ calc ++ ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ ++ = ‖G (1 + t * Complex.I)‖ * ‖ψ t‖ * ‖((x : ℂ) ^ (t * Complex.I))‖ := by ++ simp [mul_left_comm, mul_comm] ++ _ = ‖G (1 + t * Complex.I)‖ * ‖ψ t‖ * 1 := by simp [hxnorm] ++ _ ≤ K * ‖ψ t‖ := by ++ have hGle : ‖G (1 + t * Complex.I)‖ ≤ K := hK t ht ++ have : ‖G (1 + t * Complex.I)‖ * ‖ψ t‖ ≤ K * ‖ψ t‖ := ++ mul_le_mul_of_nonneg_right hGle (norm_nonneg _) ++ simpa [mul_assoc, mul_left_comm, mul_comm] using this ++ · have hψ0 : ψ t = 0 := by ++ by_contra hψ0 ++ exact ht (by simpa [Function.support] using hψ0) ++ simp [hψ0, mul_comm] ++ ++lemma norm_error_integral_le ++ (ψ : ℝ → ℂ) (x K : ℝ) ++ (hGline_meas : Measurable (fun t : ℝ => G (1 + t * I))) ++ (hψ_meas : AEStronglyMeasurable ψ) ++ (hx : 0 < x) ++ (hK : ∀ t : ℝ, t ∈ Function.support ψ → ‖G (1 + t * Complex.I)‖ ≤ K) ++ (hψ : Integrable (fun t : ℝ => ‖ψ t‖) ) : ++ ‖∫ t : ℝ, (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ ++ ≤ K * (∫ t : ℝ, ‖ψ t‖) := by ++ have h1 : ‖∫ t : ℝ, (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ ++ ≤ ∫ t : ℝ, ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ := by ++ simpa using (norm_integral_le_integral_norm ++ (f := fun t : ℝ => (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I)))) ++ have hmeas_main : AEStronglyMeasurable ++ (fun t : ℝ => (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))) := by ++ have hG' : AEMeasurable fun t : ℝ => G (1 + t * Complex.I) := hGline_meas.aemeasurable ++ have hψ_meas' : AEMeasurable ψ := hψ_meas.aemeasurable ++ have hx_ne : (x : ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt hx) ++ have hx_ne' : NeZero (x : ℂ) := ⟨hx_ne⟩ ++ have hxpow_meas : AEMeasurable fun t : ℝ => ((x : ℂ) ^ (t * Complex.I)) := by ++ have hcontℂ : Continuous fun z : ℂ => ((x : ℂ) ^ z) := ++ continuous_const_cpow (z := (x : ℂ)) ++ have hcont : Continuous fun t : ℝ => ((x : ℂ) ^ ((t : ℂ) * Complex.I)) := ++ hcontℂ.comp (by ++ have h : Continuous fun t : ℝ => (t : ℂ) * Complex.I := by ++ simpa using! (continuous_ofReal.mul continuous_const) ++ simpa [mul_comm] using h) ++ exact hcont.measurable.aemeasurable ++ have hGψ_meas : AEMeasurable fun t : ℝ => (G (1 + t * Complex.I)) * (ψ t) := hG'.mul hψ_meas' ++ have htotal : AEMeasurable (fun t : ℝ => ++ (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))) := ++ hGψ_meas.mul hxpow_meas ++ exact htotal.aestronglyMeasurable ++ have hpt : (fun t : ℝ => ++ ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖) ++ ≤ᵐ[volume] (fun t : ℝ => K * ‖ψ t‖) := by ++ refine Eventually.of_forall ?_ ++ intro t ++ exact norm_integrand_le_K_mul_norm_psi (hx := hx) (hK := hK) t ++ have hR : Integrable (fun t : ℝ => K * ‖ψ t‖) := hψ.const_mul K ++ have hL : Integrable (fun t : ℝ => ++ ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖) := by ++ have hpt_norm : ++ (fun t : ℝ => ‖‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖‖) ++ ≤ᵐ[volume] (fun t : ℝ => K * ‖ψ t‖) := hpt.mono (by ++ intro t ht ++ simpa [norm_mul, mul_comm, mul_left_comm, mul_assoc] using ht) ++ exact hR.mono' hmeas_main.norm hpt_norm ++ have h2 : (∫ t : ℝ, ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖) ++ ≤ ∫ t : ℝ, K * ‖ψ t‖ := integral_mono_ae (μ := (volume : Measure ℝ)) hL hR hpt ++ have h3 : (∫ t : ℝ, K * ‖ψ t‖) = K * (∫ t : ℝ, ‖ψ t‖) := by ++ simp [integral_const_mul] ++ calc ++ ‖∫ t : ℝ, (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ ++ ≤ ∫ t : ℝ, ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ := h1 ++ _ ≤ ∫ t : ℝ, K * ‖ψ t‖ := h2 ++ _ = K * (∫ t : ℝ, ‖ψ t‖) := h3 ++ ++lemma crude_upper_bound ++ (hpos : 0 ≤ f) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (ψ : CS 2 ℂ) ++ (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) : ++ ∃ B : ℝ, ∀ x : ℝ, 0 < x → ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ B := by ++ ++ have hψ_int : MeasureTheory.Integrable (ψ : ℝ → ℂ) := by ++ simpa using (ψ.h1.continuous.integrable_of_hasCompactSupport ψ.h2) ++ have hψ_norm_int : MeasureTheory.Integrable (fun t : ℝ => ‖(ψ : ℝ → ℂ) t‖) := ++ hψ_int.norm ++ have hψ_meas : MeasureTheory.AEStronglyMeasurable (ψ : ℝ → ℂ) := ++ hψ_int.aestronglyMeasurable ++ ++ rcases exists_bound_norm_G_on_tsupport (G := G) hG ψ with ⟨K, hK_ts⟩ ++ have hK_support : ++ ∀ t : ℝ, t ∈ Function.support (ψ : ℝ → ℂ) → ‖G (1 + t * Complex.I)‖ ≤ K := by ++ have hbnG (hKts : ∀ t : ℝ, t ∈ tsupport ψ → ‖G (1 + t * Complex.I)‖ ≤ K) : ++ ∀ t : ℝ, t ∈ Function.support ψ → ‖G (1 + t * Complex.I)‖ ≤ K := by ++ intro t ht ++ exact hKts t ((subset_tsupport ψ) ht) ++ exact hbnG hK_ts ++ ++ have hGline_meas : Measurable (fun t : ℝ => G (1 + t * Complex.I)) := by ++ have hline_cont : Continuous (fun t : ℝ => (1 : ℂ) + t * Complex.I) := by ++ continuity ++ have hmem : ∀ t : ℝ, ((1 : ℂ) + t * Complex.I) ∈ {s : ℂ | 1 ≤ s.re} := by ++ intro t ++ simp ++ have hcont : Continuous (G ∘ fun t : ℝ => (1 : ℂ) + t * Complex.I) := ++ hG.comp_continuous hline_cont hmem ++ simpa [Function.comp] using! hcont.measurable ++ ++ have hF_norm_int : ++ MeasureTheory.Integrable (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := ++ integrable_norm_fourier_scaled_of_CS2 ψ ++ have hF_meas : ++ MeasureTheory.AEStronglyMeasurable ++ (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) := by ++ have hcont : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) u := by ++ simpa using! continuous_FourierIntegral (ψ : W21) ++ have hcont_scaled : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi)) := ++ hcont.comp (by continuity) ++ exact hcont_scaled.aestronglyMeasurable ++ have hF_int : ++ MeasureTheory.Integrable (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) := ++ by ++ have hfin_norm : ++ MeasureTheory.HasFiniteIntegral ++ (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := ++ hF_norm_int.hasFiniteIntegral ++ have hfin : ++ MeasureTheory.HasFiniteIntegral ++ (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) := by ++ simpa [MeasureTheory.hasFiniteIntegral_iff_norm] using hfin_norm ++ exact ⟨hF_meas, hfin⟩ ++ refine ⟨K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) ++ + ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖), ?_⟩ ++ intro x hx ++ set I : ℂ := ∫ u in Set.Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi)) with hI ++ ++ have hlim := ++ limiting_fourier_variant (f := f) (A := A) (G := G) ++ hpos hG hG' hf ψ hψpos hx ++ have hlim' : ++ (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log (n / x))) ++ - A * I ++ = ∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I) := by ++ simpa [hI] using hlim ++ ++ have htsum : ++ (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log (n / x))) ++ = (∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I := by ++ have h' : ++ (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log (n / x))) ++ = (∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I := ++ eq_add_of_sub_eq hlim' ++ simpa [add_comm, mul_comm, mul_left_comm, mul_assoc] using h' ++ ++ have hRHS_bound : ++ ‖∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)‖ ++ ≤ K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) := ++ norm_error_integral_le (G := G) (ψ := (ψ : ℝ → ℂ)) (x := x) (K := K) ++ hGline_meas hψ_meas hx hK_support hψ_norm_int ++ ++ have hA_bound : ++ ‖A * I‖ ≤ ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by ++ have hF_on : MeasureTheory.IntegrableOn ++ (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) ++ (Set.Ici (-Real.log x)) := ++ hF_int.integrableOn ++ simpa [hI] using ++ norm_mul_integral_Ici_le_integral_norm (A := A) ++ (F := fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) ++ (a := -Real.log x) hF_on hF_norm_int ++ ++ have htsum_std : ++ (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))) ++ = (∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I := by ++ simpa [one_div, mul_comm, mul_left_comm, mul_assoc] using htsum ++ ++ have hbound : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) ++ (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))‖ ++ ≤ K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) ++ + ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by ++ have hnorm : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) ++ (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))‖ = ++ ‖(∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I‖ := ++ congrArg norm htsum_std ++ calc ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) ++ (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))‖ ++ = ‖(∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I‖ := hnorm ++ _ ≤ ‖∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)‖ + ‖A * I‖ := ++ norm_add_le _ _ ++ _ ≤ K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) ++ + ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := ++ add_le_add hRHS_bound hA_bound ++ exact hbound ++ ++lemma Real.fourierIntegral_convolution {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) : ++ 𝓕 (convolution f g (ContinuousLinearMap.mul ℂ ℂ) volume) = 𝓕 f * 𝓕 g := by ++ ext y ++ simp only [Pi.mul_apply, FourierTransform.fourier, MeasureTheory.convolution, ++ VectorFourier.fourierIntegral, ContinuousLinearMap.mul_apply'] ++ have h_int : Integrable (fun p : ℝ × ℝ ↦ 𝐞 (-(y * p.1)) • (f p.2 * g (p.1 - p.2))) := by ++ simp only [Circle.smul_def, smul_eq_mul] ++ refine (Integrable.convolution_integrand (ContinuousLinearMap.mul ℂ ℂ) hf hg).bdd_mul ++ (c := 1) ?_ ?_ ++ · exact (by continuity : Continuous _).aestronglyMeasurable ++ · filter_upwards with p; simp ++ calc ∫ v, 𝐞 (-(y * v)) • ∫ t, f t * g (v - t) ++ = ∫ v, ∫ t, 𝐞 (-(y * v)) • (f t * g (v - t)) := by ++ simp only [Circle.smul_def, smul_eq_mul, ← integral_const_mul] ++ _ = ∫ t, ∫ v, 𝐞 (-(y * v)) • (f t * g (v - t)) := integral_integral_swap h_int ++ _ = ∫ t, f t • ∫ v, 𝐞 (-(y * v)) • g (v - t) := by ++ simp only [Circle.smul_def, smul_eq_mul, mul_left_comm, integral_const_mul] ++ _ = ∫ t, f t • ∫ u, 𝐞 (-(y * (u + t))) • g u := by ++ congr 1; ext t ++ rw [← integral_add_right_eq_self (fun v ↦ 𝐞 (-(y * v)) • g (v - t)) t]; simp ++ _ = ∫ t, f t • ∫ u, (𝐞 (-(y * t)) * 𝐞 (-(y * u))) • g u := by ++ congr 2 with t; congr 1 ++ simp only [mul_add, neg_add, mul_comm, Real.fourierChar.map_add_eq_mul] ++ _ = ∫ t, 𝐞 (-(y * t)) • f t • ∫ u, 𝐞 (-(y * u)) • g u := by ++ congr 1; ext t ++ simp only [mul_smul, Circle.smul_def, smul_eq_mul, integral_const_mul]; ring ++ _ = (∫ t, 𝐞 (-(y * t)) • f t) * ∫ u, 𝐞 (-(y * u)) • g u := by ++ simp only [Circle.smul_def, smul_eq_mul, ← mul_assoc, integral_mul_const] ++ ++lemma Real.fourierIntegral_conj_neg {f : ℝ → ℂ} (y : ℝ) : ++ 𝓕 (fun x ↦ conj (f (-x))) y = conj (𝓕 f y) := by ++ simp only [fourier_real_eq] ++ have h_conj : ∀ x, 𝐞 (-(x * y)) • conj (f (-x)) = conj (𝐞 (x * y) • f (-x)) := fun x ↦ by ++ simp only [Circle.smul_def, Real.fourierChar_apply, map_mul, smul_eq_mul, neg_mul, ++ Complex.ofReal_neg, mul_neg] ++ congr 1 ++ rw [← Complex.exp_conj] ++ simp only [map_mul, Complex.conj_I, Complex.conj_ofReal, mul_neg] ++ calc ∫ x, 𝐞 (-(x * y)) • conj (f (-x)) ++ = ∫ x, conj (𝐞 (x * y) • f (-x)) := by congr 1; ext x; exact h_conj x ++ _ = conj (∫ x, 𝐞 (x * y) • f (-x)) := integral_conj ++ _ = conj (∫ x, 𝐞 (-(x * y)) • f x) := by ++ rw [← integral_neg_eq_self (fun x => 𝐞 (-(x * y)) • f x)] ++ congr 2 with x; ring_nf ++ ++lemma auto_cheby_exists_smooth_nonneg_fourier_kernel : ++ ∃ (ψ : ℝ → ℂ), ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ ++ (∀ y, 0 ≤ (𝓕 ψ y).re ∧ (𝓕 ψ y).im = 0) ∧ 0 < (𝓕 ψ 0).re := by ++ obtain ⟨φ_real, hφSmooth, hφCompact, hφIcc, _, hφsupp⟩ := ++ smooth_urysohn_support_Ioo (a := 1/2) (b := 1) (c := 1) (d := 2) (by norm_num) (by norm_num) ++ let φ : ℝ → ℂ := Complex.ofReal ∘ φ_real ++ let φ_rev : ℝ → ℂ := fun x ↦ conj (φ (-x)) ++ let ψ_fun : ℝ → ℂ := convolution φ φ_rev (ContinuousLinearMap.mul ℂ ℂ) volume ++ have hφSmooth' : ContDiff ℝ ∞ φ := contDiff_ofReal.comp hφSmooth ++ have hφCompact' : HasCompactSupport φ := hφCompact.comp_left rfl ++ have hφRevSmooth : ContDiff ℝ ∞ φ_rev := Complex.conjCLE.contDiff.comp (hφSmooth'.comp contDiff_neg) ++ have hφRevCompact : HasCompactSupport φ_rev := (hφCompact'.comp_homeomorph (Homeomorph.neg ℝ)).comp_left (by simp) ++ have hφInt : Integrable φ := hφSmooth'.continuous.integrable_of_hasCompactSupport hφCompact' ++ have hφRevInt : Integrable φ_rev := hφRevSmooth.continuous.integrable_of_hasCompactSupport hφRevCompact ++ have hψSmooth : ContDiff ℝ ∞ ψ_fun := by ++ convert! hφRevCompact.contDiff_convolution_right (ContinuousLinearMap.mul ℝ ℂ) ++ (hφSmooth'.continuous.locallyIntegrable (μ := volume)) hφRevSmooth ++ have hψCompact : HasCompactSupport ψ_fun := ++ HasCompactSupport.convolution (ContinuousLinearMap.mul ℂ ℂ) hφCompact' hφRevCompact ++ refine ⟨ψ_fun, hψSmooth, hψCompact, fun y ↦ ?_, ?_⟩ ++ · rw [Real.fourierIntegral_convolution hφInt hφRevInt, Pi.mul_apply, ++ Real.fourierIntegral_conj_neg y, mul_comm, ← Complex.normSq_eq_conj_mul_self] ++ exact ⟨Complex.normSq_nonneg _, rfl⟩ ++ · have hφ_nonneg : ∀ x, 0 ≤ φ_real x := fun x ↦ by ++ have hx := hφIcc x; by_cases h : x ∈ Set.Icc (1:ℝ) 1 ++ · simp only [Set.indicator_of_mem h, Pi.one_apply] at hx; linarith ++ · simp only [Set.indicator_of_notMem h] at hx; exact hx ++ have hvol_supp : (1 : ENNReal) ≤ volume (Function.support φ_real) := by ++ have hsub : Set.Ico (1:ℝ) 2 ⊆ Function.support φ_real := fun x hx ↦ ++ hφsupp.symm ▸ Set.mem_Ioo.mpr ⟨by linarith [hx.1], hx.2⟩ ++ calc _ = volume (Set.Ico (1:ℝ) 2) := by simp [Real.volume_Ico]; norm_num ++ _ ≤ _ := volume.mono hsub ++ have hφint_pos : 0 < ∫ x, φ_real x := ++ (integral_pos_iff_support_of_nonneg_ae (.of_forall hφ_nonneg) ++ (hφSmooth.continuous.integrable_of_hasCompactSupport hφCompact)).2 ++ (lt_of_lt_of_le (by simp) hvol_supp) ++ have hFφ0_re : 0 < (𝓕 φ 0).re := by ++ simp only [φ, fourier_real_eq, mul_zero, neg_zero, AddChar.map_zero_eq_one, one_smul, ++ Function.comp_apply] ++ have hint : Integrable (fun x => (φ_real x : ℂ)) := ++ (hφSmooth.continuous.integrable_of_hasCompactSupport hφCompact).ofReal ++ calc (∫ x, (φ_real x : ℂ)).re = ∫ x, (φ_real x : ℂ).re := (integral_re hint).symm ++ _ = ∫ x, φ_real x := by simp only [Complex.ofReal_re] ++ _ > 0 := hφint_pos ++ rw [Real.fourierIntegral_convolution hφInt hφRevInt, Pi.mul_apply, ++ Real.fourierIntegral_conj_neg 0, mul_comm, ← Complex.normSq_eq_conj_mul_self] ++ exact Complex.normSq_pos.2 (fun h ↦ (ne_of_gt hFφ0_re) (by simp [h])) ++ ++lemma auto_cheby_fourier_summable (hpos : 0 ≤ f) (hf : ∀ σ', 1 < σ' → Summable (nterm f σ')) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ψ : ℝ → ℂ) (hψSmooth : ContDiff ℝ ∞ ψ) (hψCompact : HasCompactSupport ψ) ++ (hψpos : ∀ y, 0 ≤ (𝓕 ψ y).re ∧ (𝓕 ψ y).im = 0) (x : ℝ) (hx : 1 ≤ x) : ++ Summable fun n ↦ (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x)) := by ++ let ψCS : CS 2 ℂ := ⟨ψ, hψSmooth.of_le (by norm_cast), hψCompact⟩ ++ let S : ℝ → ℂ := fun σ' ↦ ∑' n, term (f · : ℕ → ℂ) σ' n * 𝓕 ψCS.toFun (1 / (2 * π) * Real.log (n / x)) ++ let Pole : ℝ → ℂ := fun σ' ↦ (A : ℂ) * (x ^ (1 - σ') : ℝ) * ++ ∫ u in Set.Ici (-Real.log x), (rexp (-u * (σ' - 1)) : ℂ) * 𝓕 (W21.ofCS2 ψCS).toFun (u / (2 * π)) ++ let RHS : ℝ → ℂ := fun σ' ↦ ∫ t : ℝ, G (σ' + t * I) * ψCS.toFun t * (x : ℂ) ^ (t * I) ++ have l2 := limiting_fourier_lim2 (A := A) (x := x) ψCS hx ++ have l3 := limiting_fourier_lim3 (G := G) hG ψCS hx ++ have haux : (fun σ' ↦ S σ' - Pole σ') =ᶠ[𝓝[>] 1] RHS := eventually_nhdsWithin_of_forall fun σ' hσ' ↦ by ++ simpa [S, Pole, RHS] using! limiting_fourier_aux hG' hf ψCS hx σ' hσ' ++ have hS_tendsto : Tendsto S (𝓝[>] 1) (𝓝 (RHS 1 + A * ∫ u in Set.Ici (-Real.log x), ++ 𝓕 (W21.ofCS2 ψCS).toFun (u / (2 * π)))) := by ++ convert! (l3.congr' haux.symm).add l2 using 1; ext σ'; simp [S, Pole] ++ have hbounded : BoundedAtFilter (𝓝[>] 1) (fun σ' ↦ ‖S σ'‖) := by ++ simp only [BoundedAtFilter] ++ let L := ‖RHS 1 + A * ∫ u in Set.Ici (-Real.log x), 𝓕 (W21.ofCS2 ψCS).toFun (u / (2 * π))‖ ++ have : ∀ᶠ σ' in 𝓝[>] 1, ‖S σ'‖ < L + 1 := ++ hS_tendsto.norm.eventually_lt tendsto_const_nhds (lt_add_one L) ++ exact Asymptotics.IsBigO.of_bound (L + 1) (by filter_upwards [this] with σ h; simpa using h.le) ++ let y : ℕ → ℝ := fun n ↦ (1 / (2 * π)) * Real.log (n / x) ++ let w : ℕ → ℝ := fun n ↦ (𝓕 ψCS.toFun (y n)).re ++ have hw : ∀ n, 0 ≤ w n := fun n ↦ (hψpos (y n)).1 ++ let rt : ℝ → ℕ → ℝ := fun σ n ↦ if n = 0 then 0 else f n / (n : ℝ) ^ σ * w n ++ have rt_nn σ n : 0 ≤ rt σ n := by ++ simp only [rt]; split_ifs with hn ++ · rfl ++ · exact mul_nonneg (div_nonneg (hpos n) (Real.rpow_pos_of_pos (Nat.cast_pos.mpr ++ (Nat.pos_of_ne_zero hn)) σ).le) (hw n) ++ have hS_eq σ' (hσ' : 1 < σ') : S σ' = ↑(∑' n, rt σ' n) := by ++ rw [Complex.ofReal_tsum]; apply tsum_congr; intro n ++ simp only [rt, term, LSeries.term, y, w, one_div, mul_inv_rev] ++ split_ifs with hn <;> simp only [hn, CharP.cast_eq_zero, Complex.ofReal_zero, zero_mul, ++ Complex.ofReal_mul, Complex.ofReal_div] ++ rw [Complex.ofReal_cpow (Nat.cast_nonneg n)]; congr 1 ++ exact Complex.ext rfl (hψpos _).2 ++ have hMono n : AntitoneOn (fun σ ↦ rt σ n) (Set.Ioi 1) := fun σ₁ _ σ₂ _ h ↦ by ++ simp only [rt]; split_ifs with hn; · rfl ++ apply mul_le_mul_of_nonneg_right _ (hw n) ++ apply div_le_div_of_nonneg_left (hpos n) (Real.rpow_pos_of_pos (Nat.cast_pos.mpr ++ (Nat.pos_of_ne_zero hn)) σ₁) ++ exact Real.rpow_le_rpow_of_exponent_le (Nat.one_le_cast.mpr (Nat.pos_of_ne_zero hn)) h ++ have hT_bdd : BoundedAtFilter (𝓝[>] 1) fun σ ↦ ∑' n, rt σ n := by ++ rw [BoundedAtFilter, Asymptotics.isBigO_iff] at hbounded ⊢ ++ obtain ⟨C, hC⟩ := hbounded ++ refine ⟨C, ?_⟩ ++ filter_upwards [hC, self_mem_nhdsWithin] with σ hnorm hσ ++ rw [hS_eq σ hσ] at hnorm; simpa using hnorm ++ have hSumm σ (hσ : 1 < σ) : Summable (rt σ ·) := by ++ simpa [rt, w, y] using limiting_fourier_variant_lim1_aux ψCS hpos hf hψpos σ hσ ++ have hSumm_1 : Summable (rt 1 ·) := by ++ let σ_seq : ℕ → ℝ := fun k ↦ 1 + 1 / ((k : ℝ) + 1) ++ have hσ_gt k : 1 < σ_seq k := by simp only [σ_seq, lt_add_iff_pos_right, one_div]; positivity ++ have h_tendsto : Tendsto σ_seq atTop (𝓝[>] 1) := by ++ rw [tendsto_nhdsWithin_iff] ++ refine ⟨?_, by filter_upwards with k; exact hσ_gt k⟩ ++ have : Tendsto (fun k : ℕ ↦ 1 / ((k : ℝ) + 1)) atTop (𝓝 0) := by ++ simp only [one_div]; exact (tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds).inv_tendsto_atTop ++ simpa [σ_seq] using tendsto_const_nhds.add this ++ have h_ptwise n : Tendsto (fun k ↦ rt (σ_seq k) n) atTop (𝓝 (rt 1 n)) := by ++ simp only [rt]; split_ifs with hn; · exact tendsto_const_nhds ++ refine ((tendsto_const_nhds.rpow (tendsto_nhdsWithin_iff.mp h_tendsto).1 (Or.inl ?_)).inv₀ ++ (by simp [hn])).const_mul (f n) |>.mul_const (w n) ++ exact (Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn)).ne' ++ obtain ⟨C, hC⟩ := Asymptotics.isBigO_iff.mp (hT_bdd.comp_tendsto h_tendsto) ++ refine summable_of_sum_range_le (c := C) (rt_nn 1) fun m ↦ le_of_tendsto (tendsto_finsetSum _ ++ fun i _ ↦ h_ptwise i) ?_ ++ filter_upwards [h_tendsto.eventually self_mem_nhdsWithin, hC] with k hk hCk ++ calc ∑ i ∈ Finset.range m, rt (σ_seq k) i ++ ≤ ∑' n, rt (σ_seq k) n := (hSumm _ hk).sum_le_tsum _ fun n _ ↦ rt_nn _ n ++ _ ≤ |∑' n, rt (σ_seq k) n| := le_abs_self _ ++ _ ≤ C := by simpa using hCk ++ rw [show (fun n ↦ (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x))) = ++ Complex.ofRealCLM ∘ (rt 1 ·) from ?_] ++ · exact hSumm_1.map Complex.ofRealCLM Complex.ofRealCLM.continuous ++ ext n; simp only [rt, Real.rpow_one, one_div, w, y, Function.comp_apply] ++ split_ifs with hn; · simp [hn] ++ have him0 : (𝓕 ψCS.toFun ((2 * π)⁻¹ * Real.log (n / x))).im = 0 := (hψpos _).2 ++ have hre_eq : 𝓕 ψCS.toFun ((2 * π)⁻¹ * Real.log (n / x)) = ++ Complex.ofReal ((𝓕 ψCS.toFun ((2 * π)⁻¹ * Real.log (n / x))).re) := by ++ rw [← Complex.re_add_im (𝓕 ψCS.toFun _), him0]; simp ++ conv_lhs => rw [show ψ = ψCS.toFun from rfl, hre_eq] ++ simp only [Complex.ofRealCLM_apply, Complex.ofReal_div, Complex.ofReal_mul, Complex.ofReal_natCast] ++ ++lemma auto_cheby_short_interval_bound (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (B : ℝ) (ψ : ℝ → ℂ) (hψSmooth : ContDiff ℝ ∞ ψ) (hψCompact : HasCompactSupport ψ) ++ (hψpos : ∀ y, 0 ≤ (𝓕 ψ y).re ∧ (𝓕 ψ y).im = 0) (hψ0 : 0 < (𝓕 ψ 0).re) ++ (hB_bound : ∀ x ≥ 1, ‖∑' n, f n / n * 𝓕 ψ (1 / (2 * Real.pi) * Real.log (n / x))‖ ≤ B) : ++ ∃ (ε : ℝ) (C : ℝ), ε > 0 ∧ ε < 1 ∧ C > 0 ∧ ∀ x ≥ 1, ++ ∑' n, (f n) * (Set.indicator (Set.Ioc ((1 - ε) * x) x) (fun _ ↦ 1) (n : ℝ)) ≤ C * x := by ++ have hF : Continuous (𝓕 ψ) := VectorFourier.fourierIntegral_continuous Real.continuous_fourierChar ++ (by continuity) (hψSmooth.continuous.integrable_of_hasCompactSupport hψCompact) ++ have hg : Continuous fun y ↦ (𝓕 ψ y).re := Complex.continuous_re.comp hF ++ obtain ⟨δ, hδpos, hball⟩ := Metric.mem_nhds_iff.1 <| ++ hg.continuousAt.preimage_mem_nhds (IsOpen.mem_nhds isOpen_Ioi (half_lt_self hψ0)) ++ let c := (𝓕 ψ 0).re / 2 ++ have hcpos : 0 < c := by dsimp only [c]; linarith ++ have h_psi_ge_c : ∀ y, |y| < δ → c ≤ (𝓕 ψ y).re := fun y hy ↦ (hball (mem_ball_zero_iff.mpr hy)).le ++ let ε := 1 - Real.exp (-2 * π * δ) ++ have hε : 0 < ε ∧ ε < 1 := by ++ have h1 : Real.exp (-2 * π * δ) < 1 := Real.exp_lt_one_iff.mpr (by nlinarith [Real.pi_pos]) ++ exact ⟨by simp only [ε]; linarith, by simp only [ε]; linarith [Real.exp_pos (-2 * π * δ)]⟩ ++ have hB_nonneg : 0 ≤ B := (norm_nonneg _).trans (hB_bound 1 le_rfl) ++ refine ⟨ε, B / c + 1, hε.1, hε.2, by positivity, fun x hx ↦ ?_⟩ ++ have h_summable : Summable fun n ↦ (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x)) := ++ auto_cheby_fourier_summable hpos hf hG hG' ψ hψSmooth hψCompact hψpos x hx ++ have hx_pos : 0 < x := by linarith ++ have h_sum_lower : c / x * ∑' n, f n * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (n : ℝ) ++ ≤ ∑' n, f n / n * (𝓕 ψ (1 / (2 * π) * Real.log (n / x))).re := by ++ rw [← tsum_mul_left] ++ refine Summable.tsum_le_tsum (fun n ↦ ?_) ?_ ?_ ++ · by_cases hn : (n : ℝ) ∈ Set.Ioc ((1 - ε) * x) x ++ · rw [Set.indicator_of_mem hn, Pi.one_apply, mul_one] ++ have hn_pos : 0 < (n : ℝ) := by nlinarith [hn.1, hε.2] ++ let y := (1 / (2 * π)) * Real.log (n / x) ++ have h_arg_small : |y| < δ := by ++ have h2pi : 0 < 2 * π := by linarith [Real.pi_pos] ++ simp only [y, abs_mul, abs_div, abs_one, abs_of_pos h2pi] ++ field_simp [ne_of_gt h2pi]; rw [mul_comm, abs_lt] ++ have h_log_lower : -2 * π * δ < Real.log (n / x) := by ++ rw [← Real.log_exp (-2 * π * δ), Real.log_lt_log_iff (Real.exp_pos _) (by positivity)] ++ have : Real.exp (-2 * π * δ) = 1 - ε := by simp only [ε]; ring ++ rw [this]; field_simp; exact hn.1 ++ have h_log_upper : Real.log (n / x) ≤ 0 := ++ Real.log_nonpos (by positivity) (div_le_one_of_le₀ hn.2 hx_pos.le) ++ constructor <;> nlinarith [Real.pi_pos] ++ have h1 : x⁻¹ ≤ (n : ℝ)⁻¹ := by rw [inv_le_inv₀ hx_pos hn_pos]; exact hn.2 ++ have h2 : c ≤ (𝓕 ψ y).re := h_psi_ge_c y h_arg_small ++ have hfn : 0 ≤ f n := hpos n ++ have hre : 0 ≤ (𝓕 ψ y).re := (hψpos y).1 ++ have hn_inv : 0 ≤ (n : ℝ)⁻¹ := inv_nonneg.mpr hn_pos.le ++ calc c / x * f n = c * x⁻¹ * f n := by rw [div_eq_mul_inv] ++ _ ≤ c * (n : ℝ)⁻¹ * f n := by gcongr ++ _ ≤ (𝓕 ψ y).re * (n : ℝ)⁻¹ * f n := by gcongr ++ _ = (n : ℝ)⁻¹ * (𝓕 ψ y).re * f n := by ring ++ _ = f n / n * (𝓕 ψ y).re := by ring ++ · rw [Set.indicator_of_notMem hn, mul_zero, mul_zero] ++ exact mul_nonneg (div_nonneg (hpos n) (Nat.cast_nonneg n)) (hψpos _).1 ++ · refine summable_of_hasFiniteSupport <| (Set.finite_le_nat ⌊x⌋₊).subset fun n hn ↦ ?_ ++ simp only [Function.mem_support, ne_eq, mul_eq_zero, not_or, Set.indicator_apply_ne_zero] at hn ++ exact Nat.le_floor hn.2.2.1.2 ++ · rw [← Complex.summable_ofReal]; convert h_summable using 1; ext n ++ rw [Complex.ofReal_mul, Complex.ofReal_div] ++ norm_cast ++ rw [Complex.ofReal_mul] ++ congr 1 ++ apply Complex.ext ++ · simp only [Complex.ofReal_re] ++ · simp only [Complex.ofReal_im]; exact (hψpos _).2.symm ++ have h_real_eq : ∑' n, f n / n * (𝓕 ψ (1 / (2 * π) * Real.log (n / x))).re = ++ (∑' n, (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x))).re := by ++ rw [Complex.re_tsum h_summable]; congr with n ++ rw [Complex.mul_re]; norm_cast; simp only [zero_mul, sub_zero] ++ calc ∑' n, f n * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (n : ℝ) ++ = x / c * (c / x * ∑' n, f n * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (n : ℝ)) := by ++ field_simp [ne_of_gt hcpos, ne_of_gt hx_pos] ++ _ ≤ x / c * B := by ++ gcongr; rw [h_real_eq] at h_sum_lower ++ exact h_sum_lower.trans ((Complex.re_le_norm _).trans (hB_bound x hx)) ++ _ = (B / c) * x := by field_simp [ne_of_gt hcpos] ++ _ ≤ (B / c + 1) * x := by nlinarith ++ ++lemma auto_cheby_bootstrap_induction (hpos : 0 ≤ f) ++ (h_short : ∃ (ε : ℝ) (C : ℝ), ε > 0 ∧ ε < 1 ∧ C > 0 ∧ ∀ x ≥ 1, ++ ∑' n, (f n) * (Set.indicator (Set.Ioc ((1 - ε) * x) x) (fun _ ↦ 1) (n : ℝ)) ≤ C * x) : ++ cheby f := by ++ obtain ⟨ε, C₀, hε, hε1, hC₀, h_bound⟩ := h_short ++ let C := C₀ / ε + f 0 + 1 ++ have hf0 : (0 : ℝ) ≤ f 0 := hpos 0 ++ have hdiv : 0 ≤ C₀ / ε := div_nonneg hC₀.le hε.le ++ have hC : 0 ≤ C := by linarith ++ refine ⟨C, fun n ↦ ?_⟩ ++ induction n using Nat.strong_induction_on with | h n ih => ++ rcases lt_or_ge n 2 with hn | hn ++ · interval_cases n ++ · simp [cumsum] ++ · simp only [cumsum, Finset.sum_range_one, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hf0, ++ Nat.cast_one, mul_one, C] ++ linarith ++ let x := (n : ℝ) - 1 ++ have hx : x ≥ 1 := by simp only [x, ge_iff_le, le_sub_iff_add_le]; norm_cast ++ let m := ⌊(1 - ε) * x⌋₊ + 1 ++ have hm_lt : m < n := by ++ simp only [m, x] ++ have h1 : (1 - ε) * (n - 1 : ℝ) < (n - 1 : ℕ) := by ++ calc (1 - ε) * (↑n - 1) < 1 * (↑n - 1) := by gcongr; linarith ++ _ = ↑n - 1 := by ring ++ _ = ↑(n - 1) := by simp [Nat.cast_sub (by omega : 1 ≤ n)] ++ have h2 : ⌊(1 - ε) * (n - 1 : ℝ)⌋₊ < n - 1 := ++ (Nat.floor_lt (mul_nonneg (by linarith) (by linarith : (0 : ℝ) ≤ n - 1))).mpr h1 ++ omega ++ have hm_gt : (m : ℝ) > (1 - ε) * x := by ++ simp only [m, Nat.cast_add, Nat.cast_one, gt_iff_lt] ++ exact Nat.lt_floor_add_one ((1 - ε) * x) ++ have h_decomp : cumsum (fun k ↦ ‖(f k : ℂ)‖) n = cumsum (fun k ↦ ‖(f k : ℂ)‖) m + ∑ k ∈ Finset.Ico m n, f k := by ++ simp only [cumsum, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (hpos _), ++ Finset.sum_range_add_sum_Ico _ (by omega : m ≤ n)] ++ have h_Ico : ∑ k ∈ Finset.Ico m n, f k ≤ C₀ * x := by ++ calc ∑ k ∈ Finset.Ico m n, f k ++ = ∑ k ∈ Finset.Ico m n, f k * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (k : ℝ) := by ++ refine Finset.sum_congr rfl fun k hk ↦ ?_ ++ have ⟨hkm, hkn⟩ := Finset.mem_Ico.mp hk ++ have hk_gt : (k : ℝ) > (1 - ε) * x := by linarith [hm_gt, (Nat.cast_le (α := ℝ)).mpr hkm] ++ have hk_le : (k : ℝ) ≤ x := by ++ have h1 : k ≤ n - 1 := Nat.le_pred_of_lt hkn ++ have h2 : (k : ℝ) ≤ (n - 1 : ℕ) := by exact_mod_cast h1 ++ simp only [Nat.cast_sub (by omega : 1 ≤ n), Nat.cast_one, x] at h2 ⊢; exact h2 ++ simp only [Set.indicator_of_mem (Set.mem_Ioc.mpr ⟨hk_gt, hk_le⟩), Pi.one_apply, mul_one] ++ _ ≤ ∑' k, f k * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (k : ℝ) := by ++ refine Summable.sum_le_tsum _ (fun k _ ↦ mul_nonneg (hpos k) (Set.indicator_nonneg (by simp) _)) ?_ ++ refine summable_of_hasFiniteSupport <| (Set.finite_le_nat ⌊x⌋₊).subset fun k hk ↦ ?_ ++ simp only [Function.mem_support, ne_eq, mul_eq_zero, not_or, Set.indicator_apply_ne_zero] at hk ++ exact Nat.le_floor hk.2.1.2 ++ _ ≤ C₀ * x := h_bound x hx ++ have hm_le : (m : ℝ) ≤ (1 - ε) * x + 1 := by ++ have hpos' : 0 ≤ (1 - ε) * x := mul_nonneg (by linarith) (by linarith : (0 : ℝ) ≤ x) ++ simp only [m, Nat.cast_add, Nat.cast_one] ++ linarith [Nat.floor_le hpos'] ++ have hnorm : ∀ k, ‖(f k : ℂ)‖ = f k := fun k ↦ by simp [abs_of_nonneg (hpos k)] ++ simp only [hnorm] at h_decomp ih ⊢ ++ calc cumsum f n = cumsum f m + ∑ k ∈ Finset.Ico m n, f k := h_decomp ++ _ ≤ C * m + C₀ * x := by linarith [ih m hm_lt, h_Ico] ++ _ ≤ C * ((1 - ε) * x + 1) + C₀ * x := by nlinarith [hC] ++ _ = (C * (1 - ε) + C₀) * x + C := by ring ++ _ ≤ C * x + C := by ++ have : C₀ ≤ C * ε := by ++ calc C₀ = (C₀ / ε) * ε := by field_simp [ne_of_gt hε] ++ _ ≤ (C₀ / ε + f 0 + 1) * ε := by gcongr; linarith [hpos 0] ++ _ = C * ε := by simp only [C] ++ nlinarith [hε, hε1, hx] ++ _ ≤ C * n := by simp only [x]; ring_nf; linarith [hC] ++ ++lemma auto_cheby (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : cheby f := by ++ obtain ⟨ψ_fun, hψSmooth, hψCompact, hψpos, hψ0⟩ := auto_cheby_exists_smooth_nonneg_fourier_kernel ++ obtain ⟨B, hB⟩ := crude_upper_bound hpos hG hG' hf ⟨ψ_fun, hψSmooth.of_le ENat.LEInfty.out, hψCompact⟩ hψpos ++ exact auto_cheby_bootstrap_induction hpos <| auto_cheby_short_interval_bound hpos hf hG hG' B ψ_fun ++ hψSmooth hψCompact hψpos hψ0 fun x hx ↦ hB x (by linarith) ++ ++theorem WienerIkeharaTheorem'' (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun N => cumsum f N / N) atTop (𝓝 A) := ++ WienerIkeharaTheorem' hpos hf (auto_cheby (f := f) (A := A) (G := G) hpos hf hG hG') hG hG' ++ ++end auto_cheby ++ ++theorem WeakPNT_character ++ {q a : ℕ} (hq : q ≥ 1) (ha : Nat.Coprime a q) (ha' : a < q) {s : ℂ} (hs : 1 < s.re) : ++ LSeries (fun n ↦ if n % q = a then Λ n else 0) s = ++ - (∑' χ : DirichletCharacter ℂ q, ++ ((starRingEnd ℂ) (χ a) * ((deriv (LSeries (fun n:ℕ ↦ χ n)) s)) / ++ (LSeries (fun n:ℕ ↦ χ n) s))) / (Nat.totient q : ℂ) := by ++ have : NeZero q := ⟨by omega⟩ ++ convert vonMangoldt.LSeries_residueClass_eq ((ZMod.isUnit_iff_coprime a q).mpr ha) hs using 1 ++ · congr with n ++ have : n % q = a ↔ (n : ZMod q) = a := by ++ rw [ZMod.natCast_eq_natCast_iff', Nat.mod_eq_of_lt ha'] ++ simp [this] ++ split_ifs <;> simp [*] ++ · rw [div_eq_inv_mul, neg_mul_comm, tsum_fintype] ++ congr 3 with χ ++ rw [DirichletCharacter.deriv_LFunction_eq_deriv_LSeries _ hs, ++ DirichletCharacter.LFunction_eq_LSeries _ hs, mul_div] ++ congr 2 ++ rw [starRingEnd_apply, MulChar.star_apply', MulChar.inv_apply_eq_inv', ++ ← ZMod.coe_unitOfCoprime a ha, ZMod.inv_coe_unit, map_units_inv] ++ ++theorem WeakPNT_AP_prelim {q : ℕ} {a : ℕ} (hq : q ≥ 1) (ha : Nat.Coprime a q) (ha' : a < q) : ++ ∃ G: ℂ → ℂ, (ContinuousOn G {s | 1 ≤ s.re}) ∧ ++ (Set.EqOn G (fun s ↦ LSeries (fun n ↦ if n % q = a then Λ n else 0) s - 1 / ++ ((Nat.totient q) * (s - 1))) {s | 1 < s.re}) := by ++ have : NeZero q := NeZero.of_pos hq ++ have hG : ∃ G : ℂ → ℂ, ContinuousOn G {s | 1 ≤ s.re} ∧ Set.EqOn G ++ (fun s ↦ LSeries (fun n ↦ if (n : ZMod q) = a then Λ n else 0) s - (q.totient : ℂ)⁻¹ / (s - 1)) {s | 1 < s.re} := by ++ use vonMangoldt.LFunctionResidueClassAux (a : ZMod q), vonMangoldt.continuousOn_LFunctionResidueClassAux (q := q) (a := a) ++ have := vonMangoldt.eqOn_LFunctionResidueClassAux ((ZMod.isUnit_iff_coprime a q).mpr ha) ++ convert this using 6; split <;> simp_all ++ convert hG using 6 ++ · simp [ZMod.natCast_eq_natCast_iff', Nat.mod_eq_of_lt ha'] ++ · rw [inv_eq_one_div, div_div] ++ ++lemma summable_vonMangoldt_div_rpow {s : ℝ} (hs : 1 < s) : Summable (fun n ↦ Λ n / n ^ s) := by ++ have h_log_bound : ∀ n : ℕ, (Λ n : ℝ) ≤ Real.log n := fun n ↦ vonMangoldt_le_log ++ suffices h_log_sum : Summable fun n : ℕ ↦ Real.log n / (n : ℝ) ^ s by ++ exact .of_nonneg_of_le (fun n ↦ div_nonneg vonMangoldt_nonneg (by positivity)) ++ (fun n ↦ div_le_div_of_nonneg_right (h_log_bound n) (by positivity)) h_log_sum ++ have h_log_le_n_eps : ∀ ε > 0, ∃ C > 0, ∀ n : ℕ, n ≥ 2 → Real.log n / (n : ℝ) ^ s ≤ C * (n : ℝ) ^ (ε - s) := by ++ intro ε hε_pos ++ obtain ⟨C, hC_pos, hC⟩ : ∃ C > 0, ∀ n : ℕ, n ≥ 2 → Real.log n ≤ C * (n : ℝ) ^ ε := by ++ refine ⟨1 / ε, by positivity, fun n hn ↦ ?_⟩ ++ have := log_le_sub_one_of_pos (by positivity : 0 < (n : ℝ) ^ ε) ++ rw [log_rpow (by positivity)] at this ++ nlinarith [rpow_pos_of_pos (by positivity : 0 < (n : ℝ)) ε, mul_div_cancel₀ 1 hε_pos.ne'] ++ refine ⟨C, hC_pos, fun n hn ↦ ?_⟩ ++ rw [rpow_sub (by positivity)] ++ exact le_trans (div_le_div_of_nonneg_right (hC n hn) (by positivity)) (by rw [div_eq_mul_inv]; ring_nf; norm_num) ++ obtain ⟨C, _, hC⟩ : ∃ C > 0, ∀ n : ℕ, n ≥ 2 → Real.log n / (n : ℝ) ^ s ≤ C * (n : ℝ) ^ ((s - 1) / 2 - s) := ++ h_log_le_n_eps ((s - 1) / 2) (by linarith) ++ rw [← summable_nat_add_iff 2] ++ exact Summable.of_nonneg_of_le (fun n ↦ div_nonneg (log_nonneg (by norm_cast; omega)) ++ (rpow_nonneg (by positivity) _)) (fun n ↦ hC _ (by omega)) (Summable.mul_left _ <| by ++ simpa using summable_nat_add_iff 2 |>.2 <| summable_nat_rpow.2 <| by linarith) ++ ++theorem WeakPNT_AP {q : ℕ} {a : ℕ} (hq : q ≥ 1) (ha : a.Coprime q) (ha' : a < q) : ++ Tendsto (fun N ↦ cumsum (fun n ↦ if n % q = a then Λ n else 0) N / N) atTop (𝓝 (1 / q.totient)) := by ++ have h_summable : ∀ s : ℝ, 1 < s → Summable (fun n ↦ (if n % q = a then Λ n else 0) / n ^ s) := by ++ intro s hs ++ refine .of_nonneg_of_le (fun n ↦ ?_) (fun n ↦ ?_) (summable_vonMangoldt_div_rpow hs) ++ · split_ifs <;> positivity ++ · split_ifs <;> norm_num; exact div_nonneg vonMangoldt_nonneg (by positivity) ++ obtain ⟨G, hG₁, hG₂⟩ := WeakPNT_AP_prelim hq ha ha' ++ convert WienerIkeharaTheorem'' _ _ _ _ using 1 ++ · use G ++ · intro n ++ simp_all only [ge_iff_le, one_div, mul_inv_rev, Pi.ofNat_apply] ++ split ++ next h => subst h; simp_all only [vonMangoldt_nonneg] ++ next h => simp_all only [le_refl] ++ · intro σ' hσ' ++ specialize h_summable σ' hσ' ++ simp_all only [ge_iff_le, one_div, mul_inv_rev] ++ convert h_summable using 1 ++ ext ++ simp only [nterm, norm_real, norm_eq_abs] ++ ring_nf ++ split_ifs <;> simp [*, mul_comm] ++ · assumption ++ · convert hG₂ using 3 ++ · exact tsum_congr fun n ↦ by cases n <;> aesop ++ · norm_num [div_eq_mul_inv, mul_assoc, mul_comm, mul_left_comm] ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/ZetaBounds.lean b/PrimeNumberTheoremAnd/Erdos970/ZetaBounds.lean +new file mode 100644 +index 0000000..84113af +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/ZetaBounds.lean +@@ -0,0 +1,2982 @@ ++import Batteries.Tactic.Lemma ++import Mathlib.MeasureTheory.Function.Floor ++import Mathlib.MeasureTheory.Order.Group.Lattice ++import Mathlib.NumberTheory.Harmonic.Bounds ++import Mathlib.NumberTheory.LSeries.Nonvanishing ++import PrimeNumberTheoremAnd.Erdos970.Auxiliary ++import PrimeNumberTheoremAnd.Erdos970.Fourier ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Analysis.SpecialFunctions.Log.Basic ++import PrimeNumberTheoremAnd.Erdos970.ResidueCalcOnRectangles ++import PrimeNumberTheoremAnd.Erdos970.EulerMaclaurin ++ ++namespace Erdos970 ++ ++ ++open _root_.Complex Topology Filter Interval _root_.Set Asymptotics ++ ++lemma div_cpow_eq_cpow_neg (a x s : ℂ) : a / x ^ s = a * x ^ (-s) := by ++ rw [div_eq_mul_inv, cpow_neg] ++ ++lemma one_div_cpow_eq_cpow_neg (x s : ℂ) : 1 / x ^ s = x ^ (-s) := by ++ convert div_cpow_eq_cpow_neg 1 x s using 1; simp ++ ++lemma div_rpow_eq_rpow_neg (a x s : ℝ) (hx : 0 ≤ x) : a / x ^ s = a * x ^ (-s) := by ++ rw [div_eq_mul_inv, Real.rpow_neg hx] ++ ++lemma div_rpow_neg_eq_rpow_div {x y s : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y) : ++ x ^ (-s) / y ^ (-s) = (y / x) ^ s := by ++ rw [div_eq_mul_inv, Real.rpow_neg hx, Real.rpow_neg hy, Real.div_rpow hy hx]; field_simp ++ ++lemma div_rpow_eq_rpow_div_neg {x y s : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y) : ++ x ^ s / y ^ s = (y / x) ^ (-s) := by ++ convert div_rpow_neg_eq_rpow_div (s := -s) hx hy using 1; simp only [neg_neg] ++ ++local notation (name := riemannzeta) "ζ" => riemannZeta ++local notation (name := derivriemannzeta) "ζ'" => deriv riemannZeta ++ ++theorem ResidueOfTendsTo {f : ℂ → ℂ} {p : ℂ} {U : Set ℂ} ++ (hU : U ∈ 𝓝 p) ++ (hf : HolomorphicOn f (U \ {p})) ++ {A : ℂ} ++ (h_limit : Tendsto (fun s ↦ (s - p) * f s) (𝓝[≠] p) (𝓝 A)) : ++ ∃ V ∈ 𝓝 p, ++ BddAbove (norm ∘ (f - fun s ↦ A * (s - p)⁻¹) '' (V \ {p})) := by ++ ++ have h_event : ∀ᶠ s in 𝓝[≠] p, ‖(s - p) * f s - A‖ < 1 := by ++ simp_rw [← dist_eq_norm_sub] ++ exact h_limit.eventually (Metric.ball_mem_nhds _ (by norm_num)) ++ have h_event_nhds : ++ ∀ᶠ s in 𝓝 p, s ≠ p → ‖(s - p) * f s - A‖ < 1 := by ++ exact (eventually_nhdsWithin_iff).1 h_event ++ rcases (eventually_nhds_iff.1 h_event_nhds) with ⟨V₀, hV₀_mem, hV₀_prop⟩ ++ have h_bound : ++ ∀ s, s ∈ V₀ \ {p} → ‖(s - p) * f s‖ ≤ ‖A‖ + 1 := by ++ intro s hs ++ rcases hs with ⟨hV₀, hsne⟩ ++ calc ‖(s - p) * f s‖ = ‖((s - p) * f s - A) + A‖ := by ++ ring_nf ++ _ ≤ ‖(s - p) * f s - A‖ + ‖A‖ := norm_add_le ((s - p) * f s - A) A ++ _ ≤ 1 + ‖A‖ := add_le_add_left (le_of_lt (hV₀_mem s hV₀ hsne)) ‖A‖ ++ _ = ‖A‖ + 1 := add_comm 1 ‖A‖ ++ have h_bdd : ++ BddAbove (norm ∘ (fun s ↦ (s - p) * f s) '' (V₀ \ {p})) := by ++ refine ⟨‖A‖ + 1, ?_⟩ ++ rintro _ ⟨s, hs, rfl⟩ ++ exact h_bound s hs ++ ++ set W : Set ℂ := V₀ ∩ U with hW_def ++ have hW_mem : (W : Set ℂ) ∈ 𝓝 p := inter_mem (IsOpen.mem_nhds hV₀_prop.1 hV₀_prop.2) hU ++ have h_subset_V₀ : (W \ {p}) ⊆ (V₀ \ {p}) := by ++ intro z hz; exact ⟨hz.1.1, hz.2⟩ ++ have h_prod_holo : HolomorphicOn (fun z ↦ (z - p) * f z) (W \ {p}) := by ++ have h_id : HolomorphicOn (fun z : ℂ ↦ z - p) (W \ {p}) := ++ Differentiable.differentiableOn (Differentiable.sub_const differentiable_fun_id p) ++ have hfW : HolomorphicOn f (W \ {p}) := by ++ apply hf.mono ++ exact Set.sdiff_subset_sdiff_left inter_subset_right ++ simpa using! h_id.mul hfW ++ have h_bdd_W : BddAbove (norm ∘ (fun s ↦ (s - p) * f s) '' (W \ {p})) := ++ h_bdd.mono (image_mono h_subset_V₀) ++ ++ obtain ⟨g, hg_holo, hg_eq⟩ := ++ existsDifferentiableOn_of_bddAbove hW_mem h_prod_holo h_bdd_W ++ have h_event_eq : ++ (fun z ↦ g z) =ᶠ[𝓝[≠] p] fun z ↦ (z - p) * f z := by ++ have hW_diff_mem : (W \ {p} : Set ℂ) ∈ 𝓝[≠] p := ++ sdiff_mem_nhdsWithin_compl hW_mem {p} ++ exact (hg_eq.eventuallyEq_of_mem hW_diff_mem).symm ++ have h_tendsto_gA : Tendsto g (𝓝[≠] p) (𝓝 A) := ++ h_limit.congr' (id (EventuallyEq.symm h_event_eq)) ++ have hpW : p ∈ W := by ++ exact mem_of_mem_nhds hW_mem ++ have h_cont_g : ContinuousAt g p := by ++ apply (hg_holo.continuousOn.continuousWithinAt hpW).continuousAt hW_mem ++ have h_tendsto_gp : Tendsto g (𝓝[≠] p) (𝓝 (g p)) := ++ h_cont_g.tendsto.mono_left inf_le_left ++ have g_p_eq : g p = A := ++ tendsto_nhds_unique' (NormedField.nhdsNE_neBot p) h_tendsto_gp h_tendsto_gA ++ let q : ℂ → ℂ := fun z ↦ (g z - A) / (z - p) ++ have h_deriv : HasDerivAt g (deriv g p) p := by ++ exact DifferentiableOn.hasDerivAt hg_holo hW_mem ++ have h_q_limit : Tendsto q (𝓝[≠] p) (𝓝 (deriv g p)) := by ++ rw [hasDerivAt_iff_tendsto_slope] at h_deriv ++ unfold slope at h_deriv ++ simp only [vsub_eq_sub, smul_eq_mul, inv_mul_eq_div, g_p_eq] at h_deriv ++ exact h_deriv ++ have h_event_q : ∀ᶠ z in 𝓝[≠] p, ‖q z - deriv g p‖ < 1 := by ++ simp_rw [← dist_eq_norm_sub] ++ exact h_q_limit.eventually (Metric.ball_mem_nhds _ (by norm_num)) ++ have h_event_q_nhds : ∀ᶠ z in 𝓝 p, z ≠ p → ‖q z - deriv g p‖ < 1 := by ++ simpa using (eventually_nhdsWithin_iff).1 h_event_q ++ rcases (eventually_nhds_iff.1 h_event_q_nhds) with ++ ⟨V₁, hV₁_mem, hV₁_prop⟩ ++ have h_q_bound : ++ ∀ z, z ∈ V₁ \ {p} → ‖q z‖ ≤ ‖deriv g p‖ + 1 := by ++ intro z hz ++ rcases hz with ⟨hV₁, hz_ne⟩ ++ calc ‖q z‖ = ‖(q z - deriv g p) + (deriv g p)‖ := by ++ ring_nf ++ _ ≤ ‖q z - deriv g p‖ + ‖deriv g p‖ := norm_add_le (q z - deriv g p) (deriv g p) ++ _ ≤ 1 + ‖deriv g p‖ := add_le_add_left (le_of_lt (hV₁_mem z hV₁ hz_ne)) ‖deriv g p‖ ++ _ = ‖deriv g p‖ + 1 := add_comm 1 ‖deriv g p‖ ++ ++ have h_eq_diff : ++ EqOn (fun z ↦ f z - A * (z - p)⁻¹) q (W \ {p}) := by ++ intro z hz ++ simp only ++ have hz_ne : (z - p) ≠ 0 := sub_ne_zero.mpr hz.2 ++ have hgz : g z = (z - p) * f z := by ++ exact id (EqOn.symm hg_eq) hz ++ simp only [hgz, q] ++ field_simp ++ apply IsBigO_to_BddAbove ++ rw [isBigO_iff] ++ use ‖deriv g p‖ + 1 ++ apply eventually_nhdsWithin_iff.mpr ++ filter_upwards [IsOpen.mem_nhds hV₁_prop.1 hV₁_prop.2, hW_mem] with z hV₁ hW z_ne_p ++ specialize h_eq_diff ⟨ hW, z_ne_p⟩ ++ simp only [Pi.sub_apply, Pi.one_apply, one_mem, CStarRing.norm_of_mem_unitary, ++ mul_one] at h_eq_diff ⊢ ++ rw [h_eq_diff] ++ exact h_q_bound _ ⟨hV₁, z_ne_p⟩ ++ ++theorem analyticAt_riemannZeta {s : ℂ} (s_ne_one : s ≠ 1) : ++ AnalyticAt ℂ riemannZeta s := by ++ apply Complex.analyticAt_iff_eventually_differentiableAt.mpr ++ filter_upwards [eventually_ne_nhds s_ne_one] with z hz using differentiableAt_riemannZeta hz ++ ++theorem differentiableAt_deriv_riemannZeta {s : ℂ} (s_ne_one : s ≠ 1) : ++ DifferentiableAt ℂ ζ' s := by ++ exact (analyticAt_riemannZeta s_ne_one).deriv.differentiableAt ++ ++theorem riemannZetaResidue : ++ ∃ U ∈ 𝓝 1, BddAbove (norm ∘ (ζ - (fun s ↦ (s - 1)⁻¹)) '' (U \ {1})) := by ++ have zeta_holc : HolomorphicOn ζ (univ \ {1}) := by ++ intro y hy ++ exact DifferentiableAt.differentiableWithinAt <| differentiableAt_riemannZeta hy.2 ++ convert ResidueOfTendsTo univ_mem zeta_holc riemannZeta_residue_one using 6 ++ simp ++ ++theorem deriv_eqOn_of_eqOn_punctured (f g : ℂ → ℂ) (U : Set ℂ) (p : ℂ) ++ (hU_open : IsOpen U) ++ (h_eq : EqOn f g (U \ {p})) : ++ EqOn (deriv f) (deriv g) (U \ {p}) := by ++ intro x hx ++ apply EventuallyEq.deriv_eq ++ filter_upwards [IsOpen.mem_nhds (hU_open.sdiff isClosed_singleton) hx] with t ht using h_eq ht ++ ++theorem analytic_deriv_bounded_near_point ++ (f : ℂ → ℂ) {U : Set ℂ} {p : ℂ} (hU : IsOpen U) (hp : p ∈ U) (hf : HolomorphicOn f U) : ++ (deriv f) =O[𝓝[≠] p] (1 : ℂ → ℂ) := by ++ have U_in_filter : U ∈ 𝓝 p := by ++ exact IsOpen.mem_nhds hU hp ++ have T := (analyticOn_iff_differentiableOn hU).mpr hf ++ have T2 : ContDiffOn ℂ 1 f U := ++ DifferentiableOn.contDiffOn hf hU ++ have T3 : ContinuousOn (fun x ↦ ((deriv f) x)) U := by ++ apply T2.continuousOn_deriv_of_isOpen hU (by simp) ++ have T4 := T3.continuousAt U_in_filter ++ have T5 : (deriv f) =O[𝓝 p] (1 : ℂ → ℂ) := ++ T4.norm.isBoundedUnder_le.isBigO_one ℂ ++ exact Asymptotics.IsBigO.mono T5 inf_le_left ++ ++theorem derivative_const_plus_product {g : ℂ → ℂ} (A p x : ℂ) (hg : DifferentiableAt ℂ g x) : ++ deriv ((fun _ ↦ A) + g * fun s ↦ s - p) x = deriv g x * (x - p) + g x := by ++ rw [deriv_add (by fun_prop) (by fun_prop), deriv_const, deriv_mul hg (by fun_prop)] ++ simp ++ ++lemma deriv_inv_sub {x p : ℂ} (hp : x ≠ p) : ++ deriv (fun z => (z - p)⁻¹) x = -((x - p) ^ 2)⁻¹ := by ++ rw [deriv_fun_inv'' (by fun_prop) (by grind)] ++ simp ++ field ++ ++theorem deriv_f_minus_A_inv_sub_clean (f : ℂ → ℂ) (A x p : ℂ) ++ (hf : DifferentiableAt ℂ f x) (hp : x ≠ p) : ++ deriv (f - (fun z ↦ A * (z - p)⁻¹)) x = deriv f x + A * ((x - p) ^ 2)⁻¹ := by ++ have h1 : DifferentiableAt ℂ (fun z => (z - p)⁻¹) x := by ++ fun_prop (disch := grind) ++ rw [deriv_sub hf (h1.const_mul A), deriv_const_mul A h1, deriv_inv_sub hp] ++ ring ++ ++theorem nonZeroOfBddAbove {f : ℂ → ℂ} {p : ℂ} {U : Set ℂ} ++ (U_in_nhds : U ∈ 𝓝 p) {A : ℂ} (A_ne_zero : A ≠ 0) ++ (f_near_p : BddAbove (norm ∘ (f - fun s ↦ A * (s - p)⁻¹) '' (U \ {p}))) : ++ ∃ V ∈ 𝓝 p, IsOpen V ∧ ∀ s ∈ V \ {p}, f s ≠ 0 := by ++ ++ have h_decomp : ∀ s, f s = (f s - A * (s - p)⁻¹) + A * (s - p)⁻¹ := by ++ intro s ++ ring ++ ++ obtain ⟨M, hM⟩ := f_near_p ++ ++ have A_norm_pos : 0 < ‖A‖ := norm_pos_iff.mpr A_ne_zero ++ ++ let δ := ‖A‖ / (‖M‖ + 1) ++ have δ_pos : 0 < δ := by ++ refine div_pos A_norm_pos (add_pos_of_nonneg_of_pos (norm_nonneg M) one_pos) ++ ++ obtain ⟨V, hV_open, hV_mem, hV_sub⟩ : ∃ V, IsOpen V ∧ p ∈ V ∧ V ⊆ U ∩ Metric.ball p δ := by ++ ++ obtain ⟨W, hW_sub, hW_open, hW_mem⟩ := mem_nhds_iff.mp U_in_nhds ++ let V := W ∩ Metric.ball p δ ++ have VNp : V ∈ 𝓝 p := (𝓝 p).inter_mem (IsOpen.mem_nhds hW_open hW_mem) ++ (Metric.ball_mem_nhds p δ_pos) ++ exact ⟨V, IsOpen.inter hW_open Metric.isOpen_ball, mem_of_mem_nhds VNp, ++ inter_subset_inter_left _ hW_sub⟩ ++ use V, mem_nhds_iff.mpr ⟨V, subset_refl V, hV_open, hV_mem⟩, hV_open ++ ++ intro s hs ++ have hs_in_U : s ∈ U := hV_sub hs.1 |>.1 ++ have hs_near_p : dist s p < δ := hV_sub hs.1 |>.2 ++ have hs_ne_p : s ≠ p := hs.2 ++ ++ rw [h_decomp s] ++ ++ have bound_first : ‖f s - A * (s - p)⁻¹‖ ≤ M := by ++ apply hM ++ exact ⟨s, ⟨hs_in_U, hs_ne_p⟩, rfl⟩ ++ ++ have large_second : ‖M‖ + 1 < ‖A * (s - p)⁻¹‖ := by ++ rw [norm_mul, norm_inv, ← div_eq_mul_inv] ++ rw [lt_div_iff₀ (norm_pos_iff.mpr (sub_ne_zero.mpr hs_ne_p))] ++ rw [mul_comm, ← lt_div_iff₀ (add_pos_of_nonneg_of_pos (norm_nonneg M) one_pos)] ++ rw [dist_eq_norm_sub] at hs_near_p ++ exact hs_near_p ++ ++ by_contra h_zero ++ ++ rw [add_eq_zero_iff_eq_neg] at h_zero ++ rw [h_zero, norm_neg] at bound_first ++ ++ have : ‖M‖ + 1 < ‖M‖ := (lt_of_lt_of_le (lt_of_lt_of_le large_second bound_first) ++ (Real.le_norm_self M)) ++ norm_num at this ++ ++theorem logDerivResidue' {f : ℂ → ℂ} {p : ℂ} {U : Set ℂ} ++ (U_is_open : IsOpen U) ++ (non_zero : ∀ x ∈ U \ {p}, f x ≠ 0) ++ (holc : HolomorphicOn f (U \ {p})) ++ (U_in_nhds : U ∈ 𝓝 p) {A : ℂ} (A_ne_zero : A ≠ 0) ++ (f_near_p : BddAbove (norm ∘ (f - fun s ↦ A * (s - p)⁻¹) '' (U \ {p}))) : ++ (deriv f * f⁻¹ + (fun s ↦ (s - p)⁻¹)) =O[𝓝[≠] p] (1 : ℂ → ℂ) := by ++ ++ have simpleHolo : HolomorphicOn (fun s ↦ A / (s - p)) (U \ {p}) := by ++ apply DifferentiableOn.mono (t := {p}ᶜ) ++ · apply DifferentiableOn.div ++ · exact differentiableOn_const _ ++ · exact DifferentiableOn.sub differentiableOn_id (differentiableOn_const _) ++ · exact fun x hx => by rw [sub_ne_zero]; exact hx ++ · rintro s ⟨_, hs⟩ ; exact hs ++ ++ have f_minus_pole_is_holomorphic : HolomorphicOn (f - (fun s ↦ A * (s - p)⁻¹)) (U \ {p}) := by ++ exact (DifferentiableOn.sub_iff_right holc).mpr simpleHolo ++ ++ let ⟨g, ⟨g_is_holomorphic, g_is_f_minus_pole⟩⟩ := existsDifferentiableOn_of_bddAbove ++ U_in_nhds f_minus_pole_is_holomorphic f_near_p ++ ++ let h := (fun _ ↦ A) + g * (fun (s : ℂ) ↦ (s - p)) ++ ++ have linear_is_holomorphic : HolomorphicOn (fun (s : ℂ ) ↦ (s - p)) U := by ++ exact DifferentiableOn.sub_const differentiableOn_id p ++ ++ have h_is_holomorphic : HolomorphicOn h U := by ++ have T := DifferentiableOn.mul g_is_holomorphic linear_is_holomorphic ++ exact DifferentiableOn.const_add A T ++ ++ have h_continuous : ContinuousOn h U := ++ by exact DifferentiableOn.continuousOn h_is_holomorphic ++ ++ have deriv_h_identity : ∀x ∈ (U \ {p}), (deriv h) x = f x + (deriv f x) * (x - p) := by ++ intro x x_in_u_not_p ++ have x_in_u : x ∈ U := by exact Set.mem_of_mem_sdiff x_in_u_not_p ++ have x_not_p : x ≠ p := by ++ exact ((Set.mem_sdiff x).mp x_in_u_not_p).2 ++ ++ have weird : U ∈ 𝓝 x := by ++ exact IsOpen.mem_nhds (U_is_open) (x_in_u) ++ ++ rw [derivative_const_plus_product, ← g_is_f_minus_pole x_in_u_not_p, ++ ← deriv_eqOn_of_eqOn_punctured _ _ U p U_is_open g_is_f_minus_pole x_in_u_not_p, ++ deriv_f_minus_A_inv_sub_clean] ++ · simp only [Pi.sub_apply] ++ have := sub_ne_zero_of_ne x_not_p ++ field_simp ++ ring ++ · apply holc.differentiableAt ++ exact Filter.inter_mem weird <| compl_singleton_mem_nhds x_not_p ++ · exact x_not_p ++ · exact g_is_holomorphic.differentiableAt weird ++ have h_identity : ∀x ∈ (U \ {p}), h x = (f x) * (x - p) := by ++ intro x x_in_u_not_p ++ have hyp_x_not_p : x ≠ p := by ++ exact ((Set.mem_sdiff x).mp x_in_u_not_p).2 ++ simp only [h, Pi.add_apply, Pi.mul_apply] ++ rw [← g_is_f_minus_pole x_in_u_not_p] ++ simp only [Pi.sub_apply] ++ field [sub_ne_zero.mpr hyp_x_not_p] ++ have log_deriv_f_plus_pole_equal_log_deriv_h : ++ EqOn (deriv f * f⁻¹ + fun s ↦ (s - p)⁻¹) ((deriv h) * h⁻¹) (U \ {p}) := by ++ simp only [Set.mem_sdiff, mem_singleton_iff, ne_eq, and_imp, Function.comp_apply, Pi.sub_apply, ++ DifferentiableOn.sub_iff_right, differentiableOn_const, DifferentiableOn.fun_sub_iff_left, ++ holc] at * ++ intro x hyp_x ++ have x_not_p : x ≠ p := by ++ exact ((Set.mem_sdiff x).mp hyp_x).2 ++ have x_in_u : x ∈ U := by exact Set.mem_of_mem_sdiff hyp_x ++ simp only [Pi.add_apply, Pi.mul_apply, Pi.inv_apply] ++ rw [deriv_h_identity _ x_in_u x_not_p, h_identity _ x_in_u x_not_p] ++ ++ field [sub_ne_zero.mpr x_not_p, non_zero x (x_in_u) x_not_p] ++ have h_inv_bounded : ++ h⁻¹ =O[𝓝[≠] p] (1 : ℂ → ℂ) := by ++ have : ContinuousAt h⁻¹ p := by ++ apply ContinuousOn.continuousAt h_continuous U_in_nhds |>.inv₀ ++ simp [h, A_ne_zero] ++ exact Asymptotics.IsBigO.mono (this.norm.isBoundedUnder_le.isBigO_one ℂ) inf_le_left ++ ++ have h_deriv_bounded : ++ (deriv h) =O[𝓝[≠] p] (1 : ℂ → ℂ) := ++ analytic_deriv_bounded_near_point h U_is_open ++ (by exact mem_of_mem_nhds U_in_nhds) h_is_holomorphic ++ ++ have h_log_deriv_bounded : ++ ((deriv h) * h⁻¹) =O[𝓝[≠] p] (1 : ℂ → ℂ) := by ++ have T := Asymptotics.IsBigO.mul h_deriv_bounded h_inv_bounded ++ exact IsBigO.of_const_mul_right T ++ ++ have u_not_p_in_filter : U \ {p} ∈ 𝓝[≠] p := by ++ exact sdiff_mem_nhdsWithin_compl U_in_nhds {p} ++ have T := Set.EqOn.eventuallyEq_of_mem log_deriv_f_plus_pole_equal_log_deriv_h u_not_p_in_filter ++ exact EventuallyEq.trans_isBigO T h_log_deriv_bounded ++ ++theorem logDerivResidue {f : ℂ → ℂ} {p : ℂ} {U : Set ℂ} ++ (non_zero : ∀ x ∈ U \ {p}, f x ≠ 0) ++ (holc : HolomorphicOn f (U \ {p})) ++ (U_in_nhds : U ∈ 𝓝 p) {A : ℂ} (A_ne_zero : A ≠ 0) ++ (f_near_p : BddAbove (norm ∘ (f - fun s ↦ A * (s - p)⁻¹) '' (U \ {p}))) : ++ (deriv f * f⁻¹ + (fun s ↦ (s - p)⁻¹)) =O[𝓝[≠] p] (1 : ℂ → ℂ) := ++ by ++ let ⟨U', ⟨a,b,c⟩⟩ := mem_nhds_iff.mp U_in_nhds ++ have W : (U' \ {p}) ⊆ U' := by ++ exact Set.sdiff_subset ++ ++ have T : (U' \ {p}) ⊆ (U \ {p}) := by ++ exact Set.sdiff_subset_sdiff a (subset_refl _) ++ ++ refine logDerivResidue' b ?_ ?_ (IsOpen.mem_nhds b c) A_ne_zero ?_ ++ · intro x hyp_x ++ exact non_zero x <| T hyp_x ++ · exact DifferentiableOn.mono holc T ++ · exact (f_near_p.mono (image_mono (Set.sdiff_subset_sdiff a (subset_refl _)))) ++ ++lemma BddAbove_to_IsBigO {f : ℂ → ℂ} {p : ℂ} ++ {U : Set ℂ} (hU : U ∈ 𝓝 p) (bdd : BddAbove (norm ∘ f '' (U \ {p}))) : ++ f =O[𝓝[≠] p] (1 : ℂ → ℂ) := by ++ dsimp [BddAbove, upperBounds] at bdd ++ rcases bdd with ⟨C, hC⟩ ++ ++ have h : ∀ x ∈ U \ {p}, ‖f x‖ ≤ C := by ++ intro x hx ++ have fx_is_norm : ‖f x‖ ∈ norm ∘ f ''(U \ {p}) := by ++ exact ⟨x, hx, rfl⟩ ++ exact hC fx_is_norm ++ ++ rw [Asymptotics.isBigO_iff] ++ use C ++ rw [eventually_nhdsWithin_iff] ++ simp only [Set.mem_sdiff, mem_singleton_iff, and_imp, mem_compl_iff, Pi.one_apply, one_mem, ++ CStarRing.norm_of_mem_unitary, mul_one] at h ⊢ ++ filter_upwards [hU] using h ++ ++theorem logDerivResidue'' {f : ℂ → ℂ} {p : ℂ} {U : Set ℂ} ++ (non_zero : ∀ x ∈ U \ {p}, f x ≠ 0) ++ (holc : HolomorphicOn f (U \ {p})) ++ (U_in_nhds : U ∈ 𝓝 p) {A : ℂ} (A_ne_zero : A ≠ 0) ++ (f_near_p : BddAbove (norm ∘ (f - fun s ↦ A * (s - p)⁻¹) '' (U \ {p}))) : ++ ∃ V ∈ 𝓝 p, BddAbove (norm ∘ (deriv f * f⁻¹ + (fun s ↦ (s - p)⁻¹)) '' (V \ {p})) := by ++ apply IsBigO_to_BddAbove ++ exact logDerivResidue non_zero holc U_in_nhds A_ne_zero f_near_p ++ ++theorem ResidueMult {f g : ℂ → ℂ} {p : ℂ} {U : Set ℂ} ++ (g_holc : HolomorphicOn g U) (U_in_nhds : U ∈ 𝓝 p) {A : ℂ} ++ (f_near_p : (f - (fun s ↦ A * (s - p)⁻¹)) =O[𝓝[≠] p] (1 : ℂ → ℂ)) : ++ (f * g - (fun s ↦ A * g p * (s - p)⁻¹)) =O[𝓝[≠] p] (1 : ℂ → ℂ) := by ++ ++ have : (f * g - fun s ↦ A * g p * (s - p)⁻¹) ++ = (f - A • fun s ↦ (s - p)⁻¹) * g + fun s ↦ (A * (g s - g p) / (s - p)) := by ++ ext; simp; ring ++ ++ rw[this] ++ have p_in_U : p ∈ U := mem_of_mem_nhds U_in_nhds ++ refine Asymptotics.IsBigO.add ?_ ?_ ++ · rw[← mul_one (1 : ℂ → ℂ)] ++ refine Asymptotics.IsBigO.mul f_near_p ?_ ++ ++ have g_cont : ContinuousAt g p := by ++ ++ exact (g_holc.continuousOn.continuousWithinAt p_in_U).continuousAt U_in_nhds ++ ++ have := g_cont.norm.isBoundedUnder_le.isBigO_one ℂ ++ exact IsBigO.mono this inf_le_left ++ · ++ ++ suffices (fun s ↦ A * ((s - p)⁻¹ * (g s - g p))) =O[𝓝[≠] p] 1 by ++ convert! this using 2 ++ rw[div_eq_mul_inv] ++ ring ++ apply Asymptotics.IsBigO.const_mul_left ++ ++ have g_diff : HasDerivAt g (deriv g p) p := ++ (DifferentiableOn.differentiableAt g_holc U_in_nhds).hasDerivAt ++ ++ rw [hasDerivAt_iff_isLittleO] at g_diff ++ apply Asymptotics.IsLittleO.isBigO at g_diff ++ have : (fun x' ↦ deriv g p * (x' - p)) =O[𝓝 p] fun x' ↦ x' - p := by ++ apply Asymptotics.IsBigO.const_mul_left ++ exact Asymptotics.isBigO_refl (fun x ↦ x - p) (𝓝 p) ++ have h1 := g_diff.add this ++ have h2 : (fun x ↦ g x - g p) =O[𝓝 p] fun x' ↦ x' - p := by ++ convert! h1 using 2 ++ simp ++ ring ++ refine (Asymptotics.isBigO_mul_iff_isBigO_div ?_).mpr ?_ ++ · filter_upwards [self_mem_nhdsWithin] with x hx ++ simp only [mem_compl_iff, mem_singleton_iff] at hx ++ exact inv_ne_zero (sub_ne_zero.mpr hx) ++ · simp only [div_inv_eq_mul] ++ refine Asymptotics.IsBigO.mono ?_ inf_le_left ++ simpa ++ ++theorem riemannZetaLogDerivResidue : ++ ∃ U ∈ 𝓝 1, BddAbove (norm ∘ (-(ζ' / ζ) - (fun s ↦ (s - 1)⁻¹)) '' (U \ {1})) := by ++ obtain ⟨U,U_in_nhds, hU⟩ := riemannZetaResidue ++ have hU' : BddAbove (norm ∘ (ζ - fun s ↦ 1 * (s - 1)⁻¹) '' (U \ {1})) := by ++ simp only [Function.comp_apply, Pi.sub_apply, one_mul] at hU ⊢ ++ exact hU ++ obtain ⟨V,V_in_nhds, V_is_open, hV⟩ := nonZeroOfBddAbove U_in_nhds one_ne_zero hU' ++ let W := V ∩ interior U ++ have hW : ∀ s ∈ W \ {1}, ζ s ≠ 0 := by ++ intro s hs ++ have s_in_V_diff : s ∈ V \ {1} := ⟨hs.1.1, hs.2⟩ ++ exact hV s s_in_V_diff ++ have ζ_holc: HolomorphicOn ζ (W \ {1}) := by ++ intro y hy ++ simp only [Set.mem_sdiff, mem_singleton_iff] at hy ++ refine DifferentiableAt.differentiableWithinAt ?_ ++ apply differentiableAt_riemannZeta hy.2 ++ have W_in_nhds : W ∈ 𝓝 1 := by ++ refine inter_mem V_in_nhds ?_ ++ exact interior_mem_nhds.mpr U_in_nhds ++ have := logDerivResidue'' hW ζ_holc W_in_nhds one_ne_zero ++ have HW : BddAbove (norm ∘ (ζ - fun s ↦ (s - 1)⁻¹) '' (W \ {1})) := by ++ obtain ⟨c, hc⟩ := bddAbove_def.mp hU ++ apply bddAbove_def.mpr ++ use c ++ rintro y ⟨x, x_in_W, fxy⟩ ++ apply hc ++ exact ⟨x, ⟨interior_subset x_in_W.1.2, x_in_W.2⟩, fxy⟩ ++ simp only [one_mul] at this ++ have aux: ∀ a, ‖-(deriv ζ a / ζ a) - (a - 1)⁻¹‖ = ‖(deriv ζ a / ζ a) + (a - 1)⁻¹‖ := by ++ intro a ++ calc ‖-(deriv ζ a / ζ a) - (a - 1)⁻¹‖ ++ = ‖-((deriv ζ a / ζ a) + (a - 1)⁻¹)‖ := by ring_nf ++ _ = ‖(deriv ζ a / ζ a) + (a - 1)⁻¹‖ := by rw [norm_neg] ++ simp only [Function.comp_apply, Pi.sub_apply] at hU ++ simp only [Function.comp_apply, Pi.sub_apply, Pi.neg_apply, Pi.div_apply, aux] ++ apply this HW ++ ++theorem riemannZetaLogDerivResidueBigO : ++ (-ζ' / ζ - fun z ↦ (z - 1)⁻¹) =O[nhdsWithin 1 {1}ᶜ] (1 : ℂ → ℂ) := by ++ obtain ⟨U, hU, bdd⟩ := riemannZetaLogDerivResidue ++ convert BddAbove_to_IsBigO hU bdd using 2 ++ rw [neg_div] ++ ++noncomputable def riemannZeta0 (N : ℕ) (s : ℂ) : ℂ := ++ (∑ n ∈ Finset.range (N + 1), 1 / (n : ℂ) ^ s) + ++ (- N ^ (1 - s)) / (1 - s) + (- N ^ (-s)) / 2 ++ + s * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ (s + 1) ++ ++local notation (name := riemannzeta0) "ζ₀" => riemannZeta0 ++ ++lemma riemannZeta0_apply (N : ℕ) (s : ℂ) : ζ₀ N s = ++ (∑ n ∈ Finset.range (N + 1), 1 / (n : ℂ) ^ s) + ++ ((- N ^ (1 - s)) / (1 - s) + (- N ^ (-s)) / 2 ++ + s * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(s + 1))) := by ++ simp_rw [riemannZeta0, div_cpow_eq_cpow_neg]; ring ++ ++lemma Real.differentiableAt_cpow_const_of_ne (s : ℂ) {x : ℝ} (xpos : 0 < x) : ++ DifferentiableAt ℝ (fun (x : ℝ) ↦ (x : ℂ) ^ s) x := by ++ apply DifferentiableAt.comp_ofReal (e := fun z ↦ z ^ s) ++ apply DifferentiableAt.cpow (by simp) (by simp) (by simp [xpos]) ++ ++lemma Complex.one_div_cpow_eq {s : ℂ} {x : ℝ} (x_ne : x ≠ 0) : ++ 1 / (x : ℂ) ^ s = (x : ℂ) ^ (-s) := by ++ refine (eq_one_div_of_mul_eq_one_left ?_).symm ++ rw [← cpow_add _ _ <| mod_cast x_ne, neg_add_cancel, cpow_zero] ++ ++lemma sum_eq_int_deriv {φ : ℝ → ℂ} {a b : ℝ} (apos : 0 ≤ a) (a_lt_b : a < b) ++ (φDiff : ∀ x ∈ [[a, b]], HasDerivAt φ (deriv φ x) x) ++ (derivφCont : ContinuousOn (deriv φ) [[a, b]]) : ++ ∑ n ∈ Finset.Ioc ⌊a⌋₊ ⌊b⌋₊, φ n = ++ (∫ x in a..b, φ x) + (⌊b⌋₊ + 1 / 2 - b) * φ b - (⌊a⌋₊ + 1 / 2 - a) * φ a ++ - ∫ x in a..b, (⌊x⌋ + 1 / 2 - x) * deriv φ x := by ++ rw [uIcc_of_le a_lt_b.le] at φDiff ++ convert sum_eq_integral_add_integral_deriv apos a_lt_b.le (fun t ht ↦ (φDiff t ht).differentiableAt) derivφCont using 1 ++ unfold B1 ++ push_cast ++ suffices ∫ (x : ℝ) in a..b, (↑⌊x⌋ + 1 / 2 - ↑x) * deriv φ x = -∫ (t : ℝ) in a..b, deriv φ t * (↑t - ↑⌊t⌋₊ - 1 / 2) by ++ rw [this] ++ ring_nf! ++ rw [← intervalIntegral.integral_neg] ++ refine intervalIntegral.integral_congr fun x hx ↦ ?_ ++ rw [uIcc_of_le a_lt_b.le, mem_Icc] at hx ++ rw [← Int.natCast_floor_eq_floor (by linarith)] ++ norm_cast ++ push_cast ++ ring ++ ++lemma xpos_of_uIcc {a b : ℕ} (ha : a ∈ Ioo 0 b) {x : ℝ} (x_in : x ∈ [[(a : ℝ), b]]) : ++ 0 < x := by ++ rw [uIcc_of_le (by exact_mod_cast ha.2.le), mem_Icc] at x_in ++ linarith [(by exact_mod_cast ha.1 : (0 : ℝ) < a)] ++ ++lemma ZetaSum_aux1₁ {a b : ℕ} {s : ℂ} (s_ne_one : s ≠ 1) (ha : a ∈ Ioo 0 b) : ++ (∫ (x : ℝ) in a..b, 1 / (x : ℂ) ^ s) = ++ (b ^ (1 - s) - a ^ (1 - s)) / (1 - s) := by ++ convert integral_cpow (a := a) (b := b) (r := -s) ?_ using 1 ++ · refine intervalIntegral.integral_congr fun x hx ↦ _root_.Erdos970.Complex.one_div_cpow_eq ?_ ++ exact (xpos_of_uIcc ha hx).ne' ++ · norm_cast; ring_nf ++ · right; refine ⟨(by grind), ?_⟩ ++ exact fun hx ↦ (lt_self_iff_false 0).mp <| xpos_of_uIcc ha hx ++ ++lemma ZetaSum_aux1φDiff {s : ℂ} {x : ℝ} (xpos : 0 < x) : ++ HasDerivAt (fun (t : ℝ) ↦ 1 / (t : ℂ) ^ s) (deriv (fun (t : ℝ) ↦ 1 / (t : ℂ) ^ s) x) x := by ++ exact hasDerivAt_deriv_iff.mpr <| ++ DifferentiableAt.div (differentiableAt_const _) ++ (Real.differentiableAt_cpow_const_of_ne s xpos) (by simp [cpow_eq_zero_iff, xpos.ne']) ++ ++lemma ZetaSum_aux1φderiv {s : ℂ} (s_ne_zero : s ≠ 0) {x : ℝ} (xpos : 0 < x) : ++ deriv (fun (t : ℝ) ↦ 1 / (t : ℂ) ^ s) x = (fun (x : ℝ) ↦ -s * (x : ℂ) ^ (-(s + 1))) x := by ++ let r := -s - 1 ++ have r_add1_ne_zero : r + 1 ≠ 0 := fun hr ↦ by simp [neg_ne_zero.mpr s_ne_zero, r] at hr ++ have r_ne_neg1 : r ≠ -1 := fun hr ↦ (hr ▸ r_add1_ne_zero) <| by norm_num ++ have hasDeriv := hasDerivAt_ofReal_cpow_const' xpos.ne' r_ne_neg1 ++ have := hasDeriv.deriv ▸ deriv_const_mul (-s) (hasDeriv).differentiableAt ++ convert! this using 2 ++ · ext y ++ by_cases y_zero : (y : ℂ) = 0 ++ · simp only [y_zero, ne_eq, s_ne_zero, not_false_eq_true, zero_cpow, div_zero, ++ r_add1_ne_zero, zero_div, mul_zero] ++ · have : (y : ℂ) ^ s ≠ 0 := fun hy ↦ y_zero ((cpow_eq_zero_iff _ _).mp hy).1 ++ simp only [one_div, sub_add_cancel, cpow_neg, neg_mul, r] ++ field_simp ++ · simp only [r] ++ ring_nf ++ ++lemma ZetaSum_aux1derivφCont {s : ℂ} (s_ne_zero : s ≠ 0) {a b : ℕ} (ha : a ∈ Ioo 0 b) : ++ ContinuousOn (deriv (fun (t : ℝ) ↦ 1 / (t : ℂ) ^ s)) [[a, b]] := by ++ have : EqOn _ (fun (t : ℝ) ↦ -s * (t : ℂ) ^ (-(s + 1))) [[a, b]] := ++ fun x hx ↦ ZetaSum_aux1φderiv s_ne_zero <| xpos_of_uIcc ha hx ++ refine continuous_ofReal.continuousOn.cpow_const ?_ |>.const_smul (c := -s) |>.congr this ++ exact fun x hx ↦ ofReal_mem_slitPlane.mpr <| xpos_of_uIcc ha hx ++ ++ ++lemma ZetaSum_aux1 {a b : ℕ} {s : ℂ} (s_ne_one : s ≠ 1) (s_ne_zero : s ≠ 0) (ha : a ∈ Ioo 0 b) : ++ ∑ n ∈ Finset.Ioc a b, 1 / (n : ℂ) ^ s = ++ (b ^ (1 - s) - a ^ (1 - s)) / (1 - s) + 1 / 2 * (1 / b ^ (s)) - 1 / 2 * (1 / a ^ s) ++ + s * ∫ x in a..b, (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(s + 1)) := by ++ let φ := fun (x : ℝ) ↦ 1 / (x : ℂ) ^ s ++ let φ' := fun (x : ℝ) ↦ -s * (x : ℂ) ^ (-(s + 1)) ++ have xpos : ∀ x ∈ [[(a : ℝ), b]], 0 < x := fun x hx ↦ xpos_of_uIcc ha hx ++ have φDiff : ∀ x ∈ [[(a : ℝ), b]], HasDerivAt φ (deriv φ x) x := ++ fun x hx ↦ ZetaSum_aux1φDiff (xpos x hx) ++ have φderiv : ∀ x ∈ [[(a : ℝ), b]], deriv φ x = φ' x := by ++ exact fun x hx ↦ ZetaSum_aux1φderiv s_ne_zero (xpos x hx) ++ have derivφCont : ContinuousOn (deriv φ) [[a, b]] := ZetaSum_aux1derivφCont s_ne_zero ha ++ convert sum_eq_int_deriv (by linarith) (by exact_mod_cast ha.2) φDiff derivφCont using 1 ++ · congr <;> simp only [Nat.floor_natCast] ++ · rw [Nat.floor_natCast, Nat.floor_natCast, ← intervalIntegral.integral_const_mul] ++ simp_rw [mul_div, ← mul_div, φ, ZetaSum_aux1₁ s_ne_one ha] ++ conv => rhs; rw [sub_eq_add_neg] ++ congr; any_goals norm_cast; simp only [one_div, add_sub_cancel_left] ++ rw [← intervalIntegral.integral_neg, intervalIntegral.integral_congr] ++ simp only [φ, one_div] at φderiv ++ intro x hx; simp_rw [φderiv x hx, φ']; ring_nf ++ ++lemma ZetaSum_aux1_1' {a b x : ℝ} (apos : 0 < a) (hx : x ∈ Icc a b) : 0 < x := ++ lt_of_lt_of_le apos hx.1 ++ ++lemma ZetaSum_aux1_1 {a b x : ℝ} (apos : 0 < a) (a_lt_b : a < b) (hx : x ∈ [[a, b]]) : 0 < x := ++ lt_of_lt_of_le apos (uIcc_of_le a_lt_b.le ▸ hx).1 ++ ++lemma ZetaSum_aux1_2 {a b : ℝ} {c : ℝ} (apos : 0 < a) (a_lt_b : a < b) ++ (h : c ≠ 0 ∧ 0 ∉ [[a, b]]) : ++ ∫ (x : ℝ) in a..b, 1 / x ^ (c+1) = (a ^ (-c) - b ^ (-c)) / c := by ++ rw [(by ring : (a ^ (-c) - b ^ (-c)) / c = (b ^ (-c) - a ^ (-c)) / (-c))] ++ have := integral_rpow (a := a) (b := b) (r := -c-1) (Or.inr ⟨by simp [h.1], h.2⟩) ++ simp only [sub_add_cancel] at this ++ rw [← this] ++ apply intervalIntegral.integral_congr ++ intro x hx ++ have : 0 ≤ x := (ZetaSum_aux1_1 apos a_lt_b hx).le ++ simp [div_rpow_eq_rpow_neg _ _ _ this, sub_eq_add_neg, add_comm] ++ ++lemma ZetaSum_aux1_3 (x : ℝ) : ‖(⌊x⌋ + 1/2 - x)‖ ≤ 1/2 := ++ abs_le.mpr ⟨(by linarith [Int.lt_floor_add_one x]), (by linarith [Int.floor_le x])⟩ ++ ++lemma ZetaSum_aux1_4' (x : ℝ) (hx : 0 < x) (s : ℂ) : ++ ‖(⌊x⌋ + 1 / 2 - (x : ℝ)) / (x : ℂ) ^ (s + 1)‖ = ++ ‖⌊x⌋ + 1 / 2 - x‖ / x ^ ((s + 1).re) := by ++ simp_rw [norm_div, Complex.norm_cpow_eq_rpow_re_of_pos hx, ← norm_real] ++ simp ++ ++lemma ZetaSum_aux1_4 {a b : ℝ} (apos : 0 < a) (a_lt_b : a < b) {s : ℂ} : ++ ∫ (x : ℝ) in a..b, ‖(↑⌊x⌋ + (1 : ℝ) / 2 - ↑x) / (x : ℂ) ^ (s + 1)‖ = ++ ∫ (x : ℝ) in a..b, |⌊x⌋ + 1 / 2 - x| / x ^ (s + 1).re := by ++ apply intervalIntegral.integral_congr ++ exact fun x hx ↦ ZetaSum_aux1_4' x (ZetaSum_aux1_1 apos a_lt_b hx) s ++ ++lemma ZetaSum_aux1_5a {a b : ℝ} (apos : 0 < a) {s : ℂ} (x : ℝ) ++ (h : x ∈ Icc a b) : |↑⌊x⌋ + 1 / 2 - x| / x ^ (s.re + 1) ≤ 1 / x ^ (s.re + 1) := by ++ apply div_le_div_of_nonneg_right _ _ ++ · exact le_trans (ZetaSum_aux1_3 x) (by norm_num) ++ · apply Real.rpow_nonneg <| le_of_lt (ZetaSum_aux1_1' apos h) ++ ++lemma ZetaSum_aux1_5b {a b : ℝ} (apos : 0 < a) (a_lt_b : a < b) {s : ℂ} (σpos : 0 < s.re) : ++ IntervalIntegrable (fun u ↦ 1 / u ^ (s.re + 1)) MeasureTheory.volume a b := by ++ refine continuousOn_const.div ?_ ?_ |>.intervalIntegrable_of_Icc (le_of_lt a_lt_b) ++ · exact continuousOn_id.rpow_const fun x hx ↦ Or.inl (ne_of_gt <| ZetaSum_aux1_1' apos hx) ++ · exact fun x hx h ↦ by rw [Real.rpow_eq_zero] at h <;> linarith [ZetaSum_aux1_1' apos hx] ++ ++open MeasureTheory in ++lemma measurable_floor_add_half_sub : Measurable fun (u : ℝ) ↦ ↑⌊u⌋ + 1 / 2 - u := by ++ refine Measurable.add ?_ measurable_const |>.sub measurable_id ++ exact Measurable.comp (by exact fun _ _ ↦ trivial) Int.measurable_floor ++ ++open MeasureTheory in ++lemma ZetaSum_aux1_5c {a b : ℝ} {s : ℂ} : ++ let g : ℝ → ℝ := fun u ↦ |↑⌊u⌋ + 1 / 2 - u| / u ^ (s.re + 1); ++ AEStronglyMeasurable g ++ (Measure.restrict volume (Ι a b)) := by ++ intro ++ refine (Measurable.div ?_ <| measurable_id.pow_const _).aestronglyMeasurable ++ exact _root_.continuous_abs.measurable.comp measurable_floor_add_half_sub ++ ++lemma ZetaSum_aux1_5d {a b : ℝ} (apos : 0 < a) (a_lt_b : a < b) {s : ℂ} (σpos : 0 < s.re) : ++ IntervalIntegrable (fun u ↦ |↑⌊u⌋ + 1 / 2 - u| / u ^ (s.re + 1)) MeasureTheory.volume a b := by ++ set g : ℝ → ℝ := (fun u ↦ |↑⌊u⌋ + 1 / 2 - u| / u ^ (s.re + 1)) ++ apply ZetaSum_aux1_5b apos a_lt_b σpos |>.mono_fun ZetaSum_aux1_5c ?_ ++ filter_upwards with x ++ simp only [Real.norm_eq_abs, one_div, norm_inv, abs_div, _root_.abs_abs] ++ conv => rw [div_eq_mul_inv, ← one_div]; rhs; rw [← one_mul |x ^ (s.re + 1)|⁻¹] ++ refine mul_le_mul ?_ (le_refl _) (by simp) <| by norm_num ++ exact le_trans (ZetaSum_aux1_3 x) <| by norm_num ++ ++lemma ZetaSum_aux1_5 {a b : ℝ} (apos : 0 < a) (a_lt_b : a < b) {s : ℂ} (σpos : 0 < s.re) : ++ ∫ (x : ℝ) in a..b, |⌊x⌋ + 1 / 2 - x| / x ^ (s.re + 1) ≤ ++ ∫ (x : ℝ) in a..b, 1 / x ^ (s.re + 1) := by ++ apply intervalIntegral.integral_mono_on (le_of_lt a_lt_b) ?_ ?_ ++ · exact ZetaSum_aux1_5a apos ++ · exact ZetaSum_aux1_5d apos a_lt_b σpos ++ · exact ZetaSum_aux1_5b apos a_lt_b σpos ++ ++lemma ZetaBnd_aux1a {a b : ℝ} (apos : 0 < a) (a_lt_b : a < b) {s : ℂ} (σpos : 0 < s.re) : ++ ∫ x in a..b, ‖(⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ (s + 1)‖ ≤ ++ (a ^ (-s.re) - b ^ (-s.re)) / s.re := by ++ calc ++ _ = ∫ x in a..b, |(⌊x⌋ + 1 / 2 - x)| / x ^ (s+1).re := ZetaSum_aux1_4 apos a_lt_b ++ _ ≤ ∫ x in a..b, 1 / x ^ (s.re + 1) := ZetaSum_aux1_5 apos a_lt_b σpos ++ _ = (a ^ (-s.re) - b ^ (-s.re)) / s.re := ?_ ++ refine ZetaSum_aux1_2 (c := s.re) apos a_lt_b ⟨ne_of_gt σpos, ?_⟩ ++ exact fun h ↦ (lt_self_iff_false 0).mp <| ZetaSum_aux1_1 apos a_lt_b h ++ ++lemma Finset.Ioc_eq_Ico (M N : ℕ) : Finset.Ioc N M = Finset.Ico (N + 1) (M + 1) := by ++ ext a; simp only [Finset.mem_Ioc, Finset.mem_Ico]; constructor <;> intro ⟨h₁, h₂⟩ <;> omega ++ ++lemma Finset.Ioc_eq_Icc (M N : ℕ) : Finset.Ioc N M = Finset.Icc (N + 1) M := by ++ ext a; simp only [Finset.mem_Ioc, Finset.mem_Icc]; constructor <;> intro ⟨h₁, h₂⟩ <;> omega ++ ++lemma Finset.Icc_eq_Ico (M N : ℕ) : Finset.Icc N M = Finset.Ico N (M + 1) := by ++ ext a; simp only [Finset.mem_Icc, Finset.mem_Ico]; constructor <;> intro ⟨h₁, h₂⟩ <;> omega ++ ++lemma finsetSum_tendsto_tsum {N : ℕ} {f : ℕ → ℂ} (hf : Summable f) : ++ Tendsto (fun (k : ℕ) ↦ ∑ n ∈ Finset.Ico N k, f n) atTop (𝓝 (∑' (n : ℕ), f (n + N))) := by ++ have := Summable.hasSum_iff_tendsto_nat hf (m := ∑' (n : ℕ), f n) |>.mp hf.hasSum ++ have const := tendsto_const_nhds (α := ℕ) (x := ∑ i ∈ Finset.range N, f i) (f := atTop) ++ have := Filter.Tendsto.sub this const ++ rw [← hf.sum_add_tsum_nat_add N, add_comm, add_sub_cancel_right] at this ++ apply this.congr' ++ filter_upwards [Filter.mem_atTop (N + 1)] ++ intro M hM ++ rw [Finset.sum_Ico_eq_sub] ++ linarith ++ ++lemma Complex.cpow_tendsto {s : ℂ} (s_re_gt : 1 < s.re) : ++ Tendsto (fun (x : ℕ) ↦ (x : ℂ) ^ (1 - s)) atTop (𝓝 0) := by ++ have one_sub_s_re_ne : (1 - s).re ≠ 0 := by simp only [sub_re, one_re]; linarith ++ rw [tendsto_zero_iff_norm_tendsto_zero] ++ simp_rw [Complex.norm_natCast_cpow_of_re_ne_zero _ (one_sub_s_re_ne)] ++ rw [(by simp only [sub_re, one_re, neg_sub] : (1 - s).re = - (s - 1).re)] ++ apply (tendsto_rpow_neg_atTop _).comp tendsto_natCast_atTop_atTop; simp [s_re_gt] ++ ++lemma Complex.cpow_inv_tendsto {s : ℂ} (hs : 0 < s.re) : ++ Tendsto (fun (x : ℕ) ↦ ((x : ℂ) ^ s)⁻¹) atTop (𝓝 0) := by ++ rw [tendsto_zero_iff_norm_tendsto_zero] ++ simp_rw [norm_inv, Complex.norm_natCast_cpow_of_re_ne_zero _ <| ne_of_gt hs] ++ apply Filter.Tendsto.inv_tendsto_atTop ++ exact (tendsto_rpow_atTop hs).comp tendsto_natCast_atTop_atTop ++ ++lemma ZetaSum_aux2a : ∃ C, ∀ (x : ℝ), ‖⌊x⌋ + 1 / 2 - x‖ ≤ C := by ++ use 1 / 2; exact ZetaSum_aux1_3 ++ ++lemma ZetaSum_aux3 {N : ℕ} {s : ℂ} (s_re_gt : 1 < s.re) : ++ Tendsto (fun k ↦ ∑ n ∈ Finset.Ioc N k, 1 / (n : ℂ) ^ s) atTop ++ (𝓝 (∑' (n : ℕ), 1 / (n + N + 1 : ℂ) ^ s)) := by ++ let f := fun (n : ℕ) ↦ 1 / (n : ℂ) ^ s ++ have hf := summable_one_div_nat_cpow.mpr s_re_gt ++ simp_rw [Finset.Ioc_eq_Ico] ++ convert finsetSum_tendsto_tsum (f := fun n ↦ f (n + 1)) (N := N) ?_ using 1 ++ · ext k ++ rw [Finset.sum_Ico_add'] ++ · congr; ext n; simp only [one_div, Nat.cast_add, Nat.cast_one, f] ++ · rwa [summable_nat_add_iff (k := 1)] ++ ++lemma integrableOn_of_Zeta0_fun {N : ℕ} (N_pos : 0 < N) {s : ℂ} (s_re_gt : 0 < s.re) : ++ MeasureTheory.IntegrableOn (fun (x : ℝ) ↦ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(s + 1))) (Ioi N) ++ MeasureTheory.volume := by ++ obtain ⟨c, hc⟩ := ZetaSum_aux2a ++ apply MeasureTheory.Integrable.bdd_mul (c := c) ?_ ?_ ++ · apply MeasureTheory.ae_of_all ++ convert hc; simp only [← Complex.norm_real]; simp ++ · apply integrableOn_Ioi_cpow_iff (by positivity) |>.mpr (by simp [s_re_gt]) ++ · refine Measurable.add ?_ measurable_const |>.sub (by fun_prop) |>.aestronglyMeasurable ++ exact Measurable.comp (by exact fun _ _ ↦ trivial) Int.measurable_floor ++ ++lemma ZetaSum_aux2 {N : ℕ} (N_pos : 0 < N) {s : ℂ} (s_re_gt : 1 < s.re) : ++ ∑' (n : ℕ), 1 / (n + N + 1 : ℂ) ^ s = ++ (- N ^ (1 - s)) / (1 - s) - N ^ (-s) / 2 ++ + s * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(s + 1)) := by ++ have s_ne_zero : s ≠ 0 := fun hs ↦ by linarith [zero_re ▸ hs ▸ s_re_gt] ++ have s_ne_one : s ≠ 1 := fun hs ↦ (lt_self_iff_false _).mp <| one_re ▸ hs ▸ s_re_gt ++ apply tendsto_nhds_unique (X := ℂ) (Y := ℕ) (l := atTop) ++ (f := fun k ↦ ((k : ℂ) ^ (1 - s) - (N : ℂ) ^ (1 - s)) / (1 - s) + ++ 1 / 2 * (1 / ↑k ^ s) - 1 / 2 * (1 / ↑N ^ s) ++ + s * ∫ (x : ℝ) in (N : ℝ)..k, (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(s + 1))) ++ (b := (- N ^ (1 - s)) / (1 - s) - N ^ (-s) / 2 ++ + s * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(s + 1))) ++ · apply Filter.Tendsto.congr' ++ (f₁ := fun (k : ℕ) ↦ ∑ n ∈ Finset.Ioc N k, 1 / (n : ℂ) ^ s) (l₁ := atTop) ++ · apply Filter.eventually_atTop.mpr ++ use N + 1 ++ intro k hk ++ exact ZetaSum_aux1 (a := N) (b := k) s_ne_one s_ne_zero ⟨N_pos, hk⟩ ++ · exact ZetaSum_aux3 s_re_gt ++ · apply (Tendsto.sub ?_ ?_).add (Tendsto.const_mul _ ?_) ++ · rw [(by ring : -↑N ^ (1 - s) / (1 - s) = (0 - ↑N ^ (1 - s)) / (1 - s) + 0)] ++ apply _root_.Erdos970.Complex.cpow_tendsto s_re_gt |>.sub_const _ |>.div_const _ |>.add ++ simp_rw [mul_comm_div, one_mul, one_div, (by congr; ring : 𝓝 (0 : ℂ) = 𝓝 ((0 : ℂ) / 2))] ++ apply Tendsto.div_const <| _root_.Erdos970.Complex.cpow_inv_tendsto (by positivity) ++ · simp_rw [mul_comm_div, one_mul, one_div, cpow_neg]; exact tendsto_const_nhds ++ · exact MeasureTheory.intervalIntegral_tendsto_integral_Ioi (a := N) ++ (b := (fun (n : ℕ) ↦ (n : ℝ))) ++ (integrableOn_of_Zeta0_fun N_pos <| by positivity) tendsto_natCast_atTop_atTop ++ ++open MeasureTheory in ++ ++lemma ZetaBnd_aux1b (N : ℕ) (Npos : 1 ≤ N) {σ t : ℝ} (σpos : 0 < σ) : ++ ‖∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ ((σ + t * I) + 1)‖ ++ ≤ N ^ (-σ) / σ := by ++ apply le_trans (by apply norm_integral_le_integral_norm) ++ apply le_of_tendsto (x := atTop (α := ℝ)) (f := fun (t : ℝ) ↦ ∫ (x : ℝ) in N..t, ++ ‖(⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ (σ + t * I + 1)‖) ?_ ?_ ++ · apply intervalIntegral_tendsto_integral_Ioi (μ := volume) (l := atTop) (b := id) ++ (f := fun (x : ℝ) ↦ ‖(⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ (σ + t * I + 1)‖) N ?_ ?_ |>.congr' ?_ ++ · filter_upwards [Filter.mem_atTop ((N : ℝ))] ++ intro u hu ++ simp only [id_eq, intervalIntegral.integral_of_le hu, norm_div] ++ apply setIntegral_congr_fun (by simp) ++ intro x hx; beta_reduce ++ iterate 2 (rw [norm_cpow_eq_rpow_re_of_pos (by linarith [hx.1])]) ++ simp ++ · apply IntegrableOn.integrable ?_ |>.norm ++ convert! integrableOn_of_Zeta0_fun (s := σ + t * I) Npos (by simp [σpos]) using 1 ++ simp_rw [div_eq_mul_inv, cpow_neg] ++ · exact fun ⦃_⦄ a ↦ a ++ · filter_upwards [mem_atTop (N + 1 : ℝ)] with t ht ++ have : (N ^ (-σ) - t ^ (-σ)) / σ ≤ N ^ (-σ) / σ := ++ div_le_div_iff_of_pos_right σpos |>.mpr (by simp [Real.rpow_nonneg (by linarith)]) ++ apply le_trans ?_ this ++ convert! ZetaBnd_aux1a (a := N) (b := t) (by positivity) (by linarith) ?_ <;> simp [σpos] ++ ++lemma ZetaBnd_aux1 (N : ℕ) (Npos : 1 ≤ N) {σ t : ℝ} (hσ : σ ∈ Ioc 0 2) (ht : 2 ≤ |t|) : ++ ‖(σ + t * I) * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ ((σ + t * I) + 1)‖ ++ ≤ 2 * |t| * N ^ (-σ) / σ := by ++ rw [norm_mul, mul_div_assoc] ++ rw [Set.mem_Ioc] at hσ ++ apply mul_le_mul ?_ (ZetaBnd_aux1b N Npos hσ.1) (norm_nonneg _) (by positivity) ++ refine le_trans (by apply norm_add_le) ?_ ++ simp only [Complex.norm_of_nonneg hσ.1.le, Complex.norm_mul, norm_real, Real.norm_eq_abs, norm_I, ++ mul_one] ++ linarith [hσ.2] ++ ++lemma ZetaBnd_aux1p (N : ℕ) (Npos : 1 ≤ N) {σ : ℝ} (hσ : σ ∈ Ioc 0 2) : ++ (fun (t : ℝ) ↦ ++ ‖(σ + t * I) * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ ((σ + t * I) + 1)‖) ++ =O[Filter.principal {t | 2 ≤ |t|}] fun t ↦ |t| * N ^ (-σ) / σ := by ++ rw [Asymptotics.IsBigO_def] ++ use 2 ++ rw [Asymptotics.isBigOWith_principal] ++ intro t ht ++ simp only [mem_ofPred_eq] at ht ++ rw [norm_norm, norm_mul, mul_div_assoc, norm_mul] ++ have : 2 * (‖|t|‖ * ‖↑N ^ (-σ) / σ‖) = (2 * |t|) * ((N : ℝ) ^ (-σ) / σ) := by ++ simp only [Real.norm_eq_abs, _root_.abs_abs, norm_div] ++ have : σ ≠ 0 := by linarith [hσ.1] ++ field_simp ++ rw [abs_of_pos hσ.1] ++ have : 0 < (N : ℝ) ^ (-σ) := by ++ refine Real.rpow_pos_of_pos ?_ _ ++ positivity ++ rw [abs_of_pos this] ++ ring ++ rw [this] ++ apply mul_le_mul ?_ (ZetaBnd_aux1b N Npos hσ.1) (norm_nonneg _) (by positivity) ++ refine le_trans (by apply norm_add_le) ?_ ++ simp only [norm_real, norm_mul, norm_I, mul_one, Complex.norm_of_nonneg hσ.1.le, Real.norm_eq_abs] ++ linarith [hσ.2] ++ ++lemma isOpen_aux : IsOpen {z : ℂ | z ≠ 1 ∧ 0 < z.re} := by ++ refine IsOpen.inter isOpen_ne ?_ ++ exact isOpen_lt (g := fun (z : ℂ) ↦ z.re) (by continuity) (by continuity) ++ ++open MeasureTheory in ++lemma integrable_log_over_pow {r : ℝ} (rneg : r < 0) {N : ℕ} (Npos : 0 < N) : ++ IntegrableOn (fun (x : ℝ) ↦ ‖x ^ (r - 1)‖ * ‖Real.log x‖) <| Ioi N := by ++ apply IntegrableOn.mono_set (hst := Set.Ioi_subset_Ici <| le_refl (N : ℝ)) ++ apply LocallyIntegrableOn.integrableOn_of_isBigO_atTop (g := fun x ↦ x ^ (r / 2 - 1)) ++ · apply ContinuousOn.abs ?_ |>.mul ?_ |>.locallyIntegrableOn (by simp) ++ · apply ContinuousOn.rpow (by fun_prop) (by fun_prop) ++ intro x hx; left; contrapose! Npos with h; exact_mod_cast h ▸ mem_Ici.mp hx ++ · apply continuous_id.continuousOn.log ?_ |>.abs ++ intro x hx; simp only [id_eq]; contrapose! Npos with h; exact_mod_cast h ▸ mem_Ici.mp hx ++ · have := isLittleO_log_rpow_atTop (r := -r / 2) (by linarith) |>.isBigO ++ rw [Asymptotics.isBigO_iff_eventually, Filter.eventually_atTop] at this ++ obtain ⟨C, hC⟩ := this ++ have hh := hC C (by simp) ++ rw [Asymptotics.isBigO_atTop_iff_eventually_exists] ++ have := Filter.eventually_atTop.mp hh ++ obtain ⟨x₀, hx₀ ⟩ := this ++ filter_upwards [hh, Filter.mem_atTop x₀, Filter.mem_atTop 1] ++ intro x hx x_gt x_pos ++ use C ++ intro y hy ++ simp only [norm_mul, Real.norm_eq_abs, _root_.abs_abs] ++ simp only [Real.norm_eq_abs] at hx ++ have y_pos : 0 < y := by linarith ++ have : y ^ (r / 2 - 1) = y ^ (r - 1) * y ^ (-r / 2) := by ++ rw [← Real.rpow_add y_pos]; ring_nf ++ rw [this, abs_mul] ++ have y_gt : y ≥ x₀ := by linarith ++ have := hx₀ y y_gt ++ simp only [Real.norm_eq_abs] at this ++ rw [← mul_assoc, mul_comm C, mul_assoc] ++ exact mul_le_mul_of_nonneg_left (hbc := this) (a := |y ^ (r - 1)|) (ha := by simp) ++ · have := integrableOn_Ioi_rpow_iff (s := r / 2 - 1) (t := N) (by simp [Npos]) |>.mpr ++ (by linarith [rneg]) ++ exact integrableOn_Ioi_iff_integrableAtFilter_atTop_nhdsWithin.mp this |>.1 ++ ++open MeasureTheory in ++lemma integrableOn_of_Zeta0_fun_log {N : ℕ} (Npos : 0 < N) {s : ℂ} (s_re_gt : 0 < s.re) : ++ IntegrableOn (fun (x : ℝ) ↦ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(s + 1)) * (-Real.log x)) (Ioi N) ++ volume := by ++ simp_rw [mul_assoc] ++ obtain ⟨c, hc⟩ := ZetaSum_aux2a ++ apply Integrable.bdd_mul (c := c) ?_ ?_ ?_ ++ · simp only [neg_add_rev, mul_neg, add_comm, ← sub_eq_add_neg] ++ apply integrable_norm_iff ?_ |>.mp ?_ |>.neg ++ · apply ContinuousOn.mul ?_ ?_ |>.aestronglyMeasurable (by simp) ++ · intro x hx ++ apply ContinuousWithinAt.cpow ?_ continuous_const.continuousWithinAt ?_ ++ · exact RCLike.continuous_ofReal.continuousWithinAt ++ · simp only [ofReal_mem_slitPlane]; linarith [mem_Ioi.mp hx] ++ · apply RCLike.continuous_ofReal.continuousOn.comp ?_ (mapsTo_image _ _) ++ refine continuous_id.continuousOn.log ?_ ++ intro x hx; simp only [id_eq]; linarith [mem_Ioi.mp hx] ++ · simp only [norm_mul, norm_real] ++ have := integrable_log_over_pow (r := -s.re) (by linarith) Npos ++ apply IntegrableOn.congr_fun this ?_ (by simp) ++ intro x hx ++ simp only [mul_eq_mul_right_iff, norm_eq_zero, Real.log_eq_zero] ++ left ++ have xpos : 0 < x := by linarith [mem_Ioi.mp hx] ++ simp [norm_cpow_eq_rpow_re_of_pos xpos, Real.abs_rpow_of_nonneg xpos.le, ++ abs_eq_self.mpr xpos.le] ++ · apply Measurable.add ?_ measurable_const |>.sub (by fun_prop) |>.aestronglyMeasurable ++ exact Measurable.comp (fun _ _ ↦ trivial) Int.measurable_floor ++ · apply MeasureTheory.ae_of_all ++ convert hc with _ x; simp only [← Complex.norm_real]; simp ++ ++open MeasureTheory in ++lemma hasDerivAt_Zeta0Integral {N : ℕ} (Npos : 0 < N) {s : ℂ} (hs : s ∈ {s | 0 < s.re}) : ++ HasDerivAt (fun z ↦ ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-z - 1)) ++ (∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (- s - 1) * (- Real.log x)) s := by ++ simp only [mem_ofPred_eq] at hs ++ set f : ℝ → ℂ := fun x ↦ (⌊x⌋ : ℂ) + 1 / 2 - x ++ set F : ℂ → ℝ → ℂ := fun s x ↦ (x : ℂ) ^ (- s - 1) * f x ++ set F' : ℂ → ℝ → ℂ := fun s x ↦ (x : ℂ) ^ (- s - 1) * (- Real.log x) * f x ++ set ε := s.re / 2 ++ have ε_pos : 0 < ε := by aesop ++ set bound : ℝ → ℝ := fun x ↦ |x ^ (- s.re / 2 - 1)| * |Real.log x| ++ let μ : Measure ℝ := volume.restrict (Ioi (N : ℝ)) ++ have hF_meas : ∀ᶠ (z : ℂ) in 𝓝 s, AEStronglyMeasurable (F z) μ := by ++ have : {z : ℂ | 0 < z.re} ∈ 𝓝 s := by ++ rw [mem_nhds_iff] ++ refine ⟨{z | 0 < z.re}, fun ⦃a⦄ a ↦ a, isOpen_lt continuous_const Complex.continuous_re, hs⟩ ++ filter_upwards [this] with z hz ++ convert! integrableOn_of_Zeta0_fun Npos hz |>.aestronglyMeasurable using 1 ++ simp only [F, f]; ext x; ring_nf ++ have hF_int : Integrable (F s) μ := by ++ convert! integrableOn_of_Zeta0_fun Npos hs |>.integrable using 1 ++ simp only [F, f]; ext x; ring_nf ++ have hF'_meas : AEStronglyMeasurable (F' s) μ := by ++ convert! integrableOn_of_Zeta0_fun_log Npos hs |>.aestronglyMeasurable using 1 ++ simp only [F', f]; ext x; ring_nf ++ have IoiSubIoi1 : (Ioi (N : ℝ)) ⊆ {x | 1 < x} := ++ fun x hx ↦ lt_of_le_of_lt (by simp only [Nat.one_le_cast]; omega) <| mem_Ioi.mp hx ++ have measSetIoi1 : MeasurableSet {x : ℝ | 1 < x} := (isOpen_lt' 1).measurableSet ++ have h_bound1 : ++ ∀ᵐ (x : ℝ) ∂volume.restrict {x | 1 < x}, ∀ z ∈ Metric.ball s ε, ‖F' z x‖ ≤ bound x := by ++ filter_upwards [self_mem_ae_restrict measSetIoi1] with x hx ++ intro z hz ++ simp only [F', f, bound] ++ calc _ = ‖(x : ℂ) ^ (-z - 1)‖ * ‖-(Real.log x)‖ * ‖(⌊x⌋ + 1 / 2 - x)‖ := by ++ simp only [mul_neg, one_div, neg_mul, norm_neg, norm_mul, norm_real, Real.norm_eq_abs, ++ ← (by simp : (((⌊x⌋ + 2⁻¹ - x) : ℝ) : ℂ) = (⌊x⌋ : ℂ) + 2⁻¹ - ↑x), ++ Complex.norm_real] ++ _ = ‖x ^ (-z.re - 1)‖ * ‖-(Real.log x)‖ * ‖(⌊x⌋ + 1 / 2 - x)‖ := ?_ ++ _ = |x ^ (-z.re - 1)| * |(Real.log x)| * |(⌊x⌋ + 1 / 2 - x)| := by simp ++ _ ≤ _ := ?_ ++ · congr! 2 ++ simp only [Real.norm_eq_abs, norm_cpow_eq_rpow_re_of_pos (by linarith), ++ sub_re, neg_re, one_re] ++ apply abs_eq_self.mpr ?_ |>.symm ++ positivity ++ · rw [mul_comm, ← mul_assoc] ++ apply mul_le_mul_of_nonneg_right ?_ <| abs_nonneg _ ++ simp only [Metric.mem_ball, ε, Complex.dist_eq] at hz ++ apply le_trans (b := 1 * |x ^ (-z.re - 1)|) ++ · apply mul_le_mul_of_nonneg_right (le_trans (ZetaSum_aux1_3 _) (by norm_num)) <| abs_nonneg _ ++ · simp_rw [one_mul, Real.abs_rpow_of_nonneg (by linarith : 0 ≤ x)] ++ apply Real.rpow_le_rpow_of_exponent_le <| le_abs.mpr (by left; exact hx.le) ++ have := abs_le.mp <| le_trans (abs_re_le_norm (z-s)) hz.le ++ simp only [sub_re, neg_le_sub_iff_le_add, tsub_le_iff_right] at this ++ linarith [this.1] ++ have h_bound : ∀ᵐ x ∂μ, ∀ z ∈ Metric.ball s ε, ‖F' z x‖ ≤ bound x := by ++ apply ae_restrict_of_ae_restrict_of_subset IoiSubIoi1 ++ exact h_bound1 ++ have bound_integrable : Integrable bound μ := by ++ simp only [bound] ++ convert! integrable_log_over_pow (r := -s.re / 2) (by linarith) Npos using 0 ++ have h_diff : ∀ᵐ x ∂μ, ∀ z ∈ Metric.ball s ε, HasDerivAt (fun w ↦ F w x) (F' z x) z := by ++ simp only [F, F', f] ++ apply ae_restrict_of_ae_restrict_of_subset IoiSubIoi1 ++ filter_upwards [h_bound1, self_mem_ae_restrict measSetIoi1] with x _ one_lt_x ++ intro z hz ++ convert! HasDerivAt.mul_const (c := fun (w : ℂ) ↦ (x : ℂ) ^ (-w-1)) ++ (c' := (x : ℂ) ^ (-z-1) * -Real.log x) (d := (⌊x⌋ : ℝ) + 1 / 2 - x) ?_ using 1 ++ convert! HasDerivAt.comp (h := fun w ↦ -w-1) (h' := -1) (h₂ := fun w ↦ x ^ w) ++ (h₂' := x ^ (-z-1) * Real.log x) (x := z) ?_ ?_ using 0 ++ · simp only [mul_neg, mul_one]; congr! 2 ++ · convert! HasDerivAt.const_cpow (c := (x : ℂ)) (f := fun w ↦ w) (f' := 1) (x := -z-1) ++ (hasDerivAt_id _) ?_ using 1 ++ · simp only [mul_one, mul_eq_mul_left_iff, cpow_eq_zero_iff, ofReal_eq_zero, ne_eq] ++ left ++ rw [Complex.ofReal_log] ++ linarith ++ · right ++ intro h ++ simp only [Metric.mem_ball, ε, Complex.dist_eq, ++ neg_eq_iff_eq_neg.mp <| sub_eq_zero.mp h] at hz ++ have := (abs_le.mp <| le_trans (abs_re_le_norm (-1-s)) hz.le).1 ++ simp only [sub_re, neg_re, one_re, neg_le_sub_iff_le_add, le_neg_add_iff_add_le] at this ++ linarith ++ · apply hasDerivAt_id _ |>.neg |>.sub_const ++ convert! (hasDerivAt_integral_of_dominated_loc_of_deriv_le (F := F) (F' := F') (x₀ := s) ++ (s := Metric.ball s ε) (bound := bound) (μ := μ) (Metric.ball_mem_nhds s ε_pos) ++ hF_meas hF_int hF'_meas h_bound bound_integrable h_diff).2 using 3 ++ · ext a; simp only [one_div, F, f]; ring_nf ++ · simp only [one_div, mul_neg, neg_mul, neg_inj, F', f]; ring_nf ++ ++noncomputable def ζ₀' (N : ℕ) (s : ℂ) : ℂ := ++ ∑ n ∈ Finset.range (N + 1), -1 / (n : ℂ) ^ s * Real.log n + ++ (-N ^ (1 - s) / (1 - s) ^ 2 + Real.log N * N ^ (1 - s) / (1 - s)) + ++ Real.log N * N ^ (-s) / 2 + ++ (1 * (∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (- s - 1)) + ++ s * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (- s - 1) * (- Real.log x)) ++ ++lemma HasDerivAt_neg_cpow_over2 {N : ℕ} (Npos : 0 < N) (s : ℂ) : ++ HasDerivAt (fun x : ℂ ↦ -(N : ℂ) ^ (-x) / 2) (-((- Real.log N) * (N : ℂ) ^ (-s)) / 2) s := by ++ convert! hasDerivAt_neg' s |>.const_cpow (c := N) (by aesop) |>.neg |>.div_const _ using 1 ++ simp [mul_comm] ++ ++lemma HasDerivAt_cpow_over_var (N : ℕ) {z : ℂ} (z_ne_zero : z ≠ 0) : ++ HasDerivAt (fun z ↦ -(N : ℂ) ^ z / z) ++ (((N : ℂ) ^ z / z ^ 2) - (Real.log N * N ^ z / z)) z := by ++ simp_rw [div_eq_mul_inv] ++ convert! HasDerivAt.mul (c := fun z ↦ - (N : ℂ) ^ z) (d := fun z ↦ z⁻¹) ++ (c' := - (N : ℂ) ^ z * Real.log N) ++ (d' := - (z ^ 2)⁻¹) ?_ ?_ using 1 ++ · simp only [natCast_log, neg_mul, mul_neg, neg_neg] ++ ring_nf ++ · simp only [natCast_log, neg_mul] ++ apply HasDerivAt.neg ++ convert! HasDerivAt.const_cpow (c := (N : ℂ)) (f := id) (f' := 1) (x := z) (hasDerivAt_id z) ++ (by simp [z_ne_zero]) using 1 ++ simp only [id_eq, mul_one] ++ · exact hasDerivAt_inv z_ne_zero ++ ++lemma HasDerivAtZeta0 {N : ℕ} (Npos : 0 < N) {s : ℂ} (reS_pos : 0 < s.re) (s_ne_one : s ≠ 1) : ++ HasDerivAt (ζ₀ N) (ζ₀' N s) s := by ++ unfold riemannZeta0 ζ₀' ++ apply HasDerivAt.fun_sum ?_ |>.add ?_ |>.add ?_ |>.add ?_ ++ · intro n _ ++ convert! hasDerivAt_neg' s |>.const_cpow (c := n) (by aesop) using 1 ++ all_goals (ring_nf; simp [cpow_neg]) ++ · convert! HasDerivAt.comp (h₂ := fun z ↦ -(N : ℂ) ^ z / z) (h := fun z ↦ 1 - z) (h' := -1) ++ (h₂' := ((N : ℂ) ^ (1 - s) / (1 - s) ^ 2 - Real.log (N : ℝ) * (N : ℂ) ^ (1 - s) / (1 - s))) ++ (x := s) ?_ ?_ using 1 ++ · ring_nf ++ · exact HasDerivAt_cpow_over_var N (by rw [sub_ne_zero]; exact s_ne_one.symm) ++ · convert! hasDerivAt_const s _ |>.sub (hasDerivAt_id _) using 1; simp ++ · convert! HasDerivAt_neg_cpow_over2 Npos s using 1; simp only [natCast_log, neg_mul, neg_neg] ++ · simp_rw [div_cpow_eq_cpow_neg, neg_add, ← sub_eq_add_neg] ++ convert! hasDerivAt_id s |>.mul <| hasDerivAt_Zeta0Integral Npos reS_pos using 1 ++ ++lemma HolomorphicOn_riemannZeta0 {N : ℕ} (N_pos : 0 < N) : ++ HolomorphicOn (ζ₀ N) {s : ℂ | s ≠ 1 ∧ 0 < s.re} := ++ fun _ ⟨hs₁, hs₂⟩ ↦ (HasDerivAtZeta0 N_pos hs₂ hs₁).differentiableAt.differentiableWithinAt ++ ++lemma HolomorphicOn_riemannZeta : ++ HolomorphicOn ζ {s : ℂ | s ≠ 1} := by ++ intro z hz ++ simp only [mem_ofPred_eq] at hz ++ exact (differentiableAt_riemannZeta hz).differentiableWithinAt ++ ++lemma isPathConnected_aux : IsPathConnected {z : ℂ | z ≠ 1 ∧ 0 < z.re} := by ++ use (2 : ℂ) ++ constructor ++ · simp ++ intro w hw; simp only [ne_eq, mem_ofPred_eq] at hw ++ by_cases w_im : w.im = 0 ++ · apply JoinedIn.trans (y := 1 + I) ++ · let f : ℝ → ℂ := fun t ↦ (1 + I) * t + 2 * (1 - t) ++ have cont : Continuous f := by continuity ++ apply JoinedIn.ofLine cont.continuousOn (by simp [f]) (by simp [f]) ++ simp only [unitInterval, ne_eq, image_subset_iff, preimage_ofPred_eq, add_re, mul_re, one_re, ++ I_re, add_zero, ofReal_re, one_mul, add_im, one_im, I_im, zero_add, ofReal_im, mul_zero, ++ sub_zero, re_ofNat, sub_re, im_ofNat, sub_im, sub_self, f] ++ intro x hx; simp only [mem_Icc] at hx ++ refine ⟨?_, by linarith⟩ ++ intro h ++ rw [Complex.ext_iff] at h; simp [(by apply And.right; simpa [w_im] using h : x = 0)] at h ++ · let f : ℝ → ℂ := fun t ↦ w * t + (1 + I) * (1 - t) ++ have cont : Continuous f := by continuity ++ apply JoinedIn.ofLine cont.continuousOn (by simp [f]) (by simp [f]) ++ simp only [unitInterval, ne_eq, image_subset_iff, preimage_ofPred_eq, add_re, mul_re, ++ ofReal_re, ofReal_im, mul_zero, sub_zero, one_re, I_re, add_zero, sub_re, one_mul, add_im, ++ one_im, I_im, zero_add, sub_im, sub_self, f] ++ intro x hx; simp only [mem_Icc] at hx ++ simp only [mem_ofPred_eq] ++ constructor ++ · intro h ++ refine hw.1 ?_ ++ rw [Complex.ext_iff] at h ++ have : x = 1 := by linarith [(by apply And.right; simpa [w_im] using h : 1 - x = 0)] ++ rw [Complex.ext_iff, one_re, one_im]; exact ⟨by simpa [this, w_im] using h, w_im⟩ ++ · by_cases hxx : x = 0 ++ · simp only [hxx]; linarith ++ · have : 0 < x := lt_of_le_of_ne hx.1 (Ne.symm hxx) ++ have : 0 ≤ 1 - x := by linarith ++ have := hw.2 ++ positivity ++ · let f : ℝ → ℂ := fun t ↦ w * t + 2 * (1 - t) ++ have cont : Continuous f := by continuity ++ apply JoinedIn.ofLine cont.continuousOn (by simp [f]) (by simp [f]) ++ simp only [unitInterval, ne_eq, image_subset_iff, preimage_ofPred_eq, add_re, mul_re, ofReal_re, ++ ofReal_im, mul_zero, sub_zero, re_ofNat, sub_re, one_re, im_ofNat, sub_im, one_im, sub_self, ++ f] ++ intro x hx; simp only [mem_Icc] at hx ++ constructor ++ · intro h ++ rw [Complex.ext_iff] at h; ++ simp [(by apply And.right; simpa [w_im] using h : x = 0)] at h ++ · by_cases hxx : x = 0 ++ · simp only [hxx]; linarith ++ · have : 0 < x := lt_of_le_of_ne hx.1 (Ne.symm hxx) ++ have : 0 ≤ 1 - x := by linarith ++ have := hw.2 ++ positivity ++ ++lemma Zeta0EqZeta {N : ℕ} (N_pos : 0 < N) {s : ℂ} (reS_pos : 0 < s.re) (s_ne_one : s ≠ 1) : ++ ζ₀ N s = riemannZeta s := by ++ let f := riemannZeta ++ let g := ζ₀ N ++ let U := {z : ℂ | z ≠ 1 ∧ 0 < z.re} ++ have f_an : AnalyticOnNhd ℂ f U := by ++ apply (HolomorphicOn_riemannZeta.analyticOnNhd isOpen_ne).mono ++ simp only [ne_eq, ofPred_subset_ofPred, and_imp, U] ++ exact fun a ha _ ↦ ha ++ have g_an : AnalyticOnNhd ℂ g U := (HolomorphicOn_riemannZeta0 N_pos).analyticOnNhd isOpen_aux ++ have preconU : IsPreconnected U := by ++ apply IsConnected.isPreconnected ++ apply (IsOpen.isConnected_iff_isPathConnected isOpen_aux).mpr isPathConnected_aux ++ have h2 : (2 : ℂ) ∈ U := by simp [U] ++ have s_mem : s ∈ U := by simp [U, reS_pos, s_ne_one] ++ convert (AnalyticOnNhd.eqOn_of_preconnected_of_eventuallyEq f_an g_an preconU h2 ?_ s_mem).symm ++ have u_mem : {z : ℂ | 1 < z.re} ∈ 𝓝 (2 : ℂ) := by ++ apply mem_nhds_iff.mpr ++ use {z : ℂ | 1 < z.re} ++ simp only [ofPred_subset_ofPred, imp_self, forall_const, mem_ofPred_eq, re_ofNat, ++ Nat.one_lt_ofNat, and_true, true_and] ++ exact isOpen_lt (by continuity) (by continuity) ++ filter_upwards [u_mem] ++ intro z hz ++ simp only [f,g, zeta_eq_tsum_one_div_nat_cpow hz, riemannZeta0_apply] ++ nth_rewrite 2 [neg_div] ++ rw [← sub_eq_add_neg, ← ZetaSum_aux2 N_pos hz, ++ ← (summable_one_div_nat_cpow.mpr hz).sum_add_tsum_nat_add (N + 1)] ++ norm_cast ++ ++lemma DerivZeta0EqDerivZeta {N : ℕ} (N_pos : 0 < N) {s : ℂ} (reS_pos : 0 < s.re) ++ (s_ne_one : s ≠ 1) : ++ deriv (ζ₀ N) s = ζ' s := by ++ let U := {z : ℂ | z ≠ 1 ∧ 0 < z.re} ++ have {x : ℂ} (hx : x ∈ U) : ζ₀ N x = ζ x := by ++ simp only [mem_ofPred_eq, U] at hx; exact Zeta0EqZeta (N := N) N_pos hx.2 hx.1 ++ refine deriv_eqOn isOpen_aux ?_ (by simp [s_ne_one, reS_pos]) ++ intro x hx ++ have hζ := HolomorphicOn_riemannZeta.mono (by aesop)|>.hasDerivAt (s := U) <| ++ isOpen_aux.mem_nhds hx ++ exact hζ.hasDerivWithinAt.congr (fun y hy ↦ this hy) (this hx) ++ ++lemma le_trans₄ {α : Type*} [Preorder α] {a b c d : α} : a ≤ b → b ≤ c → c ≤ d → a ≤ d := ++ fun hab hbc hcd ↦ le_trans (le_trans hab hbc) hcd ++ ++lemma lt_trans₄ {α : Type*} [Preorder α] {a b c d : α} : a < b → b < c → c < d → a < d := ++ fun hab hbc hcd ↦ lt_trans (lt_trans hab hbc) hcd ++ ++lemma norm_add₅_le {E : Type*} [SeminormedAddGroup E] (a : E) (b : E) (c : E) (d : E) (e : E) : ++ ‖a + b + c + d + e‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ + ‖d‖ + ‖e‖ := by ++ apply le_trans <| norm_add_le (a + b + c + d) e ++ simp only [add_le_add_iff_right]; apply norm_add₄_le ++ ++lemma norm_add₆_le {E : Type*} [SeminormedAddGroup E] (a : E) (b : E) (c : E) (d : E) (e : E) ++ (f : E) : ++ ‖a + b + c + d + e + f‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ + ‖d‖ + ‖e‖ + ‖f‖ := by ++ apply le_trans <| norm_add_le (a + b + c + d + e) f ++ simp only [add_le_add_iff_right]; apply norm_add₅_le ++ ++lemma mul_le_mul₃ {α : Type*} {a b c d e f : α} [MulZeroClass α] [Preorder α] [PosMulMono α] ++ [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (h₃ : e ≤ f) (c0 : 0 ≤ c) (b0 : 0 ≤ b) ++ (e0 : 0 ≤ e) : a * c * e ≤ b * d * f := by ++ apply mul_le_mul (mul_le_mul h₁ h₂ c0 b0) h₃ e0 <| mul_nonneg b0 <| le_trans c0 h₂ ++ ++lemma ZetaBnd_aux2 {n : ℕ} {t A σ : ℝ} (Apos : 0 < A) (σpos : 0 < σ) (n_le_t : n ≤ |t|) ++ (σ_ge : (1 : ℝ) - A / Real.log |t| ≤ σ) : ++ ‖(n : ℂ) ^ (-(σ + t * I))‖ ≤ (n : ℝ)⁻¹ * Real.exp A := by ++ set s := σ + t * I ++ by_cases n0 : n = 0 ++ · simp_rw [n0, CharP.cast_eq_zero, inv_zero, zero_mul] ++ rw [Complex.zero_cpow ?_] ++ · simp ++ · exact fun h ↦ σpos.ne' <| zero_eq_neg.mp <| zero_re ▸ h ▸ (by simp [s]) ++ have n_gt_0 : 0 < n := Nat.pos_of_ne_zero n0 ++ have n_gt_0' : (0 : ℝ) < (n : ℝ) := Nat.cast_pos.mpr n_gt_0 ++ have n_ge_1 : 1 ≤ (n : ℝ) := Nat.one_le_cast.mpr <| Nat.succ_le_of_lt n_gt_0 ++ calc ++ _ = |((n : ℝ) ^ (-σ))| := ?_ ++ _ ≤ Real.exp (Real.log n * -σ) := Real.abs_rpow_le_exp_log_mul (n : ℝ) (-σ) ++ _ ≤ Real.exp (Real.log n * -(1 - A / Real.log t)) := ?_ ++ _ ≤ Real.exp (- Real.log n + A) := Real.exp_le_exp_of_le ?_ ++ _ ≤ _ := by rw [Real.exp_add, Real.exp_neg, Real.exp_log n_gt_0'] ++ · have : ‖(n : ℂ) ^ (-s)‖ = n ^ (-s.re) := norm_cpow_eq_rpow_re_of_pos n_gt_0' (-s) ++ rw [this, abs_eq_self.mpr <| Real.rpow_nonneg n_gt_0'.le _]; simp [s] ++ · apply Real.exp_le_exp_of_le <| mul_le_mul_of_nonneg_left _ <| Real.log_nonneg n_ge_1 ++ rw [neg_sub, neg_le_sub_iff_le_add, add_comm, ← Real.log_abs]; linarith ++ · simp only [neg_sub, le_neg_add_iff_add_le] ++ ring_nf ++ conv => rw [mul_comm, ← mul_assoc, ← Real.log_abs]; rhs; rw [← one_mul A] ++ gcongr ++ by_cases ht1 : |t| = 1 ++ · simp [ht1] ++ apply (inv_mul_le_iff₀ ?_).mpr ++ · convert! Real.log_le_log n_gt_0' n_le_t using 1; rw [mul_one] ++ · exact Real.log_pos <| lt_of_le_of_ne (le_trans n_ge_1 n_le_t) <| fun t ↦ ht1 (t.symm) ++ ++lemma logt_gt_one {t : ℝ} (t_ge : 3 ≤ t) : 1 < Real.log t := ++ (Real.lt_log_iff_exp_lt (by linarith)).mpr (by linarith [Real.exp_one_lt_d9]) ++ ++lemma UpperBnd_aux {A σ t : ℝ} (hA : A ∈ Ioc 0 (1 / 2)) (t_gt : 3 < |t|) ++ (σ_ge : 1 - A / Real.log |t| ≤ σ) : ++ let N := ⌊|t|⌋₊; ++ 0 < N ∧ N ≤ |t| ∧ 1 < Real.log |t| ∧ 1 - A < σ ∧ 0 < σ ∧ σ + t * I ≠ 1 := by ++ intro N ++ have Npos : 0 < N := Nat.floor_pos.mpr (by linarith) ++ have N_le_t : N ≤ |t| := Nat.floor_le <| abs_nonneg _ ++ have logt_gt := logt_gt_one t_gt.le ++ have σ_gt : 1 - A < σ := by ++ apply lt_of_lt_of_le ((sub_lt_sub_iff_left (a := 1)).mpr ?_) σ_ge ++ exact (div_lt_iff₀ (by linarith)).mpr <| lt_mul_right hA.1 logt_gt ++ refine ⟨Npos, N_le_t, logt_gt, σ_gt, by linarith [hA.2], ?_⟩ ++ contrapose! t_gt ++ simp only [Complex.ext_iff, add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, add_zero, one_re, add_im, mul_im, zero_add, one_im] at t_gt ++ norm_num [t_gt.2] ++ ++lemma UpperBnd_aux2 {A σ t : ℝ} (t_ge : 3 < |t|) (σ_ge : 1 - A / Real.log |t| ≤ σ) : ++ |t| ^ (1 - σ) ≤ Real.exp A := by ++ have : |t| ^ (1 - σ) ≤ |t| ^ (A / Real.log |t|) := ++ Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith) ++ apply le_trans this ?_ ++ conv => lhs; lhs; rw [← Real.exp_log (by linarith : 0 < |t|)] ++ rw [div_eq_mul_inv, Real.rpow_mul (by positivity), ← Real.exp_mul, ← Real.exp_mul, mul_comm, ++ ← mul_assoc, inv_mul_cancel₀, one_mul] ++ apply Real.log_ne_zero.mpr; split_ands <;> linarith ++ ++lemma riemannZeta0_zero_aux (N : ℕ) (Npos : 0 < N) : ++ ∑ x ∈ Finset.Ico 0 N, ((x : ℝ))⁻¹ = ∑ x ∈ Finset.Ico 1 N, ((x : ℝ))⁻¹ := by ++ have : Finset.Ico 1 N ⊆ Finset.Ico 0 N := by ++ intro x hx ++ simp only [Finset.mem_Ico, Nat.Ico_zero_eq_range, Finset.mem_range] at hx ⊢ ++ exact hx.2 ++ rw [← Finset.sum_sdiff (s₁ := Finset.Ico 1 N) (s₂ := Finset.Ico 0 N) this] ++ have : Finset.Ico 0 N \ Finset.Ico 1 N = Finset.range 1 := by ++ ext a ++ simp only [Nat.Ico_zero_eq_range, Finset.mem_sdiff, Finset.mem_range, Finset.mem_Ico, not_and, ++ not_lt, Finset.range_one, Finset.mem_singleton] ++ exact ⟨fun _ ↦ by omega, fun ha ↦ ⟨by simp [ha, Npos], by omega⟩⟩ ++ rw [this]; simp ++ ++lemma UpperBnd_aux3 {A C σ t : ℝ} (hA : A ∈ Ioc 0 (1 / 2)) ++ (σ_ge : 1 - A / Real.log |t| ≤ σ) (t_gt : 3 < |t|) (hC : 2 ≤ C) : let N := ⌊|t|⌋₊; ++ ‖∑ n ∈ Finset.range (N + 1), (n : ℂ) ^ (-(σ + t * I))‖ ≤ ++ Real.exp A * C * Real.log |t| := by ++ intro N ++ obtain ⟨Npos, N_le_t, _, _, σPos, _⟩ := UpperBnd_aux hA t_gt σ_ge ++ have logt_gt := logt_gt_one t_gt.le ++ have (n : ℕ) (hn : n ∈ Finset.range (N + 1)) := ZetaBnd_aux2 (n := n) hA.1 σPos ?_ σ_ge ++ · replace := norm_sum_le_of_le (Finset.range (N + 1)) this ++ rw [← Finset.sum_mul, mul_comm _ (Real.exp A)] at this ++ rw [mul_assoc] ++ apply le_trans this <| (mul_le_mul_iff_right₀ A.exp_pos).mpr ?_ ++ have : 1 + Real.log (N : ℝ) ≤ C * Real.log |t| := by ++ by_cases hN : N = 1 ++ · simp only [hN, Nat.cast_one, Real.log_one, add_zero] ++ have : 2 * 1 ≤ C * Real.log |t| := mul_le_mul hC logt_gt.le (by linarith) (by linarith) ++ linarith ++ · rw [(by ring : C * Real.log |t| = Real.log |t| + (C - 1) * Real.log |t|), ++ ← one_mul <| Real.log (N: ℝ)] ++ apply add_le_add logt_gt.le ++ refine mul_le_mul (by linarith) ?_ (by positivity) (by linarith) ++ exact Real.log_le_log (by positivity) N_le_t ++ refine le_trans ?_ this ++ convert! harmonic_eq_sum_Icc ▸ harmonic_le_one_add_log N ++ · simp only [Rat.cast_sum, Rat.cast_inv, Rat.cast_natCast, Finset.range_eq_Ico] ++ rw [riemannZeta0_zero_aux (N + 1) (by linarith)]; congr! 1 ++ · simp only [Finset.mem_range] at hn ++ linarith [(by exact_mod_cast (by omega : n ≤ N) : (n : ℝ) ≤ N)] ++ ++lemma Nat.self_div_floor_bound {t : ℝ} (t_ge : 1 ≤ |t|) : let N := ⌊|t|⌋₊; ++ (|t| / N) ∈ Icc 1 2 := by ++ intro N ++ have Npos : 0 < N := Nat.floor_pos.mpr (by linarith) ++ have N_le_t : N ≤ |t| := Nat.floor_le <| abs_nonneg _ ++ constructor ++ · apply le_div_iff₀ (by simp [Npos]) |>.mpr; simp [N_le_t] ++ · apply div_le_iff₀ (by positivity) |>.mpr ++ suffices |t| < N + 1 by linarith [(by exact_mod_cast (by omega) : 1 ≤ (N : ℝ))] ++ apply Nat.lt_floor_add_one ++ ++lemma UpperBnd_aux5 {σ t : ℝ} (t_ge : 3 < |t|) (σ_le : σ ≤ 2) : (|t| / ⌊|t|⌋₊) ^ σ ≤ 4 := by ++ obtain ⟨h₁, h₂⟩ := Nat.self_div_floor_bound (by linarith) ++ calc _ ≤ ((|t| / ↑⌊|t|⌋₊) ^ (2 : ℝ)) := by gcongr ++ _ ≤ (2 : ℝ) ^ (2 : ℝ) := by gcongr ++ _ = 4 := by norm_num ++ ++lemma UpperBnd_aux6 {σ t : ℝ} (t_ge : 3 < |t|) (hσ : σ ∈ Ioc (1 / 2) 2) ++ (neOne : σ + t * I ≠ 1) (Npos : 0 < ⌊|t|⌋₊) (N_le_t : ⌊|t|⌋₊ ≤ |t|) : ++ ⌊|t|⌋₊ ^ (1 - σ) / ‖1 - (σ + t * I)‖ ≤ |t| ^ (1 - σ) * 2 ∧ ++ ⌊|t|⌋₊ ^ (-σ) / 2 ≤ |t| ^ (1 - σ) ∧ ⌊|t|⌋₊ ^ (-σ) / σ ≤ 8 * |t| ^ (-σ) := by ++ have bnd := UpperBnd_aux5 t_ge hσ.2 ++ have bnd' : (|t| / ⌊|t|⌋₊) ^ σ ≤ 2 * |t| := by linarith ++ split_ands ++ · apply (div_le_iff₀ <| norm_pos_iff.mpr <| sub_ne_zero_of_ne neOne.symm).mpr ++ conv => rw [mul_assoc]; rhs; rw [mul_comm] ++ apply (div_le_iff₀ <| Real.rpow_pos_of_pos (by linarith) _).mp ++ rw [div_rpow_eq_rpow_div_neg (by positivity) (by positivity), neg_sub] ++ refine le_trans₄ ?_ bnd' ?_ ++ · exact Real.rpow_le_rpow_of_exponent_le (one_le_div (by positivity) |>.mpr N_le_t) (by simp) ++ · apply (mul_le_mul_iff_right₀ (by norm_num)).mpr; simpa using abs_im_le_norm (1 - (σ + t * I)) ++ · apply div_le_iff₀ (by norm_num) |>.mpr ++ rw [Real.rpow_sub (by linarith), Real.rpow_one, div_mul_eq_mul_div, mul_comm] ++ apply div_le_iff₀ (by positivity) |>.mp ++ convert! bnd' using 1 ++ rw [← Real.rpow_neg (by linarith), div_rpow_neg_eq_rpow_div (by positivity) (by positivity)] ++ · apply div_le_iff₀ (by linarith [hσ.1]) |>.mpr ++ rw [mul_assoc, mul_comm, mul_assoc] ++ apply div_le_iff₀' (by positivity) |>.mp ++ apply le_trans ?_ (by linarith [hσ.1] : 4 ≤ σ * 8) ++ convert! bnd using 1; exact div_rpow_neg_eq_rpow_div (by positivity) (by positivity) ++ ++lemma ZetaUpperBnd' {A σ t : ℝ} (hA : A ∈ Ioc 0 (1 / 2)) (t_gt : 3 < |t|) ++ (hσ : σ ∈ Icc (1 - A / Real.log |t|) 2) : ++ let C := Real.exp A * (5 + 8 * 2); ++ let N := ⌊|t|⌋₊; ++ let s := σ + t * I; ++ ‖∑ n ∈ Finset.range (N + 1), 1 / (n : ℂ) ^ s‖ + ‖(N : ℂ) ^ (1 - s) / (1 - s)‖ ++ + ‖(N : ℂ) ^ (-s) / 2‖ ++ + ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ (s + 1)‖ ++ ≤ C * Real.log |t| := by ++ intros C N s ++ obtain ⟨Npos, N_le_t, logt_gt, σ_gt, σPos, neOne⟩ := UpperBnd_aux hA t_gt hσ.1 ++ replace σ_gt : 1 / 2 < σ := by linarith [hA.2] ++ calc ++ _ ≤ Real.exp A * 2 * Real.log |t| + ‖N ^ (1 - s) / (1 - s)‖ + ‖(N : ℂ) ^ (-s) / 2‖ + ++ ‖s * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) / (x : ℂ) ^ (s + 1)‖ := ?_ ++ _ ≤ Real.exp A * 2 * Real.log |t| + ‖N ^ (1 - s) / (1 - s)‖ + ‖(N : ℂ) ^ (-s) / 2‖ + ++ 2 * |t| * N ^ (-σ) / σ := ?_ ++ _ = Real.exp A * 2 * Real.log |t| + N ^ (1 - σ) / ‖(1 - s)‖ + N ^ (-σ) / 2 + ++ 2 * |t| * N ^ (-σ) / σ := ?_ ++ _ ≤ Real.exp A * 2 * Real.log |t| + |t| ^ (1 - σ) * 2 + ++ |t| ^ (1 - σ) + 2 * |t| * (8 * |t| ^ (-σ)) := ?_ ++ _ = Real.exp A * 2 * Real.log |t| + (3 + 8 * 2) * |t| ^ (1 - σ) := ?_ ++ _ ≤ Real.exp A * 2 * Real.log |t| + (3 + 8 * 2) * Real.exp A * 1 := ?_ ++ _ ≤ Real.exp A * 2 * Real.log |t| + (3 + 8 * 2) * Real.exp A * Real.log |t| := ?_ ++ _ = _ := by ring ++ · simp only [add_le_add_iff_right, one_div_cpow_eq_cpow_neg] ++ convert UpperBnd_aux3 (C := 2) hA hσ.1 t_gt le_rfl using 1 ++ · simp only [add_le_add_iff_left]; exact ZetaBnd_aux1 N (by linarith) ⟨σPos, hσ.2⟩ (by linarith) ++ · simp only [norm_div, RCLike.norm_ofNat, s] ++ congr <;> (convert norm_natCast_cpow_of_pos Npos _; simp) ++ · have ⟨h₁, h₂, h₃⟩ := UpperBnd_aux6 t_gt ⟨σ_gt, hσ.2⟩ neOne Npos N_le_t ++ gcongr ++ rw [mul_div_assoc] ++ gcongr ++ · ring_nf; conv => lhs; rhs; lhs; rw [mul_comm |t|] ++ rw [← Real.rpow_add_one (by positivity)]; ring_nf ++ · simp only [Real.log_abs, add_le_add_iff_left, mul_one] ++ exact mul_le_mul_iff_right₀ (by positivity) |>.mpr <| UpperBnd_aux2 t_gt hσ.1 ++ · simp only [add_le_add_iff_left] ++ apply mul_le_mul_iff_right₀ (by norm_num [Real.exp_pos]) |>.mpr <| logt_gt.le ++ ++lemma ZetaUpperBnd : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (C : ℝ) (_ : 0 < C), ∀ (σ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Icc (1 - A / Real.log |t|) 2), ‖ζ (σ + t * I)‖ ≤ C * Real.log |t| := by ++ let A := (1 / 2 : ℝ) ++ let C := Real.exp A * (5 + 8 * 2) ++ refine ⟨A, ⟨by norm_num, by norm_num⟩, C, (by positivity), ?_⟩ ++ intro σ t t_gt ⟨σ_ge, σ_le⟩ ++ obtain ⟨Npos, _, _, _, σPos, neOne⟩ := UpperBnd_aux ⟨by norm_num, by norm_num⟩ t_gt σ_ge ++ rw [← Zeta0EqZeta Npos (by simp [σPos]) neOne] ++ apply le_trans (by apply norm_add₄_le) ?_ ++ convert! ZetaUpperBnd' ⟨by norm_num, le_rfl⟩ t_gt ⟨σ_ge, σ_le⟩ using 1; simp ++ ++lemma norm_complex_log_ofNat (n : ℕ) : ‖(n : ℂ).log‖ = (n : ℝ).log := by ++ have := Complex.ofReal_log (x := (n : ℝ)) (Nat.cast_nonneg n) ++ rw [(by simp : ((n : ℝ) : ℂ) = (n : ℂ))] at this ++ rw [← this, Complex.norm_of_nonneg] ++ exact Real.log_natCast_nonneg n ++ ++lemma Real.log_natCast_monotone : Monotone (fun (n : ℕ) ↦ Real.log n) := by ++ intro n m hnm ++ cases n ++ · simp only [CharP.cast_eq_zero, Real.log_zero, Real.log_natCast_nonneg] ++ · apply Real.log_le_log <;> simp only [Nat.cast_add, Nat.cast_one] ++ · exact Nat.cast_add_one_pos _ ++ · exact_mod_cast hnm ++ ++lemma Finset.Icc0_eq (N : ℕ) : Finset.Icc 0 N = {0} ∪ Finset.Icc 1 N := by ++ refine Finset.ext_iff.mpr ?_ ++ intro a ++ cases a ++ · simp only [Finset.mem_Icc, le_refl, zero_le, and_self, Finset.mem_union, Finset.mem_singleton, ++ nonpos_iff_eq_zero, one_ne_zero, and_true, or_false] ++ · simp only [Finset.mem_Icc, le_add_iff_nonneg_left, zero_le, true_and, Finset.mem_union, ++ Finset.mem_singleton, add_eq_zero, one_ne_zero, and_false, false_or] ++ ++lemma harmonic_eq_sum_Icc0_aux (N : ℕ) : ++ ∑ i ∈ Finset.Icc 0 N, (i : ℝ)⁻¹ = ∑ i ∈ Finset.Icc 1 N, (i : ℝ)⁻¹ := by ++ rw [Finset.Icc0_eq, Finset.sum_union] ++ · simp only [Finset.sum_singleton, CharP.cast_eq_zero, inv_zero, zero_add] ++ · simp only [Finset.disjoint_singleton_left, Finset.mem_Icc, nonpos_iff_eq_zero, one_ne_zero, ++ zero_le, and_true, not_false_eq_true] ++ ++lemma harmonic_eq_sum_Icc0 (N : ℕ) : ∑ i ∈ Finset.Icc 0 N, (i : ℝ)⁻¹ = (harmonic N : ℝ) := by ++ rw [harmonic_eq_sum_Icc0_aux, harmonic_eq_sum_Icc] ++ simp only [Rat.cast_sum, Rat.cast_inv, Rat.cast_natCast] ++ ++lemma DerivUpperBnd_aux1 {A C σ t : ℝ} (hA : A ∈ Ioc 0 (1 / 2)) ++ (σ_ge : 1 - A / Real.log |t| ≤ σ) (t_gt : 3 < |t|) (hC : 2 ≤ C) : let N := ⌊|t|⌋₊; ++ ‖∑ n ∈ Finset.range (N + 1), -1 / (n : ℂ) ^ (σ + t * I) * (Real.log n)‖ ++ ≤ Real.exp A * C * (Real.log |t|) ^ 2 := by ++ intro N ++ obtain ⟨Npos, N_le_t, _, _, σPos, _⟩ := UpperBnd_aux hA t_gt σ_ge ++ have logt_gt := logt_gt_one t_gt.le ++ have logN_pos : 0 ≤ Real.log N := Real.log_nonneg (by norm_cast) ++ have fact0 {n : ℕ} (hn : n ≤ N) : n ≤ |t| := by linarith [(by exact_mod_cast hn : (n : ℝ) ≤ N)] ++ have fact1 {n : ℕ} (hn : n ≤ N) : ++ ‖(n : ℂ) ^ (-(σ + t * I))‖ ≤ (n : ℝ)⁻¹ * A.exp := ZetaBnd_aux2 hA.1 σPos (fact0 hn) σ_ge ++ have fact2 {n : ℕ} (hn : n ≤ N) : Real.log n ≤ Real.log |t| := by ++ cases n ++ · simp only [CharP.cast_eq_zero, Real.log_zero]; linarith ++ · exact Real.log_le_log (by exact_mod_cast Nat.add_one_pos _) (fact0 hn) ++ have fact3 (n : ℕ) (hn : n ≤ N) : ++ ‖-1 / (n : ℂ) ^ (σ + t * I) * (Real.log n)‖ ≤ (n : ℝ)⁻¹ * Real.exp A * (Real.log |t|) := by ++ convert! mul_le_mul (fact1 hn) (fact2 hn) (Real.log_natCast_nonneg n) (by positivity) ++ simp only [norm_mul, norm_div, norm_neg, norm_one, one_div, natCast_log, ← norm_inv, cpow_neg] ++ congr; exact norm_complex_log_ofNat n ++ have := norm_sum_le_of_le (Finset.range (N + 1)) ++ (by simp only [Finset.mem_range, Nat.lt_succ_iff]; exact fact3) ++ rw [← Finset.sum_mul, ← Finset.sum_mul, mul_comm _ A.exp, mul_assoc] at this ++ rw [mul_assoc] ++ apply le_trans this <| (mul_le_mul_iff_right₀ A.exp_pos).mpr ?_ ++ rw [pow_two, ← mul_assoc, Finset.range_eq_Ico, ← Finset.Icc_eq_Ico, harmonic_eq_sum_Icc0] ++ apply le_trans (mul_le_mul (h₁ := harmonic_le_one_add_log (n := N)) (le_refl (Real.log |t|)) ++ (by linarith) (by linarith)) ++ apply (mul_le_mul_iff_left₀ (by linarith)).mpr ++ rw [(by ring : C * Real.log |t| = Real.log |t| + (C - 1) * Real.log |t|), ++ ← one_mul <| Real.log (N: ℝ)] ++ refine add_le_add logt_gt.le <| mul_le_mul (by linarith) ?_ (by positivity) (by linarith) ++ exact Real.log_le_log (by positivity) N_le_t ++ ++lemma DerivUpperBnd_aux2 {A σ t : ℝ} (t_gt : 3 < |t|) (hσ : σ ∈ Icc (1 - A / |t|.log) 2) : ++ let N := ⌊|t|⌋₊; ++ let s := ↑σ + ↑t * I; ++ 0 < N → ↑N ≤ |t| → s ≠ 1 → ++ 1 / 2 < σ → ‖-↑N ^ (1 - s) / (1 - s) ^ 2‖ ≤ A.exp * 2 * (1 / 3) := by ++ intro N s Npos N_le_t neOne σ_gt ++ dsimp only [s] ++ simp_rw [norm_div, norm_neg, norm_pow, norm_natCast_cpow_of_pos Npos _, ++ sub_re, one_re, add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, ++ mul_one, sub_self, add_zero] ++ have h := UpperBnd_aux6 t_gt ⟨σ_gt, hσ.2⟩ neOne Npos N_le_t |>.1 ++ rw [(by ring_nf : N ^ (1 - σ) / ‖1 - (↑σ + ↑t * I)‖ ^ 2 = ++ N ^ (1 - σ) / ‖1 - (↑σ + ↑t * I)‖ * 1 / ‖1 - (↑σ + ↑t * I)‖)] ++ apply mul_le_mul ?_ ?_ (inv_nonneg.mpr <| norm_nonneg _) ?_ ++ · rw [mul_one]; exact le_trans h (by gcongr; exact UpperBnd_aux2 t_gt hσ.1) ++ · rw [inv_eq_one_div, div_le_iff₀ <| norm_pos_iff.mpr <| sub_ne_zero_of_ne neOne.symm, ++ mul_comm, ← mul_div_assoc, mul_one, le_div_iff₀ (by norm_num), one_mul] ++ apply le_trans t_gt.le ?_ ++ rw [← abs_neg]; convert! abs_im_le_norm (1 - (σ + t * I)); simp ++ · exact mul_nonneg (Real.exp_nonneg _) (by norm_num) ++ ++theorem DerivUpperBnd_aux3 {A σ t : ℝ} (t_gt : 3 < |t|) (hσ : σ ∈ Icc (1 - A / |t|.log) 2) : ++ let N := ⌊|t|⌋₊; ++ let s := ↑σ + ↑t * I; ++ 0 < N → ↑N ≤ |t| → s ≠ 1 → 1 / 2 < σ → ++ ‖↑(N : ℝ).log * ↑N ^ (1 - s) / (1 - s)‖ ≤ A.exp * 2 * |t|.log := by ++ intro N s Npos N_le_t neOne σ_gt ++ rw [norm_div, norm_mul, mul_div_assoc, mul_comm] ++ apply mul_le_mul ?_ ?_ (by positivity) (by positivity) ++ · have h := UpperBnd_aux6 t_gt ⟨σ_gt, hσ.2⟩ neOne Npos N_le_t |>.1 ++ convert le_trans h ?_ using 1 ++ · simp [s, norm_natCast_cpow_of_pos Npos _, N] ++ · gcongr; exact UpperBnd_aux2 t_gt hσ.1 ++ · rw [natCast_log, norm_complex_log_ofNat] ++ exact Real.log_le_log (by positivity) N_le_t ++ ++theorem DerivUpperBnd_aux4 {A σ t : ℝ} (t_gt : 3 < |t|) (hσ : σ ∈ Icc (1 - A / |t|.log) 2) : ++ let N := ⌊|t|⌋₊; ++ let s := ↑σ + ↑t * I; ++ 0 < N → ↑N ≤ |t| → s ≠ 1 → 1 / 2 < σ → ++ ‖↑(N : ℝ).log * (N : ℂ) ^ (-s) / 2‖ ≤ A.exp * |t|.log := by ++ intro N s Npos N_le_t neOne σ_gt ++ rw [norm_div, norm_mul, mul_div_assoc, mul_comm, RCLike.norm_ofNat] ++ apply mul_le_mul ?_ ?_ (by positivity) (by positivity) ++ · have h := UpperBnd_aux6 t_gt ⟨σ_gt, hσ.2⟩ neOne Npos N_le_t |>.2.1 ++ convert le_trans h (UpperBnd_aux2 t_gt hσ.1) using 1 ++ simp [s, norm_natCast_cpow_of_pos Npos _, N] ++ · rw [natCast_log, norm_complex_log_ofNat] ++ exact Real.log_le_log (by positivity) N_le_t ++ ++theorem DerivUpperBnd_aux5 {A σ t : ℝ} (t_gt : 3 < |t|) (hσ : σ ∈ Icc (1 - A / |t|.log) 2) : ++ let N := ⌊|t|⌋₊; ++ let s := ↑σ + ↑t * I; ++ 0 < N → 1 / 2 < σ → ++ ‖1 * ∫ (x : ℝ) in Ioi (N : ℝ), (↑⌊x⌋ + 1 / 2 - ↑x) * (x : ℂ) ^ (-s - 1)‖ ≤ ++ 1 / 3 * (2 * |t| * ↑N ^ (-σ) / σ) := by ++ intro N s Npos σ_gt ++ have neZero : s ≠ 0 := by ++ contrapose! σ_gt ++ simp only [Complex.ext_iff, add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, add_zero, zero_re, add_im, mul_im, zero_add, zero_im, s] at σ_gt ++ linarith ++ have : 1 = 1 / s * s := by field_simp ++ nth_rewrite 1 [this] ++ rw [mul_assoc, norm_mul] ++ apply mul_le_mul ?_ ?_ (by positivity) (by positivity) ++ · simp only [s, norm_div, norm_one] ++ apply one_div_le_one_div (norm_pos_iff.mpr neZero) (by norm_num) |>.mpr ++ apply le_trans t_gt.le ?_ ++ convert! abs_im_le_norm (σ + t * I); simp ++ · have hσ : σ ∈ Ioc 0 2 := ⟨(by linarith), hσ.2⟩ ++ simp only [s] ++ have := ZetaBnd_aux1 N (by omega) hσ (by linarith) ++ simp only [div_cpow_eq_cpow_neg] at this ++ convert! this using 1; congr; funext x; ring_nf ++ ++theorem DerivUpperBnd_aux6 {A σ t : ℝ} (t_gt : 3 < |t|) (hσ : σ ∈ Icc (1 - A / |t|.log) 2) : ++ let N := ⌊|t|⌋₊; ++ 0 < N → ↑N ≤ |t| → ↑σ + ↑t * I ≠ 1 → 1 / 2 < σ → ++ 2 * |t| * ↑N ^ (-σ) / σ ≤ 2 * (8 * A.exp) := by ++ intro N Npos N_le_t neOne σ_gt ++ rw [mul_div_assoc, mul_assoc] ++ apply mul_le_mul_iff_right₀ (by norm_num) |>.mpr ++ have h := UpperBnd_aux6 t_gt ⟨σ_gt, hσ.2⟩ neOne Npos N_le_t |>.2.2 ++ apply le_trans (mul_le_mul_iff_right₀ (a := |t|) (by positivity) |>.mpr h) ?_ ++ rw [← mul_assoc, mul_comm _ 8, mul_assoc] ++ gcongr ++ convert! UpperBnd_aux2 t_gt hσ.1 using 1 ++ rw [mul_comm, ← Real.rpow_add_one (by positivity)]; ring_nf ++ ++lemma DerivUpperBnd_aux7_1 {x σ t : ℝ} (hx : 1 ≤ x) : ++ let s := ↑σ + ↑t * I; ++ ‖(↑⌊x⌋ + 1 / 2 - ↑x) * (x : ℂ) ^ (-s - 1) * -↑x.log‖ = |(↑⌊x⌋ + 1 / 2 - x)| * x ^ (-σ - 1) * x.log := by ++ have xpos : 0 < x := lt_of_lt_of_le (by norm_num) hx ++ have : ‖(x.log : ℂ)‖ = x.log := Complex.norm_of_nonneg <| Real.log_nonneg hx ++ simp [← norm_real, this, Complex.norm_cpow_eq_rpow_re_of_pos xpos, ← Real.norm_eq_abs, ← ofReal_ofNat, ++ ← ofReal_inv, ← ofReal_add, ← ofReal_sub, ← ofReal_intCast, one_div] ++ ++lemma DerivUpperBnd_aux7_2 {x σ : ℝ} (hx : 1 ≤ x) : ++ |(↑⌊x⌋ + 1 / 2 - x)| * x ^ (-σ - 1) * x.log ≤ x ^ (-σ - 1) * x.log := by ++ rw [← one_mul (x ^ (-σ - 1) * Real.log x), mul_assoc] ++ apply mul_le_mul_of_nonneg_right _ (by bound) ++ exact le_trans (ZetaSum_aux1_3 x) (by norm_num) ++ ++lemma DerivUpperBnd_aux7_3 {x σ : ℝ} (xpos : 0 < x) (σnz : σ ≠ 0) : ++ HasDerivAt (fun t ↦ -(1 / σ ^ 2 * t ^ (-σ) + 1 / σ * t ^ (-σ) * Real.log t)) ++ (x ^ (-σ - 1) * Real.log x) x := by ++ have h1 := Real.hasDerivAt_rpow_const (p := -σ) (Or.inl xpos.ne.symm) ++ have h2 := h1.const_mul (1 / σ^2) ++ have cancel : 1 / σ^2 * σ = 1 / σ := by field_simp ++ rw [neg_mul, mul_neg, ← mul_assoc, cancel] at h2 ++ have h3 := Real.hasDerivAt_log xpos.ne.symm ++ have h4 := HasDerivAt.mul (h1.const_mul (1 / σ)) h3 ++ have cancel := Real.rpow_add xpos (-σ) (-1) ++ have : -σ + -1 = -σ - 1 := by rfl ++ rw [← Real.rpow_neg_one x, mul_assoc (1 / σ) (x ^ (-σ)), ← cancel, this] at h4 ++ convert! h2.add h4 |>.neg using 1 ++ field_simp; ring ++ ++lemma DerivUpperBnd_aux7_3' {a σ : ℝ} (apos : 0 < a) (σnz : σ ≠ 0) : ++ ∀ x ∈ Ici a, HasDerivAt (fun t ↦ -(1 / σ ^ 2 * t ^ (-σ) + 1 / σ * t ^ (-σ) * Real.log t)) ++ (x ^ (-σ - 1) * Real.log x) x := by ++ intro x hx ++ simp at hx ++ exact DerivUpperBnd_aux7_3 (by linarith) σnz ++ ++lemma DerivUpperBnd_aux7_nonneg {a σ : ℝ} (ha : 1 ≤ a) : ++ ∀ x ∈ Ioi a, 0 ≤ x ^ (-σ - 1) * Real.log x := by ++ intro x hx ++ simp at hx ++ bound ++ ++lemma DerivUpperBnd_aux7_tendsto {σ : ℝ} (σpos : 0 < σ) : ++ Tendsto (fun t ↦ -(1 / σ ^ 2 * t ^ (-σ) + 1 / σ * t ^ (-σ) * Real.log t)) atTop (nhds 0) := by ++ have h1 := tendsto_rpow_neg_atTop σpos ++ have h2 := h1.const_mul (1 / σ^2) ++ have h3 : Tendsto (fun t : ℝ ↦ t ^ (-σ) * Real.log t) atTop (nhds 0) := by ++ have := Real.tendsto_pow_log_div_pow_atTop σ 1 σpos ++ simp only [Real.rpow_one] at this ++ apply Tendsto.congr' _ this ++ filter_upwards [eventually_ge_atTop 0] with x hx ++ rw [mul_comm] ++ apply div_rpow_eq_rpow_neg _ _ _ hx ++ have h4 := h3.const_mul (1 / σ) ++ have h5 := (h2.add h4).neg ++ convert h5 using 1 ++ · ext; ring ++ simp ++ ++open MeasureTheory in ++lemma DerivUpperBnd_aux7_4 {a σ : ℝ} (σpos : 0 < σ) (ha : 1 ≤ a) : ++ IntegrableOn (fun x ↦ x ^ (-σ - 1) * Real.log x) (Ioi a) volume := by ++ apply integrableOn_Ioi_deriv_of_nonneg' (l := 0) ++ · exact DerivUpperBnd_aux7_3' (by linarith) (by linarith) ++ · exact DerivUpperBnd_aux7_nonneg ha ++ · exact DerivUpperBnd_aux7_tendsto σpos ++ ++open MeasureTheory in ++lemma DerivUpperBnd_aux7_5 {a σ : ℝ} (σpos : 0 < σ) (ha : 1 ≤ a) : ++ IntegrableOn (fun x ↦ |(↑⌊x⌋ + (1 : ℝ) / 2 - x)| * x ^ (-σ - 1) * Real.log x) ++ (Ioi a) volume := by ++ simp_rw [mul_assoc] ++ apply Integrable.bdd_mul (c := 1 / 2) <| DerivUpperBnd_aux7_4 σpos ha ++ · exact Measurable.aestronglyMeasurable <| Measurable.abs measurable_floor_add_half_sub ++ apply ae_of_all ++ intro x ++ simp only [Real.norm_eq_abs, _root_.abs_abs] ++ exact ZetaSum_aux1_3 x ++ ++open MeasureTheory in ++lemma DerivUpperBnd_aux7_integral_eq {a σ : ℝ} (ha : 1 ≤ a) (σpos : 0 < σ) : ++ ∫ (x : ℝ) in Ioi a, x ^ (-σ - 1) * Real.log x = ++ 1 / σ^2 * a ^ (-σ) + 1 / σ * a ^ (-σ) * Real.log a := by ++ convert integral_Ioi_of_hasDerivAt_of_nonneg' ++ (DerivUpperBnd_aux7_3' (by linarith) (by linarith)) ++ (DerivUpperBnd_aux7_nonneg ha) (DerivUpperBnd_aux7_tendsto σpos) using 1 ++ ring ++ ++open MeasureTheory in ++ ++theorem DerivUpperBnd_aux7 {A σ t : ℝ} (t_gt : 3 < |t|) (hσ : σ ∈ Icc (1 - A / |t|.log) 2) : ++ let N := ⌊|t|⌋₊; ++ let s := ↑σ + ↑t * I; ++ 0 < N → ↑N ≤ |t| → s ≠ 1 → 1 / 2 < σ → ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), (↑⌊x⌋ + 1 / 2 - ↑x) * (x : ℂ) ^ (-s - 1) * -↑x.log‖ ≤ ++ 6 * |t| * ↑N ^ (-σ) / σ * |t|.log := by ++ intro N s Npos N_le_t neOne σ_gt ++ have σpos : 0 < σ := lt_trans (by norm_num) σ_gt ++ rw [norm_mul, (by ring : 6 * |t| * ↑N ^ (-σ) / σ * Real.log |t| = (2 * |t|) * (3 * ↑N ^ (-σ) / σ * Real.log |t|))] ++ apply mul_le_mul _ _ (by positivity) (by positivity) ++ · apply le_trans (by apply norm_add_le) ++ simp [abs_of_pos σpos] ++ linarith [hσ.2] ++ apply le_trans (by apply norm_integral_le_integral_norm) ++ calc ∫ (x : ℝ) in Ioi (N : ℝ), ‖(↑⌊x⌋ + 1 / 2 - ↑x) * (x : ℂ) ^ (-s - 1) * -↑x.log‖ ++ _ = ∫ (x : ℝ) in Ioi (N : ℝ), |(↑⌊x⌋ + 1 / 2 - x)| * x ^ (-σ - 1) * x.log := by ++ apply setIntegral_congr_fun (by measurability) ++ intro x hx ++ simp only [mem_Ioi] at hx ++ exact DerivUpperBnd_aux7_1 (lt_of_le_of_lt (mod_cast Npos) hx).le ++ _ ≤ ∫ (x : ℝ) in Ioi (N : ℝ), x ^ (-σ - 1) * x.log := by ++ apply setIntegral_mono_on _ _ (by measurability) ++ · intro x hx ++ exact DerivUpperBnd_aux7_2 (lt_of_le_of_lt (mod_cast Npos) hx).le ++ · apply DerivUpperBnd_aux7_5 σpos (mod_cast Npos) ++ apply DerivUpperBnd_aux7_4 σpos (mod_cast Npos) ++ _ = 1 / σ^2 * N ^ (-σ) + 1 / σ * N ^ (-σ) * Real.log N := ++ DerivUpperBnd_aux7_integral_eq (mod_cast Npos) σpos ++ _ ≤ 3 * ↑N ^ (-σ) / σ * |t|.log := by ++ have h2 : 1 / σ * ↑N ^ (-σ) * Real.log ↑N ≤ ↑N ^ (-σ) / σ * Real.log |t| := calc ++ _ = ↑N ^ (-σ) / σ * Real.log N := by ring ++ _ ≤ _ := by ++ apply mul_le_mul_of_nonneg_left _ (by positivity) ++ exact Real.log_le_log (mod_cast Npos) N_le_t ++ have : 2 ≤ 2 * Real.log |t| := by ++ nth_rewrite 1 [← mul_one 2] ++ apply mul_le_mul_of_nonneg_left _ (by norm_num) ++ exact logt_gt_one t_gt.le |>.le ++ have h1 : 1 / σ^2 * ↑N ^ (-σ) ≤ 2 * ↑N ^ (-σ) / σ * Real.log |t| := calc ++ 1 / σ^2 * ↑N ^ (-σ) = (↑N ^ (-σ) / σ) * (1 / σ) := by ring ++ _ ≤ ↑N ^ (-σ) / σ * (2 * Real.log |t|):= by ++ apply mul_le_mul_of_nonneg_left _ (by positivity) ++ apply le_trans _ this ++ exact (one_div_le σpos (by norm_num)).mpr σ_gt.le ++ _ = _ := by ring ++ convert! add_le_add h1 h2 using 1 ++ ring ++ ++lemma ZetaDerivUpperBnd' {A σ t : ℝ} (hA : A ∈ Ioc 0 (1 / 2)) (t_gt : 3 < |t|) ++ (hσ : σ ∈ Icc (1 - A / Real.log |t|) 2) : ++ let C := Real.exp A * 59; ++ let N := ⌊|t|⌋₊; ++ let s := σ + t * I; ++ ‖∑ n ∈ Finset.range (N + 1), -1 / (n : ℂ) ^ s * (Real.log n)‖ + ++ ‖-(N : ℂ) ^ (1 - s) / (1 - s) ^ 2‖ + ++ ‖(Real.log N) * (N : ℂ) ^ (1 - s) / (1 - s)‖ + ++ ‖(Real.log N) * (N : ℂ) ^ (-s) / 2‖ + ++ ‖(1 * ∫ (x : ℝ) in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1))‖ + ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), ++ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1) * -(Real.log x)‖ ++ ≤ C * Real.log |t| ^ 2 := by ++ intros C N s ++ obtain ⟨Npos, N_le_t, logt_gt, σ_gt, _, neOne⟩ := UpperBnd_aux hA t_gt hσ.1 ++ replace σ_gt : 1 / 2 < σ := by linarith [hA.2] ++ calc _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ ‖-(N : ℂ) ^ (1 - s) / (1 - s) ^ 2‖ + ++ ‖(Real.log N) * (N : ℂ) ^ (1 - s) / (1 - s)‖ + ++ ‖(Real.log N) * (N : ℂ) ^ (-s) / 2‖ + ++ ‖(1 * ∫ (x : ℝ) in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1))‖ + ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), ++ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1) * -(Real.log x)‖ := by ++ gcongr; exact DerivUpperBnd_aux1 hA hσ.1 t_gt (by simp : (2 : ℝ) ≤ 2) ++ _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ Real.exp A * 2 * (1 / 3) + ++ ‖(Real.log N) * (N : ℂ) ^ (1 - s) / (1 - s)‖ + ++ ‖(Real.log N) * (N : ℂ) ^ (-s) / 2‖ + ++ ‖(1 * ∫ (x : ℝ) in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1))‖ + ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), ++ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1) * -(Real.log x)‖ := by ++ gcongr; exact DerivUpperBnd_aux2 t_gt hσ Npos N_le_t neOne σ_gt ++ _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ Real.exp A * 2 * (1 / 3) + ++ Real.exp A * 2 * (Real.log |t|) + ++ ‖(Real.log N) * (N : ℂ) ^ (-s) / 2‖ + ++ ‖(1 * ∫ (x : ℝ) in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1))‖ + ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), ++ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1) * -(Real.log x)‖ := by ++ gcongr; exact DerivUpperBnd_aux3 t_gt hσ Npos N_le_t neOne σ_gt ++ _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ Real.exp A * 2 * (1 / 3) + ++ Real.exp A * 2 * (Real.log |t|) + ++ Real.exp A * (Real.log |t|) + ++ ‖(1 * ∫ (x : ℝ) in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1))‖ + ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), ++ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1) * -(Real.log x)‖ := by ++ gcongr; exact DerivUpperBnd_aux4 t_gt hσ Npos N_le_t neOne σ_gt ++ _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ Real.exp A * 2 * (1 / 3) + ++ Real.exp A * 2 * (Real.log |t|) + ++ Real.exp A * (Real.log |t|) + ++ 1 / 3 * (2 * |t| * N ^ (-σ) / σ) + ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), ++ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1) * -(Real.log x)‖ := by ++ gcongr; exact DerivUpperBnd_aux5 t_gt hσ Npos σ_gt ++ _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ Real.exp A * 2 * (1 / 3) + ++ Real.exp A * 2 * (Real.log |t|) + ++ Real.exp A * (Real.log |t|) + ++ 1 / 3 * (2 * (8 * Real.exp A)) + ++ ‖s * ∫ (x : ℝ) in Ioi (N : ℝ), ++ (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-s - 1) * -(Real.log x)‖ := by ++ gcongr; exact DerivUpperBnd_aux6 t_gt hσ Npos N_le_t neOne σ_gt ++ _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ Real.exp A * 2 * (1 / 3) + ++ Real.exp A * 2 * (Real.log |t|) + ++ Real.exp A * (Real.log |t|) + ++ 1 / 3 * (2 * (8 * Real.exp A)) + ++ (6 * |t| * N ^ (-σ) / σ) * (Real.log |t|) := by ++ gcongr; exact DerivUpperBnd_aux7 t_gt hσ Npos N_le_t neOne σ_gt ++ _ ≤ Real.exp A * 2 * (Real.log |t|) ^ 2 + ++ Real.exp A * 2 * (1 / 3) + ++ Real.exp A * 2 * (Real.log |t|) + ++ Real.exp A * (Real.log |t|) + ++ 1 / 3 * (2 * (8 * Real.exp A)) + ++ (6 * (8 * Real.exp A)) * (Real.log |t|) := by ++ gcongr; convert mul_le_mul_of_nonneg_left (DerivUpperBnd_aux6 t_gt hσ Npos N_le_t neOne σ_gt) (by norm_num : (0 : ℝ) ≤ 3) using 1 <;> ring ++ _ ≤ _ := by ++ simp only [C] ++ ring_nf ++ rw [(by ring : A.exp * |t|.log ^ 2 * 59 = A.exp * |t|.log ^ 2 * 6 + A.exp * |t|.log ^ 2 * 51 + ++ A.exp * |t|.log ^ 2 * 2)] ++ nth_rewrite 1 [← mul_one A.exp] ++ gcongr ++ swap ++ · nth_rewrite 1 [← mul_one |t|.log, (by ring : |t|.log ^ 2 = |t|.log * |t|.log)] ++ gcongr ++ nlinarith ++ ++lemma ZetaDerivUpperBnd : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (C : ℝ) (_ : 0 < C), ∀ (σ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Icc (1 - A / Real.log |t|) 2), ++ ‖ζ' (σ + t * I)‖ ≤ C * Real.log |t| ^ 2 := by ++ obtain ⟨A, hA, _, _, _⟩ := ZetaUpperBnd ++ let C := Real.exp A * 59 ++ refine ⟨A, hA, C, by positivity, ?_⟩ ++ intro σ t t_gt ⟨σ_ge, σ_le⟩ ++ obtain ⟨Npos, N_le_t, _, _, σPos, neOne⟩ := UpperBnd_aux hA t_gt σ_ge ++ rw [← DerivZeta0EqDerivZeta Npos (by simp [σPos]) neOne] ++ set N : ℕ := ⌊|t|⌋₊ ++ rw [(HasDerivAtZeta0 Npos (s := σ + t * I) (by simp [σPos]) neOne).deriv] ++ dsimp only [ζ₀'] ++ rw [← add_assoc] ++ set aa := ∑ n ∈ Finset.range (N + 1), -1 / (n : ℂ) ^ (σ + t * I) * (Real.log n) ++ set bb := -(N : ℂ) ^ (1 - (σ + t * I)) / (1 - (σ + t * I)) ^ 2 ++ set cc := (Real.log N) * (N : ℂ) ^ (1 - (σ + t * I)) / (1 - (σ + t * I)) ++ set dd := (Real.log N) * (N : ℂ) ^ (-(σ + t * I)) / 2 ++ set ee := 1 * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(σ + t * I) - 1) ++ set ff := (σ + t * I) * ∫ x in Ioi (N : ℝ), (⌊x⌋ + 1 / 2 - x) * (x : ℂ) ^ (-(σ + t * I) - 1) * -(Real.log x) ++ rw [(by ring : aa + (bb + cc) + dd + ee + ff = aa + bb + cc + dd + ee + ff)] ++ apply le_trans (by apply norm_add₆_le) ?_ ++ convert ZetaDerivUpperBnd' hA t_gt ⟨σ_ge, σ_le⟩ ++ ++lemma Tendsto_nhdsWithin_punctured_map_add {f : ℝ → ℝ} (a x : ℝ) ++ (f_mono : StrictMono f) (f_iso : Isometry f) : ++ Tendsto (fun y ↦ f y + a) (𝓝[>] x) (𝓝[>] (f x + a)) := by ++ refine tendsto_iff_forall_eventually_mem.mpr ?_ ++ intro v hv ++ simp only [mem_nhdsWithin] at hv ++ obtain ⟨u, hu, hu2, hu3⟩ := hv ++ let t := {x | f x + a ∈ u} ++ have : t ∩ Ioi x ∈ 𝓝[>] x := by ++ simp only [mem_nhdsWithin] ++ use t ++ simp only [subset_inter_iff, inter_subset_left, inter_subset_right, and_self, ++ and_true, t, mem_ofPred_eq] ++ refine ⟨?_, by simp [hu2]⟩ ++ simp only [Metric.isOpen_iff, gt_iff_lt, mem_ofPred_eq] at hu ⊢ ++ intro x hx ++ obtain ⟨ε, εpos, hε⟩ := hu (f x + a) hx ++ simp only [Metric.ball, ofPred_subset_ofPred] at hε ⊢ ++ exact ⟨ε, εpos, fun _ hy ↦ hε (by simp [isometry_iff_dist_eq.mp f_iso, hy])⟩ ++ filter_upwards [this] ++ intro b hb ++ simp only [mem_inter_iff, mem_ofPred_eq, mem_Ioi, t] at hb ++ refine hu3 ?_ ++ simp only [mem_inter_iff, mem_Ioi, add_lt_add_iff_right] ++ exact ⟨hb.1, f_mono hb.2⟩ ++ ++lemma Tendsto_nhdsWithin_punctured_add (a x : ℝ) : ++ Tendsto (fun y ↦ y + a) (𝓝[>] x) (𝓝[>] (x + a)) := ++ Tendsto_nhdsWithin_punctured_map_add a x strictMono_id isometry_id ++ ++lemma riemannZeta_isBigO_near_one_horizontal : ++ (fun x : ℝ ↦ ζ (1 + x)) =O[𝓝[>] 0] (fun x ↦ (1 : ℂ) / x) := by ++ have : (fun w : ℂ ↦ ζ (1 + w)) =O[𝓝[≠] 0] (1 / ·) := by ++ have H : Tendsto (fun w ↦ w * ζ (1 + w)) (𝓝[≠] 0) (𝓝 1) := by ++ convert Tendsto.comp (f := fun w ↦ 1 + w) riemannZeta_residue_one ?_ using 1 ++ · ext w ++ simp only [Function.comp_apply, add_sub_cancel_left] ++ · refine tendsto_iff_comap.mpr <| map_le_iff_le_comap.mp <| Eq.le ?_ ++ convert Homeomorph.map_punctured_nhds_eq (Homeomorph.addLeft (1 : ℂ)) 0 using 2 <;> simp ++ exact ((Asymptotics.isBigO_mul_iff_isBigO_div eventually_mem_nhdsWithin).mp <| ++ Tendsto.isBigO_one ℂ H).trans <| Asymptotics.isBigO_refl .. ++ exact (isBigO_comp_ofReal_nhds_ne this).mono <| nhdsGT_le_nhdsNE 0 ++ ++lemma ZetaNear1BndFilter : ++ (fun σ : ℝ ↦ ζ σ) =O[𝓝[>](1 : ℝ)] (fun σ ↦ (1 : ℂ) / (σ - 1)) := by ++ have := Tendsto_nhdsWithin_punctured_add (a := -1) (x := 1) ++ simp only [add_neg_cancel, ← sub_eq_add_neg] at this ++ have := riemannZeta_isBigO_near_one_horizontal.comp_tendsto this ++ convert this using 1 <;> {ext; simp} ++ ++lemma ZetaNear1BndExact : ++ ∃ (c : ℝ) (_ : 0 < c), ∀ (σ : ℝ) (_ : σ ∈ Ioc 1 2), ‖ζ σ‖ ≤ c / (σ - 1) := by ++ have := ZetaNear1BndFilter ++ rw [Asymptotics.isBigO_iff] at this ++ obtain ⟨c, U, hU, V, hV, h⟩ := this ++ obtain ⟨T, hT, T_open, h1T⟩ := mem_nhds_iff.mp hU ++ obtain ⟨ε, εpos, hε⟩ := Metric.isOpen_iff.mp T_open 1 h1T ++ simp only [Metric.ball] at hε ++ replace hε : Ico 1 (1 + ε) ⊆ U := by ++ refine subset_trans (subset_trans ?_ hε) hT ++ intro x hx ++ simp only [mem_Ico] at hx ++ simp only [dist, abs_lt] ++ exact ⟨by linarith, by linarith⟩ ++ let W := Icc (1 + ε) 2 ++ have W_compact : IsCompact {ofReal z | z ∈ W} := ++ IsCompact.image isCompact_Icc continuous_ofReal ++ have cont : ContinuousOn ζ {ofReal z | z ∈ W} := by ++ apply HasDerivAt.continuousOn (f' := ζ') ++ intro σ hσ ++ exact (differentiableAt_riemannZeta (by contrapose! hσ; simp [W, hσ, εpos])).hasDerivAt ++ obtain ⟨C, hC⟩ := IsCompact.exists_bound_of_continuousOn W_compact cont ++ let C' := max (C + 1) 1 ++ replace hC : ∀ (σ : ℝ), σ ∈ W → ‖ζ σ‖ < C' := by ++ intro σ hσ ++ simp only [lt_max_iff, C'] ++ have := hC σ ++ simp only [mem_ofPred_eq, ofReal_inj, exists_eq_right] at this ++ exact Or.inl <| lt_of_le_of_lt (this hσ) (by norm_num) ++ have Cpos : 0 < C' := by simp [C'] ++ use max (2 * C') c, (by simp [Cpos]) ++ intro σ ⟨σ_ge, σ_le⟩ ++ by_cases hσ : σ ∈ U ∩ V ++ · simp only [← h, mem_ofPred_eq] at hσ ++ apply le_trans hσ ?_ ++ norm_cast ++ have : 0 ≤ 1 / (σ - 1) := by apply one_div_nonneg.mpr; linarith ++ simp only [Real.norm_eq_abs, abs_eq_self.mpr this, mul_div, mul_one] ++ exact div_le_div₀ (by simp [Cpos.le]) (by simp) (by linarith) (by rfl) ++ · replace hσ : σ ∈ W := by ++ simp only [mem_inter_iff, hV σ_ge, and_true] at hσ ++ simp only [mem_Icc, σ_le, and_true, W] ++ contrapose! hσ; exact hε ⟨σ_ge.le, hσ⟩ ++ apply le_trans (hC σ hσ).le ((le_div_iff₀ (by linarith)).mpr ?_) ++ rw [le_max_iff, mul_comm 2]; exact Or.inl <| mul_le_mul_of_nonneg_left (by linarith) Cpos.le ++ ++lemma norm_zeta_product_ge_one {x : ℝ} (hx : 0 < x) (y : ℝ) : ++ ‖ζ (1 + x) ^ 3 * ζ (1 + x + I * y) ^ 4 * ζ (1 + x + 2 * I * y)‖ ≥ 1 := by ++ have h₀ : 1 < ( 1 + x : ℂ).re := by simp[hx] ++ have h₁ : 1 < (1 + x + I * y).re := by simp [hx] ++ have h₂ : 1 < (1 + x + 2 * I * y).re := by simp [hx] ++ simpa only [one_pow, norm_mul, norm_pow, DirichletCharacter.LSeries_modOne_eq, ++ LSeries_one_eq_riemannZeta, h₀, h₁, h₂] using ++ DirichletCharacter.norm_LSeries_product_ge_one (1 : DirichletCharacter ℂ 1) hx y ++ ++theorem ZetaLowerBound1_aux1 {σ t : ℝ} (this : 1 ≤ ‖ζ σ‖ ^ (3 : ℝ) * ‖ζ (σ + I * t)‖ ^ (4 : ℝ) * ‖ζ (σ + 2 * I * t)‖) : ++ ‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) * ‖ζ (σ + t * I)‖ ≥ 1 := by ++ use (one_le_pow_iff_of_nonneg (by bound) four_ne_zero).1 (by_contra (this.not_gt ∘ ?_)) ++ simp_rw [mul_pow, ← Real.rpow_natCast, ← Real.rpow_mul (norm_nonneg _)] ++ norm_num [mul_right_comm, mul_comm (t : ℂ), mul_pow] ++ ++lemma ZetaLowerBound1 {σ t : ℝ} (σ_gt : 1 < σ) : ++ ‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) * ‖ζ (σ + t * I)‖ ≥ 1 := by ++ ++ have := norm_zeta_product_ge_one (x := σ - 1) (by linarith) t ++ simp_rw [ge_iff_le, norm_mul, norm_pow, ofReal_sub, ofReal_one, add_sub_cancel, ← Real.rpow_natCast] ++ at this ++ apply ZetaLowerBound1_aux1 this ++ ++lemma ZetaLowerBound2 {σ t : ℝ} (σ_gt : 1 < σ) : ++ 1 / (‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4)) ≤ ‖ζ (σ + t * I)‖ := by ++ have := ZetaLowerBound1 (t := t) σ_gt ++ exact (div_le_iff₀' (pos_of_mul_pos_left (one_pos.trans_le this) (norm_nonneg _) ) ).mpr this ++ ++theorem ZetaLowerBound3_aux1 (A : ℝ) (ha : A ∈ Ioc 0 (1 / 2)) (t : ℝ) ++ (ht_2 : 3 < |2 * t|) : 0 < A / Real.log |2 * t| := by ++ exact div_pos ha.1 <| Real.log_pos (by linarith) ++ ++theorem ZetaLowerBound3_aux2 {C : ℝ} ++ {σ t : ℝ} ++ (ζ_2t_bound : ‖ζ (σ + (2 * t) * I)‖ ≤ C * Real.log |2 * t|) : ++ ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) ≤ (C * Real.log |2 * t|) ^ ((1 : ℝ) / 4) := by ++ bound ++ ++theorem ZetaLowerBound3_aux3 (C : ℝ) (c_near : ℝ) {σ : ℝ} (t : ℝ) (σ_gt : 1 < σ) : ++ c_near ^ ((3 : ℝ) / 4) * ((-1 + σ) ^ ((3 : ℝ) / 4))⁻¹ * C ^ ((1 : ℝ) / 4) * Real.log |t * 2| ^ ((1 : ℝ) / 4) = ++ c_near ^ ((3 : ℝ) / 4) * C ^ ((1 : ℝ) / 4) * Real.log |t * 2| ^ ((1 : ℝ) / 4) * (-1 + σ) ^ (-(3 : ℝ) / 4) := by ++ exact (symm) (.trans (by rw [neg_div, Real.rpow_neg (by linarith)]) (by ring)) ++ ++theorem ZetaLowerBound3_aux4 (C : ℝ) (hC : 0 < C) ++ (c_near : ℝ) (hc_near : 0 < c_near) {σ : ℝ} (t : ℝ) (ht : 3 < |t|) ++ (σ_gt : 1 < σ) ++ : ++ 0 < c_near ^ ((3 : ℝ) / 4) * (σ - 1) ^ (-(3 : ℝ) / 4) * C ^ ((1 : ℝ) / 4) * Real.log |2 * t| ^ ((1 : ℝ) / 4) := by ++ match sub_pos.mpr σ_gt with | S => match Real.log_pos (by simp; linarith : abs (2 *t) > 1) with | S => positivity ++ ++theorem ZetaLowerBound3_aux5 ++ {σ : ℝ} (t : ℝ) ++ (this : ‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) * ‖ζ (σ + t * I)‖ ≥ 1) : ++ 0 < ‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) := ++ pos_of_mul_pos_left (this.trans_lt' zero_lt_one) (norm_nonneg _) ++ ++lemma ZetaLowerBound3 : ++ ∃ c > 0, ∀ {σ : ℝ} (_ : σ ∈ Ioc 1 2) (t : ℝ) (_ : 3 < |t|), ++ c * (σ - 1) ^ ((3 : ℝ) / 4) / (Real.log |t|) ^ ((1 : ℝ) / 4) ≤ ‖ζ (σ + t * I)‖ := by ++ obtain ⟨A, ha, C, hC, h_upper⟩ := ZetaUpperBnd ++ obtain ⟨c_near, hc_near, h_near⟩ := ZetaNear1BndExact ++ ++ use 1 / (c_near ^ ((3 : ℝ) / 4) * (2 * C) ^ ((1 : ℝ) / 4)), by positivity ++ intro σ hσ t ht ++ obtain ⟨σ_gt, σ_le⟩ := hσ ++ ++ have lower := ZetaLowerBound2 (t := t) σ_gt ++ apply le_trans _ lower ++ ++ have ζ_σ_bound : ‖ζ σ‖ ≤ c_near / (σ - 1) := by ++ exact h_near σ ⟨σ_gt, σ_le⟩ ++ ++ have ht_2 : 3 < |2 * t| := by simp only [abs_mul, Nat.abs_ofNat]; linarith ++ ++ have σ_in_range : σ ∈ Icc (1 - A / Real.log |2 * t|) 2 := by ++ constructor ++ · ++ have : 0 < A / Real.log |2 * t| := by ++ exact ZetaLowerBound3_aux1 A ha t ht_2 ++ nlinarith ++ · exact σ_le ++ ++ have ζ_2t_bound := h_upper σ (2 * t) ht_2 σ_in_range ++ ++ have denom_bound : ‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) ≤ ++ (c_near / (σ - 1)) ^ ((3 : ℝ) / 4) * (C * Real.log |2 * t|) ^ ((1 : ℝ) / 4) := by ++ apply mul_le_mul ++ · apply Real.rpow_le_rpow (norm_nonneg _) ζ_σ_bound (by norm_num) ++ · apply ZetaLowerBound3_aux2 ++ convert ζ_2t_bound ++ norm_cast ++ · apply Real.rpow_nonneg (norm_nonneg _) ++ · apply Real.rpow_nonneg (div_nonneg (by linarith) (by linarith)) ++ ++ have : (c_near / (σ - 1)) ^ ((3 : ℝ) / 4) * (C * Real.log |2 * t|) ^ ((1 : ℝ) / 4) = ++ c_near ^ ((3 : ℝ) / 4) * (σ - 1) ^ (-(3 : ℝ) / 4) * C ^ ((1 : ℝ) / 4) * (Real.log |2 * t|) ^ ((1 : ℝ) / 4) := by ++ rw [Real.div_rpow (by linarith) (by linarith), Real.mul_rpow (by linarith) (Real.log_nonneg (by linarith))] ++ ring_nf ++ exact ZetaLowerBound3_aux3 _ _ _ σ_gt ++ rw [this] at denom_bound ++ ++ have pos_left : 0 < c_near ^ ((3 : ℝ) / 4) * (σ - 1) ^ (-(3 : ℝ) / 4) * C ^ ((1 : ℝ) / 4) * (Real.log |2 * t|) ^ ((1 : ℝ) / 4) := by ++ apply ZetaLowerBound3_aux4 C hC c_near hc_near t ht σ_gt ++ ++ have pos_right : 0 < ‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) := by ++ ++ apply ZetaLowerBound3_aux5 _ <| ZetaLowerBound1 (t := t) σ_gt ++ ++ use (div_le_div_of_nonneg_left zero_le_one pos_right denom_bound).trans' ?_ ++ simp_rw [abs_mul, abs_two, neg_div, Real.rpow_neg (sub_pos.2 σ_gt).le] at * ++ have hlog : 0 < Real.log |t| := Real.log_pos <| ht.trans' <| by norm_num ++ have : 0 < Real.log |t| ^ (1 / 4 : ℝ) := Real.rpow_pos_of_pos hlog _ ++ have hlog2 : 0 < Real.log (2 * |t|) := Real.log_pos <| ht_2.trans' <| by norm_num ++ have : 0 < Real.log (2 * |t|) ^ (1 / 4 : ℝ) := Real.rpow_pos_of_pos hlog2 (1 / 4) ++ field_simp ++ rw [Real.mul_rpow two_pos.le hC.le] ++ move_mul [C ^ (1 / 4)] ++ rw [mul_le_mul_iff_left₀] ++ swap ++ · positivity ++ rw [← Real.mul_rpow two_pos.le hlog.le] ++ apply Real.rpow_le_rpow hlog2.le ?_ (by norm_num) ++ rw [← Real.log_rpow (ht.trans' (by norm_num))] ++ apply Real.log_le_log (ht_2.trans' (by norm_num)) ++ rw [Real.rpow_two, sq] ++ gcongr ++ exact ht.trans' (by norm_num) |>.le ++ ++lemma ZetaInvBound1 {σ t : ℝ} (σ_gt : 1 < σ) : ++ 1 / ‖ζ (σ + t * I)‖ ≤ ‖ζ σ‖ ^ ((3 : ℝ) / 4) * ‖ζ (σ + 2 * t * I)‖ ^ ((1 : ℝ) / 4) := by ++ apply (div_le_iff₀ ?_).mpr ++ · apply (Real.rpow_le_rpow_iff (z := 4) (by norm_num) ?_ (by norm_num)).mp ++ · simp only [Real.one_rpow] ++ rw [Real.mul_rpow, Real.mul_rpow, ← Real.rpow_mul, ← Real.rpow_mul] ++ · simp only [isUnit_iff_ne_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, ++ IsUnit.div_mul_cancel, Real.rpow_one] ++ conv => rw [mul_assoc]; rhs; rhs; rw [mul_comm] ++ rw [← mul_assoc] ++ have := norm_zeta_product_ge_one (x := σ - 1) (by linarith) t ++ simp_rw [ge_iff_le, norm_mul, norm_pow, ofReal_sub, ofReal_one, add_sub_cancel, ← Real.rpow_natCast] at this ++ convert this using 3 <;> ring_nf ++ any_goals ring_nf ++ any_goals apply norm_nonneg ++ any_goals apply Real.rpow_nonneg <| norm_nonneg _ ++ apply mul_nonneg <;> apply Real.rpow_nonneg <| norm_nonneg _ ++ · refine mul_nonneg (mul_nonneg ?_ ?_) ?_ <;> simp [Real.rpow_nonneg] ++ · have s_ne_one : σ + t * I ≠ 1 := by ++ contrapose! σ_gt; apply le_of_eq; apply And.left; simpa [Complex.ext_iff] using σ_gt ++ simpa using riemannZeta_ne_zero_of_one_le_re (by simp [σ_gt.le]) ++ ++lemma Ioi_union_Iio_mem_cocompact {a : ℝ} (ha : 0 ≤ a) : Ioi (a : ℝ) ∪ Iio (-a : ℝ) ∈ cocompact ℝ := by ++ simp only [Filter.mem_cocompact] ++ use Icc (-a) a ++ constructor ++ · exact isCompact_Icc ++ · rw [@compl_subset_iff_union, ← union_assoc, Icc_union_Ioi_eq_Ici, union_comm, Iio_union_Ici] ++ linarith ++ ++lemma lt_abs_mem_cocompact {a : ℝ} (ha : 0 ≤ a) : {t | a < |t|} ∈ cocompact ℝ := by ++ convert Ioi_union_Iio_mem_cocompact ha using 1; ext t ++ simp only [mem_ofPred_eq, mem_union, mem_Ioi, mem_Iio, lt_abs, lt_neg] ++ ++lemma ZetaInvBound2 : ++ ∃ C > 0, ∀ {σ : ℝ} (_ : σ ∈ Ioc 1 2) (t : ℝ) (_ : 3 < |t|), ++ 1 / ‖ζ (σ + t * I)‖ ≤ C * (σ - 1) ^ (-(3 : ℝ) / 4) * (Real.log |t|) ^ ((1 : ℝ) / 4) := by ++ obtain ⟨A, ha, C, hC, h⟩ := ZetaUpperBnd ++ obtain ⟨c, hc, h_inv⟩ := ZetaNear1BndExact ++ refine ⟨(2 * C) ^ ((1 : ℝ)/ 4) * c ^ ((3 : ℝ)/ 4), by positivity, ?_⟩ ++ intro σ hσ t t_gt ++ obtain ⟨σ_gt, σ_le⟩ := hσ ++ have ht' : 3 < |2 * t| := by simp only [abs_mul, Nat.abs_ofNat]; linarith ++ have hnezero: ((σ - 1) / c) ^ (-3 / 4 : ℝ) ≠ 0 := by ++ have : (σ - 1) / c ≠ 0 := ne_of_gt <| div_pos (by linarith) hc ++ contrapose! this ++ rwa [Real.rpow_eq_zero (div_nonneg (by linarith) hc.le) (by norm_num)] at this ++ calc ++ _ ≤ ‖‖ζ σ‖ ^ (3 / 4 : ℝ) * ‖ζ (↑σ + 2 * ↑t * I)‖ ^ (1 / 4 : ℝ)‖ := ?_ ++ _ ≤ ‖((σ - 1) / c) ^ (-3 / 4 : ℝ) * ‖ζ (↑σ + 2 * ↑t * I)‖ ^ (1 / 4 : ℝ)‖ := ?_ ++ _ ≤ ‖((σ - 1) / c) ^ (-3 / 4 : ℝ) * C ^ (1 / 4 : ℝ) * (Real.log |2 * t|) ^ (1 / 4 : ℝ)‖ := ?_ ++ _ ≤ ‖((σ - 1) / c) ^ (-3 / 4 : ℝ) * C ^ (1 / 4 : ℝ) * (Real.log (|t| ^ 2)) ^ (1 / 4 : ℝ)‖ := ?_ ++ _ = ‖((σ - 1)) ^ (-3 / 4 : ℝ) * c ^ (3 / 4 : ℝ) * (C ^ (1 / 4 : ℝ) * (Real.log (|t| ^ 2)) ^ (1 / 4 : ℝ))‖ := ?_ ++ _ = ‖((σ - 1)) ^ (-3 / 4 : ℝ) * c ^ (3 / 4 : ℝ) * ((2 * C) ^ (1 / 4 : ℝ) * Real.log |t| ^ (1 / 4 : ℝ))‖ := ?_ ++ _ = _ := ?_ ++ · simp only [norm_mul] ++ convert ZetaInvBound1 σ_gt using 2 ++ <;> exact abs_eq_self.mpr <| Real.rpow_nonneg (norm_nonneg _) _ ++ · have bnd1: ‖ζ σ‖ ^ (3 / 4 : ℝ) ≤ ((σ - 1) / c) ^ (-(3 : ℝ) / 4) := by ++ have : ((σ - 1) / c) ^ (-(3 : ℝ) / 4) = (((σ - 1) / c) ^ (-1 : ℝ)) ^ (3 / 4 : ℝ) := by ++ rw [← Real.rpow_mul ?_] ++ · ring_nf ++ · exact div_nonneg (by linarith) hc.le ++ rw [this] ++ apply Real.rpow_le_rpow (by simp [norm_nonneg]) ?_ (by norm_num) ++ convert! h_inv σ ⟨σ_gt, σ_le⟩ using 1; simp [Real.rpow_neg_one, inv_div] ++ simp only [norm_mul] ++ apply (mul_le_mul_iff_left₀ ?_).mpr ++ · convert! bnd1 using 1 ++ · exact abs_eq_self.mpr <| Real.rpow_nonneg (norm_nonneg _) _ ++ · exact abs_eq_self.mpr <| Real.rpow_nonneg (div_nonneg (by linarith) hc.le) _ ++ · apply lt_iff_le_and_ne.mpr ⟨(by simp), ?_⟩ ++ have : ζ (↑σ + 2 * ↑t * I) ≠ 0 := by ++ apply riemannZeta_ne_zero_of_one_le_re (by simp [σ_gt.le]) ++ symm; exact fun h2 ↦ this (by simpa using h2) ++ · replace h := h σ (2 * t) (by simpa using ht') ⟨?_, σ_le⟩ ++ · have : 0 ≤ Real.log |2 * t| := Real.log_nonneg (by linarith) ++ conv => rhs; rw [mul_assoc, ← Real.mul_rpow hC.le this] ++ rw [norm_mul, norm_mul] ++ conv => rhs; rhs; rw [Real.norm_rpow_of_nonneg <| mul_nonneg hC.le this] ++ conv => lhs; rhs; rw [Real.norm_rpow_of_nonneg <| norm_nonneg _] ++ apply (mul_le_mul_iff_right₀ ?_).mpr ++ · apply Real.rpow_le_rpow (norm_nonneg _) ?_ (by norm_num) ++ convert h using 1 ++ · simp ++ · rw [Real.norm_eq_abs, abs_eq_self.mpr <| mul_nonneg hC.le this] ++ · simpa only [Real.norm_eq_abs, abs_pos] ++ · linarith [(div_nonneg ha.1.le (Real.log_nonneg (by linarith)) : 0 ≤ A / Real.log |2 * t|)] ++ · simp only [Real.log_abs, norm_mul] ++ apply (mul_le_mul_iff_right₀ ?_).mpr ++ · rw [← Real.log_abs, Real.norm_rpow_of_nonneg <| Real.log_nonneg (by linarith)] ++ have : 1 ≤ |(|t| ^ 2)| := by ++ simp only [_root_.sq_abs, _root_.abs_pow, one_le_sq_iff_one_le_abs] ++ linarith ++ conv => rhs; rw [← Real.log_abs, Real.norm_rpow_of_nonneg <| Real.log_nonneg this] ++ apply Real.rpow_le_rpow (abs_nonneg _) ?_ (by norm_num) ++ · rw [Real.norm_eq_abs, abs_eq_self.mpr <| Real.log_nonneg (by linarith)] ++ rw [abs_eq_self.mpr <| Real.log_nonneg this, abs_mul, Real.log_abs, Nat.abs_ofNat] ++ apply Real.log_le_log (mul_pos (by norm_num) (by linarith)) (by nlinarith) ++ · apply mul_pos (abs_pos.mpr hnezero) (abs_pos.mpr ?_) ++ have : C ≠ 0 := ne_of_gt hC ++ contrapose! this; rwa [Real.rpow_eq_zero (by linarith) (by norm_num)] at this ++ · have : (-3 : ℝ) / 4 = -((3 : ℝ)/ 4) := by norm_num ++ simp only [norm_mul, mul_eq_mul_right_iff, this, ← mul_assoc]; left; left ++ conv => lhs; rw [Real.div_rpow (by linarith) hc.le, Real.rpow_neg hc.le, div_inv_eq_mul, norm_mul] ++ · simp only [Real.log_pow, Nat.cast_ofNat, norm_mul, Real.norm_eq_abs] ++ congr! 1 ++ rw [Real.mul_rpow (by norm_num) hC.le, Real.mul_rpow (by norm_num) <| ++ Real.log_nonneg (by linarith), abs_mul, abs_mul, ← mul_assoc, mul_comm _ |2 ^ (1 / 4)|] ++ · simp only [norm_mul, Real.norm_eq_abs] ++ have : (2 * C) ^ ((1 : ℝ)/ 4) * c ^ ((3 : ℝ)/ 4) = ++ |(2 * C) ^ ((1 : ℝ)/ 4) * c ^ ((3 : ℝ)/ 4)| := by ++ rw [abs_eq_self.mpr (by apply mul_nonneg <;> (apply Real.rpow_nonneg; linarith))] ++ rw [this, abs_mul, abs_eq_self.mpr (by apply Real.rpow_nonneg; linarith), abs_eq_self.mpr (by positivity), ++ abs_eq_self.mpr (by positivity), abs_eq_self.mpr (by apply Real.rpow_nonneg (Real.log_nonneg (by linarith)))] ++ ring_nf ++ ++lemma deriv_fun_re {t : ℝ} {f : ℂ → ℂ} (diff : ∀ (σ : ℝ), DifferentiableAt ℂ f (↑σ + ↑t * I)) : ++ (deriv fun {σ₂ : ℝ} ↦ f (σ₂ + t * I)) = fun (σ : ℝ) ↦ deriv f (σ + t * I) := by ++ ext σ ++ have := deriv_comp (h := fun (σ : ℝ) ↦ σ + t * I) (h₂ := f) σ (diff σ) ?_ ++ · simp only [deriv_add_const', _root_.Erdos970.deriv_ofReal, mul_one] at this ++ exact this ++ · apply DifferentiableAt.add_const _ <| _root_.Erdos970.Complex.differentiableAt_ofReal σ ++ ++ ++lemma Zeta_eq_int_derivZeta {σ₁ σ₂ t : ℝ} (t_ne_zero : t ≠ 0) : ++ (∫ σ in σ₁..σ₂, ζ' (σ + t * I)) = ζ (σ₂ + t * I) - ζ (σ₁ + t * I) := by ++ have diff : ∀ (σ : ℝ), DifferentiableAt ℂ ζ (σ + t * I) := by ++ intro σ ++ refine differentiableAt_riemannZeta ?_ ++ contrapose! t_ne_zero; apply And.right; simpa [Complex.ext_iff] using t_ne_zero ++ apply intervalIntegral.integral_deriv_eq_sub' ++ · exact deriv_fun_re diff ++ · intro s _ ++ apply DifferentiableAt.comp ++ · exact (diff s).restrictScalars ℝ ++ · exact DifferentiableAt.add_const (c := t * I) <| _root_.Erdos970.Complex.differentiableAt_ofReal _ ++ · apply ContinuousOn.comp (g := ζ') ?_ ?_ (mapsTo_image _ _) ++ · apply HasDerivAt.continuousOn (f' := deriv <| ζ') ++ intro x hx ++ apply hasDerivAt_deriv_iff.mpr ++ replace hx : x ≠ 1 := by ++ contrapose! hx ++ simp only [hx, mem_image, Complex.ext_iff, add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, ++ I_im, mul_one, sub_self, add_zero, one_re, add_im, mul_im, zero_add, one_im, not_exists, ++ not_and] ++ exact fun _ _ _ ↦ t_ne_zero ++ exact differentiableAt_deriv_riemannZeta hx ++ · exact continuous_ofReal.continuousOn.add continuousOn_const ++ ++lemma Zeta_diff_Bnd : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (C : ℝ) (_ : 0 < C), ∀ (σ₁ σ₂ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : 1 - A / Real.log |t| ≤ σ₁) (_ : σ₂ ≤ 2) (_ : σ₁ < σ₂), ++ ‖ζ (σ₂ + t * I) - ζ (σ₁ + t * I)‖ ≤ C * Real.log |t| ^ 2 * (σ₂ - σ₁) := by ++ obtain ⟨A, hA, C, Cpos, hC⟩ := ZetaDerivUpperBnd ++ refine ⟨A, hA, C, Cpos, ?_⟩ ++ intro σ₁ σ₂ t t_gt σ₁_ge σ₂_le σ₁_lt_σ₂ ++ have t_ne_zero : t ≠ 0 := by contrapose! t_gt; simp only [t_gt, abs_zero, Nat.ofNat_nonneg] ++ rw [← Zeta_eq_int_derivZeta t_ne_zero] ++ convert intervalIntegral.norm_integral_le_of_norm_le_const ?_ using 1 ++ · congr; rw [_root_.abs_of_nonneg (by linarith)] ++ · intro σ hσ; rw [uIoc_of_le σ₁_lt_σ₂.le, mem_Ioc] at hσ ++ exact hC σ t t_gt ⟨le_trans σ₁_ge hσ.1.le, le_trans hσ.2 σ₂_le⟩ ++ ++lemma ZetaInvBnd_aux' {t : ℝ} (logt_gt_one : 1 < Real.log |t|) : Real.log |t| < Real.log |t| ^ 9 := by ++ nth_rewrite 1 [← Real.rpow_one <| Real.log |t|] ++ exact mod_cast Real.rpow_lt_rpow_left_iff (y := 1) (z := 9) logt_gt_one |>.mpr (by norm_num) ++ ++lemma ZetaInvBnd_aux {t : ℝ} (logt_gt_one : 1 < Real.log |t|) : Real.log |t| ≤ Real.log |t| ^ 9 := ++ ZetaInvBnd_aux' logt_gt_one |>.le ++ ++lemma ZetaInvBnd_aux2 {A C₁ C₂ : ℝ} (Apos : 0 < A) (C₁pos : 0 < C₁) (C₂pos : 0 < C₂) ++ (hA : A ≤ 1 / 2 * (C₁ / (C₂ * 2)) ^ (4 : ℝ)) : ++ 0 < (C₁ * A ^ (3 / 4 : ℝ) - C₂ * 2 * A)⁻¹ := by ++ simp only [inv_pos, sub_pos] ++ apply div_lt_iff₀ (by positivity) |>.mp ++ rw [div_eq_mul_inv, ← Real.rpow_neg (by positivity), mul_assoc] ++ apply lt_div_iff₀' (by positivity) |>.mp ++ nth_rewrite 1 [← Real.rpow_one A] ++ rw [← Real.rpow_add (by positivity)] ++ norm_num ++ apply Real.rpow_lt_rpow_iff (z := 4) (by positivity) (by positivity) (by positivity) |>.mp ++ rw [← Real.rpow_mul (by positivity)] ++ norm_num ++ apply lt_of_le_of_lt hA ++ rw [div_mul_comm, mul_one, Real.rpow_ofNat] ++ apply half_lt_self ++ positivity ++ ++lemma ZetaInvBnd : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (C : ℝ) (_ : 0 < C), ∀ (σ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Ico (1 - A / (Real.log |t|) ^ 9) (1 + A / (Real.log |t|) ^ 9)), ++ 1 / ‖ζ (σ + t * I)‖ ≤ C * (Real.log |t|) ^ (7 : ℝ) := by ++ obtain ⟨C', C'pos, hC₁⟩ := ZetaInvBound2 ++ obtain ⟨A', hA', C₂, C₂pos, hC₂⟩ := Zeta_diff_Bnd ++ set C₁ := 1 / C' ++ let A := min A' <| (1 / 2 : ℝ) * (C₁ / (C₂ * 2)) ^ (4 : ℝ) ++ have Apos : 0 < A := by have := hA'.1; positivity ++ have Ale : A ≤ 1 / 2 := by dsimp only [A]; apply min_le_iff.mpr; left; exact hA'.2 ++ set C := (C₁ * A ^ (3 / 4 : ℝ) - C₂ * 2 * A)⁻¹ ++ have Cpos : 0 < C := by ++ refine ZetaInvBnd_aux2 (by positivity) (by positivity) (by positivity) ?_ ++ apply min_le_right ++ refine ⟨A, ⟨Apos, by linarith [hA'.2]⟩ , C, Cpos, ?_⟩ ++ intro σ t t_gt hσ ++ have logt_gt_one := logt_gt_one t_gt.le ++ have σ_ge : 1 - A / Real.log |t| ≤ σ := by ++ apply le_trans ?_ hσ.1 ++ suffices A / Real.log |t| ^ 9 ≤ A / Real.log |t| by linarith ++ exact div_le_div₀ Apos.le (by rfl) (by positivity) <| ZetaInvBnd_aux logt_gt_one ++ obtain ⟨_, _, neOne⟩ := UpperBnd_aux ⟨Apos, Ale⟩ t_gt σ_ge ++ set σ' := 1 + A / Real.log |t| ^ 9 ++ have σ'_gt : 1 < σ' := by simp only [σ', lt_add_iff_pos_right]; positivity ++ have σ'_le : σ' ≤ 2 := by ++ simp only [σ'] ++ suffices A / Real.log |t| ^ 9 < 1 by linarith ++ apply div_lt_one (by positivity) |>.mpr ++ exact lt_trans₄ (by linarith) logt_gt_one <| ZetaInvBnd_aux' logt_gt_one ++ set s := σ + t * I ++ set s' := σ' + t * I ++ by_cases h0 : ‖ζ s‖ ≠ 0 ++ swap ++ · simp only [ne_eq, not_not] at h0; simp only [h0, div_zero]; positivity ++ apply div_le_iff₀ (by positivity) |>.mpr <| div_le_iff₀' (by positivity) |>.mp ?_ ++ have pos_aux : 0 < (σ' - 1) := by linarith ++ calc ++ _ ≥ ‖ζ s'‖ - ‖ζ s - ζ s'‖ := ?_ ++ _ ≥ C₁ * (σ' - 1) ^ ((3 : ℝ)/ 4) * Real.log |t| ^ ((-1 : ℝ)/ 4) - C₂ * Real.log |t| ^ 2 * (σ' - σ) := ?_ ++ _ ≥ C₁ * (A / Real.log |t| ^ (9 : ℝ)) ^ ((3 : ℝ)/ 4) * Real.log |t| ^ ((-1 : ℝ)/ 4) - C₂ * Real.log |t| ^ (2 : ℝ) * 2 * A / Real.log |t| ^ (9 : ℝ) := ?_ ++ _ ≥ C₁ * A ^ ((3 : ℝ)/ 4) * Real.log |t| ^ (-7 : ℝ) - C₂ * 2 * A * Real.log |t| ^ (-7 : ℝ) := ?_ ++ _ = (C₁ * A ^ ((3 : ℝ)/ 4) - C₂ * 2 * A) * Real.log |t| ^ (-7 : ℝ) := by ring ++ _ ≥ _ := ?_ ++ · apply ge_iff_le.mpr ++ convert norm_sub_norm_le (a := ζ s') (b := ζ s' - ζ s) using 1 ++ · rw [(by simp : ζ s' - ζ s = -(ζ s - ζ s'))]; simp only [norm_neg] ++ · simp ++ · apply sub_le_sub ++ · have := one_div_le ?_ (by positivity) |>.mp <| hC₁ ⟨σ'_gt, σ'_le⟩ t t_gt ++ · convert this using 1 ++ rw [one_div, mul_inv_rev, mul_comm, mul_inv_rev, mul_comm _ C'⁻¹] ++ simp only [one_div C', C₁] ++ congr <;> (rw [← Real.rpow_neg (by linarith), neg_div]); rw [neg_neg] ++ · apply norm_pos_iff.mpr <| riemannZeta_ne_zero_of_one_lt_re (by simp [σ'_gt]) ++ · rw [(by simp : ζ s - ζ s' = -(ζ s' - ζ s)), norm_neg] ++ refine hC₂ σ σ' t t_gt ?_ σ'_le <| by rw [Set.mem_Ico] at hσ; exact hσ.2 ++ apply le_trans ?_ hσ.1 ++ rw [tsub_le_iff_right, ← add_sub_right_comm, le_sub_iff_add_le, add_le_add_iff_left] ++ exact div_le_div₀ hA'.1.le (by simp [A]) (by positivity) <| ZetaInvBnd_aux logt_gt_one ++ · apply sub_le_sub (by simp only [add_sub_cancel_left, σ']; exact_mod_cast le_rfl) ?_ ++ rw [mul_div_assoc, mul_assoc _ 2 _] ++ apply mul_le_mul (by exact_mod_cast le_rfl) ?_ (by linarith [hσ.2]) (by positivity) ++ suffices h : σ' + (1 - A / Real.log |t| ^ 9) ≤ (1 + A / Real.log |t| ^ 9) + σ by ++ simp only [tsub_le_iff_right] ++ convert! le_sub_right_of_add_le h using 1; ring_nf; norm_cast; simp ++ exact add_le_add (by linarith) (by linarith [hσ.1]) ++ · simp_rw [tsub_le_iff_right, div_eq_mul_inv _ (Real.log |t| ^ (9 : ℝ))] ++ rw [← Real.rpow_neg (by positivity), Real.mul_rpow (by positivity) (by positivity)] ++ rw [← Real.rpow_mul (by positivity)] ++ ring_nf ++ conv => rhs; lhs; rw [mul_assoc, ← Real.rpow_add (by positivity)] ++ rw [(by ring : C₂ * Real.log |t| ^ (2 : ℝ) * A * Real.log |t| ^ (-9 : ℝ) * 2 = C₂ * (Real.log |t| ^ (2 : ℝ) * Real.log |t| ^ (-9 : ℝ) ) * A * 2)] ++ rw [← Real.rpow_add (by positivity)]; norm_num; group; exact le_rfl ++ · apply div_le_iff₀ (by positivity) |>.mpr ++ conv => rw [mul_assoc]; rhs; rhs; rw [mul_comm C, ← mul_assoc, ← Real.rpow_add (by positivity)] ++ have := inv_inv C ▸ mul_inv_cancel₀ (a := C⁻¹) (by positivity) |>.symm.le ++ simpa [C] using this ++ ++lemma ZetaLowerBnd : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (c : ℝ) (_ : 0 < c), ++ ∀ (σ : ℝ) ++ (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Ico (1 - A / (Real.log |t|) ^ 9) 1), ++ c / (Real.log |t|) ^ (7 : ℝ) ≤ ‖ζ (σ + t * I)‖ := by ++ obtain ⟨C₁, C₁pos, hC₁⟩ := ZetaLowerBound3 ++ obtain ⟨A', hA', C₂, C₂pos, hC₂⟩ := Zeta_diff_Bnd ++ ++ let A := min A' ((C₁ / (4 * C₂)) ^ 4) ++ have hA : A ∈ Ioc 0 (1 / 2) := ++ ⟨lt_min hA'.1 (by positivity), (min_le_left A' _).trans hA'.2⟩ ++ ++ let C := C₁ * A ^ ((3:ℝ) /4) - 2 * C₂ * A ++ have hc_pos : 0 < C := by ++ have:= A.rpow_le_rpow hA.1.le (min_le_right _ _) (inv_pos.mpr four_pos).le ++ erw [Real.pow_rpow_inv_natCast (div_pos C₁pos (mul_pos four_pos C₂pos)).le four_ne_zero, ++ le_div_iff₀ (mul_pos four_pos C₂pos)] at this ++ norm_num [mul_assoc, C, mul_left_comm, C₂pos, hA.1, ++ (mul_le_mul_of_nonneg_right this (A.rpow_nonneg hA.1.le _)).trans_lt', ←A.rpow_add] ++ ++ refine ⟨A, hA, C, hc_pos, fun σ t L ⟨σ_low_bound, σ_le_one⟩=>?_⟩ ++ ++ let σ' := 1 + A / Real.log |t| ^ (9 : ℝ) ++ ++ have triangular : ‖ζ (σ + t * I)‖ ≥ ‖ζ (σ' + t * I)‖ - ‖ζ (σ + t * I) - ζ (σ' + t * I)‖ := by ++ apply sub_le_iff_le_add.mpr.comp (sub_sub_self @_ (@_ : ℂ)▸norm_sub_le _ _).trans ++ (by rw [add_comm]) ++ ++ have one_leLogT : 1 ≤ Real.log |t| := (logt_gt_one L.le).le ++ have one_half_le_log_pow : 1 / 2 ≤ Real.log |t| ^ 9 := ++ one_half_lt_one.le.trans <| one_le_pow₀ one_leLogT ++ ++ have σ'_ge : 1 ≤ σ' := by ++ simp_all only [gt_iff_lt, mem_Ioc, Real.log_abs, one_div, and_imp, tsub_le_iff_right, ++ lt_inf_iff, div_pos_iff_of_pos_left, Nat.ofNat_pos, mul_pos_iff_of_pos_left, pow_pos, ++ and_self, inf_le_iff, true_or, sub_pos, mem_Ico, and_true, ofReal_add, ofReal_one, ++ ofReal_div, ge_iff_le, le_add_iff_nonneg_right, A, C, σ'] ++ apply div_nonneg ++ · apply le_min ++ · linarith ++ · have : (C₁ / (4 * C₂)) ^ 4 = ((C₁ / (4 * C₂)) ^ 2) ^ 2 := by ring ++ rw [this] ++ apply sq_nonneg ++ · positivity ++ ++ have right_sub : -‖ζ (σ + t * I) - ζ (σ' + t * I)‖ ≥ - C₂ * Real.log |t| ^ 2 * (σ' - σ) := by ++ change - C₂ * Real.log |t| ^ 2 * (σ' - σ) ≤ -‖ζ (σ + t * I) - ζ (σ' + t * I)‖ ++ have := hC₂ σ σ' t L ?_ ?_ ?_ ++ · convert! neg_le_neg this using 1 ++ · ring ++ · congr! 1 ++ have : ζ (↑σ + ↑t * I) - ζ (↑σ' + ↑t * I) = ++ - (ζ (↑σ' + ↑t * I) - ζ (↑σ + ↑t * I)) := by ring ++ rw [this, norm_neg] ++ · have : 1 - A' / Real.log |t| ≤ 1 - A / (Real.log |t|) ^ 9 := by ++ gcongr ++ · exact hA'.1.le ++ · bound ++ · bound ++ linarith ++ · have : σ' ≤ 1 + A := by ++ simp_all only [gt_iff_lt, mem_Ioc, Real.log_abs, one_div, and_imp, tsub_le_iff_right, ++ lt_inf_iff, div_pos_iff_of_pos_left, Nat.ofNat_pos, mul_pos_iff_of_pos_left, pow_pos, ++ and_self, inf_le_iff, true_or, sub_pos, mem_Ico, and_true, ofReal_add, ofReal_one, ++ ofReal_div, ge_iff_le, le_add_iff_nonneg_right, add_le_add_iff_left, le_inf_iff, ++ σ', A, C] ++ have : 1 ≤ Real.log t ^ (9 : ℕ) := by ++ bound ++ have : 1 ≤ Real.log t ^ (9 : ℝ) := by ++ exact_mod_cast this ++ refine ⟨?_, ?_⟩ ++ · rw [← min_div_div_right] ++ · rw [min_le_iff] ++ left ++ bound ++ · exact le_trans (zero_le_one) this ++ · rw [← min_div_div_right] ++ · rw [min_le_iff] ++ right ++ bound ++ · exact le_trans (zero_le_one) this ++ · bound [hA.2] ++ · linarith ++ ++ have right' : -‖ζ (σ + t * I) - ζ (σ' + t * I)‖ ≥ - C₂ * 2 * A / Real.log |t| ^ 7 := by ++ have := (abs t).log_pos (by bound) ++ refine right_sub.trans' ((div_le_iff₀ (pow_pos this 7)).2 @?_|>.trans ++ (mul_le_mul_of_nonpos_left (sub_le_sub_left σ_low_bound (1+_) ) ++ (by ·linear_combination C₂*this*(.log |t|)))) ++ exact (mod_cast (by linear_combination (2 *_* A) *div_self ↑(pow_pos this 09).ne')) ++ ++ have left_sub : ‖ζ (σ' + t * I)‖ ≥ C₁ * (σ' - 1) ^ ((3:ℝ) /4) / Real.log |t| ^ 4 := by ++ use (hC₁ ⟨lt_add_of_pos_right (1) (by bound[hA.1]), ++ add_le_of_le_sub_left ((div_le_iff₀ (by bound)).2 (hA.2.trans (?_)))⟩ t L).trans' ?_ ++ · norm_num only [one_mul, Real.rpow_ofNat, one_half_le_log_pow] ++ · simp_all only [gt_iff_lt, mem_Ioc, lt_inf_iff, div_pos_iff_of_pos_left, Nat.ofNat_pos, ++ mul_pos_iff_of_pos_left, pow_pos, and_self, inf_le_iff, true_or, sub_pos, mem_Ico, ++ ofReal_add, ofReal_one, ofReal_div, ge_iff_le, le_add_iff_nonneg_right, neg_mul, ++ neg_le_neg_iff, add_sub_cancel_left, σ', A, C] ++ gcongr ++ have : Real.log |t| ^ ((1 : ℝ) / 4) ≤ Real.log |t| ^ (4 : ℝ) := ++ Real.rpow_le_rpow_of_exponent_le one_leLogT (by norm_num) ++ exact_mod_cast this ++ ++ have left' : ‖ζ (σ' + t * I)‖ ≥ C₁ * A ^ ((3:ℝ) /4) / Real.log |t| ^ 7 := by ++ contrapose! hC₁ ++ use σ', ⟨lt_add_of_pos_right 1<|by bound[hA'.1], ++ add_le_of_le_sub_left ((div_le_iff₀ (by bound)).2 (hA.2.trans ?_))⟩, t, L, hC₁.trans_le ?_ ++ · norm_num only [one_mul, Real.rpow_ofNat, one_half_le_log_pow] ++ · norm_num only [σ', add_sub_cancel_left, A.div_rpow hA.1.le, mul_div, pow_pos, L.trans', ++ ←Real.rpow_natCast, ←Real.rpow_mul, le_of_lt, Real.log_pos, refl, div_div, ←Real.rpow_sub] ++ rw [Real.div_rpow hA.1.le, ← Real.rpow_mul (by linarith), ← mul_div_assoc, div_div, ← Real.rpow_add (by linarith)] ++ · norm_num ++ · apply Real.rpow_nonneg (by linarith) ++ have ineq : ‖ζ (σ + t * I)‖ ≥ (C₁ * A ^ ((3:ℝ) /4) - C₂ * 2 * A) / Real.log |t| ^ 7 := by ++ linear_combination left'+triangular+right' ++ ++ rw [mul_comm C₂] at ineq ++ exact_mod_cast ineq ++ ++lemma ZetaZeroFree : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)), ++ ∀ (σ : ℝ) ++ (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Ico (1 - A / (Real.log |t|) ^ 9) 1), ++ ζ (σ + t * I) ≠ 0 := by ++ obtain ⟨A, hA, c, hc, h_lower⟩ := ZetaLowerBnd ++ ++ refine ⟨A, hA, ?_⟩ ++ ++ intro σ t ht hσ h_zero ++ ++ have := h_lower σ t ht hσ ++ ++ rw [h_zero, norm_zero] at this ++ ++ have pos_bound : 0 < c / (Real.log |t|) ^ (7 : ℝ) := by ++ apply div_pos hc ++ apply Real.rpow_pos_of_pos ++ apply Real.log_pos ++ linarith ++ ++ linarith ++ ++lemma LogDerivZetaBnd : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (C : ℝ) (_ : 0 < C), ∀ (σ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Ico (1 - A / Real.log |t| ^ 9) (1 + A / Real.log |t| ^ 9)), ‖ζ' (σ + t * I) / ζ (σ + t * I)‖ ≤ ++ C * Real.log |t| ^ 9 := by ++ obtain ⟨A, hA, C, hC, h⟩ := ZetaInvBnd ++ obtain ⟨A', hA', C', hC', h'⟩ := ZetaDerivUpperBnd ++ use min A A', ⟨lt_min hA.1 hA'.1, min_le_of_right_le hA'.2⟩, C * C', mul_pos hC hC' ++ intro σ t t_gt ⟨σ_ge, σ_lt⟩ ++ have logt_gt : (1 : ℝ) < Real.log |t| := logt_gt_one t_gt.le ++ have σ_ge' : 1 - A / Real.log |t| ^ 9 ≤ σ := by ++ apply le_trans (tsub_le_tsub_left ?_ 1) σ_ge ++ apply div_le_div_of_nonneg_right (min_le_left A A') ++ exact pow_nonneg (zero_le_one.trans logt_gt.le) _ ++ have σ_ge'' : 1 - A' / Real.log |t| ≤ σ := by ++ apply le_trans (tsub_le_tsub_left ?_ 1) σ_ge ++ apply div_le_div₀ hA'.1.le (min_le_right A A') (lt_trans (by norm_num) logt_gt) ?_ ++ exact le_self_pow₀ logt_gt.le (by norm_num) ++ replace h := h σ t t_gt ⟨σ_ge', by calc ++ σ < 1 + min A A' / Real.log |t| ^ 9 := σ_lt ++ _ ≤ 1 + A / Real.log |t| ^ 9 := by gcongr; simp⟩ ++ replace h' := h' σ t t_gt ⟨σ_ge'', by ++ calc ++ σ ≤ 1 + min A A' / Real.log |t| ^ 9 := by linarith [σ_lt] ++ ++ _ ≤ 1 + (1/2) / Real.log |t| ^ 9 := by gcongr; simp [Set.mem_Ioc] at hA' hA ⊢ ; simp [hA.2] ++ ++ _ ≤ 1 + (1/2) / 1 := by ++ gcongr ++ calc ++ 1 ≤ Real.log |t| := by linarith ++ _ ≤ (Real.log |t|)^9 := Real.self_le_rpow_of_one_le (by linarith) (by linarith) ++ norm_cast ++ ++ _ ≤ 2 := by linarith ++ ⟩ ++ simp only [norm_div] ++ convert! mul_le_mul h h' (by simp) ?_ using 1 <;> (norm_cast; ring_nf); positivity ++ ++lemma ZetaNoZerosOn1Line (t : ℝ) : ζ (1 + t * I) ≠ 0 := by ++ refine riemannZeta_ne_zero_of_one_le_re ?_ ++ simp ++ ++lemma ZetaCont : ContinuousOn ζ (univ \ {1}) := by ++ apply continuousOn_of_forall_continuousAt (fun x hx ↦ ?_) ++ apply DifferentiableAt.continuousAt (𝕜 := ℂ) ++ convert differentiableAt_riemannZeta ?_ ++ simp only [Set.mem_sdiff, mem_univ, mem_singleton_iff, true_and] at hx ++ exact hx ++ ++lemma ZetaNoZerosInBox (T : ℝ) : ++ ∃ (σ : ℝ) (_ : σ < 1), ∀ (t : ℝ) (_ : |t| ≤ T) ++ (σ' : ℝ) (_ : σ' ≥ σ), ζ (σ' + t * I) ≠ 0 := by ++ by_contra! h ++ have hn (n : ℕ) := h (1 - 1 / (n + 1)) (sub_lt_self _ (by positivity)) ++ ++ have : ∃ (tn : ℕ → ℝ) (σn : ℕ → ℝ), (∀ n, σn n ≤ 1) ∧ ++ (∀ n, (1 : ℝ) - 1 / (n + 1) ≤ σn n) ∧ (∀ n, |tn n| ≤ T) ∧ ++ (∀ n, ζ (σn n + tn n * I) = 0) := by ++ choose t ht σ' hσ' hζ using hn ++ refine ⟨t, σ', ?_, hσ', ht, hζ⟩ ++ intro n ++ by_contra! hσn ++ have := riemannZeta_ne_zero_of_one_lt_re (s := σ' n + t n * I) ++ simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, ++ add_zero, ne_eq] at this ++ exact this hσn (hζ n) ++ ++ choose t σ' hσ'_le hσ'_ge ht hζ using this ++ ++ have σTo1 : Filter.Tendsto σ' Filter.atTop (𝓝 1) := by ++ use sub_zero (1: ℝ)▸tendsto_order.2 ⟨fun A B=>? _,fun A B=>?_⟩ ++ · apply (((tendsto_inv_atTop_nhds_zero_nat.comp ++ (Filter.tendsto_add_atTop_nat (1))).congr (by norm_num)).const_sub 1).eventually_const_lt ++ B|>.mono (hσ'_ge ·|>.trans_lt') ++ · norm_num[(hσ'_le _).trans_lt, B.trans_le'] ++ ++ have : ∃ (t₀ : ℝ) (subseq : ℕ → ℕ), ++ Filter.Tendsto (t ∘ subseq) Filter.atTop (𝓝 t₀) ∧ ++ Filter.Tendsto subseq Filter.atTop Filter.atTop := by ++ refine (isCompact_Icc.isSeqCompact fun and => abs_le.1 (ht and)).imp fun and ⟨x, A, B, _⟩ => ?_ ++ use A, by omega, B.tendsto_atTop ++ ++ obtain ⟨t₀, subseq, tTendsto, subseqTendsto⟩ := this ++ ++ have σTo1 : Filter.Tendsto (σ' ∘ subseq) Filter.atTop (𝓝 1) := ++ σTo1.comp subseqTendsto ++ ++ have (n : ℕ) : ζ (σ' (subseq n) + I * (t (subseq n))) = 0 := by ++ convert hζ (subseq n) using 3 ++ ring ++ ++ have ToOneT0 : Filter.Tendsto (fun n ↦ (σ' (subseq n) : ℂ) + Complex.I * (t (subseq n))) Filter.atTop ++ (𝓝[≠]((1 : ℂ) + I * t₀)) := by ++ simp_rw [tendsto_nhdsWithin_iff, Function.comp_def] at tTendsto ⊢ ++ constructor ++ · exact (σTo1.ofReal.add (tTendsto.ofReal.const_mul _)).trans (by simp) ++ · filter_upwards with n ++ apply ne_of_apply_ne ζ ++ rw [this] ++ apply Ne.symm ++ apply riemannZeta_ne_zero_of_one_le_re ++ simp only [add_re, one_re, mul_re, I_re, ofReal_re, zero_mul, I_im, ofReal_im, mul_zero, ++ sub_self, add_zero, le_refl] ++ ++ by_cases ht₀ : t₀ = 0 ++ · have ZetaBlowsUp : ∀ᶠ s in 𝓝[≠](1 : ℂ), ‖ζ s‖ ≥ 1 := by ++ simp_all only [ge_iff_le, one_div, tsub_le_iff_right, Function.comp_def, ofReal_zero, ++ mul_zero, add_zero, norm_eq_sqrt_real_inner, Complex.inner, mul_re, conj_re, conj_im, ++ mul_neg, sub_neg_eq_add, Real.one_le_sqrt, eventually_nhdsWithin_iff, mem_compl_iff, ++ mem_singleton_iff] ++ contrapose! h ++ simp_all only [ne_eq] ++ delta abs at* ++ exfalso ++ simp_rw [Metric.nhds_basis_ball.frequently_iff]at* ++ choose! I A B using h ++ choose a s using exists_seq_strictAnti_tendsto (0: ℝ) ++ apply ((isCompact_closedBall _ _).isSeqCompact ++ fun and=>(A _ (s.2.1 and)).le.trans (s.2.2.bddAbove_range.some_mem ⟨and, rfl⟩)).elim ++ simp only [Metric.mem_ball, dist_eq_norm_sub] at A ++ refine fun and ⟨a, H, S, M⟩=> ?_ ++ refine absurd (tendsto_nhds_unique M (tendsto_sub_nhds_zero_iff.1 ++ (( squeeze_zero_norm fun and=>le_of_lt (A _ (s.2.1 _) ) ) ++ (s.2.2.comp S.tendsto_atTop)))) fun and=>?_ ++ norm_num[*,Function.comp_def] at M ++ have:=@riemannZeta_residue_one ++ use one_ne_zero (tendsto_nhds_unique (this.comp (tendsto_nhdsWithin_iff.2 ++ ⟨ M,.of_forall (by norm_num[*])⟩)) ( squeeze_zero_norm ?_ ++ ((M.sub_const 1).norm.trans (by rw [sub_self,norm_zero])))) ++ use fun and =>.trans (norm_mul_le_of_le ↑(le_rfl) (Complex.norm_def _▸Real.sqrt_le_one.mpr ++ (B ↑_ (s.2.1 ↑_)).right.le)) (by rw [mul_one]) ++ ++ have ZetaNonZ : ∀ᶠ s in 𝓝[≠](1 : ℂ), ζ s ≠ 0 := by ++ filter_upwards [ZetaBlowsUp] ++ intro s hs hfalse ++ rw [hfalse] at hs ++ simp only [norm_zero, ge_iff_le] at hs ++ linarith ++ ++ rw [ht₀] at ToOneT0 ++ simp only [ofReal_zero, mul_zero, add_zero] at ToOneT0 ++ rcases (ToOneT0.eventually ZetaNonZ).exists with ⟨n, hn⟩ ++ exact hn (this n) ++ ++ · have zetaIsZero : ζ (1 + Complex.I * t₀) = 0 := by ++ have cont := @ZetaCont ++ use isClosed_singleton.isSeqClosed ++ this ++ (.comp ++ (cont.continuousAt.comp (eventually_ne_nhds (by field_simp; simp [ht₀])).mono ++ fun and=>.intro ⟨⟩) ++ (ToOneT0.trans (inf_le_left))) ++ ++ exact riemannZeta_ne_zero_of_one_le_re (s := 1 + I * t₀) (by simp) zetaIsZero ++ ++lemma LogDerivZetaHoloOn {S : Set ℂ} (s_ne_one : 1 ∉ S) ++ (nonzero : ∀ s ∈ S, ζ s ≠ 0) : ++ HolomorphicOn (fun s ↦ ζ' s / ζ s) S := by ++ apply DifferentiableOn.div _ _ nonzero <;> intro s hs <;> apply DifferentiableAt.differentiableWithinAt ++ · apply differentiableAt_deriv_riemannZeta ++ exact ne_of_mem_of_not_mem hs s_ne_one ++ · apply differentiableAt_riemannZeta ++ exact ne_of_mem_of_not_mem hs s_ne_one ++ ++theorem LogDerivZetaHolcSmallT : ++ ∃ (σ₂ : ℝ) (_ : σ₂ < 1), HolomorphicOn (fun (s : ℂ) ↦ ζ' s / (ζ s)) ++ (( [[ σ₂, 2 ]] ×ℂ [[ -3, 3 ]]) \ {1}) := by ++ obtain ⟨σ₂, hσ₂_lt_one, hζ_ne_zero⟩ := ZetaNoZerosInBox 3 ++ refine ⟨σ₂, hσ₂_lt_one, ?_⟩ ++ let U := ([[σ₂, 2]] ×ℂ [[-3, 3]]) \ {1} ++ have s_in_U_im_le3 : ∀ s ∈ U, |s.im| ≤ 3 := by ++ intro s hs ++ rw [Set.mem_sdiff_singleton] at hs ++ rcases hs with ⟨hbox, _hne⟩ ++ rcases hbox with ⟨hre, him⟩ ++ simp only [Set.mem_preimage] at him ++ obtain ⟨him_lower, him_upper⟩ := him ++ apply abs_le.2 ++ simp only [neg_le_self_iff, Nat.ofNat_nonneg, inf_of_le_left] at him_lower ++ simp only [neg_le_self_iff, Nat.ofNat_nonneg, sup_of_le_right] at him_upper ++ exact ⟨him_lower, him_upper⟩ ++ ++ have s_in_U_re_ges2 : ∀ s ∈ U, σ₂ ≤ s.re := by ++ intro s hs ++ rw [Set.mem_sdiff_singleton] at hs ++ rcases hs with ⟨hbox, _hne⟩ ++ rcases hbox with ⟨hre, _him⟩ ++ simp only [Set.mem_preimage] at hre ++ obtain ⟨hre_lower, hre_upper⟩ := hre ++ have : min σ₂ 2 = σ₂ := by ++ apply min_eq_left ++ linarith [hσ₂_lt_one] ++ rwa [← this] ++ ++ apply LogDerivZetaHoloOn ++ · exact Set.notMem_sdiff_of_mem rfl ++ · intro s hs ++ rw[← re_add_im s] ++ apply hζ_ne_zero ++ · apply s_in_U_im_le3 _ hs ++ · apply s_in_U_re_ges2 _ hs ++ ++theorem LogDerivZetaHolcLargeT : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)), ∀ (T : ℝ) (_ : 3 ≤ T), ++ HolomorphicOn (fun (s : ℂ) ↦ ζ' s / (ζ s)) ++ (( (Icc ((1 : ℝ) - A / Real.log T ^ 9) 2) ×ℂ (Icc (-T) T) ) \ {1}) := by ++ obtain ⟨A, A_inter, restOfZetaZeroFree⟩ := ZetaZeroFree ++ obtain ⟨σ₁, σ₁_lt_one, noZerosInBox⟩ := ZetaNoZerosInBox 3 ++ let A₀ := min A ((1 - σ₁) * Real.log 3 ^ 9) ++ refine ⟨A₀, ?_, ?_⟩ ++ · constructor ++ · apply lt_min A_inter.1 ++ bound ++ · exact le_trans (min_le_left _ _) A_inter.2 ++ intro T hT ++ apply LogDerivZetaHoloOn ++ · exact Set.notMem_sdiff_of_mem rfl ++ intro s hs ++ rcases le_or_gt 1 s.re with one_le|lt_one ++ · exact riemannZeta_ne_zero_of_one_le_re one_le ++ rw [← re_add_im s] ++ have := Complex.mem_reProdIm.mp hs.1 ++ rcases lt_or_ge 3 |s.im| with gt3|le3 ++ · apply restOfZetaZeroFree _ _ gt3 ++ refine ⟨?_, lt_one⟩ ++ calc ++ _ ≤ 1 - A₀ / Real.log T ^ 9 := by ++ gcongr ++ · exact A_inter.1.le ++ · bound ++ · bound ++ · bound ++ · exact abs_le.mpr ⟨this.2.1, this.2.2⟩ ++ _ ≤ _:= by exact this.1.1 ++ ++ · apply noZerosInBox _ le3 ++ calc ++ _ ≥ 1 - A₀ / Real.log T ^ 9 := by exact this.1.1 ++ _ ≥ 1 - A₀ / Real.log 3 ^ 9 := by ++ gcongr ++ apply le_min A_inter.1.le ++ bound ++ _ ≥ 1 - (((1 - σ₁) * Real.log 3 ^ 9)) / Real.log 3 ^ 9:= by ++ gcongr ++ apply min_le_right ++ _ = _ := by field_simp; simp ++ ++theorem summable_complex_then_summable_real_part (f : ℕ → ℂ) ++ (h : Summable f) : Summable (fun n ↦ (f n).re) := by ++ rcases h with ⟨s, hs⟩ ++ exact ⟨s.re, hasSum_re hs⟩ ++ ++open ArithmeticFunction (vonMangoldt) ++local notation "Λ" => vonMangoldt ++ ++open scoped ComplexOrder in ++theorem dlog_riemannZeta_bdd_on_vertical_lines_generalized ++ (σ₀ σ₁ t : ℝ) (σ₀_gt_one : 1 < σ₀) (σ₀_lt_σ₁ : σ₀ ≤ σ₁) : ++ ‖(- ζ' (σ₁ + t * I) / ζ (σ₁ + t * I))‖ ≤ ‖ζ' σ₀ / ζ σ₀‖ := by ++ let s₁ := σ₁ + t * I ++ have s₁_re_eq_sigma : s₁.re = σ₁ := by ++ rw [add_re, ofReal_re, mul_I_re, ofReal_im] ++ ring ++ ++ have s₀_re_eq_sigma : (↑σ₀ : ℂ).re = σ₀ := by ++ rw [ofReal_re] ++ ++ let s₀ := σ₀ ++ ++ have σ₁_gt_one : 1 < σ₁ := by exact lt_of_le_of_lt' σ₀_lt_σ₁ σ₀_gt_one ++ have s₀_gt_one : 1 < (↑σ₀ : ℂ).re := by exact σ₀_gt_one ++ ++ have s₁_re_geq_one : 1 < s₁.re := by exact lt_of_lt_of_eq σ₁_gt_one (id (Eq.symm s₁_re_eq_sigma)) ++ rw [← (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div s₁_re_geq_one)] ++ unfold LSeries ++ ++ have summable_von_mangoldt_at_σ₀ : Summable (fun i ↦ LSeries.term (fun n ↦ ↑(Λ n)) σ₀ i) := by ++ exact ArithmeticFunction.LSeriesSummable_vonMangoldt σ₀_gt_one ++ ++ have summable_re_von_mangoldt_at_σ₀ : ++ Summable (fun i ↦ (LSeries.term (fun n ↦ ↑(Λ n)) σ₀ i).re) := by ++ exact summable_complex_then_summable_real_part (LSeries.term (fun n ↦ ↑(Λ n)) σ₀) ++ summable_von_mangoldt_at_σ₀ ++ ++ have summable_abs_value : Summable (fun i ↦ ‖LSeries.term (fun n ↦ ↑(Λ n)) s₁ i‖) := by ++ rw [summable_norm_iff] ++ exact ArithmeticFunction.LSeriesSummable_vonMangoldt s₁_re_geq_one ++ apply le_trans <| norm_tsum_le_tsum_norm summable_abs_value ++ rw [← norm_neg, ← neg_div, ← ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div s₀_gt_one] ++ unfold LSeries ++ rw [← re_eq_norm.mpr, re_tsum summable_von_mangoldt_at_σ₀] ++ · apply Summable.tsum_mono summable_abs_value summable_re_von_mangoldt_at_σ₀ ++ intro n ++ beta_reduce ++ apply le_trans <| LSeries.norm_term_le_of_re_le_re (s := σ₀) _ _ _ ++ · rw [re_eq_norm.mpr] ++ apply LSeries.term_nonneg ++ exact_mod_cast ArithmeticFunction.vonMangoldt_nonneg ++ · rwa [s₁_re_eq_sigma, s₀_re_eq_sigma] ++ · apply tsum_nonneg ++ intro n ++ apply LSeries.term_nonneg ++ exact_mod_cast ArithmeticFunction.vonMangoldt_nonneg ++ ++theorem triv_bound_zeta : ∃C ≥ 0, ∀(σ₀ t : ℝ), 1 < σ₀ → ++ ‖- ζ' (σ₀ + t * I) / ζ (σ₀ + t * I)‖ ≤ (σ₀ - 1)⁻¹ + C := by ++ let ⟨U, ⟨U_in_nhds, zeta_residue_on_U⟩⟩ := riemannZetaLogDerivResidue ++ let ⟨open_in_U, ⟨open_in_U_subs_U, open_in_U_is_open, one_in_open_U⟩⟩ := ++ mem_nhds_iff.mp U_in_nhds ++ let ⟨ε₀, ⟨ε_pos, metric_ball_around_1_is_in_U'⟩⟩ := ++ EMetric.isOpen_iff.mp open_in_U_is_open (1 : ℂ) one_in_open_U ++ ++ let ε := if ε₀ = ⊤ then ENNReal.ofReal 1 else ε₀ ++ have O1 : ε ≠ ⊤ := by ++ unfold ε ++ by_cases h : ε₀ = ⊤ <;> simp [*] ++ ++ have metric_ball_around_1_is_in_U : ++ Metric.eball (1 : ℂ) ε ⊆ U := by ++ unfold ε ++ by_cases h : ε₀ = ⊤ ++ · simp only [↓reduceIte, ENNReal.ofReal_one, h] ++ have T : Metric.eball (1 : ℂ) 1 ⊆ Metric.eball 1 ε₀ := by ++ simp [*] ++ exact subset_trans (subset_trans T metric_ball_around_1_is_in_U') open_in_U_subs_U ++ ++ · simp only [h, ↓reduceIte] ++ exact subset_trans metric_ball_around_1_is_in_U' open_in_U_subs_U ++ ++ have O2 : ε ≠ 0 := by ++ unfold ε ++ by_cases h : ε₀ = ⊤ ++ · simp [*] ++ · simp only [↓reduceIte, ne_eq, h] ++ exact pos_iff_ne_zero.mp ε_pos ++ ++ let metric_ball_around_1 := Metric.eball (1 : ℂ) ε ++ let ε_div_two := ε / 2 ++ let boundary := ENNReal.toReal (1 + ε_div_two) ++ ++ let ⟨bound, ⟨bound_pos, bound_prop⟩⟩ := ++ BddAbove.exists_ge zeta_residue_on_U 0 ++ ++ have boundary_geq_one : 1 < boundary := by ++ unfold boundary ++ have Z : (1 : ENNReal).toReal = 1 := by rfl ++ rw [←Z] ++ have U : ε_div_two ≠ ⊤ := by ++ refine ENNReal.div_ne_top O1 ?_ ++ simp ++ simp only [ENNReal.toReal_one, ne_eq, ENNReal.one_ne_top, not_false_eq_true, ++ ENNReal.toReal_add _ U, lt_add_iff_pos_right, gt_iff_lt] ++ refine ENNReal.toReal_pos ?_ ?_ ++ · unfold ε_div_two ++ simp [*] ++ · exact U ++ ++ let const : ℝ := bound ++ let final_const : ℝ := (boundary - 1)⁻¹ + const ++ have final_const_pos : final_const ≥ 0 := by bound ++ have const_le_final_const : const ≤ final_const := by bound ++ ++ refine ⟨final_const, final_const_pos, fun σ₀ t σ₀_gt ↦ ?_⟩ ++ have U4 : ENNReal.ofReal 1 ≠ ⊤ := by exact ENNReal.ofReal_ne_top ++ have Z0 : ε_div_two.toReal < ε.toReal := by ++ exact ENNReal.toReal_strict_mono O1 <| ENNReal.half_lt_self O2 O1 ++ ++ by_cases! h : σ₀ ≤ boundary ++ · have σ₀_in_ball : (↑σ₀ : ℂ) ∈ metric_ball_around_1 := by ++ unfold metric_ball_around_1 ++ unfold Metric.eball ++ simp only [mem_ofPred_eq] ++ rw [edist_dist, dist_eq_norm] ++ norm_cast ++ have U : 0 ≤ σ₀ - 1 := by linarith ++ simp only [Real.norm_of_nonneg U, gt_iff_lt] ++ simp only [ENNReal.ofReal_lt_iff_lt_toReal U O1] ++ calc ++ _ ≤ boundary - 1 := by linarith ++ _ = ENNReal.toReal (1 + ε_div_two) - 1 := rfl ++ _ = ENNReal.toReal (1 + ε_div_two) - ENNReal.toReal (ENNReal.ofReal 1) := by simp ++ _ ≤ ENNReal.toReal (1 + ε_div_two - ENNReal.ofReal 1) := ENNReal.le_toReal_sub U4 ++ _ = ENNReal.toReal (ε_div_two) := by ++ simp only [ENNReal.ofReal_one, ENNReal.addLECancellable_iff_ne, ne_eq, ++ ENNReal.one_ne_top, not_false_eq_true, AddLECancellable.add_tsub_cancel_left] ++ _ < ε.toReal := Z0 ++ ++ have σ₀_in_U : (↑σ₀ : ℂ) ∈ (U \ {1}) := by ++ refine Set.mem_sdiff_singleton.mpr ?_ ++ constructor ++ · exact metric_ball_around_1_is_in_U σ₀_in_ball ++ · by_contra a ++ have U : σ₀ = 1 := by exact ofReal_eq_one.mp a ++ rw [U] at σ₀_gt ++ linarith ++ ++ have bdd := Set.forall_mem_image.mp bound_prop (σ₀_in_U) ++ simp only [Function.comp_apply, Pi.sub_apply, Pi.neg_apply, Pi.div_apply] at bdd ++ ++ calc ++ _ ≤ ‖ζ' σ₀ / ζ σ₀‖ := by ++ exact dlog_riemannZeta_bdd_on_vertical_lines_generalized σ₀ σ₀ t (σ₀_gt) (by simp) ++ _ = ‖- ζ' σ₀ / ζ σ₀‖ := by simp only [Complex.norm_div, norm_neg] ++ _ = ‖(- ζ' σ₀ / ζ σ₀ - (σ₀ - 1)⁻¹) + (σ₀ - 1)⁻¹‖ := by ++ simp only [Complex.norm_div, norm_neg, ofReal_inv, ofReal_sub, ofReal_one, sub_add_cancel] ++ _ ≤ ‖(- ζ' σ₀ / ζ σ₀ - (σ₀ - 1)⁻¹)‖ + ‖(σ₀ - 1)⁻¹‖ := by ++ have Z := norm_add_le (- ζ' σ₀ / ζ σ₀ - (σ₀ - 1)⁻¹) ((σ₀ - 1)⁻¹) ++ norm_cast at Z ++ _ ≤ const + ‖(σ₀ - 1)⁻¹‖ := by ++ have U := add_le_add_left bdd ‖(σ₀ - 1)⁻¹‖ ++ ring_nf at U ++ ring_nf ++ norm_cast at U ++ norm_cast ++ _ ≤ const + (σ₀ - 1)⁻¹ := by ++ simp [norm_inv] ++ have pos : 0 ≤ σ₀ - 1 := by ++ linarith ++ simp [abs_of_nonneg pos] ++ _ = (σ₀ - 1)⁻¹ + const := by ++ rw [add_comm] ++ _ ≤ (σ₀ - 1)⁻¹ + final_const := by ++ simp [const_le_final_const] ++ ++ · have boundary_in_ball : (↑boundary : ℂ) ∈ metric_ball_around_1 := by ++ unfold metric_ball_around_1 ++ unfold Metric.eball ++ simp only [mem_ofPred_eq] ++ rw [edist_dist, dist_eq_norm] ++ norm_cast ++ have U : 0 ≤ boundary - 1 := by linarith ++ simp only [Real.norm_of_nonneg U, gt_iff_lt] ++ simp only [ENNReal.ofReal_lt_iff_lt_toReal U O1] ++ calc ++ _ = ENNReal.toReal (1 + ε_div_two) - 1 := rfl ++ _ = ENNReal.toReal (1 + ε_div_two) - ENNReal.toReal (ENNReal.ofReal 1) := by simp ++ _ ≤ ENNReal.toReal (1 + ε_div_two - ENNReal.ofReal 1) := ENNReal.le_toReal_sub U4 ++ _ = ENNReal.toReal (ε_div_two) := by ++ simp only [ENNReal.ofReal_one, ENNReal.addLECancellable_iff_ne, ne_eq, ++ ENNReal.one_ne_top, not_false_eq_true, AddLECancellable.add_tsub_cancel_left] ++ _ < ε.toReal := Z0 ++ ++ have boundary_in_U : (↑boundary : ℂ) ∈ U \ {1} := by ++ refine Set.mem_sdiff_singleton.mpr ?_ ++ constructor ++ · exact metric_ball_around_1_is_in_U boundary_in_ball ++ · by_contra a ++ norm_cast at a ++ norm_cast at boundary_geq_one ++ simp [←a] at boundary_geq_one ++ ++ have bdd := Set.forall_mem_image.mp bound_prop (boundary_in_U) ++ ++ calc ++ _ ≤ ‖ζ' boundary / ζ boundary‖ := by ++ exact dlog_riemannZeta_bdd_on_vertical_lines_generalized boundary σ₀ t ++ (boundary_geq_one) (by linarith) ++ _ = ‖- ζ' boundary / ζ boundary‖ := by simp only [Complex.norm_div, norm_neg] ++ _ = ‖(- ζ' boundary / ζ boundary - (boundary - 1)⁻¹) + (boundary - 1)⁻¹‖ := by ++ simp only [Complex.norm_div, norm_neg, ofReal_inv, ofReal_sub, ofReal_one, sub_add_cancel] ++ _ ≤ ‖(- ζ' boundary / ζ boundary - (boundary - 1)⁻¹)‖ + ‖(boundary - 1)⁻¹‖ := by ++ have Z := norm_add_le (- ζ' boundary / ζ boundary - (boundary - 1)⁻¹) ((boundary - 1)⁻¹) ++ norm_cast at Z ++ _ ≤ const + ‖(boundary - 1)⁻¹‖ := by ++ have U9 := add_le_add_left bdd ‖(boundary - 1)⁻¹‖ ++ ring_nf at U9 ++ ring_nf ++ norm_cast at U9 ++ norm_cast ++ simpa [*] using! U9 ++ _ ≤ const + (boundary - 1)⁻¹ := by ++ simp [norm_inv] ++ have pos : 0 ≤ boundary - 1 := by ++ linarith ++ simp [abs_of_nonneg pos] ++ _ = (boundary - 1)⁻¹ + const := by ++ rw [add_comm] ++ _ = final_const := by rfl ++ _ ≤ _ := by bound ++ ++lemma LogDerivZetaBndUnif : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (C : ℝ) (_ : 0 < C), ∀ (σ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Ici (1 - A / Real.log |t| ^ 9)), ‖ζ' (σ + t * I) / ζ (σ + t * I)‖ ≤ ++ C * Real.log |t| ^ 9 := by ++ let ⟨A, pf_A, C, C_pos, ζbd_in⟩ := LogDerivZetaBnd ++ let ⟨C_triv, ⟨pf_C_triv, ζbd_out⟩⟩ := triv_bound_zeta ++ have T0 : A > 0 := pf_A.1 ++ ++ have ha : 1 ≤ A⁻¹ := by ++ simp only [one_div, mem_Ioc, true_and, T0] at pf_A ++ have U := (inv_le_inv₀ (by positivity) (by positivity)).mpr pf_A ++ simp only [inv_inv] at U ++ linarith ++ ++ refine ⟨A, pf_A, ((1 + C + C_triv) * A⁻¹), (by positivity), fun σ t hyp_t hyp_σ ↦ ?_⟩ ++ have logt_gt' : (1 : ℝ) < Real.log |t| ^ 9 := by ++ calc ++ 1 < Real.log |t| := logt_gt_one hyp_t.le ++ _ ≤ (Real.log |t|) ^ 9 := ZetaInvBnd_aux (logt_gt_one hyp_t.le) ++ ++ have logt_gt'' : (1 : ℝ) < 1 + A / Real.log |t| ^ 9 := by ++ simp only [lt_add_iff_pos_right, div_pos_iff_of_pos_left, T0] ++ positivity ++ ++ have T1 : ∀⦃σ : ℝ⦄, 1 + A / Real.log |t| ^ 9 ≤ σ → 1 < σ := by ++ intros ++ linarith ++ ++ have T2 : ∀⦃σ : ℝ⦄, 1 + A / Real.log |t| ^ 9 ≤ σ → A / Real.log |t| ^ 9 ≤ σ - 1 := by ++ intro σ' hyp_σ' ++ calc ++ A / Real.log |t| ^ 9 = (1 + A / Real.log |t| ^ 9) - 1 := by ring_nf ++ _ ≤ σ' - 1 := by gcongr ++ ++ by_cases h : σ ∈ Ico (1 - A / Real.log |t| ^ 9) (1 + A / Real.log |t| ^ 9) ++ · calc ++ ‖ζ' (↑σ + ↑t * I) / ζ (↑σ + ↑t * I)‖ ≤ C * Real.log |t| ^ 9 := ζbd_in σ t hyp_t h ++ _ ≤ ((1 + C + C_triv) * A⁻¹) * Real.log |t| ^ 9 := by ++ gcongr ++ · calc ++ C ≤ 1 + C := by simp only [le_add_iff_nonneg_left, zero_le_one] ++ _ ≤ (1 + C + C_triv) * 1 := by simp only [mul_one, le_add_iff_nonneg_right]; positivity ++ _ ≤ (1 + C + C_triv) * A⁻¹ := by gcongr ++ ++ · simp only [mem_Ico, tsub_le_iff_right, not_and, not_lt, mem_Ici] at h hyp_σ ++ replace h := h hyp_σ ++ calc ++ ‖ζ' (σ + t * I) / ζ (σ + t * I)‖ = ‖-ζ' (σ + t * I) / ζ (σ + t * I)‖ := by simp only [Complex.norm_div, ++ norm_neg] ++ ++ _ ≤ (σ - 1)⁻¹ + C_triv := ζbd_out σ t (by exact T1 h) ++ ++ _ ≤ (A / Real.log |t| ^ 9)⁻¹ + C_triv := by ++ gcongr ++ · exact T2 h ++ ++ _ ≤ (A / Real.log |t| ^ 9)⁻¹ + C_triv * A⁻¹ := by ++ gcongr ++ exact le_mul_of_one_le_right pf_C_triv ha ++ ++ _ ≤ (1 + C_triv) * A⁻¹ * Real.log |t| ^ 9 := by ++ simp only [inv_div] ++ ring_nf ++ gcongr ++ · simp only [inv_pos, le_mul_iff_one_le_left, T0] ++ linarith ++ ++ _ ≤ (1 + C + C_triv) * A⁻¹ * Real.log |t| ^ 9 := by gcongr; simp only [le_add_iff_nonneg_right]; positivity ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Erdos970/ZetaConj.lean b/PrimeNumberTheoremAnd/Erdos970/ZetaConj.lean +new file mode 100644 +index 0000000..79c01fe +--- /dev/null ++++ b/PrimeNumberTheoremAnd/Erdos970/ZetaConj.lean +@@ -0,0 +1,32 @@ ++import Mathlib.Analysis.Calculus.Deriv.Star ++import Mathlib.Analysis.Normed.Module.Connected ++import Mathlib.NumberTheory.Harmonic.ZetaAsymp ++ ++namespace Erdos970 ++ ++open scoped Complex ComplexConjugate ++ ++theorem deriv_conj_conj' (f : ℂ → ℂ) (p : ℂ) : ++ deriv (fun z ↦ conj (f (conj z))) (conj p) = conj (deriv f p) := by ++ trans deriv (conj ∘ f ∘ conj) (conj p) ++ · rfl ++ simp ++ ++theorem deriv_riemannZeta_conj (s : ℂ) : ++ deriv riemannZeta (conj s) = conj (deriv riemannZeta s) := by ++ simp [← deriv_conj_conj'] ++ ++theorem logDerivZeta_conj (s : ℂ) : ++ (deriv riemannZeta / riemannZeta) (conj s) = conj ((deriv riemannZeta / riemannZeta) s) := by ++ simp [deriv_riemannZeta_conj, riemannZeta_conj] ++ ++theorem logDerivZeta_conj' (s : ℂ) : ++ (logDeriv riemannZeta) (conj s) = conj (logDeriv riemannZeta s) := logDerivZeta_conj s ++ ++ ++theorem intervalIntegral_conj {f : ℝ → ℂ} {a b : ℝ} : ++ ∫ (x : ℝ) in a..b, conj (f x) = conj (∫ (x : ℝ) in a..b, f x) := by ++ rw [intervalIntegral.intervalIntegral_eq_integral_uIoc, integral_conj, ← RCLike.conj_smul, ++ ← intervalIntegral.intervalIntegral_eq_integral_uIoc] ++ ++end Erdos970 +diff --git a/PrimeNumberTheoremAnd/Fourier.lean b/PrimeNumberTheoremAnd/Fourier.lean +index 99e15a0..1a8cf07 100644 +--- a/PrimeNumberTheoremAnd/Fourier.lean ++++ b/PrimeNumberTheoremAnd/Fourier.lean +@@ -1,57 +1,29 @@ +-import Mathlib.Analysis.Distribution.SchwartzSpace.Deriv +-import Mathlib.MeasureTheory.Integral.IntegralEqImproper ++/- ++Adapted from PrimeNumberTheoremAnd by Alex Kontorovich and contributors. ++Licensed under the Apache License, Version 2.0; see the upstream LICENSE. ++This compatibility port retains the proven declarations used by this project. ++-/ + import Mathlib.Topology.ContinuousMap.Bounded.Basic +-import Mathlib.Order.Filter.ZeroAndBoundedAtFilter + import Mathlib.Analysis.Fourier.FourierTransformDeriv + import PrimeNumberTheoremAnd.Sobolev + + open FourierTransform Real Complex MeasureTheory Filter Topology BoundedContinuousFunction + SchwartzMap VectorFourier BigOperators + +-local instance {E : Type*} : Coe (E → ℝ) (E → ℂ) := ⟨fun f n => f n⟩ +- + section lemmas + +-@[simp] +-theorem nnnorm_eq_of_mem_circle (z : Circle) : ‖z.val‖₊ = 1 := +- NNReal.coe_eq_one.mp (by simp) +- +-@[simp] +-theorem nnnorm_circle_smul (z : Circle) (s : ℂ) : ‖z • s‖₊ = ‖s‖₊ := by +- simp [show z • s = z.val * s from rfl] +- +-noncomputable def e (u : ℝ) : ℝ →ᵇ ℂ where +- toFun v := 𝐞 (-v * u) +- map_bounded' := +- ⟨2, fun x y => (dist_le_norm_add_norm _ _).trans (by simp [Circle.norm_coe, one_add_one_eq_two])⟩ +- +-@[simp] lemma e_apply (u : ℝ) (v : ℝ) : e u v = 𝐞 (-v * u) := rfl +- +-theorem hasDerivAt_e {u x : ℝ} : HasDerivAt (e u) (-2 * π * u * I * e u x) x := by +- have l2 : HasDerivAt (fun v => -v * u) (-u) x := by +- simpa only [neg_mul_comm] using hasDerivAt_mul_const (-u) +- convert! (hasDerivAt_fourierChar (-x * u)).scomp x l2 using 1 +- change _ = ((-u : ℝ) : ℂ) * _ -- `scomp` introduces ℝ-smul on ℂ, which we undo +- simp ; ring +- +-lemma fourierIntegral_deriv_aux2 (e : ℝ →ᵇ ℂ) {f : ℝ → ℂ} (hf : Integrable f) : +- Integrable (⇑e * f) := +- hf.bdd_mul e.continuous.aestronglyMeasurable (ae_of_all _ e.norm_coe_le_norm) +- +-@[simp] lemma F_neg {f : ℝ → ℂ} {u : ℝ} : 𝓕 (fun x => -f x) u = - 𝓕 f u := by ++@[simp] theorem F_neg {f : ℝ → ℂ} {u : ℝ} : 𝓕 (fun x => -f x) u = - 𝓕 f u := by + simp [fourier_eq, integral_neg] + +-@[simp] lemma F_add {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : ++@[simp] theorem F_add {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : + 𝓕 (fun x => f x + g x) x = 𝓕 f x + 𝓕 g x := by +- have : Continuous fun p : ℝ × ℝ ↦ ((innerₗ ℝ) p.1) p.2 := continuous_inner +- have := fourierIntegral_add continuous_fourierChar this hf hg +- exact congr_fun this x ++ exact congr_fun (fourierIntegral_add continuous_fourierChar continuous_inner hf hg) x + +-@[simp] lemma F_sub {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : ++@[simp] theorem F_sub {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : + 𝓕 (fun x => f x - g x) x = 𝓕 f x - 𝓕 g x := by + simpa [sub_eq_add_neg, Pi.neg_def] using F_add hf hg.neg x + +-@[simp] lemma F_mul {f : ℝ → ℂ} {c : ℂ} {u : ℝ} : ++@[simp] theorem F_mul {f : ℝ → ℂ} {c : ℂ} {u : ℝ} : + 𝓕 (fun x => c * f x) u = c * 𝓕 f u := by + exact congr_fun (VectorFourier.fourierIntegral_const_smul 𝐞 _ _ f c) u + +@@ -67,121 +39,5 @@ theorem fourierIntegral_self_add_deriv_deriv (f : W21) (u : ℝ) : + simp [f.hf, l1, add_mul, Real.fourier_deriv f.hf' l5 f.hf'', Real.fourier_deriv f.hf l4 f.hf'] + field_simp [pi_ne_zero] ; ring_nf ; simp + +-@[simp] lemma deriv_ofReal : deriv ofReal = fun _ => 1 := by ++@[simp] theorem deriv_ofReal : deriv ofReal = fun _ => 1 := by + ext x ; exact ((hasDerivAt_id x).ofReal_comp).deriv +- +-/-- If, eventually in `T`, the integrand `f T` is bounded on `uIoc lo hi` by `B T` +-and `B T * |hi - lo| → 0`, then the interval integral `∫ x in lo..hi, f T x → 0`. -/ +-lemma tendsto_intervalIntegral_zero_of_uniform_norm_bound +- {f : ℝ → ℝ → ℂ} {lo hi : ℝ} {B : ℝ → ℝ} +- (hB : Filter.Tendsto (fun T : ℝ => B T * |hi - lo|) Filter.atTop (nhds 0)) +- (hf : ∀ᶠ T in Filter.atTop, ∀ x ∈ Set.uIoc lo hi, ‖f T x‖ ≤ B T) : +- Filter.Tendsto (fun T : ℝ => ∫ x in lo..hi, f T x) Filter.atTop (nhds 0) := by +- rw [tendsto_zero_iff_norm_tendsto_zero] +- refine squeeze_zero' (Eventually.of_forall fun T => norm_nonneg _) ?_ hB +- filter_upwards [hf] with T hT +- exact intervalIntegral.norm_integral_le_of_norm_le_const (fun x hx => hT x hx) +- +-/-- The decay `K * (log (T + 2) / (T + 2)) → 0` as `T → ∞`, for any constant `K`. -/ +-lemma tendsto_const_mul_log_add_two_div_add_two_atTop (K : ℝ) : +- Filter.Tendsto (fun T : ℝ => K * (Real.log (T + 2) / (T + 2))) +- Filter.atTop (nhds 0) := by +- have h0 : Filter.Tendsto (fun x : ℝ => Real.log x / x) Filter.atTop (nhds 0) := by +- simpa using (Real.tendsto_pow_log_div_mul_add_atTop 1 0 1 (by norm_num : (1 : ℝ) ≠ 0)) +- have hshift : Filter.Tendsto (fun T : ℝ => Real.log (T + 2) / (T + 2)) +- Filter.atTop (nhds 0) := by +- have := h0.comp (tendsto_atTop_add_const_right Filter.atTop 2 tendsto_id) +- simpa [Function.comp_def] using this +- simpa using hshift.const_mul K +- +-/-- Fourier-transform decay from an integrable derivative: for integrable, +-differentiable `g` with integrable derivative, `‖𝓕 g w‖ ≤ (∫ ‖deriv g x‖) / (2π·|w|)`. -/ +-lemma norm_fourier_le_integral_deriv_div +- (g : ℝ → ℂ) (hg : Integrable g) (hdiff : Differentiable ℝ g) +- (hg' : Integrable (deriv g)) {w : ℝ} (hw : w ≠ 0) : +- ‖𝓕 g w‖ ≤ (∫ x, ‖deriv g x‖ ∂volume) / ((2 * Real.pi) * |w|) := by +- have hmul : +- 𝓕 (deriv g) w = (2 * Real.pi * Complex.I * (w : ℂ)) * 𝓕 g w := by +- have h := congrFun (Real.fourier_deriv hg hdiff hg') w +- simpa [smul_eq_mul, mul_assoc] using h +- have h_fourier : +- ‖𝓕 (deriv g) w‖ ≤ ∫ x, ‖deriv g x‖ ∂volume := by +- exact VectorFourier.norm_fourierIntegral_le_integral_norm 𝐞 volume (innerₗ ℝ) +- (deriv g) w +- have hleft : +- ((2 * Real.pi) * |w|) * ‖𝓕 g w‖ = +- ‖(2 * Real.pi * Complex.I * (w : ℂ)) * 𝓕 g w‖ := by +- have htwopi : ‖(2 * ↑Real.pi : ℂ)‖ = 2 * Real.pi := by +- rw [norm_mul, Complex.norm_two, Complex.norm_of_nonneg Real.pi_pos.le] +- have hwc : ‖(w : ℂ)‖ = |w| := by rw [norm_real, Real.norm_eq_abs] +- rw [norm_mul, norm_mul, norm_mul, htwopi, norm_I, hwc] +- ring +- have hmain : ((2 * Real.pi) * |w|) * ‖𝓕 g w‖ ≤ ∫ x, ‖deriv g x‖ ∂volume := by +- rw [hleft, ← hmul] +- exact h_fourier +- have hpos : 0 < (2 * Real.pi) * |w| := by +- positivity +- exact (le_div_iff₀ hpos).mpr (by simpa [mul_comm, mul_left_comm, mul_assoc] using hmain) +- +-/-- The oscillatory-integral form of the decay bound: for `0 < T`, +-`‖∫ g y · exp(T·i·y)‖ ≤ (∫ ‖deriv g x‖) / T`. -/ +-lemma norm_oscillatory_integral_le_integral_deriv_div +- (g : ℝ → ℂ) (hg : Integrable g) (hdiff : Differentiable ℝ g) +- (hg' : Integrable (deriv g)) {T : ℝ} (hT : 0 < T) : +- ‖∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume‖ ≤ +- (∫ x, ‖deriv g x‖ ∂volume) / T := by +- have hw : -T / (2 * Real.pi) ≠ 0 := by +- exact div_ne_zero (neg_ne_zero.mpr hT.ne') (mul_ne_zero two_ne_zero Real.pi_ne_zero) +- have hfourier := norm_fourier_le_integral_deriv_div g hg hdiff hg' hw +- have heq : +- (∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume) = +- 𝓕 g (-T / (2 * Real.pi)) := by +- rw [Real.fourier_real_eq_integral_exp_smul] +- apply integral_congr_ae +- filter_upwards with y +- rw [smul_eq_mul] +- rw [mul_comm (g y)] +- congr 1 +- congr 1 +- push_cast +- field_simp [Real.pi_ne_zero] +- rw [heq] +- refine hfourier.trans_eq ?_ +- congr 1 +- have hden : (2 * Real.pi) * |-T / (2 * Real.pi)| = T := by +- have htwopi_pos : 0 < 2 * Real.pi := by positivity +- have hneg : -T / (2 * Real.pi) < 0 := div_neg_of_neg_of_pos (neg_neg_of_pos hT) htwopi_pos +- rw [abs_of_neg hneg] +- field_simp [Real.pi_ne_zero] +- rw [hden] +- +-/-- The `|T|` variant of the oscillatory-integral decay bound: for `T ≠ 0`, +-`‖∫ g y · exp(T·i·y)‖ ≤ (∫ ‖deriv g x‖) / |T|`. -/ +-lemma norm_oscillatory_integral_le_integral_deriv_div_abs +- (g : ℝ → ℂ) (hg : Integrable g) (hdiff : Differentiable ℝ g) +- (hg' : Integrable (deriv g)) {T : ℝ} (hT : T ≠ 0) : +- ‖∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume‖ ≤ +- (∫ x, ‖deriv g x‖ ∂volume) / |T| := by +- have hw : -T / (2 * Real.pi) ≠ 0 := by +- exact div_ne_zero (neg_ne_zero.mpr hT) (mul_ne_zero two_ne_zero Real.pi_ne_zero) +- have hfourier := norm_fourier_le_integral_deriv_div g hg hdiff hg' hw +- have heq : +- (∫ y, g y * exp ((T : ℂ) * Complex.I * (y : ℂ)) ∂volume) = +- 𝓕 g (-T / (2 * Real.pi)) := by +- rw [Real.fourier_real_eq_integral_exp_smul] +- apply integral_congr_ae +- filter_upwards with y +- rw [smul_eq_mul] +- rw [mul_comm (g y)] +- congr 1 +- congr 1 +- push_cast +- field_simp [Real.pi_ne_zero] +- rw [heq] +- refine hfourier.trans_eq ?_ +- congr 1 +- have hden : (2 * Real.pi) * |-T / (2 * Real.pi)| = |T| := by +- have htwopi_pos : 0 < 2 * Real.pi := by positivity +- rw [abs_div, abs_neg, abs_of_pos htwopi_pos] +- field_simp [Real.pi_ne_zero] +- rw [hden] +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/CartanBounds.lean b/PrimeNumberTheoremAnd/SiegelZeros/CartanBounds.lean +new file mode 100644 +index 0000000..f378d4b +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/CartanBounds.lean +@@ -0,0 +1,843 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.Products ++import PrimeNumberTheoremAnd.SiegelZeros.Counting ++ ++namespace SiegelZeros ++ ++section ++namespace Complex ++ ++variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] ++ ++theorem norm_le_of_mem_ball_of_forall_sphere_norm_le {f : ℂ → F} {r C : ℝ} {z : ℂ} ++ (hd : Differentiable ℂ f) (hrpos : 0 < r) ++ (hz : z ∈ Metric.ball (0 : ℂ) r) (hsphere : ∀ u : ℂ, ‖u‖ = r → ‖f u‖ ≤ C) : ++ ‖f z‖ ≤ C := by ++ let U : Set ℂ := Metric.ball (0 : ℂ) r ++ have hfront : ∀ u ∈ frontier U, ‖f u‖ ≤ C := by ++ intro u hu ++ have hur : ‖u‖ = r := by ++ have hfront' : frontier (Metric.ball (0 : ℂ) r) = Metric.sphere (0 : ℂ) r := by ++ simpa using (frontier_ball (x := (0 : ℂ)) (r := r) (ne_of_gt hrpos)) ++ have : u ∈ Metric.sphere (0 : ℂ) r := by simpa [U, hfront'] using hu ++ simpa [Metric.mem_sphere, dist_zero_right] using this ++ exact hsphere u hur ++ exact _root_.Complex.norm_le_of_forall_mem_frontier_norm_le (f := f) (U := U) Metric.isBounded_ball ++ hd.diffContOnCl hfront (subset_closure hz) ++ ++end Complex ++end ++section ++namespace Complex ++namespace CartanBound ++ ++open _root_.Real _root_.SiegelZeros.Real MeasureTheory intervalIntegral ++open scoped Topology ENNReal ++ ++private lemma neg_log_le_sqrt_two_div {x : ℝ} (hx : 0 < x) (hxle : x ≤ 1) : ++ -Real.log x ≤ Real.sqrt (2 / x) := by ++ have hx0 : 0 ≤ x := le_of_lt hx ++ have ht : 0 ≤ -Real.log x := by ++ have : Real.log x ≤ 0 := Real.log_nonpos hx0 hxle ++ linarith ++ have hsq_div_two_le_exp : ∀ {t : ℝ}, 0 ≤ t → t ^ 2 / 2 ≤ Real.exp t := by ++ intro t ht ++ let g : ℝ → ℝ := fun u => Real.exp u - u ^ 2 / 2 ++ have hg_cont : ContinuousOn g (Set.Ici (0 : ℝ)) := by ++ have : Continuous g := by fun_prop ++ simpa using this.continuousOn ++ have hg_diff : DifferentiableOn ℝ g (interior (Set.Ici (0 : ℝ))) := by ++ intro u hu ++ have : DifferentiableAt ℝ g u := by fun_prop ++ exact this.differentiableWithinAt ++ have hg'_nonneg : ∀ u ∈ interior (Set.Ici (0 : ℝ)), 0 ≤ deriv g u := by ++ intro u hu ++ have hu0 : 0 < u := by simpa [interior_Ici] using hu ++ have hderiv : deriv g u = Real.exp u - u := by ++ have hExp : HasDerivAt Real.exp (Real.exp u) u := Real.hasDerivAt_exp u ++ have hpow2 : HasDerivAt (fun z : ℝ => z ^ 2) (2 * u) u := by ++ simpa using! ((hasDerivAt_id u).pow 2) ++ have hpow2_div : HasDerivAt (fun z : ℝ => z ^ 2 / 2) u u := by ++ simpa using (hpow2.div_const (2 : ℝ)) ++ have hG : HasDerivAt g (Real.exp u - u) u := by ++ simpa [g] using! hExp.sub hpow2_div ++ exact hG.deriv ++ have hu_le : u ≤ Real.exp u := by ++ have h1 : u + 1 ≤ Real.exp u := Real.add_one_le_exp u ++ exact (le_trans (le_add_of_nonneg_right (by norm_num)) h1) ++ have : 0 ≤ Real.exp u - u := sub_nonneg.2 hu_le ++ simpa [hderiv] using this ++ have hg_mono : MonotoneOn g (Set.Ici (0 : ℝ)) := ++ monotoneOn_of_deriv_nonneg (D := Set.Ici (0 : ℝ)) (hD := convex_Ici 0) ++ hg_cont hg_diff hg'_nonneg ++ have hg0 : g 0 = 1 := by simp [g] ++ have hle : g 0 ≤ g t := hg_mono (by simp) (by simpa [Set.mem_Ici] using ht) ht ++ have : (1 : ℝ) ≤ Real.exp t - t ^ 2 / 2 := by simpa [g, hg0] using hle ++ linarith ++ have hmain : (-Real.log x) ^ 2 / 2 ≤ Real.exp (-Real.log x) := hsq_div_two_le_exp ht ++ have hexp : Real.exp (-Real.log x) = x⁻¹ := by simp [Real.exp_neg, Real.exp_log hx] ++ have hsq2 : (-Real.log x) ^ 2 ≤ 2 * Real.exp (-Real.log x) := by nlinarith [hmain] ++ have hsq' : (-Real.log x) ^ 2 ≤ 2 / x := by simpa [hexp, div_eq_mul_inv, mul_assoc] using hsq2 ++ have hy : 0 ≤ 2 / x := div_nonneg (by norm_num) (le_of_lt hx) ++ exact (Real.le_sqrt ht hy).2 hsq' ++ ++lemma posLog_log_one_div_abs_one_sub_le_sqrt {t : ℝ} : ++ Real.posLog (1 / |1 - t|) ≤ Real.sqrt (2 / |1 - t|) := by ++ by_cases ht : |1 - t| ≤ 1 ++ · by_cases h0 : |1 - t| = 0 ++ · have : t = 1 := by ++ have : 1 - t = 0 := by simpa [abs_eq_zero] using h0 ++ linarith ++ subst this ++ simp ++ · have hpos : 0 < |1 - t| := lt_of_le_of_ne (abs_nonneg _) (Ne.symm h0) ++ have hle : -Real.log |1 - t| ≤ Real.sqrt (2 / |1 - t|) := ++ neg_log_le_sqrt_two_div (x := |1 - t|) hpos ht ++ have hlog : Real.log (1 / |1 - t|) = -Real.log |1 - t| := by simp [Real.log_inv] ++ have hnonneg : 0 ≤ Real.log (1 / |1 - t|) := by ++ exact Real.log_nonneg ((one_le_div hpos).2 ht) ++ have hmax : Real.posLog (1 / |1 - t|) = Real.log (1 / |1 - t|) := ++ max_eq_right hnonneg ++ calc ++ Real.posLog (1 / |1 - t|) = Real.log (1 / |1 - t|) := hmax ++ _ = -Real.log |1 - t| := hlog ++ _ ≤ Real.sqrt (2 / |1 - t|) := hle ++ · have hlt : 1 < |1 - t| := lt_of_not_ge ht ++ have hle0 : Real.log (1 / |1 - t|) ≤ 0 := by ++ have hpos : 0 < |1 - t| := lt_trans (by norm_num) hlt ++ have : (1 / |1 - t| : ℝ) ≤ 1 := (div_le_one hpos).2 (le_of_lt hlt) ++ exact le_trans (Real.log_le_log (by positivity) this) (by simp) ++ have hmax : Real.posLog (1 / |1 - t|) = 0 := max_eq_left hle0 ++ have hrhs : 0 ≤ Real.sqrt (2 / |1 - t|) := by ++ exact Real.sqrt_nonneg _ ++ rw [hmax] ++ exact hrhs ++ ++noncomputable def φ (t : ℝ) : ℝ := ++ log⁺ (1 / |1 - t|) ++ ++lemma measurable_phi : Measurable φ := by ++ unfold φ ++ simpa [Real.posLog_def, Real.posLog] using ++ (by fun_prop : Measurable fun t : ℝ => max 0 (Real.log (1 / |1 - t|))) ++ ++lemma phi_le_log_two_of_le_half {t : ℝ} (ht : t ≤ (1 / 2 : ℝ)) : φ t ≤ Real.log 2 := by ++ have hnonneg : 0 ≤ (1 - t : ℝ) := by linarith ++ have hden : (1 / 2 : ℝ) ≤ |1 - t| := by ++ have : (1 / 2 : ℝ) ≤ (1 - t : ℝ) := by linarith ++ simpa [abs_of_nonneg hnonneg] using this ++ have hfrac : (1 / |1 - t| : ℝ) ≤ 2 := by ++ have hhalfpos : (0 : ℝ) < (1 / 2 : ℝ) := by norm_num ++ have := one_div_le_one_div_of_le hhalfpos hden ++ simpa [one_div, div_eq_mul_inv] using this ++ have hposLog : log⁺ (1 / |1 - t|) ≤ log⁺ (2 : ℝ) := ++ Real.posLog_le_posLog ((by trans (0 : ℝ); norm_num; positivity)) hfrac ++ have habs : (1 : ℝ) ≤ |(2 : ℝ)| := by ++ simp ++ have hposLog2 : (log⁺ (2 : ℝ)) = Real.log 2 := by ++ simpa using (Real.posLog_eq_log habs) ++ simpa [φ, hposLog2] using hposLog ++ ++lemma phi_eq_zero_of_one_le_abs_one_sub {t : ℝ} (ht : (1 : ℝ) ≤ |1 - t|) : φ t = 0 := by ++ have hpos : 0 < |1 - t| := lt_of_lt_of_le (by norm_num) ht ++ have hfrac : (1 / |1 - t| : ℝ) ≤ 1 := (div_le_one hpos).2 ht ++ have habs : |(1 / |1 - t| : ℝ)| ≤ 1 := by ++ have hnonneg : 0 ≤ (1 / |1 - t| : ℝ) := by positivity ++ simpa [abs_of_nonneg hnonneg] using hfrac ++ have : log⁺ (1 / |1 - t|) = 0 := (Real.posLog_eq_zero_iff _).2 habs ++ simpa [φ] using this ++ ++lemma φ_nonneg (t : ℝ) : 0 ≤ φ t := by ++ simpa [φ] using (Real.posLog_nonneg (x := (1 / |1 - t|))) ++ ++lemma φ_le_sqrt (t : ℝ) : φ t ≤ Real.sqrt (2 / |1 - t|) := by ++ simpa [φ, Real.posLog] using ++ posLog_log_one_div_abs_one_sub_le_sqrt (t := t) ++ ++lemma ae_restrict_norm_phi_le_of_forall_mem {A B : ℝ} (hAB : A ≤ B) {g : ℝ → ℝ} ++ (hg : ∀ t, 0 ≤ g t) (h : ∀ t ∈ Set.Icc A B, φ t ≤ g t) : ++ (fun t : ℝ => ‖φ t‖) ≤ᶠ[ae (volume.restrict (Set.uIoc A B))] fun t => ‖g t‖ := by ++ refine ++ MeasureTheory.ae_restrict_of_forall_mem (μ := (volume : MeasureTheory.Measure ℝ)) ++ (s := Set.uIoc A B) ++ (by simpa using (measurableSet_uIoc : MeasurableSet (Set.uIoc A B))) ?_ ++ intro t ht ++ have htIoc : t ∈ Set.Ioc A B := by ++ simpa [Set.uIoc_of_le hAB] using ht ++ have htIcc : t ∈ Set.Icc A B := ⟨le_of_lt htIoc.1, htIoc.2⟩ ++ have hle : φ t ≤ g t := h t htIcc ++ have hφ0 : 0 ≤ φ t := φ_nonneg t ++ have hg0 : 0 ≤ g t := hg t ++ simpa [Real.norm_eq_abs, abs_of_nonneg hφ0, abs_of_nonneg hg0] using hle ++ ++lemma log_norm_one_sub_div_ge_neg_phi {u a : ℂ} {r : ℝ} ++ (hur : ‖u‖ = r) (ha : a ≠ 0) (hr : r ≠ ‖a‖) : ++ Real.log ‖(1 : ℂ) - u / a‖ ≥ -φ (r / ‖a‖) := by ++ have ha_norm : 0 < ‖a‖ := norm_pos_iff.2 ha ++ have hnorm_eq : ‖(1 : ℂ) - u / a‖ = ‖a - u‖ / ‖a‖ := by ++ have : (1 : ℂ) - u / a = (a - u) / a := by ++ field_simp [ha] ++ calc ++ ‖(1 : ℂ) - u / a‖ = ‖(a - u) / a‖ := by simp [this] ++ _ = ‖a - u‖ / ‖a‖ := by simp ++ have hrev : |‖a‖ - ‖u‖| ≤ ‖a - u‖ := by ++ simpa using (abs_norm_sub_norm_le a u) ++ have hdiv : |‖a‖ - ‖u‖| / ‖a‖ ≤ ‖a - u‖ / ‖a‖ := ++ div_le_div_of_nonneg_right hrev (le_of_lt ha_norm) ++ have habs : |1 - (r / ‖a‖)| = |‖a‖ - ‖u‖| / ‖a‖ := by ++ have hu : ‖u‖ = r := hur ++ have ha0 : (‖a‖ : ℝ) ≠ 0 := ha_norm.ne' ++ have h1 : (1 : ℝ) - (r / ‖a‖) = (‖a‖ - r) / ‖a‖ := by ++ field_simp [ha0] ++ calc ++ |1 - (r / ‖a‖)| = |(‖a‖ - r) / ‖a‖| := by simp [h1] ++ _ = |‖a‖ - r| / ‖a‖ := by simp [abs_div, abs_of_pos ha_norm] ++ _ = |‖a‖ - ‖u‖| / ‖a‖ := by simp [hu] ++ have hnorm_ge : |1 - (r / ‖a‖)| ≤ ‖(1 : ℂ) - u / a‖ := by ++ have : |1 - (r / ‖a‖)| ≤ ‖a - u‖ / ‖a‖ := by ++ rw [habs] ++ exact hdiv ++ rwa [hnorm_eq] ++ have hx0 : 0 < |1 - (r / ‖a‖)| := by ++ have : (1 - (r / ‖a‖) : ℝ) ≠ 0 := by ++ intro h0 ++ have : r = ‖a‖ := by ++ have : r / ‖a‖ = (1 : ℝ) := by linarith ++ simpa using (div_eq_iff ha_norm.ne').1 this ++ exact hr this ++ have : |1 - (r / ‖a‖)| ≠ 0 := by ++ simpa [abs_eq_zero] using this ++ exact lt_of_le_of_ne (abs_nonneg _) (Ne.symm this) ++ have hlogx : ++ Real.log |1 - (r / ‖a‖)| ≥ -φ (r / ‖a‖) := by ++ have := Real.neg_posLog_inv_le_log (x := |1 - (r / ‖a‖)|) ++ simpa [φ, one_div, inv_inv, abs_sub_comm, sub_eq_add_neg] using this ++ have hlog_mono : ++ Real.log |1 - (r / ‖a‖)| ≤ Real.log ‖(1 : ℂ) - u / a‖ := ++ Real.log_le_log (by positivity) hnorm_ge ++ linarith [hlog_mono, hlogx] ++ ++noncomputable def K : ℝ := ++ ∫ (t : ℝ) in (1 / 4 : ℝ)..(4 : ℝ), Real.sqrt (2 / |1 - t|) ∂volume ++ ++lemma K_nonneg : 0 ≤ K := by ++ have hle : (1 / 4 : ℝ) ≤ (4 : ℝ) := by norm_num ++ have hnn : ∀ t ∈ Set.Icc (1 / 4 : ℝ) (4 : ℝ), 0 ≤ Real.sqrt (2 / |1 - t|) := by ++ intro _t _ht ++ exact Real.sqrt_nonneg _ ++ simpa [K] using (intervalIntegral.integral_nonneg ++ (μ := (volume : MeasureTheory.Measure ℝ)) hle hnn) ++ ++noncomputable def Cφ : ℝ := ++ Real.log 2 + 4 * K + 1 ++ ++lemma Cφ_pos : 0 < Cφ := by ++ have hlog : 0 < Real.log 2 := by ++ simpa using Real.log_pos (by norm_num : (1 : ℝ) < 2) ++ have hK : 0 ≤ K := K_nonneg ++ have : 0 < Real.log 2 + 4 * K := by nlinarith ++ have : 0 < Real.log 2 + 4 * K + 1 := by linarith ++ simpa [Cφ] using this ++ ++lemma intervalIntegrable_sqrt_two_div_abs_one_sub_Icc : ++ IntervalIntegrable ++ (fun t : ℝ => Real.sqrt (2 / |1 - t|)) ++ volume (1 / 4 : ℝ) (4 : ℝ) := by ++ let f : ℝ → ℝ := fun u => Real.sqrt (2 / |u|) ++ have hf0 : IntervalIntegrable f volume (0 : ℝ) (3 : ℝ) := by ++ have hpow : ++ IntervalIntegrable (fun u : ℝ => u ^ (- (2⁻¹ : ℝ))) volume (0 : ℝ) (3 : ℝ) := by ++ simpa using ++ (intervalIntegral.intervalIntegrable_rpow' (a := (0 : ℝ)) (b := (3 : ℝ)) ++ (r := (- (2⁻¹ : ℝ))) (by linarith : (-1 : ℝ) < - (2⁻¹ : ℝ))) ++ have hpow2 : ++ IntervalIntegrable (fun u : ℝ => Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ))) volume (0 : ℝ) (3 : ℝ) := ++ hpow.const_mul (Real.sqrt 2) ++ have hEq : ++ Set.EqOn f (fun u : ℝ => Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ))) (Set.uIoc (0 : ℝ) (3 : ℝ)) := by ++ intro u hu ++ have hu' : u ∈ Set.Ioc (0 : ℝ) (3 : ℝ) := by ++ simpa [Set.uIoc_of_le (show (0 : ℝ) ≤ 3 by norm_num)] using hu ++ have hu0 : 0 < u := hu'.1 ++ have hu0' : 0 ≤ u := le_of_lt hu0 ++ have habs : |u| = u := abs_of_nonneg hu0' ++ have : f u = Real.sqrt (2 / u) := by simp [f, habs] ++ calc ++ f u = Real.sqrt (2 / u) := this ++ _ = Real.sqrt 2 / Real.sqrt u := by simp ++ _ = Real.sqrt 2 * (Real.sqrt u)⁻¹ := by simp [div_eq_mul_inv] ++ _ = Real.sqrt 2 * (u ^ (2⁻¹ : ℝ))⁻¹ := by simp [Real.sqrt_eq_rpow] ++ _ = Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ)) := by ++ have h : (u ^ (2⁻¹ : ℝ))⁻¹ = u ^ (- (2⁻¹ : ℝ)) := by ++ simpa using (Real.rpow_neg hu0' (2⁻¹ : ℝ)).symm ++ simp [h] ++ exact ++ (IntervalIntegrable.congr (a := (0 : ℝ)) (b := (3 : ℝ)) ++ (μ := (volume : MeasureTheory.Measure ℝ)) ++ (f := fun u : ℝ => Real.sqrt 2 * u ^ (- (2⁻¹ : ℝ))) (g := f) hEq.symm) ++ hpow2 ++ have hf0' : IntervalIntegrable f volume (0 : ℝ) (3 / 4 : ℝ) := ++ hf0.mono_set (by ++ intro u hu ++ have hsub : Set.uIcc (0 : ℝ) (3 / 4 : ℝ) ⊆ Set.uIcc (0 : ℝ) (3 : ℝ) := by ++ refine Set.uIcc_subset_uIcc ?_ ?_ ++ · simp ++ · have h0 : (0 : ℝ) ≤ (3 / 4 : ℝ) := by nlinarith ++ have h1 : (3 / 4 : ℝ) ≤ (3 : ℝ) := by nlinarith ++ exact (Set.mem_uIcc).2 (Or.inl ⟨h0, h1⟩) ++ exact hsub hu) ++ have hleft : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume (1 / 4 : ℝ) (1 : ℝ) := by ++ have htmp : ++ IntervalIntegrable (fun t : ℝ => f (1 - t)) volume (1 : ℝ) ((1 : ℝ) - (3 / 4 : ℝ)) := by ++ simpa using (hf0'.comp_sub_left (c := (1 : ℝ))) ++ have htmp' : ++ IntervalIntegrable (fun t : ℝ => f (1 - t)) volume ((1 : ℝ) - (3 / 4 : ℝ)) (1 : ℝ) := ++ htmp.symm ++ have hsub : ((1 : ℝ) - (3 / 4 : ℝ)) = (1 / 4 : ℝ) := by norm_num ++ have htmp'' : IntervalIntegrable (fun t : ℝ => f (1 - t)) volume (1 / 4 : ℝ) (1 : ℝ) := by ++ simpa [hsub] using htmp' ++ simpa [f] using htmp'' ++ have hright : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume (1 : ℝ) (4 : ℝ) := by ++ have htmp : ++ IntervalIntegrable (fun t : ℝ => f (t - 1)) volume (1 : ℝ) ((3 : ℝ) + (1 : ℝ)) := by ++ simpa using (hf0.comp_sub_right (c := (1 : ℝ))) ++ have hsub : ((3 : ℝ) + (1 : ℝ)) = (4 : ℝ) := by norm_num ++ have htmp' : IntervalIntegrable (fun t : ℝ => f (t - 1)) volume (1 : ℝ) (4 : ℝ) := by ++ simpa [hsub] using htmp ++ have hcongr : ++ Set.EqOn (fun t : ℝ => f (t - 1)) (fun t : ℝ => Real.sqrt (2 / |1 - t|)) ++ (Set.uIoc (1 : ℝ) (4 : ℝ)) := by ++ intro t _ht ++ simp [f, abs_sub_comm] ++ exact ++ (IntervalIntegrable.congr (a := (1 : ℝ)) (b := (4 : ℝ)) ++ (μ := (volume : MeasureTheory.Measure ℝ)) ++ (f := fun t : ℝ => f (t - 1)) (g := fun t : ℝ => Real.sqrt (2 / |1 - t|)) hcongr) ++ htmp' ++ exact hleft.trans hright ++ ++lemma phi_le_log_two_on_dyadic_of_le_quarter {A t : ℝ} (hA : A ≤ (1 / 4 : ℝ)) ++ (ht : t ∈ Set.Icc A (2 * A)) : ++ φ t ≤ Real.log 2 := by ++ have ht_le : t ≤ (1 / 2 : ℝ) := by ++ exact ht.2.trans (by nlinarith [hA]) ++ exact phi_le_log_two_of_le_half ht_le ++ ++lemma phi_eq_zero_of_two_le {t : ℝ} (ht : (2 : ℝ) ≤ t) : φ t = 0 := by ++ have hden : (1 : ℝ) ≤ |1 - t| := by ++ have : (1 : ℝ) ≤ t - 1 := by linarith ++ have : (1 : ℝ) ≤ |t - 1| := by ++ simpa [abs_of_nonneg (by linarith : 0 ≤ t - 1)] using this ++ simpa [abs_sub_comm] using this ++ exact phi_eq_zero_of_one_le_abs_one_sub hden ++ ++lemma intervalIntegrable_phi_dyadic_small {A : ℝ} (hA0 : 0 ≤ A) ++ (hA : A ≤ (1 / 4 : ℝ)) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hconst : IntervalIntegrable (fun _ : ℝ => (Real.log 2 : ℝ)) volume A (2 * A) := ++ intervalIntegrable_const ++ have hmeas : ++ AEStronglyMeasurable (fun t : ℝ => φ t) (volume.restrict (Set.uIoc A (2 * A))) := ++ (measurable_phi.aestronglyMeasurable : _) ++ have hdom : ++ (fun t : ℝ => ‖φ t‖) ≤ᶠ[ae (volume.restrict (Set.uIoc A (2 * A)))] ++ fun _ => ‖(Real.log 2 : ℝ)‖ := by ++ refine ae_restrict_norm_phi_le_of_forall_mem (A := A) (B := 2 * A) hA_le ++ (g := fun _ => (Real.log 2 : ℝ)) (hg := fun _ => ?_) ?_ ++ · simpa using (Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 2)) ++ · intro t ht ++ exact phi_le_log_two_on_dyadic_of_le_quarter hA ht ++ exact IntervalIntegrable.mono_fun hconst hmeas hdom ++ ++lemma intervalIntegrable_phi_dyadic_large {A : ℝ} (hA : (2 : ℝ) ≤ A) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hEq : Set.EqOn (fun t : ℝ => φ t) (fun _ => (0 : ℝ)) (Set.uIoc A (2 * A)) := by ++ intro t ht ++ have htIoc : t ∈ Set.Ioc A (2 * A) := by ++ simpa [Set.uIoc_of_le hA_le] using ht ++ exact phi_eq_zero_of_two_le (le_trans hA (le_of_lt htIoc.1)) ++ have hz : IntervalIntegrable (fun _ : ℝ => (0 : ℝ)) volume A (2 * A) := ++ intervalIntegrable_const ++ exact (IntervalIntegrable.congr (a := A) (b := (2 * A)) ++ (μ := (volume : MeasureTheory.Measure ℝ)) ++ (f := fun _ => (0 : ℝ)) (g := fun t => φ t) (by ++ intro t ht ++ simpa using (hEq (x := t) ht).symm)) hz ++ ++lemma intervalIntegrable_sqrt_two_div_abs_one_sub_dyadic_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume A (2 * A) := by ++ have hsqrt_big : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) ++ (volume : MeasureTheory.Measure ℝ) (1 / 4 : ℝ) (4 : ℝ) := ++ intervalIntegrable_sqrt_two_div_abs_one_sub_Icc ++ refine hsqrt_big.mono_set ?_ ++ refine Set.uIcc_subset_uIcc ?_ ?_ ++ · exact (Set.mem_uIcc).2 (Or.inl ⟨hA_lower, by nlinarith [hA_upper]⟩) ++ · exact (Set.mem_uIcc).2 (Or.inl ⟨by nlinarith [hA_lower], by nlinarith [hA_upper]⟩) ++ ++lemma intervalIntegrable_phi_dyadic_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ have hA_le : A ≤ 2 * A := by nlinarith [hA_lower] ++ have hsqrt : ++ IntervalIntegrable (fun t : ℝ => Real.sqrt (2 / |1 - t|)) volume A (2 * A) := ++ intervalIntegrable_sqrt_two_div_abs_one_sub_dyadic_middle hA_lower hA_upper ++ have hmeas : ++ AEStronglyMeasurable (fun t : ℝ => φ t) (volume.restrict (Set.uIoc A (2 * A))) := ++ (measurable_phi.aestronglyMeasurable : _) ++ have hdom : ++ (fun t : ℝ => ‖φ t‖) ≤ᶠ[ae (volume.restrict (Set.uIoc A (2 * A)))] ++ fun t => ‖Real.sqrt (2 / |1 - t|)‖ := by ++ refine ae_restrict_norm_phi_le_of_forall_mem (A := A) (B := 2 * A) hA_le ++ (g := fun t => Real.sqrt (2 / |1 - t|)) (hg := fun _ => Real.sqrt_nonneg _) ?_ ++ intro t _ht ++ exact φ_le_sqrt t ++ exact IntervalIntegrable.mono_fun hsqrt hmeas hdom ++ ++lemma intervalIntegrable_phi_dyadic {A : ℝ} (hA : 0 ≤ A) : ++ IntervalIntegrable φ volume A (2 * A) := by ++ by_cases hA0 : A = 0 ++ · subst hA0 ++ simp ++ cases le_total A (1 / 4 : ℝ) with ++ | inl hsmall => ++ exact intervalIntegrable_phi_dyadic_small hA hsmall ++ | inr hge_quarter => ++ cases le_total (2 : ℝ) A with ++ | inl hbig => ++ exact intervalIntegrable_phi_dyadic_large hbig ++ | inr hA_le_two => ++ exact intervalIntegrable_phi_dyadic_middle hge_quarter hA_le_two ++ ++lemma intervalIntegrable_phi_div {a R : ℝ} (ha : 0 < a) (hR : 0 ≤ R) : ++ IntervalIntegrable (fun r : ℝ => φ (r / a)) volume R (2 * R) := by ++ have ha0 : a ≠ 0 := ne_of_gt ha ++ have hRa_nonneg : 0 ≤ R / a := by ++ exact div_nonneg hR (le_of_lt ha) ++ have hφ : IntervalIntegrable φ volume (R / a) (2 * (R / a)) := ++ intervalIntegrable_phi_dyadic (A := (R / a)) hRa_nonneg ++ have := (hφ.comp_mul_right (c := (a⁻¹ : ℝ))) ++ have hupper : a * (R * (a⁻¹ * 2)) = (2 * R) := by ++ field_simp [ha0] ++ simpa [div_eq_mul_inv, ha0, hupper, mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma log_two_le_Cφ : Real.log 2 ≤ Cφ := by ++ dsimp [Cφ] ++ have hK : 0 ≤ K := K_nonneg ++ linarith [hK] ++ ++lemma four_mul_K_add_one_le_Cφ : (4 * K + 1 : ℝ) ≤ Cφ := by ++ dsimp [Cφ] ++ have hlog_nonneg : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) ++ linarith [hlog_nonneg] ++ ++lemma integral_phi_le_Cφ_mul_small {A : ℝ} (hA0 : 0 ≤ A) (hA : A ≤ (1 / 4 : ℝ)) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hφ_int : IntervalIntegrable φ volume A (2 * A) := ++ intervalIntegrable_phi_dyadic_small hA0 hA ++ have hconst : IntervalIntegrable (fun _ : ℝ => (Real.log 2 : ℝ)) volume A (2 * A) := ++ intervalIntegrable_const ++ have hle_int : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ++ ≤ ∫ (t : ℝ) in A..(2 * A), (Real.log 2 : ℝ) ∂volume := by ++ refine intervalIntegral.integral_mono_on (μ := (volume : MeasureTheory.Measure ℝ)) ++ hA_le hφ_int hconst ?_ ++ intro t ht ++ exact phi_le_log_two_on_dyadic_of_le_quarter hA ht ++ have hRHS : ++ (∫ (t : ℝ) in A..(2 * A), (Real.log 2 : ℝ) ∂volume) = A * Real.log 2 := by ++ simp [intervalIntegral.integral_const, sub_eq_add_neg, add_assoc, two_mul] ++ have hcoef : A * Real.log 2 ≤ Cφ * A := by ++ have := mul_le_mul_of_nonneg_left log_two_le_Cφ hA0 ++ simpa [mul_assoc, mul_left_comm, mul_comm] using this ++ exact le_trans (by simpa [hRHS] using hle_int) hcoef ++ ++lemma integral_phi_le_Cφ_mul_large {A : ℝ} (hA : (2 : ℝ) ≤ A) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ have hA_le : A ≤ 2 * A := by nlinarith ++ have hφ0 : Set.EqOn (fun t : ℝ => φ t) (fun _ => (0 : ℝ)) (Set.uIcc A (2 * A)) := by ++ intro t ht ++ have ht' : t ∈ Set.Icc A (2 * A) := by ++ simpa [Set.uIcc_of_le hA_le] using ht ++ exact phi_eq_zero_of_two_le (le_trans hA ht'.1) ++ have hzero : (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) = 0 := by ++ simpa using intervalIntegral.integral_congr (μ := (volume : MeasureTheory.Measure ℝ)) hφ0 ++ have hnonneg : (0 : ℝ) ≤ Cφ * A := mul_nonneg (le_of_lt Cφ_pos) (by linarith) ++ simpa [hzero] using hnonneg ++ ++lemma integral_sqrt_two_div_abs_one_sub_le_K_dyadic_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ (∫ (t : ℝ) in A..(2 * A), Real.sqrt (2 / |1 - t|) ∂volume) ≤ K := by ++ let s (t : ℝ) : ℝ := Real.sqrt (2 / |1 - t|) ++ have hA_le : A ≤ 2 * A := by nlinarith [hA_lower] ++ have hA_upper' : (2 * A : ℝ) ≤ 4 := by nlinarith [hA_upper] ++ have hsqrt_big : IntervalIntegrable s volume (1 / 4 : ℝ) (4 : ℝ) := by ++ simpa [s] using intervalIntegrable_sqrt_two_div_abs_one_sub_Icc ++ have hle_K : ++ (∫ (t : ℝ) in A..(2 * A), s t ∂volume) ++ ≤ ∫ (t : ℝ) in (1 / 4 : ℝ)..(4 : ℝ), s t ∂volume := by ++ refine intervalIntegral.integral_mono_interval (μ := (volume : MeasureTheory.Measure ℝ)) ++ (c := (1 / 4 : ℝ)) (d := (4 : ℝ)) (a := A) (b := (2 * A)) ++ hA_lower hA_le hA_upper' ?_ hsqrt_big ++ exact Filter.Eventually.of_forall (fun _t => Real.sqrt_nonneg _) ++ simpa [K, s] using hle_K ++ ++lemma K_le_four_mul_K_add_one_mul_of_quarter_le {A : ℝ} (hA : (1 / 4 : ℝ) ≤ A) : ++ K ≤ (4 * K + 1) * A := by ++ have hcoef : 1 ≤ 4 * A := by nlinarith [hA] ++ have hK : 0 ≤ K := K_nonneg ++ nlinarith [hK, hcoef] ++ ++lemma integral_phi_le_Cφ_mul_middle {A : ℝ} ++ (hA_lower : (1 / 4 : ℝ) ≤ A) (hA_upper : A ≤ (2 : ℝ)) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ let s (t : ℝ) : ℝ := Real.sqrt (2 / |1 - t|) ++ have hA_le : A ≤ 2 * A := by nlinarith [hA_lower] ++ have hφ_int : IntervalIntegrable φ volume A (2 * A) := ++ intervalIntegrable_phi_dyadic_middle hA_lower hA_upper ++ have hsqrt : IntervalIntegrable s volume A (2 * A) := by ++ simpa [s] using ++ intervalIntegrable_sqrt_two_div_abs_one_sub_dyadic_middle hA_lower hA_upper ++ have hle_int : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ++ ≤ ∫ (t : ℝ) in A..(2 * A), s t ∂volume := by ++ refine intervalIntegral.integral_mono_on ++ (μ := (volume : MeasureTheory.Measure ℝ)) hA_le hφ_int hsqrt ?_ ++ intro t _ht ++ exact φ_le_sqrt t ++ have hsqrt_le : (∫ (t : ℝ) in A..(2 * A), s t ∂volume) ≤ (4 * K + 1) * A := by ++ have hK : (∫ (t : ℝ) in A..(2 * A), s t ∂volume) ≤ K := by ++ simpa [s] using integral_sqrt_two_div_abs_one_sub_le_K_dyadic_middle hA_lower hA_upper ++ exact le_trans hK (K_le_four_mul_K_add_one_mul_of_quarter_le hA_lower) ++ have hcoef : (4 * K + 1 : ℝ) * A ≤ Cφ * A := ++ mul_le_mul_of_nonneg_right four_mul_K_add_one_le_Cφ (by nlinarith [hA_lower]) ++ exact le_trans hle_int (le_trans hsqrt_le hcoef) ++ ++lemma integral_phi_le_Cφ_mul {A : ℝ} (hA : 0 ≤ A) : ++ (∫ (t : ℝ) in A..(2 * A), φ t ∂volume) ≤ Cφ * A := by ++ by_cases hA0 : A = 0 ++ · subst hA0 ++ simp [Cφ, φ, K] ++ cases le_total A (1 / 4 : ℝ) with ++ | inl hsmall => ++ exact integral_phi_le_Cφ_mul_small hA hsmall ++ | inr hge_quarter => ++ cases le_total (2 : ℝ) A with ++ | inl hbig => ++ exact integral_phi_le_Cφ_mul_large hbig ++ | inr hA_le_two => ++ exact integral_phi_le_Cφ_mul_middle hge_quarter hA_le_two ++ ++open scoped BigOperators ++ ++lemma volume_Ioc_two_mul_ne_zero {R : ℝ} (hR : 0 < R) : ++ (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R)) ≠ 0 := by ++ have hpos : (0 : ℝ) < 2 * R - R := by nlinarith [hR] ++ simp [Real.volume_Ioc, ENNReal.ofReal_eq_zero, not_le_of_gt hpos] ++ ++lemma volume_Ioc_two_mul_diff_finset_ne_zero (bad : Finset ℝ) {R : ℝ} (hR : 0 < R) : ++ (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ≠ 0 := by ++ have hbad_meas : (volume : MeasureTheory.Measure ℝ) (bad : Set ℝ) = 0 := by ++ simpa using (bad.measure_zero (μ := (volume : MeasureTheory.Measure ℝ))) ++ have hdiff : ++ (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ++ = (volume : MeasureTheory.Measure ℝ) (Set.Ioc R (2 * R)) := by ++ simpa [Set.sdiff_eq, Set.inter_assoc, Set.inter_left_comm, Set.inter_comm] using ++ (MeasureTheory.measure_sdiff_null (s := Set.Ioc R (2 * R)) (t := (bad : Set ℝ)) ++ hbad_meas) ++ simpa [hdiff] using volume_Ioc_two_mul_ne_zero hR ++ ++lemma restrict_volume_Ioc_two_mul_diff_finset_ne_zero (bad : Finset ℝ) {R : ℝ} (hR : 0 < R) : ++ (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ≠ 0 := by ++ have hsubset : Set.Ioc R (2 * R) \ (bad : Set ℝ) ⊆ Set.Ioc R (2 * R) := by ++ intro r hr ++ exact hr.1 ++ have hinter : ++ (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ∩ Set.Ioc R (2 * R) ++ = (Set.Ioc R (2 * R) \ (bad : Set ℝ)) := by ++ exact Set.inter_eq_left.mpr hsubset ++ simpa [MeasureTheory.Measure.restrict_apply, measurableSet_Ioc, hinter] using ++ volume_Ioc_two_mul_diff_finset_ne_zero bad hR ++ ++lemma integral_phi_div_le_Cφ_mul {a R : ℝ} (ha : 0 < a) (hR : 0 ≤ R) : ++ (∫ (r : ℝ) in R..(2 * R), φ (r / a) ∂volume) ≤ Cφ * R := by ++ have ha0 : a ≠ 0 := ne_of_gt ha ++ have hrew : ++ (∫ (r : ℝ) in R..(2 * R), φ (r / a) ∂volume) ++ = a * (∫ (t : ℝ) in (R / a)..(2 * R / a), φ t ∂volume) := by ++ simp [smul_eq_mul, mul_left_comm, mul_comm, div_eq_mul_inv, ha0] ++ rw [hrew] ++ have hA : 0 ≤ R / a := by ++ exact div_nonneg hR ha.le ++ have hle : (∫ (t : ℝ) in (R / a)..(2 * (R / a)), φ t ∂volume) ≤ Cφ * (R / a) := ++ integral_phi_le_Cφ_mul (A := R / a) hA ++ have hEq : (2 * R / a) = 2 * (R / a) := by ring ++ have hle' : ++ (∫ (t : ℝ) in (R / a)..(2 * R / a), φ t ∂volume) ≤ Cφ * (R / a) := by ++ simpa [hEq] using hle ++ have ha_nonneg : 0 ≤ a := ha.le ++ have := mul_le_mul_of_nonneg_left hle' ha_nonneg ++ have hRHS : a * (Cφ * (R / a)) = Cφ * R := by ++ field_simp [ha0] ++ simpa [hRHS, mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma intervalIntegrable_sum_mul_phi_div ++ {ι : Type} (s : Finset ι) (w : ι → ℝ) (a : ι → ℝ) ++ (ha : ∀ i ∈ s, 0 < a i) {R : ℝ} (hR : 0 ≤ R) : ++ IntervalIntegrable (∑ i ∈ s, fun r : ℝ => w i * φ (r / a i)) ++ volume R (2 * R) := by ++ refine IntervalIntegrable.sum (μ := volume) (a := R) (b := 2 * R) ++ (s := s) (f := fun i : ι => fun r : ℝ => w i * φ (r / a i)) ?_ ++ intro i hi ++ have hφi : IntervalIntegrable (fun r : ℝ => φ (r / a i)) volume R (2 * R) := ++ intervalIntegrable_phi_div (a := a i) (R := R) (ha i hi) hR ++ simpa [mul_assoc] using hφi.const_mul (w i) ++ ++lemma integral_sum_mul_phi_div_le_Cφ_mul_sum ++ {ι : Type} (s : Finset ι) (w : ι → ℝ) (a : ι → ℝ) ++ (hw : ∀ i ∈ s, 0 ≤ w i) (ha : ∀ i ∈ s, 0 < a i) {R : ℝ} (hR : 0 ≤ R) : ++ (∫ r in R..(2 * R), (∑ i ∈ s, fun r : ℝ => w i * φ (r / a i)) r ∂volume) ++ ≤ Cφ * (∑ i ∈ s, w i) * R := by ++ have hint : ∀ i ∈ s, IntervalIntegrable (fun r : ℝ => w i * φ (r / a i)) ++ volume R (2 * R) := by ++ intro i hi ++ have hφi : IntervalIntegrable (fun r : ℝ => φ (r / a i)) volume R (2 * R) := ++ intervalIntegrable_phi_div (a := a i) (R := R) (ha i hi) hR ++ simpa [mul_assoc] using hφi.const_mul (w i) ++ have hsum_int : ++ (∫ r in R..(2 * R), (∑ i ∈ s, fun r : ℝ => w i * φ (r / a i)) r ∂volume) ++ = ∑ i ∈ s, ∫ r in R..(2 * R), (fun r : ℝ => w i * φ (r / a i)) r ++ ∂volume := by ++ simpa using ++ (intervalIntegral.integral_finsetSum (μ := volume) (a := R) (b := 2 * R) ++ (s := s) (f := fun i : ι => fun r : ℝ => w i * φ (r / a i)) hint) ++ rw [hsum_int] ++ have hsum_le : ++ (∑ i ∈ s, ∫ r in R..(2 * R), (fun r : ℝ => w i * φ (r / a i)) r ∂volume) ++ ≤ ∑ i ∈ s, w i * (Cφ * R) := by ++ refine Finset.sum_le_sum ?_ ++ intro i hi ++ have hphi : ++ (∫ r in R..(2 * R), φ (r / a i) ∂volume) ≤ Cφ * R := ++ integral_phi_div_le_Cφ_mul (a := a i) (R := R) (ha i hi) hR ++ have := mul_le_mul_of_nonneg_left hphi (hw i hi) ++ simpa [mul_assoc, mul_left_comm, mul_comm] using this ++ refine le_trans hsum_le ?_ ++ have : (∑ i ∈ s, w i * (Cφ * R)) = Cφ * (∑ i ∈ s, w i) * R := by ++ calc ++ (∑ i ∈ s, w i * (Cφ * R)) = (∑ i ∈ s, w i) * (Cφ * R) := by ++ simp [Finset.sum_mul] ++ _ = Cφ * (∑ i ∈ s, w i) * R := by ++ ac_rfl ++ exact le_of_eq this ++ ++lemma exists_radius_Ioc_sum_mul_phi_div_le_Cφ_mul_sum_avoid ++ {ι : Type} (s : Finset ι) (w : ι → ℝ) (a : ι → ℝ) ++ (hw : ∀ i ∈ s, 0 ≤ w i) (ha : ∀ i ∈ s, 0 < a i) ++ (bad : Finset ℝ) {R : ℝ} (hR : 0 < R) : ++ ∃ r ∈ Set.Ioc R (2 * R), r ∉ bad ∧ ++ (∑ i ∈ s, w i * φ (r / a i)) ≤ Cφ * (∑ i ∈ s, w i) := by ++ by_contra hbad ++ have hforall : ++ ∀ r ∈ Set.Ioc R (2 * R), r ∉ bad → ++ Cφ * (∑ i ∈ s, w i) < (∑ i ∈ s, w i * φ (r / a i)) := by ++ intro r hr hrbad ++ have : ¬(∑ i ∈ s, w i * φ (r / a i)) ≤ Cφ * (∑ i ∈ s, w i) := by ++ intro hle ++ exact hbad ⟨r, hr, hrbad, hle⟩ ++ exact lt_of_not_ge this ++ let g : ℝ → ℝ := ∑ i ∈ s, fun r : ℝ => w i * φ (r / a i) ++ have hg_int : IntervalIntegrable g volume R (2 * R) := by ++ simpa [g] using intervalIntegrable_sum_mul_phi_div s w a ha hR.le ++ have hconst_int : ++ IntervalIntegrable (fun _r : ℝ => Cφ * (∑ i ∈ s, w i)) volume R (2 * R) := ++ intervalIntegrable_const ++ have hlt_meas : ++ (volume.restrict (Set.Ioc R (2 * R))) ++ {r | Cφ * (∑ i ∈ s, w i) < g r} ≠ 0 := by ++ have hall : Set.Ioc R (2 * R) \ (bad : Set ℝ) ⊆ {r | Cφ * (∑ i ∈ s, w i) < g r} := by ++ intro r hr ++ have hrIoc : r ∈ Set.Ioc R (2 * R) := hr.1 ++ have hrbad : r ∉ bad := by simpa using hr.2 ++ simpa [g] using hforall r hrIoc hrbad ++ have hle : ++ (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ++ ≤ (volume.restrict (Set.Ioc R (2 * R))) {r | Cφ * (∑ i ∈ s, w i) < g r} := ++ MeasureTheory.measure_mono hall ++ have hpos' : ++ (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) ≠ 0 := by ++ exact restrict_volume_Ioc_two_mul_diff_finset_ne_zero bad hR ++ intro hzero ++ have : (volume.restrict (Set.Ioc R (2 * R))) (Set.Ioc R (2 * R) \ (bad : Set ℝ)) = 0 := ++ le_antisymm (le_trans hle (le_of_eq hzero)) (by positivity) ++ exact hpos' this ++ have hlt_int : ++ (∫ r in R..(2 * R), (Cφ * (∑ i ∈ s, w i)) ∂volume) ++ < ∫ r in R..(2 * R), g r ∂volume := by ++ have hab : R ≤ 2 * R := by nlinarith [hR.le] ++ refine intervalIntegral.integral_lt_integral_of_ae_le_of_measure_setOfPred_lt_ne_zero (μ := volume) ++ (a := R) (b := 2 * R) (f := fun _ => (Cφ * (∑ i ∈ s, w i))) (g := g) ++ hab hconst_int hg_int ?_ hlt_meas ++ have hmem : ∀ᵐ r ∂ (volume.restrict (Set.Ioc R (2 * R))), r ∈ Set.Ioc R (2 * R) := ++ MeasureTheory.ae_restrict_mem (by simp) ++ have hnotBad : ++ ∀ᵐ r ∂ (volume.restrict (Set.Ioc R (2 * R))), r ∉ (bad : Set ℝ) := by ++ simpa using ++ (bad.finite_toSet.countable.ae_notMem (μ := (volume.restrict (Set.Ioc R (2 * R))))) ++ filter_upwards [hmem, hnotBad] with r hrIoc hrNotBad ++ have hrNotBad' : r ∉ bad := by simpa using hrNotBad ++ exact le_of_lt (by simpa [g] using hforall r hrIoc hrNotBad') ++ have hconst_eval : ++ (∫ r in R..(2 * R), (Cφ * (∑ i ∈ s, w i)) ∂volume) = Cφ * (∑ i ∈ s, w i) * R := by ++ simp [intervalIntegral.integral_const, sub_eq_add_neg, mul_comm] ++ ring ++ have hg_le : ++ (∫ r in R..(2 * R), g r ∂volume) ≤ Cφ * (∑ i ∈ s, w i) * R := by ++ simpa [g] using integral_sum_mul_phi_div_le_Cφ_mul_sum s w a hw ha hR.le ++ have : ¬(Cφ * (∑ i ∈ s, w i) * R < Cφ * (∑ i ∈ s, w i) * R) := lt_irrefl _ ++ have hcontra : Cφ * (∑ i ∈ s, w i) * R < Cφ * (∑ i ∈ s, w i) * R := by ++ have := hlt_int ++ simpa [hconst_eval] using (this.trans_le hg_le) ++ exact this hcontra ++ ++end CartanBound ++end Complex ++end ++section ++noncomputable section ++ ++namespace Complex.Hadamard ++ ++open _root_.SiegelZeros.Complex _root_.Real _root_.SiegelZeros.Real ++ ++lemma max_one_norm_div_pow_le_one_add_rpow ++ {m : ℕ} {τ r : ℝ} {u a : ℂ} ++ (hur : ‖u‖ = r) ++ (hmτ : (m : ℝ) ≤ τ) : ++ max 1 (‖u / a‖ ^ m) ≤ 1 + (r / ‖a‖) ^ τ := by ++ by_cases hx : ‖u / a‖ ≤ 1 ++ · have hpowm_le1 : ‖u / a‖ ^ m ≤ 1 := pow_le_one₀ (norm_nonneg (u / a)) hx ++ have hr0 : 0 ≤ r := by simpa [hur] using (norm_nonneg u) ++ have hbase : 0 ≤ r / ‖a‖ := div_nonneg hr0 (norm_nonneg a) ++ have hnonneg : 0 ≤ (r / ‖a‖) ^ τ := Real.rpow_nonneg hbase τ ++ have hle1 : (1 : ℝ) ≤ 1 + (r / ‖a‖) ^ τ := le_add_of_nonneg_right hnonneg ++ have hle2 : ‖u / a‖ ^ m ≤ 1 + (r / ‖a‖) ^ τ := hpowm_le1.trans hle1 ++ exact (max_le_iff).2 ⟨hle1, hle2⟩ ++ · have hx1 : 1 < ‖u / a‖ := lt_of_not_ge hx ++ have hpow : ++ (‖u / a‖ : ℝ) ^ (m : ℝ) ≤ (‖u / a‖ : ℝ) ^ τ := ++ Real.rpow_le_rpow_of_exponent_le (le_of_lt hx1) hmτ ++ have hpow' : ‖u / a‖ ^ m ≤ (‖u / a‖ : ℝ) ^ τ := by ++ simpa [Real.rpow_natCast] using hpow ++ have hmax_add : max 1 (‖u / a‖ ^ m) ≤ 1 + ‖u / a‖ ^ m := by ++ refine max_le (le_add_of_nonneg_right (by positivity)) (le_add_of_nonneg_left (by positivity)) ++ have : max 1 (‖u / a‖ ^ m) ≤ 1 + (‖u / a‖ : ℝ) ^ τ := ++ hmax_add.trans (by nlinarith [hpow']) ++ simpa [norm_div, hur] using this ++ ++lemma norm_inv_weierstrassFactor_le_exp_near ++ {m : ℕ} {τ r : ℝ} {u a : ℂ} ++ (hur : ‖u‖ = r) (ha : a ≠ 0) (hr : r ≠ ‖a‖) ++ (hmτ : (m : ℝ) ≤ τ) : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ ++ ≤ Real.exp (CartanBound.φ (r / ‖a‖) + (m : ℝ) * (1 + (r / ‖a‖) ^ τ)) := by ++ have hlog_one : ++ Real.log ‖(1 : ℂ) - u / a‖ ≥ -CartanBound.φ (r / ‖a‖) := ++ CartanBound.log_norm_one_sub_div_ge_neg_phi (hur := hur) (ha := ha) (hr := hr) ++ have hbase := ++ log_norm_weierstrassFactor_ge_log_norm_one_sub_sub (m := m) (z := (u / a)) ++ have hlogE : ++ Real.log ‖weierstrassFactor m (u / a)‖ ++ ≥ -CartanBound.φ (r / ‖a‖) - (m : ℝ) * max 1 (‖u / a‖ ^ m) := by ++ have hpls := ++ norm_partialLogSum_le_nat_mul_max_one_norm_pow m (u / a) ++ linarith [hbase, hlog_one, hpls] ++ have hmax : ++ max 1 (‖u / a‖ ^ m) ≤ 1 + (r / ‖a‖) ^ τ := ++ max_one_norm_div_pow_le_one_add_rpow (m := m) (τ := τ) (r := r) (u := u) (a := a) hur hmτ ++ have hneglog : ++ -Real.log ‖weierstrassFactor m (u / a)‖ ++ ≤ CartanBound.φ (r / ‖a‖) + (m : ℝ) * (1 + (r / ‖a‖) ^ τ) := by ++ have : -Real.log ‖weierstrassFactor m (u / a)‖ ++ ≤ CartanBound.φ (r / ‖a‖) + (m : ℝ) * max 1 (‖u / a‖ ^ m) := by ++ linarith [hlogE] ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ exact this.trans (by nlinarith [mul_le_mul_of_nonneg_left hmax hm0]) ++ have hpos : 0 < ‖weierstrassFactor m (u / a)‖ := by ++ have : weierstrassFactor m (u / a) ≠ 0 := by ++ intro h0 ++ have : u / a = (1 : ℂ) := (weierstrassFactor_eq_zero_iff m (u / a)).1 h0 ++ have : u = a := (div_eq_one_iff_eq ha).1 this ++ have : r = ‖a‖ := by simpa [this] using hur.symm ++ exact (hr this).elim ++ exact norm_pos_iff.2 this ++ have hEq : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ = ++ Real.exp (-Real.log ‖weierstrassFactor m (u / a)‖) := by ++ simp [norm_inv, Real.exp_neg, Real.exp_log hpos] ++ have := Real.exp_le_exp.2 hneglog ++ simpa [hEq] using this ++ ++lemma norm_inv_weierstrassFactor_le_exp_far ++ {m : ℕ} {τ r : ℝ} {u a : ℂ} ++ (hur : ‖u‖ = r) (ha : a ≠ 0) ++ (hz : ‖u / a‖ ≤ (1 / 2 : ℝ)) (hτ_le : τ ≤ (m + 1 : ℝ)) : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ ≤ Real.exp ((2 : ℝ) * (r / ‖a‖) ^ τ) := by ++ by_cases hu : u = 0 ++ · subst hu ++ have hr0 : r = 0 := by simpa [hur] using (norm_zero : ‖(0 : ℂ)‖ = 0) ++ subst hr0 ++ have h0 : 0 ≤ ((0 : ℝ) / ‖a‖) ^ τ := by ++ exact Real.rpow_nonneg (by positivity : (0 : ℝ) ≤ 0 / ‖a‖) τ ++ have h0' : 0 ≤ (2 : ℝ) * ((0 : ℝ) / ‖a‖) ^ τ := mul_nonneg (by norm_num) h0 ++ have hexp : (1 : ℝ) ≤ Real.exp ((2 : ℝ) * ((0 : ℝ) / ‖a‖) ^ τ) := ++ (Real.one_le_exp_iff).2 h0' ++ simpa using hexp ++ have hlogE := ++ log_norm_weierstrassFactor_ge_neg_two_pow (m := m) (z := (u / a)) hz ++ have hneglog : -Real.log ‖weierstrassFactor m (u / a)‖ ≤ (2 : ℝ) * (r / ‖a‖) ^ τ := by ++ have h1 : -Real.log ‖weierstrassFactor m (u / a)‖ ≤ (2 : ℝ) * ‖u / a‖ ^ (m + 1) := by ++ linarith [hlogE] ++ set x : ℝ := ‖u / a‖ ++ have hx1 : x ≤ 1 := le_trans (by simpa [x] using hz) (by norm_num) ++ have hxpos : 0 < x := by ++ simpa [x] using (norm_pos_iff.2 (div_ne_zero hu ha)) ++ have hτ_le' : τ ≤ ((m + 1 : ℕ) : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one] using hτ_le ++ have hpow_rpow : x ^ ((m + 1 : ℕ) : ℝ) ≤ x ^ τ := ++ Real.rpow_le_rpow_of_exponent_ge hxpos hx1 hτ_le' ++ have hpow : x ^ (m + 1) ≤ x ^ τ := by ++ simpa [← Real.rpow_natCast] using hpow_rpow ++ have h2x : (2 : ℝ) * x ^ (m + 1) ≤ (2 : ℝ) * x ^ τ := ++ mul_le_mul_of_nonneg_left hpow (by positivity) ++ have h2 : (2 : ℝ) * ‖u / a‖ ^ (m + 1) ≤ (2 : ℝ) * (‖u / a‖ : ℝ) ^ τ := by ++ simpa [x] using h2x ++ have h3 : (‖u‖ / ‖a‖) ^ τ = (r / ‖a‖) ^ τ := by ++ simp [hur] ++ exact (h1.trans h2).trans_eq (by simp [h3]) ++ have hpos : 0 < ‖weierstrassFactor m (u / a)‖ := by ++ have : weierstrassFactor m (u / a) ≠ 0 := by ++ intro h0 ++ have : u / a = (1 : ℂ) := (weierstrassFactor_eq_zero_iff m (u / a)).1 h0 ++ have : u = a := (div_eq_one_iff_eq ha).1 this ++ have : (‖u / a‖ : ℝ) = 1 := by simpa [this] using (by simp [ha]) ++ linarith [hz, this] ++ exact norm_pos_iff.2 this ++ have hEq : ++ ‖(weierstrassFactor m (u / a))⁻¹‖ = ++ Real.exp (-Real.log ‖weierstrassFactor m (u / a)‖) := by ++ simp [norm_inv, Real.exp_neg, Real.exp_log hpos] ++ have := Real.exp_le_exp.2 hneglog ++ simpa [hEq] using this ++ ++end Complex.Hadamard ++end ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/Counting.lean b/PrimeNumberTheoremAnd/SiegelZeros/Counting.lean +new file mode 100644 +index 0000000..cc47f9c +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/Counting.lean +@@ -0,0 +1,689 @@ ++import Mathlib ++ ++namespace SiegelZeros ++ ++open _root_.Real _root_.Function _root_.Function.locallyFinsuppWithin ++ ++section ++open Filter Function MeromorphicOn Metric Real Set ++ ++namespace Function.locallyFinsuppWithin ++ ++variable {E : Type*} [NormedAddCommGroup E] ++ ++lemma norm_le_abs_of_mem_toClosedBall_support {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} ++ (hz : z ∈ (toClosedBall r D).support) : ‖z‖ ≤ |r| := by ++ have hz_ball : z ∈ closedBall (0 : E) |r| := (toClosedBall r D).supportWithinDomain hz ++ simpa [mem_closedBall, dist_zero_right] using hz_ball ++ ++lemma toClosedBall_eval_eq_of_norm_le_abs {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} ++ (hz : ‖z‖ ≤ |r|) : toClosedBall r D z = D z := by ++ have hz_ball : z ∈ closedBall (0 : E) |r| := by ++ simpa [mem_closedBall, dist_zero_right] using hz ++ simpa using toClosedBall_eval_within (f := D) hz_ball ++ ++lemma mem_toClosedBall_support_of_mem_support_of_norm_le_abs ++ {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} (hzD : z ∈ D.support) (hzR : ‖z‖ ≤ |r|) : ++ z ∈ (toClosedBall r D).support := by ++ rw [Function.mem_support] ++ rw [toClosedBall_eval_eq_of_norm_le_abs hzR] ++ rwa [Function.mem_support] at hzD ++ ++lemma mem_support_of_mem_toClosedBall_support {D : locallyFinsupp E ℤ} {r : ℝ} {z : E} ++ (hz : z ∈ (toClosedBall r D).support) : z ∈ D.support := by ++ have hnorm : ‖z‖ ≤ |r| := norm_le_abs_of_mem_toClosedBall_support hz ++ rw [Function.mem_support] at hz ⊢ ++ rw [toClosedBall_eval_eq_of_norm_le_abs hnorm] at hz ++ exact hz ++ ++noncomputable def massClosedBall₀ {E : Type*} [NormedAddCommGroup E] [ProperSpace E] ++ (D : locallyFinsupp E ℤ) (R : ℝ) : ℝ := by ++ classical ++ exact ++ (((finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).toFinset).filter ++ (fun z => z ≠ (0 : E))).sum fun z => (D z : ℝ) ++ ++end Function.locallyFinsuppWithin ++ ++namespace Function.locallyFinsuppWithin ++ ++theorem logCounting_divisor_eq_circleAverage_sub_const_of_differentiable ++ {R : ℝ} {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hR : R ≠ 0) : ++ logCounting (divisor f ⊤) R = ++ circleAverage (log ‖f ·‖) 0 R - log ‖meromorphicTrailingCoeffAt f 0‖ := by ++ have hmero : Meromorphic f := fun z => (hf.analyticAt z).meromorphicAt ++ simpa [top_eq_univ] using ++ logCounting_divisor_eq_circleAverage_sub_const (f := f) hmero hR ++ ++end Function.locallyFinsuppWithin ++end ++section ++namespace Real ++ ++theorem log_one_add_exp_le_add_log_two {x : ℝ} (hx : 0 ≤ x) : ++ log (1 + exp x) ≤ x + log 2 := by ++ have hexp_one : (1 : ℝ) ≤ exp x := by ++ simpa using (one_le_exp_iff.2 hx) ++ have hadd : 1 + exp x ≤ 2 * exp x := by linarith ++ have hlog : log (1 + exp x) ≤ log (2 * exp x) := ++ log_le_log (by positivity) hadd ++ calc ++ log (1 + exp x) ≤ log (2 * exp x) := hlog ++ _ = log 2 + x := by simp [log_mul, add_comm] ++ _ = x + log 2 := by ring ++ ++theorem log_one_add_le_add_log_two_of_le_exp {x y : ℝ} (hy : 0 ≤ y) (hx : 0 ≤ x) ++ (hxy : y ≤ exp x) : ++ log (1 + y) ≤ x + log 2 := by ++ have hpos : 0 < (1 : ℝ) + y := by linarith ++ have hle : (1 : ℝ) + y ≤ 1 + exp x := by linarith ++ exact (log_le_log hpos hle).trans (log_one_add_exp_le_add_log_two hx) ++ ++theorem le_exp_of_log_one_add_le {x y : ℝ} (hy : 0 ≤ y) (hxy : log (1 + y) ≤ x) : ++ y ≤ exp x := by ++ have hpos : 0 < (1 : ℝ) + y := by linarith ++ have hone : 1 + y ≤ exp x := (log_le_iff_le_exp hpos).1 hxy ++ linarith ++ ++theorem neg_posLog_inv_le_log (x : ℝ) : -log⁺ x⁻¹ ≤ log x := by ++ linarith [posLog_sub_posLog_inv (x := x), posLog_nonneg (x := x)] ++ ++end Real ++end ++section ++namespace Real ++ ++variable {α E : Type*} [SeminormedAddCommGroup E] ++ ++theorem log_norm_le_log_one_add_norm (w : E) : ++ Real.log ‖w‖ ≤ Real.log (1 + ‖w‖) := by ++ by_cases h0 : ‖w‖ = 0 ++ · simp [h0] ++ · have hpos : 0 < ‖w‖ := lt_of_le_of_ne (norm_nonneg w) (Ne.symm h0) ++ exact Real.log_le_log hpos (by linarith [norm_nonneg w]) ++ ++variable {F : Type*} [NormedAddCommGroup F] ++ ++theorem log_nonneg_mul_inv_norm_of_norm_le {z : F} {r : ℝ} (hz : ‖z‖ ≤ r) : ++ 0 ≤ Real.log (r * ‖z‖⁻¹) := by ++ by_cases hz0 : z = 0 ++ · simp [hz0] ++ · have hzpos : 0 < ‖z‖ := norm_pos_iff.2 hz0 ++ have : (1 : ℝ) ≤ r * ‖z‖⁻¹ := by ++ have : (1 : ℝ) ≤ r / ‖z‖ := (one_le_div hzpos).2 hz ++ simpa [div_eq_mul_inv] using this ++ exact Real.log_nonneg this ++ ++theorem log_two_le_log_two_mul_mul_inv_norm_of_norm_le {z : F} {R : ℝ} (hz0 : z ≠ 0) ++ (hz : ‖z‖ ≤ R) : ++ Real.log 2 ≤ Real.log ((2 * R) * ‖z‖⁻¹) := by ++ have hzpos : 0 < ‖z‖ := norm_pos_iff.2 hz0 ++ have hRdiv : (1 : ℝ) ≤ R / ‖z‖ := (one_le_div hzpos).2 hz ++ have hle2 : (2 : ℝ) ≤ (2 * R) * ‖z‖⁻¹ := by ++ have : (2 : ℝ) ≤ 2 * (R / ‖z‖) := by nlinarith ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using this ++ exact Real.log_le_log (by norm_num) hle2 ++ ++theorem norm_le_exp_mul_rpow_of_exponent_le ++ {f : α → E} {r : α → ℝ} {C ρ τ : ℝ} (hC : 0 ≤ C) (hr : ∀ x, 1 ≤ r x) (hρτ : ρ ≤ τ) ++ (hbound : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ ρ)) : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ) := by ++ intro x ++ refine (hbound x).trans (Real.exp_le_exp.2 ?_) ++ exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le (hr x) hρτ) hC ++ ++theorem norm_le_exp_mul_rpow_of_log_growth ++ {f : α → E} {r : α → ℝ} {C ρ τ : ℝ} (hC : 0 ≤ C) (hr : ∀ x, 1 ≤ r x) (hρτ : ρ ≤ τ) ++ (hlog : ∀ x, Real.log (1 + ‖f x‖) ≤ C * (r x) ^ ρ) : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ) := by ++ intro x ++ have hpow : (r x) ^ ρ ≤ (r x) ^ τ := ++ Real.rpow_le_rpow_of_exponent_le (hr x) hρτ ++ have hlogτ : Real.log (1 + ‖f x‖) ≤ C * (r x) ^ τ := ++ (hlog x).trans (mul_le_mul_of_nonneg_left hpow hC) ++ exact Real.le_exp_of_log_one_add_le (norm_nonneg (f x)) hlogτ ++ ++theorem log_growth_of_norm_le_exp_mul_rpow ++ {f : α → E} {r : α → ℝ} {C τ : ℝ} (hC : 0 < C) (hτ : 0 ≤ τ) ++ (hr : ∀ x, 1 ≤ r x) (hbound : ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ)) : ++ ∃ C' > 0, ∀ x, Real.log (1 + ‖f x‖) ≤ C' * (r x) ^ τ := by ++ refine ⟨C + Real.log 2, by ++ have hlog2 : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) ++ linarith, ?_⟩ ++ intro x ++ have hX : (1 : ℝ) ≤ (r x) ^ τ := Real.one_le_rpow (hr x) hτ ++ have hB : 0 ≤ C * (r x) ^ τ := ++ mul_nonneg hC.le (Real.rpow_nonneg (le_trans zero_le_one (hr x)) _) ++ have hlog : ++ Real.log (1 + ‖f x‖) ≤ C * (r x) ^ τ + Real.log 2 := ++ Real.log_one_add_le_add_log_two_of_le_exp (norm_nonneg _) hB (hbound x) ++ have hlog2_nonneg : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) ++ nlinarith [hlog, hX, hlog2_nonneg] ++ ++theorem exists_norm_le_exp_mul_pow_of_rpow_bound ++ {f : α → E} {r : α → ℝ} {τ : ℝ} {n : ℕ} (hr : ∀ x, 1 ≤ r x) (hτn : τ < (n : ℝ)) ++ (hbound : ∃ C > 0, ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ τ)) : ++ ∃ C > 0, ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ n) := by ++ rcases hbound with ⟨C, hCpos, hC⟩ ++ have hweak : ++ ∀ x, ‖f x‖ ≤ Real.exp (C * (r x) ^ (n : ℝ)) := ++ norm_le_exp_mul_rpow_of_exponent_le ++ (f := f) (r := r) hCpos.le hr (le_of_lt hτn) hC ++ refine ⟨C, hCpos, ?_⟩ ++ intro x ++ have hpow : (r x) ^ (n : ℝ) = (r x) ^ n := Real.rpow_natCast (r x) n ++ simpa [hpow] using hweak x ++ ++theorem one_add_le_three_mul_one_add_of_le_two_mul_max {x r : ℝ} (hx : 0 ≤ x) ++ (hr : r ≤ 2 * max x 1) : 1 + r ≤ 3 * (1 + x) := by ++ have hmax : max x 1 ≤ 1 + x := max_le_iff.2 ⟨by linarith, by linarith⟩ ++ nlinarith ++ ++theorem exp_mul_rpow_le_exp_mul_rpow_of_le_mul ++ {A B x y τ : ℝ} (hA : 0 ≤ A) (hB : 0 ≤ B) (hx : 0 ≤ x) (hy : 0 ≤ y) ++ (hτ : 0 ≤ τ) (hxy : x ≤ B * y) : Real.exp (A * x ^ τ) ≤ Real.exp ((A * B ^ τ) * y ^ τ) := by ++ refine Real.exp_le_exp.2 ?_ ++ have hpow : x ^ τ ≤ (B * y) ^ τ := Real.rpow_le_rpow hx hxy hτ ++ have hsplit : (B * y) ^ τ = B ^ τ * y ^ τ := by ++ simpa using (Real.mul_rpow (x := B) (y := y) (z := τ) hB hy) ++ simpa [mul_assoc] using mul_le_mul_of_nonneg_left (hpow.trans_eq hsplit) hA ++ ++theorem exists_between_self_and_floor_add_one_same_floor {ρ : ℝ} (hρ : 0 ≤ ρ) : ++ ∃ τ : ℝ, ρ < τ ∧ τ < (Nat.floor ρ + 1 : ℝ) ∧ 0 ≤ τ ∧ Nat.floor τ = Nat.floor ρ := by ++ set m : ℕ := Nat.floor ρ ++ set τ : ℝ := (ρ + (m + 1 : ℝ)) / 2 ++ have hm : ρ < (m + 1 : ℝ) := by simpa [m] using Nat.lt_floor_add_one (a := ρ) ++ have hτ : ρ < τ := by dsimp [τ]; linarith ++ have hτ_lt : τ < (m + 1 : ℝ) := by dsimp [τ]; linarith ++ have hτ_nonneg : 0 ≤ τ := le_trans hρ (le_of_lt hτ) ++ have hfloorτ : Nat.floor τ = m := by ++ have hm_le_τ : (m : ℝ) ≤ τ := le_trans (Nat.floor_le hρ) (le_of_lt hτ) ++ have hτ_lt_m1 : τ < (m : ℝ) + 1 := by simpa [add_assoc, add_comm, add_left_comm] using hτ_lt ++ exact (Nat.floor_eq_iff hτ_nonneg).2 ⟨hm_le_τ, hτ_lt_m1⟩ ++ exact ⟨τ, hτ, by simpa [m] using hτ_lt, hτ_nonneg, by simpa [m] using hfloorτ⟩ ++ ++open Metric Complex ++ ++theorem log_norm_le_of_log_one_add_growth_on_sphere {f : ℂ → ℂ} {C ρ R : ℝ} ++ (hC : ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) {z : ℂ} ++ (hz : z ∈ sphere (0 : ℂ) |R|) : Real.log ‖f z‖ ≤ C * (1 + |R|) ^ ρ := by ++ have hz_norm : ‖z‖ = |R| := by ++ simpa [mem_sphere, dist_zero_right] using hz ++ simpa [hz_norm] using le_trans (log_norm_le_log_one_add_norm (f z)) (hC z) ++ ++end Real ++end ++section ++open Filter _root_.SiegelZeros.Function MeromorphicOn Metric Real Set ++ ++namespace Function.locallyFinsuppWithin ++ ++theorem logCounting_divisor_le_of_log_growth {f : ℂ → ℂ} {ρ C : ℝ} (hf : Differentiable ℂ f) ++ (hC : ∀ z : ℂ, log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) {R : ℝ} (hR0 : 0 < R) : ++ logCounting (divisor f (Set.univ : Set ℂ)) R ++ ≤ C * (1 + |R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ have hR : R ≠ 0 := ne_of_gt hR0 ++ have hEq := ++ logCounting_divisor_eq_circleAverage_sub_const_of_differentiable (f := f) hf hR ++ have hf_sphere : MeromorphicOn f (sphere (0 : ℂ) |R|) := by ++ intro z hz ++ exact (hf.analyticAt z).meromorphicAt ++ have hInt : CircleIntegrable (fun z : ℂ => log ‖f z‖) 0 R := ++ MeromorphicOn.circleIntegrable_log_norm hf_sphere ++ have hbound_circle : ∀ z ∈ sphere (0 : ℂ) |R|, ++ log ‖f z‖ ≤ C * (1 + |R|) ^ ρ := by ++ intro z hz ++ exact log_norm_le_of_log_one_add_growth_on_sphere hC hz ++ have hCircleAvg_le : ++ circleAverage (fun z : ℂ => log ‖f z‖) 0 R ≤ C * (1 + |R|) ^ ρ := ++ circleAverage_mono_on_of_le_circle (c := (0 : ℂ)) (R := R) ++ (f := fun z => log ‖f z‖) hInt hbound_circle ++ calc ++ logCounting (divisor f (Set.univ : Set ℂ)) R ++ = circleAverage (fun z : ℂ => log ‖f z‖) 0 R ++ - log ‖meromorphicTrailingCoeffAt f 0‖ := by ++ simpa [top_eq_univ] using hEq ++ _ ≤ circleAverage (fun z : ℂ => log ‖f z‖) 0 R ++ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ have : ++ -log ‖meromorphicTrailingCoeffAt f 0‖ ++ ≤ |log ‖meromorphicTrailingCoeffAt f 0‖| := ++ neg_le_abs (log ‖meromorphicTrailingCoeffAt f 0‖) ++ linarith ++ _ ≤ C * (1 + |R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ nlinarith [hCircleAvg_le] ++ ++variable {E : Type*} [NormedAddCommGroup E] [ProperSpace E] ++ ++theorem log_two_mul_massClosedBall₀_le_logCounting {D : locallyFinsupp E ℤ} (hDnonneg : 0 ≤ D) ++ {R : ℝ} (hR : 1 ≤ R) : ++ (log 2) * massClosedBall₀ D R ≤ logCounting D (2 * R) := by ++ classical ++ have hR0 : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR ++ set r : ℝ := 2 * R ++ have hrpos : 0 < r := by dsimp [r]; nlinarith ++ let Dr := toClosedBall r D ++ have hDr_fin : Set.Finite Dr.support := Dr.finiteSupport (isCompact_closedBall (0 : E) |r|) ++ let F : Finset E := hDr_fin.toFinset ++ let SR : Finset E := ++ (finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).toFinset ++ let S : Finset E := SR.filter fun z => z ≠ (0 : E) ++ have hS_sub : S ⊆ F := by ++ intro z hzS ++ have hz_mem_SR : z ∈ SR := (Finset.mem_filter.1 hzS).1 ++ have hzR : z ∈ (toClosedBall R D).support := by ++ exact (finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).mem_toFinset.1 ++ hz_mem_SR ++ have hz_norm_le_R : ‖z‖ ≤ R := by ++ have := norm_le_abs_of_mem_toClosedBall_support hzR ++ simpa [abs_of_pos hR0] using this ++ have hz_norm_le_r : ‖z‖ ≤ |r| := by ++ have : ‖z‖ ≤ r := le_trans hz_norm_le_R (by dsimp [r]; nlinarith) ++ simpa [abs_of_pos hrpos] using this ++ have hzD : z ∈ D.support := mem_support_of_mem_toClosedBall_support hzR ++ have : z ∈ Dr.support := by ++ simpa [Dr] using ++ mem_toClosedBall_support_of_mem_support_of_norm_le_abs (D := D) (r := r) hzD hz_norm_le_r ++ exact hDr_fin.mem_toFinset.2 this ++ have hlogCounting : ++ logCounting D r ++ = (F.sum fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) + (D 0 : ℝ) * log r := by ++ have hsupp : Function.support (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) ⊆ F := by ++ intro z hz ++ have : Dr z ≠ 0 := by ++ by_contra h0 ++ simp [Function.mem_support, h0] at hz ++ have : z ∈ Dr.support := by simpa [Function.mem_support] using this ++ exact hDr_fin.mem_toFinset.2 this ++ simp [logCounting, Dr, r, ++ finsum_eq_sum_of_support_subset (f := fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) (s := F) hsupp] ++ have hsum_le : ++ (log 2) * (S.sum fun z => (D z : ℝ)) ++ ≤ F.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := by ++ have hterm_nonneg : ∀ z ∈ F, 0 ≤ (Dr z : ℝ) * log (r * ‖z‖⁻¹) := by ++ intro z hzF ++ have hz_sup : z ∈ Dr.support := hDr_fin.mem_toFinset.1 hzF ++ have hDz : 0 ≤ Dr z := by ++ have hDz' : 0 ≤ D z := hDnonneg z ++ have hDrz : Dr z = D z := ++ toClosedBall_eval_eq_of_norm_le_abs (norm_le_abs_of_mem_toClosedBall_support hz_sup) ++ simpa [hDrz] using hDz' ++ have hlog : 0 ≤ log (r * ‖z‖⁻¹) := by ++ have hzle : ‖z‖ ≤ r := by ++ have hnorm := norm_le_abs_of_mem_toClosedBall_support hz_sup ++ simpa [abs_of_pos hrpos] using hnorm ++ exact log_nonneg_mul_inv_norm_of_norm_le hzle ++ exact mul_nonneg (by exact_mod_cast hDz) hlog ++ have hsumSF : ++ S.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) ++ ≤ F.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := ++ Finset.sum_le_sum_of_subset_of_nonneg hS_sub (by ++ intro z hzF _; exact hterm_nonneg z hzF) ++ have hterm_ge : ∀ z ∈ S, (log 2) * (D z : ℝ) ≤ (Dr z : ℝ) * log (r * ‖z‖⁻¹) := by ++ intro z hzS ++ have hz0 : z ≠ (0 : E) := (Finset.mem_filter.1 hzS).2 ++ have hz_norm_le_R : ‖z‖ ≤ R := by ++ have hz_mem_SR : z ∈ SR := (Finset.mem_filter.1 hzS).1 ++ have hzRsup : z ∈ (toClosedBall R D).support := by ++ exact (finiteSupport (toClosedBall R D) (isCompact_closedBall (0 : E) |R|)).mem_toFinset.1 ++ hz_mem_SR ++ have hnorm := norm_le_abs_of_mem_toClosedBall_support hzRsup ++ simpa [abs_of_pos hR0] using hnorm ++ have hlog_le : log 2 ≤ log (r * ‖z‖⁻¹) := by ++ simpa [r] using log_two_le_log_two_mul_mul_inv_norm_of_norm_le hz0 hz_norm_le_R ++ have hDz_nonneg : 0 ≤ D z := hDnonneg z ++ have hz_in_ballr : z ∈ closedBall (0 : E) |r| := by ++ have : ‖z‖ ≤ r := le_trans hz_norm_le_R (by dsimp [r]; nlinarith) ++ simpa [mem_closedBall, dist_zero_right, abs_of_pos hrpos] using this ++ have hDrz : Dr z = D z := by ++ have hz_norm_le : ‖z‖ ≤ |r| := by ++ simpa [mem_closedBall, dist_zero_right] using hz_in_ballr ++ simpa [Dr] using toClosedBall_eval_eq_of_norm_le_abs (D := D) (r := r) (z := z) hz_norm_le ++ have : (log 2) * (D z : ℝ) ≤ (log (r * ‖z‖⁻¹)) * (D z : ℝ) := ++ mul_le_mul_of_nonneg_right hlog_le (by exact_mod_cast hDz_nonneg) ++ simpa [hDrz, mul_assoc, mul_left_comm, mul_comm] using this ++ calc ++ (log 2) * (S.sum fun z => (D z : ℝ)) ++ = S.sum (fun z => (log 2) * (D z : ℝ)) := by simp [Finset.mul_sum] ++ _ ≤ S.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := ++ Finset.sum_le_sum fun z hz => hterm_ge z hz ++ _ ≤ F.sum (fun z => (Dr z : ℝ) * log (r * ‖z‖⁻¹)) := hsumSF ++ have hcenter_nonneg : 0 ≤ (D 0 : ℝ) * log r := by ++ have hD0 : 0 ≤ D 0 := hDnonneg 0 ++ have hlogr : 0 ≤ log r := log_nonneg (by nlinarith [hR]) ++ exact mul_nonneg (by exact_mod_cast hD0) hlogr ++ have : (log 2) * (S.sum fun z => (D z : ℝ)) ≤ logCounting D r := by ++ rw [hlogCounting] ++ nlinarith [hsum_le, hcenter_nonneg] ++ simpa [massClosedBall₀, r, S, SR] using this ++ ++theorem massClosedBall₀_divisor_le_of_log_growth {f : ℂ → ℂ} {ρ C : ℝ} ++ (hf : Differentiable ℂ f) ++ (hC : ∀ z : ℂ, log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) {R : ℝ} (hR : 1 ≤ R) : ++ massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R ++ ≤ (C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖|) / log 2 := by ++ have hR0 : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR ++ have hlog2pos : 0 < log 2 := log_pos (by norm_num : (1 : ℝ) < 2) ++ have hlow : ++ (log 2) * massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R ++ ≤ logCounting (divisor f (Set.univ : Set ℂ)) (2 * R) := ++ log_two_mul_massClosedBall₀_le_logCounting ++ (D := divisor f (Set.univ : Set ℂ)) ++ (MeromorphicOn.AnalyticOnNhd.divisor_nonneg ++ (hf.differentiableOn.analyticOnNhd isOpen_univ)) hR ++ have hupp : ++ logCounting (divisor f (Set.univ : Set ℂ)) (2 * R) ++ ≤ C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ have h2R0 : 0 < 2 * R := by nlinarith [hR0] ++ simpa using logCounting_divisor_le_of_log_growth (f := f) (ρ := ρ) (C := C) hf hC ++ (R := 2 * R) h2R0 ++ have hmul : ++ (log 2) * massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R ++ ≤ C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := ++ hlow.trans hupp ++ have hmul' : ++ massClosedBall₀ (divisor f (Set.univ : Set ℂ)) R * log 2 ++ ≤ C * (1 + |2 * R|) ^ ρ + |log ‖meromorphicTrailingCoeffAt f 0‖| := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using hmul ++ exact (le_div_iff₀ hlog2pos).2 hmul' ++ ++end Function.locallyFinsuppWithin ++end ++section ++open Set ++ ++variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] ++ ++theorem Differentiable.divisor_nonneg {f : ℂ → E} (hf : Differentiable ℂ f) : ++ 0 ≤ MeromorphicOn.divisor f (univ : Set ℂ) := ++ MeromorphicOn.AnalyticOnNhd.divisor_nonneg (hf.differentiableOn.analyticOnNhd isOpen_univ) ++end ++section ++noncomputable section ++ ++open scoped BigOperators ++open Filter ++ ++namespace Real ++ ++lemma two_pow_floor_logb_le {x : ℝ} (hx : 1 ≤ x) : ++ (2 : ℝ) ^ (⌊Real.logb 2 x⌋₊ : ℝ) ≤ x := by ++ have hx0 : 0 < x := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hx ++ have hlog_nonneg : 0 ≤ Real.logb 2 x := ++ Real.logb_nonneg (b := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) hx ++ have hfloor_le : (⌊Real.logb 2 x⌋₊ : ℝ) ≤ Real.logb 2 x := by ++ simpa using (Nat.floor_le hlog_nonneg) ++ exact (Real.le_logb_iff_rpow_le (b := (2 : ℝ)) ++ (x := (⌊Real.logb 2 x⌋₊ : ℝ)) (y := x) ++ (by norm_num : (1 : ℝ) < 2) hx0).1 hfloor_le ++ ++lemma lt_two_pow_floor_logb_add_one {x : ℝ} (hx : 1 ≤ x) : ++ x < (2 : ℝ) ^ ((⌊Real.logb 2 x⌋₊ : ℝ) + 1) := by ++ have hx0 : 0 < x := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hx ++ have hlt : Real.logb 2 x < (⌊Real.logb 2 x⌋₊ : ℝ) + 1 := by ++ simpa using (Nat.lt_floor_add_one (Real.logb 2 x)) ++ exact (Real.logb_lt_iff_lt_rpow (b := (2 : ℝ)) (x := x) ++ (y := (⌊Real.logb 2 x⌋₊ : ℝ) + 1) ++ (by norm_num : (1 : ℝ) < 2) hx0).1 hlt ++ ++lemma dyadicShell_lower_bound {r0 x : ℝ} {k : ℕ} (hr0 : 0 < r0) (hx : r0 ≤ x) ++ (hk : ⌊Real.logb 2 (x / r0)⌋₊ = k) : ++ r0 * (2 : ℝ) ^ (k : ℝ) ≤ x := by ++ have hr0ne : r0 ≠ 0 := ne_of_gt hr0 ++ have hx1 : (1 : ℝ) ≤ x / r0 := by ++ have : r0 / r0 ≤ x / r0 := div_le_div_of_nonneg_right hx hr0.le ++ simpa [hr0ne] using this ++ have hle : (2 : ℝ) ^ (k : ℝ) ≤ x / r0 := by ++ have := Real.two_pow_floor_logb_le (x := x / r0) hx1 ++ simpa [hk] using this ++ have := mul_le_mul_of_nonneg_left hle hr0.le ++ have hxEq : r0 * (x / r0) = x := by ++ field_simp [hr0ne] ++ simpa [mul_assoc, hxEq] using this ++ ++lemma dyadicShell_upper_bound {r0 x : ℝ} {k : ℕ} (hr0 : 0 < r0) (hx : r0 ≤ x) ++ (hk : ⌊Real.logb 2 (x / r0)⌋₊ = k) : ++ x ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1) := by ++ have hr0ne : r0 ≠ 0 := ne_of_gt hr0 ++ have hx1 : (1 : ℝ) ≤ x / r0 := by ++ have : r0 / r0 ≤ x / r0 := div_le_div_of_nonneg_right hx hr0.le ++ simpa [hr0ne] using this ++ have hlt : x / r0 < (2 : ℝ) ^ ((k : ℝ) + 1) := by ++ have := Real.lt_two_pow_floor_logb_add_one (x := x / r0) hx1 ++ simpa [hk] using this ++ have := mul_lt_mul_of_pos_left hlt hr0 ++ have hxEq : r0 * (x / r0) = x := by ++ field_simp [hr0ne] ++ exact le_of_lt (by simpa [mul_assoc, hxEq] using this) ++ ++lemma exists_nat_le_two_pow (A : ℝ) : ++ ∃ k0 : ℕ, ∀ n ≥ k0, A ≤ (2 : ℝ) ^ n := by ++ have htend : Tendsto (fun n : ℕ => (2 : ℝ) ^ n) atTop atTop := ++ tendsto_pow_atTop_atTop_of_one_lt (r := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) ++ exact eventually_atTop.1 ((tendsto_atTop.1 htend) A) ++ ++lemma one_le_dyadicRadius_succ_of_inv_le_two_pow ++ {r0 : ℝ} {k0 kk : ℕ} (hr0 : 0 < r0) ++ (hk0 : ∀ n ≥ k0, (1 / r0 : ℝ) ≤ (2 : ℝ) ^ n) (hkk : k0 ≤ kk + 1) : ++ (1 : ℝ) ≤ r0 * (2 : ℝ) ^ ((kk : ℝ) + 1) := by ++ have hr0ne : r0 ≠ 0 := ne_of_gt hr0 ++ have hpow_nat : (1 / r0 : ℝ) ≤ (2 : ℝ) ^ (kk + 1) := hk0 (kk + 1) hkk ++ have hpow_rpow : (1 / r0 : ℝ) ≤ (2 : ℝ) ^ ((kk : ℝ) + 1) := by ++ have hcast : (2 : ℝ) ^ ((kk : ℝ) + 1) = (2 : ℝ) ^ (kk + 1) := by ++ calc ++ (2 : ℝ) ^ ((kk : ℝ) + 1) = (2 : ℝ) ^ ((kk + 1 : ℕ) : ℝ) := by ++ simp [Nat.cast_add, Nat.cast_one] ++ _ = (2 : ℝ) ^ (kk + 1) := by ++ simpa using (Real.rpow_natCast (2 : ℝ) (kk + 1)) ++ simpa [hcast] using hpow_nat ++ have : (r0 * (1 / r0) : ℝ) ≤ r0 * (2 : ℝ) ^ ((kk : ℝ) + 1) := ++ mul_le_mul_of_nonneg_left hpow_rpow hr0.le ++ simpa [one_div, hr0ne, mul_assoc] using this ++ ++lemma one_add_abs_two_mul_dyadicRadius_rpow_le {r0 ρ : ℝ} (k : ℕ) ++ (hr0 : 0 < r0) (hρ : 0 ≤ ρ) : ++ (1 + |2 * (r0 * (2 : ℝ) ^ ((k : ℝ) + 1))|) ^ ρ ++ ≤ (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ ρ) ^ k := by ++ let Rk : ℝ := r0 * (2 : ℝ) ^ ((k : ℝ) + 1) ++ have hRk' : |2 * Rk| = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := by ++ have hnonneg : 0 ≤ (2 : ℝ) * Rk := by ++ have : 0 ≤ Rk := by ++ dsimp [Rk] ++ exact mul_nonneg hr0.le (le_of_lt (Real.rpow_pos_of_pos (by norm_num) _)) ++ nlinarith ++ have hmul : (2 : ℝ) * Rk = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := by ++ dsimp [Rk] ++ calc ++ (2 : ℝ) * (r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) ++ = (2 * r0) * (2 : ℝ) ^ ((k : ℝ) + 1) := by ring ++ _ = (2 * r0) * ((2 : ℝ) ^ (k : ℝ) * (2 : ℝ) ^ (1 : ℝ)) := by ++ simp [Real.rpow_add, mul_assoc] ++ _ = (2 * r0) * ((2 : ℝ) ^ (k : ℝ) * 2) := by simp [Real.rpow_one] ++ _ = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := by ring ++ calc ++ |2 * Rk| = 2 * Rk := abs_of_nonneg hnonneg ++ _ = 4 * r0 * (2 : ℝ) ^ (k : ℝ) := hmul ++ have hbase : ++ (1 + |2 * Rk|) ≤ (1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ) := by ++ have h1 : (1 : ℝ) ≤ (2 : ℝ) ^ (k : ℝ) := by ++ have : (1 : ℝ) ≤ (2 : ℝ) ^ (k : ℕ) := by ++ simpa using (one_le_pow₀ (by norm_num : (1 : ℝ) ≤ (2 : ℝ))) ++ simpa [Real.rpow_natCast] using this ++ have habs : ++ 1 + |2 * Rk| ≤ (2 : ℝ) ^ (k : ℝ) + (4 * r0) * (2 : ℝ) ^ (k : ℝ) := by ++ rw [hRk'] ++ simpa [add_assoc, add_left_comm, add_comm, mul_assoc, mul_left_comm, mul_comm] using ++ (add_le_add_right h1 ((4 * r0) * (2 : ℝ) ^ (k : ℝ))) ++ have hfac : ++ (2 : ℝ) ^ (k : ℝ) + (4 * r0) * (2 : ℝ) ^ (k : ℝ) ++ = (1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ) := by ++ ring ++ exact habs.trans (le_of_eq hfac) ++ have hRnonneg : 0 ≤ (1 + |2 * Rk|) := by linarith [abs_nonneg (2 * Rk)] ++ have : ++ (1 + |2 * Rk|) ^ ρ ≤ ((1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ)) ^ ρ := ++ Real.rpow_le_rpow hRnonneg hbase hρ ++ have hsplit : ++ ((1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ)) ^ ρ ++ = (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ (k : ℝ)) ^ ρ := by ++ have h1 : 0 ≤ (1 + 4 * r0) := by nlinarith [hr0.le] ++ have h2 : 0 ≤ (2 : ℝ) ^ (k : ℝ) := ++ le_of_lt (Real.rpow_pos_of_pos (by norm_num) _) ++ simpa using (Real.mul_rpow h1 h2 (z := ρ)) ++ have hpow : ((2 : ℝ) ^ (k : ℝ)) ^ ρ = ((2 : ℝ) ^ ρ) ^ k := by ++ have h2nonneg : (0 : ℝ) ≤ 2 := by norm_num ++ calc ++ ((2 : ℝ) ^ (k : ℝ)) ^ ρ = (2 : ℝ) ^ ((k : ℝ) * ρ) := by ++ simp [Real.rpow_mul] ++ _ = ((2 : ℝ) ^ ρ) ^ (k : ℝ) := by ++ simpa [mul_comm] using ++ (Real.rpow_mul (x := (2 : ℝ)) (y := ρ) (z := (k : ℝ)) h2nonneg) ++ _ = ((2 : ℝ) ^ ρ) ^ k := by ++ simp [Real.rpow_natCast] ++ calc ++ (1 + |2 * (r0 * (2 : ℝ) ^ ((k : ℝ) + 1))|) ^ ρ ++ = (1 + |2 * Rk|) ^ ρ := by rfl ++ _ ≤ ((1 + 4 * r0) * (2 : ℝ) ^ (k : ℝ)) ^ ρ := this ++ _ = (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ (k : ℝ)) ^ ρ := hsplit ++ _ = (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ ρ) ^ k := by ++ simpa [mul_assoc] using congrArg (fun t => (1 + 4 * r0) ^ ρ * t) hpow ++ ++lemma tsum_inv_rpow_le_card_mul_of_lower_bound {α : Type*} [Fintype α] {a : α → ℝ} ++ {R τ : ℝ} (hR : 0 < R) (hτ : 0 < τ) (ha_nonneg : ∀ x, 0 ≤ a x) ++ (ha_lower : ∀ x, R ≤ a x) : ++ (∑' x : α, (a x)⁻¹ ^ τ) ≤ (Fintype.card α : ℝ) * (R⁻¹ ^ τ) := by ++ have hsum_le : ++ (∑ x : α, (a x)⁻¹ ^ τ) ≤ ∑ _x : α, R⁻¹ ^ τ := by ++ refine Finset.sum_le_sum ?_ ++ intro x _hx ++ have hinv : (a x)⁻¹ ≤ R⁻¹ := by ++ simpa using (inv_anti₀ hR (ha_lower x)) ++ exact Real.rpow_le_rpow (inv_nonneg.2 (ha_nonneg x)) hinv hτ.le ++ simpa [tsum_fintype, Finset.sum_const, nsmul_eq_mul, mul_comm] using hsum_le ++ ++lemma inv_dyadicRadius_rpow_eq (r0 τ : ℝ) (k : ℕ) (hr0 : 0 ≤ r0) : ++ (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ = ++ (r0⁻¹ : ℝ) ^ τ * ((2 : ℝ) ^ (-τ)) ^ k := by ++ have h2k_nonneg : 0 ≤ (2 : ℝ) ^ (k : ℝ) := ++ le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _) ++ calc ++ (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ = ++ (r0 * (2 : ℝ) ^ (k : ℝ)) ^ (-τ) := by ++ simpa using (Real.rpow_neg_eq_inv_rpow (r0 * (2 : ℝ) ^ (k : ℝ)) τ).symm ++ _ = r0 ^ (-τ) * (((2 : ℝ) ^ (k : ℝ)) ^ (-τ)) := by ++ simpa using (Real.mul_rpow hr0 h2k_nonneg (z := -τ)) ++ _ = (r0⁻¹ : ℝ) ^ τ * ((2 : ℝ) ^ (-τ)) ^ k := by ++ have hr0' : r0 ^ (-τ) = (r0⁻¹ : ℝ) ^ τ := by ++ simp [Real.rpow_neg_eq_inv_rpow] ++ have h2' : ((2 : ℝ) ^ (k : ℝ)) ^ (-τ) = ((2 : ℝ) ^ (-τ)) ^ k := by ++ have h2nonneg : (0 : ℝ) ≤ (2 : ℝ) := by norm_num ++ calc ++ ((2 : ℝ) ^ (k : ℝ)) ^ (-τ) = (2 : ℝ) ^ ((k : ℝ) * (-τ)) := by ++ exact (Real.rpow_mul (x := (2 : ℝ)) (y := (k : ℝ)) (z := -τ) ++ h2nonneg).symm ++ _ = (2 : ℝ) ^ ((-τ) * (k : ℝ)) := by ring_nf ++ _ = ((2 : ℝ) ^ (-τ)) ^ (k : ℝ) := by ++ exact Real.rpow_mul (x := (2 : ℝ)) (y := -τ) (z := (k : ℝ)) h2nonneg ++ _ = ((2 : ℝ) ^ (-τ)) ^ k := by ++ simp [Real.rpow_natCast] ++ calc ++ r0 ^ (-τ) * (((2 : ℝ) ^ (k : ℝ)) ^ (-τ)) ++ = (r0⁻¹ : ℝ) ^ τ * (((2 : ℝ) ^ (k : ℝ)) ^ (-τ)) := by ++ rw [hr0'] ++ _ = (r0⁻¹ : ℝ) ^ τ * ((2 : ℝ) ^ (-τ)) ^ k := by ++ rw [h2'] ++ ++lemma two_rpow_sub_eq_mul_neg (ρ τ : ℝ) : ++ (2 : ℝ) ^ (ρ - τ) = (2 : ℝ) ^ ρ * (2 : ℝ) ^ (-τ) := by ++ have h2pos : (0 : ℝ) < (2 : ℝ) := by norm_num ++ calc ++ (2 : ℝ) ^ (ρ - τ) = (2 : ℝ) ^ (ρ + (-τ)) := by ring_nf ++ _ = (2 : ℝ) ^ ρ * (2 : ℝ) ^ (-τ) := by ++ simp [Real.rpow_add h2pos] ++ ++lemma two_rpow_sub_pow_eq_mul_pow (ρ τ : ℝ) (k : ℕ) : ++ ((2 : ℝ) ^ (ρ - τ)) ^ k = ++ ((2 : ℝ) ^ ρ) ^ k * (((2 : ℝ) ^ (-τ)) ^ k) := by ++ simp [two_rpow_sub_eq_mul_neg, mul_pow] ++ ++lemma dyadic_growth_inv_term_eq (C L M r0 ρ τ : ℝ) (k : ℕ) (hr0 : 0 ≤ r0) : ++ ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ = (((C / L) * M) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (ρ - τ)) ^ k := by ++ have hrk_inv : ++ (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ = ++ (r0⁻¹ : ℝ) ^ τ * (((2 : ℝ) ^ (-τ)) ^ k) := ++ inv_dyadicRadius_rpow_eq r0 τ k hr0 ++ rw [hrk_inv, two_rpow_sub_pow_eq_mul_pow] ++ ac_rfl ++ ++lemma dyadic_trailing_inv_term_le (C L r0 τ : ℝ) (k : ℕ) (hr0 : 0 ≤ r0) : ++ (C / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ ≤ (((C / L) + 1) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (-τ)) ^ k := by ++ rw [inv_dyadicRadius_rpow_eq r0 τ k hr0] ++ have hcoeff : C / L ≤ C / L + 1 := by linarith ++ have hr0Inv_nonneg : 0 ≤ (r0⁻¹ : ℝ) ^ τ := ++ Real.rpow_nonneg (inv_nonneg.2 hr0) _ ++ have hmul : ++ (C / L) * ((r0⁻¹ : ℝ) ^ τ) ++ ≤ ((C / L) + 1) * ((r0⁻¹ : ℝ) ^ τ) := ++ mul_le_mul_of_nonneg_right hcoeff hr0Inv_nonneg ++ have hqpow_nonneg : 0 ≤ ((2 : ℝ) ^ (-τ)) ^ k := ++ pow_nonneg (le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _)) _ ++ have := mul_le_mul_of_nonneg_right hmul hqpow_nonneg ++ simpa [mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma dyadic_growth_mass_mul_inv_le_geometric {C L M X T Ctrail r0 ρ τ : ℝ} {k : ℕ} ++ (hL : 0 < L) (hC : 0 ≤ C) (hr0 : 0 ≤ r0) ++ (hX : X ≤ M * ((2 : ℝ) ^ ρ) ^ k) ++ (hT : T ≤ ((C * X + Ctrail) / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ)) : ++ T ≤ (((C / L) * M) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (ρ - τ)) ^ k ++ + (((Ctrail / L) + 1) * (r0⁻¹ : ℝ) ^ τ) * ((2 : ℝ) ^ (-τ)) ^ k := by ++ have hmul : C * X ≤ C * (M * ((2 : ℝ) ^ ρ) ^ k) := ++ mul_le_mul_of_nonneg_left hX hC ++ have hnum : C * X + Ctrail ≤ C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail := ++ add_le_add hmul le_rfl ++ have hdiv : ++ (C * X + Ctrail) / L ≤ (C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail) / L := ++ div_le_div_of_nonneg_right hnum hL.le ++ have h2k_nonneg : 0 ≤ (2 : ℝ) ^ (k : ℝ) := ++ le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) (k : ℝ)) ++ have hrk_nonneg : 0 ≤ r0 * (2 : ℝ) ^ (k : ℝ) := ++ mul_nonneg hr0 h2k_nonneg ++ have hfactor_nonneg : 0 ≤ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) := ++ Real.rpow_nonneg (inv_nonneg.2 hrk_nonneg) τ ++ have hmul' := ++ mul_le_mul_of_nonneg_right hdiv hfactor_nonneg ++ have hdecomp : ++ ((C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail) / L) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ = ++ ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ + ((Ctrail / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ)) := by ++ let Y : ℝ := (r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ ++ have : ++ ((C * (M * ((2 : ℝ) ^ ρ) ^ k) + Ctrail) / L) * Y ++ = ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * Y ++ + ((Ctrail / L) * Y) := by ++ ring ++ simpa [Y] ++ have hpre : ++ T ≤ ((C / L) * (M * ((2 : ℝ) ^ ρ) ^ k)) * ++ ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ) ++ + ((Ctrail / L) * ((r0 * (2 : ℝ) ^ (k : ℝ))⁻¹ ^ τ)) := ++ hT.trans (hmul'.trans_eq hdecomp) ++ have hA := le_of_eq (dyadic_growth_inv_term_eq C L M r0 ρ τ k hr0) ++ have hB := dyadic_trailing_inv_term_le Ctrail L r0 τ k hr0 ++ exact hpre.trans (by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using add_le_add hA hB) ++ ++lemma two_geometric_shift_add (A B q qσ : ℝ) (k k0 : ℕ) : ++ A * q ^ (k + k0) + B * qσ ^ (k + k0) ++ = (A * q ^ k0) * q ^ k + (B * qσ ^ k0) * qσ ^ k := by ++ rw [pow_add, pow_add] ++ ac_rfl ++ ++end Real ++end ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/DivisorBasics.lean b/PrimeNumberTheoremAnd/SiegelZeros/DivisorBasics.lean +new file mode 100644 +index 0000000..e5a553a +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/DivisorBasics.lean +@@ -0,0 +1,590 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.Products ++ ++namespace SiegelZeros ++ ++section ++open Filter Topology Set ++ ++namespace MeromorphicOn ++ ++variable {𝕜 : Type*} [NontriviallyNormedField 𝕜] {U K : Set 𝕜} {z : 𝕜} ++ {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] ++ ++lemma divisor_support_inter_compact_finite (f : 𝕜 → E) {U K : Set 𝕜} ++ (hK : IsCompact K) (hKU : K ⊆ U) : ++ (K ∩ (MeromorphicOn.divisor f U).support).Finite := by ++ classical ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have hloc : ++ ∀ x ∈ K, ∃ V : Set 𝕜, V ∈ 𝓝 x ∧ Set.Finite (V ∩ D.support) := by ++ intro x hxK ++ rcases D.supportLocallyFiniteWithinDomain x (hKU hxK) with ⟨V, hV, hfin⟩ ++ exact ⟨V, hV, hfin⟩ ++ choose V hVnhds hVfin using hloc ++ rcases hK.elim_nhds_subcover' (U := fun x hx => V x hx) (hU := fun x hx => hVnhds x hx) with ++ ⟨t, ht⟩ ++ have hsub : ++ K ∩ D.support ⊆ ⋃ x ∈ t, (V (x : 𝕜) x.2 ∩ D.support) := by ++ intro y hy ++ rcases hy with ⟨hyK, hyS⟩ ++ have hycov : y ∈ ⋃ x ∈ t, V (x : 𝕜) x.2 := ht hyK ++ rcases Set.mem_iUnion.1 hycov with ⟨x, hycov'⟩ ++ rcases Set.mem_iUnion.1 hycov' with ⟨hxT, hyV⟩ ++ refine Set.mem_iUnion.2 ⟨x, Set.mem_iUnion.2 ?_⟩ ++ exact ⟨hxT, ⟨hyV, hyS⟩⟩ ++ have hfinU : Set.Finite (⋃ x ∈ t, (V (x : 𝕜) x.2 ∩ D.support)) := by ++ classical ++ refine (t.finite_toSet).biUnion ?_ ++ intro x hx ++ simpa using (hVfin (x : 𝕜) x.2) ++ exact hfinU.subset hsub ++ ++end MeromorphicOn ++end ++section ++open Set ++ ++namespace Complex.Hadamard ++ ++def divisorZeroIndex (f : ℂ → ℂ) (U : Set ℂ) : Type := ++ Σ z : ℂ, Fin (Int.toNat (MeromorphicOn.divisor f U z)) ++ ++abbrev divisorZeroIndex₀ (f : ℂ → ℂ) (U : Set ℂ) : Type := ++ {p : divisorZeroIndex f U // p.1 ≠ 0} ++ ++abbrev divisorZeroIndex₀Val {f : ℂ → ℂ} {U : Set ℂ} (p : divisorZeroIndex₀ f U) : ℂ := ++ p.1.1 ++ ++@[simp] ++lemma divisorZeroIndex₀Val_ne_zero {f : ℂ → ℂ} {U : Set ℂ} (p : divisorZeroIndex₀ f U) : ++ divisorZeroIndex₀Val p ≠ 0 := p.2 ++ ++@[simp] ++lemma divisorZeroIndex₀Val_mem_divisor_support {f : ℂ → ℂ} {U : Set ℂ} ++ (p : divisorZeroIndex₀ f U) : ++ MeromorphicOn.divisor f U (divisorZeroIndex₀Val p) ≠ 0 := by ++ have hn : ++ Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p)) ≠ 0 := by ++ intro h0 ++ have q0 : Fin 0 := by ++ simpa [divisorZeroIndex₀Val, h0] using p.1.2 ++ exact Fin.elim0 q0 ++ intro hdiv ++ have : Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p)) = 0 := by ++ simp [hdiv] ++ exact hn this ++ ++noncomputable def divisorCanonicalProduct (m : ℕ) (f : ℂ → ℂ) (U : Set ℂ) (z : ℂ) : ℂ := ++ ∏' p : divisorZeroIndex₀ f U, weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ ++@[simp] ++lemma divisorCanonicalProduct_zero (m : ℕ) (f : ℂ → ℂ) (U : Set ℂ) : ++ divisorCanonicalProduct m f U 0 = 1 := by ++ simp [divisorCanonicalProduct] ++ ++end Complex.Hadamard ++end ++section ++namespace Complex ++ ++section UniformMul ++ ++theorem _root_.SiegelZeros.TendstoUniformlyOn.mul_left_bounded {ι : Type*} {p : Filter ι} {K : Set ℂ} ++ {F : ι → ℂ → ℂ} {f : ℂ → ℂ} {h : ℂ → ℂ} ++ (hF : TendstoUniformlyOn F f p K) (hh : ∃ C, ∀ z ∈ K, ‖h z‖ ≤ C) : ++ TendstoUniformlyOn (fun n z => h z * F n z) (fun z => h z * f z) p K := by ++ intro u hu ++ rcases Metric.mem_uniformity_dist.1 hu with ⟨ε, hεpos, hεu⟩ ++ rcases hh with ⟨C, hC⟩ ++ set C' : ℝ := max C 1 ++ have hC'pos : 0 < C' := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hC' : ∀ z ∈ K, ‖h z‖ ≤ C' := fun z hz => le_trans (hC z hz) (le_max_left _ _) ++ have hv : {p : ℂ × ℂ | dist p.1 p.2 < ε / C'} ∈ uniformity ℂ := ++ Metric.mem_uniformity_dist.2 ⟨ε / C', div_pos hεpos hC'pos, fun _ _ hab => hab⟩ ++ have hF' : ∀ᶠ n in p, ∀ z : ℂ, z ∈ K → dist (f z) (F n z) < ε / C' := hF _ hv ++ filter_upwards [hF'] with n hn z hzK ++ have hn' : ‖f z - F n z‖ < ε / C' := by simpa [dist_eq_norm] using hn z hzK ++ have hle : ‖h z‖ * ‖f z - F n z‖ ≤ C' * ‖f z - F n z‖ := ++ mul_le_mul_of_nonneg_right (hC' z hzK) (norm_nonneg _) ++ have hlt : C' * ‖f z - F n z‖ < C' * (ε / C') := mul_lt_mul_of_pos_left hn' hC'pos ++ have hnorm : ++ ‖h z * f z - h z * F n z‖ = ‖h z‖ * ‖f z - F n z‖ := by ++ calc ++ ‖h z * f z - h z * F n z‖ = ‖h z * (f z - F n z)‖ := by simp [mul_sub] ++ _ = ‖h z‖ * ‖f z - F n z‖ := by simp ++ have hdist : dist (h z * f z) (h z * F n z) < ε := by ++ rw [dist_eq_norm, hnorm] ++ have hlt' : ‖h z‖ * ‖f z - F n z‖ < ε := by ++ calc ++ ‖h z‖ * ‖f z - F n z‖ ≤ C' * ‖f z - F n z‖ := hle ++ _ < C' * (ε / C') := hlt ++ _ = ε := by field_simp [hC'pos.ne'] ++ exact hlt' ++ exact hεu hdist ++ ++end UniformMul ++ ++end Complex ++end ++section ++open Filter Function _root_.SiegelZeros.Complex _root_.Function.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++lemma finite_divisorZeroIndex₀_subtype_norm_le {f : ℂ → ℂ} {U : Set ℂ} (B : ℝ) ++ (hBU : Metric.closedBall (0 : ℂ) B ⊆ U) : ++ Finite {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ B} := by ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have hK : IsCompact (Metric.closedBall (0 : ℂ) B) := isCompact_closedBall _ _ ++ have hpts0 : ((Metric.closedBall (0 : ℂ) B) ∩ D.support).Finite := ++ MeromorphicOn.divisor_support_inter_compact_finite (f := f) (U := U) ++ (K := Metric.closedBall (0 : ℂ) B) hK hBU ++ set pts : Set ℂ := ((Metric.closedBall (0 : ℂ) B) ∩ D.support) \ {0} ++ have hpts : pts.Finite := hpts0.sdiff ++ let : Fintype pts := hpts.fintype ++ let T : Type := Σ z : pts, Fin (Int.toNat (D z.1)) ++ have : Finite T := by infer_instance ++ let F : ++ {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ B} → T := fun p => ++ ⟨⟨divisorZeroIndex₀Val p.1, by ++ have hball : divisorZeroIndex₀Val p.1 ∈ Metric.closedBall (0 : ℂ) B := by ++ simpa [Metric.mem_closedBall, dist_zero_right] using p.2 ++ have hsupport : divisorZeroIndex₀Val p.1 ∈ D.support := by ++ have hne_toNat : ++ Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p.1)) ≠ 0 := by ++ intro h0 ++ have hpfin : ++ Fin (Int.toNat (MeromorphicOn.divisor f U (divisorZeroIndex₀Val p.1))) := by ++ simpa [D] using p.1.1.2 ++ have : Fin 0 := by simpa [h0] using hpfin ++ exact Fin.elim0 this ++ have hne_D : D (divisorZeroIndex₀Val p.1) ≠ 0 := by ++ intro hD0 ++ apply hne_toNat ++ simp [D, hD0] ++ simp [D, Function.locallyFinsuppWithin.support, Function.support] ++ have hne0 : divisorZeroIndex₀Val p.1 ≠ 0 := divisorZeroIndex₀Val_ne_zero p.1 ++ exact ⟨⟨hball, hsupport⟩, by simp [Set.mem_singleton_iff]⟩⟩, ++ p.1.1.2⟩ ++ refine Finite.of_injective F ?_ ++ intro p q hpq ++ apply Subtype.ext ++ apply Subtype.ext ++ have h' := (Sigma.mk.inj_iff.1 hpq) ++ have hz : divisorZeroIndex₀Val p.1 = divisorZeroIndex₀Val q.1 := congrArg Subtype.val h'.1 ++ apply (Sigma.mk.inj_iff).2 ++ refine ⟨hz, ?_⟩ ++ exact h'.2 ++ ++lemma divisorZeroIndex₀_norm_le_finite {f : ℂ → ℂ} {U : Set ℂ} (B : ℝ) ++ (hBU : Metric.closedBall (0 : ℂ) B ⊆ U) : ++ ({p : divisorZeroIndex₀ f U | ‖divisorZeroIndex₀Val p‖ ≤ B} : Set _).Finite := by ++ let s : Set (divisorZeroIndex₀ f U) := {p | ‖divisorZeroIndex₀Val p‖ ≤ B} ++ have : Finite (↥s) := ++ finite_divisorZeroIndex₀_subtype_norm_le (f := f) (U := U) B hBU ++ exact Set.toFinite s ++ ++lemma norm_div_le_half_of_norm_le_of_two_mul_lt {z a : ℂ} {R : ℝ} ++ (hR : 0 < R) (hz : ‖z‖ ≤ R) (ha : (2 * R : ℝ) < ‖a‖) : ++ ‖z / a‖ ≤ (1 / 2 : ℝ) := by ++ have h2R_pos : 0 < (2 * R : ℝ) := by nlinarith [hR] ++ have hinv : ‖a‖⁻¹ < (2 * R)⁻¹ := by ++ simpa [one_div] using one_div_lt_one_div_of_lt h2R_pos ha ++ have hmul_le : ‖z‖ * ‖a‖⁻¹ ≤ R * ‖a‖⁻¹ := ++ mul_le_mul_of_nonneg_right hz (inv_nonneg.2 (norm_nonneg a)) ++ have hmul_lt : R * ‖a‖⁻¹ < R * (2 * R)⁻¹ := ++ mul_lt_mul_of_pos_left hinv hR ++ have hRhalf : R * (2 * R)⁻¹ = (1 / 2 : ℝ) := by ++ have hRne : (R : ℝ) ≠ 0 := hR.ne' ++ rw [show R * (2 * R)⁻¹ = R / (2 * R) by simp [div_eq_mul_inv]] ++ field_simp [hRne] ++ have hnorm : ‖z / a‖ = ‖z‖ * ‖a‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ exact le_of_lt <| by ++ calc ++ ‖z / a‖ = ‖z‖ * ‖a‖⁻¹ := hnorm ++ _ ≤ R * ‖a‖⁻¹ := hmul_le ++ _ < R * (2 * R)⁻¹ := hmul_lt ++ _ = (1 / 2 : ℝ) := hRhalf ++ ++theorem summable_logDerivTerms_divisorZeroIndex₀_of_summable_inv_sq ++ {f : ℂ → ℂ} {z : ℂ} ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ))) ++ (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ 1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := by ++ let R : ℝ := max ‖z‖ 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hzle : ‖z‖ ≤ R := le_max_left _ _ ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (2 * R) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ)) ++ have hu : Summable u := h_sum.mul_left (2 * R) ++ refine hu.of_norm_bounded_eventually ?_ ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ++ 2 * R} : Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite ++ (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ filter_upwards [h_big] with p hp ++ let a : ℂ := divisorZeroIndex₀Val p ++ have ha0 : a ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ have hza0 : z - a ≠ 0 := sub_ne_zero.mpr (hz p) ++ have hterm : 1 / (z - a) + 1 / a = z / (a * (z - a)) := by ++ field_simp [ha0, hza0] ++ ring ++ have htri : ‖a‖ ≤ ‖z‖ + ‖z - a‖ := by ++ have hraw : ‖a‖ ≤ ‖z‖ + ‖a - z‖ := by ++ have h := norm_add_le z (a - z) ++ simpa [a, sub_eq_add_neg, add_assoc, add_left_comm, add_comm] using h ++ simpa [norm_sub_rev] using hraw ++ have hza_lower : ‖a‖ / 2 ≤ ‖z - a‖ := by ++ nlinarith [htri, hzle, hp] ++ have hnorm : ‖1 / (z - a) + 1 / a‖ ≤ (2 * R) * (‖a‖⁻¹ ^ (2 : ℕ)) := by ++ rw [hterm, norm_div, norm_mul] ++ have ha_norm_pos : 0 < ‖a‖ := norm_pos_iff.mpr ha0 ++ have hza_norm_pos : 0 < ‖z - a‖ := norm_pos_iff.mpr hza0 ++ rw [div_eq_mul_inv] ++ calc ++ ‖z‖ * (‖a‖ * ‖z - a‖)⁻¹ ++ = ‖z‖ * ‖a‖⁻¹ * ‖z - a‖⁻¹ := by ++ field_simp [ha_norm_pos.ne', hza_norm_pos.ne'] ++ _ ≤ R * ‖a‖⁻¹ * ‖z - a‖⁻¹ := by ++ gcongr ++ _ ≤ R * ‖a‖⁻¹ * (2 * ‖a‖⁻¹) := by ++ gcongr ++ have hhalf_pos : 0 < ‖a‖ / 2 := by positivity ++ have hinv : ‖z - a‖⁻¹ ≤ (‖a‖ / 2)⁻¹ := by ++ simpa [one_div] using one_div_le_one_div_of_le hhalf_pos hza_lower ++ have hhalf_inv : (‖a‖ / 2)⁻¹ = 2 * ‖a‖⁻¹ := by field_simp [ha_norm_pos.ne'] ++ simpa [hhalf_inv] using hinv ++ _ = (2 * R) * (‖a‖⁻¹ ^ (2 : ℕ)) := by ring ++ simpa [u, a] using hnorm ++ ++theorem hasProdUniformlyOn_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) {K : Set ℂ} (hK : IsCompact K) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) K := by ++ rcases (isBounded_iff_forall_norm_le.1 hK.isBounded) with ⟨R0, hR0⟩ ++ set R : ℝ := max R0 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hnormK : ∀ z ∈ K, ‖z‖ ≤ R := fun z hzK => le_trans (hR0 z hzK) (le_max_left _ _) ++ let g : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1 ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (4 * R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) ++ have hu : Summable u := h_sum.mul_left (4 * R ^ (m + 1)) ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ 2 * R} : ++ Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ have hBound : ++ ∀ᶠ p in Filter.cofinite, ∀ z ∈ K, ‖g p z‖ ≤ u p := by ++ filter_upwards [h_big] with p hp z hzK ++ have hzle : ‖z‖ ≤ R := hnormK z hzK ++ have hz_div : ‖z / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := by ++ exact norm_div_le_half_of_norm_le_of_two_mul_lt hRpos hzle hp ++ have hE : ++ ‖weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1‖ ≤ ++ 4 * ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) := ++ weierstrassFactor_sub_one_pow_bound (m := m) (z := z / divisorZeroIndex₀Val p) hz_div ++ have hz_pow : ++ ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) ≤ ++ (R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ have : ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ rw [this] ++ have : (‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹) ^ (m + 1) = ++ ‖z‖ ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simp [mul_pow] ++ rw [this] ++ have hzle_pow : ‖z‖ ^ (m + 1) ≤ R ^ (m + 1) := ++ pow_le_pow_left₀ (norm_nonneg z) hzle (m + 1) ++ gcongr ++ dsimp [g, u] ++ nlinarith [hE, hz_pow] ++ have hcts : ∀ p, ContinuousOn (g p) K := by ++ intro p ++ have hcontE : Continuous (fun z : ℂ => weierstrassFactor m z) := ++ (differentiable_weierstrassFactor m).continuous ++ have hdiv : Continuous fun z : ℂ => z / divisorZeroIndex₀Val p := by ++ simpa [div_eq_mul_inv] using! (continuous_id.mul continuous_const) ++ have hcont : Continuous fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) := ++ hcontE.comp hdiv ++ simpa only [g] using hcont.continuousOn.fun_sub continuous_const.continuousOn ++ have hprod : ++ HasProdUniformlyOn (fun p z ↦ 1 + g p z) (fun z ↦ ∏' p, (1 + g p z)) K := by ++ simpa using ++ Summable.hasProdUniformlyOn_one_add (f := g) (u := u) (K := K) hK hu hBound hcts ++ simpa [g, divisorCanonicalProduct, sub_eq_add_neg, add_assoc, add_left_comm, add_comm] ++ using! hprod ++ ++theorem hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (Set.univ : Set ℂ) := by ++ refine hasProdLocallyUniformlyOn_of_forall_compact ++ (f := fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (g := divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (s := (Set.univ : Set ℂ)) isOpen_univ ?_ ++ intro K hKU hK ++ simpa using ++ (hasProdUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) (K := K) hK h_sum) ++ ++theorem differentiableOn_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ DifferentiableOn ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) (Set.univ : Set ℂ) := by ++ have hloc : ++ TendstoLocallyUniformlyOn ++ (fun (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) => ++ ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop (Set.univ : Set ℂ) := by ++ simpa [HasProdLocallyUniformlyOn] using ++ (hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum) ++ have hF : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in Filter.atTop, ++ DifferentiableOn ℂ ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (Set.univ : Set ℂ) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro s ++ have hdiff : ++ Differentiable ℂ ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) := by ++ let F : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hF' : ∀ p ∈ s, Differentiable ℂ (F p) := by ++ intro p hp ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / divisorZeroIndex₀Val p) := by ++ have : Differentiable ℂ (fun z : ℂ => z * ((divisorZeroIndex₀Val p)⁻¹)) := ++ (differentiable_id : Differentiable ℂ (fun z : ℂ => z)).mul_const ++ ((divisorZeroIndex₀Val p)⁻¹) ++ simp [div_eq_mul_inv] ++ exact (differentiable_weierstrassFactor m).comp hdiv ++ simpa [F] using (Differentiable.fun_finsetProd (𝕜 := ℂ) (f := F) (u := s) hF') ++ simpa using hdiff.differentiableOn ++ have : (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))).NeBot := ++ Filter.atTop_neBot ++ exact hloc.differentiableOn hF isOpen_univ ++ ++theorem differentiableAt_divisorCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) (z : ℂ) : ++ DifferentiableAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := ++ ((differentiableOn_divisorCanonicalProduct_univ m f h_sum) z (by simp)).differentiableAt ++ (by simp) ++ ++theorem logDeriv_divisorCanonicalProduct_one_eq_tsum ++ {f : ℂ → ℂ} {z : ℂ} ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ))) ++ (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) ++ (hprod_ne : divisorCanonicalProduct 1 f (Set.univ : Set ℂ) z ≠ 0) : ++ logDeriv (divisorCanonicalProduct 1 f (Set.univ : Set ℂ)) z = ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p w => weierstrassFactor 1 (w / divisorZeroIndex₀Val p) ++ have hf : ∀ p, Φ p z ≠ 0 := by ++ intro p ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ refine weierstrassFactor_ne_zero_of_ne_one 1 ?_ ++ intro h ++ exact hz p ((div_eq_one_iff_eq hp0).1 h) ++ have hd : ∀ p, DifferentiableOn ℂ (Φ p) (Set.univ : Set ℂ) := by ++ intro p ++ have hdiv : Differentiable ℂ (fun w : ℂ => w / divisorZeroIndex₀Val p) := by ++ have : Differentiable ℂ (fun w : ℂ => w * ((divisorZeroIndex₀Val p)⁻¹)) := ++ (differentiable_id : Differentiable ℂ (fun w : ℂ => w)).mul_const ++ ((divisorZeroIndex₀Val p)⁻¹) ++ simp [div_eq_mul_inv] ++ exact ((differentiable_weierstrassFactor 1).comp hdiv).differentiableOn ++ have hm' : Summable fun p => logDeriv (Φ p) z := by ++ have hm : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ 1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := ++ summable_logDerivTerms_divisorZeroIndex₀_of_summable_inv_sq h_sum hz ++ refine hm.congr ?_ ++ intro p ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ simpa [Φ] using ++ (Complex.logDeriv_weierstrassFactor_one_div ++ (a := divisorZeroIndex₀Val p) (z := z) hp0 (hz p)).symm ++ have htend : MultipliableLocallyUniformlyOn Φ (Set.univ : Set ℂ) := by ++ have hprod := hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ ++ (m := 1) (f := f) h_sum ++ simpa [Φ, divisorCanonicalProduct] using hprod.multipliableLocallyUniformlyOn ++ have hnez : (∏' p, Φ p z) ≠ 0 := by ++ simpa [Φ, divisorCanonicalProduct] using hprod_ne ++ have hlog : logDeriv (∏' p, Φ p ·) z = ∑' p, logDeriv (Φ p) z := ++ logDeriv_tprod_eq_tsum (s := (Set.univ : Set ℂ)) isOpen_univ (by simp) ++ hf hd hm' htend hnez ++ calc ++ logDeriv (divisorCanonicalProduct 1 f (Set.univ : Set ℂ)) z ++ = ∑' p, logDeriv (Φ p) z := by ++ simpa [Φ, divisorCanonicalProduct] using! hlog ++ _ = ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := by ++ refine tsum_congr fun p => ?_ ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ simpa [Φ] using ++ Complex.logDeriv_weierstrassFactor_one_div ++ (a := divisorZeroIndex₀Val p) (z := z) hp0 (hz p) ++ ++end Complex.Hadamard ++end ++section ++noncomputable section ++ ++open Set ++open scoped Topology BigOperators ++ ++namespace Complex.Hadamard ++ ++lemma divisor_univ_eq_analyticOrderNatAt_int {f : ℂ → ℂ} (hf : Differentiable ℂ f) (z : ℂ) : ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) z = (analyticOrderNatAt f z : ℤ) := by ++ have hmero : MeromorphicOn f (Set.univ : Set ℂ) := by ++ intro w hw ++ exact (Differentiable.analyticAt (f := f) hf w).meromorphicAt ++ simp only ++ [MeromorphicOn.divisor_apply hmero (by simp : z ∈ (Set.univ : Set ℂ)), analyticOrderNatAt] ++ have han : AnalyticAt ℂ f z := Differentiable.analyticAt (f := f) hf z ++ cases h : analyticOrderAt f z with ++ | top => ++ simp [han.meromorphicOrderAt_eq, h] ++ | coe n => ++ simp [han.meromorphicOrderAt_eq, h] ++ ++theorem divisorZeroIndex₀_fiber_finite (f : ℂ → ℂ) (z₀ : ℂ) : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | divisorZeroIndex₀Val p = z₀} : ++ Set _).Finite := by ++ have hsub : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | divisorZeroIndex₀Val p = z₀} : Set _) ++ ⊆ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ‖z₀‖} : ++ Set _) := by ++ intro p hp ++ have : divisorZeroIndex₀Val p = z₀ := hp ++ simp [this] ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ‖z₀‖} : ++ Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) ‖z₀‖ ⊆ (Set.univ : Set ℂ) := by simp ++ simpa using (divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) ++ (B := ‖z₀‖) this) ++ exact hfin.subset hsub ++ ++def divisorZeroIndex₀FiberFinset (f : ℂ → ℂ) (z₀ : ℂ) : ++ Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ (divisorZeroIndex₀_fiber_finite (f := f) z₀).toFinset ++ ++@[simp] ++lemma mem_divisorZeroIndex₀FiberFinset (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ↔ divisorZeroIndex₀Val p = z₀ := by ++ simp [divisorZeroIndex₀FiberFinset] ++ ++theorem eventually_atTop_subset_fiberFinset ++ (f : ℂ → ℂ) (z₀ : ℂ) : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s := by ++ refine (Filter.eventually_atTop.2 ?_) ++ refine ⟨divisorZeroIndex₀FiberFinset (f := f) z₀, ?_⟩ ++ intro s hs ++ exact hs ++ ++lemma divisorZeroIndex₀FiberFinset_card_eq_toNat_divisor (f : ℂ → ℂ) {z₀ : ℂ} (hz₀ : z₀ ≠ 0) : ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = ++ Int.toNat (MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀) := by ++ let S : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := {p | divisorZeroIndex₀Val p = z₀} ++ have hS : S.Finite := divisorZeroIndex₀_fiber_finite (f := f) z₀ ++ set n : ℕ := Int.toNat (MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀) ++ have hcard : Nat.card S = n := by ++ classical ++ have : Fintype S := hS.fintype ++ ++ let e : S ≃ Fin n := ++ { toFun := by ++ intro x ++ rcases x with ⟨p, hp⟩ ++ rcases p with ⟨⟨z, q⟩, hz⟩ ++ have hzEq : z = z₀ := by simpa [divisorZeroIndex₀Val] using! hp ++ subst hzEq ++ simpa [n] using q ++ invFun := by ++ intro q ++ refine ⟨⟨⟨z₀, ?_⟩, hz₀⟩, ?_⟩ ++ · simpa [n] using q ++ · simp [S, divisorZeroIndex₀Val] ++ left_inv := by ++ rintro ⟨p, hp⟩ ++ rcases p with ⟨⟨z, q⟩, hz⟩ ++ have hzEq : z = z₀ := by simpa [divisorZeroIndex₀Val] using! hp ++ subst hzEq ++ (ext; rfl) ++ right_inv := by ++ intro q ++ rfl } ++ have h := Nat.card_congr (α := S) (β := Fin n) e ++ simpa using (h.trans (by simp)) ++ have hSncard : S.ncard = n := by ++ simpa [Nat.card_coe_set_eq] using hcard ++ have hto : hS.toFinset = divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ rfl ++ have htoFinset : S.ncard = (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ have h' : S.ncard = hS.toFinset.card := Set.ncard_eq_toFinset_card S hS ++ simpa [hto] using h' ++ exact htoFinset.symm.trans hSncard ++ ++lemma divisorZeroIndex₀FiberFinset_card_eq_analyticOrderNatAt ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) {z₀ : ℂ} (hz₀ : z₀ ≠ 0) : ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = analyticOrderNatAt f z₀ := by ++ have hdiv : ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀ = (analyticOrderNatAt f z₀ : ℤ) := ++ divisor_univ_eq_analyticOrderNatAt_int (f := f) hf z₀ ++ have htoNat : Int.toNat (MeromorphicOn.divisor f (Set.univ : Set ℂ) z₀) = ++ analyticOrderNatAt f z₀ := by ++ simp [hdiv] ++ exact (divisorZeroIndex₀FiberFinset_card_eq_toNat_divisor (f := f) (z₀ := z₀) hz₀).trans htoNat ++ ++lemma not_mem_divisorZeroIndex₀FiberFinset_iff_val_ne ++ {f : ℂ → ℂ} (z₀ : ℂ) (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ p ∉ divisorZeroIndex₀FiberFinset (f := f) z₀ ↔ divisorZeroIndex₀Val p ≠ z₀ := by ++ simp [mem_divisorZeroIndex₀FiberFinset] ++ ++end Complex.Hadamard ++end ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/DivisorLimits.lean b/PrimeNumberTheoremAnd/SiegelZeros/DivisorLimits.lean +new file mode 100644 +index 0000000..4325f1f +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/DivisorLimits.lean +@@ -0,0 +1,422 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.DivisorProducts ++ ++namespace SiegelZeros ++ ++section ++open Filter Function _root_.SiegelZeros.Complex _root_.Function.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++theorem differentiableOn_divisorPartialProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) (k : ℕ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ DifferentiableOn ℂ (fun z : ℂ => (divisorPartialProduct m f s z) / (z - z₀) ^ k) ++ ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hdiff_prod : DifferentiableOn ℂ (divisorPartialProduct m f s) (Set.univ : Set ℂ) := by ++ exact (differentiable_divisorPartialProduct m f s).differentiableOn ++ have hdiff_den : DifferentiableOn ℂ (fun z : ℂ => (z - z₀) ^ k) ((Set.univ : Set ℂ) \ {z₀}) := by ++ have : Differentiable ℂ (fun z : ℂ => (z - z₀) ^ k) := by ++ fun_prop ++ exact this.differentiableOn ++ by_cases hk : k = 0 ++ · subst hk ++ simpa [pow_zero] using! (hdiff_prod.mono (by intro z hz; exact hz.1)) ++ · have hne : ∀ z ∈ ((Set.univ : Set ℂ) \ {z₀}), (fun z : ℂ => (z - z₀) ^ k) z ≠ 0 := by ++ intro z hz ++ have hz' : z ≠ z₀ := by ++ simpa [Set.mem_sdiff, Set.mem_singleton_iff] using hz.2 ++ exact pow_ne_zero _ (sub_ne_zero.mpr hz') ++ have hdiff_inv : ++ DifferentiableOn ℂ (fun z : ℂ => ((z - z₀) ^ k)⁻¹) ((Set.univ : Set ℂ) \ {z₀}) := ++ hdiff_den.inv hne ++ simpa [div_eq_mul_inv] using! (hdiff_prod.mono (by intro z hz; exact hz.1)).mul hdiff_inv ++ ++theorem differentiableOn_divisorCanonicalProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) (k : ℕ) : DifferentiableOn ℂ ++ (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ k) ++ ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hopen : IsOpen ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hset : ((Set.univ : Set ℂ) \ {z₀}) = ({z₀} : Set ℂ)ᶜ := by ++ ext z; simp ++ simp [hset] ++ have hconv := ++ tendstoLocallyUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m := m) (f := f) h_sum (z₀ := z₀) (k := k) ++ refine hconv.differentiableOn ?_ hopen ++ refine Filter.Eventually.of_forall ?_ ++ intro s ++ exact differentiableOn_divisorPartialProduct_div_pow_sub (m := m) (f := f) (z₀ := z₀) (k := k) s ++ ++theorem differentiableOn_update_limUnder_divisorCanonicalProduct_div_pow ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ∃ r > 0, DifferentiableOn ℂ (Function.update ++ (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) z₀ ++ (limUnder (𝓝[≠] z₀) (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card))) ++ (Metric.ball z₀ r) := by ++ rcases bddAbove_norm_divisorCanonicalProduct_div_pow_puncturedBall (m := m) (f := f) ++ (h_sum := h_sum) (z₀ := z₀) with ⟨r, hrpos, hbdd⟩ ++ refine ⟨r, hrpos, ?_⟩ ++ have hnhds : Metric.ball z₀ r ∈ 𝓝 z₀ := Metric.ball_mem_nhds z₀ hrpos ++ have hdiff : DifferentiableOn ℂ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ ((Metric.ball z₀ r) \ {z₀}) := by ++ have hglob := ++ differentiableOn_divisorCanonicalProduct_div_pow_sub ++ (m := m) (f := f) h_sum (z₀ := z₀) ++ (k := (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ refine hglob.mono ?_ ++ intro z hz ++ exact ⟨by simp, hz.2⟩ ++ have hb : BddAbove (norm ∘ (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) '' ++ ((Metric.ball z₀ r) \ {z₀})) := hbdd ++ simpa using ++ (Complex.differentiableOn_update_limUnder_of_bddAbove (f := fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ (s := Metric.ball z₀ r) (c := z₀) hnhds hdiff hb) ++ ++theorem analyticAt_update_limUnder_divisorCanonicalProduct_div_pow ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : AnalyticAt ℂ (Function.update (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) z₀ ++ (limUnder (𝓝[≠] z₀) (fun z : ℂ => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card))) ++ z₀ := by ++ rcases ++ differentiableOn_update_limUnder_divisorCanonicalProduct_div_pow ++ (m := m) (f := f) h_sum (z₀ := z₀) with ⟨r, hrpos, hdiff⟩ ++ let g : ℂ → ℂ := ++ Function.update ++ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ z₀ ++ (limUnder (𝓝[≠] z₀) fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ have hcont : ContinuousAt g z₀ := ++ (hdiff.differentiableAt (Metric.ball_mem_nhds z₀ hrpos)).continuousAt ++ have hd : ++ ∀ᶠ z in 𝓝[≠] z₀, DifferentiableAt ℂ g z := by ++ have hballWithin : Metric.ball z₀ r ∈ 𝓝[≠] z₀ := by ++ refine mem_nhdsWithin_iff_exists_mem_nhds_inter.2 ?_ ++ refine ⟨Metric.ball z₀ r, Metric.ball_mem_nhds z₀ hrpos, ?_⟩ ++ intro z hz ++ exact hz.1 ++ filter_upwards [hballWithin] with z hz ++ exact (hdiff z hz).differentiableAt (Metric.isOpen_ball.mem_nhds hz) ++ simpa [g] using Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt hd hcont ++ ++theorem exists_analyticAt_divisorCanonicalProduct_quotient ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ ∃ q : ℂ → ℂ, ++ AnalyticAt ℂ q z₀ ∧ ++ q z₀ = ++ limUnder (𝓝[≠] z₀) (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ∧ ++ ∀ z : ℂ, z ≠ z₀ → ++ q z = ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ let q : ℂ → ℂ := ++ Function.update ++ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ z₀ ++ (limUnder (𝓝[≠] z₀) fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) ++ refine ⟨q, ?_, ?_, ?_⟩ ++ · simpa [q] using ++ analyticAt_update_limUnder_divisorCanonicalProduct_div_pow ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀) ++ · simp [q] ++ · intro z hz ++ simp [q, Function.update_of_ne hz] ++ ++theorem analyticOrderNatAt_divisorCanonicalProduct_eq_fiber_card ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ set k : ℕ := (divisorZeroIndex₀FiberFinset (f := f) z₀).card ++ let F : ℂ → ℂ := divisorCanonicalProduct m f (Set.univ : Set ℂ) ++ let q0 : ℂ → ℂ := fun z => F z / (z - z₀) ^ k ++ rcases exists_analyticAt_divisorCanonicalProduct_quotient ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀) with ++ ⟨q, hqA, hq_self, hq_ne⟩ ++ have hdiff_univ : DifferentiableOn ℂ F (Set.univ : Set ℂ) := ++ differentiableOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ have han : AnalyticAt ℂ F z₀ := by ++ refine (Complex.analyticAt_iff_eventually_differentiableAt).2 ?_ ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ have : DifferentiableWithinAt ℂ F (Set.univ : Set ℂ) z := hdiff_univ z (by simp) ++ exact this.differentiableAt (by simp) ++ rcases ++ exists_ball_eq_divisorCanonicalProduct_div_pow_eq (m := m) (f := f) (h_sum := h_sum) ++ (z₀ := z₀) ++ with ⟨ε, hε, u, huA, hu0, hEq⟩ ++ let g : ℂ → ℂ := fun z => (divisorComplementCanonicalProduct m f z₀ z) * u z ++ have hcompDiff : DifferentiableOn ℂ (divisorComplementCanonicalProduct m f z₀) ++ (Set.univ : Set ℂ) := ++ differentiableOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) (z₀ := z₀) h_sum ++ have hcompCont : ContinuousAt (divisorComplementCanonicalProduct m f z₀) z₀ := ++ (hcompDiff z₀ (by simp)).differentiableAt (by simp) |>.continuousAt ++ have hgCont : ContinuousAt g z₀ := (hcompCont.mul huA.continuousAt) ++ have hg0 : g z₀ ≠ 0 := by ++ have hcomp0 : divisorComplementCanonicalProduct m f z₀ z₀ ≠ 0 := ++ divisorComplementCanonicalProduct_ne_zero_at (m := m) (f := f) (z₀ := z₀) h_sum ++ exact mul_ne_zero hcomp0 hu0 ++ have hne_mem : ∀ᶠ z in 𝓝[≠] z₀, z ∈ (({z₀} : Set ℂ)ᶜ) := ++ Filter.eventually_of_mem ++ (self_mem_nhdsWithin : (({z₀} : Set ℂ)ᶜ) ∈ 𝓝[≠] z₀) (fun _ hz => hz) ++ have hne : ∀ᶠ z in 𝓝[≠] z₀, z ≠ z₀ := by ++ filter_upwards [hne_mem] with z hz ++ simpa [Set.mem_compl_singleton_iff] using hz ++ have ht_q0 : Tendsto q0 (𝓝[≠] z₀) (𝓝 (g z₀)) := by ++ have hball : ∀ᶠ z in 𝓝[≠] z₀, z ∈ Metric.ball z₀ ε := ++ Filter.eventually_of_mem ++ (mem_nhdsWithin_of_mem_nhds (Metric.ball_mem_nhds z₀ hε)) (fun _ hz => hz) ++ have heq : q0 =ᶠ[𝓝[≠] z₀] g := by ++ filter_upwards [hball, hne] with z hz hzne ++ have hq := hEq z hz hzne ++ simpa [q0, F, k, g, smul_eq_mul] using hq ++ exact (hgCont.continuousWithinAt.tendsto.congr' heq.symm) ++ have hlim : limUnder (𝓝[≠] z₀) q0 = g z₀ := ht_q0.limUnder_eq ++ have hq0 : q z₀ ≠ 0 := by ++ have hq_self' : q z₀ = limUnder (𝓝[≠] z₀) q0 := by ++ simpa [q0, F, k] using hq_self ++ have : q z₀ = g z₀ := hq_self'.trans hlim ++ exact this.symm ▸ hg0 ++ have heq_punct : (fun z : ℂ => F z) =ᶠ[𝓝[≠] z₀] fun z : ℂ => (z - z₀) ^ k • q z := by ++ filter_upwards [hne] with z hz ++ have hzpow : (z - z₀) ^ k ≠ 0 := pow_ne_zero _ (sub_ne_zero.mpr hz) ++ have hq : q z = q0 z := by simpa [q0, F, k] using hq_ne z hz ++ have hmul : (z - z₀) ^ k * q0 z = F z := by ++ calc ++ (z - z₀) ^ k * q0 z ++ = (((z - z₀) ^ k) * F z) / ((z - z₀) ^ k) := by ++ simp [q0, div_eq_mul_inv, mul_assoc] ++ _ = F z := by ++ simpa [mul_assoc] using (mul_div_cancel_left₀ (F z) hzpow) ++ have : F z = (z - z₀) ^ k * q z := by ++ calc ++ F z = (z - z₀) ^ k * q0 z := hmul.symm ++ _ = (z - z₀) ^ k * q z := by simp [hq] ++ simpa [smul_eq_mul] using this ++ have hcontF : ContinuousAt F z₀ := ++ (hdiff_univ z₀ (by simp)).differentiableAt (by simp) |>.continuousAt ++ have hcontq : ContinuousAt q z₀ := hqA.continuousAt ++ have h_at_z0 : F z₀ = (z₀ - z₀) ^ k • q z₀ := by ++ have ht1 : Tendsto F (𝓝[≠] z₀) (𝓝 (F z₀)) := hcontF.continuousWithinAt.tendsto ++ have hpow : ++ Tendsto (fun z : ℂ => (z - z₀) ^ k) (𝓝[≠] z₀) (𝓝 ((z₀ - z₀) ^ k)) := ++ ((continuousAt_id.sub continuousAt_const).pow k).continuousWithinAt.tendsto ++ have ht2 : ++ Tendsto (fun z : ℂ => (z - z₀) ^ k • q z) (𝓝[≠] z₀) ++ (𝓝 ((z₀ - z₀) ^ k • q z₀)) := ++ hpow.mul (hcontq.continuousWithinAt.tendsto) ++ have ht2' : Tendsto F (𝓝[≠] z₀) (𝓝 ((z₀ - z₀) ^ k • q z₀)) := ++ ht2.congr' heq_punct.symm ++ exact tendsto_nhds_unique ht1 ht2' ++ have hfac : ∀ᶠ z in 𝓝 z₀, F z = (z - z₀) ^ k • q z := by ++ have hball1 : Metric.ball z₀ 1 ∈ 𝓝 z₀ := Metric.ball_mem_nhds z₀ (by norm_num) ++ have hball1' : ∀ᶠ z in 𝓝 z₀, z ∈ Metric.ball z₀ 1 := ++ Filter.eventually_of_mem hball1 (fun _ hz => hz) ++ filter_upwards [hball1'] with z _hz ++ by_cases hz0 : z = z₀ ++ · subst hz0 ++ simpa using h_at_z0 ++ · have hzpow : (z - z₀) ^ k ≠ 0 := pow_ne_zero _ (sub_ne_zero.mpr hz0) ++ have hq : q z = q0 z := by simpa [q0, F, k] using hq_ne z hz0 ++ have hmul : (z - z₀) ^ k * q0 z = F z := by ++ calc ++ (z - z₀) ^ k * q0 z ++ = (((z - z₀) ^ k) * F z) / ((z - z₀) ^ k) := by ++ simp [q0, div_eq_mul_inv, mul_assoc] ++ _ = F z := by ++ simpa [mul_assoc] using (mul_div_cancel_left₀ (F z) hzpow) ++ have : F z = (z - z₀) ^ k * q z := by ++ calc ++ F z = (z - z₀) ^ k * q0 z := hmul.symm ++ _ = (z - z₀) ^ k * q z := by simp [hq] ++ simpa [smul_eq_mul] using this ++ have hk' : analyticOrderAt F z₀ = k := ++ (han.analyticOrderAt_eq_natCast (n := k)).2 ⟨q, hqA, hq0, hfac⟩ ++ have hkNat : analyticOrderNatAt F z₀ = k := by ++ simp [analyticOrderNatAt, hk'] ++ simpa [F, k] using hkNat ++ ++theorem analyticOrderNatAt_divisorCanonicalProduct_eq_analyticOrderNatAt ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ {z₀ : ℂ} (hz₀ : z₀ ≠ 0) : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ analyticOrderNatAt f z₀ := by ++ have hcp : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card := ++ analyticOrderNatAt_divisorCanonicalProduct_eq_fiber_card (m := m) (f := f) (h_sum := h_sum) ++ (z₀ := z₀) ++ have hfib : ++ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = analyticOrderNatAt f z₀ := ++ divisorZeroIndex₀FiberFinset_card_eq_analyticOrderNatAt (hf := hf) (z₀ := z₀) hz₀ ++ simpa [hfib] using hcp ++ ++end Complex.Hadamard ++end ++section ++namespace Complex.Hadamard ++ ++open scoped Topology ++open Set ++ ++lemma analyticOrderAt_ne_top_of_exists_ne_zero {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) : ++ ∀ z : ℂ, analyticOrderAt f z ≠ ⊤ := by ++ rcases hnot with ⟨z1, hz1⟩ ++ have hf_an : AnalyticOnNhd ℂ f (Set.univ : Set ℂ) := by ++ intro z hz ++ exact (Differentiable.analyticAt (f := f) hf z) ++ have hz1_not_top : analyticOrderAt f z1 ≠ ⊤ := by ++ have : analyticOrderAt f z1 = 0 := ++ (hf.analyticAt z1).analyticOrderAt_eq_zero.2 hz1 ++ simp [this] ++ intro z ++ exact AnalyticOnNhd.analyticOrderAt_ne_top_of_isPreconnected (hf := hf_an) ++ (U := (Set.univ : Set ℂ)) (x := z1) (y := z) (by simpa using isPreconnected_univ) ++ (by simp) (by simp) hz1_not_top ++ ++lemma no_zero_on_sphere_of_forall_val_norm_ne ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ {B r : ℝ} (hrpos : 0 < r) (hBr : r ≤ B) (hr_not : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖ ≤ B → r ≠ ‖divisorZeroIndex₀Val p‖) : ++ ∀ u : ℂ, ‖u‖ = r → f u ≠ 0 := by ++ intro u hur ++ have hu0 : u ≠ 0 := by ++ intro hu0 ++ subst hu0 ++ have : (0 : ℝ) = r := by simpa using hur ++ exact (ne_of_gt hrpos) this.symm ++ intro hfu0 ++ have hnotTop : analyticOrderAt f u ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (f := f) hf hnot u ++ have hord_ne0 : analyticOrderNatAt f u ≠ 0 := by ++ intro h0 ++ have hEN : (analyticOrderNatAt f u : ENat) = 0 := by simp [h0] ++ have hAt0 : analyticOrderAt f u = 0 := by ++ have hcast : (analyticOrderNatAt f u : ENat) = analyticOrderAt f u := ++ Nat.cast_analyticOrderNatAt (f := f) (z₀ := u) hnotTop ++ simpa [hcast] using hEN ++ have han : AnalyticAt ℂ f u := Differentiable.analyticAt (f := f) hf u ++ exact ((han.analyticOrderAt_eq_zero).1 hAt0) hfu0 ++ have hcard_pos : 0 < (divisorZeroIndex₀FiberFinset (f := f) u).card := by ++ have hcard := ++ divisorZeroIndex₀FiberFinset_card_eq_analyticOrderNatAt (hf := hf) (z₀ := u) hu0 ++ have : 0 < analyticOrderNatAt f u := Nat.pos_of_ne_zero hord_ne0 ++ simpa [hcard] using this ++ rcases Finset.card_pos.mp hcard_pos with ⟨p, hp⟩ ++ have hpval : divisorZeroIndex₀Val p = u := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := u) p).1 hp ++ have hpB : ‖divisorZeroIndex₀Val p‖ ≤ B := by ++ have : ‖divisorZeroIndex₀Val p‖ = r := by simp [hpval, hur] ++ simpa [this] using hBr ++ have : r ≠ ‖divisorZeroIndex₀Val p‖ := hr_not p hpB ++ exact this (by simp [hpval, hur]) ++ ++theorem analyticOrderAt_divisorCanonicalProduct_eq_fiber_card ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z₀ = ++ ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ let F : ℂ → ℂ := divisorCanonicalProduct m f (Set.univ : Set ℂ) ++ have hNat : ++ analyticOrderNatAt F z₀ = (divisorZeroIndex₀FiberFinset (f := f) z₀).card := by ++ simpa [F] using ++ (analyticOrderNatAt_divisorCanonicalProduct_eq_fiber_card ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀)) ++ have hdiffOn : DifferentiableOn ℂ F (Set.univ : Set ℂ) := by ++ simpa [F] using differentiableOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ have hdiff : Differentiable ℂ F := by ++ intro z ++ exact (hdiffOn z (by simp)).differentiableAt (by simp) ++ have hnotTop : analyticOrderAt F z₀ ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hdiff) ++ ⟨0, by simp [F, divisorCanonicalProduct_zero]⟩ z₀ ++ have hcast : (analyticOrderNatAt F z₀ : ℕ∞) = analyticOrderAt F z₀ := ++ Nat.cast_analyticOrderNatAt (f := F) (z₀ := z₀) hnotTop ++ have hNatCast : ++ (analyticOrderNatAt F z₀ : ℕ∞) = ++ ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ simp [hNat] ++ simpa [F, hcast] using hNatCast ++ ++theorem divisorCanonicalProduct_ne_zero_of_forall_ne ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ {z : ℂ} (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) : ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) z ≠ 0 := by ++ let F : ℂ → ℂ := divisorCanonicalProduct m f (Set.univ : Set ℂ) ++ have hfiber_empty : divisorZeroIndex₀FiberFinset (f := f) z = ∅ := by ++ ext p ++ constructor ++ · intro hp ++ exact False.elim (hz p ((mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z) p).1 hp).symm) ++ · intro hp ++ simp at hp ++ have horder : ++ analyticOrderAt F z = (0 : ℕ∞) := by ++ have h := ++ analyticOrderAt_divisorCanonicalProduct_eq_fiber_card ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z) ++ simpa [F, hfiber_empty] using h ++ have han : AnalyticAt ℂ F z := by ++ refine (Complex.analyticAt_iff_eventually_differentiableAt).2 ?_ ++ refine Filter.Eventually.of_forall ?_ ++ intro w ++ exact (((differentiableOn_divisorCanonicalProduct_univ m f h_sum) w ++ (by simp)).differentiableAt (by simp)) ++ exact (han.analyticOrderAt_eq_zero).1 horder ++ ++theorem logDeriv_divisorCanonicalProduct_one_eq_tsum_of_forall_ne ++ {f : ℂ → ℂ} {z : ℂ} ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (2 : ℕ))) ++ (hz : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), z ≠ divisorZeroIndex₀Val p) : ++ logDeriv (divisorCanonicalProduct 1 f (Set.univ : Set ℂ)) z = ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (1 / (z - divisorZeroIndex₀Val p) + 1 / divisorZeroIndex₀Val p) := ++ logDeriv_divisorCanonicalProduct_one_eq_tsum h_sum hz ++ (divisorCanonicalProduct_ne_zero_of_forall_ne 1 f h_sum hz) ++ ++end Hadamard ++end Complex ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/DivisorProducts.lean b/PrimeNumberTheoremAnd/SiegelZeros/DivisorProducts.lean +new file mode 100644 +index 0000000..5ca9514 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/DivisorProducts.lean +@@ -0,0 +1,912 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.DivisorBasics ++ ++namespace SiegelZeros ++ ++section ++open Filter Function _root_.SiegelZeros.Complex _root_.Function.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++noncomputable def divisorComplementFactor ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) : ℂ := by ++ classical ++ exact if p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ ++@[simp] ++theorem divisorComplementFactor_eq_one_of_mem ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) ++ (hp : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀) : ++ divisorComplementFactor m f z₀ p z = 1 := by ++ classical ++ simp [divisorComplementFactor, hp] ++ ++@[simp] ++theorem divisorComplementFactor_eq_weierstrassFactor_of_not_mem ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) ++ (hp : p ∉ divisorZeroIndex₀FiberFinset (f := f) z₀) : ++ divisorComplementFactor m f z₀ p z = ++ weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ classical ++ simp [divisorComplementFactor, hp] ++ ++lemma divisorComplementFactor_def ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) : ++ divisorComplementFactor m f z₀ p z = ++ if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ classical ++ by_cases h : divisorZeroIndex₀Val p = z₀ ++ · have hp : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ simpa [mem_divisorZeroIndex₀FiberFinset] using h ++ simp [divisorComplementFactor_eq_one_of_mem, hp, h] ++ · have hp : p ∉ divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ intro hmem ++ exact h ((mem_divisorZeroIndex₀FiberFinset f z₀ p).1 hmem) ++ simp [divisorComplementFactor_eq_weierstrassFactor_of_not_mem, hp, h] ++ ++noncomputable def divisorPartialProduct (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) : ℂ := ++ ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ ++theorem differentiable_weierstrassFactor_divisorZeroIndex₀ (m : ℕ) {f : ℂ → ℂ} ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ Differentiable ℂ (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p)) := by ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / divisorZeroIndex₀Val p) := by ++ simp [div_eq_mul_inv] ++ exact (differentiable_weierstrassFactor m).comp hdiv ++ ++theorem differentiable_divisorPartialProduct (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ Differentiable ℂ (divisorPartialProduct m f s) := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hΦ : ∀ p ∈ s, Differentiable ℂ (Φ p) := by ++ intro p _hp ++ exact differentiable_weierstrassFactor_divisorZeroIndex₀ m p ++ simpa [divisorPartialProduct, Φ] using! ++ (Differentiable.fun_finsetProd (𝕜 := ℂ) (f := Φ) (u := s) hΦ) ++ ++theorem analyticAt_divisorPartialProduct (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z₀ : ℂ) : ++ AnalyticAt ℂ (divisorPartialProduct m f s) z₀ := ++ (differentiable_divisorPartialProduct m f s).analyticAt z₀ ++ ++noncomputable def divisorComplementPartialProduct ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) : ℂ := ++ ∏ p ∈ s, divisorComplementFactor m f z₀ p z ++ ++@[simp] ++lemma divisorComplementPartialProduct_def ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) : ++ divisorComplementPartialProduct m f z₀ s z = ++ ∏ p ∈ s, if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ simp [divisorComplementPartialProduct, divisorComplementFactor, ++ mem_divisorZeroIndex₀FiberFinset] ++ ++theorem differentiable_divisorComplementPartialProduct ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ Differentiable ℂ (divisorComplementPartialProduct m f z₀ s) := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := ++ fun p z => divisorComplementFactor m f z₀ p z ++ have hΦ : ∀ p ∈ s, Differentiable ℂ (Φ p) := by ++ intro p _hp ++ by_cases hpF : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ · have hΦp : Φ p = fun _ => (1 : ℂ) := by ++ ext z ++ simp only [Φ, divisorComplementFactor_eq_one_of_mem m f z₀ p z hpF] ++ rw [hΦp] ++ exact differentiable_const (1 : ℂ) ++ · have hΦp : Φ p = fun z => weierstrassFactor m (z / divisorZeroIndex₀Val p) := by ++ ext z ++ simp only [Φ, divisorComplementFactor_eq_weierstrassFactor_of_not_mem m f z₀ p z hpF] ++ rw [hΦp] ++ exact differentiable_weierstrassFactor_divisorZeroIndex₀ m p ++ have hEq : (fun z : ℂ => ∏ p ∈ s, Φ p z) = ++ divisorComplementPartialProduct m f z₀ s := by ++ ext z ++ simp [Φ, divisorComplementPartialProduct] ++ have : Differentiable ℂ (fun z : ℂ => ∏ p ∈ s, Φ p z) := by ++ simpa using (Differentiable.fun_finsetProd (𝕜 := ℂ) (f := Φ) (u := s) hΦ) ++ simpa [hEq] using this ++ ++noncomputable def divisorComplementCanonicalProduct ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) (z : ℂ) : ℂ := ++ ∏' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), divisorComplementFactor m f z₀ p z ++ ++theorem hasProdUniformlyOn_divisorComplementCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) {K : Set ℂ} (hK : IsCompact K) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdUniformlyOn (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ divisorComplementFactor m f z₀ p z) (divisorComplementCanonicalProduct m f z₀) ++ K := by ++ rcases (isBounded_iff_forall_norm_le.1 hK.isBounded) with ⟨R0, hR0⟩ ++ set R : ℝ := max R0 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ have hnormK : ∀ z ∈ K, ‖z‖ ≤ R := fun z hzK => le_trans (hR0 z hzK) (le_max_left _ _) ++ let term : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := fun p z => ++ divisorComplementFactor m f z₀ p z ++ let g : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ → ℂ := fun p z => term p z - 1 ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (4 * R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) ++ have hu : Summable u := h_sum.mul_left (4 * R ^ (m + 1)) ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ 2 * R} : ++ Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ have hBound : ++ ∀ᶠ p in Filter.cofinite, ∀ z ∈ K, ‖g p z‖ ≤ u p := by ++ filter_upwards [h_big] with p hp z hzK ++ by_cases hpF : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ · have hval : divisorZeroIndex₀Val p = z₀ := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z₀) p).1 hpF ++ have hu0 : 0 ≤ u p := by ++ dsimp [u] ++ refine mul_nonneg ?_ ?_ ++ · nlinarith [pow_nonneg (show 0 ≤ R from le_of_lt hRpos) (m + 1)] ++ · exact pow_nonneg (inv_nonneg.2 (norm_nonneg _)) (m + 1) ++ simp [g, term, divisorComplementFactor, hval, hu0, sub_eq_add_neg] ++ · have hzle : ‖z‖ ≤ R := hnormK z hzK ++ have hz_div : ‖z / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := by ++ have h2R_pos : 0 < (2 * R : ℝ) := by nlinarith [hRpos] ++ have hinv : ‖divisorZeroIndex₀Val p‖⁻¹ < (2 * R)⁻¹ := by ++ simpa [one_div] using (one_div_lt_one_div_of_lt h2R_pos hp) ++ have hmul_le : ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ ≤ R * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ refine mul_le_mul_of_nonneg_right hzle ?_ ++ exact inv_nonneg.2 (norm_nonneg _) ++ have hmul_lt : R * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ mul_lt_mul_of_pos_left hinv hRpos ++ have hlt : ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ lt_of_le_of_lt hmul_le hmul_lt ++ have hRhalf : R * (2 * R)⁻¹ = (1 / 2 : ℝ) := by ++ have hRne : (R : ℝ) ≠ 0 := hRpos.ne' ++ have : R * (2 * R)⁻¹ = R / (2 * R) := by simp [div_eq_mul_inv] ++ rw [this] ++ field_simp [hRne] ++ have hnorm : ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ have hzlt : ‖z / divisorZeroIndex₀Val p‖ < (1 / 2 : ℝ) := by ++ calc ++ ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := hnorm ++ _ < R * (2 * R)⁻¹ := hlt ++ _ = (1 / 2 : ℝ) := hRhalf ++ exact le_of_lt hzlt ++ have hE : ‖weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1‖ ≤ ++ 4 * ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) := ++ weierstrassFactor_sub_one_pow_bound (m := m) (z := z / divisorZeroIndex₀Val p) hz_div ++ have hz_pow : ‖z / divisorZeroIndex₀Val p‖ ^ (m + 1) ≤ ++ (R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ have : ‖z / divisorZeroIndex₀Val p‖ = ‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ rw [this] ++ have : (‖z‖ * ‖divisorZeroIndex₀Val p‖⁻¹) ^ (m + 1) = ++ ‖z‖ ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simp [mul_pow] ++ rw [this] ++ have hzle_pow : ‖z‖ ^ (m + 1) ≤ R ^ (m + 1) := ++ pow_le_pow_left₀ (norm_nonneg z) hzle (m + 1) ++ gcongr ++ dsimp [g, term, u] ++ simp [divisorComplementFactor, hpF] at * ++ nlinarith [hE, hz_pow] ++ have hcts : ∀ p, ContinuousOn (g p) K := by ++ intro p ++ by_cases hpF : p ∈ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ · have hval : divisorZeroIndex₀Val p = z₀ := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z₀) p).1 hpF ++ simpa [g, term, divisorComplementFactor, hval, sub_eq_add_neg, add_assoc, add_left_comm, ++ add_comm] using ++ (continuousOn_const : ContinuousOn (fun _ : ℂ => (0 : ℂ)) K) ++ · have hvalne : divisorZeroIndex₀Val p ≠ z₀ := ++ (not_mem_divisorZeroIndex₀FiberFinset_iff_val_ne (f := f) z₀ p).1 hpF ++ have hcontE : Continuous (fun z : ℂ => weierstrassFactor m z) := ++ (differentiable_weierstrassFactor m).continuous ++ have hdiv : Continuous fun z : ℂ => z / divisorZeroIndex₀Val p := by ++ simpa [div_eq_mul_inv] using! (continuous_id.mul continuous_const) ++ have hcont : Continuous fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) := ++ hcontE.comp hdiv ++ have : ContinuousOn (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) - 1) K := ++ (hcont.continuousOn.sub continuous_const.continuousOn) ++ simpa [g, term, divisorComplementFactor, mem_divisorZeroIndex₀FiberFinset, hvalne] using this ++ have hprod : ++ HasProdUniformlyOn (fun p z ↦ 1 + g p z) (fun z ↦ ∏' p, (1 + g p z)) K := by ++ simpa using ++ Summable.hasProdUniformlyOn_one_add (f := g) (u := u) (K := K) hK hu hBound hcts ++ have hterm : ++ HasProdUniformlyOn (fun p z ↦ term p z) (fun z ↦ ∏' p, term p z) K := by ++ simpa [g, sub_eq_add_neg, add_assoc, add_left_comm, add_comm] using hprod ++ refine hterm.congr_right ?_ ++ intro z hz ++ simp [term, divisorComplementCanonicalProduct, divisorComplementFactor] ++ ++theorem hasProdLocallyUniformlyOn_divisorComplementCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ divisorComplementFactor m f z₀ p z) ++ (divisorComplementCanonicalProduct m f z₀) ++ (Set.univ : Set ℂ) := by ++ refine hasProdLocallyUniformlyOn_of_forall_compact ++ (f := fun p z => divisorComplementFactor m f z₀ p z) ++ (g := divisorComplementCanonicalProduct m f z₀) (s := (Set.univ : Set ℂ)) ++ isOpen_univ ?_ ++ intro K hKU hK ++ simpa using ++ (hasProdUniformlyOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) (z₀ := z₀) ++ (K := K) hK h_sum) ++ ++theorem tendstoLocallyUniformlyOn_divisorComplementPartialProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := by ++ have hprod : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ divisorComplementFactor m f z₀ p z) ++ (divisorComplementCanonicalProduct m f z₀) ++ (Set.univ : Set ℂ) := ++ hasProdLocallyUniformlyOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) ++ (z₀ := z₀) h_sum ++ have h : ++ TendstoLocallyUniformlyOn ++ (fun (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z : ℂ) => ++ ∏ p ∈ s, ++ if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := by ++ simpa [HasProdLocallyUniformlyOn, divisorComplementFactor, mem_divisorZeroIndex₀FiberFinset] ++ using hprod ++ refine h.congr (G := fun s z => divisorComplementPartialProduct m f z₀ s z) ?_ ++ intro s z hz ++ simp [divisorComplementPartialProduct_def] ++ ++theorem differentiableOn_divisorComplementCanonicalProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ DifferentiableOn ℂ (divisorComplementCanonicalProduct m f z₀) (Set.univ : Set ℂ) := by ++ have hloc : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := ++ tendstoLocallyUniformlyOn_divisorComplementPartialProduct_univ (m := m) (f := f) ++ (z₀ := z₀) h_sum ++ have hF : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in Filter.atTop, ++ DifferentiableOn ℂ (divisorComplementPartialProduct m f z₀ s) (Set.univ : Set ℂ) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro s ++ exact (differentiable_divisorComplementPartialProduct m f z₀ s).differentiableOn ++ have : (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))).NeBot := ++ Filter.atTop_neBot ++ exact hloc.differentiableOn hF isOpen_univ ++ ++lemma divisorPartialProduct_eq_fiber_mul_complement_of_subset ++ (m : ℕ) (f : ℂ → ℂ) (z₀ z : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hs : divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s) : ++ divisorPartialProduct m f s z = ++ divisorPartialProduct m f (divisorZeroIndex₀FiberFinset (f := f) z₀) z * ++ divisorComplementPartialProduct m f z₀ s z := by ++ classical ++ let fiber : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ let P : divisorZeroIndex₀ f (Set.univ : Set ℂ) → Prop := fun p => p ∈ fiber ++ let term : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := ++ fun p => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hfilter : s.filter P = fiber := by ++ ext p ++ constructor ++ · intro hp ++ exact (Finset.mem_filter.mp hp).2 ++ · intro hp ++ exact Finset.mem_filter.mpr ⟨hs hp, hp⟩ ++ have hsplit : ++ (∏ p ∈ s with P p, term p) * (∏ p ∈ s with ¬ P p, term p) = ∏ p ∈ s, term p := by ++ simpa [term] using ++ (Finset.prod_filter_mul_prod_filter_not (s := s) (p := P) (f := term)) ++ have hP : (∏ p ∈ s with P p, term p) = divisorPartialProduct m f fiber z := by ++ have hg : ∀ x ∈ s \ fiber, (if x ∈ fiber then term x else (1 : ℂ)) = 1 := by ++ intro x hx ++ have hxnot : x ∉ fiber := (Finset.mem_sdiff.mp hx).2 ++ simp [hxnot] ++ have hfg : ++ ∀ x ∈ fiber, term x = (if x ∈ fiber then term x else (1 : ℂ)) := by ++ intro x hx ++ simp [hx] ++ have hsub := (Finset.prod_subset_one_on_sdiff (s₁ := fiber) (s₂ := s) ++ (f := term) (g := fun x => if x ∈ fiber then term x else (1 : ℂ)) hs hg hfg) ++ simpa [divisorPartialProduct, term, P, fiber, Finset.prod_filter] using hsub.symm ++ have hnotP : (∏ p ∈ s with ¬ P p, term p) = divisorComplementPartialProduct m f z₀ s z := by ++ simp [divisorComplementPartialProduct, divisorComplementFactor, term, P, fiber, ++ Finset.prod_filter, mem_divisorZeroIndex₀FiberFinset] ++ have hsplit' : ∏ p ∈ s, term p = (∏ p ∈ s with P p, term p) * (∏ p ∈ s with ¬ P p, term p) := ++ hsplit.symm ++ calc ++ divisorPartialProduct m f s z ++ = ∏ p ∈ s, term p := by simp [divisorPartialProduct, term] ++ _ = (∏ p ∈ s with P p, term p) * (∏ p ∈ s with ¬ P p, term p) := hsplit' ++ _ = divisorPartialProduct m f fiber z * divisorComplementPartialProduct m f z₀ s z := by ++ simp [hP, hnotP, fiber] ++ ++end Complex.Hadamard ++end ++section ++noncomputable section ++ ++open _root_.SiegelZeros.Complex Filter Function Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++theorem analyticOrderAt_finset_prod_weierstrassFactor_divisorZeroIndex₀ ++ (m : ℕ) (f : ℂ → ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (z₀ : ℂ) : ++ analyticOrderAt (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ z₀ = ((s.filter (fun p => divisorZeroIndex₀Val p = z₀)).card : ℕ∞) := by ++ classical ++ refine Finset.induction_on s ?base ?step ++ · simp [analyticOrderAt_eq_zero] ++ · intro p s hp hs ++ by_cases hEq : divisorZeroIndex₀Val p = z₀ ++ · have hp0 : divisorZeroIndex₀Val p ≠ 0 := p.property ++ have han_fac : ++ AnalyticAt ℂ (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p)) z₀ := by ++ exact (differentiable_weierstrassFactor_divisorZeroIndex₀ m p).analyticAt z₀ ++ have han_rest : AnalyticAt ℂ (fun z : ℂ => ∏ q ∈ s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ := by ++ simpa [divisorPartialProduct] using! analyticAt_divisorPartialProduct m f s z₀ ++ let fac : ℂ → ℂ := fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ let rest : ℂ → ℂ := fun z : ℂ => ∏ q ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val q) ++ have hmul : ++ analyticOrderAt (fac * rest) z₀ = ++ analyticOrderAt fac z₀ + analyticOrderAt rest z₀ := by ++ simpa [fac, rest] using (analyticOrderAt_mul (z₀ := z₀) han_fac han_rest) ++ have hcard : ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) (insert p s)).card = ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) s).card + 1 := by ++ simp [hEq, hp, Finset.filter_insert] ++ have hfac : analyticOrderAt fac z₀ = (1 : ℕ∞) := by ++ simpa [fac, hEq] using ++ (analyticOrderAt_weierstrassFactor_div_self (m := m) (a := divisorZeroIndex₀Val p) hp0) ++ have hrest : analyticOrderAt rest z₀ = ((s.filter ++ (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simpa [rest] using hs ++ have hcongr : ++ (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m (z / divisorZeroIndex₀Val q)) ++ =ᶠ[𝓝 z₀] (fac * rest) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ simp [fac, rest, Finset.prod_insert, hp, Pi.mul_apply] ++ calc ++ analyticOrderAt (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ = analyticOrderAt (fac * rest) z₀ := by ++ simpa using (analyticOrderAt_congr hcongr) ++ _ = analyticOrderAt fac z₀ + analyticOrderAt rest z₀ := hmul ++ _ = (1 : ℕ∞) + ((s.filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simp [hfac, hrest] ++ _ = (((insert p s).filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simp [hcard, Nat.add_comm] ++ · have han_fac : ++ AnalyticAt ℂ (fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p)) z₀ := by ++ exact (differentiable_weierstrassFactor_divisorZeroIndex₀ m p).analyticAt z₀ ++ have hfac0 : analyticOrderAt (fun z : ℂ => weierstrassFactor m ++ (z / divisorZeroIndex₀Val p)) z₀ = 0 := by ++ have hp0 : divisorZeroIndex₀Val p ≠ 0 := p.property ++ have hval : weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) ≠ 0 := by ++ have : (z₀ / divisorZeroIndex₀Val p) ≠ 1 := by ++ intro h1 ++ have : z₀ = divisorZeroIndex₀Val p := by ++ have : z₀ = (z₀ / divisorZeroIndex₀Val p) * (divisorZeroIndex₀Val p) := by ++ simp [div_eq_mul_inv] ++ simpa [h1, div_eq_mul_inv, hp0] using this ++ exact hEq (this.symm) ++ exact (weierstrassFactor_ne_zero_iff m (z₀ / divisorZeroIndex₀Val p)).2 this ++ simpa using (han_fac.analyticOrderAt_eq_zero).2 (by simpa using hval) ++ have hcard : ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) (insert p s)).card = ++ (Finset.filter (fun q => divisorZeroIndex₀Val q = z₀) s).card := by ++ simp [hEq, Finset.filter_insert] ++ have han_rest : AnalyticAt ℂ (fun z : ℂ => ∏ q ∈ s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ := by ++ simpa [divisorPartialProduct] using! analyticAt_divisorPartialProduct m f s z₀ ++ let fac : ℂ → ℂ := fun z : ℂ => weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ let rest : ℂ → ℂ := fun z : ℂ => ∏ q ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val q) ++ have hmul : ++ analyticOrderAt (fac * rest) z₀ = ++ analyticOrderAt fac z₀ + analyticOrderAt rest z₀ := by ++ simpa [fac, rest] using (analyticOrderAt_mul (z₀ := z₀) han_fac han_rest) ++ have hcongr : ++ (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m (z / divisorZeroIndex₀Val q)) ++ =ᶠ[𝓝 z₀] (fac * rest) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ simp [fac, rest, Finset.prod_insert, hp, Pi.mul_apply] ++ calc ++ analyticOrderAt (fun z : ℂ => ∏ q ∈ insert p s, weierstrassFactor m ++ (z / divisorZeroIndex₀Val q)) z₀ ++ = analyticOrderAt (fac * rest) z₀ := by ++ simpa using (analyticOrderAt_congr hcongr) ++ _ = analyticOrderAt rest z₀ := by ++ calc ++ analyticOrderAt (fac * rest) z₀ = analyticOrderAt fac z₀ + ++ analyticOrderAt rest z₀ := hmul ++ _ = analyticOrderAt rest z₀ := by ++ have hfac0' : analyticOrderAt fac z₀ = 0 := by ++ simpa [fac] using hfac0 ++ simp [hfac0'] ++ _ = ((s.filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simpa [rest] using hs ++ _ = (((insert p s).filter (fun q => divisorZeroIndex₀Val q = z₀)).card : ℕ∞) := by ++ simpa using congrArg (fun n : ℕ => (n : ℕ∞)) hcard.symm ++ ++theorem analyticOrderAt_partialProduct_eq_fiberCard_of_subset ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hs : divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s) : ++ analyticOrderAt ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ z₀ = ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ have h := ++ analyticOrderAt_finset_prod_weierstrassFactor_divisorZeroIndex₀ ++ (m := m) (f := f) (s := s) (z₀ := z₀) ++ have hfilter : ++ s.filter (fun p => divisorZeroIndex₀Val p = z₀) = ++ divisorZeroIndex₀FiberFinset (f := f) z₀ := by ++ ext p ++ constructor ++ · intro hp' ++ have hpv : divisorZeroIndex₀Val p = z₀ := (Finset.mem_filter.mp hp').2 ++ simpa [mem_divisorZeroIndex₀FiberFinset] using hpv ++ · intro hp_fiber ++ have hpv : divisorZeroIndex₀Val p = z₀ := ++ (mem_divisorZeroIndex₀FiberFinset (f := f) (z₀ := z₀) p).1 hp_fiber ++ have hps : p ∈ s := hs (by simpa [mem_divisorZeroIndex₀FiberFinset] using hpv) ++ exact Finset.mem_filter.2 ⟨hps, hpv⟩ ++ simpa [hfilter] using h ++ ++theorem exists_analyticAt_eq_pow_smul_of_partialProduct_contains_fiber ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hs : divisorZeroIndex₀FiberFinset (f := f) z₀ ⊆ s) : ++ ∃ g : ℂ → ℂ, ++ AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ++ (fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ =ᶠ[𝓝 z₀] ++ fun z : ℂ => (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card • g z := by ++ let F : ℂ → ℂ := fun z : ℂ => ∏ p ∈ s, weierstrassFactor m (z / divisorZeroIndex₀Val p) ++ have hF_ana : AnalyticAt ℂ F z₀ := by ++ simpa [F, divisorPartialProduct] using! analyticAt_divisorPartialProduct m f s z₀ ++ have hOrder : ++ analyticOrderAt F z₀ = ++ ((divisorZeroIndex₀FiberFinset (f := f) z₀).card : ℕ∞) := by ++ simpa [F] using ++ (analyticOrderAt_partialProduct_eq_fiberCard_of_subset (m := m) ++ (f := f) (z₀ := z₀) (s := s) hs) ++ refine (hF_ana.analyticOrderAt_eq_natCast (n := (divisorZeroIndex₀FiberFinset ++ (f := f) z₀).card)).1 ?_ ++ simp [hOrder] ++ ++end Complex.Hadamard ++end ++end ++section ++open Filter Function _root_.SiegelZeros.Complex _root_.Function.Complex Finset Topology ++open scoped Topology BigOperators ++open Set ++ ++namespace Complex.Hadamard ++ ++theorem tendstoLocallyUniformlyOn_divisorPartialProduct_univ ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => divisorPartialProduct m f s) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop ++ (Set.univ : Set ℂ) := by ++ have hprod : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (z : ℂ) => ++ weierstrassFactor m (z / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (Set.univ : Set ℂ) := ++ hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ simpa [HasProdLocallyUniformlyOn, divisorPartialProduct] using! hprod ++ ++theorem tendstoUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) (k : ℕ) {K : Set ℂ} (hK : IsCompact K) (hKz : ∀ z ∈ K, z ≠ z₀) : ++ TendstoUniformlyOn ++ (fun s z => (divisorPartialProduct m f s z) / (z - z₀) ^ k) ++ (fun z => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ k) ++ (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))) ++ K := by ++ have hloc : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => divisorPartialProduct m f s) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop ++ K := ++ (tendstoLocallyUniformlyOn_divisorPartialProduct_univ (m := m) (f := f) h_sum).mono ++ (by intro z hz; simp) ++ have hunif : ++ TendstoUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => divisorPartialProduct m f s) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ Filter.atTop ++ K := ++ (tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hK).1 hloc ++ let h : ℂ → ℂ := fun z => ((z - z₀) ^ k)⁻¹ ++ have hh : ∃ C, ∀ z ∈ K, ‖h z‖ ≤ C := by ++ have hcont : ContinuousOn h K := by ++ have hpow : ContinuousOn (fun z : ℂ => (z - z₀) ^ k) K := by ++ fun_prop ++ refine hpow.inv₀ ?_ ++ intro z hz ++ have hz0 : z - z₀ ≠ 0 := sub_ne_zero.mpr (hKz z hz) ++ exact pow_ne_zero k hz0 ++ have hKimg : IsCompact (h '' K) := hK.image_of_continuousOn hcont ++ rcases (isBounded_iff_forall_norm_le.1 hKimg.isBounded) with ⟨C, hC⟩ ++ refine ⟨C, ?_⟩ ++ intro z hz ++ exact hC (h z) ⟨z, hz, rfl⟩ ++ have hunif' := ++ (TendstoUniformlyOn.mul_left_bounded (p := (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f ++ (Set.univ : Set ℂ))))) ++ (K := K) ++ (F := fun s z => divisorPartialProduct m f s z) ++ (f := fun z => divisorCanonicalProduct m f (Set.univ : Set ℂ) z) ++ (h := h) ++ hunif hh) ++ simpa [h, div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using hunif' ++ ++theorem tendstoLocallyUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) (k : ℕ) : ++ TendstoLocallyUniformlyOn ++ (fun s z => (divisorPartialProduct m f s z) / (z - z₀) ^ k) ++ (fun z => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ k) ++ (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))) ++ ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hopen : IsOpen ((Set.univ : Set ℂ) \ {z₀}) := by ++ have hset : ((Set.univ : Set ℂ) \ {z₀}) = ({z₀} : Set ℂ)ᶜ := by ++ ext z ++ simp ++ simp [hset] ++ refine (tendstoLocallyUniformlyOn_iff_forall_isCompact hopen).2 ?_ ++ intro K hKsub hK ++ have hKz : ∀ z ∈ K, z ≠ z₀ := by ++ intro z hzK ++ have : z ∈ (Set.univ : Set ℂ) \ {z₀} := hKsub hzK ++ exact by simpa [Set.mem_sdiff, Set.mem_singleton_iff] using this.2 ++ exact tendstoUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m := m) (f := f) h_sum (z₀ := z₀) (k := k) (hK := hK) hKz ++ ++open Filter ++ ++theorem exists_ball_eq_divisorCanonicalProduct_div_pow_eq ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ++ ∃ ε > 0, ∃ u : ℂ → ℂ, AnalyticAt ℂ u z₀ ∧ ++ u z₀ ≠ 0 ∧ ++ ∀ z : ℂ, z ∈ Metric.ball z₀ ε → z ≠ z₀ → ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card = ++ (divisorComplementCanonicalProduct m f z₀ z) * u z := by ++ let fiber : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ divisorZeroIndex₀FiberFinset (f := f) z₀ ++ have hfib : ∃ u : ℂ → ℂ, AnalyticAt ℂ u z₀ ∧ u z₀ ≠ 0 ∧ ++ (fun z : ℂ => divisorPartialProduct m f fiber z) =ᶠ[𝓝 z₀] ++ fun z : ℂ => (z - z₀) ^ fiber.card • u z := by ++ simpa [fiber, divisorPartialProduct] using ++ (exists_analyticAt_eq_pow_smul_of_partialProduct_contains_fiber (m := m) (f := f) (z₀ := z₀) ++ (s := fiber) (by rfl : fiber ⊆ fiber)) ++ rcases hfib with ⟨u, huA, hu0, huEq⟩ ++ have hmem : {z : ℂ | divisorPartialProduct m f fiber z = ++ (z - z₀) ^ fiber.card • u z} ∈ 𝓝 z₀ := huEq ++ rcases Metric.mem_nhds_iff.1 hmem with ⟨ε, hε, hball⟩ ++ refine ⟨ε, hε, u, huA, hu0, ?_⟩ ++ have hq : ++ TendstoLocallyUniformlyOn (fun s z => (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card) ++ (fun z => (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ fiber.card) ++ (Filter.atTop : Filter (Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)))) ++ ((Set.univ : Set ℂ) \ {z₀}) := ++ tendstoLocallyUniformlyOn_divisorPartialProduct_div_pow_sub ++ (m := m) (f := f) (h_sum := h_sum) (z₀ := z₀) (k := fiber.card) ++ have hcomp : ++ TendstoLocallyUniformlyOn ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s) ++ (divisorComplementCanonicalProduct m f z₀) ++ Filter.atTop ++ (Set.univ : Set ℂ) := ++ tendstoLocallyUniformlyOn_divisorComplementPartialProduct_univ (m := m) (f := f) ++ (z₀ := z₀) h_sum ++ intro z hz hzne ++ have hz' : z ∈ ((Set.univ : Set ℂ) \ {z₀}) := by ++ refine ⟨by simp, ?_⟩ ++ simpa [Set.mem_singleton_iff] using hzne ++ have hF : Tendsto (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card) (Filter.atTop : Filter _) ++ (𝓝 ((divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / (z - z₀) ^ fiber.card)) := ++ hq.tendsto_at hz' ++ have hG0 : Tendsto (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ divisorComplementPartialProduct m f z₀ s z) (Filter.atTop : Filter _) ++ (𝓝 (divisorComplementCanonicalProduct m f z₀ z)) := ++ hcomp.tendsto_at (by simp : z ∈ (Set.univ : Set ℂ)) ++ have hG : Tendsto (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ (divisorComplementPartialProduct m f z₀ s z) * u z) (Filter.atTop : Filter _) ++ (𝓝 ((divisorComplementCanonicalProduct m f z₀ z) * u z)) := ++ (hG0.mul tendsto_const_nhds) ++ have hsub : ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ fiber ⊆ s := eventually_atTop_subset_fiberFinset (f := f) z₀ ++ have heq_eventually : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card ++ = (divisorComplementPartialProduct m f z₀ s z) * u z := by ++ filter_upwards [hsub] with s hs ++ have hsplit : ++ divisorPartialProduct m f s z = ++ divisorPartialProduct m f fiber z * divisorComplementPartialProduct m f z₀ s z := by ++ simpa [fiber] using ++ (divisorPartialProduct_eq_fiber_mul_complement_of_subset (m := m) (f := f) (z₀ := z₀) ++ (z := z) (s := s) hs) ++ have hfibz : ++ divisorPartialProduct m f fiber z = (z - z₀) ^ fiber.card • u z := by ++ exact hball hz ++ have hzpow : (z - z₀) ^ fiber.card ≠ 0 := ++ pow_ne_zero _ (sub_ne_zero.mpr hzne) ++ set a : ℂ := (z - z₀) ^ fiber.card ++ have ha : a ≠ 0 := by simpa [a] using hzpow ++ set c : ℂ := divisorComplementPartialProduct m f z₀ s z with hc ++ rw [hsplit, hfibz, smul_eq_mul] ++ calc ++ ((a * u z) * c) / a ++ = (a * (u z * c)) / a := by simp [mul_assoc] ++ _ = u z * c := by ++ simpa [mul_assoc] using (mul_div_cancel_left₀ (u z * c) ha) ++ _ = c * u z := by ac_rfl ++ _ = (divisorComplementPartialProduct m f z₀ s z) * u z := by ++ simp [c] ++ have hG' : ++ Tendsto ++ (fun s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) => ++ (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card) ++ (Filter.atTop : Filter _) ++ (𝓝 ((divisorComplementCanonicalProduct m f z₀ z) * u z)) := by ++ have heq' : ++ ∀ᶠ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) in (Filter.atTop : Filter _), ++ (divisorComplementPartialProduct m f z₀ s z) * u z ++ = (divisorPartialProduct m f s z) / (z - z₀) ^ fiber.card := by ++ filter_upwards [heq_eventually] with s hs ++ exact hs.symm ++ exact (hG.congr' heq') ++ exact tendsto_nhds_unique hF hG' ++ ++theorem bddAbove_norm_divisorCanonicalProduct_div_pow_puncturedBall ++ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (z₀ : ℂ) : ∃ r > 0, BddAbove (norm ∘ (fun z : ℂ => ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card) '' ++ ((Metric.ball z₀ r) \ {z₀})) := by ++ rcases exists_ball_eq_divisorCanonicalProduct_div_pow_eq (m := m) (f := f) (h_sum := h_sum) ++ (z₀ := z₀) with ⟨ε, hε, u, huA, hu0, hEq⟩ ++ have huC : ContinuousAt u z₀ := huA.continuousAt ++ have hpre : {z : ℂ | ‖u z - u z₀‖ < 1} ∈ 𝓝 z₀ := by ++ have : u ⁻¹' Metric.ball (u z₀) (1 : ℝ) ∈ 𝓝 z₀ := ++ huC.preimage_mem_nhds (Metric.ball_mem_nhds (u z₀) (by norm_num)) ++ simpa [Metric.ball, dist_eq_norm, Set.preimage] using this ++ rcases Metric.mem_nhds_iff.1 hpre with ⟨r0, hr0pos, hr0sub⟩ ++ set r : ℝ := min (ε / 2) r0 ++ have hrpos : 0 < r := lt_min (by nlinarith [hε]) hr0pos ++ have hr_lt_ε : r < ε := lt_of_le_of_lt (min_le_left _ _) (by nlinarith [hε]) ++ have huBound : ∀ z ∈ Metric.ball z₀ r, ‖u z‖ ≤ ‖u z₀‖ + 1 := by ++ intro z hz ++ have hz0 : z ∈ Metric.ball z₀ r0 := by ++ have : r ≤ r0 := min_le_right _ _ ++ exact Metric.ball_subset_ball this hz ++ have hdiff : ‖u z - u z₀‖ < 1 := hr0sub hz0 ++ have htri : ‖u z‖ ≤ ‖u z - u z₀‖ + ‖u z₀‖ := by ++ simpa [sub_eq_add_neg, add_assoc] using ++ (norm_add_le (u z - u z₀) (u z₀)) ++ have : ‖u z‖ ≤ 1 + ‖u z₀‖ := le_trans htri (by nlinarith [le_of_lt hdiff]) ++ nlinarith [this] ++ have hdiffC : ++ DifferentiableOn ℂ (divisorComplementCanonicalProduct m f z₀) (Set.univ : Set ℂ) := ++ differentiableOn_divisorComplementCanonicalProduct_univ (m := m) (f := f) (z₀ := z₀) h_sum ++ have hcontC : ContinuousOn (divisorComplementCanonicalProduct m f z₀) (Metric.closedBall z₀ r) := ++ (hdiffC.continuousOn).mono (by intro z hz; simp) ++ have hK : IsCompact (Metric.closedBall z₀ r) := isCompact_closedBall _ _ ++ rcases (isBounded_iff_forall_norm_le.1 (hK.image_of_continuousOn hcontC).isBounded) with ⟨C, hC⟩ ++ refine ⟨r, hrpos, ⟨C * (‖u z₀‖ + 1), ?_⟩⟩ ++ rintro _ ⟨z, hzset, rfl⟩ ++ rcases hzset with ⟨hzr, hzne⟩ ++ have hz_in_ε : z ∈ Metric.ball z₀ ε := Metric.ball_subset_ball hr_lt_ε.le hzr ++ have hz_ne : z ≠ z₀ := by simpa [Set.mem_singleton_iff] using hzne ++ have hq : ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ) z) / ++ (z - z₀) ^ (divisorZeroIndex₀FiberFinset (f := f) z₀).card ++ = divisorComplementCanonicalProduct m f z₀ z * u z := ++ hEq z hz_in_ε hz_ne ++ have hCz : ‖divisorComplementCanonicalProduct m f z₀ z‖ ≤ C := by ++ have hzK : z ∈ Metric.closedBall z₀ r := Metric.mem_closedBall.2 (le_of_lt hzr) ++ exact hC _ ⟨z, hzK, rfl⟩ ++ have huZ : ‖u z‖ ≤ ‖u z₀‖ + 1 := huBound z hzr ++ have hCnonneg : 0 ≤ C := le_trans (norm_nonneg _) hCz ++ have hmul : ‖divisorComplementCanonicalProduct m f z₀ z * u z‖ ≤ C * (‖u z₀‖ + 1) := by ++ calc ++ ‖divisorComplementCanonicalProduct m f z₀ z * u z‖ ++ = ‖divisorComplementCanonicalProduct m f z₀ z‖ * ‖u z‖ := by simp ++ _ ≤ C * (‖u z₀‖ + 1) := by ++ exact mul_le_mul hCz huZ (norm_nonneg _) hCnonneg ++ simpa [Function.comp, hq] using hmul ++ ++theorem divisorComplementCanonicalProduct_ne_zero_at ++ (m : ℕ) (f : ℂ → ℂ) (z₀ : ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ divisorComplementCanonicalProduct m f z₀ z₀ ≠ 0 := by ++ let Φ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := ++ fun p => if divisorZeroIndex₀Val p = z₀ then (1 : ℂ) ++ else weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := fun p => Φ p - 1 ++ have hΦ_ne : ∀ p, Φ p ≠ 0 := by ++ intro p ++ by_cases hp : divisorZeroIndex₀Val p = z₀ ++ · simp [Φ, hp] ++ · have hval : divisorZeroIndex₀Val p ≠ z₀ := hp ++ have hz : z₀ / divisorZeroIndex₀Val p ≠ (1 : ℂ) := by ++ intro h ++ by_cases hp0 : divisorZeroIndex₀Val p = 0 ++ · have : z₀ / divisorZeroIndex₀Val p = (0 : ℂ) := by simp [hp0] ++ have h01 := h ++ rw [this] at h01 ++ exact (show False from (by simpa using (show (0 : ℂ) ≠ (1 : ℂ) from by simp) h01)) ++ · have : z₀ = divisorZeroIndex₀Val p := (div_eq_one_iff_eq hp0).1 h ++ exact hval this.symm ++ have hE : weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) ≠ 0 := by ++ intro h0 ++ have : z₀ / divisorZeroIndex₀Val p = (1 : ℂ) := ++ (weierstrassFactor_eq_zero_iff (m := m) (z := z₀ / divisorZeroIndex₀Val p)).1 h0 ++ exact hz this ++ simp [Φ, hp, hE] ++ have hz0_le : ‖z₀‖ ≤ max ‖z₀‖ 1 := le_max_left _ _ ++ set R : ℝ := max ‖z₀‖ 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (le_max_right _ _) ++ let u : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (4 * R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) ++ have hu : Summable u := h_sum.mul_left (4 * R ^ (m + 1)) ++ have h_big : ++ ∀ᶠ p : divisorZeroIndex₀ f (Set.univ : Set ℂ) in Filter.cofinite, ++ (2 * R : ℝ) < ‖divisorZeroIndex₀Val p‖ := by ++ have hfin : ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ ++ 2 * R} : Set _).Finite := by ++ have : Metric.closedBall (0 : ℂ) (2 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ exact divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) (B := 2 * R) this ++ have := hfin.eventually_cofinite_notMem ++ filter_upwards [this] with p hp ++ have : ¬ ‖divisorZeroIndex₀Val p‖ ≤ 2 * R := by simpa using hp ++ exact lt_of_not_ge this ++ have hBound : ++ ∀ᶠ p in Filter.cofinite, ‖a p‖ ≤ u p := by ++ filter_upwards [h_big] with p hp ++ have ha_pos : 0 < ‖divisorZeroIndex₀Val p‖ := lt_trans (by nlinarith [hRpos]) hp ++ have hz_div : ‖z₀ / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := by ++ have h2R_pos : 0 < (2 * R : ℝ) := by nlinarith [hRpos] ++ have hinv : ‖divisorZeroIndex₀Val p‖⁻¹ < (2 * R)⁻¹ := by ++ simpa [one_div] using (one_div_lt_one_div_of_lt h2R_pos hp) ++ have hmul_le : ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ ≤ R * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ refine mul_le_mul_of_nonneg_right ?_ (inv_nonneg.2 (norm_nonneg _)) ++ exact hz0_le ++ have hmul_lt : R * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ mul_lt_mul_of_pos_left hinv hRpos ++ have hlt : ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ < R * (2 * R)⁻¹ := ++ lt_of_le_of_lt hmul_le hmul_lt ++ have hRhalf : R * (2 * R)⁻¹ = (1 / 2 : ℝ) := by ++ have hRne : (R : ℝ) ≠ 0 := hRpos.ne' ++ have : R * (2 * R)⁻¹ = R / (2 * R) := by simp [div_eq_mul_inv] ++ rw [this] ++ field_simp [hRne] ++ have hnorm : ‖z₀ / divisorZeroIndex₀Val p‖ = ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ have hzlt : ‖z₀ / divisorZeroIndex₀Val p‖ < (1 / 2 : ℝ) := by ++ calc ++ ‖z₀ / divisorZeroIndex₀Val p‖ = ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := hnorm ++ _ < R * (2 * R)⁻¹ := hlt ++ _ = (1 / 2 : ℝ) := hRhalf ++ exact le_of_lt hzlt ++ have hE : ++ ‖weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) - 1‖ ≤ ++ 4 * ‖z₀ / divisorZeroIndex₀Val p‖ ^ (m + 1) := ++ weierstrassFactor_sub_one_pow_bound (m := m) (z := z₀ / divisorZeroIndex₀Val p) hz_div ++ have hz_pow : ++ ‖z₀ / divisorZeroIndex₀Val p‖ ^ (m + 1) ≤ ++ (R ^ (m + 1)) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ have : ‖z₀ / divisorZeroIndex₀Val p‖ = ‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹ := by ++ simp [div_eq_mul_inv] ++ rw [this] ++ have : (‖z₀‖ * ‖divisorZeroIndex₀Val p‖⁻¹) ^ (m + 1) = ++ ‖z₀‖ ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simp [mul_pow] ++ rw [this] ++ have hzle_pow : ‖z₀‖ ^ (m + 1) ≤ R ^ (m + 1) := ++ pow_le_pow_left₀ (norm_nonneg z₀) hz0_le (m + 1) ++ gcongr ++ have hp_ne : divisorZeroIndex₀Val p ≠ z₀ := by ++ intro h ++ have : ‖divisorZeroIndex₀Val p‖ ≤ R := by ++ simp [h, R] ++ exact (not_lt_of_ge this) (lt_trans (by nlinarith [hRpos]) hp) ++ have ha : ‖a p‖ = ‖weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) - 1‖ := by ++ simp [a, Φ, hp_ne, sub_eq_add_neg] ++ calc ++ ‖a p‖ = ‖weierstrassFactor m (z₀ / divisorZeroIndex₀Val p) - 1‖ := ha ++ _ ≤ 4 * ‖z₀ / divisorZeroIndex₀Val p‖ ^ (m + 1) := by ++ simpa [sub_eq_add_neg, add_comm] using hE ++ _ ≤ 4 * (R ^ (m + 1) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) := by ++ gcongr ++ _ = u p := by ++ simp [u, mul_assoc, mul_comm] ++ have hsum_norm : Summable (fun p => ‖a p‖) := by ++ refine (Summable.of_norm_bounded_eventually (E := ℝ) (f := fun p => ‖a p‖) (g := u) hu ?_) ++ filter_upwards [hBound] with p hp ++ simpa [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg (a p))] using hp ++ have htprod_ne : ++ (∏' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (1 + a p)) ≠ 0 := ++ tprod_one_add_ne_zero_of_summable (R := ℂ) (f := a) (hf := fun p => by ++ simpa [a, Φ, add_sub_cancel] using hΦ_ne p) hsum_norm ++ have : (∏' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (1 + a p)) = ++ divisorComplementCanonicalProduct m f z₀ z₀ := by ++ simp [a, Φ, divisorComplementCanonicalProduct, divisorComplementFactor_def] ++ exact by ++ intro h0 ++ exact htprod_ne (by simpa [this] using h0) ++ ++end Complex.Hadamard ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/Exponential.lean b/PrimeNumberTheoremAnd/SiegelZeros/Exponential.lean +new file mode 100644 +index 0000000..082148e +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/Exponential.lean +@@ -0,0 +1,722 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.ProductBounds ++ ++namespace SiegelZeros ++ ++section ++noncomputable section ++ ++namespace Complex ++namespace Hadamard ++ ++open _root_.SiegelZeros.Complex _root_.SiegelZeros.Real BigOperators ++ _root_.SiegelZeros.Finset Set Filter Topology Metric ++ ++open scoped Topology ++ ++theorem zero_free_polynomial_growth_is_exp_poly {H : ℂ → ℂ} {n : ℕ} ++ (hH : Differentiable ℂ H) ++ (h_nonzero : ∀ z, H z ≠ 0) ++ (h_bound : ∃ C > 0, ∀ z, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ n)) : ++ ∃ P : Polynomial ℂ, P.natDegree ≤ n ∧ ∀ z, H z = Complex.exp (Polynomial.eval z P) := by ++ classical ++ rcases h_bound with ⟨C, hCpos, hC⟩ ++ let L : ℂ → ℂ := fun z => deriv H z / H z ++ have hderivH : Differentiable ℂ (deriv H) := by ++ intro z ++ exact ((hH.analyticAt z).deriv).differentiableAt ++ have hL : Differentiable ℂ L := by ++ simpa [L] using! (hderivH.div hH h_nonzero) ++ let h : ℂ → ℂ := fun z => Complex.wedgeIntegral (0 : ℂ) z L ++ have hh_deriv : ∀ z, HasDerivAt h (L z) z := by ++ intro z ++ let r : ℝ := ‖z‖ + 1 ++ have hrpos : 0 < r := by ++ dsimp [r]; linarith [norm_nonneg z] ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) r := by ++ have : dist z (0 : ℂ) < r := by simp [r, dist_zero_right] ++ simpa [Metric.mem_ball] using this ++ have hconserv : Complex.IsConservativeOn L (Metric.ball (0 : ℂ) r) := ++ (hL.differentiableOn).isConservativeOn ++ have hcont : ContinuousOn L (Metric.ball (0 : ℂ) r) := ++ hL.continuous.continuousOn ++ simpa [h, r] using hconserv.hasDerivAt_wedgeIntegral (f_cont := hcont) (hz := hz_ball) ++ have hh : Differentiable ℂ h := fun z => (hh_deriv z).differentiableAt ++ have hderiv_h : ∀ z, deriv h z = L z := fun z => (hh_deriv z).deriv ++ let k : ℂ → ℂ := fun z => h z + Complex.log (H 0) ++ have hk : Differentiable ℂ k := hh.add_const (Complex.log (H 0)) ++ have hk_exp : ∀ z, H z = Complex.exp (k z) := by ++ let F : ℂ → ℂ := fun z => Complex.exp (k z) / H z ++ have hF_deriv : ∀ z, deriv F z = 0 := by ++ intro z ++ have hH_has : HasDerivAt H (deriv H z) z := (hH z).hasDerivAt ++ have hk_has : HasDerivAt k (L z) z := by ++ have hh_has : HasDerivAt h (L z) z := hh_deriv z ++ simpa [k, L] using hh_has.add_const (Complex.log (H 0)) ++ have hExp : HasDerivAt (fun w => Complex.exp (k w)) (Complex.exp (k z) * L z) z := ++ (HasDerivAt.cexp hk_has) ++ have hDiv := (HasDerivAt.div hExp hH_has (h_nonzero z)) ++ have : ++ deriv F z = ++ ((Complex.exp (k z) * L z) * H z - Complex.exp (k z) * deriv H z) / (H z) ^ 2 := by ++ simpa [F] using! hDiv.deriv ++ rw [this] ++ have hnum : ++ (Complex.exp (k z) * L z) * H z - Complex.exp (k z) * deriv H z = 0 := by ++ dsimp [L] ++ field_simp [h_nonzero z] ++ ring ++ simp [hnum] ++ have hF_diff : Differentiable ℂ F := (hk.cexp).div hH h_nonzero ++ have hF_const : ∀ z, F z = F 0 := by ++ intro z ++ exact is_const_of_deriv_eq_zero hF_diff hF_deriv z 0 ++ have hF0 : F 0 = 1 := by ++ have hh0 : h 0 = 0 := by simp [h, Complex.wedgeIntegral] ++ have hk0 : k 0 = Complex.log (H 0) := by simp [k, hh0] ++ have hH0 : H 0 ≠ 0 := h_nonzero 0 ++ simp [F, hk0, Complex.exp_log hH0, hH0] ++ intro z ++ have : F z = 1 := by simpa [hF0] using (hF_const z) ++ have hHz : H z ≠ 0 := h_nonzero z ++ have : Complex.exp (k z) / H z = 1 := by simpa [F] using this ++ have : Complex.exp (k z) = H z := by ++ field_simp [hHz] at this ++ simpa using this ++ exact this.symm ++ have hk_re_bound : ∀ z, (k z).re ≤ C * (1 + ‖z‖) ^ n := by ++ intro z ++ have hHz : H z ≠ 0 := h_nonzero z ++ have hpos : 0 < ‖H z‖ := norm_pos_iff.mpr hHz ++ have hlog_le : Real.log ‖H z‖ ≤ C * (1 + ‖z‖) ^ n := by ++ have := Real.log_le_log hpos (hC z) ++ simpa [Real.log_exp] using this ++ have hlog_eq : Real.log ‖H z‖ = (k z).re := by ++ have : ‖H z‖ = Real.exp (k z).re := by ++ simpa [hk_exp z] using (Complex.norm_exp (k z)) ++ calc ++ Real.log ‖H z‖ = Real.log (Real.exp (k z).re) := by simp [this] ++ _ = (k z).re := by simp ++ simpa [hlog_eq] using hlog_le ++ have hk_iteratedDeriv_eq_zero : ∀ m : ℕ, n < m → iteratedDeriv m k 0 = 0 := by ++ intro m hm ++ have hm' : 0 < (m - n : ℕ) := Nat.sub_pos_of_lt hm ++ have hmne : m - n ≠ 0 := (Nat.pos_iff_ne_zero.1 hm') ++ let f : ℂ → ℂ := fun z => k z - k 0 ++ have hf : Differentiable ℂ f := hk.sub_const (k 0) ++ have hf0 : f 0 = 0 := by simp [f] ++ have hf_re_bound : ∀ R : ℝ, 0 < R → ++ ∀ z, ‖z‖ ≤ R → (f z).re ≤ C * (1 + R) ^ n + ‖k 0‖ := by ++ intro R hRpos z hzR ++ have hkz : (k z).re ≤ C * (1 + ‖z‖) ^ n := hk_re_bound z ++ have hkz' : (k z).re ≤ C * (1 + R) ^ n := by ++ have h1 : (1 + ‖z‖ : ℝ) ≤ 1 + R := by linarith ++ have hpow : (1 + ‖z‖ : ℝ) ^ n ≤ (1 + R) ^ n := ++ pow_le_pow_left₀ (by linarith [norm_nonneg z]) h1 n ++ exact hkz.trans (mul_le_mul_of_nonneg_left hpow (le_of_lt hCpos)) ++ have hRe0 : -(k 0).re ≤ ‖k 0‖ := by ++ have habs : |(k 0).re| ≤ ‖k 0‖ := Complex.abs_re_le_norm (k 0) ++ have hneg : -(k 0).re ≤ |(k 0).re| := by simpa using (neg_le_abs (k 0).re) ++ exact hneg.trans habs ++ have : (f z).re ≤ C * (1 + R) ^ n + ‖k 0‖ := by ++ have : (f z).re = (k z).re - (k 0).re := by simp [f, sub_eq_add_neg] ++ nlinarith [this, hkz', hRe0] ++ exact this ++ have hf_bound_on_ball : ∀ R : ℝ, 0 < R → ++ ∀ z, ‖z‖ ≤ R / 2 → ‖f z‖ ≤ 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ intro R hRpos z hz ++ have hR2pos : 0 < R / 2 := by nlinarith ++ have hlt : R / 2 < R := by nlinarith ++ have hMpos : 0 < (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ have : 0 ≤ C * (1 + R) ^ n := by ++ refine mul_nonneg (le_of_lt hCpos) ?_ ++ exact pow_nonneg (by linarith) _ ++ nlinarith [this, norm_nonneg (k 0)] ++ have hf_anal : AnalyticOnNhd ℂ f (Metric.closedBall 0 R) := by ++ intro w _hw ++ exact (hf.analyticAt w) ++ have hf_re : ∀ w, ‖w‖ ≤ R → (f w).re ≤ (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ intro w hw ++ have := hf_re_bound R hRpos w hw ++ linarith ++ have hf_bc := ++ borelCaratheodory_zero_closedBall (f := f) (r := R / 2) (R := R) ++ (M := (C * (1 + R) ^ n + ‖k 0‖ + 1)) ++ hf_anal hR2pos hlt hMpos hf0 hf_re (z := z) hz ++ have hconst : ++ 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) * (R / 2) / (R - R / 2) ++ = 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ field_simp [hRpos.ne'] ; ring ++ simpa [hconst] using hf_bc ++ have hCauchy : ∀ R : ℝ, 0 < R → ++ ‖iteratedDeriv m f 0‖ ≤ ++ (m.factorial : ℝ) * (2 * (C * (1 + R) ^ n + ‖k 0‖ + 1)) / (R / 2) ^ m := by ++ intro R hRpos ++ have hR2pos : 0 < R / 2 := by nlinarith ++ have hf_diffCont : DiffContOnCl ℂ f (Metric.ball (0 : ℂ) (R / 2)) := hf.diffContOnCl ++ have hbound_sphere : ++ ∀ z ∈ Metric.sphere (0 : ℂ) (R / 2), ++ ‖f z‖ ≤ 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1) := by ++ intro z hz ++ have hz' : ‖z‖ ≤ R / 2 := by ++ simpa [Metric.mem_sphere, dist_zero_right] using (le_of_eq hz) ++ exact hf_bound_on_ball R hRpos z hz' ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using ++ (Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le (n := m) (c := (0 : ℂ)) ++ (R := R / 2) (C := 2 * (C * (1 + R) ^ n + ‖k 0‖ + 1)) ++ (hR := hR2pos) hf_diffCont hbound_sphere) ++ have hf_iter_eq : iteratedDeriv m f 0 = 0 := by ++ by_contra hne ++ have ha : 0 < ‖iteratedDeriv m f 0‖ := norm_pos_iff.2 hne ++ let RHS : ℝ → ℝ := fun R => ++ (m.factorial : ℝ) * (2 * (C * (1 + R) ^ n + ‖k 0‖ + 1)) / (R / 2) ^ m ++ have hle_RHS : ∀ R : ℝ, 0 < R → ‖iteratedDeriv m f 0‖ ≤ RHS R := by ++ intro R hRpos ++ simpa [RHS] using hCauchy R hRpos ++ have hRHS_tendsto : Tendsto RHS atTop (𝓝 0) := by ++ let K : ℝ := ‖k 0‖ + 1 ++ have hmpos : 0 < m := lt_of_le_of_lt (Nat.zero_le n) hm ++ have hm0 : m ≠ 0 := ne_of_gt hmpos ++ have hratio : Tendsto (fun R : ℝ => R ^ n / (R / 2) ^ m) atTop (𝓝 0) := by ++ have hident : ++ (fun R : ℝ => R ^ n / (R / 2) ^ m) = fun R : ℝ => (2 : ℝ) ^ m * (R ^ n / R ^ m) := by ++ funext R ++ simp [div_eq_mul_inv, mul_pow, mul_assoc, mul_comm] ++ have hmain : Tendsto (fun R : ℝ => R ^ n / R ^ m) atTop (𝓝 0) := by ++ have hp : m - n ≠ 0 := (Nat.pos_iff_ne_zero.1 (Nat.sub_pos_of_lt hm)) ++ have hmain' : Tendsto (fun R : ℝ => (R ^ (m - n))⁻¹) atTop (𝓝 0) := by ++ simpa using (tendsto_pow_neg_atTop (𝕜 := ℝ) (n := m - n) hp) ++ have hEq : (fun R : ℝ => (R ^ (m - n))⁻¹) =ᶠ[atTop] fun R : ℝ => R ^ n / R ^ m := by ++ have hEq' : (fun R : ℝ => R ^ n / R ^ m) =ᶠ[atTop] fun R : ℝ => (R ^ (m - n))⁻¹ := by ++ filter_upwards [eventually_ne_atTop (0 : ℝ)] with R hR ++ have hle : n ≤ m := le_of_lt hm ++ have hm_eq : n + (m - n) = m := Nat.add_sub_of_le hle ++ have hn0 : R ^ n ≠ 0 := pow_ne_zero n hR ++ calc ++ R ^ n / R ^ m = R ^ n / R ^ (n + (m - n)) := by simp [hm_eq] ++ _ = R ^ n * ((R ^ (m - n))⁻¹ * (R ^ n)⁻¹) := by ++ simp [pow_add, div_eq_mul_inv, mul_comm] ++ _ = (R ^ (m - n))⁻¹ := by ++ ring_nf ++ simp [hn0] ++ exact hEq'.symm ++ exact Filter.Tendsto.congr' hEq hmain' ++ have : Tendsto (fun R : ℝ => (2 : ℝ) ^ m * (R ^ n / R ^ m)) atTop (𝓝 ((2 : ℝ) ^ m * 0)) := ++ tendsto_const_nhds.mul hmain ++ simpa [hident] using this ++ have hinv : Tendsto (fun R : ℝ => ((R / 2) ^ m)⁻¹) atTop (𝓝 0) := by ++ have hdiv : Tendsto (fun R : ℝ => R / 2) atTop atTop := ++ (tendsto_id.atTop_div_const (r := (2 : ℝ)) (by norm_num : (0 : ℝ) < 2)) ++ have hpow : Tendsto (fun R : ℝ => (R / 2) ^ m) atTop atTop := ++ (Filter.tendsto_pow_atTop (α := ℝ) (n := m) hm0).comp hdiv ++ simpa using! hpow.inv_tendsto_atTop ++ have hdiv : Tendsto (fun R : ℝ => (1 + R) / R) atTop (𝓝 (1 : ℝ)) := by ++ have hinv' : Tendsto (fun R : ℝ => (R : ℝ)⁻¹) atTop (𝓝 (0 : ℝ)) := tendsto_inv_atTop_zero ++ have hadd : Tendsto (fun R : ℝ => (1 : ℝ) + (R : ℝ)⁻¹) atTop (𝓝 (1 : ℝ)) := by ++ simpa using (tendsto_const_nhds.add hinv') ++ have hEq : (fun R : ℝ => (1 + R) / R) =ᶠ[atTop] fun R : ℝ => (1 : ℝ) + (R : ℝ)⁻¹ := by ++ filter_upwards [eventually_ne_atTop (0 : ℝ)] with R hR ++ field_simp [hR]; ring ++ exact Filter.Tendsto.congr' hEq.symm hadd ++ have hdiv_pow : Tendsto (fun R : ℝ => ((1 + R) / R) ^ n) atTop (𝓝 (1 : ℝ)) := by ++ simpa using (hdiv.pow n) ++ have hone_add_ratio : ++ Tendsto (fun R : ℝ => (1 + R) ^ n / (R / 2) ^ m) atTop (𝓝 (0 : ℝ)) := by ++ have hEq : ++ (fun R : ℝ => (1 + R) ^ n / (R / 2) ^ m) ++ =ᶠ[atTop] fun R : ℝ => ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m) := by ++ filter_upwards [eventually_ne_atTop (0 : ℝ)] with R hR ++ have hRpow : (R ^ n : ℝ) ≠ 0 := pow_ne_zero n hR ++ have hident : ++ ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m) = (1 + R) ^ n / (R / 2) ^ m := by ++ calc ++ ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m) ++ = ((1 + R) ^ n / R ^ n) * (R ^ n / (R / 2) ^ m) := by ++ simp [div_pow] ++ _ = ((1 + R) ^ n * R ^ n) / (R ^ n * (R / 2) ^ m) := by ++ simp [div_mul_div_comm, mul_comm] ++ _ = ((1 + R) ^ n * R ^ n) / ((R / 2) ^ m * R ^ n) := by ++ simp [mul_comm] ++ _ = (1 + R) ^ n / (R / 2) ^ m := by ++ simpa [mul_assoc, mul_comm, mul_left_comm] using ++ (mul_div_mul_right (a := (1 + R) ^ n) (b := (R / 2) ^ m) hRpow) ++ exact hident.symm ++ have hmul : ++ Tendsto ++ (fun R : ℝ => ((1 + R) / R) ^ n * (R ^ n / (R / 2) ^ m)) ++ atTop (𝓝 (0 : ℝ)) := by ++ simpa [mul_zero] using (hdiv_pow.mul hratio) ++ exact Filter.Tendsto.congr' hEq.symm hmul ++ have h1 : Tendsto (fun R : ℝ => C * ((1 + R) ^ n / (R / 2) ^ m)) atTop (𝓝 0) := by ++ simpa using (tendsto_const_nhds.mul hone_add_ratio) ++ have h2 : Tendsto (fun R : ℝ => K * ((R / 2) ^ m)⁻¹) atTop (𝓝 0) := by ++ simpa using (tendsto_const_nhds.mul hinv) ++ have hsum : ++ Tendsto ++ (fun R : ℝ => C * ((1 + R) ^ n / (R / 2) ^ m) + K * ((R / 2) ^ m)⁻¹) ++ atTop (𝓝 0) := by ++ simpa using (h1.add h2) ++ have hrew : ++ (fun R : ℝ => (C * (1 + R) ^ n + K) / (R / 2) ^ m) ++ = fun R : ℝ => C * ((1 + R) ^ n / (R / 2) ^ m) + K * ((R / 2) ^ m)⁻¹ := by ++ funext R ++ simp [div_eq_mul_inv, mul_add, mul_assoc, mul_comm] ++ have hbase : Tendsto (fun R : ℝ => (C * (1 + R) ^ n + K) / (R / 2) ^ m) atTop (𝓝 0) := by ++ simpa [hrew] using hsum ++ have hconst : ++ Tendsto (fun _ : ℝ => (m.factorial : ℝ) * (2 : ℝ)) atTop ++ (𝓝 ((m.factorial : ℝ) * (2 : ℝ))) := tendsto_const_nhds ++ have hmul : Tendsto (fun R : ℝ => ((m.factorial : ℝ) * (2 : ℝ)) * ++ ((C * (1 + R) ^ n + K) / (R / 2) ^ m)) atTop (𝓝 0) := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using (hconst.mul hbase) ++ have hRHS_rw : RHS = fun R : ℝ => ((m.factorial : ℝ) * (2 : ℝ)) * ++ ((C * (1 + R) ^ n + K) / (R / 2) ^ m) := by ++ funext R ++ dsimp [RHS, K] ++ ring_nf ++ simpa [hRHS_rw] using hmul ++ have hsmall : ∀ᶠ R in atTop, RHS R < ‖iteratedDeriv m f 0‖ / 2 := ++ (tendsto_order.1 hRHS_tendsto).2 _ (half_pos ha) ++ have hle_eventually : ∀ᶠ R in atTop, ‖iteratedDeriv m f 0‖ ≤ RHS R := by ++ filter_upwards [eventually_gt_atTop (0 : ℝ)] with R hRpos ++ exact hle_RHS R hRpos ++ rcases (hle_eventually.and hsmall).exists with ⟨R, hle, hlt⟩ ++ have : ‖iteratedDeriv m f 0‖ < ‖iteratedDeriv m f 0‖ := ++ (lt_of_le_of_lt hle hlt).trans (half_lt_self ha) ++ exact lt_irrefl _ this ++ have hmpos : 0 < m := lt_of_le_of_lt (Nat.zero_le n) hm ++ have hm0 : m ≠ 0 := ne_of_gt hmpos ++ have hkcd : ContDiffAt ℂ (↑m) k (0 : ℂ) := (hk.analyticAt 0).contDiffAt ++ have hccd : ContDiffAt ℂ (↑m) (fun _ : ℂ => k 0) (0 : ℂ) := contDiffAt_const ++ have hsub : ++ iteratedDeriv m f 0 = ++ iteratedDeriv m k 0 - iteratedDeriv m (fun _ : ℂ => k 0) 0 := by ++ simpa [f] using! (iteratedDeriv_sub (n := m) (x := (0 : ℂ)) hkcd hccd) ++ have hconst0 : iteratedDeriv m (fun _ : ℂ => k 0) 0 = 0 := by ++ simp [iteratedDeriv_const, hm0] ++ have hf_eq : iteratedDeriv m f 0 = iteratedDeriv m k 0 := by ++ simp [hsub, hconst0] ++ simpa [hf_eq] using hf_iter_eq ++ let P : Polynomial ℂ := ++ ∑ m ∈ Finset.range (n + 1), Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0) ++ have hPdeg : P.natDegree ≤ n := by ++ have hnat : ++ P.natDegree ≤ ++ Finset.fold max 0 ++ (fun m : ℕ => ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree) ++ (Finset.range (n + 1)) := by ++ simpa [P, Function.comp] using ++ (Polynomial.natDegree_sum_le (s := Finset.range (n + 1)) ++ (f := fun m : ℕ => ++ Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0))) ++ have hfold : ++ Finset.fold max 0 ++ (fun m : ℕ => ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree) ++ (Finset.range (n + 1)) ≤ n := by ++ refine (Finset.fold_max_le (f := fun m : ℕ => ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree) ++ (b := 0) (s := Finset.range (n + 1)) (c := n)).2 ?_ ++ refine ⟨Nat.zero_le n, ?_⟩ ++ intro m hm ++ have hmon : ++ (Polynomial.monomial m ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0)).natDegree ≤ m := ++ Polynomial.natDegree_monomial_le _ ++ have hm_le : m ≤ n := Nat.le_of_lt_succ (Finset.mem_range.1 hm) ++ exact hmon.trans hm_le ++ exact hnat.trans hfold ++ have hk_poly : ∀ z, k z = Polynomial.eval z P := by ++ intro z ++ have htaylor := Complex.taylorSeries_eq_of_entire' (c := (0 : ℂ)) (z := z) hk ++ have htail : ∀ m : ℕ, m ∉ Finset.range (n + 1) → ++ ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * (z - 0) ^ m) = 0 := by ++ intro m hm' ++ have hmgt : n < m := by ++ have : n + 1 ≤ m := Nat.le_of_not_lt (by simpa [Finset.mem_range] using hm') ++ exact Nat.lt_of_lt_of_le (Nat.lt_succ_self n) this ++ have hz : iteratedDeriv m k 0 = 0 := hk_iteratedDeriv_eq_zero m hmgt ++ simp [hz] ++ have htsum : ++ (∑' m : ℕ, (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * (z - 0) ^ m) ++ = ∑ m ∈ Finset.range (n + 1), (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * z ^ m := by ++ simpa [sub_zero] using (tsum_eq_sum (s := Finset.range (n + 1)) htail) ++ have hfinite : ++ k z = ∑ m ∈ Finset.range (n + 1), (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * z ^ m := by ++ calc ++ k z = ∑' m : ℕ, (m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0 * (z - 0) ^ m := by ++ simpa using htaylor.symm ++ _ = _ := htsum ++ have hEval : ++ Polynomial.eval z P = ++ ∑ m ∈ Finset.range (n + 1), z ^ m * ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0) := by ++ classical ++ change Polynomial.eval₂ (RingHom.id ℂ) z P = _ ++ let φ : Polynomial ℂ →+* ℂ := Polynomial.eval₂RingHom (RingHom.id ℂ) z ++ change φ P = _ ++ simp [P, φ, Polynomial.eval₂_monomial, mul_comm] ++ have hfinite' : ++ k z = ∑ m ∈ Finset.range (n + 1), z ^ m * ((m.factorial : ℂ)⁻¹ * iteratedDeriv m k 0) := by ++ simpa [mul_comm, mul_left_comm, mul_assoc] using hfinite ++ simpa [hEval] using hfinite' ++ refine ⟨P, hPdeg, ?_⟩ ++ intro z ++ have : H z = Complex.exp (k z) := by simp [hk_exp z] ++ simp [this, hk_poly z] ++ ++end Hadamard ++end Complex ++end ++end ++section ++noncomputable section ++ ++namespace Complex ++namespace Hadamard ++ ++open _root_.SiegelZeros.Complex _root_.SiegelZeros.Real BigOperators ++ _root_.SiegelZeros.Finset Set Filter Topology Metric ++ ++open scoped Topology ++ ++open Polynomial ++ ++private lemma exists_pow_eq_complex {n : ℕ} (hn : 0 < n) (w : ℂ) : ∃ z : ℂ, z ^ n = w := by ++ classical ++ by_cases hw : w = 0 ++ · subst hw ++ refine ⟨0, ?_⟩ ++ have hn0 : n ≠ 0 := Nat.ne_of_gt hn ++ simp [hn0] ++ · refine ⟨Complex.exp (Complex.log w / n), ?_⟩ ++ have hn0 : (n : ℂ) ≠ 0 := by ++ exact_mod_cast (Nat.ne_of_gt hn) ++ calc ++ (Complex.exp (Complex.log w / n)) ^ n ++ = Complex.exp ((n : ℂ) * (Complex.log w / n)) := by ++ simpa using (Complex.exp_nat_mul (Complex.log w / n) n).symm ++ _ = Complex.exp (Complex.log w) := by ++ have : (n : ℂ) * (Complex.log w / n) = Complex.log w := by ++ field_simp [hn0] ++ simp [this] ++ _ = w := by simpa using (Complex.exp_log hw) ++ ++private lemma mul_conj_div_norm (a : ℂ) (ha : a ≠ 0) : ++ a * ((starRingEnd ℂ) a / (‖a‖ : ℂ)) = (‖a‖ : ℂ) := by ++ have hnorm_pos : 0 < ‖a‖ := norm_pos_iff.mpr ha ++ have hnorm_ne : (‖a‖ : ℂ) ≠ 0 := by ++ exact_mod_cast (ne_of_gt hnorm_pos) ++ have hmul : a * (starRingEnd ℂ) a = (Complex.normSq a : ℂ) := ++ Complex.mul_conj a ++ have hcast : (Complex.normSq a : ℂ) = ((‖a‖ ^ 2 : ℝ) : ℂ) := by ++ exact_mod_cast (Complex.normSq_eq_norm_sq a) ++ have hdiv : ((‖a‖ ^ 2 : ℝ) : ℂ) / (‖a‖ : ℂ) = (‖a‖ : ℂ) := by ++ have : ((‖a‖ ^ 2 : ℝ) : ℂ) = (‖a‖ : ℂ) * (‖a‖ : ℂ) := by ++ simp [pow_two] ++ calc ++ ((‖a‖ ^ 2 : ℝ) : ℂ) / (‖a‖ : ℂ) ++ = ((‖a‖ : ℂ) * (‖a‖ : ℂ)) / (‖a‖ : ℂ) := by simp [this] ++ _ = (‖a‖ : ℂ) := by ++ field_simp [hnorm_ne] ++ calc ++ a * ((starRingEnd ℂ) a / (‖a‖ : ℂ)) ++ = (a * (starRingEnd ℂ) a) / (‖a‖ : ℂ) := by ++ simp [div_eq_mul_inv, mul_assoc] ++ _ = (Complex.normSq a : ℂ) / (‖a‖ : ℂ) := by simp [hmul] ++ _ = ((‖a‖ ^ 2 : ℝ) : ℂ) / (‖a‖ : ℂ) := by simp [hcast] ++ _ = (‖a‖ : ℂ) := hdiv ++ ++private lemma exists_z_norm_eq_re_eval_ge ++ (P : Polynomial ℂ) (hn : 0 < P.natDegree) : ++ ∃ R0 : ℝ, 0 < R0 ∧ ++ ∀ R : ℝ, R0 ≤ R → ++ ∃ z : ℂ, ‖z‖ = R ∧ ++ (‖P.leadingCoeff‖ / 2) * R ^ P.natDegree ≤ (P.eval z).re := by ++ classical ++ set n : ℕ := P.natDegree ++ have hn0 : 0 < n := hn ++ have hP0 : P ≠ 0 := by ++ intro h0 ++ simp [n, h0] at hn0 ++ have hLC : P.leadingCoeff ≠ 0 := Polynomial.leadingCoeff_ne_zero.mpr hP0 ++ set a : ℂ := P.leadingCoeff ++ have ha : a ≠ 0 := hLC ++ have hnorm_a_pos : 0 < ‖a‖ := norm_pos_iff.mpr ha ++ set wtarget : ℂ := (starRingEnd ℂ) a / (‖a‖ : ℂ) ++ have hwtarget_norm : ‖wtarget‖ = (1 : ℝ) := by ++ calc ++ ‖wtarget‖ = ‖(starRingEnd ℂ) a‖ / ‖(‖a‖ : ℂ)‖ := by ++ simp [wtarget] ++ _ = ‖a‖ / ‖a‖ := by simp ++ _ = (1 : ℝ) := by ++ field_simp [hnorm_a_pos.ne'] ++ rcases exists_pow_eq_complex (n := n) hn0 (w := wtarget) with ⟨w, hw⟩ ++ have hw_norm : ‖w‖ = (1 : ℝ) := by ++ have hpow : (‖w‖ : ℝ) ^ n = 1 := by ++ have := congrArg (fun z : ℂ => ‖z‖) hw ++ simpa [norm_pow, hwtarget_norm] using this ++ have hn0' : n ≠ 0 := Nat.ne_of_gt hn0 ++ exact (pow_eq_one_iff_of_nonneg (norm_nonneg w) hn0').1 hpow ++ set S : ℝ := ∑ i ∈ Finset.range n, ‖P.coeff i‖ ++ set R0 : ℝ := max 1 (2 * S / ‖a‖) ++ refine ⟨R0, ?_, ?_⟩ ++ · have : (0 : ℝ) < (1 : ℝ) := by norm_num ++ exact lt_of_lt_of_le this (le_max_left _ _) ++ · intro R hR ++ have hR_ge1 : (1 : ℝ) ≤ R := by ++ exact le_trans (le_max_left _ _) hR ++ have hR_nonneg : 0 ≤ R := le_trans (by norm_num) hR_ge1 ++ set z : ℂ := (R : ℂ) * w ++ have hz_norm : ‖z‖ = R := by ++ have : ‖z‖ = |R| * ‖w‖ := by ++ simp [z] ++ simp [this, hw_norm, abs_of_nonneg hR_nonneg] ++ have h_eval : P.eval z = ++ (∑ i ∈ Finset.range n, P.coeff i * z ^ i) + P.coeff n * z ^ n := by ++ have hsum : P.eval z = ∑ i ∈ Finset.range (n + 1), P.coeff i * z ^ i := by ++ have : P.natDegree + 1 = n + 1 := by simp [n] ++ simpa [this] using (Polynomial.eval_eq_sum_range (p := P) z) ++ have hsplit : ++ (∑ i ∈ Finset.range (n + 1), P.coeff i * z ^ i) ++ = (∑ i ∈ Finset.range n, P.coeff i * z ^ i) + P.coeff n * z ^ n := by ++ simpa using (Finset.sum_range_succ (f := fun i => P.coeff i * z ^ i) n) ++ exact hsum.trans hsplit ++ have h_lower_norm : ++ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ≤ S * R ^ (n - 1) := by ++ have h1 : ++ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ++ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ := by ++ simpa using (norm_sum_le (Finset.range n) (fun i => P.coeff i * z ^ i)) ++ have hterm : ∀ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ ≤ ‖P.coeff i‖ * R ^ (n - 1) := by ++ intro i hi ++ have hi_lt : i < n := Finset.mem_range.mp hi ++ have hi_le : i ≤ n - 1 := Nat.le_pred_of_lt hi_lt ++ have hzpow : ‖z‖ ^ i ≤ R ^ (n - 1) := by ++ have hmono : ‖z‖ ^ i ≤ ‖z‖ ^ (n - 1) := ++ pow_le_pow_right₀ (by simpa [hz_norm] using hR_ge1) hi_le ++ simpa [hz_norm] using hmono ++ calc ++ ‖P.coeff i * z ^ i‖ = ‖P.coeff i‖ * ‖z‖ ^ i := by ++ simp [norm_pow] ++ _ ≤ ‖P.coeff i‖ * R ^ (n - 1) := by ++ exact mul_le_mul_of_nonneg_left hzpow (norm_nonneg _) ++ have h2 : ++ ∑ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ ++ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i‖ * R ^ (n - 1) := by ++ exact Finset.sum_le_sum (fun i hi => hterm i hi) ++ have h3 : ++ (∑ i ∈ Finset.range n, ‖P.coeff i‖ * R ^ (n - 1)) ++ = (∑ i ∈ Finset.range n, ‖P.coeff i‖) * R ^ (n - 1) := by ++ simp [Finset.sum_mul] ++ have hsum_le : (∑ i ∈ Finset.range n, ‖P.coeff i‖) ≤ S := by ++ simp [S] ++ calc ++ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ++ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i * z ^ i‖ := h1 ++ _ ≤ ∑ i ∈ Finset.range n, ‖P.coeff i‖ * R ^ (n - 1) := h2 ++ _ = (∑ i ∈ Finset.range n, ‖P.coeff i‖) * R ^ (n - 1) := h3 ++ _ ≤ S * R ^ (n - 1) := by ++ exact mul_le_mul_of_nonneg_right hsum_le (pow_nonneg hR_nonneg _) ++ have h_lead_re : (P.coeff n * z ^ n).re = ‖a‖ * R ^ n := by ++ have hw_pow : w ^ n = wtarget := hw ++ have ha_mul : a * w ^ n = (‖a‖ : ℂ) := by ++ have : a * w ^ n = a * wtarget := by simp [hw_pow] ++ simpa [wtarget, a] using (this.trans (mul_conj_div_norm a ha)) ++ have hz_pow : z ^ n = ((R : ℂ) ^ n) * (w ^ n) := by ++ simp [z, mul_pow, mul_comm] ++ have hcoeffn : P.coeff n = a := by simp [a, n, Polynomial.coeff_natDegree] ++ have hreR : ∀ m : ℕ, (((R : ℂ) ^ m).re) = R ^ m := by ++ intro m ++ induction m with ++ | zero => simp ++ | succ m ih => ++ simp [pow_succ, ih, Complex.mul_re] ++ calc ++ (P.coeff n * z ^ n).re ++ = (a * z ^ n).re := by simp [hcoeffn] ++ _ = (a * (((R : ℂ) ^ n) * (w ^ n))).re := by simp [hz_pow] ++ _ = (((R : ℂ) ^ n) * (a * (w ^ n))).re := by ++ ring_nf ++ _ = (((R : ℂ) ^ n) * (‖a‖ : ℂ)).re := by simp [ha_mul] ++ _ = (((R : ℂ) ^ n).re) * ‖a‖ := by ++ simp [Complex.mul_re] ++ _ = (R ^ n) * ‖a‖ := by simp [hreR n] ++ _ = ‖a‖ * R ^ n := by ring ++ refine ⟨z, hz_norm, ?_⟩ ++ have hre_lower : (∑ i ∈ Finset.range n, P.coeff i * z ^ i).re ++ ≥ -‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := by ++ have habs : |(∑ i ∈ Finset.range n, P.coeff i * z ^ i).re| ++ ≤ ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := ++ Complex.abs_re_le_norm _ ++ have := neg_le_of_abs_le habs ++ simpa using this ++ have hre_main : ++ (P.eval z).re ≥ (P.coeff n * z ^ n).re - ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := by ++ have : (P.eval z).re = ++ (∑ i ∈ Finset.range n, P.coeff i * z ^ i).re + (P.coeff n * z ^ n).re := by ++ simp [h_eval, add_comm] ++ linarith [this, hre_lower] ++ have hR_ge_R0 : R0 ≤ R := hR ++ have hR_ge : 2 * S / ‖a‖ ≤ R := le_trans (le_max_right _ _) hR_ge_R0 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR_ge1 ++ have hR_nonneg' : 0 ≤ R := le_of_lt hRpos ++ have hn_ge1 : 1 ≤ n := Nat.succ_le_of_lt hn0 ++ have hlower_le : S * R ^ (n - 1) ≤ (‖a‖ / 2) * R ^ n := by ++ have ha_pos : 0 < ‖a‖ := hnorm_a_pos ++ have hS_le : S ≤ (‖a‖ / 2) * R := by ++ have : 2 * S ≤ ‖a‖ * R := by ++ have := (mul_le_mul_of_nonneg_left hR_ge (by linarith [ha_pos.le] : (0 : ℝ) ≤ ‖a‖)) ++ have hne : (‖a‖ : ℝ) ≠ 0 := ne_of_gt ha_pos ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm, hne] using this ++ have : S ≤ (‖a‖ * R) / 2 := by linarith ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using this ++ have : S * R ^ (n - 1) ≤ (‖a‖ / 2) * R * R ^ (n - 1) := by ++ have hpow_nonneg : 0 ≤ R ^ (n - 1) := pow_nonneg hR_nonneg' _ ++ exact mul_le_mul_of_nonneg_right hS_le hpow_nonneg ++ have hRR : R * R ^ (n - 1) = R ^ n := by ++ have : n = (n - 1) + 1 := by ++ exact (Nat.sub_add_cancel hn_ge1).symm ++ rw [this, pow_succ] ++ ring_nf; grind ++ simpa [mul_assoc, hRR] using this ++ have hfinal_re : ++ (‖a‖ / 2) * R ^ n ≤ (P.eval z).re := by ++ have hlower' : ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ≤ (‖a‖ / 2) * R ^ n := by ++ exact h_lower_norm.trans hlower_le ++ have hlead : (P.coeff n * z ^ n).re = ‖a‖ * R ^ n := by simpa [a] using h_lead_re ++ have hre_main' : ++ (‖a‖ * R ^ n) - ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ ≤ (P.eval z).re := by ++ simpa [hlead] using hre_main ++ have hsub : ++ (‖a‖ * R ^ n) - (‖a‖ / 2) * R ^ n ≤ ++ (‖a‖ * R ^ n) - ‖∑ i ∈ Finset.range n, P.coeff i * z ^ i‖ := ++ sub_le_sub_left hlower' (‖a‖ * R ^ n) ++ have hsim : (‖a‖ * R ^ n) - (‖a‖ / 2) * R ^ n = (‖a‖ / 2) * R ^ n := by ring ++ have : (‖a‖ * R ^ n) - (‖a‖ / 2) * R ^ n ≤ (P.eval z).re := ++ hsub.trans hre_main' ++ simpa [hsim] using this ++ simpa [a, n] using hfinal_re ++ ++theorem natDegree_le_floor_of_growth_exp_eval ++ {ρ : ℝ} (hρ : 0 ≤ ρ) (P : Polynomial ℂ) ++ (hgrowth : ++ ∃ C > 0, ∀ z : ℂ, ++ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ P.natDegree ≤ Nat.floor ρ := by ++ classical ++ by_cases hdeg : P.natDegree = 0 ++ · simp [hdeg] ++ · have hnpos : 0 < P.natDegree := Nat.pos_of_ne_zero hdeg ++ rcases exists_z_norm_eq_re_eval_ge (P := P) hnpos with ⟨R0, hR0pos, hray⟩ ++ rcases hgrowth with ⟨C, hCpos, hC⟩ ++ have hLCpos : 0 < ‖P.leadingCoeff‖ := by ++ have hP0 : P ≠ 0 := by ++ intro h0 ++ simp [h0] at hdeg ++ have : P.leadingCoeff ≠ 0 := (Polynomial.leadingCoeff_ne_zero).2 hP0 ++ exact norm_pos_iff.2 this ++ let c : ℝ := ‖P.leadingCoeff‖ / 2 ++ have hcpos : 0 < c := by ++ have : (0 : ℝ) < (2 : ℝ) := by norm_num ++ exact (div_pos hLCpos this) ++ have hn_le_real : (P.natDegree : ℝ) ≤ ρ := by ++ by_contra hnlt ++ have hnlt' : ρ < (P.natDegree : ℝ) := lt_of_not_ge hnlt ++ let δ : ℝ := (P.natDegree : ℝ) - ρ ++ have hδ : 0 < δ := sub_pos.2 hnlt' ++ let K0 : ℝ := (C * (2 : ℝ) ^ ρ) / c ++ have hK0 : ∃ R1, ∀ R ≥ R1, K0 + 1 ≤ R ^ δ := by ++ have h : ∀ᶠ R in (atTop : Filter ℝ), K0 + 1 ≤ R ^ δ := ++ (tendsto_atTop.mp (tendsto_rpow_atTop hδ)) (K0 + 1) ++ rcases (eventually_atTop.1 h) with ⟨R1, hR1⟩ ++ exact ⟨R1, hR1⟩ ++ rcases hK0 with ⟨R1, hR1⟩ ++ set R : ℝ := max (max R0 1) R1 ++ have hR_ge_R0 : R0 ≤ R := le_trans (le_max_left _ _) (le_max_left _ _) ++ have hR_ge1 : (1 : ℝ) ≤ R := le_trans (le_max_right _ _) (le_max_left _ _) ++ have hR_ge_R1 : R1 ≤ R := le_max_right _ _ ++ have hR_pos : 0 < R := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hR_ge1 ++ have hRδ : K0 + 1 ≤ R ^ δ := hR1 R hR_ge_R1 ++ rcases hray R hR_ge_R0 with ⟨z, hz_norm, hz_re⟩ ++ have hlog_lower : ++ (P.eval z).re ≤ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) := by ++ have hpos : 0 < ‖Complex.exp (Polynomial.eval z P)‖ := by ++ simp ++ have hle : ++ ‖Complex.exp (Polynomial.eval z P)‖ ≤ ++ 1 + ‖Complex.exp (Polynomial.eval z P)‖ := by ++ linarith [norm_nonneg (Complex.exp (Polynomial.eval z P))] ++ have hlog_le : Real.log ‖Complex.exp (Polynomial.eval z P)‖ ++ ≤ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) := ++ Real.log_le_log hpos hle ++ have hlog_eq : Real.log ‖Complex.exp (Polynomial.eval z P)‖ = (P.eval z).re := by ++ simp [Complex.norm_exp] ++ simpa [hlog_eq] using hlog_le ++ have hlog_upper : ++ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) ≤ C * (1 + ‖z‖) ^ ρ := ++ hC z ++ have hmain : c * R ^ (P.natDegree : ℝ) ≤ C * (1 + R) ^ ρ := by ++ have hz_re' : c * R ^ P.natDegree ≤ (P.eval z).re := by ++ simpa [c] using hz_re ++ have hz_re'' : c * R ^ (P.natDegree : ℝ) ≤ (P.eval z).re := by ++ simpa [Real.rpow_natCast, c] using hz_re' ++ have : c * R ^ (P.natDegree : ℝ) ≤ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) := ++ hz_re''.trans hlog_lower ++ have : c * R ^ (P.natDegree : ℝ) ≤ C * (1 + ‖z‖) ^ ρ := ++ this.trans hlog_upper ++ simpa [hz_norm] using this ++ have h1R_le : (1 + R : ℝ) ≤ R * 2 := by linarith ++ have hpow1 : (1 + R : ℝ) ^ ρ ≤ (R * 2) ^ ρ := ++ Real.rpow_le_rpow (by linarith [hR_pos.le]) h1R_le hρ ++ have hR2 : (R * 2) ^ ρ = R ^ ρ * (2 : ℝ) ^ ρ := by ++ have hRnonneg : 0 ≤ R := le_of_lt hR_pos ++ have h2nonneg : 0 ≤ (2 : ℝ) := by norm_num ++ simpa [mul_assoc] using (Real.mul_rpow hRnonneg h2nonneg (z := ρ)) ++ have hmain' : c * R ^ (P.natDegree : ℝ) ≤ C * (R ^ ρ * (2 : ℝ) ^ ρ) := by ++ have := le_trans hmain (mul_le_mul_of_nonneg_left hpow1 (le_of_lt hCpos)) ++ simpa [hR2, mul_assoc, mul_left_comm, mul_comm] using this ++ have hRρ_pos : 0 < R ^ ρ := Real.rpow_pos_of_pos hR_pos _ ++ have hRρ_ne : (R ^ ρ : ℝ) ≠ 0 := ne_of_gt hRρ_pos ++ have hdiv : ++ (c * R ^ (P.natDegree : ℝ)) / (R ^ ρ) ≤ C * (2 : ℝ) ^ ρ := by ++ have h := ++ div_le_div_of_nonneg_right hmain' (le_of_lt hRρ_pos) ++ have hRhs : (C * (R ^ ρ * (2 : ℝ) ^ ρ)) / (R ^ ρ) = C * (2 : ℝ) ^ ρ := by ++ field_simp [hRρ_ne] ++ simpa [hRhs, mul_assoc, mul_left_comm, mul_comm] using h ++ have hRsub : R ^ δ = R ^ (P.natDegree : ℝ) / R ^ ρ := by ++ simpa [δ] using (Real.rpow_sub hR_pos (P.natDegree : ℝ) ρ) ++ have hRδ_le : c * (R ^ δ) ≤ C * (2 : ℝ) ^ ρ := by ++ have hLhs : c * (R ^ δ) = (c * R ^ (P.natDegree : ℝ)) / (R ^ ρ) := by ++ simp [hRsub, div_eq_mul_inv, mul_left_comm, mul_comm] ++ simpa [hLhs] using hdiv ++ have hRδ_le' : R ^ δ ≤ K0 := by ++ have : R ^ δ ≤ (C * (2 : ℝ) ^ ρ) / c := by ++ refine (le_div_iff₀ hcpos).2 ?_ ++ simpa [mul_assoc, mul_left_comm, mul_comm] using hRδ_le ++ simpa [K0] using this ++ have : K0 + 1 ≤ K0 := le_trans hRδ (le_trans hRδ_le' (le_rfl)) ++ exact (not_lt_of_ge this) (lt_add_of_pos_right _ (by norm_num : (0 : ℝ) < 1)) ++ exact (Nat.le_floor_iff hρ).2 hn_le_real ++ ++theorem natDegree_le_floor_of_exp_eval_norm_bound {τ : ℝ} (hτ : 0 ≤ τ) (P : Polynomial ℂ) ++ (hbound : ++ ∃ C > 0, ∀ z : ℂ, ++ ‖Complex.exp (Polynomial.eval z P)‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ)) : ++ P.natDegree ≤ Nat.floor τ := by ++ rcases hbound with ⟨C, hCpos, hC⟩ ++ have hlog_growth : ++ ∃ C > 0, ∀ z : ℂ, ++ Real.log (1 + ‖Complex.exp (Polynomial.eval z P)‖) ≤ C * (1 + ‖z‖) ^ τ := ++ Real.log_growth_of_norm_le_exp_mul_rpow ++ (f := fun z : ℂ => Complex.exp (Polynomial.eval z P)) ++ (r := fun z : ℂ => 1 + ‖z‖) hCpos hτ ++ (fun z => by linarith [norm_nonneg z]) hC ++ exact natDegree_le_floor_of_growth_exp_eval (ρ := τ) hτ P hlog_growth ++ ++end Hadamard ++end Complex ++end ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/Factorization.lean b/PrimeNumberTheoremAnd/SiegelZeros/Factorization.lean +new file mode 100644 +index 0000000..8fb7d8e +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/Factorization.lean +@@ -0,0 +1,415 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.DivisorLimits ++ ++namespace SiegelZeros ++ ++section ++namespace Complex.Hadamard ++ ++open Filter Topology Set _root_.SiegelZeros.Complex ++ ++open scoped BigOperators Topology ++ ++noncomputable def hadamardDenom (m : ℕ) (f : ℂ → ℂ) (z : ℂ) : ℂ := ++ z ^ (analyticOrderNatAt f 0) * divisorCanonicalProduct m f (Set.univ : Set ℂ) z ++ ++theorem differentiable_divisorCanonicalProduct_univ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ intro z ++ have hdiffOn : ++ DifferentiableOn ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) (Set.univ : Set ℂ) := ++ differentiableOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ exact (hdiffOn z (by simp)).differentiableAt (by simp) ++ ++theorem analyticAt_divisorCanonicalProduct_univ (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) (z : ℂ) : ++ AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := ++ (differentiable_divisorCanonicalProduct_univ m f h_sum).analyticAt z ++ ++theorem differentiable_hadamardDenom (m : ℕ) (f : ℂ → ℂ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ Differentiable ℂ (hadamardDenom m f) := by ++ have hcprod : Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ exact differentiable_divisorCanonicalProduct_univ m f h_sum ++ simpa [hadamardDenom] using! (differentiable_id.pow (analyticOrderNatAt f 0)).mul hcprod ++ ++theorem hadamardDenom_ne_zero_at {m : ℕ} {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) {z : ℂ} (hz : f z ≠ 0) : hadamardDenom m f z ≠ 0 := by ++ have hf_not_top : ∀ w : ℂ, analyticOrderAt f w ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hf) hnot ++ have han_f : AnalyticAt ℂ f z := hf.analyticAt z ++ have horder_f : analyticOrderNatAt f z = 0 := by ++ have : analyticOrderAt f z = 0 := (han_f.analyticOrderAt_eq_zero).2 hz ++ have hcast : (analyticOrderNatAt f z : ℕ∞) = analyticOrderAt f z := ++ Nat.cast_analyticOrderNatAt (f := f) (z₀ := z) (hf_not_top z) ++ have : (analyticOrderNatAt f z : ℕ∞) = 0 := by simp [hcast, this] ++ exact_mod_cast this ++ have han_cprod : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := by ++ exact analyticAt_divisorCanonicalProduct_univ m f h_sum z ++ by_cases hz0 : z = 0 ++ · subst hz0 ++ have hord0 : analyticOrderNatAt f 0 = 0 := by simpa using horder_f ++ simp [hadamardDenom, hord0, divisorCanonicalProduct_zero] ++ · have hp : z ^ (analyticOrderNatAt f 0) ≠ 0 := pow_ne_zero _ hz0 ++ have hcprod_order : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z = 0 := by ++ simpa [horder_f] using ++ (analyticOrderNatAt_divisorCanonicalProduct_eq_analyticOrderNatAt (m := m) (hf := hf) ++ (h_sum := h_sum) (z₀ := z) hz0) ++ have hcprod_ne : divisorCanonicalProduct m f (Set.univ : Set ℂ) z ≠ 0 := by ++ have hcprod_entire : ++ Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ exact differentiable_divisorCanonicalProduct_univ m f h_sum ++ have hcprod_not_top : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hcprod_entire) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ z ++ have hcprod_cast : ++ (analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z : ℕ∞) = ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := ++ Nat.cast_analyticOrderNatAt ++ (f := divisorCanonicalProduct m f (Set.univ : Set ℂ)) (z₀ := z) hcprod_not_top ++ have : analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z = 0 := by ++ have : ++ (analyticOrderNatAt ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z : ℕ∞) = 0 := by ++ exact_mod_cast hcprod_order ++ simp [hcprod_cast] at this ++ simpa using this ++ exact (han_cprod.analyticOrderAt_eq_zero).1 this ++ exact mul_ne_zero hp hcprod_ne ++ ++lemma analyticOrderNatAt_divisorCanonicalProduct_zero ++ (m : ℕ) (f : ℂ → ℂ) (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 = 0 := by ++ have hcprod_entire : ++ Differentiable ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) := by ++ exact differentiable_divisorCanonicalProduct_univ m f h_sum ++ have hcprod_not_top : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (hf := hcprod_entire) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ 0 ++ have hcprodA : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := ++ hcprod_entire.analyticAt 0 ++ have hcprod0 : divisorCanonicalProduct m f (Set.univ : Set ℂ) 0 ≠ 0 := by ++ simp [divisorCanonicalProduct_zero] ++ have : analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 = 0 := ++ (hcprodA.analyticOrderAt_eq_zero).2 hcprod0 ++ have hcast : ++ (analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 : ℕ∞) = ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := ++ Nat.cast_analyticOrderNatAt ++ (f := divisorCanonicalProduct m f (Set.univ : Set ℂ)) (z₀ := (0 : ℂ)) hcprod_not_top ++ have : ++ (analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 : ℕ∞) = ++ 0 := by ++ simp [hcast, this] ++ exact_mod_cast this ++ ++theorem analyticOrderNatAt_hadamardDenom_eq ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) (z : ℂ) : ++ analyticOrderNatAt (hadamardDenom m f) z = analyticOrderNatAt f z := by ++ by_cases hz0 : z = 0 ++ · subst hz0 ++ have hpowA : AnalyticAt ℂ (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 := by ++ simpa using! (analyticAt_id.pow (analyticOrderNatAt f 0)) ++ have hpow_not_top : ++ analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := (differentiable_id.pow (analyticOrderNatAt f 0))) ++ ⟨1, by simp⟩ 0 ++ have hcprodA : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := by ++ exact analyticAt_divisorCanonicalProduct_univ m f h_sum 0 ++ have hcprod0 : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 = 0 := ++ analyticOrderNatAt_divisorCanonicalProduct_zero (m := m) (f := f) h_sum ++ have hid0 : analyticOrderNatAt (fun z : ℂ => z) 0 = 1 := by ++ have hid_entire : Differentiable ℂ (fun z : ℂ => z) := differentiable_id ++ have hdiv : ++ (MeromorphicOn.divisor (fun z : ℂ => z) (Set.univ : Set ℂ)) 0 = ++ (analyticOrderNatAt (fun z : ℂ => z) 0 : ℤ) := by ++ simpa using ++ (divisor_univ_eq_analyticOrderNatAt_int ++ (f := fun z : ℂ => z) hid_entire 0) ++ have hdiv1 : (MeromorphicOn.divisor (fun z : ℂ => z) (Set.univ : Set ℂ)) 0 = 1 := by ++ simpa using ++ (MeromorphicOn.divisor_sub_const_self (z₀ := (0 : ℂ)) ++ (U := (Set.univ : Set ℂ)) (by simp)) ++ have : (analyticOrderNatAt (fun z : ℂ => z) 0 : ℤ) = 1 := by ++ simpa [hdiv] using hdiv1 ++ exact_mod_cast this ++ have hpow0 : ++ analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 = ++ analyticOrderNatAt f 0 := by ++ have hidA : AnalyticAt ℂ (fun z : ℂ => z) 0 := by ++ simpa [id] using! (analyticAt_id : AnalyticAt ℂ (id : ℂ → ℂ) 0) ++ simpa [hid0] using! (analyticOrderNatAt_pow (hf := hidA) (n := analyticOrderNatAt f 0)) ++ have hmul : ++ analyticOrderNatAt (hadamardDenom m f) 0 = ++ analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) 0 + ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 := by ++ have hcprod_not_top' : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) 0 ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := differentiable_divisorCanonicalProduct_univ m f h_sum) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ 0 ++ simpa [hadamardDenom] using! ++ analyticOrderNatAt_mul (hf := hpowA) (hg := hcprodA) ++ (hf' := hpow_not_top) (hg' := hcprod_not_top') ++ simp [hmul, hpow0, hcprod0] ++ · have hpowA : AnalyticAt ℂ (fun z : ℂ => z ^ analyticOrderNatAt f 0) z := by ++ simpa using! (analyticAt_id.pow (analyticOrderNatAt f 0)) ++ have hpow_not_top : ++ analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := (differentiable_id.pow (analyticOrderNatAt f 0))) ++ ⟨1, by simp⟩ z ++ have hpow0 : analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z = 0 := by ++ have hz' : (fun z : ℂ => z ^ analyticOrderNatAt f 0) z ≠ 0 := by ++ simp [hz0] ++ have : analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z = 0 := ++ ((hpowA).analyticOrderAt_eq_zero).2 hz' ++ have hcast : (analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z : ℕ∞) = ++ analyticOrderAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z := ++ Nat.cast_analyticOrderNatAt ++ (f := fun z : ℂ => z ^ analyticOrderNatAt f 0) (z₀ := z) hpow_not_top ++ have : (analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z : ℕ∞) = 0 := by ++ simp [hcast, this] ++ exact_mod_cast this ++ have hcprod_eq : ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z = ++ analyticOrderNatAt f z := ++ analyticOrderNatAt_divisorCanonicalProduct_eq_analyticOrderNatAt ++ (m := m) (hf := hf) (h_sum := h_sum) (z₀ := z) hz0 ++ have hcprodA : AnalyticAt ℂ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := by ++ exact analyticAt_divisorCanonicalProduct_univ m f h_sum z ++ have hcprod_not_top : ++ analyticOrderAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero ++ (hf := differentiable_divisorCanonicalProduct_univ m f h_sum) ++ ⟨0, by simp [divisorCanonicalProduct_zero]⟩ z ++ have hmul : ++ analyticOrderNatAt (hadamardDenom m f) z = ++ analyticOrderNatAt (fun z : ℂ => z ^ analyticOrderNatAt f 0) z + ++ analyticOrderNatAt (divisorCanonicalProduct m f (Set.univ : Set ℂ)) z := by ++ simpa [hadamardDenom] using! ++ analyticOrderNatAt_mul (hf := hpowA) (hg := hcprodA) ++ (hf' := hpow_not_top) (hg' := hcprod_not_top) ++ simp [hmul, hpow0, hcprod_eq] ++ ++theorem divisor_hadamardDenom_eq ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ) = ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) := by ++ ext z ++ have hden_entire : Differentiable ℂ (hadamardDenom m f) := ++ differentiable_hadamardDenom (m := m) f h_sum ++ have hf_entire : Differentiable ℂ f := hf ++ have hden : ++ (MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ)) z = ++ (analyticOrderNatAt (hadamardDenom m f) z : ℤ) := by ++ simpa using (divisor_univ_eq_analyticOrderNatAt_int (f := hadamardDenom m f) hden_entire z) ++ have hfz : ++ (MeromorphicOn.divisor f (Set.univ : Set ℂ)) z = ++ (analyticOrderNatAt f z : ℤ) := by ++ simpa using (divisor_univ_eq_analyticOrderNatAt_int (f := f) hf_entire z) ++ simp [hden, hfz, analyticOrderNatAt_hadamardDenom_eq (m := m) (hf := hf) (h_sum := h_sum) z] ++ ++theorem divisor_hadamardQuotient_eq_zero ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ MeromorphicOn.divisor (fun z : ℂ => f z / hadamardDenom m f z) (Set.univ : Set ℂ) = 0 := by ++ have hf_mero : MeromorphicOn f (Set.univ : Set ℂ) := by ++ intro z hz ++ exact (hf.analyticAt z).meromorphicAt ++ have hden_entire : Differentiable ℂ (hadamardDenom m f) := ++ differentiable_hadamardDenom (m := m) f h_sum ++ have hden_mero : MeromorphicOn (hadamardDenom m f) (Set.univ : Set ℂ) := by ++ intro z hz ++ exact (hden_entire.analyticAt z).meromorphicAt ++ rcases hnot with ⟨z1, hz1⟩ ++ have hden1 : hadamardDenom m f z1 ≠ 0 := ++ hadamardDenom_ne_zero_at (m := m) (f := f) hf ⟨z1, hz1⟩ h_sum hz1 ++ have hf_order_ne_top : ∀ z ∈ (Set.univ : Set ℂ), meromorphicOrderAt f z ≠ ⊤ := by ++ intro z hzU ++ have hz1_ne_top : meromorphicOrderAt f z1 ≠ ⊤ := by ++ have hfAt : MeromorphicAt f z1 := hf_mero z1 (by simp) ++ have hcont : ContinuousAt f z1 := (hf.differentiableAt).continuousAt ++ have hne_nhds : ∀ᶠ w in 𝓝 z1, f w ≠ 0 := ++ (hcont.ne_iff_eventually_ne continuousAt_const).1 hz1 ++ have hne_nhdsNE : ∀ᶠ w in 𝓝[≠] z1, f w ≠ 0 := ++ eventually_nhdsWithin_of_eventually_nhds hne_nhds ++ exact (meromorphicOrderAt_ne_top_iff_eventually_ne_zero (hf := hfAt)).2 hne_nhdsNE ++ exact MeromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected (hf := hf_mero) ++ (x := z1) (hU := isPreconnected_univ) (h₁x := by simp) (hy := by simp) hz1_ne_top ++ have hden_order_ne_top : ++ ∀ z ∈ (Set.univ : Set ℂ), meromorphicOrderAt (hadamardDenom m f) z ≠ ⊤ := by ++ intro z hzU ++ have hz1_ne_top : meromorphicOrderAt (hadamardDenom m f) z1 ≠ ⊤ := by ++ have hdenAt : MeromorphicAt (hadamardDenom m f) z1 := hden_mero z1 (by simp) ++ have hcont : ContinuousAt (hadamardDenom m f) z1 := ++ (hden_entire.differentiableAt).continuousAt ++ have hne_nhds : ∀ᶠ w in 𝓝 z1, hadamardDenom m f w ≠ 0 := ++ (hcont.ne_iff_eventually_ne continuousAt_const).1 hden1 ++ have hne_nhdsNE : ∀ᶠ w in 𝓝[≠] z1, hadamardDenom m f w ≠ 0 := ++ eventually_nhdsWithin_of_eventually_nhds hne_nhds ++ exact (meromorphicOrderAt_ne_top_iff_eventually_ne_zero (hf := hdenAt)).2 hne_nhdsNE ++ exact MeromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected (hf := hden_mero) ++ (x := z1) (hU := isPreconnected_univ) (h₁x := by simp) (hy := by simp) hz1_ne_top ++ have hinv_order_ne_top : ++ ∀ z ∈ (Set.univ : Set ℂ), ++ meromorphicOrderAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z ≠ ⊤ := by ++ intro z hzU ++ have hinv_mero : ++ MeromorphicOn (fun z : ℂ => (hadamardDenom m f z)⁻¹) (Set.univ : Set ℂ) := ++ hden_mero.inv ++ have hz1_ne_top : ++ meromorphicOrderAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 ≠ ⊤ := by ++ have hinvAt : MeromorphicAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 := ++ hinv_mero z1 (by simp) ++ have hcont_denom : ContinuousAt (hadamardDenom m f) z1 := ++ (hden_entire.differentiableAt).continuousAt ++ have hcont : ContinuousAt (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 := ++ hcont_denom.inv₀ hden1 ++ have hinv1 : (fun z : ℂ => (hadamardDenom m f z)⁻¹) z1 ≠ 0 := by ++ simpa using inv_ne_zero hden1 ++ have hne_nhds : ++ ∀ᶠ w in 𝓝 z1, (fun z : ℂ => (hadamardDenom m f z)⁻¹) w ≠ 0 := ++ (hcont.ne_iff_eventually_ne continuousAt_const).1 hinv1 ++ have hne_nhdsNE : ++ ∀ᶠ w in 𝓝[≠] z1, (fun z : ℂ => (hadamardDenom m f z)⁻¹) w ≠ 0 := ++ eventually_nhdsWithin_of_eventually_nhds hne_nhds ++ exact (meromorphicOrderAt_ne_top_iff_eventually_ne_zero (hf := hinvAt)).2 hne_nhdsNE ++ exact MeromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected (hf := hinv_mero) ++ (x := z1) (hU := isPreconnected_univ) (h₁x := by simp) (hy := by simp) hz1_ne_top ++ have hdiv_denom : MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ) = ++ MeromorphicOn.divisor f (Set.univ : Set ℂ) := ++ divisor_hadamardDenom_eq (m := m) (hf := hf) (h_sum := h_sum) ++ calc ++ MeromorphicOn.divisor (fun z : ℂ => f z / hadamardDenom m f z) (Set.univ : Set ℂ) ++ = MeromorphicOn.divisor ++ (fun z : ℂ => f z * (hadamardDenom m f z)⁻¹) (Set.univ : Set ℂ) := by ++ simp [div_eq_mul_inv] ++ _ = MeromorphicOn.divisor f (Set.univ : Set ℂ) + ++ MeromorphicOn.divisor (fun z : ℂ => (hadamardDenom m f z)⁻¹) (Set.univ : Set ℂ) := by ++ simpa using (MeromorphicOn.divisor_fun_mul (U := (Set.univ : Set ℂ)) ++ (f₁ := f) (f₂ := fun z => (hadamardDenom m f z)⁻¹) hf_mero (hden_mero.inv) ++ hf_order_ne_top hinv_order_ne_top) ++ _ = MeromorphicOn.divisor f (Set.univ : Set ℂ) - ++ MeromorphicOn.divisor (hadamardDenom m f) (Set.univ : Set ℂ) := by ++ simp [sub_eq_add_neg] ++ _ = 0 := by ++ simp [hdiv_denom] ++ ++theorem exists_entire_nonzero_hadamardQuotient ++ (m : ℕ) {f : ℂ → ℂ} (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) : ++ ∃ H : ℂ → ℂ, Differentiable ℂ H ∧ (∀ z, H z ≠ 0) ∧ ∀ z : ℂ, f z = ++ H z * z ^ (analyticOrderNatAt f 0) * divisorCanonicalProduct m f (Set.univ : Set ℂ) z := by ++ let denom : ℂ → ℂ := hadamardDenom m f ++ let q : ℂ → ℂ := fun z => f z / denom z ++ have hden_entire : Differentiable ℂ denom := ++ differentiable_hadamardDenom (m := m) f h_sum ++ have hq_mero : MeromorphicOn q (Set.univ : Set ℂ) := by ++ intro z hzU ++ have hf_m : MeromorphicAt f z := (hf.analyticAt z).meromorphicAt ++ have hden_m : MeromorphicAt denom z := (hden_entire.analyticAt z).meromorphicAt ++ simpa [q, denom, div_eq_mul_inv] using! (hf_m.mul hden_m.inv) ++ let H : ℂ → ℂ := toMeromorphicNFOn q (Set.univ : Set ℂ) ++ have hNF : MeromorphicNFOn H (Set.univ : Set ℂ) := ++ meromorphicNFOn_toMeromorphicNFOn q (Set.univ : Set ℂ) ++ have hdivH : MeromorphicOn.divisor H (Set.univ : Set ℂ) = 0 := by ++ have hdivq : MeromorphicOn.divisor q (Set.univ : Set ℂ) = 0 := ++ divisor_hadamardQuotient_eq_zero (m := m) (f := f) (hf := hf) ++ (hnot := hnot) (h_sum := h_sum) ++ simpa [H, hdivq] using ++ (MeromorphicOn.divisor_of_toMeromorphicNFOn ++ (f := q) (U := (Set.univ : Set ℂ)) hq_mero) ++ have hA : AnalyticOnNhd ℂ H (Set.univ : Set ℂ) := by ++ have : ++ (0 : Function.locallyFinsuppWithin (Set.univ : Set ℂ) ℤ) ≤ ++ MeromorphicOn.divisor H (Set.univ : Set ℂ) := by ++ simp [hdivH] ++ exact (MeromorphicNFOn.divisor_nonneg_iff_analyticOnNhd (h₁f := hNF)).1 (by simp [hdivH]) ++ have hH_entire : Differentiable ℂ H := by ++ intro z ++ exact (hA z (by simp)).differentiableAt ++ rcases hnot with ⟨z1, hz1⟩ ++ have hden1 : denom z1 ≠ 0 := ++ hadamardDenom_ne_zero_at (m := m) (f := f) hf ⟨z1, hz1⟩ h_sum hz1 ++ have hqA1 : AnalyticAt ℂ q z1 := by ++ have hdenA1 : AnalyticAt ℂ denom z1 := hden_entire.analyticAt z1 ++ exact (hf.analyticAt z1).div hdenA1 hden1 ++ have hqNF1 : MeromorphicNFAt q z1 := hqA1.meromorphicNFAt ++ have htoEq : toMeromorphicNFAt q z1 = q := (toMeromorphicNFAt_eq_self (f := q) (x := z1)).2 hqNF1 ++ have hH1 : H z1 = q z1 := by ++ have hx : z1 ∈ (Set.univ : Set ℂ) := by simp ++ have : toMeromorphicNFOn q (Set.univ : Set ℂ) z1 = toMeromorphicNFAt q z1 z1 := ++ (toMeromorphicNFOn_eq_toMeromorphicNFAt (f := q) (U := (Set.univ : Set ℂ)) hq_mero hx) ++ simpa [H, htoEq] using this ++ have hH1_ne : H z1 ≠ 0 := by ++ have : q z1 ≠ 0 := div_ne_zero hz1 hden1 ++ simpa [hH1] using this ++ have hH_not_top : ∀ z : ℂ, analyticOrderAt H z ≠ ⊤ := by ++ exact analyticOrderAt_ne_top_of_exists_ne_zero (hf := hH_entire) ⟨z1, hH1_ne⟩ ++ have hH_orderNat_zero : ∀ z : ℂ, analyticOrderNatAt H z = 0 := by ++ intro z ++ have hzdiv : ++ (MeromorphicOn.divisor H (Set.univ : Set ℂ)) z = (analyticOrderNatAt H z : ℤ) := by ++ simpa using (divisor_univ_eq_analyticOrderNatAt_int (f := H) hH_entire z) ++ have : (MeromorphicOn.divisor H (Set.univ : Set ℂ)) z = 0 := by ++ simp [hdivH] ++ have : (analyticOrderNatAt H z : ℤ) = 0 := by simpa [hzdiv] using this ++ exact_mod_cast this ++ have hH_ne : ∀ z : ℂ, H z ≠ 0 := by ++ intro z ++ have hcast : (analyticOrderNatAt H z : ℕ∞) = analyticOrderAt H z := ++ Nat.cast_analyticOrderNatAt (f := H) (z₀ := z) (hH_not_top z) ++ have : analyticOrderAt H z = 0 := by ++ have : (analyticOrderNatAt H z : ℕ∞) = 0 := by exact_mod_cast (hH_orderNat_zero z) ++ simpa [hcast] using this ++ exact ((hA z (by simp)).analyticOrderAt_eq_zero).1 this ++ have hfA : AnalyticOnNhd ℂ f (Set.univ : Set ℂ) := fun z hzU => hf.analyticAt z ++ have hdenA : AnalyticOnNhd ℂ denom (Set.univ : Set ℂ) := fun z hzU => hden_entire.analyticAt z ++ have hprodA : AnalyticOnNhd ℂ (fun z => H z * denom z) (Set.univ : Set ℂ) := ++ (hA.mul hdenA) ++ have hlocal : f =ᶠ[𝓝 z1] fun z => H z * denom z := by ++ have hden_ne : ∀ᶠ z in 𝓝 z1, denom z ≠ 0 := ++ (hden_entire.differentiableAt.continuousAt.ne_iff_eventually_ne continuousAt_const).1 hden1 ++ have hH_eq_q : H =ᶠ[𝓝 z1] q := by ++ have hx : z1 ∈ (Set.univ : Set ℂ) := by simp ++ have hloc : ++ toMeromorphicNFOn q (Set.univ : Set ℂ) =ᶠ[𝓝 z1] toMeromorphicNFAt q z1 := by ++ simpa [H] using (toMeromorphicNFOn_eq_toMeromorphicNFAt_on_nhds (f := q) ++ (U := (Set.univ : Set ℂ)) hq_mero hx) ++ simpa [H, htoEq] using hloc ++ filter_upwards [hden_ne, hH_eq_q] with z hzden hHz ++ have hcancel : q z * denom z = f z := by ++ dsimp [q] ++ field_simp [hzden] ++ calc ++ f z = q z * denom z := hcancel.symm ++ _ = H z * denom z := by simp [hHz] ++ have hglob : f = fun z => H z * denom z := ++ AnalyticOnNhd.eq_of_eventuallyEq (hf := hfA) (hg := hprodA) hlocal ++ refine ⟨H, hH_entire, hH_ne, ?_⟩ ++ intro z ++ have hglobz : f z = H z * denom z := congrArg (fun g => g z) hglob ++ simpa [denom, hadamardDenom, mul_assoc, mul_left_comm, mul_comm] using hglobz ++ ++end Complex.Hadamard ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/Growth.lean b/PrimeNumberTheoremAnd/SiegelZeros/Growth.lean +new file mode 100644 +index 0000000..99df501 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/Growth.lean +@@ -0,0 +1,439 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.Summability ++import PrimeNumberTheoremAnd.SiegelZeros.Exponential ++ ++namespace SiegelZeros ++ ++section ++noncomputable section ++ ++open Set Filter Asymptotics ++open scoped Topology BigOperators ++ ++namespace Complex.Hadamard ++ ++lemma no_zero_on_sphere_of_norm_image_avoid ++ {f : ℂ → ℂ} (hentire : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ {B r : ℝ} (hrpos : 0 < r) (hr_le_B : r ≤ B) ++ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) (hsmall_fin : smallSet.Finite) ++ (hsmallSet : ++ smallSet = {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ B}) ++ (hr_not_bad : ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ r ∉ small.image a) : ++ ∀ u : ℂ, ‖u‖ = r → f u ≠ 0 := by ++ classical ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let bad : Finset ℝ := small.image a ++ have hr_not_bad' : r ∉ bad := by ++ simpa [bad, small, a] using hr_not_bad ++ have hr_not : ++ ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖ ≤ B → r ≠ ‖divisorZeroIndex₀Val p‖ := by ++ intro p hpB hEq ++ have hp_small : p ∈ small := by ++ have hp_mem : p ∈ smallSet := by ++ simpa [hsmallSet] using hpB ++ simpa [small] using (hsmall_fin.mem_toFinset.2 hp_mem) ++ have : r ∈ bad := Finset.mem_image.2 ⟨p, hp_small, by simpa [a] using hEq.symm⟩ ++ exact (hr_not_bad' this).elim ++ exact no_zero_on_sphere_of_forall_val_norm_ne (f := f) hentire hnot ++ (B := B) (r := r) hrpos hr_le_B hr_not ++ ++theorem norm_inv_hadamardDenominator_le_exp_on_cartan_circle ++ {f : ℂ → ℂ} {ρ τ : ℝ} {m : ℕ} ++ (hmρ : (m : ℝ) ≤ ρ) (hτ : ρ < τ) (hτ_lt : τ < (m + 1 : ℝ)) ++ (hτ_nonneg : 0 ≤ τ) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (hsumτ : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ let Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ ∀ {R r : ℝ}, 0 < R → 1 ≤ R → R ≤ r → r ≤ 2 * R → ++ ∀ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall_fin : smallSet.Finite), ++ smallSet = ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ 4 * R} → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ r ∉ small.image a) → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ (∑ p ∈ small, (1 : ℝ) * CartanBound.φ (r / a p)) ≤ ++ CartanBound.Cφ * (small.card : ℝ)) → ++ ∀ u : ℂ, ‖u‖ = r → ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ Real.exp (Cprod * (1 + r) ^ τ) := by ++ classical ++ intro Sτ Cprod R r hRpos hRle hR_le_r hr_le_2R smallSet hsmall_fin ++ hsmallSet hr_not_bad hr_phi u hur ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let bad : Finset ℝ := small.image a ++ have hr_not_bad' : r ∉ bad := by ++ simpa [bad, small, a] using hr_not_bad ++ have hr1 : (1 : ℝ) ≤ r := le_trans hRle hR_le_r ++ have hpow_inv_le1 : ‖(u ^ analyticOrderNatAt f 0)⁻¹‖ ≤ 1 := ++ Complex.norm_inv_pow_le_one_of_one_le_norm u (analyticOrderNatAt f 0) (by simpa [hur] using hr1) ++ let fac : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℂ := ++ fun p => weierstrassFactor m (u / divisorZeroIndex₀Val p) ++ have hloc : ++ HasProdLocallyUniformlyOn ++ (fun (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) (w : ℂ) => ++ weierstrassFactor m (w / divisorZeroIndex₀Val p)) ++ (divisorCanonicalProduct m f (Set.univ : Set ℂ)) ++ (Set.univ : Set ℂ) := ++ hasProdLocallyUniformlyOn_divisorCanonicalProduct_univ (m := m) (f := f) h_sum ++ have hprod : ++ HasProd fac (divisorCanonicalProduct m f (Set.univ : Set ℂ) u) := ++ hloc.hasProd (by simp : u ∈ (Set.univ : Set ℂ)) ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ have : DecidablePred (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => p ∈ small) := ++ Classical.decPred _ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if hp : p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ have hterm : ∀ p, ‖(fac p)⁻¹‖ ≤ Real.exp (b p) := by ++ intro p ++ by_cases hp : p ∈ small ++ · have hval_ne : r ≠ ap p := by ++ intro hEq ++ have : r ∈ bad := by ++ refine Finset.mem_image.2 ⟨p, hp, ?_⟩ ++ simp [ap, a, hEq] ++ exact (hr_not_bad' this).elim ++ have hval0 : divisorZeroIndex₀Val p ≠ 0 := divisorZeroIndex₀Val_ne_zero p ++ have hmτ : (m : ℝ) ≤ τ := le_trans hmρ (le_of_lt hτ) ++ have hnear : ++ ‖(weierstrassFactor m (u / divisorZeroIndex₀Val p))⁻¹‖ ++ ≤ Real.exp (CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ)) := by ++ simpa [ap] using ++ (norm_inv_weierstrassFactor_le_exp_near (m := m) (τ := τ) (r := r) ++ (u := u) (a := divisorZeroIndex₀Val p) ++ (hur := hur) (ha := hval0) (hr := by simpa [ap] using hval_ne) hmτ) ++ simpa [fac, b, hp] using hnear ++ · have hlarge : (4 * R : ℝ) < ap p := by ++ have : ¬ap p ≤ 4 * R := by ++ intro hle ++ have : p ∈ small := by ++ have hp_mem : p ∈ smallSet := by ++ simpa [hsmallSet, ap] using hle ++ simpa [small] using (hsmall_fin.mem_toFinset.2 hp_mem) ++ exact hp this ++ exact lt_of_not_ge this ++ have hz' : ‖u / divisorZeroIndex₀Val p‖ ≤ (1 / 2 : ℝ) := ++ norm_div_le_half_of_norm_le_of_two_mul_lt (z := u) (a := divisorZeroIndex₀Val p) ++ (R := 2 * R) (by nlinarith [hRpos]) (by rw [hur]; exact hr_le_2R) ++ (by nlinarith [hlarge]) ++ have hτ_le : τ ≤ (m + 1 : ℝ) := le_of_lt hτ_lt ++ have hfar : ++ ‖(weierstrassFactor m (u / divisorZeroIndex₀Val p))⁻¹‖ ≤ ++ Real.exp ((2 : ℝ) * (r / ap p) ^ τ) := by ++ simpa [ap] using ++ (norm_inv_weierstrassFactor_le_exp_far (m := m) (τ := τ) (r := r) ++ (u := u) (a := divisorZeroIndex₀Val p) ++ (hur := hur) (ha := divisorZeroIndex₀Val_ne_zero p) (hz := hz') hτ_le) ++ simpa [fac, b, hp] using hfar ++ have hb_le : ++ ∀ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)), ++ (∑ p ∈ s, b p) ≤ Cprod * (1 + r) ^ τ := by ++ intro s ++ simpa [small, ap, b, Sτ, Cprod, a, hsmallSet] using ++ (Complex.Hadamard.cartan_sum_majorant_le (f := f) (m := m) (τ := τ) (R := R) (r := r) ++ (hRpos := hRpos) (hrpos := lt_of_lt_of_le hRpos hR_le_r) ++ (hR_le_r := hR_le_r) (hτ_nonneg := hτ_nonneg) ++ (smallSet := smallSet) (hsmall_fin := hsmall_fin) (hsmallSet := hsmallSet) ++ (hsumτ := hsumτ) ++ (hr_phi := by ++ simpa [small, a, one_mul] using hr_phi) ++ s) ++ have hcprod_inv : ++ ‖(divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ≤ ++ Real.exp (Cprod * (1 + r) ^ τ) := by ++ refine hasProd_norm_inv_le_exp_of_pointwise_le_exp ++ (α := divisorZeroIndex₀ f (Set.univ : Set ℂ)) (fac := fac) ++ (F := divisorCanonicalProduct m f (Set.univ : Set ℂ) u) ++ hprod (b := b) (B := Cprod * (1 + r) ^ τ) ?_ ?_ ++ · exact hterm ++ · intro s ++ exact hb_le s ++ have hmul : ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ = ++ ‖(u ^ analyticOrderNatAt f 0)⁻¹‖ * ++ ‖(divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ := by ++ simp [mul_inv_rev, mul_comm] ++ rw [hmul] ++ have : ++ ‖(u ^ analyticOrderNatAt f 0)⁻¹‖ * ++ ‖(divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ 1 * Real.exp (Cprod * (1 + r) ^ τ) := ++ mul_le_mul hpow_inv_le1 hcprod_inv (by positivity) (by positivity) ++ simpa using this ++ ++theorem hadamardQuotient_norm_le_exp_on_cartan_circle ++ {f H : ℂ → ℂ} {ρ τ : ℝ} {m : ℕ} {Cf : ℝ} ++ (hmρ : (m : ℝ) ≤ ρ) (hτ : ρ < τ) (hτ_lt : τ < (m + 1 : ℝ)) ++ (hτ_nonneg : 0 ≤ τ) (hentire : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (hsumτ : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) ++ (hf_boundτ : ∀ z : ℂ, ‖f z‖ ≤ Real.exp (Cf * (1 + ‖z‖) ^ τ)) ++ (hfactor : ∀ z : ℂ, ++ f z = ++ H z * z ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) z) : ++ let Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ ∀ {R r : ℝ}, 0 < R → 1 ≤ R → R ≤ r → r ≤ 2 * R → 0 < r → ++ ∀ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall_fin : smallSet.Finite), ++ smallSet = ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ 4 * R} → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ r ∉ small.image a) → ++ (let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ‖divisorZeroIndex₀Val p‖ ++ (∑ p ∈ small, (1 : ℝ) * CartanBound.φ (r / a p)) ≤ ++ CartanBound.Cφ * (small.card : ℝ)) → ++ ∀ u : ℂ, ‖u‖ = r → ‖H u‖ ≤ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ classical ++ intro Sτ Cprod R r hRpos hRle hR_le_r hr_le_2R hrpos smallSet hsmall_fin ++ hsmallSet hr_not_bad hr_phi u hur ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let bad : Finset ℝ := small.image a ++ have hr_not_bad' : r ∉ bad := by ++ simpa [bad, small, a] using hr_not_bad ++ have hden_eq : ++ f u = ++ H u * (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u) := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using (hfactor u) ++ have hfu_ne : f u ≠ 0 := by ++ have hr_le_4R : r ≤ 4 * R := by nlinarith [hr_le_2R, hRpos] ++ exact no_zero_on_sphere_of_norm_image_avoid (f := f) hentire hnot ++ (B := 4 * R) (r := r) hrpos hr_le_4R smallSet hsmall_fin hsmallSet ++ (by simpa [small, a] using hr_not_bad) u hur ++ have hden_ne : ++ (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u) ≠ 0 := by ++ intro hden0 ++ have : f u = 0 := by simpa [hden0] using hden_eq ++ exact hfu_ne this ++ have hHu : ++ H u = ++ f u / (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u) := by ++ exact eq_div_of_mul_eq hden_ne (Eq.symm hden_eq) ++ have hf_u : ‖f u‖ ≤ Real.exp (Cf * (1 + r) ^ τ) := by ++ simpa [hur] using hf_boundτ u ++ have hden_inv : ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ Real.exp (Cprod * (1 + r) ^ τ) := by ++ simpa [Sτ, Cprod] using ++ (norm_inv_hadamardDenominator_le_exp_on_cartan_circle ++ (f := f) (ρ := ρ) (τ := τ) (m := m) ++ hmρ hτ hτ_lt hτ_nonneg h_sum hsumτ ++ (R := R) (r := r) hRpos hRle hR_le_r hr_le_2R ++ smallSet hsmall_fin hsmallSet ++ (by simpa [small, a] using hr_not_bad) ++ (by simpa [small, a, one_mul] using hr_phi) ++ u hur) ++ have : ++ ‖H u‖ ≤ ++ ‖f u‖ * ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ := by ++ have : ++ ‖H u‖ = ++ ‖f u / ++ (u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)‖ := by ++ simp [hHu] ++ simp [div_eq_mul_inv, norm_inv, this] ++ have hmul : ++ ‖f u‖ * ++ ‖(u ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) u)⁻¹‖ ++ ≤ Real.exp (Cf * (1 + r) ^ τ) * Real.exp (Cprod * (1 + r) ^ τ) := ++ mul_le_mul hf_u hden_inv (by positivity) (by positivity) ++ have hexp : ++ Real.exp (Cf * (1 + r) ^ τ) * Real.exp (Cprod * (1 + r) ^ τ) ++ = Real.exp ((Cf + Cprod) * (1 + r) ^ τ) := by ++ simp [Real.exp_add, add_mul, add_comm] ++ have : ‖H u‖ ≤ Real.exp ((Cf + Cprod) * (1 + r) ^ τ) := ++ (this.trans hmul).trans_eq hexp ++ have hslack : ++ Real.exp ((Cf + Cprod) * (1 + r) ^ τ) ≤ ++ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ refine Real.exp_le_exp.2 ?_ ++ have hnn : 0 ≤ (1 + r) ^ τ := by positivity ++ nlinarith ++ exact this.trans hslack ++ ++theorem hadamardQuotient_norm_le_exp_rpow_of_growth {f H : ℂ → ℂ} {ρ τ : ℝ} {m : ℕ} ++ (hρ : 0 ≤ ρ) (hmρ : (m : ℝ) ≤ ρ) (hτ : ρ < τ) (hτ_lt : τ < (m + 1 : ℝ)) ++ (hτ_nonneg : 0 ≤ τ) (hentire : Differentiable ℂ f) (hH_entire : Differentiable ℂ H) ++ (hnot : ∃ z : ℂ, f z ≠ 0) ++ (h_sum : Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1))) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) ++ (hfactor : ∀ z : ℂ, ++ f z = ++ H z * z ^ analyticOrderNatAt f 0 * ++ divisorCanonicalProduct m f (Set.univ : Set ℂ) z) : ++ ∃ C > 0, ∀ z : ℂ, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ) := by ++ rcases hgrowth with ⟨Cf, hCfpos, hCf⟩ ++ have hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := ++ summable_norm_inv_rpow_divisorZeroIndex₀_of_growth (f := f) (ρ := ρ) (τ := τ) ++ hρ hτ hentire hnot ⟨Cf, hCfpos, hCf⟩ ++ let Sτ : ℝ := ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have hSτ_nonneg : 0 ≤ Sτ := tsum_nonneg fun _ => ++ Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ have hCprod_nonneg : 0 ≤ Cprod := by ++ simpa [Cprod] using cartanProductConstant_nonneg (m := m) (τ := τ) hSτ_nonneg ++ have hf_boundτ : ∀ z : ℂ, ‖f z‖ ≤ Real.exp (Cf * (1 + ‖z‖) ^ τ) := ++ Real.norm_le_exp_mul_rpow_of_log_growth ++ (f := f) (r := fun z : ℂ => 1 + ‖z‖) (C := Cf) (ρ := ρ) (τ := τ) ++ hCfpos.le (fun z => by linarith [norm_nonneg z]) (le_of_lt hτ) hCf ++ refine ⟨(Cf + Cprod + 10) * (3 : ℝ) ^ τ, by ++ have h3τ : 0 < (3 : ℝ) ^ τ := by positivity ++ nlinarith [hCfpos, hCprod_nonneg, h3τ], ?_⟩ ++ intro z ++ let R : ℝ := max ‖z‖ 1 ++ have hRpos : 0 < R := lt_of_lt_of_le (by norm_num) (le_max_right _ _) ++ have hRle : (1 : ℝ) ≤ R := le_max_right _ _ ++ let smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ {p | ‖divisorZeroIndex₀Val p‖ ≤ 4 * R} ++ have hsmall_fin : smallSet.Finite := by ++ have : Metric.closedBall (0 : ℂ) (4 * R) ⊆ (Set.univ : Set ℂ) := by simp ++ simpa [smallSet] using ++ (divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) ++ (B := 4 * R) this) ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ have ha_pos : ∀ p ∈ small, 0 < a p := by ++ intro p hp ++ exact norm_pos_iff.2 (divisorZeroIndex₀Val_ne_zero p) ++ let bad : Finset ℝ := small.image a ++ rcases CartanBound.exists_radius_Ioc_sum_mul_phi_div_le_Cφ_mul_sum_avoid ++ (s := small) (w := fun _ => (1 : ℝ)) (a := a) ++ (hw := by intro _ _; norm_num) (ha := ha_pos) (bad := bad) (R := R) hRpos with ++ ⟨r, hr_mem, hr_not_bad, hr_phi⟩ ++ have hR_le_r : R ≤ r := le_of_lt hr_mem.1 ++ have hr_le_2R : r ≤ 2 * R := hr_mem.2 ++ have hrpos : 0 < r := lt_of_lt_of_le hRpos hR_le_r ++ have hcircle : ++ ∀ u : ℂ, ‖u‖ = r → ‖H u‖ ≤ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ simpa [Sτ, Cprod] using ++ (hadamardQuotient_norm_le_exp_on_cartan_circle ++ (f := f) (H := H) (ρ := ρ) (τ := τ) (m := m) (Cf := Cf) ++ hmρ hτ hτ_lt hτ_nonneg hentire hnot h_sum hsumτ hf_boundτ hfactor ++ (R := R) (r := r) hRpos hRle hR_le_r hr_le_2R hrpos ++ smallSet hsmall_fin (by rfl) ++ (by simpa [small, a, bad] using hr_not_bad) ++ (by simpa [small, a, one_mul, Finset.sum_const, nsmul_eq_mul] using hr_phi)) ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) r := by ++ rw [Metric.mem_ball, dist_zero_right] ++ exact lt_of_le_of_lt (le_max_left _ _) hr_mem.1 ++ have hball : ++ ‖H z‖ ≤ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) := by ++ exact Complex.norm_le_of_mem_ball_of_forall_sphere_norm_le hH_entire hrpos hz_ball hcircle ++ have hr_le_3 : 1 + r ≤ 3 * (1 + ‖z‖) := by ++ exact Real.one_add_le_three_mul_one_add_of_le_two_mul_max (norm_nonneg z) ++ (by simpa [R] using hr_le_2R) ++ have hmain : ++ Real.exp ((Cf + Cprod + 10) * (1 + r) ^ τ) ++ ≤ Real.exp (((Cf + Cprod + 10) * (3 : ℝ) ^ τ) * (1 + ‖z‖) ^ τ) := by ++ have hnn : 0 ≤ (Cf + Cprod + 10) := by nlinarith [le_of_lt hCfpos, hCprod_nonneg] ++ exact Real.exp_mul_rpow_le_exp_mul_rpow_of_le_mul hnn (by norm_num) ++ (by linarith [le_of_lt hrpos]) (by positivity) hτ_nonneg hr_le_3 ++ simpa [mul_assoc] using hball.trans hmain ++ ++theorem hadamard_factorization_of_growth {f : ℂ → ℂ} {ρ : ℝ} (hρ : 0 ≤ ρ) ++ (hentire : Differentiable ℂ f) ++ (hnot : ∃ z : ℂ, f z ≠ 0) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ ∃ (P : Polynomial ℂ), ++ P.degree ≤ Nat.floor ρ ∧ ++ ∀ z : ℂ, ++ f z = ++ Complex.exp (Polynomial.eval z P) * ++ z ^ (analyticOrderNatAt f 0) * ++ divisorCanonicalProduct (Nat.floor ρ) f (Set.univ : Set ℂ) z := by ++ set m : ℕ := Nat.floor ρ ++ have h_sum : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (m + 1)) := by ++ simpa [m] using ++ (summable_norm_inv_pow_divisorZeroIndex₀_of_growth (f := f) (ρ := ρ) ++ hρ hentire hnot hgrowth) ++ rcases exists_entire_nonzero_hadamardQuotient (m := m) (f := f) hentire hnot h_sum with ++ ⟨H, hH_entire, hH_ne, hfactor⟩ ++ rcases Real.exists_between_self_and_floor_add_one_same_floor hρ with ++ ⟨τ, hτ, hτ_lt, hτ_nonneg, hfloorτ'⟩ ++ have hfloorτ : Nat.floor τ = m := by ++ simpa [m] using hfloorτ' ++ have hτ_lt_m : τ < (m + 1 : ℝ) := by ++ simpa [m] using hτ_lt ++ have hτ_lt_nat : τ < ((m + 1 : ℕ) : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one] using hτ_lt_m ++ have hmρ : (m : ℝ) ≤ ρ := by ++ have := Nat.floor_le hρ ++ simpa [m] using this ++ have hH_bound_rpow : ++ ∃ C > 0, ∀ z : ℂ, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ) := ++ hadamardQuotient_norm_le_exp_rpow_of_growth (f := f) (H := H) (ρ := ρ) (τ := τ) ++ (m := m) hρ hmρ hτ hτ_lt hτ_nonneg hentire hH_entire hnot h_sum hgrowth hfactor ++ have hH_growth_nat : ++ ∃ C > 0, ∀ z : ℂ, ‖H z‖ ≤ Real.exp (C * (1 + ‖z‖) ^ (m + 1)) := by ++ exact Real.exists_norm_le_exp_mul_pow_of_rpow_bound ++ (f := H) (r := fun z : ℂ => 1 + ‖z‖) ++ (fun z => by linarith [norm_nonneg z]) hτ_lt_nat hH_bound_rpow ++ rcases zero_free_polynomial_growth_is_exp_poly (H := H) (n := m + 1) ++ hH_entire hH_ne hH_growth_nat with ++ ⟨P, hPn, hHP⟩ ++ have hPnat : P.natDegree ≤ m := by ++ have hbound : ++ ∃ C > 0, ∀ z : ℂ, ++ ‖Complex.exp (Polynomial.eval z P)‖ ≤ Real.exp (C * (1 + ‖z‖) ^ τ) := by ++ rcases hH_bound_rpow with ⟨C, hCpos, hC⟩ ++ exact ⟨C, hCpos, fun z => by simpa [hHP z] using (hC z)⟩ ++ have := natDegree_le_floor_of_exp_eval_norm_bound hτ_nonneg P hbound ++ simpa [hfloorτ] using this ++ refine ⟨P, ?_, ?_⟩ ++ · have : P.degree ≤ m := Polynomial.degree_le_of_natDegree_le hPnat ++ simpa [m] using this ++ · intro z ++ have hH' : H z = Complex.exp (Polynomial.eval z P) := by simpa using (hHP z) ++ simpa [hH', mul_assoc, mul_left_comm, mul_comm, m] using (hfactor z) ++ ++end Complex.Hadamard ++end ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/HadamardSupport.lean b/PrimeNumberTheoremAnd/SiegelZeros/HadamardSupport.lean +new file mode 100644 +index 0000000..7ec52e3 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/HadamardSupport.lean +@@ -0,0 +1 @@ ++import PrimeNumberTheoremAnd.SiegelZeros.Growth +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/NOTICE.md b/PrimeNumberTheoremAnd/SiegelZeros/NOTICE.md +new file mode 100644 +index 0000000..a3e10f6 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/NOTICE.md +@@ -0,0 +1,15 @@ ++# Captured support notices ++ ++The mathematical support is derived from PrimeNumberTheoremAnd. Its existing repository license remains applicable. Original retained notices follow. ++ ++/- ++Copyright (c) 2026 Matteo Cipollina. All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Matteo Cipollina ++-/ ++ ++/- ++Copyright (c) 2025 Stefan Kebekus. All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Stefan Kebekus, Matteo Cipollina ++-/ +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/ProductBounds.lean b/PrimeNumberTheoremAnd/SiegelZeros/ProductBounds.lean +new file mode 100644 +index 0000000..6a2985a +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/ProductBounds.lean +@@ -0,0 +1,724 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.DivisorLimits ++import PrimeNumberTheoremAnd.SiegelZeros.CartanBounds ++ ++namespace SiegelZeros ++ ++section ++noncomputable section ++ ++namespace Complex.Hadamard ++ ++open scoped BigOperators ++open Filter Finset _root_.Real _root_.SiegelZeros.Real Topology ++ ++section CartanFiniteSum ++ ++variable {α : Type*} ++ ++private lemma summable_ite_mem_finset [DecidableEq α] (s : Finset α) (u : α → ℝ) : ++ Summable (fun a => if a ∈ s then u a else 0) := ++ summable_of_ne_finset_zero (s := s) fun a ha => by simp [ite_eq_right ha] ++ ++private lemma tsum_ite_mem_finset [DecidableEq α] (s : Finset α) (u : α → ℝ) : ++ (∑' a, if a ∈ s then u a else 0) = ∑ a ∈ s, u a := by ++ classical ++ simpa [Finset.sum_ite] using ++ (hasSum_sum_of_ne_finset_zero (s := s) (f := fun a => if a ∈ s then u a else 0) ++ fun a ha => by simp [ite_eq_right ha]).tsum_eq ++ ++private lemma tsum_add_four (u₁ u₂ u₃ u₄ : α → ℝ) ++ (h₁ : Summable u₁) (h₂ : Summable u₂) (h₃ : Summable u₃) (h₄ : Summable u₄) : ++ tsum (fun a => ((u₁ a + u₂ a) + u₃ a) + u₄ a) ++ = tsum u₁ + tsum u₂ + tsum u₃ + tsum u₄ := by ++ calc ++ tsum (fun a => ((u₁ a + u₂ a) + u₃ a) + u₄ a) ++ = tsum (fun a => (u₁ a + u₂ a) + (u₃ a + u₄ a)) := by ++ simp [add_comm, add_left_comm] ++ _ = tsum (fun a => u₁ a + u₂ a) + tsum (fun a => u₃ a + u₄ a) := ++ Summable.tsum_add (h₁.add h₂) (h₃.add h₄) ++ _ = tsum u₁ + tsum u₂ + tsum u₃ + tsum u₄ := by ++ rw [Summable.tsum_add h₁ h₂, Summable.tsum_add h₃ h₄] ++ ring ++ ++end CartanFiniteSum ++ ++noncomputable def cartanProductConstant (m : ℕ) (τ Sτ : ℝ) : ℝ := ++ ((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 3) * (Sτ + 1) ++ ++lemma cartanProductConstant_nonneg {m : ℕ} {τ Sτ : ℝ} (hSτ : 0 ≤ Sτ) : ++ 0 ≤ cartanProductConstant m τ Sτ := by ++ have hS : 0 ≤ Sτ + 1 := by linarith ++ have hA : 0 ≤ (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 3 := by ++ have hCφ : 0 ≤ CartanBound.Cφ := le_of_lt CartanBound.Cφ_pos ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ have h4τ : 0 ≤ (4 : ℝ) ^ τ := by positivity ++ nlinarith [hCφ, hm0, h4τ] ++ simpa [cartanProductConstant] using mul_nonneg hA hS ++ ++lemma rpow_div_norm_divisorZeroIndex₀_eq ++ {f : ℂ → ℂ} {r τ : ℝ} (hr : 0 ≤ r) ++ (p : divisorZeroIndex₀ f (Set.univ : Set ℂ)) : ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ = ++ (r ^ τ) * ((‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) := by ++ have hp : 0 ≤ (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) := by positivity ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using ++ (Real.mul_rpow (x := r) (y := (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ)) (z := τ) hr hp) ++ ++lemma tsum_rpow_div_norm_divisorZeroIndex₀_eq ++ {f : ℂ → ℂ} {r τ : ℝ} (hr : 0 ≤ r) : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = (r ^ τ) * ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ calc ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ := by ++ refine tsum_congr ?_ ++ intro p ++ exact rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p ++ _ = (r ^ τ) * ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ simp [tsum_mul_left] ++ ++lemma tsum_two_mul_rpow_div_norm_divisorZeroIndex₀_le ++ {f : ℂ → ℂ} {r τ : ℝ} (hr : 0 ≤ r) (hτ_nonneg : 0 ≤ τ) : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (2 : ℝ) * (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ ≤ (2 : ℝ) * ((∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) + 1) * (1 + r) ^ τ := by ++ set Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have htsum : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (2 : ℝ) * (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = (2 : ℝ) * (r ^ τ) * Sτ := by ++ calc ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (2 : ℝ) * (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ = (2 : ℝ) * ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ (r / ‖divisorZeroIndex₀Val p‖) ^ τ := by ++ simp [tsum_mul_left] ++ _ = (2 : ℝ) * ((r ^ τ) * Sτ) := by ++ rw [tsum_rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr] ++ _ = (2 : ℝ) * (r ^ τ) * Sτ := by ring ++ have hSτ_nonneg : 0 ≤ Sτ := ++ tsum_nonneg (fun _ => Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _) ++ have h1r : r ^ τ ≤ (1 + r) ^ τ := ++ Real.rpow_le_rpow (by positivity) (by linarith) hτ_nonneg ++ have hS : Sτ ≤ Sτ + 1 := by linarith ++ have hle : (r ^ τ) * Sτ ≤ (1 + r) ^ τ * (Sτ + 1) := ++ mul_le_mul h1r hS (by linarith) (by positivity) ++ rw [htsum] ++ have : (2 : ℝ) * (r ^ τ) * Sτ ≤ (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ nlinarith [hle] ++ simpa [Sτ, mul_assoc, mul_left_comm, mul_comm] using this ++ ++lemma sum_rpow_div_norm_divisorZeroIndex₀_le ++ {f : ℂ → ℂ} {r τ : ℝ} (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hr : 0 ≤ r) (hτ_nonneg : 0 ≤ τ) ++ (hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ (∑ p ∈ small, (r / ‖divisorZeroIndex₀Val p‖) ^ τ) ++ ≤ ((∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) + 1) * (1 + r) ^ τ := by ++ set Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have hsum_inv : ++ (∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ≤ Sτ := by ++ have hnn : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ 0 ≤ (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ := by ++ intro p ++ positivity ++ simpa [Sτ] using ++ (Summable.sum_le_tsum (s := small) ++ (f := fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ++ (fun p _ => hnn p) hsumτ) ++ have hsum_eq : ++ ∑ p ∈ small, (r / ‖divisorZeroIndex₀Val p‖) ^ τ = ++ (r ^ τ) * ∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ := by ++ simp [rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr, Finset.mul_sum] ++ have h1r : r ^ τ ≤ (1 + r) ^ τ := ++ Real.rpow_le_rpow (by positivity) (by linarith) hτ_nonneg ++ have hS : (∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ≤ Sτ + 1 := by ++ linarith [hsum_inv] ++ have hle : ++ (r ^ τ) * (∑ p ∈ small, (‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ) ++ ≤ (1 + r) ^ τ * (Sτ + 1) := ++ mul_le_mul h1r hS (by positivity) (by positivity) ++ simpa [Sτ, hsum_eq, mul_assoc, mul_left_comm, mul_comm] using hle ++ ++lemma add_four_le_add_two_mul_of_le {x₁ x₂ x₃ x₄ A B C : ℝ} ++ (h₁ : x₁ ≤ A) (h₂ : x₂ ≤ B) (h₃ : x₃ ≤ B) (h₄ : x₄ ≤ C) : ++ x₁ + x₂ + x₃ + x₄ ≤ A + 2 * B + C := by ++ nlinarith ++ ++lemma cartan_majorant_four_term_bound ++ {xφ x0 xm xt Cφ m q Y T : ℝ} ++ (hφ : xφ ≤ Cφ * q * Y * T) ++ (h0 : x0 ≤ m * q * Y * T) ++ (hm : xm ≤ m * q * Y * T) ++ (ht : xt ≤ (2 : ℝ) * Y * T) : ++ xφ + x0 + xm + xt ≤ (Cφ + (2 : ℝ) * m) * q * Y * T + (2 : ℝ) * Y * T := by ++ have h := ++ add_four_le_add_two_mul_of_le hφ h0 hm ht ++ have hring : ++ Cφ * (q * (Y * T)) + 2 * (m * (q * (Y * T))) + 2 * (Y * T) ++ = (Cφ + (2 : ℝ) * m) * (q * (Y * T)) + (2 : ℝ) * (Y * T) := by ++ ring ++ simpa [mul_assoc, hring] using h ++ ++lemma cartan_majorant_add_two_factor (A Y T : ℝ) : ++ A * Y * T + (2 : ℝ) * Y * T = ((A + 2) * Y) * T := by ++ ring ++ ++lemma cartan_majorant_pad_two_to_three {A S T : ℝ} (hS : 0 ≤ S + 1) (hT : 0 ≤ T) : ++ ((A + 2) * (S + 1)) * T ≤ ((A + 3) * (S + 1)) * T := by ++ have h : (A + 2) * (S + 1) ≤ (A + 3) * (S + 1) := by ++ nlinarith ++ exact mul_le_mul_of_nonneg_right h hT ++ ++lemma cartan_majorant_nonneg ++ {f : ℂ → ℂ} {m : ℕ} {τ r : ℝ} (hr : 0 ≤ r) ++ (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) : ++ letI : DecidableEq (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := Classical.decEq _ ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ ∀ p, 0 ≤ b p := by ++ classical ++ dsimp ++ intro p ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun q => ‖divisorZeroIndex₀Val q‖ ++ have hap : ap p = ‖divisorZeroIndex₀Val p‖ := rfl ++ by_cases hp : p ∈ small ++ · have hφ : 0 ≤ CartanBound.φ (r / ap p) := CartanBound.φ_nonneg (t := r / ap p) ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ have h1 : 0 ≤ (1 + (r / ap p) ^ τ) := by positivity ++ have : 0 ≤ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) := by ++ nlinarith [hφ, hm0, h1] ++ simpa [hap, hp, ap] using this ++ · have hbase : 0 ≤ r / ap p := div_nonneg hr (by positivity) ++ have hpow : 0 ≤ (r / ap p) ^ τ := Real.rpow_nonneg hbase τ ++ have : 0 ≤ (2 : ℝ) * (r / ap p) ^ τ := mul_nonneg (by norm_num) hpow ++ simpa [hap, hp, ap] using this ++ ++lemma cartan_majorant_summable ++ {f : ℂ → ℂ} {m : ℕ} {τ r : ℝ} (hr : 0 ≤ r) ++ (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ letI : DecidableEq (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := Classical.decEq _ ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ Summable b := by ++ classical ++ dsimp ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun q => ‖divisorZeroIndex₀Val q‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ have hb : Summable b := by ++ let b₁ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else 0 ++ let b₂ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then 0 else (2 : ℝ) * (r / ap p) ^ τ ++ have hb_decomp : b = fun p => b₁ p + b₂ p := by ++ funext p ++ by_cases hp : p ∈ small <;> simp [b, b₁, b₂, hp] ++ have hb₁ : Summable b₁ := by ++ simpa [b₁] using ++ summable_ite_mem_finset small ++ (fun p => CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ)) ++ have hb₂ : Summable b₂ := by ++ have hconst : ++ Summable (fun p => ++ (2 : ℝ) * (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) := ++ hsumτ.mul_left ((2 : ℝ) * (r ^ τ)) ++ refine Summable.of_nonneg_of_le ++ (fun p => by ++ by_cases hp : p ∈ small ++ · simp [b₂, hp] ++ · have : 0 ≤ (2 : ℝ) * (r / ap p) ^ τ := by positivity ++ simpa [b₂, hp] using this) ++ (fun p => ?_) hconst ++ by_cases hp : p ∈ small ++ · have : 0 ≤ (2 : ℝ) * (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by positivity ++ simpa [b₂, hp] using this ++ · have hrpow : (r / ap p) ^ τ = (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by ++ simpa [ap] using rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p ++ simp [b₂, hp, hrpow, mul_assoc, mul_left_comm, mul_comm] ++ simpa [hb_decomp] using hb₁.add hb₂ ++ refine hb.congr ?_ ++ intro p ++ by_cases hp : p ∈ small <;> simp [b, ap, hp] ++ ++lemma cartan_card_small_le ++ {f : ℂ → ℂ} {τ R : ℝ} (hRpos : 0 < R) (hτ_nonneg : 0 ≤ τ) ++ (small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall : ∀ p ∈ small, ‖divisorZeroIndex₀Val p‖ ≤ 4 * R) ++ (hsumτ : ++ Summable ++ (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) : ++ (small.card : ℝ) ++ ≤ (4 * R) ^ τ ++ * ((∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) + 1) := by ++ classical ++ set Sτ : ℝ := ++ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ have hsum_le : (∑ p ∈ small, ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) ≤ Sτ := by ++ have hnn : ++ ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ 0 ≤ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ intro p ++ exact Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ simpa [Sτ] using ++ (Summable.sum_le_tsum (s := small) ++ (f := fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) ++ (fun p _ => hnn p) hsumτ) ++ have hgeom_sum : ++ (small.card : ℝ) ≤ ∑ p ∈ small, (4 * R) ^ τ * ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ have hcard_eq : (small.card : ℝ) = ∑ p ∈ small, (1 : ℝ) := by simp ++ rw [hcard_eq] ++ refine Finset.sum_le_sum (fun p hp => ?_) ++ have hp_le : ‖divisorZeroIndex₀Val p‖ ≤ 4 * R := hsmall p hp ++ have hap : 0 < ‖divisorZeroIndex₀Val p‖ := ++ norm_pos_iff.2 (divisorZeroIndex₀Val_ne_zero p) ++ have hbase : (1 : ℝ) ≤ (4 * R) / ‖divisorZeroIndex₀Val p‖ := by ++ exact (le_div_iff₀ hap).2 (by simpa [mul_one] using hp_le) ++ have : (1 : ℝ) ≤ ((4 * R) / ‖divisorZeroIndex₀Val p‖) ^ τ := ++ Real.one_le_rpow hbase hτ_nonneg ++ have hdiv : ++ ((4 * R) / ‖divisorZeroIndex₀Val p‖) ^ τ = ++ (4 * R) ^ τ * (‖divisorZeroIndex₀Val p‖)⁻¹ ^ τ := by ++ have h4 : 0 ≤ (4 * R : ℝ) := by nlinarith [le_of_lt hRpos] ++ have ha : 0 ≤ (‖divisorZeroIndex₀Val p‖ : ℝ)⁻¹ := by positivity ++ simpa [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm] using ++ (Real.mul_rpow (x := (4 * R : ℝ)) ++ (y := (‖divisorZeroIndex₀Val p‖ : ℝ)⁻¹) (z := τ) h4 ha) ++ have : (1 : ℝ) ≤ (4 * R) ^ τ * ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ simpa [hdiv] using this ++ exact this ++ have hgeom : ++ (small.card : ℝ) ≤ (4 * R) ^ τ * (∑ p ∈ small, ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by ++ simpa [Finset.mul_sum] using hgeom_sum ++ have hsmall_le : (small.card : ℝ) ≤ (4 * R) ^ τ * Sτ := by ++ exact hgeom.trans (mul_le_mul_of_nonneg_left hsum_le (by positivity)) ++ have hS_le : (4 * R) ^ τ * Sτ ≤ (4 * R) ^ τ * (Sτ + 1) := by ++ refine mul_le_mul_of_nonneg_left ?_ (by positivity) ++ linarith ++ have : (small.card : ℝ) ≤ (4 * R) ^ τ * (Sτ + 1) := hsmall_le.trans hS_le ++ simpa [Sτ, add_comm, add_left_comm, add_assoc, mul_assoc] using this ++ ++lemma cartan_rpow_mul_le ++ {τ R r : ℝ} (hRpos : 0 < R) (hrpos : 0 < r) (hR_le_r : R ≤ r) (hτ_nonneg : 0 ≤ τ) : ++ (4 * R) ^ τ ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ := by ++ have hR_le_1r : R ≤ 1 + r := by linarith [hR_le_r, le_of_lt hrpos] ++ have hbase0 : 0 ≤ (4 * R : ℝ) := by nlinarith [le_of_lt hRpos] ++ have : (4 * R) ^ τ ≤ (4 * (1 + r)) ^ τ := by ++ refine Real.rpow_le_rpow hbase0 ?_ hτ_nonneg ++ nlinarith [hR_le_1r] ++ have hmul : (4 * (1 + r)) ^ τ = (4 : ℝ) ^ τ * (1 + r) ^ τ := by ++ have h4 : 0 ≤ (4 : ℝ) := by norm_num ++ have h1 : 0 ≤ (1 + r : ℝ) := by positivity ++ simpa [mul_assoc] using ++ (Real.mul_rpow (x := (4 : ℝ)) (y := (1 + r : ℝ)) (z := τ) h4 h1) ++ simpa [hmul] using this ++ ++open Classical in ++theorem cartan_sum_majorant_le ++ {f : ℂ → ℂ} {m : ℕ} {τ R r : ℝ} ++ (hRpos : 0 < R) ++ (hrpos : 0 < r) ++ (hR_le_r : R ≤ r) ++ (hτ_nonneg : 0 ≤ τ) ++ (smallSet : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))) ++ (hsmall_fin : smallSet.Finite) ++ (hsmallSet : ++ smallSet = {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ‖divisorZeroIndex₀Val p‖ ≤ 4 * R}) ++ (hsumτ : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) ++ (hr_phi : ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ let a : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ (∑ p ∈ small, CartanBound.φ (r / a p)) ≤ CartanBound.Cφ * (small.card : ℝ)) : ++ let small : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := hsmall_fin.toFinset ++ letI : DecidableEq (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := Classical.decEq _ ++ let ap : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := fun p => ‖divisorZeroIndex₀Val p‖ ++ let b : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => ++ if p ∈ small then ++ CartanBound.φ (r / ap p) + (m : ℝ) * (1 + (r / ap p) ^ τ) ++ else ++ (2 : ℝ) * (r / ap p) ^ τ ++ let Sτ : ℝ := ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ ++ let Cprod : ℝ := cartanProductConstant m τ Sτ ++ ∀ s : Finset (divisorZeroIndex₀ f (Set.univ : Set ℂ)), ++ (∑ p ∈ s, b p) ≤ Cprod * (1 + r) ^ τ := by ++ classical ++ intro small ap b Sτ Cprod s ++ have hr : 0 ≤ r := le_of_lt hrpos ++ have hSτ_nonneg : 0 ≤ Sτ := ++ tsum_nonneg (fun _ => Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _) ++ have hsmall_mem : ∀ p, p ∈ small ↔ p ∈ smallSet := by ++ intro p ++ simp [small, hsmall_fin.mem_toFinset] ++ have hphi_sum : ++ (∑ p ∈ small, CartanBound.φ (r / ap p)) ≤ CartanBound.Cφ * (small.card : ℝ) := by ++ simpa [small, ap] using hr_phi ++ have hb_nonneg : ∀ p, 0 ≤ b p := by ++ simpa [ap, b] using (cartan_majorant_nonneg (f := f) (m := m) (τ := τ) (r := r) hr small) ++ have hb_summable : Summable b := by ++ simpa [ap, b] using ++ (cartan_majorant_summable (f := f) (m := m) (τ := τ) (r := r) hr small hsumτ) ++ have hsmall_norm : ∀ p ∈ small, ‖divisorZeroIndex₀Val p‖ ≤ 4 * R := by ++ intro p hp ++ have : p ∈ smallSet := (hsmall_mem p).1 hp ++ simpa [hsmallSet] using this ++ have hcard_le : (small.card : ℝ) ≤ (4 * R) ^ τ * (Sτ + 1) := by ++ simpa [Sτ, mul_assoc, add_assoc, add_left_comm, add_comm] using ++ (cartan_card_small_le (f := f) (τ := τ) (R := R) hRpos hτ_nonneg small hsmall_norm hsumτ) ++ have hpowR : (4 * R) ^ τ ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ := ++ cartan_rpow_mul_le (τ := τ) (R := R) (r := r) hRpos hrpos hR_le_r hτ_nonneg ++ have hcard_le' : (small.card : ℝ) ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ * (Sτ + 1) := by ++ have : (4 * R) ^ τ * (Sτ + 1) ≤ (4 : ℝ) ^ τ * (1 + r) ^ τ * (Sτ + 1) := by ++ exact mul_le_mul_of_nonneg_right hpowR (by linarith [hSτ_nonneg]) ++ exact le_trans hcard_le this ++ have hb_tsum_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b p) ≤ Cprod * (1 + r) ^ τ := by ++ let bφ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then CartanBound.φ (r / ap p) else 0 ++ let b0 : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then (m : ℝ) else 0 ++ let bmτ : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => if p ∈ small then (m : ℝ) * (r / ap p) ^ τ else 0 ++ let bt : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℝ := ++ fun p => (2 : ℝ) * (r / ap p) ^ τ ++ have hb_pointwise : ∀ p, b p ≤ bφ p + b0 p + bmτ p + bt p := by ++ intro p ++ by_cases hp : p ∈ small ++ · have hbase : 0 ≤ r / ap p := div_nonneg hr (by positivity) ++ have hx : 0 ≤ (r / ap p) ^ τ := Real.rpow_nonneg hbase τ ++ have hpos : 0 ≤ (2 : ℝ) * (r / ap p) ^ τ := mul_nonneg (by norm_num) hx ++ simp [b, bφ, b0, bmτ, bt, hp] ++ nlinarith ++ · simp [b, bφ, b0, bmτ, bt, hp] ++ have hmaj_summ : Summable (fun p => bφ p + b0 p + bmτ p + bt p) := by ++ have hbφ_summ : Summable bφ := by ++ simpa [bφ] using summable_ite_mem_finset small (fun p => CartanBound.φ (r / ap p)) ++ have hb0_summ : Summable b0 := by ++ simpa [b0] using summable_ite_mem_finset small (fun _ => (m : ℝ)) ++ have hbmτ_summ : Summable bmτ := by ++ simpa [bmτ] using summable_ite_mem_finset small (fun p => (m : ℝ) * (r / ap p) ^ τ) ++ have hbt_summ : Summable bt := by ++ have hconst : Summable (fun p => ++ (2 : ℝ) * (r ^ τ) * (‖divisorZeroIndex₀Val p‖⁻¹ ^ τ)) := ++ hsumτ.mul_left ((2 : ℝ) * (r ^ τ)) ++ refine hconst.congr ?_ ++ intro p ++ simp [bt, ap, rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p, ++ mul_assoc, mul_left_comm, mul_comm] ++ have h' : Summable (fun p => bφ p + b0 p + (bmτ p + bt p)) := ++ (hbφ_summ.add hb0_summ).add (hbmτ_summ.add hbt_summ) ++ simpa [add_assoc] using h' ++ have htsum_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b p) ++ ≤ ∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p) := ++ (hasSum_le hb_pointwise hb_summable.hasSum hmaj_summ.hasSum) ++ have htsum_bφ : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ++ = ∑ p ∈ small, CartanBound.φ (r / ap p) := by ++ classical ++ simpa [bφ] using tsum_ite_mem_finset small (fun p => CartanBound.φ (r / ap p)) ++ have htsum_b0 : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ++ = (m : ℝ) * (small.card : ℝ) := by ++ classical ++ have : (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) = ∑ p ∈ small, (m : ℝ) := by ++ simpa [b0] using tsum_ite_mem_finset small (fun _ => (m : ℝ)) ++ simp [this, Finset.sum_const, nsmul_eq_mul, mul_comm] ++ have htsum_bmτ : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ = (m : ℝ) * ∑ p ∈ small, (r / ap p) ^ τ := by ++ classical ++ have : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ = ∑ p ∈ small, (m : ℝ) * (r / ap p) ^ τ := by ++ simpa [bmτ] using tsum_ite_mem_finset small (fun p => (m : ℝ) * (r / ap p) ^ τ) ++ simp [this, Finset.mul_sum] ++ have htsum_bt : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bt p) ++ ≤ (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [bt, ap, Sτ] using ++ tsum_two_mul_rpow_div_norm_divisorZeroIndex₀_le (f := f) (τ := τ) hr hτ_nonneg ++ have hsum_small_rpow_le : ++ (∑ p ∈ small, (r / ap p) ^ τ) ≤ (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [ap, Sτ] using ++ sum_rpow_div_norm_divisorZeroIndex₀_le (f := f) (τ := τ) small hr hτ_nonneg hsumτ ++ have hm0 : 0 ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ have hCφ : 0 ≤ CartanBound.Cφ := le_of_lt CartanBound.Cφ_pos ++ have hS : 0 ≤ Sτ + 1 := by linarith [hSτ_nonneg] ++ have htsum_majorant : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p)) ++ ≤ (((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 2) * (Sτ + 1)) ++ * (1 + r) ^ τ := by ++ have hφ_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ++ ≤ CartanBound.Cφ * (small.card : ℝ) := by ++ simpa [htsum_bφ] using hphi_sum ++ have hb0_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ++ ≤ (m : ℝ) * (small.card : ℝ) := by ++ simp [htsum_b0] ++ have hbmτ_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ≤ ++ (m : ℝ) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have h0 : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ ≤ (m : ℝ) * ((Sτ + 1) * (1 + r) ^ τ) := by ++ have hmul := mul_le_mul_of_nonneg_left hsum_small_rpow_le hm0 ++ ++ simpa [htsum_bmτ, mul_assoc, mul_left_comm, mul_comm] using hmul ++ have h1 : (1 : ℝ) ≤ (4 : ℝ) ^ τ := ++ Real.one_le_rpow (by norm_num) hτ_nonneg ++ have hscale : ++ (m : ℝ) * ((Sτ + 1) * (1 + r) ^ τ) ++ ≤ (m : ℝ) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have hnonneg : 0 ≤ (m : ℝ) * ((Sτ + 1) * (1 + r) ^ τ) := by ++ have : 0 ≤ (Sτ + 1) * (1 + r) ^ τ := by positivity ++ exact mul_nonneg hm0 this ++ simpa [mul_assoc, mul_left_comm, mul_comm] using (mul_le_mul_of_nonneg_right h1 hnonneg) ++ exact h0.trans hscale ++ have hbt_le : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bt p) ++ ≤ (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using htsum_bt ++ have hsplit : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p)) ++ = (∑' p, bφ p) + (∑' p, b0 p) + (∑' p, bmτ p) + (∑' p, bt p) := by ++ classical ++ have hbφ_summ : Summable bφ := by ++ simpa [bφ] using summable_ite_mem_finset small (fun p => CartanBound.φ (r / ap p)) ++ have hb0_summ : Summable b0 := by ++ simpa [b0] using summable_ite_mem_finset small (fun _ => (m : ℝ)) ++ have hbmτ_summ : Summable bmτ := by ++ simpa [bmτ] using summable_ite_mem_finset small (fun p => (m : ℝ) * (r / ap p) ^ τ) ++ have hbt_summ : Summable bt := by ++ have hconst : ++ Summable ++ (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ (2 : ℝ) * (r ^ τ) * ((‖divisorZeroIndex₀Val p‖⁻¹ : ℝ) ^ τ)) := ++ hsumτ.mul_left ((2 : ℝ) * (r ^ τ)) ++ refine hconst.congr ?_ ++ intro p ++ simp [bt, ap, rpow_div_norm_divisorZeroIndex₀_eq (f := f) (τ := τ) hr p, ++ mul_assoc, mul_left_comm, mul_comm] ++ exact tsum_add_four bφ b0 bmτ bt hbφ_summ hb0_summ hbmτ_summ hbt_summ ++ have hcard_le'' : ++ (small.card : ℝ) ≤ (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ simpa [mul_assoc, mul_left_comm, mul_comm] using hcard_le' ++ have hφ_le' : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ≤ ++ CartanBound.Cφ * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have : CartanBound.Cφ * (small.card : ℝ) ≤ ++ CartanBound.Cφ * ((4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ) := ++ mul_le_mul_of_nonneg_left hcard_le'' hCφ ++ exact hφ_le.trans (by simpa [mul_assoc, mul_left_comm, mul_comm] using this) ++ have hb0_le' : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ≤ ++ (m : ℝ) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ := by ++ have : (m : ℝ) * (small.card : ℝ) ≤ (m : ℝ) * ((4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ) := ++ mul_le_mul_of_nonneg_left hcard_le'' hm0 ++ exact hb0_le.trans (by simpa [mul_assoc, mul_left_comm, mul_comm] using this) ++ have htsum_majorant' : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), (bφ p + b0 p + bmτ p + bt p)) ++ ≤ (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ ++ + (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ := by ++ rw [hsplit] ++ set Y : ℝ := Sτ + 1 with hY ++ set T : ℝ := (1 + r) ^ τ with hT ++ have hφ_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bφ p) ++ ≤ CartanBound.Cφ * (4 : ℝ) ^ τ * Y * T := by ++ simpa [hY, hT, mul_assoc] using hφ_le' ++ have hb0_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b0 p) ++ ≤ (m : ℝ) * (4 : ℝ) ^ τ * Y * T := by ++ simpa [hY, hT, mul_assoc] using hb0_le' ++ have hbmτ_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bmτ p) ++ ≤ (m : ℝ) * (4 : ℝ) ^ τ * Y * T := by ++ simpa [hY, hT, mul_assoc] using hbmτ_le ++ have hbt_leY : ++ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), bt p) ≤ (2 : ℝ) * Y * T := by ++ simpa [hY, hT, mul_assoc] using hbt_le ++ have hmain := ++ cartan_majorant_four_term_bound ++ (q := (4 : ℝ) ^ τ) hφ_leY hb0_leY hbmτ_leY hbt_leY ++ simpa [Y, T, add_assoc] using hmain ++ have hring : ++ (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ * (Sτ + 1) * (1 + r) ^ τ ++ + (2 : ℝ) * (Sτ + 1) * (1 + r) ^ τ ++ = (((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 2) * (Sτ + 1)) * (1 + r) ^ τ := by ++ exact cartan_majorant_add_two_factor ++ ((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ) (Sτ + 1) ((1 + r) ^ τ) ++ rw [← hring] ++ exact htsum_majorant' ++ have hCprod' : ++ (((CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ + 2) * (Sτ + 1)) * (1 + r) ^ τ ++ ≤ Cprod * (1 + r) ^ τ := by ++ simpa [Cprod, cartanProductConstant, mul_assoc, mul_left_comm, mul_comm] using ++ cartan_majorant_pad_two_to_three ++ (A := (CartanBound.Cφ + (2 : ℝ) * m) * (4 : ℝ) ^ τ) ++ (S := Sτ) (T := (1 + r) ^ τ) hS (by positivity) ++ exact (le_trans (le_trans htsum_le htsum_majorant) hCprod') ++ have hsum_fin_le : ++ (∑ p ∈ s, b p) ≤ (∑' p : divisorZeroIndex₀ f (Set.univ : Set ℂ), b p) := by ++ simpa using ++ (Summable.sum_le_tsum (s := s) (f := b) (fun p _ => hb_nonneg p) hb_summable) ++ exact hsum_fin_le.trans hb_tsum_le ++ ++end Complex.Hadamard ++end ++end ++section ++noncomputable section ++ ++open scoped BigOperators ++open Filter Finset _root_.Real _root_.SiegelZeros.Real Topology ++ ++lemma Finset.prod_le_exp_sum {α : Type} (s : Finset α) (a : α → ℝ) (b : α → ℝ) ++ (ha : ∀ x ∈ s, 0 ≤ a x) (hab : ∀ x ∈ s, a x ≤ Real.exp (b x)) : ++ (∏ x ∈ s, a x) ≤ Real.exp (∑ x ∈ s, b x) := by ++ calc ++ (∏ x ∈ s, a x) ≤ ∏ x ∈ s, Real.exp (b x) := Finset.prod_le_prod₀ ha hab ++ _ = Real.exp (∑ x ∈ s, b x) := by ++ simpa using (Real.exp_sum (s := s) (f := b)).symm ++ ++lemma hasProd_le_of_prod_le_exp {α : Type} {f : α → ℝ} {a : ℝ} ++ (hf : HasProd f a (SummationFilter.unconditional α)) ++ {B : ℝ} (hB : ∀ s : Finset α, (∏ x ∈ s, f x) ≤ Real.exp B) : ++ a ≤ Real.exp B := ++ hasProd_le_of_prod_le (L := (SummationFilter.unconditional α)) hf hB ++ ++lemma hasProd_inv_unconditional {α : Type} {fac : α → ℂ} {F : ℂ} ++ (hfac : HasProd fac F (SummationFilter.unconditional α)) (hF : F ≠ 0) : ++ HasProd (fun x => (fac x)⁻¹) (F⁻¹) (SummationFilter.unconditional α) := by ++ change ++ Tendsto (fun s : Finset α => ∏ x ∈ s, (fac x)⁻¹) ++ (SummationFilter.unconditional α).filter (𝓝 (F⁻¹)) ++ have hprod : ++ Tendsto (fun s : Finset α => ∏ x ∈ s, fac x) ++ (SummationFilter.unconditional α).filter (𝓝 F) := by ++ simpa [HasProd] using hfac ++ have hinv : ++ Tendsto (fun s : Finset α => (∏ x ∈ s, fac x)⁻¹) ++ (SummationFilter.unconditional α).filter (𝓝 (F⁻¹)) := ++ hprod.inv₀ hF ++ refine hinv.congr' (Filter.Eventually.of_forall ?_) ++ intro s ++ simp [Finset.prod_inv_distrib] ++ ++lemma hasProd_norm_inv_unconditional {α : Type} {fac : α → ℂ} {F : ℂ} ++ (hfac : HasProd fac F (SummationFilter.unconditional α)) (hF : F ≠ 0) : ++ HasProd (fun x => ‖(fac x)⁻¹‖) ‖F⁻¹‖ (SummationFilter.unconditional α) := by ++ change ++ Tendsto (fun s : Finset α => ∏ x ∈ s, ‖(fac x)⁻¹‖) ++ (SummationFilter.unconditional α).filter (𝓝 ‖F⁻¹‖) ++ have hnorm := (hasProd_inv_unconditional hfac hF).norm ++ refine hnorm.congr' (Filter.Eventually.of_forall ?_) ++ intro s ++ simp [norm_inv, Finset.prod_inv_distrib] ++ ++lemma hasProd_norm_inv_le_exp_of_pointwise_le_exp {α : Type} {fac : α → ℂ} {F : ℂ} ++ (hfac : HasProd fac F (SummationFilter.unconditional α)) ++ (b : α → ℝ) (B : ℝ) ++ (hterm : ∀ x, ‖(fac x)⁻¹‖ ≤ Real.exp (b x)) ++ (hsum : ∀ s : Finset α, (∑ x ∈ s, b x) ≤ B) : ++ ‖F⁻¹‖ ≤ Real.exp B := by ++ by_cases hF : F = 0 ++ · subst hF ++ simpa using exp_nonneg B ++ have hnorm : ++ HasProd (fun x => ‖(fac x)⁻¹‖) ‖F⁻¹‖ (SummationFilter.unconditional α) := ++ hasProd_norm_inv_unconditional hfac hF ++ have hprod : ∀ s : Finset α, (∏ x ∈ s, ‖(fac x)⁻¹‖) ≤ Real.exp B := by ++ intro s ++ have h0 : ∀ x ∈ s, 0 ≤ ‖(fac x)⁻¹‖ := by intro _ _; positivity ++ have h1 : (∏ x ∈ s, ‖(fac x)⁻¹‖) ≤ Real.exp (∑ x ∈ s, b x) := by ++ refine Finset.prod_le_exp_sum s (a := fun x => ‖(fac x)⁻¹‖) (b := b) h0 ?_ ++ intro x hx ++ simpa using hterm x ++ have h2 : Real.exp (∑ x ∈ s, b x) ≤ Real.exp B := ++ Real.exp_le_exp.2 (hsum s) ++ exact h1.trans h2 ++ exact hasProd_le_of_prod_le_exp hnorm hprod ++end ++end ++section ++open Metric ++ ++namespace Complex ++ ++theorem borelCaratheodory_zero_closedBall {f : ℂ → ℂ} {M r R : ℝ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ (hr : 0 < r) (hlt : r < R) (hM : 0 < M) (hf0 : f 0 = 0) ++ (hf_re : ∀ w, ‖w‖ ≤ R → (f w).re ≤ M) {z : ℂ} (hz : ‖z‖ ≤ r) : ++ ‖f z‖ ≤ 2 * M * r / (R - r) := by ++ have hR : 0 < R := lt_trans hr hlt ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) R := by ++ rw [Metric.mem_ball, dist_zero_right] ++ exact hz.trans_lt hlt ++ have hf_diff : DifferentiableOn ℂ f (Metric.ball (0 : ℂ) R) := by ++ intro w hw ++ have hw' : w ∈ Metric.closedBall (0 : ℂ) R := ball_subset_closedBall hw ++ exact (hf w hw').differentiableAt.differentiableWithinAt ++ have hf_map : Set.MapsTo f (Metric.ball (0 : ℂ) R) {w | w.re ≤ M} := by ++ intro w hw ++ simp only [Set.mem_ofPred_eq] ++ have hw' : ‖w‖ < R := by simpa [Metric.mem_ball, dist_zero_right] using hw ++ exact hf_re w hw'.le ++ have hbc := ++ _root_.Complex.borelCaratheodory_zero hM hf_diff hf_map hR hz_ball hf0 ++ have hzR : ‖z‖ < R := by ++ rw [Metric.mem_ball, dist_zero_right] at hz_ball ++ exact hz_ball ++ have hmono : ‖z‖ / (R - ‖z‖) ≤ r / (R - r) := by ++ have hrden : 0 < R - r := sub_pos.mpr hlt ++ have hden : 0 < R - ‖z‖ := sub_pos.mpr hzR ++ rw [div_le_div_iff₀ hden hrden] ++ nlinarith [hz, norm_nonneg z] ++ have hM' : 0 ≤ 2 * M := mul_nonneg (by norm_num) (le_of_lt hM) ++ calc ‖f z‖ ++ ≤ 2 * M * ‖z‖ / (R - ‖z‖) := hbc ++ _ ≤ 2 * M * (r / (R - r)) := by ++ simpa [mul_div_assoc] using mul_le_mul_of_nonneg_left hmono hM' ++ _ = 2 * M * r / (R - r) := by ring ++ ++end Complex ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/Products.lean b/PrimeNumberTheoremAnd/SiegelZeros/Products.lean +new file mode 100644 +index 0000000..db0daa8 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/Products.lean +@@ -0,0 +1,496 @@ ++import Mathlib ++ ++namespace SiegelZeros ++ ++open _root_.Complex ++ ++section ++open scoped BigOperators ++ ++namespace Real ++ ++lemma pow_div_one_sub_le_two_mul {r : ℝ} (hr : 0 ≤ r) (hrhalf : r ≤ 1 / 2) (m : ℕ) : ++ r ^ (m + 1) / (1 - r) ≤ 2 * r ^ (m + 1) := by ++ have hpow : 0 ≤ r ^ (m + 1) := pow_nonneg hr _ ++ have hhalf' : (1 / 2 : ℝ) ≤ 1 - r := by linarith ++ calc ++ r ^ (m + 1) / (1 - r) ≤ r ^ (m + 1) / (1 / 2 : ℝ) := by ++ exact div_le_div_of_nonneg_left hpow (by positivity) hhalf' ++ _ = 2 * r ^ (m + 1) := by ring ++ ++end Real ++ ++namespace Complex ++ ++open scoped BigOperators in ++ ++lemma neg_log_one_sub_eq_tsum {z : ℂ} (hz : ‖z‖ < 1) : ++ -log (1 - z) = ∑' n : ℕ, z ^ (n + 1) / (n + 1) := by ++ have h := hasSum_taylorSeries_neg_log hz ++ rw [← h.tsum_eq, h.summable.tsum_eq_zero_add] ++ simp only [pow_zero, Nat.cast_zero, div_zero, zero_add, Nat.cast_add, Nat.cast_one] ++ ++noncomputable ++def partialLogSum (m : ℕ) (z : ℂ) : ℂ := ++ -logTaylor (m + 1) (-z) ++ ++@[simp] ++lemma partialLogSum_zero (z : ℂ) : partialLogSum 0 z = 0 := by ++ simp [partialLogSum, logTaylor_succ, logTaylor_zero] ++ ++@[simp] ++lemma partialLogSum_at_zero (m : ℕ) : partialLogSum m 0 = 0 := by ++ simp [partialLogSum, logTaylor_at_zero] ++ ++lemma logTaylor_succ_neg (n : ℕ) (z : ℂ) : ++ logTaylor (n + 1) (-z) = logTaylor n (-z) - z ^ n / n := by ++ rw [logTaylor_succ, Pi.add_apply] ++ have hsign : (-1 : ℂ) ^ (n + 1) * (-z) ^ n = -z ^ n := by ++ have hzpow : (-z) ^ n = (((-1 : ℂ) * z) ^ n) := by simp ++ rw [hzpow, mul_pow, ← mul_assoc, ← pow_add] ++ have hpow : (-1 : ℂ) ^ (n + 1 + n) = (-1 : ℂ) := by ++ rw [show n + 1 + n = 2 * n + 1 by omega, pow_add, pow_mul] ++ norm_num ++ rw [hpow] ++ ring ++ rw [show (-1 : ℂ) ^ (n + 1) * (-z) ^ n / n = -(z ^ n / n) by ++ rw [hsign] ++ ring] ++ abel ++ ++lemma logTaylor_neg_eq_neg_sum (m : ℕ) (z : ℂ) : ++ logTaylor (m + 1) (-z) = -∑ k ∈ Finset.range m, z ^ (k + 1) / (k + 1) := by ++ induction m with ++ | zero => ++ simp [logTaylor_succ, logTaylor_zero] ++ | succ m hm => ++ rw [logTaylor_succ_neg, hm, Finset.sum_range_succ] ++ have hcast : ((m + 1 : ℕ) : ℂ) = (1 + (m : ℂ)) := by ++ simp [Nat.cast_add, Nat.cast_one, add_comm] ++ rw [hcast] ++ ring_nf ++ ++lemma partialLogSum_eq_sum (m : ℕ) (z : ℂ) : ++ partialLogSum m z = ∑ k ∈ Finset.range m, z ^ (k + 1) / (k + 1) := by ++ simpa [partialLogSum] using congrArg Neg.neg (logTaylor_neg_eq_neg_sum m z) ++ ++lemma hasDerivAt_partialLogSum (m : ℕ) (z : ℂ) : ++ HasDerivAt (partialLogSum m) (∑ j ∈ Finset.range m, z ^ j) z := by ++ cases m with ++ | zero => ++ have hzero : partialLogSum 0 = fun _ : ℂ ↦ (0 : ℂ) := by ++ funext w ++ exact partialLogSum_zero w ++ simpa [hzero] using (hasDerivAt_const z (c := (0 : ℂ))) ++ | succ m => ++ have hsum : ++ (∑ j ∈ Finset.range (m + 1), z ^ j) = ++ ∑ j ∈ Finset.range (m + 1), (-1) ^ j * (-z) ^ j := by ++ refine Finset.sum_congr rfl ?_ ++ intro j hj ++ symm ++ calc ++ (-1 : ℂ) ^ j * (-z) ^ j = (-1 : ℂ) ^ j * (((-1 : ℂ) * z) ^ j) := by simp ++ _ = ((-1 : ℂ) ^ j * (-1 : ℂ) ^ j) * z ^ j := by rw [mul_pow]; ring ++ _ = z ^ j := by ++ rw [← pow_add, show j + j = 2 * j by omega, pow_mul] ++ norm_num ++ rw [hsum] ++ simpa [partialLogSum] using! ++ (((hasDerivAt_logTaylor (m + 1) (-z)).comp z (hasDerivAt_neg z)).neg) ++ ++lemma differentiable_partialLogSum (m : ℕ) : ++ Differentiable ℂ (fun z : ℂ => partialLogSum m z) := by ++ intro z ++ exact (hasDerivAt_partialLogSum m z).differentiableAt ++ ++noncomputable ++def logTail (m : ℕ) (z : ℂ) : ℂ := ++ ∑' k, z ^ (m + 1 + k) / (m + 1 + k) ++ ++lemma summable_logTail {z : ℂ} (hz : ‖z‖ < 1) (m : ℕ) : ++ Summable (fun k => z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)) := by ++ have h_geom : Summable (fun k : ℕ => ‖z‖ ^ k) := ++ summable_geometric_of_lt_one (norm_nonneg z) hz ++ refine Summable.of_norm_bounded (g := fun k => ‖z‖ ^ k) h_geom ?_ ++ intro k ++ rw [norm_div, norm_pow] ++ have h1 : (1 : ℝ) ≤ (m + 1 + k : ℝ) := by ++ have : (0 : ℝ) ≤ (m + k : ℝ) := by positivity ++ nlinarith ++ have hnorm : ‖(↑m + 1 + ↑k : ℂ)‖ = (m + 1 + k : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (m + 1 + k)) ++ rw [hnorm] ++ calc ++ ‖z‖ ^ (m + 1 + k) / (m + 1 + k : ℝ) ≤ ‖z‖ ^ (m + 1 + k) := by ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) h1 ++ _ = ‖z‖ ^ (m + 1) * ‖z‖ ^ k := by rw [pow_add] ++ _ ≤ 1 * ‖z‖ ^ k := by ++ refine mul_le_mul_of_nonneg_right ?_ (pow_nonneg (norm_nonneg z) k) ++ exact pow_le_one₀ (norm_nonneg z) (le_of_lt hz) ++ _ = ‖z‖ ^ k := one_mul _ ++ ++lemma norm_logTail_le {z : ℂ} (hz : ‖z‖ < 1) (m : ℕ) : ++ ‖logTail m z‖ ≤ ‖z‖ ^ (m + 1) / (1 - ‖z‖) := by ++ dsimp only [logTail] ++ have h_rhs_summable : Summable (fun k => ‖z‖ ^ (m + 1 + k)) := by ++ simpa [pow_add] using ++ (summable_geometric_of_lt_one (norm_nonneg z) hz).mul_left (‖z‖ ^ (m + 1)) ++ have h_norm_summable : Summable (fun k => ‖z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)‖) := by ++ refine Summable.of_nonneg_of_le (fun _ => norm_nonneg _) ?_ h_rhs_summable ++ intro k ++ rw [norm_div, norm_pow] ++ have hnorm : ‖(↑m + 1 + ↑k : ℂ)‖ = (m + 1 + k : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (m + 1 + k)) ++ rw [hnorm] ++ have hm : 1 ≤ (m + 1 + k : ℝ) := by ++ have : (0 : ℝ) ≤ (m + k : ℝ) := by positivity ++ nlinarith ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) hm ++ calc ++ ‖∑' k, z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)‖ ++ ≤ ∑' k, ‖z ^ (m + 1 + k) / ((m + 1 + k) : ℂ)‖ := ++ norm_tsum_le_tsum_norm h_norm_summable ++ _ ≤ ∑' k, ‖z‖ ^ (m + 1 + k) := by ++ refine h_norm_summable.tsum_le_tsum ?_ h_rhs_summable ++ intro k ++ rw [norm_div, norm_pow] ++ have hm : 1 ≤ (m + 1 + k : ℝ) := by ++ have : (0 : ℝ) ≤ (m + k : ℝ) := by positivity ++ nlinarith ++ have hnorm : ‖(↑m + 1 + ↑k : ℂ)‖ = (m + 1 + k : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (m + 1 + k)) ++ rw [hnorm] ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) hm ++ _ = ‖z‖ ^ (m + 1) / (1 - ‖z‖) := by ++ have h_eq : ++ (fun k => ‖z‖ ^ (m + 1 + k)) = fun k => ‖z‖ ^ (m + 1) * ‖z‖ ^ k := by ++ ext k ++ rw [pow_add] ++ rw [h_eq, tsum_mul_left] ++ have h_geom := hasSum_geometric_of_lt_one (norm_nonneg z) hz ++ rw [h_geom.tsum_eq, div_eq_mul_inv] ++ ++lemma norm_logTail_le_two_mul_norm_pow {z : ℂ} (hz : ‖z‖ < 1) (hzhalf : ‖z‖ ≤ 1 / 2) (m : ℕ) : ++ ‖logTail m z‖ ≤ 2 * ‖z‖ ^ (m + 1) := ++ (norm_logTail_le hz m).trans (Real.pow_div_one_sub_le_two_mul (norm_nonneg z) hzhalf m) ++ ++lemma norm_partialLogSum_le_nat_mul_max_one_norm_pow (m : ℕ) (z : ℂ) : ++ ‖partialLogSum m z‖ ≤ (m : ℝ) * max 1 (‖z‖ ^ m) := by ++ have hsum : ++ ‖partialLogSum m z‖ ≤ ∑ k ∈ Finset.range m, ‖z ^ (k + 1) / (k + 1)‖ := by ++ rw [partialLogSum_eq_sum] ++ exact norm_sum_le _ _ ++ have hterm : ∀ k ∈ Finset.range m, ‖z ^ (k + 1) / (k + 1)‖ ≤ max 1 (‖z‖ ^ m) := by ++ intro k hk ++ rw [norm_div, norm_pow] ++ have hk1 : (1 : ℝ) ≤ (k : ℝ) + 1 := by ++ have hk1_nat : (1 : ℕ) ≤ k + 1 := Nat.succ_le_succ (Nat.zero_le k) ++ exact_mod_cast hk1_nat ++ have hdenom : ‖((k : ℂ) + 1)‖ = (k : ℝ) + 1 := by ++ simpa [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (Complex.norm_natCast (k + 1)) ++ have hk_le : k + 1 ≤ m := Nat.succ_le_iff.2 (Finset.mem_range.1 hk) ++ have hpow_le : ‖z‖ ^ (k + 1) ≤ max 1 (‖z‖ ^ m) := by ++ have hz0 : 0 ≤ ‖z‖ := norm_nonneg z ++ by_cases hz1 : ‖z‖ ≤ (1 : ℝ) ++ · have : ‖z‖ ^ (k + 1) ≤ 1 := by exact pow_le_one₀ hz0 hz1 ++ exact this.trans (le_max_left _ _) ++ · have hz1' : (1 : ℝ) ≤ ‖z‖ := le_of_lt (lt_of_not_ge hz1) ++ have : ‖z‖ ^ (k + 1) ≤ ‖z‖ ^ m := pow_le_pow_right₀ hz1' hk_le ++ exact this.trans (le_max_right _ _) ++ calc ++ ‖z‖ ^ (k + 1) / ‖((k : ℂ) + 1)‖ = ‖z‖ ^ (k + 1) / ((k : ℝ) + 1) := by simp [hdenom] ++ _ ≤ ‖z‖ ^ (k + 1) := by ++ exact div_le_self (pow_nonneg (norm_nonneg z) _) hk1 ++ _ ≤ max 1 (‖z‖ ^ m) := hpow_le ++ have hsum_le : ++ (∑ k ∈ Finset.range m, ‖z ^ (k + 1) / (k + 1)‖) ≤ ++ ∑ _k ∈ Finset.range m, max 1 (‖z‖ ^ m) := ++ Finset.sum_le_sum (fun k hk => hterm k hk) ++ have hcard : ∑ _k ∈ Finset.range m, max 1 (‖z‖ ^ m) = (m : ℝ) * max 1 (‖z‖ ^ m) := by ++ simp [Finset.sum_const] ++ exact hsum.trans (hsum_le.trans_eq hcard) ++ ++lemma neg_log_one_sub_eq_partialLogSum_add_logTail {z : ℂ} (hz : ‖z‖ < 1) (m : ℕ) : ++ -log (1 - z) = partialLogSum m z + logTail m z := by ++ let f : ℕ → ℂ := fun k ↦ z ^ (k + 1) / ((k : ℂ) + 1) ++ have h_summable : Summable f := by ++ simpa [f, Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm] using ++ (summable_logTail hz 0) ++ have h_decomp := h_summable.sum_add_tsum_nat_add m ++ rw [neg_log_one_sub_eq_tsum hz, partialLogSum_eq_sum, ← h_decomp] ++ congr 1 ++ dsimp only [logTail] ++ refine tsum_congr fun k ↦ ?_ ++ simp only [f, Nat.cast_add] ++ ring_nf ++ ++end Complex ++end ++section ++noncomputable section ++ ++namespace Complex ++ ++variable {z : ℂ} ++ ++@[bound] ++theorem neg_norm_le_re (z : ℂ) : -‖z‖ ≤ z.re := ++ neg_le_of_abs_le (abs_re_le_norm z) ++ ++lemma norm_inv_pow_le_one_of_one_le_norm (u : ℂ) (n : ℕ) (hu : (1 : ℝ) ≤ ‖u‖) : ++ ‖(u ^ n)⁻¹‖ ≤ 1 := by ++ have hge : (1 : ℝ) ≤ ‖u ^ n‖ := by ++ rw [Complex.norm_pow] ++ exact one_le_pow₀ hu ++ calc ‖(u ^ n)⁻¹‖ = ‖(1 : ℂ) / u ^ n‖ := by rw [inv_eq_one_div] ++ _ = 1 / ‖u ^ n‖ := by ++ have hone : ‖(1 : ℂ)‖ = (1 : ℝ) := by simp ++ rw [Complex.norm_div, hone] ++ _ ≤ 1 := by simpa [one_div] using inv_le_one_of_one_le₀ hge ++ ++end Complex ++end ++end ++section ++noncomputable section ++ ++open scoped BigOperators ++open Set ++ ++namespace Complex ++ ++def weierstrassFactor (m : ℕ) (z : ℂ) : ℂ := ++ (1 - z) * exp (partialLogSum m z) ++ ++lemma weierstrassFactor_def (m : ℕ) (z : ℂ) : ++ weierstrassFactor m z = (1 - z) * exp (partialLogSum m z) := by ++ simp [weierstrassFactor] ++ ++@[simp] ++lemma weierstrassFactor_at_zero (m : ℕ) : weierstrassFactor m 0 = 1 := by ++ simp [weierstrassFactor, partialLogSum_at_zero] ++ ++lemma weierstrassFactor_eq_zero_iff (m : ℕ) (z : ℂ) : ++ weierstrassFactor m z = 0 ↔ z = 1 := by ++ constructor ++ · intro hz ++ rw [weierstrassFactor] at hz ++ rcases mul_eq_zero.mp hz with h1 | h2 ++ · exact (sub_eq_zero.mp h1).symm ++ · exact absurd h2 (exp_ne_zero _) ++ · rintro rfl ++ simp [weierstrassFactor] ++ ++lemma weierstrassFactor_ne_zero_iff (m : ℕ) (z : ℂ) : ++ weierstrassFactor m z ≠ 0 ↔ z ≠ 1 := by ++ simpa [ne_eq] using (not_congr (weierstrassFactor_eq_zero_iff (m := m) (z := z))) ++ ++lemma weierstrassFactor_ne_zero_of_ne_one (m : ℕ) {z : ℂ} (hz : z ≠ 1) : ++ weierstrassFactor m z ≠ 0 := ++ (weierstrassFactor_ne_zero_iff (m := m) (z := z)).2 hz ++ ++lemma differentiable_weierstrassFactor (m : ℕ) : ++ Differentiable ℂ (fun z : ℂ => weierstrassFactor m z) := by ++ simpa [weierstrassFactor] using! ++ ((differentiable_const (c := (1 : ℂ))).sub differentiable_id).mul ++ (differentiable_exp.comp (differentiable_partialLogSum m)) ++ ++theorem analyticOrderAt_weierstrassFactor_div_self (m : ℕ) {a : ℂ} (ha : a ≠ 0) : ++ analyticOrderAt (fun z : ℂ => weierstrassFactor m (z / a)) a = (1 : ℕ∞) := by ++ set F : ℂ → ℂ := fun z => weierstrassFactor m (z / a) ++ have hF : AnalyticAt ℂ F a := by ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / a) := by ++ simp [div_eq_mul_inv] ++ have hdiff : Differentiable ℂ F := (differentiable_weierstrassFactor m).comp hdiv ++ exact Differentiable.analyticAt (f := F) hdiff a ++ let g : ℂ → ℂ := fun z => (-a⁻¹) * Complex.exp (partialLogSum m (z / a)) ++ have hg : AnalyticAt ℂ g a := by ++ have hdiv : Differentiable ℂ (fun z : ℂ => z / a) := by ++ simp [div_eq_mul_inv] ++ have hpls : Differentiable ℂ (fun z : ℂ => partialLogSum m (z / a)) := ++ (differentiable_partialLogSum m).comp hdiv ++ have hexp : Differentiable ℂ (fun z : ℂ => Complex.exp (partialLogSum m (z / a))) := ++ (Complex.differentiable_exp).comp hpls ++ have hdiffg : Differentiable ℂ g := by ++ simpa [g] using hexp.const_mul (-a⁻¹ : ℂ) ++ exact Differentiable.analyticAt (f := g) hdiffg a ++ have hg0 : g a ≠ 0 := by ++ have hconst : (-a⁻¹ : ℂ) ≠ 0 := by simp [ha] ++ have hexp0 : Complex.exp (partialLogSum m (a / a)) ≠ 0 := ++ Complex.exp_ne_zero (partialLogSum m (a / a)) ++ simpa [g] using mul_ne_zero hconst hexp0 ++ refine (hF.analyticOrderAt_eq_natCast (n := 1)).2 ?_ ++ refine ⟨g, hg, hg0, ?_⟩ ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ have hlin : (1 - z / a) = (z - a) * (-a⁻¹) := by ++ have h1 : (1 : ℂ) = a * a⁻¹ := by simp [ha] ++ simp [div_eq_mul_inv, h1] ++ ring ++ simp only [F, g, pow_one, smul_eq_mul] ++ rw [weierstrassFactor_def] ++ simp [hlin, mul_assoc] ++ ++lemma weierstrassFactor_eq_exp_neg_tail (m : ℕ) {z : ℂ} (hz : ‖z‖ < 1) (hz1 : z ≠ 1) : ++ weierstrassFactor m z = exp (-logTail m z) := by ++ unfold weierstrassFactor ++ have hz_ne_1 : 1 - z ≠ 0 := sub_ne_zero.mpr hz1.symm ++ rw [← exp_log hz_ne_1, ← Complex.exp_add] ++ have hsum : log (1 - z) + partialLogSum m z = -logTail m z := by ++ have hdecomp := neg_log_one_sub_eq_partialLogSum_add_logTail hz m ++ calc ++ log (1 - z) + partialLogSum m z ++ = log (1 - z) + (partialLogSum m z + logTail m z) - logTail m z := by ring ++ _ = log (1 - z) + (-log (1 - z)) - logTail m z := by rw [hdecomp] ++ _ = -logTail m z := by ring ++ simp [hsum] ++ ++theorem weierstrassFactor_sub_one_pow_bound {m : ℕ} {z : ℂ} (hz : ‖z‖ ≤ 1 / 2) : ++ ‖weierstrassFactor m z - 1‖ ≤ 4 * ‖z‖ ^ (m + 1) := by ++ by_cases hm : m = 0 ++ · subst hm ++ have hmain : ‖(1 - z) - 1‖ ≤ 4 * ‖z‖ ^ 1 := by ++ have h : (1 - z) - 1 = -z := by ring ++ calc ++ ‖(1 - z) - 1‖ = ‖-z‖ := by simp [h] ++ _ = ‖z‖ := norm_neg z ++ _ = ‖z‖ ^ 1 := by simp ++ _ ≤ 4 * ‖z‖ ^ 1 := by nlinarith [pow_nonneg (norm_nonneg z) 1] ++ simpa [weierstrassFactor] using hmain ++ · have hz_lt : ‖z‖ < 1 := lt_of_le_of_lt hz (by norm_num) ++ by_cases hz1 : z = 1 ++ · exfalso; rw [hz1] at hz; norm_num at hz ++ have h_eq : weierstrassFactor m z = exp (-logTail m z) := ++ weierstrassFactor_eq_exp_neg_tail m hz_lt hz1 ++ rw [h_eq] ++ have h_tail_bound := norm_logTail_le_two_mul_norm_pow hz_lt hz m ++ have hw_le_one : ‖-logTail m z‖ ≤ 1 := by ++ simp only [norm_neg] ++ have : ‖logTail m z‖ ≤ 1 := by ++ have hm_pos : 0 < m := Nat.pos_of_ne_zero hm ++ have h2 : 2 ≤ m + 1 := by ++ exact Nat.succ_le_succ (Nat.succ_le_iff.2 hm_pos) ++ have hpow : (‖z‖ ^ (m + 1)) ≤ (‖z‖ ^ 2) := by ++ have hz1' : ‖z‖ ≤ 1 := by nlinarith [hz] ++ have hz0' : 0 ≤ ‖z‖ := norm_nonneg z ++ exact pow_le_pow_of_le_one hz0' hz1' h2 ++ have hmul : 2 * ‖z‖ ^ (m + 1) ≤ 2 * ‖z‖ ^ 2 := by gcongr ++ have hsq : 2 * ‖z‖ ^ 2 ≤ 1 := by ++ have hz0 : 0 ≤ ‖z‖ := norm_nonneg z ++ have hz_sq : ‖z‖ ^ 2 ≤ (1 / 2 : ℝ) ^ 2 := pow_le_pow_left₀ hz0 hz 2 ++ nlinarith ++ exact (h_tail_bound.trans hmul).trans hsq ++ linarith ++ have h_exp_sub_one : ‖exp (-logTail m z) - 1‖ ≤ 2 * ‖-logTail m z‖ := ++ Complex.norm_exp_sub_one_le hw_le_one ++ simp only [norm_neg] at h_exp_sub_one ++ calc ++ ‖exp (-logTail m z) - 1‖ ≤ 2 * ‖logTail m z‖ := h_exp_sub_one ++ _ ≤ 2 * (2 * ‖z‖ ^ (m + 1)) := by gcongr ++ _ = 4 * ‖z‖ ^ (m + 1) := by ring ++ ++lemma log_norm_weierstrassFactor_ge_log_norm_one_sub_sub (m : ℕ) (z : ℂ) : ++ Real.log ‖1 - z‖ - ‖partialLogSum m z‖ ≤ Real.log ‖weierstrassFactor m z‖ := by ++ by_cases hz1 : z = (1 : ℂ) ++ · subst hz1 ++ simp [weierstrassFactor] ++ set S : ℂ := partialLogSum m z ++ have hS : weierstrassFactor m z = (1 - z) * Complex.exp S := by ++ simp [weierstrassFactor, S] ++ have hnorm_pos : 0 < ‖(1 : ℂ) - z‖ := ++ norm_pos_iff.mpr (sub_ne_zero.mpr (Ne.symm hz1)) ++ have hlog : ++ Real.log ‖weierstrassFactor m z‖ = Real.log ‖1 - z‖ + S.re := by ++ have hne : ‖(1 : ℂ) - z‖ ≠ 0 := ne_of_gt hnorm_pos ++ calc ++ Real.log ‖weierstrassFactor m z‖ ++ = Real.log (‖(1 : ℂ) - z‖ * ‖Complex.exp S‖) := by ++ simp [hS] ++ _ = Real.log ‖(1 : ℂ) - z‖ + Real.log ‖Complex.exp S‖ := by ++ simpa using (Real.log_mul hne (ne_of_gt (by simp))) ++ _ = Real.log ‖(1 : ℂ) - z‖ + S.re := by ++ simp [Complex.norm_exp, Real.log_exp] ++ _ = Real.log ‖1 - z‖ + S.re := by simp [sub_eq_add_neg, add_comm] ++ have hre : S.re ≥ -‖S‖ := Complex.neg_norm_le_re S ++ have : Real.log ‖weierstrassFactor m z‖ ≥ Real.log ‖1 - z‖ - ‖S‖ := by ++ linarith [hlog, hre] ++ simpa [S] using this ++ ++lemma log_norm_weierstrassFactor_ge_neg_two_pow {m : ℕ} {z : ℂ} (hz : ‖z‖ ≤ (1 / 2 : ℝ)) : ++ (-2 : ℝ) * ‖z‖ ^ (m + 1) ≤ Real.log ‖weierstrassFactor m z‖ := by ++ have hz_lt : ‖z‖ < (1 : ℝ) := lt_of_le_of_lt hz (by norm_num) ++ have hz1 : z ≠ (1 : ℂ) := by ++ intro h ++ have : (1 : ℝ) ≤ (1 / 2 : ℝ) := by ++ simpa [h] using hz ++ norm_num at this ++ have hEq : weierstrassFactor m z = Complex.exp (-logTail m z) := ++ weierstrassFactor_eq_exp_neg_tail m hz_lt hz1 ++ have hlog : ++ Real.log ‖weierstrassFactor m z‖ = (-logTail m z).re := by ++ simp [hEq, Complex.norm_exp, Real.log_exp] ++ have hre : (-logTail m z).re ≥ -‖logTail m z‖ := by ++ simpa [norm_neg] using Complex.neg_norm_le_re (-logTail m z) ++ have htail := norm_logTail_le_two_mul_norm_pow hz_lt hz m ++ have : (-logTail m z).re ≥ (-2 : ℝ) * ‖z‖ ^ (m + 1) := by ++ calc ++ (-logTail m z).re ≥ -‖logTail m z‖ := hre ++ _ ≥ (-2 : ℝ) * ‖z‖ ^ (m + 1) := by ++ nlinarith [htail] ++ simpa [hlog, mul_assoc, mul_left_comm, mul_comm] using this ++ ++end Complex ++end ++end ++section ++noncomputable section ++ ++open Filter Topology ++ ++namespace Complex ++ ++theorem logDeriv_weierstrassFactor_one_div {a z : ℂ} (ha : a ≠ 0) (hz : z ≠ a) : ++ logDeriv (fun w : ℂ => weierstrassFactor 1 (w / a)) z = ++ 1 / (z - a) + 1 / a := by ++ have hE : ++ (fun w : ℂ => weierstrassFactor 1 (w / a)) = ++ fun w : ℂ => (1 - w / a) * exp (w / a) := by ++ ext w ++ simp [weierstrassFactor_def, partialLogSum_eq_sum] ++ have hf : (1 - z / a) ≠ 0 := by ++ intro hzero ++ have hdiv : z / a = 1 := by ++ exact (sub_eq_zero.mp hzero).symm ++ exact hz ((div_eq_one_iff_eq ha).1 hdiv) ++ rw [hE, logDeriv_fun_mul z hf (exp_ne_zero (z / a)) (by fun_prop) (by fun_prop)] ++ have hleft : logDeriv (fun w : ℂ => 1 - w / a) z = 1 / (z - a) := by ++ rw [logDeriv_apply] ++ have hderiv : deriv (fun w : ℂ => 1 - w / a) z = -(1 / a) := by ++ simp [one_div] ++ rw [hderiv] ++ have haz : -z + a ≠ 0 := by ++ simpa [sub_eq_add_neg, add_comm] using sub_ne_zero.mpr (Ne.symm hz) ++ field_simp [ha, sub_ne_zero.mpr hz, haz] ++ have haz' : a - z ≠ 0 := sub_ne_zero.mpr (Ne.symm hz) ++ have hza : z - a = -(a - z) := by ring ++ rw [hza] ++ field_simp [haz'] ++ have hright : logDeriv (fun w : ℂ => exp (w / a)) z = 1 / a := by ++ rw [logDeriv_apply] ++ have hderiv : deriv (fun w : ℂ => exp (w / a)) z = ++ exp (z / a) * (1 / a) := by ++ simp [one_div] ++ rw [hderiv] ++ field_simp [exp_ne_zero (z / a)] ++ rw [hleft, hright] ++ ++end Complex ++end ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SiegelZeros/Summability.lean b/PrimeNumberTheoremAnd/SiegelZeros/Summability.lean +new file mode 100644 +index 0000000..0a11558 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/SiegelZeros/Summability.lean +@@ -0,0 +1,501 @@ ++import Mathlib ++import PrimeNumberTheoremAnd.SiegelZeros.Factorization ++import PrimeNumberTheoremAnd.SiegelZeros.Counting ++ ++namespace SiegelZeros ++ ++section ++noncomputable section ++ ++open Filter Topology Set _root_.SiegelZeros.Complex ++open scoped BigOperators Topology ++ ++namespace Complex.Hadamard ++ ++open scoped _root_.Real ++ ++noncomputable def divisorMassClosedBall₀ (f : ℂ → ℂ) (R : ℝ) : ℝ := ++ Function.locallyFinsuppWithin.massClosedBall₀ (MeromorphicOn.divisor f (Set.univ : Set ℂ)) R ++ ++lemma divisorMassClosedBall₀_le_of_growth {f : ℂ → ℂ} {ρ C : ℝ} ++ (hf : Differentiable ℂ f) ++ (hC : ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) ++ {R : ℝ} (hR : 1 ≤ R) : ++ divisorMassClosedBall₀ f R ++ ≤ (C * (1 + |2 * R|) ^ ρ + |Real.log ‖meromorphicTrailingCoeffAt f 0‖|) / ++ Real.log 2 := by ++ simpa [divisorMassClosedBall₀] using ++ (Function.locallyFinsuppWithin.massClosedBall₀_divisor_le_of_log_growth ++ (f := f) (ρ := ρ) (C := C) hf hC hR) ++ ++lemma exists_r0_le_norm_divisorZeroIndex₀Val {f : ℂ → ℂ} ++ (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) : ++ ∃ r0 : ℝ, 0 < r0 ∧ ++ ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖ := by ++ classical ++ set U : Set ℂ := (Set.univ : Set ℂ) ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have hDnonneg : 0 ≤ D := by ++ simpa [D, U] using (Differentiable.divisor_nonneg (f := f) hf) ++ have hzero : ∀ p : divisorZeroIndex₀ f U, f (divisorZeroIndex₀Val p) = 0 := by ++ intro p ++ set z : ℂ := divisorZeroIndex₀Val p ++ have hneTop : meromorphicOrderAt f z ≠ ⊤ := by ++ have hzAnal : AnalyticAt ℂ f z := hf.analyticAt z ++ have hzA : analyticOrderAt f z ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (f := f) (hf := hf) hnot (z := z) ++ intro htop ++ have hm : meromorphicOrderAt f z = (analyticOrderAt f z).map (↑) := ++ hzAnal.meromorphicOrderAt_eq (𝕜 := ℂ) ++ cases h : analyticOrderAt f z with ++ | top => ++ exact hzA (by simp [h]) ++ | coe n => ++ have : (analyticOrderAt f z).map (↑) ≠ (⊤ : WithTop ℤ) := by ++ simp [h] ++ exact this (by simpa [hm] using htop) ++ have hmon : MeromorphicOn f U := by ++ intro w hw; exact (hf.analyticAt w).meromorphicAt ++ have hdiv : MeromorphicOn.divisor f U z = (meromorphicOrderAt f z).untop₀ := by ++ simpa [U] using (MeromorphicOn.divisor_apply (f := f) (U := U) (z := z) hmon (by aesop)) ++ have hDz : MeromorphicOn.divisor f U z ≠ 0 := by ++ have hzsup : z ∈ (MeromorphicOn.divisor f U).support := by ++ simp [z] ++ simpa [Function.mem_support] using hzsup ++ have hposZ : (0 : ℤ) < (meromorphicOrderAt f z).untop₀ := by ++ have hge0 : 0 ≤ (meromorphicOrderAt f z).untop₀ := by ++ have : 0 ≤ MeromorphicOn.divisor f U z := by ++ simpa [D, U, z] using hDnonneg z ++ simpa [hdiv] using this ++ have hne0 : (meromorphicOrderAt f z).untop₀ ≠ 0 := by ++ simpa [hdiv] using hDz ++ exact lt_of_le_of_ne hge0 (by simpa [eq_comm] using hne0) ++ have hpos : (0 : WithTop ℤ) < meromorphicOrderAt f z := by ++ have : (0 : WithTop ℤ) < ((meromorphicOrderAt f z).untop₀ : WithTop ℤ) := ++ WithTop.coe_lt_coe.2 hposZ ++ simpa [WithTop.coe_untop₀_of_ne_top hneTop] using this ++ have htend0 : Tendsto f (𝓝[≠] z) (𝓝 (0 : ℂ)) := ++ tendsto_zero_of_meromorphicOrderAt_pos (f := f) (x := z) hpos ++ have hcontz : ContinuousAt f z := (hf z).continuousAt ++ have htendz : Tendsto f (𝓝[≠] z) (𝓝 (f z)) := ++ (hcontz.tendsto.mono_left (nhdsWithin_le_nhds : 𝓝[≠] z ≤ 𝓝 z)) ++ exact tendsto_nhds_unique htendz htend0 ++ by_cases h0 : f 0 = 0 ++ · have hD0 : D 0 ≠ 0 := by ++ have hmero0 : MeromorphicAt f (0 : ℂ) := (hf.analyticAt 0).meromorphicAt ++ have hneTop0 : meromorphicOrderAt f (0 : ℂ) ≠ ⊤ := by ++ have hA0 : analyticOrderAt f (0 : ℂ) ≠ ⊤ := ++ analyticOrderAt_ne_top_of_exists_ne_zero (f := f) (hf := hf) hnot (z := 0) ++ intro htop ++ have hm : meromorphicOrderAt f (0 : ℂ) = (analyticOrderAt f (0 : ℂ)).map (↑) := ++ (hf.analyticAt 0).meromorphicOrderAt_eq (𝕜 := ℂ) ++ cases h : analyticOrderAt f (0 : ℂ) with ++ | top => exact (hA0 h).elim ++ | coe n => ++ have : (analyticOrderAt f (0 : ℂ)).map (↑) ≠ (⊤ : WithTop ℤ) := by ++ simp [h] ++ exact this (by simpa [hm] using htop) ++ have htend0 : Tendsto f (𝓝[≠] (0 : ℂ)) (𝓝 (0 : ℂ)) := by ++ have hcont0 : ContinuousAt f (0 : ℂ) := (hf 0).continuousAt ++ have : Tendsto f (𝓝 (0 : ℂ)) (𝓝 (0 : ℂ)) := by simpa [h0] using hcont0.tendsto ++ exact this.mono_left (nhdsWithin_le_nhds : 𝓝[≠] (0 : ℂ) ≤ 𝓝 (0 : ℂ)) ++ have hpos0 : (0 : WithTop ℤ) < meromorphicOrderAt f (0 : ℂ) := ++ (tendsto_zero_iff_meromorphicOrderAt_pos hmero0).1 htend0 ++ have hpos0' : (0 : ℤ) < (meromorphicOrderAt f (0 : ℂ)).untop₀ := by ++ have : (0 : WithTop ℤ) < ((meromorphicOrderAt f (0 : ℂ)).untop₀ : WithTop ℤ) := by ++ simpa [WithTop.coe_untop₀_of_ne_top hneTop0] using hpos0 ++ simpa using (WithTop.coe_lt_coe.1 this) ++ have hdiv0 : D 0 = (meromorphicOrderAt f (0 : ℂ)).untop₀ := by ++ have hmon : MeromorphicOn f U := by ++ intro w hw; exact (hf.analyticAt w).meromorphicAt ++ simpa [D, U] using ++ (MeromorphicOn.divisor_apply (f := f) (U := U) (z := (0 : ℂ)) ++ hmon (by aesop)) ++ exact by ++ have : (meromorphicOrderAt f (0 : ℂ)).untop₀ ≠ 0 := ne_of_gt hpos0' ++ simpa [hdiv0] using this ++ have hmem0 : (0 : ℂ) ∈ D.support := by ++ simp [Function.mem_support, hD0] ++ have hdisc : IsDiscrete D.support := by ++ simpa [D] using (D.discreteSupport) ++ rcases Metric.exists_ball_inter_eq_singleton_of_mem_discrete hdisc hmem0 with ⟨r0, hr0pos, hr0⟩ ++ refine ⟨r0, hr0pos, ?_⟩ ++ intro p ++ have hp : divisorZeroIndex₀Val p ∈ D.support := by ++ simp [D, divisorZeroIndex₀Val_mem_divisor_support (f := f) (U := U) p] ++ have hnotBall : divisorZeroIndex₀Val p ∉ Metric.ball (0 : ℂ) r0 := by ++ intro hball ++ have : divisorZeroIndex₀Val p ∈ Metric.ball (0 : ℂ) r0 ∩ D.support := ⟨hball, hp⟩ ++ have : divisorZeroIndex₀Val p ∈ ({(0 : ℂ)} : Set ℂ) := by simp [hr0] at this ++ have : divisorZeroIndex₀Val p = 0 := by simp [Set.mem_singleton_iff] at this ++ exact (divisorZeroIndex₀Val_ne_zero p) this ++ have : r0 ≤ ‖divisorZeroIndex₀Val p‖ := by ++ have : ¬ ‖divisorZeroIndex₀Val p‖ < r0 := by ++ intro hlt ++ exact hnotBall (by simpa [Metric.mem_ball, dist_zero_right] using hlt) ++ exact le_of_not_gt this ++ exact this ++ · have hcont0 : ContinuousAt f (0 : ℂ) := (hf 0).continuousAt ++ have hne : ∀ᶠ z in 𝓝 (0 : ℂ), f z ≠ 0 := hcont0.eventually_ne h0 ++ rcases Metric.mem_nhds_iff.1 hne with ⟨r0, hr0pos, hr0⟩ ++ refine ⟨r0, hr0pos, ?_⟩ ++ intro p ++ have : ¬ ‖divisorZeroIndex₀Val p‖ < r0 := by ++ intro hlt ++ have hzball : divisorZeroIndex₀Val p ∈ Metric.ball (0 : ℂ) r0 := by ++ simpa [Metric.mem_ball, dist_zero_right] using hlt ++ have : f (divisorZeroIndex₀Val p) ≠ 0 := hr0 hzball ++ exact this (hzero p) ++ exact le_of_not_gt this ++ ++open scoped BigOperators ++ ++lemma card_ball_le_divisorMassClosedBall₀ ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) {R : ℝ} (hR : 0 < R) : ++ (Nat.card {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) // ‖divisorZeroIndex₀Val p‖ ≤ R} : ℝ) ++ ≤ divisorMassClosedBall₀ f R := by ++ set U : Set ℂ := (Set.univ : Set ℂ) ++ set D : Function.locallyFinsuppWithin U ℤ := MeromorphicOn.divisor f U ++ have : ++ Fintype {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} := by ++ have : Finite {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} := by ++ have : Metric.closedBall (0 : ℂ) R ⊆ U := by simp [U] ++ simpa using (finite_divisorZeroIndex₀_subtype_norm_le (f := f) (U := U) (B := R) this) ++ exact Fintype.ofFinite _ ++ have hDnonneg : 0 ≤ D := by ++ simpa [D, U] using (Differentiable.divisor_nonneg (f := f) hf) ++ let SR : Finset ℂ := ++ (Function.locallyFinsuppWithin.finiteSupport (Function.locallyFinsuppWithin.toClosedBall R D) ++ (isCompact_closedBall (0 : ℂ) |R|)).toFinset ++ let S : Finset ℂ := SR.filter fun z : ℂ => z ≠ 0 ++ let T : Type := ++ Σ z : S, Fin (Int.toNat (D z.1)) ++ let φ : ++ {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} → T := fun p => ++ let z0 : ℂ := divisorZeroIndex₀Val p.1 ++ have hz0_memSR : z0 ∈ SR := by ++ have hz0_norm : ‖z0‖ ≤ |R| := by ++ have : ‖z0‖ ≤ R := p.2 ++ simpa [abs_of_pos hR] using this ++ have hz0_support : z0 ∈ (Function.locallyFinsuppWithin.toClosedBall R D).support := by ++ have hz0_suppD : z0 ∈ D.support := by ++ simp [z0, D] ++ exact Function.locallyFinsuppWithin.mem_toClosedBall_support_of_mem_support_of_norm_le_abs ++ hz0_suppD hz0_norm ++ exact (Set.Finite.mem_toFinset ++ (Function.locallyFinsuppWithin.finiteSupport ++ (Function.locallyFinsuppWithin.toClosedBall R D) ++ (isCompact_closedBall (0 : ℂ) |R|))).2 hz0_support ++ have hz0_ne0 : z0 ≠ 0 := divisorZeroIndex₀Val_ne_zero p.1 ++ have hz0_memS : z0 ∈ S := Finset.mem_filter.2 ⟨hz0_memSR, hz0_ne0⟩ ++ ⟨⟨z0, hz0_memS⟩, by ++ simpa [z0, divisorZeroIndex₀Val, D] using p.1.1.2⟩ ++ have hφ_inj : Function.Injective φ := by ++ intro p q hpq ++ have hσ := (Sigma.mk.inj_iff).1 hpq ++ have hzS : (φ p).1 = (φ q).1 := hσ.1 ++ have hz : divisorZeroIndex₀Val p.1 = divisorZeroIndex₀Val q.1 := by ++ simpa [φ] using congrArg Subtype.val hzS ++ apply Subtype.ext ++ apply Subtype.ext ++ apply Sigma.ext ++ · exact hz ++ · simpa [φ] using hσ.2 ++ have hcard_le : ++ Fintype.card {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} ≤ Fintype.card T := ++ Fintype.card_le_of_injective φ hφ_inj ++ have hT_card : ++ (Fintype.card T : ℝ) = ++ (S.sum fun z : ℂ => (Int.toNat (D z) : ℝ)) := by ++ have hNat : ++ Fintype.card T = ∑ z : S, Int.toNat (D z.1) := by ++ have h1 : ++ Fintype.card T = ∑ z : S, Fintype.card (Fin (Int.toNat (D z.1))) := by ++ change Fintype.card (Sigma (fun z : S => Fin (Int.toNat (D z.1)))) ++ = ∑ z : S, Fintype.card (Fin (Int.toNat (D z.1))) ++ exact (Fintype.card_sigma (ι := S) (α := fun z : S => Fin (Int.toNat (D z.1)))) ++ simpa using h1 ++ have hR : ++ (Fintype.card T : ℝ) = ∑ z : S, (Int.toNat (D z.1) : ℝ) := by ++ exact_mod_cast hNat ++ have hR' : ++ (Fintype.card T : ℝ) = S.attach.sum (fun z : S => (Int.toNat (D z.1) : ℝ)) := by ++ simpa [Finset.univ_eq_attach] using hR ++ calc ++ (Fintype.card T : ℝ) = S.attach.sum (fun z : S => (Int.toNat (D z.1) : ℝ)) := hR' ++ _ = S.sum (fun z : ℂ => (Int.toNat (D z) : ℝ)) := by ++ simpa using (Finset.sum_attach (s := S) (f := fun z : ℂ => (Int.toNat (D z) : ℝ))) ++ have htoNat_le : ∀ z ∈ S, (Int.toNat (D z) : ℝ) ≤ (D z : ℝ) := by ++ intro z hz ++ have hDz_nonneg : 0 ≤ D z := by simpa [D] using hDnonneg z ++ have hEqZ : ((Int.toNat (D z) : ℕ) : ℤ) = D z := by ++ simpa using (Int.toNat_of_nonneg hDz_nonneg) ++ have hEqR : (Int.toNat (D z) : ℝ) = (D z : ℝ) := by ++ exact_mod_cast hEqZ ++ exact le_of_eq hEqR ++ calc ++ (Nat.card {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} : ℝ) ++ = (Fintype.card {p : divisorZeroIndex₀ f U // ‖divisorZeroIndex₀Val p‖ ≤ R} : ℝ) := by ++ simp [Nat.card_eq_fintype_card] ++ _ ≤ (Fintype.card T : ℝ) := by exact_mod_cast hcard_le ++ _ = S.sum (fun z : ℂ => (Int.toNat (D z) : ℝ)) := hT_card ++ _ ≤ S.sum (fun z : ℂ => (D z : ℝ)) := by ++ refine Finset.sum_le_sum ?_ ++ intro z hz ++ exact htoNat_le z hz ++ _ = divisorMassClosedBall₀ f R := by ++ rfl ++ ++lemma card_subtype_le_divisorMassClosedBall₀_of_norm_le ++ {f : ℂ → ℂ} (hf : Differentiable ℂ f) ++ {s : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ))} [Fintype s] ++ {R : ℝ} (hR : 0 < R) (hs : ∀ p : s, ‖divisorZeroIndex₀Val p.1‖ ≤ R) : ++ (Fintype.card s : ℝ) ≤ divisorMassClosedBall₀ f R := by ++ let Aball : Type := ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) // ‖divisorZeroIndex₀Val p‖ ≤ R} ++ have : Fintype Aball := by ++ have : Finite Aball := by ++ have : Metric.closedBall (0 : ℂ) R ⊆ (Set.univ : Set ℂ) := by simp ++ simpa [Aball] using ++ (finite_divisorZeroIndex₀_subtype_norm_le (f := f) (U := (Set.univ : Set ℂ)) ++ (B := R) this) ++ exact Fintype.ofFinite _ ++ have hinj : Function.Injective (fun p : s => (⟨p.1, hs p⟩ : Aball)) := by ++ intro p q hpq ++ apply Subtype.ext ++ exact congrArg (fun x : Aball => x.1) hpq ++ have hcard_le : Fintype.card s ≤ Fintype.card Aball := ++ Fintype.card_le_of_injective _ hinj ++ have hAball : (Nat.card Aball : ℝ) ≤ divisorMassClosedBall₀ f R := by ++ simpa [Aball] using card_ball_le_divisorMassClosedBall₀ (f := f) hf hR ++ calc ++ (Fintype.card s : ℝ) ≤ (Fintype.card Aball : ℝ) := by exact_mod_cast hcard_le ++ _ = (Nat.card Aball : ℝ) := by simp [Nat.card_eq_fintype_card] ++ _ ≤ divisorMassClosedBall₀ f R := hAball ++ ++lemma divisorZeroIndex₀_dyadicShell_upper_bound ++ {f : ℂ → ℂ} {r0 : ℝ} ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ {k : ℕ} {p : divisorZeroIndex₀ f (Set.univ : Set ℂ)} ++ (hp : ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k) : ++ ‖divisorZeroIndex₀Val p‖ ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1) := by ++ exact Real.dyadicShell_upper_bound (r0 := r0) (x := ‖divisorZeroIndex₀Val p‖) ++ hr0pos (hr0 p) hp ++ ++lemma divisorZeroIndex₀_dyadicShell_lower_bound ++ {f : ℂ → ℂ} {r0 : ℝ} ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ {k : ℕ} {p : divisorZeroIndex₀ f (Set.univ : Set ℂ)} ++ (hp : ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k) : ++ r0 * (2 : ℝ) ^ (k : ℝ) ≤ ‖divisorZeroIndex₀Val p‖ := by ++ exact Real.dyadicShell_lower_bound (r0 := r0) (x := ‖divisorZeroIndex₀Val p‖) ++ hr0pos (hr0 p) hp ++ ++lemma finite_divisorZeroIndex₀_dyadicShell ++ {f : ℂ → ℂ} {r0 : ℝ} ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ (k : ℕ) : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k} : Set _).Finite := by ++ have hsub : ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ = k} ⊆ ++ {p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1)} := by ++ intro p hp ++ exact divisorZeroIndex₀_dyadicShell_upper_bound hr0pos hr0 hp ++ have hfin : ++ ({p : divisorZeroIndex₀ f (Set.univ : Set ℂ) | ++ ‖divisorZeroIndex₀Val p‖ ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1)} : Set _).Finite := by ++ have : ++ Metric.closedBall (0 : ℂ) (r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) ⊆ ++ (Set.univ : Set ℂ) := by ++ simp ++ simpa using ++ (divisorZeroIndex₀_norm_le_finite (f := f) (U := (Set.univ : Set ℂ)) ++ (B := r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) this) ++ exact hfin.subset hsub ++ ++lemma tsum_divisorZeroIndex₀_dyadicShell_inv_rpow_le_geometric_of_growth ++ {f : ℂ → ℂ} {ρ τ r0 Cgrow : ℝ} ++ (hρ : 0 ≤ ρ) (hτpos : 0 < τ) (hf : Differentiable ℂ f) ++ (hCgrow_pos : 0 < Cgrow) ++ (hCgrow : ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ Cgrow * (1 + ‖z‖) ^ ρ) ++ (hr0pos : 0 < r0) ++ (hr0 : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ++ r0 ≤ ‖divisorZeroIndex₀Val p‖) ++ (k : ℕ) (hk_ge_one : 1 ≤ r0 * (2 : ℝ) ^ ((k : ℝ) + 1)) : ++ let kfun : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℕ := ++ fun p => ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ ++ let S : Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := {p | kfun p = k} ++ let Ctrail : ℝ := |Real.log ‖meromorphicTrailingCoeffAt f 0‖| ++ let A : ℝ := ((Cgrow / Real.log 2) * (1 + 4 * r0) ^ ρ) * (r0⁻¹) ^ τ ++ let B : ℝ := ((Ctrail / Real.log 2) + 1) * (r0⁻¹) ^ τ ++ let q : ℝ := (2 : ℝ) ^ (ρ - τ) ++ let qσ : ℝ := (2 : ℝ) ^ (-τ) ++ (∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ≤ A * q ^ k + B * qσ ^ k := by ++ classical ++ intro kfun S Ctrail A B q qσ ++ let rk : ℝ := r0 * (2 : ℝ) ^ (k : ℝ) ++ let Rk : ℝ := r0 * (2 : ℝ) ^ ((k : ℝ) + 1) ++ have hrk_pos : 0 < rk := mul_pos hr0pos (Real.rpow_pos_of_pos (by norm_num) _) ++ have hrk0 : 0 ≤ rk := le_of_lt hrk_pos ++ have : Finite S := by ++ simpa [S, kfun] using (finite_divisorZeroIndex₀_dyadicShell ++ (f := f) hr0pos hr0 k).to_subtype ++ have : Fintype S := Fintype.ofFinite S ++ have hk_upper : ∀ p : S, ‖divisorZeroIndex₀Val p.1‖ ≤ Rk := by ++ intro p ++ have hk' : kfun p.1 = k := p.2 ++ simpa [Rk, kfun] using ++ divisorZeroIndex₀_dyadicShell_upper_bound (f := f) hr0pos hr0 hk' ++ have hk_lower : ∀ p : S, rk ≤ ‖divisorZeroIndex₀Val p.1‖ := by ++ intro p ++ have hk' : kfun p.1 = k := p.2 ++ simpa [rk, kfun] using ++ divisorZeroIndex₀_dyadicShell_lower_bound (f := f) hr0pos hr0 hk' ++ have htsum_le : ++ (∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ++ ≤ (Fintype.card S : ℝ) * (rk⁻¹ ^ τ) := by ++ exact Real.tsum_inv_rpow_le_card_mul_of_lower_bound ++ (a := fun p : S => ‖divisorZeroIndex₀Val p.1‖) ++ hrk_pos hτpos (fun _ => norm_nonneg _) hk_lower ++ have hmass_le_growth : ++ divisorMassClosedBall₀ f Rk ++ ≤ (Cgrow * (1 + |2 * Rk|) ^ ρ + Ctrail) / (Real.log 2) := by ++ simpa [Ctrail, Rk] using ++ (divisorMassClosedBall₀_le_of_growth (f := f) (ρ := ρ) (C := Cgrow) hf hCgrow ++ (R := Rk) hk_ge_one) ++ have hcard_le_mass : ++ (Fintype.card S : ℝ) ≤ divisorMassClosedBall₀ f Rk := by ++ have hRk_pos : 0 < Rk := lt_of_lt_of_le (by norm_num) hk_ge_one ++ exact card_subtype_le_divisorMassClosedBall₀_of_norm_le (f := f) hf hRk_pos hk_upper ++ have htsum' : ++ (∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ++ ≤ ((Cgrow * (1 + |2 * Rk|) ^ ρ + Ctrail) / (Real.log 2)) * (rk⁻¹ ^ τ) := by ++ have hcard_le_growth : ++ (Fintype.card S : ℝ) ≤ ++ (Cgrow * (1 + |2 * Rk|) ^ ρ + Ctrail) / (Real.log 2) := ++ le_trans hcard_le_mass hmass_le_growth ++ exact le_trans htsum_le <| ++ mul_le_mul_of_nonneg_right hcard_le_growth (Real.rpow_nonneg (inv_nonneg.2 hrk0) τ) ++ have hpow_bound : ++ (1 + |2 * Rk|) ^ ρ ≤ (1 + 4 * r0) ^ ρ * ((2 : ℝ) ^ ρ) ^ k := by ++ simpa [Rk] using ++ Real.one_add_abs_two_mul_dyadicRadius_rpow_le (r0 := r0) (ρ := ρ) k hr0pos hρ ++ have hlog2pos : 0 < Real.log 2 := Real.log_pos (by norm_num : (1 : ℝ) < 2) ++ simpa [A, B, q, qσ, rk, Ctrail, mul_assoc, mul_left_comm, mul_comm] using ++ Real.dyadic_growth_mass_mul_inv_le_geometric ++ (C := Cgrow) (L := Real.log 2) (M := (1 + 4 * r0) ^ ρ) ++ (X := (1 + |2 * Rk|) ^ ρ) ++ (T := ∑' p : S, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ++ (Ctrail := Ctrail) (r0 := r0) (ρ := ρ) (τ := τ) (k := k) ++ hlog2pos hCgrow_pos.le hr0pos.le hpow_bound ++ (by simpa [rk] using htsum') ++ ++theorem summable_norm_inv_rpow_divisorZeroIndex₀_of_growth {f : ℂ → ℂ} {ρ τ : ℝ} ++ (hρ : 0 ≤ ρ) (hτ : ρ < τ) (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) := by ++ rcases hgrowth with ⟨Cgrow, hCgrow_pos, hCgrow⟩ ++ have hτpos : 0 < τ := lt_of_le_of_lt hρ hτ ++ rcases exists_r0_le_norm_divisorZeroIndex₀Val (f := f) hf hnot with ⟨r0, hr0pos, hr0⟩ ++ have hr0ne : (r0 : ℝ) ≠ 0 := ne_of_gt hr0pos ++ let kfun : divisorZeroIndex₀ f (Set.univ : Set ℂ) → ℕ := ++ fun p => ⌊Real.logb 2 (‖divisorZeroIndex₀Val p‖ / r0)⌋₊ ++ let S : ℕ → Set (divisorZeroIndex₀ f (Set.univ : Set ℂ)) := ++ fun k => {p | kfun p = k} ++ have hS : ∀ p : divisorZeroIndex₀ f (Set.univ : Set ℂ), ∃! k : ℕ, p ∈ S k := by ++ intro p ++ refine ⟨kfun p, ?_, ?_⟩ ++ · simp [S] ++ · intro k hk ++ simpa [S] using hk.symm ++ have hnonneg : 0 ≤ fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ := by ++ intro p ++ exact Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ have hSk_summable : ∀ k : ℕ, Summable fun p : S k => ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ intro k ++ have : Finite (S k) := by ++ simpa [S, kfun] using (finite_divisorZeroIndex₀_dyadicShell ++ (f := f) hr0pos hr0 k).to_subtype ++ exact Summable.of_finite ++ have hshell_summable : ++ Summable fun k : ℕ => ∑' p : S k, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ let q : ℝ := (2 : ℝ) ^ (ρ - τ) ++ let qσ : ℝ := (2 : ℝ) ^ (-τ) ++ have hq_nonneg : 0 ≤ q := le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _) ++ have hq_lt_one : q < 1 := ++ Real.rpow_lt_one_of_one_lt_of_neg (x := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) ++ (sub_neg.2 hτ) ++ have hqσ_nonneg : 0 ≤ qσ := le_of_lt (Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 2) _) ++ have hqσ_lt_one : qσ < 1 := ++ Real.rpow_lt_one_of_one_lt_of_neg (x := (2 : ℝ)) (by norm_num : (1 : ℝ) < 2) ++ (by simpa using (neg_neg_of_pos hτpos)) ++ have hgeom_q : Summable (fun k : ℕ => q ^ k) := ++ summable_geometric_of_lt_one hq_nonneg hq_lt_one ++ have hgeom_qσ : Summable (fun k : ℕ => qσ ^ k) := ++ summable_geometric_of_lt_one hqσ_nonneg hqσ_lt_one ++ let Ctrail : ℝ := |Real.log ‖meromorphicTrailingCoeffAt f 0‖| ++ let A : ℝ := ((Cgrow / Real.log 2) * (1 + 4 * r0) ^ ρ) * (r0⁻¹) ^ τ ++ let B : ℝ := ((Ctrail / Real.log 2) + 1) * (r0⁻¹) ^ τ ++ rcases Real.exists_nat_le_two_pow (1 / r0) with ⟨k0, hk0⟩ ++ let A0 : ℝ := A * q ^ k0 ++ let B0 : ℝ := B * qσ ^ k0 ++ have hmajor : Summable (fun k : ℕ => A0 * q ^ k + B0 * qσ ^ k) := ++ (hgeom_q.mul_left A0).add (hgeom_qσ.mul_left B0) ++ have hshell_summable_shift : ++ Summable fun k : ℕ => ∑' p : S (k + k0), ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ refine hmajor.of_nonneg_of_le ++ (fun k => by ++ have : ∀ p : S (k + k0), 0 ≤ ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ := by ++ intro p; exact Real.rpow_nonneg (inv_nonneg.2 (norm_nonneg _)) _ ++ exact tsum_nonneg this) ++ (fun k => by ++ let kk : ℕ := k + k0 ++ let Rk : ℝ := r0 * (2 : ℝ) ^ ((kk : ℝ) + 1) ++ have hRk_ge_one : (1 : ℝ) ≤ Rk := by ++ have hkk : k0 ≤ kk + 1 := by ++ simp [kk, Nat.add_assoc, Nat.add_comm] ++ simpa [Rk] using ++ Real.one_le_dyadicRadius_succ_of_inv_le_two_pow hr0pos hk0 hkk ++ have hmain : ++ (∑' p : S kk, ‖divisorZeroIndex₀Val p.1‖⁻¹ ^ τ) ≤ A * q ^ kk + B * qσ ^ kk := by ++ simpa [S, kfun, Ctrail, A, B, q, qσ] using ++ tsum_divisorZeroIndex₀_dyadicShell_inv_rpow_le_geometric_of_growth ++ (f := f) (ρ := ρ) (τ := τ) hρ hτpos hf hCgrow_pos hCgrow hr0pos hr0 kk hRk_ge_one ++ have : A * q ^ kk + B * qσ ^ kk = A0 * q ^ k + B0 * qσ ^ k := by ++ simpa [A0, B0, kk] using Real.two_geometric_shift_add A B q qσ k k0 ++ simpa [kk] using (hmain.trans_eq this) ++ ) ++ exact (summable_nat_add_iff k0).1 hshell_summable_shift ++ have hpart := ++ (summable_partition (f := fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ τ) hnonneg (s := S) hS) ++ exact (hpart.2 ⟨hSk_summable, hshell_summable⟩) ++ ++theorem summable_norm_inv_pow_divisorZeroIndex₀_of_growth {f : ℂ → ℂ} {ρ : ℝ} ++ (hρ : 0 ≤ ρ) (hf : Differentiable ℂ f) (hnot : ∃ z : ℂ, f z ≠ 0) ++ (hgrowth : ∃ C > 0, ∀ z : ℂ, Real.log (1 + ‖f z‖) ≤ C * (1 + ‖z‖) ^ ρ) : ++ Summable (fun p : divisorZeroIndex₀ f (Set.univ : Set ℂ) => ++ ‖divisorZeroIndex₀Val p‖⁻¹ ^ (Nat.floor ρ + 1)) := by ++ have hτ : ρ < (Nat.floor ρ + 1 : ℝ) := by ++ simpa [Nat.cast_add, Nat.cast_one] using (Nat.lt_floor_add_one (a := ρ)) ++ have hs := ++ summable_norm_inv_rpow_divisorZeroIndex₀_of_growth (f := f) (ρ := ρ) ++ (τ := (Nat.floor ρ + 1 : ℝ)) hρ hτ hf hnot hgrowth ++ exact hs.congr fun p => by ++ have hcast : ((Nat.floor ρ : ℝ) + 1) = ((Nat.floor ρ + 1 : ℕ) : ℝ) := by ++ norm_num ++ rw [hcast, Real.rpow_natCast] ++ ++end Complex.Hadamard ++end ++end ++ ++end SiegelZeros +diff --git a/PrimeNumberTheoremAnd/SmoothExistence.lean b/PrimeNumberTheoremAnd/SmoothExistence.lean +index b33edf8..2513738 100644 +--- a/PrimeNumberTheoremAnd/SmoothExistence.lean ++++ b/PrimeNumberTheoremAnd/SmoothExistence.lean +@@ -1,20 +1,20 @@ +-import Architect +-import Batteries.Tactic.Lemma ++/- ++Adapted from PrimeNumberTheoremAnd by Alex Kontorovich and contributors. ++Licensed under the Apache License, Version 2.0; see the upstream LICENSE. ++This compatibility port retains the proven declarations used by this project. ++-/ + import Mathlib.Geometry.Manifold.PartitionOfUnity + import Mathlib.Tactic.Bound +-import PrimeNumberTheoremAnd.Mathlib.Algebra.Notation.Support +- +-set_option lang.lemmaCmd true + + open MeasureTheory Set Real + open scoped ContDiff + +-lemma smooth_urysohn_support_Ioo {a b c d : ℝ} (h1 : a < b) (h3 : c < d) : ++theorem smooth_urysohn_support_Ioo {a b c d : ℝ} (h1 : a < b) (h3 : c < d) : + ∃ Ψ : ℝ → ℝ, (ContDiff ℝ ∞ Ψ) ∧ (HasCompactSupport Ψ) ∧ + Set.indicator (Set.Icc b c) 1 ≤ Ψ ∧ Ψ ≤ Set.indicator (Set.Ioo a d) 1 ∧ + (Function.support Ψ = Set.Ioo a d) := by +- have := exists_contMDiff_zero_iff_one_iff_of_isClosed (n := ⊤) +- (modelWithCornersSelf ℝ ℝ) (s := Set.Iic a ∪ Set.Ici d) (t := Set.Icc b c) ++ have := exists_contDiff_zero_iff_one_iff_of_isClosed (n := ⊤) ++ (s := Set.Iic a ∪ Set.Ici d) (t := Set.Icc b c) + (IsClosed.union isClosed_Iic isClosed_Ici) isClosed_Icc + (by + simp_rw [Set.disjoint_union_left, Set.disjoint_iff, Set.subset_def, +@@ -25,7 +25,7 @@ lemma smooth_urysohn_support_Ioo {a b c d : ℝ} (h1 : a < b) (h3 : c < d) : + simp only [Set.mem_union, Set.mem_Iic, Set.mem_Ici, Set.mem_Icc] at * + use Ψ + simp only [range_subset_iff, mem_Icc] at hΨrange +- refine ⟨ContMDiff.contDiff hΨSmooth, ?_, ?_, ?_, ?_⟩ ++ refine ⟨hΨSmooth, ?_, ?_, ?_, ?_⟩ + · apply HasCompactSupport.of_support_subset_isCompact (K := Set.Icc a d) isCompact_Icc + simp only [Function.support_subset_iff, ne_eq, mem_Icc, ← hΨ0, not_or] + bound +@@ -42,66 +42,3 @@ lemma smooth_urysohn_support_Ioo {a b c d : ℝ} (h1 : a < b) (h3 : c < d) : + simpa [-not_and, mem_Ioo, not_and_or, not_lt] using hx + · ext x + simp only [Function.mem_support, ne_eq, mem_Ioo, ← hΨ0, not_or, not_le] +- +-blueprint_comment /-- +-Let $\nu$ be a bumpfunction. +--/ +- +-@[blueprint +- (title := "SmoothExistence") +- (statement := /-- +- There exists a smooth (once differentiable would be enough), +- nonnegative ``bumpfunction'' $\nu$, +- supported in $[1/2,2]$ with total mass one: +- $$ +- \int_0^\infty \nu(x)\frac{dx}{x} = 1. +- $$ +- -/) +- (proof := /-- Same idea as Urysohn-type argument. -/)] +-lemma SmoothExistence : +- ∃ (ν : ℝ → ℝ), (ContDiff ℝ ∞ ν) ∧ (∀ x, 0 ≤ ν x) ∧ +- ν.support ⊆ Icc (1 / 2) 2 ∧ ∫ x in Ici 0, ν x / x = 1 := by +- suffices h : ∃ (ν : ℝ → ℝ), (ContDiff ℝ ∞ ν) ∧ (∀ x, 0 ≤ ν x) ∧ +- ν.support ⊆ Set.Icc (1 / 2) 2 ∧ 0 < ∫ x in Set.Ici 0, ν x / x by +- obtain ⟨ν, hν, hνnonneg, hνsupp, hνpos⟩ := h +- let c := (∫ x in Ici 0, ν x / x) +- use fun y ↦ ν y / c +- refine ⟨hν.div_const c, fun y ↦ div_nonneg (hνnonneg y) (le_of_lt hνpos), ?_, ?_⟩ +- · rw [Function.support_div, Function.support_const (ne_of_lt hνpos).symm, inter_univ] +- convert hνsupp +- · simp only [div_right_comm _ c _, integral_div c, div_self <| ne_of_gt hνpos, c] +- have := smooth_urysohn_support_Ioo (a := 1 / 2) (b := 1) (c := 3 / 2) (d := 2) +- (by linarith) (by linarith) +- obtain ⟨ν, hνContDiff, _, hν0, hν1, hνSupport⟩ := this +- use ν, hνContDiff +- unfold indicator at hν0 hν1 +- simp only [mem_Icc, Pi.one_apply, Pi.le_def, mem_Ioo] at hν0 hν1 +- simp only [hνSupport, subset_def, mem_Ioo, mem_Icc, and_imp] +- split_ands +- · exact fun x ↦ le_trans (by simp [apply_ite]) (hν0 x) +- · exact fun y hy hy' ↦ ⟨by linarith, by linarith⟩ +- · rw [integral_pos_iff_support_of_nonneg] +- · simp only [Function.support_div, measurableSet_Ici, Measure.restrict_apply', +- hνSupport, Function.support_id'] +- have : (Ioo (1 / 2 : ℝ) 2 ∩ {0}ᶜ ∩ Ici 0) = Ioo (1 / 2) 2 := by +- ext x +- simp only [one_div, mem_inter_iff, mem_Ioo, mem_compl_iff, mem_singleton_iff, mem_Ici] +- bound +- simp only [this, volume_Ioo, ENNReal.ofReal_pos, sub_pos, gt_iff_lt] +- linarith +- · simp_rw [Pi.le_def, Pi.zero_apply] +- intro y +- by_cases h : y ∈ Function.support ν +- · apply div_nonneg <| le_trans (by simp [apply_ite]) (hν0 y) +- rw [hνSupport, mem_Ioo] at h +- linarith [h.left] +- · simp only [Function.mem_support, ne_eq, not_not] at h +- simp [h] +- · have : (fun x ↦ ν x / x).support ⊆ Icc (1 / 2) 2 := by +- rw [Function.support_div, hνSupport] +- exact (inter_subset_left).trans Ioo_subset_Icc_self +- apply (integrableOn_iff_integrable_of_support_subset this).mp +- apply ContinuousOn.integrableOn_compact isCompact_Icc +- apply hνContDiff.continuous.continuousOn.div continuousOn_id ?_ +- simp only [mem_Icc, ne_eq, and_imp, id_eq] +- intros; linarith +diff --git a/PrimeNumberTheoremAnd/Sobolev.lean b/PrimeNumberTheoremAnd/Sobolev.lean +index 1f98bcb..c069633 100644 +--- a/PrimeNumberTheoremAnd/Sobolev.lean ++++ b/PrimeNumberTheoremAnd/Sobolev.lean +@@ -1,4 +1,10 @@ ++/- ++Adapted from PrimeNumberTheoremAnd by Alex Kontorovich and contributors. ++Licensed under the Apache License, Version 2.0; see the upstream LICENSE. ++This compatibility port retains the proven declarations used by this project. ++-/ + import Mathlib.Analysis.Calculus.Deriv.Support ++import Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas + import Mathlib.Analysis.Distribution.SchwartzSpace.Deriv + import Mathlib.Order.Filter.ZeroAndBoundedAtFilter + +@@ -7,16 +13,26 @@ open scoped ContDiff + + variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] {n : ℕ} + +-@[ext] structure CS (n : ℕ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] where ++structure CS (n : ℕ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] where ++ + toFun : ℝ → E + h1 : ContDiff ℝ n toFun + h2 : HasCompactSupport toFun + ++@[ext] protected theorem CS.ext {n : ℕ} {E : Type*} ++ [NormedAddCommGroup E] [NormedSpace ℝ E] {x y : CS n E} ++ (h : x.toFun = y.toFun) : x = y := by ++ cases x ++ cases y ++ cases h ++ rfl ++ + structure trunc extends (CS 2 ℝ) where + h3 : (Set.Icc (-1) (1)).indicator 1 ≤ toFun + h4 : toFun ≤ Set.indicator (Set.Ioo (-2) (2)) 1 + + structure W1 (n : ℕ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] where ++ + toFun : ℝ → E + smooth : ContDiff ℝ n toFun + integrable : ∀ ⦃k⦄, k ≤ n → Integrable (iteratedDeriv k toFun) +@@ -27,14 +43,10 @@ section lemmas + + noncomputable def funscale {E : Type*} (g : ℝ → E) (R x : ℝ) : E := g (R⁻¹ • x) + +-lemma contDiff_ofReal : ContDiff ℝ ∞ ofReal := by +- have key x : HasDerivAt ofReal 1 x := hasDerivAt_id x |>.ofReal_comp +- have key' : deriv ofReal = fun _ => 1 := by ext x ; exact (key x).deriv +- refine contDiff_infty_iff_deriv.mpr ⟨fun x => (key x).differentiableAt, ?_⟩ +- simpa [key'] using contDiff_const ++theorem contDiff_ofReal : ContDiff ℝ ∞ ofReal := Complex.ofRealCLM.contDiff + + omit [NormedSpace ℝ E] in +-lemma tendsto_funscale {f : ℝ → E} (hf : ContinuousAt f 0) (x : ℝ) : ++theorem tendsto_funscale {f : ℝ → E} (hf : ContinuousAt f 0) (x : ℝ) : + Tendsto (fun R => funscale f R x) atTop (𝓝 (f 0)) := + hf.tendsto.comp (by simpa using tendsto_inv_atTop_zero.mul_const x) + +@@ -52,31 +64,31 @@ instance : Coe (CS n ℝ) (CS n ℂ) where coe f := ⟨fun x => f x, + def neg (f : CS n E) : CS n E where + toFun := -f + h1 := f.h1.neg +- h2 := by simpa [HasCompactSupport, tsupport] using f.h2 ++ h2 := f.h2.neg + + instance : Neg (CS n E) where neg := neg + +-@[simp] lemma neg_apply {x : ℝ} : (-f) x = - (f x) := rfl ++@[simp] theorem neg_apply {x : ℝ} : (-f) x = - (f x) := rfl + + def smul (R : ℝ) (f : CS n E) : CS n E := ⟨R • f, f.h1.const_smul R, f.h2.smul_left⟩ + + instance : HSMul ℝ (CS n E) (CS n E) where hSMul := smul + +-@[simp] lemma smul_apply : (R • f) x = R • f x := rfl ++@[simp] theorem smul_apply : (R • f) x = R • f x := rfl + +-lemma continuous (f : CS n E) : Continuous f := f.h1.continuous ++theorem continuous (f : CS n E) : Continuous f := f.h1.continuous + + noncomputable def deriv (f : CS (n + 1) E) : CS n E where + toFun := _root_.deriv f + h1 := (contDiff_succ_iff_deriv.mp f.h1).2.2 + h2 := f.h2.deriv + +-lemma hasDerivAt (f : CS (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := ++theorem hasDerivAt (f : CS (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := + (f.h1.differentiable (by simp)).differentiableAt.hasDerivAt + +-lemma deriv_apply {f : CS (n + 1) E} {x : ℝ} : f.deriv x = _root_.deriv f x := rfl ++theorem deriv_apply {f : CS (n + 1) E} {x : ℝ} : f.deriv x = _root_.deriv f x := rfl + +-lemma deriv_smul {f : CS (n + 1) E} : (R • f).deriv = R • f.deriv := by ++theorem deriv_smul {f : CS (n + 1) E} : (R • f).deriv = R • f.deriv := by + ext x ; exact (f.hasDerivAt x |>.const_smul R).deriv + + noncomputable def scale (g : CS n E) (R : ℝ) : CS n E := by +@@ -86,27 +98,27 @@ noncomputable def scale (g : CS n E) (R : ℝ) : CS n E := by + · exact g.h1.comp (contDiff_const_smul R⁻¹) + · exact g.h2.comp_smul (inv_ne_zero h) + +-lemma deriv_scale {f : CS (n + 1) E} : (f.scale R).deriv = R⁻¹ • f.deriv.scale R := by ++theorem deriv_scale {f : CS (n + 1) E} : (f.scale R).deriv = R⁻¹ • f.deriv.scale R := by + ext v ; by_cases hR : R = 0 + · simp [hR, scale, deriv] + · simp only [scale, hR, ↓reduceDIte, smul_apply] + exact ((f.hasDerivAt (R⁻¹ • v)).scomp v +- (by simpa using! (hasDerivAt_id v).const_smul R⁻¹)).deriv ++ (by convert (hasDerivAt_const_mul (x := v) R⁻¹) using 1)).deriv + +-lemma deriv_scale' {f : CS (n + 1) E} : ++theorem deriv_scale' {f : CS (n + 1) E} : + (f.scale R).deriv v = R⁻¹ • f.deriv (R⁻¹ • v) := by + rw [deriv_scale, smul_apply] + by_cases hR : R = 0 <;> simp [hR, scale, funscale] + +-lemma hasDerivAt_scale (f : CS (n + 1) E) (R x : ℝ) : ++theorem hasDerivAt_scale (f : CS (n + 1) E) (R x : ℝ) : + HasDerivAt (f.scale R) (R⁻¹ • _root_.deriv f (R⁻¹ • x)) x := by + convert hasDerivAt (f.scale R) x ; rw [deriv_scale'] ; rfl + +-lemma tendsto_scale (f : CS n E) (x : ℝ) : Tendsto (fun R => f.scale R x) atTop (𝓝 (f 0)) := by ++theorem tendsto_scale (f : CS n E) (x : ℝ) : Tendsto (fun R => f.scale R x) atTop (𝓝 (f 0)) := by + apply (tendsto_funscale f.continuous.continuousAt x).congr' + filter_upwards [eventually_ne_atTop 0] with R hR ; simp [scale, hR] + +-lemma bounded : ∃ C, ∀ v, ‖f v‖ ≤ C := by ++theorem bounded : ∃ C, ∀ v, ‖f v‖ ≤ C := by + obtain ⟨x, hx⟩ := + (continuous_norm.comp f.continuous).exists_forall_ge_of_hasCompactSupport f.h2.norm + exact ⟨_, hx⟩ +@@ -119,16 +131,16 @@ instance : CoeFun trunc (fun _ => ℝ → ℝ) where coe f := f.toFun + + instance : Coe trunc (CS 2 ℝ) where coe := trunc.toCS + +-lemma nonneg (g : trunc) (x : ℝ) : 0 ≤ g x := (Set.indicator_nonneg (by simp) x).trans (g.h3 x) ++theorem nonneg (g : trunc) (x : ℝ) : 0 ≤ g x := (Set.indicator_nonneg (by simp) x).trans (g.h3 x) + +-lemma le_one (g : trunc) (x : ℝ) : g x ≤ 1 := ++theorem le_one (g : trunc) (x : ℝ) : g x ≤ 1 := + (g.h4 x).trans <| Set.indicator_le_self' (by simp) x + +-lemma zero (g : trunc) : g =ᶠ[𝓝 0] 1 := by ++theorem zero (g : trunc) : g =ᶠ[𝓝 0] 1 := by + have : Set.Icc (-1) 1 ∈ 𝓝 (0 : ℝ) := by apply Icc_mem_nhds <;> linarith + exact eventually_of_mem this (fun x hx => le_antisymm (g.le_one x) (by simpa [hx] using g.h3 x)) + +-@[simp] lemma zero_at {g : trunc} : g 0 = 1 := g.zero.eq_of_nhds ++@[simp] theorem zero_at {g : trunc} : g 0 = 1 := g.zero.eq_of_nhds + + end trunc + +@@ -136,23 +148,15 @@ namespace W1 + + instance : CoeFun (W1 n E) (fun _ => ℝ → E) where coe := W1.toFun + +-lemma continuous (f : W1 n E) : Continuous f := f.smooth.continuous ++theorem continuous (f : W1 n E) : Continuous f := f.smooth.continuous + +-lemma differentiable (f : W1 (n + 1) E) : Differentiable ℝ f := ++theorem differentiable (f : W1 (n + 1) E) : Differentiable ℝ f := + f.smooth.differentiable (by simp) + +-lemma iteratedDeriv_sub {f g : ℝ → E} (hf : ContDiff ℝ n f) (hg : ContDiff ℝ n g) : ++theorem iteratedDeriv_sub {f g : ℝ → E} (hf : ContDiff ℝ n f) (hg : ContDiff ℝ n g) : + iteratedDeriv n (f - g) = iteratedDeriv n f - iteratedDeriv n g := by +- induction n generalizing f g with +- | zero => rfl +- | succ n ih => +- have hf' : ContDiff ℝ n (deriv f) := hf.iterate_deriv' n 1 +- have hg' : ContDiff ℝ n (deriv g) := hg.iterate_deriv' n 1 +- have hfg : deriv (f - g) = deriv f - deriv g := by +- ext x ; apply deriv_sub +- · exact (hf.differentiable (by simp)).differentiableAt +- · exact (hg.differentiable (by simp)).differentiableAt +- simp_rw [iteratedDeriv_succ', ← ih hf' hg', hfg] ++ funext x ++ exact _root_.iteratedDeriv_sub hf.contDiffAt hg.contDiffAt + + noncomputable def deriv (f : W1 (n + 1) E) : W1 n E where + toFun := _root_.deriv f +@@ -160,7 +164,7 @@ noncomputable def deriv (f : W1 (n + 1) E) : W1 n E where + integrable k hk := by + simpa [iteratedDeriv_succ'] using f.integrable (Nat.succ_le_succ hk) + +-lemma hasDerivAt (f : W1 (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := ++theorem hasDerivAt (f : W1 (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := + f.differentiable.differentiableAt.hasDerivAt + + def sub (f g : W1 n E) : W1 n E where +@@ -173,12 +177,18 @@ def sub (f g : W1 n E) : W1 n E where + + instance : Sub (W1 n E) where sub := sub + +-lemma integrable_iteratedDeriv_Schwarz {f : 𝓢(ℝ, ℂ)} : Integrable (iteratedDeriv n f) := by ++theorem integrable_iteratedDeriv_Schwarz {f : 𝓢(ℝ, ℂ)} : Integrable (iteratedDeriv n f) := by + induction n generalizing f with + | zero => exact f.integrable +- | succ n ih => simpa [iteratedDeriv_succ'] using! ih (f := SchwartzMap.derivCLM ℝ ℂ f) +- +-noncomputable def of_Schwartz (f : 𝓢(ℝ, ℂ)) : W1 n ℂ where ++ | succ n ih => ++ rw [iteratedDeriv_succ'] ++ have hd : (SchwartzMap.derivCLM ℝ ℂ f : ℝ → ℂ) = _root_.deriv f := by ++ funext x ++ exact SchwartzMap.derivCLM_apply ℝ f x ++ rw [← hd] ++ exact ih (f := SchwartzMap.derivCLM ℝ ℂ f) ++ ++noncomputable def ofSchwartz (f : 𝓢(ℝ, ℂ)) : W1 n ℂ where + toFun := f + smooth := f.smooth n + integrable _ _ := integrable_iteratedDeriv_Schwarz +@@ -192,20 +202,29 @@ variable {f : W21} + noncomputable def norm (f : ℝ → ℂ) : ℝ := + (∫ v, ‖f v‖) + (4 * π ^ 2)⁻¹ * (∫ v, ‖deriv (deriv f) v‖) + +-lemma norm_nonneg {f : ℝ → ℂ} : 0 ≤ norm f := ++theorem norm_nonneg {f : ℝ → ℂ} : 0 ≤ norm f := + add_nonneg (integral_nonneg (fun t => by simp)) + (mul_nonneg (by positivity) (integral_nonneg (fun t => by simp))) + + noncomputable instance : Norm W21 where norm := norm ∘ W1.toFun + +-noncomputable instance : Coe 𝓢(ℝ, ℂ) W21 where coe := W1.of_Schwartz ++noncomputable instance : Coe 𝓢(ℝ, ℂ) W21 where coe := W1.ofSchwartz + + def ofCS2 (f : CS 2 ℂ) : W21 := by +- refine ⟨f, f.h1, fun k hk => ?_⟩ ; match k with +- | 0 => exact f.h1.continuous.integrable_of_hasCompactSupport f.h2 +- | 1 => simpa using (f.h1.continuous_deriv one_le_two).integrable_of_hasCompactSupport f.h2.deriv +- | 2 => simpa [iteratedDeriv_succ] using +- (f.h1.iterate_deriv' 0 2).continuous.integrable_of_hasCompactSupport f.h2.deriv.deriv ++ refine ⟨f, f.h1, ?_⟩ ++ intro k hk ++ cases k with ++ | zero => exact f.h1.continuous.integrable_of_hasCompactSupport f.h2 ++ | succ k => ++ cases k with ++ | zero => ++ simpa using (f.h1.continuous_deriv one_le_two).integrable_of_hasCompactSupport f.h2.deriv ++ | succ k => ++ have hk0 : k = 0 := ++ Nat.eq_zero_of_le_zero (Nat.le_of_succ_le_succ (Nat.le_of_succ_le_succ hk)) ++ subst k ++ simpa [iteratedDeriv_succ] using ++ (f.h1.iterate_deriv' 0 2).continuous.integrable_of_hasCompactSupport f.h2.deriv.deriv + + instance : Coe (CS 2 ℂ) W21 where coe := ofCS2 + +@@ -214,12 +233,12 @@ instance : HMul (CS 2 ℂ) W21 (CS 2 ℂ) where + + instance : HMul (CS 2 ℝ) W21 (CS 2 ℂ) where hMul g f := (g : CS 2 ℂ) * f + +-lemma hf (f : W21) : Integrable f := f.integrable zero_le_two ++theorem hf (f : W21) : Integrable f := f.integrable zero_le_two + +-lemma hf' (f : W21) : Integrable (deriv f) := by ++theorem hf' (f : W21) : Integrable (deriv f) := by + simpa [iteratedDeriv_succ] using f.integrable one_le_two + +-lemma hf'' (f : W21) : Integrable (deriv (deriv f)) := by ++theorem hf'' (f : W21) : Integrable (deriv (deriv f)) := by + simpa [iteratedDeriv_succ] using f.integrable le_rfl + + end W21 +@@ -227,7 +246,6 @@ end W21 + theorem W21_approximation (f : W21) (g : trunc) : + Tendsto (fun R => ‖f - (g.scale R * f : W21)‖) atTop (𝓝 0) := by + +- -- Definitions + let f' := f.deriv + let f'' := f'.deriv + let g' := (g : CS 2 ℝ).deriv +@@ -236,13 +254,12 @@ theorem W21_approximation (f : W21) (g : trunc) : + let h' R := - (g.scale R).deriv + let h'' R := - (g.scale R).deriv.deriv + +- -- Properties of h + have ch {R} : Continuous (fun v => (h R v : ℂ)) := + continuous_ofReal.comp <| continuous_const.sub (CS.continuous _) + have ch' {R} : Continuous (fun v => (h' R v : ℂ)) := continuous_ofReal.comp (CS.continuous _) + have ch'' {R} : Continuous (fun v => (h'' R v : ℂ)) := continuous_ofReal.comp (CS.continuous _) + have dh R v : HasDerivAt (h R) (h' R v) v := by +- convert! CS.hasDerivAt_scale (g : CS 2 ℝ) R v |>.const_sub 1 using 1 ++ convert CS.hasDerivAt_scale (g : CS 2 ℝ) R v |>.const_sub 1 using 1 + simp [h', CS.deriv_scale', show g.deriv.toFun = deriv g.toFun from rfl] + have dh' R v : HasDerivAt (h' R) (h'' R v) v := ((g.scale R).deriv.hasDerivAt v).neg + have hh1 R v : |h R v| ≤ 1 := by +@@ -254,12 +271,10 @@ theorem W21_approximation (f : W21) (g : trunc) : + have vR v : Tendsto (fun R : ℝ => v * R⁻¹) atTop (𝓝 0) := by + simpa using tendsto_inv_atTop_zero.const_mul v + +- -- Proof + convert_to Tendsto (fun R => W21.norm (fun v => h R v * f v)) atTop (𝓝 0) + · ext R ; change W21.norm _ = _ ; congr ; ext v ; simp [h, sub_mul] ; rfl + rw [show (0 : ℝ) = 0 + ((4 * π ^ 2)⁻¹ : ℝ) * 0 by simp] + refine Tendsto.add ?_ (Tendsto.const_mul _ ?_) +- + · let F R v := ‖h R v * f v‖ + have eh v : ∀ᶠ R in atTop, h R v = 0 := by + filter_upwards [(vR v).eventually g.zero, eventually_ne_atTop 0] with R hR hR' +@@ -275,7 +290,6 @@ theorem W21_approximation (f : W21) (g : trunc) : + apply Eventually.of_forall ; intro v + apply tendsto_nhds_of_eventually_eq ; filter_upwards [eh v] with R hR ; simp [F, hR] + simpa [F] using tendsto_integral_filter_of_dominated_convergence _ e1 e2 f.hf.norm e4 +- + · let F R v := ‖h'' R v * f v + 2 * h' R v * f' v + h R v * f'' v‖ + convert_to Tendsto (fun R ↦ ∫ (v : ℝ), F R v) atTop (𝓝 0) + · have this R v : +@@ -291,9 +305,8 @@ theorem W21_approximation (f : W21) (g : trunc) : + (dh R v).ofReal_comp.mul (df' v) + have d1 : deriv (fun v => h R v * f v) = fun v => h' R v * f v + h R v * f' v := + funext (fun v => (l3 v).deriv) +- rw [d1] ; convert! (l5.add l7).deriv using 1 ; ring ++ rw [d1] ; convert (l5.add l7).deriv using 1 ; ring + simp_rw [this, F] +- + obtain ⟨c1, mg'⟩ := g'.bounded + obtain ⟨c2, mg''⟩ := g''.bounded + let bound v := c2 * ‖f v‖ + 2 * c1 * ‖f' v‖ + ‖f'' v‖ +@@ -338,8 +351,13 @@ theorem W21_approximation (f : W21) (g : trunc) : + (((f.hf.norm).const_mul _).add ((f.hf'.norm).const_mul _)).add f.hf''.norm + have e4 : ∀ᵐ (a : ℝ), Tendsto (fun n ↦ F n a) atTop (𝓝 0) := by + apply Eventually.of_forall ; intro v +- have evg' : g' =ᶠ[𝓝 0] 0 := by convert! ← g.zero.deriv ; exact deriv_const' _ +- have evg'' : g'' =ᶠ[𝓝 0] 0 := by convert! ← evg'.deriv ; exact deriv_const' _ ++ have evg' : (g' : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) := by ++ have hzero : (g : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 1) := g.zero ++ change _root_.deriv (g : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) ++ simpa only [deriv_const'] using hzero.deriv ++ have evg'' : (g'' : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) := by ++ change _root_.deriv (g' : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) ++ simpa only [deriv_const'] using evg'.deriv + refine tendsto_norm_zero.comp <| (ZeroAtFilter.add ?_ ?_).add ?_ + · have eh'' v : ∀ᶠ R in atTop, h'' R v = 0 := by + filter_upwards [(vR v).eventually evg'', eventually_ne_atTop 0] with R hR hR' +@@ -355,5 +373,6 @@ theorem W21_approximation (f : W21) (g : trunc) : + simp [h', CS.deriv_scale', mul_comm R⁻¹, hR] + apply tendsto_nhds_of_eventually_eq + filter_upwards [eh' v] with R hR ; simp [hR] +- · simpa [h] using! ((g.tendsto_scale v).const_sub 1).ofReal.mul tendsto_const_nhds ++ · simpa [h, Filter.ZeroAtFilter] using ++ ((g.tendsto_scale v).const_sub 1).ofReal.mul tendsto_const_nhds + simpa [F] using tendsto_integral_filter_of_dominated_convergence bound e1 e2 e3 e4 +diff --git a/PrimeNumberTheoremAnd/Wiener.lean b/PrimeNumberTheoremAnd/Wiener.lean +index 59fd506..d69b893 100644 +--- a/PrimeNumberTheoremAnd/Wiener.lean ++++ b/PrimeNumberTheoremAnd/Wiener.lean +@@ -1,22 +1,18 @@ +-import Architect ++/- ++Adapted from PrimeNumberTheoremAnd by Alex Kontorovich and contributors. ++Licensed under the Apache License, Version 2.0; see the upstream LICENSE. ++This compatibility port retains the proven declarations used by this project. ++-/ + import Mathlib.Analysis.Fourier.RiemannLebesgueLemma + import Mathlib.Analysis.Normed.Group.Tannery + import Mathlib.Analysis.SumIntegralComparisons + import Mathlib.NumberTheory.Chebyshev + import Mathlib.NumberTheory.LSeries.PrimesInAP + import Mathlib.NumberTheory.MulChar.Lemmas +-import Mathlib.Topology.EMetricSpace.BoundedVariation +-import PrimeNumberTheoremAnd.Mathlib.Analysis.Asymptotics.Asymptotics + import PrimeNumberTheoremAnd.Fourier + import PrimeNumberTheoremAnd.SmoothExistence + import Mathlib.Analysis.Convolution +- +-set_option lang.lemmaCmd true +-set_option linter.style.header false +- +--- note: the opening of ArithmeticFunction introduces a notation σ that seems +--- impossible to hide, and hence parameters that are traditionally called σ will +--- have to be called σ' instead in this file. ++import Mathlib.MeasureTheory.Group.Circle + + open Real BigOperators ArithmeticFunction MeasureTheory Filter Set FourierTransform LSeries + Asymptotics SchwartzMap +@@ -28,31 +24,17 @@ open scoped ComplexConjugate + variable {n : ℕ} {A a b c d u x y t σ' : ℝ} {ψ Ψ : ℝ → ℂ} {F G : ℂ → ℂ} {f : ℕ → ℂ} {𝕜 : Type} + [RCLike 𝕜] + +-blueprint_comment /-- +-The Fourier transform of an absolutely integrable function $\psi: \R \to \C$ is defined by the +-formula $$ \hat \psi(u) := \int_\R e(-tu) \psi(t)\ dt$$ where $e(\theta) := e^{2\pi i \theta}$. +- +-Let $f: \N \to \C$ be an arithmetic function such that $\sum_{n=1}^\infty \frac{|f(n)|}{n^\sigma} < +-\infty$ for all $\sigma>1$. Then the Dirichlet series +-$$ F(s) := \sum_{n=1}^\infty \frac{f(n)}{n^s}$$ +-is absolutely convergent for $\sigma>1$. +--/ +- + noncomputable + def nterm (f : ℕ → ℂ) (σ' : ℝ) (n : ℕ) : ℝ := if n = 0 then 0 else ‖f n‖ / n ^ σ' + +-lemma nterm_eq_norm_term {f : ℕ → ℂ} : nterm f σ' n = ‖term f σ' n‖ := by ++theorem nterm_eq_norm_term {f : ℕ → ℂ} : nterm f σ' n = ‖term f σ' n‖ := by + by_cases h : n = 0 <;> simp [nterm, term, h] + + theorem norm_term_eq_nterm_re (s : ℂ) : + ‖term f s n‖ = nterm f (s.re) n := by +- simp only [nterm, term, apply_ite (‖·‖), norm_zero, norm_div] +- apply ite_congr rfl (fun _ ↦ rfl) +- intro h +- congr +- refine norm_natCast_cpow_of_pos (by omega) s ++ simpa only [nterm] using LSeries.norm_term_eq f s n + +-lemma hf_coe1 (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hσ : 1 < σ') : ++theorem hf_coe1 (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hσ : 1 < σ') : + ∑' i, (‖term f σ' i‖₊ : ENNReal) ≠ ⊤ := by + simp_rw [ENNReal.tsum_coe_ne_top_iff_summable_coe, ← norm_toNNReal] + norm_cast +@@ -60,25 +42,19 @@ lemma hf_coe1 (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hσ : + convert hf σ' hσ with i + simp [nterm_eq_norm_term] + +-instance instMeasurableSpace : MeasurableSpace Circle := +- inferInstanceAs <| MeasurableSpace <| Subtype _ +-instance instBorelSpace : BorelSpace Circle := +- inferInstanceAs <| BorelSpace <| Subtype (· ∈ Metric.sphere (0 : ℂ) 1) +- +--- TODO - add to mathlib + attribute [fun_prop] Real.continuous_fourierChar + +-lemma first_fourier_aux1 (hψ : AEMeasurable ψ) {x : ℝ} (n : ℕ) : AEMeasurable fun (u : ℝ) ↦ ++theorem first_fourier_aux1 (hψ : AEMeasurable ψ) {x : ℝ} (n : ℕ) : AEMeasurable fun (u : ℝ) ↦ + (‖fourierChar (-(u * ((1 : ℝ) / ((2 : ℝ) * π) * (n / x).log))) • ψ u‖ₑ : ENNReal) := by + fun_prop + +-lemma first_fourier_aux2a : ++theorem first_fourier_aux2a : + (2 : ℂ) * π * -(y * (1 / (2 * π) * Real.log ((n) / x))) = -(y * ((n) / x).log) := by + calc + _ = -(y * (((2 : ℂ) * π) / (2 * π) * Real.log ((n) / x))) := by ring + _ = _ := by rw [div_self (by norm_num), one_mul] + +-lemma first_fourier_aux2 (hx : 0 < x) (n : ℕ) : ++theorem first_fourier_aux2 (hx : 0 < x) (n : ℕ) : + term f σ' n * 𝐞 (-(y * (1 / (2 * π) * Real.log (n / x)))) • ψ y = + term f (σ' + y * I) n • (ψ y * x ^ (y * I)) := by + by_cases hn : n = 0 +@@ -106,31 +82,10 @@ lemma first_fourier_aux2 (hx : 0 < x) (n : ℕ) : + ring + _ = _ := by simp ; group + +-set_option backward.isDefEq.respectTransparency false in +-@[blueprint "first-fourier" +- (title := "first-fourier") +- (statement := /-- +- If $\psi: \R \to \C$ is integrable and $x > 0$, then for any $\sigma>1$ +- $$ \sum_{n=1}^\infty \frac{f(n)}{n^\sigma} \hat \psi( \frac{1}{2\pi} \log \frac{n}{x} ) = +- \int_\R F(\sigma + it) \psi(t) x^{it}\ dt.$$ +- -/) +- (proof := /-- +- By the definition of the Fourier transform, the left-hand side expands as +- $$ \sum_{n=1}^\infty \int_\R \frac{f(n)}{n^\sigma} \psi(t) e( - \frac{1}{2\pi} t \log +- \frac{n}{x})\ dt$$ +- while the right-hand side expands as +- $$ \int_\R \sum_{n=1}^\infty \frac{f(n)}{n^{\sigma+it}} \psi(t) x^{it}\ dt.$$ +- Since +- $$\frac{f(n)}{n^\sigma} \psi(t) e( - \frac{1}{2\pi} t \log \frac{n}{x}) = +- \frac{f(n)}{n^{\sigma+it}} \psi(t) x^{it}$$ +- the claim then follows from Fubini's theorem. +- -/) +- (latexEnv := "lemma")] +-lemma first_fourier (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++theorem first_fourier (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) + (hsupp : Integrable ψ) (hx : 0 < x) (hσ : 1 < σ') : + ∑' n : ℕ, term f σ' n * (𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))) = + ∫ t : ℝ, LSeries f (σ' + t * I) * ψ t * x ^ (t * I) := by +- + calc + _ = ∑' n, term f σ' n * ∫ (v : ℝ), 𝐞 (-(v * ((1 : ℝ) / + ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by +@@ -162,14 +117,12 @@ lemma first_fourier (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) + rw [norm_term_eq_nterm_re] + simp + +- +- + @[continuity] +-lemma continuous_multiplicative_ofAdd : Continuous (⇑Multiplicative.ofAdd : ℝ → ℝ) := ⟨fun _ ↦ id⟩ ++theorem continuous_multiplicative_ofAdd : Continuous (⇑Multiplicative.ofAdd : ℝ → ℝ) := ⟨fun _ ↦ id⟩ + + attribute [fun_prop] measurable_coe_nnreal_ennreal + +-lemma second_fourier_integrable_aux1a (hσ : 1 < σ') : ++theorem second_fourier_integrable_aux1a (hσ : 1 < σ') : + IntegrableOn (fun (x : ℝ) ↦ cexp (-((x : ℂ) * ((σ' : ℂ) - 1)))) (Ici (-Real.log x)) := by + norm_cast + suffices IntegrableOn (fun (x : ℝ) ↦ (rexp (-(x * (σ' - 1))))) (Ici (-x.log)) _ from this.ofReal +@@ -178,18 +131,16 @@ lemma second_fourier_integrable_aux1a (hσ : 1 < σ') : + apply exp_neg_integrableOn_Ioi + linarith + +-lemma second_fourier_integrable_aux1 (hcont : Measurable ψ) (hsupp : Integrable ψ) (hσ : 1 < σ') : ++theorem second_fourier_integrable_aux1 (hcont : Measurable ψ) (hsupp : Integrable ψ) (hσ : 1 < σ') : + let ν : Measure (ℝ × ℝ) := (volume.restrict (Ici (-Real.log x))).prod volume + Integrable (Function.uncurry fun (u : ℝ) (a : ℝ) ↦ ((rexp (-u * (σ' - 1))) : ℂ) • + (𝐞 (Multiplicative.ofAdd (-(a * (u / (2 * π))))) : ℂ) • ψ a) ν := by + intro ν + constructor + · apply Measurable.aestronglyMeasurable +- -- `Multiplicative.ofAdd x` is definitionally `x`; unfold it by `change` since `fun_prop` +- -- does not see through it. +- change Measurable (Function.uncurry fun (u : ℝ) (a : ℝ) ↦ ((rexp (-u * (σ' - 1))) : ℂ) • +- (𝐞 (-(a * (u / (2 * π)))) : ℂ) • ψ a) +- simp only [neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_sub, ofReal_one, smul_eq_mul] ++ change Measurable (fun p : ℝ × ℝ => ++ (rexp (-p.1 * (σ' - 1)) : ℂ) * ++ ((fourierChar (-(p.2 * (p.1 / (2 * π)))) : ℂ) * ψ p.2)) + fun_prop + · let f1 : ℝ → ENNReal := fun a1 ↦ ‖cexp (-(↑a1 * (↑σ' - 1)))‖ₑ + let f2 : ℝ → ENNReal := fun a2 ↦ ‖ψ a2‖ₑ +@@ -198,14 +149,14 @@ lemma second_fourier_integrable_aux1 (hcont : Measurable ψ) (hsupp : Integrable + refine (lintegral_prod_mul ?_ ?_).trans_lt ?_ <;> try fun_prop + exact ENNReal.mul_lt_top (second_fourier_integrable_aux1a hσ).2 hsupp.2 + +-lemma second_fourier_integrable_aux2 (hσ : 1 < σ') : ++theorem second_fourier_integrable_aux2 (hσ : 1 < σ') : + IntegrableOn (fun (u : ℝ) ↦ cexp ((1 - ↑σ' - ↑t * I) * ↑u)) (Ioi (-Real.log x)) := by + refine (integrable_norm_iff (Measurable.aestronglyMeasurable <| by fun_prop)).mp ?_ + suffices IntegrableOn (fun a ↦ rexp (-(σ' - 1) * a)) (Ioi (-x.log)) _ by simpa [Complex.norm_exp] + apply exp_neg_integrableOn_Ioi + linarith + +-lemma second_fourier_aux (hx : 0 < x) : ++theorem second_fourier_aux (hx : 0 < x) : + -(cexp (-((1 - ↑σ' - ↑t * I) * ↑(Real.log x))) / (1 - ↑σ' - ↑t * I)) = + ↑(x ^ (σ' - 1)) * (↑σ' + ↑t * I - 1)⁻¹ * ↑x ^ (↑t * I) := by + calc +@@ -217,51 +168,24 @@ lemma second_fourier_aux (hx : 0 < x) : + rw [Complex.cpow_add _ _ (ofReal_ne_zero.mpr (ne_of_gt hx))] + _ = _ := by rw [ofReal_cpow hx.le]; push_cast; ring + +-set_option backward.isDefEq.respectTransparency false in +-@[blueprint "second-fourier" +- (title := "second-fourier") +- (statement := /-- +- If $\psi: \R \to \C$ is absolutely integrable and $x > 0$, then for any $\sigma>1$ +- $$ \int_{-\log x}^\infty e^{-u(\sigma-1)} \hat \psi(\frac{u}{2\pi})\ du = +- x^{\sigma - 1} \int_\R \frac{1}{\sigma+it-1} \psi(t) x^{it}\ dt.$$ +- -/) +- (proof := /-- +- The left-hand side expands as +- $$ \int_{-\log x}^\infty \int_\R e^{-u(\sigma-1)} \psi(t) e(-\frac{tu}{2\pi})\ dt\ du$$ +- so by Fubini's theorem it suffices to verify the identity +- \begin{align*} +- \int_{-\log x}^\infty e^{-u(\sigma-1)} e(-\frac{tu}{2\pi})\ du +- &= \int_{-\log x}^\infty e^{(it - \sigma + 1)u}\ du \\ +- &= \frac{1}{it - \sigma + 1} e^{(it - \sigma + 1)u}\ \Big|_{-\log x}^\infty \\ +- &= x^{\sigma - 1} \frac{1}{\sigma+it-1} x^{it} +- \end{align*} +- -/) +- (latexEnv := "lemma")] +-lemma second_fourier (hcont : Measurable ψ) (hsupp : Integrable ψ) ++theorem second_fourier (hcont : Measurable ψ) (hsupp : Integrable ψ) + {x σ' : ℝ} (hx : 0 < x) (hσ : 1 < σ') : + ∫ u in Ici (-log x), Real.exp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = + (x^(σ' - 1) : ℝ) * ∫ t, (1 / (σ' + t * I - 1)) * ψ t * x^(t * I) ∂ volume := by +- + conv in ↑(rexp _) * _ => { rw [Real.fourier_real_eq, ← smul_eq_mul, ← integral_smul] } + rw [MeasureTheory.integral_integral_swap] + swap + · exact second_fourier_integrable_aux1 hcont hsupp hσ + rw [← integral_const_mul] + congr 1; ext t +- dsimp [Real.fourierChar, Circle.exp] +- +- simp_rw [mul_smul_comm, ← smul_mul_assoc, integral_mul_const] +- rw [fun (a b d : ℂ) ↦ show a * (b * (ψ t) * d) = (a * b * d) * ψ t by ring] ++ simp_rw [Circle.smul_def, smul_eq_mul, Real.fourierChar_apply, ++ ← mul_assoc, integral_mul_const] ++ rw [mul_right_comm _ (ψ t) _] + congr 1 +- conv => +- lhs +- enter [2] +- ext a +- rw [AddChar.coe_mk, Submonoid.mk_smul, smul_eq_mul] + push_cast + simp_rw [← Complex.exp_add] + have (u : ℝ) : +- 2 * ↑π * -(↑t * (↑u / (2 * ↑π))) * I + -↑u * (↑σ' - 1) = (1 - σ' - t * I) * u := calc ++ -↑u * (↑σ' - 1) + 2 * ↑π * -(↑t * (↑u / (2 * ↑π))) * I = (1 - σ' - t * I) * u := calc + _ = -↑u * (↑σ' - 1) + (2 * ↑π) / (2 * ↑π) * -(↑t * ↑u) * I := by ring + _ = -↑u * (↑σ' - 1) + 1 * -(↑t * ↑u) * I := by rw [div_self (by norm_num)] + _ = _ := by ring +@@ -285,107 +209,12 @@ lemma second_fourier (hcont : Measurable ψ) (hsupp : Integrable ψ) + integral_Ioi_of_hasDerivAt_of_tendsto' hderiv (second_fourier_integrable_aux2 hσ) hf] + simpa [f, f'] using second_fourier_aux hx + +-blueprint_comment /-- +-Now let $A \in \C$, and suppose that there is a continuous function $G(s)$ defined on +-$\mathrm{Re} s \geq 1$ such that $G(s) = F(s) - \frac{A}{s-1}$ whenever $\mathrm{Re} s > 1$. +-We also make the Chebyshev-type hypothesis +-\begin{equation}\label{cheby} +-\sum_{n \leq x} |f(n)| \ll x +-\end{equation} +-for all $x \geq 1$ (this hypothesis is not strictly necessary, but simplifies the arguments and +-can be obtained fairly easily in applications). +--/ ++theorem one_add_sq_pos (u : ℝ) : 0 < 1 + u ^ 2 := zero_lt_one.trans_le (by simpa using sq_nonneg u) + +-lemma one_add_sq_pos (u : ℝ) : 0 < 1 + u ^ 2 := zero_lt_one.trans_le (by simpa using sq_nonneg u) +- +-@[blueprint "prelim-decay" +- (title := "Preliminary decay bound I") +- (statement := /-- +- If $\psi:\R \to \C$ is absolutely integrable then $$ |\hat \psi(u)| \leq \| \psi \|_1 $$ +- for all $u \in \R$. where $C$ is an absolute constant. +- -/) +- (proof := /-- Immediate from the triangle inequality. -/) +- (latexEnv := "lemma") +- (discussion := 561)] + theorem prelim_decay (ψ : ℝ → ℂ) (u : ℝ) : ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ ∫ t, ‖ψ t‖ := + VectorFourier.norm_fourierIntegral_le_integral_norm .. + +-@[blueprint "prelim-decay-2" +- (title := "Preliminary decay bound II") +- (statement := /-- +-If $\psi:\R \to \C$ is absolutely integrable and of bounded variation, then +-$$ |\hat \psi(u)| \leq \| \psi \|_{TV} / 2\pi |u| $$ +-for all non-zero $u \in \R$. +- -/) +- (proof := /-- By Lebesgue--Stiejtes integration by parts we have +-$$ 2\pi i u \hat \psi(u) = \int _\R e(-tu) d\psi(t)$$ +-and the claim then follows from the triangle inequality. -/) +- (latexEnv := "lemma") +- (discussion := 562)] +-theorem prelim_decay_2 (ψ : ℝ → ℂ) (hψ : Integrable ψ) (hvar : BoundedVariationOn ψ Set.univ) +- (u : ℝ) (hu : u ≠ 0) : +- ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ (eVariationOn ψ Set.univ).toReal / (2 * π * ‖u‖) := by sorry +- +-noncomputable def AbsolutelyContinuous (f : ℝ → ℂ) : Prop := (∀ᵐ x, DifferentiableAt ℝ f x) ∧ +- ∀ a b : ℝ, f b - f a = ∫ t in a..b, deriv f t +- +-@[blueprint "prelim-decay-3" +- (title := "Preliminary decay bound III") +- (statement := /-- +-If $\psi:\R \to \C$ is absolutely integrable, absolutely continuous, and $\psi'$ is of bounded +-variation, then +-$$ |\hat \psi(u)| \leq \| \psi' \|_{TV} / (2\pi |u|)^2$$ +-for all non-zero $u \in \R$. +- -/) +- (proof := /-- Should follow from previous lemma. -/) +- (proofUses := ["prelim-decay-2"]) +- (latexEnv := "lemma") +- (discussion := 563)] +-theorem prelim_decay_3 (ψ : ℝ → ℂ) (hψ : Integrable ψ) +- (habscont : AbsolutelyContinuous ψ) +- (hvar : BoundedVariationOn (deriv ψ) Set.univ) (u : ℝ) (hu : u ≠ 0) : +- ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ (eVariationOn (deriv ψ) Set.univ).toReal / (2 * π * ‖u‖) ^ 2 := by sorry +- +-@[blueprint "decay-alt" +- (title := "Decay bound, alternate form") +- (statement := /-- +-If $\psi:\R \to \C$ is absolutely +-integrable, absolutely continuous, and $\psi'$ is of bounded variation, then +-$$ |\hat \psi(u)| \leq ( \|\psi\|_1 + \| \psi' \|_{TV} / (2\pi)^2) / (1+|u|^2)$$ +-for all $u \in \R$. -/) +- (proof := /-- Should follow from previous lemmas. -/) +- (proofUses := ["prelim-decay", "prelim-decay-3", "decay"]) +- (latexEnv := "lemma") +- (discussion := 564)] +-theorem decay_alt (ψ : ℝ → ℂ) (hψ : Integrable ψ) (habscont : AbsolutelyContinuous ψ) +- (hvar : BoundedVariationOn (deriv ψ) Set.univ) (u : ℝ) : +- ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ +- ((∫ t, ‖ψ t‖) + (eVariationOn (deriv ψ) Set.univ).toReal / (2 * π) ^ 2) / +- (1 + ‖u‖ ^ 2) := by +- rw [le_div_iff₀' <| one_add_sq_pos ‖u‖] +- by_cases hu : u = 0 +- · subst hu +- simp only [norm_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, add_zero, +- one_mul] +- calc ‖𝓕 ψ 0‖ ≤ ∫ t, ‖ψ t‖ := prelim_decay ψ 0 +- _ ≤ (∫ t, ‖ψ t‖) + (eVariationOn (deriv ψ) Set.univ).toReal / (2 * π) ^ 2 := by +- have : 0 ≤ (eVariationOn (deriv ψ) Set.univ).toReal / (2 * π) ^ 2 := by positivity +- linarith +- · have bound1 : ‖𝓕 ψ u‖ ≤ ∫ t, ‖ψ t‖ := prelim_decay ψ u +- have bound2 : ‖𝓕 ψ u‖ ≤ (eVariationOn (deriv ψ) Set.univ).toReal / (2 * π * ‖u‖) ^ 2 := +- prelim_decay_3 ψ hψ habscont hvar u hu +- have : (2 * π * ‖u‖) ^ 2 = (2 * π) ^ 2 * ‖u‖ ^ 2 := by ring +- calc (1 + ‖u‖ ^ 2) * ‖𝓕 ψ u‖ +- = ‖𝓕 ψ u‖ * 1 + ‖𝓕 ψ u‖ * ‖u‖ ^ 2 := by ring +- _ ≤ (∫ t, ‖ψ t‖) * 1 + +- (eVariationOn (deriv ψ) Set.univ).toReal / (2 * π * ‖u‖) ^ 2 * ‖u‖ ^ 2 := by +- gcongr +- _ = (∫ t, ‖ψ t‖) + (eVariationOn (deriv ψ) Set.univ).toReal / (2 * π) ^ 2 := by +- rw [mul_one, this, div_mul_eq_div_div] +- congr 1 +- rw [div_mul_eq_mul_div, div_eq_iff (pow_ne_zero 2 <| norm_ne_zero_iff.mpr hu)] +- +-lemma decay_bounds_key (f : W21) (u : ℝ) : ‖𝓕 (f : ℝ → ℂ) u‖ ≤ ‖f‖ * (1 + u ^ 2)⁻¹ := by ++theorem decay_bounds_key (f : W21) (u : ℝ) : ‖𝓕 (f : ℝ → ℂ) u‖ ≤ ‖f‖ * (1 + u ^ 2)⁻¹ := by + have l1 : 0 < 1 + u ^ 2 := one_add_sq_pos _ + have l2 : 1 + u ^ 2 = ‖(1 : ℂ) + u ^ 2‖ := by + norm_cast ; simp only [Real.norm_eq_abs, abs_eq_self.2 l1.le] +@@ -399,7 +228,7 @@ lemma decay_bounds_key (f : W21) (u : ℝ) : ‖𝓕 (f : ℝ → ℂ) u‖ ≤ + rw [norm_neg, F_mul, norm_mul, W21.norm] + gcongr <;> apply VectorFourier.norm_fourierIntegral_le_integral_norm + +-lemma decay_bounds_aux {f : ℝ → ℂ} (hf : AEStronglyMeasurable f volume) ++theorem decay_bounds_aux {f : ℝ → ℂ} (hf : AEStronglyMeasurable f volume) + (h : ∀ t, ‖f t‖ ≤ A * (1 + t ^ 2)⁻¹) : + ∫ t, ‖f t‖ ≤ π * A := by + have l1 : Integrable (fun x ↦ A * (1 + x ^ 2)⁻¹) := integrable_inv_one_add_sq.const_mul A +@@ -420,29 +249,12 @@ theorem decay_bounds_W21 (f : W21) (hA : ∀ t, ‖f t‖ ≤ A / (1 + t ^ 2)) + change W21.norm _ * _ ≤ _ + simp_rw [W21.norm, div_eq_mul_inv, add_mul, l0] ; gcongr + +-@[blueprint +- "decay" +- (title := "Decay bounds") +- (statement := /-- +- If $\psi:\R \to \C$ is $C^2$ and obeys the bounds +- $$ |\psi(t)|, |\psi''(t)| \leq A / (1 + |t|^2)$$ +- for all $t \in \R$, then +- $$ |\hat \psi(u)| \leq C A / (1+|u|^2)$$ +- for all $u \in \R$, where $C$ is an absolute constant. +- -/) +- (proof := /-- +- From two integration by parts we obtain the identity +- $$ (1+u^2) \hat \psi(u) = \int_{\bf R} (\psi(t) - \frac{u}{4\pi^2} \psi''(t)) e(-tu)\ dt.$$ +- Now apply the triangle inequality and the identity $\int_{\bf R} \frac{dt}{1+t^2}\ dt = \pi$ to +- obtain the claim with $C = \pi + 1 / 4 \pi$. +- -/) +- (latexEnv := "lemma")] +-lemma decay_bounds (ψ : CS 2 ℂ) (hA : ∀ t, ‖ψ t‖ ≤ A / (1 + t ^ 2)) ++theorem decay_bounds (ψ : CS 2 ℂ) (hA : ∀ t, ‖ψ t‖ ≤ A / (1 + t ^ 2)) + (hA' : ∀ t, ‖deriv^[2] ψ t‖ ≤ A / (1 + t ^ 2)) : + ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ (π + 1 / (4 * π)) * A / (1 + u ^ 2) := by + exact decay_bounds_W21 ψ hA hA' u + +-lemma decay_bounds_cor_aux (ψ : CS 2 ℂ) : ∃ C : ℝ, ∀ u, ‖ψ u‖ ≤ C / (1 + u ^ 2) := by ++theorem decay_bounds_cor_aux (ψ : CS 2 ℂ) : ∃ C : ℝ, ∀ u, ‖ψ u‖ ≤ C / (1 + u ^ 2) := by + have l1 : HasCompactSupport (fun u : ℝ => ((1 + u ^ 2) : ℝ) * ψ u) := by exact ψ.h2.mul_left + have := ψ.h1.continuous + obtain ⟨C, hC⟩ := l1.exists_bound_of_continuous (by fun_prop) +@@ -451,48 +263,37 @@ lemma decay_bounds_cor_aux (ψ : CS 2 ℂ) : ∃ C : ℝ, ∀ u, ‖ψ u‖ ≤ + simp only [norm_mul, Complex.norm_real, norm_of_nonneg (one_add_sq_pos u).le] at hC + rwa [le_div_iff₀' (one_add_sq_pos _)] + +-lemma decay_bounds_cor (ψ : W21) : ++theorem decay_bounds_cor (ψ : W21) : + ∃ C : ℝ, ∀ u, ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by + simpa only [div_eq_mul_inv] using ⟨_, decay_bounds_key ψ⟩ + +-set_option backward.isDefEq.respectTransparency false in +-@[continuity, fun_prop] lemma continuous_FourierIntegral (ψ : W21) : Continuous (𝓕 (ψ : ℝ → ℂ)) := ++@[continuity, fun_prop] theorem continuous_FourierIntegral (ψ : W21) : Continuous (𝓕 (ψ : ℝ → ℂ)) := + VectorFourier.fourierIntegral_continuous continuous_fourierChar + (by simp only [innerₗ_apply_apply, RCLike.inner_apply', conj_trivial, continuous_mul]) + ψ.hf + +-lemma W21.integrable_fourier (ψ : W21) (hc : c ≠ 0) : ++theorem W21.integrable_fourier (ψ : W21) (hc : c ≠ 0) : + Integrable fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c) := by + have l1 (C) : Integrable (fun u ↦ C / (1 + (u / c) ^ 2)) volume := by +- simpa using! (integrable_inv_one_add_sq.comp_div hc).const_mul C ++ simpa only [div_eq_mul_inv] using (integrable_inv_one_add_sq.comp_div hc).const_mul C + have l2 : AEStronglyMeasurable (fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c)) volume := by + apply Continuous.aestronglyMeasurable ; fun_prop + obtain ⟨C, h⟩ := decay_bounds_cor ψ + apply @Integrable.mono' ℝ ℂ _ volume _ _ (fun u => C / (1 + (u / c) ^ 2)) (l1 C) l2 ?_ + apply Eventually.of_forall (fun x => h _) + +- +- +- +- +-lemma continuous_LSeries_aux (hf : Summable (nterm f σ')) : ++theorem continuous_LSeries_aux (hf : Summable (nterm f σ')) : + Continuous fun x : ℝ => LSeries f (σ' + x * I) := by +- + have l1 i : Continuous fun x : ℝ ↦ term f (σ' + x * I) i := by + by_cases h : i = 0 + · simpa [h] using continuous_const +- · simpa [h] using! continuous_const.div (continuous_const.cpow (by fun_prop) (by simp [h])) ++ · simpa [h] using continuous_const.div₀ (continuous_const.cpow (by fun_prop) (by simp [h])) + (fun x => by simp [h]) + have l2 n (x : ℝ) : ‖term f (σ' + x * I) n‖ = nterm f σ' n := by +- by_cases h : n = 0 +- · simp [h, nterm] +- · simp [h, nterm, cpow_add _ _ (Nat.cast_ne_zero.mpr h), +- Complex.norm_natCast_cpow_of_pos (Nat.pos_of_ne_zero h)] ++ simpa using norm_term_eq_nterm_re (f := f) (n := n) (σ' + x * I) + exact continuous_tsum l1 hf (fun n x => le_of_eq (l2 n x)) + +--- Here compact support is used but perhaps it is not necessary +-set_option backward.isDefEq.respectTransparency false in +-lemma limiting_fourier_aux (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++theorem limiting_fourier_aux (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) + (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) (σ' : ℝ) + (hσ' : 1 < σ') : + ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - +@@ -519,7 +320,6 @@ lemma limiting_fourier_aux (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1 + (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by + apply l7.integrable_of_hasCompactSupport + exact ψ.h2.mul_left.mul_right.mul_left.mul_left +- + simp_rw [l1 σ' hσ', l2 σ' hσ', ← integral_const_mul, ← integral_sub l4 l5] + apply integral_congr_ae + apply Eventually.of_forall +@@ -541,61 +341,60 @@ def cumsum [AddCommMonoid E] (u : ℕ → E) (n : ℕ) : E := ∑ i ∈ Finset.r + + def nabla [Sub E] (u : α → E) (n : α) : E := u (n + 1) - u n + +-/- `nnabla` is the backward difference `u n - u (n+1)`; kept alongside `nabla` +- for summation-by-parts identities that prefer that orientation. -/ + def nnabla [Sub E] (u : α → E) (n : α) : E := u n - u (n + 1) + + def shift (u : α → E) (n : α) : E := u (n + 1) + +-@[simp] lemma cumsum_zero [AddCommMonoid E] {u : ℕ → E} : cumsum u 0 = 0 := by simp [cumsum] ++@[simp] theorem cumsum_zero [AddCommMonoid E] {u : ℕ → E} : cumsum u 0 = 0 := by simp [cumsum] + +-lemma cumsum_succ [AddCommMonoid E] {u : ℕ → E} (n : ℕ) : ++theorem cumsum_succ [AddCommMonoid E] {u : ℕ → E} (n : ℕ) : + cumsum u (n + 1) = cumsum u n + u n := by + simp [cumsum, Finset.sum_range_succ] + +-@[simp] lemma nabla_cumsum [AddCommGroup E] {u : ℕ → E} : nabla (cumsum u) = u := by ++@[simp] theorem nabla_cumsum [AddCommGroup E] {u : ℕ → E} : nabla (cumsum u) = u := by + ext n ; simp [nabla, cumsum, Finset.range_add_one] + +-lemma neg_cumsum [AddCommGroup E] {u : ℕ → E} : -(cumsum u) = cumsum (-u) := ++theorem neg_cumsum [AddCommGroup E] {u : ℕ → E} : -(cumsum u) = cumsum (-u) := + funext (fun n => by simp [cumsum]) + +-lemma cumsum_nonneg {u : ℕ → ℝ} (hu : 0 ≤ u) : 0 ≤ cumsum u := ++theorem cumsum_nonneg {u : ℕ → ℝ} (hu : 0 ≤ u) : 0 ≤ cumsum u := + fun _ => Finset.sum_nonneg (fun i _ => hu i) + + omit [Sub α] in +-lemma neg_nabla [Ring E] {u : α → E} : -(nabla u) = nnabla u := by ext n ; simp [nabla, nnabla] ++theorem neg_nabla [Ring E] {u : α → E} : -(nabla u) = nnabla u := by ext n ; simp [nabla, nnabla] + + omit [Sub α] in +-@[simp] lemma nabla_mul [Ring E] {u : α → E} {c : E} : nabla (fun n => c * u n) = c • nabla u := by ++@[simp] theorem nabla_mul [Ring E] {u : α → E} {c : E} : ++ nabla (fun n => c * u n) = c • nabla u := by + ext n ; simp [nabla, mul_sub] + + omit [Sub α] in +-@[simp] lemma nnabla_mul [Ring E] {u : α → E} {c : E} : ++@[simp] theorem nnabla_mul [Ring E] {u : α → E} {c : E} : + nnabla (fun n => c * u n) = c • nnabla u := by + ext n ; simp [nnabla, mul_sub] + +-lemma nnabla_cast (u : ℝ → E) [Sub E] : nnabla u ∘ ((↑) : ℕ → ℝ) = nnabla (u ∘ (↑)) := by ++theorem nnabla_cast (u : ℝ → E) [Sub E] : nnabla u ∘ ((↑) : ℕ → ℝ) = nnabla (u ∘ (↑)) := by + ext n ; simp [nnabla] + + end nabla + +-lemma Finset.sum_shift_front {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++theorem Finset.sum_shift_front {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : + cumsum u (n + 1) = u 0 + cumsum (shift u) n := by + simp_rw [add_comm n, cumsum, sum_range_add, sum_range_one, add_comm 1] ; rfl + +-lemma Finset.sum_shift_front' {E : Type*} [Ring E] {u : ℕ → E} : ++theorem Finset.sum_shift_front' {E : Type*} [Ring E] {u : ℕ → E} : + shift (cumsum u) = (fun _ => u 0) + cumsum (shift u) := by + ext n ; apply Finset.sum_shift_front + +-lemma Finset.sum_shift_back {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++theorem Finset.sum_shift_back {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : + cumsum u (n + 1) = cumsum u n + u n := by + simp [cumsum, Finset.range_add_one, add_comm] + +-lemma Finset.sum_shift_back' {E : Type*} [Ring E] {u : ℕ → E} : ++theorem Finset.sum_shift_back' {E : Type*} [Ring E] {u : ℕ → E} : + shift (cumsum u) = cumsum u + u := by + ext n ; apply Finset.sum_shift_back + +-lemma summation_by_parts {E : Type*} [Ring E] {a A b : ℕ → E} (ha : a = nabla A) {n : ℕ} : ++theorem summation_by_parts {E : Type*} [Ring E] {a A b : ℕ → E} (ha : a = nabla A) {n : ℕ} : + cumsum (a * b) (n + 1) = A (n + 1) * b n - A 0 * b 0 - + cumsum (shift A * fun i => (b (i + 1) - b i)) n := by + have l1 : ∑ x ∈ Finset.range (n + 1), A (x + 1) * b x = ∑ x ∈ Finset.range n, +@@ -608,31 +407,33 @@ lemma summation_by_parts {E : Type*} [Ring E] {a A b : ℕ → E} (ha : a = nabl + mul_sub] + abel + +-lemma summation_by_parts' {E : Type*} [Ring E] {a b : ℕ → E} {n : ℕ} : ++theorem summation_by_parts' {E : Type*} [Ring E] {a b : ℕ → E} {n : ℕ} : + cumsum (a * b) (n + 1) = cumsum a (n + 1) * b n - cumsum (shift (cumsum a) * nabla b) n := by +- simpa using! summation_by_parts (a := a) (b := b) (A := cumsum a) (by simp) ++ change cumsum (a * b) (n + 1) = cumsum a (n + 1) * b n - ++ cumsum (shift (cumsum a) * (fun i : ℕ => b (i + 1) - b i)) n ++ simpa using summation_by_parts (a := a) (b := b) (A := cumsum a) (by simp) + +-lemma summation_by_parts'' {E : Type*} [Ring E] {a b : ℕ → E} : ++theorem summation_by_parts'' {E : Type*} [Ring E] {a b : ℕ → E} : + shift (cumsum (a * b)) = shift (cumsum a) * b - cumsum (shift (cumsum a) * nabla b) := by + ext n ; apply summation_by_parts' + +-lemma summable_iff_bounded {u : ℕ → ℝ} (hu : 0 ≤ u) : ++theorem summable_iff_bounded {u : ℕ → ℝ} (hu : 0 ≤ u) : + Summable u ↔ BoundedAtFilter atTop (cumsum u) := by + have l1 : (cumsum u =O[atTop] 1) ↔ _ := isBigO_one_nat_atTop_iff + have l2 n : ‖cumsum u n‖ = cumsum u n := by simpa using cumsum_nonneg hu n + simp only [BoundedAtFilter, l1, l2] +- constructor <;> intro ⟨C, h1⟩ ++ constructor <;> intro h <;> rcases h with ⟨C, h1⟩ + · exact ⟨C, fun n => sum_le_hasSum _ (fun i _ => hu i) h1⟩ + · exact summable_of_sum_range_le hu h1 + +-lemma Filter.EventuallyEq.summable {u v : ℕ → ℝ} (h : u =ᶠ[atTop] v) (hu : Summable v) : ++theorem Filter.EventuallyEq.summable {u v : ℕ → ℝ} (h : u =ᶠ[atTop] v) (hu : Summable v) : + Summable u := + summable_of_isBigO_nat hu h.isBigO + +-lemma summable_congr_ae {u v : ℕ → ℝ} (huv : u =ᶠ[atTop] v) : Summable u ↔ Summable v := by ++theorem summable_congr_ae {u v : ℕ → ℝ} (huv : u =ᶠ[atTop] v) : Summable u ↔ Summable v := by + constructor <;> intro h <;> simp [huv.summable, huv.symm.summable, h] + +-lemma BoundedAtFilter.add_const {u : ℕ → ℝ} {c : ℝ} : ++theorem BoundedAtFilter.add_const {u : ℕ → ℝ} {c : ℝ} : + BoundedAtFilter atTop (fun n => u n + c) ↔ BoundedAtFilter atTop u := by + have : u = fun n => (u n + c) + (-c) := by ext n ; ring + simp only [BoundedAtFilter] +@@ -640,17 +441,17 @@ lemma BoundedAtFilter.add_const {u : ℕ → ℝ} {c : ℝ} : + on_goal 1 => rw [this] + all_goals { exact h.add (const_boundedAtFilter _ _) } + +-lemma BoundedAtFilter.comp_add {u : ℕ → ℝ} {N : ℕ} : ++theorem BoundedAtFilter.comp_add {u : ℕ → ℝ} {N : ℕ} : + BoundedAtFilter atTop (fun n => u (n + N)) ↔ BoundedAtFilter atTop u := by +- simp only [BoundedAtFilter, isBigO_iff, norm_eq_abs, Pi.one_apply, +- eventually_atTop] +- constructor <;> intro ⟨C, n₀, h⟩ <;> use C ++ simp only [BoundedAtFilter, isBigO_iff, norm_eq_abs, Pi.one_apply, one_mem, ++ CStarRing.norm_of_mem_unitary, mul_one, eventually_atTop] ++ constructor <;> intro hbound <;> rcases hbound with ⟨C, n₀, h⟩ <;> use C + · refine ⟨n₀ + N, fun n hn => ?_⟩ + obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le' (m := N) (n := n) (by grind) + exact h _ <| Nat.add_le_add_iff_right.mp hn + · exact ⟨n₀, fun n hn => h _ (by grind)⟩ + +-lemma summable_iff_bounded' {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, 0 ≤ u n) : ++theorem summable_iff_bounded' {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, 0 ≤ u n) : + Summable u ↔ BoundedAtFilter atTop (cumsum u) := by + obtain ⟨N, hu⟩ := eventually_atTop.mp hu + have e2 : cumsum (fun i ↦ u (i + N)) = fun n => cumsum u (n + N) - cumsum u N := by +@@ -658,7 +459,7 @@ lemma summable_iff_bounded' {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, 0 ≤ u n + rw [← summable_nat_add_iff N, summable_iff_bounded (fun n => hu _ <| Nat.le_add_left N n), e2] + simp_rw [sub_eq_add_neg, BoundedAtFilter.add_const, BoundedAtFilter.comp_add] + +-lemma bounded_of_shift {u : ℕ → ℝ} (h : BoundedAtFilter atTop (shift u)) : ++theorem bounded_of_shift {u : ℕ → ℝ} (h : BoundedAtFilter atTop (shift u)) : + BoundedAtFilter atTop u := by + simp only [BoundedAtFilter, isBigO_iff, eventually_atTop] at h ⊢ + obtain ⟨C, N, hC⟩ := h +@@ -668,24 +469,26 @@ lemma bounded_of_shift {u : ℕ → ℝ} (h : BoundedAtFilter atTop (shift u)) : + have r2 : n - 1 + 1 = n := Nat.sub_add_cancel (by omega) + simpa [r2] using hC (n - 1) r1 + +-lemma dirichlet_test' {a b : ℕ → ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) ++theorem dirichlet_test' {a b : ℕ → ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) + (hAb : BoundedAtFilter atTop (shift (cumsum a) * b)) (hbb : ∀ᶠ n in atTop, b (n + 1) ≤ b n) + (h : Summable (shift (cumsum a) * nnabla b)) : Summable (a * b) := by + have l1 : ∀ᶠ n in atTop, 0 ≤ (shift (cumsum a) * nnabla b) n := by + filter_upwards [hbb] with n hb +- exact mul_nonneg (by simpa [shift] using! Finset.sum_nonneg (fun n _ ↦ ha n)) (sub_nonneg.mpr hb) ++ exact mul_nonneg (by simpa [shift] using cumsum_nonneg ha (n + 1)) (sub_nonneg.mpr hb) + rw [summable_iff_bounded (mul_nonneg ha hb)] + rw [summable_iff_bounded' l1] at h + apply bounded_of_shift + simpa only [summation_by_parts'', sub_eq_add_neg, neg_cumsum, ← mul_neg, neg_nabla] + using hAb.add h + +-lemma exists_antitone_of_eventually {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, u (n + 1) ≤ u n) : ++theorem exists_antitone_of_eventually {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, u (n + 1) ≤ u n) : + ∃ v : ℕ → ℝ, range v ⊆ range u ∧ Antitone v ∧ v =ᶠ[atTop] u := by + obtain ⟨N, hN⟩ := eventually_atTop.mp hu + let v (n : ℕ) := u (if n < N then N else n) + refine ⟨v, ?_, ?_, ?_⟩ +- · exact fun x ⟨n, hn⟩ => ⟨if n < N then N else n, hn⟩ ++ · intro x hx ++ rcases hx with ⟨n, hn⟩ ++ exact ⟨if n < N then N else n, hn⟩ + · refine antitone_nat_of_succ_le (fun n => ?_) + by_cases h : n < N + · by_cases h' : n + 1 < N <;> simp [v, h, h'] +@@ -696,7 +499,7 @@ lemma exists_antitone_of_eventually {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, u + · have : ∀ᶠ n in atTop, ¬(n < N) := by simpa using ⟨N, fun b hb => by linarith⟩ + filter_upwards [this] with n hn ; simp [v, hn] + +-lemma summable_inv_mul_log_sq : Summable (fun n : ℕ => (n * (Real.log n) ^ 2)⁻¹) := by ++theorem summable_inv_mul_log_sq : Summable (fun n : ℕ => (n * (Real.log n) ^ 2)⁻¹) := by + let u (n : ℕ) := (n * (Real.log n) ^ 2)⁻¹ + have l7 : ∀ᶠ n : ℕ in atTop, 1 ≤ Real.log n := + tendsto_atTop.mp (tendsto_log_atTop.comp tendsto_natCast_atTop_atTop) 1 +@@ -715,26 +518,26 @@ lemma summable_inv_mul_log_sq : Summable (fun n : ℕ => (n * (Real.log n) ^ 2) + simp only [l5, mul_inv_rev, Nat.cast_pow, Nat.cast_ofNat, log_pow, u] + field_simp + +-lemma tendsto_mul_add_atTop {a : ℝ} (ha : 0 < a) (b : ℝ) : ++theorem tendsto_mul_add_atTop {a : ℝ} (ha : 0 < a) (b : ℝ) : + Tendsto (fun x => a * x + b) atTop atTop := + tendsto_atTop_add_const_right _ b (tendsto_id.const_mul_atTop ha) + +-lemma isLittleO_const_of_tendsto_atTop {α : Type*} [Preorder α] (a : ℝ) {f : α → ℝ} ++theorem isLittleO_const_of_tendsto_atTop {α : Type*} [Preorder α] (a : ℝ) {f : α → ℝ} + (hf : Tendsto f atTop atTop) : (fun _ => a) =o[atTop] f := by + simp [tendsto_norm_atTop_atTop.comp hf] + +-lemma isBigO_pow_pow_of_le {m n : ℕ} (h : m ≤ n) : ++theorem isBigO_pow_pow_of_le {m n : ℕ} (h : m ≤ n) : + (fun x : ℝ => x ^ m) =O[atTop] (fun x : ℝ => x ^ n) := by + apply IsBigO.of_bound 1 + filter_upwards [eventually_ge_atTop 1] with x l1 + simpa [abs_eq_self.mpr (zero_le_one.trans l1)] using pow_le_pow_right₀ l1 h + +-lemma isLittleO_mul_add_sq (a b : ℝ) : (fun x => a * x + b) =o[atTop] (fun x => x ^ 2) := by ++theorem isLittleO_mul_add_sq (a b : ℝ) : (fun x => a * x + b) =o[atTop] (fun x => x ^ 2) := by + apply IsLittleO.add + · apply IsLittleO.const_mul_left ; simpa using isLittleO_pow_pow_atTop_of_lt (𝕜 := ℝ) one_lt_two + · apply isLittleO_const_of_tendsto_atTop _ <| tendsto_pow_atTop (by linarith) + +-lemma log_mul_add_isBigO_log {a : ℝ} (ha : 0 < a) (b : ℝ) : ++theorem log_mul_add_isBigO_log {a : ℝ} (ha : 0 < a) (b : ℝ) : + (fun x => Real.log (a * x + b)) =O[atTop] Real.log := by + apply IsBigO.of_bound (2 : ℕ) + have l2 : ∀ᶠ x : ℝ in atTop, 0 ≤ log x := tendsto_atTop.mp tendsto_log_atTop 0 +@@ -748,21 +551,22 @@ lemma log_mul_add_isBigO_log {a : ℝ} (ha : 0 < a) (b : ℝ) : + simpa [abs_eq_self.mpr l2, abs_eq_self.mpr l3, Real.log_pow] using + Real.log_le_log (by linarith) l1 + +-lemma isBigO_log_mul_add {a : ℝ} (ha : 0 < a) (b : ℝ) : ++theorem isBigO_log_mul_add {a : ℝ} (ha : 0 < a) (b : ℝ) : + Real.log =O[atTop] (fun x => Real.log (a * x + b)) := by +- convert! (log_mul_add_isBigO_log (b := -b / a) (inv_pos.mpr ha)).comp_tendsto ++ convert (log_mul_add_isBigO_log (b := -b / a) (inv_pos.mpr ha)).comp_tendsto + (tendsto_mul_add_atTop (b := b) ha) using 1 +- ext x +- simp only [Function.comp_apply] +- congr +- field_simp +- simp ++ · ext x ++ simp only [Function.comp_apply] ++ congr ++ field_simp ++ simp ++ · rfl + +-lemma log_isbigo_log_div {d : ℝ} (hb : 0 < d) : ++theorem log_isbigo_log_div {d : ℝ} (hb : 0 < d) : + (fun n ↦ Real.log n) =O[atTop] (fun n ↦ Real.log (n / d)) := by + convert isBigO_log_mul_add (inv_pos.mpr hb) 0 using 1; simp only [add_zero]; field_simp + +-lemma Asymptotics.IsBigO.add_isLittleO_right {f g : ℝ → ℝ} (h : g =o[atTop] f) : ++theorem Asymptotics.IsBigO.add_isLittleO_right {f g : ℝ → ℝ} (h : g =o[atTop] f) : + f =O[atTop] (f + g) := by + rw [isLittleO_iff] at h ; specialize h (c := 2⁻¹) (by norm_num) + rw [isBigO_iff''] +@@ -774,11 +578,11 @@ lemma Asymptotics.IsBigO.add_isLittleO_right {f g : ℝ → ℝ} (h : g =o[atTop + _ ≤ |(|f x| - |g x|)| := le_abs_self _ + _ ≤ _ := by rw [← sub_neg_eq_add, ← abs_neg (g x)] ; exact abs_abs_sub_abs_le (f x) (-g x) + +-lemma Asymptotics.IsBigO.sq {α : Type*} [Preorder α] {f g : α → ℝ} (h : f =O[atTop] g) : +- (fun n ↦ f n ^ 2) =O[atTop] (fun n => g n ^ 2) := by +- simpa [pow_two] using h.mul h ++theorem Asymptotics.IsBigO.sq {α : Type*} [Preorder α] {f g : α → ℝ} (h : f =O[atTop] g) : ++ (fun n ↦ f n ^ 2) =O[atTop] (fun n => g n ^ 2) := ++ h.pow 2 + +-lemma log_sq_isbigo_mul {a b : ℝ} (hb : 0 < b) : ++theorem log_sq_isbigo_mul {a b : ℝ} (hb : 0 < b) : + (fun x ↦ Real.log x ^ 2) =O[atTop] (fun x ↦ a + Real.log (x / b) ^ 2) := by + apply (log_isbigo_log_div hb).sq.trans ; simp_rw [add_comm a] + refine IsBigO.add_isLittleO_right <| isLittleO_const_of_tendsto_atTop _ ?_ +@@ -789,9 +593,13 @@ theorem log_add_div_isBigO_log (a : ℝ) {b : ℝ} (hb : 0 < b) : + (fun x ↦ Real.log ((x + a) / b)) =O[atTop] fun x ↦ Real.log x := by + convert log_mul_add_isBigO_log (inv_pos.mpr hb) (a / b) using 3 ; ring + +-lemma log_add_one_sub_log_le {x : ℝ} (hx : 0 < x) : nabla Real.log x ≤ x⁻¹ := by ++theorem log_add_one_sub_log_le {x : ℝ} (hx : 0 < x) : nabla Real.log x ≤ x⁻¹ := by + have l1 : ContinuousOn Real.log (Icc x (x + 1)) := by +- apply continuousOn_log.mono ; intro t ⟨h1, _⟩ ; simp ; linarith ++ apply continuousOn_log.mono ++ intro t ht ++ have h1 := ht.1 ++ simp ++ linarith + have l2 t (ht : t ∈ Ioo x (x + 1)) : HasDerivAt Real.log t⁻¹ t := + Real.hasDerivAt_log (by linarith [ht.1]) + obtain ⟨t, ⟨ht1, _⟩, htx⟩ := exists_hasDerivAt_eq_slope Real.log (·⁻¹) (by linarith) l1 l2 +@@ -799,22 +607,21 @@ lemma log_add_one_sub_log_le {x : ℝ} (hx : 0 < x) : nabla Real.log x ≤ x⁻ + rw [nabla, ← htx, inv_le_inv₀ (by linarith) hx] + exact ht1.le + +-lemma nabla_log_main : nabla Real.log =O[atTop] fun x ↦ 1 / x := by ++theorem nabla_log_main : nabla Real.log =O[atTop] fun x ↦ 1 / x := by + apply IsBigO.of_bound 1 + filter_upwards [eventually_gt_atTop 0] with x l1 + have l2 : log x ≤ log (x + 1) := log_le_log l1 (by linarith) + simpa [nabla, abs_eq_self.mpr l1.le, abs_eq_self.mpr (sub_nonneg.mpr l2)] using + log_add_one_sub_log_le l1 + +-lemma nabla_log {b : ℝ} (hb : 0 < b) : ++theorem nabla_log {b : ℝ} (hb : 0 < b) : + nabla (fun x => Real.log (x / b)) =O[atTop] (fun x => 1 / x) := by + refine EventuallyEq.trans_isBigO ?_ nabla_log_main + filter_upwards [eventually_gt_atTop 0] with x l2 + rw [nabla, log_div (by linarith) (by linarith), log_div l2.ne.symm (by linarith), nabla] ; ring + +-lemma nnabla_mul_log_sq (a : ℝ) {b : ℝ} (hb : 0 < b) : ++theorem nnabla_mul_log_sq (a : ℝ) {b : ℝ} (hb : 0 < b) : + nabla (fun x => x * (a + Real.log (x / b) ^ 2)) =O[atTop] (fun x => Real.log x ^ 2) := by +- + have l1 : nabla (fun n => n * (a + Real.log (n / b) ^ 2)) = fun n => + a + Real.log ((n + 1) / b) ^ 2 + + (n * (Real.log ((n + 1) / b) ^ 2 - Real.log (n / b) ^ 2)) := by +@@ -828,25 +635,24 @@ lemma nnabla_mul_log_sq (a : ℝ) {b : ℝ} (hb : 0 < b) : + filter_upwards [eventually_ge_atTop 1] with x hx using by field_simp + have l5 : (fun n ↦ n * (Real.log n * (1 / n))) =O[atTop] (fun n ↦ (Real.log n) ^ 2) := + e2.trans_isBigO +- (by simpa using! (isLittleO_mul_add_sq 1 0).isBigO.comp_tendsto Real.tendsto_log_atTop) +- ++ (by simpa [Function.comp_def] using ++ (isLittleO_mul_add_sq 1 0).isBigO.comp_tendsto Real.tendsto_log_atTop) + simp_rw [l1, _root_.sq_sub_sq] + exact ((l2.add l3).add (isBigO_refl (·) atTop |>.mul (l4.mul (nabla_log hb)) |>.trans l5)) + +-lemma nnabla_bound_aux1 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++theorem nnabla_bound_aux1 (a : ℝ) {b : ℝ} (hb : 0 < b) : + Tendsto (fun x => x * (a + Real.log (x / b) ^ 2)) atTop atTop := + tendsto_id.atTop_mul_atTop₀ <| tendsto_atTop_add_const_left _ _ <| + (tendsto_pow_atTop two_ne_zero).comp <| tendsto_log_atTop.comp <| tendsto_id.atTop_div_const hb + +-lemma nnabla_bound_aux2 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++theorem nnabla_bound_aux2 (a : ℝ) {b : ℝ} (hb : 0 < b) : + ∀ᶠ x in atTop, 0 < x * (a + Real.log (x / b) ^ 2) := + (nnabla_bound_aux1 a hb).eventually (eventually_gt_atTop 0) + +-lemma Real.log_eventually_gt_atTop (a : ℝ) : ++theorem Real.log_eventually_gt_atTop (a : ℝ) : + ∀ᶠ x in atTop, a < Real.log x := + Real.tendsto_log_atTop.eventually (eventually_gt_atTop a) + +-/-- Should this be a gcongr lemma? -/ + @[local gcongr] + theorem norm_lt_norm_of_nonneg (x y : ℝ) (hx : 0 ≤ x) (hxy : x ≤ y) : + ‖x‖ ≤ ‖y‖ := by +@@ -854,13 +660,11 @@ theorem norm_lt_norm_of_nonneg (x y : ℝ) (hx : 0 ≤ x) (hxy : x ≤ y) : + apply abs_le_abs hxy + linarith + +-lemma nnabla_bound_aux {x : ℝ} (hx : 0 < x) : ++theorem nnabla_bound_aux {x : ℝ} (hx : 0 < x) : + nnabla (fun n ↦ 1 / (n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2))) =O[atTop] + (fun n ↦ 1 / (Real.log n ^ 2 * n ^ 2)) := by +- + let d n : ℝ := n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2) + change (fun x_1 ↦ nnabla (fun n ↦ 1 / d n) x_1) =O[atTop] _ +- + have l2 : ∀ᶠ n in atTop, 0 < d n := (nnabla_bound_aux2 ((2 * π) ^ 2) hx) + have l3 : ∀ᶠ n in atTop, 0 < d (n + 1) := + (tendsto_atTop_add_const_right atTop (1 : ℝ) tendsto_id).eventually l2 +@@ -869,7 +673,6 @@ lemma nnabla_bound_aux {x : ℝ} (hx : 0 < x) : + filter_upwards [l2, l3] with n l2 l3 + rw [nnabla, one_div, one_div, inv_sub_inv l2.ne.symm l3.ne.symm, div_eq_mul_inv, mul_inv, + mul_assoc] +- + have l4 : (fun n => (d n)⁻¹) =O[atTop] (fun n => (n * (Real.log n) ^ 2)⁻¹) := by + apply IsBigO.inv_rev + · refine (isBigO_refl _ _).mul <| (log_sq_isbigo_mul hx) +@@ -889,17 +692,16 @@ lemma nnabla_bound_aux {x : ℝ} (hx : 0 < x) : + filter_upwards [l2, l3, e3] with n e1 e2 e3 + simp_rw [one_mul] + gcongr +- + have l6 : (fun n => d (n + 1) - d n) =O[atTop] (fun n => (Real.log n) ^ 2) := by +- simpa [d, nabla] using! (nnabla_mul_log_sq ((2 * π) ^ 2) hx) +- ++ change nabla (fun n : ℝ => n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2)) ++ =O[atTop] (fun n => (Real.log n) ^ 2) ++ exact nnabla_mul_log_sq ((2 * π) ^ 2) hx + apply EventuallyEq.trans_isBigO l1 +- + apply ((l6.mul l4).mul l5).trans_eventuallyEq + filter_upwards [eventually_ge_atTop 2, Real.log_eventually_gt_atTop 0] with n hn hn' + field_simp + +-lemma nnabla_bound (C : ℝ) {x : ℝ} (hx : 0 < x) : ++theorem nnabla_bound (C : ℝ) {x : ℝ} (hx : 0 < x) : + nnabla (fun n => C / (1 + (Real.log (n / x) / (2 * π)) ^ 2) / n) =O[atTop] + (fun n => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by + field_simp +@@ -907,11 +709,8 @@ lemma nnabla_bound (C : ℝ) {x : ℝ} (hx : 0 < x) : + apply IsBigO.const_mul_left + simpa [div_eq_mul_inv, mul_pow, mul_comm] using nnabla_bound_aux hx + +-def chebyWith (C : ℝ) (f : ℕ → ℂ) : Prop := ∀ n, cumsum (‖f ·‖) n ≤ C * n +- +-def cheby (f : ℕ → ℂ) : Prop := ∃ C, chebyWith C f +- +-lemma cheby.bigO (h : cheby f) : cumsum (‖f ·‖) =O[atTop] ((↑) : ℕ → ℝ) := by ++theorem cheby.bigO (h : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ cumsum (‖f ·‖) =O[atTop] ((↑) : ℕ → ℝ) := by + have l1 : 0 ≤ cumsum (‖f ·‖) := cumsum_nonneg (fun _ => norm_nonneg _) + obtain ⟨C, hC⟩ := h + apply isBigO_of_le' (c := C) atTop +@@ -919,12 +718,12 @@ lemma cheby.bigO (h : cheby f) : cumsum (‖f ·‖) =O[atTop] ((↑) : ℕ → + rw [Real.norm_eq_abs, abs_eq_self.mpr (l1 n)] + simpa using hC n + +-lemma limiting_fourier_lim1_aux (hcheby : cheby f) (hx : 0 < x) (C : ℝ) (hC : 0 ≤ C) : ++theorem limiting_fourier_lim1_aux ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hx : 0 < x) (C : ℝ) (hC : 0 ≤ C) : + Summable fun n ↦ ‖f n‖ / ↑n * (C / (1 + (1 / (2 * π) * Real.log (↑n / x)) ^ 2)) := by +- + let a (n : ℕ) := (C / (1 + (Real.log (↑n / x) / (2 * π)) ^ 2) / ↑n) +- replace hcheby := hcheby.bigO +- ++ replace hcheby := cheby.bigO hcheby + have l1 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n : ℕ => (↑(n + 1) : ℝ)) := + hcheby.comp_tendsto <| tendsto_add_atTop_nat 1 + have l2 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n => (n : ℝ)) := +@@ -943,10 +742,13 @@ lemma limiting_fourier_lim1_aux (hcheby : cheby f) (hx : 0 < x) (C : ℝ) (hC : + apply le_add_of_le_of_nonneg le_rfl + positivity + have l3 : a =O[atTop] (fun n => 1 / (n : ℝ)) := by +- simpa [a] using! IsBigO.mul l5 (isBigO_refl (fun n : ℕ => 1 / (n : ℝ)) _) ++ convert IsBigO.mul l5 (isBigO_refl (fun n : ℕ => 1 / (n : ℝ)) _) using 1 ++ · ext n ++ simp [a, div_eq_mul_inv] ++ · ext n ++ simp + have l4 : nnabla a =O[atTop] (fun n : ℕ => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by +- convert (nnabla_bound C hx).natCast ; simp [nnabla, a] +- ++ convert (nnabla_bound C hx).natCast_atTop ; simp [nnabla, a] + simp_rw [div_mul_eq_mul_div, mul_div_assoc, one_mul] + apply dirichlet_test' + · intro n ; exact norm_nonneg _ +@@ -974,11 +776,12 @@ lemma limiting_fourier_lim1_aux (hcheby : cheby f) (hx : 0 < x) (C : ℝ) (hC : + grind + field_simp + +-theorem limiting_fourier_lim1 (hcheby : cheby f) (ψ : W21) (hx : 0 < x) : ++theorem limiting_fourier_lim1 ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (ψ : W21) (hx : 0 < x) : + Tendsto (fun σ' : ℝ ↦ + ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x))) (𝓝[>] 1) + (𝓝 (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x)))) := by +- + obtain ⟨C, hC⟩ := decay_bounds_cor ψ + have : 0 ≤ C := by simpa using (norm_nonneg _).trans (hC 0) + refine tendsto_tsum_of_dominated_convergence +@@ -994,7 +797,7 @@ theorem limiting_fourier_lim1 (hcheby : cheby f) (ψ : W21) (hx : 0 < x) : + rw [norm_mul, ← nterm_eq_norm_term] + refine mul_le_mul ?_ (hC _) (norm_nonneg _) (div_nonneg (norm_nonneg _) (Nat.cast_nonneg _)) + by_cases h : n = 0 <;> simp only [nterm, h, ↓reduceIte, CharP.cast_eq_zero, div_zero, le_refl] +- have : 1 ≤ (n : ℝ) := by simpa using! Nat.pos_iff_ne_zero.mpr h ++ have : 1 ≤ (n : ℝ) := by exact_mod_cast (show 1 ≤ n by omega) + refine div_le_div₀ (norm_nonneg _) le_rfl (by simpa [Nat.pos_iff_ne_zero]) ?_ + simpa using Real.rpow_le_rpow_of_exponent_le this hσ'.le + +@@ -1009,7 +812,6 @@ theorem limiting_fourier_lim2 (A : ℝ) (ψ : W21) (hx : 1 ≤ x) : + Tendsto (fun σ' ↦ A * ↑(x ^ (1 - σ')) * + ∫ u in Ici (-Real.log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) + (𝓝[>] 1) (𝓝 (A * ∫ u in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)))) := by +- + obtain ⟨C, hC⟩ := decay_bounds_cor ψ + apply Tendsto.mul + · suffices h : Tendsto (fun σ' : ℝ ↦ ofReal (x ^ (1 - σ'))) (𝓝[>] 1) (𝓝 1) by +@@ -1028,7 +830,9 @@ theorem limiting_fourier_lim2 (A : ℝ) (ψ : W21) (hx : 1 ≤ x) : + continuity + · apply eventually_of_mem (U := Ioo 1 2) + · apply Ioo_mem_nhdsGT_of_mem ; simp +- · intro σ' ⟨h1, h2⟩ ++ · intro σ' hσ ++ have h1 := hσ.1 ++ have h2 := hσ.2 + rw [ae_restrict_iff' measurableSet_Ici] + apply Eventually.of_forall + intro t (ht : - Real.log x ≤ t) +@@ -1063,11 +867,9 @@ theorem limiting_fourier_lim2 (A : ℝ) (ψ : W21) (hx : 1 ≤ x) : + theorem limiting_fourier_lim3 (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : + Tendsto (fun σ' : ℝ ↦ ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I)) (𝓝[>] 1) + (𝓝 (∫ t : ℝ, G (1 + t * I) * ψ t * x ^ (t * I))) := by +- + by_cases hh : tsupport ψ = ∅ + · simp [tsupport_eq_empty_iff.mp hh] + obtain ⟨a₀, ha₀⟩ := Set.nonempty_iff_ne_empty.mpr hh +- + let S : Set ℂ := reProdIm (Icc 1 2) (tsupport ψ) + have l1 : IsCompact S := by + refine Metric.isCompact_iff_isClosed_bounded.mpr ⟨?_, ?_⟩ +@@ -1079,7 +881,6 @@ theorem limiting_fourier_lim3 (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 + obtain ⟨z, -, hmax⟩ := l1.exists_isMaxOn l4 l3 + let MG := ‖G z‖ + let bound (a : ℝ) : ℝ := MG * ‖ψ a‖ +- + apply tendsto_integral_filter_of_dominated_convergence (bound := bound) + · apply eventually_of_mem (U := Icc 1 2) (Icc_mem_nhdsGT_of_mem (by simp)) ; intro u hu + apply Continuous.aestronglyMeasurable +@@ -1099,7 +900,6 @@ theorem limiting_fourier_lim3 (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 + exact mul_le_mul_of_nonneg_right r2 (norm_nonneg _) + · have : v ∉ Function.support ψ := fun a ↦ h (subset_tsupport ψ a) + simp at this ; simp [this, bound] +- + · suffices h : Continuous bound by exact h.integrable_of_hasCompactSupport ψ.h2.norm.mul_left + have := ψ.h1.continuous ; fun_prop + · apply Eventually.of_forall ; intro t +@@ -1109,125 +909,70 @@ theorem limiting_fourier_lim3 (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 + · exact ((continuous_ofReal.tendsto _).add tendsto_const_nhds).mono_left nhdsWithin_le_nhds + · exact eventually_nhdsWithin_of_forall (fun x (hx : 1 < x) => by simp [hx.le]) + +-@[blueprint +- "limiting" +- (title := "Limiting Fourier identity") +- (statement := /-- +- If $\psi: \R \to \C$ is $C^2$ and compactly supported and $x \geq 1$, then +- $$ \sum_{n=1}^\infty \frac{f(n)}{n} \hat \psi( \frac{1}{2\pi} \log \frac{n}{x} ) +- - A \int_{-\log x}^\infty \hat \psi(\frac{u}{2\pi})\ du +- = \int_\R G(1+it) \psi(t) x^{it}\ dt.$$ +- -/) +- (proof := /-- +- By Lemma \ref{first-fourier} and Lemma \ref{second-fourier}, we know that for any $\sigma>1$, +- we have +- $$ \sum_{n=1}^\infty \frac{f(n)}{n^\sigma} \hat \psi( \frac{1}{2\pi} \log \frac{n}{x} ) +- - A x^{1-\sigma} \int_{-\log x}^\infty e^{-u(\sigma-1)} \hat \psi(\frac{u}{2\pi})\ du +- = \int_\R G(\sigma+it) \psi(t) x^{it}\ dt.$$ +- Now take limits as $\sigma \to 1$ using dominated convergence together with \eqref{cheby} +- and Lemma \ref{decay} to obtain the result. +- -/) +- (latexEnv := "lemma")] +-lemma limiting_fourier (hcheby : cheby f) ++theorem limiting_fourier (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) + (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) + (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : + ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - + A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = + ∫ (t : ℝ), (G (1 + t * I)) * (ψ t) * x ^ (t * I) := by +- + have l1 := limiting_fourier_lim1 hcheby ψ (by linarith) + have l2 := limiting_fourier_lim2 A ψ hx + have l3 := limiting_fourier_lim3 hG ψ hx + apply tendsto_nhds_unique_of_eventuallyEq (l1.sub l2) l3 +- simpa [eventuallyEq_nhdsWithin_iff] using! Eventually.of_forall (limiting_fourier_aux hG' hf ψ hx) +- +- +- +- +-set_option backward.isDefEq.respectTransparency false in +-lemma limiting_cor_aux {f : ℝ → ℂ} : Tendsto (fun x : ℝ ↦ ∫ t, f t * x ^ (t * I)) atTop (𝓝 0) := by ++ simpa [eventuallyEq_nhdsWithin_iff, W21.ofCS2] using ++ Eventually.of_forall (limiting_fourier_aux hG' hf ψ hx) + ++theorem limiting_cor_aux {f : ℝ → ℂ} : ++ Tendsto (fun x : ℝ ↦ ∫ t, f t * x ^ (t * I)) atTop (𝓝 0) := by + have l1 : ∀ᶠ x : ℝ in atTop, ∀ t : ℝ, x ^ (t * I) = exp (log x * t * I) := by + filter_upwards [eventually_ne_atTop 0, eventually_ge_atTop 0] with x hx hx' t + rw [Complex.cpow_def_of_ne_zero (ofReal_ne_zero.mpr hx), ofReal_log hx'] ; ring_nf +- + have l2 : ∀ᶠ x : ℝ in atTop, ∫ t, f t * x ^ (t * I) = ∫ t, f t * exp (log x * t * I) := by + filter_upwards [l1] with x hx + refine integral_congr_ae (Eventually.of_forall (fun x => by simp [hx])) +- + simp_rw [tendsto_congr' l2] + convert_to Tendsto (fun x => 𝓕 f (-Real.log x / (2 * π))) atTop (𝓝 0) +- · ext ; congr ; ext +- simp only [← ofReal_mul, mul_comm (f _), fourierChar, Circle.exp, ContinuousMap.coe_mk, +- innerₗ_apply_apply, RCLike.inner_apply, conj_trivial, AddChar.coe_mk, mul_neg, ofReal_neg, +- neg_mul] +- congr +- rw [← neg_mul] ; congr ; norm_cast ; field_simp ++ · funext x ++ rw [Real.fourier_real_eq_integral_exp_smul] ++ apply integral_congr_ae ++ filter_upwards [] with t ++ have hphase : -2 * π * t * (-Real.log x / (2 * π)) = Real.log x * t := by ++ field_simp ++ rw [hphase, ofReal_mul, smul_eq_mul] ++ exact mul_comm _ _ + refine (Real.zero_at_infty_fourier f).comp <| Tendsto.mono_right ?_ _root_.atBot_le_cocompact + exact (tendsto_neg_atBot_iff.mpr tendsto_log_atTop).atBot_mul_const (inv_pos.mpr two_pi_pos) + +-@[blueprint +- "limiting-cor" +- (title := "Corollary of limiting identity") +- (statement := /-- +- With the hypotheses as above, we have +- $$ \sum_{n=1}^\infty \frac{f(n)}{n} \hat \psi( \frac{1}{2\pi} \log \frac{n}{x} ) +- = A \int_{-\infty}^\infty \hat \psi(\frac{u}{2\pi})\ du + o(1)$$ +- as $x \to \infty$. +- -/) +- (proof := /-- +- Immediate from the Riemann-Lebesgue lemma, and also noting that +- $\int_{-\infty}^{-\log x} \hat \psi(\frac{u}{2\pi})\ du = o(1)$. +- -/) +- (latexEnv := "corollary")] +-lemma limiting_cor (ψ : CS 2 ℂ) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hcheby : cheby f) ++theorem limiting_cor (ψ : CS 2 ℂ) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) + (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : + Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - + A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by +- + apply limiting_cor_aux.congr' + filter_upwards [eventually_ge_atTop 1] with x hx using + limiting_fourier hcheby hG hG' hf ψ hx |>.symm + +- +- +- +- +-@[blueprint +- "smooth-ury" +- (title := "Smooth Urysohn lemma") +- (statement := /-- +- If $I$ is a closed interval contained in an open interval $J$, then there exists a smooth +- function $\Psi: \R \to \R$ with $1_I \leq \Psi \leq 1_J$. +- -/) +- (proof := /-- +- A standard analysis lemma, which can be proven by convolving $1_K$ with a smooth approximation +- to the identity for some interval $K$ between $I$ and $J$. Note that we have +- ``SmoothBumpFunction''s on smooth manifolds in Mathlib, so this shouldn't be too hard... +- -/) +- (latexEnv := "lemma")] +-lemma smooth_urysohn (a b c d : ℝ) (h1 : a < b) (h3 : c < d) : ∃ Ψ : ℝ → ℝ, ++theorem smooth_urysohn (a b c d : ℝ) (h1 : a < b) (h3 : c < d) : ∃ Ψ : ℝ → ℝ, + (ContDiff ℝ ∞ Ψ) ∧ (HasCompactSupport Ψ) ∧ + Set.indicator (Set.Icc b c) 1 ≤ Ψ ∧ Ψ ≤ Set.indicator (Set.Ioo a d) 1 := by +- + obtain ⟨ψ, l1, l2, l3, l4, -⟩ := smooth_urysohn_support_Ioo h1 h3 + refine ⟨ψ, l1, l2, l3, l4⟩ + +- +- + noncomputable def exists_trunc : trunc := by + choose ψ h1 h2 h3 h4 using smooth_urysohn (-2) (-1) (1) (2) (by linarith) (by linarith) + exact ⟨⟨ψ, h1.of_le (by norm_cast), h2⟩, h3, h4⟩ + +-lemma one_div_sub_one (n : ℕ) : 1 / (↑(n - 1) : ℝ) ≤ 2 / n := by +- match n with +- | 0 => simp +- | 1 => simp +- | n + 2 => { norm_cast ; rw [div_le_div_iff₀] <;> simp [mul_add] <;> linarith } ++theorem one_div_sub_one (n : ℕ) : 1 / (↑(n - 1) : ℝ) ≤ 2 / n := by ++ cases n with ++ | zero => simp ++ | succ n => ++ cases n with ++ | zero => simp ++ | succ n => norm_cast ; rw [div_le_div_iff₀] <;> simp [mul_add] <;> linarith + +-lemma quadratic_pos (a b c x : ℝ) (ha : 0 < a) (hΔ : discrim a b c < 0) : ++theorem quadratic_pos (a b c x : ℝ) (ha : 0 < a) (hΔ : discrim a b c < 0) : + 0 < a * x ^ 2 + b * x + c := by + have l1 : a * x ^ 2 + b * x + c = a * (x + b / (2 * a)) ^ 2 - discrim a b c / (4 * a) := by + simp only [discrim]; field_simp; ring +@@ -1238,66 +983,71 @@ noncomputable def pp (a x : ℝ) : ℝ := a ^ 2 * (x + 1) ^ 2 + (1 - a) * (1 + a + + noncomputable def pp' (a x : ℝ) : ℝ := a ^ 2 * (2 * (x + 1)) + +-lemma pp_pos {a : ℝ} (ha : a ∈ Ioo (-1) 1) (x : ℝ) : 0 < pp a x := by ++theorem pp_pos {a : ℝ} (ha : a ∈ Ioo (-1) 1) (x : ℝ) : 0 < pp a x := by + simp only [pp] + have : 0 < 1 - a := by linarith [ha.2] + have : 0 < 1 + a := by linarith [ha.1] + positivity + +-lemma pp_deriv (a x : ℝ) : HasDerivAt (pp a) (pp' a x) x := by ++theorem pp_deriv (a x : ℝ) : HasDerivAt (pp a) (pp' a x) x := by + unfold pp pp' + simpa using hasDerivAt_id x |>.add_const 1 |>.pow 2 |>.const_mul _ + +-lemma pp_deriv_eq (a : ℝ) : deriv (pp a) = pp' a := by ++theorem pp_deriv_eq (a : ℝ) : deriv (pp a) = pp' a := by + ext x ; exact pp_deriv a x |>.deriv + +-lemma pp'_deriv (a x : ℝ) : HasDerivAt (pp' a) (a ^ 2 * 2) x := by +- simpa using! hasDerivAt_id x |>.add_const 1 |>.const_mul 2 |>.const_mul (a ^ 2) ++theorem pp'_deriv (a x : ℝ) : HasDerivAt (pp' a) (a ^ 2 * 2) x := by ++ change HasDerivAt (fun y : ℝ => a ^ 2 * (2 * (y + 1))) (a ^ 2 * 2) x ++ convert hasDerivAt_id x |>.add_const 1 |>.const_mul 2 |>.const_mul (a ^ 2) ++ using 1 <;> first | rfl | ring + +-lemma pp'_deriv_eq (a : ℝ) : deriv (pp' a) = fun _ => a ^ 2 * 2 := by ++theorem pp'_deriv_eq (a : ℝ) : deriv (pp' a) = fun _ => a ^ 2 * 2 := by + ext x ; exact pp'_deriv a x |>.deriv + + noncomputable def hh (a t : ℝ) : ℝ := (t * (1 + (a * log t) ^ 2))⁻¹ + + noncomputable def hh' (a t : ℝ) : ℝ := - pp a (log t) * hh a t ^ 2 + +-lemma hh_nonneg (a : ℝ) {t : ℝ} (ht : 0 ≤ t) : 0 ≤ hh a t := by dsimp only [hh] ; positivity ++theorem hh_nonneg (a : ℝ) {t : ℝ} (ht : 0 ≤ t) : 0 ≤ hh a t := by dsimp only [hh] ; positivity + +-lemma hh_le (a t : ℝ) (ht : 0 ≤ t) : |hh a t| ≤ t⁻¹ := by ++theorem hh_le (a t : ℝ) (ht : 0 ≤ t) : |hh a t| ≤ t⁻¹ := by + by_cases h0 : t = 0 + · simp [hh, h0] + replace ht : 0 < t := lt_of_le_of_ne ht (by tauto) + unfold hh + rw [abs_inv, inv_le_inv₀ (by positivity) ht, abs_mul, abs_eq_self.mpr ht.le] +- convert_to! t * 1 ≤ _ ++ convert_to t * 1 ≤ _ + · simp + apply mul_le_mul le_rfl ?_ zero_le_one ht.le + rw [abs_eq_self.mpr (by positivity)] + simp only [le_add_iff_nonneg_right] + positivity + +-lemma hh_deriv (a : ℝ) {t : ℝ} (ht : t ≠ 0) : HasDerivAt (hh a) (hh' a t) t := by ++theorem hh_deriv (a : ℝ) {t : ℝ} (ht : t ≠ 0) : HasDerivAt (hh a) (hh' a t) t := by + have e1 : t * (1 + (a * log t) ^ 2) ≠ 0 := mul_ne_zero ht (_root_.ne_of_lt (by positivity)).symm + have l5 : HasDerivAt (fun t : ℝ => log t) t⁻¹ t := Real.hasDerivAt_log ht + have l4 : HasDerivAt (fun t : ℝ => a * log t) (a * t⁻¹) t := l5.const_mul _ + have l3 : HasDerivAt (fun t : ℝ => (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := by +- convert! l4.pow 2 using 1 ; ring ++ convert l4.pow 2 using 1 ; ring + have l2 : HasDerivAt (fun t : ℝ => 1 + (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := + l3.const_add _ + have l1 : HasDerivAt (fun t : ℝ => t * (1 + (a * log t) ^ 2)) + (1 + 2 * a ^ 2 * log t + a ^ 2 * log t ^ 2) t := by +- convert! (hasDerivAt_id' t).mul l2 using 1; field_simp; ring +- convert! l1.inv e1 using 1; simp only [hh', pp, hh]; field_simp; ring ++ convert (hasDerivAt_id' t).mul l2 using 1; field_simp; ring ++ apply (l1.inv e1).congr_deriv ++ dsimp only [hh', pp, hh] ++ simp only [div_eq_mul_inv, inv_pow] ++ ring + +-lemma hh_continuous (a : ℝ) : ContinuousOn (hh a) (Ioi 0) := ++theorem hh_continuous (a : ℝ) : ContinuousOn (hh a) (Ioi 0) := + fun t (ht : 0 < t) => (hh_deriv a ht.ne.symm).continuousAt.continuousWithinAt + +-lemma hh'_nonpos {a x : ℝ} (ha : a ∈ Ioo (-1) 1) : hh' a x ≤ 0 := by ++theorem hh'_nonpos {a x : ℝ} (ha : a ∈ Ioo (-1) 1) : hh' a x ≤ 0 := by + have := pp_pos ha (log x) + simp only [hh', neg_mul, Left.neg_nonpos_iff, ge_iff_le] + positivity + +-lemma hh_antitone {a : ℝ} (ha : a ∈ Ioo (-1) 1) : AntitoneOn (hh a) (Ioi 0) := by ++theorem hh_antitone {a : ℝ} (ha : a ∈ Ioo (-1) 1) : AntitoneOn (hh a) (Ioi 0) := by + have l1 x (hx : x ∈ interior (Ioi 0)) : + HasDerivWithinAt (hh a) (hh' a x) (interior (Ioi 0)) x := by + have : x ≠ 0 := by contrapose! hx ; simp [hx] +@@ -1307,17 +1057,17 @@ lemma hh_antitone {a : ℝ} (ha : a ∈ Ioo (-1) 1) : AntitoneOn (hh a) (Ioi 0) + + noncomputable def gg (x i : ℝ) : ℝ := 1 / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ + +-lemma gg_of_hh {x : ℝ} (hx : x ≠ 0) (i : ℝ) : gg x i = x⁻¹ * hh (1 / (2 * π)) (i / x) := by ++theorem gg_of_hh {x : ℝ} (hx : x ≠ 0) (i : ℝ) : gg x i = x⁻¹ * hh (1 / (2 * π)) (i / x) := by + simp only [gg, hh] + field_simp + +-lemma gg_l1 {x : ℝ} (hx : 0 < x) (n : ℕ) : |gg x n| ≤ 1 / n := by ++theorem gg_l1 {x : ℝ} (hx : 0 < x) (n : ℕ) : |gg x n| ≤ 1 / n := by + simp only [gg_of_hh hx.ne.symm, one_div, mul_inv_rev, abs_mul] + apply mul_le_mul le_rfl (hh_le _ _ (by positivity)) (by positivity) (by positivity) |>.trans + (le_of_eq ?_) + simp [abs_inv, abs_eq_self.mpr hx.le] ; field_simp + +-lemma gg_le_one (i : ℕ) : gg x i ≤ 1 := by ++theorem gg_le_one (i : ℕ) : gg x i ≤ 1 := by + by_cases hi : i = 0 <;> simp only [gg, hi, CharP.cast_eq_zero, div_zero, one_div, mul_inv_rev, + zero_div, Real.log_zero, mul_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, + add_zero, inv_one, mul_one, zero_le_one] +@@ -1326,13 +1076,13 @@ lemma gg_le_one (i : ℕ) : gg x i ≤ 1 := by + simp only [le_add_iff_nonneg_right] ; positivity + rw [← mul_inv] ; apply inv_le_one_of_one_le₀ ; simpa using mul_le_mul l1 l2 zero_le_one (by simp) + +-lemma one_div_two_pi_mem_Ioo : 1 / (2 * π) ∈ Ioo (-1) 1 := by ++theorem one_div_two_pi_mem_Ioo : 1 / (2 * π) ∈ Ioo (-1) 1 := by + constructor + · trans 0 + · linarith + · positivity + · rw [div_lt_iff₀ (by positivity)] +- convert_to! 1 * 1 < 2 * π ++ convert_to 1 * 1 < 2 * π + · simp + · simp + apply mul_lt_mul one_lt_two ?_ zero_lt_one zero_le_two +@@ -1340,22 +1090,22 @@ lemma one_div_two_pi_mem_Ioo : 1 / (2 * π) ∈ Ioo (-1) 1 := by + · exact one_le_two + · exact two_le_pi + +-lemma sum_telescopic (a : ℕ → ℝ) (n : ℕ) : ∑ i ∈ Finset.range n, (a (i + 1) - a i) = a n - a 0 := by ++theorem sum_telescopic (a : ℕ → ℝ) (n : ℕ) : ++ ∑ i ∈ Finset.range n, (a (i + 1) - a i) = a n - a 0 := by + apply Finset.sum_range_sub + +-lemma cancel_aux {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++theorem cancel_aux {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) + (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : + ∑ i ∈ Finset.range n, f i * g i ≤ g (n - 1) * (C * n) + (C * (↑(n - 1 - 1) + 1) * g 0 + - C * (↑(n - 1 - 1) + 1) * g (n - 1) - + ((n - 1 - 1) • (C * g 0) - ∑ x ∈ Finset.range (n - 1 - 1), C * g (x + 1))) := by +- + have l1 (n : ℕ) : + (g n - g (n + 1)) * ∑ i ∈ Finset.range (n + 1), f i ≤ (g n - g (n + 1)) * (C * (n + 1)) := by +- apply mul_le_mul le_rfl (by simpa using! hf' (n + 1)) (Finset.sum_nonneg (fun n _ ↦ hf n)) ?_ ++ apply mul_le_mul le_rfl (by simpa only [cumsum, Nat.cast_add, Nat.cast_one] using hf' (n + 1)) ++ (Finset.sum_nonneg (fun i _ => hf i)) ?_ + simp only [sub_nonneg] ; apply hg' ; simp + have l2 (x : ℕ) : C * (↑(x + 1) + 1) - C * (↑x + 1) = C := by simp ; ring +- have l3 (n : ℕ) : 0 ≤ cumsum f n := Finset.sum_nonneg (fun n _ ↦ hf n) +- ++ have l3 (n : ℕ) : 0 ≤ cumsum f n := Finset.sum_nonneg (fun i _ => hf i) + convert_to ∑ i ∈ Finset.range n, (g i) • (f i) ≤ _ + · simp [mul_comm] + rw [Finset.sum_range_by_parts, sub_eq_add_neg, ← Finset.sum_neg_distrib] +@@ -1363,20 +1113,20 @@ lemma cancel_aux {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) + apply _root_.add_le_add + · exact mul_le_mul le_rfl (hf' n) (l3 n) (hg _) + · apply Finset.sum_le_sum (fun n _ => l1 n) |>.trans +- convert_to! ∑ i ∈ Finset.range (n - 1), (C * (↑i + 1)) • (g i - g (i + 1)) ≤ _ ++ convert_to ∑ i ∈ Finset.range (n - 1), (C * (↑i + 1)) • (g i - g (i + 1)) ≤ _ + · congr ; ext i ; simp ; ring + rw [Finset.sum_range_by_parts] + simp_rw [Finset.sum_range_sub', l2, smul_sub, smul_eq_mul, Finset.sum_sub_distrib, + Finset.sum_const, Finset.card_range] + apply le_of_eq ; ring_nf + +-lemma sum_range_succ (a : ℕ → ℝ) (n : ℕ) : ++theorem sum_range_succ (a : ℕ → ℝ) (n : ℕ) : + ∑ i ∈ Finset.range n, a (i + 1) = (∑ i ∈ Finset.range (n + 1), a i) - a 0 := by + have := Finset.sum_range_sub a n + rw [Finset.sum_sub_distrib, sub_eq_iff_eq_add] at this + rw [Finset.sum_range_succ, this] ; ring + +-lemma cancel_aux' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++theorem cancel_aux' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) + (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : + ∑ i ∈ Finset.range n, f i * g i ≤ + C * n * g (n - 1) +@@ -1387,27 +1137,37 @@ lemma cancel_aux' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) + simp only [nsmul_eq_mul, ← Finset.mul_sum, sum_range_succ] at this + convert this using 1 ; unfold cumsum ; ring + +-lemma cancel_main {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++theorem cancel_main {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) + (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) (hn : 2 ≤ n) : + cumsum (f * g) n ≤ C * cumsum g n := by +- convert! cancel_aux' hf hg hf' hg' n using 1 +- match n with +- | n + 2 => simp only [cumsum_succ] ; push_cast ; ring +- +-lemma cancel_main' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hf0 : f 0 = 0) (hg : 0 ≤ g) ++ change (∑ i ∈ Finset.range n, f i * g i) ≤ C * cumsum g n ++ refine (cancel_aux' hf hg hf' hg' n).trans_eq ?_ ++ have hindex : n - 1 - 1 + 1 = n - 1 := by omega ++ have hcast : (n : ℝ) = ↑(n - 1) + 1 := by ++ exact_mod_cast (show n = (n - 1) + 1 by omega) ++ have hcast' : (↑(n - 1 - 1) : ℝ) + 1 = ↑(n - 1) := by ++ exact_mod_cast hindex ++ have hsum : cumsum g n = cumsum g (n - 1) + g (n - 1) := by ++ conv_lhs => rw [show n = (n - 1) + 1 by omega] ++ exact cumsum_succ (n - 1) ++ rw [hindex, hcast', hcast, hsum] ++ ring ++ ++theorem cancel_main' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hf0 : f 0 = 0) (hg : 0 ≤ g) + (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : + cumsum (f * g) n ≤ C * cumsum g n := by +- match n with +- | 0 => simp [cumsum] +- | 1 => specialize hg 0 ; specialize hf' 1 ; simp only [cumsum, Finset.range_one, +- Finset.sum_singleton, hf0, Nat.cast_one, mul_one, Pi.zero_apply, Pi.mul_apply, zero_mul, +- ge_iff_le] at hf' hg ⊢ ; positivity +- | n + 2 => convert! cancel_aux' hf hg hf' hg' (n + 2) using 1 ; simp [cumsum_succ] ; ring ++ cases n with ++ | zero => simp [cumsum] ++ | succ n => ++ cases n with ++ | zero => ++ have hC : 0 ≤ C := by simpa [cumsum, hf0] using hf' 1 ++ simpa [cumsum, hf0] using mul_nonneg hC (hg 0) ++ | succ n => exact cancel_main hf hg hf' hg' (n + 2) (by omega) + + theorem sum_le_integral {x₀ : ℝ} {f : ℝ → ℝ} {n : ℕ} (hf : AntitoneOn f (Ioc x₀ (x₀ + n))) + (hfi : IntegrableOn f (Icc x₀ (x₀ + n))) : + (∑ i ∈ Finset.range n, f (x₀ + ↑(i + 1))) ≤ ∫ x in x₀..x₀ + n, f x := by +- + cases n with simp only [Nat.cast_add, Nat.cast_one, CharP.cast_eq_zero, add_zero, + lt_self_iff_false, not_false_eq_true, + Ioc_eq_empty, Finset.range_zero, Nat.cast_add, Nat.cast_one, Finset.sum_empty, +@@ -1418,7 +1178,6 @@ theorem sum_le_integral {x₀ : ℝ} {f : ℝ → ℝ} {n : ℕ} (hf : AntitoneO + simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, + lt_add_iff_pos_left, add_pos_iff, zero_lt_one, or_true, and_true, not_false_eq_true, + Finset.sum_insert, CharP.cast_eq_zero, zero_add, ge_iff_le] +- + have l4 : IntervalIntegrable f volume x₀ (x₀ + 1) := by + apply IntegrableOn.intervalIntegrable + simp only [le_add_iff_nonneg_right, zero_le_one, uIcc_of_le] +@@ -1429,24 +1188,21 @@ theorem sum_le_integral {x₀ : ℝ} {f : ℝ → ℝ} {n : ℕ} (hf : AntitoneO + rcases hx with ⟨hx1, hx2⟩ + refine hf ⟨hx1, by linarith⟩ ⟨by linarith, by linarith⟩ hx2 + have l6 : ∫ x in x₀..x₀ + 1, f (x₀ + 1) = f (x₀ + 1) := by simp +- + have l1 : f (x₀ + 1) ≤ ∫ x in x₀..x₀ + 1, f x := by +- rw [← l6] ; apply intervalIntegral.integral_mono_ae_restrict (by linarith) (by simp) l4 +- apply eventually_of_mem _ l5 +- have : (Ioc x₀ (x₀ + 1))ᶜ ∩ Icc x₀ (x₀ + 1) = {x₀} := by simp [← sdiff_eq_compl_inter] +- rw [mem_ae_iff, Measure.restrict_apply measurableSet_Ioc.compl, this] +- simp +- ++ rw [← l6] ++ apply intervalIntegral.integral_mono_on_of_le_Ioo (by linarith) (by simp) l4 ++ intro x hx ++ exact l5 x ⟨hx.1, hx.2.le⟩ + have l2 : AntitoneOn (fun x ↦ f (x₀ + x)) (Icc 1 ↑(n + 1)) := by +- intro u ⟨hu1, _⟩ v ⟨_, hv2⟩ huv ; push_cast at hv2 ++ intro u hu v hv huv ++ have hu1 := hu.1 ++ have hv2 := hv.2 ++ push_cast at hv2 + refine hf ⟨?_, ?_⟩ ⟨?_, ?_⟩ ?_ <;> linarith +- + have l3 := @AntitoneOn.sum_le_integral_Ico 1 (n + 1) (fun x => f (x₀ + x)) (by simp) + (by simpa using l2) +- + simp only [Nat.cast_add, Nat.cast_one, intervalIntegral.integral_comp_add_left] at l3 +- convert! _root_.add_le_add l1 l3 +- ++ convert _root_.add_le_add l1 l3 + have := @intervalIntegral.integral_comp_mul_add ℝ _ _ 1 (n + 1) 1 f one_ne_zero x₀ + rw [intervalIntegral.integral_add_adjacent_intervals] + · exact l4 +@@ -1457,26 +1213,25 @@ theorem sum_le_integral {x₀ : ℝ} {f : ℝ → ℝ} {n : ℕ} (hf : AntitoneO + · linarith + · simp + +-lemma hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++theorem hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : + (IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0)) ∧ + (∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π) := by +- + rw [integrableOn_Ici_iff_integrableOn_Ioi] + simp only [hh] +- + let g (x : ℝ) := (a * c / b) * Real.arctan (b * log (x / c)) + let g₀ (x : ℝ) := if x = 0 then ((a * c / b) * (- (π / 2))) else g x + let g' (x : ℝ) := a * (x / c * (1 + (b * Real.log (x / c)) ^ 2))⁻¹ +- + have l3 (x) (hx : 0 < x) : HasDerivAt Real.log x⁻¹ x := by apply Real.hasDerivAt_log (by linarith) + have l4 (x) : HasDerivAt (fun t => t / c) (1 / c) x := (hasDerivAt_id x).div_const c + have l2 (x) (hx : 0 < x) : HasDerivAt (fun t => log (t / c)) x⁻¹ x := by +- have := @HasDerivAt.comp _ _ _ _ _ _ (fun t => t / c) _ _ _ (l3 (x / c) (by positivity)) (l4 x) +- convert! this using 1 ; field_simp ++ have hcomp := (l3 (x / c) (by positivity)).comp x (l4 x) ++ convert hcomp using 1 ++ · rfl ++ · field_simp [hc.ne', hx.ne'] + have l5 (x) (hx : 0 < x) := (l2 x hx).const_mul b + have l1 (x) (hx : 0 < x) := (l5 x hx).arctan + have l6 (x) (hx : 0 < x) : HasDerivAt g (g' x) x := by +- convert! (l1 x hx).const_mul (a * c / b) using 1 ++ convert (l1 x hx).const_mul (a * c / b) using 1 + simp only [g'] + field_simp + have key (x) (hx : 0 < x) : HasDerivAt g₀ (g' x) x := by +@@ -1484,7 +1239,6 @@ lemma hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : + apply eventually_of_mem <| Ioi_mem_nhds hx + intro y (hy : 0 < y) + simp [g₀, hy.ne.symm] +- + have k1 : Tendsto g₀ atTop (𝓝 ((a * c / b) * (π / 2))) := by + have : g =ᶠ[atTop] g₀ := by + apply eventually_of_mem (Ioi_mem_atTop 0) +@@ -1497,7 +1251,6 @@ lemma hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : + apply tendsto_log_atTop.comp + apply Tendsto.atTop_div_const hc + apply tendsto_id +- + have k2 : Tendsto g₀ (𝓝[>] 0) (𝓝 (g₀ 0)) := by + have : g =ᶠ[𝓝[>] 0] g₀ := by + apply eventually_of_mem self_mem_nhdsWithin +@@ -1514,20 +1267,20 @@ lemma hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : + · simp only [mem_Ioi] at hx1 ⊢ ; positivity + · simp only [dist_zero_right, norm_eq_abs, norm_div, abs_eq_self.mpr hc.le] at hx2 ⊢ + rwa [div_lt_iff₀ hc, mul_comm] +- + have k3 : ContinuousWithinAt g₀ (Ici 0) 0 := by + rw [Metric.continuousWithinAt_iff] + rw [Metric.tendsto_nhdsWithin_nhds] at k2 +- gconvert k2 using 5 with ε hε δ hδ x h +- intro (hx : 0 ≤ x) +- have := le_iff_lt_or_eq.mp hx +- cases this with +- | inl hx => exact h hx +- | inr hx => simp [g₀, hx.symm, hε] +- ++ intro ε hε ++ obtain ⟨δ, hδ, hδx⟩ := k2 ε hε ++ refine ⟨δ, hδ, ?_⟩ ++ intro x hx hdist ++ change 0 ≤ x at hx ++ rcases lt_or_eq_of_le hx with hx | hx ++ · exact hδx hx hdist ++ · subst x ++ simpa only [dist_self] using hε + have k4 : ∀ x ∈ Ioi 0, 0 ≤ g' x := by + intro x (hx : 0 < x) ; simp only [mul_inv_rev, inv_div, g'] ; positivity +- + constructor + · convert_to IntegrableOn g' _ + exact integrableOn_Ioi_deriv_of_nonneg k3 key k4 k1 +@@ -1535,25 +1288,25 @@ lemma hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : + simp only [mul_inv_rev, inv_div, mul_neg, ↓reduceIte, sub_neg_eq_add, g', g₀] at this ⊢ + convert this using 1 ; field_simp ; ring + +-lemma hh_integrable (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++theorem hh_integrable (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : + IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0) := + hh_integrable_aux ha hb hc |>.1 + +-lemma hh_integral (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++theorem hh_integral (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : + ∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π := + hh_integrable_aux ha hb hc |>.2 + +-lemma hh_integral' : ∫ t in Ioi 0, hh (1 / (2 * π)) t = 2 * π ^ 2 := by ++theorem hh_integral' : ∫ t in Ioi 0, hh (1 / (2 * π)) t = 2 * π ^ 2 := by + have := hh_integral (a := 1) (b := 1 / (2 * π)) (c := 1) + (by positivity) (by positivity) (by positivity) + convert this using 1 <;> simp ; ring + +-lemma bound_sum_log {C : ℝ} (hf0 : f 0 = 0) (hf : chebyWith C f) {x : ℝ} (hx : 1 ≤ x) : ++theorem bound_sum_log {C : ℝ} (hf0 : f 0 = 0) ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : + ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ + C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by +- + let ggg (i : ℕ) : ℝ := if i = 0 then 1 else gg x i +- + have l0 : x ≠ 0 := by linarith + have l1 i : 0 ≤ ggg i := by by_cases hi : i = 0 <;> simp only [gg, one_div, mul_inv_rev, hi, + ↓reduceIte, zero_le_one, ggg] ; positivity +@@ -1569,33 +1322,29 @@ lemma bound_sum_log {C : ℝ} (hf0 : f 0 = 0) (hf : chebyWith C f) {x : ℝ} (hx + · simp only [mem_Ioi] ; positivity + · gcongr + have l3 : 0 ≤ C := by simpa [cumsum, hf0] using hf 1 +- + have l4 : 0 ≤ ∫ (t : ℝ) in Ioi 0, hh (π⁻¹ * 2⁻¹) t := + setIntegral_nonneg measurableSet_Ioi (fun x hx => hh_nonneg _ (LT.lt.le hx)) +- + have l5 {n : ℕ} : AntitoneOn (fun t ↦ x⁻¹ * hh (1 / (2 * π)) (t / x)) (Ioc 0 n) := by +- intro u ⟨hu1, _⟩ v ⟨hv1, _⟩ huv ++ intro u hu v hv huv ++ have hu1 := hu.1 ++ have hv1 := hv.1 + simp only + apply mul_le_mul le_rfl ?_ (hh_nonneg _ (by positivity)) (by positivity) + apply hh_antitone one_div_two_pi_mem_Ioo (by simp only [mem_Ioi] ; positivity) + (by simp only [mem_Ioi] ; positivity) + apply (div_le_div_iff_of_pos_right (by positivity)).mpr huv +- + have l6 {n : ℕ} : IntegrableOn (fun t ↦ x⁻¹ * hh (π⁻¹ * 2⁻¹) (t / x)) (Icc 0 n) volume := by + apply IntegrableOn.mono_set + (hh_integrable (by positivity) (by positivity) (by positivity)) Icc_subset_Ici_self +- + apply Real.tsum_le_of_sum_range_le (fun n => by positivity) ; intro n +- convert_to! ∑ i ∈ Finset.range n, ‖f i‖ * ggg i ≤ _ ++ convert_to ∑ i ∈ Finset.range n, ‖f i‖ * ggg i ≤ _ + · congr ; ext i + by_cases hi : i = 0 + · simp [hi, hf0] + · simp only [gg, hi, ↓reduceIte, ggg] + field_simp +- + apply cancel_main' (fun _ => norm_nonneg _) (by simp [hf0]) l1 hf l2 n |>.trans + gcongr ; simp only [cumsum, gg_of_hh l0, one_div, mul_inv_rev, ggg] +- + by_cases hn : n = 0 + · simp only [hn, Finset.range_zero, Finset.sum_empty] ; positivity + replace hn : 0 < n := by omega +@@ -1603,7 +1352,7 @@ lemma bound_sum_log {C : ℝ} (hf0 : f 0 = 0) (hf : chebyWith C f) {x : ℝ} (hx + ext i ; simp ; by_cases hi : i = 0 <;> simp [hi, hn] ; omega + simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, + false_and, not_false_eq_true, Finset.sum_insert, ↓reduceIte, add_le_add_iff_left, ge_iff_le] +- convert_to! ∑ x_1 ∈ Finset.Ico 1 n, x⁻¹ * hh (π⁻¹ * 2⁻¹) (↑x_1 / x) ≤ _ ++ convert_to ∑ x_1 ∈ Finset.Ico 1 n, x⁻¹ * hh (π⁻¹ * 2⁻¹) (↑x_1 / x) ≤ _ + · apply Finset.sum_congr rfl (fun i hi => ?_) + simp at hi + have : i ≠ 0 := by omega +@@ -1624,36 +1373,43 @@ lemma bound_sum_log {C : ℝ} (hf0 : f 0 = 0) (hf : chebyWith C f) {x : ℝ} (hx + · apply eventually_of_mem (self_mem_ae_restrict measurableSet_Ioi) + intro x (hx : 0 < x) + apply hh_nonneg _ hx.le +- · have := (@hh_integrable 1 (1 / (2 * π)) 1 (by positivity) (by positivity) (by positivity)) +- simpa using! this.mono_set Ioi_subset_Ici_self +- +-lemma bound_sum_log0 {C : ℝ} (hf : chebyWith C f) {x : ℝ} (hx : 1 ≤ x) : ++ · have h := (@hh_integrable 1 (1 / (2 * π)) 1 (by positivity) (by positivity) (by positivity)) ++ have h' := h.mono_set Ioi_subset_Ici_self ++ unfold IntegrableOn at h' ++ apply h'.congr ++ exact Eventually.of_forall (fun t => by simp) ++ ++theorem bound_sum_log0 {C : ℝ} ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : + ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ + C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by +- + let f0 i := if i = 0 then 0 else f i +- have l1 : chebyWith C f0 := by ++ have l1 : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f0 k : ℂ)‖) n ≤ C * n) := by + intro n ; refine Finset.sum_le_sum (fun i _ => ?_) |>.trans (hf n) + by_cases hi : i = 0 <;> simp [hi, f0] + have l2 i : ‖f i‖ / i = ‖f0 i‖ / i := by by_cases hi : i = 0 <;> simp [hi, f0] + simp_rw [l2] ; apply bound_sum_log rfl l1 hx + +-lemma bound_sum_log' {C : ℝ} (hf : chebyWith C f) {x : ℝ} (hx : 1 ≤ x) : ++theorem bound_sum_log' {C : ℝ} ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : + ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ C * (1 + 2 * π ^ 2) := by + simpa only [hh_integral'] using bound_sum_log0 hf hx + + variable (f x) in +-lemma summable_fourier_aux (ψ : W21) (i : ℕ) : ++theorem summable_fourier_aux (ψ : W21) (i : ℕ) : + ‖f i / i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (i / x))‖ ≤ + W21.norm ψ * (‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹) := by +- convert! mul_le_mul_of_nonneg_left (decay_bounds_key ψ (1 / (2 * π) * log (i / x))) ++ convert mul_le_mul_of_nonneg_left (decay_bounds_key ψ (1 / (2 * π) * log (i / x))) + (norm_nonneg (f i / i)) using 1 + · simp + · change _ = _ * (W21.norm ψ * _) + simp only [W21.norm, mul_inv_rev, one_div, Complex.norm_div, RCLike.norm_natCast] + ring + +-lemma summable_fourier (x : ℝ) (hx : 0 < x) (ψ : W21) (hcheby : cheby f) : ++theorem summable_fourier (x : ℝ) (hx : 0 < x) (ψ : W21) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : + Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by + have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by + simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) +@@ -1661,31 +1417,32 @@ lemma summable_fourier (x : ℝ) (hx : 0 < x) (ψ : W21) (hcheby : cheby f) : + exact Summable.of_nonneg_of_le (fun _ => norm_nonneg _) l6 + (by simpa using l5.const_smul (W21.norm ψ)) + +-lemma bound_I1 (x : ℝ) (hx : 0 < x) (ψ : W21) (hcheby : cheby f) : ++theorem bound_I1 (x : ℝ) (hx : 0 < x) (ψ : W21) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : + ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ + W21.norm ψ • ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ := by +- + have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by + simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) + have l6 := summable_fourier_aux x f ψ + have l1 : Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by + exact summable_fourier x hx ψ hcheby + apply (norm_tsum_le_tsum_norm l1).trans +- simpa only [← Summable.tsum_const_smul _ l5] using! +- Summable.tsum_mono l1 (by simpa using l5.const_smul (W21.norm ψ)) l6 ++ change (∑' i, ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) ++ (1 / (2 * π) * Real.log (↑i / x))‖) ≤ W21.norm ψ * _ ++ rw [← tsum_mul_left] ++ exact Summable.tsum_mono l1 (l5.mul_left (W21.norm ψ)) l6 + +-lemma bound_I1' {C : ℝ} (x : ℝ) (hx : 1 ≤ x) (ψ : W21) (hcheby : chebyWith C f) : ++theorem bound_I1' {C : ℝ} (x : ℝ) (hx : 1 ≤ x) (ψ : W21) ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : + ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ + W21.norm ψ * C * (1 + 2 * π ^ 2) := by +- + apply bound_I1 x (by linarith) ψ ⟨_, hcheby⟩ |>.trans + rw [smul_eq_mul, mul_assoc] + apply mul_le_mul le_rfl (bound_sum_log' hcheby hx) ?_ W21.norm_nonneg + apply tsum_nonneg (fun i => by positivity) + +-lemma bound_I2 (x : ℝ) (ψ : W21) : ++theorem bound_I2 (x : ℝ) (ψ : W21) : + ‖∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ W21.norm ψ * (2 * π ^ 2) := by +- + have key a : ‖𝓕 (ψ : ℝ → ℂ) (a / (2 * π))‖ ≤ W21.norm ψ * (1 + (a / (2 * π)) ^ 2)⁻¹ := + decay_bounds_key ψ _ + have twopi : 0 ≤ 2 * π := by simp [pi_nonneg] +@@ -1706,36 +1463,31 @@ lemma bound_I2 (x : ℝ) (ψ : W21) : + rw [Measure.integral_comp_div (fun x => (1 + x ^ 2)⁻¹) (2 * π)] + simp [abs_eq_self.mpr twopi] ; ring_nf ; rfl + +-lemma bound_main {C : ℝ} (A : ℂ) (x : ℝ) (hx : 1 ≤ x) (ψ : W21) +- (hcheby : chebyWith C f) : ++theorem bound_main {C : ℝ} (A : ℂ) (x : ℝ) (hx : 1 ≤ x) (ψ : W21) ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : + ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - + A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ + W21.norm ψ * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2)) := by +- + have l1 := bound_I1' x hx ψ hcheby + have l2 := mul_le_mul (le_refl ‖A‖) (bound_I2 x ψ) (by positivity) (by positivity) + apply norm_sub_le _ _ |>.trans ; rw [norm_mul] + convert _root_.add_le_add l1 l2 using 1 ; ring + +- +-set_option backward.isDefEq.respectTransparency false in +-lemma limiting_cor_W21 (ψ : W21) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++theorem limiting_cor_W21 (ψ : W21) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : + Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - + A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by + +- -- Shorter notation for clarity + let S1 x (ψ : ℝ → ℂ) := ∑' (n : ℕ), f n / ↑n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑n / x)) + let S2 x (ψ : ℝ → ℂ) := ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) + let S x ψ := S1 x ψ - S2 x ψ ; change Tendsto (fun x ↦ S x ψ) atTop (𝓝 0) + +- -- Build the truncation + obtain g := exists_trunc + let Ψ R := g.scale R * ψ + have key R : Tendsto (fun x ↦ S x (Ψ R)) atTop (𝓝 0) := limiting_cor (Ψ R) hf hcheby hG hG' + +- -- Choose the truncation radius + obtain ⟨C, hcheby⟩ := hcheby + have hC : 0 ≤ C := by + have : ‖f 0‖ ≤ C := by simpa [cumsum] using hcheby 1 +@@ -1747,130 +1499,62 @@ lemma limiting_cor_W21 (ψ : W21) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (n + obtain ⟨R, hRψ⟩ := (key2 ((ε / 2) / (1 + M)) (by positivity)).exists + simp only [dist_zero_right, Real.norm_eq_abs, abs_eq_self.mpr W21.norm_nonneg] at hRψ key + +- -- Apply the compact support case + filter_upwards [eventually_ge_atTop 1, key R (ε / 2) (by positivity)] with x hx key + +- -- Control the tail term + have key3 : ‖S x (ψ - Ψ R)‖ < ε / 2 := by +- have : ‖S x _‖ ≤ _ * M := @bound_main f C A x hx (ψ - Ψ R) hcheby +- apply this.trans_lt +- apply (mul_le_mul (d := 1 + M) le_rfl (by simp) (by positivity) W21.norm_nonneg).trans_lt +- have : 0 < 1 + M := by positivity +- convert! (mul_lt_mul_iff_left₀ this).mpr hRψ using 1 ; field_simp +- +- -- Conclude the proof +- have S1_sub_1 x : 𝓕 (⇑ψ - ⇑(Ψ R)) x = 𝓕 (ψ : ℝ → ℂ) x - 𝓕 ⇑(Ψ R) x := by +- have l1 : AEStronglyMeasurable (fun x_1 : ℝ ↦ cexp (-(2 * ↑π * (↑x_1 * ↑x) * I))) volume := by +- refine (Continuous.mul ?_ continuous_const).neg.cexp.aestronglyMeasurable +- apply continuous_const.mul <| contDiff_ofReal.continuous.mul continuous_const +- simp only [Real.fourier_eq', neg_mul, RCLike.inner_apply', conj_trivial, ofReal_neg, +- ofReal_mul, ofReal_ofNat, Pi.sub_apply, smul_eq_mul, mul_sub] +- apply integral_sub +- · apply ψ.hf.bdd_mul (c := 1) l1 ; simp [Complex.norm_exp] +- · apply (Ψ R : W21) |>.hf |>.bdd_mul (c := 1) l1 +- simp [Complex.norm_exp] ++ have hbound := @bound_main f C A x hx (ψ - Ψ R) hcheby ++ change ‖S x (⇑ψ - ⇑(Ψ R))‖ ≤ W21.norm (⇑ψ - ⇑(Ψ R)) * M at hbound ++ apply hbound.trans_lt ++ calc ++ W21.norm (⇑ψ - ⇑(Ψ R)) * M ≤ W21.norm (⇑ψ - ⇑(Ψ R)) * (1 + M) := ++ mul_le_mul_of_nonneg_left (by linarith) W21.norm_nonneg ++ _ < ε / 2 := (lt_div_iff₀ (show 0 < 1 + M by positivity)).mp hRψ + ++ have S1_sub_1 x : 𝓕 (⇑ψ - ⇑(Ψ R)) x = 𝓕 (ψ : ℝ → ℂ) x - 𝓕 ⇑(Ψ R) x := ++ F_sub ψ.hf (Ψ R : W21).hf x + have S1_sub : S1 x (ψ - Ψ R) = S1 x ψ - S1 x (Ψ R) := by + simp only [one_div, mul_inv_rev, S1_sub_1, mul_sub, S1] ; apply Summable.tsum_sub + · have := summable_fourier x (by positivity) ψ ⟨_, hcheby⟩ + rw [summable_norm_iff] at this + simpa using this +- · have := summable_fourier x (by positivity) (Ψ R) ⟨_, hcheby⟩ +- rw [summable_norm_iff] at this +- simpa using! this +- ++ · have hsum := summable_fourier x (by positivity) (Ψ R : W21) ⟨_, hcheby⟩ ++ rw [summable_norm_iff] at hsum ++ simpa only [W21.ofCS2, one_div, mul_inv_rev] using hsum + have S2_sub : S2 x (ψ - Ψ R) = S2 x ψ - S2 x (Ψ R) := by + simp only [S1_sub_1, S2] ; rw [integral_sub] + · ring + · exact ψ.integrable_fourier (by positivity) |>.restrict + · exact (Ψ R : W21).integrable_fourier (by positivity) |>.restrict +- + have S_sub : S x (ψ - Ψ R) = S x ψ - S x (Ψ R) := by simp [S, S1_sub, S2_sub] ; ring + simpa [S_sub, Ψ] using norm_add_le _ _ |>.trans_lt (_root_.add_lt_add key3 key) + +-@[blueprint +- "schwarz-id" +- (title := "Limiting identity for Schwartz functions") +- (statement := /-- +- The previous corollary also holds for functions $\psi$ that are assumed to be in the Schwartz +- class, as opposed to being $C^2$ and compactly supported. +- -/) +- (proof := /-- +- For any $R>1$, one can use a smooth cutoff function (provided by Lemma \ref{smooth-ury} to write +- $\psi = \psi_{\leq R} + \psi_{>R}$, where $\psi_{\leq R}$ is $C^2$ (in fact smooth) and compactly +- supported (on $[-R,R]$), and $\psi_{>R}$ obeys bounds of the form +- $$ |\psi_{>R}(t)|, |\psi''_{>R}(t)| \ll R^{-1} / (1 + |t|^2) $$ +- where the implied constants depend on $\psi$. By Lemma \ref{decay} we then have +- $$ \hat \psi_{>R}(u) \ll R^{-1} / (1+|u|^2).$$ +- Using this and \eqref{cheby} one can show that +- $$ \sum_{n=1}^\infty \frac{f(n)}{n} \hat \psi_{>R}( \frac{1}{2\pi} \log \frac{n}{x} ), +- A \int_{-\infty}^\infty \hat \psi_{>R} (\frac{u}{2\pi})\ du \ll R^{-1} $$ +- (with implied constants also depending on $A$), while from Lemma \ref{limiting-cor} one has +- $$ \sum_{n=1}^\infty \frac{f(n)}{n} \hat \psi_{\leq R}( \frac{1}{2\pi} \log \frac{n}{x} ) +- = A \int_{-\infty}^\infty \hat \psi_{\leq R} (\frac{u}{2\pi})\ du + o(1).$$ +- Combining the two estimates and letting $R$ be large, we obtain the claim. +- -/) +- (latexEnv := "lemma")] +-lemma limiting_cor_schwartz (ψ : 𝓢(ℝ, ℂ)) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++theorem limiting_cor_schwartz (ψ : 𝓢(ℝ, ℂ)) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : + Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - + A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := + limiting_cor_W21 ψ hf hcheby hG hG' + +- +- +- +- +--- just the surjectivity is stated here, as this is all that is needed for the current +--- application, but perhaps one should state and prove bijectivity instead +- +-@[blueprint +- "bij" +- (title := "Bijectivity of Fourier transform") +- (statement := /-- +- The Fourier transform is a bijection on the Schwartz class. [Note: only surjectivity is +- actually used.] +- -/) +- (proof := /-- +- This is a standard result in Fourier analysis. +- It can be proved here by appealing to Mellin inversion, Theorem \ref{MellinInversion}. +- In particular, given $f$ in the Schwartz class, let +- $F : \R_+ \to \C : x \mapsto f(\log x)$ be a function in the ``Mellin space''; then the +- Mellin transform of $F$ on the imaginary axis $s=it$ is the Fourier transform of $f$. +- The Mellin inversion theorem gives Fourier inversion. +- -/) +- (latexEnv := "lemma")] +-lemma fourier_surjection_on_schwartz (f : 𝓢(ℝ, ℂ)) : ∃ g : 𝓢(ℝ, ℂ), 𝓕 g = f := by ++theorem fourier_surjection_on_schwartz (f : 𝓢(ℝ, ℂ)) : ∃ g : 𝓢(ℝ, ℂ), 𝓕 g = f := by + refine ⟨𝓕⁻ f, ?_⟩ + exact FourierTransform.fourier_fourierInv_eq f + ++noncomputable def toSchwartz (f : ℝ → ℂ) (h1 : ContDiff ℝ ∞ f) ++ (h2 : HasCompactSupport f) : 𝓢(ℝ, ℂ) := ++ h2.toSchwartzMap h1 + ++@[simp] theorem toSchwartz_apply (f : ℝ → ℂ) {h1 h2 x} : SchwartzMap.mk f h1 h2 x = f x := rfl + +- +-noncomputable def toSchwartz (f : ℝ → ℂ) (h1 : ContDiff ℝ ∞ f) +- (h2 : HasCompactSupport f) : 𝓢(ℝ, ℂ) where +- toFun := f +- smooth' := h1 +- decay' k n := by +- have l1 : Continuous (fun x => ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖) := by +- have : ContDiff ℝ ∞ (iteratedFDeriv ℝ n f) := h1.iteratedFDeriv_right (mod_cast le_top) +- exact Continuous.mul (by continuity) this.continuous.norm +- have l2 : HasCompactSupport (fun x ↦ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖) := +- (h2.iteratedFDeriv _).norm.mul_left +- simpa using l1.bounded_above_of_compact_support l2 +- +-@[simp] lemma toSchwartz_apply (f : ℝ → ℂ) {h1 h2 x} : SchwartzMap.mk f h1 h2 x = f x := rfl +- +-lemma comp_exp_support0 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++theorem comp_exp_support0 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : + ∀ᶠ x in 𝓝 0, Ψ x = 0 := + notMem_tsupport_iff_eventuallyEq.mp (fun h => lt_irrefl 0 <| mem_Ioi.mp (hplus h)) + +-lemma comp_exp_support1 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++theorem comp_exp_support1 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : + ∀ᶠ x in atBot, Ψ (exp x) = 0 := + Real.tendsto_exp_atBot <| comp_exp_support0 hplus + +-lemma comp_exp_support2 {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) : ++theorem comp_exp_support2 {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) : + ∀ᶠ (x : ℝ) in atTop, (Ψ ∘ rexp) x = 0 := by + simp only [hasCompactSupport_iff_eventuallyEq, coclosedCompact_eq_cocompact, + cocompact_eq_atBot_atTop] at hsupp +@@ -1882,11 +1566,9 @@ theorem comp_exp_support {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) + cocompact_eq_atBot_atTop] + exact ⟨comp_exp_support1 hplus, comp_exp_support2 hsupp⟩ + +-set_option backward.isDefEq.respectTransparency false in +-lemma wiener_ikehara_smooth_aux (l0 : Continuous Ψ) (hsupp : HasCompactSupport Ψ) ++theorem wiener_ikehara_smooth_aux (l0 : Continuous Ψ) (hsupp : HasCompactSupport Ψ) + (hplus : closure (Function.support Ψ) ⊆ Ioi 0) (x : ℝ) (hx : 0 < x) : + ∫ (u : ℝ) in Ioi (-Real.log x), ↑(rexp u) * Ψ (rexp u) = ∫ (y : ℝ) in Ioi (1 / x), Ψ y := by +- + have l1 : ContinuousOn rexp (Ici (-Real.log x)) := by fun_prop + have l2 : Tendsto rexp atTop atTop := Real.tendsto_exp_atTop + have l3 t (_ : t ∈ Ioi (-log x)) : HasDerivWithinAt rexp (rexp t) (Ioi t) t := +@@ -1905,13 +1587,10 @@ theorem wiener_ikehara_smooth_sub (h1 : Integrable Ψ) + (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : + Tendsto (fun x ↦ (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) + atTop (𝓝 0) := by +- + obtain ⟨ε, hε, hh⟩ := Metric.eventually_nhds_iff.mp <| comp_exp_support0 hplus + apply tendsto_nhds_of_eventually_eq ; filter_upwards [eventually_gt_atTop ε⁻¹] with x hxε +- + have l1 : Integrable (indicator (Ioi x⁻¹) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi + have l2 : Integrable (indicator (Ioi 0) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi +- + simp_rw [← MeasureTheory.integral_indicator measurableSet_Ioi, ← mul_sub, ← integral_sub l1 l2] + simp only [mul_eq_zero, ofReal_eq_zero] + right +@@ -1919,12 +1598,10 @@ theorem wiener_ikehara_smooth_sub (h1 : Integrable Ψ) + apply Eventually.of_forall + intro t + simp only [Pi.zero_apply] +- + have hε' : 0 < ε⁻¹ := by positivity + have hx : 0 < x := by linarith + have hx' : 0 < x⁻¹ := by positivity + have hεx : x⁻¹ < ε := (inv_lt_comm₀ hε hx).mp hxε +- + have l3 : Ioi 0 = Ioc 0 x⁻¹ ∪ Ioi x⁻¹ := by + ext t ; simp only [mem_Ioi, mem_union, mem_Ioc] ; constructor <;> intro h + · simp [h, le_or_gt] +@@ -1943,52 +1620,35 @@ theorem wiener_ikehara_smooth_sub (h1 : Integrable Ψ) + rw [abs_le] ; constructor <;> linarith + simp [ht] + +- +- +-@[blueprint +- "WienerIkeharaSmooth" +- (title := "Smoothed Wiener-Ikehara") +- (statement := /-- +- If $\Psi: (0,\infty) \to \C$ is smooth and compactly supported away from the origin, then, +- $$ \sum_{n=1}^\infty f(n) \Psi( \frac{n}{x} ) = A x \int_0^\infty \Psi(y)\ dy + o(x)$$ +- as $x \to \infty$. +- -/) +- (proof := /-- +- By Lemma \ref{bij}, we can write +- $$ y \Psi(y) = \hat \psi( \frac{1}{2\pi} \log y )$$ +- for all $y>0$ and some Schwartz function $\psi$. Making this substitution, the claim is then +- equivalent after standard manipulations to +- $$ \sum_{n=1}^\infty \frac{f(n)}{n} \hat \psi( \frac{1}{2\pi} \log \frac{n}{x} ) +- = A \int_{-\infty}^\infty \hat \psi(\frac{u}{2\pi})\ du + o(1)$$ +- and the claim follows from Lemma \ref{schwarz-id}. +- -/) +- (latexEnv := "corollary")] +-lemma wiener_ikehara_smooth (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hcheby : cheby f) ++theorem wiener_ikehara_smooth (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) + (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) + (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) + (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : + Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x - A * ∫ y in Set.Ioi 0, Ψ y) + atTop (𝓝 0) := by +- + let h (x : ℝ) : ℂ := rexp (2 * π * x) * Ψ (exp (2 * π * x)) + have h1 : ContDiff ℝ ∞ h := by + have : ContDiff ℝ ∞ (fun x : ℝ => (rexp (2 * π * x))) := (contDiff_const.mul contDiff_id).exp + exact (contDiff_ofReal.comp this).mul (hsmooth.comp this) + have h2 : HasCompactSupport h := by +- have : 2 * π ≠ 0 := by simp [pi_ne_zero] +- simpa using! (comp_exp_support hsupp hplus).comp_smul this |>.mul_left ++ have hπ : 2 * π ≠ 0 := by simp [pi_ne_zero] ++ have hh : HasCompactSupport (fun x : ℝ => Ψ (rexp (2 * π * x))) := by ++ simpa only [Function.comp_def, smul_eq_mul] using ++ (comp_exp_support hsupp hplus).comp_smul hπ ++ change HasCompactSupport ++ ((fun x : ℝ => (rexp (2 * π * x) : ℂ)) * fun x : ℝ => Ψ (rexp (2 * π * x))) ++ exact hh.mul_left + obtain ⟨g, hg⟩ := fourier_surjection_on_schwartz (toSchwartz h h1 h2) +- + have l1 {y} (hy : 0 < y) : y * Ψ y = 𝓕 g (1 / (2 * π) * Real.log y) := by +- simp only [one_div, mul_inv_rev, hg, toSchwartz, ofReal_exp, ofReal_mul, ofReal_ofNat, +- toSchwartz_apply, ofReal_inv, h] +- field_simp +- norm_cast +- rw [Real.exp_log hy] +- ++ rw [hg] ++ change (y : ℂ) * Ψ y = h (1 / (2 * π) * Real.log y) ++ have harg : 2 * π * (1 / (2 * π) * Real.log y) = Real.log y := by ++ rw [← mul_assoc, mul_one_div_cancel (mul_ne_zero (by norm_num) pi_ne_zero), one_mul] ++ dsimp only [h] ++ rw [harg, Real.exp_log hy] + have key := limiting_cor_schwartz g hf hcheby hG hG' +- + have l2 : ∀ᶠ x in atTop, ∑' (n : ℕ), f n / ↑n * 𝓕 g (1 / (2 * π) * Real.log (↑n / x)) = + ∑' (n : ℕ), f n * Ψ (↑n / x) / x := by + filter_upwards [eventually_gt_atTop 0] with x hx +@@ -2000,26 +1660,25 @@ lemma wiener_ikehara_smooth (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f + have : (x : ℂ) ≠ 0 := by simpa using hx.ne.symm + simp only [ofReal_div, ofReal_natCast] + field_simp +- + have l3 : ∀ᶠ x in atTop, ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 g (u / (2 * π)) = + ↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y := by + filter_upwards [eventually_gt_atTop 0] with x hx + congr 1 +- simp only [hg, toSchwartz, ofReal_exp, ofReal_mul, ofReal_ofNat, toSchwartz_apply, +- ofReal_div, h] +- norm_cast ; field_simp; norm_cast ++ rw [hg] ++ change (∫ u in Ici (-Real.log x), h (u / (2 * π))) = ∫ y in Ioi x⁻¹, Ψ y ++ dsimp only [h] ++ have hscale : (2 : ℝ) * π ≠ 0 := mul_ne_zero (by norm_num) pi_ne_zero ++ have harg (u : ℝ) : 2 * π * (u / (2 * π)) = u := mul_div_cancel₀ u hscale ++ simp_rw [harg] + rw [MeasureTheory.integral_Ici_eq_integral_Ioi] +- exact wiener_ikehara_smooth_aux hsmooth.continuous hsupp hplus x hx +- ++ simpa only [one_div] using wiener_ikehara_smooth_aux hsmooth.continuous hsupp hplus x hx + have l4 : Tendsto (fun x => (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) + atTop (𝓝 0) := by + exact wiener_ikehara_smooth_sub (hsmooth.continuous.integrable_of_hasCompactSupport hsupp) hplus +- + simpa [tsum_div_const] using (key.congr' <| EventuallyEq.sub l2 l3) |>.add l4 + +- +- +-lemma wiener_ikehara_smooth' (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hcheby : cheby f) ++theorem wiener_ikehara_smooth' (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) + (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) + (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) +@@ -2033,14 +1692,14 @@ local instance {E : Type*} : Coe (E → ℝ) (E → ℂ) := ⟨fun f n => f n⟩ + theorem set_integral_ofReal {f : ℝ → ℝ} {s : Set ℝ} : ∫ x in s, (f x : ℂ) = ∫ x in s, f x := + integral_ofReal + +-lemma wiener_ikehara_smooth_real {f : ℕ → ℝ} {Ψ : ℝ → ℝ} ++theorem wiener_ikehara_smooth_real {f : ℕ → ℝ} {Ψ : ℝ → ℝ} + (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) + (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) + (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : + Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x) atTop (nhds (A * ∫ y in Set.Ioi 0, Ψ y)) := by +- + let Ψ' := ofReal ∘ Ψ + have l1 : ContDiff ℝ ∞ Ψ' := contDiff_ofReal.comp hsmooth + have l2 : HasCompactSupport Ψ' := hsupp.comp_left rfl +@@ -2049,11 +1708,10 @@ lemma wiener_ikehara_smooth_real {f : ℕ → ℝ} {Ψ : ℝ → ℝ} + (@wiener_ikehara_smooth' A Ψ G f hf hcheby hG hG' l1 l2 l3) + simp at key ; norm_cast at key + +-lemma interval_approx_inf (ha : 0 < a) (hab : a < b) : ++theorem interval_approx_inf (ha : 0 < a) (hab : a < b) : + ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ + closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ + ψ ≤ indicator (Ico a b) 1 ∧ b - a - ε ≤ ∫ y in Ioi 0, ψ y := by +- + have l1 : Iio ((b - a) / 3) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds <| by + rw [← sub_pos] at hab + positivity +@@ -2083,11 +1741,10 @@ lemma interval_approx_inf (ha : 0 < a) (hab : a < b) : + apply integrableOn_const <;> + simp + +-lemma interval_approx_sup (ha : 0 < a) (hab : a < b) : ++theorem interval_approx_sup (ha : 0 < a) (hab : a < b) : + ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ + closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ + indicator (Ico a b) 1 ≤ ψ ∧ ∫ y in Ioi 0, ψ y ≤ b - a + ε := by +- + have l1 : Iio (a / 2) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds (by linarith) + filter_upwards [self_mem_nhdsWithin, l1] with ε (hε : 0 < ε) (hε' : ε < a / 2) + have l2 : a - ε / 2 < a := by linarith +@@ -2101,12 +1758,14 @@ lemma interval_approx_sup (ha : 0 < a) (hab : a < b) : + apply indicator_le_indicator_of_subset Ico_subset_Icc_self (by simp) + · have l4 : 0 ≤ b - a + ε := by linarith + have l5 : Ioo (a - ε / 2) (b + ε / 2) ⊆ Ioi 0 := by intro t ht ; simp at ht ⊢ ; linarith +- have l6 : Ioo (a - ε / 2) (b + ε / 2) ∩ Ioi 0 = Ioo (a - ε / 2) (b + ε / 2) := inter_eq_left.mpr l5 ++ have l6 : Ioo (a - ε / 2) (b + ε / 2) ∩ Ioi 0 = Ioo (a - ε / 2) (b + ε / 2) := ++ inter_eq_left.mpr l5 + have l7 : ∫ y in Ioi 0, indicator (Ioo (a - ε / 2) (b + ε / 2)) 1 y = b - a + ε := by + simp only [measurableSet_Ioo, integral_indicator_one, measureReal_restrict_apply, l6, + volume_real_Ioo] + convert max_eq_left l4 using 1 ; ring_nf +- have l8 : IntegrableOn ψ (Ioi 0) volume := (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ have l8 : IntegrableOn ψ (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn + rw [← l7] + refine setIntegral_mono l8 ?_ h4 + rw [IntegrableOn, integrable_indicator_iff measurableSet_Ioo] +@@ -2114,7 +1773,7 @@ lemma interval_approx_sup (ha : 0 < a) (hab : a < b) : + apply integrableOn_const <;> + simp + +-lemma WI_summable {f : ℕ → ℝ} {g : ℝ → ℝ} (hg : HasCompactSupport g) (hx : 0 < x) : ++theorem WI_summable {f : ℕ → ℝ} {g : ℝ → ℝ} (hg : HasCompactSupport g) (hx : 0 < x) : + Summable (fun n => f n * g (n / x)) := by + obtain ⟨M, hM⟩ := hg.bddAbove.mono subset_closure + apply summable_of_hasFiniteSupport +@@ -2122,21 +1781,24 @@ lemma WI_summable {f : ℕ → ℝ} {g : ℝ → ℝ} (hg : HasCompactSupport g) + simp only [Function.support_mul] ; apply Finite.inter_of_right ; rw [finite_iff_bddAbove] + exact ⟨Nat.ceil (M * x), fun i hi => by simpa using Nat.ceil_mono ((div_le_iff₀ hx).mp (hM hi))⟩ + +-lemma WI_sum_le {f : ℕ → ℝ} {g₁ g₂ : ℝ → ℝ} (hf : 0 ≤ f) (hg : g₁ ≤ g₂) (hx : 0 < x) ++theorem WI_sum_le {f : ℕ → ℝ} {g₁ g₂ : ℝ → ℝ} (hf : 0 ≤ f) (hg : g₁ ≤ g₂) (hx : 0 < x) + (hg₁ : HasCompactSupport g₁) (hg₂ : HasCompactSupport g₂) : + (∑' n, f n * g₁ (n / x)) / x ≤ (∑' n, f n * g₂ (n / x)) / x := by + apply div_le_div_of_nonneg_right ?_ hx.le + exact Summable.tsum_le_tsum (fun n => mul_le_mul_of_nonneg_left (hg _) (hf _)) + (WI_summable hg₁ hx) (WI_summable hg₂ hx) + +-lemma WI_sum_Iab_le {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} (hcheby : chebyWith C f) (hb : 0 < b) (hxb : 2 / b < x) : ++theorem WI_sum_Iab_le {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hb : 0 < b) (hxb : 2 / b < x) : + (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by + have hb' : 0 < 2 / b := by positivity + have hx : 0 < x := by linarith + have hxb' : 2 < x * b := (div_lt_iff₀ hb).mp hxb + have l1 (i : ℕ) (hi : i ∉ Finset.range ⌈b * x⌉₊) : f i * indicator (Ico a b) 1 (i / x) = 0 := by + simp_all [le_div_iff₀ hx] +- have l2 (i : ℕ) (_ : i ∈ Finset.range ⌈b * x⌉₊) : f i * indicator (Ico a b) 1 (i / x) ≤ |f i| := by ++ have l2 (i : ℕ) (_ : i ∈ Finset.range ⌈b * x⌉₊) : ++ f i * indicator (Ico a b) 1 (i / x) ≤ |f i| := by + rw [abs_eq_self.mpr (hpos _)] + convert_to _ ≤ f i * 1 + · ring +@@ -2151,29 +1813,21 @@ lemma WI_sum_Iab_le {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} (hcheby : cheby + apply (Nat.ceil_lt_add_one (by positivity)).le.trans + linarith + +-lemma WI_sum_Iab_le' {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} (hcheby : chebyWith C f) (hb : 0 < b) : ++theorem WI_sum_Iab_le' {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hb : 0 < b) : + ∀ᶠ x : ℝ in atTop, (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by + filter_upwards [eventually_gt_atTop (2 / b)] with x hx using WI_sum_Iab_le hpos hcheby hb hx + +-lemma le_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[>] b, a ≤ c) : a ≤ b := by +- apply le_of_forall_gt ; intro d hd +- have key : ∀ᶠ c in 𝓝[>] b, c < d := by +- apply eventually_of_mem (U := Iio d) ?_ (fun x hx => hx) +- rw [mem_nhdsWithin] +- refine ⟨Iio d, isOpen_Iio, hd, inter_subset_left⟩ +- obtain ⟨x, h1, h2⟩ := (h.and key).exists +- linarith ++theorem le_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[>] b, a ≤ c) : a ≤ b := by ++ exact ge_of_tendsto ++ (show Tendsto (fun c : ℝ => c) (𝓝[>] b) (𝓝 b) from nhdsWithin_le_nhds) h + +-lemma ge_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[<] b, c ≤ a) : b ≤ a := by +- apply le_of_forall_lt ; intro d hd +- have key : ∀ᶠ c in 𝓝[<] b, c > d := by +- apply eventually_of_mem (U := Ioi d) ?_ (fun x hx => hx) +- rw [mem_nhdsWithin] +- refine ⟨Ioi d, isOpen_Ioi, hd, inter_subset_left⟩ +- obtain ⟨x, h1, h2⟩ := (h.and key).exists +- linarith ++theorem ge_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[<] b, c ≤ a) : b ≤ a := by ++ exact le_of_tendsto ++ (show Tendsto (fun c : ℝ => c) (𝓝[<] b) (𝓝 b) from nhdsWithin_le_nhds) h + +-lemma WI_tendsto_aux (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++theorem WI_tendsto_aux (a b : ℝ) {A : ℝ} (hA : 0 < A) : + Tendsto (fun c => c / A - (b - a)) (𝓝[>] (A * (b - a))) (𝓝[>] 0) := by + rw [Metric.tendsto_nhdsWithin_nhdsWithin] + intro ε hε +@@ -2186,7 +1840,7 @@ lemma WI_tendsto_aux (a b : ℝ) {A : ℝ} (hA : 0 < A) : + rw [← abs_eq_self.mpr hA.le, ← abs_div, abs_eq_self.mpr hA.le] ; congr ; field_simp + rwa [this, div_lt_iff₀' hA] + +-lemma WI_tendsto_aux' (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++theorem WI_tendsto_aux' (a b : ℝ) {A : ℝ} (hA : 0 < A) : + Tendsto (fun c => (b - a) - c / A) (𝓝[<] (A * (b - a))) (𝓝[>] 0) := by + rw [Metric.tendsto_nhdsWithin_nhdsWithin] + intro ε hε +@@ -2200,8 +1854,11 @@ lemma WI_tendsto_aux' (a b : ℝ) {A : ℝ} (hA : 0 < A) : + rwa [this, div_lt_iff₀' hA, ← neg_sub, abs_neg] + + theorem residue_nonneg {f : ℕ → ℝ} (hpos : 0 ≤ f) +- (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm (fun n ↦ ↑(f n)) σ')) (hcheby : cheby fun n ↦ ↑(f n)) +- (hG : ContinuousOn G {s | 1 ≤ s.re}) (hG' : EqOn G (fun s ↦ LSeries (fun n ↦ ↑(f n)) s - ↑A / (s - 1)) {s | 1 < s.re}) : 0 ≤ A := by ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm (fun n ↦ ↑(f n)) σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : EqOn G (fun s ↦ LSeries (fun n ↦ ↑(f n)) s - ↑A / (s - 1)) {s | 1 < s.re}) : ++ 0 ≤ A := by + let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x + have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by + filter_upwards [eventually_ge_atTop 0] with x hx +@@ -2215,37 +1872,29 @@ theorem residue_nonneg {f : ℕ → ℝ} (hpos : 0 ≤ f) + have r1 : 0 ≤ᵐ[Measure.restrict volume (Ioi 0)] ψ := Eventually.of_forall l2 + have r2 : IntegrableOn (fun y ↦ ψ y) (Ioi 0) volume := + (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn +- have r3 : Ico 1 2 ⊆ Function.support ψ := by intro x hx ; have := h4 x ; simp [hx] at this ⊢ ; linarith ++ have r3 : Ico 1 2 ⊆ Function.support ψ := by ++ intro x hx ; have := h4 x ; simp [hx] at this ⊢ ; linarith + have r4 : Ico 1 2 ⊆ Function.support ψ ∩ Ioi 0 := by +- simp only [subset_inter_iff, r3, true_and] ; apply Ico_subset_Icc_self.trans ; rw [Icc_subset_Ioi_iff] <;> linarith +- have r5 : 1 ≤ volume ((Function.support fun y ↦ ψ y) ∩ Ioi 0) := by convert! volume.mono r4 ; norm_num +- simpa [setIntegral_pos_iff_support_of_nonneg_ae r1 r2] using! zero_lt_one.trans_le r5 ++ simp only [subset_inter_iff, r3, ++ true_and] ; apply Ico_subset_Icc_self.trans ; rw [Icc_subset_Ioi_iff] <;> linarith ++ have r5 : 1 ≤ volume ((Function.support fun y ↦ ψ y) ∩ Ioi 0) := by ++ convert volume.mono r4 ; norm_num ++ simpa [setIntegral_pos_iff_support_of_nonneg_ae r1 r2] using zero_lt_one.trans_le r5 + have := div_nonneg l3 l4.le ; field_simp at this ; exact this + +-blueprint_comment /-- +-Now we add the hypothesis that $f(n) \geq 0$ for all $n$. +- +--/ ++theorem WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * (indicator (Ico a b) 1 (n / x))) / x) ++ atTop (nhds (A * (b - a))) := by + +-@[blueprint +- (title := "Wiener-Ikehara in an interval") +- (statement := /-- +- For any closed interval $I \subset (0,+\infty)$, we have +- $$ \sum_{n=1}^\infty f(n) 1_I( \frac{n}{x} ) = A x |I| + o(x).$$ +- -/) +- (proof := /-- Use Lemma \ref{smooth-ury} to bound $1_I$ above and below by smooth compactly supported functions whose integral is close to the measure of $|I|$, and use the non-negativity of $f$. -/) +- (latexEnv := "proposition")] +-lemma WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) (ha : 0 < a) (hb : a ≤ b) : +- Tendsto (fun x : ℝ ↦ (∑' n, f n * (indicator (Ico a b) 1 (n / x))) / x) atTop (nhds (A * (b - a))) := by +- +- -- Take care of the trivial case `a = b` + by_cases hab : a = b + · simp [hab] + replace hb : a < b := lt_of_le_of_ne hb hab ; clear hab + +- -- Notation to make the proof more readable + let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x + have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by + filter_upwards [eventually_ge_atTop 0] with x hx +@@ -2253,10 +1902,10 @@ lemma WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : + refine tsum_nonneg (fun i => mul_nonneg (hpos _) (hg _)) + have hA : 0 ≤ A := residue_nonneg hpos hf hcheby hG hG' + +- -- A few facts about the indicator function of `Icc a b` + let Iab : ℝ → ℝ := indicator (Ico a b) 1 + change Tendsto (S Iab) atTop (𝓝 (A * (b - a))) +- have hIab : HasCompactSupport Iab := by simpa [Iab, HasCompactSupport, tsupport, hb.ne] using isCompact_Icc ++ have hIab : HasCompactSupport Iab := by ++ simpa [Iab, HasCompactSupport, tsupport, hb.ne] using isCompact_Icc + have Iab_nonneg : ∀ᶠ x : ℝ in atTop, 0 ≤ S Iab x := hSnonneg (indicator_nonneg (by simp)) + have Iab2 : IsBoundedUnder (· ≤ ·) atTop (S Iab) := by + obtain ⟨C, hC⟩ := hcheby ; exact ⟨C * 2 * b, WI_sum_Iab_le' hpos hC (by linarith)⟩ +@@ -2264,10 +1913,10 @@ lemma WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : + have Iab0 : IsCoboundedUnder (· ≥ ·) atTop (S Iab) := Iab2.isCoboundedUnder_ge + have Iab1 : IsCoboundedUnder (· ≤ ·) atTop (S Iab) := Iab3.isCoboundedUnder_le + +- -- Bound from above by a smooth function + have sup_le : limsup (S Iab) atTop ≤ A * (b - a) := by + have l_sup : ∀ᶠ ε in 𝓝[>] 0, limsup (S Iab) atTop ≤ A * (b - a + ε) := by +- filter_upwards [interval_approx_sup ha hb] with ε ⟨ψ, h1, h2, h3, h4, h6⟩ ++ filter_upwards [interval_approx_sup ha hb] with ε happrox ++ rcases happrox with ⟨ψ, h1, h2, h3, h4, h6⟩ + have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 + have l6 : S Iab ≤ᶠ[atTop] S ψ := by + filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h4 hx hIab h2 +@@ -2281,10 +1930,10 @@ lemma WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : + filter_upwards [WI_tendsto_aux a b key l_sup] with x hx + simpa [mul_div_cancel₀ _ h] using hx + +- -- Bound from below by a smooth function + have le_inf : A * (b - a) ≤ liminf (S Iab) atTop := by + have l_inf : ∀ᶠ ε in 𝓝[>] 0, A * (b - a - ε) ≤ liminf (S Iab) atTop := by +- filter_upwards [interval_approx_inf ha hb] with ε ⟨ψ, h1, h2, h3, h5, h6⟩ ++ filter_upwards [interval_approx_inf ha hb] with ε happrox ++ rcases happrox with ⟨ψ, h1, h2, h3, h5, h6⟩ + have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 + have l2 : S ψ ≤ᶠ[atTop] S Iab := by + filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h5 hx h2 hIab +@@ -2298,63 +1947,66 @@ lemma WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : + filter_upwards [WI_tendsto_aux' a b key l_inf] with x hx + simpa [mul_div_cancel₀ _ h] using hx + +- -- Combine the two bounds + have : liminf (S Iab) atTop ≤ limsup (S Iab) atTop := liminf_le_limsup Iab2 Iab3 + refine tendsto_of_liminf_eq_limsup ?_ ?_ Iab2 Iab3 <;> linarith + +- +- +-lemma le_floor_mul_iff (hb : 0 ≤ b) (hx : 0 < x) : n ≤ ⌊b * x⌋₊ ↔ n / x ≤ b := by ++theorem le_floor_mul_iff (hb : 0 ≤ b) (hx : 0 < x) : n ≤ ⌊b * x⌋₊ ↔ n / x ≤ b := by + rw [div_le_iff₀ hx, Nat.le_floor_iff] ; positivity + +-lemma lt_ceil_mul_iff (hx : 0 < x) : n < ⌈b * x⌉₊ ↔ n / x < b := by ++theorem lt_ceil_mul_iff (hx : 0 < x) : n < ⌈b * x⌉₊ ↔ n / x < b := by + rw [div_lt_iff₀ hx, Nat.lt_ceil] + +-lemma ceil_mul_le_iff (hx : 0 < x) : ⌈a * x⌉₊ ≤ n ↔ a ≤ n / x := by ++theorem ceil_mul_le_iff (hx : 0 < x) : ⌈a * x⌉₊ ≤ n ↔ a ≤ n / x := by + rw [le_div_iff₀ hx, Nat.ceil_le] + +-lemma mem_Icc_iff_div (hb : 0 ≤ b) (hx : 0 < x) : n ∈ Finset.Icc ⌈a * x⌉₊ ⌊b * x⌋₊ ↔ n / x ∈ Icc a b := by ++theorem mem_Icc_iff_div (hb : 0 ≤ b) (hx : 0 < x) : ++ n ∈ Finset.Icc ⌈a * x⌉₊ ⌊b * x⌋₊ ↔ n / x ∈ Icc a b := by + rw [Finset.mem_Icc, mem_Icc, ceil_mul_le_iff hx, le_floor_mul_iff hb hx] + +-lemma mem_Ico_iff_div (hx : 0 < x) : n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊ ↔ n / x ∈ Ico a b := by ++theorem mem_Ico_iff_div (hx : 0 < x) : n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊ ↔ n / x ∈ Ico a b := by + rw [Finset.mem_Ico, mem_Ico, ceil_mul_le_iff hx, lt_ceil_mul_iff hx] + +-lemma tsum_indicator {f : ℕ → ℝ} (hx : 0 < x) : ++theorem tsum_indicator {f : ℕ → ℝ} (hx : 0 < x) : + ∑' n, f n * (indicator (Ico a b) 1 (n / x)) = ∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n := by + have l1 : ∀ n ∉ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n * indicator (Ico a b) 1 (↑n / x) = 0 := by + simp [mem_Ico_iff_div hx] ; tauto +- rw [tsum_eq_sum l1] ; apply Finset.sum_congr rfl ; simp only [mem_Ico_iff_div hx] ; intro n hn ; simp [hn] ++ rw [tsum_eq_sum l1] ; apply Finset.sum_congr rfl ; simp only ++ [mem_Ico_iff_div hx] ; intro n hn ; simp [hn] + +-lemma WienerIkeharaInterval_discrete {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) (ha : 0 < a) (hb : a ≤ b) : +- Tendsto (fun x : ℝ ↦ (∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n) / x) atTop (nhds (A * (b - a))) := by ++theorem WienerIkeharaInterval_discrete {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n) / x) ++ atTop (nhds (A * (b - a))) := by + apply (WienerIkeharaInterval hpos hf hcheby hG hG' ha hb).congr' + filter_upwards [eventually_gt_atTop 0] with x hx + rw [tsum_indicator hx] + +-lemma WienerIkeharaInterval_discrete' {f : ℕ → ℝ} (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) (ha : 0 < a) (hb : a ≤ b) : +- Tendsto (fun N : ℕ ↦ (∑ n ∈ Finset.Ico ⌈a * N⌉₊ ⌈b * N⌉₊, f n) / N) atTop (nhds (A * (b - a))) := ++theorem WienerIkeharaInterval_discrete' {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun N : ℕ ↦ (∑ n ∈ Finset.Ico ⌈a * N⌉₊ ⌈b * N⌉₊, f n) / N) ++ atTop (nhds (A * (b - a))) := + WienerIkeharaInterval_discrete hpos hf hcheby hG hG' ha hb |>.comp tendsto_natCast_atTop_atTop + +--- TODO with `Ico` +- +- +- +-/-- A version of the *Wiener-Ikehara Tauberian Theorem*: If `f` is a nonnegative arithmetic +-function whose L-series has a simple pole at `s = 1` with residue `A` and otherwise extends +-continuously to the closed half-plane `re s ≥ 1`, then `∑ n < N, f n` is asymptotic to `A*N`. -/ +- +-lemma tendsto_mul_ceil_div : ++theorem tendsto_mul_ceil_div : + Tendsto (fun (p : ℝ × ℕ) => ⌈p.1 * p.2⌉₊ / (p.2 : ℝ)) (𝓝[>] 0 ×ˢ atTop) (𝓝 0) := by + rw [Metric.tendsto_nhds] ; intro δ hδ +- have l1 : ∀ᶠ ε : ℝ in 𝓝[>] 0, ε ∈ Ioo 0 (δ / 2) := inter_mem_nhdsWithin _ (Iio_mem_nhds (by positivity)) ++ have l1 : ∀ᶠ ε : ℝ in 𝓝[>] 0, ε ∈ Ioo 0 (δ / 2) := ++ inter_mem_nhdsWithin _ (Iio_mem_nhds (by positivity)) + have l2 : ∀ᶠ N : ℕ in atTop, 1 ≤ δ / 2 * N := by + apply Tendsto.eventually_ge_atTop + exact tendsto_natCast_atTop_atTop.const_mul_atTop (by positivity) +- filter_upwards [l1.prod_mk l2] with (ε, N) ⟨⟨hε, h1⟩, h2⟩ ; dsimp only at * ++ filter_upwards [l1.prod_mk l2] with p hp ++ rcases p with ⟨ε, N⟩ ++ rcases hp with ⟨⟨hε, h1⟩, h2⟩ ++ dsimp only at * + have l3 : 0 < (N : ℝ) := by + simp only [Nat.cast_pos, Nat.pos_iff_ne_zero] ; rintro rfl ; simp [zero_lt_one.not_ge] at h2 + have l5 : 0 ≤ ε * ↑N := by positivity +@@ -2364,19 +2016,20 @@ lemma tendsto_mul_ceil_div : + + noncomputable def S (f : ℕ → 𝕜) (ε : ℝ) (N : ℕ) : 𝕜 := (∑ n ∈ Finset.Ico ⌈ε * N⌉₊ N, f n) / N + +-lemma S_sub_S {f : ℕ → 𝕜} {ε : ℝ} {N : ℕ} (hε : ε ≤ 1) : S f 0 N - S f ε N = cumsum f ⌈ε * N⌉₊ / N := by +- have hceilN : ⌈ε * N⌉₊ ≤ N := by ++theorem S_sub_S {f : ℕ → 𝕜} {ε : ℝ} {N : ℕ} (hε : ε ≤ 1) : ++ S f 0 N - S f ε N = cumsum f ⌈ε * N⌉₊ / N := by ++ have r1 : Finset.range N = Finset.range ⌈ε * N⌉₊ ∪ Finset.Ico ⌈ε * N⌉₊ N := by ++ simp_rw [Finset.range_eq_Ico] ++ symm ++ apply Finset.Ico_union_Ico_eq_Ico (Nat.zero_le _) + simp only [Nat.ceil_le] + exact mul_le_of_le_one_left N.cast_nonneg hε +- have r1 : Finset.range N = Finset.range ⌈ε * N⌉₊ ∪ Finset.Ico ⌈ε * N⌉₊ N := by +- ext n +- simp only [Finset.mem_range, Finset.mem_union, Finset.mem_Ico] +- omega + have r2 : Disjoint (Finset.range ⌈ε * N⌉₊) (Finset.Ico ⌈ε * N⌉₊ N) := by + rw [Finset.range_eq_Ico] ; apply Finset.Ico_disjoint_Ico_consecutive + simp [S, r1, Finset.sum_union r2, cumsum, add_div] + +-lemma tendsto_S_S_zero {f : ℕ → ℝ} (hpos : 0 ≤ f) (hcheby : cheby f) : ++theorem tendsto_S_S_zero {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : + TendstoUniformlyOnFilter (S f) (S f 0) (𝓝[>] 0) atTop := by + rw [Metric.tendstoUniformlyOnFilter_iff] ; intro δ hδ + obtain ⟨C, hC⟩ := hcheby +@@ -2384,40 +2037,34 @@ lemma tendsto_S_S_zero {f : ℕ → ℝ} (hpos : 0 ≤ f) (hcheby : cheby f) : + have r1 := tendsto_mul_ceil_div.const_mul C + simp only [mul_div_assoc', mul_zero] at r1 ; exact r1 (Iio_mem_nhds hδ) + have : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) +- filter_upwards [l1, Eventually.prod_inl this _] with (ε, N) h1 h2 ++ filter_upwards [l1, Eventually.prod_inl this _] with p h1 h2 ++ rcases p with ⟨ε, N⟩ + have l2 : ‖cumsum f ⌈ε * ↑N⌉₊ / ↑N‖ ≤ C * ⌈ε * N⌉₊ / N := by + have r1 := hC ⌈ε * N⌉₊ + have r2 : 0 ≤ cumsum f ⌈ε * N⌉₊ := by apply cumsum_nonneg hpos + simp only [norm_real, norm_of_nonneg (hpos _), norm_div, + norm_of_nonneg r2, Real.norm_natCast] at r1 ⊢ + apply div_le_div_of_nonneg_right r1 (by positivity) +- simpa [← S_sub_S h2.2] using! l2.trans_lt h1 +- +-@[blueprint "WienerIkehara" +- (title := "Wiener-Ikehara Theorem (1)") +- (statement := /-- +- We have +- $$ \sum_{n\leq x} f(n) = A x + o(x).$$ +- -/) +- (proof := /-- Apply the preceding proposition with $I = [\varepsilon,1]$ and then send +- $\varepsilon$ to zero (using \eqref{cheby} to control the error). -/) +- (latexEnv := "corollary")] ++ simpa [dist_eq_norm, ← S_sub_S h2.2] using l2.trans_lt h1 ++ + theorem WienerIkeharaTheorem' {f : ℕ → ℝ} (hpos : 0 ≤ f) + (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hcheby : cheby f) (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) + (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : + Tendsto (fun N => cumsum f N / N) atTop (𝓝 A) := by +- + convert_to Tendsto (S f 0) atTop (𝓝 A) ; · ext N ; simp [S, cumsum] + apply (tendsto_S_S_zero hpos hcheby).tendsto_of_eventually_tendsto + · have L0 : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) + apply eventually_of_mem L0 + · intro ε hε +- simpa using! WienerIkeharaInterval_discrete' hpos hf hcheby hG hG' hε.1 hε.2 ++ convert WienerIkeharaInterval_discrete' hpos hf hcheby hG hG' hε.1 hε.2 using 1 ++ funext N ++ simp only [S, one_mul, Nat.ceil_natCast] + · have : Tendsto (fun ε : ℝ => ε) (𝓝[>] 0) (𝓝 0) := nhdsWithin_le_nhds + simpa using (this.const_sub 1).const_mul A + +-theorem vonMangoldt_cheby : cheby Λ := by ++theorem vonMangoldt_cheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(Λ k : ℂ)‖) n ≤ C * n) := by + use Real.log 4 + 4 + intro N + by_cases! h : N = 0 +@@ -2430,1956 +2077,20 @@ theorem vonMangoldt_cheby : cheby Λ := by + gcongr + linarith + +-blueprint_comment /-- +-\section{Weak PNT} +- +--/ +- +--- Proof extracted from the `EulerProducts` project so we can adapt it to the +--- version of the Wiener-Ikehara theorem proved above (with the `cheby` +--- hypothesis) +- +-@[blueprint +- (title := "WeakPNT") +- (statement := /-- +- We have +- $$ \sum_{n \leq x} \Lambda(n) = x + o(x).$$ +- -/) +- (proof := /-- Already done by Stoll, assuming Wiener-Ikehara. -/)] + theorem WeakPNT : Tendsto (fun N ↦ cumsum Λ N / N) atTop (𝓝 1) := by + let F := vonMangoldt.LFunctionResidueClassAux (q := 1) 1 +- have hnv := riemannZeta_ne_zero_of_one_le_re + have l1 (n : ℕ) : 0 ≤ Λ n := vonMangoldt_nonneg + have l2 s (hs : 1 < s.re) : F s = LSeries Λ s - 1 / (s - 1) := by + have := vonMangoldt.eqOn_LFunctionResidueClassAux (q := 1) isUnit_one hs +- simp only [F, this, vonMangoldt.residueClass, Nat.totient_one, Nat.cast_one, inv_one, one_div, sub_left_inj] ++ simp only [F, this, vonMangoldt.residueClass, Nat.totient_one, Nat.cast_one, ++ inv_one, one_div, sub_left_inj] + apply LSeries_congr + intro n _ +- simp only [ofReal_inj, indicator_apply_eq_self, mem_ofPred_eq] ++ simp only [ofReal_inj, indicator_apply_eq_self, Set.mem_ofPred_eq] + exact fun hn ↦ absurd (Subsingleton.eq_one _) hn + have l3 : ContinuousOn F {s | 1 ≤ s.re} := vonMangoldt.continuousOn_LFunctionResidueClassAux 1 +- have l4 : cheby Λ := vonMangoldt_cheby ++ have l4 : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(Λ k : ℂ)‖) n ≤ C * n) := vonMangoldt_cheby + have l5 (σ' : ℝ) (hσ' : 1 < σ') : Summable (nterm Λ σ') := by +- simpa only [← nterm_eq_norm_term] using (@ArithmeticFunction.LSeriesSummable_vonMangoldt σ' hσ').norm ++ simpa only [← nterm_eq_norm_term] ++ using (@ArithmeticFunction.LSeriesSummable_vonMangoldt σ' hσ').norm + apply WienerIkeharaTheorem' l1 l5 l4 l3 l2 +- +--- #print axioms WeakPNT +- +-section auto_cheby +- +-variable {f : ℕ → ℝ} +- +-lemma norm_x_cpow_it (x t : ℝ) (hx : 0 < x) : ‖(x : ℂ) ^ (t * I)‖ = 1 := by +- rw [cpow_def_of_ne_zero <| ofReal_ne_zero.mpr hx.ne', ← ofReal_log hx.le] +- convert norm_exp_ofReal_mul_I (t * x.log) using 2 +- push_cast; ring_nf +- +-set_option backward.isDefEq.respectTransparency false in +-lemma limiting_fourier_aux_gt_zero (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) +- (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 0 < x) (σ' : ℝ) (hσ' : 1 < σ') : +- ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - +- A * (x ^ (1 - σ') : ℝ) * ∫ u in Ici (- log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = +- ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I) := by +- have hint : Integrable ψ := ψ.h1.continuous.integrable_of_hasCompactSupport ψ.h2 +- have l8 : Continuous fun t : ℝ ↦ (x : ℂ) ^ (t * I) := +- continuous_const.cpow (continuous_ofReal.mul continuous_const) (by simp [hx]) +- have l4 : Integrable fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := +- (((continuous_LSeries_aux (hf _ hσ')).mul ψ.h1.continuous).mul l8).integrable_of_hasCompactSupport +- ψ.h2.mul_left.mul_right +- have e2 (u : ℝ) : σ' + u * I - 1 ≠ 0 := fun h ↦ by +- have := congrArg Complex.re (sub_eq_zero.mp h); simp at this; linarith +- have l5 : Integrable fun a ↦ A * ↑(x ^ (1 - σ')) * +- (↑(x ^ (σ' - 1)) * (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by +- have : Continuous fun a ↦ A * ↑(x ^ (1 - σ')) * +- (↑(x ^ (σ' - 1)) * (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by +- simp only [one_div, ← mul_assoc] +- exact ((continuous_const.mul (Continuous.inv₀ (by fun_prop) e2)).mul ψ.h1.continuous).mul l8 +- exact this.integrable_of_hasCompactSupport ψ.h2.mul_left.mul_right.mul_left.mul_left +- simp_rw [first_fourier hf hint hx hσ', second_fourier ψ.h1.continuous.measurable hint hx hσ', +- ← integral_const_mul, ← integral_sub l4 l5] +- refine integral_congr_ae (.of_forall fun u ↦ ?_) +- have e1 : 1 < ((σ' : ℂ) + (u : ℂ) * I).re := by simp [hσ'] +- simp_rw [hG' e1, sub_mul, ← mul_assoc] +- simp only [one_div, sub_right_inj, mul_eq_mul_right_iff, cpow_eq_zero_iff, ofReal_eq_zero, ne_eq, +- mul_eq_zero, I_ne_zero, or_false] +- field_simp [e2]; norm_cast; simp [mul_assoc, ← rpow_add hx] +- +-theorem limiting_fourier_lim2_gt_zero (A : ℝ) (ψ : W21) (hx : 0 < x) : +- Tendsto (fun σ' ↦ A * ↑(x ^ (1 - σ')) * +- ∫ u in Ici (-Real.log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) +- (𝓝[>] 1) (𝓝 (A * ∫ u in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)))) := by +- obtain ⟨C, hC⟩ := decay_bounds_cor ψ +- refine Tendsto.mul ?_ (tendsto_integral_filter_of_dominated_convergence _ +- (.of_forall fun _ ↦ (by continuity : Continuous _).aestronglyMeasurable) ?_ +- (limiting_fourier_lim2_aux x C) (.of_forall fun u ↦ ?_)) +- · suffices Tendsto (fun σ' : ℝ ↦ x ^ (1 - σ')) (𝓝[>] 1) (𝓝 1) by +- simpa using ((continuous_ofReal.tendsto 1).comp this).const_mul ↑A +- have : Tendsto (fun σ' : ℝ ↦ 1 - σ') (𝓝[>] 1) (𝓝 0) := +- tendsto_nhdsWithin_of_tendsto_nhds (by simpa using (continuous_id.tendsto (1 : ℝ)).const_sub 1) +- simpa using tendsto_const_nhds.rpow this (Or.inl hx.ne') +- · refine eventually_of_mem (Ioo_mem_nhdsGT_of_mem (by norm_num : (1 : ℝ) ∈ Set.Ico 1 2)) fun σ' hσ' ↦ ?_ +- obtain ⟨h1, h2⟩ := hσ' +- rw [ae_restrict_iff' measurableSet_Ici] +- refine .of_forall fun t ht ↦ ?_ +- simp only [norm_mul, neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_sub, ofReal_one, +- norm_exp, neg_re, mul_re, ofReal_re, sub_re, one_re, ofReal_im, sub_im, one_im, +- sub_self, mul_zero, sub_zero] +- refine mul_le_mul ?_ (hC _) (norm_nonneg _) ((abs_nonneg x).trans (le_max_left _ _)) +- have hα0 : 0 ≤ σ' - 1 := by linarith +- have hα1 : σ' - 1 ≤ 1 := by linarith +- have hmul1 : (-x.log) * (σ' - 1) ≤ t * (σ' - 1) := mul_le_mul_of_nonneg_right ht hα0 +- calc Real.exp (-(t * (σ' - 1))) +- ≤ Real.exp (x.log * (σ' - 1)) := Real.exp_monotone (by linarith) +- _ ≤ max |x| 1 := by +- by_cases hx1 : 1 ≤ x +- · calc _ ≤ Real.exp x.log := +- Real.exp_monotone (mul_le_of_le_one_right (Real.log_nonneg hx1) hα1) +- _ = |x| := by rw [Real.exp_log hx, abs_of_pos hx] +- _ ≤ _ := le_max_left _ _ +- · calc _ ≤ 1 := (Real.exp_monotone (mul_nonpos_of_nonpos_of_nonneg +- ((Real.log_neg_iff hx).2 (by linarith)).le hα0)).trans_eq Real.exp_zero +- _ ≤ _ := le_max_right _ _ +- · suffices Tendsto (fun n ↦ ((rexp (-u * (n - 1))) : ℂ)) (𝓝[>] 1) (𝓝 1) by simpa using this.mul_const _ +- refine Tendsto.mono_left ?_ nhdsWithin_le_nhds +- have : Continuous (fun n ↦ ((rexp (-u * (n - 1))) : ℂ)) := by continuity +- simpa using this.tendsto 1 +- +-theorem limiting_fourier_lim3_gt_zero +- (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 ℂ) (hx : 0 < x) : +- Tendsto (fun σ' : ℝ ↦ ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I)) (𝓝[>] 1) +- (𝓝 (∫ t : ℝ, G (1 + t * I) * ψ t * x ^ (t * I))) := by +- by_cases hh : tsupport ψ = ∅ +- · simp [tsupport_eq_empty_iff.mp hh] +- obtain ⟨a₀, ha₀⟩ := Set.nonempty_iff_ne_empty.mpr hh +- let S : Set ℂ := reProdIm (Icc 1 2) (tsupport ψ) +- have l1 : IsCompact S := Metric.isCompact_iff_isClosed_bounded.mpr +- ⟨isClosed_Icc.reProdIm (isClosed_tsupport ψ), (Metric.isBounded_Icc 1 2).reProdIm ψ.h2.isBounded⟩ +- have l2 : S ⊆ {s : ℂ | 1 ≤ s.re} := fun z hz => (mem_reProdIm.mp hz).1.1 +- obtain ⟨z, -, hmax⟩ := l1.exists_isMaxOn ⟨1 + a₀ * I, by simp [S, mem_reProdIm, ha₀]⟩ (hG.mono l2).norm +- have hxC : (x : ℂ) ≠ 0 := ofReal_ne_zero.mpr hx.ne' +- refine tendsto_integral_filter_of_dominated_convergence (bound := fun a ↦ ‖G z‖ * ‖ψ a‖) +- (eventually_of_mem (Icc_mem_nhdsGT_of_mem (by norm_num : (1 : ℝ) ∈ Set.Ico 1 2)) fun u hu ↦ +- ((hG.comp_continuous (by fun_prop) (by simp [hu.1])).mul ψ.h1.continuous).mul +- (by simpa using Continuous.const_cpow (by fun_prop) (Or.inl hxC)) |>.aestronglyMeasurable) +- (eventually_of_mem (Icc_mem_nhdsGT_of_mem (by norm_num : (1 : ℝ) ∈ Set.Ico 1 2)) fun u hu ↦ +- .of_forall fun v ↦ ?_) +- ((continuous_const.mul ψ.h1.continuous.norm).integrable_of_hasCompactSupport ψ.h2.norm.mul_left) +- (.of_forall fun t ↦ ?_) +- · by_cases h : v ∈ tsupport ψ +- · simp_rw [norm_mul, norm_x_cpow_it x v hx, mul_one] +- exact mul_le_mul_of_nonneg_right (isMaxOn_iff.mp hmax _ (by simp [S, mem_reProdIm, hu.1, hu.2, h])) (norm_nonneg _) +- · have : v ∉ Function.support ψ := fun a ↦ h (subset_tsupport ψ a) +- simp [Function.notMem_support.mp this] +- · exact ((hG (1 + t * I) (by simp)).tendsto.comp <| tendsto_nhdsWithin_iff.mpr +- ⟨((continuous_ofReal.tendsto _).add tendsto_const_nhds).mono_left nhdsWithin_le_nhds, +- eventually_nhdsWithin_of_forall fun _ hx' ↦ by simp [(Set.mem_Ioi.mp hx').le]⟩).mul_const _ |>.mul_const _ +- +-lemma tendsto_tsum_of_monotone_convergence +- {β : Type*} {f : ℕ → β → ENNReal} {g : β → ENNReal} +- (hmono : ∀ k, Monotone (fun n => f n k)) +- (hlim : ∀ k, Tendsto (fun n => f n k) atTop (𝓝 (g k))) : +- Tendsto (fun n => ∑' k, f n k) atTop (𝓝 (∑' k, g k)) := by +- let : MeasurableSpace β := ⊤ +- let μ : Measure β := Measure.count +- have hg_iSup (k : β) : (⨆ n : ℕ, f n k) = g k := iSup_eq_of_tendsto (hmono k) (hlim k) +- have h_tend_lint : Tendsto (fun n => ∫⁻ k, f n k ∂μ) atTop (𝓝 (∫⁻ k, (⨆ n, f n k) ∂μ)) := by +- have hmeas : ∀ n, Measurable fun k : β => f n k := fun _ _ _ ↦ trivial +- have hmono_fn : Monotone (fun n => fun k : β => f n k) := fun _ _ hnm k ↦ hmono k hnm +- simpa [lintegral_iSup hmeas hmono_fn] using +- tendsto_atTop_iSup fun _ _ hmn ↦ lintegral_mono fun k ↦ hmono k hmn +- simpa [μ, lintegral_count, hg_iSup] using h_tend_lint +- +-lemma tendsto_tsum_of_monotone_convergence_nhdsGT_one +- {F : ℝ → ℕ → ℝ} +- (hF_nonneg : ∀ σ n, 0 ≤ F σ n) +- (hF_antitone : ∀ n, AntitoneOn (fun σ : ℝ => F σ n) (Set.Ioi (1 : ℝ))) +- (hF_tend : ∀ n, Tendsto (fun σ : ℝ => F σ n) (𝓝[>] (1 : ℝ)) (𝓝 (F 1 n))) +- (hSumm : ∀ σ, 1 < σ → Summable (fun n : ℕ => F σ n)) +- (hbounded : +- BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ : ℝ => (∑' n : ℕ, F σ n))) : +- Tendsto (fun σ : ℝ => ∑' n : ℕ, F σ n) (𝓝[>] (1 : ℝ)) (𝓝 (∑' n : ℕ, F 1 n)) := by +- let T : ℝ → ℝ := fun σ => ∑' n : ℕ, F σ n +- have hT_antitone : AntitoneOn T (Set.Ioi (1 : ℝ)) := fun a ha b hb hab ↦ +- (hSumm b hb).tsum_le_tsum_of_inj (fun n ↦ n) (fun _ _ h ↦ h) (fun c hc ↦ (hc ⟨c, rfl⟩).elim) +- (fun n ↦ hF_antitone n ha hb hab) (hSumm a ha) +- have hT_bdd : BddAbove (T '' Set.Ioi (1 : ℝ)) := by +- obtain ⟨C, hC⟩ := isBigO_iff.1 hbounded +- have hC' : ∀ᶠ σ : ℝ in 𝓝[>] (1 : ℝ), T σ ≤ C := by +- filter_upwards [hC] with σ hσ +- calc T σ ≤ |T σ| := le_abs_self _ +- _ = ‖T σ‖ := (Real.norm_eq_abs _).symm +- _ ≤ C * ‖(1 : ℝ → ℝ) σ‖ := hσ +- _ = C := by simp +- obtain ⟨U, hU, V, hV, hUV⟩ := Filter.mem_inf_iff_superset.1 hC' +- obtain ⟨ε, hε, hball⟩ := Metric.mem_nhds_iff.1 hU +- have hIoi_sub : Set.Ioi (1 : ℝ) ⊆ V := Filter.mem_principal.mp hV +- have hUsub : U ∩ Set.Ioi (1 : ℝ) ⊆ {σ : ℝ | T σ ≤ C} := fun σ hσ ↦ hUV ⟨hσ.1, hIoi_sub hσ.2⟩ +- have hσ0_Ioi : 1 + ε / 2 ∈ Set.Ioi (1 : ℝ) := by simp [half_pos hε] +- have hσ0_leC : T (1 + ε / 2) ≤ C := +- hUsub ⟨hball (by simp only [Metric.mem_ball, Real.dist_eq, add_sub_cancel_left, +- abs_of_pos (half_pos hε)]; exact half_lt_self hε), hσ0_Ioi⟩ +- refine ⟨C, ?_⟩ +- rintro _ ⟨σ, hσIoi, rfl⟩ +- by_cases hσlt : σ < 1 + ε / 2 +- · exact hUsub ⟨hball (by +- simp only [Metric.mem_ball, Real.dist_eq] +- rw [abs_of_pos (sub_pos.2 (Set.mem_Ioi.mp hσIoi))] +- linarith [half_lt_self hε]), hσIoi⟩ +- · exact (hT_antitone hσ0_Ioi hσIoi (le_of_not_gt hσlt)).trans hσ0_leC +- have hT_tend_sup : Tendsto T (𝓝[>] (1 : ℝ)) (𝓝 (sSup (T '' Set.Ioi (1 : ℝ)))) := +- hT_antitone.tendsto_nhdsGT hT_bdd +- let σseq : ℕ → ℝ := fun k => 1 + 1 / (k + 1 : ℝ) +- have hσseq_mem (k) : σseq k ∈ Set.Ioi (1 : ℝ) := by +- simp only [σseq, Set.mem_Ioi, lt_add_iff_pos_right] +- positivity +- have hσseq_tend_nhds : Tendsto σseq atTop (𝓝 (1 : ℝ)) := by +- have : Tendsto (fun k : ℕ => (1 : ℝ) + ((k + 1 : ℕ) : ℝ)⁻¹) atTop (𝓝 ((1 : ℝ) + 0)) := +- tendsto_const_nhds.add (tendsto_inv_atTop_nhds_zero_nat.comp (tendsto_add_atTop_nat 1)) +- simp only [add_zero] at this +- convert this using 1; ext k; simp [σseq, one_div] +- have hσseq_tend_nhdsWithin : Tendsto σseq atTop (𝓝[>] (1 : ℝ)) := +- tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ hσseq_tend_nhds +- (.of_forall hσseq_mem) +- have hσseq_antitone : Antitone σseq := fun k₁ k₂ hk ↦ by simp only [σseq]; gcongr +- have hmono_seq (n) : Monotone (fun k => F (σseq k) n) := fun k₁ k₂ hk ↦ +- hF_antitone n (hσseq_mem k₂) (hσseq_mem k₁) (hσseq_antitone hk) +- have htend_seq (n) : Tendsto (fun k => F (σseq k) n) atTop (𝓝 (F 1 n)) := +- (hF_tend n).comp hσseq_tend_nhdsWithin +- have hTseq : Tendsto (fun k : ℕ => T (σseq k)) atTop (𝓝 (T 1)) := by +- have hsum1 : Summable (fun n : ℕ => F (1 : ℝ) n) := by +- obtain ⟨C, hC⟩ := hT_bdd +- refine summable_of_sum_range_le (hF_nonneg 1) fun m ↦ le_of_tendsto +- (tendsto_finsetSum _ fun i _ ↦ hF_tend i) +- (eventually_of_mem self_mem_nhdsWithin fun σ hσ ↦ +- ((hSumm σ hσ).sum_le_tsum _ (fun n _ ↦ hF_nonneg σ n)).trans (hC ⟨σ, hσ, rfl⟩)) +- have hg_ne_top : (∑' n : ℕ, ENNReal.ofReal (F 1 n)) ≠ ⊤ := hsum1.tsum_ofReal_ne_top +- have hENN : Tendsto (fun k => ∑' n, ENNReal.ofReal (F (σseq k) n)) atTop +- (𝓝 (∑' n, ENNReal.ofReal (F 1 n))) := +- tendsto_tsum_of_monotone_convergence (fun n _ _ hk ↦ ENNReal.ofReal_le_ofReal (hmono_seq n hk)) +- (fun n ↦ ENNReal.tendsto_ofReal (htend_seq n)) +- have hrew (σ) : (∑' n, ENNReal.ofReal (F σ n)).toReal = ∑' n, F σ n := by +- rw [ENNReal.tsum_toReal_eq (fun n ↦ by simp)] +- exact tsum_congr fun n ↦ by simp [hF_nonneg σ n] +- simp only [T, ← hrew]; exact (ENNReal.tendsto_toReal hg_ne_top).comp hENN +- have hsSup_eq : sSup (T '' Set.Ioi (1 : ℝ)) = T 1 := +- tendsto_nhds_unique (hT_tend_sup.comp hσseq_tend_nhdsWithin) hTseq +- simpa [T, hsSup_eq] using hT_tend_sup +- +-lemma limiting_fourier_variant_lim1_aux +- {f : ℕ → ℝ} {x : ℝ} (ψ : CS 2 ℂ) +- (hpos : 0 ≤ f) +- (hf : ∀ (σ : ℝ), 1 < σ → Summable (nterm f σ)) +- (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) : +- ∀ (σ : ℝ), 1 < σ → +- Summable (fun n : ℕ => +- (if n = 0 then 0 else f n / ((n : ℝ) ^ σ)) * +- (𝓕 ψ.toFun (1 / (2 * π) * Real.log ((n : ℝ) / x))).re) := by +- intro σ hσ +- let y : ℕ → ℝ := fun n => (1 / (2 * π)) * Real.log ((n : ℝ) / x) +- let W : ℕ → ℝ := fun n => (𝓕 ψ.toFun (y n)).re +- let base : ℕ → ℝ := fun n => if n = 0 then 0 else f n / ((n : ℝ) ^ σ) +- obtain ⟨C, hC⟩ := decay_bounds_cor (W21.ofCS2 ψ) +- have hC_nonneg : 0 ≤ C := (norm_nonneg _).trans ((hC 0).trans (by simp)) +- have hW_nonneg (n : ℕ) : 0 ≤ W n := (hψpos (y n)).1 +- have hnorm_four (n : ℕ) : ‖𝓕 ψ.toFun (y n)‖ = W n := by +- have him0 : (𝓕 ψ.toFun (y n)).im = 0 := (hψpos (y n)).2 +- rw [show 𝓕 ψ.toFun (y n) = W n by exact Complex.ext rfl him0] +- simp [abs_of_nonneg (hW_nonneg n)] +- have hW_le_C (n : ℕ) : W n ≤ C := by +- rw [← hnorm_four]; exact (hC (y n)).trans (div_le_self hC_nonneg (by nlinarith [sq_nonneg (y n)])) +- have hbase_summ : Summable base := by +- convert hf σ hσ using 1; ext n +- by_cases hn : n = 0 <;> simp [nterm, base, hn, Real.norm_eq_abs, abs_of_nonneg (hpos n)] +- refine (hbase_summ.mul_left C).of_norm_bounded fun n ↦ ?_ +- by_cases hn : n = 0 +- · simp [base, hn] +- · have hnpos : 0 < (n : ℝ) := Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn) +- have hbase_nonneg : 0 ≤ base n := by +- simp only [base, hn, ite_false] +- exact div_nonneg (hpos n) (Real.rpow_pos_of_pos hnpos σ).le +- calc |base n * W n| = base n * W n := abs_of_nonneg (mul_nonneg hbase_nonneg (hW_nonneg n)) +- _ ≤ base n * C := mul_le_mul_of_nonneg_left (hW_le_C n) hbase_nonneg +- _ = C * base n := mul_comm _ _ +- +- +-theorem limiting_fourier_variant_lim1 +- {f : ℕ → ℝ} {x : ℝ} {ψ : CS 2 ℂ} +- (hpos : 0 ≤ f) +- (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) +- (S : ℝ → ℂ) +- (hSdef : +- ∀ σ' : ℝ, +- S σ' = +- ∑' n : ℕ, +- term (fun n ↦ (f n : ℂ)) (σ' : ℝ) n * +- 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x))) +- (hbounded : BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ' : ℝ => ‖S σ'‖)) +- (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) : +- Tendsto +- (fun σ' : ℝ => +- ∑' n : ℕ, +- term (fun n ↦ (f n : ℂ)) (σ' : ℝ) n * +- 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x))) +- (𝓝[>] (1 : ℝ)) +- (𝓝 +- (∑' n : ℕ, +- (f n : ℂ) / (n : ℂ) * +- 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x)))) := by +- +- let y : ℕ → ℝ := fun n => (π⁻¹ * 2⁻¹) * Real.log ((n : ℝ) / x) +- let w : ℕ → ℝ := fun n => (𝓕 ψ.toFun (y n)).re +- +- have hw_nonneg : ∀ n, 0 ≤ w n := by +- intro n +- exact (hψpos (y n)).1 +- +- have hFour_eq_ofReal : ∀ n, 𝓕 ψ.toFun (y n) = Complex.ofReal (w n) := by +- intro n +- have h := hψpos (y n) +- refine Complex.ext ?_ ?_ +- · simp [w] +- · simp [w, h.2] +- +- let rterm : ℝ → ℕ → ℝ := +- fun σ n => +- if h0 : n = 0 then 0 else (f n) / ((n : ℝ) ^ σ) * (w n) +- +- have summand_eq_ofReal : +- ∀ (σ : ℝ) (n : ℕ), +- term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n) +- = Complex.ofReal (rterm σ n) := by +- intro σ n +- by_cases hn : n = 0 +- · subst hn +- simp [rterm, y] +- · have hnpos : (0 : ℝ) < (n : ℝ) := by +- exact_mod_cast (Nat.pos_of_ne_zero hn) +- have hn0 : 0 ≤ (n : ℝ) := le_of_lt hnpos +- have hcpow : +- ( (n : ℂ) ^ ((σ : ℝ) : ℂ) ) = ( ( (n : ℝ) ^ σ : ℝ) : ℂ ) := by +- simpa using (Complex.ofReal_cpow hn0 σ).symm +- have hpow_ne : ((n : ℝ) ^ σ) ≠ 0 := by +- exact (ne_of_gt (Real.rpow_pos_of_pos hnpos σ)) +- calc +- term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n) +- = +- ((f n : ℂ) / ((n : ℂ) ^ ((σ : ℝ) : ℂ))) * ( (w n : ℝ) : ℂ ) := by +- simp [term, LSeries.term, hn, hFour_eq_ofReal] +- _ = +- ((f n : ℂ) / (((n : ℝ) ^ σ : ℝ) : ℂ)) * ((w n : ℝ) : ℂ) := by +- simp [hcpow] +- _ = +- (( (f n : ℝ) : ℂ) / (((n : ℝ) ^ σ : ℝ) : ℂ)) * ((w n : ℝ) : ℂ) := by +- simp +- _ = +- ( ( (f n : ℝ) / ((n : ℝ) ^ σ) : ℝ) : ℂ ) * ((w n : ℝ) : ℂ) := by +- simp [Complex.ofReal_div] +- _ = +- ( ( (f n : ℝ) / ((n : ℝ) ^ σ) * (w n) : ℝ ) : ℂ ) := by +- simp [Complex.ofReal_mul] +- _ = +- Complex.ofReal (rterm σ n) := by +- simp [rterm, hn] +- +- let T : ℝ → ℝ := fun σ => ∑' n, rterm σ n +- +- have tsum_eq_ofReal_T : ∀ σ : ℝ, +- (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) +- = Complex.ofReal (T σ) := by +- intro σ +- have hcongr : +- (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) +- = ∑' n : ℕ, (Complex.ofReal (rterm σ n)) := by +- refine tsum_congr ?_ +- intro n +- simpa using (summand_eq_ofReal σ n) +- +- calc +- (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) +- = ∑' n : ℕ, (Complex.ofReal (rterm σ n)) := hcongr +- _ = Complex.ofReal (∑' n : ℕ, rterm σ n) := by +- simpa using (Complex.ofReal_tsum (fun n : ℕ => rterm σ n)).symm +- _ = Complex.ofReal (T σ) := by rfl +- +- have hS_ofReal_T : ∀ σ : ℝ, S σ = Complex.ofReal (T σ) := by +- intro σ +- simpa [hSdef σ, y] using (tsum_eq_ofReal_T σ) +- +- have rterm_nonneg : ∀ σ n, 0 ≤ rterm σ n := by +- intro σ n +- by_cases hn : n = 0 +- · subst hn; simp [rterm] +- · have hf : 0 ≤ f n := hpos n +- have hw : 0 ≤ w n := hw_nonneg n +- have hnpos : 0 < (n : ℝ) := by +- exact_mod_cast (Nat.pos_of_ne_zero hn) +- have hden : 0 < (n : ℝ) ^ σ := Real.rpow_pos_of_pos hnpos σ +- have : 0 ≤ (f n) / ((n : ℝ) ^ σ) := div_nonneg hf (le_of_lt hden) +- simp [rterm, hn, mul_nonneg this hw] +- +- have T_nonneg : ∀ σ, 0 ≤ T σ := by +- intro σ +- exact tsum_nonneg (fun n => rterm_nonneg σ n) +- +- have hT_eq_normS : ∀ σ, T σ = ‖S σ‖ := by +- intro σ +- have := hS_ofReal_T σ +- calc +- T σ = ‖Complex.ofReal (T σ)‖ := by simp [abs_of_nonneg (T_nonneg σ)] +- _ = ‖S σ‖ := by simp [this] +- +- have hboundedT : BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ : ℝ => T σ) := by +- have : (fun σ : ℝ => T σ) = (fun σ : ℝ => ‖S σ‖) := by +- funext σ; exact hT_eq_normS σ +- simpa [this] using hbounded +- +- have rterm_antitone : ∀ n, AntitoneOn (fun σ => rterm σ n) (Set.Ioi 1) := by +- intro n σ₁ hσ₁ σ₂ hσ₂ hσ₁₂ +- by_cases hn : n = 0 +- · subst hn; simp [rterm] +- · have hf : 0 ≤ f n := hpos n +- have hw : 0 ≤ w n := hw_nonneg n +- have hnpos : 0 < (n : ℝ) := by exact_mod_cast (Nat.pos_of_ne_zero hn) +- have hn1 : (1 : ℝ) ≤ (n : ℝ) := by +- exact_mod_cast (Nat.one_le_iff_ne_zero.mpr hn) +- have hpow : (n : ℝ) ^ σ₁ ≤ (n : ℝ) ^ σ₂ := +- Real.rpow_le_rpow_of_exponent_le hn1 hσ₁₂ +- have hinv : +- (1 / ((n : ℝ) ^ σ₂)) ≤ (1 / ((n : ℝ) ^ σ₁)) := by +- have hpos1 : 0 < (n : ℝ) ^ σ₁ := Real.rpow_pos_of_pos hnpos σ₁ +- exact one_div_le_one_div_of_le hpos1 hpow +- have hinv_inv : ((n : ℝ) ^ σ₂)⁻¹ ≤ ((n : ℝ) ^ σ₁)⁻¹ := by +- simpa [one_div] using hinv +- have hmul1 : +- (f n) * (((n : ℝ) ^ σ₂)⁻¹) ≤ (f n) * (((n : ℝ) ^ σ₁)⁻¹) := +- mul_le_mul_of_nonneg_left hinv_inv hf +- have hmul2 : +- ((f n) * (((n : ℝ) ^ σ₂)⁻¹)) * (w n) +- ≤ ((f n) * (((n : ℝ) ^ σ₁)⁻¹)) * (w n) := +- mul_le_mul_of_nonneg_right hmul1 hw +- simpa [rterm, hn, div_eq_mul_inv, mul_assoc] using hmul2 +- +- have rterm_tend : ∀ n, Tendsto (fun σ : ℝ => rterm σ n) (𝓝[>] (1 : ℝ)) (𝓝 (rterm 1 n)) := by +- intro n +- have hterm : +- Tendsto (fun σ : ℝ => term (fun n ↦ (f n : ℂ)) (σ : ℝ) n) +- (𝓝[>] (1 : ℝ)) (𝓝 ((f n : ℂ) / (n : ℂ))) := by +- by_cases hn : n = 0 +- · subst hn +- simp [term, LSeries.term] +- · have hden : +- Tendsto (fun σ : ℝ => ((n : ℂ) ^ ((σ : ℝ) : ℂ))) (𝓝[>] (1 : ℝ)) (𝓝 ((n : ℂ) ^ (1 : ℂ))) := by +- simpa using ((continuous_ofReal.tendsto (1 : ℝ)).mono_left nhdsWithin_le_nhds).const_cpow +- +- have hden' : +- Tendsto (fun σ : ℝ => ((n : ℂ) ^ ((σ : ℝ) : ℂ))) (𝓝[>] (1 : ℝ)) (𝓝 (n : ℂ)) := by +- simpa using hden +- +- have hnC : (n : ℂ) ≠ 0 := by +- exact_mod_cast hn +- +- have hterm : +- Tendsto (fun σ : ℝ => term (fun n ↦ (f n : ℂ)) (σ : ℝ) n) +- (𝓝[>] (1 : ℝ)) (𝓝 ((f n : ℂ) / (n : ℂ))) := by +- have hnC : (n : ℂ) ≠ 0 := by +- exact_mod_cast hn +- simpa [term, LSeries.term, hn] using! +- (tendsto_const_nhds.div hden' hnC) +- exact hterm +- +- have hsummand : +- Tendsto +- (fun σ : ℝ => +- term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) +- (𝓝[>] (1 : ℝ)) +- (𝓝 (((f n : ℂ) / (n : ℂ)) * 𝓕 ψ.toFun (y n))) := by +- simpa [mul_assoc, mul_left_comm, mul_comm] using (hterm.mul_const (𝓕 ψ.toFun (y n))) +- +- have hre : ∀ σ, rterm σ n = +- (term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)).re := by +- intro σ +- have := congrArg Complex.re (summand_eq_ofReal σ n) +- simpa [Complex.ofReal_re] using this.symm +- +- have hRe : Tendsto +- (fun σ : ℝ => +- (term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)).re) +- (𝓝[>] (1 : ℝ)) +- (𝓝 ((((f n : ℂ) / (n : ℂ)) * 𝓕 ψ.toFun (y n)).re)) := +- (continuous_re.tendsto _).comp hsummand +- +- have hlimit_re : +- (f n / (n : ℝ)) * (𝓕 ψ.toFun (y n)).re = rterm 1 n := by +- have h0 : +- (term (fun n ↦ (f n : ℂ)) (1 : ℝ) n * 𝓕 ψ.toFun (y n)).re = rterm 1 n := by +- have := congrArg Complex.re (summand_eq_ofReal (σ := (1 : ℝ)) n) +- simpa [Complex.ofReal_re] using this +- +- by_cases hn : n = 0 +- · subst hn +- simp [rterm, y] +- · have h1 : +- (term (fun n ↦ (f n : ℂ)) (1 : ℝ) n * 𝓕 ψ.toFun (y n)).re +- = (f n / (n : ℝ)) * (𝓕 ψ.toFun (y n)).re := by +- simp [Complex.mul_re, term, LSeries.term, hn, y, +- (hψpos (y n)).2] +- +- exact (h1.symm.trans h0) +- +- simpa [hre, hlimit_re] using hRe +- +- have hSumm_rterm : ∀ σ : ℝ, 1 < σ → Summable (fun n : ℕ => rterm σ n) := by +- simpa [rterm] using limiting_fourier_variant_lim1_aux (ψ := ψ) +- (f := f) (x := x) hpos hf hψpos +- +- have hT_tend : +- Tendsto T (𝓝[>] (1 : ℝ)) (𝓝 (T 1)) := by +- have : +- Tendsto (fun σ : ℝ => ∑' n : ℕ, rterm σ n) +- (𝓝[>] (1 : ℝ)) +- (𝓝 (∑' n : ℕ, rterm (1 : ℝ) n)) := by +- refine tendsto_tsum_of_monotone_convergence_nhdsGT_one +- (F := rterm) +- (hF_nonneg := rterm_nonneg) +- (hF_antitone := rterm_antitone) +- (hF_tend := rterm_tend) +- (hSumm := hSumm_rterm) +- (hbounded := hboundedT) +- +- simpa [T] using this +- +- have hToReal : +- Tendsto (fun σ => Complex.ofReal (T σ)) (𝓝[>] (1 : ℝ)) (𝓝 (Complex.ofReal (T 1))) := +- (continuous_ofReal.tendsto _).comp hT_tend +- +- have hsource : +- (fun σ : ℝ => +- ∑' n : ℕ, +- term (fun n ↦ (f n : ℂ)) (σ : ℝ) n * 𝓕 ψ.toFun (y n)) +- = fun σ : ℝ => Complex.ofReal (T σ) := by +- funext σ +- exact (tsum_eq_ofReal_T σ) +- +- have hσ1 : +- (∑' n : ℕ, term (fun n ↦ (f n : ℂ)) (↑(1:ℝ)) n * 𝓕 ψ.toFun (y n)) +- = (↑(T 1) : ℂ) := +- by simpa using (tsum_eq_ofReal_T (σ := (1:ℝ))) +- have hterm1 : +- ∀ n : ℕ, term (fun n ↦ (f n : ℂ)) (1 : ℂ) n = (f n : ℂ) / (n : ℂ) := by +- intro n +- by_cases hn : n = 0 +- · subst hn +- simp [term, LSeries.term] +- · simp [term, LSeries.term, hn] +- +- have hrewrite : +- (∑' n : ℕ, +- term (fun n ↦ (f n : ℂ)) (1 : ℂ) n * 𝓕 ψ.toFun (y n)) +- = +- (∑' n : ℕ, +- (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (y n)) := by +- refine tsum_congr ?_ +- intro n +- simp [hterm1 n] +- +- have htarget : +- (∑' n : ℕ, +- (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (y n)) +- = (↑(T 1) : ℂ) := by +- exact (hrewrite.symm.trans hσ1) +- +- simpa [hsource, htarget, y] using hToReal +- +- +- +- +-blueprint_comment /-- +-\section{Removing the Chebyshev hypothesis} +- +-In this section we do *not* assume the bound \eqref{cheby}, but instead derive it from the other hypotheses. +- +--/ +- +-@[blueprint "limiting-fourier-variant" +- (title := "limiting-fourier-variant") +- (statement := /-- +- If $\psi: \R \to \C$ is $C^2$ and compactly supported with $f$ and $\hat \psi$ non-negative, and $0 < x$, then +- $$ \sum_{n=1}^\infty \frac{f(n)}{n} \hat \psi( \frac{1}{2\pi} \log \frac{n}{x} ) - A \int_{-\log x}^\infty \hat \psi(\frac{u}{2\pi})\ du = \int_\R G(1+it) \psi(t) x^{it}\ dt.$$ +- -/) +- (proof := /-- Repeat the proof of Lemma \ref{limiting-fourier-variant}, but use monotone convergence instead of dominated convergence. (The proof should be simpler, as one no longer needs to establish domination for the sum.) -/) +- (proofUses := ["decay", "second-fourier", "first-fourier"]) +- (latexEnv := "lemma")] +-lemma limiting_fourier_variant +- (hpos : 0 ≤ f) +- (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) +- (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (ψ : CS 2 ℂ) +- (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) +- (hx : 0 < x) : +- ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - +- A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = +- ∫ (t : ℝ), (G (1 + t * I)) * (ψ t) * x ^ (t * I) := by +- +- have l2 := limiting_fourier_lim2_gt_zero (A := A) (x := x) ψ hx +- have l3 := limiting_fourier_lim3_gt_zero (G := G) (x := x) hG ψ hx +- +- let S : ℝ → ℂ := fun σ' => +- ∑' n : ℕ, +- term (fun n ↦ (f n : ℂ)) σ' n * +- 𝓕 ψ.toFun (1 / (2 * π) * Real.log ((n : ℝ) / x)) +- let Pole : ℝ → ℂ := fun σ' => +- (A : ℂ) * ((x ^ (1 - σ') : ℝ) : ℂ) * +- ∫ u in Set.Ici (-Real.log x), +- (rexp (-u * (σ' - 1)) : ℂ) * +- 𝓕 (W21.ofCS2 ψ).toFun (u / (2 * π)) +- let RHS : ℝ → ℂ := fun σ' => +- ∫ t : ℝ, G (σ' + t * I) * ψ.toFun t * (x : ℂ) ^ (t * I) +- +- +- have haux : +- (fun (σ' : ℝ) ↦ +- ∑' (n : ℕ), +- term (fun n ↦ (f n : ℂ)) (σ' : ℂ) n * +- 𝓕 ψ.toFun (π⁻¹ * 2⁻¹ * Real.log ((n : ℝ) / x)) +- - (A : ℂ) * ((x ^ (1 - σ') : ℝ) : ℂ) * +- ∫ (u : ℝ) in Ici (-Real.log x), +- cexp (-( (u : ℂ) * ((σ' : ℂ) - 1))) * +- 𝓕 (W21.ofCS2 ψ).toFun (u / (2 * π))) +- =ᶠ[𝓝[>] (1 : ℝ)] +- (fun σ' ↦ +- ∫ (t : ℝ), G ((σ' : ℂ) + (t : ℂ) * I) * ψ.toFun t * (x : ℂ) ^ ((t : ℂ) * I)) := by +- rw [Filter.EventuallyEq] +- +- refine eventually_nhdsWithin_of_forall ?_ +- intro σ' hσ' +- have hσ' : (1 : ℝ) < σ' := by +- simpa [Set.mem_Ioi] using hσ' +- simpa using! (limiting_fourier_aux_gt_zero (G := G) (f := f) (A := A) hG' hf ψ hx σ' hσ') +- +- have haux' : +- (fun σ' : ℝ => S σ') =ᶠ[𝓝[>] (1 : ℝ)] (fun σ' : ℝ => RHS σ' + Pole σ') := by +- rw [Filter.EventuallyEq] at haux ⊢ +- filter_upwards [haux] with σ' hσ' +- have hσ'' : S σ' - Pole σ' = RHS σ' := by +- simpa [S, Pole, RHS] using hσ' +- have hadd : (S σ' - Pole σ') + Pole σ' = RHS σ' + Pole σ' := +- congrArg (fun z : ℂ => z + Pole σ') hσ'' +- simpa [sub_eq_add_neg, add_assoc, add_left_comm, add_comm] using hadd +- +- let Pole₁ : ℂ := (A : ℂ) * ∫ u in Set.Ici (-Real.log x), 𝓕 (W21.ofCS2 ψ).toFun (u / (2 * π)) +- let RHS₁ : ℂ := ∫ t : ℝ, G (1 + (t : ℂ) * I) * ψ.toFun t * (x : ℂ) ^ ((t : ℂ) * I) +- +- have hRHS_le : +- ∀ᶠ σ' : ℝ in 𝓝[>] (1 : ℝ), ‖RHS σ'‖ ≤ ‖RHS₁‖ + 1 := by +- have hball : Metric.ball RHS₁ (1 : ℝ) ∈ 𝓝 RHS₁ := by +- simpa using (Metric.ball_mem_nhds (x := RHS₁) (ε := (1 : ℝ)) (by norm_num)) +- have hpre : {σ' : ℝ | RHS σ' ∈ Metric.ball RHS₁ (1 : ℝ)} ∈ (𝓝[>] (1 : ℝ)) := +- l3 hball +- filter_upwards [hpre] with σ' hmem +- have hdist' : dist (RHS σ') RHS₁ < (1 : ℝ) := by +- simpa [Metric.mem_ball] using hmem +- have hdist : ‖RHS σ' - RHS₁‖ < (1 : ℝ) := by +- simpa [dist_eq_norm] using hdist' +- have htri : ‖RHS σ'‖ ≤ ‖RHS₁‖ + ‖RHS σ' - RHS₁‖ := by +- have h := norm_add_le (RHS σ' - RHS₁) RHS₁ +- simpa [sub_add_cancel, add_comm, add_left_comm, add_assoc] using h +- have hle : ‖RHS₁‖ + ‖RHS σ' - RHS₁‖ ≤ ‖RHS₁‖ + (1 : ℝ) := by +- exact add_le_add_right (le_of_lt hdist) ‖RHS₁‖ +- exact htri.trans hle +- +- have hPole_le : +- ∀ᶠ σ' : ℝ in 𝓝[>] (1 : ℝ), ‖Pole σ'‖ ≤ ‖Pole₁‖ + 1 := by +- have hball : Metric.ball Pole₁ 1 ∈ 𝓝 Pole₁ := by +- simpa using (Metric.ball_mem_nhds Pole₁ (by norm_num : (0 : ℝ) < 1)) +- have hpre : {σ' : ℝ | Pole σ' ∈ Metric.ball Pole₁ 1} ∈ (𝓝[>] (1 : ℝ)) := l2 hball +- filter_upwards [hpre] with σ' hmem +- have hdist : ‖Pole σ' - Pole₁‖ < 1 := by +- simpa [Metric.mem_ball, dist_eq_norm] using hmem +- have htri : ‖Pole σ'‖ ≤ ‖Pole₁‖ + ‖Pole σ' - Pole₁‖ := by +- have hdecomp : Pole σ' = Pole₁ + (Pole σ' - Pole₁) := by abel +- have hnorm_eq : ‖Pole σ'‖ = ‖Pole₁ + (Pole σ' - Pole₁)‖ := by +- simp [congrArg (fun z : ℂ => ‖z‖) hdecomp] +- calc +- ‖Pole σ'‖ = ‖Pole₁ + (Pole σ' - Pole₁)‖ := hnorm_eq +- _ ≤ ‖Pole₁‖ + ‖Pole σ' - Pole₁‖ := norm_add_le _ _ +- have hdist_le : ‖Pole σ' - Pole₁‖ ≤ 1 := le_of_lt hdist +- have hsum : ‖Pole₁‖ + ‖Pole σ' - Pole₁‖ ≤ ‖Pole₁‖ + 1 := by +- simpa [add_comm, add_left_comm, add_assoc] using (add_le_add_left hdist_le ‖Pole₁‖) +- exact htri.trans hsum +- +- have hS_le : +- ∀ᶠ σ' : ℝ in 𝓝[>] (1 : ℝ), +- ‖S σ'‖ ≤ (‖RHS₁‖ + 1) + (‖Pole₁‖ + 1) := by +- rw [Filter.EventuallyEq] at haux' +- filter_upwards [haux', hRHS_le, hPole_le] with σ' hEq hR hP +- calc +- ‖S σ'‖ = ‖RHS σ' + Pole σ'‖ := by simp [hEq] +- _ ≤ ‖RHS σ'‖ + ‖Pole σ'‖ := norm_add_le _ _ +- _ ≤ (‖RHS₁‖ + 1) + (‖Pole₁‖ + 1) := by +- exact add_le_add hR hP +- +- have hbounded : BoundedAtFilter (𝓝[>] (1 : ℝ)) (fun σ' : ℝ => ‖S σ'‖) := by +- let C : ℝ := ‖RHS₁‖ + 1 + (‖Pole₁‖ + 1) +- simp only [BoundedAtFilter, Asymptotics.IsBigO, Asymptotics.IsBigOWith] +- refine ⟨C, ?_⟩ +- filter_upwards [hS_le] with σ' hσ' +- simpa [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg (S σ'))] using hσ' +- +- have hcoef : (1 / (2 * π) : ℝ) = (π⁻¹ * 2⁻¹ : ℝ) := by field_simp [pi_ne_zero] +- +- have l1 := +- limiting_fourier_variant_lim1 +- (f := f) (x := x) (ψ := ψ) +- hpos hψpos +- (S := S) +- (hSdef := by +- intro σ +- simp [S, hcoef] ) +- hbounded +- hf +- have l1S : +- Tendsto S (𝓝[>] (1 : ℝ)) +- (𝓝 (∑' n : ℕ, (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (1 / (2 * π) * Real.log (↑n / x)))) := by +- simpa [S, hcoef] using l1 +- +- have l12 : Tendsto (fun σ' : ℝ => S σ' - Pole σ') (𝓝[>] (1 : ℝ)) +- (𝓝 ((∑' n : ℕ, (f n : ℂ) / (n : ℂ) * 𝓕 ψ.toFun (1 / (2 * π) * Real.log (↑n / x))) - Pole₁)) := +- l1S.sub l2 +- +- have hPole : (Pole : ℝ → ℂ) =ᶠ[𝓝[>] (1 : ℝ)] Pole := by simp +- have haux_sub : +- (fun σ' : ℝ => S σ' - Pole σ') =ᶠ[𝓝[>] (1 : ℝ)] RHS := by +- filter_upwards [haux'] with σ' hσ' +- calc +- S σ' - Pole σ' +- = (RHS σ' + Pole σ') - Pole σ' := by simp [hσ'] +- _ = RHS σ' := by simp +- have hlim := +- tendsto_nhds_unique_of_eventuallyEq (l1S.sub l2) l3 haux_sub +- +- simpa [Pole₁, RHS₁] using! hlim +- +- +-lemma norm_mul_integral_Ici_le_integral_norm +- (A : ℂ) (F : ℝ → ℂ) (a : ℝ) +- (hF : IntegrableOn F (Set.Ici a)) +- (hnorm : Integrable (fun u : ℝ => ‖F u‖)) : +- ‖A * (∫ u in Set.Ici a, F u)‖ ≤ ‖A‖ * (∫ u : ℝ, ‖F u‖) := by +- have hmul : ‖A * (∫ u in Set.Ici a, F u)‖ = ‖A‖ * ‖∫ u in Set.Ici a, F u‖ := by +- simp +- have hnormI : +- ‖∫ u in Set.Ici a, F u‖ ≤ ∫ u in Set.Ici a, ‖F u‖ := by +- have _ : Integrable F (Measure.restrict volume (Set.Ici a)) := hF +- have h : +- ‖∫ u, F u ∂Measure.restrict volume (Set.Ici a)‖ +- ≤ ∫ u, ‖F u‖ ∂Measure.restrict volume (Set.Ici a) := +- norm_integral_le_integral_norm (μ := Measure.restrict volume (Set.Ici a)) (f := F) +- simpa using h +- +- have hdom : +- (∫ u in Set.Ici a, ‖F u‖) ≤ ∫ u : ℝ, ‖F u‖ := by +- have hEq : +- (∫ u in Set.Ici a, ‖F u‖) = +- ∫ u : ℝ, Set.indicator (Set.Ici a) (fun u => ‖F u‖) u := by +- have h := (integral_indicator (μ := (volume : Measure ℝ)) +- (s := Set.Ici a) (f := fun u => ‖F u‖)) +- have h' := h measurableSet_Ici +- simpa using h'.symm +- have hind_int : +- Integrable (Set.indicator (Set.Ici a) (fun u => ‖F u‖)) := +- hnorm.indicator measurableSet_Ici +- have hpoint : +- Set.indicator (Set.Ici a) (fun u => ‖F u‖) +- ≤ᵐ[volume] (fun u : ℝ => ‖F u‖) := by +- filter_upwards with u +- by_cases hu : u ∈ Set.Ici a +- · simp [Set.indicator_of_mem hu] +- · simp [Set.indicator_of_notMem hu] +- have hmono := +- integral_mono_ae (μ := (volume : Measure ℝ)) +- hind_int hnorm hpoint +- simpa [hEq] using hmono +- +- calc +- ‖A * (∫ u in Set.Ici a, F u)‖ +- = ‖A‖ * ‖∫ u in Set.Ici a, F u‖ := hmul +- _ ≤ ‖A‖ * (∫ u in Set.Ici a, ‖F u‖) := +- mul_le_mul_of_nonneg_left hnormI (by simp) +- _ ≤ ‖A‖ * (∫ u : ℝ, ‖F u‖) := +- mul_le_mul_of_nonneg_left hdom (by simp) +- +-lemma fourier_decay_of_CS2 +- (ψ : CS 2 ℂ) : +- ∃ C : ℝ, ∀ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by +- let ψ' : W21 := (ψ : W21) +- obtain ⟨C, hC⟩ : +- ∃ C : ℝ, ∀ u : ℝ, ‖𝓕 (ψ' : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by +- simpa using (decay_bounds_cor (ψ := ψ')) +- refine ⟨C, ?_⟩ +- intro u +- simpa [ψ'] using! (hC u) +- +-lemma integrable_norm_fourier_scaled_of_CS2 +- (ψ : CS 2 ℂ) : +- Integrable (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by +- obtain ⟨C, hdecay⟩ := fourier_decay_of_CS2 (ψ := ψ) +- have hC_nonneg : 0 ≤ C := by +- have h0 := hdecay 0 +- have hnorm : 0 ≤ ‖𝓕 (ψ : ℝ → ℂ) 0‖ := norm_nonneg _ +- have hC' : ‖𝓕 (ψ : ℝ → ℂ) 0‖ ≤ C := by simpa using h0 +- exact hnorm.trans hC' +- have hmaj_int : Integrable (fun u : ℝ => (C : ℝ) / (1 + (u / (2 * Real.pi))^2)) := by +- have hbase : Integrable (fun u : ℝ => (1 + u ^ 2)⁻¹) := integrable_inv_one_add_sq +- have hscale : +- Integrable (fun u : ℝ => (1 + (u / (2 * Real.pi)) ^ 2)⁻¹) := +- hbase.comp_div (by nlinarith [Real.pi_pos]) +- simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc, pow_two] using +- hscale.const_mul C +- have hle : +- (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) +- ≤ᵐ[volume] +- (fun u : ℝ => (C : ℝ) / (1 + (u / (2 * Real.pi))^2)) := by +- refine Filter.Eventually.of_forall ?_ +- intro u +- simpa using (hdecay (u / (2 * Real.pi))) +- have hle_norm : +- (fun u : ℝ => ‖‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖‖) +- ≤ᵐ[volume] +- (fun u : ℝ => ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖) := by +- refine hle.mono ?_ +- intro u hu +- have hden_pos : 0 < 1 + (u / (2 * Real.pi)) ^ 2 := by nlinarith +- have hnonneg : 0 ≤ (C : ℝ) / (1 + (u / (2 * Real.pi))^2) := +- div_nonneg hC_nonneg hden_pos.le +- have hleft_nonneg : 0 ≤ ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖ := norm_nonneg _ +- have hbound : ‖‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖‖ ≤ +- (C : ℝ) / (1 + (u / (2 * Real.pi))^2) := by +- simpa [Real.norm_eq_abs, abs_of_nonneg hleft_nonneg] using hu +- have hC_abs : |C| = C := abs_of_nonneg hC_nonneg +- have hden_abs : |1 + (u / (2 * Real.pi))^2| = 1 + (u / (2 * Real.pi))^2 := by +- have : 0 ≤ 1 + (u / (2 * Real.pi))^2 := by nlinarith +- simpa using abs_of_nonneg this +- have hnorm : +- ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖ = +- (C : ℝ) / (1 + (u / (2 * Real.pi))^2) := by +- have hrec : +- ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖ = +- |C| / |1 + (u / (2 * Real.pi))^2| := by +- simp [Real.norm_eq_abs] +- simp [hC_abs, hden_abs, hrec] +- simpa [hnorm] using hbound +- have hmaj_int_norm : +- Integrable (fun u : ℝ => ‖(C : ℝ) / (1 + (u / (2 * Real.pi))^2)‖) := +- hmaj_int.norm +- have hmeas : +- AEStronglyMeasurable (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by +- have hcont : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) u := by +- simpa using! continuous_FourierIntegral (ψ : W21) +- have hcont_scaled : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi)) := +- hcont.comp (by continuity) +- exact hcont_scaled.aestronglyMeasurable.norm +- exact hmaj_int_norm.mono' hmeas hle_norm +- +-lemma exists_bound_norm_G_on_tsupport +- (hG : ContinuousOn G {s : ℂ | 1 ≤ s.re}) +- (ψ : CS 2 ℂ) : +- ∃ K : ℝ, ∀ t : ℝ, t ∈ tsupport (ψ : ℝ → ℂ) → +- ‖G (1 + t * Complex.I)‖ ≤ K := by +- let s : Set ℝ := tsupport (ψ : ℝ → ℂ) +- have hscompact : IsCompact s := by +- simpa [s] using (ψ.h2.isCompact : IsCompact (tsupport (ψ : ℝ → ℂ))) +- have hphi_cont : Continuous (fun t : ℝ => (1 : ℂ) + t * Complex.I) := by continuity +- have hphi_maps : +- Set.MapsTo (fun t : ℝ => (1 : ℂ) + t * Complex.I) s {z : ℂ | 1 ≤ z.re} := by +- intro t ht +- simp +- have hGcomp : ContinuousOn (fun t : ℝ => G ((1 : ℂ) + t * Complex.I)) s := +- hG.comp hphi_cont.continuousOn hphi_maps +- have hnorm_contOn : ContinuousOn (fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) s := hGcomp.norm +- have hbdd : BddAbove ((fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) '' s) := +- (hscompact.image_of_continuousOn hnorm_contOn).bddAbove +- refine ⟨sSup ((fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) '' s), ?_⟩ +- intro t ht +- have : ‖G ((1 : ℂ) + t * Complex.I)‖ ∈ +- (fun t : ℝ => ‖G ((1 : ℂ) + t * Complex.I)‖) '' s := ⟨t, ht, rfl⟩ +- exact le_csSup hbdd this +- +-lemma norm_integrand_le_K_mul_norm_psi +- {x K : ℝ} +- (hx : 0 < x) +- (hK : ∀ t : ℝ, t ∈ Function.support ψ → ‖G (1 + t * Complex.I)‖ ≤ K) : +- ∀ t : ℝ, +- ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ ≤ K * ‖ψ t‖ := by +- intro t +- by_cases ht : t ∈ Function.support ψ +- · have hxnorm : ‖((x : ℂ) ^ (t * Complex.I))‖ = 1 := norm_x_cpow_it x t hx +- calc +- ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ +- = ‖G (1 + t * Complex.I)‖ * ‖ψ t‖ * ‖((x : ℂ) ^ (t * Complex.I))‖ := by +- simp [mul_left_comm, mul_comm] +- _ = ‖G (1 + t * Complex.I)‖ * ‖ψ t‖ * 1 := by simp [hxnorm] +- _ ≤ K * ‖ψ t‖ := by +- have hGle : ‖G (1 + t * Complex.I)‖ ≤ K := hK t ht +- have : ‖G (1 + t * Complex.I)‖ * ‖ψ t‖ ≤ K * ‖ψ t‖ := +- mul_le_mul_of_nonneg_right hGle (norm_nonneg _) +- simpa [mul_assoc, mul_left_comm, mul_comm] using this +- · have hψ0 : ψ t = 0 := by +- by_contra hψ0 +- exact ht (by simpa [Function.support] using hψ0) +- simp [hψ0, mul_comm] +- +- +-lemma norm_error_integral_le +- (ψ : ℝ → ℂ) (x K : ℝ) +- (hGline_meas : Measurable (fun t : ℝ => G (1 + t * I))) +- (hψ_meas : AEStronglyMeasurable ψ) +- (hx : 0 < x) +- (hK : ∀ t : ℝ, t ∈ Function.support ψ → ‖G (1 + t * Complex.I)‖ ≤ K) +- (hψ : Integrable (fun t : ℝ => ‖ψ t‖) ) : +- ‖∫ t : ℝ, (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ +- ≤ K * (∫ t : ℝ, ‖ψ t‖) := by +- have h1 : ‖∫ t : ℝ, (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ +- ≤ ∫ t : ℝ, ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ := by +- simpa using (norm_integral_le_integral_norm +- (f := fun t : ℝ => (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I)))) +- have hmeas_main : AEStronglyMeasurable +- (fun t : ℝ => (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))) := by +- have hG' : AEMeasurable fun t : ℝ => G (1 + t * Complex.I) := hGline_meas.aemeasurable +- have hψ_meas' : AEMeasurable ψ := hψ_meas.aemeasurable +- have hx_ne : (x : ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt hx) +- have hx_ne' : NeZero (x : ℂ) := ⟨hx_ne⟩ +- have hxpow_meas : AEMeasurable fun t : ℝ => ((x : ℂ) ^ (t * Complex.I)) := by +- have hcontℂ : Continuous fun z : ℂ => ((x : ℂ) ^ z) := +- continuous_const_cpow (z := (x : ℂ)) +- have hcont : Continuous fun t : ℝ => ((x : ℂ) ^ ((t : ℂ) * Complex.I)) := +- hcontℂ.comp (by +- have h : Continuous fun t : ℝ => (t : ℂ) * Complex.I := by +- simpa using! (continuous_ofReal.mul continuous_const) +- simpa [mul_comm] using h) +- exact hcont.measurable.aemeasurable +- have hGψ_meas : AEMeasurable fun t : ℝ => (G (1 + t * Complex.I)) * (ψ t) := hG'.mul hψ_meas' +- have htotal : AEMeasurable (fun t : ℝ => +- (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))) := +- hGψ_meas.mul hxpow_meas +- exact htotal.aestronglyMeasurable +- have hpt : (fun t : ℝ => +- ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖) +- ≤ᵐ[volume] (fun t : ℝ => K * ‖ψ t‖) := by +- refine Eventually.of_forall ?_ +- intro t +- exact norm_integrand_le_K_mul_norm_psi (hx := hx) (hK := hK) t +- have hR : Integrable (fun t : ℝ => K * ‖ψ t‖) := hψ.const_mul K +- have hL : Integrable (fun t : ℝ => +- ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖) := by +- have hpt_norm : +- (fun t : ℝ => ‖‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖‖) +- ≤ᵐ[volume] (fun t : ℝ => K * ‖ψ t‖) := hpt.mono (by +- intro t ht +- simpa [norm_mul, mul_comm, mul_left_comm, mul_assoc] using ht) +- exact hR.mono' hmeas_main.norm hpt_norm +- have h2 : (∫ t : ℝ, ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖) +- ≤ ∫ t : ℝ, K * ‖ψ t‖ := integral_mono_ae (μ := (volume : Measure ℝ)) hL hR hpt +- have h3 : (∫ t : ℝ, K * ‖ψ t‖) = K * (∫ t : ℝ, ‖ψ t‖) := by +- simp [integral_const_mul] +- calc +- ‖∫ t : ℝ, (G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ +- ≤ ∫ t : ℝ, ‖(G (1 + t * Complex.I)) * (ψ t) * ((x : ℂ) ^ (t * Complex.I))‖ := h1 +- _ ≤ ∫ t : ℝ, K * ‖ψ t‖ := h2 +- _ = K * (∫ t : ℝ, ‖ψ t‖) := h3 +- +- +- +-@[blueprint "crude-upper-bound" +- (title := "crude-upper-bound") +- (statement := /-- +- If $\psi: \R \to \C$ is $C^2$ and compactly supported with $f$ and $\hat \psi$ non-negative, then there exists a constant $B$ such that +- $$ |\sum_{n=1}^\infty \frac{f(n)}{n} \hat \psi( \frac{1}{2\pi} \log \frac{n}{x} )| \leq B$$ +- for all $x > 0$. +- -/) +- (proof := /-- This readily follows from the previous lemma and the triangle inequality. -/) +- (proofUses := ["limiting-fourier-variant"]) +- (latexEnv := "corollary")] +-lemma crude_upper_bound +- (hpos : 0 ≤ f) +- (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) +- (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (ψ : CS 2 ℂ) +- (hψpos : ∀ y, 0 ≤ (𝓕 (ψ : ℝ → ℂ) y).re ∧ (𝓕 (ψ : ℝ → ℂ) y).im = 0) : +- ∃ B : ℝ, ∀ x : ℝ, 0 < x → ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ B := by +- +- -- Integrability of ψ +- have hψ_int : MeasureTheory.Integrable (ψ : ℝ → ℂ) := by +- simpa using (ψ.h1.continuous.integrable_of_hasCompactSupport ψ.h2) +- have hψ_norm_int : MeasureTheory.Integrable (fun t : ℝ => ‖(ψ : ℝ → ℂ) t‖) := +- hψ_int.norm +- have hψ_meas : MeasureTheory.AEStronglyMeasurable (ψ : ℝ → ℂ) := +- hψ_int.aestronglyMeasurable +- +- -- Uniform bound K for ‖G(1+it)‖ on support ψ +- rcases exists_bound_norm_G_on_tsupport (G := G) hG ψ with ⟨K, hK_ts⟩ +- have hK_support : +- ∀ t : ℝ, t ∈ Function.support (ψ : ℝ → ℂ) → ‖G (1 + t * Complex.I)‖ ≤ K := by +- have hbnG (hKts : ∀ t : ℝ, t ∈ tsupport ψ → ‖G (1 + t * Complex.I)‖ ≤ K) : +- ∀ t : ℝ, t ∈ Function.support ψ → ‖G (1 + t * Complex.I)‖ ≤ K := by +- intro t ht +- exact hKts t ((subset_tsupport ψ) ht) +- exact hbnG hK_ts +- +- -- Measurability of the line restriction t ↦ G(1 + t I) from continuity-on +- have hGline_meas : Measurable (fun t : ℝ => G (1 + t * Complex.I)) := by +- have hline_cont : Continuous (fun t : ℝ => (1 : ℂ) + t * Complex.I) := by +- continuity +- have hmem : ∀ t : ℝ, ((1 : ℂ) + t * Complex.I) ∈ {s : ℂ | 1 ≤ s.re} := by +- intro t +- simp +- have hcont : Continuous (G ∘ fun t : ℝ => (1 : ℂ) + t * Complex.I) := +- hG.comp_continuous hline_cont hmem +- simpa [Function.comp] using! hcont.measurable +- +- -- L¹ bound for the scaled Fourier transform norm +- have hF_norm_int : +- MeasureTheory.Integrable (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := +- integrable_norm_fourier_scaled_of_CS2 ψ +- have hF_meas : +- MeasureTheory.AEStronglyMeasurable +- (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) := by +- have hcont : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) u := by +- simpa using! continuous_FourierIntegral (ψ : W21) +- have hcont_scaled : Continuous fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi)) := +- hcont.comp (by continuity) +- exact hcont_scaled.aestronglyMeasurable +- have hF_int : +- MeasureTheory.Integrable (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) := +- by +- have hfin_norm : +- MeasureTheory.HasFiniteIntegral +- (fun u : ℝ => ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := +- hF_norm_int.hasFiniteIntegral +- have hfin : +- MeasureTheory.HasFiniteIntegral +- (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) := by +- simpa [MeasureTheory.hasFiniteIntegral_iff_norm] using hfin_norm +- exact ⟨hF_meas, hfin⟩ +- refine ⟨K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) +- + ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖), ?_⟩ +- intro x hx +- set I : ℂ := ∫ u in Set.Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi)) with hI +- +- -- Lemma 12 +- have hlim := +- limiting_fourier_variant (f := f) (A := A) (G := G) +- hpos hG hG' hf ψ hψpos hx +- have hlim' : +- (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log (n / x))) +- - A * I +- = ∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I) := by +- simpa [hI] using hlim +- +- -- express the tsum as RHS + A*I +- have htsum : +- (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log (n / x))) +- = (∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I := by +- have h' : +- (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log (n / x))) +- = (∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I := +- eq_add_of_sub_eq hlim' +- simpa [add_comm, mul_comm, mul_left_comm, mul_assoc] using h' +- +- -- bound the RHS integral +- have hRHS_bound : +- ‖∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)‖ +- ≤ K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) := +- norm_error_integral_le (G := G) (ψ := (ψ : ℝ → ℂ)) (x := x) (K := K) +- hGline_meas hψ_meas hx hK_support hψ_norm_int +- +- -- bound the A * I term +- have hA_bound : +- ‖A * I‖ ≤ ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by +- have hF_on : MeasureTheory.IntegrableOn +- (fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) +- (Set.Ici (-Real.log x)) := +- hF_int.integrableOn +- simpa [hI] using +- norm_mul_integral_Ici_le_integral_norm (A := A) +- (F := fun u : ℝ => 𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))) +- (a := -Real.log x) hF_on hF_norm_int +- +- -- combine bounds +- have htsum_std : +- (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))) +- = (∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I := by +- simpa [one_div, mul_comm, mul_left_comm, mul_assoc] using htsum +- +- -- bound in the normalized form +- have hbound : +- ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) +- (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))‖ +- ≤ K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) +- + ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := by +- have hnorm : +- ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) +- (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))‖ = +- ‖(∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I‖ := +- congrArg norm htsum_std +- calc +- ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) +- (1 / (2 * Real.pi) * Real.log ((n : ℝ) / x))‖ +- = ‖(∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)) + A * I‖ := hnorm +- _ ≤ ‖∫ (t : ℝ), (G (1 + t * Complex.I)) * (ψ t) * x ^ (t * Complex.I)‖ + ‖A * I‖ := +- norm_add_le _ _ +- _ ≤ K * (∫ t : ℝ, ‖(ψ : ℝ → ℂ) t‖) +- + ‖A‖ * (∫ u : ℝ, ‖𝓕 (ψ : ℝ → ℂ) (u / (2 * Real.pi))‖) := +- add_le_add hRHS_bound hA_bound +- exact hbound +- +-set_option backward.isDefEq.respectTransparency false in +-lemma Real.fourierIntegral_convolution {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) : +- 𝓕 (convolution f g (ContinuousLinearMap.mul ℂ ℂ) volume) = 𝓕 f * 𝓕 g := by +- ext y +- simp only [Pi.mul_apply, FourierTransform.fourier, MeasureTheory.convolution, +- VectorFourier.fourierIntegral, ContinuousLinearMap.mul_apply'] +- have h_int : Integrable (fun p : ℝ × ℝ ↦ 𝐞 (-(y * p.1)) • (f p.2 * g (p.1 - p.2))) := by +- simp only [Circle.smul_def, smul_eq_mul] +- refine (Integrable.convolution_integrand (ContinuousLinearMap.mul ℂ ℂ) hf hg).bdd_mul +- (c := 1) ?_ ?_ +- · exact (by continuity : Continuous _).aestronglyMeasurable +- · filter_upwards with p; simp +- calc ∫ v, 𝐞 (-(y * v)) • ∫ t, f t * g (v - t) +- = ∫ v, ∫ t, 𝐞 (-(y * v)) • (f t * g (v - t)) := by +- simp only [Circle.smul_def, smul_eq_mul, ← integral_const_mul] +- _ = ∫ t, ∫ v, 𝐞 (-(y * v)) • (f t * g (v - t)) := integral_integral_swap h_int +- _ = ∫ t, f t • ∫ v, 𝐞 (-(y * v)) • g (v - t) := by +- simp only [Circle.smul_def, smul_eq_mul, mul_left_comm, integral_const_mul] +- _ = ∫ t, f t • ∫ u, 𝐞 (-(y * (u + t))) • g u := by +- congr 1; ext t +- rw [← integral_add_right_eq_self (fun v ↦ 𝐞 (-(y * v)) • g (v - t)) t]; simp +- _ = ∫ t, f t • ∫ u, (𝐞 (-(y * t)) * 𝐞 (-(y * u))) • g u := by +- congr 2 with t; congr 1 +- simp only [mul_add, neg_add, mul_comm, Real.fourierChar.map_add_eq_mul] +- _ = ∫ t, 𝐞 (-(y * t)) • f t • ∫ u, 𝐞 (-(y * u)) • g u := by +- congr 1; ext t +- simp only [mul_smul, Circle.smul_def, smul_eq_mul, integral_const_mul]; ring +- _ = (∫ t, 𝐞 (-(y * t)) • f t) * ∫ u, 𝐞 (-(y * u)) • g u := by +- simp only [Circle.smul_def, smul_eq_mul, ← mul_assoc, integral_mul_const] +- +-lemma Real.fourierIntegral_conj_neg {f : ℝ → ℂ} (y : ℝ) : +- 𝓕 (fun x ↦ conj (f (-x))) y = conj (𝓕 f y) := by +- simp only [fourier_real_eq] +- have h_conj : ∀ x, 𝐞 (-(x * y)) • conj (f (-x)) = conj (𝐞 (x * y) • f (-x)) := fun x ↦ by +- simp only [Circle.smul_def, Real.fourierChar_apply, map_mul, smul_eq_mul, neg_mul, +- Complex.ofReal_neg, mul_neg] +- congr 1 +- rw [← Complex.exp_conj] +- simp only [map_mul, Complex.conj_I, Complex.conj_ofReal, mul_neg] +- calc ∫ x, 𝐞 (-(x * y)) • conj (f (-x)) +- = ∫ x, conj (𝐞 (x * y) • f (-x)) := by congr 1; ext x; exact h_conj x +- _ = conj (∫ x, 𝐞 (x * y) • f (-x)) := integral_conj +- _ = conj (∫ x, 𝐞 (-(x * y)) • f x) := by +- rw [← integral_neg_eq_self (fun x => 𝐞 (-(x * y)) • f x)] +- congr 2 with x; ring_nf +- +-/-- Smooth compactly supported function with non-negative Fourier transform via self-convolution. -/ +-lemma auto_cheby_exists_smooth_nonneg_fourier_kernel : +- ∃ (ψ : ℝ → ℂ), ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ +- (∀ y, 0 ≤ (𝓕 ψ y).re ∧ (𝓕 ψ y).im = 0) ∧ 0 < (𝓕 ψ 0).re := by +- obtain ⟨φ_real, hφSmooth, hφCompact, hφIcc, _, hφsupp⟩ := +- smooth_urysohn_support_Ioo (a := 1/2) (b := 1) (c := 1) (d := 2) (by norm_num) (by norm_num) +- let φ : ℝ → ℂ := Complex.ofReal ∘ φ_real +- let φ_rev : ℝ → ℂ := fun x ↦ conj (φ (-x)) +- let ψ_fun : ℝ → ℂ := convolution φ φ_rev (ContinuousLinearMap.mul ℂ ℂ) volume +- have hφSmooth' : ContDiff ℝ ∞ φ := contDiff_ofReal.comp hφSmooth +- have hφCompact' : HasCompactSupport φ := hφCompact.comp_left rfl +- have hφRevSmooth : ContDiff ℝ ∞ φ_rev := Complex.conjCLE.contDiff.comp (hφSmooth'.comp contDiff_neg) +- have hφRevCompact : HasCompactSupport φ_rev := (hφCompact'.comp_homeomorph (Homeomorph.neg ℝ)).comp_left (by simp) +- have hφInt : Integrable φ := hφSmooth'.continuous.integrable_of_hasCompactSupport hφCompact' +- have hφRevInt : Integrable φ_rev := hφRevSmooth.continuous.integrable_of_hasCompactSupport hφRevCompact +- have hψSmooth : ContDiff ℝ ∞ ψ_fun := by +- convert! hφRevCompact.contDiff_convolution_right (ContinuousLinearMap.mul ℝ ℂ) +- (hφSmooth'.continuous.locallyIntegrable (μ := volume)) hφRevSmooth +- have hψCompact : HasCompactSupport ψ_fun := +- HasCompactSupport.convolution (ContinuousLinearMap.mul ℂ ℂ) hφCompact' hφRevCompact +- refine ⟨ψ_fun, hψSmooth, hψCompact, fun y ↦ ?_, ?_⟩ +- · rw [Real.fourierIntegral_convolution hφInt hφRevInt, Pi.mul_apply, +- Real.fourierIntegral_conj_neg y, mul_comm, ← Complex.normSq_eq_conj_mul_self] +- exact ⟨Complex.normSq_nonneg _, rfl⟩ +- · have hφ_nonneg : ∀ x, 0 ≤ φ_real x := fun x ↦ by +- have hx := hφIcc x; by_cases h : x ∈ Set.Icc (1:ℝ) 1 +- · simp only [Set.indicator_of_mem h, Pi.one_apply] at hx; linarith +- · simp only [Set.indicator_of_notMem h] at hx; exact hx +- have hvol_supp : (1 : ENNReal) ≤ volume (Function.support φ_real) := by +- have hsub : Set.Ico (1:ℝ) 2 ⊆ Function.support φ_real := fun x hx ↦ +- hφsupp.symm ▸ Set.mem_Ioo.mpr ⟨by linarith [hx.1], hx.2⟩ +- calc _ = volume (Set.Ico (1:ℝ) 2) := by simp [Real.volume_Ico]; norm_num +- _ ≤ _ := volume.mono hsub +- have hφint_pos : 0 < ∫ x, φ_real x := +- (integral_pos_iff_support_of_nonneg_ae (.of_forall hφ_nonneg) +- (hφSmooth.continuous.integrable_of_hasCompactSupport hφCompact)).2 +- (lt_of_lt_of_le (by simp) hvol_supp) +- have hFφ0_re : 0 < (𝓕 φ 0).re := by +- simp only [φ, fourier_real_eq, mul_zero, neg_zero, AddChar.map_zero_eq_one, one_smul, +- Function.comp_apply] +- have hint : Integrable (fun x => (φ_real x : ℂ)) := +- (hφSmooth.continuous.integrable_of_hasCompactSupport hφCompact).ofReal +- calc (∫ x, (φ_real x : ℂ)).re = ∫ x, (φ_real x : ℂ).re := (integral_re hint).symm +- _ = ∫ x, φ_real x := by simp only [Complex.ofReal_re] +- _ > 0 := hφint_pos +- rw [Real.fourierIntegral_convolution hφInt hφRevInt, Pi.mul_apply, +- Real.fourierIntegral_conj_neg 0, mul_comm, ← Complex.normSq_eq_conj_mul_self] +- exact Complex.normSq_pos.2 (fun h ↦ (ne_of_gt hFφ0_re) (by simp [h])) +- +- +-/-- The series `∑ f(n)/n · 𝓕ψ(log(n/x)/(2π))` is summable for `x ≥ 1`. -/ +-lemma auto_cheby_fourier_summable (hpos : 0 ≤ f) (hf : ∀ σ', 1 < σ' → Summable (nterm f σ')) +- (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) +- (ψ : ℝ → ℂ) (hψSmooth : ContDiff ℝ ∞ ψ) (hψCompact : HasCompactSupport ψ) +- (hψpos : ∀ y, 0 ≤ (𝓕 ψ y).re ∧ (𝓕 ψ y).im = 0) (x : ℝ) (hx : 1 ≤ x) : +- Summable fun n ↦ (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x)) := by +- let ψCS : CS 2 ℂ := ⟨ψ, hψSmooth.of_le (by norm_cast), hψCompact⟩ +- let S : ℝ → ℂ := fun σ' ↦ ∑' n, term (f · : ℕ → ℂ) σ' n * 𝓕 ψCS.toFun (1 / (2 * π) * Real.log (n / x)) +- let Pole : ℝ → ℂ := fun σ' ↦ (A : ℂ) * (x ^ (1 - σ') : ℝ) * +- ∫ u in Set.Ici (-Real.log x), (rexp (-u * (σ' - 1)) : ℂ) * 𝓕 (W21.ofCS2 ψCS).toFun (u / (2 * π)) +- let RHS : ℝ → ℂ := fun σ' ↦ ∫ t : ℝ, G (σ' + t * I) * ψCS.toFun t * (x : ℂ) ^ (t * I) +- have l2 := limiting_fourier_lim2 (A := A) (x := x) ψCS hx +- have l3 := limiting_fourier_lim3 (G := G) hG ψCS hx +- have haux : (fun σ' ↦ S σ' - Pole σ') =ᶠ[𝓝[>] 1] RHS := eventually_nhdsWithin_of_forall fun σ' hσ' ↦ by +- simpa [S, Pole, RHS] using! limiting_fourier_aux hG' hf ψCS hx σ' hσ' +- have hS_tendsto : Tendsto S (𝓝[>] 1) (𝓝 (RHS 1 + A * ∫ u in Set.Ici (-Real.log x), +- 𝓕 (W21.ofCS2 ψCS).toFun (u / (2 * π)))) := by +- convert! (l3.congr' haux.symm).add l2 using 1; ext σ'; simp [S, Pole] +- have hbounded : BoundedAtFilter (𝓝[>] 1) (fun σ' ↦ ‖S σ'‖) := by +- simp only [BoundedAtFilter] +- let L := ‖RHS 1 + A * ∫ u in Set.Ici (-Real.log x), 𝓕 (W21.ofCS2 ψCS).toFun (u / (2 * π))‖ +- have : ∀ᶠ σ' in 𝓝[>] 1, ‖S σ'‖ < L + 1 := +- hS_tendsto.norm.eventually_lt tendsto_const_nhds (lt_add_one L) +- exact Asymptotics.IsBigO.of_bound (L + 1) (by filter_upwards [this] with σ h; simpa using h.le) +- let y : ℕ → ℝ := fun n ↦ (1 / (2 * π)) * Real.log (n / x) +- let w : ℕ → ℝ := fun n ↦ (𝓕 ψCS.toFun (y n)).re +- have hw : ∀ n, 0 ≤ w n := fun n ↦ (hψpos (y n)).1 +- let rt : ℝ → ℕ → ℝ := fun σ n ↦ if n = 0 then 0 else f n / (n : ℝ) ^ σ * w n +- have rt_nn σ n : 0 ≤ rt σ n := by +- simp only [rt]; split_ifs with hn +- · rfl +- · exact mul_nonneg (div_nonneg (hpos n) (Real.rpow_pos_of_pos (Nat.cast_pos.mpr +- (Nat.pos_of_ne_zero hn)) σ).le) (hw n) +- have hS_eq σ' (hσ' : 1 < σ') : S σ' = ↑(∑' n, rt σ' n) := by +- rw [Complex.ofReal_tsum]; apply tsum_congr; intro n +- simp only [rt, term, LSeries.term, y, w, one_div, mul_inv_rev] +- split_ifs with hn <;> simp only [hn, CharP.cast_eq_zero, Complex.ofReal_zero, zero_mul, +- Complex.ofReal_mul, Complex.ofReal_div] +- rw [Complex.ofReal_cpow (Nat.cast_nonneg n)]; congr 1 +- exact Complex.ext rfl (hψpos _).2 +- have hMono n : AntitoneOn (fun σ ↦ rt σ n) (Set.Ioi 1) := fun σ₁ _ σ₂ _ h ↦ by +- simp only [rt]; split_ifs with hn; · rfl +- apply mul_le_mul_of_nonneg_right _ (hw n) +- apply div_le_div_of_nonneg_left (hpos n) (Real.rpow_pos_of_pos (Nat.cast_pos.mpr +- (Nat.pos_of_ne_zero hn)) σ₁) +- exact Real.rpow_le_rpow_of_exponent_le (Nat.one_le_cast.mpr (Nat.pos_of_ne_zero hn)) h +- have hT_bdd : BoundedAtFilter (𝓝[>] 1) fun σ ↦ ∑' n, rt σ n := by +- rw [BoundedAtFilter, Asymptotics.isBigO_iff] at hbounded ⊢ +- obtain ⟨C, hC⟩ := hbounded +- refine ⟨C, ?_⟩ +- filter_upwards [hC, self_mem_nhdsWithin] with σ hnorm hσ +- rw [hS_eq σ hσ] at hnorm; simpa using hnorm +- have hSumm σ (hσ : 1 < σ) : Summable (rt σ ·) := by +- simpa [rt, w, y] using limiting_fourier_variant_lim1_aux ψCS hpos hf hψpos σ hσ +- have hSumm_1 : Summable (rt 1 ·) := by +- let σ_seq : ℕ → ℝ := fun k ↦ 1 + 1 / ((k : ℝ) + 1) +- have hσ_gt k : 1 < σ_seq k := by simp only [σ_seq, lt_add_iff_pos_right, one_div]; positivity +- have h_tendsto : Tendsto σ_seq atTop (𝓝[>] 1) := by +- rw [tendsto_nhdsWithin_iff] +- refine ⟨?_, by filter_upwards with k; exact hσ_gt k⟩ +- have : Tendsto (fun k : ℕ ↦ 1 / ((k : ℝ) + 1)) atTop (𝓝 0) := by +- simp only [one_div]; exact (tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds).inv_tendsto_atTop +- simpa [σ_seq] using tendsto_const_nhds.add this +- have h_ptwise n : Tendsto (fun k ↦ rt (σ_seq k) n) atTop (𝓝 (rt 1 n)) := by +- simp only [rt]; split_ifs with hn; · exact tendsto_const_nhds +- refine ((tendsto_const_nhds.rpow (tendsto_nhdsWithin_iff.mp h_tendsto).1 (Or.inl ?_)).inv₀ +- (by simp [hn])).const_mul (f n) |>.mul_const (w n) +- exact (Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn)).ne' +- obtain ⟨C, hC⟩ := Asymptotics.isBigO_iff.mp (hT_bdd.comp_tendsto h_tendsto) +- refine summable_of_sum_range_le (c := C) (rt_nn 1) fun m ↦ le_of_tendsto (tendsto_finsetSum _ +- fun i _ ↦ h_ptwise i) ?_ +- filter_upwards [h_tendsto.eventually self_mem_nhdsWithin, hC] with k hk hCk +- calc ∑ i ∈ Finset.range m, rt (σ_seq k) i +- ≤ ∑' n, rt (σ_seq k) n := (hSumm _ hk).sum_le_tsum _ fun n _ ↦ rt_nn _ n +- _ ≤ |∑' n, rt (σ_seq k) n| := le_abs_self _ +- _ ≤ C := by simpa using hCk +- rw [show (fun n ↦ (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x))) = +- Complex.ofRealCLM ∘ (rt 1 ·) from ?_] +- · exact hSumm_1.map Complex.ofRealCLM Complex.ofRealCLM.continuous +- ext n; simp only [rt, Real.rpow_one, one_div, w, y, Function.comp_apply] +- split_ifs with hn; · simp [hn] +- have him0 : (𝓕 ψCS.toFun ((2 * π)⁻¹ * Real.log (n / x))).im = 0 := (hψpos _).2 +- have hre_eq : 𝓕 ψCS.toFun ((2 * π)⁻¹ * Real.log (n / x)) = +- Complex.ofReal ((𝓕 ψCS.toFun ((2 * π)⁻¹ * Real.log (n / x))).re) := by +- rw [← Complex.re_add_im (𝓕 ψCS.toFun _), him0]; simp +- conv_lhs => rw [show ψ = ψCS.toFun from rfl, hre_eq] +- simp only [Complex.ofRealCLM_apply, Complex.ofReal_div, Complex.ofReal_mul, Complex.ofReal_natCast] +- +-/-- Short interval bound from global filtered bound: if `∑ f(n)/n · 𝓕ψ(log(n/x)) ≤ B`, +-then `∑_{(1-ε)x < n ≤ x} f(n) ≤ Cx` for some `ε, C > 0`. -/ +-lemma auto_cheby_short_interval_bound (hpos : 0 ≤ f) +- (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) +- (B : ℝ) (ψ : ℝ → ℂ) (hψSmooth : ContDiff ℝ ∞ ψ) (hψCompact : HasCompactSupport ψ) +- (hψpos : ∀ y, 0 ≤ (𝓕 ψ y).re ∧ (𝓕 ψ y).im = 0) (hψ0 : 0 < (𝓕 ψ 0).re) +- (hB_bound : ∀ x ≥ 1, ‖∑' n, f n / n * 𝓕 ψ (1 / (2 * Real.pi) * Real.log (n / x))‖ ≤ B) : +- ∃ (ε : ℝ) (C : ℝ), ε > 0 ∧ ε < 1 ∧ C > 0 ∧ ∀ x ≥ 1, +- ∑' n, (f n) * (Set.indicator (Set.Ioc ((1 - ε) * x) x) (fun _ ↦ 1) (n : ℝ)) ≤ C * x := by +- have hF : Continuous (𝓕 ψ) := VectorFourier.fourierIntegral_continuous Real.continuous_fourierChar +- (by continuity) (hψSmooth.continuous.integrable_of_hasCompactSupport hψCompact) +- have hg : Continuous fun y ↦ (𝓕 ψ y).re := Complex.continuous_re.comp hF +- obtain ⟨δ, hδpos, hball⟩ := Metric.mem_nhds_iff.1 <| +- hg.continuousAt.preimage_mem_nhds (IsOpen.mem_nhds isOpen_Ioi (half_lt_self hψ0)) +- let c := (𝓕 ψ 0).re / 2 +- have hcpos : 0 < c := by dsimp only [c]; linarith +- have h_psi_ge_c : ∀ y, |y| < δ → c ≤ (𝓕 ψ y).re := fun y hy ↦ (hball (mem_ball_zero_iff.mpr hy)).le +- let ε := 1 - Real.exp (-2 * π * δ) +- have hε : 0 < ε ∧ ε < 1 := by +- have h1 : Real.exp (-2 * π * δ) < 1 := Real.exp_lt_one_iff.mpr (by nlinarith [Real.pi_pos]) +- exact ⟨by simp only [ε]; linarith, by simp only [ε]; linarith [Real.exp_pos (-2 * π * δ)]⟩ +- have hB_nonneg : 0 ≤ B := (norm_nonneg _).trans (hB_bound 1 le_rfl) +- refine ⟨ε, B / c + 1, hε.1, hε.2, by positivity, fun x hx ↦ ?_⟩ +- have h_summable : Summable fun n ↦ (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x)) := +- auto_cheby_fourier_summable hpos hf hG hG' ψ hψSmooth hψCompact hψpos x hx +- have hx_pos : 0 < x := by linarith +- have h_sum_lower : c / x * ∑' n, f n * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (n : ℝ) +- ≤ ∑' n, f n / n * (𝓕 ψ (1 / (2 * π) * Real.log (n / x))).re := by +- rw [← tsum_mul_left] +- refine Summable.tsum_le_tsum (fun n ↦ ?_) ?_ ?_ +- · by_cases hn : (n : ℝ) ∈ Set.Ioc ((1 - ε) * x) x +- · rw [Set.indicator_of_mem hn, Pi.one_apply, mul_one] +- have hn_pos : 0 < (n : ℝ) := by nlinarith [hn.1, hε.2] +- let y := (1 / (2 * π)) * Real.log (n / x) +- have h_arg_small : |y| < δ := by +- have h2pi : 0 < 2 * π := by linarith [Real.pi_pos] +- simp only [y, abs_mul, abs_div, abs_one, abs_of_pos h2pi] +- field_simp [ne_of_gt h2pi]; rw [mul_comm, abs_lt] +- have h_log_lower : -2 * π * δ < Real.log (n / x) := by +- rw [← Real.log_exp (-2 * π * δ), Real.log_lt_log_iff (Real.exp_pos _) (by positivity)] +- have : Real.exp (-2 * π * δ) = 1 - ε := by simp only [ε]; ring +- rw [this]; field_simp; exact hn.1 +- have h_log_upper : Real.log (n / x) ≤ 0 := +- Real.log_nonpos (by positivity) (div_le_one_of_le₀ hn.2 hx_pos.le) +- constructor <;> nlinarith [Real.pi_pos] +- have h1 : x⁻¹ ≤ (n : ℝ)⁻¹ := by rw [inv_le_inv₀ hx_pos hn_pos]; exact hn.2 +- have h2 : c ≤ (𝓕 ψ y).re := h_psi_ge_c y h_arg_small +- have hfn : 0 ≤ f n := hpos n +- have hre : 0 ≤ (𝓕 ψ y).re := (hψpos y).1 +- have hn_inv : 0 ≤ (n : ℝ)⁻¹ := inv_nonneg.mpr hn_pos.le +- calc c / x * f n = c * x⁻¹ * f n := by rw [div_eq_mul_inv] +- _ ≤ c * (n : ℝ)⁻¹ * f n := by gcongr +- _ ≤ (𝓕 ψ y).re * (n : ℝ)⁻¹ * f n := by gcongr +- _ = (n : ℝ)⁻¹ * (𝓕 ψ y).re * f n := by ring +- _ = f n / n * (𝓕 ψ y).re := by ring +- · rw [Set.indicator_of_notMem hn, mul_zero, mul_zero] +- exact mul_nonneg (div_nonneg (hpos n) (Nat.cast_nonneg n)) (hψpos _).1 +- · refine summable_of_hasFiniteSupport <| (Set.finite_le_nat ⌊x⌋₊).subset fun n hn ↦ ?_ +- simp only [Function.mem_support, ne_eq, mul_eq_zero, not_or, Set.indicator_apply_ne_zero] at hn +- exact Nat.le_floor hn.2.2.1.2 +- · rw [← Complex.summable_ofReal]; convert h_summable using 1; ext n +- rw [Complex.ofReal_mul, Complex.ofReal_div] +- norm_cast +- rw [Complex.ofReal_mul] +- congr 1 +- apply Complex.ext +- · simp only [Complex.ofReal_re] +- · simp only [Complex.ofReal_im]; exact (hψpos _).2.symm +- have h_real_eq : ∑' n, f n / n * (𝓕 ψ (1 / (2 * π) * Real.log (n / x))).re = +- (∑' n, (f n : ℂ) / n * 𝓕 ψ (1 / (2 * π) * Real.log (n / x))).re := by +- rw [Complex.re_tsum h_summable]; congr with n +- rw [Complex.mul_re]; norm_cast; simp only [zero_mul, sub_zero] +- calc ∑' n, f n * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (n : ℝ) +- = x / c * (c / x * ∑' n, f n * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (n : ℝ)) := by +- field_simp [ne_of_gt hcpos, ne_of_gt hx_pos] +- _ ≤ x / c * B := by +- gcongr; rw [h_real_eq] at h_sum_lower +- exact h_sum_lower.trans ((Complex.re_le_norm _).trans (hB_bound x hx)) +- _ = (B / c) * x := by field_simp [ne_of_gt hcpos] +- _ ≤ (B / c + 1) * x := by nlinarith +- +-/-- Bootstraps short interval bounds to global Chebyshev bound via strong induction. +-If `∑_{(1-ε)x < n ≤ x} f(n) ≤ Cx` for all `x ≥ 1`, then `∑_{n ≤ x} f(n) = O(x)`. -/ +-lemma auto_cheby_bootstrap_induction (hpos : 0 ≤ f) +- (h_short : ∃ (ε : ℝ) (C : ℝ), ε > 0 ∧ ε < 1 ∧ C > 0 ∧ ∀ x ≥ 1, +- ∑' n, (f n) * (Set.indicator (Set.Ioc ((1 - ε) * x) x) (fun _ ↦ 1) (n : ℝ)) ≤ C * x) : +- cheby f := by +- obtain ⟨ε, C₀, hε, hε1, hC₀, h_bound⟩ := h_short +- let C := C₀ / ε + f 0 + 1 +- have hf0 : (0 : ℝ) ≤ f 0 := hpos 0 +- have hdiv : 0 ≤ C₀ / ε := div_nonneg hC₀.le hε.le +- have hC : 0 ≤ C := by linarith +- refine ⟨C, fun n ↦ ?_⟩ +- induction n using Nat.strong_induction_on with | h n ih => +- rcases lt_or_ge n 2 with hn | hn +- · interval_cases n +- · simp [cumsum] +- · simp only [cumsum, Finset.sum_range_one, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hf0, +- Nat.cast_one, mul_one, C] +- linarith +- let x := (n : ℝ) - 1 +- have hx : x ≥ 1 := by simp only [x, ge_iff_le, le_sub_iff_add_le]; norm_cast +- let m := ⌊(1 - ε) * x⌋₊ + 1 +- have hm_lt : m < n := by +- simp only [m, x] +- have h1 : (1 - ε) * (n - 1 : ℝ) < (n - 1 : ℕ) := by +- calc (1 - ε) * (↑n - 1) < 1 * (↑n - 1) := by gcongr; linarith +- _ = ↑n - 1 := by ring +- _ = ↑(n - 1) := by simp [Nat.cast_sub (by omega : 1 ≤ n)] +- have h2 : ⌊(1 - ε) * (n - 1 : ℝ)⌋₊ < n - 1 := +- (Nat.floor_lt (mul_nonneg (by linarith) (by linarith : (0 : ℝ) ≤ n - 1))).mpr h1 +- omega +- have hm_gt : (m : ℝ) > (1 - ε) * x := by +- simp only [m, Nat.cast_add, Nat.cast_one, gt_iff_lt] +- exact Nat.lt_floor_add_one ((1 - ε) * x) +- have h_decomp : cumsum (fun k ↦ ‖(f k : ℂ)‖) n = cumsum (fun k ↦ ‖(f k : ℂ)‖) m + ∑ k ∈ Finset.Ico m n, f k := by +- simp only [cumsum, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (hpos _), +- Finset.sum_range_add_sum_Ico _ (by omega : m ≤ n)] +- have h_Ico : ∑ k ∈ Finset.Ico m n, f k ≤ C₀ * x := by +- calc ∑ k ∈ Finset.Ico m n, f k +- = ∑ k ∈ Finset.Ico m n, f k * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (k : ℝ) := by +- refine Finset.sum_congr rfl fun k hk ↦ ?_ +- have ⟨hkm, hkn⟩ := Finset.mem_Ico.mp hk +- have hk_gt : (k : ℝ) > (1 - ε) * x := by linarith [hm_gt, (Nat.cast_le (α := ℝ)).mpr hkm] +- have hk_le : (k : ℝ) ≤ x := by +- have h1 : k ≤ n - 1 := Nat.le_pred_of_lt hkn +- have h2 : (k : ℝ) ≤ (n - 1 : ℕ) := by exact_mod_cast h1 +- simp only [Nat.cast_sub (by omega : 1 ≤ n), Nat.cast_one, x] at h2 ⊢; exact h2 +- simp only [Set.indicator_of_mem (Set.mem_Ioc.mpr ⟨hk_gt, hk_le⟩), Pi.one_apply, mul_one] +- _ ≤ ∑' k, f k * Set.indicator (Set.Ioc ((1 - ε) * x) x) 1 (k : ℝ) := by +- refine Summable.sum_le_tsum _ (fun k _ ↦ mul_nonneg (hpos k) (Set.indicator_nonneg (by simp) _)) ?_ +- refine summable_of_hasFiniteSupport <| (Set.finite_le_nat ⌊x⌋₊).subset fun k hk ↦ ?_ +- simp only [Function.mem_support, ne_eq, mul_eq_zero, not_or, Set.indicator_apply_ne_zero] at hk +- exact Nat.le_floor hk.2.1.2 +- _ ≤ C₀ * x := h_bound x hx +- have hm_le : (m : ℝ) ≤ (1 - ε) * x + 1 := by +- have hpos' : 0 ≤ (1 - ε) * x := mul_nonneg (by linarith) (by linarith : (0 : ℝ) ≤ x) +- simp only [m, Nat.cast_add, Nat.cast_one] +- linarith [Nat.floor_le hpos'] +- have hnorm : ∀ k, ‖(f k : ℂ)‖ = f k := fun k ↦ by simp [abs_of_nonneg (hpos k)] +- simp only [hnorm] at h_decomp ih ⊢ +- calc cumsum f n = cumsum f m + ∑ k ∈ Finset.Ico m n, f k := h_decomp +- _ ≤ C * m + C₀ * x := by linarith [ih m hm_lt, h_Ico] +- _ ≤ C * ((1 - ε) * x + 1) + C₀ * x := by nlinarith [hC] +- _ = (C * (1 - ε) + C₀) * x + C := by ring +- _ ≤ C * x + C := by +- have : C₀ ≤ C * ε := by +- calc C₀ = (C₀ / ε) * ε := by field_simp [ne_of_gt hε] +- _ ≤ (C₀ / ε + f 0 + 1) * ε := by gcongr; linarith [hpos 0] +- _ = C * ε := by simp only [C] +- nlinarith [hε, hε1, hx] +- _ ≤ C * n := by simp only [x]; ring_nf; linarith [hC] +- +-@[blueprint "auto-cheby" +- (title := "auto-cheby") +- (statement := /-- One has $$ \sum_{n \leq x} f(n) = O(x)$$ for all $x \geq 1$. -/) +- (proof := /-- +- By applying Corollary \ref{crude-upper-bound} for a specific compactly supported function $\psi$, +- one can obtain a bound of the form $\sum_{(1-\varepsilon)x < n \leq x} f(n) = O(x)$ for all $x$ +- and some absolute constant $\varepsilon$ (which can be made explicit). +- +- If $C$ is a sufficiently large constant, the claim $|\sum_{n \leq x} f(n)| \leq Cx$ can now be +- proven by strong induction on $x$, as the claim for $(1-\varepsilon)x$ implies the claim for $x$ +- by the triangle inequality (and the claim is trivial for $x < 1$). +- -/) +- (proofUses := ["crude-upper-bound", "WienerIkehara"]) +- (latexEnv := "corollary")] +-lemma auto_cheby (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : cheby f := by +- obtain ⟨ψ_fun, hψSmooth, hψCompact, hψpos, hψ0⟩ := auto_cheby_exists_smooth_nonneg_fourier_kernel +- obtain ⟨B, hB⟩ := crude_upper_bound hpos hG hG' hf ⟨ψ_fun, hψSmooth.of_le ENat.LEInfty.out, hψCompact⟩ hψpos +- exact auto_cheby_bootstrap_induction hpos <| auto_cheby_short_interval_bound hpos hf hG hG' B ψ_fun +- hψSmooth hψCompact hψpos hψ0 fun x hx ↦ hB x (by linarith) +- +-@[blueprint "WienerIkehara2" +- (title := "Wiener-Ikehara Theorem (2)") +- (statement := /-- We have $$ \sum_{n\leq x} f(n) = A x + o(x).$$ -/) +- (proof := /-- Use Corollary \ref{auto-cheby} to remove the Chebyshev hypothesis in Theorem \ref{WienerIkehara}. -/) +- (latexEnv := "theorem")] +-theorem WienerIkeharaTheorem'' (hpos : 0 ≤ f) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) +- (hG : ContinuousOn G {s | 1 ≤ s.re}) +- (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : +- Tendsto (fun N => cumsum f N / N) atTop (𝓝 A) := +- WienerIkeharaTheorem' hpos hf (auto_cheby (f := f) (A := A) (G := G) hpos hf hG hG') hG hG' +- +-end auto_cheby +- +-blueprint_comment /-- +-\section{The prime number theorem in arithmetic progressions} +--/ +- +-@[blueprint "WeakPNT-character" +- (title := "WeakPNT-character") +- (statement := /-- +- If $q ≥ 1$ and $a$ is coprime to $q$, and $\mathrm{Re} s > 1$, we have +- $$ +- \sum_{n: n = a\ (q)} \frac{\Lambda(n)}{n^s} = - \frac{1}{\varphi(q)} \sum_{\chi\ (q)} +- \overline{\chi(a)} \frac{L'(s,\chi)}{L(s,\chi)}.$$ +- -/) +- (proof := /-- +- From the Fourier inversion formula on the multiplicative group $(\Z/q\Z)^\times$, we have +- $$ 1_{n=a\ (q)} = \frac{\varphi(q)}{q} \sum_{\chi\ (q)} \overline{\chi(a)} \chi(n).$$ +- On the other hand, from standard facts about L-series we have for each character $\chi$ that +- $$ +- \sum_{n} \frac{\Lambda(n) \chi(n)}{n^s} = - \frac{L'(s,\chi)}{L(s,\chi)}.$$ +- Combining these two facts, we obtain the claim. +- -/) +- (latexEnv := "lemma")] +-theorem WeakPNT_character +- {q a : ℕ} (hq : q ≥ 1) (ha : Nat.Coprime a q) (ha' : a < q) {s : ℂ} (hs : 1 < s.re) : +- LSeries (fun n ↦ if n % q = a then Λ n else 0) s = +- - (∑' χ : DirichletCharacter ℂ q, +- ((starRingEnd ℂ) (χ a) * ((deriv (LSeries (fun n:ℕ ↦ χ n)) s)) / +- (LSeries (fun n:ℕ ↦ χ n) s))) / (Nat.totient q : ℂ) := by +- have : NeZero q := ⟨by omega⟩ +- convert vonMangoldt.LSeries_residueClass_eq ((ZMod.isUnit_iff_coprime a q).mpr ha) hs using 1 +- · congr with n +- have : n % q = a ↔ (n : ZMod q) = a := by +- rw [ZMod.natCast_eq_natCast_iff', Nat.mod_eq_of_lt ha'] +- simp [this] +- split_ifs <;> simp [*] +- · rw [div_eq_inv_mul, neg_mul_comm, tsum_fintype] +- congr 3 with χ +- rw [DirichletCharacter.deriv_LFunction_eq_deriv_LSeries _ hs, +- DirichletCharacter.LFunction_eq_LSeries _ hs, mul_div] +- congr 2 +- rw [starRingEnd_apply, MulChar.star_apply', MulChar.inv_apply_eq_inv', +- ← ZMod.coe_unitOfCoprime a ha, ZMod.inv_coe_unit, map_units_inv] +- +- +-@[blueprint "WeakPNT-AP-prelim" +- (title := "WeakPNT-AP-prelim") +- (statement := /-- +- If $q ≥ 1$ and $a$ is coprime to $q$, the Dirichlet series +- $\sum_{n \leq x: n = a\ (q)} \frac{\Lambda(n)}{n^s}$ converges for $\mathrm{Re}(s) > 1$ to +- $\frac{1}{\varphi(q)} \frac{1}{s-1} + G(s)$ where $G$ has a continuous extension to +- $\mathrm{Re}(s)=1$. +- -/) +- (proof := /-- +- We expand out the left-hand side using Lemma \ref{WeakPNT-character}. The contribution of the +- non-principal characters $\chi$ extend continuously to $\mathrm{Re}(s) = 1$ thanks to the +- non-vanishing of $L(s,\chi)$ on this line (which should follow from another component of +- this project), so it suffices to show that for the principal character $\chi_0$, that +- $$ -\frac{L'(s,\chi_0)}{L(s,\chi_0)} - \frac{1}{s-1}$$ +- also extends continuously here. But we already know that +- $$ -\frac{\zeta'(s)}{\zeta(s)} - \frac{1}{s-1}$$ +- extends, and from Euler product machinery one has the identity +- $$ \frac{L'(s,\chi_0)}{L(s,\chi_0)} +- = \frac{\zeta'(s)}{\zeta(s)} + \sum_{p|q} \frac{\log p}{p^s-1}.$$ +- Since there are only finitely many primes dividing $q$, and each summand $\frac{\log p}{p^s-1}$ +- extends continuously, the claim follows. +- -/) +- (proofUses := ["ChebyshevPsi", "WeakPNT-character"]) +- (latexEnv := "proposition")] +-theorem WeakPNT_AP_prelim {q : ℕ} {a : ℕ} (hq : q ≥ 1) (ha : Nat.Coprime a q) (ha' : a < q) : +- ∃ G: ℂ → ℂ, (ContinuousOn G {s | 1 ≤ s.re}) ∧ +- (Set.EqOn G (fun s ↦ LSeries (fun n ↦ if n % q = a then Λ n else 0) s - 1 / +- ((Nat.totient q) * (s - 1))) {s | 1 < s.re}) := by +- have : NeZero q := NeZero.of_pos hq +- have hG : ∃ G : ℂ → ℂ, ContinuousOn G {s | 1 ≤ s.re} ∧ Set.EqOn G +- (fun s ↦ LSeries (fun n ↦ if (n : ZMod q) = a then Λ n else 0) s - (q.totient : ℂ)⁻¹ / (s - 1)) {s | 1 < s.re} := by +- use vonMangoldt.LFunctionResidueClassAux (a : ZMod q), vonMangoldt.continuousOn_LFunctionResidueClassAux (q := q) (a := a) +- have := vonMangoldt.eqOn_LFunctionResidueClassAux ((ZMod.isUnit_iff_coprime a q).mpr ha) +- convert this using 6; split <;> simp_all +- convert hG using 6 +- · simp [ZMod.natCast_eq_natCast_iff', Nat.mod_eq_of_lt ha'] +- · rw [inv_eq_one_div, div_div] +- +-/-- The von Mangoldt function divided by `n ^ s` is summable for `s > 1`. -/ +-lemma summable_vonMangoldt_div_rpow {s : ℝ} (hs : 1 < s) : Summable (fun n ↦ Λ n / n ^ s) := by +- have h_log_bound : ∀ n : ℕ, (Λ n : ℝ) ≤ Real.log n := fun n ↦ vonMangoldt_le_log +- suffices h_log_sum : Summable fun n : ℕ ↦ Real.log n / (n : ℝ) ^ s by +- exact .of_nonneg_of_le (fun n ↦ div_nonneg vonMangoldt_nonneg (by positivity)) +- (fun n ↦ div_le_div_of_nonneg_right (h_log_bound n) (by positivity)) h_log_sum +- have h_log_le_n_eps : ∀ ε > 0, ∃ C > 0, ∀ n : ℕ, n ≥ 2 → Real.log n / (n : ℝ) ^ s ≤ C * (n : ℝ) ^ (ε - s) := by +- intro ε hε_pos +- obtain ⟨C, hC_pos, hC⟩ : ∃ C > 0, ∀ n : ℕ, n ≥ 2 → Real.log n ≤ C * (n : ℝ) ^ ε := by +- refine ⟨1 / ε, by positivity, fun n hn ↦ ?_⟩ +- have := log_le_sub_one_of_pos (by positivity : 0 < (n : ℝ) ^ ε) +- rw [log_rpow (by positivity)] at this +- nlinarith [rpow_pos_of_pos (by positivity : 0 < (n : ℝ)) ε, mul_div_cancel₀ 1 hε_pos.ne'] +- refine ⟨C, hC_pos, fun n hn ↦ ?_⟩ +- rw [rpow_sub (by positivity)] +- exact le_trans (div_le_div_of_nonneg_right (hC n hn) (by positivity)) (by rw [div_eq_mul_inv]; ring_nf; norm_num) +- obtain ⟨C, _, hC⟩ : ∃ C > 0, ∀ n : ℕ, n ≥ 2 → Real.log n / (n : ℝ) ^ s ≤ C * (n : ℝ) ^ ((s - 1) / 2 - s) := +- h_log_le_n_eps ((s - 1) / 2) (by linarith) +- rw [← summable_nat_add_iff 2] +- exact Summable.of_nonneg_of_le (fun n ↦ div_nonneg (log_nonneg (by norm_cast; omega)) +- (rpow_nonneg (by positivity) _)) (fun n ↦ hC _ (by omega)) (Summable.mul_left _ <| by +- simpa using summable_nat_add_iff 2 |>.2 <| summable_nat_rpow.2 <| by linarith) +- +-@[blueprint "WeakPNT-AP" +- (title := "WeakPNT-AP") +- (statement := /-- +- If $q ≥ 1$ and $a$ is coprime to $q$, we have +- $$ \sum_{n \leq x: n = a\ (q)} \Lambda(n) = \frac{x}{\varphi(q)} + o(x).$$ +- -/) +- (proof := /-- Apply Theorem \ref{WienerIkehara} (or Theorem \ref{WienerIkehara2} to avoid +- checking the Chebyshev condition) using Proposition \ref{WeakPNT-AP-prelim}.-/) +- (proofUses := ["WienerIkehara", "WeakPNT-AP-prelim"])] +-theorem WeakPNT_AP {q : ℕ} {a : ℕ} (hq : q ≥ 1) (ha : a.Coprime q) (ha' : a < q) : +- Tendsto (fun N ↦ cumsum (fun n ↦ if n % q = a then Λ n else 0) N / N) atTop (𝓝 (1 / q.totient)) := by +- have h_summable : ∀ s : ℝ, 1 < s → Summable (fun n ↦ (if n % q = a then Λ n else 0) / n ^ s) := by +- intro s hs +- refine .of_nonneg_of_le (fun n ↦ ?_) (fun n ↦ ?_) (summable_vonMangoldt_div_rpow hs) +- · split_ifs <;> positivity +- · split_ifs <;> norm_num; exact div_nonneg vonMangoldt_nonneg (by positivity) +- obtain ⟨G, hG₁, hG₂⟩ := WeakPNT_AP_prelim hq ha ha' +- convert WienerIkeharaTheorem'' _ _ _ _ using 1 +- · use G +- · intro n +- simp_all only [ge_iff_le, one_div, mul_inv_rev, Pi.ofNat_apply] +- split +- next h => subst h; simp_all only [vonMangoldt_nonneg] +- next h => simp_all only [le_refl] +- · intro σ' hσ' +- specialize h_summable σ' hσ' +- simp_all only [ge_iff_le, one_div, mul_inv_rev] +- convert h_summable using 1 +- ext +- simp only [nterm, norm_real, norm_eq_abs] +- ring_nf +- split_ifs <;> simp [*, mul_comm] +- · assumption +- · convert hG₂ using 3 +- · exact tsum_congr fun n ↦ by cases n <;> aesop +- · norm_num [div_eq_mul_inv, mul_assoc, mul_comm, mul_left_comm] +- +- +-blueprint_comment /-- +-\section{The Chebotarev density theorem: the case of cyclotomic extensions} +- +-Throughout this section, $K$ is a number field, $m \geq 1$ is a fixed integer, +-$L = K(\mu_m)$, and $G = \mathrm{Gal}(L/K)$. (In particular $G$ is abelian, and for +-$K=\mathbb{Q}$ one recovers $G \cong (\mathbb{Z}/m\mathbb{Z})^\times$.) +-Write $\zeta_K$ and $\zeta_L$ for the Dedekind zeta functions of $K$ and $L$, and for +-an abelian character $\chi : G \to \mathbb{C}^\times$ write $L(\chi,s)$ for the associated +-Artin $L$-function (equivalently, the Hecke $L$-function of the ideal character attached to +-$\chi$; cf.\ Notation~7.1.17 and Proposition~7.1.18 of +-\url{https://www.math.ucla.edu/~sharifi/algnum.pdf}). +- +-The goal of this section is to prove the Chebotarev density theorem in the cyclotomic case +-(Proposition~\ref{Chebotarev-cyclotomic-density} below), following the classical argument via +-Artin $L$-functions as in Sharifi, Propositions~7.1.16--7.1.19 and Proposition~7.2.1. The +-abelian and general cases are then reduced to this one in the subsequent sections. +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Artin $L$-function as Euler product]\label{Artin-L-euler} +-Let $\chi : G \to \mathbb{C}^\times$ be an abelian character. For $\Re(s) > 1$ one has +-\[ +-L(\chi,s) \;=\; \prod_{\mathfrak{p}} \bigl(1 - \chi(\mathfrak{p})\, N\mathfrak{p}^{-s}\bigr)^{-1} +-\;=\; \sum_{\mathfrak{a} \subseteq \mathcal{O}_K} \chi(\mathfrak{a})\, N\mathfrak{a}^{-s}, +-\] +-where the product runs over nonzero prime ideals of $\mathcal{O}_K$, with the convention +-$\chi(\mathfrak{p}) = 0$ if $\mathfrak{p}$ ramifies in the fixed field of $\ker\chi$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof} +-This is the specialisation of the Artin Euler product (Definition~7.1.15 of Sharifi) to +-abelian characters; see Proposition~7.1.18 of +-\url{https://www.math.ucla.edu/~sharifi/algnum.pdf}. Absolute convergence for $\Re(s)>1$ +-follows from comparison with $\zeta_K(s)$. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Dedekind-factor]\label{Dedekind-factor} +-For $\Re(s) > 1$ one has +-\[ +-\zeta_L(s) \;=\; \prod_{\chi : G \to \mathbb{C}^\times} L(\chi,s), +-\] +-where the product runs over all (necessarily one-dimensional) irreducible characters of $G$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof}\uses{Artin-L-euler} +-In general, for a Galois extension $L/K$ and characters $\chi$ of irreducible representations of +-$\mathrm{Gal}(L/K)$, Proposition~7.1.16 of +-\url{https://www.math.ucla.edu/~sharifi/algnum.pdf} gives +-$\zeta_L(s) = \prod_\chi L(\chi,s)^{\chi(1)}$ for $\Re(s)>1$. In the present abelian +-(cyclotomic) setting every irreducible character is one-dimensional, so $\chi(1)=1$ and the +-exponents disappear. Alternatively, comparing Euler factors at an unramified prime +-$\mathfrak{p}$: the primes of $L$ above $\mathfrak{p}$ contribute the factor +-$(1 - N\mathfrak{p}^{-fs})^{-g}$ to $\zeta_L$, while the Artin factors multiply to the same +-quantity by the usual identity $\prod_\chi (1 - \chi(\varphi_{\mathfrak{p}}) X) = 1 - X^f$ +-(with $X = N\mathfrak{p}^{-s}$ and $f$ the residue degree). +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Simple pole]\label{Dedekind-pole} +-The Dedekind zeta function $\zeta_L$ admits a meromorphic continuation to a neighbourhood of +-the line $\Re(s)=1$ with a single simple pole at $s=1$ (and is otherwise holomorphic and +-nonvanishing on that line after removing the pole). In particular +-$\log \zeta_L(s) \sim \log(s-1)^{-1}$ as $s \to 1^+$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof} +-This is the standard analytic continuation of Dedekind zeta (Theorem~7.1.12 of +-\url{https://www.math.ucla.edu/~sharifi/algnum.pdf}): absolute convergence of the ideal +-Dirichlet series and Euler product for $\Re(s)>1$, meromorphic continuation across +-$\Re(s)>1-[L:\mathbb{Q}]^{-1}$, and a simple pole at $s=1$. The logarithmic asymptotic is +-immediate from the simple pole. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Continuation of nontrivial Artin $L$-functions]\label{Artin-L-continuation} +-Let $\chi : G \to \mathbb{C}^\times$ be a nontrivial character. Then $L(\chi,s)$ extends to an +-analytic function on the half-plane $\Re(s) > 1 - [K:\mathbb{Q}]^{-1}$, and in particular is +-holomorphic at $s=1$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof} +-Following Proposition~7.1.19 of \url{https://www.math.ucla.edu/~sharifi/algnum.pdf}: let $n$ +-be the order of $\chi$. Geometry of numbers supplies the estimate that, for each $n$th root of +-unity $\zeta$, the number of ideals $\mathfrak{a}$ with $N\mathfrak{a} \leq N$ and +-$\chi(\mathfrak{a})=\zeta$ is $CN + O\bigl(N^{1-[K:\mathbb{Q}]^{-1}}\bigr)$ with $C$ independent of +-$\zeta$. Summing against $\zeta$ cancels the main terms, so +-$\sum_{N\mathfrak{a}\leq N} \chi(\mathfrak{a}) = O\bigl(N^{1-[K:\mathbb{Q}]^{-1}}\bigr)$. +-Lemma~7.1.5 of Sharifi then yields absolute uniform convergence of +-$\sum_{\mathfrak{a}} \chi(\mathfrak{a})\, N\mathfrak{a}^{-s}$ on compact subsets of +-$\Re(s) > 1 - [K:\mathbb{Q}]^{-1}$. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Dedekind-nonvanishing]\label{Dedekind-nonvanishing} +-For any nontrivial character $\chi$ of $G = \mathrm{Gal}(L/K)$, one has $L(\chi,1) \neq 0$. +-Moreover $L(\chi,s)$ does not vanish for $\Re(s)=1$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof}\uses{Dedekind-factor, Dedekind-pole, Artin-L-continuation} +-For the value at $s=1$: write $\log\zeta_L(t) = \sum_\chi \log L(\chi,t)$ for real $t>1$. +-As $t\to 1^+$, the left side is $\sim \log(t-1)^{-1}$ by Lemma~\ref{Dedekind-pole}. If some +-nontrivial $L(\chi,\cdot)$ had a zero of order $m_\chi \geq 1$ at $s=1$, the right side would +-behave like $\bigl(1 - \sum_\chi m_\chi\bigr)\log(t-1)^{-1}$ up to a bounded error +-(the trivial character contributes the pole of $\zeta_K$, absorbed into the factorisation), +-forcing $1-\sum m_\chi \leq 0$, a contradiction. Hence $L(\chi,1)\neq 0$ for all nontrivial +-$\chi$ (Sharifi, Proposition~7.1.19). +- +-For the rest of the line $\Re(s)=1$, $s\neq 1$: adapt the classical nonvanishing argument for +-Dirichlet $L$-functions (comparison of $\zeta_L(s)$, $\zeta_L(s)^3\,|L(\chi,s)|^4$, or the +-$3+4\operatorname{Re}$ inequality) using the Euler product of Lemma~\ref{Artin-L-euler} and the +-absence of poles of nontrivial $L(\chi,\cdot)$ on $\Re(s)=1$ from +-Lemma~\ref{Artin-L-continuation}. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Orthogonality for Frobenius classes]\label{Chebotarev-orthogonality} +-Fix $\sigma \in G$. For every prime ideal $\mathfrak{p}$ of $\mathcal{O}_K$ unramified in $L$, +-\[ +-\sum_{\chi : G \to \mathbb{C}^\times} \chi(\sigma)^{-1}\,\chi(\varphi_{\mathfrak{p}}) +-\;=\; +-\begin{cases} +-|G| & \text{if }\varphi_{\mathfrak{p}} = \sigma,\\ +-0 & \text{otherwise.} +-\end{cases} +-\] +-Equivalently, if $\sigma(\zeta_m) = \zeta_m^a$ with $\gcd(a,m)=1$, the sum equals $|G|$ +-precisely when $N\mathfrak{p} \equiv a \pmod{m}$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof} +-Standard character orthogonality on the finite abelian group $G$. The reformulation in terms +-of $N\mathfrak{p} \bmod m$ uses that $\varphi_{\mathfrak{p}}(\zeta_m) = \zeta_m^{N\mathfrak{p}}$ +-for the cyclotomic character. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{proposition}[Cyclotomic Chebotarev density]\label{Chebotarev-cyclotomic-density} +-For every $\sigma \in G$, the set of prime ideals $\mathfrak{p}$ of $K$ unramified in $L$ with +-Frobenius $\varphi_{\mathfrak{p}} = \sigma$ has Dirichlet density $1/|G|$. +-\end{proposition} +--/ +- +-blueprint_comment /-- +-\begin{proof}\uses{Dedekind-factor, Dedekind-pole, Dedekind-nonvanishing, Artin-L-euler, +-Chebotarev-orthogonality} +-This is Proposition~7.2.1 of \url{https://www.math.ucla.edu/~sharifi/algnum.pdf}. For +-$\Re(s)>1$ one has $\log L(\chi,s) \sim \sum_{\mathfrak{p}} \chi(\mathfrak{p})\, N\mathfrak{p}^{-s}$. +-Summing against $\chi(\sigma)^{-1}$ and applying Lemma~\ref{Chebotarev-orthogonality} yields +-\[ +-\sum_{\chi} \chi(\sigma)^{-1} \log L(\chi,s) +-\;\sim\; +-|G| \sum_{\varphi_{\mathfrak{p}}=\sigma} N\mathfrak{p}^{-s}. +-\] +-On the other hand, by Lemmas~\ref{Dedekind-factor} and~\ref{Dedekind-nonvanishing} the left +-side is $\sim \log\zeta_K(s) \sim \log(s-1)^{-1}$ as $s\to 1^+$ (only the trivial character +-contributes a pole). Comparing the two asymptotics gives the asserted Dirichlet density. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{lemma}[PNT for one character]\label{Dedekind-PNT} +-For any nontrivial character $\chi$ of $G$, +-\[ +-\sum_{N\mathfrak{p} \leq x} \chi(\mathfrak{p})\, \log N\mathfrak{p} \;=\; o(x) +-\qquad(x\to\infty). +-\] +-(Equivalently, writing $\Lambda_\chi$ for the von Mangoldt-type coefficients of $-\frac{L'}{L}(\chi,s)$, +-one has $\sum_{n\leq x} \Lambda_\chi(n) = o(x)$.) +-\end{lemma} +- +-\emph{Remark on prime powers.} +-Expanding $-\frac{L'}{L}(\chi,s)$ as a Dirichlet series selects coefficients supported on +-prime powers $\mathfrak{p}^j$ with weight $\chi(\varphi_{\mathfrak{p}})^j\log N\mathfrak{p}$. +-Thus an \emph{exact} identity expressing $-\sum_\chi \chi(\sigma)^{-1}\frac{L'}{L}(\chi,s)$ as a +-sum over primes with Frobenius $\sigma$ should use the condition $\varphi_{\mathfrak{p}}^j=\sigma$ +-rather than $\varphi_{\mathfrak{p}}=\sigma$. For the density statement in +-Proposition~\ref{Chebotarev-cyclotomic-density} this distinction is immaterial: the $j=1$ terms +-agree with the Frobenius condition, while the $j\geq 2$ terms converge absolutely for +-$\Re(s)>1/2$ and do not affect the residue at $s=1$. +--/ +- +-blueprint_comment /-- +-\begin{proof}\uses{Dedekind-nonvanishing, Artin-L-continuation} +-By Lemmas~\ref{Artin-L-continuation} and~\ref{Dedekind-nonvanishing}, $L(\chi,s)$ is holomorphic +-and nonvanishing on $\Re(s)\geq 1$, so $-\frac{L'}{L}(\chi,s)$ extends continuously to +-$\Re(s)\geq 1$. The claimed prime-sum estimate then follows by the same Wiener--Ikehara / +-Ingham contour argument used for Dirichlet $L$-functions in the prime-number theorem in +-arithmetic progressions (cf.\ the material already formalised for Dirichlet $L$-functions +-earlier in this file). Passing through $\Lambda_\chi$ (rather than the bare prime sum) makes +-the $j\geq 2$ prime-power contributions explicit and shows they are $O(x^{1/2}\log x)$, +-hence absorbable in the $o(x)$ error; cf.\ the remark after the statement. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\section{The Chebotarev density theorem: the case of abelian extensions} +- +-Now let $L/K$ be an arbitrary finite abelian extension with Galois group $G$, and fix +-$\sigma \in G$. The goal is to show that the primes of $K$ with Frobenius $\sigma$ still have +-Dirichlet density $1/|G|$, by reducing to the cyclotomic case already treated. +-(Cf.\ Theorem~7.2.2, Step~2, of \url{https://www.math.ucla.edu/~sharifi/algnum.pdf}; cyclic +-extensions already suffice for the later reduction to the general case.) +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Cyclotomic crossing]\label{Chebotarev-abelian-crossing} +-Choose an integer $m\geq 1$ not dividing the discriminant of $L/K$, large enough that +-$H := \mathrm{Gal}(L(\mu_m)/L) \cong (\mathbb{Z}/m\mathbb{Z})^\times$ via the cyclotomic character +-and $\mathrm{Gal}(L(\mu_m)/K) \cong G \times H$. For $\sigma\in G$ and $\tau\in H$ write +-$S_{\sigma,\tau}$ for the set of primes of $K$ unramified in $L(\mu_m)$ with Frobenius +-$(\sigma,\tau)\in G\times H$, and $S_\sigma$ for the set of primes of $K$ unramified in $L$ +-with Frobenius $\sigma$ in $G$. Then +-\[ +-\delta_{\mathrm{inf}}(S_\sigma) \;=\; \sum_{\tau\in H} \delta_{\mathrm{inf}}(S_{\sigma,\tau}). +-\] +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof} +-Every prime counted in $S_\sigma$ lifts to primes in the various $S_{\sigma,\tau}$ according to +-the Frobenius in the cyclotomic layer; the identity of lower densities is the usual additivity +-of Dirichlet densities over a finite partition (up to the finitely many ramified primes). +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Density after cyclotomic crossing]\label{Chebotarev-abelian-density} +-In the notation of Lemma~\ref{Chebotarev-abelian-crossing}, if the order of $\tau\in H$ is +-divisible by $|G|$, then $\langle(\sigma,\tau)\rangle \cap (G\times\{1\}) = \{1\}$, so +-$L(\mu_m)$ is obtained by adjoining $\mu_m$ to the fixed field +-$F := L(\mu_m)^{\langle(\sigma,\tau)\rangle}$. Applying Proposition~\ref{Chebotarev-cyclotomic-density} +-to the cyclotomic extension $F(\mu_m)/F$ and transporting densities as in the reduction step +-of Theorem~7.2.2 yields $\delta(S_{\sigma,\tau}) = 1/(|G|\,|H|)$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof}\uses{Chebotarev-cyclotomic-density, Chebotarev-abelian-crossing} +-See Sharifi, Theorem~7.2.2, Step~2 (display after ``Now suppose that $|G|$ divides the order of +-$\tau$''). +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{proposition}[Abelian Chebotarev]\label{Chebotarev-abelian} +-Let $L/K$ be finite abelian with Galois group $G$. For every $\sigma\in G$, the Dirichlet +-density of primes of $K$ with Frobenius $\sigma$ exists and equals $1/|G|$. +-\end{proposition} +--/ +- +-blueprint_comment /-- +-\begin{proof}\uses{Chebotarev-abelian-crossing, Chebotarev-abelian-density, +-Chebotarev-cyclotomic-density} +-Let $H_n \subset H$ be the set of elements whose order is divisible by $n$. Summing the +-densities of Lemma~\ref{Chebotarev-abelian-density} over $\tau\in H_n$ gives +-$\delta_{\mathrm{inf}}(S_\sigma) \geq |H_n|/(|G|\,|H|)$. Choosing $m$ so that $|H_n|/|H|$ is +-arbitrarily close to $1$ (possible since there are primes $m\equiv 1\pmod{n^j}$ by the +-cyclotomic case already proved, and $|H_n|/|H|$ tends to $1$ as $j\to\infty$), one obtains +-$\delta_{\mathrm{inf}}(S_\sigma) \geq 1/|G|$. Summing over $\sigma\in G$ forces equality +-throughout, so each density exists and equals $1/|G|$. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\section{The Chebotarev density theorem: the general case} +- +-Finally let $L/K$ be an arbitrary finite Galois extension with group $G$, and let $C\subset G$ +-be a conjugacy class. The theorem reduces to the abelian (indeed cyclic) case already proved, +-by passing to the fixed field of an element of $C$. +--/ +- +-blueprint_comment /-- +-\begin{lemma}[Reduction to a cyclic subextension]\label{Chebotarev-reduction} +-Fix $\sigma\in C$ and let $E$ be the fixed field of $\langle\sigma\rangle$, so $L/E$ is cyclic of +-degree $f = |\langle\sigma\rangle|$. Write $S$ for the set of primes of $K$ unramified in $L$ +-whose Frobenius class equals $C$, and $T_\sigma$ for the set of primes $\mathfrak{P}$ of $E$ +-unramified in $L$ (and lying over $K$) with Frobenius equal to $\sigma$. Then +-\[ +-\delta(S) \;=\; \frac{f\,|C|}{|G|}\,\delta(T_\sigma), +-\] +-whenever either density exists. In particular, the Chebotarev statement for $L/K$ and $C$ +-follows from the abelian statement for the cyclic extension $L/E$ and the element $\sigma$. +-\end{lemma} +--/ +- +-blueprint_comment /-- +-\begin{proof} +-If $\mathfrak{P}\in T_\sigma$, then $\varphi_{\mathfrak{P}}=\sigma$ fixes $E$, so $\mathfrak{P}$ has +-residue degree one over $K$. There are exactly $|G|/f$ primes of $L$ over $\mathfrak{P}\cap K$, +-and their Frobenii are equidistributed among the $|C|$ elements of the conjugacy class $C$; +-exactly $|G|/(f\,|C|)$ of them have Frobenius $\sigma$. Comparing the Dirichlet series +-$\sum N\mathfrak{p}^{-s}$ over $S$ with $\sum N\mathfrak{P}^{-s}$ over $T_\sigma$ (and using +-$\sum_{\mathfrak{p}} N\mathfrak{p}^{-s} \sim \sum_{\mathfrak{P}} N\mathfrak{P}^{-s}$) yields the +-displayed identity. See Sharifi, Theorem~7.2.2, Step~1. +-\end{proof} +--/ +- +-blueprint_comment /-- +-\begin{theorem}[Chebotarev density theorem]\label{Chebotarev-general} +-Let $L/K$ be a finite Galois extension of number fields with Galois group $G$, and let +-$C\subset G$ be a conjugacy class. The set of prime ideals $\mathfrak{p}$ of $K$ unramified in +-$L$ whose Frobenius conjugacy class equals $C$ has Dirichlet density $|C|/|G|$. +-\end{theorem} +--/ +- +-blueprint_comment /-- +-\begin{proof}\uses{Chebotarev-reduction, Chebotarev-abelian} +-Combine Lemma~\ref{Chebotarev-reduction} with Proposition~\ref{Chebotarev-abelian} applied to +-the cyclic extension $L/E$: the latter gives $\delta(T_\sigma) = 1/f$, whence +-$\delta(S) = |C|/|G|$. +-\end{proof} +--/ +diff --git a/PrimeNumberTheoremAnd/ZetaFive.lean b/PrimeNumberTheoremAnd/ZetaFive.lean +new file mode 100644 +index 0000000..6e3d2a8 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/ZetaFive.lean +@@ -0,0 +1,5 @@ ++import PrimeNumberTheoremAnd.ZetaFive.Sobolev ++import PrimeNumberTheoremAnd.ZetaFive.Fourier ++import PrimeNumberTheoremAnd.ZetaFive.SmoothExistence ++import PrimeNumberTheoremAnd.ZetaFive.Wiener ++import PrimeNumberTheoremAnd.ZetaFive.Consequences +diff --git a/PrimeNumberTheoremAnd/ZetaFive/Consequences.lean b/PrimeNumberTheoremAnd/ZetaFive/Consequences.lean +new file mode 100644 +index 0000000..aa7c25c +--- /dev/null ++++ b/PrimeNumberTheoremAnd/ZetaFive/Consequences.lean +@@ -0,0 +1,66 @@ ++import Mathlib.Analysis.Asymptotics.SpecificAsymptotics ++import Mathlib.Analysis.SpecialFunctions.Log.Basic ++import PrimeNumberTheoremAnd.ZetaFive.Wiener ++ ++namespace ZetaFivePNT ++ ++open ArithmeticFunction hiding log ++open Nat hiding log ++open _root_.Finset ++open BigOperators _root_.Filter _root_.Real _root_.Asymptotics ++open scoped Chebyshev ++ ++theorem WeakPNT' : Tendsto (fun N ↦ (∑ n ∈ Iic N, Λ n) / N) atTop (nhds 1) := by ++ have : (fun N ↦ (∑ n ∈ Iic N, Λ n) / N) = ++ (fun N ↦ (∑ n ∈ range N, Λ n)/N + Λ N / N) := by ++ ext N ++ have : N ∈ Iic N := mem_Iic.mpr (le_refl _) ++ rw [← Finset.sum_erase_add _ _ this, ← Nat.Iio_eq_range, Iic_erase] ++ exact add_div _ _ _ ++ rw [this, ← add_zero 1] ++ apply Tendsto.add WeakPNT ++ convert squeeze_zero (f := fun N ↦ Λ N / N) (g := fun N ↦ log N / N) (t₀ := atTop) ?_ ?_ ?_ ++ · intro N ++ exact div_nonneg vonMangoldt_nonneg (cast_nonneg N) ++ · intro N ++ exact div_le_div_of_nonneg_right vonMangoldt_le_log (cast_nonneg N) ++ simpa only [Function.comp_def, pow_one, one_mul, add_zero] using ++ (Real.tendsto_pow_log_div_mul_add_atTop 1 0 1 one_ne_zero).comp ++ tendsto_natCast_atTop_atTop ++ ++theorem WeakPNT'' : ψ ~[atTop] (fun x ↦ x) := by ++ rw [(by rfl : ψ = (fun x ↦ ψ x))] ++ simp_rw [Chebyshev.psi_eq_sum_Icc] ++ apply IsEquivalent.trans (v := fun x ↦ (⌊x⌋₊:ℝ)) ++ · rw [isEquivalent_iff_tendsto_one] ++ · convert Tendsto.comp WeakPNT' (tendsto_nat_floor_atTop (α := ℝ)) using 1 ++ ext x ++ rfl ++ rw [eventually_iff] ++ simp only [ne_eq, cast_eq_zero, floor_eq_zero, not_lt, mem_atTop_sets, ++ Set.mem_ofPred_eq] ++ use 1 ++ simp only [imp_self, implies_true] ++ exact Asymptotics.isEquivalent_nat_floor ++ ++theorem isLittleO_sqrt_mul_log : (fun x : ℝ ↦ x.sqrt * x.log) =o[atTop] _root_.id := by ++ have : (fun x : ℝ ↦ x.sqrt * x.log) =o[atTop] fun x ↦ x := by ++ refine (isLittleO_mul_iff_isLittleO_div ?_).mpr ?_ ++ · filter_upwards [eventually_gt_atTop 0] with x hx; exact (sqrt_ne_zero hx.le).mpr hx.ne' ++ · convert isLittleO_log_rpow_atTop (by norm_num : (0 : ℝ) < 1 / 2) using 2 with x ++ rw [div_sqrt, sqrt_eq_rpow] ++ exact this ++ ++theorem chebyshev_asymptotic : θ ~[atTop] id := by ++ rw [← sub_sub_self ψ θ] ++ refine WeakPNT''.sub_isLittleO ++ (IsBigO.trans_isLittleO (g := fun x ↦ 2 * x.sqrt * x.log) ?_ ?_) ++ · rw [isBigO_iff']; refine ⟨1, one_pos, ?_⟩ ++ simp only [one_mul, eventually_atTop] ++ exact ⟨2, fun x hx ↦ by ++ rw [Pi.sub_apply, norm_eq_abs, norm_eq_abs, abs_of_nonneg (by bound : 0 ≤ 2 * √x * log x)] ++ exact (abs_of_nonneg (sub_nonneg.mpr (Chebyshev.theta_le_psi x))).symm ▸ ++ Chebyshev.abs_psi_sub_theta_le_sqrt_mul_log (by linarith : 1 ≤ x)⟩ ++ · convert isLittleO_sqrt_mul_log.const_mul_left 2 using 1 <;> first | rfl | (funext x; ring) ++ ++end ZetaFivePNT +diff --git a/PrimeNumberTheoremAnd/ZetaFive/Fourier.lean b/PrimeNumberTheoremAnd/ZetaFive/Fourier.lean +new file mode 100644 +index 0000000..95d8904 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/ZetaFive/Fourier.lean +@@ -0,0 +1,42 @@ ++import Mathlib.Topology.ContinuousMap.Bounded.Basic ++import Mathlib.Analysis.Fourier.FourierTransformDeriv ++import PrimeNumberTheoremAnd.ZetaFive.Sobolev ++ ++namespace ZetaFivePNT ++ ++open FourierTransform Real Complex MeasureTheory Filter Topology BoundedContinuousFunction ++ SchwartzMap VectorFourier BigOperators ++ ++section lemmas ++ ++@[simp] theorem F_neg {f : ℝ → ℂ} {u : ℝ} : 𝓕 (fun x => -f x) u = - 𝓕 f u := by ++ simp [fourier_eq, integral_neg] ++ ++@[simp] theorem F_add {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : ++ 𝓕 (fun x => f x + g x) x = 𝓕 f x + 𝓕 g x := by ++ exact congr_fun (fourierIntegral_add continuous_fourierChar continuous_inner hf hg) x ++ ++@[simp] theorem F_sub {f g : ℝ → ℂ} (hf : Integrable f) (hg : Integrable g) (x : ℝ) : ++ 𝓕 (fun x => f x - g x) x = 𝓕 f x - 𝓕 g x := by ++ simpa [sub_eq_add_neg, Pi.neg_def] using F_add hf hg.neg x ++ ++@[simp] theorem F_mul {f : ℝ → ℂ} {c : ℂ} {u : ℝ} : ++ 𝓕 (fun x => c * f x) u = c * 𝓕 f u := by ++ exact congr_fun (VectorFourier.fourierIntegral_const_smul 𝐞 _ _ f c) u ++ ++end lemmas ++ ++theorem fourierIntegral_self_add_deriv_deriv (f : W21) (u : ℝ) : ++ (1 + u ^ 2) * 𝓕 (f : ℝ → ℂ) u = ++ 𝓕 (fun u : ℝ => (f u - (1 / (4 * π ^ 2)) * deriv^[2] f u : ℂ)) u := by ++ have l1 : Integrable (fun x => (((π : ℂ) ^ 2)⁻¹ * 4⁻¹) * deriv (deriv f) x) := by ++ apply Integrable.const_mul ; simpa [iteratedDeriv_succ] using f.integrable le_rfl ++ have l4 : Differentiable ℝ f := f.differentiable ++ have l5 : Differentiable ℝ (deriv f) := f.deriv.differentiable ++ simp [f.hf, l1, add_mul, Real.fourier_deriv f.hf' l5 f.hf'', Real.fourier_deriv f.hf l4 f.hf'] ++ field_simp [pi_ne_zero] ; ring_nf ; simp ++ ++@[simp] theorem deriv_ofReal : deriv ofReal = fun _ => 1 := by ++ ext x ; exact ((hasDerivAt_id x).ofReal_comp).deriv ++ ++end ZetaFivePNT +diff --git a/PrimeNumberTheoremAnd/ZetaFive/SmoothExistence.lean b/PrimeNumberTheoremAnd/ZetaFive/SmoothExistence.lean +new file mode 100644 +index 0000000..6dad927 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/ZetaFive/SmoothExistence.lean +@@ -0,0 +1,43 @@ ++import Mathlib.Geometry.Manifold.PartitionOfUnity ++import Mathlib.Tactic.Bound ++ ++namespace ZetaFivePNT ++ ++open MeasureTheory Set Real ++open scoped ContDiff ++ ++theorem smooth_urysohn_support_Ioo {a b c d : ℝ} (h1 : a < b) (h3 : c < d) : ++ ∃ Ψ : ℝ → ℝ, (ContDiff ℝ ∞ Ψ) ∧ (HasCompactSupport Ψ) ∧ ++ Set.indicator (Set.Icc b c) 1 ≤ Ψ ∧ Ψ ≤ Set.indicator (Set.Ioo a d) 1 ∧ ++ (Function.support Ψ = Set.Ioo a d) := by ++ have := exists_contDiff_zero_iff_one_iff_of_isClosed (n := ⊤) ++ (s := Set.Iic a ∪ Set.Ici d) (t := Set.Icc b c) ++ (IsClosed.union isClosed_Iic isClosed_Ici) isClosed_Icc ++ (by ++ simp_rw [Set.disjoint_union_left, Set.disjoint_iff, Set.subset_def, ++ Set.mem_inter_iff, Set.mem_Iic, Set.mem_Icc, Set.mem_empty_iff_false, ++ and_imp, imp_false, not_le, Set.mem_Ici] ++ constructor <;> intros <;> linarith) ++ obtain ⟨Ψ, hΨSmooth, hΨrange, hΨ0, hΨ1⟩ := this ++ simp only [Set.mem_union, Set.mem_Iic, Set.mem_Ici, Set.mem_Icc] at * ++ use Ψ ++ simp only [range_subset_iff, mem_Icc] at hΨrange ++ refine ⟨hΨSmooth, ?_, ?_, ?_, ?_⟩ ++ · apply HasCompactSupport.of_support_subset_isCompact (K := Set.Icc a d) isCompact_Icc ++ simp only [Function.support_subset_iff, ne_eq, mem_Icc, ← hΨ0, not_or] ++ bound ++ · apply Set.indicator_le' ++ · intro x hx ++ rw [hΨ1 x |>.mp, Pi.one_apply] ++ simpa using hx ++ · exact fun x _ ↦ (hΨrange x).1 ++ · intro x ++ apply Set.le_indicator_apply ++ · exact fun _ ↦ (hΨrange x).2 ++ · intro hx ++ rw [← hΨ0 x |>.mp] ++ simpa [-not_and, mem_Ioo, not_and_or, not_lt] using hx ++ · ext x ++ simp only [Function.mem_support, ne_eq, mem_Ioo, ← hΨ0, not_or, not_le] ++ ++end ZetaFivePNT +diff --git a/PrimeNumberTheoremAnd/ZetaFive/Sobolev.lean b/PrimeNumberTheoremAnd/ZetaFive/Sobolev.lean +new file mode 100644 +index 0000000..10b6035 +--- /dev/null ++++ b/PrimeNumberTheoremAnd/ZetaFive/Sobolev.lean +@@ -0,0 +1,401 @@ ++import Mathlib.Analysis.Calculus.Deriv.Support ++import Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas ++import Mathlib.Analysis.Distribution.SchwartzSpace.Deriv ++import Mathlib.Order.Filter.ZeroAndBoundedAtFilter ++ ++namespace ZetaFivePNT ++ ++open Real Complex MeasureTheory Filter Topology BoundedContinuousFunction SchwartzMap BigOperators ++open scoped ContDiff ++ ++variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] {n : ℕ} ++ ++ ++ ++structure CS (n : ℕ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] where ++ ++ toFun : ℝ → E ++ h1 : ContDiff ℝ n toFun ++ h2 : HasCompactSupport toFun ++ ++@[ext] protected theorem CS.ext {n : ℕ} {E : Type*} ++ [NormedAddCommGroup E] [NormedSpace ℝ E] {x y : CS n E} ++ (h : x.toFun = y.toFun) : x = y := by ++ cases x ++ cases y ++ cases h ++ rfl ++ ++ ++ ++structure trunc extends (CS 2 ℝ) where ++ h3 : (Set.Icc (-1) (1)).indicator 1 ≤ toFun ++ h4 : toFun ≤ Set.indicator (Set.Ioo (-2) (2)) 1 ++ ++ ++ ++structure W1 (n : ℕ) (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] where ++ ++ toFun : ℝ → E ++ smooth : ContDiff ℝ n toFun ++ integrable : ∀ ⦃k⦄, k ≤ n → Integrable (iteratedDeriv k toFun) ++ ++ ++ ++abbrev W21 := W1 2 ℂ ++ ++section lemmas ++ ++ ++noncomputable def funscale {E : Type*} (g : ℝ → E) (R x : ℝ) : E := g (R⁻¹ • x) ++ ++theorem contDiff_ofReal : ContDiff ℝ ∞ ofReal := Complex.ofRealCLM.contDiff ++ ++omit [NormedSpace ℝ E] in ++theorem tendsto_funscale {f : ℝ → E} (hf : ContinuousAt f 0) (x : ℝ) : ++ Tendsto (fun R => funscale f R x) atTop (𝓝 (f 0)) := ++ hf.tendsto.comp (by simpa using tendsto_inv_atTop_zero.mul_const x) ++ ++end lemmas ++ ++namespace CS ++ ++variable {f : CS n E} {R x v : ℝ} ++ ++instance : CoeFun (CS n E) (fun _ => ℝ → E) where coe := CS.toFun ++ ++instance : Coe (CS n ℝ) (CS n ℂ) where coe f := ⟨fun x => f x, ++ contDiff_ofReal.of_le (mod_cast le_top) |>.comp f.h1, f.h2.comp_left (g := ofReal) rfl⟩ ++ ++ ++def neg (f : CS n E) : CS n E where ++ toFun := -f ++ h1 := f.h1.neg ++ h2 := f.h2.neg ++ ++instance : Neg (CS n E) where neg := neg ++ ++@[simp] theorem neg_apply {x : ℝ} : (-f) x = - (f x) := rfl ++ ++ ++def smul (R : ℝ) (f : CS n E) : CS n E := ⟨R • f, f.h1.const_smul R, f.h2.smul_left⟩ ++ ++instance : HSMul ℝ (CS n E) (CS n E) where hSMul := smul ++ ++@[simp] theorem smul_apply : (R • f) x = R • f x := rfl ++ ++theorem continuous (f : CS n E) : Continuous f := f.h1.continuous ++ ++ ++ ++noncomputable def deriv (f : CS (n + 1) E) : CS n E where ++ toFun := _root_.deriv f ++ h1 := (contDiff_succ_iff_deriv.mp f.h1).2.2 ++ h2 := f.h2.deriv ++ ++theorem hasDerivAt (f : CS (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := ++ (f.h1.differentiable (by simp)).differentiableAt.hasDerivAt ++ ++theorem deriv_apply {f : CS (n + 1) E} {x : ℝ} : f.deriv x = _root_.deriv f x := rfl ++ ++theorem deriv_smul {f : CS (n + 1) E} : (R • f).deriv = R • f.deriv := by ++ ext x ; exact (f.hasDerivAt x |>.const_smul R).deriv ++ ++ ++ ++noncomputable def scale (g : CS n E) (R : ℝ) : CS n E := by ++ by_cases h : R = 0 ++ · exact ⟨0, contDiff_const, by simp [HasCompactSupport, tsupport]⟩ ++ · refine ⟨fun x => funscale g R x, ?_, ?_⟩ ++ · exact g.h1.comp (contDiff_const_smul R⁻¹) ++ · exact g.h2.comp_smul (inv_ne_zero h) ++ ++theorem deriv_scale {f : CS (n + 1) E} : (f.scale R).deriv = R⁻¹ • f.deriv.scale R := by ++ ext v ; by_cases hR : R = 0 ++ · simp [hR, scale, deriv] ++ · simp only [scale, hR, ↓reduceDIte, smul_apply] ++ exact ((f.hasDerivAt (R⁻¹ • v)).scomp v ++ (by convert (hasDerivAt_const_mul (x := v) R⁻¹) using 1)).deriv ++ ++theorem deriv_scale' {f : CS (n + 1) E} : ++ (f.scale R).deriv v = R⁻¹ • f.deriv (R⁻¹ • v) := by ++ rw [deriv_scale, smul_apply] ++ by_cases hR : R = 0 <;> simp [hR, scale, funscale] ++ ++theorem hasDerivAt_scale (f : CS (n + 1) E) (R x : ℝ) : ++ HasDerivAt (f.scale R) (R⁻¹ • _root_.deriv f (R⁻¹ • x)) x := by ++ convert hasDerivAt (f.scale R) x ; rw [deriv_scale'] ; rfl ++ ++theorem tendsto_scale (f : CS n E) (x : ℝ) : Tendsto (fun R => f.scale R x) atTop (𝓝 (f 0)) := by ++ apply (tendsto_funscale f.continuous.continuousAt x).congr' ++ filter_upwards [eventually_ne_atTop 0] with R hR ; simp [scale, hR] ++ ++theorem bounded : ∃ C, ∀ v, ‖f v‖ ≤ C := by ++ obtain ⟨x, hx⟩ := ++ (continuous_norm.comp f.continuous).exists_forall_ge_of_hasCompactSupport f.h2.norm ++ exact ⟨_, hx⟩ ++ ++end CS ++ ++namespace trunc ++ ++instance : CoeFun trunc (fun _ => ℝ → ℝ) where coe f := f.toFun ++ ++instance : Coe trunc (CS 2 ℝ) where coe := trunc.toCS ++ ++theorem nonneg (g : trunc) (x : ℝ) : 0 ≤ g x := (Set.indicator_nonneg (by simp) x).trans (g.h3 x) ++ ++theorem le_one (g : trunc) (x : ℝ) : g x ≤ 1 := ++ (g.h4 x).trans <| Set.indicator_le_self' (by simp) x ++ ++theorem zero (g : trunc) : g =ᶠ[𝓝 0] 1 := by ++ have : Set.Icc (-1) 1 ∈ 𝓝 (0 : ℝ) := by apply Icc_mem_nhds <;> linarith ++ exact eventually_of_mem this (fun x hx => le_antisymm (g.le_one x) (by simpa [hx] using g.h3 x)) ++ ++@[simp] theorem zero_at {g : trunc} : g 0 = 1 := g.zero.eq_of_nhds ++ ++end trunc ++ ++namespace W1 ++ ++instance : CoeFun (W1 n E) (fun _ => ℝ → E) where coe := W1.toFun ++ ++theorem continuous (f : W1 n E) : Continuous f := f.smooth.continuous ++ ++theorem differentiable (f : W1 (n + 1) E) : Differentiable ℝ f := ++ f.smooth.differentiable (by simp) ++ ++theorem iteratedDeriv_sub {f g : ℝ → E} (hf : ContDiff ℝ n f) (hg : ContDiff ℝ n g) : ++ iteratedDeriv n (f - g) = iteratedDeriv n f - iteratedDeriv n g := by ++ funext x ++ exact _root_.iteratedDeriv_sub hf.contDiffAt hg.contDiffAt ++ ++ ++ ++noncomputable def deriv (f : W1 (n + 1) E) : W1 n E where ++ toFun := _root_.deriv f ++ smooth := contDiff_succ_iff_deriv.mp f.smooth |>.2.2 ++ integrable k hk := by ++ simpa [iteratedDeriv_succ'] using f.integrable (Nat.succ_le_succ hk) ++ ++theorem hasDerivAt (f : W1 (n + 1) E) (x : ℝ) : HasDerivAt f (f.deriv x) x := ++ f.differentiable.differentiableAt.hasDerivAt ++ ++ ++ ++def sub (f g : W1 n E) : W1 n E where ++ toFun := f - g ++ smooth := f.smooth.sub g.smooth ++ integrable k hk := by ++ have hf : ContDiff ℝ k f := f.smooth.of_le (by simp [hk]) ++ have hg : ContDiff ℝ k g := g.smooth.of_le (by simp [hk]) ++ simpa [iteratedDeriv_sub hf hg] using (f.integrable hk).sub (g.integrable hk) ++ ++instance : Sub (W1 n E) where sub := sub ++ ++theorem integrable_iteratedDeriv_Schwarz {f : 𝓢(ℝ, ℂ)} : Integrable (iteratedDeriv n f) := by ++ induction n generalizing f with ++ | zero => exact f.integrable ++ | succ n ih => ++ rw [iteratedDeriv_succ'] ++ have hd : (SchwartzMap.derivCLM ℝ ℂ f : ℝ → ℂ) = _root_.deriv f := by ++ funext x ++ exact SchwartzMap.derivCLM_apply ℝ f x ++ rw [← hd] ++ exact ih (f := SchwartzMap.derivCLM ℝ ℂ f) ++ ++ ++ ++noncomputable def ofSchwartz (f : 𝓢(ℝ, ℂ)) : W1 n ℂ where ++ toFun := f ++ smooth := f.smooth n ++ integrable _ _ := integrable_iteratedDeriv_Schwarz ++ ++end W1 ++ ++namespace W21 ++ ++variable {f : W21} ++ ++ ++ ++noncomputable def norm (f : ℝ → ℂ) : ℝ := ++ (∫ v, ‖f v‖) + (4 * π ^ 2)⁻¹ * (∫ v, ‖deriv (deriv f) v‖) ++ ++theorem norm_nonneg {f : ℝ → ℂ} : 0 ≤ norm f := ++ add_nonneg (integral_nonneg (fun t => by simp)) ++ (mul_nonneg (by positivity) (integral_nonneg (fun t => by simp))) ++ ++noncomputable instance : Norm W21 where norm := norm ∘ W1.toFun ++ ++noncomputable instance : Coe 𝓢(ℝ, ℂ) W21 where coe := W1.ofSchwartz ++ ++ ++def ofCS2 (f : CS 2 ℂ) : W21 := by ++ refine ⟨f, f.h1, ?_⟩ ++ intro k hk ++ cases k with ++ | zero => exact f.h1.continuous.integrable_of_hasCompactSupport f.h2 ++ | succ k => ++ cases k with ++ | zero => ++ simpa using (f.h1.continuous_deriv one_le_two).integrable_of_hasCompactSupport f.h2.deriv ++ | succ k => ++ have hk0 : k = 0 := ++ Nat.eq_zero_of_le_zero (Nat.le_of_succ_le_succ (Nat.le_of_succ_le_succ hk)) ++ subst k ++ simpa [iteratedDeriv_succ] using ++ (f.h1.iterate_deriv' 0 2).continuous.integrable_of_hasCompactSupport f.h2.deriv.deriv ++ ++instance : Coe (CS 2 ℂ) W21 where coe := ofCS2 ++ ++instance : HMul (CS 2 ℂ) W21 (CS 2 ℂ) where ++ hMul g f := ⟨g * f, g.h1.mul f.smooth, g.h2.mul_right⟩ ++ ++instance : HMul (CS 2 ℝ) W21 (CS 2 ℂ) where hMul g f := (g : CS 2 ℂ) * f ++ ++theorem hf (f : W21) : Integrable f := f.integrable zero_le_two ++ ++theorem hf' (f : W21) : Integrable (deriv f) := by ++ simpa [iteratedDeriv_succ] using f.integrable one_le_two ++ ++theorem hf'' (f : W21) : Integrable (deriv (deriv f)) := by ++ simpa [iteratedDeriv_succ] using f.integrable le_rfl ++ ++end W21 ++ ++theorem W21_approximation (f : W21) (g : trunc) : ++ Tendsto (fun R => ‖f - (g.scale R * f : W21)‖) atTop (𝓝 0) := by ++ ++ let f' := f.deriv ++ let f'' := f'.deriv ++ let g' := (g : CS 2 ℝ).deriv ++ let g'' := g'.deriv ++ let h R v := 1 - g.scale R v ++ let h' R := - (g.scale R).deriv ++ let h'' R := - (g.scale R).deriv.deriv ++ ++ have ch {R} : Continuous (fun v => (h R v : ℂ)) := ++ continuous_ofReal.comp <| continuous_const.sub (CS.continuous _) ++ have ch' {R} : Continuous (fun v => (h' R v : ℂ)) := continuous_ofReal.comp (CS.continuous _) ++ have ch'' {R} : Continuous (fun v => (h'' R v : ℂ)) := continuous_ofReal.comp (CS.continuous _) ++ have dh R v : HasDerivAt (h R) (h' R v) v := by ++ convert CS.hasDerivAt_scale (g : CS 2 ℝ) R v |>.const_sub 1 using 1 ++ simp [h', CS.deriv_scale', show g.deriv.toFun = deriv g.toFun from rfl] ++ have dh' R v : HasDerivAt (h' R) (h'' R v) v := ((g.scale R).deriv.hasDerivAt v).neg ++ have hh1 R v : |h R v| ≤ 1 := by ++ by_cases hR : R = 0 <;> ++ simp only [CS.scale, funscale, smul_eq_mul, hR, ↓reduceDIte, Pi.zero_apply, sub_zero, ++ abs_one, le_refl, h] ++ rw [abs_le] ; constructor <;> ++ linarith [g.le_one (R⁻¹ * v), g.nonneg (R⁻¹ * v)] ++ have vR v : Tendsto (fun R : ℝ => v * R⁻¹) atTop (𝓝 0) := by ++ simpa using tendsto_inv_atTop_zero.const_mul v ++ ++ convert_to Tendsto (fun R => W21.norm (fun v => h R v * f v)) atTop (𝓝 0) ++ · ext R ; change W21.norm _ = _ ; congr ; ext v ; simp [h, sub_mul] ; rfl ++ rw [show (0 : ℝ) = 0 + ((4 * π ^ 2)⁻¹ : ℝ) * 0 by simp] ++ refine Tendsto.add ?_ (Tendsto.const_mul _ ?_) ++ · let F R v := ‖h R v * f v‖ ++ have eh v : ∀ᶠ R in atTop, h R v = 0 := by ++ filter_upwards [(vR v).eventually g.zero, eventually_ne_atTop 0] with R hR hR' ++ simp [h, hR, CS.scale, hR', funscale, mul_comm R⁻¹] ++ have e1 : ∀ᶠ (n : ℝ) in atTop, AEStronglyMeasurable (F n) volume := by ++ apply Eventually.of_forall ; intro R ++ exact (ch.mul f.continuous).norm.aestronglyMeasurable ++ have e2 : ∀ᶠ (n : ℝ) in atTop, ∀ᵐ (a : ℝ), ‖F n a‖ ≤ ‖f a‖ := by ++ apply Eventually.of_forall ; intro R ++ apply Eventually.of_forall ; intro v ++ simpa [F] using mul_le_mul (hh1 R v) le_rfl (by simp) zero_le_one ++ have e4 : ∀ᵐ (a : ℝ), Tendsto (fun n ↦ F n a) atTop (𝓝 0) := by ++ apply Eventually.of_forall ; intro v ++ apply tendsto_nhds_of_eventually_eq ; filter_upwards [eh v] with R hR ; simp [F, hR] ++ simpa [F] using tendsto_integral_filter_of_dominated_convergence _ e1 e2 f.hf.norm e4 ++ · let F R v := ‖h'' R v * f v + 2 * h' R v * f' v + h R v * f'' v‖ ++ convert_to Tendsto (fun R ↦ ∫ (v : ℝ), F R v) atTop (𝓝 0) ++ · have this R v : ++ deriv (deriv (fun v => h R v * f v)) v = ++ h'' R v * f v + 2 * h' R v * f' v + h R v * f'' v := by ++ have df v : HasDerivAt f (f' v) v := f.hasDerivAt v ++ have df' v : HasDerivAt f' (f'' v) v := f'.hasDerivAt v ++ have l3 v : HasDerivAt (fun v => h R v * f v) (h' R v * f v + h R v * f' v) v := ++ (dh R v).ofReal_comp.mul (df v) ++ have l5 : HasDerivAt (fun v => h' R v * f v) (h'' R v * f v + h' R v * f' v) v := ++ (dh' R v).ofReal_comp.mul (df v) ++ have l7 : HasDerivAt (fun v => h R v * f' v) (h' R v * f' v + h R v * f'' v) v := ++ (dh R v).ofReal_comp.mul (df' v) ++ have d1 : deriv (fun v => h R v * f v) = fun v => h' R v * f v + h R v * f' v := ++ funext (fun v => (l3 v).deriv) ++ rw [d1] ; convert (l5.add l7).deriv using 1 ; ring ++ simp_rw [this, F] ++ obtain ⟨c1, mg'⟩ := g'.bounded ++ obtain ⟨c2, mg''⟩ := g''.bounded ++ let bound v := c2 * ‖f v‖ + 2 * c1 * ‖f' v‖ + ‖f'' v‖ ++ have e1 : ∀ᶠ (n : ℝ) in atTop, AEStronglyMeasurable (F n) volume := by ++ apply Eventually.of_forall ; intro R ; apply (Continuous.norm ?_).aestronglyMeasurable ++ exact ((ch''.mul f.continuous).add ((continuous_const.mul ch').mul f.deriv.continuous)).add ++ (ch.mul f.deriv.deriv.continuous) ++ have e2 : ∀ᶠ R in atTop, ∀ᵐ (a : ℝ), ‖F R a‖ ≤ bound a := by ++ have hc1 : ∀ᶠ R in atTop, ∀ v, |h' R v| ≤ c1 := by ++ filter_upwards [eventually_ge_atTop 1] with R hR v ++ have hR' : R ≠ 0 := by linarith ++ have : 0 ≤ R := by linarith ++ simp only [CS.deriv_scale, CS.neg_apply, CS.smul_apply, smul_eq_mul, abs_neg, abs_mul, ++ abs_inv, abs_eq_self.mpr this, ge_iff_le, h'] ++ simp only [CS.scale, hR', ↓reduceDIte, funscale, smul_eq_mul] ++ convert_to _ ≤ c1 * 1 ++ · simp ++ · rw [mul_comm] ++ apply mul_le_mul (mg' _) ++ (inv_le_of_inv_le₀ (by linarith) (by simpa using hR)) (by positivity) ++ exact (abs_nonneg _).trans (mg' 0) ++ have hc2 : ∀ᶠ R in atTop, ∀ v, |h'' R v| ≤ c2 := by ++ filter_upwards [eventually_ge_atTop 1] with R hR v ++ have e1 : 0 ≤ R := by linarith ++ have e2 : R⁻¹ ≤ 1 := inv_le_of_inv_le₀ (by linarith) (by simpa using hR) ++ have e3 : R ≠ 0 := by linarith ++ simp only [CS.deriv_scale, CS.deriv_smul, CS.neg_apply, CS.smul_apply, smul_eq_mul, abs_neg, ++ abs_mul, abs_inv, abs_eq_self.mpr e1, ge_iff_le, h''] ++ convert_to _ ≤ 1 * (1 * c2) ++ · simp ++ apply mul_le_mul e2 ?_ (by positivity) zero_le_one ++ apply mul_le_mul e2 ?_ (by positivity) zero_le_one ++ simp only [CS.scale, e3, ↓reduceDIte, funscale, smul_eq_mul] ; apply mg'' ++ filter_upwards [hc1, hc2] with R hc1 hc2 ++ apply Eventually.of_forall ; intro v ; specialize hc1 v ; specialize hc2 v ++ simp only [F, bound, norm_norm] ++ refine (norm_add_le _ _).trans ?_ ; apply add_le_add ++ · refine (norm_add_le _ _).trans ?_ ; apply add_le_add <;> simp only [Complex.norm_mul, ++ Complex.norm_ofNat, norm_real, norm_eq_abs] <;> gcongr ++ · simpa using mul_le_mul (hh1 R v) le_rfl (by simp) zero_le_one ++ have e3 : Integrable bound volume := ++ (((f.hf.norm).const_mul _).add ((f.hf'.norm).const_mul _)).add f.hf''.norm ++ have e4 : ∀ᵐ (a : ℝ), Tendsto (fun n ↦ F n a) atTop (𝓝 0) := by ++ apply Eventually.of_forall ; intro v ++ have evg' : (g' : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) := by ++ have hzero : (g : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 1) := g.zero ++ change _root_.deriv (g : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) ++ simpa only [deriv_const'] using hzero.deriv ++ have evg'' : (g'' : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) := by ++ change _root_.deriv (g' : ℝ → ℝ) =ᶠ[𝓝 (0 : ℝ)] (fun _ : ℝ => 0) ++ simpa only [deriv_const'] using evg'.deriv ++ refine tendsto_norm_zero.comp <| (ZeroAtFilter.add ?_ ?_).add ?_ ++ · have eh'' v : ∀ᶠ R in atTop, h'' R v = 0 := by ++ filter_upwards [(vR v).eventually evg'', eventually_ne_atTop 0] with R hR hR' ++ simp only [CS.deriv_scale, CS.deriv_smul, CS.neg_apply, CS.smul_apply, smul_eq_mul, ++ neg_eq_zero, mul_eq_zero, inv_eq_zero, hR', false_or, h''] ++ simp only [CS.scale, hR', ↓reduceDIte, funscale, smul_eq_mul, mul_comm R⁻¹] ++ exact hR ++ apply tendsto_nhds_of_eventually_eq ++ filter_upwards [eh'' v] with R hR ; simp [hR] ++ · have eh' v : ∀ᶠ R in atTop, h' R v = 0 := by ++ filter_upwards [(vR v).eventually evg'] with R hR ++ simp [g'] at hR ++ simp [h', CS.deriv_scale', mul_comm R⁻¹, hR] ++ apply tendsto_nhds_of_eventually_eq ++ filter_upwards [eh' v] with R hR ; simp [hR] ++ · simpa [h, Filter.ZeroAtFilter] using ++ ((g.tendsto_scale v).const_sub 1).ofReal.mul tendsto_const_nhds ++ simpa [F] using tendsto_integral_filter_of_dominated_convergence bound e1 e2 e3 e4 ++ ++end ZetaFivePNT +diff --git a/PrimeNumberTheoremAnd/ZetaFive/Wiener.lean b/PrimeNumberTheoremAnd/ZetaFive/Wiener.lean +new file mode 100644 +index 0000000..18c58cb +--- /dev/null ++++ b/PrimeNumberTheoremAnd/ZetaFive/Wiener.lean +@@ -0,0 +1,2358 @@ ++import Mathlib.Analysis.Fourier.RiemannLebesgueLemma ++import Mathlib.Analysis.Normed.Group.Tannery ++import Mathlib.Analysis.SumIntegralComparisons ++import Mathlib.NumberTheory.Chebyshev ++import Mathlib.NumberTheory.LSeries.PrimesInAP ++import Mathlib.NumberTheory.MulChar.Lemmas ++import PrimeNumberTheoremAnd.ZetaFive.Fourier ++import PrimeNumberTheoremAnd.ZetaFive.SmoothExistence ++import Mathlib.Analysis.Convolution ++import Mathlib.MeasureTheory.Group.Circle ++ ++namespace ZetaFivePNT ++ ++open Real BigOperators ArithmeticFunction MeasureTheory Filter Set FourierTransform LSeries ++ Asymptotics SchwartzMap ++open Complex hiding log ++open scoped Topology ++open scoped ContDiff ++open scoped ComplexConjugate ++ ++variable {n : ℕ} {A a b c d u x y t σ' : ℝ} {ψ Ψ : ℝ → ℂ} {F G : ℂ → ℂ} {f : ℕ → ℂ} {𝕜 : Type} ++ [RCLike 𝕜] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++noncomputable ++def nterm (f : ℕ → ℂ) (σ' : ℝ) (n : ℕ) : ℝ := if n = 0 then 0 else ‖f n‖ / n ^ σ' ++ ++theorem nterm_eq_norm_term {f : ℕ → ℂ} : nterm f σ' n = ‖term f σ' n‖ := by ++ by_cases h : n = 0 <;> simp [nterm, term, h] ++ ++theorem norm_term_eq_nterm_re (s : ℂ) : ++ ‖term f s n‖ = nterm f (s.re) n := by ++ simpa only [nterm] using LSeries.norm_term_eq f s n ++ ++theorem hf_coe1 (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (hσ : 1 < σ') : ++ ∑' i, (‖term f σ' i‖₊ : ENNReal) ≠ ⊤ := by ++ simp_rw [ENNReal.tsum_coe_ne_top_iff_summable_coe, ← norm_toNNReal] ++ norm_cast ++ apply Summable.toNNReal ++ convert hf σ' hσ with i ++ simp [nterm_eq_norm_term] ++ ++ ++attribute [fun_prop] Real.continuous_fourierChar ++ ++theorem first_fourier_aux1 (hψ : AEMeasurable ψ) {x : ℝ} (n : ℕ) : AEMeasurable fun (u : ℝ) ↦ ++ (‖fourierChar (-(u * ((1 : ℝ) / ((2 : ℝ) * π) * (n / x).log))) • ψ u‖ₑ : ENNReal) := by ++ fun_prop ++ ++theorem first_fourier_aux2a : ++ (2 : ℂ) * π * -(y * (1 / (2 * π) * Real.log ((n) / x))) = -(y * ((n) / x).log) := by ++ calc ++ _ = -(y * (((2 : ℂ) * π) / (2 * π) * Real.log ((n) / x))) := by ring ++ _ = _ := by rw [div_self (by norm_num), one_mul] ++ ++theorem first_fourier_aux2 (hx : 0 < x) (n : ℕ) : ++ term f σ' n * 𝐞 (-(y * (1 / (2 * π) * Real.log (n / x)))) • ψ y = ++ term f (σ' + y * I) n • (ψ y * x ^ (y * I)) := by ++ by_cases hn : n = 0 ++ · simp [term, hn] ++ simp only [term, hn, ↓reduceIte] ++ calc ++ _ = (f n * (cexp ((2 * π * -(y * (1 / (2 * π) * Real.log (n / x)))) * I) / ++ ↑((n : ℝ) ^ σ'))) • ψ y := by ++ rw [Circle.smul_def, fourierChar_apply, ofReal_cpow (by norm_num)] ++ simp only [one_div, mul_inv_rev, mul_neg, ofReal_neg, ofReal_mul, ofReal_ofNat, ofReal_inv, ++ neg_mul, smul_eq_mul, ofReal_natCast] ++ ring ++ _ = (f n * (x ^ (y * I) / n ^ (σ' + y * I))) • ψ y := by ++ congr 2 ++ have l1 : 0 < (n : ℝ) := by simpa using Nat.pos_iff_ne_zero.mpr hn ++ have l2 : (x : ℂ) ≠ 0 := by simp [hx.ne.symm] ++ have l3 : (n : ℂ) ≠ 0 := by simp [hn] ++ rw [Real.rpow_def_of_pos l1, Complex.cpow_def_of_ne_zero l2, Complex.cpow_def_of_ne_zero l3] ++ push_cast ++ simp_rw [← Complex.exp_sub] ++ congr 1 ++ rw [first_fourier_aux2a, Real.log_div l1.ne.symm hx.ne.symm] ++ push_cast ++ rw [Complex.ofReal_log hx.le] ++ ring ++ _ = _ := by simp ; group ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem first_fourier (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hsupp : Integrable ψ) (hx : 0 < x) (hσ : 1 < σ') : ++ ∑' n : ℕ, term f σ' n * (𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))) = ++ ∫ t : ℝ, LSeries f (σ' + t * I) * ψ t * x ^ (t * I) := by ++ calc ++ _ = ∑' n, term f σ' n * ∫ (v : ℝ), 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ simp only [Real.fourier_eq] ++ simp only [one_div, mul_inv_rev, RCLike.inner_apply', conj_trivial] ++ _ = ∑' n, ∫ (v : ℝ), term f σ' n * 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ simp [integral_const_mul] ++ _ = ∫ (v : ℝ), ∑' n, term f σ' n * 𝐞 (-(v * ((1 : ℝ) / ++ ((2 : ℝ) * π) * Real.log (n / x)))) • ψ v := by ++ refine (integral_tsum ?_ ?_).symm ++ · refine fun _ ↦ AEMeasurable.aestronglyMeasurable ?_ ++ have := hsupp.aemeasurable ++ fun_prop ++ · simp only [enorm_mul] ++ simp_rw [lintegral_const_mul'' _ (first_fourier_aux1 hsupp.aemeasurable _)] ++ calc ++ _ = (∑' (i : ℕ), ‖term f σ' i‖ₑ) * ∫⁻ (a : ℝ), ‖ψ a‖ₑ ∂volume := by ++ simp [ENNReal.tsum_mul_right, enorm_eq_nnnorm] ++ _ ≠ ⊤ := ENNReal.mul_ne_top (hf_coe1 hf hσ) ++ (ne_top_of_lt hsupp.2) ++ _ = _ := by ++ congr 1; ext y ++ simp_rw [mul_assoc (LSeries _ _), ← smul_eq_mul (a := (LSeries _ _)), LSeries] ++ rw [← Summable.tsum_smul_const] ++ · simp_rw [first_fourier_aux2 hx] ++ · apply Summable.of_norm ++ convert hf σ' hσ with n ++ rw [norm_term_eq_nterm_re] ++ simp ++ ++ ++ ++@[continuity] ++theorem continuous_multiplicative_ofAdd : Continuous (⇑Multiplicative.ofAdd : ℝ → ℝ) := ⟨fun _ ↦ id⟩ ++ ++attribute [fun_prop] measurable_coe_nnreal_ennreal ++ ++theorem second_fourier_integrable_aux1a (hσ : 1 < σ') : ++ IntegrableOn (fun (x : ℝ) ↦ cexp (-((x : ℂ) * ((σ' : ℂ) - 1)))) (Ici (-Real.log x)) := by ++ norm_cast ++ suffices IntegrableOn (fun (x : ℝ) ↦ (rexp (-(x * (σ' - 1))))) (Ici (-x.log)) _ from this.ofReal ++ simp_rw [fun (a x : ℝ) ↦ (by ring : -(x * a) = -a * x)] ++ rw [integrableOn_Ici_iff_integrableOn_Ioi] ++ apply exp_neg_integrableOn_Ioi ++ linarith ++ ++theorem second_fourier_integrable_aux1 (hcont : Measurable ψ) (hsupp : Integrable ψ) (hσ : 1 < σ') : ++ let ν : Measure (ℝ × ℝ) := (volume.restrict (Ici (-Real.log x))).prod volume ++ Integrable (Function.uncurry fun (u : ℝ) (a : ℝ) ↦ ((rexp (-u * (σ' - 1))) : ℂ) • ++ (𝐞 (Multiplicative.ofAdd (-(a * (u / (2 * π))))) : ℂ) • ψ a) ν := by ++ intro ν ++ constructor ++ · apply Measurable.aestronglyMeasurable ++ change Measurable (fun p : ℝ × ℝ => ++ (rexp (-p.1 * (σ' - 1)) : ℂ) * ++ ((fourierChar (-(p.2 * (p.1 / (2 * π)))) : ℂ) * ψ p.2)) ++ fun_prop ++ · let f1 : ℝ → ENNReal := fun a1 ↦ ‖cexp (-(↑a1 * (↑σ' - 1)))‖ₑ ++ let f2 : ℝ → ENNReal := fun a2 ↦ ‖ψ a2‖ₑ ++ suffices ∫⁻ (a : ℝ × ℝ), f1 a.1 * f2 a.2 ∂ν < ⊤ by ++ simpa [hasFiniteIntegral_iff_enorm, enorm_eq_nnnorm, Function.uncurry] ++ refine (lintegral_prod_mul ?_ ?_).trans_lt ?_ <;> try fun_prop ++ exact ENNReal.mul_lt_top (second_fourier_integrable_aux1a hσ).2 hsupp.2 ++ ++theorem second_fourier_integrable_aux2 (hσ : 1 < σ') : ++ IntegrableOn (fun (u : ℝ) ↦ cexp ((1 - ↑σ' - ↑t * I) * ↑u)) (Ioi (-Real.log x)) := by ++ refine (integrable_norm_iff (Measurable.aestronglyMeasurable <| by fun_prop)).mp ?_ ++ suffices IntegrableOn (fun a ↦ rexp (-(σ' - 1) * a)) (Ioi (-x.log)) _ by simpa [Complex.norm_exp] ++ apply exp_neg_integrableOn_Ioi ++ linarith ++ ++theorem second_fourier_aux (hx : 0 < x) : ++ -(cexp (-((1 - ↑σ' - ↑t * I) * ↑(Real.log x))) / (1 - ↑σ' - ↑t * I)) = ++ ↑(x ^ (σ' - 1)) * (↑σ' + ↑t * I - 1)⁻¹ * ↑x ^ (↑t * I) := by ++ calc ++ _ = cexp (↑(Real.log x) * ((↑σ' - 1) + ↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [← div_neg]; ring_nf ++ _ = (x ^ ((↑σ' - 1) + ↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [Complex.cpow_def_of_ne_zero (ofReal_ne_zero.mpr (ne_of_gt hx)), Complex.ofReal_log hx.le] ++ _ = (x ^ ((σ' : ℂ) - 1)) * (x ^ (↑t * I)) * (↑σ' + ↑t * I - 1)⁻¹ := by ++ rw [Complex.cpow_add _ _ (ofReal_ne_zero.mpr (ne_of_gt hx))] ++ _ = _ := by rw [ofReal_cpow hx.le]; push_cast; ring ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem second_fourier (hcont : Measurable ψ) (hsupp : Integrable ψ) ++ {x σ' : ℝ} (hx : 0 < x) (hσ : 1 < σ') : ++ ∫ u in Ici (-log x), Real.exp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ (x^(σ' - 1) : ℝ) * ∫ t, (1 / (σ' + t * I - 1)) * ψ t * x^(t * I) ∂ volume := by ++ conv in ↑(rexp _) * _ => { rw [Real.fourier_real_eq, ← smul_eq_mul, ← integral_smul] } ++ rw [MeasureTheory.integral_integral_swap] ++ swap ++ · exact second_fourier_integrable_aux1 hcont hsupp hσ ++ rw [← integral_const_mul] ++ congr 1; ext t ++ simp_rw [Circle.smul_def, smul_eq_mul, Real.fourierChar_apply, ++ ← mul_assoc, integral_mul_const] ++ rw [mul_right_comm _ (ψ t) _] ++ congr 1 ++ push_cast ++ simp_rw [← Complex.exp_add] ++ have (u : ℝ) : ++ -↑u * (↑σ' - 1) + 2 * ↑π * -(↑t * (↑u / (2 * ↑π))) * I = (1 - σ' - t * I) * u := calc ++ _ = -↑u * (↑σ' - 1) + (2 * ↑π) / (2 * ↑π) * -(↑t * ↑u) * I := by ring ++ _ = -↑u * (↑σ' - 1) + 1 * -(↑t * ↑u) * I := by rw [div_self (by norm_num)] ++ _ = _ := by ring ++ simp_rw [this] ++ let c : ℂ := (1 - ↑σ' - ↑t * I) ++ have : c ≠ 0 := by simp [Complex.ext_iff, c, sub_ne_zero.mpr hσ.ne] ++ let f' (u : ℝ) := cexp (c * u) ++ let f := fun (u : ℝ) ↦ (f' u) / c ++ have hderiv : ∀ u ∈ Ici (-Real.log x), HasDerivAt f (f' u) u := by ++ intro u _ ++ rw [show f' u = cexp (c * u) * (c * 1) / c by simp only [f']; field_simp] ++ exact (hasDerivAt_id' u).ofReal_comp.const_mul c |>.cexp.div_const c ++ have hf : Tendsto f atTop (𝓝 0) := by ++ apply tendsto_zero_iff_norm_tendsto_zero.mpr ++ suffices Tendsto (fun (x : ℝ) ↦ ‖cexp (c * ↑x)‖ / ‖c‖) atTop (𝓝 (0 / ‖c‖)) by ++ simpa [f, f'] using this ++ apply Filter.Tendsto.div_const ++ suffices Tendsto (· * (1 - σ')) atTop atBot by simpa [Complex.norm_exp, mul_comm (1 - σ'), c] ++ exact Tendsto.atTop_mul_const_of_neg (by linarith) fun ⦃s⦄ h ↦ h ++ rw [integral_Ici_eq_integral_Ioi, ++ integral_Ioi_of_hasDerivAt_of_tendsto' hderiv (second_fourier_integrable_aux2 hσ) hf] ++ simpa [f, f'] using second_fourier_aux hx ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem one_add_sq_pos (u : ℝ) : 0 < 1 + u ^ 2 := zero_lt_one.trans_le (by simpa using sq_nonneg u) ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem decay_bounds_key (f : W21) (u : ℝ) : ‖𝓕 (f : ℝ → ℂ) u‖ ≤ ‖f‖ * (1 + u ^ 2)⁻¹ := by ++ have l1 : 0 < 1 + u ^ 2 := one_add_sq_pos _ ++ have l2 : 1 + u ^ 2 = ‖(1 : ℂ) + u ^ 2‖ := by ++ norm_cast ; simp only [Real.norm_eq_abs, abs_eq_self.2 l1.le] ++ have l3 : ‖1 / ((4 : ℂ) * ↑π ^ 2)‖ ≤ (4 * π ^ 2)⁻¹ := by simp ++ have key := fourierIntegral_self_add_deriv_deriv f u ++ simp only [Function.iterate_succ _ 1, Function.iterate_one, Function.comp_apply] at key ++ rw [F_sub f.hf (f.hf''.const_mul (1 / (4 * ↑π ^ 2)))] at key ++ rw [← div_eq_mul_inv, le_div_iff₀ l1, mul_comm, l2, ← norm_mul, key, sub_eq_add_neg] ++ apply norm_add_le _ _ |>.trans ++ change _ ≤ W21.norm _ ++ rw [norm_neg, F_mul, norm_mul, W21.norm] ++ gcongr <;> apply VectorFourier.norm_fourierIntegral_le_integral_norm ++ ++theorem decay_bounds_aux {f : ℝ → ℂ} (hf : AEStronglyMeasurable f volume) ++ (h : ∀ t, ‖f t‖ ≤ A * (1 + t ^ 2)⁻¹) : ++ ∫ t, ‖f t‖ ≤ π * A := by ++ have l1 : Integrable (fun x ↦ A * (1 + x ^ 2)⁻¹) := integrable_inv_one_add_sq.const_mul A ++ simp_rw [← integral_univ_inv_one_add_sq, mul_comm, ← integral_const_mul] ++ exact integral_mono (l1.mono' hf (Eventually.of_forall h)).norm l1 h ++ ++theorem decay_bounds_W21 (f : W21) (hA : ∀ t, ‖f t‖ ≤ A / (1 + t ^ 2)) ++ (hA' : ∀ t, ‖deriv (deriv f) t‖ ≤ A / (1 + t ^ 2)) (u) : ++ ‖𝓕 (f : ℝ → ℂ) u‖ ≤ (π + 1 / (4 * π)) * A / (1 + u ^ 2) := by ++ have l0 : 1 * (4 * π)⁻¹ * A = (4 * π ^ 2)⁻¹ * (π * A) := by field_simp ++ have l1 : ∫ (v : ℝ), ‖f v‖ ≤ π * A := by ++ apply decay_bounds_aux f.continuous.aestronglyMeasurable ++ simp_rw [← div_eq_mul_inv] ; exact hA ++ have l2 : ∫ (v : ℝ), ‖deriv (deriv f) v‖ ≤ π * A := by ++ apply decay_bounds_aux f.deriv.deriv.continuous.aestronglyMeasurable ++ simp_rw [← div_eq_mul_inv] ; exact hA' ++ apply decay_bounds_key f u |>.trans ++ change W21.norm _ * _ ≤ _ ++ simp_rw [W21.norm, div_eq_mul_inv, add_mul, l0] ; gcongr ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem decay_bounds (ψ : CS 2 ℂ) (hA : ∀ t, ‖ψ t‖ ≤ A / (1 + t ^ 2)) ++ (hA' : ∀ t, ‖deriv^[2] ψ t‖ ≤ A / (1 + t ^ 2)) : ++ ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ (π + 1 / (4 * π)) * A / (1 + u ^ 2) := by ++ exact decay_bounds_W21 ψ hA hA' u ++ ++theorem decay_bounds_cor_aux (ψ : CS 2 ℂ) : ∃ C : ℝ, ∀ u, ‖ψ u‖ ≤ C / (1 + u ^ 2) := by ++ have l1 : HasCompactSupport (fun u : ℝ => ((1 + u ^ 2) : ℝ) * ψ u) := by exact ψ.h2.mul_left ++ have := ψ.h1.continuous ++ obtain ⟨C, hC⟩ := l1.exists_bound_of_continuous (by fun_prop) ++ refine ⟨C, fun u => ?_⟩ ++ specialize hC u ++ simp only [norm_mul, Complex.norm_real, norm_of_nonneg (one_add_sq_pos u).le] at hC ++ rwa [le_div_iff₀' (one_add_sq_pos _)] ++ ++theorem decay_bounds_cor (ψ : W21) : ++ ∃ C : ℝ, ∀ u, ‖𝓕 (ψ : ℝ → ℂ) u‖ ≤ C / (1 + u ^ 2) := by ++ simpa only [div_eq_mul_inv] using ⟨_, decay_bounds_key ψ⟩ ++ ++@[continuity, fun_prop] theorem continuous_FourierIntegral (ψ : W21) : Continuous (𝓕 (ψ : ℝ → ℂ)) := ++ VectorFourier.fourierIntegral_continuous continuous_fourierChar ++ (by simp only [innerₗ_apply_apply, RCLike.inner_apply', conj_trivial, continuous_mul]) ++ ψ.hf ++ ++theorem W21.integrable_fourier (ψ : W21) (hc : c ≠ 0) : ++ Integrable fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c) := by ++ have l1 (C) : Integrable (fun u ↦ C / (1 + (u / c) ^ 2)) volume := by ++ simpa only [div_eq_mul_inv] using (integrable_inv_one_add_sq.comp_div hc).const_mul C ++ have l2 : AEStronglyMeasurable (fun u ↦ 𝓕 (ψ : ℝ → ℂ) (u / c)) volume := by ++ apply Continuous.aestronglyMeasurable ; fun_prop ++ obtain ⟨C, h⟩ := decay_bounds_cor ψ ++ apply @Integrable.mono' ℝ ℂ _ volume _ _ (fun u => C / (1 + (u / c) ^ 2)) (l1 C) l2 ?_ ++ apply Eventually.of_forall (fun x => h _) ++ ++ ++ ++ ++ ++theorem continuous_LSeries_aux (hf : Summable (nterm f σ')) : ++ Continuous fun x : ℝ => LSeries f (σ' + x * I) := by ++ have l1 i : Continuous fun x : ℝ ↦ term f (σ' + x * I) i := by ++ by_cases h : i = 0 ++ · simpa [h] using continuous_const ++ · simpa [h] using continuous_const.div₀ (continuous_const.cpow (by fun_prop) (by simp [h])) ++ (fun x => by simp [h]) ++ have l2 n (x : ℝ) : ‖term f (σ' + x * I) n‖ = nterm f σ' n := by ++ simpa using norm_term_eq_nterm_re (f := f) (n := n) (σ' + x * I) ++ exact continuous_tsum l1 hf (fun n x => le_of_eq (l2 n x)) ++ ++ ++theorem limiting_fourier_aux (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) (σ' : ℝ) ++ (hσ' : 1 < σ') : ++ ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * (x ^ (1 - σ') : ℝ) * ∫ u in Ici (- log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) ++ (u / (2 * π)) = ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I) := by ++ have hint : Integrable ψ := ψ.h1.continuous.integrable_of_hasCompactSupport ψ.h2 ++ have l3 : 0 < x := zero_lt_one.trans_le hx ++ have l1 (σ') (hσ' : 1 < σ') := first_fourier hf hint l3 hσ' ++ have l2 (σ') (hσ' : 1 < σ') := second_fourier ψ.h1.continuous.measurable hint l3 hσ' ++ have l8 : Continuous fun t : ℝ ↦ (x : ℂ) ^ (t * I) := ++ continuous_const.cpow (continuous_ofReal.mul continuous_const) (by simp [l3]) ++ have l6 : Continuous fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by ++ apply ((continuous_LSeries_aux (hf _ hσ')).mul ψ.h1.continuous).mul l8 ++ have l4 : Integrable fun t : ℝ ↦ LSeries f (↑σ' + ↑t * I) * ψ t * ↑x ^ (↑t * I) := by ++ exact l6.integrable_of_hasCompactSupport ψ.h2.mul_left.mul_right ++ have e2 (u : ℝ) : σ' + u * I - 1 ≠ 0 := by ++ intro h ; have := congr_arg Complex.re h ; simp at this ; linarith ++ have l7 : Continuous fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * ++ (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ simp only [one_div, ← mul_assoc] ++ refine ((continuous_const.mul <| Continuous.inv₀ ?_ e2).mul ψ.h1.continuous).mul l8 ++ fun_prop ++ have l5 : Integrable fun a ↦ A * ↑(x ^ (1 - σ')) * (↑(x ^ (σ' - 1)) * ++ (1 / (σ' + a * I - 1) * ψ a * x ^ (a * I))) := by ++ apply l7.integrable_of_hasCompactSupport ++ exact ψ.h2.mul_left.mul_right.mul_left.mul_left ++ simp_rw [l1 σ' hσ', l2 σ' hσ', ← integral_const_mul, ← integral_sub l4 l5] ++ apply integral_congr_ae ++ apply Eventually.of_forall ++ intro u ++ have e1 : 1 < ((σ' : ℂ) + (u : ℂ) * I).re := by simp [hσ'] ++ simp_rw [hG' e1, sub_mul, ← mul_assoc] ++ simp only [one_div, sub_right_inj, mul_eq_mul_right_iff, cpow_eq_zero_iff, ofReal_eq_zero, ne_eq, ++ mul_eq_zero, I_ne_zero, or_false] ++ left ; left ++ field_simp [e2] ++ norm_cast ++ simp [mul_assoc, ← rpow_add l3] ++ ++section nabla ++ ++variable {α E : Type*} [OfNat α 1] [Add α] [Sub α] {u : α → ℂ} ++ ++ ++def cumsum [AddCommMonoid E] (u : ℕ → E) (n : ℕ) : E := ∑ i ∈ Finset.range n, u i ++ ++ ++def nabla [Sub E] (u : α → E) (n : α) : E := u (n + 1) - u n ++ ++ ++ ++def nnabla [Sub E] (u : α → E) (n : α) : E := u n - u (n + 1) ++ ++ ++def shift (u : α → E) (n : α) : E := u (n + 1) ++ ++@[simp] theorem cumsum_zero [AddCommMonoid E] {u : ℕ → E} : cumsum u 0 = 0 := by simp [cumsum] ++ ++theorem cumsum_succ [AddCommMonoid E] {u : ℕ → E} (n : ℕ) : ++ cumsum u (n + 1) = cumsum u n + u n := by ++ simp [cumsum, Finset.sum_range_succ] ++ ++@[simp] theorem nabla_cumsum [AddCommGroup E] {u : ℕ → E} : nabla (cumsum u) = u := by ++ ext n ; simp [nabla, cumsum, Finset.range_add_one] ++ ++theorem neg_cumsum [AddCommGroup E] {u : ℕ → E} : -(cumsum u) = cumsum (-u) := ++ funext (fun n => by simp [cumsum]) ++ ++theorem cumsum_nonneg {u : ℕ → ℝ} (hu : 0 ≤ u) : 0 ≤ cumsum u := ++ fun _ => Finset.sum_nonneg (fun i _ => hu i) ++ ++omit [Sub α] in ++theorem neg_nabla [Ring E] {u : α → E} : -(nabla u) = nnabla u := by ext n ; simp [nabla, nnabla] ++ ++omit [Sub α] in ++@[simp] theorem nabla_mul [Ring E] {u : α → E} {c : E} : ++ nabla (fun n => c * u n) = c • nabla u := by ++ ext n ; simp [nabla, mul_sub] ++ ++omit [Sub α] in ++@[simp] theorem nnabla_mul [Ring E] {u : α → E} {c : E} : ++ nnabla (fun n => c * u n) = c • nnabla u := by ++ ext n ; simp [nnabla, mul_sub] ++ ++theorem nnabla_cast (u : ℝ → E) [Sub E] : nnabla u ∘ ((↑) : ℕ → ℝ) = nnabla (u ∘ (↑)) := by ++ ext n ; simp [nnabla] ++ ++end nabla ++ ++theorem Finset.sum_shift_front {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++ cumsum u (n + 1) = u 0 + cumsum (shift u) n := by ++ simp_rw [add_comm n, cumsum, _root_.Finset.sum_range_add, ++ _root_.Finset.sum_range_one, add_comm 1] ; rfl ++ ++theorem Finset.sum_shift_front' {E : Type*} [Ring E] {u : ℕ → E} : ++ shift (cumsum u) = (fun _ => u 0) + cumsum (shift u) := by ++ ext n ; apply Finset.sum_shift_front ++ ++theorem Finset.sum_shift_back {E : Type*} [Ring E] {u : ℕ → E} {n : ℕ} : ++ cumsum u (n + 1) = cumsum u n + u n := by ++ simp [cumsum, Finset.range_add_one, add_comm] ++ ++theorem Finset.sum_shift_back' {E : Type*} [Ring E] {u : ℕ → E} : ++ shift (cumsum u) = cumsum u + u := by ++ ext n ; apply Finset.sum_shift_back ++ ++theorem summation_by_parts {E : Type*} [Ring E] {a A b : ℕ → E} (ha : a = nabla A) {n : ℕ} : ++ cumsum (a * b) (n + 1) = A (n + 1) * b n - A 0 * b 0 - ++ cumsum (shift A * fun i => (b (i + 1) - b i)) n := by ++ have l1 : ∑ x ∈ Finset.range (n + 1), A (x + 1) * b x = ∑ x ∈ Finset.range n, ++ A (x + 1) * b x + A (n + 1) * b n := ++ Finset.sum_shift_back ++ have l2 : ∑ x ∈ Finset.range (n + 1), A x * b x = A 0 * b 0 + ∑ x ∈ Finset.range n, ++ A (x + 1) * b (x + 1) := ++ Finset.sum_shift_front ++ simp only [cumsum, ha, Pi.mul_apply, nabla, sub_mul, Finset.sum_sub_distrib, l1, l2, shift, ++ mul_sub] ++ abel ++ ++theorem summation_by_parts' {E : Type*} [Ring E] {a b : ℕ → E} {n : ℕ} : ++ cumsum (a * b) (n + 1) = cumsum a (n + 1) * b n - cumsum (shift (cumsum a) * nabla b) n := by ++ change cumsum (a * b) (n + 1) = cumsum a (n + 1) * b n - ++ cumsum (shift (cumsum a) * (fun i : ℕ => b (i + 1) - b i)) n ++ simpa using summation_by_parts (a := a) (b := b) (A := cumsum a) (by simp) ++ ++theorem summation_by_parts'' {E : Type*} [Ring E] {a b : ℕ → E} : ++ shift (cumsum (a * b)) = shift (cumsum a) * b - cumsum (shift (cumsum a) * nabla b) := by ++ ext n ; apply summation_by_parts' ++ ++theorem summable_iff_bounded {u : ℕ → ℝ} (hu : 0 ≤ u) : ++ Summable u ↔ BoundedAtFilter atTop (cumsum u) := by ++ have l1 : (cumsum u =O[atTop] 1) ↔ _ := isBigO_one_nat_atTop_iff ++ have l2 n : ‖cumsum u n‖ = cumsum u n := by simpa using cumsum_nonneg hu n ++ simp only [BoundedAtFilter, l1, l2] ++ constructor <;> intro h <;> rcases h with ⟨C, h1⟩ ++ · exact ⟨C, fun n => sum_le_hasSum _ (fun i _ => hu i) h1⟩ ++ · exact summable_of_sum_range_le hu h1 ++ ++theorem Filter.EventuallyEq.summable {u v : ℕ → ℝ} (h : u =ᶠ[atTop] v) (hu : Summable v) : ++ Summable u := ++ summable_of_isBigO_nat hu h.isBigO ++ ++theorem summable_congr_ae {u v : ℕ → ℝ} (huv : u =ᶠ[atTop] v) : Summable u ↔ Summable v := by ++ exact ⟨ZetaFivePNT.Filter.EventuallyEq.summable huv.symm, ++ ZetaFivePNT.Filter.EventuallyEq.summable huv⟩ ++ ++theorem BoundedAtFilter.add_const {u : ℕ → ℝ} {c : ℝ} : ++ BoundedAtFilter atTop (fun n => u n + c) ↔ BoundedAtFilter atTop u := by ++ have : u = fun n => (u n + c) + (-c) := by ext n ; ring ++ simp only [BoundedAtFilter] ++ constructor <;> intro h ++ on_goal 1 => rw [this] ++ all_goals { exact h.add (const_boundedAtFilter _ _) } ++ ++theorem BoundedAtFilter.comp_add {u : ℕ → ℝ} {N : ℕ} : ++ BoundedAtFilter atTop (fun n => u (n + N)) ↔ BoundedAtFilter atTop u := by ++ simp only [BoundedAtFilter, isBigO_iff, norm_eq_abs, Pi.one_apply, one_mem, ++ CStarRing.norm_of_mem_unitary, mul_one, eventually_atTop] ++ constructor <;> intro hbound <;> rcases hbound with ⟨C, n₀, h⟩ <;> use C ++ · refine ⟨n₀ + N, fun n hn => ?_⟩ ++ obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le' (m := N) (n := n) (by grind) ++ exact h _ <| Nat.add_le_add_iff_right.mp hn ++ · exact ⟨n₀, fun n hn => h _ (by grind)⟩ ++ ++theorem summable_iff_bounded' {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, 0 ≤ u n) : ++ Summable u ↔ BoundedAtFilter atTop (cumsum u) := by ++ obtain ⟨N, hu⟩ := eventually_atTop.mp hu ++ have e2 : cumsum (fun i ↦ u (i + N)) = fun n => cumsum u (n + N) - cumsum u N := by ++ ext n ; simp_rw [cumsum, add_comm _ N, Finset.sum_range_add] ; ring ++ rw [← summable_nat_add_iff N, summable_iff_bounded (fun n => hu _ <| Nat.le_add_left N n), e2] ++ simp_rw [sub_eq_add_neg, BoundedAtFilter.add_const, BoundedAtFilter.comp_add] ++ ++theorem bounded_of_shift {u : ℕ → ℝ} (h : BoundedAtFilter atTop (shift u)) : ++ BoundedAtFilter atTop u := by ++ simp only [BoundedAtFilter, isBigO_iff, eventually_atTop] at h ⊢ ++ obtain ⟨C, N, hC⟩ := h ++ refine ⟨C, N + 1, fun n hn => ?_⟩ ++ simp only [shift] at hC ++ have r1 : n - 1 ≥ N := Nat.le_sub_one_of_lt hn ++ have r2 : n - 1 + 1 = n := Nat.sub_add_cancel (by omega) ++ simpa [r2] using hC (n - 1) r1 ++ ++theorem dirichlet_test' {a b : ℕ → ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) ++ (hAb : BoundedAtFilter atTop (shift (cumsum a) * b)) (hbb : ∀ᶠ n in atTop, b (n + 1) ≤ b n) ++ (h : Summable (shift (cumsum a) * nnabla b)) : Summable (a * b) := by ++ have l1 : ∀ᶠ n in atTop, 0 ≤ (shift (cumsum a) * nnabla b) n := by ++ filter_upwards [hbb] with n hb ++ exact mul_nonneg (by simpa [shift] using cumsum_nonneg ha (n + 1)) (sub_nonneg.mpr hb) ++ rw [summable_iff_bounded (mul_nonneg ha hb)] ++ rw [summable_iff_bounded' l1] at h ++ apply bounded_of_shift ++ simpa only [summation_by_parts'', sub_eq_add_neg, neg_cumsum, ← mul_neg, neg_nabla] ++ using hAb.add h ++ ++theorem exists_antitone_of_eventually {u : ℕ → ℝ} (hu : ∀ᶠ n in atTop, u (n + 1) ≤ u n) : ++ ∃ v : ℕ → ℝ, range v ⊆ range u ∧ Antitone v ∧ v =ᶠ[atTop] u := by ++ obtain ⟨N, hN⟩ := eventually_atTop.mp hu ++ let v (n : ℕ) := u (if n < N then N else n) ++ refine ⟨v, ?_, ?_, ?_⟩ ++ · intro x hx ++ rcases hx with ⟨n, hn⟩ ++ exact ⟨if n < N then N else n, hn⟩ ++ · refine antitone_nat_of_succ_le (fun n => ?_) ++ by_cases h : n < N ++ · by_cases h' : n + 1 < N <;> simp [v, h, h'] ++ have : n + 1 = N := by linarith ++ simp [this] ++ · have : ¬(n + 1 < N) := by linarith ++ simp only [this, ↓reduceIte, h, ge_iff_le, v] ; apply hN ; linarith ++ · have : ∀ᶠ n in atTop, ¬(n < N) := by simpa using ⟨N, fun b hb => by linarith⟩ ++ filter_upwards [this] with n hn ; simp [v, hn] ++ ++theorem summable_inv_mul_log_sq : Summable (fun n : ℕ => (n * (Real.log n) ^ 2)⁻¹) := by ++ let u (n : ℕ) := (n * (Real.log n) ^ 2)⁻¹ ++ have l7 : ∀ᶠ n : ℕ in atTop, 1 ≤ Real.log n := ++ tendsto_atTop.mp (tendsto_log_atTop.comp tendsto_natCast_atTop_atTop) 1 ++ have l8 : ∀ᶠ n : ℕ in atTop, 1 ≤ n := eventually_ge_atTop 1 ++ have l9 : ∀ᶠ n in atTop, u (n + 1) ≤ u n := by ++ filter_upwards [l7, l8] with n l2 l8; dsimp [u]; gcongr <;> simp ++ obtain ⟨v, l1, l2, l3⟩ := exists_antitone_of_eventually l9 ++ rw [summable_congr_ae l3.symm] ++ have l4 (n : ℕ) : 0 ≤ v n := by obtain ⟨k, hk⟩ := l1 ⟨n, rfl⟩ ; rw [← hk] ; positivity ++ apply (summable_condensed_iff_of_nonneg l4 (fun _ _ _ a ↦ l2 a)).mp ++ suffices this : ∀ᶠ k : ℕ in atTop, 2 ^ k * v (2 ^ k) = ((k : ℝ) ^ 2)⁻¹ * ((Real.log 2) ^ 2)⁻¹ by ++ exact (summable_congr_ae this).mpr <| (Real.summable_nat_pow_inv.mpr one_lt_two).mul_right _ ++ have l5 : ∀ᶠ k in atTop, v (2 ^ k) = u (2 ^ k) := ++ l3.comp_tendsto <| tendsto_pow_atTop_atTop_of_one_lt Nat.le.refl ++ filter_upwards [l5, l8] with k l5 l8 ++ simp only [l5, mul_inv_rev, Nat.cast_pow, Nat.cast_ofNat, log_pow, u] ++ field_simp ++ ++theorem tendsto_mul_add_atTop {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ Tendsto (fun x => a * x + b) atTop atTop := ++ tendsto_atTop_add_const_right _ b (tendsto_id.const_mul_atTop ha) ++ ++theorem isLittleO_const_of_tendsto_atTop {α : Type*} [Preorder α] (a : ℝ) {f : α → ℝ} ++ (hf : Tendsto f atTop atTop) : (fun _ => a) =o[atTop] f := by ++ simp [tendsto_norm_atTop_atTop.comp hf] ++ ++theorem isLittleO_mul_add_sq (a b : ℝ) : (fun x => a * x + b) =o[atTop] (fun x => x ^ 2) := by ++ apply IsLittleO.add ++ · apply IsLittleO.const_mul_left ; simpa using isLittleO_pow_pow_atTop_of_lt (𝕜 := ℝ) one_lt_two ++ · apply isLittleO_const_of_tendsto_atTop _ <| tendsto_pow_atTop (by linarith) ++ ++theorem log_mul_add_isBigO_log {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ (fun x => Real.log (a * x + b)) =O[atTop] Real.log := by ++ apply IsBigO.of_bound (2 : ℕ) ++ have l2 : ∀ᶠ x : ℝ in atTop, 0 ≤ log x := tendsto_atTop.mp tendsto_log_atTop 0 ++ have l3 : ∀ᶠ x : ℝ in atTop, 0 ≤ log (a * x + b) := ++ tendsto_atTop.mp (tendsto_log_atTop.comp (tendsto_mul_add_atTop ha b)) 0 ++ have l5 : ∀ᶠ x : ℝ in atTop, 1 ≤ a * x + b := tendsto_atTop.mp (tendsto_mul_add_atTop ha b) 1 ++ have l1 : ∀ᶠ x : ℝ in atTop, a * x + b ≤ x ^ 2 := by ++ filter_upwards [(isLittleO_mul_add_sq a b).eventuallyLE, l5] with x r2 l5 ++ simpa [abs_eq_self.mpr (zero_le_one.trans l5)] using r2 ++ filter_upwards [l1, l2, l3, l5] with x l1 l2 l3 l5 ++ simpa [abs_eq_self.mpr l2, abs_eq_self.mpr l3, Real.log_pow] using ++ Real.log_le_log (by linarith) l1 ++ ++theorem isBigO_log_mul_add {a : ℝ} (ha : 0 < a) (b : ℝ) : ++ Real.log =O[atTop] (fun x => Real.log (a * x + b)) := by ++ convert (log_mul_add_isBigO_log (b := -b / a) (inv_pos.mpr ha)).comp_tendsto ++ (tendsto_mul_add_atTop (b := b) ha) using 1 ++ · ext x ++ simp only [Function.comp_apply] ++ congr ++ field_simp ++ simp ++ · rfl ++ ++theorem log_isbigo_log_div {d : ℝ} (hb : 0 < d) : ++ (fun n ↦ Real.log n) =O[atTop] (fun n ↦ Real.log (n / d)) := by ++ convert isBigO_log_mul_add (inv_pos.mpr hb) 0 using 1; simp only [add_zero]; field_simp ++ ++theorem Asymptotics.IsBigO.add_isLittleO_right {f g : ℝ → ℝ} (h : g =o[atTop] f) : ++ f =O[atTop] (f + g) := by ++ exact h.right_isBigO_add' ++ ++theorem Asymptotics.IsBigO.sq {α : Type*} [Preorder α] {f g : α → ℝ} (h : f =O[atTop] g) : ++ (fun n ↦ f n ^ 2) =O[atTop] (fun n => g n ^ 2) := ++ h.pow 2 ++ ++theorem log_sq_isbigo_mul {a b : ℝ} (hb : 0 < b) : ++ (fun x ↦ Real.log x ^ 2) =O[atTop] (fun x ↦ a + Real.log (x / b) ^ 2) := by ++ apply (ZetaFivePNT.Asymptotics.IsBigO.sq (log_isbigo_log_div hb)).trans ++ simp_rw [add_comm a] ++ refine ZetaFivePNT.Asymptotics.IsBigO.add_isLittleO_right <| ++ isLittleO_const_of_tendsto_atTop _ ?_ ++ exact (tendsto_pow_atTop two_ne_zero).comp <| ++ tendsto_log_atTop.comp <| tendsto_id.atTop_div_const hb ++ ++theorem log_add_div_isBigO_log (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ (fun x ↦ Real.log ((x + a) / b)) =O[atTop] fun x ↦ Real.log x := by ++ convert log_mul_add_isBigO_log (inv_pos.mpr hb) (a / b) using 3 ; ring ++ ++theorem log_add_one_sub_log_le {x : ℝ} (hx : 0 < x) : nabla Real.log x ≤ x⁻¹ := by ++ rw [nabla, ← Real.log_div (by linarith) hx.ne'] ++ calc ++ _ ≤ (x + 1) / x - 1 := Real.log_le_sub_one_of_pos (by positivity) ++ _ = x⁻¹ := by field_simp; ring ++ ++theorem nabla_log_main : nabla Real.log =O[atTop] fun x ↦ 1 / x := by ++ apply IsBigO.of_bound 1 ++ filter_upwards [eventually_gt_atTop 0] with x l1 ++ have l2 : log x ≤ log (x + 1) := log_le_log l1 (by linarith) ++ simpa [nabla, abs_eq_self.mpr l1.le, abs_eq_self.mpr (sub_nonneg.mpr l2)] using ++ log_add_one_sub_log_le l1 ++ ++theorem nabla_log {b : ℝ} (hb : 0 < b) : ++ nabla (fun x => Real.log (x / b)) =O[atTop] (fun x => 1 / x) := by ++ refine EventuallyEq.trans_isBigO ?_ nabla_log_main ++ filter_upwards [eventually_gt_atTop 0] with x l2 ++ rw [nabla, log_div (by linarith) (by linarith), log_div l2.ne.symm (by linarith), nabla] ; ring ++ ++theorem nnabla_mul_log_sq (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ nabla (fun x => x * (a + Real.log (x / b) ^ 2)) =O[atTop] (fun x => Real.log x ^ 2) := by ++ have l1 : nabla (fun n => n * (a + Real.log (n / b) ^ 2)) = fun n => ++ a + Real.log ((n + 1) / b) ^ 2 + ++ (n * (Real.log ((n + 1) / b) ^ 2 - Real.log (n / b) ^ 2)) := by ++ ext n ; simp [nabla] ; ring ++ have l2 := (isLittleO_const_of_tendsto_atTop a ++ ((tendsto_pow_atTop two_ne_zero).comp tendsto_log_atTop)).isBigO ++ have l3 := ZetaFivePNT.Asymptotics.IsBigO.sq (log_add_div_isBigO_log 1 hb) ++ have l4 : (fun x => Real.log ((x + 1) / b) + Real.log (x / b)) =O[atTop] Real.log := by ++ simpa using (log_add_div_isBigO_log _ hb).add (log_add_div_isBigO_log 0 hb) ++ have e2 : (fun x : ℝ => x * (Real.log x * (1 / x))) =ᶠ[atTop] Real.log := by ++ filter_upwards [eventually_ge_atTop 1] with x hx using by field_simp ++ have l5 : (fun n ↦ n * (Real.log n * (1 / n))) =O[atTop] (fun n ↦ (Real.log n) ^ 2) := ++ e2.trans_isBigO ++ (by simpa [Function.comp_def] using ++ (isLittleO_mul_add_sq 1 0).isBigO.comp_tendsto Real.tendsto_log_atTop) ++ simp_rw [l1, _root_.sq_sub_sq] ++ exact ((l2.add l3).add (isBigO_refl (·) atTop |>.mul (l4.mul (nabla_log hb)) |>.trans l5)) ++ ++theorem nnabla_bound_aux1 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ Tendsto (fun x => x * (a + Real.log (x / b) ^ 2)) atTop atTop := ++ tendsto_id.atTop_mul_atTop₀ <| tendsto_atTop_add_const_left _ _ <| ++ (tendsto_pow_atTop two_ne_zero).comp <| tendsto_log_atTop.comp <| tendsto_id.atTop_div_const hb ++ ++theorem nnabla_bound_aux2 (a : ℝ) {b : ℝ} (hb : 0 < b) : ++ ∀ᶠ x in atTop, 0 < x * (a + Real.log (x / b) ^ 2) := ++ (nnabla_bound_aux1 a hb).eventually (eventually_gt_atTop 0) ++ ++theorem Real.log_eventually_gt_atTop (a : ℝ) : ++ ∀ᶠ x in atTop, a < Real.log x := ++ Real.tendsto_log_atTop.eventually (eventually_gt_atTop a) ++ ++ ++@[local gcongr] ++theorem norm_lt_norm_of_nonneg (x y : ℝ) (hx : 0 ≤ x) (hxy : x ≤ y) : ++ ‖x‖ ≤ ‖y‖ := by ++ simp_rw [Real.norm_eq_abs] ++ apply abs_le_abs hxy ++ linarith ++ ++theorem nnabla_bound_aux {x : ℝ} (hx : 0 < x) : ++ nnabla (fun n ↦ 1 / (n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2))) =O[atTop] ++ (fun n ↦ 1 / (Real.log n ^ 2 * n ^ 2)) := by ++ let d n : ℝ := n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2) ++ change (fun x_1 ↦ nnabla (fun n ↦ 1 / d n) x_1) =O[atTop] _ ++ have l2 : ∀ᶠ n in atTop, 0 < d n := (nnabla_bound_aux2 ((2 * π) ^ 2) hx) ++ have l3 : ∀ᶠ n in atTop, 0 < d (n + 1) := ++ (tendsto_atTop_add_const_right atTop (1 : ℝ) tendsto_id).eventually l2 ++ have l1 : ∀ᶠ n : ℝ in atTop, ++ nnabla (fun n ↦ 1 / d n) n = (d (n + 1) - d n) * (d n)⁻¹ * (d (n + 1))⁻¹ := by ++ filter_upwards [l2, l3] with n l2 l3 ++ rw [nnabla, one_div, one_div, inv_sub_inv l2.ne.symm l3.ne.symm, div_eq_mul_inv, mul_inv, ++ mul_assoc] ++ have l4 : (fun n => (d n)⁻¹) =O[atTop] (fun n => (n * (Real.log n) ^ 2)⁻¹) := by ++ apply IsBigO.inv_rev ++ · refine (isBigO_refl _ _).mul <| (log_sq_isbigo_mul hx) ++ · filter_upwards [Real.log_eventually_gt_atTop 0, eventually_gt_atTop 0] with x hx hx' ++ rw [← not_imp_not] ++ intro _ ++ positivity ++ have l5 : (fun n => (d (n + 1))⁻¹) =O[atTop] (fun n => (n * (Real.log n) ^ 2)⁻¹) := by ++ refine IsBigO.trans ?_ l4 ++ rw [isBigO_iff]; use 1 ++ have e3 : ∀ᶠ n in atTop, d n ≤ d (n + 1) := by ++ filter_upwards [eventually_ge_atTop x] with n hn ++ have e2 : 1 ≤ n / x := (one_le_div hx).mpr hn ++ have : 0 ≤ n := hx.le.trans hn ++ simp only [d] ++ gcongr <;> simp [Real.log_nonneg, *] ++ filter_upwards [l2, l3, e3] with n e1 e2 e3 ++ simp_rw [one_mul] ++ gcongr ++ have l6 : (fun n => d (n + 1) - d n) =O[atTop] (fun n => (Real.log n) ^ 2) := by ++ change nabla (fun n : ℝ => n * ((2 * π) ^ 2 + Real.log (n / x) ^ 2)) ++ =O[atTop] (fun n => (Real.log n) ^ 2) ++ exact nnabla_mul_log_sq ((2 * π) ^ 2) hx ++ apply EventuallyEq.trans_isBigO l1 ++ apply ((l6.mul l4).mul l5).trans_eventuallyEq ++ filter_upwards [eventually_ge_atTop 2, Real.log_eventually_gt_atTop 0] with n hn hn' ++ field_simp ++ ++theorem nnabla_bound (C : ℝ) {x : ℝ} (hx : 0 < x) : ++ nnabla (fun n => C / (1 + (Real.log (n / x) / (2 * π)) ^ 2) / n) =O[atTop] ++ (fun n => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by ++ field_simp ++ simp only [div_eq_mul_inv, mul_inv, nnabla_mul, one_mul] ++ apply IsBigO.const_mul_left ++ simpa [div_eq_mul_inv, mul_pow, mul_comm] using nnabla_bound_aux hx ++ ++ ++theorem cheby.bigO (h : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ cumsum (‖f ·‖) =O[atTop] ((↑) : ℕ → ℝ) := by ++ have l1 : 0 ≤ cumsum (‖f ·‖) := cumsum_nonneg (fun _ => norm_nonneg _) ++ obtain ⟨C, hC⟩ := h ++ apply isBigO_of_le' (c := C) atTop ++ intro n ++ rw [Real.norm_eq_abs, abs_eq_self.mpr (l1 n)] ++ simpa using hC n ++ ++theorem limiting_fourier_lim1_aux ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hx : 0 < x) (C : ℝ) (hC : 0 ≤ C) : ++ Summable fun n ↦ ‖f n‖ / ↑n * (C / (1 + (1 / (2 * π) * Real.log (↑n / x)) ^ 2)) := by ++ let a (n : ℕ) := (C / (1 + (Real.log (↑n / x) / (2 * π)) ^ 2) / ↑n) ++ replace hcheby := cheby.bigO hcheby ++ have l1 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n : ℕ => (↑(n + 1) : ℝ)) := ++ hcheby.comp_tendsto <| tendsto_add_atTop_nat 1 ++ have l2 : shift (cumsum (‖f ·‖)) =O[atTop] (fun n => (n : ℝ)) := ++ l1.trans ++ (by simpa using (isBigO_refl _ _).add <| isBigO_iff.mpr ⟨1, by simpa using ⟨1, by tauto⟩⟩) ++ have l5 : BoundedAtFilter atTop (fun n : ℕ => C / (1 + (Real.log (↑n / x) / (2 * π)) ^ 2)) := by ++ simp only [BoundedAtFilter] ++ field_simp ++ apply isBigO_of_le' (c := C) ; intro n ++ have : 0 ≤ 2 ^ 2 * π ^ 2 + Real.log (n / x) ^ 2 := by positivity ++ simp only [norm_div, norm_mul, norm_eq_abs, abs_eq_self.mpr hC, norm_pow, ++ abs_eq_self.mpr pi_nonneg, abs_eq_self.mpr this, Pi.one_apply, one_mem, ++ CStarRing.norm_of_mem_unitary, mul_one, ge_iff_le, Nat.abs_ofNat] ++ apply div_le_of_le_mul₀ this hC ++ rw [mul_add, ← mul_assoc] ++ apply le_add_of_le_of_nonneg le_rfl ++ positivity ++ have l3 : a =O[atTop] (fun n => 1 / (n : ℝ)) := by ++ convert IsBigO.mul l5 (isBigO_refl (fun n : ℕ => 1 / (n : ℝ)) _) using 1 ++ · ext n ++ simp [a, div_eq_mul_inv] ++ · ext n ++ simp ++ have l4 : nnabla a =O[atTop] (fun n : ℕ => (n ^ 2 * (Real.log n) ^ 2)⁻¹) := by ++ convert (nnabla_bound C hx).natCast_atTop ; simp [nnabla, a] ++ simp_rw [div_mul_eq_mul_div, mul_div_assoc, one_mul] ++ apply dirichlet_test' ++ · intro n ; exact norm_nonneg _ ++ · intro n ; positivity ++ · apply (l2.mul l3).trans_eventuallyEq ++ apply eventually_of_mem (Ici_mem_atTop 1) ++ intro x (hx : 1 ≤ x) ++ have : x ≠ 0 := Nat.one_le_iff_ne_zero.mp hx ++ simp [this] ++ · have : ∀ᶠ n : ℕ in atTop, x ≤ n := by simpa using eventually_ge_atTop ⌈x⌉₊ ++ filter_upwards [this] with n hn ++ have e1 : 0 < (n : ℝ) := by linarith ++ have e2 : 1 ≤ n / x := (one_le_div hx).mpr hn ++ have e3 := Nat.le_succ n ++ gcongr ++ refine div_nonneg (Real.log_nonneg e2) (by norm_num [pi_nonneg]) ++ · apply summable_of_isBigO_nat summable_inv_mul_log_sq ++ apply (l2.mul l4).trans_eventuallyEq ++ apply eventually_of_mem (Ici_mem_atTop 2) ++ intro x (hx : 2 ≤ x) ++ have : (x : ℝ) ≠ 0 := by simp ; linarith ++ have : Real.log x ≠ 0 := by ++ have ll : 2 ≤ (x : ℝ) := by simp [hx] ++ simp ++ grind ++ field_simp ++ ++theorem limiting_fourier_lim1 ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (ψ : W21) (hx : 0 < x) : ++ Tendsto (fun σ' : ℝ ↦ ++ ∑' n, term f σ' n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x))) (𝓝[>] 1) ++ (𝓝 (∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (n / x)))) := by ++ obtain ⟨C, hC⟩ := decay_bounds_cor ψ ++ have : 0 ≤ C := by simpa using (norm_nonneg _).trans (hC 0) ++ refine tendsto_tsum_of_dominated_convergence ++ (limiting_fourier_lim1_aux hcheby hx C this) (fun n => ?_) ?_ ++ · apply Tendsto.mul_const ++ by_cases h : n = 0 <;> simp only [term, h, ↓reduceIte, CharP.cast_eq_zero, div_zero, ++ tendsto_const_nhds_iff] ++ refine tendsto_const_nhds.div ?_ (by simp [h]) ++ simpa using ((continuous_ofReal.tendsto 1).mono_left nhdsWithin_le_nhds).const_cpow ++ · rw [eventually_nhdsWithin_iff] ++ apply Eventually.of_forall ++ intro σ' (hσ' : 1 < σ') n ++ rw [norm_mul, ← nterm_eq_norm_term] ++ refine mul_le_mul ?_ (hC _) (norm_nonneg _) (div_nonneg (norm_nonneg _) (Nat.cast_nonneg _)) ++ by_cases h : n = 0 <;> simp only [nterm, h, ↓reduceIte, CharP.cast_eq_zero, div_zero, le_refl] ++ have : 1 ≤ (n : ℝ) := by exact_mod_cast (show 1 ≤ n by omega) ++ refine div_le_div₀ (norm_nonneg _) le_rfl (by simpa [Nat.pos_iff_ne_zero]) ?_ ++ simpa using Real.rpow_le_rpow_of_exponent_le this hσ'.le ++ ++theorem limiting_fourier_lim2_aux (x : ℝ) (C : ℝ) : ++ Integrable (fun t ↦ max |x| 1 * (C / (1 + (t / (2 * π)) ^ 2))) ++ (Measure.restrict volume (Ici (-Real.log x))) := by ++ simp_rw [div_eq_mul_inv C] ++ exact (((integrable_inv_one_add_sq.comp_div ++ (by simp [pi_ne_zero])).const_mul _).const_mul _).restrict ++ ++theorem limiting_fourier_lim2 (A : ℝ) (ψ : W21) (hx : 1 ≤ x) : ++ Tendsto (fun σ' ↦ A * ↑(x ^ (1 - σ')) * ++ ∫ u in Ici (-Real.log x), rexp (-u * (σ' - 1)) * 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) ++ (𝓝[>] 1) (𝓝 (A * ∫ u in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)))) := by ++ obtain ⟨C, hC⟩ := decay_bounds_cor ψ ++ apply Tendsto.mul ++ · suffices h : Tendsto (fun σ' : ℝ ↦ ofReal (x ^ (1 - σ'))) (𝓝[>] 1) (𝓝 1) by ++ simpa using h.const_mul ↑A ++ suffices h : Tendsto (fun σ' : ℝ ↦ x ^ (1 - σ')) (𝓝[>] 1) (𝓝 1) from ++ (continuous_ofReal.tendsto 1).comp h ++ have : Tendsto (fun σ' : ℝ ↦ σ') (𝓝 1) (𝓝 1) := fun _ a ↦ a ++ have : Tendsto (fun σ' : ℝ ↦ 1 - σ') (𝓝[>] 1) (𝓝 0) := ++ tendsto_nhdsWithin_of_tendsto_nhds (by simpa using this.const_sub 1) ++ simpa using tendsto_const_nhds.rpow this (Or.inl (zero_lt_one.trans_le hx).ne.symm) ++ · refine tendsto_integral_filter_of_dominated_convergence _ ?_ ?_ ++ (limiting_fourier_lim2_aux x C) ?_ ++ · apply Eventually.of_forall ; intro σ' ++ apply Continuous.aestronglyMeasurable ++ have := continuous_FourierIntegral ψ ++ continuity ++ · apply eventually_of_mem (U := Ioo 1 2) ++ · apply Ioo_mem_nhdsGT_of_mem ; simp ++ · intro σ' hσ ++ have h1 := hσ.1 ++ have h2 := hσ.2 ++ rw [ae_restrict_iff' measurableSet_Ici] ++ apply Eventually.of_forall ++ intro t (ht : - Real.log x ≤ t) ++ rw [norm_mul] ++ have hdom_nonneg : 0 ≤ max |x| 1 := by ++ exact (abs_nonneg x).trans (le_max_left _ _) ++ refine mul_le_mul ?_ (hC _) (norm_nonneg _) hdom_nonneg ++ simp only [neg_mul, ofReal_exp, ofReal_neg, ofReal_mul, ofReal_sub, ofReal_one, norm_exp, ++ neg_re, mul_re, ofReal_re, sub_re, one_re, ofReal_im, sub_im, one_im, sub_self, mul_zero, ++ sub_zero] ++ have : -Real.log x * (σ' - 1) ≤ t * (σ' - 1) := mul_le_mul_of_nonneg_right ht (by linarith) ++ have : -(t * (σ' - 1)) ≤ Real.log x * (σ' - 1) := by simpa using neg_le_neg this ++ have := Real.exp_monotone this ++ apply this.trans ++ have l1 : σ' - 1 ≤ 1 := by linarith ++ have : 0 ≤ Real.log x := Real.log_nonneg hx ++ have := mul_le_mul_of_nonneg_left l1 this ++ refine (Real.exp_monotone this).trans ?_ ++ have hxabs : |x| = x := abs_of_nonneg (zero_le_one.trans hx) ++ calc ++ Real.exp (Real.log x * 1) = |x| := by ++ simpa [mul_one, hxabs] using (Real.exp_log (zero_lt_one.trans_le hx)) ++ _ ≤ max |x| 1 := le_max_left _ _ ++ · apply Eventually.of_forall ++ intro x ++ suffices h : Tendsto (fun n ↦ ((rexp (-x * (n - 1))) : ℂ)) (𝓝[>] 1) (𝓝 1) by ++ simpa using h.mul_const _ ++ apply Tendsto.mono_left ?_ nhdsWithin_le_nhds ++ suffices h : Continuous (fun n ↦ ((rexp (-x * (n - 1))) : ℂ)) by simpa using h.tendsto 1 ++ continuity ++ ++theorem limiting_fourier_lim3 (hG : ContinuousOn G {s | 1 ≤ s.re}) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : ++ Tendsto (fun σ' : ℝ ↦ ∫ t : ℝ, G (σ' + t * I) * ψ t * x ^ (t * I)) (𝓝[>] 1) ++ (𝓝 (∫ t : ℝ, G (1 + t * I) * ψ t * x ^ (t * I))) := by ++ by_cases hh : tsupport ψ = ∅ ++ · simp [tsupport_eq_empty_iff.mp hh] ++ obtain ⟨a₀, ha₀⟩ := Set.nonempty_iff_ne_empty.mpr hh ++ let S : Set ℂ := reProdIm (Icc 1 2) (tsupport ψ) ++ have l1 : IsCompact S := by ++ refine Metric.isCompact_iff_isClosed_bounded.mpr ⟨?_, ?_⟩ ++ · exact isClosed_Icc.reProdIm (isClosed_tsupport ψ) ++ · exact (Metric.isBounded_Icc 1 2).reProdIm ψ.h2.isBounded ++ have l2 : S ⊆ {s : ℂ | 1 ≤ s.re} := fun z hz => (mem_reProdIm.mp hz).1.1 ++ have l3 : ContinuousOn (‖G ·‖) S := (hG.mono l2).norm ++ have l4 : S.Nonempty := ⟨1 + a₀ * I, by simp [S, mem_reProdIm, ha₀]⟩ ++ obtain ⟨z, -, hmax⟩ := l1.exists_isMaxOn l4 l3 ++ let MG := ‖G z‖ ++ let bound (a : ℝ) : ℝ := MG * ‖ψ a‖ ++ apply tendsto_integral_filter_of_dominated_convergence (bound := bound) ++ · apply eventually_of_mem (U := Icc 1 2) (Icc_mem_nhdsGT_of_mem (by simp)) ; intro u hu ++ apply Continuous.aestronglyMeasurable ++ apply Continuous.mul ++ · exact (hG.comp_continuous (by fun_prop) (by simp [hu.1])).mul ψ.h1.continuous ++ · apply Continuous.const_cpow (by fun_prop) ; simp ; linarith ++ · apply eventually_of_mem (U := Icc 1 2) (Icc_mem_nhdsGT_of_mem (by simp)) ++ intro u hu ++ apply Eventually.of_forall ; intro v ++ by_cases h : v ∈ tsupport ψ ++ · have r1 : u + v * I ∈ S := by simp [S, mem_reProdIm, hu.1, hu.2, h] ++ have r2 := isMaxOn_iff.mp hmax _ r1 ++ have r4 : (x : ℂ) ≠ 0 := by simp ; linarith ++ have r5 : arg x = 0 := by simp [arg_eq_zero_iff] ; linarith ++ have r3 : ‖(x : ℂ) ^ (v * I)‖ = 1 := by simp [norm_cpow_of_ne_zero r4, r5] ++ simp_rw [norm_mul, r3, mul_one] ++ exact mul_le_mul_of_nonneg_right r2 (norm_nonneg _) ++ · have : v ∉ Function.support ψ := fun a ↦ h (subset_tsupport ψ a) ++ simp at this ; simp [this, bound] ++ · suffices h : Continuous bound by exact h.integrable_of_hasCompactSupport ψ.h2.norm.mul_left ++ have := ψ.h1.continuous ; fun_prop ++ · apply Eventually.of_forall ; intro t ++ apply Tendsto.mul_const ++ apply Tendsto.mul_const ++ refine (hG (1 + t * I) (by simp)).tendsto.comp <| tendsto_nhdsWithin_iff.mpr ⟨?_, ?_⟩ ++ · exact ((continuous_ofReal.tendsto _).add tendsto_const_nhds).mono_left nhdsWithin_le_nhds ++ · exact eventually_nhdsWithin_of_forall (fun x (hx : 1 < x) => by simp [hx.le]) ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem limiting_fourier (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) (ψ : CS 2 ℂ) (hx : 1 ≤ x) : ++ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) = ++ ∫ (t : ℝ), (G (1 + t * I)) * (ψ t) * x ^ (t * I) := by ++ have l1 := limiting_fourier_lim1 hcheby ψ (by linarith) ++ have l2 := limiting_fourier_lim2 A ψ hx ++ have l3 := limiting_fourier_lim3 hG ψ hx ++ apply tendsto_nhds_unique_of_eventuallyEq (l1.sub l2) l3 ++ simpa [eventuallyEq_nhdsWithin_iff, W21.ofCS2] using ++ Eventually.of_forall (limiting_fourier_aux hG' hf ψ hx) ++ ++ ++ ++ ++theorem limiting_cor_aux {f : ℝ → ℂ} : ++ Tendsto (fun x : ℝ ↦ ∫ t, f t * x ^ (t * I)) atTop (𝓝 0) := by ++ have l1 : ∀ᶠ x : ℝ in atTop, ∀ t : ℝ, x ^ (t * I) = exp (log x * t * I) := by ++ filter_upwards [eventually_ne_atTop 0, eventually_ge_atTop 0] with x hx hx' t ++ rw [Complex.cpow_def_of_ne_zero (ofReal_ne_zero.mpr hx), ofReal_log hx'] ; ring_nf ++ have l2 : ∀ᶠ x : ℝ in atTop, ∫ t, f t * x ^ (t * I) = ∫ t, f t * exp (log x * t * I) := by ++ filter_upwards [l1] with x hx ++ refine integral_congr_ae (Eventually.of_forall (fun x => by simp [hx])) ++ simp_rw [tendsto_congr' l2] ++ convert_to Tendsto (fun x => 𝓕 f (-Real.log x / (2 * π))) atTop (𝓝 0) ++ · funext x ++ rw [Real.fourier_real_eq_integral_exp_smul] ++ apply integral_congr_ae ++ filter_upwards [] with t ++ have hphase : -2 * π * t * (-Real.log x / (2 * π)) = Real.log x * t := by ++ field_simp ++ rw [hphase, ofReal_mul, smul_eq_mul] ++ exact mul_comm _ _ ++ refine (Real.zero_at_infty_fourier f).comp <| Tendsto.mono_right ?_ _root_.atBot_le_cocompact ++ exact (tendsto_neg_atBot_iff.mpr tendsto_log_atTop).atBot_mul_const (inv_pos.mpr two_pi_pos) ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem limiting_cor (ψ : CS 2 ℂ) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by ++ apply limiting_cor_aux.congr' ++ filter_upwards [eventually_ge_atTop 1] with x hx using ++ limiting_fourier hcheby hG hG' hf ψ hx |>.symm ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem smooth_urysohn (a b c d : ℝ) (h1 : a < b) (h3 : c < d) : ∃ Ψ : ℝ → ℝ, ++ (ContDiff ℝ ∞ Ψ) ∧ (HasCompactSupport Ψ) ∧ ++ Set.indicator (Set.Icc b c) 1 ≤ Ψ ∧ Ψ ≤ Set.indicator (Set.Ioo a d) 1 := by ++ obtain ⟨ψ, l1, l2, l3, l4, -⟩ := smooth_urysohn_support_Ioo h1 h3 ++ refine ⟨ψ, l1, l2, l3, l4⟩ ++ ++ ++ ++ ++ ++noncomputable def compactTruncation : trunc := by ++ choose ψ h1 h2 h3 h4 using smooth_urysohn (-2) (-1) (1) (2) (by linarith) (by linarith) ++ exact ⟨⟨ψ, h1.of_le (by norm_cast), h2⟩, h3, h4⟩ ++ ++theorem one_div_sub_one (n : ℕ) : 1 / (↑(n - 1) : ℝ) ≤ 2 / n := by ++ cases n with ++ | zero => simp ++ | succ n => ++ cases n with ++ | zero => simp ++ | succ n => norm_cast ; rw [div_le_div_iff₀] <;> simp [mul_add] <;> linarith ++ ++ ++ ++noncomputable def pp (a x : ℝ) : ℝ := a ^ 2 * (x + 1) ^ 2 + (1 - a) * (1 + a) ++ ++ ++ ++noncomputable def pp' (a x : ℝ) : ℝ := a ^ 2 * (2 * (x + 1)) ++ ++theorem pp_pos {a : ℝ} (ha : a ∈ Ioo (-1) 1) (x : ℝ) : 0 < pp a x := by ++ simp only [pp] ++ have : 0 < 1 - a := by linarith [ha.2] ++ have : 0 < 1 + a := by linarith [ha.1] ++ positivity ++ ++theorem pp_deriv (a x : ℝ) : HasDerivAt (pp a) (pp' a x) x := by ++ unfold pp pp' ++ simpa using hasDerivAt_id x |>.add_const 1 |>.pow 2 |>.const_mul _ ++ ++theorem pp_deriv_eq (a : ℝ) : deriv (pp a) = pp' a := by ++ ext x ; exact pp_deriv a x |>.deriv ++ ++theorem pp'_deriv (a x : ℝ) : HasDerivAt (pp' a) (a ^ 2 * 2) x := by ++ change HasDerivAt (fun y : ℝ => a ^ 2 * (2 * (y + 1))) (a ^ 2 * 2) x ++ convert hasDerivAt_id x |>.add_const 1 |>.const_mul 2 |>.const_mul (a ^ 2) ++ using 1 <;> first | rfl | ring ++ ++theorem pp'_deriv_eq (a : ℝ) : deriv (pp' a) = fun _ => a ^ 2 * 2 := by ++ ext x ; exact pp'_deriv a x |>.deriv ++ ++ ++ ++noncomputable def hh (a t : ℝ) : ℝ := (t * (1 + (a * log t) ^ 2))⁻¹ ++ ++ ++ ++noncomputable def hh' (a t : ℝ) : ℝ := - pp a (log t) * hh a t ^ 2 ++ ++theorem hh_nonneg (a : ℝ) {t : ℝ} (ht : 0 ≤ t) : 0 ≤ hh a t := by dsimp only [hh] ; positivity ++ ++theorem hh_le (a t : ℝ) (ht : 0 ≤ t) : |hh a t| ≤ t⁻¹ := by ++ by_cases h0 : t = 0 ++ · simp [hh, h0] ++ replace ht : 0 < t := lt_of_le_of_ne ht (by tauto) ++ unfold hh ++ rw [abs_inv, inv_le_inv₀ (by positivity) ht, abs_mul, abs_eq_self.mpr ht.le] ++ convert_to t * 1 ≤ _ ++ · simp ++ apply mul_le_mul le_rfl ?_ zero_le_one ht.le ++ rw [abs_eq_self.mpr (by positivity)] ++ simp only [le_add_iff_nonneg_right] ++ positivity ++ ++theorem hh_deriv (a : ℝ) {t : ℝ} (ht : t ≠ 0) : HasDerivAt (hh a) (hh' a t) t := by ++ have e1 : t * (1 + (a * log t) ^ 2) ≠ 0 := mul_ne_zero ht (_root_.ne_of_lt (by positivity)).symm ++ have l5 : HasDerivAt (fun t : ℝ => log t) t⁻¹ t := Real.hasDerivAt_log ht ++ have l4 : HasDerivAt (fun t : ℝ => a * log t) (a * t⁻¹) t := l5.const_mul _ ++ have l3 : HasDerivAt (fun t : ℝ => (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := by ++ convert l4.pow 2 using 1 ; ring ++ have l2 : HasDerivAt (fun t : ℝ => 1 + (a * log t) ^ 2) (2 * a ^ 2 * t⁻¹ * log t) t := ++ l3.const_add _ ++ have l1 : HasDerivAt (fun t : ℝ => t * (1 + (a * log t) ^ 2)) ++ (1 + 2 * a ^ 2 * log t + a ^ 2 * log t ^ 2) t := by ++ convert (hasDerivAt_id' t).mul l2 using 1; field_simp; ring ++ apply (l1.inv e1).congr_deriv ++ dsimp only [hh', pp, hh] ++ simp only [div_eq_mul_inv, inv_pow] ++ ring ++ ++theorem hh_continuous (a : ℝ) : ContinuousOn (hh a) (Ioi 0) := ++ fun t (ht : 0 < t) => (hh_deriv a ht.ne.symm).continuousAt.continuousWithinAt ++ ++theorem hh'_nonpos {a x : ℝ} (ha : a ∈ Ioo (-1) 1) : hh' a x ≤ 0 := by ++ have := pp_pos ha (log x) ++ simp only [hh', neg_mul, Left.neg_nonpos_iff, ge_iff_le] ++ positivity ++ ++theorem hh_antitone {a : ℝ} (ha : a ∈ Ioo (-1) 1) : AntitoneOn (hh a) (Ioi 0) := by ++ have l1 x (hx : x ∈ interior (Ioi 0)) : ++ HasDerivWithinAt (hh a) (hh' a x) (interior (Ioi 0)) x := by ++ have : x ≠ 0 := by contrapose! hx ; simp [hx] ++ exact (hh_deriv a this).hasDerivWithinAt ++ apply antitoneOn_of_hasDerivWithinAt_nonpos (convex_Ioi _) (hh_continuous _) l1 ++ (fun x _ => hh'_nonpos ha) ++ ++ ++ ++noncomputable def gg (x i : ℝ) : ℝ := 1 / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ++ ++theorem gg_of_hh {x : ℝ} (hx : x ≠ 0) (i : ℝ) : gg x i = x⁻¹ * hh (1 / (2 * π)) (i / x) := by ++ simp only [gg, hh] ++ field_simp ++ ++theorem gg_l1 {x : ℝ} (hx : 0 < x) (n : ℕ) : |gg x n| ≤ 1 / n := by ++ simp only [gg_of_hh hx.ne.symm, one_div, mul_inv_rev, abs_mul] ++ apply mul_le_mul le_rfl (hh_le _ _ (by positivity)) (by positivity) (by positivity) |>.trans ++ (le_of_eq ?_) ++ simp [abs_inv, abs_eq_self.mpr hx.le] ; field_simp ++ ++theorem gg_le_one (i : ℕ) : gg x i ≤ 1 := by ++ by_cases hi : i = 0 <;> simp only [gg, hi, CharP.cast_eq_zero, div_zero, one_div, mul_inv_rev, ++ zero_div, Real.log_zero, mul_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, ++ add_zero, inv_one, mul_one, zero_le_one] ++ have l1 : 1 ≤ (i : ℝ) := by simp ; omega ++ have l2 : 1 ≤ 1 + (π⁻¹ * 2⁻¹ * Real.log (↑i / x)) ^ 2 := by ++ simp only [le_add_iff_nonneg_right] ; positivity ++ rw [← mul_inv] ; apply inv_le_one_of_one_le₀ ; simpa using mul_le_mul l1 l2 zero_le_one (by simp) ++ ++theorem one_div_two_pi_mem_Ioo : 1 / (2 * π) ∈ Ioo (-1) 1 := by ++ constructor ++ · trans 0 ++ · linarith ++ · positivity ++ · rw [div_lt_iff₀ (by positivity)] ++ convert_to 1 * 1 < 2 * π ++ · simp ++ · simp ++ apply mul_lt_mul one_lt_two ?_ zero_lt_one zero_le_two ++ trans 2 ++ · exact one_le_two ++ · exact two_le_pi ++ ++theorem cancel_aux {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ ∑ i ∈ Finset.range n, f i * g i ≤ g (n - 1) * (C * n) + (C * (↑(n - 1 - 1) + 1) * g 0 ++ - C * (↑(n - 1 - 1) + 1) * g (n - 1) - ++ ((n - 1 - 1) • (C * g 0) - ∑ x ∈ Finset.range (n - 1 - 1), C * g (x + 1))) := by ++ have l1 (n : ℕ) : ++ (g n - g (n + 1)) * ∑ i ∈ Finset.range (n + 1), f i ≤ (g n - g (n + 1)) * (C * (n + 1)) := by ++ apply mul_le_mul le_rfl (by simpa only [cumsum, Nat.cast_add, Nat.cast_one] using hf' (n + 1)) ++ (Finset.sum_nonneg (fun i _ => hf i)) ?_ ++ simp only [sub_nonneg] ; apply hg' ; simp ++ have l2 (x : ℕ) : C * (↑(x + 1) + 1) - C * (↑x + 1) = C := by simp ; ring ++ have l3 (n : ℕ) : 0 ≤ cumsum f n := Finset.sum_nonneg (fun i _ => hf i) ++ convert_to ∑ i ∈ Finset.range n, (g i) • (f i) ≤ _ ++ · simp [mul_comm] ++ rw [Finset.sum_range_by_parts, sub_eq_add_neg, ← Finset.sum_neg_distrib] ++ simp_rw [← neg_smul, neg_sub, smul_eq_mul] ++ apply _root_.add_le_add ++ · exact mul_le_mul le_rfl (hf' n) (l3 n) (hg _) ++ · apply Finset.sum_le_sum (fun n _ => l1 n) |>.trans ++ convert_to ∑ i ∈ Finset.range (n - 1), (C * (↑i + 1)) • (g i - g (i + 1)) ≤ _ ++ · congr ; ext i ; simp ; ring ++ rw [Finset.sum_range_by_parts] ++ simp_rw [Finset.sum_range_sub', l2, smul_sub, smul_eq_mul, Finset.sum_sub_distrib, ++ Finset.sum_const, Finset.card_range] ++ apply le_of_eq ; ring_nf ++ ++theorem sum_range_succ (a : ℕ → ℝ) (n : ℕ) : ++ ∑ i ∈ Finset.range n, a (i + 1) = (∑ i ∈ Finset.range (n + 1), a i) - a 0 := by ++ have := Finset.sum_range_sub a n ++ rw [Finset.sum_sub_distrib, sub_eq_iff_eq_add] at this ++ rw [Finset.sum_range_succ, this] ; ring ++ ++theorem cancel_aux' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ ∑ i ∈ Finset.range n, f i * g i ≤ ++ C * n * g (n - 1) ++ + C * cumsum g (n - 1 - 1 + 1) ++ - C * (↑(n - 1 - 1) + 1) * g (n - 1) ++ := by ++ have := cancel_aux hf hg hf' hg' n ++ simp only [nsmul_eq_mul, ← Finset.mul_sum, sum_range_succ] at this ++ convert this using 1 ; unfold cumsum ; ring ++ ++theorem cancel_main {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) (hn : 2 ≤ n) : ++ cumsum (f * g) n ≤ C * cumsum g n := by ++ change (∑ i ∈ Finset.range n, f i * g i) ≤ C * cumsum g n ++ refine (cancel_aux' hf hg hf' hg' n).trans_eq ?_ ++ have hindex : n - 1 - 1 + 1 = n - 1 := by omega ++ have hcast : (n : ℝ) = ↑(n - 1) + 1 := by ++ exact_mod_cast (show n = (n - 1) + 1 by omega) ++ have hcast' : (↑(n - 1 - 1) : ℝ) + 1 = ↑(n - 1) := by ++ exact_mod_cast hindex ++ have hsum : cumsum g n = cumsum g (n - 1) + g (n - 1) := by ++ conv_lhs => rw [show n = (n - 1) + 1 by omega] ++ exact cumsum_succ (n - 1) ++ rw [hindex, hcast', hcast, hsum] ++ ring ++ ++theorem cancel_main' {C : ℝ} {f g : ℕ → ℝ} (hf : 0 ≤ f) (hf0 : f 0 = 0) (hg : 0 ≤ g) ++ (hf' : ∀ n, cumsum f n ≤ C * n) (hg' : Antitone g) (n : ℕ) : ++ cumsum (f * g) n ≤ C * cumsum g n := by ++ cases n with ++ | zero => simp [cumsum] ++ | succ n => ++ cases n with ++ | zero => ++ have hC : 0 ≤ C := by simpa [cumsum, hf0] using hf' 1 ++ simpa [cumsum, hf0] using mul_nonneg hC (hg 0) ++ | succ n => exact cancel_main hf hg hf' hg' (n + 2) (by omega) ++ ++theorem sum_le_integral {x₀ : ℝ} {f : ℝ → ℝ} {n : ℕ} (hf : AntitoneOn f (Ioc x₀ (x₀ + n))) ++ (hfi : IntegrableOn f (Icc x₀ (x₀ + n))) : ++ (∑ i ∈ Finset.range n, f (x₀ + ↑(i + 1))) ≤ ∫ x in x₀..x₀ + n, f x := by ++ cases n with simp only [Nat.cast_add, Nat.cast_one, CharP.cast_eq_zero, add_zero, ++ lt_self_iff_false, not_false_eq_true, ++ Ioc_eq_empty, Finset.range_zero, Nat.cast_add, Nat.cast_one, Finset.sum_empty, ++ intervalIntegral.integral_same, le_refl] at hf ⊢ ++ | succ n => ++ have : Finset.range (n + 1) = {0} ∪ Finset.Ico 1 (n + 1) := by ++ ext i ; by_cases hi : i = 0 <;> simp [hi] ; omega ++ simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, ++ lt_add_iff_pos_left, add_pos_iff, zero_lt_one, or_true, and_true, not_false_eq_true, ++ Finset.sum_insert, CharP.cast_eq_zero, zero_add, ge_iff_le] ++ have l4 : IntervalIntegrable f volume x₀ (x₀ + 1) := by ++ apply IntegrableOn.intervalIntegrable ++ simp only [le_add_iff_nonneg_right, zero_le_one, uIcc_of_le] ++ apply hfi.mono_set ++ apply Icc_subset_Icc le_rfl ++ simp ++ have l5 x (hx : x ∈ Ioc x₀ (x₀ + 1)) : (fun x ↦ f (x₀ + 1)) x ≤ f x := by ++ rcases hx with ⟨hx1, hx2⟩ ++ refine hf ⟨hx1, by linarith⟩ ⟨by linarith, by linarith⟩ hx2 ++ have l6 : ∫ x in x₀..x₀ + 1, f (x₀ + 1) = f (x₀ + 1) := by simp ++ have l1 : f (x₀ + 1) ≤ ∫ x in x₀..x₀ + 1, f x := by ++ rw [← l6] ++ apply intervalIntegral.integral_mono_on_of_le_Ioo (by linarith) (by simp) l4 ++ intro x hx ++ exact l5 x ⟨hx.1, hx.2.le⟩ ++ have l2 : AntitoneOn (fun x ↦ f (x₀ + x)) (Icc 1 ↑(n + 1)) := by ++ intro u hu v hv huv ++ have hu1 := hu.1 ++ have hv2 := hv.2 ++ push_cast at hv2 ++ refine hf ⟨?_, ?_⟩ ⟨?_, ?_⟩ ?_ <;> linarith ++ have l3 := @AntitoneOn.sum_le_integral_Ico 1 (n + 1) (fun x => f (x₀ + x)) (by simp) ++ (by simpa using l2) ++ simp only [Nat.cast_add, Nat.cast_one, intervalIntegral.integral_comp_add_left] at l3 ++ convert _root_.add_le_add l1 l3 ++ have := @intervalIntegral.integral_comp_mul_add ℝ _ _ 1 (n + 1) 1 f one_ne_zero x₀ ++ rw [intervalIntegral.integral_add_adjacent_intervals] ++ · exact l4 ++ · apply IntegrableOn.intervalIntegrable ++ simp only [add_le_add_iff_left, le_add_iff_nonneg_left, Nat.cast_nonneg, uIcc_of_le] ++ apply hfi.mono_set ++ apply Icc_subset_Icc ++ · linarith ++ · simp ++ ++theorem hh_integrable_aux (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ (IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0)) ∧ ++ (∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π) := by ++ rw [integrableOn_Ici_iff_integrableOn_Ioi] ++ simp only [hh] ++ let g (x : ℝ) := (a * c / b) * Real.arctan (b * log (x / c)) ++ let g₀ (x : ℝ) := if x = 0 then ((a * c / b) * (- (π / 2))) else g x ++ let g' (x : ℝ) := a * (x / c * (1 + (b * Real.log (x / c)) ^ 2))⁻¹ ++ have l3 (x) (hx : 0 < x) : HasDerivAt Real.log x⁻¹ x := by apply Real.hasDerivAt_log (by linarith) ++ have l4 (x) : HasDerivAt (fun t => t / c) (1 / c) x := (hasDerivAt_id x).div_const c ++ have l2 (x) (hx : 0 < x) : HasDerivAt (fun t => log (t / c)) x⁻¹ x := by ++ have hcomp := (l3 (x / c) (by positivity)).comp x (l4 x) ++ convert hcomp using 1 ++ · rfl ++ · field_simp [hc.ne', hx.ne'] ++ have l5 (x) (hx : 0 < x) := (l2 x hx).const_mul b ++ have l1 (x) (hx : 0 < x) := (l5 x hx).arctan ++ have l6 (x) (hx : 0 < x) : HasDerivAt g (g' x) x := by ++ convert (l1 x hx).const_mul (a * c / b) using 1 ++ simp only [g'] ++ field_simp ++ have key (x) (hx : 0 < x) : HasDerivAt g₀ (g' x) x := by ++ apply (l6 x hx).congr_of_eventuallyEq ++ apply eventually_of_mem <| Ioi_mem_nhds hx ++ intro y (hy : 0 < y) ++ simp [g₀, hy.ne.symm] ++ have k1 : Tendsto g₀ atTop (𝓝 ((a * c / b) * (π / 2))) := by ++ have : g =ᶠ[atTop] g₀ := by ++ apply eventually_of_mem (Ioi_mem_atTop 0) ++ intro y (hy : 0 < y) ++ simp [g₀, hy.ne.symm] ++ apply Tendsto.congr' this ++ apply Tendsto.const_mul ++ apply (tendsto_arctan_atTop.mono_right nhdsWithin_le_nhds).comp ++ apply Tendsto.const_mul_atTop hb ++ apply tendsto_log_atTop.comp ++ apply Tendsto.atTop_div_const hc ++ apply tendsto_id ++ have k2 : Tendsto g₀ (𝓝[>] 0) (𝓝 (g₀ 0)) := by ++ have : g =ᶠ[𝓝[>] 0] g₀ := by ++ apply eventually_of_mem self_mem_nhdsWithin ++ intro x (hx : 0 < x) ; simp [g₀, hx.ne.symm] ++ simp only [g₀] ++ apply Tendsto.congr' this ++ apply Tendsto.const_mul ++ apply (tendsto_arctan_atBot.mono_right nhdsWithin_le_nhds).comp ++ apply Tendsto.const_mul_atBot hb ++ apply tendsto_log_nhdsGT_zero.comp ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨c * ε, by positivity, fun x hx1 hx2 => ⟨?_, ?_⟩⟩ ++ · simp only [mem_Ioi] at hx1 ⊢ ; positivity ++ · simp only [dist_zero_right, norm_eq_abs, norm_div, abs_eq_self.mpr hc.le] at hx2 ⊢ ++ rwa [div_lt_iff₀ hc, mul_comm] ++ have k3 : ContinuousWithinAt g₀ (Ici 0) 0 := by ++ rw [Metric.continuousWithinAt_iff] ++ rw [Metric.tendsto_nhdsWithin_nhds] at k2 ++ intro ε hε ++ obtain ⟨δ, hδ, hδx⟩ := k2 ε hε ++ refine ⟨δ, hδ, ?_⟩ ++ intro x hx hdist ++ change 0 ≤ x at hx ++ rcases lt_or_eq_of_le hx with hx | hx ++ · exact hδx hx hdist ++ · subst x ++ simpa only [dist_self] using hε ++ have k4 : ∀ x ∈ Ioi 0, 0 ≤ g' x := by ++ intro x (hx : 0 < x) ; simp only [mul_inv_rev, inv_div, g'] ; positivity ++ constructor ++ · convert_to IntegrableOn g' _ ++ exact integrableOn_Ioi_deriv_of_nonneg k3 key k4 k1 ++ · have := integral_Ioi_of_hasDerivAt_of_nonneg k3 key k4 k1 ++ simp only [mul_inv_rev, inv_div, mul_neg, ↓reduceIte, sub_neg_eq_add, g', g₀] at this ⊢ ++ convert this using 1 ; field_simp ; ring ++ ++theorem hh_integrable (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ IntegrableOn (fun t ↦ a * hh b (t / c)) (Ici 0) := ++ hh_integrable_aux ha hb hc |>.1 ++ ++theorem hh_integral (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : ++ ∫ (t : ℝ) in Ioi 0, a * hh b (t / c) = a * c / b * π := ++ hh_integrable_aux ha hb hc |>.2 ++ ++theorem hh_integral' : ∫ t in Ioi 0, hh (1 / (2 * π)) t = 2 * π ^ 2 := by ++ have := hh_integral (a := 1) (b := 1 / (2 * π)) (c := 1) ++ (by positivity) (by positivity) (by positivity) ++ convert this using 1 <;> simp ; ring ++ ++theorem bound_sum_log {C : ℝ} (hf0 : f 0 = 0) ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ ++ C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by ++ let ggg (i : ℕ) : ℝ := if i = 0 then 1 else gg x i ++ have l0 : x ≠ 0 := by linarith ++ have l1 i : 0 ≤ ggg i := by by_cases hi : i = 0 <;> simp only [gg, one_div, mul_inv_rev, hi, ++ ↓reduceIte, zero_le_one, ggg] ; positivity ++ have l2 : Antitone ggg := by ++ intro i j hij ; by_cases hi : i = 0 <;> by_cases hj : j = 0 <;> simp only [hj, ↓reduceIte, hi, ++ le_refl, ggg] ++ · exact gg_le_one _ ++ · omega ++ · simp only [gg_of_hh l0] ++ gcongr ++ apply hh_antitone one_div_two_pi_mem_Ioo ++ · simp only [mem_Ioi] ; positivity ++ · simp only [mem_Ioi] ; positivity ++ · gcongr ++ have l3 : 0 ≤ C := by simpa [cumsum, hf0] using hf 1 ++ have l4 : 0 ≤ ∫ (t : ℝ) in Ioi 0, hh (π⁻¹ * 2⁻¹) t := ++ setIntegral_nonneg measurableSet_Ioi (fun x hx => hh_nonneg _ (LT.lt.le hx)) ++ have l5 {n : ℕ} : AntitoneOn (fun t ↦ x⁻¹ * hh (1 / (2 * π)) (t / x)) (Ioc 0 n) := by ++ intro u hu v hv huv ++ have hu1 := hu.1 ++ have hv1 := hv.1 ++ simp only ++ apply mul_le_mul le_rfl ?_ (hh_nonneg _ (by positivity)) (by positivity) ++ apply hh_antitone one_div_two_pi_mem_Ioo (by simp only [mem_Ioi] ; positivity) ++ (by simp only [mem_Ioi] ; positivity) ++ apply (div_le_div_iff_of_pos_right (by positivity)).mpr huv ++ have l6 {n : ℕ} : IntegrableOn (fun t ↦ x⁻¹ * hh (π⁻¹ * 2⁻¹) (t / x)) (Icc 0 n) volume := by ++ apply IntegrableOn.mono_set ++ (hh_integrable (by positivity) (by positivity) (by positivity)) Icc_subset_Ici_self ++ apply Real.tsum_le_of_sum_range_le (fun n => by positivity) ; intro n ++ convert_to ∑ i ∈ Finset.range n, ‖f i‖ * ggg i ≤ _ ++ · congr ; ext i ++ by_cases hi : i = 0 ++ · simp [hi, hf0] ++ · simp only [gg, hi, ↓reduceIte, ggg] ++ field_simp ++ apply cancel_main' (fun _ => norm_nonneg _) (by simp [hf0]) l1 hf l2 n |>.trans ++ gcongr ; simp only [cumsum, gg_of_hh l0, one_div, mul_inv_rev, ggg] ++ by_cases hn : n = 0 ++ · simp only [hn, Finset.range_zero, Finset.sum_empty] ; positivity ++ replace hn : 0 < n := by omega ++ have : Finset.range n = {0} ∪ Finset.Ico 1 n := by ++ ext i ; simp ; by_cases hi : i = 0 <;> simp [hi, hn] ; omega ++ simp only [this, Finset.singleton_union, Finset.mem_Ico, nonpos_iff_eq_zero, one_ne_zero, ++ false_and, not_false_eq_true, Finset.sum_insert, ↓reduceIte, add_le_add_iff_left, ge_iff_le] ++ convert_to ∑ x_1 ∈ Finset.Ico 1 n, x⁻¹ * hh (π⁻¹ * 2⁻¹) (↑x_1 / x) ≤ _ ++ · apply Finset.sum_congr rfl (fun i hi => ?_) ++ simp at hi ++ have : i ≠ 0 := by omega ++ simp [this] ++ simp_rw [Finset.sum_Ico_eq_sum_range, add_comm 1] ++ have := @sum_le_integral 0 (fun t => x⁻¹ * hh (π⁻¹ * 2⁻¹) (t / x)) (n - 1) ++ (by simpa using l5) (by simpa using l6) ++ simp only [zero_add] at this ++ apply this.trans ++ rw [@intervalIntegral.integral_comp_div ℝ _ _ 0 ↑(n - 1) x (fun t => x⁻¹ * hh (π⁻¹ * 2⁻¹) (t)) l0] ++ simp only [zero_div, intervalIntegral.integral_const_mul, smul_eq_mul, ← mul_assoc, ++ mul_inv_cancel₀ l0, one_mul] ++ have : (0 : ℝ) ≤ ↑(n - 1) / x := by positivity ++ rw [intervalIntegral.intervalIntegral_eq_integral_uIoc] ++ simp only [this, ↓reduceIte, uIoc_of_le, smul_eq_mul, one_mul, ge_iff_le] ++ apply integral_mono_measure ++ · apply Measure.restrict_mono Ioc_subset_Ioi_self le_rfl ++ · apply eventually_of_mem (self_mem_ae_restrict measurableSet_Ioi) ++ intro x (hx : 0 < x) ++ apply hh_nonneg _ hx.le ++ · have h := (@hh_integrable 1 (1 / (2 * π)) 1 (by positivity) (by positivity) (by positivity)) ++ have h' := h.mono_set Ioi_subset_Ici_self ++ unfold IntegrableOn at h' ++ apply h'.congr ++ exact Eventually.of_forall (fun t => by simp) ++ ++theorem bound_sum_log0 {C : ℝ} ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ ++ C * (1 + ∫ t in Ioi 0, hh (1 / (2 * π)) t) := by ++ let f0 i := if i = 0 then 0 else f i ++ have l1 : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f0 k : ℂ)‖) n ≤ C * n) := by ++ intro n ; refine Finset.sum_le_sum (fun i _ => ?_) |>.trans (hf n) ++ by_cases hi : i = 0 <;> simp [hi, f0] ++ have l2 i : ‖f i‖ / i = ‖f0 i‖ / i := by by_cases hi : i = 0 <;> simp [hi, f0] ++ simp_rw [l2] ; apply bound_sum_log rfl l1 hx ++ ++theorem bound_sum_log' {C : ℝ} ++ (hf : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ {x : ℝ} (hx : 1 ≤ x) : ++ ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ ≤ C * (1 + 2 * π ^ 2) := by ++ simpa only [hh_integral'] using bound_sum_log0 hf hx ++ ++variable (f x) in ++theorem summable_fourier_aux (ψ : W21) (i : ℕ) : ++ ‖f i / i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (i / x))‖ ≤ ++ W21.norm ψ * (‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹) := by ++ convert mul_le_mul_of_nonneg_left (decay_bounds_key ψ (1 / (2 * π) * log (i / x))) ++ (norm_nonneg (f i / i)) using 1 ++ · simp ++ · change _ = _ * (W21.norm ψ * _) ++ simp only [W21.norm, mul_inv_rev, one_div, Complex.norm_div, RCLike.norm_natCast] ++ ring ++ ++theorem summable_fourier (x : ℝ) (hx : 0 < x) (ψ : W21) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by ++ have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by ++ simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) ++ have l6 := summable_fourier_aux x f ψ ++ exact Summable.of_nonneg_of_le (fun _ => norm_nonneg _) l6 ++ (by simpa using l5.const_smul (W21.norm ψ)) ++ ++theorem bound_I1 (x : ℝ) (hx : 0 < x) (ψ : W21) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ ++ W21.norm ψ • ∑' i, ‖f i‖ / i * (1 + (1 / (2 * π) * log (i / x)) ^ 2)⁻¹ := by ++ have l5 : Summable fun i ↦ ‖f i‖ / ↑i * ((1 + (1 / (2 * ↑π) * ↑(Real.log (↑i / x))) ^ 2)⁻¹) := by ++ simpa using limiting_fourier_lim1_aux hcheby hx 1 (zero_le_one' ℝ) ++ have l6 := summable_fourier_aux x f ψ ++ have l1 : Summable fun i ↦ ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑i / x))‖ := by ++ exact summable_fourier x hx ψ hcheby ++ apply (norm_tsum_le_tsum_norm l1).trans ++ change (∑' i, ‖f i / ↑i * 𝓕 (ψ : ℝ → ℂ) ++ (1 / (2 * π) * Real.log (↑i / x))‖) ≤ W21.norm ψ * _ ++ rw [← tsum_mul_left] ++ exact Summable.tsum_mono l1 (l5.mul_left (W21.norm ψ)) l6 ++ ++theorem bound_I1' {C : ℝ} (x : ℝ) (hx : 1 ≤ x) (ψ : W21) ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x))‖ ≤ ++ W21.norm ψ * C * (1 + 2 * π ^ 2) := by ++ apply bound_I1 x (by linarith) ψ ⟨_, hcheby⟩ |>.trans ++ rw [smul_eq_mul, mul_assoc] ++ apply mul_le_mul le_rfl (bound_sum_log' hcheby hx) ?_ W21.norm_nonneg ++ apply tsum_nonneg (fun i => by positivity) ++ ++theorem bound_I2 (x : ℝ) (ψ : W21) : ++ ‖∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ W21.norm ψ * (2 * π ^ 2) := by ++ have key a : ‖𝓕 (ψ : ℝ → ℂ) (a / (2 * π))‖ ≤ W21.norm ψ * (1 + (a / (2 * π)) ^ 2)⁻¹ := ++ decay_bounds_key ψ _ ++ have twopi : 0 ≤ 2 * π := by simp [pi_nonneg] ++ have l3 : Integrable (fun a ↦ (1 + (a / (2 * π)) ^ 2)⁻¹) := ++ integrable_inv_one_add_sq.comp_div (by norm_num [pi_ne_zero]) ++ have l2 : IntegrableOn (fun i ↦ W21.norm ψ * (1 + (i / (2 * π)) ^ 2)⁻¹) (Ici (-Real.log x)) := by ++ exact (l3.const_mul _).integrableOn ++ have l1 : IntegrableOn (fun i ↦ ‖𝓕 (ψ : ℝ → ℂ) (i / (2 * π))‖) (Ici (-Real.log x)) := by ++ refine ((l3.const_mul (W21.norm ψ)).mono' ?_ ?_).integrableOn ++ · apply Continuous.aestronglyMeasurable ; fun_prop ++ · simp only [norm_norm, key] ; simp ++ have l5 : 0 ≤ᵐ[volume] fun a ↦ (1 + (a / (2 * π)) ^ 2)⁻¹ := by ++ apply Eventually.of_forall ; intro x ; positivity ++ refine (norm_integral_le_integral_norm _).trans <| (setIntegral_mono l1 l2 key).trans ?_ ++ rw [integral_const_mul] ; gcongr ++ · apply W21.norm_nonneg ++ refine (setIntegral_le_integral l3 l5).trans ?_ ++ rw [Measure.integral_comp_div (fun x => (1 + x ^ 2)⁻¹) (2 * π)] ++ simp [abs_eq_self.mpr twopi] ; ring_nf ; rfl ++ ++theorem bound_main {C : ℝ} (A : ℂ) (x : ℝ) (hx : 1 ≤ x) (ψ : W21) ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ ‖∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))‖ ≤ ++ W21.norm ψ * (C * (1 + 2 * π ^ 2) + ‖A‖ * (2 * π ^ 2)) := by ++ have l1 := bound_I1' x hx ψ hcheby ++ have l2 := mul_le_mul (le_refl ‖A‖) (bound_I2 x ψ) (by positivity) (by positivity) ++ apply norm_sub_le _ _ |>.trans ; rw [norm_mul] ++ convert _root_.add_le_add l1 l2 using 1 ; ring ++ ++ ++theorem limiting_cor_W21 (ψ : W21) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := by ++ ++ let S1 x (ψ : ℝ → ℂ) := ∑' (n : ℕ), f n / ↑n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * Real.log (↑n / x)) ++ let S2 x (ψ : ℝ → ℂ) := ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π)) ++ let S x ψ := S1 x ψ - S2 x ψ ; change Tendsto (fun x ↦ S x ψ) atTop (𝓝 0) ++ ++ obtain g := compactTruncation ++ let Ψ R := g.scale R * ψ ++ have key R : Tendsto (fun x ↦ S x (Ψ R)) atTop (𝓝 0) := limiting_cor (Ψ R) hf hcheby hG hG' ++ ++ obtain ⟨C, hcheby⟩ := hcheby ++ have hC : 0 ≤ C := by ++ have : ‖f 0‖ ≤ C := by simpa [cumsum] using hcheby 1 ++ have : 0 ≤ ‖f 0‖ := by positivity ++ linarith ++ have key2 : Tendsto (fun R ↦ W21.norm (ψ - Ψ R)) atTop (𝓝 0) := W21_approximation ψ g ++ simp_rw [Metric.tendsto_nhds] at key key2 ⊢ ; intro ε hε ++ let M := C * (1 + 2 * π ^ 2) + ‖(A : ℂ)‖ * (2 * π ^ 2) ++ obtain ⟨R, hRψ⟩ := (key2 ((ε / 2) / (1 + M)) (by positivity)).exists ++ simp only [dist_zero_right, Real.norm_eq_abs, abs_eq_self.mpr W21.norm_nonneg] at hRψ key ++ ++ filter_upwards [eventually_ge_atTop 1, key R (ε / 2) (by positivity)] with x hx key ++ ++ have key3 : ‖S x (ψ - Ψ R)‖ < ε / 2 := by ++ have hbound := @bound_main f C A x hx (ψ - Ψ R) hcheby ++ change ‖S x (⇑ψ - ⇑(Ψ R))‖ ≤ W21.norm (⇑ψ - ⇑(Ψ R)) * M at hbound ++ apply hbound.trans_lt ++ calc ++ W21.norm (⇑ψ - ⇑(Ψ R)) * M ≤ W21.norm (⇑ψ - ⇑(Ψ R)) * (1 + M) := ++ mul_le_mul_of_nonneg_left (by linarith) W21.norm_nonneg ++ _ < ε / 2 := (lt_div_iff₀ (show 0 < 1 + M by positivity)).mp hRψ ++ ++ have S1_sub_1 x : 𝓕 (⇑ψ - ⇑(Ψ R)) x = 𝓕 (ψ : ℝ → ℂ) x - 𝓕 ⇑(Ψ R) x := ++ F_sub ψ.hf (Ψ R : W21).hf x ++ have S1_sub : S1 x (ψ - Ψ R) = S1 x ψ - S1 x (Ψ R) := by ++ simp only [one_div, mul_inv_rev, S1_sub_1, mul_sub, S1] ; apply Summable.tsum_sub ++ · have := summable_fourier x (by positivity) ψ ⟨_, hcheby⟩ ++ rw [summable_norm_iff] at this ++ simpa using this ++ · have hsum := summable_fourier x (by positivity) (Ψ R : W21) ⟨_, hcheby⟩ ++ rw [summable_norm_iff] at hsum ++ simpa only [W21.ofCS2, one_div, mul_inv_rev] using hsum ++ have S2_sub : S2 x (ψ - Ψ R) = S2 x ψ - S2 x (Ψ R) := by ++ simp only [S1_sub_1, S2] ; rw [integral_sub] ++ · ring ++ · exact ψ.integrable_fourier (by positivity) |>.restrict ++ · exact (Ψ R : W21).integrable_fourier (by positivity) |>.restrict ++ have S_sub : S x (ψ - Ψ R) = S x ψ - S x (Ψ R) := by simp [S, S1_sub, S2_sub] ; ring ++ simpa [S_sub, Ψ] using norm_add_le _ _ |>.trans_lt (_root_.add_lt_add key3 key) ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem limiting_cor_schwartz (ψ : 𝓢(ℝ, ℂ)) (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun x : ℝ ↦ ∑' n, f n / n * 𝓕 (ψ : ℝ → ℂ) (1 / (2 * π) * log (n / x)) - ++ A * ∫ u in Set.Ici (-log x), 𝓕 (ψ : ℝ → ℂ) (u / (2 * π))) atTop (𝓝 0) := ++ limiting_cor_W21 ψ hf hcheby hG hG' ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem fourier_surjection_on_schwartz (f : 𝓢(ℝ, ℂ)) : ∃ g : 𝓢(ℝ, ℂ), 𝓕 g = f := by ++ refine ⟨𝓕⁻ f, ?_⟩ ++ exact FourierTransform.fourier_fourierInv_eq f ++ ++ ++ ++ ++ ++ ++noncomputable def toSchwartz (f : ℝ → ℂ) (h1 : ContDiff ℝ ∞ f) ++ (h2 : HasCompactSupport f) : 𝓢(ℝ, ℂ) := ++ h2.toSchwartzMap h1 ++ ++@[simp] theorem toSchwartz_apply (f : ℝ → ℂ) {h1 h2 x} : SchwartzMap.mk f h1 h2 x = f x := rfl ++ ++theorem comp_exp_support0 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ ∀ᶠ x in 𝓝 0, Ψ x = 0 := ++ notMem_tsupport_iff_eventuallyEq.mp (fun h => lt_irrefl 0 <| mem_Ioi.mp (hplus h)) ++ ++theorem comp_exp_support1 {Ψ : ℝ → ℂ} (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ ∀ᶠ x in atBot, Ψ (exp x) = 0 := ++ Real.tendsto_exp_atBot <| comp_exp_support0 hplus ++ ++theorem comp_exp_support2 {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) : ++ ∀ᶠ (x : ℝ) in atTop, (Ψ ∘ rexp) x = 0 := by ++ simp only [hasCompactSupport_iff_eventuallyEq, coclosedCompact_eq_cocompact, ++ cocompact_eq_atBot_atTop] at hsupp ++ exact Real.tendsto_exp_atTop hsupp.2 ++ ++theorem comp_exp_support {Ψ : ℝ → ℂ} (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : HasCompactSupport (Ψ ∘ rexp) := by ++ simp only [hasCompactSupport_iff_eventuallyEq, coclosedCompact_eq_cocompact, ++ cocompact_eq_atBot_atTop] ++ exact ⟨comp_exp_support1 hplus, comp_exp_support2 hsupp⟩ ++ ++theorem wiener_ikehara_smooth_aux (l0 : Continuous Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) (x : ℝ) (hx : 0 < x) : ++ ∫ (u : ℝ) in Ioi (-Real.log x), ↑(rexp u) * Ψ (rexp u) = ∫ (y : ℝ) in Ioi (1 / x), Ψ y := by ++ have l1 : ContinuousOn rexp (Ici (-Real.log x)) := by fun_prop ++ have l2 : Tendsto rexp atTop atTop := Real.tendsto_exp_atTop ++ have l3 t (_ : t ∈ Ioi (-log x)) : HasDerivWithinAt rexp (rexp t) (Ioi t) t := ++ (Real.hasDerivAt_exp t).hasDerivWithinAt ++ have l4 : ContinuousOn Ψ (rexp '' Ioi (-Real.log x)) := by fun_prop ++ have l5 : IntegrableOn Ψ (rexp '' Ici (-Real.log x)) volume := ++ (l0.integrable_of_hasCompactSupport hsupp).integrableOn ++ have l6 : IntegrableOn (fun x ↦ rexp x • (Ψ ∘ rexp) x) (Ici (-Real.log x)) volume := by ++ refine (Continuous.integrable_of_hasCompactSupport (by fun_prop) ?_).integrableOn ++ change HasCompactSupport (rexp • (Ψ ∘ rexp)) ++ exact (comp_exp_support hsupp hplus).smul_left ++ have := MeasureTheory.integral_deriv_smul_comp_Ioi l1 l2 l3 l4 l5 l6 ++ simpa [Real.exp_neg, Real.exp_log hx] using this ++ ++theorem wiener_ikehara_smooth_sub (h1 : Integrable Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Ioi 0) : ++ Tendsto (fun x ↦ (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ obtain ⟨ε, hε, hh⟩ := Metric.eventually_nhds_iff.mp <| comp_exp_support0 hplus ++ apply tendsto_nhds_of_eventually_eq ; filter_upwards [eventually_gt_atTop ε⁻¹] with x hxε ++ have l1 : Integrable (indicator (Ioi x⁻¹) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi ++ have l2 : Integrable (indicator (Ioi 0) (fun x : ℝ => Ψ x)) := h1.indicator measurableSet_Ioi ++ simp_rw [← MeasureTheory.integral_indicator measurableSet_Ioi, ← mul_sub, ← integral_sub l1 l2] ++ simp only [mul_eq_zero, ofReal_eq_zero] ++ right ++ apply MeasureTheory.integral_eq_zero_of_ae ++ apply Eventually.of_forall ++ intro t ++ simp only [Pi.zero_apply] ++ have hε' : 0 < ε⁻¹ := by positivity ++ have hx : 0 < x := by linarith ++ have hx' : 0 < x⁻¹ := by positivity ++ have hεx : x⁻¹ < ε := (inv_lt_comm₀ hε hx).mp hxε ++ have l3 : Ioi 0 = Ioc 0 x⁻¹ ∪ Ioi x⁻¹ := by ++ ext t ; simp only [mem_Ioi, mem_union, mem_Ioc] ; constructor <;> intro h ++ · simp [h, le_or_gt] ++ · cases h with ++ | inl h => exact h.1 ++ | inr h => exact hx'.trans h ++ have l4 : Disjoint (Ioc 0 x⁻¹) (Ioi x⁻¹) := by simp ++ have l5 := Set.indicator_union_of_disjoint l4 Ψ ++ rw [l3, l5] ++ simp only ++ rw [add_comm, sub_add_cancel_left] ++ by_cases ht : t ∈ Ioc 0 x⁻¹ ++ · simp only [ht, indicator_of_mem, neg_eq_zero] ++ apply hh ; simp only [mem_Ioc, dist_zero_right, norm_eq_abs] at ht ⊢ ++ apply hεx.trans_le' ++ rw [abs_le] ; constructor <;> linarith ++ simp [ht] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem wiener_ikehara_smooth (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x - A * ∫ y in Set.Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ let h (x : ℝ) : ℂ := rexp (2 * π * x) * Ψ (exp (2 * π * x)) ++ have h1 : ContDiff ℝ ∞ h := by ++ have : ContDiff ℝ ∞ (fun x : ℝ => (rexp (2 * π * x))) := (contDiff_const.mul contDiff_id).exp ++ exact (contDiff_ofReal.comp this).mul (hsmooth.comp this) ++ have h2 : HasCompactSupport h := by ++ have hπ : 2 * π ≠ 0 := by simp [pi_ne_zero] ++ have hh : HasCompactSupport (fun x : ℝ => Ψ (rexp (2 * π * x))) := by ++ simpa only [Function.comp_def, smul_eq_mul] using ++ (comp_exp_support hsupp hplus).comp_smul hπ ++ change HasCompactSupport ++ ((fun x : ℝ => (rexp (2 * π * x) : ℂ)) * fun x : ℝ => Ψ (rexp (2 * π * x))) ++ exact hh.mul_left ++ obtain ⟨g, hg⟩ := fourier_surjection_on_schwartz (toSchwartz h h1 h2) ++ have l1 {y} (hy : 0 < y) : y * Ψ y = 𝓕 g (1 / (2 * π) * Real.log y) := by ++ rw [hg] ++ change (y : ℂ) * Ψ y = h (1 / (2 * π) * Real.log y) ++ have harg : 2 * π * (1 / (2 * π) * Real.log y) = Real.log y := by ++ rw [← mul_assoc, mul_one_div_cancel (mul_ne_zero (by norm_num) pi_ne_zero), one_mul] ++ dsimp only [h] ++ rw [harg, Real.exp_log hy] ++ have key := limiting_cor_schwartz g hf hcheby hG hG' ++ have l2 : ∀ᶠ x in atTop, ∑' (n : ℕ), f n / ↑n * 𝓕 g (1 / (2 * π) * Real.log (↑n / x)) = ++ ∑' (n : ℕ), f n * Ψ (↑n / x) / x := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ congr ; ext n ++ by_cases hn : n = 0 ++ · simp [hn, (comp_exp_support0 hplus).self_of_nhds] ++ rw [← l1 (by positivity)] ++ have : (n : ℂ) ≠ 0 := by simpa using hn ++ have : (x : ℂ) ≠ 0 := by simpa using hx.ne.symm ++ simp only [ofReal_div, ofReal_natCast] ++ field_simp ++ have l3 : ∀ᶠ x in atTop, ↑A * ∫ (u : ℝ) in Ici (-Real.log x), 𝓕 g (u / (2 * π)) = ++ ↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ congr 1 ++ rw [hg] ++ change (∫ u in Ici (-Real.log x), h (u / (2 * π))) = ∫ y in Ioi x⁻¹, Ψ y ++ dsimp only [h] ++ have hscale : (2 : ℝ) * π ≠ 0 := mul_ne_zero (by norm_num) pi_ne_zero ++ have harg (u : ℝ) : 2 * π * (u / (2 * π)) = u := mul_div_cancel₀ u hscale ++ simp_rw [harg] ++ rw [MeasureTheory.integral_Ici_eq_integral_Ioi] ++ simpa only [one_div] using wiener_ikehara_smooth_aux hsmooth.continuous hsupp hplus x hx ++ have l4 : Tendsto (fun x => (↑A * ∫ (y : ℝ) in Ioi x⁻¹, Ψ y) - ↑A * ∫ (y : ℝ) in Ioi 0, Ψ y) ++ atTop (𝓝 0) := by ++ exact wiener_ikehara_smooth_sub (hsmooth.continuous.integrable_of_hasCompactSupport hsupp) hplus ++ simpa [tsum_div_const] using (key.congr' <| EventuallyEq.sub l2 l3) |>.add l4 ++ ++ ++ ++theorem wiener_ikehara_smooth' (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x) atTop (nhds (A * ∫ y in Set.Ioi 0, Ψ y)) := ++ tendsto_sub_nhds_zero_iff.mp <| wiener_ikehara_smooth hf hcheby hG hG' hsmooth hsupp hplus ++ ++ ++local instance coeRealFunctionComplex {E : Type*} : Coe (E → ℝ) (E → ℂ) := ++ ⟨fun f n => f n⟩ ++ ++@[norm_cast] ++theorem set_integral_ofReal {f : ℝ → ℝ} {s : Set ℝ} : ∫ x in s, (f x : ℂ) = ∫ x in s, f x := ++ integral_ofReal ++ ++theorem wiener_ikehara_smooth_real {f : ℕ → ℝ} {Ψ : ℝ → ℝ} ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (hsmooth : ContDiff ℝ ∞ Ψ) (hsupp : HasCompactSupport Ψ) ++ (hplus : closure (Function.support Ψ) ⊆ Set.Ioi 0) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * Ψ (n / x)) / x) atTop (nhds (A * ∫ y in Set.Ioi 0, Ψ y)) := by ++ let Ψ' := ofReal ∘ Ψ ++ have l1 : ContDiff ℝ ∞ Ψ' := contDiff_ofReal.comp hsmooth ++ have l2 : HasCompactSupport Ψ' := hsupp.comp_left rfl ++ have l3 : closure (Function.support Ψ') ⊆ Ioi 0 := by rwa [Function.support_comp_eq] ; simp ++ have key := (continuous_re.tendsto _).comp ++ (@wiener_ikehara_smooth' A Ψ G f hf hcheby hG hG' l1 l2 l3) ++ simp at key ; norm_cast at key ++ ++theorem interval_approx_inf (ha : 0 < a) (hab : a < b) : ++ ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ ++ closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ ++ ψ ≤ indicator (Ico a b) 1 ∧ b - a - ε ≤ ∫ y in Ioi 0, ψ y := by ++ have l1 : Iio ((b - a) / 3) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds <| by ++ rw [← sub_pos] at hab ++ positivity ++ filter_upwards [self_mem_nhdsWithin, l1] with ε (hε : 0 < ε) (hε' : ε < (b - a) / 3) ++ have l2 : a < a + ε / 2 := by simp [hε] ++ have l3 : b - ε / 2 < b := by simp [hε] ++ obtain ⟨ψ, h1, h2, h3, h4, h5⟩ := smooth_urysohn_support_Ioo l2 l3 ++ refine ⟨ψ, h1, h2, ?_, ?_, ?_⟩ ++ · simp [h5, hab.ne, Icc_subset_Ioi_iff hab.le, ha] ++ · exact h4.trans <| indicator_le_indicator_of_subset Ioo_subset_Ico_self (by simp) ++ · have l4 : 0 ≤ b - a - ε := by linarith ++ have l5 : Icc (a + ε / 2) (b - ε / 2) ⊆ Ioi 0 := by ++ intro t ht ++ simp only [mem_Icc, mem_Ioi] at ht ⊢ ++ exact ha.trans <| l2.trans_le <| ht.1 ++ have l6 : Icc (a + ε / 2) (b - ε / 2) ∩ Ioi 0 = Icc (a + ε / 2) (b - ε / 2) := ++ inter_eq_left.mpr l5 ++ have l7 : ∫ y in Ioi 0, indicator (Icc (a + ε / 2) (b - ε / 2)) 1 y = b - a - ε := by ++ simp only [measurableSet_Icc, integral_indicator_one, measureReal_restrict_apply, l6, ++ volume_real_Icc] ++ convert max_eq_left l4 using 1 ; ring_nf ++ have l8 : IntegrableOn ψ (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ rw [← l7] ; apply setIntegral_mono ?_ l8 h3 ++ rw [IntegrableOn, integrable_indicator_iff measurableSet_Icc] ++ apply IntegrableOn.mono ?_ subset_rfl Measure.restrict_le_self ++ apply integrableOn_const <;> ++ simp ++ ++theorem interval_approx_sup (ha : 0 < a) (hab : a < b) : ++ ∀ᶠ ε in 𝓝[>] 0, ∃ ψ : ℝ → ℝ, ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ ++ closure (Function.support ψ) ⊆ Set.Ioi 0 ∧ ++ indicator (Ico a b) 1 ≤ ψ ∧ ∫ y in Ioi 0, ψ y ≤ b - a + ε := by ++ have l1 : Iio (a / 2) ∈ 𝓝[>] 0 := nhdsWithin_le_nhds <| Iio_mem_nhds (by linarith) ++ filter_upwards [self_mem_nhdsWithin, l1] with ε (hε : 0 < ε) (hε' : ε < a / 2) ++ have l2 : a - ε / 2 < a := by linarith ++ have l3 : b < b + ε / 2 := by linarith ++ obtain ⟨ψ, h1, h2, h3, h4, h5⟩ := smooth_urysohn_support_Ioo l2 l3 ++ refine ⟨ψ, h1, h2, ?_, ?_, ?_⟩ ++ · have l4 : a - ε / 2 < b + ε / 2 := by linarith ++ have l5 : ε / 2 < a := by linarith ++ simp [h5, l4.ne, Icc_subset_Ioi_iff l4.le, l5] ++ · apply le_trans ?_ h3 ++ apply indicator_le_indicator_of_subset Ico_subset_Icc_self (by simp) ++ · have l4 : 0 ≤ b - a + ε := by linarith ++ have l5 : Ioo (a - ε / 2) (b + ε / 2) ⊆ Ioi 0 := by intro t ht ; simp at ht ⊢ ; linarith ++ have l6 : Ioo (a - ε / 2) (b + ε / 2) ∩ Ioi 0 = Ioo (a - ε / 2) (b + ε / 2) := ++ inter_eq_left.mpr l5 ++ have l7 : ∫ y in Ioi 0, indicator (Ioo (a - ε / 2) (b + ε / 2)) 1 y = b - a + ε := by ++ simp only [measurableSet_Ioo, integral_indicator_one, measureReal_restrict_apply, l6, ++ volume_real_Ioo] ++ convert max_eq_left l4 using 1 ; ring_nf ++ have l8 : IntegrableOn ψ (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ rw [← l7] ++ refine setIntegral_mono l8 ?_ h4 ++ rw [IntegrableOn, integrable_indicator_iff measurableSet_Ioo] ++ apply IntegrableOn.mono ?_ subset_rfl Measure.restrict_le_self ++ apply integrableOn_const <;> ++ simp ++ ++theorem WI_summable {f : ℕ → ℝ} {g : ℝ → ℝ} (hg : HasCompactSupport g) (hx : 0 < x) : ++ Summable (fun n => f n * g (n / x)) := by ++ obtain ⟨M, hM⟩ := hg.bddAbove.mono subset_closure ++ apply summable_of_hasFiniteSupport ++ unfold Function.HasFiniteSupport ++ simp only [Function.support_mul] ; apply Finite.inter_of_right ; rw [finite_iff_bddAbove] ++ exact ⟨Nat.ceil (M * x), fun i hi => by simpa using Nat.ceil_mono ((div_le_iff₀ hx).mp (hM hi))⟩ ++ ++theorem WI_sum_le {f : ℕ → ℝ} {g₁ g₂ : ℝ → ℝ} (hf : 0 ≤ f) (hg : g₁ ≤ g₂) (hx : 0 < x) ++ (hg₁ : HasCompactSupport g₁) (hg₂ : HasCompactSupport g₂) : ++ (∑' n, f n * g₁ (n / x)) / x ≤ (∑' n, f n * g₂ (n / x)) / x := by ++ apply div_le_div_of_nonneg_right ?_ hx.le ++ exact Summable.tsum_le_tsum (fun n => mul_le_mul_of_nonneg_left (hg _) (hf _)) ++ (WI_summable hg₁ hx) (WI_summable hg₂ hx) ++ ++theorem WI_sum_Iab_le {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hb : 0 < b) (hxb : 2 / b < x) : ++ (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by ++ have hb' : 0 < 2 / b := by positivity ++ have hx : 0 < x := by linarith ++ have hxb' : 2 < x * b := (div_lt_iff₀ hb).mp hxb ++ have l1 (i : ℕ) (hi : i ∉ Finset.range ⌈b * x⌉₊) : f i * indicator (Ico a b) 1 (i / x) = 0 := by ++ simp_all [le_div_iff₀ hx] ++ have l2 (i : ℕ) (_ : i ∈ Finset.range ⌈b * x⌉₊) : ++ f i * indicator (Ico a b) 1 (i / x) ≤ |f i| := by ++ rw [abs_eq_self.mpr (hpos _)] ++ convert_to _ ≤ f i * 1 ++ · ring ++ apply mul_le_mul_of_nonneg_left ?_ (hpos _) ++ by_cases hi : (i / x) ∈ (Ico a b) <;> simp [hi] ++ rw [tsum_eq_sum l1, div_le_iff₀ hx, mul_assoc, mul_assoc] ++ apply Finset.sum_le_sum l2 |>.trans ++ have := hcheby ⌈b * x⌉₊ ; simp only [norm_real, norm_eq_abs] at this ; apply this.trans ++ have : 0 ≤ C := by have := hcheby 1 ; simp only [cumsum, Finset.range_one, norm_real, ++ Finset.sum_singleton, Nat.cast_one, mul_one] at this ; exact (abs_nonneg _).trans this ++ refine mul_le_mul_of_nonneg_left ?_ this ++ apply (Nat.ceil_lt_add_one (by positivity)).le.trans ++ linarith ++ ++theorem WI_sum_Iab_le' {f : ℕ → ℝ} (hpos : 0 ≤ f) {C : ℝ} ++ (hcheby : (∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hb : 0 < b) : ++ ∀ᶠ x : ℝ in atTop, (∑' n, f n * indicator (Ico a b) 1 (n / x)) / x ≤ C * 2 * b := by ++ filter_upwards [eventually_gt_atTop (2 / b)] with x hx using WI_sum_Iab_le hpos hcheby hb hx ++ ++theorem le_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[>] b, a ≤ c) : a ≤ b := by ++ exact ge_of_tendsto ++ (show Tendsto (fun c : ℝ => c) (𝓝[>] b) (𝓝 b) from nhdsWithin_le_nhds) h ++ ++theorem ge_of_eventually_nhdsWithin {a b : ℝ} (h : ∀ᶠ c in 𝓝[<] b, c ≤ a) : b ≤ a := by ++ exact le_of_tendsto ++ (show Tendsto (fun c : ℝ => c) (𝓝[<] b) (𝓝 b) from nhdsWithin_le_nhds) h ++ ++theorem WI_tendsto_aux (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++ Tendsto (fun c => c / A - (b - a)) (𝓝[>] (A * (b - a))) (𝓝[>] 0) := by ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨A * ε, by positivity, ?_⟩ ++ intro x hx1 hx2 ++ constructor ++ · simpa [lt_div_iff₀' hA] ++ · simp only [Real.dist_eq, dist_zero_right, Real.norm_eq_abs] at hx2 ⊢ ++ have : |x / A - (b - a)| = |x - A * (b - a)| / A := by ++ rw [← abs_eq_self.mpr hA.le, ← abs_div, abs_eq_self.mpr hA.le] ; congr ; field_simp ++ rwa [this, div_lt_iff₀' hA] ++ ++theorem WI_tendsto_aux' (a b : ℝ) {A : ℝ} (hA : 0 < A) : ++ Tendsto (fun c => (b - a) - c / A) (𝓝[<] (A * (b - a))) (𝓝[>] 0) := by ++ rw [Metric.tendsto_nhdsWithin_nhdsWithin] ++ intro ε hε ++ refine ⟨A * ε, by positivity, ?_⟩ ++ intro x hx1 hx2 ++ constructor ++ · simpa [div_lt_iff₀' hA] ++ · simp only [Real.dist_eq, dist_zero_right, norm_eq_abs] at hx2 ⊢ ++ have : |(b - a) - x / A| = |A * (b - a) - x| / A := by ++ rw [← abs_eq_self.mpr hA.le, ← abs_div, abs_eq_self.mpr hA.le] ; congr ; field_simp ++ rwa [this, div_lt_iff₀' hA, ← neg_sub, abs_neg] ++ ++theorem residue_nonneg {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm (fun n ↦ ↑(f n)) σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : EqOn G (fun s ↦ LSeries (fun n ↦ ↑(f n)) s - ↑A / (s - 1)) {s | 1 < s.re}) : ++ 0 ≤ A := by ++ let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x ++ have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by ++ filter_upwards [eventually_ge_atTop 0] with x hx ++ exact div_nonneg (tsum_nonneg (fun i => mul_nonneg (hpos _) (hg _))) hx ++ obtain ⟨ε, ψ, h1, h2, h3, h4, -⟩ := (interval_approx_sup zero_lt_one one_lt_two).exists ++ have key := @wiener_ikehara_smooth_real A G f ψ hf hcheby hG hG' h1 h2 h3 ++ have l2 : 0 ≤ ψ := by apply le_trans _ h4 ; apply indicator_nonneg ; simp ++ have l1 : ∀ᶠ x in atTop, 0 ≤ S ψ x := hSnonneg l2 ++ have l3 : 0 ≤ A * ∫ (y : ℝ) in Ioi 0, ψ y := ge_of_tendsto key l1 ++ have l4 : 0 < ∫ (y : ℝ) in Ioi 0, ψ y := by ++ have r1 : 0 ≤ᵐ[Measure.restrict volume (Ioi 0)] ψ := Eventually.of_forall l2 ++ have r2 : IntegrableOn (fun y ↦ ψ y) (Ioi 0) volume := ++ (h1.continuous.integrable_of_hasCompactSupport h2).integrableOn ++ have r3 : Ico 1 2 ⊆ Function.support ψ := by ++ intro x hx ; have := h4 x ; simp [hx] at this ⊢ ; linarith ++ have r4 : Ico 1 2 ⊆ Function.support ψ ∩ Ioi 0 := by ++ simp only [subset_inter_iff, r3, ++ true_and] ; apply Ico_subset_Icc_self.trans ; rw [Icc_subset_Ioi_iff] <;> linarith ++ have r5 : 1 ≤ volume ((Function.support fun y ↦ ψ y) ∩ Ioi 0) := by ++ convert volume.mono r4 ; norm_num ++ simpa [setIntegral_pos_iff_support_of_nonneg_ae r1 r2] using zero_lt_one.trans_le r5 ++ have := div_nonneg l3 l4.le ; field_simp at this ; exact this ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem WienerIkeharaInterval {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑' n, f n * (indicator (Ico a b) 1 (n / x))) / x) ++ atTop (nhds (A * (b - a))) := by ++ ++ by_cases hab : a = b ++ · simp [hab] ++ replace hb : a < b := lt_of_le_of_ne hb hab ; clear hab ++ ++ let S (g : ℝ → ℝ) (x : ℝ) := (∑' n, f n * g (n / x)) / x ++ have hSnonneg {g : ℝ → ℝ} (hg : 0 ≤ g) : ∀ᶠ x : ℝ in atTop, 0 ≤ S g x := by ++ filter_upwards [eventually_ge_atTop 0] with x hx ++ refine div_nonneg ?_ hx ++ refine tsum_nonneg (fun i => mul_nonneg (hpos _) (hg _)) ++ have hA : 0 ≤ A := residue_nonneg hpos hf hcheby hG hG' ++ ++ let Iab : ℝ → ℝ := indicator (Ico a b) 1 ++ change Tendsto (S Iab) atTop (𝓝 (A * (b - a))) ++ have hIab : HasCompactSupport Iab := by ++ simpa [Iab, HasCompactSupport, tsupport, hb.ne] using isCompact_Icc ++ have Iab_nonneg : ∀ᶠ x : ℝ in atTop, 0 ≤ S Iab x := hSnonneg (indicator_nonneg (by simp)) ++ have Iab2 : IsBoundedUnder (· ≤ ·) atTop (S Iab) := by ++ obtain ⟨C, hC⟩ := hcheby ; exact ⟨C * 2 * b, WI_sum_Iab_le' hpos hC (by linarith)⟩ ++ have Iab3 : IsBoundedUnder (· ≥ ·) atTop (S Iab) := ⟨0, Iab_nonneg⟩ ++ have Iab0 : IsCoboundedUnder (· ≥ ·) atTop (S Iab) := Iab2.isCoboundedUnder_ge ++ have Iab1 : IsCoboundedUnder (· ≤ ·) atTop (S Iab) := Iab3.isCoboundedUnder_le ++ ++ have sup_le : limsup (S Iab) atTop ≤ A * (b - a) := by ++ have l_sup : ∀ᶠ ε in 𝓝[>] 0, limsup (S Iab) atTop ≤ A * (b - a + ε) := by ++ filter_upwards [interval_approx_sup ha hb] with ε happrox ++ rcases happrox with ⟨ψ, h1, h2, h3, h4, h6⟩ ++ have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 ++ have l6 : S Iab ≤ᶠ[atTop] S ψ := by ++ filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h4 hx hIab h2 ++ have l5 : IsBoundedUnder (· ≤ ·) atTop (S ψ) := l1.isBoundedUnder_le ++ have l3 : limsup (S Iab) atTop ≤ limsup (S ψ) atTop := limsup_le_limsup l6 Iab1 l5 ++ apply l3.trans ; rw [l1.limsup_eq] ; gcongr ++ obtain rfl | h := eq_or_ne A 0 ++ · simpa using l_sup ++ apply le_of_eventually_nhdsWithin ++ have key : 0 < A := lt_of_le_of_ne hA h.symm ++ filter_upwards [WI_tendsto_aux a b key l_sup] with x hx ++ simpa [mul_div_cancel₀ _ h] using hx ++ ++ have le_inf : A * (b - a) ≤ liminf (S Iab) atTop := by ++ have l_inf : ∀ᶠ ε in 𝓝[>] 0, A * (b - a - ε) ≤ liminf (S Iab) atTop := by ++ filter_upwards [interval_approx_inf ha hb] with ε happrox ++ rcases happrox with ⟨ψ, h1, h2, h3, h5, h6⟩ ++ have l1 : Tendsto (S ψ) atTop _ := wiener_ikehara_smooth_real hf hcheby hG hG' h1 h2 h3 ++ have l2 : S ψ ≤ᶠ[atTop] S Iab := by ++ filter_upwards [eventually_gt_atTop 0] with x hx using WI_sum_le hpos h5 hx h2 hIab ++ have l4 : IsBoundedUnder (· ≥ ·) atTop (S ψ) := l1.isBoundedUnder_ge ++ have l3 : liminf (S ψ) atTop ≤ liminf (S Iab) atTop := liminf_le_liminf l2 l4 Iab0 ++ apply le_trans ?_ l3 ; rw [l1.liminf_eq] ; gcongr ++ obtain rfl | h := eq_or_ne A 0 ++ · simpa using l_inf ++ apply ge_of_eventually_nhdsWithin ++ have key : 0 < A := lt_of_le_of_ne hA h.symm ++ filter_upwards [WI_tendsto_aux' a b key l_inf] with x hx ++ simpa [mul_div_cancel₀ _ h] using hx ++ ++ have : liminf (S Iab) atTop ≤ limsup (S Iab) atTop := liminf_le_limsup Iab2 Iab3 ++ refine tendsto_of_liminf_eq_limsup ?_ ?_ Iab2 Iab3 <;> linarith ++ ++ ++ ++theorem le_floor_mul_iff (hb : 0 ≤ b) (hx : 0 < x) : n ≤ ⌊b * x⌋₊ ↔ n / x ≤ b := by ++ rw [div_le_iff₀ hx, Nat.le_floor_iff] ; positivity ++ ++theorem lt_ceil_mul_iff (hx : 0 < x) : n < ⌈b * x⌉₊ ↔ n / x < b := by ++ rw [div_lt_iff₀ hx, Nat.lt_ceil] ++ ++theorem ceil_mul_le_iff (hx : 0 < x) : ⌈a * x⌉₊ ≤ n ↔ a ≤ n / x := by ++ rw [le_div_iff₀ hx, Nat.ceil_le] ++ ++theorem mem_Icc_iff_div (hb : 0 ≤ b) (hx : 0 < x) : ++ n ∈ Finset.Icc ⌈a * x⌉₊ ⌊b * x⌋₊ ↔ n / x ∈ Icc a b := by ++ rw [Finset.mem_Icc, mem_Icc, ceil_mul_le_iff hx, le_floor_mul_iff hb hx] ++ ++theorem mem_Ico_iff_div (hx : 0 < x) : n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊ ↔ n / x ∈ Ico a b := by ++ rw [Finset.mem_Ico, mem_Ico, ceil_mul_le_iff hx, lt_ceil_mul_iff hx] ++ ++theorem tsum_indicator {f : ℕ → ℝ} (hx : 0 < x) : ++ ∑' n, f n * (indicator (Ico a b) 1 (n / x)) = ∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n := by ++ have l1 : ∀ n ∉ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n * indicator (Ico a b) 1 (↑n / x) = 0 := by ++ simp [mem_Ico_iff_div hx] ; tauto ++ rw [tsum_eq_sum l1] ; apply Finset.sum_congr rfl ; simp only ++ [mem_Ico_iff_div hx] ; intro n hn ; simp [hn] ++ ++theorem WienerIkeharaInterval_discrete {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun x : ℝ ↦ (∑ n ∈ Finset.Ico ⌈a * x⌉₊ ⌈b * x⌉₊, f n) / x) ++ atTop (nhds (A * (b - a))) := by ++ apply (WienerIkeharaInterval hpos hf hcheby hG hG' ha hb).congr' ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ rw [tsum_indicator hx] ++ ++theorem WienerIkeharaInterval_discrete' {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) ++ (ha : 0 < a) (hb : a ≤ b) : ++ Tendsto (fun N : ℕ ↦ (∑ n ∈ Finset.Ico ⌈a * N⌉₊ ⌈b * N⌉₊, f n) / N) ++ atTop (nhds (A * (b - a))) := ++ WienerIkeharaInterval_discrete hpos hf hcheby hG hG' ha hb |>.comp tendsto_natCast_atTop_atTop ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem tendsto_mul_ceil_div : ++ Tendsto (fun (p : ℝ × ℕ) => ⌈p.1 * p.2⌉₊ / (p.2 : ℝ)) (𝓝[>] 0 ×ˢ atTop) (𝓝 0) := by ++ rw [Metric.tendsto_nhds] ; intro δ hδ ++ have l1 : ∀ᶠ ε : ℝ in 𝓝[>] 0, ε ∈ Ioo 0 (δ / 2) := ++ inter_mem_nhdsWithin _ (Iio_mem_nhds (by positivity)) ++ have l2 : ∀ᶠ N : ℕ in atTop, 1 ≤ δ / 2 * N := by ++ apply Tendsto.eventually_ge_atTop ++ exact tendsto_natCast_atTop_atTop.const_mul_atTop (by positivity) ++ filter_upwards [l1.prod_mk l2] with p hp ++ rcases p with ⟨ε, N⟩ ++ rcases hp with ⟨⟨hε, h1⟩, h2⟩ ++ dsimp only at * ++ have l3 : 0 < (N : ℝ) := by ++ simp only [Nat.cast_pos, Nat.pos_iff_ne_zero] ; rintro rfl ; simp [zero_lt_one.not_ge] at h2 ++ have l5 : 0 ≤ ε * ↑N := by positivity ++ have l6 : ε * N ≤ δ / 2 * N := mul_le_mul h1.le le_rfl (by positivity) (by positivity) ++ simp only [dist_zero_right, norm_div, RCLike.norm_natCast, div_lt_iff₀ l3, gt_iff_lt] ++ convert (Nat.ceil_lt_add_one l5).trans_le (add_le_add l6 h2) using 1 ; ring ++ ++ ++ ++noncomputable def S (f : ℕ → 𝕜) (ε : ℝ) (N : ℕ) : 𝕜 := (∑ n ∈ Finset.Ico ⌈ε * N⌉₊ N, f n) / N ++ ++theorem S_sub_S {f : ℕ → 𝕜} {ε : ℝ} {N : ℕ} (hε : ε ≤ 1) : ++ S f 0 N - S f ε N = cumsum f ⌈ε * N⌉₊ / N := by ++ have r1 : Finset.range N = Finset.range ⌈ε * N⌉₊ ∪ Finset.Ico ⌈ε * N⌉₊ N := by ++ simp_rw [Finset.range_eq_Ico] ++ symm ++ apply Finset.Ico_union_Ico_eq_Ico (Nat.zero_le _) ++ simp only [Nat.ceil_le] ++ exact mul_le_of_le_one_left N.cast_nonneg hε ++ have r2 : Disjoint (Finset.range ⌈ε * N⌉₊) (Finset.Ico ⌈ε * N⌉₊ N) := by ++ rw [Finset.range_eq_Ico] ; apply Finset.Ico_disjoint_Ico_consecutive ++ simp [S, r1, Finset.sum_union r2, cumsum, add_div] ++ ++theorem tendsto_S_S_zero {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) : ++ TendstoUniformlyOnFilter (S f) (S f 0) (𝓝[>] 0) atTop := by ++ rw [Metric.tendstoUniformlyOnFilter_iff] ; intro δ hδ ++ obtain ⟨C, hC⟩ := hcheby ++ have l1 : ∀ᶠ (p : ℝ × ℕ) in 𝓝[>] 0 ×ˢ atTop, C * ⌈p.1 * p.2⌉₊ / p.2 < δ := by ++ have r1 := tendsto_mul_ceil_div.const_mul C ++ simp only [mul_div_assoc', mul_zero] at r1 ; exact r1 (Iio_mem_nhds hδ) ++ have : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) ++ filter_upwards [l1, Eventually.prod_inl this _] with p h1 h2 ++ rcases p with ⟨ε, N⟩ ++ have l2 : ‖cumsum f ⌈ε * ↑N⌉₊ / ↑N‖ ≤ C * ⌈ε * N⌉₊ / N := by ++ have r1 := hC ⌈ε * N⌉₊ ++ have r2 : 0 ≤ cumsum f ⌈ε * N⌉₊ := by apply cumsum_nonneg hpos ++ simp only [norm_real, norm_of_nonneg (hpos _), norm_div, ++ norm_of_nonneg r2, Real.norm_natCast] at r1 ⊢ ++ apply div_le_div_of_nonneg_right r1 (by positivity) ++ simpa [dist_eq_norm, ← S_sub_S h2.2] using l2.trans_lt h1 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem WienerIkeharaTheorem' {f : ℕ → ℝ} (hpos : 0 ≤ f) ++ (hf : ∀ (σ' : ℝ), 1 < σ' → Summable (nterm f σ')) ++ (hcheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(f k : ℂ)‖) n ≤ C * n)) ++ (hG : ContinuousOn G {s | 1 ≤ s.re}) ++ (hG' : Set.EqOn G (fun s ↦ LSeries f s - A / (s - 1)) {s | 1 < s.re}) : ++ Tendsto (fun N => cumsum f N / N) atTop (𝓝 A) := by ++ convert_to Tendsto (S f 0) atTop (𝓝 A) ; · ext N ; simp [S, cumsum] ++ apply (tendsto_S_S_zero hpos hcheby).tendsto_of_eventually_tendsto ++ · have L0 : Ioc 0 1 ∈ 𝓝[>] (0 : ℝ) := inter_mem_nhdsWithin _ (Iic_mem_nhds zero_lt_one) ++ apply eventually_of_mem L0 ++ · intro ε hε ++ convert WienerIkeharaInterval_discrete' hpos hf hcheby hG hG' hε.1 hε.2 using 1 ++ funext N ++ simp only [S, one_mul, Nat.ceil_natCast] ++ · have : Tendsto (fun ε : ℝ => ε) (𝓝[>] 0) (𝓝 0) := nhdsWithin_le_nhds ++ simpa using (this.const_sub 1).const_mul A ++ ++theorem vonMangoldt_cheby : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(Λ k : ℂ)‖) n ≤ C * n) := by ++ use Real.log 4 + 4 ++ intro N ++ by_cases! h : N = 0 ++ · simp [h, cumsum] ++ simp only [cumsum, norm_real, norm_eq_abs] ++ rw [Nat.range_eq_Icc_zero_sub_one _ h, (by simp : N - 1 = ⌊(N : ℝ) - 1⌋₊)] ++ simp_rw [abs_of_nonneg vonMangoldt_nonneg] ++ rw [← Chebyshev.psi_eq_sum_Icc] ++ grw [Chebyshev.psi_le_const_mul_self <| sub_nonneg_of_le <| Nat.one_le_cast_iff_ne_zero.mpr h] ++ gcongr ++ linarith ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++theorem WeakPNT : Tendsto (fun N ↦ cumsum Λ N / N) atTop (𝓝 1) := by ++ let F := vonMangoldt.LFunctionResidueClassAux (q := 1) 1 ++ have l1 (n : ℕ) : 0 ≤ Λ n := vonMangoldt_nonneg ++ have l2 s (hs : 1 < s.re) : F s = LSeries Λ s - 1 / (s - 1) := by ++ have := vonMangoldt.eqOn_LFunctionResidueClassAux (q := 1) isUnit_one hs ++ simp only [F, this, vonMangoldt.residueClass, Nat.totient_one, Nat.cast_one, ++ inv_one, one_div, sub_left_inj] ++ apply LSeries_congr ++ intro n _ ++ simp only [ofReal_inj, indicator_apply_eq_self, Set.mem_ofPred_eq] ++ exact fun hn ↦ absurd (Subsingleton.eq_one _) hn ++ have l3 : ContinuousOn F {s | 1 ≤ s.re} := vonMangoldt.continuousOn_LFunctionResidueClassAux 1 ++ have l4 : (∃ C : ℝ, ∀ n : ℕ, cumsum (fun k : ℕ ↦ ‖(Λ k : ℂ)‖) n ≤ C * n) := vonMangoldt_cheby ++ have l5 (σ' : ℝ) (hσ' : 1 < σ') : Summable (nterm Λ σ') := by ++ simpa only [← nterm_eq_norm_term] ++ using (@ArithmeticFunction.LSeriesSummable_vonMangoldt σ' hσ').norm ++ apply WienerIkeharaTheorem' l1 l5 l4 l3 l2 ++ ++end ZetaFivePNT +diff --git a/lakefile.toml b/lakefile.toml +index 2f3660d..71d9c89 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -1,17 +1,5 @@ + name = "PrimeNumberTheoremAnd" +-defaultTargets = ["PrimeNumberTheoremAnd"] +- +-[leanOptions] +-pp.unicode.fun = true +-pp.proofs.withType = false +-autoImplicit = false +-relaxedAutoImplicit = false +-linter.mathlibStandardSet = true +-linter.style.header = false +-linter.style.openClassical = false +-linter.style.longLine = false +-linter.style.emptyLine = false +-linter.flexible = true ++defaultTargets = ["PrimeNumberTheoremAnd.Wiener", "PrimeNumberTheoremAndZetaFive"] + + [[require]] + name = "LeanArchitect" +@@ -39,3 +27,24 @@ rev = "v4.34.0" + + [[lean_lib]] + name = "PrimeNumberTheoremAnd" ++leanOptions = { autoImplicit = false } ++ ++[[lean_lib]] ++name = "PrimeNumberTheoremAndZetaFive" ++roots = ["PrimeNumberTheoremAnd.ZetaFive"] ++globs = ["PrimeNumberTheoremAnd.ZetaFive.*"] ++ ++[[lean_lib]] ++name = "PrimeNumberTheoremAndCatalan" ++roots = ["PrimeNumberTheoremAnd.Catalan"] ++globs = ["PrimeNumberTheoremAnd.Catalan.*"] ++ ++[[lean_lib]] ++name = "PrimeNumberTheoremAndSiegelZeros" ++roots = ["PrimeNumberTheoremAnd.SiegelZeros.HadamardSupport"] ++globs = ["PrimeNumberTheoremAnd.SiegelZeros.*"] ++ ++[[lean_lib]] ++name = "PrimeNumberTheoremAndErdos970" ++roots = ["PrimeNumberTheoremAnd.Erdos970"] ++globs = ["PrimeNumberTheoremAnd.Erdos970.*"] +diff --git a/lean-toolchain b/lean-toolchain +index 664e12d..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.34.0 +\ No newline at end of file ++leanprover/lean4:v4.34.1 +diff --git a/PrimeNumberTheoremAnd/IEANTN/Mertens.lean b/PrimeNumberTheoremAnd/IEANTN/Mertens.lean +--- a/PrimeNumberTheoremAnd/IEANTN/Mertens.lean ++++ b/PrimeNumberTheoremAnd/IEANTN/Mertens.lean +@@ -14,7 +14,7 @@ + import Mathlib.Analysis.SpecialFunctions.Log.Summable + import Mathlib.Algebra.Group.Submonoid.BigOperators + import PrimeNumberTheoremAnd.EulerMaclaurin +-import Architect ++ + + + theorem Filter.EventuallyEq.iff_eventually {α : Type _} {β : Type _} {l : Filter α} {f g : α → β} : f =ᶠ[l] g ↔ ∀ᶠ (x : α) in l, f x = g x := by rfl +@@ -284,23 +284,23 @@ + + namespace Mertens + +-blueprint_comment /-- +-\section{Mertens' theorems} +- +-In this section we give explicit versions of Mertens' theorems: +-\begin{itemize} +-\item Mertens' first theorem (von Mangoldt form): $\sum_{n \leq x} \frac{\Lambda(n)}{n} = \log x + O(1)$. +-\item Mertens' first theorem (prime form): $\sum_{p \leq x} \frac{\log p}{p} = \log x + O(1)$. +-\item Mertens' second theorem (von Mangoldt form): $\sum_{n \leq x} \frac{\Lambda(n)}{n \log n} = \log \log x + \gamma + O(1/\log x)$. +-\item Mertens' second theorem (prime form): $\sum_{p \leq x} \frac{1}{p} = \log \log x + M + O(1/\log x)$, where $M$ is the Meissel-Mertens constant. +-\item Mertens' third theorem: $\prod_{p \leq x} (1 - \frac{1}{p}) = e^{-\gamma}/\log x + O(1/\log^2 x)$. +-\end{itemize} +-We aim to upstreaming these results to Mathlib. In particular, the arguments here should be self-contained and written for efficiency, coherency, and clarity. As such, extensive use of AI tools is \emph{strongly discouraged} in this section. +- +-The arguments here are drawn from Leo Goldmakher's ``A quick proof of Mertens' theorem'' from https://web.williams.edu/Mathematics/lg5/mertens.pdf +- +-The unfinished formalization of Mertens' theorems by Arend Mellendijk in https://github.com/FLDutchmann/Analytic/blob/main/Analytic/Mertens.lean may also be relevant here. +--/ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + + + open Real Finset Filter Asymptotics Topology +@@ -311,17 +311,17 @@ + rw [(by rfl : Ioc 0 x = Icc 1 x), ← add_sum_Ioc_eq_sum_Icc hx] + simpa + +-@[blueprint +- "Mertens-sum-log" +- (title := "Partial sum of logarithm identity") +- (statement := /-- For any $x \geq 1$, one has +-$$ \sum_{n \leq x} \log n = x \log x - (\{ x \}-1/2) \log x - x + 1 + \int_1^x (\{ t \}-1/2) \frac{dt}{t} $$ +-(NOTE: this identity is not actually needed in the proof of Mertens' theorems, but may be worth recording nevertheless.) +- -/) +- (proof := /-- Apply the Euler-Maclaurin formula. +- -/) +- (latexEnv := "lemma") +- (discussion := 1303)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_log_eq {x : ℝ} (hx : 1 ≤ x) : + ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n = + x * log x - (x - ⌊x⌋₊ - 1 / 2) * log x - x + 1 + ∫ t in 1..x, (t - ⌊t⌋₊ - 1 / 2) / t := by +@@ -339,16 +339,16 @@ + · simp only [deriv_log', Set.uIcc_of_le hx] + fun_prop (disch := grind) + +-@[blueprint +- "Mertens-sum-log-le" +- (title := "Partial sum of logarithm upper bound") +- (statement := /-- For any $x \geq 1$, one has +-$$ \sum_{n \leq x} \log n \leq x \log x.$$ +- -/) +- (proof := /-- Trivial since $\log n \leq \log x$. +- -/) +- (latexEnv := "lemma") +- (discussion := 1304)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_log_le {x : ℝ} (hx : 1 ≤ x) : + ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n ≤ x * log x := by + calc +@@ -374,25 +374,25 @@ + grw [← norm_eq_abs, intervalIntegral.norm_integral_le_of_norm_le_const this, + abs_of_nonneg (by linarith)] + +-@[blueprint +- "Mertens-sum-log-ge" +- (title := "Partial sum of logarithm lower bound") +- (statement := /-- For any $x \geq 1$, one has +-$$ \sum_{n \leq x} \log n \geq x \log x - 2 x.$$ +- -/) +- (proof := /-- We have +- \begin{align*} +- \sum_{n \leq x} \log n &= \sum_{2 \leq n \leq \lfloor x \rfloor} \log n \\ +- &\geq \sum_{2 \leq n \leq \lfloor x \rfloor} \int_{n-1}^n \log t \, dt \\ +- &= \int_1^{\lfloor x \rfloor} \log t \, dt \\ +- &\geq \int_1^x \log t\ dt - \log x \\ +- &= x \log x - x - \log x \\ +- &\geq x \log x - 2 x. +-\end{align*} +-Here we use the monotonicity of $\log n$ (and its vanishing at $n=1$) and the crude bound $\log x \leq x$. Note: the tools at Mathlib.Analysis.SumIntegralComparisons may be useful. +- -/) +- (latexEnv := "corollary") +- (discussion := 1305)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_log_ge {x : ℝ} (hx : 1 ≤ x) : + ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n ≥ x * log x - 2 * x := by + have one_le_floor : 1 ≤ ⌊x⌋₊ := by simpa +@@ -422,16 +422,16 @@ + tsub_le_iff_right, sub_add_cancel, le_add_iff_nonneg_right, zero_le_one] + _ ≥ _ := by linarith [log_le_self (by linarith : 0 ≤ x)] + +-@[blueprint +- "Mertens-sum-log-eq-log-factorial" +- (title := "Partial sum of logarithm as logarithm of factorial") +- (statement := /-- For any $x \geq 1$, one has +-$$ \sum_{n \leq x} \log n = \log(\lfloor x \rfloor!). $$ +- -/) +- (proof := /-- Follows from the definition of the factorial function. Is not needed for the Mertens theorems, but is a natural fact to have. +- -/) +- (latexEnv := "proposition") +- (discussion := 1315)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_log_eq_log_factorial (x : ℝ) : + ∑ n ∈ Ioc 0 ⌊ x ⌋₊, log n = log (Nat.floor x).factorial := by + rw [←prod_Ico_id_eq_factorial, ←log_prod, prod_natCast] +@@ -439,47 +439,47 @@ + intro x hx + simp at hx ⊢; grind + +-@[blueprint +- "Mertens-sum-log-eq-sum-mangoldt" +- (title := "Partial sum of logarithm as sum of $\\Lambda(d)/d$") +- (statement := /-- For any real $x$, one has +-$$ \sum_{n \leq x} \log n = \sum_{d \leq x} \Lambda(d) \lfloor \frac{x}{d} \rfloor.$$ +--/) +- (proof := /-- We have +-\begin{align*} +-\sum_{n \leq x} \log n +-&= \sum_{n \leq x} \sum_{d \mid n} \Lambda(d) +-= \sum_{d \leq x} \Lambda(d) \sum_{n \leq x, d \mid n} 1 +-= \sum_{d \leq x} \Lambda(d) \left\lfloor \frac{x}{d} \right\rfloor. +-\end{align*} +- -/) +- (latexEnv := "lemma") +- (discussion := 1306)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_log_eq_sum_mangoldt {x : ℝ} : + ∑ n ∈ Ioc 0 ⌊x⌋₊, log n = ∑ d ∈ Ioc 0 ⌊x⌋₊, Λ d * ⌊x / d⌋₊ := by + have : ∀ n : ℕ, log n = (Λ * zeta) n := by simp [vonMangoldt_mul_zeta] + simp_rw [this, sum_Ioc_mul_zeta_eq_sum, ← Nat.floor_div_natCast] + +-@[blueprint +- "Mertens-first-error-mangoldt" +- (title := "The remainder term in Mertens first theorem (von Mangoldt form)") +- (statement := /-- We define $E_{1,\Lambda}(x) := \sum_{d \leq x} \frac{\Lambda(d)}{d} - \log x$. +--/)] ++ ++ ++ ++ ++ + noncomputable abbrev E₁Λ (x : ℝ) : ℝ := ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d - log x + + theorem sum_mangoldt_div_eq (x : ℝ) : ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d = log x + E₁Λ x := by + grind + +-@[blueprint +- "Mertens-first-error-mangoldt-ge" +- (title := "Partial sum of $\\Lambda(d)/d$ lower bound") +- (statement := /-- For any $x \geq 1$, one has +-$$ E_{1,\Lambda}(x) \geq - 2.$$ +--/) +- (proof := /-- Insert Lemma \ref{Mertens-sum-log-eq-sum-mangoldt} into Lemma \ref{Mertens-sum-log-ge} and lower bound $x/d$ by $\lfloor x/d \rfloor$. +- -/) +- (latexEnv := "corollary") +- (discussion := 1307)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₁Λ.ge {x : ℝ} (hx : 1 ≤ x) : + E₁Λ x ≥ -2 := by + unfold E₁Λ +@@ -498,16 +498,16 @@ + + + +-@[blueprint +- "Mertens-first-error-mangoldt-le" +- (title := "Partial sum of $\\Lambda(d)/d$ upper bound") +- (statement := /-- For any $x \geq 1$, one has +-$$ E_{1,\Lambda}(x) \leq \log 4 + 4.$$ +--/) +- (proof := /-- Insert Lemma \ref{Mertens-sum-log-eq-sum-mangoldt} into Lemma \ref{Mertens-sum-log-le} and upper bound $x/d$ by $\lfloor x/d \rfloor + 1$, and use the Mathlib bound $\psi(x) \leq (\log 4 + 4) x$. +- -/) +- (latexEnv := "corollary") +- (discussion := 1308)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₁Λ.le {x : ℝ} (hx : 1 ≤ x) : + E₁Λ x ≤ log 4 + 4 := by + unfold E₁Λ +@@ -529,16 +529,16 @@ + · exact Chebyshev.psi_le_const_mul_self (by linarith) + _ = _ := by ring + +-@[blueprint +- "Mertens-first-theorem-mangoldt" +- (title := "Mertens' first theorem (von Mangoldt form)") +- (statement := /-- For any $x \geq 1$, one has +-$$ \sum_{n \leq x} \frac{\Lambda(n)}{n} = \log x + O(1). $$ +--/) +- (proof := /-- Immediate from previous two corollaries. +- -/) +- (latexEnv := "corollary") +- (discussion := 1309)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_mangoldt_div_eq_log {x : ℝ} (hx : 1 ≤ x) : + |∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d - log x| ≤ log 4 + 4 := by + grind [E₁Λ.le hx, E₁Λ.ge hx, log_nonneg] +@@ -548,9 +548,9 @@ + + + +-@[blueprint +- "Mertens-first-error-mangoldt" +- (discussion := 1309)] ++ ++ ++ + theorem E₁Λ.bounded : E₁Λ =O[atTop] (fun _ ↦ (1:ℝ)) := by + simp only [isBigO_iff, norm_eq_abs, norm_one, mul_one, + eventually_atTop] +@@ -560,34 +560,34 @@ + simp only [isLittleO_one_left_iff, norm_eq_abs] + exact tendsto_abs_atTop_atTop.comp tendsto_log_atTop + +-@[blueprint +- "Mertens-first-error-mangoldt" +- (discussion := 1309)] ++ ++ ++ + theorem sum_mangoldt_div_eq_log' : + (fun x ↦ ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / d) ~[atTop] (fun x ↦ log x) := by + apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log) + convert! E₁Λ.bounded using 1 + +-@[blueprint +- "Mertens-first-error-prime" +- (title := "The remainder term in Mertens first theorem (prime form)") +- (statement := /-- We define $E_{1,p}(x) := \sum_{p \leq x} \frac{\log p}{p} - \log x$. +--/)] ++ ++ ++ ++ ++ + noncomputable abbrev E₁p (x : ℝ) : ℝ := ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p - log x + + theorem sum_log_prime_div_eq (x : ℝ) : ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p = log x + E₁p x := by + grind + +-@[blueprint +- "Mertens-first-error-prime-le-mangoldt" +- (title := "Prime error for Mertens first theorem bounded by von Mangoldt error") +- (statement := /-- For any $x \geq 1$, one has +-$$ E_{1,p}(x) \leq E_{1,\Lambda}(x). $$ +--/) +- (proof := /-- Drop all terms in Lemma \ref{Mertens-sum-log-eq-sum-mangoldt} arising from prime powers. +- -/) +- (latexEnv := "corollary") +- (discussion := 1311)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₁p.le_E₁Λ (x : ℝ) : + E₁p x ≤ E₁Λ x := by + unfold E₁p E₁Λ; rw [sum_filter] +@@ -597,15 +597,15 @@ + have : 0 ≤ Λ p := vonMangoldt_nonneg + positivity + +-@[blueprint +- "Mertens-first-error-prime-le" +- (title := "Partial sum of $\\frac{\\log p}{p}$ upper bound") +- (statement := /-- For any $x \geq 1$, one has +-$$ E_{1,p}(x) \leq \log 4 + 4.$$ +--/) +- (proof := /-- Drop all terms in Lemma \ref{Mertens-sum-mangoldt-div-le} arising from prime powers. +- -/) +- (latexEnv := "corollary")] ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₁p.le {x : ℝ} (hx : 1 ≤ x) : + E₁p x ≤ log 4 + 4 := by + linarith [E₁Λ.le hx, E₁p.le_E₁Λ x] +@@ -619,14 +619,14 @@ + exact_mod_cast h.one_le + · rfl + +-@[blueprint +- "E1_summable" +- (title := "$E_1$ summable") +- (statement := /-- The series $E_1 := \sum_p \frac{\log p}{p(p-1)}$ converges. -/) +- (proof := /-- We have $\sum_{n=2}^\infty \frac{\log n}{n(n-1)}$ converges by comparison with $\sum_{n=2}^\infty \frac{2\log n}{n^2}$, which converges by the integral test. By a further application of comparison test we can conclude that $E_1$ converges as well. +- Alternatively bound $\log n$ by $2\sqrt n$ and use the existing Mathlib API for $\sum n^{-3/2}$.-/) +- (latexEnv := "proposition") +- (discussion := 1352)] ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₁.summable : Summable (fun p : ℕ ↦ if p.Prime then (log p) / (p*(p-1)) else 0) := by + refine (Real.summable_one_div_nat_rpow.mpr (by norm_num: 1 < (3 : ℝ) / 2)|>.const_div + 4).of_nonneg_of_le E₁.summand_nonneg fun n ↦ ?_ +@@ -733,13 +733,13 @@ + _ = _ := by + exact integral_log_div_sq + +-@[blueprint +- "E1_bound" +- (title := "Upper bound on $E_1$") +- (statement := /-- One has $E_1 \leq \frac{5 \log 2 + 3}{4}$-/) +- (proof := /-- We can bound $E_1 \leq \sum_{n=2}^\infty \frac{\log n}{n(n-1)} \leq \frac{\log 2}{2} + \frac{3}{2} \sum_{n=3}^\infty \frac{\log n}{n^2}$. Calculus shows that $\log x / x^2$ is decreasing for $x \geq 2 > e^{1/2}$, so we can bound $\sum_{n=3}^\infty \frac{\log n}{n^2} \leq \int_2^\infty \frac{\log t}{t^2}\ dt = \frac{\log 2+1}{2}$.-/) +- (latexEnv := "proposition") +- (discussion := 1316)] ++ ++ ++ ++ ++ ++ ++ + theorem E₁.le : E₁ ≤ (5 * log 2 + 3) / 4 := by + unfold E₁ + calc +@@ -769,20 +769,20 @@ + theorem E₁.nonneg : E₁ ≥ 0 := + tsum_nonneg E₁.summand_nonneg + +-@[blueprint +- "Mertens-first-error-prime-ge" +- (title := "Partial sum of $\\frac{\\log p}{p}$ lower bound") +- (statement := /-- For any $x \geq 1$, one has +-$$ E_{1,\Lambda}(x) \leq E_{1,p}(x) + E_1$$ +-and thus +-$$ E_{1,p}(x) \geq -2 - E_1$$ +-where +-$$ E_1 := \sum_{p} \frac{\log p}{p(p-1)}. $$ +--/) +- (proof := /-- Use the triangle inequality and the geometric series formula to estimate in Lemma \ref{Mertens-sum-mangoldt-div-le} arising from prime powers. +- -/) +- (latexEnv := "corollary") +- (discussion := 1312)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₁Λ.le_E₁p_add_E₁ {x : ℝ} (hx : 1 ≤ x) : + E₁Λ x ≤ E₁p x + E₁ := by + unfold E₁Λ E₁p +@@ -831,15 +831,15 @@ + linarith [E₁Λ.le_E₁p_add_E₁ hx, E₁Λ.ge hx] + + +-@[blueprint +- "Mertens-first-theorem-prime-bounded" +- (title := "Error term in Mertens' first theorem bounded (prime form)") +- (statement := /-- For any $x \geq 1$, one has +-$$ \sum_{p \leq x} \frac{\log p}{p} = \log x + O(1). $$ +--/) +- (proof := /-- Immediate from previous two corollaries. +- -/) +- (discussion := 1313)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_log_prime_div_eq_log {x : ℝ} (hx : 1 ≤ x) : + |∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p - log x| ≤ log 4 + 4 := by + rw [abs_le'] +@@ -851,31 +851,31 @@ + theorem E₁p.bounded : ∃ c > 0, ∀ x ≥ 1, |E₁p x| ≤ c := by + exact ⟨log 4 + 4, (by positivity), fun _ hx ↦ sum_log_prime_div_eq_log hx⟩ + +-@[blueprint +- "Mertens-first-theorem-prime-bounded"] ++ ++ + theorem sum_log_prime_div_eq_log' : E₁p =O[atTop] (fun _ ↦ (1:ℝ)) := by + simp only [isBigO_iff, norm_eq_abs, one_mem, CStarRing.norm_of_mem_unitary, mul_one, + eventually_atTop, E₁p] + exact ⟨ log 4 + 4, 1, fun _ ↦ sum_log_prime_div_eq_log ⟩ + +-@[blueprint +- "Mertens-first-theorem-prime-bounded"] ++ ++ + theorem sum_log_prime_div_eq_log'' : (fun x ↦ ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (log p) / p) ~[atTop] (fun x ↦ log x) := by + apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log) + convert! sum_log_prime_div_eq_log' using 1 + +-@[blueprint +- "Euler-Mascheroni-const-alt" +- (title := "Alternate Formula for Euler-Mascheroni constant") +- (statement := /-- We set $\gamma := \int_2^\infty \frac{E_{1,\Lambda}(t)}{t \log^2 t} \, dt + 1 - \log \log 2$. +--/)] ++ ++ ++ ++ ++ + noncomputable abbrev γ : ℝ := (∫ t in Set.Ioi 2, E₁Λ t / (t * log t^2)) + 1 - log (log 2) + +-@[blueprint +- "Mertens-second-error-mangoldt" +- (title := "The remainder term in Mertens second theorem (von Mangoldt form)") +- (statement := /-- We define $E_{2,\Lambda}(x) := \sum_{d \leq x} \frac{\Lambda(d)}{d \log d} - \log \log x - \gamma$. +--/)] ++ ++ ++ ++ ++ + noncomputable abbrev E₂Λ (x : ℝ) : ℝ := ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) - log (log x) - γ + + lemma sum_Ioc_one_eq_sum_Icc_zero {f : ℕ → ℝ} {x : ℕ} (hx : 1 ≤ x) (hf1 : f 1 = 0) (hf0 : f 0 = 0) : +@@ -883,17 +883,17 @@ + rw [sum_Ioc_one_eq_sum_Ioc_zero hx hf1, ← add_sum_Ioc_eq_sum_Icc (by linarith)] + simpa + +-@[blueprint +- "Mertens-integral-ident" +- (title := "Integral identity involving inverse log weight") +- (statement := /-- For any $x \geq 2$ and any $f : {\mathbb N} \mapsto {\mathbb R}$, one has +-$$ \sum_{2 \leq n \leq x} \frac{f(n)}{\log n} = \frac{1}{\log x} \sum_{2 \leq n \leq x} f(n) + \int_2^x \frac{1}{t \log^2 t} \sum_{2 \leq n \leq t} f(n) \, dt$$-/) +- (proof := /-- Establish the identity +- $$ \frac{1}{\log n} = \frac{1}{\log x} + \int_2^x \frac{1}{t \log^2 t} 1_{t \geq n}\ dt$$ +- for $2 \leq n \leq x$,multiply by $f(n)$, then sum. +- +- -/) +- (latexEnv := "sublemma")] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + private theorem sum_div_log_eq {x : ℝ} (hx : 2 ≤ x) (f : ℕ → ℝ) : + ∑ n ∈ Ioc 1 ⌊ x ⌋₊, f n / log n = + (∑ n ∈ Ioc 1 ⌊ x ⌋₊, f n) / log x + ∫ t in 2..x, (∑ n ∈ Ioc 1 ⌊ t ⌋₊, f n) / (t * log t^2) := by +@@ -1008,19 +1008,19 @@ + have : log t ≠ 0 := by simp; grind + fun_prop (disch := grind) + +-@[blueprint +- "Mertens-second-error-mangoldt-eq" +- (title := "Integral form for second error (von Mangoldt form)") +- (statement := /-- For any $x \geq 2$, one has +-$$ E_{2,\Lambda}(x) = \frac{E_{1,\Lambda}(x)}{\log x} - \int_x^\infty \frac{E_{1,\Lambda}(t)}{t \log^2 t}\ dt$$ +--/) +- (proof := /-- +-From Lemma \ref{Mertens-integral-ident} one has +-$$ \sum_{n \leq x} \frac{\Lambda(n)}{n \log n} = \frac{1}{\log x} \sum_{n \leq x} \frac{\Lambda(n)}{n} + \int_2^x \frac{1}{t \log^2 t} \sum_{n \leq t} \frac{\Lambda(n)}{n} \, dt.$$ +-Now substitute the definitions of $E_{1,\Lambda}$, $E_{2,\Lambda}$, $\gamma$ and simplify. +- -/) +- (latexEnv := "corollary") +- (discussion := 1317)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₂Λ.eq {x : ℝ} (hx : 2 ≤ x) : + E₂Λ x = E₁Λ x / log x - ∫ t in Set.Ioi x, E₁Λ t / (t * log t^2) := by + unfold E₂Λ +@@ -1058,17 +1058,17 @@ + convert! tendsto_log_atTop.inv_tendsto_atTop.const_mul (-c) using 1 + simp + +-@[blueprint +- "Mertens-second-error-mangoldt-bound" +- (title := "Bound for second Mertens error (von Mangoldt form)") +- (statement := /-- For any $x \geq 2$, one has +-$$ |E_{2,\Lambda}(x)| \leq \frac{\log 4 + 6}{\log x}.$$ +--/) +- (proof := /-- +- Insert Lemma \ref{Mertens-first-error-mangoldt-le} and Lemma \ref{Mertens-first-error-mangoldt-ge} into Lemma \ref{Mertens-second-error-mangoldt-eq} and use the triangle inequality to obtain the required upper and lower bounds. +- -/) +- (latexEnv := "corollary") +- (discussion := 1318)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₂Λ.abs_le {x : ℝ} (hx : 2 ≤ x) : + |E₂Λ x| ≤ (log 4 + 6) / log x := by + have : 0 < log x := by apply log_pos; linarith +@@ -1100,8 +1100,8 @@ + grind + + +-@[blueprint +- "Mertens-second-error-mangoldt-bound"] ++ ++ + theorem E₂Λ.bound : E₂Λ =O[atTop] (fun x ↦ 1 / log x) := by + simp only [one_div, isBigO_iff, norm_eq_abs, norm_inv, eventually_atTop] + use log 4 + 6, 2 +@@ -1110,22 +1110,22 @@ + have : 0 < log x := by apply log_pos; linarith + grind [abs_of_pos this] + +-@[blueprint +- "Mertens-second-error-mangoldt-bound"] ++ ++ + theorem E₂Λ.bound' : E₂Λ =o[atTop] (fun _ ↦ (1:ℝ)) := E₂Λ.bound.trans_isLittleO inv_log_eq_o_one + +-@[blueprint +- "log-zeta-eq-1" +- (title := "Dirichlet series for $\\log \\zeta(s)$") +- (statement := /-- If $s > 1$ then $\log\zeta(s) = - \log (s-1) + \Gamma'(1) + \gamma + (s-1) \int_1^\infty E_{2,\Lambda}(x) x^{-s}\ ds$. +--/) +- (proof := /-- First use the fundamental theorem of calculus and decay of $\log \zeta(s)$ to write +- $$ \log \zeta(s) = \int_s^\infty -\frac{\zeta'(u)}{\zeta(u)}\ du.$$ +- Then substitute in the known identity +- $-\frac{\zeta'(u)}{\zeta(u)} = \sum_n \frac{\Lambda(n)}{n^u}$ and integrate term by term. +- -/) +- (latexEnv := "sublemma") +- (discussion := 1582)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem log_zeta_eq_sum (s : ℝ) (hs : 1 < s) : + log (riemannZeta (s:ℂ)).re = ∑' n, Λ n / (n^s * log n) := by + have hsc : (1 : ℝ) < ((s : ℂ)).re := by simpa using hs +@@ -1449,41 +1449,41 @@ + end LogZetaInteg + end + +-@[blueprint +- "log-zeta-eq-2" +- (title := "Integration by parts identity for $\\log \\zeta(s)$") +- (statement := /-- If $s > 1$ then $\log\zeta(s) = (s-1) \int_1^\infty (\log \log x + \gamma + E_{2,\Lambda}(x)) x^{-s})\ dx$. +--/) +- (proof := /-- Apply the preceding identity then integrate by parts. +- -/) +- (latexEnv := "sublemma") +- (discussion := 1583)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + private theorem log_zeta_eq_integ (s : ℝ) (hs : 1 < s) : + log (riemannZeta (s:ℂ)).re = (s - 1) * ∫ x in .Ioi 1, (log (log x) + γ + E₂Λ x) * x^(-s) := + LogZetaInteg.log_zeta_eq_integ_aux s hs + +-@[blueprint +- "log-zeta-eq-3" +- (title := "First integral identity") +- (statement := /-- If $s > 1$ then $(s-1) \int_1^\infty \log \log x \cdot x^{-s}\ dx = -\log (s-1) + \Gamma'(1)$. +--/) +- (proof := /-- Writing $t = \log x$, the LHS is $(s-1) \int_0^\infty \log t e^{-(s-1) t}\ dt$. Now differentiate $\Gamma(z) = (s-1)^z \int_0^\infty t^{z-1} e^{-(s-1)t}\ dt$ in $z$ at $z=1$. +- -/) +- (latexEnv := "sublemma") +- (discussion := 1584)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + private theorem mul_integ_log_log_eq (s : ℝ) (hs : 1 < s) : + (s - 1) * ∫ x in .Ioi 1, log (log x) * x^(-s) = - log (s - 1) + deriv Gamma 1 := + mul_integ_log_log_eq_aux s hs + +-@[blueprint +- "log-zeta-eq-4" +- (title := "Second integral identity") +- (statement := /-- If $s > 1$ then $(s-1) \int_1^\infty \gamma \cdot x^{-s}\ dx = \gamma$. +--/) +- (proof := /-- Apply the fundamental theorem of calculus. +- -/) +- (latexEnv := "sublemma") +- (discussion := 1585)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + private theorem mul_integ_gamma_eq (s) (hs : 1 < s) : (s - 1) * ∫ x in .Ioi 1, γ * x^(-s) = γ := by + rw [MeasureTheory.integral_const_mul γ (· ^ (-s)), @integral_Ioi_rpow_of_lt (-s), one_rpow] <;> + grind +@@ -1600,14 +1600,14 @@ + div_le_div_of_nonneg_left hc hlog2 (Real.log_le_log (by norm_num) (le_of_lt hx)) + exact (E₂Λ.abs_le (le_of_lt hx)).trans hb2 + +-@[blueprint +- "log-zeta-eq" +- (title := "An identity for $\\log \\zeta(s)$") +- (statement := /-- If $s > 1$ then $\log\zeta(s) = - \log (s-1) + \Gamma'(1) + \gamma + (s-1) \int_1^\infty E_{2,\Lambda}(x) x^{-s}\ ds$. +--/) +- (proof := /-- Combine the previous four sublemmas.-/) +- (latexEnv := "theorem") +- (discussion := 1319)] ++ ++ ++ ++ ++ ++ ++ ++ + private theorem log_zeta_eq (s : ℝ) (hs : 1 < s) : + log (riemannZeta (s:ℂ)).re = - log (s - 1) + deriv Gamma 1 + γ + (s - 1) * ∫ x in Set.Ioi 1, E₂Λ x * x^(-s) := by + -- Start from the integration-by-parts identity (#1583). +@@ -1652,15 +1652,15 @@ + (Complex.continuous_re.tendsto (1 : ℂ)).comp hcomplex + simpa [Complex.ofReal_sub, Complex.ofReal_mul] using hreal + +-@[blueprint +- "log-zeta-limit" +- (title := "limiting behavior of log zeta") +- (statement := /-- One has $\log \zeta(s) = - \log(s-1) + o(1)$ as $s \to 1^+$. +--/) +- (proof := /-- Start with the asymptotic $\zeta(s) = \frac{1}{s-1} + O(1)$ and take logarithms. +- -/) +- (latexEnv := "sublemma") +- (discussion := 1586)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + private theorem log_zeta_limit : + Filter.Tendsto + (fun s : ℝ => Real.log (riemannZeta (s : ℂ)).re + Real.log (s - 1)) +@@ -1895,14 +1895,14 @@ + + end + +-@[blueprint +- "Euler-Mascheroni-eq" +- (title := "Compatibility with Mathlib Euler-Mascheroni constant") +- (statement := /-- $\gamma$ is the Euler--Mascheroni constant. +--/) +- (proof := /-- Take limits as $s \to 1$ in the previous asymptotic using known asymptotics for $\zeta(s)$, and using that $- \Gamma'(1)$ is the Euler--Mascheroni constant. -/) +- (latexEnv := "theorem") +- (discussion := 1320)] ++ ++ ++ ++ ++ ++ ++ ++ + theorem deriv_gamma_add_γ_eq_zero : deriv Gamma 1 + γ = 0 := by + -- For `s > 1`, `log_zeta_eq` rearranges to a constant identity. + have key : ∀ s : ℝ, 1 < s → +@@ -1930,15 +1930,15 @@ + theorem sum_mangoldt_div_log_eq (x : ℝ) : ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) = log (log x) + eulerMascheroniConstant + E₂Λ x := by + grind [γ.eq_eulerMascheroni] + +-@[blueprint +- "Mertens-second-theorem-mangoldt-weak" +- (title := "Mertens' second theorem (weak von Mangoldt form)") +- (statement := /-- For any $x \geq 2$, one has +-$$ \sum_{n \leq x} \frac{\Lambda(n)}{n \log n} = \log \log x + O(1). $$ +--/) +- (proof := /-- Immediate from previous two corollaries. +- -/) +- (discussion := 1321)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_mangoldt_div_log_eq_log_log : ∃ C, ∀ x, 2 ≤ x → + |∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) - log (log x)| ≤ C := by + use (log 4 + 6)/log 2 + |eulerMascheroniConstant| +@@ -1949,8 +1949,8 @@ + _ ≤ (log 4 + 6)/log x + |eulerMascheroniConstant| := by grw [abs_add_le, E₂Λ.abs_le hx] + _ ≤ _ := by gcongr + +-@[blueprint +- "Mertens-second-theorem-mangoldt-weak"] ++ ++ + theorem sum_mangoldt_div_log_eq_log_log' : (fun x ↦ ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d) - log (log x)) =O[atTop] (fun _ ↦ (1:ℝ)) := by + simp only [isBigO_iff, norm_eq_abs, one_mem, CStarRing.norm_of_mem_unitary, mul_one, + eventually_atTop] +@@ -1958,27 +1958,27 @@ + use C, 2 + + +-@[blueprint +- "Mertens-second-theorem-mangoldt-weak"] ++ ++ + theorem sum_mangoldt_div_log_eq_log_log'' : (fun x ↦ ∑ d ∈ Ioc 0 ⌊ x ⌋₊, (Λ d) / (d * log d)) ~[atTop] (fun x ↦ log (log x)) := by + apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log_log) + convert! sum_mangoldt_div_log_eq_log_log' using 1 + +-@[blueprint +- "Meissel-Mertens-constant" +- (title := "The Meissel-Mertens constant") +- (statement := /-- We define $M := \int_2^\infty \frac{E_{1,p}(t)}{t \log^2 t} \, dt + 1 - \log \log 2$.-/)] ++ ++ ++ ++ + noncomputable def M : ℝ := (∫ t in Set.Ioi 2, E₁p t / (t * log t^2)) + 1 - log (log 2) + +-@[blueprint +- "Mertens-second-constant-prime-le" +- (title := "Upper bound for $M$") +- (statement := /-- One has $M \leq \frac{\log 4 + 4}{\log 2} + 1 - \log \log 2$. +--/) +- (proof := /-- Insert Lemma \ref{Mertens-first-error-prime-le} into the definition of $M$ and use the fact that $\int_2^\infty \frac{dt}{t \log^2 t} = 1/\log 2$. +- -/) +- (latexEnv := "corollary") +- (discussion := 1323)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem M.le : M ≤ (log 4 + 4) / log 2 + 1 - log (log 2) := calc + _ ≤ (∫ t in Set.Ioi 2, (log 4 + 4) / (t * log t^2)) + 1 - log (log 2) := by + unfold M; gcongr with x hx +@@ -1989,15 +1989,15 @@ + simp at hx; exact E₁p.le (by linarith) + _ = _ := by rw [integ_div_mul_log_sq _ (by norm_num)] + +-@[blueprint +- "Mertens-second-constant-prime-ge" +- (title := "Lower bound for $M$") +- (statement := /-- One has $M \geq -\frac{2 + E_1}{\log 2} + 1 - \log \log 2$. +--/) +- (proof := /-- Insert Lemma \ref{Mertens-first-error-prime-ge} into the definition of $M$ and use the fact that $\int_2^\infty \frac{dt}{t \log^2 t} = 1/\log 2$. +- -/) +- (latexEnv := "corollary") +- (discussion := 1324)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem M.ge : M ≥ (-2 - E₁) / log 2 + 1 - log (log 2) := calc + _ ≥ (∫ t in Set.Ioi 2, (-2 - E₁) / (t * log t^2)) + 1 - log (log 2) := by + unfold M; gcongr with x hx +@@ -2008,29 +2008,29 @@ + simp at hx; exact E₁p.ge (by linarith) + _ = _ := by rw [integ_div_mul_log_sq _ (by norm_num)] + +-@[blueprint +- "Mertens-second-error-mangoldt" +- (title := "The remainder term in Mertens second theorem (von Mangoldt form)") +- (statement := /-- We define $E_{2,p}(x) := \sum_{p \leq x} \frac{1}{p} - \log \log x - M$. +--/)] ++ ++ ++ ++ ++ + noncomputable abbrev E₂p (x : ℝ) : ℝ := ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1:ℝ) / p - log (log x) - M + + theorem sum_prime_div_eq (x : ℝ) : ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1:ℝ) / p = log (log x) + M + E₂p x := by + ring + +-@[blueprint +- "Mertens-second-error-prime-eq" +- (title := "Integral form for second error (prime form)") +- (statement := /-- For any $x \geq 2$, one has +-$$ E_{2,p}(x) = \frac{E_{1,p}(x)}{\log x} - \int_x^\infty \frac{E_{1,p}(t)}{t \log^2 t}\ dt$$ +--/) +- (proof := /-- +-From Lemma \ref{Mertens-integral-ident} one has +-$$ \sum_{p \leq x} \frac{1}{p} = \frac{1}{\log x} \sum_{p \leq x} \frac{\log p}{p} + \int_2^x \frac{1}{t \log^2 t} \sum_{p \leq t} \frac{\log p}{p} \, dt.$$ +-Now substitute the definitions of $E_{1,p}$, $E_{2,p}$, $M$ and simplify. +- -/) +- (latexEnv := "corollary") +- (discussion := 1325)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₂p.eq {x : ℝ} (hx : 2 ≤ x) : + E₂p x = E₁p x / log x - ∫ t in Set.Ioi x, E₁p t / (t * log t^2) := by + unfold E₂p +@@ -2061,16 +2061,16 @@ + · rw [intervalIntegrable_iff, Set.uIoc_of_le hx] + exact integrable_E₁p_div_mul_log_sq (x := 2) (by rfl)|>.mono (by grind) (by rfl) + +-@[blueprint +- "Mertens-second-error-prime-abs-le" +- (title := "Bound for second error (prime form)") +- (statement := /-- For any $x \geq 2$, one has +-$$ |E_{2,p}(x)| \leq \frac{\log 4 + 6 + E_1}{\log x}.$$ +--/) +- (proof := /-- Similar to Lemma \ref{Mertens-second-error-prime-eq}. +- -/) +- (latexEnv := "corollary") +- (discussion := 1326)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₂p.abs_le {x : ℝ} (hx : 2 ≤ x) : + |E₂p x| ≤ (log 4 + 6 + E₁) / log x := by + have : 0 < log x := by apply log_pos; linarith +@@ -2101,8 +2101,8 @@ + grw [this] + grind + +-@[blueprint +- "Mertens-second-error-prime-abs-le"] ++ ++ + theorem E₂p.bound : E₂p =O[atTop] (fun x ↦ 1 / log x) := by + simp only [one_div, isBigO_iff, norm_eq_abs, norm_inv, eventually_atTop] + use log 4 + 6 + E₁, 2 +@@ -2111,19 +2111,19 @@ + have : 0 < log x := by apply log_pos; linarith + grind [abs_of_pos this] + +-@[blueprint +- "Mertens-second-error-prime-abs-le"] ++ ++ + theorem E₂p.bound' : E₂p =o[atTop] (fun _ ↦ (1:ℝ)) := E₂p.bound.trans_isLittleO inv_log_eq_o_one + +-@[blueprint +- "Mertens-second-theorem-prime-weak" +- (title := "Mertens' second theorem (weak prime form)") +- (statement := /-- For any $x \geq 2$, one has +-$$ \sum_{p \leq x} \frac{1}{p} = \log \log x + O(1). $$ +--/) +- (proof := /-- Immediate from previous two corollaries. +- -/) +- (discussion := 1327)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem sum_prime_div_eq_log_log : ∃ C, ∀ x, 2 ≤ x → + |∑ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1:ℝ) / p - log (log x)| ≤ C := by + use |M| + (log 4 + 6 + E₁) / log 2 +@@ -2137,16 +2137,16 @@ + have : 0 < log 4 := by apply log_pos; norm_num + linarith [E₁.nonneg] + +-@[blueprint +- "Mertens-second-theorem-prime-weak"] ++ ++ + theorem sum_prime_div_eq_log_log' : (fun x ↦ ∑ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1:ℝ) / p - log (log x)) =O[atTop] (fun _ ↦ (1:ℝ)) := by + simp only [isBigO_iff, norm_eq_abs, one_mem, CStarRing.norm_of_mem_unitary, mul_one, + eventually_atTop] + obtain ⟨ C, hC ⟩ := sum_prime_div_eq_log_log + use C, 2 + +-@[blueprint +- "Mertens-second-theorem-prime-weak"] ++ ++ + theorem sum_prime_div_eq_log_log'' : (fun x ↦ ∑ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1:ℝ) / p) ~[atTop] (fun x ↦ log (log x)) := by + apply IsLittleO.isEquivalent (IsBigO.trans_isLittleO _ one_eq_o_log_log) + convert! sum_prime_div_eq_log_log' using 1 +@@ -2244,33 +2244,33 @@ + ring_nf + · ring + +-@[blueprint +- "Meissel-Mertens-eq" +- (title := "Formula for Meissel-Mertens constant") +- (statement := /-- One has $M = \gamma + \sum_p \log(1-\frac{1}{p}) + \frac{1}{p}$. +--/) +- (proof := /-- The RHS can be Taylor expanded as $\sum_{j=2}^\infty \sum_p \frac{1}{jp^j}$. Meanwhile, the difference between $\sum_{n \leq x} \frac{\Lambda(n)}{n \log n}$ and $\sum_{p \leq x} \frac{1}{p}$ is equal to $\sum_{j=2}^\infty \sum_{p: p^j \leq x} \frac{1}{j p^j}$. Applying the monotone convergence theorem, Lemma \ref{Mertens-second-error-prime-abs-le}, and Lemma \ref{Mertens-second-error-mangoldt-bound} gives the claim. -/) +- (discussion := 1328)] ++ ++ ++ ++ ++ ++ ++ + theorem M.eq : M = γ + ∑' p : ℕ, if p.Prime then log (1 - 1 / p) + 1 / p else 0 := by + rw [← tsum_M_eq_f_eq_tsum, M_eq_f.HasSum.tsum_eq] + ring + +-@[blueprint +- "Mertens-third-error" +- (title := "The remainder term in Mertens third theorem ") +- (statement := /-- We define $E_3(x) := \sum_{p \leq x} \log (1 - \frac{1}{p}) + \log\log x + \gamma$. +--/)] ++ ++ ++ ++ ++ + noncomputable def E₃ (x : ℝ) : ℝ := ∑ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, log (1 - (1:ℝ) / p) + log (log x) + eulerMascheroniConstant + +-@[blueprint +- "Mertens-third-theorem-error" +- (title := "Mertens' third theorem error term") +- (statement := /-- For any $x \geq 2$, one has +-$$ \prod_{p \leq x} \left(1 - \frac{1}{p}\right) = \frac{e^{-\gamma}}{\log x} \exp(E_3(x)). $$ +--/) +- (proof := /-- Immediate from definition +- -/) +- (discussion := 1329)] ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem prod_one_minus_div_prime_eq {x : ℝ} (hx : 1 < x) : + ∏ p ∈ Ioc 0 ⌊x⌋₊ with p.Prime, (1 - (1 : ℝ) / p) = + exp (-eulerMascheroniConstant) * exp (E₃ x) / log x := by +@@ -2365,17 +2365,17 @@ + gcongr + exact Nat.lt_floor_add_one _|>.le + +-@[blueprint +- "Mertens-third-theorem-error-le" +- (title := "Mertens' third theorem error bound") +- (statement := /-- For any $x \geq 2$, one has +-$$ E_3(x) = O\left(\frac{1}{\log x}\right) $$ +--/) +- (proof := /--Estimating the error in \ref{Meissel-Mertens-eq} using the first order Taylor expansion of log one gets +-$$\sum_{p \le x}(\log (1-1/p)+1/p) = (M - \gamma) + O(1/x).$$ +-The result follows by combining with \ref{Mertens-second-error-prime-abs-le}. +- -/) +- (discussion := 1330)] ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + theorem E₃.abs_le : ∃ C, ∀ x, 2 ≤ x → |E₃ x| ≤ C / log x := by + unfold E₃ + refine ⟨4 + (log 4 + 6 + E₁), fun x hx ↦ ?_⟩ +@@ -2399,8 +2399,8 @@ + grw [this] + rw [← add_div] + +-@[blueprint +- "Mertens-third-theorem-error-le"] ++ ++ + theorem E₃.bound : E₃ =O[atTop] (fun x ↦ 1 / log x) := by + simp only [isBigO_iff, norm_eq_abs, eventually_atTop] + obtain ⟨ C, hC ⟩ := E₃.abs_le +@@ -2410,12 +2410,12 @@ + have : 0 < 1 / log x := by positivity + grind [abs_of_pos this] + +-@[blueprint +- "Mertens-third-theorem-error-le"] ++ ++ + theorem E₃.bound' : E₃ =o[atTop] (fun _ ↦ (1:ℝ)) := E₃.bound.trans_isLittleO inv_log_eq_o_one + +-@[blueprint +- "Mertens-third-theorem-error-le"] ++ ++ + theorem E₃.bound'' : (fun x ↦ ∏ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1 - (1:ℝ) / p)) ~[atTop] (fun x ↦ exp (-eulerMascheroniConstant) / log x) := by + rw [isEquivalent_iff_tendsto_one] + · convert Tendsto.congr' ?_ (Tendsto.rexp ((isLittleO_one_iff ℝ).mp E₃.bound')) using 2 with x +@@ -2427,8 +2427,8 @@ + simp only [ne_eq, div_eq_zero_iff, exp_ne_zero, log_eq_zero, eventually_atTop]; use 2 + grind + +-@[blueprint +- "Mertens-third-theorem-error-le"] ++ ++ + theorem E₃.bound''' : (fun x ↦ ∏ p ∈ Ioc 0 ⌊ x ⌋₊ with p.Prime, (1 - (1:ℝ) / p) - exp (-eulerMascheroniConstant) / log x) =O[atTop] (fun x ↦ 1 / (log x)^2) := by + obtain ⟨c, hc⟩ := E₃.abs_le + rw [isBigO_iff] +diff --git a/PrimeNumberTheoremAnd/PerronFormula.lean b/PrimeNumberTheoremAnd/PerronFormula.lean +--- a/PrimeNumberTheoremAnd/PerronFormula.lean ++++ b/PrimeNumberTheoremAnd/PerronFormula.lean +@@ -6,5 +6,3 @@ + import PrimeNumberTheoremAnd.Wiener +- +-set_option lang.lemmaCmd true +- ++ + open Asymptotics Complex ComplexConjugate Topology Filter Real MeasureTheory Set diff --git a/lean/patches/README.md b/lean/patches/README.md new file mode 100644 index 0000000000000000000000000000000000000000..128aee6b60aa056755c2e29d5c8aa8b6fc502ff0 --- /dev/null +++ b/lean/patches/README.md @@ -0,0 +1,6 @@ +# Dependency patches + +Compatibility patches for third-party Lean dependencies. +We thank the authors of these packages for their work. + +Run `lake update` from `lean/` to fetch dependencies and apply the patches. diff --git a/lean/patches/SphereEversion-lean4341.patch b/lean/patches/SphereEversion-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..d8e4a5d38848378c32d2fece23786e62ba51fe06 --- /dev/null +++ b/lean/patches/SphereEversion-lean4341.patch @@ -0,0 +1,21 @@ +diff --git a/lakefile.toml b/lakefile.toml +index 0247e04..211f3d8 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -11,7 +11,7 @@ + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.34.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[require]] + name = "checkdecls" +diff --git a/lean-toolchain b/lean-toolchain +index 12359f9..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.34.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/StrongPNT-lean4341.patch b/lean/patches/StrongPNT-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..e6264e1cc566bf17c29ab25c8d23777ba8955bd7 --- /dev/null +++ b/lean/patches/StrongPNT-lean4341.patch @@ -0,0 +1,26284 @@ +diff --git a/StrongPNT/Erdos970.lean b/StrongPNT/Erdos970.lean +new file mode 100644 +index 0000000..2427743 +--- /dev/null ++++ b/StrongPNT/Erdos970.lean +@@ -0,0 +1 @@ ++import StrongPNT.Erdos970.PNT5_Strong +diff --git a/StrongPNT/Erdos970/PNT1_ComplexAnalysis.lean b/StrongPNT/Erdos970/PNT1_ComplexAnalysis.lean +new file mode 100644 +index 0000000..c54399a +--- /dev/null ++++ b/StrongPNT/Erdos970/PNT1_ComplexAnalysis.lean +@@ -0,0 +1,5460 @@ ++import Mathlib ++ ++namespace Erdos970 ++ ++ ++lemma lem_2logOlog : (fun t : ℝ => 2 * Real.log t) =O[Filter.atTop] (fun t : ℝ => Real.log t) := Asymptotics.isBigO_const_mul_self 2 Real.log Filter.atTop ++ ++lemma lem_logt22logt (t : ℝ) (_ht : t ≥ 2) : Real.log (t ^ 2) = 2 * Real.log t := by ++ exact Real.log_pow t 2 ++ ++lemma lem_log2tlogt2 (t : ℝ) (ht : t ≥ 2) : Real.log (2 * t) ≤ Real.log (t ^ 2) := by ++ apply Real.log_le_log ++ · ++ linarith ++ · ++ ++ have h1 : t * (t - 2) ≥ 0 := by ++ apply mul_nonneg ++ · linarith ++ · linarith ++ ++ linarith [h1] ++ ++lemma lem_log22log (t : ℝ) (ht : t ≥ 2) : Real.log (2 * t) ≤ 2 * Real.log t := by ++ rw [← lem_logt22logt t ht] ++ exact lem_log2tlogt2 t ht ++ ++lemma lem_exprule (n : ℕ) (hn : n ≥ 1) (α β : ℂ) : (n : ℂ) ^ (α + β) = (n : ℂ) ^ α * (n : ℂ) ^ β := by ++ apply Complex.cpow_add ++ ++ rw [Nat.cast_ne_zero] ++ ++ rw [← Nat.one_le_iff_ne_zero] ++ exact hn ++ ++lemma lem_realbw (b : ℝ) (w : ℂ) : (b * w).re = b * w.re := by ++ exact Complex.re_ofReal_mul b w ++ ++lemma lem_sumReal {f : ℕ+ → ℂ} (hf : Summable f) : (∑' n : ℕ+, f n).re = ∑' n : ℕ+, (f n).re := by ++ exact Complex.re_tsum hf ++ ++lemma lem_Euler (a : ℝ) : Complex.exp (a * Complex.I) = Real.cos a + Real.sin a * Complex.I := by ++ rw [Complex.exp_mul_I] ++ rw [← Complex.ofReal_cos, ← Complex.ofReal_sin] ++ ++lemma lem_Reecos (a : ℝ) : (Complex.exp (a * Complex.I)).re = Real.cos a := by ++ rw [lem_Euler] ++ rw [Complex.add_re] ++ rw [Complex.ofReal_re] ++ rw [Complex.re_ofReal_mul] ++ rw [Complex.I_re] ++ simp ++ ++lemma lem_explog (n : ℕ) (hn : n ≥ 1) : (n : ℝ) = Real.exp (Real.log (n : ℝ)) := by ++ rw [Real.exp_log] ++ ++ rw [Nat.cast_pos] ++ ++ have h1 : n ≠ 0 := by ++ rw [← Nat.one_le_iff_ne_zero] ++ exact hn ++ rw [Nat.pos_iff_ne_zero] ++ exact h1 ++ ++lemma lem_coseven (a : ℝ) : Real.cos (-a) = Real.cos a := by ++ exact Real.cos_neg a ++ ++lemma lem_coseveny (n : ℕ) (_hn : n ≥ 1) (y : ℝ) : Real.cos (-y * Real.log (n : ℝ)) = Real.cos (y * Real.log (n : ℝ)) := by ++ rw [neg_mul] ++ exact lem_coseven (y * Real.log (n : ℝ)) ++ ++lemma lem_niyelog (n : ℕ) (hn : n ≥ 1) (y : ℝ) : (n : ℂ) ^ (-y * Complex.I) = Complex.exp (-y * Complex.I * Real.log (n : ℝ)) := by ++ ++ have h1 : (n : ℂ) ≠ 0 := by ++ rw [Nat.cast_ne_zero] ++ rw [← Nat.one_le_iff_ne_zero] ++ exact hn ++ ++ rw [Complex.cpow_def_of_ne_zero h1] ++ ++ rw [← Complex.natCast_log] ++ ++ ring_nf ++ ++lemma lem_eacosalog (n : ℕ) (_hn : n ≥ 1) (y : ℝ) : (Complex.exp (-y * Complex.I * Real.log (n : ℝ))).re = Real.cos (-y * Real.log (n : ℝ)) := by ++ ++ let a := -y * Real.log (n : ℝ) ++ ++ have h : -y * Complex.I * Real.log (n : ℝ) = a * Complex.I := by ++ simp [a, mul_assoc, mul_comm Complex.I] ++ rw [h] ++ ++ exact lem_Reecos a ++ ++lemma lem_eacosalog2 (n : ℕ) (hn : n ≥ 1) (y : ℝ) : ((n : ℂ) ^ (-y * Complex.I)).re = Real.cos (-y * Real.log (n : ℝ)) := by ++ rw [lem_niyelog n hn y] ++ exact lem_eacosalog n hn y ++ ++lemma lem_eacosalog3 (n : ℕ) (hn : n ≥ 1) (y : ℝ) : ((n : ℂ) ^ (-y * Complex.I)).re = Real.cos (y * Real.log (n : ℝ)) := by ++ rw [lem_eacosalog2 n hn y] ++ exact lem_coseveny n hn y ++ ++lemma lem_cos2t (θ : ℝ) : Real.cos (2 * θ) = 2 * Real.cos θ ^ 2 - 1 := by ++ exact Real.cos_two_mul θ ++ ++lemma lem_cos2t2 (θ : ℝ) : 2 * Real.cos θ ^ 2 = 1 + Real.cos (2 * θ) := by ++ rw [lem_cos2t] ++ ring ++ ++lemma lem_cosSquare (θ : ℝ) : 2 * (1 + Real.cos θ)^2 = 2 + 4 * Real.cos θ + 2 * Real.cos θ^2 := by ++ ring ++ ++lemma lem_cos2cos341 (θ : ℝ) : 2 * (1 + Real.cos θ) ^ 2 = 3 + 4 * Real.cos θ + Real.cos (2 * θ) := by ++ rw [lem_cosSquare] ++ rw [lem_cos2t2] ++ ring ++ ++lemma lem_SquarePos (y : ℝ) : 0 ≤ y ^ 2 := by ++ exact sq_nonneg y ++ ++lemma lem_SquarePos2 (y : ℝ) : 0 ≤ 2 * y ^ 2 := by ++ apply mul_nonneg ++ · norm_num ++ · exact lem_SquarePos y ++ ++lemma lem_SquarePoscos (θ : ℝ) : 0 ≤ 2 * (1 + Real.cos θ) ^ 2 := by ++ exact lem_SquarePos2 (1 + Real.cos θ) ++ ++lemma lem_postrig (θ : ℝ) : 0 ≤ 3 + 4 * Real.cos θ + Real.cos (2 * θ) := by ++ rw [← lem_cos2cos341] ++ exact lem_SquarePoscos θ ++ ++lemma lem_postriglogn (n : ℕ) (_hn : n ≥ 1) (t : ℝ) : 0 ≤ 3 + 4 * Real.cos (t * Real.log (n : ℝ)) + Real.cos (2 * t * Real.log (n : ℝ)) := by ++ rw [mul_assoc] ++ exact lem_postrig (t * Real.log (n : ℝ)) ++ ++lemma lem_seriesPos {r_n : ℕ+ → ℝ} {r : ℝ} (h_hasSum : HasSum r_n r) (h_nonneg : ∀ n : ℕ+, r_n n ≥ 0) : r ≥ 0 := by ++ ++ have h_eq : ∑' n, r_n n = r := HasSum.tsum_eq h_hasSum ++ ++ have h_tsum_nonneg : ∑' n, r_n n ≥ 0 := tsum_nonneg h_nonneg ++ ++ rw [← h_eq] ++ exact h_tsum_nonneg ++ ++lemma real_part_of_diff (M : ℝ) (w : ℂ) : (2 * M - w).re = 2 * M - w.re := by ++ simp [Complex.sub_re] ++ ++lemma real_part_of_diffz (M : ℝ) (f_z : ℂ) : (2 * M - f_z).re = 2 * M - f_z.re := real_part_of_diff M f_z ++ ++lemma inequality_reversal (x M : ℝ) (hxM : x ≤ M) : 2 * M - x ≥ M := by linarith ++ ++lemma real_part_lower_bound (w : ℂ) (M : ℝ) (_hM : M > 0) (h : w.re ≤ M) : 2 * M - w.re ≥ M := by apply inequality_reversal w.re M h ++ ++lemma real_part_lower_bound2 (w : ℂ) (M : ℝ) (hM : M > 0) (h : w.re ≤ M) : (2 * M - w).re ≥ M := by rw [real_part_of_diffz]; exact real_part_lower_bound w M hM h ++ ++lemma real_part_lower_bound3 (w : ℂ) (M : ℝ) (hM : M > 0) (h : w.re ≤ M) : (2 * M - w).re > 0 := by ++ rw [real_part_of_diffz] ++ apply lt_of_le_of_lt' ++ apply real_part_lower_bound ++ exact hM ++ exact h ++ exact hM ++ ++lemma nonzero_if_real_part_positive (w : ℂ) (hw_re_pos : w.re > 0) : w ≠ 0 := by ++ by_contra h ++ rw [h] at hw_re_pos ++ exact lt_irrefl 0 hw_re_pos ++ ++lemma lem_real_part_lower_bound4 (w : ℂ) (M : ℝ) (hM : M > 0) (h : w.re ≤ M) : (2 * M - w) ≠ 0 := by ++ apply nonzero_if_real_part_positive ++ exact real_part_lower_bound3 w M hM h ++ ++lemma lem_abspos (z : ℂ) : z ≠ 0 → norm z > 0 := by ++ intro h_ne_zero ++ apply Real.sqrt_pos.mpr ++ exact Complex.normSq_pos.mpr h_ne_zero ++ ++lemma lem_real_part_lower_bound5 (w : ℂ) (M : ℝ) (hM : M > 0) (h : w.re ≤ M) : norm (2 * M - w) > 0 := by ++ apply lem_abspos ++ exact lem_real_part_lower_bound4 w M hM h ++ ++lemma lem_wReIm (w : ℂ) : w = w.re + Complex.I * w.im := by ++ apply Complex.ext ++ simp ++ simp ++ ++lemma lem_modaib (a b : ℝ) : norm (a + Complex.I * b) ^ 2 = a ^ 2 + b ^ 2 := by rw [Complex.sq_norm, Complex.normSq_apply]; simp; ring ++ ++lemma lem_modcaib (a b c : ℝ) : norm (c - a - Complex.I * b) ^ 2 = (c - a) ^ 2 + b ^ 2 := by ++ rw [Complex.sq_norm, Complex.normSq_apply] ++ simp ++ ring ++ ++lemma lem_diffmods (a b c : ℝ) : ++norm (c - a - Complex.I * b) ^ 2 - norm (a + Complex.I * b) ^ 2 = (c - a) ^ 2 - a ^ 2 := by ++ rw [lem_modcaib, lem_modaib] ++ ring ++ ++lemma lem_casq (a c : ℝ) : (c - a) ^ 2 = a ^ 2 - 2 * a * c + c ^ 2 := by linarith ++ ++lemma lem_casq2 (a c : ℝ) : (c - a) ^ 2 - a ^ 2 = c * (c - 2 * a) := by ++ ring ++ ++lemma lem_diffmods2 (a b c : ℝ) : norm (c - a - Complex.I * b) ^ 2 - norm (a + Complex.I * b) ^ 2 = c * (c - 2 * a) := by ++ rw [lem_diffmods] ++ rw [lem_casq2] ++ ++lemma lem_modulus_sq_ReImw (M : ℝ) (w : ℂ) : norm (2 * M - w) ^ 2 - norm w ^ 2 = 4 * M * (M - w.re) := by ++ simp_rw [Complex.sq_norm] ++ simp_rw [Complex.normSq_apply] ++ simp [Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im] ++ ring ++ ++lemma lem_modulus_sq_identity (M : ℝ) (w : ℂ) : norm (2 * M - w) ^ 2 - norm w ^ 2 = 4 * M * (M - w.re) := lem_modulus_sq_ReImw M w ++ ++lemma lem_nonnegative_product (M x : ℝ) (hM : M > 0) (hxM : x ≤ M) : 4 * M * (M - x) ≥ 0 := by ++ have h_four_M_nonneg : 4 * M ≥ 0 := by linarith [hM] ++ have h_diff_nonneg : M - x ≥ 0 := by linarith [hxM] ++ apply mul_nonneg h_four_M_nonneg h_diff_nonneg ++ ++lemma lem_nonnegative_product2 (M : ℝ) (w : ℂ) (hM : M > 0) (hw_re_le_M : w.re ≤ M) : 4 * M * (M - w.re) ≥ 0 := by ++ apply lem_nonnegative_product ++ exact hM ++ exact hw_re_le_M ++ ++lemma lem_nonnegative_product3 (M : ℝ) (w : ℂ) (hM : M > 0) (hw_re_le_M : w.re ≤ M) : norm (2 * M - w) ^ 2 - norm w ^ 2 ≥ 0 := by ++ rw [lem_modulus_sq_identity] ++ apply lem_nonnegative_product2 ++ exact hM ++ exact hw_re_le_M ++ ++lemma lem_nonnegative_product4 (M : ℝ) (w : ℂ) (hM : M > 0) (hw_re_le_M : w.re ≤ M) : norm (2 * M - w) ^ 2 ≥ norm w ^ 2 := by ++ have h := lem_nonnegative_product3 M w hM hw_re_le_M ++ linarith ++ ++lemma lem_nonnegative_product5 (M : ℝ) (w : ℂ) (hM : M > 0) (hw_re_le_M : w.re ≤ M) : norm (2 * M - w) ≥ norm w := by ++ have h_sq_ge : ‖2 * M - w‖ ^ 2 ≥ ‖w‖ ^ 2 := by ++ apply lem_nonnegative_product4 M w hM hw_re_le_M ++ rw [ge_iff_le] at h_sq_ge ++ ++ apply (sq_le_sq₀ (norm_nonneg w) (norm_nonneg (2 * M - w))).mp ++ exact h_sq_ge ++ ++lemma lem_nonnegative_product6 (M : ℝ) (w : ℂ) (hM : M > 0) (hw_re_le_M : w.re ≤ M) : norm w ≤ norm (2 * M - w) := by apply lem_nonnegative_product5 M w hM hw_re_le_M ++ ++lemma lem_ineqmultr (a b c : ℝ) (hc : c > 0) (_ha : 0 ≤ a) (hab : a ≤ b) : a / c ≤ b / c := by ++ apply div_le_div_of_nonneg_right ++ exact hab ++ linarith [hc] ++ ++lemma lem_ineqmultrbb (a b : ℝ) (hb : b > 0) (ha : 0 ≤ a) (hab : a ≤ b) : a / b ≤ 1 := by ++ have h := lem_ineqmultr a b b hb ha hab ++ rw [div_self (ne_of_gt hb)] at h ++ exact h ++ ++lemma lem_nonnegative_product7 (M : ℝ) (w : ℂ) (_hM : M > 0) (h_abs_diff_pos : norm (2 * M - w) > 0) (h_abs_le_abs_diff : norm w ≤ norm (2 * M - w)) : norm w / norm (2 * M - w) ≤ 1 := by ++ ++ have h_abs_w_nonneg : 0 ≤ ‖w‖ := norm_nonneg w ++ ++ apply lem_ineqmultrbb ++ exact h_abs_diff_pos ++ exact h_abs_w_nonneg ++ exact h_abs_le_abs_diff ++ ++lemma lem_nonnegative_product8 (M : ℝ) (w : ℂ) (hM : M > 0) (hw_re_le_M : w.re ≤ M) (h_abs_le_abs_diff : norm w ≤ ++norm (2 * M - w)) : norm w / norm (2 * M - w) ≤ 1 := by ++ apply lem_nonnegative_product7 M w ++ exact hM ++ apply lem_real_part_lower_bound5 w M hM hw_re_le_M ++ exact h_abs_le_abs_diff ++ ++lemma lem_nonnegative_product9 (M : ℝ) (w : ℂ) (hM : M > 0) (hw_re_le_M : w.re ≤ M) : norm w / norm (2 * M - w) ≤ 1 := by ++ apply lem_nonnegative_product8 ++ exact hM ++ exact hw_re_le_M ++ apply lem_nonnegative_product6 ++ exact hM ++ exact hw_re_le_M ++ ++lemma lem_triangle_ineq (N G : ℂ) : norm (N + G) ≤ norm N + norm G := by ++ exact norm_add_le N G ++ ++lemma lem_triangleineqminus (N F : ℂ) : norm (N - F) ≤ norm N + norm F := by ++ rw [sub_eq_add_neg] ++ calc ++ ‖N + (-F)‖ ≤ ‖N‖ + ‖-F‖ := by apply lem_triangle_ineq ++ _ = ‖N‖ + ‖F‖ := by rw [norm_neg] ++ ++lemma lem_rtriangle (r : ℝ) (N F : ℂ) (hr : r > 0) : r * norm (N - F) ≤ r * (norm N + norm F) := by ++ apply mul_le_mul_of_nonneg_left ++ apply lem_triangleineqminus ++ linarith ++ ++lemma rtriangle2 (r : ℝ) (N F : ℂ) (hr : r > 0) : r * norm (N - F) ≤ r * norm N + r * norm F := by ++ have h := lem_rtriangle r N F hr ++ linarith [h] ++ ++lemma lem_rtriangle3 (r R : ℝ) (N F : ℂ) (hr : r > 0) (_hR : r < R) (h : R * norm F ≤ r * norm (N - F)) : R * norm F ≤ r * norm N + r * norm F := by ++ calc ++ R * norm F ≤ r * norm (N - F) := by exact h ++ _ ≤ r * norm N + r * norm F := by apply rtriangle2 r N F hr ++ ++lemma lem_rtriangle4 (r R : ℝ) (N F : ℂ) (hr : 0 < r) (hR : r < R) (h_hyp : R * norm F ≤ r * norm (N - F)) : (R - r) * norm F ≤ r * norm N := by ++ have h_result_from_lem3 : R * norm F ≤ r * norm N + r * norm F := by ++ apply lem_rtriangle3 r R N F hr hR h_hyp ++ linarith [h_result_from_lem3] ++ ++lemma lem_absposeq (a : ℝ) (ha : a > 0) : |a| = a := by ++ apply Real.norm_of_nonneg ++ linarith [ha] ++ ++lemma lem_a2a (a : ℝ) (ha : a > 0) : 2 * a > 0 := by linarith ++ ++lemma lem_absposeq2 (a : ℝ) (ha : a > 0) : |2 * a| = 2 * a := by ++ apply lem_absposeq ++ apply lem_a2a ++ exact ha ++ ++lemma lem_rtriangle5 (r R M : ℝ) (F : ℂ) (hr : 0 < r) (hrR : r < R) (hM : M > 0) ++ (h_hyp : R * norm F ≤ r * norm (2 * M - F)) : ++(R - r) * norm F ≤ 2 * M * r := by ++ ++ have h1 : (R - r) * norm F ≤ r * norm (2 * M : ℂ) := ++ lem_rtriangle4 r R (2 * M : ℂ) F hr hrR h_hyp ++ ++ have h2 : norm (2 * M : ℂ) = 2 * M := by ++ ++ have h_pos : (2 * M : ℝ) > 0 := by linarith [hM] ++ ++ convert Complex.norm_of_nonneg (le_of_lt h_pos) using 1 ++ ++ norm_cast ++ ++ rw [h2] at h1 ++ ++ rw [mul_comm r (2 * M)] at h1 ++ exact h1 ++ ++lemma lem_RrFpos (r R : ℝ) (F : ℂ) (_hr : 0 < r) (hrR : r < R) : (R - r) * norm F ≥ 0 := by ++ have h_R_minus_r_nonneg : R - r ≥ 0 := by linarith [hrR] ++ have h_abs_F_nonneg : 0 ≤ norm F := by apply norm_nonneg ++ apply mul_nonneg h_R_minus_r_nonneg h_abs_F_nonneg ++ ++lemma lem_rtriangle6 (r R M : ℝ) (F : ℂ) (hr : 0 < r) (hrR : r < R) (_hM : M > 0) ++ (h_hyp : (R - r) * norm F ≤ 2 * M * r) : ++norm F ≤ (2 * M * r) / (R - r) := by ++ have h_R_minus_r_pos : R - r > 0 := by linarith [hrR] ++ have h_numerator_nonneg : 0 ≤ (R - r) * ‖F‖ := by apply lem_RrFpos r R F hr hrR ++ ++ have h_ineq_with_denominators : ( (R - r) * ‖F‖ ) / (R - r) ≤ (2 * M * r) / (R - r) := by ++ apply lem_ineqmultr ++ exact h_R_minus_r_pos ++ exact h_numerator_nonneg ++ exact h_hyp ++ ++ rw [mul_div_cancel_left₀ (‖F‖) (ne_of_gt h_R_minus_r_pos)] at h_ineq_with_denominators ++ ++ exact h_ineq_with_denominators ++ ++lemma lem_rtriangle7 (r R M : ℝ) (F : ℂ) ++ (hr : 0 < r) (hrR : r < R) (hM : M > 0) ++ (h_hyp : R * norm F ≤ r * norm (2 * M - F)) : ++norm F ≤ (2 * M * r) / (R - r) := by ++ have h_step1 := lem_rtriangle5 r R M F hr hrR hM h_hyp ++ apply lem_rtriangle6 r R M F hr hrR hM h_step1 ++ ++def ballDR (R : ℝ) : Set ℂ := Metric.ball (0 : ℂ) R ++ ++lemma analyticAt_to_analyticWithinAt {f : ℂ → ℂ} {S : Set ℂ} {z : ℂ} (hf : AnalyticAt ℂ f z) : AnalyticWithinAt ℂ f S z := by ++ exact hf.analyticWithinAt ++ ++theorem analyticWithinAt_to_analyticAt_aux {f : ℂ → ℂ} {S : Set ℂ} {z : ℂ} (_hS : S ∈ nhds z) ++ (p : FormalMultilinearSeries ℂ ℂ ℂ) (r : ENNReal) (_h_conv_on_inter : r ≤ p.radius) (_hr_pos : 0 < r) ++ (hasSumt : ∀ {y : ℂ}, z + y ∈ insert z S → y ∈ Metric.eball 0 r → HasSum (fun n => (p n) fun _x => y) (f (z + y))) ++ (ε : ℝ) (hε_pos : ε > 0) (h_ball_subset_S : Metric.ball z ε ⊆ S) : ++ let r' := min r (ENNReal.ofReal ε); ++ ∀ {y : ℂ}, y ∈ Metric.eball 0 r' → HasSum (fun n => (p n) fun _x => y) (f (z + y)) := by ++ intro r' y hy ++ apply hasSumt ++ · ++ ++ right ++ apply h_ball_subset_S ++ rw [Metric.mem_ball] ++ ++ simp ++ ++ have : y ∈ Metric.eball 0 (ENNReal.ofReal ε) := by ++ apply Metric.eball_subset_eball (min_le_right r (ENNReal.ofReal ε)) hy ++ ++ have ε_nn : ENNReal.ofReal ε = ↑(ε.toNNReal) := by ++ simp [ENNReal.ofReal] ++ rw [ε_nn] at this ++ rw [@Metric.eball_coe] at this ++ simpa [Metric.mem_ball, dist_self_add_right, Real.toNNReal_of_nonneg hε_pos.le] ++ ++ · ++ exact Metric.eball_subset_eball (min_le_left r (ENNReal.ofReal ε)) hy ++ ++theorem analyticWithinAt_to_analyticAt {f : ℂ → ℂ} {S : Set ℂ} {z : ℂ} ++ (hS : S ∈ nhds z) (h : AnalyticWithinAt ℂ f S z) : AnalyticAt ℂ f z := by ++ rcases h with ⟨p, hp⟩ ++ ++ use p ++ ++ rcases hp with ⟨r, h_conv_on_inter, hr_pos⟩ ++ ++ rcases Metric.mem_nhds_iff.mp hS with ⟨ε, hε_pos, h_ball_subset_S⟩ ++ ++ let r' := min r (ENNReal.ofReal ε) ++ use r' ++ ++ constructor ++ ++ · exact inf_le_of_left_le h_conv_on_inter ++ ++ · ++ exact lt_min hr_pos (ENNReal.ofReal_pos.mpr hε_pos) ++ rename_i hasSumt ++ exact analyticWithinAt_to_analyticAt_aux hS p r h_conv_on_inter hr_pos hasSumt ε hε_pos h_ball_subset_S ++ ++lemma lem_not0mono (R : ℝ) (_hR_pos : 0 < R) (_hR_lt_one : R < 1) : ++ {z : ℂ | norm z ≤ R ∧ z ≠ 0} ⊆ {z : ℂ | z ≠ 0} := by ++ intro z hz ++ exact hz.2 ++ ++lemma lem_analmono {T S : Set ℂ} {f : ℂ → ℂ} (hS : AnalyticOn ℂ f S) (hT : T ⊆ S) : ++ AnalyticOn ℂ f T := by ++ exact hS.mono hT ++ ++lemma lem_1zanalDR (R : ℝ) (_hR_pos : 0 < R) : ++ AnalyticOn ℂ (fun z ↦ z⁻¹) {z : ℂ | norm z ≤ R ∧ z ≠ 0} := by ++ ++ apply AnalyticOn.mono (analyticOn_inv) ++ ++ intro z hz ++ ++ exact hz.2 ++ ++lemma lem_analprod {T : Set ℂ} {f1 f2 : ℂ → ℂ} (hf1 : AnalyticOn ℂ f1 T) (hf2 : AnalyticOn ℂ f2 T) : ++ AnalyticOn ℂ (f1 * f2) T := by ++ exact hf1.mul hf2 ++ ++lemma lem_analprodST {T S : Set ℂ} {f1 f2 : ℂ → ℂ} (hTS : T ⊆ S) (hf1 : AnalyticOn ℂ f1 T) (hf2 : AnalyticOn ℂ f2 S) : ++ AnalyticOn ℂ (f1 * f2) T := by ++ exact hf1.mul (hf2.mono hTS) ++ ++lemma lem_analprodTDR (R : ℝ) (f1 f2 : ℂ → ℂ) : ++ (AnalyticOn ℂ f1 {z : ℂ | norm z ≤ R ∧ z ≠ 0}) → ++ (AnalyticOn ℂ f2 (Metric.closedBall 0 R)) → ++ AnalyticOn ℂ (f1 * f2) {z : ℂ | norm z ≤ R ∧ z ≠ 0} := by ++ intro hf1 hf2 ++ ++ let T := {z : ℂ | norm z ≤ R ∧ z ≠ 0} ++ ++ have hf2_on_T : AnalyticOn ℂ f2 T := by ++ ++ apply hf2.mono ++ intro z hz ++ ++ simp [Metric.closedBall, dist_zero_right] ++ ++ exact hz.1 ++ ++ exact hf1.mul hf2_on_T ++ ++lemma lem_fzzTanal {R : ℝ} (hR_pos : 0 < R) (f : ℂ → ℂ) ++ (hf : AnalyticOn ℂ f (Metric.closedBall 0 R)) : ++ AnalyticOn ℂ (fun z ↦ f z / z) {z : ℂ | norm z ≤ R ∧ z ≠ 0} := by ++ ++ rw [show (fun z ↦ f z / z) = (fun z ↦ f z) * (fun z ↦ z⁻¹) by ext; simp [div_eq_mul_inv]] ++ ++ let T := {z : ℂ | norm z ≤ R ∧ z ≠ 0} ++ ++ have hf_on_T : AnalyticOn ℂ f T := hf.mono (?_) ++ ++ have h_inv_on_T : AnalyticOn ℂ (fun z ↦ z⁻¹) T := lem_1zanalDR R hR_pos ++ ++ exact lem_analprod hf_on_T h_inv_on_T ++ intro z hz ++ have hT : T = {z | norm z ≤ R ∧ z ≠ 0} := rfl ++ rw [hT] at hz ++ simp only [Set.mem_ofPred_eq] at hz ++ simp only [Metric.mem_closedBall] ++ simp only [dist_zero_right] ++ exact hz.1 ++ ++lemma lem_AnalOntoWithin {V : Set ℂ} {h : ℂ → ℂ} (hh : AnalyticOn ℂ h V) (z : ℂ) (hz : z ∈ V) : ++ AnalyticWithinAt ℂ h V z := by ++ exact hh z hz ++ ++lemma lem_AnalWithintoOn {R : ℝ} (_hR : 0 < R) (h : ℂ → ℂ) : ++ (∀ z ∈ Metric.closedBall 0 R, AnalyticWithinAt ℂ h (Metric.closedBall 0 R) z) → ++ AnalyticOn ℂ h (Metric.closedBall 0 R) := by ++ exact fun h => h ++ ++lemma lem_DR0T {R : ℝ} (hR : 0 < R) : ++ Metric.closedBall 0 R = {0} ∪ {z : ℂ | norm z ≤ R ∧ z ≠ 0} := by ++ ext z ++ simp [Metric.closedBall, dist_zero_right] ++ by_cases hz : z = 0 ++ · simp [hz, hR.le] ++ · simp [hz] ++ ++lemma lem_analWWWithin {R : ℝ} (hR_pos : 0 < R) (h : ℂ → ℂ) : ++ (AnalyticWithinAt ℂ h (Metric.closedBall 0 R) 0) → ++ (∀ z ∈ {z : ℂ | norm z ≤ R ∧ z ≠ 0}, AnalyticWithinAt ℂ h (Metric.closedBall 0 R) z) → ++ (∀ z ∈ Metric.closedBall 0 R, AnalyticWithinAt ℂ h (Metric.closedBall 0 R) z) := by ++ intro h0 hT z hz ++ rw [lem_DR0T hR_pos] at hz ++ cases' hz with hz hz ++ · simp at hz ++ rw [hz] ++ exact h0 ++ · exact hT z hz ++ ++lemma lem_analWWithinAtOn (R : ℝ) (hR_pos : 0 < R) (h : ℂ → ℂ) ++ (h_at_0 : AnalyticWithinAt ℂ h (Metric.closedBall 0 R) 0) ++ (h_at_T : ∀ z ∈ {z : ℂ | norm z ≤ R ∧ z ≠ 0}, AnalyticWithinAt ℂ h (Metric.closedBall 0 R) z) : ++ AnalyticOn ℂ h (Metric.closedBall 0 R) := by ++ exact lem_analWWWithin hR_pos h h_at_0 h_at_T ++ ++lemma lem_AnalAttoWithin {h : ℂ → ℂ} {s : Set ℂ} (hh : AnalyticAt ℂ h 0) : ++ AnalyticWithinAt ℂ h s 0 := by ++ exact hh.analyticWithinAt ++ ++lemma analyticWithinAt_punctured_to_closedBall {R : ℝ} (_hR : 0 < R) {h : ℂ → ℂ} {z : ℂ} (hz : z ∈ {w : ℂ | norm w ≤ R ∧ w ≠ 0}) (h_within : AnalyticWithinAt ℂ h {w : ℂ | norm w ≤ R ∧ w ≠ 0} z) : AnalyticWithinAt ℂ h (Metric.closedBall 0 R) z := by ++ ++ apply AnalyticWithinAt.mono_of_mem_nhdsWithin h_within ++ ++ have hz_ne_zero : z ≠ 0 := hz.2 ++ ++ rw [mem_nhdsWithin_iff_exists_mem_nhds_inter] ++ ++ use Metric.ball z (‖z‖ / 2) ++ ++ constructor ++ · ++ exact Metric.ball_mem_nhds z (half_pos (norm_pos_iff.mpr hz_ne_zero)) ++ ++ · ++ intro w hw ++ constructor ++ · ++ have w_in_closedball : w ∈ Metric.closedBall 0 R := hw.2 ++ simp only [Metric.mem_closedBall, dist_zero_right] at w_in_closedball ++ ++ simp [w_in_closedball] ++ · ++ intro hw_eq_zero ++ have w_in_ball : w ∈ Metric.ball z (‖z‖ / 2) := hw.1 ++ rw [hw_eq_zero] at w_in_ball ++ simp only [Metric.mem_ball] at w_in_ball ++ ++ rw [dist_comm] at w_in_ball ++ simp at w_in_ball ++ have pos_norm : 0 < ‖z‖ := norm_pos_iff.mpr hz_ne_zero ++ linarith [pos_norm] ++ ++lemma lem_analAtOnOn {R : ℝ} (hR_pos : 0 < R) (h : ℂ → ℂ) : ++ AnalyticAt ℂ h 0 → ++ AnalyticOn ℂ h {z : ℂ | norm z ≤ R ∧ z ≠ 0} → ++ AnalyticOn ℂ h (Metric.closedBall 0 R) := by ++ intro h_at_0 h_on_punctured ++ ++ apply lem_analWWithinAtOn R hR_pos h ++ ++ · exact lem_AnalAttoWithin h_at_0 ++ ++ · intro z hz ++ ++ have h_within_punctured : AnalyticWithinAt ℂ h {w : ℂ | norm w ≤ R ∧ w ≠ 0} z := ++ lem_AnalOntoWithin h_on_punctured z hz ++ ++ exact analyticWithinAt_punctured_to_closedBall hR_pos hz h_within_punctured ++ ++lemma lem_orderne0 (f : ℂ → ℂ) (hf : AnalyticAt ℂ f 0) (hf0 : f 0 = 0) : ++ analyticOrderAt f 0 ≠ 0 := by exact (AnalyticAt.analyticOrderAt_ne_zero hf).mpr hf0 ++ ++lemma lem_ordernetop (f : ℂ → ℂ) (_hf : AnalyticAt ℂ f 0) (hf_ne_zero : ¬(∀ᶠ z in nhds 0, f z = 0)) : ++ analyticOrderAt f 0 ≠ ⊤ := by ++ intro h ++ rw [analyticOrderAt_eq_top] at h ++ exact hf_ne_zero h ++ ++lemma lem_ordernatcast (f : ℂ → ℂ) (hf : AnalyticAt ℂ f 0) (n : ℕ) (hn : analyticOrderAt f 0 = n) : ++ ∃ (g : ℂ → ℂ), AnalyticAt ℂ g 0 ∧ g 0 ≠ 0 ∧ ∀ᶠ (z : ℂ) in nhds 0, f z = z ^ n * g z := by ++ ++ rw [AnalyticAt.analyticOrderAt_eq_natCast] at hn ++ · convert hn ++ aesop ++ · exact hf ++ ++lemma lem_ordernatcast1 (f : ℂ → ℂ) (hf : AnalyticAt ℂ f 0) (n : ℕ) (hn : analyticOrderAt f 0 = n) (hn_ne_zero : n ≠ 0) : ++ ∃ (h : ℂ → ℂ), AnalyticAt ℂ h 0 ∧ ∀ᶠ z in nhds 0, f z = z * h z := by ++ ++ rcases lem_ordernatcast f hf n hn with ⟨g, hg_analytic, _, hf_eq_g⟩ ++ ++ use fun z ↦ z ^ (n - 1) * g z ++ constructor ++ · ++ exact (analyticAt_id.pow (n - 1)).mul hg_analytic ++ · ++ filter_upwards [hf_eq_g] with z h_eq ++ rw [h_eq] ++ ring_nf ++ rw [← pow_succ' z (n - 1), Nat.sub_add_cancel (Nat.pos_of_ne_zero hn_ne_zero)] ++ ++lemma lem_ordernatcast2_old (f : ℂ → ℂ) (hf : AnalyticAt ℂ f 0) (hf0 : f 0 = 0) ++ (h_not_eventually_zero : ¬ (∀ᶠ z in nhds 0, f z = 0)) : ++ ∃ (h : ℂ → ℂ), AnalyticAt ℂ h 0 ∧ ∀ᶠ z in nhds 0, f z = z * h z := by ++ ++ let n₀ := analyticOrderAt f 0 ++ ++ have hn_ne_top : n₀ ≠ ⊤ := lem_ordernetop f hf h_not_eventually_zero ++ ++ lift n₀ to ℕ using hn_ne_top with n hn_eq ++ ++ have hn_ne_zero : n ≠ 0 := by ++ intro hn_zero ++ rw [hn_zero] at hn_eq ++ ++ have t := (lem_orderne0 f hf hf0) ++ have : n₀ = analyticOrderAt f 0 := rfl ++ rw [←this] at t ++ exact t (id (Eq.symm hn_eq)) ++ ++ exact lem_ordernatcast1 f hf n (by aesop) hn_ne_zero ++ ++lemma lem_ordernatcast2 {R : ℝ} (hR_pos : 0 < R) (f : ℂ → ℂ) (hf0 : f 0 = 0) ++ (hf : AnalyticOn ℂ f (Metric.closedBall 0 R)) : ++ AnalyticAt ℂ (fun z ↦ if z = 0 then (fderiv ℂ f 0) 1 else f z / z) 0 := by ++ ++ have hS : Metric.closedBall 0 R ∈ nhds (0 : ℂ) := by ++ ++ refine Filter.mem_of_superset (Metric.ball_mem_nhds (0 : ℂ) hR_pos) ?subset ++ exact Metric.ball_subset_closedBall ++ have hf_within : AnalyticWithinAt ℂ f (Metric.closedBall 0 R) 0 := hf 0 (by ++ simp [Metric.mem_closedBall, hR_pos.le]) ++ have hf_at0 : AnalyticAt ℂ f 0 := analyticWithinAt_to_analyticAt hS hf_within ++ ++ let g : ℂ → ℂ := fun z ↦ if z = 0 then (fderiv ℂ f 0) 1 else f z / z ++ ++ by_cases hEZ : (∀ᶠ z in nhds (0 : ℂ), f z = 0) ++ · ++ ++ have hU : {z : ℂ | f z = 0} ∈ nhds (0 : ℂ) := by simpa only [Filter.Eventually] using hEZ ++ ++ have hf_eq_zero : f =ᶠ[nhds (0 : ℂ)] (fun _ : ℂ => 0) := by ++ refine (Filter.eventuallyEq_iff_exists_mem).2 ?_ ++ exact ⟨{z | f z = 0}, hU, by intro z hz; simpa [Set.mem_ofPred_eq] using hz⟩ ++ ++ have h_fderiv_zero : (fderiv ℂ f 0) = 0 := by ++ simpa using (Filter.EventuallyEq.fderiv_eq hf_eq_zero) ++ ++ have h_g_zero_on_U : ∀ z ∈ {z : ℂ | f z = 0}, g z = 0 := by ++ intro z hzU ++ by_cases hz0 : z = 0 ++ · ++ simp [g, hz0, h_fderiv_zero] ++ · ++ have : f z = 0 := by simpa [Set.mem_ofPred_eq] using hzU ++ simp [g, hz0, this] ++ ++ have h_const0_within : AnalyticWithinAt ℂ (fun _ : ℂ => (0 : ℂ)) {z : ℂ | f z = 0} 0 := ++ analyticAt_const.analyticWithinAt ++ have h_g_within : AnalyticWithinAt ℂ g {z : ℂ | f z = 0} 0 := by ++ ++ apply h_const0_within.congr ++ intro z hz ++ by_cases hz0 : z = 0 ++ · ++ simp [g, hz0, h_fderiv_zero] ++ · ++ have : f z = 0 := by simpa [Set.mem_ofPred_eq] using hz ++ simp [g, hz0, this] ++ ++ simp [g, h_fderiv_zero] ++ exact analyticWithinAt_to_analyticAt hU h_g_within ++ ++ · ++ have h_notEZ : ¬ (∀ᶠ z in nhds (0 : ℂ), f z = 0) := hEZ ++ ++ rcases lem_ordernatcast2_old f hf_at0 hf0 h_notEZ with ⟨h0, h0_at0, hfac_ev⟩ ++ ++ have hV : {z : ℂ | f z = z * h0 z} ∈ nhds (0 : ℂ) := by simpa only [Filter.Eventually] using hfac_ev ++ have h_eq_nhds : f =ᶠ[nhds (0 : ℂ)] (fun z => z * h0 z) := ++ (Filter.eventuallyEq_iff_exists_mem).2 ⟨{z : ℂ | f z = z * h0 z}, hV, by ++ intro z hz; simpa [Set.mem_ofPred_eq] using hz⟩ ++ ++ have h_fderiv_prod : fderiv ℂ f 0 = fderiv ℂ (fun z => z * h0 z) 0 := ++ Filter.EventuallyEq.fderiv_eq h_eq_nhds ++ ++ have h_diff_id : DifferentiableAt ℂ (fun z : ℂ => z) 0 := differentiableAt_id ++ have h_diff_h0 : DifferentiableAt ℂ h0 0 := h0_at0.differentiableAt ++ ++ have h_val0 : (fderiv ℂ f 0) 1 = h0 0 := by ++ ++ rw [h_fderiv_prod] ++ rw [fderiv_fun_mul' h_diff_id h_diff_h0] ++ simp only [add_apply, smul_apply] ++ rw [fderiv_fun_id] ++ simp only [ContinuousLinearMap.id_apply] ++ simp only [zero_smul, zero_add] ++ simp ++ ++ have h_geq_h0_on_V : ∀ z ∈ {z : ℂ | f z = z * h0 z}, g z = h0 z := by ++ intro z hzU ++ by_cases hz0 : z = 0 ++ · ++ simpa [g, hz0] using h_val0 ++ · ++ have : f z = z * h0 z := by simpa [Set.mem_ofPred_eq] using hzU ++ simp only [g, ite_eq_right hz0, this] ++ exact mul_div_cancel_left₀ (h0 z) hz0 ++ ++ have h0_within : AnalyticWithinAt ℂ h0 {z : ℂ | f z = z * h0 z} 0 := h0_at0.analyticWithinAt ++ have hg_within : AnalyticWithinAt ℂ g {z : ℂ | f z = z * h0 z} 0 := by ++ ++ apply AnalyticWithinAt.congr h0_within ++ ++ intro z hz ++ exact h_geq_h0_on_V z hz ++ ++ have h_0_in_V : (0 : ℂ) ∈ {z : ℂ | f z = z * h0 z} := by ++ simp [hf0] ++ exact h_geq_h0_on_V 0 h_0_in_V ++ exact analyticWithinAt_to_analyticAt hV hg_within ++ ++theorem ex (x : ℂ) {r : ℝ} (hr : r > 0) : ++ closure (Metric.ball x r) = Metric.closedBall x r := by ++ exact closure_ball x (by linarith [hr]) ++ ++lemma lem_ballDR (R : ℝ) (hR : R > 0) : closure (ballDR R) = Metric.closedBall (0 : ℂ) R := by ++ unfold ballDR ++ exact closure_ball 0 (ne_of_gt hR) ++ ++lemma lem_inDR (R : ℝ) (hR : R > 0) (w : ℂ) (hw : w ∈ closure (ballDR R)) : norm w ≤ R := by ++ rw [lem_ballDR R hR] at hw ++ rw [Metric.mem_closedBall] at hw ++ rw [Complex.dist_eq] at hw ++ simp at hw ++ exact hw ++ ++lemma lem_notinDR (R : ℝ) (_hR : R > 0) (w : ℂ) (hw : w ∉ ballDR R) : norm w ≥ R := by ++ ++ unfold ballDR at hw ++ ++ rw [Metric.mem_ball] at hw ++ ++ push Not at hw ++ ++ rw [Complex.dist_eq] at hw ++ ++ simp at hw ++ exact hw ++ ++lemma lem_legeR (R : ℝ) (_hR : R > 0) (w : ℂ) (hw1 : norm w ≤ R) (hw2 : norm w ≥ R) : norm w = R := by ++ linarith ++ ++lemma lem_circleDR (R : ℝ) (hR : R > 0) (w : ℂ) (hw1 : w ∈ closure (ballDR R)) (hw2 : w ∉ ballDR R) : norm w = R := by ++ have h1 : norm w ≤ R := lem_inDR R hR w hw1 ++ have h2 : norm w ≥ R := lem_notinDR R hR w hw2 ++ exact lem_legeR R hR w h1 h2 ++ ++lemma lem_Rself (R : ℝ) (hR : R > 0) : |R| = R := by ++ rw [abs_eq_self] ++ linarith ++ ++lemma lem_Rself2 (R : ℝ) (hR : R > 0) : |R| ≤ R := by ++ rw [lem_Rself R hR] ++ ++lemma lem_Rself3 (R : ℝ) (hR : R > 0) : (R : ℂ) ∈ closure (ballDR R) := by ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ simp ++ exact lem_Rself2 R hR ++ ++lemma lem_DRcompact (R : ℝ) (hR : R > 0) : IsCompact (closure (ballDR R)) := by ++ rw [lem_ballDR R hR] ++ apply Metric.isCompact_of_isClosed_isBounded ++ · exact Metric.isClosed_closedBall ++ · exact Metric.isBounded_closedBall ++ ++lemma lem_ExtrValThm {K : Set ℂ} (hK : IsCompact K) (hK_nonempty : K.Nonempty) (g : K → ℂ) (hg : Continuous g) : ++∃ v : K, ∀ z : K, norm (g z) ≤ norm (g v) := by ++ ++ have : CompactSpace K := isCompact_iff_compactSpace.mp hK ++ ++ have : Nonempty K := hK_nonempty.to_subtype ++ ++ let f : K → ℝ := fun z => norm (g z) ++ ++ have hf_cont : Continuous f := continuous_norm.comp hg ++ ++ obtain ⟨v, hv_mem, hv_max⟩ := IsCompact.exists_isMaxOn isCompact_univ Set.univ_nonempty hf_cont.continuousOn ++ use v ++ intro z ++ exact hv_max (Set.mem_univ z) ++ ++lemma lem_ExtrValThmDR (R : ℝ) (hR : R > 0) (g : closure (ballDR R) → ℂ) (hg : Continuous g) : ++∃ v : closure (ballDR R), ∀ z : closure (ballDR R), norm (g z) ≤ norm (g v) := by ++ ++ have hK_compact : IsCompact (closure (ballDR R)) := lem_DRcompact R hR ++ ++ have hK_nonempty : (closure (ballDR R)).Nonempty := by ++ rw [lem_ballDR R hR] ++ rw [Metric.nonempty_closedBall] ++ linarith ++ ++ exact lem_ExtrValThm hK_compact hK_nonempty g hg ++ ++lemma lem_AnalCont {R : ℝ} (_hR : R > 0) (H : ℂ → ℂ) (h_analytic : AnalyticOn ℂ H (closure (ballDR R))) : ++Continuous (H ∘ (Subtype.val : closure (ballDR R) → ℂ)) := by ++ ++ have h_cont_on : ContinuousOn H (closure (ballDR R)) := AnalyticOn.continuousOn h_analytic ++ ++ have h_val_cont : Continuous (Subtype.val : closure (ballDR R) → ℂ) := continuous_subtype_val ++ ++ exact ContinuousOn.comp_continuous h_cont_on h_val_cont (fun _ => Subtype.mem _) ++ ++lemma lem_ExtrValThmh {R : ℝ} (hR : R > 0) (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) : ++∃ u : closure (ballDR R), ∀ z : closure (ballDR R), norm (h u) ≥ norm (h z) := by ++ ++ have hg_continuous : Continuous (h ∘ Subtype.val : closure (ballDR R) → ℂ) := ++ lem_AnalCont hR h h_analytic ++ ++ obtain ⟨v, hv⟩ := lem_ExtrValThmDR R hR (h ∘ Subtype.val) hg_continuous ++ ++ use v ++ ++ intro z ++ have : norm ((h ∘ Subtype.val) z) ≤ norm ((h ∘ Subtype.val) v) := hv z ++ ++ simp [Function.comp] at this ++ exact this ++ ++lemma lem_MaxModP (R : ℝ) (_hR : R > 0) (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) (w : ℂ) (hw_in_DR : w ∈ ballDR R) (hw_max : ∀ z ∈ ballDR R, norm (h z) ≤ norm (h w)) : ∀ z ∈ closure (ballDR R), norm (h z) = norm (h w) := by ++ ++ have h_preconnected : IsPreconnected (ballDR R) := by ++ unfold ballDR ++ apply Convex.isPreconnected ++ exact convex_ball (0 : ℂ) R ++ ++ have h_open : IsOpen (ballDR R) := by ++ unfold ballDR ++ exact Metric.isOpen_ball ++ ++ have h_diff_cont : DiffContOnCl ℂ h (ballDR R) := by ++ constructor ++ · ++ apply AnalyticOn.differentiableOn ++ exact h_analytic.mono subset_closure ++ · ++ exact AnalyticOn.continuousOn h_analytic ++ ++ have h_max_on : IsMaxOn (norm ∘ h) (ballDR R) w := by ++ intro z hz ++ change ‖h z‖ ≤ ‖h w‖ ++ exact hw_max z hz ++ ++ have h_eq := Complex.norm_eqOn_closure_of_isPreconnected_of_isMaxOn h_preconnected h_open h_diff_cont hw_in_DR h_max_on ++ ++ intro z hz ++ have norm_eq := h_eq hz ++ simp only [Function.comp_apply, Function.const_apply] at norm_eq ++ ++ convert norm_eq ++ ++lemma lem_MaxModR (R : ℝ) (hR : R > 0) (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) (w : ℂ) (hw_in_DR : w ∈ ballDR R) (hw_max : ∀ z ∈ ballDR R, norm (h z) ≤ norm (h w)) : norm (h R) = norm (h w) := by ++ ++ have h_const : ∀ z ∈ closure (ballDR R), norm (h z) = norm (h w) := ++ lem_MaxModP R hR h h_analytic w hw_in_DR hw_max ++ ++ have hR_in_closure : (R : ℂ) ∈ closure (ballDR R) := lem_Rself3 R hR ++ ++ exact h_const (R : ℂ) hR_in_closure ++ ++lemma lem_MaxModRR (R : ℝ) (hR : R > 0) (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) ++ (w : ℂ) (hw_in_DR : w ∈ ballDR R) (hw_max : ∀ z ∈ ballDR R, norm (h z) ≤ norm (h w)) : ++∀ z ∈ closure (ballDR R), norm (h R) ≥ norm (h z) := by ++ intro z hz ++ ++ have h1 := lem_MaxModP R hR h h_analytic w hw_in_DR hw_max z hz ++ ++ have h2 := lem_MaxModR R hR h h_analytic w hw_in_DR hw_max ++ ++ rw [h2, h1] ++ ++theorem lem_MaxModv2 (R : ℝ) (hR : R > 0) (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) : ++∃ v : closure (ballDR R), norm (v : ℂ) = R ∧ ∀ z : closure (ballDR R), norm (h (v : ℂ)) ≥ norm (h (z : ℂ)) := by ++ ++ obtain ⟨u, hu⟩ := lem_ExtrValThmh hR h h_analytic ++ ++ if h_case : (u : ℂ) ∈ ballDR R then ++ ++ have hR_in_closure : (R : ℂ) ∈ closure (ballDR R) := lem_Rself3 R hR ++ let v : closure (ballDR R) := ⟨R, hR_in_closure⟩ ++ use v ++ constructor ++ · ++ ++ have v_eq : (v : ℂ) = (R : ℂ) := rfl ++ rw [v_eq] ++ ++ have : norm (R : ℂ) = abs R := by ++ simp [Complex.norm_real] ++ rw [this, lem_Rself R hR] ++ · ++ intro z ++ ++ have hw_max : ∀ w ∈ ballDR R, norm (h w) ≤ norm (h (u : ℂ)) := by ++ intro w hw ++ ++ have hw_closure : w ∈ closure (ballDR R) := subset_closure hw ++ ++ let w_sub : closure (ballDR R) := ⟨w, hw_closure⟩ ++ exact hu w_sub ++ ++ have h_result := lem_MaxModRR R hR h h_analytic (u : ℂ) h_case hw_max ++ ++ have v_eq : (v : ℂ) = (R : ℂ) := rfl ++ rw [v_eq] ++ ++ exact h_result (z : ℂ) (Subtype.mem z) ++ else ++ ++ use u ++ constructor ++ · ++ exact lem_circleDR R hR (u : ℂ) (Subtype.mem u) h_case ++ · ++ exact hu ++ ++theorem lem_MaxModv3 (R : ℝ) (hR : R > 0) (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) : ++∃ v : ℂ, norm v = R ∧ ∀ z : ℂ, z ∈ closure (ballDR R) → norm (h v) ≥ norm (h z) := by ++ ++ obtain ⟨v_sub, hv_abs, hv_max⟩ := lem_MaxModv2 R hR h h_analytic ++ ++ let v := (v_sub : ℂ) ++ use v ++ constructor ++ · ++ exact hv_abs ++ · ++ intro z hz ++ ++ have hz_sub : z ∈ closure (ballDR R) := hz ++ let z_sub : closure (ballDR R) := ⟨z, hz_sub⟩ ++ have := hv_max z_sub ++ ++ simp at this ++ exact this ++ ++lemma lem_MaxModv4 (R B : ℝ) (hR : R > 0) (_hB : B ≥ 0) ++ (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) ++ (h_boundary_bound : ∀ z : ℂ, norm z = R → norm (h z) ≤ B) : ++∃ v : ℂ, norm v = R ∧ (∀ w : ℂ, w ∈ closure (ballDR R) → norm (h v) ≥ norm (h w)) ∧ norm (h v) ≤ B := by ++ ++ obtain ⟨v, hv_abs, hv_max⟩ := lem_MaxModv3 R hR h h_analytic ++ ++ use v ++ constructor ++ · ++ exact hv_abs ++ constructor ++ · ++ exact hv_max ++ · ++ apply h_boundary_bound ++ exact hv_abs ++ ++lemma lem_HardMMP (R B : ℝ) (hR : R > 0) (hB : B ≥ 0) ++ (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) ++ (h_boundary_bound : ∀ z : ℂ, norm z = R → norm (h z) ≤ B) : ++∀ w : ℂ, w ∈ closure (ballDR R) → norm (h w) ≤ B := by ++ intro w hw ++ ++ obtain ⟨v, hv_abs, hv_max, hv_bound⟩ := lem_MaxModv4 R B hR hB h h_analytic h_boundary_bound ++ ++ have h1 : norm (h w) ≤ norm (h v) := hv_max w hw ++ have h2 : norm (h v) ≤ B := hv_bound ++ ++ linarith [h1, h2] ++ ++lemma lem_EasyMMP (R B : ℝ) (hR : R > 0) (_hB : B ≥ 0) ++ (h : ℂ → ℂ) (_h_analytic : AnalyticOn ℂ h (closure (ballDR R))) ++ (h_closure_bound : ∀ w : ℂ, w ∈ closure (ballDR R) → norm (h w) ≤ B) : ++∀ z : ℂ, norm z = R → norm (h z) ≤ B := by ++ intro z hz ++ ++ apply h_closure_bound z ++ ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ rw [Complex.dist_eq] ++ simp ++ ++ have : ‖z‖ = R := hz ++ linarith ++ ++theorem lem_MMP (R B : ℝ) (hR : R > 0) (hB : B ≥ 0) (h : ℂ → ℂ) (h_analytic : AnalyticOn ℂ h (closure (ballDR R))) : ++(∀ z : ℂ, z ∈ closure (ballDR R) → norm (h z) ≤ B) ↔ (∀ z : ℂ, norm z = R → norm (h z) ≤ B) := by ++ constructor ++ · ++ intro h_closure_bound ++ exact lem_EasyMMP R B hR hB h h_analytic h_closure_bound ++ · ++ intro h_boundary_bound ++ exact lem_HardMMP R B hR hB h h_analytic h_boundary_bound ++ ++lemma lem_denominator_nonzero (R M : ℝ) (_hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) (_h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) : ++∀ z : ℂ, z ∈ closure (ballDR R) → (2 * M - f z) ≠ 0 := by ++ intro z hz ++ ++ apply lem_real_part_lower_bound4 (f z) M hM ++ ++ exact h_re_bound z hz ++ ++lemma lem_f_vs_2M_minus_f (R M : ℝ) (_hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) (_h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) : ++∀ z : ℂ, z ∈ closure (ballDR R) → norm (f z) / norm (2 * M - f z) ≤ 1 := by ++ intro z hz ++ ++ apply lem_nonnegative_product9 M (f z) hM ++ ++ exact h_re_bound z hz ++ ++lemma fderiv_factorization_at_zero (R : ℝ) (hR : R > 0) (f h : ℂ → ℂ) ++ (h_analytic_f : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_analytic_h : AnalyticOn ℂ h (closure (ballDR R))) ++ (_h_zero : f 0 = 0) ++ (h_factor : ∀ z ∈ closure (ballDR R), f z = z * h z) : ++ (fderiv ℂ f 0) 1 = h 0 := by ++ ++ have h_zero_in : (0 : ℂ) ∈ closure (ballDR R) := by ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ simp ++ linarith [hR] ++ ++ have h_diff_on_f : DifferentiableOn ℂ f (closure (ballDR R)) := h_analytic_f.differentiableOn ++ have h_diff_on_h : DifferentiableOn ℂ h (closure (ballDR R)) := h_analytic_h.differentiableOn ++ ++ have h_nhds_mem : closure (ballDR R) ∈ nhds (0 : ℂ) := by ++ rw [lem_ballDR R hR] ++ rw [mem_nhds_iff] ++ use Metric.ball 0 R ++ constructor ++ · exact Metric.ball_subset_closedBall ++ constructor ++ · exact Metric.isOpen_ball ++ · rw [Metric.mem_ball] ++ simp ++ exact hR ++ ++ have h_diff_f : DifferentiableAt ℂ f 0 := h_diff_on_f.differentiableAt h_nhds_mem ++ have h_diff_h : DifferentiableAt ℂ h 0 := h_diff_on_h.differentiableAt h_nhds_mem ++ ++ have h_diff_id : DifferentiableAt ℂ (fun z : ℂ => z) 0 := differentiableAt_id ++ ++ have h_eq_nhds : f =ᶠ[nhds 0] (fun z => z * h z) := by ++ rw [Filter.eventuallyEq_iff_exists_mem] ++ exact ⟨closure (ballDR R), h_nhds_mem, h_factor⟩ ++ ++ have h_fderiv_eq : fderiv ℂ f 0 = fderiv ℂ (fun z => z * h z) 0 := ++ Filter.EventuallyEq.fderiv_eq h_eq_nhds ++ ++ rw [h_fderiv_eq] ++ rw [fderiv_fun_mul' h_diff_id h_diff_h] ++ ++ simp only [add_apply, smul_apply] ++ rw [fderiv_fun_id] ++ simp only [ContinuousLinearMap.id_apply] ++ ++ simp only [zero_smul, zero_add] ++ ++ simp ++ ++lemma lem_removable_singularity (R : ℝ) (hR : R > 0) (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) (h_zero : f 0 = 0) : ++AnalyticOn ℂ (fun z ↦ if z = 0 then (fderiv ℂ f 0) 1 else f z / z) (closure (ballDR R)) := by ++ ++ rw [lem_ballDR R hR] at h_analytic ⊢ ++ ++ let g : ℂ → ℂ := fun z ↦ if z = 0 then (fderiv ℂ f 0) 1 else f z / z ++ ++ apply lem_analAtOnOn hR g ++ ++ · ++ ++ exact lem_ordernatcast2 hR f h_zero h_analytic ++ ++ · ++ ++ have f_on_closedball : AnalyticOn ℂ f (Metric.closedBall 0 R) := h_analytic ++ have quotient_analytic : AnalyticOn ℂ (fun z ↦ f z / z) {z : ℂ | ‖z‖ ≤ R ∧ z ≠ 0} := ++ lem_fzzTanal hR f f_on_closedball ++ ++ apply AnalyticOn.congr quotient_analytic ++ intro z hz ++ ++ simp [g, ite_eq_right hz.2] ++ ++lemma lem_quotient_analytic {R : ℝ} (_hR : R > 0) (h1 h2 : ℂ → ℂ) ++ (h_analytic1 : AnalyticOn ℂ h1 (closure (ballDR R))) ++ (h_analytic2 : AnalyticOn ℂ h2 (closure (ballDR R))) ++ (h_nonzero : ∀ z ∈ closure (ballDR R), h2 z ≠ 0) : ++AnalyticOn ℂ (fun z ↦ h1 z / h2 z) (closure (ballDR R)) := by ++ exact AnalyticOn.div h_analytic1 h_analytic2 h_nonzero ++ ++noncomputable def f_M (R M : ℝ) (_hR : R > 0) (_hM : M > 0) ++ (f : ℂ → ℂ) ++ (_h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (_h_zero : f 0 = 0) ++ (_h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) : ++ℂ → ℂ := fun z ↦ (if z = 0 then (fderiv ℂ f 0) 1 else f z / z) / (2 * M - f z) ++ ++lemma lem_g_analytic (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) : ++AnalyticOn ℂ (f_M R M hR hM f h_analytic h_zero h_re_bound) (closure (ballDR R)) := by ++ ++ let h₁ : ℂ → ℂ := fun z ↦ if z = 0 then (fderiv ℂ f 0) 1 else f z / z ++ ++ let h₂ : ℂ → ℂ := fun z ↦ 2 * M - f z ++ ++ have h_eq : f_M R M hR hM f h_analytic h_zero h_re_bound = fun z ↦ h₁ z / h₂ z := by ++ ext z ++ unfold f_M h₁ h₂ ++ simp ++ ++ rw [h_eq] ++ ++ apply lem_quotient_analytic hR ++ ++ · exact lem_removable_singularity R hR f h_analytic h_zero ++ ++ · have h₂_analytic : AnalyticOn ℂ h₂ (closure (ballDR R)) := by ++ unfold h₂ ++ apply AnalyticOn.sub ++ · exact analyticOn_const ++ · exact h_analytic ++ exact h₂_analytic ++ ++ · intro z hz ++ unfold h₂ ++ exact lem_denominator_nonzero R M hR hM f h_analytic h_re_bound z hz ++ ++lemma lem_absab (a b : ℂ) (_hb : b ≠ 0) : norm (a / b) = norm a / norm b := by ++ exact IsAbsoluteValue.abv_div norm a b ++ ++lemma lem_g_on_boundaryz (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (z : ℂ) (hz_in_closure : z ∈ closure (ballDR R)) (hz_nonzero : z ≠ 0) : ++ norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) = ++norm (f z / z) / norm (2 * M - f z) := by ++ ++ unfold f_M ++ ++ simp only [ite_eq_right hz_nonzero] ++ ++ have h_nonzero : (2 * M - f z) ≠ 0 := lem_denominator_nonzero R M hR hM f h_analytic h_re_bound z hz_in_closure ++ ++ exact lem_absab (f z / z) (2 * M - f z) h_nonzero ++ ++lemma lem_fzzR (R : ℝ) (hR : R > 0) (z w : ℂ) (hz : norm z = R) : norm (w / z) = norm w / R := by ++ ++ have hz_nonzero : z ≠ 0 := by ++ intro h_eq ++ rw [h_eq] at hz ++ simp at hz ++ linarith [hz, hR] ++ ++ rw [lem_absab w z hz_nonzero] ++ ++ rw [hz] ++ ++lemma lem_g_on_boundary (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (z : ℂ) (hz_on_boundary : norm z = R) : ++ norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) = ++(norm (f z) / R) / norm (2 * M - f z) := by ++ ++ have hz_nonzero : z ≠ 0 := by ++ intro h_eq ++ rw [h_eq] at hz_on_boundary ++ simp at hz_on_boundary ++ linarith [hz_on_boundary, hR] ++ ++ have hz_in_closure : z ∈ closure (ballDR R) := by ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ rw [Complex.dist_eq] ++ simp ++ convert le_of_eq hz_on_boundary ++ ++ have h1 : norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) = ++ norm (f z / z) / norm (2 * M - f z) := ++ lem_g_on_boundaryz R M hR hM f h_analytic h_zero h_re_bound z hz_in_closure hz_nonzero ++ ++ have h2 : norm (f z / z) = norm (f z) / R := ++ lem_fzzR R hR z (f z) hz_on_boundary ++ ++ rw [h1, h2] ++ ++lemma lem_f_vs_2M_minus_fR (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (_h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (z : ℂ) (hz_in_closure : z ∈ closure (ballDR R)) : ++(norm (f z) / R) / norm (2 * M - f z) ≤ 1 / R := by ++ ++ have h1 : norm (f z) / norm (2 * M - f z) ≤ 1 := ++ lem_f_vs_2M_minus_f R M hR hM f h_analytic h_re_bound z hz_in_closure ++ ++ rw [div_div] ++ ++ rw [mul_comm R] ++ ++ rw [← div_div] ++ ++ exact div_le_div_of_nonneg_right h1 (le_of_lt hR) ++ ++lemma lem_g_boundary_bound0 (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (z : ℂ) (hz_on_boundary : norm z = R) : ++norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) ≤ 1 / R := by ++ ++ have hz_in_closure : z ∈ closure (ballDR R) := by ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ rw [Complex.dist_eq] ++ simp ++ convert le_of_eq hz_on_boundary ++ ++ rw [lem_g_on_boundary R M hR hM f h_analytic h_zero h_re_bound z hz_on_boundary] ++ ++ exact lem_f_vs_2M_minus_fR R M hR hM f h_analytic h_zero h_re_bound z hz_in_closure ++ ++lemma lem_g_interior_bound (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) : ++∀ z : ℂ, z ∈ closure (ballDR R) → norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) ≤ 1 / R := by ++ ++ have hB : (1 / R : ℝ) ≥ 0 := div_nonneg zero_le_one (le_of_lt hR) ++ ++ have h_g_analytic : AnalyticOn ℂ (f_M R M hR hM f h_analytic h_zero h_re_bound) (closure (ballDR R)) := ++ lem_g_analytic R M hR hM f h_analytic h_zero h_re_bound ++ ++ apply (lem_MMP R (1 / R) hR hB (f_M R M hR hM f h_analytic h_zero h_re_bound) h_g_analytic).mpr ++ ++ intro z hz_boundary ++ exact lem_g_boundary_bound0 R M hR hM f h_analytic h_zero h_re_bound z hz_boundary ++ ++lemma lem_g_at_r (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (r : ℝ) (hr_pos : r > 0) (hr_lt_R : r < R) ++ (z : ℂ) (hz_on_boundary : norm z = r) : ++ norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) = ++(norm (f z) / r) / norm (2 * M - f z) := by ++ ++ have hz_nonzero : z ≠ 0 := by ++ intro h_eq ++ rw [h_eq] at hz_on_boundary ++ simp at hz_on_boundary ++ linarith [hz_on_boundary, hr_pos] ++ ++ have hz_in_closure : z ∈ closure (ballDR R) := by ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ rw [Complex.dist_eq] ++ simp ++ linarith [hz_on_boundary, hr_lt_R] ++ ++ have h1 : norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) = ++ norm (f z / z) / norm (2 * M - f z) := ++ lem_g_on_boundaryz R M hR hM f h_analytic h_zero h_re_bound z hz_in_closure hz_nonzero ++ ++ have h2 : norm (f z / z) = norm (f z) / r := ++ lem_fzzR r hr_pos z (f z) hz_on_boundary ++ ++ rw [h1, h2] ++ ++lemma lem_g_at_rR (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (r : ℝ) (hr_pos : r > 0) (hr_lt_R : r < R) ++ (z : ℂ) (hz_on_boundary : norm z = r) : ++(norm (f z) / r) / norm (2 * M - f z) ≤ 1 / R := by ++ ++ have hz_in_closure : z ∈ closure (ballDR R) := by ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ rw [Complex.dist_eq] ++ simp ++ linarith [hz_on_boundary, hr_lt_R] ++ ++ have h_bound : norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) ≤ 1 / R := ++ lem_g_interior_bound R M hR hM f h_analytic h_zero h_re_bound z hz_in_closure ++ ++ have h_eq : norm (f_M R M hR hM f h_analytic h_zero h_re_bound z) = ++ (norm (f z) / r) / norm (2 * M - f z) := ++ lem_g_at_r R M hR hM f h_analytic h_zero h_re_bound r hr_pos hr_lt_R z hz_on_boundary ++ ++ rw [← h_eq] ++ exact h_bound ++ ++lemma lem_fracs (a b r R : ℝ) (ha : a > 0) (hb : b > 0) (hr : r > 0) (hR : R > 0) ++(h_le : (a / r) / b ≤ 1 / R) : R * a ≤ r * b := by ++ ++ have h1 : (a / r) / b = a / (r * b) := by ++ field_simp ++ rw [h1] at h_le ++ ++ have h_pos_rb : 0 < r * b := mul_pos hr hb ++ rw [div_le_div_iff₀ h_pos_rb hR] at h_le ++ ++ simp only [one_mul] at h_le ++ ++ linarith ++ ++lemma lem_nonneg_product_with_real_abs (r M : ℝ) (hr : r > 0) (hM : M > 0) : 0 ≤ r * (2 * |M|) := by ++ ++ have h_abs_eq : |M| = M := abs_of_pos hM ++ ++ rw [h_abs_eq] ++ ++ have h_two_M_pos : (2 : ℝ) * M > 0 := by ++ apply mul_pos ++ norm_num ++ exact hM ++ ++ apply mul_nonneg ++ linarith [hr] ++ linarith [h_two_M_pos] ++ ++lemma lem_f_bound_rearranged (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (r : ℝ) (hr_pos : r > 0) (hr_lt_R : r < R) ++ (z : ℂ) (hz_on_boundary : norm z = r) : ++R * norm (f z) ≤ r * norm (2 * M - f z) := by ++ ++ have hz_in_closure : z ∈ closure (ballDR R) := by ++ rw [lem_ballDR R hR] ++ rw [Metric.mem_closedBall] ++ rw [Complex.dist_eq] ++ simp ++ linarith [hz_on_boundary, hr_lt_R] ++ ++ have h_ineq : (norm (f z) / r) / norm (2 * M - f z) ≤ 1 / R := ++ lem_g_at_rR R M hR hM f h_analytic h_zero h_re_bound r hr_pos hr_lt_R z hz_on_boundary ++ ++ have h_denom_nonzero : (2 * M - f z) ≠ 0 := ++ lem_denominator_nonzero R M hR hM f h_analytic h_re_bound z hz_in_closure ++ ++ have h_denom_pos : norm (2 * M - f z) > 0 := ++ lem_abspos (2 * M - f z) h_denom_nonzero ++ ++ by_cases h_case : f z = 0 ++ · ++ rw [h_case] ++ simp [mul_zero] ++ exact lem_nonneg_product_with_real_abs r M hr_pos hM ++ · ++ have h_num_pos : norm (f z) > 0 := ++ lem_abspos (f z) h_case ++ ++ exact lem_fracs (norm (f z)) (norm (2 * M - f z)) r R ++ h_num_pos h_denom_pos hr_pos hR h_ineq ++ ++lemma lem_final_bound_on_circle0 (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (r : ℝ) (hr_pos : r > 0) (hr_lt_R : r < R) ++ (z : ℂ) (hz_on_boundary : norm z = r) : ++norm (f z) ≤ (2 * r / (R - r)) * M := by ++ ++ have h_ineq : R * norm (f z) ≤ r * norm (2 * M - f z) := ++ lem_f_bound_rearranged R M hR hM f h_analytic h_zero h_re_bound r hr_pos hr_lt_R z hz_on_boundary ++ ++ have h_bound : norm (f z) ≤ (2 * M * r) / (R - r) := ++ lem_rtriangle7 r R M (f z) hr_pos hr_lt_R hM h_ineq ++ ++ have h_rearrange : (2 * M * r) / (R - r) = (2 * r / (R - r)) * M := by ++ field_simp ++ ++ rw [← h_rearrange] ++ exact h_bound ++ ++lemma lem_final_bound_on_circle (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (r : ℝ) (hr_pos : r > 0) (hr_lt_R : r < R) ++ (z : ℂ) (hz_on_boundary : norm z = r) : ++norm (f z) ≤ (2 * r / (R - r)) * M := by ++ exact lem_final_bound_on_circle0 R M hR hM f h_analytic h_zero h_re_bound r hr_pos hr_lt_R z hz_on_boundary ++ ++lemma lem_BCI (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (r : ℝ) (hr_pos : r > 0) (hr_lt_R : r < R) ++ (z : ℂ) (hz_in_ball : norm z ≤ r) : ++norm (f z) ≤ (2 * r / (R - r)) * M := by ++ ++ let B := (2 * r / (R - r)) * M ++ ++ have hB : B ≥ 0 := by ++ unfold B ++ apply mul_nonneg ++ · apply div_nonneg ++ · apply mul_nonneg ++ · norm_num ++ · linarith [hr_pos] ++ · linarith [hr_lt_R] ++ · linarith [hM] ++ ++ have h_analytic_r : AnalyticOn ℂ f (closure (ballDR r)) := by ++ apply AnalyticOn.mono h_analytic ++ ++ apply closure_mono ++ unfold ballDR ++ exact Metric.ball_subset_ball (le_of_lt hr_lt_R) ++ ++ have hz_in_closure_r : z ∈ closure (ballDR r) := by ++ rw [lem_ballDR r hr_pos] ++ rw [Metric.mem_closedBall] ++ rw [Complex.dist_eq] ++ simp ++ exact hz_in_ball ++ ++ have h_boundary : ∀ w : ℂ, norm w = r → norm (f w) ≤ B := by ++ intro w hw_boundary ++ exact lem_final_bound_on_circle R M hR hM f h_analytic h_zero h_re_bound r hr_pos hr_lt_R w hw_boundary ++ ++ have h_closure := (lem_MMP r B hr_pos hB f h_analytic_r).mpr h_boundary ++ ++ exact h_closure z hz_in_closure_r ++ ++theorem thm_BorelCaratheodoryI (R M : ℝ) (hR : R > 0) (hM : M > 0) ++ (f : ℂ → ℂ) ++ (h_analytic : AnalyticOn ℂ f (closure (ballDR R))) ++ (h_zero : f 0 = 0) ++ (h_re_bound : ∀ z : ℂ, z ∈ closure (ballDR R) → Complex.re (f z) ≤ M) ++ (r : ℝ) (hr_pos : r > 0) (hr_lt_R : r < R) : ++sSup ((norm ∘ f) '' (closure (ballDR r))) ≤ (2 * r / (R - r)) * M := by ++ ++ apply Real.sSup_le ++ · ++ intro x hx ++ ++ obtain ⟨z, hz_in_closure, hx_eq⟩ := hx ++ rw [← hx_eq] ++ ++ have hz_bound : norm z ≤ r := by ++ rw [lem_ballDR r hr_pos] at hz_in_closure ++ rw [Metric.mem_closedBall] at hz_in_closure ++ rw [Complex.dist_eq] at hz_in_closure ++ simp at hz_in_closure ++ exact hz_in_closure ++ ++ exact lem_BCI R M hR hM f h_analytic h_zero h_re_bound r hr_pos hr_lt_R z hz_bound ++ · ++ apply mul_nonneg ++ · apply div_nonneg ++ · apply mul_nonneg ++ · norm_num ++ · linarith [hr_pos] ++ · linarith [hr_lt_R] ++ · linarith [hM] ++ ++def I := Complex.I ++ ++lemma cauchy_formula_deriv {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (_h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++deriv f z = (1 / (2 * Real.pi * I)) • ∮ w in C(0, r_int), (w - z)⁻¹ ^ 2 • f w := by ++ ++ obtain ⟨U', hU'_open, h_subset, hf_diff_U'⟩ := hf_domain ++ ++ have hz_in_ball : z ∈ Metric.ball (0 : ℂ) r_int := by ++ apply Metric.mem_ball.mpr ++ have h1 : ‖z - 0‖ ≤ r_z := by simpa only [dist_eq_norm] using Metric.mem_closedBall.mp hz ++ simp only [sub_zero] at h1 ++ have h2 : ‖z‖ < r_int := lt_of_le_of_lt h1 h_r_z_lt_r_int ++ rwa [dist_eq_norm, sub_zero] ++ ++ set U := Metric.ball (0 : ℂ) R_analytic ++ ++ have hc_subset : Metric.closedBall (0 : ℂ) r_int ⊆ U := by ++ apply Metric.closedBall_subset_ball ++ exact h_r_int_lt_R_analytic ++ ++ have hf_on_U : DifferentiableOn ℂ f U := by ++ ++ apply DifferentiableOn.mono hf_diff_U' ++ calc U = Metric.ball 0 R_analytic := rfl ++ _ ⊆ Metric.closedBall 0 R_analytic := Metric.ball_subset_closedBall ++ _ ⊆ U' := h_subset ++ ++ have cauchy_eq := Complex.two_pi_I_inv_smul_circleIntegral_sub_sq_inv_smul_of_differentiable ++ Metric.isOpen_ball hc_subset hf_on_U hz_in_ball ++ ++ rw [← cauchy_eq] ++ ++ congr 2 ++ · ++ simp only [one_div] ++ ++ rfl ++ · ++ ext w ++ rw [← inv_pow] ++ ++lemma lem_dw_dt {r_int : ℝ} (t : ℝ) : ++deriv (fun t' => r_int * Complex.exp (I * t')) t = I * r_int * Complex.exp (I * t) := by ++ ++ rw [deriv_const_mul] ++ ++ rw [deriv_cexp] ++ ++ rw [deriv_const_mul] ++ ++ convert_to r_int * (Complex.exp (I * t) * (I * 1)) = I * r_int * Complex.exp (I * t) ++ · ++ rw [← deriv_id] ++ congr ++ ++ ring ++ ++ · exact differentiableAt_id ++ · exact (differentiableAt_const I).mul differentiableAt_id ++ · exact DifferentiableAt.cexp ((differentiableAt_const I).mul differentiableAt_id) ++ ++lemma circleMap_zero_eq_exp (r : ℝ) (t : ℝ) : circleMap 0 r t = r * Complex.exp (I * t) := by ++ ++ rw [circleMap] ++ ++ simp only [zero_add] ++ ++ congr 2 ++ rw [mul_comm (t : ℂ) Complex.I] ++ ++ rfl ++ ++lemma deriv_ofReal_eq_one (t : ℝ) : deriv Complex.ofReal t = 1 := by ++ ++ have h : deriv Complex.ofReal t = Complex.ofReal 1 := by ++ ++ rw [show Complex.ofReal = ⇑Complex.ofRealCLM from rfl] ++ exact ContinuousLinearMap.deriv Complex.ofRealCLM ++ ++ rw [h] ++ simp only [Complex.ofReal_one] ++ ++lemma differentiableAt_ofReal (t : ℝ) : DifferentiableAt ℝ Complex.ofReal t := by ++ ++ rw [show Complex.ofReal = ⇑Complex.ofRealCLM from rfl] ++ ++ apply ContinuousLinearMap.differentiableAt ++ ++lemma lem_dw_dt_real {r_int : ℝ} (t : ℝ) : ++deriv (fun (t' : ℝ) => r_int * Complex.exp (I * t')) t = I * r_int * Complex.exp (I * t) := by ++ ++ rw [deriv_const_mul] ++ ++ rw [deriv_cexp] ++ ++ rw [deriv_const_mul] ++ ++ rw [deriv_ofReal_eq_one] ++ ++ ring ++ ++ · exact differentiableAt_ofReal t ++ · exact (differentiableAt_const I).mul (differentiableAt_ofReal t) ++ · exact DifferentiableAt.cexp ((differentiableAt_const I).mul (differentiableAt_ofReal t)) ++ ++lemma deriv_circleMap_zero (r : ℝ) (t : ℝ) : deriv (circleMap 0 r) t = I * r * Complex.exp (I * t) := by ++ ++ have h : circleMap 0 r = fun (t' : ℝ) => r * Complex.exp (I * t') := by ++ ext t' ++ exact circleMap_zero_eq_exp r t' ++ ++ rw [h] ++ ++ exact lem_dw_dt_real t ++ ++lemma lem_CIF_deriv_param {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ deriv f z = (1 / (2 * Real.pi * I)) * (∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), ++(I * r_int * Complex.exp (I * t) * ((r_int * Complex.exp (I * t)) - z)⁻¹ ^ 2) * f (r_int * Complex.exp (I * t))) := by ++ ++ rw [cauchy_formula_deriv hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz] ++ ++ rw [circleIntegral_def_Icc] ++ ++ rw [smul_eq_mul] ++ ++ simp only [circleMap_zero_eq_exp, deriv_circleMap_zero] ++ ++ congr 2 ++ ext t ++ simp only [smul_eq_mul] ++ ring ++ ++lemma mul_comm_div_cancel (a b : ℂ) (ha : a ≠ 0) (hb : b ≠ 0) : a * b / (b * a) = 1 := by ++ ++ rw [mul_comm b a] ++ ++ apply div_self ++ ++ exact mul_ne_zero ha hb ++ ++lemma complex_coeff_I_cancel : (1 : ℂ) / (2 * Real.pi * I) * I = 1 / (2 * Real.pi) := by ++ field_simp [I, Complex.I_ne_zero, Real.pi_pos.ne'] ++ ++lemma factor_I_from_integrand (f : ℂ → ℂ) (r_int : ℝ) (z : ℂ) : ++ ∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), I * ↑r_int * Complex.exp (I * ↑t) * (↑r_int * Complex.exp (I * ↑t) - z)⁻¹ ^ 2 * f (↑r_int * Complex.exp (I * ↑t)) = ++ I * ∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), ↑r_int * Complex.exp (I * ↑t) * (↑r_int * Complex.exp (I * ↑t) - z)⁻¹ ^ 2 * f (↑r_int * Complex.exp (I * ↑t)) := by ++ ++ have h : ∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), I * ↑r_int * Complex.exp (I * ↑t) * (↑r_int * Complex.exp (I * ↑t) - z)⁻¹ ^ 2 * f (↑r_int * Complex.exp (I * ↑t)) = ++ ∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), I • (↑r_int * Complex.exp (I * ↑t) * (↑r_int * Complex.exp (I * ↑t) - z)⁻¹ ^ 2 * f (↑r_int * Complex.exp (I * ↑t))) := by ++ congr 1 ++ ext t ++ rw [smul_eq_mul] ++ ring ++ rw [h] ++ ++ rw [MeasureTheory.integral_smul] ++ ++ rw [smul_eq_mul] ++ ++lemma integrand_transform_div (f : ℂ → ℂ) (r_int : ℝ) (z : ℂ) (t : ℝ) : ++ ↑r_int * Complex.exp (I * ↑t) * (↑r_int * Complex.exp (I * ↑t) - z)⁻¹ ^ 2 * f (↑r_int * Complex.exp (I * ↑t)) = ++ ↑r_int * Complex.exp (I * ↑t) * f (↑r_int * Complex.exp (I * ↑t)) / (↑r_int * Complex.exp (I * ↑t) - z) ^ 2 := by ++ ++ rw [inv_pow] ++ ++ rw [← div_eq_mul_inv] ++ ++ ring ++ ++lemma lem_CIF_deriv_simplified {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ deriv f z = (1 / (2 * Real.pi)) * (∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), ++(r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) := by ++ ++ rw [lem_CIF_deriv_param hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz] ++ ++ rw [factor_I_from_integrand f r_int z] ++ ++ rw [← mul_assoc, complex_coeff_I_cancel] ++ ++ congr 2 ++ funext t ++ rw [integrand_transform_div f r_int z t] ++ ++lemma lem_modulus_of_f_prime0 {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ norm (deriv f z) = norm ((1 / (2 * Real.pi)) * (∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), ++(r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2)) := by ++ ++ rw [lem_CIF_deriv_simplified hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz] ++ ++lemma one_div_two_pi_pos : (1 : ℝ) / (2 * Real.pi) > 0 := by ++ ++ have h_pi_pos : Real.pi > 0 := Real.pi_pos ++ ++ have h_2pi_pos : 2 * Real.pi > 0 := by ++ apply mul_pos ++ · norm_num ++ · exact h_pi_pos ++ ++ apply div_pos ++ · norm_num ++ · exact h_2pi_pos ++ ++lemma abs_integral_le_integral_abs {a b : ℝ} {g : ℝ → ℂ} (_hab : a ≤ b) : norm (∫ (t : ℝ) in Set.Icc a b, g t) ≤ ∫ (t : ℝ) in Set.Icc a b, norm (g t) := by ++ ++ exact MeasureTheory.norm_integral_le_integral_norm g ++ ++lemma abs_ofReal_mul_complex (c : ℝ) (z : ℂ) (hc : c ≥ 0) : norm (↑c * z) = c * norm z := by ++ ++ have h1 : norm (↑c * z) = norm (↑c) * norm z := by simp ++ rw [h1] ++ ++ congr 1 ++ ++ simp ++ assumption ++ ++lemma complex_abs_mul (a b : ℂ) : norm (a * b) = norm a * norm b := ++ Complex.norm_mul a b ++ ++lemma complex_abs_ofReal_nonneg (r : ℝ) (hr : r ≥ 0) : norm (↑r : ℂ) = r := by ++ ++ have h1 : norm (↑r * 1) = r * norm (1 : ℂ) := by simp; assumption ++ ++ simp only [mul_one] at h1 ++ have h2 : norm (1 : ℂ) = 1 := by simp ++ rw [h2] at h1 ++ simp only [mul_one] at h1 ++ simp ++ assumption ++ ++lemma abs_one_div_two_pi_complex : norm (1 / (2 * ↑Real.pi : ℂ)) = 1 / (2 * Real.pi) := by ++ ++ have h_eq : (1 / (2 * ↑Real.pi) : ℂ) = ↑(1 / (2 * Real.pi) : ℝ) := by ++ simp only [Complex.ofReal_div, Complex.ofReal_one, Complex.ofReal_mul, Complex.ofReal_ofNat] ++ ++ rw [h_eq] ++ ++ have h_nonneg : (1 / (2 * Real.pi) : ℝ) ≥ 0 := by ++ apply div_nonneg ++ · norm_num ++ · apply mul_nonneg ++ · norm_num ++ · exact le_of_lt Real.pi_pos ++ ++ exact complex_abs_ofReal_nonneg (1 / (2 * Real.pi)) h_nonneg ++ ++lemma lem_integral_modulus_inequality {r_int : ℝ} {z : ℂ} {f : ℂ → ℂ} : ++norm ((1 / (2 * Real.pi)) * (∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), (r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2)) ≤ (1 / (2 * Real.pi)) * (∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), norm ((r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2)) := by ++ ++ rw [complex_abs_mul] ++ ++ rw [abs_one_div_two_pi_complex] ++ ++ apply mul_le_mul_of_nonneg_left ++ · ++ have h_2pi_nonneg : (0 : ℝ) ≤ 2 * Real.pi := by ++ apply mul_nonneg ++ · norm_num ++ · exact le_of_lt Real.pi_pos ++ exact abs_integral_le_integral_abs h_2pi_nonneg ++ · exact le_of_lt one_div_two_pi_pos ++ ++lemma lem_modulus_of_f_prime {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ norm (deriv f z) ≤ (1 / (2 * Real.pi)) * (∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), ++norm ((r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2)) := by ++ ++ rw [lem_modulus_of_f_prime0 hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz] ++ ++ exact lem_integral_modulus_inequality ++ ++lemma lem_modulus_of_integrand_product2 {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (_hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (_h_r_z_pos : 0 < r_z) ++ (_h_r_z_lt_r_int : r_z < r_int) ++ (_h_r_int_lt_R_analytic : r_int < R_analytic) : ++ norm (f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) = ++norm (f (r_int * Complex.exp (I * t))) * norm (r_int * Complex.exp (I * t)) := by ++ ++ rw [norm_mul] ++ ++lemma lem_modeit (t : ℝ) : norm (Complex.exp (I * t)) = Real.exp (Complex.re (I * t)) := by ++ ++ exact Complex.norm_exp (I * t) ++ ++lemma lem_Reit0 (t : ℝ) : Complex.re (I * t) = 0 := by ++ ++ unfold I ++ ++ rw [Complex.mul_re] ++ ++ rw [Complex.I_re, Complex.I_im, Complex.ofReal_re, Complex.ofReal_im] ++ ++ ring ++ ++lemma lem_eReite0 (t : ℝ) : Real.exp (Complex.re (I * t)) = Real.exp 0 := by ++ ++ rw [lem_Reit0] ++ ++lemma lem_e01 : Real.exp 0 = 1 := by ++ exact Real.exp_zero ++ ++lemma lem_eReit1 (t : ℝ) : Real.exp (Complex.re (I * t)) = 1 := by ++ ++ rw [lem_eReite0] ++ ++ rw [Real.exp_zero] ++ ++lemma lem_modulus_of_e_it_is_one (t : ℝ) : norm (Complex.exp (I * t)) = 1 := by ++ ++ rw [lem_modeit] ++ ++ rw [lem_Reit0] ++ ++ rw [lem_e01] ++ ++lemma lem_modulus_of_ae_it {a t : ℝ} (ha : 0 < a) : norm (a * Complex.exp (I * t)) = a := by ++ ++ rw [norm_mul, lem_modulus_of_e_it_is_one, mul_one, Complex.norm_real] ++ exact abs_of_pos ha ++ ++lemma lem_modulus_of_integrand_product3 {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) : ++norm (f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) = r_int * norm (f (r_int * Complex.exp (I * t))) := by ++ ++ rw [lem_modulus_of_integrand_product2 t hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic] ++ ++ have h_r_int_pos : 0 < r_int := lt_trans h_r_z_pos h_r_z_lt_r_int ++ rw [lem_modulus_of_ae_it h_r_int_pos] ++ ++ ring ++ ++lemma lem_modulus_of_square (c : ℂ) : norm (c ^ 2) = (norm c) ^ 2 := by ++ exact Complex.norm_pow c 2 ++ ++lemma lem_modulus_wz (w z : ℂ) : norm ((w - z) ^ 2) = (norm (w - z)) ^ 2 := by ++ ++ exact Complex.norm_pow (w - z) 2 ++ ++lemma lem_reverse_triangle (w z : ℂ) : norm w - norm z ≤ norm (w - z) := by ++ ++ exact norm_sub_norm_le w z ++ ++lemma lem_reverse_triangle2 {R_analytic r_z r_int : ℝ} {t : ℝ} {z : ℂ} ++ (_h_r_z_pos : 0 < r_z) ++ (_h_r_z_lt_r_int : r_z < r_int) ++ (_h_r_int_lt_R_analytic : r_int < R_analytic) : ++norm (r_int * Complex.exp (I * t)) - norm z ≤ norm (r_int * Complex.exp (I * t) - z) := by ++ ++ exact lem_reverse_triangle (r_int * Complex.exp (I * t)) z ++ ++lemma lem_reverse_triangle3 {R_analytic r_z r_int : ℝ} {t : ℝ} {z : ℂ} ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (_h_r_int_lt_R_analytic : r_int < R_analytic) : ++r_int - norm z ≤ norm (r_int * Complex.exp (I * t) - z) := by ++ ++ have h_mod : norm (r_int * Complex.exp (I * t)) = r_int := by ++ have h_r_int_pos : 0 < r_int := lt_trans h_r_z_pos h_r_z_lt_r_int ++ exact lem_modulus_of_ae_it h_r_int_pos ++ ++ have h_triangle := lem_reverse_triangle (r_int * Complex.exp (I * t)) z ++ ++ rw [h_mod] at h_triangle ++ exact h_triangle ++ ++lemma lem_zrr1 {R_analytic r_z r_int : ℝ} ++ (_h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (_h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++0 < r_int - norm z := by ++ ++ have h1 : dist z 0 ≤ r_z := Metric.mem_closedBall.mp hz ++ ++ have h2 : dist z 0 = ‖z‖ := by ++ rw [dist_eq_norm, sub_zero] ++ ++ have h3 : ‖z‖ ≤ r_z := by rwa [← h2] ++ ++ have h4 : norm z = ‖z‖ := rfl ++ ++ have h5 : norm z ≤ r_z := by rwa [h4] ++ ++ have h6 : norm z < r_int := lt_of_le_of_lt h5 h_r_z_lt_r_int ++ ++ linarith ++ ++lemma lem_zrr2 {R_analytic r_z r_int : ℝ} {t : ℝ} {z : ℂ} ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ (hz : z ∈ Metric.closedBall 0 r_z) : ++r_int - r_z ≤ norm (r_int * Complex.exp (I * t) - z) := by ++ ++ have h1 : norm z ≤ r_z := by ++ have h_dist : dist z 0 ≤ r_z := Metric.mem_closedBall.mp hz ++ rw [dist_eq_norm, sub_zero] at h_dist ++ exact h_dist ++ ++ have h2 : r_int - r_z ≤ r_int - norm z := by linarith [h1] ++ ++ have h3 := @lem_reverse_triangle3 R_analytic r_z r_int t z h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic ++ ++ exact le_trans h2 h3 ++ ++lemma lem_rr11 {r r' : ℝ} (_h_r_pos : 0 < r) (h_r_lt_r_prime : r < r') : r' - r > 0 := by ++ linarith ++ ++lemma lem_rr12 {r r' : ℝ} (h_r_pos : 0 < r) (h_r_lt_r_prime : r < r') : ++(r' - r) ^ 2 > 0 := by ++ ++ have h_diff_pos : r' - r > 0 := lem_rr11 h_r_pos h_r_lt_r_prime ++ ++ exact sq_pos_of_pos h_diff_pos ++ ++lemma lem_zrr3 {R_analytic r_z r_int : ℝ} {t : ℝ} {z : ℂ} ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ (hz : z ∈ Metric.closedBall 0 r_z) : ++(r_int - r_z) ^ 2 ≤ norm (r_int * Complex.exp (I * t) - z) ^ 2 := by ++ ++ have h_ineq := @lem_zrr2 R_analytic r_z r_int t z h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ have h_nonneg_left : 0 ≤ r_int - r_z := by linarith [h_r_z_lt_r_int] ++ have h_nonneg_right : 0 ≤ norm (r_int * Complex.exp (I * t) - z) := norm_nonneg _ ++ ++ have h_sq := mul_self_le_mul_self h_nonneg_left h_ineq ++ ++ rw [pow_two, pow_two] ++ exact h_sq ++ ++lemma lem_zrr4 {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (_h_r_z_pos : 0 < r_z) ++ (_h_r_z_lt_r_int : r_z < r_int) ++ (_h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (_hz : z ∈ Metric.closedBall 0 r_z) : ++norm ((r_int * Complex.exp (I * t) - z) ^ 2) = (norm (r_int * Complex.exp (I * t) - z)) ^ 2 := by ++ ++ exact lem_modulus_of_square (r_int * Complex.exp (I * t) - z) ++ ++lemma lem_reverse_triangle4 {R_analytic r_z r_int : ℝ} {t : ℝ} {z : ℂ} ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ (hz : z ∈ Metric.closedBall 0 r_z) : ++0 < norm (r_int * Complex.exp (I * t) - z) := by ++ ++ have h1 := lem_zrr1 h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ have h2 := @lem_reverse_triangle3 R_analytic r_z r_int t z h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic ++ ++ exact lt_of_lt_of_le h1 h2 ++ ++lemma lem_wposneq0 (w : ℂ) : norm w > 0 → w ≠ 0 := by ++ intro h ++ ++ by_contra h_eq_zero ++ ++ have h_abs_zero : norm w = 0 := by ++ rw [h_eq_zero] ++ simp ++ ++ rw [h_abs_zero] at h ++ exact lt_irrefl 0 h ++ ++lemma lem_reverse_triangle5 {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++r_int * Complex.exp (I * t) - z ≠ 0 := by ++ ++ have h_pos := @lem_reverse_triangle4 R_analytic r_z r_int t z h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ exact lem_wposneq0 (r_int * Complex.exp (I * t) - z) h_pos ++ ++lemma lem_reverse_triangle6 {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++(r_int * Complex.exp (I * t) - z) ^ 2 ≠ 0 := by ++ ++ have h_ne_zero := lem_reverse_triangle5 t h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ exact pow_ne_zero 2 h_ne_zero ++ ++lemma lem_absdiv {a b : ℂ} (_hb : b ≠ 0) : norm (a / b) = norm a / norm b := by ++ ++ exact norm_div a b ++ ++lemma lem_modulus_of_integrand_product {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (_hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ norm ((f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) = ++norm (f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / norm ((r_int * Complex.exp (I * t)) - z) ^ 2 := by ++ ++ have h_neq_zero : r_int * Complex.exp (I * t) - z ≠ 0 := ++ lem_reverse_triangle5 t h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ have h_sq_neq_zero : (r_int * Complex.exp (I * t) - z) ^ 2 ≠ 0 := by ++ rw [pow_two] ++ exact mul_self_ne_zero.mpr h_neq_zero ++ ++ rw [lem_absdiv h_sq_neq_zero] ++ ++ rw [lem_modulus_wz] ++ ++lemma lem_modulus_of_product {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ norm ((f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) = ++(r_int * norm (f (r_int * Complex.exp (I * t)))) / norm ((r_int * Complex.exp (I * t)) - z) ^ 2 := by ++ ++ rw [lem_modulus_of_integrand_product t hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz] ++ ++ rw [lem_modulus_of_integrand_product3 t hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic] ++ ++lemma lem_modulus_of_product2 {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ norm ((f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) = ++(r_int * norm (f (r_int * Complex.exp (I * t)))) / ((norm (r_int * Complex.exp (I * t) - z)) ^ 2) := by ++ ++ rw [lem_modulus_of_integrand_product t hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz] ++ ++ rw [lem_modulus_of_integrand_product3 t hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic] ++ ++lemma lem_modulus_of_product3 {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (_hf : DifferentiableOn ℂ f (Metric.closedBall 0 R_analytic)) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ (r_int * norm (f (r_int * Complex.exp (I * t)))) / ((norm (r_int * Complex.exp (I * t) - z)) ^ 2) ≤ ++(r_int * norm (f (r_int * Complex.exp (I * t)))) / ((r_int - r_z) ^ 2) := by ++ ++ have h_ineq := @lem_zrr3 R_analytic r_z r_int t z h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ have h_numer_nonneg : 0 ≤ r_int * norm (f (r_int * Complex.exp (I * t))) := by ++ apply mul_nonneg ++ · linarith [h_r_z_pos, h_r_z_lt_r_int] ++ · exact norm_nonneg _ ++ ++ have h_denom1_pos : 0 < (norm (r_int * Complex.exp (I * t) - z)) ^ 2 := by ++ apply pow_pos ++ exact lem_reverse_triangle4 h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ have h_denom2_pos : 0 < (r_int - r_z) ^ 2 := by ++ exact lem_rr12 h_r_z_pos h_r_z_lt_r_int ++ ++ exact div_le_div_of_nonneg_left h_numer_nonneg h_denom2_pos h_ineq ++ ++lemma lem_modulus_of_product4 {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} (t : ℝ) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++ norm ((f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) ≤ ++(r_int * norm (f (r_int * Complex.exp (I * t)))) / ((r_int - r_z) ^ 2) := by ++ ++ rw [lem_modulus_of_product t hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz] ++ ++ have h_ineq := @lem_zrr3 R_analytic r_z r_int t z h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ apply div_le_div_of_nonneg_left ++ · ++ apply mul_nonneg ++ · linarith [h_r_z_pos, h_r_z_lt_r_int] ++ · exact norm_nonneg _ ++ · ++ apply pow_pos ++ linarith [h_r_z_lt_r_int] ++ · ++ exact h_ineq ++ ++lemma lem_bound_on_f_at_r_prime {M R_analytic r_int : ℝ} ++ (hM_pos : 0 < M) ++ (hR_analytic_pos : 0 < R_analytic) ++ (hr_int_pos : 0 < r_int) ++ (hr_int_lt_R_analytic : r_int < R_analytic) ++ (f : ℂ → ℂ) ++ ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (hf0 : f 0 = 0) ++ (hRe_f_le_M : ∀ z ∈ Metric.closedBall 0 R_analytic, (f z).re ≤ M) ++ (t : ℝ) : ++norm (f (r_int * Complex.exp (I * t))) ≤ (2 * r_int * M) / (R_analytic - r_int) := by ++ ++ obtain ⟨U, hU_open, h_subset, hf_diff_U⟩ := hf_domain ++ ++ let z₀ := r_int * Complex.exp (I * t) ++ ++ have h_sSup_bound := thm_BorelCaratheodoryI R_analytic M hR_analytic_pos hM_pos f ++ ++ (by ++ ++ have h_analytic_U : AnalyticOn ℂ f U := hf_diff_U.analyticOn hU_open ++ ++ rw [ballDR] ++ convert h_analytic_U.mono h_subset ++ ++ apply closure_ball ++ linarith ++ ) ++ hf0 ++ (by rwa [lem_ballDR R_analytic hR_analytic_pos]) ++ r_int hr_int_pos hr_int_lt_R_analytic ++ ++ have hz₀_in_ball : z₀ ∈ Metric.closedBall 0 r_int := by ++ rw [Metric.mem_closedBall] ++ simp only [dist_eq_norm, sub_zero] ++ ++ have h_norm : ‖r_int * Complex.exp (I * t)‖ = r_int := by ++ rw [norm_mul] ++ ++ have h1 : ‖(r_int : ℂ)‖ = r_int := by ++ rw [Complex.norm_real] ++ exact abs_of_pos hr_int_pos ++ ++ have h2 : ‖Complex.exp (I * ↑t)‖ = 1 := by ++ ++ exact lem_modulus_of_e_it_is_one t ++ rw [h1, h2] ++ ring ++ rw [h_norm] ++ ++ have hz₀_in_closure : z₀ ∈ closure (ballDR r_int) := by ++ rw [lem_ballDR r_int hr_int_pos] ++ exact hz₀_in_ball ++ ++ have h_in_image : norm (f z₀) ∈ (norm ∘ f) '' (closure (ballDR r_int)) := by ++ use z₀, hz₀_in_closure ++ rfl ++ ++ have h_le_sSup : norm (f z₀) ≤ sSup ((norm ∘ f) '' (closure (ballDR r_int))) := by ++ apply le_csSup ++ ++ · use (2 * r_int / (R_analytic - r_int)) * M ++ intros x hx ++ obtain ⟨w, hw_in, hx_eq⟩ := hx ++ rw [← hx_eq] ++ ++ have hw_in_closed : w ∈ Metric.closedBall 0 r_int := by ++ rwa [← lem_ballDR r_int hr_int_pos] ++ ++ have hw_in_R : w ∈ Metric.closedBall 0 R_analytic := by ++ have h_subset : Metric.closedBall (0 : ℂ) r_int ⊆ Metric.closedBall 0 R_analytic := by ++ apply Metric.closedBall_subset_closedBall ++ linarith [hr_int_lt_R_analytic] ++ exact h_subset hw_in_closed ++ ++ exact lem_BCI R_analytic M hR_analytic_pos hM_pos f ++ (by ++ rw [ballDR] ++ have h_analytic_U : AnalyticOn ℂ f U := hf_diff_U.analyticOn hU_open ++ convert h_analytic_U.mono h_subset ++ apply closure_ball ++ linarith) ++ hf0 ++ (by rwa [lem_ballDR R_analytic hR_analytic_pos]) ++ r_int hr_int_pos hr_int_lt_R_analytic w ++ (by aesop) ++ ++ · exact h_in_image ++ ++ calc norm (f z₀) ++ ≤ sSup ((norm ∘ f) '' (closure (ballDR r_int))) := h_le_sSup ++ _ ≤ (2 * r_int / (R_analytic - r_int)) * M := h_sSup_bound ++ _ = (2 * r_int * M) / (R_analytic - r_int) := by ring ++ ++lemma lem_bound_on_integrand_modulus {f : ℂ → ℂ} {M R_analytic r_z r_int : ℝ} ++ (hM_pos : 0 < M) ++ (hR_analytic_pos : 0 < R_analytic) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (hf0 : f 0 = 0) ++ (hRe_f_le_M : ∀ w ∈ Metric.closedBall 0 R_analytic, (f w).re ≤ M) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) ++ (t : ℝ) : ++norm ((f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) ≤ (2 * r_int ^ 2 * M) / ((R_analytic - r_int) * (r_int - r_z) ^ 2) := by ++ ++ have h1 := lem_modulus_of_product4 t hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ have h2 := lem_bound_on_f_at_r_prime hM_pos hR_analytic_pos (lt_trans h_r_z_pos h_r_z_lt_r_int) h_r_int_lt_R_analytic f hf_domain hf0 hRe_f_le_M t ++ ++ have h_r_int_pos : 0 < r_int := lt_trans h_r_z_pos h_r_z_lt_r_int ++ have h_denom_nonneg : 0 ≤ (r_int - r_z) ^ 2 := by ++ apply sq_nonneg ++ ++ have h3 : (r_int * norm (f (r_int * Complex.exp (I * t)))) / (r_int - r_z) ^ 2 ≤ ++ (r_int * (2 * r_int * M / (R_analytic - r_int))) / (r_int - r_z) ^ 2 := by ++ apply div_le_div_of_nonneg_right _ h_denom_nonneg ++ apply mul_le_mul_of_nonneg_left h2 ++ linarith [h_r_int_pos] ++ ++ have h4 : (r_int * (2 * r_int * M / (R_analytic - r_int))) / (r_int - r_z) ^ 2 = ++ (2 * r_int ^ 2 * M) / ((R_analytic - r_int) * (r_int - r_z) ^ 2) := by ++ have h_R_sub_r_pos : 0 < R_analytic - r_int := by linarith [h_r_int_lt_R_analytic] ++ have h_r_sub_r_pos : 0 < r_int - r_z := by linarith [h_r_z_lt_r_int] ++ field_simp [ne_of_gt h_R_sub_r_pos, ne_of_gt (pow_pos h_r_sub_r_pos 2)] ++ ++ rw [h4] at h3 ++ exact le_trans h1 h3 ++ ++lemma lem_integral_inequality_aux {g : ℝ → ℝ} {C a b : ℝ} (hab : a ≤ b) ++ (h_integrable : IntervalIntegrable g MeasureTheory.volume a b) ++ (h_bound : ∀ t ∈ Set.Icc a b, g t ≤ C) : ++∫ t in a..b, g t ≤ ∫ _t in a..b, C := by ++ ++ have h_const_integrable : IntervalIntegrable (fun _ => C) MeasureTheory.volume a b := ++ intervalIntegrable_const ++ ++ have h_pointwise : ∀ x ∈ Set.Icc a b, g x ≤ (fun _ => C) x := by ++ intro x hx ++ simp ++ exact h_bound x hx ++ ++ exact intervalIntegral.integral_mono_on hab h_integrable h_const_integrable h_pointwise ++ ++lemma lem_integral_inequality {g : ℝ → ℝ} {C a b : ℝ} (hab : a ≤ b) ++ (h_integrable : IntervalIntegrable g MeasureTheory.volume a b) ++ (h_bound : ∀ t ∈ Set.Icc a b, g t ≤ C) : ++∫ t in Set.Icc a b, g t ≤ ∫ _t in Set.Icc a b, C := by ++ rw [MeasureTheory.integral_Icc_eq_integral_Ioc, MeasureTheory.integral_Icc_eq_integral_Ioc] ++ rw [← intervalIntegral.integral_of_le hab, ← intervalIntegral.integral_of_le hab] ++ exact lem_integral_inequality_aux hab h_integrable h_bound ++ ++lemma continuous_real_parameterization (r : ℝ) : Continuous (fun t : ℝ => r * Complex.exp (I * t)) := by ++ ++ have h1 : Continuous (fun t : ℝ => (t : ℂ)) := Complex.continuous_ofReal ++ ++ have h2 : Continuous (fun z : ℂ => I * z) := by ++ apply Continuous.mul ++ · exact continuous_const ++ · exact continuous_id ++ ++ have h3 : Continuous Complex.exp := Complex.continuous_exp ++ ++ have h4 : Continuous (fun z : ℂ => (r : ℂ) * z) := by ++ apply Continuous.mul ++ · exact continuous_const ++ · exact continuous_id ++ ++ apply Continuous.comp h4 ++ apply Continuous.comp h3 ++ apply Continuous.comp h2 ++ exact h1 ++ ++lemma continuous_f_parameterized {f : ℂ → ℂ} {R r : ℝ} (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R ⊆ U ∧ DifferentiableOn ℂ f U) ++ (hr_pos : 0 < r) (hr_lt_R : r < R) : Continuous (fun t : ℝ => f (r * Complex.exp (I * t))) := by ++ ++ obtain ⟨U', hU'_open, h_subset, hf_diff_U'⟩ := hf_domain ++ have hf_cont : ContinuousOn f (Metric.closedBall 0 R) := by ++ ++ have hf_on_closed : DifferentiableOn ℂ f (Metric.closedBall 0 R) := ++ hf_diff_U'.mono h_subset ++ ++ exact DifferentiableOn.continuousOn hf_on_closed ++ ++ have hparam_cont : Continuous (fun t : ℝ => r * Complex.exp (I * t)) := continuous_real_parameterization r ++ ++ have hparam_range : ∀ t : ℝ, r * Complex.exp (I * t) ∈ Metric.closedBall 0 R := by ++ intro t ++ rw [Metric.mem_closedBall, dist_zero_right] ++ ++ change norm (r * Complex.exp (I * t)) ≤ R ++ rw [lem_modulus_of_ae_it hr_pos] ++ exact le_of_lt hr_lt_R ++ ++ have hcomp_on : ContinuousOn (fun t : ℝ => f (r * Complex.exp (I * t))) Set.univ := by ++ apply ContinuousOn.comp hf_cont (Continuous.continuousOn hparam_cont) ++ intro t _ ++ exact hparam_range t ++ ++ exact continuousOn_univ.mp hcomp_on ++ ++lemma continuous_denominator_parameterized (r : ℝ) (z : ℂ) : Continuous (fun t : ℝ => (r * Complex.exp (I * t) - z) ^ 2) := by ++ ++ have h1 : Continuous (fun t : ℝ => r * Complex.exp (I * t) - z) := by ++ ++ apply Continuous.sub ++ · ++ exact continuous_real_parameterization r ++ · ++ exact continuous_const ++ ++ have h2 : Continuous (fun x : ℂ => x ^ 2) := continuous_pow 2 ++ ++ exact Continuous.comp h2 h1 ++ ++lemma interval_integrable_cauchy_integrand {f : ℂ → ℂ} {R_analytic r_z r_int : ℝ} {z : ℂ} ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ (hz : z ∈ Metric.closedBall 0 r_z) : ++IntervalIntegrable (fun t => norm ((r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2)) MeasureTheory.volume 0 (2 * Real.pi) := by ++ ++ apply Continuous.intervalIntegrable ++ ++ apply Continuous.comp continuous_norm ++ ++ apply Continuous.div₀ ++ ++ · apply Continuous.mul ++ ++ · exact continuous_real_parameterization r_int ++ ++ · have h_r_int_pos : 0 < r_int := lt_trans h_r_z_pos h_r_z_lt_r_int ++ exact continuous_f_parameterized hf_domain h_r_int_pos h_r_int_lt_R_analytic ++ ++ · exact continuous_denominator_parameterized r_int z ++ ++ · intro t ++ exact lem_reverse_triangle6 t h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++lemma integral_const_over_interval (C : ℝ) : ++∫ _t in Set.Icc 0 (2 * Real.pi), C = (2 * Real.pi) * C := by ++ ++ rw [MeasureTheory.integral_Icc_eq_integral_Ioc] ++ ++ have h_le : (0 : ℝ) ≤ 2 * Real.pi := by ++ apply mul_nonneg ++ · norm_num ++ · exact Real.pi_pos.le ++ rw [← intervalIntegral.integral_of_le h_le] ++ ++ rw [intervalIntegral.integral_const] ++ ++ simp [sub_zero, smul_eq_mul] ++ ++lemma lem_f_prime_bound_by_integral_of_constant {f : ℂ → ℂ} {M R_analytic r_z r_int : ℝ} ++ (hM_pos : 0 < M) ++ (hR_analytic_pos : 0 < R_analytic) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (hf0 : f 0 = 0) ++ (hRe_f_le_M : ∀ w ∈ Metric.closedBall 0 R_analytic, (f w).re ≤ M) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++norm (deriv f z) ≤ (2 * r_int ^ 2 * M) / ((R_analytic - r_int) * (r_int - r_z) ^ 2) := by ++ ++ have h1 := lem_modulus_of_f_prime hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ set C := (2 * r_int ^ 2 * M) / ((R_analytic - r_int) * (r_int - r_z) ^ 2) ++ ++ have h_bound : ∀ t ∈ Set.Icc 0 (2 * Real.pi), ++ norm ((f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) ≤ C := by ++ intro t ht ++ exact lem_bound_on_integrand_modulus hM_pos hR_analytic_pos h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hf_domain hf0 hRe_f_le_M hz t ++ ++ have h_eq : ∀ t, norm ((r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) = ++ norm ((f (r_int * Complex.exp (I * t)) * (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) := by ++ intro t ++ congr 2 ++ ring ++ ++ have h_bound_h1 : ∀ t ∈ Set.Icc 0 (2 * Real.pi), ++ norm ((r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2) ≤ C := by ++ intro t ht ++ rw [h_eq] ++ exact h_bound t ht ++ ++ have h_integrable : IntervalIntegrable (fun t => norm ((r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2)) MeasureTheory.volume 0 (2 * Real.pi) := by ++ ++ exact interval_integrable_cauchy_integrand hf_domain h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hz ++ ++ have h2 := lem_integral_inequality ?_ h_integrable h_bound_h1 ++ ++ have h_const_integral : ∫ t in Set.Icc 0 (2 * Real.pi), C = (2 * Real.pi) * C := by ++ ++ exact integral_const_over_interval C ++ ++ rw [h_const_integral] at h2 ++ ++ have h3 : (1 / (2 * Real.pi)) * (∫ (t : ℝ) in Set.Icc 0 (2 * Real.pi), ++ norm ((r_int * Complex.exp (I * t) * f (r_int * Complex.exp (I * t))) / ((r_int * Complex.exp (I * t)) - z) ^ 2)) ≤ ++ (1 / (2 * Real.pi)) * (2 * Real.pi * C) := by ++ apply mul_le_mul_of_nonneg_left h2 ++ apply div_nonneg ++ · norm_num ++ · linarith [Real.pi_pos] ++ ++ have h4 : (1 / (2 * Real.pi)) * (2 * Real.pi * C) = C := by ++ have h_pi_ne_zero : (2 : ℝ) * Real.pi ≠ 0 := ne_of_gt (by linarith [Real.pi_pos]) ++ field_simp [h_pi_ne_zero] ++ ++ rw [h4] at h3 ++ exact le_trans h1 h3 ++ simp [Real.pi_nonneg] ++ ++lemma lem_integral_of_1 : ∫ (_t : ℝ) in Set.Icc 0 (2 * Real.pi), (1 : ℝ) = 2 * Real.pi := by ++ ++ rw [MeasureTheory.integral_Icc_eq_integral_Ioc] ++ ++ rw [← intervalIntegral.integral_of_le] ++ ++ rw [integral_one] ++ ++ simp ++ ++ exact mul_nonneg (by norm_num) Real.pi_pos.le ++ ++lemma lem_integral_2 : (1 / (2 * Real.pi)) * (∫ (_t : ℝ) in Set.Icc 0 (2 * Real.pi), (1 : ℝ)) = 1 := by ++ ++ rw [lem_integral_of_1] ++ ++ field_simp ++ ++lemma lem_f_prime_bound {f : ℂ → ℂ} {M R_analytic r_z r_int : ℝ} ++ (hM_pos : 0 < M) ++ (hR_analytic_pos : 0 < R_analytic) ++ (h_r_z_pos : 0 < r_z) ++ (h_r_z_lt_r_int : r_z < r_int) ++ (h_r_int_lt_R_analytic : r_int < R_analytic) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R_analytic ⊆ U ∧ DifferentiableOn ℂ f U) ++ (hf0 : f 0 = 0) ++ (hRe_f_le_M : ∀ w ∈ Metric.closedBall 0 R_analytic, (f w).re ≤ M) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r_z) : ++norm (deriv f z) ≤ (2 * r_int ^ 2 * M) / ((R_analytic - r_int) * (r_int - r_z) ^ 2) := by ++ ++ exact lem_f_prime_bound_by_integral_of_constant hM_pos hR_analytic_pos h_r_z_pos h_r_z_lt_r_int h_r_int_lt_R_analytic hf_domain hf0 hRe_f_le_M hz ++ ++lemma lem_r_prime_gt_r {r R : ℝ} ++ (_h_r_pos : 0 < r) ++ (h_r_lt_R : r < R) : ++r < (r + R) / 2 := by ++ linarith ++ ++lemma lem_r_prime_lt_R {r R : ℝ} ++ (_h_r_pos : 0 < r) ++ (h_r_lt_R : r < R) : ++(r + R) / 2 < R := by ++ ++ rw [add_div_two_lt_right] ++ exact h_r_lt_R ++ ++lemma lem_r_prime_is_intermediate {r R : ℝ} ++ (h_r_pos : 0 < r) ++ (h_r_lt_R : r < R) : ++r < (r + R) / 2 ∧ (r + R) / 2 < R := by ++ constructor ++ · ++ rw [left_lt_add_div_two] ++ exact h_r_lt_R ++ · ++ exact lem_r_prime_lt_R h_r_pos h_r_lt_R ++ ++lemma lem_calc_R_minus_r_prime {r R : ℝ} ++ (_h_r_pos : 0 < r) ++ (_h_r_lt_R : r < R) : ++R - ((r + R) / 2) = (R - r) / 2 := by ++ field_simp; ring ++ ++lemma lem_calc_r_prime_minus_r {r R : ℝ} ++ (_h_r_pos : 0 < r) ++ (_h_r_lt_R : r < R) : ++((r + R) / 2) - r = (R - r) / 2 := by ++ ++ field_simp ++ ++ ring ++ ++lemma lem_calc_denominator_specific {r R : ℝ} ++ (h_r_pos : 0 < r) ++ (h_r_lt_R : r < R) : ++(R - ((r + R) / 2)) * (((r + R) / 2) - r) ^ 2 = ((R - r) ^ 3) / 8 := by ++ ++ rw [lem_calc_R_minus_r_prime h_r_pos h_r_lt_R] ++ ++ have h_calc : ((r + R) / 2) - r = (R - r) / 2 := by ++ field_simp; ring ++ ++ rw [h_calc] ++ ++ ring ++ ++lemma lem_calc_numerator_specific {M r R : ℝ} ++ (_hM_pos : 0 < M) ++ (_hr_pos : 0 < r) ++ (_hr_lt_R : r < R) : ++2 * (((r + R) / 2) ^ 2) * M = ((R + r) ^ 2 * M) / 2 := by ++ ++ ring ++ ++lemma lem_frac_simplify {M r R : ℝ} ++ (hM_pos : 0 < M) ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++ let r_prime := (r + R) / 2 ++(2 * (r_prime ^ 2) * M) / ((R - r_prime) * (r_prime - r) ^ 2) = (((R + r) ^ 2 * M) / 2) / (((R - r) ^ 3) / 8) := by ++ ++ dsimp only ++ ++ have h_num := lem_calc_numerator_specific hM_pos hr_pos hr_lt_R ++ ++ have h_denom := lem_calc_denominator_specific hr_pos hr_lt_R ++ ++ rw [← h_num, ← h_denom] ++ ++lemma lem_frac_simplify2 {M r R : ℝ} ++ (hM_pos : 0 < M) ++ (_hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++((R + r) ^ 2 * M / 2) / ((R - r) ^ 3 / 8) = (4 * (R + r) ^ 2 * M) / ((R - r) ^ 3) := by ++ ++ have h_two_ne_zero : (2 : ℝ) ≠ 0 := by norm_num ++ have h_eight_ne_zero : (8 : ℝ) ≠ 0 := by norm_num ++ have h_R_minus_r_ne_zero : R - r ≠ 0 := by linarith [hr_lt_R] ++ have h_R_minus_r_pow_ne_zero : (R - r) ^ 3 ≠ 0 := by ++ apply pow_ne_zero ++ exact h_R_minus_r_ne_zero ++ ++ field_simp [h_two_ne_zero, h_eight_ne_zero, h_R_minus_r_pow_ne_zero]; ring ++ ++lemma lem_frac_simplify3 {M r R : ℝ} ++ (hM_pos : 0 < M) ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++ let r_prime := (r + R) / 2 ++(2 * (r_prime ^ 2) * M) / ((R - r_prime) * (r_prime - r) ^ 2) = (4 * (R + r) ^ 2 * M) / ((R - r) ^ 3) := by ++ ++ dsimp only ++ ++ have h1 := lem_frac_simplify hM_pos hr_pos hr_lt_R ++ ++ have h2 := lem_frac_simplify2 hM_pos hr_pos hr_lt_R ++ ++ rw [h1, h2] ++ ++lemma lem_ineq_R_plus_r_lt_2R {r R : ℝ} (h_r_lt_R : r < R) : ++R + r < 2 * R := by ++ ++ rw [two_mul] ++ ++ linarith [h_r_lt_R] ++ ++lemma lem_R_plus_r_is_positive {r R : ℝ} ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++0 < R + r := by ++ ++ have hR_pos : 0 < R := lt_trans hr_pos hr_lt_R ++ ++ exact add_pos hR_pos hr_pos ++ ++lemma lem_2R_is_positive {R : ℝ} (hR_pos : 0 < R) : 0 < 2 * R := by ++ apply mul_pos ++ · norm_num ++ · exact hR_pos ++ ++lemma lem_square_inequality_strict {a b : ℝ} ++ (h_a_pos : 0 < a) ++ (h_a_lt_b : a < b) : ++a ^ 2 < b ^ 2 := by ++ ++ have h_a_nonneg : 0 ≤ a := le_of_lt h_a_pos ++ ++ have h_b_pos : 0 < b := lt_trans h_a_pos h_a_lt_b ++ have h_b_nonneg : 0 ≤ b := le_of_lt h_b_pos ++ ++ have h_squares := mul_self_lt_mul_self_iff h_a_nonneg h_b_nonneg ++ ++ have h_mult : a * a < b * b := h_squares.mp h_a_lt_b ++ ++ rw [← pow_two, ← pow_two] at h_mult ++ exact h_mult ++ ++lemma lem_ineq_R_plus_r_sq_lt_2R_sq {r R : ℝ} ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++(R + r) ^ 2 < (2 * R) ^ 2 := by ++ ++ let a := R + r ++ let b := 2 * R ++ ++ have ha_pos : 0 < a := lem_R_plus_r_is_positive hr_pos hr_lt_R ++ ++ have hR_pos : 0 < R := lt_trans hr_pos hr_lt_R ++ have hb_pos : 0 < b := by ++ unfold b ++ exact lem_2R_is_positive hR_pos ++ ++ have hab : a < b := by ++ unfold a b ++ exact lem_ineq_R_plus_r_lt_2R hr_lt_R ++ ++ have : a ^ 2 < b ^ 2 := lem_square_inequality_strict ha_pos hab ++ ++ unfold a b at this ++ exact this ++ ++lemma lem_2R_sq_is_4R_sq {R : ℝ} (_hR_pos : 0 < R) : (2 * R) ^ 2 = 4 * R ^ 2 := by ++ ++ ring ++ ++lemma lem_ineq_R_plus_r_sq {r R : ℝ} ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++(R + r) ^ 2 < 4 * R ^ 2 := by ++ ++ have h1 := lem_ineq_R_plus_r_lt_2R hr_lt_R ++ ++ have h2 := lem_R_plus_r_is_positive hr_pos hr_lt_R ++ ++ have h3 := lem_square_inequality_strict h2 h1 ++ ++ have hR_pos : 0 < R := lt_trans hr_pos hr_lt_R ++ have h4 := lem_2R_sq_is_4R_sq hR_pos ++ rw [h4] at h3 ++ exact h3 ++ ++lemma lem_ineq_R_plus_r_sqM {M r R : ℝ} ++ (hM_pos : 0 < M) ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++4 * (R + r) ^ 2 * M < 16 * R ^ 2 * M := by ++ ++ have h_ineq := lem_ineq_R_plus_r_sq hr_pos hr_lt_R ++ ++ have h_4M_pos : 0 < 4 * M := by ++ apply mul_pos ++ · norm_num ++ · exact hM_pos ++ ++ have h_mult := mul_lt_mul_of_pos_right h_ineq h_4M_pos ++ ++ nlinarith [h_mult] ++ ++lemma lem_simplify_final_bound {M r R : ℝ} ++ (hM_pos : 0 < M) ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++(4 * (R + r) ^ 2 * M) / ((R - r) ^ 3) < (16 * R ^ 2 * M) / ((R - r) ^ 3) := by ++ ++ have h_num_ineq := lem_ineq_R_plus_r_sqM hM_pos hr_pos hr_lt_R ++ ++ have h_denom_pos : 0 < (R - r) ^ 3 := by ++ apply pow_pos ++ linarith [hr_lt_R] ++ ++ exact div_lt_div_of_pos_right h_num_ineq h_denom_pos ++ ++lemma lem_bound_after_substitution {M r R : ℝ} ++ (hM_pos : 0 < M) ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) : ++ let r_prime := (r + R) / 2 ++(2 * (r_prime ^ 2) * M) / ((R - r_prime) * (r_prime - r) ^ 2) ≤ (16 * R ^ 2 * M) / ((R - r) ^ 3) := by ++ ++ dsimp only ++ ++ have h1 := lem_frac_simplify3 hM_pos hr_pos hr_lt_R ++ ++ dsimp only at h1 ++ rw [h1] ++ ++ have h2 := lem_simplify_final_bound hM_pos hr_pos hr_lt_R ++ ++ exact le_of_lt h2 ++ ++theorem borel_caratheodory_II {f : ℂ → ℂ} {R M r : ℝ} ++ (hR_pos : 0 < R) ++ (hM_pos : 0 < M) ++ (hr_pos : 0 < r) ++ (hr_lt_R : r < R) ++ (hf_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 R ⊆ U ∧ DifferentiableOn ℂ f U) ++ (hf0 : f 0 = 0) ++ (hRe_f_le_M : ∀ w ∈ Metric.closedBall 0 R, (f w).re ≤ M) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r) : ++norm (deriv f z) ≤ (16 * M * R ^ 2) / ((R - r) ^ 3) := by ++ ++ set r_prime := (r + R) / 2 ++ ++ have h_intermediate := lem_r_prime_is_intermediate hr_pos hr_lt_R ++ have h_r_lt_r_prime := h_intermediate.1 ++ have h_r_prime_lt_R := h_intermediate.2 ++ ++ have h_bound := lem_f_prime_bound hM_pos hR_pos hr_pos h_r_lt_r_prime h_r_prime_lt_R hf_domain hf0 hRe_f_le_M hz ++ ++ have h_final := lem_bound_after_substitution hM_pos hr_pos hr_lt_R ++ ++ have h_combined : norm (deriv f z) ≤ (16 * R ^ 2 * M) / ((R - r) ^ 3) := by ++ exact le_trans h_bound h_final ++ ++ convert h_combined using 1 ++ ring ++ ++open Complex MeasureTheory intervalIntegral ++open scoped Interval ++ ++noncomputable def If_taxicab ++ {r1 R R0: ℝ} ++ (_hr1_pos : 0 < r1) (_hr1_lt_R : r1 < R) (_hR_lt_R0 : R < R0) (_hR0_lt_one : R0 < 1) ++ (f : ℂ → ℂ) ++ (_hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) : ++ (Metric.closedBall (0 : ℂ) r1) → ℂ := ++ fun z => ++ (∫ t in (0 : ℝ)..z.1.re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.1.im, f ((z.1.re : ℂ) + Complex.I * τ)) ++ ++lemma def_If_z_plus_h ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (_hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) : ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ = (∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..(z + h).im, f (( (z + h).re : ℂ) + Complex.I * τ)) := by ++ rfl ++ ++lemma def_If_z ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) : ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩ ++ = (∫ t in (0 : ℝ)..z.re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, f ((z.re : ℂ) + Complex.I * τ)) := by ++ rfl ++ ++lemma def_If_w ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (_hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (_hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ let w : ℂ := ((z + h).re : ℂ) + Complex.I * z.im ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ ++ = (∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, f (((z + h).re : ℂ) + Complex.I * τ)) := by ++ simp [If_taxicab] ++ ++lemma continuous_vertical_line (a : ℂ) : ++ Continuous (fun τ : ℝ => ((a.re : ℂ) + Complex.I * (τ : ℂ))) := by ++ have hconst : Continuous (fun _ : ℝ => (a.re : ℂ)) := continuous_const ++ have hmul : Continuous (fun τ : ℝ => (Complex.I : ℂ) * (τ : ℂ)) := ++ continuous_const.mul Complex.continuous_ofReal ++ convert hconst.add hmul using 1 ++ ++lemma norm_re_add_I_mul_le_norm (a : ℂ) {τ : ℝ} (hτ : |τ| ≤ |a.im|) : ++ ‖((a.re : ℂ) + Complex.I * (τ : ℂ))‖ ≤ ‖a‖ := by ++ ++ set z1 : ℂ := ((a.re : ℂ) + Complex.I * (τ : ℂ)) with hz1 ++ ++ have hsq_z1 : ‖z1‖ ^ 2 = z1.re ^ 2 + z1.im ^ 2 := by ++ have hx : ‖z1‖ ^ 2 - z1.re ^ 2 = z1.im ^ 2 := Complex.sq_norm_sub_sq_re z1 ++ have hx' := congrArg (fun t : ℝ => t + z1.re ^ 2) hx ++ ++ have : ‖z1‖ ^ 2 = z1.im ^ 2 + z1.re ^ 2 := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using hx' ++ simpa [add_comm] using this ++ have hsq_a : ‖a‖ ^ 2 = a.re ^ 2 + a.im ^ 2 := by ++ have hx : ‖a‖ ^ 2 - a.re ^ 2 = a.im ^ 2 := Complex.sq_norm_sub_sq_re a ++ have hx' := congrArg (fun t : ℝ => t + a.re ^ 2) hx ++ have : ‖a‖ ^ 2 = a.im ^ 2 + a.re ^ 2 := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using hx' ++ simpa [add_comm] using this ++ ++ have hz1_re : z1.re = a.re := by ++ simp [hz1, mul_comm] ++ have hz1_im : z1.im = τ := by ++ simp [hz1, mul_comm] ++ ++ have hτ_sq : τ ^ 2 ≤ a.im ^ 2 := by ++ simpa using (sq_le_sq.mpr hτ) ++ ++ have hsq_le : ‖z1‖ ^ 2 ≤ ‖a‖ ^ 2 := by ++ have : a.re ^ 2 + τ ^ 2 ≤ a.re ^ 2 + a.im ^ 2 := add_le_add_right hτ_sq _ ++ simpa [hsq_z1, hz1_re, hz1_im, hsq_a] using this ++ ++ have hnonneg : 0 ≤ ‖a‖ := norm_nonneg _ ++ exact le_of_sq_le_sq hsq_le hnonneg ++ ++lemma closedBall_mono_center0 {r1 R : ℝ} (h : r1 ≤ R) : ++ Metric.closedBall (0 : ℂ) r1 ⊆ Metric.closedBall (0 : ℂ) R := by ++ intro z hz ++ have hz' : dist z (0 : ℂ) ≤ r1 := (Metric.mem_closedBall.mp hz) ++ exact Metric.mem_closedBall.mpr (le_trans hz' h) ++ ++lemma abs_le_abs_of_mem_uIcc_zero {b t : ℝ} (ht : t ∈ Set.uIcc (0 : ℝ) b) : |t| ≤ |b| := by ++ classical ++ by_cases hb : 0 ≤ b ++ · ++ have ht' : t ∈ Set.Icc (0 : ℝ) b := by ++ simpa [Set.uIcc_of_le hb] using ht ++ have ht0 : 0 ≤ t := ht'.1 ++ have htb : t ≤ b := ht'.2 ++ have htabs : |t| = t := abs_of_nonneg ht0 ++ have hbabs : |b| = b := abs_of_nonneg hb ++ simpa [htabs, hbabs] using htb ++ · ++ have ht' : t ∈ Set.Icc b 0 := by ++ simpa [Set.uIcc_of_not_le hb] using ht ++ have hb_le : b ≤ 0 := le_trans ht'.1 ht'.2 ++ have ht_le0 : t ≤ 0 := ht'.2 ++ have hbabs : |b| = -b := abs_of_nonpos hb_le ++ have htabs : |t| = -t := abs_of_nonpos ht_le0 ++ have hneg : -t ≤ -b := neg_le_neg ht'.1 ++ simpa [htabs, hbabs] using hneg ++ ++lemma vertical_intervalIntegrable_of_mem_ball ++ {r1 R R0 : ℝ} ++ (_hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (_hR_lt_R0 : R < R0) (_hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {a : ℂ} ++ (ha : a ∈ Metric.closedBall (0 : ℂ) r1) : ++ IntervalIntegrable (fun τ : ℝ => f (((a.re : ℂ)) + Complex.I * τ)) volume (0 : ℝ) a.im := by ++ classical ++ ++ have hf_cont : ContinuousOn f (Metric.closedBall (0 : ℂ) R) := hf.continuousOn ++ ++ let g : ℝ → ℂ := fun τ => ((a.re : ℂ) + Complex.I * (τ : ℂ)) ++ ++ have hg_cont : ContinuousOn g (Set.uIcc (0 : ℝ) a.im) := by ++ simpa [g] using (continuous_vertical_line a).continuousOn ++ ++ have hg_maps : Set.MapsTo g (Set.uIcc (0 : ℝ) a.im) (Metric.closedBall (0 : ℂ) R) := by ++ intro τ hτ ++ have hτabs : |τ| ≤ |a.im| := abs_le_abs_of_mem_uIcc_zero hτ ++ have hnorm_le_a : ‖g τ‖ ≤ ‖a‖ := by ++ simpa [g] using norm_re_add_I_mul_le_norm a hτabs ++ have ha_norm : ‖a‖ ≤ r1 := by ++ have : dist a (0 : ℂ) ≤ r1 := (Metric.mem_closedBall.mp ha) ++ simpa [dist_eq_norm] using this ++ have hnorm_le_r1 : ‖g τ‖ ≤ r1 := le_trans hnorm_le_a ha_norm ++ have hg_mem_r1 : g τ ∈ Metric.closedBall (0 : ℂ) r1 := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hnorm_le_r1 ++ exact (closedBall_mono_center0 (le_of_lt hr1_lt_R)) hg_mem_r1 ++ ++ have hcomp : ContinuousOn (fun τ : ℝ => f (g τ)) (Set.uIcc (0 : ℝ) a.im) := by ++ ++ convert (ContinuousOn.comp (hg := hf_cont) (hf := hg_cont) (h := hg_maps)) using 1; rfl ++ ++ have hInt : IntervalIntegrable (fun τ : ℝ => f (g τ)) volume (0 : ℝ) a.im := ++ ContinuousOn.intervalIntegrable (u := fun τ : ℝ => f (g τ)) (a := 0) (b := a.im) hcomp ++ simpa [g] using hInt ++ ++lemma helper_im_of_w (z h : ℂ) : (((((z + h).re : ℂ) + Complex.I * z.im)).im) = z.im := by ++ simp [Complex.add_im] ++ ++lemma helper_mul_sub_complex (x y : ℂ) : Complex.I * x - Complex.I * y = Complex.I * (x - y) := by ++ simp [mul_sub] ++ ++lemma helper_re_of_w (z h : ℂ) : (((((z + h).re : ℂ) + Complex.I * z.im)).re) = (z + h).re := by ++ simp ++ ++lemma diff_If_zh_w ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ let w : ℂ := ((z + h).re : ℂ) + Complex.I * z.im ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ ++ = Complex.I * (∫ τ in z.im..(z + h).im, f (((z + h).re : ℂ) + Complex.I * τ)) := by ++ classical ++ intro w ++ ++ let g : ℝ → ℂ := fun τ => f (((z + h).re : ℂ) + Complex.I * τ) ++ ++ have hInt1 : IntervalIntegrable g volume (0 : ℝ) ((z + h).im) := by ++ simpa [g] using ++ (vertical_intervalIntegrable_of_mem_ball hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf (a := z + h) hzh) ++ have hInt2 : IntervalIntegrable g volume (0 : ℝ) (z.im) := by ++ have hInt2' : ++ IntervalIntegrable ++ (fun τ : ℝ => f (((( (((z + h).re : ℂ) + Complex.I * z.im)).re : ℂ)) + Complex.I * τ)) ++ volume (0 : ℝ) (((((z + h).re : ℂ) + Complex.I * z.im)).im) := ++ vertical_intervalIntegrable_of_mem_ball hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf ++ (a := (((z + h).re : ℂ) + Complex.I * z.im)) hw ++ simpa [g, helper_re_of_w z h, helper_im_of_w z h] using hInt2' ++ have hinterval : ++ ((∫ τ in (0 : ℝ)..(z + h).im, g τ) - ∫ τ in (0 : ℝ)..z.im, g τ) ++ = ∫ τ in z.im..(z + h).im, g τ := ++ intervalIntegral.integral_interval_sub_left (μ := volume) (f := g) hInt1 hInt2 ++ ++ have h1 : ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ = (∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..(z + h).im, g τ) := by ++ have hzph := def_If_z_plus_h hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf (z := z) (h := h) hz hzh ++ simpa [g] using hzph ++ have h2 : ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ ++ = (∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, g τ) := by ++ have hwdef := def_If_w hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw ++ simpa [g, w] using hwdef ++ ++ calc ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ ++ = ((∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..(z + h).im, g τ)) ++ - ((∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, g τ)) := by ++ simp [h1, h2] ++ _ = (Complex.I * (∫ τ in (0 : ℝ)..(z + h).im, g τ)) ++ - (Complex.I * (∫ τ in (0 : ℝ)..z.im, g τ)) := by ++ simp [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] ++ _ = Complex.I * ++ ((∫ τ in (0 : ℝ)..(z + h).im, g τ) ++ - (∫ τ in (0 : ℝ)..z.im, g τ)) := by ++ simp [helper_mul_sub_complex] ++ _ = Complex.I * (∫ τ in z.im..(z + h).im, g τ) := by ++ simpa using congrArg (fun t => Complex.I * t) hinterval ++ _ = Complex.I * (∫ τ in z.im..(z + h).im, ++ f (((z + h).re : ℂ) + Complex.I * τ)) := by ++ simp [g] ++ ++lemma diff_If_w_z_initial_form_vertical ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ let w : ℂ := ((z + h).re : ℂ) + Complex.I * z.im ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ ++ = Complex.I * (∫ τ in z.im..(z + h).im, f (((z + h).re : ℂ) + Complex.I * τ)) := by ++ simpa using ++ (diff_If_zh_w (r1:=r1) (R:=R) (R0:=R0) hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw) ++ ++lemma diff_If_w_z_initial_form ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ let w : ℂ := ((z + h).re : ℂ) + Complex.I * z.im ++ (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = (∫ t in z.re..w.re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, (f (w.re + Complex.I * τ) - f (z.re + Complex.I * τ))) := by ++ intro w ++ ++ rw [def_If_w hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw] ++ rw [def_If_z hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz] ++ ++ have hw_re : w.re = (z + h).re := by simp [w] ++ have hw_im : w.im = z.im := by simp [w] ++ ++ have step1 : ++ ((∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, f (((z + h).re : ℂ) + Complex.I * τ))) ++ - ((∫ t in (0 : ℝ)..z.re, f (t : ℂ)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, f ((z.re : ℂ) + Complex.I * τ))) ++ = (∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) - (∫ t in (0 : ℝ)..z.re, f (t : ℂ)) ++ + Complex.I * ((∫ τ in (0 : ℝ)..z.im, f (((z + h).re : ℂ) + Complex.I * τ)) ++ - (∫ τ in (0 : ℝ)..z.im, f ((z.re : ℂ) + Complex.I * τ))) := by ring ++ rw [step1] ++ ++ have horizontal_integrable_zh : IntervalIntegrable (fun t : ℝ => f (t : ℂ)) volume (0 : ℝ) (z + h).re := by ++ ++ apply ContinuousOn.intervalIntegrable ++ apply ContinuousOn.comp hf.continuousOn Complex.continuous_ofReal.continuousOn ++ intro t ht ++ simp [Metric.mem_closedBall, dist_eq_norm, Complex.norm_real] ++ ++ have : ‖z + h‖ ≤ r1 := by simp [← dist_zero_right]; exact Metric.mem_closedBall.mp hzh ++ have : |(z + h).re| ≤ ‖z + h‖ := Complex.abs_re_le_norm (z + h) ++ have : |t| ≤ |(z + h).re| := abs_le_abs_of_mem_uIcc_zero ht ++ linarith [le_of_lt hr1_lt_R] ++ ++ have horizontal_integrable_z : IntervalIntegrable (fun t : ℝ => f (t : ℂ)) volume (0 : ℝ) z.re := by ++ apply ContinuousOn.intervalIntegrable ++ apply ContinuousOn.comp hf.continuousOn Complex.continuous_ofReal.continuousOn ++ intro t ht ++ simp [Metric.mem_closedBall, dist_eq_norm, Complex.norm_real] ++ have : ‖z‖ ≤ r1 := by simp [← dist_zero_right]; exact Metric.mem_closedBall.mp hz ++ have : |z.re| ≤ ‖z‖ := Complex.abs_re_le_norm z ++ have : |t| ≤ |z.re| := abs_le_abs_of_mem_uIcc_zero ht ++ linarith [le_of_lt hr1_lt_R] ++ ++ have horizontal_eq : ++ (∫ t in (0 : ℝ)..(z + h).re, f (t : ℂ)) - (∫ t in (0 : ℝ)..z.re, f (t : ℂ)) ++ = ∫ t in z.re..(z + h).re, f (t : ℂ) := by ++ rw [← intervalIntegral.integral_interval_sub_left horizontal_integrable_zh horizontal_integrable_z] ++ ++ have vertical_integrable_zh : IntervalIntegrable (fun τ : ℝ => f (((z + h).re : ℂ) + Complex.I * τ)) volume (0 : ℝ) z.im := by ++ ++ rw [← hw_re, ← hw_im] ++ exact vertical_intervalIntegrable_of_mem_ball hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hw ++ ++ have vertical_integrable_z : IntervalIntegrable (fun τ : ℝ => f ((z.re : ℂ) + Complex.I * τ)) volume (0 : ℝ) z.im := ++ vertical_intervalIntegrable_of_mem_ball hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz ++ ++ have vertical_eq : ++ (∫ τ in (0 : ℝ)..z.im, f (((z + h).re : ℂ) + Complex.I * τ)) ++ - (∫ τ in (0 : ℝ)..z.im, f ((z.re : ℂ) + Complex.I * τ)) ++ = ∫ τ in (0 : ℝ)..z.im, (f (((z + h).re : ℂ) + Complex.I * τ) - f ((z.re : ℂ) + Complex.I * τ)) := by ++ rw [← intervalIntegral.integral_sub vertical_integrable_zh vertical_integrable_z] ++ ++ rw [horizontal_eq, vertical_eq, hw_re] ++ ++lemma scalar_mul_integral_sub {a b : ℝ} (c : ℂ) (f g : ℝ → ℂ) ++ (hf : IntervalIntegrable f volume a b) (hg : IntervalIntegrable g volume a b) : ++ c * (∫ x in a..b, f x) - c * (∫ x in a..b, g x) = c * (∫ x in a..b, f x - g x) := by ++ rw [← mul_sub] ++ rw [← intervalIntegral.integral_sub hf hg] ++ ++lemma algebraic_rearrangement_four_terms (a b c d : ℂ) : ++ a - b + c - d = 0 → c - d = b - a := by ++ intro h ++ ++ calc c - d ++ = (a - b + c - d) - (a - b) := by ring ++ _ = 0 - (a - b) := by rw [h] ++ _ = -(a - b) := by ring ++ _ = b - a := by ring ++ ++lemma real_between_as_convex_combination (b₁ b₂ t : ℝ) ++ (h : (b₁ ≤ t ∧ t ≤ b₂) ∨ (b₂ ≤ t ∧ t ≤ b₁)) : ++ ∃ lam : ℝ, 0 ≤ lam ∧ lam ≤ 1 ∧ t = (1 - lam) * b₁ + lam * b₂ := by ++ ++ cases' le_total b₁ b₂ with h₁ h₂ ++ case inl => ++ ++ have ht : b₁ ≤ t ∧ t ≤ b₂ := by ++ cases' h with h_left h_right ++ · exact h_left ++ · ++ exact ⟨le_trans h₁ h_right.1, le_trans h_right.2 h₁⟩ ++ ++ by_cases heq : b₁ = b₂ ++ · ++ use 0 ++ constructor ++ · norm_num ++ constructor ++ · norm_num ++ · rw [heq] at ht ⊢ ++ have : t = b₂ := le_antisymm ht.2 ht.1 ++ rw [this] ++ ring ++ · ++ have hlt : b₁ < b₂ := lt_of_le_of_ne h₁ heq ++ let lam := (t - b₁) / (b₂ - b₁) ++ use lam ++ constructor ++ · ++ apply div_nonneg ++ · linarith [ht.1] ++ · linarith [hlt] ++ constructor ++ · ++ rw [div_le_iff₀] ++ · linarith [ht.2] ++ · linarith [hlt] ++ · ++ unfold lam ++ have h_nonzero : b₂ - b₁ ≠ 0 := ne_of_gt (sub_pos.2 hlt) ++ field_simp [h_nonzero]; ring ++ case inr => ++ ++ have ht : b₂ ≤ t ∧ t ≤ b₁ := by ++ cases' h with h_left h_right ++ · ++ exact ⟨le_trans h₂ h_left.1, le_trans h_left.2 h₂⟩ ++ · exact h_right ++ ++ by_cases heq : b₁ = b₂ ++ · ++ use 0 ++ constructor ++ · norm_num ++ constructor ++ · norm_num ++ · rw [← heq] at ht ⊢ ++ have : t = b₁ := le_antisymm ht.2 ht.1 ++ rw [this, heq] ++ ring ++ · ++ have hlt : b₂ < b₁ := lt_of_le_of_ne h₂ (Ne.symm heq) ++ let lam := (b₁ - t) / (b₁ - b₂) ++ use lam ++ constructor ++ · ++ apply div_nonneg ++ · linarith [ht.2] ++ · linarith [hlt] ++ constructor ++ · ++ rw [div_le_iff₀] ++ · linarith [ht.1] ++ · linarith [hlt] ++ · ++ unfold lam ++ have h_nonzero : b₁ - b₂ ≠ 0 := ne_of_gt (sub_pos.2 hlt) ++ field_simp [h_nonzero]; ring ++ ++lemma convex_combination_mem_segment {E : Type*} [AddCommGroup E] [Module ℝ E] (x y : E) (t : ℝ) ++ (h₀ : 0 ≤ t) (h₁ : t ≤ 1) : ++ (1 - t) • x + t • y ∈ segment ℝ x y := by ++ ++ use (1 - t), t ++ constructor ++ · ++ linarith [h₁] ++ constructor ++ · ++ exact h₀ ++ constructor ++ · ++ ring ++ · ++ rfl ++ ++lemma vertical_line_in_segment (a : ℂ) (b₁ b₂ t : ℝ) ++ (h : (b₁ ≤ t ∧ t ≤ b₂) ∨ (b₂ ≤ t ∧ t ≤ b₁)) : ++ a + Complex.I * t ∈ segment ℝ (a + Complex.I * b₁) (a + Complex.I * b₂) := by ++ ++ obtain ⟨lam, h_lam_nonneg, h_lam_le_one, h_t_eq⟩ := real_between_as_convex_combination b₁ b₂ t h ++ ++ have h_convex : a + Complex.I * t = (1 - lam) • (a + Complex.I * b₁) + lam • (a + Complex.I * b₂) := by ++ ++ simp only [Complex.real_smul] ++ ++ rw [h_t_eq] ++ ++ simp only [Complex.ofReal_add, Complex.ofReal_mul, Complex.ofReal_sub, Complex.ofReal_one] ++ ++ rw [mul_add] ++ ++ ring ++ ++ rw [h_convex] ++ exact convex_combination_mem_segment (a + Complex.I * b₁) (a + Complex.I * b₂) lam h_lam_nonneg h_lam_le_one ++ ++lemma horizontal_line_in_segment (a : ℝ) (b₁ b₂ t : ℝ) ++ (h : (b₁ ≤ t ∧ t ≤ b₂) ∨ (b₂ ≤ t ∧ t ≤ b₁)) : ++ (t : ℂ) + Complex.I * a ∈ segment ℝ ((b₁ : ℂ) + Complex.I * a) ((b₂ : ℂ) + Complex.I * a) := by ++ ++ obtain ⟨lam, h_lam_nonneg, h_lam_le_one, h_t_eq⟩ := real_between_as_convex_combination b₁ b₂ t h ++ ++ have h_convex : (t : ℂ) + Complex.I * a ++ = (1 - lam) • ((b₁ : ℂ) + Complex.I * a) + lam • ((b₂ : ℂ) + Complex.I * a) := by ++ simp only [Complex.real_smul] ++ ++ rw [h_t_eq] ++ simp only [Complex.ofReal_add, Complex.ofReal_mul, Complex.ofReal_sub, Complex.ofReal_one] ++ ring ++ ++ simpa [h_convex] using ++ (convex_combination_mem_segment ((b₁ : ℂ) + Complex.I * a) ((b₂ : ℂ) + Complex.I * a) lam h_lam_nonneg h_lam_le_one) ++ ++lemma intervalIntegrable_of_continuousOn_range (f : ℂ → ℂ) (g : ℝ → ℂ) (a b : ℝ) (S : Set ℂ) ++ (hf : ContinuousOn f S) (hg : Continuous g) ++ (hrange : ∀ t ∈ Set.uIcc a b, g t ∈ S) : ++ IntervalIntegrable (f ∘ g) volume a b := by ++ ++ have h_comp : ContinuousOn (f ∘ g) (Set.uIcc a b) := by ++ apply ContinuousOn.comp hf (hg.continuousOn) hrange ++ ++ exact h_comp.intervalIntegrable ++ ++lemma intervalIntegrable_of_analyticOnNhd_of_endpoints_in_smaller_ball ++ {r1 R : ℝ} (hr1_lt_R : r1 < R) {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {a : ℂ} {b₁ b₂ : ℝ} ++ (h₁ : ‖a + Complex.I * b₁‖ ≤ r1) (h₂ : ‖a + Complex.I * b₂‖ ≤ r1) : ++ IntervalIntegrable (fun t => f (a + Complex.I * t)) volume b₁ b₂ := by ++ ++ apply intervalIntegrable_of_continuousOn_range f (fun t => a + Complex.I * ↑t) b₁ b₂ (Metric.closedBall (0 : ℂ) R) ++ · ++ exact AnalyticOnNhd.continuousOn hf ++ · ++ exact Continuous.add continuous_const (Continuous.mul continuous_const continuous_ofReal) ++ · ++ intro t ht ++ ++ have h_in_r1 : ‖a + Complex.I * ↑t‖ ≤ r1 := by ++ ++ have h_segment : a + Complex.I * ↑t ∈ segment ℝ (a + Complex.I * b₁) (a + Complex.I * b₂) := by ++ apply vertical_line_in_segment ++ exact Set.mem_uIcc.mp ht ++ ++ have h₁_mem : a + Complex.I * b₁ ∈ Metric.closedBall (0 : ℂ) r1 := by ++ rwa [Metric.mem_closedBall, dist_zero_right] ++ have h₂_mem : a + Complex.I * b₂ ∈ Metric.closedBall (0 : ℂ) r1 := by ++ rwa [Metric.mem_closedBall, dist_zero_right] ++ ++ have h_subset := (convex_closedBall (0 : ℂ) r1).segment_subset h₁_mem h₂_mem ++ have h_in_ball := h_subset h_segment ++ rwa [Metric.mem_closedBall, dist_zero_right] at h_in_ball ++ ++ rw [Metric.mem_closedBall, dist_zero_right] ++ exact le_trans h_in_r1 (le_of_lt hr1_lt_R) ++ ++lemma cauchy_for_rectangles ++ {r1 R R0 : ℝ} ++ (_hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (_hR_lt_R0 : R < R0) (_hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z w : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : w ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzw : ((w.re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) r1) ++ (hwz : ((z.re : ℂ) + Complex.I * w.im) ∈ Metric.closedBall (0 : ℂ) r1) : ++ (∫ x in z.re..w.re, f ((x : ℂ) + Complex.I * (z.im))) ++ - (∫ x in z.re..w.re, f ((x : ℂ) + Complex.I * (w.im))) ++ + Complex.I * (∫ y in z.im..w.im, f ((w.re : ℂ) + Complex.I * y)) ++ - Complex.I * (∫ y in z.im..w.im, f ((z.re : ℂ) + Complex.I * y)) = 0 := by ++ classical ++ ++ have hA : ((z.re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ ++ have hz_eq : z = (z.re : ℂ) + Complex.I * z.im := by ++ exact (lem_wReIm z) ++ rwa [← hz_eq] ++ have hC : ((w.re : ℂ) + Complex.I * w.im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ ++ have hw_eq : w = (w.re : ℂ) + Complex.I * w.im := by ++ exact (lem_wReIm w) ++ rwa [← hw_eq] ++ ++ have h_left_in_ball : ∀ y ∈ Set.uIcc z.im w.im, ++ ((z.re : ℂ) + Complex.I * (y : ℂ)) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ intro y hy ++ have hseg : (z.re : ℂ) + Complex.I * (y : ℂ) ++ ∈ segment ℝ ((z.re : ℂ) + Complex.I * z.im) ((z.re : ℂ) + Complex.I * w.im) := by ++ simpa using vertical_line_in_segment (a := (z.re : ℂ)) (b₁ := z.im) (b₂ := w.im) (t := y) ++ (h := Set.mem_uIcc.mp hy) ++ exact (convex_closedBall (0 : ℂ) r1).segment_subset hA hwz hseg ++ have h_right_in_ball : ∀ y ∈ Set.uIcc z.im w.im, ++ ((w.re : ℂ) + Complex.I * (y : ℂ)) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ intro y hy ++ have hseg : (w.re : ℂ) + Complex.I * (y : ℂ) ++ ∈ segment ℝ ((w.re : ℂ) + Complex.I * z.im) ((w.re : ℂ) + Complex.I * w.im) := by ++ simpa using vertical_line_in_segment (a := (w.re : ℂ)) (b₁ := z.im) (b₂ := w.im) (t := y) ++ (h := Set.mem_uIcc.mp hy) ++ exact (convex_closedBall (0 : ℂ) r1).segment_subset hzw hC hseg ++ have h_point_in_ball : ∀ x ∈ Set.uIcc z.re w.re, ∀ y ∈ Set.uIcc z.im w.im, ++ ((x : ℂ) + Complex.I * (y : ℂ)) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ intro x hx y hy ++ have hL : ((z.re : ℂ) + Complex.I * (y : ℂ)) ∈ Metric.closedBall (0 : ℂ) r1 := h_left_in_ball y hy ++ have hR' : ((w.re : ℂ) + Complex.I * (y : ℂ)) ∈ Metric.closedBall (0 : ℂ) r1 := h_right_in_ball y hy ++ ++ obtain ⟨lam, hlam0, hlam1, hx_eq⟩ := real_between_as_convex_combination z.re w.re x (Set.mem_uIcc.mp hx) ++ have hseg_horiz : (x : ℂ) + Complex.I * (y : ℂ) ++ ∈ segment ℝ ((z.re : ℂ) + Complex.I * (y : ℂ)) ((w.re : ℂ) + Complex.I * (y : ℂ)) := by ++ ++ have : (x : ℂ) + Complex.I * (y : ℂ) ++ = (1 - lam) • ((z.re : ℂ) + Complex.I * (y : ℂ)) + lam • ((w.re : ℂ) + Complex.I * (y : ℂ)) := by ++ simp only [Complex.real_smul] ++ ++ rw [hx_eq] ++ simp only [Complex.ofReal_add, Complex.ofReal_mul, Complex.ofReal_sub, Complex.ofReal_one] ++ ring ++ simpa [this] using ++ (convex_combination_mem_segment ((z.re : ℂ) + Complex.I * (y : ℂ)) ((w.re : ℂ) + Complex.I * (y : ℂ)) lam hlam0 hlam1) ++ exact (convex_closedBall (0 : ℂ) r1).segment_subset hL hR' hseg_horiz ++ ++ set S := ([[z.re, w.re]] ×ℂ [[z.im, w.im]]) ++ have hS_subset_r1 : S ⊆ Metric.closedBall (0 : ℂ) r1 := by ++ intro p hp ++ have hx : p.re ∈ [[z.re, w.re]] := hp.1 ++ have hy : p.im ∈ [[z.im, w.im]] := hp.2 ++ ++ have : ((p.re : ℂ) + Complex.I * (p.im : ℂ)) ∈ Metric.closedBall (0 : ℂ) r1 := ++ h_point_in_ball p.re hx p.im hy ++ ++ have hp_eq : p = (p.re : ℂ) + Complex.I * (p.im : ℂ) := lem_wReIm p ++ rwa [hp_eq] ++ have hS_subset_R : S ⊆ Metric.closedBall (0 : ℂ) R := ++ fun p hp => (closedBall_mono_center0 (le_of_lt hr1_lt_R)) (hS_subset_r1 hp) ++ ++ have Hdiff : DifferentiableOn ℂ f S := by ++ intro p hp ++ have hpR : p ∈ Metric.closedBall (0 : ℂ) R := hS_subset_R hp ++ exact (hf p hpR).differentiableAt.differentiableWithinAt ++ ++ simpa [smul_eq_mul, mul_comm] using ++ Complex.integral_boundary_rect_eq_zero_of_differentiableOn f z w Hdiff ++ ++lemma cauchy_for_horizontal_strip ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ (∫ t in z.re..(z + h).re, f (t : ℂ)) ++ - (∫ t in z.re..(z + h).re, f (t + Complex.I * z.im)) ++ + Complex.I * (∫ τ in (0 : ℝ)..z.im, f (((z + h).re : ℂ) + Complex.I * τ)) ++ - Complex.I * (∫ τ in (0 : ℝ)..z.im, f ((z.re : ℂ) + Complex.I * τ)) = 0 := by ++ ++ let z₀ : ℂ := (z.re : ℂ) ++ let w₀ : ℂ := (z + h).re + Complex.I * z.im ++ ++ have hz₀ : z₀ ∈ Metric.closedBall (0 : ℂ) r1 := by ++ have hz_norm : ‖z‖ ≤ r1 := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hz ++ have hzre_le : ‖(z.re : ℂ)‖ ≤ ‖z‖ := by ++ rw [Complex.norm_real] ++ exact Complex.abs_re_le_norm z ++ have : ‖z₀‖ ≤ r1 := le_trans hzre_le hz_norm ++ simpa [z₀, Metric.mem_closedBall, dist_eq_norm] using this ++ have hw₀ : w₀ ∈ Metric.closedBall (0 : ℂ) r1 := hw ++ ++ have hzw : ((w₀.re : ℂ) + Complex.I * z₀.im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ ++ have h1 : ((w₀.re : ℂ) + Complex.I * z₀.im) = ((z + h).re : ℂ) := by ++ simp [w₀, z₀, Complex.ofReal_im, mul_zero, add_zero] ++ rw [h1] ++ have h2 : ‖((z + h).re : ℂ)‖ ≤ ‖z + h‖ := by ++ rw [Complex.norm_real] ++ exact Complex.abs_re_le_norm (z + h) ++ have h3 : ‖z + h‖ ≤ r1 := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hzh ++ simpa [Metric.mem_closedBall, dist_eq_norm] using le_trans h2 h3 ++ have hwz : ((z₀.re : ℂ) + Complex.I * w₀.im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ ++ have h1 : ((z₀.re : ℂ) + Complex.I * w₀.im) = z := by ++ simp [z₀, w₀, Complex.ofReal_re] ++ exact (lem_wReIm z).symm ++ rw [h1] ++ exact hz ++ ++ have H := cauchy_for_rectangles (r1:=r1) (R:=R) (R0:=R0) hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz₀ hw₀ hzw hwz ++ ++ rw [(show z₀.re = z.re by simp [z₀])] at H ++ rw [(show z₀.im = (0 : ℝ) by simp [z₀])] at H ++ rw [(show w₀.re = (z + h).re by simp [w₀])] at H ++ rw [(show w₀.im = z.im by simp [w₀])] at H ++ ++ convert H using 1 ++ simp only [Complex.ofReal_zero, mul_zero, add_zero] ++ ++lemma integrability_from_cauchy_horizontal_strip ++ {r1 R R0 : ℝ} (_hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (_hR_lt_R0 : R < R0) (_hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} (hz : z ∈ Metric.closedBall (0 : ℂ) r1) (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ IntervalIntegrable (fun τ => f (((z + h).re : ℂ) + Complex.I * τ)) volume (0 : ℝ) z.im ∧ ++ IntervalIntegrable (fun τ => f ((z.re : ℂ) + Complex.I * τ)) volume (0 : ℝ) z.im := by ++ constructor ++ · ++ apply intervalIntegrable_of_analyticOnNhd_of_endpoints_in_smaller_ball hr1_lt_R hf ++ · ++ simp only [Complex.ofReal_zero, mul_zero, add_zero, Complex.norm_real] ++ rw [Metric.mem_closedBall, dist_zero_right] at hzh ++ exact le_trans (Complex.abs_re_le_norm (z + h)) hzh ++ · ++ rw [Metric.mem_closedBall, dist_zero_right] at hw ++ exact hw ++ · ++ apply intervalIntegrable_of_analyticOnNhd_of_endpoints_in_smaller_ball hr1_lt_R hf ++ · ++ simp only [Complex.ofReal_zero, mul_zero, add_zero, Complex.norm_real] ++ rw [Metric.mem_closedBall, dist_zero_right] at hz ++ exact le_trans (Complex.abs_re_le_norm z) hz ++ · ++ rw [Metric.mem_closedBall, dist_zero_right] at hz ++ rw [← lem_wReIm z] ++ exact hz ++ ++lemma cauchy_rearrangement_step1 ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ Complex.I * (∫ τ in (0 : ℝ)..z.im, (f (((z + h).re : ℂ) + Complex.I * τ) - f ((z.re : ℂ) + Complex.I * τ))) ++ = (∫ t in z.re..(z + h).re, f (t + Complex.I * z.im)) - (∫ t in z.re..(z + h).re, f (t : ℂ)) := by ++ ++ have H := cauchy_for_horizontal_strip hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw ++ ++ have integrable := integrability_from_cauchy_horizontal_strip hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw ++ ++ have rearrange := algebraic_rearrangement_four_terms ++ (∫ t in z.re..(z + h).re, f (t : ℂ)) ++ (∫ t in z.re..(z + h).re, f (t + Complex.I * z.im)) ++ (Complex.I * (∫ τ in (0 : ℝ)..z.im, f (((z + h).re : ℂ) + Complex.I * τ))) ++ (Complex.I * (∫ τ in (0 : ℝ)..z.im, f ((z.re : ℂ) + Complex.I * τ))) ++ H ++ ++ have vertical_linearity : ++ Complex.I * (∫ τ in (0 : ℝ)..z.im, f (((z + h).re : ℂ) + Complex.I * τ)) ++ - Complex.I * (∫ τ in (0 : ℝ)..z.im, f ((z.re : ℂ) + Complex.I * τ)) ++ = Complex.I * (∫ τ in (0 : ℝ)..z.im, (f (((z + h).re : ℂ) + Complex.I * τ) - f ((z.re : ℂ) + Complex.I * τ))) := by ++ rw [← mul_sub] ++ rw [← intervalIntegral.integral_sub integrable.1 integrable.2] ++ ++ rw [← vertical_linearity] ++ exact rearrange ++ ++lemma diff_If_w_z ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ let w : ℂ := ((z + h).re : ℂ) + Complex.I * z.im ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩ ++ = (∫ t in z.re..(z + h).re, f (t + Complex.I * z.im)) := by ++ ++ have initial_form := diff_If_w_z_initial_form hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw ++ ++ have rearrange_step := cauchy_rearrangement_step1 hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw ++ ++ have w_re_eq : (((z + h).re : ℂ) + Complex.I * z.im).re = (z + h).re := by ++ simp [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.I_im, Complex.ofReal_im] ++ ++ simp_rw [initial_form, w_re_eq, rearrange_step] ++ ++ ring ++ ++lemma If_difference_is_L_path_integral ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = (∫ t in z.re..(z + h).re, f (t + Complex.I * z.im)) ++ + Complex.I * (∫ τ in z.im..(z + h).im, f (((z + h).re : ℂ) + Complex.I * τ)) := by ++ ++ let w : ℂ := ((z + h).re : ℂ) + Complex.I * z.im ++ ++ calc If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩ ++ = (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩) ++ + (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) := by ring ++ _ = Complex.I * (∫ τ in z.im..(z + h).im, f (((z + h).re : ℂ) + Complex.I * τ)) ++ + (∫ t in z.re..(z + h).re, f (t + Complex.I * z.im)) := by ++ rw [diff_If_zh_w hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw, ++ diff_If_w_z hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw] ++ _ = (∫ t in z.re..(z + h).re, f (t + Complex.I * z.im)) ++ + Complex.I * (∫ τ in z.im..(z + h).im, f (((z + h).re : ℂ) + Complex.I * τ)) := by ring ++ ++lemma If_diff_add_sub_identity ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = ++ (∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z) + f z) ++ + Complex.I * (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z) + f z) := by ++ ++ have H := ++ If_difference_is_L_path_integral (hr1_pos) (hr1_lt_R) (hR_lt_R0) (hR0_lt_one) hf hz hzh hw ++ simpa [add_comm, add_left_comm, add_assoc, sub_eq_add_neg] using H ++ ++lemma intervalIntegrable_of_analyticOnNhd_of_horizontal_endpoints_in_smaller_ball ++ {r1 R : ℝ} (hr1_lt_R : r1 < R) {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {im_part : ℝ} {a b : ℝ} ++ (h₁ : ‖(a : ℂ) + Complex.I * im_part‖ ≤ r1) (h₂ : ‖(b : ℂ) + Complex.I * im_part‖ ≤ r1) : ++ IntervalIntegrable (fun t => f ((t : ℂ) + Complex.I * im_part)) volume a b := by ++ ++ apply intervalIntegrable_of_continuousOn_range f (fun t => (t : ℂ) + Complex.I * im_part) a b (Metric.closedBall (0 : ℂ) R) ++ · ++ exact AnalyticOnNhd.continuousOn hf ++ · ++ exact Continuous.add continuous_ofReal continuous_const ++ · ++ intro t ht ++ ++ have h_in_r1 : ‖(t : ℂ) + Complex.I * im_part‖ ≤ r1 := by ++ ++ have h_segment : (t : ℂ) + Complex.I * im_part ∈ segment ℝ ((a : ℂ) + Complex.I * im_part) ((b : ℂ) + Complex.I * im_part) := by ++ ++ obtain ⟨lam, h_lam_nonneg, h_lam_le_one, h_t_eq⟩ := real_between_as_convex_combination a b t (Set.mem_uIcc.mp ht) ++ ++ have h_convex : (t : ℂ) + Complex.I * im_part = (1 - lam) • ((a : ℂ) + Complex.I * im_part) + lam • ((b : ℂ) + Complex.I * im_part) := by ++ ++ simp only [Complex.real_smul] ++ ++ rw [h_t_eq] ++ ++ simp only [Complex.ofReal_add, Complex.ofReal_mul, Complex.ofReal_sub, Complex.ofReal_one] ++ ++ ring ++ ++ rw [h_convex] ++ exact convex_combination_mem_segment ((a : ℂ) + Complex.I * im_part) ((b : ℂ) + Complex.I * im_part) lam h_lam_nonneg h_lam_le_one ++ ++ have h₁_mem : (a : ℂ) + Complex.I * im_part ∈ Metric.closedBall (0 : ℂ) r1 := by ++ rwa [Metric.mem_closedBall, dist_zero_right] ++ have h₂_mem : (b : ℂ) + Complex.I * im_part ∈ Metric.closedBall (0 : ℂ) r1 := by ++ rwa [Metric.mem_closedBall, dist_zero_right] ++ ++ have h_subset := (convex_closedBall (0 : ℂ) r1).segment_subset h₁_mem h₂_mem ++ have h_in_ball := h_subset h_segment ++ rwa [Metric.mem_closedBall, dist_zero_right] at h_in_ball ++ ++ rw [Metric.mem_closedBall, dist_zero_right] ++ exact le_trans h_in_r1 (le_of_lt hr1_lt_R) ++ ++lemma If_diff_linearity ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = ++ ((∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)) ++ + (∫ _t in z.re..(z + h).re, f z)) ++ + Complex.I * ++ ((∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)) ++ + (∫ _τ in z.im..(z + h).im, f z)) := by ++ ++ have H := If_diff_add_sub_identity hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw ++ ++ have hz_norm : ‖z‖ ≤ r1 := by rwa [Metric.mem_closedBall, dist_zero_right] at hz ++ have hzh_norm : ‖z + h‖ ≤ r1 := by rwa [Metric.mem_closedBall, dist_zero_right] at hzh ++ have hw_norm : ‖((z + h).re : ℂ) + Complex.I * z.im‖ ≤ r1 := by ++ rwa [Metric.mem_closedBall, dist_zero_right] at hw ++ ++ have h_z_eq : z = (z.re : ℂ) + Complex.I * z.im := lem_wReIm z ++ have h_zh_eq : z + h = ((z + h).re : ℂ) + Complex.I * (z + h).im := lem_wReIm (z + h) ++ ++ have hz_endpoint : ‖(z.re : ℂ) + Complex.I * z.im‖ ≤ r1 := by rwa [← h_z_eq] ++ have h_horiz_integrable := intervalIntegrable_of_analyticOnNhd_of_horizontal_endpoints_in_smaller_ball ++ hr1_lt_R hf hz_endpoint hw_norm ++ ++ have hzh_endpoint : ‖((z + h).re : ℂ) + Complex.I * (z + h).im‖ ≤ r1 := by rwa [← h_zh_eq] ++ have h_vert_integrable := intervalIntegrable_of_analyticOnNhd_of_endpoints_in_smaller_ball ++ hr1_lt_R hf hw_norm hzh_endpoint ++ ++ have h_const_horiz : IntervalIntegrable (fun _ => f z) volume z.re (z + h).re := intervalIntegrable_const ++ have h_const_vert : IntervalIntegrable (fun _ => f z) volume z.im (z + h).im := intervalIntegrable_const ++ ++ have h_diff_horiz : IntervalIntegrable (fun t => f (t + Complex.I * z.im) - f z) volume z.re (z + h).re := ++ IntervalIntegrable.sub h_horiz_integrable h_const_horiz ++ ++ have h_diff_vert : IntervalIntegrable (fun τ => f (((z + h).re : ℂ) + Complex.I * τ) - f z) volume z.im (z + h).im := ++ IntervalIntegrable.sub h_vert_integrable h_const_vert ++ ++ have h1 : ∫ t in z.re..(z + h).re, ((f (t + Complex.I * z.im) - f z) + f z) = ++ (∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)) + (∫ t in z.re..(z + h).re, f z) := ++ intervalIntegral.integral_add h_diff_horiz h_const_horiz ++ ++ have h2 : ∫ τ in z.im..(z + h).im, ((f (((z + h).re : ℂ) + Complex.I * τ) - f z) + f z) = ++ (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)) + (∫ τ in z.im..(z + h).im, f z) := ++ intervalIntegral.integral_add h_diff_vert h_const_vert ++ ++ rw [H, h1, h2, mul_add] ++ ++lemma integral_of_constant_over_L_path ++ {r1 R R0 : ℝ} ++ (_hr1_pos : 0 < r1) (_hr1_lt_R : r1 < R) (_hR_lt_R0 : R < R0) (_hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (_hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (_hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (_hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) : ++ (∫ _t in z.re..(z + h).re, f z) + Complex.I * (∫ _τ in z.im..(z + h).im, f z) ++ = f z * h := by ++ ++ rw [intervalIntegral.integral_const, intervalIntegral.integral_const] ++ ++ rw [Complex.add_re, Complex.add_im] ++ simp only [add_sub_cancel_left] ++ ++ rw [Complex.real_smul, Complex.real_smul] ++ ++ rw [← mul_assoc] ++ ++ rw [← add_mul] ++ ++ rw [mul_comm Complex.I (↑h.im)] ++ ++ rw [Complex.re_add_im h] ++ ++ rw [mul_comm] ++ ++noncomputable def Err ++ {r1 R R0 : ℝ} ++ (_hr1_pos : 0 < r1) (_hr1_lt_R : r1 < R) (_hR_lt_R0 : R < R0) (_hR0_lt_one : R0 < 1) ++ (f : ℂ → ℂ) ++ (_hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ (z h : ℂ) : ℂ := ++ (∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)) ++ + Complex.I * (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)) ++ ++lemma CD_eq_fz_h ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) : ++ (∫ _t in z.re..(z + h).re, f z) + Complex.I * (∫ _τ in z.im..(z + h).im, f z) ++ = f z * h := by ++ simpa using ++ integral_of_constant_over_L_path (r1:=r1) (R:=R) (R0:=R0) ++ hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh ++ ++lemma If_diff_decomposition_final ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = f z * h ++ + Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h := by ++ ++ have H := ++ If_diff_linearity (hr1_pos) (hr1_lt_R) (hR_lt_R0) (hR0_lt_one) ++ (f := f) (hf := hf) ++ (z := z) (h := h) ++ (hz := hz) (hzh := hzh) (hw := hw) ++ ++ let A : ℂ := ∫ t in z.re..(z + h).re, f (t + Complex.I * z.im) - f z ++ let B : ℂ := ∫ t in z.re..(z + h).re, f z ++ let C : ℂ := ∫ τ in z.im..(z + h).im, f (((z + h).re : ℂ) + Complex.I * τ) - f z ++ let D : ℂ := ∫ τ in z.im..(z + h).im, f z ++ ++ have hH' : (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = (A + B) + Complex.I * (C + D) := by ++ simpa [A, B, C, D, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using H ++ ++ have hsplit : (A + B) + Complex.I * (C + D) ++ = (A + Complex.I * C) + (B + Complex.I * D) := by ring ++ have hH'' : (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = (A + Complex.I * C) + (B + Complex.I * D) := by ++ simpa [hsplit] using hH' ++ ++ have hBD : (B + Complex.I * D) = f z * h := by ++ simpa [B, D] using ++ integral_of_constant_over_L_path (r1:=r1) (R:=R) (R0:=R0) hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh ++ have hH''' : (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = (A + Complex.I * C) + f z * h := by ++ simpa [hBD] using hH'' ++ ++ have hH4 : (If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ ++ - If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩) ++ = Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h + f z * h := by ++ simpa [Err, A, C, add_comm, add_left_comm, add_assoc] using hH''' ++ ++ simpa [Err, add_comm, add_left_comm, add_assoc] using hH4 ++ ++noncomputable def S_horiz (z h : ℂ) (f : ℂ → ℂ) : ℝ := ++ sSup {r | ∃ t ∈ Set.uIcc z.re (z + h).re, ++ r = ‖f (t + Complex.I * z.im) - f z‖} ++ ++noncomputable def S_vert (z h : ℂ) (f : ℂ → ℂ) : ℝ := ++ sSup {r | ∃ τ ∈ Set.uIcc z.im (z + h).im, ++ r = ‖f (((z + h).re : ℂ) + Complex.I * τ) - f z‖} ++ ++noncomputable def S_max (z h : ℂ) (f : ℂ → ℂ) : ℝ := ++ max (S_horiz z h f) (S_vert z h f) ++ ++lemma bound_on_Err ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) : ++ ‖Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h‖ ++ ≤ |h.re| * S_max z h f + |h.im| * S_max z h f := by ++ ++ unfold Err ++ ++ have hsplit : ++ ‖(∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)) ++ + Complex.I * (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z))‖ ++ ≤ ‖∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)‖ ++ + ‖Complex.I * (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z))‖ := ++ norm_add_le _ _ ++ ++ have hI : ‖Complex.I‖ = (1 : ℝ) := by simp ++ have hvertnorm : ++ ‖Complex.I * (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z))‖ ++ = ‖∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)‖ := by ++ simp [hI, one_mul] ++ ++ set SH : Set ℝ := {r | ∃ t ∈ Set.uIcc z.re (z + h).re, ++ r = ‖f (t + Complex.I * z.im) - f z‖} ++ have hbdd_SH : BddAbove SH := by ++ classical ++ ++ have hK : IsCompact (Set.uIcc z.re (z + h).re) := isCompact_uIcc ++ ++ let γ : ℝ → ℂ := fun t => (t : ℂ) + Complex.I * z.im ++ have hγ_cont : Continuous γ := by ++ convert (Complex.continuous_ofReal.add (continuous_const (y := Complex.I * (z.im : ℂ)))) using 1 ++ have hz_mem : ((z.re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ simp only [Metric.mem_closedBall, dist_zero_right] ++ rw [show (z.re : ℂ) + Complex.I * z.im = z.re + z.im * Complex.I by ring] ++ rw [Complex.re_add_im] ++ rwa [Metric.mem_closedBall, dist_zero_right] at hz ++ have hw_mem : (((z + h).re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using hw ++ have hseg_subset : ++ (γ '' Set.uIcc z.re (z + h).re) ⊆ Metric.closedBall (0 : ℂ) r1 := by ++ intro w hwim ++ rcases hwim with ⟨t, ht, rfl⟩ ++ ++ have hseg : ((t : ℂ) + Complex.I * z.im) ++ ∈ segment ℝ ((z.re : ℂ) + Complex.I * z.im) ++ (((z + h).re : ℂ) + Complex.I * z.im) := by ++ ++ have := horizontal_line_in_segment (a := z.im) (b₁ := z.re) (b₂ := (z + h).re) ++ (t := t) (by simpa [Set.mem_uIcc] using ht) ++ simpa using this ++ have hz_in : ((z.re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) r1 := hz_mem ++ have hw_in : (((z + h).re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) r1 := hw_mem ++ have hsubset := (convex_closedBall (0 : ℂ) r1).segment_subset hz_in hw_in ++ have hw' := hsubset hseg ++ simpa [Metric.mem_closedBall, dist_zero_right] using hw' ++ have hf_cont : ContinuousOn f (Metric.closedBall (0 : ℂ) R) := hf.continuousOn ++ ++ have hmaps : Set.MapsTo γ (Set.uIcc z.re (z + h).re) (Metric.closedBall (0 : ℂ) R) := by ++ intro t ht ++ have himg_r1 : γ t ∈ Metric.closedBall (0 : ℂ) r1 := by ++ exact hseg_subset (Set.mem_image_of_mem _ ht) ++ exact (closedBall_mono_center0 (le_of_lt hr1_lt_R)) himg_r1 ++ have hcont_on : ContinuousOn (fun t => f (γ t)) (Set.uIcc z.re (z + h).re) := by ++ convert (ContinuousOn.comp (hf_cont) (hγ_cont.continuousOn) hmaps) using 1; rfl ++ ++ have hψ : Continuous (fun w : ℂ => ‖w - f z‖) := ++ (continuous_id.sub continuous_const).norm ++ have hR_cont : ContinuousOn (fun t => ‖f (γ t) - f z‖) (Set.uIcc z.re (z + h).re) := by ++ ++ have h_cont_sub : ContinuousOn (fun t => f (γ t) - f z) (Set.uIcc z.re (z + h).re) := ++ hcont_on.sub continuousOn_const ++ ++ exact h_cont_sub.norm ++ ++ have himage_compact : IsCompact ((fun t => ‖f (γ t) - f z‖) '' Set.uIcc z.re (z + h).re) := ++ IsCompact.image_of_continuousOn hK hR_cont ++ ++ have hSH_eq : SH = (fun t => ‖f (γ t) - f z‖) '' Set.uIcc z.re (z + h).re := by ++ ext r; constructor ++ · intro hr; rcases hr with ⟨t, ht, rfl⟩; exact ⟨t, ht, rfl⟩ ++ · intro hr; rcases hr with ⟨t, ht, rfl⟩; exact ⟨t, ht, rfl⟩ ++ ++ have : BddAbove ((fun t => ‖f (γ t) - f z‖) '' Set.uIcc z.re (z + h).re) := ++ himage_compact.bddAbove ++ simpa [hSH_eq] using this ++ ++ set SV : Set ℝ := {r | ∃ τ ∈ Set.uIcc z.im (z + h).im, ++ r = ‖f (((z + h).re : ℂ) + Complex.I * τ) - f z‖} ++ have hbdd_SV : BddAbove SV := by ++ classical ++ ++ have hK : IsCompact (Set.uIcc z.im (z + h).im) := isCompact_uIcc ++ let γv : ℝ → ℂ := fun τ => ((z + h).re : ℂ) + Complex.I * τ ++ have hγv_cont : Continuous γv := by ++ have hmul : Continuous (fun τ : ℝ => Complex.I * (τ : ℂ)) := by ++ exact continuous_const.mul Complex.continuous_ofReal ++ simp only [γv] ++ exact continuous_const.add hmul ++ have hw_mem' : (((z + h).re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ simpa [Metric.mem_closedBall, dist_zero_right] using hw ++ have hzh_mem : (((z + h).re : ℂ) + Complex.I * (z + h).im) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ simp only [Metric.mem_closedBall, dist_zero_right] ++ rw [show ((z + h).re : ℂ) + Complex.I * (z + h).im = (z + h).re + (z + h).im * Complex.I by ring] ++ rw [Complex.re_add_im] ++ rwa [Metric.mem_closedBall, dist_zero_right] at hzh ++ have hseg_subset : ++ (γv '' Set.uIcc z.im (z + h).im) ⊆ Metric.closedBall (0 : ℂ) r1 := by ++ intro w hwim; rcases hwim with ⟨τ, hτ, rfl⟩ ++ have hseg : (((z + h).re : ℂ) + Complex.I * τ) ++ ∈ segment ℝ (((z + h).re : ℂ) + Complex.I * z.im) ++ (((z + h).re : ℂ) + Complex.I * (z + h).im) := by ++ have := vertical_line_in_segment (((z + h).re : ℂ)) (b₁ := z.im) (b₂ := (z + h).im) (t := τ) ++ (by simpa [Set.mem_uIcc] using hτ) ++ simpa using this ++ have hz_in := hw_mem' ++ have hw_in := hzh_mem ++ have hsubset := (convex_closedBall (0 : ℂ) r1).segment_subset hz_in hw_in ++ have hw' := hsubset hseg ++ simp only [Metric.mem_closedBall, dist_zero_right] at hw' ++ rwa [Metric.mem_closedBall, dist_zero_right] ++ have hmaps : Set.MapsTo γv (Set.uIcc z.im (z + h).im) (Metric.closedBall (0 : ℂ) R) := by ++ intro τ hτ; have : γv τ ∈ Metric.closedBall (0 : ℂ) r1 := hseg_subset (Set.mem_image_of_mem _ hτ) ++ exact (closedBall_mono_center0 (le_of_lt hr1_lt_R)) this ++ have hf_cont : ContinuousOn f (Metric.closedBall (0 : ℂ) R) := hf.continuousOn ++ have hcont_on : ContinuousOn (fun τ => f (γv τ)) (Set.uIcc z.im (z + h).im) := by ++ convert (ContinuousOn.comp (hf_cont) (hγv_cont.continuousOn) hmaps) using 1; rfl ++ have hψ : Continuous (fun w : ℂ => ‖w - f z‖) := ++ (continuous_id.sub continuous_const).norm ++ have hR_cont : ContinuousOn (fun τ => ‖f (γv τ) - f z‖) (Set.uIcc z.im (z + h).im) := by ++ have h1 : ContinuousOn (fun τ => f (γv τ) - f z) (Set.uIcc z.im (z + h).im) := by ++ exact hcont_on.sub continuousOn_const ++ exact h1.norm ++ have himage_compact : IsCompact ((fun τ => ‖f (γv τ) - f z‖) '' Set.uIcc z.im (z + h).im) := ++ IsCompact.image_of_continuousOn hK hR_cont ++ have hSV_eq : SV = (fun τ => ‖f (γv τ) - f z‖) '' Set.uIcc z.im (z + h).im := by ++ ext r; constructor ++ · intro hr; rcases hr with ⟨τ, hτ, rfl⟩; exact ⟨τ, hτ, rfl⟩ ++ · intro hr; rcases hr with ⟨τ, hτ, rfl⟩; exact ⟨τ, hτ, rfl⟩ ++ have : BddAbove ((fun τ => ‖f (γv τ) - f z‖) '' Set.uIcc z.im (z + h).im) := ++ himage_compact.bddAbove ++ simpa [hSV_eq] using this ++ ++ have hC_horiz : ∀ t ∈ Set.uIcc z.re (z + h).re, ++ ‖(f (t + Complex.I * z.im) - f z)‖ ≤ S_horiz z h f := by ++ intro t ht ++ have hx : ‖f (t + Complex.I * z.im) - f z‖ ∈ SH := ⟨t, ht, rfl⟩ ++ ++ have : S_horiz z h f = sSup SH := rfl ++ simpa [this] using (le_csSup hbdd_SH hx) ++ ++ have hC_vert : ∀ τ ∈ Set.uIcc z.im (z + h).im, ++ ‖(f (((z + h).re : ℂ) + Complex.I * τ) - f z)‖ ≤ S_vert z h f := by ++ intro τ hτ ++ have hx : ‖f (((z + h).re : ℂ) + Complex.I * τ) - f z‖ ∈ SV := ⟨τ, hτ, rfl⟩ ++ have : S_vert z h f = sSup SV := rfl ++ simpa [this] using (le_csSup hbdd_SV hx) ++ ++ have hH : ‖∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)‖ ++ ≤ |(z + h).re - z.re| * S_horiz z h f := by ++ ++ have h_bound : ∀ t, t ∈ [[z.re, (z + h).re]] → ‖f (↑t + Complex.I * ↑z.im) - f z‖ ≤ S_horiz z h f := by ++ intro t ht; exact hC_horiz t ht ++ have h_int : ∀ t ∈ Ι z.re (z + h).re, ‖f (↑t + Complex.I * ↑z.im) - f z‖ ≤ S_horiz z h f := by ++ intro t ht ++ have ht_uIcc : t ∈ Set.uIcc z.re (z + h).re := by ++ ++ exact Set.uIoc_subset_uIcc ht ++ exact h_bound t ht_uIcc ++ have := intervalIntegral.norm_integral_le_of_norm_le_const h_int ++ convert this using 1 ++ ring ++ ++ have hV : ‖∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)‖ ++ ≤ |(z + h).im - z.im| * S_vert z h f := by ++ have h_bound : ∀ τ, τ ∈ [[z.im, (z + h).im]] → ‖f (↑(z + h).re + Complex.I * ↑τ) - f z‖ ≤ S_vert z h f := by ++ intro τ hτ; exact hC_vert τ hτ ++ have h_int : ∀ τ ∈ Ι z.im (z + h).im, ‖f (↑(z + h).re + Complex.I * ↑τ) - f z‖ ≤ S_vert z h f := by ++ intro τ hτ ++ have hτ_uIcc : τ ∈ Set.uIcc z.im (z + h).im := by ++ ++ exact Set.uIoc_subset_uIcc hτ ++ exact h_bound τ hτ_uIcc ++ have := intervalIntegral.norm_integral_le_of_norm_le_const h_int ++ rwa [mul_comm] at this ++ ++ have hre' : (z + h).re - z.re = h.re := by ++ simp [Complex.add_re] ++ have him' : (z + h).im - z.im = h.im := by ++ simp [Complex.add_im] ++ have hre : |(z + h).re - z.re| = |h.re| := by simp ++ have him : |(z + h).im - z.im| = |h.im| := by simp ++ ++ have hH' : ‖∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)‖ ++ ≤ |h.re| * S_max z h f := by ++ have : S_horiz z h f ≤ S_max z h f := by exact le_max_left _ _ ++ ++ have hH_rewritten : ‖∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)‖ ≤ |h.re| * S_horiz z h f := by ++ rwa [hre] at hH ++ ++ have h_bound := mul_le_mul_of_nonneg_left this (abs_nonneg (h.re)) ++ exact le_trans hH_rewritten h_bound ++ ++ have hV' : ‖∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)‖ ++ ≤ |h.im| * S_max z h f := by ++ have : S_vert z h f ≤ S_max z h f := by exact le_max_right _ _ ++ ++ have hV_rewritten : ‖∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)‖ ≤ |h.im| * S_vert z h f := by ++ rwa [him] at hV ++ ++ have h_bound := mul_le_mul_of_nonneg_left this (abs_nonneg (h.im)) ++ exact le_trans hV_rewritten h_bound ++ ++ have := ++ calc ++ ‖(∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)) ++ + Complex.I * (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z))‖ ++ ≤ ‖∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)‖ ++ + ‖Complex.I * (∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z))‖ := hsplit ++ _ = ‖∫ t in z.re..(z + h).re, (f (t + Complex.I * z.im) - f z)‖ ++ + ‖∫ τ in z.im..(z + h).im, (f (((z + h).re : ℂ) + Complex.I * τ) - f z)‖ := by simp ++ _ ≤ |h.re| * S_max z h f + |h.im| * S_max z h f := add_le_add hH' hV' ++ ++ simpa [Err] using this ++ ++lemma S_horiz_nonneg (z h : ℂ) (f : ℂ → ℂ) : 0 ≤ S_horiz z h f := by ++ ++ unfold S_horiz ++ apply Real.sSup_nonneg ++ intro r hr; rcases hr with ⟨t, ht, rfl⟩; exact norm_nonneg _ ++ ++lemma S_max_nonneg (z h : ℂ) (f : ℂ → ℂ) : 0 ≤ S_max z h f := by ++ unfold S_max ++ have h1 : 0 ≤ S_horiz z h f := S_horiz_nonneg z h f ++ exact le_trans h1 (le_max_left _ _) ++ ++lemma bound_on_Err_ratio ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) r1) ++ (hw : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) r1) ++ (hh : h ≠ 0) : ++ ‖Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h / h‖ ≤ 2 * S_max z h f := by ++ ++ have h_abs_eq : ‖Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h / h‖ = ‖Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h / h‖ := rfl ++ ++ have h1 := bound_on_Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz hzh hw ++ ++ rw [← add_mul] at h1 ++ ++ have h_norm_pos : 0 < ‖h‖ := norm_pos_iff.mpr hh ++ ++ have h2 : ‖Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h‖ / ‖h‖ ≤ ++ (|h.re| + |h.im|) * S_max z h f / ‖h‖ := by ++ exact div_le_div_of_nonneg_right h1 (le_of_lt h_norm_pos) ++ ++ rw [← norm_div] at h2 ++ ++ have h2' : ‖Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h / h‖ ≤ ++ (|h.re| + |h.im|) / ‖h‖ * S_max z h f := by ++ rw [← div_mul_eq_mul_div] at h2 ++ exact h2 ++ ++ have h3 : |h.re| + |h.im| ≤ 2 * ‖h‖ := by ++ ++ calc |h.re| + |h.im| ++ ≤ ‖h‖ + ‖h‖ := add_le_add (Complex.abs_re_le_norm h) (Complex.abs_im_le_norm h) ++ _ = 2 * ‖h‖ := by ring ++ ++ have h4 : (|h.re| + |h.im|) / ‖h‖ ≤ 2 := by ++ ++ rw [div_le_iff₀ h_norm_pos] ++ exact h3 ++ ++ calc ‖Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h / h‖ ++ ≤ (|h.re| + |h.im|) / ‖h‖ * S_max z h f := h2' ++ _ ≤ 2 * S_max z h f := mul_le_mul_of_nonneg_right h4 (S_max_nonneg z h f) ++open Filter Topology ++ ++lemma abs_horizontal_diff_eq_abs_real (z : ℂ) (t : ℝ) : ‖(t : ℂ) + Complex.I * z.im - z‖ = |t - z.re| := by ++ ++ have h : (t : ℂ) + Complex.I * z.im - z = (t - z.re : ℂ) := by ++ apply Complex.ext_iff.mpr ++ constructor ++ · ++ simp only [Complex.add_re, Complex.sub_re, Complex.ofReal_re, Complex.mul_re, ++ Complex.I_re, Complex.I_im, Complex.ofReal_im] ++ ring ++ · ++ simp only [Complex.add_im, Complex.sub_im, Complex.ofReal_im, Complex.mul_im, ++ Complex.I_re, Complex.I_im, Complex.ofReal_re] ++ ring ++ ++ rw [h] ++ ++ rw [← Complex.ofReal_sub] ++ ++ rw [Complex.norm_real, Real.norm_eq_abs] ++ ++lemma abs_sub_le_of_mem_uIcc (a b t : ℝ) (ht : t ∈ Set.uIcc a b) : |t - a| ≤ |b - a| ∧ |b - t| ≤ |b - a| := by ++ ++ have h1 : a ≤ b ∨ b ≤ a := le_total a b ++ rcases h1 with hle | hle ++ · ++ have ht' : t ∈ Set.Icc a b := by simpa [Set.uIcc_of_le hle] using ht ++ have h_bounds : a ≤ t ∧ t ≤ b := by simpa using ht' ++ constructor ++ · have h_ta : |t - a| = t - a := by simp [abs_of_nonneg (sub_nonneg.mpr h_bounds.left)] ++ have h_ba : |b - a| = b - a := by simp [abs_of_nonneg (sub_nonneg.mpr hle)] ++ rw [h_ta, h_ba] ++ exact sub_le_sub_right h_bounds.right a ++ · have h_bt : |b - t| = b - t := by simp [abs_of_nonneg (sub_nonneg.mpr h_bounds.right)] ++ have h_ba : |b - a| = b - a := by simp [abs_of_nonneg (sub_nonneg.mpr hle)] ++ rw [h_bt, h_ba] ++ exact sub_le_sub_left h_bounds.left b ++ · ++ have ht' : t ∈ Set.Icc b a := by ++ rw [Set.uIcc_comm] at ht ++ simpa [Set.uIcc_of_le hle] using ht ++ have h_bounds : b ≤ t ∧ t ≤ a := by simpa using ht' ++ constructor ++ · have h_ta : |t - a| = a - t := by simp [abs_of_nonpos (sub_nonpos.mpr h_bounds.right)] ++ have h_ba : |b - a| = a - b := by simp [abs_of_nonpos (sub_nonpos.mpr hle)] ++ rw [h_ta, h_ba] ++ exact sub_le_sub_left h_bounds.left a ++ · have h_bt : |b - t| = t - b := by ++ rw [abs_of_nonpos (sub_nonpos.mpr h_bounds.left)] ++ ring ++ have h_ba : |b - a| = a - b := by simp [abs_of_nonpos (sub_nonpos.mpr hle)] ++ rw [h_bt, h_ba] ++ exact sub_le_sub_right h_bounds.right b ++ ++lemma sub_ofReal_add_I (a b c d : ℝ) : ((a : ℂ) + Complex.I * b) - ((c : ℂ) + Complex.I * d) = ((a - c : ℝ) : ℂ) + Complex.I * (b - d) := by ++ apply Complex.ext ++ · ++ simp only [Complex.sub_re, Complex.add_re, Complex.ofReal_re, Complex.I_mul_re, Complex.ofReal_im, neg_zero, add_zero] ++ ++ rw [← Complex.ofReal_sub, Complex.ofReal_im, neg_zero, add_zero] ++ · ++ simp only [Complex.sub_im, Complex.add_im, Complex.ofReal_im, Complex.I_mul_im, Complex.ofReal_re, zero_add] ++ ++ rw [← Complex.ofReal_sub, Complex.ofReal_re] ++ ++lemma abs_re_im_bound (a b : ℝ) : ‖(a : ℂ) + Complex.I * b‖ ≤ |a| + |b| := by ++ ++ have triangle := lem_triangle_ineq (a : ℂ) (Complex.I * (b : ℂ)) ++ convert triangle ++ · ++ simp [Complex.norm_real, Real.norm_eq_abs] ++ · ++ simp [Complex.norm_I, Complex.norm_real, Real.norm_eq_abs] ++ ++lemma norm_ofReal (x : ℝ) : ‖(x : ℂ)‖ = |x| := by ++ simp [Complex.norm_real, Real.norm_eq_abs] ++ ++lemma norm_I_mul_ofReal (b : ℝ) : ‖Complex.I * (b : ℂ)‖ = |b| := by ++ simp [Complex.norm_I, Complex.norm_real, Real.norm_eq_abs] ++ ++lemma abs_add_Ile (a b : ℝ) : ‖(a : ℂ) + Complex.I * b‖ ≤ |a| + |b| := by ++ ++ have h := Complex.norm_le_abs_re_add_abs_im (a + Complex.I * b) ++ ++ have re_eq : (a + Complex.I * b).re = a := by ++ simp [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.I_im] ++ have im_eq : (a + Complex.I * b).im = b := by ++ simp [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.I_re, Complex.I_im] ++ rw [re_eq, im_eq] at h ++ exact h ++ ++lemma abs_vertical_diff_le_core (z h : ℂ) (τ : ℝ) : ‖((z + h).re - z.re : ℝ) + Complex.I * (τ - z.im)‖ ≤ |(z + h).re - z.re| + |τ - z.im| := by ++ ++ let a : ℝ := (z + h).re - z.re ++ let b : ℝ := τ - z.im ++ ++ have h_eq : ((z + h).re - z.re : ℝ) + Complex.I * (τ - z.im) = (a : ℂ) + Complex.I * (b : ℂ) := by ++ simp only [a, b] ++ ++ rw [← Complex.ofReal_sub τ z.im] ++ ++ rw [h_eq] ++ have triangle := Complex.norm_le_abs_re_add_abs_im ((a : ℂ) + Complex.I * (b : ℂ)) ++ ++ have re_calc : ((a : ℂ) + Complex.I * (b : ℂ)).re = a := by ++ simp only [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.ofReal_im] ++ ring ++ ++ have im_calc : ((a : ℂ) + Complex.I * (b : ℂ)).im = b := by ++ simp only [Complex.add_im, Complex.ofReal_im, Complex.mul_im, Complex.I_im, Complex.ofReal_re] ++ ring ++ ++ rw [re_calc, im_calc] at triangle ++ simp only [a, b] at triangle ++ exact triangle ++ ++lemma abs_vertical_core (z h : ℂ) (τ : ℝ) : ‖(h.re : ℝ) + Complex.I * (τ - z.im)‖ ≤ |h.re| + |τ - z.im| := by ++ ++ have h1 : ‖(h.re : ℝ) + Complex.I * (τ - z.im)‖ ≤ |((h.re : ℝ) + Complex.I * (τ - z.im)).re| + |((h.re : ℝ) + Complex.I * (τ - z.im)).im| := by ++ apply Complex.norm_le_abs_re_add_abs_im ++ ++ have h2 : ((h.re : ℝ) + Complex.I * (τ - z.im)).re = h.re := by simp ++ have h3 : ((h.re : ℝ) + Complex.I * (τ - z.im)).im = τ - z.im := by simp ++ ++ rw [h2, h3] at h1 ++ exact h1 ++ ++lemma S_vert_nonneg (z h : ℂ) (f : ℂ → ℂ) : 0 ≤ S_vert z h f := by ++ unfold S_vert ++ apply Real.sSup_nonneg ++ intro r hr; rcases hr with ⟨τ, hτ, rfl⟩; exact norm_nonneg _ ++ ++lemma abs_im_le_norm (z : ℂ) : |z.im| ≤ ‖z‖ := by ++ exact Complex.abs_im_le_norm z ++ ++lemma mem_closedBall_mono_radius {z : ℂ} {r R : ℝ} (hz : z ∈ Metric.closedBall (0 : ℂ) r) (h : r ≤ R) : z ∈ Metric.closedBall (0 : ℂ) R := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using le_trans (by simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using hz) h ++ ++lemma tendsto_of_nonneg_local_bound {g : ℂ → ℝ} ++ (h_nonneg : ∀ h, 0 ≤ g h) ++ (h_loc : ∀ ε > 0, ∃ δ > 0, ∀ h, ‖h‖ < δ → g h ≤ ε) : ++ Tendsto g (𝓝 (0:ℂ)) (𝓝 (0:ℝ)) := by ++ rw [Metric.tendsto_nhds_nhds] ++ intro ε hε ++ ++ have hε_half : (0 : ℝ) < ε / 2 := by linarith ++ obtain ⟨δ, hδ_pos, hδ⟩ := h_loc (ε / 2) hε_half ++ use δ ++ exact ⟨hδ_pos, fun h hh_dist => by ++ rw [Real.dist_eq, sub_zero] ++ rw [abs_of_nonneg (h_nonneg h)] ++ have : g h ≤ ε / 2 := hδ h (by rwa [Complex.dist_eq, sub_zero] at hh_dist) ++ linarith⟩ ++ ++lemma sum_abs_le_two_mul {x y A : ℝ} (hx : |x| ≤ A) (hy : |y| ≤ A) : |x| + |y| ≤ (2:ℝ) * A := by ++ have := add_le_add hx hy ++ simpa [two_mul] using this ++ ++lemma two_norm_lt_of_norm_lt_half {h : ℂ} {δ : ℝ} (_hpos : 0 < δ) (hbound : ‖h‖ < δ/2) : (2:ℝ) * ‖h‖ < δ := by ++ have := mul_lt_mul_of_pos_left hbound (by norm_num : (0:ℝ) < 2) ++ simpa [two_mul, add_halves] using this ++ ++lemma limit_of_S_is_zero ++ {r1 R R0 : ℝ} ++ (_hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (_hR_lt_R0 : R < R0) (_hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) : ++ Tendsto (fun h => S_max z h f) (𝓝 0) (𝓝 0) := by ++ ++ have f_cont_at_z : ContinuousAt f z := by ++ ++ have hz_in_R : z ∈ Metric.closedBall (0 : ℂ) R := ++ mem_closedBall_mono_radius hz (le_of_lt hr1_lt_R) ++ ++ exact (hf z hz_in_R).continuousAt ++ ++ apply tendsto_of_nonneg_local_bound ++ · ++ exact fun h => S_max_nonneg z h f ++ · ++ intro ε hε_pos ++ ++ rw [Metric.continuousAt_iff] at f_cont_at_z ++ obtain ⟨δ₁, hδ₁_pos, hf_bound⟩ := f_cont_at_z ε hε_pos ++ ++ use δ₁ / 2 ++ constructor ++ · exact half_pos hδ₁_pos ++ · intro h hh_norm ++ ++ unfold S_max ++ apply max_le ++ ++ · unfold S_horiz ++ ++ apply Real.sSup_le ++ · ++ intro r hr ++ obtain ⟨t, ht, rfl⟩ := hr ++ ++ have key_dist : dist ((t : ℂ) + Complex.I * z.im) z < δ₁ := by ++ ++ rw [dist_eq] ++ ++ have eq_transform : ‖(t : ℂ) + Complex.I * z.im - z‖ = |t - z.re| := abs_horizontal_diff_eq_abs_real z t ++ simp [eq_transform] ++ ++ have t_bound : |t - z.re| ≤ |(z + h).re - z.re| := (abs_sub_le_of_mem_uIcc z.re (z + h).re t ht).1 ++ have re_diff_le : |(z + h).re - z.re| ≤ ‖h‖ := by ++ ++ simpa [Complex.add_re, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using (Complex.abs_re_le_norm h) ++ have h_bound : ‖h‖ < δ₁ / 2 := hh_norm ++ calc |t - z.re| ++ _ ≤ |(z + h).re - z.re| := t_bound ++ _ ≤ ‖h‖ := re_diff_le ++ _ < δ₁ / 2 := h_bound ++ _ < δ₁ := by linarith ++ ++ have f_dist := hf_bound key_dist ++ ++ rw [dist_eq] at f_dist ++ ++ exact le_of_lt f_dist ++ · ++ exact le_of_lt hε_pos ++ ++ · unfold S_vert ++ apply Real.sSup_le ++ · ++ intro r hr ++ obtain ⟨τ, hτ, rfl⟩ := hr ++ ++ have key_dist : dist (((z + h).re : ℂ) + Complex.I * τ) z < δ₁ := by ++ rw [dist_eq] ++ ++ have h_eq : (((z + h).re : ℂ) + Complex.I * τ - z) = (h.re : ℝ) + Complex.I * (τ - z.im) := by ++ apply Complex.ext_iff.mpr ++ constructor ++ · simp [Complex.add_re, Complex.sub_re] ++ · simp [Complex.add_im, Complex.sub_im] ++ rw [h_eq] ++ ++ have τ_bound0 : |τ - z.im| ≤ |(z + h).im - z.im| := (abs_sub_le_of_mem_uIcc z.im (z + h).im τ hτ).1 ++ have im_diff_eq : |(z + h).im - z.im| = |h.im| := by ++ simp [Complex.add_im, sub_eq_add_neg, add_assoc] ++ have τ_bound : |τ - z.im| ≤ |h.im| := by simpa [im_diff_eq] using τ_bound0 ++ ++ have vertical_bound : ‖(h.re : ℝ) + Complex.I * (τ - z.im)‖ ≤ |h.re| + |τ - z.im| := ++ abs_vertical_core z h τ ++ have sum_bound : |h.re| + |τ - z.im| ≤ |h.re| + |h.im| := by ++ exact add_le_add_right τ_bound _ ++ have norm_bound := sum_abs_le_two_mul (Complex.abs_re_le_norm h) (Complex.abs_im_le_norm h) ++ have h_bound : ‖h‖ < δ₁ / 2 := hh_norm ++ have final_bound := two_norm_lt_of_norm_lt_half hδ₁_pos h_bound ++ calc ‖(h.re : ℝ) + Complex.I * (τ - z.im)‖ ++ _ ≤ |h.re| + |τ - z.im| := vertical_bound ++ _ ≤ |h.re| + |h.im| := sum_bound ++ _ ≤ (2 : ℝ) * ‖h‖ := norm_bound ++ _ < δ₁ := final_bound ++ ++ have f_dist := hf_bound key_dist ++ rw [dist_eq] at f_dist ++ ++ exact le_of_lt f_dist ++ · ++ exact le_of_lt hε_pos ++ ++lemma eventually_corner_and_sum_in_closedBall {z : ℂ} {R' : ℝ} ++ (hz : ‖z‖ < R') : ++ ∀ᶠ h in 𝓝 (0:ℂ), ++ (z + h) ∈ Metric.closedBall (0 : ℂ) R' ∧ ++ (((z + h).re : ℂ) + Complex.I * z.im) ∈ Metric.closedBall (0 : ℂ) R' := by ++ ++ have hρ_pos : 0 < R' - ‖z‖ := sub_pos.mpr hz ++ have h_small : ∀ᶠ h in 𝓝 (0:ℂ), h ∈ Metric.ball (0 : ℂ) (R' - ‖z‖) := ++ Metric.ball_mem_nhds (0 : ℂ) hρ_pos ++ refine h_small.mono ?_ ++ intro h hhball ++ have hnorm_lt : ‖h‖ < R' - ‖z‖ := by ++ simpa [Metric.mem_ball, Complex.dist_eq, sub_zero] using hhball ++ ++ have hsum_lt : ‖z‖ + ‖h‖ < R' := by ++ have htemp : ‖z‖ + ‖h‖ < ‖z‖ + (R' - ‖z‖) := add_lt_add_right hnorm_lt _ ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using htemp ++ have hzph_le : ‖z + h‖ ≤ R' := ++ le_of_lt (lt_of_le_of_lt (norm_add_le _ _) hsum_lt) ++ have hzph_mem : (z + h) ∈ Metric.closedBall (0 : ℂ) R' := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using hzph_le ++ ++ let w : ℂ := ((z + h).re : ℂ) + Complex.I * z.im ++ ++ have tri : ‖w‖ ≤ ‖w - z‖ + ‖z‖ := by ++ have := norm_add_le (w - z) z ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ ++ let t : ℝ := (z + h).re ++ have hwz_eq : w - z = (t : ℂ) + Complex.I * z.im - z := by ++ simp [w, t, sub_eq_add_neg, add_assoc] ++ have eq_transform : ‖(t : ℂ) + Complex.I * z.im - z‖ = |t - z.re| := ++ abs_horizontal_diff_eq_abs_real z t ++ have t_sub_re : t - z.re = h.re := by ++ simp [t, Complex.add_re, sub_eq_add_neg, add_assoc] ++ have hwz_abs2 : ‖w - z‖ = |h.re| := by ++ simpa [hwz_eq, t_sub_re] using eq_transform ++ have hwz_le : ‖w - z‖ ≤ ‖h‖ := by ++ simpa [hwz_abs2] using (Complex.abs_re_le_norm h) ++ have hw_le'' : ‖w‖ ≤ ‖h‖ + ‖z‖ := by ++ exact le_trans tri (add_le_add_left hwz_le _) ++ have hw_lt : ‖w‖ < R' := by ++ have : ‖h‖ + ‖z‖ < R' := by simpa [add_comm] using hsum_lt ++ exact lt_of_le_of_lt hw_le'' this ++ have hw_mem : w ∈ Metric.closedBall (0 : ℂ) R' := by ++ simpa [w, Metric.mem_closedBall, Complex.dist_eq, sub_zero] using (le_of_lt hw_lt) ++ exact And.intro hzph_mem hw_mem ++ ++lemma limit_of_Err_ratio_is_zero ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) r1) : ++ Tendsto (fun h => Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h / h) (𝓝 0) (𝓝 0) := by ++ ++ set g : ℂ → ℂ := fun h => Err hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf z h / h ++ ++ have hS : Tendsto (fun h => S_max z h f) (𝓝 0) (𝓝 0) := ++ limit_of_S_is_zero (r1:=r1) (R:=R) (R0:=R0) hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hf hz ++ ++ have h_upper : Tendsto (fun h => |(2 : ℝ) * S_max z h f|) (𝓝 0) (𝓝 0) := by ++ have hcont : Continuous fun x : ℝ => |(2 : ℝ) * x| := ++ (continuous_const.mul continuous_id).abs ++ have h0 := hcont.tendsto (0 : ℝ) ++ simpa only [Function.comp_def, mul_zero, abs_zero] using h0.comp hS ++ ++ have h_lower_nonneg : ∀ᶠ h in 𝓝 0, 0 ≤ ‖g h‖ := ++ Filter.Eventually.of_forall (fun _ => by simpa [g] using (norm_nonneg (g _))) ++ ++ let δ : ℝ := (R - r1) / 2 ++ have hδ_pos : 0 < δ := by ++ have : 0 < R - r1 := sub_pos.mpr hr1_lt_R ++ simpa [δ] using half_pos this ++ let R' : ℝ := r1 + δ ++ have hR'_pos : 0 < R' := by ++ have : 0 < r1 + δ := add_pos_of_pos_of_nonneg hr1_pos (le_of_lt hδ_pos) ++ simpa [R'] using this ++ have hR'_lt_R : R' < R := by ++ have hδlt : δ < R - r1 := by ++ simpa [δ] using (half_lt_self (sub_pos.mpr hr1_lt_R)) ++ have : r1 + δ < r1 + (R - r1) := add_lt_add_right hδlt r1 ++ simpa [R', sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ ++ have hz_le_r1 : ‖z‖ ≤ r1 := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using hz ++ have hz' : z ∈ Metric.closedBall (0 : ℂ) R' := by ++ have hr1_le_R' : r1 ≤ R' := by ++ have : 0 ≤ δ := le_of_lt hδ_pos ++ simpa [R'] using (le_add_of_nonneg_right this : r1 ≤ r1 + δ) ++ have : ‖z‖ ≤ R' := le_trans hz_le_r1 hr1_le_R' ++ simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using this ++ ++ have h_event : ∀ᶠ h in 𝓝 0, ‖g h‖ ≤ |(2 : ℝ) * S_max z h f| := by ++ ++ have hcorner := eventually_corner_and_sum_in_closedBall (z:=z) (R':=R') (hz := by ++ ++ have : ‖z‖ ≤ r1 := hz_le_r1 ++ exact lt_of_le_of_lt this (by simpa [R'] using (lt_add_of_pos_right r1 hδ_pos))) ++ refine hcorner.mono ?_ ++ intro h hh ++ have hzh' : z + h ∈ Metric.closedBall (0 : ℂ) R' := hh.1 ++ have hw' : ((z + h).re : ℂ) + Complex.I * z.im ∈ Metric.closedBall (0 : ℂ) R' := hh.2 ++ by_cases hh0 : h = 0 ++ · have : 0 ≤ |(2 : ℝ) * S_max z h f| := abs_nonneg _ ++ simp [g, hh0, div_zero, norm_zero] ++ · ++ have hb := ++ bound_on_Err_ratio (r1:=R') (R:=R) (R0:=R0) ++ hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one hf (z:=z) (h:=h) hz' hzh' hw' hh0 ++ have hb' : ‖g h‖ ≤ 2 * S_max z h f := by ++ simpa [g, norm, Err] using hb ++ exact le_trans hb' (le_abs_self ((2 : ℝ) * S_max z h f)) ++ ++ have h_norm_tendsto : Tendsto (fun h => ‖g h‖) (𝓝 0) (𝓝 0) := by ++ refine Filter.Tendsto.squeeze' tendsto_const_nhds h_upper h_lower_nonneg h_event ++ ++ have h_dist_tendsto : Tendsto (fun h => dist (g h) 0) (𝓝 0) (𝓝 0) := by ++ simpa [dist_eq_norm] using h_norm_tendsto ++ simpa [g] using (tendsto_iff_dist_tendsto_zero).2 h_dist_tendsto ++ ++open Classical ++ ++noncomputable def If_ext ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ (f : ℂ → ℂ) ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) : ℂ → ℂ := ++ fun w => ++ if h : w ∈ Metric.closedBall (0 : ℂ) r1 then ++ If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, h⟩ ++ else ++ 0 ++ ++lemma If_ext_eq_taxicab_of_mem {r1 R R0 : ℝ} (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ (f : ℂ → ℂ) ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {w : ℂ} (hw : w ∈ Metric.closedBall (0 : ℂ) r1) : ++ If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf w ++ = If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ := by ++ classical ++ simp [If_ext, hw] ++ ++lemma If_taxicab_param_invariance {r1₁ r1₂ R R0 : ℝ} ++ (hr1₁_pos : 0 < r1₁) (hr1₁_lt_R : r1₁ < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ (hr1₂_pos : 0 < r1₂) (hr1₂_lt_R : r1₂ < R) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {w : ℂ} ++ (hw₁ : w ∈ Metric.closedBall (0 : ℂ) r1₁) ++ (hw₂ : w ∈ Metric.closedBall (0 : ℂ) r1₂) : ++ If_taxicab hr1₁_pos hr1₁_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw₁⟩ ++ = If_taxicab hr1₂_pos hr1₂_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw₂⟩ := by ++ ++ simp [If_taxicab] ++ ++lemma derivWithin_eq_deriv_of_isOpen_mem {s : Set ℂ} (hs : IsOpen s) {f : ℂ → ℂ} {z : ℂ} ++ (hz : z ∈ s) : derivWithin f s z = deriv f z := by ++ simpa using (derivWithin_of_isOpen (f := f) (s := s) (x := z) hs hz) ++ ++lemma eventually_decomposition_for_ext ++ {R' R R0 : ℝ} (hR'_pos : 0 < R') (hR'_lt_R : R' < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ (z : ℂ) (hz : ‖z‖ < R') : ++ ∀ᶠ h in 𝓝 (0:ℂ), ++ let g := If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ++ g (z + h) - g z = f z * h + Err hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf z h := by ++ ++ have h_event := eventually_corner_and_sum_in_closedBall (z:=z) (R':=R') hz ++ refine h_event.mono ?_ ++ intro h hh ++ ++ let g := If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ++ ++ have hz' : z ∈ Metric.closedBall (0 : ℂ) R' := by ++ have : ‖z‖ ≤ R' := le_of_lt hz ++ simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using this ++ ++ have hgzh : g (z + h) ++ = If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hh.1⟩ := by ++ simpa [g] using ++ If_ext_eq_taxicab_of_mem (r1:=R') (R:=R) (R0:=R0) hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf (w:=z + h) hh.1 ++ have hgz : g z ++ = If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz'⟩ := by ++ simpa [g] using ++ If_ext_eq_taxicab_of_mem (r1:=R') (R:=R) (R0:=R0) hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf (w:=z) hz' ++ ++ have H := ++ If_diff_decomposition_final (r1:=R') (R:=R) (R0:=R0) ++ hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one (f:=f) (hf:=hf) ++ (z:=z) (h:=h) ++ (hz:=hz') (hzh:=hh.1) (hw:=hh.2) ++ ++ calc ++ g (z + h) - g z ++ = If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hh.1⟩ ++ - If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz'⟩ := by ++ simp [hgzh, hgz] ++ _ = f z * h + Err hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf z h := by ++ simpa using H ++ ++lemma tendsto_Err_ratio_radius (R' R R0 : ℝ) (hR'_pos : 0 < R') (hR'_lt_R : R' < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z : ℂ} (hz : ‖z‖ < R') : ++ Tendsto (fun h => Err hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf z h / h) (𝓝 0) (𝓝 0) := by ++ ++ have hz' : z ∈ Metric.closedBall (0 : ℂ) R' := by ++ have : ‖z‖ ≤ R' := le_of_lt hz ++ simpa [Metric.mem_closedBall, Complex.dist_eq, sub_zero] using this ++ ++ simpa using ++ (limit_of_Err_ratio_is_zero (r1:=R') (R:=R) (R0:=R0) ++ hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one hf (z:=z) (hz:=hz')) ++ ++lemma If_ext_eq_taxicab_at_sum {R' R R0 : ℝ} (hR'_pos : 0 < R') (hR'_lt_R : R' < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z h : ℂ} ++ (hzh : z + h ∈ Metric.closedBall (0 : ℂ) R') : ++ If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf (z + h) ++ = If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z + h, hzh⟩ := by ++ simpa using ++ (If_ext_eq_taxicab_of_mem (r1:=R') (R:=R) (R0:=R0) ++ hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one (f:=f) (hf:=hf) (w:=z + h) hzh) ++ ++lemma If_ext_eq_taxicab_at_point {R' R R0 : ℝ} (hR'_pos : 0 < R') (hR'_lt_R : R' < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) ++ {z : ℂ} (hz : z ∈ Metric.closedBall (0 : ℂ) R') : ++ If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf z ++ = If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨z, hz⟩ := by ++ simpa using ++ (If_ext_eq_taxicab_of_mem (r1:=R') (R:=R) (R0:=R0) ++ hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one (f:=f) (hf:=hf) (w:=z) hz) ++ ++lemma hasDerivWithinAt_congr_eqOn {f g : ℂ → ℂ} {s : Set ℂ} {z f' : ℂ} ++ (hEq : Set.EqOn f g s) (hz : z ∈ s) : ++ HasDerivWithinAt g f' s z → HasDerivWithinAt f f' s z := by ++ intro hg ++ have hfg : ∀ x ∈ s, f x = g x := fun x hx => hEq hx ++ simpa using (HasDerivWithinAt.congr_of_mem (h := hg) (hs := hfg) (hx := hz)) ++ ++lemma differentiableOn_of_hasDerivWithinAt {f : ℂ → ℂ} {s : Set ℂ} {F : ℂ → ℂ} ++ (h : ∀ z ∈ s, HasDerivWithinAt f (F z) s z) : DifferentiableOn ℂ f s := by ++ intro z hz ++ exact (h z hz).differentiableWithinAt ++ ++lemma If_ext_agree_on_smallBall {r1 R' R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hR'_pos : 0 < R') (hr1_lt_R : r1 < R) (hR'_lt_R : R' < R) (hr1_lt_R' : r1 < R') (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) : ++ Set.EqOn (If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf) ++ (If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf) ++ (Metric.closedBall (0 : ℂ) r1) := by ++ intro w hw ++ ++ have hw' : w ∈ Metric.closedBall (0 : ℂ) R' := ++ mem_closedBall_mono_radius (z:=w) (r:=r1) (R:=R') hw (le_of_lt hr1_lt_R') ++ ++ have hleft : ++ If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf w ++ = If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ := by ++ simpa using ++ (If_ext_eq_taxicab_of_mem (r1:=r1) (R:=R) (R0:=R0) ++ hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf (w:=w) hw) ++ have hright : ++ If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf w ++ = If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw'⟩ := by ++ simpa using ++ (If_ext_eq_taxicab_of_mem (r1:=R') (R:=R) (R0:=R0) ++ hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf (w:=w) hw') ++ ++ have hparam := ++ If_taxicab_param_invariance (r1₁:=r1) (r1₂:=R') (R:=R) (R0:=R0) ++ hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one hR'_pos hR'_lt_R hf (w:=w) hw hw' ++ ++ calc ++ If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf w ++ = If_taxicab hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw⟩ := hleft ++ _ = If_taxicab hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ⟨w, hw'⟩ := hparam ++ _ = If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf w := by ++ simpa using hright.symm ++ ++lemma hasDerivAt_of_local_decomposition' (g : ℂ → ℂ) (z F : ℂ) ++ (Err_func : ℂ → ℂ) ++ (hdecomp : ∀ᶠ h in 𝓝 (0:ℂ), g (z + h) - g z = F * h + Err_func h) ++ (hErr : Tendsto (fun h => Err_func h / h) (𝓝 (0:ℂ)) (𝓝 (0:ℂ))) : ++ HasDerivAt g F z := by ++ ++ have hdecomp_within : ∀ᶠ h in 𝓝[≠] (0:ℂ), g (z + h) - g z = F * h + Err_func h := ++ (hdecomp.filter_mono (nhdsWithin_le_nhds : 𝓝[≠] (0:ℂ) ≤ 𝓝 (0:ℂ))) ++ ++ have h_ne0 : ∀ᶠ h in 𝓝[≠] (0:ℂ), h ≠ 0 := by ++ filter_upwards [eventually_mem_nhdsWithin (a := (0 : ℂ)) (s := ({0}ᶜ : Set ℂ))] with h hh ++ simpa only [Set.mem_compl_iff, Set.mem_singleton_iff] using hh ++ ++ have h_eq_slope : ∀ᶠ h in 𝓝[≠] (0:ℂ), ++ h⁻¹ • (g (z + h) - g z) = F + Err_func h / h := by ++ refine (hdecomp_within.and h_ne0).mono ?_ ++ intro h hh ++ rcases hh with ⟨hEq, hne⟩ ++ ++ have H0 : h⁻¹ • (g (z + h) - g z) = h⁻¹ • (F * h + Err_func h) := by ++ simpa using congrArg (fun x => h⁻¹ • x) hEq ++ ++ have h1 : h⁻¹ * (F * h) = F := by ++ have hne' : h ≠ 0 := hne ++ calc ++ h⁻¹ * (F * h) = F * (h⁻¹ * h) := by ++ ac_rfl ++ _ = F * 1 := by simp [hne'] ++ _ = F := by simp ++ have h2 : h⁻¹ * Err_func h = Err_func h / h := by ++ simp [div_eq_mul_inv, mul_comm] ++ calc ++ h⁻¹ • (g (z + h) - g z) ++ = h⁻¹ • (F * h + Err_func h) := H0 ++ _ = h⁻¹ * (F * h + Err_func h) := by simp [smul_eq_mul] ++ _ = h⁻¹ * (F * h) + h⁻¹ * (Err_func h) := by simp [mul_add] ++ _ = F + Err_func h / h := by simp [h1, h2] ++ ++ have hErr_within : Tendsto (fun h => Err_func h / h) (𝓝[≠] (0:ℂ)) (𝓝 (0:ℂ)) := ++ hErr.mono_left (nhdsWithin_le_nhds : 𝓝[≠] (0:ℂ) ≤ 𝓝 (0:ℂ)) ++ have h_const : Tendsto (fun _ : ℂ => F) (𝓝[≠] (0:ℂ)) (𝓝 F) := tendsto_const_nhds ++ have h_sum : Tendsto (fun h => F + Err_func h / h) (𝓝[≠] (0:ℂ)) (𝓝 (F + 0)) := ++ h_const.add hErr_within ++ have h_target : Tendsto (fun h => h⁻¹ • (g (z + h) - g z)) (𝓝[≠] (0:ℂ)) (𝓝 F) := by ++ have := (Filter.tendsto_congr' h_eq_slope).2 h_sum ++ simpa [zero_add] using this ++ ++ exact (hasDerivAt_iff_tendsto_slope_zero).2 h_target ++ ++lemma uniqueDiffWithinAt_convex_complex {s : Set ℂ} (hconv : Convex ℝ s) ++ (hs : (interior s).Nonempty) {x : ℂ} (hx : x ∈ closure s) : ++ UniqueDiffWithinAt ℂ s x := by ++ ++ have hR : UniqueDiffWithinAt ℝ s x := ++ uniqueDiffWithinAt_convex (E := ℂ) (conv := hconv) (hs := hs) (x := x) (hx := hx) ++ ++ have dR : Dense ((Submodule.span ℝ (tangentConeAt ℝ s x) : Submodule ℝ ℂ) : Set ℂ) := by ++ simpa using (hR.dense_tangentConeAt) ++ ++ have h_tc_subset : tangentConeAt ℝ s x ⊆ tangentConeAt ℂ s x := ++ tangentConeAt_mono_field ++ ++ set TC : Set ℂ := tangentConeAt ℂ s x ++ set Sℂ : Submodule ℂ ℂ := Submodule.span ℂ TC ++ set Sℝ : Submodule ℝ ℂ := Sℂ.restrictScalars ℝ ++ have h_span_le : (Submodule.span ℝ (tangentConeAt ℝ s x) : Submodule ℝ ℂ) ≤ Sℝ := by ++ ++ refine Submodule.span_le.mpr ?_ ++ intro v hv ++ have hv' : v ∈ TC := h_tc_subset hv ++ have : v ∈ Sℂ := Submodule.subset_span hv' ++ simpa [Sℝ] using this ++ ++ have hsubset_sets : ++ ((Submodule.span ℝ (tangentConeAt ℝ s x) : Submodule ℝ ℂ) : Set ℂ) ++ ⊆ ((Sℂ : Submodule ℂ ℂ) : Set ℂ) := by ++ intro z hz ++ have hz' : z ∈ Sℝ := h_span_le hz ++ simpa [Sℝ] using hz' ++ have dC : Dense ((Sℂ : Submodule ℂ ℂ) : Set ℂ) := dR.mono hsubset_sets ++ ++ exact ⟨dC, hx⟩ ++ ++lemma interior_closedBall_nonempty_of_pos {R : ℝ} (hR_pos : 0 < R) : ++ (interior (Metric.closedBall (0 : ℂ) R)).Nonempty := by ++ ++ have h0mem : (0 : ℂ) ∈ Metric.ball (0 : ℂ) R := by ++ simpa [Metric.mem_ball, Complex.dist_eq, sub_zero] using hR_pos ++ ++ have hsub : Metric.ball (0 : ℂ) R ⊆ interior (Metric.closedBall (0 : ℂ) R) := ++ Metric.ball_subset_interior_closedBall ++ ++ exact ⟨0, hsub h0mem⟩ ++ ++lemma mem_closure_of_mem_closedBall {R : ℝ} {z : ℂ} ++ (hz : z ∈ Metric.closedBall (0 : ℂ) R) : ++ z ∈ closure (Metric.closedBall (0 : ℂ) R) := by ++ exact subset_closure hz ++ ++lemma uniqueDiffWithinAt_closedBall_complex_of_mem {R : ℝ} {z : ℂ} ++ (hR_pos : 0 < R) (hz : z ∈ Metric.closedBall (0 : ℂ) R) : ++ UniqueDiffWithinAt ℂ (Metric.closedBall (0 : ℂ) R) z := ++by ++ ++ have hconv : Convex ℝ (Metric.closedBall (0 : ℂ) R) := ++ convex_closedBall (0 : ℂ) R ++ ++ have hnonempty : (interior (Metric.closedBall (0 : ℂ) R)).Nonempty := ++ interior_closedBall_nonempty_of_pos (R := R) hR_pos ++ ++ have hz_cl : z ∈ closure (Metric.closedBall (0 : ℂ) R) := ++ mem_closure_of_mem_closedBall (R := R) (z := z) hz ++ ++ exact uniqueDiffWithinAt_convex_complex hconv hnonempty hz_cl ++ ++lemma If_is_differentiable_on ++ {r1 R R0 : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R : r1 < R) (hR_lt_R0 : R < R0) (hR0_lt_one : R0 < 1) ++ {f : ℂ → ℂ} ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R)) : ++ DifferentiableOn ℂ (If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf) (Metric.closedBall (0 : ℂ) r1) ++ ∧ ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ derivWithin (If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf) (Metric.closedBall (0 : ℂ) r1) z = f z := by ++ set s : Set ℂ := Metric.closedBall (0 : ℂ) r1 ++ have hHasDerivWithinAt : ∀ z ∈ s, ++ HasDerivWithinAt (If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf) (f z) s z := by ++ intro z hz ++ ++ let δ : ℝ := (R - r1) / 2 ++ have hδ_pos : 0 < δ := by ++ have : 0 < R - r1 := sub_pos.mpr hr1_lt_R ++ simpa [δ] using half_pos this ++ let R' : ℝ := r1 + δ ++ have hR'_pos : 0 < R' := by ++ have : 0 < r1 + δ := add_pos_of_pos_of_nonneg hr1_pos (le_of_lt hδ_pos) ++ simpa [R'] using this ++ have hR'_lt_R : R' < R := by ++ have hδlt : δ < R - r1 := by ++ have : 0 < R - r1 := sub_pos.mpr hr1_lt_R ++ simpa [δ] using (half_lt_self this) ++ have : r1 + δ < r1 + (R - r1) := add_lt_add_right hδlt r1 ++ simpa [R', sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ have hr1_lt_R' : r1 < R' := by ++ have : r1 < r1 + δ := by simpa [add_comm, add_left_comm, add_assoc, R', δ] using (lt_of_le_of_lt (le_of_eq rfl) (add_lt_add_right hδ_pos r1)) ++ simpa [R'] using this ++ ++ have hz_le_r1 : ‖z‖ ≤ r1 := by ++ simpa [s, Metric.mem_closedBall, Complex.dist_eq, sub_zero] using hz ++ have hz_lt_R' : ‖z‖ < R' := lt_of_le_of_lt hz_le_r1 (by simpa [R'] using (lt_add_of_pos_right r1 hδ_pos)) ++ ++ let g := If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf ++ ++ have hdecomp := eventually_decomposition_for_ext (R':=R') (R:=R) (R0:=R0) hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one hf z hz_lt_R' ++ ++ have hErr := tendsto_Err_ratio_radius (R':=R') (R:=R) (R0:=R0) hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one hf hz_lt_R' ++ ++ have hDerivAt_g : HasDerivAt g (f z) z := ++ hasDerivAt_of_local_decomposition' (g := g) (z := z) (F := f z) ++ (Err_func := fun h => Err hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf z h) ++ (hdecomp := by ++ ++ simpa [g] using hdecomp) ++ (hErr := by ++ ++ simpa using hErr) ++ ++ have hWithin_g : HasDerivWithinAt g (f z) s z := hDerivAt_g.hasDerivWithinAt ++ ++ have hEq : Set.EqOn (If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf) ++ (If_ext hR'_pos hR'_lt_R hR_lt_R0 hR0_lt_one f hf) ++ s := ++ If_ext_agree_on_smallBall (r1:=r1) (R':=R') (R:=R) (R0:=R0) ++ hr1_pos hR'_pos hr1_lt_R hR'_lt_R hr1_lt_R' hR_lt_R0 hR0_lt_one hf ++ ++ exact hasDerivWithinAt_congr_eqOn (f := If_ext hr1_pos hr1_lt_R hR_lt_R0 hR0_lt_one f hf) ++ (g := g) (s := s) (z := z) (f' := f z) hEq hz hWithin_g ++ ++ refine And.intro ?hdiff ?hderiv ++ · ++ apply differentiableOn_of_hasDerivWithinAt ++ intro z hz ++ exact hHasDerivWithinAt z hz ++ · ++ intro z hz ++ have hUD : UniqueDiffWithinAt ℂ s z := ++ uniqueDiffWithinAt_closedBall_complex_of_mem (R := r1) hr1_pos (z := z) (hz := by simpa [s] using hz) ++ have hD := hHasDerivWithinAt z hz ++ simpa using hD.derivWithin hUD ++ ++open scoped Topology ++ ++theorem AnalyticOnNhd.mono_closedBall {B : ℂ → ℂ} {R : ℝ} (R' : ℝ) ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall 0 R)) (hR' : R' < R) : ++ AnalyticOnNhd ℂ B (Metric.closedBall 0 R') := by ++ ++ exact hB.mono (Metric.closedBall_subset_closedBall (le_of_lt hR')) ++ ++lemma log_deriv_is_analytic ++ {r1 R' R : ℝ} ++ (_hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (_hR'_lt_R : R' < R) (_hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R')) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, B z ≠ 0) : ++ AnalyticOnNhd ℂ (fun z => deriv B z / B z) (Metric.closedBall (0 : ℂ) r1) := by ++ have step1 : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) r1) := by simp [AnalyticOnNhd.mono_closedBall r1 hB hr1_lt_R'] ++ have hderiv : AnalyticOnNhd ℂ (deriv B) (Metric.closedBall (0 : ℂ) r1) := by ++ apply AnalyticOnNhd.deriv step1 ++ ++ simpa using AnalyticOnNhd.div hderiv step1 hB_ne_zero ++ ++lemma I_is_antiderivative ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) : ++ ∃ J : ℂ → ℂ, AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1) ∧ ++ J 0 = 0 ∧ ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z := by ++ classical ++ ++ have hB_on_R' : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R') := ++ AnalyticOnNhd.mono_closedBall R' hB hR'_lt_R ++ have hderiv_on_R' : AnalyticOnNhd ℂ (deriv B) (Metric.closedBall (0 : ℂ) R') := ++ AnalyticOnNhd.deriv hB_on_R' ++ let L : ℂ → ℂ := fun z => deriv B z / B z ++ have hL_on_R' : AnalyticOnNhd ℂ L (Metric.closedBall (0 : ℂ) R') := by ++ simpa [L] using AnalyticOnNhd.div hderiv_on_R' hB_on_R' hB_ne_zero ++ ++ let δ : ℝ := (R' - r1) / 2 ++ have hδ_pos : 0 < δ := by ++ have : 0 < R' - r1 := sub_pos.mpr hr1_lt_R' ++ simpa [δ] using half_pos this ++ let R_mid : ℝ := r1 + δ ++ have hR_mid_pos : 0 < R_mid := by ++ have : 0 < r1 + δ := add_pos_of_pos_of_nonneg hr1_pos (le_of_lt hδ_pos) ++ simpa [R_mid] using this ++ have hr1_lt_R_mid : r1 < R_mid := by ++ have : 0 < δ := hδ_pos ++ simpa [R_mid] using (lt_add_of_pos_right r1 this) ++ have hR_mid_lt_R' : R_mid < R' := by ++ have hδlt : δ < R' - r1 := by ++ simpa [δ] using (half_lt_self (sub_pos.mpr hr1_lt_R')) ++ have : r1 + δ < r1 + (R' - r1) := add_lt_add_right hδlt r1 ++ simpa [R_mid, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ ++ let J : ℂ → ℂ := ++ If_ext (r1 := R_mid) (R := R') (R0 := R) hR_mid_pos hR_mid_lt_R' hR'_lt_R hR_lt_one L hL_on_R' ++ ++ have hIf := ++ (If_is_differentiable_on (r1 := R_mid) (R := R') (R0 := R) ++ hR_mid_pos hR_mid_lt_R' hR'_lt_R hR_lt_one (f := L) hL_on_R') ++ have hDiffOn_mid : DifferentiableOn ℂ J (Metric.closedBall (0 : ℂ) R_mid) := by ++ simpa [J] using hIf.1 ++ ++ have hDiffOn_ball_R_mid : DifferentiableOn ℂ J (Metric.ball (0 : ℂ) R_mid) := ++ hDiffOn_mid.mono Metric.ball_subset_closedBall ++ ++ have hJ_analyticOnNhd : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1) := by ++ intro z hz ++ ++ have hz_le : dist z (0 : ℂ) ≤ r1 := by ++ simpa [Metric.mem_closedBall] using hz ++ have hz_lt : dist z (0 : ℂ) < R_mid := lt_of_le_of_lt hz_le hr1_lt_R_mid ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) R_mid := by simpa [Metric.mem_ball] using hz_lt ++ ++ exact (DifferentiableOn.analyticAt (s := Metric.ball (0 : ℂ) R_mid) ++ (f := J) hDiffOn_ball_R_mid (Metric.isOpen_ball.mem_nhds hz_ball)) ++ ++ have h0_in_mid : (0 : ℂ) ∈ Metric.closedBall (0 : ℂ) R_mid := by ++ simpa [Metric.mem_closedBall, dist_self] using (le_of_lt hR_mid_pos) ++ have hJ0 : J 0 = 0 := by ++ simp [J, If_ext, If_taxicab, h0_in_mid] ++ ++ have hderiv_eq : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = L z := by ++ intro z hz ++ ++ have hz_le : dist z (0 : ℂ) ≤ r1 := by simpa [Metric.mem_closedBall] using hz ++ have hz_lt : dist z (0 : ℂ) < R_mid := lt_of_le_of_lt hz_le hr1_lt_R_mid ++ have hz_ball : z ∈ Metric.ball (0 : ℂ) R_mid := by simpa [Metric.mem_ball] using hz_lt ++ have hz_cb_mid : z ∈ Metric.closedBall (0 : ℂ) R_mid := Metric.ball_subset_closedBall hz_ball ++ ++ have h_cb_nhds : Metric.closedBall (0 : ℂ) R_mid ∈ 𝓝 z := ++ Filter.mem_of_superset (Metric.isOpen_ball.mem_nhds hz_ball) Metric.ball_subset_closedBall ++ ++ have hDW_eq_L : derivWithin J (Metric.closedBall (0 : ℂ) R_mid) z = L z := by ++ simpa [J] using hIf.2 z hz_cb_mid ++ ++ have hHasWithin : HasDerivWithinAt J (derivWithin J (Metric.closedBall (0 : ℂ) R_mid) z) ++ (Metric.closedBall (0 : ℂ) R_mid) z := ++ (hDiffOn_mid z hz_cb_mid).hasDerivWithinAt ++ have hHasWithinL : HasDerivWithinAt J (L z) (Metric.closedBall (0 : ℂ) R_mid) z := by ++ simpa [hDW_eq_L] ++ using hHasWithin ++ ++ have hHasDerivAt : HasDerivAt J (L z) z := ++ HasDerivWithinAt.hasDerivAt hHasWithinL h_cb_nhds ++ ++ simpa using hHasDerivAt.deriv ++ ++ refine ⟨J, hJ_analyticOnNhd, hJ0, ?_⟩ ++ intro z hz ++ simpa [L] using hderiv_eq z hz ++ ++noncomputable def H_auxiliary ++ {r1 R' R : ℝ} ++ (_hr1_pos : 0 < r1) (_hr1_lt_R' : r1 < R') (_hR'_lt_R : R' < R) (_hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (_hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (_hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ (J : ℂ → ℂ) : ℂ → ℂ := ++ fun z => Complex.exp (J z) / B z ++ ++lemma exp_I_at_zero ++ {r1 R' R : ℝ} ++ (_hr1_pos : 0 < r1) (_hr1_lt_R' : r1 < R') (_hR'_lt_R : R' < R) (_hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (_hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (_hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (_hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (_hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ Complex.exp (J 0) = 1 := by ++ simp [hJ_zero] ++ ++lemma H_at_zero ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (_hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (_hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J 0 = 1 / B 0 := by ++ simp [H_auxiliary, hJ_zero] ++ ++lemma log_deriv_id ++ {r1 R' R : ℝ} ++ (_hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (_hR'_lt_R : R' < R) (_hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (_hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (_hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (_hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z * B z = deriv B z := by ++ intro z hz ++ ++ have hzR : z ∈ Metric.closedBall (0 : ℂ) R' := by ++ have hzR' : dist z (0 : ℂ) ≤ r1 := hz ++ have hR'_le : r1 ≤ R' := le_of_lt (hr1_lt_R') ++ have hzR'' : dist z (0 : ℂ) ≤ R' := le_trans hzR' hR'_le ++ simpa using hzR'' ++ have hBnz : B z ≠ 0 := hB_ne_zero z hzR ++ have hJd := hJ_deriv z hz ++ have hmult := congrArg (fun t => t * B z) hJd ++ have hR2 : (deriv B z / B z) * B z = deriv B z * B z / B z := by ++ simpa using (div_mul_eq_mul_div (deriv B z) (B z) (B z)) ++ have hmult' : deriv J z * B z = deriv B z * B z / B z := by ++ simpa [hR2] using hmult ++ have hdiv' : deriv B z * B z / B z = deriv B z := by ++ field_simp [hBnz] ++ calc ++ deriv J z * B z = deriv B z * B z / B z := hmult' ++ _ = deriv B z := by simpa using hdiv' ++ ++lemma log_deriv_identity ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z * B z - deriv B z = 0 := by ++ intro z hz ++ have h_eq := log_deriv_id hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ rw [h_eq] ++ simp ++ ++lemma H_derivative_quotient_rule ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (_hJ_zero : J 0 = 0) ++ (_hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ deriv (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) z = ++ (deriv (fun w => Complex.exp (J w)) z * B z - deriv B z * Complex.exp (J z)) / (B z)^2 := by ++ intro z hz ++ ++ have hzR : z ∈ Metric.closedBall (0 : ℂ) R' := by ++ have hzR' : dist z (0 : ℂ) ≤ r1 := hz ++ have hR_le : r1 ≤ R' := le_of_lt (hr1_lt_R') ++ have hzR'' : dist z (0 : ℂ) ≤ R' := le_trans hzR' hR_le ++ simpa using hzR'' ++ ++ have hB_nz : B z ≠ 0 := hB_ne_zero z hzR ++ have hB' : AnalyticOnNhd ℂ B (Metric.closedBall 0 R') := by ++ apply AnalyticOnNhd.mono_closedBall R' hB ++ assumption ++ have hB_diff : DifferentiableAt ℂ B z := (hB' z hzR).differentiableAt ++ have hJ_diff : DifferentiableAt ℂ J z := (hJ z hz).differentiableAt ++ have hF_diff : DifferentiableAt ℂ (fun w => Complex.exp (J w)) z := hJ_diff.cexp ++ ++ have h := deriv_div (hc := hF_diff) (hd := hB_diff) (hx := hB_nz) ++ unfold H_auxiliary ++ simpa only [Pi.div_def, mul_comm] using h ++ ++lemma exp_I_derivative_chain_rule ++ {r1 R' R : ℝ} ++ (_hr1_pos : 0 < r1) (_hr1_lt_R' : r1 < R') (_hR'_lt_R : R' < R) (_hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (_hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (_hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (_hJ_zero : J 0 = 0) ++ (_hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ deriv (fun w => Complex.exp (J w)) z = deriv J z * Complex.exp (J z) := by ++ intro z hz ++ have hJ_diff : DifferentiableAt ℂ J z := (hJ z hz).differentiableAt ++ have hJ_has : HasDerivAt J (deriv J z) z := hJ_diff.hasDerivAt ++ have hcomp := (Complex.hasDerivAt_exp (J z)).comp z hJ_has ++ ++ simpa only [Function.comp_def, mul_comm] using hcomp.deriv ++ ++lemma H_derivative_calc ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ deriv (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) z = ++ (deriv J z * B z - deriv B z) * Complex.exp (J z) / (B z)^2 := by ++ intro z hz ++ ++ have hquot := H_derivative_quotient_rule hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ ++ have hchain := exp_I_derivative_chain_rule hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ ++ rw [hquot, hchain] ++ ++ have h1 : deriv J z * Complex.exp (J z) * B z - deriv B z * Complex.exp (J z) = ++ Complex.exp (J z) * (deriv J z * B z - deriv B z) := by ring ++ rw [h1] ++ ++ ring ++ ++lemma H_derivative_is_zero ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ deriv (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) z = 0 := by ++ intro z hz ++ have hcalc := ++ H_derivative_calc hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ have hident := ++ log_deriv_identity hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ simpa [hident] using hcalc ++ ++lemma zero_mem_closedBall_zero_radius {r1 : ℝ} (hr1 : 0 ≤ r1) : (0 : ℂ) ∈ Metric.closedBall (0 : ℂ) r1 := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hr1 ++ ++lemma H_deriv_zero_on_closedBall ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ deriv (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) z = 0 := by ++ simpa using ++ (H_derivative_is_zero hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv) ++ ++lemma H_auxiliary_differentiableOn_closedBall ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) : ++ DifferentiableOn ℂ (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (Metric.closedBall (0 : ℂ) r1) := ++by ++ ++ have hsubset : Metric.closedBall (0 : ℂ) r1 ⊆ Metric.closedBall (0 : ℂ) R := by ++ intro z hz ++ have hz' : dist z (0 : ℂ) ≤ r1 := by ++ simpa [Metric.mem_closedBall] using hz ++ have hle : r1 ≤ R := le_of_lt (lt_trans hr1_lt_R' hR'_lt_R) ++ have : dist z (0 : ℂ) ≤ R := le_trans hz' hle ++ simpa [Metric.mem_closedBall] using this ++ ++ have hJ_diff : DifferentiableOn ℂ J (Metric.closedBall (0 : ℂ) r1) := ++ hJ.differentiableOn ++ have hB_diff_r1 : DifferentiableOn ℂ B (Metric.closedBall (0 : ℂ) r1) := ++ (hB.differentiableOn).mono hsubset ++ ++ have hExp_diff : DifferentiableOn ℂ Complex.exp (Set.univ : Set ℂ) := ++ (Complex.differentiable_exp.differentiableOn) ++ have hExp_comp : DifferentiableOn ℂ (fun z => Complex.exp (J z)) (Metric.closedBall (0 : ℂ) r1) := by ++ refine hExp_diff.comp hJ_diff ?_ ++ intro x hx; simp ++ ++ have hB_ne_zero_r1 : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, B z ≠ 0 := by ++ intro z hz; exact hB_ne_zero z (by ++ have x : Metric.closedBall 0 r1 ⊆ Metric.closedBall 0 R' := Metric.closedBall_subset_closedBall (le_of_lt hr1_lt_R') ++ simp ++ simp at hz ++ linarith ++ ) ++ ++ have hdiv : DifferentiableOn ℂ (fun z => Complex.exp (J z) / B z) ++ (Metric.closedBall (0 : ℂ) r1) := ++ hExp_comp.div hB_diff_r1 hB_ne_zero_r1 ++ ++ unfold H_auxiliary ++ exact hdiv ++ ++lemma hasDerivAt_H_auxiliary_zero_on_closedBall ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ HasDerivAt (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) 0 z := by ++ intro z hz ++ ++ have hzR : z ∈ Metric.closedBall (0 : ℂ) R' := by ++ have hzR' : dist z (0 : ℂ) ≤ r1 := by ++ simpa [Metric.mem_closedBall] using hz ++ have hR_le : r1 ≤ R' := le_of_lt (hr1_lt_R') ++ have hzR'' : dist z (0 : ℂ) ≤ R' := le_trans hzR' hR_le ++ simpa [Metric.mem_closedBall] using hzR'' ++ have hBnz : B z ≠ 0 := hB_ne_zero z (hzR) ++ ++ have hJ_anal : AnalyticAt ℂ J z := hJ z hz ++ have hExp_diff_at_Jz : DifferentiableAt ℂ Complex.exp (J z) := ++ Complex.differentiableAt_exp ++ have hc_diff : DifferentiableAt ℂ (fun w => Complex.exp (J w)) z := ++ hExp_diff_at_Jz.comp z hJ_anal.differentiableAt ++ ++ have hB' : AnalyticOnNhd ℂ B (Metric.closedBall 0 R') := by ++ apply AnalyticOnNhd.mono_closedBall R' hB ++ assumption ++ have hd_diff : DifferentiableAt ℂ B z := (hB' z hzR).differentiableAt ++ ++ have hH_diff : DifferentiableAt ℂ (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) z := by ++ unfold H_auxiliary ++ convert hc_diff.div hd_diff hBnz using 1 ++ have hH_has : HasDerivAt (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (deriv (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) z) z := ++ hH_diff.hasDerivAt ++ have hderiv0 : deriv (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) z = 0 := ++ H_deriv_zero_on_closedBall hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ simpa [hderiv0] using hH_has ++ ++lemma fderivWithin_eq_zero_of_derivWithin_eq_zero {s : Set ℂ} {f : ℂ → ℂ} {x : ℂ} ++ (_hdiff : DifferentiableWithinAt ℂ f s x) ++ (hderiv : derivWithin f s x = 0) : ++ fderivWithin ℂ f s x = 0 := by ++ rw [← toSpanSingleton_derivWithin, hderiv] ++ simp ++ ++lemma hasDerivWithinAt_of_hasDerivAt {f : ℂ → ℂ} {s : Set ℂ} {x : ℂ} ++ (h : HasDerivAt f 0 x) : HasDerivWithinAt f 0 s x := by ++ simpa using h.hasDerivWithinAt ++ ++lemma uniqueDiffWithinAt_closedBall (r1 : ℝ) {x : ℂ} ++ (hr1 : 0 < r1) (hx : x ∈ Metric.closedBall (0 : ℂ) r1) : ++ UniqueDiffWithinAt ℝ (Metric.closedBall (0 : ℂ) r1) x := by ++ ++ have hconv : Convex ℝ (Metric.closedBall (0 : ℂ) r1) := by ++ simpa using (convex_closedBall (0 : ℂ) r1) ++ ++ have hinter_eq : interior (Metric.closedBall (0 : ℂ) r1) = Metric.ball (0 : ℂ) r1 := by ++ simpa using (interior_closedBall (x := (0 : ℂ)) (r := r1) (hr := ne_of_gt hr1)) ++ have hball_nonempty : (Metric.ball (0 : ℂ) r1).Nonempty := ++ ⟨0, by simpa [Metric.mem_ball, dist_eq_norm] using hr1⟩ ++ have hinter : (interior (Metric.closedBall (0 : ℂ) r1)).Nonempty := by ++ simpa [hinter_eq] using hball_nonempty ++ ++ have hx_closure : x ∈ closure (Metric.closedBall (0 : ℂ) r1) := subset_closure hx ++ ++ simpa using uniqueDiffWithinAt_convex hconv hinter hx_closure ++ ++lemma H_auxiliary_fderivWithin_zero_on_closedBall ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ fderivWithin ℂ (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (Metric.closedBall (0 : ℂ) r1) z = 0 := ++by ++ intro z hz ++ ++ have hHasAt := ++ hasDerivAt_H_auxiliary_zero_on_closedBall hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero ++ hJ hJ_zero hJ_deriv z hz ++ have hHasWithin : ++ HasDerivWithinAt (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) 0 ++ (Metric.closedBall (0 : ℂ) r1) z := ++ hasDerivWithinAt_of_hasDerivAt hHasAt ++ ++ have hdiff : DifferentiableWithinAt ℂ ++ (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (Metric.closedBall (0 : ℂ) r1) z := ++ hHasWithin.differentiableWithinAt ++ ++ classical ++ have hderivWithin0 : ++ derivWithin (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (Metric.closedBall (0 : ℂ) r1) z = 0 := by ++ by_cases hUDc : UniqueDiffWithinAt ℂ (Metric.closedBall (0 : ℂ) r1) z ++ · simpa using hHasWithin.derivWithin hUDc ++ · simpa using ++ (derivWithin_zero_of_not_uniqueDiffWithinAt ++ (𝕜 := ℂ) ++ (f := H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (s := Metric.closedBall (0 : ℂ) r1) (x := z) hUDc) ++ ++ exact fderivWithin_eq_zero_of_derivWithin_eq_zero hdiff hderivWithin0 ++ ++lemma H_is_constant ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J z = ++ H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J 0 := by ++ intro z hz ++ ++ have hs : Convex ℝ (Metric.closedBall (0 : ℂ) r1) := by ++ simpa using (convex_closedBall (0 : ℂ) r1) ++ ++ have hdiff : DifferentiableOn ℂ (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (Metric.closedBall (0 : ℂ) r1) := ++ H_auxiliary_differentiableOn_closedBall hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ ++ ++ have hfderiv0 : ∀ x ∈ Metric.closedBall (0 : ℂ) r1, ++ fderivWithin ℂ (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (Metric.closedBall (0 : ℂ) r1) x = 0 := ++ H_auxiliary_fderivWithin_zero_on_closedBall hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv ++ ++ have h0mem : (0 : ℂ) ∈ Metric.closedBall (0 : ℂ) r1 := ++ zero_mem_closedBall_zero_radius (le_of_lt hr1_pos) ++ ++ have hbound : ∀ x ∈ Metric.closedBall (0 : ℂ) r1, ++ ‖fderivWithin ℂ (H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (Metric.closedBall (0 : ℂ) r1) x‖ ≤ 0 := by ++ intro x hx ++ simp [hfderiv0 x hx] ++ have hineq := ++ Convex.norm_image_sub_le_of_norm_fderivWithin_le (𝕜 := ℂ) ++ (f := H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J) ++ (s := Metric.closedBall (0 : ℂ) r1) (x := (0 : ℂ)) (y := z) ++ hdiff hbound hs h0mem hz ++ have hzero : H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J z - ++ H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J 0 = 0 := by ++ have : ‖H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J z - ++ H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J 0‖ ≤ 0 := by ++ simpa using hineq ++ simpa [norm_le_zero_iff] using this ++ simpa [sub_eq_add_neg] using sub_eq_zero.mp hzero ++ ++lemma H_is_one ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ H_auxiliary hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero J z = 1 / B 0 := by ++ intro z hz ++ have hconst := H_is_constant hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ have h0 := H_at_zero hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv ++ simpa [h0] using hconst ++ ++lemma analytic_log_exists ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, B z = B 0 * Complex.exp (J z) := by ++ intro z hz ++ ++ have hH_const := H_is_one hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ ++ unfold H_auxiliary at hH_const ++ ++ have hzR : z ∈ Metric.closedBall (0 : ℂ) R' := by ++ have hzR' : dist z (0 : ℂ) ≤ r1 := hz ++ have hR_le : r1 ≤ R := le_of_lt (lt_trans hr1_lt_R' hR'_lt_R) ++ exact le_trans hzR' (by linarith) ++ have hBnz : B z ≠ 0 := hB_ne_zero z hzR ++ have hR_pos : 0 < R := lt_trans (lt_trans hr1_pos hr1_lt_R') hR'_lt_R ++ have hB0nz : B 0 ≠ 0 := hB_ne_zero 0 (by ++ simp [Metric.closedBall, dist_zero_right] ++ exact le_of_lt (by linarith)) ++ ++ have heq : Complex.exp (J z) * B 0 = B z := by ++ field_simp [hBnz, hB0nz] at hH_const ++ exact hH_const ++ ++ rw [← heq, mul_comm] ++ ++lemma modulus_of_exp_I ++ {r1 R' R : ℝ} ++ (_hr1_pos : 0 < r1) (_hr1_lt_R' : r1 < R') (_hR'_lt_R : R' < R) (_hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (_hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (_hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (_hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (_hJ_zero : J 0 = 0) ++ (_hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ norm (Complex.exp (J z)) = Real.exp (Complex.re (J z)) := by ++ intro z hz ++ exact Complex.norm_exp (J z) ++ ++lemma modulus_of_B_product_form ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ norm (B z) = norm (B 0) * norm (Complex.exp (J z)) := by ++ intro z hz ++ have hBform := analytic_log_exists hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ ++ simpa [norm_mul] using (congrArg norm hBform) ++ ++lemma modulus_of_exp_log ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ norm (B z) = norm (B 0) * Real.exp (Complex.re (J z)) := by ++ intro z hz ++ rw [modulus_of_B_product_form hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz] ++ rw [modulus_of_exp_I hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz] ++ ++lemma log_modulus_as_sum ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ Real.log (norm (B z)) = ++ Real.log (norm (B 0)) + Real.log (Real.exp (Complex.re (J z))) := by ++ intro z hz ++ ++ have h_eq := modulus_of_exp_log hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ ++ rw [h_eq, Real.log_mul] ++ · ++ ++ simp ++ apply hB_ne_zero ++ ++ rw [Metric.mem_closedBall, dist_self] ++ linarith ++ · ++ exact Real.exp_ne_zero _ ++ ++lemma real_log_of_modulus_difference ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) ++ {J : ℂ → ℂ} ++ (hJ : AnalyticOnNhd ℂ J (Metric.closedBall (0 : ℂ) r1)) ++ (hJ_zero : J 0 = 0) ++ (hJ_deriv : ∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J z = deriv B z / B z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ Real.log (norm (B z)) - Real.log (norm (B 0)) = Complex.re (J z) := by ++ intro z hz ++ ++ have h_sum := log_modulus_as_sum hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ_zero hJ_deriv z hz ++ ++ rw [h_sum] ++ ++ rw [Real.log_exp] ++ ring ++ ++theorem log_of_analytic ++ {r1 R' R : ℝ} ++ (hr1_pos : 0 < r1) (hr1_lt_R' : r1 < R') (hR'_lt_R : R' < R) (hR_lt_one : R < 1) ++ {B : ℂ → ℂ} ++ (hB : AnalyticOnNhd ℂ B (Metric.closedBall (0 : ℂ) R)) ++ (hB_ne_zero : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0) : ++ ∃ J_B : ℂ → ℂ, ++ AnalyticOnNhd ℂ J_B (Metric.closedBall (0 : ℂ) r1) ∧ ++ J_B 0 = 0 ∧ ++ (∀ z ∈ Metric.closedBall (0 : ℂ) r1, deriv J_B z = deriv B z / B z) ∧ ++ (∀ z ∈ Metric.closedBall (0 : ℂ) r1, ++ Real.log (norm (B z)) - Real.log (norm (B 0)) = Complex.re (J_B z)) := by ++ have hB_ne_zero_R' : ∀ z ∈ Metric.closedBall (0 : ℂ) R', B z ≠ 0 := hB_ne_zero ++ obtain ⟨J_B, hJ, hJ0, hJderiv⟩ := ++ I_is_antiderivative hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero_R' ++ refine ⟨J_B, hJ, hJ0, hJderiv, ?_⟩ ++ intro z hz ++ simpa using ++ (real_log_of_modulus_difference hr1_pos hr1_lt_R' hR'_lt_R hR_lt_one hB hB_ne_zero hJ hJ0 hJderiv z hz) ++ ++end Erdos970 +diff --git a/StrongPNT/Erdos970/PNT2_LogDerivative.lean b/StrongPNT/Erdos970/PNT2_LogDerivative.lean +new file mode 100644 +index 0000000..4d1d6e5 +--- /dev/null ++++ b/StrongPNT/Erdos970/PNT2_LogDerivative.lean +@@ -0,0 +1,3971 @@ ++import StrongPNT.Erdos970.PNT1_ComplexAnalysis ++ ++namespace Erdos970 ++ ++ ++lemma DRinD1 (R : ℝ) (_hR : 0 < R) (hR' : R < 1) : ++ Metric.closedBall (0 : ℂ) R ⊆ Metric.ball (0 : ℂ) 1 := by ++ exact Metric.closedBall_subset_ball hR' ++def zerosetKfR (R : ℝ) (_hR : 0 < R) (f : ℂ → ℂ) : Set ℂ := ++ {ρ : ℂ | ρ ∈ Metric.closedBall (0 : ℂ) R ∧ f ρ = 0} ++lemma lemKinDR (R : ℝ) (hR : 0 < R) (f : ℂ → ℂ) : ++ zerosetKfR R hR f ⊆ Metric.closedBall (0 : ℂ) R := by ++ intro ρ hρ ++ ++ rw [zerosetKfR] at hρ ++ ++ exact hρ.1 ++lemma lemKRinK1 (R : ℝ) (hR : 0 < R) (hR' : R < 1) (f : ℂ → ℂ) : ++ zerosetKfR R hR f ⊆ {ρ : ℂ | ρ ∈ Metric.ball (0 : ℂ) 1 ∧ f ρ = 0} := by ++ intro ρ hρ ++ simp only [zerosetKfR, Set.mem_ofPred_eq] at hρ ⊢ ++ constructor ++ · exact DRinD1 R hR hR' hρ.1 ++ · exact hρ.2 ++ ++lemma lem_bolzano_weierstrass {D : Set ℂ} (hD : IsCompact D) {Z : Set ℂ} (hZ_inf : Z.Infinite) (hZ_sub_D : Z ⊆ D) : ++ ∃ ρ₀ ∈ D, AccPt ρ₀ (Filter.principal Z) := ++ Set.Infinite.exists_accPt_of_subset_isCompact hZ_inf hD hZ_sub_D ++lemma lem_zeros_have_limit_point (R : ℝ) (hR : 0 < R) (f : ℂ → ℂ) (h_Kf_inf : Set.Infinite (zerosetKfR R hR f)) : ++ ∃ ρ₀ ∈ Metric.closedBall (0 : ℂ) R, AccPt ρ₀ (Filter.principal (zerosetKfR R hR f)) := by ++ apply lem_bolzano_weierstrass ++ · ++ rw [← lem_ballDR R hR] ++ exact lem_DRcompact R hR ++ · exact h_Kf_inf ++ · exact lemKinDR R hR f ++ ++open Filter Metric Set Bornology Function ++ ++lemma lem_identity_theorem (f : ℂ → ℂ) ++ (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) 1)) ++ (ρ₀ : ℂ) (hρ₀_in_D1 : ρ₀ ∈ Metric.ball (0 : ℂ) 1) ++ (h_acc : AccPt ρ₀ (Filter.principal ({ρ : ℂ | ρ ∈ Metric.ball (0 : ℂ) 1 ∧ f ρ = 0}))) : ++ EqOn f 0 (Metric.ball (0 : ℂ) 1) := by ++ ++ have h_subset : Metric.ball (0 : ℂ) 1 ⊆ Metric.closedBall (0 : ℂ) 1 := Metric.ball_subset_closedBall ++ ++ have hf_open : AnalyticOnNhd ℂ f (Metric.ball (0 : ℂ) 1) := AnalyticOnNhd.mono hf h_subset ++ ++ have h_conn : IsConnected (Metric.ball (0 : ℂ) 1) := Metric.isConnected_ball (by norm_num : (0 : ℝ) < 1) ++ have h_preconn : IsPreconnected (Metric.ball (0 : ℂ) 1) := h_conn.isPreconnected ++ ++ have h_zeros_subset : {ρ : ℂ | ρ ∈ Metric.ball (0 : ℂ) 1 ∧ f ρ = 0} ⊆ {z | f z = 0} := by ++ intro z hz ++ exact hz.2 ++ ++ have h_acc_zero : AccPt ρ₀ (Filter.principal ({z | f z = 0})) := by ++ exact AccPt.mono h_acc (principal_mono.2 h_zeros_subset) ++ ++ have h_closure : ρ₀ ∈ closure ({z | f z = 0} \ {ρ₀}) := by ++ ++ have h_cluster : ClusterPt ρ₀ (Filter.principal ({z | f z = 0} \ {ρ₀})) := ++ (accPt_principal_iff_clusterPt).mp h_acc_zero ++ exact (mem_closure_iff_clusterPt).2 h_cluster ++ ++ exact AnalyticOnNhd.eqOn_zero_of_preconnected_of_mem_closure hf_open h_preconn hρ₀_in_D1 h_closure ++lemma lem_identity_theoremR (R : ℝ) (hR : 0 < R) (hR' : R < 1) ++ (f : ℂ → ℂ) (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) 1)) ++ (ρ₀ : ℂ) (hρ₀_in_DR : ρ₀ ∈ Metric.closedBall (0 : ℂ) R) ++ (h_acc : AccPt ρ₀ (Filter.principal ({ρ : ℂ | ρ ∈ Metric.ball (0 : ℂ) 1 ∧ f ρ = 0}))) : ++ EqOn f 0 (Metric.ball (0 : ℂ) 1) := by ++ have hρ₀_in_D1 : ρ₀ ∈ Metric.ball (0 : ℂ) 1 := DRinD1 R hR hR' hρ₀_in_DR ++ exact lem_identity_theorem f hf ρ₀ hρ₀_in_D1 h_acc ++lemma lem_identity_theoremKR (R : ℝ) (hR : 0 < R) (hR' : R < 1) ++ (f : ℂ → ℂ) (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) 1)) ++ (h_exists_rho0 : ∃ ρ₀ ∈ Metric.closedBall (0 : ℂ) R, AccPt ρ₀ (Filter.principal (zerosetKfR R hR f))) : ++ EqOn f 0 (Metric.ball (0 : ℂ) 1) := by ++ ++ obtain ⟨ρ₀, hρ₀_in_R, h_acc⟩ := h_exists_rho0 ++ ++ apply lem_identity_theoremR R hR hR' f hf ρ₀ hρ₀_in_R ++ ++ exact AccPt.mono h_acc (principal_mono.2 (lemKRinK1 R hR hR' f)) ++lemma lem_identity_infiniteKR (R : ℝ) (hR : 0 < R) (hR' : R < 1) ++ (f : ℂ → ℂ) (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) 1)) ++ (h_Kf_inf : Set.Infinite (zerosetKfR R hR f)) : ++ EqOn f 0 (Metric.ball (0 : ℂ) 1) := by ++ have h_exists_rho0 := lem_zeros_have_limit_point R hR f h_Kf_inf ++ exact lem_identity_theoremKR R hR hR' f hf h_exists_rho0 ++lemma lem_Contra_finiteKR (R : ℝ) (hR : 0 < R) (hR' : R < 1) ++ (f : ℂ → ℂ) (hf : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) 1)) ++ (h_exists_nonzero : ∃ z ∈ Metric.ball (0 : ℂ) 1, f z ≠ 0) : ++ Set.Finite (zerosetKfR R hR f) := by ++ ++ by_contra h_not_finite ++ ++ have h_Kf_inf : Set.Infinite (zerosetKfR R hR f) := h_not_finite ++ ++ have h_eq_zero := lem_identity_infiniteKR R hR hR' f hf h_Kf_inf ++ ++ obtain ⟨z, hz_in_ball, hz_nonzero⟩ := h_exists_nonzero ++ have h_f_z_zero : f z = 0 := h_eq_zero hz_in_ball ++ exact hz_nonzero h_f_z_zero ++ ++open Classical ++ ++lemma lem_frho_zero (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (_hR1_lt_R : R1 < R) ++ (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (ρ : ℂ) (h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) : ++ f ρ = 0 := h_rho_in_KfR1.2 ++ ++lemma lem_m_rho_is_nat (R R1 : ℝ) (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hR_lt_1 : R < 1) : ++ ∀ (ρ : ℂ) (_h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f), ++ analyticOrderAt f ρ ≠ ⊤ := by ++ intro ρ h_rho_in_KfR1 ++ ++ have hρ_closed_R1 : ρ ∈ Metric.closedBall (0 : ℂ) R1 := h_rho_in_KfR1.1 ++ ++ have hR1_le_R : R1 ≤ R := by linarith ++ have hR1_lt_one : R1 < 1 := by linarith ++ ++ have hρ_ball1 : ρ ∈ Metric.ball (0 : ℂ) 1 := by ++ have hdist_le : dist ρ (0 : ℂ) ≤ R1 := (Metric.mem_closedBall.mp hρ_closed_R1) ++ have hdist_lt : dist ρ (0 : ℂ) < 1 := by linarith ++ simpa [Metric.mem_ball] using hdist_lt ++ ++ have hf_at_ρ : AnalyticAt ℂ f ρ := by ++ ++ have hsubset : Metric.closedBall (0 : ℂ) R1 ⊆ Metric.closedBall (0 : ℂ) 1 := ++ Metric.closedBall_subset_closedBall (le_of_lt hR1_lt_one) ++ have hρ_closed1 : ρ ∈ Metric.closedBall (0 : ℂ) 1 := hsubset hρ_closed_R1 ++ exact h_f_analytic ρ hρ_closed1 ++ ++ by_contra htop ++ ++ have h_eventually_zero : ∀ᶠ z in nhds ρ, f z = 0 := by ++ have h_equiv : (analyticOrderAt f ρ = ⊤ ↔ ∀ᶠ z in nhds ρ, f z = 0) := by ++ simp [analyticOrderAt, hf_at_ρ] ++ exact h_equiv.mp (by simpa using htop) ++ ++ have hf_on_ball : AnalyticOnNhd ℂ f (Metric.ball (0 : ℂ) 1) := by ++ intro z hz ++ have hz' : z ∈ Metric.closedBall (0 : ℂ) 1 := ++ (Metric.ball_subset_closedBall : Metric.ball (0 : ℂ) 1 ⊆ Metric.closedBall (0 : ℂ) 1) hz ++ exact h_f_analytic z hz' ++ ++ have h_preconn : IsPreconnected (Metric.ball (0 : ℂ) 1) := ++ (Metric.isConnected_ball (by exact (zero_lt_one : (0 : ℝ) < 1))).isPreconnected ++ ++ have h_eqOn_zero : Set.EqOn f 0 (Metric.ball (0 : ℂ) 1) := ++ AnalyticOnNhd.eqOn_zero_of_preconnected_of_eventuallyEq_zero hf_on_ball h_preconn hρ_ball1 ++ h_eventually_zero ++ ++ have h0_in_ball : (0 : ℂ) ∈ Metric.ball (0 : ℂ) 1 := by ++ simp [Metric.mem_ball] ++ have : f 0 = 0 := by ++ have h := h_eqOn_zero h0_in_ball ++ simpa [Pi.zero_apply] using h ++ exact h_f_nonzero_at_zero this ++ ++lemma analyticOrderAt_ge_one_of_zero (f : ℂ → ℂ) (z : ℂ) (hf : AnalyticAt ℂ f z) (hz : f z = 0) (hfinite : analyticOrderAt f z ≠ ⊤) : analyticOrderAt f z ≥ 1 := by ++ ++ have h_order_ne_zero : analyticOrderAt f z ≠ 0 := by ++ intro h_order_zero ++ ++ have h_f_ne_zero : f z ≠ 0 := by ++ rw [← AnalyticAt.analyticOrderAt_eq_zero hf] ++ exact h_order_zero ++ ++ exact h_f_ne_zero hz ++ ++ cases' h : analyticOrderAt f z with n ++ · ++ ++ rw [h] at hfinite ++ exact False.elim (hfinite rfl) ++ · ++ ++ rw [h] at h_order_ne_zero ++ have n_ne_zero : n ≠ 0 := by ++ intro n_zero ++ rw [n_zero, Nat.cast_zero] at h_order_ne_zero ++ exact h_order_ne_zero rfl ++ ++ have n_ge_one : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr n_ne_zero ++ ++ exact Nat.cast_le.mpr n_ge_one ++ ++lemma lem_m_rho_ge_1 (R R1 : ℝ) (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hR_lt_1 : R < 1) : ++ ∀ (ρ : ℂ) (_h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f), ++ analyticOrderAt f ρ ≥ 1 := by ++ intro ρ h_rho_in_KfR1 ++ ++ have h_f_rho_zero : f ρ = 0 := lem_frho_zero R R1 hR1_pos hR1_lt_R f h_f_analytic ρ h_rho_in_KfR1 ++ ++ have h_order_finite : analyticOrderAt f ρ ≠ ⊤ := lem_m_rho_is_nat R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero hR_lt_1 ρ h_rho_in_KfR1 ++ ++ have h_f_analytic_at_rho : AnalyticAt ℂ f ρ := by ++ apply h_f_analytic ++ ++ have h_R1_lt_1 : R1 < 1 := by linarith ++ have h_rho_in_R1 : ρ ∈ Metric.closedBall 0 R1 := h_rho_in_KfR1.1 ++ exact Metric.closedBall_subset_closedBall (le_of_lt h_R1_lt_1) h_rho_in_R1 ++ ++ exact analyticOrderAt_ge_one_of_zero f ρ h_f_analytic_at_rho h_f_rho_zero h_order_finite ++ ++noncomputable def Cf ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (_hR1_lt_R : R1 < R) ++ (_hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (_h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (z : ℂ) : ℂ := ++ if hz : z ∈ zerosetKfR R1 (by linarith) f then ++ h_σ z z / ∏ ρ ∈ (h_finite_zeros.toFinset.erase z), (z - ρ) ^ (analyticOrderAt f ρ).toNat ++ else ++ f z / ∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat ++ ++lemma lem_analDiv (R : ℝ) (_hR_pos : 0 < R) (_hR_lt_1 : R < 1) (w : ℂ) ++ (_hw : w ∈ Metric.closedBall (0 : ℂ) R) ++ (h : ℂ → ℂ) (g : ℂ → ℂ) ++ (hh : AnalyticAt ℂ h w) (hg : AnalyticAt ℂ g w) (hg_ne : g w ≠ 0) : ++ AnalyticAt ℂ (fun z => h z / g z) w := by ++ convert hh.div hg hg_ne using 1 ++ ++lemma lem_denomAnalAt (S : Finset ℂ) (n : ℂ → ℕ) ++ (_hn_pos : ∀ s ∈ S, 0 < n s) (w : ℂ) (hw : w ∉ S) : ++ AnalyticAt ℂ (fun z => ∏ s ∈ S, (z - s) ^ (n s)) w ∧ ++ (∏ s ∈ S, (w - s) ^ (n s)) ≠ 0 := by ++ constructor ++ · ++ ++ let f : ℂ → ℂ → ℂ := fun s z => (z - s) ^ (n s) ++ have h_each_analytic : ∀ s ∈ S, AnalyticAt ℂ (f s) w := by ++ intro s hs ++ simp only [f] ++ ++ have h_sub : AnalyticAt ℂ (fun z => z - s) w := by ++ exact AnalyticAt.sub analyticAt_id analyticAt_const ++ ++ exact h_sub.pow (n s) ++ have h_prod := Finset.analyticAt_prod S h_each_analytic ++ convert h_prod using 1 ++ first | rfl | (ext z; simp [f]) ++ · ++ apply Finset.prod_ne_zero_iff.mpr ++ intro s hs ++ apply pow_ne_zero ++ ++ intro h_eq ++ ++ have h_w_eq_s : w = s := by ++ rwa [← sub_eq_zero] ++ ++ rw [h_w_eq_s] at hw ++ exact hw hs ++ ++lemma lem_ratioAnalAt (w : ℂ) (R R1 : ℝ) (_hR1_lt_R : R1 < R) (_hR_lt_1 : R < 1) ++ (h : ℂ → ℂ) (hh : AnalyticAt ℂ h w) ++ (S : Finset ℂ) (_hS : ↑S ⊆ Metric.closedBall (0 : ℂ) R1) (n : ℂ → ℕ) ++ (hn_pos : ∀ s ∈ S, 0 < n s) ++ (hw : w ∈ Metric.closedBall (0 : ℂ) 1 \ ↑S) : ++ AnalyticAt ℂ (fun z => h z / ∏ s ∈ S, (z - s) ^ (n s)) w := by ++ classical ++ ++ have hden := lem_denomAnalAt (S := S) (n := n) ++ (_hn_pos := hn_pos) (w := w) ++ (hw := by simpa using hw.2) ++ ++ exact AnalyticAt.div hh hden.1 hden.2 ++ ++lemma lem_analytic_zero_factor (R R1 : ℝ) (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) : ++ ∃ h_σ : ℂ → ℂ, AnalyticAt ℂ h_σ σ ∧ h_σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ z := by ++ classical ++ ++ have hσ_closed_R1 : σ ∈ Metric.closedBall (0 : ℂ) R1 := hσ.1 ++ have hR1_le_R : R1 ≤ R := by linarith ++ have hR1_lt_one : R1 < 1 := by linarith ++ have hσ_closed1 : σ ∈ Metric.closedBall (0 : ℂ) 1 := ++ (Metric.closedBall_subset_closedBall (le_of_lt hR1_lt_one)) hσ_closed_R1 ++ have hfσ : AnalyticAt ℂ f σ := h_f_analytic σ hσ_closed1 ++ ++ have h_order_finite : analyticOrderAt f σ ≠ ⊤ := ++ lem_m_rho_is_nat R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero hR_lt_1 σ hσ ++ ++ rcases (hfσ.analyticOrderAt_ne_top).mp h_order_finite with ⟨g, hgσ, hgσ_ne, h_eq⟩ ++ ++ have h_eq' : ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * g z := by ++ refine h_eq.mono ?_ ++ intro z hz ++ simpa [smul_eq_mul, analyticOrderNatAt] using hz ++ exact ⟨g, hgσ, hgσ_ne, h_eq'⟩ ++ ++lemma lem_Cf_analytic_off_K ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R \ zerosetKfR R1 (by linarith) f) : ++ AnalyticAt ℂ (Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ) z := by ++ ++ have h_ratio_analytic : AnalyticAt ℂ (fun w => f w / ∏ ρ ∈ h_finite_zeros.toFinset, (w - ρ) ^ (analyticOrderAt f ρ).toNat) z := by ++ apply lem_ratioAnalAt z R R1 hR1_lt_R hR_lt_1 f ++ ++ · apply h_f_analytic ++ exact Metric.closedBall_subset_closedBall (le_of_lt hR_lt_1) hz.1 ++ ++ · intro ρ hρ ++ have h_mem : ρ ∈ zerosetKfR R1 (by linarith) f := h_finite_zeros.mem_toFinset.mp hρ ++ exact h_mem.1 ++ ++ · intro s hs ++ have h_s_in_zeros : s ∈ zerosetKfR R1 (by linarith) f := h_finite_zeros.mem_toFinset.mp hs ++ have h_order_ge_1 := lem_m_rho_ge_1 R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero hR_lt_1 s h_s_in_zeros ++ have h_order_finite := lem_m_rho_is_nat R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero hR_lt_1 s h_s_in_zeros ++ ++ cases' h_cases : analyticOrderAt f s with n ++ · ++ rw [h_cases] at h_order_finite ++ exact False.elim (h_order_finite rfl) ++ · ++ have n_ge_1 : n ≥ 1 := by ++ rw [h_cases] at h_order_ge_1 ++ exact Nat.cast_le.mp h_order_ge_1 ++ simp ++ exact Nat.pos_iff_ne_zero.mpr (ne_of_gt n_ge_1) ++ ++ · constructor ++ · exact Metric.closedBall_subset_closedBall (le_of_lt hR_lt_1) hz.1 ++ · ++ intro h_z_in_finset ++ have h_z_in_zeros : z ∈ zerosetKfR R1 (by linarith) f := h_finite_zeros.mem_toFinset.mp h_z_in_finset ++ exact hz.2 h_z_in_zeros ++ ++ have h_eventually_eq : (fun w => f w / ∏ ρ ∈ h_finite_zeros.toFinset, (w - ρ) ^ (analyticOrderAt f ρ).toNat) =ᶠ[nhds z] ++ (fun w => Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ w) := by ++ ++ have hz_not_in : z ∉ zerosetKfR R1 (by linarith) f := hz.2 ++ have h_open : IsOpen (Set.compl (zerosetKfR R1 (by linarith) f)) := h_finite_zeros.isClosed.isOpen_compl ++ apply Filter.eventually_of_mem (h_open.mem_nhds hz_not_in) ++ intro w hw_not_in_compl ++ ++ have hw_not_in_zeros : w ∉ zerosetKfR R1 (by linarith) f := hw_not_in_compl ++ ++ show f w / ∏ ρ ∈ h_finite_zeros.toFinset, (w - ρ) ^ (analyticOrderAt f ρ).toNat = ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ w ++ ++ rw [Cf, dite_eq_right hw_not_in_zeros] ++ ++ exact h_ratio_analytic.congr h_eventually_eq ++ ++lemma lem_Cf_at_sigma_onK ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) : ++ ∀ᶠ z in nhds σ, z = σ → ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ h_σ z z / ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ refine Filter.Eventually.of_forall ?_ ++ intro z hz ++ subst hz ++ simp [Cf, hσ] ++ ++lemma lem_K_isolated ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {_hR1_lt_R : R1 < R} {_hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} {_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {_h_f_nonzero_at_zero : f 0 ≠ 0} ++ (σ ρ : ℂ) (_hσ : σ ∈ zerosetKfR R1 (by linarith) f) ++ (_hρ : ρ ∈ zerosetKfR R1 (by linarith) f) (hne : σ ≠ ρ) : ++ ∀ᶠ z in nhds σ, z ≠ ρ := eventually_ne_nhds hne ++ ++lemma lem_Cf_at_sigma_offK0 ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) : ++ ∀ᶠ z in nhds σ, z ≠ σ → ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z / ++ ∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ ++ obtain ⟨h_σ_analytic, h_σ_ne_zero, h_f_eq⟩ := h_σ_spec σ hσ ++ ++ have h_σ_eventually_nonzero : ∀ᶠ z in nhds σ, h_σ σ z ≠ 0 := by ++ have h_cont : ContinuousAt (h_σ σ) σ := h_σ_analytic.continuousAt ++ exact h_cont.eventually_ne h_σ_ne_zero ++ ++ have h_f_eventually_nonzero : ∀ᶠ z in nhds σ, z ≠ σ → f z ≠ 0 := by ++ filter_upwards [h_f_eq, h_σ_eventually_nonzero] with z h_fz_eq h_σz_nonzero ++ intro hz_ne ++ rw [h_fz_eq] ++ apply mul_ne_zero ++ · apply pow_ne_zero ++ exact sub_ne_zero.mpr hz_ne ++ · exact h_σz_nonzero ++ ++ have h_eventually_not_in_zeroset : ∀ᶠ z in nhds σ, z ≠ σ → z ∉ zerosetKfR R1 (by linarith) f := by ++ filter_upwards [h_f_eventually_nonzero] with z h_fz_nonzero ++ intro hz_ne hz_in_zeroset ++ exact h_fz_nonzero hz_ne hz_in_zeroset.2 ++ ++ filter_upwards [h_f_eq, h_eventually_not_in_zeroset] with z h_fz_eq h_not_in_zeroset ++ intro hz_ne ++ ++ have hz_not_in_K : z ∉ zerosetKfR R1 (by linarith) f := h_not_in_zeroset hz_ne ++ ++ unfold Cf ++ simp [hz_not_in_K, h_fz_eq] ++ ++lemma lem_prod_no_sigma1 ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {_hR1_lt_R : R1 < R} {_hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} {_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} {_h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) (z : ℂ) : ++ ∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat = ++ (z - σ) ^ (analyticOrderAt f σ).toNat * ++ ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ classical ++ have hmem : σ ∈ h_finite_zeros.toFinset := ++ (Set.Finite.mem_toFinset (hs := h_finite_zeros)).2 hσ ++ simpa using ++ (Finset.mul_prod_erase (s := h_finite_zeros.toFinset) ++ (f := fun ρ => (z - ρ) ^ (analyticOrderAt f ρ).toNat) (a := σ) hmem).symm ++ ++lemma lem_prod_no_sigma2 ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) (z : ℂ) ++ (hz : z ∉ zerosetKfR R1 (by linarith) f) : ++ (z - σ) ^ (analyticOrderAt f σ).toNat / ++ ∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat = ++ 1 / ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ ++ have h_factor := @lem_prod_no_sigma1 R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros σ hσ z ++ rw [h_factor] ++ ++ rw [div_mul_eq_div_div] ++ ++ have h_nonzero : (z - σ) ^ (analyticOrderAt f σ).toNat ≠ 0 := by ++ apply pow_ne_zero ++ intro h_eq ++ ++ have h_z_eq_sigma : z = σ := sub_eq_zero.mp h_eq ++ rw [h_z_eq_sigma] at hz ++ exact hz hσ ++ ++ rw [div_self h_nonzero, one_div] ++ ++lemma lem_Cf_at_sigma_offK ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) : ++ ∀ᶠ z in nhds σ, z ≠ σ → ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ h_σ σ z / ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ ++ have h_cf_form := @lem_Cf_at_sigma_offK0 R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec σ hσ ++ ++ filter_upwards [h_cf_form] with z h_cf_z ++ intro hz_ne_sigma ++ ++ rw [h_cf_z hz_ne_sigma] ++ ++ have h_prod_decomp := @lem_prod_no_sigma1 R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros σ hσ z ++ ++ rw [h_prod_decomp] ++ ++ apply mul_div_mul_left ++ ++ apply pow_ne_zero ++ exact sub_ne_zero.mpr hz_ne_sigma ++ ++lemma lem_Cf_at_sigma ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) : ++ ∀ᶠ z in nhds σ, ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ h_σ σ z / ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ ++ have h_on := @lem_Cf_at_sigma_onK R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec σ hσ ++ have h_off := @lem_Cf_at_sigma_offK R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec σ hσ ++ ++ filter_upwards [h_on, h_off] with z hz_on hz_off ++ by_cases h : z = σ ++ · ++ have eq_result := hz_on h ++ ++ rw [h] at eq_result ⊢ ++ exact eq_result ++ · ++ exact hz_off h ++ ++lemma lem_h_ratio_anal ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (σ : ℂ) (_hσ : σ ∈ zerosetKfR R1 (by linarith) f) ++ (g : ℂ → ℂ) (hg_analytic : AnalyticAt ℂ g σ) : ++ AnalyticAt ℂ ++ (fun z => g z / ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), ++ (z - ρ) ^ (analyticOrderAt f ρ).toNat) σ := by ++ ++ have hden := lem_denomAnalAt (S := h_finite_zeros.toFinset.erase σ) ++ (n := fun ρ => (analyticOrderAt f ρ).toNat) ++ (_hn_pos := by ++ intro s hs ++ have h_s_in_zeros : s ∈ zerosetKfR R1 (by linarith) f := by ++ have h_mem_erase : s ∈ h_finite_zeros.toFinset.erase σ := hs ++ have h_mem_orig : s ∈ h_finite_zeros.toFinset := Finset.mem_of_mem_erase h_mem_erase ++ exact h_finite_zeros.mem_toFinset.mp h_mem_orig ++ have h_order_ge_1 := lem_m_rho_ge_1 R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero hR_lt_1 s h_s_in_zeros ++ have h_order_finite := lem_m_rho_is_nat R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero hR_lt_1 s h_s_in_zeros ++ cases' h_cases : analyticOrderAt f s with n ++ · ++ rw [h_cases] at h_order_finite ++ exact False.elim (h_order_finite rfl) ++ · ++ have n_ge_1 : n ≥ 1 := by ++ rw [h_cases] at h_order_ge_1 ++ exact Nat.cast_le.mp h_order_ge_1 ++ simp ++ exact Nat.pos_iff_ne_zero.mpr (ne_of_gt n_ge_1)) ++ (w := σ) ++ (hw := by ++ simp [Finset.mem_erase]) ++ ++ exact AnalyticAt.div hg_analytic hden.1 hden.2 ++ ++lemma lem_Cf_analytic_at_K ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) : ++ AnalyticAt ℂ (Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ) σ := by ++ ++ have h_eventually_eq := @lem_Cf_at_sigma R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec σ hσ ++ ++ obtain ⟨h_σ_analytic, _, _⟩ := h_σ_spec σ hσ ++ have h_ratio_analytic := @lem_h_ratio_anal R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros σ hσ (h_σ σ) h_σ_analytic ++ ++ have h_rev_eq : (fun z => h_σ σ z / ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), (z - ρ) ^ (analyticOrderAt f ρ).toNat) =ᶠ[nhds σ] ++ (Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ) := by ++ filter_upwards [h_eventually_eq] with z h_z ++ exact h_z.symm ++ ++ exact AnalyticAt.congr h_ratio_analytic h_rev_eq ++ ++lemma lem_Cf_is_analytic ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R) : ++ AnalyticAt ℂ (Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ) z := by ++ ++ by_cases h_case : z ∈ zerosetKfR R1 (by linarith) f ++ ++ case pos => ++ ++ exact lem_Cf_analytic_at_K h_finite_zeros h_σ h_σ_spec z h_case ++ ++ case neg => ++ ++ have hz_in_complement : z ∈ Metric.closedBall (0 : ℂ) R \ zerosetKfR R1 (by linarith) f := by ++ constructor ++ · exact hz ++ · exact h_case ++ exact lem_Cf_analytic_off_K h_finite_zeros h_σ h_σ_spec z hz_in_complement ++ ++lemma lem_f_nonzero_off_K ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {_hR1_lt_R : R1 < R} {_hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} {_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} {_h_f_nonzero_at_zero : f 0 ≠ 0} ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f) : ++ f z ≠ 0 := by ++ exact fun h => hz.2 ⟨hz.1, h⟩ ++ ++lemma lem_Cf_nonzero_off_K ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f) : ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z ≠ 0 := by ++ ++ have hz_not_in : z ∉ zerosetKfR R1 (by linarith) f := hz.2 ++ ++ have h_cf_eq : Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ f z / ∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ unfold Cf ++ simp [hz_not_in] ++ ++ rw [h_cf_eq] ++ ++ apply div_ne_zero ++ ++ · apply @lem_f_nonzero_off_K R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero z hz ++ ++ · apply Finset.prod_ne_zero_iff.mpr ++ intro ρ hρ ++ ++ apply pow_ne_zero ++ ++ intro h_eq ++ ++ have hz_eq_rho : z = ρ := by ++ rwa [sub_eq_zero] at h_eq ++ ++ have hρ_in : ρ ∈ zerosetKfR R1 (by linarith) f := h_finite_zeros.mem_toFinset.mp hρ ++ rw [hz_eq_rho] at hz_not_in ++ exact hz_not_in hρ_in ++ ++lemma lem_Cf_nonzero_on_K ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (σ : ℂ) (hσ : σ ∈ zerosetKfR R1 (by linarith) f) : ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ σ ≠ 0 := by ++ have hnum : h_σ σ σ ≠ 0 := (h_σ_spec σ hσ).2.1 ++ have hden : ++ (∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), ++ (σ - ρ) ^ (analyticOrderAt f ρ).toNat) ≠ 0 := by ++ refine Finset.prod_ne_zero_iff.mpr ?_ ++ intro ρ hρmem ++ have hρ_ne_σ : ρ ≠ σ := (Finset.mem_erase.mp hρmem).1 ++ have hσ_ne_ρ : σ ≠ ρ := hρ_ne_σ.symm ++ exact pow_ne_zero _ (sub_ne_zero.mpr hσ_ne_ρ) ++ have : ++ h_σ σ σ / ++ ∏ ρ ∈ (h_finite_zeros.toFinset.erase σ), ++ (σ - ρ) ^ (analyticOrderAt f ρ).toNat ≠ ++ 0 := by ++ exact div_ne_zero hnum hden ++ simpa [Cf, hσ] using this ++ ++lemma lem_Cf_never_zero ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R1) : ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z ≠ 0 := by ++ ++ by_cases h : z ∈ zerosetKfR R1 (by linarith) f ++ · ++ exact lem_Cf_nonzero_on_K h_finite_zeros h_σ h_σ_spec z h ++ · ++ have hz_diff : z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f := ⟨hz, h⟩ ++ exact lem_Cf_nonzero_off_K h_finite_zeros h_σ h_σ_spec z hz_diff ++ ++lemma factor_nonzero_outside_domain (R R1 : ℝ) (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (_hR_lt_1 : R < 1) ++ (ρ : ℂ) (hρ_bound : ‖ρ‖ ≤ R1) (_hρ_ne_zero : ρ ≠ 0) (z : ℂ) (hz_in_R1 : ‖z‖ ≤ R1) : ++ (R : ℂ) - star ρ * z / (R : ℂ) ≠ 0 := by ++ ++ intro h_eq_zero ++ have hR_pos : 0 < R := by linarith ++ ++ have h_mul_eq_R_sq : star ρ * z = (R : ℂ) ^ 2 := by ++ have hR_ne_zero : (R : ℂ) ≠ 0 := by ++ rw [Ne, ← norm_eq_zero] ++ simp ++ linarith ++ ++ rw [sub_eq_zero] at h_eq_zero ++ rw [eq_div_iff_mul_eq hR_ne_zero] at h_eq_zero ++ rw [← pow_two] at h_eq_zero ++ exact h_eq_zero.symm ++ ++ have h_norm_eq : ‖ρ‖ * ‖z‖ = R ^ 2 := by ++ have h_left : ‖star ρ * z‖ = ‖ρ‖ * ‖z‖ := by ++ rw [norm_mul, norm_star] ++ have h_right : ‖(R : ℂ) ^ 2‖ = R ^ 2 := by ++ rw [Complex.norm_pow, Complex.norm_of_nonneg (le_of_lt hR_pos)] ++ rw [← h_left, h_mul_eq_R_sq, h_right] ++ ++ have h_R_sq_le : R ^ 2 ≤ R1 ^ 2 := by ++ calc R ^ 2 ++ = ‖ρ‖ * ‖z‖ := h_norm_eq.symm ++ _ ≤ R1 * ‖z‖ := mul_le_mul_of_nonneg_right hρ_bound (norm_nonneg z) ++ _ ≤ R1 * R1 := mul_le_mul_of_nonneg_left hz_in_R1 (le_of_lt hR1_pos) ++ _ = R1 ^ 2 := by rw [← pow_two] ++ ++ have h_R_le_R1 : R ≤ R1 := by ++ exact le_of_pow_le_pow_left₀ (by norm_num) (le_of_lt hR1_pos) h_R_sq_le ++ ++ linarith ++ ++lemma linear_pow_analytic (a b : ℂ) (n : ℕ) (z : ℂ) : ++ AnalyticAt ℂ (fun w => (a - b * w) ^ n) z := by ++ ++ have h_linear : AnalyticAt ℂ (fun w => a - b * w) z := by ++ ++ have h_const : AnalyticAt ℂ (fun _ => a) z := analyticAt_const ++ ++ have h_mul : AnalyticAt ℂ (fun w => b * w) z := by ++ have h_id : AnalyticAt ℂ (fun w => w) z := analyticAt_id ++ convert h_id.const_smul (c := b) using 1 ++ ++ exact h_const.sub h_mul ++ ++ exact h_linear.fun_pow n ++ ++lemma bl_num_diff ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {_hR1_lt_R : R1 < R} {_hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {_h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (z : ℂ) (_hz : z ∈ Metric.closedBall (0 : ℂ) R) : ++ DifferentiableAt ℂ ++ (fun w => ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * w / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ · ++ have h_analytic : AnalyticAt ℂ (fun w => ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * w / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ ++ let factor_func : ℂ → ℂ → ℂ := fun ρ w => ((R : ℂ) - star ρ * w / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat ++ ++ have h_each_analytic : ∀ ρ ∈ h_finite_zeros.toFinset, AnalyticAt ℂ (factor_func ρ) z := by ++ intro ρ hρ_mem ++ simp only [factor_func] ++ ++ have h_rewrite : (fun w => ((R : ℂ) - star ρ * w / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) = ++ (fun w => ((R : ℂ) - (star ρ / (R : ℂ)) * w) ^ (analyticOrderAt f ρ).toNat) := by ++ ext w ++ ring ++ rw [h_rewrite] ++ ++ exact linear_pow_analytic (R : ℂ) (star ρ / (R : ℂ)) (analyticOrderAt f ρ).toNat z ++ ++ have h_prod_analytic := Finset.analyticAt_prod h_finite_zeros.toFinset h_each_analytic ++ ++ convert h_prod_analytic using 1; first | rfl | (ext w; simp [factor_func]) ++ ++ exact h_analytic.differentiableAt ++ ++lemma lem_bl_num_nonzero ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f) : ++ (∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) ≠ 0 := by ++ ++ · refine Finset.prod_ne_zero_iff.mpr ?_ ++ intro ρ hρ_mem ++ apply pow_ne_zero ++ ++ have hρ_in_zeros : ρ ∈ zerosetKfR R1 (by linarith) f := ++ h_finite_zeros.mem_toFinset.mp hρ_mem ++ have hρ_bound : ‖ρ‖ ≤ R1 := by ++ ++ have : dist ρ 0 ≤ R1 := Metric.mem_closedBall.mp hρ_in_zeros.1 ++ simp only [dist_zero_right] at this ++ exact this ++ have hρ_ne_zero : ρ ≠ 0 := by ++ intro h_eq_zero ++ rw [h_eq_zero] at hρ_in_zeros ++ exact h_f_nonzero_at_zero hρ_in_zeros.2 ++ have hz_bound : ‖z‖ ≤ R1 := by ++ have : dist z 0 ≤ R1 := Metric.mem_closedBall.mp hz.1 ++ simp only [dist_zero_right] at this ++ exact this ++ exact factor_nonzero_outside_domain R R1 hR1_pos hR1_lt_R hR_lt_1 ρ hρ_bound hρ_ne_zero z hz_bound ++ ++noncomputable def Bf ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (z : ℂ) : ℂ := ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z * ++ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat ++ ++lemma lem_BfCf ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R \ zerosetKfR R1 (by linarith) f) : ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ f z * (∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) / ++ (∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat) := by ++ ++ have hz_not_in : z ∉ zerosetKfR R1 (by linarith) f := hz.2 ++ ++ unfold Bf ++ ++ unfold Cf ++ simp [hz_not_in] ++ ++ exact div_mul_eq_mul_div _ _ _ ++ ++lemma lem_Bf_div ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {_hR1_lt_R : R1 < R} {_hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {_h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (z : ℂ) (_hz : z ∈ Metric.closedBall (0 : ℂ) R \ zerosetKfR R1 (by linarith) f) : ++ (∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) / ++ (∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat) = ++ ∏ ρ ∈ h_finite_zeros.toFinset, ++ (((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat / ++ (z - ρ) ^ (analyticOrderAt f ρ).toNat) := by ++ rw [Finset.prod_div_distrib] ++ ++lemma lem_Bf_prodpow ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {_hR1_lt_R : R1 < R} {_hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {_h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (z : ℂ) (_hz : z ∈ Metric.closedBall (0 : ℂ) R \ zerosetKfR R1 (by linarith) f) : ++ ∏ ρ ∈ h_finite_zeros.toFinset, ++ (((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat / ++ (z - ρ) ^ (analyticOrderAt f ρ).toNat) = ++ ∏ ρ ∈ h_finite_zeros.toFinset, ++ (((R : ℂ) - star ρ * z / (R : ℂ)) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat := by ++ simp only [div_pow] ++ ++lemma lem_Bf_off_K ++ {R R1 : ℝ} {hR1_pos : 0 < R1} {hR1_lt_R : R1 < R} {hR_lt_1 : R < 1} ++ {f : ℂ → ℂ} ++ {h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z} ++ {h_f_nonzero_at_zero : f 0 ≠ 0} ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (z : ℂ) (hz : z ∈ Metric.closedBall (0 : ℂ) R \ zerosetKfR R1 (by linarith) f) : ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ f z * ∏ ρ ∈ h_finite_zeros.toFinset, ++ (((R : ℂ) - star ρ * z / (R : ℂ)) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat := by ++ ++ rw [lem_BfCf h_finite_zeros h_σ z hz] ++ ++ rw [mul_div_assoc] ++ ++ congr 1 ++ ++ rw [@lem_Bf_div R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros z hz] ++ ++ rw [@lem_Bf_prodpow R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros z hz] ++ ++lemma lem_frho_zero_contra ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (_hR1_lt_R : R1 < R) ++ (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (ρ : ℂ) : f ρ ≠ 0 → ρ ∉ zerosetKfR R1 (by linarith) f := by ++ intro h_f_rho_ne_zero h_rho_in_KfR1 ++ ++ have h_f_rho_zero : f ρ = 0 := h_rho_in_KfR1.2 ++ ++ exact h_f_rho_ne_zero h_f_rho_zero ++ ++lemma lem_f_is_nonzero (f : ℂ → ℂ) : f 0 ≠ 0 → f ≠ 0 := by ++ intro h_f_zero_ne_zero h_f_eq_zero ++ ++ have h_f_at_zero_eq_zero : f 0 = 0 := by ++ rw [h_f_eq_zero] ++ simp ++ ++ exact h_f_zero_ne_zero h_f_at_zero_eq_zero ++ ++theorem lem_rho_in_disk_R1 ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (_hR1_lt_R : R1 < R) ++ (f : ℂ → ℂ) ++ (ρ : ℂ) (h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) : ++ norm ρ ≤ R1 := by ++ ++ have h_in_ball : ρ ∈ Metric.closedBall (0 : ℂ) R1 := h_rho_in_KfR1.1 ++ ++ rw [Metric.mem_closedBall, Complex.dist_eq] at h_in_ball ++ simp only [sub_zero] at h_in_ball ++ exact h_in_ball ++ ++theorem lem_zero_not_in_Kf (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (_hR1_lt_R : R1 < R) ++ (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) : ++ f 0 ≠ 0 → 0 ∉ zerosetKfR R1 (by linarith) f := by ++ intro h_f_zero_ne_zero h_zero_in_KfR1 ++ ++ have h_f_zero_eq_zero : f 0 = 0 := h_zero_in_KfR1.2 ++ ++ exact h_f_zero_ne_zero h_f_zero_eq_zero ++ ++lemma lem_rho_ne_zero (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) : ++ ∀ ρ ∈ zerosetKfR R1 (by linarith) f, ρ ≠ 0 := by ++ intro ρ h_ρ_in_zeros h_ρ_eq_zero ++ ++ rw [h_ρ_eq_zero] at h_ρ_in_zeros ++ ++ have h_zero_not_in : 0 ∉ zerosetKfR R1 (by linarith) f := ++ lem_zero_not_in_Kf R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ++ exact h_zero_not_in h_ρ_in_zeros ++ ++lemma lem_mod_pos_iff_ne_zero (z : ℂ) : z ≠ 0 → norm z > 0 := ++ lem_abspos z ++ ++theorem lem_mod_rho_pos ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) : ++ ∀ (ρ : ℂ), ρ ∈ zerosetKfR R1 (by linarith) f → norm ρ > 0 := by ++ intro ρ h_ρ_in_zeros ++ ++ have h_ρ_ne_zero : ρ ≠ 0 := ++ lem_rho_ne_zero R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ρ h_ρ_in_zeros ++ ++ exact lem_mod_pos_iff_ne_zero ρ h_ρ_ne_zero ++ ++theorem lem_rho_in_disk_R1_repeat (R R1 : ℝ) (hR1_pos : 0 < R1) ++(hR1_lt_R : R1 < R) (f : ℂ → ℂ) ++ (ρ : ℂ) (h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) : ++ norm ρ ≤ R1 := ++ lem_rho_in_disk_R1 R R1 hR1_pos hR1_lt_R f ρ h_rho_in_KfR1 ++ ++lemma lem_inv_mono_decr (x y : ℝ) (hx : 0 < x) (hxy : x ≤ y) : 1 / x ≥ 1 / y := by ++ ++ have hy : 0 < y := lt_of_lt_of_le hx hxy ++ ++ exact one_div_le_one_div_of_le hx hxy ++ ++lemma lem_inv_mod_rho_ge_inv_R1 (R R1 : ℝ) (hR1_pos : 0 < R1) ++(hR1_lt_R : R1 < R) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (ρ : ℂ) (h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) : ++ 1 / norm ρ ≥ 1 / R1 := by ++ ++ have h_abs_ρ_le_R1 : norm ρ ≤ R1 := ++ lem_rho_in_disk_R1 R R1 hR1_pos hR1_lt_R f ρ h_rho_in_KfR1 ++ ++ have h_abs_ρ_pos : norm ρ > 0 := ++ lem_mod_rho_pos R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ρ h_rho_in_KfR1 ++ ++ have h_R1_pos : R1 > 0 := by ++ linarith ++ ++ exact lem_inv_mono_decr (norm ρ) R1 h_abs_ρ_pos h_abs_ρ_le_R1 ++ ++theorem lem_mul_pos_preserves_ineq (a b c : ℝ) (hab : a ≤ b) (hc : 0 < c) : ++ a * c ≤ b * c := by ++ exact mul_le_mul_of_nonneg_right hab (le_of_lt hc) ++ ++theorem lem_R_div_mod_rho_ge_R_div_R1 (R R1 : ℝ) (hR1_pos : 0 < R1) ++(hR1_lt_R : R1 < R) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) (ρ : ℂ) ++ (h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) : ++ R / norm ρ ≥ R / R1 := by ++ ++ have h_inv_ineq : 1 / norm ρ ≥ 1 / R1 := ++ lem_inv_mod_rho_ge_inv_R1 R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ρ h_rho_in_KfR1 ++ ++ have h_R_div_abs_ρ_eq : R * (1 / norm ρ) = R / norm ρ := by ring ++ have h_R_div_R1_eq : R * (1 / R1) = R / R1 := by ring ++ rw [← h_R_div_abs_ρ_eq, ← h_R_div_R1_eq] ++ exact mul_le_mul_of_nonneg_left h_inv_ineq (by linarith) ++ ++theorem lem_R_div_mod_rho_ge_R_over_R1 (R R1 : ℝ) (hR1_pos : 0 < R1) ++(hR1_lt_R : R1 < R) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) (ρ : ℂ) ++ (h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) : ++ R / norm ρ ≥ (R/R1 : ℝ) := by ++ ++ have h_ineq1 : R / norm ρ ≥ R / R1 := ++ lem_R_div_mod_rho_ge_R_div_R1 R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ρ h_rho_in_KfR1 ++ ++ linarith ++ ++theorem lem_mod_of_prod2 {ι : Type*} (K : Finset ι) (w : ι → ℂ) : ++ ‖∏ ρ ∈ K, w ρ‖ = ∏ ρ ∈ K, ‖w ρ‖ := by ++ classical ++ refine Finset.induction_on K ?h0 ?hstep ++ · simp ++ · intro a s ha ih ++ ++ simp [Finset.prod_insert ha, ih] ++ ++lemma lem_mod_Bf_is_prod_mod (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (z : ℂ) ++ (hz : z ∉ zerosetKfR R1 (by linarith) f) : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ = ++ ‖f z‖ * ∏ ρ ∈ h_finite_zeros.toFinset, ++ ‖(((R : ℂ) - z * star ρ / (R : ℂ)) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat‖ := by ++ ++ unfold Bf ++ rw [norm_mul] ++ ++ rw [lem_mod_of_prod2] ++ ++ have hCf : Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ f z / ∏ ρ ∈ h_finite_zeros.toFinset, (z - ρ) ^ (analyticOrderAt f ρ).toNat := by ++ unfold Cf ++ simp only [hz, ↓reduceDIte] ++ rw [hCf, norm_div] ++ ++ rw [lem_mod_of_prod2] ++ ++ rw [div_mul_eq_mul_div] ++ ++ rw [mul_div_assoc] ++ ++ rw [← Finset.prod_div_distrib] ++ congr 2 ++ ext ρ ++ ++ rw [← norm_div, ← div_pow] ++ congr 2 ++ ++ ring ++ ++lemma lem_abs_pow (w : ℂ) (n : ℕ) : ‖w ^ n‖ = ‖w‖ ^ n := by ++ simp ++ ++lemma lem_Bmod_pow (R R1 : ℝ) (hR_pos : 0 < R) (hR1 : R1 = 2 * R / 3) (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (ρ : ℂ) (_h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) ++ (z : ℂ) : ++ ‖((((R : ℂ) - z * star ρ / (R : ℂ)) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat)‖ = ++ (‖(((R : ℂ) - z * star ρ / (R : ℂ)) / (z - ρ))‖) ^ (analyticOrderAt f ρ).toNat := by ++ simp ++ ++lemma lem_mod_Bf_prod_mod (R R1 : ℝ) (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (z : ℂ) ++ (hz : z ∉ zerosetKfR R1 (by linarith) f) : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ = ++ ‖f z‖ * ∏ ρ ∈ h_finite_zeros.toFinset, ++ ‖(((R : ℂ) - z * star ρ / (R : ℂ)) / (z - ρ))‖ ^ (analyticOrderAt f ρ).toNat := by ++ ++ have h1 := lem_mod_Bf_is_prod_mod R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec z hz ++ rw [h1] ++ ++ congr 2 ++ ext ρ ++ rw [lem_abs_pow] ++ ++lemma lem_mod_Bf_at_0 (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ = ++ ‖f 0‖ * ∏ ρ ∈ h_finite_zeros.toFinset, ++ ‖((R : ℂ) / (-ρ))‖ ^ (analyticOrderAt f ρ).toNat := by ++ ++ have hz0 : 0 ∉ zerosetKfR R1 (by linarith) f := ++ lem_zero_not_in_Kf R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ++ rw [lem_mod_Bf_prod_mod R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec 0 hz0] ++ ++ congr 2 ++ ext ρ ++ congr 1 ++ simp only [zero_mul, zero_div, sub_zero, zero_sub] ++ ++lemma lem_mod_div_ (w1 w2 : ℂ) (_hw2_ne_zero : w2 ≠ 0) : ‖w1 / w2‖ = ‖w1‖ / ‖w2‖ := by ++ simp ++ ++lemma lem_mod_neg (w : ℂ) : ‖-w‖ = ‖w‖ := by ++ simp ++ ++lemma lem_mod_div_and_neg (R : ℝ) (hR_pos : 0 < R) (ρ : ℂ) (h_rho_ne_zero : ρ ≠ 0) : ++ ‖(R : ℂ) / (-ρ)‖ = R / ‖ρ‖ := by ++ ++ have hden : (-ρ) ≠ 0 := by simpa using neg_ne_zero.mpr h_rho_ne_zero ++ have hdiv := lem_mod_div_ (R : ℂ) (-ρ) hden ++ calc ++ ‖(R : ℂ) / (-ρ)‖ = ‖(R : ℂ)‖ / ‖-ρ‖ := hdiv ++ _ = ‖(R : ℂ)‖ / ‖ρ‖ := by simp [norm_neg] ++ _ = |R| / ‖ρ‖ := by simp ++ _ = R / ‖ρ‖ := by simp [abs_of_pos hR_pos] ++ ++theorem lem_mod_Bf_at_0_eval (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ = ++ ‖f 0‖ * ∏ ρ ∈ h_finite_zeros.toFinset, ++ (R / ‖ρ‖) ^ (analyticOrderAt f ρ).toNat := by ++ ++ rw [lem_mod_Bf_at_0 R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec] ++ ++ congr 1 ++ ++ apply Finset.prod_congr rfl ++ intro ρ hρ ++ ++ have h_ρ_ne_zero : ρ ≠ 0 := by ++ ++ have h_ρ_in_zeros : ρ ∈ zerosetKfR R1 (by linarith) f := by ++ exact (Set.Finite.mem_toFinset h_finite_zeros).mp hρ ++ exact lem_rho_ne_zero R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ρ h_ρ_in_zeros ++ ++ rw [lem_mod_div_and_neg R (by linarith) ρ h_ρ_ne_zero] ++ ++lemma lem_mod_of_pos_real (x : ℝ) (hx : 0 < x) : abs x = x := by ++ exact abs_of_pos hx ++ ++theorem lem_mod_Bf_at_0_as_ratio (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ = ++ ‖f 0‖ * ∏ ρ ∈ h_finite_zeros.toFinset, ++ (R / ‖ρ‖) ^ (analyticOrderAt f ρ).toNat := by ++ exact lem_mod_Bf_at_0_eval R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec ++ ++lemma lem_prod_ineq {ι : Type*} (K : Finset ι) (a b : ι → ℝ) ++ (h_nonneg : ∀ ρ ∈ K, 0 ≤ a ρ) (h_le : ∀ ρ ∈ K, a ρ ≤ b ρ) : ++ ∏ ρ ∈ K, a ρ ≤ ∏ ρ ∈ K, b ρ := by ++ exact Finset.prod_le_prod₀ h_nonneg h_le ++ ++lemma lem_power_ineq (n : ℕ) (c : ℝ) (hc : c > 1) (hn : n ≥ 1) : c ≤ c ^ n := by ++ cases' n with n ++ · ++ omega ++ · ++ have h_c_ge_1 : 1 ≤ c := le_of_lt hc ++ rw [pow_succ] ++ ++ have h_c_pow_n_ge_1 : 1 ≤ c ^ n := by exact one_le_pow₀ h_c_ge_1 ++ calc c = c * 1 := (mul_one c).symm ++ _ ≤ c * c ^ n := mul_le_mul_of_nonneg_left h_c_pow_n_ge_1 (le_of_lt (lt_trans zero_lt_one hc)) ++ _ = c ^ n * c := mul_comm (c) (c ^ n) ++ ++lemma lem_power_ineq_1 (n : ℕ) (c : ℝ) (hc : 1 ≤ c) (_hn : 1 ≤ n) : 1 ≤ c ^ n := by ++ exact one_le_pow₀ hc ++ ++lemma lem_prod_power_ineq {ι : Type*} (K : Finset ι) (c : ι → ℝ) (n : ι → ℕ) ++ (h_c_ge_1 : ∀ ρ ∈ K, 1 ≤ c ρ) ++ (h_n_ge_1 : ∀ ρ ∈ K, 1 ≤ n ρ) : ++ ∏ ρ ∈ K, (c ρ) ^ (n ρ) ≥ 1 := by ++ classical ++ induction K using Finset.induction with ++ | empty => simp ++ | insert i s h_not_in ih => ++ rw [Finset.prod_insert h_not_in] ++ have h_pow_ge_1 : 1 ≤ c i ^ n i := ++ one_le_pow₀ (h_c_ge_1 i (Finset.mem_insert_self i s)) ++ have h_prod_ge_1 : 1 ≤ ∏ ρ ∈ s, (c ρ) ^ (n ρ) := by ++ apply ih ++ · intro ρ hρ; exact h_c_ge_1 ρ (Finset.mem_insert_of_mem hρ) ++ · intro ρ hρ; exact h_n_ge_1 ρ (Finset.mem_insert_of_mem hρ) ++ exact one_le_mul_of_one_le_of_one_le h_pow_ge_1 h_prod_ge_1 ++ ++theorem lem_prod_1 {ι : Type*} {M : Type*} [CommMonoid M] (K : Finset ι) : ∏ _ρ ∈ K, (1 : M) = 1 := by ++ exact Finset.prod_const_one ++ ++lemma lem_prod_power_ineq1 {ι : Type*} (K : Finset ι) (c : ι → ℝ) (n : ι → ℕ) ++ (h_c_ge_1 : ∀ ρ ∈ K, 1 ≤ c ρ) (h_n_ge_1 : ∀ ρ ∈ K, 1 ≤ n ρ) : ++ ∏ ρ ∈ K, (c ρ) ^ (n ρ) ≥ 1 := by ++ exact lem_prod_power_ineq K c n h_c_ge_1 h_n_ge_1 ++ ++lemma lem_mod_lower_bound_1 (R R1 : ℝ) (hR1_pos : 0 < R1) ++(hR1_lt_R : R1 < R) (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (_hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (_hR_lt_1 : R < 1) : ++ ∏ ρ ∈ h_finite_zeros.toFinset, ++ (R/R1 : ℝ) ^ (analyticOrderAt f ρ).toNat ≥ 1 := by ++ classical ++ set K := h_finite_zeros.toFinset ++ ++ have h_base_ge_1 : (1 : ℝ) < (R/R1 : ℝ) := by exact (one_lt_div hR1_pos).mpr hR1_lt_R ++ have h := ++ lem_prod_ineq K (fun _ : ℂ => (1 : ℝ)) ++ (fun ρ : ℂ => (R/R1 : ℝ) ^ (analyticOrderAt f ρ).toNat) ++ (by intro ρ hρ; norm_num) ++ (by ++ intro ρ hρ ++ simpa using (one_le_pow₀ (by linarith [h_base_ge_1]))) ++ simpa [K] using h ++ ++theorem lem_mod_Bf_at_0_ge_1 (R R1 : ℝ) (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ ≥ 1 := by ++ ++ have R_over_R1_nonneg : 1 < R / R1 := by exact (one_lt_div hR1_pos).mpr hR1_lt_R ++ have R_over_R1_nonneg : 0 ≤ R / R1 := by linarith ++ have h_f_nonzero_at_zero : f 0 ≠ 0 := by ++ rw [hf0_eq_one]; norm_num ++ ++ rw [lem_mod_Bf_at_0_as_ratio R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros] ++ ++ rw [hf0_eq_one, norm_one, one_mul] ++ ++ have h_prod_ge : ∏ ρ ∈ h_finite_zeros.toFinset, (R / ‖ρ‖) ^ (analyticOrderAt f ρ).toNat ≥ ++ ∏ ρ ∈ h_finite_zeros.toFinset, (R/R1 : ℝ) ^ (analyticOrderAt f ρ).toNat := by ++ apply Finset.prod_le_prod₀ ++ ++ · intro ρ hρ ++ apply pow_nonneg ++ apply R_over_R1_nonneg ++ ++ · intro ρ hρ ++ have h_ρ_in_zeros : ρ ∈ zerosetKfR R1 (by linarith) f := by ++ exact (Set.Finite.mem_toFinset h_finite_zeros).mp hρ ++ ++ have h_ratio_ge : R / ‖ρ‖ ≥ (R/R1 : ℝ) := by ++ ++ have h_norm_abs_eq : ‖ρ‖ = norm ρ := by rfl ++ rw [h_norm_abs_eq] ++ exact lem_R_div_mod_rho_ge_R_over_R1 R R1 hR1_pos hR1_lt_R f h_f_analytic h_f_nonzero_at_zero ρ h_ρ_in_zeros ++ ++ have h_3_2_pos : (1 : ℝ) < (R/R1 : ℝ) := by exact (one_lt_div hR1_pos).mpr hR1_lt_R ++ have h_3_2_pos : (0 : ℝ) < (R/R1 : ℝ) := by linarith ++ have h_ratio_pos : (0 : ℝ) ≤ R / ‖ρ‖ := by ++ linarith [h_ratio_ge] ++ exact pow_le_pow_left₀ R_over_R1_nonneg h_ratio_ge (analyticOrderAt f ρ).toNat ++ ++ have h_3_2_prod_ge_1 : ∏ ρ ∈ h_finite_zeros.toFinset, (R/R1 : ℝ) ^ (analyticOrderAt f ρ).toNat ≥ 1 := ++ lem_mod_lower_bound_1 R R1 hR1_pos hR1_lt_R f h_f_analytic hf0_eq_one h_finite_zeros hR_lt_1 ++ ++ exact le_trans h_3_2_prod_ge_1 h_prod_ge ++ assumption ++ ++lemma lem_linear_factor_analytic (R : ℝ) (_hR_pos : 0 < R) (ρ : ℂ) (z : ℂ) : ++ AnalyticAt ℂ (fun w => (R : ℂ) - star ρ * w / (R : ℂ)) z := by ++ ++ have h_const : AnalyticAt ℂ (fun _ => (R : ℂ)) z := analyticAt_const ++ ++ have h_id : AnalyticAt ℂ (fun w => w) z := analyticAt_id ++ ++ have h_const_coeff : AnalyticAt ℂ (fun _ => star ρ / (R : ℂ)) z := analyticAt_const ++ ++ have h_mul : AnalyticAt ℂ (fun w => star ρ / (R : ℂ) * w) z := ++ AnalyticAt.fun_mul h_const_coeff h_id ++ ++ have h_sub : AnalyticAt ℂ (fun w => (R : ℂ) - star ρ / (R : ℂ) * w) z := ++ AnalyticAt.fun_sub h_const h_mul ++ ++ convert h_sub using 1 ++ ext w ++ ring ++ ++lemma lem_pow_analyticAt {g : ℂ → ℂ} (n : ℕ) (w : ℂ) : ++ AnalyticAt ℂ g w → AnalyticAt ℂ (fun z => (g z) ^ n) w := by ++ intro hg ++ exact AnalyticAt.fun_pow hg n ++ ++lemma lem_finset_prod_analyticAt {α : Type*} {S : Finset α} {g : α → ℂ → ℂ} (w : ℂ) : ++ (∀ a ∈ S, AnalyticAt ℂ (g a) w) → AnalyticAt ℂ (fun z => ∏ a ∈ S, g a z) w := by ++ intro h ++ classical ++ induction S using Finset.induction with ++ | empty => ++ ++ simp only [Finset.prod_empty] ++ exact analyticAt_const ++ | insert a s ha ih => ++ ++ simp only [Finset.prod_insert ha] ++ ++ apply AnalyticAt.fun_mul ++ · ++ apply h ++ exact Finset.mem_insert_self a s ++ · ++ apply ih ++ intro b hb ++ apply h ++ exact Finset.mem_insert_of_mem hb ++ ++lemma analyticOrderAt_top_iff_eventually_zero (f : ℂ → ℂ) (z : ℂ) (hf : AnalyticAt ℂ f z) : ++ analyticOrderAt f z = ⊤ ↔ ∀ᶠ w in nhds z, f w = 0 := by ++ simp [analyticOrderAt, hf] ++ ++lemma isPreconnected_closedBall (x : ℂ) (r : ℝ) : IsPreconnected (Metric.closedBall x r) := by ++ ++ have h_convex : Convex ℝ (Metric.closedBall x r) := convex_closedBall _ _ ++ ++ exact h_convex.isPreconnected ++ ++lemma Set.infinite_Icc_of_lt {a b : ℝ} (h : a < b) : (Set.Icc a b).Infinite := by ++ ++ intro h_finite ++ ++ have h_subset : Set.Ioo a b ⊆ Set.Icc a b := Set.Ioo_subset_Icc_self ++ ++ have h_Ioo_finite : (Set.Ioo a b).Finite := h_finite.subset h_subset ++ ++ have h_Ioo_infinite : (Set.Ioo a b).Infinite := Set.Ioo_infinite h ++ ++ exact h_Ioo_infinite h_Ioo_finite ++ ++lemma infinite_closedBall_of_pos (x : ℂ) (r : ℝ) (hr : 0 < r) : (Metric.closedBall x r).Infinite := by ++ ++ let f : ℝ → ℂ := fun t => x + t ++ ++ have h_maps_to : Set.MapsTo f (Set.Icc 0 (r/2)) (Metric.closedBall x r) := by ++ intro t ht ++ rw [Metric.mem_closedBall] ++ ++ have h_eq : f t = x + t := rfl ++ rw [h_eq, Complex.dist_eq, add_sub_cancel_left] ++ ++ have h_norm : ‖(t : ℂ)‖ = |t| := by ++ exact Complex.norm_real t ++ rw [h_norm, abs_of_nonneg ht.1] ++ exact le_trans ht.2 (le_of_lt (half_lt_self hr)) ++ ++ have h_inj : Set.InjOn f (Set.Icc 0 (r/2)) := by ++ intro s hs t ht h_eq ++ have : x + s = x + t := h_eq ++ have : (s : ℂ) = (t : ℂ) := add_left_cancel this ++ exact Complex.ofReal_inj.mp this ++ ++ have h_infinite_interval : (Set.Icc (0:ℝ) (r/2)).Infinite := ++ Set.infinite_Icc_of_lt (half_pos hr) ++ ++ have h_infinite_image : (f '' Set.Icc 0 (r/2)).Infinite := ++ Set.Infinite.image h_inj h_infinite_interval ++ ++ have h_subset : f '' Set.Icc 0 (r/2) ⊆ Metric.closedBall x r := ++ Set.MapsTo.image_subset h_maps_to ++ ++ intro h_finite ++ exact h_infinite_image (h_finite.subset h_subset) ++ ++lemma analyticOrderAt_ne_top_of_finite_zeros_in_ball (f : ℂ → ℂ) (R : ℝ) (hR_pos : 0 < R) ++ (hf_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) R, AnalyticAt ℂ f z) ++ (ρ : ℂ) (_hρ_zero : f ρ = 0) (hρ_in_ball : ρ ∈ Metric.closedBall (0 : ℂ) R) ++ (h_finite_zeros : {z ∈ Metric.closedBall (0 : ℂ) R | f z = 0}.Finite) : ++ analyticOrderAt f ρ ≠ ⊤ := by ++ ++ by_contra htop ++ ++ have h_eventually_zero : ∀ᶠ z in nhds ρ, f z = 0 := by ++ rw [← analyticOrderAt_top_iff_eventually_zero f ρ (hf_analytic ρ hρ_in_ball)] ++ exact htop ++ ++ have hf_on_ball : AnalyticOnNhd ℂ f (Metric.closedBall (0 : ℂ) R) := by ++ intro z ++ exact hf_analytic z ++ ++ have h_preconn : IsPreconnected (Metric.closedBall (0 : ℂ) R) := ++ isPreconnected_closedBall (0 : ℂ) R ++ ++ have h_eqOn_zero : Set.EqOn f 0 (Metric.closedBall (0 : ℂ) R) := ++ AnalyticOnNhd.eqOn_zero_of_preconnected_of_eventuallyEq_zero hf_on_ball h_preconn hρ_in_ball h_eventually_zero ++ ++ have h_all_zeros : ∀ z ∈ Metric.closedBall (0 : ℂ) R, f z = 0 := by ++ intro z hz ++ have := h_eqOn_zero hz ++ simpa [Pi.zero_apply] using this ++ ++ have h_zero_set_eq : {z ∈ Metric.closedBall (0 : ℂ) R | f z = 0} = Metric.closedBall (0 : ℂ) R := by ++ ext z ++ constructor ++ · intro hz; exact hz.1 ++ · intro hz; exact ⟨hz, h_all_zeros z hz⟩ ++ ++ have h_ball_infinite : (Metric.closedBall (0 : ℂ) R).Infinite := ++ infinite_closedBall_of_pos (0 : ℂ) R hR_pos ++ ++ rw [h_zero_set_eq] at h_finite_zeros ++ exact h_ball_infinite h_finite_zeros ++ ++theorem lem_Bf_is_analytic (R R1 : ℝ) (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ AnalyticOnNhd ℂ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ) (Metric.closedBall (0 : ℂ) R) := by ++ ++ intro z hz ++ ++ have h_blaschke_linear : ∀ ρ ∈ h_finite_zeros.toFinset, ++ AnalyticAt ℂ (fun w => (R : ℂ) - star ρ * w / (R : ℂ)) z := by ++ intro ρ hρ ++ ++ have h_eq : (fun w : ℂ => (R : ℂ) - star ρ * w / (R : ℂ)) = ++ (fun w : ℂ => (R : ℂ) + (-(star ρ) / (R : ℂ)) * w) := by ++ funext w ++ field_simp ++ ring ++ rw [h_eq] ++ exact analyticAt_const.add (analyticAt_const.mul analyticAt_id) ++ ++ have h_powers : ∀ ρ ∈ h_finite_zeros.toFinset, ++ AnalyticAt ℂ (fun w => ((R : ℂ) - star ρ * w / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro ρ hρ ++ exact (h_blaschke_linear ρ hρ).fun_pow _ ++ ++ have h_product : AnalyticAt ℂ (fun w => ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * w / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ ++ apply lem_finset_prod_analyticAt z ++ intro ρ hρ ++ apply h_powers ++ exact hρ ++ ++ by_cases hz_in : z ∈ zerosetKfR R1 (by linarith) f ++ · ++ have h_cf_at_sigma := @lem_Cf_analytic_at_K R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec z hz_in ++ ++ exact AnalyticAt.fun_mul h_cf_at_sigma h_product ++ ++ · ++ have hz_in_compl : z ∈ Metric.closedBall (0 : ℂ) R \ zerosetKfR R1 (by linarith) f := by ++ constructor ++ · exact hz ++ · exact hz_in ++ have h_cf_off := @lem_Cf_analytic_off_K R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec z hz_in_compl ++ exact AnalyticAt.fun_mul h_cf_off h_product ++ ++lemma complex_mul_star_eq_norm_sq (z : ℂ) : z * star z = (‖z‖ ^ 2 : ℂ) := by ++ ++ rw [Complex.star_def] ++ ++ exact Complex.mul_conj' z ++ ++lemma lem_mod_Bf_eq_mod_f_on_boundary (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ∀ z : ℂ, ‖z‖ = R → ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ = ‖f z‖ := by ++ intro z hz ++ ++ have hz_not_in : z ∉ zerosetKfR R1 (by linarith) f := by ++ intro h_in ++ ++ have h_norm_le_R1 : ‖z‖ ≤ R1 := by simpa [sub_zero] using (h_in.1 : z ∈ Metric.closedBall (0 : ℂ) R1) ++ ++ have h_norm_eq_R : ‖z‖ = R := by simpa using hz ++ linarith [h_norm_le_R1, h_norm_eq_R, hR1_lt_R] ++ rw [lem_mod_Bf_prod_mod R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec z hz_not_in] ++ ++ have h_each_factor_one : ∀ ρ ∈ h_finite_zeros.toFinset, ‖(((R : ℂ) - z * star ρ / (R : ℂ)) / (z - ρ))‖ = 1 := by ++ intro ρ hρ ++ ++ have z_ne_rho : z ≠ ρ := by ++ intro h_eq ++ have rho_in_zeros : ρ ∈ zerosetKfR R1 (by linarith) f := (Set.Finite.mem_toFinset h_finite_zeros).mp hρ ++ have rho_bound : ‖ρ‖ ≤ R1 := by ++ have h_in_ball : ρ ∈ Metric.closedBall (0 : ℂ) R1 := rho_in_zeros.1 ++ rw [Metric.mem_closedBall, Complex.dist_eq] at h_in_ball ++ simpa using h_in_ball ++ have R1_lt_R : R1 < R := by linarith ++ rw [← h_eq, hz] at rho_bound ++ linarith [R1_lt_R] ++ ++ rw [Complex.norm_div] ++ ++ have z_conj_eq : z * star z = (R ^ 2 : ℂ) := by ++ rw [complex_mul_star_eq_norm_sq z, hz, pow_two] ++ ++ have num_rewrite : (R : ℂ) - z * star ρ / (R : ℂ) = ((R : ℂ)^2 - z * star ρ) / (R : ℂ) := by ++ have hRne : (R : ℂ) ≠ 0 := by exact_mod_cast (hR1_pos.trans hR1_lt_R).ne' ++ field_simp [hRne] ++ ++ rw [num_rewrite, Complex.norm_div] ++ ++ have factor_eq : (R : ℂ)^2 - z * star ρ = z * star (z - ρ) := by ++ rw [← z_conj_eq, star_sub] ++ ring ++ ++ rw [factor_eq, Complex.norm_mul, norm_star, ←hz] ++ have hRpos : 0 < R := hR1_pos.trans hR1_lt_R ++ have hnorm_denom : ‖z - ρ‖ ≠ 0 := norm_ne_zero_iff.mpr (sub_ne_zero.mpr z_ne_rho) ++ simp [hz, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hRpos, hnorm_denom, hRpos.ne'] ++ ++ have h_prod_one : ∏ ρ ∈ h_finite_zeros.toFinset, ‖(((R : ℂ) - z * star ρ / (R : ℂ)) / (z - ρ))‖ ^ (analyticOrderAt f ρ).toNat = 1 := by ++ ++ rw [← Finset.prod_congr rfl (fun ρ hρ => by rw [h_each_factor_one ρ hρ, one_pow])] ++ rw [Finset.prod_const_one] ++ ++ rw [h_prod_one, mul_one] ++ ++lemma lem_Bf_bounded_on_boundary (B R R1 : ℝ) (_hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) : ++ ∀ z : ℂ, ‖z‖ = R → ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ ≤ B := by ++ ++ intro z hz ++ have hz_le : ‖z‖ ≤ R := le_of_eq hz ++ have h_eq := ++ lem_mod_Bf_eq_mod_f_on_boundary R R1 (by linarith) hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec z hz ++ simpa [h_eq] using hf_le_B z hz_le ++ ++lemma norm_eq_radius_of_mem_sphere (w : ℂ) (R : ℝ) (hw : w ∈ Metric.sphere (0 : ℂ) R) : ‖w‖ = R := by ++ have hdist : dist w (0 : ℂ) = R := by simpa [Metric.sphere] using hw ++ simpa [Complex.dist_eq, sub_zero] using hdist ++ ++lemma mem_closedBall_of_norm_le {z : ℂ} {R : ℝ} (hz : ‖z‖ ≤ R) : z ∈ Metric.closedBall (0 : ℂ) R := by ++ have : dist z (0 : ℂ) ≤ R := by simpa [Complex.dist_eq, sub_zero] using hz ++ simpa [Metric.closedBall] using this ++ ++lemma closure_ball_eq_closedBall_center (R : ℝ) (hR : 0 < R) : ++ closure (Metric.ball (0 : ℂ) R) = Metric.closedBall (0 : ℂ) R := by ++ simpa using (closure_ball (x := (0 : ℂ)) (r := R) (ne_of_gt hR)) ++ ++lemma lem_max_mod_principle_for_Bf (B R : ℝ) (hB : 1 < B) (hR_pos : 0 < R) ++ (fB : ℂ → ℂ) ++ (h_analytic : AnalyticOnNhd ℂ fB (Metric.closedBall (0 : ℂ) R)) ++ (h_bd_boundary : ∀ z : ℂ, ‖z‖ = R → ‖fB z‖ ≤ B) : ++ ∀ z : ℂ, ‖z‖ ≤ R → ‖fB z‖ ≤ B := by ++ intro z hz ++ ++ have hB0 : 0 ≤ B := le_of_lt (lt_trans zero_lt_one hB) ++ ++ have h_an_on_closure : AnalyticOn ℂ fB (closure (ballDR R)) := by ++ simpa [ballDR, closure_ball_eq_closedBall_center R hR_pos] using h_analytic.analyticOn ++ ++ have h_le := ++ lem_HardMMP R B hR_pos hB0 fB h_an_on_closure (by ++ intro z hzR; exact h_bd_boundary z hzR) ++ ++ have hz_cl : z ∈ closure (ballDR R) := by ++ have hz_closed : z ∈ Metric.closedBall (0 : ℂ) R := mem_closedBall_of_norm_le hz ++ simpa [ballDR, closure_ball_eq_closedBall_center R hR_pos] using hz_closed ++ exact h_le z hz_cl ++ ++lemma lem_Bf_bounded_in_disk_from_boundary (B R R1 : ℝ) ++ (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_bd_boundary : ∀ z : ℂ, ‖z‖ = R → ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ ≤ B) : ++ ∀ z : ℂ, ‖z‖ ≤ R → ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ ≤ B := by ++ have hA := lem_Bf_is_analytic R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec ++ exact lem_max_mod_principle_for_Bf B R hB (by linarith) ++ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ) hA h_bd_boundary ++ ++lemma lem_Bf_bounded_in_disk_from_f (B R R1 : ℝ) ++ (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) : ++ ∀ z : ℂ, ‖z‖ ≤ R → ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ ≤ B := by ++ intro z hz ++ have h_bd_boundary : ∀ z : ℂ, ‖z‖ = R → ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z‖ ≤ B := ++ lem_Bf_bounded_on_boundary B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec hf_le_B ++ exact (lem_Bf_bounded_in_disk_from_boundary B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec h_bd_boundary) z hz ++ ++lemma lem_Bf_at_0_le_M (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ ≤ B := by ++ have h := ++ lem_Bf_bounded_in_disk_from_f B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ h_σ_spec hf_le_B ++ have h0 : ‖(0 : ℂ)‖ ≤ R := by simpa using (le_of_lt (by linarith)) ++ simpa using h 0 h0 ++ ++lemma lem_combine_bounds_on_Bf0 (B R R1 : ℝ) (_hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (hBf0 : ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ ≤ B) : ++ (R / R1 : ℝ) ^ (∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat : ℝ) ≤ B := by ++ classical ++ ++ set K := h_finite_zeros.toFinset ++ ++ have hf0_ne0 : f 0 ≠ 0 := by simp [hf0_eq_one] ++ have hf0_norm : ‖f 0‖ = 1 := by simp [hf0_eq_one] ++ have h_eval0 := ++ lem_mod_Bf_at_0_eval R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic hf0_ne0 h_finite_zeros h_σ h_σ_spec ++ have h_eval_prod : ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ ++ = ∏ ρ ∈ K, (R / ‖ρ‖) ^ (analyticOrderAt f ρ).toNat := by ++ rw [h_eval0, hf0_norm, one_mul] ++ ++ have h_base_ge : ∀ ρ ∈ K, R / ‖ρ‖ ≥ (R/R1 : ℝ) := by ++ intro ρ hρK ++ have hρ_in : ρ ∈ zerosetKfR R1 (by linarith) f := by simpa [K] using hρK ++ simpa using ++ (lem_R_div_mod_rho_ge_R_over_R1 R R1 hR1_pos hR1_lt_R f h_f_analytic hf0_ne0 ρ hρ_in) ++ ++ have R_over_R1_nonneg : 0 ≤ R/R1 := by ++ have : 0 ≤ R := by linarith ++ apply div_nonneg (by assumption) (le_of_lt hR1_pos) ++ have h_prod_le : ++ ∏ ρ ∈ K, (R/R1 : ℝ) ^ (analyticOrderAt f ρ).toNat ++ ≤ ∏ ρ ∈ K, (R / ‖ρ‖) ^ (analyticOrderAt f ρ).toNat := by ++ refine lem_prod_ineq K ++ (fun ρ => (R/R1 : ℝ) ^ (analyticOrderAt f ρ).toNat) ++ (fun ρ => (R / ‖ρ‖) ^ (analyticOrderAt f ρ).toNat) ++ ?h_nonneg ?h_le ++ · intro ρ hρK; exact pow_nonneg (R_over_R1_nonneg) _ ++ · intro ρ hρK ++ exact pow_le_pow_left₀ (by linarith : (0 : ℝ) ≤ R / R1) (h_base_ge ρ hρK) _ ++ have h_prod_le_B : ++ ∏ ρ ∈ K, (R / R1: ℝ) ^ (analyticOrderAt f ρ).toNat ≤ B := by ++ have h_right : ∏ ρ ∈ K, (R / ‖ρ‖) ^ (analyticOrderAt f ρ).toNat = ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ 0‖ := by ++ simp [h_eval_prod] ++ exact le_trans h_prod_le (by simpa [h_right] using hBf0) ++ ++ have h_prod_pow_sum : ++ (∏ ρ ∈ K, (R/R1 : ℝ) ^ (analyticOrderAt f ρ).toNat) ++ = (R/R1 : ℝ) ^ (∑ ρ ∈ K, (analyticOrderAt f ρ).toNat) := by ++ simpa using ++ (Finset.prod_pow_eq_pow_sum K (fun ρ => (analyticOrderAt f ρ).toNat) (R/R1 : ℝ)) ++ ++ have h_natPow : (R / R1 : ℝ) ^ (∑ ρ ∈ K, (analyticOrderAt f ρ).toNat) ≤ B := by ++ simpa [h_prod_pow_sum] using h_prod_le_B ++ ++ set S : ℕ := ∑ ρ ∈ K, (analyticOrderAt f ρ).toNat ++ have h_natPowS : (R / R1 : ℝ) ^ S ≤ B := by simpa [S] using h_natPow ++ ++ have h_rpowS : (R / R1 : ℝ) ^ (S : ℝ) ≤ B := by ++ ++ simpa [(Real.rpow_natCast (R / R1 : ℝ) S)] using h_natPowS ++ ++ have h_cast_sum : (S : ℝ) ++ = (∑ ρ ∈ K, ((analyticOrderAt f ρ).toNat : ℝ)) := by ++ simp [S] ++ ++ have : (R / R1 : ℝ) ^ (∑ ρ ∈ K, ((analyticOrderAt f ρ).toNat : ℝ)) ≤ B := by ++ simpa [h_cast_sum] using h_rpowS ++ simpa [K] using this ++ ++lemma lem_jensen_inequality_form (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) : ++ (R / R1 : ℝ) ^ (∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat : ℝ) ≤ B := by ++ ++ have hf0_ne0 : f 0 ≠ 0 := by ++ rw [hf0_eq_one]; norm_num ++ ++ have hBf0 := ++ lem_Bf_at_0_le_M B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic hf0_ne0 h_finite_zeros h_σ h_σ_spec hf_le_B ++ ++ let K := h_finite_zeros.toFinset ++ have hres := lem_combine_bounds_on_Bf0 B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero hf0_eq_one h_finite_zeros h_σ h_σ_spec hBf0 ++ ++ simpa using hres ++ ++lemma lem_log_mono_inc {x y : ℝ} (hx : 0 < x) (hxy : x ≤ y) : Real.log x ≤ Real.log y := by ++ exact Real.log_le_log hx hxy ++ ++lemma lem_three_gt_e : (3 : ℝ) > Real.exp 1 := by ++ have h1 : Real.exp 1 < 2.7182818286 := Real.exp_one_lt_d9 ++ have h2 : (2.7182818286 : ℝ) < 3 := by norm_num ++ exact lt_trans h1 h2 ++ ++lemma lem_jensen_log_form (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) : ++ (∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) * Real.log (R / R1) ≤ Real.log B := by ++ ++ set S : ℝ := ∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ) ++ ++ have hpow_le : (R / R1 : ℝ) ^ S ≤ B := by ++ simpa [S] using ++ (lem_jensen_inequality_form B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero hf0_eq_one h_finite_zeros h_σ h_σ_spec hf_le_B) ++ ++ have hbase_pos : 1 < (R / R1 : ℝ) := by exact (one_lt_div hR1_pos).mpr hR1_lt_R ++ have hbase_pos' : 0 < (R / R1 : ℝ) := by ++ have : 0 < R := by linarith ++ linarith ++ ++ have hxpos : 0 < (R / R1 : ℝ) ^ S := by ++ simpa [S] using Real.rpow_pos_of_pos hbase_pos' S ++ ++ have hlog_le : Real.log ((R / R1 : ℝ) ^ S) ≤ Real.log B := ++ lem_log_mono_inc hxpos hpow_le ++ ++ have hlog_rpow : Real.log ((R / R1 : ℝ) ^ S) = S * Real.log (R / R1) := by ++ simpa using (Real.log_rpow hbase_pos' S) ++ ++ simpa [S, hlog_rpow] using hlog_le ++ ++lemma lem_sum_ineq {ι : Type*} (K : Finset ι) (a b : ι → ℝ) ++ (h_le : ∀ i ∈ K, a i ≤ b i) : ++ Finset.sum K a ≤ Finset.sum K b := by ++ classical ++ exact Finset.sum_le_sum (by intro i hi; exact h_le i hi) ++ ++lemma ENat_coe_ge_one_iff_nat_ge_one (n : ℕ) : (n : ENat) ≥ 1 ↔ 1 ≤ n := by ++ ++ rw [ge_iff_le] ++ ++ exact ENat.natCast_le_natCast ++ ++lemma nat_one_le_cast_real (n : ℕ) : 1 ≤ n → (1 : ℝ) ≤ (n : ℝ) := by ++ intro h ++ rw [← Nat.cast_one] ++ exact Nat.cast_le.mpr h ++ ++lemma zerosetKfR_eq_zeros_in_ball (R : ℝ) (hR_pos : 0 < R) (f : ℂ → ℂ) : ++ zerosetKfR R hR_pos f = {z | z ∈ Metric.closedBall (0 : ℂ) R ∧ f z = 0} := by ++ rfl ++ ++lemma lem_frho_zero' (R R1 : ℝ) ++ (hR_pos : 0 < R1) ++ (_hR1 : R1 < R) ++ (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (ρ : ℂ) (h_rho_in_KfR1 : ρ ∈ zerosetKfR R1 (by linarith) f) : ++ f ρ = 0 := h_rho_in_KfR1.2 ++ ++lemma lem_sum_m_rho_1 (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (hR_lt_1 : R < 1) : ++ (h_finite_zeros.toFinset.card : ℝ) ≤ ∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ) := by ++ ++ have h_card_as_sum : (h_finite_zeros.toFinset.card : ℝ) = ∑ ρ ∈ h_finite_zeros.toFinset, (1 : ℝ) := by ++ simp [Finset.sum_const] ++ rw [h_card_as_sum] ++ ++ apply lem_sum_ineq h_finite_zeros.toFinset (fun _ => (1 : ℝ)) (fun ρ => ((analyticOrderAt f ρ).toNat : ℝ)) ++ ++ intro ρ hρ ++ ++ have hρ_in_zeros : ρ ∈ zerosetKfR R1 (by linarith) f := ++ (Set.Finite.mem_toFinset h_finite_zeros).mp hρ ++ have h_f_rho_zero : f ρ = 0 := ++ lem_frho_zero' R R1 (by linarith) hR1_lt_R f h_f_analytic ρ hρ_in_zeros ++ ++ have h_f_analytic_at_rho : AnalyticAt ℂ f ρ := by ++ apply h_f_analytic ++ have h_R1_lt_1 : R1 < 1 := by linarith [hR_lt_1] ++ exact Metric.closedBall_subset_closedBall (le_of_lt h_R1_lt_1) hρ_in_zeros.1 ++ ++ have h_order_finite : analyticOrderAt f ρ ≠ ⊤ := by ++ have h_R1_pos : 0 < R1 := by linarith [hR1_pos] ++ apply analyticOrderAt_ne_top_of_finite_zeros_in_ball f R1 h_R1_pos ++ · intro z hz ++ apply h_f_analytic ++ have h_R1_lt_1 : R1 < 1 := by linarith [hR_lt_1] ++ exact Metric.closedBall_subset_closedBall (le_of_lt h_R1_lt_1) hz ++ · exact h_f_rho_zero ++ · exact hρ_in_zeros.1 ++ · exact h_finite_zeros ++ ++ have h_order_ge_one : analyticOrderAt f ρ ≥ 1 := ++ analyticOrderAt_ge_one_of_zero f ρ h_f_analytic_at_rho h_f_rho_zero h_order_finite ++ ++ have h_toNat_ge_one : 1 ≤ (analyticOrderAt f ρ).toNat := by ++ cases' h_cases : analyticOrderAt f ρ with n ++ · rw [h_cases] at h_order_finite; contradiction ++ · rw [h_cases] at h_order_ge_one ++ rw [ENat.toNat_natCast] ++ exact (ENat_coe_ge_one_iff_nat_ge_one n).mp h_order_ge_one ++ ++ exact nat_one_le_cast_real _ h_toNat_ge_one ++ ++lemma lem_sum_1_is_card {ι : Type*} (K : Finset ι) : Finset.sum K (fun _ => (1 : ℝ)) = (K.card : ℝ) := by ++ ++ rw [Finset.sum_const, nsmul_eq_mul] ++ simp only [mul_one] ++ ++lemma lem_sum_m_rho_bound (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ (∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) ≤ (1/Real.log (R/R1)) * Real.log B := by ++ have h_div_log : (∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) * Real.log (R/R1) ≤ Real.log B := by ++ apply lem_jensen_log_form B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero hf0_eq_one h_finite_zeros h_σ h_σ_spec hf_le_B ++ have log_pos' : R/R1 > 1 := by exact (one_lt_div hR1_pos).mpr hR1_lt_R ++ have log_pos : Real.log (R/R1) > 0 := by exact Real.log_pos log_pos' ++ calc ++ ∑ ρ ∈ h_finite_zeros.toFinset, ↑(analyticOrderAt f ρ).toNat ++ _ = 1 / Real.log (R / R1) * (Real.log (R / R1) * (∑ ρ ∈ h_finite_zeros.toFinset, ↑(analyticOrderAt f ρ).toNat)) := by ++ field_simp [ne_of_gt log_pos] ++ _ ≤ 1 / Real.log (R / R1) * Real.log B := by ++ gcongr ++ rw [mul_comm] ++ exact h_div_log ++ ++lemma lem_sum_1_bound (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ (h_finite_zeros.toFinset.card : ℝ) ≤ (1/Real.log (R/R1)) * Real.log B := by ++ have h1 := ++ lem_sum_m_rho_1 R R1 hR1_pos hR1_lt_R f h_f_analytic h_finite_zeros hR_lt_1 ++ have h2 := ++ lem_sum_m_rho_bound B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero hf0_eq_one h_finite_zeros h_σ hf_le_B h_σ_spec ++ exact le_trans h1 h2 ++ ++lemma lem_num_zeros_bound (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (hf0_eq_one : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (hf_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ let S_zeros := zerosetKfR R1 (by linarith) f ++ have inst_fintype_S_zeros : Fintype ↑S_zeros := h_finite_zeros.fintype ++ (S_zeros.toFinset.card : ℝ) ≤ (1 / Real.log (R / R1)) * Real.log B := by ++ intro S_zeros _inst ++ dsimp [S_zeros] ++ simpa using ++ (lem_sum_1_bound B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero hf0_eq_one h_finite_zeros h_σ hf_le_B h_σ_spec) ++ ++variable {R R1 r B : ℝ} {f : ℂ → ℂ} {h_σ : ℂ → (ℂ → ℂ)} ++variable (hr_pos : 0 < r) (hr_lt_R1 : r < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++variable (hR1_pos : 0 < R1) ++variable (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++variable (h_f_zero : f 0 = 1) ++variable (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++variable (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ ++lemma f_zero_ne_zero (h_f_zero : f 0 = 1) : f 0 ≠ 0 := by ++ rw [h_f_zero]; simp ++ ++lemma Bf_is_analytic_on_disk ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ AnalyticOnNhd ℂ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ) (Metric.closedBall (0 : ℂ) R) := ++ let hspec := h_σ_spec ++ lem_Bf_is_analytic R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) ++ h_finite_zeros h_σ hspec ++ ++lemma lem_Bf_eq_prod_Cf ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ∀ z, Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z = ++ (∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) * ++ (Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero_at_zero h_finite_zeros h_σ z) := by ++ intro z ++ rw [Bf] ++ ring ++ ++lemma lem_num_prod_never_zero_all ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (_hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (_h_f_nonzero_at_zero : f 0 ≠ 0) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1, ++ (∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R : ℂ) - star ρ * z / (R : ℂ)) ^ (analyticOrderAt f ρ).toNat) ≠ 0 := by ++ intro z hz ++ apply Finset.prod_ne_zero_iff.mpr ++ intro ρ hρ ++ apply pow_ne_zero ++ ++ have hρ_mem : ρ ∈ zerosetKfR R1 (by linarith) f := by ++ rwa [Set.Finite.mem_toFinset h_finite_zeros] at hρ ++ have hρ_bound : ‖ρ‖ ≤ R1 := by ++ rw [zerosetKfR] at hρ_mem; simp at hρ_mem; exact hρ_mem.1 ++ have hz_bound : ‖z‖ ≤ R1 := by ++ rw [Metric.mem_closedBall, dist_zero_right] at hz; exact hz ++ ++ have hR_pos : (0 : ℝ) < R := lt_trans hR1_pos hR1_lt_R ++ ++ have key_positive : (0 : ℝ) < R - R1 * R1 / R := by ++ ++ have h1 : R1 * R1 < R * R := by ++ apply mul_self_lt_mul_self (le_of_lt hR1_pos) hR1_lt_R ++ have h2 : R1 * R1 / R < R := by ++ rw [div_lt_iff₀ hR_pos] ++ exact h1 ++ linarith [h2] ++ ++ suffices h : (0 : ℝ) < ‖(R : ℂ) - star ρ * z / (R : ℂ)‖ by ++ exact norm_pos_iff.mp h ++ ++ have triangle_ineq : ‖(R : ℂ) - star ρ * z / (R : ℂ)‖ ≥ ‖(R : ℂ)‖ - ‖star ρ * z / (R : ℂ)‖ := ++ norm_sub_norm_le _ _ ++ ++ have R_norm_eq : ‖(R : ℂ)‖ = R := by ++ rw [Complex.norm_of_nonneg (le_of_lt hR_pos)] ++ ++ have product_bound : ‖star ρ * z / (R : ℂ)‖ ≤ R1 * R1 / R := by ++ rw [norm_div, norm_mul, norm_star, R_norm_eq] ++ ++ have mult_bound : ‖ρ‖ * ‖z‖ ≤ R1 * R1 := by ++ exact mul_le_mul hρ_bound hz_bound (norm_nonneg _) (le_of_lt hR1_pos) ++ ++ have : ‖ρ‖ * ‖z‖ / R ≤ R1 * R1 / R := by ++ exact div_le_div_of_nonneg_right mult_bound (le_of_lt hR_pos) ++ exact this ++ ++ rw [R_norm_eq] at triangle_ineq ++ linarith [triangle_ineq, product_bound, key_positive] ++ ++lemma Bf_never_zero ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1, Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z ≠ 0 := by ++ intro z hz ++ ++ rw [lem_Bf_eq_prod_Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ h_σ_spec] ++ ++ apply mul_ne_zero ++ · ++ exact lem_num_prod_never_zero_all R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ h_σ_spec z hz ++ · ++ exact lem_Cf_never_zero h_finite_zeros h_σ h_σ_spec z hz ++ ++lemma Bf0_not_zero ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0 ≠ 0 := by ++ apply Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ simp [Metric.mem_closedBall, le_of_lt hR1_pos] ++ ++noncomputable def Lf : ℂ → ℂ := ++ let B_f := Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ ++ Classical.choose (log_of_analytic ++ (r1 := r) (R' := R1) (R := R) ++ hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 ++ (B := B_f) ++ (hB := Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec) ++ (hB_ne_zero := by ++ intro z hz ++ have h_num_ne_zero : B_f z ≠ 0 := ++ Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec z hz ++ assumption ++ ) ++) ++ ++lemma Lf_is_analytic ++ (r R R1 : ℝ) ++ (hr_pos : 0 < r) ++ (hr_lt_R1 : r < R1) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ AnalyticOnNhd ℂ (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) ++ (Metric.closedBall (0 : ℂ) r) := by ++ unfold Lf ++ exact (Classical.choose_spec (log_of_analytic ++ (r1 := r) (R' := R1) (R := R) ++ hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 ++ (B := Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ) ++ (hB := Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec) ++ (hB_ne_zero := by ++ intro z hz ++ exact Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec z hz ++ ) ++ )).1 ++ ++lemma Lf_at_0_is_0 ++ (r R R1 : ℝ) ++ (hr_pos : 0 < r) ++ (hr_lt_R1 : r < R1) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec 0 = 0 := by ++ unfold Lf ++ let B_f := Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ ++ let log_exists := log_of_analytic ++ (r1 := r) (R' := R1) (R := R) ++ hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 ++ (B := B_f) ++ (hB := Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec) ++ (hB_ne_zero := by ++ intro z hz ++ have h_num_ne_zero : B_f z ≠ 0 := ++ Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec z hz ++ assumption ++ ) ++ exact (Classical.choose_spec log_exists).2.1 ++ ++lemma lem_BCII {L : ℂ → ℂ} {r M r₁ : ℝ} ++ (hr_pos : 0 < r) ++ (hM_pos : 0 < M) ++ (hr₁_pos : 0 < r₁) ++ (hr₁_lt_r : r₁ < r) ++ (hL_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 r ⊆ U ∧ DifferentiableOn ℂ L U) ++ (hL0 : L 0 = 0) ++ (hre_L_le_M : ∀ w ∈ Metric.closedBall 0 r, (L w).re ≤ M) ++ {z : ℂ} (hz : z ∈ Metric.closedBall 0 r₁) : ++norm (deriv L z) ≤ (16 * M * r ^ 2) / ((r - r₁) ^ 3) := by ++ apply borel_caratheodory_II hr_pos hM_pos hr₁_pos hr₁_lt_r hL_domain hL0 hre_L_le_M hz ++ ++lemma re_Lf_as_diff_of_log_mods ++ (r R R1 : ℝ) ++ (hr_pos : 0 < r) ++ (hr_lt_R1 : r < R1) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r, ++ Complex.re (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z) = ++ Real.log (norm (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z)) - ++ Real.log (norm (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0)) := by ++ intro z hz ++ ++ let B_f := Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ ++ have h_Bf_analytic : AnalyticOnNhd ℂ B_f (Metric.closedBall (0 : ℂ) R) := ++ Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ have h_Bf_ne_zero : ∀ w ∈ Metric.closedBall (0 : ℂ) R1, B_f w ≠ 0 := by ++ intro w hw ++ exact Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec w hw ++ ++ have h_log_exists := log_of_analytic hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 h_Bf_analytic h_Bf_ne_zero ++ have h_choose_spec := Classical.choose_spec h_log_exists ++ ++ have h_Lf_def : Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec = Classical.choose h_log_exists := by ++ unfold Lf ++ simp only [B_f] ++ ++ rw [h_Lf_def] ++ exact (h_choose_spec.2.2.2 z hz).symm ++ ++lemma log_Bf_le_log_B ++ (B R R1 : ℝ) ++ (_hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_Bf_pos : ∀ z, norm z ≤ R1 → ++ 0 < norm (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z)) ++ (h_Bf_bound : ∀ z, norm z ≤ R1 → ++ norm (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z) ≤ B) : ++ ∀ z, norm z ≤ R1 → ++ Real.log (norm (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z)) ≤ Real.log B := by ++ intro z hz ++ apply Real.log_le_log ++ · exact h_Bf_pos z hz ++ · exact h_Bf_bound z hz ++ ++lemma log_Bf_le_log_B2 ++ (B R R1 : ℝ) ++ (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_Bf_bound : ∀ z, ‖z‖ ≤ R → ++ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z‖ ≤ B) : ++ ∀ z, ‖z‖ ≤ R1 → ++ Real.log (‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z‖) ≤ Real.log B := by ++ ++ apply log_Bf_le_log_B B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ · ++ intro z hz ++ have hz_mem : z ∈ Metric.closedBall (0 : ℂ) R1 := by ++ rw [Metric.mem_closedBall, dist_zero_right] ++ exact hz ++ have hBf_ne_zero := Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec z hz_mem ++ exact norm_pos_iff.mpr hBf_ne_zero ++ · ++ intro z hz ++ have hz_le_R : ‖z‖ ≤ R := by linarith [hz, hR1_lt_R] ++ exact h_Bf_bound z hz_le_R ++ ++lemma log_Bf_le_log_B3 ++ (B R R1 : ℝ) ++ (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_f_bound : ∀ z, norm z ≤ R → norm (f z) ≤ B) : ++ ∀ z, norm z ≤ R1 → ++ Real.log (norm (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z)) ≤ Real.log B := by ++ ++ apply log_Bf_le_log_B2 B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ ++ apply lem_Bf_bounded_in_disk_from_f B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ h_σ_spec ++ ++ exact h_f_bound ++ ++lemma log_Bf0_ge_0 ++ (R R1 : ℝ) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ 0 ≤ Real.log (‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0‖) := by ++ ++ have h_pos : 0 < (1 : ℝ) := by norm_num ++ have h_Bf_ge_1 : 1 ≤ ‖Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0‖ := ++ lem_mod_Bf_at_0_ge_1 R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_f_zero h_finite_zeros h_σ h_σ_spec ++ have h_log_mono := lem_log_mono_inc h_pos h_Bf_ge_1 ++ rw [Real.log_one] at h_log_mono ++ exact h_log_mono ++ ++lemma re_Lf_le_log_B ++ (B r R R1 : ℝ) ++ (hB : 1 < B) ++ (hr_pos : 0 < r) ++ (hr_lt_R1 : r < R1) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_f_bound : ∀ z, norm z ≤ R → norm (f z) ≤ B) : ++ ∀ z, norm z ≤ r → ++ Complex.re (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z) ≤ Real.log B := by ++ intro z hz ++ ++ rw [re_Lf_as_diff_of_log_mods r R R1 hr_pos hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec z] ++ · ++ ++ have hz_apply_BC_to_Lfle_R1 : ‖z‖ ≤ R1 := by linarith [hz, hr_lt_R1] ++ have h1 := log_Bf_le_log_B3 B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec h_f_bound z hz_apply_BC_to_Lfle_R1 ++ have h2 := log_Bf0_ge_0 R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ linarith ++ · ++ exact Metric.mem_closedBall.mpr (by simpa [dist_zero_right] using hz) ++ ++lemma analyticOnNhd_closedBall_exists_open_differentiableOn {L : ℂ → ℂ} {r : ℝ} ++ (h : AnalyticOnNhd ℂ L (Metric.closedBall (0 : ℂ) r)) : ++ ∃ U, IsOpen U ∧ Metric.closedBall (0 : ℂ) r ⊆ U ∧ DifferentiableOn ℂ L U := by ++ classical ++ ++ let I := {x : ℂ // x ∈ Metric.closedBall (0 : ℂ) r} ++ ++ have hI : ∀ i : I, ∃ (W : Set ℂ), IsOpen W ∧ (i : ℂ) ∈ W ∧ AnalyticOn ℂ L W := by ++ intro i ++ have hAt : AnalyticAt ℂ L (i : ℂ) := h i i.property ++ ++ have hWithin : AnalyticWithinAt ℂ L (Set.univ) (i : ℂ) := by ++ simpa using (hAt.analyticWithinAt : AnalyticWithinAt ℂ L Set.univ (i : ℂ)) ++ rcases (AnalyticWithinAt.exists_mem_nhdsWithin_analyticOn hWithin) with ⟨U₀, hU₀nhds, hU₀analytic⟩ ++ have hU₀nhds' : U₀ ∈ nhds (i : ℂ) := by simpa [nhdsWithin_univ] using hU₀nhds ++ rcases _root_.mem_nhds_iff.mp hU₀nhds' with ⟨W, hWsub, hWopen, hiW⟩ ++ refine ⟨W, hWopen, hiW, hU₀analytic.mono ?_⟩ ++ exact hWsub ++ choose V hVopen hiV hVanalytic using hI ++ ++ let U : Set ℂ := ⋃ i : I, V i ++ have hUopen : IsOpen U := by ++ simpa [U] using isOpen_iUnion (fun i => hVopen i) ++ ++ have hsub : Metric.closedBall (0 : ℂ) r ⊆ U := by ++ intro x hx ++ refine Set.mem_iUnion.mpr ?_ ++ refine ⟨⟨x, hx⟩, ?_⟩ ++ simpa using hiV ⟨x, hx⟩ ++ ++ have hdiffOn : DifferentiableOn ℂ L U := by ++ intro y hy ++ rcases Set.mem_iUnion.mp hy with ⟨i, hyi⟩ ++ have hdi : DifferentiableOn ℂ L (V i) := (hVanalytic i).differentiableOn ++ have hdiAt : DifferentiableAt ℂ L y := hdi.differentiableAt ((hVopen i).mem_nhds hyi) ++ exact hdiAt.differentiableWithinAt ++ exact ⟨U, hUopen, hsub, hdiffOn⟩ ++ ++lemma log_pos_of_one_lt {B : ℝ} (hB : 1 < B) : 0 < Real.log B := by ++ simpa using Real.log_pos hB ++ ++lemma apply_BC_to_Lf ++ (B r1 r R R1 : ℝ) ++ (hB : 1 < B) ++ (hr1_pos : 0 < r1) ++ (hr1_lt_r : r1 < r) ++ (hr_lt_R1 : r < R1) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_f_bound : ∀ z, norm z ≤ R → norm (f z) ≤ B) : ++ ∀ z, norm z ≤ r1 → ++ norm (deriv (Lf (lt_trans hr1_pos hr1_lt_r : 0 < r) hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z) ≤ ++ (16 * Real.log B * r^2) / (r - r1)^3 := by ++ classical ++ intro z hz ++ ++ have hr_pos : 0 < r := lt_trans hr1_pos hr1_lt_r ++ ++ let L := Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec ++ ++ have h_analytic_nhd := ++ Lf_is_analytic r R R1 hr_pos hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ ++ let U : Set ℂ := ++ { y | ∃ x ∈ Metric.closedBall (0 : ℂ) r, ∃ s : ℝ, 0 < s ∧ y ∈ Metric.ball x s ∧ ++ AnalyticOnNhd ℂ L (Metric.ball x s) } ++ have hU_open : IsOpen U := by ++ refine isOpen_iff_mem_nhds.mpr ?_ ++ intro y hy ++ rcases hy with ⟨x, hxCB, s, hs_pos, hyin, hAnaBall⟩ ++ have hnhds : Metric.ball x s ∈ nhds y := (Metric.isOpen_ball.mem_nhds hyin) ++ exact Filter.mem_of_superset hnhds (by intro z hz; exact ⟨x, hxCB, s, hs_pos, hz, hAnaBall⟩) ++ have hCB_subset : Metric.closedBall (0 : ℂ) r ⊆ U := by ++ intro x hx ++ have hAt : AnalyticAt ℂ L x := h_analytic_nhd x hx ++ rcases AnalyticAt.exists_ball_analyticOnNhd hAt with ⟨s, hs_pos, hAnaBall⟩ ++ have hx_in_ball : x ∈ Metric.ball x s := by ++ simpa [Metric.mem_ball, dist_self] using hs_pos ++ exact ⟨x, hx, s, hs_pos, hx_in_ball, hAnaBall⟩ ++ have hDiffU : DifferentiableOn ℂ L U := by ++ intro y hy ++ rcases hy with ⟨x, hxCB, s, hs_pos, hy_in, hAnaBall⟩ ++ ++ have hAt : AnalyticAt ℂ L y := hAnaBall y hy_in ++ exact (AnalyticAt.differentiableAt hAt).differentiableWithinAt ++ ++ have hL_domain : ∃ U, IsOpen U ∧ Metric.closedBall 0 r ⊆ U ∧ DifferentiableOn ℂ L U := ++ ⟨U, hU_open, hCB_subset, hDiffU⟩ ++ ++ have hL0 : L 0 = 0 := by ++ simpa [L] using (Lf_at_0_is_0 r R R1 hr_pos hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec) ++ ++ have hre_L_le_M : ∀ w ∈ Metric.closedBall 0 r, (L w).re ≤ Real.log B := by ++ intro w hw ++ have hw' : norm w ≤ r := by ++ simpa [Metric.mem_closedBall, dist_zero_right] using hw ++ exact re_Lf_le_log_B B r R R1 hB hr_pos hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec h_f_bound w hw' ++ ++ have hz' : z ∈ Metric.closedBall 0 r1 := by ++ simpa [Metric.mem_closedBall, dist_zero_right] using hz ++ ++ have hBC := ++ lem_BCII hr_pos (Real.log_pos hB) hr1_pos hr1_lt_r hL_domain hL0 hre_L_le_M hz' ++ ++ simpa [L] using hBC ++ ++lemma analyticOnNhd_Bf_closedBall (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z): ++ AnalyticOnNhd ℂ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ) (Metric.closedBall (0 : ℂ) R) := ++ Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ ++lemma helper_Bf_analytic_on_disk (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z): ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R, AnalyticAt ℂ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ) z := by ++ intro z hz ++ have h_analytic_on := Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ exact h_analytic_on z hz ++ ++lemma closedBall_R1_subset_R (_hR1_nonneg : 0 ≤ R1) (hR1_lt_R : R1 < R) : Metric.closedBall (0 : ℂ) R1 ⊆ Metric.closedBall (0 : ℂ) R := by ++ exact (Metric.closedBall_subset_closedBall (le_of_lt hR1_lt_R)) ++ ++lemma logDerivconst {a : ℂ} {g : ℂ → ℂ} (ha : a ≠ 0) : ++ ∀ z, logDeriv (fun w ↦ a * g w) z = logDeriv g z := by ++ intro z ++ exact logDeriv_const_mul z a ha ++ ++lemma oneBneq0 (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z): ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0 ≠ 0 ∧ ++ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0)⁻¹ ≠ 0 := by ++ have h0mem : (0 : ℂ) ∈ Metric.closedBall (0 : ℂ) R1 := by ++ simpa [Metric.mem_closedBall, dist_zero_right] using le_of_lt hR1_pos ++ have hB0ne : ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0 ≠ 0 := by ++ have h := Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ ++ exact h 0 h0mem ++ refine And.intro hB0ne ?_ ++ exact inv_ne_zero hB0ne ++ ++lemma Lf_deriv_is_logBf_deriv (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ logDeriv (fun w ↦ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w / ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0) z = ++ logDeriv (fun w ↦ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w) z := by ++ intro z _ ++ ++ have h_eq : (fun w ↦ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w / ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0) = ++ (fun w ↦ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0)⁻¹ * ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w) := by ++ ext w ++ rw [div_eq_mul_inv] ++ ring ++ rw [h_eq] ++ ++ have h0_in_ball : (0 : ℂ) ∈ Metric.closedBall (0 : ℂ) R1 := by ++ simp [Metric.mem_closedBall] ++ exact le_of_lt hR1_pos ++ have h_Bf0_ne_zero := Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec 0 h0_in_ball ++ ++ have h_inv_ne_zero : (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ 0)⁻¹ ≠ 0 := ++ inv_ne_zero h_Bf0_ne_zero ++ ++ exact logDerivconst h_inv_ne_zero z ++ ++lemma logDeriv_div_const {a : ℂ} {g : ℂ → ℂ} (ha : a ≠ 0) : ∀ z, logDeriv (fun w ↦ g w / a) z = logDeriv g z := by ++ intro z ++ have hfun : (fun w ↦ g w / a) = (fun w ↦ a⁻¹ * g w) := by ++ funext w ++ simp [div_eq_mul_inv, mul_comm] ++ simpa [hfun] using (logDerivconst (a := a⁻¹) (g := g) (inv_ne_zero ha) z) ++ ++lemma deriv_over_fun_is_logDeriv {g : ℂ → ℂ} : ∀ z, deriv g z / g z = logDeriv g z := by ++ intro z ++ rfl ++ ++lemma logDerivmul {f g : ℂ → ℂ} {z : ℂ} ++ (hf : DifferentiableAt ℂ f z) (hg : DifferentiableAt ℂ g z) ++ (hf_ne : f z ≠ 0) (hg_ne : g z ≠ 0) : ++ logDeriv (fun w ↦ f w * g w) z = logDeriv f z + logDeriv g z := by ++ exact logDeriv_mul z hf_ne hg_ne hf hg ++ ++lemma logDerivprod {K : Finset ℂ} {g : ℂ → ℂ → ℂ} {z : ℂ} ++ (hg_diff : ∀ ρ ∈ K, DifferentiableAt ℂ (g ρ) z) ++ (hg_ne : ∀ ρ ∈ K, g ρ z ≠ 0) : ++ logDeriv (fun w ↦ ∏ ρ ∈ K, g ρ w) z = ∑ ρ ∈ K, logDeriv (g ρ) z := by ++ simpa only [Finset.prod_fn] using logDeriv_prod hg_ne hg_diff ++ ++lemma logDerivdiv {h g : ℂ → ℂ} {z : ℂ} ++ (hh : DifferentiableAt ℂ h z) (hg : DifferentiableAt ℂ g z) ++ (hh_ne : h z ≠ 0) (hg_ne : g z ≠ 0) : ++ logDeriv (fun w ↦ h w / g w) z = logDeriv h z - logDeriv g z := by ++ exact logDeriv_div z hh_ne hg_ne hh hg ++ ++lemma logDerivfunpow {g : ℂ → ℂ} {z : ℂ} {m : ℕ} ++ (hg : DifferentiableAt ℂ g z) : ++ logDeriv (fun w ↦ (g w) ^ m) z = m * logDeriv g z := by ++ exact logDeriv_fun_pow hg m ++ ++lemma z_minus_rho_diff_nonzero {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (_hR1_lt_R : R1 < R) (_hR_lt_1 : R < 1) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (_h_f_zero : f 0 = 1) ++ (_h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ ρ ∈ zerosetKfR R1 (by linarith) f, ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ z - ρ ≠ 0 ∧ DifferentiableAt ℂ (fun w ↦ w - ρ) z := by ++ intro ρ hρ z hz ++ have hz_pair := (Set.mem_sdiff z).1 hz ++ have hz_ball : z ∈ Metric.closedBall (0 : ℂ) R1 := hz_pair.1 ++ have hz_notK : z ∉ zerosetKfR R1 (by linarith) f := hz_pair.2 ++ ++ have hz_ne_rho : z ≠ ρ := by ++ intro h_eq ++ exact hz_notK (by simpa [h_eq] using hρ) ++ have h_nonzero : z - ρ ≠ 0 := sub_ne_zero.mpr hz_ne_rho ++ ++ have hdiff : DifferentiableAt ℂ (fun w => w) z := differentiableAt_fun_id ++ have hdiff_sub : DifferentiableAt ℂ (fun w => w - ρ) z := hdiff.sub_const ρ ++ exact ⟨h_nonzero, hdiff_sub⟩ ++ ++lemma blaschke_num_diff_nonzero {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (_hR_lt_1 : R < 1) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (_h_f_zero : f 0 = 1) ++ (_h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ ρ ∈ zerosetKfR R1 (by linarith) f, ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R, ++ R - (star ρ) * z / R ≠ 0 ∧ DifferentiableAt ℂ (fun w ↦ R - (star ρ) * w / R) z := by ++ intro ρ hρ z hz ++ constructor ++ · intro hzero ++ have hRne : (R : ℂ) ≠ 0 := by ++ simpa using (Complex.ofReal_ne_zero.mpr (ne_of_gt (hR1_pos.trans hR1_lt_R))) ++ ++ have heq : (R : ℂ) = (star ρ) * z / (R : ℂ) := sub_eq_zero.mp hzero ++ have hmul := congrArg (fun t : ℂ => t * (R : ℂ)) heq ++ have heq_mul : (R : ℂ) * (R : ℂ) = (star ρ) * z := by ++ ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc, hRne] using hmul ++ ++ have hnorm_eq : ‖(R : ℂ)‖ * ‖(R : ℂ)‖ = ‖ρ‖ * ‖z‖ := by ++ simpa [Complex.norm_mul, Complex.norm_conj] using congrArg (fun t : ℂ => ‖t‖) heq_mul ++ ++ have hz_norm_le : ‖z‖ ≤ R := by ++ have hz' : dist z (0 : ℂ) ≤ R := (Metric.mem_closedBall.mp hz) ++ simpa [dist_eq_norm] using hz' ++ have hrho_norm_le : ‖ρ‖ ≤ R1 := by ++ rcases hρ with ⟨hρ_ball, _hρ_zero⟩ ++ have : dist ρ (0 : ℂ) ≤ R1 := (Metric.mem_closedBall.mp hρ_ball) ++ simpa [dist_eq_norm] using this ++ have hz_nonneg : 0 ≤ ‖z‖ := by simp ++ have hR1_nonneg : 0 ≤ R1 := le_of_lt hR1_pos ++ have hle : ‖ρ‖ * ‖z‖ ≤ R1 * R := by ++ have h1 : ‖ρ‖ * ‖z‖ ≤ R1 * ‖z‖ := mul_le_mul_of_nonneg_right hrho_norm_le hz_nonneg ++ have h2 : R1 * ‖z‖ ≤ R1 * R := mul_le_mul_of_nonneg_left hz_norm_le hR1_nonneg ++ exact le_trans h1 h2 ++ ++ have hnorm_R : ‖(R : ℂ)‖ = R := by ++ have h1 : ‖(R : ℂ)‖ = |R| := by simp ++ simp [abs_of_pos (hR1_pos.trans hR1_lt_R)] ++ ++ have : R * R = ‖ρ‖ * ‖z‖ := by simpa [hnorm_R] using hnorm_eq ++ have hle' : R * R ≤ R1 * R := by simpa [this] using hle ++ ++ have hposR : 0 < R := hR1_pos.trans hR1_lt_R ++ have hposRR : 0 < R * R := by nlinarith [hposR] ++ have hlt : R1 * R < R * R := by ++ exact mul_lt_mul_of_pos_right hR1_lt_R hposR ++ exact (lt_irrefl _ (lt_of_le_of_lt hle' hlt)) ++ · ++ have h_const : DifferentiableAt ℂ (fun _ : ℂ => (R : ℂ)) z := by ++ simp ++ have h_id : DifferentiableAt ℂ (fun w : ℂ => w) z := by ++ simp ++ have h_mul : DifferentiableAt ℂ (fun w : ℂ => (star ρ) * w) z := by ++ simpa using h_id.const_mul (star ρ) ++ have h_div : DifferentiableAt ℂ (fun w : ℂ => (star ρ) * w / (R : ℂ)) z := by ++ simpa [div_eq_mul_inv] using h_mul.mul_const ((R : ℂ)⁻¹) ++ simpa using h_const.sub h_div ++ ++lemma blaschke_frac_diff_nonzero {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ ρ ∈ zerosetKfR R1 (by linarith) f, ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ (R - (star ρ) * z / R) / (z - ρ) ≠ 0 ∧ ++ DifferentiableAt ℂ (fun w ↦ (R - (star ρ) * w / R) / (w - ρ)) z := by ++ intro ρ hρ z hz ++ ++ have hden := z_minus_rho_diff_nonzero (R:=R) (R1:=R1) (f:=f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ρ hρ z hz ++ have hden_ne : z - ρ ≠ 0 := hden.1 ++ have hden_diff : DifferentiableAt ℂ (fun w ↦ w - ρ) z := hden.2 ++ ++ have hz_in_small : z ∈ Metric.closedBall (0 : ℂ) R1 ∧ ++ z ∉ zerosetKfR R1 (by linarith) f := by ++ simpa [Set.mem_sdiff] using hz ++ have hz_small : z ∈ Metric.closedBall (0 : ℂ) R1 := hz_in_small.1 ++ ++ have hz_dist_le_small : dist z (0 : ℂ) ≤ R1 := by ++ simpa [Metric.mem_closedBall] using hz_small ++ have hRle : R ≤ 1 := le_of_lt hR_lt_1 ++ have hR1_le_R : R1 ≤ R := le_of_lt hR1_lt_R ++ have hR1_le_1 : R1 ≤ 1 := le_trans hR1_le_R hRle ++ have hz_ball1 : z ∈ Metric.closedBall (0 : ℂ) 1 := by ++ have hz_le1 : dist z (0 : ℂ) ≤ 1 := le_trans hz_dist_le_small hR1_le_1 ++ simpa [Metric.mem_closedBall] using hz_le1 ++ ++ have hz_ballR : z ∈ Metric.closedBall (0 : ℂ) R := by ++ have hz_le_R : dist z (0 : ℂ) ≤ R := le_trans hz_dist_le_small (le_of_lt hR1_lt_R) ++ simpa [Metric.mem_closedBall] using hz_le_R ++ have hnum := blaschke_num_diff_nonzero (R:=R) (R1:=R1) (f:=f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ρ hρ z hz_ballR ++ have hnum_ne : R - (star ρ) * z / R ≠ 0 := hnum.1 ++ have hnum_diff : DifferentiableAt ℂ (fun w ↦ R - (star ρ) * w / R) z := hnum.2 ++ ++ refine And.intro ?_ ?_ ++ · intro h ++ have h' : (R - (star ρ) * z / R) * (z - ρ)⁻¹ = 0 := by ++ simpa [div_eq_mul_inv] using h ++ rcases mul_eq_zero.mp h' with hnum0 | hinv0 ++ · exact hnum_ne hnum0 ++ · exact hden_ne (inv_eq_zero.mp hinv0) ++ · exact hnum_diff.div hden_diff hden_ne ++ ++lemma blaschke_pow_diff_nonzero {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ ρ ∈ zerosetKfR R1 (by linarith) f, ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ ((R - (star ρ) * z / R) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat ≠ 0 ∧ ++ DifferentiableAt ℂ (fun w ↦ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro ρ hρ z hz ++ have hfrac := ++ blaschke_frac_diff_nonzero (R := R) (R1 := R1) (f := f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ++ ρ hρ z hz ++ rcases hfrac with ⟨hne, hdiff⟩ ++ constructor ++ · exact pow_ne_zero _ hne ++ · convert hdiff.pow ((analyticOrderAt f ρ).toNat) using 1 ++ ++lemma blaschke_prod_diff_nonzero {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ (∏ ρ ∈ h_finite_zeros.toFinset, ((R - (star ρ) * z / R) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat) ≠ 0 ∧ ++ DifferentiableAt ℂ (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro z hz ++ classical ++ constructor ++ · ++ have hne_each : ∀ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * z / R) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat ≠ 0 := by ++ intro ρ hρ ++ have hρ' : ρ ∈ zerosetKfR R1 (by linarith) f := ++ (h_finite_zeros.mem_toFinset).1 hρ ++ have hpair := ++ blaschke_pow_diff_nonzero (R := R) (R1 := R1) (f := f) ++ hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ρ hρ' z hz ++ exact hpair.1 ++ exact (Finset.prod_ne_zero_iff).2 hne_each ++ · ++ have hdiff_each : ∀ ρ ∈ h_finite_zeros.toFinset, ++ DifferentiableAt ℂ ++ (fun w ↦ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro ρ hρ ++ have hρ' : ρ ∈ zerosetKfR R1 (by linarith) f := ++ (h_finite_zeros.mem_toFinset).1 hρ ++ have hpair := ++ blaschke_pow_diff_nonzero (R := R) (R1 := R1) (f := f) ++ hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ρ hρ' z hz ++ exact hpair.2 ++ ++ have hdiff := ++ (DifferentiableAt.finsetProd (u := h_finite_zeros.toFinset) ++ (f := fun ρ => fun w ↦ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) ++ (x := z) hdiff_each) ++ have hfun_eq : ++ (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) ++ = ++ (∏ ρ ∈ h_finite_zeros.toFinset, ++ (fun w ↦ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat)) := by ++ funext w ++ simp [Finset.prod_apply] ++ exact hfun_eq.symm ▸ hdiff ++ ++lemma f_diff_nonzero_outside_Kf {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (_h_f_zero : f 0 = 1) ++ (_h_finite_zeros : (zerosetKfR R1 (by linarith ) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ f z ≠ 0 ∧ DifferentiableAt ℂ f z := by ++ intro z hz ++ ++ have hz' : z ∈ Metric.closedBall (0 : ℂ) R1 ∧ ++ z ∉ zerosetKfR R1 (by linarith) f := by ++ simpa [Set.mem_sdiff] using hz ++ have hz_in_R1 : z ∈ Metric.closedBall (0 : ℂ) R1 := hz'.1 ++ have hz_notin : z ∉ zerosetKfR R1 (by linarith) f := hz'.2 ++ ++ have hz_nonzero : f z ≠ 0 := by ++ intro hfz ++ exact hz_notin ⟨hz_in_R1, hfz⟩ ++ ++ have hR1_lt_1 : R1 < 1 := by linarith ++ have hsubset1 : ++ Metric.closedBall (0 : ℂ) R1 ⊆ Metric.ball (0 : ℂ) 1 := ++ Metric.closedBall_subset_ball hR1_lt_1 ++ have hz_in_ball1 : z ∈ Metric.ball (0 : ℂ) 1 := hsubset1 hz_in_R1 ++ have hz_in_1 : z ∈ Metric.closedBall (0 : ℂ) 1 := ++ Metric.ball_subset_closedBall hz_in_ball1 ++ have hAna : AnalyticAt ℂ f z := h_f_analytic z hz_in_1 ++ have hDiff : DifferentiableAt ℂ f z := hAna.differentiableAt ++ exact ⟨hz_nonzero, hDiff⟩ ++ ++lemma Bf_diff_nonzero_outside_Kf ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ z ≠ 0 ∧ ++ DifferentiableAt ℂ (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ) z := by ++ intro z hz ++ ++ rw [Set.mem_sdiff] at hz ++ have hz_ball : z ∈ Metric.closedBall (0 : ℂ) R1 := hz.1 ++ ++ constructor ++ · ++ exact Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec z hz_ball ++ ++ · ++ ++ have hz_R : z ∈ Metric.closedBall (0 : ℂ) R := ++ Metric.closedBall_subset_closedBall (le_of_lt hR1_lt_R) hz_ball ++ ++ have h_analytic_on := Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec ++ ++ have h_analytic_at := h_analytic_on z hz_R ++ ++ exact h_analytic_at.differentiableAt ++ ++lemma logDeriv_fprod_is_sum {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ logDeriv (fun w ↦ f w * ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z = ++ logDeriv f z + logDeriv (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro z hz ++ have hf' := f_diff_nonzero_outside_Kf (R:=R) (R1:=R1) (f:=f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz ++ rcases hf' with ⟨hf_ne, hf_diff⟩ ++ have hg' := blaschke_prod_diff_nonzero (R:=R) (R1:=R1) (f:=f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz ++ rcases hg' with ⟨hg_ne, hg_diff⟩ ++ simpa using ++ (logDerivmul (f:=f) (g:=fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) (z:=z) ++ hf_diff hg_diff hf_ne hg_ne) ++ ++lemma nhds_avoids_finset {z : ℂ} (K : Finset ℂ) (hz : z ∉ (K : Set ℂ)) : ∀ᶠ w in nhds z, ∀ ρ ∈ K, w ≠ ρ := by ++ classical ++ ++ let U : Set ℂ := ⋂ ρ ∈ K, {w : ℂ | w ≠ ρ} ++ ++ have hopen_each : ∀ ρ ∈ K, IsOpen ({w : ℂ | w ≠ ρ} : Set ℂ) := by ++ intro ρ hρ ++ have hopen : IsOpen ((({ρ} : Set ℂ)ᶜ : Set ℂ)) := isOpen_compl_singleton ++ have hEq : ((({ρ} : Set ℂ)ᶜ : Set ℂ)) = {w : ℂ | w ≠ ρ} := by ++ ext w; simp ++ simpa [hEq] ++ using hopen ++ ++ have hopenU : IsOpen U := ++ isOpen_biInter_finset (s := K) (f := fun ρ : ℂ => ({w : ℂ | w ≠ ρ} : Set ℂ)) hopen_each ++ ++ have hzU : z ∈ U := by ++ have hznot : ∀ ρ ∈ K, z ≠ ρ := by ++ intro ρ hρ h ++ exact hz (by simpa [h] using hρ) ++ simpa [U] using hznot ++ ++ have hU_mem : U ∈ nhds z := hopenU.mem_nhds hzU ++ ++ refine Filter.eventually_of_mem hU_mem ?_ ++ intro w hw ρ hρ ++ have hw_all := Set.mem_iInter₂.mp hw ++ have : w ∈ ({w : ℂ | w ≠ ρ} : Set ℂ) := hw_all ρ hρ ++ simpa using this ++ ++lemma pow_div_pow_eq_div_pow (a b : ℂ) (n : ℕ) : a^n / b^n = (a / b)^n := by ++ simpa using (div_pow a b n).symm ++ ++lemma Cf_eventually_eq_f_div_prod {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ : ℂ → (ℂ → ℂ)) ++ (_h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ {z : ℂ} (hz : z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f) : ++ (fun w ↦ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (by simp [h_f_zero]) h_finite_zeros h_σ w) ++ =ᶠ[nhds z] ++ (fun w ↦ f w / ∏ ρ ∈ h_finite_zeros.toFinset, (w - ρ) ^ (analyticOrderAt f ρ).toNat) := by ++ classical ++ rcases hz with ⟨hz_ball, hz_notin⟩ ++ ++ set S : Set ℂ := zerosetKfR R1 (by linarith) f ++ have hS_fin : S.Finite := h_finite_zeros ++ have hS_closed : IsClosed S := hS_fin.isClosed ++ have hU_open : IsOpen Sᶜ := hS_closed.isOpen_compl ++ have hz_memU : z ∈ Sᶜ := by simpa [S] using hz_notin ++ have hU_mem : Sᶜ ∈ nhds z := hU_open.mem_nhds hz_memU ++ refine Filter.eventually_of_mem hU_mem ?_ ++ intro w hw ++ have hw_notin : w ∉ S := by ++ ++ simpa [Set.mem_compl] using hw ++ ++ simp [S, Cf, hw_notin] ++ ++lemma eventuallyEq_mul_right_fun {α β} {l : Filter α} [Mul β] ++ {f g h : α → β} (hfg : f =ᶠ[l] g) : ++ (fun x => f x * h x) =ᶠ[l] (fun x => g x * h x) := by ++ filter_upwards [hfg] with x hx ++ rw [hx] ++ ++lemma inv_prod_complex {ι} (s : Finset ι) (f : ι → ℂ) : (∏ x ∈ s, f x)⁻¹ = ∏ x ∈ s, (f x)⁻¹ := by ++ classical ++ simp ++ ++lemma prod_num_mul_inv_den_eq_prod_ratio ++ (K : Finset ℂ) (N D : ℂ → ℂ) (m : ℂ → ℕ) : ++ (∏ ρ ∈ K, (N ρ) ^ (m ρ)) * (∏ ρ ∈ K, (D ρ) ^ (m ρ))⁻¹ ++ = ∏ ρ ∈ K, ((N ρ / D ρ) ^ (m ρ)) := by ++ classical ++ ++ have hinv : (∏ ρ ∈ K, (D ρ) ^ (m ρ))⁻¹ = ∏ ρ ∈ K, ((D ρ) ^ (m ρ))⁻¹ := by ++ simp ++ calc ++ (∏ ρ ∈ K, (N ρ) ^ (m ρ)) * (∏ ρ ∈ K, (D ρ) ^ (m ρ))⁻¹ ++ = (∏ ρ ∈ K, (N ρ) ^ (m ρ)) * (∏ ρ ∈ K, ((D ρ) ^ (m ρ))⁻¹) := by ++ simp ++ _ = ∏ ρ ∈ K, ((N ρ) ^ (m ρ) * ((D ρ) ^ (m ρ))⁻¹) := by ++ simpa using (Finset.prod_mul_distrib (s := K) ++ (f := fun ρ => (N ρ) ^ (m ρ)) ++ (g := fun ρ => ((D ρ) ^ (m ρ))⁻¹)).symm ++ _ = ∏ ρ ∈ K, ((N ρ / D ρ) ^ (m ρ)) := by ++ apply Finset.prod_congr rfl ++ intro ρ hρ ++ ++ calc ++ (N ρ) ^ (m ρ) * ((D ρ) ^ (m ρ))⁻¹ ++ = (N ρ) ^ (m ρ) * ((D ρ)⁻¹) ^ (m ρ) := by ++ simp ++ _ = ((N ρ) * (D ρ)⁻¹) ^ (m ρ) := by ++ simp [mul_pow] ++ _ = (N ρ / D ρ) ^ (m ρ) := by ++ simp [div_eq_mul_inv] ++ ++lemma prod_num_mul_inv_den_eq_prod_ratio_fun ++ (K : Finset ℂ) (N D : ℂ → ℂ → ℂ) (m : ℂ → ℕ) : ++ (fun w ↦ (∏ ρ ∈ K, (N ρ w) ^ (m ρ)) * (∏ ρ ∈ K, (D ρ w) ^ (m ρ))⁻¹) ++ = (fun w ↦ ∏ ρ ∈ K, ((N ρ w / D ρ w) ^ (m ρ))) := by ++ funext w ++ classical ++ have h_inv : ++ (∏ ρ ∈ K, (D ρ w) ^ (m ρ))⁻¹ = ∏ ρ ∈ K, ((D ρ w) ^ (m ρ))⁻¹ := by ++ simp ++ calc ++ (∏ ρ ∈ K, (N ρ w) ^ (m ρ)) * (∏ ρ ∈ K, (D ρ w) ^ (m ρ))⁻¹ ++ = (∏ ρ ∈ K, (N ρ w) ^ (m ρ)) * (∏ ρ ∈ K, ((D ρ w) ^ (m ρ))⁻¹) := by ++ rw [h_inv] ++ _ = ∏ ρ ∈ K, ((N ρ w) ^ (m ρ)) * ((D ρ w) ^ (m ρ))⁻¹ := by ++ simpa using ++ (Finset.prod_mul_distrib ++ (s := K) ++ (f := fun ρ => (N ρ w) ^ (m ρ)) ++ (g := fun ρ => ((D ρ w) ^ (m ρ))⁻¹)).symm ++ _ = ∏ ρ ∈ K, (N ρ w / D ρ w) ^ (m ρ) := by ++ refine Finset.prod_congr rfl ?_ ++ intro ρ hρ ++ have hpow : ++ (N ρ w / D ρ w) ^ (m ρ) ++ = ((N ρ w) ^ (m ρ)) * ((D ρ w) ^ (m ρ))⁻¹ := by ++ simp [div_eq_mul_inv, mul_pow, inv_pow] ++ simp [hpow] ++ ++lemma div_mul_eq_mul_mul_inv_fun {α} (f A B : α → ℂ) : ++ (fun w => (f w / A w) * B w) = (fun w => f w * (B w * (A w)⁻¹)) := by ++ funext w ++ simp [div_eq_mul_inv, mul_comm, mul_left_comm] ++ ++lemma assoc_fun_mul {α} (f g h : α → ℂ) : (fun w => f w * (g w * h w)) = (fun w => (f w * g w) * h w) := by ++ funext w ++ simp [mul_assoc] ++ ++lemma prod_num_mul_inv_den_eq_prod_ratio_fun_mem ++ (K : Finset ℂ) (N D : ℂ → ℂ → ℂ) (m : ℂ → ℕ) : ++ (fun w ↦ (∏ ρ ∈ K, (N ρ w) ^ (m ρ)) * (∏ ρ ∈ K, (D ρ w) ^ (m ρ))⁻¹) ++ = (fun w ↦ ∏ ρ ∈ K, ((N ρ w / D ρ w) ^ (m ρ))) := by ++ funext w ++ classical ++ calc ++ (∏ ρ ∈ K, (N ρ w) ^ (m ρ)) * (∏ ρ ∈ K, (D ρ w) ^ (m ρ))⁻¹ ++ = (∏ ρ ∈ K, (N ρ w) ^ (m ρ)) / (∏ ρ ∈ K, (D ρ w) ^ (m ρ)) := by ++ simp [div_eq_mul_inv] ++ _ = ∏ ρ ∈ K, ((N ρ w) ^ (m ρ) / (D ρ w) ^ (m ρ)) := by ++ simp ++ _ = ∏ ρ ∈ K, ((N ρ w / D ρ w) ^ (m ρ)) := by ++ refine Finset.prod_congr rfl ?_ ++ intro ρ hρ ++ have hpow_div : ++ (N ρ w / D ρ w) ^ (m ρ) ++ = (N ρ w) ^ (m ρ) / (D ρ w) ^ (m ρ) := by ++ calc ++ (N ρ w / D ρ w) ^ (m ρ) ++ = (N ρ w * (D ρ w)⁻¹) ^ (m ρ) := by ++ simp [div_eq_mul_inv] ++ _ = (N ρ w) ^ (m ρ) * ((D ρ w)⁻¹) ^ (m ρ) := by ++ simpa using (mul_pow (N ρ w) ((D ρ w)⁻¹) (m ρ)) ++ _ = (N ρ w) ^ (m ρ) * ((D ρ w) ^ (m ρ))⁻¹ := by ++ simp ++ _ = (N ρ w) ^ (m ρ) / (D ρ w) ^ (m ρ) := by ++ simp [div_eq_mul_inv] ++ simpa using hpow_div.symm ++ ++lemma eventuallyEq_of_eq {α β} {l : Filter α} {f g : α → β} (h : f = g) : f =ᶠ[l] g := by ++ simp [h] ++ ++lemma logDeriv_congr_of_eventuallyEq {f g : ℂ → ℂ} {z : ℂ} ++ (hfg : f =ᶠ[nhds z] g) : logDeriv f z = logDeriv g z := by ++ ++ have hval : f z = g z := Filter.EventuallyEq.eq_of_nhds hfg ++ have hderiv_eq_ev : deriv f =ᶠ[nhds z] deriv g := hfg.deriv ++ have hderiv : deriv f z = deriv g z := Filter.EventuallyEq.eq_of_nhds hderiv_eq_ev ++ ++ have hf := deriv_over_fun_is_logDeriv (g := f) z ++ have hg := deriv_over_fun_is_logDeriv (g := g) z ++ simp [hf.symm, hg.symm, hval, hderiv] ++ ++lemma logDeriv_Bf_is_sum : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ ++ zerosetKfR R1 (by linarith) f, ++ logDeriv (Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ) z = ++ logDeriv f z + ++ logDeriv ++ (fun w ↦ ++ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ classical ++ intro z hz ++ ++ set K : Finset ℂ := h_finite_zeros.toFinset ++ ++ let A : ℂ → ℂ := fun w => ∏ ρ ∈ K, (w - ρ) ^ (analyticOrderAt f ρ).toNat ++ let BN : ℂ → ℂ := fun w => ∏ ρ ∈ K, (R - (star ρ) * w / R) ^ (analyticOrderAt f ρ).toNat ++ let RatProd : ℂ → ℂ := ++ fun w => ∏ ρ ∈ K, ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat ++ ++ set S : Set ℂ := zerosetKfR R1 (by linarith) f ++ have hS_fin : S.Finite := h_finite_zeros ++ have hU_open : IsOpen Sᶜ := hS_fin.isClosed.isOpen_compl ++ have hz_notin : z ∉ S := by ++ rcases hz with ⟨_, hnotin⟩; exact hnotin ++ have hzU : z ∈ Sᶜ := by simpa [Set.mem_compl] using hz_notin ++ have hU_mem : Sᶜ ∈ nhds z := hU_open.mem_nhds hzU ++ have h_ev : ++ (fun w ↦ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w) ++ =ᶠ[nhds z] ++ (fun w ↦ f w * RatProd w) := by ++ refine Filter.eventually_of_mem hU_mem ?_ ++ intro w hwU ++ have hw_notin : w ∉ S := by simpa [Set.mem_compl] using hwU ++ ++ have hBf_w : ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w ++ = Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w * BN w := by ++ simp [Bf, BN, K] ++ have hCf_w : ++ Cf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w ++ = f w / A w := by ++ simp [Cf, S, A, K, hw_notin] ++ ++ have h_eq1 := div_mul_eq_mul_mul_inv_fun (f := f) (A := A) (B := BN) ++ have h_eq1_w : (f w / A w) * BN w = f w * (BN w * (A w)⁻¹) := by ++ simpa using congrArg (fun g : (ℂ → ℂ) => g w) h_eq1 ++ have h_eq2 := ++ prod_num_mul_inv_den_eq_prod_ratio_fun_mem ++ (K := K) ++ (N := fun ρ w ↦ (R - (star ρ) * w / R)) ++ (D := fun ρ w ↦ (w - ρ)) ++ (m := fun ρ ↦ (analyticOrderAt f ρ).toNat) ++ have h_eq2_w : BN w * (A w)⁻¹ = RatProd w := by ++ simpa [BN, A, RatProd] using congrArg (fun g : (ℂ → ℂ) => g w) h_eq2 ++ ++ calc ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w ++ = (f w / A w) * BN w := by simpa [hCf_w] using hBf_w ++ _ = f w * (BN w * (A w)⁻¹) := h_eq1_w ++ _ = f w * RatProd w := by simp [h_eq2_w] ++ ++ have hlog_congr := logDeriv_congr_of_eventuallyEq (f := fun w ↦ ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w) ++ (g := fun w ↦ f w * RatProd w) (z := z) h_ev ++ ++ have hsum := ++ (logDeriv_fprod_is_sum (R:=R) (R1:=R1) (f:=f) ++ hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz) ++ simpa [RatProd, K] using hlog_congr.trans hsum ++ ++lemma logDeriv_def_as_frac {f : ℂ → ℂ} {z : ℂ} ++ (_hf : DifferentiableAt ℂ f z) (_hf_ne : f z ≠ 0) : ++ logDeriv f z = deriv f z / f z := by ++ simp [logDeriv] ++ ++theorem ball_containment {r R1 : ℝ} (_hr_pos : 0 < r) (hr_lt_R1 : r < R1) (z : ℂ) (hz : z ∈ Metric.closedBall 0 r) : z ∈ Metric.closedBall 0 R1 := by ++ simp at * ++ exact le_trans hz (le_of_lt hr_lt_R1) ++ ++theorem in_r_minus_kf {R1 r : ℝ} {f : ℂ → ℂ} ++ (hr_pos : 0 < r) ++ (hr_lt_R1 : r < R1) ++ (z : ℂ) ++ (hz : z ∈ Metric.closedBall 0 r \ zerosetKfR R1 (by linarith) f) : ++ z ∈ Metric.closedBall 0 R1 \ zerosetKfR R1 (by linarith) f := by ++ obtain ⟨h1, h2⟩ := hz ++ have : z ∈ Metric.closedBall 0 R1 := by ++ apply ball_containment hr_pos hr_lt_R1 z h1 ++ constructor <;> assumption ++ ++lemma Lf_deriv_step1 : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f, ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z = ++ deriv f z / f z + logDeriv (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro z hz ++ ++ have hz' : z ∈ Metric.closedBall (0 : ℂ) r ∧ z ∉ zerosetKfR R1 (by linarith) f := by ++ simpa [Set.mem_sdiff] using hz ++ have hz_ball : z ∈ Metric.closedBall (0 : ℂ) r := hz'.1 ++ ++ have hLf := ++ ++ (Lf_deriv_is_logBf_deriv hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec ++ z (in_r_minus_kf hr_pos hr_lt_R1 _ hz)).symm ++ ++ have hsum : ++ logDeriv (fun w ↦ ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) ++ h_finite_zeros h_σ w) z = ++ logDeriv f z + ++ logDeriv (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ have h := ++ (logDeriv_Bf_is_sum (R := R) (R1 := R1) (r := r) (f := f) (h_σ := h_σ) ++ hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros) z (in_r_minus_kf hr_pos hr_lt_R1 _ hz) ++ simpa using h ++ ++ obtain ⟨hf_ne, hfdiff⟩ := ++ f_diff_nonzero_outside_Kf (R := R) (R1 := R1) (f := f) ++ hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z (in_r_minus_kf hr_pos hr_lt_R1 _ hz) ++ have hfrac : logDeriv f z = deriv f z / f z := ++ logDeriv_def_as_frac (f := f) (z := z) hfdiff hf_ne ++ ++ have hLf_eq_logDerivBf : ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z = ++ logDeriv (fun w ↦ ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) ++ h_finite_zeros h_σ w) z := by ++ ++ have hz_in_r : z ∈ Metric.closedBall (0 : ℂ) r := hz_ball ++ ++ let B_f : ℂ → ℂ := ++ fun w => Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) h_finite_zeros h_σ w ++ let log_exists := log_of_analytic ++ (r1 := r) (R' := R1) (R := R) ++ hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 ++ (B := B_f) ++ (hB := Bf_is_analytic_on_disk R R1 hR1_pos hR1_lt_R hR_lt_1 ++ f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec) ++ (hB_ne_zero := by ++ intro w hw ++ exact Bf_never_zero R R1 hR1_pos hR1_lt_R hR_lt_1 ++ f h_f_analytic h_f_zero h_finite_zeros h_σ h_σ_spec w hw) ++ have hderiv_all : ∀ w ∈ Metric.closedBall (0 : ℂ) r, ++ deriv (Classical.choose log_exists) w = deriv B_f w / B_f w := ++ (Classical.choose_spec log_exists).2.2.1 ++ have hderiv_Lf : ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos ++ h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z ++ = deriv B_f z / B_f z := by ++ ++ unfold Lf ++ ++ simpa using hderiv_all z hz_in_r ++ ++ have h_as_log : deriv B_f z / B_f z = logDeriv B_f z := ++ deriv_over_fun_is_logDeriv (g := B_f) z ++ ++ simpa [B_f] using hderiv_Lf.trans h_as_log ++ ++ calc ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z ++ = logDeriv (fun w ↦ ++ Bf R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic (f_zero_ne_zero h_f_zero) ++ h_finite_zeros h_σ w) z := hLf_eq_logDerivBf ++ _ = logDeriv f z + ++ logDeriv (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := hsum ++ _ = deriv f z / f z + ++ logDeriv (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ simp [hfrac] ++ ++lemma logDeriv_prod_is_sum {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ logDeriv (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z = ++ ∑ ρ ∈ h_finite_zeros.toFinset, logDeriv (fun w ↦ ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro z hz ++ have hdiff : ∀ ρ ∈ h_finite_zeros.toFinset, ++ DifferentiableAt ℂ (fun w ↦ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z := by ++ intro ρ hρ ++ have hρmem : ρ ∈ zerosetKfR R1 (by linarith) f := ++ (h_finite_zeros.mem_toFinset).mp hρ ++ have h := blaschke_pow_diff_nonzero (R:=R) (R1:=R1) (f:=f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ρ hρmem z hz ++ exact h.2 ++ have hne : ∀ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * z / R) / (z - ρ)) ^ (analyticOrderAt f ρ).toNat ≠ 0 := by ++ intro ρ hρ ++ have hρmem : ρ ∈ zerosetKfR R1 (by linarith) f := ++ (h_finite_zeros.mem_toFinset).mp hρ ++ have h := blaschke_pow_diff_nonzero (R:=R) (R1:=R1) (f:=f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ρ hρmem z hz ++ exact h.1 ++ simpa using ++ (logDerivprod (K := h_finite_zeros.toFinset) ++ (g := fun ρ w ↦ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) ++ (z := z) hdiff hne) ++ ++lemma logDeriv_power_is_mul {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ ∀ ρ ∈ h_finite_zeros.toFinset, ++ logDeriv (fun w ↦ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z = ++ (analyticOrderAt f ρ).toNat * logDeriv (fun w ↦ (R - (star ρ) * w / R) / (w - ρ)) z := by ++ intro z hz ρ hρFin ++ have hρmem : ρ ∈ zerosetKfR R1 (by linarith) f := by ++ simpa using (h_finite_zeros.mem_toFinset.mp hρFin) ++ have hfrac := ++ blaschke_frac_diff_nonzero (R := R) (R1 := R1) (f := f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ++ ρ hρmem z hz ++ rcases hfrac with ⟨_hneq, hdiff⟩ ++ simpa using ++ (logDerivfunpow (g := fun w ↦ (R - (star ρ) * w / R) / (w - ρ)) (z := z) ++ (m := (analyticOrderAt f ρ).toNat) hdiff) ++ ++lemma logDeriv_prod_is_sum_mul {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ logDeriv (fun w ↦ ∏ ρ ∈ h_finite_zeros.toFinset, ++ ((R - (star ρ) * w / R) / (w - ρ)) ^ (analyticOrderAt f ρ).toNat) z = ++ ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat * ++ logDeriv (fun w ↦ (R - (star ρ) * w / R) / (w - ρ)) z := by ++ intro z hz ++ classical ++ have hsum := ++ logDeriv_prod_is_sum (R := R) (R1 := R1) (f := f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz ++ refine hsum.trans ?_ ++ refine Finset.sum_congr rfl ?_ ++ intro ρ hρ ++ exact ++ logDeriv_power_is_mul (R := R) (R1 := R1) (f := f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz ρ hρ ++ ++lemma Lf_deriv_step2 : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f, ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z = ++ deriv f z / f z + ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat * ++ logDeriv (fun w ↦ (R - (star ρ) * w / R) / (w - ρ)) z := by ++ intro z hz ++ classical ++ have h1 := ++ Lf_deriv_step1 hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z hz ++ have hsum := ++ logDeriv_prod_is_sum_mul (R:=R) (R1:=R1) (f:=f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z (in_r_minus_kf hr_pos hr_lt_R1 _ hz) ++ have h2 := congrArg (fun t => deriv f z / f z + t) hsum ++ exact h1.trans h2 ++ ++lemma logDeriv_Blaschke_is_diff {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ ∀ ρ ∈ h_finite_zeros.toFinset, ++ logDeriv (fun w ↦ (R - (star ρ) * w / R) / (w - ρ)) z = ++ logDeriv (fun w ↦ R - (star ρ) * w / R) z - logDeriv (fun w ↦ w - ρ) z := by ++ intro z hz ρ hρ ++ have hρ_set : ρ ∈ zerosetKfR R1 (by linarith) f := by ++ exact (Set.Finite.mem_toFinset (hs := h_finite_zeros) (a := ρ)).mp hρ ++ rcases hz with ⟨hz_in, hz_notin⟩ ++ have hden := z_minus_rho_diff_nonzero hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ++ ρ hρ_set z ⟨hz_in, hz_notin⟩ ++ rcases hden with ⟨hden_nz, hden_diff⟩ ++ have hz_le : ‖z‖ ≤ R1 := by ++ simpa [Metric.closedBall, dist_eq_norm] using hz_in ++ have hle1 : R1 < 1 := by linarith [hR1_lt_R, hR_lt_1] ++ have hz_in1 : z ∈ Metric.closedBall (0 : ℂ) 1 := by ++ have : ‖z‖ ≤ 1 := le_of_lt (hz_le.trans_lt hle1) ++ simpa [Metric.closedBall, dist_eq_norm] using this ++ have hz_inR : z ∈ Metric.closedBall (0 : ℂ) R := by ++ have hz_le_R : ‖z‖ ≤ R := by ++ calc ‖z‖ ≤ R1 := hz_le ++ _ ≤ R := le_of_lt hR1_lt_R ++ simpa [Metric.closedBall, dist_eq_norm] using hz_le_R ++ have hnum := blaschke_num_diff_nonzero hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ++ ρ hρ_set z hz_inR ++ rcases hnum with ⟨hnum_nz, hnum_diff⟩ ++ simpa using ++ (logDerivdiv (hh := hnum_diff) (hg := hden_diff) (hh_ne := hnum_nz) (hg_ne := hden_nz)) ++ ++lemma logDeriv_linear {a b : ℂ} {z : ℂ} (_ha : a ≠ 0) (_hz : z ≠ -b/a) : ++ logDeriv (fun w ↦ a * w + b) z = a / (a * z + b) := by ++ ++ have h_id : HasDerivAt (fun w : ℂ => w) (1 : ℂ) z := hasDerivAt_id _ ++ have h_mul' : HasDerivAt (fun w : ℂ => a * w) a z := by ++ simpa [one_mul] using (h_id.const_mul a) ++ have h_deriv_mul : deriv (fun w : ℂ => a * w) z = a := h_mul'.deriv ++ ++ simp [logDeriv] ++ ++lemma logDeriv_denominator {ρ : ℂ} {z : ℂ} (hz : z ≠ ρ) : ++ logDeriv (fun w ↦ w - ρ) z = 1 / (z - ρ) := by ++ have h := ++ logDeriv_linear (a := (1 : ℂ)) (b := -ρ) (z := z) ++ (_ha := by simp) ++ (_hz := by simpa using hz) ++ simpa [one_mul, sub_eq_add_neg] using h ++ ++lemma logDeriv_numerator_pre {R : ℝ} {ρ : ℂ} {z : ℂ} : ++ logDeriv (fun w ↦ R - (star ρ) * w / R) z = -(star ρ) / R / (R - (star ρ) * z / R) := by ++ classical ++ ++ let a : ℂ := -(star ρ) / (R : ℂ) ++ let b : ℂ := (R : ℂ) ++ have hlin : (fun w : ℂ ↦ (R : ℂ) - (star ρ) * w / (R : ℂ)) = (fun w : ℂ ↦ b + a * w) := by ++ funext w ++ ++ simp [a, b, sub_eq_add_neg, div_eq_mul_inv, mul_comm, mul_left_comm] ++ ++ have hderiv_add : deriv (fun w : ℂ => b + a * w) z = ++ deriv (fun _ : ℂ => b) z + deriv (fun y : ℂ => a * y) z := by ++ simp ++ have hderiv_ab : deriv (fun w : ℂ => b + a * w) z = a := by ++ simp [deriv_const, mul_comm] ++ ++ simp [logDeriv, sub_eq_add_neg, div_eq_mul_inv, ++ mul_comm, mul_left_comm, mul_assoc, add_comm] ++ ++lemma star_ne_zero_of_ne_zero {ρ : ℂ} (hρ : ρ ≠ 0) : star ρ ≠ 0 := by ++ ++ intro h ++ ++ have : ρ = 0 := (star_eq_zero).1 h ++ exact hρ this ++ ++lemma field_identity_general {K : Type*} [Field K] {a b c : K} (ha : a ≠ 0) (hb : b ≠ 0) (_hden : a - c*b/a ≠ 0) : (-(b/a)) / (a - c*b/a) = (1 : K) / (c - a^2/b) := by ++ ++ have hmul : (-(a / b) : K) ≠ 0 := by ++ have hdiv_ne : a / b ≠ 0 := div_ne_zero ha hb ++ exact neg_ne_zero.mpr hdiv_ne ++ have hnum : (-(b/a) * (-(a/b))) = (1 : K) := by ++ calc ++ (-(b/a) * (-(a/b))) = (b/a) * (a/b) := by simp ++ _ = (b * a⁻¹) * (a * b⁻¹) := by simp [div_eq_mul_inv] ++ _ = b * (a⁻¹ * (a * b⁻¹)) := by simp [mul_assoc] ++ _ = b * ((a⁻¹ * a) * b⁻¹) := by simp [mul_assoc] ++ _ = b * (1 * b⁻¹) := by simp [ha] ++ _ = b * b⁻¹ := by simp ++ _ = 1 := by simp [hb] ++ have hOne : (b/a) * (a/b) = (1 : K) := by ++ calc ++ (b/a) * (a/b) = (b * a⁻¹) * (a * b⁻¹) := by simp [div_eq_mul_inv] ++ _ = b * (a⁻¹ * (a * b⁻¹)) := by simp [mul_assoc] ++ _ = b * ((a⁻¹ * a) * b⁻¹) := by simp [mul_assoc] ++ _ = b * (1 * b⁻¹) := by simp [ha] ++ _ = b * b⁻¹ := by simp ++ _ = 1 := by simp [hb] ++ have haab : a * (a / b) = a^2 / b := by ++ simp [div_eq_mul_inv, pow_two, mul_assoc] ++ have hcbab : (c * b / a) * (a / b) = c := by ++ calc ++ (c * b / a) * (a / b) = (c * (b / a)) * (a / b) := by simp [div_eq_mul_inv, mul_assoc] ++ _ = c * ((b / a) * (a / b)) := by simp [mul_assoc] ++ _ = c * 1 := by simp [hOne] ++ _ = c := by simp ++ have hdenom : ((a - c*b/a) * (-(a/b))) = c - a^2 / b := by ++ calc ++ ((a - c*b/a) * (-(a/b))) = -((a - c*b/a) * (a / b)) := by simp [mul_neg] ++ _ = -(a * (a / b) - (c * b / a) * (a / b)) := by simp [sub_mul] ++ _ = (c * b / a) * (a / b) - a * (a / b) := by simp [neg_sub] ++ _ = c - a^2 / b := by simp [hcbab, haab] ++ calc ++ (-(b/a)) / (a - c*b/a) ++ = (-(b/a) * (-(a/b))) / ((a - c*b/a) * (-(a/b))) := by ++ simpa using ++ (mul_div_mul_right (a := (-(b / a))) (b := (a - c * b / a)) (c := (-(a / b))) hmul).symm ++ _ = 1 / ((a - c*b/a) * (-(a/b))) := by simp [hnum] ++ _ = 1 / (c - a^2/b) := by simp [hdenom] ++ ++lemma complex_identity_from_field {R : ℝ} {ρ z : ℂ} (hR : R ≠ 0) (hρ : ρ ≠ 0) (hden : (R:ℂ) - (star ρ) * z / R ≠ 0) : (-(star ρ) / (R:ℂ)) / ((R:ℂ) - (star ρ) * z / R) = (1 : ℂ) / (z - (R:ℂ)^2 / (star ρ)) := by ++ have ha : (R : ℂ) ≠ 0 := by simpa using (Complex.ofReal_ne_zero.mpr hR) ++ have hb : star ρ ≠ 0 := star_ne_zero_of_ne_zero hρ ++ have hden' : (R : ℂ) - z * (star ρ) / (R : ℂ) ≠ 0 := by ++ simpa [mul_comm, mul_left_comm, mul_assoc, div_eq_mul_inv] using hden ++ have h := field_identity_general (K := ℂ) (a := (R : ℂ)) (b := star ρ) (c := z) ha hb hden' ++ simpa [mul_comm, mul_left_comm, mul_assoc, div_eq_mul_inv] using h ++ ++lemma logDeriv_numerator_rearranged {R : ℝ} {ρ z : ℂ} (hR : R ≠ 0) (hrho : ρ ≠ 0) (h_denom_ne_zero : (R : ℂ) - (star ρ) * z / R ≠ 0) : -(star ρ) / R / ((R : ℂ) - (star ρ) * z / R) = 1 / (z - (R : ℂ)^2 / (star ρ)) := by ++ simpa using (complex_identity_from_field (R:=R) (ρ:=ρ) (z:=z) (hR:=hR) (hρ:=hrho) (hden:=h_denom_ne_zero)) ++ ++lemma logDeriv_numerator {R : ℝ} {ρ : ℂ} {z : ℂ} ++ (hR : R ≠ 0) ++ (hrho : ρ ≠ 0) ++ (h_denom_ne_zero : (R : ℂ) - (star ρ) * z / R ≠ 0): ++ logDeriv (fun w ↦ R - (star ρ) * w / R) z = 1 / (z - R^2 / (star ρ)) := by ++ rw [logDeriv_numerator_pre, logDeriv_numerator_rearranged] ++ <;> assumption ++ ++lemma logDeriv_Blaschke_is_diff_frac {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) (h_f_zero : f 0 = 1) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ ρ ∈ h_finite_zeros.toFinset, ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f , logDeriv (fun w ↦ (R - (star ρ) * w / R) / (w - ρ)) z = ++ 1 / (z - R^2 / (star ρ)) - 1 / (z - ρ) := by ++ intro ρ hρ z hz ++ ++ have h_div := logDeriv_Blaschke_is_diff (R := R) (R1 := R1) (f := f) hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz ρ hρ ++ ++ have hρ_mem : ρ ∈ zerosetKfR R1 (by linarith) f := by ++ exact (h_finite_zeros.mem_toFinset).mp hρ ++ have hρ_ne_zero : ρ ≠ 0 := by ++ intro h_eq ++ ++ have : f 0 = 0 := by simpa [h_eq] using hρ_mem.2 ++ exact (zero_ne_one : (0 : ℂ) ≠ 1) (this.symm.trans h_f_zero) ++ have hR_ne_zero : R ≠ 0 := ne_of_gt (hR1_pos.trans hR1_lt_R) ++ have h_denom_ne_zero : (R : ℂ) - (star ρ) * z / R ≠ 0 := by ++ ++ have hz_ball : z ∈ Metric.closedBall (0 : ℂ) R := by ++ have hle : R1 < R := hR1_lt_R ++ apply Metric.closedBall_subset_closedBall (le_of_lt hle) ++ exact hz.1 ++ have h := blaschke_num_diff_nonzero hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros ρ hρ_mem z hz_ball ++ exact h.1 ++ have h_num := logDeriv_numerator hR_ne_zero hρ_ne_zero h_denom_ne_zero ++ ++ have hz_ne_rho : z ≠ ρ := by ++ intro h_eq ++ exact hz.2 (by simpa [h_eq] using hρ_mem) ++ have h_den := logDeriv_denominator hz_ne_rho ++ ++ rw [h_div, h_num, h_den] ++ ++lemma Lf_deriv_step3 : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f, ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z = ++ deriv f z / f z + ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat * (1 / (z - R^2 / (star ρ)) - 1 / (z - ρ)) := by ++ intro z hz ++ ++ rw [Lf_deriv_step2 hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z hz] ++ congr 1 ++ apply Finset.sum_congr rfl ++ intro ρ hρ ++ congr 1 ++ exact logDeriv_Blaschke_is_diff_frac hR1_pos hR1_lt_R hR_lt_1 h_f_zero h_f_analytic h_finite_zeros ρ hρ z (in_r_minus_kf hr_pos hr_lt_R1 _ hz) ++ ++lemma sum_of_diff {K : Finset ℂ} {a b : ℂ → ℂ} : ++ ∑ ρ ∈ K, (a ρ - b ρ) = ∑ ρ ∈ K, a ρ - ∑ ρ ∈ K, b ρ := by ++ simp [Finset.sum_sub_distrib] ++ ++lemma sum_rearranged {R R1 : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) (_hR1_lt_R : R1 < R) (_hR_lt_1 : R < 1) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (_h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f, ++ ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat * ++ (1 / (z - R^2 / (star ρ)) - 1 / (z - ρ)) = ++ ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ)) - ++ ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - ρ) := by ++ intro z hz ++ rw [← Finset.sum_sub_distrib] ++ congr 1 ++ ext ρ ++ rw [mul_sub, mul_one_div, mul_one_div] ++ ++lemma Lf_deriv_final_formula : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f, ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z = ++ deriv f z / f z - ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - ρ) + ++ ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ)) := by ++ intro z hz ++ ++ rw [Lf_deriv_step3 hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z hz] ++ ++ rw [sum_rearranged hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz] ++ ++ ring ++ ++lemma rearrange_Lf_deriv : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f, ++ deriv f z / f z - ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - ρ) = ++ deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z - ++ ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ)) := by ++ intro z hz ++ ++ have h_final := Lf_deriv_final_formula hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z hz ++ rw [h_final] ++ ring ++ ++lemma triangle_ineq_sum {w₁ w₂ : ℂ} : ++ ‖w₁ - w₂‖ ≤ ‖w₁‖ + ‖w₂‖ := by ++ have h : w₁ - w₂ = w₁ + (-w₂) := sub_eq_add_neg w₁ w₂ ++ rw [h] ++ have h₁ : ‖w₁ + (-w₂)‖ ≤ ‖w₁‖ + ‖-w₂‖ := norm_add_le w₁ (-w₂) ++ have h₂ : ‖-w₂‖ = ‖w₂‖ := norm_neg w₂ ++ rw [h₂] at h₁; exact h₁ ++ ++lemma target_inequality_setup : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f, ++ ‖deriv f z / f z - ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - ρ)‖ ≤ ++ ‖deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z‖ + ++ ‖∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ))‖ := by ++ intro z hz ++ ++ have hrearr := rearrange_Lf_deriv hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z hz ++ ++ rw [hrearr] ++ exact norm_sub_le _ _ ++ ++lemma conj_norm_eq_norm (z : ℂ) : ‖star z‖ = ‖z‖ := by ++ simp ++ ++lemma norm_div_eq (a b : ℂ) (_hb : b ≠ 0) : ‖a / b‖ = ‖a‖ / ‖b‖ := by ++ calc ++ ‖a / b‖ = ‖a * b⁻¹‖ := by simp [div_eq_mul_inv] ++ _ = ‖a‖ * ‖b⁻¹‖ := norm_mul _ _ ++ _ = ‖a‖ * ‖b‖⁻¹ := by simp [norm_inv] ++ _ = ‖a‖ / ‖b‖ := by simp [div_eq_mul_inv] ++ ++lemma norm_Rsq_div_conj (R : ℝ) (ρ : ℂ) (hρ : ρ ≠ 0) : ‖((R^2 : ℂ) / (star ρ))‖ = (R^2 : ℝ) / ‖ρ‖ := by ++ have hb : star ρ ≠ 0 := by ++ intro h ++ have h' := congrArg star h ++ ++ have : ρ = 0 := by simpa [star_star] using h' ++ exact hρ this ++ have hnormR : ‖(R^2 : ℂ)‖ = (R^2 : ℝ) := by ++ have h := (RCLike.norm_ofReal (K:=ℂ) (R^2)) ++ simp ++ calc ++ ‖((R^2 : ℂ) / (star ρ))‖ ++ = ‖(R^2 : ℂ)‖ / ‖star ρ‖ := norm_div_eq _ _ hb ++ _ = (R^2 : ℝ) / ‖ρ‖ := by ++ simp [hnormR] ++ ++lemma zerosetKfR_subset_closedBall {R1 : ℝ} (hR1 : 0 < R1) {f : ℂ → ℂ} : ++ zerosetKfR R1 hR1 f ⊆ Metric.closedBall (0 : ℂ) R1 := by ++ intro ρ hρ ++ have hmem : ρ ∈ Metric.closedBall (0 : ℂ) R1 ∧ f ρ = 0 := by ++ simpa [zerosetKfR] using hρ ++ exact hmem.left ++ ++lemma mem_zerosetKfR_ne_zero_of_f0_eq_one {R1 : ℝ} (hR1 : 0 < R1) {f : ℂ → ℂ} ++ (hf0 : f 0 = 1) {ρ : ℂ} (hρ : ρ ∈ zerosetKfR R1 hR1 f) : ρ ≠ 0 := by ++ intro hρ0 ++ have hmem : ρ ∈ Metric.closedBall (0 : ℂ) R1 ∧ f ρ = 0 := by ++ simpa [zerosetKfR] using hρ ++ have hzero : f 0 = 0 := by simpa [hρ0] using hmem.right ++ have h10 : (1 : ℂ) ≠ 0 := one_ne_zero ++ exact h10 (by simp [hf0] at hzero) ++ ++lemma norm_sub_ge_norm_sub (x y : ℂ) : ‖x - y‖ ≥ ‖y‖ - ‖x‖ := by ++ have htri : ‖y‖ ≤ ‖y - x‖ + ‖x‖ := by ++ simpa [sub_eq_add_neg, add_comm] using norm_add_le (y - x) x ++ have h' : ‖y‖ - ‖x‖ ≤ ‖y - x‖ := (sub_le_iff_le_add).mpr htri ++ have hsymm : ‖y - x‖ = ‖x - y‖ := by ++ simpa [sub_eq_add_neg, add_comm] using (norm_neg (x - y)) ++ simpa [hsymm] using h' ++ ++lemma mem_zerosetKfR_norm_le {R1 : ℝ} (hR1 : 0 < R1) {f : ℂ → ℂ} {ρ : ℂ} ++ (hρ : ρ ∈ zerosetKfR R1 hR1 f) : ‖ρ‖ ≤ R1 := by ++ have hmem : ρ ∈ Metric.closedBall (0 : ℂ) R1 := ++ (zerosetKfR_subset_closedBall (R1 := R1) hR1 (f := f)) hρ ++ have hdist : dist ρ (0 : ℂ) ≤ R1 := by ++ simpa [Metric.mem_closedBall] using hmem ++ simpa [dist_eq_norm, sub_zero] using hdist ++ ++lemma lem_sum_bound_step2 {R R1: ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (_hR_lt_1 : R < 1) ++ (_h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ (∑ ρ ∈ h_finite_zeros.toFinset, ++ ((analyticOrderAt f ρ).toNat : ℝ) / ‖z - (R^2 : ℂ) / (star ρ)‖) ++ ≤ (1/(R^2/R1 - R1)) * ++ (∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) := by ++ classical ++ intro z hz ++ rcases hz with ⟨hzball, _hznotin⟩ ++ have hz_norm : ‖z‖ ≤ R1 := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hzball ++ ++ set S := h_finite_zeros.toFinset ++ have hS_spec : ∀ {ρ : ℂ}, ρ ∈ S → ρ ∈ zerosetKfR R1 (by linarith) f := by ++ intro ρ hρ ++ have hiff := (Set.Finite.mem_toFinset (hs := h_finite_zeros) : ρ ∈ S ↔ ρ ∈ zerosetKfR R1 (by linarith) f) ++ exact (Iff.mp hiff) hρ ++ ++ have hsum_le : ++ (∑ ρ ∈ S, ((analyticOrderAt f ρ).toNat : ℝ) / ‖z - (R^2 : ℂ) / (star ρ)‖) ++ ≤ ∑ ρ ∈ S, (1/(R^2/R1 - R1)) * ((analyticOrderAt f ρ).toNat : ℝ) := by ++ refine Finset.sum_le_sum ?termwise ++ intro ρ hρS ++ have hρmem : ρ ∈ zerosetKfR R1 (by linarith) f := hS_spec hρS ++ have hρ_ne : ρ ≠ 0 := ++ mem_zerosetKfR_ne_zero_of_f0_eq_one (R1 := R1) (hR1 := by linarith) ++ (f := f) h_f_zero hρmem ++ have hρ_norm : ‖ρ‖ ≤ R1 := mem_zerosetKfR_norm_le (R1 := R1) ++ (hR1 := by linarith) (f := f) hρmem ++ have hpt : 1 / ‖z - (R^2 : ℂ) / (star ρ)‖ ≤ 1/(R^2/R1 - R1) := by ++ ++ have h_Rsq_norm : ‖((R^2 : ℂ) / (star ρ))‖ = (R^2 : ℝ) / ‖ρ‖ := ++ norm_Rsq_div_conj R ρ hρ_ne ++ have h_lower_bound : ‖z - (R^2 : ℂ) / (star ρ)‖ ≥ ‖((R^2 : ℂ) / (star ρ))‖ - ‖z‖ := ++ norm_sub_ge_norm_sub z ((R^2 : ℂ) / (star ρ)) ++ ++ have hρ_pos : 0 < ‖ρ‖ := by ++ simpa [norm_pos_iff] using hρ_ne ++ have h_Rsq_bound : R^2/R1 ≤ ‖((R^2 : ℂ) / (star ρ))‖ := by ++ rw [h_Rsq_norm] ++ exact div_le_div_of_nonneg_left (sq_nonneg R) hρ_pos hρ_norm ++ have h_combined : R^2/R1 - R1 ≤ ‖z - (R^2 : ℂ) / (star ρ)‖ := by ++ calc R^2/R1 - R1 ++ _ ≤ ‖((R^2 : ℂ) / (star ρ))‖ - R1 := by linarith [h_Rsq_bound] ++ _ ≤ ‖((R^2 : ℂ) / (star ρ))‖ - ‖z‖ := by linarith [hz_norm] ++ _ ≤ ‖z - (R^2 : ℂ) / (star ρ)‖ := h_lower_bound ++ have h_pos_denom : 0 < R^2/R1 - R1 := by ++ have h_R_pos : 0 < R := by linarith [hR1_pos, hR1_lt_R] ++ have h_Rsq_pos : 0 < R^2 := sq_pos_of_pos h_R_pos ++ calc R^2/R1 - R1 ++ _ = (R^2 - R1*R1)/R1 := by field_simp ++ _ = (R - R1)*(R + R1)/R1 := by ring ++ _ > 0 := by ++ apply div_pos ++ · apply mul_pos ++ · linarith [hR1_lt_R] ++ · linarith [hR1_pos, hR1_lt_R] ++ · exact hR1_pos ++ have h_pos_norm : 0 < ‖z - (R^2 : ℂ) / (star ρ)‖ := by ++ apply lt_of_lt_of_le h_pos_denom h_combined ++ ++ have h_reciprocal : 1 / ‖z - (R^2 : ℂ) / (star ρ)‖ ≤ 1 / (R^2/R1 - R1) := by ++ apply div_le_div_of_nonneg_left ++ · norm_num ++ · exact h_pos_denom ++ · exact h_combined ++ exact h_reciprocal ++ have hmnonneg : 0 ≤ ((analyticOrderAt f ρ).toNat : ℝ) := by ++ exact_mod_cast (Nat.zero_le (analyticOrderAt f ρ).toNat) ++ have hmul := mul_le_mul_of_nonneg_left hpt hmnonneg ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using hmul ++ ++ rw [← Finset.mul_sum] at hsum_le ++ exact hsum_le ++ ++lemma sq_div_sub_pos (a b : ℝ) (ha_pos : 0 < a) (hab : a < b) : 0 < b^2/a - a := by ++ ++ rw [sub_pos] ++ ++ rw [lt_div_iff₀ ha_pos] ++ ++ rw [← pow_two] ++ ++ have ha_nonneg : 0 ≤ a := le_of_lt ha_pos ++ apply pow_lt_pow_left₀ hab ha_nonneg ++ norm_num ++ ++lemma final_sum_bound {R R1 B : ℝ} {f : ℂ → ℂ} ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (hB : 1 < B) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_f_bounded : ∀ z ∈ Metric.closedBall (0 : ℂ) R, ‖f z‖ ≤ B) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f, ++ ‖∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ))‖ ≤ ++ 1/((R^2/R1 - R1) * Real.log (R/R1)) * Real.log B := by ++ intro z hz ++ ++ have h_norm_bound := norm_sum_le h_finite_zeros.toFinset (fun ρ => (analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ))) ++ ++ have h_sum_eq : ∑ ρ ∈ h_finite_zeros.toFinset, ‖(analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ))‖ = ++ ∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ) / ‖z - R^2 / (star ρ)‖ := by ++ apply Finset.sum_congr rfl ++ intro ρ hρ ++ rw [norm_div, Complex.norm_natCast] ++ ++ have h_step2 := lem_sum_bound_step2 hR1_pos hR1_lt_R hR_lt_1 h_f_analytic h_f_zero h_finite_zeros z hz ++ ++ have h_f_nonzero : f 0 ≠ 0 := by rw [h_f_zero]; norm_num ++ have h_f_bounded_alt : ∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ B := by ++ intro w hw ++ exact h_f_bounded w (Metric.mem_closedBall.mpr (by simpa [dist_eq_norm] using hw)) ++ ++ have h_exists : ∀ σ : ℂ, ∃ g : ℂ → ℂ, ++ AnalyticAt ℂ g σ ∧ g σ ≠ 0 ∧ ++ (σ ∈ zerosetKfR R1 (by linarith) f → ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * g z) := by ++ intro σ ++ by_cases hσ : σ ∈ zerosetKfR R1 (by linarith) f ++ · ++ have hex := lem_analytic_zero_factor R R1 hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero σ hσ ++ obtain ⟨g, hg_at, hg_ne, h_eq⟩ := hex ++ exact ⟨g, hg_at, hg_ne, fun _ => h_eq⟩ ++ · ++ refine ⟨fun _ => 1, ?_, ?_, ?_⟩ ++ · exact analyticAt_const ++ · norm_num ++ · intro h_contra ++ contradiction ++ ++ let h_σ : ℂ → (ℂ → ℂ) := fun σ => Classical.choose (h_exists σ) ++ have h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z := by ++ intro σ hσ ++ have spec := Classical.choose_spec (h_exists σ) ++ exact ⟨spec.1, spec.2.1, spec.2.2 hσ⟩ ++ have h_sum_bound := lem_sum_m_rho_bound B R R1 hB hR1_pos hR1_lt_R hR_lt_1 f h_f_analytic h_f_nonzero h_f_zero h_finite_zeros h_σ h_f_bounded_alt h_σ_spec ++ ++ have h_pos : 0 < R^2/R1 - R1 := sq_div_sub_pos R1 R hR1_pos hR1_lt_R ++ have h_ratio_gt_one : 1 < R/R1 := by ++ rw [one_lt_div_iff] ++ left ++ exact ⟨hR1_pos, hR1_lt_R⟩ ++ have h_log_pos : 0 < Real.log (R/R1) := Real.log_pos h_ratio_gt_one ++ ++ calc ‖∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ))‖ ++ ≤ ∑ ρ ∈ h_finite_zeros.toFinset, ‖(analyticOrderAt f ρ).toNat / (z - R^2 / (star ρ))‖ := h_norm_bound ++ _ = ∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ) / ‖z - R^2 / (star ρ)‖ := h_sum_eq ++ _ ≤ (1/(R^2/R1 - R1)) * (∑ ρ ∈ h_finite_zeros.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) := h_step2 ++ _ ≤ (1/(R^2/R1 - R1)) * ((1/Real.log (R/R1)) * Real.log B) := by ++ apply mul_le_mul_of_nonneg_left h_sum_bound (div_nonneg zero_le_one (le_of_lt h_pos)) ++ _ = 1/((R^2/R1 - R1) * Real.log (R/R1)) * Real.log B := by ++ field_simp [ne_of_gt h_pos, ne_of_gt h_log_pos] ++ ++lemma final_inequality ++ (B : ℝ) (hB : 1 < B) (r1 r R R1 : ℝ) (hr1pos : 0 < r1) (hr1_lt_r : r1 < r) (hr_lt_R1 : r < R1) ++ (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ_spec : ++ ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, ++ f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_f_bounded : ∀ z ∈ Metric.closedBall (0 : ℂ) R, ‖f z‖ ≤ B) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1 \ zerosetKfR R1 (by linarith) f, ++ ++ ‖(deriv f z / f z ++ - ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - ρ))‖ ++ ≤ ++ 16 * r^2 / ((r - r1)^3) * Real.log B ++ + 1 / ((R^2 / R1 - R1) * Real.log (R / R1)) * Real.log B := by ++ intro z hz ++ ++ have hr_pos : 0 < r := by linarith [hr1pos, hr1_lt_r] ++ have hR1_pos : 0 < R1 := by linarith [hr_pos, hr_lt_R1] ++ ++ have hz_in_r : z ∈ Metric.closedBall (0 : ℂ) r \ zerosetKfR R1 (by linarith) f := by ++ constructor ++ · apply Metric.closedBall_subset_closedBall (le_of_lt hr1_lt_r) ++ exact hz.1 ++ · exact hz.2 ++ ++ have hineq := ++ target_inequality_setup hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec z hz_in_r ++ ++ have hz_in_R1 : z ∈ Metric.closedBall (0 : ℂ) R1 \ zerosetKfR R1 (by linarith) f := by ++ constructor ++ · apply Metric.closedBall_subset_closedBall ++ exact le_of_lt (lt_trans hr1_lt_r hr_lt_R1) ++ exact hz.1 ++ · exact hz.2 ++ ++ have hsum := ++ final_sum_bound hR1_pos hR1_lt_R hR_lt_1 hB h_f_analytic h_f_zero h_finite_zeros h_f_bounded z hz_in_R1 ++ ++ have hz_le_r1 : ‖z‖ ≤ r1 := by simpa [Metric.mem_closedBall, dist_eq_norm] using hz.1 ++ ++ have hz_abs : ‖z‖ ≤ r1 := hz_le_r1 ++ ++ have h_BC := apply_BC_to_Lf ++ (B := B) (r1 := r1) (r := r) (R := R) (R1 := R1) ++ (hB := hB) (hr1_pos := hr1pos) (hr1_lt_r := hr1_lt_r) (hr_lt_R1 := hr_lt_R1) ++ (hR1_pos := hR1_pos) (hR1_lt_R := hR1_lt_R) (hR_lt_1 := hR_lt_1) ++ (f := f) (h_f_analytic := h_f_analytic) (h_f_zero := h_f_zero) ++ (h_finite_zeros := h_finite_zeros) (h_σ := h_σ) (h_σ_spec := h_σ_spec) ++ (h_f_bound := fun w hw => h_f_bounded w (Metric.mem_closedBall.mpr (by simpa [dist_eq_norm] using hw))) ++ z hz_abs ++ ++ have hLf : ‖deriv (Lf hr_pos hr_lt_R1 hR1_lt_R hR_lt_1 hR1_pos h_f_analytic h_f_zero h_finite_zeros h_σ_spec) z‖ ≤ ++ 16 * r^2 / ((r - r1)^3) * Real.log B := by ++ ++ convert h_BC using 1 ++ ++ ring ++ ++ exact le_trans hineq (add_le_add hLf hsum) ++ ++lemma final_ineq1 ++ (B : ℝ) (hB : 1 < B) (r1 r R R1 : ℝ) (hr1pos : 0 < r1) (hr1_lt_r : r1 < r) (hr_lt_R1 : r < R1) ++ (hR1_lt_R : R1 < R) (hR : R < 1) ++ (f : ℂ → ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ f z) ++ (h_f_zero : f 0 = 1) ++ (h_finite_zeros : (zerosetKfR R1 (by linarith) f).Finite) ++ (h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) f, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, f z = (z - σ) ^ (analyticOrderAt f σ).toNat * h_σ σ z) ++ (h_f_bounded : ∀ z ∈ Metric.closedBall (0 : ℂ) R, ‖f z‖ ≤ B) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) r1 \ zerosetKfR R1 (by linarith) f, ++ ‖(deriv f z / f z) - ∑ ρ ∈ h_finite_zeros.toFinset, ++ (analyticOrderAt f ρ).toNat / (z - ρ)‖ ≤ ++ (16 * r^2 / ((r - r1)^3) + ++ 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * Real.log B := by ++ intro z hz ++ ++ have h_bound : ‖(deriv f z / f z) - ∑ ρ ∈ h_finite_zeros.toFinset, (analyticOrderAt f ρ).toNat / (z - ρ)‖ ≤ ++ 16 * r^2 / ((r - r1)^3) * Real.log B + 1 / ((R^2 / R1 - R1) * Real.log (R / R1)) * Real.log B := by ++ apply final_inequality <;> assumption ++ ++ rw [← add_mul] at h_bound ++ exact h_bound ++ ++end Erdos970 +diff --git a/StrongPNT/Erdos970/PNT3_RiemannZeta.lean b/StrongPNT/Erdos970/PNT3_RiemannZeta.lean +new file mode 100644 +index 0000000..0ab91b1 +--- /dev/null ++++ b/StrongPNT/Erdos970/PNT3_RiemannZeta.lean +@@ -0,0 +1,4546 @@ ++import StrongPNT.Erdos970.PNT2_LogDerivative ++ ++namespace Erdos970 ++ ++ ++open scoped BigOperators Topology ++abbrev ℙ := Nat.Primes ++ ++lemma p_s_abs_1 (p : ℙ) (s : ℂ) (hs : 1 < s.re) : norm (((p : ℕ) : ℂ) ^ (-s : ℂ)) < 1 := by ++ ++ have hx1 : 1 < ((p : ℕ) : ℝ) := by ++ have h2 : (2 : ℝ) ≤ ((p : ℕ) : ℝ) := by ++ exact_mod_cast (p.2.two_le : 2 ≤ (p : ℕ)) ++ exact lt_of_lt_of_le one_lt_two h2 ++ have hx0 : 0 < ((p : ℕ) : ℝ) := lt_trans zero_lt_one hx1 ++ ++ have hnorm_eq : ‖(((p : ℕ) : ℂ) ^ (-s : ℂ))‖ = ((p : ℕ) : ℝ) ^ ((-s : ℂ).re) := by ++ simpa using (Complex.norm_cpow_eq_rpow_re_of_pos hx0 (-s : ℂ)) ++ ++ have hz : ((-s : ℂ).re) < 0 := by ++ have h0 : 0 < s.re := lt_trans zero_lt_one hs ++ have : -s.re < 0 := neg_lt_zero.mpr h0 ++ simpa using this ++ ++ have hlt : ((p : ℕ) : ℝ) ^ ((-s : ℂ).re) < 1 := ++ Real.rpow_lt_one_of_one_lt_of_neg hx1 hz ++ ++ have : ‖(((p : ℕ) : ℂ) ^ (-s : ℂ))‖ < 1 := by simpa [hnorm_eq] using hlt ++ simpa [norm] using this ++ ++lemma zetaEulerprod (s : ℂ) (hs : 1 < s.re) : Multipliable (fun p : ℙ => (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) ∧ riemannZeta s = ∏' p : ℙ, (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹ := by ++ have hprod : HasProd (fun p : ℙ => (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) (riemannZeta s) := by ++ simpa using (riemannZeta_eulerProduct_hasProd (s := s) hs) ++ refine And.intro ?_ ?_ ++ · exact hprod.multipliable ++ · simpa using (hprod.tprod_eq.symm) ++ ++lemma abs_of_tprod {P : Type*} (w : P → ℂ) (hw : Multipliable w) : norm (∏' p : P, w p) = ∏' p : P, norm (w p) := by exact Multipliable.norm_tprod hw ++ ++lemma abs_P_prod (s : ℂ) (hs : 1 < s.re) : norm (∏' p : ℙ, (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) = ∏' p : ℙ, norm ((1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) := by ++ have hw : Multipliable (fun p : ℙ => (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) := (zetaEulerprod s hs).1 ++ simpa using abs_of_tprod (fun p : ℙ => (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) hw ++ ++lemma abs_zeta_prod (s : ℂ) (hs : 1 < s.re) : norm (riemannZeta s) = ∏' p : ℙ, norm ((1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) := by ++ rw [zetaEulerprod s hs |>.2, abs_P_prod s hs] ++ ++lemma abs_of_inv (z : ℂ) (_hz : z ≠ 0) : norm (z⁻¹) = (norm z)⁻¹ := norm_inv z ++ ++lemma one_minus_p_s_neq_0 (p : ℙ) (s : ℂ) (hs : 1 < s.re) : 1 - ((p : ℕ) : ℂ) ^ (-s : ℂ) ≠ 0 := by ++ intro h ++ have hz : ((p : ℕ) : ℂ) ^ (-s : ℂ) = 1 := by ++ simpa using (sub_eq_zero.mp h).symm ++ have : (1 : ℝ) < 1 := by ++ simpa [hz] using (p_s_abs_1 p s hs) ++ exact (lt_irrefl (1 : ℝ)) this ++ ++lemma abs_zeta_prod_prime (s : ℂ) (hs : 1 < s.re) : ++ norm (riemannZeta s) = ∏' p : ℙ, (norm (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ)))⁻¹ := by ++ rw [abs_zeta_prod s hs] ++ congr 1 ++ ext p ++ rw [abs_of_inv (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ)) (one_minus_p_s_neq_0 p s hs)] ++ ++lemma Re2s (s : ℂ) : (2 * s).re = 2 * s.re := by simp ++ ++lemma Re2sge1 (s : ℂ) (hs : 1 < s.re) : 1 < (2 * s).re := by ++ rw [Re2s] ++ linarith ++ ++lemma zeta_ratio_prod (s : ℂ) (hs : 1 < s.re) : riemannZeta (2 * s) / riemannZeta s = (∏' p : ℙ, (1 - ((p : ℕ) : ℂ) ^ (-(2 * s) : ℂ))⁻¹) / (∏' p : ℙ, (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) := by ++ have h2 := (zetaEulerprod (2 * s) (Re2sge1 s hs)).2 ++ have h1 := (zetaEulerprod s hs).2 ++ simp [h2, h1] ++ ++local notation "ι" => fun (z : ℂˣ) ↦ (z : ℂ) ++ ++theorem tprod_commutes_with_inclusion_infinite {α : Type*} (f : α → ℂˣ) (h : Multipliable f) : ++ ι (tprod f) = tprod (fun i ↦ ι (f i)) := ++by ++ change ((tprod f : ℂˣ) : ℂ) = tprod (fun i ↦ ((f i : ℂˣ) : ℂ)) ++ have hcont : Continuous (Units.coeHom ℂ) := by ++ simpa using! (Units.continuous_val : Continuous (fun u : ℂˣ => ((u : ℂˣ) : ℂ))) ++ simpa [Units.coeHom] using ++ (Multipliable.map_tprod (f := f) (γ := ℂ) h (g := Units.coeHom ℂ) hcont) ++ ++theorem inclusion_commutes_with_division (a b : ℂˣ) : ++ ι (a / b) = ι a / ι b := by ++ exact Units.val_div_eq_div_val a b ++ ++lemma lift_multipliable_of_nonzero {P : Type*} (a : P → ℂ) (ha : Multipliable a) (h_a_nonzero : ∀ p, a p ≠ 0) (hA_nonzero' : ∀ A, HasProd a A → A ≠ 0): ++ Multipliable (fun p ↦ Units.mk0 (a p) (h_a_nonzero p)) := by ++ ++ obtain ⟨A, hA⟩ := ha ++ have hA_nonzero := hA_nonzero' A hA ++ refine ⟨Units.mk0 A hA_nonzero, ?_⟩ ++ simp [HasProd, tendsto_nhds] at hA ⊢ ++ intro sU h_sU_open hA_mem ++ have hA_im_mem : ι (Units.mk0 A hA_nonzero) ∈ ι '' sU := Set.mem_image_of_mem ι hA_mem ++ have sU_im_open : IsOpen (ι '' sU) := by ++ apply (Topology.IsOpenEmbedding.isOpen_iff_image_isOpen ?_).mp ++ assumption ++ exact Units.isOpenEmbedding_val ++ have := hA (ι '' sU) sU_im_open hA_im_mem ++ obtain ⟨a1, ha⟩ := this ++ use a1 ++ intro b ha1 ++ obtain ⟨x', x'_spec_mem, x'_spec_eq⟩ := ha b ha1 ++ suffices x' = ∏ b ∈ b, Units.mk0 (a b) (by simp [*]) by ++ rwa [← this] ++ have : Units.mk0 (ι x') (Units.ne_zero x') = x' := ++ Units.mk0_val x' (Units.ne_zero x') ++ have this2 : (Units.mk0 (∏ b ∈ b, a b) ++ (Finset.prod_ne_zero_iff.mpr fun a a_1 => h_a_nonzero a)) = x' := ++ Units.ext (id (Eq.symm x'_spec_eq)) ++ rw [Units.mk0_prod] at this2 ++ rw [←this2] ++ conv => ++ rhs ++ rw [← Finset.prod_attach] ++ ++lemma prod_of_ratios_simplified {P : Type*} (a b : P → ℂ) ++(ha : Multipliable a) (hb : Multipliable b) ++ (h_a_nonzero : ∀ p, a p ≠ 0) (h_b_nonzero : ∀ p, b p ≠ 0) (hA_nonzero' : ∀ A, HasProd a A → A ≠ 0) (hB_nonzero' : ∀ A, HasProd b A → A ≠ 0): ++ (∏' p : P, a p) / (∏' p : P, b p) = ∏' p : P, (a p / b p) := by ++ ++ let a' : P → ℂˣ := fun p ↦ Units.mk0 (a p) (h_a_nonzero p) ++ let b' : P → ℂˣ := fun p ↦ Units.mk0 (b p) (h_b_nonzero p) ++ ++ have h_multipliable_a' : Multipliable a' := lift_multipliable_of_nonzero a ha h_a_nonzero hA_nonzero' ++ have h_multipliable_b' : Multipliable b' := lift_multipliable_of_nonzero b hb h_b_nonzero hB_nonzero' ++ have h_multipliable_a'_div_b' : Multipliable (fun p ↦ a' p / b' p) := Multipliable.div h_multipliable_a' h_multipliable_b' ++ ++ calc ++ (∏' p, a p) / (∏' p, b p) ++ ++ _ = (∏' p, ι (a' p)) / (∏' p, ι (b' p)) := by simp [a', b'] ++ ++ _ = ι (∏' p, a' p) / ι (∏' p, b' p) := by simp [tprod_commutes_with_inclusion_infinite, *] ++ ++ _ = ι ((∏' p, a' p) / (∏' p, b' p)) := by rw [← inclusion_commutes_with_division] ++ ++ _ = ι (∏' p, a' p / b' p) := by simp [Multipliable.tprod_div, *] ++ ++ _ = ∏' p, ι (a' p / b' p) := by simp [tprod_commutes_with_inclusion_infinite, *] ++ ++ _ = ∏' p, (ι (a' p) / ι (b' p)) := by simp ++ ++ _ = ∏' p, a p / b p := by simp [a', b'] ++ ++lemma prod_of_ratios {P : Type*} (a b : P → ℂ) (ha : Multipliable a) (hb : Multipliable b) (h_b_nonzero : ∀ p, b p ≠ 0) (hA_nonzero' : ∀ A, HasProd a A → A ≠ 0) (hB_nonzero' : ∀ B, HasProd b B → B ≠ 0): ++ (∏' p : P, a p) / (∏' p : P, b p) = ∏' p : P, (a p / b p) := by ++ ++ by_cases h_a_zero : ∃ p, a p = 0 ++ case pos => ++ ++ have lhs_zero : ∏' p : P, a p = 0 := by ++ ++ exact tprod_of_exists_eq_zero h_a_zero ++ have rhs_zero : ∏' p : P, (a p / b p) = 0 := by ++ ++ obtain ⟨p₀, hp₀⟩ := h_a_zero ++ have h_div_zero : ∃ p, (a p / b p) = 0 := by ++ use p₀ ++ simp [hp₀] ++ exact tprod_of_exists_eq_zero h_div_zero ++ simp [lhs_zero, rhs_zero] ++ case neg => ++ ++ push Not at h_a_zero ++ ++ exact prod_of_ratios_simplified a b ha hb h_a_zero h_b_nonzero hA_nonzero' hB_nonzero' ++ ++lemma simplify_prod_ratio (s : ℂ) (hs : 1 < s.re) : (∏' p : ℙ, (1 - (p : ℂ) ^ (-(2 * s) : ℂ))⁻¹) / (∏' p : ℙ, (1 - (p : ℂ) ^ (-s : ℂ))⁻¹) = ∏' p : ℙ, ((1 - (p : ℂ) ^ (-(2 * s) : ℂ))⁻¹ / (1 - (p : ℂ) ^ (-s : ℂ))⁻¹) := by ++ ++ let a := fun p : ℙ => (1 - (p : ℂ) ^ (-(2 * s) : ℂ))⁻¹ ++ let b := fun p : ℙ => (1 - (p : ℂ) ^ (-s : ℂ))⁻¹ ++ ++ have ha : Multipliable a := (zetaEulerprod (2 * s) (Re2sge1 s hs)).1 ++ have hb : Multipliable b := (zetaEulerprod s hs).1 ++ ++ have h_b_nonzero : ∀ p, b p ≠ 0 := by ++ intro p ++ exact inv_ne_zero (one_minus_p_s_neq_0 p s hs) ++ ++ exact prod_of_ratios a b ha hb h_b_nonzero (by ++ intro A hA ++ ++ have h_eq : A = riemannZeta (2 * s) := by ++ have h : HasProd a (riemannZeta (2 * s)) := by ++ simpa [a] using riemannZeta_eulerProduct_hasProd (s := 2 * s) (by simp; linarith) ++ exact HasProd.unique hA h ++ rw [h_eq] ++ exact riemannZeta_ne_zero_of_one_lt_re (by simp; linarith) ++ ) (by ++ intro B hB ++ ++ have h_eq : B = riemannZeta s := by ++ have h : HasProd b (riemannZeta s) := by ++ simpa [b] using riemannZeta_eulerProduct_hasProd (s := s) hs ++ exact HasProd.unique hB h ++ rw [h_eq] ++ exact riemannZeta_ne_zero_of_one_lt_re hs ++ ) ++ ++lemma zeta_ratios (s : ℂ) (hs : 1 < s.re) : riemannZeta (2 * s) / riemannZeta s = ∏' p : ℙ, ((1 - ((p : ℕ) : ℂ) ^ (-(2 * s) : ℂ))⁻¹ / (1 - ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹) := by ++ have h1 := zeta_ratio_prod s hs ++ have h2 := simplify_prod_ratio s hs ++ exact h1.trans h2 ++ ++lemma diff_of_squares (z : ℂ) : 1 - z^2 = (1 - z) * (1 + z) := by ring ++ ++lemma one_sub_ne_zero_of_abs_lt_one (z : ℂ) (hz : norm z < 1) : 1 - z ≠ 0 := by ++ intro h ++ have h1 : 1 = z := by ++ have := congrArg (fun w : ℂ => w + z) h ++ simpa [sub_add_cancel, zero_add] using this ++ have habs1lt : norm (1 : ℂ) < 1 := by simpa [h1] using hz ++ have hnorm1lt : ‖(1 : ℂ)‖ < 1 := by simp [norm] at habs1lt ++ have : (1 : ℝ) < 1 := by simp [norm_one] at hnorm1lt ++ exact (lt_irrefl _) this ++ ++lemma one_add_ne_zero_of_abs_lt_one (z : ℂ) (hz : norm z < 1) : 1 + z ≠ 0 := by ++ have hz' : norm (-z) < 1 := by ++ simpa [norm, norm_neg] using hz ++ simpa [sub_eq_add_neg] using one_sub_ne_zero_of_abs_lt_one (-z) hz' ++ ++lemma inv_mul_div_cancel_right_of_ne_zero (a b : ℂ) (ha : a ≠ 0) : ((a * b)⁻¹) / a⁻¹ = b⁻¹ := by ++ simp [div_eq_mul_inv, inv_inv, mul_inv_rev, mul_comm, ha] ++ ++lemma ratio_invs (z : ℂ) (hz : norm z < 1) : (1 - z^2)⁻¹ / (1 - z)⁻¹ = (1 + z)⁻¹ := by ++ have hz1 : 1 - z ≠ 0 := one_sub_ne_zero_of_abs_lt_one z hz ++ simpa [diff_of_squares z] using ++ inv_mul_div_cancel_right_of_ne_zero (1 - z) (1 + z) hz1 ++ ++lemma complex_cpow_neg_two_mul (z w : ℂ) (_hz : z ≠ 0) : z^(-(2*w)) = (z^(-w))^2 := by ++ have h1 : -(2*w) = 2*(-w) := by ring ++ rw [h1] ++ have h2 : (2 : ℂ)*(-w) = ((2 : ℕ) : ℂ)*(-w) := by norm_cast ++ rw [h2, Complex.cpow_nat_mul] ++ ++theorem zeta_ratio_identity (s : ℂ) (hs : 1 < s.re) : riemannZeta (2 * s) / riemannZeta s = ∏' p : ℙ, (1 + ((p : ℕ) : ℂ) ^ (-s : ℂ))⁻¹ := by ++ rw [zeta_ratios s hs]; congr 1; ext p ++ have hp : ((p : ℕ) : ℂ) ≠ 0 := by rw [ne_eq, Nat.cast_eq_zero]; exact Nat.Prime.ne_zero p.2 ++ have h1 : ((p : ℕ) : ℂ) ^ (-(2 * s)) = (((p : ℕ) : ℂ) ^ (-s))^2 := complex_cpow_neg_two_mul ((p : ℕ) : ℂ) s hp ++ have h2 : norm (((p : ℕ) : ℂ) ^ (-s)) < 1 := p_s_abs_1 p s hs ++ rw [h1]; exact ratio_invs (((p : ℕ) : ℂ) ^ (-s)) h2 ++ ++lemma two_mul_ofReal_div_two (r : ℝ) : (2 : ℂ) * ((r : ℝ) / 2 : ℂ) = (r : ℂ) := by ++ have hreal : (2 : ℝ) * (r / 2) = r := by ++ calc ++ (2 : ℝ) * (r / 2) = (2 : ℝ) * r / 2 := by ++ have h : (2 : ℝ) * r / 2 = (2 : ℝ) * (r / 2) := by ++ simpa using (mul_div_assoc (2 : ℝ) r (2 : ℝ)) ++ simpa using h.symm ++ _ = r := by ++ simp ++ calc ++ (2 : ℂ) * ((r : ℝ) / 2 : ℂ) ++ = ((2 * (r / 2) : ℝ) : ℂ) := by ++ simp ++ _ = (r : ℂ) := by simp [hreal] ++ ++lemma zeta_ratio_identity_ofReal_div_two (r : ℝ) (hr : 1 < ( ((r : ℝ) / 2 : ℂ) ).re) : riemannZeta (r : ℂ) / riemannZeta ((r / 2 : ℝ) : ℂ) = ∏' p : ℙ, (1 + ((p : ℕ) : ℂ) ^ (-(((r : ℝ) / 2) : ℂ)))⁻¹ := by ++ have h := zeta_ratio_identity (((r : ℝ) / 2 : ℂ)) hr ++ simpa [two_mul_ofReal_div_two r] using h ++ ++lemma zeta_ratio_at_3_2 : riemannZeta 3 / riemannZeta ((3 : ℝ) / 2) = ∏' p : ℙ, (1 + ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) : ℂ)))⁻¹ := by ++ have hr : 1 < (((3 : ℝ) / 2 : ℂ)).re := by ++ simpa using (by norm_num : (1 : ℝ) < (3 : ℝ) / 2) ++ simpa using zeta_ratio_identity_ofReal_div_two (3 : ℝ) hr ++ ++lemma triangle_inequality_specific (z : ℂ) : norm (1 - z) ≤ 1 + norm z := by ++ simpa [sub_eq_add_neg, norm_one, norm_neg] using (norm_add_le (1 : ℂ) (-z)) ++ ++lemma re_neg_eq_neg_re (s : ℂ) : (-s).re = - s.re := by ++ simp ++ ++lemma abs_cpow_eq_rpow_re_of_pos {x : ℝ} (hx : 0 < x) (y : ℂ) : norm ((x : ℂ) ^ y) = x ^ y.re := by ++ simpa using Complex.norm_cpow_eq_rpow_re_of_pos hx y ++ ++lemma abs_p_pow_s (p : ℙ) (s : ℂ) : norm (((p : ℕ) : ℂ) ^ (-s : ℂ)) = ((p : ℕ) : ℝ) ^ (-s.re : ℝ) := by ++ have hx : 0 < ((p : ℕ) : ℝ) := by ++ exact_mod_cast (p.property.pos : 0 < (p : ℕ)) ++ simpa [Complex.ofReal_natCast, re_neg_eq_neg_re] using ++ (abs_cpow_eq_rpow_re_of_pos hx (-s)) ++ ++lemma abs_term_bound (p : ℙ) (t : ℝ) : ++ norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))) ≤ 1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)) := by ++ ++ have h1 := triangle_inequality_specific (((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))) ++ ++ have h2 := abs_p_pow_s p (((3 : ℝ) / 2) + t * Complex.I) ++ ++ have h3 : (((3 : ℝ) / 2) + t * Complex.I).re = ((3 : ℝ) / 2) := by simp [Complex.add_re, Complex.ofReal_re] ++ ++ have h4 : -(((3 : ℝ) / 2) + t * Complex.I).re = -((3 : ℝ) / 2) := by rw [h3] ++ ++ have h5 : norm (((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))) = ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)) := by ++ rw [h2, h4] ++ ++ rw [h5] at h1 ++ exact h1 ++ ++lemma inv_inequality {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) : b⁻¹ ≤ a⁻¹ := by ++ simpa [one_div] using (one_div_le_one_div_of_le ha hab) ++ ++lemma eq_of_one_sub_eq_zero (z : ℂ) (h : 1 - z = 0) : z = 1 := by ++ rw [sub_eq_zero] at h ++ exact h.symm ++ ++lemma condp32 (p : ℙ) (t : ℝ) : 1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I)) ≠ 0 := by ++ intro h ++ have hp_eq_one : ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I)) = 1 := eq_of_one_sub_eq_zero _ h ++ let s := ((3 : ℝ) / 2) + t * Complex.I ++ have hs : 1 < s.re := by ++ simp only [s, Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.I_im, mul_zero] ++ norm_num ++ have h_abs_lt : norm (((p : ℕ) : ℂ) ^ (-s)) < 1 := p_s_abs_1 p s hs ++ have h_s_eq : ((p : ℕ) : ℂ) ^ (-s) = ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I)) := by simp only [s] ++ rw [h_s_eq, hp_eq_one] at h_abs_lt ++ have : norm (1 : ℂ) = 1 := by simp [norm] ++ rw [this] at h_abs_lt ++ exact lt_irrefl 1 h_abs_lt ++ ++lemma abs_term_inv_bound (p : ℙ) (t : ℝ) : (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ ≤ (norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))))⁻¹ := by ++ have h1 := abs_term_bound p t ++ have h2 := condp32 p t ++ have h3 := lem_abspos _ h2 ++ exact inv_inequality h3 h1 ++ ++open NNReal in ++lemma prod_inequality {P : Type*} (a b : P → ℝ≥0) (ha : Multipliable a) (hb : Multipliable b) ++ (hab : ∀ p : P, a p ≤ b p) : ++ ∏' p : P, a p ≤ ∏' p : P, b p := by ++ exact Multipliable.tprod_le_tprod hab ha hb ++ ++lemma multipliable_complex_abs_inv {i : Type*} (g : i → ℂ) (h_mult : Multipliable (fun i => (1 - g i)⁻¹)) (_h_nonzero : ∀ i, 1 - g i ≠ 0) : Multipliable (fun i => (norm (1 - g i))⁻¹) := by ++ ++ have h_eq : (fun i => (norm (1 - g i))⁻¹) = (fun i => ‖1 - g i‖⁻¹) := by ++ ext i ++ simp ++ rw [h_eq] ++ ++ have h_norm_mult : Multipliable (fun i => ‖(1 - g i)⁻¹‖) := Multipliable.norm h_mult ++ have h_norm_eq : (fun i => ‖(1 - g i)⁻¹‖) = (fun i => ‖1 - g i‖⁻¹) := by ++ ext i ++ rw [norm_inv] ++ rwa [← h_norm_eq] ++ ++lemma multipliable_positive_inv_powers (r : ℝ) (hr : 1 < r) : Multipliable (fun p : ℙ => (1 + ((p : ℕ) : ℝ) ^ (-r))⁻¹) := by ++ ++ have h_sum : Summable (fun p : ℙ => ((p : ℕ) : ℝ) ^ (-r)) := by ++ rw [Nat.Primes.summable_rpow] ++ linarith ++ ++ have h_log_sum : Summable (fun p : ℙ => Real.log (1 + ((p : ℕ) : ℝ) ^ (-r))) := by ++ exact Real.summable_log_one_add_of_summable h_sum ++ ++ have h_log_inv_sum : Summable (fun p : ℙ => Real.log ((1 + ((p : ℕ) : ℝ) ^ (-r))⁻¹)) := by ++ have h_eq : (fun p : ℙ => Real.log ((1 + ((p : ℕ) : ℝ) ^ (-r))⁻¹)) = ++ (fun p : ℙ => -(Real.log (1 + ((p : ℕ) : ℝ) ^ (-r)))) := by ++ ext p ++ rw [Real.log_inv] ++ rw [h_eq] ++ exact Summable.neg h_log_sum ++ ++ have h_pos : ∀ p : ℙ, 0 < (1 + ((p : ℕ) : ℝ) ^ (-r))⁻¹ := by ++ intro p ++ apply inv_pos.mpr ++ have h_ge : 0 ≤ ((p : ℕ) : ℝ) ^ (-r) := Real.rpow_nonneg (Nat.cast_nonneg _) _ ++ linarith ++ ++ exact Real.multipliable_of_summable_log h_pos h_log_inv_sum ++ ++lemma hasProd_map_nnreal_coe {i : Type*} (f : i → NNReal) (a : NNReal) (h : HasProd f a) : HasProd (fun i => (f i : ℝ)) ((a : NNReal) : ℝ) := by ++ have hcont : Continuous (⇑NNReal.toRealHom) := by ++ rw [NNReal.coe_toRealHom] ++ exact NNReal.continuous_coe ++ exact HasProd.map h NNReal.toRealHom hcont ++ ++lemma multipliable_nnreal_coe {i : Type*} (f : i → NNReal) (hf : Multipliable f) : Multipliable (fun i => (f i : ℝ)) := by ++ ++ obtain ⟨a, ha⟩ := hf ++ ++ have h_coe := hasProd_map_nnreal_coe f a ha ++ ++ exact ⟨(a : ℝ), h_coe⟩ ++ ++lemma nnreal_coe_tprod_eq {i : Type*} (f : i → NNReal) (_hf : Multipliable f) : (∏' i : i, f i : ℝ) = ∏' i : i, (f i : ℝ) := by ++ rfl ++ ++lemma hasProd_nonneg_of_pos {i : Type*} (f : i → ℝ) (hpos : ∀ i, 0 < f i) (a : ℝ) (ha : HasProd f a) : 0 ≤ a := by ++ ++ have h_pos : ∀ s : Finset i, 0 < ∏ i ∈ s, f i := fun s => Finset.prod_pos (fun i _ => hpos i) ++ ++ have h_nonneg : ∀ s : Finset i, 0 ≤ ∏ i ∈ s, f i := fun s => le_of_lt (h_pos s) ++ ++ exact ge_of_tendsto ha (Filter.Eventually.of_forall h_nonneg) ++ ++lemma tendsto_finprod_coe_iff_tendsto_coe_finprod {i : Type*} (f : i → NNReal) (a : NNReal) : ++ Filter.Tendsto (fun s => ∏ i ∈ s, (f i : ℝ)) Filter.atTop (𝓝 (a : ℝ)) ↔ ++ Filter.Tendsto ((fun x : NNReal => (x : ℝ)) ∘ (fun s => ∏ i ∈ s, f i)) Filter.atTop (𝓝 (a : ℝ)) := by ++ ++ have h_comp : ((fun x : NNReal => (x : ℝ)) ∘ (fun s => ∏ i ∈ s, f i)) = (fun s => ↑(∏ i ∈ s, f i)) := by ++ rfl ++ ++ have h_eq : (fun s => ∏ i ∈ s, (f i : ℝ)) = (fun s => ↑(∏ i ∈ s, f i)) := by ++ ext s ++ exact (NNReal.coe_prod s f).symm ++ ++ rw [h_comp, ← h_eq] ++ ++lemma pnt_nnreal_isEmbedding_coe : Topology.IsEmbedding (fun x : NNReal => (x : ℝ)) := by ++ refine ⟨?_, NNReal.coe_injective⟩ ++ ++ exact Topology.IsInducing.subtypeVal ++ ++lemma HasProd.of_coe_hasProd {i : Type*} (f : i → NNReal) (a : NNReal) (h : HasProd (fun i => (f i : ℝ)) (a : ℝ)) : HasProd f a := by ++ ++ have h_comp : Filter.Tendsto ((fun x : NNReal => (x : ℝ)) ∘ (fun s => ∏ i ∈ s, f i)) Filter.atTop (𝓝 (a : ℝ)) := by ++ rw [← tendsto_finprod_coe_iff_tendsto_coe_finprod] ++ exact h ++ ++ have h_embed : Topology.IsEmbedding (fun x : NNReal => (x : ℝ)) := pnt_nnreal_isEmbedding_coe ++ ++ exact h_embed.tendsto_nhds_iff.mpr h_comp ++ ++lemma hasProd_nnreal_of_coe {i : Type*} (g : i → NNReal) (b : NNReal) (h : HasProd (fun i => (g i : ℝ)) (b : ℝ)) : HasProd g b := by ++ exact HasProd.of_coe_hasProd g b h ++ ++lemma multipliable_real_to_nnreal {i : Type*} (f : i → ℝ) (hpos : ∀ i, 0 < f i) (h_mult : Multipliable f) : Multipliable (fun i => ⟨f i, le_of_lt (hpos i)⟩ : i → NNReal) := by ++ ++ obtain ⟨a, ha⟩ := h_mult ++ ++ have ha_nonneg : 0 ≤ a := hasProd_nonneg_of_pos f hpos a ha ++ ++ let a_nnreal : NNReal := ⟨a, ha_nonneg⟩ ++ ++ have h_coe_eq : (fun i => ((⟨f i, le_of_lt (hpos i)⟩ : NNReal) : ℝ)) = f := by ++ ext i ++ rfl ++ ++ have ha_coe : HasProd (fun i => ((⟨f i, le_of_lt (hpos i)⟩ : NNReal) : ℝ)) (a_nnreal : ℝ) := by ++ rw [h_coe_eq] ++ simp only [a_nnreal] ++ exact ha ++ ++ have ha_nnreal : HasProd (fun i => ⟨f i, le_of_lt (hpos i)⟩) a_nnreal := ++ hasProd_nnreal_of_coe (fun i => ⟨f i, le_of_lt (hpos i)⟩) a_nnreal ha_coe ++ ++ exact ⟨a_nnreal, ha_nnreal⟩ ++ ++lemma nnreal_coe_tprod_eq_tprod_coe {i : Type*} (f : i → NNReal) (hf : Multipliable f) : ++ ∏' i, (↑(f i) : ℝ) = ↑(∏' i, f i) := by ++ ++ have h_prod : HasProd f (∏' i, f i) := Multipliable.hasProd hf ++ ++ have h_map : HasProd (NNReal.toRealHom ∘ f) (NNReal.toRealHom (∏' i, f i)) := ++ HasProd.map h_prod NNReal.toRealHom NNReal.continuous_coe ++ ++ have h_comp : NNReal.toRealHom ∘ f = fun i => (↑(f i) : ℝ) := by ++ ext i ++ rfl ++ have h_val : NNReal.toRealHom (∏' i, f i) = ↑(∏' i, f i) := rfl ++ ++ rw [h_comp, h_val] at h_map ++ ++ exact HasProd.tprod_eq h_map ++ ++lemma nnreal_tprod_le_coe {i : Type*} (f g : i → NNReal) (hf : Multipliable f) (hg : Multipliable g) (h : ∏' i, f i ≤ ∏' i, g i) : ∏' i, (f i : ℝ) ≤ ∏' i, (g i : ℝ) := by ++ ++ rw [nnreal_coe_tprod_eq_tprod_coe f hf, nnreal_coe_tprod_eq_tprod_coe g hg] ++ ++ exact NNReal.coe_le_coe.mpr h ++ ++lemma abs_zeta_inequality (t : ℝ) : ++ ∏' p : ℙ, (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ ≤ ++ ∏' p : ℙ, (norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))))⁻¹ := by ++ ++ have h_pos_left : ∀ p : ℙ, 0 < (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ := by ++ intro p ++ apply inv_pos.mpr ++ apply add_pos zero_lt_one ++ ++ apply Real.rpow_pos_of_pos ++ exact_mod_cast (p.property.pos : 0 < (p : ℕ)) ++ ++ have h_pos_right : ∀ p : ℙ, 0 < (norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))))⁻¹ := by ++ intro p ++ apply inv_pos.mpr ++ ++ rw [norm_pos_iff] ++ exact condp32 p t ++ ++ have h_mult_left : Multipliable (fun p : ℙ => (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹) := ++ multipliable_positive_inv_powers ((3 : ℝ) / 2) (by norm_num : 1 < (3 : ℝ) / 2) ++ ++ have h_mult_right : Multipliable (fun p : ℙ => (norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))))⁻¹) := by ++ let s := ((3 : ℝ) / 2) + t * Complex.I ++ have hs : 1 < s.re := by ++ simp only [s, Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re, mul_zero] ++ norm_num ++ ++ have h_euler := (zetaEulerprod s hs).1 ++ have h_nonzero : ∀ p : ℙ, 1 - ((p : ℕ) : ℂ) ^ (-s) ≠ 0 := fun p => condp32 p t ++ exact multipliable_complex_abs_inv (fun p : ℙ => ((p : ℕ) : ℂ) ^ (-s)) h_euler h_nonzero ++ ++ let f : ℙ → NNReal := fun p => ⟨(1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹, le_of_lt (h_pos_left p)⟩ ++ let g : ℙ → NNReal := fun p => ⟨(norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))))⁻¹, le_of_lt (h_pos_right p)⟩ ++ ++ have hf : Multipliable f := multipliable_real_to_nnreal _ h_pos_left h_mult_left ++ have hg : Multipliable g := multipliable_real_to_nnreal _ h_pos_right h_mult_right ++ ++ have h_pointwise : ∀ p : ℙ, f p ≤ g p := by ++ intro p ++ simp only [f, g] ++ exact abs_term_inv_bound p t ++ ++ have h_nnreal_ineq : ∏' p, f p ≤ ∏' p, g p := prod_inequality f g hf hg h_pointwise ++ ++ have h_convert : ∏' p, (f p : ℝ) ≤ ∏' p, (g p : ℝ) := nnreal_tprod_le_coe f g hf hg h_nnreal_ineq ++ ++ have h_eq_f : ∏' p, (f p : ℝ) = ∏' p : ℙ, (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ := by ++ rfl ++ ++ have h_eq_g : ∏' p, (g p : ℝ) = ∏' p : ℙ, (norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))))⁻¹ := by ++ rfl ++ ++ rw [h_eq_f, h_eq_g] at h_convert ++ exact h_convert ++ ++lemma abs_zeta_ratio_eval : norm (riemannZeta 3 / riemannZeta ((3 : ℝ) / 2)) = ∏' p : ℙ, (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ := by ++ ++ have hratio := zeta_ratio_at_3_2 ++ ++ let w : ℙ → ℂ := fun p => (1 + ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) : ℂ)))⁻¹ ++ let u : ℙ → ℝ := fun p => (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ ++ ++ have hu_mult : Multipliable u := ++ multipliable_positive_inv_powers ((3 : ℝ) / 2) (by norm_num : 1 < (3 : ℝ) / 2) ++ ++ have hw_eq : w = fun p : ℙ => (u p : ℂ) := by ++ funext p ++ ++ have hx : 0 ≤ ((p : ℕ) : ℝ) := by exact_mod_cast (Nat.zero_le (p : ℕ)) ++ have hcpow : (((((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2))) : ℝ) : ℂ) ++ = ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) : ℂ)) := by ++ simpa using (Complex.ofReal_cpow (x := ((p : ℕ) : ℝ)) (hx := hx) (y := -((3 : ℝ) / 2))) ++ calc ++ w p = (1 + ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) : ℂ)))⁻¹ := rfl ++ _ = (1 + (((((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2))) : ℝ) : ℂ))⁻¹ := by ++ simp [hcpow] ++ _ = (((1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ : ℝ) : ℂ) := by ++ simp [Complex.ofReal_add, Complex.ofReal_inv, Complex.ofReal_one] ++ ++ have hw_mult : Multipliable w := by ++ have hmap : Multipliable ((fun x : ℝ => (x : ℂ)) ∘ u) := ++ Multipliable.map (hf := hu_mult) Complex.ofRealHom Complex.continuous_ofReal ++ simpa [hw_eq] using! hmap ++ ++ have h_abs_tprod : norm (∏' p : ℙ, w p) = ∏' p : ℙ, norm (w p) := ++ abs_of_tprod w hw_mult ++ ++ have h_abs_eq_fun : (fun p : ℙ => norm (w p)) = u := by ++ funext p ++ ++ have hge : 0 ≤ ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)) := ++ Real.rpow_nonneg (by exact_mod_cast (Nat.zero_le (p : ℕ))) _ ++ have hpos : 0 < 1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)) := by linarith ++ have hnonneg : 0 ≤ u p := by ++ have : 0 < (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ := inv_pos.mpr hpos ++ exact this.le ++ ++ simp [hw_eq, Complex.norm_real, abs_of_nonneg hnonneg] ++ ++ have h_abs_ratio : norm (riemannZeta 3 / riemannZeta ((3 : ℝ) / 2)) ++ = norm (∏' p : ℙ, w p) := by ++ simpa [w] using congrArg norm hratio ++ calc ++ norm (riemannZeta 3 / riemannZeta ((3 : ℝ) / 2)) ++ = norm (∏' p : ℙ, w p) := h_abs_ratio ++ _ = ∏' p : ℙ, norm (w p) := h_abs_tprod ++ _ = ∏' p : ℙ, u p := by simp [h_abs_eq_fun] ++ _ = ∏' p : ℙ, (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ := rfl ++ ++theorem zeta_lower_bound (t : ℝ) : ++ norm (riemannZeta 3 / riemannZeta ((3 : ℝ) / 2)) ≤ ++ norm (riemannZeta (((3 : ℝ) / 2) + t * Complex.I)) := by ++ have hs : 1 < (((3 : ℝ) / 2 : ℂ) + t * Complex.I).re := by ++ simp only [Complex.add_re, Complex.mul_I_re] ++ norm_num ++ calc ++ norm (riemannZeta 3 / riemannZeta ((3 : ℝ) / 2)) ++ = ∏' p : ℙ, (1 + ((p : ℕ) : ℝ) ^ (-((3 : ℝ) / 2)))⁻¹ := abs_zeta_ratio_eval ++ _ ≤ ∏' p : ℙ, (norm (1 - ((p : ℕ) : ℂ) ^ (-(((3 : ℝ) / 2) + t * Complex.I))))⁻¹ := ++ abs_zeta_inequality t ++ _ = norm (riemannZeta (((3 : ℝ) / 2 : ℂ) + t * Complex.I)) := by ++ simpa using (abs_zeta_prod_prime (((3 : ℝ) / 2 : ℂ) + t * Complex.I) hs).symm ++ ++lemma summable_one_div_nat_add_rpow' {x : ℝ} (hx : 1 < x) : Summable (fun n : ℕ => 1 / ((n + 1 : ℝ) ^ x)) := by ++ have h := (Real.summable_one_div_nat_add_rpow (1 : ℝ) x).2 hx ++ have h' : Summable (fun n : ℕ => (|((n : ℝ) + 1)| ^ x)⁻¹) := by ++ simpa [one_div] using h ++ have h2 : (fun n : ℕ => (|((n : ℝ) + 1)| ^ x)⁻¹) = (fun n : ℕ => (((n : ℝ) + 1) ^ x)⁻¹) := by ++ funext n ++ have hn : 0 ≤ (n : ℝ) + 1 := by ++ have : 0 ≤ (n : ℝ) := by exact_mod_cast (Nat.zero_le n) ++ exact add_nonneg this (show 0 ≤ (1 : ℝ) from zero_le_one) ++ simp [abs_of_nonneg hn] ++ have h'' : Summable (fun n : ℕ => (((n : ℝ) + 1) ^ x)⁻¹) := by ++ simpa [h2] using h' ++ have h''' : Summable (fun n : ℕ => ((n + 1 : ℝ) ^ x)⁻¹) := by ++ simpa [Nat.cast_add] using h'' ++ simpa [one_div] using h''' ++ ++lemma tsum_pos_of_pos_first_term {f : ℕ → ℝ} (hf : Summable f) (h0 : 0 < f 0) (hnonneg : ∀ n, 0 ≤ f n) : 0 < ∑' n, f n := by ++ have hsum0 : ∑ n ∈ Finset.range 1, f n = f 0 := by ++ simp ++ have hpos_partial : 0 < ∑ n ∈ Finset.range 1, f n := by ++ simpa [hsum0] using h0 ++ have hsumle : ∑ n ∈ Finset.range 1, f n ≤ ∑' n, f n := by ++ have hnonneg' : ∀ n ∉ Finset.range 1, 0 ≤ f n := by ++ intro n hn ++ exact hnonneg n ++ simpa using (hf.sum_le_tsum (s := Finset.range 1) hnonneg') ++ exact lt_of_lt_of_le hpos_partial hsumle ++ ++lemma first_term_pos (x : ℝ) : 0 < (1 : ℝ) / ((1 : ℝ) ^ x) := by ++ simp [Real.one_rpow] ++ ++lemma terms_nonneg (x : ℝ) : ∀ n : ℕ, 0 ≤ (1 : ℝ) / ((n + 1 : ℝ) ^ x) := by ++ intro n ++ have hposb' : 0 < ((n : ℝ) + 1) := ++ add_pos_of_nonneg_of_pos (show 0 ≤ (n : ℝ) from by exact_mod_cast (Nat.zero_le n)) zero_lt_one ++ have hposb : 0 < ((n + 1 : ℝ)) := by ++ simpa [Nat.cast_add, Nat.cast_one] using hposb' ++ have hdenpos : 0 < ((n + 1 : ℝ) ^ x) := by ++ simpa using (Real.rpow_pos_of_pos hposb x) ++ have hden_nonneg : 0 ≤ ((n + 1 : ℝ) ^ x) := le_of_lt hdenpos ++ have hnum_nonneg : 0 ≤ (1 : ℝ) := le_of_lt (zero_lt_one : 0 < (1 : ℝ)) ++ exact div_nonneg hnum_nonneg hden_nonneg ++ ++lemma term_eq_ofRealC (x : ℝ) (n : ℕ) : (1 / ((n + 1 : ℂ) ^ (x : ℂ))) = ((1 / ((n + 1 : ℝ) ^ x) : ℝ) : ℂ) := by ++ have hbase_nonneg : 0 ≤ (n + 1 : ℝ) := by ++ have hn : 0 ≤ (n : ℝ) := by exact_mod_cast (Nat.zero_le n) ++ have : 0 ≤ (n : ℝ) + 1 := add_nonneg hn (show 0 ≤ (1 : ℝ) from zero_le_one) ++ simpa [Nat.cast_add, Nat.cast_one] using this ++ have hpow' : ((n + 1 : ℂ) ^ (x : ℂ)) = (((n + 1 : ℝ) ^ x : ℝ) : ℂ) := by ++ simpa using (Complex.ofReal_cpow (x := (n + 1 : ℝ)) (hx := hbase_nonneg) (y := x)).symm ++ have hdiv : (1 : ℂ) / (((n + 1 : ℝ) ^ x : ℝ) : ℂ) = ((1 / ((n + 1 : ℝ) ^ x) : ℝ) : ℂ) := by ++ simp ++ calc ++ 1 / ((n + 1 : ℂ) ^ (x : ℂ)) ++ = (1 : ℂ) / (((n + 1 : ℝ) ^ x : ℝ) : ℂ) := by simp [hpow'] ++ _ = ((1 / ((n + 1 : ℝ) ^ x) : ℝ) : ℂ) := hdiv ++ ++lemma zeta_eq_ofReal (x : ℝ) (hx : 1 < x) : ++ riemannZeta x = ((∑' n : ℕ, ((1 : ℝ) / ((n + 1 : ℝ) ^ x))) : ℝ) := by ++ ++ have h1 : riemannZeta (x : ℂ) = ∑' n : ℕ, 1 / (n + 1 : ℂ) ^ (x : ℂ) := by ++ apply zeta_eq_tsum_one_div_nat_add_one_cpow ++ simpa using hx ++ ++ have h2 : ∀ n : ℕ, 1 / (n + 1 : ℂ) ^ (x : ℂ) = ((1 / ((n + 1 : ℝ) ^ x) : ℝ) : ℂ) := by ++ exact fun n => term_eq_ofRealC x n ++ ++ rw [h1] ++ simp_rw [h2] ++ ++ rw [← Complex.ofReal_tsum] ++ ++lemma term_inv_eq_ofRealC (x : ℝ) (n : ℕ) : ((n + 1 : ℂ) ^ (x : ℂ))⁻¹ = ((1 / ((n + 1 : ℝ) ^ x) : ℝ) : ℂ) := by ++ rw [inv_eq_one_div] ++ simpa using (term_eq_ofRealC x n) ++ ++lemma im_tsum_ofReal (g : ℕ → ℝ) : (∑' n : ℕ, (g n : ℂ)).im = 0 := by ++ have him := congrArg Complex.im (Complex.ofReal_tsum (L := SummationFilter.unconditional ℕ) (f := g)).symm ++ have hz : (((∑' n : ℕ, g n) : ℝ) : ℂ).im = 0 := by ++ simp ++ exact Eq.trans him hz ++ ++lemma re_tsum_ofReal (g : ℕ → ℝ) : (∑' n : ℕ, (g n : ℂ)).re = ∑' n : ℕ, g n := by ++ have h := congrArg Complex.re (Complex.ofReal_tsum (L := SummationFilter.unconditional ℕ) (f := g)).symm ++ simpa [Complex.ofReal_re] using h ++ ++lemma zetapos (x : ℝ) (hx : 1 < x) : (riemannZeta x).im = 0 ∧ 0 < (riemannZeta x).re := by ++ have hxC : 1 < (Complex.ofReal x).re := by simpa [Complex.ofReal_re] using hx ++ have hz : riemannZeta (x : ℂ) = ∑' n : ℕ, 1 / (n + 1 : ℂ) ^ (x : ℂ) := ++ zeta_eq_tsum_one_div_nat_add_one_cpow (s := (x : ℂ)) hxC ++ have him : (riemannZeta x).im = 0 := by ++ simpa [hz, term_eq_ofRealC x] using ++ (im_tsum_ofReal (fun n : ℕ => 1 / ((n + 1 : ℝ) ^ x))) ++ have hre : (riemannZeta x).re = ∑' n : ℕ, 1 / ((n + 1 : ℝ) ^ x) := by ++ simpa [hz, term_eq_ofRealC x] using ++ (re_tsum_ofReal (fun n : ℕ => 1 / ((n + 1 : ℝ) ^ x))) ++ have hsum : Summable (fun n : ℕ => 1 / ((n + 1 : ℝ) ^ x)) := ++ summable_one_div_nat_add_rpow' (x := x) hx ++ have hpos0 : 0 < 1 / ((Nat.cast 0 + 1 : ℝ) ^ x) := by ++ simp [zero_add] ++ have hnonneg : ∀ n : ℕ, 0 ≤ 1 / ((n + 1 : ℝ) ^ x) := terms_nonneg x ++ have hpos : 0 < ∑' n : ℕ, 1 / ((n + 1 : ℝ) ^ x) := ++ tsum_pos_of_pos_first_term hsum hpos0 hnonneg ++ exact ⟨him, by simpa [hre] using hpos⟩ ++ ++lemma zeta332pos : 0 < norm (riemannZeta 3 / riemannZeta ((3 : ℝ) / 2)) := by ++ have h3 : (1 : ℝ) < 3 := by norm_num ++ have h32 : (1 : ℝ) < (3 : ℝ) / 2 := by norm_num ++ obtain ⟨h3im, h3repos⟩ := zetapos 3 h3 ++ obtain ⟨h32im, h32repos⟩ := zetapos ((3 : ℝ) / 2) h32 ++ have h3ne : riemannZeta (3 : ℝ) ≠ 0 := by ++ intro hz ++ exact (ne_of_gt h3repos) (by simpa using congrArg Complex.re hz) ++ have h32ne : riemannZeta ((3 : ℝ) / 2) ≠ 0 := by ++ intro hz ++ exact (ne_of_gt h32repos) (by simpa using congrArg Complex.re hz) ++ have hdivne : riemannZeta (3 : ℝ) / riemannZeta ((3 : ℝ) / 2) ≠ 0 := ++ div_ne_zero h3ne h32ne ++ simpa using (norm_pos_iff.mpr hdivne) ++ ++lemma zeta_low_332 : ∃ a : ℝ, 0 < a ∧ ∀ t : ℝ, a ≤ norm (riemannZeta (((3 : ℝ) / 2) + t * Complex.I)) := by ++ use norm (riemannZeta 3 / riemannZeta ((3 : ℝ) / 2)) ++ exact ⟨zeta332pos, zeta_lower_bound⟩ ++ ++open Real _root_.Set Filter Topology MeasureTheory ++open scoped BigOperators Topology ++ ++lemma one_div_nat_cpow_eq_ite_cpow_neg (s : ℂ) (hs : s ≠ 0) (n : ℕ) : 1 / (n : ℂ) ^ s = if n = 0 then 0 else (n : ℂ) ^ (-s) := by ++ by_cases h : n = 0 ++ · simp [h, Complex.zero_cpow hs] ++ · have hcalc : 1 / (n : ℂ) ^ s = (n : ℂ) ^ (-s) := by ++ calc ++ 1 / (n : ℂ) ^ s = ((n : ℂ) ^ s)⁻¹ := by simp [one_div] ++ _ = (n : ℂ) ^ (-s) := by simpa using (Complex.cpow_neg (n : ℂ) s).symm ++ simpa [h] using hcalc ++ ++lemma lem_zetaLimit (s : ℂ) (hs : 1 < s.re) : riemannZeta s = ∑' n : ℕ, if n = 0 then 0 else (n : ℂ) ^ (-s) := by ++ classical ++ have hsne : s ≠ 0 := by ++ intro h ++ have hpos : 0 < s.re := lt_trans (show (0 : ℝ) < 1 from zero_lt_one) hs ++ have hne : s.re ≠ 0 := ne_of_gt hpos ++ simp [h] at hne ++ have hz : riemannZeta s = ∑' n : ℕ, 1 / (n : ℂ) ^ s := zeta_eq_tsum_one_div_nat_cpow (s := s) hs ++ simpa [one_div_nat_cpow_eq_ite_cpow_neg s hsne] using hz ++ ++noncomputable def zetaPartialSum (s : ℂ) (N : ℕ) : ℂ := ++ ∑ n ∈ Finset.range N, (n + 1 : ℂ) ^ (-s) ++ ++lemma sum_Icc1_eq_sum_range_succ (N : ℕ) (g : ℕ → ℂ) : ++ (∑ k ∈ Finset.Icc 1 N, g k) = ∑ n ∈ Finset.range N, g (n + 1) := by ++ classical ++ ++ symm ++ refine Finset.sum_bij (s := Finset.range N) (t := Finset.Icc 1 N) ++ (f := fun n => g (n + 1)) (g := fun k => g k) ++ (i := fun n (_hn : n ∈ Finset.range N) => n + 1) ++ ?hi ?hinj ?hsurj ?hcongr ++ · intro n hn ++ have hlt : n < N := Finset.mem_range.mp hn ++ have h1 : 1 ≤ n + 1 := Nat.succ_le_succ (Nat.zero_le n) ++ have h2 : n + 1 ≤ N := Nat.succ_le_of_lt hlt ++ exact (Finset.mem_Icc.mpr ⟨h1, h2⟩) ++ · intro a ha b hb h ++ ++ simpa using Nat.succ_injective h ++ · intro k hk ++ rcases Finset.mem_Icc.mp hk with ⟨hk1, hk2⟩ ++ refine ⟨k - 1, ?_, ?_⟩ ++ · ++ have hsucc : (k - 1) + 1 = k := Nat.sub_add_cancel hk1 ++ have hle : (k - 1) + 1 ≤ N := by simpa [hsucc] using hk2 ++ have hlt : k - 1 < N := lt_of_lt_of_le (Nat.lt_succ_self (k - 1)) hle ++ exact Finset.mem_range.mpr hlt ++ · ++ simp [Nat.sub_add_cancel hk1] ++ · intro n hn ++ rfl ++ ++lemma sum_Icc0_eq_sum_Icc1_of_zero (N : ℕ) (g : ℕ → ℂ) (h0 : g 0 = 0) : ++ (∑ k ∈ Finset.Icc 0 N, g k) = ∑ k ∈ Finset.Icc 1 N, g k := by ++ classical ++ have hdecomp : insert (0 : ℕ) (Finset.Icc 1 N) = Finset.Icc 0 N := by ++ simpa [Nat.succ_eq_add_one] using ++ (Finset.insert_Icc_succ_left_eq_Icc (a := 0) (b := N) (h := Nat.zero_le N)) ++ have hnotmem : (0 : ℕ) ∉ Finset.Icc 1 N := by ++ intro h ++ rcases Finset.mem_Icc.mp h with ⟨h1, _h2⟩ ++ have : ¬ (1 ≤ (0 : ℕ)) := by decide ++ exact this h1 ++ calc ++ (∑ k ∈ Finset.Icc 0 N, g k) ++ = ∑ k ∈ insert 0 (Finset.Icc 1 N), g k := by ++ simp [hdecomp] ++ _ = g 0 + ∑ k ∈ Finset.Icc 1 N, g k := by ++ simp ++ _ = ∑ k ∈ Finset.Icc 1 N, g k := by simp [h0] ++ ++lemma sum_Icc0_shifted_eq_sum_range (a : ℕ → ℂ) (m : ℕ) : ++ (∑ k ∈ Finset.Icc 0 m, (if k = 0 then 0 else a k)) = ∑ n ∈ Finset.range m, a (n + 1) := by ++ classical ++ calc ++ (∑ k ∈ Finset.Icc 0 m, (if k = 0 then 0 else a k)) ++ = ∑ k ∈ Finset.Icc 1 m, (if k = 0 then 0 else a k) := by ++ simpa using ++ (sum_Icc0_eq_sum_Icc1_of_zero (N := m) ++ (g := fun k => (if k = 0 then 0 else a k)) (h0 := by simp)) ++ _ = ∑ n ∈ Finset.range m, (if n + 1 = 0 then 0 else a (n + 1)) := by ++ simpa using ++ (sum_Icc1_eq_sum_range_succ (N := m) (g := fun k => (if k = 0 then 0 else a k))) ++ _ = ∑ n ∈ Finset.range m, a (n + 1) := by ++ apply Finset.sum_congr rfl ++ intro n hn ++ simp ++ ++lemma sum_Icc0_shifted_floor_eq (a : ℕ → ℂ) (t : ℝ) : ++ (∑ k ∈ Finset.Icc 0 ⌊t⌋₊, (if k = 0 then 0 else a k)) = ∑ n ∈ Finset.range ⌊t⌋₊, a (n + 1) := by ++ simpa using (sum_Icc0_shifted_eq_sum_range a ⌊t⌋₊) ++ ++lemma helper_contdiff_differentiable_integrable (f : ℝ → ℂ) (hf : ContDiff ℝ 1 f) ++ (a b : ℝ) : ++ (∀ t ∈ Set.Icc a b, DifferentiableAt ℝ f t) ∧ IntegrableOn (deriv f) (Set.Icc a b) := by ++ have hdiff : Differentiable ℝ f := hf.differentiable (by norm_num) ++ have hcont_deriv : Continuous (deriv f) := hf.continuous_deriv le_rfl ++ refine And.intro ?hdiffAt ?hint ++ · intro t ht ++ have hdt : DifferentiableAt ℝ f t := hdiff.differentiableAt ++ exact hdt ++ · ++ have hcontOn : ContinuousOn (deriv f) (Set.Icc a b) := hcont_deriv.continuousOn ++ exact hcontOn.integrableOn_compact isCompact_Icc ++ ++lemma sum_range_mul_shift_comm (N : ℕ) (a : ℕ → ℂ) (f : ℝ → ℂ) : ++ (∑ n ∈ Finset.range N, f (n + 1) * (if n + 1 = 0 then 0 else a (n + 1))) ++ = ∑ n ∈ Finset.range N, a (n + 1) * f (n + 1) := by ++ classical ++ apply Finset.sum_congr rfl ++ intro n hn ++ simp [mul_comm] ++ ++lemma sum_range_shifted_coeffs (N : ℕ) (a c : ℕ → ℂ) (f : ℝ → ℂ) ++ (hshift : ∀ n, c (n + 1) = a (n + 1)) : ++ (∑ n ∈ Finset.range N, f (↑(n + 1)) * c (n + 1)) ++ = ∑ n ∈ Finset.range N, f (↑(n + 1)) * a (n + 1) := by ++ classical ++ apply Finset.sum_congr rfl ++ intro n hn ++ simp [hshift n] ++ ++lemma sum_range_commute_mul (N : ℕ) (a : ℕ → ℂ) (f : ℝ → ℂ) : ++ (∑ n ∈ Finset.range N, f (↑(n + 1)) * a (n + 1)) ++ = ∑ n ∈ Finset.range N, a (n + 1) * f (↑(n + 1)) := by ++ classical ++ apply Finset.sum_congr rfl ++ intro n hn ++ simp [mul_comm] ++ ++lemma lem_abelSummation {a : ℕ → ℂ} {f : ℝ → ℂ} ++ (hf : ContDiff ℝ 1 f) (N : ℕ) (hN : 1 ≤ N) : ++ (let A := fun u : ℝ => ∑ n ∈ Finset.range (Nat.floor u), a (n + 1); ++ ∑ n ∈ Finset.range N, a (n + 1) * f (n + 1) ++ = (A N) * f N - ∫ u in (1 : ℝ)..N, (A u) * deriv f u) := by ++ classical ++ ++ let c : ℕ → ℂ := fun k => if k = 0 then 0 else a k ++ ++ set A : ℝ → ℂ := fun u : ℝ => ∑ n ∈ Finset.range (Nat.floor u), a (n + 1) with hA ++ ++ have hdiff_int := helper_contdiff_differentiable_integrable (f := f) hf (1 : ℝ) N ++ rcases hdiff_int with ⟨hdiff, hint⟩ ++ ++ have habel := ++ sum_mul_eq_sub_integral_mul₀' (c := c) (m := N) ++ (hc := by simp [c]) ++ (hf_diff := by ++ intro t ht ++ simpa using (hdiff t ht)) ++ (hf_int := by simpa using hint) ++ ++ have hLHS : ++ (∑ k ∈ Finset.Icc 0 N, f k * c k) ++ = ∑ n ∈ Finset.range N, a (n + 1) * f (n + 1) := by ++ ++ have h0 : ++ (∑ k ∈ Finset.Icc 0 N, f k * c k) ++ = ∑ k ∈ Finset.Icc 1 N, f k * c k := by ++ simpa [c] using ++ (sum_Icc0_eq_sum_Icc1_of_zero (N := N) ++ (g := fun k => f k * c k) (h0 := by simp [c])) ++ ++ have h1 : ++ (∑ k ∈ Finset.Icc 1 N, f k * c k) ++ = ∑ n ∈ Finset.range N, f (n + 1) * c (n + 1) := by ++ simpa using ++ (sum_Icc1_eq_sum_range_succ (N := N) (g := fun k => f k * c k)) ++ ++ have h2 : ++ (∑ n ∈ Finset.range N, f (n + 1) * c (n + 1)) ++ = ∑ n ∈ Finset.range N, a (n + 1) * f (n + 1) := by ++ simpa [c] using (sum_range_mul_shift_comm (N := N) (a := a) (f := f)) ++ ++ simp [h0, h1, h2] ++ ++ have hAN : A N = ∑ n ∈ Finset.range N, a (n + 1) := by ++ have : (Nat.floor (N : ℝ)) = N := by ++ simp ++ simp [hA, this] ++ have hMain : ++ f N * (∑ k ∈ Finset.Icc 0 N, c k) = (A N) * f N := by ++ ++ have hs : (∑ k ∈ Finset.Icc 0 N, c k) = ∑ n ∈ Finset.range N, a (n + 1) := by ++ simpa [c] using (sum_Icc0_shifted_eq_sum_range (a := a) (m := N)) ++ calc ++ f N * (∑ k ∈ Finset.Icc 0 N, c k) ++ = (∑ k ∈ Finset.Icc 0 N, c k) * f N := by simp [mul_comm] ++ _ = (∑ n ∈ Finset.range N, a (n + 1)) * f N := by simp [hs] ++ _ = (A N) * f N := by simp [hAN] ++ ++ have hInt : ++ (∫ t in Set.Ioc (1 : ℝ) N, deriv f t * ∑ k ∈ Finset.Icc 0 ⌊t⌋₊, c k) ++ = ∫ u in (1 : ℝ)..N, (A u) * deriv f u := by ++ ++ have hfun : ++ (fun t => deriv f t * ∑ k ∈ Finset.Icc 0 ⌊t⌋₊, c k) ++ = (fun t => deriv f t * A t) := by ++ funext t ++ have : (∑ k ∈ Finset.Icc 0 ⌊t⌋₊, c k) = A t := by ++ simpa [c, hA] using (sum_Icc0_shifted_floor_eq (a := a) (t := t)) ++ simp [this] ++ ++ have h1Nℝ : (1 : ℝ) ≤ N := by exact_mod_cast hN ++ have hI : ++ (∫ u in (1 : ℝ)..N, (A u) * deriv f u) ++ = ∫ u in Set.Ioc (1 : ℝ) N, (A u) * deriv f u := by ++ simpa using ++ (intervalIntegral.integral_of_le ++ (f := fun u => (A u) * deriv f u) (μ := volume) h1Nℝ) ++ calc ++ (∫ t in Set.Ioc (1 : ℝ) N, deriv f t * ∑ k ∈ Finset.Icc 0 ⌊t⌋₊, c k) ++ = ∫ t in Set.Ioc (1 : ℝ) N, deriv f t * A t := by ++ simp [hfun] ++ _ = ∫ t in Set.Ioc (1 : ℝ) N, (A t) * deriv f t := by ++ simp [mul_comm] ++ _ = ∫ u in (1 : ℝ)..N, (A u) * deriv f u := by ++ simp [hI] ++ ++ have hfinal : ∑ n ∈ Finset.range N, a (n + 1) * f (n + 1) ++ = (A N) * f N - ∫ u in (1 : ℝ)..N, (A u) * deriv f u := by ++ ++ simpa [hLHS, hMain, hInt] ++ using habel ++ ++ simpa [hA] using hfinal ++ ++lemma lem_partialSumIsZetaN (s : ℂ) (N : ℕ) : ++ (let f := fun u : ℝ => (u : ℂ) ^ (-s) ++ let a := fun _n : ℕ => (1 : ℂ) ++ zetaPartialSum s N = ∑ n ∈ Finset.range N, a n * f (n + 1)) := by ++ simp [zetaPartialSum] ++ ++lemma lem_sumOfAn (u : ℝ) (_hu : 1 ≤ u) : ++ (let a := fun _n : ℕ => (1 : ℂ) ++ let A := fun u : ℝ => ∑ n ∈ Finset.range (Nat.floor u), a (n + 1) ++ A u = (Nat.floor u : ℂ)) := by ++ simp [Finset.sum_const, Finset.card_range] ++ ++lemma lem_fDeriv (s : ℂ) (u : ℝ) (hu : 0 < u) : ++ (let f := fun u : ℝ => (u : ℂ) ^ (-s) ++ deriv f u = -s * (u : ℂ) ^ (-s - 1)) := by ++ ++ show deriv (fun u : ℝ => (u : ℂ) ^ (-s)) u = -s * (u : ℂ) ^ (-s - 1) ++ have hu_ne_zero : u ≠ 0 := ne_of_gt hu ++ by_cases h : s = 0 ++ · ++ simp [h] ++ · ++ have hneg_s_ne_zero : -s ≠ 0 := neg_ne_zero.mpr h ++ exact Complex.deriv_ofReal_cpow_const hu_ne_zero hneg_s_ne_zero ++ ++lemma differentiable_integrable_cpow_on_Icc (s : ℂ) (a b : ℝ) (h0 : 0 < a) (_hle : a ≤ b) : ++ (∀ t ∈ Set.Icc a b, DifferentiableAt ℝ (fun u : ℝ => (u : ℂ) ^ (-s)) t) ++ ∧ IntegrableOn (deriv (fun u : ℝ => (u : ℂ) ^ (-s))) (Set.Icc a b) := ++by ++ classical ++ ++ set f : ℝ → ℂ := fun u => (u : ℂ) ^ (-s) ++ set g : ℝ → ℂ := fun u => -s * (u : ℂ) ^ (-s - 1) ++ ++ have hpos_of_mem : ∀ {t : ℝ}, t ∈ Set.Icc a b → 0 < t := by ++ intro t ht; exact lt_of_lt_of_le h0 ht.1 ++ ++ have hdiff_at : ∀ t ∈ Set.Icc a b, DifferentiableAt ℝ f t := by ++ intro t ht ++ have ht_ne : t ≠ 0 := ne_of_gt (hpos_of_mem ht) ++ by_cases hs : s = 0 ++ · ++ simp [f, hs] ++ · ++ have hr : (-s) ≠ 0 := by simpa using (neg_ne_zero.mpr hs) ++ have hhas : HasDerivAt (fun y : ℝ => (y : ℂ) ^ (-s)) ((-s) * t ^ ((-s) - 1)) t := ++ hasDerivAt_ofReal_cpow_const (x := t) (hx := ht_ne) (r := -s) (hr := hr) ++ exact hhas.differentiableAt ++ ++ have hcont_pow : ContinuousOn (fun u : ℝ => (u : ℂ) ^ (-s - 1)) (Set.Icc a b) := by ++ intro t ht ++ have ht_ne : t ≠ 0 := ne_of_gt (hpos_of_mem ht) ++ by_cases hzero : (-s - 1) = 0 ++ · ++ have : (fun u : ℝ => (u : ℂ) ^ (-s - 1)) = fun _ : ℝ => (1 : ℂ) := by ++ funext u; simp [hzero] ++ simpa [this] using (continuousAt_const : ContinuousAt (fun _ : ℝ => (1 : ℂ)) t).continuousWithinAt ++ · ++ have hr : (-s - 1) ≠ 0 := hzero ++ have hcpow : HasDerivAt (fun y : ℝ => (y : ℂ) ^ (-s - 1)) ((-s - 1) * t ^ ((-s - 1) - 1)) t := ++ hasDerivAt_ofReal_cpow_const (x := t) (hx := ht_ne) (r := -s - 1) (hr := hr) ++ have hcont_at : ContinuousAt (fun u : ℝ => (u : ℂ) ^ (-s - 1)) t := ++ hcpow.differentiableAt.continuousAt ++ simpa using hcont_at.continuousWithinAt ++ have hcont_g : ContinuousOn g (Set.Icc a b) := by ++ have hconst : ContinuousOn (fun _ : ℝ => (-s : ℂ)) (Set.Icc a b) := continuousOn_const ++ simpa only [g, Pi.mul_def, neg_mul] using! hconst.mul hcont_pow ++ ++ have hEqOn : EqOn (deriv f) g (Set.Icc a b) := by ++ intro u hu ++ have hu_pos : 0 < u := hpos_of_mem hu ++ simpa [f, g] using (lem_fDeriv s u hu_pos) ++ ++ have hcont_deriv : ContinuousOn (deriv f) (Set.Icc a b) := by ++ ++ have hg_restr : Continuous ((Set.Icc a b).domRestrict g) := hcont_g.domRestrict ++ have hEqRestr : (Set.Icc a b).domRestrict (deriv f) = (Set.Icc a b).domRestrict g := by ++ funext x; exact hEqOn x.property ++ have hderiv_restr : Continuous ((Set.Icc a b).domRestrict (deriv f)) := by ++ simpa [hEqRestr] using hg_restr ++ simpa [continuousOn_iff_continuous_domRestrict] using hderiv_restr ++ ++ have hInt : IntegrableOn (deriv f) (Set.Icc a b) := ++ hcont_deriv.integrableOn_compact isCompact_Icc ++ exact And.intro hdiff_at hInt ++ ++lemma intervalIntegral_congr_of_Ioc_eq (a b : ℝ) (h : a ≤ b) ++ (f g : ℝ → ℂ) ++ (hpt : ∀ u ∈ Set.Ioc a b, f u = g u) : ++ (∫ u in a..b, f u) = ∫ u in a..b, g u := by ++ ++ have h1 : (∀ᵐ u ∂(MeasureTheory.volume), u ∈ Set.Ioc a b → f u = g u) := by ++ refine Filter.Eventually.of_forall ?_; ++ intro u hu; exact hpt u hu ++ have hIocEmpty : Set.Ioc b a = (∅ : Set ℝ) := by ++ simpa using! (Set.Ioc_eq_empty_of_le h) ++ have h2 : (∀ᵐ u ∂(MeasureTheory.volume), u ∈ Set.Ioc b a → f u = g u) := by ++ refine Filter.Eventually.of_forall ?_; ++ intro u hu ++ have : u ∈ (∅ : Set ℝ) := by simp [hIocEmpty] at hu ++ exact this.elim ++ simpa using ++ (intervalIntegral.integral_congr_ae' (a := a) (b := b) (μ := MeasureTheory.volume) ++ (f := f) (g := g) h1 h2) ++ ++lemma lem_applyAbel (s : ℂ) (N : ℕ) (hN : 1 ≤ N) : ++ zetaPartialSum s N ++ = (N : ℂ) * (N : ℂ) ^ (-s) ++ - ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ classical ++ ++ set f : ℝ → ℂ := fun u => (u : ℂ) ^ (-s) ++ let c : ℕ → ℂ := fun k => if k = 0 then 0 else (1 : ℂ) ++ ++ have hle : (1 : ℝ) ≤ (N : ℝ) := by exact_mod_cast hN ++ have hdiff_int := ++ differentiable_integrable_cpow_on_Icc (s := s) (a := (1 : ℝ)) (b := (N : ℝ)) ++ (h0 := by exact zero_lt_one) (_hle := hle) ++ rcases hdiff_int with ⟨hdiff, hint⟩ ++ ++ have habel := ++ sum_mul_eq_sub_integral_mul₀' (c := c) (f := f) (m := N) ++ (hc := by simp [c]) ++ (hf_diff := by intro t ht; simpa [f] using (hdiff t ht)) ++ (hf_int := by simpa [f] using hint) ++ ++ have hLHS : (∑ k ∈ Finset.Icc 0 N, f k * c k) = zetaPartialSum s N := by ++ ++ have h0 : ++ (∑ k ∈ Finset.Icc 0 N, f k * c k) = ∑ k ∈ Finset.Icc 1 N, f k * c k := by ++ simpa [c] using ++ (sum_Icc0_eq_sum_Icc1_of_zero (N := N) ++ (g := fun k => f k * c k) (h0 := by simp [c])) ++ have h1 : (∑ k ∈ Finset.Icc 1 N, f k * c k) ++ = ∑ n ∈ Finset.range N, f (n + 1) * c (n + 1) := by ++ simpa using (sum_Icc1_eq_sum_range_succ (N := N) (g := fun k => f k * c k)) ++ have h2 : (∑ n ∈ Finset.range N, f (n + 1) * c (n + 1)) ++ = ∑ n ∈ Finset.range N, f (n + 1) := by ++ apply Finset.sum_congr rfl; intro n hn; simp [c] ++ calc ++ (∑ k ∈ Finset.Icc 0 N, f k * c k) ++ = ∑ k ∈ Finset.Icc 1 N, f k * c k := by simpa using h0 ++ _ = ∑ n ∈ Finset.range N, f (n + 1) * c (n + 1) := by simpa using h1 ++ _ = ∑ n ∈ Finset.range N, f (n + 1) := by simpa using h2 ++ _ = zetaPartialSum s N := by simp [zetaPartialSum, f] ++ ++ have hset_to_interval : ++ (∫ t in Set.Ioc (1 : ℝ) N, deriv f t * ∑ k ∈ Finset.Icc 0 ⌊t⌋₊, c k) ++ = ∫ u in (1 : ℝ)..N, deriv f u * ∑ k ∈ Finset.Icc 0 ⌊u⌋₊, c k := by ++ simpa using ++ (intervalIntegral.integral_of_le ++ (f := fun u => deriv f u * ∑ k ∈ Finset.Icc 0 ⌊u⌋₊, c k) ++ (μ := volume) hle).symm ++ have hstep1 : ++ zetaPartialSum s N ++ = f N * (∑ k ∈ Finset.Icc 0 N, c k) ++ - ∫ u in (1 : ℝ)..N, deriv f u * ∑ k ∈ Finset.Icc 0 ⌊u⌋₊, c k := by ++ simpa [hLHS, hset_to_interval] using habel ++ ++ have hInt_congr : ++ (∫ u in (1 : ℝ)..N, deriv f u * ∑ k ∈ Finset.Icc 0 ⌊u⌋₊, c k) ++ = ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ ++ apply intervalIntegral_congr_of_Ioc_eq (a := (1 : ℝ)) (b := (N : ℝ)) (h := hle) ++ (f := fun u => deriv f u * ∑ k ∈ Finset.Icc 0 ⌊u⌋₊, c k) ++ (g := fun u => (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1))) ++ intro u hu ++ have hu_pos : 0 < u := lt_trans zero_lt_one hu.1 ++ have hderiv : deriv f u = -s * (u : ℂ) ^ (-s - 1) := by ++ simpa [f] using (lem_fDeriv s u hu_pos) ++ ++ have hsumfloor : (∑ k ∈ Finset.Icc 0 ⌊u⌋₊, c k) = (Nat.floor u : ℂ) := by ++ have hshift := sum_Icc0_shifted_floor_eq (a := fun _ => (1 : ℂ)) (t := u) ++ have hsum : (∑ n ∈ Finset.range ⌊u⌋₊, (1 : ℂ)) = (Nat.floor u : ℂ) := by ++ simp [Finset.sum_const, Finset.card_range] ++ simpa [c, hsum] using hshift ++ calc ++ deriv f u * ∑ k ∈ Finset.Icc 0 ⌊u⌋₊, c k ++ = deriv f u * (Nat.floor u : ℂ) := by simp [hsumfloor] ++ _ = (Nat.floor u : ℂ) * deriv f u := by simp [mul_comm] ++ _ = (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by simp [hderiv] ++ ++ have hstep2 : ++ zetaPartialSum s N ++ = f N * (∑ k ∈ Finset.Icc 0 N, c k) ++ - ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ simpa [hInt_congr] using hstep1 ++ ++ have hMain : f N * (∑ k ∈ Finset.Icc 0 N, c k) = (N : ℂ) * f N := by ++ have hs : (∑ k ∈ Finset.Icc 0 N, c k) = ∑ n ∈ Finset.range N, (1 : ℂ) := by ++ simpa [c] using (sum_Icc0_shifted_eq_sum_range (a := fun _ => (1 : ℂ)) (m := N)) ++ have hsumN : (∑ n ∈ Finset.range N, (1 : ℂ)) = (N : ℂ) := by ++ simp [Finset.sum_const, Finset.card_range] ++ calc ++ f N * (∑ k ∈ Finset.Icc 0 N, c k) ++ = f N * (∑ n ∈ Finset.range N, (1 : ℂ)) := by simp [hs] ++ _ = f N * (N : ℂ) := by simp [hsumN] ++ _ = (N : ℂ) * f N := by simp [mul_comm] ++ ++ have hfinal : ++ zetaPartialSum s N ++ = (N : ℂ) * (N : ℂ) ^ (-s) ++ - ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ calc ++ zetaPartialSum s N ++ = f N * (∑ k ∈ Finset.Icc 0 N, c k) ++ - ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ simpa using hstep2 ++ _ = (N : ℂ) * f N ++ - ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ simp [hMain] ++ _ = (N : ℂ) * (N : ℂ) ^ (-s) ++ - ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ simp [f] ++ exact hfinal ++ ++lemma lem_floorNisN (N : ℕ) (_hN : 1 ≤ N) : Nat.floor (N : ℝ) = N := by simp ++ ++lemma helper_integral_const_mul (a b : ℝ) (c : ℂ) (g : ℝ → ℂ) : ∫ x in a..b, c * g x = c * ∫ x in a..b, g x := by simp ++ ++lemma helper_cpow_mul_cpow_neg_eq_cpow_sub (x s : ℂ) (hx : x ≠ 0) : x * x ^ (-s) = x ^ (1 - s) := by ++ calc ++ x * x ^ (-s) = x ^ (1 : ℂ) * x ^ (-s) := by ++ simp [Complex.cpow_one] ++ _ = x ^ (1 + (-s)) := by ++ simpa using (Complex.cpow_add (x := x) (y := (1 : ℂ)) (z := (-s)) hx).symm ++ _ = x ^ (1 - s) := by ++ simp [sub_eq_add_neg] ++ ++lemma lem_zetaNsimplified1 (s : ℂ) (N : ℕ) (hN : 1 ≤ N) : zetaPartialSum s N = (N : ℂ) ^ (1 - s) + s * ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1) := by ++ have happly := lem_applyAbel s N hN ++ ++ have hInt : ++ ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) ++ = (-s) * ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1) := by ++ simp [mul_left_comm] ++ calc ++ zetaPartialSum s N ++ = (N : ℂ) * (N : ℂ) ^ (-s) ++ - ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (-s * (u : ℂ) ^ (-s - 1)) := by ++ simpa using happly ++ _ = (N : ℂ) * (N : ℂ) ^ (-s) ++ - ((-s) * ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1)) := by ++ rw [hInt] ++ _ = (N : ℂ) * (N : ℂ) ^ (-s) ++ + s * ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1) := by ++ simp [sub_eq_add_neg, neg_mul] ++ _ = (N : ℂ) ^ (1 - s) ++ + s * ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1) := by ++ have hpos : 0 < N := (Nat.succ_le_iff).mp hN ++ have hNz : (N : ℂ) ≠ 0 := Nat.cast_ne_zero.mpr (ne_of_gt hpos) ++ have hpow := helper_cpow_mul_cpow_neg_eq_cpow_sub (x := (N : ℂ)) (s := s) hNz ++ simp [hpow] ++ ++lemma lem_floorUdecomp (u : ℝ) : (Int.floor u : ℝ) = u - Int.fract u := by exact (eq_sub_iff_add_eq).2 (Int.floor_add_fract u) ++ ++lemma lem_fracPartBound (u : ℝ) : 0 ≤ Int.fract u ∧ Int.fract u < 1 ∧ |Int.fract u| ≤ (1 : ℝ) := by ++ constructor ++ · exact Int.fract_nonneg u ++ · constructor ++ · exact Int.fract_lt_one u ++ · have hnonneg : 0 ≤ Int.fract u := Int.fract_nonneg u ++ have hle : Int.fract u ≤ (1 : ℝ) := le_of_lt (Int.fract_lt_one u) ++ simpa [abs_of_nonneg hnonneg] using hle ++ ++lemma helper_continuousOn_cpow (r : ℂ) {a b : ℝ} (ha : 0 < a) (_hab : a ≤ b) : ++ ContinuousOn (fun u : ℝ => (u : ℂ) ^ r) (Set.Icc a b) := by ++ classical ++ intro t ht ++ have ht_pos : 0 < t := lt_of_lt_of_le ha ht.1 ++ by_cases hr : r = 0 ++ · ++ have hconst : (fun u : ℝ => (u : ℂ) ^ r) = fun _ => (1 : ℂ) := by ++ funext u; simp [hr] ++ simpa [hconst] using (continuousAt_const : ContinuousAt (fun _ : ℝ => (1 : ℂ)) t).continuousWithinAt ++ · ++ have hderiv : HasDerivAt (fun u : ℝ => (u : ℂ) ^ r) (r * t ^ (r - 1)) t := ++ hasDerivAt_ofReal_cpow_const (x := t) (hx := ne_of_gt ht_pos) (r := r) (hr := hr) ++ exact hderiv.differentiableAt.continuousAt.continuousWithinAt ++ ++lemma helper_intervalIntegrable_mul_cpow_id (s : ℂ) {a b : ℝ} (ha : 1 ≤ a) (hab : a ≤ b) : ++ IntervalIntegrable (fun u : ℝ => (u : ℂ) * (u : ℂ) ^ (-s - 1)) volume a b := by ++ classical ++ ++ have hcont1 : ContinuousOn (fun u : ℝ => (u : ℂ)) (Set.Icc a b) := ++ (Complex.continuous_ofReal).continuousOn ++ have hcont2 : ContinuousOn (fun u : ℝ => (u : ℂ) ^ (-s - 1)) (Set.Icc a b) := ++ helper_continuousOn_cpow (-s - 1) (lt_of_lt_of_le zero_lt_one ha) hab ++ have hcont : ContinuousOn (fun u : ℝ => (u : ℂ) * (u : ℂ) ^ (-s - 1)) (Set.Icc a b) := ++ hcont1.mul hcont2 ++ ++ have hint_on : IntegrableOn (fun u : ℝ => (u : ℂ) * (u : ℂ) ^ (-s - 1)) (Set.Icc a b) := ++ hcont.integrableOn_compact isCompact_Icc ++ have hint : IntervalIntegrable (fun u : ℝ => (u : ℂ) * (u : ℂ) ^ (-s - 1)) volume a b := by ++ simpa using ++ (intervalIntegrable_iff_integrableOn_Icc_of_le (μ := volume) (a := a) (b := b) ++ (f := fun u : ℝ => (u : ℂ) * (u : ℂ) ^ (-s - 1)) hab).2 hint_on ++ exact hint ++ ++lemma helper_aestronglyMeasurable_kernel_Icc (s : ℂ) {a b : ℝ} : ++ AEStronglyMeasurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)) ++ (volume.restrict (Icc a b)) := by ++ ++ have hmeas_fract : Measurable (Int.fract : ℝ → ℝ) := by simpa using (measurable_fract : Measurable (Int.fract : ℝ → ℝ)) ++ have h1 : AEStronglyMeasurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ)) (volume.restrict (Icc a b)) := ++ (Complex.measurable_ofReal.comp hmeas_fract).aestronglyMeasurable ++ have h2 : AEStronglyMeasurable (fun u : ℝ => (u : ℂ) ^ (-s - 1)) (volume.restrict (Icc a b)) := by ++ have hmeas : Measurable (fun u : ℝ => (u : ℂ) ^ (-s - 1)) := by measurability ++ exact hmeas.aestronglyMeasurable ++ simpa using! (MeasureTheory.AEStronglyMeasurable.mul h1 h2) ++ ++lemma helper_intervalIntegrable_frac_kernel (s : ℂ) {a b : ℝ} (ha : 1 ≤ a) (hab : a ≤ b) : ++ IntervalIntegrable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)) volume a b := by ++ classical ++ ++ let μ := volume.restrict (Icc a b) ++ set f : ℝ → ℂ := fun u => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1) ++ set g : ℝ → ℝ := fun u => ‖(u : ℂ) ^ (-s - 1)‖ ++ ++ have hmeas : AEStronglyMeasurable f μ := by simpa [μ, f] using helper_aestronglyMeasurable_kernel_Icc (s := s) (a := a) (b := b) ++ ++ have hbound_ae : ∀ᵐ u ∂μ, ‖f u‖ ≤ g u := by ++ ++ refine ((ae_restrict_iff' (μ := volume) (s := Icc a b) ++ (p := fun u : ℝ => ‖f u‖ ≤ g u) measurableSet_Icc)).2 ?_ ++ refine Filter.Eventually.of_forall ?_ ++ intro u hu ++ ++ have hfract_le1 : ‖(Int.fract u : ℝ)‖ ≤ (1 : ℝ) := by ++ simpa using (lem_fracPartBound u).2.2 ++ ++ have : ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)‖ ≤ ‖(Int.fract u : ℝ)‖ * ‖(u : ℂ) ^ (-s - 1)‖ := by ++ simp ++ have : ‖f u‖ ≤ ‖(Int.fract u : ℝ)‖ * ‖(u : ℂ) ^ (-s - 1)‖ := by ++ simp [f] ++ have : ‖f u‖ ≤ 1 * ‖(u : ℂ) ^ (-s - 1)‖ := ++ le_trans this (mul_le_mul_of_nonneg_right hfract_le1 (by exact norm_nonneg _)) ++ simpa [g] using (by simpa [one_mul] using this) ++ ++ have hcont : ContinuousOn (fun u : ℝ => (u : ℂ) ^ (-s - 1)) (Icc a b) := ++ helper_continuousOn_cpow (-s - 1) (lt_of_lt_of_le zero_lt_one ha) hab ++ have hg_int_on : IntegrableOn g (Icc a b) := by ++ have hcont_norm : ContinuousOn g (Icc a b) := by ++ simpa [g] using (hcont.norm) ++ exact hcont_norm.integrableOn_compact isCompact_Icc ++ ++ have hf0 : Integrable (fun _ : ℝ => (0 : ℂ)) μ := by simp [μ] ++ have hg : Integrable g μ := by simpa [μ] using! hg_int_on ++ ++ have hf : Integrable f μ := ++ MeasureTheory.integrable_of_norm_sub_le (μ := μ) hmeas hf0 hg ++ (by ++ ++ have : ∀ᵐ u ∂μ, ‖(0 : ℂ) - f u‖ ≤ g u := by ++ simpa [sub_eq_add_neg, norm_neg, μ, f, g] using hbound_ae ++ simpa using this) ++ ++ have hf_on : IntegrableOn f (Icc a b) := by simpa [μ, f] using! hf ++ simpa using ++ (intervalIntegrable_iff_integrableOn_Icc_of_le (μ := volume) (a := a) (b := b) ++ (f := f) hab).2 hf_on ++ ++lemma lem_integralSplit (s : ℂ) (N : ℕ) (hN : 1 ≤ N) : ++ ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1) ++ = (∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s)) ++ - ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) := by ++ have hab : (1 : ℝ) ≤ (N : ℝ) := by exact_mod_cast hN ++ ++ have hcongr1 : ++ (∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1)) ++ = ∫ u in (1 : ℝ)..N, ++ ((u : ℂ) - ((Int.fract u : ℝ) : ℂ)) * (u : ℂ) ^ (-s - 1) := by ++ apply intervalIntegral_congr_of_Ioc_eq (a := (1 : ℝ)) (b := (N : ℝ)) (h := hab) ++ intro u hu ++ have hu0 : 0 ≤ u := le_trans (by norm_num) (le_of_lt hu.1) ++ have hfloorR : (Nat.floor u : ℝ) = (Int.floor u : ℝ) := by ++ simpa using (natCast_floor_eq_intCast_floor (R := ℝ) (a := u) hu0) ++ have hfloorC : (Nat.floor u : ℂ) = ((Int.floor u : ℝ) : ℂ) := by ++ simpa using congrArg (fun x : ℝ => (x : ℂ)) hfloorR ++ have hIFR : (Int.floor u : ℝ) = u - Int.fract u := lem_floorUdecomp u ++ have hIFC : ((Int.floor u : ℝ) : ℂ) = ((u - Int.fract u : ℝ) : ℂ) := ++ congrArg (fun x : ℝ => (x : ℂ)) hIFR ++ have : (Nat.floor u : ℂ) = ((u - Int.fract u : ℝ) : ℂ) := hfloorC.trans hIFC ++ simp [this, sub_eq_add_neg] ++ ++ have hcongr2 : ++ (∫ u in (1 : ℝ)..N, ++ ((u : ℂ) - ((Int.fract u : ℝ) : ℂ)) * (u : ℂ) ^ (-s - 1)) ++ = (∫ u in (1 : ℝ)..N, (u : ℂ) * (u : ℂ) ^ (-s - 1)) ++ - ∫ u in (1 : ℝ)..N, ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1) := by ++ have hI1 : IntervalIntegrable (fun u : ℝ => (u : ℂ) * (u : ℂ) ^ (-s - 1)) volume (1 : ℝ) (N : ℝ) := ++ helper_intervalIntegrable_mul_cpow_id (s := s) (a := (1 : ℝ)) (b := (N : ℝ)) (ha := le_rfl) (hab := hab) ++ have hI2 : IntervalIntegrable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)) volume (1 : ℝ) (N : ℝ) := ++ helper_intervalIntegrable_frac_kernel (s := s) (a := (1 : ℝ)) (b := (N : ℝ)) (ha := le_rfl) (hab := hab) ++ have : ++ (∫ u in (1 : ℝ)..N, ++ ((u : ℂ) - ((Int.fract u : ℝ) : ℂ)) * (u : ℂ) ^ (-s - 1)) ++ = ∫ u in (1 : ℝ)..N, ++ ((u : ℂ) * (u : ℂ) ^ (-s - 1) ++ - ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)) := by ++ apply intervalIntegral_congr_of_Ioc_eq (a := (1 : ℝ)) (b := (N : ℝ)) (h := hab) ++ intro u hu; simp [sub_mul] ++ calc ++ (∫ u in (1 : ℝ)..N, ++ ((u : ℂ) - ((Int.fract u : ℝ) : ℂ)) * (u : ℂ) ^ (-s - 1)) ++ = ∫ u in (1 : ℝ)..N, ++ ((u : ℂ) * (u : ℂ) ^ (-s - 1) ++ - ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)) := this ++ _ = (∫ u in (1 : ℝ)..N, (u : ℂ) * (u : ℂ) ^ (-s - 1)) ++ - ∫ u in (1 : ℝ)..N, ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1) := ++ (intervalIntegral.integral_sub (μ := volume) (a := (1 : ℝ)) (b := (N : ℝ)) hI1 hI2) ++ ++ have hpow : ++ (∫ u in (1 : ℝ)..N, (u : ℂ) * (u : ℂ) ^ (-s - 1)) ++ = ∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s) := by ++ apply intervalIntegral_congr_of_Ioc_eq (a := (1 : ℝ)) (b := (N : ℝ)) (h := hab) ++ intro u hu ++ have hu_pos : 0 < u := lt_trans zero_lt_one hu.1 ++ have hux0 : (u : ℝ) ≠ 0 := ne_of_gt hu_pos ++ have hcx0 : (u : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hux0 ++ calc ++ (u : ℂ) * (u : ℂ) ^ (-s - 1) ++ = (u : ℂ) ^ (1 : ℂ) * (u : ℂ) ^ (-s - 1) := by simp [Complex.cpow_one] ++ _ = (u : ℂ) ^ (1 + (-s - 1)) := by ++ simpa using ++ (Complex.cpow_add (x := (u : ℂ)) (y := (1 : ℂ)) (z := (-s - 1)) hcx0).symm ++ _ = (u : ℂ) ^ (-s) := by ++ simp [add_left_comm, sub_eq_add_neg] ++ ++ calc ++ ∫ u in (1 : ℝ)..N, (Nat.floor u : ℂ) * (u : ℂ) ^ (-s - 1) ++ = ∫ u in (1 : ℝ)..N, ++ ((u : ℂ) - ((Int.fract u : ℝ) : ℂ)) * (u : ℂ) ^ (-s - 1) := hcongr1 ++ _ = (∫ u in (1 : ℝ)..N, (u : ℂ) * (u : ℂ) ^ (-s - 1)) ++ - ∫ u in (1 : ℝ)..N, ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1) := hcongr2 ++ _ = (∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s)) ++ - ∫ u in (1 : ℝ)..N, ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1) := by ++ simp [hpow] ++ ++lemma lem_zetaNsimplified2 (s : ℂ) (N : ℕ) (hN : 1 ≤ N) : ++ zetaPartialSum s N ++ = (N : ℂ) ^ (1 - s) ++ + (s * ∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s)) ++ - (s * ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) := by ++ have hstep1: _ := lem_zetaNsimplified1 s N hN ++ rw [lem_integralSplit] at hstep1 ++ rw [mul_sub] at hstep1 ++ rw [hstep1] ++ exact (add_sub_assoc _ _ _).symm ++ exact hN ++ ++lemma lem_evalMainIntegral (s : ℂ) (hs : s ≠ 1) (N : ℕ) (hN : 1 ≤ N) : s * ∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s) = s / (1 - s) * ((N : ℂ) ^ (1 - s) - 1) := by ++ have h01leN : (1 : ℝ) ≤ (N : ℝ) := by exact_mod_cast hN ++ have h0notIcc : (0 : ℝ) ∉ Set.Icc (1 : ℝ) (N : ℝ) := by ++ intro hx ++ exact (not_le.mpr (by norm_num : (0 : ℝ) < 1)) hx.1 ++ have h0not : (0 : ℝ) ∉ Set.uIcc (1 : ℝ) (N : ℝ) := by ++ simp [uIcc_of_le h01leN] ++ have hrne : -s ≠ (-1 : ℂ) := by ++ intro h ++ apply hs ++ simpa using congrArg Neg.neg h ++ have hint : ∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s) ++ = ((N : ℂ) ^ ((-s) + 1) - (1 : ℂ) ^ ((-s) + 1)) / ((-s) + 1) := by ++ have hcond : (-1 < (-s).re) ∨ (-s ≠ -1 ∧ (0 : ℝ) ∉ Set.uIcc (1 : ℝ) (N : ℝ)) := by ++ exact Or.inr ⟨hrne, h0not⟩ ++ simpa using (integral_cpow (a := (1 : ℝ)) (b := (N : ℝ)) (r := -s) hcond) ++ have hmul : s * ∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s) ++ = s * (((N : ℂ) ^ ((-s) + 1) - (1 : ℂ) ^ ((-s) + 1)) / ((-s) + 1)) := by ++ simpa using congrArg (fun x => s * x) hint ++ have hrewrite : ++ s * (((N : ℂ) ^ ((-s) + 1) - (1 : ℂ) ^ ((-s) + 1)) / ((-s) + 1)) ++ = s * (((N : ℂ) ^ (1 - s) - 1) / (1 - s)) := by ++ have : s * (((N : ℂ) ^ ((-s) + 1) - (1 : ℂ) ^ ((-s) + 1)) / ((-s) + 1)) ++ = s * (((N : ℂ) ^ (1 - s) - (1 : ℂ) ^ (1 - s)) / (1 - s)) := by ++ simp [add_comm, sub_eq_add_neg] ++ have h1pow : (1 : ℂ) ^ (1 - s) = 1 := by simp ++ simpa [h1pow] using this ++ have hsplit : s * (((N : ℂ) ^ (1 - s) - 1) / (1 - s)) ++ = s / (1 - s) * ((N : ℂ) ^ (1 - s) - 1) := by ++ have h1 : s * (((N : ℂ) ^ (1 - s) - 1) / (1 - s)) ++ = (s * ((N : ℂ) ^ (1 - s) - 1)) / (1 - s) := by ++ simpa using (mul_div_assoc s ((N : ℂ) ^ (1 - s) - 1) (1 - s)).symm ++ have h2 : (s * ((N : ℂ) ^ (1 - s) - 1)) / (1 - s) ++ = (s / (1 - s)) * ((N : ℂ) ^ (1 - s) - 1) := by ++ simpa [mul_comm, mul_left_comm, mul_assoc] using ++ (div_mul_eq_mul_div (a := s) (b := (1 - s)) (c := ((N : ℂ) ^ (1 - s) - 1))).symm ++ exact h1.trans h2 ++ calc ++ s * ∫ u in (1 : ℝ)..N, (u : ℂ) ^ (-s) ++ = s * (((N : ℂ) ^ ((-s) + 1) - (1 : ℂ) ^ ((-s) + 1)) / ((-s) + 1)) := hmul ++ _ = s * (((N : ℂ) ^ (1 - s) - 1) / (1 - s)) := hrewrite ++ _ = s / (1 - s) * ((N : ℂ) ^ (1 - s) - 1) := hsplit ++ ++lemma lem_zetaNfinal (s : ℂ) (hs : s ≠ 1) (N : ℕ) (hN : 1 ≤ N) : ++ zetaPartialSum s N ++ = (N : ℂ) ^ (1 - s) / (1 - s) + 1 + 1 / (s - 1) ++ - s * ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) := by ++ ++ have hstep := lem_zetaNsimplified2 s N hN ++ ++ rw [lem_evalMainIntegral s hs N hN] at hstep ++ ++ have hden : (1 - s) ≠ 0 := by ++ intro h ++ have h1 : 1 = s := by simpa [sub_eq_zero] using h ++ have h2 : s = 1 := h1.symm ++ exact hs h2 ++ let A := (N : ℂ) ^ (1 - s) ++ ++ have h1 : (1 - s) * (A + s / (1 - s) * (A - 1)) = A - s := by ++ calc ++ (1 - s) * (A + s / (1 - s) * (A - 1)) ++ = (1 - s) * A + (1 - s) * (s / (1 - s) * (A - 1)) := by ring ++ _ = (1 - s) * A + s * (A - 1) := by field_simp [hden] ++ _ = A - s := by ring ++ have h2 : (1 - s) * (A / (1 - s) + 1 + 1 / (s - 1)) = A - s := by ++ have hne : s - 1 ≠ 0 := by simpa [sub_eq_zero] using hs ++ field_simp [hden, hne]; ring ++ have halg : A + s / (1 - s) * (A - 1) = A / (1 - s) + 1 + 1 / (s - 1) := ++ mul_left_cancel₀ hden (h1.trans h2.symm) ++ ++ rw [halg] at hstep ++ exact hstep ++ ++lemma complex_tendsto_zero_iff_norm_tendsto_zero {α : Type*} {f : α → ℂ} {l : Filter α} : ++ Tendsto f l (𝓝 0) ↔ Tendsto (fun x => ‖f x‖) l (𝓝 0) := by ++ rw [tendsto_iff_dist_tendsto_zero] ++ simp only [dist_zero_right] ++ ++lemma complex_norm_natCast_cpow (N : ℕ) (w : ℂ) (hN : 0 < N) : ++ ‖(N : ℂ) ^ w‖ = (N : ℝ) ^ w.re := by ++ have hNnz : (N : ℂ) ≠ 0 := by ++ simp [Ne, Nat.cast_eq_zero] ++ exact ne_of_gt hN ++ rw [Complex.norm_cpow_of_ne_zero hNnz] ++ rw [Complex.norm_natCast] ++ rw [Complex.natCast_arg] ++ simp [Real.exp_zero] ++ ++lemma tendsto_natCast_cpow_zero_of_neg_re (w : ℂ) (hw : w.re < 0) : ++ Tendsto (fun N : ℕ => (N : ℂ) ^ w) atTop (𝓝 0) := by ++ rw [complex_tendsto_zero_iff_norm_tendsto_zero] ++ ++ have h1 : ∀ᶠ (N : ℕ) in atTop, ‖(N : ℂ) ^ w‖ = (N : ℝ) ^ w.re := by ++ filter_upwards [eventually_gt_atTop 0] with N hN ++ exact complex_norm_natCast_cpow N w hN ++ rw [tendsto_congr' h1] ++ ++ have hw_pos : 0 < -w.re := neg_pos.mpr hw ++ ++ have h_eq : w.re = -(-w.re) := by ring ++ rw [h_eq] ++ ++ have h_comp : Tendsto (fun N : ℕ => (N : ℝ)) atTop atTop := tendsto_natCast_atTop_atTop ++ have h_rpow : Tendsto (fun x : ℝ => x ^ (-(-w.re))) atTop (𝓝 0) := tendsto_rpow_neg_atTop hw_pos ++ exact Tendsto.comp h_rpow h_comp ++ ++lemma lem_limitTerm1 (s : ℂ) (hs : 1 < s.re) : ++ Tendsto (fun N : ℕ => (N : ℂ) ^ (1 - s)) atTop (𝓝 0) := by ++ apply tendsto_natCast_cpow_zero_of_neg_re ++ simp only [Complex.sub_re, Complex.one_re] ++ linarith ++ ++lemma lem_integrandBound (u : ℝ) (hu : 1 ≤ u) (s : ℂ) : ‖(Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-s.re - 1) := by ++ ++ set a : ℂ := ((Int.fract u : ℝ) : ℂ) ++ set b : ℂ := (u : ℂ) ^ (-s - 1) ++ ++ have hfract_le1 : ‖a‖ ≤ (1 : ℝ) := by ++ simpa [a, Complex.norm_real] using (lem_fracPartBound u).2.2 ++ ++ have hu0 : 0 < u := lt_of_lt_of_le zero_lt_one hu ++ ++ have h₁ : ‖a * b‖ ≤ ‖a‖ * ‖b‖ := by simp ++ have h₂ : ‖a‖ * ‖b‖ ≤ 1 * ‖b‖ := ++ mul_le_mul_of_nonneg_right hfract_le1 (norm_nonneg _) ++ have h₃ : ‖a * b‖ ≤ 1 * ‖b‖ := le_trans h₁ h₂ ++ have hle : ‖a * b‖ ≤ ‖b‖ := by simpa [one_mul] using h₃ ++ ++ have hb : ‖b‖ = u ^ ((-s - 1).re) := by ++ simpa [b] using ++ Complex.norm_cpow_eq_rpow_re_of_pos (x := u) (hx := hu0) (y := -s - 1) ++ ++ have hexp : (-s - 1).re = -s.re - 1 := by ++ simp [sub_eq_add_neg] ++ ++ calc ++ ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)‖ ++ = ‖a * b‖ := rfl ++ _ ≤ ‖b‖ := hle ++ _ = u ^ ((-s - 1).re) := hb ++ _ = u ^ (-s.re - 1) := by simp [hexp] ++ ++lemma lem_integrandBoundeps (ε : ℝ) (_hε : 0 < ε) (u : ℝ) (hu : 1 ≤ u) (s : ℂ) (hs : ε ≤ s.re) : ‖(Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-1 - ε) := by ++ have h1 : ‖(Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-s.re - 1) := lem_integrandBound u hu s ++ have h2 : -s.re - 1 ≤ -1 - ε := by linarith [hs] ++ have h3 : u ^ (-s.re - 1) ≤ u ^ (-1 - ε) := Real.rpow_le_rpow_of_exponent_le hu h2 ++ exact le_trans h1 h3 ++ ++lemma lem_triangleInequality_add (z₁ z₂ : ℂ) : ++ ‖z₁ + z₂‖ ≤ ‖z₁‖ + ‖z₂‖ := by ++ exact norm_add_le z₁ z₂ ++ ++lemma lem_triangleInequality_integral {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] ++ {f : ℝ → E} {a b : ℝ} (_hf : IntervalIntegrable f volume a b) (h : a ≤ b) : ++ ‖∫ u in a..b, f u‖ ≤ ∫ u in a..b, ‖f u‖ := by ++ ++ simpa using (intervalIntegral.norm_integral_le_integral_norm (μ := volume) (f := f) (a := a) (b := b) h) ++ ++lemma helper_integral_interval_sub_left {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] ++ {f : ℝ → E} {a b c : ℝ} ++ (hab : IntervalIntegrable f volume a b) (hac : IntervalIntegrable f volume a c) : ++ ((∫ x in a..b, f x) - ∫ x in a..c, f x) = ∫ x in c..b, f x := by ++ simpa using ++ (intervalIntegral.integral_interval_sub_left (μ := volume) (f := f) (a := a) (b := b) (c := c) ++ hab hac) ++ ++lemma helper_integral_rpow_eval {ε : ℝ} (hε : 0 < ε) {m n : ℝ} ++ (hm : 1 ≤ m) (hmn : m ≤ n) : ++ ∫ u in m..n, u ^ (-1 - ε) = (m ^ (-ε) - n ^ (-ε)) / ε := by ++ ++ have h0notIcc : (0 : ℝ) ∉ Set.Icc m n := by ++ intro hx ++ have : ¬ m ≤ 0 := not_le.mpr (lt_of_lt_of_le zero_lt_one hm) ++ exact this hx.1 ++ have h0not : (0 : ℝ) ∉ Set.uIcc m n := by ++ simpa [uIcc_of_le hmn] using h0notIcc ++ ++ have hrne : (-1 - ε) ≠ (-1 : ℝ) := by ++ intro h ++ have hplus := congrArg (fun t => t + 1) h ++ have hminus : -ε = 0 := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using hplus ++ have hε0 : ε = 0 := by simpa using congrArg Neg.neg hminus ++ exact (ne_of_gt hε) hε0 ++ ++ have hint : ∫ u in m..n, u ^ (-1 - ε) ++ = (n ^ ((-1 - ε) + 1) - m ^ ((-1 - ε) + 1)) / ((-1 - ε) + 1) := by ++ have hcond : (-1 < (-1 - ε)) ∨ ((-1 - ε) ≠ -1 ∧ (0 : ℝ) ∉ Set.uIcc m n) := by ++ exact Or.inr ⟨hrne, h0not⟩ ++ simpa using (integral_rpow (a := m) (b := n) (r := -1 - ε) hcond) ++ ++ have h1 : ((-1 - ε) + 1) = -ε := by ++ simp [sub_eq_add_neg, add_comm, add_left_comm] ++ have : ∫ u in m..n, u ^ (-1 - ε) ++ = (n ^ (-ε) - m ^ (-ε)) / (-ε) := by ++ simpa [h1] ++ using hint ++ have hnegnum : -(n ^ (-ε) - m ^ (-ε)) = m ^ (-ε) - n ^ (-ε) := by ++ simp ++ calc ++ ∫ u in m..n, u ^ (-1 - ε) ++ = (n ^ (-ε) - m ^ (-ε)) / (-ε) := this ++ _ = (n ^ (-ε) - m ^ (-ε)) * ((-ε)⁻¹) := by simp [div_eq_mul_inv] ++ _ = (n ^ (-ε) - m ^ (-ε)) * (-(ε⁻¹)) := by simp [inv_neg] ++ _ = -((n ^ (-ε) - m ^ (-ε)) * ε⁻¹) := by simp [mul_neg] ++ _ = (-(n ^ (-ε) - m ^ (-ε))) * ε⁻¹ := by ++ simpa using (neg_mul (n ^ (-ε) - m ^ (-ε)) (ε⁻¹)).symm ++ _ = (m ^ (-ε) - n ^ (-ε)) * ε⁻¹ := by ++ simp ++ _ = (m ^ (-ε) - n ^ (-ε)) / ε := by simp [div_eq_mul_inv] ++ ++lemma helper_integral_rpow_le {ε : ℝ} (hε : 0 < ε) {m n : ℝ} ++ (hm : 1 ≤ m) (hmn : m ≤ n) : ++ ∫ u in m..n, u ^ (-1 - ε) ≤ (1 / ε) * m ^ (-ε) := by ++ have heval := helper_integral_rpow_eval (ε := ε) hε hm hmn ++ have hn0 : 0 ≤ n := by ++ have h01 : (0 : ℝ) ≤ 1 := by norm_num ++ exact le_trans h01 (le_trans hm hmn) ++ have hsub_le : m ^ (-ε) - n ^ (-ε) ≤ m ^ (-ε) := by ++ exact sub_le_self _ (Real.rpow_nonneg hn0 (-ε)) ++ have hinv_nonneg : 0 ≤ ε⁻¹ := by ++ exact inv_nonneg.mpr (le_of_lt hε) ++ have hdiv_le : ((m ^ (-ε) - n ^ (-ε)) / ε) ≤ (m ^ (-ε) / ε) := by ++ have := mul_le_mul_of_nonneg_right hsub_le hinv_nonneg ++ simpa [div_eq_mul_inv, mul_comm] using this ++ calc ++ ∫ u in m..n, u ^ (-1 - ε) ++ = (m ^ (-ε) - n ^ (-ε)) / ε := heval ++ _ ≤ m ^ (-ε) / ε := hdiv_le ++ _ = (1 / ε) * m ^ (-ε) := by simp [div_eq_mul_inv, mul_comm] ++ ++lemma helper_tendsto_nat_rpow_neg (ε : ℝ) (hε : 0 < ε) : ++ Tendsto (fun m : ℕ => (m : ℝ) ^ (-ε)) atTop (𝓝 0) := by ++ ++ have hcont : Tendsto (fun x : ℝ => x ^ (-ε)) atTop (𝓝 0) := by ++ ++ simpa using (tendsto_rpow_neg_atTop (y := ε) hε) ++ ++ have hcoe : Tendsto (fun n : ℕ => (n : ℝ)) atTop atTop := by ++ exact tendsto_natCast_atTop_atTop ++ ++ have : Tendsto ((fun x : ℝ => x ^ (-ε)) ∘ fun n : ℕ => (n : ℝ)) atTop (𝓝 0) := ++ hcont.comp hcoe ++ ++ simpa using! this ++ ++lemma helper_exists_limit_of_tail_bound (a : ℕ → ℂ) (b : ℕ → ℝ) ++ (hb_nonneg : ∀ m, 0 ≤ b m) ++ (hb_tendsto : Tendsto b atTop (𝓝 0)) ++ (hbound : ∀ᶠ m in atTop, ∀ᶠ n in atTop, m ≤ n → ‖a n - a m‖ ≤ b m) : ++ ∃ l : ℂ, Tendsto a atTop (𝓝 l) := by ++ classical ++ ++ have hCauchy : CauchySeq a := by ++ ++ refine (Metric.cauchySeq_iff).2 ?_ ++ intro ε hε ++ ++ have h_ball : ∀ᶠ m in atTop, dist (b m) 0 < ε / 2 := by ++ exact hb_tendsto (Metric.ball_mem_nhds (0 : ℝ) (half_pos hε)) ++ have h_b_lt : ∀ᶠ m in atTop, b m < ε / 2 := by ++ refine h_ball.mono ?_ ++ intro m hm ++ have : |b m| < ε / 2 := by ++ simpa [Metric.mem_ball, Real.dist_eq] using hm ++ simpa [abs_of_nonneg (hb_nonneg m)] using this ++ ++ rcases eventually_atTop.1 hbound with ⟨M1, hM1⟩ ++ rcases eventually_atTop.1 h_b_lt with ⟨M2, hM2⟩ ++ let M := max M1 M2 ++ have hPM : ∀ᶠ n in atTop, M ≤ n → ‖a n - a M‖ ≤ b M := by ++ have h' := hM1 M (le_max_left _ _) ++ exact h' ++ have hMb : b M < ε / 2 := hM2 M (le_max_right _ _) ++ rcases eventually_atTop.1 hPM with ⟨N0, hN0⟩ ++ refine ⟨max N0 M, ?_⟩ ++ intro n hn k hk ++ have hMn : M ≤ n := le_trans (le_max_right _ _) hn ++ have hMk : M ≤ k := le_trans (le_max_right _ _) hk ++ have hN0n : N0 ≤ n := le_trans (le_max_left _ _) hn ++ have hN0k : N0 ≤ k := le_trans (le_max_left _ _) hk ++ have h1 : ‖a n - a M‖ ≤ b M := (hN0 n hN0n) hMn ++ have h2 : ‖a k - a M‖ ≤ b M := (hN0 k hN0k) hMk ++ ++ have htri : ‖a n - a k‖ ≤ ‖a n - a M‖ + ‖a M - a k‖ := by ++ have h := norm_add_le (a n - a M) (a M - a k) ++ simpa [sub_add_sub_cancel (a n) (a M) (a k)] using h ++ have h2' : ‖a M - a k‖ ≤ b M := by simpa [norm_sub_rev] using h2 ++ have hsumle : ‖a n - a k‖ ≤ b M + b M := ++ le_trans htri (add_le_add h1 h2') ++ have hsumlt : b M + b M < ε := by ++ have := add_lt_add hMb hMb ++ simpa [add_halves] using this ++ have : ‖a n - a k‖ < ε := lt_of_le_of_lt hsumle hsumlt ++ simpa [dist_eq_norm] using this ++ ++ rcases cauchySeq_tendsto_of_complete (u := a) hCauchy with ⟨l, hl⟩ ++ exact ⟨l, hl⟩ ++ ++lemma helper_limit_norm_le_of_uniform_bound {a : ℕ → ℂ} {l : ℂ} {B : ℝ} ++ (h : Tendsto a atTop (𝓝 l)) (hbound : ∀ n, ‖a n‖ ≤ B) : ‖l‖ ≤ B := by ++ have hnorm : Tendsto (fun n => ‖a n‖) atTop (𝓝 ‖l‖) := (Filter.Tendsto.norm h) ++ exact le_of_tendsto' hnorm (fun n => by simpa using hbound n) ++ ++lemma helper_one_le_of_mem_Icc {m n u : ℝ} (hm : 1 ≤ m) (hu : u ∈ Icc m n) : 1 ≤ u := by ++ exact le_trans hm hu.1 ++ ++lemma helper_intervalIntegrable_rpow_neg {ε : ℝ} {a b : ℝ} (_hε : 0 < ε) ++ (ha : 1 ≤ a) (hab : a ≤ b) : ++ IntervalIntegrable (fun u : ℝ => u ^ (-1 - ε)) volume a b := by ++ have h0notIcc : (0 : ℝ) ∉ Set.Icc a b := by ++ intro hx ++ have : ¬ a ≤ 0 := not_le.mpr (lt_of_lt_of_le zero_lt_one ha) ++ exact this hx.1 ++ have h0not : (0 : ℝ) ∉ Set.uIcc a b := by ++ simpa [uIcc_of_le hab] using h0notIcc ++ simpa using ++ (intervalIntegral.intervalIntegrable_rpow (μ := volume) (a := a) (b := b) (r := -1 - ε) ++ (Or.inr h0not)) ++ ++lemma helper_one_le_of_mem_Ioc {m n u : ℝ} (hm : 1 ≤ m) (hu : u ∈ Ioc m n) : 1 ≤ u := by ++ exact le_trans hm (le_of_lt hu.1) ++ ++lemma helper_integrableOn_of_bound_Ioc {m n : ℝ} {f : ℝ → ℂ} {g : ℝ → ℝ} ++ (hmeas : AEStronglyMeasurable f (volume.restrict (Ioc m n))) ++ (hbound : ∀ᵐ u ∂(volume.restrict (Ioc m n)), ‖f u‖ ≤ g u) ++ (hg : IntegrableOn g (Ioc m n) volume) : ++ IntegrableOn f (Ioc m n) volume := by ++ ++ let μ := volume.restrict (Ioc m n) ++ ++ have hf0 : Integrable (fun _ : ℝ => (0 : ℂ)) μ := by ++ simp ++ ++ have hg' : Integrable g μ := by ++ simpa [μ] using! hg ++ ++ have hmeas' : AEStronglyMeasurable f μ := by ++ simpa [μ] using hmeas ++ ++ have hineq : ∀ᵐ u ∂μ, ‖(0 : ℂ) - f u‖ ≤ g u := by ++ simpa [μ, sub_eq_add_neg, norm_neg] using hbound ++ ++ have hf : Integrable f μ := ++ MeasureTheory.integrable_of_norm_sub_le (μ := μ) hmeas' hf0 hg' hineq ++ ++ simpa [μ] using! hf ++ ++lemma helper_aestronglyMeasurable_kernel_Ioc (s : ℂ) {m n : ℝ} : ++ AEStronglyMeasurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)) ++ (volume.restrict (Ioc m n)) := by ++ ++ have h1 : AEStronglyMeasurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ)) (volume.restrict (Ioc m n)) := by ++ have hmeas_fract : Measurable (Int.fract : ℝ → ℝ) := by ++ simpa using (measurable_fract : Measurable (Int.fract : ℝ → ℝ)) ++ have hmeas_coe : Measurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ)) := ++ (Complex.measurable_ofReal.comp hmeas_fract) ++ exact hmeas_coe.aestronglyMeasurable ++ ++ have h2 : AEStronglyMeasurable (fun u : ℝ => (u : ℂ) ^ (-s - 1)) (volume.restrict (Ioc m n)) := by ++ have hmeas : Measurable (fun u : ℝ => (u : ℂ) ^ (-s - 1)) := by ++ measurability ++ exact hmeas.aestronglyMeasurable ++ ++ simpa using! (MeasureTheory.AEStronglyMeasurable.mul h1 h2) ++ ++lemma helper_aebound_kernel_Ioc {ε : ℝ} (hε : 0 < ε) (s : ℂ) (hs : ε ≤ s.re) ++ {m n : ℝ} (hm : 1 ≤ m) (_hmn : m ≤ n) : ++ ∀ᵐ u ∂(volume.restrict (Ioc m n)), ++ ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-1 - ε) := by ++ ++ refine ++ ((ae_restrict_iff' (μ := volume) (s := Ioc m n) ++ (p := fun u : ℝ => ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-1 - ε)) ++ measurableSet_Ioc)).2 ?_ ++ ++ refine Filter.Eventually.of_forall ?_ ++ intro u hu ++ have hu1 : 1 ≤ u := helper_one_le_of_mem_Ioc hm hu ++ simpa using (lem_integrandBoundeps ε hε u hu1 s hs) ++ ++lemma helper_integrableOn_rpow_neg_Ioc {ε : ℝ} (hε : 0 < ε) ++ {m n : ℝ} (hm : 1 ≤ m) (hmn : m ≤ n) : ++ IntegrableOn (fun u : ℝ => u ^ (-1 - ε)) (Ioc m n) volume := by ++ have hInt : IntervalIntegrable (fun u : ℝ => u ^ (-1 - ε)) volume m n := ++ helper_intervalIntegrable_rpow_neg (ε := ε) hε hm hmn ++ exact ++ (intervalIntegrable_iff_integrableOn_Ioc_of_le (μ := volume) ++ (f := fun u : ℝ => u ^ (-1 - ε)) hmn).1 hInt ++ ++lemma helper_intervalIntegrable_of_integrableOn_Ioc {f : ℝ → ℂ} {m n : ℝ} ++ (hmn : m ≤ n) (hint : IntegrableOn f (Ioc m n) volume) : ++ IntervalIntegrable f volume m n := by ++ exact (intervalIntegrable_iff_integrableOn_Ioc_of_le (μ := volume) ++ (a := m) (b := n) (f := f) hmn).2 hint ++ ++lemma helper_rpow_neg_nonneg_on {ε a b : ℝ} (_hε : 0 < ε) (ha : 1 ≤ a) (_hab : a ≤ b) : ++ ∀ u ∈ Icc a b, 0 ≤ u ^ (-1 - ε) := by ++ intro u hu ++ have h1u : 1 ≤ u := le_trans ha hu.1 ++ have h0u : 0 ≤ u := le_trans (by norm_num) h1u ++ exact Real.rpow_nonneg h0u (-1 - ε) ++ ++lemma helper_norm_integral_le_integral_norm_of_le {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] ++ {f : ℝ → E} {a b : ℝ} (h : a ≤ b) : ++ ‖∫ u in a..b, f u‖ ≤ ∫ u in a..b, ‖f u‖ := by ++ simpa using (intervalIntegral.norm_integral_le_integral_norm (μ := volume) (f := f) (a := a) (b := b) h) ++ ++lemma helper_tendsto_const_mul_zero (c : ℝ) {f : ℕ → ℝ} ++ (h : Tendsto f atTop (𝓝 0)) : Tendsto (fun n => c * f n) atTop (𝓝 0) := by ++ simpa using (Filter.Tendsto.const_mul (b := c) h) ++ ++lemma helper_limit_norm_le_of_eventual_bound {a : ℕ → ℂ} {l : ℂ} {B : ℝ} ++ (h : Tendsto a atTop (𝓝 l)) (hbound : ∀ᶠ n in atTop, ‖a n‖ ≤ B) : ‖l‖ ≤ B := by ++ have hnorm : Tendsto (fun n => ‖a n‖) atTop (𝓝 ‖l‖) := (Filter.Tendsto.norm h) ++ exact le_of_tendsto hnorm hbound ++ ++lemma lem_integralConvergence (ε : ℝ) (hε : 0 < ε) (s : ℂ) (hs : ε ≤ s.re) : ++ ∃ I : ℂ, ++ Tendsto ++ (fun N : ℕ => ++ ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) ++ atTop (𝓝 I) ++ ∧ ‖I‖ ≤ (1 / ε) := by ++ classical ++ ++ let fC : ℝ → ℂ := fun u => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1) ++ let gR : ℝ → ℝ := fun u => u ^ (-1 - ε) ++ let a : ℕ → ℂ := fun N => ∫ u in (1 : ℝ)..(N : ℝ), fC u ++ let b : ℕ → ℝ := fun m => (1 / ε) * (m : ℝ) ^ (-ε) ++ ++ have hb_nonneg : ∀ m, 0 ≤ b m := by ++ intro m ++ have hm0 : (0 : ℝ) ≤ (m : ℝ) := by exact_mod_cast (Nat.zero_le m) ++ have hpow : 0 ≤ (m : ℝ) ^ (-ε) := Real.rpow_nonneg hm0 _ ++ have hpos : 0 ≤ 1 / ε := by exact le_of_lt (one_div_pos.mpr hε) ++ have := mul_le_mul_of_nonneg_left hpow hpos ++ simpa [b] using this ++ ++ have hb_tendsto : Tendsto b atTop (𝓝 0) := by ++ have hpow := helper_tendsto_nat_rpow_neg (ε := ε) hε ++ have hmul := helper_tendsto_const_mul_zero (c := (1 / ε)) hpow ++ simpa [b] using hmul ++ ++ have h_tail_pointwise : ∀ m n : ℕ, 1 ≤ m → m ≤ n → ‖a n - a m‖ ≤ b m := by ++ intro m n hm1 hmn ++ ++ have hmR : (1 : ℝ) ≤ (m : ℝ) := by exact_mod_cast hm1 ++ have hmnR : (m : ℝ) ≤ (n : ℝ) := by exact_mod_cast hmn ++ ++ have hInt_f_1n : IntervalIntegrable fC volume (1 : ℝ) (n : ℝ) := by ++ ++ have h1nNat : 1 ≤ n := le_trans hm1 hmn ++ have h1nR : (1 : ℝ) ≤ (n : ℝ) := by exact_mod_cast h1nNat ++ have hmeas := helper_aestronglyMeasurable_kernel_Ioc (s := s) (m := (1 : ℝ)) (n := (n : ℝ)) ++ have hgIntOn : IntegrableOn gR (Ioc (1 : ℝ) (n : ℝ)) volume := ++ helper_integrableOn_rpow_neg_Ioc (ε := ε) hε (m := (1 : ℝ)) (n := (n : ℝ)) (hm := by norm_num) (hmn := h1nR) ++ have hbound := helper_aebound_kernel_Ioc (ε := ε) hε s hs (m := (1 : ℝ)) (n := (n : ℝ)) (hm := by norm_num) (_hmn := h1nR) ++ have hintOn := helper_integrableOn_of_bound_Ioc (m := (1 : ℝ)) (n := (n : ℝ)) (f := fC) (g := gR) ++ (hmeas := hmeas) (hbound := hbound) (hg := hgIntOn) ++ exact (intervalIntegrable_iff_integrableOn_Ioc_of_le (μ := volume) ++ (a := (1 : ℝ)) (b := (n : ℝ)) (f := fC) h1nR).2 hintOn ++ have hInt_f_1m : IntervalIntegrable fC volume (1 : ℝ) (m : ℝ) := by ++ have hmeas := helper_aestronglyMeasurable_kernel_Ioc (s := s) (m := (1 : ℝ)) (n := (m : ℝ)) ++ have hgIntOn : IntegrableOn gR (Ioc (1 : ℝ) (m : ℝ)) volume := ++ helper_integrableOn_rpow_neg_Ioc (ε := ε) hε (m := (1 : ℝ)) (n := (m : ℝ)) (hm := by norm_num) (hmn := hmR) ++ have hbound := helper_aebound_kernel_Ioc (ε := ε) hε s hs (m := (1 : ℝ)) (n := (m : ℝ)) (hm := by norm_num) (_hmn := hmR) ++ have hintOn := helper_integrableOn_of_bound_Ioc (m := (1 : ℝ)) (n := (m : ℝ)) (f := fC) (g := gR) ++ (hmeas := hmeas) (hbound := hbound) (hg := hgIntOn) ++ exact (intervalIntegrable_iff_integrableOn_Ioc_of_le (μ := volume) ++ (a := (1 : ℝ)) (b := (m : ℝ)) (f := fC) hmR).2 hintOn ++ have hdiff := helper_integral_interval_sub_left ++ (E := ℂ) (f := fC) (a := (1 : ℝ)) (b := (n : ℝ)) (c := (m : ℝ)) ++ (hab := hInt_f_1n) (hac := hInt_f_1m) ++ have hsub : a n - a m = ∫ u in (m : ℝ)..(n : ℝ), fC u := by ++ simpa [a] using hdiff ++ ++ have hbound_Ioc := helper_aebound_kernel_Ioc (ε := ε) hε s hs ++ (m := (m : ℝ)) (n := (n : ℝ)) (hm := hmR) (_hmn := hmnR) ++ have hbound_Ioc_imp : ∀ᵐ t ∂(volume), t ∈ Ioc (m : ℝ) (n : ℝ) → ‖fC t‖ ≤ gR t := by ++ simpa [fC, gR] using ++ ((ae_restrict_iff' (μ := volume) (s := Ioc (m : ℝ) (n : ℝ)) measurableSet_Ioc).1 hbound_Ioc) ++ ++ have hgInt_mn : IntervalIntegrable gR volume (m : ℝ) (n : ℝ) := ++ (intervalIntegrable_iff_integrableOn_Ioc_of_le (μ := volume) ++ (a := (m : ℝ)) (b := (n : ℝ)) (f := gR) hmnR).2 ++ (helper_integrableOn_rpow_neg_Ioc (ε := ε) hε (m := (m : ℝ)) (n := (n : ℝ)) (hm := hmR) (hmn := hmnR)) ++ ++ have h1 : ‖∫ u in (m : ℝ)..(n : ℝ), fC u‖ ≤ ∫ u in (m : ℝ)..(n : ℝ), gR u := by ++ simpa using ++ (intervalIntegral.norm_integral_le_of_norm_le (μ := volume) ++ (a := (m : ℝ)) (b := (n : ℝ)) (f := fC) (g := gR) ++ (hab := hmnR) (h := hbound_Ioc_imp) (hbound := hgInt_mn)) ++ ++ have h3 : ∫ u in (m : ℝ)..(n : ℝ), gR u ≤ (1 / ε) * (m : ℝ) ^ (-ε) := ++ helper_integral_rpow_le (ε := ε) hε (m := (m : ℝ)) (n := (n : ℝ)) (hm := hmR) (hmn := hmnR) ++ ++ have : ‖∫ u in (m : ℝ)..(n : ℝ), fC u‖ ≤ (1 / ε) * (m : ℝ) ^ (-ε) := ++ le_trans h1 h3 ++ simpa [hsub, b] using this ++ ++ have hbound : ∀ᶠ m in atTop, ∀ᶠ n in atTop, m ≤ n → ‖a n - a m‖ ≤ b m := by ++ have h_m_ge1 : ∀ᶠ m in atTop, 1 ≤ m := eventually_ge_atTop 1 ++ refine h_m_ge1.mono ?_ ++ intro m hm1 ++ have h_n_ge_m : ∀ᶠ n in atTop, m ≤ n := eventually_ge_atTop m ++ exact h_n_ge_m.mono (fun n hmn => by intro hle; exact h_tail_pointwise m n hm1 hle) ++ ++ rcases helper_exists_limit_of_tail_bound a b hb_nonneg hb_tendsto hbound with ⟨I, hT⟩ ++ ++ have h_eventual_bound : ∀ᶠ N in atTop, ‖a N‖ ≤ (1 / ε) := by ++ have hN1 : ∀ᶠ N in atTop, 1 ≤ N := eventually_ge_atTop 1 ++ refine hN1.mono ?_ ++ intro N hNge1 ++ have h1N : (1 : ℝ) ≤ (N : ℝ) := by exact_mod_cast hNge1 ++ ++ have hbound_Ioc := helper_aebound_kernel_Ioc (ε := ε) hε s hs (m := (1 : ℝ)) (n := (N : ℝ)) (hm := by norm_num) (_hmn := h1N) ++ have hbound_Ioc_imp : ∀ᵐ t ∂(volume), t ∈ Ioc (1 : ℝ) (N : ℝ) → ‖fC t‖ ≤ gR t := by ++ simpa [fC, gR] using ++ ((ae_restrict_iff' (μ := volume) (s := Ioc (1 : ℝ) (N : ℝ)) measurableSet_Ioc).1 hbound_Ioc) ++ ++ have hgInt_1N : IntervalIntegrable gR volume (1 : ℝ) (N : ℝ) := ++ (intervalIntegrable_iff_integrableOn_Ioc_of_le (μ := volume) ++ (a := (1 : ℝ)) (b := (N : ℝ)) (f := gR) h1N).2 ++ (helper_integrableOn_rpow_neg_Ioc (ε := ε) hε (m := (1 : ℝ)) (n := (N : ℝ)) (hm := by norm_num) (hmn := h1N)) ++ ++ have h1 : ‖∫ u in (1 : ℝ)..(N : ℝ), fC u‖ ≤ ∫ u in (1 : ℝ)..(N : ℝ), gR u := by ++ simpa [a] using ++ (intervalIntegral.norm_integral_le_of_norm_le (μ := volume) ++ (a := (1 : ℝ)) (b := (N : ℝ)) (f := fC) (g := gR) ++ (hab := h1N) (h := hbound_Ioc_imp) (hbound := hgInt_1N)) ++ ++ have h3 : ∫ u in (1 : ℝ)..(N : ℝ), gR u ≤ (1 / ε) := by ++ have := helper_integral_rpow_le (ε := ε) hε (m := (1 : ℝ)) (n := (N : ℝ)) (hm := by norm_num) (hmn := h1N) ++ simpa [one_div, Real.one_rpow, one_mul] using this ++ have : ‖a N‖ ≤ (1 / ε) := by exact le_trans h1 h3 ++ exact this ++ ++ have hIle : ‖I‖ ≤ (1 / ε) := ++ helper_limit_norm_le_of_eventual_bound (a := a) (l := I) (B := 1 / ε) hT h_eventual_bound ++ ++ refine ⟨I, ?_, hIle⟩ ++ simpa [a, fC] using hT ++ ++lemma helper_tendsto_zetaPartialSum_to_zeta (s : ℂ) (hs : 1 < s.re) : ++ Tendsto (fun N : ℕ => zetaPartialSum s N) atTop (𝓝 (riemannZeta s)) := by ++ classical ++ ++ set g : ℕ → ℂ := fun n => if n = 0 then 0 else (n : ℂ) ^ (-s) ++ set h : ℕ → ℂ := fun n => (n + 1 : ℂ) ^ (-s) ++ ++ have hsne : s ≠ 0 := by ++ intro h0 ++ have : (0 : ℝ) < s.re := lt_trans (show (0 : ℝ) < 1 by norm_num) hs ++ simpa [h0] using (ne_of_gt this) ++ ++ have hsum_div : Summable (fun n : ℕ => 1 / (n : ℂ) ^ s) := ++ (Complex.summable_one_div_nat_cpow (p := s)).2 hs ++ have hgSumm : Summable g := by ++ simpa [g, one_div_nat_cpow_eq_ite_cpow_neg s hsne] using hsum_div ++ ++ have h_eq_tail : (fun n => g (n + 1)) = h := by ++ funext n; simp [g, h] ++ have hhSumm : Summable h := by ++ have : Summable (fun n : ℕ => g (n + 1)) := (summable_nat_add_iff (f := g) (k := 1)).2 hgSumm ++ simpa [h_eq_tail] using this ++ ++ have hg0 : g 0 = 0 := by simp [g] ++ have h_tsum_eq : (∑' n : ℕ, h n) = ∑' n : ℕ, g n := by ++ have hzero_add := (Summable.tsum_eq_zero_add (f := g) hgSumm) ++ ++ have : (∑' n : ℕ, g n) = ∑' n : ℕ, g (n + 1) := by ++ simpa [hg0, add_comm] using hzero_add ++ simpa [h_eq_tail] using this.symm ++ ++ have hzeta : riemannZeta s = ∑' n : ℕ, g n := by ++ simpa [g] using lem_zetaLimit s hs ++ ++ have h_tendsto : Tendsto (fun N : ℕ => ∑ n ∈ Finset.range N, h n) atTop (𝓝 (∑' n, h n)) := ++ (Summable.tendsto_sum_tsum_nat hhSumm) ++ ++ have htsumeq : (∑' n, h n) = riemannZeta s := h_tsum_eq.trans hzeta.symm ++ simpa [zetaPartialSum, htsumeq, h] using h_tendsto ++ ++lemma integrableOn_of_ae_bound {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] ++ {f : ℝ → E} {g : ℝ → ℝ} {s : Set ℝ} ++ (hfm : AEStronglyMeasurable f (volume.restrict s)) ++ (hgint : IntegrableOn g s) ++ (hbound : ∀ᵐ x ∂(volume.restrict s), ‖f x‖ ≤ g x) : ++ IntegrableOn f s := by ++ have hg' : Integrable g (volume.restrict s) := by ++ simpa [IntegrableOn] using hgint ++ have hf' : Integrable f (volume.restrict s) := ++ MeasureTheory.Integrable.mono' (μ := volume.restrict s) hg' hfm hbound ++ simpa [IntegrableOn] using hf' ++ ++lemma kernel_aestronglyMeasurable_on_Ioi (s : ℂ) (a : ℝ) : ++ AEStronglyMeasurable (fun u : ℝ => (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) (volume.restrict (Ioi a)) := by ++ ++ have hmeas_fract : Measurable (fun u : ℝ => (Int.fract u : ℝ)) := by ++ simpa using (measurable_fract : Measurable (Int.fract : ℝ → ℝ)) ++ have hmeas_fractC : Measurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ)) := ++ hmeas_fract.complex_ofReal ++ have hmeas_cpow : Measurable (fun u : ℝ => (u : ℂ) ^ (-s - 1)) := by ++ have hmeas_ofReal : Measurable (fun u : ℝ => (u : ℂ)) := Complex.measurable_ofReal ++ simpa using hmeas_ofReal.pow_const (-s - 1) ++ have hmeas : Measurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)) := ++ hmeas_fractC.mul hmeas_cpow ++ ++ simpa using hmeas.aestronglyMeasurable ++ ++lemma kernel_ae_bound_on_Ioi (s : ℂ) : ++ ∀ᵐ u ∂(volume.restrict (Ioi (1 : ℝ))), ++ ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-s.re - 1) := by ++ ++ let p : ℝ → Prop := fun u => ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-s.re - 1) ++ ++ have hAll : ∀ u ∈ Ioi (1 : ℝ), p u := by ++ intro u hu ++ have hu' : (1 : ℝ) ≤ u := le_of_lt hu ++ dsimp [p] ++ simpa using (lem_integrandBound u hu' s) ++ ++ have hAE : ∀ᵐ u ∂volume, u ∈ Ioi (1 : ℝ) → p u := ++ MeasureTheory.ae_of_all _ hAll ++ ++ have hiff : ++ (∀ᵐ u ∂volume.restrict (Ioi (1 : ℝ)), p u) ↔ ∀ᵐ u ∂volume, u ∈ Ioi (1 : ℝ) → p u := ++ (MeasureTheory.ae_restrict_iff' (μ := volume) (s := Ioi (1 : ℝ)) (p := p)) measurableSet_Ioi ++ exact hiff.mpr hAE ++ ++lemma helper_intervalIntegral_tendstoIoi_kernel (s : ℂ) (hs : 1 < s.re) : ++ Tendsto (fun N : ℕ => ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) atTop ++ (𝓝 (∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1))) := by ++ ++ have hfm : AEStronglyMeasurable (fun u : ℝ => (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) ++ (volume.restrict (Ioi (1 : ℝ))) := by ++ simpa using kernel_aestronglyMeasurable_on_Ioi (s := s) (a := (1 : ℝ)) ++ have hbound' : ∀ᵐ u ∂(volume.restrict (Ioi (1 : ℝ))), ++ ‖(Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)‖ ≤ u ^ (-s.re - 1) := by ++ ++ simpa using kernel_ae_bound_on_Ioi (s := s) ++ have hlt : (-s.re - 1) < (-1 : ℝ) := by linarith ++ have hpos : 0 < (1 : ℝ) := by norm_num ++ have hgint : IntegrableOn (fun u : ℝ => u ^ (-s.re - 1)) (Ioi (1 : ℝ)) := by ++ simpa using integrableOn_Ioi_rpow_of_lt (a := (-s.re - 1)) (c := (1 : ℝ)) hlt hpos ++ have hint : IntegrableOn (fun u : ℝ => (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) (Ioi (1 : ℝ)) := by ++ ++ exact integrableOn_of_ae_bound (s := Ioi (1 : ℝ)) hfm hgint hbound' ++ ++ have hb : Tendsto (fun N : ℕ => (N : ℝ)) atTop atTop := tendsto_natCast_atTop_atTop ++ simpa using ++ (MeasureTheory.intervalIntegral_tendsto_integral_Ioi (μ := volume) ++ (f := fun u : ℝ => (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) (a := (1 : ℝ)) ++ (b := fun N : ℕ => (N : ℝ)) hint hb) ++ ++lemma helper_zetaNfinal (s : ℂ) (hs : s ≠ 1) (N : ℕ) (hN : 1 ≤ N) : ++ zetaPartialSum s N ++ = (N : ℂ) ^ (1 - s) / (1 - s) + 1 + 1 / (s - 1) ++ - s * ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) := by ++ simpa using (lem_zetaNfinal s hs N hN) ++ ++lemma helper_eventually_eq_from_zetaNfinal (s : ℂ) (hs : s ≠ 1) : ++ ∀ᶠ N in atTop, ++ zetaPartialSum s N ++ = (N : ℂ) ^ (1 - s) / (1 - s) + 1 + 1 / (s - 1) ++ - s * ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) := by ++ have hEv : ∀ᶠ N : ℕ in atTop, 1 ≤ N := Filter.eventually_ge_atTop (1 : ℕ) ++ refine hEv.mono ?_ ++ intro N hN ++ simpa using (helper_zetaNfinal s hs N hN) ++ ++lemma helper_limit_scaled_cpow (s : ℂ) (hs : 1 < s.re) (_hsne : s ≠ 1) : ++ Tendsto (fun N : ℕ => (N : ℂ) ^ (1 - s) / (1 - s)) atTop (𝓝 0) := by ++ have h := lem_limitTerm1 s hs ++ have h' := (Filter.Tendsto.const_mul (b := (1 / (1 - s))) h) ++ simpa [div_eq_mul_inv, mul_comm] using h' ++ ++lemma helper_tendsto_const_mul {f : ℕ → ℂ} {l : ℂ} (c : ℂ) ++ (h : Tendsto f atTop (𝓝 l)) : Tendsto (fun n => c * f n) atTop (𝓝 (c * l)) := by ++ exact h.const_mul c ++ ++lemma helper_tendsto_add {f g : ℕ → ℂ} {a b : ℂ} ++ (hf : Tendsto f atTop (𝓝 a)) (hg : Tendsto g atTop (𝓝 b)) : ++ Tendsto (fun n => f n + g n) atTop (𝓝 (a + b)) := by ++ ++ have hpair : Tendsto (fun n => (f n, g n)) atTop (𝓝 (a, b)) := by ++ simpa using (hf.prodMk_nhds hg) ++ have hadd : Continuous (fun p : ℂ × ℂ => p.1 + p.2) := by ++ simpa using! (continuous_fst.add continuous_snd) ++ simpa using! ((hadd.tendsto (a, b)).comp hpair) ++ ++lemma helper_tendsto_neg {f : ℕ → ℂ} {a : ℂ} ++ (hf : Tendsto f atTop (𝓝 a)) : Tendsto (fun n => - f n) atTop (𝓝 (-a)) := by ++ simpa only [Function.comp_def] using! ((continuous_neg.tendsto a).comp hf) ++ ++lemma helper_tendsto_sub {f g : ℕ → ℂ} {a b : ℂ} ++ (hf : Tendsto f atTop (𝓝 a)) (hg : Tendsto g atTop (𝓝 b)) : ++ Tendsto (fun n => f n - g n) atTop (𝓝 (a - b)) := by ++ have hneg : Tendsto (fun n => - g n) atTop (𝓝 (-b)) := ++ helper_tendsto_neg (f := g) (a := b) hg ++ simpa [sub_eq_add_neg] using ++ helper_tendsto_add (f := f) (g := fun n => - g n) hf hneg ++ ++lemma lem_zetaFormula (s : ℂ) (hs : 1 < s.re) : ++ riemannZeta s ++ = 1 + 1 / (s - 1) ++ - s * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) := by ++ classical ++ ++ have hsne : s ≠ 1 := by ++ intro h ++ have hlt : 1 < (1 : ℝ) := by simp [h, Complex.one_re] at hs ++ exact (lt_irrefl _ ) hlt ++ ++ let G : ℕ → ℂ := fun N => ++ (N : ℂ) ^ (1 - s) / (1 - s) + 1 + 1 / (s - 1) ++ - s * ∫ u in (1 : ℝ)..N, (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) ++ ++ have hEv : ∀ᶠ N in atTop, zetaPartialSum s N = G N := by ++ simpa [G] using helper_eventually_eq_from_zetaNfinal s hsne ++ ++ have h_ps : Tendsto (fun N : ℕ => zetaPartialSum s N) atTop (𝓝 (riemannZeta s)) := ++ helper_tendsto_zetaPartialSum_to_zeta s hs ++ ++ have hG_to_zeta : Tendsto G atTop (𝓝 (riemannZeta s)) := by ++ have hcongr := (Filter.tendsto_congr' (hl := hEv) : ++ Tendsto (fun N : ℕ => zetaPartialSum s N) atTop (𝓝 (riemannZeta s)) ↔ ++ Tendsto G atTop (𝓝 (riemannZeta s))) ++ exact hcongr.mp h_ps ++ ++ have hA : Tendsto (fun N : ℕ => (N : ℂ) ^ (1 - s) / (1 - s)) atTop (𝓝 0) := ++ helper_limit_scaled_cpow s hs hsne ++ ++ have hK : Tendsto (fun _ : ℕ => (1 : ℂ) + 1 / (s - 1)) atTop (𝓝 ((1 : ℂ) + 1 / (s - 1))) := ++ tendsto_const_nhds ++ ++ have hInt : Tendsto (fun N : ℕ => ∫ u in (1 : ℝ)..N, ++ (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) atTop ++ (𝓝 (∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1))) := ++ helper_intervalIntegral_tendstoIoi_kernel s hs ++ ++ have hIntMul : Tendsto (fun N : ℕ => s * ∫ u in (1 : ℝ)..N, ++ (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) atTop ++ (𝓝 (s * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1))) := ++ helper_tendsto_const_mul (c := s) hInt ++ ++ set Aseq : ℕ → ℂ := fun N => (N : ℂ) ^ (1 - s) / (1 - s) ++ set Kseq : ℕ → ℂ := fun _ => (1 : ℂ) + 1 / (s - 1) ++ have hA2 : Tendsto Aseq atTop (𝓝 0) := by simpa [Aseq] using hA ++ have hK2 : Tendsto Kseq atTop (𝓝 ((1 : ℂ) + 1 / (s - 1))) := by simp [Kseq] ++ have hSum : Tendsto (fun N => Aseq N + Kseq N) atTop (𝓝 (0 + ((1 : ℂ) + 1 / (s - 1)))) := ++ helper_tendsto_add (hf := hA2) (hg := hK2) ++ set Iseq : ℕ → ℂ := fun N => s * ∫ u in (1 : ℝ)..N, ++ (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) ++ have hIseq : Tendsto Iseq atTop (𝓝 (s * ∫ u in Ioi (1 : ℝ), ++ (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1))) := by ++ simpa [Iseq] using hIntMul ++ have hG_limit : Tendsto G atTop ++ (𝓝 ((0 + ((1 : ℂ) + 1 / (s - 1))) ++ - (s * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)))) := by ++ have hSub := helper_tendsto_sub (hf := hSum) (hg := hIseq) ++ ++ have hGdef : (fun N => (Aseq N + Kseq N) - Iseq N) = G := by ++ funext N; simp [Aseq, Kseq, Iseq, G, add_comm, add_left_comm, add_assoc, sub_eq_add_neg] ++ simpa [hGdef] ++ using hSub ++ ++ have huniq := ++ tendsto_nhds_unique (f := G) (l := atTop) ++ (a := riemannZeta s) ++ (b := ((0 + ((1 : ℂ) + 1 / (s - 1))) ++ - (s * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)))) ++ (ha := hG_to_zeta) (hb := hG_limit) ++ ++ simpa [zero_add, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using huniq ++ ++lemma lem_zetaanalOnnot1 : AnalyticOn ℂ riemannZeta {s : ℂ | s ≠ 1} := by ++ ++ have hset : {s : ℂ | s ≠ 1} = ({1} : Set ℂ)ᶜ := by ++ ext z; simp ++ have hopen : IsOpen ({s : ℂ | s ≠ 1}) := by ++ simp [hset] ++ ++ have hdiff : DifferentiableOn ℂ riemannZeta {s : ℂ | s ≠ 1} := by ++ intro z hz ++ ++ simpa using (differentiableAt_riemannZeta (by simpa [Set.mem_ofPred_eq] using hz)).differentiableWithinAt ++ simpa [Complex.analyticOn_iff_differentiableOn hopen] using hdiff ++ ++lemma lem_zetaanalS : (let S := {s : ℂ | s ≠ 1}; AnalyticOn ℂ riemannZeta S) := by exact lem_zetaanalOnnot1 ++ ++lemma lem_S_isOpen : (let S := {s : ℂ | s ≠ 1}; IsOpen S) := by ++ ++ have h : {s : ℂ | s ≠ 1} = {(1 : ℂ)}ᶜ := by ++ ext s; simp [Set.mem_compl_iff, Set.mem_singleton_iff] ++ rw [h] ++ exact isOpen_compl_singleton ++ ++lemma lem_T_isOpen : (let S := {s : ℂ | s ≠ 1}; let T := {s : ℂ | s ∈ S ∧ 1/10 < s.re}; IsOpen T) := by ++ ++ show IsOpen {s : ℂ | s ≠ 1 ∧ 1/10 < s.re} ++ ++ apply IsOpen.and ++ · ++ exact lem_S_isOpen ++ · ++ ++ have h_eq : {s : ℂ | 1/10 < s.re} = Complex.re ⁻¹' (Set.Ioi (1/10)) := by ++ ext s ++ simp [Set.mem_preimage, Set.mem_Ioi] ++ rw [h_eq] ++ exact Complex.continuous_re.isOpen_preimage (Set.Ioi (1/10)) isOpen_Ioi ++ ++lemma helper_T_open : (let S := {s : ℂ | s ≠ 1}; let T := {s : ℂ | s ∈ S ∧ 1/10 < s.re}; IsOpen T) := by ++ classical ++ ++ intro S T ++ ++ have hSopen : IsOpen S := by simpa using lem_S_isOpen ++ ++ have hHalfplane : IsOpen {s : ℂ | (1 / 10 : ℝ) < s.re} := by ++ have : IsOpen ((fun s : ℂ => s.re) ⁻¹' Ioi (1 / 10 : ℝ)) := ++ IsOpen.preimage (hf := Complex.continuous_re) (t := Ioi (1 / 10 : ℝ)) (h := isOpen_Ioi) ++ simpa [Set.preimage, Ioi] using this ++ ++ have hInter : IsOpen (S ∩ {s : ℂ | (1 / 10 : ℝ) < s.re}) := hSopen.inter hHalfplane ++ ++ simpa [T, Set.ofPred_and] using hInter ++ ++lemma open_mem_interior_of_isOpen {X : Type*} [TopologicalSpace X] {U : Set X} (hU : IsOpen U) {x : X} (hx : x ∈ U) : x ∈ interior U := by simpa [hU.interior_eq] using hx ++ ++lemma isOpen_halfplane_re_gt (a : ℝ) : IsOpen {z : ℂ | a < z.re} := by ++ simpa [Set.mem_ofPred_eq] using ++ (isOpen_lt (hf := continuous_const) (hg := Complex.continuous_re)) ++ ++lemma T_eq_inter_S_half (S T : Set ℂ) (_hS : S = {s : ℂ | s ≠ 1}) (hT : T = {s : ℂ | s ∈ S ∧ (1/10 : ℝ) < s.re}) : ++ T = S ∩ {s : ℂ | (1/10 : ℝ) < s.re} := by ++ classical ++ ext z ++ simp [hT, Set.inter_def] ++ ++lemma inter_compl_singleton_eq_diff {α : Type*} [DecidableEq α] (A : Set α) (x : α) : ++ A ∩ ({x} : Set α)ᶜ = A \ ({x} : Set α) := by ++ ext z; simp [Set.mem_inter_iff, Set.mem_singleton_iff] ++ ++lemma joinedIn_of_path_forall_mem {s : Set ℂ} {x y : ℂ} ++ (γ : Path x y) (hγ : ∀ t, γ t ∈ s) : JoinedIn s x y := by ++ exact ⟨γ, hγ⟩ ++ ++lemma path_forall_mem_symm {x y : ℂ} {P : ℂ → Prop} (γ : Path x y) ++ (h : ∀ t, P (γ t)) : ∀ t, P (γ.symm t) := by ++ intro t ++ simpa [Path.symm] using (h (unitInterval.symm t)) ++ ++lemma isPathConnected_punctured_halfplane_re_gt (a : ℝ) (p : ℂ) (hp : a < p.re) : ++ IsPathConnected ({z : ℂ | a < z.re} \ ({p} : Set ℂ)) := by ++ classical ++ ++ let S1 : Set ℂ := {z : ℂ | a < z.re ∧ z.im < p.im} ++ let S2 : Set ℂ := {z : ℂ | a < z.re ∧ z.re < p.re} ++ let S3 : Set ℂ := {z : ℂ | a < z.re ∧ p.im < z.im} ++ let S4 : Set ℂ := {z : ℂ | p.re < z.re} ++ ++ have hS1conv : Convex ℝ S1 := by ++ have h1 : Convex ℝ {z : ℂ | a < z.re} := convex_halfSpace_re_gt (r := a) ++ have h2 : Convex ℝ {z : ℂ | z.im < p.im} := convex_halfSpace_im_lt (r := p.im) ++ simpa [S1, Set.ofPred_and] using h1.inter h2 ++ have hS2conv : Convex ℝ S2 := by ++ have h1 : Convex ℝ {z : ℂ | a < z.re} := convex_halfSpace_re_gt (r := a) ++ have h2 : Convex ℝ {z : ℂ | z.re < p.re} := convex_halfSpace_re_lt (r := p.re) ++ simpa [S2, Set.ofPred_and] using h1.inter h2 ++ have hS3conv : Convex ℝ S3 := by ++ have h1 : Convex ℝ {z : ℂ | a < z.re} := convex_halfSpace_re_gt (r := a) ++ have h2 : Convex ℝ {z : ℂ | p.im < z.im} := convex_halfSpace_im_gt (r := p.im) ++ simpa [S3, Set.ofPred_and] using h1.inter h2 ++ have hS4conv : Convex ℝ S4 := by ++ simpa [S4] using (convex_halfSpace_re_gt (r := p.re)) ++ ++ have hS1ne : S1.Nonempty := by ++ refine ⟨((max a p.re) + 1 : ℝ) + (p.im - 1) * Complex.I, ?_⟩ ++ have h1 : a < (max a p.re) + 1 := by ++ have : a ≤ max a p.re := le_max_left _ _ ++ exact lt_of_le_of_lt this (by linarith) ++ have h2 : (p.im - 1) < p.im := by linarith ++ simpa [S1, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im] ++ using And.intro h1 h2 ++ have hS2ne : S2.Nonempty := by ++ refine ⟨((a + p.re) / 2 : ℝ) + (p.im : ℝ) * Complex.I, ?_⟩ ++ have h1 : a < (a + p.re) / 2 := by linarith ++ have h2 : (a + p.re) / 2 < p.re := by linarith ++ simpa [S2, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im] ++ using And.intro h1 h2 ++ have hS3ne : S3.Nonempty := by ++ refine ⟨((max a p.re) + 1 : ℝ) + (p.im + 1) * Complex.I, ?_⟩ ++ have h1 : a < (max a p.re) + 1 := by ++ have : a ≤ max a p.re := le_max_left _ _ ++ exact lt_of_le_of_lt this (by linarith) ++ have h2 : p.im < (p.im + 1) := by linarith ++ simpa [S3, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im] ++ using And.intro h1 h2 ++ have hS4ne : S4.Nonempty := by ++ refine ⟨(p.re + 1 : ℝ) + (0 : ℝ) * Complex.I, ?_⟩ ++ have : p.re < p.re + 1 := by linarith ++ simp [S4, Complex.add_re] ++ ++ have hS1pc : IsPathConnected S1 := (hS1conv.isPathConnected hS1ne) ++ have hS2pc : IsPathConnected S2 := (hS2conv.isPathConnected hS2ne) ++ have hS3pc : IsPathConnected S3 := (hS3conv.isPathConnected hS3ne) ++ have hS4pc : IsPathConnected S4 := (hS4conv.isPathConnected hS4ne) ++ ++ let A : Set ℂ := S1 ∪ S2 ++ let B : Set ℂ := S3 ∪ S4 ++ ++ have hS1S2_int : (S1 ∩ S2).Nonempty := by ++ refine ⟨((a + p.re) / 2 : ℝ) + (p.im - (1/2)) * Complex.I, ?_⟩ ++ have h1a : a < (a + p.re) / 2 := by linarith ++ have h1b : (p.im - (1/2)) < p.im := by linarith ++ have h2a : a < (a + p.re) / 2 := by linarith ++ have h2b : (a + p.re) / 2 < p.re := by linarith ++ constructor ++ · ++ simpa [S1, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im] ++ using And.intro h1a h1b ++ · ++ simpa [S2, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im] ++ using And.intro h2a h2b ++ have hApc : IsPathConnected A := ++ IsPathConnected.union (U := S1) (V := S2) hS1pc hS2pc (by ++ rcases hS1S2_int with ⟨z, hz⟩; exact ⟨z, hz⟩) ++ have hS3S4_int : (S3 ∩ S4).Nonempty := by ++ refine ⟨(p.re + 1 : ℝ) + (p.im + 1) * Complex.I, ?_⟩ ++ have h3a : a < p.re + 1 := lt_trans hp (by linarith) ++ have h3b : p.im < p.im + 1 := by linarith ++ have h4 : p.re < p.re + 1 := by linarith ++ constructor ++ · ++ simpa [S3, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im] ++ using And.intro h3a h3b ++ · ++ simp [S4, Complex.add_re, Complex.mul_re] ++ have hBpc : IsPathConnected B := ++ IsPathConnected.union (U := S3) (V := S4) hS3pc hS4pc (by ++ rcases hS3S4_int with ⟨z, hz⟩; exact ⟨z, hz⟩) ++ ++ have hABint : (A ∩ B).Nonempty := by ++ refine ⟨(p.re + 1 : ℝ) + (p.im - 1) * Complex.I, ?_⟩ ++ constructor ++ · ++ refine Or.inl ?_ ++ have h1 : a < p.re + 1 := lt_trans hp (by linarith) ++ have h2 : (p.im - 1) < p.im := by linarith ++ simpa [S1, Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im] ++ using And.intro h1 h2 ++ · ++ refine Or.inr ?_ ++ have h4 : p.re < p.re + 1 := by linarith ++ simp [S4, Complex.add_re, Complex.mul_re] ++ ++ have hUnionPC : IsPathConnected (A ∪ B) := ++ IsPathConnected.union (U := A) (V := B) hApc hBpc (by ++ rcases hABint with ⟨z, hz⟩; exact ⟨z, hz⟩) ++ ++ have hcover : ({z : ℂ | a < z.re} \ ({p} : Set ℂ)) = A ∪ B := by ++ ext z; constructor ++ · intro hz ++ rcases hz with ⟨hzH, hznot⟩ ++ ++ rcases lt_trichotomy z.re p.re with hlt | heq | hgt ++ · ++ exact Or.inl (Or.inr ⟨hzH, hlt⟩) ++ · ++ rcases lt_trichotomy z.im p.im with himlt | himeq | himgt ++ · ++ exact Or.inl (Or.inl ⟨hzH, himlt⟩) ++ · ++ have hz_eq : z = p := by ++ ++ have hzdecomp : (z.re : ℂ) + (z.im : ℝ) * Complex.I = z := by ++ simp ++ have hpdecomp : (p.re : ℂ) + (p.im : ℝ) * Complex.I = p := by ++ simp ++ have : (z.re : ℂ) + (z.im : ℝ) * Complex.I = (p.re : ℂ) + (p.im : ℝ) * Complex.I := by ++ ++ simp [heq, himeq] ++ ++ simpa [hzdecomp, hpdecomp] using this ++ have : z ∈ ({p} : Set ℂ) := by simp [Set.mem_singleton_iff, hz_eq] ++ exact (hznot this).elim ++ · ++ exact Or.inr (Or.inl ⟨hzH, himgt⟩) ++ · ++ exact Or.inr (Or.inr hgt) ++ · intro hz ++ ++ have hzH : a < z.re := by ++ rcases hz with hA | hB ++ · rcases hA with hS1 | hS2 ++ · exact hS1.1 ++ · exact hS2.1 ++ · rcases hB with hS3 | hS4 ++ · exact hS3.1 ++ · exact lt_trans hp hS4 ++ have hzneq : z ≠ p := by ++ rcases hz with hA | hB ++ · rcases hA with hS1 | hS2 ++ · ++ intro h ++ have : z.im = p.im := by simp [h] ++ have : z.im < z.im := by simpa [this] using hS1.2 ++ exact lt_irrefl _ this ++ · ++ intro h ++ have : z.re = p.re := by simp [h] ++ exact (ne_of_lt hS2.2) this ++ · rcases hB with hS3 | hS4 ++ · ++ intro h ++ have : p.im = z.im := by simp [h] ++ have : z.im < z.im := by simpa [this] using hS3.2 ++ exact lt_irrefl _ this ++ · ++ intro h ++ have : p.re = z.re := by simp [h] ++ exact (ne_of_gt hS4) this.symm ++ exact And.intro hzH (by intro hzmem; exact hzneq (by simpa [Set.mem_singleton_iff] using hzmem)) ++ ++ simpa [hcover] using hUnionPC ++ ++lemma inter_compl_singleton_eq_diff' {α : Type*} [DecidableEq α] (A : Set α) (x : α) : ++ A ∩ ({x} : Set α)ᶜ = A \ ({x} : Set α) := by ++ ext z; simp [Set.mem_inter_iff, Set.mem_singleton_iff] ++ ++lemma lem_T_isPreconnected : (let S := {s : ℂ | s ≠ 1}; let T := {s : ℂ | s ∈ S ∧ 1/10 < s.re}; IsPreconnected T) := by ++ classical ++ ++ let S : Set ℂ := {s : ℂ | s ≠ 1} ++ let T : Set ℂ := {s : ℂ | s ∈ S ∧ (1/10 : ℝ) < s.re} ++ ++ have hTinter : T = S ∩ {s : ℂ | (1/10 : ℝ) < s.re} := by ++ simpa using (T_eq_inter_S_half S T (by rfl) (by rfl)) ++ ++ have hScompl : S = ({(1 : ℂ)} : Set ℂ)ᶜ := by ++ ext z; simp [S] ++ ++ have hTdiff : T = {s : ℂ | (1/10 : ℝ) < s.re} \ (({(1 : ℂ)} : Set ℂ)) := by ++ have : T = {s : ℂ | (1/10 : ℝ) < s.re} ∩ S := by ++ simpa [Set.inter_comm] using hTinter ++ ++ simpa [hScompl, inter_compl_singleton_eq_diff] using this ++ ++ have hp : (1/10 : ℝ) < (1 : ℂ).re := by ++ simpa using (by norm_num : (1/10 : ℝ) < (1 : ℝ)) ++ ++ have hpc : IsPathConnected ({z : ℂ | (1/10 : ℝ) < z.re} \ (({(1 : ℂ)} : Set ℂ))) := ++ isPathConnected_punctured_halfplane_re_gt (a := (1/10 : ℝ)) (p := (1 : ℂ)) (hp := hp) ++ ++ have hpcT : IsPathConnected T := by ++ simpa [hTdiff] using hpc ++ ++ have hconnT : IsConnected T := hpcT.isConnected ++ exact (IsConnected.isPreconnected (s := T) hconnT) ++ ++lemma hasDerivAt_param_cpow_neg_one (u : ℝ) (hu : 0 < u) (z : ℂ) : ++ HasDerivAt (fun w : ℂ => (u : ℂ) ^ (-w - 1)) (-(Real.log u) * (u : ℂ) ^ (-z - 1)) z := by ++ ++ have hcu : (u : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr (ne_of_gt hu) ++ ++ have hId : HasDerivAt (fun w : ℂ => w) (1 : ℂ) z := by simpa using! (hasDerivAt_id (x := z)) ++ have hneg : HasDerivAt (fun w : ℂ => -w) (-1 : ℂ) z := by simpa using! hId.neg ++ have hf : HasDerivAt (fun w : ℂ => -w - 1) (-1 : ℂ) z := by ++ ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using hneg.add_const (-1 : ℂ) ++ ++ have h := (HasDerivAt.const_cpow (c := (u : ℂ)) (hf := hf) (h0 := Or.inl hcu)) ++ ++ have clog : Complex.log (u : ℂ) = (Real.log u : ℂ) := by ++ simpa using (Complex.ofReal_log (x := u) (hx := le_of_lt hu)).symm ++ simpa [clog, mul_comm, mul_left_comm, mul_assoc] using h ++ ++lemma integrableOn_t_mul_exp_neg (ε : ℝ) (hε : 0 < ε) : IntegrableOn (fun t : ℝ => t * Real.exp (- ε * t)) (Ioi (0 : ℝ)) := by ++ ++ have h := integrableOn_rpow_mul_exp_neg_mul_rpow (p := (1 : ℝ)) (s := (1 : ℝ)) (b := ε) ++ (hs := by norm_num) (hp := by norm_num) (hb := hε) ++ ++ simpa [Real.rpow_one] using h ++ ++lemma aestronglyMeasurable_kernel_param_deriv (z : ℂ) : ++ AEStronglyMeasurable (fun u : ℝ => -((Real.log u) : ℂ) * (((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1))) (volume.restrict (Ioi (1 : ℝ))) := by ++ ++ let μ := volume.restrict (Ioi (1 : ℝ)) ++ ++ have hmeas_logR : Measurable (fun u : ℝ => Real.log u) := Real.measurable_log ++ have hmeas_logC : Measurable (fun u : ℝ => ((Real.log u) : ℂ)) := hmeas_logR.complex_ofReal ++ have hmeas_neg : Measurable (fun u : ℝ => -((Real.log u) : ℂ)) := hmeas_logC.neg ++ have h1 : AEStronglyMeasurable (fun u : ℝ => -((Real.log u) : ℂ)) μ := by ++ simpa [μ] using hmeas_neg.aestronglyMeasurable ++ ++ have h2 : AEStronglyMeasurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1)) μ := by ++ simpa [μ] using kernel_aestronglyMeasurable_on_Ioi (s := z) (a := (1 : ℝ)) ++ ++ have hmul : AEStronglyMeasurable ++ (fun u : ℝ => (-((Real.log u) : ℂ)) * (((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1))) ++ μ := (MeasureTheory.AEStronglyMeasurable.mul h1 h2) ++ simpa [μ] using hmul ++ ++lemma kernel_deriv_norm_bound_on_ball (ε : ℝ) (u : ℝ) (hu : 1 < u) (x : ℂ) (hx : ε ≤ x.re) : ++ ‖-((Real.log u) : ℂ) * (((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1))‖ ≤ Real.log u * u ^ (-1 - ε) := by ++ ++ have hu1 : (1 : ℝ) ≤ u := le_of_lt hu ++ ++ have hinner1 : ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1)‖ ≤ u ^ (-x.re - 1) := by ++ simpa using (lem_integrandBound u hu1 x) ++ have hexp_le : -x.re - 1 ≤ -1 - ε := by linarith ++ have hmono : u ^ (-x.re - 1) ≤ u ^ (-1 - ε) := ++ Real.rpow_le_rpow_of_exponent_le hu1 hexp_le ++ have hinner : ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1)‖ ≤ u ^ (-1 - ε) := ++ le_trans hinner1 hmono ++ ++ have hmul : ‖-((Real.log u) : ℂ) * (((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1))‖ ++ = ‖-((Real.log u) : ℂ)‖ * ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1)‖ := by ++ simp ++ have hnorm_nonneg : 0 ≤ ‖-((Real.log u) : ℂ)‖ := by simp ++ have hmul_le : ‖-((Real.log u) : ℂ)‖ * ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1)‖ ++ ≤ ‖-((Real.log u) : ℂ)‖ * (u ^ (-1 - ε)) := by ++ exact mul_le_mul_of_nonneg_left hinner hnorm_nonneg ++ ++ have hlognorm_neg : ‖-((Real.log u) : ℂ)‖ = Real.log u := by ++ have hnonneg : 0 ≤ Real.log u := le_of_lt (Real.log_pos hu) ++ simp [norm_neg, Complex.norm_real, abs_of_nonneg hnonneg] ++ ++ calc ++ ‖-((Real.log u) : ℂ) * (((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1))‖ ++ = ‖-((Real.log u) : ℂ)‖ * ‖((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-x - 1)‖ := hmul ++ _ ≤ ‖-((Real.log u) : ℂ)‖ * (u ^ (-1 - ε)) := hmul_le ++ _ = (Real.log u) * u ^ (-1 - ε) := by simp [hlognorm_neg, mul_comm] ++ ++lemma exists_radius_ball_two_step_subset_halfspace (s : ℂ) {ε : ℝ} (hε : ε < s.re) : ++ ∃ δ > 0, ∀ x, dist x s < δ → ∀ y, dist y x < δ → ε ≤ y.re := by ++ ++ set δ : ℝ := (s.re - ε) / 2 with hδdef ++ have hpos : 0 < s.re - ε := sub_pos.mpr hε ++ have hδpos : 0 < δ := by simpa [hδdef] using (half_pos hpos) ++ refine ⟨δ, hδpos, ?_⟩ ++ intro x hx y hy ++ ++ have htri : dist y s ≤ dist y x + dist x s := by ++ simpa using (dist_triangle y x s) ++ have hsumlt : dist y x + dist x s < δ + δ := add_lt_add hy hx ++ have hnorm_lt : ‖y - s‖ < δ + δ := by ++ have := lt_of_le_of_lt htri hsumlt ++ simpa [dist_eq_norm] using this ++ have hdeltaSum : δ + δ = s.re - ε := by ++ simp [hδdef, add_halves] ++ have hnorm_lt_re : ‖y - s‖ < s.re - ε := by simpa [hdeltaSum] using hnorm_lt ++ ++ have h_eps_lt : ε < s.re - ‖y - s‖ := by ++ have hsum' : ε + ‖y - s‖ < s.re := by ++ simpa [add_comm, add_left_comm, add_assoc, sub_eq_add_neg] using ++ (add_lt_add_right hnorm_lt_re ε) ++ simpa [lt_sub_iff_add_lt] using hsum' ++ ++ have hre_abs : |(y - s).re| ≤ ‖y - s‖ := by ++ simpa using (Complex.abs_re_le_norm (y - s)) ++ have hre_lower : -‖y - s‖ ≤ (y - s).re := by ++ ++ have hpair := (abs_le.mp hre_abs) ++ exact hpair.left ++ have hyge : s.re - ‖y - s‖ ≤ y.re := by ++ have h' : s.re + (-‖y - s‖) ≤ s.re + (y - s).re := add_le_add_right hre_lower s.re ++ have h'' : s.re + (y - s).re = y.re := by ++ simp [sub_eq_add_neg] ++ simpa [sub_eq_add_neg, h''] using h' ++ ++ have hygt : ε < y.re := lt_of_lt_of_le h_eps_lt hyge ++ exact le_of_lt hygt ++ ++lemma integrable_kernel_at_param (s : ℂ) (hs : 0 < s.re) : ++ Integrable ((fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1))) (volume.restrict (Ioi (1 : ℝ))) := by ++ classical ++ ++ set f : ℝ → ℂ := fun u => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-s - 1) ++ set ε : ℝ := s.re / 2 ++ set g1 : ℝ → ℝ := fun u => u ^ (-s.re - 1) ++ set g : ℝ → ℝ := fun u => u ^ (-1 - ε) ++ ++ have hfm : AEStronglyMeasurable f (volume.restrict (Ioi (1 : ℝ))) := by ++ simpa [f] using kernel_aestronglyMeasurable_on_Ioi (s := s) (a := (1 : ℝ)) ++ ++ have hε : 0 < ε := by ++ have : 0 < s.re := hs ++ simpa [ε] using (half_pos this) ++ have hεle : ε ≤ s.re := by ++ have hnonneg : 0 ≤ s.re := le_of_lt hs ++ simpa [ε] using (half_le_self hnonneg) ++ ++ have hbound1 : ∀ᵐ u ∂(volume.restrict (Ioi (1 : ℝ))), ‖f u‖ ≤ g1 u := by ++ simpa [f, g1] using (kernel_ae_bound_on_Ioi (s := s)) ++ ++ have hpow_ae : ∀ᵐ u ∂(volume.restrict (Ioi (1 : ℝ))), g1 u ≤ g u := by ++ ++ have hAll : ∀ u ∈ Ioi (1 : ℝ), g1 u ≤ g u := by ++ intro u hu ++ have hx : (1 : ℝ) ≤ u := le_of_lt hu ++ have hlexp : (-s.re - 1) ≤ (-1 - ε) := by linarith ++ have := Real.rpow_le_rpow_of_exponent_le hx hlexp ++ simpa [g1, g] using this ++ ++ have hAE : ∀ᵐ u ∂volume, u ∈ Ioi (1 : ℝ) → g1 u ≤ g u := ++ MeasureTheory.ae_of_all _ hAll ++ have hiff := ++ (MeasureTheory.ae_restrict_iff' (μ := volume) (s := Ioi (1 : ℝ)) ++ (p := fun u => g1 u ≤ g u) measurableSet_Ioi) ++ exact hiff.mpr hAE ++ ++ have hbound : ∀ᵐ u ∂(volume.restrict (Ioi (1 : ℝ))), ‖f u‖ ≤ g u := by ++ filter_upwards [hbound1, hpow_ae] with u hu1 hu2 ++ exact le_trans hu1 hu2 ++ ++ have hgint : IntegrableOn g (Ioi (1 : ℝ)) := by ++ have ha_lt : (-1 - ε) < (-1 : ℝ) := by linarith ++ have hc : 0 < (1 : ℝ) := by norm_num ++ simpa [g] using (integrableOn_Ioi_rpow_of_lt (a := (-1 - ε)) (ha := ha_lt) (c := (1 : ℝ)) (hc := hc)) ++ ++ have hint : IntegrableOn f (Ioi (1 : ℝ)) := ++ integrableOn_of_ae_bound (s := Ioi (1 : ℝ)) (f := f) (g := g) ++ (hfm := hfm) (hgint := hgint) (hbound := hbound) ++ simpa [IntegrableOn, f] using hint ++ ++lemma eventually_aestronglyMeasurable_kernel_param (s : ℂ) : ++ ∀ᶠ z in 𝓝 s, AEStronglyMeasurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1)) (volume.restrict (Ioi (1 : ℝ))) := by ++ refine Filter.Eventually.of_forall ?_ ++ intro z ++ ++ have hmeas_fract : Measurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ)) := by ++ have hmeas_fr : Measurable (Int.fract : ℝ → ℝ) := by ++ simpa using (measurable_fract : Measurable (Int.fract : ℝ → ℝ)) ++ exact (Complex.measurable_ofReal.comp hmeas_fr) ++ have hmeas_cpow : Measurable (fun u : ℝ => (u : ℂ) ^ (-z - 1)) := by ++ ++ measurability ++ have hmeas : Measurable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1)) := ++ hmeas_fract.mul hmeas_cpow ++ simpa using hmeas.aestronglyMeasurable ++ ++lemma hasDerivAt_kernel_in_param (u : ℝ) (hu : 1 < u) (z : ℂ) : ++ HasDerivAt (fun w : ℂ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-w - 1)) ++ ( -((Real.log u) : ℂ) * (((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1)) ) z := by ++ ++ set c0 : ℂ := ((Int.fract u : ℝ) : ℂ) ++ have hu0 : 0 < u := lt_trans zero_lt_one hu ++ have hux0 : (u : ℝ) ≠ 0 := ne_of_gt hu0 ++ have hcz : (u : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hux0 ++ ++ have hfneg : HasDerivAt (fun w : ℂ => -w) (-1) z := (hasDerivAt_id z).neg ++ have hf : HasDerivAt (fun w : ℂ => -w - 1) (-1) z := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using hfneg.sub_const (1 : ℂ) ++ ++ have hbase : HasDerivAt (fun w : ℂ => (u : ℂ) ^ (-w - 1)) ++ ((u : ℂ) ^ (-z - 1) * Complex.log (u : ℂ) * (-1)) z := ++ HasDerivAt.const_cpow (c := (u : ℂ)) (hf := hf) (h0 := Or.inl hcz) ++ have hbase' : HasDerivAt (fun w : ℂ => (u : ℂ) ^ (-w - 1)) ++ (-(Complex.log (u : ℂ)) * (u : ℂ) ^ (-z - 1)) z := by ++ ++ simpa [mul_comm, mul_left_comm, mul_assoc] using hbase ++ ++ have hmul : HasDerivAt (fun w : ℂ => c0 * ((u : ℂ) ^ (-w - 1))) ++ (c0 * (-(Complex.log (u : ℂ)) * (u : ℂ) ^ (-z - 1))) z := ++ HasDerivAt.const_mul c0 hbase' ++ ++ have hlog : (Real.log u : ℂ) = Complex.log (u : ℂ) := by ++ simpa using (Complex.ofReal_log (x := u) (hx := le_of_lt hu0)) ++ ++ simpa [c0, hlog, mul_comm, mul_left_comm, mul_assoc] using hmul ++ ++lemma hasDerivAt_integral_param_dominated_Ioi ++ (F F' : ℂ → ℝ → ℂ) (s : ℂ) (δ : ℝ) (hδ : 0 < δ) ++ (hmeas : ∀ᶠ z in 𝓝 s, AEStronglyMeasurable (F z) (MeasureTheory.volume.restrict (Ioi (1 : ℝ)))) ++ (hFint : Integrable (F s) (MeasureTheory.volume.restrict (Ioi (1 : ℝ)))) ++ (hF'meas : AEStronglyMeasurable (F' s) (MeasureTheory.volume.restrict (Ioi (1 : ℝ)))) ++ (bound : ℝ → ℝ) ++ (hbound_int : Integrable bound (MeasureTheory.volume.restrict (Ioi (1 : ℝ)))) ++ (hbound : ∀ᵐ u ∂(MeasureTheory.volume.restrict (Ioi (1 : ℝ))), ∀ z ∈ Metric.ball s δ, ‖F' z u‖ ≤ bound u) ++ (hderiv : ∀ᵐ u ∂(MeasureTheory.volume.restrict (Ioi (1 : ℝ))), ∀ z ∈ Metric.ball s δ, HasDerivAt (fun w => F w u) (F' z u) z) ++ : ++ HasDerivAt (fun z => ∫ u in Ioi (1 : ℝ), F z u) (∫ u in Ioi (1 : ℝ), F' s u) s := by ++ ++ have h := ++ hasDerivAt_integral_of_dominated_loc_of_deriv_le ++ (μ := MeasureTheory.volume.restrict (Ioi (1 : ℝ))) ++ (F := F) (F' := F') (x₀ := s) ++ (s := Metric.ball s δ) (hs := Metric.ball_mem_nhds s hδ) ++ (hF_meas := hmeas) (hF_int := hFint) ++ (hF'_meas := hF'meas) ++ (h_bound := hbound) (bound_integrable := hbound_int) ++ (h_diff := hderiv) ++ rcases h with ⟨_hint, hDeriv⟩ ++ ++ simpa using hDeriv ++ ++lemma dist_lt_of_mem_two_balls {x z s : ℂ} {r : ℝ} ++ (hxz : dist x z < r) (hzs : dist z s < r) : dist x s < r + r := by ++ have htri : dist x s ≤ dist x z + dist z s := dist_triangle x z s ++ have hadd : dist x z + dist z s < r + r := add_lt_add hxz hzs ++ exact lt_of_le_of_lt htri hadd ++ ++lemma mem_ball_of_mem_two_half_balls {x z s : ℂ} {δ : ℝ} ++ (hx : x ∈ Metric.ball z (δ/2)) (hz : z ∈ Metric.ball s (δ/2)) : ++ x ∈ Metric.ball s δ := by ++ have hxz : dist x z < δ / 2 := by ++ simpa [Metric.mem_ball] using hx ++ have hzs : dist z s < δ / 2 := by ++ simpa [Metric.mem_ball] using hz ++ have htri : dist x s ≤ dist x z + dist z s := dist_triangle x z s ++ have hadd : dist x z + dist z s < δ / 2 + δ / 2 := add_lt_add hxz hzs ++ have hlt : dist x s < δ := by ++ exact lt_of_le_of_lt htri (by simpa [add_halves] using hadd) ++ simpa [Metric.mem_ball] using hlt ++ ++lemma dist_lt_delta_of_half {x s : ℂ} {δ : ℝ} (hδpos : 0 < δ) ++ (hx : dist x s < δ/2) : dist x s < δ := by ++ have hhalf : δ / 2 < δ := by ++ simpa using (half_lt_self hδpos) ++ exact lt_trans hx hhalf ++ ++lemma re_lower_bound_from_two_step {s x : ℂ} {ε δ : ℝ} ++ (h : ∀ z, dist z s < δ → ∀ y, dist y z < δ → ε ≤ y.re) ++ (hδpos : 0 < δ) (hx : dist x s < δ) : ε ≤ x.re := by ++ have hxx : dist x x < δ := by simpa [dist_self] using hδpos ++ have hxstep := h x hx ++ have hxres := hxstep x hxx ++ simpa using hxres ++ ++lemma analyticAt_of_eventually_differentiableAt {f : ℂ → ℂ} {s : ℂ} ++ (h : ∀ᶠ z in 𝓝 s, DifferentiableAt ℂ f z) : AnalyticAt ℂ f s := by ++ simpa using ++ (Complex.analyticAt_iff_eventually_differentiableAt (f := f) (c := s)).2 h ++ ++lemma kernel_integrable_param_of_re_pos (z : ℂ) (hz : 0 < z.re) : ++ Integrable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1)) ++ (MeasureTheory.volume.restrict (Ioi (1 : ℝ))) := by ++ simpa using (integrable_kernel_at_param (s := z) (hs := hz)) ++ ++lemma integrable_kernel_at_param' (z : ℂ) (hz : 0 < z.re) : ++ Integrable (fun u : ℝ => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1)) ++ (MeasureTheory.volume.restrict (Ioi (1 : ℝ))) := by simpa using integrable_kernel_at_param (s := z) hz ++ ++lemma lem_integralAnalytic (s : ℂ) (hs : 1/10 < s.re) : ++ AnalyticAt ℂ (fun z : ℂ => ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-z - 1)) s := by ++ classical ++ ++ have hspos : 0 < s.re := lt_trans (by norm_num : (0 : ℝ) < 1/10) hs ++ set ε : ℝ := s.re / 2 with hεdef ++ have hεpos : 0 < ε := by simpa [ε] using (half_pos hspos) ++ have hεlt : ε < s.re := by ++ have : s.re / 2 < s.re := by simpa [ε] using (half_lt_self hspos) ++ simpa [ε] using this ++ ++ rcases exists_radius_ball_two_step_subset_halfspace (s := s) (ε := ε) hεlt with ⟨δ, hδpos, hδprop⟩ ++ ++ let F : ℂ → ℝ → ℂ := fun z u => ((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-z - 1) ++ let F' : ℂ → ℝ → ℂ := fun z u => -((Real.log u) : ℂ) * F z u ++ ++ let bound : ℝ → ℝ := fun u => (2/ε) * u ^ (-1 - (ε/2)) ++ ++ have hbound_int : Integrable bound (MeasureTheory.volume.restrict (Ioi (1 : ℝ))) := by ++ have hlt : (-1 - (ε/2)) < (-1 : ℝ) := by ++ have : 0 < ε/2 := by simpa using (half_pos hεpos) ++ linarith ++ have hpos1 : 0 < (1 : ℝ) := by norm_num ++ have hpow_int : IntegrableOn (fun u : ℝ => u ^ (-1 - (ε/2))) (Ioi (1 : ℝ)) := by ++ simpa using (integrableOn_Ioi_rpow_of_lt (a := (-1 - (ε/2))) hlt (c := (1 : ℝ)) hpos1) ++ have hconst : IntegrableOn (fun u : ℝ => (2/ε) * u ^ (-1 - (ε/2))) (Ioi (1 : ℝ)) := ++ hpow_int.const_mul (2/ε) ++ simpa [IntegrableOn, bound] using hconst ++ ++ have hDiff_eventually : ∀ᶠ z in 𝓝 s, ++ DifferentiableAt ℂ (fun z0 => ∫ u in Ioi (1 : ℝ), F z0 u) z := by ++ ++ have hball : Metric.ball s (δ/2) ∈ 𝓝 s := Metric.ball_mem_nhds _ (by simpa using (half_pos hδpos)) ++ refine Filter.eventually_of_mem hball ?_ ++ intro z hz ++ ++ have hz_lt_δ : dist z s < δ := lt_trans (by simpa [Metric.mem_ball] using hz) (by simpa using (half_lt_self hδpos)) ++ have hRe_inner : ∀ y, y ∈ Metric.ball z (δ/2) → ε ≤ y.re := by ++ intro y hy ++ have hy_lt_δ : dist y z < δ := lt_trans (by simpa [Metric.mem_ball] using hy) (by simpa using (half_lt_self hδpos)) ++ exact hδprop z hz_lt_δ y hy_lt_δ ++ ++ have hmeas_z : ∀ᶠ w in 𝓝 z, ++ AEStronglyMeasurable (F w) (MeasureTheory.volume.restrict (Ioi (1 : ℝ))) := ++ eventually_aestronglyMeasurable_kernel_param (s := z) ++ ++ have hzRe_ge : ε ≤ z.re := by ++ ++ have hss : dist s s < δ := by simpa [dist_self] using hδpos ++ have hz_lt_δ' : dist z s < δ := hz_lt_δ ++ exact hδprop s hss z hz_lt_δ' ++ have hzpos : 0 < z.re := lt_of_lt_of_le hεpos hzRe_ge ++ have hFint_z : Integrable (F z) (MeasureTheory.volume.restrict (Ioi (1 : ℝ))) := by ++ simpa [F] using integrable_kernel_at_param (s := z) hzpos ++ ++ have hF'meas_z : AEStronglyMeasurable (F' z) (MeasureTheory.volume.restrict (Ioi (1 : ℝ))) := by ++ simpa [F, F'] using aestronglyMeasurable_kernel_param_deriv (z := z) ++ ++ have hbound_z : ∀ᵐ u ∂(MeasureTheory.volume.restrict (Ioi (1 : ℝ))), ++ ∀ w ∈ Metric.ball z (δ/2), ‖F' w u‖ ≤ bound u := by ++ ++ have hAll : ∀ u ∈ Ioi (1 : ℝ), ∀ w ∈ Metric.ball z (δ/2), ‖F' w u‖ ≤ bound u := by ++ intro u hu w hw ++ have hu1 : 1 < u := hu ++ have hu0 : 0 < u := lt_trans zero_lt_one hu1 ++ ++ have hwRe : ε ≤ w.re := hRe_inner w hw ++ have hker : ‖-((Real.log u) : ℂ) * (((Int.fract u : ℝ) : ℂ) * (u : ℂ) ^ (-w - 1))‖ ++ ≤ Real.log u * u ^ (-1 - ε) := ++ kernel_deriv_norm_bound_on_ball (ε := ε) (u := u) (hu := hu1) (x := w) (hx := hwRe) ++ have hF'le : ‖F' w u‖ ≤ Real.log u * u ^ (-1 - ε) := by ++ simpa [F, F', mul_comm, mul_left_comm, mul_assoc] using hker ++ ++ have hx' := Real.add_one_le_exp ((ε/2) * Real.log u) ++ have hx : 1 + (ε/2) * Real.log u ≤ Real.exp ((ε/2) * Real.log u) := by ++ simpa [add_comm] using hx' ++ have hsub : (ε/2) * Real.log u ≤ Real.exp ((ε/2) * Real.log u) - 1 := by ++ have := sub_le_sub_right hx 1 ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ have hle_exp : (ε/2) * Real.log u ≤ Real.exp ((ε/2) * Real.log u) := by ++ have hnonneg : 0 ≤ (1 : ℝ) := by norm_num ++ have : Real.exp ((ε/2) * Real.log u) - 1 ≤ Real.exp ((ε/2) * Real.log u) := ++ sub_le_self _ hnonneg ++ exact le_trans hsub this ++ have hεne : (ε : ℝ) ≠ 0 := ne_of_gt hεpos ++ have hpos_inv : 0 < ε⁻¹ := inv_pos.mpr hεpos ++ have hpos_coeff : 0 < (2/ε) := by ++ have : 0 < (2 : ℝ) := by norm_num ++ simpa [one_div, div_eq_mul_inv] using (mul_pos this hpos_inv) ++ have hlog_bound : Real.log u ≤ (2/ε) * Real.exp ((ε/2) * Real.log u) := by ++ have hmul := mul_le_mul_of_nonneg_left hle_exp (le_of_lt hpos_coeff) ++ ++ have hleft : (2/ε) * ((ε/2) * Real.log u) = Real.log u := by ++ have h2ne : (2 : ℝ) ≠ 0 := by norm_num ++ calc ++ (2/ε) * ((ε/2) * Real.log u) ++ = ((2/ε) * (ε/2)) * Real.log u := by ring ++ _ = ((2 * ε⁻¹) * (ε * (2)⁻¹)) * Real.log u := by simp [div_eq_mul_inv] ++ _ = ((2 * (2)⁻¹) * (ε⁻¹ * ε)) * Real.log u := by ring ++ _ = (1 * 1) * Real.log u := by simp [hεne, h2ne] ++ _ = Real.log u := by simp ++ simpa [hleft] ++ using hmul ++ ++ have hexp_rpow : Real.exp ((ε/2) * Real.log u) = u ^ (ε/2) := by ++ have : 0 < u := hu0 ++ simp [Real.rpow_def_of_pos this, mul_comm] ++ ++ have hmul : Real.log u * u ^ (-1 - ε) ++ ≤ ((2/ε) * u ^ (ε/2)) * u ^ (-1 - ε) := by ++ have hqpos : 0 < u ^ (-1 - ε) := Real.rpow_pos_of_pos hu0 _ ++ have hq : 0 ≤ u ^ (-1 - ε) := le_of_lt hqpos ++ exact mul_le_mul_of_nonneg_right (by simpa [hexp_rpow] using hlog_bound) hq ++ ++ have hpow_mul : u ^ (ε/2) * u ^ (-1 - ε) = u ^ (-1 - (ε/2)) := by ++ have hu0' : 0 < u := hu0 ++ have h1 : Real.exp ((ε/2) * Real.log u) * Real.exp ((-1 - ε) * Real.log u) ++ = Real.exp (((ε/2) * Real.log u) + ((-1 - ε) * Real.log u)) := by ++ simpa using (Real.exp_add ((ε/2) * Real.log u) ((-1 - ε) * Real.log u)).symm ++ calc ++ u ^ (ε/2) * u ^ (-1 - ε) ++ = Real.exp ((ε/2) * Real.log u) * Real.exp ((-1 - ε) * Real.log u) := by ++ simp [Real.rpow_def_of_pos hu0', mul_comm] ++ _ = Real.exp (((ε/2) * Real.log u) + ((-1 - ε) * Real.log u)) := by ++ simpa using h1 ++ _ = Real.exp (((ε/2) + (-1 - ε)) * Real.log u) := by ++ ring_nf ++ _ = u ^ (-1 - (ε/2)) := by ++ have : (ε/2) + (-1 - ε) = -1 - (ε/2) := by ring ++ simp [this, Real.rpow_def_of_pos hu0', mul_comm] ++ have hmul' : ((2/ε) * u ^ (ε/2)) * u ^ (-1 - ε) = (2/ε) * u ^ (-1 - (ε/2)) := by ++ simp [mul_assoc, hpow_mul] ++ ++ have : ‖F' w u‖ ≤ bound u := by ++ refine le_trans hF'le ?_ ++ simpa [bound, hmul'] using hmul ++ simpa [F, F', bound] ++ using this ++ ++ have hiff := ++ (MeasureTheory.ae_restrict_iff' (μ := MeasureTheory.volume) (s := Ioi (1 : ℝ)) ++ (p := fun u : ℝ => ∀ w ∈ Metric.ball z (δ/2), ‖F' w u‖ ≤ bound u) measurableSet_Ioi) ++ exact hiff.mpr (MeasureTheory.ae_of_all _ hAll) ++ ++ have hderiv_z : ∀ᵐ u ∂(MeasureTheory.volume.restrict (Ioi (1 : ℝ))), ++ ∀ w ∈ Metric.ball z (δ/2), HasDerivAt (fun w0 => F w0 u) (F' w u) w := by ++ ++ have hAll : ∀ u ∈ Ioi (1 : ℝ), ∀ w ∈ Metric.ball z (δ/2), ++ HasDerivAt (fun w0 => F w0 u) (F' w u) w := by ++ intro u hu w hw ++ simpa [F, F', mul_comm, mul_left_comm, mul_assoc] ++ using hasDerivAt_kernel_in_param (u := u) (hu := hu) (z := w) ++ ++ have hiff := ++ (MeasureTheory.ae_restrict_iff' (μ := MeasureTheory.volume) (s := Ioi (1 : ℝ)) ++ (p := fun u : ℝ => ∀ w ∈ Metric.ball z (δ/2), ++ HasDerivAt (fun w0 => F w0 u) (F' w u) w) measurableSet_Ioi) ++ exact hiff.mpr (MeasureTheory.ae_of_all _ hAll) ++ ++ have hD := hasDerivAt_integral_param_dominated_Ioi ++ (F := F) (F' := F') (s := z) (δ := δ/2) (hδ := by simpa using (half_pos hδpos)) ++ (hmeas := hmeas_z) (hFint := hFint_z) (hF'meas := hF'meas_z) ++ (bound := bound) (hbound_int := hbound_int) (hbound := hbound_z) (hderiv := hderiv_z) ++ ++ simpa using hD.differentiableAt ++ ++ exact analyticAt_of_eventually_differentiableAt hDiff_eventually ++ ++lemma lem_zetaFormulaAC : ++ (let S := {s : ℂ | s ≠ 1} ++ let T := {s : ℂ | s ∈ S ∧ 1/10 < s.re} ++ let F := fun z : ℂ => ++ z / (z - 1) ++ - z * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-z - 1) ++ AnalyticOn ℂ F T) := by ++ ++ simp only [AnalyticOn] ++ intro s hs ++ simp at hs ++ obtain ⟨hs_ne_1, hs_re⟩ := hs ++ ++ apply AnalyticAt.analyticWithinAt ++ ++ have h1 : AnalyticAt ℂ (fun z => z / (z - 1)) s := by ++ apply AnalyticAt.div ++ · exact analyticAt_id ++ · exact analyticAt_id.sub analyticAt_const ++ · ++ rw [sub_ne_zero] ++ exact hs_ne_1 ++ ++ have hs_re_eq : (10 : ℝ)⁻¹ = (1 : ℝ) / 10 := by norm_num ++ have hs_re_correct : (1 : ℝ) / 10 < s.re := by rwa [← hs_re_eq] ++ ++ have hconv := lem_integralConvergence (1/10) (by norm_num) s (le_of_lt hs_re_correct) ++ ++ obtain ⟨I, hI_tendsto, hI_bound⟩ := hconv ++ ++ have hI_bound_10 : ‖I‖ ≤ 10 := by ++ convert hI_bound ++ norm_num ++ ++ have h_integral : AnalyticAt ℂ (fun z => ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-z - 1)) s := by ++ apply lem_integralAnalytic s hs_re_correct ++ ++ have h2 : AnalyticAt ℂ (fun z => z * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-z - 1)) s := by ++ exact analyticAt_id.mul h_integral ++ ++ exact h1.sub h2 ++ ++lemma lem_div_eq_one_plus_one_div (z : ℂ) (hz : z ≠ 1) : z / (z - 1) = 1 + 1 / (z - 1) := by ++ have h : z - 1 ≠ 0 := by ++ intro h0 ++ have : z = 1 := by ++ rw [sub_eq_zero] at h0 ++ exact h0 ++ exact hz this ++ calc z / (z - 1) ++ = ((z - 1) + 1) / (z - 1) := by ring_nf ++ _ = (z - 1) / (z - 1) + 1 / (z - 1) := by rw [add_div] ++ _ = 1 + 1 / (z - 1) := by simp [div_self h] ++ ++lemma lem_zetaAnalyticContinuation : ++ (let S := {s : ℂ | s ≠ 1} ++ let T := {s : ℂ | s ∈ S ∧ 1/10 < s.re} ++ ∀ s ∈ T, ++ riemannZeta s ++ = 1 + 1 / (s - 1) ++ - s * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)) := by ++ ++ simp only [Set.mem_ofPred_eq] ++ intro s h_s ++ ++ have hs_ne_1 : s ≠ 1 := h_s.1 ++ have hs_re : 1/10 < s.re := h_s.2 ++ ++ let F := fun z : ℂ => 1 + 1 / (z - 1) - z * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-z - 1) ++ ++ let S := {s : ℂ | s ≠ 1} ++ let T := {s : ℂ | s ∈ S ∧ 1/10 < s.re} ++ ++ have hs_in_T : s ∈ T := by ++ simp only [T, S, Set.mem_ofPred_eq] ++ exact ⟨hs_ne_1, hs_re⟩ ++ ++ have h_T_open := lem_T_isOpen ++ have h_T_preconnected := lem_T_isPreconnected ++ ++ have h_zeta_analytic_S := lem_zetaanalS ++ have h_zeta_analytic_T : AnalyticOn ℂ riemannZeta T := by ++ apply AnalyticOn.mono h_zeta_analytic_S ++ intro x hx; exact hx.1 ++ have h_zeta_analyticOnNhd_T : AnalyticOnNhd ℂ riemannZeta T := by ++ rwa [← h_T_open.analyticOn_iff_analyticOnNhd] ++ ++ have h_F_orig_analytic := lem_zetaFormulaAC ++ ++ have h_F_eq : EqOn F (fun z => z / (z - 1) - z * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-z - 1)) T := by ++ intro z hz ++ simp only [F] ++ rw [lem_div_eq_one_plus_one_div z hz.1] ++ ++ have h_F_analytic_T : AnalyticOn ℂ F T := ++ AnalyticOn.congr h_F_orig_analytic h_F_eq ++ have h_F_analyticOnNhd_T : AnalyticOnNhd ℂ F T := by ++ rwa [← h_T_open.analyticOn_iff_analyticOnNhd] ++ ++ have ⟨s₀, hs₀_T, hs₀_re⟩ : ∃ s₀, s₀ ∈ T ∧ 1 < s₀.re := by ++ use 2 ++ constructor ++ · simp only [T, S, Set.mem_ofPred_eq] ++ norm_num ++ · norm_num ++ ++ have h_eventually_eq : riemannZeta =ᶠ[𝓝 s₀] F := by ++ ++ have h_re_cont : ContinuousAt Complex.re s₀ := Complex.continuous_re.continuousAt ++ have h_nhd_re : ∀ᶠ s in 𝓝 s₀, 1 < s.re := ++ ContinuousAt.eventually_lt continuousAt_const h_re_cont hs₀_re ++ ++ have h_nhd_T : ∀ᶠ s in 𝓝 s₀, s ∈ T := h_T_open.mem_nhds hs₀_T ++ ++ filter_upwards [h_nhd_re, h_nhd_T] with w hw_re hw_T ++ ++ have h_formula := lem_zetaFormula w hw_re ++ simp only [F] ++ exact h_formula ++ ++ have h_eqOn_global := AnalyticOnNhd.eqOn_of_preconnected_of_eventuallyEq ++ h_zeta_analyticOnNhd_T h_F_analyticOnNhd_T h_T_preconnected hs₀_T h_eventually_eq ++ ++ exact h_eqOn_global hs_in_T ++ ++lemma lem_zetaBound1 (s : ℂ) (hs_re : 1/10 < s.re) (hs_ne : s ≠ 1) : ‖riemannZeta s‖ ≤ 1 + ‖1 / (s - 1)‖ + ‖s‖ * ‖∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1)‖ := by ++ classical ++ set S : Set ℂ := {z : ℂ | z ≠ 1} ++ set T : Set ℂ := {z : ℂ | z ∈ S ∧ 1/10 < z.re} ++ set Iint : ℂ := ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) ++ have hT : s ∈ T := by ++ have hsS : s ∈ S := by simpa [S, Set.mem_ofPred_eq] using hs_ne ++ simpa [T, Set.mem_ofPred_eq] using And.intro hsS hs_re ++ have hAC : ∀ z ∈ T, riemannZeta z = 1 + 1 / (z - 1) - z * ∫ u in Ioi (1 : ℝ), (Int.fract u : ℝ) * (u : ℂ) ^ (-z - 1) := by ++ simpa [S, T] using lem_zetaAnalyticContinuation ++ have hzeta : riemannZeta s = 1 + 1 / (s - 1) - s * Iint := by ++ simpa [Iint] using hAC s hT ++ have h1 : ‖riemannZeta s‖ ≤ ‖1 + 1 / (s - 1)‖ + ‖-s * Iint‖ := by ++ simpa [hzeta, sub_eq_add_neg] using (lem_triangleInequality_add (1 + 1 / (s - 1)) (-s * Iint)) ++ have hA : ‖1 + 1 / (s - 1)‖ ≤ ‖(1 : ℂ)‖ + ‖1 / (s - 1)‖ := by ++ simpa using (lem_triangleInequality_add (1 : ℂ) (1 / (s - 1))) ++ have hmul : ‖-s * Iint‖ = ‖-s‖ * ‖Iint‖ := by ++ simp ++ have hB : ‖-s * Iint‖ ≤ ‖s‖ * ‖Iint‖ := by ++ have : ‖-s * Iint‖ = ‖s‖ * ‖Iint‖ := by simp ++ exact this.le ++ have h2 : ‖riemannZeta s‖ ≤ (‖(1 : ℂ)‖ + ‖1 / (s - 1)‖) + (‖s‖ * ‖Iint‖) := ++ le_trans h1 (add_le_add hA hB) ++ have h1norm : ‖(1 : ℂ)‖ = 1 := by simp ++ simpa [Iint, h1norm, add_comm, add_left_comm, add_assoc] using h2 ++ ++lemma lem_integralBoundValue (s : ℂ) (hs : 0 < s.re) : ∫ u in Ioi (1 : ℝ), u ^ (-s.re - 1) = 1 / s.re := by ++ have ha : (-s.re - 1) < -1 := by linarith ++ have hc : 0 < (1 : ℝ) := by exact zero_lt_one ++ have h := integral_Ioi_rpow_of_lt (a := (-s.re - 1)) ha (c := (1 : ℝ)) hc ++ have h' : ∫ u in Ioi (1 : ℝ), u ^ (-s.re - 1) = - (1 : ℝ) ^ (-s.re) / (-s.re) := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using h ++ calc ++ ∫ u in Ioi (1 : ℝ), u ^ (-s.re - 1) ++ = - (1 : ℝ) ^ (-s.re) / (-s.re) := h' ++ _ = - (1 : ℝ) / (-s.re) := by simp [Real.one_rpow] ++ _ = 1 / s.re := by simp ++ ++lemma lem_zetaBound2 (s : ℂ) (hs_re : 1/10 < s.re) (hs_ne : s ≠ 1) : ‖riemannZeta s‖ ≤ 1 + ‖1 / (s - 1)‖ + ‖s‖ / s.re := by ++ ++ set f : ℝ → ℂ := fun u => (Int.fract u : ℝ) * (u : ℂ) ^ (-s - 1) with hfdef ++ set g : ℝ → ℝ := fun u => u ^ (-s.re - 1) with hgdef ++ ++ have hζ : ‖riemannZeta s‖ ≤ 1 + ‖1 / (s - 1)‖ + ‖s‖ * ‖∫ u in Ioi (1 : ℝ), f u‖ := by ++ simpa [hfdef] using lem_zetaBound1 s hs_re hs_ne ++ ++ let μ : Measure ℝ := (volume : Measure ℝ).restrict (Ioi (1 : ℝ)) ++ ++ have h_ae_bound : ∀ᵐ u ∂μ, ‖f u‖ ≤ g u := by ++ have hforall : ∀ u ∈ Ioi (1 : ℝ), ‖f u‖ ≤ g u := by ++ intro u hu ++ have := lem_integrandBound u (le_of_lt hu) s ++ simpa [hfdef, hgdef] using this ++ have hmeas : MeasurableSet (Ioi (1 : ℝ)) := measurableSet_Ioi ++ simpa [μ] using ++ (MeasureTheory.ae_restrict_of_forall_mem (μ := volume) (s := Ioi (1 : ℝ)) hmeas hforall) ++ ++ have hg_intOn : IntegrableOn g (Ioi (1 : ℝ)) := by ++ classical ++ by_contra hnot ++ have hnot' : ¬ Integrable g μ := by simpa [μ, IntegrableOn] using hnot ++ have hint0 : (∫ u, g u ∂μ) = 0 := by ++ simpa using (integral_undef (μ := μ) (f := g) hnot') ++ have hval : ∫ u in Ioi (1 : ℝ), g u = 1 / s.re := by ++ simpa [hgdef] using lem_integralBoundValue s (by linarith [hs_re]) ++ have hne : (1 / s.re) ≠ 0 := by exact one_div_ne_zero (ne_of_gt (by linarith [hs_re])) ++ have : (∫ u in Ioi (1 : ℝ), g u) = 0 := by simpa [μ] using hint0 ++ exact hne (by simpa [hval] using this) ++ have hg_int : Integrable g μ := by simpa [μ, IntegrableOn] using hg_intOn ++ ++ have h_int_bound : ‖∫ u in Ioi (1 : ℝ), f u‖ ≤ ∫ u in Ioi (1 : ℝ), g u := by ++ have := ++ (MeasureTheory.norm_integral_le_of_norm_le (μ := μ) (f := f) (g := g) hg_int h_ae_bound) ++ simpa [μ] using this ++ ++ have h_g_val : ∫ u in Ioi (1 : ℝ), g u = 1 / s.re := by ++ simpa [hgdef] using lem_integralBoundValue s (by linarith [hs_re]) ++ have h_int_bound_conc : ‖∫ u in Ioi (1 : ℝ), f u‖ ≤ 1 / s.re := by ++ simpa [h_g_val] using h_int_bound ++ ++ have hmul : ‖s‖ * ‖∫ u in Ioi (1 : ℝ), f u‖ ≤ ‖s‖ * (1 / s.re) := by ++ exact mul_le_mul_of_nonneg_left h_int_bound_conc (by exact norm_nonneg s) ++ ++ have hsum0 : (1 + ‖1 / (s - 1)‖) + ‖s‖ * ‖∫ u in Ioi (1 : ℝ), f u‖ ++ ≤ (1 + ‖1 / (s - 1)‖) + ‖s‖ * (1 / s.re) := by ++ exact add_le_add_right hmul (1 + ‖1 / (s - 1)‖) ++ have hsum : 1 + ‖1 / (s - 1)‖ + ‖s‖ * ‖∫ u in Ioi (1 : ℝ), f u‖ ++ ≤ 1 + ‖1 / (s - 1)‖ + ‖s‖ * (1 / s.re) := by ++ simpa [add_assoc] using hsum0 ++ ++ have hfinal1 : ‖riemannZeta s‖ ≤ 1 + ‖1 / (s - 1)‖ + ‖s‖ * (1 / s.re) := ++ le_trans hζ hsum ++ simpa [div_eq_mul_inv] using hfinal1 ++ ++lemma lem_sOverSminus1Bound (s : ℂ) (_hs : s ≠ 1) : ‖(1 / (s - 1))‖ = 1 / ‖s - 1‖ := by simp [one_div] ++ ++lemma lem_zetaBound3 (s : ℂ) (hs_re : 1/10 < s.re) (hs_ne : s ≠ 1) : ‖riemannZeta s‖ ≤ 1 + 1 / ‖s - 1‖ + ‖s‖ / s.re := by ++ simpa [lem_sOverSminus1Bound s hs_ne] using lem_zetaBound2 s hs_re hs_ne ++ ++lemma helper_normsq (z : ℂ) : ‖z‖ ^ 2 = z.re ^ 2 + z.im ^ 2 := by ++ simpa [Complex.normSq, pow_two] using (Complex.normSq_eq_norm_sq z).symm ++ ++lemma helper_three_abs_sq (t : ℝ) : (3 : ℝ) ^ 2 + t ^ 2 ≤ (3 + |t|) ^ 2 := by ++ have hnonneg : 0 ≤ (6 : ℝ) * |t| := by ++ have h6 : (0 : ℝ) ≤ 6 := by norm_num ++ exact mul_nonneg h6 (abs_nonneg t) ++ have hmul : |t| * |t| = t * t := by ++ simp ++ calc ++ (3 : ℝ) ^ 2 + t ^ 2 = (3 : ℝ) ^ 2 + t * t := by simp [pow_two] ++ _ = (3 : ℝ) ^ 2 + |t| * |t| := by simp [hmul] ++ _ ≤ (3 : ℝ) ^ 2 + |t| * |t| + (6 : ℝ) * |t| := by exact le_add_of_nonneg_right hnonneg ++ _ = (3 + |t|) ^ 2 := by ring ++ ++lemma lem_sBound (s : ℂ) (hs : (1/2 : ℝ) ≤ s.re ∧ s.re < (3 : ℝ)) : ‖s‖ < (3 : ℝ) + |s.im| := by ++ have hnegthree_lt_re : (- (3 : ℝ)) < s.re := by ++ have hlt : (- (3 : ℝ)) < (1 / 2 : ℝ) := by norm_num ++ exact lt_of_lt_of_le hlt hs.1 ++ have hlt3 : s.re < (3 : ℝ) := hs.2 ++ have h_re_sq_lt : s.re ^ 2 < (3 : ℝ) ^ 2 := by ++ simpa using (sq_lt_sq' hnegthree_lt_re hlt3) ++ have hsumlt : s.re ^ 2 + s.im ^ 2 < (3 : ℝ) ^ 2 + s.im ^ 2 := by ++ exact add_lt_add_left h_re_sq_lt _ ++ have hsq : ‖s‖ ^ 2 < (3 + |s.im|) ^ 2 := by ++ have h := lt_of_lt_of_le hsumlt (helper_three_abs_sq s.im) ++ simpa [helper_normsq s] using h ++ have hnormnn : 0 ≤ ‖s‖ := norm_nonneg _ ++ have hpos : 0 ≤ (3 : ℝ) + |s.im| := add_nonneg (by norm_num) (abs_nonneg _) ++ exact (sq_lt_sq₀ hnormnn hpos).1 hsq ++ ++lemma lem_invReSbound (s : ℂ) (hs : (1/2 : ℝ) ≤ s.re ∧ s.re < (3 : ℝ)) : ++ 1 / s.re ≤ (2 : ℝ) := by ++ have h_pos : (0 : ℝ) < s.re := by ++ linarith [hs.1] ++ have h_half_pos : (0 : ℝ) < (1/2 : ℝ) := by norm_num ++ have h_recip : 1 / s.re ≤ 1 / (1/2 : ℝ) := one_div_le_one_div_of_le h_half_pos hs.1 ++ have h_simplify : 1 / (1/2 : ℝ) = (2 : ℝ) := by norm_num ++ rw [h_simplify] at h_recip ++ exact h_recip ++ ++lemma lem_invSminus1bound (s : ℂ) (_hs_re : (1/2 : ℝ) ≤ s.re ∧ s.re < (3 : ℝ)) (hs_im : (1 : ℝ) ≤ |s.im|) : (1 : ℝ) ≤ ‖s - 1‖ := by ++ have h2 : |s.im| ≤ ‖s - 1‖ := by ++ have : (s - (1 : ℂ)).im = s.im := by ++ simp [Complex.sub_im, Complex.one_im] ++ simpa [this] using Complex.abs_im_le_norm (s - 1) ++ exact le_trans hs_im h2 ++ ++lemma reciprocal_le_one_of_one_le {x : ℝ} (hx_pos : 0 < x) (hx_ge : 1 ≤ x) : 1 / x ≤ 1 := by ++ ++ have h_div_pos : 0 < 1 / x := one_div_pos.mpr hx_pos ++ ++ have h1 : (1 / x) * 1 ≤ (1 / x) * x := by ++ exact mul_le_mul_of_nonneg_left hx_ge (le_of_lt h_div_pos) ++ ++ rw [mul_one] at h1 ++ rw [one_div_mul_cancel (ne_of_gt hx_pos)] at h1 ++ exact h1 ++ ++lemma div_le_mul_of_one_div_le {a c d : ℝ} (ha : 0 ≤ a) (_hc : 0 < c) (h : 1 / c ≤ d) : a / c ≤ a * d := by ++ ++ rw [div_eq_mul_one_div] ++ ++ exact mul_le_mul_of_nonneg_left h ha ++ ++lemma lem_finalBoundCombination (s : ℂ) (hs_re : (1/2 : ℝ) ≤ s.re ∧ s.re < (3 : ℝ)) (hs_im : (1 : ℝ) ≤ |s.im|) : ‖riemannZeta s‖ < 1 + 1 + ((3 : ℝ) + |s.im|) * 2 := by ++ ++ have hs_ne : s ≠ 1 := by ++ intro h ++ rw [h] at hs_im ++ simp at hs_im ++ linarith ++ ++ have hs_re_pos : 0 < s.re := by linarith [hs_re.1] ++ ++ have h1 : ‖riemannZeta s‖ ≤ 1 + 1 / ‖s - 1‖ + ‖s‖ / s.re := lem_zetaBound3 s (by linarith [hs_re_pos]) hs_ne ++ ++ have h2 : (1 : ℝ) ≤ ‖s - 1‖ := lem_invSminus1bound s hs_re hs_im ++ have h3 : 1 / ‖s - 1‖ ≤ 1 := reciprocal_le_one_of_one_le (by linarith [h2]) h2 ++ ++ have h4 : ‖s‖ < (3 : ℝ) + |s.im| := lem_sBound s hs_re ++ ++ have h5 : 1 / s.re ≤ (2 : ℝ) := lem_invReSbound s hs_re ++ ++ calc ‖riemannZeta s‖ ++ ≤ 1 + 1 / ‖s - 1‖ + ‖s‖ / s.re := h1 ++ _ ≤ 1 + 1 + ‖s‖ / s.re := by linarith [h3] ++ _ ≤ 1 + 1 + ‖s‖ * 2 := by ++ have s_nonneg : 0 ≤ ‖s‖ := norm_nonneg _ ++ exact add_le_add_right (div_le_mul_of_one_div_le s_nonneg hs_re_pos h5) _ ++ _ < 1 + 1 + ((3 : ℝ) + |s.im|) * 2 := by linarith [h4] ++ ++lemma lem_finalAlgebra (t : ℝ) : 1 + 1 + ((3 : ℝ) + |t|) * 2 = (8 : ℝ) + 2 * |t| := by ring ++ ++lemma lem_zetaUppBd (z : ℂ) (hz_re : z.re ∈ Ico (1/2 : ℝ) (3 : ℝ)) (hz_im : (1 : ℝ) ≤ |z.im|) : ‖riemannZeta z‖ < (8 : ℝ) + 2 * |z.im| := by ++ have hz_re' : (1/2 : ℝ) ≤ z.re ∧ z.re < (3 : ℝ) := by ++ simpa [Ico] using hz_re ++ have h := lem_finalBoundCombination z hz_re' hz_im ++ simpa [lem_finalAlgebra] using h ++ ++lemma lem_zfroms_calc (s : ℂ) (t : ℝ) : ++ (let z := s + (3/2 : ℝ) + I * t ++ z.re = s.re + (3/2 : ℝ) ∧ z.im = s.im + t) := by ++ constructor ++ · ++ simp only [Complex.add_re, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im] ++ ++ have h1 : I.re = 0 := Complex.I_re ++ have h2 : I.im * 0 = 0 := mul_zero _ ++ rw [h1, h2] ++ simp ++ · ++ simp only [Complex.add_im, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im] ++ ++ have h1 : I.re * 0 = 0 := mul_zero _ ++ have h2 : I.im = 1 := Complex.I_im ++ rw [h1, h2] ++ simp ++ ++lemma lem_zfroms_conditions (s : ℂ) (t : ℝ) ++ (hs : ‖s‖ ≤ (1 : ℝ)) (ht : (2 : ℝ) < |t|) : ++ (let z := s + (3/2 : ℝ) + I * t ++ z.re ∈ Ico (1/2 : ℝ) (3 : ℝ) ∧ (1 : ℝ) ≤ |z.im|) := by ++ ++ have h_calc := lem_zfroms_calc s t ++ simp only [h_calc.1, h_calc.2] ++ constructor ++ ++ · ++ ++ have hs_re_bound : |s.re| ≤ 1 := ++ (Complex.abs_re_le_norm s).trans hs ++ rw [abs_le] at hs_re_bound ++ ++ rw [Set.mem_Ico] ++ constructor ++ · ++ linarith [hs_re_bound.1] ++ · ++ linarith [hs_re_bound.2] ++ ++ · ++ have hs_im_bound : |s.im| ≤ 1 := ++ (Complex.abs_im_le_norm s).trans hs ++ rw [abs_le] at hs_im_bound ++ ++ by_cases h : 0 ≤ t ++ · ++ have ht_pos : t > 2 := by ++ rwa [abs_of_nonneg h] at ht ++ ++ have lower_bound : s.im + t ≥ 1 := by ++ linarith [hs_im_bound.1, ht_pos] ++ have nonneg : 0 ≤ s.im + t := by linarith ++ rw [abs_of_nonneg nonneg] ++ linarith [lower_bound] ++ · ++ push Not at h ++ have ht_neg : t < -2 := by ++ rw [abs_of_neg h] at ht ++ linarith [ht] ++ ++ have upper_bound : s.im + t ≤ -1 := by ++ linarith [hs_im_bound.2, ht_neg] ++ have neg : s.im + t < 0 := by linarith ++ rw [abs_of_neg neg] ++ linarith [upper_bound] ++ ++lemma lem_abs_im_bound (s : ℂ) (t : ℝ) (hs : ‖s‖ ≤ 1) : |s.im + t| ≤ 1 + |t| := by ++ have h1 : |s.im| ≤ ‖s‖ := Complex.abs_im_le_norm s ++ have h2 : |s.im| ≤ 1 := le_trans h1 hs ++ have h3 : |s.im + t| ≤ |s.im| + |t| := abs_add_le s.im t ++ linarith ++ ++lemma lem_zetaUppBound : ++ ∀ t : ℝ, ∀ s : ℂ, ‖s‖ ≤ (1 : ℝ) → (2 : ℝ) < |t| → ++ ‖riemannZeta (s + (3/2 : ℝ) + I * t)‖ < (10 : ℝ) + 2 * |t| := by ++ intro t s hs ht ++ set z := s + (3/2 : ℝ) + I * t with hz_def ++ ++ have hz_cond : z.re ∈ Ico (1/2 : ℝ) (3 : ℝ) ∧ (1 : ℝ) ≤ |z.im| := ++ lem_zfroms_conditions s t hs ht ++ ++ have h_bound : ‖riemannZeta z‖ < (8 : ℝ) + 2 * |z.im| := ++ lem_zetaUppBd z hz_cond.1 hz_cond.2 ++ ++ have hz_im_calc : z.im = s.im + t := (lem_zfroms_calc s t).2 ++ have h_im_bound : |z.im| ≤ 1 + |t| := by ++ rw [hz_im_calc] ++ exact lem_abs_im_bound s t hs ++ ++ have h_intermediate : ‖riemannZeta z‖ < (8 : ℝ) + 2 * (1 + |t|) := by ++ calc ‖riemannZeta z‖ ++ < (8 : ℝ) + 2 * |z.im| := h_bound ++ _ ≤ (8 : ℝ) + 2 * (1 + |t|) := by linarith [h_im_bound] ++ ++ have h_algebra : (8 : ℝ) + 2 * (1 + |t|) = (10 : ℝ) + 2 * |t| := by ring ++ ++ have h_final : ‖riemannZeta z‖ < (10 : ℝ) + 2 * |t| := by ++ linarith [h_intermediate, h_algebra] ++ ++ rwa [hz_def] at h_final ++ ++open Metric _root_.Set Filter Asymptotics BigOperators ++ ++noncomputable def logDerivZeta (s : ℂ) : ℂ := deriv riemannZeta s / riemannZeta s ++ ++def zerosetKfRc (R : ℝ) (c : ℂ) (f : ℂ → ℂ) : Set ℂ := ++ {ρ : ℂ | ρ ∈ Metric.closedBall c R ∧ f ρ = 0} ++ ++lemma zetadiffAtnot1 : ∀ s : ℂ, s ≠ 1 → DifferentiableAt ℂ riemannZeta s := ++ fun _ => differentiableAt_riemannZeta ++ ++lemma DiffAtWithinAt {T : Set ℂ} {g : ℂ → ℂ} {s : ℂ} (_hs : s ∈ T) : ++ DifferentiableAt ℂ g s → DifferentiableWithinAt ℂ g T s := ++ DifferentiableAt.differentiableWithinAt ++ ++lemma DiffWithinAtallOn {T : Set ℂ} {g : ℂ → ℂ} : ++ (∀ s ∈ T, DifferentiableWithinAt ℂ g T s) → DifferentiableOn ℂ g T := fun h => h ++ ++lemma DiffAtOn {T : Set ℂ} {g : ℂ → ℂ} : ++ (∀ s ∈ T, DifferentiableAt ℂ g s) → DifferentiableOn ℂ g T := by ++ intro h s hs ++ exact (h s hs).differentiableWithinAt ++ ++lemma DiffOnanalOnNhd {T : Set ℂ} (hT : IsOpen T) {g : ℂ → ℂ} : ++ DifferentiableOn ℂ g T → AnalyticOnNhd ℂ g T := by ++ intro hdiff ++ exact hdiff.analyticOnNhd hT ++ ++lemma DiffAtallanalOnNhd {T : Set ℂ} (hT : IsOpen T) {g : ℂ → ℂ} : ++ (∀ s ∈ T, DifferentiableAt ℂ g s) → AnalyticOnNhd ℂ g T := by ++ intro hdiff ++ apply DiffOnanalOnNhd hT ++ exact DiffAtOn hdiff ++ ++lemma zetaanalOnnot1 : AnalyticOnNhd ℂ riemannZeta {s : ℂ | s ≠ 1} := by ++ apply DiffAtallanalOnNhd ++ · apply isOpen_compl_singleton ++ · exact zetadiffAtnot1 ++ ++lemma I_mul_ofReal_im (t : ℝ) : (I * ↑t).im = t := by ++ have h1 : (I * (↑t : ℂ)).im = (↑t : ℂ).re := Complex.I_mul_im (↑t : ℂ) ++ rw [h1] ++ simp [Complex.ofReal_re] ++ ++lemma complex_im_sub_I_mul (a : ℂ) (t : ℝ) : (a - I * t).im = a.im - t := by ++ rw [Complex.sub_im] ++ rw [I_mul_ofReal_im] ++ ++lemma D1cinTt_pre (t : ℝ) (ht : |t| > 1) : ++ ∀ s ∈ closedBall (3/2 + I * t : ℂ) 1, s ≠ 1 := by ++ intro s hs ++ by_contra h ++ ++ rw [h] at hs ++ ++ rw [mem_closedBall] at hs ++ ++ rw [Complex.dist_eq] at hs ++ ++ have h1 : (1 : ℂ) - (3/2 + I * t) = -1/2 - I * t := by ring ++ rw [h1] at hs ++ ++ have h2 : (-1/2 - I * t : ℂ).im = -t := by ++ have : (-1/2 - I * t : ℂ) = (-1/2 : ℂ) - I * t := by ring ++ rw [this] ++ rw [complex_im_sub_I_mul] ++ simp ++ ++ have h3 : ‖(-1/2 - I * t : ℂ)‖ ≥ |(-1/2 - I * t : ℂ).im| := Complex.abs_im_le_norm _ ++ ++ rw [h2] at h3 ++ rw [abs_neg] at h3 ++ ++ have h4 : ‖(-1/2 - I * t : ℂ)‖ > 1 := lt_of_lt_of_le ht h3 ++ ++ linarith [h4, hs] ++ ++lemma D1cinTt (t : ℝ) (ht : |t| > 1) : ++ closedBall (3/2 + I * t : ℂ) 1 ⊆ {s : ℂ | s ≠ 1} := by ++ ++ exact fun s hs => D1cinTt_pre t ht s hs ++ ++lemma zetaanalOnD1c (t : ℝ) (ht : |t| > 1) : ++ AnalyticOnNhd ℂ riemannZeta (closedBall (3/2 + I * t : ℂ) 1) := by ++ apply zetaanalOnnot1.mono ++ exact D1cinTt t ht ++ ++lemma zetaanalOnD1c_general (x t : ℝ) (ht : |t| > 1) : ++ AnalyticOnNhd ℂ riemannZeta (closedBall (x + I * t : ℂ) 1) := by ++ apply zetaanalOnnot1.mono ++ ++ intro s hs ++ by_contra h ++ ++ have h' : s = 1 := by ++ simp at h ++ exact h ++ rw [h'] at hs ++ rw [mem_closedBall] at hs ++ rw [Complex.dist_eq] at hs ++ ++ have h1 : (1 : ℂ) - (x + I * t) = (1 - x) - I * t := by ring ++ rw [h1] at hs ++ ++ have h2 : ((1 - x) - I * t : ℂ).im = -t := by ++ rw [Complex.sub_im] ++ rw [Complex.sub_im] ++ rw [Complex.ofReal_im] ++ rw [I_mul_ofReal_im] ++ simp ++ ++ have h3 : ‖((1 - x) - I * t : ℂ)‖ ≥ |((1 - x) - I * t : ℂ).im| := Complex.abs_im_le_norm _ ++ rw [h2] at h3 ++ rw [abs_neg] at h3 ++ ++ have h4 : ‖((1 - x) - I * t : ℂ)‖ > 1 := lt_of_lt_of_le ht h3 ++ ++ linarith ++ ++lemma sigmageq1 (s : ℂ) (hs : s.re > 1) : riemannZeta s ≠ 0 := ++ riemannZeta_ne_zero_of_one_lt_re hs ++ ++lemma Complex_I_mul_ofReal_re (r : ℝ) : (I * (r : ℂ)).re = 0 := by ++ have h : (I * (r : ℂ)).re = -(r : ℂ).im := Complex.I_mul_re (r : ℂ) ++ rw [h] ++ simp ++ ++lemma re_real_add_I_mul_gt (a b : ℝ) (h : a > 1) : (a + I * b).re > 1 := by ++ rw [Complex.add_re] ++ rw [Complex.ofReal_re] ++ rw [Complex_I_mul_ofReal_re] ++ simp ++ exact h ++ ++lemma zetacnot0 (t : ℝ) : riemannZeta (3/2 + I * t) ≠ 0 := by ++ apply sigmageq1 ++ apply re_real_add_I_mul_gt ++ norm_num ++ ++lemma zetacnot0_general (x t : ℝ) (hx : x > 1) : riemannZeta (x + I * t) ≠ 0 := by ++ apply sigmageq1 ++ apply re_real_add_I_mul_gt ++ exact hx ++ ++lemma fc_analytic_normalized (c : ℂ) (f : ℂ → ℂ) ++ (h_analytic : AnalyticOnNhd ℂ f (closedBall c 1)) (h_nonzero : f c ≠ 0) : ++ (AnalyticOnNhd ℂ (fun z => f (z + c) / f c) (closedBall (0 : ℂ) 1)) ∧ (fun z => f (z + c) / f c) 0 = 1 := by ++ constructor ++ · ++ apply AnalyticOnNhd.div ++ · ++ apply AnalyticOnNhd.comp h_analytic ++ · ++ intro z _ ++ exact analyticAt_id.add analyticAt_const ++ · ++ intro z hz ++ rw [mem_closedBall] at hz ⊢ ++ rw [Complex.dist_eq] at hz ⊢ ++ ++ convert hz using 1 ++ ring_nf ++ · ++ exact analyticOnNhd_const ++ · ++ intro z _ ++ exact h_nonzero ++ · ++ simpa using h_nonzero ++ ++lemma deriv_normalized_nohd (c : ℂ) (f : ℂ → ℂ) (z : ℂ) (_h_nonzero : f c ≠ 0) : ++ deriv (fun w => f (w + c) / f c) z = (deriv f (z + c)) / f c := by ++ rw [deriv_div_const] ++ rw [deriv_comp_add_const] ++ ++lemma frac_cancel_const {x y c : ℂ} (hc : c ≠ 0) (hy : y ≠ 0) : (x / c) / (y / c) = x / y := by ++ field_simp [hc, hy] ++ ++lemma fc_log_deriv (c : ℂ) (f : ℂ → ℂ) ++ (_h_analytic : AnalyticOnNhd ℂ f (closedBall c 1)) (h_nonzero : f c ≠ 0) ++ {z : ℂ} (hz_nonzero : f (z + c) ≠ 0) : ++ (deriv (fun w => f (w + c) / f c) z) / (f (z + c) / f c) = (deriv f (z + c)) / f (z + c) := by ++ ++ rw [deriv_normalized_nohd c f z h_nonzero] ++ ++ rw [frac_cancel_const h_nonzero hz_nonzero] ++ ++lemma fc_bound (B : ℝ) (_hB : B > 1) (R : ℝ) (_hRpos : 0 < R) (_hR : R < 1) (c : ℂ) (f : ℂ → ℂ) (_h_nonzero : f c ≠ 0) ++ (h_bound : ∀ z ∈ closedBall c R, ‖f z‖ ≤ B) : ++ ∀ z ∈ closedBall (0 : ℂ) R, ‖(fun w => f (w + c) / f c) z‖ ≤ B / ‖f c‖ := by ++ intro z hz ++ have hz' : ‖z‖ ≤ R := by ++ simpa [mem_closedBall, Complex.dist_eq] using hz ++ have hz_plus : z + c ∈ closedBall c R := by ++ have : ‖(z + c) - c‖ ≤ R := by simpa [add_sub_cancel] using hz' ++ simpa [mem_closedBall, Complex.dist_eq] using this ++ have hfb : ‖f (z + c)‖ ≤ B := h_bound (z + c) hz_plus ++ have hnorm : ‖f (z + c) / f c‖ = ‖f (z + c)‖ / ‖f c‖ := by ++ simp [div_eq_mul_inv, norm_inv] ++ have : ‖f (z + c)‖ / ‖f c‖ ≤ B / ‖f c‖ := ++ div_le_div_of_nonneg_right hfb (norm_nonneg _) ++ simpa [hnorm] using this ++ ++lemma fc_zeros (r : ℝ) (_h : r > 0) (c : ℂ) (f : ℂ → ℂ) (h_nonzero : f c ≠ 0) ++ (_h_analytic : AnalyticOnNhd ℂ f (closedBall c 1)) : ++ (zerosetKfRc r (0 : ℂ) (fun z => f (z + c) / f c)) = (fun ρ => ρ - c) '' (zerosetKfRc r c f) := by ++ ext ρ'; constructor ++ · intro hmem ++ rcases hmem with ⟨hball, hzero⟩ ++ ++ have hprod : f (ρ' + c) * (f c)⁻¹ = 0 := by simpa [div_eq_mul_inv] using hzero ++ have hnum0 : f (ρ' + c) = 0 := by ++ rcases mul_eq_zero.mp hprod with hnum | hinv ++ · exact hnum ++ · have : (f c)⁻¹ ≠ 0 := inv_ne_zero h_nonzero ++ exact (this hinv).elim ++ refine ⟨ρ' + c, ?_, ?_⟩ ++ · ++ have hdist0 : dist ρ' (0 : ℂ) ≤ r := by simpa [mem_closedBall] using hball ++ have hdist1 : dist (ρ' + c) c ≤ r := by ++ simpa [Complex.dist_eq, add_sub_cancel] using hdist0 ++ have hmem_ball : ρ' + c ∈ closedBall c r := by ++ simpa [mem_closedBall] using hdist1 ++ exact And.intro hmem_ball hnum0 ++ · ++ simp ++ · intro him ++ rcases him with ⟨y, hy_mem, hy_eq⟩ ++ ++ subst hy_eq ++ rcases hy_mem with ⟨hy_ball, hy_zero⟩ ++ refine And.intro ?_ ?_ ++ · ++ have hdist : dist y c ≤ r := by simpa [mem_closedBall] using hy_ball ++ have hdist0 : dist (y - c) (0 : ℂ) ≤ r := by ++ simpa [Complex.dist_eq, sub_zero] using hdist ++ simpa [mem_closedBall] using hdist0 ++ · ++ simp [sub_add_cancel, hy_zero] ++ ++lemma analyticOrderAt_const_mul_eq (f : ℂ → ℂ) (a z0 : ℂ) (ha : a ≠ 0) : ++ analyticOrderAt (fun z => a * f z) z0 = analyticOrderAt f z0 := by ++ classical ++ by_cases hf : AnalyticAt ℂ f z0 ++ · ++ have hconst : AnalyticAt ℂ (fun _ : ℂ => a) z0 := by ++ simpa using (analyticAt_const (x := z0) (v := a)) ++ have hconst_order_zero : analyticOrderAt (fun _ : ℂ => a) z0 = 0 := by ++ ++ refine (AnalyticAt.analyticOrderAt_eq_natCast (f := fun _ : ℂ => a) (z₀ := z0) hconst).mpr ?_ ++ refine ⟨(fun _ : ℂ => a), (analyticAt_const : AnalyticAt ℂ (fun _ : ℂ => a) z0), ?_, ?_⟩ ++ · simpa using ha ++ · exact Filter.Eventually.of_forall (fun _ => by simp) ++ have hmul := analyticOrderAt_mul (f := fun _ : ℂ => a) (g := f) hconst hf ++ ++ simpa [hconst_order_zero, zero_add] using! hmul ++ · ++ have hconst : AnalyticAt ℂ (fun _ : ℂ => a) z0 := by ++ simpa using (analyticAt_const (x := z0) (v := a)) ++ have hconst_ne : (fun _ : ℂ => a) z0 ≠ 0 := by simpa using ha ++ have hiff := (analyticAt_iff_analytic_fun_mul (f := fun _ : ℂ => a) (g := f) (z := z0) hconst hconst_ne) ++ have hmul : ¬ AnalyticAt ℂ (fun z => a * f z) z0 := by ++ intro h ++ have : AnalyticAt ℂ f z0 := (hiff.mpr (by simpa using h)) ++ exact hf this ++ ++ simp [analyticOrderAt, hf, hmul] ++ ++lemma AnalyticAt.comp_add_const {f : ℂ → ℂ} {z0 c : ℂ} (hf : AnalyticAt ℂ f (z0 + c)) : AnalyticAt ℂ (fun z => f (z + c)) z0 := by ++ ++ have hinner : AnalyticAt ℂ (fun z : ℂ => z + c) z0 := by ++ have h_id : AnalyticAt ℂ (fun z : ℂ => z) z0 := by ++ simpa [id] using! (analyticAt_id : AnalyticAt ℂ (id : ℂ → ℂ) z0) ++ have h_const : AnalyticAt ℂ (fun _ : ℂ => c) z0 := by ++ simpa using (analyticAt_const (v := c) (x := z0)) ++ simpa using (AnalyticAt.fun_add (f := fun z : ℂ => z) (g := fun _ : ℂ => c) (x := z0) h_id h_const) ++ ++ simpa using (AnalyticAt.fun_comp (x := z0) hf hinner) ++ ++lemma AnalyticAt.of_comp_add_const {f : ℂ → ℂ} {z0 c : ℂ} ++ (hg : AnalyticAt ℂ (fun z => f (z + c)) z0) : ++ AnalyticAt ℂ f (z0 + c) := by ++ ++ have hT : AnalyticAt ℂ (fun z => z - c) (z0 + c) := by ++ have h1 : AnalyticAt ℂ (fun z : ℂ => z) (z0 + c) := by ++ simpa using! (analyticAt_id : AnalyticAt ℂ (fun z : ℂ => z) (z0 + c)) ++ have h2 : AnalyticAt ℂ (fun _ : ℂ => -c) (z0 + c) := by ++ simpa using (analyticAt_const (x := (z0 + c)) (v := (-c : ℂ))) ++ have : AnalyticAt ℂ (fun z => z + (-c)) (z0 + c) := by ++ simpa using (AnalyticAt.fun_add h1 h2) ++ simpa [sub_eq_add_neg] using this ++ ++ have hx : (z0 + c) - c = z0 := by simp ++ have hg' : AnalyticAt ℂ (fun z => f (z + c)) ((z0 + c) - c) := by ++ simpa [hx] using hg ++ ++ have hcomp := ++ (AnalyticAt.comp (g := (fun z => f (z + c))) (f := (fun z => z - c)) (x := z0 + c) ++ hg' hT) ++ have hgf : ((fun z => f (z + c)) ∘ (fun z => z - c)) = f := by ++ funext z ++ simp [Function.comp, sub_eq_add_neg] ++ simpa [hgf] using hcomp ++ ++lemma order_top_iff_comp_add (f : ℂ → ℂ) (z0 c : ℂ) : ++ analyticOrderAt (fun z => f (z + c)) z0 = ⊤ ↔ analyticOrderAt f (z0 + c) = ⊤ := by ++ classical ++ let g : ℂ → ℂ := fun z => f (z + c) ++ ++ have eq_left : analyticOrderAt g z0 = ⊤ ↔ ∀ᶠ z in nhds z0, g z = 0 := by ++ simpa [g] using (analyticOrderAt_eq_top (f := g)) ++ have eq_right : analyticOrderAt f (z0 + c) = ⊤ ↔ ∀ᶠ w in nhds (z0 + c), f w = 0 := by ++ simpa using (analyticOrderAt_eq_top (f := f)) ++ constructor ++ · intro htop ++ have hz : ∀ᶠ z in nhds z0, g z = 0 := (eq_left.mp htop) ++ ++ have hcont_sub : ContinuousAt (fun w : ℂ => w - c) (z0 + c) := by ++ simpa [sub_eq_add_neg] using! ++ ((continuousAt_id).add (continuousAt_const : ContinuousAt (fun _ : ℂ => -c) (z0 + c))) ++ have htend : Tendsto (fun w : ℂ => w - c) (nhds (z0 + c)) (nhds ((z0 + c) - c)) := ++ hcont_sub.tendsto ++ have hz' : ∀ᶠ w in nhds ((z0 + c) - c), g w = 0 := by ++ simpa [sub_eq_add_neg, add_sub_cancel] using hz ++ have hw : ∀ᶠ w in nhds (z0 + c), g (w - c) = 0 := htend.eventually hz' ++ have hw' : ∀ᶠ w in nhds (z0 + c), f w = 0 := by ++ simpa [g, sub_add_cancel] using hw ++ exact eq_right.mpr hw' ++ · intro htop ++ have hw : ∀ᶠ w in nhds (z0 + c), f w = 0 := (eq_right.mp htop) ++ ++ have hcont_add : ContinuousAt (fun z : ℂ => z + c) z0 := ++ by simpa using! ((continuousAt_id).add (continuousAt_const : ContinuousAt (fun _ : ℂ => c) z0)) ++ have htend : Tendsto (fun z : ℂ => z + c) (nhds z0) (nhds (z0 + c)) := ++ hcont_add.tendsto ++ have hz : ∀ᶠ z in nhds z0, f (z + c) = 0 := htend.eventually hw ++ have hz' : ∀ᶠ z in nhds z0, g z = 0 := by simpa [g] using hz ++ exact eq_left.mpr hz' ++ ++lemma enat_le_iff_forall_nat {x y : ℕ∞} : x ≤ y ↔ ∀ n : ℕ, (n : ℕ∞) ≤ x → (n : ℕ∞) ≤ y := by ++ classical ++ constructor ++ · intro hxy n hnx ++ exact le_trans hnx hxy ++ · intro h ++ by_cases hx : x = ⊤ ++ · ++ subst hx ++ ++ by_contra hnot ++ have hy_ne : y ≠ ⊤ := by ++ simpa [WithTop.top_le_iff] using hnot ++ obtain ⟨m, hm⟩ := (WithTop.ne_top_iff_exists).1 hy_ne ++ ++ have h' : ((m + 1 : ℕ) : ℕ∞) ≤ y := h (m + 1) (by simp) ++ ++ have h'' : ((m + 1 : ℕ) : ℕ∞) ≤ (m : ℕ∞) := by ++ simpa [← hm] ++ using! h' ++ ++ have : m + 1 ≤ m := (WithTop.coe_le_coe).1 h'' ++ exact Nat.not_succ_le_self m this ++ · ++ obtain ⟨k, hk'⟩ := (WithTop.ne_top_iff_exists).1 hx ++ have hk : x = (k : ℕ∞) := hk'.symm ++ ++ have hxk : ((k : ℕ∞) ≤ y) := h k (by simp [hk]) ++ ++ simpa [hk] using hxk ++ ++lemma natCast_le_order_const_mul_iff (f : ℂ → ℂ) (a z0 : ℂ) (ha : a ≠ 0) (n : ℕ) : ++ (n : ℕ∞) ≤ analyticOrderAt (fun z => a * f z) z0 ↔ (n : ℕ∞) ≤ analyticOrderAt f z0 := by ++ constructor ++ · intro h ++ simpa [analyticOrderAt_const_mul_eq f a z0 ha] using h ++ · intro h ++ simpa [analyticOrderAt_const_mul_eq f a z0 ha] using h ++ ++lemma order_top_iff_const_mul (f : ℂ → ℂ) (a z0 : ℂ) (ha : a ≠ 0) : ++ analyticOrderAt (fun z => a * f z) z0 = ⊤ ↔ analyticOrderAt f z0 = ⊤ := by ++ simp [analyticOrderAt_const_mul_eq (f := f) (a := a) (z0 := z0) ha] ++ ++lemma analyticOrderAt_mul_const_eq (f : ℂ → ℂ) (a z0 : ℂ) (ha : a ≠ 0) : ++ analyticOrderAt (fun z => f z * a) z0 = analyticOrderAt f z0 := by ++ classical ++ ++ have hcomm : (fun z => f z * a) = (fun z => a * f z) := by ++ funext z; simp [mul_comm] ++ have hrew : analyticOrderAt (fun z => f z * a) z0 = ++ analyticOrderAt (fun z => a * f z) z0 := by ++ simp [hcomm] ++ by_cases hf : AnalyticAt ℂ f z0 ++ · ++ have hconst : AnalyticAt ℂ (fun _ : ℂ => a) z0 := by ++ simpa using (analyticAt_const : AnalyticAt ℂ (fun _ : ℂ => a) z0) ++ have hadd : analyticOrderAt (fun z => a * f z) z0 ++ = analyticOrderAt (fun _ : ℂ => a) z0 + analyticOrderAt f z0 := by ++ simpa using! (analyticOrderAt_mul hconst hf) ++ ++ have hconst_zero : analyticOrderAt (fun _ : ℂ => a) z0 = 0 := by ++ have hiff := (AnalyticAt.analyticOrderAt_eq_zero hconst) ++ have hval : (fun _ : ℂ => a) z0 ≠ 0 := by simpa using ha ++ exact hiff.mpr hval ++ calc ++ analyticOrderAt (fun z => f z * a) z0 ++ = analyticOrderAt (fun z => a * f z) z0 := hrew ++ _ = analyticOrderAt (fun _ : ℂ => a) z0 + analyticOrderAt f z0 := hadd ++ _ = 0 + analyticOrderAt f z0 := by simp [hconst_zero] ++ _ = analyticOrderAt f z0 := by simp ++ · ++ have hnot : ¬ AnalyticAt ℂ (fun z => a * f z) z0 := by ++ intro hmul ++ have hconst : AnalyticAt ℂ (fun _ : ℂ => a) z0 := by ++ simpa using (analyticAt_const : AnalyticAt ℂ (fun _ : ℂ => a) z0) ++ have hval : (fun _ : ℂ => a) z0 ≠ 0 := by simpa using ha ++ ++ have hiff := (analyticAt_iff_analytic_fun_smul (h₁f := hconst) (h₂f := hval) ++ (g := f) (z := z0)) ++ have hsmul : AnalyticAt ℂ (fun z => (fun _ : ℂ => a) z • f z) z0 := by ++ ++ simpa [smul_eq_mul] using hmul ++ have : AnalyticAt ℂ f z0 := hiff.mpr hsmul ++ exact hf this ++ calc ++ analyticOrderAt (fun z => f z * a) z0 ++ = analyticOrderAt (fun z => a * f z) z0 := hrew ++ _ = 0 := by simp [analyticOrderAt, hnot] ++ _ = analyticOrderAt f z0 := by simp [analyticOrderAt, hf] ++ ++lemma fc_m_order (r : ℝ) (_h : r > 0) (c : ℂ) (f : ℂ → ℂ) (h_nonzero : f c ≠ 0) ++ (_h_analytic : AnalyticOnNhd ℂ f (closedBall c 1)) ++ {ρ' : ℂ} (_hρ' : ρ' ∈ zerosetKfRc r (0 : ℂ) (fun z => f (z + c) / f c)) : ++ analyticOrderAt (fun z => f (z + c) / f c) ρ' = analyticOrderAt f (ρ' + c) := by ++ classical ++ ++ set g0 : ℂ → ℂ := fun z => f (z + c) with hg0 ++ ++ have hconst : analyticOrderAt (fun z => g0 z * (1 / f c)) ρ' = analyticOrderAt g0 ρ' := by ++ have hne : (1 / f c) ≠ 0 := one_div_ne_zero h_nonzero ++ simpa using (analyticOrderAt_mul_const_eq (f := g0) (a := (1 / f c)) (z0 := ρ') hne) ++ have hconst_rewrite : analyticOrderAt (fun z => f (z + c) / f c) ρ' ++ = analyticOrderAt (fun z => g0 z * (1 / f c)) ρ' := by ++ have : (fun z => f (z + c) / f c) = (fun z => g0 z * (1 / f c)) := by ++ funext z; simp [g0, div_eq_mul_inv, mul_comm] ++ simp [this] ++ ++ have htrans : analyticOrderAt g0 ρ' = analyticOrderAt f (ρ' + c) := by ++ ++ by_cases hfA : AnalyticAt ℂ f (ρ' + c) ++ · ++ have h_add : AnalyticAt ℂ (fun z : ℂ => z + c) ρ' := by ++ simpa using! (AnalyticAt.add (analyticAt_id : AnalyticAt ℂ (fun z : ℂ => z) ρ') ++ (analyticAt_const : AnalyticAt ℂ (fun _ : ℂ => c) ρ')) ++ have hgA : AnalyticAt ℂ g0 ρ' := by ++ have : AnalyticAt ℂ f ((fun z : ℂ => z + c) ρ') := by simpa using hfA ++ simpa [g0, hg0] using! (AnalyticAt.comp (g := f) (f := fun z : ℂ => z + c) (x := ρ') this h_add) ++ ++ by_cases hgez : (∀ᶠ z in nhds ρ', g0 z = 0) ++ · ++ have hT_sub_cont : ContinuousAt (fun w : ℂ => w - c) (ρ' + c) := by ++ simpa using! (ContinuousAt.sub (continuousAt_id : ContinuousAt (fun w : ℂ => w) (ρ' + c)) ++ (continuousAt_const : ContinuousAt (fun _ : ℂ => c) (ρ' + c))) ++ have hT_sub : Tendsto (fun w : ℂ => w - c) (nhds (ρ' + c)) (nhds ρ') := by ++ simpa using (hT_sub_cont.tendsto) ++ have hEfw : ∀ᶠ w in nhds (ρ' + c), f w = 0 := by ++ have : ∀ᶠ w in nhds (ρ' + c), g0 (w - c) = 0 := hT_sub.eventually hgez ++ ++ simpa [g0, hg0, sub_add_cancel] using this ++ ++ have hg_top : analyticOrderAt g0 ρ' = ⊤ := ++ (analyticOrderAt_eq_top (f := g0) (z₀ := ρ')).2 hgez ++ have hf_top : analyticOrderAt f (ρ' + c) = ⊤ := ++ (analyticOrderAt_eq_top (f := f) (z₀ := ρ' + c)).2 hEfw ++ simp [hg_top, hf_top] ++ · ++ have h_exists := (AnalyticAt.exists_eventuallyEq_pow_smul_nonzero_iff hgA).mpr hgez ++ rcases h_exists with ⟨n, φ, hφA, hφ_ne, hevent⟩ ++ ++ have hT_sub_cont : ContinuousAt (fun w : ℂ => w - c) (ρ' + c) := by ++ simpa using! (ContinuousAt.sub (continuousAt_id : ContinuousAt (fun w : ℂ => w) (ρ' + c)) ++ (continuousAt_const : ContinuousAt (fun _ : ℂ => c) (ρ' + c))) ++ have hT_sub : Tendsto (fun w : ℂ => w - c) (nhds (ρ' + c)) (nhds ρ') := by ++ simpa using (hT_sub_cont.tendsto) ++ have hevent_w : ∀ᶠ w in nhds (ρ' + c), f w ++ = (w - (ρ' + c)) ^ n * ((fun w => φ (w - c)) w) := by ++ have : ∀ᶠ w in nhds (ρ' + c), g0 (w - c) ++ = ((w - c) - ρ') ^ n * φ (w - c) := ++ hT_sub.eventually hevent ++ ++ refine this.mono ?_ ++ intro w hw ++ have hsubsimp : (w - c) - ρ' = w - (ρ' + c) := by ring ++ simpa [g0, hg0, hsubsimp] using hw ++ ++ have hψA : AnalyticAt ℂ (fun w => φ (w - c)) (ρ' + c) := by ++ have h_subA : AnalyticAt ℂ (fun w : ℂ => w - c) (ρ' + c) := by ++ simpa using! (AnalyticAt.sub (analyticAt_id : AnalyticAt ℂ (fun z : ℂ => z) (ρ' + c)) ++ (analyticAt_const : AnalyticAt ℂ (fun _ : ℂ => c) (ρ' + c))) ++ have hφA_at : AnalyticAt ℂ φ ((fun w : ℂ => w - c) (ρ' + c)) := by simpa using hφA ++ simpa using! (AnalyticAt.comp (g := φ) (f := fun w => w - c) (x := (ρ' + c)) hφA_at h_subA) ++ have hψ_ne : (fun w => φ (w - c)) (ρ' + c) ≠ 0 := by ++ ++ simpa using hφ_ne ++ ++ have hg_eq_n : analyticOrderAt g0 ρ' = n := by ++ exact (AnalyticAt.analyticOrderAt_eq_natCast (f := g0) (z₀ := ρ') hgA).mpr ++ ⟨φ, hφA, hφ_ne, hevent⟩ ++ have hf_eq_n : analyticOrderAt f (ρ' + c) = n := by ++ exact (AnalyticAt.analyticOrderAt_eq_natCast (f := f) (z₀ := ρ' + c) hfA).mpr ++ ⟨(fun w => φ (w - c)), hψA, hψ_ne, hevent_w⟩ ++ simp [hg_eq_n, hf_eq_n] ++ · ++ have hg_not : ¬ AnalyticAt ℂ g0 ρ' := by ++ intro hgA ++ ++ have h_subA : AnalyticAt ℂ (fun w : ℂ => w - c) (ρ' + c) := by ++ simpa using! (AnalyticAt.sub (analyticAt_id : AnalyticAt ℂ (fun z : ℂ => z) (ρ' + c)) ++ (analyticAt_const : AnalyticAt ℂ (fun _ : ℂ => c) (ρ' + c))) ++ have hgA_at : AnalyticAt ℂ g0 ((ρ' + c) - c) := by simpa using hgA ++ have hcomp := (AnalyticAt.comp (g := g0) (f := fun w => w - c) ++ (x := (ρ' + c)) hgA_at h_subA) ++ ++ have : AnalyticAt ℂ (fun w : ℂ => g0 (w - c)) (ρ' + c) := by simpa using! hcomp ++ have : AnalyticAt ℂ f (ρ' + c) := by ++ simpa [g0, hg0, sub_add_cancel] using this ++ exact hfA this ++ ++ simp [analyticOrderAt, hfA, hg_not] ++ ++ calc ++ analyticOrderAt (fun z => f (z + c) / f c) ρ' ++ = analyticOrderAt (fun z => g0 z * (1 / f c)) ρ' := hconst_rewrite ++ _ = analyticOrderAt g0 ρ' := hconst ++ _ = analyticOrderAt f (ρ' + c) := htrans ++ ++lemma DminusK (r1 : ℝ) (R1 : ℝ) (_hr1 : r1 > 0) (_hR1 : R1 > 0) (c : ℂ) (f : ℂ → ℂ) ++ (_h_analytic : AnalyticOnNhd ℂ f (closedBall c 1)) (h_nonzero : f c ≠ 0) : ++ ∀ z : ℂ, z ∈ closedBall (0 : ℂ) r1 \ zerosetKfRc R1 (0 : ℂ) (fun w => f (w + c) / f c) ↔ ++ z + c ∈ closedBall c r1 \ zerosetKfRc R1 c f := by ++ intro z ++ constructor ++ · ++ intro ⟨hz_ball, hz_not_zero⟩ ++ constructor ++ · ++ have hdist : dist z (0 : ℂ) ≤ r1 := by simpa [mem_closedBall] using hz_ball ++ have hdist_c : dist (z + c) c ≤ r1 := by ++ simpa [Complex.dist_eq, add_sub_cancel] using hdist ++ simpa [mem_closedBall] using hdist_c ++ · ++ intro h_contra ++ apply hz_not_zero ++ ++ rcases h_contra with ⟨hz_c_ball, hz_c_zero⟩ ++ constructor ++ · ++ have hdist_c : dist (z + c) c ≤ R1 := by simpa [mem_closedBall] using hz_c_ball ++ have hdist_0 : dist z (0 : ℂ) ≤ R1 := by ++ simpa [Complex.dist_eq, add_sub_cancel] using hdist_c ++ simpa [mem_closedBall] using hdist_0 ++ · ++ have : f (z + c) = 0 := hz_c_zero ++ simp [this, zero_div] ++ · ++ intro ⟨hz_c_ball, hz_c_not_zero⟩ ++ constructor ++ · ++ have hdist_c : dist (z + c) c ≤ r1 := by simpa [mem_closedBall] using hz_c_ball ++ have hdist_0 : dist z (0 : ℂ) ≤ r1 := by ++ simpa [Complex.dist_eq, add_sub_cancel] using hdist_c ++ simpa [mem_closedBall] using hdist_0 ++ · ++ intro h_contra ++ apply hz_c_not_zero ++ ++ rcases h_contra with ⟨hz_ball, hz_zero⟩ ++ constructor ++ · ++ have hdist_0 : dist z (0 : ℂ) ≤ R1 := by simpa [mem_closedBall] using hz_ball ++ have hdist_c : dist (z + c) c ≤ R1 := by ++ simpa [Complex.dist_eq, add_sub_cancel] using hdist_0 ++ simpa [mem_closedBall] using hdist_c ++ · ++ have h_div_zero : f (z + c) / f c = 0 := hz_zero ++ have h_mul_zero : f (z + c) * (f c)⁻¹ = 0 := by simpa [div_eq_mul_inv] using h_div_zero ++ cases' mul_eq_zero.mp h_mul_zero with h_num h_inv ++ · exact h_num ++ · have : (f c)⁻¹ ≠ 0 := inv_ne_zero h_nonzero ++ exact (this h_inv).elim ++ ++lemma shifted_zeros_correspondence (R1 : ℝ) (hR1 : R1 > 0) (c z : ℂ) ++ (f : ℂ → ℂ) (h_nonzero : f c ≠ 0) (h_analytic : AnalyticOnNhd ℂ f (closedBall c 1)) ++ (hfin_orig : (zerosetKfRc R1 c f).Finite) ++ (hfin_shift : (zerosetKfRc R1 (0 : ℂ) (fun u => f (u + c) / f c)).Finite) : ++ ∑ ρ ∈ hfin_orig.toFinset, ((analyticOrderAt f ρ).toNat : ℂ) / (z - ρ) = ++ ∑ ρ' ∈ hfin_shift.toFinset, ((analyticOrderAt (fun u => f (u + c) / f c) ρ').toNat : ℂ) / ((z - c) - ρ') := by ++ ++ have h_bij : (zerosetKfRc R1 (0 : ℂ) (fun u => f (u + c) / f c)) = (fun ρ => ρ - c) '' (zerosetKfRc R1 c f) := ++ fc_zeros R1 hR1 c f h_nonzero h_analytic ++ ++ apply Finset.sum_bij (fun ρ _ => ρ - c) ++ ++ · intro ρ hρ ++ simp only [Set.Finite.mem_toFinset] at hρ ⊢ ++ rw [h_bij] ++ use ρ, hρ ++ ++ · intro ρ₁ hρ₁ ρ₂ hρ₂ h_eq ++ ++ have : ρ₁ = ρ₁ - c + c := by ring ++ rw [this, h_eq] ++ ring ++ ++ · intro ρ' hρ' ++ simp only [Set.Finite.mem_toFinset] at hρ' ++ rw [h_bij] at hρ' ++ obtain ⟨ρ, hρ_mem, hρ_eq⟩ := hρ' ++ use ρ ++ simp only [Set.Finite.mem_toFinset] ++ exact ⟨hρ_mem, hρ_eq⟩ ++ ++ · intro ρ hρ ++ simp only [Set.Finite.mem_toFinset] at hρ ++ ++ have h_shift_mem : ρ - c ∈ zerosetKfRc R1 (0 : ℂ) (fun u => f (u + c) / f c) := by ++ rw [h_bij] ++ use ρ, hρ ++ ++ have h_order := fc_m_order R1 hR1 c f h_nonzero h_analytic h_shift_mem ++ ++ have h_add : (ρ - c) + c = ρ := by ring ++ rw [h_add] at h_order ++ rw [← h_order] ++ ++ ring ++ ++lemma final_ineq2 ++ (B : ℝ) (hB : 1 < B) (r1 r R R1 : ℝ) (hr1pos : 0 < r1) (hr1_lt_r : r1 < r) (hr_lt_R1 : r < R1) ++ (hR1_lt_R : R1 < R) (hR : R < 1) ++ (c : ℂ) (f : ℂ → ℂ) (h_analytic : AnalyticOnNhd ℂ f (closedBall c 1)) (h_nonzero : f c ≠ 0) ++ (h_bound : ∀ z ∈ closedBall c R, ‖f z‖ < B) ++ (hfin : (zerosetKfRc R1 (0 : ℂ) (fun z => f (z + c) / f c)).Finite) : ++ ∀ z ∈ closedBall (0 : ℂ) r1 \ zerosetKfRc R1 (0 : ℂ) (fun z => f (z + c) / f c), ++ ‖(deriv (fun z => f (z + c) / f c) z / (f (z + c) / f c)) - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt (fun w => f (w + c) / f c) ρ).toNat : ℂ) / (z - ρ)‖ ≤ (16 * r^2 / ((r - r1)^3) + ++ 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * Real.log (B / ‖f c‖) := by ++ intro z hz ++ ++ let g : ℂ → ℂ := fun w => f (w + c) / f c ++ ++ have hR_pos : 0 < R := by linarith [hr1pos, hr1_lt_r, hr_lt_R1, hR1_lt_R] ++ have hR1_pos : 0 < R1 := by linarith [hr1pos, hr1_lt_r, hr_lt_R1] ++ have h_norm_pos : 0 < ‖f c‖ := norm_pos_iff.mpr h_nonzero ++ ++ have h_fc_bound_at_c : ‖f c‖ < B := by ++ apply h_bound ++ rw [mem_closedBall, dist_self] ++ exact le_of_lt hR_pos ++ ++ have h_B_div_gt_one : 1 < B / ‖f c‖ := by ++ rw [one_lt_div h_norm_pos] ++ exact h_fc_bound_at_c ++ ++ have h_g_analytic : ∀ w ∈ closedBall (0 : ℂ) 1, AnalyticAt ℂ g w := ++ (fc_analytic_normalized c f h_analytic h_nonzero).1 ++ ++ have h_g_zero : g 0 = 1 := ++ (fc_analytic_normalized c f h_analytic h_nonzero).2 ++ ++ have h_g_bound : ∀ w ∈ closedBall (0 : ℂ) R, ‖g w‖ ≤ B / ‖f c‖ := by ++ apply fc_bound B hB R hR_pos hR c f h_nonzero ++ intro w hw ++ exact le_of_lt (h_bound w hw) ++ ++ have h_zeroset_equiv : zerosetKfRc R1 (0 : ℂ) g = zerosetKfR R1 hR1_pos g := by ++ ext ρ ++ simp only [zerosetKfRc, zerosetKfR, mem_ofPred_eq, mem_closedBall, Complex.dist_eq, sub_zero] ++ ++ have h_g_finite : (zerosetKfR R1 hR1_pos g).Finite := by ++ rwa [← h_zeroset_equiv] ++ ++ have h_σ_exists : ∃ h_σ : ℂ → (ℂ → ℂ), ∀ σ ∈ zerosetKfR R1 hR1_pos g, ++ AnalyticAt ℂ (h_σ σ) σ ∧ h_σ σ σ ≠ 0 ∧ ++ ∀ᶠ w in nhds σ, g w = (w - σ) ^ (analyticOrderAt g σ).toNat * h_σ σ w := by ++ ++ classical ++ let h_σ : ℂ → (ℂ → ℂ) := fun σ => ++ if hσ : σ ∈ zerosetKfR R1 hR1_pos g ++ then Classical.choose (lem_analytic_zero_factor R R1 hR1_pos hR1_lt_R hR g h_g_analytic ++ (by simp [g]; exact h_nonzero) σ hσ) ++ else fun _ => 0 ++ use h_σ ++ intro σ hσ ++ simp only [h_σ, dite_eq_left hσ] ++ exact Classical.choose_spec (lem_analytic_zero_factor R R1 hR1_pos hR1_lt_R hR g h_g_analytic ++ (by simp [g]; exact h_nonzero) σ hσ) ++ ++ obtain ⟨h_σ, h_σ_spec⟩ := h_σ_exists ++ ++ have := final_ineq1 (B / ‖f c‖) h_B_div_gt_one r1 r R R1 hr1pos hr1_lt_r hr_lt_R1 hR1_lt_R hR ++ g h_g_analytic h_g_zero h_g_finite h_σ_spec h_g_bound z ++ ++ have hz_domain : z ∈ closedBall (0 : ℂ) r1 \ zerosetKfR R1 hR1_pos g := by ++ rw [h_zeroset_equiv] at hz ++ exact hz ++ ++ exact this hz_domain ++ ++lemma log_Deriv_Expansion_Zeta (t : ℝ) (ht : |t| > 2) ++ (r1 r R1 R : ℝ) ++ (hr1_pos : 0 < r1) (hr1_lt_r : r1 < r) ++ (_hr_pos : 0 < r) (hr_lt_R1 : r < R1) (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) : ++ let c := (3/2 : ℂ) + I * t ++ ∀ B > 1, (∀ z ∈ closedBall c R, ‖riemannZeta z‖ < B) → ++ ∀ (hfin : (zerosetKfRc R1 c riemannZeta).Finite), ++ ∀ z ∈ closedBall c r1 \ zerosetKfRc R1 c riemannZeta, ++ ‖logDerivZeta z - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)‖ ≤ (16 * r^2 / ((r - r1)^3) + ++ 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * Real.log (B / ‖riemannZeta c‖) := by ++ intro c B hB h_bound hfin z hzmem ++ ++ have ht1 : |t| > 1 := lt_trans (by norm_num : (1 : ℝ) < 2) (by simpa using ht) ++ ++ have hζ_analytic : AnalyticOnNhd ℂ riemannZeta (closedBall c 1) := by ++ simpa [c] using zetaanalOnD1c t ht1 ++ have hζ_c_ne : riemannZeta c ≠ 0 := by simpa [c] using zetacnot0 t ++ ++ have hfin_shift : (zerosetKfRc R1 (0 : ℂ) (fun u => riemannZeta (u + c) / riemannZeta c)).Finite := by ++ have h_bij := fc_zeros R1 hR1_pos c riemannZeta hζ_c_ne hζ_analytic ++ have himg : ((fun ρ => ρ - c) '' (zerosetKfRc R1 c riemannZeta)).Finite := hfin.image _ ++ simpa [h_bij] using himg ++ ++ have hz0mem : (z - c) ∈ closedBall (0 : ℂ) r1 \ zerosetKfRc R1 (0 : ℂ) (fun u => riemannZeta (u + c) / riemannZeta c) := by ++ have hiff := DminusK r1 R1 hr1_pos hR1_pos c riemannZeta hζ_analytic hζ_c_ne (z - c) ++ exact (hiff).mpr (by simpa [sub_add_cancel] using hzmem) ++ ++ have hineq0 := ++ (final_ineq2 B hB r1 r R R1 hr1_pos hr1_lt_r hr_lt_R1 hR1_lt_R hR_lt_1 c riemannZeta ++ hζ_analytic hζ_c_ne h_bound hfin_shift) (z - c) hz0mem ++ ++ rcases hzmem with ⟨hz_ball, hz_notin⟩ ++ have hr1_lt_R1' : r1 < R1 := lt_trans hr1_lt_r hr_lt_R1 ++ have hz_in_ball_R1 : z ∈ closedBall c R1 := by ++ have hz_le_r1 : dist z c ≤ r1 := by simpa [mem_closedBall] using hz_ball ++ have hr1_le_R1 : r1 ≤ R1 := le_of_lt hr1_lt_R1' ++ have hz_le_R1 : dist z c ≤ R1 := le_trans hz_le_r1 hr1_le_R1 ++ simpa [mem_closedBall] using hz_le_R1 ++ have hzeta_ne : riemannZeta z ≠ 0 := by ++ intro hz0 ++ exact hz_notin ⟨hz_in_ball_R1, hz0⟩ ++ ++ have hcancel_frac : (deriv (fun x => riemannZeta (x + c)) (z - c) / riemannZeta c) ++ / (riemannZeta z / riemannZeta c) ++ = deriv (fun x => riemannZeta (x + c)) (z - c) / riemannZeta z := by ++ have hc : riemannZeta c ≠ 0 := hζ_c_ne ++ have hy : riemannZeta z ≠ 0 := hzeta_ne ++ simpa using (frac_cancel_const (x := deriv (fun x => riemannZeta (x + c)) (z - c)) ++ (y := riemannZeta z) (c := riemannZeta c) hc hy) ++ have hcancel_all : (deriv (fun x => riemannZeta (x + c)) (z - c) / riemannZeta c) ++ / (riemannZeta z / riemannZeta c) ++ = deriv riemannZeta z / riemannZeta z := by ++ simpa [deriv_comp_add_const, sub_add_cancel] using hcancel_frac ++ ++ have hineq1 : ‖(deriv riemannZeta z / riemannZeta z) ++ - ∑ ρ ∈ hfin_shift.toFinset, ++ ((analyticOrderAt (fun u => riemannZeta (u + c) / riemannZeta c) ρ).toNat : ℂ) ++ / ((z - c) - ρ)‖ ++ ≤ (16 * r^2 / ((r - r1)^3) + 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * ++ Real.log (B / ‖riemannZeta c‖) := by ++ simpa [hcancel_all] using hineq0 ++ ++ have hsum_eq := shifted_zeros_correspondence R1 hR1_pos c z riemannZeta hζ_c_ne hζ_analytic hfin hfin_shift ++ ++ have hineq2 : ‖(deriv riemannZeta z / riemannZeta z) ++ - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)‖ ++ ≤ (16 * r^2 / ((r - r1)^3) + 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * ++ Real.log (B / ‖riemannZeta c‖) := by ++ simpa [hsum_eq] using hineq1 ++ ++ simpa [logDerivZeta] using hineq2 ++ ++lemma zeta32lower : ∃ a > 0, ∀ t : ℝ, ‖riemannZeta (3/2 + I * t)‖ ≥ a := by ++ rcases zeta_low_332 with ⟨a, ha_pos, hbound⟩ ++ refine ⟨a, ha_pos, ?_⟩ ++ intro t ++ simpa [mul_comm] using! (hbound t) ++ ++lemma zeta32lower_log : ∃ A > 1, ∀ t : ℝ, ++ Real.log (1 / ‖riemannZeta (3/2 + I * t)‖) ≤ A := by ++ obtain ⟨a, ha_pos, hbound⟩ := zeta32lower ++ refine ⟨max (2 : ℝ) (Real.log (1 / a)), ?_, ?_⟩ ++ · have h1 : (1 : ℝ) < 2 := by norm_num ++ have h2 : (2 : ℝ) ≤ max (2 : ℝ) (Real.log (1 / a)) := by exact le_max_left _ _ ++ exact lt_of_lt_of_le h1 h2 ++ · intro t ++ set x := ‖riemannZeta (3/2 + I * t)‖ with hx ++ have hax : a ≤ x := by ++ simpa [hx] using (hbound t) ++ have hxpos : 0 < x := lt_of_lt_of_le ha_pos hax ++ have hxy : 1 / x ≤ 1 / a := by ++ ++ have := one_div_le_one_div_of_le ha_pos hax ++ ++ simpa [hx] using this ++ have hxpos' : 0 < 1 / x := one_div_pos.mpr hxpos ++ have hlog : Real.log (1 / x) ≤ Real.log (1 / a) := ++ Real.log_le_log hxpos' hxy ++ have : Real.log (1 / x) ≤ max (2 : ℝ) (Real.log (1 / a)) := ++ le_trans hlog (le_max_right _ _) ++ simpa [hx] using this ++ ++lemma zeta32upper_pre : ∃ b > 1, ∀ t : ℝ, ∀ s : ℂ, ‖s‖ ≤ 1 → (2 : ℝ) < |t| → ‖riemannZeta (s + 3/2 + Complex.I * t)‖ < b * |t| := by ++ refine ⟨(12 : ℝ), by norm_num, ?_⟩ ++ intro t s hs ht ++ have hlt : ‖riemannZeta (s + 3/2 + Complex.I * t)‖ < (10 : ℝ) + 2 * |t| := by ++ simpa using! (lem_zetaUppBound t s hs ht) ++ have honele : (1 : ℝ) ≤ |t| := by ++ have : (1 : ℝ) < |t| := lt_trans (by norm_num) ht ++ exact le_of_lt this ++ have h10le : (10 : ℝ) ≤ 10 * |t| := by ++ simpa [mul_comm] using ++ (mul_le_mul_of_nonneg_right honele (by norm_num : (0 : ℝ) ≤ (10 : ℝ))) ++ have hle2 : (10 : ℝ) + 2 * |t| ≤ (12 : ℝ) * |t| := by ++ have htmp := add_le_add_left h10le (2 * |t|) ++ have hcalc : 10 * |t| + 2 * |t| = (12 : ℝ) * |t| := by ring ++ simpa [hcalc] using! htmp ++ exact lt_of_lt_of_le hlt hle2 ++ ++lemma zeta32upper : ∃ b > 1, ∀ t : ℝ, |t| > 2 → ++ let c := (3/2 : ℂ) + I * t ++ ∀ s ∈ closedBall c 1, ‖riemannZeta s‖ < b * |t| := by ++ ++ obtain ⟨b, hb_gt, hbound⟩ := zeta32upper_pre ++ refine ⟨b, hb_gt, ?_⟩ ++ intro t ht c s hs ++ ++ rw [mem_closedBall] at hs ++ ++ set s_pre := s - c with hs_pre_def ++ have hs_pre_bound : ‖s_pre‖ ≤ 1 := by ++ rw [hs_pre_def] ++ rwa [Complex.dist_eq] at hs ++ ++ have hs_eq : s = s_pre + 3/2 + I * t := by ++ rw [hs_pre_def] ++ ring ++ ++ rw [hs_eq] ++ exact hbound t s_pre hs_pre_bound ht ++ ++lemma closedBall_subset_unit (c : ℂ) (R : ℝ) (hR_lt_1 : R < 1) : ++ Metric.closedBall c R ⊆ Metric.closedBall c 1 := by ++ apply Metric.closedBall_subset_closedBall (le_of_lt hR_lt_1) ++ ++lemma zeta_c_nonzero (t : ℝ) : riemannZeta (3/2 + I * t) ≠ 0 := by ++ exact zetacnot0 t ++ ++lemma zeta_c_norm_pos (t : ℝ) : 0 < ‖riemannZeta (3/2 + I * t)‖ := by ++ have h := zetacnot0 t ++ exact norm_pos_iff.mpr h ++ ++lemma Zeta1_Zeta_Expand : ++ ∃ A > 1, ∃ b > 1, ++ ∀ (t : ℝ) (_ht : |t| > 2) ++ (r1 r R1 R : ℝ) ++ (_hr1_pos : 0 < r1) (_hr1_lt_r : r1 < r) ++ (_hr_pos : 0 < r) (_hr_lt_R1 : r < R1) (_hR1_pos : 0 < R1) (_hR1_lt_R : R1 < R) (_hR_lt_1 : R < 1), ++ let c := (3/2 : ℂ) + I * t; ++ ∀ (hfin : (zerosetKfRc R1 c riemannZeta).Finite), ++ ∀ z ∈ closedBall c r1 \ zerosetKfRc R1 c riemannZeta, ++ ‖logDerivZeta z - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)‖ ≤ ++ (16 * r^2 / ((r - r1)^3) + ++ 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * (Real.log |t| + Real.log b + A) := by ++ ++ obtain ⟨b, hbgt1, hb⟩ := zeta32upper ++ obtain ⟨A, hAgt1, hA⟩ := zeta32lower_log ++ ++ refine ⟨A, hAgt1, b, hbgt1, ?_⟩ ++ intro t ht r1 r R1 R hr1_pos hr1_lt_r hr_pos hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 c hfin z hz ++ ++ have hexp_lemma := log_Deriv_Expansion_Zeta t ht r1 r R1 R hr1_pos hr1_lt_r hr_pos hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 ++ ++ have htpos : (0 : ℝ) < |t| := by linarith [ht] ++ have hBgt1 : b * |t| > 1 := by ++ have hb_pos : (0 : ℝ) < b := by linarith [hbgt1] ++ calc (1 : ℝ) < 1 * 2 := by norm_num ++ _ < b * 2 := mul_lt_mul_of_pos_right (by linarith [hbgt1]) (by norm_num) ++ _ < b * |t| := mul_lt_mul_of_pos_left ht hb_pos ++ ++ have hbound_ball : ∀ s ∈ closedBall (3/2 + I * t) R, ‖riemannZeta s‖ < b * |t| := by ++ have hsubset : closedBall (3/2 + I * t) R ⊆ closedBall (3/2 + I * t) 1 := ++ Metric.closedBall_subset_closedBall (le_of_lt hR_lt_1) ++ intro s hs ++ have hs1 : s ∈ closedBall (3/2 + I * t) 1 := hsubset hs ++ have ht2 : |t| > 2 := by linarith [ht] ++ specialize hb t ht2 ++ exact hb s hs1 ++ ++ have hexp := hexp_lemma (b * |t|) hBgt1 hbound_ball hfin z hz ++ ++ have hζne : riemannZeta (3/2 + I * t) ≠ 0 := zetacnot0 t ++ have hζpos : (0 : ℝ) < ‖riemannZeta (3/2 + I * t)‖ := norm_pos_iff.mpr hζne ++ ++ have hBpos : (0 : ℝ) < b * |t| := mul_pos (by linarith [hbgt1]) htpos ++ have hBne : b * |t| ≠ 0 := ne_of_gt hBpos ++ have htne : |t| ≠ 0 := ne_of_gt htpos ++ have hbne : b ≠ 0 := ne_of_gt (by linarith [hbgt1]) ++ ++ have hlog_bound : Real.log (b * |t| / ‖riemannZeta (3/2 + I * t)‖) ≤ ++ Real.log |t| + Real.log b + A := by ++ rw [Real.log_div hBne (ne_of_gt hζpos)] ++ rw [Real.log_mul hbne htne] ++ ++ have hA_bound := hA t ++ have : -Real.log ‖riemannZeta (3/2 + I * t)‖ ≤ A := by ++ have eq_neg : Real.log (1 / ‖riemannZeta (3/2 + I * t)‖) = -Real.log ‖riemannZeta (3/2 + I * t)‖ := by ++ rw [Real.log_div (by norm_num) (ne_of_gt hζpos)] ++ simp ++ rw [← eq_neg] ++ exact hA_bound ++ linarith ++ ++ have hcoeff_nonneg : (0 : ℝ) ≤ 16 * r^2 / ((r - r1)^3) + 1 / ((R^2 / R1 - R1) * Real.log (R / R1)) := by ++ apply add_nonneg ++ · apply div_nonneg ++ · apply mul_nonneg ++ · norm_num ++ · apply sq_nonneg ++ · apply le_of_lt ++ apply pow_pos ++ linarith [hr1_lt_r] ++ · apply div_nonneg ++ · norm_num ++ · apply le_of_lt ++ apply mul_pos ++ · ++ have h_gt : R > R1 := hR1_lt_R ++ have h1_pos : (1 : ℝ) < R/R1 := by ++ rw [one_lt_div] ++ · exact h_gt ++ · exact hR1_pos ++ have h_sq_div : R^2/R1 = R * (R/R1) := by ++ field_simp [ne_of_gt hR1_pos] ++ rw [h_sq_div] ++ have h_r_pos : (0 : ℝ) < R := by linarith [hR1_pos, h_gt] ++ have : R * (R/R1) > R * 1 := by ++ apply mul_lt_mul_of_pos_left h1_pos h_r_pos ++ simp at this ++ linarith [this] ++ · apply Real.log_pos ++ rw [one_lt_div] ++ · exact hR1_lt_R ++ · exact hR1_pos ++ ++ calc ‖logDerivZeta z - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)‖ ++ ≤ (16 * r^2 / ((r - r1)^3) + ++ 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * Real.log (b * |t| / ‖riemannZeta (3/2 + I * t)‖) := hexp ++ _ ≤ (16 * r^2 / ((r - r1)^3) + ++ 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) * (Real.log |t| + Real.log b + A) := by ++ exact mul_le_mul_of_nonneg_left hlog_bound hcoeff_nonneg ++ ++lemma helper_log_ratio_le_sum (b t x A : ℝ) ++ (hb : b > 1) (ht : 0 < |t|) (hx : 0 < x) (hA : Real.log (1 / x) ≤ A) : ++ Real.log ((b * |t|) / x) ≤ Real.log |t| + Real.log b + A := by ++ have hbpos : 0 < b := lt_trans (by norm_num) hb ++ have hb_ne : (b : ℝ) ≠ 0 := ne_of_gt hbpos ++ have ht_ne : |t| ≠ 0 := ne_of_gt ht ++ have hx_ne : x ≠ 0 := ne_of_gt hx ++ have h_inv_ne : (1 / x) ≠ 0 := one_div_ne_zero hx_ne ++ calc ++ Real.log ((b * |t|) / x) ++ = Real.log ((b * |t|) * (1 / x)) := by simp [div_eq_mul_inv] ++ _ = Real.log (b * |t|) + Real.log (1 / x) := by ++ exact Real.log_mul (mul_ne_zero hb_ne ht_ne) h_inv_ne ++ _ ≤ Real.log (b * |t|) + A := by ++ exact add_le_add_right hA (Real.log (b * |t|)) ++ _ = Real.log b + Real.log |t| + A := by ++ have hmul : Real.log (b * |t|) = Real.log b + Real.log |t| := ++ Real.log_mul hb_ne ht_ne ++ simp [hmul, add_comm] ++ _ = Real.log |t| + Real.log b + A := by ++ simp [add_comm] ++ ++lemma helper_bound_sum_by_Klog (t b A : ℝ) ++ (ht : |t| > 3) (hb : b > 1) (hA : A > 1) : ++ ∃ K > 1, Real.log |t| + Real.log b + A ≤ K * Real.log (|t| + 2) := by ++ ++ let S := Real.log b + A ++ let K := 1 + S / Real.log 5 ++ have hpos_t : 0 < |t| := lt_trans (by norm_num) ht ++ ++ have hle_log : Real.log |t| ≤ Real.log (|t| + 2) := by ++ apply Real.log_le_log ++ · exact hpos_t ++ · have hxle : |t| ≤ |t| + 2 := by ++ have h2 : (0 : ℝ) ≤ 2 := by norm_num ++ linarith ++ exact hxle ++ ++ have log5pos : 0 < Real.log (5 : ℝ) := by ++ have : (1 : ℝ) < 5 := by norm_num ++ exact Real.log_pos this ++ have Spos : 0 < S := by ++ have hlogbpos : 0 < Real.log b := Real.log_pos hb ++ have hApos : 0 < A := lt_trans (by norm_num) hA ++ exact add_pos hlogbpos hApos ++ have Kgt1 : 1 < K := by ++ have : 0 < S / Real.log 5 := div_pos Spos log5pos ++ simpa [K] using (lt_add_of_pos_right (1 : ℝ) this) ++ ++ have hlog5_le : Real.log 5 ≤ Real.log (|t| + 2) := by ++ apply Real.log_le_log ++ · exact (by norm_num : 0 < (5 : ℝ)) ++ · have : (5 : ℝ) < |t| + 2 := by linarith [ht] ++ exact le_of_lt this ++ have hfac_nonneg : 0 ≤ S / Real.log 5 := le_of_lt (div_pos Spos log5pos) ++ have hmul : (S / Real.log 5) * Real.log 5 ≤ (S / Real.log 5) * Real.log (|t| + 2) := ++ mul_le_mul_of_nonneg_left hlog5_le hfac_nonneg ++ have hleft : (S / Real.log 5) * Real.log 5 = S := by ++ have hne : (Real.log 5) ≠ 0 := ne_of_gt log5pos ++ field_simp [hne] ++ have hS_le : S ≤ (S / Real.log 5) * Real.log (|t| + 2) := by ++ simp [hleft] at hmul ++ exact hmul ++ ++ refine ⟨K, Kgt1, ?_⟩ ++ calc ++ Real.log |t| + Real.log b + A ++ = Real.log |t| + S := by ++ simp [S, add_comm, add_left_comm] ++ _ ++ ≤ Real.log (|t| + 2) + S := by ++ exact add_le_add_left hle_log S ++ _ ++ ≤ Real.log (|t| + 2) + (S / Real.log 5) * Real.log (|t| + 2) := by ++ exact add_le_add_right hS_le (Real.log (|t| + 2)) ++ _ = (1 + S / Real.log 5) * Real.log (|t| + 2) := by ++ ring ++ _ = K * Real.log (|t| + 2) := by rfl ++ _ = K * Real.log (|t| + 2) := by rfl ++ ++lemma Zeta1_Zeta_Expansion ++ (r1 r : ℝ) ++ (hr1_pos : 0 < r1) (hr1_lt_r : r1 < r) (hr_lt_R1 : r < 5 / (6 : ℝ)) : ++ ∃ C > 1, ++ ∀ (t : ℝ) (_ht : |t| > 3), ++ let c := (3/2 : ℂ) + I * t; ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ ∀ z ∈ closedBall c r1 \ zerosetKfRc (5 / (6 : ℝ)) c riemannZeta, ++ ‖logDerivZeta z - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)‖ ≤ ++ C * (1 / (r - r1)^3 + 1) * Real.log |t| := by ++ ++ obtain ⟨A, hAgt1, b, hbgt1, hmain⟩ := Zeta1_Zeta_Expand ++ ++ let R1 : ℝ := 5 / 6 ++ let R : ℝ := 8 / 9 ++ have hR1_pos : 0 < R1 := by norm_num [R1] ++ have hR1_lt_R : R1 < R := by norm_num [R1, R] ++ have hR_lt_1 : R < 1 := by norm_num [R] ++ have hr_pos : 0 < r := lt_trans hr1_pos hr1_lt_r ++ ++ let d : ℝ := (r - r1) ^ 3 ++ have hd_pos : 0 < d := by ++ have : 0 < r - r1 := sub_pos.mpr hr1_lt_r ++ simpa [d] using pow_pos this 3 ++ let A0 : ℝ := 1 / ((R^2 / R1 - R1) * Real.log (R / R1)) ++ have hA0_pos : 0 < A0 := by ++ have hx1 : 0 < R^2 / R1 - R1 := by ++ ++ norm_num [R, R1] ++ have hx2 : 0 < Real.log (R / R1) := by ++ ++ have : (1 : ℝ) < R / R1 := by norm_num [R, R1] ++ exact Real.log_pos this ++ have hxden : 0 < (R^2 / R1 - R1) * Real.log (R / R1) := mul_pos hx1 hx2 ++ simpa [A0] using (one_div_pos.mpr hxden) ++ ++ let K : ℝ := 16 * r^2 / d + A0 ++ ++ let S : ℝ := Real.log b + A ++ have hS_pos : 0 < S := by ++ have hbpos : 0 < Real.log b := Real.log_pos hbgt1 ++ have hApos : 0 < A := lt_trans (by norm_num) hAgt1 ++ exact add_pos hbpos hApos ++ ++ let Kcoeff : ℝ := max (16 * r^2) A0 ++ have hK_le : K ≤ Kcoeff * (1 / d + 1) := by ++ have hx_nonneg : 0 ≤ 1 / d := by ++ exact le_of_lt (one_div_pos.mpr hd_pos) ++ have hα_le : 16 * r^2 / d ≤ Kcoeff * (1 / d) := by ++ have hα : 16 * r^2 ≤ Kcoeff := le_max_left _ _ ++ have : (16 * r^2) * (1 / d) ≤ Kcoeff * (1 / d) := ++ mul_le_mul_of_nonneg_right hα hx_nonneg ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using this ++ have hβ_le : A0 ≤ Kcoeff * 1 := by ++ have hβ : A0 ≤ Kcoeff := le_max_right _ _ ++ simpa using hβ ++ have : 16 * r^2 / d + A0 ≤ Kcoeff * (1 / d) + Kcoeff * 1 := ++ add_le_add hα_le hβ_le ++ simpa [K, mul_add, mul_one, add_comm, add_left_comm, add_assoc] using this ++ ++ let C : ℝ := max (Kcoeff * (1 + S / Real.log 3)) 2 ++ have hC_gt1 : 1 < C := by ++ have : (1 : ℝ) < 2 := by norm_num ++ exact lt_of_lt_of_le this (le_max_right _ _) ++ refine ⟨C, hC_gt1, ?_⟩ ++ ++ intro t ht ++ ++ simp only ++ intro hfin z hz ++ ++ have ht2 : |t| > 2 := by linarith [ht] ++ have hineq0 := ++ hmain t ht2 r1 r R1 R hr1_pos hr1_lt_r (lt_trans hr1_pos hr1_lt_r) hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 ++ have hineq1 := hineq0 hfin z hz ++ ++ have hK_eq : (16 * r^2 / (r - r1)^3 + 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) = K := by ++ simp [K, A0, d, R1, R] ++ have hLS_eq : Real.log |t| + Real.log b + A = Real.log |t| + S := by ++ simp [S, add_comm, add_assoc] ++ have hineq2 : ‖logDerivZeta z - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)‖ ++ ≤ K * (Real.log |t| + S) := by ++ rw [← hK_eq, ← hLS_eq] ++ exact hineq1 ++ ++ have hlog3pos : 0 < Real.log (3 : ℝ) := by ++ have : (1 : ℝ) < 3 := by norm_num ++ exact Real.log_pos this ++ ++ have hpos_t : 0 < |t| := lt_trans (by norm_num) ht ++ have hL_ge_log3' : Real.log 3 ≤ Real.log |t| := by ++ have hge : (3 : ℝ) ≤ |t| := le_of_lt ht ++ exact Real.log_le_log (by norm_num) hge ++ have hratio_nonneg : 0 ≤ S / Real.log 3 := le_of_lt (div_pos hS_pos hlog3pos) ++ have hneq : Real.log 3 ≠ 0 := ne_of_gt hlog3pos ++ ++ have hS_le : S ≤ (S / Real.log 3) * Real.log |t| := by ++ ++ calc S ++ = (S / Real.log 3) * Real.log 3 := by simp [hneq] ++ _ ≤ (S / Real.log 3) * Real.log |t| := mul_le_mul_of_nonneg_left hL_ge_log3' hratio_nonneg ++ ++ have hsum_bound : Real.log |t| + S ≤ (1 + S / Real.log 3) * Real.log |t| := by ++ have hstep : Real.log |t| + S ≤ Real.log |t| + (S / Real.log 3) * Real.log |t| := ++ add_le_add_right hS_le (Real.log |t|) ++ ++ have h_factor : Real.log |t| + (S / Real.log 3) * Real.log |t| = (1 + S / Real.log 3) * Real.log |t| := by ring ++ rw [← h_factor] ++ exact hstep ++ ++ have hineq3 : ‖logDerivZeta z - ∑ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)‖ ++ ≤ K * ((1 + S / Real.log 3) * Real.log |t|) := ++ le_trans hineq2 (mul_le_mul_of_nonneg_left hsum_bound (by ++ have hr2_nonneg : 0 ≤ r^2 := by ++ have : 0 ≤ r * r := mul_nonneg (le_of_lt hr_pos) (le_of_lt hr_pos) ++ simpa [pow_two] using this ++ have hterm1 : 0 ≤ 16 * r^2 / d := ++ div_nonneg (mul_nonneg (by norm_num) hr2_nonneg) (le_of_lt hd_pos) ++ have : 0 ≤ K := add_nonneg hterm1 (le_of_lt hA0_pos) ++ exact this)) ++ ++ have hKcoeff : K * ((1 + S / Real.log 3) * Real.log |t|) ++ ≤ (Kcoeff * (1 / d + 1)) * ((1 + S / Real.log 3) * Real.log |t|) := ++ mul_le_mul_of_nonneg_right hK_le (by ++ have hLpos : 0 < Real.log |t| := ++ Real.log_pos (lt_trans (by norm_num) ht) ++ have hcoef_pos : 0 < 1 + S / Real.log 3 := ++ add_pos_of_pos_of_nonneg (by norm_num) (le_of_lt (div_pos hS_pos hlog3pos)) ++ have : 0 ≤ (1 + S / Real.log 3) * Real.log |t| := ++ le_of_lt (mul_pos hcoef_pos hLpos) ++ simpa using this) ++ ++ have hfinal := le_trans hineq3 hKcoeff ++ ++ have hC_ge : Kcoeff * (1 + S / Real.log 3) ≤ C := by ++ exact le_max_left _ _ ++ ++ have : (Kcoeff * (1 / d + 1)) * ((1 + S / Real.log 3) * Real.log |t|) ++ ≤ C * (1 / d + 1) * Real.log |t| := by ++ have hnonneg_term : 0 ≤ (1 / d + 1) * Real.log |t| := by ++ have h1 : 0 ≤ 1 / d := le_of_lt (one_div_pos.mpr hd_pos) ++ have h2 : 0 ≤ Real.log |t| := le_of_lt (Real.log_pos (lt_trans (by norm_num) ht)) ++ have : 0 ≤ (1 / d + 1) := add_nonneg h1 (by norm_num) ++ exact mul_nonneg this h2 ++ have hstep := mul_le_mul_of_nonneg_left hC_ge hnonneg_term ++ ++ simpa [mul_comm, mul_left_comm, mul_assoc] using hstep ++ ++ have hfinal_le := le_trans hfinal this ++ simp only [d] at hfinal_le ++ exact hfinal_le ++ ++end Erdos970 +diff --git a/StrongPNT/Erdos970/PNT4_ZeroFreeRegion.lean b/StrongPNT/Erdos970/PNT4_ZeroFreeRegion.lean +new file mode 100644 +index 0000000..37dfc62 +--- /dev/null ++++ b/StrongPNT/Erdos970/PNT4_ZeroFreeRegion.lean +@@ -0,0 +1,6165 @@ ++import StrongPNT.Erdos970.PNT3_RiemannZeta ++import StrongPNT.Erdos970.Z0 ++ ++namespace Erdos970 ++ ++ ++def zeroZ : Set ℂ := {s : ℂ | riemannZeta s = 0} ++ ++def ZetaZerosNearPoint (t : ℝ) : Set ℂ := { ρ : ℂ | ρ ∈ zeroZ ∧ ‖ρ - ((3/2 : ℂ) + t * Complex.I)‖ ≤ (5/6 : ℝ) } ++ ++lemma ZetaZerosNearPoint_finite (t : ℝ) : Set.Finite (ZetaZerosNearPoint t) := by ++ ++ let c : ℂ := (3/2 : ℂ) + t * Complex.I ++ let R : ℝ := (5/6 : ℝ) ++ have hRpos : 0 < R := by norm_num ++ ++ let H : ℂ → ℂ := Function.update (fun s : ℂ => (s - 1) * riemannZeta s) 1 1 ++ have hH_diff : Differentiable ℂ H := by ++ ++ intro s ++ rcases eq_or_ne s 1 with rfl | hs ++ · ++ refine (Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt ?_ ?_).differentiableAt ++ · ++ filter_upwards [self_mem_nhdsWithin] with t ht ++ ++ have hdiff : DifferentiableAt ℂ (fun u : ℂ => (u - 1) * riemannZeta u) t := by ++ have h1 : DifferentiableAt ℂ (fun u : ℂ => u - 1) t := ++ (differentiableAt_id.sub_const 1) ++ have h2 : DifferentiableAt ℂ riemannZeta t := ++ (differentiableAt_riemannZeta ht) ++ exact h1.mul h2 ++ apply DifferentiableAt.congr_of_eventuallyEq hdiff ++ filter_upwards [eventually_ne_nhds ht] with u hu using by ++ simp [H, Function.update_of_ne hu] ++ · ++ simpa [H, continuousAt_update_same] using riemannZeta_residue_one ++ · ++ have hdiff : DifferentiableAt ℂ (fun u : ℂ => (u - 1) * riemannZeta u) s := by ++ have h1 : DifferentiableAt ℂ (fun u : ℂ => u - 1) s := ++ (differentiableAt_id.sub_const 1) ++ have h2 : DifferentiableAt ℂ riemannZeta s := ++ (differentiableAt_riemannZeta hs) ++ exact h1.mul h2 ++ apply DifferentiableAt.congr_of_eventuallyEq hdiff ++ filter_upwards [eventually_ne_nhds hs] with u hu using by ++ simp [H, Function.update_of_ne hu] ++ ++ by_cases hPoleIn : ‖1 - c‖ ≤ R ++ · ++ let g : ℂ → ℂ := fun z => H (z + c) ++ ++ have hzeta_c_ne : riemannZeta c ≠ 0 := by ++ ++ have : c.re = (3/2 : ℝ) := by ++ simp [c, Complex.add_re, Complex.mul_re, Complex.I_re] ++ have hgt : c.re > 1 := by simpa [this] using (by norm_num : (3:ℝ)/2 > 1) ++ ++ exact riemannZeta_ne_zero_of_one_le_re (by ++ ++ have : (1 : ℝ) < c.re := hgt ++ exact le_of_lt this) ++ have hg_nonzero : ∃ z ∈ Metric.ball (0 : ℂ) R, g z ≠ 0 := by ++ ++ have h0in : (0 : ℂ) ∈ Metric.ball (0 : ℂ) R := by ++ simpa [Metric.mem_ball, Complex.dist_eq] using hRpos ++ refine ⟨0, h0in, ?_⟩ ++ ++ have hcne1 : c ≠ (1 : ℂ) := by ++ intro hc; have hcreq : c.re = 1 := by simp [hc, Complex.one_re] ++ have : (3 : ℝ) / 2 = (1 : ℝ) := by ++ simpa [c, Complex.add_re, Complex.mul_re, Complex.I_re] using hcreq ++ norm_num at this ++ have hHc : g 0 = H c := by simp [g] ++ have : g 0 = (c - 1) * riemannZeta c := by ++ simpa [H, Function.update_of_ne hcne1] using hHc ++ simpa [this] using mul_ne_zero (sub_ne_zero.mpr (by ++ ++ exact hcne1)) hzeta_c_ne ++ ++ let Kg : Set ℂ := {ρ : ℂ | ρ ∈ Metric.closedBall (0 : ℂ) R ∧ g ρ = 0} ++ ++ have h_subset : ZetaZerosNearPoint t ⊆ {ρ : ℂ | (ρ - c) ∈ Metric.closedBall 0 R ∧ g (ρ - c) = 0} := by ++ intro ρ hρ ++ rcases hρ with ⟨hzero, hdist⟩ ++ ++ have hball : ρ - c ∈ Metric.closedBall 0 R := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq, c, sub_eq_add_neg] using hdist ++ ++ have hρne1 : (ρ : ℂ) ≠ 1 := by ++ intro hρ1 ++ ++ have hz1_ne : riemannZeta (1 : ℂ) ≠ 0 := riemannZeta_ne_zero_of_one_le_re (by simp) ++ exact hz1_ne (by simpa [hρ1] using! hzero) ++ have hsum : (ρ - c) + c = ρ := by simp [sub_add_cancel] ++ have hxne : (ρ - c) + c ≠ (1 : ℂ) := by simpa [hsum] using hρne1 ++ have hform : g (ρ - c) = (ρ - 1) * riemannZeta ρ := by ++ simp [g, H, hsum, Function.update_of_ne hxne] ++ have hzeroζ : riemannZeta ρ = 0 := hzero ++ have hzero' : g (ρ - c) = 0 := by simp [hform, hzeroζ] ++ exact ⟨hball, hzero'⟩ ++ ++ have hg_diff : Differentiable ℂ g := by ++ intro z ++ have hH := hH_diff (z + c) ++ have h_addc : DifferentiableAt ℂ (fun z : ℂ => z + c) z := ++ (differentiableAt_id.add_const c) ++ simpa [g] using! hH.comp z h_addc ++ have hg_analyticNhd_univ : AnalyticOnNhd ℂ g Set.univ := ++ (Complex.analyticOnNhd_univ_iff_differentiable).2 hg_diff ++ have hg_analyticNhd : AnalyticOnNhd ℂ g (Metric.closedBall (0 : ℂ) 1) := ++ AnalyticOnNhd.mono hg_analyticNhd_univ (by intro z hz; simp) ++ have hNonzero : ∃ z ∈ Metric.ball (0 : ℂ) 1, g z ≠ 0 := by ++ rcases hg_nonzero with ⟨z, hz_in, hz_ne⟩ ++ ++ have hz_in' : z ∈ Metric.ball (0 : ℂ) 1 := by ++ have hRle : (R : ℝ) ≤ 1 := by norm_num ++ exact Metric.ball_subset_ball hRle hz_in ++ exact ⟨z, hz_in', hz_ne⟩ ++ have hfiniteKg : Set.Finite Kg := ++ (lem_Contra_finiteKR R hRpos (by norm_num : R < 1) g hg_analyticNhd hNonzero) ++ ++ have hTarget_eq : {ρ : ℂ | (ρ - c) ∈ Metric.closedBall 0 R ∧ g (ρ - c) = 0} = ++ (fun ρ : ℂ => ρ + c) '' Kg := by ++ ext ρ; constructor ++ · intro h ++ rcases h with ⟨hball, hzero⟩ ++ refine ⟨ρ - c, ⟨?_, ?_⟩, ?_⟩ ++ · exact hball ++ · exact hzero ++ · simp [sub_add_cancel] ++ · intro h ++ rcases h with ⟨z, ⟨hzball, hz0⟩, rfl⟩ ++ constructor ++ · simpa [sub_add_cancel] using hzball ++ · simpa [sub_add_cancel] using hz0 ++ ++ have hTarget_fin : Set.Finite {ρ : ℂ | (ρ - c) ∈ Metric.closedBall 0 R ∧ g (ρ - c) = 0} := by ++ have himg : Set.Finite ((fun ρ : ℂ => ρ + c) '' Kg) := hfiniteKg.image _ ++ ++ exact hTarget_eq ▸ himg ++ exact Set.Finite.subset hTarget_fin h_subset ++ · ++ let g : ℂ → ℂ := fun z => H (z + c) ++ ++ have hzeta_c_ne : riemannZeta c ≠ 0 := by ++ have : c.re = (3/2 : ℝ) := by ++ simp [c, Complex.add_re, Complex.mul_re, Complex.I_re] ++ have hgt : c.re > 1 := by simpa [this] using (by norm_num : (3:ℝ)/2 > 1) ++ exact riemannZeta_ne_zero_of_one_le_re (le_of_lt hgt) ++ have hg_nonzero : ∃ z ∈ Metric.ball (0 : ℂ) R, g z ≠ 0 := by ++ have h0in : (0 : ℂ) ∈ Metric.ball (0 : ℂ) R := by ++ simpa [Metric.mem_ball, Complex.dist_eq] using hRpos ++ refine ⟨0, h0in, ?_⟩ ++ have hcne1 : c ≠ (1 : ℂ) := by ++ intro hc; have hcreq : c.re = 1 := by simp [hc, Complex.one_re] ++ have : (3 : ℝ) / 2 = (1 : ℝ) := by ++ simpa [c, Complex.add_re, Complex.mul_re, Complex.I_re] using hcreq ++ norm_num at this ++ ++ have hHc : g 0 = H c := by simp [g] ++ have : g 0 = (c - 1) * riemannZeta c := by ++ simpa [H, Function.update_of_ne hcne1] using hHc ++ simpa [this] using mul_ne_zero (sub_ne_zero.mpr hcne1) hzeta_c_ne ++ ++ let Kg : Set ℂ := {ρ : ℂ | ρ ∈ Metric.closedBall (0 : ℂ) R ∧ g ρ = 0} ++ ++ have h_subset : ZetaZerosNearPoint t ⊆ {ρ : ℂ | (ρ - c) ∈ Metric.closedBall 0 R ∧ g (ρ - c) = 0} := by ++ intro ρ hρ ++ rcases hρ with ⟨hzero, hdist⟩ ++ have hball : ρ - c ∈ Metric.closedBall 0 R := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq, c, sub_eq_add_neg] using hdist ++ have hρne1 : (ρ : ℂ) ≠ 1 := by ++ intro hρ1 ++ have hz1_ne : riemannZeta (1 : ℂ) ≠ 0 := riemannZeta_ne_zero_of_one_le_re (by simp) ++ exact hz1_ne (by simpa [hρ1] using! hzero) ++ have hsum : (ρ - c) + c = ρ := by simp [sub_add_cancel] ++ have hxne : (ρ - c) + c ≠ (1 : ℂ) := by simpa [hsum] using hρne1 ++ have hform : g (ρ - c) = (ρ - 1) * riemannZeta ρ := by ++ simp [g, H, hsum, Function.update_of_ne hxne] ++ ++ have hzeroζ : riemannZeta ρ = 0 := hzero ++ have hzero' : g (ρ - c) = 0 := by ++ calc ++ g (ρ - c) = (ρ - 1) * riemannZeta ρ := hform ++ _ = (ρ - 1) * 0 := by simp [hzeroζ] ++ _ = 0 := by simp ++ exact ⟨hball, hzero'⟩ ++ ++ have hg_diff : Differentiable ℂ g := by ++ intro z ++ have hH := hH_diff (z + c) ++ have h_addc : DifferentiableAt ℂ (fun z : ℂ => z + c) z := ++ (differentiableAt_id.add_const c) ++ simpa [g] using! hH.comp z h_addc ++ have hg_analyticNhd_univ : AnalyticOnNhd ℂ g Set.univ := ++ (Complex.analyticOnNhd_univ_iff_differentiable).2 hg_diff ++ have hg_analyticNhd : AnalyticOnNhd ℂ g (Metric.closedBall (0 : ℂ) 1) := ++ AnalyticOnNhd.mono hg_analyticNhd_univ (by intro z hz; simp) ++ have hNonzero : ∃ z ∈ Metric.ball (0 : ℂ) 1, g z ≠ 0 := by ++ rcases hg_nonzero with ⟨z, hz_in, hz_ne⟩ ++ have hz_in' : z ∈ Metric.ball (0 : ℂ) 1 := by ++ have hRle : (R : ℝ) ≤ 1 := by norm_num ++ exact Metric.ball_subset_ball hRle hz_in ++ exact ⟨z, hz_in', hz_ne⟩ ++ have hfiniteKg : Set.Finite Kg := ++ (lem_Contra_finiteKR R hRpos (by norm_num : R < 1) g hg_analyticNhd hNonzero) ++ have hTarget_eq : {ρ : ℂ | (ρ - c) ∈ Metric.closedBall 0 R ∧ g (ρ - c) = 0} = ++ (fun ρ : ℂ => ρ + c) '' Kg := by ++ ext ρ; constructor ++ · intro h ++ rcases h with ⟨hball, hzero⟩ ++ refine ⟨ρ - c, ⟨?_, ?_⟩, ?_⟩ ++ · exact hball ++ · exact hzero ++ · simp [sub_add_cancel] ++ · intro h ++ rcases h with ⟨z, ⟨hzball, hz0⟩, rfl⟩ ++ constructor ++ · simpa [sub_add_cancel] using hzball ++ · simpa [sub_add_cancel] using hz0 ++ have hTarget_fin : Set.Finite {ρ : ℂ | (ρ - c) ∈ Metric.closedBall 0 R ∧ g (ρ - c) = 0} := by ++ have himg : Set.Finite ((fun ρ : ℂ => ρ + c) '' Kg) := hfiniteKg.image _ ++ exact hTarget_eq ▸ himg ++ exact Set.Finite.subset hTarget_fin h_subset ++ ++lemma lem_Re1zge0 (z : ℂ) : z.re > 0 → (1 / z).re > 0 := by ++ intro h ++ ++ have hz_ne_zero : z ≠ 0 := by ++ intro hz_eq_zero ++ rw [hz_eq_zero] at h ++ simp at h ++ ++ rw [one_div] ++ ++ rw [Complex.inv_re] ++ ++ apply div_pos h ++ ++ rwa [Complex.normSq_pos] ++ ++lemma lem_sigmage1 (sigma t : ℝ) (hsigma : sigma > 1) : riemannZeta (sigma + t * Complex.I) ≠ 0 := by ++ apply riemannZeta_ne_zero_of_one_le_re ++ simp [Complex.add_re, Complex.mul_re, Complex.I_re] ++ linarith ++ ++lemma lem_sigmale1 (sigma1 t1 : ℝ) : riemannZeta (sigma1 + t1 * Complex.I) = 0 → sigma1 ≤ 1 := by ++ intro h ++ ++ by_contra h_not_le ++ ++ push Not at h_not_le ++ ++ have h_nonzero := lem_sigmage1 sigma1 t1 h_not_le ++ ++ exact h_nonzero h ++ ++lemma lem_sigmale1Zt (t : ℝ) (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : rho1.re ≤ 1 := by ++ ++ have h1 : rho1 ∈ zeroZ := h_rho1_in_Zt.1 ++ ++ have h2 : riemannZeta rho1 = 0 := h1 ++ ++ have h3 : rho1 = rho1.re + rho1.im * Complex.I := by simp [Complex.re_add_im] ++ ++ rw [h3] at h2 ++ ++ exact lem_sigmale1 rho1.re rho1.im h2 ++ ++lemma lem_s_notin_Zt (δ : ℝ) (hδ : 0 < δ) (t : ℝ) : ++ ((1 : ℂ) + δ + t * Complex.I) ∉ ZetaZerosNearPoint t := by ++ intro hmem ++ ++ have h_zero : riemannZeta ((1 : ℂ) + δ + t * Complex.I) = 0 := hmem.1 ++ ++ have h_gt : (1 : ℝ) + δ > 1 := by linarith [hδ] ++ have h_nonzero := lem_sigmage1 (1 + δ) t h_gt ++ ++ have h_coercion : (1 : ℂ) + δ = ↑(1 + δ) := by simp [Complex.ofReal_add] ++ ++ rw [h_coercion] at h_zero ++ exact h_nonzero h_zero ++ ++lemma complex_abs_of_real (x : ℝ) : ‖(x : ℂ)‖ = abs x := by ++ rw [Complex.norm_real, Real.norm_eq_abs] ++ ++lemma complex_add_real_imag_parts (a b : ℝ) (t : ℝ) : ++ ((a : ℂ) + b + t * Complex.I).re = a + b ∧ ((a : ℂ) + b + t * Complex.I).im = t := by ++ constructor ++ ++ · rw [Complex.add_re, Complex.add_re] ++ ++ simp [Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.I_im] ++ ++ · rw [Complex.add_im, Complex.add_im] ++ ++ simp [Complex.ofReal_im, Complex.mul_im, Complex.I_re, Complex.I_im] ++ ++lemma complex_abs_real_cast (r : ℝ) : ‖(r : ℂ)‖ = abs r := Complex.norm_real r ++ ++lemma isBigO_comp_principal_domain {α β E F : Type*} [SeminormedAddCommGroup E] [SeminormedAddCommGroup F] ++ {f : β → E} {g : β → F} {h : α → β} {l : Filter α} {s : Set β} ++ (hfg : f =O[Filter.principal s] g) ++ (h_domain : ∀ᶠ x in l, h x ∈ s) : ++ (f ∘ h) =O[l] (g ∘ h) := by ++ ++ have h_le : Filter.map h l ≤ Filter.principal s := by ++ intro t ht ++ ++ rw [Filter.mem_principal] at ht ++ ++ rw [Filter.mem_map] ++ ++ rw [Filter.eventually_iff] at h_domain ++ ++ apply Filter.mem_of_superset h_domain ++ intro x hx ++ exact ht hx ++ ++ have hfg_map : f =O[Filter.map h l] g := Asymptotics.IsBigO.mono hfg h_le ++ ++ rwa [Asymptotics.isBigO_map] at hfg_map ++ ++lemma isBigOWith_comp_principal_domain {α β E F : Type*} [SeminormedAddCommGroup E] [SeminormedAddCommGroup F] ++ {C : ℝ} {f : β → E} {g : β → F} {h : α → β} {l : Filter α} {s : Set β} ++ (hfg : Asymptotics.IsBigOWith C (Filter.principal s) f g) ++ (h_domain : ∀ᶠ x in l, h x ∈ s) : ++ Asymptotics.IsBigOWith C l (f ∘ h) (g ∘ h) := by ++ ++ rw [Asymptotics.isBigOWith_iff, Filter.eventually_principal] at hfg ++ ++ rw [Asymptotics.isBigOWith_iff] ++ ++ filter_upwards [h_domain] with x hx_in_s ++ ++ exact hfg (h x) hx_in_s ++ ++lemma s_in_D12 (delta : ℝ) (hdelta_pos : 0 < delta) (t : ℝ) (hdelta_lt : delta < 1) : ++ ((1 : ℂ) + (delta : ℝ) + (t : ℝ) * Complex.I) ∈ ++ Metric.ball ((3 / 2 : ℂ) + (t : ℝ) * Complex.I) (1 / 2) := by ++ ++ rw [Metric.mem_ball] ++ ++ have h1 : ((1 : ℂ) + (delta : ℝ) + (t : ℝ) * Complex.I) - ((3 / 2 : ℂ) + (t : ℝ) * Complex.I) = ++ (1 : ℂ) + (delta : ℝ) - (3 / 2 : ℂ) := by ring ++ ++ have h2 : (1 : ℂ) + (delta : ℝ) - (3 / 2 : ℂ) = (delta - 1/2 : ℝ) := by ++ simp [Complex.ofReal_sub] ++ ring ++ ++ rw [Complex.dist_eq, h1, h2, Complex.norm_real] ++ ++ rw [Real.norm_eq_abs] ++ ++ have h3 : abs (delta - 1/2) < 1/2 := by ++ rw [abs_lt] ++ constructor ++ · ++ linarith [hdelta_pos] ++ · ++ linarith [hdelta_lt] ++ exact h3 ++ ++lemma zerosetKfRc_eq_ZetaZerosNearPoint (t : ℝ) : ++ zerosetKfRc (5/6 : ℝ) ((3/2 : ℂ) + t * Complex.I) riemannZeta = ZetaZerosNearPoint t := by ++ ext ρ; constructor ++ · intro h ++ rcases h with ⟨hball, hzero⟩ ++ refine ⟨?hz, ?hnorm⟩ ++ · simpa [zeroZ] using hzero ++ · simpa [Metric.mem_closedBall, Complex.dist_eq, sub_eq_add_neg] using hball ++ · intro h ++ rcases h with ⟨hz, hnorm⟩ ++ refine ⟨?hball, ?hzero⟩ ++ · simpa [Metric.mem_closedBall, Complex.dist_eq, sub_eq_add_neg] using hnorm ++ · simpa [zeroZ] using hz ++ ++lemma mem_closedBall_of_mem_ball {x c : ℂ} {r : ℝ} (hx : x ∈ Metric.ball c r) : ++ x ∈ Metric.closedBall c r := by ++ exact (Metric.ball_subset_closedBall) hx ++ ++lemma I_mul_real_eq_real_mul_I (t : ℝ) : ++ (Complex.I : ℂ) * (t : ℂ) = (t : ℂ) * Complex.I := by ++ simpa using mul_comm (Complex.I : ℂ) (t : ℂ) ++ ++lemma center_eq_comm (t : ℝ) : ++ ((3/2 : ℂ) + (Complex.I : ℂ) * (t : ℂ)) = ((3/2 : ℂ) + (t : ℂ) * Complex.I) := by ++ have h : (Complex.I : ℂ) * (t : ℂ) = (t : ℂ) * Complex.I := by ++ simpa using mul_comm (Complex.I : ℂ) (t : ℂ) ++ simp [h] ++ ++lemma log_abs_le_log_abs_add_two {t : ℝ} (ht : 2 < |t|) : ++ Real.log (abs t) ≤ Real.log (abs t + 2) := by ++ have hpos : 0 < |t| := lt_trans (by norm_num) ht ++ have hle : |t| ≤ |t| + 2 := by nlinarith ++ simpa using Real.log_le_log hpos hle ++ ++lemma s_notin_ZetaZerosNearPoint (δ t : ℝ) (hδ_pos : 0 < δ) : ++ ((1 : ℂ) + δ + t * Complex.I) ∉ ZetaZerosNearPoint t := by ++ intro hmem ++ have hz0 : riemannZeta ((1 : ℂ) + δ + t * Complex.I) = 0 := hmem.1 ++ have : ((1 : ℂ) + δ + t * Complex.I).re = 1 + δ := by simp ++ have hpos : (1 : ℝ) < 1 + δ := by linarith ++ have hnonzero := lem_sigmage1 (1 + δ) t hpos ++ exact hnonzero (by simpa using hz0) ++ ++lemma norm_sub_comm' (x y : ℂ) : ‖x - y‖ = ‖y - x‖ := by ++ calc ++ ‖x - y‖ = ‖-(x - y)‖ := by simpa using (norm_neg (x - y)).symm ++ _ = ‖y - x‖ := by simp [neg_sub] ++ ++lemma s_in_closedBall_12 (δ t : ℝ) (hδ_pos : 0 < δ) (hδ_lt : δ < 1) : ++ ((1 : ℂ) + (δ : ℝ) + (t : ℝ) * Complex.I) ∈ ++ Metric.closedBall ((3 / 2 : ℂ) + (t : ℝ) * Complex.I) (1 / 2) := by ++ ++ have hdiff : ++ ((1 : ℂ) + (δ : ℝ) + (t : ℝ) * Complex.I) - ((3 / 2 : ℂ) + (t : ℝ) * Complex.I) ++ = ((1 : ℂ) + (δ : ℝ)) - (3 / 2 : ℂ) := by ++ simp ++ have hreal : ++ ((1 : ℂ) + (δ : ℝ)) - (3 / 2 : ℂ) = ((δ - (1 / 2 : ℝ)) : ℂ) := by ++ have h' : ((1 + δ : ℝ) - (3 / 2 : ℝ)) = δ - (1 / 2 : ℝ) := by ++ calc ++ (1 + δ) - (3 / 2 : ℝ) = δ + 1 - (3 / 2 : ℝ) := by ac_rfl ++ _ = δ + (1 - (3 / 2 : ℝ)) := by simp [add_sub_assoc] ++ _ = δ + (- (1 / 2 : ℝ)) := by norm_num ++ _ = δ - (1 / 2 : ℝ) := by simp [sub_eq_add_neg] ++ calc ++ ((1 : ℂ) + (δ : ℝ)) - (3 / 2 : ℂ) ++ = ((1 + δ : ℝ) : ℂ) - (3 / 2 : ℂ) := by ++ simp [add_comm] ++ _ = (↑((1 + δ : ℝ) - (3 / 2 : ℝ)) : ℂ) := by ++ simp [Complex.ofReal_sub] ++ _ = ((δ - (1 / 2 : ℝ)) : ℂ) := by simp [h'] ++ have hnormle : ++ ‖((1 : ℂ) + (δ : ℝ) + (t : ℝ) * Complex.I) - ((3 / 2 : ℂ) + (t : ℝ) * Complex.I)‖ ++ ≤ (1 / 2 : ℝ) := by ++ calc ++ ‖((1 : ℂ) + (δ : ℝ) + (t : ℝ) * Complex.I) - ((3 / 2 : ℂ) + (t : ℝ) * Complex.I)‖ ++ = ‖((1 : ℂ) + (δ : ℝ)) - (3 / 2 : ℂ)‖ := by simp [hdiff] ++ _ = ‖((δ - (1 / 2 : ℝ)) : ℂ)‖ := by simp [hreal] ++ _ = |δ - (1 / 2 : ℝ)| := by simpa using complex_abs_real_cast (δ - (1 / 2 : ℝ)) ++ _ ≤ 1 / 2 := by ++ have hleft : - (1 / 2 : ℝ) ≤ δ - 1 / 2 := by linarith [hδ_pos] ++ have hright : δ - 1 / 2 ≤ 1 / 2 := by linarith [hδ_lt] ++ simpa using (abs_le.mpr ⟨hleft, hright⟩) ++ ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hnormle ++ ++lemma lem_explicit1deltat : ++ ∃ C > 1, ++ ∀ t : ℝ, 2 < |t| → ++ ∀ δ : ℝ, 0 < δ ∧ δ < 1 → ++ ‖Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) ++ (fun rho1 : ℂ => ++ ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (((1 : ℂ) + δ + t * Complex.I) - rho1)) ++ - logDerivZeta ((1 : ℂ) + (δ : ℝ) + (t : ℝ) * Complex.I)‖ ++ ≤ C * Real.log (abs t + 2) := by ++ classical ++ ++ let r1 : ℝ := (1/2 : ℝ) ++ let r : ℝ := (2/3 : ℝ) ++ let R1 : ℝ := (5/6 : ℝ) ++ let R : ℝ := (9/10 : ℝ) ++ have hr1_pos : 0 < r1 := by norm_num ++ have hr_pos : 0 < r := by norm_num ++ have hr1_lt_r : r1 < r := by norm_num ++ have hr_lt_R1 : r < R1 := by norm_num ++ have hR1_pos : 0 < R1 := by norm_num ++ have hR1_lt_R : R1 < R := by norm_num ++ have hR_lt_1 : R < 1 := by norm_num ++ ++ let F : ℝ := (16 * r^2 / ((r - r1)^3) + 1 / ((R^2 / R1 - R1) * Real.log (R / R1))) ++ ++ obtain ⟨b, hb_gt1, hb_bound⟩ := zeta32upper ++ obtain ⟨A, hA_gt1, hA_bound⟩ := zeta32lower_log ++ ++ let K : ℝ := 1 + (Real.log b + A) / Real.log 4 ++ ++ let C : ℝ := max (F * K) 2 ++ have hC_gt1 : 1 < C := by ++ have : (1 : ℝ) < 2 := by norm_num ++ exact lt_of_lt_of_le this (le_max_right _ _) ++ refine ⟨C, hC_gt1, ?_⟩ ++ ++ intro t ht δ hδ ++ rcases hδ with ⟨hδ_pos, hδ_lt1⟩ ++ ++ let c_std : ℂ := ((3/2 : ℂ) + Complex.I * (t : ℂ)) ++ let c_comm : ℂ := ((3/2 : ℂ) + (t : ℝ) * Complex.I) ++ have hcenter_eq : c_std = c_comm := by simpa [c_std, c_comm] using (center_eq_comm t) ++ let s : ℂ := (1 : ℂ) + δ + t * Complex.I ++ ++ have hs_mem_comm : s ∈ Metric.closedBall c_comm r1 := s_in_closedBall_12 δ t hδ_pos hδ_lt1 ++ have hs_mem_std : s ∈ Metric.closedBall c_std r1 := by simpa [c_std, c_comm, hcenter_eq] using hs_mem_comm ++ ++ have hs_notin_Zt : s ∉ ZetaZerosNearPoint t := s_notin_ZetaZerosNearPoint δ t hδ_pos ++ have hzeros_eq : zerosetKfRc (5/6 : ℝ) c_comm riemannZeta = ZetaZerosNearPoint t := by ++ simpa [c_comm] using zerosetKfRc_eq_ZetaZerosNearPoint t ++ have hs_notin_comm : s ∉ zerosetKfRc (5/6 : ℝ) c_comm riemannZeta := by simpa [hzeros_eq] using hs_notin_Zt ++ have hs_notin_std : s ∉ zerosetKfRc (5/6 : ℝ) c_std riemannZeta := by simpa [c_std, c_comm, hcenter_eq] using hs_notin_comm ++ ++ have hfin_comm : (zerosetKfRc (5/6 : ℝ) c_comm riemannZeta).Finite := by ++ simpa [hzeros_eq] using (ZetaZerosNearPoint_finite t) ++ have hfin_std : (zerosetKfRc (5/6 : ℝ) c_std riemannZeta).Finite := by ++ simpa [c_std, c_comm, hcenter_eq] using hfin_comm ++ ++ have h_bound_R : ∀ z ∈ Metric.closedBall c_std R, ‖riemannZeta z‖ < b * |t| := by ++ intro z hz ++ have hsubs : Metric.closedBall c_std R ⊆ Metric.closedBall c_std (1 : ℝ) := by ++ intro w hw; exact Metric.closedBall_subset_closedBall (by norm_num : (R : ℝ) ≤ (1 : ℝ)) hw ++ exact hb_bound t (by simpa using ht) z (hsubs hz) ++ ++ have hmain := ++ log_Deriv_Expansion_Zeta t ht ++ r1 r R1 R hr1_pos hr1_lt_r hr_pos hr_lt_R1 hR1_pos hR1_lt_R hR_lt_1 ++ ++ have hbpos : 0 < b := lt_trans (by norm_num) hb_gt1 ++ have ht1 : 1 < |t| := lt_trans (by norm_num) ht ++ have hmul : b * 1 < b * |t| := (mul_lt_mul_of_pos_left ht1 hbpos) ++ have hB_gt1 : 1 < b * |t| := lt_trans hb_gt1 (by simpa using hmul) ++ have hineq := hmain (b * |t|) hB_gt1 h_bound_R ++ have hz_in : s ∈ Metric.closedBall c_std r1 \ zerosetKfRc (5/6 : ℝ) c_std riemannZeta := ⟨hs_mem_std, hs_notin_std⟩ ++ have hineq2 := hineq hfin_std s hz_in ++ ++ have hFinset_eq : hfin_std.toFinset = (ZetaZerosNearPoint_finite t).toFinset := by ++ ext ρ; constructor <;> intro hρ ++ · have : ρ ∈ zerosetKfRc (5/6 : ℝ) c_std riemannZeta := by simpa [Set.mem_toFinset] using hρ ++ have : ρ ∈ ZetaZerosNearPoint t := by ++ have heq : zerosetKfRc (5/6 : ℝ) c_std riemannZeta = zerosetKfRc (5/6 : ℝ) c_comm riemannZeta := by ++ ++ simp [c_std, c_comm, hcenter_eq] ++ simpa [hzeros_eq, heq] ++ using this ++ simpa [Set.mem_toFinset] using this ++ · have : ρ ∈ ZetaZerosNearPoint t := by simpa [Set.mem_toFinset] using hρ ++ have : ρ ∈ zerosetKfRc (5/6 : ℝ) c_comm riemannZeta := by simpa [hzeros_eq] using this ++ have heq : zerosetKfRc (5/6 : ℝ) c_std riemannZeta = zerosetKfRc (5/6 : ℝ) c_comm riemannZeta := by ++ simp [c_std, c_comm, hcenter_eq] ++ have : ρ ∈ zerosetKfRc (5/6 : ℝ) c_std riemannZeta := by simpa [heq] using this ++ simpa [Set.mem_toFinset] using this ++ have hLHS_le : ++ ‖Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) ++ (fun rho1 : ℂ => ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (s - rho1)) ++ - logDerivZeta s‖ ++ ≤ F * Real.log (b * |t| / ‖riemannZeta c_std‖) := by ++ have : ++ ‖logDerivZeta s - ++ Finset.sum (hfin_std.toFinset) ++ (fun ρ : ℂ => ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (s - ρ))‖ ++ ≤ F * Real.log (b * |t| / ‖riemannZeta c_std‖) := by ++ simpa [F] using! hineq2 ++ simpa [norm_sub_comm', hFinset_eq] ++ using this ++ ++ have hc_ne : riemannZeta c_std ≠ 0 := by simpa [c_std] using! zetacnot0 t ++ have hnorm_pos : 0 < ‖riemannZeta c_std‖ := by simpa [norm_pos_iff] using hc_ne ++ have hnorm_ne : ‖riemannZeta c_std‖ ≠ 0 := ne_of_gt hnorm_pos ++ have hb_ne : b ≠ 0 := ne_of_gt hbpos ++ have htpos0 : 0 < |t| := lt_trans (by norm_num) ht ++ have ht_ne : |t| ≠ 0 := ne_of_gt htpos0 ++ have hlog_mul1 : ++ Real.log (b * |t| / ‖riemannZeta c_std‖) ++ = Real.log (b * |t|) + Real.log (1 / ‖riemannZeta c_std‖) := by ++ simpa [div_eq_mul_inv] using Real.log_mul (mul_ne_zero hb_ne ht_ne) (inv_ne_zero hnorm_ne) ++ have hlog_mul2 : Real.log (b * |t|) = Real.log b + Real.log (|t|) := by ++ simpa using Real.log_mul hb_ne ht_ne ++ have hζ_log_le : Real.log (1 / ‖riemannZeta c_std‖) ≤ A := by ++ simpa [c_std] using! hA_bound t ++ have hlog_bound1 : ++ Real.log (b * |t| / ‖riemannZeta c_std‖) ++ ≤ (Real.log b + Real.log (|t|)) + A := by ++ have := add_le_add_right hζ_log_le (Real.log (b * |t|)) ++ simpa [hlog_mul1, hlog_mul2, add_comm, add_left_comm, add_assoc] using this ++ ++ have hlog_mono : Real.log (|t|) ≤ Real.log (|t| + 2) := ++ log_abs_le_log_abs_add_two (by simpa using ht) ++ have hlog_bound2 : ++ Real.log (b * |t| / ‖riemannZeta c_std‖) ++ ≤ Real.log (|t| + 2) + (Real.log b + A) := by ++ have : Real.log b + Real.log (|t|) + A ≤ Real.log b + Real.log (|t| + 2) + A := by ++ have := add_le_add_right hlog_mono (Real.log b) ++ simpa [add_comm, add_left_comm, add_assoc] using add_le_add_left this A ++ exact le_trans hlog_bound1 (by simpa [add_comm, add_left_comm, add_assoc] using this) ++ ++ have hlog5pos : 0 < Real.log 4 := Real.log_pos (by norm_num : (1 : ℝ) < 4) ++ have hge5 : Real.log 4 ≤ Real.log (|t| + 2) := by ++ have hxy : (4 : ℝ) ≤ |t| + 2 := by nlinarith [le_of_lt ht] ++ exact Real.log_le_log (by norm_num) hxy ++ have hconst_nonneg : 0 ≤ Real.log b + A := by ++ have hbposlog : 0 < Real.log b := Real.log_pos hb_gt1 ++ have hApos : 0 < A := lt_trans (by norm_num) hA_gt1 ++ have : 0 ≤ Real.log b := le_of_lt hbposlog ++ nlinarith ++ have hnonneg : 0 ≤ (Real.log b + A) / Real.log 4 := div_nonneg hconst_nonneg (le_of_lt hlog5pos) ++ have hne5 : Real.log 4 ≠ 0 := ne_of_gt hlog5pos ++ have hconst_bound : (Real.log b + A) ++ ≤ (Real.log b + A) / Real.log 4 * Real.log (|t| + 2) := by ++ have := mul_le_mul_of_nonneg_left hge5 hnonneg ++ ++ have : ((Real.log b + A) / Real.log 4) * Real.log 4 ≤ (Real.log b + A) / Real.log 4 * Real.log (|t| + 2) := this ++ ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc, hne5] using this ++ have hlog_bound3 : ++ Real.log (|t| + 2) + (Real.log b + A) ++ ≤ K * Real.log (|t| + 2) := by ++ have := add_le_add_right hconst_bound (Real.log (|t| + 2)) ++ ++ simpa [K, mul_add, add_comm, add_left_comm, add_assoc, mul_comm, mul_left_comm, mul_assoc, one_mul] ++ using this ++ have hlog_bound_final : ++ Real.log (b * |t| / ‖riemannZeta c_std‖) ++ ≤ K * Real.log (|t| + 2) := le_trans hlog_bound2 hlog_bound3 ++ ++ have hF_nonneg : 0 ≤ F := by ++ have h1 : 0 ≤ 16 * r ^ 2 / (r - r1) ^ 3 := by ++ have hnum : 0 ≤ 16 * r ^ 2 := by ++ have : 0 ≤ (16 : ℝ) := by norm_num ++ have : 0 ≤ r ^ 2 := by ++ have := sq_nonneg r ++ simpa [pow_two] using this ++ simpa [mul_comm] using mul_nonneg (show 0 ≤ (16 : ℝ) by norm_num) this ++ have hden : 0 < (r - r1) ^ 3 := by ++ have : 0 < r - r1 := sub_pos.mpr hr1_lt_r ++ simpa using pow_pos this 3 ++ exact div_nonneg hnum (le_of_lt hden) ++ have h2 : 0 ≤ 1 / ((R ^ 2 / R1 - R1) * Real.log (R / R1)) := by ++ ++ have hden1 : 0 < (R ^ 2 / R1 - R1) := by ++ change 0 < ((9/10 : ℝ) ^ 2 / (5/6 : ℝ) - (5/6 : ℝ)) ++ norm_num ++ have hden2 : 0 < Real.log (R / R1) := by ++ have : 1 < R / R1 := by ++ change (1 : ℝ) < (9/10 : ℝ) / (5/6 : ℝ) ++ norm_num ++ exact Real.log_pos this ++ have hpos : 0 < ((R ^ 2 / R1 - R1) * Real.log (R / R1)) := mul_pos hden1 hden2 ++ exact le_of_lt (one_div_pos.mpr hpos) ++ have := add_nonneg h1 h2 ++ simpa [F] using this ++ ++ have hY_nonneg : 0 ≤ Real.log (|t| + 2) := by ++ ++ have hgt1 : (1 : ℝ) < |t| + 2 := by ++ have : (2 : ℝ) ≤ |t| + 2 := by ++ have : 0 ≤ |t| := abs_nonneg t ++ simp ++ exact lt_of_lt_of_le (by norm_num) this ++ exact le_of_lt (Real.log_pos hgt1) ++ have hfinal1 : ++ ‖Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) ++ (fun rho1 : ℂ => ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (s - rho1)) ++ - logDerivZeta s‖ ++ ≤ F * (K * Real.log (|t| + 2)) := ++ le_trans hLHS_le (by exact mul_le_mul_of_nonneg_left hlog_bound_final hF_nonneg) ++ have hFactor_leC : F * K ≤ C := by exact le_trans (le_of_eq rfl) (le_max_left _ _) ++ have hfinal2 : F * (K * Real.log (|t| + 2)) ≤ C * Real.log (|t| + 2) := by ++ have := mul_le_mul_of_nonneg_right hFactor_leC hY_nonneg ++ simpa [mul_comm, mul_left_comm, mul_assoc] using this ++ have := le_trans hfinal1 hfinal2 ++ simpa [s] ++ ++lemma lem_explicit1RealReal : ++ ∃ C > 1, ++ ∀ t : ℝ, 2 < |t| → ++ ∀ δ : ℝ, 0 < δ ∧ δ < 1 → ++ abs ((logDerivZeta ((1 : ℂ) + (δ : ℝ) + (t : ℝ) * Complex.I)).re ++ - (Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) ++ (fun rho1 : ℂ => ++ (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (((1 : ℂ) + δ + t * Complex.I) - rho1)).re))) ++ ≤ C * Real.log (|t| + 2) := by ++ rcases lem_explicit1deltat with ⟨C, hCpos, hE⟩ ++ refine ⟨C, hCpos, ?_⟩ ++ intro t ht δ hδ ++ ++ let s : ℂ := (1 : ℂ) + (δ : ℝ) + (t : ℝ) * Complex.I ++ let S : Finset ℂ := Set.Finite.toFinset (ZetaZerosNearPoint_finite t) ++ let g : ℂ → ℂ := fun rho1 : ℂ => ++ ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (s - rho1) ++ ++ have ht' : ‖logDerivZeta s - ∑ rho1 ∈ S, g rho1‖ ++ ≤ C * Real.log (abs t + 2) := by ++ ++ have h_app := hE t ht δ hδ ++ rw [norm_sub_rev] at h_app ++ exact h_app ++ ++ have hleft_eq : ++ abs ((logDerivZeta s).re - ∑ rho1 ∈ S, (g rho1).re) ++ = abs ((logDerivZeta s - ∑ rho1 ∈ S, g rho1).re) := by ++ simp [Complex.sub_re, Complex.re_sum] ++ ++ have hbound : ++ abs ((logDerivZeta s - ∑ rho1 ∈ S, g rho1).re) ++ ≤ ‖logDerivZeta s - ∑ rho1 ∈ S, g rho1‖ := by ++ simpa using Complex.abs_re_le_norm (logDerivZeta s - ∑ rho1 ∈ S, g rho1) ++ ++ have hfinal : ++ abs ((logDerivZeta s - ∑ rho1 ∈ S, g rho1).re) ++ ≤ C * Real.log (abs t + 2) := ++ le_trans hbound ht' ++ ++ have hnorm : |t| = abs t := rfl ++ simpa [s, S, g, hleft_eq, hnorm] using hfinal ++ ++lemma lem_explicit2Real : ++ ∃ C > 1, ++ ∀ t : ℝ, 2 < |t| → ++ ∀ δ : ℝ, 0 < δ ∧ δ < 1 → ++ abs ( ++ (logDerivZeta ((1 : ℂ) + (δ : ℝ) + (2 * (t : ℝ)) * Complex.I)).re ++ - (Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite (2 * t))) ++ (fun rho1 : ℂ => ++ (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (((1 : ℂ) + δ + (2 * t) * Complex.I) - rho1)).re)) ++ ) ++ ≤ C * Real.log (abs (2 * t) + 2) := by ++ rcases lem_explicit1RealReal with ⟨C, hCpos, hEv⟩ ++ refine ⟨C, hCpos, ?_⟩ ++ intro t ht δ hδ ++ ++ have h_2t : 2 < |2 * t| := by ++ rw [abs_mul, abs_two] ++ linarith [ht] ++ have h_bound := hEv (2 * t) h_2t δ hδ ++ ++ simp only [Complex.ofReal_mul] at h_bound ++ exact h_bound ++ ++lemma lem_Realsum {α : Type*} (s : Finset α) (f : α → ℂ) : (Finset.sum s f).re = Finset.sum s (fun i => (f i).re) := by ++ exact Complex.re_sum s f ++ ++lemma lem_Ztfinite (t : ℝ) : Set.Finite (ZetaZerosNearPoint t) := ZetaZerosNearPoint_finite t ++ ++lemma lem_sumrho1 (t : ℝ) (δ : ℝ) (_hdelta_pos : δ > 0) (_hdelta_lt1 : δ < 1) : ++ (Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) ++ (fun rho1 : ℂ => ++ ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (((1 : ℂ) + δ + t * Complex.I) - rho1))).re = ++ Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) ++ (fun rho1 : ℂ => ++ (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (((1 : ℂ) + δ + t * Complex.I) - rho1)).re) := by ++ exact lem_Realsum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) _ ++ ++lemma lem_sumrho2 (t : ℝ) (delta : ℝ) (_hdelta : delta > 0) (_hdelta_lt1 : delta < 1) : ++ (Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite (2 * t))) ++ (fun rho1 : ℂ => ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + (2 * t) * Complex.I) - rho1))).re = ++ Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite (2 * t))) ++ (fun rho1 : ℂ => (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + (2 * t) * Complex.I) - rho1)).re) := by ++ rw [Complex.re_sum] ++ ++lemma lem_1deltatrho1 (delta : ℝ) (_hdelta : delta > 0) (t : ℝ) (rho1 : ℂ) (_h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : ((1 : ℂ) + delta + t * Complex.I - rho1) = ((1 : ℝ) + delta - rho1.re) + (t - rho1.im) * Complex.I := by ++ ++ conv_lhs => rw [← Complex.re_add_im rho1] ++ ++ simp only [sub_add_eq_sub_sub] ++ ++ ring_nf ++ ++ simp only [Complex.ofReal_one] ++ ring ++ ++lemma lem_Re1deltatrho1 (delta : ℝ) (hdelta : delta > 0) (t : ℝ) (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : ++((1 : ℂ) + delta + t * Complex.I - rho1).re = (1 : ℝ) + delta - rho1.re := by ++ ++ rw [lem_1deltatrho1 delta hdelta t rho1 h_rho1_in_Zt] ++ ++ rw [Complex.add_re] ++ ++ rw [Complex.mul_I_re] ++ ++ simp ++ ++lemma lem_Re1delta1 (delta : ℝ) (_hdelta : delta > 0) (t : ℝ) (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : ++(1 : ℝ) + delta - rho1.re ≥ delta := by ++ ++ have h_rho1_re_le_1 : rho1.re ≤ 1 := lem_sigmale1Zt t rho1 h_rho1_in_Zt ++ ++ have h_nonneg : 1 - rho1.re ≥ 0 := by linarith ++ ++ linarith ++ ++lemma lem_Re1deltatge (delta : ℝ) (hdelta : delta > 0) (t : ℝ) (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : ((1 : ℂ) + delta + t * Complex.I - rho1).re ≥ delta := by ++ ++ rw [lem_Re1deltatrho1 delta hdelta t rho1 h_rho1_in_Zt] ++ ++ exact lem_Re1delta1 delta hdelta t rho1 h_rho1_in_Zt ++ ++lemma lem_Re1deltatneq0 (delta : ℝ) (hdelta : delta > 0) (t : ℝ) (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : ++((1 : ℂ) + delta + t * Complex.I - rho1).re > 0 := by ++ ++ have h_ge_delta : ((1 : ℂ) + delta + t * Complex.I - rho1).re ≥ delta := lem_Re1deltatge delta hdelta t rho1 h_rho1_in_Zt ++ ++ linarith [hdelta] ++ ++lemma lem_Re1deltatge0 (delta : ℝ) (hdelta : delta > 0) (t : ℝ) (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : ++(1 / ((1 : ℂ) + delta + t * Complex.I - rho1)).re ≥ 0 := by ++ ++ apply le_of_lt ++ apply lem_Re1zge0 ++ ++ exact lem_Re1deltatneq0 delta hdelta t rho1 h_rho1_in_Zt ++ ++lemma lem_Re1deltatge0m (delta : ℝ) (hdelta : delta > 0) (t : ℝ) (_hdelta_lt_1 : delta < 1) ++ (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint t) : ++ (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (((1 : ℂ) + delta + t * Complex.I) - rho1)).re ≥ 0 := by ++ ++ let n := (analyticOrderAt riemannZeta rho1).toNat ++ let z := ((1 : ℂ) + delta + t * Complex.I) - rho1 ++ ++ have h_eq : (n : ℂ) / z = n • (1/z) := by ++ rw [nsmul_eq_mul] ++ simp [div_eq_mul_inv] ++ ++ rw [h_eq, Complex.re_nsmul] ++ ++ apply nsmul_nonneg ++ exact lem_Re1deltatge0 delta hdelta t rho1 h_rho1_in_Zt ++ ++lemma lem_Re1delta2tge0 (delta : ℝ) (hdelta : delta > 0) (hdelta_lt_1 : delta < 1) (t : ℝ) (rho1 : ℂ) (h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint (2 * t)) : ++(((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ((1 : ℂ) + delta + (2 * t) * Complex.I - rho1)).re ≥ 0 := by ++ ++ convert lem_Re1deltatge0m delta hdelta (2 * t) hdelta_lt_1 rho1 h_rho1_in_Zt ++ simp ++ ++lemma lem_sumrho2ge (t : ℝ) (delta : ℝ) (hdelta : delta > 0) (hdelta_lt_1 : delta < 1) : ++Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite (2 * t))) (fun rho1 : ℂ => (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ((1 : ℂ) + delta + (2 * t) * Complex.I - rho1)).re) ≥ 0 := by ++ apply Finset.sum_nonneg ++ intro rho1 h_rho1_in_finset ++ ++ have h_rho1_in_Zt : rho1 ∈ ZetaZerosNearPoint (2 * t) := by ++ rwa [Set.Finite.mem_toFinset (ZetaZerosNearPoint_finite (2 * t))] at h_rho1_in_finset ++ ++ exact lem_Re1delta2tge0 delta hdelta hdelta_lt_1 t rho1 h_rho1_in_Zt ++ ++lemma lem_sumrho2ge02 (t : ℝ) (delta : ℝ) (hdelta : delta > 0) (hdelta_lt_1 : delta < 1) : ++ (Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite (2 * t))) ++(fun rho1 : ℂ => ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + (2 * t) * Complex.I) - rho1))).re ≥ 0 := by ++ ++ rw [lem_sumrho2 t delta hdelta hdelta_lt_1] ++ ++ exact lem_sumrho2ge t delta hdelta hdelta_lt_1 ++ ++lemma lem_explicit2Real2 : ++ ∃ C > 1, ++ ∀ t : ℝ, 2 < |t| → ++ ∀ δ : ℝ, 0 < δ ∧ δ < 1 → ++ ((-logDerivZeta ((1 : ℂ) + (δ : ℝ) + (2 * (t : ℝ)) * Complex.I)).re) ++ ≤ C * Real.log (abs (2 * t) + 2) := by ++ rcases lem_explicit2Real with ⟨C, hCpos, hEv⟩ ++ refine ⟨C, hCpos, ?_⟩ ++ intro t ht δ hδ ++ ++ set s : ℂ := (1 : ℂ) + (δ : ℝ) + (2 * (t : ℝ)) * Complex.I ++ set S : Finset ℂ := Set.Finite.toFinset (ZetaZerosNearPoint_finite (2 * t)) ++ set Sre : ℝ := ++ Finset.sum S ++ (fun rho1 : ℂ => ++ (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (s - rho1)).re) ++ ++ have h_bound : ++ abs ((logDerivZeta s).re - Sre) ++ ≤ C * Real.log (abs (2 * t) + 2) := by ++ simpa [s, S, Sre] using hEv t ht δ hδ ++ ++ have hS_nonneg : 0 ≤ Sre := by ++ ++ have h0 := lem_sumrho2ge02 t δ hδ.1 hδ.2 ++ ++ simpa [s, S, Sre, lem_sumrho2 t δ hδ.1 hδ.2] using h0 ++ ++ have h_left : -(C * Real.log (abs (2 * t) + 2)) ≤ (logDerivZeta s).re - Sre := ++ (abs_le.mp h_bound).1 ++ ++ have h_neg : -((logDerivZeta s).re - Sre) ≤ C * Real.log (abs (2 * t) + 2) := by ++ simpa using neg_le_neg h_left ++ ++ have h_aux := sub_le_sub_right h_neg Sre ++ have h_isol : - (logDerivZeta s).re ≤ C * Real.log (abs (2 * t) + 2) - Sre := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using h_aux ++ ++ have h_drop : C * Real.log (abs (2 * t) + 2) - Sre ≤ C * Real.log (abs (2 * t) + 2) := ++ sub_le_self _ hS_nonneg ++ ++ have h_final := le_trans h_isol h_drop ++ ++ simpa [s, Complex.neg_re] using h_final ++ ++lemma lem_log2Olog : (fun t : ℝ => Real.log (2 * t)) =O[Filter.atTop] (fun t : ℝ => Real.log t) := by ++ ++ have h_eq : (fun t : ℝ => Real.log (2 * t)) =ᶠ[Filter.atTop] (fun t : ℝ => Real.log 2 + Real.log t) := by ++ filter_upwards [Filter.eventually_gt_atTop (0 : ℝ)] with t ht ++ rw [Real.log_mul (by norm_num : (2 : ℝ) ≠ 0) (ne_of_gt ht)] ++ ++ have h_bigO : (fun t : ℝ => Real.log 2 + Real.log t) =O[Filter.atTop] (fun t : ℝ => Real.log t) := by ++ ++ have h_const : (fun _ : ℝ => Real.log 2) =o[Filter.atTop] Real.log := ++ Real.isLittleO_const_log_atTop ++ have h_self : Real.log =O[Filter.atTop] Real.log := ++ Asymptotics.isBigO_refl _ _ ++ ++ have h_const_bigO : (fun _ : ℝ => Real.log 2) =O[Filter.atTop] Real.log := ++ Asymptotics.IsLittleO.isBigO h_const ++ ++ exact Asymptotics.IsBigO.add h_const_bigO h_self ++ ++ exact h_eq.trans_isBigO h_bigO ++ ++lemma lem_w2t (t : ℝ) : abs (2 * t) + 2 ≥ 0 := by ++ have h1 : abs (2 * t) ≥ 0 := abs_nonneg (2 * t) ++ linarith ++ ++lemma lem_log2Olog2 : ++(fun t : ℝ => Real.log (abs (2 * t) + 4)) =O[Filter.atTop ⊔ Filter.atBot] (fun t : ℝ => Real.log (abs t + 2)) := by ++ ++ have h_eq : ∀ t : ℝ, abs (2 * t) + 4 = 2 * (abs t + 2) := by ++ intro t ++ rw [abs_mul, abs_two] ++ ring ++ ++ have h_log_decomp : ∀ t : ℝ, Real.log (abs (2 * t) + 4) = Real.log 2 + Real.log (abs t + 2) := by ++ intro t ++ rw [h_eq] ++ have h_pos : 0 < abs t + 2 := by linarith [abs_nonneg t] ++ rw [Real.log_mul (by norm_num : (2 : ℝ) ≠ 0) (ne_of_gt h_pos)] ++ ++ have h_target_eq : (fun t : ℝ => Real.log (abs (2 * t) + 4)) = ++ (fun t : ℝ => Real.log 2 + Real.log (abs t + 2)) := by ++ funext t ++ exact h_log_decomp t ++ ++ rw [h_target_eq] ++ ++ apply Asymptotics.IsBigO.of_bound 2 ++ ++ filter_upwards with t ++ ++ have h_pos_arg : abs t + 2 ≥ 1 := by linarith [abs_nonneg t] ++ have h_log_nonneg : 0 ≤ Real.log (abs t + 2) := Real.log_nonneg h_pos_arg ++ have h_log2_pos : 0 < Real.log 2 := Real.log_pos (by norm_num : 1 < (2 : ℝ)) ++ ++ simp only [Real.norm_eq_abs] ++ rw [abs_of_nonneg (by linarith [h_log2_pos.le, h_log_nonneg] : 0 ≤ Real.log 2 + Real.log (abs t + 2))] ++ rw [abs_of_nonneg h_log_nonneg] ++ ++ have h_bound : Real.log 2 ≤ Real.log (abs t + 2) := by ++ apply Real.log_le_log (by norm_num : 0 < (2 : ℝ)) ++ linarith [abs_nonneg t] ++ ++ linarith [h_bound] ++ ++lemma lem_Z2bound : ++ ∃ C > 1, ++ ∀ t : ℝ, 2 < |t| → ++ ∀ δ, 0 < δ ∧ δ < 1 → ++ (-(logDerivZeta ((1 : ℂ) + (δ : ℝ) + (2 * (t : ℝ)) * Complex.I))).re ++ ≤ C * Real.log (abs t + 2) := by ++ ++ obtain ⟨C₁, hC₁_pos, hbound₁⟩ := lem_explicit2Real2 ++ ++ have h_log_comp : ++ ∀ t : ℝ, 2 < |t| → Real.log (abs (2 * t) + 2) ≤ 2 * Real.log (abs t + 2) := by ++ intro t ht ++ have h_pos_2t : 0 < abs (2 * t) + 2 := by linarith [abs_nonneg (2 * t)] ++ have h_pos_t : 0 < abs t + 2 := by linarith [abs_nonneg t] ++ have h_2t_eq : abs (2 * t) = 2 * abs t := by ++ rw [abs_mul, abs_two] ++ ++ have h_bound : abs (2 * t) + 2 ≤ 4 * (abs t + 2) := by ++ rw [h_2t_eq] ++ ++ linarith [abs_nonneg t] ++ ++ have h_4_pos : (0 : ℝ) < 4 := by norm_num ++ have h_log_bound : Real.log (abs (2 * t) + 2) ≤ Real.log (4 * (abs t + 2)) := ++ Real.log_le_log h_pos_2t h_bound ++ ++ have h_log_mul_eq : Real.log (4 * (abs t + 2)) = Real.log 4 + Real.log (abs t + 2) := by ++ exact Real.log_mul (by norm_num : (4 : ℝ) ≠ 0) (ne_of_gt h_pos_t) ++ ++ have h_4_le : (4 : ℝ) ≤ abs t + 2 := by linarith [ht] ++ have h_log_4 : Real.log 4 ≤ Real.log (abs t + 2) := ++ Real.log_le_log (by norm_num) h_4_le ++ ++ calc Real.log (abs (2 * t) + 2) ++ ≤ Real.log (4 * (abs t + 2)) := h_log_bound ++ _ = Real.log 4 + Real.log (abs t + 2) := h_log_mul_eq ++ _ ≤ Real.log (abs t + 2) + Real.log (abs t + 2) := add_le_add_left h_log_4 _ ++ _ = 2 * Real.log (abs t + 2) := by ring ++ ++ have hC₁_nonneg : 0 ≤ C₁ := le_of_lt (lt_trans zero_lt_one hC₁_pos) ++ ++ refine ⟨2 * C₁, ?_, ?_⟩ ++ · ++ linarith [hC₁_pos] ++ · ++ intro t ht δ hδ ++ let s := (1 : ℂ) + (δ : ℝ) + (2 * (t : ℝ)) * Complex.I ++ ++ have h1 : (-(logDerivZeta s)).re ≤ C₁ * Real.log (abs (2 * t) + 2) := hbound₁ t ht δ hδ ++ ++ have h3 : Real.log (abs (2 * t) + 2) ≤ 2 * Real.log (abs t + 2) := h_log_comp t ht ++ ++ calc (-(logDerivZeta s)).re ++ ≤ C₁ * Real.log (abs (2 * t) + 2) := h1 ++ _ ≤ C₁ * (2 * Real.log (abs t + 2)) := mul_le_mul_of_nonneg_left h3 hC₁_nonneg ++ _ = (2 * C₁) * Real.log (abs t + 2) := by ring ++ ++lemma lem_Z1split (delta : ℝ) (_hdelta : delta > 0) (_hdelta_lt1 : delta < 1) (rho : ℂ) ++ (_h_rho_in_zeroZ : rho ∈ zeroZ) ++ (h_rho_in_Zt : rho ∈ ZetaZerosNearPoint rho.im) : ++ Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite rho.im)) ++ (fun rho1 : ℂ => (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + rho.im * Complex.I) - rho1)).re) = ++ (((analyticOrderAt riemannZeta rho).toNat : ℂ) / (((1 : ℂ) + delta + rho.im * Complex.I) - rho)).re + ++ Finset.sum ((Set.Finite.toFinset (ZetaZerosNearPoint_finite rho.im)).erase rho) ++ (fun rho1 : ℂ => (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + rho.im * Complex.I) - rho1)).re) := by ++ classical ++ set s := Set.Finite.toFinset (ZetaZerosNearPoint_finite rho.im) ++ set f := fun rho1 : ℂ => (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + rho.im * Complex.I) - rho1)).re ++ have hmem : rho ∈ s := by ++ simpa [s, Set.Finite.mem_toFinset (ZetaZerosNearPoint_finite rho.im)] using h_rho_in_Zt ++ ++ have h_decomp : ∑ x ∈ s, f x = f rho + ∑ x ∈ s.erase rho, f x := by ++ rw [← Finset.insert_erase hmem] ++ rw [Finset.sum_insert (Finset.notMem_erase rho s)] ++ simp ++ exact h_decomp ++ ++lemma re_ofReal_mul_eq (a : ℝ) (z : ℂ) : ((a : ℂ) * z).re = a * z.re := by ++ calc ++ ((a : ℂ) * z).re = ((a : ℂ).re) * z.re - ((a : ℂ).im) * z.im := by ++ simp [Complex.mul_re] ++ _ = a * z.re - 0 := by ++ simp ++ _ = a * z.re := by ++ simp ++ ++lemma re_ofReal_div_eq (a : ℝ) (z : ℂ) : ((a : ℂ) / z).re = a * (1 / z).re := by ++ simp [div_eq_mul_inv] ++ ++lemma re_ofReal_div_ge_one (a : ℝ) (z : ℂ) (ha : 1 ≤ a) (hz : 0 ≤ (1 / z).re) : ((a : ℂ) / z).re ≥ (1 / z).re := by ++ have hrepr : ((a : ℂ) / z).re = a * (1 / z).re := by ++ simp [div_eq_mul_inv, Complex.mul_re] ++ have hmul : (1 : ℝ) * (1 / z).re ≤ a * (1 / z).re := ++ mul_le_mul_of_nonneg_right ha hz ++ calc ++ ((a : ℂ) / z).re = a * (1 / z).re := hrepr ++ _ ≥ 1 * (1 / z).re := by exact hmul ++ _ = (1 / z).re := by simp [one_mul] ++ ++lemma analyticAt_riemannZeta_of_ne_one {s : ℂ} (hs : s ≠ 1) : AnalyticAt ℂ riemannZeta s := by ++ ++ refine (Complex.analyticAt_iff_eventually_differentiableAt).2 ?_ ++ ++ filter_upwards [eventually_ne_nhds hs] with z hz ++ exact differentiableAt_riemannZeta hz ++ ++lemma riemannZeta_not_eventually_zero_of_ne_one {s : ℂ} (hs : s ≠ 1) : ++ ¬ (∀ᶠ z in nhds s, riemannZeta z = 0) := by ++ intro hEvZero ++ ++ let H : ℂ → ℂ := Function.update (fun z : ℂ => (z - 1) * riemannZeta z) 1 1 ++ ++ have hH_diff : Differentiable ℂ H := by ++ intro z ++ rcases eq_or_ne z 1 with rfl | hz ++ · ++ refine (Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt ?_ ?_).differentiableAt ++ · ++ ++ filter_upwards [self_mem_nhdsWithin] with t ht ++ have h1 : DifferentiableAt ℂ (fun u : ℂ => u - 1) t := (differentiableAt_id.sub_const 1) ++ have h2 : DifferentiableAt ℂ riemannZeta t := by ++ ++ exact differentiableAt_riemannZeta ht ++ have hdiff := h1.mul h2 ++ ++ apply hdiff.congr_of_eventuallyEq ++ filter_upwards [eventually_ne_nhds ht] with u hu ++ simp [H, Function.update_of_ne hu] ++ · ++ simpa [H, continuousAt_update_same] using riemannZeta_residue_one ++ · ++ have h1 : DifferentiableAt ℂ (fun u : ℂ => u - 1) z := (differentiableAt_id.sub_const 1) ++ have h2 : DifferentiableAt ℂ riemannZeta z := by ++ exact differentiableAt_riemannZeta hz ++ have hdiff := h1.mul h2 ++ ++ apply hdiff.congr_of_eventuallyEq ++ filter_upwards [eventually_ne_nhds hz] with u hu ++ simp [H, Function.update_of_ne hu] ++ ++ have hH_analytic : AnalyticOnNhd ℂ H Set.univ := ++ (Complex.analyticOnNhd_univ_iff_differentiable).2 hH_diff ++ ++ have h0_analytic : AnalyticOnNhd ℂ (fun _ : ℂ => (0 : ℂ)) Set.univ := by ++ intro z _; simpa using (analyticAt_const : AnalyticAt ℂ (fun _ : ℂ => (0 : ℂ)) z) ++ ++ have hEv_ne1 : ∀ᶠ z in nhds s, z ≠ 1 := eventually_ne_nhds hs ++ have hEv_H0 : ∀ᶠ z in nhds s, H z = 0 := by ++ filter_upwards [hEvZero, hEv_ne1] with z hz_zero hz_ne1 ++ ++ have : H z = (z - 1) * riemannZeta z := by simp [H, Function.update_of_ne hz_ne1] ++ simp [this, hz_zero] ++ ++ have hEqOn : Set.EqOn H (fun _ : ℂ => (0 : ℂ)) Set.univ := by ++ ++ have hU : IsPreconnected (Set.univ : Set ℂ) := by simpa using isPreconnected_univ ++ exact AnalyticOnNhd.eqOn_of_preconnected_of_eventuallyEq hH_analytic h0_analytic hU (by simp) hEv_H0 ++ have hHeq : H = fun _ : ℂ => (0 : ℂ) := by ++ funext z; simpa using hEqOn (by simp : z ∈ (Set.univ : Set ℂ)) ++ ++ have h2ne1 : (2 : ℂ) ≠ 1 := by norm_num ++ have hH2 : H (2 : ℂ) = (2 - 1) * riemannZeta (2 : ℂ) := by ++ simp [H] ++ have hzeta2_ne : riemannZeta (2 : ℂ) ≠ 0 := ++ riemannZeta_ne_zero_of_one_le_re (by simp) ++ have hprod_zero' : 0 = (2 - 1) * riemannZeta (2 : ℂ) := by ++ simpa [hHeq] using hH2 ++ have hprod_zero : (2 - 1) * riemannZeta (2 : ℂ) = 0 := hprod_zero'.symm ++ have hnonzero : (2 - 1) * riemannZeta (2 : ℂ) ≠ 0 := by ++ have hcoeff : (2 : ℂ) - 1 ≠ 0 := sub_ne_zero.mpr h2ne1 ++ exact mul_ne_zero hcoeff hzeta2_ne ++ exact hnonzero hprod_zero ++ ++lemma analyticOrderAt_pos_toNat_of_zero_of_analytic_not_eventually_zero {f : ℂ → ℂ} {z0 : ℂ} ++ (hf : AnalyticAt ℂ f z0) (hzero : f z0 = 0) ++ (hnot : ¬ (∀ᶠ z in nhds z0, f z = 0)) : ++ 1 ≤ (analyticOrderAt f z0).toNat := by ++ classical ++ ++ have hne0 : analyticOrderAt f z0 ≠ 0 := by ++ intro h0 ++ have hzne : f z0 ≠ 0 := (AnalyticAt.analyticOrderAt_eq_zero hf).1 h0 ++ exact hzne hzero ++ ++ have hneTop : analyticOrderAt f z0 ≠ ⊤ := by ++ intro htop ++ have hall : (∀ᶠ z in nhds z0, f z = 0) := (analyticOrderAt_eq_top).1 htop ++ exact hnot hall ++ ++ rcases WithTop.ne_top_iff_exists.mp hneTop with ⟨n, hn⟩ ++ ++ have hn_ne_zero : n ≠ 0 := by ++ intro hn0 ++ apply hne0 ++ ++ simp [hn.symm, hn0] ++ rfl ++ ++ have hposn : 1 ≤ n := Nat.succ_le_of_lt (Nat.pos_of_ne_zero hn_ne_zero) ++ ++ simpa [hn.symm] using! hposn ++ ++lemma lem_Z1splitge (delta : ℝ) (hdelta_pos : delta > 0) (hdelta : delta < 1) (rho : ℂ) ++ (h_rho_in_zeroZ : rho ∈ zeroZ) (h_rho_in_Zt : rho ∈ ZetaZerosNearPoint rho.im) : ++ Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite rho.im)) (fun rho1 : ℂ => (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + rho.im * Complex.I) - rho1)).re) ≥ ++(1 / (((1 : ℂ) + delta + rho.im * Complex.I) - rho)).re := by ++ classical ++ ++ have hsplit := ++ lem_Z1split delta hdelta_pos hdelta rho h_rho_in_zeroZ h_rho_in_Zt ++ ++ rw [hsplit] ++ ++ have h_rho_ne_one : rho ≠ (1 : ℂ) := by ++ intro h ++ have hz1_ne : riemannZeta (1 : ℂ) ≠ 0 := riemannZeta_ne_zero_of_one_le_re (by simp) ++ exact hz1_ne (by simpa [h] using! h_rho_in_zeroZ) ++ have hAnal : AnalyticAt ℂ riemannZeta rho := analyticAt_riemannZeta_of_ne_one h_rho_ne_one ++ have hNotEv : ¬ (∀ᶠ z in nhds rho, riemannZeta z = 0) := ++ riemannZeta_not_eventually_zero_of_ne_one h_rho_ne_one ++ have horder_nat : 1 ≤ (analyticOrderAt riemannZeta rho).toNat := ++ analyticOrderAt_pos_toNat_of_zero_of_analytic_not_eventually_zero ++ hAnal (by simpa using! h_rho_in_zeroZ) hNotEv ++ have ha_real : (1 : ℝ) ≤ ((analyticOrderAt riemannZeta rho).toNat : ℝ) := by exact_mod_cast horder_nat ++ have hz_nonneg : 0 ≤ (1 / (((1 : ℂ) + delta + rho.im * Complex.I) - rho)).re := ++ lem_Re1deltatge0 delta hdelta_pos rho.im rho h_rho_in_Zt ++ have hfirst : ++ (1 / (((1 : ℂ) + delta + rho.im * Complex.I) - rho)).re ++ ≤ (((((analyticOrderAt riemannZeta rho).toNat : ℝ) : ℂ) / ++ (((1 : ℂ) + delta + rho.im * Complex.I) - rho))).re := by ++ ++ simpa [ge_iff_le] using ++ (re_ofReal_div_ge_one ((analyticOrderAt riemannZeta rho).toNat : ℝ) ++ ((((1 : ℂ) + delta + rho.im * Complex.I) - rho)) ha_real hz_nonneg) ++ ++ have hsum_nonneg : ++ 0 ≤ Finset.sum ++ ((Set.Finite.toFinset (ZetaZerosNearPoint_finite rho.im)).erase rho) ++ (fun rho1 : ℂ => ++ (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ++ (((1 : ℂ) + delta + rho.im * Complex.I) - rho1)).re) := by ++ apply Finset.sum_nonneg ++ intro rho1 hmem ++ rcases Finset.mem_erase.mp hmem with ⟨_, hmemS⟩ ++ ++ have hZt : rho1 ∈ ZetaZerosNearPoint rho.im := by ++ simpa [Set.Finite.mem_toFinset (ZetaZerosNearPoint_finite rho.im)] using hmemS ++ ++ have hne1 : rho1 ≠ (1 : ℂ) := by ++ intro h ++ have hz1_ne : riemannZeta (1 : ℂ) ≠ 0 := riemannZeta_ne_zero_of_one_le_re (by simp) ++ have hzero1 : riemannZeta rho1 = 0 := hZt.1 ++ exact hz1_ne (by simpa [h] using hzero1) ++ ++ have hAnal1 : AnalyticAt ℂ riemannZeta rho1 := analyticAt_riemannZeta_of_ne_one hne1 ++ have hNotEv1 : ¬ (∀ᶠ z in nhds rho1, riemannZeta z = 0) := ++ riemannZeta_not_eventually_zero_of_ne_one hne1 ++ have hzero1 : riemannZeta rho1 = 0 := hZt.1 ++ have horder1 : 1 ≤ (analyticOrderAt riemannZeta rho1).toNat := ++ analyticOrderAt_pos_toNat_of_zero_of_analytic_not_eventually_zero hAnal1 hzero1 hNotEv1 ++ have ha1_real : (1 : ℝ) ≤ ((analyticOrderAt riemannZeta rho1).toNat : ℝ) := by exact_mod_cast horder1 ++ ++ have hz1_nonneg : 0 ≤ (1 / (((1 : ℂ) + delta + rho.im * Complex.I) - rho1)).re := ++ lem_Re1deltatge0 delta hdelta_pos rho.im rho1 hZt ++ ++ have hge : ++ (1 / (((1 : ℂ) + delta + rho.im * Complex.I) - rho1)).re ≤ ++ (((((analyticOrderAt riemannZeta rho1).toNat : ℝ) : ℂ) / ++ (((1 : ℂ) + delta + rho.im * Complex.I) - rho1))).re := by ++ simpa [ge_iff_le] using ++ (re_ofReal_div_ge_one ((analyticOrderAt riemannZeta rho1).toNat : ℝ) ++ ((((1 : ℂ) + delta + rho.im * Complex.I) - rho1)) ha1_real hz1_nonneg) ++ ++ exact le_trans hz1_nonneg hge ++ ++ have h := add_le_add hfirst hsum_nonneg ++ ++ simpa using h ++ ++lemma lem_1deltatrho0 (delta : ℝ) (_hdelta : delta > 0) (rho : ℂ) (_h_rho_in_zeroZ : rho ∈ zeroZ) : ++((1 : ℂ) + delta + rho.im * Complex.I - rho) = ((1 : ℝ) + delta - rho.re) := by ++ ++ calc (1 : ℂ) + delta + rho.im * Complex.I - rho ++ = (1 : ℂ) + delta + rho.im * Complex.I - (rho.re + rho.im * Complex.I) := by rw [Complex.re_add_im] ++ _ = (1 : ℂ) + delta - rho.re := by ring ++ _ = ((1 : ℝ) + delta - rho.re : ℂ) := by norm_cast ++ ++lemma lem_1delsigReal (delta : ℝ) (hdelta_pos : delta > 0) (_hdelta : delta < 1) (rho : ℂ) (h_rho_in_zeroZ : rho ∈ zeroZ) : ++(1 / ((1 : ℂ) + delta + rho.im * Complex.I - rho)).re = 1 / ((1 : ℝ) + delta - rho.re) := by ++ rw [lem_1deltatrho0 delta hdelta_pos rho h_rho_in_zeroZ] ++ ++ rw [← Complex.ofReal_add, ← Complex.ofReal_sub, ← Complex.ofReal_one] ++ ++ rw [Complex.div_ofReal_re] ++ ++ rw [Complex.ofReal_re] ++ ++lemma lem_11delsiginR (delta : ℝ) (hdelta : delta > 0) (_hdelta_lt_1 : delta < 1) (sigma : ℝ) (hsigma : sigma ≤ 1) : ++(1 / ((1 : ℂ) + delta - sigma)).im = 0 := by ++ ++ have h_pos : 1 + delta - sigma > 0 := by ++ calc 1 + delta - sigma ++ = (1 - sigma) + delta := by ring ++ _ ≥ 0 + delta := by linarith [hsigma] ++ _ = delta := by simp ++ _ > 0 := hdelta ++ ++ have h_eq : (1 : ℂ) + delta - sigma = (1 + delta - sigma : ℝ) := by ++ simp only [Complex.ofReal_add, Complex.ofReal_sub, Complex.ofReal_one] ++ ++ rw [h_eq] ++ ++ rw [Complex.div_ofReal_im] ++ ++ rw [Complex.one_im] ++ ++ simp ++ ++lemma lem_11delsiginR2 (delta : ℝ) (hdelta : delta > 0) (hdelta_lt_1 : delta < 1) (rho : ℂ) (h_rho_in_zeroZ : rho ∈ zeroZ) : ++(1 / ((1 : ℂ) + delta - rho.re)).im = 0 := by ++ ++ have h_zeta_zero : riemannZeta rho = 0 := h_rho_in_zeroZ ++ ++ have h_rho_form : rho = rho.re + rho.im * Complex.I := by simp [Complex.re_add_im] ++ ++ rw [h_rho_form] at h_zeta_zero ++ ++ have h_rho_re_le_1 : rho.re ≤ 1 := lem_sigmale1 rho.re rho.im h_zeta_zero ++ ++ exact lem_11delsiginR delta hdelta hdelta_lt_1 rho.re h_rho_re_le_1 ++ ++lemma lem_ReReal (x : ℝ) : (x : ℂ).re = x := Complex.ofReal_re x ++ ++lemma lem_1delsigReal2 (delta : ℝ) (_hdelta : delta > 0) (rho : ℂ) (_h_rho_in_zeroZ : rho ∈ zeroZ) : ++(1 / ((1 : ℂ) + delta - rho.re)).re = 1 / ((1 : ℝ) + delta - rho.re) := by ++ ++ have h_eq : (1 : ℂ) + delta - rho.re = (1 + delta - rho.re : ℝ) := by ++ simp only [Complex.ofReal_add, Complex.ofReal_sub, Complex.ofReal_one] ++ ++ rw [h_eq] ++ ++ rw [Complex.div_ofReal_re] ++ ++ rw [Complex.one_re] ++ ++lemma lem_re_inv_one_plus_delta_minus_rho_real (delta : ℝ) (hdelta : delta > 0) (rho : ℂ) (h_rho_in_zeroZ : rho ∈ zeroZ) : ++(1 / ((1 : ℂ) + delta + rho.im * Complex.I - rho)).re = 1 / ((1 : ℝ) + delta - rho.re) := by ++ ++ rw [lem_1deltatrho0 delta hdelta rho h_rho_in_zeroZ] ++ ++ exact lem_1delsigReal2 delta hdelta rho h_rho_in_zeroZ ++ ++lemma lem_Z1splitge2 (delta : ℝ) (hdelta : delta > 0) (hdelta_lt_1 : delta < 1) (rho : ℂ) ++ (h_rho_in_zeroZ : rho ∈ zeroZ) (h_rho_in_Zt : rho ∈ ZetaZerosNearPoint rho.im) : ++ Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite rho.im)) ++ (fun rho1 : ℂ => (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / ((1 : ℂ) + delta + rho.im * Complex.I - rho1)).re) ≥ ++1 / ((1 : ℝ) + delta - rho.re) := by ++ ++ have h1 := lem_Z1splitge delta hdelta hdelta_lt_1 rho h_rho_in_zeroZ h_rho_in_Zt ++ ++ have h2 := lem_re_inv_one_plus_delta_minus_rho_real delta hdelta rho h_rho_in_zeroZ ++ ++ rw [← h2] ++ exact h1 ++ ++lemma lem_Z1splitge3 (delta : ℝ) (hdelta : delta > 0) (hdelta_lt_1 : delta < 1) (sigma t : ℝ) (rho : ℂ) ++ (h_rho_eq : rho = sigma + t * Complex.I) (h_rho_in_zeroZ : rho ∈ zeroZ) ++ (h_rho_in_Zt : rho ∈ ZetaZerosNearPoint t) : ++(Finset.sum (Set.Finite.toFinset (ZetaZerosNearPoint_finite t)) (fun rho1 : ℂ => ((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (((1 : ℂ) + delta + t * Complex.I) - rho1)) ).re ≥ 1 / ((1 : ℝ) + delta - sigma) := by ++ ++ rw [lem_sumrho1 t delta hdelta hdelta_lt_1] ++ ++ have h_rho_im : rho.im = t := by ++ rw [h_rho_eq] ++ simp [Complex.add_im, Complex.mul_im, Complex.I_im] ++ have h_rho_re : rho.re = sigma := by ++ rw [h_rho_eq] ++ simp [Complex.add_re, Complex.mul_re, Complex.I_re] ++ ++ have h_rho_in_Zt' : rho ∈ ZetaZerosNearPoint rho.im := by ++ rw [h_rho_im] ++ exact h_rho_in_Zt ++ ++ have h_bound := lem_Z1splitge2 delta hdelta hdelta_lt_1 rho h_rho_in_zeroZ h_rho_in_Zt' ++ ++ convert h_bound using 1 ++ ++ simp_rw [← h_rho_im] ++ ++ rw [h_rho_re] ++ ++lemma lem_rho_in_Zt (delta : ℝ) (hdelta : delta > 0) (t : ℝ) ++ (h_rho_zero : (1 : ℂ) + delta + t * Complex.I ∈ zeroZ) : ++ (1 : ℂ) + delta + t * Complex.I ∈ ZetaZerosNearPoint t := by ++ ++ let ρ : ℂ := (1 : ℂ) + delta + t * Complex.I ++ ++ have h_re : ρ.re > 1 := by ++ simp [ρ, Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re] ++ linarith [hdelta] ++ ++ have h_nonzero : riemannZeta ρ ≠ 0 := by ++ apply riemannZeta_ne_zero_of_one_le_re ++ exact le_of_lt h_re ++ ++ have h_zero : riemannZeta ρ = 0 := h_rho_zero ++ ++ exact absurd h_zero h_nonzero ++ ++lemma Z1bound : ++ ∃ C > 1, ++ ∀ (delta : ℝ), (0 < delta ∧ delta < 1) → ++ ∀ t : ℝ, 2 < |t| → ++ ∀ s : ℂ, s ∈ zeroZ ∧ s.im = t → ++ (-(logDerivZeta ((1 : ℂ) + delta + t * Complex.I))).re ++ ≤ - (1 / (1 + delta - s.re)) + C * Real.log (abs t + 2) := by ++ classical ++ ++ obtain ⟨C0, hC0gt1, hExp⟩ := lem_explicit1RealReal ++ ++ have hlog5pos : 0 < Real.log 4 := Real.log_pos (by norm_num : (1 : ℝ) < 4) ++ let C : ℝ := max (C0 + 3 / Real.log 4) 2 ++ have hCgt1 : 1 < C := by ++ have : (1 : ℝ) < 2 := by norm_num ++ exact lt_of_lt_of_le this (le_max_right _ _) ++ refine ⟨C, hCgt1, ?_⟩ ++ intro delta hdelta t ht s hs ++ ++ set sp : ℂ := (1 : ℂ) + delta + t * Complex.I ++ set S : Finset ℂ := Set.Finite.toFinset (ZetaZerosNearPoint_finite t) ++ set Sre : ℝ := ++ Finset.sum S ++ (fun rho1 : ℂ => ++ (((analyticOrderAt riemannZeta rho1).toNat : ℂ) / (sp - rho1)).re) ++ ++ have h_bound : abs ((logDerivZeta sp).re - Sre) ++ ≤ C0 * Real.log (abs t + 2) := by ++ simpa [sp, S, Sre] using hExp t ht delta hdelta ++ ++ have h_left : -(C0 * Real.log (abs t + 2)) ≤ (logDerivZeta sp).re - Sre := ++ (abs_le.mp h_bound).1 ++ have h_neg : -((logDerivZeta sp).re - Sre) ≤ C0 * Real.log (abs t + 2) := by ++ simpa using neg_le_neg h_left ++ have h_isol : - (logDerivZeta sp).re ≤ C0 * Real.log (abs t + 2) - Sre := by ++ have := sub_le_sub_right h_neg Sre ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ ++ have hS_nonneg : 0 ≤ Sre := by ++ apply Finset.sum_nonneg ++ intro rho1 hmem ++ have hZt : rho1 ∈ ZetaZerosNearPoint t := by ++ simpa [S, Set.Finite.mem_toFinset (ZetaZerosNearPoint_finite t)] using hmem ++ ++ simpa [sp] using ++ (lem_Re1deltatge0m delta hdelta.1 t hdelta.2 rho1 hZt) ++ ++ have h_basic : (-(logDerivZeta sp)).re ≤ C0 * Real.log (abs t + 2) := by ++ have h_drop : C0 * Real.log (abs t + 2) - Sre ≤ C0 * Real.log (abs t + 2) := ++ sub_le_self _ hS_nonneg ++ exact le_trans h_isol h_drop ++ ++ by_cases hmem : s ∈ ZetaZerosNearPoint t ++ · ++ set sigma : ℝ := s.re ++ have h_rho_eq : s = (sigma : ℂ) + t * Complex.I := by ++ have : s = s.re + s.im * Complex.I := by simp [Complex.re_add_im] ++ simpa [sigma, hs.2] using this ++ ++ have hsum_rew := lem_sumrho1 t delta hdelta.1 hdelta.2 ++ have h_sum_ge' := ++ lem_Z1splitge3 delta hdelta.1 hdelta.2 sigma t s h_rho_eq hs.1 hmem ++ have h_sum_ge : Sre ≥ 1 / ((1 : ℝ) + delta - sigma) := by ++ simpa [sp, S, Sre, hsum_rew] using h_sum_ge' ++ ++ have h1 : (-(logDerivZeta sp)).re ≤ C0 * Real.log (abs t + 2) - (1 / ((1 : ℝ) + delta - sigma)) := by ++ have : (1 / ((1 : ℝ) + delta - sigma)) ≤ Sre := h_sum_ge ++ have := sub_le_sub_left this (C0 * Real.log (abs t + 2)) ++ exact le_trans h_isol (by simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this) ++ ++ have hCge : C0 ≤ C := ++ le_trans (by ++ have : 0 ≤ 3 / Real.log 4 := le_of_lt (div_pos (by norm_num) hlog5pos) ++ have := add_le_add_right this C0 ++ simpa using this) (le_max_left _ _) ++ ++ have hY_nonneg : 0 ≤ Real.log (abs t + 2) := by ++ have h2le : (2 : ℝ) ≤ abs t + 2 := by ++ have h0 : 0 ≤ |t| := abs_nonneg t ++ simp ++ exact le_of_lt (Real.log_pos (lt_of_lt_of_le (by norm_num) h2le)) ++ have h_enlarge : C0 * Real.log (abs t + 2) ≤ C * Real.log (abs t + 2) := ++ mul_le_mul_of_nonneg_right hCge hY_nonneg ++ have h2 : C0 * Real.log (abs t + 2) - (1 / ((1 : ℝ) + delta - sigma)) ≤ ++ C * Real.log (abs t + 2) - (1 / ((1 : ℝ) + delta - sigma)) := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using ++ (sub_le_sub_right h_enlarge (1 / ((1 : ℝ) + delta - sigma))) ++ have := le_trans h1 h2 ++ simpa [sp, sigma, Complex.neg_re, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] ++ using this ++ · ++ ++ have h_notle : ¬ ‖s - ((3/2 : ℂ) + t * Complex.I)‖ ≤ (5/6 : ℝ) := by ++ intro hle ++ exact hmem ⟨hs.1, hle⟩ ++ have hdist_gt : (5/6 : ℝ) < ‖s - ((3/2 : ℂ) + t * Complex.I)‖ := not_le.mp h_notle ++ ++ have h_re : (s - ((3/2 : ℂ) + t * Complex.I)).re = s.re - (3/2 : ℝ) := by ++ simp [Complex.sub_re, Complex.add_re] ++ have h_im : (s - ((3/2 : ℂ) + t * Complex.I)).im = 0 := by ++ have : (s - ((3/2 : ℂ) + t * Complex.I)).im = s.im - t := by ++ simp [Complex.sub_im, Complex.add_im] ++ simp [hs.2] ++ have h_eq : s - ((3/2 : ℂ) + t * Complex.I) = (((s.re - (3/2 : ℝ)) : ℝ) : ℂ) := by ++ apply Complex.ext ++ · simp [h_re] ++ · simp [h_im] ++ have hdist_real : ‖s - ((3/2 : ℂ) + t * Complex.I)‖ = |s.re - (3/2 : ℝ)| := by ++ simpa [h_eq] using complex_abs_of_real (s.re - (3/2 : ℝ)) ++ have habs_gt : (5/6 : ℝ) < |s.re - (3/2 : ℝ)| := by simpa [hdist_real] using hdist_gt ++ ++ have h0 : riemannZeta (s.re + s.im * Complex.I) = 0 := by ++ simpa [Complex.re_add_im] using! hs.1 ++ have hs_le1 : s.re ≤ 1 := lem_sigmale1 s.re s.im h0 ++ ++ have h_nonpos : s.re - (3/2 : ℝ) ≤ 0 := by linarith [hs_le1] ++ have h_abs_eq : |s.re - (3/2 : ℝ)| = (3/2 : ℝ) - s.re := by ++ have : |s.re - (3/2 : ℝ)| = -(s.re - (3/2 : ℝ)) := abs_of_nonpos h_nonpos ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ have h_gt' : (5/6 : ℝ) < (3/2 : ℝ) - s.re := by simpa [h_abs_eq] using habs_gt ++ have hs_le_23 : s.re ≤ (2/3 : ℝ) := by linarith [h_gt'] ++ ++ have hden_ge : (1/3 : ℝ) ≤ 1 + delta - s.re := by ++ have : (1/3 : ℝ) ≤ 1 - s.re := by linarith [hs_le_23] ++ have : 1 - s.re ≤ 1 + delta - s.re := by linarith [hdelta.1] ++ exact le_trans ‹(1/3 : ℝ) ≤ 1 - s.re› this ++ have hone_div_le3 : 1 / (1 + delta - s.re) ≤ (3 : ℝ) := by ++ have : 1 / (1 + delta - s.re) ≤ 1 / (1/3 : ℝ) := ++ one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 1/3) hden_ge ++ simpa [one_div] using this ++ have hneg_ge : - (3 : ℝ) ≤ - (1 / (1 + delta - s.re)) := by ++ simpa using (neg_le_neg hone_div_le3) ++ ++ have hlog_ge : Real.log 4 ≤ Real.log (abs t + 2) := by ++ have : (4 : ℝ) < abs t + 2 := by linarith [ht] ++ exact Real.log_le_log (by norm_num) (le_of_lt this) ++ have hC_ge_add : C ≥ C0 + 3 / Real.log 4 := by exact le_max_left _ _ ++ have hCminus : C - C0 ≥ 3 / Real.log 4 := by linarith ++ have hY_nonneg : 0 ≤ Real.log (abs t + 2) := by ++ have h2le : (2 : ℝ) ≤ abs t + 2 := by ++ have h0 : 0 ≤ |t| := abs_nonneg t ++ simp ++ exact le_of_lt (Real.log_pos (lt_of_lt_of_le (by norm_num) h2le)) ++ have hmul1 : (3 / Real.log 4) * Real.log 4 ≤ (3 / Real.log 4) * Real.log (abs t + 2) := by ++ have hk_nonneg : 0 ≤ 3 / Real.log 4 := le_of_lt (div_pos (by norm_num) hlog5pos) ++ exact mul_le_mul_of_nonneg_left hlog_ge hk_nonneg ++ have hmul2 : (3 / Real.log 4) * Real.log (abs t + 2) ≤ (C - C0) * Real.log (abs t + 2) := by ++ exact mul_le_mul_of_nonneg_right hCminus hY_nonneg ++ have hmul_ge3 : (3 : ℝ) ≤ (C - C0) * Real.log (abs t + 2) := by ++ have hne5 : Real.log 4 ≠ 0 := ne_of_gt hlog5pos ++ have hcalc : (3 / Real.log 4) * Real.log 4 = 3 := by ++ simp [div_eq_mul_inv, hne5] ++ have : (3 / Real.log 4) * Real.log 4 ≤ (C - C0) * Real.log (abs t + 2) := ++ le_trans hmul1 hmul2 ++ simpa [hcalc] using this ++ ++ have hCmul' : C0 * Real.log (abs t + 2) + 3 ≤ C * Real.log (abs t + 2) := by ++ have : C0 * Real.log (abs t + 2) + 3 ≤ C0 * Real.log (abs t + 2) + (C - C0) * Real.log (abs t + 2) := by ++ exact add_le_add_right hmul_ge3 _ ++ have hcalc : C * Real.log (abs t + 2) = ++ C0 * Real.log (abs t + 2) + (C - C0) * Real.log (abs t + 2) := by ++ ring ++ simpa [hcalc, add_comm, add_left_comm, add_assoc] using this ++ ++ have : (-(logDerivZeta sp)).re ≤ - (1 / (1 + delta - s.re)) + C * Real.log (abs t + 2) := by ++ have h1 : (-(logDerivZeta sp)).re ≤ C0 * Real.log (abs t + 2) := h_basic ++ have h2 : C0 * Real.log (abs t + 2) ≤ C * Real.log (abs t + 2) - 3 := by ++ linarith [hCmul'] ++ have h3 : C * Real.log (abs t + 2) - 3 ≤ - (1 / (1 + delta - s.re)) + C * Real.log (abs t + 2) := by ++ have := add_le_add_left hneg_ge (C * Real.log (abs t + 2)) ++ simpa [add_comm, add_left_comm, add_assoc, sub_eq_add_neg] using this ++ exact le_trans h1 (le_trans h2 h3) ++ simpa [sp, Complex.neg_re, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ ++lemma Z0boundRe : ++Asymptotics.IsBigO (nhdsWithin 0 (Set.Ioi 0)) (fun (delta : ℝ) => (- (logDerivZeta ((1 : ℂ) + delta))).re - (1 / delta)) (fun _ => (1 : ℝ)) := by ++ ++ have h := Z0bound ++ ++ have h_eq : (fun (delta : ℝ) => (- (logDerivZeta ((1 : ℂ) + delta))).re - (1 / delta)) = ++ (fun (delta : ℝ) => (-logDerivZeta ((1 : ℂ) + delta) - (1 / (delta : ℂ))).re) := by ++ ext delta ++ rw [Complex.sub_re, Complex.neg_re] ++ ++ have : (1 / (delta : ℂ)).re = 1 / delta := by ++ rw [Complex.div_re, Complex.one_re, Complex.ofReal_re, Complex.ofReal_im] ++ simp [Complex.normSq_ofReal] ++ rw [this] ++ ++ rw [h_eq] ++ ++ rw [Asymptotics.isBigO_iff] at h ⊢ ++ obtain ⟨c, hc⟩ := h ++ use c ++ filter_upwards [hc] with delta h_delta ++ have : ‖(1 : ℂ)‖ = (1 : ℝ) := by simp ++ rw [this] at h_delta ++ have : ‖(1 : ℝ)‖ = (1 : ℝ) := by simp ++ rw [this] ++ exact le_trans (Complex.abs_re_le_norm _) h_delta ++ ++lemma extract_bigO_bound_Z0 (delta : ℝ) (_hdelta : delta > 0) : ∃ C0 > 0, (-logDerivZeta ((1 : ℂ) + delta)).re ≤ 1 / delta + C0 := by ++ ++ let target := (-logDerivZeta ((1 : ℂ) + delta)).re ++ let base := 1 / delta ++ ++ use max 1 (target - base + 1) ++ ++ constructor ++ · ++ exact lt_of_lt_of_le zero_lt_one (le_max_left 1 (target - base + 1)) ++ ++ · ++ ++ by_cases h : target - base + 1 ≤ 1 ++ · ++ have h_max : max 1 (target - base + 1) = 1 := max_eq_left h ++ rw [h_max] ++ ++ linarith [h] ++ · ++ have h_max : max 1 (target - base + 1) = target - base + 1 := max_eq_right (le_of_not_ge h) ++ rw [h_max] ++ ++ linarith ++ ++lemma uniform_bound_Z0 : ∃ δ0 > 0, ∃ C0 ≥ 0, ∀ δ : ℝ, 0 < δ → δ < δ0 → (- (logDerivZeta ((1 : ℂ) + δ))).re ≤ 1 / δ + C0 := by ++ ++ let f : ℝ → ℝ := fun δ => (- (logDerivZeta ((1 : ℂ) + δ))).re - (1 / δ) ++ ++ have hO := Z0boundRe ++ ++ rcases (Asymptotics.isBigO_iff).1 hO with ⟨c, hc⟩ ++ ++ have h1norm : ∀ᶠ δ in nhdsWithin (0 : ℝ) (Set.Ioi (0 : ℝ)), ‖f δ‖ ≤ c := by ++ ++ have : ∀ᶠ δ in nhdsWithin (0 : ℝ) (Set.Ioi (0 : ℝ)), ‖f δ‖ ≤ c * ‖(1 : ℝ)‖ := hc ++ refine this.mono ?_ ++ intro δ hδ ++ simpa using (by simpa using hδ) ++ ++ rcases (Filter.eventually_iff_exists_mem).1 h1norm with ⟨S, hS_in, hS_bound⟩ ++ ++ rcases (mem_nhdsGT_iff_exists_Ioc_subset).1 hS_in with ⟨δ0, hδ0pos, hIoc_sub_S⟩ ++ ++ refine ⟨δ0, hδ0pos, max c 0, le_max_right _ _, ?_⟩ ++ intro δ hδpos hδlt ++ ++ have hδ_in_S : δ ∈ S := hIoc_sub_S ⟨hδpos, le_of_lt hδlt⟩ ++ ++ have hnorm_le_c : ‖f δ‖ ≤ c := hS_bound δ hδ_in_S ++ ++ have hnorm_le_C0 : ‖f δ‖ ≤ max c 0 := le_trans hnorm_le_c (le_max_left _ _) ++ ++ have h_upper : f δ ≤ max c 0 := by ++ have : |f δ| ≤ max c 0 := by simpa [Real.norm_eq_abs] using hnorm_le_C0 ++ exact (abs_le.mp this).2 ++ ++ have := (sub_le_iff_le_add).1 h_upper ++ simpa [f, add_comm] using this ++ ++lemma eventually_atTop_sup_atBot_iff_abs {P : ℝ → Prop} : ++ (∀ᶠ t in (Filter.atTop ⊔ Filter.atBot), P t) ↔ ∃ T : ℝ, ∀ t : ℝ, T ≤ |t| → P t := by ++ constructor ++ · intro h ++ have h' := (Filter.eventually_sup).1 h ++ rcases h' with ⟨hTop, hBot⟩ ++ rcases (Filter.eventually_atTop).1 hTop with ⟨A, hA⟩ ++ rcases (Filter.eventually_atBot).1 hBot with ⟨B, hB⟩ ++ refine ⟨max A (-B), ?_⟩ ++ intro t ht ++ have hcases : max A (-B) ≤ t ∨ max A (-B) ≤ -t := (le_abs).1 ht ++ cases hcases with ++ | inl hTle_t => ++ have hA_le_t : A ≤ t := le_trans (le_max_left A (-B)) hTle_t ++ exact hA t hA_le_t ++ | inr hTle_neg_t => ++ have h_negB_le_neg_t : -B ≤ -t := le_trans (le_max_right A (-B)) hTle_neg_t ++ have h_t_le_B : t ≤ B := (neg_le_neg_iff).1 h_negB_le_neg_t ++ exact hB t h_t_le_B ++ · intro h ++ rcases h with ⟨T, hT⟩ ++ refine (Filter.eventually_sup).2 ?_ ++ constructor ++ · ++ refine (Filter.eventually_atTop).2 ?_ ++ refine ⟨max T 0, ?_⟩ ++ intro t ht ++ have ht0 : 0 ≤ t := le_trans (le_max_right T 0) ht ++ have hTle : T ≤ |t| := by ++ have : T ≤ t := le_trans (le_max_left T 0) ht ++ simpa [abs_of_nonneg ht0] using this ++ exact hT t hTle ++ · ++ refine (Filter.eventually_atBot).2 ?_ ++ refine ⟨-max T 0, ?_⟩ ++ intro t ht ++ have ht0 : t ≤ 0 := by ++ have hnegmax_le_0 : -max T 0 ≤ 0 := by ++ simp ++ exact le_trans ht hnegmax_le_0 ++ have hTle : T ≤ |t| := by ++ have h1 : max T 0 ≤ -t := by ++ have := (neg_le_neg ht) ++ ++ simpa using this ++ have : T ≤ -t := le_trans (le_max_left T 0) h1 ++ simpa [abs_of_nonpos ht0] using this ++ exact hT t hTle ++ ++lemma re_sum_three (a b : ℝ) (x y z : ℂ) : ((a * x) + (b * y) + z).re = a * x.re + b * y.re + z.re := by ++ ++ simp [Complex.add_re, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, add_assoc] ++ ++lemma log_abs_add_two_ge_one (t : ℝ) (ht : Real.exp 1 - 2 ≤ |t|) : (1 : ℝ) ≤ Real.log (|t| + 2) := by ++ have hx : Real.exp 1 ≤ |t| + 2 := by ++ have h' := add_le_add_left ht (2 : ℝ) ++ simpa [sub_add_cancel] using! h' ++ have hxpos : 0 < |t| + 2 := by ++ have two_pos : 0 < (2 : ℝ) := by norm_num ++ exact add_pos_of_nonneg_of_pos (abs_nonneg t) two_pos ++ exact (Real.le_log_iff_exp_le hxpos).2 hx ++ ++lemma log_abs_add_two_ge_of_threshold (K t : ℝ) (ht : Real.exp K - 2 ≤ |t|) : K ≤ Real.log (|t| + 2) := by ++ have hx : Real.exp K ≤ |t| + 2 := by ++ have h' := add_le_add_left ht (2 : ℝ) ++ simpa [sub_add_cancel] using! h' ++ have hxpos : 0 < |t| + 2 := by ++ have two_pos : 0 < (2 : ℝ) := by norm_num ++ exact add_pos_of_nonneg_of_pos (abs_nonneg t) two_pos ++ exact (Real.le_log_iff_exp_le hxpos).2 hx ++ ++lemma re_ofReal_add_ofReal_add (a b : ℝ) (z : ℂ) : (a + b + z).re = a + b + z.re := by ++ simp [Complex.add_re, Complex.ofReal_re, add_assoc] ++ ++lemma algebraic_rewrite_RHS (δ s L C0 C1 C2 : ℝ) : ++ 3 * (1 / δ + C0) + 4 * (-(1 / (1 + δ - s)) + C1 * L) + C2 * L = ++ 3 / δ - 4 / (1 + δ - s) + (4 * C1 + C2) * L + 3 * C0 := by ++ have hA : 3 * (1 / δ + C0) = 3 * (1 / δ) + 3 * C0 := by ++ simp [mul_add] ++ have hB2 : ++ 4 * (-(1 / (1 + δ - s)) + C1 * L) = ++ -(4 * (1 / (1 + δ - s))) + (4 * C1) * L := by ++ calc ++ 4 * (-(1 / (1 + δ - s)) + C1 * L) ++ = 4 * (-(1 / (1 + δ - s))) + 4 * (C1 * L) := by ++ simp [mul_add] ++ _ = -(4 * (1 / (1 + δ - s))) + (4 * C1) * L := by ++ simp [mul_comm, mul_assoc] ++ calc ++ 3 * (1 / δ + C0) + 4 * (-(1 / (1 + δ - s)) + C1 * L) + C2 * L ++ = (3 * (1 / δ) + 3 * C0) + 4 * (-(1 / (1 + δ - s)) + C1 * L) + C2 * L := by ++ rw [hA] ++ _ = (3 * (1 / δ) + 3 * C0) + (-(4 * (1 / (1 + δ - s))) + (4 * C1) * L) + C2 * L := by ++ rw [hB2] ++ _ = (3 / δ + 3 * C0) + (- 4 / (1 + δ - s) + (4 * C1) * L) + C2 * L := by ++ simp [div_eq_mul_inv] ++ _ = 3 / δ - 4 / (1 + δ - s) + (4 * C1) * L + C2 * L + 3 * C0 := by ++ ring ++ _ = 3 / δ - 4 / (1 + δ - s) + (4 * C1 + C2) * L + 3 * C0 := by ++ ring ++ ++lemma absorb_pos_constant_into_log {L A c : ℝ} (hL : 1 ≤ L) (hc : 0 ≤ c) : A * L + c ≤ (A + c) * L := by ++ ++ have hc_le : c ≤ L * c := by ++ have h := mul_le_mul_of_nonneg_right hL hc ++ simpa [one_mul] using h ++ ++ have h0 : A * L + c ≤ A * L + L * c := by ++ exact add_le_add_right hc_le (A * L) ++ calc ++ A * L + c ≤ A * L + L * c := h0 ++ _ = A * L + c * L := by simp [mul_comm] ++ _ = (A + c) * L := by simp [right_distrib] ++ ++lemma neg_logDeriv_zeta_eq_vonMangoldt_sum (s : ℂ) (hs : 1 < s.re) : -(deriv riemannZeta s / riemannZeta s) = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-s) := by ++ ++ have h1 := ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div hs ++ ++ have h2 : -deriv riemannZeta s / riemannZeta s = LSeries (fun n => ↑(ArithmeticFunction.vonMangoldt n)) s := h1.symm ++ ++ have h3 : -(deriv riemannZeta s / riemannZeta s) = -deriv riemannZeta s / riemannZeta s := by ring ++ rw [h3, h2] ++ ++ rw [LSeries] ++ congr 1 ++ ext n ++ rw [LSeries.term_def] ++ split_ifs with h_zero ++ · ++ simp [h_zero] ++ · ++ rw [div_eq_mul_inv, Complex.cpow_neg] ++ ++lemma zeta1zetaseries {s : ℂ} (hs : 1 < s.re) : ++-logDerivZeta s = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-s) := by ++ unfold logDerivZeta ++ ++ exact neg_logDeriv_zeta_eq_vonMangoldt_sum s hs ++ ++lemma zeta1zetaseriesxy (x y : ℝ) (hx : 1 < x) : ++ -logDerivZeta (x + y * I) = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x + y * I)) := by ++ apply zeta1zetaseries ++ ++ have h : (x + y * I).re = x := by ++ simp [Complex.add_re, Complex.ofReal_re, Complex.ofReal_im] ++ right ++ exact Complex.I_re ++ rw [h] ++ exact hx ++ ++lemma Zconverges1 (x y : ℝ) (hx : 1 < x) : riemannZeta (x + y * I) ≠ 0 := by ++ apply riemannZeta_ne_zero_of_one_lt_re ++ ++ have h : (x + y * I).re = x := by ++ rw [Complex.add_re, Complex.ofReal_re] ++ simp [Complex.mul_re] ++ right ++ exact Complex.I_re ++ rw [h] ++ exact hx ++ ++lemma complex_re_of_real_add_imag (x y : ℝ) : (x + y * I).re = x := by ++ simp [Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.ofReal_im] ++ ++ right ++ exact Complex.I_re ++ ++lemma vonMangoldt_LSeriesSummable (s : ℂ) (hs : 1 < s.re) : LSeriesSummable (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) s := by ++ ++ exact ArithmeticFunction.LSeriesSummable_vonMangoldt hs ++ ++lemma summable_of_support_singleton {α : Type*} [SeminormedAddCommGroup α] (f : ℕ → α) (n₀ : ℕ) (h : ∀ n : ℕ, n ≠ n₀ → f n = 0) : Summable f := by ++ ++ have h_finite_support : Set.Finite (Function.support f) := by ++ ++ have h_subset : Function.support f ⊆ {n₀} := by ++ intro n hn ++ ++ by_contra h_ne ++ ++ have h_zero : f n = 0 := h n h_ne ++ ++ simp [Function.mem_support] at hn ++ exact hn h_zero ++ ++ exact Set.Finite.subset (Set.finite_singleton n₀) h_subset ++ ++ exact summable_of_hasFiniteSupport h_finite_support ++ ++lemma summable_of_summable_add_sub {α : Type*} [SeminormedAddCommGroup α] (f g h : ℕ → α) (h_eq : f = g + h) (hf : Summable f) (hh : Summable h) : Summable g := by ++ ++ have g_eq_f_sub_h : g = f - h := by ++ ++ rw [← sub_eq_iff_eq_add] at h_eq ++ exact h_eq.symm ++ ++ rw [g_eq_f_sub_h] ++ ++ exact hf.sub hh ++ ++lemma LSeriesSummable_to_summable (f : ℕ → ℂ) (s : ℂ) (h : LSeriesSummable f s) : Summable (fun n => f n * (n : ℂ) ^ (-s)) := by ++ ++ have h_term_summable : Summable (LSeries.term f s) := h ++ ++ have h_eq_nonzero : ∀ n : ℕ, n ≠ 0 → LSeries.term f s n = f n * (n : ℂ) ^ (-s) := by ++ intro n hn ++ rw [LSeries.term_of_ne_zero hn] ++ rw [div_eq_mul_inv, Complex.cpow_neg] ++ ++ let diff := fun n => LSeries.term f s n - f n * (n : ℂ) ^ (-s) ++ ++ have h_diff_support : ∀ n : ℕ, n ≠ 0 → diff n = 0 := by ++ intro n hn ++ simp only [diff] ++ rw [h_eq_nonzero n hn] ++ simp ++ ++ have h_diff_summable : Summable diff := by ++ ++ apply summable_of_support_singleton diff 0 h_diff_support ++ ++ have h_rw : LSeries.term f s = (fun n => f n * (n : ℂ) ^ (-s)) + diff := by ++ ext n ++ simp only [diff, Pi.add_apply] ++ ring ++ ++ exact summable_of_summable_add_sub (LSeries.term f s) (fun n => f n * (n : ℂ) ^ (-s)) diff h_rw h_term_summable h_diff_summable ++ ++lemma ReZconverges1 (x y : ℝ) (hx : 1 < x) : ++Summable (fun n => ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) (-(x + y * I))).re) := by ++ ++ have h_nonzero : riemannZeta (x + y * I) ≠ 0 := Zconverges1 x y hx ++ ++ have h_re_gt_one : 1 < (x + y * I).re := by ++ rw [complex_re_of_real_add_imag] ++ exact hx ++ ++ have h_L_summable : LSeriesSummable (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (x + y * I) := ++ vonMangoldt_LSeriesSummable (x + y * I) h_re_gt_one ++ ++ have h_summable : Summable (fun n => (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x + y * I))) := ++ LSeriesSummable_to_summable (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (x + y * I) h_L_summable ++ ++ have h_hasSum : HasSum (fun n => (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x + y * I))) (∑' n, (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x + y * I))) := ++ h_summable.hasSum ++ ++ have h_hasSum_re : HasSum (fun n => ((ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x + y * I))).re) (∑' n, (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x + y * I))).re := ++ Complex.hasSum_re h_hasSum ++ ++ exact h_hasSum_re.summable ++ ++lemma exprule (n : ℕ) (hn : n ≥ 1) (alpha beta : ℂ) : (n : ℂ) ^ (alpha + beta) = (n : ℂ) ^ alpha * (n : ℂ) ^ beta := by ++ apply Complex.cpow_add ++ ++ rw [Nat.cast_ne_zero] ++ ++ rw [← Nat.one_le_iff_ne_zero] ++ exact hn ++ ++lemma lem_nxy (n : ℕ) (hn : n ≥ 1) (x y : ℝ) : ++ Complex.cpow (n : ℂ) (-(x + y * I)) = Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I)) := by ++ ++ have h : -(x + y * I) = (-x : ℂ) + (-(y * I)) := by ring ++ rw [h] ++ ++ exact lem_exprule n hn (-x : ℂ) (-(y * I)) ++ ++lemma lem_zeta1zetaseriesxy2 (x y : ℝ) (hx : 1 < x) : ++ -logDerivZeta (x + y * I) = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℂ) * (Complex.cpow (n : ℂ) ((-x) : ℂ)) * (Complex.cpow (n : ℂ) (-(y * I))) := by ++ ++ rw [zeta1zetaseriesxy x y hx] ++ ++ congr 1 ++ ext n ++ ++ rw [← Complex.cpow_eq_pow] ++ ++ by_cases h : n = 0 ++ · ++ simp [h] ++ · ++ have hn : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr h ++ rw [lem_nxy n hn x y] ++ ++ ring ++ ++lemma complex_add_re_ofReal_mul_I (x y : ℝ) : (x + y * I).re = x := by ++ rw [Complex.add_re, Complex.ofReal_re, Complex.re_ofReal_mul] ++ ++ have h : I.re = 0 := Complex.I_re ++ rw [h] ++ simp ++ ++lemma LSeriesSummable_to_explicit_summable (x y : ℝ) (_hx : 1 < x) : LSeriesSummable (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (x + y * I) → Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I))) := by ++ intro h_summable ++ ++ have h_vm_zero : (ArithmeticFunction.vonMangoldt 0 : ℂ) = 0 := by ++ simp ++ ++ have h_eq : ∀ n : ℕ, LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (x + y * I) n = ++ (ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I)) := by ++ intro n ++ ++ rw [LSeries.term_def₀ h_vm_zero] ++ ++ rw [← Complex.cpow_eq_pow] ++ ++ by_cases hn : n = 0 ++ · ++ simp [hn] ++ · ++ have hn_ge : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr hn ++ rw [lem_nxy n hn_ge x y] ++ ring ++ ++ have h_term_summable : Summable (fun n => LSeries.term (fun n => (ArithmeticFunction.vonMangoldt n : ℂ)) (x + y * I) n) := by ++ exact h_summable ++ ++ convert h_term_summable using 1 ++ ext n ++ exact (h_eq n).symm ++ ++lemma Zseriesconverges1 (x y : ℝ) (hx : 1 < x) : ++Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I))) := by ++ ++ have h_zeta_ne_zero := Zconverges1 x y hx ++ ++ have h_series := lem_zeta1zetaseriesxy2 x y hx ++ ++ have h_re : 1 < (x + y * I).re := by ++ rw [complex_add_re_ofReal_mul_I] ++ exact hx ++ ++ have h_summable := ArithmeticFunction.LSeriesSummable_vonMangoldt h_re ++ ++ exact LSeriesSummable_to_explicit_summable x y hx h_summable ++ ++lemma lem_realnx (n : ℕ) (x : ℝ) (_hn : n ≥ 1) (_hx : x ≥ 1) : ++ ArithmeticFunction.vonMangoldt n * (n : ℝ) ^ (-x) ≥ 0 := by ++ apply mul_nonneg ++ · ++ exact ArithmeticFunction.vonMangoldt_nonneg ++ · ++ apply Real.rpow_nonneg ++ ++ exact Nat.cast_nonneg n ++ ++lemma sumReal {v : ℕ → ℂ} {v_sum : ℂ} (h_sum : HasSum v v_sum) : ++ HasSum (fun n => (v n).re) v_sum.re := by ++ exact Complex.hasSum_re h_sum ++ ++lemma sumRealLambda (x y : ℝ) (hx : 1 < x) : ++ (∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I))).re = ++ ∑' (n : ℕ), ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I))).re := by ++ apply Complex.re_tsum ++ exact Zseriesconverges1 x y hx ++ ++lemma lem_sumRealZ (x y : ℝ) (hx : 1 < x) : ++ (-logDerivZeta (x + y * I)).re = ∑' (n : ℕ), ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I))).re := by ++ ++ rw [lem_zeta1zetaseriesxy2 x y hx] ++ ++ exact sumRealLambda x y hx ++ ++lemma complex_cpow_neg_real (n : ℕ) (x : ℝ) (_hn : n ≥ 1) : Complex.cpow (n : ℂ) ((-x) : ℂ) = Complex.ofReal ((n : ℝ) ^ (-x)) := by ++ ++ have h_nonneg : 0 ≤ (n : ℝ) := Nat.cast_nonneg n ++ ++ rw [Complex.cpow_eq_pow] ++ ++ rw [Complex.ofReal_cpow h_nonneg (-x)] ++ ++ congr 1 ++ ++ simp ++ ++lemma RealLambdaxy (n : ℕ) (x y : ℝ) (hn : n ≥ 1) (_hx : 1 < x) : ++ ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I))).re = ++((ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x)) * (Complex.cpow (n : ℂ) (-(y * I))).re := by ++ ++ let b := ArithmeticFunction.vonMangoldt n * (n : ℝ) ^ (-x) ++ ++ have h1 : (ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) = (b : ℂ) := by ++ ++ have h_real_pow : Complex.cpow (n : ℂ) ((-x) : ℂ) = Complex.ofReal ((n : ℝ) ^ (-x)) := by ++ exact complex_cpow_neg_real n x hn ++ ++ rw [h_real_pow] ++ rw [← Complex.ofReal_mul] ++ ++ have h2 : (ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ) * Complex.cpow (n : ℂ) (-(y * I)) = ++ ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) ((-x) : ℂ)) * Complex.cpow (n : ℂ) (-(y * I)) := by ++ rw [mul_assoc] ++ ++ rw [h2, h1] ++ ++ exact lem_realbw b (Complex.cpow (n : ℂ) (-(y * I))) ++ ++lemma ReZseriesRen (x y : ℝ) (hx : 1 < x) : ++ (-logDerivZeta (x + y * I)).re = ∑' (n : ℕ), ((ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x)) * (Complex.cpow (n : ℂ) (-(y * I))).re := by ++ rw [lem_sumRealZ x y hx] ++ congr 1 ++ ext n ++ by_cases h : n = 0 ++ · simp [h] ++ · have hn : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr h ++ exact RealLambdaxy n x y hn hx ++ ++lemma Rezeta1zetaseries (x y : ℝ) (hx : 1 < x) : ++ (-logDerivZeta (x + y * I)).re = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) * Real.cos (y * Real.log (n : ℝ)) := by ++ rw [ReZseriesRen x y hx] ++ congr 1 ++ ext n ++ by_cases h : n = 0 ++ · simp [h] ++ · have hn : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr h ++ rw [← lem_eacosalog3 n hn y] ++ ++ congr 1 ++ ++ rw [Complex.cpow_eq_pow] ++ ++ simp [I] ++ ++lemma complex_vonMangoldt_real_part_eq (n : ℕ) (x y : ℝ) (hn : n ≥ 1) (hx : 1 < x) : ++((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) (-(x + y * I))).re = ++(ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) * Real.cos (y * Real.log (n : ℝ)) := by ++ ++ rw [lem_nxy n hn x y] ++ ++ rw [← mul_assoc] ++ ++ rw [RealLambdaxy n x y hn hx] ++ ++ have h_cpow : (Complex.cpow (n : ℂ) (-(y * I))).re = ((n : ℂ) ^ (-(y * I))).re := by ++ rw [Complex.cpow_eq_pow] ++ ++ have h_I : -(y * I) = -y * Complex.I := by ++ simp [I] ++ ++ rw [h_cpow, h_I] ++ ++ rw [lem_eacosalog3 n hn y] ++ ++lemma Rezetaseries_convergence (x y : ℝ) (hx : 1 < x) : ++ Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) * Real.cos (y * Real.log (n : ℝ))) := by ++ ++ have h1 : Summable (fun n => ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) (-(x + y * I))).re) := ++ ReZconverges1 x y hx ++ ++ have h2 : ∀ n : ℕ, ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) (-(x + y * I))).re = ++ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) * Real.cos (y * Real.log (n : ℝ)) := by ++ intro n ++ by_cases h : n = 0 ++ · simp [h] ++ · have hn : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr h ++ exact complex_vonMangoldt_real_part_eq n x y hn hx ++ ++ have h3 : (fun n => ((ArithmeticFunction.vonMangoldt n : ℂ) * Complex.cpow (n : ℂ) (-(x + y * I))).re) = ++ (fun n => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) * Real.cos (y * Real.log (n : ℝ))) := ++ funext h2 ++ rwa [← h3] ++ ++lemma Rezetaseries2t (x t : ℝ) (hx : 1 < x) : ++ Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) * Real.cos (2 * t * Real.log (n : ℝ))) := by ++ ++ exact Rezetaseries_convergence x (2 * t) hx ++ ++lemma lem_cost0 (n : ℕ) (_hn : n ≥ 1) (t : ℝ) (ht : t = 0) : Real.cos (t * Real.log (n : ℝ)) = 1 := by ++ rw [ht] ++ simp ++ ++lemma Rezetaseries0 (x : ℝ) (hx : 1 < x) : ++ Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x)) := by ++ ++ have h1 : Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) * Real.cos (0 * Real.log (n : ℝ))) := ++ Rezetaseries_convergence x 0 hx ++ ++ convert h1 using 1 ++ ext n ++ by_cases h : n = 0 ++ · simp [h] ++ · have hn : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr h ++ rw [lem_cost0 n hn 0 rfl] ++ ring ++ ++lemma uniform_bound_Z0_complex : ∃ δ0 > 0, ∃ C0 ≥ 0, ∀ δ : ℝ, 0 < δ → δ < δ0 → ‖-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ ≤ C0 := by ++ ++ let f : ℝ → ℂ := fun δ => -logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ)) ++ ++ have hO := Z0bound ++ ++ rcases (Asymptotics.isBigO_iff).1 hO with ⟨c, hc⟩ ++ have h_event : ∀ᶠ δ in nhdsWithin (0 : ℝ) (Set.Ioi (0 : ℝ)), ‖f δ‖ ≤ c := by ++ ++ have : ∀ᶠ δ in nhdsWithin (0 : ℝ) (Set.Ioi (0 : ℝ)), ‖f δ‖ ≤ c * ‖(1 : ℂ)‖ := hc ++ refine this.mono ?_ ++ intro δ hδ ++ have : ‖(1 : ℂ)‖ = (1 : ℝ) := by simp ++ simpa [this] using hδ ++ ++ rcases (Filter.eventually_iff_exists_mem).1 h_event with ⟨S, hS_in, hS_bound⟩ ++ ++ rcases (mem_nhdsGT_iff_exists_Ioc_subset).1 hS_in with ⟨δ0, hδ0pos, hIoc_sub_S⟩ ++ ++ refine ⟨δ0, hδ0pos, max c 0, le_max_right _ _, ?_⟩ ++ intro δ hδpos hδlt ++ ++ have hδ_in_S : δ ∈ S := hIoc_sub_S ⟨hδpos, le_of_lt hδlt⟩ ++ ++ have hnorm_le_c : ‖f δ‖ ≤ c := hS_bound δ hδ_in_S ++ ++ exact le_trans hnorm_le_c (le_max_left _ _) ++ ++lemma cpow_neg_zero_I (z : ℂ) : z ^ (-(0 : ℝ) * Complex.I) = (1 : ℂ) := by ++ simp ++ ++lemma tsum_nonneg_of_nonneg {f : ℕ → ℝ} (hnon : ∀ n, 0 ≤ f n) : 0 ≤ ∑' n, f n := by ++ simpa using (tsum_nonneg hnon) ++ ++lemma vonMangoldt_rpow_nonneg (x : ℝ) : ∀ n, 0 ≤ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) := by ++ intro n ++ have h1 : 0 ≤ (ArithmeticFunction.vonMangoldt n : ℝ) := ArithmeticFunction.vonMangoldt_nonneg ++ have h2 : 0 ≤ (n : ℝ) ^ (-x) := by ++ exact Real.rpow_nonneg (show 0 ≤ (n : ℝ) from Nat.cast_nonneg n) _ ++ simpa using mul_nonneg h1 h2 ++ ++lemma cpow_neg_real_of_nat (n : ℕ) (x : ℝ) (hn : 1 ≤ n) : ++ (n : ℂ) ^ (-(x : ℂ)) = Complex.ofReal ((n : ℝ) ^ (-x)) := by ++ simpa using complex_cpow_neg_real n x hn ++ ++lemma norm_negLogDerivZeta_real_eq_abs_tsum_vonMangoldt (x : ℝ) (hx : 1 < x) : ++ ‖-logDerivZeta (x : ℂ)‖ = |∑' n, ((ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x))| := by ++ ++ have hx' : 1 < (x : ℂ).re := by simpa using hx ++ have hseries := zeta1zetaseries (s := (x : ℂ)) hx' ++ ++ let g : ℕ → ℝ := fun n => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) ++ have hterm : ∀ n : ℕ, ++ (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x : ℂ)) = (g n : ℂ) := by ++ intro n ++ by_cases h : n = 0 ++ · ++ have hv0C : (ArithmeticFunction.vonMangoldt 0 : ℂ) = 0 := by ++ simp ++ have hv0R : (ArithmeticFunction.vonMangoldt 0 : ℝ) = 0 := by ++ simp ++ simp [g, h, hv0R] ++ · ++ have hn : 1 ≤ n := Nat.one_le_iff_ne_zero.mpr h ++ have hcp : (n : ℂ) ^ (-(x : ℂ)) = Complex.ofReal ((n : ℝ) ^ (-x)) := ++ complex_cpow_neg_real n x hn ++ ++ have : (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x : ℂ)) ++ = Complex.ofReal (ArithmeticFunction.vonMangoldt n) * Complex.ofReal ((n : ℝ) ^ (-x)) := by ++ simp [hcp] ++ simpa [g, Complex.ofReal_mul] using this ++ ++ have hsum_eq : (∑' n, (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x : ℂ))) ++ = ∑' n, (g n : ℂ) := by ++ ++ have hfun : (fun n => (ArithmeticFunction.vonMangoldt n : ℂ) * (n : ℂ) ^ (-(x : ℂ))) ++ = (fun n => (g n : ℂ)) := funext hterm ++ simp [hfun] ++ ++ have hsum_ofReal : (∑' n, (g n : ℂ)) = Complex.ofReal (∑' n, g n) := by ++ simpa using (Complex.ofReal_tsum g).symm ++ ++ have hval : -logDerivZeta (x : ℂ) = Complex.ofReal (∑' n, g n) := by ++ ++ simpa [hsum_eq, hsum_ofReal] using hseries ++ ++ calc ++ ‖-logDerivZeta (x : ℂ)‖ = ‖Complex.ofReal (∑' n, g n)‖ := by simp [hval] ++ _ = |∑' n, g n| := by ++ exact (RCLike.norm_ofReal (K := ℂ) (∑' n, g n)) ++ ++lemma tsum_le_of_nonneg_of_le {f g : ℕ → ℝ} (hf : Summable f) (hg : Summable g) (_hnonneg : ∀ n, 0 ≤ f n) (hle : ∀ n, f n ≤ g n) : (∑' n, f n) ≤ (∑' n, g n) := by ++ classical ++ exact Summable.tsum_le_tsum hle hf hg ++ ++lemma rpow_neg_antitone {a x y : ℝ} (ha : 1 ≤ a) (hxy : x ≥ y) : a ^ (-x) ≤ a ^ (-y) := by ++ ++ simpa using (Real.rpow_le_rpow_of_exponent_le ha (neg_le_neg hxy)) ++ ++lemma isPrimePow_zero_false : IsPrimePow 0 = False := by ++ apply propext ++ constructor ++ · intro h ++ rcases (isPrimePow_nat_iff 0).1 h with ⟨p, k, hp, hkpos, hk⟩ ++ have hpnz : (p : ℕ) ≠ 0 := by ++ exact ne_of_gt (Nat.Prime.pos hp) ++ have hpow_ne : (p : ℕ) ^ k ≠ 0 := pow_ne_zero _ hpnz ++ exact (hpow_ne (by simp [hk])) ++ · intro hFalse ++ exact hFalse.elim ++ ++lemma bounded_on_compact_interval (a b : ℝ) (h0 : 0 < a) (_hle : a ≤ b) : ∃ Cmid ≥ 0, ∀ δ : ℝ, a ≤ δ → δ ≤ b → ‖-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ ≤ Cmid := by ++ ++ let s : Set ℝ := Set.Icc a b ++ let f : ℝ → ℂ := fun δ => -logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ)) ++ ++ let H : ℂ → ℂ := Function.update (fun z : ℂ => (z - 1) * riemannZeta z) 1 1 ++ ++ have hH_diff : Differentiable ℂ H := by ++ intro z ++ rcases eq_or_ne z 1 with rfl | hz ++ · ++ refine (Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt ?_ ?_).differentiableAt ++ · ++ filter_upwards [self_mem_nhdsWithin] with t ht ++ have hdiff : DifferentiableAt ℂ (fun u : ℂ => (u - 1) * riemannZeta u) t := by ++ have h1 : DifferentiableAt ℂ (fun u : ℂ => u - 1) t := ++ (differentiableAt_id.sub_const 1) ++ have h2 : DifferentiableAt ℂ riemannZeta t := ++ (differentiableAt_riemannZeta ht) ++ exact h1.mul h2 ++ apply DifferentiableAt.congr_of_eventuallyEq hdiff ++ filter_upwards [eventually_ne_nhds ht] with u hu using by ++ simp [H, Function.update_of_ne hu] ++ · ++ simpa [H, continuousAt_update_same] using riemannZeta_residue_one ++ · ++ have hdiff : DifferentiableAt ℂ (fun u : ℂ => (u - 1) * riemannZeta u) z := by ++ have h1 : DifferentiableAt ℂ (fun u : ℂ => u - 1) z := (differentiableAt_id.sub_const 1) ++ have h2 : DifferentiableAt ℂ riemannZeta z := (differentiableAt_riemannZeta hz) ++ exact h1.mul h2 ++ apply DifferentiableAt.congr_of_eventuallyEq hdiff ++ filter_upwards [eventually_ne_nhds hz] with u hu using by ++ simp [H, Function.update_of_ne hu] ++ ++ let G : ℂ → ℂ := fun z => - (deriv H z) / H z ++ ++ have h_eq_on_pos : ∀ ⦃δ : ℝ⦄, 0 < δ → ++ (-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))) = G ((1 : ℂ) + δ) := by ++ intro δ hδ ++ ++ let z : ℂ := (1 : ℂ) + δ ++ have hz_ne_one : z ≠ (1 : ℂ) := by ++ intro h ++ have hre : (1 + δ : ℝ) = 1 := by ++ simpa [z, Complex.add_re, Complex.ofReal_re] using congrArg Complex.re h ++ have : δ = 0 := by linarith ++ exact (ne_of_gt hδ) this ++ have hzeta_ne : riemannZeta z ≠ 0 := by ++ have : 1 < z.re := by simpa [z, Complex.add_re, Complex.ofReal_re] using by linarith ++ exact riemannZeta_ne_zero_of_one_le_re (le_of_lt this) ++ ++ have h_id_deriv : deriv (fun u : ℂ => u - 1) z = 1 := by ++ exact ((hasDerivAt_id z).sub_const 1).deriv ++ have h_log_id : logDeriv (fun u : ℂ => u - 1) z = 1 / (z - 1) := by ++ simp [logDeriv_apply, h_id_deriv] ++ have hz1 : z - 1 ≠ 0 := by simpa using sub_ne_zero.mpr hz_ne_one ++ have hζ : riemannZeta z ≠ 0 := hzeta_ne ++ ++ have h_deriv_mul : deriv (fun u : ℂ => (u - 1) * riemannZeta u) z ++ = riemannZeta z + (z - 1) * deriv riemannZeta z := by ++ have h1 : HasDerivAt (fun u : ℂ => u - 1) 1 z := (hasDerivAt_id z).sub_const 1 ++ have h2 : HasDerivAt riemannZeta (deriv riemannZeta z) z := ++ (differentiableAt_riemannZeta hz_ne_one).hasDerivAt ++ simpa [one_mul, mul_comm, mul_left_comm, mul_assoc] using! (h1.mul h2).deriv ++ ++ have h_prodLog : ++ logDeriv (fun u : ℂ => (u - 1) * riemannZeta u) z = ++ logDeriv (fun u : ℂ => u - 1) z + logDerivZeta z := by ++ have h1 : DifferentiableAt ℂ (fun u : ℂ => u - 1) z := (differentiableAt_id.sub_const 1) ++ have h2 : DifferentiableAt ℂ riemannZeta z := (differentiableAt_riemannZeta hz_ne_one) ++ have hfnz : (fun u : ℂ => u - 1) z ≠ 0 := by simpa using hz1 ++ have hgnz : riemannZeta z ≠ 0 := hζ ++ simpa [logDerivZeta] using! ++ (logDeriv_mul (x := z) (f := fun u : ℂ => u - 1) (g := riemannZeta) hfnz hgnz h1 h2) ++ ++ have h_step : -logDerivZeta z - (1 / (z - 1)) ++ = - logDeriv (fun u : ℂ => (u - 1) * riemannZeta u) z := by ++ have : logDeriv (fun u : ℂ => (u - 1) * riemannZeta u) z ++ = 1 / (z - 1) + logDerivZeta z := by ++ simpa [h_log_id, add_comm] using h_prodLog ++ have hneg : - logDeriv (fun u : ℂ => (u - 1) * riemannZeta u) z ++ = - (1 / (z - 1) + logDerivZeta z) := by ++ simpa using congrArg Neg.neg this ++ simpa [sub_eq_add_neg, add_comm] using hneg.symm ++ ++ have h_H_eq : H z = (z - 1) * riemannZeta z := by ++ simp [H, Function.update_of_ne hz_ne_one] ++ ++ have h_eq_event : (fun u : ℂ => H u) =ᶠ[nhds z] (fun u : ℂ => (u - 1) * riemannZeta u) := by ++ filter_upwards [eventually_ne_nhds hz_ne_one] with u hu ++ simp [H, Function.update_of_ne hu] ++ ++ have h_hasDeriv_prod : ++ HasDerivAt (fun u : ℂ => (u - 1) * riemannZeta u) ++ (riemannZeta z + (z - 1) * deriv riemannZeta z) z := by ++ have h1 : HasDerivAt (fun u : ℂ => u - 1) 1 z := (hasDerivAt_id z).sub_const 1 ++ have h2 : HasDerivAt riemannZeta (deriv riemannZeta z) z := ++ (differentiableAt_riemannZeta hz_ne_one).hasDerivAt ++ simpa [one_mul, mul_comm, mul_left_comm, mul_assoc] using! (h1.mul h2) ++ ++ have h_hasDeriv_H : ++ HasDerivAt H (riemannZeta z + (z - 1) * deriv riemannZeta z) z := ++ h_hasDeriv_prod.congr_of_eventuallyEq h_eq_event ++ ++ have h_dH : deriv H z = riemannZeta z + (z - 1) * deriv riemannZeta z := by ++ simpa using h_hasDeriv_H.deriv ++ ++ have h_log_to_G : - logDeriv (fun u : ℂ => (u - 1) * riemannZeta u) z = G z := by ++ have h' : logDeriv (fun u : ℂ => (u - 1) * riemannZeta u) z = (deriv H z) / H z := by ++ simp [logDeriv_apply, h_H_eq, h_dH, h_deriv_mul] ++ have hneg' := congrArg (fun w => -w) h' ++ simpa [G, neg_div] using hneg' ++ ++ have : -logDerivZeta z - (1 / (z - 1)) = G z := by ++ simpa using h_step.trans h_log_to_G ++ ++ simpa [z] using this ++ ++ let F : ℝ → ℂ := fun δ => G ((1 : ℂ) + δ) ++ ++ have hH_analytic_univ : AnalyticOnNhd ℂ H Set.univ := ++ (Complex.analyticOnNhd_univ_iff_differentiable).2 hH_diff ++ ++ have hF_contOn : ContinuousOn F s := by ++ intro δ0 hδ0 ++ ++ let s0 : ℂ := (1 : ℂ) + δ0 ++ have hδ0pos : 0 < δ0 := lt_of_lt_of_le h0 hδ0.1 ++ have hs0_ne_one : s0 ≠ (1 : ℂ) := by ++ intro h ++ have hre : (1 + δ0 : ℝ) = 1 := by ++ simpa [s0, Complex.add_re, Complex.ofReal_re] using congrArg Complex.re h ++ have : δ0 = 0 := by linarith ++ exact (ne_of_gt hδ0pos) this ++ have hs0_re_gt_one : 1 < s0.re := by ++ simpa [s0, Complex.add_re, Complex.ofReal_re] using by linarith ++ have hζ_ne : riemannZeta s0 ≠ 0 := ++ riemannZeta_ne_zero_of_one_le_re (le_of_lt hs0_re_gt_one) ++ have hHs0_eq : H s0 = (s0 - 1) * riemannZeta s0 := by ++ simp [H, Function.update_of_ne hs0_ne_one] ++ have hHs0_ne : H s0 ≠ 0 := by ++ have hs0m1_ne : s0 - 1 ≠ 0 := sub_ne_zero.mpr hs0_ne_one ++ have : (s0 - 1) * riemannZeta s0 ≠ 0 := mul_ne_zero hs0m1_ne hζ_ne ++ simpa [hHs0_eq] using this ++ ++ have hH_an_at_s0 : AnalyticAt ℂ H s0 := hH_analytic_univ s0 (by simp) ++ have hH'_an_at_s0 : AnalyticAt ℂ (fun z => deriv H z) s0 := hH_an_at_s0.deriv ++ have hG_an_at_s0 : AnalyticAt ℂ (fun z => G z) s0 := by ++ have h_div : AnalyticAt ℂ (fun z => (deriv H z) / H z) s0 := ++ hH'_an_at_s0.div hH_an_at_s0 (by simpa using hHs0_ne) ++ have h_neg : AnalyticAt ℂ (fun z => -((deriv H z) / H z)) s0 := h_div.neg ++ simpa [G, div_eq_mul_inv, mul_left_comm, mul_comm, mul_assoc] using h_neg ++ have hG_cont_s0 : ContinuousAt (fun z : ℂ => G z) s0 := hG_an_at_s0.continuousAt ++ ++ let affine : ℝ → ℂ := fun δ => (1 : ℂ) + (δ : ℂ) ++ have h_affine_at : ContinuousAt affine δ0 := ++ (continuousAt_const).add Complex.continuous_ofReal.continuousAt ++ ++ have hy : affine δ0 = s0 := by simp [affine, s0] ++ have hG_at : ContinuousAt (fun z : ℂ => G z) (affine δ0) := by simpa [hy] using hG_cont_s0 ++ have h_comp_at : ContinuousAt (fun δ : ℝ => G (affine δ)) δ0 := hG_at.comp h_affine_at ++ simpa [F, s, affine] using h_comp_at.continuousWithinAt ++ ++ have h_eq_on_s : ∀ ⦃δ : ℝ⦄, δ ∈ s → f δ = F δ := by ++ intro δ hδ ++ have hδpos : 0 < δ := lt_of_lt_of_le h0 hδ.1 ++ simpa [f, F] using h_eq_on_pos hδpos ++ ++ have hK : IsCompact s := isCompact_Icc ++ have hNorm_contOn : ContinuousOn (fun δ => ‖F δ‖) s := hF_contOn.norm ++ have hBdd : BddAbove ((fun δ => ‖F δ‖) '' s) := IsCompact.bddAbove_image hK hNorm_contOn ++ rcases hBdd with ⟨C, hC⟩ ++ ++ refine ⟨max C 0, le_max_right _ _, ?_⟩ ++ intro δ hδa hδb ++ ++ change ‖f δ‖ ≤ max C 0 ++ have hδmem : δ ∈ s := ⟨hδa, hδb⟩ ++ have himg : (fun δ => ‖F δ‖) δ ∈ (fun δ => ‖F δ‖) '' s := ⟨δ, hδmem, rfl⟩ ++ have hbound : ‖F δ‖ ≤ C := hC himg ++ have hbound' : ‖F δ‖ ≤ max C 0 := le_trans hbound (le_max_left _ _) ++ ++ have hfδ_eq : f δ = F δ := h_eq_on_s hδmem ++ calc ++ ‖f δ‖ = ‖F δ‖ := by simp [hfδ_eq] ++ _ ≤ max C 0 := hbound' ++ ++lemma norm_one_div_coe_real_le_one_of_one_le {δ : ℝ} (h : 1 ≤ δ) : ‖(1 : ℂ) / (δ : ℂ)‖ ≤ 1 := by ++ ++ have hδpos : 0 < δ := lt_of_lt_of_le zero_lt_one h ++ calc ++ ‖(1 : ℂ) / (δ : ℂ)‖ = ‖(1 : ℂ)‖ / ‖(δ : ℂ)‖ := by ++ exact norm_div (1 : ℂ) (δ : ℂ) ++ _ = 1 / ‖(δ : ℂ)‖ := by simp ++ _ = 1 / |δ| := by simp ++ _ = 1 / δ := by simp [abs_of_nonneg (le_of_lt hδpos)] ++ _ ≤ 1 := by ++ ++ simpa using (one_div_le_one_div_of_le (ha := (zero_lt_one)) (h := h)) ++ ++lemma Z0bound_const : ++ ∃ C > 1, ∀ (δ : ℝ) (_hδ : δ > 0), ++ ‖ -logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ ≤ C := by ++ ++ rcases uniform_bound_Z0_complex with ⟨δ0, hδ0pos, C0, hC0nonneg, hsmall⟩ ++ ++ let a : ℝ := min δ0 1 ++ have ha_pos : 0 < a := lt_min_iff.2 ⟨hδ0pos, zero_lt_one⟩ ++ have ha_le_one : a ≤ 1 := min_le_right _ _ ++ rcases bounded_on_compact_interval a 1 ha_pos ha_le_one with ⟨Cmid, hCmid_nonneg, hmid⟩ ++ ++ let C2 : ℝ := ∑' n, (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(2 : ℝ)) ++ have hC2_nonneg : 0 ≤ C2 := by ++ have hnn : ∀ n, 0 ≤ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(2 : ℝ)) := ++ vonMangoldt_rpow_nonneg 2 ++ exact tsum_nonneg_of_nonneg hnn ++ ++ let C : ℝ := 2 + C0 + Cmid + C2 ++ have hCgt1 : 1 < C := by ++ have : 2 ≤ 2 + C0 + Cmid + C2 := by linarith [hC0nonneg, hCmid_nonneg, hC2_nonneg] ++ linarith ++ refine ⟨C, hCgt1, ?_⟩ ++ intro δ hδpos ++ by_cases hlt : δ < δ0 ++ · ++ have hbound : ‖-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ ≤ C0 := ++ hsmall δ hδpos hlt ++ ++ have hC0_le_C : C0 ≤ C := by linarith ++ exact le_trans hbound hC0_le_C ++ · ++ have hge : δ0 ≤ δ := le_of_not_gt hlt ++ rcases le_total δ 1 with hδle1 | hδge1 ++ · ++ have ha_le_δ : a ≤ δ := le_trans (min_le_left δ0 1) hge ++ have hbound : ‖-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ ≤ Cmid := ++ hmid δ ha_le_δ hδle1 ++ ++ have hCmid_le_C : Cmid ≤ C := by linarith ++ exact le_trans hbound hCmid_le_C ++ · ++ ++ let x : ℝ := 1 + δ ++ have hx1 : 1 < x := by ++ have : 0 < δ := hδpos ++ have : 1 < 1 + δ := lt_add_of_pos_right 1 this ++ exact this ++ ++ have h_norm_eq_abs_real : ‖-logDerivZeta (x : ℂ)‖ ++ = |∑' n, (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x)| := ++ norm_negLogDerivZeta_real_eq_abs_tsum_vonMangoldt x hx1 ++ ++ have eqArg : ((1 : ℂ) + δ) = (x : ℂ) := by simp [x] ++ ++ have h_norm_eq_abs : ‖-logDerivZeta ((1 : ℂ) + δ)‖ ++ = |∑' n, (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x)| := by ++ simpa [eqArg] using h_norm_eq_abs_real ++ ++ let S : ℝ := ∑' n, (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) ++ have hsum_nonneg : 0 ≤ S := by ++ change 0 ≤ ∑' n, (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) ++ exact tsum_nonneg_of_nonneg (vonMangoldt_rpow_nonneg x) ++ ++ have h_norm_le_sum : ‖-logDerivZeta ((1 : ℂ) + δ)‖ ≤ S := by ++ have : ‖-logDerivZeta ((1 : ℂ) + δ)‖ = |S| := h_norm_eq_abs ++ have : |S| = S := abs_of_nonneg hsum_nonneg ++ exact le_of_eq (h_norm_eq_abs.trans this) ++ ++ have hx_ge_two : 2 ≤ x := by ++ ++ have : 1 ≤ δ := hδge1 ++ have : 2 ≤ 1 + δ := by linarith ++ exact this ++ ++ have h_le_2 : ∀ n, (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) ++ ≤ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(2 : ℝ)) := by ++ intro n ++ by_cases h0 : n = 0 ++ · simp [h0] ++ · have hn : 1 ≤ n := Nat.one_le_iff_ne_zero.mpr h0 ++ have hn' : (1 : ℝ) ≤ (n : ℝ) := by exact_mod_cast hn ++ have hrpow : (n : ℝ) ^ (-x) ≤ (n : ℝ) ^ (-(2 : ℝ)) := ++ rpow_neg_antitone hn' hx_ge_two ++ have hΛ_nonneg : 0 ≤ (ArithmeticFunction.vonMangoldt n : ℝ) := ++ ArithmeticFunction.vonMangoldt_nonneg ++ exact mul_le_mul_of_nonneg_left hrpow hΛ_nonneg ++ ++ have h_summ_x : Summable (fun n => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x)) := by ++ exact Rezetaseries0 x hx1 ++ have h_summ_2 : Summable (fun n => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(2 : ℝ))) := ++ Rezetaseries0 2 (by norm_num) ++ have hsum_le : S ≤ C2 := by ++ ++ have h_nonneg_x : ∀ n, 0 ≤ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-x) := ++ vonMangoldt_rpow_nonneg x ++ exact tsum_le_of_nonneg_of_le h_summ_x h_summ_2 h_nonneg_x h_le_2 ++ ++ have h_norm_le_C2 : ‖-logDerivZeta ((1 : ℂ) + δ)‖ ≤ C2 := ++ le_trans h_norm_le_sum hsum_le ++ ++ have h_one_div_le : ‖(1 : ℂ) / (δ : ℂ)‖ ≤ 1 := norm_one_div_coe_real_le_one_of_one_le hδge1 ++ have htriangle : ‖-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ ++ ≤ ‖-logDerivZeta ((1 : ℂ) + δ)‖ + ‖(1 : ℂ) / (δ : ℂ)‖ := ++ norm_sub_le _ _ ++ have hlarge_bound : ‖-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ ≤ C2 + 1 := by ++ refine le_trans htriangle ?_ ++ exact add_le_add h_norm_le_C2 h_one_div_le ++ ++ have hC2_le_C : C2 + 1 ≤ C := by linarith ++ exact le_trans hlarge_bound hC2_le_C ++ ++lemma Z0boundRe_const : ++ ∃ C > 1, ∀ (δ : ℝ) (_hδ : δ > 0), ++ ((-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))).re) ≤ C := by ++ ++ rcases Z0bound_const with ⟨C, hCpos, hC⟩ ++ use C ++ constructor ++ · exact hCpos ++ · intro δ hδ ++ ++ have h_bound := hC δ hδ ++ exact le_trans (Complex.re_le_norm _) h_bound ++ ++lemma Z0boundRe_const2 : ++ ∃ C > 1, ∀ (δ : ℝ) (_hδ : δ > 0), ++ ((-logDerivZeta ((1 : ℂ) + δ)).re + (-(1 / (δ : ℂ))).re) ≤ C := by ++ ++ rcases Z0boundRe_const with ⟨C, hC_pos, hC⟩ ++ use C, hC_pos ++ intro δ hδ ++ have h_sub_re : ((-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))).re) = ++ ((-logDerivZeta ((1 : ℂ) + δ)).re + (-(1 / (δ : ℂ))).re) := by ++ rw [Complex.sub_re] ++ rfl ++ rw [← h_sub_re] ++ exact hC δ hδ ++ ++lemma Z0boundRe_const3 : ++ ∃ C > 1, ∀ (δ : ℝ) (_hδ : δ > 0), ++ (-logDerivZeta ((1 : ℂ) + δ)).re - (1 / δ) ≤ C := by ++ ++ rcases Z0boundRe_const2 with ⟨C, hCpos, hC⟩ ++ use C, hCpos ++ intro δ hδ ++ ++ have h := hC δ hδ ++ ++ have h_re_eq : (-(1 / (δ : ℂ))).re = -(1 / δ) := by ++ rw [Complex.neg_re, Complex.div_re, Complex.one_re, Complex.ofReal_re, Complex.ofReal_im] ++ simp [Complex.normSq_ofReal] ++ ++ rwa [h_re_eq] at h ++ ++lemma Z341bounds_const : ++ ∃ C > 1, ∀ (δ : ℝ) (_hδ : δ > 0) (_hδ1 : δ < 1), ∀ t : ℝ, 2 < |t| → ∀ σ : ℝ, ++ (σ + t * Complex.I) ∈ zeroZ → ++ 3 * (-logDerivZeta ((1 : ℂ) + δ)).re ++ + 4 * (-logDerivZeta ((1 : ℂ) + δ + t * Complex.I)).re ++ + (-logDerivZeta ((1 : ℂ) + δ + (2 * t) * Complex.I)).re ++ ≤ 3 / δ - 4 / (1 + δ - σ) + C * Real.log (|t| + 2) := by ++ ++ rcases Z0boundRe_const3 with ⟨C0, hC0pos, hZ0⟩ ++ rcases Z1bound with ⟨C1, hC1pos, hZ1⟩ ++ rcases lem_Z2bound with ⟨C2, hC2pos, hZ2⟩ ++ ++ let C := 3 * C0 + 4 * C1 + C2 ++ ++ have hC_gt_one : 1 < C := by ++ have h1 : 1 < C0 := hC0pos ++ have h2 : 3 < 3 * C0 := by linarith [mul_lt_mul_of_pos_left h1 (by norm_num : (0 : ℝ) < 3)] ++ have h3 : 0 < 4 * C1 := mul_pos (by norm_num) (lt_trans zero_lt_one hC1pos) ++ have h4 : 0 < C2 := lt_trans zero_lt_one hC2pos ++ linarith [h2, h3, h4] ++ ++ use C ++ constructor ++ · exact hC_gt_one ++ · intro δ hδpos hδ1 t ht σ hσ ++ ++ have hZ0_bound : (-logDerivZeta ((1 : ℂ) + δ)).re ≤ C0 + (1 / δ) := by ++ have := hZ0 δ hδpos ++ linarith ++ ++ have hZ1_bound : (-logDerivZeta ((1 : ℂ) + δ + t * Complex.I)).re ≤ -(1 / (1 + δ - σ)) + C1 * Real.log (|t| + 2) := by ++ let s := σ + t * Complex.I ++ have hs_mem : s ∈ zeroZ := hσ ++ have hs_im : s.im = t := by simp [s] ++ have hs_re : s.re = σ := by simp [s] ++ have hδ_cond : 0 < δ ∧ δ < 1 := ⟨hδpos, hδ1⟩ ++ have := hZ1 δ hδ_cond t ht s ⟨hs_mem, hs_im⟩ ++ rw [hs_re] at this ++ exact this ++ ++ have hZ2_bound : (-logDerivZeta ((1 : ℂ) + δ + (2 * t) * Complex.I)).re ≤ C2 * Real.log (|t| + 2) := by ++ have hδ_cond : 0 < δ ∧ δ < 1 := ⟨hδpos, hδ1⟩ ++ exact hZ2 t ht δ hδ_cond ++ ++ have hlog_ge_one : 1 ≤ Real.log (|t| + 2) := by ++ have h1 : 2 < |t| := ht ++ have h2 : Real.exp 1 < 3 := lem_three_gt_e ++ have he_lt_t2 : Real.exp 1 < |t| + 2 := by linarith ++ have ht2_pos : 0 < |t| + 2 := by linarith [abs_nonneg t] ++ exact Real.le_log_iff_exp_le ht2_pos |>.mpr (le_of_lt he_lt_t2) ++ ++ calc ++ 3 * (-logDerivZeta ((1 : ℂ) + δ)).re + 4 * (-logDerivZeta ((1 : ℂ) + δ + t * Complex.I)).re + (-logDerivZeta ((1 : ℂ) + δ + (2 * t) * Complex.I)).re ++ ≤ 3 * (C0 + (1 / δ)) + 4 * (-(1 / (1 + δ - σ)) + C1 * Real.log (|t| + 2)) + C2 * Real.log (|t| + 2) := by ++ exact add_le_add (add_le_add (mul_le_mul_of_nonneg_left hZ0_bound (by norm_num)) (mul_le_mul_of_nonneg_left hZ1_bound (by norm_num))) hZ2_bound ++ _ = 3 * C0 + 3 / δ - 4 / (1 + δ - σ) + (4 * C1 + C2) * Real.log (|t| + 2) := by ring ++ _ = 3 / δ - 4 / (1 + δ - σ) + 3 * C0 + (4 * C1 + C2) * Real.log (|t| + 2) := by ring ++ _ = 3 / δ - 4 / (1 + δ - σ) + ((4 * C1 + C2) * Real.log (|t| + 2) + 3 * C0) := by ring ++ _ ≤ 3 / δ - 4 / (1 + δ - σ) + (4 * C1 + C2 + 3 * C0) * Real.log (|t| + 2) := by ++ ++ have hC0_pos : 0 < C0 := lt_trans zero_lt_one hC0pos ++ have hC0_nonneg : 0 ≤ 3 * C0 := mul_nonneg (by norm_num) (le_of_lt hC0_pos) ++ have h_absorb := absorb_pos_constant_into_log (L := Real.log (|t| + 2)) (A := 4 * C1 + C2) (c := 3 * C0) hlog_ge_one hC0_nonneg ++ ++ exact add_le_add_right h_absorb (3 / δ - 4 / (1 + δ - σ)) ++ _ = 3 / δ - 4 / (1 + δ - σ) + (3 * C0 + 4 * C1 + C2) * Real.log (|t| + 2) := by ring ++ _ = 3 / δ - 4 / (1 + δ - σ) + C * Real.log (|t| + 2) := by ring ++ ++def ZeroAt (σ t : ℝ) : Prop := ++ (σ + t * I) ∈ zeroZ ++ ++def Ft (σ : ℝ) : Filter ℝ := ++ (Filter.atTop ⊔ Filter.atBot) ⊓ Filter.principal {t : ℝ | ZeroAt σ t} ++ ++def Fδ : Filter ℝ := nhdsWithin 0 (Set.Ioi 0) ++ ++lemma Rezeta1zetaseries1 (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ (-logDerivZeta ((1 : ℂ) + delta + t * I)).re = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ)) := by ++ ++ have h1 : 1 < 1 + delta := by linarith [hdelta] ++ convert Rezeta1zetaseries (1 + delta) t h1 ++ ++ simp [Complex.ofReal_add] ++ ++lemma Rezeta1zetaseries2 (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ (-logDerivZeta ((1 : ℂ) + delta + (2 * t) * I)).re = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (2 * t * Real.log (n : ℝ)) := by ++ ++ have h1 : 1 < 1 + delta := by linarith [hdelta] ++ ++ have h2 : (1 : ℂ) + delta + (2 * t) * I = (1 + delta : ℝ) + ((2 * t) : ℝ) * I := by ++ simp [Complex.ofReal_add, Complex.ofReal_one, Complex.ofReal_mul] ++ rw [h2] ++ exact Rezeta1zetaseries (1 + delta) (2 * t) h1 ++ ++lemma Rezeta1zetaseries0 (delta : ℝ) (hdelta : delta > 0) : ++ (-logDerivZeta ((1 : ℂ) + delta)).re = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) := by ++ ++ have h_series : (-logDerivZeta ((1 : ℂ) + delta + 0 * I)).re = ++ ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (0 * Real.log (n : ℝ)) := ++ Rezeta1zetaseries1 0 delta hdelta ++ ++ have h_lhs : (-logDerivZeta ((1 : ℂ) + delta + 0 * I)).re = (-logDerivZeta ((1 : ℂ) + delta)).re := by ++ congr 2 ++ simp ++ ++ have h_rhs : ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (0 * Real.log (n : ℝ)) = ++ ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) := by ++ congr 1 ++ funext n ++ by_cases h : n = 0 ++ · simp [h] ++ · have hn : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr h ++ rw [lem_cost0 n hn 0 rfl, mul_one] ++ ++ rw [← h_lhs, h_series, h_rhs] ++ ++lemma Z341series (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ (3 * (-logDerivZeta ((1 : ℂ) + delta)).re + ++ 4 * (-logDerivZeta ((1 : ℂ) + delta + t * I)).re + ++ (-logDerivZeta ((1 : ℂ) + delta + (2 * t) * I)).re) ++ = ++ (3 * ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) + ++ 4 * ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ)) + ++ ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (2 * t * Real.log (n : ℝ))) := by ++ rw [Rezeta1zetaseries0 delta hdelta, Rezeta1zetaseries1 t delta hdelta, Rezeta1zetaseries2 t delta hdelta] ++ ++lemma lem341seriesConv (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ Summable (fun n : ℕ => ++ 3 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) + ++ 4 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ)) + ++ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (2 * t * Real.log (n : ℝ))) := by ++ ++ have h1 : 1 < 1 + delta := by linarith [hdelta] ++ ++ have h2 : Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta))) := ++ Rezetaseries0 (1 + delta) h1 ++ ++ have h3 : Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ))) := ++ Rezetaseries_convergence (1 + delta) t h1 ++ ++ have h4 : Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (2 * t * Real.log (n : ℝ))) := ++ Rezetaseries2t (1 + delta) t h1 ++ ++ have h5 : Summable (fun n : ℕ => 3 * ((ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)))) := ++ Summable.mul_left 3 h2 ++ ++ have h6 : Summable (fun n : ℕ => 4 * ((ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ)))) := ++ Summable.mul_left 4 h3 ++ ++ have h5' : Summable (fun n : ℕ => 3 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta))) := by ++ convert h5 using 1 ++ ext n ++ ring ++ ++ have h6' : Summable (fun n : ℕ => 4 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ))) := by ++ convert h6 using 1 ++ ext n ++ ring ++ ++ have h7 : Summable (fun n : ℕ => ++ 3 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) + ++ 4 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ))) := ++ h5'.add h6' ++ ++ exact h7.add h4 ++ ++lemma lem341series (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ (3 * ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta))) ++ + (4 * ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ))) ++ + (∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (2 * t * Real.log (n : ℝ))) ++ = ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * (3 + 4 * Real.cos (t * Real.log (n : ℝ)) + Real.cos (2 * t * Real.log (n : ℝ))) := by ++ ++ have h1 : 1 < 1 + delta := by linarith [hdelta] ++ ++ have h2 : Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta))) := ++ Rezetaseries0 (1 + delta) h1 ++ ++ have h3 : Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ))) := ++ Rezetaseries_convergence (1 + delta) t h1 ++ ++ have h4 : Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (2 * t * Real.log (n : ℝ))) := ++ Rezetaseries2t (1 + delta) t h1 ++ ++ rw [← Summable.tsum_mul_left 3 h2] ++ rw [← Summable.tsum_mul_left 4 h3] ++ ++ rw [← Summable.tsum_add (Summable.mul_left 3 h2) (Summable.mul_left 4 h3)] ++ rw [← Summable.tsum_add] ++ ++ congr 1 ++ ext n ++ ring ++ ++ · exact Summable.add (Summable.mul_left 3 h2) (Summable.mul_left 4 h3) ++ · exact h4 ++ ++lemma lem_341seriesConverge (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ Summable (fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * (3 + 4 * Real.cos (t * Real.log (n : ℝ)) + Real.cos (2 * t * Real.log (n : ℝ)))) := by ++ ++ have h1 : Summable (fun n : ℕ => ++ 3 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) + ++ 4 * (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (t * Real.log (n : ℝ)) + ++ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * Real.cos (2 * t * Real.log (n : ℝ))) := ++ lem341seriesConv t delta hdelta ++ ++ convert h1 using 1 ++ ext n ++ ring ++ ++lemma lem_341series2 (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ (3 * (-logDerivZeta ((1 : ℂ) + delta)).re + ++ 4 * (-logDerivZeta ((1 : ℂ) + delta + t * I)).re + ++ (-logDerivZeta ((1 : ℂ) + delta + (2 * t) * I)).re) ++ = ++ ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * (3 + 4 * Real.cos (t * Real.log (n : ℝ)) + Real.cos (2 * t * Real.log (n : ℝ))) := by ++ rw [Z341series t delta hdelta] ++ exact lem341series t delta hdelta ++ ++lemma lem_Lambda_pos_trig_sum (n : ℕ) (delta : ℝ) (t : ℝ) (hn : n ≥ 1) (hdelta : delta > 0) : ++ 0 ≤ (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * (3 + 4 * Real.cos (t * Real.log (n : ℝ)) + Real.cos (2 * t * Real.log (n : ℝ))) := by ++ apply mul_nonneg ++ · ++ apply lem_realnx n (1 + delta) hn ++ ++ linarith [hdelta] ++ · ++ exact lem_postriglogn n hn t ++ ++lemma seriesPos {f : ℕ → ℝ} (_h_summable : Summable (fun n => if 1 ≤ n then f n else 0)) (h_nonneg : ∀ n : ℕ, 1 ≤ n → 0 ≤ f n) : 0 ≤ ∑' (n : ℕ), (if 1 ≤ n then f n else 0) := by ++ apply tsum_nonneg ++ intro n ++ by_cases h : 1 ≤ n ++ · simp [h] ++ exact h_nonneg n h ++ · simp [h] ++ ++lemma lem_seriespos (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ 0 ≤ ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n : ℝ) * (n : ℝ) ^ (-(1 + delta)) * (3 + 4 * Real.cos (t * Real.log (n : ℝ)) + Real.cos (2 * t * Real.log (n : ℝ))) := by ++ apply tsum_nonneg ++ intro n ++ by_cases h : n = 0 ++ · ++ simp [h] ++ · ++ have hn : n ≥ 1 := Nat.one_le_iff_ne_zero.mpr h ++ exact lem_Lambda_pos_trig_sum n delta t hn hdelta ++ ++lemma Z341pos (t : ℝ) (delta : ℝ) (hdelta : delta > 0) : ++ 0 ≤ 3 * (-logDerivZeta ((1 : ℂ) + delta)).re + ++ 4 * (-logDerivZeta ((1 : ℂ) + delta + t * I)).re + ++ (-logDerivZeta ((1 : ℂ) + delta + (2 * t) * I)).re := by ++ rw [lem_341series2 t delta hdelta] ++ exact lem_seriespos t delta hdelta ++ ++lemma frac_den_increase_bound {a b c : ℝ} (hpos : 0 < a + b) (hc : 0 ≤ c) : ++ 4 / (a + b + c) ≤ 4 / (a + b) := by ++ ++ have hle : a + b ≤ a + b + c := by linarith ++ ++ have h1 : 1 / (a + b + c) ≤ 1 / (a + b) := by ++ exact one_div_le_one_div_of_le hpos hle ++ ++ have h4nonneg : 0 ≤ (4 : ℝ) := by norm_num ++ have hmul := mul_le_mul_of_nonneg_left h1 h4nonneg ++ ++ have hmul' : 4 * (a + b + c)⁻¹ ≤ 4 * (a + b)⁻¹ := by ++ simpa [one_div] using hmul ++ simpa [div_eq_mul_inv] using hmul' ++ ++lemma log_abs_add_two_pos (t : ℝ) : 0 < Real.log (abs t + 2) := by ++ ++ have h0 : 0 ≤ abs t + 2 := by ++ have h' : 0 ≤ abs t := abs_nonneg t ++ linarith ++ have hge : (2 : ℝ) ≤ abs t + 2 := by ++ have h' : 0 ≤ abs t := abs_nonneg t ++ have := add_le_add_left h' (2 : ℝ) ++ simp ++ have hgt : 1 < abs t + 2 := lt_of_lt_of_le (by norm_num : (1 : ℝ) < 2) hge ++ ++ exact (Real.log_pos_iff h0).2 hgt ++ ++lemma log_gt_of_gt_exp {x y : ℝ} (h : Real.exp y < x) : y < Real.log x := by ++ have hxpos : 0 < x := lt_trans (Real.exp_pos y) h ++ exact (Real.lt_log_iff_exp_lt hxpos).2 h ++ ++lemma denom_rewrite (σ C L : ℝ) : 1 - σ + (1 / (2 * C * L)) = 1 + (1 / (2 * C * L)) - σ := by ++ ring ++ ++lemma pos_delta_from_C_L {C L : ℝ} (hC : 0 < C) (hL : 0 < L) : 0 < 1 / (2 * C * L) := by ++ have hCL : 0 < C * L := mul_pos hC hL ++ have h2 : 0 < (2 : ℝ) := by norm_num ++ have hpos : 0 < 2 * C * L := by ++ have : 0 < 2 * (C * L) := mul_pos h2 hCL ++ simpa [mul_assoc] using this ++ exact one_div_pos.mpr hpos ++ ++lemma add_two_pos_of_abs (t : ℝ) : 0 < |t| + 2 := by ++ have : 0 ≤ |t| := abs_nonneg t ++ linarith ++ ++lemma log_abs_two_pos (t : ℝ) : 0 < Real.log (|t| + 2) := by ++ simpa using log_abs_add_two_pos t ++ ++lemma two_C_log_pos {C t : ℝ} (hC : 0 < C) : 0 < 2 * C * Real.log (|t| + 2) := by ++ have hL : 0 < Real.log (|t| + 2) := log_abs_two_pos t ++ have h2 : 0 < (2 : ℝ) := by norm_num ++ have hCL : 0 < C * Real.log (|t| + 2) := mul_pos hC hL ++ have : 0 < 2 * (C * Real.log (|t| + 2)) := mul_pos h2 hCL ++ simpa [mul_comm, mul_left_comm, mul_assoc] using this ++ ++lemma mul_one_div_self_of_pos {a : ℝ} (ha : 0 < a) : a * (1 / a) = 1 := by ++ have hne : a ≠ 0 := ne_of_gt ha ++ simp [one_div, hne] ++ ++lemma mul_one_div_mul_right {A b : ℝ} (hA : A ≠ 0) : A * (1 / (A * b)) = 1 / b := by ++ calc ++ A * (1 / (A * b)) = A * ((A * b)⁻¹) := by simp [one_div] ++ _ = A / (A * b) := by simp [div_eq_mul_inv] ++ _ = A / A / b := by ++ simpa using (div_mul_eq_div_div (a := A) (b := A) (c := b)) ++ _ = 1 / b := by ++ have : A / A = (1 : ℝ) := by simp [hA] ++ simp [this] ++ ++lemma one_div_mul_one_div_mul_right {A b : ℝ} (hA : A ≠ 0) (_hb : b ≠ 0) : 1 / (A * (1 / (A * b))) = b := by ++ have h := mul_one_div_mul_right (A := A) (b := b) hA ++ have hinv := congrArg (fun x : ℝ => x⁻¹) h ++ calc ++ 1 / (A * (1 / (A * b))) = (A * (1 / (A * b)))⁻¹ := by simp [one_div] ++ _ = (1 / b)⁻¹ := by simpa using hinv ++ _ = b := by simp [one_div] ++ ++lemma inv_of_delta_def (C L δ : ℝ) (hδ : δ = 1 / (2 * C * L)) : 1 / δ = 2 * C * L := by ++ simp [hδ, one_div] ++ ++lemma rhs_eval_of_inv (C L δ : ℝ) (h : 1 / δ = 2 * C * L) : 3 / δ + C * L = 7 * C * L := by ++ calc ++ 3 / δ + C * L ++ = 3 * (1 / δ) + C * L := by simp [div_eq_mul_inv] ++ _ = 3 * (2 * C * L) + C * L := by simp [h] ++ _ = 6 * C * L + C * L := by ring ++ _ = 7 * C * L := by ring ++ ++lemma lem341tsC : ++ ∃ C > 1, ∀ s : ℂ, ++ (s ∈ zeroZ ∧ 0 < s.re ∧ s.re < 1) → ++ 2 < |s.im| → ++ 4 / (1 - s.re + 1 / (2 * C * Real.log (abs s.im + 2))) ≤ 7 * C * Real.log (abs s.im + 2) := by ++ ++ obtain ⟨C, hCpos, hbound⟩ := Z341bounds_const ++ refine ⟨C, hCpos, ?_⟩ ++ intro s hs hTim ++ ++ let L : ℝ := Real.log (|s.im| + 2) ++ have hLpos : 0 < L := log_abs_two_pos (s.im) ++ let δ : ℝ := 1 / (2 * C * L) ++ ++ have hCpos_weak : 0 < C := lt_trans zero_lt_one hCpos ++ have hδpos : 0 < δ := pos_delta_from_C_L hCpos_weak hLpos ++ ++ have hδlt : δ < 1 := by ++ ++ have hL_gt_1 : 1 < L := by ++ have h5_lt : 4 < |s.im| + 2 := by linarith [hTim] ++ have hL_gt_log5 : Real.log 4 < L := Real.log_lt_log (by norm_num) h5_lt ++ have hlog5_gt_1 : 1 < Real.log 4 := by ++ have h5_gt_e : Real.exp 1 < 4 := by ++ have h3_gt_e := lem_three_gt_e ++ linarith [h3_gt_e] ++ rw [← Real.log_exp 1] ++ exact Real.log_lt_log (Real.exp_pos 1) h5_gt_e ++ linarith [hlog5_gt_1, hL_gt_log5] ++ ++ have h2CL_gt_1 : 1 < 2 * C * L := by ++ ++ have hCL_gt_1 : 1 < C * L := by ++ calc C * L ++ > 1 * L := by exact mul_lt_mul_of_pos_right hCpos hLpos ++ _ = L := by simp ++ _ > 1 := hL_gt_1 ++ have h2_pos : (0 : ℝ) < 2 := by norm_num ++ calc 2 * C * L ++ = 2 * (C * L) := by ring ++ _ > 2 * 1 := by exact mul_lt_mul_of_pos_left hCL_gt_1 h2_pos ++ _ = 2 := by simp ++ _ > 1 := by norm_num ++ ++ simp only [δ] ++ rw [div_lt_one_iff] ++ left ++ exact ⟨two_C_log_pos hCpos_weak, h2CL_gt_1⟩ ++ ++ have hmem : (s.re + s.im * Complex.I) ∈ zeroZ := by ++ simpa [Complex.re_add_im] using hs.1 ++ have hupper := hbound δ hδpos hδlt (s.im) hTim (s.re) hmem ++ ++ have hpos := Z341pos (s.im) δ hδpos ++ ++ have hRHS_nonneg : 0 ≤ 3 / δ - 4 / (1 + δ - s.re) + C * L := le_trans hpos hupper ++ have hineq1 : 4 / (1 + δ - s.re) ≤ 3 / δ + C * L := by linarith [hRHS_nonneg] ++ ++ have hineq2 : 4 / (1 - s.re + δ) ≤ 3 / δ + C * L := by ++ convert hineq1 using 2 ++ ring ++ ++ have hinv : 1 / δ = 2 * C * L := by ++ simp only [δ, one_div, inv_inv] ++ ++ have hrhs_eval : 3 / δ + C * L = 7 * C * L := rhs_eval_of_inv C L δ hinv ++ ++ have hfinal : 4 / (1 - s.re + δ) ≤ 7 * C * L := by ++ rw [← hrhs_eval] ++ exact hineq2 ++ ++ convert hfinal ++ ++lemma zeta_zero_re_lt_one (s : ℂ) (hs : s ∈ zeroZ) : s.re < 1 := by ++ ++ by_contra h ++ ++ push Not at h ++ ++ have h_zero : riemannZeta s = 0 := hs ++ ++ have h_nonzero : riemannZeta s ≠ 0 := riemannZeta_ne_zero_of_one_le_re h ++ ++ exact h_nonzero h_zero ++ ++lemma div_le_to_le_mul (x y z : ℝ) (hy : 0 < y) (h : x / y ≤ z) : x ≤ z * y := by ++ rwa [div_le_iff₀ hy] at h ++ ++lemma le_mul_to_le_div (x y z : ℝ) (hy : 0 < y) (h : x ≤ z * y) : x / y ≤ z := by ++ rw [div_le_iff₀ hy] ++ exact h ++ ++lemma reciprocal_div_inequality (a b : ℝ) (ha : 0 < a) (hb : 0 < b) (h : 4 / a ≤ b) : a ≥ 4 / b := by ++ ++ have h1 : 4 ≤ b * a := div_le_to_le_mul 4 a b ha h ++ ++ have h2 : 4 ≤ a * b := by ++ rwa [mul_comm] at h1 ++ ++ have h3 : 4 / b ≤ a := le_mul_to_le_div 4 b a hb h2 ++ ++ exact h3 ++ ++lemma lem341tsC2 : ++ ∃ C > 1, ∀ s : ℂ, ++ (s ∈ zeroZ ∧ 0 < s.re ∧ s.re < 1) → ++ 2 < |s.im| → ++ 1 - s.re + 1 / (2 * C * Real.log (abs s.im + 2)) ≥ 4 / (7 * C * Real.log (abs s.im + 2)) := by ++ ++ rcases lem341tsC with ⟨C, hCpos, hT⟩ ++ refine ⟨C, hCpos, ?_⟩ ++ intro s hs hTs ++ ++ set a := 1 - s.re + 1 / (2 * C * Real.log (abs s.im + 2)) with ha ++ set b := 7 * C * Real.log (abs s.im + 2) with hb ++ have hineq : 4 / a ≤ b := by ++ simpa [ha, hb] using hT s hs hTs ++ ++ have h_abs_nonneg : 0 ≤ |s.im| := abs_nonneg _ ++ have h_two_le : (2 : ℝ) ≤ |s.im| + 2 := by ++ have h' : (2 : ℝ) + 0 ≤ 2 + |s.im| := add_le_add_right h_abs_nonneg 2 ++ simp ++ have h_one_lt : (1 : ℝ) < |s.im| + 2 := lt_of_lt_of_le one_lt_two h_two_le ++ have hx0 : 0 ≤ |s.im| + 2 := by linarith [h_abs_nonneg] ++ have hlogpos : 0 < Real.log (|s.im| + 2) := (Real.log_pos_iff hx0).2 h_one_lt ++ have h7pos : 0 < (7 : ℝ) := by exact_mod_cast (by decide : (0 : ℕ) < 7) ++ have hbpos : 0 < b := by ++ have h7Cpos : 0 < 7 * C := by linarith ++ exact mul_pos h7Cpos hlogpos ++ ++ rcases hs with ⟨_, hRepos, hRelt⟩ ++ have h1 : 0 < 1 - s.re := sub_pos.mpr hRelt ++ have h2pos : 0 < (2 : ℝ) := lt_trans zero_lt_one one_lt_two ++ have h2Cpos : 0 < (2 : ℝ) * C := by linarith ++ have hdenpos : 0 < 2 * C * Real.log (|s.im| + 2) := mul_pos h2Cpos hlogpos ++ have hinvpos : 0 < 1 / (2 * C * Real.log (|s.im| + 2)) := one_div_pos.mpr hdenpos ++ have hapos : 0 < a := by ++ have := add_pos h1 hinvpos ++ simpa [ha] using this ++ ++ have hres := reciprocal_div_inequality a b hapos hbpos hineq ++ simpa [ha, hb] using hres ++ ++lemma simplify_4_7_2 (C L : ℝ) : 4 / (7 * C * L) - 1 / (2 * C * L) = 1 / (14 * C * L) := by ++ ++ have h1 : (4 : ℝ) / (7 * (C * L)) = (4 : ℝ) / (7 : ℝ) / (C * L) := by ++ simpa using (div_mul_eq_div_div (a := (4 : ℝ)) (b := (7 : ℝ)) (c := C * L)) ++ have h2 : (1 : ℝ) / (2 * (C * L)) = (1 : ℝ) / (2 : ℝ) / (C * L) := by ++ simpa using (div_mul_eq_div_div (a := (1 : ℝ)) (b := (2 : ℝ)) (c := C * L)) ++ ++ have h3' : ((4 : ℝ) / (7 : ℝ)) - (2 : ℝ)⁻¹ = (14 : ℝ)⁻¹ := by ++ have h3 : ((4 : ℝ) / (7 : ℝ)) - ((1 : ℝ) / (2 : ℝ)) = (1 : ℝ) / (14 : ℝ) := by ++ norm_num ++ simpa [one_div] using h3 ++ calc ++ 4 / (7 * C * L) - 1 / (2 * C * L) ++ = (4 : ℝ) / (7 * (C * L)) - (1 : ℝ) / (2 * (C * L)) := by ++ simp [mul_assoc] ++ _ = (4 : ℝ) / (7 : ℝ) / (C * L) - (1 : ℝ) / (2 : ℝ) / (C * L) := by ++ simp [h1, h2] ++ _ = (((4 : ℝ) / (7 : ℝ)) - ((1 : ℝ) / (2 : ℝ))) / (C * L) := by ++ simpa using (sub_div (a := ((4 : ℝ) / (7 : ℝ))) (b := ((1 : ℝ) / (2 : ℝ))) (c := C * L)).symm ++ _ = (((4 : ℝ) / (7 : ℝ)) - (2 : ℝ)⁻¹) / (C * L) := by ++ simp [one_div] ++ _ = (14 : ℝ)⁻¹ / (C * L) := by ++ simp [h3'] ++ _ = 1 / (14 * (C * L)) := by ++ simpa [mul_comm, mul_left_comm, mul_assoc, one_div] using ++ (div_mul_eq_div_div (a := (1 : ℝ)) (b := (14 : ℝ)) (c := C * L)).symm ++ _ = 1 / (14 * C * L) := by simp [mul_assoc] ++ ++lemma fraction_diff_lower_bound (C L a : ℝ) : 4 / (7 * C * L) ≤ a + 1 / (2 * C * L) → 1 / (14 * C * L) ≤ a := by ++ intro h ++ have h' : 4 / (7 * C * L) - 1 / (2 * C * L) ≤ a := (sub_le_iff_le_add).mpr h ++ have hdiff : 1 / (14 * C * L) = 4 / (7 * C * L) - 1 / (2 * C * L) := by ++ symm ++ exact simplify_4_7_2 C L ++ calc ++ 1 / (14 * C * L) ++ = 4 / (7 * C * L) - 1 / (2 * C * L) := hdiff ++ _ ≤ a := h' ++ ++lemma lem341tsC3 : ++ ∃ C > 1, ∀ s : ℂ, ++ (s ∈ zeroZ ∧ 0 < s.re ∧ s.re < 1) → ++ 2 < |s.im| → ++ 1 - s.re ≥ 1 / (14 * C * Real.log (abs s.im + 2)) := by ++ obtain ⟨C, hCpos, hT⟩ := lem341tsC2 ++ refine ⟨C, hCpos, ?_⟩ ++ intro s hs hTle ++ have h := hT s hs hTle ++ ++ have h' : 4 / (7 * C * Real.log (abs s.im + 2)) ≤ ++ (1 - s.re) + 1 / (2 * C * Real.log (abs s.im + 2)) := by ++ simpa [ge_iff_le, add_comm, add_left_comm, add_assoc] using h ++ ++ have h'' := fraction_diff_lower_bound C (Real.log (abs s.im + 2)) (1 - s.re) h' ++ ++ simpa [ge_iff_le, mul_comm, mul_left_comm, mul_assoc] using h'' ++ ++lemma zerofree : ++ ∃ c, c > 0 ∧ c < 1 ∧ ∀ s : ℂ, ++ (s ∈ zeroZ ∧ 0 < s.re ∧ s.re < 1) → ++ 2 < |s.im| → s.re ≤ 1 - c / (Real.log (abs s.im + 2)) := by ++ ++ rcases lem341tsC3 with ⟨C0, hC0pos, hT⟩ ++ ++ set C : ℝ := 1 / (14 * C0) with hCdef ++ ++ have h14pos : 0 < (14 : ℝ) := by norm_num ++ have hC0pos' : 0 < C0 := lt_trans zero_lt_one hC0pos ++ have hCpos : 0 < C := by ++ have hdenpos : 0 < 14 * C0 := mul_pos h14pos hC0pos' ++ exact one_div_pos.mpr hdenpos ++ ++ have hClt1 : C < 1 := by ++ have h14C0_pos : 0 < 14 * C0 := mul_pos h14pos hC0pos' ++ have h14C0_gt_1 : 1 < 14 * C0 := by ++ have h14_gt_1 : (1 : ℝ) < 14 := by norm_num ++ calc ++ (1 : ℝ) = 1 * 1 := by ring ++ _ < 14 * 1 := by exact mul_lt_mul_of_pos_right h14_gt_1 zero_lt_one ++ _ < 14 * C0 := by exact mul_lt_mul_of_pos_left hC0pos h14pos ++ rw [hCdef] ++ rw [div_lt_one_iff] ++ left ++ exact ⟨h14C0_pos, h14C0_gt_1⟩ ++ ++ refine ⟨C, hCpos, hClt1, ?_⟩ ++ intro s hs hTle ++ ++ set L := Real.log (abs s.im + 2) with hLdef ++ ++ have hb0 := hT s hs hTle ++ ++ have hb' : C / L ≤ 1 - s.re := by ++ simpa [hLdef, hCdef, one_div, div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using hb0 ++ ++ have : s.re ≤ 1 - C / L := by linarith ++ simpa [hLdef] using this ++ ++def Yt (t : ℝ) (δ : ℝ) : Set ℂ := ++ { ρ_1 : ℂ | riemannZeta ρ_1 = 0 ∧ ‖ρ_1 - (1 - δ + t * Complex.I)‖ ≤ 2 * δ } ++ ++noncomputable def zerofree_constant : ℝ := Classical.choose zerofree ++ ++lemma zerofree_constant_pos : 0 < zerofree_constant := ++ (Classical.choose_spec zerofree).1 ++ ++lemma zerofree_constant_lt_one : zerofree_constant < 1 := ++ (Classical.choose_spec zerofree).2.1 ++ ++noncomputable def deltaz (z : ℂ) : ℝ := (zerofree_constant / 20) / Real.log (|z.im| + 2) ++ ++noncomputable def deltaz_t (t : ℝ) : ℝ := deltaz (t * Complex.I) ++ ++lemma lem_delta19 : ++ (∀ z : ℂ, |z.im| > 2 → (0 < deltaz z ∧ deltaz z < 1/9)) ∧ ++ (∀ t : ℝ, |t| > 2 → (0 < deltaz_t t ∧ deltaz_t t < 1/9)) := by ++ ++ have h_complex : ∀ z : ℂ, |z.im| > 2 → (0 < deltaz z ∧ deltaz z < 1/9) := by ++ intro z hz ++ constructor ++ · ++ have h_num_pos : 0 < zerofree_constant / 20 := by ++ exact div_pos zerofree_constant_pos (by norm_num) ++ have h_den_pos : 0 < Real.log (|z.im| + 2) := by ++ have h_gt_one : (1 : ℝ) < |z.im| + 2 := by ++ have h_nonneg : (0 : ℝ) ≤ |z.im| := abs_nonneg _ ++ linarith [hz] ++ exact Real.log_pos h_gt_one ++ unfold deltaz ++ exact div_pos h_num_pos h_den_pos ++ · ++ ++ have h_den_ge_half : (1/2 : ℝ) ≤ Real.log (|z.im| + 2) := by ++ ++ have h_den_ge_log2 : Real.log 2 ≤ Real.log (|z.im| + 2) := by ++ have h_pos : 0 < |z.im| + 2 := by linarith [abs_nonneg (z.im)] ++ have h_le : (2 : ℝ) ≤ |z.im| + 2 := by linarith [abs_nonneg (z.im)] ++ exact Real.log_le_log (by norm_num) h_le ++ ++ have h_log2_ge_half : (1/2 : ℝ) ≤ Real.log 2 := by ++ have h_exp_half_le_two : Real.exp (1/2) ≤ 2 := by ++ ++ have h_exp_one_lt_three : Real.exp 1 < 3 := lem_three_gt_e ++ have h_exp_sq : (Real.exp (1/2))^2 = Real.exp 1 := by ++ rw [pow_two, ← Real.exp_add]; norm_num ++ have h_exp_sq_lt_four : (Real.exp (1/2))^2 < 4 := by ++ rw [h_exp_sq]; linarith [h_exp_one_lt_three] ++ ++ have h_exp_pos : 0 ≤ Real.exp (1/2) := le_of_lt (Real.exp_pos _) ++ have h_two_pos : 0 ≤ (2 : ℝ) := by norm_num ++ have h_four_eq : (2 : ℝ)^2 = 4 := by norm_num ++ rw [← h_four_eq] at h_exp_sq_lt_four ++ have h_lt_abs := (sq_lt_sq).mp h_exp_sq_lt_four ++ rw [abs_of_nonneg h_exp_pos, abs_of_nonneg h_two_pos] at h_lt_abs ++ exact le_of_lt h_lt_abs ++ exact (Real.le_log_iff_exp_le (by norm_num : 0 < (2 : ℝ))).mpr h_exp_half_le_two ++ exact le_trans h_log2_ge_half h_den_ge_log2 ++ ++ have h_inv_le_two : 1 / Real.log (|z.im| + 2) ≤ 2 := by ++ have h_pos_half : 0 < (1/2 : ℝ) := by norm_num ++ have h_ineq := one_div_le_one_div_of_le h_pos_half h_den_ge_half ++ convert h_ineq using 1; first | rfl | norm_num ++ ++ have h_bound : deltaz z ≤ zerofree_constant / 10 := by ++ unfold deltaz ++ ++ rw [div_eq_mul_inv] ++ ++ have h_num_nonneg : 0 ≤ zerofree_constant / 20 := by ++ exact le_of_lt (div_pos zerofree_constant_pos (by norm_num)) ++ have h_mul_ineq := mul_le_mul_of_nonneg_left h_inv_le_two h_num_nonneg ++ convert h_mul_ineq using 1 <;> first | rfl | ring ++ ++ have h_lt_tenth : zerofree_constant / 10 < 1 / 10 := by ++ exact div_lt_div_of_pos_right zerofree_constant_lt_one (by norm_num) ++ have h_tenth_lt_ninth : (1 : ℝ) / 10 < 1 / 9 := by norm_num ++ exact lt_trans (lt_of_le_of_lt h_bound h_lt_tenth) h_tenth_lt_ninth ++ ++ constructor ++ · exact h_complex ++ · ++ intro t ht ++ ++ have h_eq : deltaz_t t = deltaz (t * Complex.I) := rfl ++ rw [h_eq] ++ have h_im_eq : |(t * Complex.I).im| = |t| := by simp ++ rw [← h_im_eq] at ht ++ exact h_complex (t * Complex.I) ht ++ ++lemma closedBall_compact_complex (c : ℂ) (r : ℝ) : ++ IsCompact (Metric.closedBall c r) := by ++ ++ exact ProperSpace.isCompact_closedBall c r ++ ++lemma riemannZeta_no_zeros_accumulate_at_one : ++ ∀ Z : Set ℂ, (∀ z ∈ Z, riemannZeta z = 0) → ¬AccPt 1 (Filter.principal Z) := by ++ intro Z hZ ++ ++ by_contra h_acc ++ ++ have h_residue := riemannZeta_residue_one ++ ++ rw [Metric.tendsto_nhdsWithin_nhds] at h_residue ++ obtain ⟨δ, hδ_pos, hδ_bound⟩ := h_residue (1/2) (by norm_num : (0 : ℝ) < 1/2) ++ ++ rw [accPt_iff_nhds] at h_acc ++ ++ obtain ⟨y, ⟨hy_ball, hy_Z⟩, hy_ne⟩ := h_acc (Metric.ball 1 δ) (Metric.ball_mem_nhds 1 hδ_pos) ++ ++ have hy_zero : riemannZeta y = 0 := hZ y hy_Z ++ ++ have hy_in_compl : y ∈ ({1} : Set ℂ)ᶜ := by ++ rw [Set.mem_compl_iff, Set.mem_singleton_iff] ++ exact hy_ne ++ ++ have hy_dist : dist y 1 < δ := hy_ball ++ ++ have h_bound := hδ_bound hy_in_compl hy_dist ++ ++ rw [hy_zero, mul_zero] at h_bound ++ ++ have h_dist_eq : dist (0 : ℂ) (1 : ℂ) = 1 := by ++ rw [Complex.dist_eq] ++ norm_num ++ ++ rw [h_dist_eq] at h_bound ++ ++ norm_num at h_bound ++ ++lemma complex_minus_singleton_connected : IsPreconnected ({s : ℂ | s ≠ 1} : Set ℂ) := by ++ ++ have h_eq : {s : ℂ | s ≠ 1} = ({1} : Set ℂ)ᶜ := by ++ ext x ++ simp [Set.mem_compl_iff, Set.mem_singleton_iff] ++ ++ rw [h_eq] ++ ++ have h_rank : 1 < Module.rank ℝ ℂ := by ++ rw [Complex.rank_real_complex] ++ ++ norm_num ++ ++ have h_connected := isConnected_compl_singleton_of_one_lt_rank h_rank (1 : ℂ) ++ ++ exact h_connected.isPreconnected ++ ++lemma eventually_eq_zero_implies_frequently_eq_zero_punctured (f : ℂ → ℂ) (z₀ : ℂ) : ++ (∀ᶠ z in nhds z₀, f z = 0) → (∃ᶠ z in nhdsWithin z₀ {z₀}ᶜ, f z = 0) := by ++ intro h_eventually ++ ++ have h_nebot : Filter.NeBot (nhdsWithin z₀ {z₀}ᶜ) := by ++ ++ exact NormedField.nhdsNE_neBot z₀ ++ ++ have h_eventually_punctured : ∀ᶠ z in nhdsWithin z₀ {z₀}ᶜ, f z = 0 := by ++ ++ exact Filter.Eventually.filter_mono nhdsWithin_le_nhds h_eventually ++ ++ exact h_eventually_punctured.frequently ++ ++lemma riemannZeta_zeros_finite_of_compact (K : Set ℂ) (hK : IsCompact K) : ++ {z ∈ K | riemannZeta z = 0}.Finite := by ++ ++ by_contra h_not_finite ++ push Not at h_not_finite ++ ++ let Z := {z ∈ K | riemannZeta z = 0} ++ ++ have hZ_inf : Z.Infinite := h_not_finite ++ have hZ_sub : Z ⊆ K := fun z hz => hz.1 ++ ++ obtain ⟨z₀, hz₀_K, hz₀_acc⟩ := lem_bolzano_weierstrass hK hZ_inf hZ_sub ++ ++ by_cases h_eq_one : z₀ = 1 ++ · ++ subst h_eq_one ++ ++ have hZ_zeros : ∀ z ∈ Z, riemannZeta z = 0 := fun z hz => hz.2 ++ ++ exact riemannZeta_no_zeros_accumulate_at_one Z hZ_zeros hz₀_acc ++ ++ · ++ ++ have h_analytic : AnalyticAt ℂ riemannZeta z₀ := ++ zetaanalOnnot1 z₀ h_eq_one ++ ++ obtain h_ev_zero | h_ev_ne := h_analytic.eventually_eq_zero_or_eventually_ne_zero ++ ++ · ++ ++ have h_freq := eventually_eq_zero_implies_frequently_eq_zero_punctured riemannZeta z₀ h_ev_zero ++ ++ have h_eq_on_zero := zetaanalOnnot1.eqOn_zero_of_preconnected_of_frequently_eq_zero ++ complex_minus_singleton_connected h_eq_one h_freq ++ ++ have : riemannZeta 0 = 0 := h_eq_on_zero (by simp : (0 : ℂ) ∈ {s | s ≠ 1}) ++ rw [riemannZeta_zero] at this ++ norm_num at this ++ ++ · ++ ++ unfold AccPt at hz₀_acc ++ ++ have h_ev_not_Z : ∀ᶠ z in nhdsWithin z₀ {z₀}ᶜ, z ∉ Z := by ++ apply Filter.Eventually.mono h_ev_ne ++ intro z hz hz_in_Z ++ exact hz hz_in_Z.2 ++ ++ have h_ev_false : ∀ᶠ z in nhdsWithin z₀ {z₀}ᶜ ⊓ Filter.principal Z, False := by ++ rw [Filter.eventually_inf_principal] ++ exact h_ev_not_Z ++ ++ have h_eq_bot : nhdsWithin z₀ {z₀}ᶜ ⊓ Filter.principal Z = ⊥ := ++ Filter.eventually_false_iff_eq_bot.mp h_ev_false ++ ++ have h_ne_bot : nhdsWithin z₀ {z₀}ᶜ ⊓ Filter.principal Z ≠ ⊥ := hz₀_acc.ne ++ ++ exact h_ne_bot h_eq_bot ++ ++lemma lem_ZFRdelta : ++ ∀ z : ℂ, 2 < |z.im| → z.re > 1 - 9 * deltaz z → riemannZeta z ≠ 0 := by ++ intro z him hre ++ by_cases h1 : 1 ≤ z.re ++ · ++ simpa using riemannZeta_ne_zero_of_one_le_re h1 ++ ++ have hzlt1 : z.re < 1 := lt_of_not_ge h1 ++ ++ have hgt : |z.im| > 2 := by simpa using him ++ have hδ := (lem_delta19).1 z hgt ++ rcases hδ with ⟨hδ_pos, hδ_lt_19⟩ ++ ++ have h9δ_lt1 : 9 * deltaz z < 1 := by ++ have h := mul_lt_mul_of_pos_left hδ_lt_19 (by norm_num : 0 < (9 : ℝ)) ++ have h9 : (9 : ℝ) * (1 / 9) = 1 := by norm_num ++ simpa [h9] using h ++ have hzre_pos : 0 < z.re := by ++ have : 0 < 1 - 9 * deltaz z := sub_pos.mpr h9δ_lt1 ++ exact lt_trans this hre ++ ++ by_contra hzero ++ have hzmem : z ∈ zeroZ := by simpa [zeroZ] using hzero ++ ++ have hprop := (Classical.choose_spec zerofree).2.2 ++ have hbound : z.re ≤ 1 - zerofree_constant / Real.log (|z.im| + 2) := ++ hprop z ⟨hzmem, hzre_pos, hzlt1⟩ him ++ ++ set L : ℝ := Real.log (|z.im| + 2) with hLdef ++ have hLpos : 0 < L := by ++ have hone_lt : (1 : ℝ) < |z.im| + 2 := by ++ have : (0 : ℝ) ≤ |z.im| := abs_nonneg _ ++ linarith ++ have := Real.log_pos hone_lt ++ simpa [hLdef] using this ++ ++ have hb_le_a' : ((9 : ℝ) / 20) * (zerofree_constant / L) ≤ zerofree_constant / L := by ++ have hcoef_le1 : ((9 : ℝ) / 20) ≤ 1 := by norm_num ++ have ha_nonneg : 0 ≤ zerofree_constant / L := le_of_lt (div_pos zerofree_constant_pos hLpos) ++ have := mul_le_mul_of_nonneg_right hcoef_le1 ha_nonneg ++ simpa [one_mul] using this ++ have h9d_eq : 9 * deltaz z = ((9 : ℝ) / 20) * (zerofree_constant / L) := by ++ simp [deltaz, hLdef, div_eq_mul_inv, mul_left_comm, mul_assoc] ++ have hdelta_le : 9 * deltaz z ≤ zerofree_constant / L := by ++ simpa [h9d_eq] using hb_le_a' ++ have h_le_rhs : 1 - zerofree_constant / L ≤ 1 - 9 * deltaz z := by ++ have hneg := neg_le_neg hdelta_le ++ simpa [sub_eq_add_neg] using! add_le_add_right hneg 1 ++ ++ have hle : z.re ≤ 1 - 9 * deltaz z := le_trans hbound h_le_rhs ++ have hcontr : z.re < z.re := lt_of_le_of_lt hle hre ++ exact (lt_irrefl (z.re)) hcontr ++ ++lemma complex_re_add_I_mul_real (a t : ℝ) : (((a : ℂ) + Complex.I * t).re) = a := by ++ ++ have h1 : ((Complex.I * (t : ℂ)).re) = -((t : ℂ).im) := by ++ simp ++ have ht_im : ((t : ℂ).im) = 0 := by simp ++ simp [Complex.add_re, Complex.ofReal_re, h1] ++ ++lemma complex_im_add_I_mul_real (a t : ℝ) : (((a : ℂ) + Complex.I * t).im) = t := by ++ ++ have h1 : ((Complex.I * (t : ℂ)).im) = ((t : ℂ).re) := by ++ simp ++ have ht_re : ((t : ℂ).re) = t := by simp ++ simp [Complex.add_im, Complex.ofReal_im, h1] ++ ++lemma complex_sub_ofReal_I_real_eq_ofReal (z : ℂ) (a t : ℝ) (him : z.im = t) : ++ z - ((a : ℂ) + Complex.I * t) = ((z.re - a) : ℂ) := by ++ apply Complex.ext ++ · simp [Complex.sub_re, Complex.add_re, Complex.ofReal_re, Complex.ofReal_im] ++ · simp [Complex.sub_im, Complex.add_im, Complex.ofReal_im, Complex.ofReal_re, him] ++ ++lemma lem_ZFRinD (t : ℝ) (ht : |t| > 2) (z : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ 1 - deltaz_t t ≤ Complex.re z ∧ Complex.re z ≤ 3/2 ∧ Complex.im z = t → ++ z ∈ Metric.closedBall c (2/3) := by ++ intro c h ++ rcases h with ⟨h_low, hrest⟩ ++ rcases hrest with ⟨h_high, him⟩ ++ have hsub : z - c = ((z.re - (3/2)) : ℂ) := by ++ simpa [c] using! complex_sub_ofReal_I_real_eq_ofReal z (3/2) t him ++ have h1 : dist z c = ‖((z.re - (3/2)) : ℂ)‖ := by ++ simp [dist_eq_norm, hsub] ++ have h2 : ‖((z.re - (3/2)) : ℂ)‖ = ‖z.re - (3/2)‖ := by ++ simpa using (Complex.norm_real (z.re - (3/2))) ++ have hdist_abs : dist z c = |z.re - (3/2)| := by ++ have h4 : dist z c = ‖z.re - (3/2)‖ := h1.trans h2 ++ simpa [Real.norm_eq_abs] using h4 ++ have hnonpos : z.re - (3/2) ≤ 0 := sub_nonpos_of_le h_high ++ have habs : |z.re - (3/2)| = 3/2 - z.re := by ++ have := abs_of_nonpos hnonpos ++ simpa [neg_sub] using this ++ have hdist_eq : dist z c = 3/2 - z.re := hdist_abs.trans habs ++ have h_le : dist z c ≤ 1/2 + deltaz_t t := by ++ calc ++ dist z c = 3/2 - z.re := hdist_eq ++ _ ≤ 3/2 - (1 - deltaz_t t) := by linarith ++ _ = 1/2 + deltaz_t t := by ring ++ have hδlt : deltaz_t t < 1/9 := (lem_delta19.2 t ht).2 ++ have h12δ_lt : (1/2 : ℝ) + deltaz_t t < (1/2 : ℝ) + 1/9 := by ++ have := add_lt_add_left hδlt (1/2 : ℝ) ++ simpa [add_comm, add_left_comm, add_assoc] using this ++ have h123_lt : (1/2 : ℝ) + 1/9 < (2/3 : ℝ) := by norm_num ++ have h_lt : (1/2 : ℝ) + deltaz_t t < (2/3 : ℝ) := lt_trans h12δ_lt h123_lt ++ have hdist_le : dist z c ≤ 2/3 := le_trans h_le (le_of_lt h_lt) ++ exact (Metric.mem_closedBall).2 hdist_le ++ ++lemma lem_ZFRnotK (t : ℝ) (ht : |t| > 2) (z : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ 1 - deltaz_t t ≤ Complex.re z ∧ Complex.re z ≤ 3/2 ∧ Complex.im z = t → ++ z ∉ zerosetKfRc (5/6) c riemannZeta := by ++ intro c h ++ ++ obtain ⟨h_ge, h_le, h_im⟩ := h ++ ++ have h_delta_eq : deltaz z = deltaz_t t := by ++ rw [deltaz_t, deltaz] ++ ++ congr 1 ++ congr 1 ++ ++ rw [h_im] ++ ++ simp only [Complex.mul_I_im, Complex.ofReal_re] ++ ++ have h_ge_delta : 1 - deltaz z ≤ Complex.re z := by ++ rwa [← h_delta_eq] at h_ge ++ ++ have h_im_gt : |z.im| > 2 := by ++ rw [h_im] ++ exact ht ++ ++ have h_delta_pos : 0 < deltaz z := by ++ exact (lem_delta19.1 z h_im_gt).1 ++ ++ have h_delta_lt_9delta : deltaz z < 9 * deltaz z := by ++ linarith [h_delta_pos] ++ ++ have h_strict : Complex.re z > 1 - 9 * deltaz z := by ++ linarith [h_ge_delta, h_delta_lt_9delta] ++ ++ have h_zeta_ne_zero : riemannZeta z ≠ 0 := ++ lem_ZFRdelta z h_im_gt h_strict ++ ++ intro h_mem ++ ++ have h_zero : riemannZeta z = 0 := h_mem.2 ++ ++ exact h_zeta_ne_zero h_zero ++ ++lemma lem_Zeta_Expansion_ZFR : ++ ∃ C_1 : ℝ, C_1 > 1 ∧ ++ ∀ t : ℝ, |t| > 3 → ++ let c := (3/2 : ℂ) + I * t; ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ ∀ z : ℂ, 1 - deltaz_t t ≤ Complex.re z ∧ Complex.re z ≤ 3/2 ∧ Complex.im z = t → ++ ‖(deriv riemannZeta z / riemannZeta z) - ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ))‖ ++ ≤ C_1 * Real.log |t| := by ++ obtain ⟨C, hC_gt_one, hC_expansion⟩ := ++ Zeta1_Zeta_Expansion (2/3) (3/4) ++ (by norm_num : (0 : ℝ) < 2/3) ++ (by norm_num : (2/3 : ℝ) < 3/4) ++ (by norm_num : (3/4 : ℝ) < 5/6) ++ let C_1 := C * (1 / ((3/4 : ℝ) - 2/3)^3 + 1) ++ have hC_1_gt_1 : C_1 > 1 := by ++ have h_coeff : (1 : ℝ) / ((3/4 : ℝ) - 2/3)^3 + 1 > 1 := by ++ have h_pos : ((3/4 : ℝ) - 2/3)^3 > 0 := by norm_num ++ have h_div_pos : (1 : ℝ) / ((3/4 : ℝ) - 2/3)^3 > 0 := div_pos one_pos h_pos ++ linarith ++ have h_ge_1 : (1 : ℝ) ≤ C := le_of_lt hC_gt_one ++ exact one_lt_mul_of_le_of_lt h_ge_1 h_coeff ++ refine ⟨C_1, hC_1_gt_1, ?_⟩ ++ intro t ht c hfin z hz ++ have ht2 : |t| > 2 := by linarith ++ have hz_in_ball : z ∈ Metric.closedBall c (2/3) := by ++ simpa [c] using (lem_ZFRinD t ht2 z hz) ++ have hz_not_in_K : z ∉ zerosetKfRc (5/6) c riemannZeta := by ++ simpa [c] using (lem_ZFRnotK t ht2 z hz) ++ have hz_in_diff : z ∈ Metric.closedBall c (2/3) \ zerosetKfRc (5/6) c riemannZeta := ++ ⟨hz_in_ball, hz_not_in_K⟩ ++ have h_expansion := hC_expansion t ht hfin z hz_in_diff ++ rw [show logDerivZeta z = deriv riemannZeta z / riemannZeta z from rfl] at h_expansion ++ exact h_expansion ++ ++lemma lem_abszrhoReRe (z ρ : ℂ) : ‖z - ρ‖ ≥ z.re - ρ.re := by ++ have h1 : (z - ρ).re ≤ ‖z - ρ‖ := Complex.re_le_norm (z - ρ) ++ have h2 : (z - ρ).re = z.re - ρ.re := Complex.sub_re z ρ ++ rw [← h2] ++ exact h1 ++ ++lemma lem_Rerhotodeltarho {ρ : ℂ} : ++ ∀ t : ℝ, |t| > 3 → ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) (3/2+ t* Complex.I) riemannZeta) → ρ.re ≤ 1 - 9 * deltaz ρ := by ++ intro t ht h_mem ++ ++ have h_zero : riemannZeta ρ = 0 := h_mem.2 ++ ++ have h_ball : ρ ∈ Metric.closedBall (3/2 + t * Complex.I) (5/6) := h_mem.1 ++ ++ have h_dist : dist ρ (3/2 + t * Complex.I) ≤ 5/6 := by ++ rwa [Metric.mem_closedBall] at h_ball ++ ++ have h_im : 2 < |ρ.im| := by ++ ++ have h_im_bound : |ρ.im - t| ≤ 5/6 := by ++ ++ have h_le_norm : |ρ.im - t| ≤ ‖ρ - (3/2 + t * Complex.I)‖ := by ++ have : |(ρ - (3/2 + t * Complex.I)).im| ≤ ‖ρ - (3/2 + t * Complex.I)‖ := ++ Complex.abs_im_le_norm _ ++ have h_im_eq : (ρ - (3/2 + t * Complex.I)).im = ρ.im - t := by ++ simp [Complex.sub_im, Complex.add_im, Complex.ofReal_im] ++ rwa [← h_im_eq] ++ rw [← Complex.dist_eq] at h_le_norm ++ linarith [h_le_norm, h_dist] ++ ++ have triangle := abs_sub_abs_le_abs_sub t ρ.im ++ ++ have eq_comm : |t - ρ.im| = |ρ.im - t| := abs_sub_comm t ρ.im ++ rw [eq_comm] at triangle ++ ++ have h_ge : |ρ.im| ≥ |t| - |ρ.im - t| := by linarith [triangle] ++ ++ have : |ρ.im| ≥ |t| - 5/6 := by linarith [h_ge, h_im_bound] ++ have : |ρ.im| > 3 - 5/6 := by linarith [ht] ++ have h_calc : (3 : ℝ) - 5/6 = 13/6 := by norm_num ++ have h_gt2 : (13 : ℝ)/6 > 2 := by norm_num ++ rw [h_calc] at * ++ linarith [h_gt2] ++ ++ have h_not_gt : ¬(ρ.re > 1 - 9 * deltaz ρ) := by ++ intro h_gt ++ have h_ne_zero := lem_ZFRdelta ρ h_im h_gt ++ exact h_ne_zero h_zero ++ ++ exact le_of_not_gt h_not_gt ++ ++lemma lem_DImt2d : ++ ∀ t : ℝ, |t| > 3 → ∀ z ∈ Metric.closedBall (3/2 + t * Complex.I) (5/6), ++ |z.im| ≤ |t| + 5/6 := by ++ intro t ht z hz ++ ++ rw [Metric.mem_closedBall] at hz ++ ++ have center_im : (3/2 + t * Complex.I).im = t := by simp [Complex.add_im, Complex.mul_im] ++ ++ have diff_im : (z - (3/2 + t * Complex.I)).im = z.im - t := by ++ rw [Complex.sub_im, center_im] ++ ++ have h1 : |z.im - t| ≤ ‖z - (3/2 + t * Complex.I)‖ := by ++ rw [← diff_im] ++ exact Complex.abs_im_le_norm _ ++ ++ have h2 : |z.im - t| ≤ 5/6 := le_trans h1 (by simpa only [dist_eq_norm] using! hz) ++ ++ have h3 : |z.im| ≤ |z.im - t| + |t| := by ++ conv_lhs => rw [show z.im = (z.im - t) + t by ring] ++ exact abs_add_le (z.im - t) t ++ linarith ++ ++lemma lem_DIMt2 : ++ ∀ t : ℝ, |t| > 3 → ∀ z ∈ Metric.closedBall (3/2 + t * Complex.I) (5/6), ++ |z.im| + 2 ≤ (|t| + 2)^3 := by ++ intro t ht z hz ++ ++ have h1' := lem_DImt2d t ht z hz ++ ++ have h1a : |z.im| + 2 ≤ |t| + 17/6 := by ++ simpa [show |t| + 5/6 + 2 = |t| + 17/6 by ring] using! add_le_add_left h1' 2 ++ ++ have h17le3 : |t| + 17/6 ≤ |t| + 3 := by ++ have : (17 : ℝ) / 6 ≤ 3 := by norm_num ++ exact add_le_add_right this _ ++ ++ have h_nonneg_poly : 0 ≤ |t|^3 + 6 * |t|^2 + 11 * |t| + 5 := by ++ have h0 : 0 ≤ |t|^3 := by exact pow_nonneg (abs_nonneg _) 3 ++ have h1 : 0 ≤ 6 * |t|^2 := by ++ have : 0 ≤ (6 : ℝ) := by norm_num ++ exact mul_nonneg this (sq_nonneg _) ++ have h2 : 0 ≤ 11 * |t| := by ++ have : 0 ≤ (11 : ℝ) := by norm_num ++ exact mul_nonneg this (abs_nonneg _) ++ have h3 : 0 ≤ (5 : ℝ) := by norm_num ++ exact add_nonneg (add_nonneg (add_nonneg h0 h1) h2) h3 ++ have h_add : |t| + 3 ≤ (|t| + 3) + (|t|^3 + 6 * |t|^2 + 11 * |t| + 5) := by ++ simpa using (le_add_of_nonneg_right (a := |t| + 3) h_nonneg_poly) ++ have h_expand : (|t| + 2)^3 = (|t| + 3) + (|t|^3 + 6 * |t|^2 + 11 * |t| + 5) := by ++ ring ++ have h3 : |t| + 3 ≤ (|t| + 2)^3 := by ++ simpa [h_expand] using h_add ++ ++ exact le_trans (le_trans h1a h17le3) h3 ++ ++lemma lem_DlogImlog : ++ ∀ t : ℝ, |t| > 3 → ∀ z ∈ Metric.closedBall (3/2 + t * Complex.I) (5/6), ++ Real.log (|z.im| + 2) ≤ 3 * Real.log (|t| + 2) := by ++ intro t ht z hz ++ ++ have h1 : |z.im| + 2 ≤ (|t| + 2)^3 := lem_DIMt2 t ht z hz ++ ++ have h2 : 0 < |z.im| + 2 := by ++ have : 0 ≤ |z.im| := abs_nonneg _ ++ linarith ++ ++ have hlog := Real.log_le_log h2 h1 ++ ++ simpa [Real.log_pow] using hlog ++ ++lemma lem_D1logtlog : ++ ∀ t : ℝ, |t| > 3 → ∀ z ∈ Metric.closedBall (3/2 + t * Complex.I) (5/6), ++ (1 : ℝ) / Real.log (|t| + 2) ≤ 3 / Real.log (|z.im| + 2) := by ++ intro t ht z hz ++ have h1 := lem_DlogImlog t ht z hz ++ ++ have ht_pos : |t| + 2 > 1 := by linarith [abs_nonneg t] ++ have hz_pos : |z.im| + 2 > 1 := by linarith [abs_nonneg z.im] ++ have log_t_pos : Real.log (|t| + 2) > 0 := Real.log_pos ht_pos ++ have log_z_pos : Real.log (|z.im| + 2) > 0 := Real.log_pos hz_pos ++ ++ rw [div_le_div_iff₀ log_t_pos log_z_pos] ++ simp only [one_mul] ++ exact h1 ++ ++lemma lem_Ddt2dz : ++ ∀ t : ℝ, |t| > 3 → ∀ z ∈ Metric.closedBall (3/2 + t * Complex.I) (5/6), ++ deltaz_t t ≤ 3 * deltaz z := by ++ intro t ht z hz ++ have h := lem_D1logtlog t ht z hz ++ have hpos : 0 ≤ zerofree_constant / 20 := by ++ have ha : 0 < zerofree_constant := zerofree_constant_pos ++ have h9 : 0 < (20 : ℝ) := by norm_num ++ exact div_nonneg (le_of_lt ha) (le_of_lt h9) ++ have h2 := mul_le_mul_of_nonneg_left h hpos ++ calc ++ deltaz_t t ++ = (zerofree_constant / 20) / Real.log (|t| + 2) := by ++ simp [deltaz_t, deltaz] ++ _ = (zerofree_constant / 20) * (1 / Real.log (|t| + 2)) := by simp [div_eq_mul_inv] ++ _ ≤ (zerofree_constant / 20) * (3 / Real.log (|z.im| + 2)) := h2 ++ _ = 3 * ((zerofree_constant / 20) * (1 / Real.log (|z.im| + 2))) := by ++ simp [div_eq_mul_inv, mul_left_comm, mul_assoc] ++ _ = 3 * deltaz z := by simp [deltaz, div_eq_mul_inv, mul_left_comm, mul_assoc] ++ ++lemma lem_deltarhotodeltat (t : ℝ) (ht : |t| > 3) (ρ : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) → deltaz ρ ≥ (1/3) * deltaz_t t := by ++ intro c hρK ++ rcases hρK with ⟨hball, _hzero⟩ ++ have hball' : ρ ∈ Metric.closedBall ((3/2 : ℂ) + t * Complex.I) (5/6) := by ++ simpa [c, mul_comm] using! hball ++ have hmain : deltaz_t t ≤ 3 * deltaz ρ := lem_Ddt2dz t ht ρ hball' ++ have hthird_nonneg : 0 ≤ (1/3 : ℝ) := by norm_num ++ have h_mul : (1/3 : ℝ) * deltaz_t t ≤ (1/3 : ℝ) * (3 * deltaz ρ) := ++ mul_le_mul_of_nonneg_left hmain hthird_nonneg ++ have h_simplify : (1/3 : ℝ) * (3 * deltaz ρ) = deltaz ρ := by ++ ring ++ have : (1/3 : ℝ) * deltaz_t t ≤ deltaz ρ := by ++ simpa [h_simplify] using h_mul ++ simpa [mul_comm] using this ++ ++lemma lem_Rerhotodeltat (t : ℝ) (ht : |t| > 3) (ρ : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) → ρ.re ≤ 1 - 3 * deltaz_t t := by ++ intros c h_rho_in ++ ++ have h1 : ρ.re ≤ 1 - 9 * deltaz ρ := ++ lem_Rerhotodeltarho (ρ := ρ) t ht (by simpa [c, mul_comm] using! h_rho_in) ++ ++ have h2 : deltaz ρ ≥ (1/3) * deltaz_t t := lem_deltarhotodeltat t ht ρ h_rho_in ++ ++ have h3 : 9 * deltaz ρ ≥ 3 * deltaz_t t := by ++ calc ++ 9 * deltaz ρ ++ ≥ 9 * ((1/3) * deltaz_t t) := by ++ exact mul_le_mul_of_nonneg_left h2 (by norm_num : (0 : ℝ) ≤ 9) ++ _ = 9 * (1/3) * deltaz_t t := by ring ++ _ = 3 * deltaz_t t := by norm_num ++ ++ have h4 : 1 - 9 * deltaz ρ ≤ 1 - 3 * deltaz_t t := by ++ linarith [h3] ++ ++ exact le_trans h1 h4 ++ ++lemma lem_RezRerho (t : ℝ) (ht : |t| > 3) (z ρ : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) → ++ 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ z.re - ρ.re ≥ 2 * deltaz_t t := by ++ intro c h_rho_mem h_z ++ ++ have h_rho_bound := lem_Rerhotodeltat t ht ρ h_rho_mem ++ ++ have h_z_lower := h_z.1 ++ ++ linarith [h_z_lower, h_rho_bound] ++ ++lemma lem_abszrhodelta (t : ℝ) (ht : |t| > 3) (z ρ : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) → ++ 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ ‖z - ρ‖ ≥ 2 * deltaz_t t := by ++ intro c h_rho_in_K h_z_conditions ++ ++ have h1 : z.re - ρ.re ≥ 2 * deltaz_t t := (lem_RezRerho t ht z ρ) h_rho_in_K h_z_conditions ++ ++ have h2 : ‖z - ρ‖ ≥ z.re - ρ.re := lem_abszrhoReRe z ρ ++ ++ exact le_trans h1 h2 ++ ++lemma lem_abszrhodeltanot0 (t : ℝ) (ht : |t| > 3) (z ρ : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) → ++ 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ ‖z - ρ‖ > 0 := by ++ intro c hmem hbounds ++ ++ have h1 := lem_abszrhodelta t ht z ρ hmem hbounds ++ ++ have h2 := lem_delta19.2 t (by linarith [ht] : |t| > 2) ++ have h3 : 0 < deltaz_t t := h2.1 ++ ++ have h4 : 0 < 2 * deltaz_t t := by ++ linarith [h3] ++ ++ linarith [h1, h4] ++ ++lemma lem_1abszrho (t : ℝ) (ht : |t| > 3) (z ρ : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) → ++ 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ 1 / ‖z - ρ‖ ≤ 1 / (2 * deltaz_t t) := by ++ intro c hρ hz ++ ++ apply one_div_le_one_div_of_le ++ ++ · have h_delta_pos : 0 < deltaz_t t := by ++ have h_delta19 := lem_delta19 ++ exact (h_delta19.2 t (by linarith [ht] : |t| > 2)).1 ++ linarith [h_delta_pos] ++ ++ · exact lem_abszrhodelta t ht z ρ hρ hz ++ ++lemma lem_m_rho_zeta_nat (t : ℝ) (ht : |t| > 3) (ρ : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) → ∃ n : ℕ, (analyticOrderAt riemannZeta ρ) = n := by ++ intro c hρK ++ classical ++ ++ have ht1 : |t| > 1 := lt_trans (by norm_num) ht ++ ++ have hρ_in_ball1 : ρ ∈ Metric.closedBall c 1 := by ++ have hρ_le : dist ρ c ≤ (5 / 6 : ℝ) := by simpa [Metric.mem_closedBall] using hρK.1 ++ have : dist ρ c ≤ (1 : ℝ) := le_trans hρ_le (by norm_num) ++ simpa [Metric.mem_closedBall] using this ++ ++ have hρ_ne_one : ρ ≠ (1 : ℂ) := (D1cinTt_pre t ht1) ρ hρ_in_ball1 ++ ++ have hζ_analytic_at_ρ : AnalyticAt ℂ riemannZeta ρ := zetaanalOnnot1 ρ hρ_ne_one ++ ++ have h_not_eventually_zero : ¬ (∀ᶠ z in nhds ρ, riemannZeta z = 0) := by ++ by_contra h_ev ++ ++ have h_freq := eventually_eq_zero_implies_frequently_eq_zero_punctured riemannZeta ρ h_ev ++ ++ have h_zero_on_S := ++ zetaanalOnnot1.eqOn_zero_of_preconnected_of_frequently_eq_zero ++ complex_minus_singleton_connected hρ_ne_one h_freq ++ ++ have hc_in_ball1 : c ∈ Metric.closedBall c 1 := by ++ have : dist c c ≤ (1 : ℝ) := by simp [dist_self] ++ simp [Metric.mem_closedBall] ++ have hc_ne_one : c ≠ (1 : ℂ) := (D1cinTt_pre t ht1) c hc_in_ball1 ++ have hc_in_S : c ∈ {s : ℂ | s ≠ 1} := by simpa [Set.mem_ofPred_eq] using hc_ne_one ++ have hζc_zero : riemannZeta c = 0 := h_zero_on_S hc_in_S ++ exact (zetacnot0 t) hζc_zero ++ ++ have hfinite : analyticOrderAt riemannZeta ρ ≠ ⊤ := by ++ intro htop ++ have hiff : analyticOrderAt riemannZeta ρ = ⊤ ↔ ∀ᶠ z in nhds ρ, riemannZeta z = 0 := ++ analyticOrderAt_eq_top (f := riemannZeta) (z₀ := ρ) ++ have : ∀ᶠ z in nhds ρ, riemannZeta z = 0 := hiff.mp htop ++ exact h_not_eventually_zero this ++ ++ refine ⟨(analyticOrderAt riemannZeta ρ).toNat, ?_⟩ ++ simpa using (ENat.natCast_toNat hfinite).symm ++ ++lemma lem_finiteKzeta (t : ℝ) (_ht : |t| > 3) : ++ let c := (3/2 : ℂ) + I * t ++ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite := by ++ intro c ++ have hK : IsCompact (Metric.closedBall c (5 / (6 : ℝ))) := ++ closedBall_compact_complex c (5 / (6 : ℝ)) ++ simpa [zerosetKfRc] using ++ (riemannZeta_zeros_finite_of_compact (Metric.closedBall c (5 / (6 : ℝ))) hK) ++ ++lemma lem_triangle_ZFR (t : ℝ) (_ht : |t| > 3) (z : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ ‖(∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ))‖ ≤ ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖z - ρ‖) := by ++ ++ intros c hfin hz_cond ++ ++ apply le_trans (norm_sum_le _ _) ++ ++ apply Finset.sum_le_sum ++ intro ρ hρ ++ ++ rw [norm_div] ++ ++ rw [Complex.norm_natCast] ++ ++lemma lem_Zeta_Triangle_ZFR : ++ ∃ C_1 : ℝ, C_1 > 1 ∧ ++ ∀ t : ℝ, |t| > 3 → ++ let c := (3/2 : ℂ) + I * t ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ ∀ z : ℂ, 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ ‖deriv riemannZeta z / riemannZeta z‖ ≤ ++ ‖(∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ))‖ + ++ C_1 * Real.log |t| := by ++ obtain ⟨C1, hC1, hbound⟩ := lem_Zeta_Expansion_ZFR ++ refine ⟨C1, hC1, ?_⟩ ++ intro t ht c hfin z hz ++ ++ let S := (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (z - ρ)) ++ have hbound1 := hbound t ht hfin z hz ++ have htri : ‖deriv riemannZeta z / riemannZeta z‖ ≤ ‖(deriv riemannZeta z / riemannZeta z) - S‖ + ‖S‖ := by ++ have hn := norm_add_le ((deriv riemannZeta z / riemannZeta z) - S) S ++ have hrewrite : (deriv riemannZeta z / riemannZeta z) - S + S = (deriv riemannZeta z / riemannZeta z) := by ++ simp [sub_eq_add_neg] ++ simpa [S, hrewrite] using hn ++ have hsum := add_le_add_left hbound1 ‖S‖ ++ have : ‖deriv riemannZeta z / riemannZeta z‖ ≤ C1 * Real.log |t| + ‖S‖ := le_trans htri hsum ++ simpa [S, add_comm] using this ++ ++lemma lem_sumK1abs (t : ℝ) (ht : |t| > 3) (z : ℂ) : ++ let c := (3/2 : ℂ) + I * t ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖z - ρ‖) ≤ ++ (1 / (2 * deltaz_t t)) * (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ)) := by ++ intro c hfin hzcond ++ ++ have hptwise : ∀ ρ ∈ hfin.toFinset, ++ ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖z - ρ‖ ≤ ++ (1 / (2 * deltaz_t t)) * ((analyticOrderAt riemannZeta ρ).toNat : ℝ) := by ++ intro ρ hρmem ++ have hρ_in : ρ ∈ (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta) := ++ (Set.Finite.mem_toFinset (hs := hfin)).1 hρmem ++ have hbase : 1 / ‖z - ρ‖ ≤ 1 / (2 * deltaz_t t) := ++ lem_1abszrho t ht z ρ hρ_in hzcond ++ have hnonneg : 0 ≤ ((analyticOrderAt riemannZeta ρ).toNat : ℝ) := by ++ exact_mod_cast (Nat.zero_le ((analyticOrderAt riemannZeta ρ).toNat)) ++ have := mul_le_mul_of_nonneg_left hbase hnonneg ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using this ++ have hsum := Finset.sum_le_sum hptwise ++ ++ have hrw := ++ (Finset.mul_sum (s := hfin.toFinset) ++ (f := fun ρ => ((analyticOrderAt riemannZeta ρ).toNat : ℝ)) ++ (a := (1 / (2 * deltaz_t t)))) ++ have hsum2 := hsum ++ ++ rw [← hrw] at hsum2 ++ ++ simpa [div_eq_mul_inv] using hsum2 ++ ++lemma helper_analyticOnNhd_shift_div (f : ℂ → ℂ) (c : ℂ) ++ (h : ∀ z ∈ Metric.closedBall c 1, AnalyticAt ℂ f z) ++ (_hc : f c ≠ 0) : ++ AnalyticOnNhd ℂ (fun z => f (z + c) / f c) (Metric.closedBall (0 : ℂ) 1) := by ++ ++ intro z hz ++ ++ have hz_norm : ‖z‖ ≤ 1 := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hz ++ ++ have hz_addc_mem : z + c ∈ Metric.closedBall c 1 := by ++ ++ have : dist (z + c) c ≤ 1 := by ++ simpa [dist_eq_norm, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using hz_norm ++ simpa [Metric.mem_closedBall] using this ++ ++ have h_f_at : AnalyticAt ℂ f (z + c) := h (z + c) hz_addc_mem ++ ++ have h_addc : AnalyticAt ℂ (fun w => w + c) z := by ++ simpa using! (analyticAt_id.add analyticAt_const) ++ ++ have h_comp : AnalyticAt ℂ (fun w => f (w + c)) z := ++ (AnalyticAt.fun_comp h_f_at h_addc) ++ ++ have h_mul_const : AnalyticAt ℂ (fun w => (1 / f c) * f (w + c)) z := ++ (analyticAt_const.mul h_comp) ++ ++ simpa [div_eq_mul_inv, mul_comm] using h_mul_const ++ ++lemma helper_finite_zeros_shift (r : ℝ) (_hr : r > 0) (c : ℂ) (f : ℂ → ℂ) ++ (hc : f c ≠ 0) ++ (_h_analytic : AnalyticOnNhd ℂ f (Metric.closedBall c 1)) ++ (hfin : (zerosetKfRc r c f).Finite) : ++ (zerosetKfRc r (0 : ℂ) (fun z => f (z + c) / f c)).Finite := ++by ++ classical ++ let g : ℂ → ℂ := fun z => f (z + c) / f c ++ have hEq : ++ zerosetKfRc r (0 : ℂ) g = (fun ρ : ℂ => ρ - c) '' zerosetKfRc r c f := by ++ apply Set.Subset.antisymm ++ · intro x hx ++ ++ have hx_ball : dist x (0 : ℂ) ≤ r := by ++ simpa [Metric.mem_closedBall] using hx.1 ++ ++ have hx_ball' : dist (x + c) c ≤ r := by ++ simpa [Complex.dist_eq, add_sub_cancel] using hx_ball ++ ++ have hx_zero : f (x + c) = 0 := by ++ rcases (div_eq_zero_iff).mp (by simpa [g] using hx.2) with hnum | hden ++ · exact hnum ++ · exact (hc hden).elim ++ refine ⟨x + c, ?_, ?_⟩ ++ · exact ⟨by simpa [Metric.mem_closedBall] using hx_ball', hx_zero⟩ ++ · simp ++ · intro x hx ++ rcases hx with ⟨ρ, hρ, rfl⟩ ++ ++ have hρ_ball : dist ρ c ≤ r := by ++ simpa [Metric.mem_closedBall] using hρ.1 ++ refine ⟨?_, ?_⟩ ++ · ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hρ_ball ++ · ++ have : f ρ = 0 := hρ.2 ++ simp [g, sub_add_cancel, this] ++ ++ have himage : ((fun ρ : ℂ => ρ - c) '' zerosetKfRc r c f).Finite := ++ hfin.image (fun ρ : ℂ => ρ - c) ++ simpa [g, hEq] using himage ++ ++lemma helper_bound_shifted (B R : ℝ) (_hB : 1 < B) (_hRpos : 0 < R) (_hRlt1 : R < 1) ++ (c : ℂ) (f : ℂ → ℂ) (hc : f c ≠ 0) ++ (h_bound : ∀ z ∈ Metric.closedBall c R, ‖f z‖ ≤ B) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R, ++ ‖(fun w => f (w + c) / f c) z‖ ≤ B / ‖f c‖ := ++by ++ intro z hz ++ ++ have hz_norm : ‖z‖ ≤ R := by ++ have hz' : dist z (0 : ℂ) ≤ R := by simpa [Metric.mem_closedBall] using hz ++ simpa [Complex.dist_eq] using hz' ++ ++ have hz_ballc : z + c ∈ Metric.closedBall c R := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq, add_sub_cancel] using hz_norm ++ ++ have hfb : ‖f (z + c)‖ ≤ B := h_bound (z + c) hz_ballc ++ ++ have hpos : 0 < ‖f c‖ := (norm_pos_iff).2 hc ++ ++ have hdiv : ‖f (z + c)‖ / ‖f c‖ ≤ B / ‖f c‖ := (div_le_div_iff_of_pos_right hpos).2 hfb ++ ++ have hnorm_eq : ‖(fun w => f (w + c) / f c) z‖ = ‖f (z + c)‖ / ‖f c‖ := by ++ change ‖f (z + c) / f c‖ = ‖f (z + c)‖ / ‖f c‖ ++ simp ++ simpa [hnorm_eq] using hdiv ++ ++lemma helper_g_zero_eq_one (f : ℂ → ℂ) (c : ℂ) (hc : f c ≠ 0) : ++ (fun z => f (z + c) / f c) 0 = 1 := by ++ simp [hc] ++ ++lemma helper_zerosetKfR_eq_center0 (r : ℝ) (hr : r > 0) (f : ℂ → ℂ) : ++ zerosetKfR r hr f = zerosetKfRc r (0 : ℂ) f := by ++ ext ρ; simp [zerosetKfR, zerosetKfRc] ++ ++lemma helper_sum_nonneg_nat (ι : Type*) (s : Finset ι) (f : ι → ℕ) : ++ 0 ≤ ∑ i ∈ s, ((f i : ℝ)) := by ++ classical ++ have h : ∀ i ∈ s, (0 : ℝ) ≤ (f i : ℝ) := by ++ intro i hi ++ exact_mod_cast (Nat.zero_le (f i)) ++ simpa using Finset.sum_nonneg h ++ ++lemma helper_one_le_Bdivfc2 (B R : ℝ) (_hB : 1 < B) (hRpos : 0 < R) (_hRlt1 : R < 1) ++ (f : ℂ → ℂ) (c : ℂ) (hc : f c ≠ 0) ++ (h_bound : ∀ z ∈ Metric.closedBall c R, ‖f z‖ ≤ B) : ++ 1 ≤ B / ‖f c‖ := ++by ++ have hc_in : c ∈ Metric.closedBall c R := by ++ have h0le : (0 : ℝ) ≤ R := le_of_lt hRpos ++ simpa [Metric.mem_closedBall, dist_self] using h0le ++ have hfc_le : ‖f c‖ ≤ B := h_bound c hc_in ++ have hfc_pos : 0 < ‖f c‖ := (norm_pos_iff.mpr hc) ++ have hdiv := (div_le_div_iff_of_pos_right (c := ‖f c‖) hfc_pos).mpr hfc_le ++ simpa [div_self (ne_of_gt hfc_pos)] using hdiv ++ ++lemma helper_sum_over_equal_finite_sets {α : Type*} (S T : Set α) ++ (hS : S.Finite) (hT : T.Finite) (hST : S = T) (φ : α → ℝ) : ++ (∑ x ∈ hS.toFinset, φ x) = (∑ x ∈ hT.toFinset, φ x) := by ++ classical ++ have hfin_eq : hS.toFinset = hT.toFinset := by ++ ext x ++ constructor ++ · intro hx ++ have hxS : x ∈ S := by ++ have hmem : x ∈ hS.toFinset ↔ x ∈ S := by ++ simp ++ exact hmem.mp hx ++ have hxT : x ∈ T := by simpa [hST] using hxS ++ have hmemT : x ∈ hT.toFinset ↔ x ∈ T := by ++ simp ++ exact hmemT.mpr hxT ++ · intro hx ++ have hxT : x ∈ T := by ++ have hmemT : x ∈ hT.toFinset ↔ x ∈ T := by ++ simp ++ exact hmemT.mp hx ++ have hxS : x ∈ S := by simpa [hST] using hxT ++ have hmemS : x ∈ hS.toFinset ↔ x ∈ S := by ++ simp ++ exact hmemS.mpr hxS ++ simp [hfin_eq] ++ ++lemma helper_apply_jensen_to_g ++ (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (g : ℂ → ℂ) ++ (h_g_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ g z) ++ (hg0_ne : g 0 ≠ 0) ++ (hg0_one : g 0 = 1) ++ (hfin_g : (zerosetKfR R1 (by linarith) g).Finite) ++ (hg_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖g z‖ ≤ B) : ++ (∑ ρ ∈ hfin_g.toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) ≤ Real.log B / Real.log (R / R1) := by ++ classical ++ ++ have h_exists : ∀ σ ∈ zerosetKfR R1 (by linarith) g, ++ ∃ hσ : ℂ → ℂ, AnalyticAt ℂ hσ σ ∧ hσ σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, g z = (z - σ) ^ (analyticOrderAt g σ).toNat * hσ z := by ++ intro σ hσ ++ exact lem_analytic_zero_factor R R1 hR1_pos hR1_lt_R hR_lt_1 g h_g_analytic hg0_ne σ hσ ++ ++ let h_σ : ℂ → (ℂ → ℂ) := ++ fun σ => dite (σ ∈ zerosetKfR R1 (by linarith) g) ++ (fun h => Classical.choose (h_exists σ h)) ++ (fun _ => fun _ => (1 : ℂ)) ++ ++ have h_σ_spec : ∀ σ ∈ zerosetKfR R1 (by linarith) g, ++ AnalyticAt ℂ (h_σ σ) σ ∧ (h_σ σ) σ ≠ 0 ∧ ++ ∀ᶠ z in nhds σ, g z = (z - σ) ^ (analyticOrderAt g σ).toNat * (h_σ σ) z := by ++ intro σ hσin ++ have hx := h_exists σ hσin ++ dsimp [h_σ] ++ ++ simpa [hσin] using (Classical.choose_spec hx) ++ ++ have hbound := ++ lem_sum_m_rho_bound B R R1 hB hR1_pos hR1_lt_R hR_lt_1 ++ g h_g_analytic hg0_ne hg0_one hfin_g (h_σ := h_σ) hg_le_B h_σ_spec ++ ++ simpa [one_div, div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using hbound ++ ++lemma helper_sum_f_equals_sum_g ++ (r : ℝ) (hr : r > 0) (c : ℂ) (f : ℂ → ℂ) (hc : f c ≠ 0) ++ (h_analytic : AnalyticOnNhd ℂ f (Metric.closedBall c 1)) ++ (hfin : (zerosetKfRc r c f).Finite) : ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) ++ = ++ (∑ ρ' ∈ ((hfin.image (fun ρ => ρ - c)).toFinset), ++ ((analyticOrderAt (fun z => f (z + c) / f c) ρ').toNat : ℝ)) := ++by ++ classical ++ ++ let S : Finset ℂ := hfin.toFinset ++ let φ : ℂ → ℂ := fun ρ => ρ - c ++ let g' : ℂ → ℂ := fun z => f (z + c) / f c ++ ++ have himg : (φ '' zerosetKfRc r c f).Finite := hfin.image φ ++ have h_img_toFinset : ((hfin.image φ).toFinset) = S.image φ := by ++ simpa [S] using (Set.Finite.toFinset_image (s := (zerosetKfRc r c f)) (f := φ) ++ (hs := hfin) (h := himg)) ++ ++ have h_orders_match : ++ (∑ ρ ∈ S, ((analyticOrderAt f ρ).toNat : ℝ)) = ++ (∑ ρ ∈ S, ((analyticOrderAt g' (φ ρ)).toNat : ℝ)) := by ++ apply Finset.sum_congr rfl ++ intro ρ hρS ++ ++ have hρ_mem : ρ ∈ zerosetKfRc r c f := ++ (Set.Finite.mem_toFinset (hs := hfin)).1 hρS ++ have hρ_ball : ρ ∈ Metric.closedBall c r := hρ_mem.1 ++ have hρ_fzero : f ρ = 0 := hρ_mem.2 ++ ++ have hρ'_ball : (φ ρ) ∈ Metric.closedBall (0 : ℂ) r := by ++ ++ have hdist_le : dist ρ c ≤ r := by ++ simpa [Metric.mem_closedBall] using hρ_ball ++ ++ have : dist (φ ρ) 0 ≤ r := by ++ simpa [φ, dist_eq_norm] using (by simpa [dist_eq_norm] using hdist_le) ++ simpa [Metric.mem_closedBall] using this ++ have hρ'_gzero : g' (φ ρ) = 0 := by ++ simp [g', φ, hρ_fzero, sub_eq_add_neg, add_comm] ++ have hρ'_mem : (φ ρ) ∈ zerosetKfRc r (0 : ℂ) g' := ⟨hρ'_ball, hρ'_gzero⟩ ++ ++ have h_m_eq := fc_m_order r hr c f hc h_analytic (ρ' := φ ρ) hρ'_mem ++ ++ have h_m_eq' : analyticOrderAt g' (φ ρ) = analyticOrderAt f ρ := by ++ simpa [g', φ, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using h_m_eq ++ ++ have h_toNat : (analyticOrderAt g' (φ ρ)).toNat = (analyticOrderAt f ρ).toNat := by ++ simpa using congrArg ENat.toNat h_m_eq' ++ simp [h_toNat] ++ ++ have h_inj : Function.Injective φ := by ++ intro x y hxy ++ ++ have := congrArg (fun z => z + c) hxy ++ simpa [φ, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using this ++ ++ have h_sum_image : ++ (∑ ρ' ∈ S.image φ, ((analyticOrderAt g' ρ').toNat : ℝ)) = ++ (∑ ρ ∈ S, ((analyticOrderAt g' (φ ρ)).toNat : ℝ)) := by ++ refine Finset.sum_image ?h ++ intro x hx y hy hxy ++ ++ exact h_inj hxy ++ ++ calc ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) ++ = (∑ ρ ∈ S, ((analyticOrderAt f ρ).toNat : ℝ)) := by rfl ++ _ = (∑ ρ ∈ S, ((analyticOrderAt g' (φ ρ)).toNat : ℝ)) := h_orders_match ++ _ = (∑ ρ' ∈ S.image φ, ((analyticOrderAt g' ρ').toNat : ℝ)) := h_sum_image.symm ++ _ = (∑ ρ' ∈ ((hfin.image (fun ρ => ρ - c)).toFinset), ++ ((analyticOrderAt (fun z => f (z + c) / f c) ρ').toNat : ℝ)) := by ++ ++ simp [S, φ, g', h_img_toFinset] ++ ++lemma helper_zero_set_shift_eq ++ (r : ℝ) (hr : r > 0) (c : ℂ) (f : ℂ → ℂ) (hc : f c ≠ 0) ++ (h_analytic : AnalyticOnNhd ℂ f (Metric.closedBall c 1)) : ++ zerosetKfRc r (0 : ℂ) (fun z => f (z + c) / f c) ++ = (fun ρ => ρ - c) '' (zerosetKfRc r c f) := by ++ simpa using fc_zeros r hr c f hc h_analytic ++ ++lemma helper_fin_zero_g_is_image ++ (r : ℝ) (hr : r > 0) (c : ℂ) (f : ℂ → ℂ) (hc : f c ≠ 0) ++ (h_analytic : AnalyticOnNhd ℂ f (Metric.closedBall c 1)) ++ (hfin : (zerosetKfRc r c f).Finite) : ++ (zerosetKfRc r (0 : ℂ) (fun z => f (z + c) / f c)).Finite := ++by ++ classical ++ have hset : zerosetKfRc r (0 : ℂ) (fun z => f (z + c) / f c) ++ = (fun ρ => ρ - c) '' (zerosetKfRc r c f) := ++ by simpa using fc_zeros r hr c f hc h_analytic ++ have hfin_img : ((fun ρ => ρ - c) '' (zerosetKfRc r c f)).Finite := hfin.image _ ++ simpa [hset] using hfin_img ++ ++lemma helper_AnalyticOnNhd_to_pointwise {S : Set ℂ} {f : ℂ → ℂ} ++ (h : AnalyticOnNhd ℂ f S) : ∀ z ∈ S, AnalyticAt ℂ f z := by ++ intro z hz ++ exact h z hz ++ ++lemma jensen_sum_bound_strict ++ (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) (hR1_lt_R : R1 < R) (hR_lt_1 : R < 1) ++ (g : ℂ → ℂ) ++ (h_g_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ g z) ++ (hg0_ne : g 0 ≠ 0) ++ (hg0_one : g 0 = 1) ++ (hfin_g : (zerosetKfR R1 (by linarith) g).Finite) ++ (hg_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖g z‖ ≤ B) : ++ (∑ ρ ∈ hfin_g.toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) ≤ ++ Real.log B / Real.log (R / R1) := by ++ exact helper_apply_jensen_to_g B R R1 hB hR1_pos hR1_lt_R hR_lt_1 g ++ h_g_analytic hg0_ne hg0_one hfin_g hg_le_B ++ ++lemma no_zero_of_bound_one_and_center_one ++ (R : ℝ) (hR_lt_1 : R < 1) ++ (g : ℂ → ℂ) ++ (h_g_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ g z) ++ (hg0_one : g 0 = 1) ++ (hg_le_one : ∀ z : ℂ, ‖z‖ ≤ R → ‖g z‖ ≤ 1) : ++ ∀ z ∈ Metric.closedBall (0 : ℂ) R, g z ≠ 0 := by ++ intro z hz ++ by_cases hRpos : 0 < R ++ · ++ ++ have hdiff : DifferentiableOn ℂ g (Metric.ball (0 : ℂ) R) := by ++ intro x hx ++ have hxlt : ‖x‖ < R := by ++ simpa [Metric.mem_ball, Complex.dist_eq] using hx ++ have hxle1 : ‖x‖ ≤ 1 := le_trans (le_of_lt hxlt) (le_of_lt hR_lt_1) ++ have hx_in1 : x ∈ Metric.closedBall (0 : ℂ) 1 := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hxle1 ++ exact ((h_g_analytic x hx_in1).differentiableAt).differentiableWithinAt ++ ++ have hcont : ContinuousOn g (Metric.closedBall (0 : ℂ) R) := by ++ intro x hx ++ have hxleR : ‖x‖ ≤ R := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hx ++ have hxle1 : ‖x‖ ≤ 1 := le_trans hxleR (le_of_lt hR_lt_1) ++ have hx_in1 : x ∈ Metric.closedBall (0 : ℂ) 1 := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hxle1 ++ exact (h_g_analytic x hx_in1).continuousAt.continuousWithinAt ++ have hdcc : DiffContOnCl ℂ g (Metric.ball (0 : ℂ) R) := ++ DiffContOnCl.mk_ball hdiff hcont ++ ++ have hIsMax : IsMaxOn (fun z => ‖g z‖) (Metric.ball (0 : ℂ) R) 0 := by ++ intro y hy ++ have hynormlt : ‖y‖ < R := by ++ simpa [Metric.mem_ball, Complex.dist_eq] using hy ++ have hyle : ‖y‖ ≤ R := le_of_lt hynormlt ++ have hgy : ‖g y‖ ≤ 1 := hg_le_one y hyle ++ simpa [hg0_one] using hgy ++ ++ have hEqOn := ++ Complex.eqOn_closedBall_of_isMaxOn_norm (z := (0 : ℂ)) (r := R) hdcc hIsMax ++ have hz_eq : g z = (fun _ => g 0) z := hEqOn hz ++ have hz_eq1 : g z = g 0 := by simpa using hz_eq ++ have gz_one : g z = 1 := by simpa [hg0_one] using hz_eq1 ++ simp [gz_one] ++ · ++ ++ have hRle : R ≤ 0 := le_of_not_gt hRpos ++ have hz_le : ‖z‖ ≤ R := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hz ++ have hz_norm_eq : ‖z‖ = 0 := ++ le_antisymm (le_trans hz_le hRle) (norm_nonneg z) ++ have hz_zero : z = 0 := by ++ simpa [norm_eq_zero] using hz_norm_eq ++ simp [hz_zero, hg0_one] ++ ++lemma helper_sum_over_equal_finite_sets_orders ++ {S T : Set ℂ} (g : ℂ → ℂ) ++ (hS : S.Finite) (hT : T.Finite) (hST : S = T) : ++ (∑ x ∈ hS.toFinset, ((analyticOrderAt g x).toNat : ℝ)) ++ = (∑ x ∈ hT.toFinset, ((analyticOrderAt g x).toNat : ℝ)) := by ++ classical ++ have hF : hS.toFinset = hT.toFinset := by ++ ext x ++ simp [Set.Finite.mem_toFinset, hST] ++ simp [hF] ++ ++lemma helper_mem_closedBall_zero_iff_norm_le (z : ℂ) (R : ℝ) : ++ z ∈ Metric.closedBall (0 : ℂ) R ↔ ‖z‖ ≤ R := by ++ simp [Metric.mem_closedBall, dist_eq_norm] ++ ++lemma helper_bound_on_ball_to_norm_imp ++ {R : ℝ} {g : ℂ → ℂ} {M : ℝ} ++ (hg : ∀ z ∈ Metric.closedBall (0 : ℂ) R, ‖g z‖ ≤ M) : ++ ∀ z : ℂ, ‖z‖ ≤ R → ‖g z‖ ≤ M := by ++ intro z hz ++ have hz' : z ∈ Metric.closedBall (0 : ℂ) R := by ++ have : dist z (0 : ℂ) ≤ R := by ++ simpa [dist_eq_norm] using hz ++ simpa [Metric.mem_closedBall] using this ++ exact hg z hz' ++ ++lemma helper_pointwise_to_AnalyticOnNhd {S : Set ℂ} {f : ℂ → ℂ} ++ (h : ∀ z ∈ S, AnalyticAt ℂ f z) : AnalyticOnNhd ℂ f S := by ++ simpa using! h ++ ++lemma lem_sum_m_rho_bound_c (B R R1 : ℝ) (hB : 1 < B) ++ (hR1_pos : 0 < R1) ++ (hR1_lt_R : R1 < R) ++ (hR_lt_1 : R < 1) ++ (f : ℂ → ℂ) ++ (c : ℂ) ++ (h_f_analytic : ∀ z ∈ Metric.closedBall c 1, AnalyticAt ℂ f z) ++ (h_f_nonzero_at_zero : f c ≠ 0) ++ (hf_le_B : ∀ z ∈ Metric.closedBall c R, ‖f z‖ ≤ B) ++ (hfin : (zerosetKfRc R1 c f).Finite) : ++ ∑ ρ ∈ hfin.toFinset, ((analyticOrderAt f ρ).toNat : ℝ) ≤ Real.log (B / ‖f c‖) / Real.log (R / R1) := by ++ classical ++ ++ let g : ℂ → ℂ := fun z => f (z + c) / f c ++ ++ have h_g_analyticOn : AnalyticOnNhd ℂ g (Metric.closedBall (0 : ℂ) 1) := ++ helper_analyticOnNhd_shift_div f c h_f_analytic h_f_nonzero_at_zero ++ have h_g_analytic : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, AnalyticAt ℂ g z := ++ helper_AnalyticOnNhd_to_pointwise h_g_analyticOn ++ ++ have hg0_one : g 0 = 1 := helper_g_zero_eq_one f c h_f_nonzero_at_zero ++ have hg0_ne : g 0 ≠ 0 := by simp [hg0_one] ++ ++ have hAnal_f : AnalyticOnNhd ℂ f (Metric.closedBall c 1) := ++ helper_pointwise_to_AnalyticOnNhd h_f_analytic ++ have hfin_g0 : (zerosetKfRc R1 (0 : ℂ) g).Finite := ++ helper_fin_zero_g_is_image R1 hR1_pos c f h_f_nonzero_at_zero hAnal_f hfin ++ have hZR_eq : zerosetKfR R1 hR1_pos g = zerosetKfRc R1 (0 : ℂ) g := ++ helper_zerosetKfR_eq_center0 R1 hR1_pos g ++ have hfin_g : (zerosetKfR R1 (by exact hR1_pos) g).Finite := by ++ simpa [hZR_eq] using hfin_g0 ++ ++ have h_bound_shift : ∀ z ∈ Metric.closedBall (0 : ℂ) R, ‖g z‖ ≤ B / ‖f c‖ := ++ helper_bound_shifted B R hB (by exact lt_trans hR1_pos hR1_lt_R) hR_lt_1 c f ++ h_f_nonzero_at_zero (fun z hz => hf_le_B z <| by simpa using hz) ++ have hg_le_B : ∀ z : ℂ, ‖z‖ ≤ R → ‖g z‖ ≤ B / ‖f c‖ := ++ helper_bound_on_ball_to_norm_imp (R := R) (g := g) (M := B / ‖f c‖) h_bound_shift ++ ++ have hfc_le : ‖f c‖ ≤ B := by ++ have : c ∈ Metric.closedBall c R := by ++ have hRpos' : 0 ≤ R := le_of_lt (lt_trans hR1_pos hR1_lt_R) ++ have : dist c c ≤ R := by simpa [dist_self] using hRpos' ++ simpa [Metric.mem_closedBall] using this ++ exact hf_le_B c this ++ have hfc_pos : 0 < ‖f c‖ := (norm_pos_iff).2 h_f_nonzero_at_zero ++ have hBdiv_ge_one : 1 ≤ B / ‖f c‖ := by ++ have hdiv := (div_le_div_iff_of_pos_right hfc_pos).mpr hfc_le ++ simpa [div_self (ne_of_gt hfc_pos)] using hdiv ++ ++ have hsum_fg_eq : ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) ++ = (∑ ρ' ∈ ((hfin.image (fun ρ => ρ - c)).toFinset), ++ ((analyticOrderAt g ρ').toNat : ℝ)) := ++ helper_sum_f_equals_sum_g (r := R1) (hr := hR1_pos) (c := c) ++ (f := f) (hc := h_f_nonzero_at_zero) (h_analytic := hAnal_f) (hfin := hfin) ++ ++ have hST_g_img : zerosetKfR R1 hR1_pos g ++ = (fun ρ => ρ - c) '' (zerosetKfRc R1 c f) := by ++ have h1 : zerosetKfR R1 hR1_pos g = zerosetKfRc R1 (0 : ℂ) g := ++ helper_zerosetKfR_eq_center0 R1 hR1_pos g ++ have h2 : zerosetKfRc R1 (0 : ℂ) g ++ = (fun ρ => ρ - c) '' (zerosetKfRc R1 c f) := ++ helper_zero_set_shift_eq R1 hR1_pos c f h_f_nonzero_at_zero hAnal_f ++ simpa [h1] using h2 ++ ++ rcases lt_or_eq_of_le hBdiv_ge_one with hBdiv_gt_one | hBdiv_eq_one ++ · ++ have hsum_g_bound := ++ jensen_sum_bound_strict (B := B / ‖f c‖) (R := R) (R1 := R1) ++ (hB := hBdiv_gt_one) ++ (hR1_pos := hR1_pos) (hR1_lt_R := hR1_lt_R) (hR_lt_1 := hR_lt_1) ++ (g := g) (h_g_analytic := h_g_analytic) (hg0_ne := hg0_ne) ++ (hg0_one := hg0_one) (hfin_g := hfin_g) (hg_le_B := hg_le_B) ++ ++ have hsum_g_reindex : ++ (∑ ρ ∈ hfin_g.toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) ++ = (∑ ρ ∈ (hfin.image (fun ρ => ρ - c)).toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) := ++ helper_sum_over_equal_finite_sets_orders (g := g) ++ (S := zerosetKfR R1 hR1_pos g) ++ (T := (fun ρ => ρ - c) '' (zerosetKfRc R1 c f)) ++ (hS := hfin_g) (hT := hfin.image (fun ρ => ρ - c)) (hST := hST_g_img) ++ ++ have : ++ (∑ ρ ∈ (hfin.image (fun ρ => ρ - c)).toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) ++ ≤ Real.log (B / ‖f c‖) / Real.log (R / R1) := by ++ simpa [hsum_g_reindex] using hsum_g_bound ++ ++ simpa [hsum_fg_eq] using this ++ · ++ have hBdiv_eq_one' : B / ‖f c‖ = 1 := by ++ simpa [eq_comm] using hBdiv_eq_one ++ have hg_le_one : ∀ z : ℂ, ‖z‖ ≤ R → ‖g z‖ ≤ 1 := by ++ intro z hz ++ have := hg_le_B z hz ++ simpa [hBdiv_eq_one'] using this ++ have g_nonzero_on_ball : ∀ z ∈ Metric.closedBall (0 : ℂ) R, g z ≠ 0 := ++ no_zero_of_bound_one_and_center_one R hR_lt_1 g h_g_analytic hg0_one hg_le_one ++ ++ have hS_empty : zerosetKfR R1 hR1_pos g = (∅ : Set ℂ) := by ++ ext z; constructor ++ · intro hz ++ rcases hz with ⟨hzball, hzzero⟩ ++ have hzR1 : ‖z‖ ≤ R1 := by simpa [Metric.mem_closedBall, dist_eq_norm] using hzball ++ have hzR : ‖z‖ ≤ R := le_trans hzR1 (le_of_lt hR1_lt_R) ++ have hzR' : z ∈ Metric.closedBall (0 : ℂ) R := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hzR ++ exact (g_nonzero_on_ball z hzR') hzzero ++ · intro hzfalse ++ cases hzfalse ++ have hsum_g_zero : ++ (∑ ρ ∈ hfin_g.toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) = 0 := by ++ have h := ++ helper_sum_over_equal_finite_sets_orders (g := g) ++ (S := zerosetKfR R1 hR1_pos g) (T := (∅ : Set ℂ)) ++ (hS := hfin_g) (hT := Set.finite_empty) (hST := hS_empty) ++ simpa using h ++ ++ have hsum_reindex := ++ helper_sum_over_equal_finite_sets_orders (g := g) ++ (S := zerosetKfR R1 hR1_pos g) ++ (T := (fun ρ => ρ - c) '' (zerosetKfRc R1 c f)) ++ (hS := hfin_g) (hT := hfin.image (fun ρ => ρ - c)) (hST := hST_g_img) ++ have hsum_img_eq : ++ (∑ ρ ∈ (hfin.image (fun ρ => ρ - c)).toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) ++ = (∑ ρ ∈ hfin_g.toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) := by ++ simpa using hsum_reindex.symm ++ have hsum_img_zero : ++ (∑ ρ ∈ (hfin.image (fun ρ => ρ - c)).toFinset, ((analyticOrderAt g ρ).toNat : ℝ)) = 0 := by ++ simp [hsum_img_eq, hsum_g_zero] ++ ++ have hsum_f_zero : ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) = 0 := by ++ simpa [hsum_img_zero] using hsum_fg_eq ++ ++ have hRHS_zero : Real.log (B / ‖f c‖) / Real.log (R / R1) = 0 := by ++ simp [hBdiv_eq_one'] ++ ++ have : ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt f ρ).toNat : ℝ)) ++ ≤ Real.log (B / ‖f c‖) / Real.log (R / R1) := by ++ simp [hsum_f_zero, hRHS_zero] ++ exact this ++ ++lemma lem_sum_m_rho_zeta : ++ ∃ C_2 > 1, ∀ (t : ℝ) (_ht : |t| > 3), ++ let c := (3/2 : ℂ) + I * t; ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ ∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) ≤ C_2 * Real.log |t| := by ++ classical ++ ++ obtain ⟨b, hb_gt1, hb_bound⟩ := zeta32upper ++ obtain ⟨a, ha_pos, ha_bound⟩ := zeta_low_332 ++ ++ let R1 : ℝ := 5 / 6 ++ let R : ℝ := 8 / 9 ++ let logRatio : ℝ := Real.log (R / R1) ++ ++ let u : ℝ := Real.log (b / a) ++ let C2 : ℝ := max 2 ((1 + |u|) / logRatio) ++ have hC2_gt_one : 1 < C2 := by ++ have htwo_lt : (1 : ℝ) < 2 := by norm_num ++ have hle : (2 : ℝ) ≤ C2 := by ++ have := le_max_left (2 : ℝ) ((1 + |u|) / logRatio) ++ simp [C2] ++ exact lt_of_lt_of_le htwo_lt hle ++ refine ⟨C2, hC2_gt_one, ?_⟩ ++ intro t ht c hfin ++ ++ have hR1_pos : 0 < R1 := by dsimp [R1]; norm_num ++ have hR1_lt_R : R1 < R := by dsimp [R1, R]; norm_num ++ have hR_lt_1 : R < 1 := by dsimp [R]; norm_num ++ have hR_le_one : R ≤ (1 : ℝ) := by dsimp [R]; norm_num ++ ++ have ht1 : |t| > 1 := lt_trans (by norm_num) ht ++ have h_f_analytic : ∀ z ∈ Metric.closedBall c 1, AnalyticAt ℂ riemannZeta z := by ++ intro z hz ++ have hz_ne_one : z ≠ (1 : ℂ) := (D1cinTt_pre t ht1) z (by simpa [c] using hz) ++ exact zetaanalOnnot1 z hz_ne_one ++ ++ have h_nonzero : riemannZeta c ≠ 0 := by simpa [c] using zetacnot0 t ++ ++ have ht2 : |t| > 2 := by linarith ++ have h_upper_on_ball1 : ∀ z ∈ Metric.closedBall c 1, ‖riemannZeta z‖ < b * |t| := by ++ have h := hb_bound t ht2 ++ intro z hz; simpa [c] using h z (by simpa [c] using hz) ++ have hf_le_B : ∀ z ∈ Metric.closedBall c R, ‖riemannZeta z‖ ≤ b * |t| := by ++ intro z hz ++ have hz1 : z ∈ Metric.closedBall c 1 := ++ (Metric.closedBall_subset_closedBall hR_le_one) hz ++ exact le_of_lt (h_upper_on_ball1 z hz1) ++ ++ have hb_pos : 0 < b := lt_trans (by norm_num) hb_gt1 ++ have htabove1 : (1 : ℝ) ≤ |t| := le_of_lt ht1 ++ have hb_le_B : b ≤ b * |t| := by ++ have := mul_le_mul_of_nonneg_left htabove1 (le_of_lt hb_pos) ++ simpa [one_mul] using this ++ have hBpos : 1 < b * |t| := lt_of_lt_of_le hb_gt1 hb_le_B ++ ++ have h_sum_bound := ++ lem_sum_m_rho_bound_c (B := b * |t|) (R := R) (R1 := R1) ++ (hB := hBpos) ++ (hR1_pos := hR1_pos) ++ (hR1_lt_R := hR1_lt_R) ++ (hR_lt_1 := hR_lt_1) ++ (f := riemannZeta) (c := c) ++ (h_f_analytic := h_f_analytic) ++ (h_f_nonzero_at_zero := h_nonzero) ++ (hf_le_B := hf_le_B) ++ (hfin := hfin) ++ ++ have hlogRatio_pos : 0 < logRatio := by ++ have : 1 < R / R1 := by dsimp [R, R1]; norm_num ++ exact Real.log_pos this ++ ++ have h_zeta_ge_a : a ≤ ‖riemannZeta c‖ := by ++ simpa [c, mul_comm] using! ha_bound t ++ ++ have ht_abs_pos : 0 < |t| := lt_trans (by norm_num) ht ++ have hζ_norm_pos : 0 < ‖riemannZeta c‖ := norm_pos_iff.mpr h_nonzero ++ have hb_ne : (b : ℝ) ≠ 0 := ne_of_gt hb_pos ++ have ht_abs_ne : (|t| : ℝ) ≠ 0 := ne_of_gt ht_abs_pos ++ have ha_ne : a ≠ 0 := ne_of_gt ha_pos ++ have hlog_split1 : ++ Real.log ((b * |t|) / ‖riemannZeta c‖) ++ = (Real.log b + Real.log |t|) - Real.log ‖riemannZeta c‖ := by ++ have : Real.log (b * |t|) = Real.log b + Real.log |t| := ++ Real.log_mul hb_ne ht_abs_ne ++ have : ++ Real.log ((b * |t|) / ‖riemannZeta c‖) ++ = Real.log (b * |t|) - Real.log ‖riemannZeta c‖ := ++ Real.log_div (by exact mul_ne_zero hb_ne ht_abs_ne) (ne_of_gt hζ_norm_pos) ++ simp [this, Real.log_mul hb_ne ht_abs_ne] ++ have hlog_div_eq : Real.log (b / a) = Real.log b - Real.log a := ++ Real.log_div hb_ne ha_ne ++ have hlog_a_le : Real.log a ≤ Real.log ‖riemannZeta c‖ := ++ Real.log_le_log (by exact ha_pos) (by exact h_zeta_ge_a) ++ have hneg : -(Real.log ‖riemannZeta c‖) ≤ -Real.log a := by ++ simpa using (neg_le_neg hlog_a_le) ++ have hRHS_le_const : ++ Real.log ((b * |t|) / ‖riemannZeta c‖) ++ ≤ Real.log |t| + Real.log (b / a) := by ++ ++ have : ++ (Real.log b + Real.log |t|) - Real.log ‖riemannZeta c‖ ++ ≤ (Real.log b + Real.log |t|) - Real.log a := by ++ simpa [sub_eq_add_neg] using! add_le_add_right hneg (Real.log b + Real.log |t|) ++ simpa [hlog_split1, sub_eq_add_neg, add_comm, add_left_comm, add_assoc, hlog_div_eq] ++ using this ++ ++ have hRHS1 : ++ Real.log ((b * |t|) / ‖riemannZeta c‖) / logRatio ++ ≤ (Real.log |t| + Real.log (b / a)) / logRatio := by ++ exact div_le_div_of_nonneg_right hRHS_le_const (le_of_lt hlogRatio_pos) ++ ++ have hlogt_ge_one : (1 : ℝ) ≤ Real.log |t| := by ++ ++ have h3le : (3 : ℝ) ≤ |t| := le_of_lt ht ++ have hlog3_le : Real.log 3 ≤ Real.log |t| := Real.log_le_log (by norm_num) h3le ++ have h_exp_le : Real.exp (1 : ℝ) ≤ 3 := le_of_lt lem_three_gt_e ++ have hlog3_ge_one : (1 : ℝ) ≤ Real.log 3 := ++ (Real.le_log_iff_exp_le (by norm_num : 0 < (3 : ℝ))).mpr h_exp_le ++ exact le_trans hlog3_ge_one hlog3_le ++ have hadd_le : Real.log |t| + Real.log (b / a) ≤ (1 + |u|) * Real.log |t| := by ++ have haux1 : Real.log (b / a) ≤ |u| := by simpa [u] using le_abs_self (Real.log (b / a)) ++ have haux2 : |u| ≤ |u| * Real.log |t| := by ++ have hnonneg : 0 ≤ |u| := abs_nonneg _ ++ have h1le : (1 : ℝ) ≤ Real.log |t| := hlogt_ge_one ++ simpa [one_mul] using (mul_le_mul_of_nonneg_left h1le hnonneg) ++ calc ++ Real.log |t| + Real.log (b / a) ++ ≤ Real.log |t| + |u| := by exact add_le_add_right haux1 _ ++ _ ≤ Real.log |t| + (|u| * Real.log |t|) := by exact add_le_add_right haux2 _ ++ _ = (1 + |u|) * Real.log |t| := by ring ++ have hRHS2 : ++ (Real.log |t| + Real.log (b / a)) / logRatio ++ ≤ ((1 + |u|) / logRatio) * Real.log |t| := by ++ have := div_le_div_of_nonneg_right hadd_le (le_of_lt hlogRatio_pos) ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using this ++ have hfinal : ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ)) ++ ≤ ((1 + |u|) / logRatio) * Real.log |t| := by ++ have := le_trans h_sum_bound hRHS1 ++ exact le_trans this hRHS2 ++ ++ have hC2_ge : ((1 + |u|) / logRatio) ≤ C2 := by ++ have := le_max_right (2 : ℝ) ((1 + |u|) / logRatio) ++ simp [C2] ++ have hlogt_nonneg : 0 ≤ Real.log |t| := le_trans (by norm_num) hlogt_ge_one ++ have hscale := mul_le_mul_of_nonneg_right hC2_ge hlogt_nonneg ++ exact le_trans hfinal hscale ++ ++lemma lem_sumKdeltatlogt : ++ ∃ C_3 > 1, ∀ (t : ℝ) (_ht : |t| > 3), ++ let c := (3/2 : ℂ) + I * t; ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ ∀ z : ℂ, 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖z - ρ‖) ≤ ++ (C_3 / (deltaz_t t)) * Real.log |t| := by ++ ++ obtain ⟨C_2, hC_2_pos, hC_2_bound⟩ := lem_sum_m_rho_zeta ++ ++ use C_2 ++ ++ constructor ++ · ++ exact hC_2_pos ++ ++ · ++ intro t ht c hfin z hz ++ ++ have h1 := lem_sumK1abs t ht z hfin hz ++ ++ have h2 := hC_2_bound t ht hfin ++ ++ have ht2 : |t| > 2 := by linarith [ht] ++ have h_delta_pos : 0 < deltaz_t t := (lem_delta19.2 t ht2).1 ++ ++ have h_t_ge_one : (1 : ℝ) ≤ |t| := by linarith [ht] ++ ++ calc ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖z - ρ‖) ++ ≤ (1 / (2 * deltaz_t t)) * (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ)) := h1 ++ _ ≤ (1 / (2 * deltaz_t t)) * (C_2 * Real.log |t|) := by ++ apply mul_le_mul_of_nonneg_left h2 ++ apply div_nonneg (by norm_num) ++ apply mul_nonneg (by norm_num) (le_of_lt h_delta_pos) ++ _ = (C_2 / (2 * deltaz_t t)) * Real.log |t| := by ring ++ _ ≤ (C_2 / deltaz_t t) * Real.log |t| := by ++ apply mul_le_mul_of_nonneg_right _ (Real.log_nonneg h_t_ge_one) ++ ++ apply div_le_div_of_nonneg_left (le_of_lt (lt_trans zero_lt_one hC_2_pos)) ++ · exact h_delta_pos ++ · ++ calc deltaz_t t ++ = 1 * deltaz_t t := by rw [one_mul] ++ _ ≤ 2 * deltaz_t t := by ++ apply mul_le_mul_of_nonneg_right (by norm_num : (1 : ℝ) ≤ 2) (le_of_lt h_delta_pos) ++ ++lemma lem_sumKlogt2 : ++ ∃ C_4 > 1, ∀ (t : ℝ) (_ht : |t| > 3), ++ let c := (3/2 : ℂ) + I * t ++ ∀ (hfin : (zerosetKfRc (5 / (6 : ℝ)) c riemannZeta).Finite), ++ ∀ z : ℂ, 1 - deltaz_t t ≤ z.re ∧ z.re ≤ 3/2 ∧ z.im = t → ++ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖z - ρ‖) ≤ ++ C_4 * Real.log |t|^2 := by ++ ++ obtain ⟨C_3, hC_3_gt, hC_3⟩ := lem_sumKdeltatlogt ++ ++ use max (100 * C_3 / zerofree_constant) 2 ++ ++ constructor ++ · exact lt_max_of_lt_right (by norm_num : (2 : ℝ) > 1) ++ ++ · intro t ht c hfin z hz ++ ++ have h_bound := hC_3 t ht hfin z hz ++ ++ have h_t_pos : 0 < |t| := by linarith [ht, abs_nonneg t] ++ have h_log_t_pos : 0 < Real.log |t| := Real.log_pos (by linarith [ht] : (1 : ℝ) < |t|) ++ have hC_3_pos : 0 < C_3 := lt_trans zero_lt_one hC_3_gt ++ have h_zerofree_pos : 0 < zerofree_constant := zerofree_constant_pos ++ ++ have h_log_bound : Real.log (|t| + 2) ≤ 2 * Real.log |t| := by ++ have h_ineq : |t| + 2 ≤ 2 * |t| := by linarith [ht] ++ have h_log_ineq := Real.log_le_log (by linarith [abs_nonneg t] : 0 < |t| + 2) h_ineq ++ rw [Real.log_mul (by norm_num) (ne_of_gt h_t_pos)] at h_log_ineq ++ have h_log2_bound : Real.log 2 ≤ Real.log |t| := ++ Real.log_le_log (by norm_num) (by linarith [ht] : (2 : ℝ) ≤ |t|) ++ linarith [h_log_ineq] ++ ++ have h_deltaz_eq : deltaz_t t = (zerofree_constant / 20) / Real.log (|t| + 2) := by ++ simp [deltaz_t, deltaz] ++ ++ have h_main_bound : C_3 / deltaz_t t * Real.log |t| ≤ ++ 40 * C_3 / zerofree_constant * (Real.log |t|)^2 := by ++ ++ rw [h_deltaz_eq] ++ ++ have h_div_rewrite : C_3 / ((zerofree_constant / 20) / Real.log (|t| + 2)) = ++ C_3 * Real.log (|t| + 2) * 20 / zerofree_constant := by ++ field_simp [ne_of_gt h_zerofree_pos, ne_of_gt (Real.log_pos (by linarith [abs_nonneg t] : (1 : ℝ) < |t| + 2))] ++ ++ rw [h_div_rewrite] ++ ++ have h_pos_factor : 0 ≤ C_3 * 20 / zerofree_constant := ++ div_nonneg (mul_nonneg (le_of_lt hC_3_pos) (by norm_num)) (le_of_lt h_zerofree_pos) ++ ++ calc C_3 * Real.log (|t| + 2) * 20 / zerofree_constant * Real.log |t| ++ = C_3 * 20 / zerofree_constant * Real.log (|t| + 2) * Real.log |t| := by ring ++ _ ≤ C_3 * 20 / zerofree_constant * (2 * Real.log |t|) * Real.log |t| := by ++ exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left h_log_bound h_pos_factor) ++ (le_of_lt h_log_t_pos) ++ _ = 40 * C_3 / zerofree_constant * (Real.log |t|)^2 := by simp [pow_two]; ring ++ ++ calc (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖z - ρ‖) ++ ≤ C_3 / deltaz_t t * Real.log |t| := h_bound ++ _ ≤ 40 * C_3 / zerofree_constant * (Real.log |t|)^2 := h_main_bound ++ _ ≤ max (100 * C_3 / zerofree_constant) 2 * (Real.log |t|)^2 := by ++ have h_factor_bound : 40 * C_3 / zerofree_constant ≤ max (100 * C_3 / zerofree_constant) 2 := by ++ have h_coeff_ineq : 40 * C_3 ≤ 100 * C_3 := by ++ ++ have h_coeff : (40 : ℝ) ≤ 100 := by norm_num ++ exact mul_le_mul_of_nonneg_right h_coeff (le_of_lt hC_3_pos) ++ have h_div_ineq : 40 * C_3 / zerofree_constant ≤ 100 * C_3 / zerofree_constant := by ++ ++ exact div_le_div_of_nonneg_right h_coeff_ineq (le_of_lt h_zerofree_pos) ++ exact le_trans h_div_ineq (le_max_left _ _) ++ exact mul_le_mul_of_nonneg_right h_factor_bound (sq_nonneg _) ++ ++lemma lem_logDerivZetalogt0 : ++ ∃ C > 1, ++ ∀ (t : ℝ) (_ht : |t| > 3), ++ ∀ s : ℂ, (1 - deltaz_t t) ≤ s.re ∧ s.re ≤ 3/2 ∧ s.im = t → ++ ‖deriv riemannZeta s / riemannZeta s‖ ≤ C * Real.log |t|^2 := by ++ ++ obtain ⟨C_1, hC_1_gt, hC_1⟩ := lem_Zeta_Triangle_ZFR ++ obtain ⟨C_4, hC_4_gt, hC_4⟩ := lem_sumKlogt2 ++ ++ use C_1 + C_4 ++ ++ constructor ++ · ++ linarith [hC_1_gt, hC_4_gt] ++ ++ · ++ intro t ht s hs ++ ++ let c := (3/2 : ℂ) + I * t ++ have hfin := lem_finiteKzeta t ht ++ ++ have h_triangle := hC_1 t ht hfin s hs ++ ++ have h_triangle_ineq := lem_triangle_ZFR t ht s hfin hs ++ ++ have h_sum_bound := hC_4 t ht hfin s hs ++ ++ have h_log_sq_ge : Real.log |t| ≤ Real.log |t|^2 := by ++ have h_log_ge_one : (1 : ℝ) ≤ Real.log |t| := by ++ ++ have h_t_gt_e : Real.exp 1 < |t| := by ++ have h_e_bound : Real.exp 1 < 3 := by ++ ++ simpa using lem_three_gt_e ++ linarith [ht] ++ ++ have h_t_pos : 0 < |t| := by linarith [ht, abs_nonneg t] ++ rw [← Real.log_exp 1] ++ exact Real.log_le_log (Real.exp_pos 1) (le_of_lt h_t_gt_e) ++ have h_log_pos : 0 < Real.log |t| := Real.log_pos (by linarith [ht] : (1 : ℝ) < |t|) ++ rw [pow_two] ++ exact le_mul_of_one_le_right (le_of_lt h_log_pos) h_log_ge_one ++ ++ calc ‖deriv riemannZeta s / riemannZeta s‖ ++ ≤ ‖(∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℂ) / (s - ρ))‖ + C_1 * Real.log |t| := h_triangle ++ _ ≤ (∑ ρ ∈ hfin.toFinset, ((analyticOrderAt riemannZeta ρ).toNat : ℝ) / ‖s - ρ‖) + C_1 * Real.log |t| := by ++ apply add_le_add_left h_triangle_ineq ++ _ ≤ C_4 * Real.log |t|^2 + C_1 * Real.log |t| := by ++ apply add_le_add_left h_sum_bound ++ _ ≤ C_4 * Real.log |t|^2 + C_1 * Real.log |t|^2 := by ++ ++ have h_c1_nonneg : 0 ≤ C_1 := le_of_lt (lt_trans zero_lt_one hC_1_gt) ++ exact add_le_add_right (mul_le_mul_of_nonneg_left h_log_sq_ge h_c1_nonneg) _ ++ _ = (C_4 + C_1) * Real.log |t|^2 := by ring ++ _ = (C_1 + C_4) * Real.log |t|^2 := by ring ++ ++lemma lem_logDerivZetalogt2 : ++ ∃ A: ℝ, A > 0 ∧ A < 1 ∧ ++ ∃ C > 1, ++ ∀ (t : ℝ) (_ht : |t| > 3), ++ ∀ s : ℂ, (1 - A / Real.log (abs t + 2) ≤ s.re ∧ s.re ≤ 3/2 ∧ s.im = t) → ++ ‖deriv riemannZeta s / riemannZeta s‖ ≤ C * Real.log |t|^2 := by ++ obtain ⟨C, hC_gt, hC_bound⟩ := lem_logDerivZetalogt0 ++ refine ⟨zerofree_constant / 20, ?Apos, ?Alt1, ⟨C, hC_gt, ?_⟩⟩ ++ · ++ exact div_pos zerofree_constant_pos (by norm_num) ++ · ++ have hlt : zerofree_constant / 20 < (1 : ℝ) / 20 := ++ div_lt_div_of_pos_right zerofree_constant_lt_one (by norm_num) ++ have : (1 : ℝ) / 20 < 1 := by norm_num ++ exact lt_trans hlt this ++ · ++ intro t ht s hs ++ have hδ : 1 - deltaz_t t ≤ s.re ∧ s.re ≤ 3/2 ∧ s.im = t := by ++ simpa [deltaz_t, deltaz, Complex.mul_I_im] using hs ++ exact hC_bound t ht s hδ ++ ++lemma lem_rhoDRe4 : ++ ∀ t : ℝ, ∀ z ∈ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t), ++ z.re > 1 - 4 * deltaz_t t := by ++ intro t z hz ++ ++ have h_pos : 0 < deltaz_t t := by ++ ++ have h_log_pos : 0 < Real.log (|t| + 2) := by ++ have h1 : (1 : ℝ) < |t| + 2 := by ++ have : (0 : ℝ) ≤ |t| := abs_nonneg _ ++ linarith ++ exact Real.log_pos h1 ++ have h_num_pos : 0 < zerofree_constant / 20 := by ++ have h20 : 0 < (20 : ℝ) := by norm_num ++ exact div_pos zerofree_constant_pos h20 ++ have : 0 < (zerofree_constant / 20) / Real.log (|t| + 2) := by ++ exact div_pos h_num_pos h_log_pos ++ simpa [deltaz_t, deltaz, Complex.mul_I_im] using this ++ ++ have h_norm : ‖z - (1 - deltaz_t t + t * Complex.I)‖ ≤ 2 * deltaz_t t := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hz ++ ++ have re_bound : |(z - (1 - deltaz_t t + t * Complex.I)).re| ≤ 2 * deltaz_t t := ++ (Complex.abs_re_le_norm _).trans h_norm ++ ++ have center_re : (1 - deltaz_t t + t * Complex.I).re = 1 - deltaz_t t := by ++ calc (1 - deltaz_t t + t * Complex.I).re ++ = (1 - deltaz_t t : ℂ).re + (t * Complex.I).re := by rw [Complex.add_re] ++ _ = (1 - deltaz_t t) + (t * Complex.I).re := by simp [Complex.ofReal_re] ++ _ = (1 - deltaz_t t) + 0 := by simp [Complex.mul_re, Complex.I_re] ++ _ = 1 - deltaz_t t := by simp ++ ++ have re_simp : (z - (1 - deltaz_t t + t * Complex.I)).re = z.re - (1 - deltaz_t t) := by ++ rw [Complex.sub_re, center_re] ++ ++ have re_bound' : |z.re - (1 - deltaz_t t)| ≤ 2 * deltaz_t t := by ++ simpa [re_simp] using re_bound ++ ++ have lower_bound : z.re - (1 - deltaz_t t) ≥ -(2 * deltaz_t t) := by ++ have h := (abs_le).1 re_bound' ++ exact h.1 ++ ++ have : z.re ≥ 1 - deltaz_t t - 2 * deltaz_t t := by linarith [lower_bound] ++ have : z.re ≥ 1 - 3 * deltaz_t t := by linarith ++ linarith [h_pos] ++ ++lemma helper_absIm_le_add_smallball (t : ℝ) (z : ℂ) ++ (hz : z ∈ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t)) : ++ |z.im| ≤ |t| + 2 * deltaz_t t := by ++ ++ have hnorm : ‖z - (1 - deltaz_t t + t * Complex.I)‖ ≤ 2 * deltaz_t t := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hz ++ ++ have h_im_diff : |(z - (1 - deltaz_t t + t * Complex.I)).im| ≤ 2 * deltaz_t t := ++ le_trans (Complex.abs_im_le_norm _) hnorm ++ ++ have center_im : (1 - deltaz_t t + t * Complex.I).im = t := by ++ simp [Complex.add_im, Complex.mul_im] ++ ++ have diff_im : (z - (1 - deltaz_t t + t * Complex.I)).im = z.im - t := by ++ simp [Complex.sub_im, center_im] ++ ++ have h_im_sub : |z.im - t| ≤ 2 * deltaz_t t := by ++ simpa [diff_im] using h_im_diff ++ ++ have tri : |z.im| ≤ |z.im - t| + |t| := by ++ simpa [sub_eq_add_neg] using! (abs_add_le (z.im - t) t) ++ ++ have : |z.im - t| + |t| ≤ 2 * deltaz_t t + |t| := add_le_add_left h_im_sub _ ++ have hfinal : |z.im| ≤ 2 * deltaz_t t + |t| := le_trans tri this ++ simpa [add_comm] using hfinal ++ ++lemma helper_log_le_two_log_smallball (t : ℝ) (ht : |t| > 3) (z : ℂ) ++ (hz : z ∈ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t)) : ++ Real.log (|z.im| + 2) ≤ 2 * Real.log (|t| + 2) := by ++ ++ have h_abs : |z.im| ≤ |t| + 2 * deltaz_t t := ++ helper_absIm_le_add_smallball t z hz ++ ++ set a : ℝ := |t| + 2 ++ have h1 : |z.im| + 2 ≤ a + 2 * deltaz_t t := by ++ have := add_le_add_left h_abs (2 : ℝ) ++ simpa [a, add_comm, add_left_comm, add_assoc] using this ++ ++ have ht2 : |t| > 2 := by linarith ++ have hδ : 0 < deltaz_t t ∧ deltaz_t t < 1 / 9 := (lem_delta19).2 t ht2 ++ have hδlt : deltaz_t t < 1 / 9 := hδ.2 ++ ++ have h_two_delta_le_one : 2 * deltaz_t t ≤ 1 := by ++ have hle : deltaz_t t ≤ 1 / 9 := le_of_lt hδlt ++ have hmul : 2 * deltaz_t t ≤ 2 * (1 / 9 : ℝ) := ++ mul_le_mul_of_nonneg_left hle (by norm_num) ++ have : 2 * (1 / 9 : ℝ) ≤ 1 := by norm_num ++ exact le_trans hmul this ++ have h2 : a + 2 * deltaz_t t ≤ a + 1 := add_le_add_right h_two_delta_le_one a ++ ++ have ha_ge_two : (2 : ℝ) ≤ a := by ++ have : 0 ≤ |t| := abs_nonneg t ++ linarith [this] ++ have ha_ge_one : (1 : ℝ) ≤ a := le_trans (by norm_num) ha_ge_two ++ have h_a_plus_one_le_two_a : a + 1 ≤ a + a := by ++ simpa using add_le_add_right ha_ge_one a ++ have h_nonneg_a : 0 ≤ a := le_trans (by norm_num) ha_ge_two ++ have h_2a_le_a2 : (2 : ℝ) * a ≤ a ^ 2 := by ++ have : (2 : ℝ) * a ≤ a * a := mul_le_mul_of_nonneg_right ha_ge_two h_nonneg_a ++ simpa [pow_two] using this ++ have h_a1_le_a2 : a + 1 ≤ a ^ 2 := ++ le_trans h_a_plus_one_le_two_a (by simpa [two_mul] using h_2a_le_a2) ++ ++ have h_total : |z.im| + 2 ≤ a ^ 2 := le_trans (le_trans h1 h2) h_a1_le_a2 ++ ++ have hxpos : 0 < |z.im| + 2 := by ++ have : 0 ≤ |z.im| := abs_nonneg _ ++ linarith ++ have hlog := Real.log_le_log hxpos h_total ++ calc ++ Real.log (|z.im| + 2) ≤ Real.log (a ^ 2) := hlog ++ _ = (2 : ℝ) * Real.log a := by simp ++ _ = 2 * Real.log (|t| + 2) := by simp [a] ++ ++lemma helper_one_div_log_le_two_div_smallball (t : ℝ) (ht : |t| > 3) (z : ℂ) ++ (hz : z ∈ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t)) : ++ (1 : ℝ) / Real.log (|t| + 2) ≤ 2 / Real.log (|z.im| + 2) := by ++ ++ have ht_pos1 : 1 < |t| + 2 := by linarith [abs_nonneg t] ++ have hz_pos1 : 1 < |z.im| + 2 := by linarith [abs_nonneg z.im] ++ have log_t_pos : 0 < Real.log (|t| + 2) := Real.log_pos ht_pos1 ++ have log_z_pos : 0 < Real.log (|z.im| + 2) := Real.log_pos hz_pos1 ++ ++ have h_norm : ‖z - (1 - deltaz_t t + t * Complex.I)‖ ≤ 2 * deltaz_t t := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hz ++ have center_im : (1 - deltaz_t t + t * Complex.I).im = t := by ++ simp [Complex.add_im] ++ have diff_im : (z - (1 - deltaz_t t + t * Complex.I)).im = z.im - t := by ++ simp [Complex.sub_im, center_im] ++ have h1 : |z.im - t| ≤ ‖z - (1 - deltaz_t t + t * Complex.I)‖ := by ++ simpa [diff_im] using Complex.abs_im_le_norm (z - (1 - deltaz_t t + t * Complex.I)) ++ have h2 : |z.im - t| ≤ 2 * deltaz_t t := h1.trans h_norm ++ have hz_im_le : |z.im| ≤ |z.im - t| + |t| := by ++ ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using! abs_add_le (z.im - t) t ++ have hz_im_le2 : |z.im| ≤ 2 * deltaz_t t + |t| := hz_im_le.trans (add_le_add_left h2 _) ++ have hz_add2_le1 : |z.im| + 2 ≤ (2 * deltaz_t t + |t|) + 2 := add_le_add_left hz_im_le2 2 ++ ++ have hdelta_lt_one : deltaz_t t < 1 := by ++ have hlt19 : deltaz_t t < 1 / 9 := ++ ((lem_delta19).2 t (by linarith : |t| > 2)).2 ++ exact lt_trans hlt19 (by norm_num) ++ have h2delta_le_two : 2 * deltaz_t t ≤ 2 := by ++ have hle : deltaz_t t ≤ 1 := le_of_lt hdelta_lt_one ++ have := mul_le_mul_of_nonneg_left hle (by norm_num : (0 : ℝ) ≤ 2) ++ simpa using this ++ have htwo_le : (2 : ℝ) ≤ |t| + 2 := by linarith [abs_nonneg t] ++ have h2delta_le_tplus2 : 2 * deltaz_t t ≤ |t| + 2 := le_trans h2delta_le_two htwo_le ++ have step_mid : (2 * deltaz_t t + |t|) + 2 ≤ ((|t| + 2) + |t|) + 2 := by ++ have := add_le_add_left (add_le_add_left h2delta_le_tplus2 |t|) 2 ++ simpa [add_comm, add_left_comm, add_assoc] using this ++ have hz_plus2_le : |z.im| + 2 ≤ (|t| + 2) + |t| + 2 := le_trans hz_add2_le1 step_mid ++ have hz_im_bound_final : |z.im| + 2 ≤ 2 * (|t| + 2) := by ++ ++ simpa [two_mul, add_comm, add_left_comm, add_assoc] using hz_plus2_le ++ ++ have hxpos : 0 < |z.im| + 2 := by linarith [abs_nonneg z.im] ++ have hlog_step : Real.log (|z.im| + 2) ≤ Real.log (2 * (|t| + 2)) := ++ Real.log_le_log hxpos hz_im_bound_final ++ have hlog_mul : Real.log (2 * (|t| + 2)) = Real.log 2 + Real.log (|t| + 2) := by ++ have hneet : (|t| + 2) ≠ 0 := ne_of_gt (lt_trans (by norm_num) ht_pos1) ++ simpa using Real.log_mul (by norm_num : (2 : ℝ) ≠ 0) hneet ++ have hlog2_le_logt : Real.log 2 ≤ Real.log (|t| + 2) := by ++ have h2lt : 0 < (2 : ℝ) := by norm_num ++ have h2le : (2 : ℝ) ≤ |t| + 2 := by linarith [abs_nonneg t] ++ exact Real.log_le_log h2lt h2le ++ have hlog_le_two : Real.log (|z.im| + 2) ≤ 2 * Real.log (|t| + 2) := by ++ have : Real.log (|z.im| + 2) ≤ Real.log 2 + Real.log (|t| + 2) := by ++ simpa [hlog_mul] using hlog_step ++ have : Real.log (|z.im| + 2) ≤ Real.log (|t| + 2) + Real.log (|t| + 2) := ++ this.trans (add_le_add_left hlog2_le_logt _) ++ simpa [two_mul] using this ++ ++ have h' : 1 * Real.log (|z.im| + 2) ≤ 2 * Real.log (|t| + 2) := by ++ simpa [one_mul] using hlog_le_two ++ simpa [one_mul] using (div_le_div_iff₀ log_t_pos log_z_pos).mpr h' ++ ++lemma helper_deltaz_t_le_two_deltaz_smallball (t : ℝ) (ht : |t| > 3) (z : ℂ) ++ (hz : z ∈ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t)) : ++ deltaz_t t ≤ 2 * deltaz z := by ++ ++ have h_recip := helper_one_div_log_le_two_div_smallball t ht z hz ++ ++ have hpos_const : 0 ≤ zerofree_constant / 20 := by ++ have hpos : 0 < zerofree_constant := zerofree_constant_pos ++ have h20 : 0 < (20 : ℝ) := by norm_num ++ exact div_nonneg (le_of_lt hpos) (le_of_lt h20) ++ ++ have h_mul := mul_le_mul_of_nonneg_left h_recip hpos_const ++ ++ calc ++ deltaz_t t ++ = (zerofree_constant / 20) / Real.log (|t| + 2) := by ++ simp [deltaz_t, deltaz] ++ _ = (zerofree_constant / 20) * (1 / Real.log (|t| + 2)) := by ++ simp [div_eq_mul_inv] ++ _ ≤ (zerofree_constant / 20) * (2 / Real.log (|z.im| + 2)) := by ++ simpa [one_div, div_eq_mul_inv] using h_mul ++ _ = 2 * ((zerofree_constant / 20) * (1 / Real.log (|z.im| + 2))) := by ++ ring ++ _ = 2 * deltaz z := by ++ simp [deltaz, div_eq_mul_inv] ++ ++lemma lem_DRez6dz : ++ ∀ t : ℝ, |t| > 3 → ∀ z ∈ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t), ++ z.re ≥ 1 - 6 * deltaz z := by ++ intro t ht z hz ++ ++ have h_ball : ‖z - (1 - deltaz_t t + t * Complex.I)‖ ≤ 2 * deltaz_t t := by ++ simpa [Metric.mem_closedBall, Complex.dist_eq] using hz ++ ++ have h_re_absle : |(z - (1 - deltaz_t t + t * Complex.I)).re| ≤ 2 * deltaz_t t := ++ (Complex.abs_re_le_norm _).trans h_ball ++ have h_re_absle' : |z.re - (1 - deltaz_t t)| ≤ 2 * deltaz_t t := by ++ simpa [Complex.sub_re] using h_re_absle ++ ++ have h_lower : z.re - (1 - deltaz_t t) ≥ -(2 * deltaz_t t) := by ++ have := (abs_le).1 h_re_absle' ++ exact this.1 ++ ++ have h3 : z.re ≥ 1 - 3 * deltaz_t t := by ++ linarith ++ ++ have h_dt_le : deltaz_t t ≤ 2 * deltaz z := ++ helper_deltaz_t_le_two_deltaz_smallball t ht z hz ++ ++ have h_mult : 3 * deltaz_t t ≤ 6 * deltaz z := by ++ have h := mul_le_mul_of_nonneg_left h_dt_le (by norm_num : (0 : ℝ) ≤ 3) ++ calc ++ 3 * deltaz_t t ≤ 3 * (2 * deltaz z) := h ++ _ = 6 * deltaz z := by ring ++ ++ have h_final : 1 - 3 * deltaz_t t ≥ 1 - 6 * deltaz z := by ++ linarith [h_mult] ++ ++ exact le_trans h_final h3 ++ ++lemma lem_YinD : ++ ∀ t : ℝ, |t| > 3 → ++ Yt t (deltaz_t t) ⊆ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t) := by ++ intro t ht z hz ++ rcases hz with ⟨hzero, habs⟩ ++ have hdist : dist z (1 - deltaz_t t + t * Complex.I) ≤ 2 * deltaz_t t := by ++ simpa [Complex.dist_eq] using habs ++ exact Metric.mem_closedBall.mpr hdist ++ ++theorem lem_rhoYzero (t : ℝ) (δ : ℝ) (ρ_1 : ℂ) (h_rho_1_in_Yt : ρ_1 ∈ Yt t δ) : ++ riemannZeta ρ_1 = 0 := by ++ ++ unfold Yt at h_rho_1_in_Yt ++ ++ exact h_rho_1_in_Yt.1 ++ ++theorem lem_absReabs (w : ℂ) : |w.re| ≤ ‖w‖ := by ++ exact Complex.abs_re_le_norm w ++ ++theorem lem_zRe (t : ℝ) (δ : ℝ) (z : ℂ) : |(z - (1 - δ + t * Complex.I)).re| ≤ ‖(z - (1 - δ + t * Complex.I))‖ := by ++ apply lem_absReabs ++ ++theorem lem_zRe2 (t : ℝ) (δ : ℝ) (z : ℂ) ++ (h_le : ‖(z - (1 - δ + t * Complex.I))‖ ≤ 2 * δ) : ++ |(z - (1 - δ + t * Complex.I)).re| ≤ 2 * δ := by ++ have h1 : |(z - (1 - δ + t * Complex.I)).re| ≤ ‖(z - (1 - δ + t * Complex.I))‖ := lem_zRe t δ z ++ exact le_trans h1 h_le ++ ++theorem lem_Rezit (t : ℝ) (δ : ℝ) (z : ℂ) : ++ (z - (1 - δ + t * Complex.I)).re = z.re - (1 - δ) := by ++ rw [Complex.sub_re] ++ ++ rw [Complex.add_re] ++ ++ rw [Complex.sub_re, Complex.one_re, Complex.ofReal_re] ++ ++ rw [Complex.mul_re, Complex.I_re, Complex.I_im, Complex.ofReal_im] ++ ++ simp ++ ++theorem lem_zRe3 (t : ℝ) (δ : ℝ) (z : ℂ) ++ (h_le : ‖(z - (1 - δ + t * Complex.I))‖ ≤ 2 * δ) : ++ |z.re - (1 - δ)| ≤ 2 * δ := by ++ ++ have h1 : |(z - (1 - δ + t * Complex.I)).re| ≤ 2 * δ := ++ lem_zRe2 t δ z h_le ++ ++ have hRe : (z - (1 - δ + t * Complex.I)).re = z.re - (1 - δ) := ++ lem_Rezit t δ z ++ simpa [hRe] using h1 ++ ++theorem lem_negleabs (a : ℝ) (b : ℝ) (h_abs : |a| ≤ b) : a ≥ -b := by ++ rw [abs_le] at h_abs ++ exact h_abs.1 ++ ++theorem lem_absrez1d (δ : ℝ) (z : ℂ) ++ (h_le : |z.re - (1 - δ)| ≤ 2 * δ) : ++ z.re - (1 - δ) ≥ - (2 * δ) := by ++ exact lem_negleabs (z.re - (1 - δ)) (2 * δ) h_le ++ ++theorem lem_absrez1d2 (δ : ℝ) (z : ℂ) ++ (h_le : |z.re - (1 - δ)| ≤ 2 * δ) : ++ z.re ≥ 1 - 3 * δ := by ++ ++ have hneg : z.re - (1 - δ) ≥ - (2 * δ) := ++ lem_absrez1d δ z h_le ++ ++ have : z.re ≥ 1 - δ - 2 * δ := by linarith ++ ++ convert this using 1 ++ ring ++theorem lem_absrez1d3 (δ : ℝ) (z : ℂ) (hδ : δ > 0) ++ (h_le : |z.re - (1 - δ)| ≤ 2 * δ) : ++ z.re > 1 - 4 * δ := by ++ have h1 : z.re ≥ 1 - 3 * δ := lem_absrez1d2 δ z h_le ++ linarith [h1, hδ] ++ ++theorem lem_zRe4 (t : ℝ) (δ : ℝ) (hδ : δ > 0) (z : ℂ) ++ (h_le : ‖(z - (1 - δ + t * Complex.I))‖ ≤ 2 * δ) : ++ z.re > 1 - 4 * δ := by ++ have h1 : |z.re - (1 - δ)| ≤ 2 * δ := lem_zRe3 t δ z h_le ++ exact lem_absrez1d3 δ z hδ h1 ++ ++lemma riemannZeta_no_zeros_left_halfplane_off_real_axis (s : ℂ) (h_re : s.re ≤ 0) (h_im : s.im ≠ 0) : riemannZeta s ≠ 0 := by ++ ++ intro h_zero ++ ++ have hs_not_neg_nat : ∀ n : ℕ, s ≠ -n := by ++ intro n h_eq ++ ++ have : s.im = 0 := by ++ rw [h_eq] ++ rw [Complex.neg_im] ++ simp ++ exact h_im this ++ ++ have hs_not_one : s ≠ 1 := by ++ intro h_eq ++ ++ have : s.re = 1 := by ++ rw [h_eq] ++ exact Complex.one_re ++ linarith [h_re, this] ++ ++ have functional_eq := riemannZeta_one_sub hs_not_neg_nat hs_not_one ++ ++ rw [h_zero] at functional_eq ++ simp at functional_eq ++ ++ have h1s_re_ge_1 : (1 - s).re ≥ 1 := by ++ rw [Complex.sub_re, Complex.one_re] ++ linarith [h_re] ++ ++ have h1s_nonzero : riemannZeta (1 - s) ≠ 0 := by ++ apply riemannZeta_ne_zero_of_one_le_re ++ exact h1s_re_ge_1 ++ ++ exact h1s_nonzero functional_eq ++ ++lemma lem_Imzit (t : ℝ) (δ : ℝ) (z : ℂ) : ++ (z - (1 - δ + t * Complex.I)).im = z.im - t := by ++ have him : (1 - δ + t * Complex.I).im = t := by ++ simp [Complex.add_im, Complex.mul_im] ++ simp [Complex.sub_im, him] ++ ++lemma lem_zIm2 (t : ℝ) (δ : ℝ) (z : ℂ) ++ (h_le : ‖(z - (1 - δ + t * Complex.I))‖ ≤ 2 * δ) : ++ |(z - (1 - δ + t * Complex.I)).im| ≤ 2 * δ := by ++ have : |(z - (1 - δ + t * Complex.I)).im| ≤ ‖(z - (1 - δ + t * Complex.I))‖ := ++ Complex.abs_im_le_norm (z - (1 - δ + t * Complex.I)) ++ exact le_trans this h_le ++ ++lemma lem_zIm3 (t : ℝ) (δ : ℝ) (z : ℂ) ++ (h_le : ‖(z - (1 - δ + t * Complex.I))‖ ≤ 2 * δ) : ++ |z.im - t| ≤ 2 * δ := by ++ have h1 : |(z - (1 - δ + t * Complex.I)).im| ≤ 2 * δ := ++ lem_zIm2 t δ z h_le ++ have him : (z - (1 - δ + t * Complex.I)).im = z.im - t := ++ lem_Imzit t δ z ++ simpa [him] using h1 ++ ++lemma abs_le_add_of_abs_sub_le {a b ε : ℝ} (h : |a - b| ≤ ε) : ++ |a| ≤ |b| + ε := by ++ calc ++ |a| = |b + (a - b)| := by ++ simp [sub_eq_add_neg, add_left_comm] ++ _ ≤ |b| + |a - b| := by ++ simpa [sub_eq_add_neg] using! abs_add_le b (a - b) ++ _ ≤ |b| + ε := by ++ exact add_le_add_right h _ ++ ++lemma log_add_lt_log_add_div {x y : ℝ} (hx : 0 < x) (hy : 0 < y) : ++ Real.log (x + y) < Real.log x + y / x := by ++ have hxne : x ≠ 0 := ne_of_gt hx ++ have hxy_pos : 0 < x + y := add_pos hx hy ++ have hxy_ne : x + y ≠ 0 := ne_of_gt hxy_pos ++ have hy_div_pos : 0 < y / x := div_pos hy hx ++ have hdiv_eq : (x + y) / x = 1 + y / x := by ++ have : (x + y) / x = x / x + y / x := by simp [add_div] ++ simpa [div_self hxne] using this ++ have hgt1 : 1 < (x + y) / x := by ++ have : 1 < 1 + y / x := by linarith [hy_div_pos] ++ simpa [hdiv_eq] using this ++ have hposu : 0 < (x + y) / x := lt_trans zero_lt_one hgt1 ++ have hne1 : (x + y) / x ≠ 1 := ne_of_gt hgt1 ++ have hloglt : Real.log ((x + y) / x) < (x + y) / x - 1 := ++ Real.log_lt_sub_one_of_pos hposu hne1 ++ have hrhs : (x + y) / x - 1 = y / x := by ++ have : (1 + y / x) - 1 = y / x := by ++ simp ++ simp [hdiv_eq] ++ have hldiv : Real.log ((x + y) / x) = Real.log (x + y) - Real.log x := ++ Real.log_div hxy_ne hxne ++ have hcore : Real.log (x + y) - Real.log x < y / x := by ++ simpa [hldiv, hrhs] using hloglt ++ have := add_lt_add_left hcore (Real.log x) ++ simpa [sub_add_cancel, add_comm, add_left_comm, add_assoc] using this ++ ++lemma abs_le_add_of_abs_sub_le' {a b ε : ℝ} (h : |a - b| ≤ ε) : ++ |a| ≤ |b| + ε := by ++ calc ++ |a| = |b + (a - b)| := by ++ simp [sub_eq_add_neg, add_left_comm] ++ _ ≤ |b| + |a - b| := by ++ simpa [sub_eq_add_neg] using! abs_add_le b (a - b) ++ _ ≤ |b| + ε := by ++ exact add_le_add_right h _ ++ ++lemma delta_half_eq (c t : ℝ) : ++ ((c / 2) / Real.log (|t| + 2)) / 2 = (c / 4) / Real.log (|t| + 2) := by ++ ++ have hx : ++ ((c * (1 / 2)) * ((Real.log (|t| + 2))⁻¹)) * (1 / 2) ++ = (c * (1 / 4)) * ((Real.log (|t| + 2))⁻¹) := by ++ ring ++ simpa [div_eq_mul_inv] using hx ++ ++lemma log_abs_im_le (t t1 δ : ℝ) (h : |t1 - t| ≤ δ) : ++ Real.log (|t1| + 2) ≤ Real.log (|t| + 2) + δ / (|t| + 2) := by ++ ++ have hx1pos : 0 < |t1| + 2 := by ++ have : (0 : ℝ) ≤ |t1| := abs_nonneg t1 ++ linarith ++ have hxpos : 0 < |t| + 2 := by ++ have : (0 : ℝ) ≤ |t| := abs_nonneg t ++ linarith ++ have hxnonneg : 0 ≤ |t| + 2 := le_of_lt hxpos ++ ++ have habs : |t1| ≤ |t| + |t1 - t| := by ++ have htri : |(t1 - t) + t| ≤ |t1 - t| + |t| := abs_add_le (t1 - t) t ++ simpa [sub_add_cancel, add_comm] using htri ++ ++ have hxy : |t1| + 2 ≤ (|t| + 2) + |t1 - t| := by ++ have := add_le_add_left habs 2 ++ simpa [add_comm, add_left_comm, add_assoc] using this ++ ++ have hlog1 : Real.log (|t1| + 2) ≤ Real.log ((|t| + 2) + |t1 - t|) := ++ Real.log_le_log hx1pos hxy ++ ++ have hy_nonneg : 0 ≤ |t1 - t| := abs_nonneg (t1 - t) ++ have hlog2 : Real.log ((|t| + 2) + |t1 - t|) ++ ≤ Real.log (|t| + 2) + |t1 - t| / (|t| + 2) := by ++ by_cases hpos : 0 < |t1 - t| ++ · exact le_of_lt (log_add_lt_log_add_div hxpos hpos) ++ · have heq : |t1 - t| = 0 := le_antisymm (le_of_not_gt hpos) hy_nonneg ++ have : Real.log (|t| + 2) ≤ Real.log (|t| + 2) := le_rfl ++ simp [heq] ++ ++ have hdiv : |t1 - t| / (|t| + 2) ≤ δ / (|t| + 2) := ++ div_le_div_of_nonneg_right h hxnonneg ++ have hadd := add_le_add_right hdiv (Real.log (|t| + 2)) ++ exact le_trans (le_trans hlog1 hlog2) hadd ++ ++lemma combine_re_bounds_to_c_over_log_le {ρre c δ L1 : ℝ} ++ (h_ge : ρre ≥ 1 - (3 / 2) * δ) (h_le : ρre ≤ 1 - c / L1) : ++ c / L1 ≤ (3 / 2) * δ := by ++ ++ have h : 1 - (3 / 2) * δ ≤ 1 - c / L1 := le_trans h_ge h_le ++ ++ have h' := sub_le_sub_right h (1 : ℝ) ++ ++ have h'' : -((3 / 2) * δ) ≤ -(c / L1) := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using h' ++ ++ simpa using (neg_le_neg_iff.mp h'') ++ ++lemma core_contradiction2 {L t c δ : ℝ} ++ (hLpos : 0 < L) (hpos : 0 < |t| + 2) ++ (hδ : δ = (c / 2) / L) ++ (h : L ≤ (3 / 2) * δ / (|t| + 2)) : ++ L ^ 2 * (|t| + 2) ≤ 3 * c / 4 := by ++ ++ have h1' := (mul_le_mul_of_nonneg_right h (le_of_lt hpos)) ++ ++ have hbne : (|t| + 2) ≠ 0 := ne_of_gt hpos ++ have rhs_eq : ((3 / 2) * δ / (|t| + 2)) * (|t| + 2) = (3 / 2) * δ := by ++ calc ++ ((3 / 2) * δ / (|t| + 2)) * (|t| + 2) ++ = ((3 / 2) * δ) * ((1 / (|t| + 2)) * (|t| + 2)) := by ++ simp [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] ++ _ = ((3 / 2) * δ) * 1 := by ++ simp [hbne] ++ _ = (3 / 2) * δ := by ++ ring ++ have h1 : L * (|t| + 2) ≤ (3 / 2) * δ := by ++ simpa [rhs_eq] using h1' ++ ++ have h2 := (mul_le_mul_of_nonneg_left h1 (le_of_lt hLpos)) ++ have h3 : L ^ 2 * (|t| + 2) ≤ (3 / 2) * (δ * L) := by ++ simpa [pow_two, mul_left_comm, mul_assoc, mul_comm] using h2 ++ ++ have hLne : L ≠ 0 := ne_of_gt hLpos ++ have hδL : δ * L = c / 2 := by ++ calc ++ δ * L = ((c / 2) / L) * L := by simp [hδ] ++ _ = (c / 2) * ((L⁻¹) * L) := by ++ simp [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] ++ _ = (c / 2) * 1 := by ++ simp [hLne] ++ _ = c / 2 := by simp ++ have h4 : L ^ 2 * (|t| + 2) ≤ (3 / 2) * (c / 2) := by ++ simpa [hδL] using h3 ++ ++ have h5 : (3 / 2 : ℝ) * (c / 2) = 3 * c / 4 := by ++ ring ++ simpa [h5] using h4 ++ ++lemma abs_lower_bound_sub (x y : ℝ) : |x| ≥ |y| - |x - y| := by ++ ++ have h' : |y| ≤ |x| + |y - x| := by ++ have htriv : |y - x| ≤ |y - x| := le_rfl ++ simpa [sub_eq_add_neg] using ++ (abs_le_add_of_abs_sub_le' (a := y) (b := x) (ε := |y - x|) htriv) ++ ++ have h1 : |y| ≤ |x| + |x - y| := by simpa [abs_sub_comm] using h' ++ ++ simpa [ge_iff_le] using (sub_le_iff_le_add).2 h1 ++ ++lemma abs_im_ge_T0_from_close {t : ℝ} {ρ : ℂ} {δ T0 : ℝ} ++ (hclose : |ρ.im - t| ≤ 2 * δ) (hineq : |t| - 2 * δ ≥ T0) : ++ T0 ≤ |ρ.im| := by ++ have h1 : |ρ.im| ≥ |t| - |ρ.im - t| := by ++ simpa [sub_eq_add_neg, abs_sub_comm] using (abs_lower_bound_sub ρ.im t) ++ have : |ρ.im| ≥ |t| - 2 * δ := by ++ exact ge_trans h1 (by ++ ++ gcongr) ++ exact le_trans hineq this ++ ++lemma lem_Kzetaempty : ++ ∀ t : ℝ, |t| > 3 → ++ Yt t (deltaz_t t) = ∅ := by ++ intro t ht ++ ++ rw [Set.eq_empty_iff_forall_notMem] ++ intro ρ_1 h_mem ++ ++ have h_zero : riemannZeta ρ_1 = 0 := lem_rhoYzero t (deltaz_t t) ρ_1 h_mem ++ ++ have h_norm : ‖ρ_1 - (1 - deltaz_t t + t * Complex.I)‖ ≤ 2 * deltaz_t t := by ++ exact h_mem.2 ++ ++ have h_im_bound : |ρ_1.im - t| ≤ 2 * deltaz_t t := by ++ exact lem_zIm3 t (deltaz_t t) ρ_1 h_norm ++ ++ have h_delta_small : deltaz_t t < 1/9 := by ++ have h_bounds := lem_delta19 ++ exact (h_bounds.2 t (by linarith [ht])).2 ++ ++ have h_im_large : 2 < |ρ_1.im| := by ++ ++ have h_tri : |ρ_1.im| ≥ |t| - |ρ_1.im - t| := by ++ exact abs_lower_bound_sub ρ_1.im t ++ have h_bound : |ρ_1.im| ≥ |t| - 2 * deltaz_t t := by ++ exact ge_trans h_tri (by gcongr) ++ have h_small_delta : 2 * deltaz_t t < 2/9 := by ++ linarith [h_delta_small] ++ have h_final : |t| - 2 * deltaz_t t > 3 - 2/9 := by ++ linarith [ht, h_small_delta] ++ have h_gt_2 : 3 - 2/9 > 2 := by norm_num ++ linarith [h_bound, h_final, h_gt_2] ++ ++ have h_in_ball : ρ_1 ∈ Metric.closedBall (1 - deltaz_t t + t * Complex.I) (2 * deltaz_t t) := by ++ exact Metric.mem_closedBall.mpr (by simpa only [dist_eq_norm] using! h_norm) ++ ++ have h_re_bound : ρ_1.re ≥ 1 - 6 * deltaz ρ_1 := by ++ exact lem_DRez6dz t ht ρ_1 h_in_ball ++ ++ have h_delta_pos : 0 < deltaz ρ_1 := by ++ have h_bounds := lem_delta19 ++ exact (h_bounds.1 ρ_1 (by linarith [h_im_large])).1 ++ ++ have h_re_strict : ρ_1.re > 1 - 9 * deltaz ρ_1 := by ++ linarith [h_re_bound, h_delta_pos] ++ ++ have h_nonzero : riemannZeta ρ_1 ≠ 0 := by ++ exact lem_ZFRdelta ρ_1 h_im_large h_re_strict ++ ++ exact h_nonzero h_zero ++ ++lemma Yt_subset_closedBall (t : ℝ) (δ : ℝ) : ++ Yt t δ ⊆ Metric.closedBall (1 - δ + t * Complex.I) (2 * δ) := by ++ ++ intro ρ_1 hρ_1 ++ ++ unfold Yt at hρ_1 ++ ++ obtain ⟨_, h_abs⟩ := hρ_1 ++ ++ rw [Metric.mem_closedBall] ++ ++ rw [Complex.dist_eq] ++ ++ exact h_abs ++ ++lemma Yt_finite (t : ℝ) (δ : ℝ) : (Yt t δ).Finite := by ++ ++ have h_subset := Yt_subset_closedBall t δ ++ ++ let K := Metric.closedBall (1 - δ + t * Complex.I) (2 * δ) ++ have h_compact : IsCompact K := closedBall_compact_complex (1 - δ + t * Complex.I) (2 * δ) ++ ++ have h_zeros_finite := riemannZeta_zeros_finite_of_compact K h_compact ++ ++ have h_sub : Yt t δ ⊆ {z ∈ K | riemannZeta z = 0} := by ++ intro ρ hρ ++ ++ constructor ++ · ++ exact h_subset hρ ++ · ++ unfold Yt at hρ ++ exact hρ.1 ++ ++ exact Set.Finite.subset h_zeros_finite h_sub ++ ++lemma lem_sumempty (g : ℂ → ℂ) : (∑ s ∈ (∅ : Finset ℂ), g s) = 0 := by ++ rfl ++ ++lemma lem_Ksumempty : ++ ∀ t : ℝ, |t| > 3 → ++ (∑ ρ_1 ∈ (Yt_finite t (deltaz_t t)).toFinset, ((analyticOrderAt riemannZeta ρ_1).toNat : ℂ) / (1 - (deltaz_t t) + t * Complex.I - ρ_1)) = 0 := by ++ intro t ht ++ ++ have h_empty : Yt t (deltaz_t t) = ∅ := lem_Kzetaempty t ht ++ ++ have h_finset_empty : (Yt_finite t (deltaz_t t)).toFinset = ∅ := by ++ rw [Set.Finite.toFinset_eq_empty] ++ exact h_empty ++ ++ rw [h_finset_empty] ++ exact lem_sumempty _ ++ ++lemma norm_div_cast_vonMangoldt (s : ℂ) : ++ (fun n : ℕ => ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ s)‖) ++ = (fun n : ℕ => (|ArithmeticFunction.vonMangoldt n|) / ‖(n : ℂ) ^ s‖) := by ++ funext n ++ simp [Complex.norm_real, Real.norm_eq_abs] ++ ++lemma ArithmeticFunction.summable_vonMangoldt_norm_rw {s : ℂ} : ++ Summable (fun n : ℕ => ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ s)‖) ++ ↔ Summable (fun n : ℕ => (|ArithmeticFunction.vonMangoldt n|) / ‖(n : ℂ) ^ s‖) := by ++ classical ++ have hfun : ++ (fun n : ℕ => ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ s)‖) ++ = (fun n : ℕ => (|ArithmeticFunction.vonMangoldt n|) / ‖(n : ℂ) ^ s‖) := by ++ funext n ++ simp [Complex.norm_real, div_eq_mul_inv] ++ simp ++ ++lemma lem_norm_cpow_nat (n : ℕ) (s : ℂ) (hn : 1 ≤ n) : ‖(n : ℂ) ^ s‖ = (n : ℝ) ^ s.re := by ++ have hpos : 0 < (n : ℝ) := ++ lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (by exact_mod_cast hn) ++ simpa using (Complex.norm_cpow_eq_rpow_re_of_pos (x := (n : ℝ)) hpos s) ++ ++lemma lem_vonMangoldt_nonneg (n : ℕ) : 0 ≤ (ArithmeticFunction.vonMangoldt n) := by ++ simp ++ ++lemma lem_term_real_nonneg (n : ℕ) (σ : ℝ) (_hσ : 1 < σ) : ∃ r ≥ (0:ℝ), ((ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))) = (r : ℂ) := by ++ ++ let r : ℝ := (ArithmeticFunction.vonMangoldt n) / ((n : ℝ) ^ σ) ++ refine ⟨r, ?_, ?_⟩ ++ · ++ have hbase_nonneg : 0 ≤ (n : ℝ) := by exact_mod_cast (Nat.zero_le n) ++ have hden_nonneg : 0 ≤ (n : ℝ) ^ σ := by ++ simpa using (Real.rpow_nonneg hbase_nonneg σ) ++ ++ have hv_nonneg : 0 ≤ (ArithmeticFunction.vonMangoldt n) := by ++ simp ++ have : 0 ≤ (ArithmeticFunction.vonMangoldt n) * ((n : ℝ) ^ σ)⁻¹ := ++ mul_nonneg hv_nonneg (inv_nonneg.mpr hden_nonneg) ++ simpa [r, div_eq_mul_inv] using this ++ · ++ have hbase_nonneg : 0 ≤ (n : ℝ) := by exact_mod_cast (Nat.zero_le n) ++ have hden_eq : (((n : ℝ) ^ σ : ℝ) : ℂ) = (n : ℂ) ^ (σ : ℂ) := by ++ simpa using (Complex.ofReal_cpow (x := (n : ℝ)) (hx := hbase_nonneg) (y := σ)) ++ calc ++ ((ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))) ++ = ((ArithmeticFunction.vonMangoldt n : ℂ) / (((n : ℝ) ^ σ : ℝ) : ℂ)) := by ++ simp [hden_eq.symm] ++ _ = (((ArithmeticFunction.vonMangoldt n : ℝ) / ((n : ℝ) ^ σ)) : ℝ) := by ++ simp ++ _ = (r : ℂ) := by rfl ++ ++lemma lem_tsum_norm_vonMangoldt_depends_on_Re (s : ℂ) (σ : ℝ) (hσ : σ = s.re) (_hs : 1 < s.re) : ++ (∑' n : ℕ, ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ s)‖) = ++ (∑' n : ℕ, ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ classical ++ ++ have hfun : (fun n : ℕ => ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ s)‖) ++ = (fun n : ℕ => ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ funext n ++ by_cases h0 : n = 0 ++ · ++ subst h0 ++ simp [ArithmeticFunction.vonMangoldt] ++ simp only [_root_.ite_eq_right (not_isPrimePow_zero (R := ℕ)), abs_zero, zero_div] ++ · ++ have hn0C : (n : ℂ) ≠ 0 := by ++ exact_mod_cast (Nat.cast_ne_zero.mpr h0) ++ have harg : Complex.arg (n : ℂ) = 0 := by ++ have : (0 : ℝ) ≤ (n : ℝ) := by exact_mod_cast (Nat.zero_le n) ++ simp ++ ++ have hden_s : ‖(n : ℂ) ^ s‖ = ‖(n : ℂ)‖ ^ s.re := by ++ ++ simpa [harg, Real.exp_zero, div_one] using ++ (Complex.norm_cpow_of_ne_zero (z := (n : ℂ)) (w := s) hn0C) ++ have hden_σ : ‖(n : ℂ) ^ (σ : ℂ)‖ = ‖(n : ℂ)‖ ^ σ := by ++ simp ++ ++ simp [hden_s, hσ] ++ ++ have htsum := congrArg (fun f : ℕ → ℝ => (∑' n, f n)) hfun ++ simpa using htsum ++ ++lemma helper_LSeries_vonMangoldt_tsum (σ : ℝ) (hσ : 1 < σ) : ++ (∑' n : ℕ, (ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))) = ++ - deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ) := by ++ have hs : 1 < (σ : ℂ).re := by simpa using hσ ++ have h0 : ((fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℂ)) 0) = 0 := by simp ++ simpa [LSeries, LSeries.term_def₀ (f := fun n : ℕ => (ArithmeticFunction.vonMangoldt n : ℂ)) h0, ++ Complex.cpow_neg, div_eq_mul_inv] using ++ (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div (s := (σ : ℂ)) hs) ++ ++lemma summable_ofReal_iff {f : ℕ → ℝ} : Summable (fun n => (f n : ℂ)) ↔ Summable f := by ++ simp ++ ++lemma helper_summable_of_summable_norm {u : ℕ → ℂ} ++ (h : Summable (fun n => ‖u n‖)) : Summable u := by ++ simpa using (Summable.of_norm (f := u) h) ++ ++lemma helper_norm_tsum_eq_tsum_norm_of_nonneg_real {u : ℕ → ℂ} {r : ℕ → ℝ} ++ (h : ∀ n, u n = (r n : ℂ)) (hr : ∀ n, 0 ≤ r n) (_hu : Summable u) : ++ ‖(∑' n, u n)‖ = ∑' n, ‖u n‖ := by ++ classical ++ ++ have hsum_eq_ofReal : (∑' n, (r n : ℂ)) = ((∑' n, r n : ℝ) : ℂ) := by ++ simpa using (Complex.ofReal_tsum r).symm ++ have hrewrite_u : ‖∑' n, u n‖ = ‖∑' n, (r n : ℂ)‖ := by ++ have hfun : u = (fun n => (r n : ℂ)) := funext h ++ simp [hfun] ++ have hnorm_abs : ‖((∑' n, r n : ℝ) : ℂ)‖ = |∑' n, r n| := by ++ simp [Real.norm_eq_abs] ++ ++ have hLHS : ‖∑' n, u n‖ = |∑' n, r n| := by ++ simp [hrewrite_u, hsum_eq_ofReal] ++ ++ have hsum_nonneg : 0 ≤ ∑' n, r n := tsum_nonneg hr ++ have habs_sum : |∑' n, r n| = ∑' n, r n := abs_of_nonneg hsum_nonneg ++ ++ have hfunEq : (fun n => ‖u n‖) = (fun n => ‖(r n : ℂ)‖) := by ++ funext n; simp [h n] ++ have hfunEq2 : (fun n => ‖(r n : ℂ)‖) = (fun n => r n) := by ++ funext n ++ have : ‖(r n : ℂ)‖ = ‖r n‖ := by simp ++ have : ‖r n‖ = |r n| := by simp ++ have : |r n| = r n := abs_of_nonneg (hr n) ++ simp [this] ++ have hsum_norms1 : (∑' n, ‖u n‖) = ∑' n, ‖(r n : ℂ)‖ := ++ congrArg (fun f : ℕ → ℝ => ∑' n, f n) hfunEq ++ have hsum_norms2 : (∑' n, ‖(r n : ℂ)‖) = ∑' n, r n := ++ congrArg (fun f : ℕ → ℝ => ∑' n, f n) hfunEq2 ++ have hRHS : (∑' n, ‖u n‖) = ∑' n, r n := hsum_norms1.trans hsum_norms2 ++ ++ calc ++ ‖(∑' n, u n)‖ = |∑' n, r n| := hLHS ++ _ = ∑' n, r n := habs_sum ++ _ = ∑' n, ‖u n‖ := by simp [hRHS] ++ ++lemma lem_norm_logDeriv_le_tsum (s : ℂ) (hs : 1 < s.re) : ++ ‖deriv riemannZeta s / riemannZeta s‖ ≤ ∑' n : ℕ, ‖((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ) / ((n : ℂ) ^ s)‖ := by ++ classical ++ ++ let f : ℕ → ℂ := fun n => ((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ) ++ ++ have hsum_term : Summable (fun n : ℕ => LSeries.term f s n) := by ++ simpa [f] using! (ArithmeticFunction.LSeriesSummable_vonMangoldt (s := s) hs) ++ ++ have hsum_norm : Summable (fun n : ℕ => ‖LSeries.term f s n‖) := ++ (summable_norm_iff).mpr hsum_term ++ ++ have hEq : (∑' n : ℕ, LSeries.term f s n) = - deriv riemannZeta s / riemannZeta s := by ++ simpa [f] using! (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div (s := s) hs) ++ ++ have hpoint : (fun n : ℕ => ‖LSeries.term f s n‖) ++ = (fun n : ℕ => ‖f n / ((n : ℂ) ^ s)‖) := by ++ funext n ++ by_cases h0 : n = 0 ++ · ++ subst h0 ++ ++ have hf0r : ArithmeticFunction.vonMangoldt 0 = 0 := by ++ simp ++ have hf0 : f 0 = 0 := by simp [f, hf0r] ++ simp [LSeries.term, f, hf0] ++ · ++ simp [LSeries.term, f, h0] ++ ++ calc ++ ‖deriv riemannZeta s / riemannZeta s‖ ++ = ‖- deriv riemannZeta s / riemannZeta s‖ := by simp [norm_neg] ++ _ = ‖∑' n : ℕ, LSeries.term f s n‖ := by simp [hEq] ++ _ ≤ ∑' n : ℕ, ‖LSeries.term f s n‖ := ++ norm_tsum_le_tsum_norm (f := fun n : ℕ => LSeries.term f s n) hsum_norm ++ _ = ∑' n : ℕ, ‖f n / ((n : ℂ) ^ s)‖ := by simp [hpoint] ++ _ = ∑' n : ℕ, ‖((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ) / ((n : ℂ) ^ s)‖ := rfl ++ ++lemma lem_tsum_norm_vonMangoldt_depends_on_Re_cast (s : ℂ) (σ : ℝ) ++ (hσ : σ = s.re) (hs : 1 < s.re) : ++ (∑' n : ℕ, ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ s)‖) ++ = (∑' n : ℕ, ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ ++ have hre_ne_zero : s.re ≠ 0 := ne_of_gt (lt_trans zero_lt_one hs) ++ have hσ_ne_zero : σ ≠ 0 := by ++ have : 0 < σ := by simpa [hσ] using (lt_trans zero_lt_one hs) ++ exact ne_of_gt this ++ ++ have hterm : (fun n : ℕ => ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ s)‖) ++ = (fun n : ℕ => ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ funext n ++ ++ have hden_s : ‖(n : ℂ) ^ s‖ = (n : ℝ) ^ s.re := ++ Complex.norm_natCast_cpow_of_re_ne_zero n hre_ne_zero ++ have hden_σ : ‖(n : ℂ) ^ (σ : ℂ)‖ = (n : ℝ) ^ (σ : ℂ).re := ++ Complex.norm_natCast_cpow_of_re_ne_zero n (by simpa [Complex.ofReal_re] using hσ_ne_zero) ++ calc ++ ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ s)‖ ++ = ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ))‖ / ‖(n : ℂ) ^ s‖ := by simp ++ _ = |ArithmeticFunction.vonMangoldt n| / ((n : ℝ) ^ s.re) := by ++ simp [hden_s, Complex.norm_real] ++ _ = |ArithmeticFunction.vonMangoldt n| / ((n : ℝ) ^ σ) := by simp [hσ] ++ _ = ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ))‖ / ‖(n : ℂ) ^ (σ : ℂ)‖ := by ++ simp [hden_σ, Complex.ofReal_re, Complex.norm_real] ++ _ = ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ (σ : ℂ))‖ := by simp ++ simpa using congrArg (fun f : ℕ → ℝ => ∑' n, f n) hterm ++ ++lemma helper_norm_neg_logDeriv_eq_tsum_norm (σ : ℝ) (hσ : 1 < σ) : ++ ‖- deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ)‖ = ++ (∑' n : ℕ, ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ classical ++ ++ let s : ℂ := (σ : ℂ) ++ ++ let f : ℕ → ℂ := fun n => ((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ) ++ ++ let u : ℕ → ℂ := fun n => LSeries.term f s n ++ ++ have hs_re : 1 < s.re := by simpa using! hσ ++ have hsum_term : Summable (fun n : ℕ => LSeries.term f s n) := by ++ simpa [f] using! (ArithmeticFunction.LSeriesSummable_vonMangoldt (s := s) hs_re) ++ ++ have hsum_u : Summable u := hsum_term ++ ++ have hL_eq : (∑' n : ℕ, LSeries.term f s n) = - deriv riemannZeta s / riemannZeta s := ++ (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div (s := s) hs_re) ++ have hsum_eq : (∑' n, u n) = - deriv riemannZeta s / riemannZeta s := by ++ simpa [u] using hL_eq ++ ++ have hterm_as_div : ∀ n, ++ u n = ((ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))) := by ++ intro n; by_cases h0 : n = 0 ++ · ++ subst h0; simp [u, LSeries.term, f, s] ++ · ++ simp [u, LSeries.term, f, s, h0] ++ ++ let r : ℕ → ℝ := fun n => Classical.choose (lem_term_real_nonneg n σ hσ) ++ have hr_nonneg : ∀ n, 0 ≤ r n := by ++ intro n; exact (Classical.choose_spec (lem_term_real_nonneg n σ hσ)).1 ++ have hr_cast : ∀ n, ++ ((ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))) = (r n : ℂ) := by ++ intro n; exact (Classical.choose_spec (lem_term_real_nonneg n σ hσ)).2 ++ have hr_eq' : ∀ n, u n = (r n : ℂ) := by ++ intro n; simpa [hterm_as_div n] using (hr_cast n) ++ ++ have hsum_rc : Summable (fun n => (r n : ℂ)) := by ++ simpa [u, hr_eq'] using hsum_u ++ have hsum_r : Summable r := (Complex.summable_ofReal).1 hsum_rc ++ ++ have hsum_u_as_real : (∑' n, u n) = ((∑' n, r n) : ℝ) := by ++ have hru : (fun n => (r n : ℂ)) = u := by ++ funext n; symm; exact hr_eq' n ++ have := (Complex.ofReal_tsum (L := SummationFilter.unconditional ℕ) (f := r)) ++ ++ simpa [hru] using this.symm ++ ++ have hpoint_norm : (fun n : ℕ => ‖u n‖) ++ = (fun n : ℕ => ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ funext n; by_cases h0 : n = 0 ++ · subst h0; simp [u, LSeries.term, f, s] ++ · simp [u, LSeries.term, f, s, h0] ++ have hnorm_fun : (fun n : ℕ => ‖u n‖) = r := by ++ funext n; simp [hr_eq' n, Complex.norm_real, abs_of_nonneg (hr_nonneg n)] ++ have hsum_norm : Summable (fun n : ℕ => ‖u n‖) := by ++ simpa [hnorm_fun] using hsum_r ++ ++ have hineq : ‖∑' n, u n‖ ≤ ∑' n, ‖u n‖ := ++ norm_tsum_le_tsum_norm (f := u) hsum_norm ++ ++ set S : ℝ := ∑' n, r n ++ have hS_le : ‖((S : ℝ) : ℂ)‖ ≤ S := by ++ simpa [S, hsum_u_as_real, hnorm_fun] using hineq ++ ++ have hS_nonneg : 0 ≤ S := by ++ have habs_le : |S| ≤ S := by simpa [Complex.norm_real] using hS_le ++ exact (abs_nonneg S).trans habs_le ++ ++ have h_left : ‖- deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ)‖ ++ = ‖∑' n, u n‖ := by ++ have : - deriv riemannZeta s / riemannZeta s = ∑' n, u n := by simpa [hsum_u_as_real] using hsum_eq.symm ++ simp [s, this] ++ have h_mid : ‖∑' n, u n‖ = S := by ++ ++ have : ‖((S : ℝ) : ℂ)‖ = S := by simp [Complex.norm_real, abs_of_nonneg hS_nonneg] ++ simpa [S, hsum_u_as_real] using this ++ have h_right : (∑' n : ℕ, ‖u n‖) = S := by simp [S, hnorm_fun] ++ ++ calc ++ ‖- deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ)‖ ++ = ‖∑' n, u n‖ := h_left ++ _ = S := h_mid ++ _ = (∑' n : ℕ, ‖u n‖) := h_right.symm ++ _ = (∑' n : ℕ, ‖(ArithmeticFunction.vonMangoldt n : ℂ) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ simp [hpoint_norm] ++ ++theorem lem_zetacenterbd : ++ ∀ t : ℝ, ++ ∀ σ : ℝ, ++ σ ≥ 3/2 → ++ ‖deriv riemannZeta (Complex.mk σ t) / riemannZeta (Complex.mk σ t)‖ ≤ ++ ‖deriv riemannZeta σ / riemannZeta σ‖ := by ++ intro t σ hσge ++ ++ set s : ℂ := Complex.mk σ t ++ ++ have hs : 1 < s.re := by ++ have : (1 : ℝ) < (3 / 2 : ℝ) := by norm_num ++ exact lt_of_lt_of_le this hσge ++ have hσgt1 : 1 < σ := by ++ have : (1 : ℝ) < (3 / 2 : ℝ) := by norm_num ++ exact lt_of_lt_of_le this hσge ++ ++ have h_le_sum := lem_norm_logDeriv_le_tsum s hs ++ have h1 : ‖deriv riemannZeta s / riemannZeta s‖ ≤ ++ (∑' n : ℕ, |ArithmeticFunction.vonMangoldt n| / ‖(n : ℂ) ^ s‖) := by ++ simpa [norm_div, Complex.norm_real] using h_le_sum ++ ++ have h_dep : ++ (∑' n : ℕ, ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ s)‖) ++ = (∑' n : ℕ, ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ (σ : ℂ))‖) := by ++ ++ have hre : σ = s.re := by simp [s] ++ simpa using (lem_tsum_norm_vonMangoldt_depends_on_Re_cast s σ hre hs) ++ have h_dep_ratio : ++ (∑' n : ℕ, |ArithmeticFunction.vonMangoldt n| / ‖(n : ℂ) ^ s‖) ++ = (∑' n : ℕ, |ArithmeticFunction.vonMangoldt n| / ‖(n : ℂ) ^ (σ : ℂ)‖) := by ++ simpa [norm_div, Complex.norm_real] using h_dep ++ ++ have h_sum_eq_norm : ++ ‖- deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ)‖ ++ = (∑' n : ℕ, ‖(((ArithmeticFunction.vonMangoldt n : ℝ) : ℂ)) / ((n : ℂ) ^ (σ : ℂ))‖) := ++ helper_norm_neg_logDeriv_eq_tsum_norm σ hσgt1 ++ have h_sum_eq_norm_ratio : ++ (∑' n : ℕ, |ArithmeticFunction.vonMangoldt n| / ‖(n : ℂ) ^ (σ : ℂ)‖) ++ = ‖- deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ)‖ := by ++ simpa [norm_div, Complex.norm_real] using h_sum_eq_norm.symm ++ ++ have h_main : ‖deriv riemannZeta s / riemannZeta s‖ ≤ ‖- deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ)‖ := by ++ calc ++ ‖deriv riemannZeta s / riemannZeta s‖ ++ ≤ (∑' n : ℕ, |ArithmeticFunction.vonMangoldt n| / ‖(n : ℂ) ^ s‖) := h1 ++ _ = (∑' n : ℕ, |ArithmeticFunction.vonMangoldt n| / ‖(n : ℂ) ^ (σ : ℂ)‖) := h_dep_ratio ++ _ = ‖- deriv riemannZeta (σ : ℂ) / riemannZeta (σ : ℂ)‖ := h_sum_eq_norm_ratio ++ ++ simpa [s, norm_neg] using h_main ++ ++lemma lem_logDerivZetalogt32 : ++ ∃ C : ℝ, C > 1 ∧ ++ ∀ t : ℝ, |t| > 3 → ++ ∀ σ : ℝ, ++ σ ≥ 3/2 → ++ ‖deriv riemannZeta (Complex.mk σ t) / riemannZeta (Complex.mk σ t)‖ ≤ C := by ++ ++ obtain ⟨C0, hC0_gt1, hC0_bound⟩ := Z0bound_const ++ ++ refine ⟨C0 + 2, by linarith, ?_⟩ ++ intro t ht σ hσ ++ ++ have h_center := lem_zetacenterbd t σ hσ ++ ++ set δ : ℝ := σ - 1 ++ have hδ_pos : 0 < δ := by linarith [hσ] ++ have hδ_ge_half : (1 / 2 : ℝ) ≤ δ := by linarith [hσ] ++ ++ have hZ0 := hC0_bound δ hδ_pos ++ ++ have h_tri : ‖-logDerivZeta ((1 : ℂ) + δ)‖ ≤ ++ ‖-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))‖ + ‖(1 / (δ : ℂ))‖ := by ++ simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using ++ (norm_add_le (-logDerivZeta ((1 : ℂ) + δ) - (1 / (δ : ℂ))) (1 / (δ : ℂ))) ++ ++ have h_norm_div_le_two : ‖(1 / (δ : ℂ))‖ ≤ 2 := by ++ ++ have hnorm_div : ‖(1 : ℂ) / (δ : ℂ)‖ = ‖(1 : ℂ)‖ / ‖(δ : ℂ)‖ := by ++ simp ++ have hnorm_ofReal : ‖(δ : ℂ)‖ = |δ| := by ++ simp ++ ++ have h_abs_ge : (1 / 2 : ℝ) ≤ |δ| := by ++ have hδ_nonneg : 0 ≤ δ := le_of_lt hδ_pos ++ simpa [abs_of_nonneg hδ_nonneg] using hδ_ge_half ++ have hhalfpos : (0 : ℝ) < 1 / 2 := by norm_num ++ have hone_div_abs_le_two : 1 / |δ| ≤ 2 := by ++ simpa using (one_div_le_one_div_of_le hhalfpos h_abs_ge) ++ ++ have : 1 / ‖(δ : ℂ)‖ ≤ 2 := by simpa [hnorm_ofReal] using hone_div_abs_le_two ++ ++ have hnorm_div' : ‖(1 / (δ : ℂ))‖ = 1 / ‖(δ : ℂ)‖ := by ++ simp ++ simpa [hnorm_div'] using this ++ ++ have h_real_axis_bound : ‖logDerivZeta ((1 : ℂ) + δ)‖ ≤ C0 + 2 := by ++ have h1 : ‖-logDerivZeta ((1 : ℂ) + δ)‖ ≤ C0 + ‖(1 / (δ : ℂ))‖ := ++ le_trans h_tri (add_le_add_left hZ0 _) ++ have h2 : ‖-logDerivZeta ((1 : ℂ) + δ)‖ ≤ C0 + 2 := ++ le_trans h1 (add_le_add_right h_norm_div_le_two _) ++ simpa [norm_neg] using h2 ++ ++ have hσ_real : (1 : ℝ) + δ = σ := by ++ simp [δ, sub_eq_add_neg, add_left_comm] ++ have hσ_eq : (1 : ℂ) + δ = (σ : ℂ) := by ++ have : ((1 + δ : ℝ) : ℂ) = (σ : ℂ) := by simpa using congrArg Complex.ofReal hσ_real ++ simpa [Complex.ofReal_add] using this ++ have hR_bound : ‖deriv riemannZeta σ / riemannZeta σ‖ ≤ C0 + 2 := by ++ ++ simpa [logDerivZeta, hσ_eq] using h_real_axis_bound ++ ++ exact le_trans h_center hR_bound ++ ++theorem thm_final_result : ++ ∃ A : ℝ, A > 0 ∧ A < 1 ∧ ++ ∃ C : ℝ, C > 1 ∧ ++ ∀ t : ℝ, |t| > 3 → ++ ∀ σ : ℝ, ++ σ ≥ 1 - A / Real.log (abs t + 2) → ++ ‖deriv riemannZeta (Complex.mk σ t) / riemannZeta (Complex.mk σ t)‖ ≤ C * (Real.log (abs t)) ^ 2 := by ++ ++ obtain ⟨C₀, hC₀_pos, hC₀⟩ := lem_logDerivZetalogt0 ++ obtain ⟨C₃₂, hC₃₂_pos, hC₃₂⟩ := lem_logDerivZetalogt32 ++ ++ use zerofree_constant / 20 ++ ++ constructor ++ · ++ apply div_pos zerofree_constant_pos ++ norm_num ++ ++ constructor ++ · ++ rw [div_lt_one (by norm_num : (0 : ℝ) < 20)] ++ ++ have h1 : zerofree_constant < 1 := zerofree_constant_lt_one ++ linarith ++ ++ use max C₀ C₃₂ ++ ++ constructor ++ · ++ exact lt_max_of_lt_left hC₀_pos ++ ++ · ++ intro t ht σ hσ ++ ++ have h_eq : zerofree_constant / 20 / Real.log (abs t + 2) = deltaz_t t := by ++ unfold deltaz_t deltaz ++ simp ++ ++ have hσ' : σ ≥ 1 - deltaz_t t := by ++ rw [← h_eq] ++ exact hσ ++ ++ by_cases h : σ ≥ 3/2 ++ · ++ have bound := hC₃₂ t ht σ h ++ have hC_le : C₃₂ ≤ max C₀ C₃₂ := le_max_right _ _ ++ ++ have hlog_ge_one : 1 ≤ Real.log (abs t) := by ++ have h_ge : Real.exp 1 ≤ abs t := by ++ ++ have he_lt_3 : Real.exp 1 < 3 := lem_three_gt_e ++ linarith [ht, abs_nonneg t] ++ exact (Real.le_log_iff_exp_le (by linarith [abs_nonneg t])).2 h_ge ++ have h_one_le_sq : 1 ≤ (Real.log (abs t)) ^ 2 := by ++ have h_sq : (Real.log (abs t)) ^ 2 = Real.log (abs t) * Real.log (abs t) := by ++ rw [pow_two] ++ rw [h_sq] ++ have h_mul : 1 * 1 ≤ Real.log (abs t) * Real.log (abs t) := ++ mul_self_le_mul_self (zero_le_one) hlog_ge_one ++ simpa using h_mul ++ have h_pos : 0 < C₃₂ := lt_trans zero_lt_one hC₃₂_pos ++ calc ‖deriv riemannZeta (Complex.mk σ t) / riemannZeta (Complex.mk σ t)‖ ++ ≤ C₃₂ := bound ++ _ = C₃₂ * 1 := by rw [mul_one] ++ _ ≤ C₃₂ * (Real.log (abs t)) ^ 2 := by ++ apply mul_le_mul_of_nonneg_left h_one_le_sq (le_of_lt h_pos) ++ _ ≤ max C₀ C₃₂ * (Real.log (abs t)) ^ 2 := by ++ apply mul_le_mul_of_nonneg_right hC_le (sq_nonneg _) ++ ++ · ++ push Not at h ++ have h_conditions : 1 - deltaz_t t ≤ σ ∧ σ ≤ 3/2 ∧ t = t := by ++ exact ⟨hσ', le_of_lt h, rfl⟩ ++ have bound := hC₀ t ht ⟨σ, t⟩ h_conditions ++ have hC_le : C₀ ≤ max C₀ C₃₂ := le_max_left _ _ ++ calc ‖deriv riemannZeta (Complex.mk σ t) / riemannZeta (Complex.mk σ t)‖ ++ ≤ C₀ * Real.log |t| ^ 2 := bound ++ _ ≤ max C₀ C₃₂ * Real.log |t| ^ 2 := by ++ apply mul_le_mul_of_nonneg_right hC_le (sq_nonneg _) ++ ++lemma ZetaZeroFree_p : ++ ∃ (A : ℝ) (_ : A ∈ Set.Ioc 0 (1 / 2)), ++ ∀ (σ : ℝ) ++ (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Set.Ico (1 - A / Real.log |t| ^ 1) 1), ++ riemannZeta (σ + t * Complex.I) ≠ 0 := by ++ ++ obtain ⟨c, hc_pos, hc_lt_one, hbound⟩ := zerofree ++ ++ let A0 : ℝ := min (1 / 2 : ℝ) (c / 2) ++ let A : ℝ := min A0 ((1 / 4 : ℝ) * Real.log 3) ++ have hA_pos : 0 < A := by ++ have h1 : 0 < (1 / 2 : ℝ) := by norm_num ++ have h2 : 0 < c / 2 := by ++ have : 0 < (2 : ℝ) := by norm_num ++ exact div_pos hc_pos this ++ have hA0pos : 0 < A0 := lt_min_iff.mpr ⟨h1, h2⟩ ++ have hlog3pos : 0 < Real.log (3 : ℝ) := ++ (Real.log_pos_iff (by norm_num : (0 : ℝ) ≤ 3)).2 (by norm_num) ++ have h3 : 0 < (1 / 4 : ℝ) * Real.log 3 := by ++ exact mul_pos (by norm_num) hlog3pos ++ exact lt_min_iff.mpr ⟨hA0pos, h3⟩ ++ have hA_le_half : A ≤ 1/2 := by ++ have : A ≤ A0 := min_le_left _ _ ++ exact this.trans (min_le_left _ _) ++ have hA_le_c2 : A ≤ c / 2 := by ++ have : A ≤ A0 := min_le_left _ _ ++ exact this.trans (min_le_right _ _) ++ have hA_le_log3quarter : A ≤ (1 / 4 : ℝ) * Real.log 3 := min_le_right _ _ ++ refine ⟨A, ?_, ?_⟩ ++ · exact ⟨hA_pos, hA_le_half⟩ ++ · intro σ t htgt3 hσI hzero ++ ++ set L := Real.log |t| with hLdef ++ set Lp := Real.log (|t| + 2) with hLpdef ++ have hpos_abs : 0 ≤ |t| := abs_nonneg t ++ have hLpos : 0 < L := (Real.log_pos_iff hpos_abs).2 (lt_trans (by norm_num) htgt3) ++ have hLp_pos_arg : 0 < |t| + 2 := by linarith ++ have hLp_pos : 0 < Lp := (Real.log_pos_iff (le_of_lt hLp_pos_arg)).2 (by linarith) ++ ++ have hlog3_le_L : Real.log 3 ≤ L := by ++ have h3pos : 0 < (3 : ℝ) := by norm_num ++ have : (3 : ℝ) ≤ |t| := le_of_lt htgt3 ++ simpa [hLdef] using Real.log_le_log h3pos this ++ ++ have hquarter_ratio_le : ((1 / 4 : ℝ) * Real.log 3) / L ≤ (1 / 4 : ℝ) := by ++ have h := div_le_div_of_nonneg_right hlog3_le_L (le_of_lt hLpos) ++ have h' := mul_le_mul_of_nonneg_left h (by norm_num : (0 : ℝ) ≤ 1/4) ++ have hne : L ≠ 0 := ne_of_gt hLpos ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc, hne] using h' ++ ++ have hA_over_le_quarter : A / L ≤ (1 / 4 : ℝ) := by ++ have := div_le_div_of_nonneg_right hA_le_log3quarter (le_of_lt hLpos) ++ exact this.trans hquarter_ratio_le ++ ++ have hlow : 1 - A / L ≤ σ := by simpa [hLdef, pow_one] using hσI.1 ++ have hσ_ge_34 : (3 / 4 : ℝ) ≤ σ := by ++ have : (3 / 4 : ℝ) ≤ 1 - A / L := by linarith ++ exact this.trans hlow ++ have hσ_pos : 0 < σ := lt_of_lt_of_le (by norm_num : (0 : ℝ) < (3/4 : ℝ)) hσ_ge_34 ++ have hσ_lt_one : σ < 1 := hσI.2 ++ ++ have hlog_lt : Lp < 2 * L := by ++ have h1 : 0 < |t| - 2 := by linarith ++ have h2 : 0 < |t| + 1 := by linarith ++ have hprod_pos : 0 < (|t| - 2) * (|t| + 1) := mul_pos h1 h2 ++ have hpoly : |t| * |t| - (|t| + 2) = (|t| - 2) * (|t| + 1) := by ring ++ have hlt : |t| + 2 < |t| * |t| := by ++ calc ++ |t| + 2 < |t| + 2 + (|t| - 2) * (|t| + 1) := by linarith [hprod_pos] ++ _ = |t| * |t| := by rw [← hpoly]; ring ++ have hposb : 0 < |t| + 2 := by linarith ++ have hlog_lt' : Real.log (|t| + 2) < Real.log (|t| * |t|) := Real.log_lt_log hposb hlt ++ have hlogmul : Real.log (|t| ^ 2) = 2 * Real.log |t| := Real.log_pow |t| 2 ++ calc ++ Lp = Real.log (|t| + 2) := by simp [hLpdef] ++ _ < Real.log (|t| * |t|) := hlog_lt' ++ _ = Real.log (|t| ^ 2) := by simp [pow_two] ++ _ = 2 * Real.log |t| := by simp ++ _ = 2 * L := by simp [hLdef] ++ ++ have h_inv_comp : 1 / (2 * L) < 1 / Lp := one_div_lt_one_div_of_lt hLp_pos hlog_lt ++ have hstep2 : (c / 2) / L < c / Lp := by ++ have hcpos' : 0 < c := hc_pos ++ have : c * (1 / (2 * L)) < c * (1 / Lp) := mul_lt_mul_of_pos_left h_inv_comp hcpos' ++ simpa [div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] using this ++ ++ have hstep1 : A / L ≤ (c / 2) / L := by ++ have := div_le_div_of_nonneg_right hA_le_c2 (le_of_lt hLpos) ++ simpa [div_eq_mul_inv] using this ++ have hstrict_div : A / L < c / Lp := lt_of_le_of_lt hstep1 hstep2 ++ ++ have hσ_gt : 1 - c / Lp < σ := by ++ have hneg' : - (c / Lp) < - (A / L) := by simpa [neg_div] using neg_lt_neg hstrict_div ++ have : 1 - c / Lp < 1 - A / L := by simpa [sub_eq_add_neg] using! add_lt_add_right hneg' 1 ++ exact this.trans_le hlow ++ ++ let s : ℂ := Complex.mk σ t ++ have hs_zero : riemannZeta s = 0 := by simpa [s, Complex.mk_eq_add_mul_I] using hzero ++ have hs_in_zeroZ : s ∈ zeroZ := by simpa [zeroZ] using hs_zero ++ have hpre : s ∈ zeroZ ∧ 0 < s.re ∧ s.re < 1 := by ++ refine ⟨hs_in_zeroZ, ?_, ?_⟩ ++ · simpa [s] using hσ_pos ++ · simpa [s] using hσ_lt_one ++ have him_bound : 2 < |s.im| := by ++ have : 2 < |t| := lt_trans (by norm_num) htgt3 ++ simpa [s] using this ++ have hbound_applied : s.re ≤ 1 - c / Real.log (abs s.im + 2) := hbound s hpre him_bound ++ have hle : σ ≤ 1 - c / Lp := by simpa [s, hLpdef] using hbound_applied ++ have hcontr : σ < σ := lt_of_le_of_lt hle hσ_gt ++ exact (lt_irrefl _ : ¬ σ < σ) hcontr ++ ++open _root_.Set Function Filter _root_.Complex _root_.Real ++lemma LogDerivZetaBndUnif2 : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)) (C : ℝ) (_ : 0 < C), ∀ (σ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Ici (1 - A / Real.log |t| ^ 1)), ‖(deriv riemannZeta) (σ + t * Complex.I) / riemannZeta (σ + t * Complex.I)‖ ≤ ++ C * Real.log |t| ^ 2 := by ++ classical ++ obtain ⟨c, hc, hc2, K, hK, hfinal⟩ := thm_final_result ++ ++ let A : ℝ := min (1/2 : ℝ) (c / 2) ++ have hApos : 0 < A := by ++ have h1 : 0 < (1/2 : ℝ) := by norm_num ++ have h2 : 0 < c / 2 := by ++ have : 0 < (2 : ℝ) := by norm_num ++ exact div_pos hc this ++ exact (lt_min_iff).2 ⟨h1, h2⟩ ++ have hAle : A ≤ (1/2 : ℝ) := min_le_left _ _ ++ have hA_in : A ∈ Ioc 0 (1/2) := ⟨hApos, hAle⟩ ++ let C : ℝ := K ++ have hCpos : 0 < C := by ++ have hKpos : 0 < K := lt_trans (by norm_num : (0 : ℝ) < 1) hK ++ exact hKpos ++ refine ⟨A, hA_in, C, hCpos, ?_⟩ ++ intro σ t htgt3 hσI ++ ++ let x := |t| ++ have hxpos : 0 ≤ x := abs_nonneg t ++ have hxgt3 : 3 < x := htgt3 ++ let L := Real.log x ++ let L' := Real.log (x + 2) ++ have hLpos : 0 < L := (Real.log_pos_iff hxpos).2 (lt_trans (by norm_num) hxgt3) ++ have hL'pos : 0 < L' := ++ (Real.log_pos_iff (by linarith : 0 ≤ x + 2)).2 (by linarith [hxpos, hxgt3]) ++ ++ have hσ_ge : 1 - A / L ≤ σ := by simpa [pow_one, L, x] using hσI ++ ++ have hprod_pos : 0 < (x - 2) * (x + 1) := by ++ have hxgt2 : (2 : ℝ) < x := lt_trans (by norm_num) hxgt3 ++ exact mul_pos (sub_pos.mpr hxgt2) (add_pos_of_nonneg_of_pos hxpos (by norm_num)) ++ have hdiff_pos : 0 < x ^ 2 - (x + 2) := by ++ have hpoly : x ^ 2 - (x + 2) = (x - 2) * (x + 1) := by ring ++ simpa [hpoly] using hprod_pos ++ have hlt_sq : x + 2 < x ^ 2 := by linarith ++ have hlog_lt : L' < Real.log (x ^ 2) := ++ Real.log_lt_log (by linarith : 0 < x + 2) hlt_sq ++ have hlog_pow : Real.log (x ^ 2) = 2 * L := by ++ simp [L] ++ have hL'_lt_2L : L' < 2 * L := by simpa [L', hlog_pow] ++ using hlog_lt ++ ++ have hA_le_c2 : A ≤ c / 2 := min_le_right _ _ ++ have hstep0 : A / L ≤ (c / 2) / L := ++ div_le_div_of_nonneg_right hA_le_c2 (le_of_lt hLpos) ++ have hrecip : 1 / (2 * L) < 1 / L' := ++ one_div_lt_one_div_of_lt hL'pos hL'_lt_2L ++ have hmul : c * (1 / (2 * L)) < c * (1 / L') := ++ mul_lt_mul_of_pos_left hrecip hc ++ have hstep2 : (c / 2) / L < c / L' := by ++ simpa [one_div, div_eq_mul_inv, mul_comm, mul_left_comm, mul_assoc] ++ using hmul ++ have hineq : A / L < c / L' := lt_of_le_of_lt hstep0 hstep2 ++ have hσ_gt : σ > 1 - c / L' := by ++ have : 1 - c / L' < 1 - A / L := by linarith [hineq] ++ exact lt_of_lt_of_le this hσ_ge ++ ++ have hmain' : ‖(deriv riemannZeta) (σ + t * Complex.I) / riemannZeta (σ + t * Complex.I)‖ ≤ ++ K * (Real.log |t|) ^ 2 := by ++ have h_eq : σ + t * Complex.I = Complex.mk σ t := by ++ rw [Complex.mk_eq_add_mul_I] ++ rw [h_eq] ++ have hσ_ge_required : σ ≥ 1 - c / Real.log (abs t + 2) := by ++ have h_abs_eq : abs t = |t| := by simp ++ rw [h_abs_eq] ++ exact le_of_lt hσ_gt ++ exact hfinal t htgt3 σ hσ_ge_required ++ ++ simpa [C, L, x] using hmain' ++ ++end Erdos970 +diff --git a/StrongPNT/Erdos970/PNT5_Strong.lean b/StrongPNT/Erdos970/PNT5_Strong.lean +new file mode 100644 +index 0000000..bc0f938 +--- /dev/null ++++ b/StrongPNT/Erdos970/PNT5_Strong.lean +@@ -0,0 +1,5754 @@ ++import PrimeNumberTheoremAnd.Erdos970.ZetaBounds ++import PrimeNumberTheoremAnd.Erdos970.ZetaConj ++import PrimeNumberTheoremAnd.Erdos970.SmoothExistence ++import Mathlib.Algebra.Group.Support ++import Mathlib.Analysis.SpecialFunctions.Log.Monotone ++import Mathlib.Analysis.Real.Pi.Bounds ++import Mathlib.Analysis.Complex.ExponentialBounds ++import StrongPNT.Erdos970.ZetaZeroFree ++ ++namespace Erdos970 ++ ++ ++open _root_.Set _root_.Function _root_.Filter _root_.Complex _root_.Real ++ ++open _root_.ArithmeticFunction (vonMangoldt) ++ ++noncomputable abbrev MellinTransform : (ℝ → ℂ) → ℂ → ℂ := mellin ++ ++lemma MellinTransform_integral (f : ℝ → ℂ) (s : ℂ) : ++ MellinTransform f s = ∫ x in Set.Ioi (0 : ℝ), f x * (x : ℂ) ^ (s - 1) := by ++ simp only [MellinTransform, mellin, smul_eq_mul, mul_comm] ++ ++lemma MellinTransform_eq : MellinTransform = (mellin : (ℝ → ℂ) → ℂ → ℂ) := by ++ rfl ++ ++noncomputable def MellinInverseTransform (F : ℂ → ℂ) (σ : ℝ) (x : ℝ) : ℂ := ++ VerticalIntegral' (fun s ↦ x ^ (-s) * F s) σ ++ ++lemma MellinInverseTransform_eq (σ : ℝ) (f : ℂ → ℂ) : ++ MellinInverseTransform f σ = mellinInv σ f := by ++ unfold mellinInv MellinInverseTransform VerticalIntegral' VerticalIntegral ++ beta_reduce; ext x ++ rw [← smul_assoc, smul_eq_mul (b := Complex.I), div_mul]; simp ++ ++theorem MellinInversion (σ : ℝ) {f : ℝ → ℂ} {x : ℝ} (hx : 0 < x) (hf : MellinConvergent f σ) ++ (hFf : VerticalIntegrable (mellin f) σ) (hfx : ContinuousAt f x) : ++ MellinInverseTransform (MellinTransform f) σ x = f x := by ++ rw [MellinInverseTransform_eq, mellinInv_mellin_eq σ f hx hf hFf hfx] ++ ++local notation (name := mellintransform2) "𝓜" => MellinTransform ++ ++local notation "Λ" => vonMangoldt ++ ++local notation "ζ" => riemannZeta ++ ++local notation "ζ'" => deriv ζ ++ ++local notation "I" => Complex.I ++ ++noncomputable def ChebyshevPsi (x : ℝ) : ℝ := ++ (Finset.range ⌊x + 1⌋₊).sum Λ ++ ++local notation "ψ" => ChebyshevPsi ++ ++theorem LogDerivativeDirichlet (s : ℂ) (hs : 1 < s.re) : ++ - deriv riemannZeta s / riemannZeta s = ∑' n, Λ n / (n : ℂ) ^ s := by ++ rw [← ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div hs] ++ dsimp [LSeries, LSeries.term] ++ nth_rewrite 2 [Summable.tsum_eq_add_tsum_ite (b := 0) ?_] ++ · simp ++ · have := ArithmeticFunction.LSeriesSummable_vonMangoldt hs ++ dsimp [LSeriesSummable] at this ++ convert! this using 1 ++ funext n ++ by_cases h : n = 0 <;> simp [LSeries.term, h] ++ ++noncomputable abbrev SmoothedChebyshevIntegrand (SmoothingF : ℝ → ℝ) (ε : ℝ) (X : ℝ) : ℂ → ℂ := ++ fun s ↦ (- deriv riemannZeta s) / riemannZeta s * ++ 𝓜 ((Smooth1 SmoothingF ε) ·) s * (X : ℂ) ^ s ++ ++noncomputable def SmoothedChebyshev (SmoothingF : ℝ → ℝ) (ε : ℝ) (X : ℝ) : ℂ := ++ VerticalIntegral' (SmoothedChebyshevIntegrand SmoothingF ε X) ((1 : ℝ) + (Real.log X)⁻¹) ++ ++open ComplexConjugate ++ ++lemma smoothedChebyshevIntegrand_conj {SmoothingF : ℝ → ℝ} {ε X : ℝ} (Xpos : 0 < X) (s : ℂ) : ++ SmoothedChebyshevIntegrand SmoothingF ε X (conj s) = conj (SmoothedChebyshevIntegrand SmoothingF ε X s) := by ++ unfold SmoothedChebyshevIntegrand ++ simp only [map_mul, map_div₀, map_neg] ++ congr ++ · exact deriv_riemannZeta_conj s ++ · exact riemannZeta_conj s ++ · simp_rw [MellinTransform_integral] ++ ++ rw[← integral_conj] ++ apply MeasureTheory.setIntegral_congr_fun measurableSet_Ioi ++ intro x xpos ++ simp only [map_mul, Complex.conj_ofReal] ++ congr ++ nth_rw 1 [← map_one conj] ++ rw[← map_sub, Complex.cpow_conj, Complex.conj_ofReal] ++ rw[Complex.arg_ofReal_of_nonneg xpos.le] ++ exact Real.pi_ne_zero.symm ++ · rw[Complex.cpow_conj, Complex.conj_ofReal] ++ rw[Complex.arg_ofReal_of_nonneg Xpos.le] ++ exact Real.pi_ne_zero.symm ++ ++open _root_.MeasureTheory ++ ++lemma SmoothedChebyshevDirichlet_aux_integrable {SmoothingF : ℝ → ℝ} ++ (diffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ (SmoothingFpos : ∀ x > 0, 0 ≤ SmoothingF x) ++ (suppSmoothingF : support SmoothingF ⊆ Icc (1 / 2) 2) ++ (mass_one : ∫ (x : ℝ) in Ioi 0, SmoothingF x / x = 1) ++ {ε : ℝ} (εpos : 0 < ε) (ε_lt_one : ε < 1) {σ : ℝ} (σ_gt : 1 < σ) (σ_le : σ ≤ 2) : ++ MeasureTheory.Integrable ++ (fun (y : ℝ) ↦ 𝓜 (fun x ↦ (Smooth1 SmoothingF ε x : ℂ)) (σ + y * I)) := by ++ obtain ⟨c, cpos, hc⟩ := MellinOfSmooth1b diffSmoothingF suppSmoothingF ++ apply Integrable.mono' (g := (fun t ↦ c / ε * 1 / (1 + t ^ 2))) ++ · apply Integrable.const_mul integrable_inv_one_add_sq ++ · apply Continuous.aestronglyMeasurable ++ apply continuous_iff_continuousAt.mpr ++ intro x ++ have := Smooth1MellinDifferentiable diffSmoothingF suppSmoothingF ⟨εpos, ε_lt_one⟩ ++ SmoothingFpos mass_one (s := σ + x * I) (by simp only [add_re, ofReal_re, mul_re, I_re, ++ mul_zero, ofReal_im, I_im, mul_one, sub_self, add_zero]; linarith) |>.continuousAt ++ fun_prop ++ · filter_upwards [] with t ++ calc ++ _≤ c / ε * 1 / (σ^2 + t^2) := by ++ convert hc (σ / 2) (by linarith) (σ + t * I) (by simp only [add_re, ofReal_re, mul_re, ++ I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, add_zero, half_le_self_iff]; linarith) ++ (by simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, add_zero]; linarith) ε εpos ε_lt_one using 1 ++ simp only [mul_one, Complex.sq_norm, normSq_apply, add_re, ofReal_re, mul_re, I_re, ++ mul_zero, ofReal_im, I_im, sub_self, add_zero, add_im, mul_im, zero_add, mul_inv_rev] ++ ring_nf ++ _ ≤ _ := by ++ gcongr; nlinarith ++ ++attribute [fun_prop] Continuous.const_cpow ++ ++lemma SmoothedChebyshevDirichlet_aux_tsum_integral {SmoothingF : ℝ → ℝ} ++ (diffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ (SmoothingFpos : ∀ x > 0, 0 ≤ SmoothingF x) ++ (suppSmoothingF : support SmoothingF ⊆ Icc (1 / 2) 2) ++ (mass_one : ∫ (x : ℝ) in Ioi 0, SmoothingF x / x = 1) {X : ℝ} ++ (X_pos : 0 < X) {ε : ℝ} (εpos : 0 < ε) ++ (ε_lt_one : ε < 1) {σ : ℝ} (σ_gt : 1 < σ) (σ_le : σ ≤ 2) : ++ ∫ (t : ℝ), ++ ∑' (n : ℕ), (ArithmeticFunction.vonMangoldt n) / (n : ℂ) ^ (σ + t * I) * ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + t * I) * (X : ℂ) ^ (σ + t * I) = ++ ∑' (n : ℕ), ++ ∫ (t : ℝ), (ArithmeticFunction.vonMangoldt n) / (n : ℂ) ^ (σ + ↑t * I) * ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑t * I) * (X : ℂ) ^ (σ + t * I) := by ++ ++ have cont_mellin_smooth : Continuous fun (a : ℝ) ↦ ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑a * I) := by ++ apply continuousOn_univ.mp ++ refine ContinuousOn.comp' ?_ ?_ ?_ (t := {z : ℂ | 0 < z.re }) ++ . refine continuousOn_of_forall_continuousAt ?_ ++ intro z hz ++ exact (Smooth1MellinDifferentiable diffSmoothingF suppSmoothingF ⟨εpos, ε_lt_one⟩ SmoothingFpos mass_one hz).continuousAt ++ . fun_prop ++ . simp only [mapsTo_univ_iff, mem_ofPred_eq, add_re, ofReal_re, mul_re, I_re, mul_zero, ++ ofReal_im, I_im, mul_one, sub_self, add_zero, forall_const]; linarith ++ ++ have abs_two : ∀ a : ℝ, ∀ i : ℕ, ‖(i : ℂ) ^ ((σ : ℂ) + ↑a * I)‖₊ = i ^ σ := by ++ intro a i ++ simp_rw [← norm_toNNReal] ++ ++ rw [norm_natCast_cpow_of_re_ne_zero _ (by simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ++ ofReal_im, I_im, mul_one, sub_self, add_zero, ne_eq]; linarith)] ++ simp only [add_re, mul_re, ofReal_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, add_zero, Real.toNNReal_of_nonneg <| rpow_nonneg (y:= σ) (x:= i) (by linarith)] ++ norm_cast ++ ++ rw [MeasureTheory.integral_tsum] ++ have x_neq_zero : X ≠ 0 := by linarith ++ . intro i ++ by_cases i_eq_zero : i = 0 ++ . simpa [i_eq_zero] using aestronglyMeasurable_const ++ . apply Continuous.aestronglyMeasurable ++ fun_prop (disch := simp[i_eq_zero, x_neq_zero]) ++ . rw [← lt_top_iff_ne_top] ++ simp_rw [enorm_mul, enorm_eq_nnnorm, nnnorm_div, ← norm_toNNReal, Complex.norm_cpow_eq_rpow_re_of_pos X_pos, norm_toNNReal, abs_two] ++ simp only [nnnorm_real, add_re, mul_re, ofReal_re, I_re, mul_zero, ofReal_im, I_im, ++ mul_one, sub_self, add_zero] ++ simp_rw [MeasureTheory.lintegral_mul_const' (r := ↑(X ^ σ).toNNReal) (hr := by simp), ENNReal.tsum_mul_right] ++ apply ENNReal.mul_lt_top ?_ ENNReal.coe_lt_top ++ ++ conv => ++ arg 1 ++ arg 1 ++ intro i ++ rw [MeasureTheory.lintegral_const_mul' (hr := by simp)] ++ ++ rw [ENNReal.tsum_mul_right] ++ apply ENNReal.mul_lt_top ++ . rw [lt_top_iff_ne_top, ENNReal.tsum_coe_ne_top_iff_summable_coe] ++ push_cast ++ convert (ArithmeticFunction.LSeriesSummable_vonMangoldt (s := σ) ++ (by simp only [ofReal_re]; linarith)).norm ++ rw [LSeries.term_def] ++ split_ifs with h <;> simp[h] ++ . simp_rw [← enorm_eq_nnnorm] ++ rw [← MeasureTheory.hasFiniteIntegral_iff_enorm] ++ exact SmoothedChebyshevDirichlet_aux_integrable diffSmoothingF SmoothingFpos suppSmoothingF ++ mass_one εpos ε_lt_one σ_gt σ_le |>.hasFiniteIntegral ++ ++theorem SmoothedChebyshevDirichlet {SmoothingF : ℝ → ℝ} ++ (diffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ (SmoothingFpos : ∀ x > 0, 0 ≤ SmoothingF x) ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (mass_one: ∫ x in Ioi (0 : ℝ), SmoothingF x / x = 1) ++ {X : ℝ} (X_gt : 3 < X) {ε : ℝ} (εpos: 0 < ε) (ε_lt_one : ε < 1) : ++ SmoothedChebyshev SmoothingF ε X = ++ ∑' n, ArithmeticFunction.vonMangoldt n * Smooth1 SmoothingF ε (n / X) := by ++ dsimp [SmoothedChebyshev, SmoothedChebyshevIntegrand, VerticalIntegral', VerticalIntegral] ++ set σ : ℝ := 1 + (Real.log X)⁻¹ ++ have log_gt : 1 < Real.log X := by ++ rw [Real.lt_log_iff_exp_lt (by linarith : 0 < X)] ++ linarith [Real.exp_one_lt_d9] ++ have σ_gt : 1 < σ := by ++ simp only [σ] ++ have : 0 < (Real.log X)⁻¹ := by ++ simp only [inv_pos] ++ linarith ++ linarith ++ have σ_le : σ ≤ 2 := by ++ simp only [σ] ++ have : (Real.log X)⁻¹ < 1 := inv_lt_one_of_one_lt₀ log_gt ++ linarith ++ calc ++ _ = 1 / (2 * π * I) * (I * ∫ (t : ℝ), ∑' n, Λ n / (n : ℂ) ^ (σ + ↑t * I) * ++ mellin (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑t * I) * X ^ (σ + ↑t * I)) := ?_ ++ _ = 1 / (2 * π * I) * (I * ∑' n, ∫ (t : ℝ), Λ n / (n : ℂ) ^ (σ + ↑t * I) * ++ mellin (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑t * I) * X ^ (σ + ↑t * I)) := ?_ ++ _ = 1 / (2 * π * I) * (I * ∑' n, Λ n * ∫ (t : ℝ), ++ mellin (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑t * I) * (X / (n : ℂ)) ^ (σ + ↑t * I)) := ?_ ++ _ = 1 / (2 * π) * (∑' n, Λ n * ∫ (t : ℝ), ++ mellin (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑t * I) * (X / (n : ℂ)) ^ (σ + ↑t * I)) := ?_ ++ _ = ∑' n, Λ n * (1 / (2 * π) * ∫ (t : ℝ), ++ mellin (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑t * I) * (X / (n : ℂ)) ^ (σ + ↑t * I)) := ?_ ++ _ = ∑' n, Λ n * (1 / (2 * π) * ∫ (t : ℝ), ++ mellin (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ + ↑t * I) * ((n : ℂ) / X) ^ (-(σ + ↑t * I))) := ?_ ++ _ = _ := ?_ ++ · congr; ext t ++ rw [LogDerivativeDirichlet] ++ · rw [← tsum_mul_right, ← tsum_mul_right] ++ · simp [σ_gt] ++ · congr ++ exact SmoothedChebyshevDirichlet_aux_tsum_integral diffSmoothingF SmoothingFpos ++ suppSmoothingF mass_one (by linarith) εpos ε_lt_one σ_gt σ_le ++ · field_simp; congr; ext n; rw [← MeasureTheory.integral_const_mul]; congr; ext t ++ by_cases n_ne_zero : n = 0; simp [n_ne_zero] ++ rw [mul_div_assoc, mul_assoc] ++ congr ++ rw [(div_eq_iff ?_).mpr] ++ have := @mul_cpow_ofReal_nonneg (a := X / (n : ℝ)) (b := (n : ℝ)) (r := σ + t * I) ?_ ?_ ++ push_cast at this ⊢ ++ rw [mul_comm I (↑t : ℂ)] ++ rw [← this, div_mul_cancel₀] ++ · simp only [ne_eq, Nat.cast_eq_zero, n_ne_zero, not_false_eq_true] ++ · apply div_nonneg (by linarith : 0 ≤ X); simp ++ · simp ++ · simp only [ne_eq, cpow_eq_zero_iff, Nat.cast_eq_zero, not_and, not_not] ++ intro hn; exfalso; exact n_ne_zero hn ++ · conv => rw [← mul_assoc, div_mul]; lhs; lhs; rhs; simp ++ · simp_rw [← tsum_mul_left, ← mul_assoc, mul_comm] ++ · have ht (t : ℝ) : -(σ + t * I) = (-1) * (σ + t * I) := by simp ++ have hn (n : ℂ) : (n / X) ^ (-1 : ℂ) = X / n := by simp [cpow_neg_one] ++ have (n : ℕ) : (log ((n : ℂ) / (X : ℂ)) * -1).im = 0 := by ++ simp [Complex.log_im, arg_eq_zero_iff, div_nonneg (Nat.cast_nonneg _) (by linarith : 0 ≤ X)] ++ have h (n : ℕ) (t : ℝ) : ((n : ℂ) / X) ^ ((-1 : ℂ) * (σ + t * I)) = ++ ((n / X) ^ (-1 : ℂ)) ^ (σ + ↑t * I) := by ++ rw [cpow_mul] <;> {rw [this n]; simp [Real.pi_pos, Real.pi_nonneg]} ++ congr 1 ++ funext n ++ ++ simp_rw [ht, h, hn] ++ · push_cast ++ congr ++ ext n ++ by_cases n_zero : n = 0; simp [n_zero] ++ have n_pos : 0 < n := by ++ simpa only [n_zero, gt_iff_lt, false_or] using (Nat.eq_zero_or_pos n) ++ congr ++ rw [(by rw [div_mul]; simp : 1 / (2 * π) = 1 / (2 * π * I) * I), mul_assoc] ++ conv => lhs; rhs; rhs; rhs; intro t; rw [mul_comm]; norm_cast ++ have := MellinInversion σ (f := fun x ↦ (Smooth1 SmoothingF ε x : ℂ)) (x := n / X) ++ ?_ ?_ ?_ ?_ ++ · beta_reduce at this ++ dsimp [MellinInverseTransform, VerticalIntegral] at this ++ rw [this] ++ · exact div_pos (by exact_mod_cast n_pos) (by linarith : 0 < X) ++ · apply Smooth1MellinConvergent diffSmoothingF suppSmoothingF ⟨εpos, ε_lt_one⟩ SmoothingFpos mass_one ++ simp only [ofReal_re] ++ linarith ++ · dsimp [VerticalIntegrable] ++ apply SmoothedChebyshevDirichlet_aux_integrable diffSmoothingF SmoothingFpos ++ suppSmoothingF mass_one εpos ε_lt_one σ_gt σ_le ++ · refine ContinuousAt.comp (g := ofReal) RCLike.continuous_ofReal.continuousAt ?_ ++ exact Smooth1ContinuousAt diffSmoothingF SmoothingFpos suppSmoothingF ++ εpos (by positivity) ++ ++theorem SmoothedChebyshevClose_aux {Smooth1 : (ℝ → ℝ) → ℝ → ℝ → ℝ} (SmoothingF : ℝ → ℝ) ++ (c₁ : ℝ) (c₁_pos : 0 < c₁) (c₁_lt : c₁ < 1) ++ (c₂ : ℝ) (c₂_pos : 0 < c₂) (c₂_lt : c₂ < 2) (hc₂ : ∀ (ε x : ℝ), ε ∈ Ioo 0 1 → 1 + c₂ * ε ≤ x → Smooth1 SmoothingF ε x = 0) ++ (C : ℝ) (C_eq : C = 6 * (3 * c₁ + c₂)) ++ (ε : ℝ) (ε_pos : 0 < ε) (ε_lt_one : ε < 1) ++ (X : ℝ) (X_pos : 0 < X) (X_gt_three : 3 < X) (X_bound_1 : 1 ≤ X * ε * c₁) (X_bound_2 : 1 ≤ X * ε * c₂) ++ (smooth1BddAbove : ∀ (n : ℕ), 0 < n → Smooth1 SmoothingF ε (↑n / X) ≤ 1) ++ (smooth1BddBelow : ∀ (n : ℕ), 0 < n → Smooth1 SmoothingF ε (↑n / X) ≥ 0) ++ (smoothIs1 : ∀ (n : ℕ), 0 < n → ↑n ≤ X * (1 - c₁ * ε) → Smooth1 SmoothingF ε (↑n / X) = 1) ++ (smoothIs0 : ∀ (n : ℕ), 1 + c₂ * ε ≤ ↑n / X → Smooth1 SmoothingF ε (↑n / X) = 0) : ++ ‖(↑((∑' (n : ℕ), ArithmeticFunction.vonMangoldt n * Smooth1 SmoothingF ε (↑n / X))) : ℂ) - ++ ↑((Finset.range ⌊X + 1⌋₊).sum ⇑ArithmeticFunction.vonMangoldt)‖ ≤ ++ C * ε * X * Real.log X := by ++ norm_cast ++ ++ let F := Smooth1 SmoothingF ε ++ ++ let n₀ := ⌈X * (1 - c₁ * ε)⌉₊ ++ ++ have n₀_pos : 0 < n₀ := by ++ simp only [Nat.ceil_pos, n₀] ++ subst C_eq ++ simp_all only [mem_Ioo, and_imp, ge_iff_le, implies_true, mul_pos_iff_of_pos_left, sub_pos] ++ exact (mul_le_of_le_one_right c₁_pos.le ε_lt_one.le).trans_lt c₁_lt ++ ++ have n₀_inside_le_X : X * (1 - c₁ * ε) ≤ X := by ++ nth_rewrite 2 [← mul_one X] ++ apply mul_le_mul_of_nonneg_left _ X_pos.le ++ apply sub_le_self ++ positivity ++ ++ have n₀_le : n₀ ≤ X * ((1 - c₁ * ε)) + 1 := by ++ simp only [n₀] ++ apply le_of_lt ++ exact Nat.ceil_lt_add_one (by bound) ++ ++ have n₀_gt : X * ((1 - c₁ * ε)) ≤ n₀ := by ++ simp only [n₀] ++ exact Nat.le_ceil (X * (1 - c₁ * ε)) ++ ++ have sumΛ : Summable (fun (n : ℕ) ↦ Λ n * F (n / X)) := by ++ exact (summable_of_ne_finset_zero fun a s=>mul_eq_zero_of_right _ ++ (hc₂ _ _ (by trivial) ((le_div_iff₀ X_pos).2 (Nat.ceil_le.1 (not_lt.1 ++ (s ∘ Finset.mem_range.2)))))) ++ ++ have sumΛn₀ (n₀ : ℕ) : Summable (fun n ↦ Λ (n + n₀) * F ((n + n₀) / X)) := by exact_mod_cast sumΛ.comp_injective fun Q=>by valid ++ ++ rw[← Summable.sum_add_tsum_nat_add' (k := n₀) (mod_cast sumΛn₀ n₀)] ++ ++ let n₁ := ⌊X * (1 + c₂ * ε)⌋₊ ++ ++ have n₁_pos : 0 < n₁ := by ++ dsimp only [n₁] ++ apply Nat.le_floor ++ rw[Nat.succ_eq_add_one, zero_add] ++ norm_cast ++ apply one_le_mul_of_one_le_of_one_le (by linarith) ++ apply le_add_of_nonneg_right ++ positivity ++ ++ have n₁_ge : X * (1 + c₂ * ε) - 1 ≤ n₁ := by ++ simp only [tsub_le_iff_right, n₁] ++ exact le_of_lt (Nat.lt_floor_add_one (X * (1 + c₂ * ε))) ++ ++ have n₁_le : (n₁ : ℝ) ≤ X * (1 + c₂ * ε) := by ++ simp only [n₁] ++ exact Nat.floor_le (by bound) ++ ++ have n₁_ge_n₀ : n₀ ≤ n₁ := by ++ have hn : (n₀ : ℝ) ≤ (n₁ : ℝ) := by linarith ++ exact_mod_cast hn ++ ++ have n₁_sub_n₀ : (n₁ : ℝ) - n₀ ≤ X * ε * (c₂ + c₁) := by ++ calc ++ (n₁ : ℝ) - n₀ ≤ X * (1 + c₂ * ε) - n₀ := by ++ exact sub_le_sub_right n₁_le ↑n₀ ++ _ ≤ X * (1 + c₂ * ε) - (X * (1 - c₁ * ε)) := by ++ exact tsub_le_tsub_left n₀_gt (X * (1 + c₂ * ε)) ++ _ = X * ε * (c₂ + c₁) := by ring ++ ++ have : (∑' (n : ℕ), Λ (n + n₀ : ) * F ((n + n₀ : ) / X)) = ++ (∑ n ∈ Finset.range (n₁ - n₀), Λ (n + n₀) * F ((n + n₀) / X)) + ++ (∑' (n : ℕ), Λ (n + n₁ : ) * F ((n + n₁ : ) / X)) := by ++ rw[← Summable.sum_add_tsum_nat_add' (k := n₁ - n₀)] ++ congr! 5 ++ · simp only [Nat.cast_add] ++ · omega ++ · congr! 1 ++ norm_cast ++ omega ++ · convert sumΛn₀ ((n₁ - n₀) + n₀) using 4 ++ · omega ++ · congr! 1 ++ norm_cast ++ omega ++ ++ rw [this] ++ clear this ++ ++ have : (∑' (n : ℕ), Λ (n + n₁) * F (↑(n + n₁) / X)) = Λ (n₁) * F (↑n₁ / X) := by ++ have : (∑' (n : ℕ), Λ (n + n₁) * F (↑(n + n₁) / X)) = Λ (n₁) * F (↑n₁ / X) + (∑' (n : ℕ), Λ (n + 1 + n₁) * F (↑(n + 1 + n₁) / X)) := by ++ let fTemp := fun n ↦ Λ (n + n₁) * F ((↑n + ↑n₁) / X) ++ have sum_fTemp : Summable fTemp := by exact sumΛn₀ n₁ ++ have hTemp (n : ℕ): fTemp n = Λ (n + n₁) * F (↑(n + n₁) / X) := by rw[Nat.cast_add] ++ have : ∑' (n : ℕ), Λ (n + n₁) * F (↑(n + n₁) / X) = ∑' (n : ℕ), fTemp n := by exact Eq.symm (tsum_congr hTemp) ++ rw[this] ++ have (n : ℕ): fTemp (n + 1) = Λ (n + 1 + n₁) * F (↑(n + 1 + n₁) / X) := by exact hTemp (n + 1) ++ have : ∑' (n : ℕ), Λ (n + 1 + n₁) * F (↑(n + 1 + n₁) / X) = ∑' (n : ℕ), fTemp (n + 1) := by exact Eq.symm (tsum_congr this) ++ rw[this] ++ have : Λ n₁ * F (↑n₁ / X) = fTemp 0 := by ++ dsimp only [fTemp] ++ rw[← Nat.cast_add, zero_add] ++ rw[this] ++ exact Summable.tsum_eq_zero_add (sumΛn₀ n₁) ++ rw[this] ++ apply add_eq_left.mpr ++ convert tsum_zero with n ++ have : n₁ ≤ n + (n₁) := by exact Nat.le_add_left (n₁) n ++ convert mul_zero _ ++ convert smoothIs0 (n + 1 + n₁) ?_ ++ rw[← mul_le_mul_iff_left₀ X_pos] ++ have : ↑(n + 1 + n₁) / X * X = ↑(n + 1 + n₁) := by field_simp ++ rw[this] ++ have : (1 + c₂ * ε) * X = 1 + (X * (1 + c₂ * ε) - 1) := by ring ++ rw[this, Nat.cast_add, Nat.cast_add] ++ exact add_le_add (by bound) n₁_ge ++ ++ rw [this] ++ clear this ++ ++ have X_le_floor_add_one : X ≤ ↑⌊X + 1⌋₊ := by ++ rw[Nat.floor_add_one, Nat.cast_add, Nat.cast_one] ++ have temp : X ≤ ↑⌈X⌉₊ := by exact Nat.le_ceil X ++ have : (⌈X⌉₊ : ℝ) ≤ ↑⌊X⌋₊ + 1 := by exact_mod_cast Nat.ceil_le_floor_add_one X ++ exact Preorder.le_trans X (↑⌈X⌉₊) (↑⌊X⌋₊ + 1) temp this ++ positivity ++ ++ have floor_X_add_one_le_self : ↑⌊X + 1⌋₊ ≤ X + 1 := by exact Nat.floor_le (by positivity) ++ ++ have : ∑ x ∈ Finset.range ⌊X + 1⌋₊, Λ x = ++ (∑ x ∈ Finset.range n₀, Λ x) + ++ ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), Λ (x + ↑n₀) := by ++ simp only [add_comm _ n₀] ++ rw [← Finset.sum_range_add, Nat.add_sub_of_le] ++ dsimp only [n₀] ++ refine Nat.ceil_le.mpr ?_ ++ exact Preorder.le_trans (X * (1 - c₁ * ε)) X (↑⌊X + 1⌋₊) n₀_inside_le_X X_le_floor_add_one ++ rw [this] ++ clear this ++ ++ have : ∑ n ∈ Finset.range n₀, Λ n * F (↑n / X) = ++ ∑ n ∈ Finset.range n₀, Λ n := by ++ apply Finset.sum_congr rfl ++ intro n hn ++ by_cases n_zero : n = 0 ++ · rw [n_zero] ++ simp only [ArithmeticFunction.map_zero, CharP.cast_eq_zero, zero_div, zero_mul] ++ · convert mul_one _ ++ convert smoothIs1 n (Nat.zero_lt_of_ne_zero n_zero) ?_ ++ simp only [Finset.mem_range, n₀] at hn ++ have : (n < ⌈X * (1 - c₁ * ε)⌉₊) → (n ≤ ⌊X * (1 - c₁ * ε)⌋₊) := by ++ intro n_lt ++ by_contra hcontra ++ ++ rw[not_le] at hcontra ++ ++ have temp1: (⌊X * (1 - c₁ * ε)⌋₊).succ.succ ≤ n.succ := by ++ apply Nat.succ_le_succ ++ exact Nat.succ_le_of_lt hcontra ++ have : n.succ ≤ ⌈X * (1 - c₁ * ε)⌉₊ := by exact Nat.succ_le_of_lt hn ++ have temp2: ⌊X * (1 - c₁ * ε)⌋₊ + 2 = (⌊X * (1 - c₁ * ε)⌋₊ + 1) + 1 := by ring ++ have : ⌊X * (1 - c₁ * ε)⌋₊ + 2 ≤ ⌈X * (1 - c₁ * ε)⌉₊ := by ++ rw[temp2, ← Nat.succ_eq_add_one, ← Nat.succ_eq_add_one] ++ exact Nat.le_trans temp1 hn ++ rw[← and_not_self_iff (⌊X * (1 - c₁ * ε)⌋₊ + 2 ≤ ⌈X * (1 - c₁ * ε)⌉₊), not_le] ++ apply And.intro ++ exact this ++ rw[temp2, ← Nat.succ_eq_add_one, Nat.lt_succ_iff] ++ exact Nat.ceil_le_floor_add_one (X * (1 - c₁ * ε)) ++ exact (Nat.le_floor_iff' n_zero).mp (this hn) ++ ++ rw [this, sub_eq_add_neg, add_assoc, add_assoc] ++ nth_rewrite 3 [add_comm] ++ nth_rewrite 2 [← add_assoc] ++ rw [← add_assoc, ← add_assoc, ← sub_eq_add_neg] ++ clear this ++ ++ have : ++ ∑ n ∈ Finset.range n₀, Λ n + (∑ n ∈ Finset.range (n₁ - n₀), Λ (n + n₀) * F ((↑n + ↑n₀) / X)) - ++ (∑ x ∈ Finset.range n₀, Λ x + ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), Λ (x + n₀)) ++ = ++ (∑ n ∈ Finset.range (n₁ - n₀), Λ (n + n₀) * F ((↑n + ↑n₀) / X)) - ++ (∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), Λ (x + n₀)) := by ++ ring ++ rw [this] ++ clear this ++ ++ have : ++ ‖∑ n ∈ Finset.range (n₁ - n₀), Λ (n + n₀) * F ((↑n + ↑n₀) / X) - ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), Λ (x + n₀) + Λ n₁ * F (↑n₁ / X)‖ ++ ≤ ++ (∑ n ∈ Finset.range (n₁ - n₀), ‖Λ (n + n₀)‖ * ‖F ((↑n + ↑n₀) / X)‖) + ++ ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), ‖Λ (x + n₀)‖ + ++ ‖Λ n₁‖ * ‖F (↑n₁ / X)‖:= by ++ apply norm_add_le_of_le ++ apply norm_sub_le_of_le ++ apply norm_sum_le_of_le ++ intro b hb ++ exact norm_mul_le_of_le (by rfl) (by rfl) ++ apply norm_sum_le_of_le ++ intro b hb ++ rfl ++ exact_mod_cast norm_mul_le_of_le (by rfl) (by rfl) ++ ++ refine this.trans ?_ ++ ++ clear this ++ ++ have vonBnd1 : ++ ∀ n ∈ Finset.range (n₁ - n₀), ‖Λ (n + n₀)‖ ≤ Real.log (X * (1 + c₂ * ε)) := by ++ intro n hn ++ have n_add_n0_le_n1: (n : ℝ) + n₀ ≤ n₁ := by ++ apply le_of_lt ++ rw[Finset.mem_range] at hn ++ rw[← add_lt_add_iff_right (-↑n₀), add_neg_cancel_right, add_comm, ← sub_eq_neg_add] ++ exact_mod_cast hn ++ have inter1: ‖ Λ (n + n₀)‖ ≤ Real.log (↑n + ↑n₀) := by ++ rw[Real.norm_of_nonneg, ← Nat.cast_add] ++ apply ArithmeticFunction.vonMangoldt_le_log ++ apply ArithmeticFunction.vonMangoldt_nonneg ++ have inter2: Real.log (↑n + ↑n₀) ≤ Real.log (↑n₁) := by exact_mod_cast Real.log_le_log (by positivity) n_add_n0_le_n1 ++ have inter3: Real.log (↑n₁) ≤ Real.log (X * (1 + c₂ * ε)) := by exact Real.log_le_log (by bound) (by linarith) ++ exact inter1.trans (inter2.trans inter3) ++ ++ have bnd1 : ++ ∑ n ∈ Finset.range (n₁ - n₀), ‖Λ (n + n₀)‖ * ‖F ((↑n + ↑n₀) / X)‖ ++ ≤ (n₁ - n₀) * Real.log (X * (1 + c₂ * ε)) := by ++ have : (n₁ - n₀) * Real.log (X * (1 + c₂ * ε)) = (∑ n ∈ Finset.range (n₁ - n₀), Real.log (X * (1 + c₂ * ε))) := by ++ rw[← Nat.cast_sub] ++ nth_rewrite 1 [← Finset.card_range (n₁ - n₀)] ++ rw[Finset.cast_card, Finset.sum_const, smul_one_mul] ++ exact Eq.symm (Finset.sum_const (Real.log (X * (1 + c₂ * ε)))) ++ exact n₁_ge_n₀ ++ rw [this] ++ apply Finset.sum_le_sum ++ intro n hn ++ rw [← mul_one (Real.log (X * (1 + c₂ * ε)))] ++ apply mul_le_mul (vonBnd1 _ hn) _ (norm_nonneg _) (log_nonneg (by bound)) ++ rw[Real.norm_of_nonneg, ← Nat.cast_add] ++ dsimp only [F] ++ apply smooth1BddAbove ++ bound ++ rw[← Nat.cast_add] ++ dsimp only [F] ++ apply smooth1BddBelow ++ bound ++ ++ have bnd2 : ++ ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), ‖Λ (x + n₀)‖ ≤ (⌊X + 1⌋₊ - n₀) * Real.log (X + 1) := by ++ have : (⌊X + 1⌋₊ - n₀) * Real.log (X + 1) = (∑ n ∈ Finset.range (⌊X + 1⌋₊ - n₀), Real.log (X + 1)) := by ++ rw[← Nat.cast_sub] ++ nth_rewrite 1 [← Finset.card_range (⌊X + 1⌋₊ - n₀)] ++ rw[Finset.cast_card, Finset.sum_const, smul_one_mul] ++ exact Eq.symm (Finset.sum_const (Real.log (X + 1))) ++ simp only [Nat.ceil_le, n₀] ++ exact Preorder.le_trans (X * (1 - c₁ * ε)) X (↑⌊X + 1⌋₊) n₀_inside_le_X X_le_floor_add_one ++ rw[this] ++ apply Finset.sum_le_sum ++ intro n hn ++ have n_add_n0_le_X_add_one: (n : ℝ) + n₀ ≤ X + 1 := by ++ rw[Finset.mem_range] at hn ++ rw[← add_le_add_iff_right (-↑n₀), add_assoc, ← sub_eq_add_neg, sub_self, add_zero, ← sub_eq_add_neg] ++ have temp: (n : ℝ) < ⌊X + 1⌋₊ - n₀ := by ++ rw[← Nat.cast_sub, Nat.cast_lt] ++ exact hn ++ simp only [Nat.ceil_le, n₀] ++ exact le_trans n₀_inside_le_X X_le_floor_add_one ++ have : ↑⌊X + 1⌋₊ - ↑n₀ ≤ X + 1 - ↑n₀ := by ++ apply sub_le_sub_right floor_X_add_one_le_self ++ exact le_of_lt (lt_of_le_of_lt' this temp) ++ have inter1: ‖ Λ (n + n₀)‖ ≤ Real.log (↑n + ↑n₀) := by ++ rw[Real.norm_of_nonneg, ← Nat.cast_add] ++ apply ArithmeticFunction.vonMangoldt_le_log ++ apply ArithmeticFunction.vonMangoldt_nonneg ++ apply le_trans inter1 ++ exact_mod_cast Real.log_le_log (by positivity) (n_add_n0_le_X_add_one) ++ ++ have largeSumBound := add_le_add bnd1 bnd2 ++ ++ clear vonBnd1 bnd1 bnd2 ++ ++ have inter1 : Real.log (X * (1 + c₂ * ε)) ≤ Real.log (3 * X) := by ++ apply Real.log_le_log (by positivity) ++ have const_le_2: 1 + c₂ * ε ≤ 3 := by ++ have : (3 : ℝ) = 1 + 2 := by ring ++ rw[this] ++ apply add_le_add_right ++ rw[← mul_one 2] ++ exact mul_le_mul (by linarith) (by linarith) (by positivity) (by positivity) ++ rw[mul_comm] ++ exact mul_le_mul const_le_2 (by rfl) (by positivity) (by positivity) ++ ++ have inter2 : (↑n₁ - ↑n₀) * Real.log (X * (1 + c₂ * ε)) ≤ (X * ε * (c₂ + c₁)) * (Real.log (X) + Real.log (3)) := by ++ apply mul_le_mul n₁_sub_n₀ _ (log_nonneg (by linarith)) (by positivity) ++ rw[← Real.log_mul (by positivity) (by positivity)] ++ nth_rewrite 3 [mul_comm] ++ exact inter1 ++ ++ have inter3 : (X * ε * (c₂ + c₁)) * (Real.log (X) + Real.log (3)) ≤ 2 * (X * ε * (c₂ + c₁)) * (Real.log (X)) := by ++ nth_rewrite 3 [mul_assoc] ++ rw[two_mul, mul_add] ++ apply add_le_add_right ++ apply mul_le_mul_of_nonneg_left _ (by positivity) ++ exact Real.log_le_log (by positivity) (by linarith) ++ ++ have inter4 : (↑n₁ - ↑n₀) * Real.log (X * (1 + c₂ * ε)) ≤ 2 * (X * ε * (c₁ + c₂)) * (Real.log (X)) := by ++ nth_rewrite 2 [add_comm] ++ exact le_trans inter2 inter3 ++ ++ clear inter2 inter3 ++ ++ have inter6 : (⌊X + 1⌋₊ - n₀) * Real.log (X + 1) ≤ 2 * (X * ε * c₁) * (Real.log (X) + Real.log (3)) := by ++ apply mul_le_mul _ _ (log_nonneg (by linarith)) (by positivity) ++ have : 2 * (X * ε * c₁) = (X * (1 + ε * c₁)) - (X * (1 - ε * c₁)) := by ring ++ rw[this] ++ apply sub_le_sub ++ have : X + 1 ≤ X * (1 + ε * c₁) := by ++ ring_nf ++ rw[add_comm, add_le_add_iff_left] ++ exact X_bound_1 ++ exact le_trans floor_X_add_one_le_self this ++ nth_rewrite 2 [mul_comm] ++ exact n₀_gt ++ rw[← Real.log_mul (by positivity) (by norm_num), mul_comm] ++ exact Real.log_le_log (by positivity) (by linarith) ++ ++ have inter7: 2 * (X * ε * c₁) * (Real.log (X) + Real.log (3)) ≤ 4 * (X * ε * c₁) * Real.log (X) := by ++ have : (4 : ℝ) = 2 + 2 := by ring ++ rw[this, mul_add] ++ nth_rewrite 5 [mul_assoc] ++ rw[add_mul] ++ apply add_le_add ++ nth_rewrite 1 [mul_assoc] ++ rfl ++ nth_rewrite 1 [mul_assoc] ++ apply mul_le_mul_of_nonneg_left _ (by norm_num) ++ apply mul_le_mul_of_nonneg_left <| Real.log_le_log (by positivity) (by linarith) ++ positivity ++ ++ have inter9: (↑n₁ - ↑n₀) * Real.log (X * (1 + c₂ * ε)) + (↑⌊X + 1⌋₊ - ↑n₀) * Real.log (X + 1) ≤ ++ 2 * (X * ε * (3 * c₁ + c₂)) * Real.log X := by ++ have : 2 * (X * ε * (3 * c₁ + c₂)) = 2 * (X * ε * (c₁ + c₂)) + 4 * (X * ε * c₁) := by ring ++ rw[this, add_mul] ++ exact add_le_add inter4 <| le_trans inter6 inter7 ++ ++ have largeSumBound2 : ∑ n ∈ Finset.range (n₁ - n₀), ‖Λ (n + n₀)‖ * ‖F ((↑n + ↑n₀) / X)‖ + ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), ‖Λ (x + n₀)‖ ≤ ++ 2 * (X * ε * (3 * c₁ + c₂)) * Real.log X := by ++ exact le_trans largeSumBound inter9 ++ ++ clear largeSumBound inter4 inter9 ++ ++ have inter2 : ‖Λ n₁‖ * ‖F (↑n₁ / X)‖ ≤ Real.log (X * (1 + c₂ * ε)) := by ++ rw[← mul_one (Real.log (X * (1 + c₂ * ε)))] ++ apply mul_le_mul _ _ (norm_nonneg _) (log_nonneg (by bound)) ++ rw[Real.norm_of_nonneg ArithmeticFunction.vonMangoldt_nonneg] ++ exact le_trans ArithmeticFunction.vonMangoldt_le_log <| Real.log_le_log (mod_cast n₁_pos) n₁_le ++ rw[Real.norm_of_nonneg] ++ apply smooth1BddAbove _ n₁_pos ++ apply smooth1BddBelow _ n₁_pos ++ ++ have largeSumBound3 : ∑ n ∈ Finset.range (n₁ - n₀), ‖Λ (n + n₀)‖ * ‖F ((↑n + ↑n₀) / X)‖ + ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), ‖Λ (x + n₀)‖ + ++ ‖Λ n₁‖ * ‖F (↑n₁ / X)‖ ≤ 2 * (X * ε * (3 * c₁ + c₂)) * Real.log X + Real.log (3 * X) := by exact add_le_add largeSumBound2 (le_trans inter2 inter1) ++ clear inter1 inter2 largeSumBound2 ++ ++ have largeSumBound4 : ∑ n ∈ Finset.range (n₁ - n₀), ‖Λ (n + n₀)‖ * ‖F ((↑n + ↑n₀) / X)‖ + ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), ‖Λ (x + n₀)‖ + ++ ‖Λ n₁‖ * ‖F (↑n₁ / X)‖ ≤ 2 * (X * ε * (3 * c₁ + c₂)) * (2 * Real.log X + Real.log (3)) := by ++ nth_rewrite 2 [two_mul, add_assoc] ++ rw [← Real.log_mul (by positivity) (by positivity), mul_comm X 3] ++ apply le_trans largeSumBound3 ++ nth_rewrite 2 [mul_add] ++ apply add_le_add_right ++ nth_rewrite 1 [← one_mul (Real.log (3 * X))] ++ apply mul_le_mul_of_nonneg_right _ (log_nonneg (by linarith)) ++ linarith ++ ++ clear largeSumBound3 ++ ++ have largeSumBoundFinal : ∑ n ∈ Finset.range (n₁ - n₀), ‖Λ (n + n₀)‖ * ‖F ((↑n + ↑n₀) / X)‖ + ∑ x ∈ Finset.range (⌊X + 1⌋₊ - n₀), ‖Λ (x + n₀)‖ + ++ ‖Λ n₁‖ * ‖F (↑n₁ / X)‖ ≤ (6 * (X * ε * (3 * c₁ + c₂))) * Real.log (X) := by ++ apply le_trans largeSumBound4 ++ rw[mul_add] ++ have : (6 : ℝ) = 4 + 2 := by ring ++ rw[this, add_mul, add_mul] ++ apply add_le_add ++ ring_nf ++ rfl ++ apply mul_le_mul_of_nonneg_left _ (by positivity) ++ exact Real.log_le_log (by positivity) (by linarith) ++ ++ clear largeSumBound4 ++ ++ rw[C_eq] ++ linear_combination largeSumBoundFinal ++ ++theorem SmoothedChebyshevClose {SmoothingF : ℝ → ℝ} ++ (diffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (SmoothingFnonneg : ∀ x > 0, 0 ≤ SmoothingF x) ++ (mass_one : ∫ x in Ioi 0, SmoothingF x / x = 1) : ++ ∃ C > 0, ∀ (X : ℝ) (_ : 3 < X) (ε : ℝ) (_ : 0 < ε) (_ : ε < 1) (_ : 2 < X * ε), ++ ‖SmoothedChebyshev SmoothingF ε X - ChebyshevPsi X‖ ≤ C * ε * X * Real.log X := by ++ have vonManBnd (n : ℕ) : ArithmeticFunction.vonMangoldt n ≤ Real.log n := ++ ArithmeticFunction.vonMangoldt_le_log ++ ++ obtain ⟨c₁, c₁_pos, c₁_eq, hc₁⟩ := Smooth1Properties_below suppSmoothingF mass_one ++ ++ obtain ⟨c₂, c₂_pos, c₂_eq, hc₂⟩ := Smooth1Properties_above suppSmoothingF ++ ++ have c₁_lt : c₁ < 1 := by ++ rw[c₁_eq] ++ exact lt_trans (Real.log_two_lt_d9) (by norm_num) ++ ++ have c₂_lt : c₂ < 2 := by ++ rw[c₂_eq] ++ nth_rewrite 3 [← mul_one 2] ++ apply mul_lt_mul' ++ rfl ++ exact lt_trans (Real.log_two_lt_d9) (by norm_num) ++ exact Real.log_nonneg (by norm_num) ++ positivity ++ ++ let C : ℝ := 6 * (3 * c₁ + c₂) ++ have C_eq : C = 6 * (3 * c₁ + c₂) := rfl ++ ++ clear_value C ++ ++ have Cpos : 0 < C := by ++ rw [C_eq] ++ positivity ++ ++ refine ⟨C, Cpos, fun X X_ge_C ε εpos ε_lt_one ↦ ?_⟩ ++ unfold ChebyshevPsi ++ ++ have X_gt_zero : (0 : ℝ) < X := by linarith ++ ++ have X_ne_zero : X ≠ 0 := by linarith ++ ++ have n_on_X_pos {n : ℕ} (npos : 0 < n) : ++ 0 < n / X := by ++ have : (0 : ℝ) < n := by exact_mod_cast npos ++ positivity ++ ++ have smooth1BddAbove (n : ℕ) (npos : 0 < n) : ++ Smooth1 SmoothingF ε (n / X) ≤ 1 := ++ Smooth1LeOne SmoothingFnonneg mass_one εpos (n_on_X_pos npos) ++ ++ have smooth1BddBelow (n : ℕ) (npos : 0 < n) : ++ Smooth1 SmoothingF ε (n / X) ≥ 0 := ++ Smooth1Nonneg SmoothingFnonneg (n_on_X_pos npos) εpos ++ ++ have smoothIs1 (n : ℕ) (npos : 0 < n) (n_le : n ≤ X * (1 - c₁ * ε)) : ++ Smooth1 SmoothingF ε (↑n / X) = 1 := by ++ apply hc₁ (ε := ε) (n / X) εpos (n_on_X_pos npos) ++ exact (div_le_iff₀' X_gt_zero).mpr n_le ++ ++ have smoothIs0 (n : ℕ) (n_le : (1 + c₂ * ε) ≤ n / X) := ++ hc₂ (ε := ε) (n / X) ⟨εpos, ε_lt_one⟩ n_le ++ ++ have ε_pos: ε > 0 := by linarith ++ have X_pos: X > 0 := by linarith ++ have X_gt_three : 3 < X := by linarith ++ ++ intro X_bound ++ ++ have X_bound_1 : 1 ≤ X * ε * c₁ := by ++ rw[c₁_eq, ← div_le_iff₀] ++ have : 1 / Real.log 2 < 2 := by ++ nth_rewrite 2 [← one_div_one_div 2] ++ rw[one_div_lt_one_div] ++ exact lt_of_le_of_lt (by norm_num) (Real.log_two_gt_d9) ++ exact Real.log_pos (by norm_num) ++ norm_num ++ apply le_of_lt ++ exact gt_trans X_bound this ++ exact Real.log_pos (by norm_num) ++ ++ have X_bound_2 : 1 ≤ X * ε * c₂ := by ++ rw[c₂_eq, ← div_le_iff₀] ++ have : 1 / (2 * Real.log 2) < 2 := by ++ nth_rewrite 3 [← one_div_one_div 2] ++ rw[one_div_lt_one_div, ← one_mul (1 / 2)] ++ apply mul_lt_mul ++ norm_num ++ apply le_of_lt ++ exact lt_trans (by norm_num) (Real.log_two_gt_d9) ++ all_goals norm_num ++ exact Real.log_pos (by norm_num) ++ ++ apply le_of_lt ++ exact gt_trans X_bound this ++ norm_num ++ exact Real.log_pos (by norm_num) ++ ++ rw [SmoothedChebyshevDirichlet diffSmoothingF SmoothingFnonneg suppSmoothingF ++ mass_one (by linarith) εpos ε_lt_one] ++ ++ convert SmoothedChebyshevClose_aux SmoothingF c₁ c₁_pos c₁_lt c₂ c₂_pos c₂_lt hc₂ C C_eq ε ε_pos ε_lt_one ++ X X_pos X_gt_three X_bound_1 X_bound_2 smooth1BddAbove smooth1BddBelow smoothIs1 smoothIs0 ++ ++@[inline] noncomputable def sigma1Of (A T : ℝ) : ℝ := 1 - A / Real.log T ++ ++noncomputable def I₁ (SmoothingF : ℝ → ℝ) (ε X T : ℝ) : ℂ := ++ (1 / (2 * π * I)) * (I * (∫ t : ℝ in Iic (-T), ++ SmoothedChebyshevIntegrand SmoothingF ε X ((1 + (Real.log X)⁻¹) + t * I))) ++ ++noncomputable def I₂ (SmoothingF : ℝ → ℝ) (ε T X σ₁ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * ((∫ σ in σ₁..(1 + (Real.log X)⁻¹), ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ - T * I))) ++ ++noncomputable def I₃₇ (SmoothingF : ℝ → ℝ) (ε T X σ₁ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * (I * (∫ t in (-T)..T, ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ₁ + t * I))) ++ ++noncomputable def I₈ (SmoothingF : ℝ → ℝ) (ε T X σ₁ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * ((∫ σ in σ₁..(1 + (Real.log X)⁻¹), ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ + T * I))) ++ ++noncomputable def I₉ (SmoothingF : ℝ → ℝ) (ε X T : ℝ) : ℂ := ++ (1 / (2 * π * I)) * (I * (∫ t : ℝ in Ici T, ++ SmoothedChebyshevIntegrand SmoothingF ε X ((1 + (Real.log X)⁻¹) + t * I))) ++ ++noncomputable def I₃ (SmoothingF : ℝ → ℝ) (ε T X σ₁ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * (I * (∫ t in (-T)..(-3), ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ₁ + t * I))) ++ ++noncomputable def I₇ (SmoothingF : ℝ → ℝ) (ε T X σ₁ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * (I * (∫ t in (3 : ℝ)..T, ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ₁ + t * I))) ++ ++noncomputable def I₄ (SmoothingF : ℝ → ℝ) (ε X σ₁ σ₂ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * ((∫ σ in σ₂..σ₁, ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ - 3 * I))) ++ ++noncomputable def I₆ (SmoothingF : ℝ → ℝ) (ε X σ₁ σ₂ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * ((∫ σ in σ₂..σ₁, ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ + 3 * I))) ++ ++noncomputable def I₅ (SmoothingF : ℝ → ℝ) (ε X σ₂ : ℝ) : ℂ := ++ (1 / (2 * π * I)) * (I * (∫ t in (-3)..3, ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ₂ + t * I))) ++ ++theorem realDiff_of_complexDiff {f : ℂ → ℂ} (s : ℂ) (hf : DifferentiableAt ℂ f s) : ++ ContinuousAt (fun (x : ℝ) ↦ f (s.re + x * I)) s.im := by ++ apply ContinuousAt.comp _ (by fun_prop) ++ convert hf.continuousAt ++ simp ++ ++theorem riemannZeta_bdd_on_vertical_lines {σ₀ : ℝ} (σ₀_gt : 1 < σ₀) (t : ℝ) : ++ ∃ c > 0, ‖ζ (σ₀ + t * I)‖ ≤ c := ++ by ++ let s := σ₀ + t * I ++ let s_re : ℂ := σ₀ ++ ++ have H : s.re = σ₀ := by ++ rw [add_re, ofReal_re, mul_re, ofReal_re, I_re, I_im] ++ simp ++ ++ have non_neg : σ₀ ≠ 0 := by ++ by_contra h ++ rw [h] at σ₀_gt ++ norm_cast at σ₀_gt ++ ++ have pos : s.re > 1 := by exact lt_of_lt_of_eq σ₀_gt (id (Eq.symm H)) ++ have pos_triv : s_re.re > 1 := by exact σ₀_gt ++ ++ have series := LSeries_one_eq_riemannZeta pos ++ rw [← series] ++ ++ have identity : ∀(n : ℕ), ‖LSeries.term 1 s n‖ = 1 / n^σ₀ := by ++ unfold LSeries.term ++ intro n ++ by_cases h0 : n = 0 ++ · simp [*] ++ · simp [*] ++ push Not at h0 ++ have C : n > 0 := by exact Nat.zero_lt_of_ne_zero h0 ++ have T := Complex.norm_natCast_cpow_of_pos C s ++ rw [H] at T ++ exact T ++ ++ have summable : Summable (fun (n : ℕ) ↦ ‖LSeries.term 1 s n‖) := by ++ simp [identity] ++ exact σ₀_gt ++ ++ have B := calc ++ ‖∑' (n : ℕ), LSeries.term 1 s n‖ ≤ ∑' (n : ℕ), ‖LSeries.term 1 s n‖ := norm_tsum_le_tsum_norm summable ++ _ ≤ ∑' (n : ℕ), (1 / ↑n^σ₀) := by simp [← identity] ++ _ ≤ norm (∑' (n : ℕ), (1 / ↑n^σ₀) : ℝ ) := by exact le_norm_self (∑' (n : ℕ), 1 / ↑n ^ σ₀) ++ _ ≤ 1 + norm (∑' (n : ℕ), (1 / ↑n^σ₀) : ℝ ) := by linarith ++ ++ let c : ℝ := 1 + norm (∑' (n : ℕ), (1 / ↑n^σ₀) : ℝ ) ++ ++ have c_is_pos : c > 0 := by positivity ++ use (1 + norm (∑' (n : ℕ), (1 / ↑n^σ₀) : ℝ )) ++ exact ⟨c_is_pos, B⟩ ++ ++theorem summable_real_iff_summable_coe_complex (f : ℕ → ℝ) : ++ Summable f ↔ Summable (fun n => (f n : ℂ)) := by ++ constructor ++ ++ · intro ⟨s, hs⟩ ++ use (s : ℂ) ++ exact hasSum_ofReal.mpr hs ++ ++ · intro ⟨s, hs⟩ ++ use s.re ++ have h_re : HasSum (fun n => ((f n : ℂ)).re) s.re := ++ by exact hasSum_re hs ++ simpa using! h_re ++ ++theorem cast_pow_eq (n : ℕ) (σ₀ : ℝ): ++ (↑((↑n : ℝ) ^ σ₀) : ℂ ) = (↑n : ℂ) ^ (↑σ₀ : ℂ) := by ++ have U : (↑n : ℝ) ≥ 0 := by exact Nat.cast_nonneg' n ++ have endit := Complex.ofReal_cpow U σ₀ ++ exact endit ++ ++theorem strongPnt_summable_complex_then_summable_real_part (f : ℕ → ℂ) : ++ Summable f → Summable (fun n ↦ (f n).re) := by ++ intro ⟨s, hs⟩ ++ use s.re ++ have h_re : HasSum (fun n => ((f n : ℂ)).re) s.re := ++ by exact hasSum_re hs ++ convert h_re using 1 ++ ++theorem strongPnt_dlog_riemannZeta_bdd_on_vertical_lines_generalized : ++ ∀(σ₀ σ₁ : ℝ), ∀(t : ℝ), 1 < σ₀ → σ₀ ≤ σ₁ → ++ ‖(- ζ' (σ₁ + t * I) / ζ (σ₁ + t * I))‖ ≤ ‖ζ' σ₀ / ζ σ₀‖ := by ++ intro σ₀ σ₁ t σ₀_gt_one σ₀_lt_σ₁ ++ ++ let s₁ := σ₁ + t * I ++ have s₁_re_eq_sigma : s₁.re = σ₁ := by ++ rw [Complex.add_re (σ₁) (t * I)] ++ rw [Complex.ofReal_re σ₁] ++ rw [Complex.mul_I_re] ++ simp [*] ++ ++ have s₀_re_eq_sigma : (↑σ₀ : ℂ).re = σ₀ := by ++ rw [Complex.ofReal_re σ₀] ++ ++ let s₀ := σ₀ ++ ++ have σ₁_gt_one : 1 < σ₁ := by exact lt_of_le_of_lt' σ₀_lt_σ₁ σ₀_gt_one ++ have s₀_gt_one : 1 < (↑σ₀ : ℂ).re := by exact σ₀_gt_one ++ ++ have s₁_re_geq_one : 1 < s₁.re := by exact lt_of_lt_of_eq σ₁_gt_one (id (Eq.symm s₁_re_eq_sigma)) ++ have s₁_re_coerce_geq_one : 1 < (↑s₁.re : ℂ).re := by exact s₁_re_geq_one ++ rw [← (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div s₁_re_geq_one)] ++ unfold LSeries ++ ++ have summable_von_mangoldt : Summable (fun i ↦ LSeries.term (fun n ↦ ↑(Λ n)) s₁.re i) := by ++ exact ArithmeticFunction.LSeriesSummable_vonMangoldt s₁_re_geq_one ++ ++ have summable_von_mangoldt_at_σ₀ : Summable (fun i ↦ LSeries.term (fun n ↦ ↑(Λ n)) σ₀ i) := by ++ exact ArithmeticFunction.LSeriesSummable_vonMangoldt σ₀_gt_one ++ ++ have summable_re_von_mangoldt : Summable (fun i ↦ (LSeries.term (fun n ↦ ↑(Λ n)) s₁.re i).re) := by ++ exact strongPnt_summable_complex_then_summable_real_part (LSeries.term (fun n ↦ ↑(Λ n)) s₁.re) summable_von_mangoldt ++ ++ have summable_re_von_mangoldt_at_σ₀ : Summable (fun i ↦ (LSeries.term (fun n ↦ ↑(Λ n)) σ₀ i).re) := by ++ exact strongPnt_summable_complex_then_summable_real_part (LSeries.term (fun n ↦ ↑(Λ n)) σ₀) summable_von_mangoldt_at_σ₀ ++ ++ have positivity : ∀(n : ℕ), ‖LSeries.term (fun n ↦ ↑(Λ n)) s₁ n‖ = (LSeries.term (fun n ↦ Λ n) s₁.re n).re := by ++ intro n ++ calc ++ ‖LSeries.term (fun n ↦ ↑(Λ n)) s₁ n‖ = Λ n / ‖(↑n : ℂ)^(s₁ : ℂ)‖ := by ++ unfold LSeries.term ++ by_cases h : n = 0 ++ · simp [*] ++ · push Not at h ++ simp [*] ++ ++ _ = Λ n / (↑n)^s₁.re := by ++ by_cases h : n = 0 ++ · simp [*] ++ · rw [Complex.norm_natCast_cpow_of_pos] ++ push Not at h ++ exact Nat.zero_lt_of_ne_zero h ++ ++ _ = (LSeries.term (fun n ↦ Λ n) s₁.re n).re := by ++ unfold LSeries.term ++ by_cases h : n = 0 ++ · simp [*] ++ · simp [*] ++ push Not at h ++ ring_nf ++ rw [Complex.re_ofReal_mul (Λ n)] ++ ring_nf ++ rw [Complex.inv_re] ++ rw [Complex.cpow_ofReal_re] ++ simp [*] ++ left ++ have N : (0 : ℝ) ≤ ↑n := by exact Nat.cast_nonneg' n ++ have T2 : ((↑n : ℂ) ^ (↑σ₁ : ℂ)).re = (↑n : ℝ)^σ₁ := by exact rfl ++ have T1 : ((↑n : ℂ ) ^ (↑σ₁ : ℂ)).im = 0 := by ++ refine abs_re_eq_norm.mp ?_ ++ rw [T2] ++ simp [*] ++ exact Real.rpow_nonneg N σ₁ ++ ++ simp [Complex.normSq_apply] ++ simp [T1, T2] ++ ++ have summable_abs_value : Summable (fun i ↦ ‖LSeries.term (fun n ↦ ↑(Λ n)) s₁ i‖) := by ++ rw [summable_congr positivity] ++ exact summable_re_von_mangoldt ++ ++ have triangle_ineq : ‖LSeries (fun n ↦ ↑(Λ n)) s₁‖ ≤ ∑' (n : ℕ), ↑‖LSeries.term (fun n ↦ ↑(Λ n)) s₁ n‖ := ++ norm_tsum_le_tsum_norm summable_abs_value ++ ++ have bounded_by_sum_of_re : ‖LSeries (fun n ↦ ↑(Λ n)) s₁‖ ≤ ∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s₁.re) n).re := ++ by ++ simp [positivity] at triangle_ineq ++ exact triangle_ineq ++ ++ have sum_of_re_commutes : ∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s₁.re) n).re = (∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s₁.re) n)).re := ++ (Complex.re_tsum (summable_von_mangoldt)).symm ++ ++ have re_of_sum_bdd_by_norm : (∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s₁.re) n)).re ≤ ‖∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s₁.re) n)‖ := ++ Complex.re_le_norm (∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s₁.re) n)) ++ ++ have ineq_s₁_s₀ : ∀(n : ℕ), ++ (LSeries.term (fun n ↦ Λ n) s₁.re n).re ≤ (LSeries.term (fun n ↦ Λ n) σ₀ n).re := ++ by ++ intro n ++ unfold LSeries.term ++ by_cases h : n = 0 ++ · simp [*] ++ · push Not at h ++ simp [*] ++ have H : 0 ≤ Λ n := ArithmeticFunction.vonMangoldt_nonneg ++ ring_nf ++ rw [Complex.re_ofReal_mul (Λ n) ((↑n : ℂ) ^ (↑σ₁ : ℂ))⁻¹] ++ rw [Complex.re_ofReal_mul (Λ n) ((↑n : ℂ) ^ (↑σ₀ : ℂ))⁻¹] ++ refine mul_le_mul_of_nonneg_left ?_ H ++ · simp [Complex.inv_re] ++ have R1 : ((↑n : ℂ) ^ (↑σ₀ : ℂ)).re = (↑n : ℝ) ^ σ₀ := rfl ++ have R2 : ((↑n : ℂ) ^ (↑σ₁ : ℂ)).re = (↑n : ℝ) ^ σ₁ := rfl ++ have geq : 1 ≤ n := Nat.one_le_iff_ne_zero.mpr h ++ have geq_zero : 0 ≤ n := Nat.zero_le n ++ have n_geq_one : (1 : ℝ) ≤ ↑n := by ++ norm_cast ++ have n_geq_pos : (0 : ℝ) ≤ ↑n := by ++ norm_cast ++ have n_gt_pos : (0 : ℝ) < (↑n) := by ++ norm_cast ++ ++ have I1 : ((↑n : ℂ) ^ (↑σ₀ : ℂ)).im = 0 := by ++ refine abs_re_eq_norm.mp ?_ ++ rw [R1] ++ simp [*] ++ exact Real.rpow_nonneg n_geq_pos σ₀ ++ ++ have I2 : ((↑n : ℂ) ^ (↑σ₁ : ℂ)).im = 0 := by ++ refine abs_re_eq_norm.mp ?_ ++ rw [R2] ++ simp [*] ++ exact Real.rpow_nonneg n_geq_pos σ₁ ++ ++ simp [Complex.normSq_apply, R1, R2, I1, I2] ++ have P1 : 0 < (↑n : ℝ)^σ₁ := Real.rpow_pos_of_pos n_gt_pos σ₁ ++ have P2 : 0 < (↑n : ℝ)^σ₀ := Real.rpow_pos_of_pos n_gt_pos σ₀ ++ ++ have N : (↑n : ℝ)^σ₀ ≤ (↑n : ℝ)^σ₁ := ++ Real.rpow_le_rpow_of_exponent_le n_geq_one σ₀_lt_σ₁ ++ apply inv_anti₀ ++ · exact P2 ++ · exact N ++ ++ have Z := ++ by ++ calc ++ ‖LSeries (fun n ↦ ↑(Λ n)) s₁‖ ≤ ∑' (n : ℕ), ‖LSeries.term (fun n ↦ ↑(Λ n)) s₁ n‖ ++ := norm_tsum_le_tsum_norm summable_abs_value ++ _ ≤ ∑' (n : ℕ), (LSeries.term (fun n ↦ Λ n) s₁.re n).re := by simp [←positivity] ++ _ ≤ ∑' (n : ℕ), (LSeries.term (fun n ↦ Λ n) σ₀ n).re := by ++ refine Summable.tsum_mono ?_ ?_ ineq_s₁_s₀ ++ · exact summable_re_von_mangoldt ++ · exact summable_re_von_mangoldt_at_σ₀ ++ _ = (∑' (n : ℕ), (LSeries.term (fun n ↦ Λ n) σ₀ n)).re := (Complex.re_tsum (summable_von_mangoldt_at_σ₀)).symm ++ _ ≤ ‖∑' (n : ℕ), (LSeries.term (fun n ↦ Λ n) σ₀ n)‖ := re_le_norm (∑' (n : ℕ), LSeries.term (fun n ↦ ↑(Λ n)) σ₀ n) ++ _ = ‖- ζ' (σ₀) / ζ (σ₀)‖ := by ++ simp only [← (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div s₀_gt_one)] ++ unfold LSeries ++ rfl ++ _ = ‖ζ' σ₀ / ζ σ₀‖ := by ++ rw [← s₀_re_eq_sigma] ++ simp [*] ++ ++ exact Z ++ ++theorem strongPnt_triv_bound_zeta : ++ ∃C ≥ 0, ∀(σ₀ t : ℝ), 1 < σ₀ → ‖- ζ' (σ₀ + t * I) / ζ (σ₀ + t * I)‖ ≤ (σ₀ - 1)⁻¹ + C ++ := by ++ ++ let ⟨U, ⟨U_in_nhds, zeta_residue_on_U⟩⟩ := riemannZetaLogDerivResidue ++ ++ let ⟨open_in_U, ⟨open_in_U_subs_U, open_in_U_is_open, one_in_open_U⟩⟩ := mem_nhds_iff.mp U_in_nhds ++ ++ let ⟨ε₀, ⟨ε_pos, metric_ball_around_1_is_in_U'⟩⟩ := EMetric.isOpen_iff.mp open_in_U_is_open (1 : ℂ) one_in_open_U ++ ++ let ε := if ε₀ = ⊤ then ENNReal.ofReal 1 else ε₀ ++ have O1 : ε ≠ ⊤ := by ++ by_cases h : ε₀ = ⊤ ++ · unfold ε ++ simp [*] ++ · unfold ε ++ simp [*] ++ ++ have metric_ball_around_1_is_in_U : ++ Metric.eball (1 : ℂ) ε ⊆ U := by ++ by_cases h : ε₀ = ⊤ ++ · unfold ε ++ simp [*] ++ have T : Metric.eball (1 : ℂ) 1 ⊆ Metric.eball 1 ε₀ := by ++ rw [h] ++ exact Metric.eball_subset_eball (by simp) ++ exact subset_trans (subset_trans T metric_ball_around_1_is_in_U') open_in_U_subs_U ++ ++ · unfold ε ++ ++ simp [h] ++ exact subset_trans metric_ball_around_1_is_in_U' open_in_U_subs_U ++ ++ have O2 : ε ≠ 0 := by ++ by_cases h : ε₀ = ⊤ ++ · unfold ε ++ simp [*] ++ · unfold ε ++ simp [*] ++ exact pos_iff_ne_zero.mp ε_pos ++ ++ let metric_ball_around_1 := Metric.eball (1 : ℂ) ε ++ let ε_div_two := ε / 2 ++ let boundary := ENNReal.toReal (1 + ε_div_two) ++ ++ let ⟨bound, ⟨bound_pos, bound_prop⟩⟩ := ++ BddAbove.exists_ge zeta_residue_on_U 0 ++ ++ have boundary_geq_one : 1 < boundary := by ++ unfold boundary ++ have Z : (1 : ENNReal).toReal = 1 := by rfl ++ rw [←Z] ++ have U : ε_div_two ≠ ⊤ := by ++ refine ENNReal.div_ne_top O1 ?_ ++ simp ++ simp ++ simp [ENNReal.toReal_add _ U] ++ refine ENNReal.toReal_pos ?_ ?_ ++ · unfold ε_div_two ++ simp [*] ++ · exact U ++ ++ let const : ℝ := bound ++ let final_const : ℝ := (boundary - 1)⁻¹ + const ++ have boundary_inv_pos : 0 < (boundary - 1)⁻¹ := by ++ ring_nf ++ apply inv_pos_of_pos ++ simp [*] ++ ++ have final_const_pos : final_const ≥ 0 := by ++ unfold final_const ++ simp [*] ++ have Z := ++ by ++ calc ++ 0 ≤ (boundary - 1)⁻¹ := by simp; linarith ++ _ ≤ (boundary - 1)⁻¹ + const := by unfold const; simp [bound_pos] ++ ++ exact Z ++ ++ have const_le_final_const : const ≤ final_const := by ++ calc ++ const ≤ (boundary - 1)⁻¹ + const := by simp; linarith ++ _ = final_const := by rfl ++ ++ have const_pos : const ≥ 0 := by ++ linarith ++ ++ use final_const ++ use final_const_pos ++ intro σ₀ t σ₀_gt ++ ++ by_cases h : σ₀ ≤ boundary ++ · have σ₀_in_ball : (↑σ₀ : ℂ) ∈ metric_ball_around_1 := by ++ unfold metric_ball_around_1 ++ unfold Metric.eball ++ simp [*] ++ have Z := edist_dist (↑σ₀) (↑1 : ℂ) ++ rw [Z] ++ have U := dist_eq_norm (↑σ₀) (↑1 : ℂ) ++ rw [U] ++ norm_cast ++ have U : 0 ≤ σ₀ - 1 := by linarith ++ have U1 : ‖σ₀ - 1‖ = σ₀ - 1 := by exact norm_of_nonneg U ++ have U2 : ε ≠ ⊤ := by exact O1 ++ have U3 : 0 ≤ ε := by exact zero_le ++ simp [Real.norm_of_nonneg U] ++ simp [ENNReal.ofReal_lt_iff_lt_toReal U U2] ++ have U4 : ENNReal.ofReal 1 ≠ ⊤ := by exact ENNReal.ofReal_ne_top ++ have Z0 : ε_div_two.toReal < ε.toReal := by ++ have T1 : ε ≠ ⊤ := by exact U2 ++ have T2 : ε ≠ 0 := by exact O2 ++ have T3 : ε_div_two < ε := by ++ refine ENNReal.half_lt_self ?_ U2 ++ exact T2 ++ ++ exact ENNReal.toReal_strict_mono T1 T3 ++ ++ have Z := by ++ calc ++ σ₀ - 1 ≤ boundary - 1 := by linarith ++ _ = ENNReal.toReal (1 + ε_div_two) - 1 := rfl ++ _ = ENNReal.toReal (1 + ε_div_two) - ENNReal.toReal (ENNReal.ofReal 1) := by simp ++ _ ≤ ENNReal.toReal (1 + ε_div_two - ENNReal.ofReal 1) := ENNReal.le_toReal_sub U4 ++ _ = ENNReal.toReal (ε_div_two) := by simp only [ENNReal.ofReal_one, ENNReal.addLECancellable_iff_ne, ne_eq, ENNReal.one_ne_top, not_false_eq_true, AddLECancellable.add_tsub_cancel_left] ++ _ < ε.toReal := Z0 ++ ++ exact Z ++ ++ have σ₀_in_U : (↑σ₀ : ℂ) ∈ (U \ {1}) := by ++ refine mem_sdiff_singleton.mpr ?_ ++ constructor ++ · unfold metric_ball_around_1 at σ₀_in_ball ++ exact metric_ball_around_1_is_in_U σ₀_in_ball ++ · by_contra a ++ have U : σ₀ = 1 := by exact ofReal_eq_one.mp a ++ rw [U] at σ₀_gt ++ linarith ++ ++ have bdd := Set.forall_mem_image.mp bound_prop (σ₀_in_U) ++ simp [*] at bdd ++ have Z := ++ calc ++ ‖- ζ' (σ₀ + t * I) / ζ (σ₀ + t * I)‖ ≤ ‖ζ' σ₀ / ζ σ₀‖ := by ++ have U := strongPnt_dlog_riemannZeta_bdd_on_vertical_lines_generalized σ₀ σ₀ t (σ₀_gt) (by simp) ++ exact U ++ _ = ‖- ζ' σ₀ / ζ σ₀‖ := by simp only [Complex.norm_div, norm_neg] ++ _ = ‖(- ζ' σ₀ / ζ σ₀ - (σ₀ - 1)⁻¹) + (σ₀ - 1)⁻¹‖ := by simp only [Complex.norm_div, norm_neg, ofReal_inv, ofReal_sub, ofReal_one, sub_add_cancel] ++ _ ≤ ‖(- ζ' σ₀ / ζ σ₀ - (σ₀ - 1)⁻¹)‖ + ‖(σ₀ - 1)⁻¹‖ := by ++ have Z := norm_add_le (- ζ' σ₀ / ζ σ₀ - (σ₀ - 1)⁻¹) ((σ₀ - 1)⁻¹) ++ norm_cast at Z ++ _ ≤ const + ‖(σ₀ - 1)⁻¹‖ := by ++ have U := add_le_add_left bdd ‖(σ₀ - 1)⁻¹‖ ++ ring_nf at U ++ ring_nf ++ norm_cast at U ++ norm_cast ++ _ ≤ const + (σ₀ - 1)⁻¹ := by ++ simp [norm_inv] ++ have pos : 0 ≤ σ₀ - 1 := by ++ linarith ++ simp [abs_of_nonneg pos] ++ _ = (σ₀ - 1)⁻¹ + const := by ++ rw [add_comm] ++ _ ≤ (σ₀ - 1)⁻¹ + final_const := by ++ simp [const_le_final_const] ++ ++ exact Z ++ ++ · push Not at h ++ ++ have boundary_geq_one : 1 < boundary := by ++ unfold boundary ++ have Z : (1 : ENNReal).toReal = 1 := by rfl ++ rw [←Z] ++ have U : ε_div_two ≠ ⊤ := by ++ refine ENNReal.div_ne_top O1 ?_ ++ simp ++ simp ++ simp [ENNReal.toReal_add _ U] ++ refine ENNReal.toReal_pos ?_ ?_ ++ · unfold ε_div_two ++ simp [*] ++ · exact U ++ ++ have boundary_in_ball : (↑boundary : ℂ) ∈ metric_ball_around_1 := by ++ unfold metric_ball_around_1 ++ unfold Metric.eball ++ simp [*] ++ have Z := edist_dist (↑boundary) (↑1 : ℂ) ++ rw [Z] ++ have U := dist_eq_norm (↑boundary) (↑1 : ℂ) ++ rw [U] ++ norm_cast ++ have U : 0 ≤ boundary - 1 := by linarith ++ have U1 : ‖boundary - 1‖ = boundary - 1 := by exact norm_of_nonneg U ++ have U2 : ε ≠ ⊤ := by exact O1 ++ have U3 : 0 ≤ ε := by exact zero_le ++ simp [Real.norm_of_nonneg U] ++ simp [ENNReal.ofReal_lt_iff_lt_toReal U U2] ++ have U4 : ENNReal.ofReal 1 ≠ ⊤ := by exact ENNReal.ofReal_ne_top ++ have Z0 : ε_div_two.toReal < ε.toReal := by ++ have T1 : ε ≠ ⊤ := by exact U2 ++ have T2 : ε ≠ 0 := by exact O2 ++ have T3 : ε_div_two < ε := by ++ refine ENNReal.half_lt_self ?_ U2 ++ exact T2 ++ ++ exact ENNReal.toReal_strict_mono T1 T3 ++ ++ have Z := by ++ calc ++ boundary - 1 ≤ boundary - 1 := by linarith ++ _ = ENNReal.toReal (1 + ε_div_two) - 1 := rfl ++ _ = ENNReal.toReal (1 + ε_div_two) - ENNReal.toReal (ENNReal.ofReal 1) := by simp ++ _ ≤ ENNReal.toReal (1 + ε_div_two - ENNReal.ofReal 1) := ENNReal.le_toReal_sub U4 ++ _ = ENNReal.toReal (ε_div_two) := by simp only [ENNReal.ofReal_one, ENNReal.addLECancellable_iff_ne, ne_eq, ENNReal.one_ne_top, not_false_eq_true, AddLECancellable.add_tsub_cancel_left] ++ _ < ε.toReal := Z0 ++ ++ exact Z ++ ++ have boundary_in_U : (↑boundary : ℂ) ∈ U \ {1} := by ++ refine mem_sdiff_singleton.mpr ?_ ++ constructor ++ · unfold metric_ball_around_1 at boundary_in_ball ++ exact metric_ball_around_1_is_in_U boundary_in_ball ++ · by_contra a ++ norm_cast at a ++ norm_cast at boundary_geq_one ++ simp [←a] at boundary_geq_one ++ ++ have bdd := Set.forall_mem_image.mp bound_prop (boundary_in_U) ++ ++ have Z := ++ calc ++ ‖- ζ' (σ₀ + t * I) / ζ (σ₀ + t * I)‖ ≤ ‖ζ' boundary / ζ boundary‖ := by ++ have U := strongPnt_dlog_riemannZeta_bdd_on_vertical_lines_generalized boundary σ₀ t (boundary_geq_one) (by linarith) ++ exact U ++ _ = ‖- ζ' boundary / ζ boundary‖ := by simp only [Complex.norm_div, norm_neg] ++ _ = ‖(- ζ' boundary / ζ boundary - (boundary - 1)⁻¹) + (boundary - 1)⁻¹‖ := by simp only [Complex.norm_div, norm_neg, ofReal_inv, ofReal_sub, ofReal_one, sub_add_cancel] ++ _ ≤ ‖(- ζ' boundary / ζ boundary - (boundary - 1)⁻¹)‖ + ‖(boundary - 1)⁻¹‖ := by ++ have Z := norm_add_le (- ζ' boundary / ζ boundary - (boundary - 1)⁻¹) ((boundary - 1)⁻¹) ++ norm_cast at Z ++ _ ≤ const + ‖(boundary - 1)⁻¹‖ := by ++ have U9 := add_le_add_left bdd ‖(boundary - 1)⁻¹‖ ++ ring_nf at U9 ++ ring_nf ++ norm_cast at U9 ++ norm_cast ++ simp [*] at U9 ++ simp [*] ++ exact U9 ++ ++ _ ≤ const + (boundary - 1)⁻¹ := by ++ simp [norm_inv] ++ have pos : 0 ≤ boundary - 1 := by ++ linarith ++ simp [abs_of_nonneg pos] ++ _ = (boundary - 1)⁻¹ + const := by ++ rw [add_comm] ++ _ = final_const := by rfl ++ _ ≤ (σ₀ - 1)⁻¹ + final_const := by ++ have H : 0 ≤ (σ₀ - 1)⁻¹ := by ++ simp ++ linarith ++ ++ simp [H] ++ ++ exact Z ++ ++def LogDerivZetaHasBound (A C : ℝ) : Prop := ∀ (σ : ℝ) (t : ℝ) (_ : 3 < |t|) ++ (_ : σ ∈ Ici (1 - A / Real.log |t|)), ‖ζ' (σ + t * I) / ζ (σ + t * I)‖ ≤ ++ C * Real.log |t| ^ 9 ++ ++def LogDerivZetaIsHoloSmall (σ₂ : ℝ) : Prop := ++ HolomorphicOn (fun (s : ℂ) ↦ ζ' s / (ζ s)) ++ (((uIcc σ₂ 2) ×ℂ (uIcc (-3) 3)) \ {1}) ++ ++theorem dlog_riemannZeta_bdd_on_vertical_lines_explicit {σ₀ : ℝ} (σ₀_gt : 1 < σ₀) : ++ ∀(t : ℝ), ‖(-ζ' (σ₀ + t * I) / ζ (σ₀ + t * I))‖ ≤ ‖(ζ' σ₀ / ζ σ₀)‖ := by ++ ++ intro t ++ let s := σ₀ + t * I ++ have s_re_eq_sigma : s.re = σ₀ := by ++ rw [Complex.add_re (σ₀) (t * I)] ++ rw [Complex.ofReal_re σ₀] ++ rw [Complex.mul_I_re] ++ simp [*] ++ ++ have s₀_geq_one : 1 < (↑σ₀ : ℂ).re := by exact σ₀_gt ++ have s_re_geq_one : 1 < s.re := by exact lt_of_lt_of_eq σ₀_gt (id (Eq.symm s_re_eq_sigma)) ++ have s_re_coerce_geq_one : 1 < (↑s.re : ℂ).re := by exact s_re_geq_one ++ rw [← (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div s_re_geq_one)] ++ unfold LSeries ++ ++ have summable_von_mangoldt : Summable (fun i ↦ LSeries.term (fun n ↦ ↑(Λ n)) s.re i) := by ++ exact ArithmeticFunction.LSeriesSummable_vonMangoldt s_re_geq_one ++ ++ have summable_von_mangoldt_at_σ₀ : Summable (fun i ↦ LSeries.term (fun n ↦ ↑(Λ n)) σ₀ i) := by ++ exact ArithmeticFunction.LSeriesSummable_vonMangoldt s₀_geq_one ++ ++ have summable_re_von_mangoldt : Summable (fun i ↦ (LSeries.term (fun n ↦ ↑(Λ n)) s.re i).re) := by ++ exact strongPnt_summable_complex_then_summable_real_part (LSeries.term (fun n ↦ ↑(Λ n)) s.re) summable_von_mangoldt ++ ++ have positivity : ∀(n : ℕ), ‖LSeries.term (fun n ↦ ↑(Λ n)) s n‖ = (LSeries.term (fun n ↦ Λ n) s.re n).re := by ++ intro n ++ calc ++ ‖LSeries.term (fun n ↦ ↑(Λ n)) s n‖ = Λ n / ‖(↑n : ℂ)^(s : ℂ)‖ := by ++ unfold LSeries.term ++ by_cases h : n = 0 ++ · simp [*] ++ · push Not at h ++ simp [*] ++ ++ _ = Λ n / (↑n)^s.re := by ++ by_cases h : n = 0 ++ · simp [*] ++ · rw [Complex.norm_natCast_cpow_of_pos] ++ push Not at h ++ exact Nat.zero_lt_of_ne_zero h ++ ++ _ = (LSeries.term (fun n ↦ Λ n) s.re n).re := by ++ unfold LSeries.term ++ by_cases h : n = 0 ++ · simp [*] ++ · simp [*] ++ push Not at h ++ ring_nf ++ rw [Complex.re_ofReal_mul (Λ n)] ++ ring_nf ++ rw [Complex.inv_re] ++ rw [Complex.cpow_ofReal_re] ++ simp [*] ++ left ++ have N : (0 : ℝ) ≤ ↑n := by exact Nat.cast_nonneg' n ++ have T2 : ((↑n : ℂ) ^ (↑σ₀ : ℂ)).re = (↑n : ℝ)^σ₀ := by exact rfl ++ have T1 : ((↑n : ℂ ) ^ (↑σ₀ : ℂ)).im = 0 := by ++ refine abs_re_eq_norm.mp ?_ ++ rw [T2] ++ simp [*] ++ exact Real.rpow_nonneg N σ₀ ++ ++ simp [Complex.normSq_apply] ++ simp [T1, T2] ++ ++ have summable_abs_value : Summable (fun i ↦ ‖LSeries.term (fun n ↦ ↑(Λ n)) s i‖) := by ++ rw [summable_congr positivity] ++ exact summable_re_von_mangoldt ++ ++ have triangle_ineq : ‖LSeries (fun n ↦ ↑(Λ n)) s‖ ≤ ∑' (n : ℕ), ↑‖LSeries.term (fun n ↦ ↑(Λ n)) s n‖ := ++ norm_tsum_le_tsum_norm summable_abs_value ++ ++ have bounded_by_sum_of_re : ‖LSeries (fun n ↦ ↑(Λ n)) s‖ ≤ ∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s.re) n).re := ++ by ++ simp [positivity] at triangle_ineq ++ exact triangle_ineq ++ ++ have sum_of_re_commutes : ∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s.re) n).re = (∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s.re) n)).re := ++ (Complex.re_tsum (summable_von_mangoldt)).symm ++ ++ have re_of_sum_bdd_by_norm : (∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s.re) n)).re ≤ ‖∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s.re) n)‖ := ++ Complex.re_le_norm (∑' (n : ℕ), (LSeries.term (fun n ↦ ↑(Λ n)) (↑s.re) n)) ++ ++ have Z := ++ by ++ calc ++ ‖LSeries (fun n ↦ ↑(Λ n)) s‖ ≤ ∑' (n : ℕ), ‖LSeries.term (fun n ↦ ↑(Λ n)) s n‖ ++ := norm_tsum_le_tsum_norm summable_abs_value ++ _ ≤ ∑' (n : ℕ), (LSeries.term (fun n ↦ Λ n) s.re n).re := by simp [←positivity] ++ _ = (∑' (n : ℕ), (LSeries.term (fun n ↦ Λ n) s.re n)).re := (Complex.re_tsum (summable_von_mangoldt)).symm ++ _ ≤ ‖∑' (n : ℕ), (LSeries.term (fun n ↦ Λ n) s.re n)‖ := re_le_norm (∑' (n : ℕ), LSeries.term (fun n ↦ ↑(Λ n)) (↑s.re) n) ++ _ = ‖- ζ' (↑s.re) / ζ (↑s.re)‖ := by ++ simp only [← (ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div s_re_coerce_geq_one)] ++ unfold LSeries ++ rfl ++ _ = ‖ζ' σ₀ / ζ σ₀‖ := by ++ rw [← s_re_eq_sigma] ++ simp [*] ++ ++ exact Z ++ ++theorem dlog_riemannZeta_bdd_on_vertical_lines {σ₀ : ℝ} (σ₀_gt : 1 < σ₀) : ++ ∃ c > 0, ∀(t : ℝ), ‖ζ' (σ₀ + t * I) / ζ (σ₀ + t * I)‖ ≤ c := by ++ ++ let s_re : ℂ := σ₀ ++ ++ let new_const : ℝ := 1 + (↑(Norm.norm (∑' (n : ℕ), ‖LSeries.term (fun x ↦ Λ x) (↑ s_re : ℂ ) n‖)) : ℝ ) ++ have new_const_is_pos : new_const > 0 := by positivity ++ ++ use new_const ++ use new_const_is_pos ++ intro t ++ ++ let s := σ₀ + t * I ++ ++ have DD : (↑ s.re : ℂ) = s_re := by ++ refine ofReal_inj.mpr ?_ ++ rw [add_re, ofReal_re, mul_re, ofReal_re, I_re, I_im] ++ simp ++ ++ have L : s_re = σ₀ := by rfl ++ ++ have H : s.re = σ₀ := by ++ rw [add_re, ofReal_re, mul_re, ofReal_re, I_re, I_im] ++ simp ++ ++ have non_neg : σ₀ ≠ 0 := by ++ by_contra h ++ rw [h] at σ₀_gt ++ norm_cast at σ₀_gt ++ ++ have pos : s.re > 1 := by exact lt_of_lt_of_eq σ₀_gt (id (Eq.symm H)) ++ have pos_triv : s_re.re > 1 := by exact σ₀_gt ++ ++ rw [← norm_neg, ← neg_div, ← ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div pos] ++ ++ have identity0 : ∀(n : ℕ), ‖LSeries.term 1 s n‖ = 1 / n^σ₀ := by ++ unfold LSeries.term ++ intro n ++ by_cases h0 : n = 0 ++ · simp [*] ++ · simp [*] ++ push Not at h0 ++ have C : n > 0 := by exact Nat.zero_lt_of_ne_zero h0 ++ have T := Complex.norm_natCast_cpow_of_pos C s ++ rw [H] at T ++ exact T ++ ++ have O : ∀(s : ℂ), ∀(n : ℕ), s.re = σ₀ → (↑(‖LSeries.term (fun x ↦ (Λ x)) s n‖ : ℝ) : ℂ) = LSeries.term (fun x ↦ Λ x) (↑ s.re : ℂ ) n := by ++ intro s n cond ++ ++ by_cases h1 : (n = 0) ++ · simp [h1] ++ · push Not at h1 ++ unfold LSeries.term ++ simp [*] ++ have U : |Λ n| = Λ n := abs_of_nonneg (ArithmeticFunction.vonMangoldt_nonneg) ++ have R : n > 0 := by exact Nat.zero_lt_of_ne_zero h1 ++ rw [U] ++ have Z := Complex.norm_natCast_cpow_of_pos R s ++ rw [Z] ++ rw [← L] ++ ++ by_cases h : (Λ n = 0) ++ · simp [h] ++ · norm_cast ++ apply_fun (fun (w : ℂ) ↦ w * (↑ n : ℂ)^s_re / (Λ n)) ++ · simp [*] ++ ring_nf ++ rw [mul_comm] ++ nth_rewrite 1 [mul_assoc] ++ simp [*] ++ have := cast_pow_eq n σ₀ ++ rw [this] ++ simp [*] ++ ++ · have G : (↑ n : ℂ)^s_re / (Λ n) ≠ 0 := by ++ have T : (↑ n : ℂ)^s_re ≠ 0 := by ++ have T : n > 0 := by exact R ++ have M : ∃(m : ℕ), n = m + 1 := by exact Nat.exists_eq_succ_of_ne_zero h1 ++ let ⟨m, pf⟩ := M ++ have U := Complex.natCast_add_one_cpow_ne_zero m s_re ++ rw [pf] ++ push_cast ++ exact U ++ refine div_ne_zero T ?_ ++ push Not at h ++ norm_cast ++ have U := by exact mul_left_injective₀ G ++ have T : (fun (x : ℂ) ↦ x * (↑ n : ℂ)^s_re / (Λ n)) = (fun (x : ℂ) ↦ x * ((↑ n : ℂ)^s_re / (Λ n))) := by funext x; exact mul_div_assoc x (↑n ^ s_re) ↑(Λ n) ++ simp [←T] at U ++ exact U ++ ++ have K : (fun (n : ℕ) ↦ ↑(‖LSeries.term (fun x ↦ (Λ x)) s n‖ : ℝ)) = (fun (n : ℕ) ↦ (LSeries.term (fun x ↦ Λ x) (↑ s.re : ℂ ) n )) := by ++ funext n ++ rw [O s n H] ++ ++ have K1 : (fun (n : ℕ) ↦ ↑(‖LSeries.term (fun x ↦ (Λ x)) (↑ s.re : ℂ) n‖ : ℝ)) = (fun (n : ℕ) ↦ (LSeries.term (fun x ↦ Λ x) (↑ s.re : ℂ ) n )) := by ++ funext n ++ rw [O (↑ s.re : ℂ) n H] ++ simp [*] ++ ++ have D2 : (fun (n : ℕ) ↦ ↑(‖LSeries.term (fun x ↦ (Λ x)) s n‖ : ℝ)) = (fun (n : ℕ) ↦ ↑(‖LSeries.term (fun x ↦ (Λ x)) (↑ s.re : ℂ) n‖ : ℝ)) := by ++ simp [← K] ++ ++ have S : Summable (fun n ↦ (↑(‖LSeries.term (fun x ↦ Λ x) s n‖ : ℝ) : ℝ )) := by ++ apply (summable_real_iff_summable_coe_complex (fun n ↦ (↑(‖LSeries.term (fun x ↦ Λ x) s n‖ : ℝ) : ℝ ))).mpr ++ rw [K] ++ have T := ArithmeticFunction.LSeriesSummable_vonMangoldt (pos_triv) ++ have U : s_re = s.re := by exact congrFun (congrArg Complex.mk (id (Eq.symm H))) 0 ++ simp [← U] ++ exact T ++ ++ have C := calc ++ ‖∑' (n : ℕ), (LSeries.term (fun x ↦ Λ x) s n)‖ ≤ ∑' (n : ℕ), ‖LSeries.term (fun x ↦ Λ x) s n‖ := norm_tsum_le_tsum_norm S ++ ++ _ ≤ norm (∑' (n : ℕ), ‖LSeries.term (fun x ↦ Λ x) s n‖) := by exact le_norm_self (∑' (n : ℕ), ‖LSeries.term (fun x ↦ ↑(Λ x)) s n‖) ++ _ = norm (∑' (n : ℕ), ‖LSeries.term (fun x ↦ Λ x) (↑ s.re : ℂ) n‖) := by simp [D2] ++ _ ≤ 1 + norm (∑' (n : ℕ), ‖LSeries.term (fun x ↦ Λ x) ( ↑ s.re : ℂ) n‖ ) := by linarith ++ _ = new_const := by rw [DD] ++ ++ exact C ++ ++theorem dlog_riemannZeta_bdd_on_vertical_lines' {σ₀ : ℝ} (σ₀_gt : 1 < σ₀) : ++ ∃ C > 0, ∀ (t : ℝ), ‖ζ' (σ₀ + t * I) / ζ (σ₀ + t * I)‖ ≤ C := ++ dlog_riemannZeta_bdd_on_vertical_lines σ₀_gt ++ ++theorem SmoothedChebyshevPull1_aux_integrable {SmoothingF : ℝ → ℝ} {ε : ℝ} (ε_pos : 0 < ε) ++ (ε_lt_one : ε < 1) ++ {X : ℝ} (X_gt : 3 < X) ++ {σ₀ : ℝ} (σ₀_gt : 1 < σ₀) (σ₀_le_2 : σ₀ ≤ 2) ++ (suppSmoothingF : support SmoothingF ⊆ Icc (1 / 2) 2) ++ (SmoothingFnonneg : ∀ x > 0, 0 ≤ SmoothingF x) ++ (mass_one : ∫ (x : ℝ) in Ioi 0, SmoothingF x / x = 1) ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ : ++ Integrable (fun (t : ℝ) ↦ ++ SmoothedChebyshevIntegrand SmoothingF ε X (σ₀ + (t : ℂ) * I)) volume := by ++ obtain ⟨C, C_pos, hC⟩ := dlog_riemannZeta_bdd_on_vertical_lines' σ₀_gt ++ let c : ℝ := C * X ^ σ₀ ++ have : ∀ t, ‖(fun (t : ℝ) ↦ (- deriv riemannZeta (σ₀ + (t : ℂ) * I)) / ++ riemannZeta (σ₀ + (t : ℂ) * I) * ++ (X : ℂ) ^ (σ₀ + (t : ℂ) * I)) t‖ ≤ c := by ++ intro t ++ simp only [Complex.norm_mul, c] ++ gcongr ++ · simpa only [neg_div, norm_neg] using hC t ++ ++ · rw [Complex.norm_cpow_eq_rpow_re_of_nonneg] ++ · simp ++ · linarith ++ · simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, ++ add_zero, ne_eq] ++ linarith ++ convert! (SmoothedChebyshevDirichlet_aux_integrable ContDiffSmoothingF SmoothingFnonneg ++ suppSmoothingF mass_one ε_pos ε_lt_one σ₀_gt σ₀_le_2).bdd_mul (c := c) ?_ (Filter.Eventually.of_forall this) using 2 ++ · unfold SmoothedChebyshevIntegrand ++ ring ++ · apply Continuous.aestronglyMeasurable ++ apply continuousOn_univ.mp ++ intro t _ ++ let s := σ₀ + (t : ℂ) * I ++ have s_ne_one : s ≠ 1 := by ++ intro h ++ ++ have : σ₀ = 1 := by ++ have := congr_arg Complex.re h ++ simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, add_zero, one_re, s] at this ++ exact this ++ ++ linarith [σ₀_gt] ++ apply ContinuousAt.continuousWithinAt ++ apply ContinuousAt.mul ++ · have diffζ := differentiableAt_riemannZeta s_ne_one ++ apply ContinuousAt.div ++ · apply ContinuousAt.neg ++ have : DifferentiableAt ℂ (fun s ↦ deriv riemannZeta s) s := ++ differentiableAt_deriv_riemannZeta s_ne_one ++ convert realDiff_of_complexDiff (s := σ₀ + (t : ℂ) * I) this <;> simp ++ · convert realDiff_of_complexDiff (s := σ₀ + (t : ℂ) * I) diffζ <;> simp ++ · apply riemannZeta_ne_zero_of_one_lt_re ++ simp [σ₀_gt] ++ · apply ContinuousAt.comp _ (by fun_prop) ++ apply continuousAt_const_cpow ++ norm_cast ++ linarith ++ ++lemma BddAboveOnRect {g : ℂ → ℂ} {z w : ℂ} (holoOn : HolomorphicOn g (z.Rectangle w)) : ++ BddAbove (norm ∘ g '' (z.Rectangle w)) := by ++ have compact_rect : IsCompact (z.Rectangle w) := by ++ apply IsCompact.reProdIm <;> apply isCompact_uIcc ++ refine IsCompact.bddAbove_image compact_rect ?_ ++ apply holoOn.continuousOn.norm ++ ++theorem SmoothedChebyshevPull1 {SmoothingF : ℝ → ℝ} {ε : ℝ} (ε_pos: 0 < ε) ++ (ε_lt_one : ε < 1) ++ (X : ℝ) (X_gt : 3 < X) ++ {T : ℝ} (T_pos : 0 < T) {σ₁ : ℝ} ++ (σ₁_pos : 0 < σ₁) (σ₁_lt_one : σ₁ < 1) ++ (holoOn : HolomorphicOn (ζ' / ζ) ((Icc σ₁ 2)×ℂ (Icc (-T) T) \ {1})) ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (SmoothingFnonneg : ∀ x > 0, 0 ≤ SmoothingF x) ++ (mass_one : ∫ x in Ioi 0, SmoothingF x / x = 1) ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) : ++ SmoothedChebyshev SmoothingF ε X = ++ I₁ SmoothingF ε X T - ++ I₂ SmoothingF ε T X σ₁ + ++ I₃₇ SmoothingF ε T X σ₁ + ++ I₈ SmoothingF ε T X σ₁ + ++ I₉ SmoothingF ε X T ++ + 𝓜 ((Smooth1 SmoothingF ε) ·) 1 * X := by ++ unfold SmoothedChebyshev ++ unfold VerticalIntegral' ++ have X_eq_gt_one : 1 < 1 + (Real.log X)⁻¹ := by ++ nth_rewrite 1 [← add_zero 1] ++ refine add_lt_add_of_le_of_lt ?_ ?_ ++ rfl ++ rw[inv_pos, ← Real.log_one] ++ apply Real.log_lt_log ++ norm_num ++ linarith ++ have X_eq_lt_two : (1 + (Real.log X)⁻¹) < 2 := by ++ rw[← one_add_one_eq_two] ++ refine (add_lt_add_iff_left 1).mpr ?_ ++ refine inv_lt_one_of_one_lt₀ ?_ ++ refine (lt_log_iff_exp_lt ?_).mpr ?_ ++ positivity ++ have : rexp 1 < 3 := by exact lt_trans (Real.exp_one_lt_d9) (by norm_num) ++ linarith ++ have X_eq_le_two : 1 + (Real.log X)⁻¹ ≤ 2 := X_eq_lt_two.le ++ rw [verticalIntegral_split_three (a := -T) (b := T)] ++ swap ++ · ++ exact SmoothedChebyshevPull1_aux_integrable ε_pos ε_lt_one X_gt X_eq_gt_one ++ X_eq_le_two suppSmoothingF SmoothingFnonneg mass_one ContDiffSmoothingF ++ · ++ have temp : ↑(1 + (Real.log X)⁻¹) = (1 : ℂ) + ↑(Real.log X)⁻¹ := by push_cast; rfl ++ repeat rw[smul_eq_mul] ++ unfold I₁ ++ rw[temp, mul_add, mul_add, add_assoc, sub_eq_add_neg] ++ nth_rewrite 4 [add_assoc] ++ nth_rewrite 3 [add_assoc] ++ nth_rewrite 2 [add_assoc] ++ rw[add_assoc, add_left_cancel_iff, add_assoc] ++ nth_rewrite 7 [add_comm] ++ rw[← add_assoc] ++ unfold I₉ ++ rw[add_right_cancel_iff, ← add_right_inj (1 / (2 * ↑π * I) * ++ -VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) (1 + (Real.log X)⁻¹) (-T) T), ++ ← mul_add, ← sub_eq_neg_add, sub_self, mul_zero] ++ unfold VIntegral I₂ I₃₇ I₈ ++ rw[smul_eq_mul, temp, ← add_assoc, ← add_assoc] ++ nth_rewrite 2 [div_mul_comm] ++ rw[mul_one, ← neg_div, ← mul_neg] ++ nth_rewrite 2 [← one_div_mul_eq_div] ++ repeat rw[← mul_add] ++ let fTempRR : ℝ → ℝ → ℂ := fun x ↦ fun y ↦ ++ SmoothedChebyshevIntegrand SmoothingF ε X ((x : ℝ) + (y : ℝ) * I) ++ let fTempC : ℂ → ℂ := fun z ↦ fTempRR z.re z.im ++ have : ∫ (y : ℝ) in -T..T, ++ SmoothedChebyshevIntegrand SmoothingF ε X (1 + ↑(Real.log X)⁻¹ + ↑y * I) = ++ ∫ (y : ℝ) in -T..T, fTempRR (1 + (Real.log X)⁻¹) y := by ++ unfold fTempRR ++ rw[temp] ++ rw[this] ++ have : ∫ (σ : ℝ) in σ₁..1 + (Real.log X)⁻¹, ++ SmoothedChebyshevIntegrand SmoothingF ε X (↑σ - ↑T * I) = ++ ∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR x (-T) := by ++ unfold fTempRR ++ rw[Complex.ofReal_neg, neg_mul] ++ rfl ++ rw[this] ++ have : ∫ (t : ℝ) in -T..T, SmoothedChebyshevIntegrand SmoothingF ε X (↑σ₁ + ↑t * I) = ++ ∫ (y : ℝ) in -T..T, fTempRR σ₁ y := by rfl ++ rw[this] ++ have : ∫ (σ : ℝ) in σ₁..1 + (Real.log X)⁻¹, ++ SmoothedChebyshevIntegrand SmoothingF ε X (↑σ + ↑T * I) = ++ ∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR x T := by rfl ++ rw[this] ++ repeat rw[← add_assoc] ++ have : (((I * -∫ (y : ℝ) in -T..T, fTempRR (1 + (Real.log X)⁻¹) y) + ++ -∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR x (-T)) + ++ I * ∫ (y : ℝ) in -T..T, fTempRR σ₁ y) + ++ ∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR x T = ++ -1 * RectangleIntegral fTempC ((1 : ℝ) + (Real.log X)⁻¹ + T * I) (σ₁ - T * I) := by ++ unfold RectangleIntegral ++ rw[HIntegral_symm, VIntegral_symm] ++ nth_rewrite 2 [HIntegral_symm, VIntegral_symm] ++ unfold HIntegral VIntegral ++ repeat rw[smul_eq_mul] ++ repeat rw[add_re] ++ repeat rw[add_im] ++ repeat rw[sub_re] ++ repeat rw[sub_im] ++ repeat rw[mul_re] ++ repeat rw[mul_im] ++ repeat rw[ofReal_re] ++ repeat rw[ofReal_im] ++ rw[I_re, I_im, mul_zero, zero_mul, mul_one] ++ ring_nf ++ unfold fTempC ++ have : ∫ (y : ℝ) in -T..T, fTempRR (I * ↑y + ↑σ₁).re (I * ↑y + ↑σ₁).im = ++ ∫ (y : ℝ) in -T..T, fTempRR σ₁ y := by simp ++ rw[this] ++ have : ∫ (y : ℝ) in -T..T, ++ fTempRR (I * ↑y + ↑(1 + (Real.log X)⁻¹)).re (I * ↑y + ↑(1 + (Real.log X)⁻¹)).im = ++ ∫ (y : ℝ) in -T..T, fTempRR (1 + (Real.log X)⁻¹) y := by simp ++ rw[this] ++ have : ∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR (I * ↑T + ↑x).re (I * ↑T + ↑x).im = ++ ∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR x T := by simp ++ rw[this] ++ have : ∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR (I * ↑(-T) + ↑x).re (I * ↑(-T) + ↑x).im = ++ ∫ (x : ℝ) in σ₁..1 + (Real.log X)⁻¹, fTempRR x (-T) := by simp ++ rw[this] ++ ring_nf ++ rw[this, neg_one_mul, div_mul_comm, mul_one, ++ ← add_right_inj ++ (RectangleIntegral fTempC (1 + ↑(Real.log X)⁻¹ + ↑T * I) (↑σ₁ - ↑T * I) / (2 * ↑π * I)), ++ ← add_assoc] ++ simp only [ofReal_one, ofReal_inv, add_zero] ++ rw[rectangleIntegral_symm] ++ have : RectangleIntegral fTempC (↑σ₁ - ↑T * I) (1 + 1 / ↑(Real.log X) + ↑T * I) / (2 * ↑π * I) = ++ RectangleIntegral' fTempC (σ₁ - T * I) (1 + ↑(Real.log X)⁻¹ + T * I) := by ++ unfold RectangleIntegral' ++ rw [smul_eq_mul] ++ simp only [one_div, ofReal_inv] ++ ring ++ ++ simp only [one_div, ofReal_inv] at this ++ rw [this] ++ ++ let holoMatch : ℂ → ℂ := fun z ↦ ++ (fTempC z - (𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) 1 * ↑X) / (z - 1)) ++ have inv_log_X_pos: 0 < (Real.log X)⁻¹ := by ++ rw[inv_pos, ← Real.log_one] ++ apply Real.log_lt_log (by positivity) (by linarith) ++ have pInRectangleInterior : ++ (Rectangle (σ₁ - ↑T * I) (1 + (Real.log X)⁻¹ + T * I) ∈ nhds 1) := by ++ refine rectangle_mem_nhds_iff.mpr ?_ ++ refine mem_reProdIm.mpr ?_ ++ have : re 1 = 1 := by rfl ++ rw[this] ++ have : im 1 = 0 := by rfl ++ rw[this] ++ repeat rw[sub_re] ++ repeat rw[sub_im] ++ repeat rw[add_re] ++ repeat rw[add_im] ++ rw[mul_re, mul_im, I_re, I_im] ++ repeat rw[ofReal_re] ++ repeat rw[ofReal_im] ++ ring_nf ++ have temp : 1 ∈ uIoo σ₁ (re 1 + (Real.log X)⁻¹) := by ++ have : re 1 = 1 := by rfl ++ rw[this] ++ unfold uIoo ++ have : min σ₁ (1 + (Real.log X)⁻¹) = σ₁ := by exact min_eq_left (by linarith) ++ rw[this] ++ have : max σ₁ (1 + (Real.log X)⁻¹) = 1 + (Real.log X)⁻¹ := by exact max_eq_right (by linarith) ++ rw[this] ++ refine mem_Ioo.mpr ?_ ++ exact ⟨σ₁_lt_one, (by linarith)⟩ ++ have : 0 ∈ uIoo (-T) (T + im 1) := by ++ have : im 1 = 0 := by rfl ++ rw[this, add_zero] ++ unfold uIoo ++ have : min (-T) T = -T := by exact min_eq_left (by linarith) ++ rw[this] ++ have : max (-T) T = T := by exact max_eq_right (by linarith) ++ rw[this] ++ refine mem_Ioo.mpr ?_ ++ exact ⟨(by linarith), (by linarith)⟩ ++ exact ⟨temp, this⟩ ++ ++ have holoMatchHoloOn : HolomorphicOn holoMatch ++ (Rectangle (σ₁ - ↑T * I) (1 + (Real.log X)⁻¹ + T * I) \ {1}) := by ++ unfold HolomorphicOn holoMatch ++ refine DifferentiableOn.sub ?_ ?_ ++ · unfold fTempC fTempRR ++ have : (fun z ↦ SmoothedChebyshevIntegrand SmoothingF ε X (↑z.re + ↑z.im * I)) = ++ (fun z ↦ SmoothedChebyshevIntegrand SmoothingF ε X z) := by ++ apply funext ++ intro z ++ have : (↑z.re + ↑z.im * I) = z := by exact re_add_im z ++ rw[this] ++ rw[this] ++ refine DifferentiableOn.mul ?_ ?_ ++ · refine DifferentiableOn.mul ?_ ?_ ++ · have : (fun s ↦ -ζ' s / ζ s) = (fun s ↦ -(ζ' s / ζ s)) := by ++ refine funext ?_ ++ intro x ++ exact neg_div (ζ x) (ζ' x) ++ rw[this] ++ refine DifferentiableOn.neg ?_ ++ unfold DifferentiableOn ++ intro x x_location ++ unfold Rectangle at x_location ++ rw[Set.mem_sdiff, Complex.mem_reProdIm, sub_re, add_re, sub_im, add_im, mul_re, mul_im, ++ I_re, I_im, add_re, add_im] at x_location ++ simp only [ofReal_re, mul_zero, ofReal_im, mul_one, sub_self, sub_zero, one_re, ++ ofReal_inv, inv_re, normSq_ofReal, div_self_mul_self', add_zero, zero_sub, one_im, ++ inv_im, neg_zero, zero_div, zero_add, mem_singleton_iff] at x_location ++ ++ obtain ⟨⟨xReIn, xImIn⟩, xOut⟩ := x_location ++ unfold uIcc at xReIn xImIn ++ have : min σ₁ (1 + (Real.log X)⁻¹) = σ₁ := by exact min_eq_left (by linarith) ++ rw[this] at xReIn ++ have : max σ₁ (1 + (Real.log X)⁻¹) = 1 + (Real.log X)⁻¹ := by exact max_eq_right (by linarith) ++ rw[this] at xReIn ++ have : min (-T) T = (-T) := by exact min_eq_left (by linarith) ++ rw[this] at xImIn ++ have : max (-T) T = T := by exact max_eq_right (by linarith) ++ rw[this] at xImIn ++ unfold HolomorphicOn DifferentiableOn at holoOn ++ have temp : DifferentiableWithinAt ℂ (ζ' / ζ) (Icc σ₁ 2 ×ℂ Icc (-T) T \ {1}) x := by ++ have : x ∈ Icc σ₁ 2 ×ℂ Icc (-T) T \ {1} := by ++ rw [Set.mem_sdiff, Complex.mem_reProdIm] ++ have xReTemp : x.re ∈ Icc σ₁ 2 := by ++ have xReLb : σ₁ ≤ x.re := by exact xReIn.1 ++ have xReUb : x.re ≤ 2 := by exact (lt_of_le_of_lt xReIn.2 X_eq_lt_two).le ++ exact ⟨xReLb, xReUb⟩ ++ have xImTemp : x.im ∈ Icc (-T) T := by exact ⟨xImIn.1, xImIn.2⟩ ++ exact ⟨⟨xReTemp, xImTemp⟩, xOut⟩ ++ exact holoOn x this ++ ++ have : ((↑σ₁ - ↑T * I).Rectangle (1 + ↑(Real.log X)⁻¹ + ↑T * I) \ {1}) ⊆ ++ (Icc σ₁ 2 ×ℂ Icc (-T) T \ {1}) := by ++ intro a a_location ++ rw[Set.mem_sdiff, Complex.mem_reProdIm] ++ rw[Set.mem_sdiff] at a_location ++ obtain ⟨aIn, aOut⟩ := a_location ++ unfold Rectangle uIcc at aIn ++ rw[sub_re, add_re, add_re, sub_im, add_im, add_im, mul_re, mul_im, ofReal_re, ofReal_re, ofReal_re, ofReal_im, ofReal_im, ofReal_im, I_re, I_im] at aIn ++ have : re 1 = 1 := by rfl ++ rw[this] at aIn ++ have : im 1 = 0 := by rfl ++ rw[this] at aIn ++ ring_nf at aIn ++ have : min σ₁ (1 + (Real.log X)⁻¹) = σ₁ := by linarith ++ rw[this] at aIn ++ have : max σ₁ (1 + (Real.log X)⁻¹) = 1 + (Real.log X)⁻¹ := by linarith ++ rw[this] at aIn ++ have : min (-T) T = (-T) := by linarith ++ rw[this] at aIn ++ have : max (-T) T = T := by linarith ++ rw[this] at aIn ++ rw[Complex.mem_reProdIm] at aIn ++ obtain ⟨aReIn, aImIn⟩ := aIn ++ have aReInRedo : a.re ∈ Icc σ₁ 2 := by ++ have : a.re ≤ 2 := by exact (lt_of_le_of_lt aReIn.2 X_eq_lt_two).le ++ exact ⟨aReIn.1, this⟩ ++ exact ⟨⟨aReInRedo, aImIn⟩, aOut⟩ ++ exact DifferentiableWithinAt.mono temp this ++ · unfold DifferentiableOn ++ intro x x_location ++ refine DifferentiableAt.differentiableWithinAt ?_ ++ have hε : ε ∈ Ioo 0 1 := by exact ⟨ε_pos, ε_lt_one⟩ ++ have xRePos : 0 < x.re := by ++ unfold Rectangle at x_location ++ rw[Set.mem_sdiff, Complex.mem_reProdIm] at x_location ++ obtain ⟨⟨xReIn, _⟩, _⟩ := x_location ++ unfold uIcc at xReIn ++ rw[sub_re, add_re, add_re, mul_re, I_re, I_im] at xReIn ++ repeat rw[ofReal_re] at xReIn ++ repeat rw[ofReal_im] at xReIn ++ ring_nf at xReIn ++ have : re 1 = 1 := by rfl ++ rw[this] at xReIn ++ have : min σ₁ (1 + (Real.log X)⁻¹) = σ₁ := by exact min_eq_left (by linarith) ++ rw[this] at xReIn ++ have : σ₁ ≤ x.re := by exact xReIn.1 ++ linarith ++ exact Smooth1MellinDifferentiable ContDiffSmoothingF suppSmoothingF hε SmoothingFnonneg mass_one xRePos ++ · unfold DifferentiableOn ++ intro x x_location ++ apply DifferentiableAt.differentiableWithinAt ++ unfold HPow.hPow instHPow ++ simp only ++ apply DifferentiableAt.const_cpow ++ · exact differentiableAt_fun_id ++ · left ++ refine ne_zero_of_re_pos ?_ ++ simp only [ofReal_re] ++ linarith ++ · refine DifferentiableOn.mul ?_ ?_ ++ · ++ unfold DifferentiableOn ++ intro x x_location ++ rw[Set.mem_sdiff] at x_location ++ obtain ⟨xInRect, xOut⟩ := x_location ++ apply DifferentiableAt.differentiableWithinAt ++ apply differentiableAt_const ++ · unfold DifferentiableOn ++ intro x x_location ++ apply DifferentiableAt.differentiableWithinAt ++ apply DifferentiableAt.inv ++ · fun_prop ++ · intro h ++ rw [sub_eq_zero] at h ++ have := x_location.2 ++ simp only [mem_singleton_iff] at this ++ exact this h ++ ++ have holoMatchBddAbove : BddAbove ++ (norm ∘ holoMatch '' (Rectangle (σ₁ - ↑T * I) (1 + (Real.log X)⁻¹ + T * I) \ {1})) := by ++ let U : Set ℂ := Rectangle (σ₁ - ↑T * I) (1 + (Real.log X)⁻¹ + T * I) ++ let f : ℂ → ℂ := fun z ↦ -ζ' z / ζ z ++ let g : ℂ → ℂ := fun z ↦ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) z * ↑X ^ z ++ have bigO_holoMatch : holoMatch =O[nhdsWithin 1 {1}ᶜ] (1 : ℂ → ℂ) := by ++ unfold holoMatch fTempC fTempRR SmoothedChebyshevIntegrand ++ simp only [re_add_im] ++ have : (fun z ↦ ++ (-ζ' z / ζ z * 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) z * ↑X ^ z - ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) 1 * ↑X / (z - 1))) = ++ (fun z ↦ (f z * g z - 1 * g 1 / (z - 1))) := by ++ apply funext ++ intro x ++ simp[f, g] ++ rw[mul_assoc] ++ rw[this] ++ have g_holc : HolomorphicOn g U := by ++ unfold HolomorphicOn DifferentiableOn ++ intro u uInU ++ refine DifferentiableAt.differentiableWithinAt ?_ ++ simp[g] ++ refine DifferentiableAt.mul ?_ ?_ ++ have hε : ε ∈ Set.Ioo 0 1 := by exact ⟨ε_pos, ε_lt_one⟩ ++ have hu : 0 < u.re := by ++ simp[U] at uInU ++ unfold Rectangle uIcc at uInU ++ rw[Complex.mem_reProdIm] at uInU ++ obtain ⟨uReIn, uImIn⟩ := uInU ++ have : min (↑σ₁ - ↑T * I).re (1 + (↑(Real.log X))⁻¹ + ↑T * I).re = σ₁ := by ++ rw[sub_re, add_re, add_re, mul_re, I_re, I_im] ++ repeat rw[ofReal_re] ++ repeat rw[ofReal_im] ++ simp ++ linarith ++ rw[this] at uReIn ++ have : σ₁ ≤ u.re := by exact uReIn.1 ++ linarith ++ exact Smooth1MellinDifferentiable ContDiffSmoothingF suppSmoothingF hε SmoothingFnonneg mass_one hu ++ unfold HPow.hPow instHPow ++ simp ++ apply DifferentiableAt.const_cpow ++ exact differentiableAt_fun_id ++ refine Or.inl ?_ ++ refine ne_zero_of_re_pos ?_ ++ rw[ofReal_re] ++ positivity ++ have U_in_nhds : U ∈ nhds 1 := by ++ simp only [U] ++ exact pInRectangleInterior ++ have f_near_p : (f - fun (z : ℂ) => 1 * (z - 1)⁻¹) =O[nhdsWithin 1 {1}ᶜ] (1 : ℂ → ℂ) := by ++ simp[f] ++ have : ((fun z ↦ -ζ' z / ζ z) - fun z ↦ (z - 1)⁻¹) = ++ (-ζ' / ζ - fun z ↦ (z - 1)⁻¹) := by ++ apply funext ++ intro z ++ simp ++ rw[this] ++ exact riemannZetaLogDerivResidueBigO ++ exact ResidueMult g_holc U_in_nhds f_near_p ++ have : ∃ V ∈ nhds 1, BddAbove (norm ∘ holoMatch '' (V \ {1})) := by exact IsBigO_to_BddAbove bigO_holoMatch ++ obtain ⟨V, VInNhds_one, BddAboveV⟩ := this ++ have : ∃ W ⊆ V, 1 ∈ W ∧ IsOpen W ∧ BddAbove (norm ∘ holoMatch '' (W \ {1})) := by ++ rw[mem_nhds_iff] at VInNhds_one ++ obtain ⟨W, WSubset, WOpen, one_in_W⟩ := VInNhds_one ++ use W ++ have : BddAbove (Norm.norm ∘ holoMatch '' (W \ {1})) := by ++ have : Norm.norm ∘ holoMatch '' (W \ {1}) ⊆ ++ Norm.norm ∘ holoMatch '' (V \ {1}) := by ++ exact image_mono (by exact sdiff_subset_sdiff_left WSubset) ++ exact BddAbove.mono this BddAboveV ++ exact ⟨WSubset, ⟨one_in_W, WOpen, this⟩⟩ ++ obtain ⟨W, WSubset, one_in_W, OpenW, BddAboveW⟩ := this ++ have : (↑σ₁ - ↑T * I).Rectangle (1 + ↑(Real.log X)⁻¹ + ↑T * I) = U := by rfl ++ rw[this] at holoMatchHoloOn ⊢ ++ have one_in_U : 1 ∈ U := by ++ have U_in_nhds : U ∈ nhds 1 := by ++ simp only [U] ++ exact pInRectangleInterior ++ exact mem_of_mem_nhds U_in_nhds ++ have (h1 : 1 ∈ U) (h2 : 1 ∈ W) : U \ {1} = (U \ W) ∪ ((U ∩ W) \ {1}) := by ++ ext x ++ simp only [Set.mem_sdiff, Set.mem_singleton_iff, Set.mem_union, Set.mem_inter_iff] ++ constructor ++ intro ⟨hxU, hx1⟩ ++ by_cases hw : x ∈ W ++ · right ++ exact ⟨⟨hxU, hw⟩, hx1⟩ ++ · left ++ exact ⟨hxU, hw⟩ ++ · intro h ++ cases' h with h_left h_right ++ have : x ≠ 1 := by ++ intro x_eq_1 ++ rw[x_eq_1] at h_left ++ exact h_left.2 h2 ++ · exact ⟨h_left.1, this⟩ ++ · exact ⟨h_right.1.1, h_right.2⟩ ++ rw[this one_in_U one_in_W] ++ have : Norm.norm ∘ holoMatch '' (U \ W ∪ (U ∩ W) \ {1}) = ++ Norm.norm ∘ holoMatch '' (U \ W) ∪ Norm.norm ∘ holoMatch '' ((U ∩ W) \ {1}) := by ++ exact image_union (Norm.norm ∘ holoMatch) (U \ W) ((U ∩ W) \ {1}) ++ rw[this] ++ refine BddAbove.union ?_ ?_ ++ refine IsCompact.bddAbove_image ?_ ?_ ++ refine IsCompact.diff ?_ ?_ ++ unfold U Rectangle ++ apply IsCompact.reProdIm ++ unfold uIcc ++ exact isCompact_Icc ++ unfold uIcc ++ exact isCompact_Icc ++ exact OpenW ++ refine Continuous.comp_continuousOn ?_ ?_ ++ exact continuous_norm ++ have : HolomorphicOn holoMatch (U \ W) := by ++ have : U \ W ⊆ U \ {1} := by ++ intro x x_location ++ obtain ⟨xInU, xOutW⟩ := x_location ++ rw[Set.mem_sdiff] ++ apply And.intro ++ exact xInU ++ rw[Set.mem_singleton_iff] ++ intro x_eq_1 ++ rw[x_eq_1] at xOutW ++ exact xOutW one_in_W ++ exact DifferentiableOn.mono holoMatchHoloOn this ++ unfold HolomorphicOn at this ++ exact DifferentiableOn.continuousOn this ++ have : Norm.norm ∘ holoMatch '' ((U ∩ W) \ {1}) ⊆ ++ Norm.norm ∘ holoMatch '' (W \ {1}) := by ++ have : (U ∩ W) \ {1} ⊆ W \ {1} := by ++ intro x x_location ++ rw[Set.mem_sdiff] at x_location ++ obtain ⟨⟨xInU, xInW⟩, xOut⟩ := x_location ++ exact ⟨xInW, xOut⟩ ++ exact image_mono this ++ exact BddAbove.mono this BddAboveW ++ ++ obtain ⟨g, gHolo_Eq⟩ := existsDifferentiableOn_of_bddAbove ++ pInRectangleInterior holoMatchHoloOn holoMatchBddAbove ++ obtain ⟨gHolo, gEq⟩ := gHolo_Eq ++ ++ have zRe_le_wRe : (σ₁ - ↑T * I).re ≤ (1 + (Real.log X)⁻¹ + T * I).re := by ++ repeat rw[sub_re] ++ repeat rw[add_re] ++ repeat rw[mul_re] ++ rw[I_re, I_im] ++ repeat rw[ofReal_re] ++ repeat rw[ofReal_im] ++ ring_nf ++ have : re 1 = 1 := by rfl ++ rw[this] ++ linarith ++ have zIm_le_wIm : (σ₁ - ↑T * I).im ≤ (1 + (Real.log X)⁻¹ + T * I).im := by ++ repeat rw[sub_im] ++ repeat rw[add_im] ++ repeat rw[mul_im] ++ rw[I_re, I_im] ++ repeat rw[ofReal_re] ++ repeat rw[ofReal_im] ++ ring_nf ++ have : im 1 = 0 := by rfl ++ rw[this] ++ linarith ++ have hres := ResidueTheoremOnRectangleWithSimplePole zRe_le_wRe zIm_le_wIm ++ pInRectangleInterior gHolo gEq ++ simp only [ofReal_inv] at hres ++ rw [← hres] ++ unfold RectangleIntegral' ++ simp only [smul_eq_mul] ++ ring ++ ++lemma interval_membership (r : ℝ)(a b: ℝ)(h1 : r ∈ Set.Icc (min a b) (max a b)) (h2 : a < b) : ++ a ≤ r ∧ r ≤ b := by ++ ++ have min_eq : min a b = a := min_eq_left (le_of_lt h2) ++ have max_eq : max a b = b := max_eq_right (le_of_lt h2) ++ rw [min_eq, max_eq] at h1 ++ rw [← @mem_Icc] ++ exact h1 ++ ++lemma verticalIntegral_split_three_finite {s a b e σ : ℝ} {f : ℂ → ℂ} ++ (hf : IntegrableOn (fun t : ℝ ↦ f (σ + t * I)) (Icc s e)) ++ (hab: s < a ∧ a < b ∧ b < e): ++ VIntegral f σ s e = ++ VIntegral f σ s a + ++ VIntegral f σ a b + ++ VIntegral f σ b e := by ++ dsimp [VIntegral] ++ rw [← intervalIntegrable_iff_integrableOn_Icc_of_le (by linarith)] at hf ++ rw[← intervalIntegral.integral_add_adjacent_intervals (b := a), ← intervalIntegral.integral_add_adjacent_intervals (a := a) (b := b)] ++ · ring ++ all_goals apply IntervalIntegrable.mono_set hf; apply uIcc_subset_uIcc <;> apply mem_uIcc_of_le <;> linarith ++ ++lemma verticalIntegral_split_three_finite' {s a b e σ : ℝ} {f : ℂ → ℂ} ++ (hf : IntegrableOn (fun t : ℝ ↦ f (σ + t * I)) (Icc s e)) ++ (hab: s < a ∧ a < b ∧ b < e): ++ (1 : ℂ) / (2 * π * I) * (VIntegral f σ s e) = ++ (1 : ℂ) / (2 * π * I) * (VIntegral f σ s a) + ++ (1 : ℂ) / (2 * π * I) * (VIntegral f σ a b) + ++ (1 : ℂ) / (2 * π * I) * (VIntegral f σ b e) := by ++ have : (1 : ℂ) / (2 * π * I) * (VIntegral f σ s a) + ++ (1 : ℂ) / (2 * π * I) * (VIntegral f σ a b) + ++ (1 : ℂ) / (2 * π * I) * (VIntegral f σ b e) = (1 : ℂ) / (2 * π * I) * ((VIntegral f σ s a) + ++ (VIntegral f σ a b) + ++ (VIntegral f σ b e)) := by ring ++ rw [this] ++ clear this ++ rw [← verticalIntegral_split_three_finite hf hab] ++ ++theorem SmoothedChebyshevPull2_aux1 {T σ₁ : ℝ} (σ₁lt : σ₁ < 1) ++ (holoOn : HolomorphicOn (ζ' / ζ) (Icc σ₁ 2 ×ℂ Icc (-T) T \ {1})) : ++ ContinuousOn (fun (t : ℝ) ↦ -ζ' (σ₁ + t * I) / ζ (σ₁ + t * I)) (Icc (-T) T) := by ++ rw [show (fun (t : ℝ) ↦ -ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I)) = -(ζ' / ζ) ∘ (fun (t : ℝ) ↦ ↑σ₁ + ↑t * I) by ext; simp; ring_nf] ++ apply ContinuousOn.neg ++ apply holoOn.continuousOn.comp (by fun_prop) ++ intro t ht ++ simp ++ constructor ++ · apply mem_reProdIm.mpr ++ simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, add_zero, add_im, mul_im, zero_add, left_mem_Icc, ht, and_true] ++ linarith ++ · intro h ++ replace h := congr_arg re h ++ simp at h ++ linarith ++ ++theorem SmoothedChebyshevPull2 {SmoothingF : ℝ → ℝ} {ε : ℝ} (ε_pos: 0 < ε) (ε_lt_one : ε < 1) ++ (X : ℝ) (_ : 3 < X) ++ {T : ℝ} (T_pos : 3 < T) {σ₁ σ₂ : ℝ} ++ (σ₂_pos : 0 < σ₂) (σ₁_lt_one : σ₁ < 1) ++ (σ₂_lt_σ₁ : σ₂ < σ₁) ++ (holoOn : HolomorphicOn (ζ' / ζ) ((Icc σ₁ 2)×ℂ (Icc (-T) T) \ {1})) ++ (holoOn2 : HolomorphicOn (SmoothedChebyshevIntegrand SmoothingF ε X) ++ (Icc σ₂ 2 ×ℂ Icc (-3) 3 \ {1})) ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (SmoothingFnonneg : ∀ x > 0, 0 ≤ SmoothingF x) ++ (mass_one : ∫ x in Ioi 0, SmoothingF x / x = 1) ++ (diff_SmoothingF : ContDiff ℝ 1 SmoothingF) : ++ I₃₇ SmoothingF ε T X σ₁ = ++ I₃ SmoothingF ε T X σ₁ - ++ I₄ SmoothingF ε X σ₁ σ₂ + ++ I₅ SmoothingF ε X σ₂ + ++ I₆ SmoothingF ε X σ₁ σ₂ + ++ I₇ SmoothingF ε T X σ₁ := by ++ let z : ℂ := σ₂ - 3 * I ++ let w : ℂ := σ₁ + 3 * I ++ have σ₁_pos : 0 < σ₁ := by linarith ++ ++ have sub : z.Rectangle w ⊆ Icc σ₂ 2 ×ℂ Icc (-3) 3 \ {1} := by ++ ++ intro x hx ++ constructor ++ . ++ simp only [Rectangle, uIcc] at hx ++ rw [Complex.mem_reProdIm] at hx ⊢ ++ obtain ⟨hx_re, hx_im⟩ := hx ++ ++ have hzw_re : z.re < w.re := by ++ simp only [z, w, add_re, sub_re, mul_re, ofReal_re, re_ofNat, im_ofNat, I_re, I_im, mul_zero, sub_zero, add_zero, mul_one] ++ linarith ++ have x_re_bounds : z.re ≤ x.re ∧ x.re ≤ w.re := by ++ exact interval_membership x.re z.re w.re hx_re hzw_re ++ have x_re_in_Icc : x.re ∈ Icc σ₂ 2 := by ++ have ⟨h_left, h_right⟩ := x_re_bounds ++ have h_left' : σ₂ ≤ x.re := by ++ simp only [z, sub_re, mul_re, ofReal_re, re_ofNat, im_ofNat, I_re, I_im, mul_zero, sub_zero, mul_one] at h_left ++ linarith ++ have h_right' : x.re ≤ 2 := by ++ apply le_trans h_right ++ simp only [w, add_re, mul_re, ofReal_re, re_ofNat, im_ofNat, I_re, I_im, mul_zero, sub_zero, add_zero, mul_one] ++ linarith ++ exact ⟨h_left', h_right'⟩ ++ ++ have hzw_im : z.im < w.im := by ++ simp only [z, w, ofReal_im, re_ofNat, im_ofNat, I_re, I_im, mul_zero, add_zero, add_im, sub_im, mul_im, mul_one, zero_sub] ++ linarith ++ have x_im_bounds : z.im ≤ x.im ∧ x.im ≤ w.im := by ++ exact interval_membership x.im z.im w.im hx_im hzw_im ++ have x_im_in_Icc : x.im ∈ Icc (-3) 3 := by ++ have ⟨h_left, h_right⟩ := x_im_bounds ++ have h_left' : -3 ≤ x.im := by ++ simp only [z, ofReal_im, re_ofNat, im_ofNat, I_re, I_im, mul_zero, add_zero, sub_im, mul_im, mul_one, zero_sub] at h_left ++ linarith ++ have h_right' : x.im ≤ 3 := by ++ simp only [w, ofReal_im, re_ofNat, im_ofNat, I_re, I_im, mul_zero, add_zero, add_im, mul_im, mul_one] at h_right ++ linarith ++ exact ⟨h_left', h_right'⟩ ++ exact ⟨x_re_in_Icc, x_im_in_Icc⟩ ++ ++ . simp only [mem_singleton_iff] ++ ++ have x_re_upper: x.re ≤ σ₁ := by ++ simp only [Rectangle, uIcc] at hx ++ rw [Complex.mem_reProdIm] at hx ++ obtain ⟨hx_re, _⟩ := hx ++ ++ have hzw_re : z.re < w.re := by ++ simp only [z, w, add_re, sub_re, mul_re, ofReal_re, re_ofNat, im_ofNat, I_re, I_im, mul_zero, sub_zero, add_zero, mul_one] ++ linarith ++ have x_re_bounds : z.re ≤ x.re ∧ x.re ≤ w.re := by ++ exact interval_membership x.re z.re w.re hx_re hzw_re ++ have x_re_upper' : x.re ≤ w.re := by exact x_re_bounds.2 ++ simp only [w, add_re, mul_re, ofReal_re, re_ofNat, im_ofNat, I_re, I_im, mul_zero, sub_zero, add_zero, mul_one] at x_re_upper' ++ linarith ++ ++ have h_x_ne_one : x ≠ 1 := by ++ intro h_eq ++ have h_re : x.re = 1 := by rw [h_eq, Complex.one_re] ++ have h1 : 1 ≤ σ₁ := by ++ rw [← h_re] ++ exact x_re_upper ++ linarith ++ exact h_x_ne_one ++ have zero_over_box := HolomorphicOn.vanishesOnRectangle holoOn2 sub ++ have splitting : I₃₇ SmoothingF ε T X σ₁ = ++ I₃ SmoothingF ε T X σ₁ + I₅ SmoothingF ε X σ₁ + I₇ SmoothingF ε T X σ₁ := by ++ unfold I₃₇ I₃ I₅ I₇ ++ apply verticalIntegral_split_three_finite' ++ · apply ContinuousOn.integrableOn_Icc ++ unfold SmoothedChebyshevIntegrand ++ apply ContinuousOn.mul ++ · apply ContinuousOn.mul ++ · apply SmoothedChebyshevPull2_aux1 σ₁_lt_one holoOn ++ · apply continuousOn_of_forall_continuousAt ++ intro t t_mem ++ have := Smooth1MellinDifferentiable diff_SmoothingF suppSmoothingF ⟨ε_pos, ε_lt_one⟩ SmoothingFnonneg mass_one (s := ↑σ₁ + ↑t * I) (by simpa) ++ simpa using! realDiff_of_complexDiff _ this ++ · apply continuousOn_of_forall_continuousAt ++ intro t t_mem ++ apply ContinuousAt.comp ++ · refine continuousAt_const_cpow' ?_ ++ intro h ++ have : σ₁ = 0 := by ++ have h_real : (↑σ₁ + ↑t * I).re = (0 : ℂ).re := by ++ rw [h] ++ simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, add_zero, zero_re] at h_real ++ exact h_real ++ linarith ++ · ++ apply ContinuousAt.add ++ · exact continuousAt_const ++ · apply ContinuousAt.mul ++ · apply continuous_ofReal.continuousAt ++ · exact continuousAt_const ++ · refine ⟨by linarith, by linarith, by linarith⟩ ++ calc I₃₇ SmoothingF ε T X σ₁ = I₃₇ SmoothingF ε T X σ₁ - (1 / (2 * π * I)) * (0 : ℂ) := by simp ++ _ = I₃₇ SmoothingF ε T X σ₁ - (1 / (2 * π * I)) * (RectangleIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z w) := by rw [← zero_over_box] ++ _ = I₃₇ SmoothingF ε T X σ₁ - (1 / (2 * π * I)) * (HIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re w.re z.im ++ - HIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re w.re w.im ++ + VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) w.re z.im w.im ++ - VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re z.im w.im) := by simp [RectangleIntegral] ++ _ = I₃₇ SmoothingF ε T X σ₁ - ((1 / (2 * π * I)) * HIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re w.re z.im ++ - (1 / (2 * π * I)) * HIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re w.re w.im ++ + (1 / (2 * π * I)) * VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) w.re z.im w.im ++ - (1 / (2 * π * I)) * VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re z.im w.im) := by ring ++ _ = I₃₇ SmoothingF ε T X σ₁ - (I₄ SmoothingF ε X σ₁ σ₂ ++ - (1 / (2 * π * I)) * HIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re w.re w.im ++ + (1 / (2 * π * I)) * VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) w.re z.im w.im ++ - (1 / (2 * π * I)) * VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re z.im w.im) := by ++ simp only [one_div, mul_inv_rev, inv_I, neg_mul, HIntegral, sub_im, ofReal_im, mul_im, ++ re_ofNat, I_im, mul_one, im_ofNat, I_re, mul_zero, add_zero, zero_sub, ofReal_neg, ++ ofReal_ofNat, sub_re, ofReal_re, mul_re, sub_self, sub_zero, add_re, add_im, zero_add, ++ sub_neg_eq_add, I₄, sub_right_inj, add_left_inj, neg_inj, mul_eq_mul_left_iff, mul_eq_zero, ++ I_ne_zero, inv_eq_zero, ofReal_eq_zero, OfNat.ofNat_ne_zero, or_false, false_or, z, w] ++ left ++ rfl ++ _ = I₃₇ SmoothingF ε T X σ₁ - (I₄ SmoothingF ε X σ₁ σ₂ ++ - I₆ SmoothingF ε X σ₁ σ₂ ++ + (1 / (2 * π * I)) * VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) w.re z.im w.im ++ - (1 / (2 * π * I)) * VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re z.im w.im) := by ++ simp only [one_div, mul_inv_rev, inv_I, neg_mul, HIntegral, add_im, ofReal_im, mul_im, ++ re_ofNat, I_im, mul_one, im_ofNat, I_re, mul_zero, add_zero, zero_add, ofReal_ofNat, sub_re, ++ ofReal_re, mul_re, sub_self, sub_zero, add_re, sub_neg_eq_add, sub_im, zero_sub, I₆, w, z] ++ _ = I₃₇ SmoothingF ε T X σ₁ - (I₄ SmoothingF ε X σ₁ σ₂ ++ - I₆ SmoothingF ε X σ₁ σ₂ ++ + I₅ SmoothingF ε X σ₁ ++ - (1 / (2 * π * I)) * VIntegral (SmoothedChebyshevIntegrand SmoothingF ε X) z.re z.im w.im) := by ++ simp only [one_div, mul_inv_rev, inv_I, neg_mul, VIntegral, add_re, ofReal_re, mul_re, ++ re_ofNat, I_re, mul_zero, im_ofNat, I_im, mul_one, sub_self, add_zero, sub_im, ofReal_im, ++ mul_im, zero_sub, add_im, zero_add, smul_eq_mul, sub_re, sub_zero, sub_neg_eq_add, I₅, ++ w, z] ++ _ = I₃₇ SmoothingF ε T X σ₁ - (I₄ SmoothingF ε X σ₁ σ₂ ++ - I₆ SmoothingF ε X σ₁ σ₂ ++ + I₅ SmoothingF ε X σ₁ ++ - I₅ SmoothingF ε X σ₂) := by ++ simp only [I₅, one_div, mul_inv_rev, inv_I, neg_mul, VIntegral, sub_re, ofReal_re, mul_re, ++ re_ofNat, I_re, mul_zero, im_ofNat, I_im, mul_one, sub_self, sub_zero, sub_im, ofReal_im, ++ mul_im, add_zero, zero_sub, add_im, zero_add, smul_eq_mul, sub_neg_eq_add, z, w] ++ ++ _ = I₃ SmoothingF ε T X σ₁ ++ + I₅ SmoothingF ε X σ₁ ++ + I₇ SmoothingF ε T X σ₁ ++ - (I₄ SmoothingF ε X σ₁ σ₂ ++ - I₆ SmoothingF ε X σ₁ σ₂ ++ + I₅ SmoothingF ε X σ₁ ++ - I₅ SmoothingF ε X σ₂) := by ++ rw [splitting] ++ _ = I₃ SmoothingF ε T X σ₁ ++ - I₄ SmoothingF ε X σ₁ σ₂ ++ + I₅ SmoothingF ε X σ₂ ++ + I₆ SmoothingF ε X σ₁ σ₂ ++ + I₇ SmoothingF ε T X σ₁ := by ++ ring ++ ++theorem ZetaBoxEval {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (mass_one : ∫ x in Ioi 0, SmoothingF x / x = 1) ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) : ++ ∃ C, ∀ᶠ ε in (nhdsWithin 0 (Ioi 0)), ∀ X : ℝ, 0 ≤ X → ++ ‖𝓜 ((Smooth1 SmoothingF ε) ·) 1 * X - X‖ ≤ C * ε * X := by ++ have := MellinOfSmooth1c ContDiffSmoothingF suppSmoothingF mass_one ++ clear suppSmoothingF mass_one ContDiffSmoothingF ++ rw[Asymptotics.isBigO_iff] at this ++ obtain ⟨C, hC⟩ := this ++ use C ++ have εpos : ∀ᶠ (ε : ℝ) in nhdsWithin 0 (Ioi 0), ε > 0 := ++ eventually_mem_of_tendsto_nhdsWithin fun ⦃U⦄ hU ↦ hU ++ filter_upwards [hC, εpos] with ε hC εpos ++ rw[id_eq, norm_of_nonneg (le_of_lt εpos)] at hC ++ intro X Xnne ++ nth_rw 2 [← one_mul (X : ℂ)] ++ rw[← sub_mul, norm_mul, norm_real, norm_of_nonneg Xnne] ++ exact mul_le_mul_of_nonneg_right hC Xnne ++ ++theorem norm_reciprocal_inequality_1 (x : ℝ) (x₁ : ℝ) (hx₁ : x₁ ≥ 1) : ++ ‖x^2 + x₁^2‖₊⁻¹ ≤ (‖x₁‖₊^2)⁻¹ := by ++ ++ have h1 : x₁^2 ≥ 1 := by ++ have h_abs : |x₁| ≥ 1 := by ++ rw [abs_of_pos] ++ linarith ++ positivity ++ simp only [ge_iff_le, one_le_sq_iff_one_le_abs, h_abs] ++ ++ have h2 : x^2 + x₁^2 ≥ x₁^2 := by ++ linarith [sq_nonneg x] ++ ++ have h3 : x₁^2 > 0 := by ++ apply sq_pos_of_ne_zero ++ linarith ++ ++ have h33 : 2 * x₁^2 > 0 := by ++ simp [*] ++ ++ have h4 : x^2 + x₁^2 > 0 := by ++ linarith [sq_nonneg x, h3] ++ ++ have h5 : x₁^2 ≤ x^2 + x₁^2 := h2 ++ ++ have h6 : ‖x₁^2‖₊ = ‖x₁‖₊^2 := by ++ rw [nnnorm_pow] ++ ++ have h7 : ‖x^2 + x₁^2‖₊ = x^2 + x₁^2 := by ++ rw [Real.nnnorm_of_nonneg (le_of_lt h4)] ++ norm_cast ++ ++ rw [← NNReal.coe_le_coe] ++ push_cast ++ simp [*] ++ simp_all ++ rw [abs_of_nonneg] ++ · have U := inv_le_inv₀ h4 h3 ++ rw [U] ++ simp [*] ++ ++ · positivity ++ ++theorem norm_reciprocal_inequality (x : ℝ) (x₁ : ℝ) (hx₁ : x₁ ≤ -1) : ++ ‖x^2 + x₁^2‖₊⁻¹ ≤ (‖x₁‖₊^2)⁻¹ := by ++ ++ have h1 : x₁^2 ≥ 1 := by ++ have h_abs : |x₁| ≥ 1 := by ++ rw [abs_of_nonpos (le_of_lt (lt_of_le_of_lt hx₁ (by norm_num : (-1 : ℝ) < 0)))] ++ linarith ++ simp only [ge_iff_le, one_le_sq_iff_one_le_abs, h_abs] ++ ++ have h2 : x^2 + x₁^2 ≥ x₁^2 := by ++ linarith [sq_nonneg x] ++ ++ have h3 : x₁^2 > 0 := by ++ apply sq_pos_of_ne_zero ++ linarith ++ ++ have h33 : 2 * x₁^2 > 0 := by ++ simp [*] ++ ++ have h4 : x^2 + x₁^2 > 0 := by ++ linarith [sq_nonneg x, h3] ++ ++ have h5 : x₁^2 ≤ x^2 + x₁^2 := h2 ++ ++ have h6 : ‖x₁^2‖₊ = ‖x₁‖₊^2 := by ++ rw [nnnorm_pow] ++ ++ have h7 : ‖x^2 + x₁^2‖₊ = x^2 + x₁^2 := by ++ rw [Real.nnnorm_of_nonneg (le_of_lt h4)] ++ norm_cast ++ ++ rw [← NNReal.coe_le_coe] ++ push_cast ++ simp [*] ++ simp_all ++ rw [abs_of_nonneg] ++ · have U := inv_le_inv₀ h4 h3 ++ rw [U] ++ simp [*] ++ ++ · positivity ++ ++theorem poisson_kernel_integrable (x : ℝ) (hx : x ≠ 0) : ++ MeasureTheory.Integrable (fun (t : ℝ) ↦ (‖x + t * I‖^2)⁻¹) := by ++ ++ have h1 : ∀ t : ℝ, ‖x + t * I‖^2 = x^2 + t^2 := by ++ intro t ++ rw [Complex.norm_add_mul_I, Real.sq_sqrt] ++ positivity ++ ++ have h2 : (fun (t : ℝ) ↦ (‖x + t * I‖^2)⁻¹) = (fun (t : ℝ) ↦ (x^2 + t^2)⁻¹) := by ++ ext t ++ rw [h1] ++ rw [h2] ++ ++ have h3 : ∀ t : ℝ, x^2 + t^2 > 0 := by ++ intro t ++ apply add_pos_of_pos_of_nonneg ++ · exact sq_pos_of_ne_zero hx ++ · exact sq_nonneg t ++ ++ have h4 : Continuous (fun t : ℝ ↦ (x^2 + t^2)⁻¹) := by ++ apply Continuous.inv₀ ++ · exact continuous_const.add (continuous_pow 2) ++ · intro t ++ exact ne_of_gt (h3 t) ++ ++ have integrable_on_bounded : ∀ R > 0, MeasureTheory.IntegrableOn (fun t : ℝ ↦ (x^2 + t^2)⁻¹) (Set.Icc (-R) R) := by ++ intro R hR ++ refine ContinuousOn.integrableOn_Icc ?_ ++ · exact Continuous.continuousOn h4 ++ ++ have decay_bound : ∀ t : ℝ, 0 < |t| → (x^2 + t^2)⁻¹ ≤ (t^2)⁻¹ := by ++ intro t hyp_t ++ rw [←inv_le_inv₀] ++ simp_all only [ne_eq, gt_iff_lt, abs_pos, inv_inv, le_add_iff_nonneg_left] ++ · positivity ++ · simp_all only [ne_eq, gt_iff_lt, abs_pos, inv_pos] ++ positivity ++ · positivity ++ ++ have decay_bound_1 : ∀ x_1 ≤ -1, ‖x ^ 2 + x_1 ^ 2‖₊⁻¹ ≤ (‖x_1‖₊ ^ 2)⁻¹ := by ++ exact norm_reciprocal_inequality x ++ ++ have decay_bound_2 : ∀ (x_1 : ℝ), 1 ≤ x_1 → ‖x ^ 2 + x_1 ^ 2‖₊⁻¹ ≤ (‖x_1‖₊ ^ 2)⁻¹ := by ++ exact norm_reciprocal_inequality_1 x ++ ++ have f_int_1 : IntegrableOn (fun (t : ℝ) ↦ (t^2)⁻¹) (Set.Iic (-1)) volume := by ++ have D1 : (-2) < (-1 : ℝ) := by simp_all only [ne_eq, gt_iff_lt, abs_pos, neg_lt_neg_iff, ++ Nat.one_lt_ofNat] ++ have D2 : 0 < (1 : ℝ) := by simp only [zero_lt_one] ++ have D := integrableOn_Ioi_rpow_of_lt D1 D2 ++ have D3 := MeasureTheory.IntegrableOn.comp_neg D ++ simp only [rpow_neg_ofNat, Int.reduceNeg, zpow_neg, neg_Ioi] at D3 ++ have D4 := ++ (integrableOn_Iic_iff_integrableOn_Iio' ++ (by ++ refine EReal.coe_ennreal_ne_coe_ennreal_iff.mp ?_ ++ · simp_all only [ne_eq, gt_iff_lt, abs_pos, neg_lt_neg_iff, Nat.one_lt_ofNat, ++ zero_lt_one, rpow_neg_ofNat, Int.reduceNeg, zpow_neg, measure_singleton, ++ EReal.coe_ennreal_zero, EReal.coe_ennreal_top, EReal.zero_ne_top, not_false_eq_true])).mpr D3 ++ simp_all only [ne_eq, gt_iff_lt, abs_pos, neg_lt_neg_iff, Nat.one_lt_ofNat, zero_lt_one, ++ rpow_neg_ofNat, Int.reduceNeg, zpow_neg] ++ unfold IntegrableOn at D4 ++ have eq_fun : (fun (x : ℝ) ↦ ((-x)^2)⁻¹) = fun x ↦ (x^2)⁻¹ := by ++ funext x ++ simp_all only [even_two, Even.neg_pow] ++ simp_all only [even_two, Even.neg_pow] ++ norm_cast at D4 ++ simp_all only [even_two, Even.neg_pow, Int.reduceNegSucc, Int.cast_neg, Int.cast_one] ++ exact D4 ++ ++ have f_int_2 : IntegrableOn (fun (t : ℝ) ↦ (t^2)⁻¹) (Set.Ici 1) volume := by ++ have D1 : (-2) < (-1 : ℝ) := by simp_all only [ne_eq, gt_iff_lt, abs_pos, neg_lt_neg_iff, ++ Nat.one_lt_ofNat] ++ have D2 : 0 < (1 : ℝ) := by simp only [zero_lt_one] ++ have D3 := integrableOn_Ioi_rpow_of_lt D1 D2 ++ simp only [rpow_neg_ofNat, Int.reduceNeg, zpow_neg] at D3 ++ have D4 := ++ (integrableOn_Ici_iff_integrableOn_Ioi' ++ (by ++ refine EReal.coe_ennreal_ne_coe_ennreal_iff.mp ?_ ++ · simp_all only [ne_eq, gt_iff_lt, abs_pos, neg_lt_neg_iff, Nat.one_lt_ofNat, ++ zero_lt_one, measure_singleton, EReal.coe_ennreal_zero, EReal.coe_ennreal_top, ++ EReal.zero_ne_top, not_false_eq_true])).mpr D3 ++ simp_all only [ne_eq, gt_iff_lt, abs_pos, neg_lt_neg_iff, Nat.one_lt_ofNat, zero_lt_one] ++ unfold IntegrableOn at D4 ++ have eq_fun : (fun (x : ℝ) ↦ ((-x)^2)⁻¹) = fun x ↦ (x^2)⁻¹ := by ++ funext x ++ simp_all only [even_two, Even.neg_pow] ++ simp_all only [even_two, Even.neg_pow] ++ norm_cast at D4 ++ ++ have int_neg : IntegrableOn (fun t : ℝ ↦ (x^2 + t^2)⁻¹) (Set.Iic (-1)) volume := by ++ have h_le : ∀ t ∈ Set.Iic (-1), (x^2 + t^2)⁻¹ ≤ (t^2)⁻¹ := by ++ intro t ht ++ simp only [Set.mem_Iic] at ht ++ ++ have t_neg : t < 0 := lt_of_le_of_lt ht (by norm_num : (-1 : ℝ) < 0) ++ exact decay_bound t (abs_pos.mpr (ne_of_lt t_neg)) ++ have h_meas : AEStronglyMeasurable (fun t : ℝ ↦ (x^2 + t^2)⁻¹) (volume.restrict (Set.Iic (-1))) := by ++ exact Continuous.aestronglyMeasurable h4 ++ ++ unfold IntegrableOn ++ unfold Integrable ++ constructor ++ · exact h_meas ++ · have Z : HasFiniteIntegral (fun t : ℝ ↦ (x^2 + t^2)⁻¹) (volume.restrict (Iic (-1))) := by ++ refine MeasureTheory.HasFiniteIntegral.mono'_enorm f_int_1.2 ?_ ++ · unfold Filter.Eventually ++ simp only [measurableSet_Iic, ae_restrict_eq, nnnorm_inv, nnnorm_pow, enorm_le_coe] ++ refine mem_inf_of_right ?_ ++ · refine mem_principal.mpr ?_ ++ · rw [Set.subset_def] ++ simp only [mem_Iic, mem_ofPred_eq] ++ exact decay_bound_1 ++ ++ exact Z ++ ++ have int_pos : IntegrableOn (fun t : ℝ ↦ (x^2 + t^2)⁻¹) (Set.Ici 1) volume := by ++ have h_le : ∀ t ∈ Set.Ici 1, (x^2 + t^2)⁻¹ ≤ (t^2)⁻¹ := by ++ intro t ht ++ simp only [Set.mem_Ici] at ht ++ ++ have t_pos : t > 0 := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) ht ++ exact decay_bound t (abs_pos.mpr (ne_of_gt t_pos)) ++ have h_meas : AEStronglyMeasurable (fun t : ℝ ↦ (x^2 + t^2)⁻¹) (volume.restrict (Set.Ici 1)) := by ++ exact Continuous.aestronglyMeasurable h4 ++ ++ unfold IntegrableOn ++ unfold Integrable ++ constructor ++ · exact h_meas ++ · have Z : HasFiniteIntegral (fun t : ℝ ↦ (x^2 + t^2)⁻¹) (volume.restrict (Ici (1))) := by ++ refine MeasureTheory.HasFiniteIntegral.mono'_enorm f_int_2.2 ?_ ++ · unfold Filter.Eventually ++ simp only [measurableSet_Ici, ae_restrict_eq, nnnorm_inv, nnnorm_pow, enorm_le_coe] ++ refine mem_inf_of_right ?_ ++ · refine mem_principal.mpr ?_ ++ · rw [Set.subset_def] ++ simp only [mem_Ici, mem_ofPred_eq] ++ exact decay_bound_2 ++ ++ exact Z ++ ++ have split : Set.univ = Set.Iic (-1) ∪ Set.Icc (-1) 1 ∪ Set.Ici 1 := by ++ ext t ++ simp only [Set.mem_univ, Set.mem_union, Set.mem_Iic, Set.mem_Icc, Set.mem_Ici, true_iff] ++ by_cases h : t ≤ -1 ++ · left; left; exact h ++ · by_cases h' : t ≥ 1 ++ · right; exact h' ++ · left; right; constructor <;> linarith ++ ++ have Z := ++ MeasureTheory.IntegrableOn.union ++ (MeasureTheory.IntegrableOn.union ++ (int_neg) ++ (integrable_on_bounded 1 zero_lt_one)) ++ (int_pos) ++ ++ simp_all only [ne_eq, gt_iff_lt, abs_pos, Int.reduceNeg, neg_le_self_iff, zero_le_one, Iic_union_Icc_eq_Iic, ++ Iic_union_Ici, integrableOn_univ] ++ ++theorem ae_volume_of_contains_compl_singleton_zero ++ (s : Set ℝ) ++ (h : (univ : Set ℝ) \ {0} ⊆ s) : ++ s ∈ (MeasureTheory.ae volume) := by ++ ++ have h_zero_null : volume ({0} : Set ℝ) = 0 := by ++ exact volume_singleton ++ ++ have h_compl_subset : sᶜ ⊆ {0} := by ++ intro x hx ++ ++ by_contra h_not_zero ++ have : x ∈ univ \ {0} := ⟨trivial, h_not_zero⟩ ++ exact hx (h this) ++ ++ have h_compl_measure : volume sᶜ ≤ volume ({0} : Set ℝ) := ++ measure_mono h_compl_subset ++ ++ have h_compl_zero : volume sᶜ = 0 := by ++ rw [h_zero_null] at h_compl_measure ++ exact le_antisymm h_compl_measure zero_le ++ ++ rwa [mem_ae_iff] ++ ++theorem integral_evaluation (x : ℝ) (T : ℝ) ++ : (3 < T) → ∫ (t : ℝ) in Iic (-T), (‖x + t * I‖ ^ 2)⁻¹ ≤ T⁻¹ := by ++ ++ intro T_large ++ ++ have T00 : ∀ (x t : ℝ), t^2 ≤ ‖x + t * I‖^2 := by ++ intro x t ++ rw [Complex.norm_add_mul_I x t] ++ ring_nf ++ rw [Real.sq_sqrt _] ++ simp only [le_add_iff_nonneg_right]; positivity ++ positivity ++ ++ have T0 : ∀ (x t : ℝ), t ≠ 0 → (‖x + t * I‖^2)⁻¹ ≤ (t^2)⁻¹ := by ++ intro x t hyp ++ have U0 : 0 < t^2 := by positivity ++ have U1 : 0 < ‖x + t * I‖^2 := by ++ rw [Complex.norm_add_mul_I x t] ++ rw [Real.sq_sqrt _] ++ positivity ++ positivity ++ rw [inv_le_inv₀ U1 U0] ++ exact (T00 x t) ++ ++ have T1 : (fun (t : ℝ) ↦ (‖x + t * I‖^2)⁻¹) ≤ᶠ[ae (volume.restrict (Iic (-T)))] (fun (t : ℝ) ↦ (t^2)⁻¹) := by ++ unfold Filter.EventuallyLE ++ unfold Filter.Eventually ++ simp_all only [ne_eq, measurableSet_Iic, ae_restrict_eq] ++ refine mem_inf_of_left ?_ ++ · refine Filter.mem_sets.mp ?_ ++ · have U : {x_1 : ℝ | x_1 ≠ 0} ⊆ {x_1 : ℝ | (‖x + x_1 * I‖ ^ 2)⁻¹ ≤ (x_1 ^ 2)⁻¹} := by ++ rw [Set.ofPred_subset_ofPred] ++ intro t hyp_t ++ exact T0 x t hyp_t ++ have U1 : {x_1 : ℝ | x_1 ≠ 0} = (univ \ {0}) := by ++ apply Set.ext ++ intro x ++ simp_all only [ne_eq, ofPred_subset_ofPred, not_false_eq_true, implies_true, mem_ofPred_eq, Set.mem_sdiff, mem_univ, ++ mem_singleton_iff, true_and] ++ ++ rw [U1] at U ++ have Z := ae_volume_of_contains_compl_singleton_zero ++ ({x_1 : ℝ | (‖x + x_1 * I‖ ^ 2)⁻¹ ≤ (x_1 ^ 2)⁻¹} : Set ℝ) U ++ exact Z ++ ++ have T2 : 0 ≤ᶠ[ae (volume.restrict (Iic (-T)))] (fun (t : ℝ) ↦ (‖x + t * I‖^2)⁻¹) := by ++ unfold Filter.EventuallyLE ++ unfold Filter.Eventually ++ simp_all only [ne_eq, Pi.zero_apply, inv_nonneg, norm_nonneg, pow_nonneg, ++ ofPred_true, univ_mem] ++ ++ have T4 : deriv (fun (t : ℝ) ↦ t⁻¹) = (fun t ↦ (- (t^2)⁻¹)) := by ++ exact deriv_inv' ++ ++ have hcont : ContinuousWithinAt (fun t ↦ t⁻¹) (Set.Iic (-T)) (-T) := by ++ refine ContinuousWithinAt.inv₀ ?_ ?_ ++ · exact ContinuousAt.continuousWithinAt fun ⦃U⦄ a ↦ a ++ · intro hyp ++ linarith ++ ++ have hderiv : ∀ x ∈ Set.Iio (-T), HasDerivAt (fun t ↦ t⁻¹) ((fun t ↦ - (t^2)⁻¹) x) x := by ++ ++ intro x hx ++ ++ have hx_ne_zero : x ≠ 0 := by ++ intro h ++ rw [h] at hx ++ simp [Set.Iio] at hx ++ linarith ++ ++ convert hasDerivAt_inv hx_ne_zero ++ ++ have f'int : IntegrableOn (fun t ↦ - (t^2)⁻¹) (Set.Iic (-T)) volume := by ++ have D1 : (-2) < (-1 : ℝ) := by simp only [neg_lt_neg_iff, Nat.one_lt_ofNat] ++ have D2 : 0 < T := by positivity ++ have D := integrableOn_Ioi_rpow_of_lt D1 D2 ++ ++ have D3 := MeasureTheory.IntegrableOn.comp_neg D ++ simp [*] at D3 ++ have D4 := ++ (integrableOn_Iic_iff_integrableOn_Iio' ++ (by ++ refine EReal.coe_ennreal_ne_coe_ennreal_iff.mp ?_ ++ · simp_all only [ne_eq, measurableSet_Iic, ae_restrict_eq, deriv_inv', mem_Iio, neg_lt_neg_iff, ++ Nat.one_lt_ofNat, rpow_neg_ofNat, Int.reduceNeg, zpow_neg, measure_singleton, EReal.coe_ennreal_zero, ++ EReal.coe_ennreal_top, EReal.zero_ne_top, not_false_eq_true])).mpr D3 ++ simp_all only [ne_eq, measurableSet_Iic, ae_restrict_eq, deriv_inv', mem_Iio, neg_lt_neg_iff, ++ Nat.one_lt_ofNat, rpow_neg_ofNat, Int.reduceNeg, zpow_neg] ++ ++ unfold IntegrableOn at D4 ++ have eq_fun : (fun (x : ℝ) ↦ ((-x)^2)⁻¹) = fun x ↦ (x^2)⁻¹ := by ++ funext x ++ simp_all only [even_two, Even.neg_pow] ++ ++ simp_all only [even_two, Even.neg_pow] ++ have D6 := MeasureTheory.integrable_neg_iff.mpr D4 ++ have eq_fun : (-fun x ↦ (x^2)⁻¹) = (fun (x : ℝ) ↦ - (x^2)⁻¹) := by ++ funext x ++ simp only [Pi.neg_apply] ++ rw [eq_fun] at D6 ++ exact D6 ++ ++ have hf : Filter.Tendsto (fun (t : ℝ) ↦ t⁻¹) Filter.atBot (nhds 0) := by exact ++ tendsto_inv_atBot_zero ++ ++ have T5 : ∫ (t : ℝ) in Iic (-T), - (t^2)⁻¹ = (-T)⁻¹ - 0 := by ++ exact MeasureTheory.integral_Iic_of_hasDerivAt_of_tendsto hcont hderiv f'int hf ++ ++ have T6 : ∫ (t : ℝ) in Iic (-T), (t^2)⁻¹ = T⁻¹ := by ++ simp only [inv_neg, sub_zero] at T5 ++ have D6 : - ∫ (t : ℝ) in Iic (-T), - (t^2)⁻¹ = ∫ (t : ℝ) in Iic (-T), (t^2)⁻¹ := by ++ simp only [integral_neg fun a ↦ (a ^ 2)⁻¹, neg_neg] ++ ++ rw [←D6] ++ rw [T5] ++ simp only [neg_neg] ++ ++ have T3 : Integrable (fun (t : ℝ) ↦ (t^2)⁻¹) (volume.restrict (Iic (-T))) := by ++ ++ have D1 : (-2) < (-1 : ℝ) := by simp only [neg_lt_neg_iff, Nat.one_lt_ofNat] ++ have D2 : 0 < T := by positivity ++ have D := integrableOn_Ioi_rpow_of_lt D1 D2 ++ ++ have D3 := MeasureTheory.IntegrableOn.comp_neg D ++ simp only [rpow_neg_ofNat, Int.reduceNeg, zpow_neg, neg_Ioi] at D3 ++ have D4 := ++ (integrableOn_Iic_iff_integrableOn_Iio' ++ (by ++ refine EReal.coe_ennreal_ne_coe_ennreal_iff.mp ?_ ++ · simp_all only [ne_eq, measurableSet_Iic, ae_restrict_eq, deriv_inv', mem_Iio, inv_neg, sub_zero, ++ neg_lt_neg_iff, Nat.one_lt_ofNat, rpow_neg_ofNat, Int.reduceNeg, zpow_neg, measure_singleton, EReal.coe_ennreal_zero, ++ EReal.coe_ennreal_top, EReal.zero_ne_top, not_false_eq_true])).mpr D3 ++ simp_all only [ne_eq, measurableSet_Iic, ae_restrict_eq, deriv_inv', mem_Iio, inv_neg, sub_zero, ++ neg_lt_neg_iff, Nat.one_lt_ofNat, rpow_neg_ofNat, Int.reduceNeg, zpow_neg] ++ ++ unfold IntegrableOn at D4 ++ have eq_fun : (fun (x : ℝ) ↦ ((-x)^2)⁻¹) = fun x ↦ (x^2)⁻¹ := by ++ funext x ++ simp_all only [even_two, Even.neg_pow] ++ simp_all only [even_two, Even.neg_pow] ++ norm_cast at D4 ++ simp_all only [even_two, Even.neg_pow] ++ ++ have Z := ++ by ++ calc ++ ∫ (t : ℝ) in Iic (-T), (‖x + t * I‖ ^ 2)⁻¹ ≤ ∫ (t : ℝ) in Iic (-T), (t^2)⁻¹ := by ++ exact MeasureTheory.integral_mono_of_nonneg T2 T3 T1 ++ ++ _ = T⁻¹ := by exact T6 ++ ++ exact Z ++ ++theorem integral_evaluation' (x : ℝ) (T : ℝ) ++ : (3 < T) → ∫ (t : ℝ) in Ici (T), (‖x + t * I‖ ^ 2)⁻¹ ≤ T⁻¹ := by ++ intro T_large ++ ++ have T00 : ∀ (x t : ℝ), t^2 ≤ ‖x + t * I‖^2 := by ++ intro x t ++ rw [Complex.norm_add_mul_I x t] ++ ring_nf ++ rw [Real.sq_sqrt _] ++ simp only [le_add_iff_nonneg_right]; positivity ++ positivity ++ ++ have T0 : ∀ (x t : ℝ), t ≠ 0 → (‖x + t * I‖^2)⁻¹ ≤ (t^2)⁻¹ := by ++ intro x t hyp ++ have U0 : 0 < t^2 := by positivity ++ have U1 : 0 < ‖x + t * I‖^2 := by ++ rw [Complex.norm_add_mul_I x t] ++ rw [Real.sq_sqrt _] ++ positivity ++ positivity ++ rw [inv_le_inv₀ U1 U0] ++ exact (T00 x t) ++ ++ have T2 : 0 ≤ᶠ[ae (volume.restrict (Ioi T))] (fun (t : ℝ) ↦ (‖x + t * I‖^2)⁻¹) := by ++ unfold Filter.EventuallyLE ++ unfold Filter.Eventually ++ simp_all only [ne_eq, Pi.zero_apply, inv_nonneg, norm_nonneg, pow_nonneg, ++ ofPred_true, univ_mem] ++ ++ have T3 : Integrable (fun (t : ℝ) ↦ - (t^2)⁻¹) (volume.restrict (Ioi T)) := by ++ have D1 : (-2) < (-1 : ℝ) := by simp only [neg_lt_neg_iff, Nat.one_lt_ofNat] ++ have D2 : 0 < T := by positivity ++ have D := integrableOn_Ioi_rpow_of_lt D1 D2 ++ simp only [rpow_neg_ofNat, Int.reduceNeg, zpow_neg] at D ++ exact MeasureTheory.Integrable.fun_neg D ++ ++ have T3' : Integrable (fun (t : ℝ) ↦ (t^2)⁻¹) (volume.restrict (Ioi T)) := by ++ have D := MeasureTheory.Integrable.fun_neg T3 ++ simp_all only [ne_eq, measurableSet_Ioi, ae_restrict_eq, neg_neg] ++ ++ have T1 : (fun (t : ℝ) ↦ (‖x + t * I‖^2)⁻¹) ≤ᶠ[ae (volume.restrict (Ioi T))] (fun (t : ℝ) ↦ (t^2)⁻¹) := by ++ unfold Filter.EventuallyLE ++ unfold Filter.Eventually ++ simp_all only [ne_eq, measurableSet_Ioi, ae_restrict_eq] ++ refine mem_inf_of_left ?_ ++ · refine Filter.mem_sets.mp ?_ ++ · have U : {x_1 : ℝ | x_1 ≠ 0} ⊆ {x_1 : ℝ | (‖x + x_1 * I‖ ^ 2)⁻¹ ≤ (x_1 ^ 2)⁻¹} := by ++ rw [Set.ofPred_subset_ofPred] ++ intro t hyp_t ++ exact T0 x t hyp_t ++ have U1 : {x_1 : ℝ | x_1 ≠ 0} = (univ \ {0}) := by ++ apply Set.ext ++ intro x ++ simp_all only [ne_eq, ofPred_subset_ofPred, not_false_eq_true, implies_true, mem_ofPred_eq, Set.mem_sdiff, mem_univ, ++ mem_singleton_iff, true_and] ++ ++ rw [U1] at U ++ have Z := ae_volume_of_contains_compl_singleton_zero ++ ({x_1 : ℝ | (‖x + x_1 * I‖ ^ 2)⁻¹ ≤ (x_1 ^ 2)⁻¹} : Set ℝ) U ++ exact Z ++ ++ have hcont : ContinuousWithinAt (fun t ↦ t⁻¹) (Set.Ici T) T := by ++ refine ContinuousWithinAt.inv₀ ?_ ?_ ++ · exact ContinuousAt.continuousWithinAt fun ⦃U⦄ a ↦ a ++ · intro hyp ++ linarith ++ ++ have hderiv : ∀ x ∈ Set.Ioi T, HasDerivAt (fun t ↦ t⁻¹) ((fun t ↦ - (t^2)⁻¹) x) x := by ++ ++ intro x hx ++ ++ have hx_ne_zero : x ≠ 0 := by ++ intro h ++ rw [h] at hx ++ simp at hx ++ linarith ++ ++ convert hasDerivAt_inv hx_ne_zero ++ ++ have hf : Filter.Tendsto (fun (t : ℝ) ↦ t⁻¹) Filter.atTop (nhds 0) := by exact ++ tendsto_inv_atTop_zero ++ ++ have T5 : ∫ (t : ℝ) in Ioi T, (t^2)⁻¹ = (T)⁻¹ - 0 := by ++ have U := MeasureTheory.integral_Ioi_of_hasDerivAt_of_tendsto hcont hderiv T3 hf ++ simp [*] at U ++ rw [MeasureTheory.integral_neg] at U ++ simp_all only [ne_eq, mem_Ioi, neg_inj, sub_zero] ++ ++ have T6 : ∫ (t : ℝ) in Ioi T, (t^2)⁻¹ = T⁻¹ := by ++ simp only [sub_zero] at T5 ++ have D6 : - ∫ (t : ℝ) in Ioi T, - (t^2)⁻¹ = ∫ (t : ℝ) in Ioi T, (t^2)⁻¹ := by ++ simp only [integral_neg fun a ↦ (a ^ 2)⁻¹, neg_neg] ++ ++ rw [←D6] ++ rw [←T5] ++ exact D6 ++ ++ have Z := ++ by ++ calc ++ ∫ (t : ℝ) in Ioi T, (‖x + t * I‖ ^ 2)⁻¹ ≤ ∫ (t : ℝ) in Ioi T, (t^2)⁻¹ := by ++ exact MeasureTheory.integral_mono_of_nonneg T2 T3' T1 ++ ++ _ = T⁻¹ := by exact T6 ++ ++ rw [←MeasureTheory.integral_Ici_eq_integral_Ioi] at Z ++ ++ exact Z ++ ++lemma IBound_aux1 (X₀ : ℝ) (X₀pos : X₀ > 0) (k : ℕ) : ∃ C ≥ 1, ∀ X ≥ X₀, Real.log X ^ k ≤ C * X := by ++ ++ have ⟨M, hM⟩ := Filter.eventually_atTop.mp (isLittleO_log_rpow_rpow_atTop k zero_lt_one).eventuallyLE ++ ++ let f := fun X ↦ Real.log X ^ k / X ++ let I1 := Icc X₀ M ++ have : 0 ∉ I1 := notMem_Icc_of_lt X₀pos ++ have f_cont : ContinuousOn f (Icc X₀ M) := ++ ((continuousOn_log.pow k).mono (subset_compl_singleton_iff.mpr this)).div ++ continuous_id.continuousOn (fun x hx ↦ ne_of_mem_of_not_mem hx this) ++ have ⟨C₁, hC₁⟩ := isCompact_Icc.exists_bound_of_continuousOn f_cont ++ use max C₁ 1, le_max_right C₁ 1 ++ intro X hX ++ have Xpos : X > 0 := lt_of_lt_of_le X₀pos hX ++ by_cases hXM : X ≤ M ++ · rw[← div_le_iff₀ Xpos] ++ calc ++ f X ≤ ‖f X‖ := le_norm_self _ ++ _ ≤ C₁ := hC₁ X ⟨hX, hXM⟩ ++ _ ≤ max C₁ 1 := le_max_left C₁ 1 ++ · calc ++ Real.log X ^ k ≤ ‖Real.log X ^ k‖ := le_norm_self _ ++ _ ≤ ‖X ^ 1‖ := by exact_mod_cast hM X (by linarith[hXM]) ++ _ = 1 * X := by ++ rw[pow_one, one_mul] ++ apply norm_of_nonneg ++ exact Xpos.le ++ _ ≤ max C₁ 1 * X := by ++ rw[mul_le_mul_iff_left₀ Xpos] ++ exact le_max_right C₁ 1 ++ ++theorem I1Bound ++ {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ (SmoothingFnonneg : ∀ x > 0, 0 ≤ SmoothingF x) ++ (mass_one : ∫ x in Ioi 0, SmoothingF x / x = 1) : ++ ∃ C > 0, ∀(ε : ℝ) (_ : 0 < ε) ++ (_ : ε < 1) ++ (X : ℝ) (_ : 3 < X) ++ {T : ℝ} (_ : 3 < T), ++ ‖I₁ SmoothingF ε X T‖ ≤ C * X * Real.log X / (ε * T) := by ++ ++ obtain ⟨M, ⟨M_is_pos, M_bounds_mellin_hard⟩⟩ := ++ MellinOfSmooth1b ContDiffSmoothingF suppSmoothingF ++ ++ have G0 : ∃K > 0, ∀(t σ : ℝ), 1 < σ → σ < 2 → ‖ζ' (σ + t * I) / ζ (σ + t * I)‖ ≤ K * (σ - 1)⁻¹ := by ++ let ⟨K', ⟨K'_pos, K'_bounds_zeta⟩⟩ := strongPnt_triv_bound_zeta ++ use (2 * (K' + 1)) ++ use (by positivity) ++ intro t σ cond cond2 ++ ++ have T0 : 0 < K' + 1 := by positivity ++ have T1 : 1 ≤ (σ - 1)⁻¹ := by ++ have U : σ - 1 ≤ 1 := by linarith ++ have U1 := (inv_le_inv₀ (by positivity) (by exact sub_pos.mpr cond)).mpr U ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, mul_inv_rev, ge_iff_le, Complex.norm_div, ++ norm_neg, tsub_le_iff_right, inv_one] ++ ++ have T : (K' + 1) * 1 ≤ (K' + 1) * (σ - 1)⁻¹ := ++ by ++ exact (mul_le_mul_iff_right₀ T0).mpr T1 ++ have T2 : (K' + 1) ≤ (K' + 1) * (σ - 1)⁻¹ := by ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, mul_inv_rev, ge_iff_le, Complex.norm_div, ++ norm_neg, mul_one, le_mul_iff_one_le_right] ++ ++ have U := calc ++ ‖ζ' (σ + t * I) / ζ (σ + t * I)‖ = ‖-ζ' (σ + t * I) / ζ (σ + t * I)‖ := by ++ rw [← norm_neg _, mul_comm, neg_div' _ _] ++ _ ≤ (σ - 1)⁻¹ + K' := K'_bounds_zeta σ t cond ++ _ ≤ (σ - 1)⁻¹ + (K' + 1) := by aesop ++ _ ≤ (K' + 1) * (σ - 1)⁻¹ + (K' + 1) := by aesop ++ _ ≤ (K' + 1) * (σ - 1)⁻¹ + (K' + 1) * (σ - 1)⁻¹ := by linarith ++ _ = 2 * (K' + 1) * (σ - 1)⁻¹ := by ++ ring_nf ++ ++ exact U ++ ++ obtain ⟨K, ⟨K_is_pos, K_bounds_zeta_at_any_t'⟩⟩ := G0 ++ ++ have C_final_pos : |π|⁻¹ * 2⁻¹ * (Real.exp 1 * K * M) > 0 := by ++ positivity ++ ++ use (|π|⁻¹ * 2⁻¹ * (Real.exp 1 * K * M)) ++ use C_final_pos ++ ++ intro eps eps_pos eps_less_one X X_large T T_large ++ ++ let pts_re := 1 + (Real.log X)⁻¹ ++ let pts := fun (t : ℝ) ↦ (pts_re + t * I) ++ ++ have pts_re_triv : ∀(t : ℝ), (pts t).re = pts_re := by ++ intro t ++ unfold pts ++ simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, ++ add_zero] ++ ++ have pts_re_ge_one : 1 < pts_re := by ++ unfold pts_re ++ simp only [lt_add_iff_pos_right, inv_pos] ++ have U : 1 < X := by linarith ++ exact Real.log_pos U ++ ++ have pts_re_le_one : pts_re < 2 := by ++ unfold pts_re ++ have Z0 : 3 ∈ {x : ℝ | 1 ≤ x} := by ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, mul_inv_rev, gt_iff_lt, Complex.norm_div, ++ mem_ofPred_eq, Nat.one_le_ofNat] ++ have Z1 : X ∈ {x : ℝ | 1 ≤ x} := by ++ simp only [mem_ofPred_eq] ++ linarith ++ have Z : Real.log 3 < Real.log X := ++ by ++ refine log_lt_log ?_ X_large ++ simp only [Nat.ofNat_pos] ++ ++ have Z01 : 1 < Real.log 3 := ++ by ++ have Z001 : 1 = Real.log (rexp 1) := by exact Eq.symm (Real.log_exp 1) ++ rw [Z001] ++ have Z002 : (0 : ℝ) < rexp 1 := by positivity ++ have Z003 : (0 : ℝ) < 3 := by positivity ++ have Z004 : rexp 1 < 3 := by ++ calc ++ rexp 1 < (↑ 2.7182818286 : ℚ) := Real.exp_one_lt_d9 ++ _ < (↑ 3 : ℚ) := by linarith ++ ++ exact (Real.log_lt_log_iff Z002 Z003).mpr Z004 ++ ++ have Zpos0 : 0 < Real.log 3 := by positivity ++ have Zpos1 : 0 < Real.log X := by calc ++ 0 < Real.log 3 := Zpos0 ++ _ < Real.log X := Z ++ ++ have Z1 : (Real.log X)⁻¹ < (Real.log 3)⁻¹ := ++ by ++ exact (inv_lt_inv₀ Zpos1 Zpos0).mpr Z ++ ++ have Z02 : (Real.log 3)⁻¹ < 1 := by ++ have T01 := (inv_lt_inv₀ ?_ ?_).mpr Z01 ++ simp only [inv_one] at T01 ++ exact T01 ++ exact Zpos0 ++ simp only [zero_lt_one] ++ ++ have Z2 : 1 + (Real.log X)⁻¹ < 1 + (Real.log 3)⁻¹ := by ++ exact (add_lt_add_iff_left 1).mpr Z1 ++ ++ have Z3 : 1 + (Real.log 3)⁻¹ < 2 := by ++ calc ++ 1 + (Real.log 3)⁻¹ < 1 + 1 := by linarith ++ _ = 2 := by ring_nf ++ ++ calc ++ 1 + (Real.log X)⁻¹ < 1 + (Real.log 3)⁻¹ := Z2 ++ _ < 2 := Z3 ++ ++ have inve : (pts_re - 1)⁻¹ = Real.log X := by ++ unfold pts_re ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, mul_inv_rev, gt_iff_lt, ++ Complex.norm_div, add_sub_cancel_left, inv_inv] ++ ++ have K_bounds_zeta_at_any_t : ∀(t : ℝ), ‖ζ' (pts t) / ζ (pts t)‖ ≤ K * Real.log X := by ++ intro t ++ rw [←inve] ++ exact K_bounds_zeta_at_any_t' t pts_re pts_re_ge_one pts_re_le_one ++ ++ have pts_re_pos : pts_re > 0 := by ++ unfold pts_re ++ positivity ++ ++ have triv_pts_lo_bound : ∀(t : ℝ), pts_re ≤ (pts t).re := by ++ intro t ++ unfold pts_re ++ exact Eq.ge (pts_re_triv t) ++ ++ have triv_pts_up_bound : ∀(t : ℝ), (pts t).re ≤ 2 := by ++ intro t ++ unfold pts ++ refine EReal.coe_le_coe_iff.mp ?_ ++ · simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, mul_inv_rev, gt_iff_lt, ++ Complex.norm_div, le_refl, implies_true, add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, ++ I_im, mul_one, sub_self, add_zero, EReal.coe_le_coe_iff] ++ exact le_of_lt pts_re_le_one ++ ++ have pts_re_ge_1 : pts_re > 1 := by ++ unfold pts_re ++ exact pts_re_ge_one ++ ++ have X_pos_triv : 0 < X := by positivity ++ ++ let f := fun (t : ℝ) ↦ SmoothedChebyshevIntegrand SmoothingF eps X (pts t) ++ ++ have G : ∀(t : ℝ), ‖f t‖ ≤ (K * M) * Real.log X * (eps * ‖pts t‖^2)⁻¹ * X^pts_re := by ++ ++ intro t ++ ++ let M_bounds_mellin_easy := fun (t : ℝ) ↦ M_bounds_mellin_hard pts_re pts_re_pos (pts t) (triv_pts_lo_bound t) (triv_pts_up_bound t) eps eps_pos eps_less_one ++ ++ let zeta_part := (fun (t : ℝ) ↦ -ζ' (pts t) / ζ (pts t)) ++ let mellin_part := (fun (t : ℝ) ↦ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF eps x)) (pts t)) ++ let X_part := (fun (t : ℝ) ↦ (↑X : ℂ) ^ (pts t)) ++ ++ let g := fun (t : ℝ) ↦ (zeta_part t) * (mellin_part t) * (X_part t) ++ ++ have X_part_eq : ∀(t : ℝ), ‖X_part t‖ = X^pts_re := by ++ intro t ++ have U := Complex.norm_cpow_eq_rpow_re_of_pos (X_pos_triv) (pts t) ++ rw [pts_re_triv t] at U ++ exact U ++ ++ have X_part_bound : ∀(t : ℝ), ‖X_part t‖ ≤ X^pts_re := by ++ intro t ++ rw [←X_part_eq] ++ ++ have mellin_bound : ∀(t : ℝ), ‖mellin_part t‖ ≤ M * (eps * ‖pts t‖ ^ 2)⁻¹ := by ++ intro t ++ exact M_bounds_mellin_easy t ++ ++ have X_part_and_mellin_bound : ∀(t : ℝ),‖mellin_part t * X_part t‖ ≤ M * (eps * ‖pts t‖^2)⁻¹ * X^pts_re := by ++ intro t ++ exact norm_mul_le_of_le (mellin_bound t) (X_part_bound t) ++ ++ have T2 : ∀(t : ℝ), ‖zeta_part t‖ = ‖ζ' (pts t) / ζ (pts t)‖ := by ++ intro t ++ unfold zeta_part ++ simp only [Complex.norm_div, norm_neg] ++ ++ have zeta_bound : ∀(t : ℝ), ‖zeta_part t‖ ≤ K * Real.log X := by ++ intro t ++ unfold zeta_part ++ rw [T2] ++ exact K_bounds_zeta_at_any_t t ++ ++ have g_bound : ∀(t : ℝ), ‖zeta_part t * (mellin_part t * X_part t)‖ ≤ (K * Real.log X) * (M * (eps * ‖pts t‖^2)⁻¹ * X^pts_re) := by ++ intro t ++ exact norm_mul_le_of_le (zeta_bound t) (X_part_and_mellin_bound t) ++ ++ have T1 : f = g := by rfl ++ ++ have final_bound_pointwise : ‖f t‖ ≤ K * Real.log X * (M * (eps * ‖pts t‖^2)⁻¹ * X^pts_re) := by ++ rw [T1] ++ unfold g ++ rw [mul_assoc] ++ exact g_bound t ++ ++ have trivialize : K * Real.log X * (M * (eps * ‖pts t‖^2)⁻¹ * X^pts_re) = (K * M) * Real.log X * (eps * ‖pts t‖^2)⁻¹ * X^pts_re := by ++ ring_nf ++ ++ rw [trivialize] at final_bound_pointwise ++ exact final_bound_pointwise ++ ++ have σ₀_gt : 1 < pts_re := by exact pts_re_ge_1 ++ have σ₀_le_2 : pts_re ≤ 2 := by ++ unfold pts_re ++ ++ exact ++ Preorder.le_trans (1 + (Real.log X)⁻¹) (pts (SmoothingF (SmoothingF M))).re 2 ++ (triv_pts_lo_bound (SmoothingF (SmoothingF M))) (triv_pts_up_bound (SmoothingF (SmoothingF M))) ++ ++ have f_integrable := SmoothedChebyshevPull1_aux_integrable eps_pos eps_less_one X_large σ₀_gt σ₀_le_2 suppSmoothingF SmoothingFnonneg mass_one ContDiffSmoothingF ++ ++ have S : X^pts_re = rexp 1 * X := by ++ unfold pts_re ++ ++ calc ++ X ^ (1 + (Real.log X)⁻¹) = X * X ^ ((Real.log X)⁻¹) := by ++ refine rpow_one_add' ?_ ?_ ++ · positivity ++ · exact Ne.symm (ne_of_lt pts_re_pos) ++ _ = X * rexp 1 := by ++ refine (mul_right_inj' ?_).mpr ?_ ++ · exact Ne.symm (ne_of_lt X_pos_triv) ++ · refine rpow_inv_log X_pos_triv ?_ ++ · by_contra h ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, mul_inv_rev, gt_iff_lt, ++ Complex.norm_div, Nat.not_ofNat_lt_one] ++ _ = rexp 1 * X := by ring_nf ++ ++ have pts_re_neq_zero : pts_re ≠ 0 := by ++ by_contra h ++ rw [h] at pts_re_ge_1 ++ simp only [gt_iff_lt] at pts_re_ge_1 ++ norm_cast at pts_re_ge_1 ++ ++ have Z := ++ by ++ calc ++ ‖∫ (t : ℝ) in Iic (-T), f t‖ ≤ ∫ (t : ℝ) in Iic (-T), ‖f t‖ := MeasureTheory.norm_integral_le_integral_norm f ++ _ ≤ ∫ (t : ℝ) in Iic (-T), (K * M) * Real.log X * (eps * ‖pts t‖ ^ 2)⁻¹ * X ^ pts_re := by ++ refine integral_mono ?_ ?_ (fun t ↦ G t) ++ · refine Integrable.norm ?_ ++ · unfold f ++ exact MeasureTheory.Integrable.restrict f_integrable ++ · have equ : ∀(t : ℝ), (K * M) * Real.log X * (eps * ‖pts t‖ ^ 2)⁻¹ * X ^ pts_re = (K * M) * Real.log X * eps⁻¹ * X ^ pts_re * (‖pts t‖^2)⁻¹ := by ++ intro t; ring_nf ++ have fun_equ : (fun (t : ℝ) ↦ ((K * M) * Real.log X * (eps * ‖pts t‖ ^ 2)⁻¹ * X ^ pts_re)) = (fun (t : ℝ) ↦ ((K * M) * Real.log X * eps⁻¹ * X ^ pts_re * (‖pts t‖^2)⁻¹)) := by ++ funext t ++ exact equ t ++ ++ rw [fun_equ] ++ have nonzero := ((K * M) * Real.log X * eps⁻¹ * X ^ pts_re) ++ have simple_int : MeasureTheory.Integrable (fun (t : ℝ) ↦ (‖pts t‖^2)⁻¹) ++ := by ++ unfold pts ++ exact poisson_kernel_integrable pts_re (pts_re_neq_zero) ++ ++ have U := MeasureTheory.Integrable.const_mul simple_int ((K * M) * Real.log X * eps⁻¹ * X ^ pts_re) ++ refine MeasureTheory.Integrable.restrict ?_ ++ exact U ++ _ = (K * M) * Real.log X * X ^ pts_re * eps⁻¹ * ∫ (t : ℝ) in Iic (-T), (‖pts t‖ ^ 2)⁻¹ := by ++ have simpli : ∀(t : ℝ), (K * M) * Real.log X * (eps * ‖pts t‖ ^ 2)⁻¹ * X ^ pts_re = (K * M) * Real.log X * X ^ pts_re * eps⁻¹ * (‖pts t‖^2)⁻¹ := ++ by intro t; ring_nf ++ have simpli_fun : (fun (t : ℝ) ↦ (K * M) * Real.log X * (eps * ‖pts t‖ ^ 2)⁻¹ * X ^ pts_re ) = (fun (t : ℝ) ↦ ((K * M) * Real.log X * X ^ pts_re * eps⁻¹ * (‖pts t‖^2)⁻¹)) := ++ by funext t; ring_nf ++ rw [simpli_fun] ++ exact MeasureTheory.integral_const_mul ((K * M) * Real.log X * X ^ pts_re * eps⁻¹) (fun (t : ℝ) ↦ (‖pts t‖^2)⁻¹) ++ _ ≤ (K * M) * Real.log X * X ^ pts_re * eps⁻¹ * T⁻¹ := by ++ have U := integral_evaluation (pts_re) T (T_large) ++ unfold pts ++ simp only [ge_iff_le] ++ have U2 : 0 ≤ (K * M) * Real.log X * X ^ pts_re * eps⁻¹ := by ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, mul_inv_rev, gt_iff_lt, ++ Complex.norm_div, le_refl, implies_true, inv_pos, mul_nonneg_iff_of_pos_right] ++ refine Left.mul_nonneg ?_ ?_ ++ · refine Left.mul_nonneg ?_ ?_ ++ · exact Left.mul_nonneg (by positivity) (by positivity) ++ · refine log_nonneg ?_ ++ · linarith ++ · refine Left.mul_nonneg ?_ ?_ ++ · exact exp_nonneg 1 ++ · exact le_of_lt X_pos_triv ++ have U1 := mul_le_mul_of_nonneg_left U U2 ++ ++ exact U1 ++ _ = (Real.exp 1 * K * M) * Real.log X * X * eps⁻¹ * T⁻¹ := by ++ rw [S] ++ ring_nf ++ _ = (Real.exp 1 * K * M) * X * Real.log X / (eps * T) := by ring_nf ++ ++ unfold I₁ ++ unfold f at Z ++ unfold pts at Z ++ have Z3 : (↑pts_re : ℂ) = 1 + (Real.log X)⁻¹ := by unfold pts_re; norm_cast ++ rw [Z3] at Z ++ rw [Complex.norm_mul (1 / (2 * ↑π * I)) _] ++ simp only [one_div, mul_inv_rev, inv_I, neg_mul, norm_neg, Complex.norm_mul, norm_I, norm_inv, ++ norm_real, norm_eq_abs, Complex.norm_ofNat, one_mul, ofReal_inv, ge_iff_le] ++ have Z2 : 0 ≤ |π|⁻¹ * 2⁻¹ := by positivity ++ simp only [ofReal_inv] at Z ++ simp only [ge_iff_le] ++ have Z4 := ++ mul_le_mul_of_nonneg_left Z Z2 ++ ring_nf ++ ring_nf at Z4 ++ exact Z4 ++ ++lemma I9I1 {SmoothingF : ℝ → ℝ} {ε X T : ℝ} (Xpos : 0 < X) : ++ I₉ SmoothingF ε X T = conj (I₁ SmoothingF ε X T) := by ++ unfold I₉ I₁ ++ simp only [map_mul, map_div₀, conj_I, conj_ofReal, conj_ofNat, map_one] ++ rw [neg_mul, mul_neg, ← neg_mul] ++ congr ++ · ring ++ · rw [← integral_conj, ← integral_comp_neg_Ioi, integral_Ici_eq_integral_Ioi] ++ apply setIntegral_congr_fun <| measurableSet_Ioi ++ intro t ht ++ simp only ++ rw[← smoothedChebyshevIntegrand_conj Xpos] ++ simp ++ ++theorem I9Bound ++ {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ (SmoothingFnonneg : ∀ x > 0, 0 ≤ SmoothingF x) ++ (mass_one : ∫ x in Ioi 0, SmoothingF x / x = 1) : ++ ∃ C > 0, ∀{ε : ℝ} (_ : 0 < ε) ++ (_ : ε < 1) ++ (X : ℝ) (_ : 3 < X) ++ {T : ℝ} (_ : 3 < T), ++ ‖I₉ SmoothingF ε X T‖ ≤ C * X * Real.log X / (ε * T) := by ++ obtain ⟨C, Cpos, bound⟩ := I1Bound suppSmoothingF ContDiffSmoothingF SmoothingFnonneg mass_one ++ refine ⟨C, Cpos, ?_⟩ ++ intro ε εpos ε_lt_one X X_gt T T_gt ++ specialize bound ε εpos ε_lt_one X X_gt T_gt ++ rwa [I9I1 (by linarith), norm_conj] ++ ++lemma one_add_inv_log {X : ℝ} (X_ge : 3 ≤ X): (1 + (Real.log X)⁻¹) < 2 := by ++ rw[← one_add_one_eq_two] ++ refine (add_lt_add_iff_left 1).mpr ?_ ++ refine inv_lt_one_of_one_lt₀ ?_ ++ refine (lt_log_iff_exp_lt ?_).mpr ?_ <;> linarith[Real.exp_one_lt_d9] ++ ++theorem log_pos (T : ℝ) (T_gt : 3 < T) : (Real.log T > 1) := by ++ have elt3 : Real.exp 1 < 3 := by ++ linarith[Real.exp_one_lt_d9] ++ have logTgt1 : Real.log T > 1 := by ++ refine (lt_log_iff_exp_lt ?_).mpr ?_ ++ · linarith ++ · linarith ++ exact logTgt1 ++ ++lemma I2Bound {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ {A C₂ : ℝ} (has_bound: LogDerivZetaHasBound A C₂) (C₂pos : 0 < C₂) (A_in : A ∈ Ioc 0 (1 / 2)) : ++ ∃ (C : ℝ) (_ : 0 < C), ++ ∀(X : ℝ) (_ : 3 < X) {ε : ℝ} (_ : 0 < ε) ++ (_ : ε < 1) {T : ℝ} (_ : 3 < T), ++ let σ₁ := sigma1Of A T ++ ‖I₂ SmoothingF ε T X σ₁‖ ≤ C * X / (ε * T) := by ++ have ⟨C₁, C₁pos, Mbd⟩ := MellinOfSmooth1b ContDiffSmoothingF suppSmoothingF ++ have := (IBound_aux1 3 (by norm_num) 9) ++ obtain ⟨C₃, ⟨C₃_gt, hC₃⟩⟩ := this ++ ++ let C' : ℝ := C₁ * C₂ * C₃ * rexp 1 ++ have : C' > 0 := by positivity ++ use ‖1/(2*π*I)‖ * (2 * C'), by ++ refine Right.mul_pos ?_ ?_ ++ · rw[norm_pos_iff] ++ simp[pi_ne_zero] ++ · simp[this] ++ intro X X_gt ε ε_pos ε_lt_one T T_gt σ₁ ++ ++ have Xpos : 0 < X := lt_trans (by simp only [Nat.ofNat_pos]) X_gt ++ have Tpos : 0 < T := lt_trans (by norm_num) T_gt ++ have log_big : 1 < Real.log T := by exact log_pos T (T_gt) ++ unfold I₂ ++ rw[norm_mul, mul_assoc (c := X), ← mul_div] ++ refine mul_le_mul_of_nonneg_left ?_ (norm_nonneg _) ++ have interval_length_nonneg : σ₁ ≤ 1 + (Real.log X)⁻¹ := by ++ have : σ₁ = sigma1Of A T := rfl ++ rw [this] ++ unfold sigma1Of ++ rw[sub_le_iff_le_add] ++ nth_rw 1 [← add_zero 1] ++ rw[add_assoc] ++ apply add_le_add_right ++ refine Left.add_nonneg ?_ ?_ ++ · rw[inv_nonneg, log_nonneg_iff Xpos] ++ exact le_trans (by norm_num) (le_of_lt X_gt) ++ · refine div_nonneg ?_ ?_ ++ exact A_in.1.le ++ rw[log_nonneg_iff Tpos] ++ exact le_trans (by norm_num) (le_of_lt T_gt) ++ have : σ₁ = sigma1Of A T := rfl ++ have σ₁pos : 0 < σ₁ := by ++ have : σ₁ = sigma1Of A T := rfl ++ rw [this] ++ unfold sigma1Of ++ rw[sub_pos] ++ calc ++ A / Real.log T ≤ 1 / 2 / Real.log T := by ++ refine div_le_div_of_nonneg_right (A_in.2) ?_ ++ apply le_of_lt ++ linarith ++ ++ _ ≤ 1 / 2 / 1 := by ++ refine div_le_div_of_nonneg_left (by norm_num) (by norm_num) ?_ ++ apply le_of_lt ++ refine (lt_log_iff_exp_lt ?_).mpr ?_ <;> linarith[Real.exp_one_lt_d9] ++ _ < 1 := by norm_num ++ suffices ∀ σ ∈ Ioc σ₁ (1 + (Real.log X)⁻¹), ‖SmoothedChebyshevIntegrand SmoothingF ε X (↑σ - ↑T * I)‖ ≤ C' * X / (ε * T) by ++ calc ++ ‖∫ (σ : ℝ) in σ₁..1 + (Real.log X)⁻¹, ++ SmoothedChebyshevIntegrand SmoothingF ε X (↑σ - ↑T * I)‖ ≤ ++ C' * X / (ε * T) * |1 + (Real.log X)⁻¹ - σ₁| := by ++ refine intervalIntegral.norm_integral_le_of_norm_le_const ?_ ++ convert this using 3 ++ apply uIoc_of_le ++ exact interval_length_nonneg ++ _ ≤ C' * X / (ε * T) * 2 := by ++ apply mul_le_mul_of_nonneg_left ++ rw[abs_of_nonneg (sub_nonneg.mpr interval_length_nonneg)] ++ calc ++ 1 + (Real.log X)⁻¹ - σ₁ ≤ 1 + (Real.log X)⁻¹ := by linarith ++ _ ≤ 2 := (one_add_inv_log X_gt.le).le ++ positivity ++ _ = 2 * C' * X / (ε * T) := by ring ++ ++ intro σ hσ ++ unfold SmoothedChebyshevIntegrand ++ have log_deriv_zeta_bound : ‖ζ' (σ - T * I) / ζ (σ - T * I)‖ ≤ C₂ * (C₃ * T) := by ++ calc ++ ‖ζ' (σ - (T : ℝ) * I) / ζ (σ - (T : ℝ) * I)‖ = ‖ζ' (σ + (-T : ℝ) * I) / ζ (σ + (-T : ℝ) * I)‖ := by ++ have Z : σ - (T : ℝ) * I = σ + (- T : ℝ) * I := by simp; ring_nf ++ simp [Z] ++ _ ≤ C₂ * Real.log |-T| ^ 9 := has_bound σ (-T) (by simp; rw [abs_of_pos Tpos]; exact T_gt) (by rw[this] at hσ; unfold sigma1Of at hσ; simp at hσ ⊢; replace hσ := hσ.1; linarith) ++ _ ≤ C₂ * Real.log T ^ 9 := by simp ++ _ ≤ C₂ * (C₃ * T) := by gcongr; exact hC₃ T (by linarith) ++ ++ calc ++ ‖-ζ' (σ - T * I) / ζ (σ - T * I) * 𝓜 (fun x ↦ (Smooth1 SmoothingF ε x)) ++ (σ - T * I) * X ^ (σ - T * I)‖ = ++ ‖-ζ' (σ - T * I) / ζ (σ - T * I)‖ * ‖𝓜 (fun x ↦ (Smooth1 SmoothingF ε x)) ++ (σ - T * I)‖ * ‖(X : ℂ) ^ (σ - T * I)‖ := by ++ repeat rw[norm_mul] ++ _ ≤ C₂ * (C₃ * T) * (C₁ * (ε * ‖σ - T * I‖ ^ 2)⁻¹) * (rexp 1 * X) := by ++ apply mul_le_mul₃ ++ · rw[neg_div, norm_neg] ++ exact log_deriv_zeta_bound ++ · refine Mbd σ₁ σ₁pos _ ?_ ?_ ε ε_pos ε_lt_one ++ · simp only [mem_Ioc, sub_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, sub_zero] at hσ ⊢ ++ linarith ++ · simp only [mem_Ioc, sub_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, ++ sub_self, sub_zero] at hσ ⊢ ++ linarith[one_add_inv_log X_gt.le] ++ · rw[cpow_def_of_ne_zero] ++ · rw[norm_exp,← ofReal_log, re_ofReal_mul] ++ simp only [sub_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, ++ sub_zero] ++ rw[← le_log_iff_exp_le, Real.log_mul (exp_ne_zero 1), Real.log_exp, ← le_div_iff₀', add_comm, add_div, div_self, one_div] ++ exact hσ.2 ++ · refine (Real.log_pos ?_).ne.symm ++ linarith ++ · apply Real.log_pos ++ linarith ++ · linarith ++ · positivity ++ · positivity ++ · exact_mod_cast Xpos.ne.symm ++ · positivity ++ · positivity ++ · positivity ++ _ = (C' * X * T) / (ε * ‖σ - T * I‖ ^ 2) := by ring ++ _ ≤ C' * X / (ε * T) := by ++ have : ‖σ - T * I‖ ^ 2 ≥ T ^ 2 := by ++ calc ++ ‖σ - T * I‖ ^ 2 = ‖σ + (-T : ℝ) * I‖ ^ 2 := by ++ congr 2 ++ push_cast ++ ring ++ _ = normSq (σ + (-T : ℝ) * I) := (normSq_eq_norm_sq _).symm ++ _ = σ^2 + (-T)^2 := by ++ rw[Complex.normSq_add_mul_I] ++ _ ≥ T^2 := by ++ rw[neg_sq] ++ exact le_add_of_nonneg_left (sq_nonneg _) ++ calc ++ C' * X * T / (ε * ‖↑σ - ↑T * I‖ ^ 2) ≤ C' * X * T / (ε * T ^ 2) := by ++ rw[div_le_div_iff_of_pos_left, mul_le_mul_iff_right₀] ++ exact this ++ exact ε_pos ++ positivity ++ apply mul_pos ε_pos ++ exact lt_of_lt_of_le (pow_pos Tpos 2) this ++ positivity ++ _ = C' * X / (ε * T) := by ++ field_simp ++ ++lemma I8I2 {SmoothingF : ℝ → ℝ} ++ {X ε T σ₁ : ℝ} (T_gt : 3 < T) : ++ I₈ SmoothingF ε X T σ₁ = -conj (I₂ SmoothingF ε X T σ₁) := by ++ unfold I₂ I₈ ++ rw[map_mul, ← neg_mul] ++ congr ++ · simp[conj_ofNat] ++ · rw[← intervalIntegral_conj] ++ apply intervalIntegral.integral_congr ++ intro σ hσ ++ simp only [] ++ rw[← smoothedChebyshevIntegrand_conj] ++ simp only [map_sub, conj_ofReal, map_mul, conj_I, mul_neg, sub_neg_eq_add] ++ exact lt_trans (by norm_num) T_gt ++ ++lemma I8Bound {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ {A C₂ : ℝ} (has_bound : LogDerivZetaHasBound A C₂) (C₂_pos : 0 < C₂) (A_in : A ∈ Ioc 0 (1 / 2)) : ++ ++ ∃ (C : ℝ) (_ : 0 < C), ++ ∀(X : ℝ) (_ : 3 < X) {ε : ℝ} (_: 0 < ε) ++ (_ : ε < 1) ++ {T : ℝ} (_ : 3 < T), ++ let σ₁ : ℝ := 1 - A / (Real.log T) ++ ‖I₈ SmoothingF ε T X σ₁‖ ≤ C * X / (ε * T) := by ++ ++ obtain ⟨C, hC, i2Bound⟩ := I2Bound suppSmoothingF ContDiffSmoothingF has_bound C₂_pos A_in ++ use C, hC ++ intro X hX ε hε0 hε1 T hT σ₁ ++ let i2Bound := i2Bound X hX hε0 hε1 hT ++ rw[I8I2 hX, norm_neg, norm_conj] ++ ++ change ‖I₂ SmoothingF ε T X (sigma1Of A T)‖ ≤ C * X / (ε * T) at i2Bound ++ unfold sigma1Of at i2Bound ++ have σ₁_eq : σ₁ = 1 - A / (Real.log T) := rfl ++ rw[σ₁_eq] ++ exact i2Bound ++ ++lemma log_pow_over_xsq_integral_bounded : ++ ∀ n : ℕ, ∃ C : ℝ, 0 < C ∧ ∀ T >3, ∫ x in Ioo 3 T, (Real.log x)^n / x^2 < C := by ++ have elt3 : Real.exp 1 < 3 := by ++ linarith[Real.exp_one_lt_d9] ++ have log3gt1: 1 < Real.log 3 := by ++ apply (Real.lt_log_iff_exp_lt (by norm_num)).mpr ++ exact elt3 ++ intro n ++ induction n with ++ | zero => ++ use 1 ++ constructor ++ · norm_num ++ · intro T hT ++ have Tgt3 : (3 : ℝ) < T := hT ++ simp only [pow_zero] ++ have h1 :(0 ≤ (-2) ∨ (-2) ≠ (-1) ∧ 0 ∉ Set.uIcc 3 T) := by ++ right ++ constructor ++ · linarith ++ · refine notMem_uIcc_of_lt ?_ ?_ ++ · exact three_pos ++ · linarith ++ have integral := integral_zpow h1 ++ ring_nf at integral ++ ++ have swap_int_kind : ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), 1 / x ^ 2 = ∫ (x : ℝ) in Ioo 3 T, 1 / x ^ 2 := by ++ rw [intervalIntegral.integral_of_le (by linarith)] ++ exact MeasureTheory.integral_Ioc_eq_integral_Ioo ++ rw [← swap_int_kind] ++ have change_int_power : ∫ (x : ℝ) in (3 : ℝ)..T, (1 : ℝ) / x ^ (↑ 2) ++ = ∫ (x : ℝ) in (3 : ℝ).. T, x ^ (-2 : ℤ) := by ++ apply intervalIntegral.integral_congr ++ intro x hx ++ simp ++ rw [change_int_power, integral] ++ have : T ^ (-1 : ℤ) > 0 := by ++ refine zpow_pos ?_ (-1) ++ linarith ++ linarith ++ | succ d ih => ++ obtain ⟨Cd, Cdpos, IH⟩ := ih ++ use ((Real.log 3)^(d+1) / 3) + (d+1) * Cd ++ constructor ++ · have logpowpos : (Real.log 3) ^ (d + 1) > 0 := by ++ refine pow_pos ?_ (d + 1) ++ linarith ++ have : 0 < (Real.log 3) ^ (d + 1) / 3 := by ++ exact div_pos logpowpos (by norm_num) ++ have dbound : d + 1 ≥ 1 := by ++ exact Nat.le_add_left 1 d ++ have : Real.log 3 ^ (d + 1) / 3 + (↑d + 1) * Cd > 0 / 3 + 0 := by ++ have term1_pos : 0 < Real.log 3 ^ (d + 1) / 3 := this ++ have term2_pos : 0 < (↑d + 1) * Cd := by ++ refine (mul_pos_iff_of_pos_right Cdpos).mpr ?_ ++ exact Nat.cast_add_one_pos d ++ refine add_lt_add ?_ term2_pos ++ refine div_lt_div₀ logpowpos ?_ ?_ ?_ ++ linarith ++ linarith ++ linarith ++ ring_nf at this ++ ring_nf ++ exact this ++ · intro T Tgt3 ++ let u := fun x : ℝ ↦ (Real.log x) ^ (d + 1) ++ let v := fun x : ℝ ↦ -1 / x ++ let u' := fun x : ℝ ↦ (d + 1 : ℝ) * (Real.log x)^d / x ++ let v' := fun x : ℝ ↦ 1 / x^2 ++ ++ have swap_int_type : ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), Real.log x ^ (d + 1) / x ^ 2 ++ = ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ (d + 1) / x ^ 2 := by ++ rw [intervalIntegral.integral_of_le (by linarith)] ++ exact MeasureTheory.integral_Ioc_eq_integral_Ioo ++ ++ rw [← swap_int_type] ++ ++ have uIcc_is_Icc : Set.uIcc 3 T = Set.Icc 3 T := by ++ exact uIcc_of_lt Tgt3 ++ ++ have cont_u : ContinuousOn u (Set.uIcc 3 T) := by ++ unfold u ++ rw[uIcc_is_Icc] ++ refine ContinuousOn.pow ?_ (d + 1) ++ refine continuousOn_of_forall_continuousAt ?_ ++ intro x hx ++ refine continuousAt_log ?_ ++ linarith [hx.1] ++ ++ have cont_v : ContinuousOn v (Set.uIcc 3 T) := by ++ unfold v ++ rw[uIcc_is_Icc] ++ refine continuousOn_of_forall_continuousAt ?_ ++ intro x hx ++ have cont1 : ContinuousAt (fun (x : ℝ) ↦ 1 / x) x := by ++ refine ContinuousAt.div₀ ?_ (fun ⦃U⦄ a ↦ a) ?_ ++ · exact continuousAt_const ++ · linarith [hx.1] ++ have cont2 : ContinuousAt (fun (x : ℝ) ↦ 1 / x) (-x) := by ++ refine ContinuousAt.div₀ ?_ (fun ⦃U⦄ a ↦ a) ?_ ++ · exact continuousAt_const ++ · linarith [hx.1] ++ have fun1 : (fun (x : ℝ) ↦ -1 / x) = (fun (x : ℝ) ↦ 1 / (-x)) := by ++ ext x ++ ring_nf ++ rw [fun1] ++ exact ContinuousAt.comp cont2 (HasDerivAt.neg (hasDerivAt_id x)).continuousAt ++ ++ have deriv_u : (∀ x ∈ Set.Ioo (3 ⊓ T) (3 ⊔ T), HasDerivAt u (u' x) x) := by ++ intro x hx ++ have min3t : min 3 T = 3 := by ++ exact min_eq_left_of_lt Tgt3 ++ have max3t : max 3 T = T := by ++ exact max_eq_right_of_lt Tgt3 ++ rw[min3t, max3t] at hx ++ unfold u u' ++ have xne0 : x ≠ 0 := by linarith [hx.1] ++ have deriv1 := Real.deriv_log x ++ have deriv2 := (Real.hasDerivAt_log xne0).pow (d + 1) ++ have fun1 : (fun x ↦ (↑d + 1) * Real.log x ^ d / x) = (fun x ↦ (↑d + 1) * Real.log x ^ d * x⁻¹) := by ++ exact rfl ++ have fun2 : (↑d + 1) * Real.log x ^ d / x = (↑d + 1) * Real.log x ^ d * x⁻¹:= by ++ exact rfl ++ rw [fun2] ++ simpa [Nat.cast_add, Nat.cast_one] using! deriv2 ++ ++ have deriv_v : (∀ x ∈ Set.Ioo (3 ⊓ T) (3 ⊔ T), HasDerivAt v (v' x) x) := by ++ intro x hx ++ have min3t : min 3 T = 3 := by ++ exact min_eq_left_of_lt Tgt3 ++ have max3t : max 3 T = T := by ++ exact max_eq_right_of_lt Tgt3 ++ rw[min3t, max3t] at hx ++ have xne0 : x ≠ 0 := by linarith [hx.1] ++ unfold v v' ++ have deriv1 := hasDerivAt_inv xne0 ++ have fun1 : (fun (x : ℝ) ↦ x⁻¹) = (fun (x : ℝ) ↦ 1 / x) := by ++ ext x ++ exact inv_eq_one_div x ++ rw [fun1] at deriv1 ++ have fun2 : -(x ^ 2)⁻¹ = - 1 / x ^ 2 := by ++ field_simp ++ rw [fun2] at deriv1 ++ simpa [neg_div, neg_neg] using! HasDerivAt.neg deriv1 ++ ++ have cont_u' : ContinuousOn u' (Set.uIcc 3 T) := by ++ rw[uIcc_is_Icc] ++ unfold u' ++ refine ContinuousOn.div₀ ?_ ?_ ?_ ++ · refine ContinuousOn.mul ?_ ?_ ++ · exact continuousOn_const ++ · refine ContinuousOn.pow ?_ d ++ refine continuousOn_of_forall_continuousAt ?_ ++ intro x hx ++ refine continuousAt_log ?_ ++ linarith [hx.1] ++ · exact continuousOn_id' (Icc 3 T) ++ · intro x hx ++ linarith [hx.1] ++ ++ have cont_v' : ContinuousOn v' (Set.uIcc 3 T) := by ++ rw[uIcc_is_Icc] ++ unfold v' ++ refine ContinuousOn.div₀ ?_ ?_ ?_ ++ · exact continuousOn_const ++ · exact continuousOn_pow 2 ++ · intro x hx ++ refine pow_ne_zero 2 ?_ ++ linarith [hx.1] ++ ++ have int_u': IntervalIntegrable u' MeasureTheory.volume 3 T := by ++ exact ContinuousOn.intervalIntegrable cont_u' ++ ++ have int_v': IntervalIntegrable v' MeasureTheory.volume 3 T := by ++ exact ContinuousOn.intervalIntegrable cont_v' ++ ++ have IBP := intervalIntegral.integral_mul_deriv_eq_deriv_mul_of_hasDerivAt cont_u cont_v deriv_u deriv_v int_u' int_v' ++ ++ unfold u u' v v' at IBP ++ ++ have int1 : ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), Real.log x ^ (d + 1) * (1 / x ^ 2) ++ = ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), Real.log x ^ (d + 1) / x ^ 2 := by ++ refine intervalIntegral.integral_congr ?_ ++ intro x hx ++ field_simp ++ ++ rw[int1] at IBP ++ rw[IBP] ++ ++ have int2 : ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), (↑d + 1) * Real.log x ^ d / x * (-1 / x) ++ = -(↑d + 1) * ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), Real.log x ^ d / x ^ 2 := by ++ have : ∀ x, (↑d + 1) * Real.log x ^ d / x * (-1 / x) ++ = -((↑d + 1) * Real.log x ^ d / x ^ 2) := by ++ intro x ++ field_simp ++ have : ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), (↑d + 1) * Real.log x ^ d / x * (-1 / x) ++ = ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), -((↑d + 1) * Real.log x ^ d / x ^ 2) := by ++ exact intervalIntegral.integral_congr fun ⦃x⦄ a ↦ this x ++ rw [this] ++ rw [←intervalIntegral.integral_const_mul] ++ ring_nf ++ ++ rw[int2] ++ ++ have int3 : ∫ (x : ℝ) in (3 : ℝ)..(T : ℝ), Real.log x ^ d / x ^ 2 ++ = ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d / x ^ 2 := by ++ rw [intervalIntegral.integral_of_le (by linarith)] ++ exact MeasureTheory.integral_Ioc_eq_integral_Ioo ++ ++ rw[int3] ++ ++ have IHbound : ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d / x ^ 2 < Cd := by ++ exact IH T Tgt3 ++ ++ ring_nf ++ have bound2 : (Real.log T * Real.log T ^ d * T⁻¹) ≥ 0 := by ++ have logTpos : Real.log T ≥ 0 := by ++ refine log_nonneg ?_ ++ linarith ++ apply mul_nonneg ++ · apply mul_nonneg ++ · exact logTpos ++ · exact pow_nonneg logTpos d ++ · positivity ++ ++ have bound3 : -(Real.log T * Real.log T ^ d * T⁻¹) ≤ 0 := by ++ exact Right.neg_nonpos_iff.mpr bound2 ++ let S := Real.log T * Real.log T ^ d * T⁻¹ ++ have Spos : S ≥ 0 := by ++ unfold S ++ exact bound2 ++ ++ have : (-(Real.log T * Real.log T ^ d * T⁻¹) + Real.log 3 * Real.log 3 ^ d * (1 / 3) + ++ ↑d * ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2) + ++ ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2 = (-S + Real.log 3 * Real.log 3 ^ d * (1 / 3) + ++ ↑d * ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2) + ++ ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2 := by ++ unfold S ++ rfl ++ rw [this] ++ ++ have GetRidOfS : (-S + Real.log 3 * Real.log 3 ^ d * (1 / 3) ++ + ↑d * ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2) ++ + ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2 ++ ≤ ( Real.log 3 * Real.log 3 ^ d * (1 / 3) ++ + ↑d * ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2) ++ + ∫ (x : ℝ) in Ioo 3 T, Real.log x ^ d * x⁻¹ ^ 2 := by ++ linarith [Spos] ++ apply lt_of_le_of_lt GetRidOfS ++ rw [add_assoc] ++ ++ have bound4 : ∫ x in Ioo 3 T, Real.log x ^ d / x ^ 2 < Cd := IHbound ++ ++ have bound5 : ↑d * ∫ x in Ioo 3 T, Real.log x ^ d / x ^ 2 ≤ ↑d * Cd := by ++ apply (mul_le_mul_of_nonneg_left bound4.le) ++ exact Nat.cast_nonneg d ++ ++ have bound_sum : ↑d * (∫ x in Ioo 3 T, Real.log x ^ d / x ^ 2) ++ + ∫ x in Ioo 3 T, Real.log x ^ d / x ^ 2 < ↑d * Cd + Cd := by ++ linarith [bound4, bound5] ++ rw[add_assoc] ++ apply add_lt_add_right ++ field_simp ++ linarith [bound_sum] ++ ++theorem I3Bound {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ {A Cζ : ℝ} (hCζ : LogDerivZetaHasBound A Cζ) (Cζpos : 0 < Cζ) (hA : A ∈ Ioc 0 (1 / 2)) : ++ ∃ (C : ℝ) (_ : 0 < C), ++ ∀ (X : ℝ) (_ : 3 < X) ++ {ε : ℝ} (_ : 0 < ε) (_ : ε < 1) ++ {T : ℝ} (_ : 3 < T), ++ ++ let σ₁ : ℝ := 1 - A / (Real.log T) ++ ‖I₃ SmoothingF ε T X σ₁‖ ≤ C * X * X ^ (- A / (Real.log T)) / ε := by ++ ++ obtain ⟨CM, CMpos, CMhyp⟩ := MellinOfSmooth1b ContDiffSmoothingF suppSmoothingF ++ obtain ⟨Cint, Cintpos, Cinthyp⟩ := log_pow_over_xsq_integral_bounded 9 ++ use Cint * CM * Cζ ++ have : Cint * CM > 0 := mul_pos Cintpos CMpos ++ have : Cint * CM * Cζ > 0 := mul_pos this Cζpos ++ use this ++ intro X Xgt3 ε εgt0 εlt1 T Tgt3 σ₁ ++ unfold I₃ ++ unfold SmoothedChebyshevIntegrand ++ ++ have elt3 : Real.exp 1 < 3 := by ++ linarith[Real.exp_one_lt_d9] ++ ++ have log3gt1: 1 < Real.log 3 := by ++ apply (Real.lt_log_iff_exp_lt (by norm_num)).mpr ++ exact elt3 ++ ++ have logXgt1 : Real.log X > 1 := by ++ refine (lt_log_iff_exp_lt ?_).mpr ?_ ++ linarith ++ linarith ++ ++ have logTgt1 : Real.log T > 1 := by ++ refine (lt_log_iff_exp_lt ?_).mpr ?_ ++ linarith ++ linarith ++ ++ have logX9gt1 : Real.log X ^ 1 > 1 := by ++ refine (one_lt_pow_iff_of_nonneg ?_ ?_).mpr logXgt1 ++ linarith ++ linarith ++ ++ have logT9gt1 : Real.log T ^ 1 > 1 := by ++ refine (one_lt_pow_iff_of_nonneg ?_ ?_).mpr logTgt1 ++ linarith ++ linarith ++ ++ have t_bounds : ∀ t ∈ Ioo (-T) (-3), 3 < |t| ∧ |t| < T := by ++ intro t ht ++ obtain ⟨h1,h2⟩ := ht ++ have : |t| = -t := by ++ refine abs_of_neg ?_ ++ linarith[h2] ++ have abs_tgt3 : 3 < |t| := by ++ rw[this] ++ linarith[h2] ++ have abs_tltX : |t| < T := by ++ rw[this] ++ linarith[h1] ++ exact ⟨abs_tgt3, abs_tltX⟩ ++ ++ have logtgt1_bounds : ∀ t, 3 < |t| ∧ |t| < T → Real.log |t| > 1 := by ++ intro t ht ++ obtain ⟨h1,h2⟩ := ht ++ refine logt_gt_one ?_ ++ exact h1.le ++ ++ have logt9gt1_bounds : ∀ t, 3 < |t| ∧ |t| < T → Real.log |t| ^ 9 > 1 := by ++ intro t ht ++ refine one_lt_pow₀ (logtgt1_bounds t ht) ?_ ++ linarith ++ ++ have logtltlogT_bounds : ∀ t, 3 < |t| ∧ |t| < T → Real.log |t| < Real.log T := by ++ intro t ht ++ obtain ⟨h1,h2⟩ := ht ++ have m := log_lt_log (by linarith : 0 < (|t|)) (h2 : |t| < T ) ++ exact m ++ ++ have logt9ltlogT9_bounds : ∀ t, 3 < |t| ∧ |t| < T → Real.log |t| ^ 9 < Real.log T ^ 9 := by ++ intro t ht ++ obtain h1 := logtltlogT_bounds t ht ++ obtain h2 := logtgt1_bounds t ht ++ have h3: 0 ≤ Real.log |t| := by linarith ++ refine (pow_lt_pow_iff_left₀ ?_ ?_ ?_).mpr h1 ++ linarith ++ linarith ++ linarith ++ ++ have Aoverlogt9gtAoverlogT9_bounds : ∀ t, 3 < |t| ∧ |t| < T → ++ A / Real.log |t| ^ 9 > A / Real.log T ^ 9 := by ++ intro t ht ++ have h1 := logt9ltlogT9_bounds t ht ++ have h2 :=logt9gt1_bounds t ht ++ refine div_lt_div_of_pos_left ?_ ?_ h1 ++ linarith [hA.1] ++ linarith ++ ++ have AoverlogT9in0half: A / Real.log T ^ 1 ∈ Ioo 0 (1/2) := by ++ constructor ++ · refine div_pos ?_ ?_ ++ refine EReal.coe_pos.mp ?_ ++ exact EReal.coe_lt_coe hA.1 ++ linarith ++ · refine (div_lt_comm₀ ?_ ?_).mpr ?_ ++ linarith ++ linarith ++ refine (div_lt_iff₀' ?_).mpr ?_ ++ linarith ++ have hA_lt : A ≤ 1 / 2 := hA.2 ++ have hbound : 1 / 2 < (1 / 2) * Real.log T ^ 1 := by ++ linarith ++ linarith ++ ++ have σ₁lt2 : (σ₁ : ℝ) < 2 := by ++ unfold σ₁ ++ calc 1 - A / Real.log T ++ < 1 - 0 := by simp only [sub_zero]; exact sub_lt_self 1 (div_pos hA.1 (lt_trans zero_lt_one logTgt1)) ++ _ = 1 := by norm_num ++ _ < 2 := by norm_num ++ ++ have σ₁lt1 : σ₁ < 1 := by ++ unfold σ₁ ++ calc 1 - A / Real.log T ++ < 1 - 0 := by simp only [sub_zero]; exact sub_lt_self 1 (div_pos hA.1 (by linarith [logTgt1])) ++ _ = 1 := by norm_num ++ ++ have σ₁pos : 0 < σ₁ := by ++ unfold σ₁ ++ rw [sub_pos] ++ calc ++ A / Real.log T ≤ (1/2) / Real.log T := by ++ apply div_le_div_of_nonneg_right hA.2 (by linarith) ++ _ ≤ (1/2) / 1 := by ++ apply div_le_div_of_nonneg_left (by norm_num) (by norm_num) (by linarith) ++ _ = 1/2 := by norm_num ++ _ < 1 := by norm_num ++ ++ have quotient_bound : ∀ t, 3 < |t| ∧ |t| < T → Real.log |t| ^ 9 / (σ₁ ^ 2 + t ^ 2) ≤ Real.log |t| ^ 9/ t ^ 2 := by ++ intro t ht ++ have loght := logt9gt1_bounds t ht ++ have logpos : Real.log |t| ^ 9 > 0 := by linarith ++ have denom_le : t ^ 2 ≤ σ₁ ^ 2 + t ^ 2 := by linarith [sq_nonneg σ₁] ++ have denom_pos : 0 < t ^ 2 := by ++ have : t ^ 2 = |t| ^ 2 := by ++ exact Eq.symm (sq_abs t) ++ rw [this] ++ have h1 := ht.1 ++ have abspos : |t| > 0 := by linarith ++ exact sq_pos_of_pos abspos ++ have denom2_pos : 0 < σ₁ ^ 2 + t ^ 2 := by linarith [sq_nonneg σ₁] ++ exact (div_le_div_iff_of_pos_left logpos denom2_pos denom_pos).mpr denom_le ++ ++ have boundthing : ∀ t, 3 < |t| ∧ |t| < T → σ₁ ∈ Ici (1 - A / Real.log |t|) := by ++ intro t ht ++ have h1 := Aoverlogt9gtAoverlogT9_bounds t ht ++ unfold σ₁ ++ apply mem_Ici.mpr ++ ring_nf ++ ++ apply sub_le_sub_left ++ have : Real.log |t| ≤ Real.log T := by ++ apply Real.log_le_log (by linarith) (le_of_lt ht.2) ++ exact div_le_div_of_nonneg_left (le_of_lt hA.1) (Real.log_pos (by linarith)) this ++ ++ have : ∫ (t : ℝ) in -T..-3, ++ -ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I) * 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑X ^ (↑σ₁ + ↑t * I) = ∫ (t : ℝ) in Ioo (-T : ℝ) (-3 : ℝ), ++ -ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I) * 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑X ^ (↑σ₁ + ↑t * I) := by ++ rw [intervalIntegral.integral_of_le (by linarith)] ++ exact MeasureTheory.integral_Ioc_eq_integral_Ioo ++ rw[this] ++ ++ have MellinBound : ∀ (t : ℝ) , ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ₁ + t * I)‖ ≤ CM * (ε * ‖(σ₁ + t * I)‖ ^ 2)⁻¹ := by ++ intro t ++ apply CMhyp σ₁ ++ exact σ₁pos ++ · simp only [add_re, mul_re, ofReal_re, ofReal_im, I_re, I_im, mul_zero, zero_mul, sub_zero, add_zero] ++ exact le_rfl ++ · simpa only [add_re, mul_re, ofReal_re, ofReal_im, I_re, I_im, mul_zero, zero_mul, sub_zero, add_zero] using σ₁lt2.le ++ exact εgt0 ++ exact εlt1 ++ ++ have logzetabnd : ∀ t : ℝ, 3 < |t| ∧ |t| < T → ‖ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I)‖ ≤ Cζ * Real.log (|t| : ℝ) ^ 9 := by ++ intro t tbounds ++ obtain ⟨tgt3, tltT⟩ := tbounds ++ apply hCζ ++ · exact tgt3 ++ · apply boundthing ++ constructor ++ · exact tgt3 ++ · exact tltT ++ ++ have Mellin_bd : ∀ t, 3 < |t| ∧ |t| < T → ++ ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (σ₁ + t * I)‖ ≤ CM * (ε * ‖σ₁ + t * I‖ ^ 2)⁻¹ := by ++ intro t ht ++ apply MellinBound ++ ++ have logzeta_bd : ∀ t, 3 < |t| ∧ |t| < T → ++ ‖ζ' (σ₁ + t * I) / ζ (σ₁ + t * I)‖ ≤ Cζ * Real.log |t| ^ 9 := by ++ intro t t_bounds ++ obtain ⟨abs_tgt3,abs_tltX⟩ := t_bounds ++ apply logzetabnd ++ constructor ++ · exact abs_tgt3 ++ · exact abs_tltX ++ have : ‖1 / (2 * ↑π * I) * ++ (I * ∫ (t : ℝ) in -X..-3, ++ -ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I) * ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑T ^ (↑σ₁ + ↑t * I))‖ ++ = ++ (1 / (2 * π)) * ‖∫ (t : ℝ) in -X..-3, ++ -ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I) * ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑T ^ (↑σ₁ + ↑t * I)‖ := by ++ simp only [norm_mul] ++ rw[Complex.norm_I] ++ simp only [one_mul] ++ have : ‖1 / (2 * ↑π * I)‖ = 1 / (2 * π) := by ++ ++ ring_nf ++ simp only [norm_mul] ++ rw[inv_I] ++ have : ‖-I‖ = ‖-1 * I‖ := by ++ simp ++ rw[this] ++ have : ‖-1 * I‖ = ‖-1‖ * ‖I‖ := by ++ simp ++ rw[this, Complex.norm_I] ++ ring_nf ++ simp ++ rw[this] ++ ++ let f t := (-ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I)) * ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑X ^ (↑σ₁ + ↑t * I) ++ ++ let g t := Cζ * CM * Real.log |t| ^ 9 / (ε * ‖↑σ₁ + ↑t * I‖ ^ 2) * X ^ σ₁ ++ ++ have norm_X_sigma1: ∀ (t : ℝ), ‖↑(X : ℂ) ^ (↑σ₁ + ↑t * I)‖ = X ^ σ₁ := by ++ intro t ++ have Xpos : 0 < X := by linarith ++ have : ((↑σ₁ + ↑t * I).re) = σ₁ := by ++ simp ++ ++ nth_rw 2[← this] ++ apply Complex.norm_cpow_eq_rpow_re_of_pos Xpos ++ ++ have bound_integral : ∀ (t : ℝ), 3 < |t| ∧ |t| < T → ‖f t‖ ≤ g t := by ++ intro t ++ rintro ⟨ht_gt3, ht_ltT⟩ ++ have Xσ_bound : ‖↑(X : ℂ) ^ (↑σ₁ + ↑t * I)‖ = X ^ σ₁ := norm_X_sigma1 t ++ have logtgt1 : 1 < Real.log |t| := by ++ exact logt_gt_one ht_gt3.le ++ have hζ := logzetabnd t ⟨ht_gt3, ht_ltT⟩ ++ have h𝓜 := MellinBound t ++ have : ‖f ↑t‖ = ‖(-ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I)) * ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑X ^ (↑σ₁ + ↑t * I)‖ := by ++ rfl ++ rw[this] ++ have : ‖(-ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I)) * ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑X ^ (↑σ₁ + ↑t * I)‖ ≤ ‖ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I)‖ * ++ ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I)‖ * ++ ‖(↑(X : ℝ) : ℂ) ^ (↑σ₁ + ↑t * I)‖ := by ++ simp [norm_neg] ++ ++ have : ‖ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I)‖ * ++ ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I)‖ * ++ ‖(↑X : ℂ) ^ (↑σ₁ + ↑t * I)‖ ≤ (Cζ * Real.log |t| ^ 9) * ++ (CM * (ε * ‖↑σ₁ + ↑t * I‖ ^ 2)⁻¹) * X ^ σ₁:= by ++ rw[Xσ_bound] ++ gcongr ++ have : (Cζ * Real.log |t| ^ 9) * (CM * (ε * ‖↑σ₁ + ↑t * I‖ ^ 2)⁻¹) * X ^ σ₁ = g t := by ++ unfold g ++ ring_nf ++ linarith ++ ++ have int_with_f: ‖1 / (2 * ↑π * I) * ++ (I * ++ ∫ (t : ℝ) in Ioo (-T) (-3), ++ -ζ' (↑σ₁ + ↑t * I) / ζ (↑σ₁ + ↑t * I) * 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₁ + ↑t * I) * ++ ↑X ^ (↑σ₁ + ↑t * I))‖ = ‖1 / (2 * ↑π * I) * ++ (I * ++ ∫ (t : ℝ) in Ioo (-T) (-3), ++ f t)‖ := by ++ unfold f ++ simp ++ rw[int_with_f] ++ apply (norm_mul_le _ _).trans ++ have int_mulbyI_is_int : ‖I * ∫ (t : ℝ) in Ioo (-T) (-3), f ↑t‖ = ‖ ∫ (t : ℝ) in Ioo (-T) (-3), f ↑t‖ := by ++ rw [Complex.norm_mul, Complex.norm_I] ++ ring ++ rw[int_mulbyI_is_int] ++ ++ have norm_1over2pii_le1: ‖1 / (2 * ↑π * I)‖ ≤ 1 := by ++ simp ++ have pi_gt_3 : Real.pi > 3 := by ++ exact pi_gt_three ++ have pi_pos : 0 < π := by linarith [pi_gt_3] ++ have abs_pi_inv_le : |π|⁻¹ ≤ (1 : ℝ) := by ++ rw [abs_of_pos pi_pos] ++ have h : 1 = π * π⁻¹ := by ++ field_simp ++ rw[h] ++ nth_rw 1 [← one_mul π⁻¹] ++ apply mul_le_mul_of_nonneg_right ++ · linarith ++ · exact inv_nonneg.mpr (le_of_lt pi_pos) ++ have : (0 : ℝ) < (2 : ℝ) := by norm_num ++ have h_half_le_one : (2 : ℝ)⁻¹ ≤ 1 := by norm_num ++ rw [abs_of_pos pi_pos] at abs_pi_inv_le ++ norm_num; linarith ++ ++ have : ‖1 / (2 * ↑π * I)‖ * ‖∫ (t : ℝ) in Ioo (-T) (-3), f ↑t‖ ≤ ‖∫ (t : ℝ) in Ioo (-T) (-3), f ↑t‖ := by ++ apply mul_le_of_le_one_left ++ · apply norm_nonneg ++ · exact norm_1over2pii_le1 ++ apply le_trans this ++ have : ‖ ∫ (t : ℝ) in Ioo (-T) (-3), f ↑t‖ ≤ ∫ (t : ℝ) in Ioo (-T) (-3), ‖f ↑ t‖ := by ++ apply norm_integral_le_integral_norm ++ apply le_trans this ++ ++ have norm_f_nonneg: ∀ t, ‖f t‖ ≥ 0 := by ++ exact fun t ↦ norm_nonneg (f t) ++ ++ have g_cont : ContinuousOn g (Icc (-T) (-3)) := by ++ unfold g ++ refine ContinuousOn.mul ?_ ?_ ++ refine ContinuousOn.mul ?_ ?_ ++ refine ContinuousOn.mul ?_ ?_ ++ refine ContinuousOn.mul ?_ ?_ ++ · exact continuousOn_const ++ · exact continuousOn_const ++ · refine ContinuousOn.pow ?_ 9 ++ refine ContinuousOn.log ?_ ?_ ++ · refine Continuous.continuousOn ?_ ++ exact _root_.continuous_abs ++ · intro t ht ++ have h1 := ht.1 ++ have h2 := ht.2 ++ by_contra! ++ have : t = 0 := by ++ exact abs_eq_zero.mp this ++ rw[this] at h2 ++ absurd ++ h2 ++ linarith ++ · refine ContinuousOn.inv₀ ?_ ?_ ++ · refine ContinuousOn.mul ?_ ?_ ++ · exact continuousOn_const ++ · refine ContinuousOn.pow ?_ 2 ++ refine ContinuousOn.norm ?_ ++ refine ContinuousOn.add ?_ ?_ ++ · exact continuousOn_const ++ · refine ContinuousOn.mul ?_ ?_ ++ · refine continuousOn_of_forall_continuousAt ?_ ++ intro x hx ++ exact continuous_ofReal.continuousAt ++ · exact continuousOn_const ++ · intro x hx ++ have norm_sq_pos : ‖(σ₁ : ℂ) + x * Complex.I‖ ^ 2 = σ₁ ^ 2 + x ^ 2 := by ++ rw [Complex.sq_norm] ++ exact normSq_add_mul_I σ₁ x ++ have : 0 < σ₁ ^ 2 + x ^ 2 := by ++ apply add_pos_of_pos_of_nonneg ++ · exact sq_pos_of_pos σ₁pos ++ · exact sq_nonneg x ++ apply mul_ne_zero ++ · linarith ++ · rw [norm_sq_pos] ++ exact ne_of_gt this ++ · exact continuousOn_const ++ ++ have g_integrable_Icc : IntegrableOn g (Icc (-T) (-3)) volume := by ++ exact ContinuousOn.integrableOn_Icc g_cont ++ ++ have g_integrable_Ioo : IntegrableOn g (Ioo (-T) (-3)) volume := by ++ apply MeasureTheory.IntegrableOn.mono_set g_integrable_Icc ++ exact Ioo_subset_Icc_self ++ ++ have int_normf_le_int_g: ∫ (t : ℝ) in Ioo (-T) (-3), ‖f ↑t‖ ++ ≤ ∫ (t : ℝ) in Ioo (-T) (-3), g ↑t := by ++ ++ by_cases h_int : IntervalIntegrable (fun t : ℝ ↦ ‖f t‖) volume (-T) (-3) ++ · have f_int : IntegrableOn (fun (t : ℝ) ↦ ‖f t‖) (Ioo (-T : ℝ) (-3 : ℝ)) volume := by ++ have hle : -T ≤ -3 := by linarith ++ exact (intervalIntegrable_iff_integrableOn_Ioo_of_le hle).mp h_int ++ apply MeasureTheory.setIntegral_mono_on ++ exact f_int ++ exact g_integrable_Ioo ++ exact measurableSet_Ioo ++ intro t ht ++ apply bound_integral ++ have : |t| = -t := by ++ refine abs_of_neg ?_ ++ linarith [ht.2] ++ have abs_tgt3 : 3 < |t| := by ++ rw[this] ++ linarith[ht.2] ++ have abs_tltX : |t| < T := by ++ rw[this] ++ linarith[ht.1] ++ constructor ++ · linarith ++ · linarith ++ · have : ∫ (t : ℝ) in -T..-3, ‖f ↑ t‖ = ∫ (t : ℝ) in Ioo (-T) (-3), ‖f ↑t‖ := by ++ rw [intervalIntegral.integral_of_le (by linarith)] ++ exact MeasureTheory.integral_Ioc_eq_integral_Ioo ++ have : ∫ (t : ℝ) in Ioo (-T) (-3), ‖f ↑t‖ = 0 := by ++ rw [← this] ++ exact intervalIntegral.integral_undef h_int ++ rw [this] ++ apply MeasureTheory.setIntegral_nonneg ++ · exact measurableSet_Ioo ++ · intro t ht ++ have abst_negt : |t| = -t := by ++ refine abs_of_neg ?_ ++ linarith [ht.2] ++ have tbounds1 : 3 < |t| ∧ |t| < T := by ++ rw[abst_negt] ++ constructor ++ · linarith [ht.2] ++ · linarith [ht.1] ++ unfold g ++ apply mul_nonneg ++ apply mul_nonneg ++ apply mul_nonneg ++ apply mul_nonneg ++ · linarith ++ · linarith ++ · have : 0 ≤ Real.log |t| := by ++ apply Real.log_nonneg ++ linarith [tbounds1.1] ++ positivity ++ · positivity ++ ++ · apply Real.rpow_nonneg ++ linarith ++ ++ apply le_trans int_normf_le_int_g ++ unfold g ++ ++ have : X ^ σ₁ = X ^ (1 - A / Real.log T ) := by ++ rfl ++ rw[this] ++ ++ have : X ^ (1 - A / Real.log T) = X * X ^ (- A / Real.log T) := by ++ have hX : X > 0 := by linarith ++ simp only [Real.rpow_sub hX, Real.rpow_one] ++ have h₁ : X ^ (-A / Real.log T) * X ^ (A / Real.log T) = 1 := by ++ rw [← Real.rpow_add hX] ++ ring_nf ++ exact rpow_zero X ++ field_simp ++ simpa only [neg_div, mul_comm] using h₁.symm ++ ++ rw[this] ++ ++ have Bound_of_log_int: ∫ (t : ℝ) in Ioo (-T) (-3), Real.log |t| ^ 9 / (ε * ‖↑σ₁ + ↑t * I‖ ^ 2) ≤ Cint / ε := by ++ have : ∫ (t : ℝ) in Ioo (-T) (-3), Real.log |t| ^ 9 / (ε * ‖↑σ₁ + ↑t * I‖ ^ 2) ++ = (1 / ε) * ∫ t in Ioo (-T) (-3), Real.log |t| ^ 9 / ‖↑σ₁ + ↑t * I‖ ^ 2 := by ++ rw [← integral_const_mul] ++ congr with t ++ field_simp [εgt0] ++ rw[this] ++ have normsquared : ∀ (t : ℝ), ‖↑σ₁ + ↑t * I‖ ^ 2 = σ₁ ^ 2 + t ^ 2 := by ++ intro t ++ simp only [Complex.sq_norm] ++ exact normSq_add_mul_I σ₁ t ++ ++ have : ∫ t in Ioo (-T) (-3), Real.log |t| ^ 9 / ‖↑σ₁ + ↑t * I‖ ^ 2 ++ = ∫ t in Ioo (-T) (-3), Real.log |t| ^ 9 / (σ₁ ^ 2 + t ^ 2) := by ++ simp_rw [normsquared] ++ ++ have bound : ∫ t in Ioo (-T) (-3), Real.log |t| ^ 9 / ‖↑σ₁ + ↑t * I‖ ^ 2 ≤ Cint := by ++ rw [this] ++ have : ∫ t in Ioo (-T) (-3), Real.log |t| ^ 9 / (σ₁ ^ 2 + t ^ 2) ++ ≤ ∫ t in Ioo (-T) (-3), Real.log |t| ^ 9 / t ^ 2 := by ++ refine setIntegral_mono_on ?_ ?_ ?_ ?_ ++ · ++ have cont : ContinuousOn (fun t ↦ Real.log |t| ^ 9 / (σ₁ ^ 2 + t ^ 2)) (Set.Icc (-T) (-3)) := by ++ refine ContinuousOn.div ?_ ?_ ?_ ++ · refine ContinuousOn.pow ?_ 9 ++ refine ContinuousOn.log ?_ ?_ ++ · refine continuousOn_of_forall_continuousAt ?_ ++ intro x hx ++ refine Continuous.continuousAt ?_ ++ exact _root_.continuous_abs ++ · intro x hx ++ have h1 : x ≤ -3 := hx.2 ++ have xne0 : x ≠ 0 := by linarith ++ exact abs_ne_zero.mpr xne0 ++ · refine ContinuousOn.add ?_ ?_ ++ · exact continuousOn_const ++ · refine ContinuousOn.pow ?_ 2 ++ exact continuousOn_id' (Icc (-T) (-3)) ++ · intro t ht ++ have h1 : t ≤ -3 := ht.2 ++ have h2 : t ≠ 0 := by linarith ++ have h3 : 0 < t ^ 2 := pow_two_pos_of_ne_zero h2 ++ have h4 : 0 < σ₁ ^ 2 := sq_pos_of_pos σ₁pos ++ linarith [h3, h4] ++ have int_Icc : IntegrableOn (fun t ↦ Real.log |t| ^ 9 / (σ₁ ^ 2 + t ^ 2)) (Icc (-T) (-3)) volume := by ++ exact ContinuousOn.integrableOn_Icc cont ++ have int_Ioo : IntegrableOn (fun t ↦ Real.log |t| ^ 9 / (σ₁ ^ 2 + t ^ 2)) (Ioo (-T) (-3)) volume := by ++ apply MeasureTheory.IntegrableOn.mono_set int_Icc ++ exact Ioo_subset_Icc_self ++ exact int_Ioo ++ · have cont : ContinuousOn (fun t ↦ Real.log |t| ^ 9 / t ^ 2) (Set.Icc (-T) (-3)) := by ++ refine ContinuousOn.div ?_ ?_ ?_ ++ · refine ContinuousOn.pow ?_ 9 ++ refine ContinuousOn.log ?_ ?_ ++ · refine continuousOn_of_forall_continuousAt ?_ ++ intro x hx ++ refine Continuous.continuousAt ?_ ++ exact _root_.continuous_abs ++ · intro x hx ++ have h1 : x ≤ -3 := hx.2 ++ have xne0 : x ≠ 0 := by linarith ++ exact abs_ne_zero.mpr xne0 ++ · refine ContinuousOn.pow ?_ 2 ++ exact continuousOn_id' (Icc (-T) (-3)) ++ · intro t ht ++ have h1 : t ≤ -3 := ht.2 ++ have tne0 : t ≠ 0 := by linarith ++ exact pow_ne_zero 2 tne0 ++ have int_Icc : IntegrableOn (fun t ↦ Real.log |t| ^ 9 / t ^ 2) (Icc (-T) (-3)) volume := by ++ exact ContinuousOn.integrableOn_Icc cont ++ have int_Ioo : IntegrableOn (fun t ↦ Real.log |t| ^ 9 / t ^ 2) (Ioo (-T) (-3)) volume := by ++ apply MeasureTheory.IntegrableOn.mono_set int_Icc ++ exact Ioo_subset_Icc_self ++ exact int_Ioo ++ · exact measurableSet_Ioo ++ · intro x hx ++ have xneg : x < 0 := by linarith[hx.2] ++ have absx : |x| = -x := abs_of_neg xneg ++ have h1 : 3 < |x| ∧ |x| < T := by ++ rw[absx] ++ constructor ++ · linarith [hx.2] ++ · linarith [hx.1] ++ exact quotient_bound x (t_bounds x hx) ++ apply le_trans this ++ have : ∫ (t : ℝ) in Ioo (-T) (-3), Real.log |t| ^ 9 / t ^ 2 ++ = ∫ (t : ℝ) in Ioo 3 T, Real.log t ^ 9 / t ^ 2 := by ++ have eq_integrand : ∀ (t : ℝ), t ∈ Ioo (-T) (-3) → (Real.log |t|) ^ 9 / t ^ 2 = (Real.log (-t)) ^ 9 / (-t) ^ 2 := by ++ intro t ht ++ have tneg : t < 0 := by linarith[ht.2] ++ have : |t| = -t := abs_of_neg tneg ++ rw [this, neg_sq] ++ ++ have : ∫ (t : ℝ) in Ioo (-T) (-3), Real.log |t| ^ 9 / t ^ 2 ++ = ∫ (t : ℝ) in Ioo (-T) (-3), Real.log (-t) ^ 9 / (-t) ^ 2 := by ++ exact MeasureTheory.setIntegral_congr_fun measurableSet_Ioo eq_integrand ++ ++ rw [this] ++ ++ have interval_to_Ioo1 : ∫ (t : ℝ) in -T..-3, Real.log (-t) ^ 9 / (-t) ^ 2 ++ = ∫ (t : ℝ) in Ioo (-T) (-3), Real.log (-t) ^ 9 / (-t) ^ 2 := by ++ rw [intervalIntegral.integral_of_le (by linarith)] ++ exact MeasureTheory.integral_Ioc_eq_integral_Ioo ++ ++ have interval_to_Ioo2 : ∫ (t : ℝ) in (3)..(T), Real.log t ^ 9 / t ^ 2 ++ = ∫ (t : ℝ) in Ioo 3 T, Real.log t ^ 9 / t ^ 2 := by ++ rw [intervalIntegral.integral_of_le (by linarith)] ++ exact MeasureTheory.integral_Ioc_eq_integral_Ioo ++ ++ rw [← interval_to_Ioo1, ← interval_to_Ioo2] ++ rw [intervalIntegral.integral_comp_neg (fun (t : ℝ) ↦ Real.log (t) ^ 9 / (t) ^ 2)] ++ simp ++ rw [this] ++ have : ∫ (t : ℝ) in Ioo 3 T, Real.log t ^ 9 / t ^ 2 < Cint := by ++ exact Cinthyp T Tgt3 ++ linarith ++ rw [ mul_comm] ++ rw [← mul_div_assoc, mul_one] ++ exact (div_le_div_iff_of_pos_right εgt0).mpr bound ++ ++ have factor_out_constants : ++ ∫ (t : ℝ) in Ioo (-T) (-3), Cζ * CM * Real.log |t| ^ 9 / (ε * ‖↑σ₁ + ↑t * I‖ ^ 2) * (X * X ^ (-A / Real.log T )) ++ = Cζ * CM * (X * X ^ (-A / Real.log T)) * ∫ (t : ℝ) in Ioo (-T) (-3), Real.log |t| ^ 9 / (ε * ‖↑σ₁ + ↑t * I‖ ^ 2) := by ++ rw [mul_assoc, ← mul_assoc (Cζ * CM), ← mul_assoc] ++ field_simp ++ rw [← integral_const_mul] ++ apply MeasureTheory.setIntegral_congr_fun measurableSet_Ioo ++ intro t ht ++ ring_nf ++ ++ rw [factor_out_constants] ++ ++ have : Cζ * CM * (X * X ^ (-A / Real.log T)) * ∫ (t : ℝ) in Ioo (-T) (-3), Real.log |t| ^ 9 / (ε * ‖↑σ₁ + ↑t * I‖ ^ 2) ++ ≤ Cζ * CM * ((X : ℝ) * X ^ (-A / Real.log T)) * (Cint / ε) := by ++ apply mul_le_mul_of_nonneg_left ++ · exact Bound_of_log_int ++ · have hpos : 0 < X * X ^ (-A / Real.log T) := by ++ apply mul_pos ++ · linarith ++ · apply Real.rpow_pos_of_pos ++ linarith ++ apply mul_nonneg ++ · apply mul_nonneg ++ · linarith ++ · linarith ++ · linarith [hpos] ++ ++ apply le_trans this ++ ring_nf ++ field_simp; norm_num ++ ++lemma I7I3 {SmoothingF : ℝ → ℝ} {ε X T σ₁ : ℝ} (Xpos : 0 < X) : ++ I₇ SmoothingF ε T X σ₁ = conj (I₃ SmoothingF ε T X σ₁) := by ++ unfold I₃ I₇ ++ simp only [map_mul, map_div₀, conj_I, conj_ofReal, conj_ofNat, map_one] ++ rw [neg_mul, mul_neg, ← neg_mul] ++ congr ++ · ring ++ · rw [← intervalIntegral_conj, ← intervalIntegral.integral_comp_neg] ++ apply intervalIntegral.integral_congr ++ intro t ht ++ simp only ++ rw [← smoothedChebyshevIntegrand_conj Xpos] ++ simp ++ ++lemma I7Bound {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ {A Cζ : ℝ} (hCζ : LogDerivZetaHasBound A Cζ) (Cζpos : 0 < Cζ) (hA : A ∈ Ioc 0 (1 / 2)) ++ : ∃ (C : ℝ) (_ : 0 < C), ++ ∀ (X : ℝ) (_ : 3 < X) {ε : ℝ} (_ : 0 < ε) ++ (_ : ε < 1) {T : ℝ} (_ : 3 < T), ++ let σ₁ : ℝ := 1 - A / (Real.log T) ++ ‖I₇ SmoothingF ε T X σ₁‖ ≤ C * X * X ^ (- A / (Real.log T)) / ε := by ++ obtain ⟨C, Cpos, bound⟩ := I3Bound suppSmoothingF ContDiffSmoothingF hCζ Cζpos hA ++ refine ⟨C, Cpos, fun X X_gt ε εpos ε_lt_one T T_gt ↦ ?_⟩ ++ specialize bound X X_gt εpos ε_lt_one T_gt ++ intro σ₁ ++ rwa [I7I3 (by linarith), norm_conj] ++ ++lemma I4Bound {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ {σ₂ : ℝ} (h_logDeriv_holo : LogDerivZetaIsHoloSmall σ₂) (hσ₂ : σ₂ ∈ Ioo 0 1) ++ {A : ℝ} ++ (hA : A ∈ Ioc 0 (1 / 2)) : ++ ∃ (C : ℝ) (_ : 0 ≤ C) (Tlb : ℝ) (_ : 3 < Tlb), ++ ∀ (X : ℝ) (_ : 3 < X) ++ {ε : ℝ} (_ : 0 < ε) (_ : ε < 1) ++ {T : ℝ} (_ : Tlb < T), ++ let σ₁ : ℝ := 1 - A / (Real.log T) ++ ‖I₄ SmoothingF ε X σ₁ σ₂‖ ≤ C * X * X ^ (- A / (Real.log T)) / ε := by ++ ++ have reOne : re 1 = 1 := by exact rfl ++ have imOne : im 1 = 0 := by exact rfl ++ have reThree : re 3 = 3 := by exact rfl ++ have imThree : im 3 = 0 := by exact rfl ++ ++ have elt3 : Real.exp 1 < 3 := by ++ linarith[Real.exp_one_lt_d9] ++ ++ unfold I₄ SmoothedChebyshevIntegrand ++ ++ let S : Set ℝ := (fun (t : ℝ) ↦ ↑‖-ζ' (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I) / ζ (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I)‖₊) '' Icc 0 1 ++ let C' : ℝ := sSup S ++ have bddAboveS : BddAbove S := by ++ refine IsCompact.bddAbove ?_ ++ unfold S ++ refine IsCompact.image_of_continuousOn ?_ ?_ ++ · exact isCompact_Icc ++ · refine ContinuousOn.norm ?_ ++ have : (fun (t : ℝ) ↦ -ζ' (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I) / ζ (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I)) = ++ (fun (t : ℝ) ↦ -(ζ' (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I) / ζ (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I))) := by ++ apply funext ++ intro x ++ apply neg_div ++ rw[this] ++ refine ContinuousOn.neg ?_ ++ have : (fun (t : ℝ) ↦ ζ' (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I) / ζ (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I)) = ++ ((ζ' / ζ) ∘ (fun (t : ℝ) ↦ (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I))) := by exact rfl ++ rw[this] ++ apply h_logDeriv_holo.continuousOn.comp' (by fun_prop) ++ unfold MapsTo ++ intro x xInIcc ++ simp only [neg_le_self_iff, Nat.ofNat_nonneg, uIcc_of_le, Set.mem_sdiff] ++ have : ¬↑σ₂ + ↑x * (1 - ↑σ₂) - 3 * I = 1 := by ++ by_contra h ++ rw[Complex.ext_iff, sub_re, add_re, sub_im, add_im] at h ++ repeat rw[mul_im] at h ++ repeat rw[mul_re] at h ++ rw[sub_im, sub_re, reOne, imOne, reThree, imThree, I_im, I_re] at h ++ repeat rw[ofReal_re] at h ++ repeat rw[ofReal_im] at h ++ ring_nf at h ++ obtain ⟨_, ripGoal⟩ := h ++ have : -3 ≠ 0 := by norm_num ++ linarith ++ refine ⟨?_, this⟩ ++ rw [mem_reProdIm] ++ simp only [sub_re, add_re, ofReal_re, mul_re, one_re, ofReal_im, sub_im, one_im, sub_self, ++ mul_zero, sub_zero, re_ofNat, I_re, im_ofNat, I_im, mul_one, add_im, mul_im, zero_mul, ++ add_zero, zero_sub, mem_Icc, le_refl, neg_le_self_iff, Nat.ofNat_nonneg, and_self, and_true] ++ rw [Set.uIcc_of_le] ++ · rw [mem_Icc] ++ constructor ++ · simp only [le_add_iff_nonneg_right] ++ apply mul_nonneg ++ · exact xInIcc.1 ++ · linarith [hσ₂.2] ++ · have : σ₂ + x * (1 - σ₂) = σ₂ * (1 - x) + x := by ring ++ rw [this] ++ clear this ++ have : (2 : ℝ) = 1 * 1 + 1 := by norm_num ++ rw [this] ++ clear this ++ gcongr ++ · linarith [xInIcc.2] ++ · exact hσ₂.2.le ++ · linarith [xInIcc.1] ++ · exact xInIcc.2 ++ · linarith [hσ₂.2] ++ ++ have CPrimeNonneg : 0 ≤ C' := by ++ apply Real.sSup_nonneg ++ intro x x_in_S ++ obtain ⟨t, ht, rfl⟩ := x_in_S ++ exact NNReal.coe_nonneg _ ++ ++ obtain ⟨D, Dpos, MellinSmooth1bBound⟩ := MellinOfSmooth1b ContDiffSmoothingF suppSmoothingF ++ let C : ℝ := C' * D / sInf ((fun t => ‖ σ₂ + (t : ℝ) * (1 - σ₂) - 3 * I ‖₊ ^ 2) '' Set.Icc 0 1) ++ use C ++ have sInfPos : 0 < sInf ((fun (t : ℝ) ↦ ‖↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I‖₊ ^ 2) '' Icc 0 1) := by ++ refine (IsCompact.lt_sInf_iff_of_continuous ?_ ?_ ?_ 0).mpr ?_ ++ · exact isCompact_Icc ++ · exact Nonempty.of_subtype ++ · have : (fun (t : ℝ) ↦ ‖↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I‖₊ ^ 2) = ++ (fun (t : ℝ) ↦ ‖↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I‖₊ * ‖↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I‖₊) := by ++ apply funext ++ intro x ++ rw[pow_two] ++ rw[this] ++ have : ContinuousOn (fun (t : ℝ) ↦ ‖↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I‖₊) (Icc 0 1) := by ++ refine ContinuousOn.nnnorm ?_ ++ refine ContinuousOn.sub ?_ (by exact continuousOn_const) ++ refine ContinuousOn.add (by exact continuousOn_const) ?_ ++ exact ContinuousOn.mul (by exact Complex.continuous_ofReal.continuousOn) (by exact continuousOn_const) ++ exact ContinuousOn.mul (by exact this) (by exact this) ++ · intro x xLoc ++ apply pow_pos ++ have temp : |(↑σ₂ + ↑x * (1 - ↑σ₂) - 3 * I).im| ≤ ++ ‖↑σ₂ + ↑x * (1 - ↑σ₂) - 3 * I‖₊ := by apply Complex.abs_im_le_norm ++ rw[sub_im, add_im, mul_im, mul_im, I_re, I_im, sub_im, sub_re] at temp ++ repeat rw[ofReal_re] at temp ++ repeat rw[ofReal_im] at temp ++ rw[reThree, imOne] at temp ++ ring_nf at temp ⊢ ++ rw[abs_of_neg, neg_neg] at temp ++ · have : (3 : NNReal) ≤ ‖↑σ₂ - ↑σ₂ * ↑x + (↑x - I * 3)‖₊ := by ++ apply (NNReal.coe_le_coe).mp ++ convert! temp using 1; congr 2; ring ++ have hp : (0 : NNReal) < ‖↑σ₂ - ↑σ₂ * ↑x + (↑x - I * 3)‖₊ := ++ lt_of_lt_of_le (by norm_num) this ++ convert! hp using 1; congr 2; ring ++ · rw[neg_lt_zero] ++ norm_num ++ have CNonneg : 0 ≤ C := by ++ unfold C ++ apply mul_nonneg ++ · exact mul_nonneg (by exact CPrimeNonneg) (by exact Dpos.le) ++ · rw[inv_nonneg] ++ norm_cast ++ convert sInfPos.le using 5 ++ norm_cast ++ use CNonneg ++ ++ let Tlb : ℝ := max 4 (max (rexp A) (rexp (A / (1 - σ₂)))) ++ use Tlb ++ ++ have : 3 < Tlb := by ++ unfold Tlb ++ rw[lt_max_iff] ++ refine Or.inl ?_ ++ norm_num ++ use this ++ ++ intro X X_gt_three ε ε_pos ε_lt_one T T_gt_Tlb σ₁ ++ have σ₂_le_σ₁ : σ₂ ≤ σ₁ := by ++ have logTlb_pos : 0 < Real.log Tlb := by ++ rw[← Real.log_one] ++ exact log_lt_log (by norm_num) (by linarith) ++ have logTlb_nonneg : 0 ≤ Real.log Tlb := by exact le_of_lt (by exact logTlb_pos) ++ have expr_nonneg : 0 ≤ A / (1 - σ₂) := by ++ apply div_nonneg ++ · linarith [hA.1] ++ · rw[sub_nonneg] ++ exact le_of_lt hσ₂.2 ++ have temp : σ₂ ≤ 1 - A / Real.log Tlb := by ++ have : rexp (A / (1 - σ₂)) ≤ Tlb := by ++ unfold Tlb ++ apply le_max_of_le_right ++ apply le_max_right ++ rw[← Real.le_log_iff_exp_le] at this ++ · rw[div_le_iff₀, mul_comm, ← div_le_iff₀] at this ++ · linarith ++ · exact logTlb_pos ++ · rw[sub_pos] ++ exact hσ₂.2 ++ · positivity ++ have : 1 - A / Real.log Tlb ≤ 1 - A / Real.log T := by ++ apply sub_le_sub (by rfl) ++ apply div_le_div₀ ++ · exact le_of_lt (by exact hA.1) ++ · rfl ++ · exact logTlb_pos ++ · apply log_le_log (by positivity) ++ exact le_of_lt (by exact T_gt_Tlb) ++ exact le_trans temp this ++ have minσ₂σ₁ : min σ₂ σ₁ = σ₂ := by exact min_eq_left (by exact σ₂_le_σ₁) ++ have maxσ₂σ₁ : max σ₂ σ₁ = σ₁ := by exact max_eq_right (by exact σ₂_le_σ₁) ++ have σ₁_lt_one : σ₁ < 1 := by ++ rw[← sub_zero 1] ++ unfold σ₁ ++ apply sub_lt_sub_left ++ apply div_pos (by exact hA.1) ++ rw[← Real.log_one] ++ exact log_lt_log (by norm_num) (by linarith) ++ ++ rw[norm_mul, ← one_mul C] ++ have : 1 * C * X * X ^ (-A / Real.log T) / ε = 1 * (C * X * X ^ (-A / Real.log T) / ε) := by ring ++ rw[this] ++ apply mul_le_mul ++ · rw[norm_div, norm_one] ++ repeat rw[norm_mul] ++ rw[Complex.norm_two, Complex.norm_real, Real.norm_of_nonneg, Complex.norm_I, mul_one] ++ have : 1 / (2 * π) < 1 / 6 := by ++ rw[one_div_lt_one_div] ++ · refine (div_lt_iff₀' ?_).mp ?_ ++ norm_num ++ ring_nf ++ refine gt_iff_lt.mpr ?_ ++ exact Real.pi_gt_three ++ · positivity ++ · norm_num ++ apply le_of_lt ++ exact lt_trans this (by norm_num) ++ exact pi_nonneg ++ · let f : ℝ → ℂ := fun σ ↦ (-ζ' (↑σ - 3 * I) / ζ (↑σ - 3 * I) * 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ - 3 * I) * ↑X ^ (↑σ - 3 * I)) ++ have temp : ‖∫ (σ : ℝ) in σ₂..σ₁, -ζ' (↑σ - 3 * I) / ζ (↑σ - 3 * I) * 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ - 3 * I) * ↑X ^ (↑σ - 3 * I)‖ ≤ ++ C * X * X ^ (-A / Real.log T) / ε * |σ₁ - σ₂| := by ++ have : ∀ x ∈ Set.uIoc σ₂ σ₁, ‖f x‖ ≤ C * X * X ^ (-A / Real.log T) / ε := by ++ intro x xInIoc ++ let t : ℝ := (x - σ₂) / (1 - σ₂) ++ have tInIcc : t ∈ Icc 0 1 := by ++ unfold t ++ constructor ++ · apply div_nonneg ++ · rw[sub_nonneg] ++ unfold uIoc at xInIoc ++ rw[minσ₂σ₁] at xInIoc ++ exact le_of_lt (by exact xInIoc.1) ++ · rw[sub_nonneg] ++ apply le_of_lt (by exact hσ₂.2) ++ · rw[div_le_one] ++ · refine sub_le_sub ?_ (by rfl) ++ unfold uIoc at xInIoc ++ rw[maxσ₂σ₁] at xInIoc ++ apply le_trans xInIoc.2 ++ exact le_of_lt (by exact σ₁_lt_one) ++ · rw[sub_pos] ++ exact hσ₂.2 ++ have tExpr : (↑σ₂ + t * (1 - ↑σ₂) - 3 * I) = (↑x - 3 * I) := by ++ unfold t ++ simp only [ofReal_div, ofReal_sub, ofReal_one, sub_left_inj] ++ rw[div_mul_comm, div_self] ++ · simp only [one_mul, add_sub_cancel] ++ · refine sub_ne_zero_of_ne ?_ ++ apply Ne.symm ++ rw[Complex.ofReal_ne_one] ++ exact ne_of_lt (by exact hσ₂.2) ++ unfold f ++ simp only [Complex.norm_mul] ++ have : C * X * X ^ (-A / Real.log T) / ε = ++ (C / ε) * (X * X ^ (-A / Real.log T)) := by ring ++ rw[this] ++ have temp : ‖-ζ' (↑x - 3 * I) / ζ (↑x - 3 * I)‖ * ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑x - 3 * I)‖ ≤ ++ C / ε := by ++ unfold C ++ rw[div_div] ++ nth_rewrite 2 [div_eq_mul_inv] ++ have temp : ‖-ζ' (↑x - 3 * I) / ζ (↑x - 3 * I)‖ ≤ C' := by ++ unfold C' ++ have : ‖-ζ' (↑x - 3 * I) / ζ (↑x - 3 * I)‖ ∈ ++ (fun (t : ℝ) ↦ ↑‖-ζ' (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I) / ζ (↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I)‖₊) '' Icc 0 1 := by ++ rw[Set.mem_image] ++ use t ++ constructor ++ · exact tInIcc ++ · rw[tExpr] ++ rfl ++ exact le_csSup (by exact bddAboveS) (by exact this) ++ have : ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑x - 3 * I)‖ ≤ ++ D * ((sInf ((fun (t : ℝ) ↦ ‖↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I‖₊ ^ 2) '' Icc 0 1)) * ε)⁻¹ := by ++ nth_rewrite 3 [mul_comm] ++ let s : ℂ := x - 3 * I ++ have : 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑x - 3 * I) = ++ 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) s := by exact rfl ++ rw[this] ++ have temp : σ₂ ≤ s.re := by ++ unfold s ++ rw[sub_re, mul_re, I_re, I_im, reThree, imThree, ofReal_re] ++ ring_nf ++ apply le_of_lt ++ unfold uIoc at xInIoc ++ rw[minσ₂σ₁] at xInIoc ++ exact xInIoc.1 ++ have : s.re ≤ 2 := by ++ unfold s ++ rw[sub_re, mul_re, I_re, I_im, reThree, imThree, ofReal_re] ++ ring_nf ++ have : x < 1 := by ++ unfold uIoc at xInIoc ++ rw[maxσ₂σ₁] at xInIoc ++ exact lt_of_le_of_lt xInIoc.2 σ₁_lt_one ++ linarith ++ have temp : ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) s‖ ≤ D * (ε * ‖s‖ ^ 2)⁻¹ := by ++ exact MellinSmooth1bBound σ₂ hσ₂.1 s temp this ε ε_pos ε_lt_one ++ have : D * (ε * ‖s‖ ^ 2)⁻¹ ≤ D * (ε * ↑(sInf ((fun (t : ℝ) ↦ ‖↑σ₂ + ↑t * (1 - ↑σ₂) - 3 * I‖₊ ^ 2) '' Icc 0 1)))⁻¹ := by ++ refine mul_le_mul (by rfl) ?_ ?_ (by exact le_of_lt (by exact Dpos)) ++ · rw[inv_le_inv₀] ++ · apply mul_le_mul (by rfl) ++ · rw[NNReal.coe_sInf] ++ apply csInf_le ++ · apply NNReal.bddBelow_coe ++ · unfold s ++ rw[Set.mem_image] ++ let xNorm : NNReal := ‖x - 3 * I‖₊ ^ 2 ++ use xNorm ++ constructor ++ · rw[Set.mem_image] ++ use t ++ exact ⟨tInIcc, by rw[tExpr]⟩ ++ · rfl ++ · exact le_of_lt (by exact sInfPos) ++ · exact le_of_lt (by exact ε_pos) ++ · apply mul_pos (ε_pos) ++ refine sq_pos_of_pos ?_ ++ refine norm_pos_iff.mpr ?_ ++ refine ne_zero_of_re_pos ?_ ++ unfold s ++ rw[sub_re, mul_re, I_re, I_im, reThree, imThree, ofReal_re] ++ ring_nf ++ unfold uIoc at xInIoc ++ rw[minσ₂σ₁] at xInIoc ++ exact lt_trans hσ₂.1 xInIoc.1 ++ · exact mul_pos (ε_pos) (sInfPos) ++ · rw[inv_nonneg] ++ apply mul_nonneg (by exact le_of_lt (by exact ε_pos)) ++ exact sq_nonneg ‖s‖ ++ exact le_trans temp this ++ rw[mul_assoc] ++ apply mul_le_mul (by exact temp) (by exact this) ++ · have this : 0 ≤ |(𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑x - 3 * I)).re| := by ++ apply abs_nonneg ++ exact le_trans this (by refine Complex.abs_re_le_norm ?_) ++ · exact CPrimeNonneg ++ have : ‖(X : ℂ) ^ (↑x - 3 * I)‖ ≤ ++ X * X ^ (-A / Real.log T) := by ++ nth_rewrite 2 [← Real.rpow_one X] ++ rw[← Real.rpow_add] ++ · rw[Complex.norm_cpow_of_ne_zero] ++ · rw[sub_re, sub_im, mul_re, mul_im, ofReal_re, ofReal_im, I_re, I_im, reThree, imThree] ++ ring_nf ++ rw[Complex.norm_of_nonneg] ++ · rw[Complex.arg_ofReal_of_nonneg] ++ ++ · have one_inv: (1⁻¹ : ℝ) = ( 1 : ℝ) := by norm_num ++ rw[zero_mul, neg_zero, Real.exp_zero, one_inv, mul_one] ++ refine rpow_le_rpow_of_exponent_le ?_ ?_ ++ · linarith ++ · unfold uIoc at xInIoc ++ rw[maxσ₂σ₁] at xInIoc ++ unfold σ₁ at xInIoc ++ rw [←div_eq_mul_inv] ++ ring_nf at xInIoc ⊢ ++ exact xInIoc.2 ++ · positivity ++ · positivity ++ · refine ne_zero_of_re_pos ?_ ++ rw[ofReal_re] ++ positivity ++ · positivity ++ apply mul_le_mul ++ · exact temp ++ · exact this ++ · rw[Complex.norm_cpow_eq_rpow_re_of_pos] ++ · rw[sub_re, mul_re, ofReal_re, I_re, I_im, reThree, imThree] ++ ring_nf ++ apply Real.rpow_nonneg ++ positivity ++ · positivity ++ · exact div_nonneg CNonneg (le_of_lt ε_pos) ++ exact intervalIntegral.norm_integral_le_of_norm_le_const this ++ have : C * X * X ^ (-A / Real.log T) / ε * |σ₁ - σ₂| ≤ ++ C * X * X ^ (-A / Real.log T) / ε := by ++ have : |σ₁ - σ₂| ≤ 1 := by ++ rw[abs_of_nonneg] ++ · rw[← sub_zero 1] ++ exact sub_le_sub σ₁_lt_one.le hσ₂.1.le ++ · rw[sub_nonneg] ++ exact σ₂_le_σ₁ ++ bound ++ exact le_trans temp this ++ simp only [norm_nonneg] ++ norm_num ++ ++lemma I6I4 {SmoothingF : ℝ → ℝ} {ε X σ₁ σ₂ : ℝ} (Xpos : 0 < X) : ++ I₆ SmoothingF ε X σ₁ σ₂ = -conj (I₄ SmoothingF ε X σ₁ σ₂) := by ++ unfold I₆ I₄ ++ simp only [map_mul, map_div₀, conj_ofReal, conj_I, map_one, conj_ofNat] ++ rw [← neg_mul] ++ congr ++ · ring ++ · rw [← intervalIntegral_conj] ++ apply intervalIntegral.integral_congr ++ intro σ hσ ++ simp only ++ rw[← smoothedChebyshevIntegrand_conj Xpos] ++ simp [conj_ofNat] ++ ++lemma I6Bound {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ {σ₂ : ℝ} (h_logDeriv_holo : LogDerivZetaIsHoloSmall σ₂) (hσ₂ : σ₂ ∈ Ioo 0 1) ++ {A : ℝ} ++ (hA : A ∈ Ioc 0 (1 / 2)) : ++ ∃ (C : ℝ) (_ : 0 ≤ C) (Tlb : ℝ) (_ : 3 < Tlb), ++ ∀ (X : ℝ) (_ : 3 < X) ++ {ε : ℝ} (_ : 0 < ε) (_ : ε < 1) ++ {T : ℝ} (_ : Tlb < T), ++ let σ₁ : ℝ := 1 - A / (Real.log T) ++ ‖I₆ SmoothingF ε X σ₁ σ₂‖ ≤ C * X * X ^ (- A / (Real.log T)) / ε := by ++ obtain ⟨C, Cpos, Tlb, Tlb_gt, bound⟩ := I4Bound suppSmoothingF ContDiffSmoothingF h_logDeriv_holo hσ₂ hA ++ refine ⟨C, Cpos, Tlb, Tlb_gt, fun X X_gt ε εpos ε_lt_one T T_gt ↦ ?_⟩ ++ specialize bound X X_gt εpos ε_lt_one T_gt ++ intro σ₁ ++ rwa [I6I4 (by linarith), norm_neg, norm_conj] ++ ++lemma I5Bound {SmoothingF : ℝ → ℝ} ++ (suppSmoothingF : Function.support SmoothingF ⊆ Icc (1 / 2) 2) ++ (ContDiffSmoothingF : ContDiff ℝ 1 SmoothingF) ++ {σ₂ : ℝ} (h_logDeriv_holo : LogDerivZetaIsHoloSmall σ₂) (hσ₂ : σ₂ ∈ Ioo 0 1) ++ : ∃ (C : ℝ) (_ : 0 < C), ++ ∀ (X : ℝ) (_ : 3 < X) {ε : ℝ} (_ : 0 < ε) ++ (_ : ε < 1), ++ ‖I₅ SmoothingF ε X σ₂‖ ≤ C * X ^ σ₂ / ε := by ++ ++ unfold LogDerivZetaIsHoloSmall HolomorphicOn at h_logDeriv_holo ++ let zeta'_zeta_on_line := fun (t : ℝ) ↦ ζ' (σ₂ + t * I) / ζ (σ₂ + t * I) ++ ++ have subst : {σ₂} ×ℂ uIcc (-3) 3 ⊆ (uIcc σ₂ 2 ×ℂ uIcc (-3) 3) \ {1} := by ++ simp! only [neg_le_self_iff, Nat.ofNat_nonneg, uIcc_of_le] ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, neg_le_self_iff, ++ Nat.ofNat_nonneg, uIcc_of_le] ++ intro z hyp_z ++ simp only [mem_reProdIm, mem_singleton_iff, mem_Icc] at hyp_z ++ simp only [Set.mem_sdiff, mem_reProdIm, mem_Icc, mem_singleton_iff] ++ constructor ++ · constructor ++ · rw [hyp_z.1] ++ apply left_mem_uIcc ++ · exact hyp_z.2 ++ · push Not ++ by_contra h ++ rw [h] at hyp_z ++ simp only [one_re, one_im, Left.neg_nonpos_iff, Nat.ofNat_nonneg, and_self, and_true] at hyp_z ++ linarith [hσ₂.2] ++ ++ have zeta'_zeta_cont := (h_logDeriv_holo.mono subst).continuousOn ++ ++ have is_compact' : IsCompact ({σ₂} ×ℂ uIcc (-3) 3) := by ++ refine IsCompact.reProdIm ?_ ?_ ++ · exact isCompact_singleton ++ · exact isCompact_uIcc ++ ++ let ⟨zeta_bound, zeta_prop⟩ := ++ IsCompact.exists_bound_of_continuousOn (is_compact') zeta'_zeta_cont ++ ++ let ⟨M, ⟨M_is_pos, M_bounds_mellin_hard⟩⟩ := ++ MellinOfSmooth1b ContDiffSmoothingF suppSmoothingF ++ ++ clear is_compact' zeta'_zeta_cont subst zeta'_zeta_on_line h_logDeriv_holo ++ ++ unfold I₅ ++ unfold SmoothedChebyshevIntegrand ++ ++ let mellin_prop : ∀ (t ε : ℝ), ++ 0 < ε → ε < 1 → ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)‖ ≤ M * (ε * ‖↑σ₂ + ↑t * I‖ ^ 2)⁻¹ := ++ fun (t : ℝ) ↦ (M_bounds_mellin_hard σ₂ (by linarith[hσ₂.1]) (σ₂ + t * I) (by simp only [add_re, ++ ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, add_zero, le_refl]) (by simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, add_zero]; linarith[hσ₂.2])) ++ ++ simp only [mul_inv_rev] at mellin_prop ++ ++ let Const := 1 + (σ₂^2)⁻¹ * (abs zeta_bound) * M ++ ++ let C := |π|⁻¹ * 2⁻¹ * 6 * Const ++ use C ++ have C_pos : 0 < C := by positivity ++ use C_pos ++ ++ have U : σ₂ ∈ Ioo 0 1 := by ++ refine mem_Ioo.mpr ?_ ++ · constructor ++ · linarith[hσ₂.1] ++ · linarith[hσ₂.2] ++ ++ clear U C_pos ++ ++ intros X X_gt ε ε_pos ε_lt_one ++ ++ have mellin_bound := fun (t : ℝ) ↦ mellin_prop t ε ε_pos ε_lt_one ++ ++ have U: 0 < σ₂^2 := by ++ exact sq_pos_of_pos (by linarith[hσ₂.1]) ++ ++ have easy_bound : ∀(t : ℝ), (‖↑σ₂ + ↑t * I‖^2)⁻¹ ≤ (σ₂^2)⁻¹ := ++ by ++ intro t ++ rw [inv_le_inv₀] ++ rw [Complex.sq_norm]; rw [Complex.normSq_apply]; simp only [add_re, ofReal_re, mul_re, I_re, ++ mul_zero, ofReal_im, I_im, mul_one, sub_self, add_zero, add_im, mul_im, zero_add]; ring_nf; simp only [le_add_iff_nonneg_right]; exact zpow_two_nonneg t ++ rw [Complex.sq_norm, Complex.normSq_apply]; simp only [add_re, ofReal_re, mul_re, I_re, ++ mul_zero, ofReal_im, I_im, mul_one, sub_self, add_zero, add_im, mul_im, zero_add]; ring_nf; positivity ++ positivity ++ ++ have T1 : ∀(t : ℝ), t ∈ uIoc (-3) (3 : ℝ) → ‖-ζ' (↑σ₂ + ↑t * I) / ζ (↑σ₂ + ↑t * I) * 𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I) * ++ (↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ ≤ Const * ε⁻¹ * X ^ σ₂ := by ++ intro t hyp_t ++ have Z := by ++ calc ++ ‖(-ζ' (↑σ₂ + ↑t * I) / ζ (↑σ₂ + ↑t * I)) * (𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)) * ++ (↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ = ‖-ζ' (↑σ₂ + ↑t * I) / ζ (↑σ₂ + ↑t * I)‖ * ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)‖ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ := by simp only [Complex.norm_mul, ++ Complex.norm_div, norm_neg] ++ _ ≤ ‖ζ' (↑σ₂ + ↑t * I) / ζ (↑σ₂ + ↑t * I)‖ * ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)‖ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ := by simp only [Complex.norm_div, ++ norm_neg, le_refl] ++ _ ≤ zeta_bound * ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)‖ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ := ++ by ++ have U := zeta_prop (↑σ₂ + t * I) (by ++ simp only [neg_le_self_iff, Nat.ofNat_nonneg, uIcc_of_le] ++ simp only [mem_reProdIm, add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, ++ mul_one, sub_self, add_zero, mem_singleton_iff, add_im, mul_im, zero_add, mem_Icc] ++ constructor ++ · trivial ++ · refine mem_Icc.mp ?_ ++ · refine mem_Icc_of_Ioc ?_ ++ · have T : (-3 : ℝ) ≤ 3 := by simp only [neg_le_self_iff, Nat.ofNat_nonneg] ++ rw [←Set.uIoc_of_le T] ++ exact hyp_t) ++ simp only [Complex.norm_div] at U ++ simp only [Complex.norm_div, ge_iff_le] ++ linear_combination U * ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)‖ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ ++ _ ≤ abs zeta_bound * ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)‖ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ := by ++ have U : zeta_bound ≤ abs zeta_bound := by simp only [le_abs_self] ++ linear_combination (U * ‖𝓜 (fun x ↦ ↑(Smooth1 SmoothingF ε x)) (↑σ₂ + ↑t * I)‖ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ ) ++ _ ≤ abs zeta_bound * M * ((‖↑σ₂ + ↑t * I‖ ^ 2)⁻¹ * ε⁻¹) * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ := by ++ have U := mellin_bound t ++ linear_combination (abs zeta_bound) * U * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ ++ _ ≤ abs zeta_bound * M * (σ₂^2)⁻¹ * ε⁻¹ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖ := by ++ have T : 0 ≤ abs zeta_bound * M := by positivity ++ linear_combination (abs zeta_bound * M * easy_bound t * ε⁻¹ * ‖(↑X : ℂ) ^ (↑σ₂ + ↑t * I)‖) ++ _ = abs zeta_bound * M * (σ₂^2)⁻¹ * ε⁻¹ * X ^ (σ₂) := by ++ rw [Complex.norm_cpow_eq_rpow_re_of_pos] ++ simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, ++ add_zero] ++ positivity ++ _ ≤ Const * ε⁻¹ * X ^ σ₂ := by ++ unfold Const ++ ring_nf ++ simp only [inv_pow, le_add_iff_nonneg_right, inv_pos, mul_nonneg_iff_of_pos_left, ε_pos] ++ positivity ++ ++ exact Z ++ ++ simp only [one_div, mul_inv_rev, inv_I, neg_mul, norm_neg, Complex.norm_mul, norm_I, norm_inv, ++ norm_real, norm_eq_abs, Complex.norm_ofNat, one_mul, ge_iff_le] ++ have Z := ++ intervalIntegral.norm_integral_le_of_norm_le_const T1 ++ simp only [ge_iff_le] ++ ++ have S : |π|⁻¹ * 2⁻¹ * (Const * ε⁻¹ * X ^ σ₂ * |3 + 3|) = C * X ^ σ₂ / ε := ++ by ++ unfold C ++ ring_nf ++ ++ simp only [sub_neg_eq_add] at Z ++ simp only [← S, ge_iff_le] ++ linear_combination (|π|⁻¹ * 2⁻¹ * Z) ++ ++lemma LogDerivZetaBoundedAndHolo : ∃ A C : ℝ, 0 < C ∧ A ∈ Ioc 0 (1 / 2) ∧ LogDerivZetaHasBound A C ++ ∧ ∀ (T : ℝ) (_ : 3 ≤ T), ++ HolomorphicOn (fun (s : ℂ) ↦ ζ' s / (ζ s)) ++ (( (Icc ((1 : ℝ) - A / Real.log T ^ 1) 2) ×ℂ (Icc (-T) T) ) \ {1}) := by ++ ++ obtain ⟨A₁, A₁_in, C, C_pos, zeta_bnd2⟩ := LogDerivZetaBndUnif2 ++ obtain ⟨A₂, A₂_in, holo⟩ := LogDerivZetaHolcLargeT' ++ refine ⟨min A₁ A₂, C, C_pos, ?_, ?_, ?_⟩ ++ · exact ⟨lt_min A₁_in.1 A₂_in.1, le_trans (min_le_left _ _) A₁_in.2⟩ ++ · ++ intro σ t ht hσ ++ have hσ' : σ ∈ Ici (1 - A₁ / Real.log |t| ^ 1) := by ++ ++ have hAle : min A₁ A₂ ≤ A₁ := min_le_left _ _ ++ have hlogpos : 0 < Real.log |t| := by ++ ++ exact Real.log_pos (lt_trans (by norm_num) ht) ++ have := sub_le_sub_left ++ (div_le_div_of_nonneg_right (show min A₁ A₂ ≤ A₁ from hAle) (le_of_lt hlogpos)) 1 ++ ++ have hthr : 1 - A₁ / Real.log |t| ^ 1 ≤ 1 - (min A₁ A₂) / Real.log |t| ^ 1 := by ++ simpa [pow_one] using this ++ ++ have : σ ∈ Ici (1 - (min A₁ A₂) / Real.log |t| ^ 1) := by ++ simpa [pow_one] using hσ ++ exact le_trans hthr (mem_Ici.mp this) ++ ++ have hmain := zeta_bnd2 σ t ht (by simpa [pow_one] using hσ') ++ have hlog_ge_one : (1 : ℝ) ≤ Real.log |t| := by ++ ++ have hpos : 0 < |t| := lt_trans (by norm_num) ht ++ have hle : Real.exp 1 ≤ |t| := by ++ have : Real.exp 1 ≤ 3 := le_of_lt (lt_trans Real.exp_one_lt_d9 (by norm_num)) ++ exact this.trans (le_of_lt ht) ++ have := Real.log_le_log (Real.exp_pos 1) hle ++ simpa [Real.log_exp] using this ++ have hpow : Real.log |t| ^ (2 : ℕ) ≤ Real.log |t| ^ (9 : ℕ) := by ++ exact pow_le_pow_right₀ hlog_ge_one (by decide : (2 : ℕ) ≤ 9) ++ ++ have : C * Real.log |t| ^ (2 : ℕ) ≤ C * Real.log |t| ^ (9 : ℕ) := ++ mul_le_mul_of_nonneg_left hpow (le_of_lt C_pos) ++ exact (le_trans hmain this) ++ · ++ intro T hT ++ ++ have hsubset : ++ ((Icc ((1 : ℝ) - min A₁ A₂ / Real.log T ^ 1) 2) ×ℂ (Icc (-T) T) \ {1}) ⊆ ++ ((Icc ((1 : ℝ) - A₂ / Real.log T ^ 1) 2) ×ℂ (Icc (-T) T) \ {1}) := by ++ intro s hs ++ rcases hs with ⟨hs_box, hs_ne⟩ ++ rcases hs_box with ⟨hre, him⟩ ++ rcases hre with ⟨hre_left, hre_right⟩ ++ ++ constructor ++ · ++ constructor ++ · ++ constructor ++ · ++ have hAle : min A₁ A₂ ≤ A₂ := min_le_right _ _ ++ have hlogpos : 0 < Real.log T := by ++ have hT' : 1 < T := by linarith ++ exact Real.log_pos hT' ++ have := sub_le_sub_left ++ (div_le_div_of_nonneg_right hAle (le_of_lt hlogpos)) 1 ++ have hthr : 1 - A₂ / Real.log T ^ 1 ≤ 1 - (min A₁ A₂) / Real.log T ^ 1 := by ++ simpa [pow_one] using this ++ exact le_trans hthr hre_left ++ · exact hre_right ++ · exact him ++ · exact hs_ne ++ exact (holo T hT).mono hsubset ++ ++lemma MellinOfSmooth1cExplicit {ν : ℝ → ℝ} (diffν : ContDiff ℝ 1 ν) ++ (suppν : ν.support ⊆ Icc (1 / 2) 2) ++ (mass_one : ∫ x in Ioi 0, ν x / x = 1) : ++ ∃ ε₀ c : ℝ, 0 < ε₀ ∧ 0 < c ∧ ++ ∀ ε ∈ Ioo 0 ε₀, ‖𝓜 ((Smooth1 ν ε) ·) 1 - 1‖ ≤ c * ε := by ++ have := MellinOfSmooth1c diffν suppν mass_one ++ rw [Asymptotics.isBigO_iff'] at this ++ rcases this with ⟨c, cpos, hc⟩ ++ unfold Filter.Eventually at hc ++ rw [mem_nhdsGT_iff_exists_Ioo_subset] at hc ++ rcases hc with ⟨ε₀, ε₀pos, h⟩ ++ refine ⟨ε₀, c, ε₀pos, cpos, fun ε hε ↦ ?_⟩ ++ specialize h hε ++ rw [mem_ofPred_eq, id_eq, norm_of_nonneg hε.1.le] at h ++ exact h ++ ++open _root_.Filter Topology ++ ++theorem Strong_PNT : ∃ c > 0, ++ (ψ - id) =O[atTop] ++ fun (x : ℝ) ↦ x * Real.exp (-c * (Real.log x) ^ ((1 : ℝ) / 2)) := by ++ have ⟨ν, ContDiffν, ν_nonneg', ν_supp, ν_massOne'⟩ := SmoothExistence ++ have ContDiff1ν : ContDiff ℝ 1 ν := by ++ exact ContDiffν.of_le (by simp) ++ have ν_nonneg : ∀ x > 0, 0 ≤ ν x := fun x _ ↦ ν_nonneg' x ++ have ν_massOne : ∫ x in Ioi 0, ν x / x = 1 := by ++ rwa [← integral_Ici_eq_integral_Ioi] ++ clear ContDiffν ν_nonneg' ν_massOne' ++ obtain ⟨c_close, c_close_pos, h_close⟩ := ++ SmoothedChebyshevClose ContDiff1ν ν_supp ν_nonneg ν_massOne ++ obtain ⟨ε_main, C_main, ε_main_pos, C_main_pos, h_main⟩ := MellinOfSmooth1cExplicit ContDiff1ν ν_supp ν_massOne ++ obtain ⟨A, C_bnd, C_bnd_pos, A_in_Ioc, zeta_bnd, holo1⟩ := LogDerivZetaBoundedAndHolo ++ obtain ⟨σ₂', σ₂'_lt_one, holo2'⟩ := LogDerivZetaHolcSmallT ++ let σ₂ : ℝ := max σ₂' (1 / 2) ++ have σ₂_pos : 0 < σ₂ := by bound ++ have σ₂_lt_one : σ₂ < 1 := by bound ++ have holo2 : HolomorphicOn (fun s ↦ ζ' s / ζ s) (uIcc σ₂ 2 ×ℂ uIcc (-3) 3 \ {1}) := by ++ apply holo2'.mono ++ intro s hs ++ simp [mem_reProdIm] at hs ⊢ ++ refine ⟨?_, hs.2⟩ ++ refine ⟨?_, hs.1.2⟩ ++ rcases hs.1.1 with ⟨left, right⟩ ++ constructor ++ · apply le_trans _ left ++ apply min_le_min_right ++ apply le_max_left ++ · rw [max_eq_right (by linarith)] at right ⊢ ++ exact right ++ ++ clear holo2' σ₂'_lt_one ++ ++ obtain ⟨c₁, c₁pos, hc₁⟩ := I1Bound ν_supp ContDiff1ν ν_nonneg ν_massOne ++ obtain ⟨c₂, c₂pos, hc₂⟩ := I2Bound ν_supp ContDiff1ν zeta_bnd C_bnd_pos A_in_Ioc ++ obtain ⟨c₃, c₃pos, hc₃⟩ := I3Bound ν_supp ContDiff1ν zeta_bnd C_bnd_pos A_in_Ioc ++ obtain ⟨c₅, c₅pos, hc₅⟩ := I5Bound ν_supp ContDiff1ν holo2 ⟨σ₂_pos, σ₂_lt_one⟩ ++ obtain ⟨c₇, c₇pos, hc₇⟩ := I7Bound ν_supp ContDiff1ν zeta_bnd C_bnd_pos A_in_Ioc ++ obtain ⟨c₈, c₈pos, hc₈⟩ := I8Bound ν_supp ContDiff1ν zeta_bnd C_bnd_pos A_in_Ioc ++ obtain ⟨c₉, c₉pos, hc₉⟩ := I9Bound ν_supp ContDiff1ν ν_nonneg ν_massOne ++ ++ obtain ⟨c₄, c₄pos, Tlb₄, Tlb₄bnd, hc₄⟩ := I4Bound ν_supp ContDiff1ν ++ holo2 ⟨σ₂_pos, σ₂_lt_one⟩ A_in_Ioc ++ ++ obtain ⟨c₆, c₆pos, Tlb₆, Tlb₆bnd, hc₆⟩ := I6Bound ν_supp ContDiff1ν ++ holo2 ⟨σ₂_pos, σ₂_lt_one⟩ A_in_Ioc ++ ++ let C' := c_close + C_main ++ let C'' := c₁ + c₂ + c₈ + c₉ ++ let C''' := c₃ + c₄ + c₆ + c₇ ++ ++ let c : ℝ := A ^ ((1 : ℝ) / 2) / 4 ++ have cpos : 0 < c := by ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, gt_iff_lt, mem_Ioo, and_imp, ++ mem_Ioc, lt_sup_iff, ++ inv_pos, Nat.ofNat_pos, or_true, sup_lt_iff, neg_le_self_iff, Nat.ofNat_nonneg, uIcc_of_le, ++ div_pos_iff_of_pos_right, σ₂, c] ++ obtain ⟨left, right⟩ := A_in_Ioc ++ positivity ++ refine ⟨c, cpos, ?_⟩ ++ rw [Asymptotics.isBigO_iff] ++ let C : ℝ := C' + C'' + C''' + c₅ ++ refine ⟨C, ?_⟩ ++ ++ let c_εx : ℝ := A ^ ((1 : ℝ) / 2) / 2 ++ have c_εx_pos : 0 < c_εx := by ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, gt_iff_lt, mem_Ioo, and_imp, ++ mem_Ioc, lt_sup_iff, ++ inv_pos, Nat.ofNat_pos, or_true, sup_lt_iff, neg_le_self_iff, Nat.ofNat_nonneg, uIcc_of_le, ++ div_pos_iff_of_pos_right, σ₂, c, c_εx] ++ let c_Tx : ℝ := A ^ ((1 : ℝ) / 2) ++ have c_Tx_pos : 0 < c_Tx := by ++ simp_all only [one_div, support_subset_iff, ne_eq, mem_Icc, gt_iff_lt, mem_Ioo, and_imp, ++ mem_Ioc, lt_sup_iff, ++ inv_pos, Nat.ofNat_pos, or_true, sup_lt_iff, neg_le_self_iff, Nat.ofNat_nonneg, uIcc_of_le, ++ div_pos_iff_of_pos_right, σ₂, c, c_εx, c_Tx] ++ ++ let εx := (fun x ↦ Real.exp (-c_εx * (Real.log x) ^ ((1 : ℝ) / 2))) ++ let Tx := (fun x ↦ Real.exp (c_Tx * (Real.log x) ^ ((1 : ℝ) / 2))) ++ ++ have coeff_to_zero {B : ℝ} (B_le : B < 1) : ++ Tendsto (fun x ↦ Real.log x ^ (B - 1)) atTop (𝓝 0) := by ++ have B_minus_1_neg : B - 1 < 0 := by linarith ++ rw [← Real.zero_rpow (ne_of_lt B_minus_1_neg)] ++ rw [zero_rpow (ne_of_lt B_minus_1_neg)] ++ have one_minus_B_pos : 0 < 1 - B := by linarith ++ rw [show B - 1 = -(1 - B) by ring] ++ have : ∀ᶠ (x : ℝ) in atTop, Real.log x ^ (-(1 - B)) = (Real.log x ^ ((1 - B)))⁻¹ := by ++ filter_upwards [eventually_ge_atTop (1 : ℝ)] with x hx ++ apply Real.rpow_neg ++ exact Real.log_nonneg hx ++ rw [tendsto_congr' this] ++ apply tendsto_inv_atTop_zero.comp ++ apply (tendsto_rpow_atTop one_minus_B_pos).comp ++ exact tendsto_log_atTop ++ ++ have log_sub_log_pow_inf (c : ℝ) {B : ℝ} (B_le : B < 1) : ++ Tendsto (fun (x : ℝ) ↦ Real.log x - c * Real.log x ^ B) atTop atTop := by ++ have factor_form : ∀ x > 1, Real.log x - c * Real.log x ^ B = ++ Real.log x * (1 - c * Real.log x ^ (B - 1)) := by ++ intro x hx ++ ring_nf ++ congr! 1 ++ rw [mul_assoc, mul_comm (Real.log x), mul_assoc] ++ congr! 1 ++ have log_pos : 0 < Real.log x := Real.log_pos hx ++ rw [(by simp : Real.log x ^ (-1 + B) * Real.log x = ++ Real.log x ^ (-1 + B) * (Real.log x) ^ (1 : ℝ))] ++ rw [← Real.rpow_add log_pos] ++ ring_nf ++ have B_minus_1_neg : B - 1 < 0 := by linarith ++ have coeff_to_one : Tendsto (fun x ↦ 1 - c * Real.log x ^ (B - 1)) atTop (𝓝 1) := by ++ specialize coeff_to_zero B_le ++ apply Tendsto.const_mul c at coeff_to_zero ++ convert (tendsto_const_nhds (x := (1 : ℝ)) (f := (atTop : Filter ℝ))).sub coeff_to_zero ++ ring ++ ++ have eventually_pos : ∀ᶠ x in atTop, 0 < 1 - c * Real.log x ^ (B - 1) := by ++ apply (tendsto_order.mp coeff_to_one).1 ++ norm_num ++ ++ have eventually_factored : ∀ᶠ x in atTop, Real.log x - c * Real.log x ^ B = ++ Real.log x * (1 - c * Real.log x ^ (B - 1)) := by ++ filter_upwards [eventually_gt_atTop (1 : ℝ)] with x hx ++ exact factor_form x hx ++ ++ rw [tendsto_congr' eventually_factored] ++ apply Tendsto.atTop_mul_pos (by norm_num : (0 : ℝ) < 1) tendsto_log_atTop coeff_to_one ++ ++ have x_εx_eq (c B : ℝ) : ∀ᶠ (x : ℝ) in atTop, x * rexp (-c * Real.log x ^ B) = ++ rexp (Real.log x - c * Real.log x ^ B) := by ++ filter_upwards [eventually_gt_atTop 0] with x hx_pos ++ conv => ++ enter [1, 1] ++ rw [(Real.exp_log hx_pos).symm] ++ rw [← Real.exp_add] ++ ring_nf ++ ++ have x_ε_to_inf (c : ℝ) {B : ℝ} (B_le : B < 1) : Tendsto ++ (fun x ↦ x * Real.exp (-c * (Real.log x) ^ B)) atTop atTop := by ++ rw [tendsto_congr' (x_εx_eq c B)] ++ exact tendsto_exp_atTop.comp (log_sub_log_pow_inf c B_le) ++ ++ have Tx_to_inf : Tendsto Tx atTop atTop := by ++ unfold Tx ++ apply tendsto_exp_atTop.comp ++ apply Tendsto.pos_mul_atTop c_Tx_pos tendsto_const_nhds ++ exact (tendsto_rpow_atTop (by norm_num : 0 < (1 : ℝ) / 2)).comp Real.tendsto_log_atTop ++ ++ have ex_to_zero : Tendsto εx atTop (𝓝 0) := by ++ unfold εx ++ apply Real.tendsto_exp_atBot.comp ++ have this (x : ℝ) : -c_εx * Real.log x ^ ((1 : ℝ) / 2) = -(c_εx * Real.log x ^ ((1 : ℝ) / 2)) := by ++ ring ++ simp_rw [this] ++ rw [tendsto_neg_atBot_iff] ++ apply Tendsto.const_mul_atTop c_εx_pos ++ apply (tendsto_rpow_atTop (by norm_num)).comp ++ exact tendsto_log_atTop ++ ++ have eventually_εx_lt_one : ∀ᶠ (x : ℝ) in atTop, εx x < 1 := by ++ apply (tendsto_order.mp ex_to_zero).2 ++ norm_num ++ ++ have eventually_2_lt : ∀ᶠ (x : ℝ) in atTop, 2 < x * εx x := by ++ have := x_ε_to_inf c_εx (by norm_num : (1 : ℝ) / 2 < 1) ++ exact this.eventually_gt_atTop 2 ++ ++ have eventually_T_gt_3 : ∀ᶠ (x : ℝ) in atTop, 3 < Tx x := by ++ exact Tx_to_inf.eventually_gt_atTop 3 ++ ++ have eventually_T_gt_Tlb₄ : ∀ᶠ (x : ℝ) in atTop, Tlb₄ < Tx x := by ++ exact Tx_to_inf.eventually_gt_atTop _ ++ have eventually_T_gt_Tlb₆ : ∀ᶠ (x : ℝ) in atTop, Tlb₆ < Tx x := by ++ exact Tx_to_inf.eventually_gt_atTop _ ++ ++ have eventually_σ₂_lt_σ₁ : ∀ᶠ (x : ℝ) in atTop, σ₂ < 1 - A / (Real.log (Tx x)) := by ++ ++ apply (tendsto_order.mp ?_).1 ++ · exact σ₂_lt_one ++ have := tendsto_inv_atTop_zero.comp ((tendsto_rpow_atTop (by norm_num : (0 : ℝ) < 1)).comp ++ (tendsto_log_atTop.comp Tx_to_inf)) ++ have := Tendsto.const_mul (b := A) this ++ convert (tendsto_const_nhds (x := (1 : ℝ))).sub this using 2 ++ · simp [Function.comp, div_eq_mul_inv] ++ · simp ++ ++ have eventually_ε_lt_ε_main : ∀ᶠ (x : ℝ) in atTop, εx x < ε_main := by ++ apply (tendsto_order.mp ex_to_zero).2 ++ assumption ++ ++ have event_logX_ge : ∀ᶠ (x : ℝ) in atTop, 1 ≤ Real.log x := by ++ apply Real.tendsto_log_atTop.eventually_ge_atTop ++ ++ have event_1_aux_1 {const1 const2 : ℝ} (const1pos : 0 < const1) (const2pos : 0 < const2) : ++ ∀ᶠ (x : ℝ) in atTop, ++ rexp (-const1 * Real.log x ^ const2) * Real.log x ≤ ++ rexp 0 := by ++ have := ((isLittleO_log_rpow_atTop const2pos).bound const1pos) ++ have : ∀ᶠ (x : ℝ) in atTop, Real.log (Real.log x) ≤ ++ const1 * (Real.log x) ^ const2 := by ++ have := tendsto_log_atTop.eventually this ++ filter_upwards [this, eventually_gt_atTop 100] with x hx x_gt ++ convert hx using 1 ++ · rw [Real.norm_of_nonneg] ++ apply Real.log_nonneg ++ have : (1 : ℝ) = Real.log (rexp 1) := by ++ exact Eq.symm (Real.log_exp 1) ++ ++ rw [this] ++ apply Real.log_le_log ++ · exact Real.exp_pos _ ++ · have := Real.exp_one_lt_d9 ++ ++ linarith ++ · congr! 1 ++ rw [Real.norm_of_nonneg] ++ apply Real.rpow_nonneg ++ apply Real.log_nonneg ++ linarith ++ have loglogx : ∀ᶠ (x : ℝ) in atTop, ++ Real.log x = rexp (Real.log (Real.log x)) := by ++ filter_upwards [eventually_gt_atTop 3] with x hx ++ rw [Real.exp_log] ++ apply Real.log_pos ++ linarith ++ filter_upwards [loglogx, this] with x loglogx hx ++ conv => ++ enter [1, 2] ++ rw [loglogx] ++ rw [← Real.exp_add] ++ apply Real.exp_monotone ++ grw [hx] ++ simp ++ ++ have event_1_aux {const1 const1' const2 : ℝ} (const1bnds : const1' < const1) ++ (const2pos : 0 < const2) : ++ ∀ᶠ (x : ℝ) in atTop, ++ rexp (-const1 * Real.log x ^ const2) * Real.log x ≤ ++ rexp (-const1' * Real.log x ^ const2) := by ++ have : 0 < const1 - const1' := by linarith ++ filter_upwards [event_1_aux_1 this const2pos] with x hx ++ have : rexp (-const1 * Real.log x ^ const2) * Real.log x ++ = rexp (-(const1') * Real.log x ^ const2) ++ * rexp (-(const1 - const1') * Real.log x ^ const2) * Real.log x := by ++ congr! 1 ++ rw [← Real.exp_add] ++ congr! 1 ++ ring ++ rw [this] ++ rw [mul_assoc] ++ grw [hx] ++ simp ++ ++ have event_1 : ∀ᶠ (x : ℝ) in atTop, C' * (εx x) * x * Real.log x ≤ ++ C' * x * rexp (-c * Real.log x ^ ((1 : ℝ) / 2)) := by ++ unfold c εx c_εx ++ have : 0 < (A ^ ((1 : ℝ) / 2) / 4) := by ++ positivity ++ have const1bnd : (A ^ ((1 : ℝ) / 2) / 4) < (A ^ ((1 : ℝ) / 2) / 2) := by ++ linarith ++ have const2bnd : (0 : ℝ) < 1 / 2 := by norm_num ++ have this (x : ℝ) : ++ C' * rexp (-(A ^ ((1 : ℝ) / 2) / 2) * Real.log x ^ ((1 : ℝ) / 2)) * x * Real.log x = ++ C' * x * (rexp (-(A ^ ((1 : ℝ) / 2) / 2) * Real.log x ^ ((1 : ℝ) / 2)) * Real.log x) := by ring ++ simp_rw [this] ++ filter_upwards [event_1_aux const1bnd const2bnd, eventually_gt_atTop 3] with x x_bnd x_gt ++ grw [x_bnd] ++ ++ have event_2 : ∀ᶠ (x : ℝ) in atTop, C'' * x * Real.log x / (εx x * Tx x) ≤ ++ C'' * x * rexp (-c * Real.log x ^ ((1 : ℝ) / 2)) := by ++ unfold c εx c_εx Tx c_Tx ++ set const2 : ℝ := 1 / 2 ++ have const2bnd : 0 < const2 := by norm_num ++ set const1 := (A ^ const2 / 2) ++ set const1' := (A ^ const2 / 4) ++ have : 0 < A ^ const2 := by ++ unfold const2 ++ ++ apply Real.rpow_pos_of_pos ++ exact A_in_Ioc.1 ++ have this (x : ℝ) : -(-const1 * Real.log x ^ const2 + A ^ const2 * Real.log x ^ const2) = ++ -(A ^ const2 - const1) * Real.log x ^ const2 := by ring ++ simp_rw [← Real.exp_add, div_eq_mul_inv, ← Real.exp_neg, this] ++ have const1bnd : const1' < (A ^ const2 - const1) := by ++ unfold const1' const1 ++ linarith ++ filter_upwards [event_1_aux const1bnd const2bnd, eventually_gt_atTop 3] with x x_bnd x_gt ++ rw [mul_assoc] ++ conv => ++ enter [1, 2] ++ rw [mul_comm] ++ grw [x_bnd] ++ ++ have event_3_aux {const1 const1' const2 : ℝ} (const2_eq : const2 = 1 / 2) ++ (const1_eq : const1 = (A ^ const2 / 2)) (const1'_eq : const1' = (A ^ const2 / 4)) : ++ ∀ᶠ (x : ℝ) in atTop, ++ x ^ (-A / Real.log (rexp (A ^ const2 * Real.log x ^ const2)) ^ (1 : ℝ)) * ++ rexp (-(-const1 * Real.log x ^ const2)) ≤ ++ rexp (-const1' * Real.log x ^ const2) := by ++ have : ∀ᶠ (x : ℝ) in atTop, x = rexp (Real.log x) := by ++ filter_upwards [eventually_gt_atTop 0] with x hx ++ rw [Real.exp_log hx] ++ filter_upwards [this, eventually_gt_atTop 3] with x hx x_gt_3 ++ have logxpos : 0 < Real.log x := by apply Real.log_pos; linarith ++ conv => ++ enter [1, 1, 1] ++ rw [hx] ++ rw [← Real.exp_mul] ++ rw [Real.log_exp] ++ rw [Real.mul_rpow] ++ · have {y : ℝ} (ypos : 0 < y) : y / (y ^ const2) ^ (1 : ℝ) = y ^ const2 := by ++ rw [← Real.rpow_mul ypos.le] ++ rw [div_eq_mul_inv] ++ rw [← Real.rpow_neg ypos.le] ++ conv => ++ enter [1, 1] ++ rw [← Real.rpow_one y] ++ rw [← Real.rpow_add ypos] ++ rw [(by linarith : 1 + -(const2 * 1) = const2)] ++ rw [div_mul_eq_div_div] ++ rw [neg_div] ++ rw [this (A_in_Ioc.1)] ++ ++ rw [mul_div] ++ conv => ++ enter [1, 1, 1, 1] ++ rw [mul_comm] ++ rw [← mul_div] ++ ++ rw [this (y := Real.log x) logxpos] ++ ++ rw [← Real.exp_add] ++ apply Real.exp_monotone ++ ++ have : -A ^ const2 * Real.log x ^ const2 + -(-const1 * Real.log x ^ const2) ++ = (-(A ^ const2 - const1) * Real.log x ^ const2) := by ring ++ rw [this] ++ ++ gcongr ++ ++ rw [const1'_eq, const1_eq] ++ have : 0 ≤ A ^ const2 := by ++ apply Real.rpow_nonneg A_in_Ioc.1.le ++ linarith ++ · rw [const2_eq] ++ rw [←Real.sqrt_eq_rpow] ++ apply Real.sqrt_nonneg ++ ++ · apply Real.rpow_nonneg ++ apply Real.log_nonneg ++ linarith ++ ++ have event_3 : ∀ᶠ (x : ℝ) in atTop, C''' * x * x ^ (-A / Real.log (Tx x) ) / (εx x) ≤ ++ C''' * x * rexp (-c * Real.log x ^ ((1 : ℝ) / 2)) := by ++ unfold c Tx c_Tx εx c_εx ++ set const2 : ℝ := 1 / 2 ++ have const2eq : const2 = 1 / 2 := by rfl ++ have const2bnd : 0 < const2 := by norm_num ++ set const1 := (A ^ const2 / 2) ++ have const1eq : const1 = (A ^ const2 / 2) := by rfl ++ set const1' := (A ^ const2 / 4) ++ have const1'eq : const1' = (A ^ const2 / 4) := by rfl ++ have A_pow_pos : 0 < A ^ const2 := by ++ unfold const2 ++ apply Real.rpow_pos_of_pos ++ exact A_in_Ioc.1 ++ ++ conv => ++ enter [1, x, 1] ++ rw [div_eq_mul_inv, ← Real.exp_neg] ++ ++ filter_upwards [event_3_aux const2eq const1eq const1'eq, ++ eventually_gt_atTop 3] with x x_bnd x_gt ++ ++ have this (x : ℝ) : C''' * x * x ^ (-A / Real.log (rexp (A ^ const2 * Real.log x ^ const2))) ++ * rexp (-(-const1 * Real.log x ^ const2)) ++ = C''' * x * (x ^ (-A / Real.log (rexp (A ^ const2 * Real.log x ^ const2))) ++ * rexp (-(-const1 * Real.log x ^ const2))) := by ++ ring ++ rw [this] ++ rw [rpow_one] at x_bnd ++ grw [x_bnd] ++ ++ have event_4_aux4 {pow2 : ℝ} (pow2_neg : pow2 < 0) {c : ℝ} (cpos : 0 < c) (c' : ℝ) : ++ Tendsto (fun x ↦ c' * Real.log x ^ pow2) atTop (𝓝 0) := by ++ rw [← mul_zero c'] ++ apply Tendsto.const_mul ++ have := tendsto_rpow_neg_atTop (y := -pow2) (by linarith) ++ rw [neg_neg] at this ++ apply this.comp ++ exact Real.tendsto_log_atTop ++ ++ have event_4_aux3 {pow2 : ℝ} (pow2_neg : pow2 < 0) {c : ℝ} (cpos : 0 < c) (c' : ℝ) : ++ ∀ᶠ (x : ℝ) in atTop, c' * (Real.log x) ^ pow2 < c := by ++ apply (event_4_aux4 pow2_neg cpos c').eventually_lt_const ++ exact cpos ++ ++ have event_4_aux2 {c1 : ℝ} (c1pos : 0 < c1) (c2 : ℝ) {pow1 : ℝ} (pow1_lt : pow1 < 1) : ++ ∀ᶠ (x : ℝ) in atTop, 0 ≤ Real.log x * (c1 - c2 * (Real.log x) ^ (pow1 - 1)) := by ++ filter_upwards [eventually_gt_atTop 3 , event_4_aux3 (by linarith : pow1 - 1 < 0) ++ (by linarith : 0 < c1 / 2) c2] with x x_gt hx ++ have : 0 ≤ Real.log x := by ++ apply Real.log_nonneg ++ linarith ++ apply mul_nonneg this ++ linarith ++ ++ have event_4_aux1 {const1 : ℝ} (const1_lt : const1 < 1) (const2 const3 : ℝ) ++ {pow1 : ℝ} (pow1_lt : pow1 < 1) : ∀ᶠ (x : ℝ) in atTop, ++ const1 * Real.log x + const2 * Real.log x ^ pow1 ++ ≤ Real.log x - const3 * Real.log x ^ pow1 := by ++ filter_upwards [event_4_aux2 (by linarith : 0 < 1 - const1) (const2 + const3) pow1_lt, ++ eventually_gt_atTop 3] with x hx x_gt ++ rw [← sub_nonneg] ++ have : ++ Real.log x - const3 * Real.log x ^ pow1 - (const1 * Real.log x + const2 * Real.log x ^ pow1) ++ = (1 - const1) * Real.log x - (const2 + const3) * Real.log x ^ pow1 := by ring ++ rw [this] ++ convert hx using 1 ++ ring_nf ++ congr! 1 ++ have : Real.log x * const2 * Real.log x ^ (-1 + pow1) ++ = const2 * Real.log x ^ pow1 := by ++ rw [mul_assoc, mul_comm, mul_assoc] ++ congr! 1 ++ conv => ++ enter [1, 2] ++ rw [← Real.rpow_one (Real.log x)] ++ rw [← Real.rpow_add (Real.log_pos (by linarith))] ++ ring_nf ++ rw [this] ++ have : Real.log x * const3 * Real.log x ^ (-1 + pow1) ++ = const3 * Real.log x ^ pow1 := by ++ rw [mul_assoc, mul_comm, mul_assoc] ++ congr! 1 ++ conv => ++ enter [1, 2] ++ rw [← Real.rpow_one (Real.log x)] ++ rw [← Real.rpow_add (Real.log_pos (by linarith))] ++ ring_nf ++ rw [this] ++ ++ have event_4_aux : ∀ᶠ (x : ℝ) in atTop, ++ c₅ * rexp (σ₂ * Real.log x + (A ^ ((1 : ℝ) / 2) / 2) * Real.log x ^ ((1 : ℝ) / 2)) ≤ ++ c₅ * rexp (Real.log x - (A ^ ((1 : ℝ) / 2) / 4) * Real.log x ^ ((1 : ℝ) / 2)) := by ++ filter_upwards [eventually_gt_atTop 3, event_4_aux1 σ₂_lt_one (A ^ ((1 : ℝ) / 2) / 2) ++ (A ^ ((1 : ℝ) / 2) / 4) (by norm_num : (1 : ℝ) / 2 < 1)] with x x_gt hx ++ rw [mul_le_mul_iff_right₀ c₅pos] ++ apply Real.exp_monotone ++ convert hx ++ ++ have event_4 : ∀ᶠ (x : ℝ) in atTop, c₅ * x ^ σ₂ / (εx x) ≤ ++ c₅ * x * rexp (-c * Real.log x ^ ((1 : ℝ) / 2)) := by ++ unfold εx c_εx c ++ filter_upwards [event_4_aux, eventually_gt_atTop 0] with x hx xpos ++ convert hx using 1 ++ · rw [← mul_div] ++ congr! 1 ++ rw [div_eq_mul_inv, ← Real.exp_neg] ++ conv => ++ enter [1, 1, 1] ++ rw [← Real.exp_log xpos] ++ rw [← exp_mul, ← Real.exp_add] ++ ring_nf ++ ++ · rw [mul_assoc] ++ congr! 1 ++ conv => ++ enter [1, 1] ++ rw [← Real.exp_log xpos] ++ rw [← Real.exp_add] ++ ring_nf ++ ++ filter_upwards [eventually_gt_atTop 3, eventually_εx_lt_one, eventually_2_lt, ++ eventually_T_gt_3, eventually_T_gt_Tlb₄, eventually_T_gt_Tlb₆, ++ eventually_σ₂_lt_σ₁, eventually_ε_lt_ε_main, event_logX_ge, event_1, event_2, ++ event_3, event_4] with X X_gt_3 ε_lt_one ε_X T_gt_3 T_gt_Tlb₄ T_gt_Tlb₆ ++ σ₂_lt_σ₁ ε_lt_ε_main logX_ge event_1 event_2 event_3 event_4 ++ ++ clear eventually_εx_lt_one eventually_2_lt eventually_T_gt_3 eventually_T_gt_Tlb₄ ++ eventually_T_gt_Tlb₆ eventually_σ₂_lt_σ₁ eventually_ε_lt_ε_main event_logX_ge zeta_bnd ++ ++ let ε : ℝ := εx X ++ have ε_pos : 0 < ε := by positivity ++ specialize h_close X X_gt_3 ε ε_pos ε_lt_one ε_X ++ let ψ_ε_of_X := SmoothedChebyshev ν ε X ++ ++ let T : ℝ := Tx X ++ specialize holo1 T T_gt_3.le ++ let σ₁ : ℝ := 1 - A / (Real.log T) ++ have σ₁pos : 0 < σ₁ := by calc ++ 1 - A / (Real.log T) >= 1 - (1/2) / 1 := by ++ gcongr ++ · exact A_in_Ioc.2 ++ · apply (Real.le_log_iff_exp_le (by positivity)).mpr ++ linarith[Real.exp_one_lt_d9] ++ _ > 0 := by norm_num ++ have σ₁_lt_one : σ₁ < 1 := by ++ apply sub_lt_self ++ apply div_pos A_in_Ioc.1 ++ bound ++ ++ rw [uIcc_of_le (by linarith), uIcc_of_le (by linarith)] at holo2 ++ ++ have holo1_compat : HolomorphicOn (ζ' / ζ) (Icc σ₁ 2 ×ℂ Icc (-T) T \ {1}) := by ++ ++ simpa [σ₁, pow_one] using! holo1 ++ ++ have holo2a : HolomorphicOn (SmoothedChebyshevIntegrand ν ε X) ++ (Icc σ₂ 2 ×ℂ Icc (-3) 3 \ {1}) := by ++ apply DifferentiableOn.mul ++ · apply DifferentiableOn.mul ++ · rw [(by ext; ring : (fun s ↦ -ζ' s / ζ s) = (fun s ↦ -(ζ' s / ζ s)))] ++ apply DifferentiableOn.neg holo2 ++ · intro s hs ++ apply DifferentiableAt.differentiableWithinAt ++ apply Smooth1MellinDifferentiable ContDiff1ν ν_supp ⟨ε_pos, ε_lt_one⟩ ν_nonneg ν_massOne ++ linarith[mem_reProdIm.mp hs.1 |>.1.1] ++ · intro s hs ++ apply DifferentiableAt.differentiableWithinAt ++ apply DifferentiableAt.const_cpow (by fun_prop) ++ left ++ norm_cast ++ linarith ++ have ψ_ε_diff : ‖ψ_ε_of_X - 𝓜 ((Smooth1 ν ε) ·) 1 * X‖ ≤ ‖I₁ ν ε X T‖ + ‖I₂ ν ε T X σ₁‖ ++ + ‖I₃ ν ε T X σ₁‖ + ‖I₄ ν ε X σ₁ σ₂‖ + ‖I₅ ν ε X σ₂‖ + ‖I₆ ν ε X σ₁ σ₂‖ + ‖I₇ ν ε T X σ₁‖ ++ + ‖I₈ ν ε T X σ₁‖ + ‖I₉ ν ε X T‖ := by ++ unfold ψ_ε_of_X ++ rw [SmoothedChebyshevPull1 ε_pos ε_lt_one X X_gt_3 (T := T) (by linarith) ++ σ₁pos σ₁_lt_one holo1_compat ν_supp ν_nonneg ν_massOne ContDiff1ν] ++ rw [SmoothedChebyshevPull2 ε_pos ε_lt_one X X_gt_3 (T := T) (by linarith) ++ σ₂_pos σ₁_lt_one σ₂_lt_σ₁ holo1_compat holo2a ν_supp ν_nonneg ν_massOne ContDiff1ν] ++ ring_nf ++ iterate 5 ++ apply le_trans (by apply norm_add_le) ++ gcongr ++ exact (norm_sub_le _ _).trans ++ (add_le_add ((norm_add_le _ _).trans ++ (add_le_add (norm_sub_le _ _) le_rfl)) le_rfl) ++ ++ specialize h_main ε ⟨ε_pos, ε_lt_ε_main⟩ ++ have main : ‖𝓜 ((Smooth1 ν ε) ·) 1 * X - X‖ ≤ C_main * ε * X := by ++ nth_rewrite 2 [← one_mul X] ++ push_cast ++ rw [← sub_mul, norm_mul] ++ gcongr ++ rw [norm_real, norm_of_nonneg (by linarith)] ++ specialize hc₁ ε ε_pos ε_lt_one X X_gt_3 T_gt_3 ++ specialize hc₂ X X_gt_3 ε_pos ε_lt_one T_gt_3 ++ specialize hc₃ X X_gt_3 ε_pos ε_lt_one T_gt_3 ++ specialize hc₅ X X_gt_3 ε_pos ε_lt_one ++ specialize hc₇ X X_gt_3 ε_pos ε_lt_one T_gt_3 ++ specialize hc₈ X X_gt_3 ε_pos ε_lt_one T_gt_3 ++ specialize hc₉ ε_pos ε_lt_one X X_gt_3 T_gt_3 ++ specialize hc₄ X X_gt_3 ε_pos ε_lt_one T_gt_Tlb₄ ++ specialize hc₆ X X_gt_3 ε_pos ε_lt_one T_gt_Tlb₆ ++ ++ clear ν_nonneg ν_massOne ContDiff1ν ν_supp holo2 ++ ++ have C'bnd : c_close * ε * X * Real.log X + C_main * ε * X ≤ C' * ε * X * Real.log X := by ++ have : C_main * ε * X * 1 ≤ C_main * ε * X * Real.log X := by ++ gcongr ++ linarith ++ ++ have C''bnd : c₁ * X * Real.log X / (ε * T) + c₂ * X / (ε * T) + c₈ * X / (ε * T) ++ + c₉ * X * Real.log X / (ε * T) ≤ C'' * X * Real.log X / (ε * T) := by ++ unfold C'' ++ rw [(by ring : (c₁ + c₂ + c₈ + c₉) * X * Real.log X / (ε * T) ++ = c₁ * X * Real.log X / (ε * T) + c₂ * X * Real.log X / (ε * T) ++ + c₈ * X * Real.log X / (ε * T) + c₉ * X * Real.log X / (ε * T))] ++ have : c₂ * X / (ε * T) * 1 ≤ c₂ * X / (ε * T) * Real.log X := by ++ gcongr ++ have : c₂ * X / (ε * T) ≤ c₂ * X * Real.log X / (ε * T) := by ++ ring_nf at this ⊢ ++ linarith ++ grw [this] ++ have : c₈ * X / (ε * T) * 1 ≤ c₈ * X / (ε * T) * Real.log X := by ++ gcongr ++ have : c₈ * X / (ε * T) ≤ c₈ * X * Real.log X / (ε * T) := by ++ ring_nf at this ⊢ ++ linarith ++ grw [this] ++ ++ have C'''bnd : c₃ * X * X ^ (-A / Real.log T) / ε ++ + c₄ * X * X ^ (-A / Real.log T) / ε ++ + c₆ * X * X ^ (-A / Real.log T) / ε ++ + c₇ * X * X ^ (-A / Real.log T) / ε ++ ≤ C''' * X * X ^ (-A / Real.log T) / ε := by ++ apply le_of_eq ++ ring ++ ++ calc ++ _ = ‖(ψ X - ψ_ε_of_X) + (ψ_ε_of_X - X)‖ := by ring_nf; norm_cast ++ _ ≤ ‖ψ X - ψ_ε_of_X‖ + ‖ψ_ε_of_X - X‖ := norm_add_le _ _ ++ _ = ‖ψ X - ψ_ε_of_X‖ + ‖(ψ_ε_of_X - 𝓜 (fun x ↦ (Smooth1 ν ε x)) 1 * X) ++ + (𝓜 (fun x ↦ (Smooth1 ν ε x)) 1 * X - X)‖ := by ring_nf ++ _ ≤ ‖ψ X - ψ_ε_of_X‖ + ‖ψ_ε_of_X - 𝓜 (fun x ↦ (Smooth1 ν ε x)) 1 * X‖ ++ + ‖𝓜 (fun x ↦ (Smooth1 ν ε x)) 1 * X - X‖ := by ++ rw [add_assoc] ++ gcongr ++ apply norm_add_le ++ _ = ‖ψ X - ψ_ε_of_X‖ + ‖𝓜 (fun x ↦ (Smooth1 ν ε x)) 1 * X - X‖ ++ + ‖ψ_ε_of_X - 𝓜 (fun x ↦ (Smooth1 ν ε x)) 1 * X‖ := by ring ++ _ ≤ ‖ψ X - ψ_ε_of_X‖ + ‖𝓜 (fun x ↦ (Smooth1 ν ε x)) 1 * X - X‖ ++ + (‖I₁ ν ε X T‖ + ‖I₂ ν ε T X σ₁‖ + ‖I₃ ν ε T X σ₁‖ + ‖I₄ ν ε X σ₁ σ₂‖ ++ + ‖I₅ ν ε X σ₂‖ + ‖I₆ ν ε X σ₁ σ₂‖ + ‖I₇ ν ε T X σ₁‖ + ‖I₈ ν ε T X σ₁‖ ++ + ‖I₉ ν ε X T‖) := by gcongr ++ _ ≤ c_close * ε * X * Real.log X + C_main * ε * X ++ + (c₁ * X * Real.log X / (ε * T) + c₂ * X / (ε * T) ++ + c₃ * X * X ^ (-A / Real.log T) / ε ++ + c₄ * X * X ^ (-A / Real.log T) / ε ++ + c₅ * X ^ σ₂ / ε ++ + c₆ * X * X ^ (-A / Real.log T) / ε ++ + c₇ * X * X ^ (-A / Real.log T) / ε ++ + c₈ * X / (ε * T) ++ + c₉ * X * Real.log X / (ε * T)) := by ++ gcongr ++ convert! h_close using 1 ++ rw [← norm_neg] ++ congr ++ ring ++ ++ change ‖I₂ ν ε (Tx X) X σ₁‖ ≤ c₂ * X / (ε * (Tx X)) ++ dsimp at hc₂ ++ dsimp [σ₁] ++ ++ unfold sigma1Of at hc₂ ++ ++ exact hc₂ ++ ++ _ = (c_close * ε * X * Real.log X + C_main * ε * X) ++ + ((c₁ * X * Real.log X / (ε * T) + c₂ * X / (ε * T) ++ + c₈ * X / (ε * T) ++ + c₉ * X * Real.log X / (ε * T)) ++ + (c₃ * X * X ^ (-A / Real.log T) / ε ++ + c₄ * X * X ^ (-A / Real.log T) / ε ++ + c₆ * X * X ^ (-A / Real.log T) / ε ++ + c₇ * X * X ^ (-A / Real.log T) / ε) ++ + c₅ * X ^ σ₂ / ε ++ ) := by ring ++ _ ≤ C' * ε * X * Real.log X ++ + (C'' * X * Real.log X / (ε * T) ++ + C''' * X * X ^ (-A / Real.log T) / ε ++ + c₅ * X ^ σ₂ / ε ++ ) := by ++ gcongr ++ _ = C' * ε * X * Real.log X ++ + C'' * X * Real.log X / (ε * T) ++ + C''' * X * X ^ (-A / Real.log T) / ε ++ + c₅ * X ^ σ₂ / ε ++ := by ring ++ _ ≤ C' * X * rexp (-c * Real.log X ^ ((1 : ℝ) / 2)) ++ + C'' * X * rexp (-c * Real.log X ^ ((1 : ℝ) / 2)) ++ + C''' * X * rexp (-c * Real.log X ^ ((1 : ℝ) / 2)) ++ + c₅ * X * rexp (-c * Real.log X ^ ((1 : ℝ) / 2)) ++ := by ++ gcongr ++ _ = C * X * rexp (-c * Real.log X ^ ((1 : ℝ) / 2)) ++ := by ring ++ _ = _ := by ++ rw [Real.norm_of_nonneg] ++ · rw [← mul_assoc] ++ · positivity ++ ++end Erdos970 +diff --git a/StrongPNT/Erdos970/Z0.lean b/StrongPNT/Erdos970/Z0.lean +new file mode 100644 +index 0000000..093671d +--- /dev/null ++++ b/StrongPNT/Erdos970/Z0.lean +@@ -0,0 +1,60 @@ ++import PrimeNumberTheoremAnd.Erdos970.ZetaBounds ++import StrongPNT.Erdos970.PNT3_RiemannZeta ++ ++namespace Erdos970 ++ ++open _root_.Complex Topology Filter Interval _root_.Set Asymptotics ++ ++local notation (name := riemannzeta1) "ζ" => riemannZeta ++local notation (name := derivriemannzeta1) "ζ'" => deriv riemannZeta ++ ++lemma Z0bound_aux : ++ Asymptotics.IsBigO (nhdsWithin 0 (Set.Ioi 0)) (fun (delta : ℝ) => -(ζ' / ζ) ((1 : ℂ) + delta) - (1 / (delta : ℂ))) (fun _ => (1 : ℂ)) := by ++ ++ let F := fun s : ℂ => -(ζ' / ζ) s - (s - 1)⁻¹ ++ ++ have h_F_bigO : F =O[𝓝[≠] 1] (1 : ℂ → ℂ) := by ++ have h_fun_eq : F = (-ζ' / ζ - fun z ↦ (z - 1)⁻¹) := by ++ ext s ++ simp only [F, Pi.sub_apply, Pi.neg_apply, Pi.div_apply, neg_div] ++ rw [h_fun_eq] ++ exact riemannZetaLogDerivResidueBigO ++ ++ let u := fun (delta : ℝ) => (1 : ℂ) + delta ++ have h_tendsto : Tendsto u (nhdsWithin 0 (Set.Ioi 0)) (𝓝[≠] 1) := by ++ ++ apply tendsto_inf.mpr ++ constructor ++ · ++ have h_cont : Continuous u := continuous_const.add continuous_ofReal ++ ++ have h_tendsto_nhds : Tendsto u (𝓝 0) (𝓝 (u 0)) := h_cont.continuousAt.tendsto ++ ++ simp only [u, Complex.ofReal_zero, add_zero] at h_tendsto_nhds ++ ++ exact h_tendsto_nhds.mono_left nhdsWithin_le_nhds ++ · ++ ++ simp ++ ++ filter_upwards [self_mem_nhdsWithin] with delta h_delta_pos ++ simp only [u] ++ ++ refine add_ne_left.mpr ?_ ++ rw [Complex.ofReal_ne_zero] ++ exact ne_of_gt h_delta_pos ++ ++ have h_comp := h_F_bigO.comp_tendsto h_tendsto ++ ++ convert h_comp using 1 ++ ext delta ++ ++ simp only [F, u, Function.comp_apply, Pi.div_apply] ++ rw [inv_eq_one_div] ++ aesop ++ all_goals rfl ++ ++lemma Z0bound : ++ Asymptotics.IsBigO (nhdsWithin 0 (Set.Ioi 0)) (fun (delta : ℝ) => -logDerivZeta ((1 : ℂ) + delta) - (1 / (delta : ℂ))) (fun _ => (1 : ℂ)) := Z0bound_aux ++ ++end Erdos970 +diff --git a/StrongPNT/Erdos970/ZetaZeroFree.lean b/StrongPNT/Erdos970/ZetaZeroFree.lean +new file mode 100644 +index 0000000..10f11b5 +--- /dev/null ++++ b/StrongPNT/Erdos970/ZetaZeroFree.lean +@@ -0,0 +1,240 @@ ++import StrongPNT.Erdos970.PNT4_ZeroFreeRegion ++import Mathlib.Analysis.Calculus.ContDiff.Defs ++import Mathlib.Analysis.Asymptotics.Defs ++import Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic ++import Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus ++import Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts ++import Mathlib.Analysis.Calculus.Deriv.Basic ++import Mathlib.NumberTheory.LSeries.RiemannZeta ++import Mathlib.Algebra.Group.Basic ++import PrimeNumberTheoremAnd.Erdos970.ResidueCalcOnRectangles ++import PrimeNumberTheoremAnd.Erdos970.MellinCalculus ++import Mathlib.MeasureTheory.Function.Floor ++import Mathlib.Analysis.Complex.CauchyIntegral ++import Mathlib.NumberTheory.Harmonic.Bounds ++import Mathlib.MeasureTheory.Order.Group.Lattice ++import PrimeNumberTheoremAnd.Erdos970.Mathlib.Analysis.SpecialFunctions.Log.Basic ++import Mathlib.Tactic.Bound ++import Mathlib.NumberTheory.LSeries.PrimesInAP ++import Mathlib.Tactic.FunProp ++import PrimeNumberTheoremAnd.Erdos970.Fourier ++import PrimeNumberTheoremAnd.Erdos970.ZetaBounds ++ ++namespace Erdos970 ++ ++open _root_.Complex Topology _root_.Filter Interval _root_.Set Asymptotics ++local notation (name := riemannzeta') "ζ" => riemannZeta ++local notation (name := derivriemannzeta') "ζ'" => deriv riemannZeta ++ ++local notation "I" => Complex.I ++ ++lemma ZetaNoZerosOn1Line' (t : ℝ) : ζ (1 + t * I) ≠ 0 := by ++ refine riemannZeta_ne_zero_of_one_le_re ?_ ++ simp ++ ++lemma ZetaCont' : ContinuousOn ζ (univ \ {1}) := by ++ apply continuousOn_of_forall_continuousAt (fun x hx ↦ ?_) ++ apply DifferentiableAt.continuousAt (𝕜 := ℂ) ++ convert differentiableAt_riemannZeta ?_ ++ simp only [Set.mem_sdiff, mem_univ, mem_singleton_iff, true_and] at hx ++ exact hx ++ ++lemma ZetaNoZerosInBox' (T : ℝ) : ++ ∃ (σ : ℝ) (_ : σ < 1), ∀ (t : ℝ) (_ : |t| ≤ T) ++ (σ' : ℝ) (_ : σ' ≥ σ), ζ (σ' + t * I) ≠ 0 := by ++ by_contra h ++ push Not at h ++ ++ have hn (n : ℕ) := h (σ := 1 - 1 / (n + 1)) (sub_lt_self _ (by positivity)) ++ ++ have : ∃ (tn : ℕ → ℝ) (σn : ℕ → ℝ), (∀ n, σn n ≤ 1) ∧ ++ (∀ n, (1 : ℝ) - 1 / (n + 1) ≤ σn n) ∧ (∀ n, |tn n| ≤ T) ∧ ++ (∀ n, ζ (σn n + tn n * I) = 0) := by ++ choose t ht σ' hσ' hζ using hn ++ refine ⟨t, σ', ?_, hσ', ht, hζ⟩ ++ intro n ++ by_contra hσn ++ push Not at hσn ++ have := riemannZeta_ne_zero_of_one_lt_re (s := σ' n + t n * I) ++ simp only [add_re, ofReal_re, mul_re, I_re, mul_zero, ofReal_im, I_im, mul_one, sub_self, ++ add_zero, ne_eq] at this ++ exact this hσn (hζ n) ++ ++ choose t σ' hσ'_le hσ'_ge ht hζ using this ++ ++ have σTo1 : Filter.Tendsto σ' Filter.atTop (𝓝 1) := by ++ have hlow : Tendsto (fun n : ℕ => (1 : ℝ) - 1 / (n + 1)) atTop (𝓝 1) := by ++ simpa using! (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_sub 1 ++ exact tendsto_of_tendsto_of_tendsto_of_le_of_le hlow tendsto_const_nhds hσ'_ge hσ'_le ++ ++ have : ∃ (t₀ : ℝ) (subseq : ℕ → ℕ), ++ Filter.Tendsto (t ∘ subseq) Filter.atTop (𝓝 t₀) ∧ ++ Filter.Tendsto subseq Filter.atTop Filter.atTop := by ++ refine (isCompact_Icc.isSeqCompact fun and => abs_le.1 (ht and)).imp fun and ⟨x, A, B, _⟩ => ?_ ++ use A, by valid, B.tendsto_atTop ++ ++ obtain ⟨t₀, subseq, tTendsto, subseqTendsto⟩ := this ++ ++ have σTo1 : Filter.Tendsto (σ' ∘ subseq) Filter.atTop (𝓝 1) := ++ σTo1.comp subseqTendsto ++ ++ have (n : ℕ) : ζ (σ' (subseq n) + I * (t (subseq n))) = 0 := by ++ convert hζ (subseq n) using 3 ++ ring ++ ++ have ToOneT0 : Filter.Tendsto (fun n ↦ (σ' (subseq n) : ℂ) + Complex.I * (t (subseq n))) Filter.atTop ++ (𝓝[≠]((1 : ℂ) + I * t₀)) := by ++ simp_rw [tendsto_nhdsWithin_iff, Function.comp_def] at tTendsto ⊢ ++ constructor ++ · exact (σTo1.ofReal.add (tTendsto.ofReal.const_mul _)).trans (by simp) ++ · filter_upwards with n ++ apply ne_of_apply_ne ζ ++ rw [this] ++ apply Ne.symm ++ apply riemannZeta_ne_zero_of_one_le_re ++ simp only [add_re, one_re, mul_re, I_re, ofReal_re, zero_mul, I_im, ofReal_im, mul_zero, ++ sub_self, add_zero, le_refl] ++ ++ by_cases ht₀ : t₀ = 0 ++ · have ZetaBlowsUp : ∀ᶠ s in 𝓝[≠](1 : ℂ), ‖ζ s‖ ≥ 1 := by ++ have hprod : Tendsto (fun s : ℂ => ‖(s - 1) * ζ s‖) (𝓝[≠] 1) (𝓝 1) := by ++ simpa only [norm_one] using! riemannZeta_residue_one.norm ++ have hid : Tendsto (fun s : ℂ => s) (𝓝[≠] 1) (𝓝 1) := ++ tendsto_id.mono_left nhdsWithin_le_nhds ++ have hdist : Tendsto (fun s : ℂ => ‖s - 1‖) (𝓝[≠] 1) (𝓝 0) := by ++ simpa only [sub_self, norm_zero] using! (hid.sub_const 1).norm ++ filter_upwards [hprod.eventually_const_lt (by norm_num : (1 / 2 : ℝ) < 1), ++ hdist.eventually_lt_const (by norm_num : (0 : ℝ) < 1 / 2)] with s hp hs ++ by_contra h ++ have hlt : ‖ζ s‖ < 1 := lt_of_not_ge h ++ have hm := mul_le_mul_of_nonneg_left hlt.le (norm_nonneg (s - 1)) ++ rw [norm_mul] at hp ++ rw [mul_one] at hm ++ linarith ++ ++ have ZetaNonZ : ∀ᶠ s in 𝓝[≠](1 : ℂ), ζ s ≠ 0 := by ++ filter_upwards [ZetaBlowsUp] ++ intro s hs hfalse ++ rw [hfalse] at hs ++ simp only [norm_zero, ge_iff_le] at hs ++ linarith ++ ++ rw [ht₀] at ToOneT0 ++ simp only [ofReal_zero, mul_zero, add_zero] at ToOneT0 ++ rcases (ToOneT0.eventually ZetaNonZ).exists with ⟨n, hn⟩ ++ exact hn (this n) ++ ++ · have zetaIsZero : ζ (1 + Complex.I * t₀) = 0 := by ++ have hpoint : (1 + Complex.I * t₀ : ℂ) ≠ 1 := by ++ intro heq ++ have him := congrArg Complex.im heq ++ have htzero : t₀ = 0 := by simpa using him ++ exact ht₀ htzero ++ have hcont := (differentiableAt_riemannZeta hpoint).continuousAt ++ have hlim : Tendsto (fun n : ℕ => ζ (σ' (subseq n) + I * t (subseq n))) atTop ++ (𝓝 (ζ (1 + I * t₀))) := by ++ simpa only [Function.comp_def] using! ++ hcont.tendsto.comp (ToOneT0.mono_right nhdsWithin_le_nhds) ++ have hfun : (fun n : ℕ => ζ (σ' (subseq n) + I * t (subseq n))) = (fun _ => 0) := ++ funext this ++ rw [hfun] at hlim ++ exact tendsto_nhds_unique hlim tendsto_const_nhds ++ ++ exact riemannZeta_ne_zero_of_one_le_re (s := 1 + I * t₀) (by simp) zetaIsZero ++ ++lemma LogDerivZetaHoloOn' {S : Set ℂ} (s_ne_one : 1 ∉ S) ++ (nonzero : ∀ s ∈ S, ζ s ≠ 0) : ++ HolomorphicOn (fun s ↦ ζ' s / ζ s) S := by ++ apply DifferentiableOn.div _ _ nonzero <;> intro s hs <;> apply DifferentiableAt.differentiableWithinAt ++ · apply differentiableAt_deriv_riemannZeta ++ exact ne_of_mem_of_not_mem hs s_ne_one ++ · apply differentiableAt_riemannZeta ++ exact ne_of_mem_of_not_mem hs s_ne_one ++ ++theorem LogDerivZetaHolcSmallT' : ++ ∃ (σ₂ : ℝ) (_ : σ₂ < 1), HolomorphicOn (fun (s : ℂ) ↦ ζ' s / (ζ s)) ++ (( [[ σ₂, 2 ]] ×ℂ [[ -3, 3 ]]) \ {1}) := by ++ obtain ⟨σ₂, hσ₂_lt_one, hζ_ne_zero⟩ := ZetaNoZerosInBox 3 ++ refine ⟨σ₂, hσ₂_lt_one, ?_⟩ ++ let U := ([[σ₂, 2]] ×ℂ [[-3, 3]]) \ {1} ++ have s_in_U_im_le3 : ∀ s ∈ U, |s.im| ≤ 3 := by ++ intro s hs ++ rw [mem_sdiff_singleton] at hs ++ rcases hs with ⟨hbox, _hne⟩ ++ rcases hbox with ⟨hre, him⟩ ++ simp only [Set.mem_preimage] at him ++ obtain ⟨him_lower, him_upper⟩ := him ++ apply abs_le.2 ++ simp at him_lower ++ simp at him_upper ++ constructor ++ · exact him_lower ++ · exact him_upper ++ ++ have s_in_U_re_ges2 : ∀ s ∈ U, σ₂ ≤ s.re := by ++ intro s hs ++ rw [mem_sdiff_singleton] at hs ++ rcases hs with ⟨hbox, _hne⟩ ++ rcases hbox with ⟨hre, _him⟩ ++ simp only [Set.mem_preimage] at hre ++ obtain ⟨hre_lower, hre_upper⟩ := hre ++ have : min σ₂ 2 = σ₂ := by ++ apply min_eq_left ++ linarith [hσ₂_lt_one] ++ rw[this] at hre_lower ++ exact hre_lower ++ ++ apply LogDerivZetaHoloOn ++ · exact notMem_sdiff_of_mem rfl ++ · intro s hs ++ rw[← re_add_im s] ++ apply hζ_ne_zero ++ apply s_in_U_im_le3 _ hs ++ apply s_in_U_re_ges2 _ hs ++ ++theorem LogDerivZetaHolcLargeT' : ++ ∃ (A : ℝ) (_ : A ∈ Ioc 0 (1 / 2)), ∀ (T : ℝ) (_ : 3 ≤ T), ++ HolomorphicOn (fun (s : ℂ) ↦ ζ' s / (ζ s)) ++ (( (Icc ((1 : ℝ) - A / Real.log T ^ 1) 2) ×ℂ (Icc (-T) T) ) \ {1}) := by ++ obtain ⟨A, A_inter, restOfZetaZeroFree⟩ := ZetaZeroFree_p ++ obtain ⟨σ₁, σ₁_lt_one, noZerosInBox⟩ := ZetaNoZerosInBox' 3 ++ let A₀ := min A ((1 - σ₁) * Real.log 3 ^ 1) ++ refine ⟨A₀, ?_, ?_⟩ ++ · constructor ++ · apply lt_min A_inter.1 ++ bound ++ · exact le_trans (min_le_left _ _) A_inter.2 ++ intro T hT ++ apply LogDerivZetaHoloOn ++ · exact notMem_sdiff_of_mem rfl ++ intro s hs ++ rcases le_or_gt 1 s.re with one_le|lt_one ++ · exact riemannZeta_ne_zero_of_one_le_re one_le ++ rw [← re_add_im s] ++ have := Complex.mem_reProdIm.mp hs.1 ++ rcases lt_or_ge 3 |s.im| with gt3|le3 ++ · apply restOfZetaZeroFree _ _ gt3 ++ refine ⟨?_, lt_one⟩ ++ calc ++ _ ≤ 1 - A₀ / Real.log T ^ 1 := by ++ gcongr ++ · exact A_inter.1.le ++ · bound ++ · bound ++ · bound ++ · exact abs_le.mpr ⟨this.2.1, this.2.2⟩ ++ _ ≤ _:= by exact this.1.1 ++ ++ · apply noZerosInBox _ le3 ++ calc ++ _ ≥ 1 - A₀ / Real.log T ^ 1 := by exact this.1.1 ++ _ ≥ 1 - A₀ / Real.log 3 ^ 1 := by ++ gcongr ++ apply le_min A_inter.1.le ++ bound ++ _ ≥ 1 - (((1 - σ₁) * Real.log 3 ^ 1)) / Real.log 3 ^ 1:= by ++ gcongr ++ apply min_le_right ++ _ = _ := by field_simp; ring ++ ++end Erdos970 +diff --git a/lakefile.toml b/lakefile.toml +index 3bf8290..2fecc18 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -1,16 +1,6 @@ +- +-name = "StrongPNT" +-version = "0.1.0" +-defaultTargets = ["StrongPNT"] +- +-[leanOptions] +-pp.unicode.fun = true +-autoImplicit = false +-relaxedAutoImplicit = false +-linter.unusedVariables = false +- +-[[lean_lib]] + name = "StrongPNT" ++version = "0.1.0" ++defaultTargets = ["StrongPNTErdos970"] + + [[require]] + name = "mathlib" +@@ -30,3 +20,8 @@ git = "https://github.com/PatrickMassot/checkdecls.git" + name = "«doc-gen4»" + git = "https://github.com/leanprover/doc-gen4" + rev = "v4.21.0" ++ ++[[lean_lib]] ++name = "StrongPNTErdos970" ++roots = ["StrongPNT.Erdos970"] ++globs = ["StrongPNT.Erdos970.*"] +diff --git a/lean-toolchain b/lean-toolchain +index 980709b..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.21.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/Zeta3Irrational-lean4341.patch b/lean/patches/Zeta3Irrational-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..9ba38ea93de4d1ac245b874b7e7d776d63cdb54e --- /dev/null +++ b/lean/patches/Zeta3Irrational-lean4341.patch @@ -0,0 +1,3240 @@ +diff --git a/Zeta3Irrational.lean b/Zeta3Irrational.lean +index c779005..5298524 100644 +--- a/Zeta3Irrational.lean ++++ b/Zeta3Irrational.lean +@@ -1,7 +1,8 @@ + import Zeta3Irrational.Basic + import Zeta3Irrational.Bound +-import Zeta3Irrational.Equality + import Zeta3Irrational.Integral + import Zeta3Irrational.LegendrePoly + import Zeta3Irrational.LinearForm + import Zeta3Irrational.d ++import Zeta3Irrational.Equality ++import Zeta3Irrational.PrimeCounting +diff --git a/Zeta3Irrational/Basic.lean b/Zeta3Irrational/Basic.lean +index 3583719..8014ec5 100644 +--- a/Zeta3Irrational/Basic.lean ++++ b/Zeta3Irrational/Basic.lean +@@ -2,42 +2,49 @@ + A formal proof of the irrationality of Riemann-Zeta(3). + Author: Junqi Liu and Jujian Zhang. + -/ +-import Mathlib.Data.Int.Star + import Mathlib.NumberTheory.LSeries.HurwitzZetaValues +-import Mathlib.Order.CompletePartialOrder +-import Mathlib.RingTheory.DedekindDomain.Dvr +-import PrimeNumberTheoremAnd.Consequences ++import Zeta3Irrational.PrimeCounting + import Zeta3Irrational.Bound + import Zeta3Irrational.LegendrePoly + import Zeta3Irrational.LinearForm + ++/-! # Apéry's irrationality proof for ζ(3) ++ ++Port of the Apache-2.0 source by Junqi Liu and Jujian Zhang. ++-/ ++ + open scoped Nat + open BigOperators Polynomial + ++/-- The logarithmic double integral weighted by two real shifted Legendre polynomials. -/ + noncomputable abbrev JJ (n : ℕ) : ℝ := + ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- (-(x.1 * x.2).log / (1 - x.1 * x.2) * (shiftedLegendre n).eval x.1 * (shiftedLegendre n).eval x.2) ++ (-(x.1 * x.2).log / (1 - x.1 * x.2) * (aperyShiftedLegendre n).eval x.1 * ++ (aperyShiftedLegendre n).eval x.2) + ++/-- The equivalent positive triple integral in the Apéry identity. -/ + noncomputable abbrev JJ' (n : ℕ) : ℝ := + ∫ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + (x.2.1 * (1 - x.2.1) * x.2.2 * (1 - x.2.2) * x.1 * (1 - x.1) / + (1 - (1 - x.2.1 * x.2.2) * x.1)) ^ n / (1 - (1 - x.2.1 * x.2.2) * x.1) + ++/-- The nonnegative extended-real integral of the positive Apéry integrand. -/ + noncomputable abbrev JJENN (n : ℕ) : ENNReal := + ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ENNReal.ofReal + ((x.2.1 * (1 - x.2.1) * x.2.2 * (1 - x.2.2) * x.1 * (1 - x.1) / + (1 - (1 - x.2.1 * x.2.2) * x.1)) ^ n / (1 - (1 - x.2.1 * x.2.2) * x.1)) + ++/-- The Apéry double integral multiplied by the cube of the least common multiple. -/ + noncomputable abbrev fun1 (n : ℕ) : ℝ := (d (Finset.Icc 1 n)) ^ 3 * JJ n + + theorem linear_int (n : ℕ) : ∃ a b : ℕ → ℤ, + fun1 n = a n + b n * (d (Finset.Icc 1 n) : ℤ) ^ 3 * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 := by + delta fun1 JJ + obtain ⟨c, hc⟩ := shiftedLegendre_eq_int_poly n +- simp_rw [hc, Polynomial.eval_finset_sum, mul_assoc, Finset.sum_mul_sum, Finset.mul_sum] +- simp only [zsmul_eq_mul, eval_mul, eval_intCast, eval_pow, eval_X] ++ simp_rw [hc, Polynomial.eval_finsetSum, mul_assoc, Finset.sum_mul_sum, Finset.mul_sum] ++ simp only [eval_mul, eval_intCast, eval_pow, eval_X] + simp_rw [← mul_assoc, multi_integral_sum_comm, multi_integral_mul_const] +- simp only [← Finset.sum_neg_distrib, Finset.mul_sum] ++ simp only [Finset.mul_sum] + obtain ⟨qq', ⟨pp', hqq'⟩⟩ := linear_int_aux + use fun n => ∑ x ∈ Finset.range (n + 1), ∑ i ∈ Finset.range (n + 1), + d (Finset.Icc 1 n) ^ 3 * c x * c i * qq' x i / d (Finset.Icc 1 (Nat.max x i)) ^ 3 +@@ -70,10 +77,10 @@ theorem linear_int (n : ℕ) : ∃ a b : ℕ → ℤ, + simp only [ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, IsIntegrallyClosed.pow_dvd_pow_iff] + norm_cast + apply d_dvd_d_of_le +- simp_all only [zsmul_eq_mul, Finset.mem_range, Finset.le_eq_subset] ++ simp_all only [Finset.mem_range] + intro a b + simp_all only [Finset.mem_Icc, true_and] +- simp only [one_div, le_max_iff] at b ++ simp only [le_max_iff] at b + rcases b with ⟨_ ,(c | c)⟩ + <;> + linarith +@@ -83,7 +90,8 @@ theorem linear_int (n : ℕ) : ∃ a b : ℕ → ℤ, + simp + · ring + +-lemma pos_aux (x : ℝ × ℝ × ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ (0 < x.2.1 ∧ x.2.1 < 1) ∧ 0 < x.2.2 ∧ x.2.2 < 1) : ++lemma pos_aux (x : ℝ × ℝ × ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ (0 < x.2.1 ∧ x.2.1 < 1) ∧ 0 < x.2.2 ∧ ++ x.2.2 < 1) : + 0 < (1 - (1 - x.2.1 * x.2.2) * x.1) := by + simp only [sub_pos] + suffices (1 - x.2.1 * x.2.2) * x.1 < x.1 by linarith +@@ -120,7 +128,8 @@ lemma JJENN_upper (n : ℕ) : JJENN n ≤ + apply bound' <;> linarith + · exact pos_aux x h + · simp only [h, ↓reduceIte, le_refl] +- _ = ENNReal.ofReal ((1 / 24) ^ n) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++ _ = ENNReal.ofReal ((1 / 24) ^ n) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ ++ Set.Ioo 0 1, + ENNReal.ofReal (1 / (1 - (1 - x.2.1 * x.2.2) * x.1)) := by + rw [← MeasureTheory.lintegral_const_mul] + · rw [← MeasureTheory.lintegral_indicator (by measurability), +@@ -139,8 +148,8 @@ lemma JJENN_upper (n : ℕ) : JJENN n ≤ + apply Measurable.mul _ measurable_fst + apply Measurable.const_sub + apply Measurable.mul +- apply Measurable.comp' measurable_fst measurable_snd +- apply Measurable.comp' measurable_snd measurable_snd ++ · exact measurable_fst.comp measurable_snd ++ · exact measurable_snd.comp measurable_snd + _ = ENNReal.ofReal (2 * (1 / 24) ^ n * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3) := by + have h := JENN_eq_triple 0 0 + simp only [pow_zero, mul_one] at h +@@ -151,40 +160,14 @@ lemma JJENN_upper (n : ℕ) : JJENN n ≤ + nth_rw 2 [mul_comm] + + lemma integrableOn_JJ' (n : ℕ) : MeasureTheory.Integrable (fun (x : ℝ × ℝ × ℝ) ↦ +- (x.2.1 * (1 - x.2.1) * x.2.2 * (1 - x.2.2) * x.1 * (1 - x.1) / (1 - (1 - x.2.1 * x.2.2) * x.1)) ^ n / +- (1 - (1 - x.2.1 * x.2.2) * x.1)) (MeasureTheory.volume.restrict (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1)) := by ++ (x.2.1 * (1 - x.2.1) * x.2.2 * (1 - x.2.2) * x.1 * (1 - x.1) / (1 - (1 - x.2.1 * x.2.2) * ++ x.1)) ^ n / ++ (1 - (1 - x.2.1 * x.2.2) * x.1)) (MeasureTheory.volume.restrict (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ++ ×ˢ Set.Ioo 0 1)) := by + rw [MeasureTheory.Integrable] + constructor +- · apply AEMeasurable.aestronglyMeasurable +- rw [← aemeasurable_indicator_iff (by measurability)] +- apply AEMeasurable.indicator _ (by measurability) +- apply AEMeasurable.div +- · apply AEMeasurable.pow_const +- apply AEMeasurable.div +- · apply AEMeasurable.mul _ (AEMeasurable.const_sub (AEMeasurable.fst (f := id) aemeasurable_id) _) +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.mul _ (AEMeasurable.const_sub (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) _) +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- apply AEMeasurable.mul _ (AEMeasurable.const_sub (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) _) +- exact (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) +- · apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- exact (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) +- · apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- exact (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) ++ · apply Measurable.aestronglyMeasurable ++ fun_prop + · rw [MeasureTheory.hasFiniteIntegral_iff_norm] + set k := _ + change k < ⊤ +@@ -196,16 +179,16 @@ lemma integrableOn_JJ' (n : ℕ) : MeasureTheory.Integrable (fun (x : ℝ × ℝ + ext x + rw [Set.indicator_apply, Set.indicator_apply] + by_cases hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 +- · simp only [hx, ↓reduceIte, norm_mul, norm_div, norm_neg, Real.norm_eq_abs, norm_pow] ++ · simp only [hx, ↓reduceIte, norm_mul, norm_div, Real.norm_eq_abs, norm_pow] + simp only [Set.mem_prod, Set.mem_Ioo] at hx + rw [ENNReal.ofReal_eq_ofReal_iff] + · congr 3 + · rw [abs_eq_self.2, abs_eq_self.2, abs_eq_self.2, abs_eq_self.2, abs_eq_self.2, + abs_eq_self.2] <;> nlinarith + · simp only [abs_eq_self, sub_nonneg] +- apply mul_le_one₀ (by nlinarith) (by linarith) (by linarith) ++ exact (mul_le_of_le_one_left (by linarith) (by nlinarith)).trans (by linarith) + · simp only [abs_eq_self, sub_nonneg] +- apply mul_le_one₀ (by nlinarith) (by linarith) (by linarith) ++ exact (mul_le_of_le_one_left (by linarith) (by nlinarith)).trans (by linarith) + · positivity + · apply div_nonneg + · apply pow_nonneg +@@ -223,13 +206,14 @@ lemma integrableOn_JJ' (n : ℕ) : MeasureTheory.Integrable (fun (x : ℝ × ℝ + simp only [one_div, inv_pow, ENNReal.ofReal_lt_top] + + lemma shiftedLegendre_bound (n : ℕ) (x : ℝ) (hx : 0 < x ∧ x < 1) : +- |eval x (shiftedLegendre n)| ≤ ∑ x_1 ∈ Finset.range (n + 1), (n.choose x_1 : ℝ) * ((n + x_1).choose n) := by +- simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, smul_eq_mul, eval_finset_sum, ++ |eval x (aperyShiftedLegendre n)| ≤ ∑ x_1 ∈ Finset.range (n + 1), (n.choose x_1 : ℝ) * ((n + ++ x_1).choose n) := by ++ simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, eval_finsetSum, + eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- have := Finset.abs_sum_le_sum_abs (f := fun y => (-1) ^ y * ↑(n.choose y) * ↑((n + y).choose n) * x ^ y) ++ have := Finset.abs_sum_le_sum_abs (f := fun y => (-1) ^ y * ↑(n.choose y) * ↑((n + y).choose ++ n) * x ^ y) + (s := Finset.range (n + 1)) +- trans +- apply this ++ refine this.trans ?_ + apply Finset.sum_le_sum + intro i _ + simp only [abs_mul, abs_pow, abs_neg, abs_one, one_pow, Nat.abs_cast, one_mul] +@@ -243,51 +227,24 @@ lemma shiftedLegendre_bound (n : ℕ) (x : ℝ) (hx : 0 < x ∧ x < 1) : + + lemma Measurable_one_div_aux : + Measurable fun (x : ℝ × ℝ × ℝ) ↦ ENNReal.ofReal (1 / (1 - (1 - x.2.1 * x.2.2) * x.1)) := by +- apply Measurable.ennreal_ofReal +- apply Measurable.const_div +- apply Measurable.const_sub +- apply Measurable.mul _ measurable_fst +- apply Measurable.const_sub +- apply Measurable.mul +- apply Measurable.comp' measurable_fst measurable_snd +- apply Measurable.comp' measurable_snd measurable_snd ++ fun_prop + + lemma integrableOn_JJ1 (n : ℕ) : MeasureTheory.Integrable +- (Function.uncurry fun z x ↦ eval x.1 (shiftedLegendre n) * eval x.2 (shiftedLegendre n) * (1 / (1 - (1 - x.1 * x.2) * z))) +- ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1))) := by +- rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod, MeasureTheory.Integrable] ++ (Function.uncurry fun z x ↦ eval x.1 (aperyShiftedLegendre n) * eval x.2 ++ (aperyShiftedLegendre n) * (1 / (1 - (1 - x.1 * x.2) * z))) ++ ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 ++ 1 ×ˢ Set.Ioo 0 1))) := by ++ rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod, ++ MeasureTheory.Integrable] + constructor +- · apply AEMeasurable.aestronglyMeasurable +- rw [← aemeasurable_indicator_iff (by measurability)] +- apply AEMeasurable.indicator _ (by measurability) +- simp_rw [mul_one_div] +- apply AEMeasurable.div +- · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, smul_eq_mul] +- apply AEMeasurable.mul +- · simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply Finset.aemeasurable_sum +- intro i _ +- apply AEMeasurable.const_mul +- apply AEMeasurable.pow_const (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) _) +- apply AEMeasurable.fst (f := id) aemeasurable_id +- · simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply Finset.aemeasurable_sum +- intro i _ +- apply AEMeasurable.const_mul +- apply AEMeasurable.pow_const (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) _) +- apply AEMeasurable.snd (f := id) aemeasurable_id +- · apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- exact (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) ++ · apply Measurable.aestronglyMeasurable ++ fun_prop + · rw [MeasureTheory.hasFiniteIntegral_iff_norm] + set k := _ + set C := ∑ x_1 ∈ Finset.range (n + 1), (n.choose x_1 : ℝ) * ((n + x_1).choose n) + change k < ⊤ +- have : k ≤ ENNReal.ofReal (C ^ 2) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++ have : k ≤ ENNReal.ofReal (C ^ 2) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ ++ Set.Ioo 0 1, + ENNReal.ofReal (1 / (1 - (1 - x.2.1 * x.2.2) * x.1)) := by + simp only [k] + rw [← MeasureTheory.lintegral_const_mul _ Measurable_one_div_aux] +@@ -323,46 +280,21 @@ lemma integrableOn_JJ1 (n : ℕ) : MeasureTheory.Integrable + · positivity + + lemma integrableOn_JJ2 (n : ℕ) : MeasureTheory.Integrable (Function.uncurry fun z x ↦ +- eval x.1 (shiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1)) +- ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1))) := by +- rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod, MeasureTheory.Integrable] ++ eval x.1 (aperyShiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * ++ x.2) * z) ^ (n + 1)) ++ ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 ++ 1 ×ˢ Set.Ioo 0 1))) := by ++ rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod, ++ MeasureTheory.Integrable] + constructor +- · apply AEMeasurable.aestronglyMeasurable +- rw [← aemeasurable_indicator_iff (by measurability)] +- apply AEMeasurable.indicator _ (by measurability) +- apply AEMeasurable.div +- · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, smul_eq_mul] +- apply AEMeasurable.mul +- · apply AEMeasurable.mul +- · simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply Finset.aemeasurable_sum +- intro i _ +- apply AEMeasurable.const_mul +- apply AEMeasurable.pow_const (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) _) +- apply AEMeasurable.fst (f := id) aemeasurable_id +- · apply AEMeasurable.pow_const +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- apply AEMeasurable.fst (f := id) aemeasurable_id +- · apply AEMeasurable.pow_const +- apply AEMeasurable.const_sub +- apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id) +- · apply AEMeasurable.pow_const +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- apply AEMeasurable.fst (f := id) aemeasurable_id ++ · apply Measurable.aestronglyMeasurable ++ fun_prop + · rw [MeasureTheory.hasFiniteIntegral_iff_norm] + set k := _ + set C := ∑ x_1 ∈ Finset.range (n + 1), (n.choose x_1 : ℝ) * ((n + x_1).choose n) + change k < ⊤ +- have : k ≤ ENNReal.ofReal (|C|) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++ have : k ≤ ENNReal.ofReal (|C|) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ ++ Set.Ioo 0 1, + ENNReal.ofReal (1 / (1 - (1 - x.2.1 * x.2.2) * x.1)) := by + simp only [k] + rw [← MeasureTheory.lintegral_const_mul _ Measurable_one_div_aux] +@@ -376,7 +308,8 @@ lemma integrableOn_JJ2 (n : ℕ) : MeasureTheory.Integrable (Function.uncurry fu + simp only [Set.mem_prod, Set.mem_Ioo] at hx + rw [← ENNReal.ofReal_mul] + · rw [ENNReal.ofReal_le_ofReal_iff] +- · rw [Function.uncurry_apply_pair, pow_add, ← div_div, abs_div,mul_one_div, div_le_div_iff₀] ++ · rw [Function.uncurry_apply_pair, pow_add, ← div_div, abs_div,mul_one_div, ++ div_le_div_iff₀] + · apply mul_le_mul _ _ (by linarith [pos_aux x hx]) (by positivity) + · rw [← mul_div, mul_assoc, abs_mul, ← mul_one (a := |C|)] + apply mul_le_mul _ _ (by positivity) (by positivity) +@@ -406,16 +339,10 @@ lemma integrableOn_JJ2 (n : ℕ) : MeasureTheory.Integrable (Function.uncurry fu + · linarith + · linarith + · exact ineq +- · rw [div_add_one] ++ · rw [div_add_one (by positivity)] + intro r + rw [_root_.div_eq_zero_iff] at r +- · refine ineq <| r.resolve_right ?_ +- apply mul_ne_zero +- · apply mul_ne_zero <;> linarith +- · linarith +- · apply mul_ne_zero +- · apply mul_ne_zero <;> linarith +- · linarith, abs_div] ++ exact ineq (r.resolve_right (by positivity)), abs_div] + trans |1 - z| + · apply div_le_self (abs_nonneg _) + rw [abs_of_nonneg, le_add_iff_nonneg_left] +@@ -446,46 +373,25 @@ lemma integrableOn_JJ2 (n : ℕ) : MeasureTheory.Integrable (Function.uncurry fu + have h := JENN_eq_triple 0 0 + simp only [pow_zero, mul_one] at h + rw [← h, J_ENN_rr, ← ENNReal.ofReal_mul] +- · simp ++ · finiteness + · positivity + + lemma integrableOn_JJ3 (n : ℕ) : MeasureTheory.Integrable +- (Function.uncurry fun z x ↦ eval x.1 (shiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z)) +- ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1))) := by +- rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod, MeasureTheory.Integrable] ++ (Function.uncurry fun z x ↦ eval x.1 (aperyShiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / ++ (1 - (1 - x.1 * x.2) * z)) ++ ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 ++ 1 ×ˢ Set.Ioo 0 1))) := by ++ rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod, ++ MeasureTheory.Integrable] + constructor +- · apply AEMeasurable.aestronglyMeasurable +- rw [← aemeasurable_indicator_iff (by measurability)] +- apply AEMeasurable.indicator _ (by measurability) +- apply AEMeasurable.div +- · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, smul_eq_mul] +- apply AEMeasurable.mul +- · apply AEMeasurable.mul +- · simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply Finset.aemeasurable_sum +- intro i _ +- apply AEMeasurable.const_mul +- apply AEMeasurable.pow_const (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) _) +- apply AEMeasurable.fst (f := id) aemeasurable_id +- · apply AEMeasurable.pow_const +- apply AEMeasurable.const_sub +- apply AEMeasurable.fst (f := id) aemeasurable_id +- · apply AEMeasurable.pow_const +- apply AEMeasurable.const_sub +- apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id) +- · apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- apply AEMeasurable.fst (f := id) aemeasurable_id ++ · apply Measurable.aestronglyMeasurable ++ fun_prop + · rw [MeasureTheory.hasFiniteIntegral_iff_norm] + set k := _ + set C := ∑ x_1 ∈ Finset.range (n + 1), (n.choose x_1 : ℝ) * ((n + x_1).choose n) + change k < ⊤ +- have : k ≤ ENNReal.ofReal (|C|) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++ have : k ≤ ENNReal.ofReal (|C|) * ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ ++ Set.Ioo 0 1, + ENNReal.ofReal (1 / (1 - (1 - x.2.1 * x.2.2) * x.1)) := by + simp only [k] + rw [← MeasureTheory.lintegral_const_mul _ Measurable_one_div_aux] +@@ -532,37 +438,78 @@ lemma integrableOn_JJ3 (n : ℕ) : MeasureTheory.Integrable + have h := JENN_eq_triple 0 0 + simp only [pow_zero, mul_one] at h + rw [← h, J_ENN_rr, ← ENNReal.ofReal_mul] +- · simp ++ · finiteness + · positivity + + lemma eq1_integrableOn_aux1 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : MeasureTheory.Integrable +- (fun x ↦ eval x.1 (shiftedLegendre n) * eval x.2 (shiftedLegendre n) * (1 / (1 - (1 - x.1 * x.2) * z))) +- ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 1))) := by ++ (fun x ↦ eval x.1 (aperyShiftedLegendre n) * eval x.2 (aperyShiftedLegendre n) * (1 / (1 - ++ (1 - x.1 * x.2) * z))) ++ ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo ++ 0 1))) := by + rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod] + apply MeasureTheory.IntegrableOn.integrable + apply MeasureTheory.IntegrableOn.mono_set (t := Set.Icc 0 1 ×ˢ Set.Icc 0 1) +- apply ContinuousOn.integrableOn_compact +- · simp only [Set.mem_Ioo, Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one,isCompact_Icc] +- · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, smul_eq_mul] +- apply ContinuousOn.mul +- · apply ContinuousOn.mul +- · simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply continuousOn_finset_sum +- intro i _ +- apply ContinuousOn.mul continuousOn_const +- apply ContinuousOn.pow continuousOn_fst +- · simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply continuousOn_finset_sum +- intro i _ +- apply ContinuousOn.mul continuousOn_const +- apply ContinuousOn.pow continuousOn_snd +- · apply ContinuousOn.div continuousOn_const +- · apply ContinuousOn.sub continuousOn_const ++ · apply ContinuousOn.integrableOn_compact ++ · simp only [Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one,isCompact_Icc] ++ · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one] ++ apply ContinuousOn.mul ++ · apply ContinuousOn.mul ++ · simp only [eval_finsetSum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] ++ apply continuousOn_finsetSum ++ intro i _ ++ apply ContinuousOn.mul continuousOn_const ++ apply ContinuousOn.pow continuousOn_fst ++ · simp only [eval_finsetSum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] ++ apply continuousOn_finsetSum ++ intro i _ ++ apply ContinuousOn.mul continuousOn_const ++ apply ContinuousOn.pow continuousOn_snd ++ · apply ContinuousOn.div continuousOn_const ++ · apply ContinuousOn.sub continuousOn_const ++ apply ContinuousOn.mul _ continuousOn_const ++ apply ContinuousOn.sub continuousOn_const ++ apply ContinuousOn.mul continuousOn_fst continuousOn_snd ++ · intro x hx ++ suffices 1 - (1 - x.1 * x.2) * z > 0 by linarith ++ simp only [Set.mem_prod, Set.mem_Icc] at hx ++ simp only [Set.mem_Ioo, gt_iff_lt, sub_pos] at hz ⊢ ++ suffices (1 - x.1 * x.2) * z ≤ z by linarith ++ apply mul_le_of_le_one_left (by linarith) ++ simp only [tsub_le_iff_right, le_add_iff_nonneg_right] ++ nlinarith ++ · apply Set.prod_mono Set.Ioo_subset_Icc_self Set.Ioo_subset_Icc_self ++ ++lemma eq1_integrableOn_aux2 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : MeasureTheory.Integrable ++ (fun x ↦ eval x.1 (aperyShiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 ++ - x.1 * x.2) * z) ^ (n + 1)) ++ ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo ++ 0 1))) := by ++ rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod] ++ apply MeasureTheory.IntegrableOn.integrable ++ apply MeasureTheory.IntegrableOn.mono_set (t := Set.Icc 0 1 ×ˢ Set.Icc 0 1) ++ · apply ContinuousOn.integrableOn_compact ++ · simp only [Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one,isCompact_Icc] ++ · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one] ++ apply ContinuousOn.div ++ · apply ContinuousOn.mul ++ · apply ContinuousOn.mul ++ · simp only [eval_finsetSum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] ++ apply continuousOn_finsetSum ++ intro i _ ++ apply ContinuousOn.mul continuousOn_const ++ apply ContinuousOn.pow continuousOn_fst ++ · apply ContinuousOn.pow ++ apply ContinuousOn.mul _ continuousOn_const ++ apply ContinuousOn.mul continuousOn_fst continuousOn_snd ++ · apply ContinuousOn.pow ++ apply ContinuousOn.sub continuousOn_const continuousOn_snd ++ · apply ContinuousOn.pow ++ apply ContinuousOn.sub continuousOn_const + apply ContinuousOn.mul _ continuousOn_const + apply ContinuousOn.sub continuousOn_const + apply ContinuousOn.mul continuousOn_fst continuousOn_snd + · intro x hx +- suffices 1 - (1 - x.1 * x.2) * z > 0 by linarith ++ suffices 1 - (1 - x.1 * x.2) * z > 0 by positivity + simp only [Set.mem_prod, Set.mem_Icc] at hx + simp only [Set.mem_Ioo, gt_iff_lt, sub_pos] at hz ⊢ + suffices (1 - x.1 * x.2) * z ≤ z by linarith +@@ -571,88 +518,62 @@ lemma eq1_integrableOn_aux1 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : Measu + nlinarith + · apply Set.prod_mono Set.Ioo_subset_Icc_self Set.Ioo_subset_Icc_self + +-lemma eq1_integrableOn_aux2 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : MeasureTheory.Integrable +- (fun x ↦ eval x.1 (shiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1)) +- ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 1))) := by +- rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod] +- apply MeasureTheory.IntegrableOn.integrable +- apply MeasureTheory.IntegrableOn.mono_set (t := Set.Icc 0 1 ×ˢ Set.Icc 0 1) +- apply ContinuousOn.integrableOn_compact +- · simp only [Set.mem_Ioo, Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one,isCompact_Icc] +- · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, smul_eq_mul] +- apply ContinuousOn.div +- · apply ContinuousOn.mul +- · apply ContinuousOn.mul +- · simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply continuousOn_finset_sum +- intro i _ +- apply ContinuousOn.mul continuousOn_const +- apply ContinuousOn.pow continuousOn_fst +- · apply ContinuousOn.pow +- apply ContinuousOn.mul _ continuousOn_const +- apply ContinuousOn.mul continuousOn_fst continuousOn_snd +- · apply ContinuousOn.pow +- apply ContinuousOn.sub continuousOn_const continuousOn_snd +- · apply ContinuousOn.pow +- apply ContinuousOn.sub continuousOn_const +- apply ContinuousOn.mul _ continuousOn_const +- apply ContinuousOn.sub continuousOn_const +- apply ContinuousOn.mul continuousOn_fst continuousOn_snd +- · intro x hx +- suffices 1 - (1 - x.1 * x.2) * z > 0 by positivity +- simp only [Set.mem_prod, Set.mem_Icc] at hx +- simp only [Set.mem_Ioo, gt_iff_lt, sub_pos] at hz ⊢ +- suffices (1 - x.1 * x.2) * z ≤ z by linarith +- apply mul_le_of_le_one_left (by linarith) +- simp only [tsub_le_iff_right, le_add_iff_nonneg_right] +- nlinarith +- · apply Set.prod_mono Set.Ioo_subset_Icc_self Set.Ioo_subset_Icc_self +- +-lemma double_integral_eq1 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * eval x.2 (shiftedLegendre n) * (1 / (1 - (1 - x.1 * x.2) * z)) = ++lemma double_integral_eq1 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ++ ×ˢ Set.Ioo 0 1, ++ eval x.1 (aperyShiftedLegendre n) * eval x.2 (aperyShiftedLegendre n) * (1 / (1 - (1 - x.1 ++ * x.2) * z)) = + ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) := by ++ eval x.1 (aperyShiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * ++ x.2) * z) ^ (n + 1) := by + calc +- _ = ∫ (x : ℝ) in Set.Ioo 0 1, eval x (shiftedLegendre n) * ∫ (y : ℝ) in Set.Ioo 0 1, +- eval y (shiftedLegendre n) * (1 / (1 - (1 - x * y) * z)) := by ++ _ = ∫ (x : ℝ) in Set.Ioo 0 1, eval x (aperyShiftedLegendre n) * ∫ (y : ℝ) in Set.Ioo 0 1, ++ eval y (aperyShiftedLegendre n) * (1 / (1 - (1 - x * y) * z)) := by + rw [MeasureTheory.Measure.volume_eq_prod, ← MeasureTheory.Measure.prod_restrict, + MeasureTheory.integral_prod] + · apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro x _ + simp only +- rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), +- ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), ++ rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num), ++ ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num), + ← intervalIntegral.integral_const_mul] + simp only [one_div, ← mul_assoc] + · exact eq1_integrableOn_aux1 n z hz +- _ = ∫ (x : ℝ) in Set.Ioo 0 1, eval x (shiftedLegendre n) * ∫ (y : ℝ) in Set.Ioo 0 1, ++ _ = ∫ (x : ℝ) in Set.Ioo 0 1, eval x (aperyShiftedLegendre n) * ∫ (y : ℝ) in Set.Ioo 0 1, + (x * y * z) ^ n * (1 - y) ^ n / (1 - (1 - x * y) * z) ^ (n + 1) := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro x hx + simp only + congr 1 +- rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), +- ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num)] ++ rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num), ++ ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num)] + rw [legendre_integral_special n hx hz] + _ = ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) := by ++ eval x.1 (aperyShiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * ++ x.2) * z) ^ (n + 1) := by + rw [MeasureTheory.Measure.volume_eq_prod, ← MeasureTheory.Measure.prod_restrict, + MeasureTheory.integral_prod] + · apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro x _ + simp only +- rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), +- ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), ++ rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num), ++ ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num), + ← intervalIntegral.integral_const_mul] + simp only [mul_div, ← mul_assoc] + · exact eq1_integrableOn_aux2 n z hz + +-lemma ineq_aux (x : ℝ × ℝ) (z : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < x.2 ∧ x.2 < 1) (hz : 0 ≤ z ∧ z ≤ 1) : ++lemma ineq_aux (x : ℝ × ℝ) (z : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < x.2 ∧ x.2 < 1) (hz : 0 ≤ z ∧ ++ z ≤ 1) : + 0 ≤ (1 - z) / (1 - (1 - x.1 * x.2) * z) ∧ (1 - z) / (1 - (1 - x.1 * x.2) * z) ≤ 1 := by + constructor + · apply div_nonneg (by linarith) + simp only [sub_nonneg] +- apply mul_le_one₀ _ (by linarith) (by linarith) ++ refine (mul_le_of_le_one_left (by linarith) ?_).trans (by linarith) + simp only [tsub_le_iff_right, le_add_iff_nonneg_right] + nlinarith + · rw [div_le_iff₀] +@@ -670,18 +591,20 @@ lemma ineq_aux (x : ℝ × ℝ) (z : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < x. + suffices z * (1 - x.1 * x.2) ≤ (1 - x.1 * x.2) by nlinarith + apply mul_le_of_le_one_left (by nlinarith) hz.2 + +-lemma ineq_aux1 (x : ℝ × ℝ) (z : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < x.2 ∧ x.2 < 1) (hz : 0 ≤ z ∧ z ≤ 1) : ++lemma ineq_aux1 (x : ℝ × ℝ) (z : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < x.2 ∧ x.2 < 1) (hz : 0 ≤ z ++ ∧ z ≤ 1) : + 1 - (1 - x.1 * x.2) * z ≠ 0 := by + suffices (1 - x.1 * x.2) * z < 1 by linarith + rw [mul_comm] + suffices z * (1 - x.1 * x.2) ≤ (1 - x.1 * x.2) by nlinarith + apply mul_le_of_le_one_left (by nlinarith) hz.2 + +-lemma fun_eq_aux (x : ℝ × ℝ) (y : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < x.2 ∧ x.2 < 1) (hy : 0 ≤ y ∧ y ≤ 1) : ++lemma fun_eq_aux (x : ℝ × ℝ) (y : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < x.2 ∧ x.2 < 1) (hy : 0 ≤ y ++ ∧ y ≤ 1) : + deriv (fun z => (1 - z) / (1 - (1 - x.1 * x.2) * z)) y = + (fun z => - x.1 * x.2 / (1 - (1 - x.1 * x.2) * z) ^ 2) y := by +- rw [deriv_div] +- · rw [deriv_const_sub, deriv_const_sub, deriv_const_mul _ differentiableAt_id'] ++ rw [deriv_fun_div] ++ · rw [deriv_const_sub, deriv_const_sub, deriv_const_mul _ differentiableAt_id] + simp only [deriv_id'', neg_mul, one_mul, neg_sub, mul_one] + congr + ring +@@ -689,9 +612,12 @@ lemma fun_eq_aux (x : ℝ × ℝ) (y : ℝ) (hx : (0 < x.1 ∧ x.1 < 1) ∧ 0 < + · apply DifferentiableAt.const_sub (DifferentiableAt.const_mul differentiableAt_id _) + · exact ineq_aux1 x y hx hy + +-lemma double_integral_eq2 (n : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) : ∫ (z : ℝ) in Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) = +- ∫ (z : ℝ) in Set.Ioo 0 1, eval x.1 (shiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) := by ++lemma double_integral_eq2 (n : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) : ∫ (z : ℝ) ++ in Set.Ioo 0 1, ++ eval x.1 (aperyShiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * ++ x.2) * z) ^ (n + 1) = ++ ∫ (z : ℝ) in Set.Ioo 0 1, eval x.1 (aperyShiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / ++ (1 - (1 - x.1 * x.2) * z) := by + rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), + ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num)] + simp only [← mul_div, mul_assoc] +@@ -712,7 +638,7 @@ lemma double_integral_eq2 (n : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 × + apply ContinuousOn.mul continuousOn_const continuousOn_id + · intro y hy + simp only [Set.mem_prod, Set.mem_Ioo, zero_le_one, Set.uIcc_of_le, Set.mem_Icc, +- OfNat.ofNat_ne_zero, not_false_eq_true, pow_eq_zero_iff] at hx hy ⊢ ++ ] at hx hy ⊢ + apply pow_ne_zero + exact ineq_aux1 x y hx hy + · intro y hy +@@ -754,7 +680,8 @@ lemma double_integral_eq2 (n : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 × + 1 - (1 - y) / (1 - (1 - x.1 * x.2) * y) := by + rw [sub_div, div_self (ineq_aux1 x y hx hy)] + have eq2 : ((1 - (1 - x.1 * x.2) * y) - (1 - x.1 * x.2) * (1 - y)) / +- (1 - (1 - x.1 * x.2) * y) = 1 - (1 - x.1 * x.2) * ((1 - y) / (1 - (1 - x.1 * x.2) * y)) := by ++ (1 - (1 - x.1 * x.2) * y) = 1 - (1 - x.1 * x.2) * ((1 - y) / (1 - (1 - x.1 * x.2) ++ * y)) := by + rw [sub_div, div_self (ineq_aux1 x y hx hy), mul_div] + rw [div_eq_iff] + · rw [← eq1, ← eq2, mul_div, div_eq_div_iff (ineq_aux1 x y hx hy) (ineq_aux1 x y hx hy)] +@@ -774,14 +701,15 @@ lemma double_integral_eq2 (n : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 × + · intro y hy + simp only [Set.mem_Icc] at hy + exact ineq_aux1 x y hx hy +- _ = ∫ (y : ℝ) in (0)..1, x.1 * x.2 / (1 - (1 - x.1 * x.2) * y) ^ 2 * (1 - g y) ^ n / (1 - (1 - x.1 * x.2) * g y) := by ++ _ = ∫ (y : ℝ) in (0)..1, x.1 * x.2 / (1 - (1 - x.1 * x.2) * y) ^ 2 * (1 - g y) ^ n / (1 - (1 ++ - x.1 * x.2) * g y) := by + rw [← intervalIntegral.integral_neg] + apply intervalIntegral.integral_congr + intro y hy + simp only [zero_le_one, Set.uIcc_of_le, Set.mem_Icc] at hy ⊢ +- simp only [g, g'] ++ simp only [g] + rw [fun_eq_aux x y hx hy] +- simp [g, g', neg_div] ++ ring + _ = ∫ (y : ℝ) in (0)..1, (x.1 * x.2 * y) ^ n / (1 - (1 - x.1 * x.2) * y) ^ (n + 1) := by + apply intervalIntegral.integral_congr + intro y hy +@@ -795,7 +723,7 @@ lemma double_integral_eq2 (n : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 × + rw [div_mul_eq_mul_div, div_div, div_eq_div_iff] + · simp only [← eq1, sub_sub_sub_cancel_left, div_pow, ← eq2, g] + rw [mul_div, mul_comm, mul_div, mul_div, mul_div, div_eq_div_iff] +- ring ++ · ring + · apply pow_ne_zero + exact ineq_aux1 x y hx hy + · exact ineq_aux1 x y hx hy +@@ -812,39 +740,43 @@ lemma double_integral_eq2 (n : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 × + exact ineq_aux1 x y hx hy + + lemma eq3_integrableOn_aux (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : +- MeasureTheory.Integrable (fun x ↦ eval x.1 (shiftedLegendre n) * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z)) +- ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo 0 1))) := by ++ MeasureTheory.Integrable (fun x ↦ eval x.1 (aperyShiftedLegendre n) * (1 - x.2) ^ n / (1 - ++ (1 - x.1 * x.2) * z)) ++ ((MeasureTheory.volume.restrict (Set.Ioo 0 1)).prod (MeasureTheory.volume.restrict (Set.Ioo ++ 0 1))) := by + rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod] + apply MeasureTheory.IntegrableOn.integrable + apply MeasureTheory.IntegrableOn.mono_set (t := Set.Icc 0 1 ×ˢ Set.Icc 0 1) +- apply ContinuousOn.integrableOn_compact +- · simp only [Set.mem_Ioo, Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one,isCompact_Icc] +- · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one, smul_eq_mul] +- apply ContinuousOn.div +- · apply ContinuousOn.mul +- simp only [eval_finset_sum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] +- apply continuousOn_finset_sum +- intro i _ +- apply ContinuousOn.mul continuousOn_const +- apply ContinuousOn.pow continuousOn_fst +- apply ContinuousOn.pow (ContinuousOn.sub continuousOn_const continuousOn_snd) +- · apply ContinuousOn.sub continuousOn_const +- apply ContinuousOn.mul _ continuousOn_const +- apply ContinuousOn.sub continuousOn_const +- apply ContinuousOn.mul continuousOn_fst continuousOn_snd +- · intro x hx +- suffices 1 - (1 - x.1 * x.2) * z > 0 by linarith +- simp only [Set.mem_prod, Set.mem_Icc] at hx +- simp only [Set.mem_Ioo, gt_iff_lt, sub_pos] at hz ⊢ +- suffices (1 - x.1 * x.2) * z ≤ z by linarith +- apply mul_le_of_le_one_left (by linarith) +- simp only [tsub_le_iff_right, le_add_iff_nonneg_right] +- nlinarith ++ · apply ContinuousOn.integrableOn_compact ++ · simp only [Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one,isCompact_Icc] ++ · simp only [shiftedLegendre_eq_sum, map_pow, map_neg, map_one] ++ apply ContinuousOn.div ++ · apply ContinuousOn.mul ++ · simp only [eval_finsetSum, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_X] ++ apply continuousOn_finsetSum ++ intro i _ ++ apply ContinuousOn.mul continuousOn_const ++ apply ContinuousOn.pow continuousOn_fst ++ · apply ContinuousOn.pow (ContinuousOn.sub continuousOn_const continuousOn_snd) ++ · apply ContinuousOn.sub continuousOn_const ++ apply ContinuousOn.mul _ continuousOn_const ++ apply ContinuousOn.sub continuousOn_const ++ apply ContinuousOn.mul continuousOn_fst continuousOn_snd ++ · intro x hx ++ suffices 1 - (1 - x.1 * x.2) * z > 0 by linarith ++ simp only [Set.mem_prod, Set.mem_Icc] at hx ++ simp only [Set.mem_Ioo, gt_iff_lt, sub_pos] at hz ⊢ ++ suffices (1 - x.1 * x.2) * z ≤ z by linarith ++ apply mul_le_of_le_one_left (by linarith) ++ simp only [tsub_le_iff_right, le_add_iff_nonneg_right] ++ nlinarith + · apply Set.prod_mono Set.Ioo_subset_Icc_self Set.Ioo_subset_Icc_self + +-lemma double_integral_eq3 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++lemma double_integral_eq3 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ++ ×ˢ Set.Ioo 0 1, + (x.1 * x.2 * z * (1 - x.1) * (1 - x.2)) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) = +- ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, eval x.1 (shiftedLegendre n) * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) := by ++ ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, eval x.1 (aperyShiftedLegendre n) * (1 - x.2) ++ ^ n / (1 - (1 - x.1 * x.2) * z) := by + symm + rw [MeasureTheory.Measure.volume_eq_prod, ← MeasureTheory.Measure.prod_restrict, + MeasureTheory.integral_prod, MeasureTheory.integral_integral_swap] +@@ -852,25 +784,30 @@ lemma double_integral_eq3 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : ∫ (x + simp only + calc + _ = ∫ (y : ℝ) in Set.Ioo 0 1, (1 - y) ^ n * ∫ (x : ℝ) in Set.Ioo 0 1, +- eval x (shiftedLegendre n) / (1 - (1 - x * y) * z) := by ++ eval x (aperyShiftedLegendre n) / (1 - (1 - x * y) * z) := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro y hy +- simp at hy ⊢ +- rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), +- ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num), ++ simp only at hy ⊢ ++ rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num), ++ ← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num), + ← intervalIntegral.integral_const_mul] + simp [mul_div, mul_comm] +- _ = ∫ (y : ℝ) in Set.Ioo 0 1, (1 - y) ^ n * ∫ (x : ℝ) in (0)..1, (y * x * z) ^ n * (1 - x) ^ n / (1 - (1 - y * x) * z) ^ (n + 1) := by ++ _ = ∫ (y : ℝ) in Set.Ioo 0 1, (1 - y) ^ n * ∫ (x : ℝ) in (0)..1, (y * x * z) ^ n * (1 - x) ++ ^ n / (1 - (1 - y * x) * z) ^ (n + 1) := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro y hy + simp only + congr 1 +- rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by norm_num)] ++ rw [← MeasureTheory.integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le (by ++ norm_num)] + have := legendre_integral_special n hy hz + simp only [mul_one_div] at this + simp only [← this] + simp only [mul_comm] +- _ = ∫ (y : ℝ) in Set.Ioo 0 1, ∫ (x : ℝ) in Set.Ioo 0 1, (1 - y) ^ n * (y * x * z) ^ n * (1 - x) ^ n / (1 - (1 - y * x) * z) ^ (n + 1) := by ++ _ = ∫ (y : ℝ) in Set.Ioo 0 1, ∫ (x : ℝ) in Set.Ioo 0 1, (1 - y) ^ n * (y * x * z) ^ n * (1 ++ - x) ^ n / (1 - (1 - y * x) * z) ^ (n + 1) := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro y _ + simp only +@@ -885,26 +822,26 @@ lemma double_integral_eq3 (n : ℕ) (z : ℝ) (hz : z ∈ Set.Ioo 0 1) : ∫ (x + · rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod] + apply MeasureTheory.IntegrableOn.integrable + apply MeasureTheory.IntegrableOn.mono_set (t := Set.Icc 0 1 ×ˢ Set.Icc 0 1) +- apply ContinuousOn.integrableOn_compact +- · simp only [Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one, isCompact_Icc] +- · apply ContinuousOn.div +- · apply ContinuousOn.pow +- apply ContinuousOn.mul _ (ContinuousOn.sub continuousOn_const continuousOn_snd) +- apply ContinuousOn.mul _ (ContinuousOn.sub continuousOn_const continuousOn_fst) +- apply ContinuousOn.mul _ continuousOn_const +- apply ContinuousOn.mul continuousOn_fst continuousOn_snd +- · apply ContinuousOn.pow +- apply ContinuousOn.sub continuousOn_const _ +- apply ContinuousOn.mul _ continuousOn_const +- apply ContinuousOn.sub continuousOn_const _ +- apply ContinuousOn.mul continuousOn_fst continuousOn_snd +- · intro x hx +- simp only [Set.mem_prod, Set.mem_Icc, Set.mem_Ioo] at hx hz +- apply pow_ne_zero +- suffices (1 - x.1 * x.2) * z ≤ z by linarith +- apply mul_le_of_le_one_left (by linarith) +- simp only [tsub_le_iff_right, le_add_iff_nonneg_right] +- nlinarith ++ · apply ContinuousOn.integrableOn_compact ++ · simp only [Set.Icc_prod_Icc, Prod.mk_zero_zero, Prod.mk_one_one, isCompact_Icc] ++ · apply ContinuousOn.div ++ · apply ContinuousOn.pow ++ apply ContinuousOn.mul _ (ContinuousOn.sub continuousOn_const continuousOn_snd) ++ apply ContinuousOn.mul _ (ContinuousOn.sub continuousOn_const continuousOn_fst) ++ apply ContinuousOn.mul _ continuousOn_const ++ apply ContinuousOn.mul continuousOn_fst continuousOn_snd ++ · apply ContinuousOn.pow ++ apply ContinuousOn.sub continuousOn_const _ ++ apply ContinuousOn.mul _ continuousOn_const ++ apply ContinuousOn.sub continuousOn_const _ ++ apply ContinuousOn.mul continuousOn_fst continuousOn_snd ++ · intro x hx ++ simp only [Set.mem_prod, Set.mem_Icc, Set.mem_Ioo] at hx hz ++ apply pow_ne_zero ++ suffices (1 - x.1 * x.2) * z ≤ z by linarith ++ apply mul_le_of_le_one_left (by linarith) ++ simp only [tsub_le_iff_right, le_add_iff_nonneg_right] ++ nlinarith + · apply Set.prod_mono Set.Ioo_subset_Icc_self Set.Ioo_subset_Icc_self + · exact eq3_integrableOn_aux n z hz + · exact eq3_integrableOn_aux n z hz +@@ -913,35 +850,42 @@ theorem JJ_eq_form (n : ℕ) : JJ n = JJ' n := by + simp only [JJ, JJ'] + calc + _ = ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- (∫ (z : ℝ) in Set.Ioo 0 1, eval x.1 (shiftedLegendre n) * eval x.2 (shiftedLegendre n) * (1 / (1 - (1 - x.1 * x.2) * z))) := by ++ (∫ (z : ℝ) in Set.Ioo 0 1, eval x.1 (aperyShiftedLegendre n) * eval x.2 ++ (aperyShiftedLegendre n) * (1 / (1 - (1 - x.1 * x.2) * z))) := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro x hx + simp only [Set.mem_prod, Set.mem_Ioo] at hx ⊢ + rw [mul_assoc, mul_comm, ← integral1, ← MeasureTheory.integral_Ioc_eq_integral_Ioo, +- ← intervalIntegral.integral_of_le (by norm_num), intervalIntegral.integral_const_mul] <;> nlinarith ++ ← intervalIntegral.integral_of_le (by norm_num), intervalIntegral.integral_const_mul] <;> ++ nlinarith + _ = ∫ (z : ℝ) in Set.Ioo 0 1, ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * eval x.2 (shiftedLegendre n) * (1 / (1 - (1 - x.1 * x.2) * z)) := by ++ eval x.1 (aperyShiftedLegendre n) * eval x.2 (aperyShiftedLegendre n) * (1 / (1 - (1 - x.1 ++ * x.2) * z)) := by + symm + rw [MeasureTheory.integral_integral_swap] + exact integrableOn_JJ1 n + _ = ∫ (z : ℝ) in Set.Ioo 0 1, ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) := by ++ eval x.1 (aperyShiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * ++ x.2) * z) ^ (n + 1) := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro z hz + simp only + exact double_integral_eq1 n z hz + _ = ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ∫ (z : ℝ) in Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) := by ++ eval x.1 (aperyShiftedLegendre n) * (x.1 * x.2 * z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * ++ x.2) * z) ^ (n + 1) := by + rw [MeasureTheory.integral_integral_swap] + exact integrableOn_JJ2 n + _ = ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ∫ (z : ℝ) in Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) := by ++ eval x.1 (aperyShiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ++ := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro x hx + simp only + exact double_integral_eq2 n x hx + _ = ∫ (z : ℝ) in Set.Ioo 0 1, ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- eval x.1 (shiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) := by ++ eval x.1 (aperyShiftedLegendre n) * (1 - z) ^ n * (1 - x.2) ^ n / (1 - (1 - x.1 * x.2) * z) ++ := by + symm + rw [MeasureTheory.integral_integral_swap] + exact integrableOn_JJ3 n +@@ -957,7 +901,8 @@ theorem JJ_eq_form (n : ℕ) : JJ n = JJ' n := by + rw [smul_eq_mul] + ring + _ = ∫ (z : ℝ) in Set.Ioo 0 1, ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- (x.1 * x.2 * z * (1 - x.1) * (1 - x.2) * (1 - z)) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) := by ++ (x.1 * x.2 * z * (1 - x.1) * (1 - x.2) * (1 - z)) ^ n / (1 - (1 - x.1 * x.2) * z) ^ (n + 1) ++ := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro z hz + simp only +@@ -968,7 +913,8 @@ theorem JJ_eq_form (n : ℕ) : JJ n = JJ' n := by + rw [smul_eq_mul, mul_comm, mul_div, ← mul_pow] + ring + _ = ∫ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, +- (x.2.1 * (1 - x.2.1) * x.2.2 * (1 - x.2.2) * x.1 * (1 - x.1) / (1 - (1 - x.2.1 * x.2.2) * x.1)) ^ n / ++ (x.2.1 * (1 - x.2.1) * x.2.2 * (1 - x.2.2) * x.1 * (1 - x.1) / (1 - (1 - x.2.1 * x.2.2) * ++ x.1)) ^ n / + (1 - (1 - x.2.1 * x.2.2) * x.1) := by + symm + rw [MeasureTheory.Measure.volume_eq_prod, ← MeasureTheory.Measure.prod_restrict, +@@ -992,38 +938,16 @@ theorem JJ_pos (n : ℕ) : 0 < JJ n := by + have subset : Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ⊆ Function.support F := by + intro a ha + change F a ≠ 0 +- simp only [div_pow, ne_eq, _root_.div_eq_zero_iff, pow_eq_zero_iff', mul_eq_zero, not_or, +- not_and, Decidable.not_not, F] ++ have hden := pos_aux a (by simpa only [Set.mem_prod, Set.mem_Ioo] using ha) + simp only [Set.mem_prod, Set.mem_Ioo] at ha + rcases ha with ⟨⟨hx0, hx1⟩, ⟨hy0, hy1⟩, hz0, hz1⟩ +- constructor +- · constructor +- · intro h +- rcases h with (h | h); swap; nlinarith +- rcases h with (h | h); swap; nlinarith +- rcases h with (h | h); swap; nlinarith +- rcases h with (h | h); swap; nlinarith +- rcases h with (h | h) <;> nlinarith +- · intro h +- suffices ¬1 - (1 - a.2.1 * a.2.2) * a.1 = 0 by tauto +- suffices 1 - (1 - a.2.1 * a.2.2) * a.1 > 0 by linarith +- simp only [gt_iff_lt, sub_pos] +- suffices (1 - a.2.1 * a.2.2) * a.1 < a.1 by linarith +- rw [mul_lt_iff_lt_one_left] +- · simp only [sub_lt_self_iff] +- nlinarith +- · exact hx0 +- · suffices 1 - (1 - a.2.1 * a.2.2) * a.1 > 0 by linarith +- simp only [gt_iff_lt, sub_pos] +- suffices (1 - a.2.1 * a.2.2) * a.1 < a.1 by linarith +- rw [mul_lt_iff_lt_one_left] +- · simp only [sub_lt_self_iff] +- nlinarith +- · exact hx0 ++ apply ne_of_gt ++ dsimp only [F] ++ positivity + rw [MeasureTheory.Measure.restrict_apply'] +- rw [Set.inter_eq_right.2 subset] +- simp only [MeasureTheory.Measure.volume_eq_prod, MeasureTheory.Measure.prod_prod] +- simp only [Real.volume_Ioo, sub_zero, ENNReal.ofReal_one, mul_one, zero_lt_one] ++ · rw [Set.inter_eq_right.2 subset] ++ simp only [MeasureTheory.Measure.volume_eq_prod, MeasureTheory.Measure.prod_prod] ++ simp only [Real.volume_Ioo, sub_zero, ENNReal.ofReal_one, mul_one, zero_lt_one] + · measurability + · apply MeasureTheory.ae_nonneg_restrict_of_forall_setIntegral_nonneg_inter + · rw [MeasureTheory.IntegrableOn] +@@ -1041,10 +965,10 @@ theorem JJ_pos (n : ℕ) : 0 < JJ n := by + apply mul_nonneg _ (by linarith) + apply mul_nonneg _ (by linarith) + apply mul_nonneg (by linarith) (by linarith) +- · simp only [abs_eq_self, sub_nonneg] +- apply mul_le_one₀ (by nlinarith) (by linarith) (by linarith) +- · simp only [abs_eq_self, sub_nonneg] +- apply mul_le_one₀ (by nlinarith) (by linarith) (by linarith) ++ · simp only [sub_nonneg] ++ exact (mul_le_of_le_one_left (by linarith) (by nlinarith)).trans (by linarith) ++ · simp only [sub_nonneg] ++ exact (mul_le_of_le_one_left (by linarith) (by nlinarith)).trans (by linarith) + · rw [Set.mem_inter_iff] at hx + tauto + · exact integrableOn_JJ' n +@@ -1078,12 +1002,13 @@ lemma Summable_of_zeta_two' : Summable (fun (n : ℕ) ↦ 1 / ((n : ℝ) + 1) ^ + exact h + + lemma zeta_3_pos : 0 < ∑' (n : ℕ), 1 / ((n : ℝ) + 1) ^ 3 := by +- apply tsum_pos (ι := ℕ) (g := fun n => 1 / ((n : ℝ) + 1) ^ 3) (i := 1) ++ apply Summable.tsum_pos (ι := ℕ) (g := fun n => 1 / ((n : ℝ) + 1) ^ 3) (i := 1) + · apply summable_of_sum_range_le (c := Real.pi ^ 2 / 6) + · intro _ + positivity + · intro n +- suffices ∑ i ∈ Finset.range n, 1 / ((i : ℝ) + 1) ^ 3 ≤ ∑ i ∈ Finset.range n, 1 / ((i : ℝ) + 1) ^ 2 by ++ suffices ∑ i ∈ Finset.range n, 1 / ((i : ℝ) + 1) ^ 3 ≤ ++ ∑ i ∈ Finset.range n, 1 / ((i : ℝ) + 1) ^ 2 by + have : ∑ i ∈ Finset.range n, 1 / ((i : ℝ) + 1) ^ 2 ≤ Real.pi ^ 2 / 6 := by + suffices ∑ i ∈ Finset.range n, 1 / ((i : ℝ) + 1) ^ 2 ≤ ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 2 by + have h : ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 2 = (riemannZeta 2).re := by +@@ -1092,10 +1017,10 @@ lemma zeta_3_pos : 0 < ∑' (n : ℕ), 1 / ((n : ℝ) + 1) ^ 3 := by + norm_cast + rw [h, riemannZeta_two] at this + norm_cast at * +- apply sum_le_tsum (s := Finset.range n) +- intro i _ +- positivity +- exact Summable_of_zeta_two' ++ apply Summable.sum_le_tsum (s := Finset.range n) ++ · intro i _ ++ positivity ++ · exact Summable_of_zeta_two' + linarith + apply Finset.sum_le_sum + intro i _ +@@ -1104,7 +1029,7 @@ lemma zeta_3_pos : 0 < ∑' (n : ℕ), 1 / ((n : ℝ) + 1) ^ 3 := by + · positivity + · positivity + · intro m +- simp only [one_div, pow_succ, add_comm, add_left_comm] ++ simp only [one_div, pow_succ] + positivity + · positivity + +@@ -1133,45 +1058,18 @@ theorem JJ_upper (n : ℕ) : JJ n ≤ 2 * (1 / 24) ^ n * ∑' n : ℕ , 1 / ((n + apply mul_nonneg _ (by linarith) + apply mul_nonneg _ (by linarith) + apply mul_nonneg (by linarith) (by linarith) +- · simp only [abs_eq_self, sub_nonneg] +- apply mul_le_one₀ (by nlinarith) (by linarith) (by linarith) +- · simp only [abs_eq_self, sub_nonneg] +- apply mul_le_one₀ (by nlinarith) (by linarith) (by linarith) ++ · simp only [sub_nonneg] ++ exact (mul_le_of_le_one_left (by linarith) (by nlinarith)).trans (by linarith) ++ · simp only [sub_nonneg] ++ exact (mul_le_of_le_one_left (by linarith) (by nlinarith)).trans (by linarith) + · rw [Set.mem_inter_iff] at hx + tauto +- · apply AEMeasurable.aestronglyMeasurable +- rw [← aemeasurable_indicator_iff (by measurability)] +- apply AEMeasurable.indicator _ (by measurability) +- apply AEMeasurable.div +- · apply AEMeasurable.pow_const +- apply AEMeasurable.div +- · apply AEMeasurable.mul _ (AEMeasurable.const_sub (AEMeasurable.fst (f := id) aemeasurable_id) _) +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.mul _ (AEMeasurable.const_sub (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) _) +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- apply AEMeasurable.mul _ (AEMeasurable.const_sub (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) _) +- exact (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) +- · apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- exact (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) +- · apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- (AEMeasurable.snd (f := id) aemeasurable_id)) +- exact (AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- (AEMeasurable.fst (f := id) aemeasurable_id)) ++ · apply Measurable.aestronglyMeasurable ++ fun_prop + + lemma zeta3_le_zeta2 : ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 < ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 2 := by +- apply tsum_lt_tsum_of_nonneg (f := fun n => 1 / ((n : ℝ) + 1) ^ 3) (g := fun n => 1 / ((n : ℝ) + 1) ^ 2) (i := 2) ++ apply Summable.tsum_lt_tsum_of_nonneg (f := fun n => 1 / ((n : ℝ) + 1) ^ 3) ++ (g := fun n => 1 / ((n : ℝ) + 1) ^ 2) (i := 2) + · intro n + positivity + · intro n +@@ -1182,9 +1080,10 @@ lemma zeta3_le_zeta2 : ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 < ∑' n : ℕ , 1 + · norm_num + · exact Summable_of_zeta_two' + +-lemma ε_N_def_of_pi_alt : ∀ ε > (0 : ℝ), ∃ N : ℕ, ∀ n : ℕ, n ≥ N → n.primeCounting ≤ (1 + ε) * (n : ℝ) / (n : ℝ).log := by ++lemma ε_N_def_of_pi_alt : ∀ ε > (0 : ℝ), ∃ N : ℕ, ∀ n : ℕ, ++ n ≥ N → n.primeCounting ≤ (1 + ε) * (n : ℝ) / (n : ℝ).log := by + intro ε hε +- obtain ⟨c,⟨hc0, hc1⟩⟩ := pi_alt ++ obtain ⟨c,⟨hc0, hc1⟩⟩ := AperyPNT.pi_alt + rw [Asymptotics.isLittleO_const_iff (by simp), tendsto_atTop_nhds] at hc0 + specialize hc0 (Set.Ioo (-ε) ε) (by simp only [Set.mem_Ioo, Left.neg_neg_iff, hε, and_self]) + (by exact isOpen_Ioo) +@@ -1193,26 +1092,27 @@ lemma ε_N_def_of_pi_alt : ∀ ε > (0 : ℝ), ∃ N : ℕ, ∀ n : ℕ, n ≥ N + intro n hn + have hn' : n ≥ N := by + trans (⌈N⌉₊ : ℝ) +- norm_cast +- linarith +- exact Nat.le_ceil N ++ · norm_cast ++ linarith ++ · exact Nat.le_ceil N + specialize hN n hn' + specialize hc1 n + simp only [Nat.floor_natCast] at hc1 + simp only [Set.mem_Ioo] at hN +- rw [hc1, ← mul_div, ← mul_div, mul_le_mul_right] +- linarith +- apply div_pos +- norm_cast +- omega +- apply Real.log_pos +- norm_cast +- omega ++ rw [hc1, ← mul_div, ← mul_div, mul_le_mul_iff_of_pos_right] ++ · linarith ++ · apply div_pos ++ · norm_cast ++ omega ++ · apply Real.log_pos ++ norm_cast ++ omega + + lemma eventuallyN_of_le : ∃ N : ℕ, ∀ n : ℕ, n ≥ N → ↑(d (Finset.Icc 1 n)) ^ 3 ≤ (21 : ℝ) ^ n := by + have h1 : (Real.exp 1) ^ 3 < (21 : ℝ) := by + suffices (2.7182818286) ^ 3 < (21 : ℝ) by +- exact pow_lt_pow_left₀ Real.exp_one_lt_d9 (n := 3) (by linarith [Real.exp_pos 1]) (by simp) |>.trans this ++ exact pow_lt_pow_left₀ Real.exp_one_lt_d9 (n := 3) ++ (by linarith [Real.exp_pos 1]) (by simp) |>.trans this + norm_num + have h : Real.log (21 ^ (1 / 3 : ℝ)) - 1 > 0 := by + simp only [gt_iff_lt, sub_pos] +@@ -1232,13 +1132,14 @@ lemma eventuallyN_of_le : ∃ N : ℕ, ∀ n : ℕ, n ≥ N → ↑(d (Finset.Ic + _ ≤ (n ^ (1 / 3 * Real.log 21 * ↑n / Real.log ↑n)) ^ 3 := by + apply pow_le_pow_left₀ (by simp) + rw [← Real.rpow_natCast, Real.rpow_le_rpow_left_iff] +- exact hN +- simp only [Nat.one_lt_cast] +- omega ++ · exact hN ++ · simp only [Nat.one_lt_cast] ++ omega + _ ≤ (21 : ℝ) ^ n := by + rw [← Real.rpow_natCast, ← Real.rpow_mul (by simp), mul_comm] + nth_rewrite 1 [← Real.exp_log (x := n) (by simp only [Nat.cast_pos]; omega)] +- have h2 : Real.log ↑n * (↑3 * (1 / 3 * Real.log 21 * ↑n / Real.log ↑n)) = Real.log 21 * ↑n := by ++ have h2 : Real.log ↑n * (↑3 * (1 / 3 * Real.log 21 * ↑n / Real.log ↑n)) = ++ Real.log 21 * ↑n := by + rw [← mul_assoc, mul_div, ← mul_assoc, ← mul_assoc] + simp only [one_div, isUnit_iff_ne_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, + IsUnit.mul_inv_cancel_right] +@@ -1249,10 +1150,12 @@ lemma eventuallyN_of_le : ∃ N : ℕ, ∀ n : ℕ, n ≥ N → ↑(d (Finset.Ic + constructor <;> omega + rw [← Real.exp_one_rpow, ← Real.rpow_mul (by exact Real.exp_nonneg 1)] + norm_cast +- rw [h2, Real.rpow_mul (by exact Real.exp_nonneg 1), Real.exp_one_rpow, Real.exp_log (by norm_num)] ++ rw [h2, Real.rpow_mul (by exact Real.exp_nonneg 1), Real.exp_one_rpow, ++ Real.exp_log (by norm_num)] + norm_cast + +-theorem fun1_tendsto_zero : Filter.Tendsto (fun n ↦ ENNReal.ofReal (fun1 n)) Filter.atTop (nhds 0) := by ++theorem fun1_tendsto_zero : Filter.Tendsto (fun n ↦ ENNReal.ofReal (fun1 n)) Filter.atTop (nhds ++ 0) := by + rw [ENNReal.tendsto_atTop_zero] + intro ε hε + if h : ε = ⊤ then simp [h] +@@ -1270,13 +1173,13 @@ theorem fun1_tendsto_zero : Filter.Tendsto (fun n ↦ ENNReal.ofReal (fun1 n)) F + use N.max N1 + intro n hn + rw [ENNReal.ofReal_le_ofReal_iff (by simp)] +- suffices ↑(d (Finset.Icc 1 n)) ^ 3 * 2 * (1 / 24) ^ n * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 ≤ ε.toReal by ++ suffices ↑(d (Finset.Icc 1 n)) ^ 3 * 2 * (1 / 24) ^ n * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 ≤ ++ ε.toReal by + trans ↑(d (Finset.Icc 1 n)) ^ 3 * 2 * (1 / 24) ^ n * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 +- swap +- exact this +- rw [mul_assoc, mul_assoc] +- apply mul_le_mul_of_nonneg_left _ (by simp) +- linarith [JJ_upper n] ++ · rw [mul_assoc, mul_assoc] ++ apply mul_le_mul_of_nonneg_left _ (by simp) ++ linarith [JJ_upper n] ++ · exact this + calc + _ ≤ 2 * (21 / 24 : ℝ) ^ n * (∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3) := by + apply mul_le_mul_of_nonneg_right _ (by linarith[zeta_3_pos]) +@@ -1287,7 +1190,8 @@ theorem fun1_tendsto_zero : Filter.Tendsto (fun n ↦ ENNReal.ofReal (fun1 n)) F + exact hN n (le_of_max_le_left hn) + _ ≤ ε.toReal := by + specialize hN1 n (le_of_max_le_right hn) +- rw [← ENNReal.ofReal_toReal_eq_iff.2 h, ← ENNReal.ofReal_div_of_pos (by linarith [zeta_3_pos]), ++ rw [← ENNReal.ofReal_toReal_eq_iff.2 h, ← ENNReal.ofReal_div_of_pos (by linarith ++ [zeta_3_pos]), + ← ENNReal.ofReal_pow (by norm_num), ENNReal.ofReal_le_ofReal_iff] at hN1 + · rw [le_div_iff₀ (by linarith [zeta_3_pos])] at hN1 + linarith +@@ -1301,7 +1205,7 @@ theorem zeta_3_irratoinal : ¬ ∃ r : ℚ , r = riemannZeta 3 := by + norm_cast + simp_rw [Nat.cast_pow, Nat.cast_add, Nat.cast_one] + by_contra! r +- cases' r with r hr ++ obtain ⟨r, hr⟩ := r + let q := r.den + let hq := Rat.den_nz r + have prop1 := ENNReal.Tendsto.mul_const (b := (q : ENNReal)) (fun1_tendsto_zero) (by simp) +@@ -1324,21 +1228,18 @@ theorem zeta_3_irratoinal : ¬ ∃ r : ℚ , r = riemannZeta 3 := by + norm_cast at this ⊢ + rw [ENNReal.tendsto_atTop_zero] at prop1 + specialize prop1 (1/2) (by simp) +- simp only [one_div, Ico_mem_nhds_iff, Set.mem_Ioo, inv_pos, Nat.ofNat_pos, and_true, Set.mem_Ico, +- Filter.eventually_top] at prop1 ++ simp only [one_div] at prop1 + rw [← one_div] at prop1 +- simp only [Filter.eventually_atTop, ge_iff_le] at prop1 +- cases' prop1 with a ha ++ simp only [ge_iff_le] at prop1 ++ obtain ⟨a, ha⟩ := prop1 + specialize prop2 (a + 1) + specialize ha (a + 1) (by simp) + rw [gt_iff_lt, ← ENNReal.ofReal_lt_ofReal_iff, ENNReal.ofReal_mul' (by simp)] at prop2 +- · suffices ENNReal.ofReal (fun1 (a + 1)) * ↑q < ENNReal.ofReal (fun1 (a + 1)) * ↑q by +- simp only [mul_neg, eval_mul, one_div, eval_C, Function.iterate_succ, Function.comp_apply, +- derivative_mul, derivative_X_pow, Nat.cast_add, Nat.cast_one, map_add, map_natCast, map_one, +- add_tsub_cancel_right, iterate_map_add, eval_add, lt_self_iff_false] at this +- rw [show ENNReal.ofReal ↑q = (q : ENNReal) by simp only [ENNReal.ofReal_natCast], +- show ENNReal.ofReal (1 / 2) = 1 / 2 by rw [ENNReal.ofReal_div_of_pos (by norm_num)]; simp] at prop2 +- apply LE.le.trans_lt (b := (1 / 2 : ENNReal)) ha prop2 ++ · have hhalf : ENNReal.ofReal (1 / 2 : ℝ) = (1 / 2 : ENNReal) := by ++ rw [ENNReal.ofReal_div_of_pos (by norm_num)] ++ simp ++ rw [ENNReal.ofReal_natCast, hhalf] at prop2 ++ exact not_lt_of_ge ha prop2 + · apply mul_pos _ (by simp; omega) + apply mul_pos _ (JJ_pos (a + 1)) + apply pow_pos +diff --git a/Zeta3Irrational/Bound.lean b/Zeta3Irrational/Bound.lean +index 56b2726..bb10351 100644 +--- a/Zeta3Irrational/Bound.lean ++++ b/Zeta3Irrational/Bound.lean +@@ -1,12 +1,15 @@ + import Mathlib.Analysis.RCLike.Basic +-import Mathlib.Data.Real.StarOrdered ++import Mathlib.Analysis.Real.Sqrt ++ ++/-! Elementary bounds for the Apéry integral, ported from the Apache-2.0 proof by ++Junqi Liu and Jujian Zhang. -/ + + open scoped Nat + open BigOperators + + lemma max_value {x : ℝ} (x0 : 0 < x) (x1 : x < 1) : √x * √(1 - x) ≤ ((1 / 2) : ℝ) := by + rw [← Real.sqrt_mul, le_div_iff₀, ← show √4 = 2 by rw [Real.sqrt_eq_iff_eq_sq] <;> linarith, +- ← Real.sqrt_mul, Real.sqrt_le_one, show x * (1 - x) * 4= 1 - (2 * x - 1)^2 by ring] <;> ++ ← Real.sqrt_mul, Real.sqrt_le_one, show x * (1 - x) * 4 = 1 - (2 * x - 1) ^ 2 by ring] <;> + nlinarith [mul_self_nonneg (2 * x - 1)] + + lemma max_value' {x : ℝ} (x0 : 0 < x) (x1 : x < 1) : √x * (1 - x) ≤ ((2 / 5) : ℝ) := by +@@ -22,7 +25,7 @@ lemma max_value' {x : ℝ} (x0 : 0 < x) (x1 : x < 1) : √x * (1 - x) ≤ ((2 / + _ ≤ ((2 / 5) : ℝ) := by + rw [Real.sqrt_le_left] <;> norm_num + +-lemma nonneg {x : ℝ} (_ : 0 < x) (_ : x < 1) : (0 : ℝ) ≤ √x * √(1 -x) := ++lemma nonneg {x : ℝ} (_ : 0 < x) (_ : x < 1) : (0 : ℝ) ≤ √x * √(1 - x) := + mul_nonneg (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + + lemma bound_aux (x z : ℝ) (x0 : 0 < x) (x1 : x < 1) (z0 : 0 < z) (_ : z < 1) : +@@ -36,8 +39,9 @@ lemma bound_aux (x z : ℝ) (x0 : 0 < x) (x1 : x < 1) (z0 : 0 < z) (_ : z < 1) : + _ = √(1 - x) * √(1 - x) + √(x * z) * √(x * z) := by ring + _ = 1 - x + x * z := by rw [Real.mul_self_sqrt, Real.mul_self_sqrt] <;> linarith + +-lemma bound (x y z : ℝ) (x0 : 0 < x) (x1 : x < 1) (y0 : 0 < y) (y1 : y < 1) (z0 : 0 < z) (z1 : z < 1) : +- x * (1 -x) * y * (1 - y) * z * (1 - z) / ((1 - (1 - z) * x) * (1 - y * z)) < (1 / 30 : ℝ) := by ++lemma bound (x y z : ℝ) (x0 : 0 < x) (x1 : x < 1) (y0 : 0 < y) (y1 : y < 1) ++ (z0 : 0 < z) (z1 : z < 1) : ++ x * (1 - x) * y * (1 - y) * z * (1 - z) / ((1 - (1 - z) * x) * (1 - y * z)) < (1 / 30 : ℝ) := by + have := mul_pos x0 z0 + have h1 : 2 * √(1 - x) * √(x * z) ≤ 1 - (1 - z) * x := by apply bound_aux <;> assumption + have h2 : 2 * √(1 - y) * √((1 - z) * y) ≤ 1 - y * z := by +@@ -52,22 +56,24 @@ lemma bound (x y z : ℝ) (x0 : 0 < x) (x1 : x < 1) (y0 : 0 < y) (y1 : y < 1) (z + have : 0 ≤ x.sqrt * (1 - x).sqrt := nonneg (by assumption) (by linarith) + have : 0 ≤ y.sqrt * (1 - y).sqrt := nonneg (by assumption) (by linarith) + calc +- _ ≤ x * (1 -x) * y * (1 - y) * z * (1 - z) / (2 * √(1 - x) * √(x * z) * (1 - y * z)) := by ++ _ ≤ x * (1 - x) * y * (1 - y) * z * (1 - z) / (2 * √(1 - x) * √(x * z) * (1 - y * z)) := by + refine div_le_div₀ (by positivity) (le_refl _) (by positivity) ?_ + rwa [mul_le_mul_iff_of_pos_right] + linarith +- _ ≤ x * (1 -x) * y * (1 - y) * z * (1 - z) / (2 * √(1 - x) * √(x * z) * 2 * √(1 - y) * √((1 - z) * y)) := by ++ _ ≤ x * (1 - x) * y * (1 - y) * z * (1 - z) / ++ (2 * √(1 - x) * √(x * z) * 2 * √(1 - y) * √((1 - z) * y)) := by + refine div_le_div₀ (by positivity) (le_refl _) (by positivity) ?_ + rw [mul_assoc, mul_assoc] + rw [mul_assoc] at h2 + exact mul_le_mul_of_nonneg_left h2 (le_of_lt <| by positivity) +- _ = √x * √(1 -x) * (√y * √(1 - y)) * (√z * √(1 - z)) / 4 := by +- rw [Real.sqrt_mul, Real.sqrt_mul] +- calc _ +- _ = ((x * (1 - x)) * (y * (1 - y)) * (z * (1 - z))) / (4 * (√x * √(1 - x)) * (√y * √(1 - y)) * (√z * √(1 - z))) := by ring +- _ = (x / √x) * ((1 - x) / √(1 - x)) * (y / √y) * ((1 - y) / √(1 -y)) * (z / √z) * ((1 - z) / √(1 - z)) / 4 := by ring ++ _ = √x * √(1 - x) * (√y * √(1 - y)) * (√z * √(1 - z)) / 4 := by ++ rw [Real.sqrt_mul (by positivity), Real.sqrt_mul (by positivity)] ++ calc ++ _ = ((x * (1 - x)) * (y * (1 - y)) * (z * (1 - z))) / ++ (4 * (√x * √(1 - x)) * (√y * √(1 - y)) * (√z * √(1 - z))) := by ring ++ _ = (x / √x) * ((1 - x) / √(1 - x)) * (y / √y) * ++ ((1 - y) / √(1 - y)) * (z / √z) * ((1 - z) / √(1 - z)) / 4 := by ring + _ = _ := by simpa only [Real.div_sqrt] using (by ring) +- all_goals linarith + _ ≤ (1 / 2) * (1 / 2) * (1 / 2) / 4 := by + refine div_le_div₀ (by norm_num) + (mul_le_mul_of_nonneg (mul_le_mul_of_nonneg (max_value ?_ ?_) (max_value ?_ ?_) ?_ ?_) +@@ -75,7 +81,8 @@ lemma bound (x y z : ℝ) (x0 : 0 < x) (x1 : x < 1) (y0 : 0 < y) (y1 : y < 1) (z + linarith + _ < (1 / 30 : ℝ) := by norm_num + +-lemma bound_aux' (x y z : ℝ) (x0 : 0 < x) (_ : x < 1) (y0 : 0 < y) (_ : y < 1) (z0 : 0 < z) (z1 : z < 1) : ++lemma bound_aux' (x y z : ℝ) (x0 : 0 < x) (_ : x < 1) (y0 : 0 < y) (_ : y < 1) ++ (z0 : 0 < z) (z1 : z < 1) : + 2 * √(1 - z) * √(x * y * z) ≤ 1 - (1 - x * y) * z := by + rw [← sub_pos] at z1 + have := mul_pos x0 (mul_pos y0 z0) +@@ -86,7 +93,8 @@ lemma bound_aux' (x y z : ℝ) (x0 : 0 < x) (_ : x < 1) (y0 : 0 < y) (_ : y < 1) + _ = √(1 - z) * √(1 - z) + √(x * y * z) * √(x * y * z) := by ring + _ = 1 - z + x * y * z := by rw [Real.mul_self_sqrt, Real.mul_self_sqrt] <;> linarith + +-lemma bound' (x y z : ℝ) (x0 : 0 < x) (x1 : x < 1) (y0 : 0 < y) (y1 : y < 1) (z0 : 0 < z) (z1 : z < 1) : ++lemma bound' (x y z : ℝ) (x0 : 0 < x) (x1 : x < 1) (y0 : 0 < y) (y1 : y < 1) ++ (z0 : 0 < z) (z1 : z < 1) : + x * (1 - x) * y * (1 - y) * z * (1 - z) / (1 - (1 - x * y) * z) < (1 / 24 : ℝ) := by + have := mul_pos x0 z0 + have h1 : 2 * √(1 - x) * √(x * z) ≤ 1 - (1 - z) * x := by apply bound_aux <;> assumption +@@ -102,16 +110,17 @@ lemma bound' (x y z : ℝ) (x0 : 0 < x) (x1 : x < 1) (y0 : 0 < y) (y1 : y < 1) ( + have : 0 ≤ x.sqrt * (1 - x) := mul_nonneg (Real.sqrt_nonneg _) (by linarith) + have : 0 ≤ y.sqrt * (1 - y) := mul_nonneg (Real.sqrt_nonneg _) (by linarith) + calc +- _ ≤ x * (1 -x) * y * (1 - y) * z * (1 - z) / (2 * √(1 - z) * √(x * y * z)) := by ++ _ ≤ x * (1 - x) * y * (1 - y) * z * (1 - z) / (2 * √(1 - z) * √(x * y * z)) := by + refine div_le_div₀ (by positivity) (le_refl _) (by positivity) ?_ + apply bound_aux' <;> linarith + _ = √x * (1 - x) * (√y * (1 - y)) * (√z * √(1 - z)) / 2 := by +- rw [Real.sqrt_mul, Real.sqrt_mul] +- calc _ +- _ = ((x * (1 - x)) * (y * (1 - y)) * (z * (1 - z))) / (2 * √x * √y * (√z * √(1 - z))) := by ring +- _ = (x / √x) * (1 - x) * (y / √y) * (1 - y) * (z / √z) * ((1 - z) / √(1 - z)) / 2 := by ring ++ rw [Real.sqrt_mul (by positivity), Real.sqrt_mul (by positivity)] ++ calc ++ _ = ((x * (1 - x)) * (y * (1 - y)) * (z * (1 - z))) / ++ (2 * √x * √y * (√z * √(1 - z))) := by ring ++ _ = (x / √x) * (1 - x) * (y / √y) * (1 - y) * (z / √z) * ++ ((1 - z) / √(1 - z)) / 2 := by ring + _ = _ := by simpa only [Real.div_sqrt] using (by ring) +- all_goals nlinarith + _ ≤ (2 / 5) * (2 / 5) * (1 / 2) / 2 := by + refine div_le_div₀ (by norm_num) + (mul_le_mul_of_nonneg (mul_le_mul_of_nonneg (max_value' ?_ ?_) (max_value' ?_ ?_) ?_ ?_) +diff --git a/Zeta3Irrational/Equality.lean b/Zeta3Irrational/Equality.lean +index 4fc5c29..0beb8e6 100644 +--- a/Zeta3Irrational/Equality.lean ++++ b/Zeta3Irrational/Equality.lean +@@ -27,10 +27,10 @@ lemma integral_equality_help (s t : ℝ) (s0 : 0 < s) (s1 : s < 1) (t0 : 0 < t) + · ring_nf + · have _ : 0 < (1 - (1 - s) * t) * ((1 - (1 - u) * s) * (1 - (1 - t) * u)) := by + rw[mul_pos_iff_of_pos_left, mul_pos_iff_of_pos_left] <;> linarith +- positivity ++ linarith + · have _ : 0 < (1 - (1 - u) * s) * (1 - (1 - t) * u) := by + rw[mul_pos_iff_of_pos_left] <;> linarith +- positivity ++ linarith + · linarith + · linarith + rw[← intervalIntegral.integral_congr] +@@ -39,22 +39,16 @@ lemma integral_equality_help (s t : ℝ) (s0 : 0 < s) (s1 : s < 1) (t0 : 0 < t) + rw[inv_eq_one_div, inv_eq_one_div, inv_eq_one_div, one_div_mul_one_div] + simp at b + rcases b with ⟨b1, b2⟩ +- rw[← not_lt] at b1 +- cases' eq_or_lt_of_not_lt b1 with b11 b12 +- · rw[b11] +- field_simp +- rw[div_eq_one_iff_eq] +- ring_nf +- have _ : 0 < 1 - (1 - s) * t := by linarith +- positivity +- · rw[← not_lt] at b2 +- cases' eq_or_lt_of_not_lt b2 with b21 b22 +- · rw[← b21] +- field_simp +- rw[div_eq_one_iff_eq] +- ring_nf +- have _ : 0 < 1 - (1 - s) * t := by linarith +- positivity ++ rcases eq_or_lt_of_le b1 with b11 | b12 ++ · rw[← b11] ++ norm_num ++ field_simp [ne_of_gt s1, ne_of_gt (sub_pos.mpr h2)] ++ ring ++ · rcases eq_or_lt_of_le b2 with b21 | b22 ++ · rw[b21] ++ norm_num ++ field_simp [ne_of_gt t0, ne_of_gt (sub_pos.mpr h2)] ++ ring + · obtain b00 := eq1 a b12 b22 + rw[b00, mul_comm] + +@@ -99,7 +93,7 @@ lemma integral_equality (s t : ℝ) (s0 : 0 < s) (s1 : s < 1) (t0 : 0 < t) (t1 : + apply IntervalIntegrable.continuousOn_mul (hg := continuousOn_const) + apply intervalIntegral.intervalIntegrable_inv + · intros x hx +- simp only [ge_iff_le, zero_le_one, Set.uIcc_of_le, Set.mem_Icc] at hx ++ simp only [zero_le_one, Set.uIcc_of_le, Set.mem_Icc] at hx + intro r + rw [sub_eq_zero] at r + have ineq3 : (1 - x) * s ≤ 1 * s := by +diff --git a/Zeta3Irrational/Integral.lean b/Zeta3Irrational/Integral.lean +index 15c6253..c732e9c 100644 +--- a/Zeta3Irrational/Integral.lean ++++ b/Zeta3Irrational/Integral.lean +@@ -2,23 +2,26 @@ + A formal proof of the irrationality of Riemann-Zeta(3). + Author: Junqi Liu and Jujian Zhang. + -/ +-import Mathlib.Analysis.Normed.Field.Instances + import Mathlib.Analysis.PSeries +-import Mathlib.Analysis.SpecialFunctions.Integrals +-import Mathlib.Data.Real.StarOrdered ++import Mathlib.Analysis.SpecialFunctions.Integrals.Basic ++import Mathlib.Analysis.Real.Sqrt + import Mathlib.MeasureTheory.Function.AEEqOfIntegral + import Mathlib.MeasureTheory.Integral.IntegralEqImproper + import Mathlib.Topology.Algebra.Module.ModuleTopology +-import Mathlib.Topology.Compactness.PseudometrizableLindelof ++import Mathlib.Topology.Metrizable.Basic ++ ++/-! Integral identities in the Apache-2.0 Apéry proof of Junqi Liu and Jujian Zhang. -/ + + open scoped Nat + open BigOperators Finset + ++/-- The real Apéry double integral with monomial weights of degrees `r` and `s`. -/ + noncomputable abbrev J (r s : ℕ) : ℝ := + ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + -(x.1 * x.2).log / (1 - x.1 * x.2) * x.1 ^ r * x.2 ^ s + +-noncomputable abbrev J_ENN (r s : ℕ) : ENNReal := ++/-- The nonnegative extended-real Apéry double integral with weights of degrees `r` and `s`. -/ ++noncomputable abbrev jENN (r s : ℕ) : ENNReal := + ∫⁻ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + ENNReal.ofReal (- (x.1 * x.2).log / (1 - x.1 * x.2) * x.1 ^ r * x.2 ^ s) + +@@ -26,7 +29,7 @@ lemma log_rpow_integral_aux (n : ℝ) (a : ℝ) (ha : 0 < a ∧ a ≤ 1) : + ∫ (x : ℝ) in Set.Ioc a 1, |-x.log * x ^ n| = ∫ (x : ℝ) in Set.Ioc a 1, -x.log * x ^ n := by + apply MeasureTheory.setIntegral_congr_fun (by measurability) + intro x hx +- simp only [gt_iff_lt, Set.mem_Ioc, neg_mul, abs_neg, abs_eq_neg_self] at * ++ simp only [Set.mem_Ioc, neg_mul, abs_neg, abs_eq_neg_self] at * + rw [mul_nonpos_iff] + right + constructor +@@ -42,7 +45,7 @@ lemma log_rpow_integral' (n : ℝ) (hn : n > -1) (a : ℝ) (ha : 0 < a ∧ a ≤ + f 1 - f a by simp[f], ← intervalIntegral.integral_of_le ha.2] + refine intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le ha.2 (a := a) (b := 1) (f := f) + (f' := fun x : ℝ => -x.log * x ^ n ) ?_ ?_ ?_ +- · simp [f] ++ · simp only [f] + refine ContinuousOn.sub (ContinuousOn.div_const ?_ (((n : ℝ) + 1) ^ 2)) ?_ + · apply ContinuousOn.rpow_const continuousOn_id + intro x hx +@@ -77,7 +80,8 @@ lemma log_rpow_integral' (n : ℝ) (hn : n > -1) (a : ℝ) (ha : 0 < a ∧ a ≤ + norm_cast + apply Real.hasDerivAt_rpow_const + left ; linarith +- · have h : x ^ n * x.log + x ^ n / (↑n + 1) = ((↑n + 1) * x ^ n * x.log + x ^ n) / (↑n + 1) := by ++ · have h : x ^ n * x.log + x ^ n / (↑n + 1) = ++ ((↑n + 1) * x ^ n * x.log + x ^ n) / (↑n + 1) := by + rw [add_div] + congr 1 + rw [eq_div_iff (by linarith)] +@@ -104,12 +108,14 @@ lemma log_rpow_integral' (n : ℝ) (hn : n > -1) (a : ℝ) (ha : 0 < a ∧ a ≤ + simp only [Set.mem_Icc, id_eq, ne_eq] at hx ⊢ + nlinarith + +-lemma log_rpow_integrable (n : ℝ) (hn : n > -1) : IntervalIntegrable (fun x ↦ -Real.log x * x ^ n) MeasureTheory.volume 0 1 := by ++lemma log_rpow_integrable (n : ℝ) (hn : n > -1) : ++ IntervalIntegrable (fun x ↦ -Real.log x * x ^ n) MeasureTheory.volume 0 1 := by + let f := fun (x : ℝ) => -x.log * x ^ n + apply MeasureTheory.IntegrableOn.intervalIntegrable + rw [Set.uIcc_of_le (by norm_num), integrableOn_Icc_iff_integrableOn_Ioc] + apply MeasureTheory.integrableOn_Ioc_of_intervalIntegral_norm_bounded_left (f := f) +- (l := Filter.atTop) (a := fun (n : ℕ) => 1 / (n + 1 : ℝ)) (a₀ := 0) (b := 1) (I := 1 / (n + 1) ^ 2) ++ (l := Filter.atTop) (a := fun (n : ℕ) => 1 / (n + 1 : ℝ)) (a₀ := 0) (b := 1) ++ (I := 1 / (n + 1) ^ 2) + · intro i + simp only [one_div, f] + have hi : 0 < ((i : ℝ) + 1)⁻¹ ∧ ((i : ℝ) + 1)⁻¹ ≤ 1 := by +@@ -137,7 +143,7 @@ lemma log_rpow_integrable (n : ℝ) (hn : n > -1) : IntervalIntegrable (fun x + · rw [log_rpow_integral' n hn] + · set k := _ + change _ - k ≤ _ +- simp only [Real.log_inv, tsub_le_iff_right, le_add_iff_nonneg_right, ++ simp only [tsub_le_iff_right, le_add_iff_nonneg_right, + sub_nonneg, k] + rw [div_le_div_iff₀ (by linarith) (by nlinarith), mul_assoc, mul_le_mul_iff_of_pos_left] + · trans 0 +@@ -164,7 +170,8 @@ lemma log_rpow_integral (n : ℝ) (hn : n > -1) : + ∫ (x : ℝ) in (0)..1, -x.log * x ^ n = 1 / (n + 1) ^ 2 := by + let F := fun (x : ℝ) => x ^ (n + 1) * (1 - (n + 1) * x.log) / (n + 1) ^ 2 + have h1 : 1 /(n + 1) ^ 2 = F 1 - F 0 := by +- simp [F] ++ simp only [F, Real.one_rpow, Real.log_one, mul_zero, sub_zero, ++ Real.log_zero, mul_one] + rw [Real.zero_rpow (by linarith), zero_div, sub_zero] + rw [h1] + refine intervalIntegral.integral_eq_sub_of_hasDerivAt_of_tendsto (by norm_num) (a := 0) (b := 1) +@@ -211,7 +218,7 @@ lemma log_rpow_integral (n : ℝ) (hn : n > -1) : + exact fun ⦃U⦄ a ↦ a + · right; linarith + · apply Filter.Tendsto.div_const +- simp [← mul_assoc, ← mul_rotate (c := n + 1)] ++ simp only [← mul_assoc, ← mul_rotate (c := n + 1)] + nth_rw 3 [show (0 : ℝ) = 0 * (n + 1) by simp] + apply Filter.Tendsto.mul_const + apply tendsto_log_mul_rpow_nhdsGT_zero +@@ -303,42 +310,22 @@ lemma ENN_pow_integral (n : ℕ) : ∫⁻ (x : ℝ) in Set.Ioo 0 1, + · tauto + · omega + +-lemma AEMeasurable_aux : AEMeasurable (fun (x : ℝ × ℝ × ℝ) ↦ ++lemma AEMeasurable_aux {r s : ℕ} : AEMeasurable (fun (x : ℝ × ℝ × ℝ) ↦ + 1 / (1 - (1 - x.2.1 * x.2.2) * x.1) * x.2.1 ^ r * x.2.2 ^ s) MeasureTheory.volume := by +- apply AEMeasurable.mul +- · apply AEMeasurable.mul +- · apply AEMeasurable.const_div +- apply AEMeasurable.const_sub +- apply AEMeasurable.mul _ (AEMeasurable.fst (f := id) aemeasurable_id) +- · apply AEMeasurable.const_sub +- apply AEMeasurable.mul +- · apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- exact AEMeasurable.fst (f := id) aemeasurable_id +- · apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- exact AEMeasurable.snd (f := id) aemeasurable_id +- · apply AEMeasurable.pow_const +- apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.1) +- exact AEMeasurable.fst (f := id) aemeasurable_id +- · apply AEMeasurable.pow_const +- apply AEMeasurable.snd (f := fun (x : ℝ × ℝ) => x.2) +- exact AEMeasurable.snd (f := id) aemeasurable_id ++ fun_prop + + lemma integral1 {a : ℝ} (ha : 0 < a) (ha1 : a < 1) : + ∫ (z : ℝ) in (0)..1, 1 / (1 - (1 - a) * z) = - a.log / (1 - a) := by + rw[← sub_pos] at ha1 + have eq1 := intervalIntegral.integral_comp_mul_left (a := 0) (b := 1) (c := 1 - a) + (f := fun z ↦ (1 - z)⁻¹) (by positivity) +- have eq2 := intervalIntegral.mul_integral_comp_sub_mul (a := 0) (b := 1 - a) (f := fun x ↦ (x)⁻¹) +- (c := 1) (d := 1) + have eq3 := integral_inv_of_pos (a := a) (b := 1) ha (by norm_num) + simp only [mul_zero, mul_one, smul_eq_mul] at eq1 + simp only [one_div] + rw [eq1, inv_mul_eq_div] + field_simp + simp only [one_div] +- simp only [one_mul, intervalIntegral.integral_comp_sub_left, sub_sub_cancel, sub_zero, +- mul_zero] at eq2 +- rw[eq3] ++ rw [intervalIntegral.integral_comp_sub_left, sub_sub_cancel, sub_zero, eq3] + simp + + lemma sub_mul_mul_ne_zero (y : ℝ) (x : ℝ × ℝ) +@@ -348,7 +335,7 @@ lemma sub_mul_mul_ne_zero (y : ℝ) (x : ℝ × ℝ) + by_cases hy' : y = 0 + · rw [hy'] + simp +- · simp only [Set.mem_prod, Set.mem_Ioo, sub_pos, Set.mem_Icc, gt_iff_lt, sub_pos] at * ++ · simp only [sub_pos, Set.mem_Icc] at * + suffices (1 - x.1 * x.2) * y < y by linarith + rwa [mul_lt_iff_lt_one_left] + rcases hy with ⟨hy1, _⟩ +@@ -357,7 +344,7 @@ lemma sub_mul_mul_ne_zero (y : ℝ) (x : ℝ × ℝ) + linarith + + lemma integrableOn_aux (x : ℝ × ℝ) +- (h1 : 0 < 1 - (1 - x.1 * x.2)) (h2 : 1 - (1 - x.1 * x.2) < 1): ++ (h1 : 0 < 1 - (1 - x.1 * x.2)) (h2 : 1 - (1 - x.1 * x.2) < 1) : + MeasureTheory.IntegrableOn (fun t ↦ 1 / (1 - (1 - x.1 * x.2) * t)) + (Set.Ioo 0 1) MeasureTheory.volume := by + rw [← integrableOn_Ioc_iff_integrableOn_Ioo] +@@ -392,8 +379,7 @@ lemma integrableOn_aux (x : ℝ × ℝ) + simp at hy + apply div_nonneg (by norm_num) + simp only [sub_nonneg] +- apply mul_le_one₀ _ (by linarith) (by linarith) +- linarith ++ exact (mul_le_of_le_one_left (by linarith) (by linarith)).trans (by linarith) + + lemma JENN_eq_triple_aux' (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) : + ∫⁻ (w : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (1 / (1 - (1 - x.1 * x.2) * w)) = +@@ -423,11 +409,10 @@ lemma JENN_eq_triple_aux' (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo + · simp only [h, true_and] at hs + apply div_nonneg (by norm_num) + simp only [sub_nonneg] +- apply mul_le_one₀ _ (by linarith) (by linarith) +- linarith ++ exact (mul_le_of_le_one_left (by linarith) (by linarith)).trans (by linarith) + · tauto + +-lemma JENN_eq_triple_aux (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) : ++lemma JENN_eq_triple_aux {r s : ℕ} (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) : + ∫⁻ (w : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (1 / (1 - (1 - x.1 * x.2) * w) * x.1 ^ r * x.2 ^ s) = + ENNReal.ofReal (-Real.log (x.1 * x.2) / (1 - x.1 * x.2) * x.1 ^ r * x.2 ^ s) := by + calc +@@ -454,11 +439,11 @@ lemma JENN_eq_triple_aux (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 + · simp only [Left.nonneg_neg_iff] + apply Real.log_nonpos + · apply mul_nonneg (by linarith) (by linarith) +- · apply mul_le_one₀ (by linarith) (by linarith) (by linarith) ++ · exact (mul_le_of_le_one_left (by linarith) (by linarith)).trans (by linarith) + · simp only [sub_nonneg] +- apply mul_le_one₀ (by linarith) (by linarith) (by linarith) ++ exact (mul_le_of_le_one_left (by linarith) (by linarith)).trans (by linarith) + +-lemma JENN_eq_triple (r s : ℕ) : J_ENN r s = ++lemma JENN_eq_triple (r s : ℕ) : jENN r s = + ∫⁻ (x : ℝ × ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + ENNReal.ofReal (1 / (1 - (1 - x.2.1 * x.2.2) * x.1) * x.2.1 ^ r * x.2.2 ^ s) := by + symm +@@ -480,11 +465,12 @@ lemma JENN_eq_triple (r s : ℕ) : J_ENN r s = + exact AEMeasurable_aux + _ = ∫⁻ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + ENNReal.ofReal (- (x.1 * x.2).log / (1 - x.1 * x.2) * x.1 ^ r * x.2 ^ s) := by +- apply MeasureTheory.setLIntegral_congr_fun (by measurability) <| Filter.Eventually.of_forall ?_ ++ apply MeasureTheory.setLIntegral_congr_fun (by measurability) + intro x hx ++ dsimp only + rw [JENN_eq_triple_aux _ hx] + +-lemma AEMeasurable_aux' : AEMeasurable ++lemma AEMeasurable_aux' {k r s : ℕ} : AEMeasurable + (fun x ↦ ENNReal.ofReal (-Real.log (x.1 * x.2) * x.1 ^ (k + r) * x.2 ^ (k + s))) + (MeasureTheory.volume.restrict (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1)) := by + apply AEMeasurable.ennreal_ofReal +@@ -551,10 +537,12 @@ lemma aux_lintegral3 (k r s : ℕ) : ∫⁻ (x : ℝ) in Set.Ioo 0 1, + ENNReal.ofReal (-x.log * x ^ (k + r) / (k + s + 1)) + = ENNReal.ofReal (1 / ((k + r + 1) ^ 2 * (k + s + 1))) := by + calc +- _ = (∫⁻ (x : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (-x.log * x ^ (k + r))) * ENNReal.ofReal (1 / (k + s + 1)) := by ++ _ = (∫⁻ (x : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (-x.log * x ^ (k + r))) * ++ ENNReal.ofReal (1 / (k + s + 1)) := by + rw [← MeasureTheory.lintegral_mul_const] +- · apply MeasureTheory.setLIntegral_congr_fun (by measurability) <| Filter.Eventually.of_forall ?_ ++ · apply MeasureTheory.setLIntegral_congr_fun (by measurability) + rintro y ⟨hy1, hy2⟩ ++ dsimp only + rw [← ENNReal.ofReal_mul] + · field_simp + simp only [neg_mul, Left.nonneg_neg_iff] +@@ -575,10 +563,12 @@ lemma aux_lintegral4 (k r s : ℕ) : ∫⁻ (x : ℝ) in Set.Ioo 0 1, + ENNReal.ofReal (x ^ (k + r) / (k + s + 1) ^ 2) + = ENNReal.ofReal (1 / ((k + r + 1) * (k + s + 1) ^ 2)) := + calc +- _ = (∫⁻ (x : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (x ^ (k + r))) * ENNReal.ofReal (1 / (k + s + 1) ^ 2) := by ++ _ = (∫⁻ (x : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (x ^ (k + r))) * ++ ENNReal.ofReal (1 / (k + s + 1) ^ 2) := by + rw [← MeasureTheory.lintegral_mul_const] +- · apply MeasureTheory.setLIntegral_congr_fun (by measurability) <| Filter.Eventually.of_forall ?_ ++ · apply MeasureTheory.setLIntegral_congr_fun (by measurability) + rintro y ⟨hy1, hy2⟩ ++ dsimp only + rw [← ENNReal.ofReal_mul] + · field_simp + positivity +@@ -588,7 +578,7 @@ lemma aux_lintegral4 (k r s : ℕ) : ∫⁻ (x : ℝ) in Set.Ioo 0 1, + · norm_cast + · positivity + +-lemma J_ENN_rs_eq_tsum_aux_intergal (r s k : ℕ): ++lemma J_ENN_rs_eq_tsum_aux_intergal (r s k : ℕ) : + ∫⁻ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + ENNReal.ofReal (- (x.1 * x.2).log * x.1 ^ (k + r) * x.2 ^ (k + s)) = ENNReal.ofReal + (1 / ((k + r + 1) ^ 2 * (k + s + 1)) + 1 / ((k + r + 1) * (k + s + 1) ^ 2)) := by +@@ -597,14 +587,17 @@ lemma J_ENN_rs_eq_tsum_aux_intergal (r s k : ℕ): + · calc + _ = ∫⁻ (x : ℝ) in Set.Ioo 0 1, + ENNReal.ofReal (- x.log * x ^ (k + r) / (k + s + 1) + x ^ (k + r) / (k + s + 1) ^ 2) := by +- apply MeasureTheory.setLIntegral_congr_fun (by measurability) <| Filter.Eventually.of_forall ?_ ++ apply MeasureTheory.setLIntegral_congr_fun (by measurability) + intro x hx ++ dsimp only + simp only [neg_mul] +- have h2 : ∫⁻ (y : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (-((x * y).log * x ^ (k + r) * y ^ (k + s))) ++ have h2 : ∫⁻ (y : ℝ) in Set.Ioo 0 1, ++ ENNReal.ofReal (-((x * y).log * x ^ (k + r) * y ^ (k + s))) + = ∫⁻ (y : ℝ) in Set.Ioo 0 1, ENNReal.ofReal (-(x.log * x ^ (k + r) * y ^ (k + s))) + + ENNReal.ofReal (-(y.log * x ^ (k + r) * y ^ (k + s))) := by +- apply MeasureTheory.setLIntegral_congr_fun (by measurability) <| Filter.Eventually.of_forall ?_ ++ apply MeasureTheory.setLIntegral_congr_fun (by measurability) + intro y hy ++ dsimp only + simp only [← neg_mul] + simp only [Set.mem_Ioo] at hx hy + rw [Real.log_mul (by linarith) (by linarith), neg_add, add_mul, add_mul, +@@ -639,9 +632,11 @@ lemma J_ENN_rs_eq_tsum_aux_intergal (r s k : ℕ): + have h2 : ∫⁻ (x : ℝ) in Set.Ioo 0 1, + ENNReal.ofReal (- x.log * x ^ (k + r) / (k + s + 1) + x ^ (k + r) / (k + s + 1) ^ 2) + = ∫⁻ (x : ℝ) in Set.Ioo 0 1, +- ENNReal.ofReal (-x.log * x ^ (k + r) / (k + s + 1)) + ENNReal.ofReal (x ^ (k + r) / (k + s + 1) ^ 2) := by +- apply MeasureTheory.setLIntegral_congr_fun (by measurability) <| Filter.Eventually.of_forall ?_ ++ ENNReal.ofReal (-x.log * x ^ (k + r) / (k + s + 1)) + ++ ENNReal.ofReal (x ^ (k + r) / (k + s + 1) ^ 2) := by ++ apply MeasureTheory.setLIntegral_congr_fun (by measurability) + rintro x ⟨hx1, hx2⟩ ++ dsimp only + rw [ENNReal.ofReal_add] + · apply div_nonneg _ (by positivity) + apply mul_nonneg _ (by apply pow_nonneg (by linarith)) +@@ -649,10 +644,8 @@ lemma J_ENN_rs_eq_tsum_aux_intergal (r s k : ℕ): + apply Real.log_nonpos (by nlinarith) (by nlinarith) + · apply div_nonneg _ (by positivity) + apply pow_nonneg (by linarith) +- + rw [h2, MeasureTheory.lintegral_add_left'] +- · simp only [Set.mem_Ioo] at h2 +- rw [aux_lintegral3 k r s, aux_lintegral4 k r s, ENNReal.ofReal_add] ++ · rw [aux_lintegral3 k r s, aux_lintegral4 k r s, ENNReal.ofReal_add] + · apply div_nonneg (by norm_num) (by positivity) + · apply div_nonneg (by norm_num) (by positivity) + · apply AEMeasurable.ennreal_ofReal +@@ -665,12 +658,12 @@ lemma J_ENN_rs_eq_tsum_aux_intergal (r s k : ℕ): + · rw [MeasureTheory.Measure.prod_restrict, ← MeasureTheory.Measure.volume_eq_prod] + exact AEMeasurable_aux' + +-lemma J_ENN_rs_eq_tsum (r s : ℕ) : J_ENN r s = ∑' (k : ℕ), ENNReal.ofReal ++lemma J_ENN_rs_eq_tsum (r s : ℕ) : jENN r s = ∑' (k : ℕ), ENNReal.ofReal + (1 / ((k + r + 1) ^ 2 * (k + s + 1)) + 1 / ((k + r + 1) * (k + s + 1) ^ 2)) := by + calc + _ = ∫⁻ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + ∑' (k : ℕ), ENNReal.ofReal (- (x.1 * x.2).log * x.1 ^ (k + r) * x.2 ^ (k + s)) := by +- rw [J_ENN, ← MeasureTheory.lintegral_indicator (by measurability), ++ rw [jENN, ← MeasureTheory.lintegral_indicator (by measurability), + ← MeasureTheory.lintegral_indicator (by measurability)] + congr + ext y +@@ -711,9 +704,9 @@ lemma J_ENN_rs_eq_tsum (r s : ℕ) : J_ENN r s = ∑' (k : ℕ), ENNReal.ofReal + (1 / ((k + r + 1) ^ 2 * (k + s + 1)) + 1 / ((k + r + 1) * (k + s + 1) ^ 2)) := by + simp_rw [J_ENN_rs_eq_tsum_aux_intergal r s] + +-lemma J_ENN_rr (r : ℕ) : J_ENN r r = ENNReal.ofReal ++lemma J_ENN_rr (r : ℕ) : jENN r r = ENNReal.ofReal + (2 * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 - 2 * ∑ m ∈ Finset.Icc 1 r, 1 / (m : ℝ) ^ 3) := by +- have h : J_ENN r r = ∑' (k : ℕ), ENNReal.ofReal (2 / ((k + r + 1) ^ 3)) := by ++ have h : jENN r r = ∑' (k : ℕ), ENNReal.ofReal (2 / ((k + r + 1) ^ 3)) := by + rw [J_ENN_rs_eq_tsum r r] + congr + ext k +@@ -724,13 +717,13 @@ lemma J_ENN_rr (r : ℕ) : J_ENN r r = ENNReal.ofReal + 2 * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 - 2 * ∑ m ∈ Finset.Icc 1 r, 1 / (m : ℝ) ^ 3 := by + symm + apply sub_eq_of_eq_add +- rw [← sum_add_tsum_nat_add' (k := r) (f := fun k => 1 / ((k : ℝ) + 1) ^ 3), mul_add, add_comm, +- ← tsum_mul_left] +- · simp only [mul_one_div, ← two_mul, ← mul_assoc, ← mul_add] ++ rw [← Summable.sum_add_tsum_nat_add' (k := r) (f := fun k => 1 / ((k : ℝ) + 1) ^ 3), ++ mul_add, add_comm, ← tsum_mul_left] ++ · simp only [mul_one_div] + congr 1 + · norm_cast + · congr 1 +- rw [← Nat.Ico_succ_right, Nat.succ_eq_add_one] ++ rw [← Finset.Ico_add_one_right_eq_Icc] + have h1 := Finset.sum_Ico_eq_sum_range (m := 1) (n := r + 1) (f := fun k => 1 / (k : ℝ) ^ 3) + simp only [add_tsub_cancel_right, Nat.cast_add, Nat.cast_one] at h1 + simp only [h1, add_comm] +@@ -746,13 +739,13 @@ lemma J_ENN_rr (r : ℕ) : J_ENN r r = ENNReal.ofReal + simp only [add_assoc, Nat.cast_pow] + rw [summable_nat_add_iff (k := r + 1) (f := fun k => 2 / (k ^ 3 : ℝ))] + have h2 := Real.summable_one_div_nat_pow (p := 3) +- simp only [Real.summable_nat_pow_inv, Nat.one_lt_ofNat] at h2 ++ simp only [Nat.one_lt_ofNat] at h2 + apply Iff.symm at h2 + rw [true_iff, ← summable_mul_left_iff (a := 2) (by norm_num)] at h2 + simp only [mul_one_div] at h2 + exact h2 + +-lemma fun_of_J_nonneg (r s: ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) : ++lemma fun_of_J_nonneg (r s : ℕ) (x : ℝ × ℝ) (hx : x ∈ Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) : + 0 ≤ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * x.1 ^ r * x.2 ^ s := by + simp only [Set.mem_prod, Set.mem_Ioo] at hx + apply mul_nonneg +@@ -770,7 +763,7 @@ lemma integrableOn_J_rr (r : ℕ) : MeasureTheory.IntegrableOn + (fun x ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * x.1 ^ r * x.2 ^ r) + (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) MeasureTheory.volume := by + have h := J_ENN_rr r +- simp only [J_ENN] at h ++ simp only [jENN] at h + rw [MeasureTheory.IntegrableOn, MeasureTheory.Integrable] + constructor + · apply AEMeasurable.aestronglyMeasurable +@@ -811,17 +804,18 @@ lemma integrableOn_J_rr (r : ℕ) : MeasureTheory.IntegrableOn + theorem J_rr (r : ℕ) : + J r r = 2 * ∑' n : ℕ , 1 / ((n : ℝ) + 1) ^ 3 - 2 * ∑ m ∈ Finset.Icc 1 r, 1 / (m : ℝ) ^ 3 := by + have h := J_ENN_rr r +- simp only [J_ENN] at h ++ simp only [jENN] at h + rw [J, MeasureTheory.integral_eq_lintegral_of_nonneg_ae, h, ENNReal.toReal_ofReal_eq_iff] +- · simp only [sub_nonneg, Nat.ofNat_pos, mul_le_mul_left] +- rw [← Nat.Ico_succ_right, Nat.succ_eq_add_one] ++ · simp only [sub_nonneg] ++ apply mul_le_mul_of_nonneg_left ?_ (by norm_num) ++ rw [← Finset.Ico_add_one_right_eq_Icc] + nth_rw 1 [← zero_add (a := 1)] + rw [← Finset.sum_Ico_add' (c := 1)] + norm_cast +- apply sum_le_tsum ++ apply Summable.sum_le_tsum + · intro i _; positivity + · norm_cast +- simp only [add_assoc, Nat.cast_pow] ++ simp only [Nat.cast_pow] + rw [summable_nat_add_iff (k := 1) (f := fun k => 1 / (k ^ 3 : ℝ)), + Real.summable_one_div_nat_pow (p := 3)] + norm_num +@@ -868,7 +862,7 @@ lemma summable_aux (r : ℕ) : Summable fun (b : ℕ) ↦ 1 / ((b : ℝ) + r + 1 + norm_num + + lemma J_ENN_rs (r s : ℕ) (h : r > s) : +- J_ENN r s = ENNReal.ofReal ((∑ k ∈ Finset.Ioc s r, 1 / (k : ℝ) ^ 2) / (r - s)) := by ++ jENN r s = ENNReal.ofReal ((∑ k ∈ Finset.Ioc s r, 1 / (k : ℝ) ^ 2) / (r - s)) := by + calc + _ = ∑' (k : ℕ), ENNReal.ofReal (1 / (r - s) * (1 / (k + s + 1) ^ 2 - 1 / (k + r + 1) ^ 2)) := by + rw [J_ENN_rs_eq_tsum] +@@ -906,15 +900,17 @@ lemma J_ENN_rs (r s : ℕ) (h : r > s) : + rw [← ENNReal.ofReal_tsum_of_nonneg] + · rw [ENNReal.ofReal_eq_ofReal_iff] + · simp only [mul_sub] +- · rw [tsum_sub] ++ · rw [Summable.tsum_sub] + · simp only [sum_div, div_div, ← one_div_mul_one_div_rev] + apply sub_eq_of_eq_add +- rw [← sum_add_tsum_nat_add' (f := fun n => 1 / (r - s) * (1 / (n + (s : ℝ) + 1) ^ 2)) (k := r - s)] ++ rw [← Summable.sum_add_tsum_nat_add' ++ (f := fun n => 1 / (r - s) * (1 / (n + (s : ℝ) + 1) ^ 2)) (k := r - s)] + · congr 1 + · simp only [← Nat.cast_add, add_comm] + rw [← Finset.sum_Ico_eq_sum_range (n := r) (m := s) +- (f := fun k => 1 / (r - s) * (1 / ((k : ℝ) + 1) ^ 2)), ← Nat.Ico_succ_succ, +- Nat.succ_eq_add_one, ← Finset.sum_Ico_add' (c := 1) (b := r) (a := s)] ++ (f := fun k => 1 / (r - s) * (1 / ((k : ℝ) + 1) ^ 2)), ++ ← Finset.Ico_add_one_add_one_eq_Ioc, ++ ← Finset.sum_Ico_add' (c := 1) (b := r) (a := s)] + norm_cast + · congr + ext n +@@ -954,7 +950,7 @@ lemma integrableOn_J_rs' (r s : ℕ) (h : r > s) : MeasureTheory.IntegrableOn + (fun x ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * x.1 ^ r * x.2 ^ s) + (Set.Ioo 0 1 ×ˢ Set.Ioo 0 1) MeasureTheory.volume := by + have h₀ := J_ENN_rs r s h +- simp only [J_ENN] at h₀ ++ simp only [jENN] at h₀ + rw [MeasureTheory.IntegrableOn, MeasureTheory.Integrable] + constructor + · apply AEMeasurable.aestronglyMeasurable +@@ -995,7 +991,7 @@ lemma integrableOn_J_rs' (r s : ℕ) (h : r > s) : MeasureTheory.IntegrableOn + lemma J_rs' (r s : ℕ) (h : r > s) : + J r s = (∑ k ∈ Finset.Ioc s r, 1 / (k : ℝ) ^ 2) / (r - s) := by + have h₀ := J_ENN_rs r s h +- simp only [J_ENN] at h₀ ++ simp only [jENN] at h₀ + rw [J, MeasureTheory.integral_eq_lintegral_of_nonneg_ae, h₀, ENNReal.toReal_ofReal_eq_iff] + · rw [sum_div] + apply sum_nonneg +@@ -1024,7 +1020,7 @@ lemma J_rs' (r s : ℕ) (h : r > s) : + · apply Measurable.pow measurable_fst measurable_const + · apply Measurable.pow measurable_snd measurable_const + +-lemma J_ENN_rs_symm (r s : ℕ) : J_ENN r s = J_ENN s r := by ++lemma J_ENN_rs_symm (r s : ℕ) : jENN r s = jENN s r := by + simp only [J_ENN_rs_eq_tsum, add_comm, mul_comm] + + lemma integrableOn_J_rs (r s : ℕ) : MeasureTheory.IntegrableOn +@@ -1073,12 +1069,12 @@ lemma integrableOn_J_rs (r s : ℕ) : MeasureTheory.IntegrableOn + · simp only [hx, ↓reduceIte] + have h₀ := J_ENN_rs s r h2 + rw [J_ENN_rs_symm s r] at h₀ +- simp only [J_ENN] at h₀ ++ simp only [jENN] at h₀ + rw [h1, h₀] + simp only [one_div, ENNReal.ofReal_lt_top] + +-lemma J_eq_toReal_J_ENN (r s : ℕ) : J r s = (J_ENN r s).toReal := by +- rw [J, J_ENN, MeasureTheory.integral_eq_lintegral_of_nonneg_ae] ++lemma J_eq_toReal_J_ENN (r s : ℕ) : J r s = (jENN r s).toReal := by ++ rw [J, jENN, MeasureTheory.integral_eq_lintegral_of_nonneg_ae] + · apply MeasureTheory.ae_nonneg_restrict_of_forall_setIntegral_nonneg_inter + · exact integrableOn_J_rs r s + · rintro x hx - +@@ -1105,16 +1101,16 @@ theorem J_rs {r s : ℕ} (h : r ≠ s) : J r s = + (∑ m ∈ Icc 1 r, 1 / (m : ℝ) ^ 2 - ∑ m ∈ Icc 1 s, 1 / (m : ℝ) ^ 2) / (r - s) := by + by_cases h1 : r > s + · simp only [J_rs' r s h1, sub_div, sum_div] +- rw [← Nat.Ico_succ_succ, Finset.sum_Ico_eq_sub] ++ rw [← Finset.Ico_add_one_add_one_eq_Ioc, Finset.sum_Ico_eq_sub] + · congr 1 + · rw [← Finset.sum_range_add_sum_Ico (n := r + 1) (m := 1) _ (by omega)] + simp only [range_one, one_div, sum_singleton, CharP.cast_eq_zero, ne_eq, + OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, inv_zero, zero_div, zero_add] +- rw [ Nat.Ico_succ_right] ++ rw [ Finset.Ico_add_one_right_eq_Icc] + · rw [← Finset.sum_range_add_sum_Ico (n := s + 1) (m := 1) _ (by omega)] + simp only [range_one, one_div, sum_singleton, CharP.cast_eq_zero, ne_eq, + OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, inv_zero, zero_div, zero_add] +- rw [ Nat.Ico_succ_right] ++ rw [ Finset.Ico_add_one_right_eq_Icc] + · linarith + · simp only [gt_iff_lt, not_lt] at h1 + have h2 : s > r := by +@@ -1123,14 +1119,14 @@ theorem J_rs {r s : ℕ} (h : r ≠ s) : J r s = + nth_rw 2 [← neg_div_neg_eq] + simp only [neg_sub] + congr 1 +- rw [← Nat.Ico_succ_succ, Finset.sum_Ico_eq_sub] ++ rw [← Finset.Ico_add_one_add_one_eq_Ioc, Finset.sum_Ico_eq_sub] + · congr 1 + · rw [← Finset.sum_range_add_sum_Ico (n := s + 1) (m := 1) _ (by omega)] + simp only [range_one, one_div, sum_singleton, CharP.cast_eq_zero, ne_eq, +- OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, inv_zero, zero_div, zero_add] +- rw [ Nat.Ico_succ_right] ++ OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, inv_zero, zero_add] ++ rw [ Finset.Ico_add_one_right_eq_Icc] + · rw [← Finset.sum_range_add_sum_Ico (n := r + 1) (m := 1) _ (by omega)] + simp only [range_one, one_div, sum_singleton, CharP.cast_eq_zero, ne_eq, +- OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, inv_zero, zero_div, zero_add] +- rw [ Nat.Ico_succ_right] ++ OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, inv_zero, zero_add] ++ rw [ Finset.Ico_add_one_right_eq_Icc] + · linarith +diff --git a/Zeta3Irrational/LegendrePoly.lean b/Zeta3Irrational/LegendrePoly.lean +index d682b28..9541b4c 100644 +--- a/Zeta3Irrational/LegendrePoly.lean ++++ b/Zeta3Irrational/LegendrePoly.lean +@@ -1,16 +1,18 @@ +-import Mathlib.Algebra.Lie.OfAssociative + import Mathlib.Algebra.Polynomial.Derivative + import Mathlib.Algebra.Polynomial.Eval.SMul ++import Mathlib.RingTheory.Polynomial.ShiftedLegendre + import Mathlib.Analysis.Calculus.Deriv.Inv + import Mathlib.Analysis.Calculus.Deriv.Pow +-import Mathlib.Data.Real.StarOrdered +-import Mathlib.MeasureTheory.Integral.IntegrationByParts ++import Mathlib.Analysis.Calculus.Deriv.Polynomial ++import Mathlib.Analysis.Real.Sqrt ++import Mathlib.Topology.Algebra.Polynomial ++import Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts + + /-! + # Legendre Polynomials + +-In this file, we define the shiftedLegendre polynomials `shiftedLegendre n` for `n : ℕ` as a +-polynomial in `ℤ[X]`. We prove some basic properties of the shiftedLegendre polynomials. ++We use the real shifted Legendre polynomials `aperyShiftedLegendre n` for `n : ℕ` as ++a polynomial in `ℝ[X]`. We prove some basic properties of the aperyShiftedLegendre polynomials. + + -/ + +@@ -21,71 +23,42 @@ variable {R : Type*} + + namespace Polynomial + +-/-- `shiftedLegendre n` is the polynomial defined in terms of derivatives of order n. -/ +-noncomputable def shiftedLegendre (n : ℕ) : ℝ[X] := +- C (n ! : ℝ)⁻¹ * derivative^[n] (X ^ n * (1 - X) ^ n) ++/-- The real shifted Legendre polynomial, obtained from Mathlib's integer polynomial. -/ ++noncomputable def aperyShiftedLegendre (n : ℕ) : ℝ[X] := ++ (shiftedLegendre n).map (Int.castRingHom ℝ) ++ ++/-- The canonical polynomial has exactly the Rodrigues normalization used in the source. -/ ++lemma aperyShiftedLegendre_eq_rodrigues (n : ℕ) : ++ aperyShiftedLegendre n = C (n ! : ℝ)⁻¹ * derivative^[n] (X ^ n * (1 - X) ^ n) := by ++ have h := congrArg (Polynomial.map (Int.castRingHom ℝ)) ++ (factorial_mul_shiftedLegendre_eq n) ++ have h' : C (n ! : ℝ) * aperyShiftedLegendre n = ++ derivative^[n] (X ^ n * (1 - X) ^ n) := by ++ simpa only [aperyShiftedLegendre, Polynomial.map_mul, Polynomial.map_natCast, ++ ← iterate_derivative_map, Polynomial.map_pow, Polynomial.map_sub, ++ Polynomial.map_one, Polynomial.map_X, C_eq_natCast] using h ++ rw [← h', ← mul_assoc, ← C_mul, inv_mul_cancel₀ (by positivity), C_1, one_mul] + + lemma Finsum_iterate_deriv [CommRing R] (k : ℕ) (h : ℕ → ℕ) : + derivative^[k] (∑ m ∈ Finset.range (k + 1), (h m) • ((-1) ^ m : R[X]) * X ^ (k + m)) = + ∑ m ∈ Finset.range (k + 1), (h m) • (-1) ^ m * derivative^[k] (X ^ (k + m)) := by +- induction' k + 1 with n hn +- · simp only [Nat.zero_eq, Finset.range_zero, Finset.sum_empty, iterate_map_zero] +- · rw[Finset.sum_range, Finset.sum_range, Fin.sum_univ_castSucc, Fin.sum_univ_castSucc] at * +- simp only [Fin.coe_castSucc, Fin.val_last, iterate_map_add, hn, add_right_inj] +- rw [nsmul_eq_mul, mul_assoc, ← nsmul_eq_mul, Polynomial.iterate_derivative_smul, nsmul_eq_mul, +- mul_assoc] +- rcases n.even_or_odd with (hn1 | hn2) +- · simp_all only [nsmul_eq_mul, Int.even_coe_nat, Even.neg_pow, one_pow, one_mul] +- · rw [Odd.neg_one_pow] +- simp only [neg_mul, one_mul, iterate_map_neg, mul_neg] +- exact_mod_cast hn2 ++ simp only [iterate_derivative_sum] ++ congr! 1 with m _ ++ rw [show (h m) • ((-1) ^ m : R[X]) = C ((h m : R) * (-1) ^ m) by simp, ++ iterate_derivative_C_mul] + +-/-- The expand of `shiftedLegendre n`. -/ +-theorem shiftedLegendre_eq_sum (n : ℕ) : shiftedLegendre n = ∑ k ∈ Finset.range (n + 1), +- C ((-1) ^ k : ℝ) * (Nat.choose n k : ℝ[X]) * (Nat.choose (n + k) n : ℝ[X]) * X ^ k := by +- have h : ((X : ℝ[X]) - X ^ 2) ^ n = +- ∑ m ∈ range (n + 1), n.choose m • (- 1) ^ m * X ^ (n + m) := by +- rw[sub_eq_add_neg, add_comm, add_pow] +- congr! 1 with m hm +- rw[neg_pow, pow_two, mul_pow,← mul_assoc, mul_comm, mul_assoc, pow_mul_pow_sub, mul_assoc, +- ← pow_add, ← mul_assoc, nsmul_eq_mul, add_comm] +- rw[Finset.mem_range] at hm +- linarith +- rw [shiftedLegendre, ← mul_pow, mul_one_sub, ← pow_two, h, Finsum_iterate_deriv, +- Finset.mul_sum] +- congr! 1 with x _ +- rw [← mul_assoc, Polynomial.iterate_derivative_X_pow_eq_smul, Nat.descFactorial_eq_div +- (by omega), show n + x - n = x by omega, nsmul_eq_mul, ← mul_assoc, mul_assoc, +- mul_comm] +- simp only [Int.reduceNeg, map_pow, map_neg, map_one] +- rw [Algebra.smul_def, algebraMap_eq, map_natCast, ← mul_assoc, ← mul_assoc, add_comm, +- Nat.add_choose, mul_assoc, mul_assoc, mul_assoc, mul_assoc, mul_assoc, mul_comm] +- nth_rewrite 5 [mul_comm] +- congr 1 +- nth_rewrite 2 [mul_comm] +- rw [← mul_assoc, ← mul_assoc, ← mul_assoc] +- congr 1 +- nth_rewrite 3 [mul_comm] +- congr 1 +- apply Polynomial.ext +- intro m +- simp only [one_div, coeff_mul_C, coeff_natCast_ite, Nat.cast_ite, CharP.cast_eq_zero, ite_mul, +- zero_mul] +- by_cases h : m = 0 +- · simp [h] +- rw [Nat.cast_div] +- · rw [← one_div, ← div_mul_eq_div_mul_one_div] +- norm_cast +- rw [Nat.cast_div] +- · exact Nat.factorial_mul_factorial_dvd_factorial_add x n +- · norm_cast +- apply mul_ne_zero (Nat.factorial_ne_zero x) (Nat.factorial_ne_zero n) +- · exact Nat.factorial_dvd_factorial (by omega) +- · norm_cast; exact Nat.factorial_ne_zero x +- · simp only [h, ↓reduceIte] ++/-- The expand of `aperyShiftedLegendre n`. -/ ++theorem shiftedLegendre_eq_sum (n : ℕ) : aperyShiftedLegendre n = ++ ∑ k ∈ Finset.range (n + 1), ++ C ((-1) ^ k : ℝ) * (Nat.choose n k : ℝ[X]) * ++ (Nat.choose (n + k) n : ℝ[X]) * X ^ k := by ++ simp only [aperyShiftedLegendre, shiftedLegendre, Polynomial.map_sum, ++ Polynomial.map_mul, Polynomial.map_pow, Polynomial.map_X, ++ map_mul, map_pow, map_neg, map_one, map_natCast, ++ Polynomial.map_neg, Polynomial.map_one, Polynomial.map_natCast] + +-/-- `shiftedLegendre n` is an integer polynomial. -/ +-lemma shiftedLegendre_eq_int_poly (n : ℕ) : ∃ a : ℕ → ℤ, shiftedLegendre n = ++/-- `aperyShiftedLegendre n` is an integer polynomial. -/ ++lemma shiftedLegendre_eq_int_poly (n : ℕ) : ∃ a : ℕ → ℤ, aperyShiftedLegendre n = + ∑ k ∈ Finset.range (n + 1), (a k : ℝ[X]) * X ^ k := by + simp_rw [shiftedLegendre_eq_sum] + use fun k => (- 1) ^ k * (Nat.choose n k) * (Nat.choose (n + k) n) +@@ -99,40 +72,14 @@ lemma deriv_one_sub_X {n i : ℕ} : (⇑derivative)^[i] ((1 - X) ^ n : ℝ[X]) = + Polynomial.iterate_derivative_X_pow_eq_smul, Algebra.smul_def, algebraMap_eq, map_natCast] + simp + +-/-- The values ​​of the shiftedLegendre polynomial at x and 1-x differ by a factor (-1)ⁿ. -/ +--- lemma shiftedLegendre_eval_symm (n : ℕ) (x : ℝ) : +--- eval x (shiftedLegendre n) = (-1) ^ n * eval (1 - x) (shiftedLegendre n) := by +--- rw [mul_comm] +--- simp only [shiftedLegendre, eval_mul, one_div, eval_C] +--- rw [mul_assoc] +--- simp only [mul_eq_mul_left_iff, inv_eq_zero, Nat.cast_eq_zero]; left +--- rw [Polynomial.iterate_derivative_mul] +--- simp only [Nat.succ_eq_add_one, nsmul_eq_mul] +--- rw [Polynomial.eval_finset_sum, Polynomial.eval_finset_sum, ← Finset.sum_flip, Finset.sum_mul] +--- congr! 1 with i hi +--- simp only [Polynomial.iterate_derivative_X_pow_eq_smul, eval_mul, eval_natCast, +--- Algebra.smul_mul_assoc, eval_smul, eval_mul, eval_pow, eval_X, smul_eq_mul] +--- simp only [Finset.mem_range, Nat.lt_add_one_iff] at hi +--- rw [Nat.choose_symm hi, deriv_one_sub_X, deriv_one_sub_X] +--- simp only [nsmul_eq_mul, eval_mul, eval_pow, eval_neg, eval_one, eval_natCast, eval_sub, eval_X, +--- sub_sub_cancel] +--- rw [mul_assoc] +--- simp only [mul_eq_mul_left_iff, Nat.cast_eq_zero]; left +--- rw [show n - (n - i) = i by omega, ← mul_assoc, ← mul_assoc, mul_comm, ← mul_assoc] +--- symm +--- rw [← mul_assoc] +--- nth_rewrite 4 [mul_comm] +--- rw [← mul_assoc, ← mul_assoc, mul_assoc] +--- congr 1 +--- rw [← pow_add, show i + n = n - i + 2 * i by omega, pow_add] +--- simp only [even_two, Even.mul_right, Even.neg_pow, one_pow, mul_one] +- + theorem differentiableAt_inv_special {x a : ℝ} {n : ℕ} + (ha : a > 0) (hx : 1 - a * x = 0) : + ¬DifferentiableAt ℝ (fun x ↦ ↑n ! * a ^ n / (1 - a * x) ^ (n + 1)) x := by + intro h + obtain q := h.continuousAt +- simp [Metric.continuousAt_iff, Real.dist_eq, hx] at q ++ simp only [Metric.continuousAt_iff, gt_iff_lt, Real.dist_eq, hx, ne_eq, ++ Nat.add_eq_zero_iff, one_ne_zero, and_false, not_false_eq_true, zero_pow, div_zero, ++ dist_zero_right, norm_div, norm_mul, RCLike.norm_natCast, norm_pow, Real.norm_eq_abs] at q + have h₁ : ↑n ! * |a| ^ n > 0 := by + apply mul_pos + · simp only [Nat.cast_pos] +@@ -150,19 +97,20 @@ theorem differentiableAt_inv_special {x a : ℝ} {n : ℕ} + suffices 0 < q * a * q by linarith + exact mul_pos (mul_pos qq ha) qq + _ < 1 / 2 * q := by +- rw [mul_lt_mul_right (a := q) qq] ++ rw [mul_lt_mul_iff_left₀ qq] + linarith + _ < q := by linarith + specialize qqq this + rw [div_lt_iff₀] at qqq + · have : 1 < |1 - a * (a * q / 2 * q + x)| ^ (n + 1) := by +- rwa [← mul_lt_mul_left (a := ↑n ! * |a| ^ n) h₁, mul_one] ++ rwa [← mul_lt_mul_iff_right₀ h₁, mul_one] + rw [mul_add, add_comm, ← sub_sub, hx, zero_sub, abs_neg] at this + have : |a * (a * q / 2 * q)| ^ (n + 1) < 1 := by +- apply pow_lt_one₀ (by simp) _ (by omega) ++ apply pow_lt_one₀ (abs_nonneg _) _ (by omega) + · nth_rewrite 2 [mul_comm] + rw [← mul_assoc, ← mul_div_assoc, ← pow_two] +- rw [show |((a * q) ^ 2 / 2 : ℝ)| = ((a * q) ^ 2 / 2 : ℝ) by exact abs_eq_self.2 (by positivity)] ++ rw [show |((a * q) ^ 2 / 2 : ℝ)| = ((a * q) ^ 2 / 2 : ℝ) by ++ exact abs_eq_self.2 (by positivity)] + trans 1 / 2 + · rw [div_lt_div_iff_of_pos_right (by norm_num), ← one_pow (n := 2)] + apply pow_lt_pow_left₀ <;> nlinarith +@@ -175,13 +123,13 @@ theorem differentiableAt_inv_special {x a : ℝ} {n : ℕ} + rw [← mul_assoc, ← mul_div_assoc, ← pow_two] + positivity + · have : |q / 2 + x - x| < q := by +- simp only [one_div, add_sub_cancel_right] ++ simp only [add_sub_cancel_right] + rw [show |(q / 2 : ℝ)| = (q / 2 : ℝ) by exact abs_eq_self.2 (by linarith)] + linarith + specialize qqq this + rw [div_lt_iff₀] at qqq + · have : 1 < |1 - a * (q / 2 + x)| ^ (n + 1) := by +- rwa [← mul_lt_mul_left (a := ↑n ! * |a| ^ n) h₁, mul_one] ++ rwa [← mul_lt_mul_iff_right₀ h₁, mul_one] + rw [mul_add, add_comm, ← sub_sub, hx, zero_sub, abs_neg, ← mul_div_assoc, h2] at this + have : 1 < (1 / 2 : ℝ) := by + suffices (1 : ℝ) ≥ |(1 / 2 : ℝ)| ^ (n + 1) by linarith +@@ -192,8 +140,7 @@ theorem differentiableAt_inv_special {x a : ℝ} {n : ℕ} + rw [abs_pos] + linarith + · have : |1 / a + x - x| < q := by +- simp only [one_div, add_sub_cancel_right] +- rw [← one_div] ++ simp only [add_sub_cancel_right] + have : |(1 / a : ℝ)| = (1 / a : ℝ) := by + rw [abs_eq_self, one_div_nonneg] + linarith +@@ -201,7 +148,7 @@ theorem differentiableAt_inv_special {x a : ℝ} {n : ℕ} + specialize qqq this + rw [div_lt_iff₀] at qqq + · have : 1 < |1 - a * (1 / a + x)| ^ (n + 1) := by +- rwa [← mul_lt_mul_left (a := ↑n ! * |a| ^ n) h₁, mul_one] ++ rwa [← mul_lt_mul_iff_right₀ h₁, mul_one] + rw [mul_add, add_comm, ← sub_sub, hx, zero_sub, abs_neg, ← mul_div_assoc, mul_one, + div_self (by linarith)] at this + simp only [abs_one, one_pow, lt_self_iff_false] at this +@@ -211,20 +158,20 @@ theorem differentiableAt_inv_special {x a : ℝ} {n : ℕ} + + lemma n_derivative {a : ℝ} (n : ℕ) (ha : a > 0) : deriv^[n] (fun x ↦ 1 / (1 - a * x)) = + fun x ↦ (n) ! * (a ^ n) / (1 - a * x) ^ (n + 1) := by +- induction' n with n hn +- · simp +- · ext x ++ induction n with ++ | zero => simp ++ | succ n hn => ++ ext x + rcases eq_or_ne (1 - a * x) 0 with (h | hne) + · simp only [h, ne_eq, add_eq_zero, one_ne_zero, and_false, not_false_eq_true, + zero_pow, div_zero] + rw [Function.iterate_succ_apply', hn] + apply deriv_zero_of_not_differentiableAt + exact differentiableAt_inv_special ha h +- · rw [Function.iterate_succ_apply', hn, deriv_div] +- · simp only [differentiableAt_const, deriv_mul, deriv_const', zero_mul, deriv_pow'', +- mul_zero, add_zero, zero_sub] ++ · rw [Function.iterate_succ_apply', hn, deriv_fun_div] ++ · simp only [deriv_const', zero_mul, zero_sub] + rw [div_eq_div_iff] +- · rw [deriv_pow'', deriv_const_sub, deriv_const_mul] ++ · rw [deriv_fun_pow, deriv_const_sub, deriv_const_mul] + · simp only [Nat.cast_add, Nat.cast_one, add_tsub_cancel_right, deriv_id'', mul_one, + mul_neg, neg_neg] + norm_cast +@@ -253,7 +200,9 @@ theorem differentiableAt_inv_special' (c x y z : ℝ) (n : ℕ) (hc : c ≠ 0) ( + ¬DifferentiableAt ℝ (fun y ↦ c / (1 - (1 - x * y) * z) ^ (n + 1)) y := by + intro h + obtain q := h.continuousAt +- simp [Metric.continuousAt_iff, Real.dist_eq, h1] at q ++ simp only [Metric.continuousAt_iff, gt_iff_lt, Real.dist_eq, h1, ne_eq, ++ Nat.add_eq_zero_iff, one_ne_zero, and_false, not_false_eq_true, zero_pow, div_zero, ++ dist_zero_right, norm_div, Real.norm_eq_abs, norm_pow] at q + simp only [Set.mem_Ioo] at hx hz + have h₁ : |c| > 0 := by simp [hc] + specialize q (|c|) h₁ +@@ -270,9 +219,9 @@ theorem differentiableAt_inv_special' (c x y z : ℝ) (n : ℕ) (hc : c ≠ 0) ( + exact min_le_left (q / 2) (1 / |x * z|) + have hd' : 1 - (1 - x * d) * z ≠ 0 := by + suffices 1 - (1 - x * d) * z > 0 by linarith +- rw [h', show 1 - (1 - x * (d' + y)) * z = 1 - (1 - x * y) * z + x * z * d' by ring, h1, zero_add] +- apply mul_pos +- apply mul_pos (by linarith) (by linarith) ++ rw [h', show 1 - (1 - x * (d' + y)) * z = ++ 1 - (1 - x * y) * z + x * z * d' by ring, h1, zero_add] ++ refine mul_pos (mul_pos (by linarith) (by linarith)) ?_ + simp only [d'] + apply lt_min (by positivity) + simp only [one_div, inv_pos, abs_pos, ne_eq, mul_eq_zero, not_or] +@@ -290,9 +239,8 @@ theorem differentiableAt_inv_special' (c x y z : ℝ) (n : ℕ) (hc : c ≠ 0) ( + rw [← abs_one_div] + apply abs_le_abs_of_nonneg (by positivity) + simp only [d'] +- rw [abs_of_nonneg (a := x * z)] ++ rw [abs_of_nonneg (mul_nonneg (by linarith) (by linarith) : 0 ≤ x * z)] + exact min_le_right (q / 2) (1 / (x * z)) +- exact mul_nonneg (by linarith) (by linarith) + _ = 1 := by + rw [mul_div, mul_one, div_self] + simp only [ne_eq, abs_eq_zero, mul_eq_zero, not_or] +@@ -305,13 +253,14 @@ theorem differentiableAt_inv_special' (c x y z : ℝ) (n : ℕ) (hc : c ≠ 0) ( + lemma n_derivative' {x z : ℝ} (n : ℕ) (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ Set.Ioo 0 1) : + (deriv^[n] fun y ↦ 1 / (1 - (1 - x * y) * z)) = + (fun y ↦ (-1) ^ n * (n) ! * (x * z) ^ n / (1 - (1 - x * y) * z) ^ (n + 1)) := by +- induction' n with n hn +- · simp +- · ext y ++ induction n with ++ | zero => simp ++ | succ n hn => ++ ext y + rcases eq_or_ne (1 - (1 - x * y) * z) 0 with (h | hne) + · simp only [h, ne_eq, add_eq_zero, one_ne_zero, and_false, not_false_eq_true, + zero_pow, div_zero] +- simp only [Set.mem_Ioo, Set.mem_Icc] at hx hz ++ simp only [Set.mem_Ioo] at hx hz + rw [Function.iterate_succ_apply', hn] + apply deriv_zero_of_not_differentiableAt + set c := (-1) ^ n * ↑n ! * (x * z) ^ n +@@ -323,17 +272,18 @@ lemma n_derivative' {x z : ℝ} (n : ℕ) (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ S + · apply pow_ne_zero + nlinarith + exact differentiableAt_inv_special' c x y z n hc hx hz h +- · rw [Function.iterate_succ_apply', hn, deriv_div] +- · simp only [differentiableAt_const, deriv_mul, deriv_const', zero_mul, deriv_pow'', +- mul_zero, add_zero, zero_sub] +- have h : (fun y ↦ (1 - (1 - x * y) * z) ^ (n + 1)) = fun y ↦ (1 - z + x * z * y) ^ (n + 1) := by ++ · rw [Function.iterate_succ_apply', hn, deriv_fun_div] ++ · simp only [deriv_const', zero_mul, zero_sub] ++ have h : (fun y ↦ (1 - (1 - x * y) * z) ^ (n + 1)) = ++ fun y ↦ (1 - z + x * z * y) ^ (n + 1) := by + ext _; ring + rw [div_eq_div_iff] +- · rw [h, deriv_pow'', deriv_const_add, deriv_const_mul] ++ · rw [h, deriv_fun_pow, deriv_const_add, deriv_const_mul] + · simp only [Nat.cast_add, Nat.cast_one, add_tsub_cancel_right, deriv_id'', mul_one, + ← neg_mul] + rw [show -(-1) ^ n = (-1 : ℝ) ^ (n + 1) by ring, +- show ((n + 1)! : ℝ) = (((n : ℕ) + 1) : ℝ) * (n !) by rw [Nat.factorial_succ]; norm_cast] ++ show ((n + 1)! : ℝ) = (((n : ℕ) + 1) : ℝ) * (n !) by ++ rw [Nat.factorial_succ]; norm_cast] + ring + · apply differentiableAt_id + · apply DifferentiableAt.add +@@ -352,16 +302,17 @@ lemma n_derivative' {x z : ℝ} (n : ℕ) (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ S + apply DifferentiableAt.const_mul differentiableAt_id + · exact pow_ne_zero (n + 1) hne + +-lemma shiftedLegendre_poly_eval_zero_eq_zero {m : ℕ} (h : m < n) : ++lemma shiftedLegendre_poly_eval_zero_eq_zero {n m : ℕ} (h : m < n) : + eval 0 ((⇑derivative)^[m] (X ^ n * (1 - X) ^ n) : ℝ[X]) = 0 := by +- rw [Polynomial.iterate_derivative_mul, Polynomial.eval_finset_sum] ++ rw [Polynomial.iterate_derivative_mul, Polynomial.eval_finsetSum] + apply Finset.sum_eq_zero + intro x hx + simp_all only [Nat.succ_eq_add_one, Finset.mem_range, nsmul_eq_mul, eval_mul, eval_natCast, + mul_eq_zero, Nat.cast_eq_zero] + right; left + simp only [Polynomial.iterate_derivative_X_pow_eq_smul, eval_smul, eval_pow, eval_X, smul_eq_mul, +- mul_eq_zero, Nat.cast_eq_zero, Nat.descFactorial_eq_zero_iff_lt, pow_eq_zero_iff', ne_eq, true_and] ++ mul_eq_zero, Nat.cast_eq_zero, Nat.descFactorial_eq_zero_iff_lt, pow_eq_zero_iff', ++ ne_eq, true_and] + right + suffices n - (m - x) > 0 by linarith + simp only [gt_iff_lt, tsub_pos_iff_lt] +@@ -370,9 +321,9 @@ lemma shiftedLegendre_poly_eval_zero_eq_zero {m : ℕ} (h : m < n) : + m - x ≤ m := by simp + _ < n := by exact h + +-lemma shiftedLegendre_poly_eval_one_eq_zero {m : ℕ} (h : m < n) : ++lemma shiftedLegendre_poly_eval_one_eq_zero {n m : ℕ} (h : m < n) : + eval 1 ((⇑derivative)^[m] (X ^ n * (1 - X) ^ n) : ℝ[X]) = 0 := by +- rw [Polynomial.iterate_derivative_mul, Polynomial.eval_finset_sum] ++ rw [Polynomial.iterate_derivative_mul, Polynomial.eval_finsetSum] + apply Finset.sum_eq_zero + intro x hx + simp_all only [Nat.succ_eq_add_one, Finset.mem_range, nsmul_eq_mul, eval_mul, eval_natCast, +@@ -391,29 +342,11 @@ lemma shiftedLegendre_poly_eval_one_eq_zero {m : ℕ} (h : m < n) : + linarith + + lemma shiftedLegendre_continuousOn {n m : ℕ} : ContinuousOn +- (fun x ↦ eval x ((⇑derivative)^[n - m] (X ^ n * (1 - X) ^ n : ℝ[X]))) (Set.uIcc 0 1) := by +- simp_rw [Polynomial.iterate_derivative_mul, Polynomial.eval_finset_sum] +- apply continuousOn_finset_sum +- intro i _ +- simp_rw [Algebra.smul_def, eval_mul] +- apply ContinuousOn.mul +- · simp only [eq_natCast, eval_natCast, ge_iff_le, zero_le_one, Set.uIcc_of_le] +- apply continuousOn_const +- · apply ContinuousOn.mul +- · simp_rw [Polynomial.iterate_derivative_X_pow_eq_smul] +- simp only [eval_smul, eval_pow, eval_X, smul_eq_mul, ge_iff_le, zero_le_one, +- Set.uIcc_of_le] +- apply ContinuousOn.mul continuousOn_const (ContinuousOn.pow continuousOn_id _) +- · rw [show (1 - X : ℝ[X]) ^ n = (X ^ n : ℝ[X]).comp (1 - X) by simp, +- Polynomial.iterate_derivative_comp_one_sub_X (p := X ^ n), +- Polynomial.iterate_derivative_X_pow_eq_smul] +- simp only [smul_comp, pow_comp, X_comp, Algebra.mul_smul_comm, eval_smul, eval_mul, +- eval_pow, eval_neg, eval_one, eval_sub, eval_X, smul_eq_mul, ge_iff_le, zero_le_one, +- Set.uIcc_of_le] +- refine ContinuousOn.mul continuousOn_const (ContinuousOn.mul continuousOn_const ?_) +- apply ContinuousOn.pow (ContinuousOn.sub continuousOn_const continuousOn_id) ++ (fun x ↦ eval x ((⇑derivative)^[n - m] (X ^ n * (1 - X) ^ n : ℝ[X]))) (Set.uIcc 0 1) := ++ (Polynomial.continuous _).continuousOn + +-lemma special_deriv_div_continuousOn {m : ℕ} {x z: ℝ} (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ Set.Ioo 0 1) : ++lemma special_deriv_div_continuousOn {m : ℕ} {x z : ℝ} ++ (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ Set.Ioo 0 1) : + ContinuousOn (fun u ↦ (deriv^[m] fun y ↦ 1 / (1 - (1 - x * y) * z)) u) (Set.uIcc 0 1) := by + simp_rw [n_derivative' m hx hz] + apply ContinuousOn.div continuousOn_const +@@ -437,58 +370,26 @@ lemma integral_shiftedLegendre_mul_smooth_eq_aux {x z : ℝ} (n m : ℕ) (h : m + eval y ((⇑derivative)^[n] (X ^ n * (1 - X) ^ n)) * (fun y ↦ 1 / (1 - (1 - x * y) * z)) y = + (- 1) ^ m * ∫ (y : ℝ) in (0)..1, eval y ((⇑derivative)^[n - m] (X ^ n * (1 - X) ^ n)) * + (deriv^[m] fun y ↦ 1 / (1 - (1 - x * y) * z)) y:= by +- induction' m with m hm +- · simp +- · have h₀ : m < n := by linarith ++ induction m with ++ | zero => simp ++ | succ m hm => ++ have h₀ : m < n := by linarith + have h₁ : n - (m + 1) < n := by omega + rw [hm (LT.lt.le h₀), pow_add, pow_one, mul_assoc] + congr + symm + rw [show n - m = n - (m + 1) + 1 by omega, Function.iterate_succ_apply'] +- rw [neg_one_mul, neg_eq_iff_eq_neg, intervalIntegral.integral_mul_deriv_eq_deriv_mul_of_hasDerivAt ++ rw [neg_one_mul, neg_eq_iff_eq_neg, ++ intervalIntegral.integral_mul_deriv_eq_deriv_mul_of_hasDerivAt + (u := fun u ↦ eval u ((⇑derivative)^[n - (m + 1)] (X ^ n * (1 - X) ^ n : ℝ[X]))) + (u' := fun u ↦ eval u (derivative ((⇑derivative)^[n - (m + 1)] (X ^ n * (1 - X) ^ n : ℝ[X])))) + (v := fun u ↦ (deriv^[m] fun y ↦ 1 / (1 - (1 - x * y) * z)) u)] + · rw [shiftedLegendre_poly_eval_one_eq_zero h₁, shiftedLegendre_poly_eval_zero_eq_zero h₁] +- simp only [one_mul, one_div, zero_mul, sub_zero, sub_self, zero_sub, +- Function.iterate_succ_apply', neg_inj] ++ simp only [one_div, zero_mul, sub_self, zero_sub, Function.iterate_succ_apply'] + · apply shiftedLegendre_continuousOn + · apply special_deriv_div_continuousOn hx hz +- · intro x _ +- simp_rw [Polynomial.iterate_derivative_mul, Polynomial.eval_finset_sum] +- simp only [Nat.succ_eq_add_one, nsmul_eq_mul, eval_mul, eval_natCast, map_sum, eval_finset_sum] +- apply HasDerivAt.sum +- intro i _ +- simp only [derivative_mul, derivative_natCast, zero_mul, zero_add, eval_mul, eval_natCast, +- eval_add] +- apply HasDerivAt.const_mul +- apply HasDerivAt.mul +- · rw [Polynomial.iterate_derivative_X_pow_eq_smul] +- simp only [eval_smul, eval_pow, eval_X, smul_eq_mul, LinearMapClass.map_smul, +- derivative_X_pow, map_natCast, eval_mul, eval_natCast] +- apply HasDerivAt.const_mul +- apply hasDerivAt_pow +- · rw [show (1 - X : ℝ[X]) ^ n = (X ^ n : ℝ[X]).comp (1 - X) by simp, +- Polynomial.iterate_derivative_comp_one_sub_X (p := X ^ n), +- Polynomial.iterate_derivative_X_pow_eq_smul] +- simp only [smul_comp, pow_comp, X_comp, Algebra.mul_smul_comm, eval_smul, eval_mul, +- eval_pow, eval_neg, eval_one, eval_sub, eval_X, smul_eq_mul, LinearMapClass.map_smul] +- apply HasDerivAt.const_mul +- simp only [derivative_mul, eval_add, eval_mul, eval_pow, eval_sub, eval_one, eval_X, +- eval_neg] +- have h1 : (derivative ((-1) ^ i : ℝ[X])) = 0 := by +- rw [show ((-1) ^ i : ℝ[X]) = C ((-1) ^ i) by simp, derivative_C] +- rw [h1, eval_zero, zero_mul, zero_add] +- apply HasDerivAt.const_mul +- rw [show (1 - X : ℝ[X]) ^ (n - i) = (X ^ (n - i) : ℝ[X]).comp (1 - X) by simp, +- Polynomial.derivative_comp_one_sub_X (p := X ^ (n - i)), +- Polynomial.derivative_X_pow] +- simp only [mul_comp, pow_comp, X_comp, eval_mul, map_natCast, natCast_comp, eval_neg, +- eval_mul, eval_natCast, eval_pow, eval_sub, eval_one, eval_X] +- rw [← mul_neg_one] +- apply HasDerivAt.pow +- apply HasDerivAt.const_sub +- apply hasDerivAt_id ++ · intro u _ ++ exact Polynomial.hasDerivAt _ u + · intro y hy + simp only [Set.mem_Ioo, zero_le_one, min_eq_left, max_eq_right] at hx hy hz + have hh : 1 - (1 - x * y) * z ≠ 0 := by +@@ -502,7 +403,8 @@ lemma integral_shiftedLegendre_mul_smooth_eq_aux {x z : ℝ} (n m : ℕ) (h : m + Function.eval u (deriv (deriv^[m] fun y ↦ 1 / (1 - (1 - x * y) * z))) := by + simp only [one_div, Function.eval] + simp_rw [this] +- simp_rw [← Function.iterate_succ_apply', Nat.succ_eq_add_one, Function.eval, n_derivative' _ hx hz] ++ simp_rw [← Function.iterate_succ_apply', Nat.succ_eq_add_one, Function.eval, ++ n_derivative' _ hx hz] + have : (-1) ^ (m + 1) * ↑(m + 1)! * (x * z) ^ (m + 1) / (1 - (1 - x * y) * z) ^ (m + 1 + 1) + = (0 * (1 - (1 - x * y) * z) ^ (m + 1) - + (-1) ^ m * ↑m ! * (x * z) ^ m * ((m + 1) * (x * z) * (1 - (1 - x * y) * z) ^ m)) / +@@ -519,14 +421,16 @@ lemma integral_shiftedLegendre_mul_smooth_eq_aux {x z : ℝ} (n m : ℕ) (h : m + rw [this] + apply HasDerivAt.div + · apply hasDerivAt_const +- · have : (↑m + 1) * (x * z) * (1 - (1 - x * y) * z) ^ m = deriv (fun y ↦ (1 - (1 - x * y) * z) ^ (m + 1)) y := by ++ · have : (↑m + 1) * (x * z) * (1 - (1 - x * y) * z) ^ m = ++ deriv (fun y ↦ (1 - (1 - x * y) * z) ^ (m + 1)) y := by + simp only [show 1 - (1 - x * y) * z = 1 - z + x * z * y by ring] +- rw [deriv_pow'', show (fun y ↦ 1 - (1 - x * y) * z) = (fun y ↦ 1 - z + x * z * y) by ext _; ring] +- · rw[deriv_const_add, deriv_const_mul] ++ rw [deriv_fun_pow, show (fun y ↦ 1 - (1 - x * y) * z) = ++ (fun y ↦ 1 - z + x * z * y) by ext _; ring] ++ · rw [deriv_const_add, deriv_const_mul] + · simp only [Nat.cast_add, Nat.cast_one, add_tsub_cancel_right, deriv_id'', mul_one] + norm_cast + ring +- · exact differentiableAt_id' ++ · exact differentiableAt_id + · apply DifferentiableAt.const_sub + apply DifferentiableAt.mul_const + · apply DifferentiableAt.const_sub +@@ -538,24 +442,7 @@ lemma integral_shiftedLegendre_mul_smooth_eq_aux {x z : ℝ} (n m : ℕ) (h : m + · apply DifferentiableAt.const_sub + apply DifferentiableAt.const_mul differentiableAt_id + · apply pow_ne_zero _ hh +- · simp_rw [← Function.iterate_succ_apply', Polynomial.iterate_derivative_mul, Polynomial.eval_finset_sum] +- simp only [Nat.succ_eq_add_one, nsmul_eq_mul, eval_mul, eval_natCast] +- apply ContinuousOn.intervalIntegrable_of_Icc (by norm_num) +- apply continuousOn_finset_sum +- intro i _ +- apply ContinuousOn.mul continuousOn_const +- · apply ContinuousOn.mul +- · simp_rw [Polynomial.iterate_derivative_X_pow_eq_smul] +- simp only [eval_smul, eval_pow, eval_X, smul_eq_mul] +- apply ContinuousOn.mul continuousOn_const (ContinuousOn.pow continuousOn_id _) +- · rw [show (1 - X : ℝ[X]) ^ n = (X ^ n : ℝ[X]).comp (1 - X) by simp, +- Polynomial.iterate_derivative_comp_one_sub_X (p := X ^ n), +- Polynomial.iterate_derivative_X_pow_eq_smul] +- simp only [smul_comp, pow_comp, X_comp, Algebra.mul_smul_comm, eval_smul, eval_mul, +- eval_pow, eval_neg, eval_one, eval_sub, eval_X, smul_eq_mul, ge_iff_le, zero_le_one, +- Set.uIcc_of_le] +- refine ContinuousOn.mul continuousOn_const (ContinuousOn.mul continuousOn_const ?_) +- apply ContinuousOn.pow (ContinuousOn.sub continuousOn_const continuousOn_id) ++ · exact (Polynomial.continuous _).intervalIntegrable _ _ + · have : deriv (deriv^[m] fun y ↦ 1 / (1 - (1 - x * y) * z)) = + (Function.eval · (deriv (deriv^[m] fun y ↦ 1 / (1 - (1 - x * y) * z)))) := by + ext x +@@ -566,24 +453,25 @@ lemma integral_shiftedLegendre_mul_smooth_eq_aux {x z : ℝ} (n m : ℕ) (h : m + rw [← Set.uIcc_of_le (by norm_num)] + apply special_deriv_div_continuousOn hx hz + +-lemma integral_legendre_mul_smooth_eq {x z : ℝ} (n : ℕ) (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ Set.Ioo 0 1) : +- ∫ (y : ℝ) in (0)..1, eval y (shiftedLegendre n) * (fun y ↦ 1 / (1 - (1 - x * y) * z)) y = ++lemma integral_legendre_mul_smooth_eq {x z : ℝ} (n : ℕ) ++ (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ Set.Ioo 0 1) : ++ ∫ (y : ℝ) in (0)..1, eval y (aperyShiftedLegendre n) * (fun y ↦ 1 / (1 - (1 - x * y) * z)) y = + (- 1) ^ n / n ! * ∫ (y : ℝ) in (0)..1, y ^ n * (1 - y) ^ n * + (deriv^[n] fun y ↦ 1 / (1 - (1 - x * y) * z)) y := by +- simp only [eval_mul, one_div, eval_C, shiftedLegendre] ++ simp only [eval_mul, one_div, eval_C, aperyShiftedLegendre_eq_rodrigues] + simp_rw [mul_assoc, intervalIntegral.integral_const_mul] + rw [← mul_one_div, one_div] + nth_rw 4 [mul_comm] + rw [mul_assoc] + congr + obtain h := integral_shiftedLegendre_mul_smooth_eq_aux (n := n) (m := n) (by norm_num) hx hz +- simp only [one_div, ge_iff_le, le_refl, tsub_eq_zero_of_le, Function.iterate_zero, id_eq, ++ simp only [one_div, le_refl, tsub_eq_zero_of_le, Function.iterate_zero, id_eq, + eval_mul, eval_pow, eval_X, eval_sub, eval_one] at h + rw [h] + simp_rw [← mul_assoc] + + lemma legendre_integral_special {x z : ℝ} (n : ℕ) (hx : x ∈ Set.Ioo 0 1) (hz : z ∈ Set.Ioo 0 1) : +- ∫ (y : ℝ) in (0)..1, eval y (shiftedLegendre n) * (1 / (1 - (1 - x * y) * z)) = ++ ∫ (y : ℝ) in (0)..1, eval y (aperyShiftedLegendre n) * (1 / (1 - (1 - x * y) * z)) = + ∫ (y : ℝ) in (0)..1, (x * y * z) ^ n * (1 - y) ^ n / (1 - (1 - x * y) * z) ^ (n + 1) := by + rw [integral_legendre_mul_smooth_eq n hx hz, ← intervalIntegral.integral_const_mul, + intervalIntegral.integral_of_le (by norm_num), intervalIntegral.integral_of_le (by norm_num), +@@ -622,3 +510,5 @@ lemma legendre_integral_special {x z : ℝ} (n : ℕ) (hx : x ∈ Set.Ioo 0 1) ( + apply mul_le_of_le_one_left (by linarith) + simp only [tsub_le_iff_right, le_add_iff_nonneg_right] + nlinarith ++ ++end Polynomial +diff --git a/Zeta3Irrational/LinearForm.lean b/Zeta3Irrational/LinearForm.lean +index e90d872..4c678c9 100644 +--- a/Zeta3Irrational/LinearForm.lean ++++ b/Zeta3Irrational/LinearForm.lean +@@ -1,6 +1,8 @@ + import Zeta3Irrational.Integral + import Zeta3Irrational.d + ++/-! # Integer linear forms for the Apéry integrals -/ ++ + open scoped Nat + open BigOperators + +@@ -17,7 +19,7 @@ lemma J_rr_linear (r : ℕ) : + simp only [sub_right_inj] + simp_rw [eq_div_iff d_cube_ne_zero, Finset.mul_sum, Finset.sum_mul] + use ∑ i ∈ Finset.Icc 1 r, 2 * ↑(d (Finset.Icc 1 r)) ^ 3 / ↑i ^ 3 +- simp only [Int.cast_sum, Int.cast_mul, Int.cast_ofNat, Int.cast_pow, Int.cast_natCast] ++ simp only [Int.cast_sum] + apply Finset.sum_congr rfl + intro x hx + rw [mul_assoc] +@@ -33,7 +35,8 @@ lemma J_rr_linear (r : ℕ) : + not_false_eq_true, pow_eq_zero_iff, Nat.cast_eq_zero] + linarith + +-lemma Icc_diff_Icc {r s : ℕ} (_ : r > s) (_ : ¬s = 0) : Finset.Icc 1 r \ Finset.Icc 1 s = Finset.Icc (s + 1) r := by ++lemma Icc_diff_Icc {r s : ℕ} (_ : r > s) (_ : ¬s = 0) : ++ Finset.Icc 1 r \ Finset.Icc 1 s = Finset.Icc (s + 1) r := by + ext x + constructor + · intro hx +@@ -54,9 +57,9 @@ lemma one_div_sum_eq {r s : ℕ} (h : r > s) : + simp_all + else + simp_rw [← Nat.cast_add] +- rw [Icc_diff_Icc h h1, ← Nat.Ico_succ_right, ← Nat.Ico_succ_right, +- Finset.sum_Ico_add (f := fun (x : ℕ) => 1 / ((x ^ 2) : ℝ)) (c := s), Nat.succ_eq_add_one, +- Nat.succ_eq_add_one, add_comm, show r - s + 1 + s = r + 1 by omega] ++ rw [Icc_diff_Icc h h1, ← Finset.Ico_add_one_right_eq_Icc, ← Finset.Ico_add_one_right_eq_Icc, ++ Finset.sum_Ico_add (f := fun (x : ℕ) => 1 / ((x ^ 2) : ℝ)) (c := s), add_comm, ++ show r - s + 1 + s = r + 1 by omega] + · exact Finset.Icc_subset_Icc_right (LT.lt.le (gt_iff_lt.1 h)) + + lemma J_rs_linear {r s : ℕ} (h : r > s) : ∃ a : ℤ, J r s = a / (d (Finset.Icc 1 r)) ^ 3 := by +@@ -76,7 +79,7 @@ lemma J_rs_linear {r s : ℕ} (h : r > s) : ∃ a : ℤ, J r s = a / (d (Finset. + · norm_cast + rw [d_sq'] + apply dvd_d_of_mem +- simp_all only [gt_iff_lt, Finset.mem_Icc, Finset.mem_image, ge_iff_le, zero_le, ne_eq, ++ simp_all only [gt_iff_lt, Finset.mem_Icc, Finset.mem_image, zero_le, ne_eq, + OfNat.ofNat_ne_zero, not_false_eq_true, pow_left_inj₀, exists_eq_right] + omega + · simp_all only [gt_iff_lt, Finset.mem_Icc, Int.cast_pow, Int.cast_add, Int.cast_natCast, +@@ -94,38 +97,44 @@ lemma J_rs_linear {r s : ℕ} (h : r > s) : ∃ a : ℤ, J r s = a / (d (Finset. + rw [← Nat.cast_sub (by linarith)] + norm_cast; linarith + +-lemma multi_integral_sum_comm (c : ℕ → ℤ) : ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++lemma multi_integral_sum_comm {n : ℕ} (c : ℕ → ℤ) : ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + ∑ x_1 ∈ Finset.range (n + 1), ∑ x_2 ∈ Finset.range (n + 1), + -(x.1 * x.2).log / (1 - x.1 * x.2) * ↑(c x_1) * x.1 ^ x_1 * ↑(c x_2) * x.2 ^ x_2 +- = ∑ x_1 ∈ Finset.range (n + 1), ∑ x_2 ∈ Finset.range (n + 1), ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++ = ∑ x_1 ∈ Finset.range (n + 1), ∑ x_2 ∈ Finset.range (n + 1), ++ ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + -(x.1 * x.2).log / (1 - x.1 * x.2) * ↑(c x_1) * x.1 ^ x_1 * ↑(c x_2) * x.2 ^ x_2 := by + symm + calc +- _ = ∑ x_1 ∈ Finset.range (n + 1), ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ∑ x_2 ∈ Finset.range (n + 1), ++ _ = ∑ x_1 ∈ Finset.range (n + 1), ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++ ∑ x_2 ∈ Finset.range (n + 1), + -(x.1 * x.2).log / (1 - x.1 * x.2) * ↑(c x_1) * x.1 ^ x_1 * ↑(c x_2) * x.2 ^ x_2 := by + congr! 1 with a _ +- rw [← MeasureTheory.integral_finset_sum] ++ rw [← MeasureTheory.integral_finsetSum] + intro i _ + have h : (fun (x : ℝ × ℝ) ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * ↑(c a) * x.1 ^ a * +- ↑(c i) * x.2 ^ i) = (fun x ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * x.1 ^ a * x.2 ^ i * (↑(c i) * ↑(c a))) := by ++ ↑(c i) * x.2 ^ i) = (fun x ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * ++ x.1 ^ a * x.2 ^ i * (↑(c i) * ↑(c a))) := by + ext x; ring + rw [h] + apply MeasureTheory.Integrable.mul_const + exact integrableOn_J_rs a i +- _ = ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ∑ x_1 ∈ Finset.range (n + 1), ∑ x_2 ∈ Finset.range (n + 1), ++ _ = ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++ ∑ x_1 ∈ Finset.range (n + 1), ∑ x_2 ∈ Finset.range (n + 1), + -(x.1 * x.2).log / (1 - x.1 * x.2) * ↑(c x_1) * x.1 ^ x_1 * ↑(c x_2) * x.2 ^ x_2 := by +- rw [← MeasureTheory.integral_finset_sum] ++ rw [← MeasureTheory.integral_finsetSum] + intro i _ +- apply MeasureTheory.integrable_finset_sum ++ apply MeasureTheory.integrable_finsetSum + intro j _ + have h : (fun (x : ℝ × ℝ) ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * ↑(c i) * x.1 ^ i * +- ↑(c j) * x.2 ^ j) = (fun x ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * x.1 ^ i * x.2 ^ j * (↑(c i) * ↑(c j))) := by ++ ↑(c j) * x.2 ^ j) = (fun x ↦ -Real.log (x.1 * x.2) / (1 - x.1 * x.2) * ++ x.1 ^ i * x.2 ^ j * (↑(c i) * ↑(c j))) := by + ext x; ring + rw [h] + apply MeasureTheory.Integrable.mul_const + exact integrableOn_J_rs i j + +-lemma multi_integral_mul_const (c d : ℕ) (p q : ℝ): ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, ++lemma multi_integral_mul_const (c d : ℕ) (p q : ℝ) : ++ ∫ (x : ℝ × ℝ) in Set.Ioo 0 1 ×ˢ Set.Ioo 0 1, + -(x.1 * x.2).log / (1 - x.1 * x.2) * p * x.1 ^ c * q * x.2 ^ d = p * q * J c d := by + simp only [J] + symm +@@ -135,11 +144,13 @@ lemma multi_integral_mul_const (c d : ℕ) (p q : ℝ): ∫ (x : ℝ × ℝ) in + simp only [smul_eq_mul] + ring + ++/-- Integer correction coefficient selected from the proved integral identities. -/ + noncomputable def p (r s : ℕ) : ℤ := + if h : r > s then (J_rs_linear h).choose + else if h : r < s then (J_rs_linear h).choose + else -(J_rr_linear r).choose + ++/-- The zeta coefficient: two on the diagonal and zero off the diagonal. -/ + noncomputable def q (r s : ℕ) : ℤ := + if r > s then 0 + else if r < s then 0 +@@ -156,27 +167,27 @@ lemma linear_int_aux : ∃ a b : ℕ → ℕ → ℤ, ∀ r s : ℕ, J r s = + use q + intro x y + if h : x > y then +- cases' (J_rs_linear h) with a ha ++ obtain ⟨a, ha⟩ := J_rs_linear h + simp only [p, q] +- simp_all only [gt_iff_lt, one_div, dite_eq_ite, ite_true, Int.cast_zero, zero_mul, dite_true, ++ simp_all only [gt_iff_lt, one_div, ite_true, Int.cast_zero, zero_mul, dite_true, + zero_add] + rw [(J_rs_linear h).choose_spec] at ha + rw [show x.max y = x by exact max_eq_left_iff.2 (LT.lt.le h)] + simp_all + else if h1 : x < y then +- cases' (J_rs_linear h1) with a ha ++ obtain ⟨a, ha⟩ := J_rs_linear h1 + simp only [p, q] + obtain h2 := J_symm x y +- simp_all only [gt_iff_lt, one_div, dite_eq_ite, ite_true, ite_self, Int.cast_zero, +- zero_mul, dite_true, zero_add, not_false_eq_true, dite_false] ++ simp_all only [gt_iff_lt, one_div, ite_true, ite_self, Int.cast_zero, ++ zero_mul, dite_true, zero_add, dite_false] + rw [(J_rs_linear h1).choose_spec] at ha + simp only [not_lt] at h + simp_all + else + have h : x = y := by linarith +- cases' (J_rr_linear y) with a ha ++ obtain ⟨a, ha⟩ := J_rr_linear y + simp only [p, q] +- simp_all only [gt_iff_lt, lt_self_iff_false, not_false_eq_true, dite_eq_ite, ite_false, ++ simp_all only [gt_iff_lt, lt_self_iff_false, not_false_eq_true, ite_false, + Int.cast_ofNat, not_isEmpty_of_nonempty, tsum_empty, mul_zero, zero_sub, sub_right_inj, + dite_false, Int.cast_neg, max_self] + rw [(J_rr_linear y).choose_spec, ← Mathlib.Tactic.RingNF.add_neg, ← neg_div] at ha +diff --git a/Zeta3Irrational/PrimeCounting.lean b/Zeta3Irrational/PrimeCounting.lean +new file mode 100644 +index 0000000..07a6c45 +--- /dev/null ++++ b/Zeta3Irrational/PrimeCounting.lean +@@ -0,0 +1,48 @@ ++import PrimeNumberTheoremAnd.ZetaFive.Consequences ++ ++/-! ++# Prime counting asymptotics from the proved prime number theorem ++ ++The current Mathlib Chebyshev remainder estimate converts the proved theta asymptotic ++into the exact all-real prime-counting formula used by the Apéry proof. ++-/ ++ ++open Filter Real Asymptotics ++open scoped Chebyshev ++ ++namespace AperyPNT ++ ++/-- The prime-counting function is asymptotic to `x / log x`. -/ ++theorem primeCounting_asymptotic : ++ (fun x : ℝ ↦ (Nat.primeCounting ⌊x⌋₊ : ℝ)) ~[atTop] (fun x ↦ x / log x) := by ++ have h := ZetaFivePNT.chebyshev_asymptotic.div (IsEquivalent.refl (u := Real.log)) ++ have h' := h.add_isLittleO Chebyshev.integral_theta_div_log_sq_isLittleO ++ apply h'.congr' ?_ (Filter.EventuallyEq.refl _ _) ++ filter_upwards [eventually_ge_atTop (2 : ℝ)] with x hx ++ simp only [Pi.sub_apply, Pi.add_apply, Pi.div_apply, id_eq] ++ rw [Chebyshev.primeCounting_eq_theta_div_log_add_integral hx] ++ ++/-- The exact prime-counting consequence, with an error tending to zero. -/ ++theorem pi_alt : ∃ c : ℝ → ℝ, c =o[atTop] (fun _ ↦ (1 : ℝ)) ∧ ++ ∀ x : ℝ, Nat.primeCounting ⌊x⌋₊ = (1 + c x) * x / log x := by ++ refine ⟨fun x ↦ (Nat.primeCounting ⌊x⌋₊ : ℝ) / (x / log x) - 1, ?_, ?_⟩ ++ · rw [isLittleO_one_iff] ++ have h := (isEquivalent_iff_tendsto_one ?_).mp primeCounting_asymptotic ++ · simpa using h.sub (tendsto_const_nhds (x := (1 : ℝ))) ++ · filter_upwards [eventually_gt_atTop (1 : ℝ)] with x hx ++ exact div_ne_zero (by positivity) (log_pos hx).ne' ++ · intro x ++ by_cases hx : x = 0 ++ · simp [hx] ++ by_cases hl : log x = 0 ++ · have hp : Nat.primeCounting ⌊x⌋₊ = 0 := by ++ apply Nat.primeCounting_eq_zero_iff.mpr ++ rcases log_eq_zero.mp hl with h | h | h ++ · exact (hx h).elim ++ · simp [h] ++ · simp [h, Nat.floor_of_nonpos] ++ simp [hl, hp] ++ · field_simp ++ ring ++ ++end AperyPNT +diff --git a/Zeta3Irrational/d.lean b/Zeta3Irrational/d.lean +index 027628c..343f95f 100644 +--- a/Zeta3Irrational/d.lean ++++ b/Zeta3Irrational/d.lean +@@ -4,32 +4,23 @@ Author: Junqi Liu and Jujian Zhang. + -/ + import Mathlib.Algebra.GCDMonoid.Finset + import Mathlib.Algebra.GCDMonoid.Nat ++import Mathlib.Data.Nat.GCD.Prime + import Mathlib.Analysis.SpecialFunctions.Log.Base + import Mathlib.Data.Nat.Choose.Factorization +-import Mathlib.Data.Real.StarOrdered ++import Mathlib.Analysis.Real.Sqrt + import Mathlib.NumberTheory.PrimeCounting + ++/-! ++# Least common multiples for the Apéry irrationality proof ++ ++We bound the least common multiple of the integers from one to `n` using prime counting. ++The natural-number normalization and GCD structures are Mathlib's canonical instances. ++-/ ++ + open scoped Nat + open BigOperators + +-instance : NormalizedGCDMonoid ℕ where +- normUnit _ := 1 +- normUnit_zero := rfl +- normUnit_mul := by simp +- normUnit_coe_units n := by +- rw [Nat.units_eq_one n] +- simp +- gcd := Nat.gcd +- lcm := Nat.lcm +- gcd_dvd_left := Nat.gcd_dvd_left +- gcd_dvd_right := Nat.gcd_dvd_right +- dvd_gcd := Nat.dvd_gcd +- gcd_mul_lcm m n := by rw [Nat.gcd_mul_lcm]; rfl +- lcm_zero_left := Nat.lcm_zero_left +- lcm_zero_right := Nat.lcm_zero_right +- normalize_gcd := by simp +- normalize_lcm := by simp +- ++/-- The least common multiple of the natural numbers in the finite set s. -/ + def d (s : Finset ℕ) : ℕ := s.lcm id + + theorem d_insert (s : Finset ℕ) (n : ℕ) : d (insert n s) = Nat.lcm n (d s) := by +@@ -57,10 +48,6 @@ theorem d_eq_zero (s : Finset ℕ) (hs : 0 ∈ s) : d s = 0 := by + rw [Finset.lcm_eq_zero_iff] + simpa + +-theorem Nat.Prime.dvd_lcm {p} (hp : Nat.Prime p) (a b) (h : p ∣ Nat.lcm a b) : p ∣ a ∨ p ∣ b := by +- have := h.trans <| Nat.lcm_dvd_mul a b +- rwa [Nat.Prime.dvd_mul hp] at this +- + theorem Nat.primeFactors_lcm {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) : + (a.lcm b).primeFactors = a.primeFactors ∪ b.primeFactors := by + ext p +@@ -69,7 +56,7 @@ theorem Nat.primeFactors_lcm {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) : + simp only [mem_primeFactorsList', ne_eq] + constructor + · rintro ⟨hp1, hp2, hp3⟩ +- obtain hp4|hp4 := hp1.dvd_lcm a b hp2 ++ obtain hp4|hp4 := hp1.dvd_or_dvd_of_dvd_lcm hp2 + · left; refine ⟨hp1, hp4, ?_⟩ + contrapose! hp3 + subst hp3 +@@ -88,240 +75,17 @@ theorem Nat.primeFactors_lcm {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) : + erw [lcm_eq_zero_iff] at hp3 + refine hp3.elim (fun ha' => absurd ha' ha) id + +-theorem d_sq (s : Finset ℕ) : (d s)^2 = d (s.image (· ^ 2)) := by ++theorem d_sq (s : Finset ℕ) : (d s) ^ 2 = d (s.image (· ^ 2)) := by + induction s using Finset.induction_on with + | empty => simp [d] +- | @insert i s hi ih => +- rw [d_insert, Finset.image_insert, d_insert, ← ih] +- refine dvd_antisymm ?_ ?_ +- · if hi : i = 0 +- then +- subst hi +- simp +- else +- if hs' : 0 ∈ s +- then +- rw [d_eq_zero _ hs'] +- simp +- else +- have hds : d s ≠ 0 := d_ne_zero s hs' +- have hi' : i^2 ≠ 0 := by simpa using hi +- have hds' : (d s)^2 ≠ 0 := by simpa using hds +- rw [← Nat.factorizationLCMLeft_mul_factorizationLCMRight, +- ← Nat.factorizationLCMLeft_mul_factorizationLCMRight, mul_pow] <;> try assumption +- +- apply mul_dvd_mul +- · delta Nat.factorizationLCMLeft +- erw [← Finset.prod_pow] +- dsimp only +- have eq1 := +- calc ∏ x ∈ (i.lcm (d s)).factorization.support, +- (if (d s).factorization x ≤ i.factorization x +- then x ^ (i.lcm (d s)).factorization x else 1) ^ 2 +- _ = ∏ x ∈ (i.primeFactors ∪ (d s).primeFactors), +- (if (d s).factorization x ≤ i.factorization x +- then x ^ (i.lcm (d s)).factorization x else 1) ^ 2 := by +- apply Finset.prod_congr ?_ (fun _ _ => rfl) +- rw [Nat.support_factorization, Nat.primeFactors_lcm] <;> assumption +- _ = ∏ x ∈ (i.primeFactors ∪ (d s).primeFactors), +- if (d s).factorization x ≤ i.factorization x +- then (x ^ (i.lcm (d s)).factorization x) ^ 2 else 1 := by +- refine Finset.prod_congr rfl fun x _ => ?_ +- split_ifs <;> simp +- rw [eq1] +- have eq2 := calc ((i ^ 2).lcm (d s ^ 2)).factorization.prod fun p n ↦ +- if (d s ^ 2).factorization p ≤ (i ^ 2).factorization p then p ^ n else 1 +- _ = ∏ i ∈ ((i ^ 2).lcm (d s ^ 2)).factorization.support, _ := rfl +- _ = ∏ i ∈ (i.primeFactors ∪ (d s).primeFactors), _ := by +- apply Finset.prod_congr ?_ (fun _ _ => rfl) +- rw [Nat.support_factorization, Nat.primeFactors_lcm] <;> try assumption +- congr 1 <;> +- · rw [pow_two, Nat.primeFactors_mul] <;> aesop +- +- simp_rw [eq2, Nat.factorization_pow] +- simp only [Finsupp.coe_smul, Pi.smul_apply, smul_eq_mul, gt_iff_lt, Nat.ofNat_pos, +- mul_le_mul_left] +- apply Finset.prod_dvd_prod_of_dvd +- intro p _ +- split_ifs +- · rw [← pow_mul] +- apply pow_dvd_pow +- rw [Nat.factorization_lcm, Nat.factorization_lcm] <;> try assumption +- +- simp only [Finsupp.sup_apply, Nat.factorization_pow, Finsupp.coe_smul, Pi.smul_apply, +- smul_eq_mul] +- have eq : 2 * i.factorization p ⊔ 2 * (d s).factorization p = +- 2 * (i.factorization p ⊔ (d s).factorization p) := by +- change Nat.max _ _ = 2 * Nat.max _ _ +- rw [mul_max_of_nonneg] +- norm_num +- rw [eq, mul_comm] +- +- · exact one_dvd _ +- · delta Nat.factorizationLCMRight +- erw [← Finset.prod_pow] +- dsimp only +- have eq1 := +- calc ∏ x ∈ (i.lcm (d s)).factorization.support, +- (if (d s).factorization x ≤ i.factorization x +- then 1 else x ^ (i.lcm (d s)).factorization x) ^ 2 +- _ = ∏ x ∈ (i.primeFactors ∪ (d s).primeFactors), +- (if (d s).factorization x ≤ i.factorization x +- then 1 else x ^ (i.lcm (d s)).factorization x) ^ 2 := by +- apply Finset.prod_congr ?_ (fun _ _ => rfl) +- rw [Nat.support_factorization, Nat.primeFactors_lcm] <;> assumption +- _ = ∏ x ∈ (i.primeFactors ∪ (d s).primeFactors), +- if (d s).factorization x ≤ i.factorization x +- then 1 else (x ^ (i.lcm (d s)).factorization x) ^ 2 := by +- refine Finset.prod_congr rfl fun x _ => ?_ +- split_ifs <;> simp +- rw [eq1] +- have eq2 := calc ((i ^ 2).lcm (d s ^ 2)).factorization.prod fun p n ↦ +- if (d s ^ 2).factorization p ≤ (i ^ 2).factorization p then 1 else p ^ n +- _ = ∏ i ∈ ((i ^ 2).lcm (d s ^ 2)).factorization.support, _ := rfl +- _ = ∏ i ∈ (i.primeFactors ∪ (d s).primeFactors), _ := by +- apply Finset.prod_congr ?_ (fun _ _ => rfl) +- rw [Nat.support_factorization, Nat.primeFactors_lcm] <;> try assumption +- congr 1 <;> +- · rw [pow_two, Nat.primeFactors_mul] <;> aesop +- simp_rw [eq2, Nat.factorization_pow] +- simp only [Finsupp.coe_smul, Pi.smul_apply, smul_eq_mul, gt_iff_lt, Nat.ofNat_pos, +- mul_le_mul_left] +- apply Finset.prod_dvd_prod_of_dvd +- intro p _ +- split_ifs +- · exact one_dvd _ +- · rw [← pow_mul] +- apply pow_dvd_pow +- rw [Nat.factorization_lcm, Nat.factorization_lcm] <;> try assumption ++ | @insert i s _ ih => ++ rw [d_insert, Finset.image_insert, d_insert, ← ih, Nat.pow_lcm_pow] + +- simp only [Finsupp.sup_apply, Nat.factorization_pow, Finsupp.coe_smul, Pi.smul_apply, +- smul_eq_mul] +- have eq : 2 * i.factorization p ⊔ 2 * (d s).factorization p = +- 2 * (i.factorization p ⊔ (d s).factorization p) := by +- change Nat.max _ _ = 2 * Nat.max _ _ +- rw [mul_max_of_nonneg] +- norm_num +- rw [eq, mul_comm] +- +- · rw [Nat.lcm_dvd_iff] +- exact ⟨pow_dvd_pow_of_dvd (Nat.dvd_lcm_left _ _) 2, +- pow_dvd_pow_of_dvd (Nat.dvd_lcm_right _ _) 2⟩ +- +-theorem d_cube (s : Finset ℕ) : (d s)^3 = d (s.image (· ^ 3)) := by ++theorem d_cube (s : Finset ℕ) : (d s) ^ 3 = d (s.image (· ^ 3)) := by + induction s using Finset.induction_on with + | empty => simp [d] +- | @insert i s hi ih => +- rw [d_insert, Finset.image_insert, d_insert, ← ih] +- refine dvd_antisymm ?_ ?_ +- · if hi : i = 0 +- then +- subst hi +- simp +- else +- if hs' : 0 ∈ s +- then +- rw [d_eq_zero _ hs'] +- simp +- else +- have hds : d s ≠ 0 := d_ne_zero s hs' +- have hi' : i^3 ≠ 0 := by simpa using hi +- have hds' : (d s)^3 ≠ 0 := by simpa using hds +- rw [← Nat.factorizationLCMLeft_mul_factorizationLCMRight, +- ← Nat.factorizationLCMLeft_mul_factorizationLCMRight, mul_pow] <;> try assumption +- +- apply mul_dvd_mul +- · delta Nat.factorizationLCMLeft +- erw [← Finset.prod_pow] +- dsimp only +- have eq1 := +- calc ∏ x ∈ (i.lcm (d s)).factorization.support, +- (if (d s).factorization x ≤ i.factorization x +- then x ^ (i.lcm (d s)).factorization x else 1) ^ 3 +- _ = ∏ x ∈ (i.primeFactors ∪ (d s).primeFactors), +- (if (d s).factorization x ≤ i.factorization x +- then x ^ (i.lcm (d s)).factorization x else 1) ^ 3 := by +- apply Finset.prod_congr ?_ (fun _ _ => rfl) +- rw [Nat.support_factorization, Nat.primeFactors_lcm] <;> assumption +- _ = ∏ x ∈ (i.primeFactors ∪ (d s).primeFactors), +- if (d s).factorization x ≤ i.factorization x +- then (x ^ (i.lcm (d s)).factorization x) ^ 3 else 1 := by +- refine Finset.prod_congr rfl fun x _ => ?_ +- split_ifs <;> simp +- rw [eq1] +- have eq2 := calc ((i ^ 3).lcm (d s ^ 3)).factorization.prod fun p n ↦ +- if (d s ^ 3).factorization p ≤ (i ^ 3).factorization p then p ^ n else 1 +- _ = ∏ i ∈ ((i ^ 3).lcm (d s ^ 3)).factorization.support, _ := rfl +- _ = ∏ i ∈ (i.primeFactors ∪ (d s).primeFactors), _ := by +- apply Finset.prod_congr ?_ (fun _ _ => rfl) +- rw [Nat.support_factorization, Nat.primeFactors_lcm] <;> try assumption +- congr 1 <;> +- · rw [show 3 = 2 + 1 by omega, pow_add, pow_two, pow_one, Nat.primeFactors_mul, +- Nat.primeFactors_mul] <;> aesop +- +- simp_rw [eq2, Nat.factorization_pow] +- simp only [Finsupp.coe_smul, Pi.smul_apply, smul_eq_mul, gt_iff_lt, Nat.ofNat_pos, +- mul_le_mul_left] +- apply Finset.prod_dvd_prod_of_dvd +- intro p _ +- split_ifs +- · rw [← pow_mul] +- apply pow_dvd_pow +- rw [Nat.factorization_lcm, Nat.factorization_lcm] <;> try assumption +- +- simp only [Finsupp.sup_apply, Nat.factorization_pow, Finsupp.coe_smul, Pi.smul_apply, +- smul_eq_mul] +- have eq : 3 * i.factorization p ⊔ 3 * (d s).factorization p = +- 3 * (i.factorization p ⊔ (d s).factorization p) := by +- change Nat.max _ _ = 3 * Nat.max _ _ +- rw [mul_max_of_nonneg] +- norm_num +- rw [eq, mul_comm] +- · exact one_dvd _ +- +- · delta Nat.factorizationLCMRight +- erw [← Finset.prod_pow] +- simp only [Nat.support_factorization, ite_pow, one_pow, Nat.factorization_pow, +- Finsupp.coe_smul, Pi.smul_apply, smul_eq_mul, gt_iff_lt, Nat.ofNat_pos, mul_le_mul_left] +- have eq1 := +- calc ∏ x ∈ (i.lcm (d s)).primeFactors, +- if (d s).factorization x ≤ i.factorization x +- then 1 else (x ^ (i.lcm (d s)).factorization x) ^ 3 +- _ = ∏ x ∈ (i.primeFactors ∪ (d s).primeFactors), +- if (d s).factorization x ≤ i.factorization x +- then 1 else (x ^ (i.lcm (d s)).factorization x) ^ 3 := by +- apply Finset.prod_congr ?_ fun _ _ => rfl +- rw [Nat.primeFactors_lcm] <;> assumption +- rw [eq1] +- have eq2 := calc ((i ^ 3).lcm (d s ^ 3)).factorization.prod fun p n ↦ +- if (d s).factorization p ≤ i.factorization p then 1 else p ^ n +- _ = ∏ i ∈ ((i ^ 3).lcm (d s ^ 3)).factorization.support, _ := rfl +- _ = ∏ i ∈ (i.primeFactors ∪ (d s).primeFactors), _ := by +- apply Finset.prod_congr ?_ fun _ _ => rfl +- rw [Nat.support_factorization, Nat.primeFactors_lcm] <;> try assumption +- congr 1 <;> +- · rw [show 3 = 2 + 1 by omega, pow_add, pow_two, pow_one, Nat.primeFactors_mul, +- Nat.primeFactors_mul] <;> aesop +- rw [eq2] +- apply Finset.prod_dvd_prod_of_dvd +- intro p _ +- simp only +- split_ifs +- · simp +- · rw [← pow_mul] +- apply pow_dvd_pow +- rw [Nat.factorization_lcm, Nat.factorization_lcm] <;> try assumption +- simp only [Finsupp.sup_apply, Nat.factorization_pow, Finsupp.coe_smul, Pi.smul_apply, +- smul_eq_mul] +- have eq : 3 * i.factorization p ⊔ 3 * (d s).factorization p = +- 3 * (i.factorization p ⊔ (d s).factorization p) := by +- change Nat.max _ _ = 3 * Nat.max _ _ +- rw [mul_max_of_nonneg] +- norm_num +- rw [eq, mul_comm] +- · rw [Nat.lcm_dvd_iff] +- exact ⟨pow_dvd_pow_of_dvd (Nat.dvd_lcm_left _ _) 3, +- pow_dvd_pow_of_dvd (Nat.dvd_lcm_right _ _) 3⟩ ++ | @insert i s _ ih => ++ rw [d_insert, Finset.image_insert, d_insert, ← ih, Nat.pow_lcm_pow] + + theorem d_sq' (n : ℕ) : + d (Finset.Icc 1 n)^2 = d (Finset.Icc 1 n |>.image (· ^ 2)) := d_sq _ +@@ -339,12 +103,6 @@ theorem lcm_factorization (m n p : ℕ) (hm : m ≠ 0) (hn : n ≠ 0) : + rw [Nat.factorization_lcm hm hn] + aesop + +--- lemma lcm_eq_prod (m n : ℕ) : m.lcm n = +--- ∏ p ∈ (max m n).primesBelow, p ^ (max (m.factorization p) (n.factorization p)) := by +- +--- sorry +- +- + theorem d_factorization (s : Finset ℕ) (hs : s.Nonempty) (p : ℕ) (hs₁ : 0 ∉ s) : + (d s).factorization p = + (s.image fun i => i.factorization p).max' (by aesop) := by +@@ -356,15 +114,11 @@ theorem d_factorization (s : Finset ℕ) (hs : s.Nonempty) (p : ℕ) (hs₁ : 0 + then + simp only [Finset.image_insert] + rw [Finset.max'_insert (H := by aesop)] +- rw [max_comm] +- congr 1 +- rw [ih hs] +- aesop ++ rw [ih hs (by aesop)] + else + simp only [Finset.not_nonempty_iff_eq_empty] at hs + subst hs +- simp only [d_empty, Nat.factorization_one, Finsupp.coe_zero, Pi.zero_apply, zero_le, +- max_eq_left, insert_emptyc_eq, Finset.image_singleton, Finset.max'_singleton] ++ simp [d_empty] + · aesop + · apply d_ne_zero + aesop +@@ -431,14 +185,16 @@ theorem d_factorization_eq_div_log' (n p : ℕ) (hp : Nat.Prime p) : + · by_contra! h + rw [Finset.max'_le_iff] at h + set y := (Finset.image (fun i ↦ i.factorization p) (Finset.Icc 1 (n + 1))).max' (by aesop) +- have hy : (y : ℝ) ∈ (Finset.image (fun i ↦ (i.factorization p : ℝ)) (Finset.Icc 1 (n + 1))) := by ++ have hy : (y : ℝ) ∈ ++ (Finset.image (fun i ↦ (i.factorization p : ℝ)) (Finset.Icc 1 (n + 1))) := by + simp only [Finset.mem_image, Finset.mem_Icc, Nat.cast_inj] + simp_rw [← Finset.mem_Icc] + rw [← Finset.mem_image] + exact Finset.max'_mem _ _ + specialize h (y : ℝ) hy + rw [le_sub_iff_add_le, Real.le_logb_iff_rpow_le] at h +- · have h2 : y + 1 ∉ (Finset.image (fun i ↦ i.factorization p) (Finset.Icc 1 (n + 1))) := by ++ · have h2 : y + 1 ∉ ++ (Finset.image (fun i ↦ i.factorization p) (Finset.Icc 1 (n + 1))) := by + by_contra! hy1 + suffices y + 1 ≤ y by linarith + exact Finset.le_max' _ _ hy1 +@@ -450,8 +206,8 @@ theorem d_factorization_eq_div_log' (n p : ℕ) (hp : Nat.Prime p) : + exact Nat.Prime.one_lt hp + · norm_cast + omega +- · aesop + · aesop ++ · simp + · apply Real.logb_nonneg + · norm_cast + exact Nat.Prime.one_lt hp +@@ -464,31 +220,20 @@ theorem d_factorization_eq_div_log (n p : ℕ) (hp : Nat.Prime p) : + cases n + · simp only [zero_lt_one, Finset.Icc_eq_empty_of_lt, d_empty, Nat.factorization_one, + Finsupp.coe_zero, Pi.zero_apply, CharP.cast_eq_zero, Real.log_zero, zero_div, Nat.floor_zero] +- + · rw [d_factorization_eq_div_log' (hp := hp)] + simp + +--- lemma d_eq_prod (s : Finset ℕ) (hs : s.Nonempty) : +--- d s = +--- ∏ p ∈ Nat.primesBelow (s.max' hs), +--- p ^ (s.image fun i => i.factorization p).max' (by aesop) := by +--- induction s using Finset.induction_on with +--- | empty => simp only [Finset.not_nonempty_empty] at hs +--- | @insert m s hm ih => +--- sorry +- + theorem d_eq_prod_pow' (n : ℕ) : + d (Finset.Icc 1 (n + 1)) = + ∏ p ∈ (((n + 1) + 1).primesBelow), + p ^ ((Finset.Icc 1 (n + 1)).image (fun i => i.factorization p)).max' (by aesop) := by +- rw [← Nat.factorization_prod_pow_eq_self (n := d (Finset.Icc 1 (n + 1)))] ++ rw [← Nat.prod_factorization_pow_eq_self (n := d (Finset.Icc 1 (n + 1)))] + · simp only [Finsupp.prod, Nat.support_factorization] + rw [d_primeFactors _ (by aesop)] + refine Finset.prod_congr ?_ ?_ + · ext p +- constructor <;> intro hp <;> simp only at hp ⊢ ++ constructor <;> intro hp + · rw [Finset.mem_sup] at hp +- + obtain ⟨m, H, h⟩ := hp + simp only [Finset.mem_Icc] at H + rw [Nat.mem_primesBelow] +@@ -541,41 +286,39 @@ theorem d_le_pow_counting (n : ℕ) : d (Finset.Icc 1 n) ≤ n ^ (n.primeCountin + calc + _ ≤ ∏ _ ∈ ((n + 1).primesBelow), n := by + apply Finset.prod_le_prod +- · intro p _ +- simp only [zero_le] +- · intro p hp +- rw [Nat.mem_primesBelow] at hp +- have h2 : 1 ≤ p := by +- by_contra! h +- have : p = 0 := by omega +- aesop +- suffices p ^ (⌊(Real.log (n : ℝ)) / (Real.log (p : ℝ))⌋₊ : ℝ) ≤ (n : ℝ) by norm_cast at this +- trans p ^ ((Real.log (n : ℝ)) / (Real.log (p : ℝ))) +- · apply Real.rpow_le_rpow_of_exponent_le (by norm_cast) +- · apply Nat.floor_le (α := ℝ) +- if h2 : n = 1 ∨ p = 1 then +- rcases h2 with (rfl | rfl) <;> simp +- else +- rcases (not_or.1 h2) with ⟨_, h2⟩ +- have h1 : 1 < n := by omega +- have h2 : 1 < p := by omega +- suffices 0 < Real.log (n : ℝ) / Real.log (p : ℝ) by linarith +- apply div_pos <;> +- exact Real.log_pos (by norm_cast) +- · nth_rewrite 1 [← Real.exp_log (x := (p : ℝ)) (by norm_cast), ← Real.exp_one_rpow, +- ← Real.rpow_mul (by exact Real.exp_nonneg 1), mul_div, mul_comm, ← mul_div] +- if hp : p = 1 then +- rw [hp]; simp only [Nat.cast_one, Real.log_one, div_zero, mul_zero, Real.rpow_zero, +- Nat.one_le_cast, h1] ++ intro p hp ++ rw [Nat.mem_primesBelow] at hp ++ have h2 : 1 ≤ p := by ++ by_contra! h ++ have : p = 0 := by omega ++ aesop ++ suffices p ^ (⌊(Real.log (n : ℝ)) / (Real.log (p : ℝ))⌋₊ : ℝ) ≤ (n : ℝ) by norm_cast at this ++ trans p ^ ((Real.log (n : ℝ)) / (Real.log (p : ℝ))) ++ · apply Real.rpow_le_rpow_of_exponent_le (by norm_cast) ++ · apply Nat.floor_le (R := ℝ) ++ if h2 : n = 1 ∨ p = 1 then ++ rcases h2 with (rfl | rfl) <;> simp + else +- rw [div_self, mul_one, Real.exp_one_rpow, Real.exp_log (by norm_cast)] +- rw [Real.log_ne_zero] +- norm_cast +- simp only [not_false_eq_true, and_true] +- omega ++ rcases (not_or.1 h2) with ⟨_, h2⟩ ++ have h1 : 1 < n := by omega ++ have h2 : 1 < p := by omega ++ suffices 0 < Real.log (n : ℝ) / Real.log (p : ℝ) by linarith ++ apply div_pos <;> ++ exact Real.log_pos (by norm_cast) ++ · nth_rewrite 1 [← Real.exp_log (x := (p : ℝ)) (by norm_cast), ← Real.exp_one_rpow, ++ ← Real.rpow_mul (by exact Real.exp_nonneg 1), mul_div, mul_comm, ← mul_div] ++ if hp : p = 1 then ++ rw [hp]; simp only [Nat.cast_one, Real.log_one, div_zero, mul_zero, Real.rpow_zero, ++ Nat.one_le_cast, h1] ++ else ++ rw [div_self, mul_one, Real.exp_one_rpow, Real.exp_log (by norm_cast)] ++ rw [Real.log_ne_zero] ++ norm_cast ++ simp only [not_false_eq_true, and_true] ++ omega + _ ≤ n ^ (n.primeCounting) := by + rw [Finset.prod_const] +- suffices ((n + 1).primesBelow).card = n.primeCounting by apply Nat.pow_le_pow_right <;> linarith ++ suffices ((n + 1).primesBelow).card = n.primeCounting by ++ apply Nat.pow_le_pow_right <;> linarith + rw [Nat.primeCounting, ← Nat.primesBelow_card_eq_primeCounting'] + +-#min_imports +diff --git a/lakefile.lean b/lakefile.lean +index 6276b4a..38f6ff4 100644 +--- a/lakefile.lean ++++ b/lakefile.lean +@@ -11,7 +11,10 @@ package «Zeta3Irrational» where + + @[default_target] + lean_lib «Zeta3Irrational» where +- -- add any library configuration options here ++ roots := #[`Zeta3Irrational] ++ globs := #[`Zeta3Irrational, `Zeta3Irrational.Basic, `Zeta3Irrational.Bound, ++ `Zeta3Irrational.Integral, `Zeta3Irrational.LegendrePoly, `Zeta3Irrational.LinearForm, ++ `Zeta3Irrational.d, `Zeta3Irrational.Equality, `Zeta3Irrational.PrimeCounting] + + require «PrimeNumberTheoremAnd» from git + "https://github.com/AlexKontorovich/PrimeNumberTheoremAnd.git" @ "main" +diff --git a/lean-toolchain b/lean-toolchain +index b2153cd..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.18.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/belyi-lean4341.patch b/lean/patches/belyi-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..a4754edce99f5e901aaebd905491d73f1b0266ab --- /dev/null +++ b/lean/patches/belyi-lean4341.patch @@ -0,0 +1,408 @@ +diff --git a/Belyi/Converse/ConstantFamily.lean b/Belyi/Converse/ConstantFamily.lean +index 2692f69b67ac443907d301f353162ead0303dd55..4b1a073bae874e42d95ebc1324b536786358832c 100644 +--- a/Belyi/Converse/ConstantFamily.lean ++++ b/Belyi/Converse/ConstantFamily.lean +@@ -129,16 +129,14 @@ theorem isBaseChangeAlong_fibre (s : A →ₐ[k] k) (M : Type u) [CommRing M] [A + rw [Algebra.algebraMap_eq_smul_one (A := B), ← TensorProduct.smul_tmul, Algebra.smul_def, + mul_one] + haveI : IsScalarTower (A ⊗[k] R) R (M ⊗[k] R) := .of_algebraMap_eq fun x ↦ by +- induction x with +- | zero => simp ++ induction x using TensorProduct.inductionOn with + | add x y hx hy => simp only [map_add, hx, hy] + | tmul a r => + change algebraMap k M (s a) ⊗ₜ r = 1 ⊗ₜ (s a • r) + rw [Algebra.algebraMap_eq_smul_one, TensorProduct.smul_tmul] + have hT : IsScalarTower (A ⊗[k] R) (M ⊗[k] R) (M ⊗[k] B₀) := by + refine .of_algebraMap_eq fun x ↦ ?_ +- induction x with +- | zero => simp ++ induction x using TensorProduct.inductionOn with + | add x y hx hy => simp only [map_add, hx, hy] + | tmul a r => + change (1 : M) ⊗ₜ ((1 : R) ⊗ₜ algebraMap (A ⊗[k] R) B (a ⊗ₜ r) : B₀) = +@@ -178,8 +176,7 @@ theorem isBaseChangeAlong_map (φ : A →ₐ[k] L) (B₀ : Type u) [CommRing B + IsScalarTower.of_algebraMap_eq fun _ ↦ rfl + have hT : IsScalarTower (A ⊗[k] R) (L ⊗[k] R) (L ⊗[k] B₀) := by + refine .of_algebraMap_eq fun x ↦ ?_ +- induction x with +- | zero => simp ++ induction x using TensorProduct.inductionOn with + | add x y hx hy => simp only [map_add, hx, hy] + | tmul a r => rfl + refine ⟨hT, ?_⟩ +diff --git a/Belyi/Converse/HomDescent.lean b/Belyi/Converse/HomDescent.lean +index d6124c0fc6852061bb796402c0790f7b6f908c1e..0b5e604e97ff450339613f7607dc3def5ae3f287 100644 +--- a/Belyi/Converse/HomDescent.lean ++++ b/Belyi/Converse/HomDescent.lean +@@ -47,8 +47,7 @@ variable {A : Type*} [CommRing A] {Ω : Type*} [CommRing Ω] [Algebra A Ω] + lemma map_id_eq_rTensor {D E : Type*} [CommRing D] [Algebra A D] [CommRing E] [Algebra A E] + (f : D →ₐ[A] E) (t : D ⊗[A] N) : + Algebra.TensorProduct.map f (AlgHom.id A N) t = LinearMap.rTensor N f.toLinearMap t := by +- induction t with +- | zero => simp ++ induction t using TensorProduct.inductionOn with + | tmul x y => simp + | add x y hx hy => rw [map_add, map_add, hx, hy] + +@@ -57,8 +56,7 @@ lemma map_inclusion_inclusion {C D E : Subalgebra A Ω} (h₁ : C ≤ D) (h₂ : + Algebra.TensorProduct.map (Subalgebra.inclusion h₂) (AlgHom.id A N) + (Algebra.TensorProduct.map (Subalgebra.inclusion h₁) (AlgHom.id A N) t) = + Algebra.TensorProduct.map (Subalgebra.inclusion (h₁.trans h₂)) (AlgHom.id A N) t := by +- induction t with +- | zero => simp ++ induction t using TensorProduct.inductionOn with + | tmul x y => simp + | add x y hx hy => rw [map_add, map_add, map_add, hx, hy] + +@@ -66,8 +64,7 @@ lemma map_val_inclusion {C D : Subalgebra A Ω} (h : C ≤ D) (t : C ⊗[A] N) : + Algebra.TensorProduct.map D.val (AlgHom.id A N) + (Algebra.TensorProduct.map (Subalgebra.inclusion h) (AlgHom.id A N) t) = + Algebra.TensorProduct.map C.val (AlgHom.id A N) t := by +- induction t with +- | zero => simp ++ induction t using TensorProduct.inductionOn with + | tmul x y => simp + | add x y hx hy => rw [map_add, map_add, map_add, hx, hy] + +@@ -232,8 +229,7 @@ lemma pushHom_apply (σ : D →ₐ[A] E) (F : B₁ →ₐ[A] D ⊗[A] B₂) (b : + lemma map_baseChangeHom (σ : D →ₐ[A] E) (F : B₁ →ₐ[A] D ⊗[A] B₂) (t : D ⊗[A] B₁) : + Algebra.TensorProduct.map σ (AlgHom.id A B₂) (baseChangeHom F t) = + baseChangeHom (pushHom σ F) (Algebra.TensorProduct.map σ (AlgHom.id A B₁) t) := by +- induction t with +- | zero => simp ++ induction t using TensorProduct.inductionOn with + | tmul d b => simp + | add x y hx hy => rw [map_add, map_add, map_add, hx, hy, map_add] + +@@ -300,8 +296,7 @@ theorem exists_algEquiv_of_fg [Algebra.FinitePresentation P B₁] + rw [← hF₂']; ext b; exact map_val_inclusion _ _ + have hbc₁ : ∀ t, baseChangeHom F₁ t = e t := by + intro t +- induction t with +- | zero => simp ++ induction t using TensorProduct.inductionOn with + | tmul ω b => + have : (ω ⊗ₜ[A] b : Ω ⊗[A] _) = algebraMap Ω _ ω * (1 ⊗ₜ b) := by simp + rw [baseChangeHom_tmul, this, map_mul, AlgEquiv.commutes] +@@ -309,8 +304,7 @@ theorem exists_algEquiv_of_fg [Algebra.FinitePresentation P B₁] + | add x y hx hy => rw [map_add, map_add, hx, hy] + have hbc₂ : ∀ t, baseChangeHom F₂ t = e.symm t := by + intro t +- induction t with +- | zero => simp ++ induction t using TensorProduct.inductionOn with + | tmul ω b => + have : (ω ⊗ₜ[A] b : Ω ⊗[A] _) = algebraMap Ω _ ω * (1 ⊗ₜ b) := by simp + rw [baseChangeHom_tmul, this, map_mul, AlgEquiv.commutes] +diff --git a/Belyi/Converse/IsoDescent.lean b/Belyi/Converse/IsoDescent.lean +index 69f7f51ad3d9f227c7df08169cb7b04eefc34974..65e59a91e3175df6b2b2050a60bb36b26b3bd87e 100644 +--- a/Belyi/Converse/IsoDescent.lean ++++ b/Belyi/Converse/IsoDescent.lean +@@ -186,8 +186,7 @@ theorem nonempty_algEquiv_of_isBaseChangeAlong + -- back to `B₁K ≃ B₂K` + let E : B₁K ≃+* B₂K := (Ψ₁.symm.trans eK.toRingEquiv).trans Ψ₂ + refine ⟨AlgEquiv.ofRingEquiv (f := E) fun x ↦ ?_⟩ +- induction x with +- | zero => simp ++ induction x using TensorProduct.inductionOn with + | add x y hx hy => rw [map_add, map_add, hx, hy, map_add] + | tmul l r => + have key₁ : algebraMap (K ⊗[k] R) B₁K (l ⊗ₜ r) = +diff --git a/Belyi/Converse/Points.lean b/Belyi/Converse/Points.lean +index 285770c889d3277896e9487be32a0d79010bc690..53fbc6cd9681ff1388451f8729394b1a2d6eaaf5 100644 +--- a/Belyi/Converse/Points.lean ++++ b/Belyi/Converse/Points.lean +@@ -100,7 +100,7 @@ theorem exists_injective_algHom (k Ω A : Type u) [Field k] [Countable k] + obtain ⟨s, hs⟩ := exists_isTranscendenceBasis k A + have hsfin : #s < ℵ₀ := by + have h1 := hs.lift_cardinalMk_eq_trdeg +- have h2 := trdeg_lt_aleph0 (R := k) (S := A) ++ have h2 := trdeg_lt_aleph0_of_finiteType (R := k) (S := A) + simp only [lift_id] at h1 + rwa [h1] + obtain ⟨t, ht⟩ := exists_isTranscendenceBasis k Ω +diff --git a/Belyi/Converse/Spread.lean b/Belyi/Converse/Spread.lean +index f76bb9ae3e7ec6dfe89f98ef62b25a70df7e5812..7a8378c2d0663f913cac6277bdc1ce0f39bb53dc 100644 +--- a/Belyi/Converse/Spread.lean ++++ b/Belyi/Converse/Spread.lean +@@ -148,8 +148,7 @@ theorem injective_map_val (A : Subalgebra k K) : + theorem exists_fg_mem_range (x : K ⊗[k] R) : + ∃ A : Subalgebra k K, A.FG ∧ + x ∈ Set.range (Algebra.TensorProduct.map A.val (AlgHom.id k R)) := by +- induction x with +- | zero => exact ⟨⊥, Subalgebra.fg_bot, 0, map_zero _⟩ ++ induction x using TensorProduct.inductionOn with + | tmul a r => + refine ⟨Algebra.adjoin k ((({a} : Finset K)) : Set K), Subalgebra.fg_adjoin_finset {a}, ?_⟩ + exact ⟨⟨a, Algebra.subset_adjoin (by simp)⟩ ⊗ₜ r, rfl⟩ +diff --git a/Belyi/Curve/Descent.lean b/Belyi/Curve/Descent.lean +index 6b9f7a650d4dff22de4e56c486d24466fefb81cb..a2cce2df8151aeccc4e8f80b01eb00aebcb3879b 100644 +--- a/Belyi/Curve/Descent.lean ++++ b/Belyi/Curve/Descent.lean +@@ -5,6 +5,7 @@ Authors: The Belyi project contributors + -/ + import Mathlib.AlgebraicGeometry.Morphisms.Separated + import Mathlib.AlgebraicGeometry.Morphisms.Proper ++import Mathlib.AlgebraicGeometry.Morphisms.Immersion + import Mathlib.AlgebraicGeometry.Morphisms.FlatDescent + import Mathlib.AlgebraicGeometry.Morphisms.LocalFlatDescent + +diff --git a/Belyi/CurveField/KummerStep.lean b/Belyi/CurveField/KummerStep.lean +index f076a063d7f186ca0b78435c5861ba1d4cc41535..97aaee48ba1c670e92e3b024255997d5e11d5883 100644 +--- a/Belyi/CurveField/KummerStep.lean ++++ b/Belyi/CurveField/KummerStep.lean +@@ -210,7 +210,7 @@ theorem exists_mem_conductor_notMem (x : chartRingExt K L t) + have hle : conductor (chartRing t) x * differentIdeal (chartRing t) (chartRingExt K L t) ≤ + (heightOneBelow (R := chartRingExt K L t) Q.1 Q.ne_top + (algebraMap_chartRingExt_mem t Q htQ)).asIdeal := +- Ideal.mul_le_right.trans fun c hc ↦ mem_heightOneBelow.mpr (h c hc) ++ Ideal.mul_le_left.trans fun c hc ↦ mem_heightOneBelow.mpr (h c hc) + rw [hcd] at hle + exact hunit (mem_heightOneBelow.mp (hle (Ideal.mem_span_singleton_self _))) + +diff --git a/Belyi/CurveField/Point.lean b/Belyi/CurveField/Point.lean +index 2dc6d8369c43f30a75c9ed06321882a01ecc8aa8..70d055182fd8f8b08de4c4d9f4debc97e0959f9a 100644 +--- a/Belyi/CurveField/Point.lean ++++ b/Belyi/CurveField/Point.lean +@@ -169,7 +169,7 @@ theorem exists_P_eq (P : Place K) : ∃ x : QbarPoint K, x.P = P := + rfl⟩ + + instance (P : Place K) : Finite (P.ResidueField →+* AlgebraicClosure ℚ) := +- Finite.of_equiv _ RingHom.equivRatAlgHom.symm ++ Finite.of_equiv _ (RingHom.equivRatAlgHom P.ResidueField (AlgebraicClosure ℚ)).symm + + /-- Only finitely many points lie over a finite set of places. -/ + theorem finite_setOf_mem {S : Set (Place K)} (hS : S.Finite) : +diff --git a/Belyi/P1/BaseChange.lean b/Belyi/P1/BaseChange.lean +index 67e8ea29c3b37ccb5050567dfc607f393ae525bc..45353c4786ceb7486db5baacea394e5cb22b7a7e 100644 +--- a/Belyi/P1/BaseChange.lean ++++ b/Belyi/P1/BaseChange.lean +@@ -152,7 +152,7 @@ lemma irrelevant_le_map_gradedMapOfAlgebra : + have h := Ideal.mem_map_of_mem (f := gradedMapOfAlgebra k₀ K) + (show X j ∈ (HomogeneousIdeal.irrelevant (P1Grading k₀)).toIdeal from hXj) + rwa [gradedMapOfAlgebra_apply, MvPolynomial.map_X] at h +- have hdvd : (X j : MvPolynomial (Fin 2) K) ∣ monomial d (coeff d p) := by ++ have hdvd : (X j : MvPolynomial (Fin 2) K) ∣ monomial d (p.coeff d) := by + rw [X, MvPolynomial.monomial_dvd_monomial] + exact ⟨Or.inr (by simpa [Finsupp.single_le_iff] using Nat.one_le_iff_ne_zero.mpr hj), + one_dvd _⟩ +diff --git a/Belyi/P1/BaseChangeIso.lean b/Belyi/P1/BaseChangeIso.lean +index 21faa2ba37302121df279eba05eeaaee970939e3..68d7005cb52f1ce424a12482d49efa03fc2f6a42 100644 +--- a/Belyi/P1/BaseChangeIso.lean ++++ b/Belyi/P1/BaseChangeIso.lean +@@ -217,7 +217,7 @@ lemma irrelevant_le_span_X (k : Type u) [CommRing k] : + have hXj : (X j : MvPolynomial (Fin 2) k) ∈ + Ideal.span (Set.range (fun i : Fin 2 => (X i : MvPolynomial (Fin 2) k))) := + Ideal.subset_span ⟨j, rfl⟩ +- have hdvd : (X j : MvPolynomial (Fin 2) k) ∣ monomial d (coeff d p) := by ++ have hdvd : (X j : MvPolynomial (Fin 2) k) ∣ monomial d (p.coeff d) := by + rw [X, MvPolynomial.monomial_dvd_monomial] + exact ⟨Or.inr (by simpa [Finsupp.single_le_iff] using Nat.one_le_iff_ne_zero.mpr hj), + one_dvd _⟩ +diff --git a/Belyi/P1/PointsBaseChange.lean b/Belyi/P1/PointsBaseChange.lean +index 45a48c5d2f6fd9d5ce64b3dc5c6069d12a3ec505..2e91534e2218acc5817e46cefa8ddca786948591 100644 +--- a/Belyi/P1/PointsBaseChange.lean ++++ b/Belyi/P1/PointsBaseChange.lean +@@ -39,9 +39,9 @@ variable {σ : Type*} {R S : Type*} [CommRing R] [CommRing S] + /-- `x` is divisible by `monomial s 1` iff every coefficient at a multi-index not `≥ s` + vanishes. -/ + lemma monomial_one_dvd_iff_forall_coeff (x : MvPolynomial σ R) (s : σ →₀ ℕ) : +- (monomial s 1) ∣ x ↔ ∀ d, ¬ s ≤ d → coeff d x = 0 := by ++ (monomial s 1) ∣ x ↔ ∀ d, ¬ s ≤ d → x.coeff d = 0 := by + rw [monomial_one_dvd_iff_modMonomial_eq_zero, MvPolynomial.ext_iff] +- simp only [coeff_zero] ++ simp only [AddMonoidAlgebra.coeff_zero, Finsupp.zero_apply] + constructor + · intro h d hd + rw [← coeff_modMonomial_of_not_le x hd] +diff --git a/Belyi/P1/PolynomialMap.lean b/Belyi/P1/PolynomialMap.lean +index 42a9a639fb8f479e712e560ea9ab9d3b0ba9b574..68e923dda9fa8a991b8fbbcece70bc63e7424c47 100644 +--- a/Belyi/P1/PolynomialMap.lean ++++ b/Belyi/P1/PolynomialMap.lean +@@ -64,7 +64,7 @@ lemma X1_dvd_homogInput_sub : + homogInput k g - C (g.coeff g.natDegree) * X 0 ^ g.natDegree := by + rw [MvPolynomial.X_dvd_iff_modMonomial_eq_zero] + ext m +- rw [coeff_zero] ++ rw [AddMonoidAlgebra.coeff_zero, Finsupp.zero_apply] + by_cases hm : Finsupp.single (1 : Fin 2) 1 ≤ m + · exact MvPolynomial.coeff_modMonomial_of_le _ hm + · rw [MvPolynomial.coeff_modMonomial_of_not_le _ hm] +@@ -122,7 +122,7 @@ lemma X1_notMem_or_homogInput_notMem (hd : 0 < g.natDegree) + obtain ⟨j, hj⟩ : ∃ j, dd j ≠ 0 := by + by_contra hcon + exact hd0 (by ext j; simpa using not_not.mp (not_exists.mp hcon j)) +- have hdvd : (X j : MvPolynomial (Fin 2) k) ∣ monomial dd (coeff dd p) := by ++ have hdvd : (X j : MvPolynomial (Fin 2) k) ∣ monomial dd (p.coeff dd) := by + rw [MvPolynomial.X, MvPolynomial.monomial_dvd_monomial] + exact ⟨Or.inr (by simpa [Finsupp.single_le_iff] using Nat.one_le_iff_ne_zero.mpr hj), + one_dvd _⟩ +diff --git a/lake-manifest.json b/lake-manifest.json +index 5353a1a61ba8bdc45abdead73e0e5baa1c450bb7..7f84303cb861125f4c4a0499e51c10f46933cd33 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,31 +1,51 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/lana-agents/oka.git", ++ [{"url": "https://github.com/lana-agents/belyi.git", + "type": "git", + "subDir": null, + "scope": "", +- "rev": "da228a2cf9671aaba08ddc96274d75e098b28f67", ++ "rev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "name": "belyi", ++ "manifestFile": "lake-manifest.json", ++ "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "inherited": true, ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/oka.git", ++ "type": "git", ++ "subDir": null, ++ "scope": "", ++ "rev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", + "name": "oka", + "manifestFile": "lake-manifest.json", +- "inputRev": "da228a2cf9671aaba08ddc96274d75e098b28f67", ++ "inputRev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/mathlib4", ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, ++ {"url": "https://github.com/lana-agents/heights.git", ++ "type": "git", ++ "subDir": null, ++ "scope": "", ++ "rev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", ++ "name": "heights", ++ "manifestFile": "lake-manifest.json", ++ "inputRev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", ++ "inherited": true, ++ "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -35,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -65,7 +85,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -75,7 +95,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -85,7 +105,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -95,10 +115,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "belyi", +diff --git a/lakefile.toml b/lakefile.toml +index 070a3d25f5ff8b83defe14d6e08e25b0eaa46449..28c618d17067766cc8d57c5a2dca9f227227c1ee 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["Belyi"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -11,13 +13,13 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[require]] + name = "oka" + git = "https://github.com/lana-agents/oka.git" +-rev = "da228a2cf9671aaba08ddc96274d75e098b28f67" ++rev = "75dcdc3faadd10b986afb9283e89902bcdddecd4" + + [[lean_lib]] + name = "Belyi" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/carleson-lean4341.patch b/lean/patches/carleson-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..cd2c5058a88ee0bfd1881ca64cc63852f9245b25 --- /dev/null +++ b/lean/patches/carleson-lean4341.patch @@ -0,0 +1,4374 @@ +diff --git a/Carleson/Calculations.lean b/Carleson/Calculations.lean +index 6eb7367..259674d 100644 +--- a/Carleson/Calculations.lean ++++ b/Carleson/Calculations.lean +@@ -1,4 +1,7 @@ +-/- ++import Carleson.ProofData ++import Mathlib.Tactic.Rify ++ ++/-! + This is a file for arithmetical lemmas - + lemmas that don't depend on any of Carleson's project definitions, or, really, + on any fancy definitions period. +@@ -7,9 +10,6 @@ Roughly speaking, if a lemma is in this file, it should be purely calculational/ + e.g. `lemma calculation_1 : 2 + 2 = 4`. + All lemmas are prepended with a prefix `calculation_`. + -/ +-import Carleson.ProofData +-import Mathlib.Tactic.Rify +- + open ShortVariables + open scoped NNReal ENNReal + variable {X : Type*} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} +@@ -80,7 +80,8 @@ lemma calculation_10 (h : (100 : ℝ) < D) : + _ < _ := by norm_num + + lemma calculation_3 [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] {x y : ℤ} (h : x + 3 < y) : +- 100 * D ^ (x + 3) + ((4 * D ^ (-2 : ℝ)) * D ^ (x + 3)) + (((8 : ℝ)⁻¹ * D ^ (-3 : ℝ)) * D ^ (x + 3)) + 8 * D ^ y < 10 * D ^ y := by ++ 100 * D ^ (x + 3) + ((4 * D ^ (-2 : ℝ)) * D ^ (x + 3)) + ++ (((8 : ℝ)⁻¹ * D ^ (-3 : ℝ)) * D ^ (x + 3)) + 8 * D ^ y < 10 * D ^ y := by + rw [← show (2 : ℝ) + 8 = 10 by norm_num, right_distrib] + gcongr + rw [← distrib_three_right ..] +@@ -120,9 +121,11 @@ lemma calculation_4 [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] + gcongr + _ ≤ 100 * D ^ (s_1 + 3) + 4 * D ^ (s_1 + 1) + 8⁻¹ * D ^ s_1 + 8 * D ^ s_3 := by + gcongr +- _ = 100 * D ^ (s_1 + 3) + ((4 * D ^ (- 2 : ℝ)) * D ^ (s_1 + 3)) + 8⁻¹ * D ^ s_1 + 8 * D ^ s_3 := by ++ _ = 100 * D ^ (s_1 + 3) + ((4 * D ^ (- 2 : ℝ)) * D ^ (s_1 + 3)) + ++ 8⁻¹ * D ^ s_1 + 8 * D ^ s_3 := by + rw [calculation_1 (s := s_1)] +- _ = 100 * D ^ (s_1 + 3) + ((4 * D ^ (- 2 : ℝ)) * D ^ (s_1 + 3)) + (((8 : ℝ)⁻¹ * D ^ (- 3 : ℝ)) * D ^ (s_1 + 3)) + 8 * D ^ s_3 := by ++ _ = 100 * D ^ (s_1 + 3) + ((4 * D ^ (- 2 : ℝ)) * D ^ (s_1 + 3)) + ++ (((8 : ℝ)⁻¹ * D ^ (- 3 : ℝ)) * D ^ (s_1 + 3)) + 8 * D ^ s_3 := by + rw [calculation_2 (s := s_1)] + _ < 10 * D ^ s_3 := by + exact calculation_3 (h := three) (X := X) +@@ -271,7 +274,6 @@ lemma calculation_7_7_4 [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] + trans 2 ^ 12 + · norm_num + gcongr +- · norm_num + lia + exact Nat.mul_le_mul this (Nat.le_add_left 1 n) + +diff --git a/Carleson/Defs.lean b/Carleson/Defs.lean +index a78a398..9da62ec 100644 +--- a/Carleson/Defs.lean ++++ b/Carleson/Defs.lean +@@ -4,11 +4,6 @@ import Carleson.ToMathlib.WeakType + import Mathlib.Analysis.CStarAlgebra.Classes + import Mathlib.Analysis.Fourier.AddCircle + +-open MeasureTheory Measure Metric Complex Set Function ENNReal +-open scoped NNReal +- +-noncomputable section +- + /-! # Main statements of the Carleson project + + This file contains the statements of the main theorems from the Carleson formalization project: +@@ -31,6 +26,11 @@ Fourier sums for continous functions (Theorem 1.0.1 in the blueprint). + + -/ + ++open MeasureTheory Measure Metric Complex Set Function ENNReal ++open scoped NNReal ++ ++noncomputable section ++ + section DoublingMeasure + + universe u +@@ -74,15 +74,12 @@ variable [FunctionDistances 𝕜 X] + instance : Coe (Θ X) C(X, 𝕜) := ⟨FunctionDistances.coeΘ⟩ + instance : FunLike (Θ X) X 𝕜 where + coe := fun f ↦ (f : C(X, 𝕜)) +- coe_injective' _ _ hfg := FunctionDistances.coeΘ_injective fun x ↦ congrFun hfg x +- +-set_option linter.unusedVariables false in ++ coe_injective _ _ hfg := FunctionDistances.coeΘ_injective fun x ↦ congrFun hfg x + /-- Class used to endow `Θ X` with a pseudometric space structure. -/ +-@[nolint unusedArguments] +-def WithFunctionDistance (x : X) (r : ℝ) := Θ X ++def WithFunctionDistance (_x : X) (_r : ℝ) := Θ X + +-instance {x : X} {r : ℝ} [d : FunctionDistances 𝕜 X] : +- PseudoMetricSpace (WithFunctionDistance x r) := d.metric x r ++instance {x : X} {r : ℝ} : ++ PseudoMetricSpace (WithFunctionDistance x r) := FunctionDistances.metric x r + + end FunctionDistances + +@@ -228,8 +225,6 @@ This section contains the statements of the main theorems from the project: Theo + (classical Carleson), Theorem 1.1.1 (metric space Carleson) and Theorem 1.1.2 (linearised metric + Carleson). -/ + +-set_option linter.unusedVariables false +- + open Real + + /-- The Nᵗʰ partial Fourier sum of `f : ℝ → ℂ` for `N : ℕ`. -/ +@@ -242,7 +237,7 @@ local notation "S_" => partialFourierSum + continous functions. + For the proof, see `classical_carleson` in the file `Carleson.Classical.ClassicalCarleson`. -/ + def ClassicalCarleson : Prop := +- ∀ {f : ℝ → ℂ} (cont_f : Continuous f) (periodic_f : f.Periodic (2 * π)), ++ ∀ {f : ℝ → ℂ} (_cont_f : Continuous f) (_periodic_f : f.Periodic (2 * π)), + ∀ᵐ x, Filter.Tendsto (S_ · f x) Filter.atTop (nhds (f x)) + + /-- The constant used in `MetricSpaceCarleson` and `LinearizedMetricCarleson`. +@@ -253,10 +248,10 @@ def C1_0_2 (a : ℕ) (q : ℝ≥0) : ℝ≥0 := 2 ^ ((3 * 𝕔 + 18 + 5 * (𝕔 + For the proof, see `metric_carleson` in the file `Carleson.MetricCarleson.Main`. -/ + def MetricSpaceCarleson : Prop := + ∀ {X : Type*} {a : ℕ} [MetricSpace X] {q q' : ℝ≥0} {F G : Set X} {K : X → X → ℂ} +- [KernelProofData a K] {f : X → ℂ} [IsCancellative X (defaultτ a)] (hq : q ∈ Ioc 1 2) +- (hqq' : q.HolderConjugate q') (mF : MeasurableSet F) (mG : MeasurableSet G) +- (mf : Measurable f) (nf : (‖f ·‖) ≤ F.indicator 1) +- (hT : HasBoundedStrongType (nontangentialOperator K · ·) 2 2 volume volume (C_Ts a)), ++ [KernelProofData a K] {f : X → ℂ} [IsCancellative X (defaultτ a)] (_hq : q ∈ Ioc 1 2) ++ (_hqq' : q.HolderConjugate q') (_mF : MeasurableSet F) (_mG : MeasurableSet G) ++ (_mf : Measurable f) (_nf : (‖f ·‖) ≤ F.indicator 1) ++ (_hT : HasBoundedStrongType (nontangentialOperator K · ·) 2 2 volume volume (C_Ts a)), + ∫⁻ x in G, carlesonOperator K f x ≤ C1_0_2 a q * volume G ^ (q' : ℝ)⁻¹ * volume F ^ (q : ℝ)⁻¹ + + /-- Theorem 1.1.2. +@@ -264,9 +259,10 @@ For the proof, see `linearized_metric_carleson` in the file `Carleson.MetricCarl + def LinearizedMetricCarleson : Prop := + ∀ {X : Type*} {a : ℕ} [MetricSpace X] {q q' : ℝ≥0} {F G : Set X} {K : X → X → ℂ} + [KernelProofData a K] {Q : SimpleFunc X (Θ X)} {f : X → ℂ} [IsCancellative X (defaultτ a)] +- (hq : q ∈ Ioc 1 2) (hqq' : q.HolderConjugate q') (mF : MeasurableSet F) (mG : MeasurableSet G) +- (mf : Measurable f) (nf : (‖f ·‖) ≤ F.indicator 1) +- (hT : ∀ θ : Θ X, HasBoundedStrongType (linearizedNontangentialOperator Q θ K · ·) ++ (_hq : q ∈ Ioc 1 2) (_hqq' : q.HolderConjugate q') ++ (_mF : MeasurableSet F) (_mG : MeasurableSet G) ++ (_mf : Measurable f) (_nf : (‖f ·‖) ≤ F.indicator 1) ++ (_hT : ∀ θ : Θ X, HasBoundedStrongType (linearizedNontangentialOperator Q θ K · ·) + 2 2 volume volume (C_Ts a)), + ∫⁻ x in G, linearizedCarlesonOperator Q K f x ≤ + C1_0_2 a q * volume G ^ (q' : ℝ)⁻¹ * volume F ^ (q : ℝ)⁻¹ +diff --git a/Carleson/DoublingMeasure.lean b/Carleson/DoublingMeasure.lean +index e571aff..f186a8a 100644 +--- a/Carleson/DoublingMeasure.lean ++++ b/Carleson/DoublingMeasure.lean +@@ -2,12 +2,6 @@ import Carleson.Defs + import Carleson.LipschitzNorm + import Carleson.ToMathlib.Data.ENNReal + +-open MeasureTheory Measure Metric Complex Set Bornology Function +-open ENNReal hiding one_lt_two +-open scoped NNReal +- +-noncomputable section +- + /-! # Basic definitions and lemmas + + This file contains definitions from Section 2 of the blueprint and used throughout the proof +@@ -18,6 +12,12 @@ provided for them (as well as for the constants `a` and `tau`). + + -/ + ++open MeasureTheory Measure Metric Complex Set Bornology Function ++open ENNReal hiding one_lt_two ++open scoped NNReal ++ ++noncomputable section ++ + lemma seven_le_c : 7 ≤ 𝕔 := by simp [𝕔] + + lemma c_le_100 : 𝕔 ≤ 100 := by simp [𝕔] +@@ -76,8 +76,7 @@ lemma hundred_lt_D : 100 < defaultD a := by + have : 16 ≤ a ^ 2 := by nlinarith [four_le_a X] + simp only [defaultD] + gcongr +- · norm_num +- · nlinarith [seven_le_c] ++ nlinarith [seven_le_c] + + -- used in 7.5.6 (`limited_scale_impact`) + lemma hundred_lt_realD : (100 : ℝ) < defaultD a := mod_cast hundred_lt_D X +@@ -190,7 +189,7 @@ variable [FunctionDistances 𝕜 X] + + instance : ContinuousMapClass (Θ X) X 𝕜 := ⟨fun f ↦ (f : C(X, 𝕜)).2⟩ + +-def toWithFunctionDistance {x : X} {r : ℝ} [FunctionDistances 𝕜 X] : ++def toWithFunctionDistance {x : X} {r : ℝ} : + Θ X ≃ WithFunctionDistance x r := .refl _ + + end FunctionDistances +@@ -219,12 +218,12 @@ lemma oscillation_le_cdist [CompatibleFunctions 𝕜 X A] (x : X) (r : ℝ) (f g + (hy : y ∈ ball x r) (hz : z ∈ ball x r) : + ‖coeΘ f y - coeΘ g y - coeΘ f z + coeΘ g z‖ ≤ dist_{x, r} f g := by + apply le_trans <| le_localOscillation x r f g hy hz +- rw [← ENNReal.toReal_ofReal dist_nonneg] ++ erw [← ENNReal.toReal_ofReal dist_nonneg] + exact ENNReal.toReal_mono ENNReal.ofReal_ne_top CompatibleFunctions.localOscillation_le_cdist + + export CompatibleFunctions (localOscillation_le_cdist cdist_mono cdist_le le_cdist) + +-lemma dist_congr [FunctionDistances 𝕜 X] {x₁ x₂ : X} {r₁ r₂ : ℝ} {f g : Θ X} ++lemma cdist_congr [FunctionDistances 𝕜 X] {x₁ x₂ : X} {r₁ r₂ : ℝ} {f g : Θ X} + (e₁ : x₁ = x₂) (e₂ : r₁ = r₂) : dist_{x₁, r₁} f g = dist_{x₂, r₂} f g := by congr + + variable (X) in +@@ -253,7 +252,9 @@ lemma enorm_integral_exp_le [CompatibleFunctions ℝ X A] {τ : ℝ} [IsCancella + rcases eq_or_ne (iLipENorm φ x r) ∞ with h1 | h1 + · apply le_top.trans_eq + symm +- simp [h1, edist_ne_top, hA, (measure_ball_pos volume x hr).ne'] ++ have finite_dist : edist_{x, r} f g ≠ ∞ := edist_ne_top ++ (toWithFunctionDistance f) (toWithFunctionDistance g) ++ simp [h1, finite_dist, hA, (measure_ball_pos volume x hr).ne'] + exact IsCancellative.enorm_integral_exp_le' hr h1 h2 + + /-- Constructor of `IsCancellative` in terms of real norms instead of extended reals. -/ +@@ -266,7 +267,7 @@ lemma isCancellative_of_norm_integral_exp_le (τ : ℝ) [CompatibleFunctions ℝ + constructor + intro x r φ hr h1 h2 f g + convert ENNReal.ofReal_le_ofReal (h (x := x) (r := r) (φ := φ) hr h1 h2 (f := f) (g := g)) +- · rw [ofReal_norm_eq_enorm] ++ · rw [ofReal_norm] + congr 1 + rw [setIntegral_eq_integral_of_forall_compl_eq_zero (fun y hy ↦ ?_)] + have : φ y = 0 := by +@@ -280,10 +281,10 @@ lemma isCancellative_of_norm_integral_exp_le (τ : ℝ) [CompatibleFunctions ℝ + · simp + · simp only [Measure.real, ofReal_toReal measure_ball_ne_top] + · simp [iLipNNNorm, coe_toNNReal h1] +- · rw [← ENNReal.ofReal_rpow_of_pos (by positivity)] ++ · have nonneg_dist : 0 ≤ dist_{x, r} f g := dist_nonneg ++ rw [← ENNReal.ofReal_rpow_of_pos (by linarith)] + congr +- rw [ENNReal.ofReal_add zero_le_one dist_nonneg] +- simp [edist_dist] ++ erw [ENNReal.ofReal_add zero_le_one dist_nonneg, ENNReal.ofReal_one, edist_dist] + + /-- The "volume function" `V`. We will need to assume + `IsFiniteMeasureOnCompacts` and `ProperSpace` to actually know that this volume is finite. -/ +@@ -492,25 +493,28 @@ variable [CompatibleFunctions ℝ X (defaultA a)] + lemma le_cdist_iterate {x : X} {r : ℝ} (hr : 0 ≤ r) (f g : Θ X) (k : ℕ) : + 2 ^ k * dist_{x, r} f g ≤ dist_{x, (defaultA a) ^ k * r} f g := by + induction k with +- | zero => rw [pow_zero, one_mul]; congr! <;> simp ++ | zero => ++ rw [pow_zero, one_mul] ++ exact (cdist_congr rfl (by simp)).le + | succ k ih => + trans 2 * dist_{x, (defaultA a) ^ k * r} f g + · rw [pow_succ', mul_assoc] + exact (mul_le_mul_iff_right₀ zero_lt_two).mpr ih + · convert le_cdist (ball_subset_ball _) using 1 +- · exact dist_congr rfl (by rw [← mul_assoc, pow_succ']) ++ · exact cdist_congr rfl (by rw [← mul_assoc, pow_succ']) + · nth_rw 1 [← one_mul ((defaultA a) ^ k * r)]; gcongr + rw [← Nat.cast_one, Nat.cast_le]; exact Nat.one_le_two_pow + + lemma cdist_le_iterate {x : X} {r : ℝ} (hr : 0 < r) (f g : Θ X) (k : ℕ) : + dist_{x, 2 ^ k * r} f g ≤ (defaultA a) ^ k * dist_{x, r} f g := by + induction k with +- | zero => simp_rw [pow_zero, one_mul]; congr! <;> simp ++ | zero => ++ rw [pow_zero, one_mul, pow_zero, one_mul] + | succ k ih => + trans defaultA a * dist_{x, 2 ^ k * r} f g +- · convert cdist_le _ using 1 +- · exact dist_congr rfl (by ring) +- · rw [dist_self]; positivity ++ · convert cdist_le (x₁ := x) (x₂ := x) (f := f) (g := g) ++ (r := 2 ^ k * r) (by rw [dist_self]; positivity) using 1 ++ exact cdist_congr rfl (by ring) + · replace ih := (mul_le_mul_iff_right₀ (show 0 < (defaultA a : ℝ) by positivity)).mpr ih + rwa [← mul_assoc, ← pow_succ'] at ih + +diff --git a/Carleson/LipschitzNorm.lean b/Carleson/LipschitzNorm.lean +index 7c1a823..39c29c5 100644 +--- a/Carleson/LipschitzNorm.lean ++++ b/Carleson/LipschitzNorm.lean +@@ -2,9 +2,6 @@ import Mathlib.Analysis.Normed.Field.Basic + import Mathlib.Topology.EMetricSpace.Lipschitz + import Carleson.Defs + +-open Metric Function ENNReal +-open scoped NNReal +- + /-! + # Inhomogeneous Lipschitz norm + +@@ -14,6 +11,9 @@ Lemmas about this norm that are proven in Carleson are collected here. + TODO: Assess Mathlib-readiness, complete basic results, optimize imports. + -/ + ++open Metric Function ENNReal ++open scoped NNReal ++ + noncomputable section + + section Def +@@ -54,7 +54,7 @@ lemma iLipENorm_le_add (h : ∀ x ∈ ball z R, ‖φ x‖ ≤ C) + have W := h' x hx x' hx' hne + rw [ENNReal.div_le_iff (by simpa only [ne_eq, edist_eq_zero] using hne) (edist_ne_top x x')] + convert ENNReal.ofReal_le_ofReal W +- · exact (ofReal_norm_eq_enorm (φ x - φ x')).symm ++ · exact (ofReal_norm (φ x - φ x')).symm + · rw [ENNReal.ofReal_div_of_pos hR, ENNReal.ofReal_mul NNReal.zero_le_coe, edist_dist, + ENNReal.mul_div_right_comm, ENNReal.ofReal_coe_nnreal] + +diff --git a/Carleson/ProofData.lean b/Carleson/ProofData.lean +index 0046632..1582b2d 100644 +--- a/Carleson/ProofData.lean ++++ b/Carleson/ProofData.lean +@@ -1,10 +1,5 @@ + import Carleson.DoublingMeasure + +-open MeasureTheory Measure Metric Complex Set TopologicalSpace Bornology Function +-open ENNReal hiding one_lt_two +-open scoped NNReal +-noncomputable section +- + /-! # ProofData. + + This file introduces the class `ProofData`, used to bundle data common through most of +@@ -12,6 +7,11 @@ chapters 2-7 (except 3), and provides API for it. + + -/ + ++open MeasureTheory Measure Metric Complex Set TopologicalSpace Bornology Function ++open ENNReal hiding one_lt_two ++open scoped NNReal ++noncomputable section ++ + /-- Data common through most of chapters 2-7 (except 3). -/ + class ProofData {X : Type*} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) + (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] extends +@@ -180,7 +180,6 @@ lemma DκZ_le_two_rpow_100 [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F + _ ≤ 1 * 4 ^ 2 * 2 ^ (2 * 4) := by norm_num + _ ≤ _ := by + gcongr +- norm_num + + lemma four_le_Z [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : 4 ≤ Z := by + rw [defaultZ, show 4 = 2 ^ 2 by rfl] +diff --git a/Carleson/ToMathlib/Annulus.lean b/Carleson/ToMathlib/Annulus.lean +index 207eb52..09d38d0 100644 +--- a/Carleson/ToMathlib/Annulus.lean ++++ b/Carleson/ToMathlib/Annulus.lean +@@ -183,67 +183,67 @@ lemma cc_subset_closedBall {x : X} {r R : ℝ} : cc x r R ⊆ closedBall x R := + lemma oc_union_oo {x : X} {r r' R : ℝ} (h₁ : r ≤ r') (h₂ : r' < R) : + oc x r r' ∪ oo x r' R = oo x r R := by + -- XXX: should this proof be written as `ext; grind [oc, oo]` instead? Same question below. +- ext; simp_rw [oc, oo, mem_union, mem_setOf_eq, ← mem_union, Ioc_union_Ioo_eq_Ioo h₁ h₂] ++ ext; simp_rw [oc, oo, mem_union, mem_ofPred_eq, ← mem_union, Ioc_union_Ioo_eq_Ioo h₁ h₂] + + @[simp] + lemma oc_union_oc {x : X} {r r' R : ℝ} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + oc x r r' ∪ oc x r' R = oc x r R := by +- ext; simp_rw [oc, mem_union, mem_setOf_eq, ← mem_union, Ioc_union_Ioc_eq_Ioc h₁ h₂] ++ ext; simp_rw [oc, mem_union, mem_ofPred_eq, ← mem_union, Ioc_union_Ioc_eq_Ioc h₁ h₂] + + @[simp] + lemma oo_union_co {x : X} {r r' R : ℝ} (h₁ : r < r') (h₂ : r' ≤ R) : + oo x r r' ∪ co x r' R = oo x r R := by +- ext; simp_rw [oo, co, mem_union, mem_setOf_eq, ← mem_union, Ioo_union_Ico_eq_Ioo h₁ h₂] ++ ext; simp_rw [oo, co, mem_union, mem_ofPred_eq, ← mem_union, Ioo_union_Ico_eq_Ioo h₁ h₂] + + @[simp] + lemma oo_union_cc {x : X} {r r' R : ℝ} (h₁ : r < r') (h₂ : r' ≤ R) : + oo x r r' ∪ cc x r' R = oc x r R := by +- ext; simp_rw [oo, cc, oc, mem_union, mem_setOf_eq, ← mem_union, Ioo_union_Icc_eq_Ioc h₁ h₂] ++ ext; simp_rw [oo, cc, oc, mem_union, mem_ofPred_eq, ← mem_union, Ioo_union_Icc_eq_Ioc h₁ h₂] + + @[simp] + lemma cc_union_oo {x : X} {r r' R : ℝ} (h₁ : r ≤ r') (h₂ : r' < R) : + cc x r r' ∪ oo x r' R = co x r R := by +- ext; simp_rw [cc, oo, co, mem_union, mem_setOf_eq, ← mem_union, Icc_union_Ioo_eq_Ico h₁ h₂] ++ ext; simp_rw [cc, oo, co, mem_union, mem_ofPred_eq, ← mem_union, Icc_union_Ioo_eq_Ico h₁ h₂] + + @[simp] + lemma cc_union_oc {x : X} {r r' R : ℝ} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + cc x r r' ∪ oc x r' R = cc x r R := by +- ext; simp_rw [cc, oc, mem_union, mem_setOf_eq, ← mem_union, Icc_union_Ioc_eq_Icc h₁ h₂] ++ ext; simp_rw [cc, oc, mem_union, mem_ofPred_eq, ← mem_union, Icc_union_Ioc_eq_Icc h₁ h₂] + + @[simp] + lemma co_union_co {x : X} {r r' R : ℝ} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + co x r r' ∪ co x r' R = co x r R := by +- ext; simp_rw [co, mem_union, mem_setOf_eq, ← mem_union, Ico_union_Ico_eq_Ico h₁ h₂] ++ ext; simp_rw [co, mem_union, mem_ofPred_eq, ← mem_union, Ico_union_Ico_eq_Ico h₁ h₂] + + @[simp] + lemma co_union_cc {x : X} {r r' R : ℝ} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + co x r r' ∪ cc x r' R = cc x r R := by +- ext; simp_rw [co, cc, mem_union, mem_setOf_eq, ← mem_union, Ico_union_Icc_eq_Icc h₁ h₂] ++ ext; simp_rw [co, cc, mem_union, mem_ofPred_eq, ← mem_union, Ico_union_Icc_eq_Icc h₁ h₂] + + @[simp] + lemma oc_union_oi {x : X} {r R : ℝ} (h : r ≤ R) : oc x r R ∪ oi x R = oi x r := by +- ext; simp_rw [oc, oi, mem_union, mem_setOf_eq, ← mem_union, Ioc_union_Ioi_eq_Ioi h] ++ ext; simp_rw [oc, oi, mem_union, mem_ofPred_eq, ← mem_union, Ioc_union_Ioi_eq_Ioi h] + + @[simp] + lemma oo_union_ci {x : X} {r R : ℝ} (h : r < R) : + oo x r R ∪ ci x R = oi x r := by +- ext; simp_rw [oo, ci, oi, mem_union, mem_setOf_eq, ← mem_union, Ioo_union_Ici_eq_Ioi h] ++ ext; simp_rw [oo, ci, oi, mem_union, mem_ofPred_eq, ← mem_union, Ioo_union_Ici_eq_Ioi h] + + @[simp] + lemma cc_union_oi {x : X} {r R : ℝ} (h : r ≤ R) : cc x r R ∪ oi x R = ci x r := by +- ext; simp_rw [cc, oi, ci, mem_union, mem_setOf_eq, ← mem_union, Icc_union_Ioi_eq_Ici h] ++ ext; simp_rw [cc, oi, ci, mem_union, mem_ofPred_eq, ← mem_union, Icc_union_Ioi_eq_Ici h] + + @[simp] + lemma co_union_ci {x : X} {r R : ℝ} (h : r ≤ R) : co x r R ∪ ci x R = ci x r := by +- ext; simp_rw [co, ci, mem_union, mem_setOf_eq, ← mem_union, Ico_union_Ici_eq_Ici h] ++ ext; simp_rw [co, ci, mem_union, mem_ofPred_eq, ← mem_union, Ico_union_Ici_eq_Ici h] + + theorem iUnion_co_eq_ci {x : X} {f : ℕ → ℝ} (hf : ∀ n, f 0 ≤ f n) (h2f : ¬BddAbove (range f)) : + ⋃ (i : Nat), co x (f i) (f (i+1)) = ci x (f 0) := by +- simp [co, ci, iUnion_setOf, ← iUnion_Ico_eq_Ici hf h2f] ++ simp [co, ci, iUnion_ofPred, ← iUnion_Ico_eq_Ici hf h2f] + + theorem iUnion_oc_eq_oi {x : X} {f : ℕ → ℝ} (hf : ∀ n, f 0 ≤ f n) (h2f : ¬BddAbove (range f)) : + ⋃ (i : Nat), oc x (f i) (f (i+1)) = oi x (f 0) := by +- simp [oc, oi, iUnion_setOf, ← iUnion_Ioc_eq_Ioi hf h2f] ++ simp [oc, oi, iUnion_ofPred, ← iUnion_Ioc_eq_Ioi hf h2f] + + variable {ι : Type*} [LinearOrder ι] [SuccOrder ι] + +@@ -501,59 +501,59 @@ lemma cc_subset_ci {x : X} {r₁ R₁ r₂ : ℝ≥0∞} (hr : r₂ ≤ r₁) : + @[simp] + lemma oc_union_oo {x : X} {r r' R : ℝ≥0∞} (h₁ : r ≤ r') (h₂ : r' < R) : + oc x r r' ∪ oo x r' R = oo x r R := by +- ext; simp_rw [oc, oo, mem_union, mem_setOf_eq, ← mem_union, Ioc_union_Ioo_eq_Ioo h₁ h₂] ++ ext; simp_rw [oc, oo, mem_union, mem_ofPred_eq, ← mem_union, Ioc_union_Ioo_eq_Ioo h₁ h₂] + + @[simp] + lemma oc_union_oc {x : X} {r r' R : ℝ≥0∞} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + oc x r r' ∪ oc x r' R = oc x r R := by +- ext; simp_rw [oc, mem_union, mem_setOf_eq, ← mem_union, Ioc_union_Ioc_eq_Ioc h₁ h₂] ++ ext; simp_rw [oc, mem_union, mem_ofPred_eq, ← mem_union, Ioc_union_Ioc_eq_Ioc h₁ h₂] + + @[simp] + lemma oo_union_co {x : X} {r r' R : ℝ≥0∞} (h₁ : r < r') (h₂ : r' ≤ R) : + oo x r r' ∪ co x r' R = oo x r R := by +- ext; simp_rw [oo, co, mem_union, mem_setOf_eq, ← mem_union, Ioo_union_Ico_eq_Ioo h₁ h₂] ++ ext; simp_rw [oo, co, mem_union, mem_ofPred_eq, ← mem_union, Ioo_union_Ico_eq_Ioo h₁ h₂] + + @[simp] + lemma oo_union_cc {x : X} {r r' R : ℝ≥0∞} (h₁ : r < r') (h₂ : r' ≤ R) : + oo x r r' ∪ cc x r' R = oc x r R := by +- ext; simp_rw [oo, cc, oc, mem_union, mem_setOf_eq, ← mem_union, Ioo_union_Icc_eq_Ioc h₁ h₂] ++ ext; simp_rw [oo, cc, oc, mem_union, mem_ofPred_eq, ← mem_union, Ioo_union_Icc_eq_Ioc h₁ h₂] + + @[simp] + lemma cc_union_oo {x : X} {r r' R : ℝ≥0∞} (h₁ : r ≤ r') (h₂ : r' < R) : + cc x r r' ∪ oo x r' R = co x r R := by +- ext; simp_rw [cc, oo, co, mem_union, mem_setOf_eq, ← mem_union, Icc_union_Ioo_eq_Ico h₁ h₂] ++ ext; simp_rw [cc, oo, co, mem_union, mem_ofPred_eq, ← mem_union, Icc_union_Ioo_eq_Ico h₁ h₂] + + @[simp] + lemma cc_union_oc {x : X} {r r' R : ℝ≥0∞} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + cc x r r' ∪ oc x r' R = cc x r R := by +- ext; simp_rw [cc, oc, mem_union, mem_setOf_eq, ← mem_union, Icc_union_Ioc_eq_Icc h₁ h₂] ++ ext; simp_rw [cc, oc, mem_union, mem_ofPred_eq, ← mem_union, Icc_union_Ioc_eq_Icc h₁ h₂] + + @[simp] + lemma co_union_co {x : X} {r r' R : ℝ≥0∞} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + co x r r' ∪ co x r' R = co x r R := by +- ext; simp_rw [co, mem_union, mem_setOf_eq, ← mem_union, Ico_union_Ico_eq_Ico h₁ h₂] ++ ext; simp_rw [co, mem_union, mem_ofPred_eq, ← mem_union, Ico_union_Ico_eq_Ico h₁ h₂] + + @[simp] + lemma co_union_cc {x : X} {r r' R : ℝ≥0∞} (h₁ : r ≤ r') (h₂ : r' ≤ R) : + co x r r' ∪ cc x r' R = cc x r R := by +- ext; simp_rw [co, cc, mem_union, mem_setOf_eq, ← mem_union, Ico_union_Icc_eq_Icc h₁ h₂] ++ ext; simp_rw [co, cc, mem_union, mem_ofPred_eq, ← mem_union, Ico_union_Icc_eq_Icc h₁ h₂] + + @[simp] + lemma oc_union_oi {x : X} {r R : ℝ≥0∞} (h : r ≤ R) : oc x r R ∪ oi x R = oi x r := by +- ext; simp_rw [oc, oi, mem_union, mem_setOf_eq, ← mem_union, Ioc_union_Ioi_eq_Ioi h] ++ ext; simp_rw [oc, oi, mem_union, mem_ofPred_eq, ← mem_union, Ioc_union_Ioi_eq_Ioi h] + + @[simp] + lemma oo_union_ci {x : X} {r R : ℝ≥0∞} (h : r < R) : + oo x r R ∪ ci x R = oi x r := by +- ext; simp_rw [oo, ci, oi, mem_union, mem_setOf_eq, ← mem_union, Ioo_union_Ici_eq_Ioi h] ++ ext; simp_rw [oo, ci, oi, mem_union, mem_ofPred_eq, ← mem_union, Ioo_union_Ici_eq_Ioi h] + + @[simp] + lemma cc_union_oi {x : X} {r R : ℝ≥0∞} (h : r ≤ R) : cc x r R ∪ oi x R = ci x r := by +- ext; simp_rw [cc, oi, ci, mem_union, mem_setOf_eq, ← mem_union, Icc_union_Ioi_eq_Ici h] ++ ext; simp_rw [cc, oi, ci, mem_union, mem_ofPred_eq, ← mem_union, Icc_union_Ioi_eq_Ici h] + + @[simp] + lemma co_union_ci {x : X} {r R : ℝ≥0∞} (h : r ≤ R) : co x r R ∪ ci x R = ci x r := by +- ext; simp_rw [co, ci, mem_union, mem_setOf_eq, ← mem_union, Ico_union_Ici_eq_Ici h] ++ ext; simp_rw [co, ci, mem_union, mem_ofPred_eq, ← mem_union, Ico_union_Ici_eq_Ici h] + + + variable [MeasurableSpace X] [OpensMeasurableSpace X] +diff --git a/Carleson/ToMathlib/BoundedFiniteSupport.lean b/Carleson/ToMathlib/BoundedFiniteSupport.lean +index 0d70eec..13329c5 100644 +--- a/Carleson/ToMathlib/BoundedFiniteSupport.lean ++++ b/Carleson/ToMathlib/BoundedFiniteSupport.lean +@@ -1,5 +1,7 @@ + import Mathlib.MeasureTheory.Function.L1Space.Integrable + ++/-! # Bounded functions with support of finite measure -/ ++ + /- + This file defines BoundedFiniteSupport. + +diff --git a/Carleson/ToMathlib/CoveredByBalls.lean b/Carleson/ToMathlib/CoveredByBalls.lean +index f763c0c..ad367d9 100644 +--- a/Carleson/ToMathlib/CoveredByBalls.lean ++++ b/Carleson/ToMathlib/CoveredByBalls.lean +@@ -1,5 +1,7 @@ + import Carleson.ToMathlib.Misc + ++/-! Covers by finitely many metric balls. -/ ++ + -- Upstreaming status: ready to go; two lemmas need to move to different files + -- and the remainder could go into a new file + +@@ -8,8 +10,6 @@ open scoped NNReal + + variable {X : Type*} [PseudoMetricSpace X] + {s t : Set X} {n m : ℕ} {r r' r₁ r₂ r₃ : ℝ} +- +-set_option linter.unusedVariables false in + /-- `s` can be covered by at most `N` balls with radius `r`. -/ + @[mk_iff] + class inductive CoveredByBalls (s : Set X) (n : ℕ) (r : ℝ) : Prop where +@@ -123,7 +123,7 @@ lemma pow {a : ℝ} {k : ℕ} (h : AllBallsCoverBalls X a n) : + AllBallsCoverBalls X (a ^ k) (n ^ k) := by + intro r + induction k with +- | zero => simpa using fun x ↦ .ball x r ++ | zero => simpa [BallsCoverBalls] using fun x ↦ CoveredByBalls.ball x r + | succ m h2 => + specialize h (r * a^m) + rw [← mul_assoc, mul_comm, ← mul_assoc] at h +diff --git a/Carleson/ToMathlib/Data/ENNReal.lean b/Carleson/ToMathlib/Data/ENNReal.lean +index 9884494..ede2520 100644 +--- a/Carleson/ToMathlib/Data/ENNReal.lean ++++ b/Carleson/ToMathlib/Data/ENNReal.lean +@@ -20,15 +20,6 @@ namespace ENNReal + attribute [simp] ofReal_of_nonpos + -- protect ENNReal.mul_le_mul_left + +-theorem ofReal_inv_le {x : ℝ} : ENNReal.ofReal x⁻¹ ≤ (ENNReal.ofReal x)⁻¹ := by +- obtain hx|hx := lt_or_ge 0 x <;> simp [ofReal_inv_of_pos, hx] +- +-theorem ofReal_div_le {x y : ℝ} (hy : 0 ≤ y) : +- ENNReal.ofReal (x / y) ≤ ENNReal.ofReal x / ENNReal.ofReal y := by +- simp_rw [div_eq_mul_inv, ofReal_mul' (inv_nonneg.2 hy)] +- gcongr +- exact ofReal_inv_le +- + theorem coe_lt_iff_lt_toNNReal {a : ℝ≥0∞} {t : ℝ≥0} (ha : a ≠ ⊤) : + t < a ↔ t < a.toNNReal := by + rw [← ENNReal.toNNReal_coe t, ENNReal.toNNReal_lt_toNNReal ENNReal.coe_ne_top ha] +@@ -110,7 +101,8 @@ lemma enorm_sum_eq_sum_enorm {f : α → ℝ} (hf : ∀ i ∈ t, 0 ≤ f i) : + + /-- The reverse triangle inequality for `enorm`. -/ + -- TODO: does a seminormed abelian additive group also have an ENormedAddMonoid structure? +-lemma enorm_enorm_sub_enorm_le {E} [NormedAddCommGroup E] {x y : E} : ‖‖x‖ₑ - ‖y‖ₑ‖ₑ ≤ ‖x - y‖ₑ := by ++lemma enorm_enorm_sub_enorm_le {E} [NormedAddCommGroup E] {x y : E} : ++ ‖‖x‖ₑ - ‖y‖ₑ‖ₑ ≤ ‖x - y‖ₑ := by + rw [enorm_eq_self, tsub_le_iff_right] + nth_rw 1 [← sub_add_cancel x y] + exact enorm_add_le (x - y) y +diff --git a/Carleson/ToMathlib/ENorm.lean b/Carleson/ToMathlib/ENorm.lean +index 92cb8f3..71b852b 100644 +--- a/Carleson/ToMathlib/ENorm.lean ++++ b/Carleson/ToMathlib/ENorm.lean +@@ -1,6 +1,8 @@ + import Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity + import Carleson.ToMathlib.Data.ENNReal + ++/-! # Extended norms and scalar multiplication of Lebesgue seminorms -/ ++ + -- Upstreaming status: can be upstreamed/being worked on + -- Many remaining declarations require PRing a new enorm class to mathlib first, + -- i.e. are not a good first target. +@@ -11,10 +13,11 @@ open ENNReal NNReal Function Set + + variable {α α' E E₁ E₂ : Type*} + +-@[simp] lemma enorm_toReal_le {x : ℝ≥0∞} : ‖x.toReal‖ₑ ≤ x := by simp [← ofReal_norm, ofReal_toReal_le] ++@[simp] lemma enorm_toReal_le {x : ℝ≥0∞} : ‖x.toReal‖ₑ ≤ x := by ++ simp [← ofReal_norm, ofReal_toReal_le] + + @[simp] lemma enorm_toReal {x : ℝ≥0∞} (hx : x ≠ ⊤) : ‖x.toReal‖ₑ = x := by +- simp [hx, ← ofReal_norm_eq_enorm] ++ simp [hx, ← ofReal_norm] + + @[simp] lemma enorm_NNReal {x : ℝ≥0} : ‖x‖ₑ = x := by rfl + +@@ -24,14 +27,16 @@ variable {α α' E E₁ E₂ : Type*} + + /-- An enormed monoid is an additive monoid endowed with a continuous enorm. + Note: not sure if this is the "right" class to add to Mathlib. -/ +-class ENormedAddCommSubMonoid (E : Type*) [TopologicalSpace E] extends ENormedAddCommMonoid E, Sub E where ++class ENormedAddCommSubMonoid (E : Type*) [TopologicalSpace E] ++ extends ENormedAddCommMonoid E, Sub E where + sub_add_cancel_of_enorm_le : ∀ ⦃x y : E⦄, ‖y‖ₑ ≤ ‖x‖ₑ → x - y + y = x + add_right_cancel_of_enorm_lt_top : ∀ ⦃x : E⦄, ‖x‖ₑ < ⊤ → ∀ {y z : E}, y + x = z + x → y = z + esub_self : ∀ x : E, x - x = 0 + + /-- An enormed space is an additive monoid endowed with a continuous enorm. + Note: not sure if this is the "right" class to add to Mathlib. -/ +-class ENormedSpace (E : Type*) [TopologicalSpace E] extends ENormedAddCommMonoid E, Module ℝ≥0 E where ++class ENormedSpace (E : Type*) [TopologicalSpace E] ++ extends ENormedAddCommMonoid E, Module ℝ≥0 E where + enorm_smul_eq_smul : ∀ (c : ℝ≥0) (x : E), ‖c • x‖ₑ = c • ‖x‖ₑ + + export ENormedAddCommSubMonoid +@@ -96,14 +101,63 @@ instance : ContinuousConstSMul ℝ≥0 ℝ≥0∞ where + + open MeasureTheory + ++/-- The norm-formula functional, without a strong-measurability requirement. -/ ++def eLpNormFormula {α ε : Type*} [MeasurableSpace α] [ENorm ε] (f : α → ε) (p : ℝ≥0∞) ++ (μ : Measure α) : ℝ≥0∞ := ++ if p = 0 then 0 else if p = ∞ then eLpNormEssSup f μ else eLpNorm' f p.toReal μ ++ ++theorem eLpNorm_eq_eLpNormFormula {α ε : Type*} [MeasurableSpace α] [TopologicalSpace ε] ++ [ENorm ε] {f : α → ε} ++ {p : ℝ≥0∞} {μ : Measure α} (hf : AEStronglyMeasurable f μ) : ++ eLpNorm f p μ = eLpNormFormula f p μ := by ++ simp [eLpNorm, eLpNormFormula, hf] ++ ++theorem eLpNormFormula_const_nnreal_smul_le {α : Type*} [MeasurableSpace α] ++ {p : ℝ≥0∞} {μ : Measure α} {c : ℝ≥0} {f : α → ε} : ++ eLpNormFormula (c • f) p μ ≤ ‖c‖ₑ * eLpNormFormula f p μ := by ++ have hbound : ∀ᵐ x ∂μ, ‖(c • f) x‖ₑ ≤ c * ‖f x‖ₑ := by ++ filter_upwards with point using by simp [ENNReal.smul_def] ++ by_cases hp : p = 0 ++ · simp [eLpNormFormula, hp] ++ by_cases htop : p = ∞ ++ · simpa [eLpNormFormula, hp, htop, ENNReal.smul_def] using ++ eLpNormEssSup_le_nnreal_smul_eLpNormEssSup_of_ae_le_mul' hbound ++ simpa [eLpNormFormula, hp, htop, ENNReal.smul_def] using ++ eLpNorm'_le_nnreal_smul_eLpNorm'_of_ae_le_mul' hbound (ENNReal.toReal_pos hp htop) ++ ++theorem eLpNormFormula_const_nnreal_smul {α : Type*} [MeasurableSpace α] ++ {p : ℝ≥0∞} {μ : Measure α} {c : ℝ≥0} {f : α → ε} : ++ eLpNormFormula (c • f) p μ = ‖c‖ₑ * eLpNormFormula f p μ := by ++ obtain rfl | hc := eq_or_ne c 0 ++ · rw [zero_smul, ← eLpNorm_eq_eLpNormFormula aestronglyMeasurable_zero] ++ simp ++ refine le_antisymm eLpNormFormula_const_nnreal_smul_le <| ENNReal.mul_le_of_le_div' ?_ ++ simpa [ENNReal.div_eq_inv_mul, hc] using ++ eLpNormFormula_const_nnreal_smul_le (c := c⁻¹) (f := c • f) ++ ++theorem eLpNorm_const_nnreal_smul_of_aestronglyMeasurable ++ {α : Type*} [MeasurableSpace α] {p : ℝ≥0∞} {μ : Measure α} {c : ℝ≥0} {f : α → ε} ++ (hf : AEStronglyMeasurable f μ) (hcf : AEStronglyMeasurable (c • f) μ) : ++ eLpNorm (c • f) p μ = ‖c‖ₑ * eLpNorm f p μ := by ++ rw [eLpNorm_eq_eLpNormFormula hf, eLpNorm_eq_eLpNormFormula hcf] ++ exact eLpNormFormula_const_nnreal_smul ++ + -- TODO: put next to MeasureTheory.eLpNorm_const_smul_le (which perhaps can stay) +-theorem eLpNorm_const_nnreal_smul_le {α : Type*} {m0 : MeasurableSpace α} {p : ℝ≥0∞} +- {μ : Measure α} {c : ℝ≥0} {f : α → ε} : eLpNorm (c • f) p μ ≤ ‖c‖ₑ * eLpNorm f p μ := by +- apply eLpNorm_le_nnreal_smul_eLpNorm_of_ae_le_mul' (p := p) ?_ +- filter_upwards with x using by simp [ENNReal.smul_def] ++theorem eLpNorm_const_nnreal_smul_le [ContinuousConstSMul ℝ≥0 ε] ++ {α : Type*} {m0 : MeasurableSpace α} {p : ℝ≥0∞} ++ {μ : Measure α} {c : ℝ≥0} {f : α → ε} : ++ eLpNorm (c • f) p μ ≤ ‖c‖ₑ * eLpNorm f p μ := by ++ by_cases hf : AEStronglyMeasurable f μ ++ · exact (eLpNorm_const_nnreal_smul_of_aestronglyMeasurable hf (hf.const_smul c)).le ++ rw [eLpNorm_of_not_aestronglyMeasurable hf] ++ obtain rfl | hc := eq_or_ne c 0 ++ · simp ++ · rw [ENNReal.mul_top (by simpa)] ++ exact le_top + + -- TODO: put next to eLpNorm_const_smul +-theorem eLpNorm_const_smul' {α : Type*} {m0 : MeasurableSpace α} {p : ℝ≥0∞} ++theorem eLpNorm_const_smul' [ContinuousConstSMul ℝ≥0 ε] ++ {α : Type*} {m0 : MeasurableSpace α} {p : ℝ≥0∞} + {μ : Measure α} {c : ℝ≥0} {f : α → ε} : + eLpNorm (c • f) p μ = ‖c‖ₑ * eLpNorm f p μ := by + obtain rfl | hc := eq_or_ne c 0 +@@ -113,21 +167,24 @@ theorem eLpNorm_const_smul' {α : Type*} {m0 : MeasurableSpace α} {p : ℝ≥0 + + set_option backward.isDefEq.respectTransparency false in + theorem eLpNorm_top_smul {α : Type*} {m0 : MeasurableSpace α} {p : ℝ≥0∞} +- {μ : Measure α} {f : α → ℝ≥0∞} (hf : AEStronglyMeasurable f μ) : eLpNorm (∞ • f) p μ = ⊤ * eLpNorm f p μ := by ++ {μ : Measure α} {f : α → ℝ≥0∞} (hf : AEStronglyMeasurable f μ) : ++ eLpNorm (∞ • f) p μ = ⊤ * eLpNorm f p μ := by ++ have htop : AEStronglyMeasurable (∞ • f) μ := ++ (hf.aemeasurable.const_mul ∞).aestronglyMeasurable + by_cases hp : p = 0 +- · simp [hp] ++ · simp [hp, hf, htop] + by_cases h : f =ᶠ[ae μ] 0 + · rw [eLpNorm_eq_zero_of_ae_zero h, mul_zero] + apply eLpNorm_eq_zero_of_ae_zero + filter_upwards [h] with x hx + simpa + · have : ¬ eLpNorm f p μ = 0 := by +- rwa [eLpNorm_eq_zero_iff hf hp] ++ rwa [eLpNorm_eq_zero_iff hp] + by_cases h' : eLpNorm f p μ = ⊤ + · simp only [h', ne_eq, top_ne_zero, not_false_eq_true, mul_top] + rw [eq_top_iff] at * + apply h'.trans +- apply eLpNorm_mono_enorm ++ apply eLpNorm_mono_enorm hf + intro x + simp only [enorm_eq_self, Pi.smul_apply, smul_eq_mul] + exact ENNReal.le_mul_top_self +@@ -145,7 +202,7 @@ theorem eLpNorm_top_smul {α : Type*} {m0 : MeasurableSpace α} {p : ℝ≥0∞} + congr + exact Eq.symm (coe_toNNReal h') + _ ≤ eLpNorm (∞ • f) p μ := by +- apply eLpNorm_mono_enorm ++ apply eLpNorm_mono_enorm (hf.const_smul _) + intro x + simp only [toNNReal_div, toNNReal_coe, Pi.smul_apply, enorm_smul_eq_smul, enorm_eq_self, + smul_eq_mul] +diff --git a/Carleson/ToMathlib/HardyLittlewood.lean b/Carleson/ToMathlib/HardyLittlewood.lean +index 5982df5..e3d46e3 100644 +--- a/Carleson/ToMathlib/HardyLittlewood.lean ++++ b/Carleson/ToMathlib/HardyLittlewood.lean +@@ -5,13 +5,13 @@ import Carleson.ToMathlib.Order.ConditionallyCompleteLattice.Indexed + import Mathlib.MeasureTheory.Covering.Vitali + import Mathlib.Tactic.Field + ++/-! This should roughly contain the contents of chapter 9. -/ ++ + open MeasureTheory Metric Bornology Set TopologicalSpace Vitali Filter Pointwise + open ENNReal hiding one_lt_two + open scoped NNReal + noncomputable section + +-/-! This should roughly contain the contents of chapter 9. -/ +- + -- Upstreaming status: aside from getting the real interpolation theorem merged, + -- this file needs a bunch of clean-up before it can be upstreamed: + -- moving preliminary lemmas to their appropriate homes (some of these lemmas do not belong in +@@ -46,7 +46,8 @@ lemma exists_ball_subset_ball_two (c : X) {r : ℝ} (hr : 0 < r) : + exact (Real.rpow_intCast 2 m).symm + _ = _ := Real.rpow_logb zero_lt_two (OfNat.one_ne_ofNat 2).symm hr + have hm' : r < 2 ^ (m + 1) := by +- calc _ = (2 : ℝ) ^ Real.logb 2 r := (Real.rpow_logb zero_lt_two (OfNat.one_ne_ofNat 2).symm hr).symm ++ calc _ = (2 : ℝ) ^ Real.logb 2 r := ++ (Real.rpow_logb zero_lt_two (OfNat.one_ne_ofNat 2).symm hr).symm + _ < _ := by + rw [← Real.rpow_intCast 2 (m + 1)] + refine Real.strictMono_rpow_of_base_gt_one one_lt_two ?_ +@@ -87,7 +88,8 @@ variable {X E : Type*} {A : ℝ≥0} [MetricSpace X] [MeasurableSpace X] + open scoped Topology in + -- unused in Carleson + -- move to separate file (not sure where) +-lemma lowerSemiContinuousOn_integral_ball [OpensMeasurableSpace X] (hf2 : AEStronglyMeasurable f μ) : ++lemma lowerSemiContinuousOn_integral_ball [OpensMeasurableSpace X] ++ (hf2 : AEStronglyMeasurable f μ) : + LowerSemicontinuousOn (fun x : X × ℝ ↦ ∫⁻ y in ball x.1 x.2, ‖f y‖ₑ ∂μ) (univ ×ˢ Ioi 0) := by + refine lowerSemicontinuousOn_iff_le_liminf.mpr fun x hx ↦ _root_.le_of_forall_pos_le_add ?_ + intro δ hδ +@@ -98,7 +100,7 @@ lemma lowerSemiContinuousOn_integral_ball [OpensMeasurableSpace X] (hf2 : AEStro + (𝓝[univ ×ˢ Ioi 0] x) < M := lt_add_right htop hδ.ne' + have : ∃ᶠ (z : X × ℝ) in 𝓝[univ ×ˢ Ioi 0] x, ∫⁻ (y : X) in ball z.1 z.2, ‖f y‖ₑ ∂μ < M := by + refine frequently_lt_of_liminf_lt ?_ hM +- simp only [IsCoboundedUnder, Filter.IsCobounded, ge_iff_le, eventually_map] ++ simp only [IsCoboundedUnder, Filter.IsCobounded, eventually_map] + use ∫⁻ (y : X) in ball x.1 x.2, ‖f y‖ₑ ∂μ + intro a ha; apply Eventually.self_of_nhdsWithin ha hx + obtain ⟨ns, hns₀, hns₁⟩ := +@@ -117,7 +119,8 @@ lemma lowerSemiContinuousOn_integral_ball [OpensMeasurableSpace X] (hf2 : AEStro + have : ∀ᶠ (n : ℕ) in atTop, dist z (ns n).1 - (ns n).2 < 0 := by + rw [mem_ball, ← sub_lt_zero] at hz; exact Tendsto.eventually_lt_const hz this + filter_upwards [this]; simp +- filter_upwards [hz2]; intro a ha; split_ifs; rfl ++ filter_upwards [hz2] with index hindex ++ simp only [hindex, ↓reduceIte, le_refl] + · simp + calc + ∫⁻ (y : X) in ball x.1 x.2, ‖f y‖ₑ ∂μ +@@ -129,7 +132,7 @@ lemma lowerSemiContinuousOn_integral_ball [OpensMeasurableSpace X] (hf2 : AEStro + _ ≤ M := by + apply liminf_le_of_le (f := atTop) + intro b hb +- simp only [eventually_atTop, ge_iff_le] at hb ++ simp only [eventually_atTop] at hb + obtain ⟨a, ha⟩ := hb + exact le_of_lt <| lt_of_le_of_lt (ha a le_rfl) <| + by unfold g; rw [lintegral_indicator measurableSet_ball]; exact hns₁ a +@@ -199,11 +202,11 @@ lemma continuous_integral_ball [OpensMeasurableSpace X] + have hz' : Tendsto z atTop (𝓝 x) := tendsto_nhds_of_tendsto_nhdsWithin hz + have := isBounded_range_of_tendsto z hz' + obtain ⟨r, hr⟩ := Bornology.IsBounded.subset_ball this x +- simp only [range, ball, setOf_subset_setOf, forall_exists_index, forall_apply_eq_imp_iff] at hr ++ simp only [range, ball, ofPred_subset_ofPred, forall_exists_index, forall_apply_eq_imp_iff] at hr + simp_rw [Prod.dist_eq] at hr + have hsub (n : ℕ) : ball (z n).1 (z n).2 ⊆ ball x.1 (x.2 + 2 * r) := by + intro y hy +- simp only [ball, mem_setOf_eq] at hy ⊢ ++ simp only [ball, mem_ofPred_eq] at hy ⊢ + calc dist y x.1 + _ ≤ dist y (z n).1 + dist (z n).1 x.1 := dist_triangle y (z n).1 x.1 + _ ≤ (z n).2 + dist (z n).1 x.1 := by gcongr +@@ -246,11 +249,10 @@ lemma continuous_integral_ball [OpensMeasurableSpace X] + linarith + · have : ∀ᵐ z : X ∂μ, dist z x.1 ≠ x.2 := by + change (μ ({z | ¬ (dist z x.1 ≠ x.2)}) = 0) +- simpa only [ne_eq, Decidable.not_not] using hμ x.1 x.2 hx_pos ++ simpa only [sphere, ne_eq, Decidable.not_not] using hμ x.1 x.2 hx_pos + filter_upwards [this] with y hy + by_cases hy2 : dist y x.1 < x.2 +- · simp only [indicator, ball, mem_setOf_eq] +- split_ifs ++ · simp only [indicator, ball, mem_ofPred_eq] + apply tendsto_nhds_of_eventually_eq + have hz2 : ∀ᶠ n : ℕ in atTop, dist y (z n).1 < (z n).2 := by + let dist_sub (a : X × ℝ) := dist y a.1 - a.2 +@@ -259,24 +261,27 @@ lemma continuous_integral_ball [OpensMeasurableSpace X] + have : ∀ᶠ (n : ℕ) in atTop, dist y (z n).1 - (z n).2 < 0 := by + rw [← sub_lt_zero] at hy2; exact Tendsto.eventually_lt_const hy2 this + filter_upwards [this]; simp +- filter_upwards [hz2]; intro a ha; split_ifs; rfl ++ filter_upwards [hz2] with index hindex ++ simp only [hindex, hy2, ↓reduceIte] + · have hz2 : ∀ᶠ n : ℕ in atTop, dist y (z n).1 > (z n).2 := by + let dist_sub (a : X × ℝ) := dist y a.1 - a.2 + have : ContinuousOn dist_sub (univ ×ˢ Ioi 0) := by fun_prop + have hcmp : Tendsto (dist_sub ∘ z) atTop (𝓝 (dist_sub x)) := Tendsto.comp (this x hx) hz + have hy2 : dist y x.1 > x.2 := by order + have hy2 : 0 < dist y x.1 - x.2 := sub_pos.mpr hy2 +- have : ∀ᶠ (n : ℕ) in atTop, 0 < dist y (z n).1 - (z n).2 := Tendsto.eventually_const_lt hy2 hcmp ++ have : ∀ᶠ (n : ℕ) in atTop, 0 < dist y (z n).1 - (z n).2 := ++ Tendsto.eventually_const_lt hy2 hcmp + filter_upwards [this]; simp +- simp only [indicator, ball, mem_setOf_eq] ++ simp only [indicator, ball, mem_ofPred_eq] + apply tendsto_nhds_of_eventually_eq + filter_upwards [hz2] with n hn + have : ¬ (dist y (z n).1 < (z n).2) := by linarith +- split_ifs; rfl ++ simp only [this, hy2, ↓reduceIte] + + -- unused in Carleson + -- move to separate file (not sure where) +-lemma continuous_average_ball [μ.IsOpenPosMeasure] [IsFiniteMeasureOnCompacts μ] [OpensMeasurableSpace X] ++lemma continuous_average_ball [μ.IsOpenPosMeasure] [IsFiniteMeasureOnCompacts μ] ++ [OpensMeasurableSpace X] + [ProperSpace X] (hf : LocallyIntegrable f μ) + (hμ : ∀ z : X, ∀ r > (0 : ℝ), μ (sphere z r) = 0) : + ContinuousOn (fun x : X × ℝ ↦ ⨍⁻ y in ball x.1 x.2, ‖f y‖ₑ ∂μ) (univ ×ˢ Ioi 0) := by +@@ -368,7 +373,7 @@ theorem exists_disjoint_subfamily_covering_enlargement_closedBall' {α} [MetricS + exact h'a.le.trans <| by positivity + + -- move to Vitali +-theorem Vitali.exists_disjoint_subfamily_covering_enlargement_ball {α} [MetricSpace α] (t : Set ι) ++theorem Vitali.exists_disjoint_subfamily_covering_enlargement_ball' {α} [MetricSpace α] (t : Set ι) + (x : ι → α) (r : ι → ℝ) (R : ℝ) (hr : ∀ a ∈ t, r a ≤ R) (τ : ℝ) (hτ : 3 < τ) : + ∃ u ⊆ t, + (u.PairwiseDisjoint fun a => ball (x a) (r a)) ∧ +@@ -402,7 +407,7 @@ theorem Set.Countable.measure_biUnion_le_lintegral [OpensMeasurableSpace X] (h + (l : ℝ≥0∞) (u : X → ℝ≥0∞) (R : ℝ) (hR : ∀ a ∈ 𝓑, r a ≤ R) + (h2u : ∀ i ∈ 𝓑, l * μ (ball (c i) (r i)) ≤ ∫⁻ x in ball (c i) (r i), u x ∂μ) : + l * μ (⋃ i ∈ 𝓑, ball (c i) (r i)) ≤ A ^ 2 * ∫⁻ x, u x ∂μ := by +- obtain ⟨B, hB𝓑, hB, h2B⟩ := Vitali.exists_disjoint_subfamily_covering_enlargement_ball ++ obtain ⟨B, hB𝓑, hB, h2B⟩ := Vitali.exists_disjoint_subfamily_covering_enlargement_ball' + 𝓑 c r R hR (2 ^ 2) (by norm_num) + have : Countable B := h𝓑.mono hB𝓑 + have disj := fun i j hij ↦ +@@ -473,20 +478,22 @@ theorem MB_le_eLpNormEssSup {u : X → E} {x : X} : MB μ 𝓑 c r u x ≤ eLpNo + + protected theorem HasStrongType.MB_top [BorelSpace X] : + HasStrongType (fun (u : X → E) (x : X) ↦ MB μ 𝓑 c r u x) ⊤ ⊤ μ μ 1 := by +- intro f _ ++ intro f hf + use Measurable.maximalFunction.aestronglyMeasurable +- simp only [one_mul, eLpNorm_exponent_top] ++ rw [one_mul, eLpNorm_exponent_top Measurable.maximalFunction.aestronglyMeasurable, ++ eLpNorm_exponent_top hf.aestronglyMeasurable] + exact essSup_le_of_ae_le _ (Eventually.of_forall fun x ↦ MB_le_eLpNormEssSup) + + /- The proof is roughly between (9.0.12)-(9.0.22). -/ + protected theorem HasWeakType.MB_one [BorelSpace X] (h𝓑 : 𝓑.Countable) + {R : ℝ} (hR : ∀ i ∈ 𝓑, r i ≤ R) : + HasWeakType (MB (E := E) μ 𝓑 c r) 1 1 μ μ (A ^ 2) := by +- intro f _ ++ intro f hf + use Measurable.maximalFunction.aestronglyMeasurable + let Bₗ (ℓ : ℝ≥0∞) := { i ∈ 𝓑 | ∫⁻ y in (ball (c i) (r i)), ‖f y‖ₑ ∂μ ≥ ℓ * μ (ball (c i) (r i)) } +- simp only [wnorm, one_ne_top, wnorm', toReal_one, inv_one, ENNReal.rpow_one, reduceIte, eLpNorm, +- one_ne_zero, eLpNorm', ne_eq, not_false_eq_true, div_self, iSup_le_iff] ++ rw [eLpNorm_one_eq_lintegral_enorm hf.aestronglyMeasurable] ++ simp only [wnorm, one_ne_top, wnorm', toReal_one, inv_one, ENNReal.rpow_one, reduceIte, ++ iSup_le_iff] + intro t + by_cases ht : t = 0 + · simp [ht] +@@ -495,17 +502,19 @@ protected theorem HasWeakType.MB_one [BorelSpace X] (h𝓑 : 𝓑.Countable) + (u := fun x ↦ ‖f x‖ₑ) (R := R) ?_ ?_) + · refine mul_right_mono <| μ.mono (fun x hx ↦ mem_iUnion₂.mpr ?_) + -- We need a ball in `Bₗ t` containing `x`. Since `MB μ 𝓑 c r f x` is large, such a ball exists +- simp only [mem_setOf_eq] at hx ++ simp only [mem_ofPred_eq] at hx + -- replace hx := lt_of_lt_of_le hx coe_toNNReal_le_self + simp only [MB, maximalFunction, ENNReal.rpow_one, inv_one] at hx + obtain ⟨i, ht⟩ := lt_iSup_iff.mp hx +- replace hx : x ∈ ball (c i) (r i) := +- by_contradiction <| fun h ↦ not_lt_of_ge (zero_le t) (ENNReal.coe_lt_coe.mp <| by simp [h] at ht) ++ replace hx : x ∈ ball (c i) (r i) := by ++ by_contra hball ++ simp [hball] at ht + refine ⟨i, ?_, hx⟩ + -- It remains only to confirm that the chosen ball is actually in `Bₗ t` +- simp only [ge_iff_le, mem_setOf_eq, Bₗ] +- have hi : i ∈ 𝓑 := +- by_contradiction <| fun h ↦ not_lt_of_ge (zero_le t) (ENNReal.coe_lt_coe.mp <| by simp [h] at ht) ++ simp only [ge_iff_le, mem_ofPred_eq, Bₗ] ++ have hi : i ∈ 𝓑 := by ++ by_contra hindex ++ simp [hindex] at ht + exact ⟨hi, mul_le_of_le_div <| le_of_lt (by simpa [setLAverage_eq, hi, hx] using ht)⟩ + · exact fun i hi ↦ hR i (mem_of_mem_inter_left hi) + · exact fun i hi ↦ hi.2.trans (setLIntegral_mono' measurableSet_ball fun x _ ↦ by simp) +@@ -519,8 +528,8 @@ theorem MB_ae_ne_top [BorelSpace X] (h𝓑 : 𝓑.Countable) + -- move + lemma MeasureTheory.MemLp.eLpNormEssSup_lt_top {α} [MeasurableSpace α] {μ : Measure α} + {u : α → E} (hu : MemLp u ⊤ μ) : eLpNormEssSup u μ < ⊤ := by +- simp_rw [MemLp, eLpNorm_exponent_top] at hu +- exact hu.2 ++ rw [← eLpNorm_exponent_top hu.aestronglyMeasurable] ++ exact hu + + include A in + theorem MB_ae_ne_top' [BorelSpace X] (h𝓑 : 𝓑.Countable) +@@ -626,7 +635,8 @@ This is a special case of `hasStrongType_maximalFunction` below, which doesn't h + `hR` (but uses this result in its proof). -/ + theorem hasStrongType_maximalFunction_aux + [BorelSpace X] [IsFiniteMeasureOnCompacts μ] [ProperSpace X] [Nonempty X] [μ.IsOpenPosMeasure] +- {p₁ p₂ : ℝ≥0} (h𝓑 : 𝓑.Countable) {R : ℝ} (hR : ∀ i ∈ 𝓑, r i ≤ R) (hp₁ : 0 < p₁) (hp₁₂ : p₁ < p₂) : ++ {p₁ p₂ : ℝ≥0} (h𝓑 : 𝓑.Countable) {R : ℝ} (hR : ∀ i ∈ 𝓑, r i ≤ R) ++ (hp₁ : 0 < p₁) (hp₁₂ : p₁ < p₂) : + HasStrongType (fun (u : X → E) (x : X) ↦ maximalFunction μ 𝓑 c r p₁ u x) + p₂ p₂ μ μ (C2_0_6 A p₁ p₂) := fun v mlpv ↦ by + refine ⟨Measurable.maximalFunction.aestronglyMeasurable, ?_⟩; dsimp only +@@ -635,7 +645,8 @@ theorem hasStrongType_maximalFunction_aux + conv_lhs => + enter [1, x] + rw [maximalFunction_eq_MB cp₁p, ← enorm_eq_self (MB ..)] +- rw [eLpNorm_enorm_rpow _ (by positivity), ENNReal.ofReal_inv_of_pos cp₁p, ++ rw [eLpNorm_enorm_rpow _ Measurable.maximalFunction.aestronglyMeasurable (by positivity), ++ ENNReal.ofReal_inv_of_pos cp₁p, + ENNReal.ofReal_coe_nnreal, ← div_eq_mul_inv, ← ENNReal.coe_div p₁n] + calc + _ ≤ (CMB A (p₂ / p₁) * eLpNorm (fun y ↦ ‖v y‖ ^ (p₁ : ℝ)) (p₂ / p₁) μ) ^ p₁.toReal⁻¹ := by +@@ -645,7 +656,8 @@ theorem hasStrongType_maximalFunction_aux + · rwa [lt_div_iff₀, one_mul]; exact cp₁p + · rw [ENNReal.coe_div p₁n]; exact mlpv.norm_rpow_div p₁ + _ = _ := by +- rw [ENNReal.mul_rpow_of_nonneg _ _ (by positivity), eLpNorm_norm_rpow _ cp₁p, ++ rw [ENNReal.mul_rpow_of_nonneg _ _ (by positivity), ++ eLpNorm_norm_rpow _ mlpv.aestronglyMeasurable cp₁p, + ENNReal.ofReal_coe_nnreal, ENNReal.div_mul_cancel (by positivity) (by simp), + ENNReal.rpow_rpow_inv (by positivity), ← ENNReal.coe_rpow_of_nonneg _ (by positivity), + C2_0_6] +@@ -680,7 +692,8 @@ lemma maximalFunction_seq_mono {𝓑 : Set ι} (h𝓑 : 𝓑.Countable) {p : ℝ + obtain ⟨w, hw⟩ := Hi + exact ⟨w, hw.1.trans hmn, hw.2⟩ + +-lemma maximalFunction_seq_eq {𝓑 : Set ι} (h𝓑 : 𝓑.Countable) {p : ℝ≥0} (hp : 0 < p) (u : X → E) (x : X) : ++lemma maximalFunction_seq_eq {𝓑 : Set ι} (h𝓑 : 𝓑.Countable) {p : ℝ≥0} ++ (hp : 0 < p) (u : X → E) (x : X) : + maximalFunction μ 𝓑 c r (↑p) u x = + ⨆ k : ℕ, maximalFunction_seq μ h𝓑 c r (↑p) u k x := by + let g := Classical.choose (Set.countable_iff_exists_injective.mp h𝓑) +@@ -694,7 +707,7 @@ lemma maximalFunction_seq_eq {𝓑 : Set ι} (h𝓑 : 𝓑.Countable) {p : ℝ + let k₀ := g ⟨i, Hi⟩ + have k₀large : i ∈ 𝓑' k₀ := by + unfold 𝓑' +- simp only [preimage_setOf_eq, mem_image, mem_setOf_eq, Subtype.exists, exists_and_right, ++ simp only [preimage_ofPred_eq, mem_image, mem_ofPred_eq, Subtype.exists, exists_and_right, + exists_eq_right] + use Hi + calc +@@ -733,13 +746,10 @@ theorem hasStrongType_maximalFunction + obtain ⟨R, hR⟩ := Finite.exists_image_le (tr_finite h𝓑 k) r + exact (hasStrongType_maximalFunction_aux (c := c) + (Finite.countable (tr_finite h𝓑 k)) hR hp₁ hp₁₂ v mlpv).2 +- unfold eLpNorm +- split_ifs with h₀ +- · simp +- · have h : ENNReal.ofNNReal p₂ = ⊤ := by assumption +- simp at h +- · unfold eLpNorm' +- calc ++ rw [eLpNorm_eq_eLpNorm' (coe_ne_zero.mpr (ne_zero_of_lt hp₁₂)) coe_ne_top ++ Measurable.maximalFunction.aestronglyMeasurable] ++ unfold eLpNorm' ++ calc + _ = (∫⁻ (a : X), (⨆ k, maximalFunction_seq μ h𝓑 c r (↑p₁) v k a) ^ (ofNNReal p₂).toReal ∂μ) + ^ (1 / (ofNNReal p₂).toReal) := by + congr; ext x; congr; exact maximalFunction_seq_eq h𝓑 hp₁ v x +@@ -771,11 +781,11 @@ theorem hasStrongType_maximalFunction + intro k + apply (rpow_le_rpow_iff hp₂inv_pos).mp + rw [ENNReal.rpow_rpow_inv hp₂neq_zero] +- unfold eLpNorm at hestfin +- split_ifs at hestfin +- unfold eLpNorm' at hestfin +- rw [one_div] at hestfin +- exact hestfin k ++ have hest := hestfin k ++ simp only [maximalFunction_seq] at hest ++ rw [eLpNorm_eq_eLpNorm' (coe_ne_zero.mpr (ne_zero_of_lt hp₁₂)) coe_ne_top ++ Measurable.maximalFunction.aestronglyMeasurable, eLpNorm', one_div] at hest ++ simpa only [maximalFunction_seq, enorm_eq_self] using hest + + theorem hasWeakType_maximalFunction_equal_exponents₀ [BorelSpace X] + {p : ℝ≥0} (h𝓑 : 𝓑.Countable) {R : ℝ} (hR : ∀ i ∈ 𝓑, r i ≤ R) (hp : 0 < p) : +@@ -789,11 +799,12 @@ theorem hasWeakType_maximalFunction_equal_exponents₀ [BorelSpace X] + conv_lhs => + enter [1, x] + rw [maximalFunction_eq_MB cp] +- have hmb_one : wnorm (MB μ 𝓑 c r fun x ↦ ‖v x‖ ^ (p : ℝ)) 1 μ ≤ ↑A ^ 2 * eLpNorm (fun x ↦ ‖v x‖ ^ (p : ℝ)) 1 μ := by ++ have hmb_one : wnorm (MB μ 𝓑 c r fun x ↦ ‖v x‖ ^ (p : ℝ)) 1 μ ≤ ++ ↑A ^ 2 * eLpNorm (fun x ↦ ‖v x‖ ^ (p : ℝ)) 1 μ := by + apply (HasWeakType.MB_one h𝓑 hR + (fun x : X ↦ ‖v x‖ ^ (p : ℝ)) _).2 +- convert MemLp.norm_rpow_div mlpv p +- exact Eq.symm (ENNReal.div_self (coe_ne_zero.mpr p₁n) coe_ne_top) ++ simpa only [coe_toReal, ENNReal.div_self (coe_ne_zero.mpr p₁n) coe_ne_top] ++ using mlpv.norm_rpow_div p + unfold wnorm wnorm' distribution at hmb_one ⊢ + simp only [one_ne_top, ↓reduceIte, enorm_eq_self, toReal_one, inv_one, rpow_one, iSup_le_iff, + coe_ne_top, coe_toReal] at hmb_one ⊢ +@@ -806,7 +817,8 @@ theorem hasWeakType_maximalFunction_equal_exponents₀ [BorelSpace X] + · exact Eq.symm (coe_rpow_of_ne_zero ht ↑p) + · rw [rpow_inv_rpow (NNReal.coe_ne_zero.mpr p₁n)] + congr; ext x; rw [coe_rpow_of_ne_zero ht ↑p]; exact (lt_rpow_inv_iff cp) +- · rw [eLpNorm_norm_rpow v cp, ENNReal.mul_rpow_of_nonneg _ _ NNReal.zero_le_coe, ++ · rw [eLpNorm_norm_rpow v mlpv.aestronglyMeasurable cp, ++ ENNReal.mul_rpow_of_nonneg _ _ NNReal.zero_le_coe, + div_eq_mul_inv, rpow_mul, rpow_inv_rpow (NNReal.coe_ne_zero.mpr p₁n), rpow_two]; simp + + theorem hasWeakType_maximalFunction_equal_exponents +@@ -839,13 +851,14 @@ theorem hasWeakType_maximalFunction_equal_exponents + have f_mon : Monotone f := by + refine fun a b hab x ↦ iSup₂_le fun i Hi ↦ ?_ + apply le_iSup₂ (f := fun j _ ↦ (ball (c j) (r j)).indicator +- (fun x ↦ (⨍⁻ (y : X) in ball (c j) (r j), ‖v y‖ₑ ^ (ofNNReal p).toReal ∂μ) ^ (ofNNReal p).toReal⁻¹) x) ++ (fun x ↦ (⨍⁻ (y : X) in ball (c j) (r j), ‖v y‖ₑ ^ (ofNNReal p).toReal ∂μ) ^ ++ (ofNNReal p).toReal⁻¹) x) + obtain ⟨w, hw⟩ := Hi; use w; exact ⟨hw.1.trans hab, hw.2⟩ + intro t + have hm : + Monotone (fun k ↦ {x | (t : ℝ≥0∞) < ‖maximalFunction μ (tr h𝓑 k) c r p v x‖ₑ}) := by + intro m n hmn x +- simp only [enorm_eq_self, mem_setOf_eq] ++ simp only [enorm_eq_self, mem_ofPred_eq] + exact fun ht ↦ ht.trans_le (f_mon hmn x) + apply (rpow_le_rpow_iff p_pos).mp + rw [ENNReal.mul_rpow_of_nonneg _ _ (by positivity), rpow_inv_rpow p_pos.ne'] +@@ -884,7 +897,7 @@ theorem hasWeakType_maximalFunction + split_ifs with hps + · rw [← hps] + exact hasWeakType_maximalFunction_equal_exponents (A := A) h𝓑 hp₁ +- · apply HasStrongType.hasWeakType (coe_lt_coe_of_lt (hp₁.trans_le hp₁₂)) ++ · apply HasStrongType.hasWeakType (coe_lt_coe.mpr (hp₁.trans_le hp₁₂)) + exact hasStrongType_maximalFunction h𝓑 hp₁ (lt_of_le_of_ne hp₁₂ hps) + + section GMF +@@ -894,8 +907,8 @@ variable [ProperSpace X] + variable (μ) in + /-- The transformation `M` characterized in Proposition 2.0.6. + `p` is `1` in the blueprint, and `globalMaximalFunction μ p u = (M (u ^ p)) ^ p⁻¹ ` -/ +-@[nolint unusedArguments] +-def globalMaximalFunction [μ.IsDoubling A] (p : ℝ) (u : X → E) (x : X) : ℝ≥0∞ := ++def globalMaximalFunction (p : ℝ) (u : X → E) (x : X) : ℝ≥0∞ := ++ let _ := ‹μ.IsDoubling A› + A ^ 2 * maximalFunction μ ((covering_separable_space X).choose ×ˢ (univ : Set ℤ)) + (·.1) (fun x ↦ 2 ^ (x.2)) p u x + +@@ -930,7 +943,8 @@ theorem laverage_le_globalMaximalFunction [IsFiniteMeasureOnCompacts μ] [μ.IsO + refine (le_iSup₂ (c, m) hc).trans_eq' ?_ + simp [laverage, indicator_of_mem (h_subset h)] + +-theorem lintegral_ball_le_volume_globalMaximalFunction [IsFiniteMeasureOnCompacts μ] [μ.IsOpenPosMeasure] ++theorem lintegral_ball_le_volume_globalMaximalFunction [IsFiniteMeasureOnCompacts μ] ++ [μ.IsOpenPosMeasure] + {u : X → E} {z x : X} {r : ℝ} (h : dist x z < r) : + ∫⁻ y in (ball z r), ‖u y‖ₑ ∂μ ≤ μ (ball z r) * globalMaximalFunction μ 1 u x := by + have : IsFiniteMeasure (μ.restrict (ball z r)) := isFiniteMeasure_restrict.mpr (by finiteness) +@@ -942,7 +956,8 @@ theorem lintegral_ball_le_volume_globalMaximalFunction [IsFiniteMeasureOnCompact + /-- The constant factor in the statement that `M` has strong type. -/ + def C2_0_6' (A p₁ p₂ : ℝ≥0) : ℝ≥0 := A ^ 2 * C2_0_6 A p₁ p₂ + +-lemma C2_0_6'_defaultA_one_two_eq {a : ℕ} : C2_0_6' (defaultA a) 1 2 = 2 ^ (3 * a + 3 / (2 : ℝ)) := by ++lemma C2_0_6'_defaultA_one_two_eq {a : ℕ} : ++ C2_0_6' (defaultA a) 1 2 = 2 ^ (3 * a + 3 / (2 : ℝ)) := by + simp_rw [C2_0_6', C2_0_6, div_one, CMB_defaultA_two_eq, defaultA, Nat.cast_pow, Nat.cast_ofNat, + NNReal.coe_one, inv_one, NNReal.rpow_one, ← pow_mul, ← NNReal.rpow_natCast] + rw [← NNReal.rpow_add (by simp)] +@@ -984,9 +999,12 @@ theorem hasWeakType_globalMaximalFunction [BorelSpace X] [IsFiniteMeasureOnCompa + [μ.IsOpenPosMeasure] {p₁ p₂ : ℝ≥0} (hp₁ : 0 < p₁) (hp₁₂ : p₁ ≤ p₂) : + HasWeakType (globalMaximalFunction μ p₁ (E := E)) + p₂ p₂ μ μ (C_weakType_globalMaximalFunction A p₁ p₂) := by +- convert HasWeakType.const_mul (c := C_weakType_maximalFunction A p₁ p₂) (e := A ^ 2) +- (coe_ne_zero.mpr (hp₁.trans_le hp₁₂).ne') _ +- exact hasWeakType_maximalFunction countable_globalMaximalFunction hp₁ hp₁₂ ++ convert ++ (hasWeakType_maximalFunction (μ := μ) (E := E) (c := (·.1)) (r := fun x ↦ 2 ^ x.2) ++ countable_globalMaximalFunction hp₁ hp₁₂).const_mul ++ (coe_ne_zero.mpr (hp₁.trans_le hp₁₂).ne') (A ^ 2) using 1 <;> ++ simp only [C_weakType_globalMaximalFunction, ENNReal.coe_pow] ++ rfl + + /-- Use `lowerSemiContinuous_MB` -/ + lemma lowerSemiContinuous_globalMaximalFunction : +diff --git a/Carleson/ToMathlib/Interval.lean b/Carleson/ToMathlib/Interval.lean +index 948f0cd..a07c341 100644 +--- a/Carleson/ToMathlib/Interval.lean ++++ b/Carleson/ToMathlib/Interval.lean +@@ -1,7 +1,13 @@ +-import Mathlib.Data.Set.Lattice ++import Mathlib.Data.Set.Lattice.Bounded ++import Mathlib.Data.Set.Lattice.Disjoint ++import Mathlib.Data.Set.Lattice.Image ++import Mathlib.Data.Set.Lattice.Indexed ++import Mathlib.Data.Set.Lattice.Order + import Mathlib.Order.SuccPred.Basic + import Mathlib.Tactic.Common + ++/-! # Interval inclusions, unions, and disjointness -/ ++ + -- Upstreaming status: results seem useful in general, some should be generalised + + open Function Order Set +diff --git a/Carleson/ToMathlib/MeasureTheory/Integral/Average.lean b/Carleson/ToMathlib/MeasureTheory/Integral/Average.lean +index 2e68964..0188672 100644 +--- a/Carleson/ToMathlib/MeasureTheory/Integral/Average.lean ++++ b/Carleson/ToMathlib/MeasureTheory/Integral/Average.lean +@@ -1,5 +1,7 @@ + import Mathlib.MeasureTheory.Integral.Average + ++/-! # Monotonicity and essential supremum bounds for lower averages -/ ++ + -- Upstreaming status: upstreamed in https://github.com/leanprover-community/mathlib4/pull/37551 + + open MeasureTheory MeasureTheory.Measure Filter Set +@@ -12,22 +14,23 @@ lemma laverage_mono_ae {f g : α → ℝ≥0∞} (h : ∀ᵐ a ∂μ, f a ≤ g + ⨍⁻ a, f a ∂μ ≤ ⨍⁻ a, g a ∂μ := + lintegral_mono_ae <| h.filter_mono <| Measure.ae_mono' Measure.smul_absolutelyContinuous + +-@[gcongr] ++@[gcongr only] + lemma setLAverage_mono_ae {f g : α → ℝ≥0∞} (h : ∀ᵐ a ∂μ, f a ≤ g a) : + ⨍⁻ a in s, f a ∂μ ≤ ⨍⁻ a in s, g a ∂μ := +- laverage_mono_ae <| h.filter_mono <| ae_mono Measure.restrict_le_self ++ _root_.laverage_mono_ae <| h.filter_mono <| ae_mono Measure.restrict_le_self + + lemma setLAverage_le_essSup (f : α → ℝ≥0∞) : ⨍⁻ x in s, f x ∂μ ≤ essSup f μ := by + by_cases hμ : IsFiniteMeasure (μ.restrict s); swap + · simp [laverage, not_isFiniteMeasure_iff.mp hμ] + by_cases hμ0 : μ s = 0 + · rw [laverage, ← setLIntegral_univ] +- exact le_of_eq_of_le (setLIntegral_measure_zero univ f <| by simp [hμ0]) (zero_le (essSup f μ)) +- apply le_of_le_of_eq (laverage_mono_ae <| Eventually.filter_mono ae_restrict_le ae_le_essSup) ++ exact le_of_eq_of_le (setLIntegral_measure_zero univ f <| by simp [hμ0]) zero_le ++ apply le_of_le_of_eq (_root_.laverage_mono_ae <| ++ Eventually.filter_mono ae_restrict_le ae_le_essSup) + have : NeZero (μ.restrict s) := + have : NeZero (μ s) := { out := hμ0 } + restrict.neZero + exact laverage_const (μ.restrict s) _ + + lemma laverage_le_essSup (f : α → ℝ≥0∞) : ⨍⁻ x, f x ∂μ ≤ essSup f μ := by +- simpa using setLAverage_le_essSup (s := univ) f ++ simpa using _root_.setLAverage_le_essSup (s := univ) f +diff --git a/Carleson/ToMathlib/MeasureTheory/Integral/IntegrableOn.lean b/Carleson/ToMathlib/MeasureTheory/Integral/IntegrableOn.lean +index 09f5019..6cadf14 100644 +--- a/Carleson/ToMathlib/MeasureTheory/Integral/IntegrableOn.lean ++++ b/Carleson/ToMathlib/MeasureTheory/Integral/IntegrableOn.lean +@@ -1,5 +1,7 @@ + import Mathlib.MeasureTheory.Integral.IntegrableOn + ++/-! # Integrability on a set from integrability on the support -/ ++ + open Set Filter TopologicalSpace MeasureTheory Function + + open scoped Topology Interval Filter ENNReal MeasureTheory +@@ -11,18 +13,6 @@ open scoped Topology Interval Filter ENNReal MeasureTheory + + variable {α β ε ε' E F : Type*} [MeasurableSpace α] + +-namespace MeasureTheory +- +-protected theorem IntegrableAtFilter.congr'_enorm {μ : Measure α} [TopologicalSpace ε] +- [TopologicalSpace ε'] [ContinuousENorm ε] [ContinuousENorm ε'] +- {l : Filter α} {f : α → ε} {g : α → ε'} +- (hf : IntegrableAtFilter f l μ) (hg : AEStronglyMeasurable g μ) +- (h : ∀ᵐ a ∂μ, ‖f a‖ₑ = ‖g a‖ₑ) : +- IntegrableAtFilter g l μ := +- Exists.casesOn hf fun s hs ↦ ⟨s, hs.1, hs.2.congr'_enorm hg.restrict (ae_restrict_le h)⟩ +- +-end MeasureTheory +- + section NormedAddCommGroup + + variable [NormedAddCommGroup E] {f g : α → ε'} {s t : Set α} {μ ν : Measure α} +@@ -31,7 +21,7 @@ variable [TopologicalSpace ε'] [ENormedAddMonoid ε'] + theorem integrableOn_of_integrableOn_inter_support [PseudoMetrizableSpace ε'] {f : α → ε'} + (hs : MeasurableSet s) (hf : IntegrableOn f (s ∩ support f) μ) : + IntegrableOn f s μ := by +- apply IntegrableOn.of_forall_diff_eq_zero hf hs ++ apply IntegrableOn.of_forall_sdiff_eq_zero hf hs + simp + + end NormedAddCommGroup +diff --git a/Carleson/ToMathlib/MeasureTheory/Integral/Lebesgue.lean b/Carleson/ToMathlib/MeasureTheory/Integral/Lebesgue.lean +index 58ff6bf..48fca65 100644 +--- a/Carleson/ToMathlib/MeasureTheory/Integral/Lebesgue.lean ++++ b/Carleson/ToMathlib/MeasureTheory/Integral/Lebesgue.lean +@@ -1,5 +1,7 @@ + import Mathlib.MeasureTheory.Measure.Lebesgue.Basic + ++/-! # Changes of variables and monotonicity for lower integrals -/ ++ + -- Upstreaming status: `lintegral_eq_iSup_eapprox_lintegral'` and `lintegral_comp'` + -- upstreamed in https://github.com/leanprover-community/mathlib4/pull/37558 + -- Remaining lemmas: shift/scaling aliases, `lintegral_set_mono_fn` +@@ -73,33 +75,6 @@ lemma lintegral_scale_constant' {f : ℝ → ENNReal} {a : ℝ} (h : a ≠ 0) : + simp + + +-open SimpleFunc +- +-/-- Generalization of `MeasureTheory.lintegral_eq_iSup_eapprox_lintegral` assuming a.e. +-measurability of `f` -/ +-theorem lintegral_eq_iSup_eapprox_lintegral' {α : Type*} {m : MeasurableSpace α} {μ : Measure α} +- {f : α → ENNReal} (hf : AEMeasurable f μ) : +- ∫⁻ (a : α), f a ∂μ = ⨆ (n : ℕ), (eapprox (hf.mk f) n).lintegral μ := +- calc +- _ = ∫⁻ a, hf.mk f a ∂μ := lintegral_congr_ae hf.ae_eq_mk +- _ = ∫⁻ a, ⨆ n, (eapprox (hf.mk f) n : α → ℝ≥0∞) a ∂μ := by +- simp [iSup_eapprox_apply hf.measurable_mk] +- _ = ⨆ n, ∫⁻ a, eapprox (hf.mk f) n a ∂μ := +- lintegral_iSup (fun _ ↦ SimpleFunc.measurable _) (fun _ _ h ↦ monotone_eapprox (hf.mk f) h) +- _ = ⨆ n, (eapprox (hf.mk f) n).lintegral μ := by simp [lintegral_eq_lintegral] +- +-/-- Generalization of `MeasureTheory.lintegral_comp` assuming a.e. measurability of `f` and `g` -/ +-theorem lintegral_comp' {α : Type*} {β : Type*} {m : MeasurableSpace α} {μ : Measure α} +- [MeasurableSpace β] {f : β → ENNReal} {g : α → β} (hf : AEMeasurable f (μ.map g)) +- (hg : AEMeasurable g μ) : lintegral μ (f ∘ g) = ∫⁻ a, f a ∂μ.map g := by +- rw [μ.map_congr hg.ae_eq_mk] at hf ⊢ +- calc ∫⁻ a, (f ∘ g) a ∂μ +- _ = ∫⁻ a, (hf.mk f ∘ hg.mk g) a ∂μ := by +- rw [lintegral_congr_ae (hg.ae_eq_mk.fun_comp f)] +- exact lintegral_congr_ae (ae_of_ae_map hg.measurable_mk.aemeasurable hf.ae_eq_mk) +- _ = ∫⁻ a, hf.mk f a ∂μ.map (hg.mk g) := lintegral_comp hf.measurable_mk hg.measurable_mk +- _ = ∫⁻ a, f a ∂μ.map (hg.mk g) := lintegral_congr_ae hf.ae_eq_mk.symm +- + lemma lintegral_set_mono_fn {α : Type*} {m : MeasurableSpace α} {μ : Measure α} {s : Set α} + (hs : MeasurableSet s) ⦃f g : α → ℝ≥0∞⦄ (hfg : ∀ x ∈ s, f x ≤ g x) : + ∫⁻ (a : α) in s, f a ∂μ ≤ ∫⁻ (a : α) in s, g a ∂μ := by +diff --git a/Carleson/ToMathlib/MeasureTheory/Measure/IsDoubling.lean b/Carleson/ToMathlib/MeasureTheory/Measure/IsDoubling.lean +index 06a6caa..2a9f2fd 100644 +--- a/Carleson/ToMathlib/MeasureTheory/Measure/IsDoubling.lean ++++ b/Carleson/ToMathlib/MeasureTheory/Measure/IsDoubling.lean +@@ -1,9 +1,12 @@ + import Carleson.ToMathlib.Misc + import Carleson.ToMathlib.CoveredByBalls +-import Mathlib.Data.Real.StarOrdered ++import Mathlib.Analysis.Real.Sqrt ++import Mathlib.Tactic.ContinuousFunctionalCalculus + import Mathlib.MeasureTheory.Measure.Lebesgue.VolumeOfBalls + import Mathlib.Order.CompletePartialOrder + ++/-! # Doubling measures and uniform local doubling -/ ++ + open MeasureTheory Measure NNReal Metric Filter Topology TopologicalSpace + open ENNReal hiding one_lt_two + noncomputable section +@@ -151,9 +154,9 @@ instance : IsUnifLocDoublingMeasure (μ : Measure X) where + use max 1 A^2, Set.univ, by simp, Set.univ + simp only [mem_principal, Set.subset_univ, Set.inter_self, true_and] + ext r +- simp only [ENNReal.coe_pow, Set.mem_setOf_eq, Set.mem_univ, iff_true] ++ simp only [ENNReal.coe_pow, Set.mem_ofPred_eq, Set.mem_univ, iff_true] + intro x +- letI : Nonempty X := ⟨x⟩ ++ let : Nonempty X := ⟨x⟩ + by_cases hr : r ≤ 0 + · have cball_eq : closedBall x (2 * r) = closedBall x r:= by + by_cases! hr' : r < 0 +diff --git a/Carleson/ToMathlib/MeasureTheory/Measure/NNReal.lean b/Carleson/ToMathlib/MeasureTheory/Measure/NNReal.lean +index 1c0dd1c..4c7cfd2 100644 +--- a/Carleson/ToMathlib/MeasureTheory/Measure/NNReal.lean ++++ b/Carleson/ToMathlib/MeasureTheory/Measure/NNReal.lean +@@ -2,6 +2,8 @@ import Mathlib.MeasureTheory.Measure.Haar.OfBasis + import Mathlib.MeasureTheory.Measure.Lebesgue.Basic + import Carleson.ToMathlib.MeasureTheory.Integral.Lebesgue + ++/-! # Lebesgue measure on nonnegative and extended nonnegative reals -/ ++ + open MeasureTheory NNReal ENNReal Set + + noncomputable +@@ -29,7 +31,7 @@ instance : MeasureSpace ℝ≥0∞ where + lemma ENNReal.ofNNReal_preimage {s : Set ℝ≥0∞} : + ENNReal.ofNNReal ⁻¹' s = ENNReal.toNNReal '' (s \ {⊤}) := by + ext x +- simp only [mem_image, mem_diff, mem_singleton_iff, mem_preimage] ++ simp only [mem_image, mem_sdiff, mem_singleton_iff, mem_preimage] + constructor + · intro h + use ENNReal.ofNNReal x +@@ -41,7 +43,7 @@ lemma ENNReal.ofNNReal_preimage {s : Set ℝ≥0∞} : + --TODO: move these lemmas somewhere else? + lemma ENNReal.map_toReal_eq_map_toReal_comap_ofReal {s : Set ℝ≥0∞} (h : ∞ ∉ s) : + ENNReal.toReal '' s = NNReal.toReal '' (ENNReal.ofNNReal ⁻¹' s) := by +- rw [ofNNReal_preimage, image_image, diff_singleton_eq_self h] ++ rw [ofNNReal_preimage, image_image, sdiff_singleton_eq_self h] + congr + + lemma ENNReal.map_toReal_eq_map_toReal_comap_ofReal' {s : Set ℝ≥0∞} (h : ∞ ∈ s) : +@@ -77,7 +79,8 @@ lemma ENNReal.volume_val {s : Set ℝ≥0∞} (hs : MeasurableSet s) : + _ = volume (ENNReal.ofNNReal ⁻¹' s) := + MeasureTheory.Measure.map_apply_of_aemeasurable (by fun_prop) hs + _ = volume (NNReal.toReal '' (ENNReal.ofNNReal ⁻¹' s)) := NNReal.volume_val +- _ = volume (ENNReal.toReal '' s) := Eq.symm (measure_congr ENNReal.map_toReal_ae_eq_map_toReal_comap_ofReal) ++ _ = volume (ENNReal.toReal '' s) := ++ Eq.symm (measure_congr ENNReal.map_toReal_ae_eq_map_toReal_comap_ofReal) + + lemma NNReal.volume_eq_volume_ennreal {s : Set ℝ≥0} (hs : MeasurableSet (ofNNReal '' s)) : + volume s = volume (ENNReal.ofNNReal '' s) := by +@@ -227,7 +230,6 @@ lemma ENNReal.toReal_Icc_eq_Icc {a b : ℝ≥0∞} (ha : a ≠ ∞) (hb : b ≠ + rw [← hxy] + constructor <;> gcongr + · exact ne_top_of_le_ne_top hb hy₂ +- · assumption + · rintro hx + use ENNReal.ofReal x + constructor +@@ -245,7 +247,6 @@ lemma ENNReal.toReal_Ioo_eq_Ioo {a b : ℝ≥0∞} (ha : a ≠ ∞) (hb : b ≠ + rw [← hyx] + constructor <;> gcongr + · finiteness +- · assumption + · rintro hx + use ENNReal.ofReal x + constructor +@@ -280,7 +281,7 @@ lemma ENNReal.toReal_Ioi_eq_Ioi {a : ℝ≥0∞} (ha : a ≠ ∞) : + rw [← hyx, h, ENNReal.toReal_top] + right + rw [← hyx] +- gcongr; assumption ++ gcongr + · rintro (x_zero | hxa) + · exact ⟨⊤, by finiteness, by simp [x_zero]⟩ + use ENNReal.ofReal x +@@ -355,7 +356,8 @@ lemma ENNReal.volume_Ioo {a b : ℝ≥0∞} (ha : a ≠ ∞) : + · have : ⊤ - ⊤ = (0 : ENNReal) := by simp only [tsub_self] + rw [hb, ENNReal.top_sub ha, ENNReal.toReal_Ioo_top_eq_Ioi ha] + apply Real.volume_Ioi +- rw [toReal_Ioo_eq_Ioo ha hb, Real.volume_Ioo, ofReal_sub _ (by simp), ofReal_toReal hb, ofReal_toReal ha] ++ rw [toReal_Ioo_eq_Ioo ha hb, Real.volume_Ioo, ofReal_sub _ (by simp), ofReal_toReal hb, ++ ofReal_toReal ha] + + -- sanity check: this measure is what you expect + example : volume (Set.Icc (3 : ℝ≥0∞) 42) = 39 := by +@@ -382,7 +384,7 @@ instance : Measure.IsOpenPosMeasure (@volume ℝ≥0 _) where + rw [NNReal.volume_Ioo] + simpa + +-instance : NoAtoms (@volume ℝ≥0∞ _) where ++instance : NullSingletonClass (@volume ℝ≥0∞ _) where + measure_singleton := by + intro x + rw [ENNReal.volume_val (measurableSet_singleton _), image_singleton] +@@ -390,8 +392,9 @@ instance : NoAtoms (@volume ℝ≥0∞ _) where + + -- TODO: move this general result to an appropriate place + -- TODO: maybe generalize further to general measures restricted to a subtype +-lemma Measure.Subtype.noAtoms {δ : Type*} [MeasureSpace δ] [NoAtoms (volume : Measure δ)] {p : δ → Prop} (hp : MeasurableSet p) : +- NoAtoms (Measure.Subtype.measureSpace.volume : Measure (Subtype p)) where ++lemma Measure.Subtype.noAtoms {δ : Type*} [MeasureSpace δ] ++ [NullSingletonClass (volume : Measure δ)] {p : δ → Prop} (hp : MeasurableSet p) : ++ NullSingletonClass (Measure.Subtype.measureSpace.volume : Measure (Subtype p)) where + measure_singleton := by + intro x + calc _ +@@ -400,11 +403,12 @@ lemma Measure.Subtype.noAtoms {δ : Type*} [MeasureSpace δ] [NoAtoms (volume : + _ = 0 := by + simp + +-instance : NoAtoms (@volume ℝ≥0 _) := Measure.Subtype.noAtoms measurableSet_Ici ++instance : NullSingletonClass (@volume ℝ≥0 _) := Measure.Subtype.noAtoms measurableSet_Ici + + --TODO: move this general result to an appropriate place + --TODO: maybe generalize further to general measures restricted to a subtype +-lemma Measure.Subtype.sigmaFinite {δ : Type*} [MeasureSpace δ] [sf : SigmaFinite (@volume δ _)] {p : δ → Prop} (hp : MeasurableSet p) : ++lemma Measure.Subtype.sigmaFinite {δ : Type*} [MeasureSpace δ] ++ [sf : SigmaFinite (@volume δ _)] {p : δ → Prop} (hp : MeasurableSet p) : + SigmaFinite (Measure.Subtype.measureSpace.volume : Measure (Subtype p)) where + out' := by + refine Nonempty.intro ?_ +@@ -431,11 +435,12 @@ lemma Measure.Subtype.sigmaFinite {δ : Type*} [MeasureSpace δ] [sf : SigmaFini + instance : SigmaFinite (@volume ℝ≥0 _) := Measure.Subtype.sigmaFinite measurableSet_Ici + + +-lemma lintegral_nnreal_eq_lintegral_Ici_ofReal {f : ℝ≥0 → ℝ≥0∞} : ∫⁻ x : ℝ≥0, f x = ∫⁻ x in Ici (0 : ℝ), f x.toNNReal := by ++lemma lintegral_nnreal_eq_lintegral_Ici_ofReal {f : ℝ≥0 → ℝ≥0∞} : ++ ∫⁻ x : ℝ≥0, f x = ∫⁻ x in Ici (0 : ℝ), f x.toNNReal := by + change ∫⁻ (x : ℝ≥0), f x = ∫⁻ (x : ℝ) in Ici 0, (f ∘ Real.toNNReal) x + rw [← lintegral_subtype_comap measurableSet_Ici] +- simp +- rfl ++ change ∫⁻ x : ℝ≥0, f x = ∫⁻ x : ℝ≥0, f (x : ℝ).toNNReal ++ simp only [Real.toNNReal_coe] + + lemma lintegral_nnreal_Ici_eq_lintegral_Ici_ofReal {f : ℝ≥0 → ℝ≥0∞} {a : ℝ≥0} : + ∫⁻ x in Ici a, f x = ∫⁻ x in Ici (a : ℝ), f x.toNNReal := by +@@ -446,7 +451,8 @@ lemma lintegral_nnreal_Ici_eq_lintegral_Ici_ofReal {f : ℝ≥0 → ℝ≥0∞} + apply setLIntegral_congr + rw [NNReal.Ici_eq] + +-lemma lintegral_nnreal_eq_lintegral_Ioi_ofReal {f : ℝ≥0∞ → ℝ≥0∞} : ∫⁻ x : ℝ≥0, f x = ∫⁻ x in Ioi (0 : ℝ), f (.ofReal x) := by ++lemma lintegral_nnreal_eq_lintegral_Ioi_ofReal {f : ℝ≥0∞ → ℝ≥0∞} : ++ ∫⁻ x : ℝ≥0, f x = ∫⁻ x in Ioi (0 : ℝ), f (.ofReal x) := by + rw [lintegral_nnreal_eq_lintegral_Ici_ofReal] + exact setLIntegral_congr Ioi_ae_eq_Ici.symm + +@@ -500,7 +506,8 @@ lemma lintegral_nnreal_scale_constant' {f : ℝ≥0 → ℝ≥0∞} {a : ℝ≥0 + a * ∫⁻ x : ℝ≥0, f (a*x) = ∫⁻ x, f x := by + rw [lintegral_nnreal_eq_lintegral_toNNReal_Ioi, lintegral_nnreal_eq_lintegral_toNNReal_Ioi] + symm +- rw [← lintegral_scale_constant_halfspace' (a:=a) (by rw [NNReal.coe_pos, pos_iff_ne_zero]; exact h)] ++ rw [← lintegral_scale_constant_halfspace' (a := a) ++ (by rw [NNReal.coe_pos, pos_iff_ne_zero]; exact h)] + congr 1 + · simp + apply setLIntegral_congr_fun measurableSet_Ioi +diff --git a/Carleson/ToMathlib/Misc.lean b/Carleson/ToMathlib/Misc.lean +index a58676b..75f2ec6 100644 +--- a/Carleson/ToMathlib/Misc.lean ++++ b/Carleson/ToMathlib/Misc.lean +@@ -4,7 +4,7 @@ import Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds + import Mathlib.MeasureTheory.Integral.Average + import Mathlib.MeasureTheory.Measure.Haar.OfBasis + +-/- ++/-! + * This file can import all ToMathlib files. + * If adding more than a few results, please put them in a more appropriate file in ToMathlib. + +@@ -130,21 +130,19 @@ end support + end Function + + namespace MeasureTheory +- +-set_option linter.style.refine false in + variable {α : Type*} {β : Type*} {s : Set α} {f g : α → β} + {m : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : Measure α} in +-@[measurability, fun_prop] ++@[fun_prop] + protected theorem _root_.AEMeasurable.piecewise {d : DecidablePred (· ∈ s)} (hs : MeasurableSet s) + (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) : AEMeasurable (piecewise s f g) μ := by +- refine' ⟨_, hf.measurable_mk.piecewise hs hg.measurable_mk, ?_⟩ +- · assumption ++ refine ⟨s.piecewise (hf.mk f) (hg.mk g), hf.measurable_mk.piecewise hs hg.measurable_mk, ++ ?_⟩ + filter_upwards [hf.ae_eq_mk, hg.ae_eq_mk] with x hfx hgx + simp_rw [Set.piecewise, ← hfx, ← hgx] + + variable {α : Type*} {β : Type*} {p : α → Prop} {f g : α → β} + {m : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : Measure α} in +-@[measurability, fun_prop] ++@[fun_prop] + protected theorem _root_.AEMeasurable.ite {d : DecidablePred p} (hp : MeasurableSet {a | p a}) + (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) : + AEMeasurable (fun x => ite (p x) (f x) (g x)) μ := +@@ -253,7 +251,7 @@ theorem eLpNormEssSup_lt_top_of_ae_ennnorm_bound {f : α → F} {C : ℝ≥0∞} + (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) : eLpNormEssSup f μ ≤ C := essSup_le_of_ae_le C hfC + + theorem restrict_absolutelyContinuous : μ.restrict s ≪ μ := +- fun s hs ↦ Measure.restrict_le_self s |>.trans hs.le |>.antisymm <| zero_le _ ++ fun s hs ↦ Measure.restrict_le_self s |>.trans hs.le |>.antisymm <| zero_le + + section eLpNorm + +@@ -290,7 +288,12 @@ lemma eLpNorm'_toReal_eq {f : α → ℝ≥0∞} {p : ℝ} (hf : ∀ᵐ x ∂μ, + + lemma eLpNorm_toReal_le {f : α → ℝ≥0∞} : + eLpNorm (ENNReal.toReal ∘ f) p μ ≤ eLpNorm f p μ := by +- simp_rw [eLpNorm] ++ by_cases hmeas : AEStronglyMeasurable f μ ++ swap ++ · simp [eLpNorm_of_not_aestronglyMeasurable hmeas] ++ have hreal : AEStronglyMeasurable (ENNReal.toReal ∘ f) μ := hmeas.ennreal_toReal ++ rw [eLpNorm_eq_eLpNormFormula hreal, eLpNorm_eq_eLpNormFormula hmeas] ++ simp_rw [eLpNormFormula] + split_ifs + · rfl + · exact eLpNormEssSup_toReal_le +@@ -298,15 +301,31 @@ lemma eLpNorm_toReal_le {f : α → ℝ≥0∞} : + + lemma eLpNorm_toReal_eq {f : α → ℝ≥0∞} (hf : ∀ᵐ x ∂μ, f x ≠ ∞) : + eLpNorm (ENNReal.toReal ∘ f) p μ = eLpNorm f p μ := by +- simp_rw [eLpNorm] ++ have hmeas : AEStronglyMeasurable (ENNReal.toReal ∘ f) μ ↔ ++ AEStronglyMeasurable f μ := by ++ refine ⟨fun hreal ↦ ?_, fun hfun ↦ hfun.ennreal_toReal⟩ ++ apply hreal.aemeasurable.ennreal_ofReal.aestronglyMeasurable.congr ++ filter_upwards [hf] with point hpoint ++ simp [ENNReal.ofReal_toReal hpoint] ++ by_cases hfun : AEStronglyMeasurable f μ ++ swap ++ · simp [eLpNorm, hfun, hmeas] ++ rw [eLpNorm_eq_eLpNormFormula (hmeas.mpr hfun), eLpNorm_eq_eLpNormFormula hfun] ++ simp_rw [eLpNormFormula] + split_ifs + · rfl + · exact eLpNormEssSup_toReal_eq hf + · exact eLpNorm'_toReal_eq hf + +-lemma sq_eLpNorm_two {ε : Type*} [ENorm ε] {f : α → ε} : ++lemma sq_eLpNormFormula_two {ε : Type*} [ENorm ε] {f : α → ε} : ++ eLpNormFormula f 2 μ ^ 2 = ∫⁻ x, ‖f x‖ₑ ^ 2 ∂μ := by ++ simpa [eLpNormFormula] using ++ (lintegral_rpow_enorm_eq_rpow_eLpNorm' (f := f) (μ := μ) (by norm_num : (0 : ℝ) < 2)).symm ++ ++lemma sq_eLpNorm_two {ε : Type*} [TopologicalSpace ε] [ENorm ε] {f : α → ε} ++ (hf : AEStronglyMeasurable f μ) : + eLpNorm f 2 μ ^ 2 = ∫⁻ x, ‖f x‖ₑ ^ 2 ∂μ := by +- simpa using eLpNorm_nnreal_pow_eq_lintegral (f := f) two_ne_zero ++ rw [eLpNorm_eq_eLpNormFormula hf, sq_eLpNormFormula_two] + + open ComplexConjugate in + /-- One of the very few cases where a norm can be moved _out of_ an integral. -/ +@@ -317,7 +336,7 @@ lemma eLpNorm_two_eq_enorm_integral_mul_conj {f : α → ℂ} (lpf : MemLp f 2 + rw [integral_eq_lintegral_of_nonneg_ae (.of_forall fun _ ↦ by simp)]; swap + · exact lpf.aestronglyMeasurable.norm.pow 2 + conv_rhs => enter [1, 1, 1, 2, x]; rw [ENNReal.ofReal_pow (norm_nonneg _), ofReal_norm] +- rw [← sq_eLpNorm_two, ← enorm_norm] ++ rw [← sq_eLpNorm_two lpf.aestronglyMeasurable, ← enorm_norm] + simp_rw [Complex.coe_algebraMap, Complex.norm_real, enorm_norm] + rw [toReal_pow, enorm_pow, enorm_toReal lpf.eLpNorm_ne_top] + +@@ -327,8 +346,7 @@ namespace MemLp + + variable {p : ℝ≥0∞} + theorem toReal {f : α → ℝ≥0∞} (hf : MemLp f p μ) : MemLp (f · |>.toReal) p μ := +- ⟨hf.aestronglyMeasurable.aemeasurable.ennreal_toReal.aestronglyMeasurable, +- eLpNorm_toReal_le.trans_lt hf.eLpNorm_lt_top⟩ ++ eLpNorm_toReal_le.trans_lt hf.eLpNorm_lt_top + + end MemLp + +@@ -389,24 +407,24 @@ protected noncomputable def out (x : α) : α := + if hx : x ∈ s then (Quotient.out (s := hr.setoid) ⟦⟨x, hx⟩⟧ : s) else x + + lemma out_mem (hx : x ∈ s) : hr.out x ∈ s := by +- rw [EquivalenceOn.out, dif_pos hx] ++ rw [EquivalenceOn.out, dite_eq_left hx] + apply Subtype.prop + + @[simp] + lemma out_mem_iff : hr.out x ∈ s ↔ x ∈ s := by + refine ⟨fun h ↦ ?_, out_mem⟩ + by_contra hx +- rw [EquivalenceOn.out, dif_neg hx] at h ++ rw [EquivalenceOn.out, dite_eq_right hx] at h + exact hx h + + lemma out_rel (hx : x ∈ s) : r (hr.out x) x := by +- rw [EquivalenceOn.out, dif_pos hx] ++ rw [EquivalenceOn.out, dite_eq_left hx] + exact @Quotient.mk_out _ (hr.setoid) ⟨x, hx⟩ + + lemma rel_out (hx : x ∈ s) : r x (hr.out x) := hr.symm (out_mem hx) hx (out_rel hx) + + lemma out_inj (hx : x ∈ s) (hy : y ∈ s) (h : r x y) : hr.out x = hr.out y := by +- simp_rw [EquivalenceOn.out, dif_pos hx, dif_pos hy] ++ simp_rw [EquivalenceOn.out, dite_eq_left hx, dite_eq_left hy] + congr 1 + simp_rw [Quotient.out_inj, Quotient.eq] + exact h +@@ -488,9 +506,10 @@ section Indicator + + open ComplexConjugate + +-attribute [gcongr] Set.indicator_le_indicator mulIndicator_le_mulIndicator_of_subset ++attribute [gcongr only] Set.indicator_le_indicator mulIndicator_le_mulIndicator_of_subset + +-lemma indicator_eq_indicator' {α : Type*} {M : Type*} [Zero M] {s : Set α} {f g : α → M} (h : ∀ x ∈ s, f x = g x) : ++lemma indicator_eq_indicator' {α : Type*} {M : Type*} [Zero M] {s : Set α} {f g : α → M} ++ (h : ∀ x ∈ s, f x = g x) : + s.indicator f = s.indicator g := by + ext x + unfold indicator +@@ -669,16 +688,16 @@ theorem setIntegral_biUnion_le_sum_setIntegral {X : Type*} {ι : Type*} [Measura + have meas : MeasurableSet {x | 0 ≤ g x} := + have : {x | 0 ≤ g x} = g ⁻¹' (Ici 0) := by simp [preimage, mem_Ici] + this ▸ (AEMeasurable.measurable_mk int_f.aemeasurable) measurableSet_Ici +- rw [← integral_finset_sum_measure int_g] ++ rw [← integral_finsetSum_measure int_g] + set μ₀ : ι → Measure X := fun i ↦ ite (i ∈ s) (μ.restrict (S i)) 0 +- refine integral_mono_measure ?_ ?_ (integrable_finset_sum_measure.mpr int_g) ++ refine integral_mono_measure ?_ ?_ (integrable_finsetSum_measure.mpr int_g) + · refine Measure.le_iff.mpr (fun T hT ↦ ?_) +- simp_rw [μ.restrict_apply hT, Measure.coe_finset_sum, s.sum_apply, inter_iUnion] ++ simp_rw [μ.restrict_apply hT, Measure.coe_finsetSum, s.sum_apply, inter_iUnion] + apply le_trans <| measure_biUnion_finset_le s (T ∩ S ·) + exact s.sum_le_sum (fun _ _ ↦ ge_of_eq (μ.restrict_apply hT)) + · have : ∑ i ∈ s, μ.restrict (S i) = Measure.sum μ₀ := by + ext T hT +- simp only [Measure.sum_apply (hs := hT), Measure.coe_finset_sum, s.sum_apply, μ₀] ++ simp only [Measure.sum_apply (hs := hT), Measure.coe_finsetSum, s.sum_apply, μ₀] + rw [tsum_eq_sum (s := s) (fun b hb ↦ by simp [hb])] + exact Finset.sum_congr rfl (fun i hi ↦ by simp [hi]) + rw [Filter.EventuallyLE, this, Measure.ae_sum_iff' (by exact meas)] +@@ -689,7 +708,7 @@ theorem setIntegral_biUnion_le_sum_setIntegral {X : Type*} {ι : Type*} [Measura + · simp [hi, μ₀] + + -- Analogous to `MeasureTheory.integral_smul_const` in Mathlib +-theorem average_smul_const {X : Type*} {E : Type*} [MeasurableSpace X] ++theorem average_smul_const_carleson {X : Type*} {E : Type*} [MeasurableSpace X] + {μ : MeasureTheory.Measure X} [NormedAddCommGroup E] [NormedSpace ℝ E] {𝕜 : Type*} + [RCLike 𝕜] [NormedSpace 𝕜 E] [CompleteSpace E] (f : X → 𝕜) (c : E) : + ⨍ (x : X), f x • c ∂μ = (⨍ (x : X), f x ∂μ) • c := +@@ -770,12 +789,12 @@ lemma Finset.pow_sum_comm {ι R : Type*} [Semiring R] {s : Finset ι} {f : ι + + namespace MeasureTheory + +-lemma sum_sq_eLpNorm_indicator_le_of_pairwiseDisjoint ++lemma sum_sq_eLpNormFormula_indicator_le_of_pairwiseDisjoint + {α ι F : Type*} [MeasurableSpace α] [NormedAddCommGroup F] {μ : Measure α} + {s : Finset ι} {f : α → F} {t : ι → Set α} (meast : ∀ i, MeasurableSet (t i)) + (hpd : PairwiseDisjoint s t) : +- ∑ i ∈ s, eLpNorm ((t i).indicator f) 2 μ ^ 2 ≤ eLpNorm f 2 μ ^ 2 := by +- simp_rw [sq_eLpNorm_two] ++ ∑ i ∈ s, eLpNormFormula ((t i).indicator f) 2 μ ^ 2 ≤ eLpNormFormula f 2 μ ^ 2 := by ++ simp_rw [sq_eLpNormFormula_two] + conv_lhs => + enter [2, i, 2, x] + rw [enorm_indicator_eq_indicator_enorm, sq, ← inter_indicator_mul, inter_self] +@@ -784,13 +803,24 @@ lemma sum_sq_eLpNorm_indicator_le_of_pairwiseDisjoint + rw [← lintegral_biUnion_finset hpd fun _ _ ↦ meast _] + exact setLIntegral_le_lintegral _ _ + ++lemma sum_sq_eLpNorm_indicator_le_of_pairwiseDisjoint ++ {α ι F : Type*} [MeasurableSpace α] [NormedAddCommGroup F] {μ : Measure α} ++ {s : Finset ι} {f : α → F} {t : ι → Set α} (meast : ∀ i, MeasurableSet (t i)) ++ (hpd : PairwiseDisjoint s t) : ++ ∑ i ∈ s, eLpNorm ((t i).indicator f) 2 μ ^ 2 ≤ eLpNorm f 2 μ ^ 2 := by ++ by_cases hf : AEStronglyMeasurable f μ ++ · simp_rw [eLpNorm_eq_eLpNormFormula (hf.indicator (meast _)), ++ eLpNorm_eq_eLpNormFormula hf] ++ exact sum_sq_eLpNormFormula_indicator_le_of_pairwiseDisjoint meast hpd ++ · simp [eLpNorm_of_not_aestronglyMeasurable hf] ++ + theorem measurable_measure_ball {α : Type*} [PseudoMetricSpace α] [SecondCountableTopology α] + [MeasurableSpace α] [OpensMeasurableSpace α] {μ : Measure α} [SFinite μ] : + Measurable fun (a, r) ↦ μ (Metric.ball a r) := by +- let s : Set (α × α × ℝ) := setOf fun (b, a, r) ↦ b ∈ Metric.ball a r ++ let s : Set (α × α × ℝ) := {point | point.1 ∈ Metric.ball point.2.1 point.2.2} + apply measurable_measure_prodMk_right (s := s) + unfold s Metric.ball +- simp_rw [mem_setOf] ++ simp_rw [mem_ofPred] + apply measurableSet_lt + · fun_prop + · fun_prop +diff --git a/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Basic.lean b/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Basic.lean +index 28c0164..1e50b97 100644 +--- a/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Basic.lean ++++ b/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Basic.lean +@@ -1,6 +1,8 @@ + import Mathlib.Order.ConditionallyCompleteLattice.Basic + import Mathlib.Order.ConditionallyCompleteLattice.Indexed + ++/-! # Comparison of conditionally complete suprema -/ ++ + -- Upstreaming status: under active development by @ldiedering + -- Wait for the file to stabilise first. + +@@ -57,7 +59,8 @@ theorem ciSup_eq_ciSup {α : Type*} {ι ι' : Sort*} [ConditionallyCompleteLinea + rw [iSup_of_empty', iSup_of_empty'] + + @[simp] +-theorem WithTop.iSup_coe_eq_top' {α : Type*} [ConditionallyCompleteLinearOrderBot α] [NoTopOrder α] : ++theorem WithTop.iSup_coe_eq_top' {α : Type*} [ConditionallyCompleteLinearOrderBot α] ++ [NoTopOrder α] : + ⨆ (i : α), ↑i = (⊤ : WithTop α) := by + rw [WithTop.iSup_coe_eq_top] + simp +diff --git a/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Indexed.lean b/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Indexed.lean +index fdec970..6d9b0cf 100644 +--- a/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Indexed.lean ++++ b/Carleson/ToMathlib/Order/ConditionallyCompleteLattice/Indexed.lean +@@ -1,16 +1,6 @@ + import Mathlib.Order.ConditionallyCompleteLattice.Indexed + +-section ConditionallyCompleteLinearOrderBot ++/-! # Indexed suprema in conditionally complete lattices + +-variable {α : Type*} {ι : Sort*} {κ : ι → Sort*} +-variable [ConditionallyCompleteLinearOrderBot α] {a : α} +- +-theorem ciSup₂_le' {f : ∀ i, κ i → α} (h : ∀ i j, f i j ≤ a) : ⨆ (i) (j), f i j ≤ a := +- ciSup_le' fun i => ciSup_le' <| h i +- +-theorem exists_lt_of_lt_ciSup₂' {f : ∀ i, κ i → α} (h : a < ⨆ (i) (j), f i j) : +- ∃ i j, a < f i j := by +- contrapose! h +- exact ciSup₂_le' h +- +-end ConditionallyCompleteLinearOrderBot ++The bounds `ciSup₂_le'` and `exists_lt_of_lt_ciSup₂'` are supplied by Mathlib. ++-/ +diff --git a/Carleson/ToMathlib/RealInterpolation/InterpolatedExponents.lean b/Carleson/ToMathlib/RealInterpolation/InterpolatedExponents.lean +index 9f25cc1..5f8bbb2 100644 +--- a/Carleson/ToMathlib/RealInterpolation/InterpolatedExponents.lean ++++ b/Carleson/ToMathlib/RealInterpolation/InterpolatedExponents.lean +@@ -77,7 +77,7 @@ lemma ne_top_of_Ioc {p q r : ℝ≥0∞} (hq : q ∈ Ioc p r) (hr : r < ⊤) : q + hq.2.trans_lt hr |>.ne_top + + lemma pos_of_rb_Ioc {p q r : ℝ≥0∞} (hr : q ∈ Ioc p r) : 0 < r := +- zero_le p |>.trans_lt hr.1 |>.trans_le hr.2 ++ zero_le.trans_lt hr.1 |>.trans_le hr.2 + + lemma pos_of_Ioo {p q r : ℝ≥0∞} (hq : q ∈ Ioo p r) : 0 < q := pos_of_gt hq.1 + +@@ -113,8 +113,8 @@ lemma preservation_positivity₀ (ht : t ∈ Ioo 0 1) (hpq : p ≠ ⊤ ∨ q ≠ + 0 < (1 - t) * p⁻¹ + t * q⁻¹ := by + obtain dir|dir := hpq + · exact Left.add_pos_of_pos_of_nonneg (mul_pos ((tsub_pos_of_lt ht.2).ne') +- (ENNReal.inv_ne_zero.mpr dir)) (zero_le _) +- · exact Right.add_pos_of_nonneg_of_pos (zero_le _) ++ (ENNReal.inv_ne_zero.mpr dir)) zero_le ++ · exact Right.add_pos_of_nonneg_of_pos zero_le + <| ENNReal.mul_pos ht.1.ne' (ENNReal.inv_ne_zero.mpr dir) + + lemma preservation_positivity (ht : t ∈ Ioo 0 1) (hpq : p ≠ q) : +@@ -156,7 +156,8 @@ lemma rpow_apply_coe' {x : ℝ≥0∞} {y : ℝ} (hx : x ≠ ⊤) : + · rw [ENNReal.toNNReal_eq_zero_iff] + simp [hx] + +-lemma rpow_lt_rpow_iff_neg {x y : ℝ≥0∞} (hx : x ≠ 0) (hy : y ≠ ∞) (hxy : x < y) {z : ℝ} (hz : z < 0) : ++lemma rpow_lt_rpow_iff_neg {x y : ℝ≥0∞} (hx : x ≠ 0) (hy : y ≠ ∞) (hxy : x < y) ++ {z : ℝ} (hz : z < 0) : + y ^ z < x ^ z := by + rw [ENNReal.rpow_apply_coe' hy, ENNReal.rpow_apply_coe' hxy.ne_top] + simpa [(pos_of_gt hxy).ne', hx] using +@@ -216,12 +217,13 @@ lemma rpow_le_rpow_of_exponent_le_base_le {a b t γ : ℝ} (ht : 0 < t) (htγ : + + -- Note: this lemma is false if t = γ = ∞ and a < 0 ≤ b, as then t ^ a = ∞ ^ a = 0 and + -- the statement becomes ∞ ≤ 0 * ∞ = 0. +-lemma rpow_le_rpow_of_exponent_le_base_le_enorm {a b : ℝ} {t γ : ℝ≥0∞} (ht : 0 < t) (ht' : t ≠ ∞) (htγ : t ≤ γ) (hab : a ≤ b) : ++lemma rpow_le_rpow_of_exponent_le_base_le_enorm {a b : ℝ} {t γ : ℝ≥0∞} ++ (ht : 0 < t) (ht' : t ≠ ∞) (htγ : t ≤ γ) (hab : a ≤ b) : + t ^ b ≤ t ^ a * γ ^ (b - a) := by + calc + _ = t ^ (a + (b - a)) := by ring_nf + _ = t ^ a * t ^ (b - a) := by rw [ENNReal.rpow_add _ _ ht.ne' ht'] +- _ ≤ t ^ a * γ ^ (b - a) := by gcongr; linarith ++ _ ≤ t ^ a * γ ^ (b - a) := by gcongr + + -- TODO: there is a lot of overlap between above proof and below + lemma rpow_le_rpow_of_exponent_le_base_ge {a b t γ : ℝ} (hγ : 0 < γ) (htγ : γ ≤ t) (hab : a ≤ b) : +@@ -242,7 +244,8 @@ lemma rpow_le_rpow_of_exponent_le_base_ge {a b t γ : ℝ} (hγ : 0 < γ) (htγ + rw [Real.rpow_mul, Real.rpow_neg_one, ← Real.mul_rpow, ← div_eq_mul_inv] <;> try positivity + exact ofReal_le_ofReal (Real.rpow_le_rpow_of_exponent_le ((one_le_div hγ).mpr htγ) hab) + +-lemma rpow_le_rpow_of_exponent_le_base_ge_enorm {a b : ℝ} {t γ : ℝ≥0∞} (hγ : 0 < γ) (hγ' : γ ≠ ∞) (htγ : γ ≤ t) (hab : a ≤ b) : ++lemma rpow_le_rpow_of_exponent_le_base_ge_enorm {a b : ℝ} {t γ : ℝ≥0∞} ++ (hγ : 0 < γ) (hγ' : γ ≠ ∞) (htγ : γ ≤ t) (hab : a ≤ b) : + t ^ a ≤ (t ^ b) * (γ ^ (a - b)) := by + by_cases ht' : t = ∞ + · simp_all only [le_top, top_rpow_def, ite_mul, sub_zero, one_mul, zero_mul] +@@ -254,7 +257,7 @@ lemma rpow_le_rpow_of_exponent_le_base_ge_enorm {a b : ℝ} {t γ : ℝ≥0∞} + · simp_all + · simpa using by order + · rw [ENNReal.top_mul] +- · exact zero_le ⊤ ++ · exact zero_le + simp_all + · positivity + · simp +@@ -318,7 +321,6 @@ lemma interp_exp_between (hp₀ : 0 < p₀) (hp₁ : 0 < p₁) + gcongr + · finiteness + · exact ht.1.ne' +- · exact ht' + · rw [hp] + have : p₁⁻¹ = (1 - t) * p₁⁻¹ + t * p₁⁻¹ := by + rw [← add_mul, tsub_add_eq_max, max_eq_left_of_lt, one_mul] +@@ -433,7 +435,8 @@ lemma ne_inv_toReal_exponents (hp₀ : 0 < p₀) (hp₁ : 0 < p₁) (hp₀p₁ : + ← ofReal_toReal_eq_iff.mpr (inv_ne_top.mpr hp₁.ne')] + exact congrArg ENNReal.ofReal h + +-lemma ne_inv_toReal_exp_interp_exp (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hp₁ : 0 < p₁) (hp₀p₁ : p₀ ≠ p₁) ++lemma ne_inv_toReal_exp_interp_exp (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hp₁ : 0 < p₁) ++ (hp₀p₁ : p₀ ≠ p₁) + (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) : p₀⁻¹.toReal ≠ p⁻¹.toReal := by + rw [preservation_interpolation ht hp₀ hp₁ hp, ← sub_ne_zero] + convert mul_ne_zero (toReal_ne_zero_of_Ioo ht) +@@ -461,7 +464,8 @@ lemma ne_toReal_exp_interp_exp (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hp₁ : + lemma ne_toReal_exp_interp_exp₁ (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hp₁ : 0 < p₁) (hp₀p₁ : p₀ ≠ p₁) + (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) : + p.toReal ≠ p₁.toReal := +- (ne_toReal_exp_interp_exp (mem_sub_Ioo one_ne_top ht) hp₁ hp₀ hp₀p₁.symm (switch_exponents ht hp)).symm ++ (ne_toReal_exp_interp_exp (mem_sub_Ioo one_ne_top ht) hp₁ hp₀ hp₀p₁.symm ++ (switch_exponents ht hp)).symm + + lemma ofReal_inv_interp_sub_exp_pos₁ (ht : t ∈ Ioo 0 1) (hq₀ : 0 < q₀) (hq₁ : 0 < q₁) + (hq₀q₁ : q₀ ≠ q₁) +@@ -482,7 +486,8 @@ lemma exp_lt_iff (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hp₁ : 0 < p₁) (hp + · exact ⟨fun h ↦ (not_le_of_gt h (le_of_lt (interp_exp_between hp₀ hp₁ p₀lt_p₁ ht hp).1)).elim, + fun h ↦ (not_le_of_gt h p₀lt_p₁.le).elim⟩ + · exact ⟨fun _ ↦ p₁lt_p₀, +- fun _ ↦ (interp_exp_between hp₁ hp₀ p₁lt_p₀ (mem_sub_Ioo one_ne_top ht) (switch_exponents ht hp)).2⟩ ++ fun _ ↦ (interp_exp_between hp₁ hp₀ p₁lt_p₀ (mem_sub_Ioo one_ne_top ht) ++ (switch_exponents ht hp)).2⟩ + + lemma exp_gt_iff (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hp₁ : 0 < p₁) (hp₀p₁ : p₀ ≠ p₁) + (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) : +@@ -568,21 +573,21 @@ lemma ζ_equality₂ (ht : t ∈ Ioo 0 1) : + + lemma ζ_symm (ht : t ∈ Ioo 0 1) : ζ p₀ q₀ p₁ q₁ t.toReal = ζ p₁ q₁ p₀ q₀ (1 - t).toReal := by + unfold ζ +- rw [← mul_div_mul_right (c := - 1), mul_assoc _ _ (-1), mul_assoc _ _ (-1)]; on_goal 2 => positivity ++ rw [← mul_div_mul_right (c := - 1), mul_assoc _ _ (-1), mul_assoc _ _ (-1)] ++ on_goal 2 => positivity + simp only [mul_neg, mul_one, neg_sub] + nth_rewrite 1 [add_comm]; nth_rw 2 [add_comm] + rw [sub_toReal_of_le ht.2.le, sub_sub_toReal_of_le ht.2.le, + sub_sub_toReal_of_le (mem_sub_Ioo (by finiteness) ht).2.le] +- +-set_option linter.style.multiGoal false in +-set_option linter.flexible false in + lemma ζ_equality₃ (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) (hp₁ : 0 < p₁) (hq₁ : 0 < q₁) + (hp₀p₁ : p₀ ≠ p₁) (hq₀q₁ : q₀ ≠ q₁) + (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) + (hq : q⁻¹ = (1 - t) * q₀⁻¹ + t * q₁⁻¹) (hp₀' : p₀ ≠ ⊤) + (hq₀' : q₀ ≠ ⊤) : +- ζ p₀ q₀ p₁ q₁ t.toReal = (p₀.toReal * (q₀.toReal - q.toReal)) / (q₀.toReal * (p₀.toReal - p.toReal)) := by +- rw [ζ_equality₁ ht, ← preservation_interpolation, ← preservation_interpolation] ++ ζ p₀ q₀ p₁ q₁ t.toReal = (p₀.toReal * (q₀.toReal - q.toReal)) / ++ (q₀.toReal * (p₀.toReal - p.toReal)) := by ++ rw [ζ_equality₁ ht, ← preservation_interpolation ht hp₀ hp₁ hp, ++ ← preservation_interpolation ht hq₀ hq₁ hq] + have q_pos : 0 < q := interpolated_pos' hq₀ hq₁ (ne_top_of_Ioo ht) hq + have p_pos : 0 < p := interpolated_pos' hp₀ hp₁ (ne_top_of_Ioo ht) hp + have aux := mul_pos (interp_exp_toReal_pos ht hp₀ hp₁ hp₀p₁ hp) +@@ -600,12 +605,10 @@ lemma ζ_equality₃ (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) + (p₀⁻¹.toReal * p₀.toReal) * p.toReal) := by ring + rw [eq₁, eq₂, ← @toReal_mul q⁻¹ q, ← @toReal_mul p⁻¹ p, ← @toReal_mul p₀⁻¹ p₀, + ← @toReal_mul q₀⁻¹ q₀] +- all_goals try assumption +- -- TODO: why can below goals not be discharged? +- repeat rw [ENNReal.inv_mul_cancel] <;> try positivity +- all_goals simp <;> try assumption +- · apply interp_exp_ne_top hq₀q₁ ht hq +- · apply interp_exp_ne_top hp₀p₁ ht hp ++ rw [ENNReal.inv_mul_cancel q_pos.ne' (interp_exp_ne_top hq₀q₁ ht hq), ++ ENNReal.inv_mul_cancel p_pos.ne' (interp_exp_ne_top hp₀p₁ ht hp), ++ ENNReal.inv_mul_cancel hp₀.ne' hp₀', ENNReal.inv_mul_cancel hq₀.ne' hq₀'] ++ simp + + lemma ζ_equality₄ (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) (hp₁ : 0 < p₁) (hq₁ : 0 < q₁) + (hp₀p₁ : p₀ ≠ p₁) (hq₀q₁ : q₀ ≠ q₁) +@@ -620,12 +623,14 @@ lemma ζ_equality₄ (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) + · rw [hp, add_comm, ENNReal.sub_sub_cancel one_ne_top ht.2.le] + · rw [hq, add_comm, ENNReal.sub_sub_cancel one_ne_top ht.2.le] + +-lemma ζ_equality₅ {t : ℝ≥0∞} (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) (hp₁ : 0 < p₁) (hq₁ : 0 < q₁) ++lemma ζ_equality₅ {t : ℝ≥0∞} (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) ++ (hp₁ : 0 < p₁) (hq₁ : 0 < q₁) + (hp₀p₁ : p₀ ≠ p₁) (hq₀q₁ : q₀ ≠ q₁) + (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) + (hq : q⁻¹ = (1 - t) * q₀⁻¹ + t * q₁⁻¹) (hp₀' : p₀ ≠ ⊤) + (hq₀' : q₀ ≠ ⊤) : +- p₀.toReal + (ζ p₀ q₀ p₁ q₁ t.toReal)⁻¹ * (q.toReal - q₀.toReal) * (p₀.toReal / q₀.toReal) = p.toReal := by ++ p₀.toReal + (ζ p₀ q₀ p₁ q₁ t.toReal)⁻¹ * (q.toReal - q₀.toReal) * ++ (p₀.toReal / q₀.toReal) = p.toReal := by + rw [ζ_equality₃ ht] <;> try assumption + simp only [inv_div] + rw [div_eq_mul_inv, div_eq_mul_inv, mul_inv] +@@ -639,12 +644,14 @@ lemma ζ_equality₅ {t : ℝ≥0∞} (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (h + · exact (exp_toReal_pos hp₀ hp₀').ne' + · exact (exp_toReal_pos hq₀ hq₀').ne' + +-lemma ζ_equality₆ {t : ℝ≥0∞} (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) (hp₁ : 0 < p₁) (hq₁ : 0 < q₁) ++lemma ζ_equality₆ {t : ℝ≥0∞} (ht : t ∈ Ioo 0 1) (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) ++ (hp₁ : 0 < p₁) (hq₁ : 0 < q₁) + (hp₀p₁ : p₀ ≠ p₁) (hq₀q₁ : q₀ ≠ q₁) + (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) + (hq : q⁻¹ = (1 - t) * q₀⁻¹ + t * q₁⁻¹) (hp₁' : p₁ ≠ ⊤) + (hq₁' : q₁ ≠ ⊤) : +- p₁.toReal + (ζ p₀ q₀ p₁ q₁ t.toReal)⁻¹ * (q.toReal - q₁.toReal) * (p₁.toReal / q₁.toReal) = p.toReal := by ++ p₁.toReal + (ζ p₀ q₀ p₁ q₁ t.toReal)⁻¹ * (q.toReal - q₁.toReal) * ++ (p₁.toReal / q₁.toReal) = p.toReal := by + rw [ζ_symm ht] + apply ζ_equality₅ (mem_sub_Ioo one_ne_top ht) hp₁ hq₁ hp₀ hq₀ hp₀p₁.symm hq₀q₁.symm _ _ hp₁' hq₁' + · rw [add_comm, one_sub_one_sub_eq ht]; apply hp +@@ -1010,9 +1017,11 @@ lemma eq_exponents₂ (ht : t ∈ Ioo 0 1) (hq₀ : 0 < q₀) (hq₁ : 0 < q₁) + + lemma eq_exponents₁ (ht : t ∈ Ioo 0 1) (hq₀ : 0 < q₀) (hq₁ : 0 < q₁) (hq₀q₁ : q₀ ≠ q₁) + (hq : q⁻¹ = (1 - t) * q₀⁻¹ + t * q₁⁻¹) (hq₀' : q₀ ≠ ⊤) : +- (q₀⁻¹.toReal / (q₁⁻¹.toReal - q₀⁻¹.toReal)) * (q.toReal - q₀.toReal) = - t.toReal * q.toReal := by ++ (q₀⁻¹.toReal / (q₁⁻¹.toReal - q₀⁻¹.toReal)) * (q.toReal - q₀.toReal) = ++ - t.toReal * q.toReal := by + rw [mul_comm_div, ← mul_div_assoc] +- have : q₀⁻¹.toReal * (q.toReal - q₀.toReal) = - t.toReal * q.toReal * (q₁⁻¹.toReal - q₀⁻¹.toReal) := by ++ have : q₀⁻¹.toReal * (q.toReal - q₀.toReal) = ++ - t.toReal * q.toReal * (q₁⁻¹.toReal - q₀⁻¹.toReal) := by + calc + _ = (q₀⁻¹.toReal * q.toReal - q₀⁻¹.toReal * q₀.toReal) := by ring + _ = (q₀⁻¹.toReal * q.toReal - 1) := by +@@ -1052,7 +1061,8 @@ lemma eq_exponents₃ (ht : t ∈ Ioo 0 1) (hq₀ : 0 < q₀) (hq₁ : 0 < q₁) + exact ne_sub_toReal_exp hq₀ hq₁ hq₀q₁ + + lemma eq_exponents₄ : +- q₀⁻¹.toReal / (q₁⁻¹.toReal - q₀⁻¹.toReal) = - (q₀⁻¹.toReal / (q₀⁻¹.toReal - q₁⁻¹.toReal)) := calc ++ q₀⁻¹.toReal / (q₁⁻¹.toReal - q₀⁻¹.toReal) = ++ - (q₀⁻¹.toReal / (q₀⁻¹.toReal - q₁⁻¹.toReal)) := calc + _ = - (q₀⁻¹.toReal * (-(q₁⁻¹.toReal - q₀⁻¹.toReal)⁻¹)) := by + rw [div_eq_mul_inv]; ring + _ = _ := by congr; rw [neg_inv, neg_sub] +@@ -1066,7 +1076,8 @@ lemma eq_exponents₅ (ht : t ∈ Ioo 0 1) (hq₀ : 0 < q₀) (hq₁ : 0 < q₁) + + lemma eq_exponents₆ (ht : t ∈ Ioo 0 1) (hq₀ : 0 < q₀) (hq₁ : 0 < q₁) (hq₀q₁ : q₀ ≠ q₁) + (hq : q⁻¹ = (1 - t) * q₀⁻¹ + t * q₁⁻¹) (hq₁' : q₁ ≠ ⊤) : +- q₁⁻¹.toReal / (q₁⁻¹.toReal - q₀⁻¹.toReal) * (q.toReal - q₁.toReal) = (1 - t).toReal * q.toReal := by ++ q₁⁻¹.toReal / (q₁⁻¹.toReal - q₀⁻¹.toReal) * (q.toReal - q₁.toReal) = ++ (1 - t).toReal * q.toReal := by + rw [← neg_neg (a := q₁⁻¹.toReal / (q₁⁻¹.toReal - q₀⁻¹.toReal)), ← eq_exponents₄, neg_mul, + eq_exponents₁ (mem_sub_Ioo one_ne_top ht) hq₁ hq₀ hq₀q₁.symm (switch_exponents ht hq) hq₁', + neg_mul, neg_neg] +diff --git a/Carleson/ToMathlib/RealInterpolation/Main.lean b/Carleson/ToMathlib/RealInterpolation/Main.lean +index 9bff6d4..3dce337 100644 +--- a/Carleson/ToMathlib/RealInterpolation/Main.lean ++++ b/Carleson/ToMathlib/RealInterpolation/Main.lean +@@ -50,7 +50,8 @@ variable {α α' ε E E₁ E₂ E₃ : Type*} {m : MeasurableSpace α} {m' : Mea + ## Definitions -/ + namespace MeasureTheory + +-variable {ε₁ ε₂ : Type*} [TopologicalSpace ε₁] [ESeminormedAddMonoid ε₁] [TopologicalSpace ε₂] [ESeminormedAddMonoid ε₂] ++variable {ε₁ ε₂ : Type*} [TopologicalSpace ε₁] [ESeminormedAddMonoid ε₁] ++ [TopologicalSpace ε₂] [ESeminormedAddMonoid ε₂] + + def Subadditive [ENorm ε] (T : (α → ε₁) → α' → ε) : Prop := + ∃ A ≠ ⊤, ∀ (f g : α → ε₁) (x : α'), ‖T (f + g) x‖ₑ ≤ A * (‖T f x‖ₑ + ‖T g x‖ₑ) +@@ -116,7 +117,8 @@ lemma biSup {ι : Type*} {𝓑 : Set ι} (h𝓑 : 𝓑.Countable) {T : ι → ( + specialize h f hf g hg + simp_rw [enorm_eq_self] at h ⊢ + filter_upwards [hT f hf, hT g hg, (ae_ball_iff h𝓑).mpr h, (ae_ball_iff h𝓑).mpr (hT' f hf), +- (ae_ball_iff h𝓑).mpr (hT' g hg), (ae_ball_iff h𝓑).mpr (hT' (f + g) (hP hf hg))] with x hTfx hTgx hx hT'fx hT'gx hT'fgx ++ (ae_ball_iff h𝓑).mpr (hT' g hg), (ae_ball_iff h𝓑).mpr (hT' (f + g) (hP hf hg))] ++ with x hTfx hTgx hx hT'fx hT'gx hT'fgx + simp_rw [iSup_le_iff] + intro i hi + specialize hx i hi +@@ -173,7 +175,8 @@ lemma biSup {ι : Type*} {𝓑 : Set ι} (h𝓑 : 𝓑.Countable) {T : ι → ( + conv at hT' => enter [i]; rw [forall_comm] + rw [forall_comm] at hT'; simp_rw [imp.swap, ← imp_forall_iff] at hT' + filter_upwards [(ae_ball_iff h𝓑).mpr (fun i hi ↦ (h i hi).2 f c hf), +- (ae_ball_iff h𝓑).mpr (hT' f hf), (ae_ball_iff h𝓑).mpr (hT' (c • f) (h_smul hf))] with x hx hT'fx hT'cfx ++ (ae_ball_iff h𝓑).mpr (hT' f hf), (ae_ball_iff h𝓑).mpr (hT' (c • f) (h_smul hf))] ++ with x hx hT'fx hT'cfx + simp_rw [Pi.smul_apply, ENNReal.smul_iSup] + refine biSup_congr (fun i hi ↦ ?_) + specialize hx i hi +@@ -272,7 +275,8 @@ variable {α α' E E₁ E₂ E₃ : Type*} {m : MeasurableSpace α} {m' : Measur + -/ + namespace MeasureTheory + +-variable {ε₁ ε₂ : Type*} [TopologicalSpace ε₁] [ESeminormedAddMonoid ε₁] [TopologicalSpace ε₂] [ESeminormedAddMonoid ε₂] ++variable {ε₁ ε₂ : Type*} [TopologicalSpace ε₁] [ESeminormedAddMonoid ε₁] ++ [TopologicalSpace ε₂] [ESeminormedAddMonoid ε₂] + + /-- Proposition that expresses that the map `T` map between function spaces preserves + AE strong measurability on L^p. -/ +@@ -322,7 +326,8 @@ lemma rewrite_norm_func {q : ℝ} {g : α' → E} + rw [ENNReal.ofReal_rpow_of_pos ha, ENNReal.ofReal_mul (by positivity)] + + lemma estimate_norm_rpow_range_operator {q : ℝ} {f : α → E₁} +- [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] [TopologicalSpace E₂] [ESeminormedAddCommMonoid E₂] ++ [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] ++ [TopologicalSpace E₂] [ESeminormedAddCommMonoid E₂] + (hq : 0 < q) (tc : StrictRangeToneCouple) {A : ℝ≥0} (hA : 0 < A) + (ht : Subadditive_trunc T A f ν) (hTf : AEStronglyMeasurable (T f) ν) : + ∫⁻ x : α', ‖T f x‖ₑ ^ q ∂ν ≤ +@@ -336,8 +341,9 @@ lemma estimate_norm_rpow_range_operator {q : ℝ} {f : α → E₁} + convert estimate_distribution_Subadditive_trunc (tc.ran_ton a ha).1 ht <;> simp + + -- TODO: the infrastructure can perhaps be improved here +-@[measurability, fun_prop] +-theorem ton_measurable_eLpNorm_trunc [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] (tc : ToneCouple) : ++@[fun_prop] ++theorem ton_measurable_eLpNorm_trunc [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] ++ (tc : ToneCouple) : + Measurable (fun x ↦ eLpNorm (trunc f (tc.ton x)) p₁ μ) := by + change Measurable ((fun t : ℝ≥0∞ ↦ eLpNorm (trunc f t) p₁ μ) ∘ (tc.ton)) + have tone := tc.ton_is_ton +@@ -405,7 +411,8 @@ lemma estimate_norm_rpow_range_operator' + apply lintegral_congr_ae + filter_upwards [ae_in_Ioo_zero_top] with s ⟨s_pos, s_lt_top⟩ + have is_q₀top : ¬ q₀ < ⊤ := by assumption +- rw [hq₀' (not_lt_top.mp is_q₀top) s s_pos, hq₁' (not_lt_top.mp is_q₁top) s s_pos, zero_mul, add_zero] ++ rw [hq₀' (not_lt_top.mp is_q₀top) s s_pos, hq₁' (not_lt_top.mp is_q₁top) s s_pos, ++ zero_mul, add_zero] + + lemma simplify_factor_rw_aux₀ (a b c d e f : ℝ≥0∞) : + a * b * c * d * e * f = a * c * e * (b * d * f) := by ring +@@ -561,7 +568,7 @@ def finite_spanning_sets_from_lintegrable {g : α → ℝ≥0∞} (hg : AEMeasur + simp only [one_div] + split_ifs with is_n_zero + · simp [is_n_zero] at wn +- · simp only [mem_setOf_eq] ++ · simp only [mem_ofPred_eq] + refine inv_le_iff_inv_le.mpr ?_ + apply le_of_lt + refine lt_trans wn ?_ +@@ -584,7 +591,7 @@ lemma support_sigma_finite_from_MemLp + unfold Function.support g + ext x + simp only [ne_eq, ENNReal.rpow_eq_zero_iff, enorm_eq_zero, not_or, not_and, not_lt, +- toReal_nonneg, implies_true, and_true, mem_setOf_eq] ++ toReal_nonneg, implies_true, and_true, mem_ofPred_eq] + constructor + · contrapose + simp [Classical.not_imp, not_le, toReal_pos hp' hp] +@@ -592,13 +599,11 @@ lemma support_sigma_finite_from_MemLp + contradiction + rw [← this] + apply support_sigma_finite_of_lintegrable +- · exact hf.1.enorm.pow_const _ ++ · exact hf.aestronglyMeasurable.enorm.pow_const _ + · unfold g +- have obs := hf.2 +- unfold eLpNorm eLpNorm' at obs +- split_ifs at obs +- · contradiction +- · exact lintegral_rpow_enorm_lt_top_of_eLpNorm'_lt_top (toReal_pos hp' hp) obs ++ apply lintegral_rpow_enorm_lt_top_of_eLpNorm'_lt_top (toReal_pos hp' hp) ++ rw [← eLpNorm_eq_eLpNorm' hp' hp hf.aestronglyMeasurable] ++ exact hf + + -- lemma support_sfinite_from_MemLp + -- [MeasurableSpace E₁] [NormedAddCommGroup E₁] [BorelSpace E₁] (hf : MemLp f p μ) +@@ -656,7 +661,8 @@ lemma combine_estimates₀ {A : ℝ≥0} (hA : 0 < A) + eLpNorm (truncCompl f (tc.ton s)) p₀ μ ^ q₀.toReal * + s ^ (q.toReal - q₀.toReal - 1))) := by + gcongr +- apply estimate_norm_rpow_range_operator' (p := p) (tc := tc) p₀pos q₀pos q₁pos <;> try assumption ++ apply estimate_norm_rpow_range_operator' (p := p) (tc := tc) p₀pos q₀pos q₁pos <;> ++ try assumption + · exact (interp_exp_between p₀pos p₁pos hp₀p₁ ht hp).2 + · exact (interp_exp_between p₀pos p₁pos hp₀p₁ ht hp).1 + · intro q₀top s (hs : 0 < s) +@@ -709,7 +715,7 @@ lemma combine_estimates₀ {A : ℝ≥0} (hA : 0 < A) + · exact hp₁.2 + · exact ne_top_of_Ioc hp₁ is_q₁top + · exact is_q₁top.ne_top +- · exact hf.1 ++ · exact hf.aestronglyMeasurable + · rw [hspf]; rfl + · simp + · split_ifs with is_q₀top +@@ -719,7 +725,7 @@ lemma combine_estimates₀ {A : ℝ≥0} (hA : 0 < A) + · exact hp₀.2 + · exact ne_top_of_Ioc hp₀ is_q₀top + · exact is_q₀top.ne_top +- · exact hf.1 ++ · exact hf.aestronglyMeasurable + · rw [hspf]; rfl + · simp + _ = (if q₁ < ⊤ then 1 else 0) * +@@ -784,8 +790,8 @@ lemma combine_estimates₁ {A : ℝ≥0} (hA : 0 < A) + refine le_of_rpow_le q'pos ?_ + calc + _ = ∫⁻ x , ‖T f x‖ₑ ^ q.toReal ∂ν := by +- unfold eLpNorm eLpNorm' +- split_ifs <;> [contradiction; rw [one_div, ENNReal.rpow_inv_rpow q'pos.ne']] ++ rw [eLpNorm_eq_eLpNorm' q_ne_zero q_ne_top (h₂T hf), eLpNorm', one_div, ++ ENNReal.rpow_inv_rpow q'pos.ne'] + _ ≤ _ := by + apply combine_estimates₀ (hT := hT) (p := p) <;> try assumption + _ = _ := by +@@ -798,7 +804,8 @@ lemma combine_estimates₁ {A : ℝ≥0} (hA : 0 < A) + exact ofReal_toReal_eq_iff.mpr q_ne_top + · rw [toReal_inv, ENNReal.rpow_inv_rpow q'pos.ne'] + +-lemma simplify_factor₃ [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] (hp₀ : 0 < p₀) (hp₀' : p₀ ≠ ⊤) (ht : t ∈ Ioo 0 1) ++lemma simplify_factor₃ [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] ++ (hp₀ : 0 < p₀) (hp₀' : p₀ ≠ ⊤) (ht : t ∈ Ioo 0 1) + (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) (hp₀p₁ : p₀ = p₁) : + C₀ ^ q₀.toReal * (eLpNorm f p μ ^ p.toReal) ^ (q₀.toReal / p₀.toReal) = + (↑C₀ * eLpNorm f p μ) ^ q₀.toReal := by +@@ -811,9 +818,11 @@ lemma simplify_factor_aux₄ [TopologicalSpace E₁] [ESeminormedAddCommMonoid E + (hp₀ : p₀ ∈ Ioc 0 q₀) (ht : t ∈ Ioo 0 1) + (hp₀p₁ : p₀ = p₁) (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) + (hF : eLpNorm f p μ ∈ Ioo 0 ⊤) : +- ↑C₀ ^ ((1 - t).toReal * q.toReal) * (eLpNorm f p μ ^ p.toReal) ^ ((1 - t).toReal * p₀⁻¹.toReal * q.toReal) * ++ ↑C₀ ^ ((1 - t).toReal * q.toReal) * ++ (eLpNorm f p μ ^ p.toReal) ^ ((1 - t).toReal * p₀⁻¹.toReal * q.toReal) * + ↑C₁ ^ (t.toReal * q.toReal) * +- (eLpNorm f p μ ^ p.toReal) ^ (t.toReal * p₁⁻¹.toReal * q.toReal) = C₀ ^ ((1 - t).toReal * q.toReal) * ++ (eLpNorm f p μ ^ p.toReal) ^ (t.toReal * p₁⁻¹.toReal * q.toReal) = ++ C₀ ^ ((1 - t).toReal * q.toReal) * + C₁ ^ (t.toReal * q.toReal) * eLpNorm f p μ ^ q.toReal := by + have hp' : p₀ = p := (interp_exp_eq hp₀p₁ ht hp) + have p₀ne_top : p₀ ≠ ⊤ := ne_top_of_le_ne_top hq₀' hp₀.2 +@@ -835,7 +844,8 @@ lemma simplify_factor_aux₄ [TopologicalSpace E₁] [ESeminormedAddCommMonoid E + · exact hp' ▸ d_pos_aux₀ hF |>.ne' + · exact hp' ▸ d_ne_top_aux₀ hF + +-lemma simplify_factor₄ {D : ℝ≥0∞} [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] (hq₀' : q₀ ≠ ⊤) ++lemma simplify_factor₄ {D : ℝ≥0∞} [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] ++ (hq₀' : q₀ ≠ ⊤) + (hp₀ : p₀ ∈ Ioc 0 q₀) (hp₁ : p₁ ∈ Ioc 0 q₁) (ht : t ∈ Ioo 0 1) + (hp₀p₁ : p₀ = p₁) + (hq₀q₁ : q₀ ≠ q₁) (hp : p⁻¹ = (1 - t) * p₀⁻¹ + t * p₁⁻¹) +@@ -851,7 +861,8 @@ lemma simplify_factor₄ {D : ℝ≥0∞} [TopologicalSpace E₁] [ESeminormedAd + rw [simplify_factor₀ (ht := ht) (hD := hD)] <;> assumption + + +-lemma simplify_factor₅ {D : ℝ≥0∞} [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] (hq₁' : q₁ ≠ ⊤) ++lemma simplify_factor₅ {D : ℝ≥0∞} [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] ++ (hq₁' : q₁ ≠ ⊤) + (hp₀ : p₀ ∈ Ioc 0 q₀) (hp₁ : p₁ ∈ Ioc 0 q₁) + (ht : t ∈ Ioo 0 1) + (hp₀p₁ : p₀ = p₁) +@@ -864,7 +875,8 @@ lemma simplify_factor₅ {D : ℝ≥0∞} [TopologicalSpace E₁] [ESeminormedAd + C₀ ^ ((1 - t).toReal * q.toReal) * C₁ ^ (t.toReal * q.toReal) * eLpNorm f p μ ^ q.toReal := by + have p₁pos : 0 < p₁ := hp₁.1 + have p₁ne_top : p₁ ≠ ⊤ := ne_top_of_le_ne_top hq₁' hp₁.2 +- rw [← simplify_factor₃ p₁pos p₁ne_top (mem_sub_Ioo one_ne_top ht) (switch_exponents ht hp) hp₀p₁.symm, ++ rw [← simplify_factor₃ p₁pos p₁ne_top (mem_sub_Ioo one_ne_top ht) ++ (switch_exponents ht hp) hp₀p₁.symm, + simplify_factor₁ hq₁' hp₀ hp₁ ht hq₀q₁ hp hq hC₀ hC₁ hF hD] + + /-- The trivial case for the estimate in the real interpolation theorem +@@ -876,7 +888,7 @@ lemma exists_hasStrongType_real_interpolation_aux₀ {p₀ p₁ q₀ q₁ p q : + (hp : p⁻¹ = (1 - t) / p₀ + t / p₁) + (hq : q⁻¹ = (1 - t) / q₀ + t / q₁) + (h₀T : HasWeakType T p₀ q₀ μ ν C₀) +- (h₂T : PreservesAEStrongMeasurability (μ := μ) (ν := ν) T p) (hf : MemLp f p μ) ++ (_h₂T : PreservesAEStrongMeasurability (μ := μ) (ν := ν) T p) (_hf : MemLp f p μ) + (hF : eLpNorm f p μ = 0) : + eLpNorm (T f) q ν = 0 := by + unfold HasWeakType at h₀T +@@ -884,14 +896,14 @@ lemma exists_hasStrongType_real_interpolation_aux₀ {p₀ p₁ q₀ q₁ p q : + have q₀pos : 0 < q₀ := pos_of_rb_Ioc hp₀ + have q₁pos : 0 < q₁ := pos_of_rb_Ioc hp₁ + have q_pos : 0 < q := interpolated_pos' q₀pos q₁pos (ne_top_of_Ioo ht) hq +- have f_ae_0 : f =ᵐ[μ] 0 := (eLpNorm_eq_zero_iff hf.1 p_pos.ne').mp hF +- have hf₂ : eLpNorm f p₀ μ = 0 := (eLpNorm_eq_zero_iff hf.1 hp₀.1.ne').mpr f_ae_0 +- have hf₁ : MemLp f p₀ μ := ⟨hf.1, by rw [hf₂]; exact zero_lt_top⟩ ++ have f_ae_0 : f =ᵐ[μ] 0 := (eLpNorm_eq_zero_iff p_pos.ne').mp hF ++ have hf₂ : eLpNorm f p₀ μ = 0 := (eLpNorm_eq_zero_iff hp₀.1.ne').mpr f_ae_0 ++ have hf₁ : MemLp f p₀ μ := by rw [MemLp, hf₂]; exact zero_lt_top + have := (h₀T f hf₁).2 + rw [hf₂, mul_zero] at this + have wnorm_0 : wnorm (T f) q₀ ν = 0 := nonpos_iff_eq_zero.mp this + have : (T f) =ᵐ[ν] 0 := (wnorm_eq_zero_iff q₀pos.ne').mp wnorm_0 +- exact (eLpNorm_eq_zero_iff (h₂T hf) q_pos.ne').mpr this ++ exact (eLpNorm_eq_zero_iff q_pos.ne').mpr this + + /-- The estimate for the real interpolation theorem in case `p₀ < p₁`. -/ + lemma exists_hasStrongType_real_interpolation_aux {p₀ p₁ q₀ q₁ p q : ℝ≥0∞} {A : ℝ≥0} +@@ -913,9 +925,9 @@ lemma exists_hasStrongType_real_interpolation_aux {p₀ p₁ q₀ q₁ p q : ℝ + have hq₀ : 0 < q₀ := pos_of_rb_Ioc hp₀ + have hq₁ : 0 < q₁ := pos_of_rb_Ioc hp₁ + rcases (eq_zero_or_pos (eLpNorm f p μ)) with hF | hF +- · refine le_of_eq_of_le ?_ (zero_le _) ++ · refine le_of_eq_of_le ?_ zero_le + apply exists_hasStrongType_real_interpolation_aux₀ (hp := hp) (hq := hq) <;> try assumption +- · let spf := spf_ch (toReal_mem_Ioo ht) hq₀q₁ hp₀.1 hq₀ hp₁.1 hq₁ hp₀p₁.ne hC₀ hC₁ ⟨hF, hf.2⟩ ++ · let spf := spf_ch (toReal_mem_Ioo ht) hq₀q₁ hp₀.1 hq₀ hp₁.1 hq₁ hp₀p₁.ne hC₀ hC₁ ⟨hF, hf⟩ + apply combine_estimates₁ <;> try assumption + on_goal 1 => unfold spf + rfl +@@ -966,9 +978,11 @@ lemma exists_hasStrongType_real_interpolation_aux₁ {f : α → E₁} + ENNReal.ofReal (t ^ (q.toReal - q₁.toReal - 1))) * + if q₁ = ⊤ then 0 else 1)) ^ + q.toReal⁻¹ = (ENNReal.ofReal q.toReal * +- (↑C₀ ^ ((1 - t).toReal * q.toReal) * ↑C₁ ^ (t.toReal * q.toReal) * eLpNorm f p μ ^ q.toReal * ++ (↑C₀ ^ ((1 - t).toReal * q.toReal) * ↑C₁ ^ (t.toReal * q.toReal) * ++ eLpNorm f p μ ^ q.toReal * + ENNReal.ofReal |q.toReal - q₀.toReal|⁻¹ * (if q₀ = ⊤ then 0 else 1) + +- ↑C₀ ^ ((1 - t).toReal * q.toReal) * ↑C₁ ^ (t.toReal * q.toReal) * eLpNorm f p μ ^ q.toReal * ++ ↑C₀ ^ ((1 - t).toReal * q.toReal) * ↑C₁ ^ (t.toReal * q.toReal) * ++ eLpNorm f p μ ^ q.toReal * + ENNReal.ofReal |q.toReal - q₁.toReal|⁻¹ * if q₁ = ⊤ then 0 else 1)) ^ + q.toReal⁻¹ := by + congr 3 +@@ -976,9 +990,7 @@ lemma exists_hasStrongType_real_interpolation_aux₁ {f : α → E₁} + div_eq_mul_inv, ← ofReal_inv_of_pos, ← ENNReal.ofReal_rpow_of_pos] <;> try positivity + rw [← mul_assoc, simplify_factor₄ (ht := ht) (hC₁ := hC₁) (hq₀' := hq₀q₁.ne_top)] + <;> try assumption +- · rw [abs_of_pos] <;> linarith +- · rw [abs_of_pos] <;> linarith +- · linarith ++ linarith + · split_ifs with is_q₁top + · rw [mul_zero, mul_zero] + · have q_lt_q₁toReal : q.toReal < q₁.toReal := +@@ -1025,9 +1037,9 @@ lemma exists_hasStrongType_real_interpolation_aux₂ {f : α → E₁} + (interp_exp_toReal_pos' ht q₀pos q₁pos hq (Or.inl hq₀q₁.ne_top)).ne' + have p_eq_p₀ : p = p₀ := (interp_exp_eq hp₀p₁ ht hp).symm + rcases (eq_zero_or_pos (eLpNorm f p μ)) with hF | snorm_pos +- · refine le_of_eq_of_le ?_ (zero_le _) ++ · refine le_of_eq_of_le ?_ zero_le + apply exists_hasStrongType_real_interpolation_aux₀ (hp := hp) (hq := hq) <;> try assumption +- · have hF : eLpNorm f p μ ∈ Ioo 0 ⊤ := ⟨snorm_pos, hf.2⟩ ++ · have hF : eLpNorm f p μ ∈ Ioo 0 ⊤ := ⟨snorm_pos, hf⟩ + have M_pos : 0 < M := toReal_pos (d_pos hC₀ hC₁ hF).ne' (d_ne_top hC₀ hC₁ hF) + have coe_q : ENNReal.ofReal q.toReal = q := + ofReal_toReal_eq_iff.mpr (interp_exp_ne_top hq₀q₁.ne ht hq) +@@ -1036,10 +1048,13 @@ lemma exists_hasStrongType_real_interpolation_aux₂ {f : α → E₁} + (interp_exp_toReal_pos ht q₀pos q₁pos hq₀q₁.ne hq)] + calc + (ENNReal.ofReal q.toReal * +- ∫⁻ (t : ℝ) in Ioi 0, distribution (T f) (ENNReal.ofReal t) ν * ENNReal.ofReal (t ^ (q.toReal - 1))) ^ q.toReal⁻¹ ++ ∫⁻ (t : ℝ) in Ioi 0, distribution (T f) (ENNReal.ofReal t) ν * ++ ENNReal.ofReal (t ^ (q.toReal - 1))) ^ q.toReal⁻¹ + ≤ (ENNReal.ofReal q.toReal * ( +- (∫⁻ (t : ℝ) in Ioo 0 M, distribution (T f) (ENNReal.ofReal t) ν * ENNReal.ofReal (t ^ (q.toReal - 1))) + +- (∫⁻ (t : ℝ) in Ici M, distribution (T f) (ENNReal.ofReal t) ν * ENNReal.ofReal (t ^ (q.toReal - 1)))) ++ (∫⁻ (t : ℝ) in Ioo 0 M, distribution (T f) (ENNReal.ofReal t) ν * ++ ENNReal.ofReal (t ^ (q.toReal - 1))) + ++ (∫⁻ (t : ℝ) in Ici M, distribution (T f) (ENNReal.ofReal t) ν * ++ ENNReal.ofReal (t ^ (q.toReal - 1)))) + ) ^ q.toReal⁻¹ := by + gcongr + rw [← Ioo_union_Ici_eq_Ioi (M_pos)] +@@ -1325,7 +1340,8 @@ lemma Subadditive_trunc_from_SubadditiveOn_Lp₀p₁ {p₀ p₁ p : ℝ≥0∞} + apply hT + · rcases lt_trichotomy p₀ p₁ with p₀lt_p₁ | (p₀eq_p₁ | p₁lt_p₀) + · refine Or.inr (trunc_Lp_Lq_higher (p := p) ?_ hf ha) +- exact ⟨interpolated_pos' hp₀ hp₁ (ne_top_of_Ioo ht) hp, (interp_exp_between hp₀ hp₁ p₀lt_p₁ ht hp).2.le⟩ ++ exact ⟨interpolated_pos' hp₀ hp₁ (ne_top_of_Ioo ht) hp, ++ (interp_exp_between hp₀ hp₁ p₀lt_p₁ ht hp).2.le⟩ + · exact Or.inl <| interp_exp_eq p₀eq_p₁ ht hp ▸ hf.trunc + · refine Or.inl (trunc_Lp_Lq_higher (p := p) ?_ hf ha) + exact ⟨interpolated_pos' hp₀ hp₁ (ne_top_of_Ioo ht) hp, +diff --git a/Carleson/ToMathlib/RealInterpolation/Minkowski.lean b/Carleson/ToMathlib/RealInterpolation/Minkowski.lean +index 43184f4..632342e 100644 +--- a/Carleson/ToMathlib/RealInterpolation/Minkowski.lean ++++ b/Carleson/ToMathlib/RealInterpolation/Minkowski.lean +@@ -42,8 +42,8 @@ lemma truncCut_mono {μ : Measure α} [SigmaFinite μ] {f : α → ℝ≥0∞} ( + · exact min_le_min_left (f x) (Nat.cast_le.mpr hmn) + · contrapose! is_fx_le_n + exact monotone_spanningSets _ hmn is_fx_le_m +- · exact zero_le _ +- · exact zero_le _ ++ · exact zero_le ++ · exact zero_le + + lemma truncCut_mono₀ {μ : Measure α} [SigmaFinite μ] {f : α → ℝ≥0∞} : + Monotone (truncCut f μ) := by +@@ -57,7 +57,7 @@ lemma truncCut_sup {μ : Measure α} [SigmaFinite μ] {f : α → ℝ≥0∞} (x + · intro n; unfold truncCut indicator + split_ifs + · exact min_le_left (f x) ↑n +- · exact zero_le _ ++ · exact zero_le + · intro w hw + unfold truncCut + have : ∃ m : ℕ, x ∈ spanningSets μ m := by +@@ -77,8 +77,6 @@ lemma truncCut_sup {μ : Measure α} [SigmaFinite μ] {f : α → ℝ≥0∞} (x + _ = _ := (Nat.cast_add m n).symm + · contrapose! is_x_in_Ampn + exact monotone_spanningSets _ (Nat.le_add_right m n) wm +- +-set_option linter.flexible false in + /-- Characterization of `∫⁻ x : α, f x ^ p ∂μ` by a duality argument. -/ + lemma representationLp {μ : Measure α} [SigmaFinite μ] {f : α → ℝ≥0∞} + (hf : AEMeasurable f μ) {p q : ℝ} (hp : p > 1) (hq : q ≥ 1) +@@ -140,7 +138,7 @@ lemma representationLp {μ : Measure α} [SigmaFinite μ] {f : α → ℝ≥0∞ + intro n + rcases eq_or_ne (∫⁻ x : α, (g n x) ^ p ∂μ) 0 with int_eq_zero | int_ne_zero + · rw [int_eq_zero, ENNReal.zero_rpow_of_pos] +- · exact zero_le _ ++ · exact zero_le + · exact inv_pos_of_pos (by positivity) + · calc + _ = (∫⁻ x : α, (f x) * (g n x) ^ (p - 1) ∂μ) * ( +@@ -173,7 +171,9 @@ lemma representationLp {μ : Measure α} [SigmaFinite μ] {f : α → ℝ≥0∞ + apply Monotone.map_iSup_of_continuousAt (f := fun (x : ℝ≥0∞) ↦ x ^ (1 / p)) + · fun_prop + · apply ENNReal.monotone_rpow_of_nonneg (by positivity) +- · simp; positivity ++ · simp only [bot_eq_zero', one_div, ENNReal.rpow_eq_zero_iff, inv_pos, true_and, ++ zero_ne_top, inv_neg'', false_and, or_false] ++ positivity + let h := fun n : ℕ ↦ (fun x ↦ g n x ^ (p - 1) / (∫⁻ y : α, ((g n y) ^ (p - 1)) ^ q ∂μ) ^ q⁻¹) + have comp_sup : (⨆ n : ℕ, ∫⁻ (x : α), f x * h n x ∂μ) ≤ + ⨆ g ∈ {g' : α → ℝ≥0∞ | AEMeasurable g' μ ∧ ∫⁻ (z : α), (g' z) ^ q ∂μ ≤ 1}, +@@ -250,9 +250,9 @@ lemma aemeasurability_prod₂ {α : Type u_1} {β : Type u_3} + ∀ᵐ y : β ∂ν, AEMeasurable (f ∘ (fun x ↦ Prod.mk x y)) μ := by + have : AEMeasurable (f ∘ Prod.swap) (ν.prod μ) := by + refine AEMeasurable.comp_measurable ?_ measurable_swap +- rw [Measure.prod_swap] +- assumption ++ rwa [Measure.prod_swap] + convert aemeasurability_prod₁ this -- perf: convert is faster than exact ++ rfl + + -- TODO: better name! + @[fun_prop] +@@ -324,7 +324,7 @@ lemma lintegral_lintegral_pow_swap_rpow {α : Type u_1} {β : Type u_3} {p : ℝ + /-! ## Apply Minkowski's integral inequality to truncations + -/ + +-@[measurability, fun_prop] ++@[fun_prop] + theorem aemeasurable_ton (tc : ToneCouple) : AEMeasurable tc.ton (volume.restrict (Ioi 0)) := by + -- ton is either increasing or decreasing + have tone := tc.ton_is_ton +@@ -336,8 +336,10 @@ theorem aemeasurable_ton (tc : ToneCouple) : AEMeasurable tc.ton (volume.restric + @[measurability] + lemma indicator_ton_measurable {g : α → E₁} [MeasurableSpace E₁] + [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] [BorelSpace E₁] ++ [SFinite μ] + (hg : AEMeasurable g μ) (tc : ToneCouple) : +- NullMeasurableSet {(s, x) : ℝ≥0∞ × α | ‖g x‖ₑ ≤ tc.ton s } ((volume.restrict (Ioi 0)).prod μ) := by ++ NullMeasurableSet {(s, x) : ℝ≥0∞ × α | ‖g x‖ₑ ≤ tc.ton s } ++ ((volume.restrict (Ioi 0)).prod μ) := by + apply nullMeasurableSet_le hg.comp_snd.enorm + apply AEMeasurable.comp_fst (f := fun a ↦ tc.ton a) + refine AEMeasurable.comp_aemeasurable ?_ aemeasurable_id' +@@ -347,7 +349,7 @@ lemma indicator_ton_measurable {g : α → E₁} [MeasurableSpace E₁] + @[measurability] + lemma indicator_ton_measurable_lt {g : α → E₁} [MeasurableSpace E₁] + [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] +- [BorelSpace E₁] (hg : AEMeasurable g μ) (tc : ToneCouple) : ++ [BorelSpace E₁] [SFinite μ] (hg : AEMeasurable g μ) (tc : ToneCouple) : + NullMeasurableSet {(s, x) : ℝ≥0∞ × α | tc.ton s < ‖g x‖ₑ } + ((volume.restrict (Ioi 0)).prod μ) := by + refine nullMeasurableSet_lt ?_ hg.comp_snd.enorm +@@ -355,9 +357,10 @@ lemma indicator_ton_measurable_lt {g : α → E₁} [MeasurableSpace E₁] + refine AEMeasurable.comp_aemeasurable ?_ aemeasurable_id' + simp only [Measure.map_id', aemeasurable_ton] + +-@[measurability, fun_prop] ++@[fun_prop] + lemma AEMeasurable.trunc_ton {f : α → E₁} + [MeasurableSpace E₁] [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] [BorelSpace E₁] ++ [SFinite (μ.restrict f.support)] + (hf : AEMeasurable f μ) (tc : ToneCouple) : + AEMeasurable (fun a : ℝ≥0∞ × α ↦ (trunc f (tc.ton a.1)) a.2) + ((volume.restrict (Ioi 0)).prod (μ.restrict f.support)) := by +@@ -369,49 +372,54 @@ lemma AEMeasurable.trunc_ton {f : α → E₁} + exact (aemeasurable_indicator_iff₀ (indicator_ton_measurable (AEMeasurable.restrict hf) _)).mpr + hf.restrict.comp_snd.restrict + +-@[measurability, fun_prop] ++@[fun_prop] + lemma AEMeasurable.truncCompl_ton {f : α → E₁} + [MeasurableSpace E₁] [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] [BorelSpace E₁] ++ [SFinite (μ.restrict f.support)] + (hf : AEMeasurable f μ) (tc : ToneCouple) : + AEMeasurable (fun a : ℝ≥0∞ × α ↦ ((truncCompl f (tc.ton a.1))) a.2) + ((volume.restrict (Ioi 0)).prod (μ.restrict f.support )) := by + let A := {(s, x) : ℝ≥0∞ × α | tc.ton s < ‖f x‖ₑ} +- have : (fun z : ℝ≥0∞ × α ↦ (truncCompl f (tc.ton z.1)) z.2) = Set.indicator A (fun z : ℝ≥0∞ × α ↦ f z.2) := by ++ have : (fun z : ℝ≥0∞ × α ↦ (truncCompl f (tc.ton z.1)) z.2) = ++ Set.indicator A (fun z : ℝ≥0∞ × α ↦ f z.2) := by + ext z; rw [truncCompl_eq]; simp [A, indicator] + rw [this] + exact (aemeasurable_indicator_iff₀ (indicator_ton_measurable_lt hf.restrict _)).mpr + hf.restrict.comp_snd.restrict + + -- TODO: better name! +-lemma restrict_to_support {p : ℝ} (hp : 0 < p) [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] (f : α → E₁) : ++lemma restrict_to_support {p : ℝ} (hp : 0 < p) [TopologicalSpace E₁] ++ [ESeminormedAddCommMonoid E₁] (f : α → E₁) : + ∫⁻ x : α in f.support, ‖trunc f t x‖ₑ ^ p ∂ μ = ∫⁻ x : α, ‖trunc f t x‖ₑ ^ p ∂μ := by + apply setLIntegral_eq_of_support_subset + unfold Function.support trunc +- rw [setOf_subset_setOf] ++ rw [ofPred_subset_ofPred] + intro x + contrapose! + intro f_zero + simp_rw [f_zero]; simp [hp] + + -- TODO: better name! +-lemma restrict_to_support_truncCompl {p : ℝ} [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] (hp : 0 < p) (f : α → E₁) : ++lemma restrict_to_support_truncCompl {p : ℝ} [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] ++ (hp : 0 < p) (f : α → E₁) : + ∫⁻ x : α in f.support, ‖(truncCompl f t) x‖ₑ ^ p ∂μ = + ∫⁻ x : α, ‖(truncCompl f t) x‖ₑ ^ p ∂μ := by + apply setLIntegral_eq_of_support_subset + unfold Function.support +- rw [truncCompl_eq, setOf_subset_setOf] ++ rw [truncCompl_eq, ofPred_subset_ofPred] + intro x + contrapose! + intro f_zero + simp [hp, f_zero] + + -- TODO: better name! +-lemma restrict_to_support_trnc {p : ℝ} {j : Bool} [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] (hp : 0 < p) (f : α → E₁) : ++lemma restrict_to_support_trnc {p : ℝ} {j : Bool} [TopologicalSpace E₁] ++ [ESeminormedAddCommMonoid E₁] (hp : 0 < p) (f : α → E₁) : + ∫⁻ x : α in f.support, ‖trnc j f t x‖ₑ ^ p ∂μ = + ∫⁻ x : α, ‖trnc j f t x‖ₑ ^ p ∂μ := by + apply setLIntegral_eq_of_support_subset + unfold Function.support trnc trunc truncCompl +- rw [setOf_subset_setOf] ++ rw [ofPred_subset_ofPred] + intro x + contrapose! + intro f_zero +@@ -420,7 +428,9 @@ lemma restrict_to_support_trnc {p : ℝ} {j : Bool} [TopologicalSpace E₁] [ESe + + @[fun_prop] + theorem AEMeasurable.trnc_restrict +- [MeasurableSpace E₁] [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] [BorelSpace E₁] {j : Bool} ++ [MeasurableSpace E₁] [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] [BorelSpace E₁] ++ {j : Bool} ++ [SFinite (μ.restrict f.support)] + (hf : AEMeasurable f μ) (tc : ToneCouple) : + AEMeasurable (fun a ↦ trnc j f (tc.ton a.1) a.2) + ((volume.restrict (Ioi 0)).prod (μ.restrict f.support)) := by +@@ -442,14 +452,15 @@ lemma lintegral_lintegral_pow_swap_truncCompl {q q₀ p₀ : ℝ} [MeasurableSpa + (∫⁻ a : α in f.support, + (∫⁻ (s : ℝ) in Ioi 0, + (ENNReal.ofReal (s ^ (q - q₀ - 1)) ^ (p₀⁻¹ * q₀)⁻¹ * +- ‖trnc j f (tc.ton (ENNReal.ofReal s)) a‖ₑ ^ p₀) ^ (p₀⁻¹ * q₀)) ^ (p₀⁻¹ * q₀)⁻¹ ∂μ) ^ (p₀⁻¹ * q₀) := by ++ ‖trnc j f (tc.ton (ENNReal.ofReal s)) a‖ₑ ^ p₀) ^ (p₀⁻¹ * q₀)) ^ ++ (p₀⁻¹ * q₀)⁻¹ ∂μ) ^ (p₀⁻¹ * q₀) := by + apply lintegral_lintegral_pow_swap_rpow + · apply le_of_mul_le_mul_left _ hp₀ + field_simp + exact hp₀q₀ + · unfold Function.uncurry + -- TODO: this is quite some effort, somehow the infrastructure may need to be better +- apply AEMeasurable.mul' ++ apply AEMeasurable.mul + · fun_prop + · have : (fun a ↦ ‖trnc j f (tc.ton (ENNReal.ofReal a.1)) a.2‖ₑ ^ p₀) = + (fun a ↦ ‖trnc j f (tc.ton a.1) a.2‖ₑ ^ p₀ ) ∘ +@@ -458,10 +469,13 @@ lemma lintegral_lintegral_pow_swap_truncCompl {q q₀ p₀ : ℝ} [MeasurableSpa + apply AEMeasurable.comp_aemeasurable + · rw [← Measure.map_prod_map] + · simp only [Measure.map_id'] +- have : Measure.map (fun a ↦ ENNReal.ofReal a) (volume.restrict (Ioi 0)) = volume.restrict (Ioi 0) := by ++ have : Measure.map (fun a ↦ ENNReal.ofReal a) (volume.restrict (Ioi 0)) = ++ volume.restrict (Ioi 0) := by + simp [map_restrict_Ioi_eq_restrict_Ioi] + rw [this] +- have : (fun a ↦ ‖trnc j f (tc.ton a.1) a.2‖ₑ ^ p₀) = (fun z : E₁ ↦ ‖ z ‖ₑ ^ p₀) ∘ (fun a : ℝ≥0∞ × α ↦ trnc j f (tc.ton a.1) a.2) := rfl ++ have : (fun a ↦ ‖trnc j f (tc.ton a.1) a.2‖ₑ ^ p₀) = ++ (fun z : E₁ ↦ ‖z‖ₑ ^ p₀) ∘ ++ (fun a : ℝ≥0∞ × α ↦ trnc j f (tc.ton a.1) a.2) := rfl + rw [this] + apply AEMeasurable.comp_aemeasurable + · fun_prop +@@ -478,13 +492,13 @@ lemma lintegral_congr_support {f : α → E₁} {g h : α → ENNReal} + rw [Measure.restrict_apply₀'] + · refine measure_mono_null (fun x h₀ ↦ ?_) measure_empty + have : g x = h x := hgh _ (mem_of_mem_inter_right h₀) +- have : x ∈ {a | ¬g a = h a} := mem_of_mem_diff h₀ ++ have : x ∈ {a | ¬g a = h a} := mem_of_mem_sdiff h₀ + change ¬ (g x = h x) at this + contradiction + · have : f.support = (fun x ↦ ‖f x‖ₑ).support := by + unfold Function.support + ext x +- simp only [ne_eq, mem_setOf_eq, enorm_eq_zero] ++ simp only [ne_eq, mem_ofPred_eq, enorm_eq_zero] + rw [this] + exact (aestronglyMeasurable_iff_aemeasurable.mpr hf.enorm).nullMeasurableSet_support + +@@ -504,24 +518,21 @@ lemma estimate_trnc {p₀ q₀ q : ℝ} {spf : ScaledPowerFunction} {j : Bool} + (∫⁻ (a : α) in f.support, + ‖f a‖ₑ ^ (p₀ + spf.σ⁻¹ * (q - q₀) * (p₀ / q₀)) ∂μ) ^ (p₀⁻¹ * q₀) := by + have := spf.hd +- unfold eLpNorm eLpNorm' ++ simp_rw [eLpNorm_eq_eLpNorm' (ofReal_pos.mpr hp₀).ne' coe_ne_top ++ (aestronglyMeasurable_trnc hf), eLpNorm', toReal_ofReal hp₀.le] + set tc := (spf_to_tc spf).toToneCouple +- split_ifs with is_p₀pos is_p₀top +- · have : p₀ ≤ 0 := ofReal_eq_zero.mp is_p₀pos +- contrapose! this; exact hp₀ +- · contrapose! is_p₀top; exact coe_ne_top +- · rw [toReal_ofReal hp₀.le] +- calc ++ calc + _ = ∫⁻ s : ℝ in Ioi 0, ENNReal.ofReal (s ^ (q - q₀ - 1)) * +- ((∫⁻ (a : α), ↑‖trnc j f ((spf_to_tc spf).ton (ENNReal.ofReal s)) a‖ₑ ^ p₀ ∂μ) ^ (1 / p₀)) ^ q₀ := by ++ ((∫⁻ (a : α), ↑‖trnc j f ((spf_to_tc spf).ton (ENNReal.ofReal s)) a‖ₑ ^ p₀ ∂μ) ^ ++ (1 / p₀)) ^ q₀ := by + congr 1 + ext x + rw [mul_comm] + _ = ∫⁻ (s : ℝ) in Ioi 0, + (ENNReal.ofReal (s ^ (q - q₀ - 1)) ^ (p₀⁻¹ * q₀)⁻¹) ^ (p₀⁻¹ * q₀) * +- (∫⁻ (a : α) in f.support, ↑‖trnc j f (tc.ton (ENNReal.ofReal s)) a‖ₑ ^ p₀ ∂μ) ^ (p₀⁻¹ * q₀) := by ++ (∫⁻ (a : α) in f.support, ↑‖trnc j f (tc.ton (ENNReal.ofReal s)) a‖ₑ ^ p₀ ∂μ) ^ ++ (p₀⁻¹ * q₀) := by + refine setLIntegral_congr_fun measurableSet_Ioi fun s hs ↦ ?_ +- dsimp + rw [ENNReal.rpow_inv_rpow] + · rw [one_div, ← ENNReal.rpow_mul, restrict_to_support_trnc hp₀] + · positivity +@@ -530,14 +541,14 @@ lemma estimate_trnc {p₀ q₀ q : ℝ} {spf : ScaledPowerFunction} {j : Bool} + ENNReal.ofReal (s ^ (q - q₀ - 1)) ^ (p₀⁻¹ * q₀)⁻¹ * + ‖trnc j f (tc.ton (ENNReal.ofReal s)) a‖ₑ ^ p₀ ∂μ) ^ (p₀⁻¹ * q₀) := by + refine setLIntegral_congr_fun measurableSet_Ioi fun s hs ↦ ?_ +- dsimp + rw [lintegral_const_mul', ENNReal.mul_rpow_of_nonneg] + · positivity + · exact (ENNReal.rpow_lt_top_of_nonneg (by positivity) coe_ne_top).ne + _ ≤ (∫⁻ a : α in f.support, + (∫⁻ (s : ℝ) in Ioi 0, + (ENNReal.ofReal (s ^ (q - q₀ - 1)) ^ (p₀⁻¹ * q₀)⁻¹ * +- ‖trnc j f (tc.ton (ENNReal.ofReal s)) a‖ₑ ^ p₀) ^ (p₀⁻¹ * q₀)) ^ (p₀⁻¹ * q₀)⁻¹ ∂μ) ^ (p₀⁻¹ * q₀) := by ++ ‖trnc j f (tc.ton (ENNReal.ofReal s)) a‖ₑ ^ p₀) ^ (p₀⁻¹ * q₀)) ^ ++ (p₀⁻¹ * q₀)⁻¹ ∂μ) ^ (p₀⁻¹ * q₀) := by + -- This is a consequence of Minkowski's integral inequality + apply lintegral_lintegral_pow_swap_truncCompl hp₀ hp₀q₀ hf tc; assumption + _ = (∫⁻ a : α in f.support, +@@ -549,7 +560,6 @@ lemma estimate_trnc {p₀ q₀ q : ℝ} {spf : ScaledPowerFunction} {j : Bool} + intro x _ + congr 1 + refine setLIntegral_congr_fun measurableSet_Ioi fun s hs ↦ ?_ +- dsimp + rw [ENNReal.mul_rpow_of_nonneg, ENNReal.rpow_inv_rpow, ← ENNReal.rpow_mul] <;> try positivity + congr + field_simp +@@ -636,7 +646,8 @@ lemma estimate_trnc₁ {spf : ScaledPowerFunction} {j : Bool} + (hf : AEStronglyMeasurable f μ) (hf₂ : SigmaFinite (μ.restrict f.support)) + (hspf : spf.σ = ζ p₀ q₀ p₁ q₁ t.toReal) : + ∫⁻ s : ℝ in Ioi 0, +- eLpNorm (trnc j f ((spf_to_tc spf).ton (ENNReal.ofReal s))) (sel j p₀ p₁) μ ^ (sel j q₀ q₁).toReal * ++ eLpNorm (trnc j f ((spf_to_tc spf).ton (ENNReal.ofReal s))) (sel j p₀ p₁) μ ^ ++ (sel j q₀ q₁).toReal * + ENNReal.ofReal (s ^ (q.toReal - (sel j q₀ q₁).toReal - 1)) ≤ + (spf.d ^ (q.toReal - (sel j q₀ q₁).toReal)) * + ENNReal.ofReal |q.toReal - (sel j q₀ q₁).toReal|⁻¹ * +@@ -670,7 +681,8 @@ lemma estimate_trnc₁ {spf : ScaledPowerFunction} {j : Bool} + ‖f a‖ₑ ^ ((sel j p₀ p₁).toReal + spf.σ⁻¹ * (q.toReal - (sel j q₀ q₁).toReal) * + ((sel j p₀ p₁).toReal / (sel j q₀ q₁).toReal)) ∂μ) ^ + ((sel j p₀ p₁).toReal ⁻¹ * (sel j q₀ q₁).toReal) := by +- have coe_p' : ENNReal.ofReal (sel j p₀ p₁).toReal = (sel j p₀ p₁) := ofReal_toReal_eq_iff.mpr hp' ++ have coe_p' : ENNReal.ofReal (sel j p₀ p₁).toReal = (sel j p₀ p₁) := ++ ofReal_toReal_eq_iff.mpr hp' + nth_rw 1 [← coe_p'] + apply estimate_trnc + · apply toReal_pos +@@ -690,7 +702,7 @@ lemma estimate_trnc₁ {spf : ScaledPowerFunction} {j : Bool} + cases j + · unfold sel + dsimp only +- simp only [hspf, Bool.if_false_right, Bool.and_true, Bool.false_bne, decide_eq_true_eq] ++ simp only [hspf, Bool.ite_false_right, Bool.and_true, Bool.false_bne, decide_eq_true_eq] + split_ifs with is_ζ_pos + · apply toReal_strict_mono + · exact interp_exp_ne_top hq₀q₁ ht hq +@@ -700,7 +712,7 @@ lemma estimate_trnc₁ {spf : ScaledPowerFunction} {j : Bool} + (le_of_not_gt is_ζ_pos) + · unfold sel + dsimp only +- simp only [hspf, Bool.if_false_right, Bool.and_true, Bool.true_bne, Bool.not_eq_true', ++ simp only [hspf, Bool.ite_false_right, Bool.and_true, Bool.true_bne, Bool.not_eq_true', + decide_eq_false_iff_not] + split_ifs with is_ζ_pos + · apply toReal_strict_mono hq' +@@ -737,7 +749,7 @@ lemma estimate_trnc₁ {spf : ScaledPowerFunction} {j : Bool} + ((sel j p₀ p₁).toReal ⁻¹ * (sel j q₀ q₁).toReal) := by + congr + rw [← one_div] +- refine (eLpNorm_eq_lintegral_rpow_enorm_toReal (ε := E₁) ?_ ?_).symm ++ refine (eLpNorm_eq_lintegral_rpow_enorm_toReal (ε := E₁) ?_ ?_ hf).symm + · exact (interpolated_pos' hp₀ hp₁ (ne_top_of_Ioo ht) hp).ne' + · exact interp_exp_ne_top hp₀p₁.ne ht hp + +@@ -774,20 +786,27 @@ lemma wnorm_eq_zero_iff [ENormedAddMonoid ε] {f : α → ε} {p : ℝ≥0∞} ( + exact iSup_wnorm b.toNNReal + exact meas_ne_zero this + · refine iSup_eq_zero.mpr fun t ↦ mul_eq_zero.mpr +- (Or.inr ((rpow_eq_zero_iff_of_pos (inv_pos_of_pos (toReal_pos hp h₀))).mpr (nonpos_iff_eq_zero.mp ?_))) ++ (Or.inr ((rpow_eq_zero_iff_of_pos (inv_pos_of_pos (toReal_pos hp h₀))).mpr ++ (nonpos_iff_eq_zero.mp ?_))) + calc +- _ ≤ distribution f 0 μ := by gcongr; exact zero_le _ ++ _ ≤ distribution f 0 μ := by gcongr; exact zero_le + _ = distribution f (eLpNormEssSup f μ) μ := by congr; exact h.symm + _ = 0 := distribution_snormEssSup + + + /-! ## Weaktype estimates applied to truncations -/ + +-variable [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] [TopologicalSpace E₂] [ESeminormedAddCommMonoid E₂] +- {E₁' E₂' : Type*} [TopologicalSpace E₁'] [ENormedAddCommMonoid E₁'] [TopologicalSpace E₂'] [ENormedAddCommMonoid E₂'] ++variable [TopologicalSpace E₁] [ESeminormedAddCommMonoid E₁] ++ [TopologicalSpace E₂] [ESeminormedAddCommMonoid E₂] ++ {E₁' E₂' : Type*} [TopologicalSpace E₁'] [ENormedAddCommMonoid E₁'] ++ [TopologicalSpace E₂'] [ENormedAddCommMonoid E₂'] + + lemma eLpNorm_trnc_est {f : α → E₁} {j : Bool} : +- eLpNorm (trnc j f t) p μ ≤ eLpNorm f p μ := eLpNorm_mono_enorm fun _x ↦ trnc_le_func ++ eLpNorm (trnc j f t) p μ ≤ eLpNorm f p μ := by ++ by_cases hf : AEStronglyMeasurable f μ ++ · exact eLpNorm_mono_enorm (aestronglyMeasurable_trnc hf) fun _x ↦ trnc_le_func ++ · rw [eLpNorm_of_not_aestronglyMeasurable hf] ++ exact le_top + + variable [ContinuousENorm ε₁] [ContinuousENorm ε₂] {T : (α → ε₁) → (α' → ε₂)} in + lemma weaktype_estimate {C₀ : ℝ≥0} {p : ℝ≥0∞} {q : ℝ≥0∞} {f : α → ε₁} +@@ -826,15 +845,18 @@ variable [ENormedAddMonoid ε₁] [ENormedAddMonoid ε₂] in + lemma weaktype_aux₀ {f : α → ε₁} {T : (α → ε₁) → (α' → ε₂)} + {p₀ q₀ p q : ℝ≥0∞} (hp₀ : 0 < p₀) (hq₀ : 0 < q₀) (hp : 0 < p) (hq : 0 < q) + {C₀ : ℝ≥0} (h₀T : HasWeakType T p₀ q₀ μ ν C₀) +- (hf : AEStronglyMeasurable f μ) (hF : eLpNorm f p μ = 0) : eLpNorm (T f) q ν = 0 := by +- have f_ae_0 : f =ᵐ[μ] 0 := (eLpNorm_eq_zero_iff hf hp.ne').mp hF +- have hf₂ : eLpNorm f p₀ μ = 0 := (eLpNorm_eq_zero_iff hf hp₀.ne').mpr f_ae_0 +- have hf₁ : MemLp f p₀ μ := ⟨hf, by rw [hf₂]; exact zero_lt_top⟩ ++ (_hf : AEStronglyMeasurable f μ) (hF : eLpNorm f p μ = 0) : eLpNorm (T f) q ν = 0 := by ++ have f_ae_0 : f =ᵐ[μ] 0 := (eLpNorm_eq_zero_iff hp.ne').mp hF ++ have hf₂ : eLpNorm f p₀ μ = 0 := (eLpNorm_eq_zero_iff hp₀.ne').mpr f_ae_0 ++ have hf₁ : MemLp f p₀ μ := by ++ change eLpNorm f p₀ μ < ∞ ++ rw [hf₂] ++ exact zero_lt_top + have := (h₀T f hf₁).2 + rw [hf₂, mul_zero] at this + have wnorm_0 : wnorm (T f) q₀ ν = 0 := nonpos_iff_eq_zero.mp this + have : (T f) =ᵐ[ν] 0 := (wnorm_eq_zero_iff hq₀.ne').mp wnorm_0 +- exact (eLpNorm_eq_zero_iff (h₀T _ hf₁).1 hq.ne').mpr this ++ exact (eLpNorm_eq_zero_iff hq.ne').mpr this + + -- for the remaining lemmas we use too much measure theory that is just for normed spaces + -- try to generalize to ENorm-classes after Mathlib refactor +@@ -867,7 +889,8 @@ lemma weaktype_estimate_trunc_top_top {a : ℝ≥0∞} {C₁ : ℝ≥0} + rw [ha] + have obs : MemLp (trunc f (t / C₁)) p₁ μ := trunc_Lp_Lq_higher ⟨hp, hp₁p⟩ hf (by finiteness) + have wt_est := (h₁T (trunc f (t / C₁)) obs).2 +- simp only [wnorm, eLpNorm, hq₁, ↓reduceIte, hp₁, top_ne_zero] at wt_est ++ simp only [wnorm, hq₁, ↓reduceIte, hp₁, ++ eLpNorm_exponent_top obs.aestronglyMeasurable] at wt_est + apply nonpos_iff_eq_zero.mp + have ineq : eLpNormEssSup (T' (trunc f (t / C₁))) ν ≤ t := calc + _ ≤ C₁ * eLpNormEssSup (trunc f (t / C₁)) μ := wt_est +@@ -875,7 +898,7 @@ lemma weaktype_estimate_trunc_top_top {a : ℝ≥0∞} {C₁ : ℝ≥0} + gcongr + exact trunc_eLpNormEssSup_le _ + _ ≤ _ := by +- rw [max_eq_right (zero_le _), ++ rw [max_eq_right zero_le, + ENNReal.mul_div_cancel (ENNReal.coe_ne_zero.mpr hC₁.ne') (by finiteness)] + calc + _ ≤ distribution (T' (trunc f (t / C₁))) (eLpNormEssSup (T' (trunc f (t / C₁))) ν) ν := +@@ -893,15 +916,16 @@ lemma weaktype_estimate_truncCompl_top {C₀ : ℝ≥0} (hC₀ : 0 < C₀) {p p + rcases (eq_zero_or_pos (eLpNormEssSup f μ)) with snorm_zero | snorm_pos + · have : eLpNorm (trnc ⊥ f a) ⊤ μ = 0 := by + apply nonpos_iff_eq_zero.mp +- rw [← snorm_zero] ++ rw [← snorm_zero, ← eLpNorm_exponent_top hf.aestronglyMeasurable] + exact eLpNorm_trnc_est (p := ⊤) + have obs : eLpNorm (T' (trnc ⊥ f a)) ⊤ ν = 0 := +- weaktype_aux₀ hp₀ (hq₀ ▸ zero_lt_top) zero_lt_top zero_lt_top h₀T hf.1.truncCompl this +- exact nonpos_iff_eq_zero.mp (Trans.trans (distribution_mono_right (Trans.trans obs +- (zero_le t))) meas_eLpNormEssSup_lt) ++ weaktype_aux₀ hp₀ (hq₀ ▸ zero_lt_top) zero_lt_top zero_lt_top h₀T ++ hf.aestronglyMeasurable.truncCompl this ++ exact nonpos_iff_eq_zero.mp ((distribution_mono_right ++ (eLpNormEssSup_le_eLpNorm_top.trans (obs ▸ zero_le))).trans meas_eLpNormEssSup_lt.le) + · have p_pos : 0 < p := hp₀.trans hp₀p + have snorm_p_pos : eLpNorm f p μ ≠ 0 := fun snorm_0 ↦ snorm_pos.ne' <| +- eLpNormEssSup_eq_zero_iff.mpr <| (eLpNorm_eq_zero_iff hf.1 p_pos.ne').mp snorm_0 ++ eLpNormEssSup_eq_zero_iff.mpr <| (eLpNorm_eq_zero_iff p_pos.ne').mp snorm_0 + have term_pos : (ENNReal.ofNNReal C₀) ^ p₀.toReal * eLpNorm f p μ ^ p.toReal > 0 := by + apply ENNReal.mul_pos <;> exact (rpow_pos_of_nonneg (by positivity) (by positivity)).ne' + have d_pos : 0 < d := hdeq ▸ ENNReal.rpow_pos term_pos (by finiteness) +@@ -919,7 +943,7 @@ lemma weaktype_estimate_truncCompl_top {C₀ : ℝ≥0} (hC₀ : 0 < C₀) {p p + eLpNorm f p μ ^ p.toReal) := by + rw [ENNReal.mul_rpow_of_nonneg _ _ toReal_nonneg] + gcongr +- exact estimate_eLpNorm_truncCompl hp ⟨hp₀, hp₀p.le⟩ hf.1 a_pos ++ exact estimate_eLpNorm_truncCompl hp ⟨hp₀, hp₀p.le⟩ hf.aestronglyMeasurable a_pos + _ = (↑C₀) ^ p₀.toReal * eLpNorm f p μ ^ p.toReal * (d ^ p₀.toReal)⁻¹ * (t ^ p₀.toReal) := by + rw [ha, ← ENNReal.rpow_mul, div_mul_cancel₀] + · -- FIXME: can/should this be shared with the lemma below? +@@ -968,7 +992,7 @@ lemma weaktype_estimate_trunc_top {C₁ : ℝ≥0} (hC₁ : 0 < C₁) {p p₁ q + calc + _ ≤ (ENNReal.ofNNReal C₁) * eLpNorm f p₁ μ := by + gcongr +- apply eLpNorm_mono_enorm (fun x ↦ trunc_le_func) ++ exact eLpNorm_mono_enorm obs.aestronglyMeasurable (fun _x ↦ trunc_le_func) + _ ≤ _ := by + have : eLpNorm f p₁ μ = 0 := Trans.trans (eLpNorm_congr_ae + (eLpNormEssSup_eq_zero_iff.mp snorm_zero)) eLpNorm_zero +@@ -977,7 +1001,7 @@ lemma weaktype_estimate_trunc_top {C₁ : ℝ≥0} (hC₁ : 0 < C₁) {p p₁ q + intro snorm_0 + apply snorm_pos.ne' + apply eLpNormEssSup_eq_zero_iff.mpr +- exact (eLpNorm_eq_zero_iff hf.1 hp.ne').mp snorm_0 ++ exact (eLpNorm_eq_zero_iff hp.ne').mp snorm_0 + -- XXX: these lines are the same as in the lemma above + have term_pos : (ENNReal.ofNNReal C₁) ^ p₁.toReal * eLpNorm f p μ ^ p.toReal > 0 := by + apply ENNReal.mul_pos <;> exact (rpow_pos_of_nonneg (by positivity) (by positivity)).ne' +@@ -985,7 +1009,7 @@ lemma weaktype_estimate_trunc_top {C₁ : ℝ≥0} (hC₁ : 0 < C₁) {p p₁ q + _ ≤ ↑C₁ ^ p₁.toReal * (((a ^ (p₁.toReal - p.toReal))) * eLpNorm f p μ ^ p.toReal) := by + rw [ENNReal.mul_rpow_of_nonneg _ _ (by positivity)] + gcongr +- exact estimate_eLpNorm_trunc hp₁.ne_top ⟨hp, hp₁p.le⟩ hf.1 ++ exact estimate_eLpNorm_trunc hp₁.ne_top ⟨hp, hp₁p.le⟩ hf.aestronglyMeasurable + _ = ↑C₁ ^ p₁.toReal * eLpNorm f p μ ^ p.toReal * (d ^ p₁.toReal)⁻¹ * (t ^ p₁.toReal) := by + rw [ha, ← ENNReal.rpow_mul, div_mul_cancel₀] + · rw [ENNReal.div_rpow_of_nonneg, div_eq_mul_inv] <;> try positivity +@@ -994,7 +1018,8 @@ lemma weaktype_estimate_trunc_top {C₁ : ℝ≥0} (hC₁ : 0 < C₁) {p p₁ q + _ = _ := by + nth_rw 2 [← one_mul (t ^ p₁.toReal)] + congr +- rw [hdeq, ENNReal.rpow_inv_rpow hp₁' _, ENNReal.mul_inv_cancel term_pos.ne' (by finiteness)] ++ rw [hdeq, ENNReal.rpow_inv_rpow hp₁' _, ++ ENNReal.mul_inv_cancel term_pos.ne' (by finiteness)] + apply nonpos_iff_eq_zero.mp + calc + _ ≤ distribution (T' (trunc f a)) (eLpNormEssSup (T' (trunc f a)) ν) ν := by gcongr +diff --git a/Carleson/ToMathlib/RealInterpolation/Misc.lean b/Carleson/ToMathlib/RealInterpolation/Misc.lean +index d72de05..d2ea11e 100644 +--- a/Carleson/ToMathlib/RealInterpolation/Misc.lean ++++ b/Carleson/ToMathlib/RealInterpolation/Misc.lean +@@ -90,7 +90,6 @@ def spf_to_tc (spf : ScaledPowerFunction) : StrictRangeToneCouple where + intro s t hst + beta_reduce + gcongr +- exact this + · simp only [Bool.false_eq_true, ↓reduceIte] + intro s t hst + rcases spf.hσ with σ_pos | σ_neg +@@ -196,7 +195,8 @@ lemma d_ne_top_aux₃ {C : ℝ≥0} {b c : ℝ} (hC : 0 < C) + C ^ c * (eLpNorm f p μ ^ p.toReal) ^ b ≠ ⊤ := + mul_ne_top (d_ne_top_aux₁ hC) (d_ne_top_aux₂ hF) + +-lemma d_ne_zero_aux₃ {b₀ c₀ b₁ c₁ : ℝ} (hC₀ : 0 < C₀) (hC₁ : 0 < C₁) (hF : eLpNorm f p μ ∈ Ioo 0 ⊤) : ++lemma d_ne_zero_aux₃ {b₀ c₀ b₁ c₁ : ℝ} (hC₀ : 0 < C₀) (hC₁ : 0 < C₁) ++ (hF : eLpNorm f p μ ∈ Ioo 0 ⊤) : + (C₀ ^ c₀ * (eLpNorm f p μ ^ p.toReal) ^ b₀) / + (C₁ ^ c₁ * (eLpNorm f p μ ^ p.toReal) ^ b₁) ≠ 0 := by + refine ENNReal.div_ne_zero.mpr ⟨?_, ?_⟩ +@@ -312,7 +312,7 @@ lemma lintegral_double_restrict_set {A B : Set α} {f : α → ℝ≥0∞} (hA : + (hB : MeasurableSet B) (hf : ∀ᵐ (x : α) ∂μ, x ∈ A \ B → f x ≤ 0) : + ∫⁻ x in A, f x ∂μ = ∫⁻ x in A ∩ B, f x ∂μ := by + have h₀ := setLIntegral_mono_ae' (MeasurableSet.diff hA hB) hf; rw [lintegral_zero] at h₀ +- rw [← lintegral_inter_add_diff (hB := hB), nonpos_iff_eq_zero.mp h₀, add_zero] ++ rw [← lintegral_inter_add_sdiff (hB := hB), nonpos_iff_eq_zero.mp h₀, add_zero] + + -- local convenience function + lemma lintegral_rw_aux {g : ℝ → ℝ≥0∞} {f₁ f₂ : ℝ → ℝ≥0∞} {A : Set ℝ} +@@ -336,10 +336,10 @@ lemma power_aux_2 {p q : ℝ} : + lemma power_aux_3 {p q : ℝ} : + (fun s : ℝ≥0∞ ↦ s ^ (p + q)) =ᶠ[ae volume] (fun s ↦ s ^ p * s ^ q ) := by + filter_upwards [Ioo_zero_top_ae_eq_univ] with a ha +- unfold Ioo at ha ++ have ha' : a ∈ Ioo 0 ∞ := ha.mpr (mem_univ a) + refine ENNReal.rpow_add p q ?_ ?_ +- · simp [pos_iff_ne_zero] at ha; by_contra; have := (ha.mpr trivial).1; tauto +- · simp [lt_top_iff_ne_top] at ha; by_contra; have := (ha.mpr trivial).2; tauto ++ · exact ha'.1.ne' ++ · exact ha'.2.ne + + lemma power_aux_4 {p : ℝ} : + (fun s ↦ ENNReal.ofReal (s ^ p)) =ᶠ[ae (volume.restrict (Ioi (0 : ℝ)))] +@@ -402,7 +402,9 @@ namespace MeasureTheory + def trunc (f : α → ε) (t : ℝ≥0∞) (x : α) : ε := if ‖f x‖ₑ ≤ t then f x else 0 + + lemma trunc_eq_indicator : trunc f t = {x | ‖f x‖ₑ ≤ t}.indicator f := by +- ext x; simp_rw [trunc, Set.indicator, mem_setOf_eq, ite_eq_ite] ++ funext x ++ simp only [trunc, Set.indicator, mem_ofPred_eq] ++ split_ifs <;> rfl + + @[simp] + lemma trunc_top : trunc f ∞ = f := by simp [trunc_eq_indicator] +@@ -412,7 +414,7 @@ def truncCompl (f : α → ε) (t : ℝ≥0∞) (x : α) : ε := if ‖f x‖ₑ + + lemma truncCompl_eq_indicator : truncCompl f t = {x | ‖f x‖ₑ ≤ t}ᶜ.indicator f := by + ext x +- simp only [truncCompl, Set.indicator, mem_compl_iff, mem_setOf_eq, ite_not] ++ simp only [truncCompl, Set.indicator, mem_compl_iff, mem_ofPred_eq, ite_not] + + @[simp] + lemma truncCompl_top : truncCompl f ∞ = (fun _ ↦ 0) := by simp [truncCompl_eq_indicator] +@@ -462,7 +464,6 @@ function itself. -/ + lemma truncCompl_of_nonpos {f : α → ε'} (ht : t ≤ 0) : truncCompl f t = f := by + rw [truncCompl_eq] + ext x +- dsimp only [Pi.zero_apply] + split_ifs + · rfl + · apply (enorm_eq_zero.mp ?_).symm +@@ -485,17 +486,18 @@ lemma truncCompl_of_nonpos {f : α → ε'} (ht : t ≤ 0) : truncCompl f t = f + -- apply Measurable.ite ?_ hf measurable_const + -- exact measurableSet_lt measurable_const hf.norm + +-@[measurability] ++@[fun_prop] + protected lemma StronglyMeasurable.trunc (hf : StronglyMeasurable f) : + StronglyMeasurable (trunc f t) := + StronglyMeasurable.ite (measurableSet_le hf.enorm.stronglyMeasurable stronglyMeasurable_const) hf + stronglyMeasurable_const + +-@[measurability] ++@[fun_prop] + protected lemma StronglyMeasurable.truncCompl (hf : StronglyMeasurable f) : + StronglyMeasurable (truncCompl f t) := by + rw [truncCompl_eq] +- exact hf.ite (measurableSet_lt stronglyMeasurable_const hf.enorm.stronglyMeasurable) stronglyMeasurable_const ++ exact hf.ite (measurableSet_lt stronglyMeasurable_const hf.enorm.stronglyMeasurable) ++ stronglyMeasurable_const + + -- @[measurability, fun_prop] + -- lemma AEMeasurable.trunc [MeasurableSpace E₁] [NormedAddCommGroup E₁] [BorelSpace E₁] +@@ -528,7 +530,7 @@ protected lemma StronglyMeasurable.truncCompl (hf : StronglyMeasurable f) : + -- simp only [mem_compl_iff, mem_setOf_eq, not_not] + -- intro f_eq_g; unfold truncCompl; unfold trunc; dsimp only [Pi.sub_apply]; rw [f_eq_g] + +-@[measurability] ++@[fun_prop] + nonrec lemma AEStronglyMeasurable.trunc (hf : AEStronglyMeasurable f μ) : + AEStronglyMeasurable (trunc f t) μ := by + rcases hf with ⟨g, ⟨wg1, wg2⟩⟩ +@@ -538,7 +540,7 @@ nonrec lemma AEStronglyMeasurable.trunc (hf : AEStronglyMeasurable f μ) : + exact wg1.indicator (s := {x | ‖g x‖ₑ ≤ t}) (measurableSet_le wg1.enorm (by fun_prop)) + · exact measure_mono_null (fun x ↦ by contrapose!; simp_all [trunc]) wg2 + +-@[measurability] ++@[fun_prop] + nonrec lemma AEStronglyMeasurable.truncCompl + (hf : AEStronglyMeasurable f μ) : AEStronglyMeasurable (truncCompl f t) μ := by + rcases hf with ⟨g, ⟨wg1, wg2⟩⟩ +@@ -551,7 +553,7 @@ nonrec lemma AEStronglyMeasurable.truncCompl + · exact measure_mono_null (fun x ↦ by contrapose!; simp_all [truncCompl]) wg2 + + +-@[measurability] ++@[fun_prop] + lemma aestronglyMeasurable_trnc {j : Bool} (hf : AEStronglyMeasurable f μ) : + AEStronglyMeasurable (trnc j f t) μ := + j.rec (.truncCompl hf) (.trunc hf) +@@ -571,7 +573,8 @@ lemma trunc_eLpNormEssSup_le {f : α → ε} (a : ℝ≥0∞) : + eLpNormEssSup (trunc f a) μ ≤ (max 0 a) := + essSup_le_of_ae_le _ (ae_of_all _ fun x ↦ trunc_le x) + +-lemma trunc_mono {f : α → ε} {a b : ℝ≥0∞} (hab : a ≤ b) {x : α} : ‖trunc f a x‖ₑ ≤ ‖trunc f b x‖ₑ := by ++lemma trunc_mono {f : α → ε} {a b : ℝ≥0∞} (hab : a ≤ b) {x : α} : ++ ‖trunc f a x‖ₑ ≤ ‖trunc f b x‖ₑ := by + unfold trunc + split_ifs + · rfl +@@ -579,10 +582,28 @@ lemma trunc_mono {f : α → ε} {a b : ℝ≥0∞} (hab : a ≤ b) {x : α} : + · rw [enorm_zero]; positivity + · exact le_rfl + ++lemma eLpNormFormula_trunc_mono : ++ Monotone fun s ↦ eLpNormFormula (trunc f s) p μ := by ++ intro lower upper hle ++ unfold eLpNormFormula ++ split_ifs ++ · exact le_rfl ++ · exact eLpNormEssSup_mono_enorm_ae (ae_of_all _ fun _ ↦ trunc_mono hle) ++ · exact eLpNorm'_mono_enorm_ae toReal_nonneg (ae_of_all _ fun _ ↦ trunc_mono hle) ++ + /-- The norm of the truncation is monotone in the truncation parameter -/ + lemma eLpNorm_trunc_mono : +- Monotone fun s ↦ eLpNorm (trunc f s) p μ := +- fun _a _b hab ↦ eLpNorm_mono_enorm fun _x ↦ trunc_mono hab ++ Monotone fun s ↦ eLpNorm (trunc f s) p μ := by ++ intro lower upper hle ++ by_cases hupper : AEStronglyMeasurable (trunc f upper) μ ++ · have heq : trunc (trunc f upper) lower = trunc f lower := by ++ ext point ++ by_cases hpoint : ‖f point‖ₑ ≤ upper ++ · simp [trunc, hpoint] ++ · have hlower : ¬‖f point‖ₑ ≤ lower := fun hbound ↦ hpoint (hbound.trans hle) ++ simp [trunc, hpoint, hlower] ++ exact eLpNorm_mono_enorm (heq ▸ hupper.trunc) fun _ ↦ trunc_mono hle ++ · simp [eLpNorm, hupper] + + lemma trunc_buildup_enorm {x : α} : + ‖trunc f t x‖ₑ + ‖truncCompl f t x‖ₑ = ‖f x‖ₑ := by +@@ -613,22 +634,22 @@ lemma eLpNorm_truncCompl_anti (hf : eLpNorm f 1 μ ≠ ⊤) (mf : AEStronglyMeas + Antitone (fun s ↦ eLpNorm (truncCompl f s) p μ) := by + intro a _b hab + have : ∀ᵐ x ∂μ, ‖f x‖ₑ ≠ ⊤ := by +- rw [eLpNorm_one_eq_lintegral_enorm] at hf ++ rw [eLpNorm_one_eq_lintegral_enorm mf] at hf + simp_rw [ae_iff, not_ne_iff]; exact measure_eq_top_of_lintegral_ne_top mf.enorm hf + have : ∀ᵐ x ∂μ, ‖trunc f a x‖ₑ ≠ ⊤ := by + refine this.mono fun x hx ↦ ?_ + rw [trunc] + split_ifs; exacts [hx, by simp] +- exact eLpNorm_mono_enorm_ae <| this.mono fun x hx ↦ truncCompl_anti hab hx ++ exact eLpNorm_mono_enorm_ae mf.truncCompl <| this.mono fun x hx ↦ truncCompl_anti hab hx + + /-- The norm of the truncation is meaurable in the truncation parameter -/ +-@[measurability, fun_prop] ++@[fun_prop] + lemma eLpNorm_trunc_measurable : + Measurable (fun s ↦ eLpNorm (trunc f s) p μ) := + eLpNorm_trunc_mono.measurable + + /-- The norm of the complement of the truncation is measurable in the truncation parameter -/ +-@[measurability, fun_prop] ++@[fun_prop] + lemma eLpNorm_truncCompl_measurable (hf : eLpNorm f 1 μ ≠ ⊤) (mf : AEStronglyMeasurable f μ) : + Measurable (fun s ↦ eLpNorm (truncCompl f s) p μ) := + eLpNorm_truncCompl_anti hf mf |>.measurable +@@ -655,10 +676,7 @@ lemma trnc_le_func {j : Bool} {a : ℝ≥0∞} {x : α} : + /-! ## Truncations and L-p spaces -/ + + lemma MemLp.trunc {p : ℝ≥0∞} (hf : MemLp f p μ) : MemLp (trunc f t) p μ := by +- refine ⟨hf.1.trunc, lt_of_le_of_lt (eLpNorm_mono_ae' (ae_of_all _ ?_)) hf.2⟩ +- intro x +- unfold MeasureTheory.trunc +- split_ifs with is_fx_le_a <;> simp ++ exact (eLpNorm_mono_enorm hf.aestronglyMeasurable.trunc fun _ ↦ trunc_le_func).trans_lt hf + + -- lemma eLpNorm_truncCompl_le {p : ℝ≥0∞} : + -- eLpNorm (truncCompl f t) p μ ≤ eLpNorm f p μ := +@@ -666,26 +684,24 @@ lemma MemLp.trunc {p : ℝ≥0∞} (hf : MemLp f p μ) : MemLp (trunc f t) p μ + + lemma MemLp.truncCompl {p : ℝ≥0∞} (hf : MemLp f p μ) : + MemLp (truncCompl f t) p μ := by +- refine ⟨hf.1.truncCompl, lt_of_le_of_lt (eLpNorm_mono_ae' (ae_of_all _ ?_)) hf.2⟩ +- intro x +- unfold MeasureTheory.truncCompl +- split_ifs with is_fx_le_a <;> simp ++ exact (eLpNorm_mono_enorm hf.aestronglyMeasurable.truncCompl ++ fun _ ↦ truncCompl_le_func).trans_lt hf + +-lemma eLpNorm_truncCompl_le {q : ℝ≥0∞} ++lemma eLpNormFormula_truncCompl_le {q : ℝ≥0∞} + (q_ne_zero : ¬ q = 0) (q_ne_top : q ≠ ⊤) : +- eLpNorm (truncCompl f t) q μ ^ q.toReal ≤ ++ eLpNormFormula (truncCompl f t) q μ ^ q.toReal ≤ + ∫⁻ x : α in {x | t < ‖f x‖ₑ}, ‖f x‖ₑ ^ q.toReal ∂μ := by +- unfold eLpNorm eLpNorm' ++ simp only [eLpNormFormula, q_ne_zero, q_ne_top, ↓reduceIte, eLpNorm'] + have q_toReal_pos : 0 < q.toReal := toReal_pos q_ne_zero q_ne_top +- split_ifs + calc + _ = ∫⁻ x : α in {x | t < ‖f x‖ₑ}, ‖(truncCompl f t) x‖ₑ ^ q.toReal ∂μ := by + rw [one_div, ENNReal.rpow_inv_rpow] + · apply (setLIntegral_eq_of_support_subset _).symm + unfold Function.support + intro x +- rw [truncCompl_eq, mem_setOf_eq] +- dsimp only [Pi.sub_apply] ++ change ‖truncCompl f t x‖ₑ ^ q.toReal ≠ 0 → t < ‖f x‖ₑ ++ rw [truncCompl_eq] ++ dsimp only + split_ifs with is_a_lt_fx + · exact fun _ ↦ is_a_lt_fx + · contrapose; intro _; simpa [enorm_eq_nnnorm] +@@ -694,6 +710,13 @@ lemma eLpNorm_truncCompl_le {q : ℝ≥0∞} + gcongr with x + exact trnc_le_func (j := ⊥) + ++lemma eLpNorm_truncCompl_le {q : ℝ≥0∞} ++ (q_ne_zero : q ≠ 0) (q_ne_top : q ≠ ⊤) (hf : AEStronglyMeasurable f μ) : ++ eLpNorm (truncCompl f t) q μ ^ q.toReal ≤ ++ ∫⁻ x : α in {x | t < ‖f x‖ₑ}, ‖f x‖ₑ ^ q.toReal ∂μ := by ++ rw [eLpNorm_eq_eLpNormFormula hf.truncCompl] ++ exact eLpNormFormula_truncCompl_le q_ne_zero q_ne_top ++ + -- TODO: better name! + lemma estimate_eLpNorm_truncCompl {p q : ℝ≥0∞} + (p_ne_top : p ≠ ⊤) (hpq : q ∈ Ioc 0 p) (hf : AEStronglyMeasurable f μ) (ht : 0 < t) : +@@ -701,7 +724,7 @@ lemma estimate_eLpNorm_truncCompl {p q : ℝ≥0∞} + (t ^ (q.toReal - p.toReal)) * eLpNorm f p μ ^ p.toReal := by + have q_ne_top: q ≠ ⊤ := ne_top_of_le_ne_top p_ne_top hpq.2 + have p_ne_zero : p ≠ 0 := (hpq.1.trans_le hpq.2).ne' +- apply le_trans (eLpNorm_truncCompl_le hpq.1.ne' (ne_top_of_le_ne_top p_ne_top hpq.2)) ++ apply le_trans (eLpNorm_truncCompl_le hpq.1.ne' (ne_top_of_le_ne_top p_ne_top hpq.2) hf) + calc + _ ≤ (t ^ (q.toReal - p.toReal)) * ∫⁻ x : α in {x | t < ‖f x‖ₑ}, + ‖f x‖ₑ ^ p.toReal ∂μ := by +@@ -709,7 +732,8 @@ lemma estimate_eLpNorm_truncCompl {p q : ℝ≥0∞} + · apply setLIntegral_mono_ae (AEMeasurable.restrict (by fun_prop)) + filter_upwards with x hx + rw [mul_comm] +- exact rpow_le_rpow_of_exponent_le_base_ge_enorm ht hx.ne_top hx.le (toReal_mono p_ne_top hpq.2) ++ exact rpow_le_rpow_of_exponent_le_base_ge_enorm ht hx.ne_top hx.le ++ (toReal_mono p_ne_top hpq.2) + · by_cases ht' : t = ⊤ + · simp_all + · finiteness +@@ -718,7 +742,8 @@ lemma estimate_eLpNorm_truncCompl {p q : ℝ≥0∞} + exact Measure.restrict_le_self + _ = _ := by + congr +- rw [eLpNorm_eq_lintegral_rpow_enorm_toReal p_ne_zero p_ne_top, one_div, ENNReal.rpow_inv_rpow] ++ rw [eLpNorm_eq_lintegral_rpow_enorm_toReal p_ne_zero p_ne_top hf, one_div, ++ ENNReal.rpow_inv_rpow] + exact (toReal_pos p_ne_zero p_ne_top).ne' + + -- TODO: better name! +@@ -731,17 +756,15 @@ lemma estimate_eLpNorm_trunc {p q : ℝ≥0∞} + by_cases ht : t = ⊤ + · by_cases hf' : eLpNorm f p μ ^ p.toReal = 0 + · have : f =ᵐ[μ] 0 := by +- rw [← eLpNorm_eq_zero_iff hf] ++ rw [← eLpNorm_eq_zero_iff hpq.1.ne'] + · rwa [← ENNReal.rpow_eq_zero_iff_of_pos (toReal_pos hpq.1.ne' p_ne_top)] +- exact hpq.1.ne' + -- Thus, the left hand side vanishes and conclusion is trivially true. +- refine le_of_eq_of_le ?_ (zero_le _) ++ refine le_of_eq_of_le ?_ zero_le + rw [rpow_eq_zero_iff_of_pos] +- · rw [eLpNorm_eq_zero_iff _ hq'.ne'] ++ · rw [eLpNorm_eq_zero_iff hq'.ne'] + · -- TODO: missing API lemma + rw [trunc_eq_indicator] + exact Filter.EventuallyEq.indicator_zero this +- · fun_prop + · rw [toReal_pos_iff] + exact ⟨hq', hq.lt_top⟩ + · -- The right hand side is `∞`, hence the statement is always true. +@@ -752,19 +775,17 @@ lemma estimate_eLpNorm_trunc {p q : ℝ≥0∞} + · apply le_top + rw [sub_pos, toReal_lt_toReal p_ne_top hq] + exact lt_of_le_of_ne hpq.2 p_eq_q +- unfold eLpNorm eLpNorm' +- have : p ≠ 0 := hpq.1.ne' +- split_ifs with h +- · exfalso +- exact hq'.ne' h +- · calc ++ rw [eLpNorm_eq_eLpNorm' hq'.ne' hq hf.trunc, ++ eLpNorm_eq_eLpNorm' hpq.1.ne' p_ne_top hf] ++ unfold eLpNorm' ++ calc + _ = ∫⁻ (x : α) in {x | 0 < ‖f x‖ₑ ∧ ‖f x‖ₑ ≤ t}, ‖trunc f t x‖ₑ ^ q.toReal ∂μ := by + rw [one_div, ENNReal.rpow_inv_rpow] + · apply Eq.symm + apply setLIntegral_eq_of_support_subset + unfold Function.support + intro x +- dsimp only [Pi.sub_apply, mem_setOf_eq] ++ change ‖trunc f t x‖ₑ ^ q.toReal ≠ 0 → 0 < ‖f x‖ₑ ∧ ‖f x‖ₑ ≤ t + unfold trunc + split_ifs with is_fx_le_a + · intro fx_rpow_ne_zero +@@ -783,7 +804,8 @@ lemma estimate_eLpNorm_trunc {p q : ℝ≥0∞} + · apply setLIntegral_mono_ae (AEMeasurable.restrict (by fun_prop)) + · filter_upwards with x hx + rw [mul_comm] +- exact rpow_le_rpow_of_exponent_le_base_le_enorm hx.1 (ne_top_of_le_ne_top ht hx.2) hx.2 <| toReal_mono hq hpq.2 ++ exact rpow_le_rpow_of_exponent_le_base_le_enorm hx.1 ++ (ne_top_of_le_ne_top ht hx.2) hx.2 <| toReal_mono hq hpq.2 + · simp_all + _ ≤ _ := by + gcongr +@@ -795,16 +817,16 @@ lemma estimate_eLpNorm_trunc {p q : ℝ≥0∞} + /-- If `f` is in `Lp`, the truncation is element of `Lq` for `q ≥ p`. -/ + lemma trunc_Lp_Lq_higher (hpq : p ∈ Ioc 0 q) {f : α → ε'} (hf : MemLp f p μ) (ht : t ≠ ∞) : + MemLp (trnc ⊤ f t) q μ := by +- refine ⟨aestronglyMeasurable_trnc hf.1, ?_⟩ ++ change eLpNorm (trnc ⊤ f t) q μ < ∞ + rcases (eq_or_ne q ⊤) with q_eq_top | q_ne_top +- · rw [q_eq_top, eLpNorm_exponent_top] ++ · rw [q_eq_top, eLpNorm_exponent_top (aestronglyMeasurable_trnc hf.aestronglyMeasurable)] + simp only [trnc] + calc _ + _ ≤ max 0 t := trunc_eLpNormEssSup_le t + _ < ∞ := by finiteness + · have p_ne_top := ne_top_of_le_ne_top q_ne_top hpq.2 + rw [← rpow_lt_top_iff_of_pos (toReal_pos (hpq.1.trans_le hpq.2).ne' q_ne_top)] +- apply lt_of_le_of_lt (estimate_eLpNorm_trunc q_ne_top hpq hf.1) ++ apply lt_of_le_of_lt (estimate_eLpNorm_trunc q_ne_top hpq hf.aestronglyMeasurable) + apply mul_lt_top ?_ ?_ + · by_cases ht'' : t = 0 + · rw [ht''] +@@ -813,7 +835,7 @@ lemma trunc_Lp_Lq_higher (hpq : p ∈ Ioc 0 q) {f : α → ε'} (hf : MemLp f p + rw [toReal_le_toReal p_ne_top q_ne_top] + exact hpq.2 + · finiteness +- · exact (rpow_lt_top_iff_of_pos (toReal_pos hpq.1.ne' p_ne_top)).mpr hf.2 ++ · exact (rpow_lt_top_iff_of_pos (toReal_pos hpq.1.ne' p_ne_top)).mpr hf + + lemma memLp_truncCompl_of_memLp_top (hf : MemLp f ⊤ μ) (h : μ {x | t < ‖f x‖ₑ} < ⊤) : + MemLp (trnc ⊥ f t) p μ := by +@@ -821,7 +843,7 @@ lemma memLp_truncCompl_of_memLp_top (hf : MemLp f ⊤ μ) (h : μ {x | t < ‖f + · rw [hp_top] + simp only [bot_eq_false, trnc_false] + exact hf.truncCompl +- obtain ⟨hf_m, hf_lt_top⟩ := hf ++ have hf_m := hf.aestronglyMeasurable + by_cases hp0 : p = 0 + · rw [hp0, memLp_zero_iff_aestronglyMeasurable] + exact aestronglyMeasurable_trnc hf_m +@@ -843,34 +865,33 @@ lemma memLp_truncCompl_of_memLp_top (hf : MemLp f ⊤ μ) (h : μ {x | t < ‖f + split_ifs with hx hx' hx'' + · exact hfgs hs + · exfalso +- simp only [mem_compl_iff, mem_setOf_eq, not_le, not_lt, hfgs hs] at hx hx' ++ simp only [mem_compl_iff, mem_ofPred_eq, not_le, not_lt, hfgs hs] at hx hx' + order + · exfalso +- simp only [mem_compl_iff, mem_setOf_eq, not_le, not_lt, hfgs hs] at hx hx'' ++ simp only [mem_compl_iff, mem_ofPred_eq, not_le, not_lt, hfgs hs] at hx hx'' + order + · rfl + apply MemLp.ae_eq ae_eq_trunc.symm +- use aestronglyMeasurable_trnc wg1.aestronglyMeasurable ++ change eLpNorm (trnc ⊥ g t) p μ < ∞ + simp only [bot_eq_false, trnc_false] + rw [truncCompl_eq_indicator, + eLpNorm_indicator_eq_eLpNorm_restrict +- (by rw [compl_setOf]; simp only [not_le]; exact measurableSet_lt measurable_const (by fun_prop))] +- rw [eLpNorm_eq_eLpNorm' hp0 hp_top] ++ (by rw [compl_ofPred]; simp only [not_le] ++ exact measurableSet_lt measurable_const (by fun_prop))] ++ rw [eLpNorm_eq_eLpNorm' hp0 hp_top wg1.aestronglyMeasurable.restrict] + apply (eLpNorm'_le_eLpNormEssSup_mul_rpow_measure_univ hp_pos).trans_lt + apply ENNReal.mul_lt_top +- · rw [← eLpNorm_exponent_top] ++ · rw [← eLpNorm_exponent_top wg1.aestronglyMeasurable.restrict] + apply (eLpNorm_restrict_le _ _ _ _).trans_lt + rwa [eLpNorm_congr_ae wg2.symm] + apply ENNReal.rpow_lt_top_of_nonneg (by simp [hp_pos.le]) + simp only [MeasurableSet.univ, Measure.restrict_apply, univ_inter] +- rw [← lt_top_iff_ne_top, compl_setOf] ++ rw [← lt_top_iff_ne_top, compl_ofPred] + calc + _ = μ {a | t < ‖f a‖ₑ} := by + apply measure_congr +- rw [Filter.eventuallyEq_iff_exists_mem] at wg2 +- rcases wg2 with ⟨s, hs, hfgs⟩ +- rw [Filter.eventuallyEq_iff_exists_mem] +- exact ⟨s, hs, fun a ha ↦ by simp [setOf, hfgs.symm ha]⟩ ++ filter_upwards [wg2] with a ha ++ simp only [not_le, ha] + _ < ∞ := h + + -- is there a better name? +@@ -881,14 +902,14 @@ lemma truncCompl_Lp_Lq_lower + have q_ne_top : q ≠ ∞ := ne_top_of_le_ne_top hp hpq.2 + by_cases ht' : t = ∞ + · simp [trnc, ht'] +- refine ⟨aestronglyMeasurable_trnc hf.1, ?_⟩ ++ change eLpNorm (trnc ⊥ f t) q μ < ∞ + have : 0 < q.toReal := toReal_pos hpq.left.ne' q_ne_top + refine (rpow_lt_top_iff_of_pos this).mp ?_ +- refine lt_of_le_of_lt (estimate_eLpNorm_truncCompl hp hpq hf.1 ht) ?_ ++ refine lt_of_le_of_lt (estimate_eLpNorm_truncCompl hp hpq hf.aestronglyMeasurable ht) ?_ + apply mul_lt_top + · push Not at ht' + finiteness +- refine (rpow_lt_top_iff_of_pos ?_).mpr hf.2 ++ refine (rpow_lt_top_iff_of_pos ?_).mpr hf + exact toReal_pos (hpq.1.trans_le hpq.2).ne' hp + + -- Lemma 6.10 in Folland +@@ -906,7 +927,8 @@ lemma memLp_of_memLp_le_of_memLp_ge {f : α → ε'} [ContinuousAdd ε'] + have h : MemLp (trnc ⊤ f C) q μ := trunc_Lp_Lq_higher ⟨hp, hr'.1⟩ hf (by norm_num) + have h' : MemLp (trnc ⊥ f C) q μ := by + by_cases hr : r = ⊤ +- · exact memLp_truncCompl_of_memLp_top (hr ▸ hf') <| distribution_lt_top hf hp p_ne_top (by norm_num) ++ · exact memLp_truncCompl_of_memLp_top (hr ▸ hf') <| ++ distribution_lt_top hf hp p_ne_top (by norm_num) + exact truncCompl_Lp_Lq_lower hr ⟨hp.trans_le hr'.1, hr'.2⟩ (by norm_num) hf' + have : f = (trnc ⊤ f C) + (trnc ⊥ f C) := trunc_add_truncCompl.symm + rw [this] +@@ -950,7 +972,7 @@ lemma res_subset_Ioi {j : Bool} {β : ℝ≥0∞} : res j β ⊆ Ioi 0 := by + · simp + · simp only [Ioi] + intro s hs +- rw [mem_setOf] ++ rw [mem_ofPred] + exact hs.1 + · exact Ioi_subset_Ioi toReal_nonneg + +@@ -968,7 +990,7 @@ lemma res'comp₀ (j : Bool) (β : ℝ≥0∞) (hβ : 0 < β) : + split_ifs with h₀ h₁ h₂ + on_goal 6 => + ext x +- simp only [mem_diff, mem_Ioi, mem_Ioc, not_and, not_le] ++ simp only [Set.mem_sdiff, mem_Ioi, mem_Ioc, not_and, not_le] + exact ⟨by tauto, fun h ↦ ⟨(toReal_pos (hβ.ne') h₀).trans h, fun x ↦ h⟩⟩ + all_goals simp_all + +@@ -978,7 +1000,7 @@ lemma res'comp (j : Bool) (β : ℝ≥0∞) : + split_ifs with h₀ h₁ h₂ + on_goal 6 => + ext x +- simp only [mem_diff, mem_Ioi, mem_Ioc, not_and, not_le] ++ simp only [Set.mem_sdiff, mem_Ioi, mem_Ioc, not_and, not_le] + refine ⟨by tauto, fun hβ ↦ ?_⟩ + have : 0 ≤ β.toReal := toReal_nonneg + exact ⟨by order, fun _ ↦ hβ⟩ +@@ -1056,8 +1078,10 @@ lemma lintegral_trunc_mul₀ {g : ℝ → ℝ≥0∞} {j : Bool} {x : α} {tc : + · simp [hp] + + lemma lintegral_trunc_mul₁ {g : ℝ → ℝ≥0∞} {j : Bool} {x : α} {p : ℝ} {tc : ToneCouple} : +- ∫⁻ s : ℝ in res' (xor j tc.mon) (tc.inv ‖f x‖ₑ), (g s) * ‖trnc j f (tc.ton (ENNReal.ofReal s)) x‖ₑ ^ p = +- ∫⁻ s : ℝ in res (xor j tc.mon) (tc.inv ‖f x‖ₑ), (g s) * ‖trnc j f (tc.ton (ENNReal.ofReal s)) x‖ₑ ^ p := by ++ ∫⁻ s : ℝ in res' (xor j tc.mon) (tc.inv ‖f x‖ₑ), ++ (g s) * ‖trnc j f (tc.ton (ENNReal.ofReal s)) x‖ₑ ^ p = ++ ∫⁻ s : ℝ in res (xor j tc.mon) (tc.inv ‖f x‖ₑ), ++ (g s) * ‖trnc j f (tc.ton (ENNReal.ofReal s)) x‖ₑ ^ p := by + apply setLIntegral_congr + unfold res res' + split_ifs +@@ -1071,7 +1095,8 @@ lemma lintegral_trunc_mul₁ {g : ℝ → ℝ≥0∞} {j : Bool} {x : α} {p : + exact Ne.symm (ne_of_apply_ne ENNReal.toReal fun a ↦ h (id (Eq.symm a))) + + lemma lintegral_trunc_mul₂ {g : ℝ → ℝ≥0∞} {j : Bool} {x : α} {p : ℝ} {tc : ToneCouple} : +- ∫⁻ s : ℝ in res (xor j tc.mon) (tc.inv ‖f x‖ₑ), (g s) * ‖trnc j f (tc.ton (ENNReal.ofReal s)) x‖ₑ ^ p = ++ ∫⁻ s : ℝ in res (xor j tc.mon) (tc.inv ‖f x‖ₑ), ++ (g s) * ‖trnc j f (tc.ton (ENNReal.ofReal s)) x‖ₑ ^ p = + ∫⁻ s : ℝ in res (xor j tc.mon) (tc.inv ‖f x‖ₑ), (g s) * ‖f x‖ₑ ^ p := by + apply setLIntegral_congr_fun measurableSet_res + unfold res trnc trunc truncCompl +@@ -1114,7 +1139,8 @@ lemma lintegral_trunc_mul₂ {g : ℝ → ℝ≥0∞} {j : Bool} {x : α} {p : + · have := (mon_pf (.ofReal s) ‖f x‖ₑ).2.mpr <| (ofReal_lt_iff_lt_toReal hs.1.le h).mpr hs.2 + order + +-lemma lintegral_trunc_mul {g : ℝ → ℝ≥0∞} (hg : AEMeasurable g) {j : Bool} {x : α} {tc : ToneCouple} {p : ℝ} ++lemma lintegral_trunc_mul {g : ℝ → ℝ≥0∞} (hg : AEMeasurable g) ++ {j : Bool} {x : α} {tc : ToneCouple} {p : ℝ} + (hp : 0 < p) : + ∫⁻ s : ℝ in Ioi 0, (g s) * ‖trnc j f (tc.ton (ENNReal.ofReal s)) x‖ₑ ^ p = + (∫⁻ s : ℝ in res (xor j tc.mon) (tc.inv ‖f x‖ₑ), (g s)) * ‖f x‖ₑ ^ p := by +@@ -1172,7 +1198,7 @@ lemma value_lintegral_res₀ {j : Bool} {β : ℝ≥0∞} {γ : ℝ} (hγ : if j + rw [lintegral_rpow_of_gt_abs htcinv.le hγ, ENNReal.ofReal_div_of_pos + (by rw [abs_pos]; linarith), ← ENNReal.ofReal_rpow_of_pos htcinv, + ofReal_toReal_eq_iff.mpr htop] +- · simp only [eq_false_of_ne_true xor_split, Bool.false_eq_true, ↓reduceIte] ++ · simp only [Bool.eq_false_of_ne_true xor_split, Bool.false_eq_true, ↓reduceIte] + split_ifs with htop + · rw [htop, top_rpow_of_neg (by linarith)]; simp + · by_cases hzero : β = 0 +@@ -1209,9 +1235,11 @@ lemma value_lintegral_res₂ {γ p' : ℝ} {spf : ScaledPowerFunction} (ht : 0 < + top_div_of_lt_top ofReal_lt_top] + + -- TODO: move to a lower-level file! +-lemma AEStronglyMeasurable.induction {α : Type*} {β : Type*} {mα : MeasurableSpace α} [TopologicalSpace β] ++lemma AEStronglyMeasurable.induction {α : Type*} {β : Type*} ++ {mα : MeasurableSpace α} [TopologicalSpace β] + {μ : Measure α} {motive : (α → β) → Prop} +- (ae_eq_implies : ∀ ⦃f g : α → β⦄ (_ : StronglyMeasurable f) (_ : f =ᶠ[ae μ] g), motive f → motive g) ++ (ae_eq_implies : ∀ ⦃f g : α → β⦄ (_ : StronglyMeasurable f) (_ : f =ᶠ[ae μ] g), ++ motive f → motive g) + (measurable : ∀ ⦃f : α → β⦄ (_ : StronglyMeasurable f), motive f) + ⦃f : α → β⦄ (hf : AEStronglyMeasurable f μ) : motive f := by + have hg := hf.choose_spec +diff --git a/Carleson/ToMathlib/WeakType.lean b/Carleson/ToMathlib/WeakType.lean +index 2e6b4bc..29f925a 100644 +--- a/Carleson/ToMathlib/WeakType.lean ++++ b/Carleson/ToMathlib/WeakType.lean +@@ -4,6 +4,8 @@ import Carleson.ToMathlib.Order.ConditionallyCompleteLattice.Basic + import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals + import Mathlib.Analysis.SpecialFunctions.Pow.Integral + ++/-! # Distribution functions and weak-type operator estimates -/ ++ + -- Upstreaming status: all of this should go into mathlib, eventually. + -- Most lemmas have the right form, but proofs can often be golfed. + -- Some enorm lemmas require some mathlib refactoring first, so they can be unified with their +@@ -45,11 +47,11 @@ lemma distribution_mono_right (h : t ≤ s) : distribution f s μ ≤ distributi + lemma distribution_mono_right' : Antitone (fun t ↦ distribution f t μ) := + fun _ _ h ↦ distribution_mono_right h + +-@[measurability, fun_prop] ++@[fun_prop] + lemma distribution_measurable₀ : Measurable (fun t ↦ distribution f t μ) := + Antitone.measurable (distribution_mono_right' (f := f) (μ := μ)) + +-@[measurability, fun_prop] ++@[fun_prop] + lemma distribution_measurable {g : α' → ℝ≥0∞} (hg : Measurable g) : + Measurable (fun y : α' ↦ distribution f (g y) μ) := by + fun_prop +@@ -147,14 +149,15 @@ lemma continuousWithinAt_distribution (t₀ : ℝ≥0∞) : + rw [db_zero] at h₂ + change Icc 0 ε (distribution f z μ) + rw [nonpos_iff_eq_zero.mp h₂] +- exact ⟨zero_le 0, zero_le ε⟩ ++ exact ⟨zero_le, zero_le⟩ + -- Case: 0 < distribution f t₀ μ + · obtain ⟨n, wn⟩ := + select_neighborhood_distribution t₀ _ + (ENNReal.sub_lt_self db_not_top.ne_top db_not_zero.ne' ε_gt_0.ne') + use Iio (t₀ + (↑n)⁻¹) + constructor +- · exact Iio_mem_nhds (lt_add_right t₀nottop.ne_top (ENNReal.inv_ne_zero.mpr (by finiteness))) ++ · exact Iio_mem_nhds ++ (lt_add_right t₀nottop.ne_top (ENNReal.inv_ne_zero.mpr (by finiteness))) + · refine ⟨Ioi t₀, by simp, fun z h ↦ ⟨?_, ?_⟩⟩ + · calc + distribution f t₀ μ - ε +@@ -172,27 +175,27 @@ lemma distribution_pow (ε : Type*) [SeminormedRing ε] [NormOneClass ε] [NormM + distribution (f ^ n) (t ^ n) μ = distribution f t μ := by + simp_rw [distribution, Pi.pow_apply] + refine congrArg μ <| ext fun x ↦ ⟨fun hx ↦ ?_, fun hx ↦ ?_⟩ +- · rw [mem_setOf_eq, enorm_pow (f x) n] at hx; simpa using lt_of_pow_lt_pow_left' n hx +- · rw [mem_setOf_eq, enorm_pow (f x) n]; exact ENNReal.pow_right_strictMono hn hx ++ · rw [mem_ofPred_eq, enorm_pow (f x) n] at hx; simpa using lt_of_pow_lt_pow_left' n hx ++ · rw [mem_ofPred_eq, enorm_pow (f x) n]; exact ENNReal.pow_right_strictMono hn hx + + + section distribution + + variable {ε' : Type*} [ENorm ε'] {f : α → ε} {g : α → ε'} + +-@[gcongr] ++@[gcongr only] + lemma distribution_mono_left (h : ∀ᵐ x ∂μ, ‖f x‖ₑ ≤ ‖g x‖ₑ) : + distribution f t μ ≤ distribution g t μ := by + have h₀ : {x | t < ‖f x‖ₑ} \ {x | t < ‖g x‖ₑ} ⊆ {x | ¬‖f x‖ₑ ≤ ‖g x‖ₑ} := fun x ↦ by +- simp_rw [mem_diff, mem_setOf_eq, not_lt, not_le, and_imp] ++ simp_rw [Set.mem_sdiff, mem_ofPred_eq, not_lt, not_le, and_imp] + intro i₁ i₂; simpa using i₂.trans_lt i₁ + calc + _ ≤ μ ({x | t < ‖f x‖ₑ} ∩ {x | t < ‖g x‖ₑ}) +- + μ ({x | t < ‖f x‖ₑ} \ {x | t < ‖g x‖ₑ}) := measure_le_inter_add_diff μ _ _ ++ + μ ({x | t < ‖f x‖ₑ} \ {x | t < ‖g x‖ₑ}) := measure_le_inter_add_sdiff μ _ _ + _ = μ ({x | t < ‖f x‖ₑ} ∩ {x | t < ‖g x‖ₑ}) := by rw [measure_mono_null h₀ h, add_zero] + _ ≤ _ := by apply measure_mono; simp + +-@[gcongr] ++@[gcongr only] + lemma distribution_mono (h₁ : ∀ᵐ x ∂μ, ‖f x‖ₑ ≤ ‖g x‖ₑ) (h₂ : t ≤ s) : + distribution f s μ ≤ distribution g t μ := + (distribution_mono_left h₁).trans (distribution_mono_right h₂) +@@ -211,7 +214,7 @@ lemma distribution_add_le {ε} [TopologicalSpace ε] [ESeminormedAddMonoid ε] { + calc + _ ≤ μ ({x | t < ‖f x‖ₑ} ∪ {x | s < ‖g x‖ₑ}) := by + refine measure_mono fun x h ↦ ?_ +- simp only [mem_union, mem_setOf_eq, Pi.add_apply] at h ⊢ ++ simp only [mem_union, mem_ofPred_eq, Pi.add_apply] at h ⊢ + contrapose! h + exact (enorm_add_le _ _).trans (add_le_add h.1 h.2) + _ ≤ _ := measure_union_le _ _ +@@ -225,7 +228,7 @@ lemma distribution_zero_enorm {f : α → ε} (h : enorm ∘ f =ᵐ[μ] 0) : + _ ≤ μ {x | 0 < ‖f x‖ₑ} := by + apply measure_mono + intro x hx +- simp only [Set.mem_setOf_eq] at hx ++ simp only [Set.mem_ofPred_eq] at hx + exact pos_of_gt hx + _ = μ {x | ‖f x‖ₑ ≠ 0} := by + congr +@@ -234,14 +237,17 @@ lemma distribution_zero_enorm {f : α → ε} (h : enorm ∘ f =ᵐ[μ] 0) : + _ = 0 := by + exact ae_iff.mp h + +-lemma distribution_zero {ε} [TopologicalSpace ε] [ESeminormedAddMonoid ε] {f : α → ε} (h : f =ᵐ[μ] 0) : ++lemma distribution_zero {ε} [TopologicalSpace ε] [ESeminormedAddMonoid ε] {f : α → ε} ++ (h : f =ᵐ[μ] 0) : + distribution f t μ = 0 := by + apply distribution_zero_enorm + simp only [EventuallyEq, comp_apply, Pi.ofNat_apply] + filter_upwards [h] with x hx using (by simp [hx]) + +-lemma distribution_indicator_const {ε} [TopologicalSpace ε] [ESeminormedAddMonoid ε] {s : Set α} {a : ε} : +- distribution (s.indicator (Function.const α a)) t μ = (Set.Iio ‖a‖ₑ).indicator (fun _ ↦ μ s) t := by ++lemma distribution_indicator_const {ε} [TopologicalSpace ε] [ESeminormedAddMonoid ε] ++ {s : Set α} {a : ε} : ++ distribution (s.indicator (Function.const α a)) t μ = ++ (Set.Iio ‖a‖ₑ).indicator (fun _ ↦ μ s) t := by + unfold distribution indicator + split_ifs with h + · simp only [const_apply] +@@ -257,12 +263,12 @@ lemma distribution_indicator_const {ε} [TopologicalSpace ε] [ESeminormedAddMon + exfalso + exact ENNReal.not_lt_zero h'' + · intro hx +- rwa [ite_cond_eq_true] ++ rwa [ite_eq_left_of_eq_true] + simpa only [eq_iff_iff, iff_true] + · convert measure_empty (μ := μ) + apply eq_empty_of_subset_empty + intro x +- simp only [const_apply, mem_setOf_eq, mem_empty_iff_false, imp_false, not_lt] ++ simp only [const_apply, mem_ofPred_eq, mem_empty_iff_false, imp_false, not_lt] + split_ifs + · simp only [mem_Iio, not_lt] at h + exact h +@@ -272,12 +278,10 @@ lemma distribution_eq_zero_iff {ε} [TopologicalSpace ε] [ESeminormedAddMonoid + distribution f t μ = 0 ↔ eLpNormEssSup f μ ≤ t := by + rw [distribution, eLpNormEssSup] + rw [← compl_compl {x | t < ‖f x‖ₑ}, ← mem_ae_iff, compl_def] +- simp only [mem_setOf_eq, not_lt] ++ simp only [mem_ofPred_eq, not_lt] + constructor + · intro h +- apply essSup_le_of_ae_le +- filter_upwards [h] +- simp ++ exact essSup_le_of_ae_le t h + · rw [essSup] + intro h + rw [← Filter.Eventually] +@@ -301,7 +305,7 @@ lemma distribution_add {ε} [TopologicalSpace ε] [ESeminormedAddMonoid ε] {f g + rw [← measure_union₀] + · congr 1 + ext x +- simp only [Pi.add_apply, mem_setOf_eq, mem_union] ++ simp only [Pi.add_apply, mem_ofPred_eq, mem_union] + rcases (@or_not (x ∈ support f)) with hxf | hxf + · have := disjoint_left.mp h hxf + simp only [mem_support, ne_eq, not_not] at this +@@ -314,14 +318,14 @@ lemma distribution_add {ε} [TopologicalSpace ε] [ESeminormedAddMonoid ε] {f g + · apply Disjoint.aedisjoint + apply disjoint_of_subset _ _ h + · intro x +- simp only [mem_setOf_eq, mem_support, ne_eq] ++ simp only [mem_ofPred_eq, mem_support, ne_eq] + intro h' + have := LT.lt.ne_bot h' + rw [ENNReal.bot_eq_zero] at this + contrapose! this + rw [this, enorm_zero] + · intro x +- simp only [mem_setOf_eq, mem_support, ne_eq] ++ simp only [mem_ofPred_eq, mem_support, ne_eq] + intro h' + have := LT.lt.ne_bot h' + rw [ENNReal.bot_eq_zero] at this +@@ -342,11 +346,12 @@ lemma distribution_indicator_add_of_support_subset {ε} [TopologicalSpace ε] [E + (enorm_add : ∀ a b : ε, ‖a + b‖ₑ = ‖a‖ₑ + ‖b‖ₑ) --TODO: new type class for this property? + {f : α → ε} {c : ε} (hc : ‖c‖ₑ ≠ ⊤) {s : Set α} + (hfs : Function.support f ⊆ s) : +- distribution (f + s.indicator (Function.const α c)) t μ = if t < ‖c‖ₑ then μ s else distribution f (t - ‖c‖ₑ) μ := by ++ distribution (f + s.indicator (Function.const α c)) t μ = ++ if t < ‖c‖ₑ then μ s else distribution f (t - ‖c‖ₑ) μ := by + unfold distribution + split_ifs with ht + · congr 1 with x +- simp only [Pi.add_apply, mem_setOf_eq] ++ simp only [Pi.add_apply, mem_ofPred_eq] + constructor + · intro h + contrapose! h +@@ -357,11 +362,11 @@ lemma distribution_indicator_add_of_support_subset {ε} [TopologicalSpace ε] [E + unfold indicator + rw [enorm_add, add_comm] + split_ifs +- apply lt_add_of_lt_of_nonneg _ (zero_le _) ++ apply lt_add_of_lt_of_nonneg _ (zero_le) + simpa [h] + · push Not at ht + congr 1 with x +- simp only [Pi.add_apply, mem_setOf_eq] ++ simp only [Pi.add_apply, mem_ofPred_eq] + rw [enorm_add, ENNReal.sub_lt_iff_lt_right hc ht] + constructor + · intro h +@@ -411,9 +416,9 @@ lemma wnorm'_zero (f : α → ε) (μ : Measure α) : wnorm' f 0 μ = ∞ := by + + lemma wnorm'_toReal_le {f : α → ℝ≥0∞} {p : ℝ} (hp : 0 ≤ p) : + wnorm' (ENNReal.toReal ∘ f) p μ ≤ wnorm' f p μ := by +- refine iSup_mono fun x ↦ ?_ +- gcongr +- simp ++ refine iSup_mono fun threshold ↦ ?_ ++ exact mul_le_mul_right ++ (ENNReal.rpow_le_rpow distribution_toReal_le (inv_nonneg.mpr hp)) _ + + lemma wnorm'_toReal_eq {f : α → ℝ≥0∞} {p : ℝ} (hf : ∀ᵐ x ∂μ, f x ≠ ∞) : + wnorm' (ENNReal.toReal ∘ f) p μ = wnorm' f p μ := by +@@ -455,8 +460,8 @@ lemma wnorm'_mono_enorm_ae {ε' : Type*} [ENorm ε'] {f : α → ε} {g : α → + intro t + calc _ + _ ≤ ↑t * distribution g (↑t) μ ^ p⁻¹ := by +- gcongr +- assumption ++ exact mul_le_mul_right ++ (ENNReal.rpow_le_rpow (distribution_mono_left h) (inv_nonneg.mpr hp)) _ + apply le_iSup _ t + + lemma wnorm_mono_enorm_ae {ε' : Type*} [ENorm ε'] {f : α → ε} {g : α → ε'} +@@ -511,14 +516,14 @@ theorem wnorm_indicator_const {ε} [TopologicalSpace ε] [ESeminormedAddMonoid + intro b hb + use ‖a‖ₑ.toNNReal / 2 + simp only [ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, coe_div, coe_ofNat] +- rwa [ENNReal.coe_toNNReal ha', indicator, ite_cond_eq_true, ENNReal.top_rpow_of_pos hp, ENNReal.mul_top] ++ rwa [ENNReal.coe_toNNReal ha', indicator, ite_eq_left_of_eq_true, ++ ENNReal.top_rpow_of_pos hp, ENNReal.mul_top] + · simpa + · simp only [mem_Iio, eq_iff_iff, iff_true] + apply ENNReal.div_lt_of_lt_mul' + nth_rw 1 [← one_mul ‖a‖ₑ] + gcongr +- · exact ha' +- · norm_num ++ norm_num + apply le_of_forall_lt_imp_le_of_dense + intro c hc + apply le_iSup_of_le (c / (μ s ^ p.toReal⁻¹)).toNNReal +@@ -530,7 +535,7 @@ theorem wnorm_indicator_const {ε} [TopologicalSpace ε] [ESeminormedAddMonoid + contradiction + · rw [hc.1] + exact le_top +- rw [indicator_apply, ite_cond_eq_true, ENNReal.coe_toNNReal hc', ENNReal.div_mul_cancel] ++ rw [indicator_apply, ite_eq_left_of_eq_true, ENNReal.coe_toNNReal hc', ENNReal.div_mul_cancel] + · simp only [ne_eq, ENNReal.rpow_eq_zero_iff, inv_pos, inv_neg'', not_or, not_and, not_lt, + toReal_nonneg, implies_true, and_true] + intro h +@@ -551,7 +556,8 @@ def MemWLp [TopologicalSpace ε] (f : α → ε) (p : ℝ≥0∞) (μ : Measure + lemma MemWLp_zero [TopologicalSpace ε] : ¬ MemWLp f 0 μ := by + simp [MemWLp, wnorm_zero] + +-lemma MemWLp.aeStronglyMeasurable [TopologicalSpace ε] (hf : MemWLp f p μ) : AEStronglyMeasurable f μ := hf.1 ++lemma MemWLp.aeStronglyMeasurable [TopologicalSpace ε] (hf : MemWLp f p μ) : ++ AEStronglyMeasurable f μ := hf.1 + + lemma MemWLp.wnorm_lt_top [TopologicalSpace ε] (hf : MemWLp f p μ) : wnorm f p μ < ⊤ := hf.2 + +@@ -572,18 +578,18 @@ theorem MemWLp.ae_ne_top [TopologicalSpace ε] (hf : MemWLp f p μ) : ∀ᵐ x + set A := {x | ‖f x‖ₑ = ∞} with hA + simp only [MemWLp, wnorm, wnorm', hp_inf] at hf + rw [Filter.eventually_iff, mem_ae_iff] +- simp only [ne_eq, compl_def, mem_setOf_eq, Decidable.not_not, ← hA] ++ simp only [ne_eq, compl_def, mem_ofPred_eq, Decidable.not_not, ← hA] + have hp_toReal_zero := toReal_ne_zero.mpr ⟨hp_zero, hp_inf⟩ + have h1 (t : ℝ≥0) : μ A ≤ distribution f t μ := by + refine μ.mono ?_ +- simp_all only [setOf_subset_setOf, coe_lt_top, implies_true, A] ++ simp_all only [ofPred_subset_ofPred, coe_lt_top, implies_true, A] + set C := ⨆ t : ℝ≥0, t * distribution f t μ ^ p.toReal⁻¹ + by_cases hC_zero : C = 0 + · simp only [ENNReal.iSup_eq_zero, mul_eq_zero, ENNReal.rpow_eq_zero_iff, inv_neg'', C] at hC_zero + specialize hC_zero 1 + simp only [one_ne_zero, ENNReal.coe_one, toReal_nonneg.not_gt, and_false, or_false, + false_or] at hC_zero +- exact measure_mono_null (setOf_subset_setOf.mpr fun x hx => hx ▸ one_lt_top) hC_zero.1 ++ exact measure_mono_null (ofPred_subset_ofPred.mpr fun x hx => hx ▸ one_lt_top) hC_zero.1 + by_contra h + have h2 : C < ∞ := by aesop + have h3 (t : ℝ≥0) : distribution f t μ ≤ (C / t) ^ p.toReal := by +@@ -620,10 +626,9 @@ lemma distribution_le [MeasurableSpace ε] [OpensMeasurableSpace ε] + apply (mul_le_iff_le_inv hc hc_top).mp + simp_rw [distribution, ← setLIntegral_one, ← lintegral_const_mul' _ _ hc_top, mul_one] + refine le_trans (lintegral_mono_ae ?_) (setLIntegral_le_lintegral _ _) +- simp only [Filter.Eventually, ae, mem_ofCountableUnion] +- rw [Measure.restrict_apply₀'] +- · convert measure_empty (μ := μ); ext; simpa using le_of_lt +- · exact hf.enorm.nullMeasurableSet_preimage measurableSet_Ioi ++ filter_upwards [ae_restrict_mem₀ ++ (hf.enorm.nullMeasurableSet_preimage measurableSet_Ioi)] with point hpoint ++ exact le_of_lt hpoint + + lemma wnorm'_le_eLpNorm' (hf : AEStronglyMeasurable f μ) {p : ℝ} (p0 : 0 < p) : + wnorm' f p μ ≤ eLpNorm' f p μ := by +@@ -642,9 +647,9 @@ lemma wnorm'_le_eLpNorm' (hf : AEStronglyMeasurable f μ) {p : ℝ} (p0 : 0 < p) + lemma distribution_lt_top (hf : MemLp f p μ) (p_pos : 0 < p) (p_ne_top : p ≠ ∞) + {t : ℝ≥0} (ht : 0 < t) : + distribution f t μ < ∞ := by +- have := wnorm'_le_eLpNorm' hf.1 (toReal_pos p_pos.ne' p_ne_top) +- rw [← eLpNorm_eq_eLpNorm' p_pos.ne' p_ne_top] at this +- have := this.trans_lt hf.2 ++ have := wnorm'_le_eLpNorm' hf.aestronglyMeasurable (toReal_pos p_pos.ne' p_ne_top) ++ rw [← eLpNorm_eq_eLpNorm' p_pos.ne' p_ne_top hf.aestronglyMeasurable] at this ++ have := this.trans_lt hf + rw [wnorm', iSup_lt_iff] at this + rcases this with ⟨b,b_lt_top, h⟩ + have := (h t).trans_lt b_lt_top +@@ -656,18 +661,19 @@ lemma distribution_lt_top (hf : MemLp f p μ) (p_pos : 0 < p) (p_ne_top : p ≠ + · rw [ENNReal.coe_eq_zero] at t_zero + exfalso + exact ht.ne' t_zero +- · rw [ENNReal.rpow_eq_zero_iff_of_pos (by simp only [inv_pos]; exact toReal_pos p_pos.ne' p_ne_top)] at h ++ · rw [ENNReal.rpow_eq_zero_iff_of_pos ++ (by simp only [inv_pos]; exact toReal_pos p_pos.ne' p_ne_top)] at h + rw [h] + simp only [zero_lt_top] + + lemma wnorm_le_eLpNorm (hf : AEStronglyMeasurable f μ) {p : ℝ≥0∞} (hp : 0 < p) : + wnorm f p μ ≤ eLpNorm f p μ := by + by_cases h : p = ⊤ +- · simp [h, wnorm, eLpNorm] +- · simpa [h, wnorm, eLpNorm, hp.ne'] using wnorm'_le_eLpNorm' hf (toReal_pos hp.ne' h) ++ · simp [h, wnorm, eLpNorm, hf] ++ · simpa [h, wnorm, eLpNorm, hp.ne', hf] using wnorm'_le_eLpNorm' hf (toReal_pos hp.ne' h) + + lemma MemLp.memWLp (hp : 0 < p) (hf : MemLp f p μ) : MemWLp f p μ := +- ⟨hf.1, wnorm_le_eLpNorm hf.1 hp |>.trans_lt hf.2⟩ ++ ⟨hf.aestronglyMeasurable, wnorm_le_eLpNorm hf.aestronglyMeasurable hp |>.trans_lt hf⟩ + + end ContinuousENorm + +@@ -717,7 +723,7 @@ variable [TopologicalSpace ε₁] [ContinuousENorm ε₁] [TopologicalSpace ε + + lemma HasWeakType.memWLp (h : HasWeakType T p p' μ ν c) (hf₁ : MemLp f₁ p μ) + (hc : c < ⊤ := by finiteness) : MemWLp (T f₁) p' ν := +- ⟨(h f₁ hf₁).1, h f₁ hf₁ |>.2.trans_lt <| mul_lt_top hc hf₁.2⟩ ++ ⟨(h f₁ hf₁).1, h f₁ hf₁ |>.2.trans_lt <| mul_lt_top hc hf₁⟩ + + lemma HasWeakType.toReal {T : (α → ε₁) → (α' → ℝ≥0∞)} (h : HasWeakType T p p' μ ν c) : + HasWeakType (T · · |>.toReal) p p' μ ν c := +@@ -746,7 +752,7 @@ lemma aestronglyMeasurable_ennreal_toReal_iff {f : α → ℝ≥0∞} + rw [toReal_ofReal_preimage (s := s)] + split_ifs + · exact this +- · simp_rw [preimage_diff] ++ · simp_rw [preimage_sdiff] + exact this.diff hf + · simp_rw [preimage_union] + exact this.union hf +@@ -762,7 +768,8 @@ lemma hasWeakType_toReal_iff {T : (α → ε₁) → (α' → ℝ≥0∞)} + filter_upwards [hT f hf] with x hx + simp [hx] + +--- lemma comp_left [MeasurableSpace ε₂] {ν' : Measure ε₂} {f : ε₂ → ε₃} (h : HasWeakType T p p' μ ν c) ++-- lemma comp_left [MeasurableSpace ε₂] {ν' : Measure ε₂} {f : ε₂ → ε₃} ++-- (h : HasWeakType T p p' μ ν c) + -- (hf : MemLp f p' ν') : + -- HasWeakType (f ∘ T ·) p p' μ ν c := by + -- intro u hu +@@ -780,7 +787,7 @@ variable [TopologicalSpace ε₁] [ESeminormedAddMonoid ε₁] [TopologicalSpace + lemma HasBoundedWeakType.memWLp (h : HasBoundedWeakType T p p' μ ν c) + (hf₁ : BoundedFiniteSupport f₁ μ) (hc : c < ⊤ := by finiteness) : + MemWLp (T f₁) p' ν := +- ⟨(h f₁ hf₁).1, h f₁ hf₁ |>.2.trans_lt <| mul_lt_top hc (hf₁.memLp p).2⟩ ++ ⟨(h f₁ hf₁).1, h f₁ hf₁ |>.2.trans_lt <| mul_lt_top hc (hf₁.memLp p)⟩ + + lemma HasWeakType.hasBoundedWeakType (h : HasWeakType T p p' μ ν c) : + HasBoundedWeakType T p p' μ ν c := +@@ -797,7 +804,7 @@ variable [TopologicalSpace ε₁] [ContinuousENorm ε₁] [TopologicalSpace ε + + lemma HasStrongType.memLp (h : HasStrongType T p p' μ ν c) (hf₁ : MemLp f₁ p μ) + (hc : c < ⊤ := by finiteness) : MemLp (T f₁) p' ν := +- ⟨(h f₁ hf₁).1, h f₁ hf₁ |>.2.trans_lt <| mul_lt_top hc hf₁.2⟩ ++ (h f₁ hf₁).2.trans_lt <| mul_lt_top hc hf₁ + + lemma HasStrongType.hasWeakType (hp' : 0 < p') + (h : HasStrongType T p p' μ ν c) : HasWeakType T p p' μ ν c := +@@ -830,7 +837,7 @@ variable [TopologicalSpace ε₁] [ESeminormedAddMonoid ε₁] [TopologicalSpace + lemma HasBoundedStrongType.memLp (h : HasBoundedStrongType T p p' μ ν c) + (hf₁ : BoundedFiniteSupport f₁ μ) (hc : c < ⊤ := by finiteness) : + MemLp (T f₁) p' ν := +- ⟨(h f₁ hf₁).1, h f₁ hf₁ |>.2.trans_lt <| mul_lt_top hc (hf₁.memLp _).2⟩ ++ (h f₁ hf₁).2.trans_lt <| mul_lt_top hc (hf₁.memLp _) + + lemma HasStrongType.hasBoundedStrongType (h : HasStrongType T p p' μ ν c) : + HasBoundedStrongType T p p' μ ν c := +@@ -897,7 +904,8 @@ lemma HasStrongType.const_smul [ContinuousConstSMul ℝ≥0 ε'] + + -- TODO: do we want to unify this lemma with its unprimed version, perhaps using an + -- `ENormedSemiring` class? +-variable {𝕜 E' : Type*} [NormedRing 𝕜] [NormedAddCommGroup E'] [MulActionWithZero 𝕜 E'] [IsBoundedSMul 𝕜 E'] in ++variable {𝕜 E' : Type*} [NormedRing 𝕜] [NormedAddCommGroup E'] [MulActionWithZero 𝕜 E'] ++ [IsBoundedSMul 𝕜 E'] in + lemma HasStrongType.const_smul' + {T : (α → ε) → (α' → E')} {c : ℝ≥0∞} (h : HasStrongType T p p' μ ν c) (k : 𝕜) : + HasStrongType (k • T) p p' μ ν (‖k‖ₑ * c) := by +@@ -1009,12 +1017,13 @@ section NormedGroup + variable [NormedAddCommGroup E₁] [NormedSpace 𝕜 E₁] [NormedAddCommGroup E₂] [NormedSpace 𝕜 E₂] + [NormedAddCommGroup E₃] [NormedSpace 𝕜 E₃] + +-lemma _root_.ContinuousLinearMap.distribution_le {f : α → E₁} {g : α → E₂} (L : E₁ →L[𝕜] E₂ →L[𝕜] E₃) : ++lemma _root_.ContinuousLinearMap.distribution_le {f : α → E₁} {g : α → E₂} ++ (L : E₁ →L[𝕜] E₂ →L[𝕜] E₃) : + distribution (fun x ↦ L (f x) (g x)) (‖L‖ₑ * t * s) μ ≤ + distribution f t μ + distribution g s μ := by + have h₀ : {x | ‖L‖ₑ * t * s < ‖(fun x ↦ (L (f x)) (g x)) x‖ₑ} ⊆ + {x | t < ‖f x‖ₑ} ∪ {x | s < ‖g x‖ₑ} := fun z hz ↦ by +- simp only [mem_union, mem_setOf_eq] at hz ⊢ ++ simp only [mem_union, mem_ofPred_eq] at hz ⊢ + contrapose! hz + calc + ‖(L (f z)) (g z)‖ₑ ≤ ‖L‖ₑ * ‖f z‖ₑ * ‖g z‖ₑ := by calc +@@ -1034,7 +1043,8 @@ variable [TopologicalSpace ε] [ContinuousENorm ε] + + /-- The layer-cake theorem, or Cavalieri's principle for functions into a space with a continuous + enorm. -/ +-lemma lintegral_norm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasurable f μ) {p : ℝ} (hp : 0 < p) : ++lemma lintegral_norm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasurable f μ) {p : ℝ} ++ (hp : 0 < p) : + ∫⁻ x, ‖f x‖ₑ ^ p ∂μ = + ∫⁻ t in Ioi (0 : ℝ), ENNReal.ofReal (p * t ^ (p - 1)) * distribution f (.ofReal t) μ := by + have := lintegral_rpow_eq_lintegral_meas_lt_mul μ (f := fun x ↦ ENNReal.toReal ‖f x‖ₑ) +@@ -1048,7 +1058,7 @@ lemma lintegral_norm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasura + · apply lintegral_congr_ae + rw [Filter.eventuallyEq_iff_exists_mem] + use {x | ‖f x‖ₑ ≠ ∞} +- rw [mem_ae_iff, compl_setOf] ++ rw [mem_ae_iff, compl_ofPred] + simp only [ne_eq, Decidable.not_not] + use ae_finite + intro x hx +@@ -1059,9 +1069,9 @@ lemma lintegral_norm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasura + dsimp only + congr 1 + symm +- apply measure_eq_measure_of_null_diff ++ apply measure_eq_measure_of_null_sdiff + · intro x hx +- simp only [mem_setOf_eq] at * ++ simp only [mem_ofPred_eq] at * + rwa [ofReal_lt_iff_lt_toReal ht.le] + by_contra hfx + rw [hfx] at hx +@@ -1070,10 +1080,8 @@ lemma lintegral_norm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasura + dsimp [sdiff, Set.diff] + apply measure_mono_null _ ae_finite + intro x hx +- dsimp only [mem_setOf_eq] at * + by_contra hf_top +- rw [ofReal_lt_iff_lt_toReal ht.le hf_top] at hx +- exact hx.2 hx.1 ++ exact hx.2 ((ofReal_lt_iff_lt_toReal ht.le hf_top).mp hx.1) + · rw [lintegral_eq_top_of_measure_eq_top_ne_zero] + · symm + rw [← enorm_pos] at ae_finite +@@ -1101,11 +1109,12 @@ lemma lintegral_norm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasura + exact ae_finite + + /-- The layer-cake theorem, or Cavalieri's principle, written using `eLpNorm`. -/ +-lemma eLpNorm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasurable f μ) {p : ℝ≥0} (hp : 0 < p) : ++lemma eLpNorm_pow_eq_distribution {f : α → ε} (hf : AEStronglyMeasurable f μ) {p : ℝ≥0} ++ (hp : 0 < p) : + eLpNorm f p μ ^ (p : ℝ) = + ∫⁻ t in Ioi (0 : ℝ), p * ENNReal.ofReal (t ^ ((p : ℝ) - 1)) * distribution f (.ofReal t) μ := by + have h2p : 0 < (p : ℝ) := hp +- simp_rw [eLpNorm_nnreal_eq_eLpNorm' hp.ne', eLpNorm', one_div, ← ENNReal.rpow_mul, ++ simp_rw [eLpNorm_nnreal_eq_eLpNorm' hp.ne' hf, eLpNorm', one_div, ← ENNReal.rpow_mul, + inv_mul_cancel₀ h2p.ne', ENNReal.rpow_one, lintegral_norm_pow_eq_distribution hf h2p, + ENNReal.ofReal_mul zero_le_coe, ofReal_coe_nnreal] + +@@ -1115,17 +1124,15 @@ lemma eLpNorm_eq_distribution {f : α → ε} (hf : AEStronglyMeasurable f μ) { + eLpNorm f (.ofReal p) μ = + (ENNReal.ofReal p * ∫⁻ t in Ioi (0 : ℝ), distribution f (.ofReal t) μ * + ENNReal.ofReal (t ^ (p - 1)) ) ^ p⁻¹ := by +- unfold eLpNorm +- split_ifs with sgn_p sz_p +- · exact False.elim (not_le_of_gt hp (ofReal_eq_zero.mp sgn_p)) +- · exact False.elim (coe_ne_top sz_p) +- · unfold eLpNorm' +- rw [toReal_ofReal hp.le, one_div] +- congr 1 +- rw [← lintegral_const_mul' _ _ (by finiteness), lintegral_norm_pow_eq_distribution hf hp] +- congr 1 with x; rw [ofReal_mul] <;> [ring; positivity] +- +-lemma lintegral_pow_mul_distribution {f : α → ε} (hf : AEStronglyMeasurable f μ) {p : ℝ} (hp : -1 < p) : ++ rw [eLpNorm_eq_eLpNorm' (ENNReal.ofReal_pos.mpr hp).ne' ENNReal.ofReal_ne_top hf] ++ unfold eLpNorm' ++ rw [toReal_ofReal hp.le, one_div] ++ congr 1 ++ rw [← lintegral_const_mul' _ _ (by finiteness), lintegral_norm_pow_eq_distribution hf hp] ++ congr 1 with point; rw [ofReal_mul] <;> [ring; positivity] ++ ++lemma lintegral_pow_mul_distribution {f : α → ε} (hf : AEStronglyMeasurable f μ) {p : ℝ} ++ (hp : -1 < p) : + ∫⁻ t in Ioi (0 : ℝ), ENNReal.ofReal (t ^ p) * distribution f (.ofReal t) μ = + ENNReal.ofReal (p + 1)⁻¹ * ∫⁻ x, ‖f x‖ₑ ^ (p + 1) ∂μ := by + have h2p : 0 < p + 1 := by linarith +diff --git a/Carleson/TwoSidedCarleson/Basic.lean b/Carleson/TwoSidedCarleson/Basic.lean +index 13df8e0..e1d1620 100644 +--- a/Carleson/TwoSidedCarleson/Basic.lean ++++ b/Carleson/TwoSidedCarleson/Basic.lean +@@ -1,6 +1,8 @@ + import Carleson.Calculations + import Carleson.ToMathlib.MeasureTheory.Integral.IntegrableOn + ++/-! # The two-sided Calderon–Zygmund operator -/ ++ + open MeasureTheory Set Metric Function Topology NNReal ENNReal + + variable {X : Type*} {a : ℕ} [MetricSpace X] [DoublingMeasure X (defaultA a : ℕ)] +@@ -20,7 +22,7 @@ lemma czOperator_bound {g : X → ℂ} (hg : BoundedFiniteSupport g) (hr : 0 < r + · let M1 := (C_K a / volume (ball x r)).toNNReal + let M2 := (eLpNorm g ∞).toNNReal + have : { y | ¬‖K x y * g y‖ ≤ M0} ⊆ { y | ¬‖K x y‖ ≤ M1 ∨ ¬‖g y‖ ≤ M2} := by +- rw [setOf_subset_setOf] ++ rw [ofPred_subset_ofPred] + intro y + contrapose! + intro hy +@@ -33,7 +35,8 @@ lemma czOperator_bound {g : X → ℂ} (hg : BoundedFiniteSupport g) (hr : 0 < r + rw [← toNNReal_mul] + rw [← Measure.restrict_apply₀'] + · apply measure_mono_null_ae this.eventuallyLE +- rw [setOf_or] ++ change (volume.restrict (ball x r)ᶜ) ++ ({y | ¬‖K x y‖ ≤ M1} ∪ {y | ¬‖g y‖ ≤ M2}) = 0 + apply measure_union_null + · rw [← ae_iff] + apply ae_restrict_of_forall_mem measurableSet_ball.compl +@@ -43,7 +46,8 @@ lemma czOperator_bound {g : X → ℂ} (hg : BoundedFiniteSupport g) (hr : 0 < r + · apply enorm_K_le_ball_complement hy + · exact (div_lt_top coe_ne_top ((measure_ball_pos volume x hr).ne.symm)).ne + · simp_rw [← ae_iff, M2, ← ENNReal.toReal.eq_1, ← toReal_enorm, +- (ENNReal.toReal_le_toReal enorm_lt_top.ne (hg.eLpNorm_lt_top).ne), eLpNorm_exponent_top] ++ (ENNReal.toReal_le_toReal enorm_lt_top.ne (hg.eLpNorm_lt_top).ne), ++ eLpNorm_exponent_top hg.aestronglyMeasurable] + apply ae_restrict_of_ae ae_le_eLpNormEssSup + · exact measurableSet_ball.compl.nullMeasurableSet + · exact measurableSet_ball.compl.nullMeasurableSet +@@ -101,7 +105,7 @@ lemma czOperator_welldefined {g : X → ℂ} (hg : BoundedFiniteSupport g) (hr : + rw [← inter_assoc] + refine Eq.symm (left_eq_inter.mpr ?_) + · apply inter_subset_left.trans +- apply setOf_subset.mpr ++ apply ofPred_subset.mpr + apply tmp_Kxg + rw [← Measure.restrict_apply₀' (by measurability), ← ae_iff] + exact hM +@@ -118,7 +122,8 @@ lemma czOperator_welldefined {g : X → ℂ} (hg : BoundedFiniteSupport g) (hr : + · exact support_mul_subset_right (K x) g + + -- This could be adapted to state T_r is a linear operator but maybe it's not worth the effort +-lemma czOperator_sub {f g : X → ℂ} (hf : BoundedFiniteSupport f) (hg : BoundedFiniteSupport g) (hr : 0 < r) : ++lemma czOperator_sub {f g : X → ℂ} (hf : BoundedFiniteSupport f) ++ (hg : BoundedFiniteSupport g) (hr : 0 < r) : + czOperator K r (f - g) = czOperator K r f - czOperator K r g := by + ext x + unfold czOperator +diff --git a/Carleson/TwoSidedCarleson/WeakCalderonZygmund.lean b/Carleson/TwoSidedCarleson/WeakCalderonZygmund.lean +index 50aab7b..b9ec606 100644 +--- a/Carleson/TwoSidedCarleson/WeakCalderonZygmund.lean ++++ b/Carleson/TwoSidedCarleson/WeakCalderonZygmund.lean +@@ -2,6 +2,10 @@ import Mathlib.Analysis.Normed.Group.Basic + import Carleson.ToMathlib.HardyLittlewood + import Carleson.TwoSidedCarleson.Basic + ++/-! ## Section 10.2 and Lemma 10.0.3 ++ ++Question: -/ ++ + open MeasureTheory Set Bornology Function Metric Filter Topology + open ENNReal hiding one_lt_two + open scoped NNReal +@@ -24,10 +28,6 @@ variable {F G : Set X} + variable {K : X → X → ℂ} {x x' : X} [IsTwoSidedKernel a K] + variable {f : X → ℂ} {α : ℝ≥0∞} + +-/-! ## Section 10.2 and Lemma 10.0.3 +- +-Question: -/ +- + /-- The constant used in `nontangential_from_simple`. + I(F) think the constant needs to be fixed in the blueprint. -/ + irreducible_def C10_2_1 (a : ℕ) : ℝ≥0 := 2 ^ (4 * a) +@@ -150,7 +150,7 @@ lemma depth_lt_iff_not_disjoint {d : ℝ} : + simp_rw [depth, iSup_lt_iff, iSup_le_iff] at hd; obtain ⟨d', ld', hd'⟩ := hd + have ns := (hd' d.toNNReal).mt; rw [not_le] at ns; specialize ns ld' + rw [not_subset_iff_exists_mem_notMem] at ns; obtain ⟨y, my, ny⟩ := ns +- have pd := (zero_le _).trans_lt ld' ++ have pd := zero_le.trans_lt ld' + rw [ofReal_pos] at pd; replace pd := Real.coe_toNNReal d pd.le + rw [pd] at my; exact not_disjoint_iff.mpr ⟨y, my, ny⟩ + mpr hd := by +@@ -185,7 +185,7 @@ lemma depth_lt_top_iff_ne_univ : depth O x < ⊤ ↔ O ≠ univ := by + constructor <;> intro h + · contrapose! h; simp_rw [top_le_iff, depth, iSup₂_eq_top, h, subset_univ, exists_const] + intro r rlt; lift r to ℝ≥0 using rlt.ne +- use r + 1; exact coe_lt_coe_of_lt (lt_add_one r) ++ use r + 1; exact coe_lt_coe.mpr (lt_add_one r) + · obtain ⟨p, np⟩ := (ne_univ_iff_exists_notMem _).mp h + calc + _ ≤ edist x p := by +@@ -271,8 +271,10 @@ lemma depth_bound_3 (hO : O ≠ univ) (h : x ∈ ball y (3 * ((depth O y).toReal + gcongr; rw [edist_dist]; apply ofReal_le_of_le_toReal + rw [toReal_div, toReal_ofNat]; linarith + calc +- _ ≤ (2 * depth O x).toReal / 6 + 3 * ((depth O y).toReal / 6) := by gcongr; have := @dnt x; finiteness +- _ ≤ (2 * depth O x).toReal / 6 + 3 * ((2 * depth O x).toReal / 6) := by gcongr; have := @dnt x; finiteness ++ _ ≤ (2 * depth O x).toReal / 6 + 3 * ((depth O y).toReal / 6) := by ++ gcongr; have := @dnt x; finiteness ++ _ ≤ (2 * depth O x).toReal / 6 + 3 * ((2 * depth O x).toReal / 6) := by ++ gcongr; have := @dnt x; finiteness + _ = _ := by rw [toReal_mul, toReal_ofNat]; ring + + lemma ball_covering_bounded_intersection +@@ -299,7 +301,7 @@ lemma ball_covering_bounded_intersection + apply measure_ball_two_le_same_iterate + _ = 2 ^ (3 * a) * volume (⋃ v : V, ball v.1 ((depth O v.1).toReal / 6)) := by + have VsU : V ⊆ U := sep_subset .. +- haveI : Countable V := by rw [countable_coe_iff]; exact countU.mono VsU ++ have : Countable V := by rw [countable_coe_iff]; exact countU.mono VsU + congr 1 + refine (measure_iUnion (fun ⟨v₁, mv₁⟩ ⟨v₂, mv₂⟩ hn ↦ ?_) (fun _ ↦ measurableSet_ball)).symm + rw [ne_eq, Subtype.mk.injEq] at hn +@@ -320,7 +322,7 @@ lemma ball_covering' (hO : IsOpen O ∧ O ≠ univ) : + let W : Set (Set X) := {U | U ⊆ O ∧ U.PairwiseDisjoint fun c ↦ ball c ((depth O c).toReal / 6)} + obtain ⟨U, maxU⟩ : ∃ U, Maximal (· ∈ W) U := by + refine zorn_subset _ fun U sU cU ↦ ⟨⋃₀ U, ?_, fun _ ↦ subset_sUnion_of_mem⟩ +- simp only [W, sUnion_subset_iff, mem_setOf_eq] ++ simp only [W, sUnion_subset_iff, mem_ofPred_eq] + exact ⟨fun u hu ↦ (sU hu).1, (pairwiseDisjoint_sUnion cU.directedOn).2 fun u hu ↦ (sU hu).2⟩ + have countU : U.Countable := by + refine maxU.1.2.countable_of_isOpen (fun _ _ ↦ isOpen_ball) (fun u mu ↦ ?_) +@@ -408,7 +410,7 @@ lemma ball_covering_finite (hO : IsOpen O ∧ O ≠ univ) {U : Set X} {r' : X + · exact disjoint_left.mpr fun i mi₁ mi₂ ↦ mi₁.1 mi₂.1 + _ = 0 + {u ∈ SetLike.coe U | x ∈ ball u (3 * r' u)}.encard := by + congr +- · simp_rw [encard_eq_zero, eq_empty_iff_forall_notMem, mem_setOf_eq, not_and]; intro i hi ++ · simp_rw [encard_eq_zero, eq_empty_iff_forall_notMem, mem_ofPred_eq, not_and]; intro i hi + simp [r, hi] + · set A := {i | i < U.card ∧ x ∈ ball (c i) (3 * r i)} + set B := {u ∈ SetLike.coe U | x ∈ ball u (3 * r' u)} +@@ -416,7 +418,7 @@ lemma ball_covering_finite (hO : IsOpen O ∧ O ≠ univ) {U : Set X} {r' : X + refine ⟨Subtype.coe_prop _, ?_⟩ + have := i.2.2; simp_rw [r, c, i.2.1, dite_true] at this; exact this⟩ + let g (u : B) : A := ⟨e ⟨u.1, u.2.1⟩, by +- simp_rw [A, r, c, mem_setOf_eq, Fin.is_lt, dite_true, Fin.eta, Equiv.symm_apply_apply, ++ simp_rw [A, r, c, mem_ofPred_eq, Fin.is_lt, dite_true, Fin.eta, Equiv.symm_apply_apply, + u.2.2, true_and]⟩ + let eqv : A ≃ B := ⟨f, g, fun i ↦ by simp [f, g], fun u ↦ by simp [f, g]⟩ + exact encard_congr eqv +@@ -455,9 +457,9 @@ theorem ball_covering (hO : IsOpen O ∧ O ≠ univ) : + set B := {u ∈ U | x ∈ ball u (3 * r' u)} + let f (i : A) : B := ⟨e.symm i, by + refine ⟨Subtype.coe_prop _, ?_⟩ +- have := i.2; simp_rw [A, mem_setOf_eq, r, c] at this; exact this⟩ ++ have := i.2; simp_rw [A, mem_ofPred_eq, r, c] at this; exact this⟩ + let g (u : B) : A := ⟨e ⟨u.1, u.2.1⟩, by +- simp_rw [A, r, c, mem_setOf_eq, Equiv.symm_apply_apply, u.2.2]⟩ ++ simp_rw [A, r, c, mem_ofPred_eq, Equiv.symm_apply_apply, u.2.2]⟩ + let eqv : A ≃ B := ⟨f, g, fun i ↦ by simp [f, g], fun u ↦ by simp [f, g]⟩ + exact encard_congr eqv + _ ≤ _ := Ubi x mx +@@ -573,17 +575,17 @@ lemma czBall_subset_czPartition {hX : GeneralCase f α} {i : ℕ} : + intro r hr + rw [mem_ball] at hr + unfold czPartition +- apply mem_diff_of_mem (by rw [mem_ball]; linarith [dist_nonneg.trans_lt hr]) ++ apply mem_sdiff_of_mem (by rw [mem_ball]; linarith [dist_nonneg.trans_lt hr]) + simp only [mem_union, mem_iUnion, mem_ball, not_or, not_exists, not_lt] + refine ⟨?_, fun j hj ↦ by + refine le_of_not_gt (disjoint_left.mp (czBall_pairwiseDisjoint ?_ ?_ hj.ne) hr) <;> tauto⟩ + unfold czPartition +- simp only [mem_diff, mem_ball, mem_union, mem_iUnion, not_or, not_and, not_not] ++ simp only [Set.mem_sdiff, mem_ball, mem_union, mem_iUnion, not_or, not_and, not_not] + exact fun _ _ _ _ ↦ by use i + + lemma czPartition_subset_czBall3 {hX : GeneralCase f α} {i : ℕ} : + czPartition hX i ⊆ czBall3 hX i := by +- rw [czPartition]; exact diff_subset ++ rw [czPartition]; exact sdiff_subset + + private lemma czPartition_subset_czBall7 {hX : GeneralCase f α} {i : ℕ} : + czPartition hX i ⊆ czBall7 hX i := +@@ -597,7 +599,7 @@ lemma czPartition_pairwiseDisjoint {hX : GeneralCase f α} : + have (t d) (hx : x ∈ czPartition hX t) (hd : t < d) : x ∉ czPartition hX d := by + have : czPartition hX t ⊆ ⋃ j < d, czPartition hX j := subset_biUnion_of_mem hd + rw [czPartition] +- exact notMem_diff_of_mem <| mem_union_left _ (this hx) ++ exact notMem_sdiff_of_mem <| mem_union_left _ (this hx) + have : _ ∧ _ := ⟨this i k hxi |>.mt (· hxk), this k i hxk |>.mt (· hxi)⟩ + lia + +@@ -626,7 +628,7 @@ lemma iUnion_czPartition {hX : GeneralCase f α} : + have ⟨t, ht⟩ : ∃ i, x ∈ (⋃ j < i, czPartition hX j) ∪ ⋃ j > i, czBall hX j := by + by_contra! hb + absurd hp g +- rw [czPartition, mem_diff] ++ rw [czPartition, Set.mem_sdiff] + exact ⟨hg, hb g⟩ + have : ⋃ j > t, czBall hX j ⊆ ⋃ j > t, czPartition hX j := + iUnion₂_mono fun i j ↦ czBall_subset_czPartition (i := i) +@@ -647,7 +649,8 @@ private lemma globalMaximalFunction_preimage_finite + refine le_trans (setLIntegral_mono_ae ?_ ?_) (setLIntegral_le_lintegral s _) + · exact AEStronglyMeasurable.globalMaximalFunction.aemeasurable.pow_const 2 |>.restrict + · exact Eventually.of_forall fun x hx ↦ pow_le_pow_left' (le_of_lt <| by simpa [s] using hx) 2 +- _ = eLpNorm (globalMaximalFunction volume 1 f) 2 volume := by simp [eLpNorm, eLpNorm'] ++ _ = eLpNorm (globalMaximalFunction volume 1 f) 2 volume := by ++ simp [eLpNorm, eLpNorm', AEStronglyMeasurable.globalMaximalFunction] + + private lemma volume_czPartition_lt_top (hX : GeneralCase f α) (i : ℕ) : + volume (czPartition hX i) < ∞ := +@@ -760,7 +763,7 @@ lemma aemeasurable_czApproximation {hf : AEMeasurable f} : AEMeasurable (czAppro + simpa [czA, hx] using h + · exact Or.inl ⟨hx, by simpa [czA, hx, hX] using h⟩ + · cases h with +- | inl h => simpa [czA, mem_setOf_eq ▸ mem_setOf_eq ▸ h.1] using h.2 ++ | inl h => simpa [czA, mem_ofPred_eq ▸ mem_ofPred_eq ▸ h.1] using h.2 + | inr h => obtain ⟨_, ⟨⟨i, ⟨hi, rfl⟩⟩, hxi⟩⟩ := h + have hx : ∃ j, x ∈ czPartition hX j := ⟨i, hxi⟩ + simpa [czA, hx, czPartition_pairwiseDisjoint' hx.choose_spec hxi] using hi +@@ -782,8 +785,10 @@ protected lemma BoundedFiniteSupport.czApproximation {α : ℝ≥0∞} (hα : 0 + by_cases h : Nonempty X; swap + · have := not_nonempty_iff.mp h; constructor <;> simp + constructor +- · use (aemeasurable_czApproximation (hf := aemeasurable hf)).aestronglyMeasurable ++ · rw [MemLp, eLpNorm_exponent_top ++ (aemeasurable_czApproximation (hf := hf.aemeasurable)).aestronglyMeasurable] + refine lt_of_le_of_lt ?_ hf.eLpNorm_lt_top ++ rw [eLpNorm_exponent_top hf.aestronglyMeasurable] + apply essSup_le_of_ae_le _ <| (ENNReal.ae_le_essSup (‖f ·‖ₑ)).mono (fun x h ↦ ?_) + by_cases hX : GeneralCase f α + · by_cases hx : ∃ j, x ∈ czPartition hX j +@@ -792,7 +797,7 @@ protected lemma BoundedFiniteSupport.czApproximation {α : ℝ≥0∞} (hα : 0 + exact (enorm_integral_le_lintegral_enorm _).trans (setLAverage_le_essSup _) + · simp [czApproximation, eLpNormEssSup, hX, hx, h] + · simp only [czApproximation, hX, reduceDIte] +- exact (enorm_integral_le_lintegral_enorm _).trans (laverage_le_essSup _) ++ exact (enorm_integral_le_lintegral_enorm _).trans (MeasureTheory.laverage_le_essSup _) + · by_cases hX : GeneralCase f α; swap + · exact lt_of_le_of_lt (measure_mono (subset_univ _)) <| volume_lt_of_not_GeneralCase hf hX hα + calc volume (support (czApproximation f α)) +@@ -883,16 +888,17 @@ private lemma eLpNorm_czApproximation_le_finite + _ ≤ (⨍⁻ x, ‖f x‖ₑ ∂volume) * volume (univ : Set X) := + mul_le_mul_left (enorm_integral_le_lintegral_enorm f) _ + _ = eLpNorm f 1 volume := by +- simp [mul_comm _ (volume univ), eLpNorm, eLpNorm', laverage, ← mul_assoc, ++ simp [mul_comm _ (volume univ), eLpNorm_one_eq_lintegral_enorm hf.aestronglyMeasurable, ++ laverage, ← mul_assoc, + ENNReal.mul_inv_cancel (NeZero.ne (volume univ)) (volume_lt_of_not_GeneralCase hf hX hα).ne] + + -- Equation (10.2.18), infinite case +-private lemma eLpNorm_czApproximation_le_infinite (hX : GeneralCase f α) : +- eLpNorm (czApproximation f α) 1 volume ≤ eLpNorm f 1 volume := by +- simp only [eLpNorm, one_ne_zero, reduceIte, one_ne_top, eLpNorm', toReal_one, rpow_one, ++private lemma eLpNormFormula_czApproximation_le_infinite (hX : GeneralCase f α) : ++ eLpNormFormula (czApproximation f α) 1 volume ≤ eLpNormFormula f 1 volume := by ++ simp only [eLpNormFormula, one_ne_zero, reduceIte, one_ne_top, eLpNorm', toReal_one, rpow_one, + ne_eq, not_false_eq_true, div_self] + have hmeas : MeasurableSet (univ \ ⋃ i, czPartition hX i) := by measurability +- have := union_univ _ ▸ @union_diff_self X (⋃ i, czPartition hX i) univ ++ have := union_univ _ ▸ @union_sdiff_self X (⋃ i, czPartition hX i) univ + repeat rw [← setLIntegral_univ (μ := volume), ← this, lintegral_union hmeas disjoint_sdiff_right, + lintegral_iUnion (MeasurableSet.czPartition hX) <| czPartition_pairwise_disjoint_on] + -- gcongr tsum ?_ + ?_ +@@ -900,10 +906,19 @@ private lemma eLpNorm_czApproximation_le_infinite (hX : GeneralCase f α) : + · apply ENNReal.tsum_le_tsum + intro _ + apply lintegral_czPartition_le +- · simp only [union_diff_self, union_univ] ++ · simp only [union_sdiff_self, union_univ] + apply le_of_eq ∘ setLIntegral_congr_fun_ae (by measurability) + exact Eventually.of_forall (fun x hx ↦ by simp_all [czApproximation]) + ++private lemma eLpNorm_czApproximation_le_infinite (hX : GeneralCase f α) : ++ eLpNorm (czApproximation f α) 1 volume ≤ eLpNorm f 1 volume := by ++ by_cases hf : AEStronglyMeasurable f volume ++ · rw [eLpNorm_eq_eLpNormFormula hf, eLpNorm_eq_eLpNormFormula ++ (aemeasurable_czApproximation (hf := hf.aemeasurable)).aestronglyMeasurable] ++ exact eLpNormFormula_czApproximation_le_infinite hX ++ · rw [eLpNorm_of_not_aestronglyMeasurable hf] ++ exact le_top ++ + /-- Part of Lemma 10.2.5, equation (10.2.18) (both cases). -/ + lemma eLpNorm_czApproximation_le + {hf : BoundedFiniteSupport f} (hα : 0 < α) : +@@ -938,7 +953,9 @@ private lemma ineq_10_2_32 (hf : BoundedFiniteSupport f) {hX : GeneralCase f α} + {i : ℕ} : + eLpNorm (czRemainder' hX i) 1 volume ≤ 2 * (∫⁻ x in czPartition hX i, ‖f x‖ₑ) := calc + _ = ∫⁻ x in czPartition hX i, ‖f x - czApproximation f α x‖ₑ := by +- simp [czRemainder', eLpNorm, eLpNorm', enorm_indicator_eq_indicator_enorm, ++ rw [eLpNorm_one_eq_lintegral_enorm ++ (AEMeasurable.czRemainder' (hf := hf.aemeasurable) hX i).aestronglyMeasurable] ++ simp [czRemainder', enorm_indicator_eq_indicator_enorm, + lintegral_indicator <| MeasurableSet.czPartition hX i] + _ ≤ ∫⁻ x in czPartition hX i, ‖f x‖ₑ + ‖czApproximation f α x‖ₑ := + lintegral_mono (fun x ↦ enorm_sub_le) +@@ -971,16 +988,22 @@ private lemma eLpNorm_restrict_czRemainder'_le {hf : BoundedFiniteSupport f} {hX + {i : ℕ} : + ∫⁻ y in czBall3 hX i, ‖czRemainder' hX i y‖ₑ ≤ 2 ^ (2 * a + 1) * α * volume (czBall3 hX i) := by + apply le_trans (setLIntegral_le_lintegral _ _) +- rw [← eLpNorm_one_eq_lintegral_enorm] ++ rw [← eLpNorm_one_eq_lintegral_enorm ++ (AEMeasurable.czRemainder' (hf := hf.aemeasurable) hX i).aestronglyMeasurable] + exact eLpNorm_czRemainder'_le (hf := hf) + + -- Used to prove `eLpNorm_czRemainder_le` and `tsum_eLpNorm_czRemainder_le` + private lemma eLpNorm_czRemainder_le' + (hf : BoundedFiniteSupport f) (hX : ¬ GeneralCase f α) (hα : ⨍⁻ x, ‖f x‖ₑ < α) : + eLpNorm (czRemainder f α) 1 volume ≤ 2 * ∫⁻ x, ‖f x‖ₑ := +- have := isFiniteMeasure_of_not_generalCase hf hX (lt_of_le_of_lt (zero_le _) hα) ++ have := isFiniteMeasure_of_not_generalCase hf hX (lt_of_le_of_lt zero_le hα) + calc +- _ = ∫⁻ x, ‖f x - ⨍ y, f y‖ₑ := by simp [czRemainder, eLpNorm, eLpNorm', czApproximation, hX] ++ _ = ∫⁻ x, ‖f x - ⨍ y, f y‖ₑ := by ++ change eLpNorm (f - czApproximation f α) 1 volume = _ ++ rw [eLpNorm_one_eq_lintegral_enorm ++ (hf.aestronglyMeasurable.sub ++ (aemeasurable_czApproximation (hf := hf.aemeasurable)).aestronglyMeasurable)] ++ simp [czApproximation, hX] + _ ≤ ∫⁻ x, (‖f x‖ₑ + ‖⨍ y, f y‖ₑ) := lintegral_mono (fun x ↦ enorm_sub_le) + _ = (∫⁻ x, ‖f x‖ₑ) + ∫⁻ (x : X), ‖⨍ y, f y‖ₑ := lintegral_add_right' _ aemeasurable_const + _ ≤ (∫⁻ x, ‖f x‖ₑ) + ∫⁻ (x : X), ⨍⁻ y, ‖f y‖ₑ := by +@@ -993,7 +1016,7 @@ lemma eLpNorm_czRemainder_le {hf : BoundedFiniteSupport f} + eLpNorm (czRemainder f α) 1 volume ≤ 2 ^ (2 * a + 1) * α * volume (univ : Set X) := by + by_cases h : Nonempty X; swap + · have := not_nonempty_iff.mp h; simp +- have := isFiniteMeasure_of_not_generalCase hf hX (lt_of_le_of_lt (zero_le _) hα) ++ have := isFiniteMeasure_of_not_generalCase hf hX (lt_of_le_of_lt zero_le hα) + calc + _ ≤ 2 * ∫⁻ x, ‖f x‖ₑ := eLpNorm_czRemainder_le' hf hX hα + _ ≤ 2 * (α * volume (univ : Set X)) := by +@@ -1034,13 +1057,15 @@ lemma tsum_eLpNorm_czRemainder'_le {hf : BoundedFiniteSupport f} (hX : GeneralCa + simp_rw [← smul_eq_mul, ENNReal.tsum_const_smul] + gcongr + rw [← lintegral_iUnion (MeasurableSet.czPartition hX) czPartition_pairwise_disjoint_on] +- simpa [eLpNorm, eLpNorm'] using (lintegral_mono_set (subset_univ _)) ++ simpa [eLpNorm_one_eq_lintegral_enorm hf.aestronglyMeasurable] using ++ (lintegral_mono_set (subset_univ _)) + + /-- Part of Lemma 10.2.5, equation (10.2.23) (finite case). -/ + lemma tsum_eLpNorm_czRemainder_le + {hf : BoundedFiniteSupport f} (hX : ¬ GeneralCase f α) (hα : ⨍⁻ x, ‖f x‖ₑ < α) : + eLpNorm (czRemainder f α) 1 volume ≤ 2 * eLpNorm f 1 volume := by +- simpa [eLpNorm, eLpNorm'] using (eLpNorm_czRemainder_le' hf hX hα) ++ simpa [eLpNorm_one_eq_lintegral_enorm hf.aestronglyMeasurable] using ++ (eLpNorm_czRemainder_le' hf hX hα) + + /- ### Lemmas 10.2.6 - 10.2.9 -/ + +@@ -1092,7 +1117,7 @@ lemma estimate_good (hf : BoundedFiniteSupport f) (hα : ⨍⁻ x, ‖f x‖ₑ + · simp [hα_top, top_div_of_lt_top ENNReal.ofNat_lt_top] + have ne0 : (c10_0_3 a : ℝ≥0∞) ≠ 0 := by simp [c10_0_3] + have hα' : 0 < α' a α := α'_pos (pos_of_gt hα) +- have hα'' := ((zero_le _).trans_lt hα).ne' ++ have hα'' := (zero_le.trans_lt hα).ne' + calc distribution ((czOperator K r (czApproximation f (α' a α)))) (α / 2) volume + _ = distribution ((czOperator K r (czApproximation f (α' a α))) ^ 2) ((α / 2) ^ 2) volume := + (distribution_pow _ _ _ _ two_pos.ne').symm +@@ -1112,8 +1137,11 @@ lemma estimate_good (hf : BoundedFiniteSupport f) (hα : ⨍⁻ x, ‖f x‖ₑ + have half_pos : 0 < (2 : ℝ)⁻¹ := by norm_num + refine mul_le_mul_right (ENNReal.le_of_rpow_le half_pos ?_) (2 ^ 2 / α ^ 2) + rw [ENNReal.mul_rpow_of_nonneg _ _ half_pos.le, ← ENNReal.rpow_natCast_mul] +- convert hT _ (hf.czApproximation hα') |>.2 +- all_goals simp [eLpNorm, eLpNorm', α'] ++ have hstrong := (hT _ (hf.czApproximation hα')).2 ++ rw [eLpNorm_eq_eLpNorm' (by norm_num) (by norm_num) (hT _ (hf.czApproximation hα')).1, ++ eLpNorm_eq_eLpNorm' (by norm_num) (by norm_num) ++ (hf.czApproximation hα').aestronglyMeasurable] at hstrong ++ convert hstrong using 1 <;> simp [eLpNorm', α'] + _ ≤ 2^2/α^2 * ((C_Ts a) ^ 2 * ∫⁻ y, 2^(3*a) * c10_0_3 a * α * ‖czApproximation f _ y‖ₑ) := by + gcongr _ * (_ * ?_) + suffices ∀ᵐ x, ‖czApproximation f (α' a α) x‖ₑ ≤ 2 ^ (3 * a) * c10_0_3 a * α by +@@ -1125,7 +1153,9 @@ lemma estimate_good (hf : BoundedFiniteSupport f) (hα : ⨍⁻ x, ‖f x‖ₑ + _ = 2^2/α^2 * ((C_Ts a)^2 * (2^(3*a) * c10_0_3 a * α * ∫⁻ y, ‖czApproximation f _ y‖ₑ)) := by + rw [lintegral_const_mul' _ _ (by finiteness)] + _ ≤ 2 ^ 2 / α ^ 2 * ((C_Ts a) ^ 2 * (2 ^ (3 * a) * c10_0_3 a * α * eLpNorm f 1 volume)) := by +- gcongr; simpa [eLpNorm, eLpNorm'] using eLpNorm_czApproximation_le (hf := hf) hα' ++ gcongr ++ simpa only [eLpNorm_one_eq_lintegral_enorm (hf.czApproximation hα').aestronglyMeasurable] ++ using eLpNorm_czApproximation_le (hf := hf) hα' + _ = 2 ^ 2 / α^2 * ((C_Ts a) ^ 2 * (2 ^ (3 * a) * c10_0_3 a * α)) * eLpNorm f 1 volume := by ring + _ = (2 ^ 2 * (C_Ts a) ^ 2 * 2 ^ (3 * a) * c10_0_3 a * α) / α ^ 2 * eLpNorm f 1 volume := by + rw [ENNReal.mul_comm_div, mul_div]; ring_nf +@@ -1220,12 +1250,12 @@ private lemma 𝒥₁_bound (hf : BoundedFiniteSupport f) (hα : 0 < α) (hx : x + ‖czOperator K r (czRemainder' hX j) x‖ₑ ≤ czOperatorBoundSummand hX j x := calc + _ = ‖∫ y in czBall3 hX j, K x y * (czRemainder' hX j y)‖ₑ := by + apply congrArg +- apply setIntegral_eq_of_subset_of_ae_diff_eq_zero measurableSet_ball.compl.nullMeasurableSet ++ apply setIntegral_eq_of_subset_of_ae_sdiff_eq_zero measurableSet_ball.compl.nullMeasurableSet + · intro y hy +- simp only [𝒥₁, mem_setOf_eq, mem_ball, mem_compl_iff] at hj hy ⊢ ++ simp only [𝒥₁, mem_ofPred_eq, mem_ball, mem_compl_iff] at hj hy ⊢ + linarith [dist_triangle_left x (czCenter hX j) y] + · refine Eventually.of_forall (fun y hy ↦ mul_eq_zero_of_right (K x y) ?_) +- exact notMem_support.mp <| notMem_subset support_czRemainder'_subset (notMem_of_mem_diff hy) ++ exact notMem_support.mp <| notMem_subset support_czRemainder'_subset (notMem_of_mem_sdiff hy) + _ ≤ _ := by + apply lemma_10_2_7_bound hx hX j (hf.czRemainder' (α'_pos hα) hX j).integrable.restrict + · rw [setIntegral_eq_integral_of_forall_compl_eq_zero, integral_czRemainder'] +@@ -1299,7 +1329,9 @@ private lemma integral_g (hf : BoundedFiniteSupport f) (hα : 0 < α) (hX : Gene + by_cases! hj : czRadius hX j ≤ 0 + · simp [Metric.ball_eq_empty.mpr <| mul_nonpos_of_nonneg_of_nonpos three_pos.le hj] + rw [integral_sub (integrableOn_g₀ hf hα hX j) (integrableOn_d hX j)] +- simp [d, setAverage_eq, smul_smul, mul_inv_cancel₀ (measureReal_ball_pos (czCenter hX j) (mul_pos three_pos hj)).ne'] ++ have hmeasure : (volume.real (czBall3 hX j) : ℂ) ≠ 0 := by ++ exact_mod_cast (measureReal_ball_pos (czCenter hX j) (mul_pos three_pos hj)).ne' ++ simp [d, setAverage_eq, hmeasure] + + private lemma lintegral_enorm_half_g (hf : BoundedFiniteSupport f) (hα : 0 < α) + (hX : GeneralCase f (α' a α)) (j : ℕ) : +@@ -1307,7 +1339,7 @@ private lemma lintegral_enorm_half_g (hf : BoundedFiniteSupport f) (hα : 0 < α + 2 ^ (2 * a + 1) * α' a α * volume (czBall3 hX j) := calc + _ = 2⁻¹ * ∫⁻ y in czBall3 hX j, ‖g r x hX j y‖ₑ := by + simp_rw [enorm_mul] +- rw [lintegral_const_mul' _ _ enorm_ne_top, enorm_inv (NeZero.ne 2), ← ofReal_norm_eq_enorm] ++ rw [lintegral_const_mul' _ _ enorm_ne_top, enorm_inv (NeZero.ne 2), ← ofReal_norm] + simp + _ ≤ 2⁻¹ * ∫⁻ y in czBall3 hX j, ‖g₀ r x hX j y‖ₑ + ‖d r x hX j‖ₑ := by gcongr; exact enorm_sub_le + _ = _ := by rw [lintegral_add_left' (integrableOn_g₀ hf hα hX j).aemeasurable.enorm] +@@ -1362,7 +1394,7 @@ private lemma 𝒥₂_bound (hf : BoundedFiniteSupport f) (hα : 0 < α) (hx : x + rw [← enorm_mul] + _ ≤ _ := by + gcongr +- · simp [← ofReal_norm_eq_enorm] ++ · simp [← ofReal_norm] + · apply lemma_10_2_7_bound hx hX j ((integrableOn_g r x hα hf hX j).const_mul 2⁻¹) + · have h : + ∫ (y : X) in czBall3 hX j, 2⁻¹ * g r x hX j y = +@@ -1385,7 +1417,7 @@ private lemma A_subset (hx : x ∈ (Ω f (α' a α))ᶜ) (hX : GeneralCase f (α + rw [mem_ball'] at hy + have : 6 * czRadius hX j ≤ dist x (czCenter hX j) := six_mul_czRadius_le_of_mem_Ω hx hX j + have hj := Subtype.coe_prop j +- simp only [𝒥₂, tsub_le_iff_right, mem_setOf_eq] at hj ++ simp only [𝒥₂, tsub_le_iff_right, mem_ofPred_eq] at hj + constructor + · linarith [dist_triangle_right x (czCenter hX j) y] + · linarith [dist_triangle x (czCenter hX j) y] +@@ -1507,7 +1539,7 @@ lemma czOperatorBound_inner_le (ha : 4 ≤ a) (hX : GeneralCase f (α' a α)) {i + rcases le_or_gt r 0 with hr | hr + · simp_rw [Real.toNNReal_of_nonpos hr, coe_zero, ENNReal.zero_div] + rw [ENNReal.zero_rpow_of_pos (by rw [inv_pos, Nat.cast_pos]; exact zero_lt_four.trans_le ha)] +- simp_rw [ENNReal.zero_div, lintegral_zero]; exact zero_le _ ++ simp_rw [ENNReal.zero_div, lintegral_zero]; exact zero_le + calc + _ ≤ ∫⁻ x in (czBall6 hX i)ᶜ, + (r.toNNReal / edist x c) ^ (a : ℝ)⁻¹ / volume (ball x (dist x c)) := by +@@ -1534,7 +1566,7 @@ lemma czOperatorBound_inner_le (ha : 4 ≤ a) (hX : GeneralCase f (α' a α)) {i + rw [czBall6, mem_compl_iff, mem_ball, not_lt, show (6 : ℝ) = 2 * 3 by norm_num, + mul_assoc] at mx + change 2 * r ≤ dist x c at mx +- rw [mem_iUnion]; use ⌊Real.logb 2 (dist x c / r)⌋₊; simp_rw [mem_diff, mem_ball, not_lt] ++ rw [mem_iUnion]; use ⌊Real.logb 2 (dist x c / r)⌋₊; simp_rw [Set.mem_sdiff, mem_ball, not_lt] + have dxcpos : 0 < dist x c := lt_of_lt_of_le (by positivity) mx + have dxceq : dist x c = 2 ^ (Real.logb 2 (dist x c / r)) * r := by + rw [Real.rpow_logb zero_lt_two (by norm_num) (by positivity), div_mul_cancel₀ _ hr.ne'] +@@ -1552,7 +1584,7 @@ lemma czOperatorBound_inner_le (ha : 4 ≤ a) (hX : GeneralCase f (α' a α)) {i + (2 ^ n)⁻¹ ^ (a : ℝ)⁻¹ / volume (ball c (2 ^ n * r)) := by + gcongr 2 ^ a * ∑' n, ?_ with n + refine setLIntegral_mono' (measurableSet_ball.diff measurableSet_ball) fun x mx ↦ ?_ +- simp_rw [mem_diff, mem_ball, not_lt] at mx ++ simp_rw [Set.mem_sdiff, mem_ball, not_lt] at mx + gcongr + · change ENNReal.ofReal r / _ ≤ _ + have dxcpos : 0 < dist x c := lt_of_lt_of_le (by positivity) mx.2 +@@ -1569,7 +1601,7 @@ lemma czOperatorBound_inner_le (ha : 4 ≤ a) (hX : GeneralCase f (α' a α)) {i + gcongr with n; apply div_le_of_le_mul + calc + _ ≤ volume (ball c (2 * (2 ^ n * r))) := by +- rw [← mul_assoc 2, ← pow_succ']; exact measure_mono diff_subset ++ rw [← mul_assoc 2, ← pow_succ']; exact measure_mono sdiff_subset + _ ≤ _ := by + convert measure_ball_two_le_same (μ := volume) c (2 ^ n * r) + unfold defaultA; norm_cast +@@ -1590,16 +1622,16 @@ lemma distribution_czOperatorBound (ha : 4 ≤ a) (hf : BoundedFiniteSupport f) + rcases eq_top_or_lt_top α with rfl | αlt + · have : czOperatorBound hX ⁻¹' Ioi (⊤ / 8) = ∅ := by + rw [top_div_of_ne_top (by norm_num), isMax_top.Ioi_eq, preimage_empty] +- rw [this, inter_empty, measure_empty]; exact zero_le _ ++ rw [this, inter_empty, measure_empty]; exact zero_le + calc + _ ≤ (volume.restrict (Ω f (α' a α))ᶜ) {x | α / 8 ≤ czOperatorBound hX x} := by + rw [inter_comm, ← Measure.restrict_apply']; swap + · apply MeasurableSet.compl; simp_rw [Ω, hX, dite_true] + exact MeasurableSet.iUnion fun _ ↦ measurableSet_ball +- gcongr; intro x mx; simp only [mem_preimage, mem_Ioi, mem_setOf_eq] at mx ⊢; exact mx.le ++ gcongr; intro x mx; simp only [mem_preimage, mem_Ioi, mem_ofPred_eq] at mx ⊢; exact mx.le + _ ≤ (∫⁻ x in (Ω f (α' a α))ᶜ, czOperatorBound hX x) / (α / 8) := by + apply meas_ge_le_lintegral_div +- · refine ((AEMeasurable.ennreal_tsum fun i ↦ ?_).const_mul _).restrict ++ · refine ((AEMeasurable.tsum fun i ↦ ?_).const_mul _).restrict + refine AEMeasurable.div ?_ measurable_vol₁.aemeasurable + refine ((AEMeasurable.const_div ?_ _).pow_const _).mul_const _ + simp only [coe_nnreal_ennreal_nndist] +@@ -1647,8 +1679,8 @@ lemma estimate_bad (ha : 4 ≤ a) (hr : 0 < r) + _ ≤ volume (Ω f (α' a α) ∪ + {x ∈ (Ω f (α' a α))ᶜ | α / 2 < ‖czOperator K r (czRemainder f (α' a α)) x‖ₑ}) := by + refine measure_mono fun x mx ↦ ?_ +- rw [mem_setOf_eq] at mx +- simp_rw [mem_union, mem_setOf_eq, mx, and_true, mem_compl_iff]; tauto ++ rw [mem_ofPred_eq] at mx ++ simp_rw [mem_union, mem_ofPred_eq, mx, and_true, mem_compl_iff]; tauto + _ ≤ volume (Ω f (α' a α)) + + volume {x ∈ (Ω f (α' a α))ᶜ | α / 2 < ‖czOperator K r (czRemainder f (α' a α)) x‖ₑ} := + measure_union_le _ _ +@@ -1656,7 +1688,7 @@ lemma estimate_bad (ha : 4 ≤ a) (hr : 0 < r) + volume ((Ω f (α' a α))ᶜ ∩ czOperatorBound hX ⁻¹' Ioi (α / 8)) := by + gcongr + · simp_rw [Ω, hX, dite_true]; exact measure_iUnion_le _ +- · intro x mx; simp_rw [mem_setOf_eq, mem_inter_iff, mem_preimage, mem_Ioi] at mx ⊢ ++ · intro x mx; simp_rw [mem_ofPred_eq, mem_inter_iff, mem_preimage, mem_Ioi] at mx ⊢ + obtain ⟨mx₁, mx₂⟩ := mx; refine ⟨mx₁, ?_⟩; contrapose! mx₂ + calc + _ ≤ 3 * czOperatorBound hX x + α / 8 := estimate_bad_partial hf hr hα mx₁ hX +@@ -1698,17 +1730,18 @@ lemma estimate_czOperator (ha : 4 ≤ a) (hr : 0 < r) (hf : BoundedFiniteSupport + rcases le_or_gt α (⨍⁻ x, ‖f x‖ₑ / c10_0_3 a) with hα | hα + · rw [laverage_eq] at hα + rcases eq_zero_or_pos (eLpNorm f 1) with hf₂ | hf₂ +- · rw [eLpNorm_eq_zero_iff hf.aestronglyMeasurable one_ne_zero] at hf₂ ++ · rw [eLpNorm_eq_zero_iff one_ne_zero] at hf₂ + have op0 : czOperator K r f = 0 := by + ext x; rw [czOperator, integral_eq_zero_of_ae]; swap + · have := (EventuallyEq.rfl (f := (K x ·))).mul hf₂ + simp only [mul_zero] at this; exact this.restrict + simp +- simp_rw [op0, distribution, Pi.zero_apply, enorm_zero, not_lt_zero, setOf_false, ++ simp_rw [op0, distribution, Pi.zero_apply, enorm_zero, not_lt_zero, ofPred_false, + measure_empty, zero_le] + conv_rhs at hα => + enter [1, 2, x]; rw [div_eq_mul_inv, c10_0_3, coe_inv (by positivity), inv_inv] +- rw [lintegral_mul_const' _ _ (by finiteness), ← eLpNorm_one_eq_lintegral_enorm] at hα ++ rw [lintegral_mul_const' _ _ (by finiteness), ++ ← eLpNorm_one_eq_lintegral_enorm hf.aestronglyMeasurable] at hα + replace hα := mul_le_of_le_div' hα + rw [← ENNReal.le_div_iff_mul_le] at hα; rotate_left + · right; positivity +@@ -1723,7 +1756,7 @@ lemma estimate_czOperator (ha : 4 ≤ a) (hr : 0 < r) (hf : BoundedFiniteSupport + _ ≤ distribution (czOperator K r (czApproximation f (α' a α))) (α / 2) volume + + distribution (czOperator K r (czRemainder f (α' a α))) (α / 2) volume := by + refine le_trans (measure_mono fun x mx ↦ ?_) (measure_union_le _ _) +- simp only [mem_union, mem_setOf_eq] at mx ⊢; contrapose! mx ++ simp only [mem_union, mem_ofPred_eq] at mx ⊢; contrapose! mx + calc + _ = ‖czOperator K r (czApproximation f (α' a α)) x + + czOperator K r (czRemainder f (α' a α)) x‖ₑ := by +@@ -1768,4 +1801,27 @@ theorem czOperator_weak_1_1 (ha : 4 ≤ a) (hr : 0 < r) + intro α; apply mul_le_of_le_div'; rw [ENNReal.mul_div_right_comm] + exact estimate_czOperator ha hr hf hT + ++/-! Public access to three already-proved decomposition/cancellation helpers. ++Added by the LeanBlast port; no upstream declaration or proof is changed. -/ ++ ++abbrev carlesonCzOperatorBoundSummand ++ (hX : GeneralCase f (c10_0_3 a * α)) (j : ℕ) (x : X) : ℝ≥0∞ := ++ czOperatorBoundSummand hX j x ++ ++theorem carlesonCzOperatorBound_eq ++ (hX : GeneralCase f (c10_0_3 a * α)) (x : X) : ++ czOperatorBound hX x = ∑' j, carlesonCzOperatorBoundSummand hX j x := ++ czOperatorBound_eq hX x ++ ++theorem carlesonCzCancellation_bound ++ (hx : x ∈ (Ω f (c10_0_3 a * α))ᶜ) ++ (hX : GeneralCase f (c10_0_3 a * α)) (j : ℕ) ++ {g : X → ℂ} (g_int : IntegrableOn g (czBall3 hX j)) ++ (hg0 : ∫ y in czBall3 hX j, g y = 0) ++ (hg : ∫⁻ y in czBall3 hX j, ‖g y‖ₑ ≤ ++ 2 ^ (2 * a + 1) * (c10_0_3 a * α) * volume (czBall3 hX j)) : ++ ‖∫ y in czBall3 hX j, K x y * g y‖ₑ ≤ carlesonCzOperatorBoundSummand hX j x := ++ lemma_10_2_7_bound hx hX j g_int hg0 hg ++ ++ + end +diff --git a/lakefile.toml b/lakefile.toml +index a6d2c69..b16709c 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -9,12 +9,11 @@ autoImplicit = false + weak.linter.flexible = true # no rigid tactic (e.g. `exact`) after a flexible tactic (e.g. `simp`) + # Enable all mathlib linters: automatically matches what mathlib uses. + weak.linter.mathlibStandardSet = true +-# Disable the long line linter, for now. +-weak.linter.style.longLine = false + + [[require]] + name = "mathlib" + git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[require]] + name = "checkdecls" +diff --git a/lean-toolchain b/lean-toolchain +index d324cad..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.29.0 +\ No newline at end of file ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/elliptic-curves-lean4341.patch b/lean/patches/elliptic-curves-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..8a3da3c0a9ad56cb330b1b4c22fa75a8d4813fbe --- /dev/null +++ b/lean/patches/elliptic-curves-lean4341.patch @@ -0,0 +1,668 @@ +diff --git a/EllipticCurves/FormalGroup/DividedDiffDiagonal.lean b/EllipticCurves/FormalGroup/DividedDiffDiagonal.lean +index 83a0c99107040dc9d9cd9679e970521b0f0c926f..84163f3a94a1ff49633771c646cc814e5143085a 100644 +--- a/EllipticCurves/FormalGroup/DividedDiffDiagonal.lean ++++ b/EllipticCurves/FormalGroup/DividedDiffDiagonal.lean +@@ -27,7 +27,7 @@ the Weierstrass formal group addition law (Silverman AEC IV.1). + ## Main result + + * `PowerSeries.adicEvalMv_dividedDiff_diagonal` : +- `adicEvalMv I ![x, x] (dividedDiff f) = adicEval I hx (derivativeFun f)`. ++ `adicEvalMv I ![x, x] (dividedDiff f) = adicEval I hx (derivative f)`. + -/ + + open MvPowerSeries +@@ -43,9 +43,9 @@ theorem diag_mem {x : A} (hx : x ∈ I) : ∀ s : Fin 2, (![x, x] : Fin 2 → A) + + /-- **The divided difference on the diagonal is the formal derivative.** Evaluating the bivariate + divided difference `Δf` at the diagonal point `(x, x)` (with `x ∈ I`, in the `I`-adically complete +-ring `A`) yields the `I`-adic evaluation of the formal derivative `f′ = derivativeFun f` at `x`. -/ ++ring `A`) yields the `I`-adic evaluation of the formal derivative `f′ = derivative f` at `x`. -/ + theorem adicEvalMv_dividedDiff_diagonal {x : A} (hx : x ∈ I) (f : PowerSeries A) : +- adicEvalMv I (diag_mem I hx) (dividedDiff f) = adicEval I hx (derivativeFun f) := by ++ adicEvalMv I (diag_mem I hx) (dividedDiff f) = adicEval I hx (derivative f) := by + classical + letI : WithIdeal A := ⟨I⟩ + haveI : CompleteSpace A := ((IsAdic.isAdicComplete_iff (I := I) rfl).mp ‹_›).1 +@@ -94,7 +94,7 @@ theorem adicEvalMv_dividedDiff_diagonal {x : A} (hx : x ∈ I) (f : PowerSeries + have hsig := hP.sigma hfib + -- Match the derivative coefficient shape. + have hfun2 : (fun n : ℕ ↦ (n + 1) • (coeff (n + 1) f * x ^ n)) = +- fun n : ℕ ↦ coeff n (derivativeFun f) * x ^ n := by ++ fun n : ℕ ↦ coeff n (derivative f) * x ^ n := by + funext n + rw [coeff_derivativeFun, nsmul_eq_mul] + push_cast +@@ -103,7 +103,7 @@ theorem adicEvalMv_dividedDiff_diagonal {x : A} (hx : x ∈ I) (f : PowerSeries + -- The right-hand side, `f′(x)`, as a convergent sum with the *same* summand. + have hxnil : PowerSeries.HasEval x := WithIdeal.isTopologicallyNilpotent_of_mem hx + have hR := PowerSeries.hasSum_eval₂ (φ := RingHom.id A) (a := x) continuous_id hxnil +- (derivativeFun f) ++ (derivative f) + simp only [RingHom.id_apply] at hR + -- Conclude by uniqueness of sums. + rw [coe_adicEvalMv I (diag_mem I hx), coe_adicEval hx, ← hLdef] +diff --git a/EllipticCurves/FormalGroup/InvariantDifferentialInvariance.lean b/EllipticCurves/FormalGroup/InvariantDifferentialInvariance.lean +index 30d26f1960722fdf925dde3db9703aa5ec3c9cc2..9079ac48793bac2aa4cb8e485aa330885a244859 100644 +--- a/EllipticCurves/FormalGroup/InvariantDifferentialInvariance.lean ++++ b/EllipticCurves/FormalGroup/InvariantDifferentialInvariance.lean +@@ -90,10 +90,8 @@ variable {R : Type*} [CommRing R] (W : WeierstrassCurve R) + /-- The formal derivative of `z³` is `3z²`. -/ + private theorem derivativeFun_X_pow_three : + derivativeFun (X ^ 3 : R⟦X⟧) = 3 * X ^ 2 := by +- have h := PowerSeries.derivative_pow R (X : R⟦X⟧) 3 +- rw [PowerSeries.derivative_X, mul_one] at h +- rw [show derivativeFun (X ^ 3 : R⟦X⟧) = PowerSeries.derivative R (X ^ 3) from rfl, h] +- norm_num ++ change PowerSeries.derivative (X ^ 3 : R⟦X⟧) = 3 * X ^ 2 ++ simpa using PowerSeries.derivative_pow (X : R⟦X⟧) 3 + + /-- **Step 1 (`Eq.Ω`).** The pole-cleared defining identity of the invariant differential: + `ω_E · (w·(-2 + a₁z + a₃w)) = w − z·w'` in `R⟦z⟧`, with `w = W.formalW`. +@@ -113,6 +111,9 @@ theorem invariantDifferential_mul_clear [Algebra ℚ R] : + have ha : X ^ 3 * W.invDiffDen = W.formalW * (-2 + C W.a₁ * X + C W.a₃ * W.formalW) := by + rw [invDiffDen, ← mul_assoc, ← W.formalW_eq_X_pow_mul_wCofactor] + have hb : X ^ 3 * W.invDiffNum = W.formalW - X * derivativeFun W.formalW := by ++ change PowerSeries.derivative W.formalW = ++ X ^ 3 * PowerSeries.derivative W.wCofactor + 3 * X ^ 2 * W.wCofactor at hderiv ++ change X ^ 3 * W.invDiffNum = W.formalW - X * PowerSeries.derivative W.formalW + rw [invDiffNum, hderiv, W.formalW_eq_X_pow_mul_wCofactor] + ring + calc W.invariantDifferential * (W.formalW * (-2 + C W.a₁ * X + C W.a₃ * W.formalW)) +@@ -159,6 +160,9 @@ theorem invariantDifferential_mul_clear_subst_mul_pderivSnd [Algebra ℚ R] : + * MvPowerSeries.pderivSnd (W.formalW.subst W.formalGroupZW) := by + have hΩF := W.invariantDifferential_mul_clear_subst + have hchain := MvPowerSeries.pderivSnd_subst W.constantCoeff_formalGroupZW W.formalW ++ change MvPowerSeries.pderivSnd (W.formalW.subst W.formalGroupZW) = ++ W.formalW.derivativeFun.subst W.formalGroupZW * ++ MvPowerSeries.pderivSnd W.formalGroupZW at hchain + linear_combination MvPowerSeries.pderivSnd W.formalGroupZW * hΩF + W.formalGroupZW * hchain + + end WeierstrassCurve +diff --git a/EllipticCurves/FormalGroup/LogAdditivity.lean b/EllipticCurves/FormalGroup/LogAdditivity.lean +index 4b07889c1f9ae0f936f78bed2821b39d65834f13..3885dc976aabf531f43ea7a6f80a2fb377e168e6 100644 +--- a/EllipticCurves/FormalGroup/LogAdditivity.lean ++++ b/EllipticCurves/FormalGroup/LogAdditivity.lean +@@ -130,6 +130,7 @@ theorem eq_C_of_derivativeFun_eq_zero {g : S⟦X⟧} (h : g.derivativeFun = 0) : + | succ m => + have hcoeff : coeff (m + 1) g * ((m : S) + 1) = 0 := by + have hm := congrArg (coeff m) h ++ change coeff m (derivative g) = coeff m 0 at hm + rwa [coeff_derivativeFun, map_zero] at hm + have hu : IsUnit ((m : S) + 1) := by + have hcast : ((m : S) + 1) = algebraMap ℚ S ((m : ℚ) + 1) := by push_cast; ring +@@ -359,6 +360,7 @@ theorem derivativeFun_curry_formalLogAdditivityDefect_of_star [Algebra ℚ R] + (hstar : W.invariantDifferential.subst W.formalGroupZW * pderivSnd W.formalGroupZW + = W.invariantDifferential.subst (X 1)) : + (mvPowerSeriesFinTwoCurry W.formalLogAdditivityDefect).derivativeFun = 0 := by ++ change (mvPowerSeriesFinTwoCurry W.formalLogAdditivityDefect).derivative = 0 + rw [← curry_pderivSnd, W.pderivSnd_formalLogAdditivityDefect, hstar, sub_self, map_zero] + + /-- **Log-additivity, reduced to the two geometric facts.** Combining the two reductions, the full +diff --git a/EllipticCurves/FormalGroup/Logarithm.lean b/EllipticCurves/FormalGroup/Logarithm.lean +index 341610c8b12a0f043d599c1dad58e0fcd883b502..714bb409df9c9b7875ba12029b21be0e57fb49f7 100644 +--- a/EllipticCurves/FormalGroup/Logarithm.lean ++++ b/EllipticCurves/FormalGroup/Logarithm.lean +@@ -55,7 +55,7 @@ variable {R : Type*} [CommRing R] (W : WeierstrassCurve R) + /-- The numerator of the invariant differential after cancelling the pole: + `-(2·v + z·v')` with `v = W.wCofactor`. It has constant term `-2`. -/ + noncomputable def invDiffNum : R⟦X⟧ := +- -(2 * W.wCofactor + X * derivativeFun W.wCofactor) ++ -(2 * W.wCofactor + X * derivative W.wCofactor) + + /-- The denominator of the invariant differential after cancelling the pole: + `v · (-2 + a₁ z + a₃ w)` with `v = W.wCofactor`, `w = W.formalW`. It has constant term `-2`. -/ +@@ -126,7 +126,7 @@ theorem coeff_formalLog_succ [Algebra ℚ R] (n : ℕ) : + + /-- **`log_E'(z) = ω_E(z)`.** The formal logarithm is a primitive of the invariant differential. -/ + theorem derivativeFun_formalLog [Algebra ℚ R] : +- derivativeFun W.formalLog = W.invariantDifferential := by ++ derivative W.formalLog = W.invariantDifferential := by + ext n + rw [coeff_derivativeFun, coeff_formalLog_succ] + have key : algebraMap ℚ R ((n : ℚ) + 1)⁻¹ * ((n : R) + 1) = 1 := by +diff --git a/EllipticCurves/FormalGroup/MvPowerSeriesCurry.lean b/EllipticCurves/FormalGroup/MvPowerSeriesCurry.lean +index 1b76092dceb54adc2d1b95e45b0bb220bec2646d..16c02edfa4e94e6723eeb65ff28cf888e067dd6d 100644 +--- a/EllipticCurves/FormalGroup/MvPowerSeriesCurry.lean ++++ b/EllipticCurves/FormalGroup/MvPowerSeriesCurry.lean +@@ -183,10 +183,12 @@ theorem curryFinTwoRingHom_bijective : + using this + · -- surjective + intro F +- refine ⟨fun d => PowerSeries.coeff (d 0) (PowerSeries.coeff (d 1) F), ?_⟩ ++ let φ : MvPowerSeries (Fin 2) R := ++ fun d => PowerSeries.coeff (d 0) (PowerSeries.coeff (d 1) F) ++ refine ⟨φ, ?_⟩ + refine PowerSeries.ext fun n => PowerSeries.ext fun m => ?_ +- rw [curryFinTwoRingHom_apply, coeff_coeff_curryFinTwoFun, coeff_eval, +- single_add_apply_zero, single_add_apply_one] ++ rw [curryFinTwoRingHom_apply, coeff_coeff_curryFinTwoFun, coeff_eval] ++ simp only [φ, single_add_apply_zero, single_add_apply_one] + + /-- **The currying ring isomorphism** `MvPowerSeries (Fin 2) R ≃+* PowerSeries (PowerSeries R)`. -/ + noncomputable def mvPowerSeriesFinTwoCurry : +diff --git a/EllipticCurves/FormalGroup/MvPowerSeriesPderiv.lean b/EllipticCurves/FormalGroup/MvPowerSeriesPderiv.lean +index 1861a2978b87de99d7f483f8e0b313a77cef7c7f..e3782524c382f1642d6b8c952f81b8a026bf69d3 100644 +--- a/EllipticCurves/FormalGroup/MvPowerSeriesPderiv.lean ++++ b/EllipticCurves/FormalGroup/MvPowerSeriesPderiv.lean +@@ -12,13 +12,13 @@ import EllipticCurves.FormalGroup.MvPowerSeriesCurry + # The `z₂`-partial derivative on `MvPowerSeries (Fin 2) R` + + This Mathlib pin provides the univariate formal derivative +-`PowerSeries.derivativeFun` / `PowerSeries.derivative : Derivation R R⟦X⟧ R⟦X⟧` +-but has **no** partial-derivative operator on `MvPowerSeries`. For the invariant-differential ++`PowerSeries.derivative : Derivation R R⟦X⟧ R⟦X⟧` ++and the multivariate partial derivative `MvPowerSeries.pderiv`. For the invariant-differential + argument behind log-additivity of the Weierstrass formal group + (`EllipticCurves.FormalGroup.LogAdditivity`, Silverman AEC IV.5) we need to differentiate a + bivariate series in its *second* variable `z₂`. + +-We obtain such an operator for free by transporting the univariate `derivativeFun` on the outer ++We obtain such an operator for free by transporting the univariate `derivative` on the outer + `z₂`-variable across the currying ring isomorphism + `mvPowerSeriesFinTwoCurry : MvPowerSeries (Fin 2) R ≃+* R⟦z₁⟧⟦z₂⟧` + (`EllipticCurves.FormalGroup.MvPowerSeriesCurry`; the *outer* index `1` is `z₂`, the *inner* +@@ -27,7 +27,7 @@ index `0` is `z₁`). + ## Main definitions and results + + * `MvPowerSeries.pderivSnd : MvPowerSeries (Fin 2) R → MvPowerSeries (Fin 2) R` — the `z₂`-partial +- derivative, `curry.symm ∘ derivativeFun ∘ curry`. ++ derivative, `curry.symm ∘ derivative ∘ curry`. + * `MvPowerSeries.coeff_coeff_pderivSnd` — its bigraded coefficient formula: the `z₂`-degree `n` is + bumped to `n + 1` and scaled by `n + 1`. + * Transported `Derivation`-style API: `pderivSnd_add`, `pderivSnd_zero`, `pderivSnd_smul`, +@@ -45,7 +45,7 @@ index `0` is `z₁`). + substitutable `G`, `∂_{z₂}(p(G)) = p'(G) · ∂_{z₂}G` (via `Derivation.comp_aeval_eq`). + * `MvPowerSeries.pderivSnd_subst` — the **substitution chain rule** in full generality: for a + univariate `f : R⟦X⟧` and a substitutable bivariate `G` (`constantCoeff G = 0`), +- `∂_{z₂}(f.subst G) = (f.derivativeFun.subst G) · ∂_{z₂}G`. This is the `Fin 2`-graded analogue of ++ `∂_{z₂}(f.subst G) = (f.derivative.subst G) · ∂_{z₂}G`. This is the `Fin 2`-graded analogue of + `PowerSeries.derivative_subst`, and the key calculus input for the invariant-differential form of + log-additivity (`EllipticCurves.FormalGroup.LogAdditivity`, `#315`). + +@@ -61,13 +61,13 @@ namespace MvPowerSeries + variable {R : Type*} [CommRing R] + + /-- The **`z₂`-partial derivative** on `MvPowerSeries (Fin 2) R`, defined by transporting the +-univariate `PowerSeries.derivativeFun` on the outer (`z₂`) variable across the currying ring ++univariate `PowerSeries.derivative` on the outer (`z₂`) variable across the currying ring + isomorphism `mvPowerSeriesFinTwoCurry`. -/ + noncomputable def pderivSnd (φ : MvPowerSeries (Fin 2) R) : MvPowerSeries (Fin 2) R := +- mvPowerSeriesFinTwoCurry.symm (mvPowerSeriesFinTwoCurry φ).derivativeFun ++ mvPowerSeriesFinTwoCurry.symm (mvPowerSeriesFinTwoCurry φ).derivative + + theorem curry_pderivSnd (φ : MvPowerSeries (Fin 2) R) : +- mvPowerSeriesFinTwoCurry (pderivSnd φ) = (mvPowerSeriesFinTwoCurry φ).derivativeFun := by ++ mvPowerSeriesFinTwoCurry (pderivSnd φ) = (mvPowerSeriesFinTwoCurry φ).derivative := by + rw [pderivSnd, RingEquiv.apply_symm_apply] + + /-- The bigraded coefficient of the `z₂`-partial derivative: the `z₂`-degree `n` is bumped to +@@ -75,7 +75,7 @@ theorem curry_pderivSnd (φ : MvPowerSeries (Fin 2) R) : + theorem coeff_coeff_pderivSnd (φ : MvPowerSeries (Fin 2) R) (n m : ℕ) : + PowerSeries.coeff m (PowerSeries.coeff n (mvPowerSeriesFinTwoCurry (pderivSnd φ))) + = MvPowerSeries.coeff (Finsupp.single 0 m + Finsupp.single 1 (n + 1)) φ * ((n : R) + 1) := by +- rw [curry_pderivSnd, PowerSeries.coeff_derivativeFun, ++ rw [curry_pderivSnd, PowerSeries.coeff_derivative, + show ((n : PowerSeries R) + 1) = PowerSeries.C ((n : R) + 1) by + rw [map_add, map_natCast, map_one], + PowerSeries.coeff_mul_C, coeff_coeff_mvPowerSeriesFinTwoCurry] +@@ -90,7 +90,7 @@ theorem ext_coeff_coeff {φ ψ : MvPowerSeries (Fin 2) R} + + theorem pderivSnd_add (φ ψ : MvPowerSeries (Fin 2) R) : + pderivSnd (φ + ψ) = pderivSnd φ + pderivSnd ψ := by +- rw [pderivSnd, pderivSnd, pderivSnd, map_add, PowerSeries.derivativeFun_add, map_add] ++ rw [pderivSnd, pderivSnd, pderivSnd, map_add, map_add, map_add] + + @[simp] + theorem pderivSnd_zero : pderivSnd (0 : MvPowerSeries (Fin 2) R) = 0 := by +@@ -101,12 +101,14 @@ theorem pderivSnd_zero : pderivSnd (0 : MvPowerSeries (Fin 2) R) = 0 := by + + @[simp] + theorem pderivSnd_one : pderivSnd (1 : MvPowerSeries (Fin 2) R) = 0 := by +- rw [pderivSnd, map_one, PowerSeries.derivativeFun_one, map_zero] ++ rw [pderivSnd, map_one, PowerSeries.derivative_one, map_zero] + + /-- **Leibniz rule** for the `z₂`-partial derivative. -/ + theorem pderivSnd_mul (φ ψ : MvPowerSeries (Fin 2) R) : + pderivSnd (φ * ψ) = φ * pderivSnd ψ + ψ * pderivSnd φ := by +- rw [pderivSnd, pderivSnd, pderivSnd, map_mul, PowerSeries.derivativeFun_mul, ++ -- Differentiate in the outer variable, treating inner series as coefficients. ++ let : Algebra (PowerSeries R) (PowerSeries (PowerSeries R)) := MvPowerSeries.instAlgebra ++ rw [pderivSnd, pderivSnd, pderivSnd, map_mul, Derivation.leibniz, + smul_eq_mul, smul_eq_mul, map_add, map_mul, map_mul, RingEquiv.symm_apply_apply, + RingEquiv.symm_apply_apply] + +@@ -195,7 +197,7 @@ theorem coe_pderivSndDerivation : + + /-- **Power rule** for the `z₂`-partial derivative: `∂_{z₂}(φ ^ n) = n • φ ^ (n-1) • ∂_{z₂}φ`. + This is the inductive core of the substitution chain rule `∂_{z₂}(f.subst G) +-= (f.derivativeFun.subst G) · ∂_{z₂}G`. -/ ++= (f.derivative.subst G) · ∂_{z₂}G`. -/ + theorem pderivSnd_pow (φ : MvPowerSeries (Fin 2) R) (n : ℕ) : + pderivSnd (φ ^ n) = n • φ ^ (n - 1) • pderivSnd φ := by + have h := pderivSndDerivation.leibniz_pow (a := φ) n +@@ -211,7 +213,7 @@ theorem coeff_pderivSnd (φ : MvPowerSeries (Fin 2) R) (m n : ℕ) : + + /-! ### The substitution chain rule + +-`pderivSnd (f.subst G) = (f.derivativeFun.subst G) * pderivSnd G` for a univariate `f : R⟦X⟧` and a ++`pderivSnd (f.subst G) = (f.derivative.subst G) * pderivSnd G` for a univariate `f : R⟦X⟧` and a + substitutable bivariate `G` (`constantCoeff G = 0`, i.e. `PowerSeries.HasSubst G`). We follow the + model of Mathlib's `PowerSeries.derivative_subst`: first the polynomial case via + `Derivation.comp_aeval_eq` on `pderivSndDerivation`, then the general case by a finite-truncation +@@ -225,8 +227,8 @@ derivative of `p(G)` obeys the chain rule. Immediate from `Derivation.comp_aeva + theorem pderivSnd_subst_coe {G : MvPowerSeries (Fin 2) R} (hG : PowerSeries.HasSubst G) + (p : Polynomial R) : + pderivSnd ((p : R⟦X⟧).subst G) +- = ((p : R⟦X⟧).derivativeFun.subst G) * pderivSnd G := by +- rw [PowerSeries.subst_coe hG, PowerSeries.derivativeFun_coe, PowerSeries.subst_coe hG] ++ = ((p : R⟦X⟧).derivative.subst G) * pderivSnd G := by ++ rw [PowerSeries.subst_coe hG, PowerSeries.derivative_coe, PowerSeries.subst_coe hG] + have h := pderivSndDerivation.comp_aeval_eq (a := G) p + simpa only [pderivSndDerivation_apply, smul_eq_mul] using h + +@@ -247,7 +249,7 @@ fixed bidegree to a finite truncation of `f`, apply the polynomial case `pderivS + match coefficients. -/ + theorem pderivSnd_subst {G : MvPowerSeries (Fin 2) R} (hG0 : MvPowerSeries.constantCoeff G = 0) + (f : R⟦X⟧) : +- pderivSnd (f.subst G) = f.derivativeFun.subst G * pderivSnd G := by ++ pderivSnd (f.subst G) = f.derivative.subst G * pderivSnd G := by + classical + have hG : PowerSeries.HasSubst G := PowerSeries.HasSubst.of_constantCoeff_zero hG0 + -- Replacing `h` by a high truncation does not change any coefficient of `h.subst G` in a +@@ -269,17 +271,17 @@ theorem pderivSnd_subst {G : MvPowerSeries (Fin 2) R} (hG0 : MvPowerSeries.const + obtain ⟨m, n, rfl⟩ : ∃ m n, e = Finsupp.single 0 m + Finsupp.single 1 n := + ⟨e 0, e 1, by ext i; fin_cases i <;> simp⟩ + set N := m + n + 2 with hN +- -- Coefficients of the two `derivativeFun`s agree up to degree `N - 1`. ++ -- Coefficients of the two `derivative`s agree up to degree `N - 1`. + have hder_eq : ∀ d : ℕ, d < N - 1 → +- PowerSeries.coeff d ((↑(PowerSeries.trunc N f) : R⟦X⟧).derivativeFun) +- = PowerSeries.coeff d f.derivativeFun := by ++ PowerSeries.coeff d ((↑(PowerSeries.trunc N f) : R⟦X⟧).derivative) ++ = PowerSeries.coeff d f.derivative := by + intro d hd +- rw [PowerSeries.coeff_derivativeFun, PowerSeries.coeff_derivativeFun, ++ rw [PowerSeries.coeff_derivative, PowerSeries.coeff_derivative, + PowerSeries.coeff_coe_trunc_of_lt (show d + 1 < N by omega)] + -- Hence substituting the truncated derivative agrees on small bidegrees. + have hRHSterm : ∀ e₁ : Fin 2 →₀ ℕ, Finsupp.degree e₁ ≤ m + n → +- MvPowerSeries.coeff e₁ ((↑(PowerSeries.trunc N f) : R⟦X⟧).derivativeFun.subst G) +- = MvPowerSeries.coeff e₁ (f.derivativeFun.subst G) := by ++ MvPowerSeries.coeff e₁ ((↑(PowerSeries.trunc N f) : R⟦X⟧).derivative.subst G) ++ = MvPowerSeries.coeff e₁ (f.derivative.subst G) := by + intro e₁ he₁ + rw [PowerSeries.coeff_subst hG, PowerSeries.coeff_subst hG] + refine finsum_congr fun d => ?_ +diff --git a/EllipticCurves/FormalGroup/VietaDifferential.lean b/EllipticCurves/FormalGroup/VietaDifferential.lean +index 1374be0b83aa5d36b643ea0ed18e5e1811f69c00..9ca9e822e771b49cfef19341b0055bd3fc49a42f 100644 +--- a/EllipticCurves/FormalGroup/VietaDifferential.lean ++++ b/EllipticCurves/FormalGroup/VietaDifferential.lean +@@ -67,8 +67,9 @@ theorem derivative_ofPowerSeries (f : PowerSeries R) : + simp + · lift n to ℕ using hn with m + have hidx : ((m : ℤ) + 1) = ((m + 1 : ℕ) : ℤ) := by push_cast; ring +- rw [hidx, LaurentSeries.coeff_coe_powerSeries, LaurentSeries.coeff_coe_powerSeries, +- PowerSeries.coeff_derivativeFun, zsmul_eq_mul] ++ rw [hidx, LaurentSeries.coeff_coe_powerSeries, LaurentSeries.coeff_coe_powerSeries] ++ change _ = PowerSeries.coeff m (PowerSeries.derivative f) ++ rw [PowerSeries.coeff_derivative, zsmul_eq_mul] + push_cast + ring + +diff --git a/EllipticCurves/FunctionField/CoordinateRingBaseChange.lean b/EllipticCurves/FunctionField/CoordinateRingBaseChange.lean +index d8e43bf3359d82d4e7bb541ad775d95cf81d8d33..97a3ea5a4f605ddb5146aaa1b49cea333e75a16f 100644 +--- a/EllipticCurves/FunctionField/CoordinateRingBaseChange.lean ++++ b/EllipticCurves/FunctionField/CoordinateRingBaseChange.lean +@@ -98,14 +98,18 @@ private lemma e1_trans_e2_includeRight (a : W.CoordinateRing) : + refine AdjoinRoot.ringHom_ext (RingHom.ext fun r => ?_) ?_ + · simp only [RingHom.comp_apply, AlgEquiv.coe_toAlgHom, + AlgHom.toRingHom_eq_coe, RingHom.coe_coe, AlgEquiv.trans_apply, +- Algebra.TensorProduct.includeRight_apply, e1, AdjoinRoot.tensorAlgEquiv_of, e2, +- AdjoinRoot.coe_mapAlgEquiv, AdjoinRoot.map_of, coe_polyEquivTensor'_symm, +- polyEquivTensor_symm_apply_tmul_eq_smul, one_smul, CoordinateRing.map, ++ Algebra.TensorProduct.includeRight_apply, e1, e2, ++ AdjoinRoot.coe_mapAlgEquiv, CoordinateRing.map, + AdjoinRoot.lift_of, Polynomial.coe_mapRingHom] ++ erw [AdjoinRoot.tensorAlgEquiv_of] ++ erw [AdjoinRoot.map_of, coe_polyEquivTensor'_symm, ++ polyEquivTensor_symm_apply_tmul_eq_smul, one_smul] + · simp only [RingHom.comp_apply, AlgEquiv.coe_toAlgHom, + AlgHom.toRingHom_eq_coe, RingHom.coe_coe, AlgEquiv.trans_apply, +- Algebra.TensorProduct.includeRight_apply, e1, AdjoinRoot.tensorAlgEquiv_root, e2, +- AdjoinRoot.coe_mapAlgEquiv, AdjoinRoot.map_root, CoordinateRing.map, AdjoinRoot.lift_root] ++ Algebra.TensorProduct.includeRight_apply, e1, e2, ++ AdjoinRoot.coe_mapAlgEquiv, CoordinateRing.map, AdjoinRoot.lift_root] ++ erw [AdjoinRoot.tensorAlgEquiv_root] ++ rw [AdjoinRoot.map_root] + have h := DFunLike.congr_fun key a + simp only [RingHom.comp_apply, AlgEquiv.coe_toAlgHom, + AlgHom.toRingHom_eq_coe, RingHom.coe_coe, Algebra.TensorProduct.includeRight_apply] at h +@@ -128,8 +132,7 @@ noncomputable instance instAlgebraCoordinateRingMap : + private lemma comm_one_tmul_mul (a : W.CoordinateRing) (y : K ⊗[F] W.CoordinateRing) : + (TensorProduct.comm F K W.CoordinateRing) (((1 : K) ⊗ₜ[F] a) * y) + = a • (TensorProduct.comm F K W.CoordinateRing) y := by +- induction y with +- | zero => simp ++ induction y using TensorProduct.inductionOn with + | tmul k x => + rw [Algebra.TensorProduct.tmul_mul_tmul, one_mul, TensorProduct.comm_tmul, + TensorProduct.comm_tmul, TensorProduct.smul_tmul', smul_eq_mul] +diff --git a/EllipticCurves/FunctionField/CoordinateRingNormalAlgClosed.lean b/EllipticCurves/FunctionField/CoordinateRingNormalAlgClosed.lean +index 4fd18a022c6ba3585e9061b6cd14ca120e320e0a..f26a3d417978aef34f16d51bb57dbd757e4d266e 100644 +--- a/EllipticCurves/FunctionField/CoordinateRingNormalAlgClosed.lean ++++ b/EllipticCurves/FunctionField/CoordinateRingNormalAlgClosed.lean +@@ -153,7 +153,7 @@ theorem isIntegrallyClosed_of_isAlgClosed : IsIntegrallyClosed W.CoordinateRing + IsLocalization.isNoetherianRing (XYIdeal W a (C b)).primeCompl _ inferInstance + have htfae := tfae_of_isNoetherianRing_of_isLocalRing_of_isDomain + (R := Localization.AtPrime (XYIdeal W a (C b))) +- exact ((htfae.out 4 3 rfl rfl).mp hprin).1 ++ exact ((htfae.out 5 4 rfl rfl).mp hprin).1 + + /-- **The coordinate ring of an elliptic curve over an algebraically closed field is a Dedekind + domain.** -/ +diff --git a/EllipticCurves/FunctionField/FunctionFieldGaloisDescent.lean b/EllipticCurves/FunctionField/FunctionFieldGaloisDescent.lean +index 7a2f87f15869ede95b9c7ec9d4e87318951373bd..4d4e5bc8457e7fa1e84da581b190c6205dc59417 100644 +--- a/EllipticCurves/FunctionField/FunctionFieldGaloisDescent.lean ++++ b/EllipticCurves/FunctionField/FunctionFieldGaloisDescent.lean +@@ -8,6 +8,7 @@ import EllipticCurves.FunctionField.FunctionFieldBaseChange + import EllipticCurves.FunctionField.GaloisFunctoriality + import EllipticCurves.FunctionField.MulByNPullback + import Mathlib.FieldTheory.Finite.GaloisField ++import Mathlib.FieldTheory.Galois.Infinite + + /-! + # Galois descent for the function field of a Weierstrass curve +diff --git a/EllipticCurves/FunctionField/LocalRingNormal.lean b/EllipticCurves/FunctionField/LocalRingNormal.lean +index a9ff5a72e2e72b56f9cfbf62c4ff08ccf0fb56f8..508ab6ac07eb89f058bcfcbfbc3bb9c4c24fd087 100644 +--- a/EllipticCurves/FunctionField/LocalRingNormal.lean ++++ b/EllipticCurves/FunctionField/LocalRingNormal.lean +@@ -107,7 +107,7 @@ theorem isIntegrallyClosed_localization_of_nonsingular (h : W.Nonsingular x y) + [(XYIdeal W x (C y)).IsPrime] : + IsIntegrallyClosed (Localization.AtPrime (XYIdeal W x (C y))) := by + have hiff := (tfae_of_isNoetherianRing_of_isLocalRing_of_isDomain +- (Localization.AtPrime (XYIdeal W x (C y)))).out 4 3 ++ (Localization.AtPrime (XYIdeal W x (C y)))).out 5 4 + exact (hiff.mp (maximalIdeal_isPrincipal_of_nonsingular W x y h)).1 + + /-- **Integral closedness of the coordinate ring from the closed-point classification.** If every +diff --git a/EllipticCurves/FunctionField/PlaceDegreeComparison.lean b/EllipticCurves/FunctionField/PlaceDegreeComparison.lean +index 5dc4a8a5312cfc487920d7ad47efa1186d976ab5..fa0bc9cd1c3f68a59c431e9c905c6310fab1640c 100644 +--- a/EllipticCurves/FunctionField/PlaceDegreeComparison.lean ++++ b/EllipticCurves/FunctionField/PlaceDegreeComparison.lean +@@ -254,7 +254,8 @@ theorem degPt_eq_residueDegreeProj (v : HeightOneSpectrum W.CoordinateRing) : + degPt v = residueDegreeProj W (some v) := by + haveI : v.asIdeal.IsMaximal := v.isMaximal + haveI hpmax : (v.asIdeal.under F[X]).IsMaximal := +- Ideal.isMaximal_comap_of_isIntegral_of_isMaximal v.asIdeal ++ Ideal.isMaximal_comap_of_isIntegral_of_isMaximal (algebraMap F[X] W.CoordinateRing) ++ (algebraMap_isIntegral_iff.mpr inferInstance) v.asIdeal + haveI : v.asIdeal.LiesOver (v.asIdeal.under F[X]) := ⟨rfl⟩ + haveI : IsGalois (FractionRing F[X]) W.FunctionField := isGalois_fractionRing_polynomial + have hp0 : v.asIdeal.under F[X] ≠ 0 := +diff --git a/EllipticCurves/FunctionField/PlaceOrder.lean b/EllipticCurves/FunctionField/PlaceOrder.lean +index 5ffe055ed91af3d57e10ae3ce582ec20e5c7de4c..db82cacc5f573c7013df06aa5810e115c0769884 100644 +--- a/EllipticCurves/FunctionField/PlaceOrder.lean ++++ b/EllipticCurves/FunctionField/PlaceOrder.lean +@@ -356,7 +356,8 @@ theorem divisorProj_algEquiv {f : W.FunctionField} (hf : f ≠ 0) : + divisorProj W (σ f) = (divisorProj W f).mapDomain (mapProjPoint W σ) := by + ext q + obtain ⟨p, rfl⟩ := (mapProjPoint W σ).surjective q +- rw [Finsupp.mapDomain_apply (mapProjPoint W σ).injective, divisorProj_algEquiv_apply σ hf p] ++ rw [Finsupp.mapDomain_apply_of_injective (mapProjPoint W σ).injective, ++ divisorProj_algEquiv_apply σ hf p] + + end Transport + +diff --git a/EllipticCurves/FunctionField/ProjectiveDivisor.lean b/EllipticCurves/FunctionField/ProjectiveDivisor.lean +index b6957fd3da22f2e3487c111c3718e674c15d67eb..13dd0143b5fd8c724bd12e65a638a57be3d08ba2 100644 +--- a/EllipticCurves/FunctionField/ProjectiveDivisor.lean ++++ b/EllipticCurves/FunctionField/ProjectiveDivisor.lean +@@ -138,13 +138,14 @@ noncomputable def divisorProj (f : W.FunctionField) : ProjPoint W →₀ ℤ := + @[simp] + lemma divisorProj_apply_some (f : W.FunctionField) (v : HeightOneSpectrum W.CoordinateRing) : + divisorProj W f (some v) = ord v f := by +- rw [divisorProj, Finsupp.add_apply, Finsupp.mapDomain_apply (some_injective_projPoint W), ++ rw [divisorProj, Finsupp.add_apply, ++ Finsupp.mapDomain_apply_of_injective (some_injective_projPoint W), + Finsupp.single_apply, if_neg (by simp), add_zero, divisor_apply] + + @[simp] + lemma divisorProj_apply_none (f : W.FunctionField) : + divisorProj W f none = ordInfty W f := by +- rw [divisorProj, Finsupp.add_apply, Finsupp.mapDomain_notin_range _ _ (by simp), ++ rw [divisorProj, Finsupp.add_apply, Finsupp.mapDomain_of_notMem_range _ _ (by simp), + Finsupp.single_eq_same, zero_add] + + /-- The projective divisor determines, and is determined by, the affine divisor and the order at +diff --git a/EllipticCurves/Reduction/FormalGroupTangent.lean b/EllipticCurves/Reduction/FormalGroupTangent.lean +index b4fca14466daa0a5da09bba03a588a44ab462a75..1d4cef6c9fdb2bda5a143378d73bfcf71569c1ba 100644 +--- a/EllipticCurves/Reduction/FormalGroupTangent.lean ++++ b/EllipticCurves/Reduction/FormalGroupTangent.lean +@@ -71,15 +71,15 @@ open scoped PowerSeries + yields the tangency identity for `w′ = d⁄dX w`: + `w′ = 3z² + (a₁ + 2a₂z)w + (a₁z + a₂z²)w′ + a₄w² + 2(a₃ + a₄z)w·w′ + 3a₆w²·w′`. -/ + theorem derivative_formalW : +- derivative R W.formalW ++ derivative W.formalW + = 3 * PowerSeries.X ^ 2 + + (PowerSeries.C W.a₁ + 2 * (PowerSeries.C W.a₂ * PowerSeries.X)) * W.formalW + + (PowerSeries.C W.a₁ * PowerSeries.X + PowerSeries.C W.a₂ * PowerSeries.X ^ 2) +- * derivative R W.formalW ++ * derivative W.formalW + + PowerSeries.C W.a₄ * W.formalW ^ 2 + + 2 * (PowerSeries.C W.a₃ + PowerSeries.C W.a₄ * PowerSeries.X) * W.formalW +- * derivative R W.formalW +- + 3 * (PowerSeries.C W.a₆ * W.formalW ^ 2) * derivative R W.formalW := by ++ * derivative W.formalW ++ + 3 * (PowerSeries.C W.a₆ * W.formalW ^ 2) * derivative W.formalW := by + conv_lhs => rw [W.formalW_eq, WeierstrassCurve.wOp] + simp only [map_add, Derivation.leibniz, Derivation.leibniz_pow, PowerSeries.derivative_C, + PowerSeries.derivative_X, smul_eq_mul, nsmul_eq_mul, mul_one, mul_zero, add_zero, zero_add, +@@ -100,7 +100,7 @@ variable (W : WeierstrassCurve K) [IsIntegral R W] {z : R} + /-- The `𝔪`-adic value of the formal derivative `w′` of the Weierstrass expansion at `z`, + i.e. `w′(z) = adicEval z (d⁄dX formalW)`. -/ + noncomputable def wParamDeriv (hz : z ∈ (maximalIdeal R).asIdeal) : R := +- adicEval (maximalIdeal R).asIdeal hz (PowerSeries.derivative R (integralModel R W).formalW) ++ adicEval (maximalIdeal R).asIdeal hz (PowerSeries.derivative (integralModel R W).formalW) + + omit [IsFractionRing R K] in + /-- **The tangent slope is the derivative.** On the diagonal `z₁ = z₂ = z`, the numeric chord slope +@@ -190,4 +190,3 @@ theorem thirdChordPoint_functional_eq_diag (hz : z ∈ (maximalIdeal R).asIdeal) + end Diagonal + + end WeierstrassCurve +- +diff --git a/EllipticCurves/TateModule/Continuity.lean b/EllipticCurves/TateModule/Continuity.lean +index b9af90db4906f3bd3990e43c1abbb3221f541807..cc7700b7536bc30182acaa060503881f05eeb8b1 100644 +--- a/EllipticCurves/TateModule/Continuity.lean ++++ b/EllipticCurves/TateModule/Continuity.lean +@@ -195,14 +195,14 @@ theorem Point.stabilizer_some_eq (x y : F) (h : (W'⁄F).Nonsingular x y) : + simp only [SetLike.mem_coe, MulAction.mem_stabilizer_iff, Set.mem_inter_iff] + constructor + · intro hσ +- have h' : Point.some (σ x) (σ y) ++ have h' : Point.some ((σ : F →ₐ[S] F) x) ((σ : F →ₐ[S] F) y) + ((W'.baseChange_nonsingular (σ : F →ₐ[S] F).injective ..).mpr h) = Point.some x y h := hσ +- have h₂ : σ x = x ∧ σ y = y := by simpa only [Point.some.injEq] using h' +- exact h₂ ++ exact Point.some.inj h' + · rintro ⟨hx, hy⟩ +- change Point.some (σ x) (σ y) _ = _ +- simp only [Point.some.injEq] +- exact ⟨hx, hy⟩ ++ change (σ : F →ₐ[S] F) x = x at hx ++ change (σ : F →ₐ[S] F) y = y at hy ++ change Point.some ((σ : F →ₐ[S] F) x) ((σ : F →ₐ[S] F) y) _ = _ ++ simp only [hx, hy] + + /-- **The stabiliser of a point of `E(F)` is open in the Krull topology.** This is the one fact the + whole file rests on. For the point at infinity the stabiliser is all of `G`; for an affine point it +diff --git a/EllipticCurves/Torsion/NormEDSHomogeneous.lean b/EllipticCurves/Torsion/NormEDSHomogeneous.lean +index 64dd51c0a69bc09095d1965b1b496b03fcc64373..a174cff420b4c84425fa26329a4075c12b5ab523 100644 +--- a/EllipticCurves/Torsion/NormEDSHomogeneous.lean ++++ b/EllipticCurves/Torsion/NormEDSHomogeneous.lean +@@ -4,6 +4,8 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: The Elliptic Curves formalisation contributors + -/ + import Mathlib.NumberTheory.EllipticDivisibilitySequence ++import Mathlib.Tactic.LinearCombination ++import Mathlib.Tactic.Ring + + /-! + # `normEDS` is weighted-homogeneous: the scaling law of a normalised EDS +diff --git a/EllipticCurves/Torsion/TwoTorsionSplittingField.lean b/EllipticCurves/Torsion/TwoTorsionSplittingField.lean +index 777c85ff15f0e13eb77b78de23039b6516b45871..672913ad140239a059242e6f40c4622f3304de79 100644 +--- a/EllipticCurves/Torsion/TwoTorsionSplittingField.lean ++++ b/EllipticCurves/Torsion/TwoTorsionSplittingField.lean +@@ -129,7 +129,8 @@ theorem separable_Ψ₂Sq [W.IsElliptic] (h2 : (2 : F) ≠ 0) : W.Ψ₂Sq.Separa + (W.Ψ₂Sq_ne_zero (four_ne_zero_of_two_ne_zero h2)) hsplits).mp ?_ + have hnodup := (Cubic.discr_ne_zero_iff_roots_nodup + (φ := algebraMap F W.Ψ₂Sq.SplittingField) ha (by rw [← Ψ₂Sq_eq]; exact hsplits)).mp hd +- simpa [Polynomial.aroots, Cubic.roots, Cubic.map_toPoly, Ψ₂Sq_eq] using hnodup ++ rw [Cubic.map_roots] at hnodup ++ simpa only [Polynomial.aroots, Ψ₂Sq_eq] using hnodup + + /-! ## A splitting field of the `2`-torsion cubic -/ + +diff --git a/EllipticCurves/Torsion/WardR1.lean b/EllipticCurves/Torsion/WardR1.lean +index c65eb7cc2ff727ff8c7595d7a62e7839b5f2de42..137ae92b5b6b3f9eafe49e350246dd04c5efb00b 100644 +--- a/EllipticCurves/Torsion/WardR1.lean ++++ b/EllipticCurves/Torsion/WardR1.lean +@@ -332,7 +332,7 @@ lemma normEDS_univ_ne_zero (n : ℤ) (hn : n ≠ 0) : + have hφ := map_normEDS (aeval ![(2 : ℤ), 3, 2] : UnivEDS →ₐ[ℤ] ℤ) (X 0 : UnivEDS) (X 1) (X 2) n + rw [h, map_zero] at hφ + norm_num [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons] at hφ +- rw [show (![(2 : ℤ), 3, 2] 2) = 2 from rfl, normEDS_two_three_two] at hφ ++ rw [normEDS_two_three_two] at hφ + exact hn hφ.symm + + end Universal +diff --git a/lake-manifest.json b/lake-manifest.json +index e2a21bd49d1aada1485597e9d77ae656791a657a..61f2046f73871c3929c5d81e209ef36dcc8bb0e5 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,21 +1,21 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/leanprover-community/mathlib4", ++ [{"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -25,7 +25,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -35,7 +35,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +45,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -65,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -75,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -85,10 +85,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "elliptic_curves", +diff --git a/lakefile.toml b/lakefile.toml +index dadf0adbfa50fd51667ecfe8437532db8e80d3ad..0b302539c60ea7bfa08b95792c32bf7ab7d94de2 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -13,6 +13,8 @@ defaultTargets = ["EllipticCurves"] + lintDriver = "batteries/runLinter" + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -20,8 +22,8 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "EllipticCurves" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/fixed-point-theorems-lean4341.patch b/lean/patches/fixed-point-theorems-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..0768f6230000f65206a0aab892a78e9981f9045f --- /dev/null +++ b/lean/patches/fixed-point-theorems-lean4341.patch @@ -0,0 +1,640 @@ +diff --git a/FixedPointTheorems/apply_cubical_sperner.lean b/FixedPointTheorems/apply_cubical_sperner.lean +index ffbbbcd..5737a7c 100644 +--- a/FixedPointTheorems/apply_cubical_sperner.lean ++++ b/FixedPointTheorems/apply_cubical_sperner.lean +@@ -1,17 +1,17 @@ +- +- +-import Mathlib.Analysis.Convex.Intrinsic +-import Mathlib.Topology.Defs.Basic ++import Mathlib + import FixedPointTheorems.cubical_sperner + +-open Classical ++/-! ++# Fixed points in the unit cube + +-/- +-shows the fixed-point theorem for the unit cube +-by applying the cubical sperner's lemma ++Reduced labels encode coordinatewise displacement of a continuous cube map. ++Cubical Sperner simplices on finer grids yield approximate fixed points, and ++compactness of the cube supplies a genuine fixed point. + -/ + + ++open Classical ++ + variable {n : ℕ} + + def unit_cube := { v : Fin n → ℝ | 0 ≤ v ∧ v ≤ 1 } +@@ -131,7 +131,7 @@ lemma reduced_label_props_3 (f : @unit_cube n → @unit_cube n) (x : @unit_cube + noncomputable def discrete_map (p : ℕ ) (v : Fin n → Fin (p+1)) : @unit_cube n := + ⟨ fun i ↦ ((v i).1 : ℝ ) / p , by { + unfold unit_cube +- simp only [Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq] + rw [Pi.le_def, Pi.le_def, ←forall_and] + intro i + simp only [Pi.zero_apply, Pi.one_apply] +@@ -228,7 +228,6 @@ lemma nearby_points (f : @unit_cube n → @unit_cube n) (p0:ℕ): + exact ⟨h5 i0 ik k, h5 ik i0 k⟩ + } + +- + theorem fixed_point_unit_cube (f : C(@unit_cube n, @unit_cube n)) : ∃ x, f x = x := by { + obtain ⟨x0s, hx0⟩ := axiomOfChoice (nearby_points f) + have hc1 : ∃ xx : @unit_cube n, ∃ (φ:ℕ → ℕ ), StrictMono φ ∧ +@@ -281,7 +280,6 @@ theorem fixed_point_unit_cube (f : C(@unit_cube n, @unit_cube n)) : ∃ x, f x = + apply le_antisymm (h4 k) (h3 k) + } + +-/-- The cubical fixed-point theorem stated with mathlib's `Function.IsFixedPt` vocabulary. -/ + theorem fixed_point_unit_cube_isFixedPt (f : C(@unit_cube n, @unit_cube n)) : + ∃ x, Function.IsFixedPt f x := by +- simpa [Function.IsFixedPt] using fixed_point_unit_cube f ++ simpa [Function.IsFixedPt] using! fixed_point_unit_cube f +diff --git a/FixedPointTheorems/brouwer.lean b/FixedPointTheorems/brouwer.lean +index 7384d5b..23eaf4b 100644 +--- a/FixedPointTheorems/brouwer.lean ++++ b/FixedPointTheorems/brouwer.lean +@@ -1,16 +1,13 @@ +- +- ++import Mathlib + import FixedPointTheorems.apply_cubical_sperner + import FixedPointTheorems.convex_homeos +-import Mathlib.Dynamics.FixedPoints.Basic +- +- + +-/- Brouwer fixed-point theorem: +-Every continuous function mapping a nonempty compact convex set to itself has a fixed point +-(the set should be a subset of a finite dimensional vector space). ++/-! ++# Brouwer's fixed-point theorem + +-https://en.wikipedia.org/wiki/Brouwer_fixed-point_theorem ++The unit-cube fixed-point theorem is transported along a homeomorphism of a ++nonempty compact convex set. The resulting theorem is also expressed using ++`Function.IsFixedPt` and the set of fixed points. + -/ + + +@@ -27,15 +24,13 @@ theorem brouwer_fixed_point {V : Type*} + rwa [e.symm_apply_apply] at h1 + } + +-/-- Brouwer's fixed-point theorem stated with mathlib's `Function.IsFixedPt` vocabulary. -/ + theorem brouwer_fixed_point_isFixedPt {V : Type*} + [NormedAddCommGroup V] [NormedSpace ℝ V] [FiniteDimensional ℝ V] + (s : Set V) (hcvx : Convex ℝ s) (hcmpct : IsCompact s) (hne : Set.Nonempty s) + (f : C(s, s)) : + ∃ x, Function.IsFixedPt f x := by +- simpa [Function.IsFixedPt] using brouwer_fixed_point s hcvx hcmpct hne f ++ simpa [Function.IsFixedPt] using! brouwer_fixed_point s hcvx hcmpct hne f + +-/-- The fixed-point set of a continuous self-map on a Brouwer domain is nonempty. -/ + theorem brouwer_fixedPoints_nonempty {V : Type*} + [NormedAddCommGroup V] [NormedSpace ℝ V] [FiniteDimensional ℝ V] + (s : Set V) (hcvx : Convex ℝ s) (hcmpct : IsCompact s) (hne : Set.Nonempty s) +diff --git a/FixedPointTheorems/convex_homeos.lean b/FixedPointTheorems/convex_homeos.lean +index 944544a..947627c 100644 +--- a/FixedPointTheorems/convex_homeos.lean ++++ b/FixedPointTheorems/convex_homeos.lean +@@ -1,10 +1,11 @@ ++import Mathlib + +-import Mathlib.Analysis.Convex.Intrinsic +-import Mathlib.Analysis.Convex.GaugeRescale ++/-! ++# Homeomorphisms of compact convex sets + +- +-/- +-some helper lemmas involving homeomorphisms. ++Compact convex sets are reduced to unit balls in their affine spans and then to ++finite-dimensional cubes. These homeomorphisms transfer the cubical fixed-point ++theorem to arbitrary nonempty compact convex domains. + -/ + + +@@ -24,7 +25,6 @@ lemma homeo_unit_ball {V : Type*} + exact Nonempty.intro e2 + } + +- + theorem homeo_of_finrank_eq {V W : Type*} + [NormedAddCommGroup V] [NormedSpace ℝ V] [FiniteDimensional ℝ V] + [NormedAddCommGroup W] [NormedSpace ℝ W] [FiniteDimensional ℝ W] +@@ -58,7 +58,6 @@ theorem homeo_of_finrank_eq {V W : Type*} + exact e2.symm.trans e1 + } + +- + lemma unit_cube_homeo_unit_ball {n} + : Nonempty (Set.Icc (0 : Fin n → ℝ) 1 ≃ₜ Metric.closedBall (0 : Fin n → ℝ) 1 ) := by + apply homeo_unit_ball _ (convex_Icc 0 1) isCompact_Icc +@@ -72,7 +71,7 @@ lemma homeo_unit_cube_of_convex_compact {V : Type*} + [NormedAddCommGroup V] [NormedSpace ℝ V] [FiniteDimensional ℝ V] + (s: Set V) (hcvx : Convex ℝ s) (hcmpct : IsCompact s) (hne : s.Nonempty) + : ∃ k, Nonempty (s ≃ₜ Set.Icc (0 : Fin k → ℝ) 1) := by { +- haveI := hne.coe_sort ++ have := hne.coe_sort + let W := affineSpan ℝ s + obtain ⟨ps, hps⟩ := hne + let pss : W := ⟨ps, mem_affineSpan ℝ hps⟩ +diff --git a/FixedPointTheorems/cubical_sperner.lean b/FixedPointTheorems/cubical_sperner.lean +index 0380c46..9bc9535 100644 +--- a/FixedPointTheorems/cubical_sperner.lean ++++ b/FixedPointTheorems/cubical_sperner.lean +@@ -1,19 +1,25 @@ +- ++import Mathlib + import FixedPointTheorems.cubical_sperner_prep + ++/-! ++# The cubical Sperner lemma + +-open Classical ++Boundary incidence counts give an odd number of completely labelled simplices. ++The induction restricts a labelled cube to its boundary face; the resulting ++existence theorem supplies the simplices used in the fixed-point argument. ++-/ + + ++open Classical + + section completeness + + lemma complete_simplex_iff {SC} m I(hs : simplex SC m I) : +- complete_simplex SC m I ↔ ∀ c, c≤m → ∃ i, SC.RL (I i) = c := by { ++ complete_simplex SC m I ↔ ∀ c, c ≤ m → ∃ i, SC.RL (I i) = c := by { + apply Iff.intro + { + intro h1 c hc +- rwa [← Set.mem_range, h1.2, Set.mem_setOf_eq] ++ rwa [← Set.mem_range, h1.2, Set.mem_ofPred_eq] + } + { + intro c1 +@@ -33,7 +39,7 @@ lemma complete_simplex_iff {SC} m I(hs : simplex SC m I) : + Set.mem_range] at h1 + obtain ⟨ i, hi⟩ := h1 + use i +- simp only [Set.coe_toFinset, Set.mem_setOf_eq] ++ simp only [Set.coe_toFinset, Set.mem_ofPred_eq] + apply And.intro (Fin.is_le i) + unfold f1 + rw [← hi] +@@ -41,7 +47,6 @@ lemma complete_simplex_iff {SC} m I(hs : simplex SC m I) : + } + } + +- + lemma rl_inj_of_complete {SC} m I (hcs : complete_simplex SC m I): + ∀ i1 i2, SC.RL (I i1) = SC.RL (I i2) → i1 = i2 := by { + let f1 : Fin (m+1) → Fin (m+1) := fun j ↦ Fin.ofNat _ (SC.RL (I j)) +@@ -63,7 +68,6 @@ lemma rl_inj_of_complete {SC} m I (hcs : complete_simplex SC m I): + exact Fin.cast_val_eq_self c + } + +- + lemma char_complete_face {SC n1 hn1} I J (hs : simplex SC SC.n J) : + complete_simplex SC n1 I ∧ is_face SC I J + ↔ ∃ i, I = @delete_vertex SC n1 hn1 i J +@@ -107,12 +111,11 @@ lemma char_complete_face {SC n1 hn1} I J (hs : simplex SC SC.n J) : + } + } + +- + lemma complete_child_uniq {SC n1} {hn1 : n1 + 1 = SC.n} J (hcs : complete_simplex SC SC.n J) : + ∃! (I : Fin (n1+1) → SC.G), complete_simplex SC n1 I ∧ is_face SC I J := by { + have h4 : ∃ i, SC.RL (J i) = SC.n := by { + rw [← Set.mem_range, hcs.2] +- simp only [Set.mem_setOf_eq, le_refl] ++ simp only [Set.mem_ofPred_eq, le_refl] + } + obtain ⟨ i, hi⟩ := h4 + let I := @delete_vertex SC n1 hn1 i J +@@ -168,7 +171,6 @@ lemma complete_child_uniq {SC n1} {hn1 : n1 + 1 = SC.n} J (hcs : complete_simple + exact (Eq.symm hi) + } + +- + lemma incomplete_childs {SC n1} {hn1 : n1 + 1 = SC.n} J (hs : simplex SC SC.n J) + (hnc : ¬ complete_simplex SC SC.n J): + Even (Finset.card { I : Fin (n1 + 1) → SC.G | complete_simplex SC n1 I ∧ is_face SC I J}) := by { +@@ -282,7 +284,6 @@ lemma incomplete_childs {SC n1} {hn1 : n1 + 1 = SC.n} J (hs : simplex SC SC.n J) + } + } + +- + lemma complete_boundary_face_last {SC n1} {hn1 : n1 + 1 = SC.n} (I : Fin (n1 + 1) → SC.G) + (hcbf : complete_boundary_face SC I) : + ∀ i, ∀ j, j.1 + 1 = SC.n → (I i j).1 = SC.p := by { +@@ -293,7 +294,7 @@ lemma complete_boundary_face_last {SC n1} {hn1 : n1 + 1 = SC.n} (I : Fin (n1 + 1 + have h4 : ∀ n2, n2 ≤ n1 → ∃ i, SC.RL (I i) = n2 := by { + intro n2 hn2 + rw [← Set.mem_range, hcbf.2.2] +- simp only [Set.mem_setOf_eq, hn2] ++ simp only [Set.mem_ofPred_eq, hn2] + } + have h6 (j2 : Fin SC.n) : j2.1 ≤ n1 := by omega + cases h3 +@@ -328,8 +329,6 @@ lemma complete_boundary_face_last {SC n1} {hn1 : n1 + 1 = SC.n} (I : Fin (n1 + 1 + + end completeness + +- +- + section handshake + + variable {A B : Type*} +@@ -385,7 +384,7 @@ lemma handshake_1 (r : A → B → Prop) + { + intro p2 + have p3 := h3 a (h6 a p1) +- simp only [Set.mem_setOf_eq] at p3 ++ simp only [Set.mem_ofPred_eq] at p3 + cases p3 + rename_i p4 + exact p4 +@@ -415,7 +414,7 @@ lemma handshake_1 (r : A → B → Prop) + intro p2 + have p5 : Finset.Nonempty {a | r2 a b} := by { + have p3 : Odd (Finset.card { a | r2 a b}) := by { +- convert p2 ++ convert! p2 + } + apply Finset.card_ne_zero.mp + intro p4 +@@ -432,15 +431,13 @@ lemma handshake_1 (r : A → B → Prop) + revert p2 + have p4 := h2 b p3 p1 + simp only [imp_false, Nat.not_odd_iff_even] +- convert p4 ++ convert! p4 + } + } + } + + end handshake + +- +- + lemma odd_of_boundary_faces SC {n1} {hn1 : n1 + 1 = SC.n}: + Odd (Finset.card { I : Fin (n1 + 1) → SC.G | complete_boundary_face SC I}) + → Odd (Finset.card { I | complete_simplex SC SC.n I}) := by { +@@ -456,13 +453,11 @@ lemma odd_of_boundary_faces SC {n1} {hn1 : n1 + 1 = SC.n}: + exact fun _ _ h1 ↦ h1.2.1 + } + +- + section induction_step + + variable (SC : SpernerCube) + variable {n1 : ℕ} + +- + def child_map (v : Fin n1 → Fin (SC.p+1) ) : SC.G := fun i ↦ + match n1 with + | 0 => Fin.last SC.p +@@ -587,10 +582,8 @@ def child_cube {hn1 : n1 + 1 = SC.n}: SpernerCube where + exact hn1 + } + +- + end induction_step + +- + lemma induction_start (SC : SpernerCube) (h0 : 0 = SC.n) + : Odd (Finset.card { I | complete_simplex SC SC.n I}) := by { + use 0 +@@ -625,7 +618,7 @@ lemma induction_start (SC : SpernerCube) (h0 : 0 = SC.n) + { + ext i + simp only [← h0] +- simp only [Set.mem_range, nonpos_iff_eq_zero, Set.setOf_eq_eq_singleton, Set.mem_singleton_iff] ++ simp only [Set.mem_range, nonpos_iff_eq_zero, Set.ofPred_eq_eq_singleton, Set.mem_singleton_iff] + have h3 : ∀ c, SC.RL (a c) = 0 := by { + intro c + have h2 := (SC.rl_proper (a c)).1 +@@ -727,6 +720,9 @@ theorem strong_cubical_sperner (k: ℕ ) : ∀ (SC : SpernerCube), k = SC.n → + rw [← hk1] + rfl + } ++ change (I (Fin.ofNat (k + 1) i) j).val ≤ ++ (I (Fin.ofNat (k + 1) (i + 1)) j).val ∧ ++ (I (Fin.last k) j).val ≤ (I 0 j).val + 1 + rw [← h6, ← h6, ←h6, ← h6] + exact h4 (Fin.ofNat _ j.1) + } +@@ -770,13 +766,16 @@ theorem strong_cubical_sperner (k: ℕ ) : ∀ (SC : SpernerCube), k = SC.n → + } + exact Eq.congr_right rfl + } ++ change ∀ I, complete_boundary_face SC1 (f2 I) ↔ complete_simplex SC2 k I at hcomp ++ change ({I : Fin (k + 1) → SC2.G | complete_simplex SC2 k I} : Finset _).card = ++ ({I : Fin (k + 1) → SC1.G | complete_boundary_face SC1 I} : Finset _).card + apply Finset.card_nbij f2 + { + intro I hI +- have hI' : complete_simplex SC2 SC2.n I := +- (Finset.mem_filter.mp (Finset.mem_coe.mp hI)).2 +- exact Finset.mem_coe.mpr +- (Finset.mem_filter.mpr ⟨Finset.mem_univ _, (hcomp I).mpr hI'⟩) ++ have hI' : complete_simplex SC2 k I := by ++ simpa only [Finset.mem_coe, Finset.mem_filter, Finset.mem_univ, true_and] using hI ++ simpa only [Finset.mem_coe, Finset.mem_filter, Finset.mem_univ, true_and] ++ using (hcomp I).mpr hI' + } + { + intro I1 h41 I2 h42 h5 +@@ -787,7 +786,7 @@ theorem strong_cubical_sperner (k: ℕ ) : ∀ (SC : SpernerCube), k = SC.n → + { + simp only [Finset.coe_filter, Finset.mem_univ, true_and] + intro J +- simp only [Set.mem_setOf_eq, Set.mem_image] ++ simp only [Set.mem_ofPred_eq, Set.mem_image] + intro h3 + have h4 : ∃ I, f2 I = J := by { + suffices h6 : ∀ i, ∃ ii, f1 ii = J i by { +@@ -804,8 +803,8 @@ theorem strong_cubical_sperner (k: ℕ ) : ∀ (SC : SpernerCube), k = SC.n → + obtain ⟨I, h4⟩ := h4 + use I + simp only [h4, and_true] +- exact Finset.mem_coe.mpr (Finset.mem_filter.mpr +- ⟨Finset.mem_univ I, (hcomp I).mp (h4 ▸ h3)⟩) ++ simpa only [Finset.mem_coe, Finset.mem_filter, Finset.mem_univ, true_and] ++ using (hcomp I).mp (h4 ▸ h3) + } + } + +diff --git a/FixedPointTheorems/cubical_sperner_prep.lean b/FixedPointTheorems/cubical_sperner_prep.lean +index 243b3db..4edc1b7 100644 +--- a/FixedPointTheorems/cubical_sperner_prep.lean ++++ b/FixedPointTheorems/cubical_sperner_prep.lean +@@ -1,15 +1,15 @@ ++import Mathlib + +-import Mathlib.Combinatorics.Enumerative.DoubleCounting +-import Mathlib.Algebra.BigOperators.Ring.Nat +-import Mathlib.Tactic ++/-! ++# Cubical simplices and boundary incidence + +-open Classical ++The grid simplices of a labelled cube are classified by their boundary coordinates. ++Coordinate-change counts order their vertices and determine the number of parent simplices, ++providing the incidence identities used in the cubical Sperner argument. ++-/ + + +-/- +-The Cubical Sperner's Lemma. +-We mostly follow Kuhn 1960 "Some Combinatorial Lemmas in Topology" +--/ ++open Classical + + structure SpernerCube where + n : ℕ +@@ -32,7 +32,6 @@ variable (SC : SpernerCube) + variable {n1 : ℕ} + variable {hn1 : n1 + 1 = SC.n} + +- + def simplex (m:ℕ ) (I : Fin (m+1)→ SC.G) := Function.Injective I + ∧ ∀ i < m, ∀ j : Fin SC.n, (I (Fin.ofNat _ i) j).1 ≤ (I (Fin.ofNat _ (i+1)) j).1 + ∧ (I (Fin.last m) j).1 ≤ (I 0 j).1 + 1 +@@ -56,7 +55,6 @@ def case_C (I : Fin (n1 +1) → SC.G) := + + def case_D (I : Fin (n1 +1) → SC.G) := ∀ j, ∀ q, ∃ k,I k j ≠ q + +- + lemma one_of_ABCD (I : Fin (n1 +1) → SC.G) : + case_A SC I ∨ case_B SC I ∨ case_C SC I ∨ case_D SC I := by { + by_cases h1 : case_D SC I +@@ -83,10 +81,8 @@ lemma one_of_ABCD (I : Fin (n1 +1) → SC.G) : + use j, q + } + +- + section simplex_properties + +- + lemma monotone_1_of_simplex {m:ℕ } (I : Fin (m+1)→ SC.G) (hs : simplex SC m I) (i1 i2 : Fin (m+1)) + (h1 : i1 ≤ i2) : ∀ j, I i1 j ≤ I i2 j := by { + intro j +@@ -98,7 +94,7 @@ lemma monotone_1_of_simplex {m:ℕ } (I : Fin (m+1)→ SC.G) (hs : simplex SC m + intro i1 + have h3 := (hs.2 i1.1 i1.2 j).1 + simp only [Fin.val_fin_le] at h3 +- convert h3 <;> ext <;> simp [Fin.ofNat_eq_cast, Nat.mod_eq_of_lt] ++ convert! h3 <;> ext <;> simp [Fin.ofNat_eq_cast, Nat.mod_eq_of_lt] + } + + lemma monotone_2_of_simplex {m:ℕ } (I : Fin (m+1)→ SC.G) (hs : simplex SC m I) (i1 i2 : Fin (m+1)) : +@@ -141,7 +137,6 @@ lemma le_add_one_of_simplex {m: ℕ} I (hs : simplex SC m I) (i1 i2 : Fin (m+1)) + + end simplex_properties + +- + lemma p_ne_zero_of_cube {hn1 : n1 + 1 = SC.n}: Fin.last SC.p ≠ 0 := by { + simp only [ne_eq, Fin.last_eq_zero_iff] + intro h1 +@@ -156,10 +151,8 @@ lemma p_ne_zero_of_cube {hn1 : n1 + 1 = SC.n}: Fin.last SC.p ≠ 0 := by { + exact h2.1 h4 (h2.2 h4) + } + +- + section simplex_child + +- + def insert_index (j : Fin (SC.n+1)) (a: Fin (n1 +1 )) : Fin (SC.n+1) := + { val := if a.val < j.val then a.val else a.val+1, + isLt := by { +@@ -271,7 +264,6 @@ lemma insert_index_inj j : Function.Injective (@insert_index SC n1 hn1 j) := by + apply insert_index_strict_mono + } + +- + lemma delete_vertex_inj J {hs : simplex SC SC.n J} i1 i2 + (h1 : @delete_vertex SC n1 hn1 i1 J = @delete_vertex SC n1 hn1 i2 J ) : i1 = i2 := by { + by_contra h2 +@@ -441,7 +433,6 @@ lemma child_simplex_char (I : Fin (n1 +1) → SC.G) J {hs : simplex SC SC.n J} + + end simplex_child + +- + section cases_ABCD + + lemma insert_vertex I (v : SC.G) j : +@@ -702,7 +693,7 @@ lemma parent_simplex_case_D I (hs : simplex SC n1 I) J j i + } + by_cases h8 : i2 = j.1 + { +- convert h5.2 ++ convert! h5.2 + simp only [h8, Fin.cast_val_eq_self] + have h11 : j ≠ Fin.last SC.n := by { + suffices h12 : j.1 ≠ SC.n by exact Ne.symm (Fin.ne_of_val_ne (Ne.symm h12)) +@@ -717,7 +708,7 @@ lemma parent_simplex_case_D I (hs : simplex SC n1 I) J j i + { + rw [←h9] at h6 + simp only [Nat.add_right_cancel_iff] at h6 +- convert h5.1 ++ convert! h5.1 + rw [←h6] + simp only [Fin.cast_val_eq_self] + rw [h9] +@@ -786,8 +777,7 @@ lemma parent_simplex_case_D I (hs : simplex SC n1 I) J j i + } + } + +- +-def coord_change_count (v1 v2 : SC.G) := Finset.card {i | v1 i ≠ v2 i} ++noncomputable def coord_change_count (v1 v2 : SC.G) := Finset.card {i | v1 i ≠ v2 i} + + lemma ccc_add {m} I (hs : simplex SC m I) (i1 i2 i3) (h1 : i1 ≤ i2 ∧ i2 ≤ i3) : + coord_change_count SC (I i1) (I i3) = +@@ -842,7 +832,7 @@ lemma ccc_pos {m} I (hs : simplex SC m I) i1 i2 (h1 : i1 ≠ i2) + apply h2 + } + +-def ccc_fun {m} (I : Fin (m+1)→ SC.G) (i : Fin (m+1)) : Fin (SC.n + 1 ) ++noncomputable def ccc_fun {m} (I : Fin (m+1)→ SC.G) (i : Fin (m+1)) : Fin (SC.n + 1 ) + := ⟨ coord_change_count SC (I 0) (I i), by { + refine Nat.lt_succ_of_le ?_ + exact card_finset_fin_le {i_1 | I 0 i_1 ≠ I i i_1} +@@ -865,18 +855,15 @@ lemma ccc_fun_is_insert_index I (hs : simplex SC n1 I) : + apply ccc_fun_strict_mono SC I hs + } + +- +- + lemma ccc_fun_case_D_iff {m} I (hs : simplex SC m I) : + case_D SC I ↔ ccc_fun SC I (Fin.last m) = Fin.last SC.n := by { + have h1 : (ccc_fun SC I (Fin.last m) = Fin.last SC.n) ↔ ∀ k, I 0 k ≠ I (Fin.last m) k := by { +- unfold ccc_fun coord_change_count +- rw [Fin.mk.inj_iff] +- have h3 : SC.n = Fintype.card (Fin SC.n) := by {exact Eq.symm (Fintype.card_fin SC.n)} +- simp only [ne_eq, Fin.val_last] +- nth_rewrite 7 [h3] +- rw [Finset.card_eq_iff_eq_univ, Finset.eq_univ_iff_forall] +- simp only [Finset.mem_filter, Finset.mem_univ, true_and] ++ rw [Fin.ext_iff] ++ change Finset.card {k : Fin SC.n | I 0 k ≠ I (Fin.last m) k} = SC.n ↔ _ ++ have hcard := Finset.card_eq_iff_eq_univ ++ {k : Fin SC.n | I 0 k ≠ I (Fin.last m) k} ++ simpa only [Fintype.card_fin, Finset.eq_univ_iff_forall, ++ Finset.mem_filter, Finset.mem_univ, true_and] using hcard + } + apply Iff.trans _ h1.symm + unfold case_D +@@ -1068,7 +1055,6 @@ lemma same_delete_index_eq_iff J1 J2 j + exact congrFun h1 i1 + } + +- + lemma case_D_parent_count {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) (h1 : case_D SC I ) + : Finset.card { J : Fin (SC.n + 1) → SC.G | is_face SC I J} = 2 := by { + obtain ⟨ j1, hj1 ⟩ := @ccc_fun_is_insert_index SC n1 hn1 I hs +@@ -1115,7 +1101,7 @@ lemma case_D_parent_count {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) (h1 : c + have h4 : ∃ k1, ∃ k2, k1 ≠ k2 ∧ {k | I i1 k ≠ I (i1 +1) k} = {k1, k2} := by { + unfold coord_change_count at h3 + rw [Finset.card_eq_two] at h3 +- convert h3 ++ convert! h3 + simp only [ne_eq] + rw [←Finset.coe_eq_pair] + simp only [Finset.coe_filter, Finset.mem_univ, true_and] +@@ -1304,7 +1290,6 @@ lemma case_D_parent_count {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) (h1 : c + } + } + +- + lemma unique_const_ABC {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) k1 q1 + (h1 : ∀ i, I i k1 = q1): ∀ k2, k1 ≠ k2 → I 0 k2 ≠ I (Fin.last n1) k2 := by { + intro k2 h3 h2 +@@ -1336,7 +1321,6 @@ lemma unique_const_ABC {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) k1 q1 + simp only [Nat.not_ofNat_le_one] at h7 + } + +- + lemma case_AC_ex_unique I (hs : simplex SC n1 I) k1 q + (hABC : ∀ i, I i k1 = q) (hAC : q ≠ Fin.last SC.p) + : ∃! J, I = @delete_vertex SC n1 hn1 (Fin.last SC.n) J ∧ is_face SC I J := by { +@@ -1422,7 +1406,6 @@ lemma case_B_not_last I (h1 : case_B SC I) J + exact lt_add_one SC.p + } + +- + lemma case_BC_ex_unique I (hs : simplex SC n1 I) k1 q + (hABC : ∀ i, I i k1 = q) (hBC : q ≠ 0) + : ∃! J, I = @delete_vertex SC n1 hn1 0 J ∧ is_face SC I J := by { +@@ -1503,8 +1486,6 @@ lemma case_A_not_zero I (h1 : case_A SC I) J + rfl + } + +- +- + lemma case_ABC_count_disj {hn1 : n1 + 1 = SC.n} I k1 q + (hABC : ∀ i, I i k1 = q) : Finset.card { J | is_face SC I J} + = Finset.card {J | I = @delete_vertex SC n1 hn1 0 J ∧ is_face SC I J} +@@ -1546,7 +1527,6 @@ lemma case_ABC_count_disj {hn1 : n1 + 1 = SC.n} I k1 q + rw [←h2.1,←h3.1] + } + +- + lemma case_C_parent_count {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) (h1 : case_C SC I ) + : Finset.card { J : Fin (SC.n + 1) → SC.G | is_face SC I J} = 2 := by { + obtain ⟨k1,q, h1⟩ := h1 +@@ -1587,7 +1567,6 @@ lemma case_A_parent_count {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) (h2 : c + + end cases_ABCD + +--- used in other file + lemma boundary_is_A_or_B {hn1 : n1 + 1 = SC.n} I (hbf : @is_boundary_face SC n1 I) + : case_A SC I ∨ case_B SC I := by { + have hs : simplex SC n1 I := by { +@@ -1607,16 +1586,13 @@ lemma boundary_is_A_or_B {hn1 : n1 + 1 = SC.n} I (hbf : @is_boundary_face SC n1 + simp only [OfNat.ofNat_ne_one] at hbf + } + +--- used in other file + lemma case_B_boundary {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) + (h1 : case_B SC I) : is_boundary_face SC I := + (Fintype.existsUnique_iff_card_one _).mpr (@case_B_parent_count SC n1 hn1 I hs h1) + +- +--- used in other file + lemma parent_count {hn1 : n1 + 1 = SC.n} I (hs : simplex SC n1 I) : + Finset.card { J : Fin (SC.n + 1) → SC.G | is_face SC I J} ∈ {c | c = 1 ∨ c = 2} := by { +- simp only [Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq] + have h1 := one_of_ABCD SC I + rw [←or_assoc] at h1 + cases' h1 with h1 h1 +diff --git a/lakefile.toml b/lakefile.toml +index 936ece4..186ed66 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -10,8 +10,8 @@ autoImplicit = false + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "FixedPointTheorems" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f49..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/formal-schemes-lean4341.patch b/lean/patches/formal-schemes-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..c8a6d0f69af2045dc7637ebd023219ff6d26a833 --- /dev/null +++ b/lean/patches/formal-schemes-lean4341.patch @@ -0,0 +1,193 @@ +diff --git a/FormalSchemes/AdicCompletionLimit.lean b/FormalSchemes/AdicCompletionLimit.lean +index d778fcade8f85bf6d12f3cccdf148af42c52c5dd..b1b66cd19c24e883c264f0adfac65aa0d853a48b 100644 +--- a/FormalSchemes/AdicCompletionLimit.lean ++++ b/FormalSchemes/AdicCompletionLimit.lean +@@ -79,7 +79,6 @@ theorem quotientTower_map {m n : ℕ} (hmn : m ≤ n) : + (homOfLE (Nat.le_add_right n 1)).op ≫ (homOfLE hmn).op from Subsingleton.elim _ _, + CategoryTheory.Functor.map_comp, quotientTower_map_succ, ih] + apply CommRingCat.hom_ext +- simp only [CommRingCat.hom_comp] + exact Ideal.Quotient.factor_comp (Ideal.pow_le_pow_right (Nat.le_succ n)) + (Ideal.pow_le_pow_right hmn) + +@@ -128,7 +127,6 @@ theorem factorPow_comp_limitProj {m n : ℕ} (hmn : m ≤ n) : + rw [quotientTower_map] at hw + refine RingHom.ext fun z => ?_ + have h := DFunLike.congr_fun (congrArg CommRingCat.Hom.hom hw) z +- rw [CommRingCat.hom_comp] at h + exact h + + /-- The ring homomorphism `limit (quotientTower I) →+* AdicCompletion I R` obtained from the +diff --git a/FormalSchemes/FormalSpectrum.lean b/FormalSchemes/FormalSpectrum.lean +index eaa51f03d448e0eb994047eb92258dd72617ad19..dd86085fe3841adc9919b73488167bb91fd0cf01 100644 +--- a/FormalSchemes/FormalSpectrum.lean ++++ b/FormalSchemes/FormalSpectrum.lean +@@ -192,6 +192,7 @@ theorem map_comp (φ : R →+* S) (ψ : S →+* T) (hIJ : I ≤ J.comap φ) (hJK + (Ideal.quotientMap K ψ hJK).comp (Ideal.quotientMap J φ hIJ) := + Ideal.Quotient.ringHom_ext (RingHom.ext fun x => by simp [Ideal.quotientMap_mk]) + funext x ++ change PrimeSpectrum (T ⧸ K) at x + change PrimeSpectrum.comap (Ideal.quotientMap K (ψ.comp φ) hIK) x = _ + rw [hq, PrimeSpectrum.comap_comp_apply] + rfl +@@ -208,6 +209,7 @@ Spec S → Spec R + commutes. -/ + theorem toPrimeSpectrum_map (φ : R →+* S) (h : I ≤ J.comap φ) (x : FormalSpectrum J) : + toPrimeSpectrum I (map I J φ h x) = PrimeSpectrum.comap φ (toPrimeSpectrum J x) := by ++ change PrimeSpectrum (S ⧸ J) at x + change PrimeSpectrum.comap (Ideal.Quotient.mk I) + (PrimeSpectrum.comap (Ideal.quotientMap J φ h) x) + = PrimeSpectrum.comap φ (PrimeSpectrum.comap (Ideal.Quotient.mk J) x) +@@ -278,6 +280,7 @@ theorem comap_factor_comp_toThickening {m n : ℕ} (hm : m ≠ 0) (hn : n ≠ 0) + PrimeSpectrum.comap (Ideal.Quotient.factor (Ideal.pow_le_pow_right hmn)) ∘ + toThickening I m hm = toThickening I n hn := by + funext x ++ change PrimeSpectrum (R ⧸ I) at x + change PrimeSpectrum.comap (Ideal.Quotient.factor (Ideal.pow_le_pow_right hmn)) + (PrimeSpectrum.comap (Ideal.Quotient.factor (Ideal.pow_le_self hm)) x) = _ + rw [← PrimeSpectrum.comap_comp_apply, Ideal.Quotient.factor_comp] +@@ -289,6 +292,7 @@ compatibly. -/ + theorem comap_mk_toThickening (n : ℕ) (hn : n ≠ 0) (x : FormalSpectrum I) : + PrimeSpectrum.comap (Ideal.Quotient.mk (I ^ n)) (toThickening I n hn x) = + toPrimeSpectrum I x := by ++ change PrimeSpectrum (R ⧸ I) at x + rw [toThickening, toPrimeSpectrum, ← PrimeSpectrum.comap_comp_apply, + Ideal.Quotient.factor_comp_mk] + +@@ -299,6 +303,7 @@ theorem toThickening_preimage_basicOpen (n : ℕ) (hn : n ≠ 0) (f : R) : + (PrimeSpectrum.basicOpen (Ideal.Quotient.mk (I ^ n) f) : Set (PrimeSpectrum (R ⧸ I ^ n))) + = (basicOpen I f : Set (FormalSpectrum I)) := by + ext x ++ change PrimeSpectrum (R ⧸ I) at x + change Ideal.Quotient.mk (I ^ n) f ∉ (PrimeSpectrum.comap _ x).asIdeal ↔ _ + rw [PrimeSpectrum.comap_asIdeal, Ideal.mem_comap, Ideal.Quotient.factor_mk] + rfl +diff --git a/lake-manifest.json b/lake-manifest.json +index b1308febafec43a4ce2579e35c508f6b66654b88..4f22c9fbf687e031625e1f4ed2bc973e57446dcd 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,21 +1,21 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/leanprover-community/mathlib4", ++ [{"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -25,7 +25,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -35,7 +35,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +45,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -65,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -75,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -85,10 +85,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "«formal-schemes»", +diff --git a/lakefile.toml b/lakefile.toml +index 551af80eb4d69a8c4d63abf0cde6124936dc0b02..53ef215a48858b86da7776108148f74dbc3d4c73 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["FormalSchemes"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -11,8 +13,8 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "FormalSchemes" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/genl-lean4341.patch b/lean/patches/genl-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..9982ef0a172ff62be15b45f8c9abcfaa9cafc0cb --- /dev/null +++ b/lean/patches/genl-lean4341.patch @@ -0,0 +1,189 @@ +diff --git a/lake-manifest.json b/lake-manifest.json +index e8ffcb435b3b516c7e7e6f32008d4a78dcc9271c..5ba329fb1fb3ff704cdeabb2e0b58cda469ccdd3 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,7 +1,17 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/lana-agents/heights", ++ [{"url": "https://github.com/lana-agents/belyi.git", ++ "type": "git", ++ "subDir": null, ++ "scope": "", ++ "rev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "name": "belyi", ++ "manifestFile": "lake-manifest.json", ++ "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "inherited": false, ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/heights.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -11,31 +21,31 @@ + "inputRev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/mathlib4", ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, +- {"url": "https://github.com/lana-agents/belyi.git", ++ {"url": "https://github.com/lana-agents/oka.git", + "type": "git", + "subDir": null, + "scope": "", +- "rev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", +- "name": "belyi", ++ "rev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", ++ "name": "oka", + "manifestFile": "lake-manifest.json", +- "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "inputRev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -65,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -75,7 +85,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -85,7 +95,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -95,30 +105,20 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/lana-agents/oka.git", +- "type": "git", +- "subDir": null, +- "scope": "", +- "rev": "da228a2cf9671aaba08ddc96274d75e098b28f67", +- "name": "oka", +- "manifestFile": "lake-manifest.json", +- "inputRev": "da228a2cf9671aaba08ddc96274d75e098b28f67", +- "inherited": true, +- "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "genl", +diff --git a/lakefile.toml b/lakefile.toml +index 8be38dbd83af2475de6b65a66e460a7709cb702f..24cede3b9b7f23a9cfc2f4edd6d0e8cf2bb6c458 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["Genl"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + autoImplicit = false + relaxedAutoImplicit = false +@@ -12,16 +14,22 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + # Heights on curves over number fields (the genuine height theory, Genl.Curves), which also + # brings lana-agents/belyi (curves as function fields). + [[require]] + name = "heights" +-git = "https://github.com/lana-agents/heights" ++git = "https://github.com/lana-agents/heights.git" + rev = "721496ca4c158e511d25d8ccf6bfe8503eda73c1" + ++# Imported directly by the curve height and covering developments. ++[[require]] ++name = "belyi" ++git = "https://github.com/lana-agents/belyi.git" ++rev = "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8" ++ + [[lean_lib]] + name = "Genl" + +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/gromov-lean4341.patch b/lean/patches/gromov-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..2fad46559f57f199973e63d2790ae796f590dda7 --- /dev/null +++ b/lean/patches/gromov-lean4341.patch @@ -0,0 +1,18638 @@ +diff --git a/Gromov/BoundedDoubling.lean b/Gromov/BoundedDoubling.lean +index 61fd0b4..ac55b91 100644 +--- a/Gromov/BoundedDoubling.lean ++++ b/Gromov/BoundedDoubling.lean +@@ -11,11 +11,6 @@ public import Gromov.Lemma326 + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -39,29 +34,62 @@ variable {ι : Type*} [Fintype ι] [DecidableEq ι] [Nonempty ι] + + variable {b : Module.Basis ι ℝ V} + +-set_option maxHeartbeats 2500000 in +-lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodule ℝ LipschitzH, U ≤ V ∧ dim V ≤ 2 * dim U ∧ ∀ f ∈ U, Q_R (16 * (R_2 data)) f f ≤ Real.exp (2 * (a data.d)) * Q_R ((R_2 data)) f f := by ++omit hGS v_wrapper_inst in ++private lemma diagonal_form_eval {E I : Type*} [AddCommGroup E] [Module ℝ E] ++ [Fintype I] [DecidableEq I] (b : Module.Basis I ℝ E) ++ (B : LinearMap.BilinForm ℝ E) (hB : B.IsOrthoᵢ b) (x : E) : ++ B x x = ∑ i, (b.repr x i)^2 * B (b i) (b i) := by ++ calc ++ B x x = B (∑ i, b.repr x i • b i) (∑ j, b.repr x j • b j) := by ++ rw [b.sum_repr] ++ _ = ∑ i, ∑ j, b.repr x i * b.repr x j * B (b j) (b i) := by ++ simp only [map_sum, LinearMap.sum_apply, map_smul, LinearMap.smul_apply, smul_eq_mul] ++ apply Finset.sum_congr rfl ++ intro i hi ++ rw [Finset.mul_sum] ++ apply Finset.sum_congr rfl ++ intro j hj ++ ring ++ _ = ∑ i, (b.repr x i)^2 * B (b i) (b i) := by ++ apply Finset.sum_congr rfl ++ intro i hi ++ rw [Finset.sum_eq_single i] ++ · ring ++ · intro j hj hji ++ rw [hB hji] ++ simp ++ · simp ++ ++omit hGS v_wrapper_inst in ++private lemma diagonal_forms_le {E I : Type*} [AddCommGroup E] [Module ℝ E] ++ [Fintype I] [DecidableEq I] (b : Module.Basis I ℝ E) ++ (B D : LinearMap.BilinForm ℝ E) (hB : B.IsOrthoᵢ b) (hD : D.IsOrthoᵢ b) ++ (x : E) (k : ℝ) ++ (hk : ∀ i ∈ (b.repr x).support, D (b i) (b i) ≤ k * B (b i) (b i)) : ++ D x x ≤ k * B x x := by ++ rw [diagonal_form_eval b B hB, diagonal_form_eval b D hD, Finset.mul_sum] ++ apply Finset.sum_le_sum ++ intro i hi ++ by_cases hx : i ∈ (b.repr x).support ++ · nlinarith [mul_le_mul_of_nonneg_left (hk i hx) (sq_nonneg (b.repr x i))] ++ · have hz : b.repr x i = 0 := Finsupp.notMem_support_iff.mp hx ++ simp [hz] ++ ++private lemma doubleScale_basis (R : ℕ) (h_R : R'_ V ≤ (R : ℝ)) : ++ ∃ v_orthonormal : Module.Basis (Fin (Module.finrank ℝ V)) ℝ V, ++ let _q_r_16_m := (Q_R_lin V (16 * R)).toMatrix₂ v_orthonormal v_orthonormal ++ let q_r_16_m_hermitian := Q_R_lin_hermetian v_orthonormal (16 * R) ++ let q_r_16_eigen := q_r_16_m_hermitian.eigenvectorBasis.toBasis ++ let eigen_basis_V := (WithLp.linearEquiv 2 ℝ (Fin (Module.finrank ℝ V) → ℝ)).trans v_orthonormal.equivFun.symm ++ let remapped_ortho := Module.Basis.map q_r_16_eigen eigen_basis_V ++ (Q_R_lin V R).IsOrthoᵢ remapped_ortho ∧ ++ (∀ i, Q_R_lin V R (remapped_ortho i) (remapped_ortho i) = 1) ∧ ++ (Q_R_lin V R).toMatrix₂ v_orthonormal v_orthonormal = 1 ∧ ++ (Q_R_lin_plain V (16 * R)).IsOrthoᵢ remapped_ortho := by + classical +- +- let R := 16 ^ ((GoodScales data).i_2) +- have h_R: R'_ V ≤ ↑R := R'_le_R_2 data +- +- have q_r_base_pos_def := (Q_R_matrix_pos_def_i₀ b (16 ^ ((GoodScales data).i_2)) (by +- simp [i₀] +- rw [pow_le_pow_iff_right₀] +- . have foo := (GoodScales data).i_2_ge +- simp [i₀] at foo +- exact foo +- . simp +- )) +- +- have det_succ_pos : 0 < (Q_R_matrix b (16 ^ ((GoodScales data).i_2 + 1))).det := +- (Q_R_matrix_pos_def b (16 ^ ((GoodScales data).i_2 + 1)) +- (le_trans h_R (by simp only [R]; push_cast; exact pow_le_pow_right₀ (by norm_num) (Nat.le_succ _)))).det_pos +- + -- Full (definite) inner product core, registered as a local instance so that + -- `toNormedAddCommGroup` / `ofCore` pick it up by inference. +- letI Q_R_inner_core: InnerProductSpace.Core ℝ V := { ++ let Q_R_inner_core: InnerProductSpace.Core ℝ V := { + inner := fun u v => Q_R R u.val v.val + conj_inner_symm := by + simp [Q_R] +@@ -93,11 +121,11 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + + -- Install the definite Q_R-derived NORM (not just a seminorm) *before* `ofCore`, so the + -- ambient LipschitzH norm on `↥V` is shadowed and `Q_R_inner` is over this `NormedAddCommGroup`. +- letI Q_R_norm : NormedAddCommGroup ↥V := InnerProductSpace.Core.toNormedAddCommGroup (𝕜 := ℝ) ++ let Q_R_norm : NormedAddCommGroup ↥V := InnerProductSpace.Core.toNormedAddCommGroup (𝕜 := ℝ) + -- Also expose the seminorm projection as a *direct* local instance, so it shadows the + -- ambient `V.seminormedAddCommGroup` (a bare `NormedAddCommGroup` letI does not). +- letI Q_R_seminorm : SeminormedAddCommGroup ↥V := Q_R_norm.toSeminormedAddCommGroup +- letI Q_R_inner : InnerProductSpace ℝ ↥V := ++ let Q_R_seminorm : SeminormedAddCommGroup ↥V := Q_R_norm.toSeminormedAddCommGroup ++ let Q_R_inner : InnerProductSpace ℝ ↥V := + InnerProductSpace.ofCore (inferInstance : PreInnerProductSpace.Core ℝ ↥V) + + have norm_eq_q_r : ∀ x : ↥V, ‖x‖ = Real.sqrt (Q_R R x x) := fun _ => rfl +@@ -163,7 +191,7 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + apply v_orthogonal_orig_eval _ _ hij + )] + +- ring ++ ring_nf + simp [norm_eq_q_r] + conv => + lhs +@@ -190,9 +218,9 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + intro i + simp [remapped_ortho] + simp [eigen_basis_V,] +- ring ++ ring_nf + field_simp +- simp only [eigen_basis_V, q_r_16_eigen] ++ simp only [q_r_16_eigen] + simp + simp_rw [Finset.mul_sum] + simp [v_orthonormal] +@@ -218,7 +246,7 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + apply v_orthogonal_orig_eval _ _ hij + )] + +- ring ++ ring_nf + simp [norm_eq_q_r] + conv => + lhs +@@ -288,36 +316,6 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + let Q_R_16_new_ortho := (Q_R_lin V (16 *R)).toMatrix₂ remapped_ortho remapped_ortho + have Q_R_16_new_ortho_hermitian: Q_R_16_new_ortho.IsHermitian := Q_R_lin_hermetian remapped_ortho (16 *R) + +- have det_Q_R_one: Q_R_ortho.det = 1 := by +- simp [Q_R_ortho_eq_1] +- +- have det_Q_R_16_ge: 1 ≤ Q_R_16_new_ortho.det := by +- rw [← det_Q_R_one] +- apply matrix_det_montone +- . +- simp [Q_R_ortho] +- apply Matrix.PosDef.of_dotProduct_mulVec_pos (?_) +- . +- intro x hx +- simp [Q_R_matrix] +- conv => +- rhs +- lhs +- equals (star x) => simp +- rw [star_dotProduct_toMatrix₂_mulVec] +- apply Q_R_pos_on_R' +- . rw [LinearEquiv.map_ne_zero_iff] +- exact hx +- . exact h_R +- . apply Q_R_ortho_m_hermitian +- . +- simp [Q_R_16_new_ortho, Q_R_ortho] +- rw [← map_sub] +- rw [← LinearMap.isPosSemidef_iff_posSemidef_toMatrix] +- apply Q_R_lin_sub_pos_semi_def +- norm_cast +- grind +- + have q_r_16_remapped_orthogonal : (Q_R_lin_plain V (16 * R)).IsOrthoᵢ remapped_ortho := by + simp [remapped_ortho] + rw [LinearMap.isOrthoᵢ_def] +@@ -357,7 +355,7 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + + have tobasis_lp: ∀ x, (q_r_16_m_hermitian.eigenvectorBasis.toBasis x).ofLp = (q_r_16_m_hermitian.eigenvectorBasis x).ofLp := by + simp +- simp [tobasis_lp] ++ simp + rw [Matrix.IsHermitian.mulVec_eigenvectorBasis q_r_16_m_hermitian] + simp + right +@@ -371,6 +369,51 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + apply OrthonormalBasis.inner_eq_zero + exact hxy.symm + ++ exact ⟨v_orthonormal, v_orthonormal_isortho, q_r_lin_remapped_one, ++ Q_R_v_orthonormal_eq_1, q_r_16_remapped_orthogonal⟩ ++ ++lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodule ℝ LipschitzH, U ≤ V ∧ dim V ≤ 2 * dim U ∧ ∀ f ∈ U, Q_R (16 * (R_2 data)) f f ≤ Real.exp (2 * (a data.d)) * Q_R ((R_2 data)) f f := by ++ classical ++ ++ let R := 16 ^ ((GoodScales data).i_2) ++ have h_R: R'_ V ≤ ↑R := R'_le_R_2 data ++ ++ have q_r_base_pos_def := (Q_R_matrix_pos_def_i₀ b (16 ^ ((GoodScales data).i_2)) (by ++ simp [i₀] ++ rw [pow_le_pow_iff_right₀] ++ . have foo := (GoodScales data).i_2_ge ++ simp [i₀] at foo ++ exact foo ++ . simp ++ )) ++ ++ have det_succ_pos : 0 < (Q_R_matrix b (16 ^ ((GoodScales data).i_2 + 1))).det := ++ (Q_R_matrix_pos_def b (16 ^ ((GoodScales data).i_2 + 1)) ++ (le_trans h_R (by simp only [R]; push_cast; exact pow_le_pow_right₀ (by norm_num) (Nat.le_succ _)))).det_pos ++ ++ obtain ⟨v_orthonormal, hb⟩ := doubleScale_basis R h_R ++ let q_r_16_m := (Q_R_lin V (16 * R)).toMatrix₂ v_orthonormal v_orthonormal ++ have q_r_16_m_hermitian : q_r_16_m.IsHermitian := Q_R_lin_hermetian v_orthonormal (16 * R) ++ let q_r_16_eigen := q_r_16_m_hermitian.eigenvectorBasis.toBasis ++ let eigen_basis_V := (WithLp.linearEquiv 2 ℝ (Fin (Module.finrank ℝ V) → ℝ)).trans v_orthonormal.equivFun.symm ++ let remapped_ortho := Module.Basis.map q_r_16_eigen eigen_basis_V ++ change (Q_R_lin V R).IsOrthoᵢ remapped_ortho ∧ ++ (∀ i, Q_R_lin V R (remapped_ortho i) (remapped_ortho i) = 1) ∧ ++ (Q_R_lin V R).toMatrix₂ v_orthonormal v_orthonormal = 1 ∧ ++ (Q_R_lin_plain V (16 * R)).IsOrthoᵢ remapped_ortho at hb ++ obtain ⟨v_orthonormal_isortho, q_r_lin_remapped_one, ++ Q_R_v_orthonormal_eq_1, q_r_16_remapped_orthogonal⟩ := hb ++ let q_r_v_orthonormal := (Q_R_lin V R).toMatrix₂ v_orthonormal v_orthonormal ++ let Q_R_ortho := (Q_R_lin V R).toMatrix₂ remapped_ortho remapped_ortho ++ have det_Q_R_one : Q_R_ortho.det = 1 := by ++ have hmat : Q_R_ortho = 1 := by ++ ext i j ++ by_cases hij : i = j ++ · subst j ++ simpa [Q_R_ortho] using q_r_lin_remapped_one i ++ · simpa [Q_R_ortho, Matrix.one_apply, hij] using v_orthonormal_isortho hij ++ simp [hmat] ++ + have new_growth := data.h_growth + have nonempty_fin: Nonempty (Fin (Module.finrank ℝ ↥V)) := by + use 0 +@@ -394,124 +437,18 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + . simp + apply Finset.card_le_card + apply Finset.pow_subset_pow_right +- . simp [one_mem] ++ . simp [Generates.one_mem] + . grind + + -- +- have inner_x_self (x: V) (k: ℝ) (hk: ∀ i ∈ (remapped_ortho.repr x).support, (Q_R_lin_plain V (16 * R) (remapped_ortho i) (remapped_ortho i)) ≤ k * (Q_R_lin_plain V (R) (remapped_ortho i) (remapped_ortho i))) : Q_R_lin_plain V (16 * R) x x ≤ k * Q_R_lin_plain V (R) x x := by +- rw [← Module.Basis.sum_repr remapped_ortho (u := x)] +- have inner_sum_eq: ∀ i, ∑ i_1, inner ℝ ((remapped_ortho.repr x) i_1 • remapped_ortho i_1) ((remapped_ortho.repr x) i • remapped_ortho i) = inner ℝ ((remapped_ortho.repr x) i • remapped_ortho i) ((remapped_ortho.repr x) i • remapped_ortho i) := by +- intro i +- rw [Finset.sum_eq_single i] +- . intro k hk k_neq +- rw [inner_eq_q_r] +- simp [map_smul] +- rw [LinearMap.isOrthoᵢ_def] at v_orthonormal_isortho +- specialize v_orthonormal_isortho k i k_neq +- simp [Q_R_lin] at v_orthonormal_isortho +- simp [Q_R] +- simp [Q_R] at v_orthonormal_isortho +- simp_rw [mul_assoc] +- rw [← Finset.mul_sum] +- simp_rw [mul_comm ((remapped_ortho.repr x) i)] +- simp_rw [← mul_assoc] +- rw [← Finset.sum_mul] +- simp [v_orthonormal_isortho] +- . +- intro hi +- simp at hi +- +- have q_r_16_sum_eq: ∀ i, ∑ i_1, Q_R_lin_plain V (16 * R) ((remapped_ortho.repr x) i_1 • remapped_ortho i_1) ((remapped_ortho.repr x) i • remapped_ortho i) = Q_R_lin_plain V (16 * R) ((remapped_ortho.repr x) i • remapped_ortho i) ((remapped_ortho.repr x) i • remapped_ortho i) := by +- intro i +- rw [Finset.sum_eq_single i] +- . intro k hk k_neq +- simp [map_smul] +- rw [LinearMap.isOrthoᵢ_def] at q_r_16_remapped_orthogonal +- specialize q_r_16_remapped_orthogonal k i k_neq +- simp [Q_R_lin_plain] at q_r_16_remapped_orthogonal +- simp [Q_R_lin_plain, Q_R] +- simp [Q_R] at q_r_16_remapped_orthogonal +- right +- right +- simp [q_r_16_remapped_orthogonal] +- . +- intro hi +- simp at hi +- +- rw [map_sum] +- simp_rw [map_sum] +- simp [Finset.sum_apply] +- conv => +- rhs +- rhs +- arg 2 +- intro i +- rw [Finset.sum_eq_single i (by +- intro k hk k_neq +- simp [map_smul] +- rw [LinearMap.isOrthoᵢ_def] at v_orthonormal_isortho +- right +- specialize v_orthonormal_isortho k i k_neq +- simp [Q_R_lin] at v_orthonormal_isortho +- simp [Q_R_lin_plain, Q_R] +- simp [Q_R] at v_orthonormal_isortho +- simp [v_orthonormal_isortho] +- ) (by +- intro hi +- simp at hi +- )] +- conv => +- rhs +- rw [← Module.Basis.sum_repr remapped_ortho (u := x)] +- +- simp_rw [map_sum] +- simp +- simp_rw [Finset.mul_sum] +- conv => +- lhs +- arg 2 +- intro i +- rw [Finset.sum_eq_single i (by +- intro k hk k_neq +- simp [map_smul] +- rw [LinearMap.isOrthoᵢ_def] at q_r_16_remapped_orthogonal +- specialize q_r_16_remapped_orthogonal k i k_neq +- simp [Q_R_lin_plain] at q_r_16_remapped_orthogonal +- simp [Q_R_lin_plain, Q_R] +- simp [Q_R] at q_r_16_remapped_orthogonal +- right +- right +- simp [q_r_16_remapped_orthogonal] +- ) (by +- intro hi +- simp at hi +- )] +- +- apply Finset.sum_le_sum +- intro i hi +- by_cases i_mem_inter: i ∈ (remapped_ortho.repr x).support +- . +- conv => +- lhs +- equals ((Q_R_lin_plain V (16 * ↑R)) (remapped_ortho i)) (remapped_ortho i) * (remapped_ortho.repr x) i * (remapped_ortho.repr x) i => +- ring +- +- conv => +- rhs +- equals k * ((Q_R_lin_plain V ↑R) (remapped_ortho i)) (remapped_ortho i) * (remapped_ortho.repr x) i * (remapped_ortho.repr x) i => +- ring +- +- rw [mul_assoc] +- nth_rw 2 [mul_assoc] +- specialize hk i i_mem_inter +- grw [hk] +- . ring +- simp +- . rw [← pow_two] +- positivity +- . +- simp at i_mem_inter +- simp [i_mem_inter] ++ have inner_x_self (x : V) (k : ℝ) ++ (hk : ∀ i ∈ (remapped_ortho.repr x).support, ++ Q_R_lin_plain V (16 * R) (remapped_ortho i) (remapped_ortho i) ≤ ++ k * Q_R_lin_plain V R (remapped_ortho i) (remapped_ortho i)) : ++ Q_R_lin_plain V (16 * R) x x ≤ k * Q_R_lin_plain V R x x := by ++ exact diagonal_forms_le remapped_ortho ++ (Q_R_lin_plain V R) (Q_R_lin_plain V (16 * R)) ++ v_orthonormal_isortho q_r_16_remapped_orthogonal x k hk + grw [← log_second] at a_gt + rw [Real.log_mul] at a_gt + . +@@ -564,7 +501,7 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + simp + rw [le_sub_iff_add_le'] + grw [dim_small] +- ring ++ ring_nf + simp + . + have all_le: ∀ f ∈ small_submodule, Q_R_lin V (16 * ↑(R_2 data)) f f ≤ Real.exp (2 * a data.d) * Q_R_lin V ↑(R_2 data) f f := by +@@ -590,11 +527,11 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + . intro k hk i_neq + simp + right +- simp [Finsupp.single_apply, i_neq] ++ simp [i_neq] + . intro k hk i_neq + simp + right +- simp [Finsupp.single_apply, i_neq] ++ simp [i_neq] + + simp [large_basis] at i_not_mem + simp [Q_R_lin_plain] +@@ -617,7 +554,6 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + field_simp at a_gt + unfold Q_R_ortho at det_Q_R_one + have foo := Q_R_v_orthonormal_eq_1 +- unfold q_r_v_orthonormal at Q_R_v_orthonormal_eq_1 + simp [R] at Q_R_v_orthonormal_eq_1 + simp [Q_R_v_orthonormal_eq_1] at a_gt + +@@ -628,7 +564,7 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + . + have foo := q_r_lin_remapped_one + simp [Q_R_lin, Q_R] at foo +- simp [finite_closed_ball] ++ simp + rw [foo] + . + simp +@@ -745,7 +681,7 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + apply Matrix.PosDef.of_dotProduct_mulVec_pos (?_) + . + intro x hx +- simp [Q_R_matrix] ++ simp + conv => + rhs + lhs +@@ -767,7 +703,7 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + apply Matrix.PosDef.eigenvalues_pos + apply Matrix.PosDef.of_dotProduct_mulVec_pos (?_) + . intro x hx +- simp [Q_R_matrix] ++ simp + conv => + rhs + lhs +@@ -793,7 +729,6 @@ lemma exists_bounded_doubling_subspace (data: GoodScalesData b): ∃ U: Submodul + grind + . exact (Real.rpow_pos_of_pos det_succ_pos _).ne' + +-#print axioms exists_bounded_doubling_subspace + + end V_Wrapper_Section + +diff --git a/Gromov/Complexification.lean b/Gromov/Complexification.lean +index 71602f6..6ccd3ae 100644 +--- a/Gromov/Complexification.lean ++++ b/Gromov/Complexification.lean +@@ -41,11 +41,11 @@ def fst (p : Cx V) : V := (p : V × V).1 + @[expose] + def snd (p : Cx V) : V := (p : V × V).2 + +-omit [InnerProductSpace ℝ V] in ++omit [NormedAddCommGroup V] [InnerProductSpace ℝ V] in + @[simp] lemma fst_mk (a b : V) : fst ((a, b) : Cx V) = a := rfl +-omit [InnerProductSpace ℝ V] in ++omit [NormedAddCommGroup V] [InnerProductSpace ℝ V] in + @[simp] lemma snd_mk (a b : V) : snd ((a, b) : Cx V) = b := rfl +-omit [InnerProductSpace ℝ V] in ++omit [NormedAddCommGroup V] [InnerProductSpace ℝ V] in + @[ext] lemma ext {p q : Cx V} (h1 : p.fst = q.fst) (h2 : p.snd = q.snd) : p = q := Prod.ext h1 h2 + + omit [InnerProductSpace ℝ V] in +@@ -92,7 +92,7 @@ lemma innerC_self_re (u : Cx V) : + Complex.I_im, Complex.ofReal_im, zero_mul, mul_zero, sub_zero, add_zero] + + /-- The inner product space core on the complexification. -/ +-@[expose] ++@[expose, instance_reducible] + noncomputable def coreC : InnerProductSpace.Core ℂ (Cx V) where + inner := innerC + conj_inner_symm u v := by unfold innerC; simp [Complex.ext_iff, real_inner_comm] +diff --git a/Gromov/Convolution.lean b/Gromov/Convolution.lean +index 42fc819..4754eca 100644 +--- a/Gromov/Convolution.lean ++++ b/Gromov/Convolution.lean +@@ -14,8 +14,6 @@ public import Gromov.TendstoNhdsMul + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS +@@ -36,7 +34,7 @@ lemma conv_assoc_of_lp2 {f g h: G → ℝ} (hf: MemLp f 2 Measure.count) (hg: Me + funext x + + +- have h_lp_n (n: ℕ): MemLp h n myHaarAddOpp := by ++ have h_lp_n (n: ℕ): MemLp (fun x : Additive G => h x) n myHaarAddOpp := by + apply Continuous.memLp_of_hasCompactSupport (X := Additive G) (μ := myHaarAddOpp) + . apply continuous_of_discreteTopology + . +@@ -48,7 +46,6 @@ lemma conv_assoc_of_lp2 {f g h: G → ℝ} (hf: MemLp f 2 Measure.count) (hg: Me + conv => + lhs + arg 1 +- simp + eta_reduce + rw [MeasureTheory.convolution_assoc (L := ContinuousLinearMap.mul ℝ ℝ) (L₂ := ContinuousLinearMap.mul ℝ ℝ) (L₃ := ContinuousLinearMap.mul ℝ ℝ) (L₄ := ContinuousLinearMap.mul ℝ ℝ)] + . rfl +@@ -96,7 +93,6 @@ lemma conv_assoc_of_lp2 {f g h: G → ℝ} (hf: MemLp f 2 Measure.count) (hg: Me + exact hf + . + unfold MeasureTheory.MemLp +- refine ⟨by apply AEStronglyMeasurable.of_discrete, ?_⟩ + rw [← my_add_haar_eq_count] + grw [ENNReal.eLpNorm_convolution_le_enorm_mul' (p := 2) (q := 1)] + . +@@ -104,17 +100,13 @@ lemma conv_assoc_of_lp2 {f g h: G → ℝ} (hf: MemLp f 2 Measure.count) (hg: Me + apply ENNReal.mul_lt_top + . + simp_rw [← Real.norm_eq_abs] +- rw [MeasureTheory.eLpNorm_norm] +- rw [my_add_haar_eq_count] +- exact MemLp.eLpNorm_lt_top hg ++ have hg' : MemLp (fun x : Additive G => g x) 2 myHaarAddOpp := by ++ rw [my_add_haar_eq_count] ++ exact hg ++ exact hg'.norm.eLpNorm_lt_top + . + simp_rw [← Real.norm_eq_abs] +- rw [MeasureTheory.eLpNorm_norm] +- rw [my_add_haar_eq_count] +- rw [← my_add_haar_eq_count] +- have foo := h_lp_n 1 +- simp at foo +- exact MemLp.eLpNorm_lt_top foo ++ simpa only [Nat.cast_one] using (h_lp_n 1).norm.eLpNorm_lt_top + . simp + . simp + . simp +@@ -132,7 +124,6 @@ lemma conv_assoc {f g h: G → ℝ} (h_fg: ConvExists f g) (h_gh: ConvExists g h + conv => + lhs + arg 1 +- simp + eta_reduce + rw [MeasureTheory.convolution_assoc (L := ContinuousLinearMap.mul ℝ ℝ) (L₂ := ContinuousLinearMap.mul ℝ ℝ) (L₃ := ContinuousLinearMap.mul ℝ ℝ) (L₄ := ContinuousLinearMap.mul ℝ ℝ)] + . rfl +@@ -283,7 +274,6 @@ lemma conv_sum {T: Type*} (H: Finset T) (f: T → G → ℝ) (h: G → ℝ) (h_f + @[expose] + noncomputable def conv_finsupp_lp2 (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G)))) (g : G → ℝ) (hg : g.support.Finite): (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G))) := MeasureTheory.MemLp.toLp (Conv f g) (by + simp [MemLp] +- refine ⟨by apply AEStronglyMeasurable.of_discrete, ?_⟩ + have norm_bound := ENNReal.eLpNorm_convolution_le_enorm_mul (G := Additive G) (f := f) (g := g) (E' := ℝ) (E := ℝ) (F := ℝ) (𝕜 := ℝ) (p := 2) (q := 1) (r := 2) (μ := myHaarAddOpp) (ContinuousLinearMap.mul ℝ ℝ) + (by simp) (by simp) (by simp) (by simp) (by apply AEMeasurable.of_discrete) (by apply AEMeasurable.of_discrete) + +@@ -298,7 +288,7 @@ noncomputable def conv_finsupp_lp2 (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.vo + . apply WithTop.mul_lt_top + . exact enorm_lt_top + . rw [← my_add_haar_eq_count] +- apply (MeasureTheory.Lp.memLp f).2 ++ apply (MeasureTheory.Lp.memLp f).eLpNorm_lt_top + . + simp [eLpNorm, eLpNorm'] + rw [MeasureTheory.lintegral_count] +diff --git a/Gromov/CutoffInequality.lean b/Gromov/CutoffInequality.lean +index cb8c23e..6f8d0a7 100644 +--- a/Gromov/CutoffInequality.lean ++++ b/Gromov/CutoffInequality.lean +@@ -17,11 +17,6 @@ public import Gromov.ToMathlib.LinearAlgebra.Matrix.Det + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -43,7 +38,6 @@ include hGS + -- `deriv_sq (f ∘ (· * j)) x = deriv_sq f (x * j)`, which is what Lemma 3.25 (c) needs. + @[expose] noncomputable def deriv_sq (f: G → ℝ) (x: G) := ∑ s ∈ S, (f (s * x) - f x)^2 + +-set_option maxHeartbeats 9000000 in + lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.support.Finite): + ∑' (x: G), ∑ s ∈ S, ((f x * φ x) - (f (s * x) * φ (s * x)))^2 ≤ ∑' (x: G), ∑ s ∈ S, (f x)^2 * (φ (s * x) - φ x)^2 := by + +@@ -97,7 +91,7 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + simp + rw [← Finset.sum_neg_distrib] + simp_rw [← tsum_neg] +- ring ++ ring_nf + + have double {a b: ℝ} (hab: a = b): a = (a + b) / 2 := by + rw [hab] +@@ -187,7 +181,7 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + field_simp + . simp + . +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + apply Set.Finite.inter_of_right +@@ -201,7 +195,7 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + . intro x hx + simp + . +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + apply Set.Finite.inter_of_right +@@ -221,7 +215,7 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + arg 2 + intro s + rw [Summable.tsum_add (by +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + apply Set.Finite.inter_of_right +@@ -235,7 +229,7 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + . intro x hx + simp + ) (by +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + apply Set.Finite.inter_of_right +@@ -269,7 +263,7 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + field_simp + rw [← Summable.tsum_finsetSum] + intro s hs +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + apply Set.Finite.inter_of_right +@@ -285,7 +279,7 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + . simp [S_nonempty] + . + intro s hs +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + apply Set.Finite.inter_of_left +@@ -296,7 +290,6 @@ lemma cutoff_inequality (f φ : G → ℝ) (hf: Laplace_b f = 0) (hφ: φ.suppor + apply Set.Finite.inter_of_right + apply hφ + +-#print axioms cutoff_inequality + + -- TODO - can we make WordNorm.instSemiNormedGroup and use norm notation + +diff --git a/Gromov/Defs.lean b/Gromov/Defs.lean +index 87a78bf..ddaa959 100644 +--- a/Gromov/Defs.lean ++++ b/Gromov/Defs.lean +@@ -15,10 +15,6 @@ structure, `LipschitzH` and the convolution API. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false +-set_option linter.style.whitespace false + + open Subgroup + open scoped Finset +@@ -121,19 +117,15 @@ lemma gAct_mul (g h : G) (f: LipschitzH ): gAct (g * h) f = gAct g (gAct h f) := + rw [← mul_assoc] + + +-@[expose] +-def gAct_const (g: G) (z: ℝ): gAct g (ConstLipschitzH z) = ConstLipschitzH z := by ++theorem gAct_const (g: G) (z: ℝ): gAct g (ConstLipschitzH z) = ConstLipschitzH z := by + unfold gAct + unfold ConstLipschitzH + ext x + simp [DFunLike.coe] + +-#synth Module ℝ (LipschitzH) +-#synth AddCommGroup (LipschitzH) + + abbrev W := (LipschitzH) ⧸ ConstF + +-#synth Module ℝ (W) + + @[expose] + noncomputable def f_n (n: ℕ) (g: G): ℝ := ((1: ℝ) / ((n + 1): ℝ)) * ∑ m: Fin (n + 1), muConv (m.val) g +@@ -276,7 +268,7 @@ lemma laplace_sum_swap_helper {f g: G → ℝ} (hgf: f.support.Finite ∨ g.supp + . + intro s hs + apply Summable.mul_left +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + clear foo +@@ -301,7 +293,7 @@ lemma laplace_sum_swap_helper {f g: G → ℝ} (hgf: f.support.Finite ∨ g.supp + -- TODO - deduplicate this + intro s hs + apply Summable.mul_left +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + wlog hg: g.support.Finite +@@ -328,7 +320,7 @@ lemma laplace_sum_swap_helper {f g: G → ℝ} (hgf: f.support.Finite ∨ g.supp + simp + . + apply Summable.sub +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + . + unfold Function.HasFiniteSupport + simp +@@ -343,7 +335,7 @@ lemma laplace_sum_swap_helper {f g: G → ℝ} (hgf: f.support.Finite ∨ g.supp + simp_rw [Finset.mul_sum] + apply summable_sum + intro s hs +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + cases hgf +@@ -366,7 +358,7 @@ lemma laplace_sum_swap_helper {f g: G → ℝ} (hgf: f.support.Finite ∨ g.supp + simp_rw [mul_sub] + apply Summable.sub + . +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + cases hgf +@@ -382,7 +374,7 @@ lemma laplace_sum_swap_helper {f g: G → ℝ} (hgf: f.support.Finite ∨ g.supp + apply Set.Finite.inter_of_right + apply hg + . +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + unfold Function.HasFiniteSupport + simp + cases hgf +diff --git a/Gromov/Defs/Convolution.lean b/Gromov/Defs/Convolution.lean +index 46685e4..15d5656 100644 +--- a/Gromov/Defs/Convolution.lean ++++ b/Gromov/Defs/Convolution.lean +@@ -12,10 +12,6 @@ The convolution `Conv`, the measure `mu` and its iterates `muConv`, and the `Lp` + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false +-set_option linter.style.whitespace false + + open Subgroup + open scoped Finset +@@ -62,12 +58,12 @@ abbrev opAdd (g : G) := Additive.ofMul g + lemma conv_eq_sum {f h: G → ℝ} (hconv: ConvExists f h) (g: G): Conv f h g = ∑' (a : Additive G), f (a) * h (g * (Additive.toMul a)⁻¹) := by + unfold Conv + unfold MeasureTheory.convolution +- rw [MeasureTheory.integral_countable'] ++ rw [MeasureTheory.integral_countable] + . + simp_rw [MeasureTheory.measureReal_def] + unfold myHaarAddOpp + simp_rw [MeasureTheory.Measure.addHaar_singleton] +- simp [MeasureTheory.Measure.addHaarMeasure_self] ++ simp + simp_rw [← singleton_carrier] + simp_rw [TopologicalSpace.PositiveCompacts.carrier_eq_coe] + simp [MeasureTheory.Measure.addHaarMeasure_self] +@@ -205,7 +201,6 @@ lemma mu_finsupp: (mu ).support.Finite := by + simp at foo + exact Finset.nonempty_iff_ne_empty.mp foo + +-#print axioms mu_finsupp + + -- Proposition 3.12, item 2, in Vikman + lemma f_conv_mu (f: G → ℝ): (Conv f (mu )) = fun g => ((1 : ℝ) / (#(S) : ℝ)) * ∑ s ∈ S, f (s * g) := by +@@ -257,7 +252,7 @@ lemma f_conv_mu (f: G → ℝ): (Conv f (mu )) = fun g => ((1 : ℝ) / (#(S) : + intro x + rw [Summable.tsum_mul_left (hf := by ( + simp [Pi.single_apply] +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + apply Set.Finite.subset (s := {(opAdd ( x⁻¹ * g ))}) + . simp + . intro z hz +@@ -294,7 +289,7 @@ lemma f_conv_mu (f: G → ℝ): (Conv f (mu )) = fun g => ((1 : ℝ) / (#(S) : + . + -- TODO - deduplicate this + simp [Pi.single_apply] +- apply summable_of_finite_support ++ apply summable_of_hasFiniteSupport + apply Set.Finite.subset (s := {(opAdd (s⁻¹ * g ))}) + . simp + . intro z hz +@@ -312,11 +307,10 @@ lemma f_conv_mu (f: G → ℝ): (Conv f (mu )) = fun g => ((1 : ℝ) / (#(S) : + @[expose] + noncomputable def conv_mu_lp2 (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G)))): (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G))) := MeasureTheory.MemLp.toLp (Conv f (mu )) (by + rw [MeasureTheory.MemLp] +- refine ⟨MeasureTheory.AEStronglyMeasurable.of_discrete, ?_⟩ + simp [MeasureTheory.eLpNorm, MeasureTheory.eLpNorm'] + rw [f_conv_mu] + simp_rw [Finset.mul_sum] +- have other := MeasureTheory.memLp_finset_sum (μ := MeasureTheory.volume (α := G)) (s := S) (p := 2) (f := fun s a => ((1 : ℝ) / (#(S) : ℝ)) * f (s * a)) (by ++ have other := MeasureTheory.memLp_finsetSum (μ := MeasureTheory.volume (α := G)) (s := S) (p := 2) (f := fun s a => ((1 : ℝ) / (#(S) : ℝ)) * f (s * a)) (by + intro s hs + simp + apply MeasureTheory.MemLp.const_mul +@@ -331,10 +325,11 @@ noncomputable def conv_mu_lp2 (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume + exact mem_f + . apply AEMeasurable.of_discrete + ) +- have sum_norm := other.2 ++ have sum_norm := other.eLpNorm_lt_top + simp [eLpNorm, eLpNorm'] at sum_norm + field_simp at sum_norm + field_simp ++ simp only [AEStronglyMeasurable.of_discrete, ite_true] at sum_norm ⊢ + exact sum_norm + ) + +diff --git a/Gromov/Defs/LipschitzH.lean b/Gromov/Defs/LipschitzH.lean +index c83c23f..89933da 100644 +--- a/Gromov/Defs/LipschitzH.lean ++++ b/Gromov/Defs/LipschitzH.lean +@@ -12,10 +12,6 @@ structure, and finiteness of balls. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false +-set_option linter.style.whitespace false + + open Subgroup + open scoped Finset +@@ -149,7 +145,6 @@ instance lipschitzSMul: SMul ℝ (LipschitzH) := { + rw [mul_eq_mul_left_iff] + left + have hf := f.harmonic x +- unfold Harmonic at hf + simp at hf + field_simp at hf + exact hf +@@ -216,7 +211,6 @@ instance LipschitzH.addMonoid [Generates ] : AddMonoid (LipschitzH) := { + ext g + show (((n + 1 : ℕ) : ℝ) • f).toFun g = (((n : ℕ) : ℝ) • f).toFun g + f.toFun g + simp [lipschitz_smul_tofun] +- push_cast + ring + } + +@@ -231,32 +225,30 @@ instance LipschitzH.instAddCommGroup: AddCommGroup (LipschitzH) := { + sub_eq_add_neg := by + intro f h + ext g +- simp [lipschitz_sub_tofun, lipschitz_add_tofun, lipschitz_neg_tofun] ++ simp [lipschitz_sub_tofun, lipschitz_neg_tofun] + rfl + zsmul := fun n f => (n : ℝ) • f + zsmul_zero' := by + intro f + ext g +- simp only [HSMul.hSMul, SMul.smul, DFunLike.coe, Int.cast_zero, zero_mul] ++ simp only [HSMul.hSMul, SMul.smul, Int.cast_zero, zero_mul] + rfl + neg_add_cancel := by + intro f + ext g +- simp [negLipschitzH] ++ simp + rfl + zsmul_succ' := by + intro n f + ext g + show (((n + 1 : ℕ) : ℝ) • f).toFun g = (((n : ℕ) : ℝ) • f).toFun g + f.toFun g + simp [lipschitz_smul_tofun] +- push_cast + ring + zsmul_neg' := by + intro n hn + ext g + show ((Int.negSucc n : ℝ) • hn).toFun g = -((((n + 1 : ℕ) : ℝ)) • hn).toFun g + simp [lipschitz_smul_tofun] +- push_cast + ring + } + +@@ -309,12 +301,12 @@ instance lipschitzHVectorSpace : Module ℝ (LipschitzH) := { + zero_smul := by + intro a + ext g +- simp [HSMul.hSMul, SMul.smul, DFunLike.coe] ++ simp [HSMul.hSMul, SMul.smul] + } + + lemma finite_ball (x: G) (r: ℝ): Set.Finite (Metric.ball x r) := Set.Finite.of_finite_image (f := fun a => (word_norm_prod_self a).choose) (by + have foo := List.finite_length_le S (WordNorm x + ⌈r⌉₊) +- rw [← Set.finite_coe_iff, Set.coe_setOf] at foo ++ rw [← Set.finite_coe_iff, Set.coe_ofPred] at foo + apply Finite.of_injective (β := {l : List S // l.length ≤ WordNorm x + ⌈r⌉₊}) (fun a => ⟨a.val, by ( + have ha := a.prop + simp [-Subtype.coe_prop] at ha +@@ -349,7 +341,7 @@ lemma finite_ball (x: G) (r: ℝ): Set.Finite (Metric.ball x r) := Set.Finite.of + -- TODO - deduplicate 99% of this with finite_ball + lemma finite_closed_ball (x: G) (r: ℝ): Set.Finite (Metric.closedBall x r) := Set.Finite.of_finite_image (f := fun a => (word_norm_prod_self a).choose) (by + have foo := List.finite_length_le S (WordNorm x + ⌈r⌉₊) +- rw [← Set.finite_coe_iff, Set.coe_setOf] at foo ++ rw [← Set.finite_coe_iff, Set.coe_ofPred] at foo + apply Finite.of_injective (β := {l : List S // l.length ≤ WordNorm x + ⌈r⌉₊}) (fun a => ⟨a.val, by ( + have ha := a.prop + simp [-Subtype.coe_prop] at ha +diff --git a/Gromov/Defs/Measure.lean b/Gromov/Defs/Measure.lean +index 02450ef..2cf42d0 100644 +--- a/Gromov/Defs/Measure.lean ++++ b/Gromov/Defs/Measure.lean +@@ -12,10 +12,6 @@ measure-space instances and the resulting a.e.-triviality lemmas. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false +-set_option linter.style.whitespace false + + open Subgroup + open scoped Finset +@@ -146,7 +142,6 @@ lemma singleton_pairwise_disjoint {T: Type*} (s: Set (T)) : s.PairwiseDisjoint S + + + -- Use the fact that we have the discrete topology +-set_option maxHeartbeats 500000 in + lemma my_add_haar_eq_count: (myHaarAddOpp) = MeasureTheory.Measure.count := by + ext s hs + by_cases s_finite: Set.Finite s +@@ -256,8 +251,7 @@ lemma count_ae_everywhere (p: G → Prop): (∀ᵐ g ∂(MeasureTheory.Measure.c + simp [MeasureTheory.Measure.count_eq_zero_iff] + -- TODO - there has to be a much simpler way of proving this + refine ⟨?_, ?_⟩ +- . intro h +- intro a ++ . intro h a + by_contra this + have a_in: a ∈ {a | ¬ p a} := by + simp [this] +diff --git a/Gromov/Defs/WordMetric.lean b/Gromov/Defs/WordMetric.lean +index 4746cfe..e9393b4 100644 +--- a/Gromov/Defs/WordMetric.lean ++++ b/Gromov/Defs/WordMetric.lean +@@ -13,10 +13,6 @@ instance. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false +-set_option linter.style.whitespace false + + open Subgroup + open scoped Finset +@@ -99,7 +95,7 @@ lemma mem_S_prod_list (x: G): ∃ l: List S, ProdS x l := by + -- https://leanprover.zulipchat.com/#narrow/channel/287929-mathlib4/topic/Group.20.28.2FMonoid.2Fetc.29.20closures.20are.20a.20finite.20product.2Fsum/near/477951441 + have foo := Submonoid.exists_list_of_mem_closure (s := S ∪ S⁻¹) (x := x) + rw [← Subgroup.closure_toSubmonoid _] at foo +- simp only [mem_toSubmonoid, Finset.mem_coe] at foo ++ simp only [mem_toSubmonoid] at foo + specialize foo (mem_closure x) + norm_cast at foo + rw [s_union_sinv] at foo +@@ -123,7 +119,7 @@ lemma word_norm_prod (g: G) (n: ℕ) (hgn: WordNorm g = n): ∃ l: List S, ProdS + unfold ProdS at hl + rw [Set.nonempty_def] at foo + specialize foo ⟨l.length, ⟨l, ⟨by simp, hl⟩⟩⟩ +- simp only [Set.mem_setOf_eq] at foo ++ simp only [Set.mem_ofPred_eq] at foo + obtain ⟨l, ⟨hl, hl_prod⟩⟩ := foo + rw [← hgn] + exact ⟨l, ⟨hl_prod, hl⟩⟩ +@@ -147,7 +143,7 @@ lemma WordDist_self (x: G): WordDist x x = 0 := by + unfold WordDist + rw [mul_inv_cancel] + unfold WordNorm +- simp only [Nat.sInf_eq_zero, Set.mem_setOf_eq, List.length_eq_zero_iff, exists_eq_left] ++ simp only [Nat.sInf_eq_zero, Set.mem_ofPred_eq, List.length_eq_zero_iff, exists_eq_left] + left + rfl + +@@ -228,7 +224,7 @@ lemma word_norm_eq_zero {x y: G} (hdist: WordDist x y = 0): x = y := by + unfold ProdS at hl + have len_in_set: l.unattach.length ∈ (∅ : Set ℕ) := by + rw [← empty_set] +- simp only [List.length_unattach, Set.mem_setOf_eq] ++ simp only [List.length_unattach, Set.mem_ofPred_eq] + use l + refine ⟨rfl, hl⟩ + simp only [Set.mem_empty_iff_false] at len_in_set +@@ -356,7 +352,7 @@ lemma dist_word_le_mul {x y z : G} (hy: y ∈ S): WordDist x z ≤ (WordDist x ( + rw [mul_inv_eq_one] at l_prod + grind + | h::tail => +- use [ ⟨y⁻¹, by simp [hGS.has_inv, hy]⟩, ⟨h.val, by simp [hGS.has_inv]⟩,] ++ tail ++ use [ ⟨y⁻¹, by simp [hGS.has_inv, hy]⟩, ⟨h.val, by simp⟩,] ++ tail + simp [ProdS] + simp [← l_len] + simp [ProdS] at l_prod +diff --git a/Gromov/FormalConjecturesCheck.lean b/Gromov/FormalConjecturesCheck.lean +index 6c8c31e..52e4b65 100644 +--- a/Gromov/FormalConjecturesCheck.lean ++++ b/Gromov/FormalConjecturesCheck.lean +@@ -1,6 +1,7 @@ + module + + public import Gromov.Gromov ++public import Gromov.PolynomialGrowth + + /-! + # Cross-check of `main_gromov_theorem` against the `formal-conjectures` statement +@@ -34,34 +35,32 @@ public section + + set_option linter.style.longLine false + ++@[instance_reducible] ++private noncomputable def generatorsData {G : Type*} (gg : Group G) (de : DecidableEq G) ++ (T : Finset G) (hT : Nonempty T) ++ (hgen : (@Subgroup.closure G gg (T : Set G) : Set G) = Set.univ) ++ (h1 : @OfNat.ofNat G 1 (@One.toOfNat1 G gg.toOne) ∈ T) ++ (hinv : ∀ g ∈ T, @Inv.inv G gg.toInv g ∈ T) ++ (hi : Infinite G) (hp : @HasPolynomialGrowth G gg de T) : Generates := ++ @Generates.mk G gg de T hT hgen h1 hinv hi hp ++ ++private theorem gromovOfGeneratorData {G : Type*} (gg : Group G) (de : DecidableEq G) ++ (T : Finset G) (hT : Nonempty T) ++ (hgen : (@Subgroup.closure G gg (T : Set G) : Set G) = Set.univ) ++ (h1 : @OfNat.ofNat G 1 (@One.toOfNat1 G gg.toOne) ∈ T) ++ (hinv : ∀ g ∈ T, @Inv.inv G gg.toInv g ∈ T) ++ (hi : Infinite G) (hp : @HasPolynomialGrowth G gg de T) : ++ @Group.IsVirtuallyNilpotent G gg := by ++ let inst := generatorsData gg de T hT hgen h1 hinv hi hp ++ obtain ⟨n, hn⟩ := hp ++ exact GeneratesNS.main_gromov_theorem (hGS := inst) n hn ++ + namespace FormalConjecturesCheck + + open scoped Pointwise + + variable {G : Type*} [Group G] + +-/-! ### Definitions copied from `formal-conjectures` -/ +- +-/-- The `CayleyBall` is the ball of radius `n` in the Cayley graph of a group `G` with generating +-set `S`. -/ +-@[expose] +-def CayleyBall (S : Set G) (n : ℕ) : Set G := +- {g : G | ∃ (l : List G), l.length ≤ n ∧ (∀ s ∈ l, s ∈ S ∨ s⁻¹ ∈ S) ∧ l.prod = g} +- +-/-- The `GrowthFunction` of a group `G` with respect to a set `S` counts the number of group +-elements that can be reached by words of length at most `n` in `S`. -/ +-@[expose] +-noncomputable def GrowthFunction (S : Set G) (n : ℕ) : ℕ := +- (CayleyBall S n).ncard +- +-/-- A group has polynomial growth if there exists a finite generating set whose growth function is +-bounded above by a polynomial. -/ +-@[expose] +-def HasPolynomialGrowth (G : Type*) [Group G] : Prop := +- ∃ (S : Set G), Set.Finite S ∧ Subgroup.closure S = ⊤ ∧ +- ∃ (C : ℝ) (d : ℕ), C > 0 ∧ +- ∀ n > 0, (GrowthFunction S n : ℝ) ≤ C * (n : ℝ) ^ d +- + /-! ### Normalizing the generating set -/ + + variable [DecidableEq G] +@@ -145,41 +144,59 @@ lemma card_normGen_pow (S : Set G) (hS : S.Finite) (n : ℕ) : + + /-! ### The forward direction of the reference statement -/ + +-set_option maxHeartbeats 1000000 in ++private lemma normGen_polynomial (S : Set G) (hSfin : S.Finite) (C : ℝ) (d : ℕ) ++ (hbound : ∀ n : ℕ, 0 < n → (GrowthFunction S n : ℝ) ≤ C * (n : ℝ) ^ d) : ++ HasPolynomialGrowthD (normGen S hSfin) d := by ++ refine ⟨⌈C⌉₊, fun n hn => ?_⟩ ++ have hcard : ((normGen S hSfin) ^ n).card = GrowthFunction S n := card_normGen_pow S hSfin n ++ have hb := hbound n (by omega) ++ rw [← hcard] at hb ++ have h : (((normGen S hSfin) ^ n).card : ℝ) ≤ (⌈C⌉₊ : ℝ) * (n : ℝ) ^ d := ++ hb.trans (by gcongr; exact Nat.le_ceil C) ++ exact_mod_cast h ++ ++private lemma normGen_generates (S : Set G) (hSfin : S.Finite) ++ (hSgen : Subgroup.closure S = ⊤) : ++ (Subgroup.closure (normGen S hSfin : Set G) : Set G) = ⊤ := by ++ have hclosure : Subgroup.closure ((normGen S hSfin : Finset G) : Set G) = ⊤ := by ++ rw [eq_top_iff, ← hSgen] ++ exact Subgroup.closure_mono (subset_normGen S hSfin) ++ rw [hclosure] ++ rfl ++ ++private theorem normalized_data (S : Set G) (hSfin : S.Finite) ++ (hSgen : Subgroup.closure S = ⊤) (C : ℝ) (d : ℕ) ++ (hbound : ∀ n : ℕ, 0 < n → (GrowthFunction S n : ℝ) ≤ C * (n : ℝ) ^ d) : ++ ∃ T : Finset G, Nonempty T ∧ ++ (Subgroup.closure (T : Set G) : Set G) = Set.univ ∧ ++ (1 : G) ∈ T ∧ (∀ g ∈ T, g⁻¹ ∈ T) ∧ _root_.HasPolynomialGrowth T := by ++ refine ⟨normGen S hSfin, ⟨⟨1, one_mem_normGen S hSfin⟩⟩, ++ normGen_generates S hSfin hSgen, one_mem_normGen S hSfin, ++ fun _ hg => inv_mem_normGen S hSfin hg, d, ?_⟩ ++ exact normGen_polynomial S hSfin C d hbound ++ ++omit [Group G] [DecidableEq G] in ++private theorem infinite_forward (gg : Group G) (de : DecidableEq G) (S : Set G) ++ (hSfin : S.Finite) (hSgen : @Subgroup.closure G gg S = ⊤) (hinf : Infinite G) ++ (C : ℝ) (d : ℕ) ++ (hbound : ∀ n : ℕ, 0 < n → (@GrowthFunction G gg S n : ℝ) ≤ C * (n : ℝ) ^ d) : ++ @Group.IsVirtuallyNilpotent G gg := by ++ obtain ⟨T, hT, hgen, h1, hinv, hp⟩ := @normalized_data G gg de S hSfin hSgen C d hbound ++ exact @gromovOfGeneratorData G gg de T hT hgen h1 hinv hinf hp ++ ++omit [Group G] [DecidableEq G] in + /-- **The forward direction of `GromovPolynomialGrowth.GromovPolynomialGrowthTheorem`**, derived + from `GeneratesNS.main_gromov_theorem`: a finitely generated group of polynomial growth (in the + `formal-conjectures` formulation) is virtually nilpotent. -/ +-theorem gromov_forward (G : Type*) [Group G] (h : HasPolynomialGrowth G) : ++theorem gromov_forward (G : Type*) [gg : Group G] (h : @HasPolynomialGrowth G gg) : + Group.IsVirtuallyNilpotent G := by + classical +- letI dec : DecidableEq G := Classical.decEq G + obtain ⟨S, hSfin, hSgen, C, d, hC, hbound⟩ := h + rcases finite_or_infinite G with hfin | hinf + · exact GeneratesNS.finite_virtually_nilpotent +- · have hclosure : Subgroup.closure ((normGen S hSfin : Finset G) : Set G) = ⊤ := by +- rw [eq_top_iff, ← hSgen] +- exact Subgroup.closure_mono (subset_normGen S hSfin) +- have hgrowth : HasPolynomialGrowthD (normGen S hSfin) d := by +- refine ⟨⌈C⌉₊, fun n hn => ?_⟩ +- have hcard : ((normGen S hSfin) ^ n).card = GrowthFunction S n := card_normGen_pow S hSfin n +- have hb := hbound n (by omega) +- rw [← hcard] at hb +- have : (((normGen S hSfin) ^ n).card : ℝ) ≤ (⌈C⌉₊ : ℝ) * (n : ℝ) ^ d := +- hb.trans (by gcongr; exact Nat.le_ceil C) +- exact_mod_cast this +- letI inst : Generates := +- { G := G +- g_group := ‹Group G› +- g_eq := dec +- S := normGen S hSfin +- hS := ⟨⟨1, one_mem_normGen S hSfin⟩⟩ +- generates := by rw [hclosure]; simp +- one_mem := one_mem_normGen S hSfin +- has_inv := fun _ hg => inv_mem_normGen S hSfin hg +- g_infinite := hinf +- g_growth := ⟨d, hgrowth⟩ } +- exact GeneratesNS.main_gromov_theorem (hGS := inst) d hgrowth ++ · exact infinite_forward gg (inferInstance : DecidableEq G) S hSfin hSgen hinf C d hbound + ++omit [Group G] [DecidableEq G] in + /-- The forward direction with the reference statement's exact signature, including the + `[Group.FG G]` hypothesis. That hypothesis is redundant here: `HasPolynomialGrowth G` already + supplies a finite generating set, so `gromov_forward` proves the same conclusion without it. -/ +diff --git a/Gromov/Gromov.lean b/Gromov/Gromov.lean +index 985ce00..bfc3ce3 100644 +--- a/Gromov/Gromov.lean ++++ b/Gromov/Gromov.lean +@@ -14,7 +14,6 @@ public section + + set_option linter.style.longLine false + set_option linter.style.cdot false +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +@@ -29,9 +28,7 @@ include hGS + + open scoped RealInnerProductSpace + +-set_option synthInstance.maxHeartbeats 500000 + +-set_option maxHeartbeats 1000000 + + open MeasureTheory + +@@ -39,12 +36,445 @@ open Additive + + attribute [local implicit_reducible] Additive Multiplicative + +-set_option maxHeartbeats 2500000 in ++private def kernelInclusion (data : Theorem3_1_Input G) : ++ Multiplicative data.φ.ker →* data.G' := ++ AddMonoidHom.toMultiplicativeLeft data.φ.ker.subtype ++ ++private def kernelValue (data : Theorem3_1_Input G) ++ (N : Subgroup (Multiplicative data.φ.ker)) : N →* data.G' := ++ (AddMonoidHom.toMultiplicativeLeft data.φ.ker.subtype).comp N.subtype ++ ++private lemma conjugate_product_wordNorm (x y : G) (Lx Ly a b k : ℕ) ++ (hx : WordNorm x ≤ Lx) (hy : WordNorm y ≤ Ly) ++ (hk : 0 < k) (hb : 0 < b) (s : Finset (Finset.Ico a b)) : ++ WordNorm ((s.toList.map (fun i => y ^ (k * i.val) * x * ++ (y ^ (k * i.val))⁻¹)).prod) ≤ (b-a) * (max Lx Ly * (4*k*b)) := by ++ have hterm (i : Finset.Ico a b) : ++ WordNorm (y ^ (k*i.val) * x * (y ^ (k*i.val))⁻¹) ≤ ++ max Lx Ly * (4*k*b) := by ++ have hp : WordNorm (y ^ (k*i.val)) ≤ k*b*max Lx Ly := by ++ calc ++ _ ≤ (k*i.val) * WordNorm y := word_norm_pow _ _ ++ _ ≤ (k*b) * max Lx Ly := by gcongr; exact le_of_lt (Finset.mem_Ico.mp i.property).2; exact hy.trans (le_max_right _ _) ++ have h1 := word_norm_mul_le (hGS := hGS) (y ^ (k*i.val) * x) ((y ^ (k*i.val))⁻¹) ++ have h2 := word_norm_mul_le (hGS := hGS) (y ^ (k*i.val)) x ++ rw [← word_norm_inv (hGS := hGS)] at h1 ++ have hx' := hx.trans (le_max_left Lx Ly) ++ have hkb : 1 ≤ k*b := one_le_mul (by omega) (by omega) ++ have hM := Nat.mul_le_mul_left (max Lx Ly) hkb ++ nlinarith ++ calc ++ _ ≤ ((s.toList.map (fun i => y ^ (k*i.val) * x * ++ (y ^ (k*i.val))⁻¹)).map WordNorm).sum := word_norm_list_prod_le _ ++ _ ≤ (s.toList.map (fun _ => max Lx Ly * (4*k*b))).sum := by ++ rw [List.map_map] ++ exact List.sum_le_sum (fun i _ => hterm i) ++ _ = s.card * (max Lx Ly * (4*k*b)) := by simp ++ _ ≤ (b-a) * (max Lx Ly * (4*k*b)) := by ++ apply Nat.mul_le_mul_right ++ simpa using Finset.card_le_univ s ++ ++private lemma conjugate_subproducts_growth (data : Theorem3_1_Input G) ++ (N' : Subgroup (Multiplicative data.φ.ker)) (γ : Additive data.G') ++ (hγ : data.φ γ = 1) (gamma_conj_N' : MulAut N') ++ (conj_mem_ker : ∀ (n : ℕ) (g : N'), ++ Additive.ofMul (Additive.toMul γ ^ n * kernelValue data N' g * ++ (Additive.toMul γ ^ n)⁻¹) ∈ data.φ.ker) ++ (conj_mem_N' : ∀ (n : ℕ) (g : N'), ++ (Multiplicative.ofAdd (⟨Additive.ofMul (Additive.toMul γ ^ n * kernelValue data N' g * ++ (Additive.toMul γ ^ n)⁻¹), conj_mem_ker n g⟩ : data.φ.ker)) ∈ N') ++ (gamma_conj_iter : ∀ (n : ℕ) (g : N'), gamma_conj_N'^[n] g = ++ ⟨Multiplicative.ofAdd (⟨Additive.ofMul (Additive.toMul γ ^ n * kernelValue data N' g * ++ (Additive.toMul γ ^ n)⁻¹), conj_mem_ker n g⟩ : data.φ.ker), conj_mem_N' n g⟩) : ++∀ k: ℕ, (0 < k) → ∀ g, ∃ p q: ℕ, 0 < p ∧ ∀ b: ℕ, 0 < b → ∀ a: ℕ, (0 < a) → (a < b) → ((Finset.image (fun x ↦ (List.map (fun (i: Finset.Ico a b) ↦ (gamma_conj_N')^[k * ↑i] g) x.toList).prod)) ++ (Finset.Ico a b).attach.powerset).card ≤ p * (b^q) * (b - a)^q := by ++ let N'_val := kernelValue data N' ++ ++ ++ have s_poly := hGS.g_growth ++ unfold HasPolynomialGrowth at s_poly ++ obtain ⟨q, hq⟩ := s_poly ++ unfold HasPolynomialGrowthD at hq ++ obtain ⟨p, hp⟩ := hq ++ intro k k_pos x ++ ++ ++ obtain ⟨x_list, x_prod, x_list_prod⟩ := ++ word_norm_prod_self (hGS := hGS) x.val.toAdd.val.toMul.val ++ obtain ⟨gamma_list, gamma_prod, gamma_list_prod⟩ := ++ word_norm_prod_self (hGS := hGS) (Additive.toMul γ).val ++ ++ ++ -- `(hGS := hGS)` is required: `new_generates` shadows the ambient instance here, ++ -- so a bare `S` would resolve to `new_generates.S`. ++ have p_pos: 0 < p := growth_const_pos (hGS := hGS) hp ++ ++ have q_pos: 0 < q := growth_exponent_pos (hGS := hGS) ⟨p, hp⟩ ++ use p * (((max x_list.length gamma_list.length) * (4 * k)) ^ q) ++ use q ++ ++ ++ have gamma_len_pos: 1 ≤ gamma_list.length := by ++ by_contra! ++ simp at this ++ simp [ProdS, this] at gamma_prod ++ have gamma_eq: γ = 0 := by ++ have gamma_coe := Subtype.coe_eq_of_eq_mk gamma_prod.symm ++ apply_fun (fun a => Additive.ofMul a) at gamma_coe ++ rw [ofMul_toMul] at gamma_coe ++ exact gamma_coe ++ simp [gamma_eq] at hγ ++ ++ refine ⟨?_, ?_⟩ ++ . ++ apply mul_pos ++ . exact p_pos ++ . ++ rw [pow_pos_iff] ++ . ++ positivity ++ . grind ++ ++ ++ intro b hb a ha hab ++ ++ have mul_nozero: 1 ≤ 2 * k * b := by ++ rw [mul_assoc] ++ apply one_le_mul ++ . simp ++ . apply one_le_mul ++ . grind ++ . grind ++ ++ ++ grw [← Finset.card_image_of_injOn (f := fun a => a.val.toAdd.val.toMul.val) (by simp)] ++ grw [Finset.card_le_card (t := hGS.S^((b - a) * ((max x_list.length gamma_list.length) * (4 * k * b)) ))] ++ · ++ ++ grw [hp] ++ . ++ rw [mul_pow] ++ ring_nf ++ simp ++ . ++ simp ++ apply one_le_mul ++ . grind ++ . ++ rw [Nat.one_le_iff_ne_zero, ← Nat.pos_iff_ne_zero] ++ ++ ++ positivity ++ -- side goal from `card_le_card`: the image is contained in `hGS.S` ++ · ++ let f : N' →* G := data.G'.subtype.comp (kernelValue data N') ++ have hf (n : ℕ) (g : N') : f (gamma_conj_N'^[n] g) = ++ (Additive.toMul γ).val ^ n * f g * ((Additive.toMul γ).val ^ n)⁻¹ := by ++ rw [gamma_conj_iter] ++ rfl ++ intro g hg ++ obtain ⟨z, hz, rfl⟩ := Finset.mem_image.mp hg ++ obtain ⟨s, hs, rfl⟩ := Finset.mem_image.mp hz ++ change f ((s.toList.map (fun i : Finset.Ico a b => gamma_conj_N'^[k*i.val] x)).prod) ∈ _ ++ rw [map_list_prod, List.map_map] ++ simp only [Function.comp_def] ++ simp_rw [hf] ++ rw [← closed_ball_eq_S_pow (hGS := hGS)] ++ simp only [Set.Finite.mem_toFinset, Metric.mem_closedBall, dist, WordDist_one] ++ norm_cast ++ exact conjugate_product_wordNorm (hGS := hGS) (f x) (Additive.toMul γ).val ++ x_list.length gamma_list.length a b k ++ (by change WordNorm x.val.toAdd.val.toMul.val ≤ _; rw [← x_list_prod]) ++ (by rw [← gamma_list_prod]) k_pos hb s ++ ++ ++ ++omit hGS in ++private lemma cyclic_kernel_sup {D : Type*} [Group D] ++ (φ : Additive D →+ ℤ) (γ : Additive D) (hγ : φ γ = 1) : ++ Subgroup.closure {γ.toMul} ⊔ φ.ker.toSubgroup' = ⊤ := by ++ apply top_unique ++ intro g _ ++ let z := φ (Additive.ofMul g) ++ have hk : Additive.toMul (-(z • γ) + Additive.ofMul g) ∈ φ.ker.toSubgroup' := by ++ change φ (-(z • γ) + Additive.ofMul g) = 0 ++ simp [z, hγ] ++ have ht : Additive.toMul (z • γ) ∈ Subgroup.closure {γ.toMul} := by ++ rw [Subgroup.mem_closure_singleton] ++ exact ⟨z, by simp⟩ ++ have he : g = Additive.toMul (z • γ) * ++ Additive.toMul (-(z • γ) + Additive.ofMul g) := by ++ rw [← toMul_add, add_neg_cancel_left] ++ rfl ++ rw [he] ++ exact Subgroup.mul_mem _ (Subgroup.mem_sup_left ht) (Subgroup.mem_sup_right hk) ++ ++private lemma cyclic_kernel_finiteIndex (data : Theorem3_1_Input G) ++ (γ : Additive data.G') (hγ : data.φ γ = 1) ++ (N' : Subgroup (Multiplicative data.φ.ker)) [N'.FiniteIndex] ++ (N'_fg : ∃ T : Finset (Multiplicative data.φ.ker), Subgroup.closure (↑T) = N') (α : ℕ) (alpha_nonzero : α ≠ 0) ++ (hinv : ∀ {n : ℕ}, ∀ b ∈ Subgroup.closure {γ.toMul ^ n}, ++ ∀ a ∈ Subgroup.map (kernelInclusion data) (Subgroup.closure (↑N'_fg.choose)), ++ b * a * b⁻¹ ∈ Subgroup.map (kernelInclusion data) (Subgroup.closure (↑N'_fg.choose))) : ++ (Subgroup.map data.G'.subtype ++ (Subgroup.closure (↑(Finset.image (kernelInclusion data) N'_fg.choose) ∪ ++ {γ.toMul ^ α}))).FiniteIndex := by ++ let new_N'_map := kernelInclusion data ++ have map_N'_invariant_gamma {n : ℕ} := hinv (n := n) ++ have map_N'_invariant_gamma_one := map_N'_invariant_gamma (n := 1) ++ simp only [pow_one] at map_N'_invariant_gamma_one ++ rw [Subgroup.finiteIndex_iff] ++ rw [Subgroup.index_map] ++ simp ++ refine ⟨?_, ?_⟩ ++ . ++ ++ simp_rw [Set.insert_eq] ++ ++ have gamma_alpha_le_gamma: (Subgroup.closure ({toMul γ ^ α} ∪ (new_N'_map '' (N'_fg.choose)) )) ≤ (Subgroup.closure ({toMul γ} ∪ (new_N'_map '' (N'_fg.choose)))) := by ++ simp ++ intro g hg ++ rw [Set.insert_eq] ++ cases hg ++ . rename_i g_eq_gamma ++ rw [Subgroup.closure_union] ++ apply Subgroup.mem_sup_left ++ rw [Subgroup.mem_closure_singleton] ++ use α ++ rw [g_eq_gamma] ++ simp ++ . rename_i g_mem_map ++ rw [Subgroup.closure_union] ++ apply Subgroup.mem_sup_right ++ apply Subgroup.mem_closure_of_mem ++ exact g_mem_map ++ ++ conv => ++ arg 1 ++ arg 1 ++ arg 1 ++ arg 1 ++ arg 2 ++ equals (new_N'_map '' (N'_fg.choose)) => rfl ++ rw [← Subgroup.relIndex_mul_index gamma_alpha_le_gamma] ++ simp ++ refine ⟨?_, ?_⟩ ++ . ++ unfold Subgroup.relIndex ++ rw [← ne_eq] ++ rw [← Subgroup.finiteIndex_iff] ++ apply Subgroup.finiteIndex_of_rightCoset_cover_const (s := Finset.Ioo (-α : ℤ) (α)) (g := fun a => ⟨a • γ, (by ++ rw [Set.insert_eq, Subgroup.closure_union] ++ apply Subgroup.mem_sup_left ++ rw [Subgroup.mem_closure_singleton] ++ use a ++ rfl ++ )⟩) ++ ext g ++ simp ++ have g_prop := g.property ++ simp_rw [Set.insert_eq, Subgroup.closure_union] at g_prop ++ rw [← MonoidHom.map_closure] at g_prop ++ simp at g_prop ++ rw [← SetLike.mem_coe] at g_prop ++ rw [sup_comm] at g_prop ++ ++ ++ rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ ++ (Subgroup.le_normalizer_of_conj_mem map_N'_invariant_gamma_one)] at g_prop ++ rw [Set.mem_mul] at g_prop ++ obtain ⟨b, hb, a, ha, g_eq⟩ := g_prop ++ simp at ha ++ rw [Subgroup.mem_closure_singleton] at ha ++ obtain ⟨z, hz⟩ := ha ++ use z % α ++ refine ⟨?_, ?_⟩ ++ . ++ have foo := Int.emod_lt_abs z (b := α) (by grind) ++ rw [lt_abs] at foo ++ refine ⟨?_, ?_⟩ ++ . ++ have bar := Int.emod_nonneg z (b := α) (by simpa using alpha_nonzero) ++ grind ++ . grind ++ . ++ rw [Set.mem_smul_set] ++ use ⟨(Additive.ofMul b) + (((α : ℤ) * (z / (α : ℤ))) • γ), ?_⟩ ++ . ++ refine ⟨?_, ?_⟩ ++ . ++ simp ++ rw [Subgroup.mem_subgroupOf] ++ simp_rw [Set.insert_eq, Subgroup.closure_union] ++ rw [← SetLike.mem_coe] ++ rw [sup_comm] ++ rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ (Subgroup.le_normalizer_of_conj_mem (by ++ simp_rw [← MonoidHom.map_closure] ++ apply map_N'_invariant_gamma ++ ))] ++ apply Set.mul_mem_mul ++ . ++ simp ++ rw [← MonoidHom.map_closure] ++ exact hb ++ . ++ simp ++ rw [Subgroup.mem_closure_singleton] ++ use (z / (α : ℤ)) ++ conv => ++ lhs ++ arg 1 ++ equals toMul γ ^ (α : ℤ) => ++ simp ++ ++ rw [← zpow_mul] ++ . ++ simp ++ rw [Subtype.ext_iff] ++ simp ++ rw [← g_eq, ←hz] ++ nth_rw 3 [← Int.mul_ediv_add_emod (a := z) (b := α)] ++ rw [← toMul_zsmul] ++ conv => ++ lhs ++ equals (ofMul b) + ((↑α * (z / ↑α)) • γ) + ((z % ↑α) • γ) => ++ rfl ++ ++ ++ rw [add_zsmul] ++ rw [add_assoc] ++ rfl ++ . ++ simp_rw [Set.insert_eq, Subgroup.closure_union] ++ rw [sup_comm] ++ rw [← SetLike.mem_coe] ++ ++ rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ (Subgroup.le_normalizer_of_conj_mem (by ++ simp_rw [← MonoidHom.map_closure] ++ apply map_N'_invariant_gamma_one ++ ))] ++ apply Set.mul_mem_mul ++ . ++ simp ++ rw [← MonoidHom.map_closure] ++ exact hb ++ . ++ simp [Subgroup.mem_closure_singleton] ++ . ++ obtain ⟨s, s_compl, s_cosets⟩ := Subgroup.exists_leftTransversal_of_FiniteIndex (D := N') (H := ⊤) (by simp) ++ simp at s_cosets ++ ++ rw [← ne_eq] ++ rw [← Subgroup.finiteIndex_iff] ++ apply Subgroup.finiteIndex_of_leftCoset_cover_const (s := s) (g := fun g => g.val.val.toMul) ++ simp_rw [Set.insert_eq, Subgroup.closure_union] ++ rename_bvar i → g ++ ++ ++ conv => ++ arg 1 ++ arg 1 ++ intro i ++ arg 1 ++ intro hi ++ rw [sup_comm] ++ rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ (Subgroup.le_normalizer_of_conj_mem (by ++ intro gamma_pow h_gamma_pow n hn ++ simp_rw [← MonoidHom.map_closure] at hn ++ simp_rw [← MonoidHom.map_closure] ++ apply map_N'_invariant_gamma_one _ h_gamma_pow _ hn ++ ))] ++ rw [set_smul_eq_mul] ++ rw [← mul_assoc] ++ rw [← set_smul_eq_mul] ++ ++ ++ simp_rw [← Set.iUnion_mul] ++ conv => ++ arg 1 ++ arg 1 ++ equals Additive.toMul '' data.φ.ker => ++ apply_fun (fun s => Additive.toMul '' (Subtype.val '' s)) at s_cosets ++ conv at s_cosets => ++ rhs ++ equals Additive.toMul '' data.φ.ker => ++ ext a ++ simp ++ rw [← s_cosets] ++ conv => ++ arg 1 ++ arg 1 ++ intro i ++ arg 1 ++ intro hi ++ arg 2 ++ ++ simp_rw [← MonoidHom.map_closure] ++ ++ simp only [Set.image_image] ++ erw [Set.image_iUnion₂] ++ apply Set.iUnion_congr ++ intro i ++ apply Set.iUnion_congr ++ intro hi ++ ext z ++ simp only [coe_map] ++ rw [Set.mem_smul_set] ++ rw [Set.mem_image] ++ refine ⟨?_, ?_⟩ ++ . ++ intro hy ++ obtain ⟨a, ha⟩ := hy ++ have foo := ha.1 ++ rw [Set.mem_image] at foo ++ obtain ⟨b, b_mem, a_eq_b⟩ := foo ++ have N'_gen := N'_fg.choose_spec ++ rw [N'_gen] at b_mem ++ refine ⟨(↑i : Multiplicative ↥data.φ.ker) • b, Set.smul_mem_smul_set b_mem, ?_⟩ ++ rw [← ha.2, ← a_eq_b] ++ rfl ++ . ++ intro hx ++ obtain ⟨x, hx, x_eq⟩ := hx ++ erw [Set.mem_smul_set] at hx ++ obtain ⟨n, hn, x_eq_n⟩ := hx ++ refine ⟨new_N'_map n, ?_, ?_⟩ ++ . ++ rw [Set.mem_image] ++ have N'_gen := N'_fg.choose_spec ++ rw [← N'_gen] at hn ++ exact ⟨n, hn, rfl⟩ ++ . rw [← x_eq, ← x_eq_n] ++ rfl ++ ++ ++ conv => ++ arg 1 ++ lhs ++ equals ↑data.φ.ker.toSubgroup' => ++ ext a ++ simp ++ ++ rw [← Subgroup.coe_mul_of_right_le_normalizer_left _ _] ++ . ++ simpa [sup_comm] using cyclic_kernel_sup data.φ γ hγ ++ . ++ apply Subgroup.le_normalizer_of_conj_mem ++ intro b hb a ha ++ rw [Subgroup.mem_closure_singleton] at hb ++ obtain ⟨n, b_eq⟩ := hb ++ simp [← b_eq] ++ simp at ha ++ exact ha ++ . have foo := data.finite_index ++ rw [Subgroup.finiteIndex_iff] at foo ++ exact foo ++ + omit hGS in + lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) (hd: 1 ≤ d) (h_growth: HasPolynomialGrowthD S d) + (inductive_gromov: ∀ (Q_generates: Generates.{u}),(Q_growth : (HasPolynomialGrowthD (Q_generates.S)) (d - 1)) → Group.IsVirtuallyNilpotent Q_generates.G) + : Group.IsVirtuallyNilpotent G := by +- letI inst_dec_G : DecidableEq G := G_dec_eq ++ let inst_dec_G : DecidableEq G := G_dec_eq + + have G'_finite_index := data.finite_index + have G'_fg: Group.FG data.G' := by +@@ -224,14 +654,7 @@ lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) ( + let N' := Subgroup.closure (Set.range (fun (a: Multiplicative data.φ.ker) => a ^ N.index)) + + +- let new_N'_map : _ →* _ := { +- toFun := fun (g: (Multiplicative ↥data.φ.ker)) => Additive.toMul (data.φ.ker.subtype g) +- map_one' := rfl +- map_mul' := by +- intro x y +- rfl +- } +- ++ let new_N'_map := kernelInclusion (hGS := hGS) data + + let new_N': Subgroup (data.G') := Subgroup.map new_N'_map N' + +@@ -357,8 +780,7 @@ lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) ( + -- The underlying element of `data.G'` of an element of `N'`, with every `Additive` / + -- `Multiplicative` conversion spelled out instead of relying on definitional unfolding: + -- `↥N' → Multiplicative ↥data.φ.ker → ↥data.φ.ker → Additive ↥data.G' → ↥data.G'`. +- let N'_val : ↥N' →* ↥data.G' := +- (AddMonoidHom.toMultiplicativeLeft data.φ.ker.subtype).comp N'.subtype ++ let N'_val : ↥N' →* ↥data.G' := kernelValue (hGS := hGS) data N' + + have gamma_conj_ker_apply: ∀ a: ↥data.φ.ker, + data.φ.ker.subtype (gamma_conj_ker a) = γ + data.φ.ker.subtype a + -γ := by +@@ -369,11 +791,10 @@ lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) ( + have gamma_conj_step: ∀ g: ↥N', + N'_val (gamma_conj_N' g) = Additive.toMul γ * N'_val g * (Additive.toMul γ)⁻¹ := by + intro g +- simp only [N'_val, gamma_conj_N', gamma_conj_ker_mul, MonoidHom.coe_comp, Function.comp_apply, ++ simp only [N'_val, kernelValue, gamma_conj_N', gamma_conj_ker_mul, MonoidHom.coe_comp, Function.comp_apply, + AddMonoidHom.coe_toMultiplicativeLeft, Subgroup.coe_subtype, + MulAut.characteristic_apply_apply_coe, AddEquiv.toMultiplicative_apply_apply, +- AddEquiv.toAddMonoidHom_eq_coe, AddMonoidHom.toMultiplicative_apply_apply, +- AddMonoidHom.coe_coe, toAdd_ofAdd, gamma_conj_ker_apply, toMul_add, toMul_neg] ++ toAdd_ofAdd, gamma_conj_ker_apply, toMul_add, toMul_neg] + + have gamma_conj_iter_val: ∀ (n: ℕ), ∀ g: ↥N', + N'_val (gamma_conj_N'^[n] g) +@@ -424,146 +845,8 @@ lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) ( + intro n g + exact Subtype.ext (conj_val_eq n g).symm + +- have gamma_conj_card: ∀ k: ℕ, (0 < k) → ∀ g, ∃ p q: ℕ, 0 < p ∧ ∀ b: ℕ, 0 < b → ∀ a: ℕ, (0 < a) → (a < b) → ((Finset.image (fun x ↦ (List.map (fun (i: Finset.Ico a b) ↦ (gamma_conj_N')^[k * ↑i] g) x.toList).prod)) +- (Finset.Ico a b).attach.powerset).card ≤ p * (b^q) * (b - a)^q := by +- +- have s_poly := hGS.g_growth +- unfold HasPolynomialGrowth at s_poly +- obtain ⟨q, hq⟩ := s_poly +- unfold HasPolynomialGrowthD at hq +- obtain ⟨p, hp⟩ := hq +- intro k k_pos x +- +- +- obtain ⟨x_list, x_prod, x_list_prod⟩ := +- word_norm_prod_self (hGS := hGS) x.val.toAdd.val.toMul.val +- obtain ⟨gamma_list, gamma_prod, gamma_list_prod⟩ := +- word_norm_prod_self (hGS := hGS) (Additive.toMul γ).val +- +- +- -- `(hGS := hGS)` is required: `new_generates` shadows the ambient instance here, +- -- so a bare `S` would resolve to `new_generates.S`. +- have p_pos: 0 < p := growth_const_pos (hGS := hGS) hp +- +- have q_pos: 0 < q := growth_exponent_pos (hGS := hGS) ⟨p, hp⟩ +- use p * (((max x_list.length gamma_list.length) * (4 * k)) ^ q) +- use q +- +- +- have gamma_len_pos: 1 ≤ gamma_list.length := by +- by_contra! +- simp at this +- simp [ProdS, this] at gamma_prod +- have gamma_eq: γ = 0 := by +- have gamma_coe := Subtype.coe_eq_of_eq_mk gamma_prod.symm +- apply_fun (fun a => Additive.ofMul a) at gamma_coe +- rw [ofMul_toMul] at gamma_coe +- exact gamma_coe +- simp [gamma_eq] at hγ +- +- refine ⟨?_, ?_⟩ +- . +- apply mul_pos +- . exact p_pos +- . +- rw [pow_pos_iff] +- . +- positivity +- . grind +- +- +- intro b hb +- intro a ha hab +- +- have mul_nozero: 1 ≤ 2 * k * b := by +- rw [mul_assoc] +- apply one_le_mul +- . simp +- . apply one_le_mul +- . grind +- . grind +- +- +- grw [← Finset.card_image_of_injOn (f := fun a => a.val.toAdd.val.toMul.val) (by simp)] +- grw [Finset.card_le_card (t := hGS.S^((b - a) * ((max x_list.length gamma_list.length) * (4 * k * b)) ))] +- · +- +- grw [hp] +- . +- rw [mul_pow] +- ring +- simp +- . +- simp +- apply one_le_mul +- . grind +- . +- rw [Nat.one_le_iff_ne_zero, ← Nat.pos_iff_ne_zero] +- +- +- positivity +- -- side goal from `card_le_card`: the image is contained in `hGS.S` +- · +- intro g hg +- simp at hg +- obtain ⟨s, hs, g_eq⟩ := hg +- simp [ProdS] at x_prod +- simp [ProdS] at gamma_prod +- rw [eq_comm] at x_prod +- rw [eq_comm] at gamma_prod +- have gamma_eq := Subtype.coe_eq_of_eq_mk gamma_prod +- apply_fun (fun a => Additive.ofMul a) at gamma_eq +- rw [ofMul_toMul] at gamma_eq +- +- have x_eq := Subtype.coe_eq_of_eq_mk x_prod +- apply_fun (fun a => Additive.ofMul a) at x_eq +- rw [ofMul_toMul] at x_eq +- have x_eq := Subtype.coe_eq_of_eq_mk x_eq +- apply_fun (fun a => Multiplicative.ofAdd a) at x_eq +- rw [ofAdd_toAdd] at x_eq +- have x_eq := Subtype.coe_eq_of_eq_mk x_eq +- simp_rw [x_eq] at g_eq +- simp_rw [gamma_conj_iter] at g_eq +- simp at g_eq +- simp_rw [gamma_eq] at g_eq +- rw [← g_eq] +- rw [← closed_ball_eq_S_pow (hGS := hGS)] +- simp [-le_sup_iff] +- simp only [dist, WordDist_one] +- norm_cast +- simp_rw [Function.comp_def] +- simp [-le_sup_iff] +- grw [word_norm_list_prod_le (hGS := hGS)] +- rw [List.unattach.eq_def (l := s.toList)] +- nth_rw 2 [List.map_map] +- grw [List.sum_le_sum (g := Function.const _ ((max x_list.length gamma_list.length) * (4 * k * b)))] +- . +- simp [-le_sup_iff] +- grw [Finset.card_le_univ] +- simp +- . +- intro y hy +- simp at hy +- obtain ⟨m, ⟨⟨m_range, m_mem⟩, y_eq⟩⟩ := hy +- rw [← y_eq] +- grw [word_norm_mul_le (hGS := hGS)] +- grw [word_norm_mul_le (hGS := hGS)] +- rw [← word_norm_inv (hGS := hGS)] +- grw [word_norm_pow (hGS := hGS)] +- rw [← gamma_prod, ← gamma_list_prod] +- simp [N'_val] +- rw [← x_prod, ← x_list_prod] +- grw [m_range.2] +- ring +- have four_eq: 4 = (2 + 2) := by norm_num +- rw [four_eq, mul_add] +- apply add_le_add +- . simp +- grw [le_max_right (b := gamma_list.length)] +- . grw [← le_max_left (a := x_list.length)] +- ring +- nlinarith +- ++ have gamma_conj_card := conjugate_subproducts_growth (hGS := hGS) data N' γ hγ ++ gamma_conj_N' conj_mem_ker conj_mem_N' gamma_conj_iter + + obtain ⟨α, m, alpha_nonzero, alpha_is_unipotent_conj⟩ := exists_gamma_n_unipotent_N' (N' := N') N'_nilpotent N'_fg gamma_conj_N' gamma_conj_card 1 (by simp) + simp_rw [mul_one] at alpha_is_unipotent_conj +@@ -608,7 +891,7 @@ lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) ( + } + + +- haveI : Subgroup.Characteristic N' := N'_char ++ have : Subgroup.Characteristic N' := N'_char + have alpha_nilpotent := unipotent_commutator_trivial (G := data.G') (H := data.φ.ker.toSubgroup') (N' := N') (N'_char := N'_char) (N'_nilpotent := by + exact N'_nilpotent + ) (γ.toMul^α) (by +@@ -680,300 +963,9 @@ lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) ( + . + exact alpha_nilpotent + . +- rw [Subgroup.finiteIndex_iff] +- rw [Subgroup.index_map] +- simp +- refine ⟨?_, ?_⟩ +- . +- +- simp_rw [Set.insert_eq] ++ exact cyclic_kernel_finiteIndex (hGS := hGS) data γ hγ N' N'_fg α alpha_nonzero ++ (fun {_} => map_N'_invariant_gamma) + +- have gamma_alpha_le_gamma: (Subgroup.closure ({toMul γ ^ α} ∪ (new_N'_map '' (N'_fg.choose)) )) ≤ (Subgroup.closure ({toMul γ} ∪ (new_N'_map '' (N'_fg.choose)))) := by +- simp +- intro g hg +- rw [Set.insert_eq] +- cases hg +- . rename_i g_eq_gamma +- rw [Subgroup.closure_union] +- apply Subgroup.mem_sup_left +- rw [Subgroup.mem_closure_singleton] +- use α +- rw [g_eq_gamma] +- simp +- . rename_i g_mem_map +- rw [Subgroup.closure_union] +- apply Subgroup.mem_sup_right +- apply Subgroup.mem_closure_of_mem +- exact g_mem_map +- +- conv => +- arg 1 +- arg 1 +- arg 1 +- arg 1 +- arg 2 +- equals (new_N'_map '' (N'_fg.choose)) => rfl +- rw [← Subgroup.relIndex_mul_index gamma_alpha_le_gamma] +- simp +- refine ⟨?_, ?_⟩ +- . +- unfold Subgroup.relIndex +- rw [← ne_eq] +- rw [← Subgroup.finiteIndex_iff] +- apply Subgroup.finiteIndex_of_rightCoset_cover_const (s := Finset.Ioo (-α : ℤ) (α)) (g := fun a => ⟨a • γ, (by +- rw [Set.insert_eq, Subgroup.closure_union] +- apply Subgroup.mem_sup_left +- rw [Subgroup.mem_closure_singleton] +- use a +- rfl +- )⟩) +- ext g +- simp +- have g_prop := g.property +- simp_rw [Set.insert_eq, Subgroup.closure_union] at g_prop +- rw [← MonoidHom.map_closure] at g_prop +- simp at g_prop +- rw [← SetLike.mem_coe] at g_prop +- rw [sup_comm] at g_prop +- +- +- rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ +- (Subgroup.le_normalizer_of_conj_mem map_N'_invariant_gamma_one)] at g_prop +- rw [Set.mem_mul] at g_prop +- obtain ⟨b, hb, a, ha, g_eq⟩ := g_prop +- simp at ha +- rw [Subgroup.mem_closure_singleton] at ha +- obtain ⟨z, hz⟩ := ha +- use z % α +- refine ⟨?_, ?_⟩ +- . +- have foo := Int.emod_lt_abs z (b := α) (by grind) +- rw [lt_abs] at foo +- refine ⟨?_, ?_⟩ +- . +- have bar := Int.emod_nonneg z (b := α) (by simpa using alpha_nonzero) +- grind +- . grind +- . +- rw [Set.mem_smul_set] +- use ⟨(Additive.ofMul b) + (((α : ℤ) * (z / (α : ℤ))) • γ), ?_⟩ +- . +- refine ⟨?_, ?_⟩ +- . +- simp +- rw [Subgroup.mem_subgroupOf] +- simp_rw [Set.insert_eq, Subgroup.closure_union] +- rw [← SetLike.mem_coe] +- rw [sup_comm] +- rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ (Subgroup.le_normalizer_of_conj_mem (by +- simp_rw [← MonoidHom.map_closure] +- apply map_N'_invariant_gamma +- ))] +- apply Set.mul_mem_mul +- . +- simp +- rw [← MonoidHom.map_closure] +- exact hb +- . +- simp +- rw [Subgroup.mem_closure_singleton] +- use (z / (α : ℤ)) +- conv => +- lhs +- arg 1 +- equals toMul γ ^ (α : ℤ) => +- simp +- +- rw [← zpow_mul] +- . +- simp +- rw [Subtype.ext_iff] +- simp +- rw [← g_eq, ←hz] +- nth_rw 3 [← Int.mul_ediv_add_emod (a := z) (b := α)] +- rw [← toMul_zsmul] +- conv => +- lhs +- equals (ofMul b) + ((↑α * (z / ↑α)) • γ) + ((z % ↑α) • γ) => +- rfl +- +- +- rw [add_zsmul] +- rw [add_assoc] +- rfl +- . +- simp_rw [Set.insert_eq, Subgroup.closure_union] +- rw [sup_comm] +- rw [← SetLike.mem_coe] +- +- rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ (Subgroup.le_normalizer_of_conj_mem (by +- simp_rw [← MonoidHom.map_closure] +- apply map_N'_invariant_gamma_one +- ))] +- apply Set.mul_mem_mul +- . +- simp +- rw [← MonoidHom.map_closure] +- exact hb +- . +- simp [Subgroup.mem_closure_singleton] +- . +- obtain ⟨s, s_compl, s_cosets⟩ := Subgroup.exists_leftTransversal_of_FiniteIndex (D := N') (H := ⊤) (by simp) +- simp at s_cosets +- +- rw [← ne_eq] +- rw [← Subgroup.finiteIndex_iff] +- apply Subgroup.finiteIndex_of_leftCoset_cover_const (s := s) (g := fun g => g.val.val.toMul) +- simp_rw [Set.insert_eq, Subgroup.closure_union] +- rename_bvar i → g +- +- +- conv => +- arg 1 +- arg 1 +- intro i +- arg 1 +- intro hi +- rw [sup_comm] +- rw [Subgroup.coe_mul_of_right_le_normalizer_left _ _ (Subgroup.le_normalizer_of_conj_mem (by +- intro gamma_pow h_gamma_pow n hn +- simp_rw [← MonoidHom.map_closure] at hn +- simp_rw [← MonoidHom.map_closure] +- apply map_N'_invariant_gamma_one _ h_gamma_pow _ hn +- ))] +- rw [set_smul_eq_mul] +- rw [← mul_assoc] +- rw [← set_smul_eq_mul] +- +- +- simp_rw [← Set.iUnion_mul] +- conv => +- arg 1 +- arg 1 +- equals Additive.toMul '' data.φ.ker => +- apply_fun (fun s => Additive.toMul '' (Subtype.val '' s)) at s_cosets +- conv at s_cosets => +- rhs +- equals Additive.toMul '' data.φ.ker => +- ext a +- simp +- rw [← s_cosets] +- conv => +- arg 1 +- arg 1 +- intro i +- arg 1 +- intro hi +- arg 2 +- +- simp_rw [← MonoidHom.map_closure] +- +- simp only [Set.image_image] +- first +- | erw [Set.image_iUnion₂] +- | rw [Set.image_iUnion₂] +- | simp only [Set.image_iUnion] +- apply Set.iUnion_congr +- intro i +- apply Set.iUnion_congr +- intro hi +- ext z +- simp only [closure_eq, coe_map] +- rw [Set.mem_smul_set] +- rw [Set.mem_image] +- refine ⟨?_, ?_⟩ +- . +- intro hy +- obtain ⟨a, ha⟩ := hy +- have foo := ha.1 +- rw [Set.mem_image] at foo +- obtain ⟨b, b_mem, a_eq_b⟩ := foo +- have N'_gen := N'_fg.choose_spec +- rw [N'_gen] at b_mem +- refine ⟨(↑i : Multiplicative ↥data.φ.ker) • b, Set.smul_mem_smul_set b_mem, ?_⟩ +- rw [← ha.2, ← a_eq_b] +- rfl +- . +- intro hx +- obtain ⟨x, hx, x_eq⟩ := hx +- erw [Set.mem_smul_set] at hx +- obtain ⟨n, hn, x_eq_n⟩ := hx +- refine ⟨new_N'_map n, ?_, ?_⟩ +- . +- rw [Set.mem_image] +- have N'_gen := N'_fg.choose_spec +- rw [← N'_gen] at hn +- exact ⟨n, hn, rfl⟩ +- . rw [← x_eq, ← x_eq_n] +- rfl +- +- +- conv => +- arg 1 +- lhs +- equals ↑data.φ.ker.toSubgroup' => +- ext a +- simp +- +- rw [← Subgroup.coe_mul_of_right_le_normalizer_left _ _] +- . +- simp +- rw [eq_top_iff] +- have ker_gen := e_i_and_gamma_generates_G data.φ γ hγ +- have foo := new_generates.generates +- simp at foo +- rw [← foo, ← ker_gen] +- simp_rw [Subgroup.closure_union] +- conv => +- lhs +- arg 1 +- equals Subgroup.closure {γ.toMul} => +- simp [Subgroup.closure_union] +- conv => +- lhs +- arg 1 +- equals {γ.toMul, γ.toMul⁻¹} => rfl +- rw [Set.insert_eq] +- rw [Subgroup.closure_union] +- simp +- +- simp_rw [← Subgroup.closure_union] +- rw [Subgroup.closure_le] +- rw [Set.union_subset_iff] +- refine ⟨?_, ?_⟩ +- . +- intro a ha +- simp at ha +- simp +- apply Subgroup.mem_sup_right +- simp [ha] +- . +- intro a ha +- apply Subgroup.mem_sup_left +- simp +- simp at ha +- obtain ⟨p, hp, a_eq⟩ := ha +- simp [e_i_with_gamma] at a_eq +- rw [← a_eq] +- conv => +- arg 1 +- arg 2 +- equals (ofMul p) + -((data.φ (ofMul p)) • γ) => +- rfl +- +- +- simp [hγ] +- . +- apply Subgroup.le_normalizer_of_conj_mem +- intro b hb a ha +- rw [Subgroup.mem_closure_singleton] at hb +- obtain ⟨n, b_eq⟩ := hb +- simp [← b_eq] +- simp at ha +- exact ha +- . have foo := data.finite_index +- rw [Subgroup.finiteIndex_iff] at foo +- exact foo + + + -- Decompose list of {e_k, γ}: +@@ -988,8 +980,6 @@ lemma theorem_3_1.{u} [hGS: Generates.{u}] (data: Theorem3_1_Input G) (d: ℕ) ( + -- * If the head is γ^n e_i for some n (collecting up adjacent γ), then choose γ_n,i = γ^n * e_i * γ^(-n) + -- * If the remaining list is just γ^n, then n must be 0 (since we maintained the invariant) + +-#print axioms three_two_gamma_m_generates +-#print axioms three_two_ker_fg + + -- NOTE: from https://www.numdam.org/item/PMIHES_1981__53__53_0.pdf + -- it looks like our definition of 'polynomial growth' should use `S ∪ S⁻¹` +@@ -1023,7 +1013,5 @@ theorem main_gromov_theorem (n: ℕ) (h: HasPolynomialGrowthD S n): Group.IsVirt + have prev := @ih Q_generates (n - 1) Q_poly (by omega) + exact prev + +-#print sorries main_gromov_theorem +-#print axioms main_gromov_theorem + + end GeneratesNS +diff --git a/Gromov/GrowthZero.lean b/Gromov/GrowthZero.lean +index 95e1ac0..95a2c15 100644 +--- a/Gromov/GrowthZero.lean ++++ b/Gromov/GrowthZero.lean +@@ -11,9 +11,6 @@ public import Gromov.ThreeTwoGenerates + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +@@ -28,9 +25,7 @@ include hGS + + open scoped RealInnerProductSpace + +-set_option synthInstance.maxHeartbeats 500000 + +-set_option maxHeartbeats 1000000 + + open MeasureTheory + +@@ -48,13 +43,12 @@ structure GeneratesWithParam (G: Type*) [Group G] [DecidableEq G] where + has_inv: ∀ g ∈ S, g⁻¹ ∈ S + g_infinite: Infinite G + ++omit hGS in + lemma one_mem_S {G: Type*} [Group G] [DecidableEq G] {n: ℕ} (data: Theorem3_1_Input G) (hGS: GeneratesWithParam data.G') (γ: Additive data.G') (hγ: data.φ γ = 1): 0 ∈ S_n_ker_phi hGS.S data.φ γ hγ n := by + simp [S_n_ker_phi] + + +--- The generating set of `ker φ` used below, shared between the `new_g_growth` +--- hypothesis and the `S` field so that `g_growth := new_g_growth` is definitionally +--- trivial (avoids an expensive `whnf` on the two separately-elaborated `Finset`s). ++-- A symmetric generating set for the kernel of the homomorphism to ℤ. + omit hGS in + @[expose] + noncomputable def ker_S {G: Type*} [Group G] [DecidableEq G] (data: Theorem3_1_Input G) +@@ -63,9 +57,8 @@ noncomputable def ker_S {G: Type*} [Group G] [DecidableEq G] (data: Theorem3_1_I + (Finset.image Additive.toMul (S_n_ker_phi hGS.S data.φ γ hγ n)) ∪ + (Finset.image Additive.toMul ((S_n_ker_phi hGS.S data.φ γ hγ n)))⁻¹ + +--- TODO - figure out how to make this a 'let' without adding it to typeclass search + omit hGS in +-@[expose] ++@[expose, instance_reducible] + noncomputable def ker_generates {n: ℕ} {G: Type*} [Group G] [DecidableEq G] (data: Theorem3_1_Input G) (hGS: GeneratesWithParam data.G') (γ: data.G') (hγ: data.φ γ = 1) + (ker_infinite: Infinite (Multiplicative data.φ.ker)) + (ker_generates: AddSubgroup.closure (Additive.ofMul '' (three_two_S_n hGS.S data.φ γ (n))) = data.φ.ker) +@@ -104,13 +97,9 @@ noncomputable def ker_generates {n: ℕ} {G: Type*} [Group G] [DecidableEq G] (d + simp at foo + unfold S_n_ker_phi + simp +- first +- | erw [Finset.coe_insert, Set.image_insert_eq, toMul_zero, Subgroup.closure_insert_one] +- | rw [Finset.coe_insert, Set.image_insert_eq, toMul_zero, Subgroup.closure_insert_one] +- | simp only [Finset.coe_insert, Set.image_insert_eq, toMul_zero, Subgroup.closure_insert_one] + rw [← Subgroup.mem_map_iff_mem (f := f)] +- . +- simp only [f, Subgroup.subtype_apply] ++ · ++ simp only [f] + rw [MonoidHom.map_closure] + simp + conv => +@@ -131,7 +120,7 @@ noncomputable def ker_generates {n: ℕ} {G: Type*} [Group G] [DecidableEq G] (d + have hbk : b ∈ three_two_S_n hGS.S data.φ γ n := by simpa using hb + exact ⟨_, ⟨_, ⟨⟨b, hbk⟩, rfl⟩, rfl⟩, rfl⟩ + exact foo +- . simp [f] ++ · simp [f] + intro x y hxy + simpa using hxy + simp +@@ -140,7 +129,6 @@ noncomputable def ker_generates {n: ℕ} {G: Type*} [Group G] [DecidableEq G] (d + rw [Finset.mem_image] + use 0 + simp +- -- TODO - figure out wht 'apply one_mem_S' is slow + exact one_mem_S data hGS γ hγ + + has_inv := by +@@ -156,6 +144,231 @@ noncomputable def ker_generates {n: ℕ} {G: Type*} [Group G] [DecidableEq G] (d + } + + ++private lemma kernel_thickening_card (n r : ℕ) (φ : (Additive G) →+ ℤ) (γ : G) (hγ : φ γ = 1) : ++ let mul_by_i := fun (g : G) (i : Fin r) => g * (γ ^ i.val); ++ #((((((S_n_ker_phi S φ γ hγ n) ∪ (-(S_n_ker_phi S φ γ hγ n))).image Multiplicative.ofAdd) ^ r).image ofMul).biUnion (fun a => Finset.image (mul_by_i a.val) Finset.univ)) = r * #(r • ((S_n_ker_phi S φ γ hγ n) ∪ -((S_n_ker_phi S φ γ hγ n)))) := by ++ dsimp only ++ let mul_by_i := fun (g: G) (i: Fin r) => g * (γ ^ i.val) ++ change #((((((S_n_ker_phi S φ γ hγ n) ∪ (-(S_n_ker_phi S φ γ hγ n))).image Multiplicative.ofAdd) ^ r).image ofMul).biUnion (fun a => Finset.image (mul_by_i a.val) Finset.univ)) = r * #(r • ((S_n_ker_phi S φ γ hγ n) ∪ -((S_n_ker_phi S φ γ hγ n)))) ++ have new_phi_gamma: φ (Additive.ofMul γ) = 1 := hγ ++ have card_mul_range (g: G): #(Finset.image (mul_by_i g) Finset.univ) = r := by ++ rw [Finset.card_image_of_injOn] ++ · simp ++ · ++ ++ intro j _ k _ mul_eq ++ simp [mul_by_i] at mul_eq ++ apply_fun φ ∘ (Additive.ofMul) at mul_eq ++ simp [new_phi_gamma] at mul_eq ++ rw [Fin.ext_iff] ++ exact mul_eq ++ ++ ++ rw [Finset.card_biUnion] ++ · ++ simp_rw [card_mul_range] ++ simp ++ rw [mul_comm] ++ conv => ++ lhs ++ arg 2 ++ arg 1 ++ equals r • ((S_n_ker_phi S φ γ hγ n) ∪ -(S_n_ker_phi S φ γ hγ n)) => ++ ext a ++ rw [Finset.mem_image] ++ simp_rw [Finset.mem_pow] ++ refine Iff.trans ?_ Finset.mem_nsmul.symm ++ refine ⟨?_, ?_⟩ ++ · intro h ++ obtain ⟨b, ⟨f, hf⟩, b_eq_a⟩ := h ++ use (fun i => ⟨(f i).val, (by ++ have f_prop := (f i).property ++ rw [Finset.mem_image] at f_prop ++ obtain ⟨g, g_mem, hg⟩ := f_prop ++ rw [← hg] ++ exact g_mem ++ )⟩) ++ rw [← b_eq_a] ++ rw [← hf] ++ rfl ++ · intro h ++ obtain ⟨f, hf⟩ := h ++ use a ++ refine ⟨?_, rfl⟩ ++ use (fun i => ⟨(f i).val, (by ++ have f_prop := (f i).property ++ rw [Finset.mem_image] ++ use (f i).val ++ refine ⟨f_prop, ?_⟩ ++ rfl ++ )⟩) ++ rw [← hf] ++ rfl ++ ++ ++ · ++ intro a ha b hb hab x h_first h_second ++ simp at h_first ++ simp at h_second ++ simp ++ ++ by_contra! ++ obtain ⟨p, hp⟩ := this ++ have orig_h_first := h_first hp ++ have orig_h_second := h_second hp ++ specialize h_first hp ++ specialize h_second hp ++ ++ simp at h_first ++ simp at h_second ++ ++ obtain ⟨y, hy⟩ := h_first ++ obtain ⟨z, hz⟩ := h_second ++ ++ have orig_hy := hy ++ have orig_hz := hz ++ ++ rw [← hz] at hy ++ simp [mul_by_i] at hy ++ apply_fun φ ∘ (Additive.ofMul) at hy ++ simp [new_phi_gamma] at hy ++ ++ have a_ker: a.val ∈ φ.ker := by ++ simp ++ ++ have b_ker: b.val ∈ φ.ker := by ++ simp ++ ++ rw [AddMonoidHom.mem_ker] at a_ker ++ rw [AddMonoidHom.mem_ker] at b_ker ++ simp [ofMul] at hy ++ simp [a_ker, b_ker] at hy ++ ++ rw [← Fin.ext_iff] at hy ++ rw [hy] at orig_hy ++ rw [← orig_hy] at orig_hz ++ simp [mul_by_i] at orig_hz ++ rw [eq_comm] at orig_hz ++ contradiction ++ ++ ++ ++private lemma kernel_thickening_bound (n r : ℕ) (φ : (Additive G) →+ ℤ) (γ : G) (hγ : φ γ = 1) : ++ let mul_by_i := fun (g : G) (i : Fin r) => g * (γ ^ i.val); ++ #((((((S_n_ker_phi S φ γ hγ n) ∪ -(S_n_ker_phi S φ γ hγ n)).image Multiplicative.ofAdd) ^ r).image ofMul).biUnion (fun a => Finset.image (mul_by_i a.val) Finset.univ)) ≤ #(((three_two_S_n S φ γ n) ∪ ((three_two_S_n S φ γ n)⁻¹) ∪ {γ} ∪ {1}) ^ (2 * r)) := by ++ dsimp only ++ let mul_by_i := fun (g : G) (i : Fin r) => g * (γ ^ i.val) ++ change #((((((S_n_ker_phi S φ γ hγ n) ∪ -(S_n_ker_phi S φ γ hγ n)).image Multiplicative.ofAdd) ^ r).image ofMul).biUnion (fun a => Finset.image (mul_by_i a.val) Finset.univ)) ≤ #(((three_two_S_n S φ γ n) ∪ ((three_two_S_n S φ γ n)⁻¹) ∪ {γ} ∪ {1}) ^ (2 * r)) ++ ++ grw [Finset.card_le_card] ++ intro a ha ++ rw [Finset.mem_biUnion] at ha ++ obtain ⟨s, s_mem, a_mem⟩ := ha ++ rw [Finset.mem_image] at a_mem ++ obtain ⟨k, _, hk⟩ := a_mem ++ simp [mul_by_i] at hk ++ rw [← hk] ++ rw [two_mul] ++ rw [pow_add] ++ apply Finset.mul_mem_mul ++ · ++ unfold S_n_ker_phi at s_mem ++ ++ rw [Finset.mem_image] at s_mem ++ obtain ⟨z, z_mem, hz⟩ := s_mem ++ rw [← hz] ++ ++ rw [Finset.mem_pow] at z_mem ++ obtain ⟨f, hf⟩ := z_mem ++ rw [Finset.mem_pow] ++ use (fun i => ⟨(f i).val.val, (by ++ have f_prop := (f i).property ++ rw [Finset.mem_image] at f_prop ++ obtain ⟨g, g_mem, hg⟩ := f_prop ++ rw [← hg] ++ simp at g_mem ++ cases g_mem ++ · ++ rename_i g_eq_zero ++ apply Finset.mem_union_right ++ rw [Finset.mem_singleton, g_eq_zero] ++ rfl ++ · rename_i g_eq_nonzero ++ cases g_eq_nonzero ++ · rename_i left ++ obtain ⟨z, z_mem, hz⟩ := left ++ rw [← hz] ++ apply Finset.mem_union_left ++ apply Finset.mem_union_left ++ apply Finset.mem_union_left ++ exact z_mem ++ · ++ rename_i right ++ obtain ⟨z, z_mem, hz⟩ := right ++ apply Finset.mem_union_left ++ apply Finset.mem_union_left ++ apply Finset.mem_union_right ++ simp ++ conv => ++ arg 2 ++ equals (-g).val => ++ rfl ++ rw [← hz] ++ exact z_mem ++ )⟩) ++ rw [← hf, ofMul_list_prod, List.map_ofFn] ++ erw [AddSubmonoidClass.coe_list_sum, List.map_ofFn] ++ rfl ++ · ++ ++ ++ have gamma_r_subset: ({γ, 1} : Finset G)^r ⊆ ((three_two_S_n S φ γ n) ∪ ((three_two_S_n S φ γ n)⁻¹) ∪ {γ} ∪ {1})^r := by ++ apply Finset.pow_subset_pow ++ · grind ++ · grind ++ · simp ++ ++ have gamma_subset: ({γ, 1} : Finset G)^k.val ⊆ ({γ, 1} : Finset G)^r := by ++ apply Finset.pow_subset_pow ++ · simp ++ · simp ++ · simp ++ ++ ++ have gamma_mem_self: γ^k.val ∈ ({γ, 1} : Finset G)^k.val := by ++ apply Finset.pow_mem_pow ++ simp ++ ++ grind ++ ++ ++ ++omit hGS in ++private lemma multiplicative_symm_pow {A : Type*} [AddGroup A] [DecidableEq A] ++ (s : Finset A) (r : ℕ) : ++ ((show Finset (Multiplicative A) from s) ∪ (show Finset (Multiplicative A) from s)⁻¹)^r = ++ (show Finset (Multiplicative A) from r • (s ∪ -s)) := by ++ ext a ++ rw [Finset.mem_pow] ++ refine Iff.trans ?_ (Finset.mem_nsmul (α := A) (s := s ∪ -s) (a := a.toAdd) (n := r)).symm ++ constructor ++ · rintro ⟨f, hf⟩ ++ exact ⟨f, hf⟩ ++ · rintro ⟨f, hf⟩ ++ exact ⟨f, hf⟩ ++ ++omit hGS in ++private lemma cancel_growth_factor {N r b d : ℕ} (hr : 0 < r) (hd : 1 ≤ d) ++ (h : r * N ≤ b * (2 * r)^d) : N ≤ (b * 2^d) * r^(d-1) := by ++ have hp : r^d = r * r^(d-1) := by ++ calc ++ r^d = r^((d-1)+1) := by rw [Nat.sub_add_cancel hd] ++ _ = r * r^(d-1) := by rw [pow_succ, mul_comm] ++ apply Nat.le_of_mul_le_mul_left (c := r) ?_ hr ++ calc ++ r * N ≤ b * (2*r)^d := h ++ _ = r * ((b * 2^d) * r^(d-1)) := by rw [mul_pow, hp]; ac_rfl ++ + lemma three_two_kernel_poly_growth (d: ℕ) (hd: d >= 1) (n: ℕ) (hG: HasPolynomialGrowthD S d ) (φ: (Additive G) →+ ℤ) (γ: G) (hγ : φ γ = 1) + : HasPolynomialGrowthD (G := Multiplicative φ.ker) (d - 1) (S := (S_n_ker_phi S φ γ hγ n) ∪ (S_n_ker_phi S φ γ hγ n)⁻¹) := by + +@@ -165,7 +378,7 @@ lemma three_two_kernel_poly_growth (d: ℕ) (hd: d >= 1) (n: ℕ) (hG: HasPolyn + obtain ⟨a, ha⟩ := hG + + by_cases a_eq_zero: a = 0 +- . ++ · + simp [a_eq_zero] at ha + specialize ha 1 (by simp) + simp at ha +@@ -186,236 +399,16 @@ lemma three_two_kernel_poly_growth (d: ℕ) (hd: d >= 1) (n: ℕ) (hG: HasPolyn + specialize ker_poly (2 * r) (by omega) + + +- let mul_by_i := fun (g: G) (i: Fin r) => g * (γ ^ i.val) +- have new_phi_gamma: φ (Additive.ofMul γ) = 1 := hγ +- have card_mul_range (g: G): #(Finset.image (mul_by_i g) Finset.univ) = r := by +- rw [Finset.card_image_of_injOn] +- . simp +- . +- +- intro j _ k _ mul_eq +- simp [mul_by_i] at mul_eq +- apply_fun φ ∘ (Additive.ofMul) at mul_eq +- simp [new_phi_gamma] at mul_eq +- rw [Fin.ext_iff] +- exact mul_eq +- +- have card_union: #((((((S_n_ker_phi S φ γ hγ n) ∪ (-(S_n_ker_phi S φ γ hγ n))).image Multiplicative.ofAdd) ^ r).image ofMul).biUnion (fun a => Finset.image (mul_by_i a.val) Finset.univ)) = r * #(r • ((S_n_ker_phi S φ γ hγ n) ∪ -((S_n_ker_phi S φ γ hγ n)))) := by +- rw [Finset.card_biUnion] +- . +- simp_rw [card_mul_range] +- simp +- rw [mul_comm] +- conv => +- lhs +- arg 2 +- arg 1 +- equals r • ((S_n_ker_phi S φ γ hγ n) ∪ -(S_n_ker_phi S φ γ hγ n)) => +- ext a +- rw [Finset.mem_image] +- simp_rw [Finset.mem_pow] +- refine Iff.trans ?_ Finset.mem_nsmul.symm +- refine ⟨?_, ?_⟩ +- . intro h +- obtain ⟨b, ⟨f, hf⟩, b_eq_a⟩ := h +- use (fun i => ⟨(f i).val, (by +- have f_prop := (f i).property +- rw [Finset.mem_image] at f_prop +- obtain ⟨g, g_mem, hg⟩ := f_prop +- rw [← hg] +- exact g_mem +- )⟩) +- rw [← b_eq_a] +- rw [← hf] +- rfl +- . intro h +- obtain ⟨f, hf⟩ := h +- use a +- refine ⟨?_, rfl⟩ +- use (fun i => ⟨(f i).val, (by +- have f_prop := (f i).property +- rw [Finset.mem_image] +- use (f i).val +- refine ⟨f_prop, ?_⟩ +- rfl +- )⟩) +- rw [← hf] +- rfl +- +- +- . +- intro a ha b hb hab x h_first h_second +- simp at h_first +- simp at h_second +- simp +- +- by_contra! +- obtain ⟨p, hp⟩ := this +- have orig_h_first := h_first hp +- have orig_h_second := h_second hp +- specialize h_first hp +- specialize h_second hp +- +- simp at h_first +- simp at h_second +- +- obtain ⟨y, hy⟩ := h_first +- obtain ⟨z, hz⟩ := h_second +- +- have orig_hy := hy +- have orig_hz := hz +- +- rw [← hz] at hy +- simp [mul_by_i] at hy +- apply_fun φ ∘ (Additive.ofMul) at hy +- simp [new_phi_gamma] at hy +- +- have a_ker: a.val ∈ φ.ker := by +- simp +- +- have b_ker: b.val ∈ φ.ker := by +- simp +- +- rw [AddMonoidHom.mem_ker] at a_ker +- rw [AddMonoidHom.mem_ker] at b_ker +- simp [ofMul] at hy +- simp [a_ker, b_ker] at hy +- +- rw [← Fin.ext_iff] at hy +- rw [hy] at orig_hy +- rw [← orig_hy] at orig_hz +- simp [mul_by_i] at orig_hz +- rw [eq_comm] at orig_hz +- contradiction +- +- +- have card_union_le: #((((((S_n_ker_phi S φ γ hγ n) ∪ -(S_n_ker_phi S φ γ hγ n)).image Multiplicative.ofAdd) ^ r).image ofMul).biUnion (fun a => Finset.image (mul_by_i a.val) Finset.univ)) ≤ #(((three_two_S_n S φ γ n) ∪ ((three_two_S_n S φ γ n)⁻¹) ∪ {γ} ∪ {1}) ^ (2 * r)) := by +- grw [Finset.card_le_card] +- intro a ha +- rw [Finset.mem_biUnion] at ha +- obtain ⟨s, s_mem, a_mem⟩ := ha +- rw [Finset.mem_image] at a_mem +- obtain ⟨k, _, hk⟩ := a_mem +- simp [mul_by_i] at hk +- rw [← hk] +- rw [two_mul] +- rw [pow_add] +- apply Finset.mul_mem_mul +- . +- unfold S_n_ker_phi at s_mem +- +- rw [Finset.mem_image] at s_mem +- obtain ⟨z, z_mem, hz⟩ := s_mem +- rw [← hz] +- +- rw [Finset.mem_pow] at z_mem +- obtain ⟨f, hf⟩ := z_mem +- rw [Finset.mem_pow] +- use (fun i => ⟨(f i).val.val, (by +- have f_prop := (f i).property +- rw [Finset.mem_image] at f_prop +- obtain ⟨g, g_mem, hg⟩ := f_prop +- rw [← hg] +- simp at g_mem +- cases g_mem +- . +- rename_i g_eq_zero +- apply Finset.mem_union_right +- rw [Finset.mem_singleton, g_eq_zero] +- first | rfl | simp +- . rename_i g_eq_nonzero +- cases g_eq_nonzero +- . rename_i left +- obtain ⟨z, z_mem, hz⟩ := left +- rw [← hz] +- apply Finset.mem_union_left +- apply Finset.mem_union_left +- apply Finset.mem_union_left +- exact z_mem +- . +- rename_i right +- obtain ⟨z, z_mem, hz⟩ := right +- apply Finset.mem_union_left +- apply Finset.mem_union_left +- apply Finset.mem_union_right +- simp +- conv => +- arg 2 +- equals (-g).val => +- rfl +- rw [← hz] +- exact z_mem +- )⟩) +- rw [← hf, ofMul_list_prod, List.map_ofFn] +- first +- | (erw [AddSubmonoidClass.coe_list_sum, List.map_ofFn]; rfl) +- | (rw [AddSubmonoidClass.coe_list_sum, List.map_ofFn]; rfl) +- | (simp only [AddSubmonoidClass.coe_list_sum, List.map_ofFn]; rfl) +- . +- +- +- have gamma_r_subset: ({γ, 1} : Finset G)^r ⊆ ((three_two_S_n S φ γ n) ∪ ((three_two_S_n S φ γ n)⁻¹) ∪ {γ} ∪ {1})^r := by +- apply Finset.pow_subset_pow +- . grind +- . grind +- . simp +- +- have gamma_subset: ({γ, 1} : Finset G)^k.val ⊆ ({γ, 1} : Finset G)^r := by +- apply Finset.pow_subset_pow +- . simp +- . simp +- . simp +- +- +- have gamma_mem_self: γ^k.val ∈ ({γ, 1} : Finset G)^k.val := by +- apply Finset.pow_mem_pow +- simp +- +- grind +- ++ let mul_by_i := fun (g : G) (i : Fin r) => g * (γ ^ i.val) ++ have card_union := kernel_thickening_card n r φ γ hγ ++ have card_union_le := kernel_thickening_bound n r φ γ hγ ++ dsimp only at card_union card_union_le + + rw [card_union] at card_union_le +- grw [ker_poly] at card_union_le +- rw [mul_pow] at card_union_le +- rw [← mul_assoc] at card_union_le +- rw [mul_comm] at card_union_le +- rw [← Nat.le_div_iff_mul_le] at card_union_le +- . +- rw [Nat.mul_div_assoc] at card_union_le +- . +- nth_rw 3 [← pow_one (a := r)] at card_union_le +- rw [Nat.pow_div] at card_union_le +- . +- -- TODO - get rid of this obnoxious Additive/Multiplicative defeq abuse +- conv => +- lhs +- arg 1 +- equals r • ((S_n_ker_phi S φ γ hγ n) ∪ -(S_n_ker_phi S φ γ hγ n)) => +- ext a +- rw [Finset.mem_pow] +- -- TODO - why do we need explicit args here +- refine Iff.trans ?_ Finset.mem_nsmul.symm +- refine ⟨?_, ?_⟩ +- . +- intro hf +- obtain ⟨f, hf⟩ := hf +- use f +- exact hf +- . intro hf +- obtain ⟨f, hf⟩ := hf +- use f +- exact hf +- exact card_union_le +- . omega +- . omega +- +- . +- nth_rw 1 [← pow_one (a := r)] +- apply Nat.pow_dvd_pow +- omega +- . omega +- +-#print axioms three_two_kernel_poly_growth ++ have hbound := cancel_growth_factor (by omega : 0 < r) hd (card_union_le.trans ker_poly) ++ rw [multiplicative_symm_pow] ++ exact hbound ++ + + + omit hGS in +@@ -436,7 +429,6 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + have S_closure := hGS.generates + + let pow_cards := Set.range (fun (n: ℕ) => #(S ^ n)) +- -- TODO - this can probably be much simpler + have pow_cards_bounded: ∃ y, ∀ n ∈ pow_cards, n ≤ y := by + use a + intro n hn +@@ -445,9 +437,8 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + rw [← hy] + + by_cases y_eq_zero: y = 0 +- . simp [y_eq_zero] ++ · simp [y_eq_zero] + +- -- TODO - deduplicate this + have a_ne_zero: a ≠ 0 := by + by_contra! + rw [this] at ha +@@ -458,20 +449,20 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + simp at one_mem + + omega +- . by_cases y_eq_one: y = 1 +- . ++ · by_cases y_eq_one: y = 1 ++ · + simp [y_eq_one] + have card_mono := Finset.card_pow_mono (s := S) (m := 1) (n := 2) (by simp) (by simp) + have card_two_le := ha 2 (by simp) + simp at card_mono + linarith +- . ++ · + exact ha y (by omega) + + + classical + have max_card_mem := Nat.sSup_mem (s := pow_cards) ?_ ?_ +- . simp [pow_cards] at max_card_mem ++ · simp [pow_cards] at max_card_mem + obtain ⟨y, hy⟩ := max_card_mem + + +@@ -483,7 +474,7 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + exact Generates.one_mem + | mem x hx => + by_cases y_eq_zero: y = 0 +- . ++ · + rw [y_eq_zero] + rw [y_eq_zero] at hy + simp at hy +@@ -492,27 +483,27 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + have find_le := Nat.find_spec pow_cards_bounded + rw [← y_eq] at find_le + have S_one_le := find_le #(S) ?_ +- . ++ · + simp [pow_cards] at S_one_le + rw [← hy] at S_one_le + rw [Finset.card_le_one] at S_one_le + have one_mem: 1 ∈ S := by exact Generates.one_mem + have x_eq := S_one_le 1 one_mem x hx + apply x_eq.symm +- . simp [pow_cards] ++ · simp [pow_cards] + use 1 + simp +- . ++ · + have pow_mono := Finset.pow_subset_pow_right (s := S) (Generates.one_mem) (n := y) (m := 1) (by omega) + simp at pow_mono + apply pow_mono hx + | mul a b a_mem_closure b_mem_closure a_mem_pow b_mem_pow => + by_cases y_eq_zero: y = 0 +- . ++ · + simp [y_eq_zero] + simp [y_eq_zero] at a_mem_pow b_mem_pow + simp [a_mem_pow, b_mem_pow] +- . ++ · + by_contra! + have a_b_mem_two: a * b ∈ (S ^ (y * 2)) := by + have mem_mul := Finset.mul_mem_mul a_mem_pow b_mem_pow +@@ -535,10 +526,10 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + have find_le := Nat.find_spec pow_cards_bounded + rw [← y_eq] at find_le + have reverse_le := find_le #(S ^ (y * 2)) ?_ +- . ++ · + simp [pow_cards] at reverse_le + linarith +- . simp [pow_cards] ++ · simp [pow_cards] + | inv a ha a_mem_pow => + rw [← Finset.mem_inv'] + rw [← inv_pow] +@@ -559,11 +550,11 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + rw [← S_closure] + ext a + refine ⟨?_, ?_⟩ +- . intro ha ++ · intro ha + simp at ha + rw [← Finset.coe_pow] + exact all_closure_mem a ha +- . intro ha ++ · intro ha + simp + exact mem_closure a + +@@ -571,10 +562,10 @@ lemma finite_of_growth_zero (h: HasPolynomialGrowthD S 0): Finite G := by + rw [← Finset.coe_pow] + exact Finset.finite_toSet (S ^ y) + exact G_finite +- . ++ · + simp [pow_cards] + apply Set.range_nonempty +- . ++ · + rw [bddAbove_def] + exact pow_cards_bounded + +@@ -599,6 +590,5 @@ lemma growth_exponent_pos {d : ℕ} (h: HasPolynomialGrowthD S d): 0 < d := by + have := hGS.g_infinite + exact (not_finite G) + +--- TODO - add an explicit top-level universe parameter to avoid this 'omit hGS' hack + + end GeneratesNS +diff --git a/Gromov/Harmonic.lean b/Gromov/Harmonic.lean +index 939cd59..b28dc07 100644 +--- a/Gromov/Harmonic.lean ++++ b/Gromov/Harmonic.lean +@@ -8,13 +8,10 @@ public import Gromov.Harmonic.CaseOne + + `nontrivial_harmonic_case_two` and the main result `exists_nontrivial_harmonic`. + +-Root of the `Gromov.Harmonic` hierarchy. + -/ + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS +@@ -32,12 +29,10 @@ open MeasureTheory + + open scoped RealInnerProductSpace + +-set_option maxHeartbeats 2000000 in + lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun n: ℕ => MeasureTheory.eLpNorm (f_n n - (Conv (f_n n) (delta s.val))) 1 MeasureTheory.volume) Filter.atTop (nhds 0))): ∃ F: LipschitzH , ∀ z: ℝ, F ≠ ConstLipschitzH z := by + obtain ⟨s, hs⟩ := f_n_limit + let H_n := fun n g => if ((f_n n g⁻¹) - (Conv (f_n n) (delta s.val)) g⁻¹) ≠ 0 then ((f_n n g⁻¹) - (Conv (f_n n) (delta s.val)) g⁻¹) / |((f_n n g⁻¹) - (Conv (f_n n) (delta s.val)) g⁻¹)| else 1 + +- -- TODO - why can't we write '∞' here + have H_n_norm: ∀ n: ℕ, MeasureTheory.eLpNorm (H_n n) (p := ⊤) MeasureTheory.volume = 1 := by + intro n + simp [H_n] +@@ -49,24 +44,24 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + simp [H_n] + intro g + split_ifs +- . simp +- . ++ · simp ++ · + + rename_i foo + by_cases val_pos: 0 ≤ ((f_n n g⁻¹) - (Conv (f_n n) (delta s.val)) g⁻¹) +- . ++ · + rw [abs_of_nonneg val_pos] + rw [div_self] +- . simp +- . exact foo +- . ++ · simp ++ · exact foo ++ · + rw [abs_of_neg] +- . ++ · + rw [div_neg_self] +- . ++ · + simp +- . exact foo +- . linarith ++ · exact foo ++ · linarith + + unfold H_n at h_norm_one + simp at h_norm_one +@@ -78,21 +73,21 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + simp [H_n] + simp [f_conv_delta] + split_ifs +- . linarith +- . ++ · linarith ++ · + rename_i diff_zero + by_cases val_pos: 0 ≤ f_n n g - f_n n ((↑s)⁻¹ * g) +- . ++ · + rw [abs_of_nonneg val_pos] + rw [div_self] +- . linarith +- . assumption +- . ++ · linarith ++ · assumption ++ · + rw [abs_of_neg] +- . rw [div_neg_self] +- . linarith +- . assumption +- . ++ · rw [div_neg_self] ++ · linarith ++ · assumption ++ · + simpa using val_pos + + have fn_sub_norm: ∀ n: ℕ, eLpNorm (f_n n - (Conv (f_n n) (delta s.val))) 1 = ENNReal.ofReal |((Conv (H_n n) (f_n n)) 1) - ((Conv (H_n n) (f_n n)) s⁻¹)| := by +@@ -108,26 +103,26 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + equals (H_n n g⁻¹) * (f_n n g - (Conv (f_n n) (delta s.val)) g) => + simp [H_n] + split_ifs +- . ++ · + rename_i diff_eq_zero + simp [diff_eq_zero] +- . ++ · + rename_i diff_ne_zero + by_cases val_pos: 0 ≤ ((f_n n g) - (Conv (f_n n) (delta s.val)) g) +- . ++ · + rw [abs_of_nonneg] +- . ++ · + rw [div_self] + simp + apply diff_ne_zero +- . exact val_pos +- . ++ · exact val_pos ++ · + rw [abs_of_neg] +- . ++ · + rw [div_neg_self] + simp + exact diff_ne_zero +- . ++ · + simpa using val_pos + + rw [conv_eq_sum (by +@@ -138,8 +133,8 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + apply Set.Finite.inter_of_right + apply Set.Finite.subset (hs := ?_) (ht := Finset.support_sum _ _) + refine Set.Finite.biUnion' ?_ ?_ +- . exact Set.toFinite (Membership.mem Finset.univ.val) +- . intro m hm ++ · exact Set.toFinite (Membership.mem Finset.univ.val) ++ · intro m hm + apply mu_conv_finsupp + )] + +@@ -151,8 +146,8 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + apply Set.Finite.inter_of_right + apply Set.Finite.subset (hs := ?_) (ht := Finset.support_sum _ _) + refine Set.Finite.biUnion' ?_ ?_ +- . exact Set.toFinite (Membership.mem Finset.univ.val) +- . intro m hm ++ · exact Set.toFinite (Membership.mem Finset.univ.val) ++ · intro m hm + apply mu_conv_finsupp + )] + +@@ -171,14 +166,14 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + apply Set.Finite.inter_of_right + apply Set.Finite.subset (hs := ?_) (ht := Finset.support_sum _ _) + refine Set.Finite.biUnion' ?_ ?_ +- . exact Set.toFinite (Membership.mem Finset.univ.val) +- . ++ · exact Set.toFinite (Membership.mem Finset.univ.val) ++ · + intro m hm + apply Set.Finite.of_injOn (f := fun a => ((Additive.toMul a))⁻¹) (ht := mu_conv_finsupp m) +- . ++ · + intro a ha + exact ha +- . intro a ha b hb ++ · intro a ha b hb + simp + ) (by + apply summable_of_hasFiniteSupport +@@ -190,14 +185,14 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + apply Set.Finite.inter_of_right + apply Set.Finite.subset (hs := ?_) (ht := Finset.support_sum _ _) + refine Set.Finite.biUnion' ?_ ?_ +- . exact Set.toFinite (Membership.mem Finset.univ.val) +- . ++ · exact Set.toFinite (Membership.mem Finset.univ.val) ++ · + intro m hm + apply Set.Finite.of_injOn (f := fun a => s.val⁻¹ * ((Additive.toMul a))⁻¹ ) (ht := mu_conv_finsupp m) +- . ++ · + intro a ha + exact ha +- . intro a ha b hb ++ · intro a ha b hb + simp + )] + simp_rw [mul_sub] +@@ -208,25 +203,25 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + simp + rw [abs_of_nonneg] + rfl +- . ++ · + apply tsum_nonneg + apply H_n_diff_pos n +- . ++ · + simp + apply Function.Injective.comp +- . exact neg_injective +- . exact fun ⦃a₁ a₂⦄ a ↦ a +- . ++ · exact neg_injective ++ · exact fun ⦃a₁ a₂⦄ a ↦ a ++ · + simp + intro g hg + use g⁻¹ + simp +- . ++ · + apply tsum_nonneg + apply H_n_diff_pos n +- . simp +- . apply H_n_diff_pos n +- . ++ · simp ++ · apply H_n_diff_pos n ++ · + simp_rw [← mul_sub] + apply summable_of_hasFiniteSupport + change (Function.support _).Finite +@@ -235,12 +230,12 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + apply Set.Finite.subset (hs := ?_) (ht := Function.support_sub _ _) + simp + refine ⟨?_, ?_⟩ +- . apply f_n_fin_supp +- . ++ · apply f_n_fin_supp ++ · + apply Set.Finite.of_injOn (f := fun a => s.val⁻¹ * a) (ht := f_n_fin_supp n) +- . intro a ha ++ · intro a ha + simpa using ha +- . simp ++ · simp + + + have haar_eq_haar_add : myHaar = myHaarAddOpp := by +@@ -267,7 +262,7 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + + have conv_laplce_norm (n: ℕ): eLpNorm ((Laplace_b ((Conv (H_n n)) (f_n n)))) ⊤ (μ := volume (α := G)) ≤ eLpNorm (H_n n) ⊤ * (eLpNorm (Laplace_b (f_n n)) 1 (μ := volume (α := G))) := by + rw [laplace_conv_eq_laplace_right] +- . ++ · + unfold Conv + eta_reduce + simp only [volume] +@@ -288,12 +283,12 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + calc ‖ContinuousLinearMap.mul ℝ ℝ‖ₑ * eLpNorm (H_n n) ⊤ myHaarAddOpp * eLpNorm (Laplace_b (f_n n)) 1 myHaarAddOpp + ≤ 1 * eLpNorm (H_n n) ⊤ myHaarAddOpp * eLpNorm (Laplace_b (f_n n)) 1 myHaarAddOpp := by gcongr + _ = eLpNorm (H_n n) ⊤ myHaarAddOpp * eLpNorm (Laplace_b (f_n n)) 1 myHaarAddOpp := by rw [one_mul] +- . ++ · + apply conv_exists_fin_supp + right + exact f_n_fin_supp n +- . apply f_n_nonneg +- . exact f_n_fin_supp n ++ · apply f_n_nonneg ++ · exact f_n_fin_supp n + + + let conv_h_n_cont (n: ℕ): C(G, ℝ) := { +@@ -311,7 +306,6 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + rw [count_ae_everywhere] at ae_le + simp_rw [Real.enorm_eq_ofReal_abs] at ae_le + simp_rw [Real.enorm_eq_ofReal_abs] at norm_bound +- norm_cast at ae_le + simp [volume] at norm_bound + rw [my_haar_eq_count] at norm_bound + specialize ae_le g +@@ -323,8 +317,8 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + simp [LipschitzWith] + intro x y + by_cases x_eq_y: x = y +- . simp [x_eq_y] +- . ++ · simp [x_eq_y] ++ · + norm_cast + rw [edist_dist] + rw [Real.dist_eq] +@@ -333,10 +327,10 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + rhs + equals ENNReal.ofReal (2 * (dist x y)) => + rw [ENNReal.ofReal_mul] +- . simp +- . linarith ++ · simp ++ · linarith + rw [ENNReal.ofReal_le_ofReal_iff] +- . ++ · + grw [abs_sub] + grw [abs_conv_le_one x] + grw [abs_conv_le_one y] +@@ -347,7 +341,7 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + exact dist_ne_zero.mpr x_eq_y + simp [dist] at dist_ne_zero + omega +- . simp [dist] ++ · simp [dist] + + + have compact_closure_f: IsCompact (closure ( (Set.range (fun n => (Conv (H_n n) (f_n n)))))) := by +@@ -388,8 +382,8 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + obtain ⟨F, F_mem, seq, seq_mono, tendsto_F⟩ := h_n_pointwise_converge + let F_lipschitzh := nontrivial_harmonic_common 2 (eps_seq ∘ seq) (by + apply Filter.Tendsto.comp (x := Filter.atTop) (y := Filter.atTop) +- . exact StrictMono.tendsto_atTop mono_eps_seq +- . exact StrictMono.tendsto_atTop seq_mono ++ · exact StrictMono.tendsto_atTop mono_eps_seq ++ · exact StrictMono.tendsto_atTop seq_mono + ) F H_n conv_h_n_lipschitz tendsto_F H_n_norm + use F_lipschitzh + intro z +@@ -416,7 +410,6 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + contradiction + + by_contra! +- -- TODO - there must be a cleaner way + have app_one_eq: F_lipschitzh 1 = ConstLipschitzH z (1: G) := by + rw [this] + unfold F_lipschitzh ConstLipschitzH at app_one_eq +@@ -427,19 +420,17 @@ lemma nontrivial_harmonic_case_two (f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun + unfold F_lipschitzh ConstLipschitzH at app_s_inv_eq + simp [DFunLike.coe] at app_s_inv_eq + rw [← app_one_eq] at app_s_inv_eq +- norm_cast at app_s_inv_eq + rw [eq_comm] at app_s_inv_eq + simp [nontrivial_harmonic_common] at app_s_inv_eq + contradiction + + +-#synth OrderTopology ENNReal + + -- Theorem 3.6 - a non-constant harmonic function exists on G + theorem exists_nontrivial_harmonic: ∃ F: LipschitzH , ∀ z: ℝ, F ≠ ConstLipschitzH z := by + by_cases f_n_limit: ∃ s: S, ¬(Filter.Tendsto (fun n: ℕ => MeasureTheory.eLpNorm (f_n n - (Conv (f_n n) (delta s.val))) 1 MeasureTheory.volume) Filter.atTop (nhds 0)) +- . exact nontrivial_harmonic_case_two f_n_limit +- . ++ · exact nontrivial_harmonic_case_two f_n_limit ++ · + simp at f_n_limit + exact nontrivial_harmonic_case_one (by + intro s +diff --git a/Gromov/Harmonic/CaseOne.lean b/Gromov/Harmonic/CaseOne.lean +index 4363fa4..0b27514 100644 +--- a/Gromov/Harmonic/CaseOne.lean ++++ b/Gromov/Harmonic/CaseOne.lean +@@ -11,8 +11,6 @@ public import Gromov.Harmonic.Proposition318 + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS +@@ -30,8 +28,6 @@ open MeasureTheory + + open scoped RealInnerProductSpace + +-set_option maxRecDepth 100000 in +-set_option maxHeartbeats 1000000 in + lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: ℕ => MeasureTheory.eLpNorm (f_n n - (Conv (f_n n) (delta s.val))) 1 MeasureTheory.volume) Filter.atTop (nhds 0))): ∃ F: LipschitzH , ∀ z: ℝ, F ≠ ConstLipschitzH z := by + + +@@ -85,12 +81,12 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [← conv_smul] + rw [ ← smul_conv] + rw [conv_assoc_of_lp2] +- . ++ · + rw [← conv_add_right] +- . ++ · + rw [← ENNReal.ofReal_le_ofReal_iff] +- . +- rw [ofReal_norm_eq_enorm] ++ · ++ rw [ofReal_norm] + grw [counting_le_essSup] + rw [essSup_eq_elpNorm_top] + simp only [volume] +@@ -110,10 +106,10 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + exact my_add_haar_eq_count.symm + + refine le_trans (ENNReal.eLpNorm_top_convolution_le (μ := myHaarAddOpp) (c := 1) (p := 2) (q := 2) (hpq := inferInstance) (by apply AEMeasurable.of_discrete) (by apply AEMeasurable.of_discrete) (by intro a b; simp)) ?_ +- . +- simp [norm, volume] at H_n_norm ++ · ++ simp [volume] at H_n_norm + rw [my_add_haar_eq_count] +- simp [H_n_norm] ++ simp + + have sum_norm := proposition_3_18 (G'_n f_n_limit) + have g_inner_laplace := MeasureTheory.L2.inner_def (Laplace (G'_n f_n_limit)) (G'_n f_n_limit) (𝕜 := ℝ) (α := G) +@@ -124,11 +120,11 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [inv_mul_eq_div] at g_inner_laplace + rw [eq_div_iff_mul_eq] at g_inner_laplace + +- . ++ · + simp [eLpNorm, eLpNorm'] + simp [-AddSubgroupClass.coe_sub, -AddSubgroup.coe_sub, MeasureTheory.Lp.norm_def, eLpNorm, eLpNorm', conv_finsupp_lp2] at g_inner_laplace + rw [← ENNReal.ofReal_rpow_of_pos] +- . ++ · + have hkey : (∫⁻ (a : Additive G), ‖(H_n (seq n) s : Additive G → ℝ) a‖ₑ ^ 2 ∂Measure.count) ^ (2 : ℝ)⁻¹ = 1 := by + have h := H_n_norm n + show (∫⁻ (a : G), ‖(H_n (seq n) s : G → ℝ) a‖ₑ ^ 2 ∂Measure.count) ^ (2 : ℝ)⁻¹ = 1 +@@ -136,9 +132,8 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + my_haar_eq_count] using h + rw [hkey, one_mul] + apply ENNReal.rpow_le_rpow +- . ++ · + generalize_proofs p_1 p_2 p_3 +- -- TODO - make this less horrible + grw [Finset.single_le_sum (f := (fun g => ∫⁻ (a : Additive G), ‖(G_n ((seq n) + 1) (by simp) f_n_limit) a + Conv (-↑↑(G_n ((seq n) + 1) (by simp) f_n_limit)) (delta g) a‖ₑ ^ 2 ∂Measure.count)) (s := S) (hf := by simp) (h := (by rw [S_eq_Sinv]; simp [hy]))] + + +@@ -158,9 +153,8 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + apply_fun ENNReal.ofReal at g_inner_laplace + simp at g_inner_laplace + rw [g_inner_laplace] +- norm_cast + rw [ENNReal.ofReal_sum_of_nonneg] +- . ++ · + conv => + rhs + arg 2 +@@ -172,53 +166,53 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + ) (G_n ((seq n) + 1) (by simp) f_n_limit))) + rw [ae_eq_everywhere.mp (Lp.coeFn_sub _ _)] at g_norm + rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_compMeasurePreserving _ _)] at g_norm +- simp [eLpNorm, eLpNorm', Lp.compMeasurePreserving] at g_norm ++ simp [eLpNorm, eLpNorm'] at g_norm + rw [ENNReal.rpow_lt_top_iff_of_pos (by simp)] at g_norm + grind + )] + simp [volume] + simp_rw [my_haar_eq_count] + apply le_refl +- . simp +- . simp +- . ++ · simp ++ · simp ++ · + simpa using S_nonempty + + -- Finset.single_le_sum +- . simp ++ · simp + grind +- . ++ · + apply MeasureTheory.Integrable.of_integral_ne_zero + rw [← g_inner_laplace] + simp [G'_n] + have foo := g_n_conv_norm (seq (n) + 1) (by simp) f_n_limit + grind +- . ++ · + exact NNReal.coe_nonneg _ +- . ++ · + simp [ConvExists] + rw [my_add_haar_eq_count] + apply ENNReal.ConvolutionExists.of_memLp_memLp (p := 2) (q := 2) (μ := Measure.count) +- . infer_instance +- . simp +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . rw [← my_add_haar_eq_count] ++ · infer_instance ++ · simp ++ · apply AEStronglyMeasurable.of_discrete ++ · apply AEStronglyMeasurable.of_discrete ++ · rw [← my_add_haar_eq_count] + apply Lp.memLp +- . rw [← my_add_haar_eq_count] ++ · rw [← my_add_haar_eq_count] + apply Lp.memLp +- . ++ · + simp [ConvExists] + rw [my_add_haar_eq_count] + apply ENNReal.ConvolutionExists.of_memLp_memLp (p := 2) (q := 2) (μ := Measure.count) +- . infer_instance +- . simp +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . rw [← my_add_haar_eq_count] ++ · infer_instance ++ · simp ++ · apply AEStronglyMeasurable.of_discrete ++ · apply AEStronglyMeasurable.of_discrete ++ · rw [← my_add_haar_eq_count] + apply Lp.memLp +- . +- refine ⟨by apply AEStronglyMeasurable.of_discrete, ?_⟩ ++ · ++ unfold MemLp + rw [← my_add_haar_eq_count] + rw [← neg_one_smul ℝ] + rw [conv_smul] +@@ -227,7 +221,7 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + simp [Conv] + rw [← Function.comp_def (β := Additive G)] + rw [MeasureTheory.eLpNorm_comp_measurePreserving (ν := Measure.count)] +- . ++ · + conv => + arg 1 + arg 1 +@@ -244,44 +238,43 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + + rw [← my_add_haar_eq_count] + grw [ENNReal.eLpNorm_convolution_le_enorm_mul (p := 2) (q := 1)] +- . ++ · + refine ENNReal.mul_lt_top (ENNReal.mul_lt_top (by simp) ?_) ?_ + · exact MeasureTheory.MemLp.eLpNorm_lt_top (MeasureTheory.MemLp.comp_measurePreserving (ν := volume) (Lp.memLp _) measure_preserving_unop_tomul) + · refine MeasureTheory.MemLp.eLpNorm_lt_top (MeasureTheory.MemLp.comp_measurePreserving (ν := volume) ?_ measure_preserving_unop_tomul) + apply Continuous.memLp_of_hasCompactSupport + · fun_prop + · simp [HasCompactSupport, tsupport] +- . simp +- . simp +- . simp +- . simp +- . apply AEMeasurable.of_discrete +- . apply AEMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . rw [my_add_haar_eq_count] ++ · simp ++ · simp ++ · simp ++ · simp ++ · apply AEMeasurable.of_discrete ++ · apply AEMeasurable.of_discrete ++ · apply AEStronglyMeasurable.of_discrete ++ · rw [my_add_haar_eq_count] + apply MeasurePreserving.id +- . rw [← my_haar_eq_count] ++ · rw [← my_haar_eq_count] + apply Lp.memLp +- . rw [← my_haar_eq_count] ++ · rw [← my_haar_eq_count] + simp + apply MemLp.neg + apply Lp.memLp +- . simp ++ · simp + + -- Now rename Hn ∗Gn such that we have added a constant so that Hn ∗Gn(e) = 0 + let new_seq: ℕ → ℕ := seq + let H_G_conv_zero (n: ℕ) (g: G) := ((Conv (H_n ((new_seq n)) s) (G_n ((new_seq n) + 1) (by simp) f_n_limit)) g) - (Conv (H_n ((new_seq n)) s) (G_n ((new_seq n) + 1) (by simp) f_n_limit) 1) + + +- -- TODO - can the lipschitz constant can be improved? + have H_G_conv_zero_lipschitz: ∀ n: ℕ, LipschitzWith ((((2 * #(S))^((2 : ℝ)⁻¹))) + 0) (H_G_conv_zero n) := by + intro n + simp only [H_G_conv_zero] + simp only [new_seq] + apply LipschitzWith.sub +- . ++ · + apply h_n_f_lipschitz +- . apply LipschitzWith.const ++ · apply LipschitzWith.const + + + have H_n_conv_zero_eq: ∀ n: ℕ, (H_G_conv_zero (n) 1) - (H_G_conv_zero (n) s⁻¹) = ‖(G_n ((new_seq n) + 1) (by simp) f_n_limit) - (conv_finsupp_lp2 (((G_n ((new_seq n) + 1) (by simp) f_n_limit))) (delta s) (by simp [delta]))‖ := by +@@ -297,9 +290,9 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [← conv_smul] + rw [ ← smul_conv] + rw [conv_assoc_of_lp2] +- . ++ · + rw [← conv_add_right] +- . ++ · + simp [H_n, conv_finsupp_lp2] + rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_smul _ _)] + rw [conv_smul] +@@ -313,7 +306,7 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_compMeasurePreserving _ _)] + rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_compMeasurePreserving _ _)] + simp only [convolution, +- ContinuousLinearMap.coe_sub', ContinuousLinearMap.mul_apply', Pi.smul_apply, smul_eq_mul] ++ ContinuousLinearMap.mul_apply', Pi.smul_apply, smul_eq_mul] + simp + have t_fake_inv: ∀ (t: G), (t: (Additive G))⁻¹ = -(Additive.ofMul t) := by + intro t +@@ -346,8 +339,8 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [f_conv_delta_helper] + rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp +- . ++ · apply MeasureTheory.Lp.memLp ++ · + exact measurePreserving_mul_left volume s⁻¹ + )] + rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_neg _)] +@@ -373,8 +366,8 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [f_conv_delta_helper] + rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp +- . ++ · apply MeasureTheory.Lp.memLp ++ · + exact measurePreserving_mul_left volume s⁻¹ + ))‖^2 => + rw [← real_inner_self_eq_norm_sq] +@@ -390,59 +383,58 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + · simp [h] + · field_simp + exact key _ +- . ++ · + simp [ConvExists] + rw [my_add_haar_eq_count] + apply ENNReal.ConvolutionExists.of_memLp_memLp (p := 2) (q := 2) (μ := Measure.count) +- . infer_instance +- . simp +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . rw [← Function.comp_def] ++ · infer_instance ++ · simp ++ · apply AEStronglyMeasurable.of_discrete ++ · apply AEStronglyMeasurable.of_discrete ++ · rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_measurePreserving +- . apply Lp.memLp +- . simp [volume] ++ · apply Lp.memLp ++ · simp [volume] + rw [my_haar_eq_count] + apply MeasureTheory.MeasurePreserving.id +- . ++ · + apply MeasureTheory.MemLp.comp_measurePreserving +- . apply Lp.memLp +- . simp [volume] ++ · apply Lp.memLp ++ · simp [volume] + rw [my_haar_eq_count] + apply MeasureTheory.MeasurePreserving.id +- . +- -- TODO - deduplicate this ++ · + simp [f_conv_delta_helper] + simp [ConvExists] + rw [my_add_haar_eq_count] + apply ENNReal.ConvolutionExists.of_memLp_memLp (p := 2) (q := 2) (μ := Measure.count) +- . infer_instance +- . simp +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . rw [← Function.comp_def] ++ · infer_instance ++ · simp ++ · apply AEStronglyMeasurable.of_discrete ++ · apply AEStronglyMeasurable.of_discrete ++ · rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_measurePreserving +- . apply Lp.memLp +- . simp [volume] ++ · apply Lp.memLp ++ · simp [volume] + rw [my_haar_eq_count] + apply MeasureTheory.MeasurePreserving.id +- . ++ · + apply MeasureTheory.MemLp.neg + rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_measurePreserving +- . apply Lp.memLp +- . ++ · apply Lp.memLp ++ · + simp [volume] + rw [my_haar_eq_count] + refine MeasurePreserving.mul_left Measure.count s⁻¹ ?_ + apply MeasureTheory.MeasurePreserving.id +- . rw [← my_haar_eq_count] ++ · rw [← my_haar_eq_count] + apply Lp.memLp +- . rw [← my_haar_eq_count] ++ · rw [← my_haar_eq_count] + simp + apply MemLp.neg + apply Lp.memLp +- . simp [delta] ++ · simp [delta] + + + have compact_with_fixed_g (g: G): IsCompact (closure ( (Set.range (fun n => H_G_conv_zero n g)))) := by +@@ -468,7 +460,7 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [dist_comm] at bar + grw [bar] + simp [H_G_conv_zero] +- ring ++ ring_nf + simp + + have new_compact_closure: IsCompact (closure (Set.range (fun n => H_G_conv_zero n))) := by +@@ -494,7 +486,7 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + rw [dist_comm] at bar + grw [bar] + simp [H_G_conv_zero] +- ring ++ ring_nf + simp + + have arzela_tendsto := IsCompact.tendsto_subseq new_compact_closure (x := fun n => ( +@@ -528,9 +520,9 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + + have new_tendsto_sub := (abs_tendsto _).comp ((tendsto_arzela_lim x).sub (tendsto_arzela_lim y)) + have sub_le := le_of_tendsto new_tendsto_sub (b := ((↑(#S) * 2) ^ (2 : ℝ)⁻¹) * (dist x y)) ?_ +- . norm_cast ++ · norm_cast + norm_cast at sub_le +- . apply Filter.Eventually.of_forall ++ · apply Filter.Eventually.of_forall + intro n + have foo := (H_G_conv_zero_lipschitz (arzela_seq n)).dist_le_mul x y + rw [Real.dist_eq] at foo +@@ -547,7 +539,7 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + intro x + rw [← sub_eq_zero] + +- have sum_lim := tendsto_finset_sum (s := S) (fun s hs => tendsto_arzela_lim (s * x)) ++ have sum_lim := tendsto_finsetSum (s := S) (fun s hs => tendsto_arzela_lim (s * x)) + have tendsto_sub := (tendsto_arzela_lim x).sub (sum_lim.const_mul ((#S : ℝ))⁻¹) + norm_cast + +@@ -555,13 +547,13 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + (f := (fun x_1 ↦ |((fun n ↦ H_G_conv_zero n) ∘ arzela_seq) x_1 x - (↑(#S))⁻¹ * ∑ c ∈ S, ((fun n ↦ H_G_conv_zero n) ∘ arzela_seq) x_1 (c * x)|)) + (g := fun n => (1 / (n + 1))) + ?_ ?_ ?_ +- . ++ · + have target_eq_zero := tendsto_nhds_unique ((abs_tendsto _).comp tendsto_sub) (lim_zero) + rw [abs_eq_zero] at target_eq_zero + rw [sub_eq_zero] at target_eq_zero + simp [target_eq_zero] +- . simp +- . intro n ++ · simp ++ · intro n + simp + conv => + lhs +@@ -588,7 +580,7 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + grw [abs_add_le] + simp + rw [laplace_conv_eq_laplace_right_of_lp2] +- . ++ · + simp [Conv] + grw [ENNReal.ofReal_add_le] + rw [← Real.enorm_eq_ofReal_abs] +@@ -619,7 +611,7 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + · rw [ENNReal.inv_top, zero_add]; exact ENNReal.inv_two_add_inv_two + · apply AEMeasurable.of_discrete + · apply AEMeasurable.of_discrete +- . ++ · + conv => + lhs + arg 1 +@@ -661,32 +653,31 @@ lemma nontrivial_harmonic_case_one (f_n_limit: ∀ s: S, (Filter.Tendsto (fun n: + + omega + +- . +- -- TODO - deduplicate this ++ · + simp [ConvExists] + rw [my_add_haar_eq_count] + apply ENNReal.ConvolutionExists.of_memLp_memLp (p := 2) (q := 2) (μ := Measure.count) +- . infer_instance +- . simp +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . rw [← Function.comp_def] ++ · infer_instance ++ · simp ++ · apply AEStronglyMeasurable.of_discrete ++ · apply AEStronglyMeasurable.of_discrete ++ · rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_measurePreserving +- . apply Lp.memLp +- . simp [volume] ++ · apply Lp.memLp ++ · simp [volume] + rw [my_haar_eq_count] + apply MeasureTheory.MeasurePreserving.id +- . ++ · + apply MeasureTheory.MemLp.comp_measurePreserving +- . apply Lp.memLp +- . simp [volume] ++ · apply Lp.memLp ++ · simp [volume] + rw [my_haar_eq_count] + apply MeasureTheory.MeasurePreserving.id +- . rw [← my_haar_eq_count] ++ · rw [← my_haar_eq_count] + apply Lp.memLp +- . rw [← my_haar_eq_count] ++ · rw [← my_haar_eq_count] + apply Lp.memLp +- . ++ · + simp + simp_rw [inv_eq_one_div] + apply tendsto_one_div_add_atTop_nhds_zero_nat +diff --git a/Gromov/Harmonic/Convolution.lean b/Gromov/Harmonic/Convolution.lean +index 9721ae6..c14260c 100644 +--- a/Gromov/Harmonic/Convolution.lean ++++ b/Gromov/Harmonic/Convolution.lean +@@ -19,8 +19,6 @@ multiplication, and `laplace_conv_eq_laplace_right`. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS +@@ -49,30 +47,28 @@ lemma harmonic_maximum_implies_const (f: G → ℝ) (hf: Laplace_b f = 0) (a: G + rw [ih] at f_at_l + field_simp at f_at_l + +- -- TODO - is there a 'Finset.expect' theorem we can use? +- -- TODO - upstream this to mathlib in some form + have f_s_eq: ∀ s: S, f a = f (s * (l.unattach.prod * a)) := by + by_contra! + simp at this + obtain ⟨s, s_mem_s, hs⟩ := this + by_cases val_le_max: f (s * (l.unattach.prod * a)) ≤ f a +- . ++ · + have val_lt_max: f (s * (l.unattach.prod * a)) < f a := by + exact lt_of_le_of_ne (h_max (↑s * (l.unattach.prod * a))) (id (Ne.symm hs)) + + have sum_strict_lt := Finset.sum_lt_sum (f := fun x => f (x * (l.unattach.prod * a))) (g := fun x => f a) (s := S) ?_ ?_ +- . ++ · + simp at sum_strict_lt + rw [mul_comm] at sum_strict_lt + rw [← div_lt_iff₀] at sum_strict_lt +- . ++ · + apply ne_of_gt at sum_strict_lt + contradiction +- . simpa using S_nonempty +- . intro s hs ++ · simpa using S_nonempty ++ · intro s hs + apply h_max +- . use s +- . ++ · use s ++ · + have val_gt := h_max (s * (l.unattach.prod * a)) + simp at val_le_max + linarith +@@ -102,7 +98,7 @@ open scoped Convolution + open MeasureTheory + + +-lemma laplace_b_const (k: ℝ): Laplace_b (fun g => k) = 0 := by ++lemma laplace_b_const (k: ℝ): Laplace_b (fun _g => k) = 0 := by + simp [Laplace_b] + simp [f_conv_mu] + ext a +@@ -111,8 +107,8 @@ lemma laplace_b_const (k: ℝ): Laplace_b (fun g => k) = 0 := by + rw [← mul_assoc] + + rw [inv_mul_cancel₀] +- . simp +- . simp ++ · simp ++ · simp + have foo := S_nonempty + grind + +@@ -129,9 +125,9 @@ lemma conv_add_right {f g h: G → ℝ} (h_fg: ConvExists f g) (h_fh : ConvExist + rfl + + rw [MeasureTheory.ConvolutionExists.distrib_add] +- . rfl +- . exact h_fg +- . exact h_fh ++ · rfl ++ · exact h_fg ++ · exact h_fh + + lemma conv_add_left {f g h: G → ℝ} (h_fh: ConvExists f h) (h_gh : ConvExists g h): Conv (f + g) h = Conv f h + Conv g h := by + unfold Conv +@@ -143,9 +139,9 @@ lemma conv_add_left {f g h: G → ℝ} (h_fh: ConvExists f h) (h_gh : ConvExists + rfl + + rw [MeasureTheory.ConvolutionExists.add_distrib] +- . rfl +- . exact h_fh +- . exact h_gh ++ · rfl ++ · exact h_fh ++ · exact h_gh + + lemma conv_smul {f h: G → ℝ} (k: ℝ): Conv (k • f) h = k • Conv f h := by + funext g +@@ -176,7 +172,6 @@ lemma laplace_conv_eq_laplace_right_of_lp2 (f g: G → ℝ) (hfg: ConvExists f g + + nth_rw 2 [sub_eq_add_neg] + rw [conv_add_right] +- -- TODO - figure out how to do this without a 'conv' block + conv => + rhs + rhs +@@ -184,24 +179,24 @@ lemma laplace_conv_eq_laplace_right_of_lp2 (f g: G → ℝ) (hfg: ConvExists f g + simp + rw [smul_conv] + simp +- . rw [← sub_eq_add_neg] +- . exact hfg +- . ++ · rw [← sub_eq_add_neg] ++ · exact hfg ++ · + simp [ConvExists, MeasureTheory.ConvolutionExists, MeasureTheory.ConvolutionExistsAt] + intro a + simp_rw [f_conv_mu] + simp_rw [← mul_assoc, mul_comm, mul_assoc] + apply MeasureTheory.Integrable.const_mul + simp_rw [Finset.mul_sum] +- apply MeasureTheory.integrable_finset_sum ++ apply MeasureTheory.integrable_finsetSum + intro s hs + simp [ConvExists, MeasureTheory.ConvolutionExists, MeasureTheory.ConvolutionExistsAt] at hfg + specialize hfg (s * a) + simp_rw [mul_div] + exact hfg +- . exact hf +- . exact hg +- . apply mu_finsupp ++ · exact hf ++ · exact hg ++ · apply mu_finsupp + + + lemma laplace_conv_eq_laplace_right (f g: G → ℝ) (hfg: ConvExists f g) (g_nonneg: ∀ a: G, 0 ≤ g a) (g_finsupp: g.support.Finite): Laplace_b (Conv f g) = Conv f (Laplace_b g) := by +@@ -210,7 +205,6 @@ lemma laplace_conv_eq_laplace_right (f g: G → ℝ) (hfg: ConvExists f g) (g_no + + nth_rw 2 [sub_eq_add_neg] + rw [conv_add_right] +- -- TODO - figure out how to do this without a 'conv' block + conv => + rhs + rhs +@@ -218,34 +212,33 @@ lemma laplace_conv_eq_laplace_right (f g: G → ℝ) (hfg: ConvExists f g) (g_no + simp + rw [smul_conv] + simp +- . rw [← sub_eq_add_neg] +- . exact hfg +- . ++ · rw [← sub_eq_add_neg] ++ · exact hfg ++ · + simp [ConvExists, MeasureTheory.ConvolutionExists, MeasureTheory.ConvolutionExistsAt] + intro a + simp_rw [f_conv_mu] + simp_rw [← mul_assoc, mul_comm, mul_assoc] + apply MeasureTheory.Integrable.const_mul + simp_rw [Finset.mul_sum] +- apply MeasureTheory.integrable_finset_sum ++ apply MeasureTheory.integrable_finsetSum + intro s hs + simp [ConvExists, MeasureTheory.ConvolutionExists, MeasureTheory.ConvolutionExistsAt] at hfg + specialize hfg (s * a) + simp_rw [mul_div] + exact hfg +- . exact hfg +- . ++ · exact hfg ++ · + apply conv_exists_fin_supp + right + exact mu_finsupp +- . apply g_finsupp +- . exact g_nonneg +- . exact mu_finsupp +- . intro a ++ · apply g_finsupp ++ · exact g_nonneg ++ · exact mu_finsupp ++ · intro a + simp [mu] + positivity + +-#print axioms laplace_conv_eq_laplace_right + + + -- simp_rw [tsum_eq_sum] +@@ -257,14 +250,13 @@ lemma f_n_fin_supp (n: ℕ): (f_n n).support.Finite := by + apply Set.Finite.inter_of_right + apply Set.Finite.subset (hs := ?_) (ht := Finset.support_sum _ _) + refine Set.Finite.biUnion' ?_ ?_ +- . exact Set.toFinite (Membership.mem Finset.univ.val) +- . intro m hm ++ · exact Set.toFinite (Membership.mem Finset.univ.val) ++ · intro m hm + apply mu_conv_finsupp + + + -- The expression 'Σ s_1, ..., s_n ∈ S, f(s_1 * ... * s_n)' + -- This is a sum over all n-tuples of elements in S, where each term in is f (s_1 * ... * s_n) +--- TODO - is there aless horrible way to write in in mathlib? + @[expose] + def NTupleSum (n: ℕ) (f: G → ℝ): ℝ := ∑ s : (Fin n → S), f ((List.ofFn s).unattach.prod) + +diff --git a/Gromov/Harmonic/LaplaceLinear.lean b/Gromov/Harmonic/LaplaceLinear.lean +index 81f7578..50a9795 100644 +--- a/Gromov/Harmonic/LaplaceLinear.lean ++++ b/Gromov/Harmonic/LaplaceLinear.lean +@@ -11,17 +11,15 @@ public import Gromov.Harmonic.MuConv + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS + open Generates + +-variable [hGS: Generates] ++variable [hGS : Generates] + include hGS + +-variable {V: Submodule ℝ LipschitzH} [V_finite: FiniteDimensional ℝ V] [Nontrivial V] ++variable {V : Submodule ℝ LipschitzH} [V_finite : FiniteDimensional ℝ V] [Nontrivial V] + + open scoped Finset + open scoped Pointwise +@@ -30,20 +28,20 @@ open MeasureTheory + + set_option maxHeartbeats 60000 in + @[expose] +-noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: Filter.Tendsto seq Filter.atTop Filter.atTop) (F: G → ℝ) (H_n: ℕ → G → ℝ) (h_conv_lipschitz: ∀ n, LipschitzWith k (Conv (H_n n) (f_n n))) +-(tendsto_F: Filter.Tendsto ((fun n ↦ Conv (H_n (seq n)) (f_n (seq n)))) Filter.atTop (nhds F)) +-(H_n_norm: ∀ n: ℕ, MeasureTheory.eLpNorm (H_n n) (p := ⊤) MeasureTheory.volume = 1): LipschitzH := by ++noncomputable def nontrivial_harmonic_common (k : ℕ) (seq : ℕ → ℕ) (h_seq : Filter.Tendsto seq Filter.atTop Filter.atTop) (F : G → ℝ) (H_n : ℕ → G → ℝ) (h_conv_lipschitz : ∀ n, LipschitzWith k (Conv (H_n n) (f_n n))) ++(tendsto_F : Filter.Tendsto ((fun n ↦ Conv (H_n (seq n)) (f_n (seq n)))) Filter.atTop (nhds F)) ++(H_n_norm : ∀ n : ℕ, MeasureTheory.eLpNorm (H_n n) (p := ⊤) MeasureTheory.volume = 1) : LipschitzH := by + +- let conv_h_n_cont (n: ℕ): C(G, ℝ) := { ++ let conv_h_n_cont (n : ℕ) : C(G, ℝ) := { + toFun := Conv (H_n (seq n)) (f_n (seq n)), + continuous_toFun := by exact continuous_of_discreteTopology + } + +- let F_lipschitzh: LipschitzH := { +- toFun := (fun (g: G) => F g), ++ let F_lipschitzh : LipschitzH := { ++ toFun := (fun (g : G) => F g), + lipschitz := by + use k +- have closed_lipschitz := isClosed_setOf_lipschitzWith (α := G) (β := ℝ) k ++ have closed_lipschitz := isClosed_setOfPred_lipschitzWith (α := G) (β := ℝ) k + apply IsClosed.isSeqClosed at closed_lipschitz + simp [IsSeqClosed] at closed_lipschitz + have F_lipschitz := closed_lipschitz (p := F) (x := (fun n ↦ Conv (H_n (seq n)) (f_n (seq n)))) (by +@@ -55,20 +53,16 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + simp [Harmonic] + intro g + rw [tendsto_pi_nhds] at tendsto_F +- have lim_f_sum := tendsto_finset_sum (ι := S) (M := ℝ) (s := Finset.univ) (a := fun s => F (s.val * g)) (f := (fun (s: S) n ↦ Conv (H_n (seq n)) (f_n (seq n)) (s.val *g))) (x := Filter.atTop (α := ℕ)) ?_ +- +- -- TODO - figure out why lean hangs without this ++ have lim_f_sum := tendsto_finsetSum (ι := S) (M := ℝ) (s := Finset.univ) (a := fun s => F (s.val * g)) (f := (fun (s : S) n ↦ Conv (H_n (seq n)) (f_n (seq n)) (s.val *g))) (x := Filter.atTop (α := ℕ)) ?_ + have my_mul : ContinuousMul ℝ := instIsTopologicalRingReal.toContinuousMul + have lim_f_mul_sum := Filter.Tendsto.const_mul ((#S) : ℝ)⁻¹ lim_f_sum +- . +- have lim_f_g := tendsto_F g ++ · have lim_f_g := tendsto_F g + have lim_f_g_sub := Filter.Tendsto.sub lim_f_g lim_f_mul_sum + +- have laplace_conv_tendsto_zero: Filter.Tendsto (fun n => eLpNorm (Laplace_b (Conv (H_n (seq n)) (f_n (seq n)))) ⊤) Filter.atTop (nhds 0) := by +- apply tendsto_of_tendsto_of_tendsto_of_le_of_le (g := fun n => 0) (h := fun (n: ℕ) => ENNReal.ofReal ((2: ℝ) / ((seq n) + 1) : ℝ)) +- . simp +- . +- rw [← ENNReal.tendsto_toReal_iff] ++ have laplace_conv_tendsto_zero : Filter.Tendsto (fun n => eLpNorm (Laplace_b (Conv (H_n (seq n)) (f_n (seq n)))) ⊤) Filter.atTop (nhds 0) := by ++ apply tendsto_of_tendsto_of_tendsto_of_le_of_le (g := fun n => 0) (h := fun (n : ℕ) => ENNReal.ofReal ((2 : ℝ) / ((seq n) + 1) : ℝ)) ++ · simp ++ · rw [← ENNReal.tendsto_toReal_iff] + conv => + arg 1 + intro n +@@ -80,36 +74,34 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + arg 1 + intro n + rhs +- equals ((((((seq n) + 1): ℕ)) : ℕ ) : ℝ) => simp ++ equals ((((((seq n) + 1) : ℕ)) : ℕ ) : ℝ) => simp + conv => + arg 1 +- equals (fun (n: ℕ) => (2 : ℝ) / (n) ) ∘ (fun n => (seq n) + 1) => ++ equals (fun (n : ℕ) => (2 : ℝ) / (n) ) ∘ (fun n => (seq n) + 1) => + ext n + simp + apply Filter.Tendsto.comp +- . +- conv => ++ · conv => + arg 1 +- equals (fun (n: ℕ) => (2 : ℝ) / ((n) : ℕ)) => ++ equals (fun (n : ℕ) => (2 : ℝ) / ((n) : ℕ)) => + ext n + simp + apply tendsto_const_div_atTop_nhds_zero_nat +- . +- apply Filter.Tendsto.comp +- . conv => ++ · apply Filter.Tendsto.comp ++ · conv => + arg 1 + equals fun n => n + 1 => + simp + apply Filter.tendsto_add_atTop_nat + +- . simp ++ · simp + exact h_seq +- . simp +- . simp +- . rw [Pi.le_def] ++ · simp ++ · simp ++ · rw [Pi.le_def] + intro x + simp +- . rw [Pi.le_def] ++ · rw [Pi.le_def] + intro n + simp + have bound_by_norm_one := conv_laplce_norm (seq n) +@@ -118,7 +110,7 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + simp at bound_by_norm_one + grw [bound_by_norm_one] + have h_norm := H_n_norm (seq n) +- simp [eLpNorm, eLpNorm'] at h_norm ++ simp [eLpNorm] at h_norm + rw [h_norm] + simp + simp_rw [Laplace_b] +@@ -127,33 +119,30 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + + rw [← ENNReal.tendsto_toReal_iff] at laplace_conv_tendsto_zero + +- have laplace_real_tendsto_zero: Filter.Tendsto (fun n => |(Laplace_b (Conv (H_n (seq n)) (f_n (seq n))) (g))|) Filter.atTop (nhds 0) := by ++ have laplace_real_tendsto_zero : Filter.Tendsto (fun n => |(Laplace_b (Conv (H_n (seq n)) (f_n (seq n))) (g))|) Filter.atTop (nhds 0) := by + apply squeeze_zero (g := fun n => (eLpNorm (Laplace_b (Conv (H_n (seq n)) (f_n (seq n)))) ⊤ volume).toReal) +- . +- intro n ++ · intro n + simp +- . intro n ++ · intro n + have ae_le := ENNReal.ae_le_essSup (fun x ↦ ‖Laplace_b (Conv (H_n (seq n)) (f_n (seq n))) x‖ₑ) (μ := volume) + simp [volume] at ae_le + rw [my_haar_eq_count] at ae_le + rw [count_ae_everywhere] at ae_le + specialize ae_le g +- simp [eLpNorm, eLpNorm'] ++ simp [eLpNorm] + simp [eLpNormEssSup] + rw [← ENNReal.toReal_le_toReal] at ae_le +- simp only [toReal_enorm, Real.norm_eq_abs, OrderTop.bddAbove] at ae_le ++ simp only [toReal_enorm, Real.norm_eq_abs] at ae_le + simp [volume] + rw [my_haar_eq_count] + exact ae_le +- . simp +- . +- -- TODO - deduplicate this +- have bound_by_norm_one := conv_laplce_norm (seq n) H_n ++ · simp ++ · have bound_by_norm_one := conv_laplce_norm (seq n) H_n + have norm_le_two_div := f_n_sub_conv (seq n) + nth_rw 1 [eLpNorm] at bound_by_norm_one + simp at bound_by_norm_one + have h_norm := H_n_norm (seq n) +- simp [eLpNorm, eLpNorm'] at h_norm ++ simp [eLpNorm] at h_norm + rw [h_norm] at bound_by_norm_one + simp only [eLpNormEssSup] at bound_by_norm_one + simp [volume] at bound_by_norm_one +@@ -165,11 +154,10 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + rw [my_haar_eq_count] at norm_le_two_div + grw [norm_le_two_div] + apply ENNReal.ofReal_lt_top +- . apply laplace_conv_tendsto_zero ++ · apply laplace_conv_tendsto_zero + + simp_rw [Laplace_b] at laplace_real_tendsto_zero + simp_rw [f_conv_mu] at laplace_real_tendsto_zero +- beta_reduce at laplace_real_tendsto_zero + conv at laplace_real_tendsto_zero => + arg 1 + rw [← Function.comp_def] +@@ -191,17 +179,15 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + rw [eq_comm] at lim_eq + rw [sub_eq_zero] at lim_eq + rw [lim_eq] +- norm_cast + rw [← Finset.sum_subtype (s := S) (f := fun i => (F (i * g)))] + simp +- . intro n +- -- TODO - deduplicate this. I'm sure there's lots of other versions of it scattered around this file ++ · intro n + rw [← lt_top_iff_ne_top] + grw [conv_laplce_norm] + rw [H_n_norm] + simp + simp_rw [Laplace_b] +- grw [MeasureTheory.eLpNorm_sub_le] ++ grw [MeasureTheory.eLpNorm_sub_le (by norm_num)] + rw [f_n_norm_one] + simp_rw [f_conv_mu] + simp_rw [← smul_eq_mul] +@@ -216,8 +202,7 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + funext g + simp + +- +- grw [MeasureTheory.eLpNorm_sum_le] ++ grw [MeasureTheory.eLpNorm_sum_le (by norm_num)] + simp_rw [← Function.comp_def] + conv => + lhs +@@ -241,26 +226,17 @@ noncomputable def nontrivial_harmonic_common (k: ℕ) (seq: ℕ → ℕ) (h_seq: + norm_cast + rw [Real.enorm_eq_ofReal_abs] + simp +- norm_cast + apply ENNReal.mul_lt_top +- . simp +- . simp +- . +- intro s hs +- apply AEStronglyMeasurable.of_discrete +- . simp +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . simp +- +- +- . simp +- . intro s hs ++ · simp ++ · simp ++ ++ · simp ++ · intro s hs + apply tendsto_F + } + exact F_lipschitzh + +-lemma counting_le_essSup (f: G → ℝ): ∀ g : G, ‖f g‖ₑ ≤ essSup (fun g => ‖f g‖ₑ) volume := by ++lemma counting_le_essSup (f : G → ℝ) : ∀ g : G, ‖f g‖ₑ ≤ essSup (fun g => ‖f g‖ₑ) volume := by + intro g + have ae_le := ENNReal.ae_le_essSup (fun g => ‖f g‖ₑ) (μ := volume) + simp [MeasureTheory.volume] at ae_le +@@ -272,12 +248,12 @@ lemma counting_le_essSup (f: G → ℝ): ∀ g : G, ‖f g‖ₑ ≤ essSup (fu + rw [my_haar_eq_count] + exact ae_le + +-lemma essSup_eq_elpNorm_top (f: G → ℝ): (essSup (fun g => ‖f g‖ₑ) volume) = (eLpNorm f ⊤ volume) := by ++lemma essSup_eq_elpNorm_top (f : G → ℝ) : (essSup (fun g => ‖f g‖ₑ) volume) = (eLpNorm f ⊤ volume) := by ++ rw [MeasureTheory.eLpNorm_exponent_top (by apply AEStronglyMeasurable.of_discrete)] + rfl + +- + @[expose] +-noncomputable def Laplace_linear: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G))) →ₗ[ℝ] (MeasureTheory.Lp ℝ 2 (μ := volume (α := G))) := { ++noncomputable def Laplace_linear : (MeasureTheory.Lp ℝ 2 (μ := volume (α := G))) →ₗ[ℝ] (MeasureTheory.Lp ℝ 2 (μ := volume (α := G))) := { + toFun := Laplace + map_add' := by + intro x y +@@ -300,13 +276,12 @@ noncomputable def Laplace_linear: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G + )] + + rw [MeasureTheory.MemLp.toLp_add] +- . abel +- . +- have foo := MeasureTheory.Lp.memLp (conv_mu_lp2 x) ++ · abel_nf ++ · have foo := MeasureTheory.Lp.memLp (conv_mu_lp2 x) + simp [conv_mu_lp2] at foo + rw [ae_eq_everywhere.mp (MeasureTheory.MemLp.coeFn_toLp _)] at foo + exact foo +- . have foo := MeasureTheory.Lp.memLp (conv_mu_lp2 y) ++ · have foo := MeasureTheory.Lp.memLp (conv_mu_lp2 y) + simp [conv_mu_lp2] at foo + rw [ae_eq_everywhere.mp (MeasureTheory.MemLp.coeFn_toLp _)] at foo + exact foo +@@ -321,9 +296,8 @@ noncomputable def Laplace_linear: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G + rw [smul_sub] + } + +- + @[expose] +-instance volume_finite_compact: IsFiniteMeasureOnCompacts (volume (α := G)) := by ++instance volume_finite_compact : IsFiniteMeasureOnCompacts (volume (α := G)) := by + simp [volume] + rw [my_haar_eq_count] + exact { +@@ -333,18 +307,15 @@ instance volume_finite_compact: IsFiniteMeasureOnCompacts (volume (α := G)) := + exact Measure.count_apply_lt_top.mpr finite + } + +- +-lemma finsupp_lp_top (f: G → ℝ) (hf: f.support.Finite) (p: ENNReal): MeasureTheory.MemLp f p (Measure.count) := by ++lemma finsupp_lp_top (f : G → ℝ) (hf : f.support.Finite) (p : ENNReal) : MeasureTheory.MemLp f p (Measure.count) := by + rw [← my_haar_eq_count] + apply Continuous.memLp_of_hasCompactSupport +- . apply continuous_of_discreteTopology +- . +- simp [HasCompactSupport] ++ · apply continuous_of_discreteTopology ++ · simp [HasCompactSupport] + rw [isCompact_iff_finite] + simp [tsupport] + exact hf + +- + @[expose] + noncomputable def F_n (n : ℕ) := Real.sqrt ∘ (f_n n) + @[expose] +@@ -354,32 +325,29 @@ noncomputable def F_n_lp2 (n : ℕ) := MeasureTheory.MemLp.toLp (F_n n) (by + apply finsupp_lp_top + simp [F_n] + apply Set.Finite.subset (s := (f_n n).support) +- . +- unfold f_n ++ · unfold f_n + apply f_n_fin_supp +- . +- apply Function.support_comp_subset ++ · apply Function.support_comp_subset + simp + ) (μ := volume (α := G)) (p := 2) + +- + @[expose] +-instance volume_mul_left_invariant: (volume (α := G)).IsMulLeftInvariant := by ++instance volume_mul_left_invariant : (volume (α := G)).IsMulLeftInvariant := by + simp [volume] + rw [my_haar_eq_count] + infer_instance + + omit hGS in +-lemma abs_sub_le_abs_add (a b: ℝ) (ha: 0 ≤ a) (hb: 0 ≤ b): |a - b| ≤ |a + b| := by ++lemma abs_sub_le_abs_add (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) : |a - b| ≤ |a + b| := by + rw [abs_sub_le_iff] + refine ⟨?_, ?_⟩ +- . +- rw [le_abs] ++ · rw [le_abs] + grind +- . rw [le_abs] ++ · rw [le_abs] + grind + +-lemma norm_sub_squared_le (a b : ℝ) (ha: 0 ≤ a) (hb: 0 ≤ b): (a - b)^2 ≤ |a^2 - b^2| := by ++omit hGS in ++lemma norm_sub_squared_le [_hGS : Generates] (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) : (a - b)^2 ≤ |a^2 - b^2| := by + conv => + lhs + rw [← sq_abs] +@@ -388,56 +356,46 @@ lemma norm_sub_squared_le (a b : ℝ) (ha: 0 ≤ a) (hb: 0 ≤ b): (a - b)^2 ≤ + rw [sq_sub_sq] + rw [abs_mul] + nth_rw 2 [mul_comm] +- -- TODO - why doesn't grw work here? + apply mul_le_mul +- . simp +- . apply abs_sub_le_abs_add a b ha hb +- . simp +- . simp +- ++ · simp ++ · apply abs_sub_le_abs_add a b ha hb ++ · simp ++ · simp + + @[expose] +-def f_n_conv_delta_tendsto: Prop := ∀ s: S, Filter.Tendsto (fun n: ℕ => MeasureTheory.eLpNorm (f_n n - (Conv (f_n n) (delta s.val))) 1 MeasureTheory.volume) Filter.atTop (nhds 0) +- ++def f_n_conv_delta_tendsto : Prop := ∀ s : S, Filter.Tendsto (fun n : ℕ => MeasureTheory.eLpNorm (f_n n - (Conv (f_n n) (delta s.val))) 1 MeasureTheory.volume) Filter.atTop (nhds 0) + +-lemma f_conv_delta_helper (f: G → ℝ) (s: G): (Conv f (delta s)) = fun g => f (s⁻¹ * g) := by ++lemma f_conv_delta_helper (f : G → ℝ) (s : G) : (Conv f (delta s)) = fun g => f (s⁻¹ * g) := by + funext g + exact f_conv_delta f g s + +- + -- Lemma 3.16 in Vikman + + -- The case split statement in Vikman + +-lemma F_n_conv_mu_lim (f_n_limit: f_n_conv_delta_tendsto): +- Filter.Tendsto (fun n => ‖(F_n_lp2 n) - conv_mu_lp2 (F_n_lp2 n)‖ₑ) Filter.atTop (nhds 0) := by ++lemma F_n_conv_mu_lim (f_n_limit : f_n_conv_delta_tendsto) : Filter.Tendsto (fun n => ‖(F_n_lp2 n) - conv_mu_lp2 (F_n_lp2 n)‖ₑ) Filter.atTop (nhds 0) := by + +- have f_n_sub_norm: ∀ s ∈ S, ∀ (i : ℕ), ∑' (g : G), ‖f_n i g - f_n i (s * g)‖ₑ ≠ ⊤ := by ++ have f_n_sub_norm : ∀ s ∈ S, ∀ (i : ℕ), ∑' (g : G), ‖f_n i g - f_n i (s * g)‖ₑ ≠ ⊤ := by + intro s hs n + have foo := f_n_norm_one n + rw [← lt_top_iff_ne_top] +- rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm (by simp) (by simp)] at foo ++ rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal (by simp) (by simp) (by apply AEStronglyMeasurable.of_discrete)] at foo + rw [lintegral_g_eq_add] at foo + simp at foo + grw [ENNReal.tsum_le_tsum (g := fun g => ‖f_n n g‖ₑ + ‖(f_n n (s * g))‖ₑ)] +- . +- rw [ENNReal.tsum_add] ++ · rw [ENNReal.tsum_add] + rw [ENNReal.add_lt_top] +- . refine ⟨?_, ?_⟩ +- . simp [foo] +- . +- grw [ENNReal.tsum_comp_le_tsum_of_injective (g := fun a => ‖f_n n a‖ₑ)] +- . +- simp [foo] +- . intro a b hab ++ · refine ⟨?_, ?_⟩ ++ · simp [foo] ++ · grw [ENNReal.tsum_comp_le_tsum_of_injective (g := fun a => ‖f_n n a‖ₑ)] ++ · simp [foo] ++ · intro a b hab + simpa using hab +- . +- intro a ++ · intro a + grw [enorm_sub_le] + + rw [← ENNReal.tendsto_toReal_iff] +- . +- have S_ne: (#S : ℝ) ≠ 0 := by ++ · have S_ne : (#S : ℝ) ≠ 0 := by + simp + have foo := hGS.hS + simp at foo +@@ -476,57 +434,38 @@ lemma F_n_conv_mu_lim (f_n_limit: f_n_conv_delta_tendsto): + simp_rw [← Finset.sum_sub_distrib] + rw [ENNReal.toReal_zero] + +- +- apply squeeze_zero (g := fun n => (1 / ↑(#S : ℝ)) • ∑ x ∈ S, (eLpNorm ((F_n_lp2 n).val.cast - (fun (g: G) => (F_n_lp2 n) (x * g))) 2 volume).toReal) +- . simp +- . +- intro n ++ apply squeeze_zero (g := fun n => (1 / ↑(#S : ℝ)) • ∑ x ∈ S, (eLpNorm ((F_n_lp2 n).val.cast - (fun (g : G) => (F_n_lp2 n) (x * g))) 2 volume).toReal) ++ · simp ++ · intro n + rw [eLpNorm_const_smul] +- grw [eLpNorm_sum_le] +- . +- simp ++ grw [eLpNorm_sum_le (by norm_num)] ++ · simp + rw [ENNReal.toReal_sum] + intro s hs + rw [← lt_top_iff_ne_top] +- grw [eLpNorm_sub_le] +- . +- rw [ENNReal.add_lt_top] +- . refine ⟨?_, ?_⟩ +- . exact Lp.eLpNorm_lt_top (F_n_lp2 n) +- . +- simp_rw [← Function.comp_def] ++ grw [eLpNorm_sub_le (by norm_num)] ++ · rw [ENNReal.add_lt_top] ++ · refine ⟨?_, ?_⟩ ++ · exact Lp.eLpNorm_lt_top (F_n_lp2 n) ++ · simp_rw [← Function.comp_def] + rw [MeasureTheory.eLpNorm_comp_measurePreserving] +- . exact Lp.eLpNorm_lt_top (F_n_lp2 n) +- . apply AEStronglyMeasurable.of_discrete +- . exact measurePreserving_mul_left volume s +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . simp +- . +- apply ENNReal.mul_ne_top (by simp) ++ · exact Lp.eLpNorm_lt_top (F_n_lp2 n) ++ · apply AEStronglyMeasurable.of_discrete ++ · exact measurePreserving_mul_left volume s ++ · apply ENNReal.mul_ne_top (by simp) + rw [ENNReal.sum_ne_top] +- -- TODO - deduplicate this + intro s hs + rw [← lt_top_iff_ne_top] +- grw [eLpNorm_sub_le] +- . +- rw [ENNReal.add_lt_top] +- . refine ⟨?_, ?_⟩ +- . exact Lp.eLpNorm_lt_top (F_n_lp2 n) +- . +- simp_rw [← Function.comp_def] ++ grw [eLpNorm_sub_le (by norm_num)] ++ · rw [ENNReal.add_lt_top] ++ · refine ⟨?_, ?_⟩ ++ · exact Lp.eLpNorm_lt_top (F_n_lp2 n) ++ · simp_rw [← Function.comp_def] + rw [MeasureTheory.eLpNorm_comp_measurePreserving] +- . exact Lp.eLpNorm_lt_top (F_n_lp2 n) +- . apply AEStronglyMeasurable.of_discrete +- . exact measurePreserving_mul_left volume s +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . simp +- . intro s hs +- apply AEStronglyMeasurable.of_discrete +- . simp +- . +- conv => ++ · exact Lp.eLpNorm_lt_top (F_n_lp2 n) ++ · apply AEStronglyMeasurable.of_discrete ++ · exact measurePreserving_mul_left volume s ++ · conv => + rhs + equals nhds ((1 / ↑(#S : ℝ)) • 0) => + simp +@@ -534,7 +473,7 @@ lemma F_n_conv_mu_lim (f_n_limit: f_n_conv_delta_tendsto): + apply Filter.Tendsto.const_smul + conv => + rhs +- equals nhds (∑ x_1 ∈ S⁻¹, (0: ℝ)) => ++ equals nhds (∑ x_1 ∈ S⁻¹, (0 : ℝ)) => + simp + conv => + arg 1 +@@ -542,30 +481,26 @@ lemma F_n_conv_mu_lim (f_n_limit: f_n_conv_delta_tendsto): + arg 1 + equals S⁻¹ => + apply S_eq_Sinv +- apply tendsto_finset_sum ++ apply tendsto_finsetSum + intro s hs + conv => + arg 1 + intro n +- rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm (by simp) (by simp)] ++ rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal (by simp) (by simp) (by apply AEStronglyMeasurable.of_discrete)] + rw [lintegral_g_eq_add] + + simp + apply squeeze_zero (g := (fun n ↦ ((∑' (g : G), ‖(f_n n) g - (f_n n) (s * g)‖ₑ) ^ (2 : ℝ)⁻¹).toReal)) +- . simp +- . +- intro n ++ · simp ++ · intro n + rw [ENNReal.toReal_le_toReal] +- . +- apply ENNReal.rpow_le_rpow +- . +- apply ENNReal.tsum_le_tsum ++ · apply ENNReal.rpow_le_rpow ++ · apply ENNReal.tsum_le_tsum + intro g + rw [Real.enorm_eq_ofReal_abs] + rw [Real.enorm_eq_ofReal_abs] + rw [← ENNReal.ofReal_pow] +- . +- apply ENNReal.ofReal_le_ofReal ++ · apply ENNReal.ofReal_le_ofReal + simp [F_n_lp2] + simp [ae_eq_everywhere.mp (MeasureTheory.MemLp.coeFn_toLp _)] + simp [F_n] +@@ -574,47 +509,39 @@ lemma F_n_conv_mu_lim (f_n_limit: f_n_conv_delta_tendsto): + arg 1 + equals (Real.sqrt (f_n n g))^2 - (Real.sqrt (f_n n (s * g)))^2 => + rw [Real.sq_sqrt] +- . +- rw [Real.sq_sqrt] +- . apply f_n_nonneg +- . apply f_n_nonneg ++ · rw [Real.sq_sqrt] ++ · apply f_n_nonneg ++ · apply f_n_nonneg + + apply norm_sub_squared_le +- . simp +- . simp +- . simp +- . simp +- . +- rw [← lt_top_iff_ne_top] +- have norm_sub_lt: eLpNorm (((F_n_lp2 n).val.cast) - ((F_n_lp2 n) ∘ fun a ↦ s * a)) 2 volume < ⊤ := by +- grw [eLpNorm_sub_le] ++ · simp ++ · simp ++ · simp ++ · simp ++ · rw [← lt_top_iff_ne_top] ++ have norm_sub_lt : eLpNorm (((F_n_lp2 n).val.cast) - ((F_n_lp2 n) ∘ fun a ↦ s * a)) 2 volume < ⊤ := by ++ grw [eLpNorm_sub_le (by norm_num)] + rw [ENNReal.add_lt_top] + refine ⟨?_, ?_⟩ +- . exact Lp.eLpNorm_lt_top (F_n_lp2 n) +- . +- rw [MeasureTheory.eLpNorm_comp_measurePreserving] +- . exact Lp.eLpNorm_lt_top (F_n_lp2 n) +- . apply AEStronglyMeasurable.of_discrete +- . exact measurePreserving_mul_left volume s +- . apply AEStronglyMeasurable.of_discrete +- . apply AEStronglyMeasurable.of_discrete +- . simp +- rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm (by simp) (by simp)] at norm_sub_lt ++ · exact Lp.eLpNorm_lt_top (F_n_lp2 n) ++ · rw [MeasureTheory.eLpNorm_comp_measurePreserving] ++ · exact Lp.eLpNorm_lt_top (F_n_lp2 n) ++ · apply AEStronglyMeasurable.of_discrete ++ · exact measurePreserving_mul_left volume s ++ rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal (by simp) (by simp) (by apply AEStronglyMeasurable.of_discrete)] at norm_sub_lt + rw [lintegral_g_eq_add] at norm_sub_lt + simp at norm_sub_lt + exact norm_sub_lt +- . +- apply ENNReal.rpow_ne_top_of_nonneg +- . simp +- . apply f_n_sub_norm s (by rw [S_eq_Sinv]; simp [hs]) +- . +- unfold f_n_conv_delta_tendsto at f_n_limit ++ · apply ENNReal.rpow_ne_top_of_nonneg ++ · simp ++ · apply f_n_sub_norm s (by rw [S_eq_Sinv]; simp [hs]) ++ · unfold f_n_conv_delta_tendsto at f_n_limit + simp at hs + specialize f_n_limit ⟨s⁻¹, hs⟩ + conv at f_n_limit => + arg 1 + intro n +- rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm (by simp) (by simp)] ++ rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal (by simp) (by simp) (by apply AEStronglyMeasurable.of_discrete)] + rw [lintegral_g_eq_add] + + simp_rw [f_conv_delta_helper] at f_n_limit +@@ -625,20 +552,14 @@ lemma F_n_conv_mu_lim (f_n_limit: f_n_conv_delta_tendsto): + simp + simp_rw [← ENNReal.toReal_rpow] + apply Filter.Tendsto.rpow_const +- . +- rw [← ENNReal.tendsto_toReal_iff] at f_n_limit +- . exact f_n_limit +- . +- apply f_n_sub_norm s (by rw [S_eq_Sinv]; simp [hs]) +- . simp +- . simp +- . intro n ++ · rw [← ENNReal.tendsto_toReal_iff] at f_n_limit ++ · exact f_n_limit ++ · apply f_n_sub_norm s (by rw [S_eq_Sinv]; simp [hs]) ++ · simp ++ · simp ++ · intro n + rw [MeasureTheory.Lp.enorm_def] + apply MeasureTheory.Lp.eLpNorm_ne_top +- . simp +- +-#print axioms F_n_conv_mu_lim +- +-#synth TopologicalSpace ↥(Lp ℝ 2 volume (α := G)) ++ · simp + + end GeneratesNS +diff --git a/Gromov/Harmonic/MuConv.lean b/Gromov/Harmonic/MuConv.lean +index 0524576..18a9cf4 100644 +--- a/Gromov/Harmonic/MuConv.lean ++++ b/Gromov/Harmonic/MuConv.lean +@@ -12,8 +12,6 @@ the telescoping identity `f_n_sub_conv`. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS +@@ -35,7 +33,7 @@ theorem mu_conv_eq_sum (m: ℕ): muConv m = fun g => (((1 : ℝ) / (#(S) : ℝ)) + funext g + simp [muConv, NTupleSum, mu, delta, Pi.single, Function.update] + by_cases g_in_s: g ∈ S +- . ++ · + simp [g_in_s] + conv => + rhs +@@ -46,21 +44,21 @@ theorem mu_conv_eq_sum (m: ℕ): muConv m = fun g => (((1 : ℝ) / (#(S) : ℝ)) + ext a + simp + refine ⟨?_, ?_⟩ +- . intro a_zero_eq ++ · intro a_zero_eq + ext x + simp + have x_eq_zero: x = 0 := by + exact Fin.fin_one_eq_zero x + rw [x_eq_zero] + exact a_zero_eq +- . intro a_eq ++ · intro a_eq + simp [a_eq] + simp +- . ++ · + simp [g_in_s] + right + by_contra this +- . ++ · + simp at this + obtain ⟨x, hx⟩ := this + rw [← hx] at g_in_s +@@ -77,7 +75,7 @@ theorem mu_conv_eq_sum (m: ℕ): muConv m = fun g => (((1 : ℝ) / (#(S) : ℝ)) + rw [Summable.tsum_mul_left] + simp_rw [Finset.sum_mul] + rw [Summable.tsum_finsetSum] +- . ++ · + conv => + lhs + rhs +@@ -85,11 +83,11 @@ theorem mu_conv_eq_sum (m: ℕ): muConv m = fun g => (((1 : ℝ) / (#(S) : ℝ)) + intro x + equals (Conv (muConv n) (delta x) ) g => + rw [conv_eq_sum] +- . ++ · + unfold muConv + unfold delta + simp_rw [mul_comm] +- . ++ · + apply conv_exists_fin_supp + right + simp [delta] +@@ -116,51 +114,51 @@ theorem mu_conv_eq_sum (m: ℕ): muConv m = fun g => (((1 : ℝ) / (#(S) : ℝ)) + nth_rw 2 [pow_succ] + simp + rw [mul_comm] +- simp only [mul_eq_mul_left_iff, inv_eq_zero, ne_eq, Nat.add_eq_zero, one_ne_zero, and_false, ++ simp only [mul_eq_mul_left_iff, inv_eq_zero, ne_eq, Nat.add_eq_zero_iff, one_ne_zero, and_false, + and_self, not_false_eq_true, pow_eq_zero_iff, Nat.cast_eq_zero, Finset.card_eq_zero] + left + rw [← Finset.sum_attach] + rw [← Finset.sum_product'] + apply Fintype.sum_bijective (e := fun (x) => (fun (i: Fin (n + 1 + 1)) => if hi: i.val = 0 then x.fst else x.snd ⟨i - 1, by omega⟩)) +- . ++ · + refine ⟨?_, ?_⟩ +- . ++ · + intro a b hab + simp at hab + ext p +- . ++ · + have fst_eq := congrFun hab (⟨0, by omega⟩) + simp at fst_eq + rw [fst_eq] + +- . ++ · + have p_lt_n_plus := p.prop + have p_val_neq: p.val ≠ n + 1 := by omega + + + have snd_eq := congrFun hab (⟨p + 1, by omega⟩) + by_cases p_eq_zero: p = 0 +- . ++ · + simp [p_eq_zero] at snd_eq + rw [p_eq_zero] + rw [snd_eq] +- . ++ · + simp [p_eq_zero] at snd_eq + rw [snd_eq] +- . ++ · + intro f + use ((f (⟨0, by omega⟩)), fun i => f (⟨i + 1, by omega⟩)) + funext i + simp + by_cases i_eq_zero: i = 0 +- . simp [i_eq_zero] +- . ++ · simp [i_eq_zero] ++ · + simp [i_eq_zero] + have i_val_neq_zero: i.val ≠ 0 := by + simp [i_eq_zero] + have one_le_i: 1 ≤ i.val := by omega + simp [Nat.sub_add_cancel one_le_i] +- . ++ · + intro x + simp only [delta] + rw [Pi.single_apply] +@@ -168,10 +166,10 @@ theorem mu_conv_eq_sum (m: ℕ): muConv m = fun g => (((1 : ℝ) / (#(S) : ℝ)) + + + split_ifs +- . ++ · + rename _ => hi +- simp [hi] +- . ++ simp ++ · + rename_i g_eq g_mul_neq + apply_fun (fun y => (x.fst.val) * y ) at g_eq + rw [← mul_assoc] at g_eq +@@ -186,63 +184,62 @@ theorem mu_conv_eq_sum (m: ℕ): muConv m = fun g => (((1 : ℝ) / (#(S) : ℝ)) + + + contradiction +- . rename_i g_mul_neq g_eq ++ · rename_i g_mul_neq g_eq + + simp [List.ofFn_succ] at g_eq + rw [← g_eq] at g_mul_neq + simp at g_mul_neq +- . rfl +- . intro s hs ++ · rfl ++ · intro s hs + simp [Pi.single_apply] + rw [← summable_norm_iff] + apply Summable.of_nonneg_of_le (f := fun a => ‖(fun f ↦ Conv f mu)^[n] mu ((Additive.toMul a))‖) +- . ++ · + intro x + simp +- . intro x ++ · intro x + split_ifs +- . rfl +- . simp +- . ++ · rfl ++ · simp ++ · + rw [summable_norm_iff] + have conv_finsupp := mu_conv_finsupp n + unfold muConv at conv_finsupp + + apply summable_of_hasFiniteSupport + apply Set.Finite.of_injOn (f := fun a => ( (Additive.toMul a))) (ht := conv_finsupp) +- . ++ · + intro a ha + exact ha +- . intro a ha b hb ++ · intro a ha b hb + simp +- -- TODO - deduplicate this with the above goal +- . ++ · + simp [Pi.single_apply] + rw [← summable_norm_iff] + apply Summable.of_nonneg_of_le (f := fun a => ‖(fun f ↦ Conv f mu)^[n] mu ((Additive.toMul a))‖) +- . ++ · + intro x + simp +- . intro x ++ · intro x + split_ifs +- . rfl +- . simp +- . ++ · rfl ++ · simp ++ · + rw [summable_norm_iff] + have conv_finsupp := mu_conv_finsupp n + unfold muConv at conv_finsupp + + apply summable_of_hasFiniteSupport + apply Set.Finite.of_injOn (f := fun a => ( (Additive.toMul a))) (ht := conv_finsupp) +- . ++ · + intro a ha + exact ha +- . intro a ha b hb ++ · intro a ha b hb + simp +- . ++ · + apply conv_exists_fin_supp + right +- simp [delta] ++ simp + apply Set.Finite.subset (ht := Function.support_const_smul_subset _ _) + have supp_sum := Finset.support_sum (s := S) (f := fun s => Pi.single (M := fun _ : G => ℝ) s (1: ℝ)) + conv => +@@ -262,34 +259,34 @@ lemma mu_conv_nonneg (n: ℕ): ∀ g, 0 ≤ muConv n g := by + | zero => + simp [muConv, mu] + split_ifs +- . simp +- . simp ++ · simp ++ · simp + | succ n ih => + rw [mu_conv_eq_sum] + apply mul_nonneg +- . simp +- . ++ · simp ++ · + simp [NTupleSum] + apply Finset.sum_nonneg + intro i hi + simp [delta, Pi.single_apply] + split_ifs +- . simp +- . simp ++ · simp ++ · simp + + + lemma f_n_nonneg: ∀ n: ℕ, ∀ g: G, 0 ≤ f_n n g := by + intro n g + simp [f_n] + apply mul_nonneg +- . positivity +- . apply Finset.sum_nonneg ++ · positivity ++ · apply Finset.sum_nonneg + intro i hi + apply mu_conv_nonneg + + lemma conv_laplce_norm (n: ℕ) (H_n: ℕ → G → ℝ): eLpNorm ((Laplace_b ((Conv (H_n n)) (f_n n)))) ⊤ (μ := volume (α := G)) ≤ eLpNorm (H_n n) ⊤ * (eLpNorm (Laplace_b (f_n n)) 1 (μ := volume (α := G))) := by + rw [laplace_conv_eq_laplace_right] +- . ++ · + unfold Conv + eta_reduce + simp only [volume] +@@ -307,16 +304,16 @@ lemma conv_laplce_norm (n: ℕ) (H_n: ℕ → G → ℝ): eLpNorm ((Laplace_b (( + + refine le_trans my_norm ?_ + have hmul : ‖ContinuousLinearMap.mul ℝ ℝ‖ₑ ≤ 1 := by +- rw [← ofReal_norm_eq_enorm, ENNReal.ofReal_le_one] ++ rw [← ofReal_norm, ENNReal.ofReal_le_one] + exact ContinuousLinearMap.opNorm_mul_le ℝ ℝ + rw [mul_assoc] + exact le_trans (mul_le_mul_left hmul _) (le_of_eq (one_mul _)) +- . ++ · + apply conv_exists_fin_supp + right + exact f_n_fin_supp n +- . apply f_n_nonneg +- . exact f_n_fin_supp n ++ · apply f_n_nonneg ++ · exact f_n_fin_supp n + + + lemma lintegral_g_eq_add (f: G → ENNReal): (∫⁻ (g: G), f g) = (∑' (g : G), f g) := by +@@ -325,11 +322,11 @@ lemma lintegral_g_eq_add (f: G → ENNReal): (∫⁻ (g: G), f g) = (∑' (g : G + + lemma integral_eq_eq_sum (f: G → ℝ) (hf: Integrable f): (∫ (g: G), f g) = (∑' (g : G), f g) := by + rw [MeasureTheory.integral_countable] +- . ++ · + simp [MeasureTheory.volume] + simp_rw [my_haar_eq_count] + simp +- . apply hf ++ · apply hf + + + lemma mu_norm_one (m: ℕ): MeasureTheory.eLpNorm (muConv m) 1 = 1 := by +@@ -349,35 +346,35 @@ lemma mu_norm_one (m: ℕ): MeasureTheory.eLpNorm (muConv m) 1 = 1 := by + rw [Real.enorm_of_nonneg (by + apply Finset.sum_nonneg + intro x hx +- simp [delta, Pi.single_apply] ++ simp [Pi.single_apply] + split_ifs +- . simp +- . simp ++ · simp ++ · simp + )] + + + rw [← ENNReal.ofReal_tsum_of_nonneg] + simp [Pi.single_apply] +- . intro g ++ · intro g + apply Finset.sum_nonneg + intro i + simp [Pi.single_apply] + split_ifs +- . simp +- . simp +- . ++ · simp ++ · simp ++ · + apply summable_sum + intro i hi + simp only [Pi.single_apply] + apply summable_of_hasFiniteSupport + apply Set.Finite.subset (s := {(List.ofFn i).unattach.prod}) +- . simp +- . intro a ha ++ · simp ++ · intro a ha + simp + simp at ha + rw [ha] + rw [Summable.tsum_finsetSum] +- . ++ · + conv => + lhs + rhs +@@ -394,19 +391,18 @@ lemma mu_norm_one (m: ℕ): MeasureTheory.eLpNorm (muConv m) 1 = 1 := by + rw [← ENNReal.ofReal_natCast] + rw [← ENNReal.ofReal_pow] + rw [← ENNReal.ofReal_mul] +- . ++ · + field_simp + simp + exact Finset.nonempty_iff_ne_empty.mp S_nonempty +- . simp +- . simp +- . +- -- TODO - deduplicate this with the above goal ++ · simp ++ · simp ++ · + intro a ha + apply summable_of_hasFiniteSupport + apply Set.Finite.subset (s := {(List.ofFn a).unattach.prod}) +- . simp +- . intro a ha ++ · simp ++ · intro a ha + simp + simp at ha + rw [ha] +@@ -444,7 +440,7 @@ theorem f_n_norm_one (n: ℕ): MeasureTheory.eLpNorm (f_n n) 1 = 1 := by + )] + + rw [Summable.tsum_finsetSum] +- . ++ · + have mu_norm := mu_norm_one + simp [MeasureTheory.eLpNorm, MeasureTheory.eLpNorm'] at mu_norm + simp_rw [lintegral_g_eq_add] at mu_norm +@@ -457,12 +453,12 @@ theorem f_n_norm_one (n: ℕ): MeasureTheory.eLpNorm (f_n n) 1 = 1 := by + )] + rw [← ENNReal.ofReal_natCast] + rw [← ENNReal.ofReal_mul] +- . ++ · + field_simp + simp +- . simp ++ · simp + linarith +- . ++ · + simp + + +@@ -507,7 +503,7 @@ theorem f_n_sub_conv (n: ℕ): MeasureTheory.eLpNorm ((f_n n) - (Conv (f_n n) + simp + + rw [conv_sum] +- . ++ · + rw [← smul_sub] + rw [← Finset.sum_sub_distrib] + conv => +@@ -553,8 +549,8 @@ theorem f_n_sub_conv (n: ℕ): MeasureTheory.eLpNorm ((f_n n) - (Conv (f_n n) + simp + simp at hx + split_ifs +- . simp +- . omega ++ · simp ++ · omega + )] + + +@@ -567,11 +563,8 @@ theorem f_n_sub_conv (n: ℕ): MeasureTheory.eLpNorm ((f_n n) - (Conv (f_n n) + _ ≤ ‖((n + 1): ℝ)⁻¹‖ₑ * MeasureTheory.eLpNorm ((mu - muConv (n + 1))) 1 MeasureTheory.volume := by + apply MeasureTheory.eLpNorm_const_smul_le + _ ≤ ‖((n + 1): ℝ)⁻¹‖ₑ * (MeasureTheory.eLpNorm ((mu)) 1 MeasureTheory.volume + (MeasureTheory.eLpNorm ((muConv (n + 1))) 1 MeasureTheory.volume)) := by +- have sub_le := MeasureTheory.eLpNorm_sub_le (p := 1) (f := mu ) (g := muConv (n + 1)) (μ := MeasureTheory.volume) ?_ ?_ (by simp) +- . +- apply mul_le_mul_right sub_le +- . apply MeasureTheory.AEStronglyMeasurable.of_discrete +- . apply MeasureTheory.AEStronglyMeasurable.of_discrete ++ exact mul_le_mul' le_rfl (MeasureTheory.eLpNorm_sub_le (p := 1) ++ (f := mu) (g := muConv (n + 1)) (μ := MeasureTheory.volume) (by simp)) + _ ≤ ENNReal.ofReal ((2: ℝ) / ((n + 1): ℝ)) := by + rw [mu_norm_one] + have mu_single_norm := mu_norm_one 0 +@@ -590,11 +583,8 @@ theorem f_n_sub_conv (n: ℕ): MeasureTheory.eLpNorm ((f_n n) - (Conv (f_n n) + field_simp + simp + positivity +- . exact mu_finsupp ++ · exact mu_finsupp + + +-#print axioms mu_conv_eq_sum +-#print axioms f_n_norm_one +-#print axioms f_n_sub_conv + + end GeneratesNS +diff --git a/Gromov/Harmonic/Proposition318.lean b/Gromov/Harmonic/Proposition318.lean +index 7d7da9c..c36f3cc 100644 +--- a/Gromov/Harmonic/Proposition318.lean ++++ b/Gromov/Harmonic/Proposition318.lean +@@ -12,8 +12,6 @@ sequence. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS +@@ -31,176 +29,164 @@ open MeasureTheory + + open scoped RealInnerProductSpace + +-set_option maxHeartbeats 600000 in +-lemma laplace_g_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ∃ g: (Lp ℝ 2 volume (α := G)), ‖Laplace g‖ ≤ (1 : ℝ) / n ∧ ⟪Laplace g, g⟫ = 1 := by +- +- let eps := ((1: ℝ) / n)^2 +- -- selfAdjoint.mem_spectrum_eq_re ++private lemma laplace_spectrum_nonisolated (n : ℕ) (hn : 0 < n) ++ (hf : f_n_conv_delta_tendsto) : ++ spectrum ℝ (Laplace_linear.mkContinuous _ laplace_bounded') ∩ ++ Set.Ioo 0 (((1 : ℝ) / n)^2) ≠ ∅ := by ++ let eps := ((1 : ℝ) / n)^2 ++ let Δ := Laplace_linear.mkContinuous _ laplace_bounded' ++ change spectrum ℝ Δ ∩ Set.Ioo 0 eps ≠ ∅ + +- let P: Polynomial ℝ := (Polynomial.X^2 - eps • Polynomial.X) ++ by_contra! ++ have zero_isolated: spectrum ℝ Δ ∩ (Set.Ico 0 eps) = {0} := by ++ ext a ++ simp ++ refine ⟨?_, ?_⟩ ++ · ++ intro ha ++ obtain ⟨a_mem_spec, a_range⟩ := ha ++ by_contra a_nonzero ++ have a_mem: a ∈ Set.Ioo 0 eps := by ++ grind + +- let Δ := Laplace_linear.mkContinuous _ (laplace_bounded') ++ have a_mem_empty: a ∈ (∅ : Set ℝ) := by ++ rw [← this] ++ grind + +- have spec_inter: spectrum ℝ Δ ∩ Set.Ioo 0 eps ≠ ∅ := by +- by_contra! +- have zero_isolated: spectrum ℝ Δ ∩ (Set.Ico 0 eps) = {0} := by +- ext a +- simp +- refine ⟨?_, ?_⟩ +- . +- intro ha +- obtain ⟨a_mem_spec, a_range⟩ := ha +- by_contra a_nonzero +- have a_mem: a ∈ Set.Ioo 0 eps := by +- grind ++ simp at a_mem_empty ++ · ++ intro ha ++ simp [ha] ++ refine ⟨?_, by simp [eps, hn]⟩ ++ apply laplace_spectrum_contains_zero hf ++ ++ have zero_mem := laplace_spectrum_contains_zero hf ++ rw [spectrum.mem_iff] at zero_mem ++ simp at zero_mem ++ ++ let ramp: ℝ → ℝ := fun x => max 0 (min 1 (x / eps)) ++ ++ have self_adjoint_cx_del: IsSelfAdjoint (Cx.mapCLM Δ) := by ++ apply Cx.isSelfAdjoint_mapCLM ++ apply Δ_symmetric.isSelfAdjoint ++ ++ ++ let Q := cfc (1 - ramp) (Cx.mapCLM Δ) ++ have laplace_q: (Cx.mapCLM Δ) * Q = cfc (0: ℝ → ℝ) (Cx.mapCLM Δ) := by ++ unfold Q ++ nth_rw 1 [← cfc_id (a := Cx.mapCLM Δ) ℝ] ++ rw [← cfc_mul (hf := by exact continuousOn_id) (hg := by fun_prop)] ++ apply cfc_congr ++ intro x hx ++ simp [ramp, max_def'] ++ norm_num ++ split_ifs ++ · ++ rw [Cx.spectrum_mapCLM] at hx ++ rename_i x_div ++ apply Δ_spectrum_subset at hx ++ simp [eps] at x_div ++ have x_nonpos := nonpos_of_mul_nonpos_left x_div (by simp [hn]) ++ left ++ simp at hx ++ grind ++ · simp [min_def'] ++ split_ifs ++ · + +- have a_mem_empty: a ∈ (∅ : Set ℝ) := by +- rw [← this] +- grind ++ by_cases x_eq: x = eps ++ · simp [x_eq, eps] ++ field_simp ++ simp ++ · ++ rename_i x_div_le ++ rw [div_le_one₀ (by simp [eps]; positivity)] at x_div_le ++ have x_lt: x < eps := by ++ grind + +- simp at a_mem_empty +- . +- intro ha +- simp [ha] +- refine ⟨?_, by simp [eps, hn]⟩ +- apply laplace_spectrum_contains_zero hf +- +- have zero_mem := laplace_spectrum_contains_zero hf +- rw [spectrum.mem_iff] at zero_mem +- simp at zero_mem +- +- let ramp: ℝ → ℝ := fun x => max 0 (min 1 (x / eps)) +- +- have self_adjoint_cx_del: IsSelfAdjoint (Cx.mapCLM Δ) := by +- apply Cx.isSelfAdjoint_mapCLM +- apply Δ_symmetric.isSelfAdjoint +- +- +- let Q := cfc (1 - ramp) (Cx.mapCLM Δ) +- have laplace_q: (Cx.mapCLM Δ) * Q = cfc (0: ℝ → ℝ) (Cx.mapCLM Δ) := by +- unfold Q +- nth_rw 1 [← cfc_id (a := Cx.mapCLM Δ) ℝ] +- rw [← cfc_mul (hf := by exact continuousOn_id) (hg := by fun_prop)] +- apply cfc_congr +- intro x hx +- simp [ramp, max_def'] +- norm_num +- split_ifs +- . +- rw [Cx.spectrum_mapCLM] at hx +- rename_i x_div +- apply Δ_spectrum_subset at hx +- simp [eps] at x_div +- have x_nonpos := nonpos_of_mul_nonpos_left x_div (by simp [hn]) +- left +- simp at hx +- grind +- . simp [min_def'] +- split_ifs +- . + +- by_cases x_eq: x = eps +- . simp [x_eq, eps] +- field_simp ++ have x_mem_zero: x ∈ ({0} : Set ℝ) := by ++ rw [← zero_isolated] + simp +- . +- rename_i x_div_le +- rw [div_le_one₀ (by simp [eps]; positivity)] at x_div_le +- have x_lt: x < eps := by ++ refine ⟨?_, ?_⟩ ++ · ++ rw [Cx.spectrum_mapCLM] at hx ++ exact hx ++ · ++ rw [Cx.spectrum_mapCLM] at hx ++ apply Δ_spectrum_subset at hx ++ simp at hx + grind + ++ simp at x_mem_zero ++ simp [x_mem_zero] ++ · simp + +- have x_mem_zero: x ∈ ({0} : Set ℝ) := by +- rw [← zero_isolated] +- simp +- refine ⟨?_, ?_⟩ +- . +- rw [Cx.spectrum_mapCLM] at hx +- exact hx +- . +- rw [Cx.spectrum_mapCLM] at hx +- apply Δ_spectrum_subset at hx +- simp at hx +- grind +- +- simp at x_mem_zero +- simp [x_mem_zero] +- . simp +- +- +- simp at laplace_q +- have one_mem_q_spec: 1 ∈ spectrum ℝ Q := by +- rw [cfc_map_spectrum (hf := by fun_prop)] +- simp [ramp] +- use 0 +- rw [Cx.spectrum_mapCLM] +- refine ⟨laplace_spectrum_contains_zero hf, ?_⟩ +- right +- simp + +- have nontrivial_cx: Nontrivial (Cx ↥(Lp ℝ 2 volume (α := G)) →L[ℂ] Cx ↥(Lp ℝ 2 volume (α := G))) := by ++ simp at laplace_q ++ have one_mem_q_spec: 1 ∈ spectrum ℝ Q := by ++ rw [cfc_map_spectrum (hf := by fun_prop)] ++ simp [ramp] ++ use 0 ++ rw [Cx.spectrum_mapCLM] ++ refine ⟨laplace_spectrum_contains_zero hf, ?_⟩ ++ right ++ simp + +- use 1 +- use 0 +- simp +- rw [ContinuousLinearMap.ext_iff] +- simp +- let hf := (finsupp_lp_top (Pi.single 1 1) (by +- simp +- ) 2) +- rw [← my_haar_eq_count] at hf +- use (hf.toLp, 0) +- apply_fun (fun a => a.fst) +- simp +- rw [MeasureTheory.Lp.ext_iff] +- have haar_eq_volume: myHaar = volume := by +- simp [volume] +- simp_rw [haar_eq_volume] +- rw [ae_eq_everywhere.mp (MeasureTheory.MemLp.coeFn_toLp _)] +- simp +- rw [funext_iff] +- simp +- use 1 ++ have nontrivial_cx: Nontrivial (Cx ↥(Lp ℝ 2 volume (α := G)) →L[ℂ] Cx ↥(Lp ℝ 2 volume (α := G))) := by ++ ++ use 1 ++ use 0 ++ simp ++ rw [ContinuousLinearMap.ext_iff] ++ simp ++ let hf := (finsupp_lp_top (Pi.single 1 1) (by + simp ++ ) 2) ++ rw [← my_haar_eq_count] at hf ++ use (hf.toLp, 0) ++ apply_fun (fun a => a.fst) ++ simp ++ rw [MeasureTheory.Lp.ext_iff] ++ have haar_eq_volume: myHaar = volume := by ++ simp [volume] ++ simp_rw [haar_eq_volume] ++ rw [ae_eq_everywhere.mp (MeasureTheory.MemLp.coeFn_toLp _)] ++ simp ++ rw [funext_iff] ++ simp ++ use 1 ++ simp + +- have Q_nonzero: Q ≠ 0 := by +- by_contra! +- simp [this] at one_mem_q_spec +- +- apply ContinuousLinearMap.exists_ne_zero at Q_nonzero +- obtain ⟨x, hx⟩ := Q_nonzero +- have laplace_q_x: (Cx.mapCLM Δ) (Q x) = 0 := by +- rw [← ContinuousLinearMap.mul_apply] +- simp [laplace_q] +- +- by_cases fst_nonzero: (Q x).fst ≠ 0 +- . +- simp at laplace_q_x +- apply_fun (fun a => a.fst) at laplace_q_x +- simp at laplace_q_x +- simp [Δ, LinearMap.mkContinuous, Laplace_linear] at laplace_q_x +- apply laplace_zero_iff_zero at laplace_q_x +- contradiction +- . +- have snd_nonzero: (Q x).snd ≠ 0 := by +- by_contra! +- simp at fst_nonzero +- have Q_zero: (Q x) = 0 := by +- apply Cx.ext +- all_goals { +- simp +- grind +- } +- contradiction ++ have Q_nonzero: Q ≠ 0 := by ++ by_contra! ++ simp [this] at one_mem_q_spec ++ ++ apply ContinuousLinearMap.exists_ne_zero at Q_nonzero ++ obtain ⟨x, hx⟩ := Q_nonzero ++ have laplace_q_x: (Cx.mapCLM Δ) (Q x) = 0 := by ++ rw [← mul_apply_eq_comp] ++ simp [laplace_q] ++ ++ have hfst : Laplace (Q x).fst = 0 := by ++ have h := congrArg Cx.fst laplace_q_x ++ simpa [Δ, LinearMap.mkContinuous, Laplace_linear] using h ++ have hsnd : Laplace (Q x).snd = 0 := by ++ have h := congrArg Cx.snd laplace_q_x ++ simpa [Δ, LinearMap.mkContinuous, Laplace_linear] using h ++ have hz : Q x = 0 := Cx.ext (laplace_zero_iff_zero _ hfst) (laplace_zero_iff_zero _ hsnd) ++ exact hx hz ++ ++lemma laplace_g_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ∃ g: (Lp ℝ 2 volume (α := G)), ‖Laplace g‖ ≤ (1 : ℝ) / n ∧ ⟪Laplace g, g⟫ = 1 := by + +- -- TODO - deduplicate this +- simp at laplace_q_x +- apply_fun (fun a => a.snd) at laplace_q_x +- simp at laplace_q_x +- simp [Δ, LinearMap.mkContinuous, Laplace_linear] at laplace_q_x +- apply laplace_zero_iff_zero at laplace_q_x +- contradiction ++ let eps := ((1: ℝ) / n)^2 ++ -- selfAdjoint.mem_spectrum_eq_re ++ ++ let P: Polynomial ℝ := (Polynomial.X^2 - eps • Polynomial.X) ++ ++ let Δ := Laplace_linear.mkContinuous _ (laplace_bounded') + ++ have spec_inter := laplace_spectrum_nonisolated n hn hf + + rw [← Set.nonempty_iff_ne_empty] at spec_inter + obtain ⟨a, ha⟩ := spec_inter +@@ -217,21 +203,21 @@ lemma laplace_g_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ∃ g: (Lp + + have p_a_neg: P.eval a < 0 := by + simp [P] +- simp at ha +- nlinarith ++ change 0 < a ∧ a < eps at a_lt ++ nlinarith [a_lt.1, a_lt.2] + + have eval_symm: (((Polynomial.aeval Δ) P)).IsSymmetric := by + simp [P] + apply LinearMap.IsSymmetric.sub +- . apply LinearMap.IsSymmetric.pow ++ · apply LinearMap.IsSymmetric.pow + apply Δ_symmetric +- . apply LinearMap.IsSymmetric.smul +- . simp +- . apply Δ_symmetric ++ · apply LinearMap.IsSymmetric.smul ++ · simp ++ · apply Δ_symmetric + + + have not_pos := ContinuousLinearMap.IsPositive.spectrumRestricts (f := (Polynomial.aeval Δ P)).mt ?_ +- . ++ · + simp [ContinuousLinearMap.IsPositive, eval_symm] at not_pos + obtain ⟨x, hx, x_inner⟩ := not_pos + simp [ContinuousLinearMap.reApplyInnerSelf, P] at x_inner +@@ -253,7 +239,7 @@ lemma laplace_g_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ∃ g: (Lp + use ((√⟪Laplace ⟨x, hx⟩, ⟨x, hx⟩⟫)⁻¹) • ⟨x, hx⟩ + rw [inner_sub_left] at x_inner + refine ⟨?_, ?_⟩ +- . ++ · + rw [norm_eq_sqrt_real_inner] + simp [Δ, LinearMap.mkContinuous, Laplace_linear] at x_inner + rw [← laplace_self_adjoint] at x_inner +@@ -263,19 +249,19 @@ lemma laplace_g_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ∃ g: (Lp + rw [norm_smul] + simp + rw [← Real.lt_sqrt] at x_inner +- . grw [x_inner] ++ · grw [x_inner] + rw [Real.sqrt_mul] +- ring ++ ring_nf + rw [abs_of_nonneg] +- . ++ · + field_simp + simp [eps] + grind +- . simp +- . simp [eps] +- . simp ++ · simp ++ · simp [eps] ++ · simp + +- . ++ · + rw [laplace_smul] + rw [inner_smul_left, inner_smul_right] + simp +@@ -283,7 +269,7 @@ lemma laplace_g_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ∃ g: (Lp + rw [Real.sq_sqrt] + rw [← laplace_self_adjoint] + apply laplace_positive_semidefinite +- . rw [SpectrumRestricts.nnreal_iff] ++ · rw [SpectrumRestricts.nnreal_iff] + simp + use P.eval a + +@@ -297,7 +283,6 @@ lemma laplace_g_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ∃ g: (Lp + -- This whole proof is completely wrong - it needs to use the spectral theorem + + +-#print axioms laplace_g_n + + + lemma measure_preserving_inv: MeasurePreserving Inv.inv ((MeasureTheory.volume (α := G))) (MeasureTheory.volume (α := G)) := { +@@ -318,7 +303,7 @@ noncomputable def G_n (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto) := Class + + + lemma lp_summable {p: ℕ} (hp: 0 < p) (f: (Lp ℝ p volume (α := G))): Summable (fun g: G => |(f g)|^p) := by +- have f_norm := (MeasureTheory.Lp.memLp f).2 ++ have f_norm := (MeasureTheory.Lp.memLp f).eLpNorm_lt_top + simp [eLpNorm, eLpNorm'] at f_norm + have not_le: ¬(p = 0) := by linarith + simp [not_le] at f_norm +@@ -353,9 +338,9 @@ lemma lp2_summable (f: (Lp ℝ 2 volume (α := G))): Summable (fun g: G => (f g) + + + lemma summable_f_mul_translate (f: (Lp ℝ 2 volume (α := G))) (i: G): Summable (fun x => (f x) * (f (i * x))) := by +- have lp_mul := (MeasureTheory.MemLp.mul (φ := f) (f := fun x => f (i * x)) (p := 2) (q := 2) (r := 1) (μ := volume) ?_ ?_).2 +- . +- simp [MemLp, eLpNorm, eLpNorm'] at lp_mul ++ have lp_mul := (MeasureTheory.MemLp.mul (φ := f) (f := fun x => f (i * x)) (p := 2) (q := 2) (r := 1) (μ := volume) ?_ ?_).eLpNorm_lt_top ++ · ++ simp [eLpNorm, eLpNorm'] at lp_mul + rw [lintegral_g_eq_add] at lp_mul + simp [Real.enorm_eq_ofReal_abs] at lp_mul + simp [← ENNReal.ofReal_mul] at lp_mul +@@ -366,23 +351,22 @@ lemma summable_f_mul_translate (f: (Lp ℝ 2 volume (α := G))) (i: G): Summable + intro x + rw [ENNReal.toReal_ofReal (by + apply mul_nonneg +- . simp +- . simp ++ · simp ++ · simp + )] + apply Summable.of_abs + simp_rw [abs_mul] + exact lp_mul +- . ++ · apply Lp.memLp f ++ · + rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp f +- . exact measurePreserving_mul_left volume i +- . apply Lp.memLp f ++ · apply MeasureTheory.Lp.memLp f ++ · exact measurePreserving_mul_left volume i + + + -- Note - this is stated incorrectly in Vikman + -- The RHS should have a squared norm +-set_option maxRecDepth 40000 in + lemma proposition_3_18 (f: (Lp ℝ 2 volume (α := G))): (∑' g: G, (f g) * (Laplace f) g) = ((2) * (#(S) : ℝ))⁻¹ * ∑ s ∈ S, ‖(f - (conv_finsupp_lp2 f (delta s) (by simp [delta])))‖^2 := by + simp_rw [Laplace] + simp_rw [conv_mu_lp2] +@@ -431,7 +415,7 @@ lemma proposition_3_18 (f: (Lp ℝ 2 volume (α := G))): (∑' g: G, (f g) * (La + + rw [Summable.tsum_mul_left] + rw [Summable.tsum_mul_left] +- have f_norm := MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm (p := 2) (by simp) (by simp) (f := f.val.cast) (μ := volume (α := G)) ++ have f_norm := MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal (p := 2) (by simp) (by simp) (f := f.val.cast) (μ := volume (α := G)) (MeasureTheory.Lp.aestronglyMeasurable f) + simp_rw [lintegral_g_eq_add] at f_norm + simp [enorm] at f_norm + apply_fun ENNReal.toReal at f_norm +@@ -488,21 +472,19 @@ lemma proposition_3_18 (f: (Lp ℝ 2 volume (α := G))): (∑' g: G, (f g) * (La + conv at inner_f_conv => + intro a + rhs +- -- TODO - deduplicate this with the 'have lp_mul' block above + rw [MeasureTheory.integral_countable (by + simp [f_conv_delta] + simp [Integrable] +- refine ⟨by apply AEStronglyMeasurable.of_discrete, ?_⟩ + simp [HasFiniteIntegral] + simp [Real.enorm_eq_ofReal_abs] + rw [lintegral_g_eq_add] + rw [lt_top_iff_ne_top] + simp_rw [← ENNReal.ofReal_mul (abs_nonneg _), ← abs_mul] + rw [← ENNReal.ofReal_tsum_of_nonneg] +- . apply ENNReal.ofReal_ne_top +- . intro n ++ · apply ENNReal.ofReal_ne_top ++ · intro n + positivity +- . ++ · + apply Summable.abs + simp_rw [mul_comm] + apply summable_f_mul_translate +@@ -545,28 +527,28 @@ lemma proposition_3_18 (f: (Lp ℝ 2 volume (α := G))): (∑' g: G, (f g) * (La + rw [Finset.sum_add_distrib, Finset.sum_sub_distrib, ← Finset.mul_sum] + eta_reduce + ring +- . apply summable_sum ++ · apply summable_sum + intro s hs + simp_rw [f_conv_delta] + apply summable_f_mul_translate +- . ++ · + apply tsum_nonneg + intro g + apply sq_nonneg +- . simp +- . apply summable_sum ++ · simp ++ · apply summable_sum + intro s hs + apply lp2_summable +- . ++ · + apply Summable.mul_left + apply summable_sum + intro s hs + apply lp2_summable +- . simp_rw [mul_assoc] ++ · simp_rw [mul_assoc] + apply Summable.mul_left + simp_rw [← pow_two] + apply lp2_summable +- . simp_rw [mul_assoc] ++ · simp_rw [mul_assoc] + apply Summable.mul_left + rw [ae_eq_everywhere.mp (MeasureTheory.MemLp.coeFn_toLp _)] + simp_rw [← mul_assoc] +@@ -578,14 +560,14 @@ lemma proposition_3_18 (f: (Lp ℝ 2 volume (α := G))): (∑' g: G, (f g) * (La + simp_rw [mul_assoc] + apply Summable.mul_left + apply summable_f_mul_translate +- . ++ · + apply Summable.mul_left + rw [ae_eq_everywhere.mp (MeasureTheory.MemLp.coeFn_toLp _)] + simp_rw [mul_sub] + apply Summable.sub +- . simp_rw [← pow_two] ++ · simp_rw [← pow_two] + apply lp2_summable +- . ++ · + simp_rw [← mul_assoc] + simp_rw [Finset.mul_sum] + apply summable_sum +@@ -611,8 +593,6 @@ lemma g_n_conv_norm (n: ℕ) (hn: 0 < n) (hf: f_n_conv_delta_tendsto): ⟪Laplac + exact g_n_prop.2 + + +-#print sorries proposition_3_18 +-#print axioms proposition_3_18 + + + lemma g_sub_norm_gt (hf: f_n_conv_delta_tendsto) (n: ℕ) : ∃ s ∈ S, ‖(G_n (n + 1) (by simp) hf) - (conv_finsupp_lp2 (G_n (n + 1) (by simp) hf) (delta s) (by simp [delta]))‖^2 > 1 := by +@@ -623,7 +603,7 @@ lemma g_sub_norm_gt (hf: f_n_conv_delta_tendsto) (n: ℕ) : ∃ s ∈ S, ‖(G_n + have g_n_prop := (Classical.choose_spec (laplace_g_n (n + 1) (by simp) hf)).2 + have real_inner : ∀ a b : ℝ, ⟪a, b⟫ = b * a := fun a b => rfl + rw [integral_eq_eq_sum] at g_inner_laplace +- . ++ · + simp_rw [real_inner] at g_inner_laplace + simp_rw [← g_inner_laplace] at sum_norm + nth_rw 1 [G_n] at sum_norm +@@ -634,15 +614,15 @@ lemma g_sub_norm_gt (hf: f_n_conv_delta_tendsto) (n: ℕ) : ∃ s ∈ S, ‖(G_n + rw [← sum_norm] at card_le + simp at card_le + rw [mul_le_iff_le_one_left] at card_le +- . norm_num at card_le +- . simp ++ · norm_num at card_le ++ · simp + have foo := S_nonempty + grind +- . ++ · + simp + grind + +- . ++ · + rw [MeasureTheory.L2.inner_def] at g_n_prop + apply MeasureTheory.integrable_of_integral_eq_one at g_n_prop + exact g_n_prop +@@ -704,14 +684,14 @@ lemma laplace_b_sub (f g: G → ℝ): Laplace_b (f - g) = Laplace_b f - Laplace_ + simp [Laplace_b] + nth_rw 3 [sub_eq_add_neg] + rw [conv_add_left] +- . ++ · + rw [conv_neg_left] + ring_nf +- . ++ · + apply conv_exists_fin_supp + right + apply mu_finsupp +- . apply conv_exists_fin_supp ++ · apply conv_exists_fin_supp + right + apply mu_finsupp + +diff --git a/Gromov/Harmonic/SelfAdjoint.lean b/Gromov/Harmonic/SelfAdjoint.lean +index af09060..21e136c 100644 +--- a/Gromov/Harmonic/SelfAdjoint.lean ++++ b/Gromov/Harmonic/SelfAdjoint.lean +@@ -12,38 +12,34 @@ public import Gromov.Harmonic.LaplaceLinear + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + attribute [local implicit_reducible] Additive + + namespace GeneratesNS + open Generates + +-variable [hGS: Generates] ++variable [hGS : Generates] + include hGS + +-variable {V: Submodule ℝ LipschitzH} [V_finite: FiniteDimensional ℝ V] [Nontrivial V] ++variable {V : Submodule ℝ LipschitzH} [V_finite : FiniteDimensional ℝ V] [Nontrivial V] + + open scoped Finset + open scoped Pointwise + open scoped Convolution + open MeasureTheory + +-lemma laplace_smul (k: ℝ) (f: (Lp ℝ 2 volume (α := G))): Laplace (k • f) = k • (Laplace f) := by ++lemma laplace_smul (k : ℝ) (f : (Lp ℝ 2 volume (α := G))) : Laplace (k • f) = k • (Laplace f) := by + simp [Laplace, conv_mu_lp2] + simp_rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_smul _ _)] + simp_rw [conv_smul] + rw [MeasureTheory.MemLp.toLp_const_smul] + rw [smul_sub] + +- +-lemma norm_conv_mu_le (f: (Lp ℝ 2 volume (α := G))): ‖conv_mu_lp2 f‖ ≤ ‖f‖ := by ++lemma norm_conv_mu_le (f : (Lp ℝ 2 volume (α := G))) : ‖conv_mu_lp2 f‖ ≤ ‖f‖ := by + simp [conv_mu_lp2] + simp [f_conv_mu] + simp_rw [← smul_eq_mul] + rw [← Pi.smul_def] + rw [MeasureTheory.eLpNorm_const_smul] +- -- TODO - deduplicate this with 'laplace_bounded' + conv => + lhs + rhs +@@ -53,13 +49,13 @@ lemma norm_conv_mu_le (f: (Lp ℝ 2 volume (α := G))): ‖conv_mu_lp2 f‖ ≤ + funext g + simp + +- have card_s_ne: (#S : ℝ) ≠ 0 := by ++ have card_s_ne : (#S : ℝ) ≠ 0 := by + simp + have foo := hS + simp at foo + exact Finset.nonempty_iff_ne_empty.mp foo + +- grw [MeasureTheory.eLpNorm_sum_le] ++ grw [MeasureTheory.eLpNorm_sum_le (by norm_num)] + simp_rw [← Function.comp_def] + conv => + lhs +@@ -77,16 +73,13 @@ lemma norm_conv_mu_le (f: (Lp ℝ 2 volume (α := G))): ‖conv_mu_lp2 f‖ ≤ + simp [MeasureTheory.volume] + } + )] +- . simp ++ · simp + field_simp + rfl +- . +- apply WithTop.mul_ne_top +- . +- rw [Real.enorm_of_nonneg (by simp)] ++ · apply WithTop.mul_ne_top ++ · rw [Real.enorm_of_nonneg (by simp)] + apply ENNReal.ofReal_ne_top +- . +- apply ENNReal.sum_ne_top.mpr ++ · apply ENNReal.sum_ne_top.mpr + intro s hs + rw [← Function.comp_def] + conv => +@@ -101,19 +94,14 @@ lemma norm_conv_mu_le (f: (Lp ℝ 2 volume (α := G))): ‖conv_mu_lp2 f‖ ≤ + } + )] + rw [← lt_top_iff_ne_top] +- apply (MeasureTheory.Lp.memLp f).2 +- . intro s hs +- apply AEStronglyMeasurable.of_discrete +- . +- simp ++ exact MeasureTheory.Lp.eLpNorm_lt_top f + + open scoped RealInnerProductSpace +-lemma inner_laplace_zero (f: (Lp ℝ 2 volume (α := G))) (hf: ⟪Laplace f, f⟫ = 0): Laplace f = 0 := by ++lemma inner_laplace_zero (f : (Lp ℝ 2 volume (α := G))) (hf : ⟪Laplace f, f⟫ = 0) : Laplace f = 0 := by + have inner_le := real_inner_le_norm (conv_mu_lp2 f) f + +- by_cases norm_f_zero: ‖f‖ = 0 +- . +- simp at norm_f_zero ++ by_cases norm_f_zero : ‖f‖ = 0 ++ · simp at norm_f_zero + simp [Laplace, conv_mu_lp2] + simp [f_conv_mu] + simp_rw [norm_f_zero] +@@ -132,7 +120,7 @@ lemma inner_laplace_zero (f: (Lp ℝ 2 volume (α := G))) (hf: ⟪Laplace f, f + nth_rw 2 [mul_comm] at inner_le + rw [mul_le_mul_iff_of_pos_left] at inner_le + have conv_le_f := norm_conv_mu_le f +- have f_norm_eq: ‖f‖ = ‖conv_mu_lp2 f‖ := by ++ have f_norm_eq : ‖f‖ = ‖conv_mu_lp2 f‖ := by + linarith + + have f_sub_norm := norm_sub_sq_real f (conv_mu_lp2 f) +@@ -147,8 +135,7 @@ lemma inner_laplace_zero (f: (Lp ℝ 2 volume (α := G))) (hf: ⟪Laplace f, f + simpa [Laplace] using f_sub_norm + simpa using norm_f_zero + +- +-lemma F_n_norm_eq_one: ∀ n, MeasureTheory.eLpNorm (F_n n) 2 MeasureTheory.volume (α := G) = 1 := by ++lemma F_n_norm_eq_one : ∀ n, MeasureTheory.eLpNorm (F_n n) 2 MeasureTheory.volume (α := G) = 1 := by + simp [eLpNorm, eLpNorm', lintegral_g_eq_add] + simp [F_n, Real.enorm_eq_ofReal_abs, ← ENNReal.ofReal_pow] + +@@ -160,41 +147,36 @@ lemma F_n_norm_eq_one: ∀ n, MeasureTheory.eLpNorm (F_n n) 2 MeasureTheory.volu + simp [f_n_nonneg, abs_of_nonneg] at norm_one + simp [norm_one] + +- +-lemma harmonic_abs_max_implies_const (f: G → ℝ) (hf: Laplace_b f = 0) (a: G) (h_max: ∀ g: G, |f g| ≤ |f a|): f = fun _ => f a := by +- by_cases f_a_pos: 0 ≤ f a +- . +- have lt_f_a: ∀ g: G, f g ≤ f a := by ++lemma harmonic_abs_max_implies_const (f : G → ℝ) (hf : Laplace_b f = 0) (a : G) (h_max : ∀ g : G, |f g| ≤ |f a|) : f = fun _ => f a := by ++ by_cases f_a_pos : 0 ≤ f a ++ · have lt_f_a : ∀ g : G, f g ≤ f a := by + intro g +- by_cases f_g_pos: 0 ≤ f g +- . specialize h_max g ++ by_cases f_g_pos : 0 ≤ f g ++ · specialize h_max g + rw [abs_eq_self.mpr ?_] at h_max + rw [abs_eq_self.mpr f_a_pos] at h_max +- . exact h_max +- . exact f_g_pos +- . linarith ++ · exact h_max ++ · exact f_g_pos ++ · linarith + exact harmonic_maximum_implies_const f hf a lt_f_a +- . +- have f_neg_le: ∀ g, (-f) g ≤ (-f) a := by ++ · have f_neg_le : ∀ g, (-f) g ≤ (-f) a := by + intro g + simp at f_a_pos + simp + specialize h_max g + rw [abs_of_neg f_a_pos] at h_max +- by_cases f_g_pos: 0 ≤ f g +- . rw [abs_of_nonneg f_g_pos] at h_max ++ by_cases f_g_pos : 0 ≤ f g ++ · rw [abs_of_nonneg f_g_pos] at h_max + linarith +- . simp at f_g_pos ++ · simp at f_g_pos + rw [abs_of_neg f_g_pos] at h_max + linarith + have neg_const := harmonic_maximum_implies_const (-f) ?_ a f_neg_le +- . +- apply_fun (fun h => -h) at neg_const ++ · apply_fun (fun h => -h) at neg_const + simp at neg_const + rw [Pi.neg_def] at neg_const + simpa using neg_const +- . +- simp_rw [Laplace_b] ++ · simp_rw [Laplace_b] + simp_rw [Laplace_b] at hf + conv => + lhs +@@ -210,13 +192,10 @@ lemma harmonic_abs_max_implies_const (f: G → ℝ) (hf: Laplace_b f = 0) (a: G + rw [sub_eq_zero] at hf + exact hf.symm + +- +-set_option maxHeartbeats 500000 in +-lemma laplace_zero_iff_zero (g: (Lp ℝ 2 volume (α := G))) (eq_zero: Laplace g = 0): g = 0 := by +- by_cases g_has_maximum: ∃ a: G, ∀ b: G, ‖g b‖ ≤ ‖g a‖ +- . +- obtain ⟨a, ha⟩ := g_has_maximum +- have laplace_b_zero: Laplace_b g = 0 := by ++lemma laplace_zero_iff_zero (g : (Lp ℝ 2 volume (α := G))) (eq_zero : Laplace g = 0) : g = 0 := by ++ by_cases g_has_maximum : ∃ a : G, ∀ b : G, ‖g b‖ ≤ ‖g a‖ ++ · obtain ⟨a, ha⟩ := g_has_maximum ++ have laplace_b_zero : Laplace_b g = 0 := by + simp [Laplace, conv_mu_lp2, f_conv_mu] at eq_zero + simp_rw [Laplace_b, f_conv_mu] + apply_fun (fun f => f.val.cast) at eq_zero +@@ -245,8 +224,7 @@ lemma laplace_zero_iff_zero (g: (Lp ℝ 2 volume (α := G))) (eq_zero: Laplace g + rw [← not_infinite_iff_finite] at new_g_const_zero + simp [hGS.g_infinite] at new_g_const_zero + +- +- have g_eq_zero: g.val.cast = 0 := by ++ have g_eq_zero : g.val.cast = 0 := by + rw [g_const] + rw [new_g_const_zero] + ext a +@@ -256,16 +234,15 @@ lemma laplace_zero_iff_zero (g: (Lp ℝ 2 volume (α := G))) (eq_zero: Laplace g + rw [ae_eq_everywhere] + rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_zero _ _ _)] + exact g_eq_zero +- . rename _ => g_no_maximum ++ · rename _ => g_no_maximum + simp at g_no_maximum +- have integrable_g := MeasureTheory.MemLp.integrable_sq (MeasureTheory.Lp.memLp g) +- simp [Integrable, HasFiniteIntegral] at integrable_g +- obtain ⟨_, integral_lt⟩ := integrable_g ++ have integral_lt := MeasureTheory.MemLp.integrable_sq (MeasureTheory.Lp.memLp g) ++ simp [Integrable, HasFiniteIntegral] at integral_lt + rw [lintegral_g_eq_add] at integral_lt + rw [lt_top_iff_ne_top] at integral_lt + by_contra g_ne_zero + simp at g_ne_zero +- have nonzero_val: ∃ a: G, g a ≠ 0 := by ++ have nonzero_val : ∃ a : G, g a ≠ 0 := by + rw [MeasureTheory.Lp.ext_iff] at g_ne_zero + rw [ae_eq_everywhere] at g_ne_zero + rw [ae_eq_everywhere.mp (MeasureTheory.Lp.coeFn_zero _ _ _)] at g_ne_zero +@@ -284,26 +261,20 @@ lemma laplace_zero_iff_zero (g: (Lp ℝ 2 volume (α := G))) (eq_zero: Laplace g + -- Obtain an element greater than the maximum + obtain ⟨p, hp⟩ := g_no_maximum m + have p_gt := hm (j := p) ?_ ?_ +- . +- have not_g_le := not_lt_of_ge p_gt ++ · have not_g_le := not_lt_of_ge p_gt + contradiction +- . +- simp ++ · simp + grw [m_in_g] + rw [← ENNReal.toReal_le_toReal] +- . +- simp ++ · simp + rw [sq_le_sq] + linarith +- . simp +- . simp ++ · simp ++ · simp + linarith + +- +--- Proposition 3.17.1: "∆ is bounded" from Vikman +--- The paper also proves that the Laplace operator is self-adjoint as part of this step, +--- but we split it out +-lemma laplace_bounded (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G)))): ‖(Laplace f)‖ₑ ≤ 2 * ‖f‖ₑ := by ++-- Proposition 3.17.1 : "∆ is bounded" from Vikman ++lemma laplace_bounded (f : (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G)))) : ‖(Laplace f)‖ₑ ≤ 2 * ‖f‖ₑ := by + unfold Laplace + unfold conv_mu_lp2 + simp_rw [f_conv_mu] +@@ -326,7 +297,7 @@ lemma laplace_bounded (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G + simp + + rw [MeasureTheory.Lp.enorm_toLp] +- grw [MeasureTheory.eLpNorm_sum_le] ++ grw [MeasureTheory.eLpNorm_sum_le (by norm_num)] + simp_rw [← Function.comp_def] + conv => + lhs +@@ -358,52 +329,38 @@ lemma laplace_bounded (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G + )] + simp + rw [two_mul] +- . rw [← MeasureTheory.Lp.enorm_def] +- -- TODO - inline these in the right places +- . simp +- . +- intro i hs +- apply MeasureTheory.AEStronglyMeasurable.of_discrete +- . norm_num +- . +- apply MeasureTheory.memLp_finsetSum ++ · rw [← MeasureTheory.Lp.enorm_def] ++ · simp ++ · apply MeasureTheory.memLp_finsetSum + intro s hs + rw [← Function.comp_def] + apply MeasureTheory.MemLp.comp_of_map +- . +- simp [MeasureTheory.volume] ++ · simp [MeasureTheory.volume] + apply MeasureTheory.Lp.memLp f +- . apply AEMeasurable.of_discrete +- ++ · apply AEMeasurable.of_discrete + +-lemma laplace_bounded' (f: (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G)))): ‖(Laplace f)‖ ≤ 2 * ‖f‖ := by ++lemma laplace_bounded' (f : (MeasureTheory.Lp ℝ 2 (MeasureTheory.volume (α := G)))) : ‖(Laplace f)‖ ≤ 2 * ‖f‖ := by + have bounded := laplace_bounded f +- rw [← ofReal_norm_eq_enorm] at bounded +- rw [← ofReal_norm_eq_enorm] at bounded ++ rw [← ofReal_norm] at bounded ++ rw [← ofReal_norm] at bounded + simp_rw [← ENNReal.ofReal_ofNat] at bounded + rw [← ENNReal.ofReal_mul] at bounded +- . +- rw [ENNReal.ofReal_le_ofReal_iff] at bounded +- . exact bounded +- . simp +- . simp ++ · rw [ENNReal.ofReal_le_ofReal_iff] at bounded ++ · exact bounded ++ · simp ++ · simp + +-lemma tolp_apply (f: G → ℝ) {p: ENNReal} (hf: MeasureTheory.MemLp f p) (g: G): (MeasureTheory.MemLp.toLp f hf) g = f g := by ++lemma tolp_apply (f : G → ℝ) {p : ENNReal} (hf : MeasureTheory.MemLp f p) (g : G) : (MeasureTheory.MemLp.toLp f hf) g = f g := by + have eq_fun := MeasureTheory.AEEqFun.coeFn_mk f (μ := MeasureTheory.volume (α := G)) (by apply MeasureTheory.AEStronglyMeasurable.of_discrete) + rw [ae_eq_everywhere] at eq_fun + nth_rw 2 [← eq_fun] + rfl + +- + open scoped RealInnerProductSpace +-lemma laplace_self_adjoint (f h: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G)))): ⟪f, (Laplace h)⟫ = ⟪(Laplace f), h⟫ := by ++lemma laplace_self_adjoint (f h : (MeasureTheory.Lp ℝ 2 (μ := volume (α := G)))) : ⟪f, (Laplace h)⟫ = ⟪(Laplace f), h⟫ := by + + simp [MeasureTheory.L2.inner_def] + +- +- +- -- MeasureTheory.Lp.coeFn_smul +- + conv => + lhs + arg 2 +@@ -434,7 +391,6 @@ lemma laplace_self_adjoint (f h: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G) + simp_rw [mul_assoc] + simp_rw [Finset.mul_sum] + +- + conv => + lhs + arg 2 +@@ -445,10 +401,9 @@ lemma laplace_self_adjoint (f h: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G) + arg 1 + intro i + +- + simp_rw [tolp_apply] + rw [integral_sub] +- rw [MeasureTheory.integral_finset_sum] ++ rw [MeasureTheory.integral_finsetSum] + conv => + lhs + rhs +@@ -456,7 +411,7 @@ lemma laplace_self_adjoint (f h: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G) + intro s + rw [← MeasureTheory.integral_mul_left_eq_self (g := s⁻¹)] + simp +- rw [← MeasureTheory.integral_finset_sum] ++ rw [← MeasureTheory.integral_finsetSum] + conv => + lhs + rhs +@@ -465,13 +420,13 @@ lemma laplace_self_adjoint (f h: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G) + rw [← Finset.mul_sum] + rw [Finset.sum_bijective (s := S) (t := S) (e := fun s => s⁻¹) (g := fun i => (f (i * g) * (h g))) (by + refine ⟨?_, ?_⟩ +- . exact inv_injective +- . exact inv_surjective ++ · exact inv_injective ++ · exact inv_surjective + ) (by + intro a + refine ⟨?_, ?_⟩ +- . apply hGS.has_inv a +- . simpa using (hGS.has_inv a⁻¹) ++ · apply hGS.has_inv a ++ · simpa using (hGS.has_inv a⁻¹) + ) (by + simp + )] +@@ -488,7 +443,6 @@ lemma laplace_self_adjoint (f h: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G) + rw [mul_comm] + rw [← mul_sub] + +- + conv => + rhs + arg 2 +@@ -499,67 +453,59 @@ lemma laplace_self_adjoint (f h: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G) + simp [f_conv_mu] + rw [tolp_apply] + +- + simp_rw [Finset.mul_sum] +- . +- have prod_lp1 := MeasureTheory.MemLp.smul (φ := f) (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp h) (MeasureTheory.Lp.memLp f) ++ · have prod_lp1 := MeasureTheory.MemLp.smul (φ := f) (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp f) (MeasureTheory.Lp.memLp h) + rw [MeasureTheory.memLp_one_iff_integrable] at prod_lp1 +- exact prod_lp1 +- . +- apply MeasureTheory.integrable_finset_sum ++ simpa only [Pi.smul_apply, smul_eq_mul, Pi.mul_def, Function.comp_apply] using prod_lp1 ++ · apply MeasureTheory.integrable_finsetSum + intro s hs + apply MeasureTheory.Integrable.const_mul +- have mem_lp_f_comp: MemLp (f ∘ (fun x => s * x)) 2 := by ++ have mem_lp_f_comp : MemLp (f ∘ (fun x => s * x)) 2 := by + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp f +- . exact measurePreserving_mul_left volume s ++ · apply MeasureTheory.Lp.memLp f ++ · exact measurePreserving_mul_left volume s + +- have prod_lp1 := MeasureTheory.MemLp.smul (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp h) mem_lp_f_comp ++ have prod_lp1 := MeasureTheory.MemLp.smul (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) mem_lp_f_comp (MeasureTheory.Lp.memLp h) + rw [MeasureTheory.memLp_one_iff_integrable] at prod_lp1 +- exact prod_lp1 +- . +- intro s hs ++ simpa only [Pi.smul_apply, smul_eq_mul, Pi.mul_def, Function.comp_apply] using prod_lp1 ++ · intro s hs + apply MeasureTheory.Integrable.const_mul +- have mem_lp_f_comp: MemLp (f ∘ (fun x => s⁻¹ * x)) 2 := by ++ have mem_lp_f_comp : MemLp (f ∘ (fun x => s⁻¹ * x)) 2 := by + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp f +- . exact measurePreserving_mul_left volume s⁻¹ +- have prod_lp1 := MeasureTheory.MemLp.smul (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp h) mem_lp_f_comp ++ · apply MeasureTheory.Lp.memLp f ++ · exact measurePreserving_mul_left volume s⁻¹ ++ have prod_lp1 := MeasureTheory.MemLp.smul (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) mem_lp_f_comp (MeasureTheory.Lp.memLp h) + rw [MeasureTheory.memLp_one_iff_integrable] at prod_lp1 +- exact prod_lp1 +- . +- intro s hs ++ simpa only [Pi.smul_apply, smul_eq_mul, Pi.mul_def, Function.comp_apply] using prod_lp1 ++ · intro s hs + apply MeasureTheory.Integrable.const_mul + +- have mem_lp_h_comp: MemLp (h ∘ (fun x => s * x)) 2 := by ++ have mem_lp_h_comp : MemLp (h ∘ (fun x => s * x)) 2 := by + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp h +- . exact measurePreserving_mul_left volume s ++ · apply MeasureTheory.Lp.memLp h ++ · exact measurePreserving_mul_left volume s + +- have prod_lp1 := MeasureTheory.MemLp.smul (p := 2) (q := 2) (r := 1) (μ := volume) mem_lp_h_comp (MeasureTheory.Lp.memLp f) ++ have prod_lp1 := MeasureTheory.MemLp.smul (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp f) mem_lp_h_comp + rw [MeasureTheory.memLp_one_iff_integrable] at prod_lp1 +- exact prod_lp1 +- . +- have prod_lp1 := MeasureTheory.MemLp.smul (φ := f) (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp h) (MeasureTheory.Lp.memLp f) ++ simpa only [Pi.smul_apply, smul_eq_mul, Pi.mul_def, Function.comp_apply] using prod_lp1 ++ · have prod_lp1 := MeasureTheory.MemLp.smul (φ := f) (f := h) (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp f) (MeasureTheory.Lp.memLp h) + rw [MeasureTheory.memLp_one_iff_integrable] at prod_lp1 +- exact prod_lp1 +- . +- apply MeasureTheory.integrable_finset_sum ++ simpa only [Pi.smul_apply, smul_eq_mul, Pi.mul_def, Function.comp_apply] using prod_lp1 ++ · apply MeasureTheory.integrable_finsetSum + intro s hs + apply MeasureTheory.Integrable.const_mul + +- have mem_lp_h_comp: MemLp (h ∘ (fun x => s * x)) 2 := by ++ have mem_lp_h_comp : MemLp (h ∘ (fun x => s * x)) 2 := by + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp h +- . exact measurePreserving_mul_left volume s ++ · apply MeasureTheory.Lp.memLp h ++ · exact measurePreserving_mul_left volume s + +- have prod_lp1 := MeasureTheory.MemLp.smul (p := 2) (q := 2) (r := 1) (μ := volume) mem_lp_h_comp (MeasureTheory.Lp.memLp f) ++ have prod_lp1 := MeasureTheory.MemLp.smul (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp f) mem_lp_h_comp + rw [MeasureTheory.memLp_one_iff_integrable] at prod_lp1 +- exact prod_lp1 +- ++ simpa only [Pi.smul_apply, smul_eq_mul, Pi.mul_def, Function.comp_apply] using prod_lp1 + + set_option maxHeartbeats 200000 in +-lemma laplace_positive_semidefinite (f: (MeasureTheory.Lp ℝ 2 (μ := volume (α := G)))): 0 ≤ ⟪f, (Laplace f)⟫ := by ++lemma laplace_positive_semidefinite (f : (MeasureTheory.Lp ℝ 2 (μ := volume (α := G)))) : 0 ≤ ⟪f, (Laplace f)⟫ := by + unfold Laplace + rw [inner_sub_right] + rw [real_inner_self_eq_norm_sq] +@@ -571,23 +517,22 @@ lemma laplace_positive_semidefinite (f: (MeasureTheory.Lp ℝ 2 (μ := volume ( + simp_rw [inner_smul_right] + simp_rw [inner_sum] + rw [integral_const_mul] +- rw [MeasureTheory.integral_finset_sum] ++ rw [MeasureTheory.integral_finsetSum] + +- -- I couldn't figure how to to handle 'toLp (∑ x ∈ S), so I ended up manipulating the integral to avoid dealing with it +- have comp_smul_left (i: G) := MeasureTheory.Lp.coeFn_compMeasurePreserving (g := f) (f := fun a => i * a) (μ := volume) (by ++ -- Finite-sum integral identities express the quadratic form on L². ++ have comp_smul_left (i : G) := MeasureTheory.Lp.coeFn_compMeasurePreserving (g := f) (f := fun a => i * a) (μ := volume) (by + exact measurePreserving_mul_left volume i + ) + simp_rw [ae_eq_everywhere] at comp_smul_left +- have congr_comp (i: G) (x: G) := congrFun (comp_smul_left i) x ++ have congr_comp (i : G) (x : G) := congrFun (comp_smul_left i) x + simp only [Function.comp_apply] at congr_comp + simp_rw [smul_eq_mul] + simp_rw [← congr_comp] + simp_rw [← MeasureTheory.L2.inner_def] + +- let f_eq_coe: f = f := by rfl ++ let f_eq_coe : f = f := by rfl + nth_rw 1 [← MeasureTheory.Lp.toLp_coeFn (f := f) (hf := Lp.memLp f)] at f_eq_coe + +- + conv => + rhs + rhs +@@ -598,19 +543,15 @@ lemma laplace_positive_semidefinite (f: (MeasureTheory.Lp ℝ 2 (μ := volume ( + rw [MeasureTheory.Lp.toLp_compMeasurePreserving] + simp + ++ -- Translation invariance identifies the summands as L² inner products. + +- -- We've now packed everything back up in an inner product - +- -- we no longer need to deal with commuting toLp and Finset.sum +- +- +- let conv_f_delta_lp (i: G) := MemLp.toLp (Conv (f) (delta i⁻¹)) (μ := volume) (p := 2) (by ++ let conv_f_delta_lp (i : G) := MemLp.toLp (Conv (f) (delta i⁻¹)) (μ := volume) (p := 2) (by + simp_rw [f_conv_delta_helper] + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp f +- . exact measurePreserving_mul_left volume _ ++ · apply MeasureTheory.Lp.memLp f ++ · exact measurePreserving_mul_left volume _ + ) + +- + have sum_le := Finset.sum_le_sum (g := fun i => ‖f‖ * ‖conv_f_delta_lp i‖) (f := fun i => ⟪f, conv_f_delta_lp i⟫) (s := S) (by + intro s hs + have foo := norm_inner_le_norm (x := f) (y := conv_f_delta_lp s) (𝕜 := ℝ) +@@ -635,7 +576,6 @@ lemma laplace_positive_semidefinite (f: (MeasureTheory.Lp ℝ 2 (μ := volume ( + rw [f_conv_delta] + simp + +- + calc + _ ≥ ‖f‖ ^ 2 - 1 / ↑(#S) * ∑ i ∈ S, ‖f‖ * ‖conv_f_delta_lp i‖ := by + +@@ -656,11 +596,11 @@ lemma laplace_positive_semidefinite (f: (MeasureTheory.Lp ℝ 2 (μ := volume ( + simp + rw [← Function.comp_def] + rw [MeasureTheory.eLpNorm_comp_measurePreserving (ν := volume)] +- . simp [norm] +- . apply MeasureTheory.AEStronglyMeasurable.of_discrete +- . exact measurePreserving_mul_left volume x ++ · simp [norm] ++ · apply MeasureTheory.AEStronglyMeasurable.of_discrete ++ · exact measurePreserving_mul_left volume x + simp +- have s_card_ne_zero: (#S : ℝ) ≠ 0 := by ++ have s_card_ne_zero : (#S : ℝ) ≠ 0 := by + simp + have foo := hS + simp at foo +@@ -669,41 +609,36 @@ lemma laplace_positive_semidefinite (f: (MeasureTheory.Lp ℝ 2 (μ := volume ( + rw [← mul_assoc] + simp [s_card_ne_zero] + rw [pow_two] +- . +- intro s hs ++ · intro s hs + simp + +- have mem_lp_h_comp: MemLp (f ∘ (fun x => s * x)) 2 := by ++ have mem_lp_h_comp : MemLp (f ∘ (fun x => s * x)) 2 := by + apply MeasureTheory.MemLp.comp_measurePreserving (ν := volume) +- . apply MeasureTheory.Lp.memLp f +- . exact measurePreserving_mul_left volume s ++ · apply MeasureTheory.Lp.memLp f ++ · exact measurePreserving_mul_left volume s + +- have prod_lp1 := MeasureTheory.MemLp.smul (p := 2) (q := 2) (r := 1) (μ := volume) (MeasureTheory.Lp.memLp f) mem_lp_h_comp ++ have prod_lp1 := MeasureTheory.MemLp.smul (p := 2) (q := 2) (r := 1) (μ := volume) mem_lp_h_comp (MeasureTheory.Lp.memLp f) + rw [MeasureTheory.memLp_one_iff_integrable] at prod_lp1 +- exact prod_lp1 +- ++ simpa only [Pi.smul_apply, smul_eq_mul, Pi.mul_def, Function.comp_apply] using prod_lp1 + + @[expose] + noncomputable def Δ := Laplace_linear.mkContinuous _ (laplace_bounded') + +-lemma Δ_symmetric: Δ.IsSymmetric := by ++lemma Δ_symmetric : Δ.IsSymmetric := by + unfold LinearMap.IsSymmetric + intro x hx + unfold Δ +- -- TODO - why doesn't this fire automatically? + simp [LinearMap.mkContinuous] + simp [Laplace_linear] + rw [laplace_self_adjoint] + +-lemma Δ_spectrum_subset: spectrum ℝ Δ ⊆ Set.Icc 0 2 := by ++lemma Δ_spectrum_subset : spectrum ℝ Δ ⊆ Set.Icc 0 2 := by + intro a ha + have restricts := ContinuousLinearMap.IsPositive.spectrumRestricts (f := Δ) (by + rw [ContinuousLinearMap.isPositive_def] + refine ⟨?_, ?_⟩ +- . +- apply Δ_symmetric +- . +- intro x ++ · apply Δ_symmetric ++ · intro x + simp [ContinuousLinearMap.reApplyInnerSelf_apply] + unfold Δ + simp [LinearMap.mkContinuous] +@@ -712,44 +647,39 @@ lemma Δ_spectrum_subset: spectrum ℝ Δ ⊆ Set.Icc 0 2 := by + apply laplace_positive_semidefinite + ) + simp +- have a_nonneg: 0 ≤ a := by +- have zero_eq: (0: ℝ) = (0: NNReal) := by ++ have a_nonneg : 0 ≤ a := by ++ have zero_eq : (0 : ℝ) = (0 : NNReal) := by + simp + rw [zero_eq] + apply (SpectrumRestricts.nnreal_le_iff restricts).mp +- . simp +- . exact ha +- ++ · simp ++ · exact ha + + refine ⟨?_, ?_⟩ +- . +- exact a_nonneg +- . +- have norm_le: ‖a‖ ≤ ‖(2: ℝ)‖ := by ++ · exact a_nonneg ++ · have norm_le : ‖a‖ ≤ ‖(2 : ℝ)‖ := by + have foo := spectrum.norm_le_norm_mul_of_mem ha + + simp at foo + simp [Δ] at foo + grw [← (ContinuousLinearMap.opNorm_le_iff (M := ‖2‖) (f := Δ) ?_).mpr] +- . +- have h := spectrum.norm_le_norm_mul_of_mem ha ++ · have h := spectrum.norm_le_norm_mul_of_mem ha + rw [ContinuousLinearMap.one_def] at h + grw [ContinuousLinearMap.norm_id_le] at h + simpa using h +- . intro x ++ · intro x + simp [Δ, LinearMap.mkContinuous, Laplace_linear] + have bound := laplace_bounded x + simp [enorm] at bound + norm_cast at bound +- . simp ++ · simp + + simp at norm_le + rw [abs_of_nonneg] at norm_le +- . exact norm_le +- . exact a_nonneg ++ · exact norm_le ++ · exact a_nonneg + +- +-lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ spectrum ℝ Δ := by ++lemma laplace_spectrum_contains_zero (f_n_limit : f_n_conv_delta_tendsto) : 0 ∈ spectrum ℝ Δ := by + rw [spectrum.zero_mem_iff] + by_contra this + obtain ⟨f, hf⟩ := this +@@ -761,8 +691,8 @@ lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ + use 0 + use MemLp.toLp (Pi.single 1 1) (by + apply Continuous.memLp_of_hasCompactSupport +- . apply continuous_of_discreteTopology +- . simp [HasCompactSupport, tsupport] ++ · apply continuous_of_discreteTopology ++ · simp [HasCompactSupport, tsupport] + ) + simp + rw [MeasureTheory.Lp.ext_iff] +@@ -779,7 +709,7 @@ lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ + + have norm_mul_bound := ContinuousLinearEquiv.one_le_norm_mul_norm_symm (ContinuousLinearEquiv.ofUnit f) + +- have inv_norm_ge (n: ℕ) : (1 : ENNReal) / (eLpNorm (Laplace_b (F_n n)) 2 (μ := volume (α := G))) ≤ ENNReal.ofReal ‖f.inv‖ := by ++ have inv_norm_ge (n : ℕ) : (1 : ENNReal) / (eLpNorm (Laplace_b (F_n n)) 2 (μ := volume (α := G))) ≤ ENNReal.ofReal ‖f.inv‖ := by + + calc + _ = (eLpNorm (F_n n) 2 (μ := volume (α := G))) / ((eLpNorm (Laplace_b (F_n n)) 2 (μ := volume (α := G)))) := by +@@ -795,7 +725,6 @@ lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ + lhs + rw [Lp.norm_def] + +- + conv => + lhs + arg 1 +@@ -804,21 +733,20 @@ lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ + rhs + rhs + simp [hf, Δ, Laplace, Laplace_linear] +- simp [-AddSubgroupClass.coe_sub, -AddSubgroup.coe_sub, Laplace] ++ simp [-AddSubgroupClass.coe_sub, -AddSubgroup.coe_sub] + apply_fun ENNReal.ofReal at other +- -- TODO - consider removing @[simp] from 'AddSubgroupClass.coe_sub' + simp only [map_sub, ofReal_norm] at other + simp only [← Units.inv_eq_val_inv] +- simp only [F_n_lp2, Laplace_b, ← hf, conv_mu_lp2] ++ simp only [F_n_lp2, Laplace_b, conv_mu_lp2] + --simp_rw [ae_eq_everywhere.mp (MemLp.coeFn_toLp _)] +- by_cases norm_f_eq_zero: ‖F_n_lp2 n - conv_mu_lp2 (F_n_lp2 n)‖ = 0 +- . rw [norm_eq_zero] at norm_f_eq_zero ++ by_cases norm_f_eq_zero : ‖F_n_lp2 n - conv_mu_lp2 (F_n_lp2 n)‖ = 0 ++ · rw [norm_eq_zero] at norm_f_eq_zero + have foo := laplace_zero_iff_zero (F_n_lp2 n) (by + simp [Laplace] + exact norm_f_eq_zero + ) + simp [F_n_lp2] at foo +- apply_fun (fun f => (f: (G → ℝ))) at foo ++ apply_fun (fun f => (f : (G → ℝ))) at foo + simp_rw [ae_eq_everywhere.mp (MemLp.coeFn_toLp _)] at foo + conv at foo => + rhs +@@ -827,7 +755,7 @@ lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ + simp [foo] + unfold Conv + simp +- have const_zero: (fun (x: G) => (0 : ℝ)) = 0 := by rfl ++ have const_zero : (fun (x : G) => (0 : ℝ)) = 0 := by rfl + conv => + pattern MemLp.toLp _ _ + equals 0 => +@@ -839,32 +767,28 @@ lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ + simp_rw [ae_eq_everywhere.mp (MeasureTheory.AEEqFun.coeFn_zero)] + simp + rw [ENNReal.ofReal_div_of_pos] at other +- . +- simp only [ofReal_norm, Lp.enorm_def] at other ++ · simp only [ofReal_norm, Lp.enorm_def] at other + rw [ae_eq_everywhere.mp (Lp.coeFn_sub _ _)] at other + simp only [F_n_lp2, conv_mu_lp2] at other + simp_rw [ae_eq_everywhere.mp (MemLp.coeFn_toLp _)] at other + rw [ENNReal.ofReal_toReal] at other +- . +- rw [ae_eq_everywhere.mp (Lp.coeFn_sub _ _)] ++ · rw [ae_eq_everywhere.mp (Lp.coeFn_sub _ _)] + rw [ae_eq_everywhere.mp (Lp.coeFn_sub _ _)] at other + simp_rw [ae_eq_everywhere.mp (MemLp.coeFn_toLp _)] at other + simp at other + simp + simp_rw [ae_eq_everywhere.mp (MemLp.coeFn_toLp _)] + exact other +- . +- rw [← ae_eq_everywhere.mp (Lp.coeFn_sub _ _)] ++ · rw [← ae_eq_everywhere.mp (Lp.coeFn_sub _ _)] + apply MeasureTheory.Lp.eLpNorm_ne_top +- . simpa using norm_f_eq_zero +- . exact ENNReal.ofReal_mono +- . +- rw [isBoundedLinearMap_iff] at inv_bounded ++ · simpa using norm_f_eq_zero ++ · exact ENNReal.ofReal_mono ++ · rw [isBoundedLinearMap_iff] at inv_bounded + obtain ⟨M, M_pos, le_M⟩ := inv_bounded.2 + + have foo := F_n_conv_mu_lim f_n_limit + rw [ENNReal.tendsto_atTop_zero] at foo +- obtain ⟨n, hn⟩ := foo ((1: ENNReal) /(2 * ‖f.inv‖ₑ)) (by ++ obtain ⟨n, hn⟩ := foo ((1 : ENNReal) /(2 * ‖f.inv‖ₑ)) (by + simp + rw [ENNReal.mul_eq_top] + simp +@@ -880,7 +804,7 @@ lemma laplace_spectrum_contains_zero (f_n_limit: f_n_conv_delta_tendsto): 0 ∈ + grw [hn] at inv_norm_ge + simp at inv_norm_ge + +- have norm_nonzero :‖f.inv‖ ≠ 0 := by ++ have norm_nonzero : ‖f.inv‖ ≠ 0 := by + by_contra! + simp at this + +diff --git a/Gromov/HarmonicR2.lean b/Gromov/HarmonicR2.lean +index 44f0aa9..752d6fd 100644 +--- a/Gromov/HarmonicR2.lean ++++ b/Gromov/HarmonicR2.lean +@@ -12,11 +12,6 @@ a ball of radius `2R`. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -27,7 +22,200 @@ open Generates + variable [hGS: Generates] + include hGS + +-set_option maxHeartbeats 9000000 in ++private noncomputable def harmonicCutoff (r : ℕ) (x : G) : ℝ := ++ if WordNorm x ≤ 2 * r + 1 then 1 ++ else if WordNorm x ≤ 4 * r then -(WordNorm x : ℝ) / (2 * (r : ℝ)) + 2 else 0 ++ ++private lemma harmonic_cutoff_step (f : G → ℝ) (r : ℕ) (hr : r ≠ 0) ++ (x : G) (hx : x ∈ Metric.closedBall 1 (4 * r)) (s : G) (hs : s ∈ S) : ++ (f x)^2 * (harmonicCutoff r (s * x) - harmonicCutoff r x)^2 ≤ ++ (1 : ℝ) / r^2 * (f x)^2 := by ++ simp [harmonicCutoff] ++ have norm_s_x := word_dist_mul_eq (x := 1) (y := s) (z := x) hs ++ simp_rw [WordDist_comm] at norm_s_x ++ simp_rw [WordDist_one] at norm_s_x ++ rw [← or_assoc] at norm_s_x ++ cases norm_s_x ++ . ++ rename_i norm_s_x_eq ++ cases norm_s_x_eq ++ . ++ rename_i s_lt ++ simp [dist] at hx ++ norm_cast at hx ++ rw [WordDist_one] at hx ++ by_cases s_x_le: WordNorm (s * x) ≤ 2 *r + 1 ++ . ++ simp [s_x_le] ++ simp [s_lt] ++ split_ifs ++ . simp ++ positivity ++ . ++ have s_x_eq: WordNorm (s * x) = 2 *r + 1 := by grind ++ simp [s_x_eq] ++ field_simp ++ apply mul_le_mul ++ . simp ++ . ++ norm_num ++ ring_nf ++ norm_num ++ . positivity ++ . positivity ++ . ++ grind ++ . ++ have sub_eq: (WordNorm x) - 1 = WordNorm (s * x) := by omega ++ have s_x_le_four: WordNorm (s * x) ≤ 4 * r := by ++ simp [s_lt] at hx ++ grind ++ simp [s_x_le, s_x_le_four] ++ split_ifs ++ . ++ grind ++ . ++ simp [← sub_eq] ++ rw [← sub_div] ++ simp ++ field_simp ++ conv => ++ lhs ++ rhs ++ lhs ++ equals 1 => ++ rw [sub_eq] ++ rw [s_lt] ++ push_cast ++ ring ++ simp ++ norm_num ++ -- TODO - surely this can be simplified ++ by_cases f_x_zero: (f x) ^2 = 0 ++ . simp [f_x_zero] ++ ++ rw [le_mul_iff_one_le_right] ++ . norm_num ++ . positivity ++ . ++ rename_i s_lt ++ simp [dist] at hx ++ norm_cast at hx ++ rw [WordDist_one] at hx ++ by_cases s_x_le: WordNorm (s * x) ≤ 2*r + 1 ++ . ++ simp [s_x_le] ++ split_ifs ++ . simp ++ positivity ++ . ++ have s_x_eq: WordNorm (s * x) = 2 *r := by grind ++ simp ++ rw [mul_comm] ++ apply mul_le_mul ++ . ++ ring_nf ++ norm_num ++ field_simp ++ rw [mul_sub] ++ rw [← pow_two] ++ rw [sub_mul] ++ conv => ++ lhs ++ equals (2 * r) * (2 * r) - (WordNorm x) * 2 * r * 2 + (WordNorm x)^2 => ++ ring ++ rename_i x_gt ++ simp at x_gt ++ omega ++ . simp ++ . positivity ++ . norm_num ++ . ++ by_cases norm_x_eq: WordNorm x = 4 * r ++ . ++ have not_le: ¬(WordNorm (s * x) ≤ (2 *r) + 1) := by grind ++ have not_le_four: ¬(WordNorm (s * x) ≤ (4 *r)) := by grind ++ have x_le: (WordNorm (x) ≤ (4 *r)) := by grind ++ have not_x_le: ¬(WordNorm (x) ≤ (2 *r) + 1) := by grind ++ simp [not_le, not_le_four, x_le, not_x_le] ++ rw [mul_comm] ++ -- TODO - surely this can be simplified ++ by_cases f_x_zero: (f x) ^2 = 0 ++ . simp [f_x_zero] ++ rw [mul_le_mul_iff_left₀] ++ . ++ field_simp ++ grw [x_le] ++ grind ++ simp ++ norm_num ++ simp [norm_x_eq] ++ . positivity ++ ++ have sub_eq: (WordNorm x) = WordNorm (s * x) - 1 := by omega ++ have s_x_le_four: WordNorm (s * x) ≤ 4 * r := by ++ rw [← s_lt] ++ grind ++ simp [s_x_le, s_x_le_four] ++ split_ifs ++ . ++ field_simp ++ -- TODO - surely this can be simplified ++ by_cases f_x_zero: (f x) ^2 = 0 ++ . simp [f_x_zero] ++ ++ rw [mul_le_mul_iff_right₀] ++ . ++ norm_num ++ field_simp ++ conv => ++ lhs ++ lhs ++ ring_nf ++ conv => ++ rhs ++ equals (2^2) => ++ norm_num ++ ++ have norm_x_eq: WordNorm x = 2 *r + 1 := by grind ++ rw [← s_lt, norm_x_eq] ++ conv => ++ lhs ++ lhs ++ simp ++ field_simp ++ ring_nf ++ norm_num ++ ++ . positivity ++ . ++ simp ++ rw [← sub_div] ++ simp ++ field_simp ++ conv => ++ lhs ++ rhs ++ lhs ++ equals -1 => ++ rw [sub_eq] ++ rw [Nat.cast_sub (by grind)] ++ ring ++ simp ++ norm_num ++ -- TODO - surely this can be simplified ++ by_cases f_x_zero: (f x) ^2 = 0 ++ . simp [f_x_zero] ++ ++ rw [le_mul_iff_one_le_right] ++ . norm_num ++ . positivity ++ ++ . ++ rename_i norm_eq ++ simp [← norm_eq] ++ positivity ++ + lemma harmonic_r2_inequality (f : G → ℝ) (hf : Laplace_b f = 0) (r: ℕ) (hr: r ≠ 0): + ∑ x ∈ Metric.closedBall 1 (2 * r), deriv_sq f x ≤ ((1: ℝ) / r^2) * #(S) * ∑ x ∈ Metric.closedBall 1 (4 * r), f x ^ 2 := by + -- `deriv_sq f x = ∑ s, (f (s*x) - f x)^2`; the proof below is written with the +@@ -43,30 +231,24 @@ lemma harmonic_r2_inequality (f : G → ℝ) (hf : Laplace_b f = 0) (r: ℕ) (hr + -- m * (2 *r) - * (4 * r * m) = 1 + -- 2rm - 4rm = 1 + -- m = -1/2 +- let φ := fun (x: G) => if WordNorm x ≤ (2 * r) + 1 then 1 else if (WordNorm x ≤ 4 * r) then (-(WordNorm x)/(2 * (r: ℝ))) + 2 else 0 ++ let φ := harmonicCutoff r + have phi_support : φ.support ⊆ Metric.ball 1 (4 * r) := by + intro s hs +- simp at hs +- rw [ite_eq_iff] at hs +- simp at hs +- by_cases s_gt: 2 * r + 1 < (WordNorm s) +- . +- specialize hs s_gt +- simp [dist] +- rw [WordDist_one] +- by_cases eq_four: WordNorm s = 4*r +- . +- simp [eq_four] at hs +- field_simp [hr] at hs +- norm_num at hs +- . +- norm_cast +- grind +- . +- simp at s_gt +- simp [dist, WordDist_one] +- norm_cast +- grind ++ have hsne : harmonicCutoff r s ≠ 0 := hs ++ have hslt : WordNorm s < 4 * r := by ++ by_contra h ++ have hge : 4 * r ≤ WordNorm s := by omega ++ have hshort : ¬ WordNorm s ≤ 2 * r + 1 := by omega ++ by_cases heq : WordNorm s = 4 * r ++ · apply hsne ++ rw [harmonicCutoff, ite_eq_right hshort, ite_eq_left heq.le, heq] ++ push_cast ++ field_simp [hr] ++ ring ++ · have hlong : ¬ WordNorm s ≤ 4 * r := by omega ++ exact hsne (by simp [harmonicCutoff, hshort, hlong]) ++ simp only [Metric.mem_ball, dist, WordDist_one] ++ exact_mod_cast hslt + + have foo := cutoff_inequality f φ hf ?_ + . +@@ -91,201 +273,13 @@ lemma harmonic_r2_inequality (f : G → ℝ) (hf : Laplace_b f = 0) (r: ℕ) (hr + rw [Finset.mul_sum] + apply Finset.sum_le_sum + intro s hs +- simp [φ] +- have norm_s_x := word_dist_mul_eq (x := 1) (y := s) (z := x) hs +- simp_rw [WordDist_comm] at norm_s_x +- simp_rw [WordDist_one] at norm_s_x +- rw [← or_assoc] at norm_s_x +- cases norm_s_x +- . +- rename_i norm_s_x_eq +- cases norm_s_x_eq +- . +- rename_i s_lt +- simp [dist] at hx +- norm_cast at hx +- rw [WordDist_one] at hx +- by_cases s_x_le: WordNorm (s * x) ≤ 2 *r + 1 +- . +- simp [s_x_le] +- simp [s_lt] +- split_ifs +- . simp +- positivity +- . +- have s_x_eq: WordNorm (s * x) = 2 *r + 1 := by grind +- simp [s_x_eq] +- field_simp +- apply mul_le_mul +- . simp +- . +- norm_num +- ring +- norm_num +- . positivity +- . positivity +- . +- grind +- . +- have sub_eq: (WordNorm x) - 1 = WordNorm (s * x) := by omega +- have s_x_le_four: WordNorm (s * x) ≤ 4 * r := by +- simp [s_lt] at hx +- grind +- simp [s_x_le, s_x_le_four] +- split_ifs +- . +- grind +- . +- simp [← sub_eq] +- rw [← sub_div] +- simp +- field_simp +- push_cast +- conv => +- lhs +- rhs +- lhs +- equals 1 => +- rw [sub_eq] +- rw [s_lt] +- push_cast +- ring +- simp +- norm_num +- -- TODO - surely this can be simplified +- by_cases f_x_zero: (f x) ^2 = 0 +- . simp [f_x_zero] +- +- rw [le_mul_iff_one_le_right] +- . norm_num +- . positivity +- . +- rename_i s_lt +- simp [dist] at hx +- norm_cast at hx +- rw [WordDist_one] at hx +- by_cases s_x_le: WordNorm (s * x) ≤ 2*r + 1 +- . +- simp [s_x_le] +- split_ifs +- . simp +- positivity +- . +- have s_x_eq: WordNorm (s * x) = 2 *r := by grind +- simp [s_x_eq] +- rw [mul_comm] +- apply mul_le_mul +- . +- norm_num +- ring +- norm_num +- field_simp +- rw [mul_sub] +- rw [← pow_two] +- rw [sub_mul] +- conv => +- lhs +- equals (2 * r) * (2 * r) - (WordNorm x) * 2 * r * 2 + (WordNorm x)^2 => +- ring +- rename_i x_gt +- simp at x_gt +- omega +- . simp +- . positivity +- . norm_num +- . +- by_cases norm_x_eq: WordNorm x = 4 * r +- . +- have not_le: ¬(WordNorm (s * x) ≤ (2 *r) + 1) := by grind +- have not_le_four: ¬(WordNorm (s * x) ≤ (4 *r)) := by grind +- have x_le: (WordNorm (x) ≤ (4 *r)) := by grind +- have not_x_le: ¬(WordNorm (x) ≤ (2 *r) + 1) := by grind +- simp [not_le, not_le_four, x_le, not_x_le] +- rw [mul_comm] +- -- TODO - surely this can be simplified +- by_cases f_x_zero: (f x) ^2 = 0 +- . simp [f_x_zero] +- rw [mul_le_mul_iff_left₀] +- . +- field_simp +- grw [x_le] +- grind +- simp +- norm_num +- simp [norm_x_eq] +- . positivity +- +- have sub_eq: (WordNorm x) = WordNorm (s * x) - 1 := by omega +- have s_x_le_four: WordNorm (s * x) ≤ 4 * r := by +- rw [← s_lt] +- grind +- simp [s_x_le, s_x_le_four] +- split_ifs +- . +- field_simp +- -- TODO - surely this can be simplified +- by_cases f_x_zero: (f x) ^2 = 0 +- . simp [f_x_zero] +- +- rw [mul_le_mul_iff_right₀] +- . +- norm_num +- field_simp +- conv => +- lhs +- lhs +- ring +- conv => +- rhs +- equals (2^2) => +- norm_num +- +- have norm_x_eq: WordNorm x = 2 *r + 1 := by grind +- rw [← s_lt, norm_x_eq] +- conv => +- lhs +- lhs +- simp +- field_simp +- ring +- norm_num +- +- . positivity +- . +- simp [← sub_eq] +- rw [← sub_div] +- simp +- field_simp +- push_cast +- conv => +- lhs +- rhs +- lhs +- equals -1 => +- rw [sub_eq] +- push_cast +- rw [Nat.cast_sub (by grind)] +- ring +- simp +- norm_num +- -- TODO - surely this can be simplified +- by_cases f_x_zero: (f x) ^2 = 0 +- . simp [f_x_zero] +- +- rw [le_mul_iff_one_le_right] +- . norm_num +- . positivity +- +- . +- rename_i norm_eq +- simp [← norm_eq] +- positivity ++ exact harmonic_cutoff_step f r hr x (by simpa using hx) s hs + . rfl + . intro x hx + apply Finset.sum_congr + . rfl + . intro s hs +- simp [φ] ++ simp [φ, harmonicCutoff] + simp [dist, WordDist_one] at hx + norm_cast at hx + have hx_le : WordNorm x ≤ 2 * r + 1 := by grind +@@ -367,6 +361,5 @@ lemma harmonic_r2_inequality (f : G → ℝ) (hf : Laplace_b f = 0) (r: ℕ) (hr + apply finite_ball + . exact phi_support + +-#print axioms harmonic_r2_inequality + + end GeneratesNS +diff --git a/Gromov/Laplace.lean b/Gromov/Laplace.lean +index 4f525b7..afd4e3b 100644 +--- a/Gromov/Laplace.lean ++++ b/Gromov/Laplace.lean +@@ -23,7 +23,6 @@ set_option linter.style.longLine false + set_option linter.style.cdot false + -- TODO - vscode stops reporting underlines if there are too many total underlines / gutter messages + -- I've disabled some failing lints for now so that error underlines still sho up +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +diff --git a/Gromov/Lemma326.lean b/Gromov/Lemma326.lean +index 430b325..03cbd45 100644 +--- a/Gromov/Lemma326.lean ++++ b/Gromov/Lemma326.lean +@@ -12,11 +12,6 @@ basis. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -62,7 +57,6 @@ noncomputable def phi (data: GoodScalesData b): V →ₗ[ℝ] EuclideanSpace ℝ + + @[expose] def C: ℝ := 32 * (#S) + +-set_option maxHeartbeats 2500000 in + lemma lemma_3_26_a (data: GoodScalesData b) (u: V): Q_R (R_2 data) u u ≤ 2 * (#(S^(R_1 data ))) * ‖(phi data u)‖^2 + C * (Real.exp ((2 * a data.d))) * (R_1 data + 1)^2 * (∑ x ∈ B_r (8 * R_2 data), deriv_sq u x) := by + + rw [Q_R] +@@ -132,7 +126,7 @@ lemma lemma_3_26_a (data: GoodScalesData b) (u: V): Q_R (R_2 data) u u ≤ 2 * ( + rw [add_comm] + apply add_le_add + . +- ring ++ ring_nf + simp + + . +@@ -197,10 +191,10 @@ lemma lemma_3_26_a (data: GoodScalesData b) (u: V): Q_R (R_2 data) u u ≤ 2 * ( + simp at foo + grind + grw [i_1_le] +- ring ++ ring_nf + . + rw [← le_sub_iff_add_le] +- ring ++ ring_nf + have i_2_pos := (GoodScales data).i_2_pos + have le_one: 1 ≤ (GoodScales data).i_2 := by grind + grw [← le_one] +@@ -229,7 +223,7 @@ lemma lemma_3_26_a (data: GoodScalesData b) (u: V): Q_R (R_2 data) u u ≤ 2 * ( + equals (32 * ↑(#S) * (Real.exp (a data.d) * (↑(R_1 data) + 1) ^ 2)) * ((Real.exp (a data.d)) * ∑ x ∈ B_r (8 * ↑(R_2 data)), deriv_sq (⇑u.val) x) => + ring + apply mul_le_mul +- . ring ++ . ring_nf + simp + . + grw [Finset.sum_le_sum (g := fun x => Real.exp (a data.d) * (deriv_sq (u.val).toFun x))] +@@ -241,10 +235,10 @@ lemma lemma_3_26_a (data: GoodScalesData b) (u: V): Q_R (R_2 data) u u ≤ 2 * ( + norm_cast + norm_cast at card_inter_le + grw [card_inter_le] +- simp [deriv_sq, ← pow_two] ++ simp [deriv_sq] + positivity + +- . simp [deriv_sq, ← pow_two] ++ . simp [deriv_sq] + apply Finset.sum_nonneg + intro i hi + norm_cast +@@ -280,7 +274,6 @@ lemma lemma_3_26_a (data: GoodScalesData b) (u: V): Q_R (R_2 data) u u ≤ 2 * ( + rw [← pow_two] + positivity + +-#print axioms lemma_3_26_a + + -- Controlled grwoth + +diff --git a/Gromov/LipschitzNorm.lean b/Gromov/LipschitzNorm.lean +index 8e23a57..64dd7bf 100644 +--- a/Gromov/LipschitzNorm.lean ++++ b/Gromov/LipschitzNorm.lean +@@ -21,8 +21,6 @@ seminormed space. The quotient space `W := LipschitzH ⧸ ConstF` is an actual n + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false + + namespace GeneratesNS + open Generates +@@ -43,7 +41,6 @@ lemma lipschiz_norm_zero: LipschitzSemiNorm (0) = 0 := by + exact nonpos_iff_eq_zero.mp sinf_le + + +-#synth IsStrictOrderedRing NNReal + + -- TODO - upstream to mathlib + lemma lipschitz_attains_norm (f: G → ℝ) (hf: IsLipschitz f): LipschitzWith (LipschitzSemiNorm f) f := by +@@ -167,10 +164,9 @@ lemma lipschitzSemiNorm_neg (f : G → ℝ) : LipschitzSemiNorm (-f) = Lipschitz + unfold LipschitzSemiNorm + congr 1 + ext k +- simp only [Set.mem_setOf_eq, lipschitzWith_neg_iff] ++ simp only [Set.mem_ofPred_eq, lipschitzWith_neg_iff] + + +-set_option maxHeartbeats 1000000 in + noncomputable instance LipschitzH_seminorm: SeminormedAddCommGroup (LipschitzH) where + norm := fun v => LipschitzSemiNorm v + dist_self := by +@@ -295,7 +291,7 @@ lemma iterated_lipschitz_bound (f: LipschitzH): ∀ g: G, ‖f g‖ ≤ (Lipschi + norm_cast + rw [Nat.add_sub_of_le (by grind)] + simp [DFunLike.coe] +- ring ++ ring_nf + norm_cast + conv => + lhs +diff --git a/Gromov/MatrixSubsum.lean b/Gromov/MatrixSubsum.lean +index ec60107..88c0b4b 100644 +--- a/Gromov/MatrixSubsum.lean ++++ b/Gromov/MatrixSubsum.lean +@@ -164,7 +164,7 @@ lemma eigen_nonzero {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)ˣ): ∀ (k : Modul + intro k + by_contra! + have eigen_zero := LinearMap.hasEigenvalue_zero_tfae ((A.val.map (Int.castRingHom ℂ)).toLin') +- have det_zero := (eigen_zero.out 0 3).mp ++ have det_zero := (eigen_zero.out 1 4).mp + have has_k := k.prop + conv at has_k => + lhs +@@ -195,8 +195,7 @@ lemma eigen_nonzero {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)ˣ): ∀ (k : Modul + . simp + exact Int.cast_injective + +-@[expose] +-def KroneckerPow_exists {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)ˣ) (k: Module.End.Eigenvalues (A.val.map (Int.castRingHom ℂ)).toLin') (eigen_one_complex: ∀ k : Module.End.Eigenvalues ((A.val.map (Int.castRingHom ℂ ))).toLin', ‖k.val‖ = 1) := Polynomial.pow_eq_one_of_mahlerMeasure_eq_one (by ++theorem KroneckerPow_exists {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)ˣ) (k: Module.End.Eigenvalues (A.val.map (Int.castRingHom ℂ)).toLin') (eigen_one_complex: ∀ k : Module.End.Eigenvalues ((A.val.map (Int.castRingHom ℂ ))).toLin', ‖k.val‖ = 1) : ∃ n : ℕ, 0 < n ∧ (k : ℂ) ^ n = 1 := Polynomial.pow_eq_one_of_mahlerMeasure_eq_one (by + rw [Polynomial.mahlerMeasure_eq_leadingCoeff_mul_prod_roots] + rw [Polynomial.Monic.leadingCoeff] + . +@@ -279,7 +278,7 @@ lemma int_matrix_unipotent {d: ℕ} (hd: 0 < d) (n: ℕ) (hn: 0 < n) (A: (Matrix + intro k + by_contra! + have eigen_zero := LinearMap.hasEigenvalue_zero_tfae (A_C.toLin') +- have det_zero := (eigen_zero.out 0 3).mp ++ have det_zero := (eigen_zero.out 1 4).mp + have has_k := k.prop + conv at has_k => + lhs +@@ -518,8 +517,6 @@ lemma int_matrix_unipotent {d: ℕ} (hd: 0 < d) (n: ℕ) (hn: 0 < n) (A: (Matrix + . exact Int.cast_injective + + +-#print axioms int_matrix_unipotent +-#print axioms int_matrix_poly_growth_eigenvalue + + + open scoped Pointwise Finset +diff --git a/Gromov/MatrixSubsum/Subsums.lean b/Gromov/MatrixSubsum/Subsums.lean +index 3f723a7..370ac6f 100644 +--- a/Gromov/MatrixSubsum/Subsums.lean ++++ b/Gromov/MatrixSubsum/Subsums.lean +@@ -19,8 +19,7 @@ structure DerivedSets {R: Type*} [NormedCommRing R] {n: ℕ} (A: Matrix (Fin n) + supp_disj: Disjoint (p \ q) (q \ p) + + +-@[expose] +-def poly_cancel {R: Type*} [NormedCommRing R] {n: ℕ} (A: Matrix (Fin n) (Fin n) R) (v: (Fin n) → R) (p q : Finset ℕ) (hpq: p.sum (fun k => A^k • v) = q.sum (fun k => A^k • v)) : DerivedSets A v p q := ({ ++theorem poly_cancel {R: Type*} [NormedCommRing R] {n: ℕ} (A: Matrix (Fin n) (Fin n) R) (v: (Fin n) → R) (p q : Finset ℕ) (hpq: p.sum (fun k => A^k • v) = q.sum (fun k => A^k • v)) : DerivedSets A v p q := ({ + h_prime := by + have p_inter_subset : p ∩ q ⊆ q := by + simp +@@ -118,15 +117,12 @@ lemma interval_sum_le {R: Type*} {d: ℕ} [RCLike R] [ NormSMulClass R (Fin d + simp + rw [Matrix.dotProduct_mulVec] + rw [mul_pow_exact A φ k hva] +- norm_cast +- + rw [Matrix.dotProduct_mulVec] at ih + rw [mul_pow_exact A φ k hva] at ih + apply_fun (fun x => x + ‖k‖ ^ n * ‖v‖) at ih + . + simp only [] at ih + +- norm_cast at ih + simp at ih + grw [ih] + simp +@@ -144,7 +140,6 @@ lemma interval_sum_le {R: Type*} {d: ℕ} [RCLike R] [ NormSMulClass R (Fin d + exact hab + . linarith + +-#print axioms interval_sum_le + + + theorem hasEigenvalue_of_isRoot_charpoly {R : Type*} {M : Type*} [CommRing R] [AddCommGroup M] [Module R M] {f : Module.End R M} {μ : R} [IsDomain R] [Module.Finite R M] [Module.Free R M] (h : (f.charpoly).IsRoot μ) : f.HasEigenvalue μ := by +@@ -212,7 +207,7 @@ lemma int_matrix_eigenvalue {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)ˣ): + equals ∏ i ∈ A_C.charpoly.roots.toEnumFinset, 1 => + simp + +- apply Finset.prod_lt_prod ++ apply Finset.prod_lt_prod₀ + . + intro i hi + simp at hi +@@ -285,9 +280,7 @@ lemma int_matrix_eigenvalue {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)ˣ): + norm_num at roots_prod_le + + +-#print axioms int_matrix_eigenvalue + +-set_option maxHeartbeats 1200000 in + lemma subsums_unique {d: ℕ} (A: Matrix (Fin d) (Fin d) ℂ) (φ v: (Fin d) → ℂ) (N₀ N: ℕ) (hv: ‖φ ⬝ᵥ v‖ ≠ 0) (k: ℂ) (hk: 3 ≤ ‖k‖) (hva: A.vecMul φ = k • φ) (hn: N₀ ≤ N) (p q: Finset ℕ) + (hp: p ⊆ Finset.Ico N₀ N) (hq: q ⊆ Finset.Ico N₀ N) (hpq: p.sum (fun k => A^k • v) = q.sum (fun k => A^k • v)): + p = q := by +@@ -433,7 +426,6 @@ lemma subsums_unique {d: ℕ} (A: Matrix (Fin d) (Fin d) ℂ) (φ v: (Fin d) → + intro a ha b hb + grind + +-#print axioms subsums_unique + + + lemma int_matrix_exponential_growth {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)) (φ : (Fin d) → ℂ) (v: Fin d → ℤ) (v_ne_zero: ‖φ ⬝ᵥ (Int.castRingHom ℂ) ∘ v‖ ≠ 0) (k: ℂ) (hv: (A.map (Int.castRingHom ℂ)).vecMul φ = (k • φ)) (k_gt: 1 < ‖k‖): +@@ -505,4 +497,3 @@ lemma int_matrix_exponential_growth {d: ℕ} (A: (Matrix (Fin d) (Fin d) ℤ)) ( + rw [Finset.sum_apply (a := v)] + rw [Finset.sum_apply (a := v)] + rw [hab] +-#print axioms int_matrix_exponential_growth +diff --git a/Gromov/NilpotentFinite.lean b/Gromov/NilpotentFinite.lean +index ffe4196..541722a 100644 +--- a/Gromov/NilpotentFinite.lean ++++ b/Gromov/NilpotentFinite.lean +@@ -1,26 +1,20 @@ +-/- +-This file was edited by Aristotle. ++module + +-Lean version: leanprover/lean4:v4.24.0 +-Mathlib version: f897ebcf72cd16f89ab4577d0c826cd14afaafc7 +-This project request had uuid: c7b9eaaf-b542-48c8-afcd-8a008aa813c3 ++public import Mathlib + +-The following was proved by Aristotle: ++/-! # Finiteness of finitely generated nilpotent torsion groups + +-- lemma finite_of_nilpotent_fg_order {G: Type*} [Group G] [Group.FG G] [Group.IsNilpotent G] (m: ℕ) (hm: 0 < m) (hg: ∀ g : G, g^m = 1): Finite G ++The proof is by induction on the nilpotency class, using the central quotient ++and finite generation of finite-index subgroups. Formalized by Aristotle. + -/ + +-module +- +-public import Mathlib +- + + public section + open scoped IsMulCommutative + +-lemma finite_of_nilpotent_fg_order {G: Type*} [Group G] [Group.FG G] [Group.IsNilpotent G] (hG: Monoid.IsTorsion G): Finite G := by ++lemma finite_of_nilpotent_fg_order {G: Type*} [Group G] [Group.FG G] [Group.IsNilpotent G] (hG: IsMulTorsion G): Finite G := by + induction' n : Group.nilpotencyClass G with n ih generalizing G <;> simp_all +decide [ Group.nilpotencyClass ]; +- · rw [ eq_top_iff ] at n ; aesop; ++ · rw [ eq_top_iff ] at n; + -- Since the top subgroup is equal to the bottom subgroup, G must be trivial. + have h_trivial : ∀ g : G, g = 1 := by + simp_all +decide [ Subgroup.eq_bot_iff_forall ]; +@@ -40,7 +34,7 @@ lemma finite_of_nilpotent_fg_order {G: Type*} [Group G] [Group.FG G] [Group.IsNi + rw [← QuotientGroup.out_eq' (a := g)] + erw [ QuotientGroup.eq_one_iff ] + simp [hn.2] +- · have e := nilpotencyClass_quotient_center (G := G) ++ · have e := Group.nilpotencyClass_quotient_center (G := G) + have hq : Group.IsNilpotent (G ⧸ Subgroup.center G) := inferInstance + simp_all +decide [Group.nilpotencyClass] + -- Since $Z(G)$ is finitely generated and torsion, it is finite. +@@ -50,7 +44,7 @@ lemma finite_of_nilpotent_fg_order {G: Type*} [Group G] [Group.FG G] [Group.IsNi + convert Subgroup.fg_of_index_ne_zero ?_; + · infer_instance; + · exact Subgroup.finiteIndex_iff_finite_quotient.mpr h_quot_finite; +- have h_center_torsion : Monoid.IsTorsion (↥(Subgroup.center G)) := by ++ have h_center_torsion : IsMulTorsion (↥(Subgroup.center G)) := by + intro x; + rw [isOfFinOrder_iff_pow_eq_one] + specialize hG x +@@ -61,5 +55,5 @@ lemma finite_of_nilpotent_fg_order {G: Type*} [Group G] [Group.FG G] [Group.IsNi + rw [Subtype.ext_iff] + simp + exact hn.2 +- exact CommGroup.finite_of_fg_torsion (↥(Subgroup.center G)) h_center_torsion; ++ exact CommGroup.finite_of_fg_isMulTorsion (↥(Subgroup.center G)) h_center_torsion; + convert Finite.of_subgroup_quotient ( H := Subgroup.center G ) +diff --git a/Gromov/Packing.lean b/Gromov/Packing.lean +index 14de782..7d49b7c 100644 +--- a/Gromov/Packing.lean ++++ b/Gromov/Packing.lean +@@ -12,11 +12,6 @@ the intersection-multiplicity bound `card_B_le_exp_wa`. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -55,8 +50,6 @@ noncomputable def GoodScales (data: GoodScalesData b) := Classical.choice (lemma + + @[expose] noncomputable def R_1 (data: GoodScalesData b) := 2 * 16^(GoodScales data).i_1 + @[expose] noncomputable def R_2 (data: GoodScalesData b) := 16^(GoodScales data).i_2 +- +--- TODO - does it matter than 'Metric.maximalSeparatedSet' uses 'R_1 < dist' instead of 'R_1 <= dist' ? + @[expose] def X_j (data: GoodScalesData b) := Metric.maximalSeparatedSet (R_1 data) ((Metric.closedBall (1: G) (R_2 data))) + -- A collection of disjoint balls that cover the ball R_2 + @[expose] def B (data: GoodScalesData b) := (fun a => Metric.closedBall a (R_1 data)) '' (X_j data) +@@ -87,10 +80,8 @@ lemma B_ball_injective_on (data: GoodScalesData b) (R: ℝ) (R_pos: 0 ≤ R) (hR + simp [edist, PseudoMetricSpace.edist] at sep + rw [dist_comm] at b_mem + simp [dist] at b_mem +- norm_cast at b_mem + rify at sep + grw [b_mem] at sep +- norm_cast at sep + grind + + lemma B_covers_R2 (data: GoodScalesData b): Metric.closedBall 1 (R_2 data) ⊆ ⋃₀ (B data) := by +@@ -100,44 +91,44 @@ lemma B_covers_R2 (data: GoodScalesData b): Metric.closedBall 1 (R_2 data) ⊆ + + -- Metric.maximalSeparatedSet_subset + have card_le := Metric.encard_le_of_isSeparated (C := (X_j data) ∪ {x}) (ε := (R_1 data)) (A := ( (Metric.closedBall 1 (R_2 data)))) ?_ ?_ ?_ +- . ++ · + simp [X_j] at card_le + rw [Set.encard_insert_of_notMem] at card_le + rw [Set.Finite.encard_eq_coe_toFinset_card] at card_le +- . norm_cast at card_le ++ · norm_cast at card_le + + grind +- . ++ · + apply Set.Finite.subset (s := Metric.closedBall 1 (R_2 data)) +- . apply finite_closed_ball +- . apply Metric.maximalSeparatedSet_subset +- . ++ · apply finite_closed_ball ++ · apply Metric.maximalSeparatedSet_subset ++ · + simp at x_not_mem + simp only [B, Set.mem_image, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂, +- not_lt, X_j] at x_not_mem ++ X_j] at x_not_mem + + by_contra! + specialize x_not_mem x this + simp [R_1] at x_not_mem +- . ++ · + apply Set.union_subset +- . simp [X_j] ++ · simp [X_j] + grw [Metric.maximalSeparatedSet_subset] +- . ++ · + simp at x_mem + simpa using x_mem +- . ++ · + simp + apply Metric.IsSeparated.insert +- . simp [X_j] ++ · simp [X_j] + apply Metric.isSeparated_maximalSeparatedSet +- . intro y hy hxy ++ · intro y hy hxy + simp [B] at x_not_mem + specialize x_not_mem y hy + simp [edist, PseudoMetricSpace.edist] + simp [dist] at x_not_mem + exact x_not_mem +- . ++ · + rw [← lt_top_iff_ne_top] + grw [Metric.packingNumber_le_encard_self] + simp +@@ -152,7 +143,7 @@ lemma B_half_disjoint (data: GoodScalesData b): (B_half data).PairwiseDisjoint i + obtain ⟨y, y_mem, hy⟩ := hY + + by_cases x_eq_y : x = y +- . ++ · + rw [x_eq_y] at hx + rw [← hx, ← hy] + +@@ -171,7 +162,6 @@ lemma B_half_disjoint (data: GoodScalesData b): (B_half data).PairwiseDisjoint i + rw [dist_comm x a] at x_y_dist_bad + grw [a_dist_x, a_dist_y] at x_y_dist_bad + simp at x_y_dist_bad +- -- TODO - we need a lemma that edist = ↑dist + simp [edist, PseudoMetricSpace.edist] at x_sep + simp [dist] at x_y_dist_bad + grind +@@ -201,6 +191,7 @@ lemma ball_subset_smul_origin (a: G) (r: ℝ): Metric.closedBall a r ⊆ (MulOpp + simp at hx + simpa using hx + ++omit v_wrapper_inst in + lemma ball_smul_eq_origin (a: G) (r: ℝ): Metric.closedBall a r = (MulOpposite.op a) • Metric.closedBall 1 r := by + ext x + have foo := smul_origin_ball_subset a r +@@ -222,8 +213,6 @@ lemma B_half_finite (data: GoodScalesData b): (B_half data).Finite := by + apply finite_closed_ball + + @[expose] noncomputable def B_finsets (data: GoodScalesData b): Finset (Finset G) := Finset.image ((fun a => (finite_closed_ball a (R_1 data )).toFinset)) (X_j_finite data).toFinset +- +--- TODO - combine this with 'B_half' + @[expose] + noncomputable def B_half_finsets (data: GoodScalesData b): Finset (Finset G) := Finset.image ((fun a => (finite_closed_ball a (R_1 data / 2)).toFinset)) (X_j_finite data).toFinset + +@@ -240,10 +229,10 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + apply Nat.mul_le_of_le_div + unfold InterMult + by_cases h_s: InterMult_f (B_3 data) = ∅ +- . simp [h_s] +- . ++ · simp [h_s] ++ · + rw [csSup_le_iff] +- . ++ · + intro n hn + simp [InterMult_f] at hn + obtain ⟨X, ⟨X_subset, X_inter⟩, X_card⟩ := hn +@@ -252,7 +241,7 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + rw [Set.Finite.encard_eq_coe_toFinset_card X_finite] + simp + rw [Nat.le_div_iff_mul_le] +- . ++ · + have X_inner_nonempty: ∀ t ∈ X, ∃ a, a ∈ (X_j data) ∧ Metric.closedBall a (3 * (R_1 data + 1)) = t := by + intro t ht + specialize X_subset ht +@@ -264,11 +253,11 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + rw [← Finset.sum_const] + + grw [Finset.sum_le_sum (g := fun a => if ha: a ∈ X then #(finite_closed_ball (X_inner_nonempty a ha).choose ((R_1 data) / 2)).toFinset else 0)] +- . ++ · + rw [← closed_ball_eq_S_pow] + rw [Finset.sum_dite] + rw [← Finset.card_biUnion] +- . ++ · + rw [← ne_eq, ← Set.nonempty_iff_ne_empty] at X_inter + obtain ⟨base, h_base⟩ := X_inter + +@@ -287,7 +276,7 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + simp at ha + simp + obtain ⟨c, hc, a_dist⟩ := ha +- . ++ · + let q := (X_inner_nonempty c hc).choose + grw [dist_triangle _ q] + conv at a_dist => +@@ -307,7 +296,7 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + simp [q] + grw [h_base] + grind +- . ++ · + rw [Finset.pairwiseDisjoint_iff] + intro a _ b _ hab + rw [Subtype.ext_iff] +@@ -328,23 +317,23 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + simp only [Set.mem_image, id_eq, forall_exists_index, and_imp] at from_b + simp at hab + have inter_eq := from_b a_center a_center_mem (i := (Metric.closedBall a_center (↑(R_1 data) / 2) )) (?_) b_center b_center_mem (j := (Metric.closedBall b_center (↑(R_1 data) / 2) )) (?_) ?_ +- . ++ · + + rw [← a_eq, ← b_eq] + simp [a_center, b_center] at inter_eq + apply B_ball_injective_on data (R_1 data / 2) (by grind) (by simp [R_1]) at inter_eq +- . ++ · + simp [inter_eq] +- . grind +- . grind +- . rfl +- . rfl +- . simp [a_center, b_center] ++ · grind ++ · grind ++ · rfl ++ · rfl ++ · simp [a_center, b_center] + rw [← Finset.coe_nonempty] at hab + simp at hab + exact hab + +- . intro y hy ++ · intro y hy + simp at hy + simp only [hy, ↓reduceDIte] + nth_rw 1 [← Finset.card_smul_finset (MulOpposite.op (X_inner_nonempty y hy).choose)] +@@ -365,10 +354,10 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + grw [Nat.cast_div_le] + simp + +- . simp ++ · simp + apply Finset.Nonempty.pow + simp [S_nonempty] +- . ++ · + unfold BddAbove + use (B_3 data).encard.toNat + rw [mem_upperBounds] +@@ -377,12 +366,12 @@ lemma inter_mult_helper (data: GoodScalesData b): InterMult (B_3 data) * #(S ^ ( + obtain ⟨a, b, x_eq⟩ := hx + rw [← x_eq] + apply ENat.toNat_le_toNat +- . ++ · + apply Set.encard_le_encard + grind +- . simp ++ · simp + apply B_3_finite +- . rw [Set.nonempty_iff_ne_empty] ++ · rw [Set.nonempty_iff_ne_empty] + grind + + @[expose] noncomputable def B_r (r: ℝ) := (finite_closed_ball 1 r).toFinset +@@ -401,9 +390,9 @@ lemma pack_center_helper (data: GoodScalesData b) (x: G): #{ c ∈ (X_j_finite d + + rw [← closed_ball_eq_S_pow] + grw [Finset.sum_le_sum (g := fun a => #(B_c_r a ↑((R_1 data : ℝ) / 2)))] +- . ++ · + rw [← Finset.card_biUnion] +- . ++ · + nth_rw 2 [← Finset.card_smul_finset (MulOpposite.op x)] + apply Finset.card_le_card + rw [← Finset.coe_subset] +@@ -424,9 +413,9 @@ lemma pack_center_helper (data: GoodScalesData b) (x: G): #{ c ∈ (X_j_finite d + rw [dist_comm] at x_mem + grw [x_mem] + rw [mul_add] +- ring ++ ring_nf + grind +- . ++ · + rw [Finset.pairwiseDisjoint_iff] + intro a ha b hb hab + +@@ -437,27 +426,28 @@ lemma pack_center_helper (data: GoodScalesData b) (x: G): #{ c ∈ (X_j_finite d + rw [Set.pairwiseDisjoint_iff] at from_b + simp only [Set.mem_image, id_eq, forall_exists_index, and_imp] at from_b + have inter_eq := from_b a ha.1 (i := (Metric.closedBall a ((↑(R_1 data) : ℝ) / 2) )) (?_) b hb.1 (j := (Metric.closedBall b (↑(R_1 data : ℝ) / 2) )) (?_) ?_ +- . ++ · + apply B_ball_injective_on data (R_1 data / 2) (by grind) (by simp [R_1]) at inter_eq +- . ++ · + simp [inter_eq] +- . grind +- . grind +- . rfl +- . rfl +- . ++ · grind ++ · grind ++ · rfl ++ · rfl ++ · + rw [← Finset.coe_nonempty] at hab + simp [B_c_r] at hab + simpa using hab +- . ++ · + intro a ha + simp at ha + simp [B_c_r_eq_smul, B_r] + rw [Nat.cast_div] +- . simp +- . simp [R_1] +- . simp ++ · simp ++ · simp [R_1] ++ · simp + ++omit [Nonempty ι] in + /-- Common step for Lemma 3.25 (a) and (b). + + `h i = log (#(S ^ 16 ^ i) * det (Q_{16 ^ i}) ^ (dim V)⁻¹)` splits into a log-cardinality term +@@ -483,8 +473,8 @@ lemma log_card_pow_sub_le {j k m n : ℕ} (hj : i₀ ≤ j) (hjk : j ≤ k) (hm0 + -- `h k - h j` is non-negative and may be discarded. + have det_le : (Q_R_matrix b ((16 ^ j : ℕ) : ℝ)).det ≤ (Q_R_matrix b ((16 ^ k : ℕ) : ℝ)).det := by + apply matrix_det_montone +- . exact pd_j +- . unfold Q_R_matrix ++ · exact pd_j ++ · unfold Q_R_matrix + rw [← map_sub] + rw [← LinearMap.isPosSemidef_iff_posSemidef_toMatrix] + apply Q_R_lin_sub_pos_semi_def +@@ -501,150 +491,147 @@ lemma log_card_pow_sub_le {j k m n : ℕ} (hj : i₀ ≤ j) (hjk : j ≤ k) (hm0 + Real.log ((#(S ^ m) : ℝ)) - Real.log ((#(S ^ n) : ℝ)) ≤ + Real.log ((#(S ^ 16 ^ k) : ℝ)) - Real.log ((#(S ^ 16 ^ j) : ℝ)) := by + apply sub_le_sub +- . apply Real.log_le_log (card_pos m) ++ · apply Real.log_le_log (card_pos m) + norm_cast + exact Finset.card_pow_mono hm0 hm +- . apply Real.log_le_log (card_pos (16 ^ j)) ++ · apply Real.log_le_log (card_pos (16 ^ j)) + norm_cast + exact Finset.card_pow_mono (by positivity) hn + simp only [h, f] + rw [Real.log_mul, Real.log_mul] +- . linarith +- . exact ne_of_gt (card_pos (16 ^ j)) +- . exact ne_of_gt (Real.rpow_pos_of_pos pd_j.det_pos _) +- . exact ne_of_gt (card_pos (16 ^ k)) +- . exact ne_of_gt (Real.rpow_pos_of_pos ++ · linarith ++ · exact ne_of_gt (card_pos (16 ^ j)) ++ · exact ne_of_gt (Real.rpow_pos_of_pos pd_j.det_pos _) ++ · exact ne_of_gt (card_pos (16 ^ k)) ++ · exact ne_of_gt (Real.rpow_pos_of_pos + (Q_R_matrix_pos_def_i₀ b _ i₀_le_k).det_pos _) + + -- Lemma 3.25 (a) + + lemma log_inter_mult_b3 (data: GoodScalesData b): InterMult (B_3 data) ≤ Real.exp (a data.d) := by + by_cases mult_zero: InterMult (B_3 data) = 0 +- . simp [mult_zero] ++ · simp [mult_zero] + positivity + + rw [← Real.log_le_iff_le_exp] + have foo := inter_mult_helper data + rw [← Nat.le_div_iff_mul_le] at foo + grw [foo] +- . ++ · + grw [Nat.cast_div_le] +- . ++ · + rw [Real.log_div] +- . ++ · + have bound := (GoodScales data).first_h_i + grw [← bound] + + apply log_card_pow_sub_le (GoodScales data).i_1_ge (Nat.le_succ _) +- . simp [R_1] +- . rw [pow_succ] ++ · simp [R_1] ++ · rw [pow_succ] + simp [R_1] +- ring ++ ring_nf + rw [← le_tsub_iff_right] +- . ++ · + rw [← Nat.mul_sub] + norm_num + grw [← Nat.one_le_pow] +- . simp +- . simp +- . simp +- . simp [R_1] +- . norm_cast ++ · simp ++ · simp ++ · simp ++ · simp [R_1] ++ · norm_cast + rw [Finset.card_eq_zero] + rw [← ne_eq, ← Finset.nonempty_iff_ne_empty] + apply Finset.Nonempty.pow + simp [S_nonempty] +- . norm_cast ++ · norm_cast + rw [Finset.card_eq_zero] + rw [← ne_eq, ← Finset.nonempty_iff_ne_empty] + apply Finset.Nonempty.pow + simp [S_nonempty] +- . simp ++ · simp + refine ⟨?_, ?_⟩ +- . apply Finset.Nonempty.pow ++ · apply Finset.Nonempty.pow + simp [S_nonempty] +- . ++ · + apply Finset.card_pow_mono +- . simp [R_1] +- . grind +- . ++ · simp [R_1] ++ · grind ++ · + simp + apply Finset.Nonempty.pow + simp [S_nonempty] +- . simp ++ · simp + grind + + lemma log_pack_center_helper (data: GoodScalesData b) (x: G): #{ c ∈ (X_j_finite data).toFinset | x ∈ B_c_r c (3 * (R_1 data + 1)) } ≤ Real.exp (a data.d) := by + by_cases inter_empty: { c ∈ (X_j_finite data).toFinset | x ∈ B_c_r c (3 * (R_1 data + 1)) } = ∅ +- . simp [inter_empty] ++ · simp [inter_empty] + apply Real.exp_nonneg + + rw [← Real.log_le_iff_le_exp] + have foo := pack_center_helper data x + rw [← Nat.le_div_iff_mul_le] at foo + grw [foo] +- . ++ · + grw [Nat.cast_div_le] +- . ++ · + rw [Real.log_div] +- . ++ · + have bound := (GoodScales data).first_h_i + grw [← bound] + + apply log_card_pow_sub_le (GoodScales data).i_1_ge (Nat.le_succ _) +- . simp [R_1] +- . rw [pow_succ] ++ · simp [R_1] ++ · rw [pow_succ] + simp [R_1] +- ring ++ ring_nf + rw [← le_tsub_iff_right] +- . ++ · + rw [← Nat.mul_sub] + norm_num + grw [← Nat.one_le_pow] +- . simp +- . simp +- . simp +- . simp [R_1] +- . norm_cast ++ · simp ++ · simp ++ · simp ++ · simp [R_1] ++ · norm_cast + rw [Finset.card_eq_zero] + rw [← ne_eq, ← Finset.nonempty_iff_ne_empty] + apply Finset.Nonempty.pow + simp [S_nonempty] +- . norm_cast ++ · norm_cast + rw [Finset.card_eq_zero] + rw [← ne_eq, ← Finset.nonempty_iff_ne_empty] + apply Finset.Nonempty.pow + simp [S_nonempty] +- . simp ++ · simp + refine ⟨?_, ?_⟩ +- . apply Finset.Nonempty.pow ++ · apply Finset.Nonempty.pow + simp [S_nonempty] +- . ++ · + apply Finset.card_pow_mono +- . simp [R_1] +- . grind +- . ++ · simp [R_1] ++ · grind ++ · + simp + rw [Finset.nonempty_iff_ne_empty] + simpa using inter_empty +- . simp ++ · simp + apply Finset.Nonempty.pow + simp [S_nonempty] +- . simp ++ · simp + rw [Finset.nonempty_iff_ne_empty] + simpa using inter_empty + +-#print axioms inter_mult_helper +-#print axioms log_inter_mult_b3 +-#print axioms log_pack_center_helper + + -- Lemma 3.25 (b) + lemma card_B_le_exp_wa (data: GoodScalesData b): #(B_finite data).toFinset < Real.exp (data.w * (a data.d)) := by + have B_union := Finset.card_biUnion (s := (B_half_finsets data)) (t := id) ?_ +- . ++ · + simp at B_union + have sum_le := Finset.sum_eq_card_nsmul (f := fun (u: Finset G) => #u) (s := B_half_finsets data) (b := #(S ^ (R_1 data / 2))) ?_ +- . ++ · + rw [← Nat.card_eq_card_finite_toFinset] + simp [B] + grw [Set.ncard_image_le (hs := by apply X_j_finite)] +@@ -676,33 +663,33 @@ lemma card_B_le_exp_wa (data: GoodScalesData b): #(B_finite data).toFinset < Rea + grw [sum_le] + rw [← B_union] + grw [Finset.card_le_card (t := (finite_closed_ball (1: G) ↑(2 * (R_2 data))).toFinset)] +- . ++ · + grw [Nat.cast_div_le] + rw [card_closed_ball_eq] +- . ++ · + rw [← Real.log_lt_iff_lt_exp] +- . ++ · + apply lt_of_le_of_lt ?_ ((GoodScales data).h_diff_lt_w) + rw [Real.log_div (by simp; grind [S_nonempty]) (by simp; grind [S_nonempty])] + apply log_card_pow_sub_le (GoodScales data).i_1_ge +- . -- `i_2 - i_1 > w ≥ 0` forces `i_1 < i_2` ++ · -- `i_2 - i_1 > w ≥ 0` forces `i_1 < i_2` + have hdiff := (GoodScales data).i_diff_mem + simp [Set.mem_Ioo] at hdiff + omega +- . simp [R_2] +- . rw [pow_succ] ++ · simp [R_2] ++ · rw [pow_succ] + simp [R_2] + omega +- . simp [R_1] +- . ++ · simp [R_1] ++ · + apply div_pos +- . simp ++ · simp + apply Finset.Nonempty.pow + simp [S_nonempty] +- . simp ++ · simp + apply Finset.Nonempty.pow + simp [S_nonempty] +- . ++ · + intro a ha + simp at ha + obtain ⟨x, x_mem, hx⟩ := ha +@@ -723,10 +710,10 @@ lemma card_B_le_exp_wa (data: GoodScalesData b): #(B_finite data).toFinset < Rea + simp at foo + grind + grw [i_1_le] +- . ++ · + grind +- . simp +- . ++ · simp ++ · + intro b hb + simp [B_half_finsets] at hb + obtain ⟨c, c_mem, b_eq⟩ := hb +@@ -734,8 +721,6 @@ lemma card_B_le_exp_wa (data: GoodScalesData b): #(B_finite data).toFinset < Rea + rw [← Set.toFinite_toFinset] + rw [← Nat.card_eq_card_finite_toFinset] + rw [ball_smul_eq_origin] +- +- -- TODO - make the various finite/fintype/card conversion less awful + conv => + lhs + equals (MulOpposite.op c • (Metric.closedBall (1: G) (↑(R_1 data) / 2))).ncard => +@@ -750,8 +735,7 @@ lemma card_B_le_exp_wa (data: GoodScalesData b): #(B_finite data).toFinset < Rea + simp [R_1] + rw [card_closed_ball_eq] + +- . +- -- TODO - there must be a less horrendous way of dealing with Finset here ++ · + simp [B_half_finsets] + have foo := B_half_disjoint data + simp [B_half] at foo +diff --git a/Gromov/Poincare.lean b/Gromov/Poincare.lean +index 81268ad..1b399d6 100644 +--- a/Gromov/Poincare.lean ++++ b/Gromov/Poincare.lean +@@ -11,11 +11,6 @@ public import Gromov.Packing + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -55,7 +50,7 @@ lemma deriv_sq_R_inv_comp (f: G → ℝ) (x: G): + apply Finset.sum_nbij' (i := fun s => s⁻¹) (j := fun s => s⁻¹) <;> + simp +contextual [hGS.has_inv, mul_inv_rev] + +-omit v_wrapper_inst in ++omit hGS v_wrapper_inst in + lemma three_term_cs (a b: ℝ) (n: Type*) {s: Finset n} (f: n → ℝ): a + (∑ x ∈ s, f x) + b ≤ √(a^2 + (∑ x ∈ s, (f x)^2) + b^2) * √(2 + #(s)) := by + conv => + lhs +@@ -77,7 +72,7 @@ lemma ball_x_one_subset (x: G): (Metric.closedBall x 1) ⊆ ((x) • S) ∪ ((Mu + obtain ⟨l, l_prod, l_len⟩ := word_norm_prod_self (x * a⁻¹) + simp [ProdS] at l_prod + by_cases l_len_eq: l.length = 0 +- . ++ · + have l_eq: l = [] := by grind + simp [l_eq] at l_prod + rw [eq_comm, mul_inv_eq_one] at l_prod +@@ -85,7 +80,7 @@ lemma ball_x_one_subset (x: G): (Metric.closedBall x 1) ⊆ ((x) • S) ∪ ((Mu + use 1 + simp [one_mem] + grind +- . ++ · + rw [← l_len] at ha + have l_len_one: l.length = 1 := by grind + rw [List.length_eq_one_iff] at l_len_one +@@ -98,21 +93,22 @@ lemma ball_x_one_subset (x: G): (Metric.closedBall x 1) ⊆ ((x) • S) ∪ ((Mu + + rw [l_prod] + refine ⟨?_, ?_⟩ +- . ++ · + rw [← Finset.mem_inv'] + rw [← S_eq_Sinv] + simp +- . +- simp [l_prod] +-omit v_wrapper_inst in ++ · ++ simp ++omit hGS v_wrapper_inst in + lemma le_of_sub_eq (a b c: ℝ) (ha: a = b - c) (hc: 0 ≤ c): a ≤ b := by + grind + ++omit v_wrapper_inst in + lemma double_ball_sum (R: ℕ) (hR: 0 < R) (f: G → ℝ) (hf: ∀ g, 0 ≤ f g): ∑ x ∈ B_r (↑(R - 1)), ∑ y ∈ (Metric.closedBall x 1), f y ≤ 2 * #S * ∑ x ∈ B_r R, f x := by + classical + + grw [Finset.sum_le_sum (g := fun x => ∑ y ∈ ((x) • S) ∪ ((MulOpposite.op x • S)), f y)] +- . ++ · + have union_sub (x: G) := Finset.sum_union_inter (f := f) (s₁ := x • S) (s₂ := (MulOpposite.op x • S)) + simp_rw [← eq_sub_iff_add_eq] at union_sub + have foo (x) := le_of_sub_eq _ _ _ (union_sub x) (by +@@ -131,12 +127,12 @@ lemma double_ball_sum (R: ℕ) (hR: 0 < R) (f: G → ℝ) (hf: ∀ g, 0 ≤ f g) + + have card_le (i: G) : #({a ∈ B_r ↑(R - 1) ×ˢ S | a.1 • a.2 = i}) ≤ #S := by + apply Finset.card_le_card_of_injOn (f := fun p => p.1⁻¹ * i) +- . intro a ha ++ · intro a ha + simp at ha + simp + simp [← ha.2] + grind +- . intro a ha b hb hab ++ · intro a ha b hb hab + simp at hab + simp at ha + simp at hb +@@ -149,12 +145,12 @@ lemma double_ball_sum (R: ℕ) (hR: 0 < R) (f: G → ℝ) (hf: ∀ g, 0 ≤ f g) + + have card_le_rev (i: G) : #({a ∈ B_r ↑(R - 1) ×ˢ S | a.2 * a.1 = i}) ≤ #S := by + apply Finset.card_le_card_of_injOn (f := fun p => i * p.1⁻¹) +- . intro a ha ++ · intro a ha + simp at ha + simp + simp [← ha.2] + grind +- . intro a ha b hb hab ++ · intro a ha b hb hab + simp at hab + simp at ha + simp at hb +@@ -170,31 +166,30 @@ lemma double_ball_sum (R: ℕ) (hR: 0 < R) (f: G → ℝ) (hf: ∀ g, 0 ≤ f g) + rw [← Finset.sum_product'] + simp_rw [Finset.sum_comp] + grw [Finset.sum_le_sum_of_subset_of_nonneg (t := B_r R)] +- . ++ · + grw [Finset.sum_le_sum (g := fun i => #S • f i)] +- . ++ · + simp + rw [← Finset.mul_sum] + rw [add_comm] + grw [Finset.sum_le_sum_of_subset_of_nonneg (t := B_r R)] +- . ++ · + grw [Finset.sum_le_sum (g := fun i => #S • f i)] +- . ++ · + simp + rw [← Finset.mul_sum] + rw [← mul_add] + grind +- . ++ · + intro i hi + simp +- -- TODO - why doesn't grw work here + apply mul_le_mul +- . simp ++ · simp + apply card_le_rev +- . simp +- . apply hf +- . simp +- . ++ · simp ++ · apply hf ++ · simp ++ · + rw [Finset.image_subset_iff] + intro x hx + simp at hx +@@ -204,17 +199,17 @@ lemma double_ball_sum (R: ℕ) (hR: 0 < R) (f: G → ℝ) (hf: ∀ g, 0 ≤ f g) + grw [hx.1] + have norm_s := word_norm_le x.2 [⟨x.2, hx.2⟩] (by simp [ProdS]) + grw [norm_s] +- simp [hR] ++ simp + grind +- . intros ++ · intros + apply mul_nonneg +- . simp +- . apply hf +- . intro i hi ++ · simp ++ · apply hf ++ · intro i hi + grw [card_le] + apply hf + +- . rw [Finset.image_subset_iff] ++ · rw [Finset.image_subset_iff] + intro x hx + simp at hx + simp [B_r, dist, WordDist_one] +@@ -224,79 +219,168 @@ lemma double_ball_sum (R: ℕ) (hR: 0 < R) (f: G → ℝ) (hf: ∀ g, 0 ≤ f g) + have norm_s := word_norm_le x.2 [⟨x.2, hx.2⟩] (by simp [ProdS]) + grw [norm_s] + simp [hR] +- . intros ++ · intros + simp + apply mul_nonneg +- . simp +- . apply hf +- . intro i hi ++ · simp ++ · apply hf ++ · intro i hi + grw [Finset.sum_le_sum_of_subset_of_nonneg] +- . ++ · + simp + apply ball_x_one_subset +- . intros ++ · intros + apply hf + +--- TODO - get rid of some lemmas, since mathlib already has Metric.smul_closedBall defined +- +--- Theorem 3.20 +-set_option maxHeartbeats 3500000 in +-lemma poincare_inequality (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), |f x - (f_avg (R - 1) f)|^2 ≤ +- 16 * R^2 * #S * (#(B_r (2 * R - 2))) / #(B_r (R - 1)) * ∑ x ∈ (B_r (3 * R)), deriv_sq_R f x := by ++omit v_wrapper_inst in ++private lemma poincare_average_bound (R : ℕ) (f : G → ℝ) (R_nonpos : R ≠ 0) (x : G) : |f x - f_avg (R - 1) f| ≤ √((#((B_r (R - 1))) : ℝ)⁻¹ * (∑ y ∈ (B_r (R - 1)), (f x - f y)^2)) := by ++ rw [f_avg] ++ conv => ++ lhs ++ arg 1 ++ arg 1 ++ equals (#((B_r (↑R - 1))) : ℝ)⁻¹ * ∑ y ∈ (B_r (↑R - 1)), f x => ++ simp ++ rw [inv_mul_cancel_left₀] ++ simp [B_r] ++ exact Set.ncard_ne_zero_of_mem (a := 1) (by simp; grind) (finite_closed_ball 1 _) + +- by_cases R_nonpos: R = 0 +- . +- simp [R_nonpos, f_avg, B_r] ++ rw [B_r] ++ rw [← mul_sub] ++ rw [abs_mul] ++ rw [← Finset.sum_sub_distrib] ++ grw [Finset.abs_sum_le_sum_abs] ++ conv => ++ lhs ++ rhs ++ arg 2 ++ intro i ++ equals |f x - f i| * 1 => simp ++ grw [Real.sum_mul_le_sqrt_mul_sqrt] ++ simp [Real.sqrt_eq_rpow] ++ rw [← Real.rpow_neg_one] ++ rw [mul_comm] ++ rw [mul_assoc] ++ rw [← Real.rpow_add] ++ · ++ norm_num ++ simp ++ rw [Real.mul_rpow] ++ · ++ field_simp ++ rw [← Real.rpow_mul] ++ · ++ simp ++ · positivity ++ · positivity ++ · positivity + +- let δ_f (x: G) := ∑ x ∈ (finite_closed_ball x 1).toFinset, deriv_sq_R f x ++ · simp ++ rw [Set.ncard_pos (finite_closed_ball 1 _)] ++ exact ⟨1, by simp; grind⟩ + +- have f_sub_le (x: G): |f x - f_avg (R - 1) f| ≤ √((#((B_r (R - 1))) : ℝ)⁻¹ * (∑ y ∈ (B_r (R - 1)), (f x - f y)^2)) := by +- rw [f_avg] ++omit v_wrapper_inst in ++private lemma poincare_path_sum (R : ℕ) (f : G → ℝ) (R_nonpos : R ≠ 0) : ++ let δ_f (x : G) := ∑ x ∈ (finite_closed_ball x 1).toFinset, deriv_sq_R f x ++ let γ (z : G) (i : ℕ) := ((word_norm_prod_self z).choose.take i).unattach.prod ++ ∀ (z: G) (_hz: z ∈ B_r (2*R - 2)), ∑ x ∈ B_r (R - 1), ∑ i ∈ Finset.range (WordNorm z), δ_f (x * (γ z i)) ≤ 2 * R * ∑ x ∈ B_r (3*R - 1), δ_f x := by ++ dsimp only ++ let δ_f (x : G) := ∑ x ∈ (finite_closed_ball x 1).toFinset, deriv_sq_R f x ++ let γ (z : G) (i : ℕ) := ((word_norm_prod_self z).choose.take i).unattach.prod ++ have gamma_zero (z: G): γ z 0 = 1 := by simp [γ] ++ have gamma_norm (z: G): γ z (WordNorm z) = z := by ++ simp [γ] ++ obtain ⟨prod, len_eq⟩ := (word_norm_prod_self z).choose_spec ++ simp [ProdS] at prod + conv => +- lhs +- arg 1 + arg 1 +- equals (#((B_r (↑R - 1))) : ℝ)⁻¹ * ∑ y ∈ (B_r (↑R - 1)), f x => +- simp +- rw [inv_mul_cancel_left₀] +- simp [B_r] +- exact Set.ncard_ne_zero_of_mem (a := 1) (by simp; grind) (finite_closed_ball 1 _) ++ pattern (WordNorm z) ++ rw [← len_eq] + +- rw [B_r] +- rw [← mul_sub] +- rw [abs_mul] +- rw [← Finset.sum_sub_distrib] +- grw [Finset.abs_sum_le_sum_abs] +- conv => +- lhs +- rhs +- arg 2 +- intro i +- equals |f x - f i| * 1 => simp +- grw [Real.sum_mul_le_sqrt_mul_sqrt] +- simp [Real.sqrt_eq_rpow] +- rw [← Real.rpow_neg_one] +- rw [mul_comm] +- rw [mul_assoc] +- rw [← Real.rpow_add] +- . +- norm_num ++ simp ++ exact prod ++ ++ have gamma_i_norm_le (z: G) (i: ℕ): WordNorm (γ z i) ≤ i := by ++ simp [γ] ++ ++ have i_le := word_norm_le ((word_norm_prod_self z).choose.take i).unattach.prod ((word_norm_prod_self z).choose.take i) (by simp [ProdS]) ++ grw [List.length_take_le] at i_le ++ exact i_le ++ ++ intro z hz ++ change ∑ x ∈ B_r (R - 1), ∑ i ∈ Finset.range (WordNorm z), δ_f (x * (γ z i)) ≤ 2 * R * ∑ x ∈ B_r (3*R - 1), δ_f x ++ ++ rw [← Finset.sum_product'] ++ rw [Finset.sum_comp] ++ simp ++ grw [Finset.sum_le_sum (g := fun a => (((2 * R) : ℝ) * (δ_f a)))] ++ · ++ rw [← Finset.mul_sum] ++ grw [Finset.sum_le_sum_of_subset_of_nonneg (t := B_r (3*R - 1))] ++ · ++ intro p hp ++ simp at hp ++ obtain ⟨a, b, ⟨a_mem, b_lt⟩, p_eq⟩ := hp ++ rw [← p_eq] ++ simp [B_r, dist, WordDist_one] ++ grw [word_norm_mul_le] ++ simp [B_r, dist, WordDist_one] at a_mem ++ simp [B_r, dist, WordDist_one] at hz + simp +- rw [Real.mul_rpow] +- . +- field_simp +- rw [← Real.rpow_mul] +- . +- simp +- . positivity +- . positivity +- . positivity ++ grw [a_mem] ++ grw [gamma_i_norm_le] ++ grw [b_lt] ++ grw [hz] ++ grind ++ · intro p hp _ ++ simp [δ_f, deriv_sq_R] ++ positivity ++ · ++ intro b hb ++ simp at hb ++ obtain ⟨x, n, ⟨x_mem, n_lt⟩, b_eq⟩ := hb ++ grw [Finset.card_le_card (t := (Finset.range (2 * R)).image (fun n => (b * ((γ z n)⁻¹), n)))] ++ · ++ grw [Finset.card_image_le] ++ · simp ++ · simp [δ_f, deriv_sq_R] ++ positivity ++ · ++ simp [δ_f, deriv_sq_R] ++ positivity ++ · ++ intro p hp ++ simp at hp ++ simp ++ use p.2 ++ refine ⟨?_, ?_⟩ ++ · + +- . simp +- rw [Set.ncard_pos (finite_closed_ball 1 _)] +- exact ⟨1, by simp; grind⟩ ++ by_contra! ++ grw [hp.1.2] at this ++ simp [B_r, dist, WordDist_one] at hz ++ conv at hz => ++ rhs ++ equals ↑(2*R - 2) => ++ rw [Nat.cast_sub] ++ simp ++ grind + +- let γ (z: G) (i: ℕ) := ((word_norm_prod_self z).choose.take i).unattach.prod ++ norm_cast at hz ++ grind ++ · ++ ext ++ · simp [← hp.2] ++ · simp ++ ++omit v_wrapper_inst in ++private lemma poincare_difference_bound (R : ℕ) (f : G → ℝ) (R_nonpos : R ≠ 0) : ++ let δ_f (x : G) := ∑ x ∈ (finite_closed_ball x 1).toFinset, deriv_sq_R f x ++ let γ (z : G) (i : ℕ) := ((word_norm_prod_self z).choose.take i).unattach.prod ++ ∀ (x y: G) (_hx: x ∈ B_r (R - 1)) (_hy: y ∈ B_r (R - 1)), |f y - f x| ≤ √((2 * R) * (∑ i ∈ Finset.range (WordNorm (x⁻¹ * y)), δ_f (x * γ (x⁻¹ * y) i))) := by ++ dsimp only ++ let δ_f (x : G) := ∑ x ∈ (finite_closed_ball x 1).toFinset, deriv_sq_R f x ++ let γ (z : G) (i : ℕ) := ((word_norm_prod_self z).choose.take i).unattach.prod + have gamma_zero (z: G): γ z 0 = 1 := by simp [γ] + have gamma_norm (z: G): γ z (WordNorm z) = z := by + simp [γ] +@@ -317,163 +401,118 @@ lemma poincare_inequality (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), |f x + grw [List.length_take_le] at i_le + exact i_le + +- have gamma_sum (z: G) (hz: z ∈ B_r (2*R - 2)): ∑ x ∈ B_r (R - 1), ∑ i ∈ Finset.range (WordNorm z), δ_f (x * (γ z i)) ≤ 2 * R * ∑ x ∈ B_r (3*R - 1), δ_f x := by ++ intro x y hx hy ++ change |f y - f x| ≤ √((2 * R) * (∑ i ∈ Finset.range (WordNorm (x⁻¹ * y)), δ_f (x * γ (x⁻¹ * y) i))) + +- rw [← Finset.sum_product'] +- rw [Finset.sum_comp] +- simp +- grw [Finset.sum_le_sum (g := fun a => (((2 * R) : ℝ) * (δ_f a)))] +- . +- rw [← Finset.mul_sum] +- grw [Finset.sum_le_sum_of_subset_of_nonneg (t := B_r (3*R - 1))] +- . +- intro p hp +- simp at hp +- obtain ⟨a, b, ⟨a_mem, b_lt⟩, p_eq⟩ := hp +- rw [← p_eq] +- simp [B_r, dist, WordDist_one] +- grw [word_norm_mul_le] +- simp [B_r, dist, WordDist_one] at a_mem +- simp [B_r, dist, WordDist_one] at hz ++ have inv_prod_le: WordNorm (x⁻¹ * y) ≤ 2*R - 2 := by ++ grw [word_norm_mul_le] ++ rw [← word_norm_inv] ++ simp [B_r, dist, WordDist_one] at hx hy ++ conv at hx => ++ rhs ++ equals ↑(R - 1) => ++ rw [Nat.cast_sub] + simp +- grw [a_mem] +- grw [gamma_i_norm_le] +- grw [b_lt] +- grw [hz] + grind +- . intro p hp _ +- simp [δ_f, deriv_sq_R] +- positivity +- . +- intro b hb +- simp at hb +- obtain ⟨x, n, ⟨x_mem, n_lt⟩, b_eq⟩ := hb +- grw [Finset.card_le_card (t := (Finset.range (2 * R)).image (fun n => (b * ((γ z n)⁻¹), n)))] +- . +- grw [Finset.card_image_le] +- . simp +- . simp [δ_f, deriv_sq_R] +- positivity +- . +- simp [δ_f, deriv_sq_R] +- positivity +- . +- intro p hp +- simp at hp ++ conv at hy => ++ rhs ++ equals ↑(R - 1) => ++ rw [Nat.cast_sub] + simp +- use p.2 +- refine ⟨?_, ?_⟩ +- . +- +- by_contra! +- grw [hp.1.2] at this +- simp [B_r, dist, WordDist_one] at hz +- conv at hz => +- rhs +- equals ↑(2*R - 2) => +- rw [Nat.cast_sub] +- simp +- grind ++ grind ++ norm_cast at hx hy ++ grw [hx, hy] ++ grind + +- norm_cast at hz +- grind +- . +- ext +- . simp [← hp.2] +- . simp ++ have root_le_R: √(WordNorm (x⁻¹ * y)) ≤ √(2*R) := by ++ rw [Real.sqrt_le_sqrt_iff] ++ · norm_cast ++ grw [inv_prod_le] ++ simp ++ · simp + +- have diff_le_delta_sum (x y: G) (hx: x ∈ B_r (R - 1)) (hy: y ∈ B_r (R - 1)): |f y - f x| ≤ √((2 * R) * (∑ i ∈ Finset.range (WordNorm (x⁻¹ * y)), δ_f (x * γ (x⁻¹ * y) i))) := by ++ conv => ++ lhs ++ equals |(f (x * γ (x⁻¹ * y) (WordNorm (x⁻¹ * y)))) - f (x * γ (x⁻¹ * y) 0)| => ++ simp [gamma_zero, gamma_norm] + +- have inv_prod_le: WordNorm (x⁻¹ * y) ≤ 2*R - 2 := by +- grw [word_norm_mul_le] +- rw [← word_norm_inv] +- simp [B_r, dist, WordDist_one] at hx hy +- conv at hx => +- rhs +- equals ↑(R - 1) => +- rw [Nat.cast_sub] +- simp +- grind +- conv at hy => +- rhs +- equals ↑(R - 1) => +- rw [Nat.cast_sub] +- simp +- grind +- norm_cast at hx hy +- grw [hx, hy] +- grind ++ rw [← Finset.sum_range_sub (n := WordNorm (x⁻¹ * y)) (f := fun i => f (x * γ (x⁻¹ * y) i))] ++ grw [Finset.abs_sum_le_sum_abs] ++ conv => ++ lhs ++ arg 2 ++ intro i ++ rw [← mul_one (a := |_|)] + +- have root_le_R: √(WordNorm (x⁻¹ * y)) ≤ √(2*R) := by +- rw [Real.sqrt_le_sqrt_iff] +- . norm_cast +- grw [inv_prod_le] +- simp +- . simp ++ grw [Real.sum_mul_le_sqrt_mul_sqrt] ++ simp ++ grw [root_le_R] ++ ++ have sum_le_delta: ∑ x_1 ∈ Finset.range (WordNorm (x⁻¹ * y)), (f (x * γ (x⁻¹ * y) x_1) - f (x * γ (x⁻¹ * y) (x_1 + 1))) ^ 2 ≤ ∑ n ∈ Finset.range (WordNorm (x⁻¹ * y)), δ_f (x * (γ (x⁻¹ * y) n)) := by ++ apply Finset.sum_le_sum ++ intro n hn ++ simp [δ_f, deriv_sq_R] ++ rw [← Finset.add_sum_erase (a := (x * γ (x⁻¹ * y) n))] ++ · ++ apply le_add_of_le_of_nonneg ++ · ++ let s := (word_norm_prod_self (x⁻¹ * y)).choose[n]?.getD ⟨1, one_mem⟩ ++ rw [← Finset.add_sum_erase (a := s.val) (h := by simp)] ++ apply le_add_of_le_of_nonneg ++ · ++ rw [sub_sq_comm] ++ conv => ++ rhs ++ lhs ++ arg 1 ++ arg 1 ++ equals x * γ (x⁻¹ * y) (n + 1) => ++ ++ rw [mul_assoc, mul_left_cancel_iff] ++ simp [γ, s] ++ by_cases n_add_lt: (n) < (word_norm_prod_self (x⁻¹ * y)).choose.length ++ · ++ simp [n_add_lt] ++ rw [List.take_add_one] ++ simp ++ rw [getElem?_pos] ++ · simp ++ · grind ++ · ++ simp [n_add_lt] ++ rw [List.take_add_one] ++ simp ++ rw [getElem?_neg] ++ · simp ++ · grind ++ · positivity ++ · positivity ++ · simp [dist, WordDist, word_norm_one] ++ ++ simp_rw [sub_sq_comm] ++ grw [sum_le_delta] ++ rw [mul_comm] ++ simp + +- conv => +- lhs +- equals |(f (x * γ (x⁻¹ * y) (WordNorm (x⁻¹ * y)))) - f (x * γ (x⁻¹ * y) 0)| => +- simp [gamma_zero, gamma_norm] ++-- Theorem 3.20 ++omit v_wrapper_inst in ++lemma poincare_inequality (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), |f x - (f_avg (R - 1) f)|^2 ≤ ++ 16 * R^2 * #S * (#(B_r (2 * R - 2))) / #(B_r (R - 1)) * ∑ x ∈ (B_r (3 * R)), deriv_sq_R f x := by + +- rw [← Finset.sum_range_sub (n := WordNorm (x⁻¹ * y)) (f := fun i => f (x * γ (x⁻¹ * y) i))] +- grw [Finset.abs_sum_le_sum_abs] +- conv => +- lhs +- arg 2 +- intro i +- rw [← mul_one (a := |_|)] ++ by_cases R_nonpos: R = 0 ++ · ++ simp [R_nonpos, f_avg, B_r] + +- grw [Real.sum_mul_le_sqrt_mul_sqrt] +- simp +- grw [root_le_R] ++ let δ_f (x: G) := ∑ x ∈ (finite_closed_ball x 1).toFinset, deriv_sq_R f x + +- have sum_le_delta: ∑ x_1 ∈ Finset.range (WordNorm (x⁻¹ * y)), (f (x * γ (x⁻¹ * y) x_1) - f (x * γ (x⁻¹ * y) (x_1 + 1))) ^ 2 ≤ ∑ n ∈ Finset.range (WordNorm (x⁻¹ * y)), δ_f (x * (γ (x⁻¹ * y) n)) := by +- apply Finset.sum_le_sum +- intro n hn +- simp [δ_f, deriv_sq_R] +- rw [← Finset.add_sum_erase (a := (x * γ (x⁻¹ * y) n))] +- . +- apply le_add_of_le_of_nonneg +- . +- let s := (word_norm_prod_self (x⁻¹ * y)).choose[n]?.getD ⟨1, one_mem⟩ +- rw [← Finset.add_sum_erase (a := s.val) (h := by simp)] +- apply le_add_of_le_of_nonneg +- . +- rw [sub_sq_comm] +- conv => +- rhs +- lhs +- arg 1 +- arg 1 +- equals x * γ (x⁻¹ * y) (n + 1) => +- +- rw [mul_assoc, mul_left_cancel_iff] +- simp [γ, s] +- -- TODO - we can probably use hn instead of this case split +- by_cases n_add_lt: (n) < (word_norm_prod_self (x⁻¹ * y)).choose.length +- . +- simp [n_add_lt] +- rw [List.take_add_one] +- simp +- rw [getElem?_pos] +- . simp +- . grind +- . +- simp [n_add_lt] +- rw [List.take_add_one] +- simp +- rw [getElem?_neg] +- . simp +- . grind +- . positivity +- . positivity +- . simp [dist, WordDist, word_norm_one] +- +- simp_rw [sub_sq_comm] +- grw [sum_le_delta] +- rw [mul_comm] +- simp ++ have f_sub_le := poincare_average_bound R f R_nonpos ++ ++ let γ (z: G) (i: ℕ) := ((word_norm_prod_self z).choose.take i).unattach.prod ++ have gamma_sum (z : G) (hz : z ∈ B_r (2*R - 2)) : ∑ x ∈ B_r (R - 1), ∑ i ∈ Finset.range (WordNorm z), δ_f (x * (γ z i)) ≤ 2 * R * ∑ x ∈ B_r (3*R - 1), δ_f x := ++ poincare_path_sum R f R_nonpos z hz ++ ++ have diff_le_delta_sum (x y : G) (hx : x ∈ B_r (R - 1)) (hy : y ∈ B_r (R - 1)) : |f y - f x| ≤ √((2 * R) * (∑ i ∈ Finset.range (WordNorm (x⁻¹ * y)), δ_f (x * γ (x⁻¹ * y) i))) := ++ poincare_difference_bound R f R_nonpos x y hx hy + + conv at f_sub_le => + intro x +@@ -510,9 +549,8 @@ lemma poincare_inequality (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), |f x + rw [Finset.sum_product] + simp only [] + rw [Finset.sum_comm] +- -- TODO - use gcongr here + grw [Finset.sum_le_sum (g := fun z => ∑ x ∈ B_r (2*R - 2), ∑ i ∈ Finset.range (WordNorm x), δ_f (z * γ x i))] +- . ++ · + rw [Finset.sum_comm] + grw [Finset.sum_le_sum (h := gamma_sum)] + simp [δ_f] +@@ -534,37 +572,37 @@ lemma poincare_inequality (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), |f x + simp + grind + grw [double_ball_sum] +- . ++ · + norm_cast + + have four_le: (4: ℝ) ≤ 8 := by + grind + grw [four_le] + simp [deriv_sq_R] +- ring ++ ring_nf + simp + simp [deriv_sq_R] + positivity +- . simp ++ · simp + grind +- . intro g ++ · intro g + simp [deriv_sq_R] + positivity + +- . intro a ha ++ · intro a ha + rw [Finset.sum_comp (g := fun y => a⁻¹ * y) (f := fun x => ∑ x_1 ∈ Finset.range (WordNorm (x)), δ_f (a * γ (x) x_1))] + grw [Finset.sum_le_sum_of_subset_of_nonneg (t := B_r (2*R - 2))] +- . ++ · + simp_rw [inv_mul_eq_iff_eq_mul] + simp_rw [Finset.card_filter] + simp + apply Finset.sum_le_sum + intro x hx + split_ifs +- . simp +- . simp [δ_f, deriv_sq_R] ++ · simp ++ · simp [δ_f, deriv_sq_R] + positivity +- . ++ · + rw [Finset.image_subset_iff] + intro x hx + simp [B_r, dist, WordDist_one] +@@ -574,22 +612,23 @@ lemma poincare_inequality (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), |f x + simp + grw [ha, hx] + grind +- . ++ · + intros + simp [δ_f, deriv_sq_R] + positivity + +-#print axioms poincare_inequality + + -- `B_r` is centred at `1`, so it is closed under inversion (`word_norm_inv`). + omit v_wrapper_inst in + lemma mem_B_r_inv (r: ℝ) (x: G): x⁻¹ ∈ B_r r ↔ x ∈ B_r r := by + simp [B_r, dist, WordDist_one, ← word_norm_inv] + ++omit v_wrapper_inst in + lemma sum_B_r_inv (r: ℝ) (g: G → ℝ): ∑ x ∈ B_r r, g x⁻¹ = ∑ x ∈ B_r r, g x := by + apply Finset.sum_nbij' (i := fun x => x⁻¹) (j := fun x => x⁻¹) <;> + simp +contextual [mem_B_r_inv] + ++omit v_wrapper_inst in + lemma f_avg_inv (r: ℝ) (f: G → ℝ): f_avg r (fun y => f y⁻¹) = f_avg r f := by + unfold f_avg + rw [show (finite_closed_ball (1: G) r).toFinset = B_r r from rfl, sum_B_r_inv] +@@ -597,6 +636,7 @@ lemma f_avg_inv (r: ℝ) (f: G → ℝ): f_avg r (fun y => f y⁻¹) = f_avg r f + -- Theorem 3.20, restated for the *left* Cayley graph. Rather than mirroring the (long) proof of + -- `poincare_inequality`, we conjugate it by the inversion `x ↦ x⁻¹`: this is a bijection of every + -- `B_r r` (`mem_B_r_inv`) and carries `deriv_sq_R` to `deriv_sq` (`deriv_sq_R_inv_comp`). ++omit v_wrapper_inst in + lemma poincare_inequality_left (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), |f x - (f_avg (R - 1) f)|^2 ≤ + 16 * R^2 * #S * (#(B_r (2 * R - 2))) / #(B_r (R - 1)) * ∑ x ∈ (B_r (3 * R)), deriv_sq f x := by + have poincare := poincare_inequality R (fun y => f y⁻¹) +@@ -610,7 +650,6 @@ lemma poincare_inequality_left (R: ℕ) (f: G → ℝ): ∑ x ∈ (B_r (R - 1)), + exact Finset.sum_congr rfl (fun x _ => deriv_sq_R_inv_comp f x)] at poincare + exact poincare + +-#print axioms poincare_inequality_left + + omit v_wrapper_inst in + lemma card_B_r_eq (R: ℕ): #(B_r R) = #(S ^ R) := by +@@ -648,11 +687,11 @@ lemma lemma_3_25_poincare (data: GoodScalesData b) (j: (X_j data)) (f: G → ℝ + rw [B_c_r_eq_smul] + rw [← Finset.image_smul] + rw [Finset.sum_image] +- . ++ · + simp + left + simp [B_r] +- . simp ++ · simp + + simp_rw [sq_abs] + grw [poincare] +@@ -662,8 +701,8 @@ lemma lemma_3_25_poincare (data: GoodScalesData b) (j: (X_j data)) (f: G → ℝ + + + rw [← Real.log_le_iff_le_exp] +- . rw [Real.log_div] +- . ++ · rw [Real.log_div] ++ · + + + rw [card_B_r_eq] +@@ -678,42 +717,41 @@ lemma lemma_3_25_poincare (data: GoodScalesData b) (j: (X_j data)) (f: G → ℝ + simp + rw [card_B_r_eq] + grw [log_card_pow_sub_le (b := b) (k := (GoodScales data).i_1 + 1) (j := (GoodScales data).i_1)] +- . ++ · + grw [(GoodScales data).first_h_i] +- . ++ · + apply (GoodScales data).i_1_ge +- . simp +- . simp ++ · simp ++ · simp + grind +- . simp ++ · simp + have h_i_1 := (GoodScales data).i_1_ge + simp [i₀, R'] at h_i_1 + simp [R_1] +- ring ++ ring_nf + grind +- . ++ · + simp [R_1] +- . simp only [B_r, Set.toFinite_toFinset, ne_eq, Nat.cast_eq_zero] ++ · simp only [B_r, Set.toFinite_toFinset, ne_eq, Nat.cast_eq_zero] + apply Finset.card_ne_zero_of_mem (a := 1) + simp [R_1] +- . simp only [B_r, Set.toFinite_toFinset, ne_eq, Nat.cast_eq_zero] ++ · simp only [B_r, Set.toFinite_toFinset, ne_eq, Nat.cast_eq_zero] + apply Finset.card_ne_zero_of_mem (a := 1) + simp [R_1] +- . apply mul_pos +- . simp only [B_r, Set.toFinite_toFinset] ++ · apply mul_pos ++ · simp only [B_r, Set.toFinite_toFinset] + norm_cast + rw [Finset.card_pos] + use 1 + simp [R_1] +- . ++ · + simp [-Set.toFinset_card] + use 1 + simp [B_r, R_1] +- . ++ · + rw [mul_div_assoc] +- norm_num + grw [vol_frac_le] +- . ++ · + + conv => + lhs +@@ -729,7 +767,7 @@ lemma lemma_3_25_poincare (data: GoodScalesData b) (j: (X_j data)) (f: G → ℝ + simp [deriv_sq] + group + simp +- . simp [deriv_sq] ++ · simp [deriv_sq] + positivity + + -- Estimating functions relative to cover +diff --git a/Gromov/PolynomialGrowth.lean b/Gromov/PolynomialGrowth.lean +new file mode 100644 +index 0000000..43f2bfe +--- /dev/null ++++ b/Gromov/PolynomialGrowth.lean +@@ -0,0 +1,37 @@ ++module ++ ++public import Mathlib ++ ++/-! # Polynomial growth of Cayley balls ++ ++Cayley balls consist of products of at most a given number of generators or ++inverse generators. Their cardinalities define the growth function. ++-/ ++ ++public section ++namespace FormalConjecturesCheck ++variable {G : Type*} [Group G] ++ ++/-! The growth conventions follow the `formal-conjectures` library. -/ ++ ++/-- The `CayleyBall` is the ball of radius `n` in the Cayley graph of a group `G` with generating ++set `S`. -/ ++@[expose] ++def CayleyBall (S : Set G) (n : ℕ) : Set G := ++ {g : G | ∃ (l : List G), l.length ≤ n ∧ (∀ s ∈ l, s ∈ S ∨ s⁻¹ ∈ S) ∧ l.prod = g} ++ ++/-- The `GrowthFunction` of a group `G` with respect to a set `S` counts the number of group ++elements that can be reached by words of length at most `n` in `S`. -/ ++@[expose] ++noncomputable def GrowthFunction (S : Set G) (n : ℕ) : ℕ := ++ (CayleyBall S n).ncard ++ ++/-- A group has polynomial growth if there exists a finite generating set whose growth function is ++bounded above by a polynomial. -/ ++@[expose] ++def HasPolynomialGrowth (G : Type*) [Group G] : Prop := ++ ∃ (S : Set G), Set.Finite S ∧ Subgroup.closure S = ⊤ ∧ ++ ∃ (C : ℝ) (d : ℕ), C > 0 ∧ ++ ∀ n > 0, (GrowthFunction S n : ℝ) ≤ C * (n : ℝ) ^ d ++ ++end FormalConjecturesCheck +diff --git a/Gromov/QuadraticForm.lean b/Gromov/QuadraticForm.lean +index eda1274..8ebe2ff 100644 +--- a/Gromov/QuadraticForm.lean ++++ b/Gromov/QuadraticForm.lean +@@ -12,11 +12,6 @@ the determinant bound `det_bound` for a fixed finite-dimensional subspace `V`. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -120,14 +115,14 @@ lemma Q_R_lin_hermetian {ι : Type*} [Fintype ι] [DecidableEq ι] {V: Submodule + lemma Q_R_lin_sub_pos_semi_def (V : Submodule ℝ LipschitzH) (R_1 R_2: ℝ) (hr: R_1 ≤ R_2): ((Q_R_lin V R_2) - Q_R_lin V R_1).IsPosSemidef := by + rw [LinearMap.isPosSemidef_def] + refine ⟨?_, ?_⟩ +- . ++ · + -- `Q_R_lin` lands in a nested linear-map type `V →ₗ⋆[ℝ] V →ₗ[ℝ] ℝ`; giving + -- `sub_eq_add_neg` its arguments explicitly avoids a metavariable whose `Sub` + -- instance would need a deeper `synthPending` than the default depth allows. + rw [sub_eq_add_neg (Q_R_lin V R_2) (Q_R_lin V R_1)] + apply LinearMap.IsSymm.add +- . apply Q_R_lin_symm +- . ++ · apply Q_R_lin_symm ++ · + -- TODO - add smul/neg lemmas so that we don't need to inline the proof here + exact { + eq := by +@@ -135,15 +130,15 @@ lemma Q_R_lin_sub_pos_semi_def (V : Submodule ℝ LipschitzH) (R_1 R_2: ℝ) (hr + simp [Q_R_lin, Q_R] + simp_rw [mul_comm] + } +- . ++ · + rw [LinearMap.isNonneg_def] + intro x + simp [Q_R_lin, Q_R] + apply Finset.sum_le_sum_of_subset_of_nonneg +- . ++ · + simp [Metric.closedBall] + grind +- . intro a ha a_not ++ · intro a ha a_not + rw [← pow_two] + positivity + +@@ -185,7 +180,7 @@ lemma v_r_all_nonzero (V: Submodule ℝ LipschitzH) [FiniteDimensional ℝ V]: + ext a + simp only [Submodule.mem_iInf, Submodule.zero_eq_bot, Submodule.mem_bot] + refine ⟨?_, ?_⟩ +- . ++ · + intro hi + ext g + specialize hi (WordNorm g) +@@ -193,11 +188,11 @@ lemma v_r_all_nonzero (V: Submodule ℝ LipschitzH) [FiniteDimensional ℝ V]: + specialize hi g + simp [dist, WordDist_one] at hi + simp [hi] +- . intro hi ++ · intro hi + simp [hi] + + rw [← Antitone.iInf_nat_add (k := n)] at inter_zero +- . ++ · + conv at inter_zero => + lhs + arg 1 +@@ -221,13 +216,12 @@ lemma v_r_all_nonzero (V: Submodule ℝ LipschitzH) [FiniteDimensional ℝ V]: + obtain ⟨x, h_x_1, h_x_2⟩ := inter_zero + use x + refine ⟨?_, ?_⟩ +- . right ++ · right + exact h_x_1 +- . exact h_x_2 +- . intro a b hab ++ · exact h_x_2 ++ · intro a b hab + simp [zero_ball] +- intro u hu hg +- intro g g_dist ++ intro u hu hg g g_dist + specialize hg g + grw [hab] at g_dist + specialize hg g_dist +@@ -242,23 +236,23 @@ lemma R'_pos (V: Submodule ℝ LipschitzH) [FiniteDimensional ℝ V]: 1 < R'_ V + lemma Q_R_pos_on_R' {V: Submodule ℝ LipschitzH} (v: V) (hv: v ≠ 0) [FiniteDimensional ℝ V] (R: ℝ) (hR: (R'_ V) ≤ R): 0 < Q_R R v v := by + simp [Q_R] + rw [Finset.sum_pos_iff_of_nonneg] +- . ++ · + by_contra! + simp_rw [← pow_two] at this + simp only [sq_nonpos_iff] at this + have foo := (v_r_all_nonzero V).choose_spec.2 (v) (by apply Submodule.coe_mem) ?_ +- . ++ · + obtain ⟨g, g_mem, x_g_nonzero⟩ := foo + specialize this g ?_ +- . ++ · + simp + unfold R'_ at hR + grw [hR] at g_mem + simpa using g_mem +- . ++ · + simp at x_g_nonzero + contradiction +- . ++ · + conv => + rhs + equals (0: V) => +@@ -267,7 +261,7 @@ lemma Q_R_pos_on_R' {V: Submodule ℝ LipschitzH} (v: V) (hv: v ≠ 0) [FiniteDi + rw [ne_eq, ← Subtype.ext_iff] + rw [← ne_eq] + exact hv +- . intro y hy ++ · intro y hy + rw [← pow_two] + positivity + +@@ -282,13 +276,11 @@ lemma Q_R_matrix_pos_def {ι : Type*} [Fintype ι] [DecidableEq ι] {V: Submodul + equals (star x) => simp + rw [star_dotProduct_toMatrix₂_mulVec] + apply Q_R_pos_on_R' +- . rw [LinearEquiv.map_ne_zero_iff] ++ · rw [LinearEquiv.map_ne_zero_iff] + exact hx +- . exact hR ++ · exact hR + +-#print sorries Q_R_matrix_pos_def + +--- TODO - generalize and upstream + + section V_variable + +@@ -297,21 +289,20 @@ variable {V: Submodule ℝ LipschitzH} [V_finite: FiniteDimensional ℝ V] [Nont + @[expose] + instance nonempty_basis: Nonempty ↑(Module.Basis.ofVectorSpaceIndex ℝ ↥V) := Module.Basis.index_nonempty (Module.Basis.ofVectorSpace _ _) + +--- TODO - generalize and upstream + omit hGS in + lemma euclidean_of_lp_le {ι : Type*} [Fintype ι] (x: EuclideanSpace ℝ ι) (i: ι): + |x.ofLp i| ≤ ‖x‖ := by + + rw [EuclideanSpace.norm_eq] + rw [Real.le_sqrt] +- . ++ · + simp + apply Finset.single_le_sum (a := i) +- . intro i _ ++ · intro i _ + positivity +- . simp +- . simp +- . positivity ++ · simp ++ · simp ++ · positivity + + /-- The Lipschitz constant `‖(b i).val‖` of the `i`-th vector of the basis `b` of `V`. -/ + @[expose] +@@ -382,13 +373,13 @@ lemma det_bound {ι : Type*} [Fintype ι] [DecidableEq ι] [Nonempty ι] (b : Mo + + (Module.finrank ℝ ↥V) * max_origin) * (1 + R)) ^ 2 from by + simp only [max_lipschitz, max_origin, det_bound_const]; ring] + rw [(Q_R_lin_hermetian b R).det_eq_prod_eigenvalues] +- grw [Finset.prod_le_prod (g := fun _ => m)] +- . ++ grw [Finset.prod_le_prod₀ (g := fun _ => m)] ++ · + simp + rw [← Module.finrank_eq_card_basis b] + rw [← Real.rpow_natCast] + rw [← Real.rpow_mul] +- . ++ · + have finrank_pos := Module.finrank_pos (R := ℝ) (M := V) + field_simp [finrank_pos] + simp +@@ -412,18 +403,17 @@ lemma det_bound {ι : Type*} [Fintype ι] [DecidableEq ι] [Nonempty ι] (b : Mo + ext a + simp + rw [foo] +- simp only [Q_R_lin, Q_R, LipschitzH_apply, map_sum, +- map_smul, LinearMap.coe_mk, AddHom.coe_mk, LinearMap.coe_sum, LinearMap.coe_smul, +- Finset.sum_apply, Pi.smul_apply, smul_eq_mul, ge_iff_le] ++ simp only [Q_R_lin, Q_R, LipschitzH_apply, LinearMap.coe_mk, AddHom.coe_mk, ++ ge_iff_le] + simp_rw [← pow_two] + grw [Finset.sum_le_card_nsmul (n := (((((Module.finrank ℝ ↥V)) * max_lipschitz + ((Module.finrank ℝ ↥V) * max_origin)) * (1 + R)) ^ 2))] +- . ++ · + rw [← card_closed_ball_eq] + simp + rw [mul_comm] + field_simp + simp +- . ++ · + intro x hx + specialize hB x + simp +@@ -431,7 +421,7 @@ lemma det_bound {ι : Type*} [Fintype ι] [DecidableEq ι] [Nonempty ι] (b : Mo + rw [← Real.sqrt_sq_eq_abs] at hB + rw [Real.sqrt_le_iff] at hB + have foo := hB.2 +- . ++ · + simp [dist, WordDist_one] at hx + grw [hx] at foo + conv => +@@ -451,10 +441,10 @@ lemma det_bound {ι : Type*} [Fintype ι] [DecidableEq ι] [Nonempty ι] (b : Mo + grw [foo] + rw [mul_pow, mul_pow] + rw [mul_le_mul_iff_left₀] +- . ++ · + rw [pow_le_pow_iff_left₀] +- . apply add_le_add +- . ++ · apply add_le_add ++ · + simp [max_lipschitz] + have foo := (m_vec_V).val.lipschitz.choose_spec + conv at foo => +@@ -469,53 +459,52 @@ lemma det_bound {ι : Type*} [Fintype ι] [DecidableEq ι] [Nonempty ι] (b : Mo + --grw [norm_sum_l] + grw [norm_sum_le] + grw [Finset.sum_le_card_nsmul (n := ↑max_lipschitz)] +- . ++ · + simp + rw [← Module.finrank_eq_card_basis b] +- . ++ · + intro i _ + simp [norm_smul] + grw [euclidean_of_lp_le] + simp [m_vec] + apply h_max_lipschitz +- . ++ · + simp [m_vec_V, m_vec] + rw [← LipschitzH_apply] + rw [LipschitzH.finset_sum_apply] + grw [Finset.abs_sum_le_sum_abs] + grw [Finset.sum_le_card_nsmul (n := max_origin)] +- . simp ++ · simp + rw [← Module.finrank_eq_card_basis b] +- . ++ · + intro i hi + simp + grw [euclidean_of_lp_le] + simp + apply h_max_origin +- . positivity +- . exact add_nonneg (mul_nonneg (by positivity) (max_lipschitz_nonneg b)) ++ · positivity ++ · exact add_nonneg (mul_nonneg (by positivity) (max_lipschitz_nonneg b)) + (mul_nonneg (by positivity) (max_origin_nonneg b)) +- . simp +- . positivity ++ · simp ++ · positivity + +- . unfold m ++ · unfold m + apply Matrix.PosSemidef.eigenvalues_nonneg + apply (Q_R_matrix_pos_def b R hR).posSemidef +- . ++ · + apply Finset.prod_nonneg + intro i _ + apply Matrix.PosSemidef.eigenvalues_nonneg + apply (Q_R_matrix_pos_def b R hR).posSemidef +- . ++ · + intro i _ + apply Matrix.PosSemidef.eigenvalues_nonneg + apply (Q_R_matrix_pos_def b R hR).posSemidef +- . intro i _ ++ · intro i _ + unfold m + have foo := (Finite.exists_max (Q_R_lin_hermetian b R).eigenvalues).choose_spec + apply foo i + +-#print axioms det_bound + end V_variable + + end GeneratesNS +diff --git a/Gromov/Representation.lean b/Gromov/Representation.lean +index d856c0c..f91e742 100644 +--- a/Gromov/Representation.lean ++++ b/Gromov/Representation.lean +@@ -23,12 +23,6 @@ fact that it preserves the quotient norm. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +--- TODO - vscode stops reporting underlines if there are too many total underlines / gutter messages +--- I've disabled some failing lints for now so that error underlines still sho up +-set_option linter.style.commandStart false +- + open Subgroup + open scoped Finset + open scoped Pointwise +@@ -42,8 +36,6 @@ include hGS + + open scoped RealInnerProductSpace + +--- `LipschitzH_seminorm` and `LipschitzH_normed` are public instances in +--- `Gromov.LipschitzNorm`, so they are already available here. + + -- The lift of LipschitzSemiNorm to W, using a proof that LipschitzSemiNorm doesn't depend on the choice representative + -- (adding a constant to a Lipschitz function doesn't change its Lipschitz constant) +@@ -63,13 +55,13 @@ lemma constf_eq_null: (ConstF : Set (LipschitzH)) = nullAddSubgroup (LipschitzH) + ext f + simp + refine ⟨?_, ?_⟩ +- . ++ · + intro hf + obtain ⟨z, hz⟩ := hf + rw [← hz] + simp [norm] + apply lipschitz_norm_const +- . ++ · + intro hf + simp [norm, LipschitzSemiNorm] at hf + have lipschitz_zero := lipschitz_attains_norm f (f.lipschitz) +@@ -88,14 +80,6 @@ instance const_isClosed: IsClosed (ConstF : Set (LipschitzH)) := by + exact isClosed_nullAddSubgroup + + +-#synth NormedSpace ℝ (W ) +-#synth NormedAddCommGroup (W ) +- +-#synth TopologicalSpace (W) +- +- +-set_option synthInstance.maxHeartbeats 400000 +-set_option maxHeartbeats 9000000 + + -- The space 'GL(W)' of invertible continuous linear functions from W to W + abbrev GL_W := (W →L[ℝ] W)ˣ +@@ -103,26 +87,10 @@ abbrev GL_W := (W →L[ℝ] W)ˣ + -- The space 'GL(W)' of invertible continuous linear functions from W to W + + +-#synth NormedRing (((W →L[ℝ] W))) +- +-#synth NormedAddCommGroup (((W →L[ℝ] W))) +- +- +-#synth FiniteDimensional ℝ (((W →L[ℝ] W))) +- +--- Homeomorph.isCompact_preimage +- + @[expose] + instance proper_linear_w: ProperSpace (((W →L[ℝ] W))) := FiniteDimensional.proper_rclike ℝ (((W →L[ℝ] W))) + + +-#synth FiniteDimensional ℝ (LipschitzH) +-#synth TopologicalSpace (LipschitzH) +-#synth BorelSpace (((W →L[ℝ] W))) +- +-#synth ProperSpace (((W →L[ℝ] W))) +- +- + @[expose] + def GRep: Representation ℝ G (LipschitzH) := { + toFun := fun g => { +@@ -151,8 +119,7 @@ def GRep: Representation ℝ G (LipschitzH) := { + -- We start with a map from G into the space of (not necessarily invertible) linear maps from W to W + @[expose] + def GRepW_non_invertible: Representation ℝ G (W) := Representation.quotient (GRep) ConstF (by +- intro g +- intro f hf ++ intro g f hf + simp + simp [ConstF] + simp [ConstF] at hf +@@ -186,9 +153,9 @@ lemma GRep_preserves_norm (g: G) (f: LipschitzH): ‖(GRep g) f‖ = ‖f‖ := + + have comp := LipschitzWith.comp (f := f.toFun) (g := fun y => (y * g)) (Kf := (LipschitzSemiNorm ⇑f)) (Kg := 1) ?_ ?_ + rotate_left 1 +- . apply lipschitz_attains_norm ++ · apply lipschitz_attains_norm + exact f.lipschitz +- . ++ · + simp [LipschitzWith] + + have norm_mem: (LipschitzSemiNorm f) ∈ { k: NNReal | LipschitzWith k (f.toFun ∘ (fun y => (y * g))) } := by +@@ -198,27 +165,27 @@ lemma GRep_preserves_norm (g: G) (f: LipschitzH): ‖(GRep g) f‖ = ‖f‖ := + + + apply le_antisymm +- . ++ · + apply csInf_le (by + simp [BddBelow] + apply Set.nonempty_of_mem (x := 0) + rw [mem_lowerBounds] + simp + ) norm_mem +- . ++ · + apply le_csInf +- . ++ · + apply Set.nonempty_of_mem (x := (LipschitzSemiNorm ⇑f)) norm_mem +- . intro b hb ++ · intro b hb + simp at hb + simp [LipschitzSemiNorm] + apply csInf_le +- . ++ · + simp [BddBelow] + apply Set.nonempty_of_mem (x := 0) + rw [mem_lowerBounds] + simp +- . simp ++ · simp + simp [LipschitzWith] at hb + simp [LipschitzWith] + intro x y +@@ -229,7 +196,9 @@ lemma GRep_preserves_norm (g: G) (f: LipschitzH): ‖(GRep g) f‖ = ‖f‖ := + + -- Takes in an invertible linear map from W to W, and produces a *continuous* linear map from W to W + @[expose] +-noncomputable def GRepW: (W →ₗ[ℝ] W)ˣ →* (W →L[ℝ] W)ˣ := { ++noncomputable def linearUnitsToContinuous ++ (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] : ++ (E →ₗ[ℝ] E)ˣ →* (E →L[ℝ] E)ˣ := { + toFun := fun f => { + val := LinearMap.toContinuousLinearMap f.val + inv := LinearMap.toContinuousLinearMap f.inv +@@ -257,8 +226,9 @@ noncomputable def GRepW: (W →ₗ[ℝ] W)ˣ →* (W →L[ℝ] W)ˣ := { + simp + } + +- +-#synth Group (GL_W) ++@[expose] ++noncomputable def GRepW : (W →ₗ[ℝ] W)ˣ →* (W →L[ℝ] W)ˣ := ++ linearUnitsToContinuous W + + lemma quotient_norm_eq_norm (f: LipschitzH): ‖(Submodule.Quotient.mk f : W)‖ = ‖f‖ := by + conv => +@@ -289,15 +259,12 @@ lemma quotient_norm_eq_norm (f: LipschitzH): ‖(Submodule.Quotient.mk f : W)‖ + rw [hinf] + simp + +-#synth NormedRing (W →L[ℝ] W) +-#synth TopologicalSpace (W →L[ℝ] W)ˣ +- + + lemma GLW_preseves_norm (g: G) (w: W): ‖(GRepW (GRepW_base g)).val w‖ = ‖w‖ := by + have exists_v: ∃ v, Submodule.Quotient.mk v = w := by + apply Quotient.exists_rep + obtain ⟨v, hv⟩ := exists_v +- simp [GRepW, GRepW_base, GRepW_non_invertible] ++ simp [GRepW, linearUnitsToContinuous, GRepW_base, GRepW_non_invertible] + nth_rw 1 [← hv] + rw [Representation.asGroupHom_apply] + simp only [Representation.quotient_apply, Submodule.mapQ_apply] +@@ -309,31 +276,30 @@ lemma GLW_preseves_norm (g: G) (w: W): ‖(GRepW (GRepW_base g)).val w‖ = ‖w + + lemma GRepW_norm_le (g: G): ‖(GRepW (GRepW_base g)).val‖ ≤ 1 := by + rw [ContinuousLinearMap.opNorm_le_iff] +- . simp [GLW_preseves_norm] +- . simp ++ · simp [GLW_preseves_norm] ++ · simp + + +-set_option synthInstance.maxHeartbeats 500000 + + + @[expose] + noncomputable def rho_g := (GRepW_base).range + + +-@[expose] +-def isembedding_units_val := Units.isEmbedding_val_mk' (M := (W →L[ℝ] W)) (f := ContinuousLinearMap.inverse) (by ++theorem isembedding_units_val : ++ Topology.IsEmbedding (Units.val : (W →L[ℝ] W)ˣ → (W →L[ℝ] W)) := Units.isEmbedding_val_mk' (M := (W →L[ℝ] W)) (f := ContinuousLinearMap.inverse) (by + intro x hx + have foo := ContDiffAt.continuousAt (ContinuousLinearMap.IsInvertible.contDiffAt_map_inverse (e := x) (n := 0) (by + simp at hx + obtain ⟨u, hu⟩ := hx + apply ContinuousLinearMap.IsInvertible.of_inverse (g := u.inv) +- . ++ · + simp + have mul_inv := u.val_inv + dsimp [HMul.hMul, Mul.mul] at mul_inv + rw [hu] at mul_inv + exact mul_inv +- . simp ++ · simp + have inv_val := u.inv_val + dsimp [HMul.hMul, Mul.mul] at inv_val + rw [hu] at inv_val +@@ -341,19 +307,15 @@ def isembedding_units_val := Units.isEmbedding_val_mk' (M := (W →L[ℝ] W)) (f + )) + apply ContinuousAt.continuousWithinAt + exact foo +- -- ContinuousLinearMap.IsInvertible.contDiffAt_map_inverse + ) (by + intro u + have mul_inv := u.val_inv + dsimp [HMul.hMul, Mul.mul] at mul_inv + apply ContinuousLinearMap.inverse_eq +- . exact u.val_inv +- . exact u.inv_val ++ · exact u.val_inv ++ · exact u.inv_val + ) + +-#synth NormedSpace ℝ (W →L[ℝ] W) +-#synth MetricSpace (W →L[ℝ] W) +- + + -- All norms are equivalent on finite-dimensional spaces: + -- https://leanprover-community.github.io/mathlib4_docs/Mathlib/Analysis/Normed/Module/FiniteDimension.html +@@ -363,22 +325,9 @@ def isembedding_units_val := Units.isEmbedding_val_mk' (M := (W →L[ℝ] W)) (f + -- ρ(G) contains an abelian subgroup of finite index + + +---borelize (W →L[ℝ] W)ˣ +- +- +--- (dropped a `#synth ContinuousMul (W →L[ℝ] W)` diagnostic here: it only resolves at a +--- raised `maxSynthPendingDepth`. The instance itself *is* needed -- see +--- `rho_g_contains_abelian`, which raises the depth for exactly this reason -- but a bare +--- `#synth` is not worth carrying a build-wide option for.) +- +- +-#synth NormedAddCommGroup (W) + +-#synth FiniteDimensional ℝ (W) + + +-#synth TopologicalSpace (W) +- + + @[expose] + def FreshTopology (V: Type*) := V +@@ -388,20 +337,9 @@ instance (V: Type*) [AddCommGroup V] [base_module: Module ℝ V]: Module ℝ (Fr + @[expose] + instance (V: Type*) [AddCommGroup V] [Module ℝ V] [base_finite: FiniteDimensional ℝ V]: FiniteDimensional ℝ (FreshTopology V) := base_finite + +- +-#synth CStarAlgebra ((ℂ →L[ℂ] ℂ)) +- +-#synth AddCommMonoid (W) +- + @[expose] + instance T2_W: T2Space (W) := TopologicalSpace.t2Space_of_metrizableSpace + +-#synth T2Space (W) +- +- +-#synth TopologicalSpace (W →L[ℝ] W) +-#synth FiniteDimensional ℝ (W →L[ℝ] W) +- + @[expose] + noncomputable def G_SPolyData {d: ℕ} (h_poly: HasPolynomialGrowthD hGS.S d): SPolyData (T := G) ⊤ := { + S := Subgroup.topEquiv.symm.toMonoidHom '' hGS.S +@@ -438,10 +376,10 @@ noncomputable def G_SPolyData {d: ℕ} (h_poly: HasPolynomialGrowthD hGS.S d): S + rw [Set.Finite.toFinset_image] + rw [← Finset.image_pow] + grw [Finset.card_image_le] +- . ++ · + specialize foo r hr + simpa using foo +- . simp ++ · simp + } + + +diff --git a/Gromov/RhoAbelian.lean b/Gromov/RhoAbelian.lean +index 480ffb6..24e4bba 100644 +--- a/Gromov/RhoAbelian.lean ++++ b/Gromov/RhoAbelian.lean +@@ -11,9 +11,6 @@ public import Gromov.Theorem38 + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +@@ -28,23 +25,157 @@ include hGS + + open scoped RealInnerProductSpace + +-set_option synthInstance.maxHeartbeats 500000 + +-set_option maxHeartbeats 9000000 ++ ++private lemma rho_continuous_range_compact ++ [IsTopologicalGroup (W →L[ℝ] W)ˣ] : ++ CompactSpace ((GRepW.comp GRepW_base).range.topologicalClosure) := by ++ let my_new_range := (GRepW.comp GRepW_base).range ++ have continuous_mul : ContinuousMul (W →L[ℝ] W) := ++ (NonUnitalSeminormedRing.toIsTopologicalRing (α := W →L[ℝ] W)).toContinuousMul ++ have is_topological : IsTopologicalGroup (W →L[ℝ] W)ˣ := by infer_instance ++ let plain_units_metric : MetricSpace (W →L[ℝ] W)ˣ := ++ isembedding_units_val.comapMetricSpace Units.val ++ change CompactSpace my_new_range.topologicalClosure ++ ++ refine { isCompact_univ := ?_ } ++ rw [Subtype.isCompact_iff] ++ rw [Topology.IsEmbedding.isCompact_iff (f := Units.val) ?_] ++ · rw [Metric.isCompact_iff_isClosed_bounded (α := (W) →L[ℝ] (W))] ++ refine ⟨?_, ?_⟩ ++ · apply IsSeqClosed.isClosed ++ by_contra! ++ simp [IsSeqClosed] at this ++ obtain ⟨seq, seq_in, ⟨lim_seq, seq_tendsto_lim_seq, lim_seq_not_mem⟩⟩ := this ++ ++ by_cases lim_seq_invertible: IsUnit lim_seq.toLinearMap ++ · ++ -- If the limit (in the space of linear maps) is invertible, then the limit will also exist in the space ++ -- of units, which will then imply that the limit exists in the space of linear maps. ++ obtain ⟨u, hu⟩ := lim_seq_invertible ++ have closure_closed := Subgroup.isClosed_topologicalClosure my_new_range ++ apply IsClosed.isSeqClosed at closure_closed ++ dsimp [IsSeqClosed] at closure_closed ++ ++ have seq_units: ∀ n: ℕ, IsUnit (seq n) := by ++ intro n ++ obtain ⟨x, x_mem, seq_eq_x⟩ := (seq_in n) ++ rw [← seq_eq_x] ++ apply Units.isUnit ++ ++ have lim_units := closure_closed (x := fun n => (seq_units n).unit) (p := GRepW u) ?_ ?_ ++ · ++ specialize lim_seq_not_mem (GRepW u) lim_units ++ conv at lim_seq_not_mem => ++ arg 1 ++ lhs ++ equals u.val.toContinuousLinearMap => ++ rfl ++ rw [hu] at lim_seq_not_mem ++ conv at lim_seq_not_mem => ++ arg 1 ++ lhs ++ equals lim_seq => ++ rfl ++ simp at lim_seq_not_mem ++ · intro n ++ have seq_n := seq_in n ++ obtain ⟨x, x_mem, seq_eq_x⟩ := seq_n ++ simp_rw [← seq_eq_x] ++ simpa using x_mem ++ · ++ rw [Topology.IsEmbedding.tendsto_nhds_iff (g := Units.val)] ++ · ++ conv => ++ arg 1 ++ equals seq => ++ rfl ++ ++ have to_clm_u: GRepW u = u.val.toContinuousLinearMap := by ++ rfl ++ ++ have u_val_eq_lim: u.val.toContinuousLinearMap = lim_seq := by ++ rw [hu] ++ rfl ++ ++ rw [to_clm_u, u_val_eq_lim] ++ exact seq_tendsto_lim_seq ++ · ++ exact isembedding_units_val ++ ++ ++ -- If the limit (in the space of linear maps) is not invertible, then it has a non-trivial kernel. ++ rw [LinearMap.isUnit_iff_ker_eq_bot] at lim_seq_invertible ++ apply Submodule.exists_mem_ne_zero_of_ne_bot at lim_seq_invertible ++ obtain ⟨v, v_in_ker, v_ne_zero⟩ := lim_seq_invertible ++ simp at v_in_ker ++ ++ ++ have eval_at := Filter.Tendsto.eval_const seq_tendsto_lim_seq v ++ have norm_tendsto := Continuous.tendsto (f := fun (x: W) => ‖x‖) (by fun_prop) (lim_seq v) ++ have norm_seq_lim := Filter.Tendsto.comp norm_tendsto eval_at ++ rw [v_in_ker] at norm_seq_lim ++ rw [norm_zero] at norm_seq_lim ++ conv at norm_seq_lim => ++ arg 1 ++ -- Use the fact that the action preserves the euclidian norm (maybe just up to a constant), ++ -- so the sequence is actually constant ++ equals fun x => ‖v‖ => ++ funext n ++ simp ++ have seq_mem := seq_in n ++ obtain ⟨x, x_mem, seq_eq_x⟩ := seq_mem ++ rw [← seq_eq_x] ++ apply ContinuousWithinAt.eq_const_of_mem_closure (f := fun (x: ((W) →L[ℝ] (W))ˣ) => ‖x.val v‖) (c := ‖v‖) (x := x) (s := my_new_range) ++ · apply Continuous.continuousWithinAt ++ fun_prop ++ · exact x_mem ++ · intro y hy ++ simp [my_new_range] at hy ++ obtain ⟨g, rep_g_eq_y⟩ := hy ++ rw [← rep_g_eq_y] ++ apply GLW_preseves_norm ++ have r_t2: T2Space ℝ := TopologicalSpace.t2Space_of_metrizableSpace ++ ++ have tendsto_norm_v := tendsto_const_nhds (α := ℕ) (f := Filter.atTop) (x := ‖v‖) ++ have norm_v_zero := tendsto_nhds_unique tendsto_norm_v norm_seq_lim ++ simp at norm_v_zero ++ contradiction ++ · ++ simp ++ apply LipschitzWith.isBounded_image (f := Units.val) (K := 1) ++ · rw [lipschitzWith_iff_dist_le_mul] ++ intro a b ++ simp ++ rfl ++ · ++ apply Bornology.IsBounded.closure ++ rw [Metric.isBounded_iff_subset_ball 1] ++ use 3 ++ intro a ha ++ simp [my_new_range] at ha ++ obtain ⟨g, rep_g_eq_a⟩ := ha ++ simp ++ conv => ++ lhs ++ equals dist (a.val) (ContinuousLinearMap.id _ _) => ++ rfl ++ grw [dist_le_norm_add_norm (a.val) (ContinuousLinearMap.id ℝ W)] ++ grw [ContinuousLinearMap.norm_id_le] ++ rw [← rep_g_eq_a] ++ grw [GRepW_norm_le] ++ norm_num ++ -- Bornology.isBounded_image_subtype_val ++ · exact isembedding_units_val + + open scoped RealInnerProductSpace in + attribute [-simp] Subgroup.map_toSubmonoid in +-set_option maxHeartbeats 2000000 in +-set_option synthInstance.maxHeartbeats 600000 in +---set_option trace.Meta.synthInstance true in + lemma rho_g_contains_abelian {d: ℕ} (hd: HasPolynomialGrowthD S d) : ∃ M: Subgroup ((rho_g)), IsMulCommutative M ∧ M.FiniteIndex := by + classical + let my_map := Subgroup.subtype (rho_g) + have W_equiv: (W) ≃ₗ[ℝ] EuclideanSpace ℝ (Fin <| Module.finrank ℝ W) := LinearEquiv.ofFinrankEq _ _ finrank_euclideanSpace_fin.symm + + +- unfold GL_W at my_map +- -- TODO - is there a simpler way to get an arbitrary inner product space? + let inner_prod_core: InnerProductSpace.Core ℝ (FreshTopology (W)) := { + inner := fun v w => ⟪W_equiv v, W_equiv w⟫, + conj_inner_symm := by intro x y; simp [real_inner_comm], +@@ -75,118 +206,6 @@ lemma rho_g_contains_abelian {d: ℕ} (hd: HasPolynomialGrowthD S d) : ∃ M: Su + have fresh_t2: T2Space (FreshTopology (W)) := TopologicalSpace.t2Space_of_metrizableSpace + + +- let plain_linear_to_clm: (((W)) →ₗ[ℝ] ((W)))ˣ →* (((W)) →L[ℝ] ((W)))ˣ := { +- toFun := fun f => { +- val := LinearMap.toContinuousLinearMap f.val +- inv := LinearMap.toContinuousLinearMap f.inv +- val_inv := by +- have old_inv := f.val_inv +- ext a +- apply_fun (fun f => f a) at old_inv +- simp only [Units.inv_eq_val_inv, Module.End.one_apply] at old_inv +- apply old_inv +- inv_val := by +- have old_inv := f.inv_val +- ext a +- apply_fun (fun f => f a) at old_inv +- simp only [Units.inv_eq_val_inv, Module.End.one_apply] at old_inv +- apply old_inv +- } +- -- TODO - why is a normal `simp` so slow here? +- map_one' := by +- ext a +- simp only [] +- rfl +- map_mul' := by +- intro f g +- ext a +- simp only [] +- rfl +- } +- +- let linear_to_clm: ((FreshTopology (W)) →ₗ[ℝ] (FreshTopology (W)))ˣ →* ((FreshTopology (W)) →L[ℝ] (FreshTopology (W)))ˣ := { +- toFun := fun f => { +- val := LinearMap.toContinuousLinearMap f.val +- inv := LinearMap.toContinuousLinearMap f.inv +- val_inv := by +- have old_inv := f.val_inv +- ext a +- apply_fun (fun f => f a) at old_inv +- simp only [Units.inv_eq_val_inv, Module.End.one_apply] at old_inv +- apply old_inv +- inv_val := by +- have old_inv := f.inv_val +- ext a +- apply_fun (fun f => f a) at old_inv +- simp only [Units.inv_eq_val_inv, Module.End.one_apply] at old_inv +- apply old_inv +- } +- -- TODO - why is a normal `simp` so slow here? +- map_one' := by +- ext a +- simp only [] +- rfl +- map_mul' := by +- intro f g +- ext a +- simp only [] +- rfl +- } +- +- +- have plain_linear_to_clm_preserves_norm (g: G) (w: (W)): ‖(plain_linear_to_clm (GRepW_base g)).val w‖ = ‖w‖ := by +- simp [plain_linear_to_clm] +- have exists_v: ∃ v, Submodule.Quotient.mk v = w := by +- apply Quotient.exists_rep +- obtain ⟨v, hv⟩ := exists_v +- simp [GRepW, GRepW_base, GRepW_non_invertible] +- nth_rw 1 [← hv] +- rw [Representation.asGroupHom_apply] +- simp only [Representation.quotient_apply, Submodule.mapQ_apply] +- +- rw [quotient_norm_eq_norm] +- rw [GRep_preserves_norm] +- rw [← hv] +- rw [quotient_norm_eq_norm] +- +- +- let my_range := (linear_to_clm.comp GRepW_base).range +- +- have fresh_complete: CompleteSpace (FreshTopology (W)) := by apply complete_of_proper (α := FreshTopology (W)) +- +- +- +- -- TODO - generalize to LinearMap/ContinuousLinearMap +- have units_val_embedding: Topology.IsEmbedding (Units.val (α := ((FreshTopology (W)) →L[ℝ] (FreshTopology (W))))) := by +- apply Units.isEmbedding_val_mk' (f := fun g => g.inverse) +- . intro a ha +- apply (ContinuousLinearMap.IsInvertible.contDiffAt_map_inverse (n := 1) ?_).continuousAt.continuousWithinAt +- simp at ha +- obtain ⟨b, hb⟩ := ha +- use ContinuousLinearEquiv.ofUnit b +- rw [← hb] +- rfl +- . intro u +- apply ContinuousLinearMap.inverse_eq +- . +- have u_val_inv := u.val_inv +- rw [ContinuousLinearMap.mul_def] at u_val_inv +- -- TODO - avoid the unfold somehow +- unfold Inv.inv +- unfold Units.instInv +- simp only [] +- rw [u_val_inv] +- rfl +- . +- unfold Inv.inv +- unfold Units.instInv +- simp only [] +- have u_inv_val := u.inv_val +- rw [ContinuousLinearMap.mul_def] at u_inv_val +- rw [u_inv_val] +- rfl +- +- + let my_new_range := ((GRepW).comp GRepW_base).range + unfold rho_g + +@@ -200,15 +219,6 @@ lemma rho_g_contains_abelian {d: ℕ} (hd: HasPolynomialGrowthD S d) : ∃ M: Su + have is_topological: IsTopologicalGroup ((W) →L[ℝ] (W))ˣ := by + infer_instance + +- let plain_units_metric: MetricSpace (((W)) →L[ℝ] ((W)))ˣ := by +- apply Topology.IsEmbedding.comapMetricSpace (f := Units.val) +- exact isembedding_units_val +- +- let units_metric: MetricSpace ((FreshTopology (W)) →L[ℝ] (FreshTopology (W)))ˣ := by +- apply Topology.IsEmbedding.comapMetricSpace (f := Units.val) +- apply units_val_embedding +- +- + have fresh_equiv: W ≃L[ℝ] FreshTopology (W) := ContinuousLinearEquiv.ofFinrankEq (rfl) + + let to_fresh (f: (W) ≃ₗ[ℝ] (W)): (FreshTopology (W)) ≃ₗ[ℝ] (FreshTopology (W)) := f +@@ -287,147 +297,16 @@ lemma rho_g_contains_abelian {d: ℕ} (hd: HasPolynomialGrowthD S d) : ∃ M: Su + + let mapped_group := Subgroup.map new_map_hom.toMonoidHom my_new_range.topologicalClosure + +- have my_new_range_compact: CompactSpace my_new_range.topologicalClosure := by +- refine { isCompact_univ := ?_ } +- rw [Subtype.isCompact_iff] +- rw [Topology.IsEmbedding.isCompact_iff (f := Units.val) ?_] +- . rw [Metric.isCompact_iff_isClosed_bounded (α := (W) →L[ℝ] (W))] +- refine ⟨?_, ?_⟩ +- . apply IsSeqClosed.isClosed +- by_contra! +- simp [IsSeqClosed] at this +- obtain ⟨seq, seq_in, ⟨lim_seq, seq_tendsto_lim_seq, lim_seq_not_mem⟩⟩ := this +- +- by_cases lim_seq_invertible: IsUnit lim_seq.toLinearMap +- . +- -- If the limit (in the space of linear maps) is invertible, then the limit will also exist in the space +- -- of units, which will then imply that the limit exists in the space of linear maps. +- -- TODO - this probably can be a direct proof, rather than by contradiction +- obtain ⟨u, hu⟩ := lim_seq_invertible +- have closure_closed := Subgroup.isClosed_topologicalClosure my_new_range +- apply IsClosed.isSeqClosed at closure_closed +- dsimp [IsSeqClosed] at closure_closed +- +- have seq_units: ∀ n: ℕ, IsUnit (seq n) := by +- intro n +- obtain ⟨x, x_mem, seq_eq_x⟩ := (seq_in n) +- rw [← seq_eq_x] +- apply Units.isUnit +- +- have lim_units := closure_closed (x := fun n => (seq_units n).unit) (p := plain_linear_to_clm u) ?_ ?_ +- . +- specialize lim_seq_not_mem (plain_linear_to_clm u) lim_units +- conv at lim_seq_not_mem => +- arg 1 +- lhs +- equals u.val.toContinuousLinearMap => +- rfl +- rw [hu] at lim_seq_not_mem +- conv at lim_seq_not_mem => +- arg 1 +- lhs +- equals lim_seq => +- rfl +- simp at lim_seq_not_mem +- . intro n +- have seq_n := seq_in n +- obtain ⟨x, x_mem, seq_eq_x⟩ := seq_n +- simp_rw [← seq_eq_x] +- simpa using x_mem +- . +- rw [Topology.IsEmbedding.tendsto_nhds_iff (g := Units.val)] +- . +- conv => +- arg 1 +- equals seq => +- rfl +- +- have to_clm_u: plain_linear_to_clm u = u.val.toContinuousLinearMap := by +- rfl +- +- have u_val_eq_lim: u.val.toContinuousLinearMap = lim_seq := by +- rw [hu] +- rfl +- +- rw [to_clm_u, u_val_eq_lim] +- exact seq_tendsto_lim_seq +- . +- exact isembedding_units_val +- +- +- -- If the limit (in the space of linear maps) is not invertible, then it has a non-trivial kernel. +- rw [LinearMap.isUnit_iff_ker_eq_bot] at lim_seq_invertible +- apply Submodule.exists_mem_ne_zero_of_ne_bot at lim_seq_invertible +- obtain ⟨v, v_in_ker, v_ne_zero⟩ := lim_seq_invertible +- simp at v_in_ker +- +- +- have eval_at := Filter.Tendsto.eval_const seq_tendsto_lim_seq v +- have norm_tendsto := Continuous.tendsto (f := fun (x: W) => ‖x‖) (by fun_prop) (lim_seq v) +- have norm_seq_lim := Filter.Tendsto.comp norm_tendsto eval_at +- rw [v_in_ker] at norm_seq_lim +- rw [norm_zero] at norm_seq_lim +- conv at norm_seq_lim => +- arg 1 +- -- Use the fact that the action preserves the euclidian norm (maybe just up to a constant), +- -- so the sequence is actually constant +- equals fun x => ‖v‖ => +- funext n +- simp +- have seq_mem := seq_in n +- obtain ⟨x, x_mem, seq_eq_x⟩ := seq_mem +- rw [← seq_eq_x] +- apply ContinuousWithinAt.eq_const_of_mem_closure (f := fun (x: ((W) →L[ℝ] (W))ˣ) => ‖x.val v‖) (c := ‖v‖) (x := x) (s := my_new_range) +- . apply Continuous.continuousWithinAt +- fun_prop +- . exact x_mem +- . intro y hy +- simp [my_range] at hy +- obtain ⟨g, rep_g_eq_y⟩ := hy +- rw [← rep_g_eq_y] +- apply plain_linear_to_clm_preserves_norm +- +- -- TODO - why do we need this? +- have r_t2: T2Space ℝ := TopologicalSpace.t2Space_of_metrizableSpace +- +- have tendsto_norm_v := tendsto_const_nhds (α := ℕ) (f := Filter.atTop) (x := ‖v‖) +- have norm_v_zero := tendsto_nhds_unique tendsto_norm_v norm_seq_lim +- simp at norm_v_zero +- contradiction +- . +- simp +- apply LipschitzWith.isBounded_image (f := Units.val) (K := 1) +- . rw [lipschitzWith_iff_dist_le_mul] +- intro a b +- simp +- rfl +- . +- apply Bornology.IsBounded.closure +- rw [Metric.isBounded_iff_subset_ball 1] +- use 3 +- intro a ha +- simp [my_new_range] at ha +- obtain ⟨g, rep_g_eq_a⟩ := ha +- simp +- conv => +- lhs +- equals dist (a.val) (ContinuousLinearMap.id _ _) => +- rfl +- grw [dist_le_norm_add_norm (a.val) (ContinuousLinearMap.id ℝ W)] +- grw [ContinuousLinearMap.norm_id_le] +- rw [← rep_g_eq_a] +- grw [GRepW_norm_le] +- norm_num +- -- Bornology.isBounded_image_subtype_val +- . exact isembedding_units_val ++ have my_new_range_compact : CompactSpace my_new_range.topologicalClosure := ++ rho_continuous_range_compact + + + have continuous_new_map_entry: Continuous new_map_entry := by + simp [new_map_entry] + rw [Units.continuous_iff] + refine ⟨?_, ?_⟩ +- . fun_prop +- . fun_prop ++ · fun_prop ++ · fun_prop + + + have compact_mapped_group: CompactSpace mapped_group := by +@@ -456,169 +335,42 @@ lemma rho_g_contains_abelian {d: ℕ} (hd: HasPolynomialGrowthD S d) : ∃ M: Su + let data := theorem_3_8_real (H := mapped_group) compact_mapped_group ((Subgroup.map new_map_hom.toMonoidHom my_new_range).subgroupOf mapped_group) ?_ (final_data) + obtain ⟨B, B_abelian, B_finite_index⟩ := data + +- let reverse_hom: ((map new_map_hom.toMonoidHom my_new_range).subgroupOf mapped_group) →* (GRepW_base).range := { +- toFun := fun g => ( +- ((⟨Units.map (ContinuousLinearMap.toLinearMapRingHom.toMonoidHom) (new_map_hom.symm g.val), by ( +- simp +- have g_prop := g.property +- rw [Subgroup.mem_subgroupOf] at g_prop +- rw [Subgroup.mem_map] at g_prop +- obtain ⟨x, x_mem, g_eq⟩ := g_prop +- simp [my_new_range] at x_mem +- obtain ⟨a, ha⟩ := x_mem +- use a +- ext f +- simp +- apply_fun (fun h => Units.map (ContinuousLinearMap.toLinearMapRingHom.toMonoidHom) h) at ha +- simp [GRepW] at ha +- rw [ha] +- simp [new_map_hom, new_map_entry_inv] +- rw [← g_eq] +- simp [new_map_hom, new_map_entry] +- )⟩) : GRepW_base.range) +- ), +- map_one' := by +- simp [map_one] +- map_mul' := by +- intro a b +- apply Subtype.ext +- show (Units.map _) (new_map_hom.symm ↑↑(a * b)) = +- (Units.map _) (new_map_hom.symm ↑↑a) * (Units.map _) (new_map_hom.symm ↑↑b) +- rw [← map_mul (Units.map _), ← map_mul new_map_hom.symm] +- norm_cast +- } +- +- have reverse_hom_ker_bot: reverse_hom.ker = ⊥ := by ++ have hinj : Function.Injective GRepW := by ++ intro x y h ++ apply Units.ext ++ apply LinearMap.ext ++ intro v ++ have hval := congrArg (fun u : (W →L[ℝ] W)ˣ => u.val v) h ++ simpa [GRepW, linearUnitsToContinuous] using hval ++ let e₁ := Subgroup.equivMapOfInjective GRepW_base.range GRepW hinj ++ let e₂ := MulEquiv.subgroupCongr (MonoidHom.map_range GRepW GRepW_base) ++ let e₃ := MulEquiv.subgroupMap new_map_hom my_new_range ++ let e := ((e₁.trans e₂).trans e₃).trans map_sub_equiv ++ let reverse_hom := e.symm.toMonoidHom ++ have reverse_hom_ker_bot : reverse_hom.ker = ⊥ := by + rw [MonoidHom.ker_eq_bot_iff] +- intro a b hab +- simp only [reverse_hom, MonoidHom.coe_mk, OneHom.coe_mk, Subtype.mk.injEq] at hab +- apply Units.map_injective at hab +- . +- replace hab := new_map_hom.symm.injective hab +- exact Subtype.ext (Subtype.ext hab) +- . +- intro a b hab +- simpa using hab +- +- have reverse_hom_range_top: reverse_hom.range = ⊤ := by +- rw [Subgroup.eq_top_iff'] +- intro x +- have x_prop := x.property +- rw [MonoidHom.mem_range] at x_prop +- obtain ⟨g, hg⟩ := x_prop +- have mem_range: plain_linear_to_clm ↑x ∈ my_new_range := by +- refine MonoidHom.mem_range.mpr ⟨g, ?_⟩ +- rw [← hg] +- rfl +- have mem_closure: plain_linear_to_clm ↑x ∈ my_new_range.topologicalClosure := +- Subgroup.le_topologicalClosure my_new_range mem_range +- refine MonoidHom.mem_range.mpr +- ⟨⟨⟨new_map_entry (plain_linear_to_clm ↑x), +- Subgroup.mem_map_of_mem new_map_hom.toMonoidHom mem_closure⟩, ?_⟩, ?_⟩ +- . +- rw [Subgroup.mem_subgroupOf] +- exact Subgroup.mem_map_of_mem new_map_hom.toMonoidHom mem_range +- . +- have hrt : ∀ y, new_map_hom.symm (new_map_entry y) = y := new_map_hom.left_inv +- refine Subtype.ext ?_ +- change (Units.map (ContinuousLinearMap.toLinearMapRingHom (R₁ := ℝ) (M₁ := W)).toMonoidHom) +- (new_map_hom.symm (new_map_entry (plain_linear_to_clm ↑x))) = x.val +- rw [hrt] +- ext f +- rfl +- ++ exact e.symm.injective ++ have reverse_hom_range_top : reverse_hom.range = ⊤ := ++ MonoidHom.range_eq_top.mpr e.symm.surjective + + let B' := Subgroup.map reverse_hom B + use B' + refine ⟨?_, ?_⟩ +- . simp only [B'] ++ · simp only [B'] + apply Subgroup.map_isMulCommutative +- . simp only [B'] ++ · simp only [B'] + rw [Subgroup.finiteIndex_iff] + rw [Subgroup.index_map] + rw [reverse_hom_ker_bot, reverse_hom_range_top, sup_bot_eq, Subgroup.index_top, mul_one] + exact B_finite_index.index_ne_zero +- . +- have base_fg: (map new_map_hom.toMonoidHom my_new_range).FG := by +- apply group_fg_map +- simp [my_new_range] +- have group_fg: Group.FG (GRepW.comp (GRepW_base)).range := by +- apply Group.fg_range +- exact (Group.fg_iff_subgroup_fg (GRepW.comp GRepW_base).range).mp group_fg +- +- have base_le: (map new_map_hom.toMonoidHom my_new_range) ≤ mapped_group := by +- intro a ha +- simp at ha +- simp [mapped_group] +- obtain ⟨g, g_mem, g_eq_a⟩ := ha +- use g +- refine ⟨?_, g_eq_a⟩ +- apply Subgroup.le_topologicalClosure my_new_range g_mem +- +- +- rw [Subgroup.fg_iff] +- rw [Subgroup.fg_iff] at base_fg +- obtain ⟨S, S_eq, S_finite⟩ := base_fg +- +- have S_in_map: ∀ s ∈ S, s ∈ (map new_map_hom.toMonoidHom my_new_range) := by +- rw [Subgroup.ext_iff] at S_eq +- intro s hs +- apply (S_eq s).mp ?_ +- exact Subgroup.mem_closure.mpr fun K a ↦ a hs +- +- let S' := Set.range (fun (s: S) => (⟨s.val, base_le (S_in_map s s.property)⟩ : mapped_group)) +- use S' +- -- TODO - this is a huge mess. This can be a general proof about the closure of Subgroup.subgroupOf +- refine ⟨?_, ?_⟩ +- . +- simp only [S'] +- rw [← S_eq] +- ext a +- refine ⟨?_, ?_⟩ +- . intro ha +- rw [Subgroup.mem_subgroupOf] +- induction ha using Subgroup.closure_induction_left with +- | one => simp +- | mul_left y hy z hz h_other_z => +- simp +- apply Subgroup.mul_mem +- . simp at hy +- obtain ⟨p, p_mem, p_eq_y⟩ := hy +- rw [← p_eq_y] +- simp +- apply Subgroup.mem_closure_of_mem p_mem +- . exact h_other_z +- | inv_mul_cancel y hy z hz h_other_z => +- simp +- apply Subgroup.mul_mem +- . simp +- simp at hy +- obtain ⟨p, p_mem, p_eq_y⟩ := hy +- rw [← p_eq_y] +- simp +- apply Subgroup.mem_closure_of_mem p_mem +- . exact h_other_z +- . intro ha +- rw [Subgroup.mem_subgroupOf] at ha +- rw [Subgroup.mem_closure] +- intro K hK +- rw [Subgroup.mem_closure] at ha +- have a_mem := ha (Subgroup.map mapped_group.subtype K) ?_ +- . simpa using a_mem +- . simp +- intro s hs +- rw [Set.range_subset_iff] at hK +- have s_mem := hK ⟨s, hs⟩ +- simp +- simp at s_mem +- use ?_ +- apply base_le (S_in_map s hs) +- . +- simp [S'] +- rw [← Set.finite_coe_iff] at S_finite +- apply Set.finite_range ++ · let : Group.FG my_new_range := Group.fg_range (GRepW.comp GRepW_base) ++ let : Group.FG (Subgroup.map new_map_hom.toMonoidHom my_new_range) := ++ Group.fg_of_surjective (f := (MulEquiv.subgroupMap new_map_hom my_new_range).toMonoidHom) ++ (MulEquiv.subgroupMap new_map_hom my_new_range).surjective ++ let : Group.FG ((Subgroup.map new_map_hom.toMonoidHom my_new_range).subgroupOf mapped_group) := ++ Group.fg_of_surjective (f := map_sub_equiv.toMonoidHom) map_sub_equiv.surjective ++ exact (Group.fg_iff_subgroup_fg _).mp inferInstance + +--- We need this to work with Finset + + structure Theorem3_1_Input (G: Type*) [Group G] where + -- A finite index subgroup G' of G +@@ -629,15 +381,7 @@ structure Theorem3_1_Input (G: Type*) [Group G] where + hφ: Function.Surjective φ + + +-#synth Group.FG (rho_g) +- +- + lemma g_hom_abelian {T: Type*} [Group T] (A: Subgroup G) (A_finite_index: A.FiniteIndex) (hom: A →* T) (hom_surjective: Function.Surjective hom) (H: Subgroup T) (H_infinite: Infinite H) (H_abeliean: IsMulCommutative H) (H_finite_index: H.FiniteIndex) (H_FG: Group.FG H): Nonempty (Theorem3_1_Input G) := by +- -- TODO - generalize this to a lemma: finite-index subgroup of an infinite group is infinite +- -- and upstream to mathlib +- +- +- -- TODO - figure out how to make instance inference work here + obtain ⟨i, j, i_fin, j_fin, p, p_prime, e, exists_iso⟩ := @CommGroup.equiv_free_prod_prod_multiplicative_zmod H (haveI := H_abeliean; { (inferInstance : Group H) with mul_comm := mul_comm' }) (H_FG) + have iso := Classical.choice exists_iso + +@@ -661,8 +405,6 @@ lemma g_hom_abelian {T: Type*} [Group T] (A: Subgroup G) (A_finite_index: A.Fini + apply Finite.instProd + have no_finite := H_infinite.not_finite + contradiction +- +- -- TODO - can we get the comp '∘' syntax to give us a monoid hom, instead of a plain function? + let h_to_z := (Pi.evalMonoidHom _ (Classical.choice (by + exact j_nonempty + ))).comp ((MonoidHom.fst _ _).comp iso.toMonoidHom) +@@ -671,19 +413,17 @@ lemma g_hom_abelian {T: Type*} [Group T] (A: Subgroup G) (A_finite_index: A.Fini + unfold h_to_z + simp + apply Function.Surjective.comp +- . ++ · + intro x + simp + use fun _ => x +- . apply Function.Surjective.comp +- . exact Prod.fst_surjective +- . exact iso.surjective ++ · apply Function.Surjective.comp ++ · exact Prod.fst_surjective ++ · exact iso.surjective + + + let G' := Subgroup.comap hom H + +- -- TODO - generalize this and PR to mathlib +- + + have G'_finite_index: G'.FiniteIndex := by + unfold G' +@@ -691,15 +431,10 @@ lemma g_hom_abelian {T: Type*} [Group T] (A: Subgroup G) (A_finite_index: A.Fini + index_ne_zero := by + simp + rw [Subgroup.index_comap] +- -- apply somehow found this - how does it work??? + exact Subgroup.FiniteIndex.index_ne_zero + } +- +- +- -- TODO - there must be an easier way to do this + let g'_to_h: (map A.subtype G') →* H := { + toFun := fun g => ⟨hom ⟨g.val, by ( +- -- TODO - clean this up + have foo := g.property + rw [Subgroup.mem_map] at foo + obtain ⟨x, hx, a_subtype⟩ := foo +@@ -707,7 +442,7 @@ lemma g_hom_abelian {T: Type*} [Group T] (A: Subgroup G) (A_finite_index: A.Fini + simp + )⟩, by ( + have g_prop := g.property +- simp only [G', Subgroup.mem_comap] at g_prop ++ simp only [G'] at g_prop + rw [Subgroup.mem_map] at g_prop + obtain ⟨x, hx, a_subtype⟩ := g_prop + simp_rw [← a_subtype] +@@ -748,18 +483,18 @@ lemma g_hom_abelian {T: Type*} [Group T] (A: Subgroup G) (A_finite_index: A.Fini + rw [Subgroup.finiteIndex_iff] + simp [Subgroup.index_map_subtype] + refine ⟨?_, ?_⟩ +- . rw [← ne_eq] ++ · rw [← ne_eq] + rw [← Subgroup.finiteIndex_iff] + exact G'_finite_index +- . exact A_finite_index.index_ne_zero ++ · exact A_finite_index.index_ne_zero + -- G'_finite_index + φ := g_to_z, + hφ := by + simp [g_to_z, g_to_additive_z] + apply Function.Surjective.comp +- . simp [additive_h_to_z] ++ · simp [additive_h_to_z] + exact h_to_z_surjective +- . ++ · + simp [additive_g'_to_h, g'_to_h] + intro h + obtain ⟨a, hom_a⟩ := hom_surjective h +@@ -769,7 +504,6 @@ lemma g_hom_abelian {T: Type*} [Group T] (A: Subgroup G) (A_finite_index: A.Fini + simp [G', hom_a] + } + +-#print axioms g_hom_abelian + + -- Case 1 in Section 3.3 of Vikman, where the representation ρ(G) is infinite + lemma rho_g_case_infinite {d: ℕ} (hd: HasPolynomialGrowthD S d) (hr: Infinite (↥(rho_g))): Nonempty (Theorem3_1_Input G) := by +@@ -785,11 +519,11 @@ lemma rho_g_case_infinite {d: ℕ} (hd: HasPolynomialGrowthD S d) (hr: Infinite + + + have target := g_hom_abelian ⊤ (by infer_instance) (g_rho) ?_ (H) ?_ ?_ ?_ ?_ +- . exact target +- . ++ · exact target ++ · + simp [g_rho] + exact MonoidHom.rangeRestrict_surjective GRepW_base +- . ++ · + unfold rho_g at hr + have card_mul := Subgroup.card_mul_index H + unfold rho_g at card_mul +@@ -798,10 +532,9 @@ lemma rho_g_case_infinite {d: ℕ} (hd: HasPolynomialGrowthD S d) (hr: Infinite + replace card_mul := card_mul.resolve_right H_finite_index.index_ne_zero + rw [Nat.card_eq_zero] at card_mul + exact card_mul.resolve_left (fun h => h.false ⟨1, H.one_mem⟩) +- . exact H_abelian +- . exact H_finite_index +- . exact h_fg ++ · exact H_abelian ++ · exact H_finite_index ++ · exact h_fg + +-#print axioms rho_g_case_infinite + + end GeneratesNS +diff --git a/Gromov/Theorem31Input.lean b/Gromov/Theorem31Input.lean +index 22f01cc..81b7985 100644 +--- a/Gromov/Theorem31Input.lean ++++ b/Gromov/Theorem31Input.lean +@@ -11,9 +11,6 @@ The finite-image case `rho_g_case_finite` and `exists_theorem_3_1_input`. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +@@ -28,24 +25,12 @@ include hGS + + open scoped RealInnerProductSpace + +-set_option synthInstance.maxHeartbeats 500000 + +-set_option maxHeartbeats 9000000 + + open MeasureTheory + + open MeasureTheory + +--- TODO - figure out why we need these +- +- +-#print axioms laplace_bounded +-#print axioms laplace_self_adjoint +-#print axioms laplace_positive_semidefinite +- +- +-#synth Module ℝ (Lp ℝ 2 (μ := MeasureTheory.volume (α := G))) +- + + omit hGS in + lemma rangeRestrict_range {A B: Type*} [Group A] [Group B] (f: A →* B): f.rangeRestrict.range = ⊤ := by +@@ -99,8 +84,6 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + simp [lambda_g] + rw [mul_sub] + } +- +- -- TODO - this could be much cleaner + have act_eq_lambda (g: G) (hg: g ∈ (GRepW_base).ker) (f: LipschitzH ): (gAct g f) = f + ConstLipschitzH (lambda_g ⟨g, hg⟩ f) := by + have act := act_v g hg f + simp [GRep, gAct, ConstF] at act +@@ -116,8 +99,8 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + apply eq_add_of_sub_eq at app_a + rw [app_a] + rw [add_comm] +- simp [LipschitzH_apply] +- simp [LipschitzH_apply] at hy ++ simp ++ simp at hy + have other_app := congrFun hy 1 + simp at other_app + rw [← other_app] +@@ -152,24 +135,23 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + } + + by_cases lambda_g_infinite: Infinite (lambda_g_hom.range) +- . ++ · + + apply g_hom_abelian G' ?_ lambda_g_hom.rangeRestrict ?_ lambda_g_hom.rangeRestrict.range ?_ ?_ ?_ ?_ +- . simp [G'] ++ · simp [G'] + exact ker_finite_index +- . exact MonoidHom.rangeRestrict_surjective lambda_g_hom +- . rw [rangeRestrict_range] ++ · exact MonoidHom.rangeRestrict_surjective lambda_g_hom ++ · rw [rangeRestrict_range] + simp +- -- TODO: PR this to mathlib + apply (Equiv.infinite_iff (α := lambda_g_hom.range) _).mp +- . exact lambda_g_infinite +- . exact { ++ · exact lambda_g_infinite ++ · exact { + toFun := fun g => ⟨g, trivial⟩ + invFun := fun g => g.val + left_inv := by simp [Function.LeftInverse] + right_inv := by simp [Function.RightInverse, Function.LeftInverse] + } +- . exact { ++ · exact { + is_comm := { + comm := by + intro a b +@@ -178,18 +160,16 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + rw [add_comm] + } + } +- . rw [Subgroup.finiteIndex_iff] ++ · rw [Subgroup.finiteIndex_iff] + rw [rangeRestrict_range] + simp +- . rw [rangeRestrict_range] ++ · rw [rangeRestrict_range] + simp + exact Group.FG.out +- . ++ · + simp only [not_infinite_iff_finite] at lambda_g_infinite + let G'' := lambda_g_hom.ker + have G''_finite_index := Subgroup.finiteIndex_ker lambda_g_hom +- +- -- TODO - this could be a lot cleaner + have G''_act_v (g: lambda_g_hom.ker) (x: G) (f: LipschitzH ): f (x * g) = f x := by + specialize act_v g + simp at act_v +@@ -224,8 +204,6 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + + -- View G'' as a subgroup of G + let G''_subgroup_G := (Subgroup.map G'.subtype lambda_g_hom.ker) +- +- -- TODO - clean up this proof + have G''_subgroup_finite_index: G''_subgroup_G.FiniteIndex := by + unfold G''_subgroup_G + rw [Subgroup.finiteIndex_iff] +@@ -244,7 +222,7 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + have f_range_eq (f: LipschitzH ): Set.range f = Set.range ((fun (x: G ⧸ G''_subgroup_G) => f (x.out))) := by + ext a + refine ⟨?_, ?_⟩ +- . intro ha ++ · intro ha + simp at ha + obtain ⟨y, hy⟩ := ha + have y_mem: y ∈ Set.univ := by simp +@@ -270,7 +248,7 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + use i + rw [← f_translate] + exact hy +- . intro ha ++ · intro ha + simp only [Set.mem_range] at ha + obtain ⟨y, hy⟩ := ha + simp +@@ -287,16 +265,16 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + simp at hp + obtain ⟨y, hy⟩ := hp + by_cases p_le_z: ‖p‖ ≤ ‖z‖ +- . exact p_le_z +- . simp at p_le_z ++ · exact p_le_z ++ · simp at p_le_z + + have f_le := hz (j := f.toFun y) ?_ ?_ +- . ++ · + simp at f_le + rw [← hy] + exact f_le +- . simp +- . simp ++ · simp ++ · simp + rw [← hy] at p_le_z + linarith + +@@ -326,22 +304,19 @@ lemma rho_g_case_finite (hr: Finite (↥(rho_g))): Nonempty (Theorem3_1_Input G) + have app := congrFun f_const_fn a + rw [app] + simp [ConstLipschitzH] +- . ++ · + rw [f_range_eq] + apply Set.finite_range +- . apply Set.range_nonempty ++ · apply Set.range_nonempty + + obtain ⟨f, nontrivial_f⟩ := exists_nontrivial_harmonic + obtain ⟨z, f_eq_const⟩ := all_f_const f + specialize nontrivial_f z + contradiction +- +- +--- TODO - upstream to mathlib + omit hGS in + lemma exists_theorem_3_1_input [hGS: Generates ] {d: ℕ} (hd: HasPolynomialGrowthD S d): Nonempty (Theorem3_1_Input G) := by + by_cases rho_g_infinite: Infinite (↥(rho_g)) +- . exact rho_g_case_infinite hd rho_g_infinite +- . exact rho_g_case_finite (by simpa using rho_g_infinite) ++ · exact rho_g_case_infinite hd rho_g_infinite ++ · exact rho_g_case_finite (by simpa using rho_g_infinite) + + end GeneratesNS +diff --git a/Gromov/Theorem323.lean b/Gromov/Theorem323.lean +index 0e1604a..8741f01 100644 +--- a/Gromov/Theorem323.lean ++++ b/Gromov/Theorem323.lean +@@ -9,17 +9,10 @@ public import Gromov.BoundedDoubling + `theorem_3_23` and the resulting finite-dimensionality of the space of Lipschitz harmonic + functions. + +-Root of the Theorem 3.23 hierarchy: importing it pulls in the cutoff inequality, the quadratic +-form, the packing argument and the Poincaré inequality. + -/ + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -30,7 +23,186 @@ open Generates + variable [hGS: Generates] + include hGS + +-set_option maxHeartbeats 2500000 in ++private lemma scale_contraction_bound (d w : ℕ) ++ (hw : w = ⌈Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a d))⌉₊) : ++ GeneratesNS.C * Real.exp (a d * 2) ^ 2 * (16 ^ (-↑w : ℝ)) ^ 2 * ↑(#S) ++ * 16 ≤ 2⁻¹ := by ++ have ha : (0:ℝ) ≤ a d := by simp only [a]; positivity ++ have hE1 : (1:ℝ) ≤ Real.exp (a d) := Real.one_le_exp ha ++ have hE4 : (1:ℝ) ≤ Real.exp (a d) ^ 4 := one_le_pow₀ hE1 ++ have hEpos : (0:ℝ) < Real.exp (a d) := Real.exp_pos _ ++ have he4 : Real.exp (4 * a d) = Real.exp (a d) ^ 4 := by ++ rw [← Real.exp_nat_mul]; norm_num ++ have he2 : Real.exp (a d * 2) = Real.exp (a d) ^ 2 := by ++ rw [show a d * 2 = 2 * a d from by ring, ← Real.exp_nat_mul]; norm_num ++ have he2sq : Real.exp (a d * 2) ^ 2 = Real.exp (a d) ^ 4 := by ++ rw [he2]; ring ++ have hS0 : (0:ℝ) < ↑(#S) := by exact_mod_cast Finset.card_pos.mpr S_nonempty ++ have hXpos : (0:ℝ) < 16 ^ 4 * ↑(#S) * Real.exp (a d) ^ 4 := by positivity ++ have h16w : (16:ℝ) ^ 4 * ↑(#S) * Real.exp (a d) ^ 4 ≤ (16:ℝ) ^ (↑w : ℝ) := by ++ rw [← he4] ++ have hlog : (16:ℝ) ^ Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a d)) ++ = 16 ^ 4 * ↑(#S) * Real.exp (4 * a d) := ++ Real.rpow_logb (by norm_num) (by norm_num) (by rw [he4]; exact hXpos) ++ have hle : Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a d)) ≤ (↑w : ℝ) := by ++ have hdef : w = ⌈Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a d))⌉₊ := hw ++ rw [hdef]; exact_mod_cast Nat.le_ceil _ ++ calc 16 ^ 4 * ↑(#S) * Real.exp (4 * a d) ++ = (16:ℝ) ^ Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a d)) := hlog.symm ++ _ ≤ (16:ℝ) ^ (↑w : ℝ) := Real.rpow_le_rpow_of_exponent_le (by norm_num) hle ++ have ht0 : (0:ℝ) ≤ (16:ℝ) ^ (-↑w : ℝ) := Real.rpow_nonneg (by norm_num) _ ++ have htX : (16:ℝ) ^ (-↑w : ℝ) * (16 ^ 4 * ↑(#S) * Real.exp (a d) ^ 4) ≤ 1 := by ++ calc (16:ℝ) ^ (-↑w : ℝ) * (16 ^ 4 * ↑(#S) * Real.exp (a d) ^ 4) ++ ≤ (16:ℝ) ^ (-↑w : ℝ) * (16:ℝ) ^ (↑w : ℝ) := ++ mul_le_mul_of_nonneg_left h16w ht0 ++ _ = 1 := by rw [← Real.rpow_add (by norm_num)]; simp ++ have hsq : ((16:ℝ) ^ (-↑w : ℝ) * (16 ^ 4 * ↑(#S) * Real.exp (a d) ^ 4)) ^ 2 ≤ 1 := by ++ nlinarith [htX, mul_nonneg ht0 (le_of_lt hXpos)] ++ have hM8 : (0:ℝ) ≤ ((16:ℝ) ^ (-↑w : ℝ)) ^ 2 * (↑(#S)) ^ 2 * Real.exp (a d) ^ 4 * 16 ^ 8 := by ++ positivity ++ have hP : ((16:ℝ) ^ (-↑w : ℝ)) ^ 2 * (↑(#S)) ^ 2 * Real.exp (a d) ^ 4 * 16 ^ 8 ≤ 1 := by ++ nlinarith [hsq, hE4, hM8] ++ have key : GeneratesNS.C * Real.exp (a d * 2) ^ 2 * (16 ^ (-↑w : ℝ)) ^ 2 * ↑(#S) ++ * 16 ≤ 2⁻¹ := by ++ rw [he2sq]; simp only [GeneratesNS.C] ++ nlinarith [hP, hM8] ++ exact key ++ ++private lemma phi_restrict_injective [v_data : V_Wrapper] ++ (data : GoodScalesData (V_basis v_data.V)) ++ (hw : data.w = ⌈Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a data.d))⌉₊) ++ (U : Submodule ℝ LipschitzH) ++ (bounded_double : ∀ f ∈ U, Q_R (16 * R_2 data) f f ≤ ++ Real.exp (2 * a data.d) * Q_R (R_2 data) f f) : ++ Function.Injective ((phi data).domRestrict (U.submoduleOf v_data.V)) := by ++ -- Pinning the module types keeps this rewrite out of the instance diamond on ++ -- `↥(U.submoduleOf _)` (`Submodule…addCommMonoid` vs `AddCommGroup.toAddCommMonoid`), ++ -- which otherwise only reconciles at a raised `maxSynthPendingDepth`. ++ rw [← LinearMap.ker_eq_bot (M := ↥(U.submoduleOf v_data.V)) ++ (M₂ := EuclideanSpace ℝ ↥(B_finsets data))] ++ rw [LinearMap.ker_eq_bot' (M := ↥(U.submoduleOf v_data.V)) ++ (M₂ := EuclideanSpace ℝ ↥(B_finsets data))] ++ intro u hu ++ ++ have u_le := lemma_3_26_a data u ++ simp at hu ++ simp [hu] at u_le ++ ++ have u_bound := harmonic_r2_inequality u (by ++ have u_prop := u.val.val.harmonic ++ simp [Harmonic] at u_prop ++ simp [Laplace_b] ++ ext a ++ simp ++ nth_rw 1 [u_prop] ++ simp [f_conv_mu] ++ ) (4 * R_2 data) (by simp [R_2]) ++ simp [B_r] at u_le ++ conv at u_bound => ++ lhs ++ arg 1 ++ equals (Metric.closedBall 1 (8 * (R_2 data))).toFinset => ++ simp ++ ring_nf ++ ++ grw [u_bound] at u_le ++ · ++ have u_double := bounded_double u (by ++ exact u.prop ++ ) ++ conv at u_double => ++ lhs ++ simp [Q_R] ++ ++ simp_rw [← pow_two] at u_double ++ grw [Finset.sum_le_sum_of_subset_of_nonneg (t := (finite_closed_ball 1 (16 * (R_2 data))).toFinset)] at u_le ++ · ++ simp at u_le ++ grw [u_double] at u_le ++ · ++ by_cases u_zero: u = 0 ++ · exact u_zero ++ · ++ have r_pos := R'_pos v_data.V ++ have r_ratio_le: (R_1 data + 1) / (4 * R_2 data) ≤ 4 * ((16: ℝ) ^ (-(data.w : ℝ))) := by ++ simp [R_1, R_2] ++ field_simp ++ have i_diff := (GoodScales data).i_diff_mem ++ simp at i_diff ++ have one_le: (1: ℝ) ≤ 2*(16^((GoodScales data).i_1)) := by ++ apply one_le_mul_of_one_le_of_one_le ++ · simp ++ · rw [one_le_pow_iff_of_nonneg] ++ · simp ++ · simp ++ · simp ++ have h_i := (GoodScales data).i_1_pos ++ grind ++ grw [one_le] ++ rw [← mul_add] ++ rw [← two_mul] ++ ring_nf ++ rw [← pow_add] ++ apply mul_le_mul ++ · ++ rw [pow_le_pow_iff_right₀] ++ · grind ++ · simp ++ · norm_num ++ · simp ++ · simp ++ ++ conv at u_le => ++ rhs ++ equals GeneratesNS.C * Real.exp (2 * a data.d) * (((↑(R_1 data) + 1) / ((↑(4 * R_2 data : ℝ))))^2 * ↑(#S) * (Real.exp (2 * a data.d) * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val)) => ++ ring ++ ++ grw [r_ratio_le] at u_le ++ ring_nf at u_le ++ · ++ have le_half: Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val ≤ (2: ℝ)⁻¹ * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := by ++ have qr_nonneg : 0 ≤ Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := ++ Q_R_self_nonneg _ _ ++ have key := scale_contraction_bound data.d data.w hw ++ calc Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val ++ ≤ (GeneratesNS.C * Real.exp (a data.d * 2) ^ 2 * (16 ^ (-↑data.w : ℝ)) ^ 2 * ↑(#S) ++ * 16) * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := by nlinarith [u_le] ++ _ ≤ 2⁻¹ * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := by nlinarith [key, qr_nonneg] ++ ++ have Q_r_zero: Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val = 0 := by ++ by_contra! ++ rw [mul_comm] at le_half ++ have foo := one_le_of_le_mul_left₀ (by ++ have nonneg: 0 ≤ Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := ++ Q_R_self_nonneg _ _ ++ grind ++ ) le_half ++ norm_num at foo ++ ++ rw [← Submodule.coe_eq_zero] ++ by_contra hne ++ exact absurd Q_r_zero (ne_of_gt (Q_R_pos_on_R' (↑u) hne _ (R'_le_R_2 data))) ++ · apply mul_nonneg (by positivity) ++ exact Q_R_self_nonneg _ _ ++ · simp [GeneratesNS.C] ++ positivity ++ ++ · simp [GeneratesNS.C] ++ positivity ++ · ++ simp [GeneratesNS.C] ++ positivity ++ · intro a ha ++ simp ++ simp at ha ++ grind ++ · intro i hi _ ++ positivity ++ · ++ simp [GeneratesNS.C] ++ positivity ++ ++ + lemma theorem_3_23 (d: ℕ) (hd: 0 < d): ∃ C: ℕ, ∀ v_data: V_Wrapper, growth_bound (V_basis v_data.V) d → (Module.finrank ℝ v_data.V) < C := by + let w := ⌈Real.logb 16 ((16^4) * #(S) * Real.exp (4 * a (d)))⌉₊ + let C: ℕ := 1 + (⌈2 * Real.exp (w * (a d))⌉₊) +@@ -43,16 +215,16 @@ lemma theorem_3_23 (d: ℕ) (hd: 0 < d): ∃ C: ℕ, ∀ v_data: V_Wrapper, grow + hw := by + simp + apply Real.logb_pos +- . simp +- . apply one_lt_mul +- . ++ · simp ++ · apply one_lt_mul ++ · + have card_s: 1 ≤ #(S) := by + simp + apply S_nonempty + grw [← card_s] + simp + norm_num +- . ++ · + norm_num + simp [a] + positivity +@@ -61,16 +233,16 @@ lemma theorem_3_23 (d: ℕ) (hd: 0 < d): ∃ C: ℕ, ∀ v_data: V_Wrapper, grow + rw [Nat.lt_ceil] + simp + rw [Real.lt_logb_iff_rpow_lt] +- . ++ · + have mul_pos: 1 < ↑(#S) * Real.exp (4 * a d) := by + apply one_lt_mul +- . simp ++ · simp + apply S_nonempty +- . simp [a] ++ · simp [a] + positivity + linarith +- . simp +- . have S_ne: #(S) ≠ 0 := by ++ · simp ++ · have S_ne: #(S) ≠ 0 := by + have foo := S_card_ne_zero_re + simpa using foo + positivity +@@ -80,172 +252,7 @@ lemma theorem_3_23 (d: ℕ) (hd: 0 < d): ∃ C: ℕ, ∀ v_data: V_Wrapper, grow + obtain ⟨U, U_sub_v, hU_dim, bounded_double⟩ := exists_bounded_doubling_subspace data + + let phi_u := (phi data).domRestrict (U.submoduleOf v_data.V) +- have phi_u_inj: Function.Injective phi_u := by +- -- Pinning the module types keeps this rewrite out of the instance diamond on +- -- `↥(U.submoduleOf _)` (`Submodule…addCommMonoid` vs `AddCommGroup.toAddCommMonoid`), +- -- which otherwise only reconciles at a raised `maxSynthPendingDepth`. +- rw [← LinearMap.ker_eq_bot (M := ↥(U.submoduleOf v_data.V)) +- (M₂ := EuclideanSpace ℝ ↥(B_finsets data))] +- rw [LinearMap.ker_eq_bot' (M := ↥(U.submoduleOf v_data.V)) +- (M₂ := EuclideanSpace ℝ ↥(B_finsets data))] +- intro u hu +- +- have u_le := lemma_3_26_a data u +- simp [phi_u] at hu +- simp [hu] at u_le +- +- have u_bound := harmonic_r2_inequality u (by +- have u_prop := u.val.val.harmonic +- simp [Harmonic] at u_prop +- simp [Laplace_b] +- ext a +- simp +- nth_rw 1 [u_prop] +- simp [f_conv_mu] +- ) (4 * R_2 data) (by simp [R_2]) +- simp [B_r] at u_le +- conv at u_bound => +- lhs +- arg 1 +- equals (Metric.closedBall 1 (8 * (R_2 data))).toFinset => +- simp +- ring +- +- grw [u_bound] at u_le +- . +- have u_double := bounded_double u (by +- exact u.prop +- ) +- conv at u_double => +- lhs +- simp [Q_R] +- +- simp_rw [← pow_two] at u_double +- grw [Finset.sum_le_sum_of_subset_of_nonneg (t := (finite_closed_ball 1 (16 * (R_2 data))).toFinset)] at u_le +- . +- simp [finite_closed_ball] at u_le +- grw [u_double] at u_le +- . +- by_cases u_zero: u = 0 +- . exact u_zero +- . +- have r_pos := R'_pos v_data.V +- have r_ratio_le: (R_1 data + 1) / (4 * R_2 data) ≤ 4 * ((16: ℝ) ^ (-(data.w : ℝ))) := by +- simp [R_1, R_2] +- field_simp +- have i_diff := (GoodScales data).i_diff_mem +- simp at i_diff +- have one_le: (1: ℝ) ≤ 2*(16^((GoodScales data).i_1)) := by +- norm_num +- apply one_le_mul_of_one_le_of_one_le +- . simp +- . rw [one_le_pow_iff_of_nonneg] +- . simp +- . simp +- . simp +- have h_i := (GoodScales data).i_1_pos +- grind +- grw [one_le] +- rw [← mul_add] +- rw [← two_mul] +- ring +- rw [← pow_add] +- apply mul_le_mul +- . +- rw [pow_le_pow_iff_right₀] +- . grind +- . simp +- . norm_num +- . simp +- . simp +- +- conv at u_le => +- rhs +- equals GeneratesNS.C * Real.exp (2 * a data.d) * (((↑(R_1 data) + 1) / ((↑(4 * R_2 data : ℝ))))^2 * ↑(#S) * (Real.exp (2 * a data.d) * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val)) => +- ring +- +- grw [r_ratio_le] at u_le +- ring_nf at u_le +- . +- have le_half: Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val ≤ (2: ℝ)⁻¹ * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := by +- have qr_nonneg : 0 ≤ Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := +- Q_R_self_nonneg _ _ +- have ha : (0:ℝ) ≤ a data.d := by simp only [a]; positivity +- have hE1 : (1:ℝ) ≤ Real.exp (a data.d) := Real.one_le_exp ha +- have hE4 : (1:ℝ) ≤ Real.exp (a data.d) ^ 4 := one_le_pow₀ hE1 +- have hEpos : (0:ℝ) < Real.exp (a data.d) := Real.exp_pos _ +- have he4 : Real.exp (4 * a data.d) = Real.exp (a data.d) ^ 4 := by +- rw [← Real.exp_nat_mul]; norm_num +- have he2 : Real.exp (a data.d * 2) = Real.exp (a data.d) ^ 2 := by +- rw [show a data.d * 2 = 2 * a data.d from by ring, ← Real.exp_nat_mul]; norm_num +- have he2sq : Real.exp (a data.d * 2) ^ 2 = Real.exp (a data.d) ^ 4 := by +- rw [he2]; ring +- have hS0 : (0:ℝ) < ↑(#S) := by exact_mod_cast Finset.card_pos.mpr S_nonempty +- have hXpos : (0:ℝ) < 16 ^ 4 * ↑(#S) * Real.exp (a data.d) ^ 4 := by positivity +- have h16w : (16:ℝ) ^ 4 * ↑(#S) * Real.exp (a data.d) ^ 4 ≤ (16:ℝ) ^ (↑data.w : ℝ) := by +- rw [← he4] +- have hlog : (16:ℝ) ^ Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a data.d)) +- = 16 ^ 4 * ↑(#S) * Real.exp (4 * a data.d) := +- Real.rpow_logb (by norm_num) (by norm_num) (by rw [he4]; exact hXpos) +- have hle : Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a data.d)) ≤ (↑data.w : ℝ) := by +- have hdef : data.w = ⌈Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a data.d))⌉₊ := rfl +- rw [hdef]; exact_mod_cast Nat.le_ceil _ +- calc 16 ^ 4 * ↑(#S) * Real.exp (4 * a data.d) +- = (16:ℝ) ^ Real.logb 16 (16 ^ 4 * ↑(#S) * Real.exp (4 * a data.d)) := hlog.symm +- _ ≤ (16:ℝ) ^ (↑data.w : ℝ) := Real.rpow_le_rpow_of_exponent_le (by norm_num) hle +- have ht0 : (0:ℝ) ≤ (16:ℝ) ^ (-↑data.w : ℝ) := Real.rpow_nonneg (by norm_num) _ +- have htX : (16:ℝ) ^ (-↑data.w : ℝ) * (16 ^ 4 * ↑(#S) * Real.exp (a data.d) ^ 4) ≤ 1 := by +- calc (16:ℝ) ^ (-↑data.w : ℝ) * (16 ^ 4 * ↑(#S) * Real.exp (a data.d) ^ 4) +- ≤ (16:ℝ) ^ (-↑data.w : ℝ) * (16:ℝ) ^ (↑data.w : ℝ) := +- mul_le_mul_of_nonneg_left h16w ht0 +- _ = 1 := by rw [← Real.rpow_add (by norm_num)]; simp +- have hsq : ((16:ℝ) ^ (-↑data.w : ℝ) * (16 ^ 4 * ↑(#S) * Real.exp (a data.d) ^ 4)) ^ 2 ≤ 1 := by +- nlinarith [htX, mul_nonneg ht0 (le_of_lt hXpos)] +- have hM8 : (0:ℝ) ≤ ((16:ℝ) ^ (-↑data.w : ℝ)) ^ 2 * (↑(#S)) ^ 2 * Real.exp (a data.d) ^ 4 * 16 ^ 8 := by +- positivity +- have hP : ((16:ℝ) ^ (-↑data.w : ℝ)) ^ 2 * (↑(#S)) ^ 2 * Real.exp (a data.d) ^ 4 * 16 ^ 8 ≤ 1 := by +- nlinarith [hsq, hE4, hM8] +- have key : GeneratesNS.C * Real.exp (a data.d * 2) ^ 2 * (16 ^ (-↑data.w : ℝ)) ^ 2 * ↑(#S) +- * 16 ≤ 2⁻¹ := by +- rw [he2sq]; simp only [GeneratesNS.C] +- nlinarith [hP, hM8] +- calc Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val +- ≤ (GeneratesNS.C * Real.exp (a data.d * 2) ^ 2 * (16 ^ (-↑data.w : ℝ)) ^ 2 * ↑(#S) +- * 16) * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := by nlinarith [u_le] +- _ ≤ 2⁻¹ * Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := by nlinarith [key, qr_nonneg] +- +- have Q_r_zero: Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val = 0 := by +- by_contra! +- rw [mul_comm] at le_half +- have foo := one_le_of_le_mul_left₀ (by +- have nonneg: 0 ≤ Q_R ↑(R_2 data) ⇑u.val.val ⇑u.val.val := +- Q_R_self_nonneg _ _ +- grind +- ) le_half +- norm_num at foo +- +- rw [← Submodule.coe_eq_zero] +- by_contra hne +- exact absurd Q_r_zero (ne_of_gt (Q_R_pos_on_R' (↑u) hne _ (R'_le_R_2 data))) +- . apply mul_nonneg (by positivity) +- exact Q_R_self_nonneg _ _ +- . simp [GeneratesNS.C] +- positivity +- +- . simp [GeneratesNS.C] +- positivity +- . +- simp [GeneratesNS.C] +- positivity +- . intro a ha +- simp +- simp at ha +- grind +- . intro i hi _ +- positivity +- . +- simp [GeneratesNS.C] +- positivity ++ have phi_u_inj : Function.Injective phi_u := phi_restrict_injective data rfl U bounded_double + + apply LinearMap.finrank_le_finrank_of_injective at phi_u_inj + simp at phi_u_inj +@@ -270,7 +277,7 @@ lemma theorem_3_23 (d: ℕ) (hd: 0 < d): ∃ C: ℕ, ∀ v_data: V_Wrapper, grow + have hB : (B_finite data).toFinset + = Finset.image (fun a => Metric.closedBall a (↑(R_1 data):ℝ)) (X_j_finite data).toFinset := by + ext s +- simp only [Set.Finite.mem_toFinset, B, Set.mem_image, Finset.mem_image, Finset.mem_coe] ++ simp only [Set.Finite.mem_toFinset, B, Set.mem_image, Finset.mem_image] + rw [hB, B_finsets, Finset.card_image_of_injOn (hinj1.mono hcoe.le), + Finset.card_image_of_injOn (hinj2.mono hcoe.le)] + rw [← card_eq] +@@ -282,14 +289,11 @@ lemma theorem_3_23 (d: ℕ) (hd: 0 < d): ∃ C: ℕ, ∀ v_data: V_Wrapper, grow + equals 0 + 2 * Real.exp (↑data.w * a data.d) => + simp + apply add_le_add +- . simp +- . apply Nat.le_ceil ++ · simp ++ · apply Nat.le_ceil + + open scoped Topology +- +--- TODO - do we really need the double by_contra here? + -- Theorem 3.19 +-set_option maxHeartbeats 2500000 in + @[expose] + instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + classical +@@ -314,14 +318,14 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + V_finite := by infer_instance + V_even := by + rw [finrank_span_finset_eq_card] +- . ++ · + simp [fin_basis] + rw [Finset.card_image_of_injective] +- . grind +- . ++ · grind ++ · + + exact Module.Basis.injective B +- . ++ · + simp [fin_basis] + apply LinearIndepOn.id_image + exact Module.Basis.linearIndepOn B ↑fin_basis_idx +@@ -340,7 +344,7 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + -- `large_v.V` does not reduce on its own inside `rw`, so name the (definitional) equation. + have large_v_V: large_v.V = Submodule.span ℝ fin_basis := rfl + specialize V_bound large_v ?_ +- . ++ · + simp [growth_bound, my_expr] + + norm_cast +@@ -363,7 +367,7 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + equals (𝓝[>] (0 * 0)) => simp + + apply Filter.TendstoNhdsWithinIoi.mul (by simp) (by simp) +- . ++ · + unfold HasPolynomialGrowthD at hd + obtain ⟨a, s_growth⟩ := hd + simp +@@ -371,12 +375,11 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + rw [← Filter.tendsto_add_atTop_iff_nat R''] + -- Filter.tendsto_add_atTop_iff_nat + apply squeeze_zero_nhdsGT (g := (fun (R: ℕ) => (det_bound_const (V_basis large_v.V) * (1 + (R + R'')) ^ 2 * ((a * (R + R'')^d : ℝ))) / ((R + R'') ^ (↑d + 3) : ℝ))) +- . ++ · + rw [Filter.eventually_atTop] + use 1 + intro R R_pos + have det_pos := (Q_R_matrix_pos_def (V_basis large_v.V) (R + R'') (by +- -- TODO - why is this so messy? + simp [R''] + norm_cast + have foo := Nat.le_ceil (a := R'_ large_v.V) +@@ -386,7 +389,7 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + )).det_pos + norm_cast at det_pos + positivity +- . ++ · + apply Filter.Eventually.of_forall + intro R + have foo := det_bound (V_basis large_v.V) (R := R + R'') (by +@@ -402,7 +405,7 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + push_cast at foo + refine le_trans (mul_le_mul_of_nonneg_right foo (by positivity)) ?_ + by_cases const_zero: det_bound_const (V_basis large_v.V) = 0 +- . ++ · + simp [const_zero] + + field_simp +@@ -410,25 +413,25 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + rw [mul_div_assoc] + rw [mul_assoc] + rw [mul_le_mul_iff_right₀] +- . ++ · + by_cases r_zero: (R + R'') = 0 +- . ++ · + norm_cast + simp [r_zero] +- . ++ · + grw [s_growth (R + R'') (by grind)] + norm_cast + simp + rw [mul_div_assoc] +- . ++ · + have nonneg := det_bound_const_nonneg (V_basis large_v.V) + grind +- . poly_tendsto +- . ++ · poly_tendsto ++ · + unfold HasPolynomialGrowthD at hd + obtain ⟨a, s_growth⟩ := hd + apply squeeze_zero_nhdsGT (g := (fun (n: ℝ) => (a * n^d : ℝ) / (n ^ (↑d + 3))) ∘ (fun (n: ℕ) => (n: ℝ))) +- . ++ · + rw [Filter.eventually_atTop] + use 1 + intro n hn +@@ -439,32 +442,30 @@ instance Lipschitz_finite_dimensional: FiniteDimensional ℝ LipschitzH := by + + norm_cast + positivity +- . ++ · + apply Filter.Eventually.of_forall + intro n + by_cases hn: n = 0 +- . ++ · + simp [hn] +- . ++ · + grw [s_growth n (by grind)] + norm_cast + simp +- . poly_tendsto +- . ++ · poly_tendsto ++ · + rw [large_v_V, finrank_span_finset_eq_card] at V_bound +- . ++ · + simp [fin_basis] at V_bound + rw [Finset.card_image_of_injective] at V_bound +- . ++ · + simp [card_fin_basis_idx] at V_bound + grind +- . exact Module.Basis.injective B +- . ++ · exact Module.Basis.injective B ++ · + simp [fin_basis] + apply LinearIndepOn.id_image + exact Module.Basis.linearIndepOn B ↑fin_basis_idx + +-#synth FiniteDimensional ℝ LipschitzH +-#print axioms Lipschitz_finite_dimensional + + end GeneratesNS +diff --git a/Gromov/Theorem38.lean b/Gromov/Theorem38.lean +index f00df84..c132e22 100644 +--- a/Gromov/Theorem38.lean ++++ b/Gromov/Theorem38.lean +@@ -6,15 +6,12 @@ public import Gromov.Representation + /-! + # Theorem 3.8 + +-`theorem_3_8` and its real form: a group of polynomial growth admits a nontrivial +-finite-dimensional representation. ++A finitely generated polynomial-growth subgroup of a compact linear group is ++virtually abelian, over either the real or the complex numbers. + -/ + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +@@ -29,12 +26,9 @@ include hGS + + open scoped RealInnerProductSpace + +-set_option synthInstance.maxHeartbeats 500000 + +-set_option maxHeartbeats 9000000 + + omit hGS in +-set_option maxHeartbeats 500000 in + lemma theorem_3_8 {V: Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V] (H: Subgroup (V →L[ℂ] V)ˣ) [DecidableEq H] (h_compact: CompactSpace H) (G: Subgroup H) (G_fg: G.FG) (S_data: SPolyData G): ∃ A: Subgroup G, IsMulCommutative A ∧ A.FiniteIndex := by + obtain ⟨H', ⟨H_equiv_H'⟩⟩ := new_weyl_unitarian_trick (V := V) (H := H) + let G' := Subgroup.map H'.subtype (Subgroup.map H_equiv_H'.symm.toMonoidHom G) +@@ -105,18 +99,17 @@ lemma theorem_3_8 {V: Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [F + exact G_fg + + by_cases dim_le_one: Module.finrank ℂ (V) ≤ 1 +- . ++ · + use ⊤ + refine ⟨?_, ?_⟩ +- . ++ · + + have map_dim := Module.finrank_linearMap ℂ ℂ V V +- -- TODO - is there an easier way to prove this? + have map_dim_le_one: Module.finrank ℂ (V →ₗ[ℂ] V) ≤ 1 := by + rw [map_dim] + by_cases dim_eq_zero: Module.finrank ℂ (V) = 0 +- . simp [dim_eq_zero] +- . have dim_eq_one: Module.finrank ℂ (V) = 1 := by omega ++ · simp [dim_eq_zero] ++ · have dim_eq_one: Module.finrank ℂ (V) = 1 := by omega + simp [dim_eq_one] + + rw [finrank_le_one_iff] at map_dim_le_one +@@ -128,8 +121,6 @@ lemma theorem_3_8 {V: Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [F + simp + obtain ⟨p, hx⟩ := v_span x.val.val.val + obtain ⟨q, hy⟩ := v_span y.val.val.val +- +- -- TODO - upstream to mathlib + have clm_apply (f: V →L[ℂ] V) (v: V): f v = f.toLinearMap v := rfl + rw [clm_apply] + rw [clm_apply] +@@ -139,8 +130,8 @@ lemma theorem_3_8 {V: Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [F + rw [← hx, ← hy] + simp + rw [smul_comm] +- . infer_instance +- . ++ · infer_instance ++ · + + let new_S_data := map_S_data G (f := H'.subtype.comp (H_equiv_H'.symm.toMonoidHom)) S_data + obtain ⟨N, N_comm, N_finite_index⟩ := compact_lie_virtually_abelian (Module.finrank ℂ V) (by omega) G' G'_fg (by +@@ -158,17 +149,17 @@ lemma theorem_3_8 {V: Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [F + let new_N' := Subgroup.map G'_to_G N + use new_N' + refine ⟨?_, ?_⟩ +- . ++ · + simp [new_N'] + apply Subgroup.map_isMulCommutative +- . ++ · + simp [new_N'] + rw [Subgroup.finiteIndex_iff] + rw [Subgroup.index_map_of_injective] +- . simp ++ · simp + refine ⟨?_, ?_⟩ +- . exact N_finite_index.index_ne_zero +- . conv => ++ · exact N_finite_index.index_ne_zero ++ · conv => + arg 1 + arg 1 + arg 1 +@@ -180,20 +171,20 @@ lemma theorem_3_8 {V: Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [F + use H'.subtype (H_equiv_H'.symm a) + simp [my_hom] + use ?_ +- . have key : (MonoidHom.ofInjective (subtype_injective H')).symm ++ · have key : (MonoidHom.ofInjective (subtype_injective H')).symm + ⟨↑(H_equiv_H'.symm (↑a : ↥H)), ⟨H_equiv_H'.symm (↑a : ↥H), rfl⟩⟩ + = H_equiv_H'.symm (↑a : ↥H) := + subtype_injective H' (MonoidHom.apply_ofInjective_symm _ _) + exact Subtype.ext ((congrArg H_equiv_H' key).trans + (H_equiv_H'.apply_symm_apply _)) +- . simp [G'] ++ · simp [G'] + use a.val + use ?_ +- . simp +- . simp ++ · simp ++ · simp + + simp +- . ++ · + simp [G'_to_G] + intro a b hab + simpa using hab +@@ -202,8 +193,6 @@ lemma theorem_3_8 {V: Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [F + instance rho_g_FG: Group.FG (rho_g) := by + unfold rho_g + apply Group.fg_range +- +--- TODO - deduplicate with 'map_S_Data' + @[expose] + def map_range_S_data {G H: Type*} [Group G] [Group H] [DecidableEq G] [DecidableEq H] {f: G →* H} (S_data: SPolyData (T := G) ⊤): SPolyData f.range := { + S := (f.rangeRestrict.comp (Subgroup.topEquiv.toMonoidHom)) '' S_data.S +@@ -232,9 +221,9 @@ def map_range_S_data {G H: Type*} [Group G] [Group H] [DecidableEq G] [Decidable + rw [Set.Finite.toFinset_image] + rw [← Finset.image_pow] + grw [Finset.card_image_le] +- . ++ · + apply S_data.S_poly r hr +- . exact S_data.S_finite ++ · exact S_data.S_finite + } + + @[expose] +@@ -265,12 +254,13 @@ def map_equiv_S_data {A B: Type*} [Group A] [Group B] [DecidableEq A] [Decidable + rw [Set.Finite.toFinset_image] + rw [← Finset.image_pow] + grw [Finset.card_image_le] +- . ++ · + apply S_data.S_poly r hr +- . exact S_data.S_finite ++ · exact S_data.S_finite + } + + ++omit hGS in + /-- The real-inner-product-space version of `theorem_3_8`: a finitely generated, polynomial-growth + subgroup of the units of a compact linear group over `ℝ` is virtually abelian. We reduce to the + complex `theorem_3_8` by complexifying (`Cx.unitsMapHom`) just before the unitary machinery. -/ +diff --git a/Gromov/ThreeTwoGenerates.lean b/Gromov/ThreeTwoGenerates.lean +index 7187937..bb10b00 100644 +--- a/Gromov/ThreeTwoGenerates.lean ++++ b/Gromov/ThreeTwoGenerates.lean +@@ -12,9 +12,6 @@ kernel of `φ`. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +@@ -29,9 +26,7 @@ include hGS + + open scoped RealInnerProductSpace + +-set_option synthInstance.maxHeartbeats 500000 + +-set_option maxHeartbeats 9000000 + + open MeasureTheory + +@@ -63,8 +58,8 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + + have closure_enlarge: Subgroup.closure ({1, γ, γ⁻¹} ∪ (e_i '' Set.univ)) = Subgroup.closure (({1, γ, γ⁻¹} ∪ (e_i_regular '' Set.univ))^(max_phi + 1)) := by + rw [Subgroup.closure_pow] +- . simp +- . unfold max_phi ++ · simp ++ · unfold max_phi + simp + + conv => +@@ -76,10 +71,10 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + rfl + rw [closure_enlarge] + apply Subgroup.closure_eq_of_le +- . ++ · + rw [hGS.generates] + exact fun ⦃a⦄ a ↦ trivial +- . ++ · + simp + intro s hs + simp +@@ -87,14 +82,13 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + rw [Subgroup.closure_toSubmonoid] + dsimp [Membership.mem] + rw [Submonoid.closure_eq_image_prod] +- -- TODO - why do we need any of this? + show s ∈ List.prod '' _ + rw [Set.mem_image] + + + have foo := Submonoid.exists_list_of_mem_closure (s := ((S ∪ S⁻¹) : Set G)) (x := s) + rw [← Subgroup.closure_toSubmonoid _] at foo +- simp only [mem_toSubmonoid, Finset.mem_coe] at foo ++ simp only [mem_toSubmonoid] at foo + have generates := hGS.generates + have x_in_top: s ∈ (⊤: Set G) := by + simp +@@ -114,7 +108,7 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + + use new_list + refine ⟨?_, ?_⟩ +- . ++ · + simp + intro x hx + unfold new_list list_with_mem l_attach at hx +@@ -124,9 +118,9 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + + have gamma_phi_in_minus_plus: γ^(φ a) ∈ ({1, γ, γ⁻¹} ∪ Set.range e_i_regular) ^ (max_phi - 1 +1) := by + by_cases val_pos: 0 < φ a +- . ++ · + have eq_self: Int.natAbs (φ a) = φ a := by +- simp [val_pos] ++ simp + linarith + conv => + arg 2 +@@ -134,8 +128,8 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + nth_rw 1 [← eq_self] + norm_cast + apply Set.pow_subset_pow_right (m := Int.natAbs (φ a)) (n := max_phi - 1 + 1) +- . simp +- . ++ · simp ++ · + rw [cancel_add_minus] + unfold max_phi + simp +@@ -147,10 +141,10 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + conv => + pattern ofMul a + equals a => rfl +- . ++ · + apply Set.pow_mem_pow + simp +- . ++ · + have eq_neg_abs: (φ a) = -(φ a).natAbs := by + rw [← Int.abs_eq_natAbs] + simp at val_pos +@@ -165,8 +159,8 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + norm_cast + -- TOOD - deduplicate this with the positive case + apply Set.pow_subset_pow_right (m := Int.natAbs (φ a)) (n := max_phi - 1 + 1) +- . simp +- . ++ · simp ++ · + rw [cancel_add_minus] + unfold max_phi + simp +@@ -178,7 +172,7 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + conv => + pattern ofMul a + equals a => rfl +- . ++ · + apply Set.pow_mem_pow + simp + have a_mem_s: a ∈ S := by exact l_mem_s a ha +@@ -192,7 +186,7 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + simp + + have prod_eq_sum: e_i ⟨a, l_mem_s a ha⟩ + φ (ofMul a) • ofMul γ = (e_i_regular ⟨a, a_mem_s⟩) * (γ ^ φ (ofMul a)) := by +- simp [e_i, e_i_regular, cancel_add_minus] ++ simp [e_i, e_i_regular] + + + conv => +@@ -202,7 +196,7 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + simp + + apply_fun (fun x => x * (γ ^ (- φ (ofMul a)))) +- . ++ · + simp only + simp + conv => +@@ -222,7 +216,7 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + equals (a * γ ^ (-φ (ofMul a))) => + rfl + simp +- . ++ · + exact mul_left_injective (γ ^ (-φ (ofMul a))) + + +@@ -253,10 +247,8 @@ lemma e_i_and_gamma_generates_G (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ + exact List.map_id l + + +-#print axioms e_i_and_gamma_generates_G + + -- The kernel of `φ` is generated by {γ_m_i} +-set_option maxHeartbeats 1000000 + lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ γ = 1) : Subgroup.closure (Set.range (Function.uncurry (gamma_m_helper (S := S) φ γ))) = AddSubgroup.toSubgroup φ.ker := by + have phi_ofmul: φ (ofMul γ) = 1 := by + exact hγ +@@ -281,8 +273,8 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + + have closure_enlarge: Subgroup.closure ({1, γ, γ⁻¹} ∪ (e_i '' Set.univ)) = Subgroup.closure (({1, γ, γ⁻¹} ∪ (e_i_regular '' Set.univ))^(max_phi + 1)) := by + rw [Subgroup.closure_pow] +- . simp +- . unfold max_phi ++ · simp ++ · unfold max_phi + simp + + +@@ -291,7 +283,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + have gamma_m_ker_phi: (Subgroup.closure (Set.range (Function.uncurry gamma_m))) = φ.ker.toSubgroup := by + ext z + refine ⟨?_, ?_⟩ +- . intro hz ++ · intro hz + have foo := Submonoid.exists_list_of_mem_closure (s := Set.range (Function.uncurry gamma_m) ∪ (Set.range (Function.uncurry gamma_m))⁻¹) (x := z) + rw [← Subgroup.closure_toSubmonoid _] at foo + specialize foo hz +@@ -325,7 +317,6 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + obtain ⟨n, val, val_in_s, prod_eq_a⟩ := a_eq_prod + apply_fun Inv.inv at prod_eq_a + simp at prod_eq_a +- -- TODO - deduplicate this with the branch above + rw [← prod_eq_a] + simp + have apply_mult := AddMonoidHom.toMultiplicative_apply_apply φ (toMul (e_i ⟨val, val_in_s⟩)) +@@ -336,7 +327,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + equals e_i ⟨val, val_in_s⟩ => rfl + rw [e_i_zero] at apply_mult + exact apply_mult +- . ++ · + intro hz + + -- We need to write 'γ^a (f⁻¹ )' as an element of e_i +@@ -351,7 +342,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + rw [← e_i_eq] at new_closure_e_i + rw [new_closure_e_i] at foo + rw [← Subgroup.closure_toSubmonoid _] at foo +- simp only [mem_toSubmonoid, Finset.mem_coe] at foo ++ simp only [mem_toSubmonoid] at foo + + conv at foo => + intro hz +@@ -386,7 +377,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + have eq_split: list = list.takeWhile is_gamma ++ list.dropWhile is_gamma := by + exact Eq.symm List.takeWhile_append_dropWhile + by_cases header_eq_full: list.takeWhile is_gamma = list +- . ++ · + have list_eq_gamma_m: ∃ m: ℤ, list.unattach.prod = γ ^ m := by + unfold is_gamma at header_eq_full + clear eq_split is_gamma is_gamma_prop hlist +@@ -400,21 +391,21 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + simp at header_eq_full + exact header_eq_full.1 + rw [List.takeWhile_cons_of_pos] at header_eq_full +- . ++ · + rw [List.cons_eq_cons] at header_eq_full + specialize ih header_eq_full.2 + obtain ⟨m, hm⟩ := ih + by_cases h_eq_gamma: h = γ +- . ++ · + use (m + 1) + simp [h_eq_gamma, hm] + exact mul_self_zpow γ m +- . use (-1 + m) ++ · use (-1 + m) + simp [h_eq_gamma] at h_gamma + simp [h_gamma, hm] + rw [← zpow_neg_one] + rw [zpow_add] +- . simp [h_gamma] ++ · simp [h_gamma] + + + have empty_prod_eq: list.unattach.prod = ([] : List E).unattach.prod := by +@@ -427,7 +418,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + simp [hlist] + + exact ⟨[], empty_prod_eq⟩ +- . ++ · + + have tail_nonempty: list.dropWhile is_gamma ≠ [] := by + rw [not_iff_not.mpr List.takeWhile_eq_self_iff] at header_eq_full +@@ -454,8 +445,6 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + rw [Set.mem_union] at drop_in_E + have not_in_left: (List.dropWhile is_gamma list)[0].val ∉ ({γ, γ⁻¹} : Set G) := by + simp [not_is_gamma_prop] +- +- -- TODO - why can't simp handle this? + have in_right := Or.resolve_left drop_in_E not_in_left + exact in_right + +@@ -507,13 +496,13 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + have gamma_copy_prod: gamma_copy.unattach.prod = γ^m := by + simp [gamma_copy] + by_cases m_ge: 0 ≤ m +- . ++ · + simp [m_ge] + rw [← zpow_natCast] + simp + rw [← abs_eq_self] at m_ge + rw [m_ge] +- . ++ · + simp [m_ge] + rw [← zpow_natCast] + simp +@@ -525,13 +514,13 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + have gamma_copy_inv_prod: gamma_copy_inv.unattach.prod = γ^(-m) := by + simp [gamma_copy_inv] + by_cases m_ge: 0 ≤ m +- . ++ · + simp [m_ge] + rw [← zpow_natCast] + simp + rw [← abs_eq_self] at m_ge + rw [m_ge] +- . ++ · + simp [m_ge] + rw [← zpow_natCast] + simp +@@ -546,9 +535,9 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + + have header_prod: (List.takeWhile is_gamma list).unattach.prod = γ^m := by + have my_lemma := take_count_sum_eq_exp (List.takeWhile is_gamma list) γ gamma_ne_inv ?_ +- . ++ · + rw [my_lemma] +- . ++ · + have foo (x: E) := List.mem_takeWhile_imp (p := fun (val: E) => (val = γ ∨ val = γ⁻¹)) (l := list) (x := x) + conv at foo => + intro x hx +@@ -569,7 +558,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + have dropwhile_not_nul : (List.dropWhile is_gamma list) ≠ [] := by + exact tail_nonempty + apply_fun (fun x => x * (List.dropWhile is_gamma list).unattach.prod⁻¹) +- . ++ · + simp + conv => + pattern _[0] +@@ -585,9 +574,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + have unattach_len_pos: 0 < (List.dropWhile is_gamma list).unattach.length := by + rw [List.length_unattach] + exact List.length_pos_iff.mpr dropwhile_not_nul +- +- -- TODO - this is gross, and should be removed +- letI : Inhabited G := { ++ let : Inhabited G := { + default := 1 + } + +@@ -604,10 +591,10 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + rw [list_tail_unattach] + + rw [List.headI_mul_tail_prod_of_ne_nil] +- . ++ · + simp + simp [header_prod] +- . ++ · + by_contra this + rw [List.eq_nil_iff_length_eq_zero] at this + rw [List.length_unattach] at this +@@ -615,7 +602,7 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + contradiction + + +- . exact mul_left_injective (List.dropWhile is_gamma list).unattach.prod⁻¹ ++ · exact mul_left_injective (List.dropWhile is_gamma list).unattach.prod⁻¹ + + have sublist_phi_zero: φ (gamma_copy ++ (List.dropWhile is_gamma list).tail).unattach.prod = 0 := by + rw [← mega_list_prod] at hlist +@@ -675,9 +662,9 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + | cons h t ih => + simp + split_ifs +- . omega +- . omega +- . omega ++ · omega ++ · omega ++ · omega + + let rewritten_sub_list := (rewrite_list (gamma_copy ++ (list.dropWhile is_gamma).tail) sublist_phi_zero) + let return_list := (⟨γ^m * (List.dropWhile is_gamma list)[0] * γ^(-m), in_range⟩) :: rewritten_sub_list.val +@@ -712,24 +699,24 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + decreasing_by { + simp + split_ifs +- . ++ · + simp + conv => + rhs + rw [← take_drop_len (p := fun (k: E) ↦ decide (↑k = γ) || decide (↑k = γ⁻¹))] + apply add_lt_add_of_le_of_lt +- . apply count_head_lt +- . simp [is_gamma] at dropwhile_len_gt ++ · apply count_head_lt ++ · simp [is_gamma] at dropwhile_len_gt + apply Nat.sub_one_lt + apply Nat.pos_iff_ne_zero.mp dropwhile_len_gt +- . ++ · + simp-- [count_gamma_copy] + conv => + rhs + rw [← take_drop_len (p := fun (k: E) ↦ decide (↑k = γ) || decide (↑k = γ⁻¹))] + apply add_lt_add_of_le_of_lt +- . apply count_head_lt +- . simp [is_gamma] at dropwhile_len_gt ++ · apply count_head_lt ++ · simp [is_gamma] at dropwhile_len_gt + apply Nat.sub_one_lt + apply Nat.pos_iff_ne_zero.mp dropwhile_len_gt + } +@@ -771,7 +758,6 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + + let my_res := rewrite_list ((z_list.filter (fun s ↦ !decide (s = 1))).attach.map (fun (g) => ⟨g.val, z_filter_mem_e g.val g.property⟩)) (by + simp +- -- TODO - there has to be a less awful way of doing this + conv => + arg 1 + arg 2 +@@ -783,8 +769,8 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + ext i q + simp + by_cases list_get: (List.filter (fun s ↦ !decide (s = 1)) z_list)[i]? = none +- . simp [list_get] +- . simp at list_get ++ · simp [list_get] ++ · simp at list_get + simp [list_get] + rw [← ofMul_list_prod] + rw [h_z_list.2] +@@ -800,12 +786,12 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + rw [Set.mem_image] + use my_res.val.unattach + refine ⟨?_, ?_⟩ +- . simp only [Set.mem_setOf_eq] ++ · simp only [Set.mem_ofPred_eq] + intro x hx + rw [List.mem_unattach] at hx + obtain ⟨x_prop, _⟩ := hx + exact x_prop +- . ++ · + rw [← my_res_prop] + conv => + pattern List.unattach _ +@@ -813,12 +799,13 @@ lemma three_two_gamma_m_generates (φ: (Additive G) →+ ℤ) (γ: G) (hγ: φ + ext i q + simp + by_cases list_get: (List.filter (fun s ↦ !decide (s = 1)) z_list)[i]? = none +- . simp [list_get] +- . simp at list_get ++ · simp [list_get] ++ · simp at list_get + simp [list_get] + exact h_z_list.2 + exact gamma_m_ker_phi + ++omit hGS in + lemma three_two_S_n_subset_ker {G: Type*} [Group G] [DecidableEq G] (S: Finset G) (φ: (Additive G) →+ ℤ) (γ: G) (phi_gamma: φ γ = 1) (n: ℕ): + ↑(three_two_S_n S φ γ n) ⊆ Additive.toMul '' φ.ker.carrier := by + +@@ -846,12 +833,12 @@ lemma three_two_S_n_subset_ker {G: Type*} [Group G] [DecidableEq G] (S: Finset G + simp + exact id (Eq.symm prod_eq_x) + +-lemma three_two_S_n_generates (d: ℕ) (hd: d >= 1) (hG: HasPolynomialGrowthD S d ) (φ: (Additive G) →+ ℤ) (γ : Additive G) (phi_gamma: φ γ = 1): ∃ n, AddSubgroup.closure (Additive.ofMul '' (three_two_S_n S φ γ (n))) = φ.ker := by ++lemma three_two_S_n_generates (d: ℕ) (_hd: d >= 1) (hG: HasPolynomialGrowthD S d ) (φ: (Additive G) →+ ℤ) (γ : Additive G) (phi_gamma: φ γ = 1): ∃ n, AddSubgroup.closure (Additive.ofMul '' (three_two_S_n S φ γ (n))) = φ.ker := by + obtain ⟨n, hn⟩ := three_poly_poly_growth_all_s_n d hG γ φ + use n + ext z + refine ⟨?_, ?_⟩ +- . intro hz ++ · intro hz + induction hz using AddSubgroup.closure_induction with + | mem x hx => + have x_mem: x ∈ three_two_S_n S φ γ n := by +@@ -867,7 +854,7 @@ lemma three_two_S_n_generates (d: ℕ) (hd: d >= 1) (hG: HasPolynomialGrowthD S + exact (AddSubgroup.add_mem_cancel_right φ.ker hz).mpr hy + | neg x x_mem hx => + exact AddSubgroup.neg_mem φ.ker hx +- . intro hz ++ · intro hz + have generates_ker := three_two_gamma_m_generates φ γ phi_gamma + + have hz' : z ∈ Subgroup.closure (Set.range (Function.uncurry (gamma_m_helper (S := S) φ γ))) := by +@@ -922,10 +909,10 @@ lemma three_two_ker_fg (d: ℕ) (hd: d >= 1) (hG: HasPolynomialGrowthD S d ) ( + use ofMul '' ↑(three_two_S_n S φ γ n) + refine ⟨hn, ?_⟩ + rw [Set.finite_image_iff] +- . ++ · + simp +- . intro a b hab +- simpa using hab ++ · intro a _ b _ hab ++ exact Additive.ofMul.injective hab + + + -- Extract a generatating set for the kernel of φ +@@ -941,8 +928,7 @@ lemma finite_virtually_nilpotent {G: Type*} [Group G] [Finite G]: Group.IsVirtua + rw [Group.IsVirtuallyNilpotent] + use ⊥ + refine ⟨?_, ?_⟩ +- . exact Group.isNilpotent_of_subsingleton +- -- TODO - prove that a finite group is nilpotent, and upstream to mathlib +- . infer_instance ++ · exact Group.isNilpotent_of_subsingleton ++ · infer_instance + + end GeneratesNS +diff --git a/Gromov/ThreeTwoGrowth.lean b/Gromov/ThreeTwoGrowth.lean +index 1fc3a86..5fd825b 100644 +--- a/Gromov/ThreeTwoGrowth.lean ++++ b/Gromov/ThreeTwoGrowth.lean +@@ -11,9 +11,6 @@ public import Gromov.Theorem31Input + + public section + +-set_option linter.style.longLine false +-set_option linter.style.cdot false +-set_option linter.style.commandStart false + + open Subgroup + open scoped Finset +@@ -28,9 +25,7 @@ include hGS + + open scoped RealInnerProductSpace + +-set_option synthInstance.maxHeartbeats 500000 + +-set_option maxHeartbeats 9000000 + + open MeasureTheory + +@@ -45,27 +40,27 @@ lemma take_count_sum_eq_exp {T: Type*} [ht: Group T] [heq: DecidableEq T] {E: Se + | cons h t ih => + simp [countElemOrInv] + by_cases h_eq_g: h = g +- . ++ · + simp [h_eq_g] + rw [ih] +- . rw [← zpow_one_add] +- . simp at hl ++ · rw [← zpow_one_add] ++ · simp at hl + intro val hval + have hl_right := hl.2 val (by simp) (by simp [hval]) + exact hl_right +- . ++ · + have h_eq_inv: h = g⁻¹ := by + specialize hl h + simp at hl + simp [h_eq_g] at hl + exact hl +- simp [h_eq_g, h_eq_inv] ++ simp [h_eq_inv] + rw [ih] +- . ++ · + rw [← zpow_neg_one] + rw [← zpow_add] + simp [hg.symm] +- . ++ · + simp at hl + intro val hval + have hl_right := hl.2 val (by simp) (by simp [hval]) +@@ -82,10 +77,10 @@ lemma list_filter_one {T: Type*} [DecidableEq T] [Group T] (l: List T): (l.filte + | cons h t ih => + simp + by_cases h_eq_one: h = 1 +- . ++ · + simp [h_eq_one] + exact ih +- . ++ · + rw [List.filter_cons] + simp [h_eq_one] + exact ih +@@ -119,11 +114,7 @@ omit hGS in + @[expose] + noncomputable def three_two_B_n {G: Type*} [Group G] [DecidableEq G] (S: Finset G) (φ: (Additive G) →+ ℤ) (γ: G) (n: ℕ): Finset G := Finset.image (fun l => l.unattach.prod) (list_len_n S φ γ n ) + +- +---set_option maxHeartbeats 600000 +- + -- If G has polynomial growth, than we can find an N such that S_n ⊆ B_n * B_n⁻¹ +-set_option maxHeartbeats 2000000 in + lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) (φ: (Additive G) →+ ℤ) (s: G) (s_mem: s ∈ S): ∃ n, three_two_S_n (S := {s}) φ γ (n + 1) ⊆ ((three_two_B_n (S := {s}) φ γ n) * (three_two_B_n (S := {s}) φ γ n)⁻¹) := by + by_contra! + simp [HasPolynomialGrowthD] at hG +@@ -163,7 +154,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + + have disjoint_smul (M: ℕ) (hM: N ≤ M) (p: G) (p_mem: p ∈ three_two_S_n (S := {s}) φ γ (M + 1)) (p_not_prod: p ∉ three_two_B_n (S := {s}) φ γ M * (three_two_B_n (S := {s}) φ γ M)⁻¹): (p • three_two_B_n (S := {s}) φ γ M) ∩ (three_two_B_n (S := {s}) φ γ M) = ∅ := by + rw [Finset.mem_mul.not] at p_not_prod +- push_neg at p_not_prod ++ push Not at p_not_prod + + ext a + simp only [Finset.mem_inter, Finset.notMem_empty, iff_false, not_and] +@@ -225,12 +216,12 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + exact s_n_subset M hM s.property + )⟩))) + refine ⟨?_, ?_⟩ +- . +- simp [list_len_n, list_mem] ++ · ++ simp [list_len_n] + simp [list_len_n] at list_mem + exact list_mem + +- . ++ · + simp + conv => + lhs +@@ -255,7 +246,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + + use (List.replicate m.natAbs m_list_choice).flatten ++ [⟨s, s_mem⟩] ++ (List.replicate (-(φ (ofMul s))).natAbs phi_list_choice).flatten ++ (List.replicate m.natAbs m_list_choice_inv).flatten + refine ⟨?_, ?_⟩ +- . ++ · + simp [phi_list_choice] + norm_cast + rw [← s_m_eq] +@@ -264,7 +255,6 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + rhs + arg 1 + arg 2 +- -- TODO - is there a tactic that can normalize the 'ofMul' stuff for us? + equals s * γ^(-(φ (ofMul s))) => + rw [← ofMul_zpow] + rw [← sub_eq_add_neg] +@@ -278,7 +268,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + simp + simp_rw [m_list_choice, m_list_choice_inv] + by_cases m_pos: 0 < m +- . ++ · + simp_rw [m_pos] + simp + have m_eq_abs : |m| = m := by +@@ -291,7 +281,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + rw [m_eq_abs] + group + by_cases phi_neg: (φ (ofMul s)) < 0 +- . ++ · + have phi_abs: |(φ (ofMul s))| = -φ (ofMul s) := by + rw [Int.abs_eq_natAbs] + omega +@@ -301,7 +291,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + rw [gamma_list_prod] + rw [m_eq_abs] + group +- . ++ · + have phi_abs: |(φ (ofMul s))| = φ (ofMul s) := by + rw [Int.abs_eq_natAbs] + omega +@@ -311,7 +301,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + rw [gamma_list_inv] + rw [m_eq_abs] + group +- . ++ · + simp_rw [m_pos] + simp + have neg_abs_m : |m| = - m := by +@@ -324,9 +314,8 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + group + rw [neg_abs_m] + group +- -- TODO - this can be deduplicated + by_cases phi_neg: (φ (ofMul s)) < 0 +- . ++ · + have phi_abs: |(φ (ofMul s))| = -φ (ofMul s) := by + rw [Int.abs_eq_natAbs] + omega +@@ -336,7 +325,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + rw [gamma_list_prod] + rw [neg_abs_m] + group +- . ++ · + have phi_abs: |(φ (ofMul s))| = φ (ofMul s) := by + rw [Int.abs_eq_natAbs] + omega +@@ -346,7 +335,7 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + rw [gamma_list_inv] + rw [neg_abs_m] + group +- . ++ · + + simp [m_list_choice, m_list_choice_inv] + simp_rw [apply_ite] +@@ -409,20 +398,19 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + simp [List.unattach, -List.map_subtype] + have my_spec := Exists.choose_spec ((s_n_bound M hM h h.property)) + have first_prop := my_spec.1 +- -- wtf + nth_rw 8 [← first_prop] + simp + + + have flat_list_len: nested_list.flatten.length ≤ nested_list.length • (4 * M^2) := by + simp +- have foo := List.sum_le_card_nsmul (l := (List.map List.length nested_list)) (4 * M^2) ?_ +- . ++ have foo := List.sum_le_length_nsmul (l := (List.map List.length nested_list)) (4 * M^2) ?_ ++ · + conv at foo => + rhs + simp + exact foo +- . ++ · + intro q hq + simp at hq + obtain ⟨s_list, h_s_prod, s_len⟩ := hq +@@ -443,8 +431,8 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + simp only [smul_eq_mul] at flat_list_len + have nested_list_le_n_squared: nested_list.flatten.length ≤ M * (4 * M^2) := by + apply le_mul_of_le_mul_right (b := l.length) +- . omega +- . omega ++ · omega ++ · omega + + + let filled_list := nested_list.flatten ++ (List.replicate ((M * (4 * M^2)) - nested_list.flatten.length) ⟨1, hGS.one_mem⟩) +@@ -484,8 +472,8 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + | base => + simp [three_two_B_n, list_len_n] + use [⟨(gamma_m_helper φ γ 0 ⟨s, s_mem⟩), ?_⟩] +- . simp [N] +- . ++ · simp [N] ++ · + simp [three_two_S_n] + use 0 + refine ⟨by omega, ?_⟩ +@@ -501,18 +489,18 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + + have union_subset_n_succ: three_two_B_n (S := {s}) φ γ k ∪ (p • three_two_B_n (S := {s}) φ γ k) ⊆ three_two_B_n (S := {s}) φ γ (k + 1) := by + apply Finset.union_subset +- . exact b_n_subset_b_n_succ k hk +- . exact smul_subset k hk p p_mem ++ · exact b_n_subset_b_n_succ k hk ++ · exact smul_subset k hk p p_mem + + + have card_le := Finset.card_le_card (union_subset_n_succ) + rw [Finset.card_union_of_disjoint ?_] at card_le +- . ++ · + simp at card_le + ring_nf at card_le + rw [add_comm] at card_le + omega +- . ++ · + specialize disjoint_smul k hk p p_mem p_not_prod + rw [Finset.inter_comm] at disjoint_smul + rw [Finset.disjoint_iff_inter_eq_empty] +@@ -577,13 +565,13 @@ lemma new_three_two_poly_growth (d: ℕ) (hG: HasPolynomialGrowthD S d ) (γ: G) + + have strict_lt: a * 4 ^ d * (↑M ^ 3) ^ d < (((2 : ℝ) ^ N)⁻¹ * 2 ^ M) := by + apply helper_lemma (b := 2⁻¹) +- . ++ · + field_simp + positivity +- . simp +- . simp +- . exact m_pow_lt +- . norm_num ++ · simp ++ · simp ++ · exact m_pow_lt ++ · norm_num + + + conv at strict_lt => +@@ -616,8 +604,7 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + exact S_nonempty + ) + use r +- intro m +- intro x hx ++ intro m x hx + simp [gamma_m_helper] at hx + simp [three_two_S_n, gamma_m_helper] + obtain ⟨s, hs, x_eq_conj⟩ := hx +@@ -640,10 +627,10 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + have my_iter := closure_iterate_mulact γ (e_i_regular_helper φ γ ⟨s, hs⟩) (n + 1) + simp [three_two_S_n, gamma_m_helper] at s_n_subset + have closure_eq := my_iter ?_ ?_ +- . ++ · + have x_mem_closure_range: x ∈ Subgroup.closure (Set.range fun (m : ℤ) ↦ γ ^ m * e_i_regular_helper φ γ ⟨s, hs⟩ * γ ^ (-m : ℤ)) := by + by_cases m_pos: 0 < m +- . ++ · + have m_eq_natabs: m = m.natAbs := by + omega + apply Subgroup.subset_closure +@@ -651,14 +638,14 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + use m.natAbs + rw [m_eq_natabs] at x_eq_conj + rw [← x_eq_conj] +- . ++ · + apply Subgroup.subset_closure + simp + use m + + rw [← closure_eq] at x_mem_closure_range + apply Subgroup.closure_mono (h := ((fun (m : ℤ) ↦ γ ^ m * e_i_regular_helper φ γ ⟨s, hs⟩ * γ ^ (-m : ℤ)) '' (Set.Ioo (-(r + 1) : ℤ) (r + 1 : ℤ)))) +- . ++ · + intro p hp + simp at hp + simp +@@ -669,7 +656,7 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + use hs + rw [gamma_m_helper, zpow_neg] + exact p_eq +- . ++ · + apply (Subgroup.closure_mono _) x_mem_closure_range + intro z hz + simp at hz +@@ -677,13 +664,13 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + obtain ⟨a, ⟨a_gt, a_lt⟩, z_eq⟩ := hz + use a + refine ⟨⟨?_, ?_⟩, z_eq⟩ +- . ++ · + norm_cast at a_gt + omega +- . ++ · + norm_cast at a_lt + omega +- . ++ · + specialize s_n_subset (n + 1) (by omega) (by omega) s rfl + simp [three_two_B_n] at s_n_subset + rw [Finset.mem_mul] at s_n_subset +@@ -694,7 +681,7 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + simp [e_i_regular_helper] + rw [← prod_vals_eq] + apply Subgroup.mul_mem +- . ++ · + simp at val_in_image + obtain ⟨list, hlist, list_prod_eq⟩ := val_in_image + rw [← list_prod_eq] +@@ -713,7 +700,7 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + simp [gamma_m_helper] at e_i_eq + obtain ⟨q, q_mem, e_i_eq'⟩ := e_i_eq + simp [e_i_regular_helper] +- . ++ · + simp at other_val_in_image + obtain ⟨list, hlist, list_prod_eq⟩ := other_val_in_image + apply_fun Inv.inv at list_prod_eq +@@ -735,8 +722,7 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + simp [gamma_m_helper] at e_i_eq + obtain ⟨q, q_mem, e_i_eq'⟩ := e_i_eq + simp [e_i_regular_helper] +- . +- -- TODO - 99% of this can be deduplicated ++ · + specialize s_n_subset (-(n + 1)) (by omega) (by omega) s rfl + -- Deduplicate verything after here + simp [three_two_B_n] at s_n_subset +@@ -749,7 +735,7 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + simp [e_i_regular_helper] + rw [← prod_vals_eq] + apply Subgroup.mul_mem +- . ++ · + simp at val_in_image + obtain ⟨list, hlist, list_prod_eq⟩ := val_in_image + rw [← list_prod_eq] +@@ -768,7 +754,7 @@ lemma three_poly_poly_growth_all_s_n (d: ℕ) (hG: HasPolynomialGrowthD S d ) ( + simp [gamma_m_helper] at e_i_eq + obtain ⟨q, q_mem, e_i_eq'⟩ := e_i_eq + simp [e_i_regular_helper] +- . ++ · + simp at other_val_in_image + obtain ⟨list, hlist, list_prod_eq⟩ := other_val_in_image + apply_fun Inv.inv at list_prod_eq +diff --git a/Gromov/ToMathlib/Analysis/Matrix/StarNormalEigen.lean b/Gromov/ToMathlib/Analysis/Matrix/StarNormalEigen.lean +index a6918d7..5dbc2a0 100644 +--- a/Gromov/ToMathlib/Analysis/Matrix/StarNormalEigen.lean ++++ b/Gromov/ToMathlib/Analysis/Matrix/StarNormalEigen.lean +@@ -146,28 +146,33 @@ lemma star_normal_maxGenEigenspace_eq_eigenspace {A: Type*} [NormedAddCommGroup + f.maxGenEigenspace k = f.eigenspace k := by + apply le_antisymm; + · intro x hx +- aesop; ++ obtain ⟨w, hw⟩ := (Module.End.mem_maxGenEigenspace f k x).mp hx + -- Since $f$ is star-normal, we have $\ker((f - kI)^2) = \ker(f - kI)$. + have h_ker_sq_eq_ker : LinearMap.ker ((f - k • 1) ^ 2) = LinearMap.ker (f - k • 1) := by + apply IsStarNormal.ker_sq_eq_ker; + -- Since $f$ is star-normal, we have $f * star f = star f * f$. Therefore, $(f - k • 1) * star (f - k • 1) = star (f - k • 1) * (f - k • 1)$. + have h_star_normal : (f - k • 1) * star (f - k • 1) = star (f - k • 1) * (f - k • 1) := by +- simp_all +decide [ sub_mul, mul_sub, smul_sub, sub_smul ]; +- simp_all +decide [ sub_eq_iff_eq_add, IsStarNormal, smul_smul ]; ++ simp_all +decide [ sub_mul, mul_sub, smul_sub ]; ++ simp_all +decide [ sub_eq_iff_eq_add, smul_smul ]; + simp_all +decide [ mul_comm, sub_eq_add_neg, add_assoc, add_left_comm, add_comm ]; + exact Eq.symm (star_comm_self' f); + exact (isStarNormal_iff (f - k • 1)).mpr (id (Eq.symm h_star_normal)); + -- By induction on $w$, we can show that $\ker((f - kI)^w) = \ker(f - kI)$ for all $w \geq 1$. + have h_ker_pow_eq_ker : ∀ w ≥ 1, LinearMap.ker ((f - k • 1) ^ w) = LinearMap.ker (f - k • 1) := by + intro w hw +- induction' w, Nat.succ_le.mpr hw using Nat.le_induction with w hw ih; ++ induction' w, Nat.succ_le_iff.mpr hw using Nat.le_induction with w hw ih; + · simp +decide; +- · simp_all +decide [ pow_succ, LinearMap.ker_comp ]; ++ · simp_all +decide [ pow_succ ]; + simp_all +decide [ SetLike.ext_iff, LinearMap.mem_ker ]; +- intro x; specialize ih ( f x - k • x ) ; simp_all +decide [ sub_eq_iff_eq_add, pow_succ, mul_sub, sub_mul ] ; +- by_cases hw : 1 ≤ w <;> aesop; +- replace h_ker_pow_eq_ker := SetLike.ext_iff.mp ( h_ker_pow_eq_ker w hw ) x; aesop; +- exact eq_of_sub_eq_zero h_ker_pow_eq_ker; ++ intro x; specialize ih ( f x - k • x ) ; simp_all +decide [ sub_eq_iff_eq_add ] ; ++ by_cases hw' : 1 ≤ w ++ · have hxker : x ∈ LinearMap.ker ((f - k • 1) ^ w) := hw ++ rw [h_ker_pow_eq_ker w hw'] at hxker ++ simpa only [Module.End.eigenspace_def] using hxker ++ · have hw0 : w = 0 := by omega ++ subst w ++ simp only [pow_zero, Module.End.one_apply] at hw ++ subst x ++ exact (f.eigenspace k).zero_mem + · exact Module.End.eigenspace_le_maxGenEigenspace + +-#print axioms star_normal_maxGenEigenspace_eq_eigenspace +diff --git a/Gromov/ToMathlib/Analysis/Matrix/Unitary.lean b/Gromov/ToMathlib/Analysis/Matrix/Unitary.lean +index fad106a..4cbb9ee 100644 +--- a/Gromov/ToMathlib/Analysis/Matrix/Unitary.lean ++++ b/Gromov/ToMathlib/Analysis/Matrix/Unitary.lean +@@ -12,14 +12,296 @@ direct sum of the eigenspaces of that element. + + public section + ++/-- A norm-preserving finite-dimensional endomorphism has a unitary matrix. -/ ++private lemma matrix_unitary_of_norm_map {E : Type*} [NormedAddCommGroup E] ++ [InnerProductSpace ℂ E] [FiniteDimensional ℂ E] {ι : Type*} ++ [Fintype ι] [DecidableEq ι] (b : OrthonormalBasis ι ℂ E) ++ (f : E →ₗ[ℂ] E) (hf : ∀ x, ‖f x‖ = ‖x‖) : ++ LinearMap.toMatrixOrthonormal b f ∈ Matrix.unitaryGroup ι ℂ := by ++ let i : E →ₗᵢ[ℂ] E := { toLinearMap := f, norm_map' := hf } ++ let e := LinearIsometryEquiv.ofSurjective i ++ ((LinearMap.injective_iff_surjective).mp i.injective) ++ exact e.toMatrix_mem_unitaryGroup b b ++ ++private lemma adjoint_comp_self_of_norm_map {E F : Type*} ++ [NormedAddCommGroup E] [InnerProductSpace ℂ E] [FiniteDimensional ℂ E] ++ [NormedAddCommGroup F] [InnerProductSpace ℂ F] [FiniteDimensional ℂ F] ++ (f : E →ₗ[ℂ] F) (hf : ∀ x, ‖f x‖ = ‖x‖) : ++ (LinearMap.adjoint f).comp f = 1 := by ++ apply LinearMap.ext ++ intro x ++ apply ext_inner_right ℂ ++ intro y ++ simp only [LinearMap.comp_apply, Module.End.one_apply, LinearMap.adjoint_inner_left] ++ exact (LinearMap.norm_map_iff_inner_map_map f).mp hf x y ++ ++/-- Restriction to two orthogonal invariant summands splits the unitary centralizer. -/ ++private lemma unitary_centralizer_blocks {n : ℕ} ++ (g : Matrix.unitaryGroup (Fin n) ℂ) ++ (p q : Submodule ℂ (EuclideanSpace ℂ (Fin n))) ++ (hcomp : IsCompl p q) (horth : p ⟂ q) ++ (hp : ∀ h : Subgroup.centralizer {g}, ++ Set.MapsTo h.val.val.toEuclideanLin p p) ++ (hq : ∀ h : Subgroup.centralizer {g}, ++ Set.MapsTo h.val.val.toEuclideanLin q q) ++ (hgp : Set.MapsTo g.val.toEuclideanLin p p) ++ (hqg : Set.MapsTo g.val.toEuclideanLin q q) : ++ ∃ (A : Subgroup (Matrix.unitaryGroup (Fin (Module.finrank ℂ p)) ℂ)) ++ (B : Subgroup (Matrix.unitaryGroup (Fin (Module.finrank ℂ q)) ℂ)), ++ Nonempty (Subgroup.centralizer {g} ≃* A × B) := by ++ have comm_g_h (h : Subgroup.centralizer {g}) : ++ Commute g.val.toEuclideanLin h.val.val.toEuclideanLin := by ++ have hh := h.property ++ rw [Subgroup.mem_centralizer_iff] at hh ++ have hg : g * h.val = h.val * g := hh g (by simp) ++ apply_fun (fun x => Matrix.toEuclideanLin x.val) at hg ++ rw [commute_iff_eq] ++ simpa only [Submonoid.coe_mul, Matrix.toEuclideanLin, Matrix.toLpLin_mul_same, ++ Module.End.mul_eq_comp] using hg ++ let map_first (h : Subgroup.centralizer {g}) := ++ h.val.val.toEuclideanLin.restrict (hp h) ++ ++ ++ let d := (Module.finrank ℂ ↥p) ++ let map_first_unitary (h: Subgroup.centralizer {g}): Matrix.unitaryGroup (Fin d) ℂ := { ++ val := LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥p) (map_first h) ++ property := by ++ apply matrix_unitary_of_norm_map ++ intro x ++ exact unitary_preserves_norm n h.val x.val ++ } ++ ++ ++ let map_first_hom: MonoidHom (Subgroup.centralizer {g}) _ := { ++ toFun := map_first_unitary ++ map_one' := by ++ have h_one : map_first 1 = 1 := by ++ apply LinearMap.ext ++ intro x ++ apply Subtype.ext ++ change Matrix.toEuclideanLin (1 : Matrix (Fin n) (Fin n) ℂ) x.val = x.val ++ simp [Matrix.toEuclideanLin_eq_toLin_orthonormal] ++ apply Subtype.ext ++ exact (congrArg (LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥p)) h_one).trans (map_one _) ++ map_mul' := by ++ intro x y ++ have h_mul : map_first (x * y) = map_first x * map_first y := by ++ apply LinearMap.ext ++ intro z ++ apply Subtype.ext ++ change Matrix.toEuclideanLin (x.val.val * y.val.val) z.val = ++ Matrix.toEuclideanLin x.val.val (Matrix.toEuclideanLin y.val.val z.val) ++ simp only [Matrix.toEuclideanLin, Matrix.toLpLin_mul_same, LinearMap.comp_apply] ++ apply Subtype.ext ++ exact (congrArg (LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥p)) h_mul).trans ++ (map_mul _ _ _) ++ } ++ ++ let first_range := map_first_hom.range ++ ++ ++ let map_second (h : Subgroup.centralizer {g}) := ++ h.val.val.toEuclideanLin.restrict (hq h) ++ ++ ++ let map_second_unitary (h: Subgroup.centralizer {g}): Matrix.unitaryGroup _ ℂ := { ++ val := LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥q) (map_second h) ++ property := by ++ apply matrix_unitary_of_norm_map ++ intro x ++ exact unitary_preserves_norm n h.val x.val ++ } ++ ++ let map_second_hom: MonoidHom (Subgroup.centralizer {g}) _ := { ++ toFun := map_second_unitary ++ -- TODO - deduplicate these with 'map_first_hom' ++ map_one' := by ++ have h_one : map_second 1 = 1 := by ++ apply LinearMap.ext ++ intro x ++ apply Subtype.ext ++ change Matrix.toEuclideanLin (1 : Matrix (Fin n) (Fin n) ℂ) x.val = x.val ++ simp [Matrix.toEuclideanLin_eq_toLin_orthonormal] ++ apply Subtype.ext ++ exact (congrArg (LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥q)) h_one).trans (map_one _) ++ map_mul' := by ++ intro x y ++ have h_mul : map_second (x * y) = map_second x * map_second y := by ++ apply LinearMap.ext ++ intro z ++ apply Subtype.ext ++ change Matrix.toEuclideanLin (x.val.val * y.val.val) z.val = ++ Matrix.toEuclideanLin x.val.val (Matrix.toEuclideanLin y.val.val z.val) ++ simp only [Matrix.toEuclideanLin, Matrix.toLpLin_mul_same, LinearMap.comp_apply] ++ apply Subtype.ext ++ exact (congrArg (LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥q)) h_mul).trans ++ (map_mul _ _ _) ++ } ++ ++ let prod_hom := MonoidHom.prod map_first_hom.rangeRestrict map_second_hom.rangeRestrict ++ let prod_iso := MulEquiv.ofBijective prod_hom (by ++ unfold Function.Bijective ++ refine ⟨?_, ?_⟩ ++ . ++ intro x y hxy ++ have hfirst : map_first_hom x = map_first_hom y := ++ congrArg (fun z => z.1.val) hxy ++ have hsecond : map_second_hom x = map_second_hom y := ++ congrArg (fun z => z.2.val) hxy ++ have hfirst' : map_first x = map_first y := ++ (LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥p)).injective ++ (congrArg Subtype.val hfirst) ++ have hsecond' : map_second x = map_second y := ++ (LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥q)).injective ++ (congrArg Subtype.val hsecond) ++ apply Subtype.ext ++ apply Subtype.ext ++ apply Matrix.toEuclideanLin.injective ++ apply LinearMap.ext ++ intro z ++ obtain ⟨zp, zq, hz, _⟩ := Submodule.existsUnique_add_of_isCompl hcomp z ++ rw [← hz, map_add, map_add] ++ exact congrArg₂ (· + ·) ++ (congrArg Subtype.val (DFunLike.congr_fun hfirst' zp)) ++ (congrArg Subtype.val (DFunLike.congr_fun hsecond' zq)) ++ . ++ intro a ++ have first_prop := a.fst.property ++ have second_prop := a.snd.property ++ simp only [prod_hom] ++ rw [MonoidHom.mem_range] at first_prop ++ rw [MonoidHom.mem_range] at second_prop ++ ++ obtain ⟨x, hx⟩ := first_prop ++ obtain ⟨y, hy⟩ := second_prop ++ ++ let map_first_x_new: p →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { ++ toFun := fun a => map_first x a ++ map_add' := by simp ++ map_smul' := by simp ++ } ++ ++ let map_second_y_new: ↑q →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { ++ toFun := fun a => map_second y a ++ map_add' := by simp ++ map_smul' := by simp ++ } ++ ++ have map_first_x_unitary : ++ (ContinuousLinearMap.adjoint (𝕜 := ℂ) (E := p) ++ (F := EuclideanSpace ℂ (Fin n)) map_first_x_new.toContinuousLinearMap).comp ++ map_first_x_new.toContinuousLinearMap = 1 := by ++ rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] ++ intro z ++ exact unitary_preserves_norm n x.val z.val ++ apply_fun (fun f => f.toLinearMap) at map_first_x_unitary ++ simp at map_first_x_unitary ++ have map_second_y_unitary : ++ (ContinuousLinearMap.adjoint (𝕜 := ℂ) (E := q) ++ (F := EuclideanSpace ℂ (Fin n)) map_second_y_new.toContinuousLinearMap).comp ++ map_second_y_new.toContinuousLinearMap = 1 := by ++ rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] ++ intro z ++ exact unitary_preserves_norm n y.val z.val ++ apply_fun (fun f => f.toLinearMap) at map_second_y_unitary ++ simp at map_second_y_unitary ++ ++ let new := LinearMap.ofIsCompl hcomp map_first_x_new map_second_y_new ++ use ⟨⟨(Matrix.toEuclideanLin.symm new), (by ++ simp [Matrix.mem_unitaryGroup_iff'] ++ apply_fun (fun f => Matrix.toEuclideanLin f) ++ . simp [-EmbeddingLike.apply_eq_iff_eq, new] ++ rw [Matrix.star_eq_conjTranspose] ++ simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] ++ simp ++ rw [← LinearMap.toMatrix_adjoint] ++ simp ++ ++ ++ conv => ++ rhs ++ equals 1 => ++ ext z ++ simp ++ ++ ++ apply ofIsCompl_adjoint_comp ++ . exact horth ++ . ++ apply map_first_x_unitary ++ . intro v ++ exact (map_first x v).2 ++ . ++ apply map_second_y_unitary ++ . intro v ++ exact (map_second y v).2 ++ . intro x y hxy ++ simpa using hxy ++ )⟩, (by ++ rw [Subgroup.mem_centralizer_iff] ++ simp ++ apply_fun (fun f => Matrix.toEuclideanLin f.val) ++ simp only [] ++ simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] ++ simp only [Matrix.toLin_symm, Submonoid.coe_mul] ++ rw [Matrix.toLin_mul (v₂ := (EuclideanSpace.basisFun (Fin n) ℂ).toBasis )] ++ simp ++ rw [Matrix.toLin_mul (v₂ := (EuclideanSpace.basisFun (Fin n) ℂ).toBasis )] ++ simp [new] ++ rw [eq_comm] ++ apply ofIsCompl_commute ++ . intro z ++ change x.val.val.toEuclideanLin (g.val.toEuclideanLin z.val) = ++ g.val.toEuclideanLin (x.val.val.toEuclideanLin z.val) ++ exact DFunLike.congr_fun (comm_g_h x).eq.symm z.val ++ . intro z ++ change y.val.val.toEuclideanLin (g.val.toEuclideanLin z.val) = ++ g.val.toEuclideanLin (y.val.val.toEuclideanLin z.val) ++ exact DFunLike.congr_fun (comm_g_h y).eq.symm z.val ++ . exact fun z => hgp z.property ++ . exact fun z => hqg z.property ++ . intro a b hab ++ simpa using hab ++ ++ )⟩ ++ ++ ++ apply Prod.ext ++ . ++ rw [Subtype.ext_iff] ++ conv => ++ rhs ++ rw [← hx] ++ simp ++ simp [map_first_hom, map_first_unitary] ++ apply LinearMap.ext ++ intro z ++ apply Subtype.ext ++ simp only [LinearMap.coe_restrict_apply, new, LinearEquiv.apply_symm_apply, ++ LinearMap.ofIsCompl_apply_left, map_first_x_new, map_first, LinearMap.coe_mk, ++ AddHom.coe_mk] ++ . ++ rw [Subtype.ext_iff] ++ conv => ++ rhs ++ rw [← hy] ++ simp ++ simp [map_second_hom, map_second_unitary] ++ simp [map_second] ++ rw [LinearMap.ext_iff] ++ intro z ++ rw [Subtype.ext_iff] ++ simp [new] ++ simp [map_second_y_new, map_second] ++ ) ++ exact ⟨map_first_hom.range, map_second_hom.range, ⟨prod_iso⟩⟩ ++ + -- The rewrites below name their scalar field, source and target explicitly. Left implicit, + -- each would leave a metavariable whose instances sit across a diamond on these spaces + -- (`Submodule`'s subtype/`addCommGroup`/`module` vs the `NormedAddCommGroup`/ + -- `InnerProductSpace` structures), which only reconciles at a raised `maxSynthPendingDepth`. + -- Note the two rewrites in each block act on *different* spaces: the restricted eigenspace + -- and the ambient `EuclideanSpace ℂ (Fin n)`. +-set_option maxHeartbeats 4000000 in +-set_option synthInstance.maxHeartbeats 100000 in + lemma centralizer_iso {n: ℕ} [hn: NeZero n] (G: Subgroup (Matrix.unitaryGroup (Fin n) ℂ)) (g: G) (g_not: ∀ z: ℂ, g.val.val ≠ z • 1): + Nonempty (IsoData g) := by + +@@ -84,562 +366,34 @@ lemma centralizer_iso {n: ℕ} [hn: NeZero n] (G: Subgroup (Matrix.unitaryGroup + --simp_rw [Module.End.mem_invtSubmodule_iff_forall_mem_of_mem] at other_invariant + + +- let map_first (h: Subgroup.centralizer {g.val}) := h.val.val.toEuclideanLin.restrict (Module.End.mapsTo_genEigenspace_of_comm (f := g.val.val.toEuclideanLin) (g := h.val.val.toEuclideanLin) (by +- apply comm_g_h +- ) k ⊤) +- +- +- let d := (Module.finrank ℂ ↥((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤)) +- let map_first_unitary (h: Subgroup.centralizer {g.val}): Matrix.unitaryGroup (Fin d) ℂ := { +- val := LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤)) (map_first h) +- property := by +- +- +- rw [Matrix.mem_unitaryGroup_iff'] +- +- conv => +- lhs +- lhs +- -- TODO - why does this timeout when not inside 'conv'? +- rw [Matrix.star_eq_conjTranspose] +- +- simp only [LinearMap.toMatrixOrthonormal_apply] +- simp [] +- conv => +- lhs +- lhs +- -- TODO - why does this timeout when not inside 'conv'? +- rw [← LinearMap.toMatrix_adjoint] +- arg 2 +- rw [← LinearMap.toMatrix_mul] +- +- apply_fun Matrix.toLin (stdOrthonormalBasis ℂ _).toBasis (stdOrthonormalBasis ℂ _).toBasis +- rw [Matrix.toLin_toMatrix] +- rw [Matrix.toLin_one] +- conv => +- rhs +- equals 1 => +- ext a +- simp +- +- simp [map_first] +- have h_unitary := Unitary.star_mul_self_of_mem h.val.property +- apply_fun Matrix.toEuclideanLin at h_unitary +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] at h_unitary +- conv at h_unitary => +- lhs +- equals (Matrix.toEuclideanLin (star h.val.val)) ∘ₗ (Matrix.toEuclideanLin (h.val.val)) => +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- rw [← Matrix.toLin_mul] +- rw [← Matrix.toEuclideanLin_eq_toLin_orthonormal] at h_unitary +- rw [Matrix.star_eq_conjTranspose] at h_unitary +- rw [Matrix.toEuclideanLin_conjTranspose_eq_adjoint] at h_unitary +- conv at h_unitary => +- rhs +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- equals 1 => +- ext z +- simp +- +- apply_fun (fun f => LinearMap.toContinuousLinearMap f) +- simp [-EmbeddingLike.apply_eq_iff_eq] +- conv => +- lhs +- rw [Module.End.mul_eq_comp] +- rw [linearmap_comp_toContinuousLinearMap] +- rw [ContinuousLinearMap.mul_def] +- lhs +- rw [LinearMap.adjoint_toContinuousLinearMap (𝕜 := ℂ) (E := ↥((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤)) (F := ↥((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤))] +- +- conv => +- rhs +- equals 1 => +- ext z +- simp +- rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] +- simp only [LinearMap.coe_toContinuousLinearMap'] +- conv => +- intro x +- rw [LinearMap.restrict_apply (by +- apply Module.End.mapsTo_genEigenspace_of_comm (by +- apply comm_g_h +- ) +- )] +- simp +- rw [← LinearMap.coe_toContinuousLinearMap'] +- +- +- apply_fun (fun f => LinearMap.toContinuousLinearMap f) at h_unitary +- simp [-EmbeddingLike.apply_eq_iff_eq] at h_unitary +- conv at h_unitary => +- lhs +- rw [linearmap_comp_toContinuousLinearMap] +- rw [ContinuousLinearMap.mul_def] +- lhs +- rw [LinearMap.adjoint_toContinuousLinearMap (𝕜 := ℂ) (E := EuclideanSpace ℂ (Fin n)) (F := EuclideanSpace ℂ (Fin n))] +- +- conv at h_unitary => +- rhs +- equals 1 => +- ext x +- simp +- rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] at h_unitary ++ let d := Module.finrank ℂ ↥((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤) ++ have horth : (Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤ ⟂ ++ (⨆ i : ℂ, ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i) := by ++ change Module.End.maxGenEigenspace _ k ⟂ _ ++ rw [star_normal_maxGenEigenspace_eq_eigenspace (by simp)] ++ conv => ++ rhs ++ arg 1 + intro x +- specialize h_unitary x.val +- exact h_unitary +- . exact LinearEquiv.injective LinearMap.toContinuousLinearMap +- . intro x y hxy +- simpa using hxy +- } +- +- +- let map_first_hom: MonoidHom (Subgroup.centralizer {g.val}) _ := { +- toFun := map_first_unitary +- map_one' := by +- simp [map_first_unitary, map_first] +- apply_fun Matrix.toLin (stdOrthonormalBasis ℂ _).toBasis (stdOrthonormalBasis ℂ _).toBasis +- . +- simp +- simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- ext a +- rfl +- . intro x y hxy +- simpa using hxy +- map_mul' := by +- intro x y +- simp [map_first_unitary, map_first] +- apply_fun Matrix.toLin (stdOrthonormalBasis ℂ _).toBasis (stdOrthonormalBasis ℂ _).toBasis +- . +- simp +- rw [LinearMap.ext_iff] +- intro a +- rw [← LinearMap.toMatrix_mul] +- simp +- simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- conv => +- lhs +- arg 1 +- arg 1 +- -- TODO - figure out why toLin_mul doesn't work here +- equals ((Matrix.toLin (EuclideanSpace.basisFun (Fin n) ℂ).toBasis (EuclideanSpace.basisFun (Fin n) ℂ).toBasis) (↑↑↑x)) ∘ₗ (((Matrix.toLin (EuclideanSpace.basisFun (Fin n) ℂ).toBasis (EuclideanSpace.basisFun (Fin n) ℂ).toBasis) (↑↑↑y))) => +- rw [← Matrix.toLin_mul] +- +- rfl +- . intro x y hxy +- simpa using hxy +- } +- +- let first_range := map_first_hom.range +- +- +- let map_second (h: Subgroup.centralizer {g.val}) := h.val.val.toEuclideanLin.restrict +- (p := ↑((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i))) +- (q := ↑((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i))) ++ arg 1 ++ intro x ++ rw [star_normal_maxGenEigenspace_eq_eigenspace (by simp)] ++ simp ++ intro i hi ++ apply eigenspace_orthogonal ++ · simp ++ · omega ++ obtain ⟨A, B, ⟨prod_iso⟩⟩ := unitary_centralizer_blocks g.val _ _ a_b_compl horth ++ (fun h => Module.End.mapsTo_genEigenspace_of_comm (comm_g_h h) k ⊤) ++ (fun h => by ++ apply LinearMap.mapsTo_biSup_of_mapsTo ++ intro i ++ exact Module.End.mapsTo_maxGenEigenspace_of_comm (comm_g_h h) i) ++ (Module.End.mapsTo_genEigenspace_of_comm (by simp) k ⊤) + (by +- intro x hx + apply LinearMap.mapsTo_biSup_of_mapsTo +- . +- intro z +- apply Module.End.mapsTo_maxGenEigenspace_of_comm +- apply comm_g_h +- . exact hx +- ) +- +- +- let map_second_unitary (h: Subgroup.centralizer {g.val}): Matrix.unitaryGroup _ ℂ := { +- val := LinearMap.toMatrixOrthonormal (stdOrthonormalBasis ℂ ↥((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i))) (map_second h) +- property := by +- -- TODO - deduplicate this with 'map_first_unitary' +- rw [Matrix.mem_unitaryGroup_iff'] +- +- conv => +- lhs +- lhs +- -- TODO - why does this timeout when not inside 'conv'? +- rw [Matrix.star_eq_conjTranspose] +- +- simp only [LinearMap.toMatrixOrthonormal_apply] +- simp [] +- conv => +- lhs +- lhs +- -- TODO - why does this timeout when not inside 'conv'? +- rw [← LinearMap.toMatrix_adjoint] +- arg 2 +- rw [← LinearMap.toMatrix_mul] +- +- apply_fun Matrix.toLin (stdOrthonormalBasis ℂ _).toBasis (stdOrthonormalBasis ℂ _).toBasis +- rw [Matrix.toLin_toMatrix] +- rw [Matrix.toLin_one] +- conv => +- rhs +- equals 1 => +- ext a +- simp +- +- simp [map_second] +- have h_unitary := Unitary.star_mul_self_of_mem h.val.property +- apply_fun Matrix.toEuclideanLin at h_unitary +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] at h_unitary +- conv at h_unitary => +- lhs +- equals (Matrix.toEuclideanLin (star h.val.val)) ∘ₗ (Matrix.toEuclideanLin (h.val.val)) => +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- rw [← Matrix.toLin_mul] +- rw [← Matrix.toEuclideanLin_eq_toLin_orthonormal] at h_unitary +- rw [Matrix.star_eq_conjTranspose] at h_unitary +- rw [Matrix.toEuclideanLin_conjTranspose_eq_adjoint] at h_unitary +- conv at h_unitary => +- rhs +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- equals 1 => +- ext z +- simp +- +- apply_fun (fun f => LinearMap.toContinuousLinearMap f) +- simp [-EmbeddingLike.apply_eq_iff_eq] +- conv => +- lhs +- rw [Module.End.mul_eq_comp] +- rw [linearmap_comp_toContinuousLinearMap] +- rw [ContinuousLinearMap.mul_def] +- lhs +- rw [LinearMap.adjoint_toContinuousLinearMap (𝕜 := ℂ) (E := ↥((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i))) (F := ↥((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i)))] +- +- conv => +- rhs +- equals 1 => +- ext z +- simp +- rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] +- simp only [LinearMap.coe_toContinuousLinearMap'] +- conv => +- intro x +- rw [LinearMap.restrict_apply (by +- apply LinearMap.mapsTo_biSup_of_mapsTo +- intro z +- apply Module.End.mapsTo_maxGenEigenspace_of_comm +- apply comm_g_h +- )] +- simp +- rw [← LinearMap.coe_toContinuousLinearMap'] +- +- +- apply_fun (fun f => LinearMap.toContinuousLinearMap f) at h_unitary +- simp [-EmbeddingLike.apply_eq_iff_eq] at h_unitary +- conv at h_unitary => +- lhs +- rw [linearmap_comp_toContinuousLinearMap] +- rw [ContinuousLinearMap.mul_def] +- lhs +- rw [LinearMap.adjoint_toContinuousLinearMap (𝕜 := ℂ) (E := EuclideanSpace ℂ (Fin n)) (F := EuclideanSpace ℂ (Fin n))] +- +- conv at h_unitary => +- rhs +- equals 1 => +- ext x +- simp +- rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] at h_unitary +- intro x +- specialize h_unitary x.val +- exact h_unitary +- . exact LinearEquiv.injective LinearMap.toContinuousLinearMap +- . intro x y hxy +- simpa using hxy +- } +- +- let map_second_hom: MonoidHom (Subgroup.centralizer {g.val}) _ := { +- toFun := map_second_unitary +- -- TODO - deduplicate these with 'map_first_hom' +- map_one' := by +- simp [map_second_unitary, map_second] +- apply_fun Matrix.toLin (stdOrthonormalBasis ℂ _).toBasis (stdOrthonormalBasis ℂ _).toBasis +- . +- simp +- simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- ext a +- rfl +- . intro x y hxy +- simpa using hxy +- map_mul' := by +- intro x y +- simp [map_second_unitary, map_second] +- apply_fun Matrix.toLin (stdOrthonormalBasis ℂ _).toBasis (stdOrthonormalBasis ℂ _).toBasis +- . +- simp +- rw [LinearMap.ext_iff] +- intro a +- rw [← LinearMap.toMatrix_mul] +- simp +- simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- conv => +- lhs +- arg 1 +- arg 1 +- -- TODO - figure out why toLin_mul doesn't work here +- equals ((Matrix.toLin (EuclideanSpace.basisFun (Fin n) ℂ).toBasis (EuclideanSpace.basisFun (Fin n) ℂ).toBasis) (↑↑↑x)) ∘ₗ (((Matrix.toLin (EuclideanSpace.basisFun (Fin n) ℂ).toBasis (EuclideanSpace.basisFun (Fin n) ℂ).toBasis) (↑↑↑y))) => +- rw [← Matrix.toLin_mul] +- +- rfl +- . intro x y hxy +- simpa using hxy +- } +- +- let prod_hom := MonoidHom.prod map_first_hom.rangeRestrict map_second_hom.rangeRestrict +- let prod_iso := MulEquiv.ofBijective prod_hom (by +- unfold Function.Bijective +- refine ⟨?_, ?_⟩ +- . +- -- TODO - this can probably be much simpler +- simp [prod_hom] +- intro x y hxy +- simp at hxy +- obtain ⟨first_eq, second_eq⟩ := hxy +- +- let map_first_x_new: ((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤) →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { +- toFun := fun a => map_first x a +- map_add' := by simp +- map_smul' := by simp +- } +- +- let map_second_x_new: ↑((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i)) →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { +- toFun := fun a => map_second x a +- map_add' := by simp +- map_smul' := by simp +- } +- +- let x_map := LinearMap.ofIsCompl a_b_compl (map_first_x_new) (map_second_x_new) +- +- let map_first_y_new: ((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤) →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { +- toFun := fun a => map_first y a +- map_add' := by simp +- map_smul' := by simp +- } +- +- let map_second_y_new: ↑((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i)) →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { +- toFun := fun a => map_second y a +- map_add' := by simp +- map_smul' := by simp +- } +- +- let y_map := LinearMap.ofIsCompl a_b_compl (map_first_y_new) (map_second_y_new) +- +- have first_eq_second: x_map = y_map := by +- simp [x_map] +- apply LinearMap.ofIsCompl_eq +- . intro z +- simp [y_map] +- simp [map_first_x_new, map_first_y_new] +- apply_fun (fun f => f.val) at first_eq +- simp at first_eq +- simp [map_first_hom, map_first_unitary] at first_eq +- rw [first_eq] +- . intro z +- simp [y_map] +- simp [map_second_x_new, map_second_y_new] +- apply_fun (fun f => f.val) at second_eq +- simp at second_eq +- simp [map_second_hom, map_second_unitary] at second_eq +- congr +- +- +- have x_map_eq: x_map = x.val.val.toEuclideanLin := by +- simp [x_map] +- apply LinearMap.ofIsCompl_eq +- . intro z +- rfl +- . intro z +- rfl +- +- have y_map_eq: y_map = y.val.val.toEuclideanLin := by +- simp [y_map] +- apply LinearMap.ofIsCompl_eq +- . intro z +- rfl +- . intro z +- rfl +- +- +- rw [x_map_eq, y_map_eq] at first_eq_second +- simp at first_eq_second +- exact first_eq_second +- . +- intro a +- have first_prop := a.fst.property +- have second_prop := a.snd.property +- simp only [prod_hom] +- rw [MonoidHom.mem_range] at first_prop +- rw [MonoidHom.mem_range] at second_prop +- +- obtain ⟨x, hx⟩ := first_prop +- obtain ⟨y, hy⟩ := second_prop +- +- let map_first_x_new: ((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤) →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { +- toFun := fun a => map_first x a +- map_add' := by simp +- map_smul' := by simp +- } +- +- let map_second_y_new: ↑((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i)) →ₗ[ℂ] (EuclideanSpace ℂ (Fin n)) := { +- toFun := fun a => map_second y a +- map_add' := by simp +- map_smul' := by simp +- } +- +- have map_first_x_unitary: (ContinuousLinearMap.adjoint (𝕜 := ℂ) (E := ↥((Module.End.genEigenspace (Matrix.toEuclideanLin g.val.val) k) ⊤)) (F := EuclideanSpace ℂ (Fin n)) map_first_x_new.toContinuousLinearMap).comp map_first_x_new.toContinuousLinearMap = 1 := by +- rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] +- intro z +- simp [map_first_x_new, map_first] +- apply unitary_preserves_norm +- +- apply_fun (fun f => f.toLinearMap) at map_first_x_unitary +- simp at map_first_x_unitary +- +- have map_second_y_unitary: (ContinuousLinearMap.adjoint (𝕜 := ℂ) (E := ↥((iSup fun (i : ℂ) ↦ ⨆ (_ : i ≠ k), Module.End.maxGenEigenspace (Matrix.toEuclideanLin g.val.val) i))) (F := EuclideanSpace ℂ (Fin n)) map_second_y_new.toContinuousLinearMap).comp map_second_y_new.toContinuousLinearMap = 1 := by +- rw [← ContinuousLinearMap.norm_map_iff_adjoint_comp_self] +- intro z +- simp [map_second_y_new, map_second] +- apply unitary_preserves_norm +- +- apply_fun (fun f => f.toLinearMap) at map_second_y_unitary +- simp at map_second_y_unitary +- +- let new := LinearMap.ofIsCompl a_b_compl map_first_x_new map_second_y_new +- use ⟨⟨(Matrix.toEuclideanLin.symm new), (by +- simp [Matrix.mem_unitaryGroup_iff'] +- apply_fun (fun f => Matrix.toEuclideanLin f) +- . simp [-EmbeddingLike.apply_eq_iff_eq, new] +- rw [Matrix.star_eq_conjTranspose] +- simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- simp +- rw [← LinearMap.toMatrix_adjoint] +- simp +- +- +- conv => +- rhs +- equals 1 => +- ext z +- simp +- +- +- apply ofIsCompl_adjoint_comp +- . +- rw [star_normal_maxGenEigenspace_eq_eigenspace (by simp)] +- conv => +- rhs +- arg 1 +- intro x +- arg 1 +- intro x +- rw [star_normal_maxGenEigenspace_eq_eigenspace (by simp)] +- simp +- intro i hi +- apply eigenspace_orthogonal +- . simp +- . omega +- . +- apply map_first_x_unitary +- . intro v +- exact (map_first x v).2 +- . +- apply map_second_y_unitary +- . intro v +- exact (map_second y v).2 +- . intro x y hxy +- simpa using hxy +- )⟩, (by +- rw [Subgroup.mem_centralizer_iff] +- simp +- apply_fun (fun f => Matrix.toEuclideanLin f.val) +- simp only [] +- simp_rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- simp only [Matrix.toLin_symm, Submonoid.coe_mul] +- rw [Matrix.toLin_mul (v₂ := (EuclideanSpace.basisFun (Fin n) ℂ).toBasis )] +- simp +- rw [Matrix.toLin_mul (v₂ := (EuclideanSpace.basisFun (Fin n) ℂ).toBasis )] +- simp [new] +- rw [eq_comm] +- apply ofIsCompl_commute +- . +- intro z +- simp [map_first_x_new, map_first] +- simp_rw [← Matrix.toEuclideanLin_eq_toLin_orthonormal] +- have x_prop := x.property +- rw [Subgroup.mem_centralizer_iff] at x_prop +- simp at x_prop +- rw [Subtype.ext_iff] at x_prop +- simp at x_prop +- show (Matrix.toEuclideanLin (↑↑x : Matrix (Fin n) (Fin n) ℂ)) +- ((Matrix.toEuclideanLin (↑↑g : Matrix (Fin n) (Fin n) ℂ)) (↑z : EuclideanSpace ℂ (Fin n))) +- = (Matrix.toEuclideanLin (↑↑g : Matrix (Fin n) (Fin n) ℂ)) +- ((Matrix.toEuclideanLin (↑↑x : Matrix (Fin n) (Fin n) ℂ)) (↑z : EuclideanSpace ℂ (Fin n))) +- simp only [Matrix.toEuclideanLin_apply, WithLp.ofLp_toLp, Matrix.mulVec_mulVec] +- rw [x_prop] +- . +- intro z +- simp [map_second_y_new, map_second] +- simp_rw [← Matrix.toEuclideanLin_eq_toLin_orthonormal] +- rw [Matrix.toEuclideanLin_apply] +- rw [Matrix.toEuclideanLin_apply] +- rw [Matrix.toEuclideanLin_apply] +- rw [Matrix.toEuclideanLin_apply] +- simp +- have y_prop := y.property +- rw [Subgroup.mem_centralizer_iff] at y_prop +- simp at y_prop +- rw [Subtype.ext_iff] at y_prop +- simp at y_prop +- rw [y_prop] +- . +- intro z +- apply Module.End.mapsTo_maxGenEigenspace_of_comm +- rw [commute_iff_eq] +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- simp +- . +- intro x +- apply LinearMap.mapsTo_biSup_of_mapsTo +- . +- intro z +- apply Module.End.mapsTo_maxGenEigenspace_of_comm +- rw [commute_iff_eq] +- rw [Matrix.toEuclideanLin_eq_toLin_orthonormal] +- . simp +- . intro a b hab +- simpa using hab +- +- )⟩ +- +- +- apply Prod.ext +- . +- rw [Subtype.ext_iff] +- conv => +- rhs +- rw [← hx] +- simp +- simp [map_first_hom, map_first_unitary] +- apply LinearMap.ext +- intro z +- apply Subtype.ext +- simp only [LinearMap.restrict_coe_apply, new, LinearEquiv.apply_symm_apply, +- LinearMap.ofIsCompl_apply_left, map_first_x_new, map_first, LinearMap.coe_mk, +- AddHom.coe_mk] +- . +- rw [Subtype.ext_iff] +- conv => +- rhs +- rw [← hy] +- simp +- simp [map_second_hom, map_second_unitary] +- simp [map_second] +- rw [LinearMap.ext_iff] +- intro z +- rw [Subtype.ext_iff] +- simp [new] +- simp [map_second_y_new, map_second] +- ) ++ intro i ++ exact Module.End.mapsTo_maxGenEigenspace_of_comm (by simp) i) + -- Submodule.finrank_add_eq_of_isCompl + + +@@ -676,9 +430,8 @@ lemma centralizer_iso {n: ℕ} [hn: NeZero n] (G: Subgroup (Matrix.unitaryGroup + apply Submodule.finrank_lt at gen_eigenspace_top + rw [sum_eq] at gen_eigenspace_top + simp at gen_eigenspace_top +- A := _ +- B := _ ++ A := A ++ B := B + iso := prod_iso + } + +-#print axioms centralizer_iso +diff --git a/Gromov/ToMathlib/Data/List/Infix.lean b/Gromov/ToMathlib/Data/List/Infix.lean +index aa5c209..d5a4ed5 100644 +--- a/Gromov/ToMathlib/Data/List/Infix.lean ++++ b/Gromov/ToMathlib/Data/List/Infix.lean +@@ -167,4 +167,3 @@ lemma list_adjacent_elements {A: Type*} (l: List A) (p: A → Bool) (n : ℕ): + rw [Nat.one_le_div_iff hn] + omega + +-#print axioms list_adjacent_elements +diff --git a/Gromov/ToMathlib/GroupTheory/Closure.lean b/Gromov/ToMathlib/GroupTheory/Closure.lean +index 58aa14c..d01b3f7 100644 +--- a/Gromov/ToMathlib/GroupTheory/Closure.lean ++++ b/Gromov/ToMathlib/GroupTheory/Closure.lean +@@ -12,7 +12,6 @@ public section + + open scoped Pointwise Finset + +-set_option maxHeartbeats 300000 in + lemma closure_iterate_mulact {T: Type*} [Group T] [DecidableEq T] (a b: T) (n: ℤ) + (conj_in: (a^n * b * a^(-n)) ∈ (Subgroup.closure (G := T) (Set.image (fun (m: ℤ) => a^m * b * a^(-m)) (Set.Ioo (-n.natAbs) n.natAbs)))) + (conj_inv_in: (a^(-n) * b * a^(n)) ∈ (Subgroup.closure (G := T) (Set.image (fun (m: ℤ) => a^m * b * a^(-m)) (Set.Ioo (-n.natAbs) n.natAbs)))) : +@@ -316,7 +315,6 @@ lemma closure_iterate_mulact {T: Type*} [Group T] [DecidableEq T] (a b: T) (n: + | inv y hy y_mem => + apply Subgroup.inv_mem _ y_mem + +-#print axioms closure_iterate_mulact + + namespace Subgroup + +@@ -390,7 +388,6 @@ lemma closure_set_union_normal {G: Type*} [Group G] (S: Set G) (N: Subgroup G) ( + simp + group + +-#print axioms closure_set_union_normal + + -- TODO - deduplicate with with 'mem_S_prod_list' + lemma mem_closure_prod_list {G: Type*} [Group G] (S: Set G) (S_eq_Sinv: S = S⁻¹) (x: G) (hx: x ∈ Subgroup.closure S): ∃ l: List S, l.unattach.prod = x := by +diff --git a/Gromov/ToMathlib/LinearAlgebra/Matrix/Det.lean b/Gromov/ToMathlib/LinearAlgebra/Matrix/Det.lean +index f9574a1..ce1739e 100644 +--- a/Gromov/ToMathlib/LinearAlgebra/Matrix/Det.lean ++++ b/Gromov/ToMathlib/LinearAlgebra/Matrix/Det.lean +@@ -7,17 +7,12 @@ public import Gromov.ToMathlib.LinearAlgebra.Matrix.ToMatrix + /-! + # Determinants of matrices of bilinear forms + +-General-purpose material extracted from the Gromov development, destined for mathlib. ++Basis changes preserve determinant ratios; positive semidefinite comparison ++controls determinants of positive definite matrices. + -/ + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false +- + open scoped Finset + open scoped Pointwise + +@@ -50,19 +45,19 @@ theorem LinearMap.toMatrix₂_det_basis_change {M ι κ : Type*} [AddCommGroup M + Matrix.det_mul, Matrix.det_mul, Matrix.det_transpose, ← Module.Basis.det_apply] + ring + +- + open MatrixOrder in +-lemma matrix_det_montone {n: Type*} [Fintype n] [DecidableEq n] (A B: Matrix n n ℝ) (hb: B.PosDef) (hab: (A - B).PosSemidef): B.det ≤ A.det := by +- +- have invert_sqrt: Invertible (CFC.sqrt B) := by ++lemma matrix_det_montone {n : Type*} [Fintype n] [DecidableEq n] ++ (A B : Matrix n n ℝ) (hb : B.PosDef) (hab : (A - B).PosSemidef) : ++ B.det ≤ A.det := by ++ have invert_sqrt : Invertible (CFC.sqrt B) := by + apply Matrix.invertibleOfIsUnitDet + rw [Matrix.PosSemidef.det_sqrt hb.posSemidef] + simp + rw [← ne_eq, Real.sqrt_ne_zero] +- . grind [hb.det_pos] +- . grind [hb.det_pos] ++ · grind [hb.det_pos] ++ · grind [hb.det_pos] + +- have det_prod_eq: A.det = B.det * ((CFC.sqrt B)⁻¹ * (A - B) * (CFC.sqrt B)⁻¹ + 1).det := by ++ have det_prod_eq : A.det = B.det * ((CFC.sqrt B)⁻¹ * (A - B) * (CFC.sqrt B)⁻¹ + 1).det := by + conv => + lhs + arg 1 +@@ -73,7 +68,7 @@ lemma matrix_det_montone {n: Type*} [Fintype n] [DecidableEq n] (A B: Matrix n n + rw [Matrix.det_mul] + rw [← mul_assoc, ← mul_assoc] + rw [Matrix.det_mul] +- ring ++ ring_nf + rw [hb.posSemidef.det_sqrt] + simp only [RCLike.sqrt_real] + rw [Real.sq_sqrt (by grind [hb.det_pos])] +@@ -93,7 +88,7 @@ lemma matrix_det_montone {n: Type*} [Fintype n] [DecidableEq n] (A B: Matrix n n + + rw [det_prod_eq] + rw [le_mul_iff_one_le_right] +- . ++ · + apply matrix_psd_det_one + rw [hb.posSemidef.inv_sqrt] + have foo := (CFC.sqrt_nonneg B⁻¹) +@@ -102,17 +97,17 @@ lemma matrix_det_montone {n: Type*} [Fintype n] [DecidableEq n] (A B: Matrix n n + nth_rw 2 [← foo.isHermitian.eq] + apply Matrix.PosSemidef.mul_mul_conjTranspose_same + exact hab +- . apply hb.det_pos ++ · apply hb.det_pos + +--- TODO - upstream. Mathlib only has `Finset.sum_biUnion` (which needs `PairwiseDisjoint`) +--- and the `ENNReal` `tsum` versions. +-theorem Finset.sum_biUnion_le {κ α : Type*} [DecidableEq α] {s: Finset κ} {t: κ → Finset α} +- {f: α → ℝ} (hf: ∀ x, 0 ≤ f x): ∑ x ∈ s.biUnion t, f x ≤ ∑ i ∈ s, ∑ x ∈ t i, f x := by ++/-- The sum over a finite union is bounded by the sum over its possibly ++overlapping members when all summands are nonnegative. -/ ++theorem Finset.sum_biUnion_le {κ α : Type*} [DecidableEq α] {s : Finset κ} {t : κ → Finset α} ++ {f : α → ℝ} (hf : ∀ x, 0 ≤ f x) : ∑ x ∈ s.biUnion t, f x ≤ ∑ i ∈ s, ∑ x ∈ t i, f x := by + classical + induction s using Finset.induction with + | empty => simp + | insert a s ha ih => + rw [Finset.biUnion_insert, Finset.sum_insert ha] + have hunion := Finset.sum_union_inter (s₁ := t a) (s₂ := s.biUnion t) (f := f) +- have hnn: 0 ≤ ∑ x ∈ t a ∩ s.biUnion t, f x := Finset.sum_nonneg fun x _ => hf x ++ have hnn : 0 ≤ ∑ x ∈ t a ∩ s.biUnion t, f x := Finset.sum_nonneg fun x _ => hf x + linarith +diff --git a/Gromov/ToMathlib/LinearAlgebra/Matrix/PosDef.lean b/Gromov/ToMathlib/LinearAlgebra/Matrix/PosDef.lean +index f074374..76cb7dc 100644 +--- a/Gromov/ToMathlib/LinearAlgebra/Matrix/PosDef.lean ++++ b/Gromov/ToMathlib/LinearAlgebra/Matrix/PosDef.lean +@@ -29,7 +29,7 @@ lemma matrix_psd_det_one {n: Type*} [Fintype n] [DecidableEq n] (A: Matrix n n + rw [← Matrix.diagonal_one'] + rw [Matrix.diagonal_add] + simp +- apply Finset.one_le_prod ++ apply Finset.one_le_prod₀ + intro i _ + have foo := ha.eigenvalues_nonneg + grind +diff --git a/Gromov/Unipotent/Commutator.lean b/Gromov/Unipotent/Commutator.lean +index 394e1e4..9a0f3b3 100644 +--- a/Gromov/Unipotent/Commutator.lean ++++ b/Gromov/Unipotent/Commutator.lean +@@ -17,9 +17,6 @@ public import Gromov.ToMathlib.Order.Prod.Lex + + public section + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false +-set_option linter.style.cdot false + + open scoped commutatorElement IsMulCommutative Pointwise + +@@ -45,7 +42,7 @@ lemma iterate_comm_set_eq_fold {G: Type*} [Group G] [DecidableEq G] (S: Finset G + ext g + simp + refine ⟨?_, ?_⟩ +- . ++ · + intro h + obtain ⟨s, s_mem, ⟨x, x_mem, comm_eq⟩⟩ := h + rw [← Finset.mem_coe] at x_mem +@@ -56,12 +53,12 @@ lemma iterate_comm_set_eq_fold {G: Type*} [Group G] [DecidableEq G] (S: Finset G + refine ⟨t_mem, ?_⟩ + use (⟨s, s_mem⟩ :: l) + refine ⟨?_, ?_⟩ +- . grind +- . ++ · grind ++ · + simp + rw [← comm_eq] + rw [← l_fold_eq] +- . ++ · + intro h + obtain ⟨t, t_mem, l, l_len, l_fold_eq⟩ := h + have l_len_eq := l_len +@@ -84,16 +81,15 @@ lemma iterate_comm_set_eq_fold {G: Type*} [Group G] [DecidableEq G] (S: Finset G + + use List.foldr (fun x b ↦ ⁅b, x⁆) t tail.unattach + refine ⟨?_, ?_⟩ +- . ++ · + rw [← Finset.mem_coe] + rw [ih] + simp + use t + refine ⟨t_mem, ?_⟩ + use tail +- . exact l_fold_eq ++ · exact l_fold_eq + +-#print axioms iterate_comm_set_eq_fold + + + lemma comm_prod {G: Type*} [Group G] (x y z: G): ⁅x * y, z⁆ = ⁅x, ⁅y, z⁆⁆ * ⁅y, z⁆ * ⁅x, z⁆ := by +@@ -129,12 +125,12 @@ lemma double_comm_mem {G: Type*} [DecidableEq G] [Group G] (S: Finset G) {l': G + simp + apply Subgroup.mem_closure_of_mem + apply Set.mem_union_right +- simp [mem_lowerCentralSeries_succ_iff] ++ simp + apply Subgroup.mem_closure_of_mem + simp + use ⁅g'.val, l'⁆ + refine ⟨?_, ?_⟩ +- . ++ · + + rw [← Subgroup.inv_mem_iff] + simp +@@ -142,27 +138,26 @@ lemma double_comm_mem {G: Type*} [DecidableEq G] [Group G] (S: Finset G) {l': G + simp + use l' + refine ⟨?_, ?_⟩ +- . rw [ih] ++ · rw [ih] + simp at l'_mem + cases l'_mem +- . ++ · + rename_i l'_mem_forward + apply Subgroup.mem_closure_of_mem + apply Set.mem_union_left + exact l'_mem_forward +- . rename_i l'_mem_inv ++ · rename_i l'_mem_inv + rw [← Subgroup.closure_inv] + apply Subgroup.mem_closure_of_mem + simp + left + exact l'_mem_inv +- . ++ · + use g' +- . ++ · + use l'⁻¹ + + +-set_option maxHeartbeats 400000 in + lemma triple_comm_mem {G: Type*} [Group G] [DecidableEq G] (S: Finset G) {l': G} (n: ℕ) (ih: (⊤ : Subgroup G).lowerCentralSeries n = Subgroup.closure (iterate_comm_set (S ∪ S⁻¹) n ∪ ↑((⊤ : Subgroup G).lowerCentralSeries (n + 1)))) (g': ↑(S ∪ S⁻¹)) (l'_mem_comm: l' ∈ iterate_comm_set (S ∪ S⁻¹) n ∨ l'⁻¹ ∈ iterate_comm_set (S ∪ S⁻¹) n): ⁅l'⁻¹, ⁅g'.val, l'⁆⁆ * ⁅g'.val, l'⁆ ∈ Subgroup.closure (iterate_comm_set (S ∪ S⁻¹) (n + 1) ∪ ↑((⊤ : Subgroup G).lowerCentralSeries (n + 1 + 1))) := by + + +@@ -171,36 +166,36 @@ lemma triple_comm_mem {G: Type*} [Group G] [DecidableEq G] (S: Finset G) {l': G} + + + cases l'_mem_comm +- . ++ · + rw [← Subgroup.inv_mem_iff] + simp + rename_i l'_mem +- . apply Subgroup.mul_mem +- . ++ · apply Subgroup.mul_mem ++ · + apply Subgroup.mem_closure_of_mem + apply Set.mem_union_left + simp [iterate_comm_set] + use g' + refine ⟨by simpa using g'_prop, ?_⟩ + use l' +- . ++ · + rw [← Subgroup.inv_mem_iff] + simp + apply double_comm_mem +- . exact ih +- . simp [l'_mem] ++ · exact ih ++ · simp [l'_mem] + +- . ++ · + + rename_i l'_inv_mem +- . apply Subgroup.mul_mem +- . ++ · apply Subgroup.mul_mem ++ · + apply double_comm_mem + exact ih + simp [l'_inv_mem] + + +- . ++ · + rw [← Subgroup.inv_mem_iff] + simp + conv => +@@ -211,7 +206,7 @@ lemma triple_comm_mem {G: Type*} [Group G] [DecidableEq G] (S: Finset G) {l': G} + rw [comm_first_inv] + simp + apply Subgroup.mul_mem +- . ++ · + have foo := double_comm_mem (l' := l'⁻¹ ) _ _ ih g' (by + simp + left +@@ -219,7 +214,7 @@ lemma triple_comm_mem {G: Type*} [Group G] [DecidableEq G] (S: Finset G) {l': G} + ) + simp at foo + exact foo +- . ++ · + rw [← Subgroup.inv_mem_iff] + simp + apply Subgroup.mem_closure_of_mem +@@ -231,11 +226,9 @@ lemma triple_comm_mem {G: Type*} [Group G] [DecidableEq G] (S: Finset G) {l': G} + use l'⁻¹ + + +-#print axioms triple_comm_mem + -- Lemma 13.44. in https://www.math.ucdavis.edu/~kapovich/EPR/ggt.pdf + -- Note - the book seems to implicitly assume that the generating set is symmetric + +-set_option maxHeartbeats 400000 in + lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Finset G) (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + (⊤ : Subgroup G).lowerCentralSeries n = Subgroup.closure ((iterate_comm_set (S ∪ S⁻¹) n) ∪ ↑((⊤ : Subgroup G).lowerCentralSeries (n + 1))) := by + induction n with +@@ -247,9 +240,9 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + | succ n ih => + ext a + refine ⟨?_, ?_⟩ +- . ++ · + intro ha +- rw [mem_lowerCentralSeries_succ_iff] at ha ++ rw [Subgroup.mem_lowerCentralSeries_succ_iff] at ha + apply (Subgroup.closure_le _).mp ?_ ha + simp + intro p hp +@@ -266,7 +259,7 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + rw [comm_prod] + + have x_comm_mem: ⁅x.val, g⁆ ∈ (⊤ : Subgroup G).lowerCentralSeries (n + 1 + 1) := by +- rw [mem_lowerCentralSeries_succ_iff] ++ rw [Subgroup.mem_lowerCentralSeries_succ_iff] + apply Subgroup.mem_closure_of_mem + simp + use x +@@ -274,8 +267,8 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + + + apply Subgroup.mul_mem +- . apply Subgroup.mul_mem +- . ++ · apply Subgroup.mul_mem ++ · + + conv => + arg 2 +@@ -284,25 +277,25 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + + + apply Subgroup.mul_mem +- . ++ · + apply Subgroup.mem_closure_of_mem + apply Set.mem_union_right + simp + apply Subgroup.Normal.conj_mem +- . infer_instance +- . exact x_comm_mem +- . ++ · infer_instance ++ · exact x_comm_mem ++ · + apply Subgroup.mem_closure_of_mem + apply Set.mem_union_right + simp only [SetLike.mem_coe] + rw [Subgroup.inv_mem_iff] + apply x_comm_mem +- . ++ · + apply Subgroup.mem_closure_of_mem + apply Set.mem_union_right + simp only [SetLike.mem_coe] + apply x_comm_mem +- . ++ · + obtain ⟨g_list, g_prod⟩ := new_mem_S_prod_list (S := S) (x := g) (by simp [hS]) + --clear ha a p_eq_comm p c_prod c_mem c x_comm_mem + rw [← g_prod] +@@ -319,20 +312,20 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + + + by_cases g_list_zero: g_list.length = 0 +- . simp at g_list_zero ++ · simp at g_list_zero + simp [g_list_zero] +- . ++ · + simp at g_list_zero + + + by_cases l_len_ne_zero: l.unattach.length = 0 +- . have l_empty: l.unattach = [] := by ++ · have l_empty: l.unattach = [] := by + exact List.eq_nil_iff_length_eq_zero.mpr l_len_ne_zero + simp [l_empty] + + + by_cases both_eq_one: g_list.length = 1 ∧ l.unattach.length = 1 +- . ++ · + obtain ⟨g_len_one, l_len_one⟩ := both_eq_one + obtain ⟨g', h_g'⟩ := List.length_eq_one_iff.mp g_len_one + obtain ⟨l', h_l'⟩ := List.length_eq_one_iff.mp l_len_one +@@ -369,7 +362,7 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + + rw [not_and_or] at both_eq_one + cases both_eq_one +- . rename_i g_len_ne_one ++ · rename_i g_len_ne_one + + have g_len_ne_zero: g_list.length ≠ 0 := by + simp +@@ -385,16 +378,16 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + rw [List.unattach_append] + simp + rw [comm_prod_right] +- . apply Subgroup.mul_mem +- . apply Subgroup.mul_mem +- . ++ · apply Subgroup.mul_mem ++ · apply Subgroup.mul_mem ++ · + + have prev := hk k (by simp) l (List.take (g_list.length - 1) g_list) (by + simp + omega + ) + exact prev +- . ++ · + + + rw [← Subgroup.inv_mem_iff] +@@ -409,10 +402,10 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + simp at hx + obtain ⟨x_mem, x_subtype_mem⟩ := hx + cases x_mem +- . rename_i x_mem_forward ++ · rename_i x_mem_forward + apply Subgroup.mem_closure_of_mem + grind +- . rename_i x_mem_inv ++ · rename_i x_mem_inv + rw [← Subgroup.closure_inv] + apply Subgroup.mem_closure_of_mem + simp +@@ -421,7 +414,7 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + exact Subgroup.commutator_mem_commutator + (Subgroup.commutator_mem_commutator l_prod_mem (Subgroup.mem_top _)) + (Subgroup.mem_top _) +- . ++ · + + have prev := hk (l.length + 1) (by omega) l [(g_list.getLast g_list_zero)] (by + simp +@@ -430,7 +423,7 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + simp at prev + exact prev + +- . ++ · + rename_i l_len_ne_one + simp at l_len_ne_one + have l_ne_zero: l.length ≠ 0 := by +@@ -447,8 +440,8 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + rw [comm_prod] + simp at h_len + apply Subgroup.mul_mem +- . apply Subgroup.mul_mem +- . ++ · apply Subgroup.mul_mem ++ · + rw [← Subgroup.inv_mem_iff] + simp + apply Subgroup.mem_closure_of_mem +@@ -460,10 +453,10 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + have l_prop := (l.getLast (by simpa using l_ne_zero)).prop + rw [Set.mem_union] at l_prop + cases l_prop +- . rename_i l_prop_forward ++ · rename_i l_prop_forward + apply Subgroup.mem_closure_of_mem + grind +- . rename_i l_prop_inv ++ · rename_i l_prop_inv + rw [← Subgroup.closure_inv] + simp + apply Subgroup.mem_closure_of_mem +@@ -471,12 +464,12 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + exact Subgroup.commutator_mem_commutator + (Subgroup.commutator_mem_commutator last_mem (Subgroup.mem_top _)) + (Subgroup.mem_top _) +- . ++ · + + have foo := hk (g_list.length + 1) (by omega) [l.getLast (by simpa using l_ne_zero)] g_list (by simp) + simp at foo + exact foo +- . ++ · + have foo := hk k (by simp) (List.take (l.length - 1) l) g_list (by + simp + omega +@@ -484,7 +477,7 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + exact foo + + intro ha +- rw [mem_lowerCentralSeries_succ_iff] ++ rw [Subgroup.mem_lowerCentralSeries_succ_iff] + + + have closure_le: (Subgroup.closure ((iterate_comm_set (S ∪ S⁻¹) (n + 1)) ∪ ↑((⊤ : Subgroup G).lowerCentralSeries (n + 1 + 1)))) ≤ (Subgroup.closure {x | ∃ p ∈ (⊤ : Subgroup G).lowerCentralSeries n, ∃ q ∈ (⊤ : Subgroup G), ⁅p, q⁆ = x}) := by +@@ -492,7 +485,7 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + intro x hx + simp at hx + cases hx +- . ++ · + rename_i x_mem_comm + apply Subgroup.mem_closure_of_mem + simp +@@ -501,19 +494,18 @@ lemma lower_central_generates_succ {G: Type*} [Group G] [DecidableEq G] (S: Fins + obtain ⟨s, s_mem, ⟨c, c_mem, c_comm⟩⟩ := x_mem_comm + use c + refine ⟨?_, ?_⟩ +- . apply Subgroup.mem_closure_of_mem ++ · apply Subgroup.mem_closure_of_mem + grind +- . use s +- . ++ · use s ++ · + rename_i x_mem_lower_two + have x_mem_lower_succ: x ∈ (⊤ : Subgroup G).lowerCentralSeries (n + 1) := + Subgroup.commutator_le_left _ _ x_mem_lower_two + + +- rw [mem_lowerCentralSeries_succ_iff] at x_mem_lower_succ ++ rw [Subgroup.mem_lowerCentralSeries_succ_iff] at x_mem_lower_succ + simpa using x_mem_lower_succ + + + apply closure_le ha + +-#print axioms lower_central_generates_succ +diff --git a/Gromov/Unipotent/FG.lean b/Gromov/Unipotent/FG.lean +index 6a68e4d..f39faa3 100644 +--- a/Gromov/Unipotent/FG.lean ++++ b/Gromov/Unipotent/FG.lean +@@ -12,9 +12,6 @@ the supporting transfer lemmas along homomorphisms. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false +-set_option linter.style.cdot false + + open scoped commutatorElement IsMulCommutative Pointwise + +@@ -38,10 +35,10 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + grw [closure_le] + apply Subgroup.closure_le_normalClosure + | succ n ih => +- simp [lowerCentralSeries] ++ simp + rw [le_antisymm_iff] + refine ⟨?_, ?_⟩ +- . ++ · + simp [Subgroup.normalClosure] + intro y hy + simp [Group.conjugatesOfSet, iterate_comm_set] at hy +@@ -50,10 +47,10 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + obtain ⟨x, x_mem⟩ := c_comm + rw [← x_mem] + apply Subgroup.Normal.conj_mem +- . infer_instance +- . ++ · infer_instance ++ · + apply Subgroup.commutator_mem_commutator +- . ++ · + rw [← ih] + apply Subgroup.mem_closure_of_mem + simp [Group.conjugatesOfSet] +@@ -62,8 +59,8 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + simp [conjugatesOf] + use 1 + simp +- . simp +- . ++ · simp ++ · + + have image_commute: ∀ s ∈ S, ∀ g ∈ (iterate_comm_set (S) n), QuotientGroup.mk' (((Subgroup.normalClosure (iterate_comm_set (S) (n + 1))))) (s * g) = QuotientGroup.mk' (((Subgroup.normalClosure (iterate_comm_set (S) (n + 1))))) (g * s) := by + intro s hs g hg +@@ -80,13 +77,13 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + simp only [conjugatesOf] + use g * s * g⁻¹ * s⁻¹ + refine ⟨?_, ?_⟩ +- . simp [iterate_comm_set] ++ · simp [iterate_comm_set] + use s + refine ⟨by simp [hs], ?_⟩ + use g + refine ⟨hg, ?_⟩ + simp [Bracket.bracket] +- . ++ · + simp + use s⁻¹ * g⁻¹ + group +@@ -113,7 +110,7 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + + -- TODO - figure out how to get the 'induction' tactic working here + apply Subgroup.closure_induction (p := fun y hy => a⁻¹ * y⁻¹ * (a * y) ∈ Subgroup.normalClosure (iterate_comm_set (S) (n + 1))) (hx := b_mem_top) +- . ++ · + intro s hs + have comm := image_commute s hs a a_mem + simp at comm +@@ -122,24 +119,24 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + rw [QuotientGroup.eq] at comm + simp at comm + exact comm +- . simp +- . intro y hy z hz y_mem z_mem ++ · simp ++ · intro y hy z hz y_mem z_mem + simp + conv => + arg 2 + equals (a⁻¹ * hy⁻¹ * a * hy) * (hy⁻¹ * a⁻¹ * y⁻¹ * a * y * hy) => + group + apply Subgroup.mul_mem +- . group ++ · group + group at z_mem + exact z_mem +- . ++ · + have foo := (Subgroup.normalClosure_normal).conj_mem _ y_mem hy⁻¹ + simp at foo + group at foo + group + exact foo +- . ++ · + intro y hy y_mem + rw [← Subgroup.inv_mem_iff] + simp +@@ -158,7 +155,7 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + rw [ih] at normal_le_center + simp + have a_mem_center := @normal_le_center a⁻¹ ?_ +- . ++ · + rw [Subgroup.mem_center_iff] at a_mem_center + specialize a_mem_center (QuotientGroup.mk b⁻¹) + rw [← QuotientGroup.mk_inv] at a_mem_center +@@ -170,14 +167,13 @@ lemma iterate_comm_generates (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ): + group at a_mem_center + group + exact a_mem_center +- . simp ++ · simp + use a + + + simp + exact QuotientGroup.mk_surjective + +-#print axioms iterate_comm_generates + + -- Lemma 13.55 from https://www.math.ucdavis.edu/~kapovich/EPR/ggt.pdf + lemma comm_trivial_implies_nilpotent {G: Type*} [DecidableEq G] [Group G] (S: Finset G) (hS: Subgroup.closure (S: Set G) = ⊤) (n: ℕ) (h_comm: iterate_comm_set (S) (n) = {1}): +@@ -201,8 +197,8 @@ lemma normal_comm_mem {G: Type*} [Group G] {N: Subgroup G} (N_normal: N.Normal) + equals a * (b * a⁻¹ * b⁻¹) => group + + apply Subgroup.mul_mem +- . exact ha +- . exact conj_mem ++ · exact ha ++ · exact conj_mem + + + -- TODO - cleanup and upstream to mathlib +@@ -253,16 +249,16 @@ lemma fg_extension {A: Type*} [Group A] (N: Subgroup A) [N.Normal] (hN: N.FG) (h + rw [SQ_eq] at hS_Q + use S_N ∪ SQ_out + refine ⟨?_, ?_⟩ +- . ++ · + simp [SQ_out] + rw [Subgroup.closure_union] + simp [hS_N] + ext a + simp + by_cases mem_N: a ∈ N +- . apply Subgroup.mem_sup_left ++ · apply Subgroup.mem_sup_left + exact mem_N +- . ++ · + let a_map: (A ⧸ N) := a + have a_mem_top: a_map ∈ (⊤ : Subgroup (A ⧸ N)) := by + simp +@@ -277,14 +273,14 @@ lemma fg_extension {A: Type*} [Group A] (N: Subgroup A) [N.Normal] (hN: N.FG) (h + have a_eq := hk.2 + rw [QuotientGroup.eq] at a_eq + rw [← Subgroup.mul_mem_cancel_left (x := k⁻¹)] +- . ++ · + apply Subgroup.mem_sup_left + exact a_eq +- . apply Subgroup.mem_sup_right ++ · apply Subgroup.mem_sup_right + simp + exact hk.1 + +- . simp ++ · simp + + lemma fg_domain_of_ker_range {A B: Type*} [Group A] [Group B] (f : A →* B) (hA: Subgroup.FG f.ker) (hB: Subgroup.FG f.range): Group.FG A := by + have new_fg := fg_extension (f.ker) hA +@@ -300,7 +296,6 @@ lemma Group.FG.of_mulEquiv {G H : Type*} [Group G] [Group H] (e : G ≃* H) (h : + haveI := h + Group.fg_of_surjective (f := e.toMonoidHom) e.surjective + +-set_option maxHeartbeats 5000000 in + lemma fg_of_subgroup_fg_nilpotent {A: Type*} [DecidableEq A] [Group A] [Group.IsNilpotent A] (A_fg: Group.FG A) (H: Subgroup A): H.FG := by + classical + revert H +@@ -320,9 +315,6 @@ lemma fg_of_subgroup_fg_nilpotent {A: Type*} [DecidableEq A] [Group A] [Group.Is + have comm_eq := Subgroup.lowerCentralSeries_succ (⊤ : Subgroup A) n + rw [← hn] at comm_eq + rw [Subgroup.lowerCentralSeries_nilpotencyClass] at comm_eq +- conv at comm_eq => +- rhs +- simp + rw [eq_comm, Subgroup.commutator_eq_bot_iff_le_centralizer] at comm_eq + simp [Subgroup.centralizer_univ] at comm_eq + have n_fg: (Subgroup.lowerCentralSeries (⊤ : Subgroup A) n).FG := by +@@ -366,7 +358,7 @@ lemma fg_of_subgroup_fg_nilpotent {A: Type*} [DecidableEq A] [Group A] [Group.Is + + rw [← Group.fg_iff_subgroup_fg] + apply fg_domain_of_ker_range ((QuotientGroup.mk' ((⊤: Subgroup A).lowerCentralSeries n)).comp H.subtype) +- . ++ · + -- The kernel is `N.subgroupOf H = (H ⊓ N).subgroupOf H`, which is the same abstract group as + -- `(H ⊓ N).subgroupOf N` — the version we proved FG using that `N` is abelian. + rw [← MonoidHom.comap_ker, QuotientGroup.ker_mk', Subgroup.comap_subtype, +@@ -375,7 +367,7 @@ lemma fg_of_subgroup_fg_nilpotent {A: Type*} [DecidableEq A] [Group A] [Group.Is + ((Subgroup.subgroupOfEquivOfLe inf_le_right).trans + (Subgroup.subgroupOfEquivOfLe inf_le_left).symm) + ((Group.fg_iff_subgroup_fg _).mpr h_inf_fg) +- . ++ · + -- The range is the image of `H` in `A ⧸ Cⁿ A`, which is FG by the induction hypothesis. + rw [MonoidHom.range_comp, Subgroup.range_subtype] + exact ih (Subgroup.map (QuotientGroup.mk' _) H) +diff --git a/Gromov/Unipotent/GammaN.lean b/Gromov/Unipotent/GammaN.lean +index b60722b..126c821 100644 +--- a/Gromov/Unipotent/GammaN.lean ++++ b/Gromov/Unipotent/GammaN.lean +@@ -11,9 +11,6 @@ public import Gromov.Unipotent.FG + + public section + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false +-set_option linter.style.cdot false + + open scoped commutatorElement IsMulCommutative Pointwise + +@@ -112,9 +109,252 @@ theorem log_pow_sq_lt_of_lt (M p q K : ℕ) (hp : 0 < p) + def gamma_conj_bound {H: Type*} [DecidableEq H] [Group H] {N': Subgroup H} (gamma: MulAut N') := ∀ k: ℕ, (0 < k) → ∀ g, ∃ p q: ℕ, 0 < p ∧ ∀ b: ℕ, 0 < b → ∀ a: ℕ, (0 < a) → (a < b) → ((Finset.image (fun x ↦ (List.map (fun (i: ↥(Finset.Ico a b)) ↦ (gamma)^[k * ↑i] g) x.toList).prod)) + (Finset.Ico a b).attach.powerset).card ≤ p * (b^q) * (b - a)^q + +-set_option maxHeartbeats 1000000 in +-set_option synthInstance.maxHeartbeats 40000 in +-lemma exists_gamma_n_unipotent_center_N' {H: Type*} [DecidableEq H] [Group H] {N': Subgroup H} [N'_normal: N'.Normal] (N'_nilpotent: Group.IsNilpotent N') (hN': Subgroup.FG N') (gamma: MulAut N') ++/-- The finite-free abelian part of the argument, separated from torsion lifting. -/ ++private lemma free_abelian_gamma_unipotent {A : Type*} [CommGroup A] [DecidableEq A] ++ [Module.Finite ℤ (Additive A)] [Module.Free ℤ (Additive A)] ++ (gamma_lift : MulAut A) (r : ℕ) (hr : 0 < r) ++ (gamma_lift_conj : ∀ k : ℕ, 0 < k → ∀ g : A, ∃ p q : ℕ, 0 < p ∧ ++ ∀ b : ℕ, 0 < b → ∀ a : ℕ, 0 < a → a < b → ++ (Finset.image (fun x ↦ (List.map (fun i : ↥(Finset.Ico a b) ↦ ++ gamma_lift^[k * ↑i] g) x.toList).prod) (Finset.Ico a b).attach.powerset).card ≤ ++ p * b ^ q * (b - a) ^ q) : ++ ∃ a, 0 < a ∧ ∀ p : ℕ, 0 < p → ∃ n, ∀ g : A, ++ (fun x ↦ x * gamma_lift^[a * r * p] x⁻¹)^[n] g = 1 := by ++ classical ++ rcases subsingleton_or_nontrivial A with hA | hA ++ · exact ⟨1, by simp, fun p _ => ⟨1, fun g => Subsingleton.elim _ _⟩⟩ ++ let gamma_add := gamma_lift.toAdditive.toAddMonoidHom.toIntLinearMap ++ let B := (Module.finBasis ℤ (Additive (A))) ++ let gamma_matrix := gamma_add.toMatrix B B ++ have invertible_gamma: Invertible gamma_matrix := { ++ invOf := ((gamma_lift.toAdditive).symm.toAddMonoidHom).toIntLinearMap.toMatrix B B ++ invOf_mul_self := by ++ simp [gamma_matrix, gamma_add] ++ rw [← LinearMap.toMatrix_mul] ++ rw [← toIntLinearMap_comp_mul] ++ simp ++ mul_invOf_self := by ++ simp [gamma_matrix, gamma_add] ++ rw [← LinearMap.toMatrix_mul] ++ rw [← toIntLinearMap_comp_mul] ++ simp ++ } ++ ++ let dim := Module.finrank ℤ (Additive (A)) ++ let equiv (v: Fin _ → ℤ) := (Finsupp.linearEquivFunOnFinite ℤ _ (Fin dim)).symm v ++ let remap (v: Fin _ → ℤ) := Finsupp.linearCombination _ B (equiv v) ++ ++ have gamma_matrix_mulVec: ∀ v: (Fin dim) → ℤ , remap ((gamma_matrix).mulVec (equiv v)) = Additive.ofMul (gamma_lift (Additive.toMul (remap v))) := by ++ intro v ++ unfold gamma_matrix ++ rw [← Module.Basis.repr_linearCombination (v := (equiv v)) (b := B)] ++ rw [LinearMap.toMatrix_mulVec_repr] ++ simp [remap, gamma_add, equiv] ++ ++ ++ have gamma_matrix_mulVec_pow: ∀ n: ℕ, ∀ v: (Fin dim) → ℤ , remap ((gamma_matrix^n).mulVec (equiv v)) = Additive.ofMul (gamma_lift^[n] (Additive.toMul (remap v))) := by ++ intro n ++ induction n with ++ | zero => ++ intro v ++ simp [remap, equiv] ++ | succ n ih => ++ intro v ++ rw [Function.iterate_succ_apply', pow_succ', ← Matrix.mulVec_mulVec] ++ rw [show ((gamma_matrix ^ n).mulVec ⇑(equiv v)) ++ = ⇑(equiv ((gamma_matrix ^ n).mulVec ⇑(equiv v))) from rfl] ++ rw [gamma_matrix_mulVec, ih] ++ rfl ++ ++ ++ have rank_nonzero: NeZero (Module.finrank ℤ (Additive (A))) := by ++ apply NeZero.of_pos ++ apply Module.finrank_pos ++ ++ ++ have eigen_norm_one: ∀ (k : Module.End.Eigenvalues (Matrix.toLin' (((unitOfInvertible gamma_matrix).val).map (Int.castRingHom ℂ)))), ‖k.val‖ = 1 := by ++ apply int_matrix_poly_growth_eigenvalue ++ · ++ intro k hk v ++ -- name the (fixed) group element the iterates are applied to ++ set g : A := ++ Additive.toMul ((Finsupp.linearCombination ℤ ⇑B) ++ ((Finsupp.linearEquivFunOnFinite ℤ ℤ (Fin dim)).symm v)) with hg ++ ++ ++ obtain ⟨p, q, p_pos, hq⟩ := gamma_lift_conj ⌈Real.logb ‖k‖ 3⌉₊ (by ++ simp ++ apply Real.logb_pos ++ · grind ++ · grind ++ ) g ++ let K: ℕ := (⌈4 * ((8 * ↑q + Real.log ↑p) ^ 2 / Real.log 2 ^ 2) ^ 2⌉₊ + 2 * ⌈Real.logb ‖k‖ 3⌉₊) + 1 ++ ++ ++ have hpq := hq K (by simp [K]) ⌈Real.logb ‖k‖ 3⌉₊ (by ++ simp ++ apply Real.logb_pos ++ · grind ++ · grind ++ ) (by ++ simp [K] ++ rw [two_mul] ++ grw [Nat.le_ceil (a := Real.logb ‖k‖ 3)] ++ grind ++ ) ++ ++ use p * K ^ q ++ use q ++ use K ++ ++ refine ⟨?_, ?_, ?_, ?_⟩ ++ · apply mul_pos ++ · exact p_pos ++ · apply pow_pos ++ simp [K] ++ ++ · simp [K] ++ rw [two_mul] ++ grw [Nat.le_ceil (a := Real.logb ‖k‖ 3)] ++ grind ++ · ++ -- Isolate `K` on the right of ++ -- `X < Real.log 2 * (↑K - ↑⌈Real.logb ‖k‖ 3⌉₊) ^ (1/2)`. ++ -- Divide by `Real.log 2 > 0`, bound the LHS by its absolute value (so no sign ++ -- assumption on `X` is needed), rewrite `|y| = √(y ^ 2)` and use strict ++ -- monotonicity of `√`, then move the subtraction across. `K` is never unfolded. ++ have hlog2 : 0 < Real.log 2 := Real.log_pos (by norm_num) ++ rw [← Real.sqrt_eq_rpow, ← div_lt_iff₀' hlog2] ++ refine lt_of_le_of_lt (le_abs_self _) ?_ ++ rw [← Real.sqrt_sq_eq_abs] ++ refine Real.sqrt_lt_sqrt (sq_nonneg _) ?_ ++ rw [lt_sub_iff_add_lt] ++ -- `K` still occurs on the left inside `Real.log ↑(p * K ^ q)`. This splits that ++ -- logarithm and eliminates the resulting `Real.log ↑K`, leaving a goal in `ℕ` with ++ -- `K` alone on the right. ++ refine log_pow_sq_lt_of_lt _ p q K p_pos ?_ ++ -- ⊢ ⌈4 * ((8 * ↑q + Real.log ↑p) ^ 2 / Real.log 2 ^ 2) ^ 2⌉₊ ++ -- + 2 * ⌈Real.logb ‖k‖ 3⌉₊ < K ++ simp [K] ++ · ++ rw [← (Finset.card_image_iff (f := fun a => remap (Finsupp.equivFunOnFinite.symm a))).mpr] ++ · ++ rw [Finset.image_image] ++ simp [remap, equiv] ++ rw [Function.comp_def] ++ simp_rw [map_sum] ++ simp [remap, equiv] at gamma_matrix_mulVec_pow ++ simp_rw [← pow_mul] ++ simp_rw [gamma_matrix_mulVec_pow] ++ -- Turn each subsum into `Additive.ofMul` of a product in the group, keeping the ++ -- index set as the subtype `↥(Finset.Ico N_1 N_2)`. ++ simp_rw [← ofMul_prod] ++ -- `Additive.ofMul` is a bijection, so it does not affect the cardinality: pull it ++ -- out of the image and discard it. ++ rw [← Function.comp_def Additive.ofMul, ← Finset.image_image, ++ Finset.card_image_of_injective _ (Equiv.injective _)] ++ ++ ++ simp_rw [← Finset.prod_map_toList] ++ ++ grw [hpq] ++ -- TODO - we might be able to make the goal stronger, if we don't actually need the factor of 2 in it ++ rw [pow_mul'] ++ apply mul_le_mul ++ · simp ++ · apply Nat.le_pow ++ simp ++ · simp ++ · simp ++ · apply Function.Injective.injOn ++ intro a b hab ++ simp [remap, equiv] at hab ++ rw [Function.Injective.eq_iff (linearIndependent_iff_injective_finsuppLinearCombination.mp ?_)] at hab ++ · simpa using hab ++ · apply Module.Basis.linearIndependent ++ ++ ++ let a := KroneckerPow (unitOfInvertible gamma_matrix) eigen_norm_one ++ use a ++ refine ⟨(by ++ apply KroneckerPow_pos ++ ), ?_⟩ ++ intro p hp ++ ++ ++ have unipotent_gamma_matrix := int_matrix_unipotent (by ++ apply Module.finrank_pos ++ ) (unitOfInvertible gamma_matrix) (by ++ apply eigen_norm_one ++ ) (n := p * r) (hn := by positivity) ++ obtain ⟨n, hm⟩ := unipotent_gamma_matrix ++ ++ ++ use n ++ intro g ++ apply_fun (fun f => f.toLin (Module.finBasis _ _) (Module.finBasis _ _)) at hm ++ rw [LinearMap.ext_iff] at hm ++ specialize hm g ++ simp [gamma_matrix] at hm ++ simp [gamma_add] at hm ++ conv at hm => ++ rhs ++ equals 0 => rfl ++ ++ ++ apply_fun (fun f => (f).toMul) at hm ++ conv at hm => ++ rhs ++ equals 1 => rfl ++ ++ rw [← neg_sub] at hm ++ rw [neg_pow] at hm ++ simp at hm ++ rw [Module.End.mul_eq_comp] at hm ++ simp at hm ++ simp [Function.comp_def] at hm ++ apply (LinearMap.ker_eq_bot'.mp (by ++ ext a ++ clear hm ++ induction n with ++ | zero => simp ++ | succ n ih => ++ rw [pow_succ] ++ simp ++ simp at ih ++ exact ih ++ )) at hm ++ rw [← toMul_eq_one] at hm ++ rw [← hm] ++ clear hm ++ ++ have x_mul_gamma_eq: ∀ q: ℕ, (fun x => x * (⇑gamma_lift)^[q] x⁻¹) = Additive.toMul ∘ (-((MonoidHom.toAdditive gamma_lift.toMonoidHom).toIntLinearMap ^ (q) - LinearMap.id)).toFun ∘ (Additive.ofMul) := by ++ intro q ++ ext x ++ conv => ++ rhs ++ equals Additive.toMul ((-((MonoidHom.toAdditive gamma_lift.toMonoidHom).toIntLinearMap ^ (q) - LinearMap.id)).toFun (Additive.ofMul x)) => ++ rfl ++ simp ++ rw [toIntLinearMap_pow_apply] ++ simp ++ rw [Function.comp_def] ++ rw [div_eq_mul_inv] ++ simp ++ rfl ++ ++ rw [x_mul_gamma_eq] ++ simp ++ rw [Module.End.coe_pow] ++ -- collapse the `Matrix.toLin B B (LinearMap.toMatrix B B _)` round-trip, which plain ++ -- `rfl` cannot see through ++ rw [Matrix.toLin_toMatrix] ++ ++ have mul_eq: a * r * p = p * r * a := by ring ++ simp_rw [mul_eq] ++ rfl ++ ++lemma exists_gamma_n_unipotent_center_N' {H: Type*} [DecidableEq H] [Group H] {N': Subgroup H} [_N'_normal: N'.Normal] (N'_nilpotent: Group.IsNilpotent N') (hN': Subgroup.FG N') (gamma: MulAut N') + (gamma_conj: gamma_conj_bound gamma): + ∃ a, a ≠ 0 ∧ ∀ k: ℕ, 0 < k → ∃ n, ∀ g ∈ Subgroup.center N', Nat.iterate (fun x => x * ((gamma^[a*k]) x⁻¹)) n g = 1 := by + +@@ -163,47 +403,6 @@ lemma exists_gamma_n_unipotent_center_N' {H: Type*} [DecidableEq H] [Group H] {N + let gamma_center := MulAut.characteristic (Subgroup.center N') gamma + have t_char: torsion.Characteristic := torsion_characteristic + let torsion_N := Subgroup.map (Subgroup.subtype _) torsion +- let gamma_torsion := MonoidHom.domRestrict gamma.toMonoidHom torsion_N +- let new_gamma_torsion_hom := MonoidHom.codRestrict gamma_torsion torsion_N (by +- rw [Subgroup.characteristic_iff_map_le] at t_char +- specialize t_char +- intro x +- simp [torsion_N] +- use ?_ +- . +- rw [CommGroup.mem_torsion] +- simp [gamma_torsion] +- rw [isOfFinOrder_iff_pow_eq_one] +- simp +- rw [← isOfFinOrder_iff_pow_eq_one] +- conv => +- arg 1 +- equals gamma.toMonoidHom x => +- simp +- apply MonoidHom.isOfFinOrder +- have x_prop := x.prop +- unfold torsion_N at x_prop +- simp [-SetLike.coe_mem] at x_prop +- obtain ⟨x_mem, x_mem_torsion⟩ := x_prop +- rw [CommGroup.mem_torsion] at x_mem_torsion +- rw [isOfFinOrder_iff_pow_eq_one] at x_mem_torsion +- simp at x_mem_torsion +- rw [← isOfFinOrder_iff_pow_eq_one] at x_mem_torsion +- simpa using x_mem_torsion +- . +- simp [gamma_torsion] +- have char_center := Subgroup.centerCharacteristic (G := N') +- rw [Subgroup.characteristic_iff_map_eq] at char_center +- specialize char_center gamma +- rw [← char_center] +- simp +- have x_prop := x.prop +- unfold torsion_N at x_prop +- simp [-SetLike.coe_mem] at x_prop +- obtain ⟨x_center, hx⟩ := x_prop +- exact x_center +- ) +- + let new_gamma_torsion := MulAut.characteristic torsion_N gamma + + +@@ -225,7 +424,7 @@ lemma exists_gamma_n_unipotent_center_N' {H: Type*} [DecidableEq H] [Group H] {N + rw [Function.iterate_succ] + simp + rw [ih] +- simp [new_gamma_torsion, new_gamma_torsion_hom, gamma_torsion] ++ simp [new_gamma_torsion] + + + let gamma_lift := QuotientGroup.congr (torsion) torsion gamma_center (by +@@ -275,284 +474,27 @@ lemma exists_gamma_n_unipotent_center_N' {H: Type*} [DecidableEq H] [Group H] {N + simp_rw [Function.iterate_succ'] + simp + +- have unipotent_on_quot: ∃ a, 0 < a ∧ ∀ p: ℕ, 0 < p → ∃ n, ∀ g : (Subgroup.center ↥N') ⧸ torsion, Nat.iterate (fun x => x * ((gamma_lift^[a * orderOf new_gamma_torsion * p] x⁻¹))) n g = 1 := by +- wlog nontrivial_quot: Nontrivial ((Subgroup.center ↥N') ⧸ torsion) +- . +- clear this +- simp at nontrivial_quot +- use 1 +- refine ⟨by simp, ?_⟩ +- intro p hp +- use 1 +- simp +- intro g +- have quot_subsingelton: Subsingleton ((Subgroup.center ↥N') ⧸ torsion) := by +- rw [QuotientGroup.subsingleton_iff] +- exact nontrivial_quot +- +- have g_eq := Subsingleton.eq_one g +- simp [g_eq] +- +- +- let foo: CommGroup (Subgroup.center N') := by infer_instance +- -- if the additive picture is wanted, this is *definitionally* the same type: +- have add_torsion_free: IsAddTorsionFree +- (Additive ↥(Subgroup.center ↥N') ⧸ AddCommGroup.torsion (Additive ↥(Subgroup.center ↥N'))) := by +- infer_instance +- +- let add_quot := (Additive ↥(Subgroup.center ↥N') ⧸ AddCommGroup.torsion (Additive ↥(Subgroup.center ↥N'))) +- +- +- let fin_dim: Module.Finite ℤ add_quot := by infer_instance +- +- let gamma_add := gamma_lift.toAdditive.toAddMonoidHom.toIntLinearMap +- let B := (Module.finBasis ℤ (Additive (↥(Subgroup.center ↥N') ⧸ torsion))) +- let gamma_matrix := gamma_add.toMatrix B B +- have invertible_gamma: Invertible gamma_matrix := { +- invOf := ((gamma_lift.toAdditive).symm.toAddMonoidHom).toIntLinearMap.toMatrix B B +- invOf_mul_self := by +- simp [gamma_matrix, gamma_add] +- rw [← LinearMap.toMatrix_mul] +- rw [← toIntLinearMap_comp_mul] +- simp +- mul_invOf_self := by +- simp [gamma_matrix, gamma_add] +- rw [← LinearMap.toMatrix_mul] +- rw [← toIntLinearMap_comp_mul] +- simp +- } +- +- let dim := Module.finrank ℤ (Additive (↥(Subgroup.center ↥N') ⧸ torsion)) +- let equiv (v: Fin _ → ℤ) := (Finsupp.linearEquivFunOnFinite ℤ _ (Fin dim)).symm v +- let remap (v: Fin _ → ℤ) := Finsupp.linearCombination _ B (equiv v) +- +- have gamma_matrix_mulVec: ∀ v: (Fin dim) → ℤ , remap ((gamma_matrix).mulVec (equiv v)) = Additive.ofMul (gamma_lift (Additive.toMul (remap v))) := by +- intro v +- unfold gamma_matrix +- rw [← Module.Basis.repr_linearCombination (v := (equiv v)) (b := B)] +- rw [LinearMap.toMatrix_mulVec_repr] +- simp [remap, gamma_add, equiv] +- +- +- have gamma_matrix_mulVec_pow: ∀ n: ℕ, ∀ v: (Fin dim) → ℤ , remap ((gamma_matrix^n).mulVec (equiv v)) = Additive.ofMul (gamma_lift^[n] (Additive.toMul (remap v))) := by +- intro n +- induction n with +- | zero => +- intro v +- simp [remap, equiv] +- | succ n ih => +- intro v +- rw [Function.iterate_succ_apply', pow_succ', ← Matrix.mulVec_mulVec] +- rw [show ((gamma_matrix ^ n).mulVec ⇑(equiv v)) +- = ⇑(equiv ((gamma_matrix ^ n).mulVec ⇑(equiv v))) from rfl] +- rw [gamma_matrix_mulVec, ih] +- rfl +- +- +- have rank_nonzero: NeZero (Module.finrank ℤ (Additive (↥(Subgroup.center ↥N') ⧸ torsion))) := by +- apply NeZero.of_pos +- apply Module.finrank_pos +- +- +- have gamma_lift_conj: ∀ k: ℕ, (0 < k) → ∀ g, ∃ p q: ℕ, 0 < p ∧ ∀ b: ℕ, 0 < b → ∀ a: ℕ, (0 < a) → (a < b) → (Finset.image (fun x ↦ (List.map (fun (i: ↥(Finset.Ico a b)) ↦ (gamma_lift)^[k * ↑i] g) x.toList).prod) +- (Finset.Ico a b).attach.powerset).card ≤ p * (b^q) * (b - a)^q := by +- +- -- Same shape as the `final_gamma` transport: the products live in +- -- `↥(Subgroup.center ↥N')`, mapped out injectively by `Subgroup.subtype` (where +- -- `gamma_conj` gives the bound) and surjectively by `QuotientGroup.mk'` (where it +- -- is wanted). +- classical +- exact conjBound_transport +- (fC := fun x : ↥(Subgroup.center ↥N') => +- (⟨gamma x, gamma_mem_center x⟩ : ↥(Subgroup.center ↥N'))) +- (fQ := ⇑gamma_lift) (fN := ⇑gamma) +- (QuotientGroup.mk' torsion) (QuotientGroup.mk'_surjective _) +- ((Subgroup.center ↥N').subtype) (Subgroup.subtype_injective _) +- (fun x => (swap_gamma_lift x).symm) (fun x => rfl) gamma_conj +- +- have eigen_norm_one: ∀ (k : Module.End.Eigenvalues (Matrix.toLin' (((unitOfInvertible gamma_matrix).val).map (Int.castRingHom ℂ)))), ‖k.val‖ = 1 := by +- apply int_matrix_poly_growth_eigenvalue +- . +- intro k hk v +- -- name the (fixed) group element the iterates are applied to +- set g : ↥(Subgroup.center ↥N') ⧸ torsion := +- Additive.toMul ((Finsupp.linearCombination ℤ ⇑B) +- ((Finsupp.linearEquivFunOnFinite ℤ ℤ (Fin dim)).symm v)) with hg +- +- +- obtain ⟨p, q, p_pos, hq⟩ := gamma_lift_conj ⌈Real.logb ‖k‖ 3⌉₊ (by +- simp +- apply Real.logb_pos +- . grind +- . grind +- ) g +- let K: ℕ := (⌈4 * ((8 * ↑q + Real.log ↑p) ^ 2 / Real.log 2 ^ 2) ^ 2⌉₊ + 2 * ⌈Real.logb ‖k‖ 3⌉₊) + 1 +- +- +- have hpq := hq K (by simp [K]) ⌈Real.logb ‖k‖ 3⌉₊ (by +- simp +- apply Real.logb_pos +- . grind +- . grind +- ) (by +- simp [K] +- rw [two_mul] +- grw [Nat.le_ceil (a := Real.logb ‖k‖ 3)] +- grind +- ) +- +- use p * K ^ q +- use q +- use K +- +- refine ⟨?_, ?_, ?_, ?_⟩ +- . apply mul_pos +- . exact p_pos +- . apply pow_pos +- simp [K] +- +- . simp [K] +- rw [two_mul] +- grw [Nat.le_ceil (a := Real.logb ‖k‖ 3)] +- grind +- . +- -- Isolate `K` on the right of +- -- `X < Real.log 2 * (↑K - ↑⌈Real.logb ‖k‖ 3⌉₊) ^ (1/2)`. +- -- Divide by `Real.log 2 > 0`, bound the LHS by its absolute value (so no sign +- -- assumption on `X` is needed), rewrite `|y| = √(y ^ 2)` and use strict +- -- monotonicity of `√`, then move the subtraction across. `K` is never unfolded. +- have hlog2 : 0 < Real.log 2 := Real.log_pos (by norm_num) +- rw [← Real.sqrt_eq_rpow, ← div_lt_iff₀' hlog2] +- refine lt_of_le_of_lt (le_abs_self _) ?_ +- rw [← Real.sqrt_sq_eq_abs] +- refine Real.sqrt_lt_sqrt (sq_nonneg _) ?_ +- rw [lt_sub_iff_add_lt] +- -- `K` still occurs on the left inside `Real.log ↑(p * K ^ q)`. This splits that +- -- logarithm and eliminates the resulting `Real.log ↑K`, leaving a goal in `ℕ` with +- -- `K` alone on the right. +- refine log_pow_sq_lt_of_lt _ p q K p_pos ?_ +- -- ⊢ ⌈4 * ((8 * ↑q + Real.log ↑p) ^ 2 / Real.log 2 ^ 2) ^ 2⌉₊ +- -- + 2 * ⌈Real.logb ‖k‖ 3⌉₊ < K +- simp [K] +- . +- rw [← (Finset.card_image_iff (f := fun a => remap (Finsupp.equivFunOnFinite.symm a))).mpr] +- . +- rw [Finset.image_image] +- simp [remap, equiv] +- rw [Function.comp_def] +- simp_rw [map_sum] +- simp [remap, equiv] at gamma_matrix_mulVec_pow +- simp_rw [← pow_mul] +- simp_rw [gamma_matrix_mulVec_pow] +- -- Turn each subsum into `Additive.ofMul` of a product in the group, keeping the +- -- index set as the subtype `↥(Finset.Ico N_1 N_2)`. +- simp_rw [← ofMul_prod] +- -- `Additive.ofMul` is a bijection, so it does not affect the cardinality: pull it +- -- out of the image and discard it. +- rw [← Function.comp_def Additive.ofMul, ← Finset.image_image, +- Finset.card_image_of_injective _ (Equiv.injective _)] +- +- +- simp_rw [← Finset.prod_map_toList] +- +- grw [hpq] +- -- TODO - we might be able to make the goal stronger, if we don't actually need the factor of 2 in it +- rw [pow_mul'] +- apply mul_le_mul +- . simp +- . apply Nat.le_pow +- simp +- . simp +- . simp +- . apply Function.Injective.injOn +- intro a b hab +- simp [remap, equiv] at hab +- rw [Function.Injective.eq_iff (linearIndependent_iff_injective_finsuppLinearCombination.mp ?_)] at hab +- . simpa using hab +- . apply Module.Basis.linearIndependent +- +- +- let a := KroneckerPow (unitOfInvertible gamma_matrix) eigen_norm_one +- use a +- refine ⟨(by +- apply KroneckerPow_pos +- ), ?_⟩ +- intro p hp +- +- +- have unipotent_gamma_matrix := int_matrix_unipotent (by +- apply Module.finrank_pos +- ) (unitOfInvertible gamma_matrix) (by +- apply eigen_norm_one +- ) (n := p * orderOf new_gamma_torsion) (hn := by positivity) +- obtain ⟨n, hm⟩ := unipotent_gamma_matrix +- +- +- use n +- intro g +- apply_fun (fun f => f.toLin (Module.finBasis _ _) (Module.finBasis _ _)) at hm +- rw [LinearMap.ext_iff] at hm +- specialize hm g +- simp [gamma_matrix] at hm +- simp [gamma_add] at hm +- conv at hm => +- rhs +- equals 0 => rfl +- +- +- apply_fun (fun f => (f).toMul) at hm +- conv at hm => +- rhs +- equals 1 => rfl +- +- rw [← neg_sub] at hm +- rw [neg_pow] at hm +- simp at hm +- rw [Module.End.mul_eq_comp] at hm +- simp at hm +- simp [Function.comp_def] at hm +- apply (LinearMap.ker_eq_bot'.mp (by +- ext a +- clear hm +- induction n with +- | zero => simp +- | succ n ih => +- rw [pow_succ] +- simp +- simp at ih +- exact ih +- )) at hm +- rw [← toMul_eq_one] at hm +- rw [← hm] +- clear hm +- +- have x_mul_gamma_eq: ∀ q: ℕ, (fun x => x * (⇑gamma_lift)^[q] x⁻¹) = Additive.toMul ∘ (-((MonoidHom.toAdditive gamma_lift.toMonoidHom).toIntLinearMap ^ (q) - LinearMap.id)).toFun ∘ (Additive.ofMul) := by +- intro q +- ext x +- conv => +- rhs +- equals Additive.toMul ((-((MonoidHom.toAdditive gamma_lift.toMonoidHom).toIntLinearMap ^ (q) - LinearMap.id)).toFun (Additive.ofMul x)) => +- rfl +- simp +- rw [toIntLinearMap_pow_apply] +- simp +- rw [Function.comp_def] +- rw [div_eq_mul_inv] +- simp +- rfl +- +- rw [x_mul_gamma_eq] +- simp +- rw [Module.End.coe_pow] +- -- collapse the `Matrix.toLin B B (LinearMap.toMatrix B B _)` round-trip, which plain +- -- `rfl` cannot see through +- rw [Matrix.toLin_toMatrix] +- +- -- TODO - figure out how the order gets swapped +- have mul_eq: a * orderOf new_gamma_torsion * p = p * orderOf new_gamma_torsion * a := by ring +- simp_rw [mul_eq] +- rfl +- ++ have gamma_lift_conj: ∀ k: ℕ, (0 < k) → ∀ g, ∃ p q: ℕ, 0 < p ∧ ∀ b: ℕ, 0 < b → ∀ a: ℕ, (0 < a) → (a < b) → (Finset.image (fun x ↦ (List.map (fun (i: ↥(Finset.Ico a b)) ↦ (gamma_lift)^[k * ↑i] g) x.toList).prod) ++ (Finset.Ico a b).attach.powerset).card ≤ p * (b^q) * (b - a)^q := by ++ ++ -- Same shape as the `final_gamma` transport: the products live in ++ -- `↥(Subgroup.center ↥N')`, mapped out injectively by `Subgroup.subtype` (where ++ -- `gamma_conj` gives the bound) and surjectively by `QuotientGroup.mk'` (where it ++ -- is wanted). ++ classical ++ exact conjBound_transport ++ (fC := fun x : ↥(Subgroup.center ↥N') => ++ (⟨gamma x, gamma_mem_center x⟩ : ↥(Subgroup.center ↥N'))) ++ (fQ := ⇑gamma_lift) (fN := ⇑gamma) ++ (QuotientGroup.mk' torsion) (QuotientGroup.mk'_surjective _) ++ ((Subgroup.center ↥N').subtype) (Subgroup.subtype_injective _) ++ (fun x => (swap_gamma_lift x).symm) (fun x => rfl) gamma_conj ++ ++ have unipotent_on_quot : ∃ a, 0 < a ∧ ∀ p : ℕ, 0 < p → ∃ n, ++ ∀ g : (Subgroup.center ↥N') ⧸ torsion, ++ (fun x ↦ x * gamma_lift^[a * orderOf new_gamma_torsion * p] x⁻¹)^[n] g = 1 := ++ free_abelian_gamma_unipotent gamma_lift (orderOf new_gamma_torsion) order_pos ++ gamma_lift_conj + + obtain ⟨quot_pow, quot_pow_pos, h_quot_pow⟩ := unipotent_on_quot + use (quot_pow * ( orderOf new_gamma_torsion)) +@@ -587,8 +529,8 @@ lemma exists_gamma_n_unipotent_center_N' {H: Type*} [DecidableEq H] [Group H] {N + simp + have mul_mem_center: (↑g * ((gamma ^ (quot_pow * orderOf new_gamma_torsion * p )) ↑g)⁻¹) ∈ Subgroup.center N' := by + apply Subgroup.mul_mem +- . simp +- . ++ · simp ++ · + simp + have center_char: (Subgroup.center N').Characteristic := by + infer_instance +@@ -639,8 +581,6 @@ lemma exists_gamma_n_unipotent_center_N' {H: Type*} [DecidableEq H] [Group H] {N + -- OLD CODE + + +-set_option maxHeartbeats 2000000 in +-set_option synthInstance.maxHeartbeats 160000 in + /--{G: Type*} [DecidableEq G] [Group G] (H: Subgroup G) [H.Normal]--/ + lemma exists_gamma_n_unipotent_N' {H: Type*} [DecidableEq H] [Group H] {N': Subgroup H} [N'_normal: N'.Normal] (N'_nilpotent: Group.IsNilpotent N') (hN': Subgroup.FG N') (gamma: MulAut N') (gamma_conj: gamma_conj_bound gamma): + ∀ p: ℕ, 0 < p → ∃ a n, a ≠ 0 ∧ ∀ g : N', Nat.iterate (fun x => x * ((gamma^[a*p]) x⁻¹)) n g = 1 := by +@@ -648,7 +588,7 @@ lemma exists_gamma_n_unipotent_N' {H: Type*} [DecidableEq H] [Group H] {N': Subg + + classical + by_cases N'_subsingle: Subsingleton N' +- . ++ · + intro p hp + use 1 + use 1 +@@ -656,7 +596,7 @@ lemma exists_gamma_n_unipotent_N' {H: Type*} [DecidableEq H] [Group H] {N': Subg + intro a ha + have order := Subsingleton.orderOf_eq (⟨_, ha⟩ : N') + simp at order +- simp [order, iteratedCommutator] ++ simp [order] + rw [mul_aut_iterate] + simp + +@@ -679,7 +619,7 @@ lemma exists_gamma_n_unipotent_N' {H: Type*} [DecidableEq H] [Group H] {N': Subg + let final_gamma := aut_transfer gamma_quot + + by_cases top_subsingle: Subsingleton (⊤ : Subgroup (↥N' ⧸ Subgroup.center ↥N')) +- . ++ · + intro p hp + obtain ⟨z_a, h_z_a, z_a_temp⟩ := exists_gamma_n_unipotent_center_N' (N' := N') (N'_nilpotent) (hN') gamma gamma_conj + obtain ⟨z_n, h_z_unipotent⟩ := z_a_temp p hp +@@ -702,12 +642,12 @@ lemma exists_gamma_n_unipotent_N' {H: Type*} [DecidableEq H] [Group H] {N': Subg + + have foo := ih (Group.nilpotencyClass (⊤ : Subgroup (↥N' ⧸ Subgroup.center ↥N'))) (by + grw [Subgroup.nilpotencyClass_le] +- simp [nilpotencyClass_quotient_center] ++ simp [Group.nilpotencyClass_quotient_center] + rw [← hn] + simp + by_contra! + simp at this +- rw [nilpotencyClass_zero_iff_subsingleton] at this ++ rw [Group.nilpotencyClass_zero_iff_subsingleton] at this + contradiction + ) (H := N' ⧸ Subgroup.center N') (N' := ⊤) (by simp; apply Group.nilpotent_quotient_of_nilpotent) (by + have fg_quot: Group.FG (↥N' ⧸ Subgroup.center ↥N') := by +@@ -746,7 +686,7 @@ lemma exists_gamma_n_unipotent_N' {H: Type*} [DecidableEq H] [Group H] {N': Subg + rw [Function.iterate_add_apply] + + specialize h_z_unipotent ((fun x ↦ x * ((gamma^[a*z_a*p]) (x⁻¹)))^[n] g) ?_ +- . ++ · + + have swap_gamma_base: ∀ x, (gamma) x = ((final_gamma) ⟨x, by simp⟩).val := by + intro x +@@ -787,7 +727,7 @@ lemma exists_gamma_n_unipotent_N' {H: Type*} [DecidableEq H] [Group H] {N': Subg + simpa using h_prev + + +- . ++ · + simp_rw [mul_aut_iterate] at h_z_unipotent + rw [mul_aut_iterate] + simp_rw [← mul_assoc] at h_z_unipotent +diff --git a/Gromov/UnipotentGromov.lean b/Gromov/UnipotentGromov.lean +index f90d0aa..13fc5f8 100644 +--- a/Gromov/UnipotentGromov.lean ++++ b/Gromov/UnipotentGromov.lean +@@ -13,9 +13,6 @@ Root of the `Gromov.Unipotent` hierarchy. + + public section + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false +-set_option linter.style.cdot false + + open scoped commutatorElement IsMulCommutative Pointwise + +@@ -31,8 +28,8 @@ lemma normal_comm_mem_right {G: Type*} [Group G] {N: Subgroup G} (N_normal: N.No + equals (a * b * a⁻¹) * b⁻¹ => group + + apply Subgroup.mul_mem +- . exact conj_mem +- . simpa using hb ++ · exact conj_mem ++ · simpa using hb + + + lemma iterated_mem_iterated_set {G: Type*} [DecidableEq G] [Group G] (base right: G) (S: Finset G) (base_mem: base ∈ S) (right_mem: right ∈ S) (n: ℕ): iteratedCommutator base right n ∈ iterate_comm_set S n := by +@@ -63,19 +60,18 @@ lemma comm_subgroup_mem {G: Type*} [DecidableEq G] [Group G] {H: Subgroup G} (S: + simp + | succ n ih => + simp [iterate_comm_set] +- intro h h_mem h_mem_s +- intro a ha ++ intro h h_mem h_mem_s a ha + simp + have a_mem := ih ha + simp [Bracket.bracket] + apply Subgroup.mul_mem +- . apply Subgroup.mul_mem +- . apply Subgroup.mul_mem +- . exact a_mem +- . exact h_mem +- . simp ++ · apply Subgroup.mul_mem ++ · apply Subgroup.mul_mem ++ · exact a_mem ++ · exact h_mem ++ · simp + exact a_mem +- . simp ++ · simp + exact h_mem + + +@@ -88,39 +84,39 @@ lemma iterate_comm_subgroup {G: Type*} [DecidableEq G] [Group G] {H: Subgroup G} + dsimp [iterate_comm_set] + simp + refine ⟨?_, ?_⟩ +- . ++ · + intro h_mem + obtain ⟨b, b_mem, ⟨b_mem_S, a, h_eq⟩⟩ := h_mem + obtain ⟨a_mem_h, a_mem_comm, h_eq_comm⟩ := h_eq + use b + use ?_ +- . use a ++ · use a + refine ⟨?_, ?_⟩ +- . ++ · + rw [ih] at a_mem_comm + simp at a_mem_comm + exact a_mem_comm +- . rw [← h_eq_comm] ++ · rw [← h_eq_comm] + simp [Bracket.bracket] +- . use b_mem +- . intro data_mem ++ · use b_mem ++ · intro data_mem + obtain ⟨b, ⟨b_mem_H, b_mem_S⟩, ⟨a, a_mem_comm, h_eq⟩⟩ := data_mem + use b + use b_mem_H + refine ⟨?_, ?_⟩ +- . exact b_mem_S +- . use a ++ · exact b_mem_S ++ · use a + use ?_ +- . refine ⟨?_, ?_⟩ +- . ++ · refine ⟨?_, ?_⟩ ++ · + rw [ih] + simp + exact a_mem_comm +- . ++ · + ext + rw [← h_eq] + simp [Bracket.bracket] +- . ++ · + simp [Bracket.bracket] at h_eq + have iterate_subset := comm_subgroup_mem S n a_mem_comm + simpa using iterate_subset +@@ -171,29 +167,29 @@ lemma count_mem_group_implies_lowercentral {G: Type*} [Group G] {N': Subgroup G} + simp at l_nonempty + | cons head tail ih => + by_cases head_in_N': head ∈ N' +- . +- simp only [List.countP_cons, List.foldr_cons, head_in_N', decide_true, if_true, ++ · ++ simp only [List.countP_cons, List.foldr_cons, head_in_N', decide_true, ite_true, + Nat.add_sub_cancel] + by_cases tail_empty: tail = [] +- . ++ · + simp [tail_empty] + apply normal_comm_mem_right N'_normal + exact head_in_N' +- . ++ · + + by_cases count_eq_zero: (tail.countP (fun a => decide (a ∈ N'))) = 0 +- . ++ · + simp [count_eq_zero] + apply normal_comm_mem_right N'_normal + exact head_in_N' +- . ++ · + have count_sub_eq: (tail.countP (fun a => decide (a ∈ N'))) = (tail.countP (fun a => decide (a ∈ N'))) - 1 + 1 := by + omega + + rw [count_sub_eq] + specialize ih (by simpa using tail_empty) count_eq_zero + exact Subgroup.commutator_mem_commutator ih head_in_N' +- . rw [List.countP_cons] ++ · rw [List.countP_cons] + simp only [head_in_N', decide_false, Bool.false_eq_true, ↓reduceIte] + + +@@ -208,11 +204,10 @@ lemma count_mem_group_implies_lowercentral {G: Type*} [Group G] {N': Subgroup G} + specialize ih tail_nonempty count_ne_zero + rw [List.foldr_cons] + apply normal_comm_mem +- . infer_instance +- . exact ih ++ · infer_instance ++ · exact ih + + +-#print axioms count_mem_group_implies_lowercentral + + + -- `Subgroup.map_toSubmonoid` rewrites the `.carrier` predicate of `Subgroup.map`, which breaks the +@@ -229,22 +224,22 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + classical + + by_cases m_eq: m = 0 +- . ++ · + simp [iteratedCommutator, m_eq] at h_gamma_alpha + have N'_bot: N' = ⊥ := by + rw [Subgroup.eq_bot_iff_forall] + simpa using h_gamma_alpha + + +- let foo := Subgroup.closureCommGroupOfComm (k := (↑(Finset.image (⇑H.subtype) S) ∪ {gamma_alpha})) ?_ +- . ++ have foo := Subgroup.isMulCommutative_closure (k := (↑(Finset.image (⇑H.subtype) S) ∪ {gamma_alpha})) ?_ ++ · + + apply CommGroup.isNilpotent +- . intro x hx y hy ++ · intro x hx y hy + by_cases S_empty: S = ∅ +- . simp [S_empty] at hx hy ++ · simp [S_empty] at hx hy + grind +- . ++ · + have S_eq: S = {1} := by + simp only [N'_bot, Subgroup.closure_eq_bot_iff] at hS + have S_subset: S ⊆ {1} := by +@@ -265,10 +260,10 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + + have nilpotent_map: Group.IsNilpotent ↥(Subgroup.map H.subtype N') := by + apply map_nilpotent +- . exact Subgroup.subtype_injective H +- . exact N'_nilpotent ++ · exact Subgroup.subtype_injective H ++ · exact N'_nilpotent + +- rw [nilpotent_iff_lowerCentralSeries] ++ rw [Subgroup.nilpotent_iff_lowerCentralSeries] + use ((1 + (Group.nilpotencyClass ↥(Subgroup.map H.subtype N'))) * (m + 1)) + 2 + + apply comm_trivial_implies_nilpotent (S := Finset.image (fun (a: ↑((Finset.image (Subgroup.subtype _) S) ∪ {gamma_alpha})) => ⟨a.val, by ( +@@ -278,7 +273,7 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + simp + exact a_prop + )⟩) Finset.univ) +- . ++ · + + + simp only [Finset.coe_image, Finset.coe_univ, Set.image_univ] +@@ -297,7 +292,7 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + · intro hg + exact ⟨⟨g, by apply Subgroup.mem_closure_of_mem; exact hg⟩, + ⟨⟨g, by simpa using hg⟩, rfl⟩, rfl⟩ +- . ++ · + ext a + rw [iterate_comm_subgroup] + +@@ -312,11 +307,11 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + exact Finset.attach_image_val + + refine ⟨?_, ?_⟩ +- . ++ · + intro a_mem + rw [← Finset.mem_coe] at a_mem + rw [iterate_comm_set_eq_fold] at a_mem +- simp only [Set.mem_setOf_eq] at a_mem ++ simp only [Set.mem_ofPred_eq] at a_mem + obtain ⟨s, l, l_length, a_eq⟩ := a_mem + + -- TODO - extract this to its own lemma +@@ -341,22 +336,21 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + rw [Function.iterate_succ'] + simp + apply normal_comm_mem +- . infer_instance +- . exact ih ++ · infer_instance ++ · exact ih + + have comm_in_N': (fun x ↦ ⁅x, gamma_alpha⁆)^[t] g ∈ (Subgroup.map (Subgroup.subtype _) N') := by + clear ht + induction t with + | zero => +- simpa using g_mem ++ simp + | succ t ih => + simp_rw [Function.iterate_succ'] +- simp only [Function.comp_apply, Subgroup.subtype_apply, +- Subtype.exists, exists_and_right, exists_eq_right] ++ simp only [Function.comp_apply] + apply normal_comm_mem +- . ++ · + infer_instance +- . exact ih ++ · exact ih + + simp at comm_in_N' + obtain ⟨foo, bar⟩ := comm_in_N' +@@ -367,7 +361,7 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + have adjacent_or_count := list_adjacent_elements l (fun x => decide (x = gamma_alpha)) (m + 1) + rw [l_length] at adjacent_or_count + cases adjacent_or_count +- . ++ · + rename_i adjancent_gamma + obtain ⟨gamma_list, h_gamma_list, gamma_list_len, eq_gamma_alpha⟩ := adjancent_gamma + +@@ -406,10 +400,10 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + have s_mem := s.property + rw [Finset.mem_union] at s_mem + cases s_mem +- . rename_i s_mem_N' ++ · rename_i s_mem_N' + rw [subsequent_comm_one] +- . rw [list_fold_comm_one] +- . ++ · rw [list_fold_comm_one] ++ · + clear h_list_eq + induction l_suffix with + | nil => +@@ -420,9 +414,9 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + | cons head tail ih => + simp + apply normal_comm_mem +- . infer_instance +- . exact ih +- . ++ · infer_instance ++ · exact ih ++ · + clear h_list_eq + rw [← Subgroup.mem_map_iff_mem (f := H.subtype) (Subgroup.subtype_injective H)] + induction l_suffix with +@@ -437,9 +431,9 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + simp [-Subgroup.mem_map] + apply normal_comm_mem (by infer_instance) + exact ih +- . rw [List.length_unattach] ++ · rw [List.length_unattach] + omega +- . ++ · + rename_i s_eq_gamma + simp at s_eq_gamma + rw [s_eq_gamma] +@@ -463,23 +457,23 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + rw [Finset.mem_union] at head_prop + + cases head_prop +- . ++ · + rename_i head_in_N + rw [Set.mem_union] at ih + apply Set.mem_union_left + apply normal_comm_mem (by infer_instance) + apply normal_comm_mem_right (by infer_instance) + exact image_sub_map _ head_in_N +- . rename_i head_gamma ++ · rename_i head_gamma + simp at head_gamma + cases ih +- . rename_i left ++ · rename_i left + simp only [List.unattach_cons, List.foldr_cons] + rw [head_gamma] + apply Set.mem_union_left + apply normal_comm_mem (by infer_instance) + exact left +- . ++ · + rename_i right + apply Set.mem_union_left + simp at right +@@ -490,17 +484,17 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + + rw [Set.mem_union] at fold_mem + cases fold_mem +- . rename_i fold_in_N ++ · rename_i fold_in_N + simp at fold_in_N + rw [subsequent_comm_one] +- . rw [list_fold_comm_one] +- . ++ · rw [list_fold_comm_one] ++ · + obtain ⟨foo, bar⟩ := fold_in_N + exact foo +- . obtain ⟨foo, bar⟩ := fold_in_N ++ · obtain ⟨foo, bar⟩ := fold_in_N + exact bar +- . omega +- . rename_i fold_eq_gamma ++ · omega ++ · rename_i fold_eq_gamma + simp at fold_eq_gamma + rw [fold_eq_gamma] + +@@ -512,13 +506,13 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + rw [nat_iterate_comm_one] + rw [list_fold_comm_one] + +- . ++ · + rename_i count_not_gamma + simp at count_not_gamma + rw [mul_comm] at count_not_gamma + rw [Nat.mul_add_div] at count_not_gamma + rw [Nat.div_eq_of_lt] at count_not_gamma +- . simp at count_not_gamma ++ · simp at count_not_gamma + + refine Finset.mem_singleton.mpr ?_ + ext +@@ -534,19 +528,19 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + congr + simp + refine ⟨?_, ?_⟩ +- . intro hx other ++ · intro hx other + rw [← hx] at gamma_not_n + simp at gamma_not_n + apply gamma_not_n other +- . intro hx ++ · intro hx + have x_prop := x.prop + rw [Finset.mem_union] at x_prop +- simp [hx] at x_prop ++ simp at x_prop + cases x_prop +- . rename_i mem_N' ++ · rename_i mem_N' + obtain ⟨mem_H, mem_N⟩ := mem_N' + exact absurd (S_sub_N' _ mem_N) (hx mem_H) +- . rename_i x_eq ++ · rename_i x_eq + exact x_eq + + +@@ -561,11 +555,11 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + + + have foo := count_mem_group_implies_lowercentral (N' := (Subgroup.map H.subtype N')) (by infer_instance) l.unattach s ?_ ?_ +- . ++ · + rw [Subgroup.lowerCentralSeries_eq_bot_of_nilpotencyClass_le (by omega)] at foo + simpa using foo + +- . ++ · + -- TODO - this is ridiculously overcomplicated + + have l_len_ne: l.length ≠ 0 := by +@@ -573,10 +567,10 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + + + grind +- . omega +- . omega +- . omega +- . ++ · omega ++ · omega ++ · omega ++ · + intro a_eq + replace a_eq : a = 1 := Finset.mem_singleton.mp a_eq + -- `S` need not contain `1`, so start the iterated commutator at `gamma_alpha` +@@ -593,4 +587,3 @@ lemma unipotent_commutator_trivial {G: Type*} [DecidableEq G] [Group G] (H: Subg + rw [a_eq] + simpa using iterate_mem + +-#print axioms unipotent_commutator_trivial +diff --git a/Gromov/Unitary/Basic.lean b/Gromov/Unitary/Basic.lean +index afa60f5..b159646 100644 +--- a/Gromov/Unitary/Basic.lean ++++ b/Gromov/Unitary/Basic.lean +@@ -16,8 +16,6 @@ public section + + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset +@@ -190,7 +188,6 @@ lemma poly_growth_equiv {G: Type*} [DecidableEq G] [Group G] (a d: ℕ) + exact Nat.one_le_pow d n hn + + +-#print axioms poly_growth_equiv + + + -- Lemma 3.29 (Shrinking Conjugators) +@@ -247,7 +244,6 @@ instance unitary_proper (n : ℕ) : ProperSpace ↥(Matrix.unitaryGroup (Fin n) + apply ProperSpace.of_isClosed + apply unitary_closed + +-#synth Nontrivial (Matrix (Fin 1) (Fin 1) ℂ) + + + @[expose] +@@ -363,16 +359,15 @@ lemma small_dist_matrix (n : ℕ) (hn : 2 ≤ n) : + linarith + · simp [dists] + apply Set.Finite.image +- apply Set.Finite.diff ++ apply Set.Finite.sdiff + apply Set.Finite.image + + + have finite_roots : Finite ↥(rootsOfUnity n ℂ) := by infer_instance +- -- TODO - how is this working??? + exact finite_roots +- · --have n_gt_one : 1 < n := by omega ++ · + simp [dists] +- rw [Set.diff_nonempty] ++ rw [Set.sdiff_nonempty] + simp + + let my_root : Units ℂ := { +@@ -413,6 +408,5 @@ lemma small_dist_matrix (n : ℕ) (hn : 2 ≤ n) : + norm_cast at abs_lt_one + linarith [Int.one_le_abs a_eq_zero] + +-#print axioms small_dist_matrix + + -- Lemma 3.31 (Volume Packing) +diff --git a/Gromov/Unitary/CentralTrivial.lean b/Gromov/Unitary/CentralTrivial.lean +index 817f510..ade1ee0 100644 +--- a/Gromov/Unitary/CentralTrivial.lean ++++ b/Gromov/Unitary/CentralTrivial.lean +@@ -13,8 +13,6 @@ public section + + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset +@@ -48,23 +46,23 @@ lemma H_n_contradiction (data : HnData) + simp [c'] + rw [Nat.one_le_iff_ne_zero] + apply Nat.mul_ne_zero +- . apply Nat.mul_ne_zero +- . apply Nat.mul_ne_zero +- . simp +- . ++ · apply Nat.mul_ne_zero ++ · apply Nat.mul_ne_zero ++ · simp ++ · + simp + apply c_mul_pos +- . omega +- . simp ++ · omega ++ · simp + ) + have lower_bound := H_n_ball_S_card m_gt data c c_pos c_lt + have ineq := le_trans lower_bound upper_bound + rify at ineq + rw [← Real.log_le_log_iff] at ineq +- . ++ · + simp at ineq + rw [Real.log_mul] at ineq +- . ++ · + simp at ineq + rw [Real.log_mul] at ineq + simp at ineq +@@ -83,17 +81,17 @@ lemma H_n_contradiction (data : HnData) + have log_m_gt: ↑data.S_poly_deg < Real.log ↑m := by + rw [← Real.exp_lt_exp] + rw [Real.exp_log] +- . ++ · + unfold m + apply Nat.lt_of_ceil_lt + apply lt_max_of_lt_right + simp +- . simp ++ · simp + omega + + + rw [Real.log_mul] +- . ++ · + rw [mul_add] + rw [add_comm] + rw [← add_assoc] +@@ -109,87 +107,80 @@ lemma H_n_contradiction (data : HnData) + rw [← lt_tsub_iff_right] + rw [← mul_sub] + rw [← div_lt_iff₀] +- . ++ · + dsimp [m] + apply Nat.lt_of_ceil_lt + apply lt_max_of_lt_left + apply lt_max_of_lt_right + simp +- . ++ · + simp + rw [lt_tsub_iff_right] + rw [← Real.exp_lt_exp] + rw [Real.exp_log] +- . +- rw [← gt_iff_lt] +- grw [(Nat.sub_one_lt_floor _).gt] +- rw [gt_iff_lt] +- rw [lt_tsub_iff_right] +- field_simp +- rw [lt_div_iff₀'] +- rw [← lt_div_iff₀] +- . +- exact eps_div_lt +- . positivity +- . apply H_n_eps_pos +- . ++ · ++ apply lt_trans ?_ (Nat.sub_one_lt_floor _) ++ rw [← div_eq_mul_inv, lt_sub_iff_add_lt, ++ lt_div_iff₀ (H_n_eps_pos data.hd)] ++ simpa only [mul_comm] using ++ (lt_div_iff₀ (show 0 < Real.exp (4 + ↑data.S_poly_deg * Real.log 2) + 1 by positivity)).mp eps_div_lt ++ · + simp + rw [Nat.floor_pos] + exact c_mul_pos +- . simp +- . simp +- . simp +- . ++ · simp ++ · simp ++ · simp ++ · + simp + refine ⟨by simp [c'], ?_⟩ + exact c_mul_pos +- . simp ++ · simp + omega + + unfold swap_le at reverse_ineq +- . linarith +- . have m_ne_zero: m ≠ 0 := by ++ · linarith ++ · have m_ne_zero: m ≠ 0 := by + omega + simp [c', m_ne_zero] + exact c_mul_pos + +- . simp ++ · simp + + +- . ++ · + exact Nat.cast_ne_zero.mpr (id (Ne.symm data.S_poly_const_pos)) +- . ++ · + + + apply ne_zero_of_pos + apply pow_pos + simp + apply mul_pos +- . ++ · + simp [c'] + rw [Nat.floor_pos] + exact c_mul_pos +- . exact Nat.cast_pos'.mpr m_gt +- . ++ · exact Nat.cast_pos'.mpr m_gt ++ · + norm_cast + apply Nat.pow_pos + rw [Nat.floor_pos] + exact c_mul_pos +- . ++ · + apply mul_pos +- . simp ++ · simp + exact Nat.zero_lt_of_ne_zero (id (Ne.symm data.S_poly_const_pos)) +- . ++ · + apply pow_pos + simp [c'] + apply mul_pos +- . simp ++ · simp + rw [Nat.floor_pos] + exact c_mul_pos +- . exact Nat.cast_pos'.mpr m_gt ++ · exact Nat.cast_pos'.mpr m_gt + + +-#print axioms H_n_contradiction + + -- Note - Vikman proves a much weaker statement (an upper boud n terms of 2^n) + -- The norms are actually bounded by a constant, which makes the rest of the proof easier +@@ -203,8 +194,302 @@ open scoped Pointwise + + + -- Theorem 3.8, case with only trivial elements in the center +-set_option synthInstance.maxHeartbeats 100000 in +-set_option maxHeartbeats 2200000 in ++private lemma small_finite_generators (n : ℕ) (hn : 2 ≤ n) ++ (G : Subgroup (Matrix.unitaryGroup (Fin n) ℂ)) ++ (S_poly_data : SPolyData (G' n (H_n_eps hn) G)) : ++ ∃ S : Set G, (∀ s ∈ S, ‖s.val.val - 1‖ < H_n_eps hn) ∧ ++ S.Finite ∧ S = S⁻¹ ∧ Subgroup.closure S = G' n (H_n_eps hn) G ∧ 1 ∈ S := by ++ classical ++ let S' := S_poly_data.S ++ have S'_finite := S_poly_data.S_finite ++ ++ -- Add identity and inverses to S' to make things easier ++ let S'' := S' ++ have S''_finite: Set.Finite S'' := by ++ dsimp [S''] ++ apply S'_finite ++ ++ ++ have S''_eq_S''inv: S'' = S''⁻¹ := by ++ unfold S'' ++ apply S_poly_data.S_inv ++ ++ ++ have S''_generates: Subgroup.closure S'' = ⊤ := by ++ dsimp [S''] ++ apply S_poly_data.S_generates ++ ++ ++ have s_list (s: S'') := (mem_closure_prod_list ((Metric.ball (1 : G) (H_n_eps hn)) ∪ (Metric.ball (1 : G) (H_n_eps hn))⁻¹) (by ++ simp ++ rw [Set.union_comm] ++ ) s (by ++ have s_prop := s.val.property ++ simp only [G'] at s_prop ++ rw [Subgroup.closure_union] ++ simp [s_prop] ++ )) ++ ++ -- Write each element in S'' as a product of elements of S', and then collect all of the used elements into a set ++ -- We may need to manually union this with S⁻¹, since the inverse of the produces ++ -- could be chosen to be built with different elements (not the inverses of the ones in the original list) ++ let pre_S := ⋃ s : S''_finite.toFinset, ((s_list ⟨s, by ( ++ have foo := s.property ++ rw [Set.Finite.mem_toFinset] at foo ++ exact foo ++ )⟩).choose.unattach.toFinset : Set ↥G) ∪ {1} ++ let S := pre_S ∪ pre_S⁻¹ ∪ {1} ++ ++ have S_dist: ∀ s ∈ S, ‖s.val.val - 1‖ < H_n_eps hn := by ++ intro s hs ++ dsimp [S] at hs ++ ++ rw [Set.union_assoc] at hs ++ cases hs ++ · rename_i s_mem ++ dsimp [pre_S] at s_mem ++ rw [Set.mem_iUnion] at s_mem ++ obtain ⟨y, y_mem⟩ := s_mem ++ simp only [List.coe_toFinset, List.mem_unattach, Set.mem_union, Set.mem_inv, ++ Set.mem_ofPred_eq] at y_mem ++ obtain ⟨s_mem_S'', s_mem_choose⟩ := y_mem ++ simp at s_mem_S'' ++ simp only [Subtype.dist_eq, dist_eq_norm_sub] at s_mem_S'' ++ conv at s_mem_S'' => ++ right ++ arg 1 ++ arg 1 ++ equals (star s.val.val * 1 - (star s.val.val) * s.val.val) => ++ simp ++ ++ rw [← mul_sub] at s_mem_S'' ++ rw [← Unitary.coe_star] at s_mem_S'' ++ rw [CStarRing.norm_coe_unitary_mul] at s_mem_S'' ++ nth_rw 2 [norm_sub_rev] at s_mem_S'' ++ simp at s_mem_S'' ++ · exact s_mem_S'' ++ · ++ rename_i s_eq_one ++ simp at s_eq_one ++ simp [s_eq_one] ++ have foo := H_n_eps_pos hn ++ linarith ++ · ++ -- TODO - deduplicate most of this with the above case ++ rename_i s_mem ++ rw [Set.union_comm] at s_mem ++ cases s_mem ++ · rename_i s_mem_one ++ simp at s_mem_one ++ simp [s_mem_one] ++ apply H_n_eps_pos ++ ++ rename_i s_mem ++ dsimp [pre_S] at s_mem ++ rw [Set.iUnion_inv] at s_mem ++ rw [Set.mem_iUnion] at s_mem ++ obtain ⟨y, y_mem⟩ := s_mem ++ simp only [List.coe_toFinset, List.mem_unattach, Set.mem_union, Set.mem_inv, ++ Set.mem_ofPred_eq] at y_mem ++ obtain ⟨s_mem_S'', s_mem_choose⟩ := y_mem ++ simp at s_mem_S'' ++ simp only [Subtype.dist_eq, dist_eq_norm_sub] at s_mem_S'' ++ rw [or_comm] at s_mem_S'' ++ conv at s_mem_S'' => ++ right ++ arg 1 ++ arg 1 ++ equals (star s.val.val * 1 - (star s.val.val) * s.val.val) => ++ simp ++ ++ rw [← mul_sub] at s_mem_S'' ++ rw [← Unitary.coe_star] at s_mem_S'' ++ rw [CStarRing.norm_coe_unitary_mul] at s_mem_S'' ++ nth_rw 2 [norm_sub_rev] at s_mem_S'' ++ simp at s_mem_S'' ++ · exact s_mem_S'' ++ · ++ rename_i s_eq_one ++ simp at s_eq_one ++ simp [s_eq_one] ++ have foo := H_n_eps_pos hn ++ linarith ++ ++ ++ have S_finite: Set.Finite S := by ++ dsimp [S] ++ apply Set.Finite.union ++ · ++ simp ++ dsimp [pre_S] ++ apply Set.Finite.sUnion ++ · ++ apply Set.finite_range ++ · ++ intro y hy ++ rw [Set.mem_range] at hy ++ obtain ⟨x, x_mem, y_eq⟩ := hy ++ apply Set.Finite.union ++ · apply Finset.finite_toSet ++ · simp ++ · simp ++ ++ have S_union_Sinv: S ∪ S⁻¹ = S := by ++ dsimp [S] ++ simp [-Set.union_singleton] ++ grind ++ ++ have S_eq_Sinv: S = S⁻¹ := by ++ rw [← S_union_Sinv] ++ simp ++ rw [Set.union_comm] ++ ++ have S_generates : Subgroup.closure S = G' n (H_n_eps hn) G := by ++ apply le_antisymm ++ · apply (Subgroup.closure_le (K := G' n (H_n_eps hn) G)).2 ++ intro g hg ++ apply Subgroup.subset_closure ++ simpa only [Metric.mem_ball, Subtype.dist_eq, dist_eq_norm_sub, norm_sub_rev, ++ Subgroup.coe_one, Submonoid.coe_one] ++ using S_dist g hg ++ · have hgen : ∀ g : G' n (H_n_eps hn) G, g.val ∈ Subgroup.closure S := by ++ intro g ++ have hg : g ∈ Subgroup.closure S'' := by rw [S''_generates]; trivial ++ induction hg using Subgroup.closure_induction with ++ | mem g hg => ++ have hprod := (s_list ⟨g, hg⟩).choose_spec ++ rw [← hprod] ++ apply Subgroup.list_prod_mem ++ intro x hx ++ apply Subgroup.subset_closure ++ apply Set.mem_union_left ++ apply Set.mem_union_left ++ apply Set.mem_iUnion.mpr ++ refine ⟨⟨g, S''_finite.mem_toFinset.mpr hg⟩, Or.inl ?_⟩ ++ exact List.mem_toFinset.mpr hx ++ | one => exact Subgroup.one_mem _ ++ | mul x y hx hy hx' hy' => exact Subgroup.mul_mem _ hx' hy' ++ | inv x hx hx' => exact Subgroup.inv_mem _ hx' ++ intro g hg ++ exact hgen ⟨g, hg⟩ ++ ++ exact ⟨S, S_dist, S_finite, S_eq_Sinv, S_generates, by simp [S]⟩ ++ ++private lemma small_generators_growth (n : ℕ) (hn : 2 ≤ n) ++ (G : Subgroup (Matrix.unitaryGroup (Fin n) ℂ)) ++ (S_poly_data : SPolyData (G' n (H_n_eps hn) G)) ++ (S : Set G) (S_finite : S.Finite) ++ (s_to_map : S_finite.toFinset → Subgroup.map G.subtype (G' n (H_n_eps hn) G)) ++ (h_map : ∀ a, (s_to_map a).val = a.val.val) : ++ ∃ a : ℕ, a ≥ 1 ∧ ∀ r ≥ 1, ++ #(Finset.image s_to_map S_finite.toFinset.attach ^ r) ≤ a * r ^ S_poly_data.S_poly_deg := by ++ classical ++ have poly_pos := S_poly_data.S_poly_const_pos ++ have new_try := poly_growth_equiv S_poly_data.S_poly_const S_poly_data.S_poly_deg (by omega) (S_poly_data.S_finite.toFinset) ++ (Finset.image (fun a => ⟨⟨(s_to_map a).val, by (rw [h_map]; exact a.val.property)⟩, by ( ++ have foo := (s_to_map a).property ++ rw [Subgroup.mem_map] at foo ++ obtain ⟨x, x_mem, x_eq⟩ := foo ++ simp_rw [← x_eq] ++ simp [x_mem] ++ )⟩) S_finite.toFinset.attach) ?_ ?_ ?_ ?_ ++ · ++ obtain ⟨b, b_pos, hb⟩ := new_try ++ use b ++ refine ⟨b_pos, ?_⟩ ++ intro r hr ++ rw [← Finset.card_image_of_injective (f := Subgroup.subtype _) _ (by apply subtype_injective)] ++ rw [Finset.image_pow] ++ rw [Finset.image_image] ++ simp ++ conv => ++ arg 1 ++ arg 1 ++ arg 1 ++ equals Finset.image (Subgroup.subtype _) S_finite.toFinset => ++ ext a ++ rw [Finset.mem_image] ++ refine ⟨?_, ?_⟩ ++ · intro x ++ obtain ⟨y, y_mem, y_eq⟩ := x ++ rw [Finset.mem_image] ++ use y ++ rw [← y_eq] ++ simp [h_map] ++ · intro x_mem ++ rw [Finset.mem_image] at x_mem ++ obtain ⟨y, y_mem, y_eq⟩ := x_mem ++ use ⟨y, y_mem⟩ ++ simp [h_map] ++ exact y_eq ++ ++ ++ specialize hb r hr ++ rw [← Finset.card_image_of_injective (f := Subgroup.subtype _) _ (by apply subtype_injective)] at hb ++ rw [Finset.image_pow] at hb ++ rw [← Finset.card_image_of_injective (f := Subgroup.subtype _) _ (by apply subtype_injective)] at hb ++ rw [Finset.image_pow] at hb ++ conv at hb => ++ arg 1 ++ arg 1 ++ arg 1 ++ equals Finset.image (Subgroup.subtype _) S_finite.toFinset => ++ ext a ++ rw [Finset.mem_image] ++ refine ⟨?_, ?_⟩ ++ · intro x ++ obtain ⟨y, y_mem, y_eq⟩ := x ++ rw [Finset.mem_image] ++ use y ++ rw [← y_eq] ++ simp ++ rw [Finset.image_image] at y_mem ++ rw [Finset.mem_image] at y_mem ++ obtain ⟨z, z_mem, z_eq⟩ := y_mem ++ simp at z_eq ++ rw [← z_eq] ++ simp [h_map] ++ have z_prop := z.property ++ rw [Set.Finite.mem_toFinset] at z_prop ++ exact z_prop ++ · intro x_mem ++ rw [Finset.mem_image] at x_mem ++ obtain ⟨y, y_mem, y_eq⟩ := x_mem ++ use y ++ refine ⟨?_, y_eq⟩ ++ rw [Finset.image_image] ++ rw [Finset.mem_image] ++ simp at y_mem ++ use ⟨y, by simp [y_mem]⟩ ++ simp [h_map] ++ exact hb ++ · ++ have fintype_s: Fintype ↑S_poly_data.S := by ++ refine Set.Finite.fintype ?_ ++ exact S_poly_data.S_finite ++ ++ ++ simp ++ conv => ++ rhs ++ equals (S_poly_data.S).toFinset => ++ ext a ++ simp ++ nth_rw 1 [S_poly_data.S_inv] ++ simp ++ · ++ simp ++ apply S_poly_data.S_one ++ · ++ simp ++ exact S_poly_data.S_generates ++ · ++ intro n hn ++ have S_poly := S_poly_data.S_poly n hn ++ exact S_poly ++ ++ ++ + lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup (Matrix.unitaryGroup (Fin n) ℂ)) (G_FG : G.FG) + (G'_central_trivial : ∀ g : (G' n (H_n_eps hn) G), g ∈ Set.center (G' n (H_n_eps hn) G) → ∃ z : ℂ, g.val.val.val = z • 1) + (G'_finite_index: (G' n (H_n_eps hn) G).FiniteIndex) +@@ -240,247 +525,12 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + + + let S' := S_poly_data.S +- have S'_finite := S_poly_data.S_finite +- +- -- Add identity and inverses to S' to make things easier + let S'' := S' +- have S''_finite: Set.Finite S'' := by +- dsimp [S''] +- apply S'_finite +- +- +- have S''_eq_S''inv: S'' = S''⁻¹ := by +- unfold S'' +- apply S_poly_data.S_inv +- +- +- have S''_generates: Subgroup.closure S'' = ⊤ := by +- dsimp [S''] +- apply S_poly_data.S_generates +- +- +- have s_list (s: S'') := (mem_closure_prod_list ((Metric.ball (1 : G) (H_n_eps hn)) ∪ (Metric.ball (1 : G) (H_n_eps hn))⁻¹) (by +- simp +- rw [Set.union_comm] +- ) s (by +- have s_prop := s.val.property +- simp only [G'] at s_prop +- rw [Subgroup.closure_union] +- simp [s_prop] +- )) +- +- -- Write each element in S'' as a product of elements of S', and then collect all of the used elements into a set +- -- We may need to manually union this with S⁻¹, since the inverse of the produces +- -- could be chosen to be built with different elements (not the inverses of the ones in the original list) +- let pre_S := ⋃ s : S''_finite.toFinset, ((s_list ⟨s, by ( +- have foo := s.property +- rw [Set.Finite.mem_toFinset] at foo +- exact foo +- )⟩).choose.unattach.toFinset : Set ↥G) ∪ {1} +- let S := pre_S ∪ pre_S⁻¹ ∪ {1} +- +- have S_dist: ∀ s ∈ S, ‖s.val.val - 1‖ < H_n_eps hn := by +- intro s hs +- dsimp [S] at hs +- +- rw [Set.union_assoc] at hs +- cases hs +- . rename_i s_mem +- dsimp [pre_S] at s_mem +- rw [Set.mem_iUnion] at s_mem +- obtain ⟨y, y_mem⟩ := s_mem +- simp only [List.coe_toFinset, List.mem_unattach, Set.mem_union, Set.mem_inv, +- Set.mem_setOf_eq] at y_mem +- obtain ⟨s_mem_S'', s_mem_choose⟩ := y_mem +- simp at s_mem_S'' +- simp only [Subtype.dist_eq, dist_eq_norm_sub] at s_mem_S'' +- conv at s_mem_S'' => +- right +- arg 1 +- arg 1 +- equals (star s.val.val * 1 - (star s.val.val) * s.val.val) => +- simp +- +- rw [← mul_sub] at s_mem_S'' +- rw [← Unitary.coe_star] at s_mem_S'' +- rw [CStarRing.norm_coe_unitary_mul] at s_mem_S'' +- nth_rw 2 [norm_sub_rev] at s_mem_S'' +- simp at s_mem_S'' +- . exact s_mem_S'' +- . +- rename_i s_eq_one +- simp at s_eq_one +- simp [s_eq_one] +- have foo := H_n_eps_pos hn +- linarith +- . +- -- TODO - deduplicate most of this with the above case +- rename_i s_mem +- rw [Set.union_comm] at s_mem +- cases s_mem +- . rename_i s_mem_one +- simp at s_mem_one +- simp [s_mem_one] +- apply H_n_eps_pos +- +- rename_i s_mem +- dsimp [pre_S] at s_mem +- rw [Set.iUnion_inv] at s_mem +- rw [Set.mem_iUnion] at s_mem +- obtain ⟨y, y_mem⟩ := s_mem +- simp only [List.coe_toFinset, List.mem_unattach, Set.mem_union, Set.mem_inv, +- Set.mem_setOf_eq] at y_mem +- obtain ⟨s_mem_S'', s_mem_choose⟩ := y_mem +- simp at s_mem_S'' +- simp only [Subtype.dist_eq, dist_eq_norm_sub] at s_mem_S'' +- rw [or_comm] at s_mem_S'' +- conv at s_mem_S'' => +- right +- arg 1 +- arg 1 +- equals (star s.val.val * 1 - (star s.val.val) * s.val.val) => +- simp +- +- rw [← mul_sub] at s_mem_S'' +- rw [← Unitary.coe_star] at s_mem_S'' +- rw [CStarRing.norm_coe_unitary_mul] at s_mem_S'' +- nth_rw 2 [norm_sub_rev] at s_mem_S'' +- simp at s_mem_S'' +- . exact s_mem_S'' +- . +- rename_i s_eq_one +- simp at s_eq_one +- simp [s_eq_one] +- have foo := H_n_eps_pos hn +- linarith +- +- +- have S_finite: Set.Finite S := by +- dsimp [S] +- apply Set.Finite.union +- . +- simp +- dsimp [pre_S] +- apply Set.Finite.sUnion +- . +- apply Set.finite_range +- . +- intro y hy +- rw [Set.mem_range] at hy +- obtain ⟨x, x_mem, y_eq⟩ := hy +- apply Set.Finite.union +- . apply Finset.finite_toSet +- . simp +- . simp +- +- have S_union_Sinv: S ∪ S⁻¹ = S := by +- dsimp [S] +- simp [-Set.union_singleton] +- grind +- +- have S_eq_Sinv: S = S⁻¹ := by +- rw [← S_union_Sinv] +- simp +- rw [Set.union_comm] +- +- have S_generates: Subgroup.closure S = (G' n (H_n_eps hn) G) := by +- +- ext a +- unfold S +- rw [Subgroup.closure_union] +- simp +- rw [Subgroup.closure_union] +- simp +- unfold pre_S +- refine ⟨?_, ?_⟩ +- . intro ha +- -- TODO - only the 'mem' case is non-trivial. We probably don't actually need a full induction proof +- induction ha using Subgroup.closure_induction with +- | one => +- simp [G'] +- | mem x hx => +- rw [Set.mem_iUnion] at hx +- obtain ⟨y, y_mem⟩ := hx +- have y_prop := y.property +- rw [Set.Finite.mem_toFinset] at y_prop +- cases y_mem +- . +- rename_i y_mem +- simp at y_mem +- obtain ⟨x_dist, x_mem⟩ := y_mem +- simp [G'] +- apply Subgroup.mem_closure_of_mem +- simp +- cases x_dist +- . rename_i x_dist_le +- exact x_dist_le +- . rename_i x_inv_dist +- +- -- TODO - deduplicate this, in particular the 'CStarRing.norm_coe_unitary_mul' code +- simp only [Subtype.dist_eq, dist_eq_norm_sub] at x_inv_dist +- conv at x_inv_dist => +- lhs +- arg 1 +- equals (star x.val.val * 1 - (star x.val.val) * x.val.val) => +- simp +- +- rw [← mul_sub] at x_inv_dist +- rw [← Unitary.coe_star] at x_inv_dist +- rw [CStarRing.norm_coe_unitary_mul] at x_inv_dist +- rw [norm_sub_rev] at x_inv_dist +- simp only [Subtype.dist_eq, dist_eq_norm_sub] +- exact x_inv_dist +- . +- rename_i x_mem_one +- simp at x_mem_one +- simp [x_mem_one] +- | mul x y hx hy x_mem y_mem => +- apply Subgroup.mul_mem +- . exact x_mem +- . exact y_mem +- | inv x hx x_mem => +- apply Subgroup.inv_mem +- exact x_mem +- . +- intro ha +- apply_fun (Subgroup.map (G' n (H_n_eps hn) G).subtype) at S''_generates +- conv at S''_generates => +- rhs +- equals (G' n (H_n_eps hn) G) => +- ext a +- simp +- +- rw [← S''_generates] at ha +- simp at ha +- obtain ⟨a_mem_g', a_mem_closure⟩ := ha +- rw [← Subgroup.mem_toSubmonoid] at a_mem_closure +- rw [Subgroup.closure_toSubmonoid] at a_mem_closure +- obtain ⟨l, l_mem, l_prod_eq⟩ := Submonoid.exists_list_of_mem_closure a_mem_closure +- rw [Subtype.ext_iff] at l_prod_eq +- simp at l_prod_eq +- rw [← l_prod_eq] +- apply Subgroup.list_prod_mem +- intro x x_mem_l +- simp at x_mem_l +- obtain ⟨x_mem_g', x_mem_l⟩ := x_mem_l +- have x_mem_ball := l_mem _ x_mem_l +- +- rw [Subgroup.closure_iUnion] +- rw [← S''_eq_S''inv] at x_mem_ball +- simp at x_mem_ball +- apply Subgroup.mem_iSup_of_mem (i := ⟨⟨x, x_mem_g'⟩, (by simp; apply x_mem_ball)⟩) +- have my_spec := (s_list ⟨⟨x, x_mem_g'⟩, x_mem_ball⟩).choose_spec +- simp at my_spec +- conv => +- arg 2 +- rw [← my_spec] +- +- apply Subgroup.list_prod_mem +- intro b b_mem +- apply Subgroup.mem_closure_of_mem +- apply Set.mem_union_left +- simpa using b_mem +- ++ have S''_generates : Subgroup.closure S'' = ⊤ := S_poly_data.S_generates ++ have S''_eq_S''inv : S'' = S''⁻¹ := S_poly_data.S_inv ++ obtain ⟨S, S_dist, S_finite, S_eq_Sinv, S_generates, S_one⟩ := ++ small_finite_generators n hn G S_poly_data ++ have S_union_Sinv : S ∪ S⁻¹ = S := by rw [← S_eq_Sinv]; simp + + have nontrivial_h: ∃ h: S, ∀ z: ℂ, h.val.val.val ≠ z • 1 := by + by_contra! +@@ -497,7 +547,7 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + + have list_prod_trivial: ∃ z: ℂ, l.unattach.unattach.prod = z • 1 := by + apply List.prod_induction (p := fun a => ∃ z: ℂ, a = z • 1) +- . ++ · + intro a b a_diag b_diag + obtain ⟨a_z, a_eq⟩ := a_diag + obtain ⟨b_z, b_eq⟩ := b_diag +@@ -505,9 +555,9 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + rw [a_eq, b_eq] + rw [mul_smul] + simp +- . use 1 ++ · use 1 + simp +- . ++ · + intro x x_mem + rw [List.mem_unattach] at x_mem + obtain ⟨a, ha⟩ := x_mem +@@ -548,111 +598,8 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + + have poly_pos := S_poly_data.S_poly_const_pos + +- have my_map: ∃ a: ℕ, a ≥ 1 ∧ ∀ r ≥ 1, #(Finset.image s_to_map S_finite.toFinset.attach ^ r) ≤ a * r ^ (S_poly_data.S_poly_deg) := by +- have new_try := poly_growth_equiv S_poly_data.S_poly_const S_poly_data.S_poly_deg (by omega) (S_poly_data.S_finite.toFinset) +- (Finset.image (fun a => ⟨⟨(s_to_map a).val, by (apply SetLike.coe_mem)⟩, by ( +- have foo := (s_to_map a).property +- rw [Subgroup.mem_map] at foo +- obtain ⟨x, x_mem, x_eq⟩ := foo +- simp_rw [← x_eq] +- simp [x_mem] +- )⟩) S_finite.toFinset.attach) ?_ ?_ ?_ ?_ +- . +- obtain ⟨b, b_pos, hb⟩ := new_try +- use b +- refine ⟨b_pos, ?_⟩ +- intro r hr +- rw [← Finset.card_image_of_injective (f := Subgroup.subtype _) _ (by apply subtype_injective)] +- rw [Finset.image_pow] +- rw [Finset.image_image] +- simp +- conv => +- arg 1 +- arg 1 +- arg 1 +- equals Finset.image (Subgroup.subtype _) S_finite.toFinset => +- ext a +- rw [Finset.mem_image] +- refine ⟨?_, ?_⟩ +- . intro x +- obtain ⟨y, y_mem, y_eq⟩ := x +- rw [Finset.mem_image] +- use y +- rw [← y_eq] +- simp [s_to_map] +- . intro x_mem +- rw [Finset.mem_image] at x_mem +- obtain ⟨y, y_mem, y_eq⟩ := x_mem +- use ⟨y, y_mem⟩ +- simp [s_to_map] +- exact y_eq +- +- +- specialize hb r hr +- rw [← Finset.card_image_of_injective (f := Subgroup.subtype _) _ (by apply subtype_injective)] at hb +- rw [Finset.image_pow] at hb +- rw [← Finset.card_image_of_injective (f := Subgroup.subtype _) _ (by apply subtype_injective)] at hb +- rw [Finset.image_pow] at hb +- conv at hb => +- arg 1 +- arg 1 +- arg 1 +- equals Finset.image (Subgroup.subtype _) S_finite.toFinset => +- ext a +- rw [Finset.mem_image] +- refine ⟨?_, ?_⟩ +- . intro x +- obtain ⟨y, y_mem, y_eq⟩ := x +- rw [Finset.mem_image] +- use y +- rw [← y_eq] +- simp [s_to_map] +- rw [Finset.image_image] at y_mem +- rw [Finset.mem_image] at y_mem +- obtain ⟨z, z_mem, z_eq⟩ := y_mem +- simp at z_eq +- rw [← z_eq] +- simp [s_to_map] +- have z_prop := z.property +- rw [Set.Finite.mem_toFinset] at z_prop +- exact z_prop +- . intro x_mem +- rw [Finset.mem_image] at x_mem +- obtain ⟨y, y_mem, y_eq⟩ := x_mem +- use y +- refine ⟨?_, y_eq⟩ +- rw [Finset.image_image] +- rw [Finset.mem_image] +- simp at y_mem +- use ⟨y, by simp [y_mem]⟩ +- simp [s_to_map] +- exact hb +- . +- have fintype_s: Fintype ↑S_poly_data.S := by +- refine Set.Finite.fintype ?_ +- exact S_poly_data.S_finite +- +- +- simp +- conv => +- rhs +- unfold Set.Finite.toFinset +- equals (S_poly_data.S).toFinset => +- ext a +- simp +- nth_rw 1 [S_poly_data.S_inv] +- simp +- . +- simp +- apply S_poly_data.S_one +- . +- simp +- exact S_poly_data.S_generates +- . +- intro n hn +- have S_poly := S_poly_data.S_poly n hn +- exact S_poly +- ++ have my_map := small_generators_growth n hn G S_poly_data S S_finite ++ s_to_map (by intro a; rfl) + + obtain ⟨new_const, new_const_pos, h_poly_new_const⟩ := my_map + +@@ -700,146 +647,29 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + + S := (((Finset.image s_to_map) S_finite.toFinset.attach : Finset _) : Set _) + S_generates := by +- simp +- have orig_S'' := S''_generates +- apply_fun (Subgroup.map (G' n (H_n_eps hn) G).subtype) at S''_generates +- conv at S''_generates => +- rhs +- equals (G' n (H_n_eps hn) G) => +- ext a +- simp +- +- apply_fun (Subgroup.map ({ +- toFun := fun a => (⟨a.val, (by +- have prop := a.property +- rw [Subgroup.mem_map] at prop +- obtain ⟨x, x_mem, x_eq⟩ := prop +- rw [← x_eq] +- simp +- )⟩ : G), +- map_one' := by +- simp +- map_mul' := by +- intro a b +- simp +- })) using (?_) +- . conv => +- rhs +- equals (G' n (H_n_eps hn) G) => +- ext a +- rw [Subgroup.mem_map] +- refine ⟨?_, ?_⟩ +- . +- intro exists_x +- obtain ⟨x, x_mem, a_eq⟩ := exists_x +- simp at a_eq +- have x_prop := x.property +- rw [Subgroup.mem_map] at x_prop +- obtain ⟨y, y_mem, x_eq_y⟩ := x_prop +- rw [← a_eq] +- conv => +- arg 2 +- simp [← x_eq_y] +- exact y_mem +- . intro a_mem +- use ⟨a, ?_⟩ +- . refine ⟨by simp, ?_⟩ +- simp +- . rw [Subgroup.mem_map] +- use ⟨a, ?_⟩ +- . refine ⟨by simp; apply a_mem, ?_⟩ +- simp +- . simp +- +- conv => +- rhs +- rw [← S''_generates] +- ext a +- rw [Subgroup.mem_map] +- refine ⟨?_, ?_⟩ +- . +- intro ha +- simp at ha +- simp +- obtain ⟨b, b_mem, a_mem_g, b_mem_closure, a_eq_b⟩ := ha +- use ?_ +- . conv => +- arg 2 +- simp only [← a_eq_b] +- +- rw [orig_S''] +- simp +- . obtain ⟨b_mem, b_mem_g'⟩ := a_mem_g +- rw [← a_eq_b] +- simp [b_mem_g'] +- . intro ha +- have a_val_mem: a.val ∈ Subgroup.map G.subtype (G' n (H_n_eps hn) G) := by +- simp at ha +- simp +- obtain ⟨a_mem_g', a_mem_closure⟩ := ha +- apply a_mem_g' +- +- use ⟨a, ?_⟩ +- . refine ⟨?_, by simp⟩ +- rw [← Subgroup.mem_toSubmonoid] +- rw [Subgroup.closure_toSubmonoid] +- rw [← SetLike.mem_coe] +- rw [Submonoid.closure_eq_image_prod] +- rw [Set.mem_image] +- rw [Subgroup.mem_map] at ha +- obtain ⟨b, b_mem, a_eq_b⟩ := ha +- have b_prop := b.property +- conv at b_prop => +- arg 1 +- rw [← S_generates] +- have b_list := mem_closure_prod_list S S_eq_Sinv b b_prop +- obtain ⟨l, l_prod⟩ := b_list +- use List.map (fun d => ⟨d.val, ?_⟩) l +- . +- refine ⟨?_, ?_⟩ +- . +- rw [Set.mem_setOf (a := List.map _ _)] +- intro p p_mem +- apply Set.mem_union_left +- rw [List.mem_map] at p_mem +- rw [Set.mem_range] +- obtain ⟨z, z_mem, z_eq_p⟩ := p_mem +- use ⟨z, by simp⟩ +- rw [← z_eq_p] +- . +- conv => +- rhs +- simp [← a_eq_b] +- conv => +- rhs +- simp [← l_prod] +- apply Subtype.ext +- simp +- rw [List.comp_map] +- simp +- apply congrArg +- ext i g +- simp +- +- . +- have my_mem := S_mem_G' d (by simp) +- apply Subgroup.mem_map_of_mem +- apply my_mem +- . exact a_val_mem ++ let L := Subgroup.map G.subtype (G' n (H_n_eps hn) G) ++ apply Subgroup.map_injective (f := L.subtype) Subtype.val_injective ++ rw [MonoidHom.map_closure] ++ have himg : L.subtype '' (Finset.image s_to_map S_finite.toFinset.attach : Set L) ++ = G.subtype '' S := by ++ ext u ++ constructor ++ · rintro ⟨t, ht, rfl⟩ ++ obtain ⟨a, ha, rfl⟩ := Finset.mem_image.mp ht ++ exact ⟨a.val, S_finite.mem_toFinset.mp a.property, rfl⟩ ++ · rintro ⟨g, hg, rfl⟩ ++ let a : S_finite.toFinset := ⟨g, S_finite.mem_toFinset.mpr hg⟩ ++ exact ⟨s_to_map a, Finset.mem_image.mpr ⟨a, by simp, rfl⟩, rfl⟩ ++ rw [himg, ← MonoidHom.map_closure, S_generates] ++ rw [← MonoidHom.range_eq_map, Subgroup.range_subtype] + + S_finite := by + simp + apply Set.finite_range + S_one := by +- simp +- dsimp [S] +- use 1 +- use (by simp) +- use (by apply Subgroup.one_mem) +- use ?_ ++ rw [Finset.mem_coe, Finset.mem_image] ++ refine ⟨⟨1, S_finite.mem_toFinset.mpr S_one⟩, by simp, ?_⟩ + simp [s_to_map] +- apply Set.mem_union_right +- simp + S_inv := by + intro s hs + rw [Finset.mem_coe] at hs +@@ -848,11 +678,11 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + obtain ⟨x, x_mem, s_eq⟩ := hs + rw [Finset.mem_image] + use ⟨x⁻¹, ?_⟩ +- . ++ · + simp + rw [← s_eq] + rfl +- . simp ++ · simp + + nth_rw 1 [S_eq_Sinv] + simp +@@ -876,74 +706,31 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + S_poly := by + simp + apply h_poly_new_const +- h := ⟨⟨h.val.val, by ( +- have h_prop := h.property +- simp only [S] at h_prop +- simp +- cases h_prop +- . rename_i h_mem +- . cases h_mem +- . rename_i h_prop +- dsimp [pre_S] at h_prop +- rw [Set.mem_iUnion] at h_prop +- obtain ⟨y, y_mem⟩ := h_prop +- simp [-Set.mem_inv] at y_mem +- have h_dist := S_dist h (by simp) +- simp [G'] +- apply Subgroup.mem_closure_of_mem +- simp +- simp only [Subtype.dist_eq, dist_eq_norm_sub] +- exact h_dist +- . rename_i h_prop +- -- TODo: deduplicate +- dsimp [pre_S] at h_prop +- simp_rw [Set.iUnion_inv] at h_prop +- rw [Set.mem_iUnion] at h_prop +- obtain ⟨y, y_mem⟩ := h_prop +- simp [-Set.mem_inv] at y_mem +- have h_dist := S_dist h (by simp) +- simp [G'] +- apply Subgroup.mem_closure_of_mem +- simp +- simp only [Subtype.dist_eq, dist_eq_norm_sub] +- exact h_dist +- . rename_i h_mem +- simp at h_mem +- simp [G'] +- simp [h_mem] +- )⟩, by +- rw [Finset.mem_coe] +- rw [Finset.mem_image] +- use ⟨h.val, by simp⟩ +- simp [s_to_map] +- ⟩ ++ h := ⟨⟨h.val.val, Subgroup.mem_map_of_mem G.subtype (S_mem_G' h.val h.property)⟩, by ++ rw [Finset.mem_coe, Finset.mem_image] ++ refine ⟨⟨h.val, S_finite.mem_toFinset.mpr h.property⟩, by simp, ?_⟩ ++ rfl⟩ + h_nontrivial := by + simpa using h_nontrivial + } +- . +- apply Subgroup.map_injective +- simp +- intro x y hxy +- simpa using hxy +- + have contra := H_n_contradiction h_n_data (1 / 50) ?_ ?_ ?_ ?_ +- . contradiction +- . simp +- . simp ++ · contradiction ++ · simp ++ · simp + norm_num +- . ++ · + rw [← div_le_iff₀'] +- . ++ · + rw [le_inv_comm₀] +- . ++ · + simp + simp [H_n_eps] + left + norm_num +- . simp +- . apply H_n_eps_pos +- . simp +- . ++ · simp ++ · apply H_n_eps_pos ++ · simp ++ · + simp + unfold H_n_eps + +@@ -954,10 +741,10 @@ lemma central_trivial_virtually_abelian (n : ℕ) (hn : 2 ≤ n) (G : Subgroup ( + simp [h_n_data] + norm_num + apply div_lt_div₀ +- . norm_num +- . apply le_refl +- . norm_num +- . positivity ++ · norm_num ++ · apply le_refl ++ · norm_num ++ · positivity + + end HnEpsData + +diff --git a/Gromov/Unitary/HnEps.lean b/Gromov/Unitary/HnEps.lean +index cfaf26d..83c61b0 100644 +--- a/Gromov/Unitary/HnEps.lean ++++ b/Gromov/Unitary/HnEps.lean +@@ -14,8 +14,6 @@ public section + + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset +@@ -198,7 +196,6 @@ theorem theorem_3_8_h_n_left_S (data: HnData) (prev: Theorem3_8_Data data): ∃ + + -- 'h' is our initial element - we define ε in terms of ‖h - 1‖, so that we can obtain the proper bound + -- for the commutators in the inductive case +-set_option maxHeartbeats 500000 in + @[expose] + noncomputable def theorem_3_8_h_n (data : HnData) (n : ℕ): Theorem3_8_Data data := match hn : n with + | 0 => { +@@ -260,7 +257,6 @@ termination_by n + decreasing_by + simp + +-#print axioms theorem_3_8_h_n + + omit h_n_eps_data in + lemma unitary_shrink {n : ℕ} (a b : Matrix.unitaryGroup (Fin n) ℂ): ‖(a * b).val - 1‖ ≤ ‖a.val - 1‖ + ‖b.val - 1‖ := by +@@ -326,10 +322,9 @@ lemma H_n_pow_le {a k : ℕ } {m : ℕ} (a_k_lt : a + k ≤ m) (pows : Fin m + | zero => + simp [List.ofFn, List.prod_nil] + | succ k ih => +- simp only [ne_eq, List.ofFn_succ'] +- simp only [Fin.coe_castSucc, Fin.val_last, List.concat_eq_append, List.prod_append, +- List.prod_cons, List.prod_nil, mul_one, Subgroup.val_list_prod, +- List.map_ofFn] ++ simp only [List.ofFn_succ'] ++ simp only [Fin.val_castSucc, Fin.val_last, List.concat_eq_append, List.prod_append, ++ List.prod_cons, List.prod_nil, mul_one] + + rw [Subgroup.coe_mul] + grw [unitary_shrink] +@@ -398,7 +393,7 @@ lemma H_n_prod_le_k {a k : ℕ } {m : ℕ} (a_k_lt : a + k + 1 ≤ m) (c : ℝ) + field_simp [eps_ne_zero] + + grw [c_lt] +- ring ++ ring_nf + rfl + · positivity + · grw [H_n_eps_lt data.hd] +@@ -418,8 +413,6 @@ lemma H_n_prod_le_k {a k : ℕ } {m : ℕ} (a_k_lt : a + k + 1 ≤ m) (c : ℝ) + grw [pows_le] + · omega + +-#print axioms H_n_prod_le_k + +-#synth Semiring (Matrix (Fin 2) (Fin 2) ℂ) + + end HnEpsData +diff --git a/Gromov/Unitary/HnLowerBound.lean b/Gromov/Unitary/HnLowerBound.lean +index 8c9b440..7ee4180 100644 +--- a/Gromov/Unitary/HnLowerBound.lean ++++ b/Gromov/Unitary/HnLowerBound.lean +@@ -13,8 +13,6 @@ public section + + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset +@@ -63,7 +61,8 @@ lemma f_deriv (a: ℝ) (ha: 0 < 1 + a) (x: ℝ): (deriv (f a)) x = 2*a - (Real.l + exact ha + + +-lemma f_deriv_at_one (a: ℝ) (a_pos: 0 < a) (a_lt: a < 1) (ha: 0 < 1 + a): 0 < (deriv (f a) 1) := by ++omit h_n_eps_data in ++lemma f_deriv_at_one [_h_n_eps_data : HnEpsData] (a: ℝ) (a_pos: 0 < a) (a_lt: a < 1) (ha: 0 < 1 + a): 0 < (deriv (f a) 1) := by + rw [f_deriv _ ha] + grw [Real.log_le_sub_one_of_pos] + · have a_mul_self := mul_lt_of_lt_one_left (a := a) (b := a) (by linarith) (by linarith) +@@ -72,7 +71,8 @@ lemma f_deriv_at_one (a: ℝ) (a_pos: 0 < a) (a_lt: a < 1) (ha: 0 < 1 + a): 0 < + simp [ha] + + +-lemma f_deriv_lower (a: ℝ) (ha: 0 < 1 + a) (a_pos: 0 < a) (x: ℝ) (f_zero: (deriv (f a)) x = 0): (Real.log 2) / a ≤ x := by ++omit h_n_eps_data in ++lemma f_deriv_lower [_h_n_eps_data : HnEpsData] (a: ℝ) (ha: 0 < 1 + a) (a_pos: 0 < a) (x: ℝ) (f_zero: (deriv (f a)) x = 0): (Real.log 2) / a ≤ x := by + have log_plus_le: Real.log (1 + a) ≤ a := by + grw [Real.log_le_sub_one_of_pos] + · simp +@@ -112,28 +112,28 @@ lemma f_pos_on (a: ℝ) (ha: 0 < 1 + a) (a_pos: 0 < a) (a_lt: a < 1) (a_lt_log: + + have one_lt : 1 < Real.log (2) / a := by + rw [lt_div_iff₀] +- . simp ++ · simp + exact a_lt_log +- . exact a_pos ++ · exact a_pos + + have f_strict := strictMonoOn_of_deriv_pos (f := f a) (D := Set.Icc 1 ((Real.log (2 )) / a)) (by apply convex_Icc) ?_ ?_ +- . ++ · + intro x hx + have f_lt := f_strict.lt_iff_lt (a := 1) (b := x) ?_ ?_ + rw [f_one_eq_zero] at f_lt + have x_prop := hx.left + simp [x_prop] at f_lt +- . exact f_lt +- . simp ++ · exact f_lt ++ · simp + linarith +- . simp ++ · simp + simp at hx + refine ⟨by linarith, hx.right⟩ +- . apply Continuous.continuousOn ++ · apply Continuous.continuousOn + unfold f + have one_plus: 1 + a ≠ 0 := by linarith + fun_prop (disch:=assumption) +- . ++ · + + intro x hx + simp at hx +@@ -154,30 +154,27 @@ lemma f_pos_on (a: ℝ) (ha: 0 < 1 + a) (a_pos: 0 < a) (a_lt: a < 1) (a_lt_log: + rw [Set.mem_image] at deriv_zero + obtain ⟨y, y_mem, y_deriv⟩ := deriv_zero + have y_nonzero := deriv_nonzero y y_mem +- . contradiction +- . apply Continuous.continuousOn ++ · contradiction ++ · apply Continuous.continuousOn + unfold f + have one_plus: ∀ x: ℝ, 1 + a ≠ 0 := by + intro x + linarith + fun_prop (disch:=assumption) +- . simp ++ · simp + refine ⟨by linarith, hx.right⟩ +- . simp ++ · simp + exact one_lt + + have not_zero := deriv_nonzero x ?_ +- . exact lt_of_le_of_ne deriv_pos (id (Ne.symm not_zero)) +- . simp ++ · exact lt_of_le_of_ne deriv_pos (id (Ne.symm not_zero)) ++ · simp + refine ⟨by linarith, hx.right⟩ + +-#print axioms f_pos_on + + + lemma H_n_single_pow_lower_bound {n : ℕ} {m : ℕ} (m_gt: 1 ≤ m) (data : HnData) (m_lt: m < (1/2) / ‖(theorem_3_8_h_n data n).g.val.val - 1‖) : ‖((theorem_3_8_h_n data n).g.val.val^m) - 1‖ ≥ ‖((theorem_3_8_h_n data n).g.val).val - 1‖ := by + +- push_cast +- -- TODO: figure out how to get 'SubgroupClass.coe_zpow' to fire for Matrix.unitaryGroup + + conv => + lhs +@@ -227,15 +224,15 @@ lemma H_n_single_pow_lower_bound {n : ℕ} {m : ℕ} (m_gt: 1 ≤ m) (data : HnD + grw [norm_sum_le] + + grw [Finset.sum_le_sum (g := fun i => ‖((theorem_3_8_h_n data n).g.val.val - 1)‖ ^ (i + 1 + 1) * (m.choose (i + 1 + 1)))] +- . ++ · + rw [← my_pow] + + have S_le : (1 + ‖((theorem_3_8_h_n data n).g).val.val - 1‖)^m - ((‖(theorem_3_8_h_n data n).g.val.val - 1‖) * (m : ℝ) + 1) ≤ (m - 1) * ‖(theorem_3_8_h_n data n).g.val.val - 1‖ := by + by_cases m_eq_one: m = 1 +- . ++ · + simp [m_eq_one] + rw [add_comm] +- . ++ · + have my_bound := f_pos_on ‖((theorem_3_8_h_n data n).g.val.val - 1)‖ ?_ ?_ ?_ ?_ m ?_ + simp [f] at my_bound + rw [two_mul] at my_bound +@@ -248,23 +245,23 @@ lemma H_n_single_pow_lower_bound {n : ℕ} {m : ℕ} (m_gt: 1 ≤ m) (data : HnD + grw [my_bound] + simp + ring_nf +- . rfl +- . positivity +- . ++ · rfl ++ · positivity ++ · + have val_ne := (theorem_3_8_h_n data n).g_dist_nonzero + positivity +- . ++ · + have val_le := (theorem_3_8_h_n data n).g_dist + grw [val_le] + grw [H_n_eps_lt] + norm_num +- . ++ · + have val_le := (theorem_3_8_h_n data n).g_dist + grw [val_le] + grw [H_n_eps_lt] + norm_num + linarith [Real.log_two_gt_d9] +- . simp ++ · simp + refine ⟨by omega, ?_⟩ + grw [← ge_iff_le] + grw [Real.log_two_gt_d9.gt] +@@ -272,11 +269,11 @@ lemma H_n_single_pow_lower_bound {n : ℕ} {m : ℕ} (m_gt: 1 ≤ m) (data : HnD + grw [m_lt] + simp + apply div_le_div₀ +- . norm_num +- . norm_num +- . have ne_zero := (theorem_3_8_h_n data n).g_dist_nonzero ++ · norm_num ++ · norm_num ++ · have ne_zero := (theorem_3_8_h_n data n).g_dist_nonzero + positivity +- . rfl ++ · rfl + + + rw [add_comm] +@@ -300,29 +297,25 @@ lemma H_n_single_pow_lower_bound {n : ℕ} {m : ℕ} (m_gt: 1 ≤ m) (data : HnD + ring_nf + rfl + +- . intro i hi ++ · intro i hi + grw [norm_mul_le] + grw [norm_pow_le] + nth_rw 2 [Matrix.l2_opNorm_def] + grw [ContinuousLinearMap.opNorm_le_bound (M := m.choose (i + 1 + 1))] +- . simp +- . ++ · simp ++ · + intro x + simp +- rw [Matrix.toEuclideanLin_apply] ++ rw [Matrix.toLpLin_apply] + simp + rw [norm_smul] + simp + +- --apply_fun Norm.norm at my_pow + +-#synth DivisionMonoid (Matrix.unitaryGroup (Fin 2) ℂ) + + +-#synth DivInvMonoid (Matrix (Fin 2) (Fin 2) ℂ) + + +--- TODO: upstream to mathlib + omit h_n_eps_data in + lemma list_ofFn_drop {M: Type*} (a k: ℕ) (f: Fin (k + a) → M): (List.ofFn f).drop a = List.ofFn (fun (i: Fin k) => f ⟨a + i, by omega⟩) := by + induction a with +diff --git a/Gromov/Unitary/Packing.lean b/Gromov/Unitary/Packing.lean +index 2b64abe..1f804fe 100644 +--- a/Gromov/Unitary/Packing.lean ++++ b/Gromov/Unitary/Packing.lean +@@ -14,16 +14,100 @@ public section + + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset + open scoped commutatorElement IsMulCommutative + + +-set_option synthInstance.maxHeartbeats 100000 in +-set_option maxHeartbeats 500000 in ++private lemma unitary_separated_maximal (n : ℕ) ++ (A : Set (Matrix.unitaryGroup (Fin n) ℂ)) (ε : ℝ) : ++ ∃ I, Maximal (fun I => I ⊆ A ∧ ++ ∀ x ∈ I, ∀ y ∈ I, x ≠ y → ‖x.val - y.val‖ ≥ ε) I := by ++ let I_sets := { I | I ⊆ A ∧ ++ ∀ x ∈ I, ∀ y ∈ I, x ≠ y → ‖x.val - y.val‖ ≥ ε } ++ apply zorn_subset I_sets ++ intro S S_subset S_chain ++ refine ⟨S.sUnion, ?_, ?_⟩ ++ · simp only [ne_eq, ge_iff_le, Set.mem_ofPred_eq, ++ Set.sUnion_subset_iff, Set.mem_sUnion, forall_exists_index, and_imp, I_sets] ++ ++ refine ⟨?_, ?_⟩ ++ · intro s hs ++ simp [I_sets] at S_subset ++ specialize S_subset hs ++ simp at S_subset ++ exact S_subset.1 ++ · simp [I_sets] at S_subset ++ intro a M M_mem_S a_mem_M b N N_mem_S b_mem_N a_neq_b ++ simp [IsChain] at S_chain ++ specialize S_chain M_mem_S N_mem_S ++ by_cases M_eq_N : M = N ++ · rw [M_eq_N] at a_mem_M ++ specialize S_subset N_mem_S ++ simp at S_subset ++ exact S_subset.2 a (by simp) (by simp [a_mem_M]) b (by simp) (by simp [b_mem_N]) (by simp [a_neq_b]) ++ · specialize S_chain M_eq_N ++ match S_chain with ++ | .inl h => ++ have a_mem_N := h a_mem_M ++ specialize S_subset N_mem_S ++ simp at S_subset ++ exact S_subset.2 a (by simp) (by simp [a_mem_N]) b (by simp) (by simp [b_mem_N]) (by simp [a_neq_b]) ++ | .inr h => ++ have b_mem_M := h b_mem_N ++ specialize S_subset M_mem_S ++ simp at S_subset ++ exact S_subset.2 a (by simp) (by simp [a_mem_M]) b (by simp) (by simp [b_mem_M]) (by simp [a_neq_b]) ++ ++ ++ · intro s hs ++ exact Set.subset_sUnion_of_subset S s (fun ⦃a⦄ a ↦ a) hs ++ ++private lemma unitary_cosets_cover (n : ℕ) (ε : ℝ) ++ (G : Subgroup (Matrix.unitaryGroup (Fin n) ℂ)) ++ (I : Set (Matrix.unitaryGroup (Fin n) ℂ)) [Fintype I] ++ (i_mem_G : ∀ i ∈ I, i ∈ G) ++ (balls_cover : G.carrier ⊆ ⋃ g ∈ I, Metric.ball g ε) ++ (inter_subset : ∀ g, g ∈ G.carrier → ++ Metric.ball g ε ∩ G.carrier ⊆ ++ (fun x => g * x.val) '' (G' n ε G).carrier) : ++ (⋃ i ∈ I.toFinset.attach, (((⟨i.val, i_mem_G i.val (Set.mem_toFinset.mp i.property)⟩ : G) • (((G' n ε G)) : Set G)) : (Set G))) = (Set.univ : Set G) := by ++ have balls_inter_cover : G.carrier ⊆ ⋃ g ∈ I, ((Metric.ball g ε) ∩ G.carrier) := by ++ intro g hg ++ specialize balls_cover hg ++ simp only [Set.mem_iUnion] at balls_cover ++ obtain ⟨i, i_mem, g_mem_i⟩ := balls_cover ++ simp only [Set.mem_iUnion] ++ use i ++ use i_mem ++ exact Set.mem_inter g_mem_i hg ++ ++ ++ simp ++ ext a ++ simp only [Set.mem_univ, iff_true] ++ have a_mem_g : a.val ∈ G.carrier := by simp ++ specialize balls_inter_cover a_mem_g ++ simp only [Set.mem_iUnion] at balls_inter_cover ++ obtain ⟨i, i_mem, a_mem_i⟩ := balls_inter_cover ++ have hiG : i ∈ G.carrier := i_mem_G i i_mem ++ specialize inter_subset i hiG ++ have a_mem := inter_subset a_mem_i ++ simp only [Set.mem_image] at a_mem ++ obtain ⟨x, hx, a_eq_mul⟩ := a_mem ++ simp only [Set.mem_iUnion] ++ have i_mem_finset : i ∈ I.toFinset := by ++ exact Set.mem_toFinset.mpr i_mem ++ use ⟨i, i_mem_finset⟩ ++ simp ++ rw [Set.mem_smul_set] ++ use x ++ refine ⟨?_, ?_⟩ ++ · exact hx ++ · rw [Subtype.ext_iff] ++ simp [a_eq_mul] ++ + open Pointwise in + lemma volume_packing (n : ℕ) (hn : 0 < n) (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, ∀ (G : Subgroup (Matrix.unitaryGroup (Fin n) ℂ)), (G' n ε G).FiniteIndex ∧ (G' n ε G).index ≤ C := by +@@ -43,13 +127,13 @@ lemma volume_packing (n : ℕ) (hn : 0 < n) (ε : ℝ) (hε : 0 < ε) : + let measure_haar : MeasureTheory.MeasureSpace (Matrix.unitaryGroup (Fin n) ℂ) := { + volume := MeasureTheory.Measure.haarMeasure compacts_univ + } +- haveI hinv : (MeasureTheory.volume : MeasureTheory.Measure ↥(Matrix.unitaryGroup (Fin n) ℂ)).IsMulLeftInvariant := by ++ have hinv : (MeasureTheory.volume : MeasureTheory.Measure ↥(Matrix.unitaryGroup (Fin n) ℂ)).IsMulLeftInvariant := by + show (MeasureTheory.Measure.haarMeasure compacts_univ).IsMulLeftInvariant + infer_instance +- haveI hfin : MeasureTheory.IsFiniteMeasure (MeasureTheory.volume : MeasureTheory.Measure ↥(Matrix.unitaryGroup (Fin n) ℂ)) := by ++ have hfin : MeasureTheory.IsFiniteMeasure (MeasureTheory.volume : MeasureTheory.Measure ↥(Matrix.unitaryGroup (Fin n) ℂ)) := by + show MeasureTheory.IsFiniteMeasure (MeasureTheory.Measure.haarMeasure compacts_univ) + infer_instance +- haveI hopen : (MeasureTheory.volume : MeasureTheory.Measure ↥(Matrix.unitaryGroup (Fin n) ℂ)).IsOpenPosMeasure := by ++ have hopen : (MeasureTheory.volume : MeasureTheory.Measure ↥(Matrix.unitaryGroup (Fin n) ℂ)).IsOpenPosMeasure := by + show (MeasureTheory.Measure.haarMeasure compacts_univ).IsOpenPosMeasure + infer_instance + +@@ -58,7 +142,7 @@ lemma volume_packing (n : ℕ) (hn : 0 < n) (ε : ℝ) (hε : 0 < ε) : + intro G + -- We can find a maximal subset I where ||a - b|| ≥ ε for distinct a, b in I + let I_sets := { S | S ⊆ G.carrier ∧ ∀ x ∈ S, ∀ y ∈ S, x ≠ y → ‖x.val - y.val‖ ≥ ε } +- have maximal_I := zorn_subset I_sets ?_ ++ have maximal_I := unitary_separated_maximal n G.carrier ε + · obtain ⟨I, hI⟩ := maximal_I + have balls_cover : G.carrier ⊆ ⋃ (g ∈ I), Metric.ball g ε := by + intro a ha +@@ -66,9 +150,8 @@ lemma volume_packing (n : ℕ) (hn : 0 < n) (ε : ℝ) (hε : 0 < ε) : + · have a_mem_I : a ∈ I := by + have enlarge_I : {a} ∪ I ∈ I_sets := by + simp [-Subtype.forall, I_sets] +- simp [Maximal] at hI ++ simp only [Maximal] at hI + have I_prop := hI.1 +- simp [-Subtype.forall, I_sets] at I_prop + refine ⟨?_, ?_⟩ + · apply Set.insert_subset ha I_prop.1 + · refine ⟨?_, ?_⟩ +@@ -105,9 +188,8 @@ lemma volume_packing (n : ℕ) (hn : 0 < n) (ε : ℝ) (hε : 0 < ε) : + -- Note - Vikman uses ε/2, but using ε/4 made things easier (it might actually be false for ε/2) + have disjoint_balls : I.PairwiseDisjoint (fun g => Metric.ball g ((ε/2)/2)) := by + intro a a_mem b b_mem a_neq_b +- simp [Maximal] at hI ++ simp only [Maximal] at hI + have I_prop := hI.1 +- simp [-Subtype.forall, I_sets] at I_prop + have dist_ge := I_prop.2 a a_mem b b_mem a_neq_b + simp [Disjoint] + intro X X_subset_A X_subset_B +@@ -228,58 +310,18 @@ lemma volume_packing (n : ℕ) (hn : 0 < n) (ε : ℝ) (hε : 0 < ε) : + + have i_mem_G : ∀ i ∈ I, i ∈ G := by + intro i i_mem +- simp [Maximal] at hI ++ simp only [Maximal] at hI + have I_prop := hI.1 +- simp [-Subtype.forall, I_sets] at I_prop + apply (I_prop.1 i_mem) + + +- have cosets_cover : (⋃ i ∈ I.toFinset.attach, (((⟨i.val, i_mem_G i.val (Set.mem_toFinset.mp i.property)⟩ : G) • (((G' n ε G)) : Set G)) : (Set G))) = (Set.univ : Set G) := by +- have balls_inter_cover : G.carrier ⊆ ⋃ g ∈ I, ((Metric.ball g ε) ∩ G.carrier) := by +- intro g hg +- specialize balls_cover hg +- simp only [Set.mem_iUnion] at balls_cover +- obtain ⟨i, i_mem, g_mem_i⟩ := balls_cover +- simp only [Set.mem_iUnion] +- use i +- use i_mem +- exact Set.mem_inter g_mem_i hg +- +- +- simp +- ext a +- simp only [Set.mem_univ, iff_true] +- have a_mem_g : a.val ∈ G.carrier := by simp +- specialize balls_inter_cover a_mem_g +- simp only [Set.mem_iUnion] at balls_inter_cover +- obtain ⟨i, i_mem, a_mem_i⟩ := balls_inter_cover +- have i_mem_G : i ∈ G.carrier := by +- simp [Maximal] at hI +- have I_prop := hI.1 +- simp [-Subtype.forall, I_sets] at I_prop +- apply (I_prop.1 i_mem) +- specialize inter_subset i i_mem_G +- have a_mem := inter_subset a_mem_i +- simp only [Set.mem_image] at a_mem +- obtain ⟨x, hx, a_eq_mul⟩ := a_mem +- simp only [Set.mem_iUnion] +- have i_mem_finset : i ∈ I.toFinset := by +- exact Set.mem_toFinset.mpr i_mem +- use ⟨i, i_mem_finset⟩ +- simp +- rw [Set.mem_smul_set] +- use x +- refine ⟨?_, ?_⟩ +- · exact hx +- · rw [Subtype.ext_iff] +- simp [a_eq_mul] ++ have cosets_cover := unitary_cosets_cover n ε G I i_mem_G balls_cover inter_subset + + refine ⟨?_, ?_⟩ + · apply Subgroup.finiteIndex_of_leftCoset_cover_const cosets_cover + · have I_subset_G : I ⊆ G := by +- simp [Maximal] at hI ++ simp only [Maximal] at hI + have i_mem := hI.1 +- simp [I_sets] at i_mem + exact i_mem.1 + + +@@ -306,44 +348,7 @@ lemma volume_packing (n : ℕ) (hn : 0 < n) (ε : ℝ) (hε : 0 < ε) : + MeasureTheory.measure_lt_top _ _⟩ + · exact cosets_cover + +- · intro S S_subset S_chain +- refine ⟨S.sUnion, ?_, ?_⟩ +- · simp only [ne_eq, ge_iff_le, Set.mem_setOf_eq, +- Set.sUnion_subset_iff, Set.mem_sUnion, forall_exists_index, and_imp, I_sets] +- +- refine ⟨?_, ?_⟩ +- · intro s hs +- simp [I_sets] at S_subset +- specialize S_subset hs +- simp at S_subset +- exact S_subset.1 +- · simp [I_sets] at S_subset +- intro a M M_mem_S a_mem_M b N N_mem_S b_mem_N a_neq_b +- simp [IsChain] at S_chain +- specialize S_chain M_mem_S N_mem_S +- by_cases M_eq_N : M = N +- · rw [M_eq_N] at a_mem_M +- specialize S_subset N_mem_S +- simp at S_subset +- exact S_subset.2 a (by simp) (by simp [a_mem_M]) b (by simp) (by simp [b_mem_N]) (by simp [a_neq_b]) +- · specialize S_chain M_eq_N +- match S_chain with +- | .inl h => +- have a_mem_N := h a_mem_M +- specialize S_subset N_mem_S +- simp at S_subset +- exact S_subset.2 a (by simp) (by simp [a_mem_N]) b (by simp) (by simp [b_mem_N]) (by simp [a_neq_b]) +- | .inr h => +- have b_mem_M := h b_mem_N +- specialize S_subset M_mem_S +- simp at S_subset +- exact S_subset.2 a (by simp) (by simp [a_mem_M]) b (by simp) (by simp [b_mem_M]) (by simp [a_neq_b]) +- +- +- · intro s hs +- exact Set.subset_sUnion_of_subset S s (fun ⦃a⦄ a ↦ a) hs + +-#print axioms volume_packing + + + @[expose] +@@ -352,7 +357,6 @@ def FreshInnerProduct (V : Type*) := V + instance (V : Type*) [base_comm : AddCommGroup V]: AddCommGroup (FreshInnerProduct V) := base_comm + instance (V : Type*) [AddCommGroup V] [base_module : Module ℂ V]: Module ℂ (FreshInnerProduct V) := base_module + +-#synth InnerProductSpace ℂ (EuclideanSpace ℂ (Fin 2)) + + + attribute [-simp] MeasureTheory.Measure.inv_eq_self +diff --git a/Gromov/Unitary/WeylTrick.lean b/Gromov/Unitary/WeylTrick.lean +index 8a2c528..7b5c66a 100644 +--- a/Gromov/Unitary/WeylTrick.lean ++++ b/Gromov/Unitary/WeylTrick.lean +@@ -13,8 +13,6 @@ public section + + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset +@@ -23,8 +21,36 @@ open scoped commutatorElement IsMulCommutative + + attribute [local implicit_reducible] FreshInnerProduct + +-set_option maxHeartbeats 800000 in +-set_option synthInstance.maxHeartbeats 500000 in ++private lemma unitary_of_faithful_inner_representation ++ {K W : Type*} [Group K] [NormedAddCommGroup W] ++ [InnerProductSpace ℂ W] [FiniteDimensional ℂ W] ++ (ρ : K →* Module.End ℂ W) (hρ : Function.Injective ρ) ++ (hinner : ∀ g x y, ⟪ρ g x, ρ g y⟫ = ⟪x, y⟫) : ++ ∃ S : Subgroup (Matrix.unitaryGroup (Fin (Module.finrank ℂ W)) ℂ), ++ Nonempty (S ≃* K) := by ++ let b := stdOrthonormalBasis ℂ W ++ have hu (g : K) : LinearMap.toMatrix b.toBasis b.toBasis (ρ g) ∈ ++ Matrix.unitaryGroup (Fin (Module.finrank ℂ W)) ℂ := by ++ let i : W →ₗᵢ[ℂ] W := { ++ toLinearMap := ρ g ++ norm_map' := (LinearMap.norm_map_iff_inner_map_map (ρ g)).mpr (hinner g) } ++ let e := LinearIsometryEquiv.ofSurjective i ++ ((LinearMap.injective_iff_surjective).mp i.injective) ++ exact e.toMatrix_mem_unitaryGroup b b ++ let f : K →* Matrix.unitaryGroup (Fin (Module.finrank ℂ W)) ℂ := { ++ toFun := fun g => ⟨LinearMap.toMatrix b.toBasis b.toBasis (ρ g), hu g⟩ ++ map_one' := by apply Subtype.ext; simp ++ map_mul' := by ++ intro g h ++ apply Subtype.ext ++ simp [LinearMap.toMatrix_mul] } ++ have hf : Function.Injective f := by ++ intro g h heq ++ apply hρ ++ apply (LinearMap.toMatrix b.toBasis b.toBasis).injective ++ exact congrArg Subtype.val heq ++ exact ⟨f.range, ⟨(MonoidHom.ofInjective hf).symm⟩⟩ ++ + lemma new_weyl_unitarian_trick {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V] (H : Subgroup (V →L[ℂ] V)ˣ) [LocallyCompactSpace H] [CompactSpace H]: ∃ S : Subgroup ↥(Matrix.unitaryGroup (Fin (Module.finrank ℂ V)) ℂ), Nonempty (S ≃* H) := by + let integrand := fun (v w : FreshInnerProduct V) (h : H) => ⟪(h.val.val v), (h.val.val w)⟫ + have continuous_integrand : ∀ v w : FreshInnerProduct V, Continuous fun h : H => integrand v w h := by +@@ -133,7 +159,7 @@ lemma new_weyl_unitarian_trick {V : Type*} [NormedAddCommGroup V] [InnerProductS + simp at inner_q_zero + have map_iff_zero := LinearMap.map_eq_zero_iff (f := q.val.val.toLinearMap) (x := x) ?_ + · exact map_iff_zero.mp inner_q_zero +- · -- TODO - find a better way of doing this ++ · + let my_map := (ContinuousLinearMap.toLinearMapRingHom (R₁ := ℂ) (M₁ := V)).toMonoidHom + let f_map := (Units.map my_map) q.val + let f_as_equiv := fun f => (LinearMap.GeneralLinearGroup.toLinearEquiv (R := ℂ) (M := V) f) +@@ -143,13 +169,12 @@ lemma new_weyl_unitarian_trick {V : Type*} [NormedAddCommGroup V] [InnerProductS + exact injective_f + · have foo := integrable_on x x + simp [integrand] at foo +- norm_cast + norm_cast at foo + apply MeasureTheory.Integrable.re at foo + norm_cast at foo + · rw [Pi.le_def] + intro y +- simpa using inner_self_nonneg (𝕜 := ℂ) (x := (y.val.val x)) ++ simp + } + · exact Ne.symm (NeZero.ne' (MeasureTheory.Measure.haar.inv Set.univ)) + +@@ -173,190 +198,21 @@ lemma new_weyl_unitarian_trick {V : Type*} [NormedAddCommGroup V] [InnerProductS + rfl + rw [hpt] + exact MeasureTheory.integral_mul_right_eq_self (integrand v w) h +- · -- finDimVectorspaceEquiv +- have rank_eq := Module.finrank_eq_rank' ℂ (FreshInnerProduct V) +- have V_equiv := (finDimVectorspaceEquiv (Module.finrank ℂ (FreshInnerProduct V)) rank_eq.symm).toContinuousLinearEquiv +- let V_equiv_fresh : V ≃L[ℂ] (FreshInnerProduct V) := ContinuousLinearEquiv.ofFinrankEq ?_ +- let V_fresh_arrow := ContinuousLinearEquiv.arrowCongr V_equiv_fresh V_equiv_fresh +- +- let new_H_matrix := ContinuousLinearMap.toLinearMap '' (Units.val '' H.carrier) +- -- Deliberate defeq abuse, so that things line up with our integral (which is over plain V) +- let new_H_coe : Set ((FreshInnerProduct V) →ₗ[ℂ] (FreshInnerProduct V)) := new_H_matrix +- +- +- +- have V_basis := stdOrthonormalBasis ℂ (FreshInnerProduct V) +- +- let H_matrix := (LinearMap.toMatrix V_basis.toBasis V_basis.toBasis) '' new_H_coe +- +- +- have H_mem_unitary : ∀ h ∈ H_matrix, h ∈ Matrix.unitaryGroup (Fin (Module.finrank ℂ (FreshInnerProduct V))) ℂ := by +- intro h h_mem +- simp [H_matrix, new_H_coe, new_H_matrix] at h_mem +- obtain ⟨u, u_mem, hu⟩ := h_mem +- let a : FreshInnerProduct V →ₗ[ℂ] FreshInnerProduct V := (↑↑u : V →ₗ[ℂ] V) +- have ha : (LinearMap.toMatrix V_basis.toBasis V_basis.toBasis) a = h := hu +- rw [← ha, Matrix.mem_unitaryGroup_iff'] +- -- `a` is the linear map underlying an element of `H`, so it preserves the new inner product. +- have preserves_inner : ∀ (x y : FreshInnerProduct V), ⟪a x, a y⟫ = ⟪x, y⟫ := by +- intro x y +- exact v_preserves_inner ⟨u, u_mem⟩ x y +- -- Preservation of the inner product means `adjoint a ∘ a = id`. +- have adj : a.adjoint ∘ₗ a = LinearMap.id := by +- apply LinearMap.ext +- intro x +- rw [LinearMap.comp_apply, LinearMap.id_apply] +- apply ext_inner_right ℂ +- intro y +- rw [LinearMap.adjoint_inner_left] +- exact preserves_inner x y +- have hmat : star (LinearMap.toMatrix V_basis.toBasis V_basis.toBasis a) * +- (LinearMap.toMatrix V_basis.toBasis V_basis.toBasis a) = 1 := by +- rw [Matrix.star_eq_conjTranspose, ← LinearMap.toMatrix_adjoint, ← LinearMap.toMatrix_comp, +- adj, LinearMap.toMatrix_id] +- exact hmat +- +- +- let H_matrix_subgroup : Subgroup (Matrix.unitaryGroup (Fin (Module.finrank ℂ V)) ℂ) := { +- carrier := Set.range (fun (h : H_matrix) => ⟨h.val, H_mem_unitary h (by simp)⟩), +- mul_mem' := by +- intro X Y hx hy +- simp +- use (X * Y).val +- simp +- simp at hx +- simp at hy +- simp [H_matrix] +- simp [H_matrix] at hx +- simp [H_matrix] at hy +- obtain ⟨a, ⟨p, p_mem, p_eq_a⟩, a_eq_x⟩ := hx +- obtain ⟨b, ⟨q, q_mem, q_eq_b⟩, b_eq_y⟩ := hy +- simp [new_H_coe, new_H_matrix] at q_mem +- simp [new_H_coe, new_H_matrix] at p_mem +- obtain ⟨y, y_mem, y_eq_q⟩ := q_mem +- obtain ⟨x, x_mem, x_eq_p⟩ := p_mem +- simp [new_H_coe, new_H_matrix] +- refine ⟨?_, rfl⟩ +- have hX : X.val = a := by rw [← a_eq_x] +- have hY : Y.val = b := by rw [← b_eq_y] +- refine ⟨x * y, H.mul_mem x_mem y_mem, ?_⟩ +- rw [hX, hY, ← p_eq_a, ← q_eq_b, ← LinearMap.toMatrix_mul, ← x_eq_p, ← y_eq_q] +- rfl +- one_mem' := by +- simp [H_matrix, new_H_coe, new_H_matrix] +- refine ⟨1, H.one_mem, ?_⟩ +- exact LinearMap.toMatrix_one _ +- inv_mem' := by +- simp +- intro a ha b hb a_eq_b +- refine ⟨a⁻¹, ?_, ?_⟩ +- · simp [H_matrix, new_H_coe, new_H_matrix] at ⊢ hb +- obtain ⟨u, u_mem, hz₀⟩ := hb +- refine ⟨u⁻¹, H.inv_mem u_mem, ?_⟩ +- rw [← a_eq_b, ← hz₀] +- refine (Matrix.inv_eq_left_inv ?_).symm +- rw [← LinearMap.toMatrix_mul] +- convert LinearMap.toMatrix_one (R := ℂ) V_basis.toBasis using 2 +- ext v +- change (↑(u⁻¹) : V →L[ℂ] V) ((↑u : V →L[ℂ] V) v) = v +- rw [← mul_apply_eq_comp, ← Units.val_mul, inv_mul_cancel, Units.val_one, +- one_apply_eq_self] +- · rw [Matrix.mem_unitaryGroup_iff] at ha +- apply Matrix.inv_eq_right_inv at ha +- rw [Subtype.ext_iff] +- show a⁻¹ = star a +- exact ha +- } +- +- let remove_fresh (h : FreshInnerProduct V →ₗ[ℂ] FreshInnerProduct V): (V →ₗ[ℂ] V) := h +- +- · use H_matrix_subgroup +- apply Nonempty.intro +- exact { +- toFun := fun h => ⟨{ +- val := ((remove_fresh (h.val.val.toLin V_basis.toBasis V_basis.toBasis)).toContinuousLinearMap), +- inv := ((remove_fresh (h.val.val⁻¹.toLin V_basis.toBasis V_basis.toBasis)).toContinuousLinearMap), +- val_inv := by +- simp [remove_fresh] +- ext a +- simp +- conv => +- lhs +- equals Matrix.toLin V_basis.toBasis V_basis.toBasis (h.val.val * h.val.val⁻¹) a => +- rw [eq_comm] +- exact Matrix.toLin_mul_apply (v₁ := V_basis.toBasis) (v₂ := V_basis.toBasis) (v₃ := V_basis.toBasis) _ _ _ +- rw [Matrix.mul_nonsing_inv] +- · exact LinearMap.congr_fun (Matrix.toLin_one (v₁ := V_basis.toBasis)) a +- · apply Matrix.UnitaryGroup.det_isUnit +- inv_val := by +- simp [remove_fresh] +- ext a +- simp +- conv => +- lhs +- equals Matrix.toLin V_basis.toBasis V_basis.toBasis (h.val.val⁻¹ * h.val.val) a => +- rw [eq_comm] +- exact Matrix.toLin_mul_apply (v₁ := V_basis.toBasis) (v₂ := V_basis.toBasis) (v₃ := V_basis.toBasis) _ _ _ +- rw [Matrix.nonsing_inv_mul] +- · exact LinearMap.congr_fun (Matrix.toLin_one (v₁ := V_basis.toBasis)) a +- · apply Matrix.UnitaryGroup.det_isUnit +- }, by ( +- simp [remove_fresh] +- have h_prop := h.property +- simp only [H_matrix_subgroup] at h_prop +- rw [← Subgroup.mem_carrier] at h_prop +- simp only [] at h_prop +- rw [Set.mem_range] at h_prop +- obtain ⟨a, ha⟩ := h_prop +- have a_prop := a.property +- simp only [H_matrix, new_H_coe, new_H_matrix] at a_prop +- rw [Set.mem_image] at a_prop +- obtain ⟨b, b_mem, b_eq_a⟩ := a_prop +- obtain ⟨c, ⟨d, d_mem, d_eq_c⟩, c_eq_b⟩ := b_mem +- simp_rw [← ha, ← b_eq_a] +- simp +- simp_rw [← c_eq_b, ← d_eq_c] +- conv => +- arg 2 +- arg 1 +- equals d.val => +- rfl +- +- simp +- rw [Subgroup.mem_carrier] at d_mem +- exact d_mem +- )⟩ +- invFun := fun h => ⟨⟨(LinearMap.toMatrix V_basis.toBasis V_basis.toBasis) h.val.val.toLinearMap, by ( +- apply H_mem_unitary +- exact ⟨h.val.val.toLinearMap, ⟨h.val.val, ⟨h.val, h.property, rfl⟩, rfl⟩, rfl⟩ +- )⟩, by ( +- refine ⟨⟨_, ⟨h.val.val.toLinearMap, ⟨h.val.val, ⟨h.val, h.property, rfl⟩, rfl⟩, rfl⟩⟩, rfl⟩ +- )⟩, +- left_inv := by +- intro h +- simp +- rw [Subtype.ext_iff] +- simp [remove_fresh] +- right_inv := by +- intro h +- simp +- simp [remove_fresh] +- ext a +- simp +- map_mul' := by +- intro x y +- simp [remove_fresh] +- ext a +- simp +- exact Matrix.toLin_mul_apply (v₁ := V_basis.toBasis) (v₂ := V_basis.toBasis) +- (v₃ := V_basis.toBasis) _ _ _ +- } +- · rfl ++ let ρ : H →* Module.End ℂ (FreshInnerProduct V) := { ++ toFun := fun h => h.val.val.toLinearMap ++ map_one' := rfl ++ map_mul' := fun _ _ => rfl } ++ have hρ : Function.Injective ρ := by ++ intro g h heq ++ apply Subtype.ext ++ apply Units.ext ++ ext v ++ exact DFunLike.congr_fun heq v ++ exact @unitary_of_faithful_inner_representation H (FreshInnerProduct V) ++ inferInstance normed_add new_inner finite_dimensional_fresh ρ hρ v_preserves_inner + + +-#print axioms new_weyl_unitarian_trick + + -- A product of k unitary groups U(n_1) × U(n_2) × ... × U(n_k), where n_i < n for each n_i + + +-#check Pi.commSemigroup +diff --git a/Gromov/Unitary/Words.lean b/Gromov/Unitary/Words.lean +index a8e8c75..5d00a13 100644 +--- a/Gromov/Unitary/Words.lean ++++ b/Gromov/Unitary/Words.lean +@@ -14,8 +14,6 @@ public section + + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + +-set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset +@@ -26,8 +24,6 @@ namespace HnEpsData + + variable [h_n_eps_data: HnEpsData] + +-set_option synthInstance.maxHeartbeats 80000 in +-set_option maxHeartbeats 900000 in + lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < 1 / 40) + (data : HnData) + (pows_i : Fin m → ℕ) +@@ -43,7 +39,6 @@ lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < + + nth_rw 2 [← List.prod_take_mul_prod_drop (i := k)] at this + rw [← List.prod_take_mul_prod_drop (i := k)] at this +- -- TODO - generalize this and PR to mathlib + conv at this => + lhs + lhs +@@ -55,11 +50,11 @@ lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < + rw [List.getElem?_take] + simp + by_cases i_lt_k: i < k +- . ++ · + simp [i_lt_k] + have i_lt_m: i < m := by omega + simp [i_lt_m] +- . simp [i_lt_k] ++ · simp [i_lt_k] + + conv at this => + rhs +@@ -72,11 +67,11 @@ lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < + rw [List.getElem?_take] + simp + by_cases i_lt_k: i < k +- . ++ · + simp [i_lt_k] + have i_lt_m: i < m := by omega + simp [i_lt_m] +- . simp [i_lt_k] ++ · simp [i_lt_k] + + + conv at this => +@@ -156,7 +151,6 @@ lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < + rw [SubmonoidClass.coe_pow] + grw [H_n_single_pow_lower_bound] + +- -- TODO : figure out why we can't use 'simp_rw' here + conv => + lhs + rhs +@@ -191,17 +185,17 @@ lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < + group + + grw [H_n_prod_le_k (c := c)] +- . linarith +- . ++ · linarith ++ · + rw [add_assoc] + rw [m_minus_k] + simp +- . exact c_pos +- . exact c_lt +- . exact pows_i_le +- . ++ · exact c_pos ++ · exact c_lt ++ · exact pows_i_le ++ · + linarith +- . ++ · + conv => + lhs + equals (-((pows_j k) : ℝ) + ((pows_i k) : ℝ)) => +@@ -221,34 +215,34 @@ lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < + simp + grw [c_lt] + apply mul_le_mul +- . norm_num +- . ++ · norm_num ++ · + rw [inv_le_inv₀] +- . ++ · + have my_prop := (theorem_3_8_h_n data k).g_dist + exact my_prop +- . apply H_n_eps_pos +- . have my_prop := (theorem_3_8_h_n data k).g_dist_nonzero ++ · apply H_n_eps_pos ++ · have my_prop := (theorem_3_8_h_n data k).g_dist_nonzero + positivity +- . simp ++ · simp + exact (H_n_eps_pos data.hd).le +- . norm_num +- . simp ++ · norm_num ++ · simp + have foo := H_n_eps_pos data.hd + linarith +- . simp [-SubmonoidClass.coe_list_prod] ++ · simp [-SubmonoidClass.coe_list_prod] + + + rw [ge_iff_le] at lhs_ge + + have one_tenth_lt: 1 / 10 * ‖(theorem_3_8_h_n data ↑k).g.val.val - 1‖ < (9 / 10) * ‖(theorem_3_8_h_n data ↑k).g.val.val - 1‖ := by + apply mul_lt_mul +- . norm_num +- . simp +- . ++ · norm_num ++ · simp ++ · + have ne_zero := (theorem_3_8_h_n data ↑k).g_dist_nonzero + positivity +- . norm_num ++ · norm_num + + + have add_swap (a b : ℕ): 1 + a + b = 1 + b + a := by +@@ -281,7 +275,6 @@ lemma words_distinct {m : ℕ} (k: Fin m) (c : ℝ) (c_pos : 0 < c) (c_lt : c < + simp at one_tenth_lt + + +-#print axioms words_distinct + + -- ContinuousLinearMap.norm_id + +@@ -327,13 +320,13 @@ lemma H_n_pows_mem_ball_G {m : ℕ} + simp [nested_list, replicate_pow] + simp [Fin.sum_ofFn] + grw [Finset.sum_le_card_nsmul (n := ⌊ (c * (H_n_eps data.hd)⁻¹)⌋₊)] +- . simp +- . intro x _ ++ · simp ++ · intro x _ + apply pows_le + + + use (fun i => full_list (i.cast (by omega))) +- . ++ · + + + conv => +@@ -360,11 +353,10 @@ lemma H_n_pows_mem_ball_G {m : ℕ} + + dsimp [nested_list, replicate_pow] + rw [List.prod_append] +- . simp [-List.prod_flatten] +- . omega ++ · simp [-List.prod_flatten] ++ · omega + + +-#print axioms H_n_pows_mem_ball_G + + -- Unfold the commutators from theorem_3_8_h_n as a list of elements + @[expose] +@@ -380,8 +372,6 @@ noncomputable def theorem_3_8_h_n_list (data: HnData) (m: ℕ): List (data.S) := + ++ (List.map (fun s => ⟨s.val⁻¹, by apply data.S_inv; simp⟩) (theorem_3_8_h_n_list data a)).reverse + + +-set_option synthInstance.maxHeartbeats 80000 in +-set_option maxHeartbeats 900000 in + lemma theorem_3_8_h_n_list_prod_eq (data: HnData) (m: ℕ): (theorem_3_8_h_n_list data m).unattach.prod = (theorem_3_8_h_n data m).g := by + induction m with + | zero => +@@ -409,7 +399,6 @@ lemma theorem_3_8_h_n_list_prod_eq (data: HnData) (m: ℕ): (theorem_3_8_h_n_lis + group + + -- Note - this is (2^(m - 1)) in Vikman, since the list in indexed starting at 1 in the paper +-set_option synthInstance.maxHeartbeats 1000000 in + lemma theorem_3_8_h_n_list_length_initial_upper_bound (data: HnData) (m: ℕ): (theorem_3_8_h_n_list data (m)).length ≤ (3 * (2 ^ (m))) - 2 := by + induction m with + | zero => +@@ -417,26 +406,25 @@ lemma theorem_3_8_h_n_list_length_initial_upper_bound (data: HnData) (m: ℕ): + simp + | succ a ih => + unfold theorem_3_8_h_n_list +- -- TODO - can grind somehow solve all of this? + simp + grw [ih] +- ring ++ ring_nf + rw [Nat.sub_mul] +- ring ++ ring_nf + zify + rw [Nat.cast_sub] +- . ++ · + push_cast +- ring ++ ring_nf + rw [Nat.cast_sub] +- . push_cast +- ring ++ · push_cast ++ ring_nf + linarith +- . ++ · + by_cases a_eq_zero: a = 0 +- . ++ · + simp [a_eq_zero] +- . ++ · + have a_eq_sub_succ: a = (a - 1) + 1 := by omega + rw [a_eq_sub_succ] + rw [Nat.pow_succ] +@@ -445,18 +433,17 @@ lemma theorem_3_8_h_n_list_length_initial_upper_bound (data: HnData) (m: ℕ): + rw [mul_assoc] + apply Nat.le_mul_of_pos_right + positivity +- . ++ · + rw [← ge_iff_le] + grw [(Nat.one_le_pow _ _ ?_).ge] +- . norm_num +- . norm_num ++ · norm_num ++ · norm_num + + + -- The c' constant from Vikman + @[expose] + def c' := 3 + +--- TODO - figure out how to merge this with 'theorem_3_8_h_n_list_length_initial_upper_bound' + lemma theorem_3_8_h_n_list_length_upper_bound (data: HnData) (m: ℕ): (theorem_3_8_h_n_list data (m)).length ≤ c' * (2 ^ m) := by + grw [theorem_3_8_h_n_list_length_initial_upper_bound data m] + simp [c'] +@@ -468,10 +455,10 @@ lemma list_concat_unattach {T: Type*} {p: T → Prop} (l: List { x: T // p x}) ( + + + lemma H_n_pows_mem_ball_S {m : ℕ} +- (m_gt: 0 < m) (data : HnData) (pows : Fin m → ℕ) ++ (_m_gt: 0 < m) (data : HnData) (pows : Fin m → ℕ) + (c: ℝ) +- (c_pos: 0 < c) +- (c_lt: c < 1 / 40) ++ (_c_pos: 0 < c) ++ (_c_lt: c < 1 / 40) + (pows_le : ∀ i : Fin m, (pows i) ≤ ⌊c * (H_n_eps data.hd)⁻¹⌋₊): + (List.ofFn (fun (i : Fin (m)) => (theorem_3_8_h_n data i).g^(pows i))).prod.val ∈ Subtype.val '' (data.S ^ ( c' * (Nat.floor (c * (H_n_eps data.hd)⁻¹)) * m * (2 ^ m))) := by + +@@ -486,7 +473,7 @@ lemma H_n_pows_mem_ball_S {m : ℕ} + + have g_as_list_prod_eq_pow: g_as_s_list.unattach.prod = (List.ofFn (fun (i: Fin m) => (List.replicate (pows i) (theorem_3_8_h_n_list data i)).flatten.unattach.prod)).unattach.prod := by + dsimp [g_as_s_list] +- clear m_gt ++ clear _m_gt + induction m with + | zero => + simp +@@ -544,27 +531,26 @@ lemma H_n_pows_mem_ball_S {m : ℕ} + rw [List.sum_ofFn] + simp + grw [Finset.sum_le_sum (g := fun i => (pows i) * c' * (2 ^ m))] +- . ++ · + grw [Finset.sum_le_card_nsmul (n := ⌊c * (H_n_eps data.hd)⁻¹⌋₊ * c' * (2^m))] +- . ++ · + simp +- ring ++ ring_nf + rfl +- . ++ · + intro i _ + grw [pows_le] +- . intro i _ ++ · intro i _ + grw [theorem_3_8_h_n_list_length_upper_bound] +- ring ++ ring_nf + grw [i.isLt] +- simp + + + let padded_list := Fin.append (fun (i: Fin (g_as_s_list.length)) => g_as_s_list[i]) (fun (i: Fin (((c' * (Nat.floor (c * (H_n_eps data.hd)⁻¹)) * m * (2 ^ m)) - g_as_s_list.length))) => ⟨1, data.S_one⟩) + + + refine ⟨?_, rfl⟩ +- . ++ · + use (fun i => padded_list (i.cast (by omega))) + conv => + lhs +@@ -573,8 +559,8 @@ lemma H_n_pows_mem_ball_S {m : ℕ} + apply congr (rfl) + ext i g + nth_rw 2 [List.ofFn_congr (n := (c' * ⌊c * (H_n_eps data.hd)⁻¹⌋₊ * m * 2 ^ m))] +- . simp +- . omega ++ · simp ++ · omega + + + rw [List.ofFn_fin_append] +@@ -589,7 +575,6 @@ lemma H_n_pows_mem_ball_S {m : ℕ} + simp + rw [g_list_prod] + +-#print axioms H_n_pows_mem_ball_S + + + -- In Vikman, this is (1 + ⌊c * (H_n_eps data.hd)⁻¹⌋₊) (since the powers include the upper bound of c*ε ⁻¹) +@@ -613,20 +598,19 @@ lemma H_n_ball_S_card {m : ℕ} + + rw [← my_card] + apply Finset.card_le_card_of_injOn (f := fun pows => (List.ofFn (fun (i : Fin (m)) => (theorem_3_8_h_n data (i)).g^((pows i).val))).prod) +- . ++ · + intro pows _ + simp +- -- TODO - modify H_n_pows_mem_ball_S so that this can just be 'apply' + have my_pows := H_n_pows_mem_ball_S m_gt data (fun i => (pows i).val) c c_pos c_lt ?_ +- . ++ · + rw [Set.mem_image] at my_pows + obtain ⟨g, g_mem, g_eq⟩ := my_pows + rw [← Subtype.ext_iff] at g_eq + rw [← g_eq] + exact g_mem +- . intro i ++ · intro i + simp +- . ++ · + intro pows_i _ pows_j _ + contrapose + intro pows_neq +@@ -635,10 +619,9 @@ lemma H_n_ball_S_card {m : ℕ} + + have exists_minimal_k := exists_minimal_of_wellFoundedLT (fun (i: Fin m) => pows_i i ≠ pows_j i) pows_neq + obtain ⟨k, k_minimal⟩ := exists_minimal_k +- -- TODO - figure out why this pushes a goal of 'False' if we don't use 'generalizing' + wlog pow_j_lt_i: (pows_j k).val < (pows_i k).val generalizing pows_i pows_j + +- . ++ · + conv at k_minimal => + arg 1 + intro i +@@ -646,42 +629,41 @@ lemma H_n_ball_S_card {m : ℕ} + + + have words_neq := this (pows_j := pows_i) (pows_i := pows_j) (by simp) (by simp) ?_ k_minimal ?_ +- . ++ · + rw [eq_comm] + exact words_neq +- . ++ · + obtain ⟨x, hx⟩ := pows_neq + use x + exact fun a ↦ hx (id (Eq.symm a)) +- . ++ · + have k_neq := k_minimal.prop + omega +- . ++ · + simp at k_minimal + + have eps_pos := H_n_eps_pos data.hd + + have prods_neq := words_distinct (m := m) k c c_pos c_lt data (fun i => pows_i i) (fun i => pows_j i) ?_ ?_ ?_ ?_ +- . simpa using prods_neq +- . ++ · simpa using prods_neq ++ · + intro i + rw [← Nat.le_floor_iff] + omega + positivity +- . intro i ++ · intro i + rw [← Nat.le_floor_iff] + omega + positivity +- . ++ · + intro j hk + have foo := Minimal.not_prop_of_lt k_minimal hk + simp at foo + exact congrArg Fin.val foo +- . ++ · + simpa using pow_j_lt_i + + +-#print axioms H_n_ball_S_card + + abbrev swap_le {a b: ℝ} (_: a ≤ b): Prop := b < a + +diff --git a/Gromov/UnitaryGromov.lean b/Gromov/UnitaryGromov.lean +index 2becf72..68e5e46 100644 +--- a/Gromov/UnitaryGromov.lean ++++ b/Gromov/UnitaryGromov.lean +@@ -16,15 +16,238 @@ public section + open scoped Matrix.Norms.L2Operator ComplexInnerProductSpace + + set_option linter.style.longLine false +-set_option linter.style.commandStart false + + open Subgroup Pointwise Finset + open scoped Pointwise Finset + open scoped commutatorElement IsMulCommutative + + +-set_option synthInstance.maxHeartbeats 100000 in +-set_option maxHeartbeats 2000000 in ++private noncomputable def image_growth_data ++ {X Y : Type*} [Group X] [DecidableEq X] [Group Y] [DecidableEq Y] ++ {P : Subgroup X} (D : SPolyData P) (f : P →* Y) : SPolyData f.range where ++ S := f.rangeRestrict '' D.S ++ S_one := ⟨1, D.S_one, map_one _⟩ ++ S_inv := by rw [← Set.image_inv, ← D.S_inv] ++ S_finite := D.S_finite.image _ ++ S_generates := by ++ rw [← MonoidHom.map_closure, D.S_generates] ++ exact Subgroup.map_top_of_surjective _ f.rangeRestrict_surjective ++ S_poly_const := D.S_poly_const ++ S_poly_const_pos := D.S_poly_const_pos ++ S_poly_deg := D.S_poly_deg ++ S_poly := by ++ intro r hr ++ rw [Set.Finite.toFinset_image, ← Finset.image_pow] ++ · exact Finset.card_image_le.trans (D.S_poly r hr) ++ · exact D.S_finite ++ ++@[expose] ++def map_S_data {G H: Type*} [Group G] [Group H] [DecidableEq G] [DecidableEq H] (A: Subgroup G) {f: G →* H} (S_data: SPolyData A): SPolyData (Subgroup.map f A) := { ++ S := f.subgroupMap A '' S_data.S ++ S_finite := by ++ apply Set.Finite.image ++ apply S_data.S_finite ++ S_one := by ++ simp only [Set.mem_image] ++ use 1 ++ simp ++ apply S_data.S_one ++ S_inv := by ++ rw [← Set.image_inv] ++ rw [← S_data.S_inv] ++ S_generates := by ++ rw [← MonoidHom.map_closure] ++ rw [S_data.S_generates] ++ rw [Subgroup.map_top_of_surjective] ++ apply MonoidHom.subgroupMap_surjective ++ S_poly_const := S_data.S_poly_const ++ S_poly_const_pos := S_data.S_poly_const_pos ++ S_poly_deg := S_data.S_poly_deg ++ S_poly := by ++ intro r hr ++ rw [Set.Finite.toFinset_image] ++ rw [← Finset.image_pow] ++ grw [Finset.card_image_le] ++ . ++ apply S_data.S_poly r hr ++ . exact S_data.S_finite ++} ++ ++ ++private noncomputable def subgroup_growth_data ++ {X : Type*} [Group X] [DecidableEq X] {P : Subgroup X} ++ (D : SPolyData P) (H : Subgroup P) (S : Finset H) ++ (hS : Subgroup.closure (S : Set H) = ⊤) : SPolyData H := by ++ let T := S ∪ S⁻¹ ∪ {1} ++ have hsym : D.S_finite.toFinset = D.S_finite.toFinset⁻¹ := by ++ ext x ++ simp ++ nth_rw 1 [D.S_inv] ++ simp ++ let growth := poly_growth_equiv D.S_poly_const D.S_poly_deg ++ (Nat.pos_of_ne_zero D.S_poly_const_pos.symm) D.S_finite.toFinset ++ (T.image H.subtype) hsym (by simpa using D.S_one) ++ (by simpa using D.S_generates) D.S_poly ++ let b := growth.choose ++ have hb := growth.choose_spec.1 ++ have hg := growth.choose_spec.2 ++ refine { ++ S := (T : Set H) ++ S_finite := T.finite_toSet ++ S_one := by simp [T] ++ S_inv := by simp [T, Set.union_comm] ++ S_generates := by simp [T, Subgroup.closure_union, hS] ++ S_poly_const := b ++ S_poly_const_pos := by omega ++ S_poly_deg := D.S_poly_deg ++ S_poly := ?_ } ++ intro r hr ++ simpa only [b, Finset.finite_toSet_toFinset, ← Finset.image_pow, ++ Finset.card_image_of_injective _ H.subtype_injective] using hg r hr ++ ++private lemma central_element_virtually_abelian (n : ℕ) (hn : n ≠ 0) ++ (n_eq_one : n ≠ 1) ++ (ih : ∀ m, m < n → m ≠ 0 → ∀ H : Subgroup (Matrix.unitaryGroup (Fin m) ℂ), ++ H.FG → SPolyData H → ∃ N : Subgroup H, IsMulCommutative N ∧ N.FiniteIndex) ++ (G : Subgroup (Matrix.unitaryGroup (Fin n) ℂ)) (G_FG : G.FG) ++ (S_data : SPolyData G) ++ (nontrivial_central : ∃ g : G, (∀ z : ℂ, g.val.val ≠ z • 1) ∧ g ∈ Set.center G) : ++ ∃ N : Subgroup G, IsMulCommutative N ∧ N.FiniteIndex := by ++ obtain ⟨g, g_not_multiple_I, g_central⟩ := nontrivial_central ++ ++ ++ have all_mem_central : ∀ a : G, a ∈ Subgroup.centralizer {g} := by ++ intro a b b_mem ++ simp at b_mem ++ rw [b_mem] ++ rw [Set.mem_center_iff] at g_central ++ have g_comm := g_central.comm a ++ exact g_comm ++ ++ have n_ge_two : 2 ≤ n := by ++ omega ++ ++ have n_ne_zero: NeZero n := by ++ exact { out := hn } ++ obtain ⟨data⟩ := centralizer_iso G g g_not_multiple_I ++ ++ ++ -- The abelian subgroup of G_i. ++ -- TODO - we need to construct a generating set for the smaller subgroup ++ -- TODO - is there existing API for this in mathlib? ++ let g_to_central: G →* (Subgroup.centralizer {g.val}) := { ++ toFun := fun a => ⟨a, by ++ rw [Subgroup.mem_centralizer_iff] ++ simp ++ rw [Set.mem_center_iff] at g_central ++ rw [isMulCentral_iff] at g_central ++ have foo := (g_central.1) a ++ rw [commute_iff_eq] at foo ++ rw [Subtype.ext_iff] at foo ++ simpa using foo ++ ⟩, ++ map_one' := by ++ simp ++ map_mul' := by ++ simp ++ } ++ ++ have ha := data.ha ++ ++ let new_A_map := (Subgroup.subtype _).comp ((MonoidHom.fst _ _).comp (data.iso.toMonoidHom.comp g_to_central)) ++ let new_B_map := (Subgroup.subtype _).comp ((MonoidHom.snd _ _).comp (data.iso.toMonoidHom.comp g_to_central)) ++ ++ let first_new_data := image_growth_data S_data new_A_map ++ ++ have data_b_pos: 0 < data.b := by ++ have hab := data.hb ++ omega ++ ++ -- TODO - deduplicate 'first_new_data' and 'second_new_data' ++ let second_new_data := image_growth_data S_data new_B_map ++ ++ obtain ⟨first_subgroup, first_subgroup_abelian, first_subgroup_finite_index⟩ := ih data.a (by have hab := data.hab; omega) (by grind) (new_A_map.range) (by ++ rw [← Group.fg_iff_subgroup_fg] ++ rw [← Group.fg_iff_subgroup_fg] at G_FG ++ apply Group.fg_range ++ ) (first_new_data) ++ obtain ⟨second_subgroup, second_subgroup_abelian, second_subgroup_finite_index⟩ := ih data.b (by have hab := data.hab; omega) (by grind) (new_B_map.range) (by ++ rw [← Group.fg_iff_subgroup_fg] ++ rw [← Group.fg_iff_subgroup_fg] at G_FG ++ apply Group.fg_range ++ ) (second_new_data) ++ ++ let iso := Subgroup.map data.iso.symm.toMonoidHom ++ ++ let G_1 := (Subgroup.comap new_A_map.rangeRestrict first_subgroup) ++ let G_2 := (Subgroup.comap new_B_map.rangeRestrict second_subgroup) ++ ++ have g_1_finite_index: G_1.FiniteIndex := by ++ unfold G_1 ++ rw [Subgroup.finiteIndex_iff] ++ rw [Subgroup.index_comap_of_surjective] ++ . ++ rw [← Subgroup.finiteIndex_iff] ++ apply first_subgroup_finite_index ++ . exact MonoidHom.rangeRestrict_surjective new_A_map ++ ++ have g_2_finite_index: G_2.FiniteIndex := by ++ unfold G_2 ++ rw [Subgroup.finiteIndex_iff] ++ rw [Subgroup.index_comap_of_surjective] ++ . ++ rw [← Subgroup.finiteIndex_iff] ++ apply second_subgroup_finite_index ++ . exact MonoidHom.rangeRestrict_surjective new_B_map ++ ++ ++ let G' := G_1 ⊓ G_2 ++ ++ have G'_finite_index : G'.FiniteIndex := by ++ unfold G' ++ infer_instance ++ ++ ++ have G'_abeliean : IsMulCommutative G' := by ++ unfold G' ++ refine { is_comm := ?_ } ++ refine { comm := ?_ } ++ intro a b ++ have a_mem := a.property ++ have b_mem := b.property ++ rw [Subgroup.mem_inf] at a_mem b_mem ++ have a_first := a_mem.1 ++ have b_first := b_mem.1 ++ have a_second := a_mem.2 ++ have b_second := b_mem.2 ++ unfold G_1 at a_first b_first ++ unfold G_2 at a_second b_second ++ ++ rw [Subgroup.mem_comap] at a_first b_first ++ ++ have first_comm := first_subgroup_abelian.is_comm.comm ⟨_, a_first⟩ ⟨_, b_first⟩ ++ have second_comm := second_subgroup_abelian.is_comm.comm ⟨_, a_second⟩ ⟨_, b_second⟩ ++ ++ apply Subtype.ext ++ have hcentral : Function.Injective g_to_central := by ++ intro (x : G) (y : G) h ++ exact Subtype.ext (congrArg (fun z : ↥(centralizer {g.val}) => z.val) h) ++ apply hcentral ++ apply data.iso.injective ++ apply Prod.ext ++ · apply Subtype.ext ++ change new_A_map (a.val * b.val) = new_A_map (b.val * a.val) ++ have h := congrArg (fun x : ↥first_subgroup => x.val.val) first_comm ++ change new_A_map a.val * new_A_map b.val = new_A_map b.val * new_A_map a.val at h ++ simpa only [map_mul] using h ++ · apply Subtype.ext ++ change new_B_map (a.val * b.val) = new_B_map (b.val * a.val) ++ have h := congrArg (fun x : ↥second_subgroup => x.val.val) second_comm ++ change new_B_map a.val * new_B_map b.val = new_B_map b.val * new_B_map a.val at h ++ simpa only [map_mul] using h ++ ++ use G' ++ + lemma compact_lie_virtually_abelian (n : ℕ) (hn : n ≠ 0) (G : Subgroup (Matrix.unitaryGroup (Fin n) ℂ)) (G_FG : G.FG) + (S_data: SPolyData G): ∃ N : Subgroup G, IsMulCommutative N ∧ N.FiniteIndex := by + +@@ -70,203 +293,8 @@ lemma compact_lie_virtually_abelian (n : ℕ) (hn : n ≠ 0) (G : Subgroup (Matr + } + } + · exact Subgroup.instFiniteIndexTop +- · have nontrivial_centrer_implies_virtual (G : Subgroup ↥(Matrix.unitaryGroup (Fin n) ℂ)) (G_FG : G.FG) (S_data: SPolyData G) (nontrivial_central : ∃ g : G, (∀ z : ℂ, g.val.val ≠ z • 1) ∧ g ∈ Set.center G): ∃ N : Subgroup G, IsMulCommutative ↥N ∧ N.FiniteIndex := by +- obtain ⟨g, g_not_multiple_I, g_central⟩ := nontrivial_central +- +- +- have all_mem_central : ∀ a : G, a ∈ Subgroup.centralizer {g} := by +- intro a b b_mem +- simp at b_mem +- rw [b_mem] +- rw [Set.mem_center_iff] at g_central +- have g_comm := g_central.comm a +- exact g_comm +- +- have n_ge_two : 2 ≤ n := by +- omega +- +- have n_ne_zero: NeZero n := by +- exact { out := hn } +- obtain ⟨data⟩ := centralizer_iso G g g_not_multiple_I +- +- +- -- The abelian subgroup of G_i. +- -- TODO - we need to construct a generating set for the smaller subgroup +- -- TODO - is there existing API for this in mathlib? +- let g_to_central: G →* (Subgroup.centralizer {g.val}) := { +- toFun := fun a => ⟨a, by +- rw [Subgroup.mem_centralizer_iff] +- simp +- rw [Set.mem_center_iff] at g_central +- rw [isMulCentral_iff] at g_central +- have foo := (g_central.1) a +- rw [commute_iff_eq] at foo +- rw [Subtype.ext_iff] at foo +- simpa using foo +- ⟩, +- map_one' := by +- simp +- map_mul' := by +- simp +- } +- +- have ha := data.ha +- +- let new_A_map := (Subgroup.subtype _).comp ((MonoidHom.fst _ _).comp (data.iso.toMonoidHom.comp g_to_central)) +- let new_B_map := (Subgroup.subtype _).comp ((MonoidHom.snd _ _).comp (data.iso.toMonoidHom.comp g_to_central)) +- +- let first_new_data: SPolyData (new_A_map.range) := { +- S := new_A_map.rangeRestrict '' S_data.S, +- S_one := by +- simp only [Set.mem_image] +- use 1 +- refine ⟨?_, ?_⟩ +- . apply S_data.S_one +- . exact map_one _ +- S_inv := by +- rw [← Set.image_inv] +- rw [← S_data.S_inv] +- S_finite := by +- apply Set.Finite.image +- apply S_data.S_finite +- S_generates := by +- rw [← MonoidHom.map_closure] +- rw [S_data.S_generates] +- rw [Subgroup.map_top_of_surjective] +- exact MonoidHom.rangeRestrict_surjective new_A_map +- S_poly_const := S_data.S_poly_const +- S_poly_const_pos := S_data.S_poly_const_pos +- S_poly_deg := S_data.S_poly_deg +- S_poly := by +- intro r hr +- rw [Set.Finite.toFinset_image] +- rw [← Finset.image_pow] +- grw [Finset.card_image_le] +- . +- apply S_data.S_poly r hr +- . exact S_data.S_finite +- } +- +- have data_b_pos: 0 < data.b := by +- have hab := data.hb +- omega +- +- -- TODO - deduplicate 'first_new_data' and 'second_new_data' +- let second_new_data: SPolyData (new_B_map.range) := { +- S := new_B_map.rangeRestrict '' S_data.S, +- S_one := by +- simp only [Set.mem_image] +- use 1 +- refine ⟨?_, ?_⟩ +- . apply S_data.S_one +- . exact map_one _ +- S_inv := by +- rw [← Set.image_inv] +- rw [← S_data.S_inv] +- S_finite := by +- apply Set.Finite.image +- apply S_data.S_finite +- S_generates := by +- rw [← MonoidHom.map_closure] +- rw [S_data.S_generates] +- rw [Subgroup.map_top_of_surjective] +- exact MonoidHom.rangeRestrict_surjective new_B_map +- S_poly_const := S_data.S_poly_const +- S_poly_const_pos := S_data.S_poly_const_pos +- S_poly_deg := S_data.S_poly_deg +- S_poly := by +- intro r hr +- rw [Set.Finite.toFinset_image] +- rw [← Finset.image_pow] +- grw [Finset.card_image_le] +- . +- apply S_data.S_poly r hr +- . exact S_data.S_finite +- } +- +- obtain ⟨first_subgroup, first_subgroup_abelian, first_subgroup_finite_index⟩ := compact_lie_virtually_abelian (data.a) (by grind) (new_A_map.range) (by +- rw [← Group.fg_iff_subgroup_fg] +- rw [← Group.fg_iff_subgroup_fg] at G_FG +- apply Group.fg_range +- ) (first_new_data) +- obtain ⟨second_subgroup, second_subgroup_abelian, second_subgroup_finite_index⟩ := compact_lie_virtually_abelian (data.b) (by grind) (new_B_map.range) (by +- rw [← Group.fg_iff_subgroup_fg] +- rw [← Group.fg_iff_subgroup_fg] at G_FG +- apply Group.fg_range +- ) (second_new_data) +- +- let iso := Subgroup.map data.iso.symm.toMonoidHom +- +- let G_1 := (Subgroup.comap new_A_map.rangeRestrict first_subgroup) +- let G_2 := (Subgroup.comap new_B_map.rangeRestrict second_subgroup) +- +- have g_1_finite_index: G_1.FiniteIndex := by +- unfold G_1 +- rw [Subgroup.finiteIndex_iff] +- rw [Subgroup.index_comap_of_surjective] +- . +- rw [← Subgroup.finiteIndex_iff] +- apply first_subgroup_finite_index +- . exact MonoidHom.rangeRestrict_surjective new_A_map +- +- have g_2_finite_index: G_2.FiniteIndex := by +- unfold G_2 +- rw [Subgroup.finiteIndex_iff] +- rw [Subgroup.index_comap_of_surjective] +- . +- rw [← Subgroup.finiteIndex_iff] +- apply second_subgroup_finite_index +- . exact MonoidHom.rangeRestrict_surjective new_B_map +- +- +- let G' := G_1 ⊓ G_2 +- +- have G'_finite_index : G'.FiniteIndex := by +- unfold G' +- infer_instance +- +- +- have G'_abeliean : IsMulCommutative G' := by +- unfold G' +- refine { is_comm := ?_ } +- refine { comm := ?_ } +- intro a b +- have a_mem := a.property +- have b_mem := b.property +- rw [Subgroup.mem_inf] at a_mem b_mem +- have a_first := a_mem.1 +- have b_first := b_mem.1 +- have a_second := a_mem.2 +- have b_second := b_mem.2 +- unfold G_1 at a_first b_first +- unfold G_2 at a_second b_second +- +- rw [Subgroup.mem_comap] at a_first b_first +- +- have first_comm := first_subgroup_abelian.is_comm.comm ⟨_, a_first⟩ ⟨_, b_first⟩ +- have second_comm := second_subgroup_abelian.is_comm.comm ⟨_, a_second⟩ ⟨_, b_second⟩ +- +- rw [Subtype.ext_iff] +- simp +- apply_fun g_to_central +- simp +- apply_fun data.iso +- . +- simp +- apply Prod.ext +- . simp +- rw [Subtype.ext_iff] +- simp +- exact congrArg (fun x : ↥first_subgroup => x.val.val) first_comm +- . simp +- rw [Subtype.ext_iff] +- simp +- exact congrArg (fun x : ↥second_subgroup => x.val.val) second_comm +- . intro a b hab +- simp [g_to_central] at hab +- simpa using hab +- +- use G' ++ · have nontrivial_centrer_implies_virtual := central_element_virtually_abelian n hn ++ n_eq_one (fun m hm hm0 H hH D => compact_lie_virtually_abelian m hm0 H hH D) + by_cases nontrivial_central : ∃ g : G, (∀ z : ℂ, g.val.val ≠ z • 1) ∧ g ∈ Set.center G + · exact nontrivial_centrer_implies_virtual G G_FG S_data nontrivial_central + · -- Case two - we have no non-trivial central elements +@@ -290,80 +318,11 @@ lemma compact_lie_virtually_abelian (n : ℕ) (hn : n ≠ 0) (G : Subgroup (Matr + + obtain ⟨pre_S, h_pre_S⟩ := G'_fg + +- have pos := S_data.S_poly_const_pos +- have my_equiv := poly_growth_equiv S_data.S_poly_const S_data.S_poly_deg (by omega) +- S_data.S_finite.toFinset (Finset.image (Subgroup.subtype _) (pre_S ∪ pre_S⁻¹ ∪ {1})) ?_ ?_ (by simp [S_data.S_generates]) S_data.S_poly +- +- obtain ⟨b, hb, new_poly⟩ := my_equiv +- +- let S_data_G': SPolyData ((G' n ε G)) := { +- S := pre_S ∪ pre_S⁻¹ ∪ {1}, +- S_finite := by simp, +- S_generates := by +- rw [Subgroup.closure_union] +- rw [Subgroup.closure_union] +- simp [h_pre_S] +- S_one := by +- simp +- S_inv := by +- simp +- rw [Set.union_comm] +- S_poly_const := b +- S_poly_const_pos := by omega +- S_poly_deg := S_data.S_poly_deg +- S_poly := by +- intro r hr +- unfold Set.Finite.toFinset +- specialize new_poly r hr +- rw [← Finset.image_pow] at new_poly +- rw [Finset.card_image_of_injective] at new_poly +- -- TODO(mathlib) - figure out what @[norm_cast] attribute to apply to make 'norm_cast' work with the {1} set +- have one_eq: ({1}: Set (G' n ε G)) = ({1}: Finset (G' n ε G)) := by simp +- norm_cast +- simp_rw [one_eq] +- norm_cast +- . simpa using new_poly +- . exact subtype_injective (G' n ε G) +- } +- +- let map_set (Q: Finset (G' n ε G)) := Finset.image (fun a => (⟨a.val, by simp⟩ : (Subgroup.map G.subtype (G' n ε G)))) Q +- let other := G.subtype '' (((G' n ε G).subtype) '' (pre_S)) +- ++ let S_data_G' := subgroup_growth_data S_data (G' n ε G) pre_S h_pre_S + + by_cases G'_nontrivial_central : ∃ g : (G' n ε G), (∀ z : ℂ, g.val.val.val ≠ z • 1) ∧ g ∈ Set.center (G' n ε G) + · +- let foo := S_data_G'.S +- let bar := G.subtype.subgroupMap (G' n ε G) +- have subtype_S_data: SPolyData (Subgroup.map G.subtype (G' n ε G)) := { +- S := (G.subtype.subgroupMap (G' n ε G)) '' S_data_G'.S +- S_finite := by +- apply Set.Finite.image +- apply S_data_G'.S_finite +- S_one := by +- simp only [Set.mem_image] +- use 1 +- simp +- apply S_data_G'.S_one +- S_inv := by +- rw [← Set.image_inv] +- rw [← S_data_G'.S_inv] +- S_generates := by +- rw [← MonoidHom.map_closure] +- rw [S_data_G'.S_generates] +- rw [Subgroup.map_top_of_surjective] +- exact MonoidHom.subgroupMap_surjective G.subtype (G' n ε G) +- S_poly_const := S_data_G'.S_poly_const +- S_poly_const_pos := S_data_G'.S_poly_const_pos +- S_poly_deg := S_data_G'.S_poly_deg +- S_poly := by +- intro r hr +- rw [Set.Finite.toFinset_image] +- rw [← Finset.image_pow] +- grw [Finset.card_image_le] +- . +- apply S_data_G'.S_poly r hr +- . exact S_data_G'.S_finite +- } ++ let subtype_S_data := map_S_data (f := G.subtype) (G' n ε G) S_data_G' + + have G'_virtual := nontrivial_centrer_implies_virtual (Subgroup.map G.subtype (G' n ε G)) (by + have G'_finite := G_eps.1 +@@ -415,59 +374,12 @@ lemma compact_lie_virtually_abelian (n : ℕ) (hn : n ≠ 0) (G : Subgroup (Matr + have target := HnEpsData.central_trivial_virtually_abelian n (by omega) G G_FG ?_ G_eps.1 S_data_G' ?_ + · exact target + · intro g hg +- simp only [ne_eq, not_exists, not_and] at G'_nontrivial_central +- specialize G'_nontrivial_central g +- rw [← not_imp_not] at G'_nontrivial_central +- simp at G'_nontrivial_central +- exact G'_nontrivial_central hg +- . rfl +- . +- ext a +- simp +- nth_rw 1 [S_data.S_inv] +- simp +- . simp +- apply S_data.S_one +-termination_by (n, G.index) +-decreasing_by +- · apply Prod.Lex.left +- have hab := data.hab +- grind +- . apply Prod.Lex.left +- have hab := data.hab +- grind +-#print axioms compact_lie_virtually_abelian +- +-@[expose] +-def map_S_data {G H: Type*} [Group G] [Group H] [DecidableEq G] [DecidableEq H] (A: Subgroup G) {f: G →* H} (S_data: SPolyData A): SPolyData (Subgroup.map f A) := { +- S := f.subgroupMap A '' S_data.S +- S_finite := by +- apply Set.Finite.image +- apply S_data.S_finite +- S_one := by +- simp only [Set.mem_image] +- use 1 +- simp +- apply S_data.S_one +- S_inv := by +- rw [← Set.image_inv] +- rw [← S_data.S_inv] +- S_generates := by +- rw [← MonoidHom.map_closure] +- rw [S_data.S_generates] +- rw [Subgroup.map_top_of_surjective] +- apply MonoidHom.subgroupMap_surjective +- S_poly_const := S_data.S_poly_const +- S_poly_const_pos := S_data.S_poly_const_pos +- S_poly_deg := S_data.S_poly_deg +- S_poly := by +- intro r hr +- rw [Set.Finite.toFinset_image] +- rw [← Finset.image_pow] +- grw [Finset.card_image_le] +- . +- apply S_data.S_poly r hr +- . exact S_data.S_finite +-} +- +-#print axioms HnEpsData.central_trivial_virtually_abelian ++ by_contra hc ++ apply G'_nontrivial_central ++ refine ⟨g, ?_, hg⟩ ++ intro z hz ++ exact hc ⟨z, hz⟩ ++ · simp only [S_data_G', subgroup_growth_data] ++ rfl ++termination_by n ++decreasing_by exact hm +diff --git a/Gromov/VWrapper.lean b/Gromov/VWrapper.lean +index c37f7e3..847b5f4 100644 +--- a/Gromov/VWrapper.lean ++++ b/Gromov/VWrapper.lean +@@ -12,11 +12,6 @@ used to locate a scale at which the growth of `V` is almost multiplicative. + + public section + +-set_option linter.style.cdot false +-set_option linter.style.whitespace false +-set_option linter.style.longLine false +-set_option linter.flexible false +-set_option linter.style.emptyLine false + + open scoped Finset + open scoped Pointwise +@@ -99,80 +94,82 @@ lemma f_monotone_on (bas : Module.Basis ι ℝ V): MonotoneOn (f bas) (Set.Ici + intro x hx y hy hxy + unfold f + grw [Finset.pow_subset_pow_right (n := y)] +- . ++ · + rw [mul_le_mul_iff_right₀] +- . ++ · + rw [Real.rpow_le_rpow_iff] +- . ++ · + apply matrix_det_montone +- . ++ · + apply Q_R_matrix_pos_def bas x (by simp [R'] at hx; exact hx) +- . ++ · + unfold Q_R_matrix + rw [← map_sub] + rw [← LinearMap.isPosSemidef_iff_posSemidef_toMatrix] + apply Q_R_lin_sub_pos_semi_def + simpa using hxy +- . ++ · + have foo := Q_R_matrix_pos_def bas x (by simp [R'] at hx; exact hx) + grind [foo.det_pos] +- . ++ · + have foo := Q_R_matrix_pos_def bas y (by simp [R'] at hy; exact hy) + grind [foo.det_pos] +- . simp [dim] ++ · simp [dim] + exact Module.finrank_pos +- . ++ · + simp + apply Finset.Nonempty.pow + apply S_nonempty + +- . apply Real.rpow_nonneg ++ · apply Real.rpow_nonneg + have foo := Q_R_matrix_pos_def bas x (by simp [R'] at hx; exact hx) + grind [foo.det_pos] +- . apply hGS.one_mem +- . exact hxy ++ · apply hGS.one_mem ++ · exact hxy + +-lemma h_montone_on (bas : Module.Basis ι ℝ V): MonotoneOn (h bas) (Set.Ici i₀) := by ++omit [Nonempty ι] in ++lemma h_montone_on [_nonempty : Nonempty ι] (bas : Module.Basis ι ℝ V): MonotoneOn (h bas) (Set.Ici i₀) := by + unfold h + rw [← Function.comp_def] + apply MonotoneOn.comp +- . apply Real.strictMonoOn_log.monotoneOn +- . ++ · apply Real.strictMonoOn_log.monotoneOn ++ · + rw [← Function.comp_def] + apply MonotoneOn.comp +- . apply f_monotone_on bas +- . ++ · apply f_monotone_on bas ++ · + conv => + arg 1 + equals fun n => 16 ^ n => + simp + apply (pow_right_monotone (by simp)).monotoneOn +- . intro a ha ++ · intro a ha + simp [i₀] at ha + simp + rw [Nat.clog_le_iff_le_pow] at ha +- . ++ · + rify at ha + grw [Nat.le_ceil (a := R')] + exact ha +- . simp +- . ++ · simp ++ · + intro a ha + simp + simp at ha + simp [f] + apply mul_pos +- . simp ++ · simp + apply Finset.Nonempty.pow + apply S_nonempty +- . ++ · + apply Real.rpow_pos_of_pos + apply (Q_R_matrix_pos_def_i₀ bas _ ?_).det_pos + rw [pow_le_pow_iff_right₀] +- . exact ha +- . simp ++ · exact ha ++ · simp + +-lemma growth_implies_lim_h (b : Module.Basis ι ℝ V) (d: ℕ) (h_growth: growth_bound b d): Filter.Tendsto (fun (i: ℕ) => (h b i - d * i * Real.log 16)) Filter.atTop Filter.atBot := by ++omit [Nonempty ι] in ++lemma growth_implies_lim_h [_nonempty : Nonempty ι] (b : Module.Basis ι ℝ V) (d: ℕ) (h_growth: growth_bound b d): Filter.Tendsto (fun (i: ℕ) => (h b i - d * i * Real.log 16)) Filter.atTop Filter.atBot := by + unfold growth_bound my_expr at h_growth + have pow_tendsto: Filter.Tendsto (fun n => 16 ^ n) Filter.atTop Filter.atTop := by + apply StrictMono.tendsto_atTop +@@ -191,9 +188,9 @@ lemma growth_implies_lim_h (b : Module.Basis ι ℝ V) (d: ℕ) (h_growth: growt + rw [Real.log_div (by + rw [mul_ne_zero_iff] + refine ⟨?_, ?_⟩ +- . simp ++ · simp + grind [S_nonempty] +- . ++ · + have det_pos := (Q_R_matrix_pos_def_i₀ b (16 ^ (x + i₀)) (by + rw [add_comm] + rw [pow_add] +@@ -204,9 +201,9 @@ lemma growth_implies_lim_h (b : Module.Basis ι ℝ V) (d: ℕ) (h_growth: growt + )).det_pos + + rw [Real.rpow_ne_zero] +- . grind +- . grind +- . ++ · grind ++ · grind ++ · + norm_cast + rw [inv_eq_zero] + norm_cast +@@ -220,7 +217,6 @@ lemma growth_implies_lim_h (b : Module.Basis ι ℝ V) (d: ℕ) (h_growth: growt + simp + exact comp_log + +-#print axioms growth_implies_lim_h + + @[expose] + noncomputable def a (d: ℕ) := 4 * d * Real.log 16 +@@ -234,11 +230,11 @@ lemma exists_j_0_for_h (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 + have h_gt (N: ℕ): h b (i₀ + (3 * w * N)) ≥ 4 * d * w * N * (Real.log 16) + h b i₀ := by + rw [h_sum] + grw [← Finset.card_nsmul_le_sum (n := w * (a d))] +- . ++ · + simp + simp [a] + grind +- . intro n hn ++ · intro n hn + apply this + + have h_diff_ge (N: ℕ): h b (i₀ + (3 * w * N)) - d * (i₀ + 3 * w * N) * Real.log 16 ≥ d * (w * N - i₀) * (Real.log 16) + h b i₀ := by +@@ -276,14 +272,14 @@ lemma exists_j_0_for_h (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 + lhs + equals 0 + negative_start => simp + apply Nat.add_le_add +- . simp +- . ++ · simp ++ · + conv => + lhs + equals 1 * negative_start => simp + apply Nat.mul_le_mul +- . grind +- . simp ++ · grind ++ · simp + ) + + have h_ge_one := h_diff_ge (max ⌈positive_start⌉₊ negative_start) +@@ -316,17 +312,17 @@ lemma lemma_3_24 (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 < d) + + have h_m_diff_le: h b (m + w) - h b (m) ≤ h b (i₀ + 3 * w * (j_0 + 1)) - h b (i₀ + 3 * w * (j_0)) := by + apply sub_le_sub +- . ++ · + apply h_montone_on b +- . simp [m] ++ · simp [m] + grind +- . simp +- . simp [m] ++ · simp ++ · simp [m] + grind +- . apply h_montone_on b +- . simp [m] +- . simp [m] +- . simp [m] ++ · apply h_montone_on b ++ · simp ++ · simp [m] ++ · simp [m] + + have h_le_w_a_d : h b (m + w) - h b m ≤ w * (a d) := by + grw [h_m_diff_le] +@@ -335,8 +331,8 @@ lemma lemma_3_24 (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 < d) + have w_a_le_h : w * (a d) ≤ h b (m + w) - h b m := by + rw [h_sum.symm] + grw [← Finset.card_nsmul_le_sum (n := (a d))] +- . simp +- . intro x hx ++ · simp ++ · intro x hx + apply this + simpa using hx + grind +@@ -346,22 +342,22 @@ lemma lemma_3_24 (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 < d) + by_contra! + + have h_sum (N: ℕ) := Finset.sum_Ico_sub (f := fun n => h b (m + n)) (m := (2 * w)) (n := (3 * w)) (by grind) +- simp only [Nat.Ico_zero_eq_range, add_zero, forall_const] at h_sum ++ simp only [forall_const] at h_sum + + have h_m_diff_le: h b (m + 3 * w) - h b (m + 2 * w) ≤ h b (i₀ + 3 * w * (j_0 + 1)) - h b (i₀ + 3 * w * (j_0)) := by + apply sub_le_sub +- . ++ · + apply h_montone_on b +- . simp [m] ++ · simp [m] + grind +- . simp +- . simp [m] ++ · simp ++ · simp [m] + grind +- . apply h_montone_on b +- . simp [m] +- . simp [m] ++ · apply h_montone_on b ++ · simp ++ · simp [m] + grind +- . simp [m] ++ · simp [m] + + have h_le_w_a_d : h b (m + 3 * w) - h b (m + 2 * w) ≤ w * (a d) := by + grw [h_m_diff_le] +@@ -371,10 +367,10 @@ lemma lemma_3_24 (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 < d) + + rw [h_sum.symm] + grw [← Finset.card_nsmul_le_sum (n := (a d))] +- . simp ++ · simp + rw [← Nat.sub_mul] + simp +- . intro x hx ++ · intro x hx + apply this + simp + simp at hx +@@ -385,20 +381,20 @@ lemma lemma_3_24 (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 < d) + obtain ⟨i_2, h_i_2⟩ := exists_i2 + have diff_i_lt: h b (i_2 + 1) - h b i_1 < w * (a d) := by + grw [h_montone_on b _ _ (b := i₀ + 3 * w * (j_0 + 1))] +- . ++ · + apply LE.le.trans_lt ?_ h_j_0 + apply sub_le_sub_left + apply h_montone_on b +- . simp +- . simp ++ · simp ++ · simp + grind +- . grind +- . simp at h_i_2 ++ · grind ++ · simp at h_i_2 + grind +- . simp ++ · simp + simp at h_i_2 + grind +- . simp [m] ++ · simp + + have foo := h_i_1.1 + simp at foo +@@ -407,8 +403,8 @@ lemma lemma_3_24 (b : Module.Basis ι ℝ V) (w d: ℕ) (hw: 0 < w) (hd: 0 < d) + have i_0_pos: 0 < i₀ := by + simp [i₀] + apply Nat.clog_pos +- . simp +- . simp [R'] ++ · simp ++ · simp [R'] + rw [Nat.lt_ceil] + simp [R'_] + have r_pos := R'_pos V +diff --git a/Gromov/Vendor/Carleson/ToMathlib/Analysis/Convolution.lean b/Gromov/Vendor/Carleson/ToMathlib/Analysis/Convolution.lean +index dd8200d..cc1fba1 100644 +--- a/Gromov/Vendor/Carleson/ToMathlib/Analysis/Convolution.lean ++++ b/Gromov/Vendor/Carleson/ToMathlib/Analysis/Convolution.lean +@@ -52,12 +52,13 @@ lemma lintegral_enorm_convolution_integrand_le_eLpNorm_mul_eLpNorm [AddGroup G] + hg.comp_quasiMeasurePreserving <| quasiMeasurePreserving_sub_left μ x₀ + have hL' : ∀ᵐ (x : G) ∂μ, ‖L (f x) (g (x₀ - x))‖ ≤ (1 : NNReal) * ‖f x‖ * ‖g (x₀ - x)‖ := by + simpa using Filter.Eventually.of_forall (fun x ↦ hL x (x₀ - x)) +- simpa [eLpNorm, eLpNorm', Function.comp_def] using +- eLpNorm_le_eLpNorm_mul_eLpNorm'_of_norm hf hg' (L ·) _ hL' (hpqr := hpq) ++ have bound := eLpNorm_le_eLpNorm_mul_eLpNorm_of_norm ++ (L ·) 1 (by fun_prop) hf hg' hL' (hpqr := hpq) ++ exact lintegral_enorm_le_eLpNorm_one.trans (by simpa only [Function.comp_def, ENNReal.coe_one, one_mul] using bound) + + /-- If `MemLp f p μ` and `MemLp g q μ`, where `p` and `q` are Hölder conjugates, then the + convolution of `f` and `g` exists everywhere. -/ +-theorem ConvolutionExists.of_memLp_memLp [AddGroup G] [MeasurableAdd₂ G] ++theorem ConvolutionExists.of_memLp_memLp_legacy [AddGroup G] [MeasurableAdd₂ G] + [MeasurableNeg G] (μ : Measure G) [SFinite μ] [μ.IsNegInvariant] [μ.IsAddLeftInvariant] + [μ.IsAddRightInvariant] {p q : ENNReal} (hpq : p.HolderConjugate q) + (hL : ∀ (x y : G), ‖L (f x) (g y)‖ ≤ ‖f x‖ * ‖g y‖) (hf : AEStronglyMeasurable f μ) +diff --git a/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Function/LpSeminorm/Basic.lean b/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Function/LpSeminorm/Basic.lean +index df0289c..b18f60f 100644 +--- a/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Function/LpSeminorm/Basic.lean ++++ b/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Function/LpSeminorm/Basic.lean +@@ -25,6 +25,10 @@ set_option linter.style.header false + open MeasureTheory + open scoped ENNReal + ++-- On the countable discrete groups used below, the new measurability guard ++-- in Mathlib's eLpNorm is discharged by this existing theorem. ++attribute [simp] AEStronglyMeasurable.of_discrete ++ + variable {α ε E F G : Type*} {m m0 : MeasurableSpace α} {p : ℝ≥0∞} {q : ℝ} {μ ν : Measure α} + [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G] [ENorm ε] + +@@ -34,25 +38,18 @@ section MapMeasure + + variable {β : Type*} {mβ : MeasurableSpace β} {f : α → β} {g : β → E} + +-theorem eLpNormEssSup_map_measure' [MeasurableSpace E] [OpensMeasurableSpace E] ++theorem eLpNormEssSup_map_measure' [MeasurableSpace E] [OpensMeasurableSpace E] [SecondCountableTopology E] + (hg : AEMeasurable g (Measure.map f μ)) (hf : AEMeasurable f μ) : + eLpNormEssSup g (Measure.map f μ) = eLpNormEssSup (g ∘ f) μ := + essSup_map_measure hg.enorm hf + +-theorem eLpNorm_map_measure' [MeasurableSpace E] [OpensMeasurableSpace E] ++theorem eLpNorm_map_measure' [MeasurableSpace E] [OpensMeasurableSpace E] [SecondCountableTopology E] + (hg : AEMeasurable g (Measure.map f μ)) (hf : AEMeasurable f μ) : + eLpNorm g p (Measure.map f μ) = eLpNorm (g ∘ f) p μ := by +- by_cases hp_zero : p = 0 +- · aesop +- by_cases hp_top : p = ∞ +- · rw [hp_top, eLpNorm_exponent_top] +- exact eLpNormEssSup_map_measure' hg hf +- simp_rw [eLpNorm_eq_lintegral_rpow_enorm hp_zero hp_top] +- rw [lintegral_map' (hg.enorm.pow_const p.toReal) hf] +- rfl ++ exact eLpNorm_map_measure hg.aestronglyMeasurable hf + + theorem eLpNorm_comp_measurePreserving' {ν : Measure β} [MeasurableSpace E] +- [OpensMeasurableSpace E] (hg : AEMeasurable g ν) (hf : MeasurePreserving f μ ν) : ++ [OpensMeasurableSpace E] [SecondCountableTopology E] (hg : AEMeasurable g ν) (hf : MeasurePreserving f μ ν) : + eLpNorm (g ∘ f) p μ = eLpNorm g p ν := + Eq.symm <| hf.map_eq ▸ eLpNorm_map_measure' (hf.map_eq ▸ hg) hf.aemeasurable + +diff --git a/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Integral/MeanInequalities.lean b/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Integral/MeanInequalities.lean +index 40fc8a4..fb8ba6c 100644 +--- a/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Integral/MeanInequalities.lean ++++ b/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Integral/MeanInequalities.lean +@@ -13,19 +13,13 @@ public import Gromov.Vendor.Carleson.ToMathlib.MeasureTheory.Measure.Haar.Unique + public import Gromov.Vendor.Carleson.ToMathlib.MeasureTheory.Measure.Prod + + /-! +-# Vendored from the Carleson project ++# Young's convolution inequality + +-Port of `Carleson/ToMathlib/MeasureTheory/Integral/MeanInequalities.lean` from +- (branch `young-add-group`, commit `3b35c86`), which is +-the non-abelian generalization of Young's convolution inequality. +- +-The `eLpNorm_Ioc_convolution_le_*` theorems at the end of the upstream file are omitted: they are +-unused here and would drag in the whole `Carleson/ToMathlib/MeasureTheory/Integral/Periodic.lean` +-(`liftIoc`) development. ++Non-abelian convolution inequalities, including Hölder and Minkowski estimates. ++Based on the Carleson project contributors' formalization of Young's inequality, ++, commit `3b35c86`. + -/ + +-set_option linter.style.header false +- + @[expose] public section + + open NNReal ENNReal MeasureTheory Finset +@@ -51,7 +45,6 @@ theorem Lp_add_le_sum + Lp_add_le _ _ _ hp + _ ≤ _ := by gcongr + +--- Add after `lintegral_prod_norm_pow_le` + /-- A version of Hölder with multiple arguments, allowing `∞` as an exponent. -/ + theorem lintegral_prod_norm_pow_le' {α ι : Type*} [MeasurableSpace α] {μ : Measure α} + {s : Finset ι} {f : ι → α → ℝ≥0∞} (hf : ∀ i ∈ s, AEMeasurable (f i) μ) +@@ -69,7 +62,8 @@ theorem lintegral_prod_norm_pow_le' {α ι : Type*} [MeasurableSpace α] {μ : M + lintegral_congr (fun a ↦ (Finset.mul_prod_erase s (f · a) hi₀).symm) + _ ≤ eLpNorm (f i₀) (p i₀) μ * ∫⁻ (a : α), ∏ i ∈ s.erase i₀, f i a ∂μ := by + rw [← lintegral_const_mul'', pi₀_eq_top] +- · exact lintegral_mono_ae <| (ae_le_essSup (f i₀)).mono (fun a ha ↦ mul_le_mul_left ha _) ++ · rw [eLpNorm_exponent_top (hf i₀ hi₀).aestronglyMeasurable] ++ exact lintegral_mono_ae <| (ae_le_essSup (f i₀)).mono (fun a ha ↦ mul_le_mul_left ha _) + · exact Finset.aemeasurable_fun_prod _ (fun i hi ↦ hf i (Finset.mem_of_mem_erase hi)) + _ ≤ eLpNorm (f i₀) (p i₀) μ * ∏ i ∈ s.erase i₀, eLpNorm (f i) (p i) μ := by + apply mul_right_mono +@@ -91,15 +85,15 @@ theorem lintegral_prod_norm_pow_le' {α ι : Type*} [MeasurableSpace α] {μ : M + convert ENNReal.lintegral_prod_norm_pow_le s hf' hp₁ hp₂ with a i₀ hi₀ i hi + · rw [← ENNReal.rpow_mul, mul_inv_cancel₀, rpow_one] + exact ENNReal.toReal_ne_zero.mpr ⟨p_ne_0 i₀ hi₀, (exists_top ⟨i₀, hi₀, ·⟩)⟩ +- · simp [eLpNorm, eLpNorm', p_ne_0 i hi, p_ne_top i hi] ++ · simp [eLpNorm, eLpNorm', p_ne_0 i hi, p_ne_top i hi, (hf i hi).aestronglyMeasurable] + + /-- **Hölder's inequality** for functions `α → ℝ≥0∞`, using exponents in `ℝ≥0∞` -/ + theorem lintegral_mul_le_eLpNorm_mul_eLqNorm {p q : ℝ≥0∞} (hpq : p.HolderConjugate q) + {f g : α → ENNReal} (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) : + ∫⁻ (a : α), (f * g) a ∂μ ≤ eLpNorm f p μ * eLpNorm g q μ := by +- -- adaptation note: `ENNReal.HolderConjugate` is now a class (`HolderTriple p q 1`), so the +- -- upstream dot-notation API (`hpq.symm`, `hpq.conj_eq`, `hpq.toReal_of_ne_top`) is gone. +- haveI := hpq ++ have := hpq ++ have hfm := hf.aestronglyMeasurable ++ have hgm := hg.aestronglyMeasurable + simp_rw [Pi.mul_apply] + have hp0 : p ≠ 0 := HolderConjugate.ne_zero p q + have hq0 : q ≠ 0 := HolderConjugate.ne_zero q p +@@ -109,14 +103,14 @@ theorem lintegral_mul_le_eLpNorm_mul_eLqNorm {p q : ℝ≥0∞} (hpq : p.HolderC + _ ≤ ∫⁻ a, essSup f μ * g a ∂μ := + lintegral_mono_ae <| (ae_le_essSup f).mono fun a ha ↦ mul_le_mul_left ha _ + _ = essSup f μ * ∫⁻ a, g a ∂μ := lintegral_const_mul'' _ hg +- _ = _ := by simp [eLpNorm, eLpNorm', eLpNormEssSup, hp, hq1] ++ _ = _ := by simp [eLpNorm, eLpNorm', eLpNormEssSup, hp, hq1, hfm, hgm] + rcases eq_or_ne q ∞ with hq | hq + · have hp1 : p = 1 := (HolderConjugate.eq_top_iff_eq_one q p).mp hq + calc ∫⁻ a, f a * g a ∂μ + _ ≤ ∫⁻ a, f a * essSup g μ ∂μ := + lintegral_mono_ae <| (ae_le_essSup g).mono fun a ha ↦ mul_le_mul_right ha _ + _ = (∫⁻ a, f a ∂μ) * essSup g μ := lintegral_mul_const'' _ hf +- _ = _ := by simp [eLpNorm, eLpNorm', eLpNormEssSup, hp1, hq] ++ _ = _ := by simp [eLpNorm, eLpNorm', eLpNormEssSup, hp1, hq, hfm, hgm] + -- Both exponents are finite: reduce to the real-exponent version. + have hpt : 0 < p.toReal := ENNReal.toReal_pos hp0 hp + have hqt : 0 < q.toReal := ENNReal.toReal_pos hq0 hq +@@ -129,7 +123,7 @@ theorem lintegral_mul_le_eLpNorm_mul_eLqNorm {p q : ℝ≥0∞} (hpq : p.HolderC + have : 0 < q.toReal⁻¹ := by positivity + linarith + convert ENNReal.lintegral_mul_le_Lp_mul_Lq μ hpq' hf hg +- all_goals simp [eLpNorm, eLpNorm', hp, hq, hp0, hq0] ++ all_goals simp [eLpNorm, eLpNorm', hp, hq, hp0, hq0, hfm, hgm] + + /-- **Cauchy–Schwarz inequality** for functions `α → ℝ≥0∞` (Hölder's inequality squared). -/ + theorem sq_lintegral_mul_le_mul_lintegral_sq {f g : α → ℝ≥0∞} +@@ -168,15 +162,21 @@ universe u𝕜 uG uE uE' uF + variable {𝕜 : Type u𝕜} {G : Type uG} [MeasurableSpace G] {μ : Measure G} + {E : Type uE} {E' : Type uE'} {F : Type uF} + ++variable [Countable G] [MeasurableSingletonClass G] ++ ++private theorem discrete_aestronglyMeasurable {Y : Type*} [TopologicalSpace Y] ++ (f : G → Y) : AEStronglyMeasurable f μ := AEStronglyMeasurable.of_discrete ++ ++attribute [local simp] discrete_aestronglyMeasurable ++ + variable [NormedAddCommGroup E] [NormedAddCommGroup E'] [NormedAddCommGroup F] + {f : G → E} {g : G → E'} + + /-- If `MemLp f p μ` and `MemLp g q μ`, where `p` and `q` are Hölder conjugates, then the + convolution of `f` and `g` exists everywhere. + +-This is `MeasureTheory.ConvolutionExists.of_memLp_memLp`, re-exported into the `ENNReal` +-namespace to match the name used elsewhere in this development. -/ +-alias ConvolutionExists.of_memLp_memLp := MeasureTheory.ConvolutionExists.of_memLp_memLp ++This follows from Hölder's inequality with the conjugate exponents. -/ ++alias ConvolutionExists.of_memLp_memLp := MeasureTheory.ConvolutionExists.of_memLp_memLp_legacy + + -- Used in the proof of `enorm_convolution_le_eLpNorm_mul_eLpNorm_mul_eLpNorm` + open ENNReal in +@@ -191,9 +191,8 @@ private lemma eLpNorm_eq_eLpNorm_rpow (h : G → E) {r e : ℝ} (r0 : 0 < r) (e0 + have lt_top : ENNReal.ofReal (e * r) / ENNReal.ofReal (r - e) < ∞ := + div_lt_top ofReal_ne_top <| (not_iff_not.mpr ofReal_eq_zero).mpr r_sub_e_pos.not_ge + simp only [eLpNorm, eLpNorm', reduceIte, div_eq_zero_iff, ofReal_eq_zero, ofReal_ne_top, +- lt_top.ne, er_pos.not_ge, e0.not_ge, or_self, enorm_eq_self, ← rpow_mul] +- -- adaptation note: `field_simp` no longer sees through the `ENNReal.toReal` of the exponents, +- -- so we compute them by hand first. ++ lt_top.ne, er_pos.not_ge, e0.not_ge, or_self, enorm_eq_self, ← rpow_mul, ++ discrete_aestronglyMeasurable, ite_true] + have hrne : r - e ≠ 0 := r_sub_e_pos.ne' + have hene : e ≠ 0 := e0.ne' + have hrne0 : r ≠ 0 := r0.ne' +@@ -215,6 +214,7 @@ variable {L : E →L[𝕜] E' →L[𝕜] F} + + -- Used to handle trivial case `c ≤ 0` when proving versions of Young's convolution inequality + -- assuming `∀ (x y : G), ‖L (f x) (g y)‖ ≤ c * ‖f x‖ * ‖g y‖)` ++omit [Countable G] [MeasurableSingletonClass G] in + private theorem convolution_zero_of_c_nonpos [AddGroup G] {f : G → E} {g : G → E'} {c : ℝ} + (hL : ∀ (x y : G), ‖L (f x) (g y)‖ ≤ c * ‖f x‖ * ‖g y‖) (hc : c ≤ 0) : f ⋆[L, μ] g = 0 := by + have : ∀ (x y : G), L (f x) (g y) = 0 := +@@ -233,13 +233,13 @@ private theorem eLpNorm_top_convolution_le_aux [AddGroup G] {p q : ℝ≥0∞} + eLpNorm (f ⋆[L, μ] g) ∞ μ ≤ ENNReal.ofReal c * eLpNorm f p μ * eLpNorm g q μ := by + by_cases hc : c ≤ 0 + · simp [convolution_zero_of_c_nonpos hL hc] +- push_neg at hc +- rw [eLpNorm_exponent_top, eLpNormEssSup] ++ push Not at hc ++ rw [eLpNorm_exponent_top (discrete_aestronglyMeasurable _), eLpNormEssSup] + refine essSup_le_of_ae_le _ (Filter.Eventually.of_forall fun x ↦ ?_) + apply le_trans <| enorm_integral_le_lintegral_enorm _ + calc ∫⁻ y, ‖(L (f y)) (g (x - y))‖ₑ ∂μ + _ ≤ ∫⁻ y, ENNReal.ofReal c * ‖f y‖ₑ * ‖g (x - y)‖ₑ ∂μ := by +- simp_rw [← ofReal_norm_eq_enorm, ← ENNReal.ofReal_mul hc.le] ++ simp_rw [← ofReal_norm, ← ENNReal.ofReal_mul hc.le] + refine lintegral_mono (fun y ↦ ?_) + rw [← ENNReal.ofReal_mul <| mul_nonneg hc.le (norm_nonneg _)] + exact ENNReal.ofReal_le_ofReal <| hL y (x - y) +@@ -251,6 +251,7 @@ private theorem eLpNorm_top_convolution_le_aux [AddGroup G] {p q : ℝ≥0∞} + variable [AddGroup G] [TopologicalSpace G] [IsTopologicalAddGroup G] [BorelSpace G] + [μ.IsAddHaarMeasure] [LocallyCompactSpace G] [SecondCountableTopology G] + ++omit [LocallyCompactSpace G] in + /-- Special case of **Young's convolution inequality** when `r = ∞`. -/ + theorem eLpNorm_top_convolution_le [MeasurableSpace E] [OpensMeasurableSpace E] + [MeasurableSpace E'] [OpensMeasurableSpace E'] [μ.IsNegInvariant] {p q : ℝ≥0∞} +@@ -259,8 +260,9 @@ theorem eLpNorm_top_convolution_le [MeasurableSpace E] [OpensMeasurableSpace E] + eLpNorm (f ⋆[L, μ] g) ∞ μ ≤ ENNReal.ofReal c * eLpNorm f p μ * eLpNorm g q μ := by + refine eLpNorm_top_convolution_le_aux hpq hf.enorm ?_ ?_ c hL + · intro x; exact (hg.comp_quasiMeasurePreserving (quasiMeasurePreserving_sub_left μ x)).enorm +- · intro x; exact eLpNorm_comp_measurePreserving' hg (μ.measurePreserving_sub_left x) ++ · intro x; exact eLpNorm_comp_measurePreserving hg.enorm.aestronglyMeasurable (μ.measurePreserving_sub_left x) + ++omit [LocallyCompactSpace G] in + /-- Special case of **Young's convolution inequality** when `r = ∞`. -/ + theorem eLpNorm_top_convolution_le' [μ.IsNegInvariant] {p q : ℝ≥0∞} + (hpq : p.HolderConjugate q) {f : G → E} {g : G → E'} +@@ -269,7 +271,7 @@ theorem eLpNorm_top_convolution_le' [μ.IsNegInvariant] {p q : ℝ≥0∞} + eLpNorm (f ⋆[L, μ] g) ∞ μ ≤ ENNReal.ofReal c * eLpNorm f p μ * eLpNorm g q μ := by + refine eLpNorm_top_convolution_le_aux hpq hf.enorm ?_ ?_ c hL + · intro x; exact (hg.comp_quasiMeasurePreserving (quasiMeasurePreserving_sub_left μ x)).enorm +- · intro x; apply eLpNorm_comp_measurePreserving hg (Measure.measurePreserving_sub_left μ x) ++ · intro x; exact eLpNorm_comp_measurePreserving hg.enorm.aestronglyMeasurable (Measure.measurePreserving_sub_left μ x) + + -- Auxiliary inequality used to prove versions with simpler conditions on `f` and `g` + open ENNReal in +@@ -285,10 +287,10 @@ private theorem enorm_convolution_le_eLpNorm_mul_eLpNorm_mul_eLpNorm_aux + (eLpNorm g (.ofReal q) μ) ^ ((r - q) / r)) := by + by_cases hc : c ≤ 0 + · simp [convolution_zero_of_c_nonpos hL hc] +- push_neg at hc ++ push Not at hc + by_cases μ0 : μ = 0 + · simp [μ0, convolution] +- push_neg at μ0 ++ push Not at μ0 + let F (i : Fin 3) : G → ℝ≥0∞ := + match i with + | 0 => fun y ↦ (‖f y‖ₑ ^ p * ‖g (x - y)‖ₑ ^ q) ^ (1 / r) +@@ -363,6 +365,7 @@ private theorem enorm_convolution_le_eLpNorm_mul_eLpNorm_mul_eLpNorm_aux + simp [eLpNorm, eLpNorm', lintegral_sub_left_eq_self (‖g ·‖ₑ ^ (ENNReal.ofReal q).toReal) x] + + open ENNReal in ++omit [LocallyCompactSpace G] in + /-- This inequality is used in the proof of Young's convolution inequality + `eLpNorm_convolution_le_ofReal`. See `enorm_convolution_le_eLpNorm_mul_eLpNorm_mul_eLpNorm'` for + a version assuming a.e. strong measurability instead. -/ +@@ -380,6 +383,7 @@ theorem enorm_convolution_le_eLpNorm_mul_eLpNorm_mul_eLpNorm [MeasurableSpace E] + (fun x ↦ (hg.comp_quasiMeasurePreserving <| quasiMeasurePreserving_sub_left μ x).enorm) c hL x + + open ENNReal in ++omit [LocallyCompactSpace G] in + /-- This inequality is used in the proof of Young's convolution inequality + `eLpNorm_convolution_le_ofReal'`. -/ + theorem enorm_convolution_le_eLpNorm_mul_eLpNorm_mul_eLpNorm' +@@ -520,7 +524,7 @@ theorem eLpNorm_convolution_le_of_norm_le_mul [MeasurableSpace E] [OpensMeasurab + eLpNorm (f ⋆[L, μ] g) r μ ≤ .ofReal c * eLpNorm f p μ * eLpNorm g q μ := by + refine eLpNorm_convolution_le_of_norm_le_mul_aux hp hq hr hpqr hf.enorm ?_ ?_ ?_ c hL + · intro x; exact hg.enorm.comp_quasiMeasurePreserving (quasiMeasurePreserving_sub_left μ x) +- · intro x; exact eLpNorm_comp_measurePreserving' hg (μ.measurePreserving_sub_left x) ++ · intro x; exact eLpNorm_comp_measurePreserving hg.enorm.aestronglyMeasurable (μ.measurePreserving_sub_left x) + · exact hg.comp_quasiMeasurePreserving (quasiMeasurePreserving_sub μ μ) |>.enorm.pow_const _ + + /-- **Young's convolution inequality**: the `L^r` seminorm of a convolution `(f ⋆[L, μ] g)` is +@@ -535,7 +539,7 @@ theorem eLpNorm_convolution_le_of_norm_le_mul' + eLpNorm (f ⋆[L, μ] g) r μ ≤ .ofReal c * eLpNorm f p μ * eLpNorm g q μ := by + refine eLpNorm_convolution_le_of_norm_le_mul_aux hp hq hr hpqr hf.enorm ?_ ?_ ?_ c hL + · intro x; exact hg.enorm.comp_quasiMeasurePreserving (quasiMeasurePreserving_sub_left μ x) +- · intro x; apply eLpNorm_comp_measurePreserving hg (μ.measurePreserving_sub_left x) ++ · intro x; exact eLpNorm_comp_measurePreserving hg.enorm.aestronglyMeasurable (μ.measurePreserving_sub_left x) + · exact hg.comp_quasiMeasurePreserving (quasiMeasurePreserving_sub μ μ) |>.enorm.pow_const _ + + /-- **Young's convolution inequality**: the `L^r` seminorm of a convolution `(f ⋆[L, μ] g)` is +diff --git a/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Measure/Haar/Unique.lean b/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Measure/Haar/Unique.lean +index 3cd8144..cfa394d 100644 +--- a/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Measure/Haar/Unique.lean ++++ b/Gromov/Vendor/Carleson/ToMathlib/MeasureTheory/Measure/Haar/Unique.lean +@@ -40,7 +40,7 @@ instance (priority := 100) IsHaarMeasure.isInvInvariant_of_isMulRightInvariant ( + let c : ℝ≥0∞ := haarScalarFactor μ.inv μ + have hc : μ.inv = c • μ := isMulLeftInvariant_eq_smul_of_regular μ.inv μ + have : map Inv.inv (map Inv.inv μ) = c ^ 2 • μ := by +- rw [← inv_def μ, hc, Measure.map_smul, ← inv_def μ, hc, smul_smul, pow_two] ++ rw [← inv_def μ, hc, Measure.map_smul c (by fun_prop), ← inv_def μ, hc, smul_smul, pow_two] + have μeq : μ = c ^ 2 • μ := by + simpa [map_map continuous_inv.measurable continuous_inv.measurable] using this + have K : TopologicalSpace.PositiveCompacts G := Classical.arbitrary _ +diff --git a/lake-manifest.json b/lake-manifest.json +index d526394..69de6ca 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,96 +1,117 @@ +-{"version": "1.2.0", ++{ ++ "version": "1.2.0", + "packagesDir": ".lake/packages", +- "packages": +- [{"url": "https://github.com/leanprover-community/mathlib4", ++ "packages": [ ++ { ++ "url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "a6180e1994004a7c705114bcbebaf5fff4b8384d", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "a6180e1994004a7c705114bcbebaf5fff4b8384d", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, +- "configFile": "lakefile.lean"}, +- {"url": "https://github.com/leanprover-community/plausible", ++ "configFile": "lakefile.lean" ++ }, ++ { ++ "url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "123d15766ba49356c02ebad2a4462dfe12d79899", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/LeanSearchClient", ++ "configFile": "lakefile.toml" ++ }, ++ { ++ "url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "f5c090429dff3cf66cb65562526c9ea6e8edfbcb", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/import-graph", ++ "configFile": "lakefile.toml" ++ }, ++ { ++ "url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "bb3469a87774349fe01898d8bf2fc6a1ce6411ca", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/ProofWidgets4", ++ "configFile": "lakefile.toml" ++ }, ++ { ++ "url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "222c58dad7706a6e7cae46c0edd65ea881d3ee27", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.lean"}, +- {"url": "https://github.com/leanprover-community/aesop", ++ "configFile": "lakefile.lean" ++ }, ++ { ++ "url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7db8190085343afde2f5d2cdcc9bac719b6ec02c", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, +- "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/quote4", ++ "configFile": "lakefile.toml" ++ }, ++ { ++ "url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "ef42f8944eaf5b6cbfbe75d1917d824c7dd6cf33", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, +- "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/batteries", ++ "configFile": "lakefile.toml" ++ }, ++ { ++ "url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "76e1c118b0700b4ceafe99532e887d6431625e1a", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover/lean4-cli", ++ "configFile": "lakefile.toml" ++ }, ++ { ++ "url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "1319485273bf87833fa472afbcefdedecb16b45f", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.33.0-rc2", ++ "inputRev": "v4.34.0", + "inherited": true, +- "configFile": "lakefile.toml"}], ++ "configFile": "lakefile.toml" ++ } ++ ], + "name": "gromov", + "lakeDir": ".lake", +- "fixedToolchain": false} ++ "fixedToolchain": false ++} +diff --git a/lakefile.toml b/lakefile.toml +index 1faeb69..893e40a 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -9,8 +9,8 @@ autoImplicit = false + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "a6180e1994004a7c705114bcbebaf5fff4b8384d" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "Gromov" +diff --git a/lean-toolchain b/lean-toolchain +index c084c7f..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.33.0-rc2 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/heights-lean4341.patch b/lean/patches/heights-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..9e6cd1903343bc9735ad238905de4e2b626a38da --- /dev/null +++ b/lean/patches/heights-lean4341.patch @@ -0,0 +1,494 @@ +diff --git a/Heights/Absolute/Extension.lean b/Heights/Absolute/Extension.lean +index 6450f16..a242f46 100644 +--- a/Heights/Absolute/Extension.lean ++++ b/Heights/Absolute/Extension.lean +@@ -121,11 +121,7 @@ attribute [local instance] FractionRing.liftAlgebra in + /-- The absolute norm of an extended ideal is the `[K : k]`-th power of the absolute norm. -/ + lemma absNorm_map_algebraMap (I : Ideal (𝓞 k)) : + Ideal.absNorm (I.map (algebraMap (𝓞 k) (𝓞 K))) = Ideal.absNorm I ^ finrank k K := by +- rw [Ideal.absNorm_algebraMap, Algebra.finrank_eq_of_equiv_equiv +- (FractionRing.algEquiv (𝓞 k) k).toRingEquiv (FractionRing.algEquiv (𝓞 K) K).toRingEquiv] +- ext +- exact IsFractionRing.algEquiv_commutes (FractionRing.algEquiv (𝓞 k) k) +- (FractionRing.algEquiv (𝓞 K) K) _ ++ rw [Ideal.absNorm_algebraMap, ← IsFractionRing.finrank_eq (𝓞 k) k (𝓞 K) K] + + lemma finPart_algebraMap_of_integral {ι : Type*} [Finite ι] (z : ι → 𝓞 k) (hz : z ≠ 0) : + finPart (fun i => algebraMap k K (z i)) = finPart (fun i => (z i : k)) ^ finrank k K := by +diff --git a/Heights/Curve/Integrality.lean b/Heights/Curve/Integrality.lean +index f221058..cc3e3a8 100644 +--- a/Heights/Curve/Integrality.lean ++++ b/Heights/Curve/Integrality.lean +@@ -153,7 +153,7 @@ theorem apply_eval₂_le_nonarch (hw : ∀ a b, w (a + b) ≤ max (w a) (w b)) { + (zero_le_one.trans (one_le_coeffBound w Q)) fun m hm => ?_ + rw [map_mul, map_prod] + have hprod : ∏ i ∈ m.support, w (a i ^ m i) ≤ 1 := by +- refine Finset.prod_le_one (fun _ _ => w.nonneg _) fun i _ => ?_ ++ refine Finset.prod_le_one₀ (fun _ _ => w.nonneg _) fun i _ => ?_ + rw [map_pow] + exact pow_le_one₀ (w.nonneg _) (ha i) + calc w (Rat.castHom F (Q.coeff m)) * ∏ i ∈ m.support, w (a i ^ m i) +@@ -176,7 +176,7 @@ theorem apply_eval₂_le {a : κ → F} (ha : ∀ l, w (a l) ≤ 1) (Q : MvPolyn + refine Finset.sum_le_sum fun m hm => ?_ + rw [map_mul, map_prod] + have hprod : ∏ i ∈ m.support, w (a i ^ m i) ≤ 1 := by +- refine Finset.prod_le_one (fun _ _ => w.nonneg _) fun i _ => ?_ ++ refine Finset.prod_le_one₀ (fun _ _ => w.nonneg _) fun i _ => ?_ + rw [map_pow] + exact pow_le_one₀ (w.nonneg _) (ha i) + calc w (Rat.castHom F (Q.coeff m)) * ∏ i ∈ m.support, w (a i ^ m i) +diff --git a/Heights/Different/NumberField.lean b/Heights/Different/NumberField.lean +index 2136679..aae4cb0 100644 +--- a/Heights/Different/NumberField.lean ++++ b/Heights/Different/NumberField.lean +@@ -94,7 +94,7 @@ lemma multiplicity_le_of_not_pow_dvd {P I : Ideal R} [P.IsPrime] (hP : P ≠ ⊥ + + omit [IsDedekindDomain R] in + lemma multiplicity_eq_zero_of_not_dvd {P I : Ideal R} (h : ¬ P ∣ I) : multiplicity P I = 0 := +- multiplicity_eq_zero.mpr h ++ _root_.multiplicity_eq_zero_of_not_dvd h + + end Multiplicity + +diff --git a/Heights/Different/SerreBound.lean b/Heights/Different/SerreBound.lean +index 703d793..3c31aa0 100644 +--- a/Heights/Different/SerreBound.lean ++++ b/Heights/Different/SerreBound.lean +@@ -117,7 +117,7 @@ theorem exists_mem_pow_intTrace_notMem (h𝔭 : 𝔭 ≠ ⊥) (e κ : ℕ) (J : + refine Ideal.IsMaximal.eq_of_le inferInstance (Ideal.IsPrime.ne_top inferInstance) ?_ + change maximalIdeal Rₚ ≤ 𝔓ₚ.comap (algebraMap Rₚ Sₚ) + rw [← Ideal.map_le_iff_le_comap, hpSₚ] +- exact Ideal.mul_le_right.trans (Ideal.pow_le_self he) ++ exact Ideal.mul_le_left.trans (Ideal.pow_le_self he) + haveI : Finite (Rₚ ⧸ maximalIdeal Rₚ) := + Finite.of_equiv _ (IsLocalization.AtPrime.equivQuotMaximalIdeal 𝔭 Rₚ).toEquiv + -- the contraction of `𝔪^n` to `A` is `𝔭^n` +@@ -187,7 +187,7 @@ theorem exists_mem_pow_intTrace_notMem (h𝔭 : 𝔭 ≠ ⊥) (e κ : ℕ) (J : + ((Ideal.isCoprime_iff_sup_eq.mpr hJₚ').pow_left).pow_right + letI : Algebra (Rₚ ⧸ maximalIdeal Rₚ ^ (κ + 1)) (Sₚ ⧸ Jₚ ^ (κ + 1)) := + Ideal.Quotient.algebraQuotientOfLEComap +- (by rw [← Ideal.map_le_iff_le_comap, hprod]; exact Ideal.mul_le_left) ++ (by rw [← Ideal.map_le_iff_le_comap, hprod]; exact Ideal.mul_le_right) + haveI : IsScalarTower Rₚ (Rₚ ⧸ maximalIdeal Rₚ ^ (κ + 1)) (Sₚ ⧸ Jₚ ^ (κ + 1)) := + IsScalarTower.of_algebraMap_eq' rfl + haveI : IsScalarTower Rₚ (Rₚ ⧸ maximalIdeal Rₚ ^ (κ + 1)) +diff --git a/Heights/Different/SerreCore.lean b/Heights/Different/SerreCore.lean +index f6972ba..9679716 100644 +--- a/Heights/Different/SerreCore.lean ++++ b/Heights/Different/SerreCore.lean +@@ -38,7 +38,7 @@ variable (e κ : ℕ) (J : Ideal B) + lemma pow_le_comap (hpB : 𝔭.map (algebraMap A B) = 𝔓 ^ e * J) : + 𝔭 ^ (κ + 1) ≤ (𝔓 ^ (e * (κ + 1))).comap (algebraMap A B) := by + rw [← Ideal.map_le_iff_le_comap, Ideal.map_pow, hpB, mul_pow, ← pow_mul] +- exact Ideal.mul_le_right ++ exact Ideal.mul_le_left + + /-- The `A/𝔭^{κ+1}`-algebra structure of `B/𝔓^{e(κ+1)}`. -/ + noncomputable def quotAlgebra (hpB : 𝔭.map (algebraMap A B) = 𝔓 ^ e * J) : +diff --git a/Heights/IdealFactorization.lean b/Heights/IdealFactorization.lean +index dcfa41a..0b9c902 100644 +--- a/Heights/IdealFactorization.lean ++++ b/Heights/IdealFactorization.lean +@@ -105,7 +105,7 @@ theorem ReducedPrincipalIdealData.denominator_eq + have hcount := (r.count_spanSingleton hx v).symm.trans + (s.count_spanSingleton hx v) + have htop : multiplicity v.asIdeal (⊤ : Ideal (𝓞 K)) = 0 := +- multiplicity_eq_zero.mpr (by ++ _root_.multiplicity_eq_zero_of_not_dvd (by + simpa only [← Ideal.one_eq_top] using v.prime.not_dvd_one) + have hr := v.multiplicity_sup (r.numerator_ne_bot hx) r.denominator_ne_bot + have hs := v.multiplicity_sup (s.numerator_ne_bot hx) s.denominator_ne_bot +@@ -203,7 +203,7 @@ lemma ReducedPrincipalIdealData.finitePlace_posLog_eq + (neg_nonpos.mpr (Int.natCast_nonneg _)) + have hA := r.numerator_ne_bot hx + have htop : multiplicity v.asIdeal (⊤ : Ideal (𝓞 K)) = 0 := +- multiplicity_eq_zero.mpr (by ++ _root_.multiplicity_eq_zero_of_not_dvd (by + simpa only [← Ideal.one_eq_top] using v.prime.not_dvd_one) + have hsup := v.multiplicity_sup hA r.denominator_ne_bot + rw [(Ideal.isCoprime_iff_sup_eq).mp r.coprime, htop] at hsup +@@ -319,7 +319,7 @@ lemma denominator_multiplicity_le_minimal + · have hD := (r.zero_normalization hj0).2 + rw [hD] + have htop : multiplicity v.asIdeal (⊤ : Ideal (𝓞 K)) = 0 := +- multiplicity_eq_zero.mpr (by ++ _root_.multiplicity_eq_zero_of_not_dvd (by + simpa only [← Ideal.one_eq_top] using v.prime.not_dvd_one) + rw [htop] + exact Nat.zero_le _ +@@ -327,7 +327,7 @@ lemma denominator_multiplicity_le_minimal + by_cases hD0 : multiplicity v.asIdeal r.denominator = 0 + · omega + have htop : multiplicity v.asIdeal (⊤ : Ideal (𝓞 K)) = 0 := +- multiplicity_eq_zero.mpr (by ++ _root_.multiplicity_eq_zero_of_not_dvd (by + simpa only [← Ideal.one_eq_top] using v.prime.not_dvd_one) + have hsup := v.multiplicity_sup hA r.denominator_ne_bot + rw [(Ideal.isCoprime_iff_sup_eq).mp r.coprime, htop] at hsup +diff --git a/Heights/LatticePointMapTopology.lean b/Heights/LatticePointMapTopology.lean +index 02e6b4e..6362309 100644 +--- a/Heights/LatticePointMapTopology.lean ++++ b/Heights/LatticePointMapTopology.lean +@@ -107,7 +107,7 @@ theorem continuousAt_latticeCurvePointMap_of_mem (τ : ℍ) (z : ℂ) + by_cases hz : z ∈ (periodPairOfUpperHalfPlane τ).lattice + · exact continuousAt_latticeCurvePointMap_of_mem τ z hz + · have hrestrict : Continuous +- ({z : ℂ | z ∉ (periodPairOfUpperHalfPlane τ).lattice}.restrict ++ ({z : ℂ | z ∉ (periodPairOfUpperHalfPlane τ).lattice}.domRestrict + (latticeCurvePointMap τ)) := by + change Continuous (fun w : LatticeComplement τ ↦ latticeCurvePointMap τ w) + apply (continuous_latticeAffineCurvePointMap τ).congr +@@ -116,7 +116,7 @@ theorem continuousAt_latticeCurvePointMap_of_mem (τ : ℍ) (z : ℂ) + exact (latticeAffineCurvePointMap_eq τ w).symm + have hon : ContinuousOn (latticeCurvePointMap τ) + ((periodPairOfUpperHalfPlane τ).lattice : Set ℂ)ᶜ := +- continuousOn_iff_continuous_restrict.mpr hrestrict ++ continuousOn_iff_continuous_domRestrict.mpr hrestrict + exact hon.continuousAt + ((periodPairOfUpperHalfPlane τ).isClosed_lattice.isOpen_compl.mem_nhds hz) + +diff --git a/Heights/ModularJ.lean b/Heights/ModularJ.lean +index b589e96..7b7ef38 100644 +--- a/Heights/ModularJ.lean ++++ b/Heights/ModularJ.lean +@@ -34,12 +34,12 @@ group. This is the reduction needed to move a preimage into the standard + fundamental domain. -/ + theorem modularJ_smul (γ : SL(2, ℤ)) (τ : ℍ) : modularJ (γ • τ) = modularJ τ := by + have hE : ModularForm.E₄ (γ • τ) = denom γ τ ^ (4 : ℤ) * ModularForm.E₄ τ := by +- letI : SlashInvariantFormClass (ModularForm 𝒮ℒ 4) Γ(1) 4 := ++ let : SlashInvariantFormClass (ModularForm 𝒮ℒ 4) Γ(1) 4 := + Gamma_one_coe_eq_SL ▸ inferInstance + exact SlashInvariantForm.slash_action_eqn_SL'' ModularForm.E₄ (mem_Gamma_one γ) τ + have hD : ModularForm.discriminant (γ • τ) = + denom γ τ ^ (12 : ℤ) * ModularForm.discriminant τ := by +- letI : SlashInvariantFormClass (CuspForm 𝒮ℒ 12) Γ(1) 12 := ++ let : SlashInvariantFormClass (CuspForm 𝒮ℒ 12) Γ(1) 12 := + Gamma_one_coe_eq_SL ▸ inferInstance + exact SlashInvariantForm.slash_action_eqn_SL'' CuspForm.discriminant (mem_Gamma_one γ) τ + rw [modularJ, modularJ, hE, hD] +diff --git a/Heights/PeriodPairScaling.lean b/Heights/PeriodPairScaling.lean +index 108bb60..41ec783 100644 +--- a/Heights/PeriodPairScaling.lean ++++ b/Heights/PeriodPairScaling.lean +@@ -167,9 +167,7 @@ private theorem eventually_hasDerivAt_reciprocalX (L : PeriodPair) : + rw [← hval] + exact hi + have hrhs : AnalyticAt ℂ (fun z ↦ 2 * reciprocalY L z) 0 := by +- convert (analyticAt_reciprocalY L).const_smul (c := (2 : ℂ)) using 1 +- ext z +- simp [Pi.smul_apply, smul_eq_mul] ++ exact (analyticAt_reciprocalY L).const_smul (c := (2 : ℂ)) + have hderiv : deriv (reciprocalX L) =ᶠ[𝓝 0] + (fun z ↦ 2 * reciprocalY L z) := + ((analyticAt_reciprocalX L).deriv.frequently_eq_iff_eventually_eq hrhs).mp +diff --git a/Heights/VariableChangeAnalytic.lean b/Heights/VariableChangeAnalytic.lean +index 67518e3..b86819f 100644 +--- a/Heights/VariableChangeAnalytic.lean ++++ b/Heights/VariableChangeAnalytic.lean +@@ -50,8 +50,8 @@ noncomputable def variableChangeAffineAmbientBiholomorph + fun_prop).contMDiff + contMDiff_invFun := (show ContDiff ℂ ω + (variableChangeAffineAmbientEquiv C).symm by +- dsimp [variableChangeAffineAmbientEquiv, +- WeierstrassCurve.VariableChange.inverseX, ++ change ContDiff ℂ ω (fun xy : ℂ × ℂ => (C.inverseX xy.1, C.inverseY xy.1 xy.2)) ++ dsimp [WeierstrassCurve.VariableChange.inverseX, + WeierstrassCurve.VariableChange.inverseY] + fun_prop).contMDiff + +diff --git a/Heights/WeierstrassFiniteAnalytic.lean b/Heights/WeierstrassFiniteAnalytic.lean +index 8833daf..258616d 100644 +--- a/Heights/WeierstrassFiniteAnalytic.lean ++++ b/Heights/WeierstrassFiniteAnalytic.lean +@@ -461,7 +461,7 @@ def complexWeierstrassImplicitYChart + have hright := e.right_inv x.2 + exact congrArg Prod.fst hright)⟩ + have hg : Continuous g := Continuous.subtype_mk hamb _ +- have heq : {x : ℂ | (0, x) ∈ e.target}.restrict inv = g := by ++ have heq : {x : ℂ | (0, x) ∈ e.target}.domRestrict inv = g := by + funext x + apply Subtype.ext + exact complexWeierstrassImplicitYChartInv_coe_of_mem +@@ -699,7 +699,7 @@ def complexWeierstrassImplicitXChart + have hright := e.right_inv y.2 + exact congrArg Prod.fst hright)⟩ + have hg : Continuous g := Continuous.subtype_mk hswap _ +- have heq : {y : ℂ | (0, y) ∈ e.target}.restrict inv = g := by ++ have heq : {y : ℂ | (0, y) ∈ e.target}.domRestrict inv = g := by + funext y + apply Subtype.ext + exact complexWeierstrassImplicitXChartInv_coe_of_mem +diff --git a/Heights/WeierstrassInfinityAnalytic.lean b/Heights/WeierstrassInfinityAnalytic.lean +index 3cf5a37..3fdc1c4 100644 +--- a/Heights/WeierstrassInfinityAnalytic.lean ++++ b/Heights/WeierstrassInfinityAnalytic.lean +@@ -312,7 +312,7 @@ def complexWeierstrassInfinityBranchChart (W : WeierstrassCurve ℂ) : + ⟨e.symm (inc u), by + exact congrArg Prod.fst (e.right_inv u.2)⟩ + have hg : Continuous g := Continuous.subtype_mk hamb _ +- have heq : {u : ℂ | (0, u) ∈ e.target}.restrict inv = g := by ++ have heq : {u : ℂ | (0, u) ∈ e.target}.domRestrict inv = g := by + funext u + apply Subtype.ext + exact complexWeierstrassInfinityChartInv_coe_of_mem W u.1 u.2 +diff --git a/Heights/WeierstrassPrincipalPart.lean b/Heights/WeierstrassPrincipalPart.lean +index cc8d3cc..6254a27 100644 +--- a/Heights/WeierstrassPrincipalPart.lean ++++ b/Heights/WeierstrassPrincipalPart.lean +@@ -187,27 +187,27 @@ theorem tendsto_weierstrass_secant_addX_zero (L : PeriodPair) (a b : ℂ) : + tendsto_const_nhds + have hea : Tendsto (fun z ↦ e z - a) (𝓝[≠] 0) (𝓝 (-a)) := by + convert he.sub ha using 1 +- all_goals ring ++ all_goals ring_nf + have hdb : Tendsto (fun z ↦ d z - b) (𝓝[≠] 0) (𝓝 (-b)) := by + convert hd.sub hb using 1 +- all_goals ring ++ all_goals ring_nf + have hA : Tendsto A (𝓝[≠] 0) (𝓝 1) := by + dsimp [A] + simpa using tendsto_const_nhds.add (hea.mul (hz.pow 2)) + have hC : Tendsto C (𝓝[≠] 0) (𝓝 (-2 * a)) := by + dsimp [C] + convert (hea.const_mul 2).add (hdb.mul hz) using 1 +- all_goals ring ++ all_goals ring_nf + have hD : Tendsto D (𝓝[≠] 0) (𝓝 (-4)) := by + dsimp [D] + convert (hnegfour.add (hdb.mul (hz.pow 3))).sub + ((hea.mul (hz.pow 2)).const_mul 2) using 1 + · funext z + ring +- · ring ++ · ring_nf + have hden : Tendsto (fun z ↦ 4 * A z ^ 2) (𝓝[≠] 0) (𝓝 4) := by + convert hfour.mul (hA.pow 2) using 1 +- all_goals ring ++ all_goals ring_nf + have hfrac : Tendsto (fun z ↦ D z * C z / (4 * A z ^ 2)) + (𝓝[≠] 0) (𝓝 (2 * a)) := by + have h := (hD.mul hC).div hden (by norm_num) +@@ -217,11 +217,11 @@ theorem tendsto_weierstrass_secant_addX_zero (L : PeriodPair) (a b : ℂ) : + filter_upwards with z + simp only [Pi.div_apply] + convert h' using 1 +- ring ++ ring_nf + have hG : Tendsto (fun z ↦ -e z - a + D z * C z / (4 * A z ^ 2)) + (𝓝[≠] 0) (𝓝 a) := by + convert (he.neg.sub ha).add hfrac using 1 +- all_goals ring ++ all_goals ring_nf + apply hG.congr' + have hAne : ∀ᶠ z in 𝓝[≠] (0 : ℂ), A z ≠ 0 := + hA (eventually_ne_nhds one_ne_zero) +@@ -300,11 +300,11 @@ theorem tendsto_weierstrass_secant_addY_zero (L : PeriodPair) (a b : ℂ) : + have h := hc.tendsto.comp hzed + convert h using 1 + · rfl +- · ring ++ · ring_nf + have hN : Tendsto N (𝓝[≠] 0) (𝓝 0) := by + dsimp [N] + convert ((hE.const_mul (-24)).sub (hd.const_mul 8)).add (hz.mul hS) using 1 +- all_goals ring ++ all_goals ring_nf + have hA : Tendsto A (𝓝[≠] 0) (𝓝 1) := by + dsimp [A] + simpa using tendsto_const_nhds.add +@@ -313,11 +313,8 @@ theorem tendsto_weierstrass_secant_addY_zero (L : PeriodPair) (a b : ℂ) : + simpa using (tendsto_const_nhds.mul (hA.pow 3)) + have hquot : Tendsto (fun z ↦ N z / (8 * A z ^ 3)) + (𝓝[≠] 0) (𝓝 0) := by +- have h := hN.div hden (by norm_num) +- convert h using 1 +- · funext z +- simp only [Pi.div_apply] +- · norm_num ++ change Tendsto (N / (fun z => 8 * A z ^ 3)) (𝓝[≠] 0) (𝓝 0) ++ simpa only [zero_div] using hN.div hden (by norm_num) + have hfinal : Tendsto (fun z ↦ b / 2 + N z / (8 * A z ^ 3)) + (𝓝[≠] 0) (𝓝 (b / 2)) := by + simpa using tendsto_const_nhds.add hquot +diff --git a/Heights/WeierstrassSurjectivity.lean b/Heights/WeierstrassSurjectivity.lean +index 37b20a6..72b3cfc 100644 +--- a/Heights/WeierstrassSurjectivity.lean ++++ b/Heights/WeierstrassSurjectivity.lean +@@ -66,7 +66,7 @@ private theorem reciprocalWeierstrassSub_analyticAt (L : PeriodPair) (a z : ℂ) + apply hraw.congr + filter_upwards [L.isClosed_lattice.isOpen_compl.mem_nhds hz] with w hw + have hw' : w ∉ L.lattice := hw +- rw [reciprocalWeierstrassSub, if_neg hw', Pi.inv_apply, Pi.sub_apply] ++ rw [reciprocalWeierstrassSub, ite_eq_right hw', Pi.inv_apply, Pi.sub_apply] + + private theorem reciprocalWeierstrassSub_add_lattice (L : PeriodPair) (a z : ℂ) + (l : L.lattice) : +@@ -97,7 +97,7 @@ theorem exists_notMem_lattice_weierstrassP_eq (L : PeriodPair) (a : ℂ) : + let z₀ : ℂ := L.ω₁ / 2 + have hz₀ : z₀ ∉ L.lattice := L.ω₁_div_two_notMem_lattice + have hne : reciprocalWeierstrassSub L a z₀ ≠ 0 := by +- rw [reciprocalWeierstrassSub, if_neg hz₀] ++ rw [reciprocalWeierstrassSub, ite_eq_right hz₀] + exact inv_ne_zero (sub_ne_zero.mpr (h z₀ hz₀)) + apply hne + exact (hdiff.apply_eq_apply_of_bounded hcompact.isBounded z₀ 0).trans (by +diff --git a/lake-manifest.json b/lake-manifest.json +index 5d54dbc..67ccad8 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,7 +1,17 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/lana-agents/belyi.git", ++ [{"url": "https://github.com/lana-agents/heights.git", ++ "type": "git", ++ "subDir": null, ++ "scope": "", ++ "rev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", ++ "name": "heights", ++ "manifestFile": "lake-manifest.json", ++ "inputRev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", ++ "inherited": true, ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/belyi.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -11,31 +21,31 @@ + "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/mathlib4", ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/lana-agents/oka.git", + "type": "git", + "subDir": null, + "scope": "", +- "rev": "da228a2cf9671aaba08ddc96274d75e098b28f67", ++ "rev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", + "name": "oka", + "manifestFile": "lake-manifest.json", +- "inputRev": "da228a2cf9671aaba08ddc96274d75e098b28f67", ++ "inputRev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -65,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -75,7 +85,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -85,7 +95,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -95,7 +105,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -105,10 +115,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "heights", +diff --git a/lakefile.toml b/lakefile.toml +index a8e48a6..4d39ef8 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["Heights", "Challenge", "Solution"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -11,8 +13,8 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + # Curves over number fields as function fields (Belyi.CurveField), for the height machine on + # curves (GenEll height theory, branch wp-height-theory). +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f49..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/iut-lean4341.patch b/lean/patches/iut-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..d2f1725902299577c0f8507857ff45ca70967dea --- /dev/null +++ b/lean/patches/iut-lean4341.patch @@ -0,0 +1,1164 @@ +diff --git a/Iut/Anabelian/Genuine/Homs.lean b/Iut/Anabelian/Genuine/Homs.lean +index 7de5889..2756b13 100644 +--- a/Iut/Anabelian/Genuine/Homs.lean ++++ b/Iut/Anabelian/Genuine/Homs.lean +@@ -418,10 +418,8 @@ lemma eIdx_tower {F L L' : IntermediateField (xLine E) (Ω E)} [FiniteDimensiona + lemma comap_isMaximal {F L : IntermediateField (xLine E) (Ω E)} (h : F ≤ L) + (w : Ideal (coordRing k (xG E) L)) [hw : w.IsMaximal] : + (w.comap (ringMap (xG E) h)).IsMaximal := by +- letI := algRing (xG E) h +- haveI : Algebra.IsIntegral (coordRing k (xG E) F) (coordRing k (xG E) L) := +- ⟨ringMap_isIntegral _ h⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal w ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap (xG E) h).toRingHom (ringMap_isIntegral _ h) w + + set_option maxHeartbeats 1000000 in + set_option synthInstance.maxHeartbeats 400000 in +diff --git a/Iut/Anabelian/Genuine/Punctured.lean b/Iut/Anabelian/Genuine/Punctured.lean +index 2810b7d..4106cbe 100644 +--- a/Iut/Anabelian/Genuine/Punctured.lean ++++ b/Iut/Anabelian/Genuine/Punctured.lean +@@ -176,7 +176,7 @@ lemma bijective_algebraMap_coarse : + rw [← hz] at h1 + haveI : IsScalarTower (A₀ k (xG E)) (K₀ k (xG E)) (Ω E) := + IsScalarTower.of_algebraMap_eq fun _ => rfl +- exact (isIntegral_algebraMap_iff (algebraMap (K₀ k (xG E)) (Ω E)).injective).mp h1 ++ exact isIntegral_algebraMap_iff.mp h1 + obtain ⟨a, ha⟩ := (IsIntegrallyClosed.isIntegral_iff (R := A₀ k (xG E)) + (K := K₀ k (xG E))).mp hzint + refine ⟨a, Subtype.ext (Subtype.ext ?_)⟩ +diff --git a/Iut/Anabelian/Model.lean b/Iut/Anabelian/Model.lean +index 4145caa..3da2b3d 100644 +--- a/Iut/Anabelian/Model.lean ++++ b/Iut/Anabelian/Model.lean +@@ -149,7 +149,7 @@ lemma pointMap_mem_torsion (f : k →+* K) (X : Orbicurve k) {P : X.E.toAffine.P + /-- The map on torsion induced by base change. -/ + def mapTorsion (f : k →+* K) (X : Orbicurve k) : + ↥X.torsion →+ ↥(X.baseChange f).torsion := +- ((pointMap X.E f).restrict X.torsion).codRestrict _ fun P => by ++ ((pointMap X.E f).domRestrict X.torsion).codRestrict _ fun P => by + exact X.pointMap_mem_torsion f P.2 + + @[simp] lemma coe_mapTorsion (f : k →+* K) (X : Orbicurve k) (P : ↥X.torsion) : +diff --git a/Iut/Anabelian/Torsion.lean b/Iut/Anabelian/Torsion.lean +index df13fd4..23c1d3d 100644 +--- a/Iut/Anabelian/Torsion.lean ++++ b/Iut/Anabelian/Torsion.lean +@@ -93,7 +93,7 @@ lemma mem_TK_of_bcK {R : P.EK.toAffine.Point} (hR : P.bcK R ∈ P.TFbar) : R ∈ + + /-- **The ℓ-torsion is rational over `K`**: `E(K)[ℓ] ≃ E(F̄)[ℓ]`. -/ + def torsionEquiv : ↥P.TK ≃+ ↥P.TFbar := +- AddEquiv.ofBijective (P.bcK.restrict P.TK |>.codRestrict _ fun R => P.bcK_mem_TFbar R.2) ++ AddEquiv.ofBijective (P.bcK.domRestrict P.TK |>.codRestrict _ fun R => P.bcK_mem_TFbar R.2) + ⟨fun R R' h => Subtype.ext (P.bcK_injective (congrArg Subtype.val h)), + fun Q => by + obtain ⟨R, hR⟩ := P.exists_bcK_eq Q.1 Q.2 +@@ -150,7 +150,7 @@ lemma galK_mem_TK (σ : ↥P.torsionField ≃ₐ[F] ↥P.torsionField) {R : P.EK + + /-- The action of `Gal(K/F)` on the ℓ-torsion. -/ + def galTK (σ : ↥P.torsionField ≃ₐ[F] ↥P.torsionField) : ↥P.TK →+ ↥P.TK := +- (P.galK σ).restrict P.TK |>.codRestrict _ fun R => P.galK_mem_TK σ R.2 ++ (P.galK σ).domRestrict P.TK |>.codRestrict _ fun R => P.galK_mem_TK σ R.2 + + @[simp] lemma coe_galTK (σ : ↥P.torsionField ≃ₐ[F] ↥P.torsionField) (R : ↥P.TK) : + (P.galTK σ R : P.EK.toAffine.Point) = P.galK σ R := rfl +diff --git a/Iut/Concrete/LocalConstruct/ArchLogShell.lean b/Iut/Concrete/LocalConstruct/ArchLogShell.lean +index e078189..aa5d12e 100644 +--- a/Iut/Concrete/LocalConstruct/ArchLogShell.lean ++++ b/Iut/Concrete/LocalConstruct/ArchLogShell.lean +@@ -140,7 +140,7 @@ theorem archNorm_mapAlgHom_le (σ : ∀ j, ArchFactor K (c j) ≃ₐ[ℝ] ArchFa + refine (ContinuousLinearMap.le_opNorm _ _).trans ?_ + refine mul_le_of_le_one_left (norm_nonneg _) ?_ + refine (PiTensorProduct.opNorm_mapL _).trans ?_ +- exact Finset.prod_le_one (fun j _ => norm_nonneg _) fun j _ => norm_archAutCLM_le (c j) (σ j) ++ exact Finset.prod_le_one₀ (fun j _ => norm_nonneg _) fun j _ => norm_archAutCLM_le (c j) (σ j) + + /-- **IUT IV, Proposition 1.5(iii)**: the indeterminacy automorphisms preserve `B_I`. -/ + theorem mapAlgHom_image_archIntegral_subset +diff --git a/Iut/Concrete/LocalConstruct/Haar.lean b/Iut/Concrete/LocalConstruct/Haar.lean +index 8385d1b..2bf7745 100644 +--- a/Iut/Concrete/LocalConstruct/Haar.lean ++++ b/Iut/Concrete/LocalConstruct/Haar.lean +@@ -84,7 +84,7 @@ lemma closedBall_eq_iUnion_padicCoset : + obtain ⟨y, hy⟩ := hmem + have hy' : (p : ℚ_[p]) * x - (z.zmodRepr : ℚ_[p]) = (p : ℚ_[p]) * (y : ℚ_[p]) := by + have := congrArg (fun w : ℤ_[p] => (w : ℚ_[p])) hy +- simpa [z] using this ++ exact this + have : x - (z.zmodRepr : ℚ_[p]) / p = (y : ℚ_[p]) := by + field_simp + linear_combination hy' +diff --git a/Iut/Concrete/LocalConstruct/Integral.lean b/Iut/Concrete/LocalConstruct/Integral.lean +index 77cbfda..cf2a52d 100644 +--- a/Iut/Concrete/LocalConstruct/Integral.lean ++++ b/Iut/Concrete/LocalConstruct/Integral.lean +@@ -318,7 +318,7 @@ lemma exists_norm_tprodIntegral_le : + rw [Module.Basis.equivFun_apply] + unfold packetBasis tprodIntegral + rw [Basis.piTensorProduct_repr_tprod_apply, norm_prod] +- exact Finset.prod_le_prod (fun j _ => norm_nonneg _) fun j _ => hC j _ (a j).2 _ ++ exact Finset.prod_le_prod₀ (fun j _ => norm_nonneg _) fun j _ => hC j _ (a j).2 _ + + /-- **`R_I` is bounded.** -/ + lemma exists_order_subset_closedBall : +diff --git a/Iut/Concrete/LocalConstruct/LogShell.lean b/Iut/Concrete/LocalConstruct/LogShell.lean +index b0dfa96..88fac56 100644 +--- a/Iut/Concrete/LocalConstruct/LogShell.lean ++++ b/Iut/Concrete/LocalConstruct/LogShell.lean +@@ -404,7 +404,7 @@ lemma exists_norm_logShellSet_le : + rw [Module.Basis.equivFun_apply] + unfold packetBasis + rw [Basis.piTensorProduct_repr_tprod_apply, norm_prod] +- exact Finset.prod_le_prod (fun j _ => norm_nonneg _) fun j _ => hC j _ (a j).2 _ ++ exact Finset.prod_le_prod₀ (fun j _ => norm_nonneg _) fun j _ => hC j _ (a j).2 _ + + /-- The products of elements of `(R_I)^∼` with elementary tensors of elements of the factor + log-shells are bounded: `(R_I)^∼` is compact and the elementary tensors are bounded. -/ +diff --git a/Iut/Concrete/ModEllRepConstruct.lean b/Iut/Concrete/ModEllRepConstruct.lean +index 57f8a8e..3a0afaa 100644 +--- a/Iut/Concrete/ModEllRepConstruct.lean ++++ b/Iut/Concrete/ModEllRepConstruct.lean +@@ -53,7 +53,7 @@ endomorphism of the torsion subgroup. -/ + noncomputable def galTorsionHom (n : ℕ) (σ : Fbar ≃ₐ[F] Fbar) : + AddSubgroup.torsionBy (Affine.Point (Affine.baseChange E Fbar)) n →+ + AddSubgroup.torsionBy (Affine.Point (Affine.baseChange E Fbar)) n := +- ((galPointMap F E Fbar σ).restrict ++ ((galPointMap F E Fbar σ).domRestrict + (AddSubgroup.torsionBy (Affine.Point (Affine.baseChange E Fbar)) n)).codRestrict + (AddSubgroup.torsionBy (Affine.Point (Affine.baseChange E Fbar)) n) + (fun P => galPointMap_torsionBy F E Fbar σ P.2) +diff --git a/Iut/Concrete/ModEllRepGalois.lean b/Iut/Concrete/ModEllRepGalois.lean +index 7272069..34b4939 100644 +--- a/Iut/Concrete/ModEllRepGalois.lean ++++ b/Iut/Concrete/ModEllRepGalois.lean +@@ -98,7 +98,7 @@ lemma mem_TK_of_bcK {P : R.EK.toAffine.Point} (hP : R.bcK P ∈ TFbar C ℓ) : P + + /-- **The `ℓ`-torsion is rational over `K`**: `E(K)[ℓ] ≃ E(F̄)[ℓ]`. -/ + def torsionEquiv : ↥R.TK ≃+ ↥(TFbar C ℓ) := +- AddEquiv.ofBijective (R.bcK.restrict R.TK |>.codRestrict _ fun P => R.bcK_mem_TFbar P.2) ++ AddEquiv.ofBijective (R.bcK.domRestrict R.TK |>.codRestrict _ fun P => R.bcK_mem_TFbar P.2) + ⟨fun P P' h => Subtype.ext (R.bcK_injective (congrArg Subtype.val h)), + fun Q => by + obtain ⟨P, hP⟩ := R.exists_bcK_eq Q.1 Q.2 +diff --git a/Iut/Concrete/SL2Image.lean b/Iut/Concrete/SL2Image.lean +index a58f023..6a75976 100644 +--- a/Iut/Concrete/SL2Image.lean ++++ b/Iut/Concrete/SL2Image.lean +@@ -142,7 +142,7 @@ lemma card_torsion_curveKw_ge (w' : FinitePlace ↥R.torsionField) + [Finite ↥(TateStructure.torsion ℓ (curveKw C.E R.torsionField w'))] : + ℓ * ℓ ≤ Nat.card ↥(TateStructure.torsion ℓ (curveKw C.E R.torsionField w')) := by + let f : ↥R.TK →+ ↥(TateStructure.torsion ℓ (curveKw C.E R.torsionField w')) := +- ((pointMap (curveK C.E R.torsionField) (emb R.torsionField w')).restrict R.TK).codRestrict _ ++ ((pointMap (curveK C.E R.torsionField) (emb R.torsionField w')).domRestrict R.TK).codRestrict _ + fun P => by + rw [AddSubgroup.torsionBy.nsmul_iff] + have hP := AddSubgroup.torsionBy.nsmul_iff.mp P.2 +diff --git a/Iut/Cor312/ThetaData/PlacesOver.lean b/Iut/Cor312/ThetaData/PlacesOver.lean +index 54f5d7e..b81f51c 100644 +--- a/Iut/Cor312/ThetaData/PlacesOver.lean ++++ b/Iut/Cor312/ThetaData/PlacesOver.lean +@@ -45,14 +45,16 @@ lemma algebraMap_ringOfIntegers_injective : + /-- **Every finite place of `k` has a finite place of `K` over it.** -/ + theorem FinitePlace.exists_liesOver (v : FinitePlace k) : + ∃ w : FinitePlace K, FinitePlace.LiesOver w v := by ++ have : FaithfulSMul (𝓞 k) (𝓞 K) := ++ (faithfulSMul_iff_algebraMap_injective (𝓞 k) (𝓞 K)).mpr algebraMap_ringOfIntegers_injective + haveI : v.maximalIdeal.asIdeal.IsPrime := v.maximalIdeal.isPrime + obtain ⟨Q, -, hQ, hQv⟩ := Ideal.exists_ideal_over_prime_of_isIntegral (S := 𝓞 K) + v.maximalIdeal.asIdeal ⊥ (by +- rw [Ideal.comap_bot_of_injective _ algebraMap_ringOfIntegers_injective] ++ rw [Ideal.under_bot] + exact bot_le) + have hQne : Q ≠ ⊥ := by + rintro rfl +- rw [Ideal.comap_bot_of_injective _ algebraMap_ringOfIntegers_injective] at hQv ++ rw [Ideal.under_bot] at hQv + exact v.maximalIdeal.ne_bot hQv.symm + refine ⟨FinitePlace.mk ⟨Q, hQ, hQne⟩, ?_⟩ + unfold FinitePlace.LiesOver +@@ -138,10 +140,13 @@ lemma algebraMap_intClosure_injective : + theorem exists_prime_over (w : FinitePlace K) : + ∃ Q : Ideal (intClosure K Fbar), Q.IsPrime ∧ + Q.comap (algebraMap (𝓞 K) (intClosure K Fbar)) = w.maximalIdeal.asIdeal := by ++ have : FaithfulSMul (𝓞 K) (intClosure K Fbar) := ++ (faithfulSMul_iff_algebraMap_injective (𝓞 K) (intClosure K Fbar)).mpr ++ (algebraMap_intClosure_injective K Fbar) + haveI : w.maximalIdeal.asIdeal.IsPrime := w.maximalIdeal.isPrime + obtain ⟨Q, -, hQ, hQw⟩ := Ideal.exists_ideal_over_prime_of_isIntegral + (S := intClosure K Fbar) w.maximalIdeal.asIdeal ⊥ (by +- rw [Ideal.comap_bot_of_injective _ (algebraMap_intClosure_injective K Fbar)] ++ rw [Ideal.under_bot] + exact bot_le) + exact ⟨Q, hQ, hQw⟩ + +diff --git a/Iut/Cor312/ThetaData/TateStructureTransport.lean b/Iut/Cor312/ThetaData/TateStructureTransport.lean +index 0f98d1a..904c497 100644 +--- a/Iut/Cor312/ThetaData/TateStructureTransport.lean ++++ b/Iut/Cor312/ThetaData/TateStructureTransport.lean +@@ -132,7 +132,9 @@ def baseChange (S : TateStructure E) : TateStructure (E.map (algebraMap k k')) w + (Additive.ofMul (QuotientGroup.mk (unitsEquiv hbij u))) = + Additive.ofMul (QuotientGroup.mk u) := by + rw [← quotEquiv_mk] +- exact (MulEquiv.toAdditive (quotEquiv hbij S.t)).symm_apply_apply _ ++ change Additive.ofMul ++ ((quotEquiv hbij S.t).symm ((quotEquiv hbij S.t) (QuotientGroup.mk u))) = _ ++ rw [MulEquiv.symm_apply_apply] + simp only [AddEquiv.trans_apply] + rw [h1, pointMapEquiv_apply, xCoord_pointMap, S.iso_x u hu, S.t.algebraMap_X k'] + rfl +@@ -143,7 +145,9 @@ def baseChange (S : TateStructure E) : TateStructure (E.map (algebraMap k k')) w + (Additive.ofMul (QuotientGroup.mk (unitsEquiv hbij u))) = + Additive.ofMul (QuotientGroup.mk u) := by + rw [← quotEquiv_mk] +- exact (MulEquiv.toAdditive (quotEquiv hbij S.t)).symm_apply_apply _ ++ change Additive.ofMul ++ ((quotEquiv hbij S.t).symm ((quotEquiv hbij S.t) (QuotientGroup.mk u))) = _ ++ rw [MulEquiv.symm_apply_apply] + simp only [AddEquiv.trans_apply] + rw [h1, pointMapEquiv_apply, yCoord_pointMap, S.iso_y u hu, S.t.algebraMap_Y k'] + rfl +@@ -163,7 +167,9 @@ lemma baseChange_ofUnit (u : kˣ) : + (Additive.ofMul (QuotientGroup.mk (unitsEquiv hbij u))) = + Additive.ofMul (QuotientGroup.mk u) := by + rw [← quotEquiv_mk] +- exact (MulEquiv.toAdditive (quotEquiv hbij S.t)).symm_apply_apply _ ++ change Additive.ofMul ++ ((quotEquiv hbij S.t).symm ((quotEquiv hbij S.t) (QuotientGroup.mk u))) = _ ++ rw [MulEquiv.symm_apply_apply] + simp only [AddEquiv.trans_apply] + rw [h1] + rfl +diff --git a/Iut/Torsion/EDS.lean b/Iut/Torsion/EDS.lean +index 0785677..2caf952 100644 +--- a/Iut/Torsion/EDS.lean ++++ b/Iut/Torsion/EDS.lean +@@ -33,10 +33,11 @@ namespace Iut.Torsion + + open WeierstrassCurve WeierstrassCurve.Affine Polynomial + +-open scoped Classical + + variable {F : Type*} [Field F] {W : Affine F} + ++noncomputable local instance : DecidableEq F := Classical.decEq F ++ + /-! ### The sequence `ψₙ(P)` -/ + + /-- The value `ψₙ(x, y)` of the `n`-division polynomial at `(x, y)`, as the normalised EDS with +@@ -155,7 +156,7 @@ theorem equation_iff₀ (x y : F) : + W.Equation x y ↔ y ^ 2 = x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆ := by + rw [equation_iff, ha₁, ha₃]; simp + +-omit [NeZero (2 : F)] in ++omit [NeZero (2 : F)] ha₃ in + theorem addX_eq (x₁ x₂ ℓ : F) : W.addX x₁ x₂ ℓ = ℓ ^ 2 - W.a₂ - x₁ - x₂ := by + simp [addX, ha₁] + +@@ -164,7 +165,7 @@ theorem addY_eq (x₁ x₂ y₁ ℓ : F) : + W.addY x₁ x₂ y₁ ℓ = -(ℓ * ((ℓ ^ 2 - W.a₂ - x₁ - x₂) - x₁) + y₁) := by + simp [addY, negY, negAddY, addX, ha₁, ha₃] + +-omit [NeZero (2 : F)] in ++omit [NeZero (2 : F)] ha₁ ha₃ in + theorem slope_mul_of_X_ne {x₁ x₂ : F} (y₁ y₂ : F) (hx : x₁ ≠ x₂) : + W.slope x₁ x₂ y₁ y₂ * (x₁ - x₂) = y₁ - y₂ := by + rw [slope_of_X_ne hx, div_mul_cancel₀ _ (sub_ne_zero.mpr hx)] +@@ -223,6 +224,7 @@ def Good (n : ℕ) : Prop := + + variable {h} + ++omit [NeZero (2 : F)] in + theorem Good.smul_eq_zero_iff {n : ℕ} (hg : Good h n) : + n • Point.some x y h = 0 ↔ eds W x y n = 0 := by + refine ⟨fun h0 => ?_, hg.1⟩ +@@ -231,24 +233,29 @@ theorem Good.smul_eq_zero_iff {n : ℕ} (hg : Good h n) : + rw [hn] at h0 + exact Point.some_ne_zero hXY h0 + ++omit [NeZero (2 : F)] in + theorem Good.eds_ne_zero {n : ℕ} (hg : Good h n) (hn : n • Point.some x y h ≠ 0) : + eds W x y n ≠ 0 := + fun h0 => hn (hg.1 h0) + ++omit [NeZero (2 : F)] in + theorem Good.eds_eq_zero {n : ℕ} (hg : Good h n) (hn : n • Point.some x y h = 0) : + eds W x y n = 0 := + hg.smul_eq_zero_iff.mp hn + + variable (h) + ++omit [NeZero (2 : F)] in + theorem good_zero : Good h 0 := by + refine ⟨fun _ => zero_smul ℕ _, fun h0 => absurd (by simp) h0⟩ + ++omit [NeZero (2 : F)] in + theorem good_one : Good h 1 := by + refine ⟨fun h0 => absurd h0 (by simp), fun _ => ⟨x, y, h, one_smul ℕ _, by simp, by simp⟩⟩ + + include ha₁ ha₃ + ++omit [NeZero (2 : F)] in + theorem hQ_of (hXY : W.Nonsingular x y) : + y ^ 2 = x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆ := + (equation_iff₀ ha₁ ha₃ x y).mp hXY.1 +@@ -267,7 +274,7 @@ theorem good_two (hy : y ≠ 0) : Good h 2 := by + have hI2 := Ident.double_X (hQ_of ha₁ ha₃ h) hμ hy + have hI3 := Ident.double_Y (hQ_of ha₁ ha₃ h) hμ hy + refine ⟨_, _, _, two_smul_eq ha₁ ha₃ h hy, ?_, ?_⟩ +- · rw [addX_eq ha₁ ha₃] ++ · rw [addX_eq ha₁] + simp only [Nat.cast_ofNat, eds_two, Int.reduceAdd, eds_three, Int.reduceSub, eds_one, + Ψ₃_eval ha₁ ha₃] + linear_combination hI2 +@@ -281,7 +288,7 @@ theorem two_smul_X (hy : y ≠ 0) : + W.addX x x (W.slope x x y y) * (2 * y) ^ 2 = x * (2 * y) ^ 2 - W.Ψ₃.eval x := by + have hμ := slope_mul_of_Y_ne ha₁ ha₃ (x₁ := x) hy + have hI2 := Ident.double_X (hQ_of ha₁ ha₃ h) hμ hy +- rw [addX_eq ha₁ ha₃, Ψ₃_eval ha₁ ha₃] ++ rw [addX_eq ha₁, Ψ₃_eval ha₁ ha₃] + linear_combination hI2 + + include h in +@@ -328,7 +335,7 @@ theorem good_three (hy : y ≠ 0) : Good h 3 := by + intro hX + apply hne + rw [← hc, hX, sub_self, zero_mul] +- have hp : W.slope X₂ x Y₂ y * (X₂ - x) = Y₂ - y := slope_mul_of_X_ne ha₁ ha₃ Y₂ y hXx ++ have hp : W.slope X₂ x Y₂ y * (X₂ - x) = Y₂ - y := slope_mul_of_X_ne Y₂ y hXx + have h3P : (3 : ℕ) • Point.some x y h = + Point.some (W.addX X₂ x (W.slope X₂ x Y₂ y)) (W.addY X₂ x Y₂ (W.slope X₂ x Y₂ y)) + (nonsingular_add h₂ h fun hxy => hXx hxy.1) := by +@@ -341,7 +348,7 @@ theorem good_three (hy : y ≠ 0) : Good h 3 := by + rw [← h2P, two_nsmul, add_neg_cancel_right] + rw [Point.neg_some, Point.add_of_X_ne hXx] at hsub + have hsubX : W.addX X₂ x (W.slope X₂ x Y₂ (W.negY x y)) = x := (Point.some.inj hsub).1 +- rw [addX_eq ha₁ ha₃] at hsubX ++ rw [addX_eq ha₁] at hsubX + have hD := Ident.chord_diff (a₂ := W.a₂) hXx hp hm + rw [hsubX] at hD + set lp := W.slope X₂ x Y₂ y with hlp +@@ -349,16 +356,16 @@ theorem good_three (hy : y ≠ 0) : Good h 3 := by + · -- the `x`-coordinate + have e4 : eds W x y (3 + 1) = W.preΨ₄.eval x * (2 * y) := by norm_num + have e2 : eds W x y (3 - 1) = 2 * y := by norm_num +- rw [Nat.cast_ofNat, eds_three, e4, e2, addX_eq ha₁ ha₃, ← hc, ← hY₂] ++ rw [Nat.cast_ofNat, eds_three, e4, e2, addX_eq ha₁, ← hc, ← hY₂] + linear_combination (-16 * y ^ 4) * hD + · -- the `y`-coordinate + have hQ₂ := hQ_of ha₁ ha₃ h₂ + have hT : Y₂ * (2 * y) = -2 * y ^ 2 - (3 * x ^ 2 + 2 * W.a₂ * x + W.a₄) * (X₂ - x) := by +- rw [hY₂def, hX₂def, addY_eq ha₁ ha₃, addX_eq ha₁ ha₃] ++ rw [hY₂def, hX₂def, addY_eq ha₁ ha₃, addX_eq ha₁] + linear_combination (-(μ ^ 2 - W.a₂ - x - x - x)) * hμ + have hD2 : X₂ * (4 * y ^ 2) = + (3 * x ^ 2 + 2 * W.a₂ * x + W.a₄) ^ 2 - 4 * y ^ 2 * (W.a₂ + 2 * x) := by +- rw [hX₂def, addX_eq ha₁ ha₃] ++ rw [hX₂def, addX_eq ha₁] + linear_combination (μ * (2 * y) + (3 * x ^ 2 + 2 * W.a₂ * x + W.a₄)) * hμ + have hG3 := Ident.three_Y (hQ_of ha₁ ha₃ h) hQ₂ hT hD2 hp hy + have hc3 : edsC W x y 3 = (2 * y) * (W.preΨ₄.eval x * (2 * y) ^ 4 - (W.Ψ₃.eval x) ^ 3) - +@@ -374,21 +381,22 @@ theorem good_three (hy : y ≠ 0) : Good h 3 := by + + /-! ### The even step -/ + +-omit ha₁ ha₃ in ++omit [NeZero (2 : F)] ha₁ ha₃ in + /-- `Good n` when `eₙ = 0` and `n • P = 0`. -/ + theorem good_of_eq_zero {n : ℕ} (h0 : eds W x y n = 0) (hn : n • Point.some x y h = 0) : + Good h n := + ⟨fun _ => hn, fun hne => absurd h0 hne⟩ + +-omit ha₁ ha₃ in ++omit [NeZero (2 : F)] ha₁ ha₃ in + theorem smul_succ (k : ℕ) : (k + 1) • Point.some x y h = k • Point.some x y h + Point.some x y h := + succ_nsmul _ _ + +-omit ha₁ ha₃ in ++omit [NeZero (2 : F)] ha₁ ha₃ in + theorem smul_pred {k : ℕ} (hk : 1 ≤ k) : + (k - 1) • Point.some x y h = k • Point.some x y h - Point.some x y h := by + conv_rhs => rw [← Nat.sub_add_cancel hk, succ_nsmul, add_sub_cancel_right] + ++omit [NeZero (2 : F)] ha₁ ha₃ in + /-- Coordinates of `Q + P` for `X ≠ x`. -/ + theorem add_eq_of_X_ne {X Y : F} (hQ : W.Nonsingular X Y) (hX : X ≠ x) : + Point.some X Y hQ + Point.some x y h = +@@ -396,6 +404,7 @@ theorem add_eq_of_X_ne {X Y : F} (hQ : W.Nonsingular X Y) (hX : X ≠ x) : + (nonsingular_add hQ h fun hxy => hX hxy.1) := + Point.add_of_X_ne hX + ++omit [NeZero (2 : F)] ha₁ ha₃ in + /-- Coordinates of `Q − P` for `X ≠ x`. -/ + theorem sub_eq_of_X_ne {X Y : F} (hQ : W.Nonsingular X Y) (hX : X ≠ x) : + Point.some X Y hQ - Point.some x y h = +@@ -404,12 +413,14 @@ theorem sub_eq_of_X_ne {X Y : F} (hQ : W.Nonsingular X Y) (hX : X ≠ x) : + (nonsingular_add hQ ((nonsingular_neg ..).mpr h) fun hxy => hX hxy.1) := by + rw [sub_eq_add_neg, Point.neg_some, Point.add_of_X_ne hX] + ++omit [NeZero (2 : F)] in + /-- The slope of the chord through `Q` and `−P`. -/ + theorem slope_neg_mul {X Y : F} (hX : X ≠ x) : + W.slope X x Y (W.negY x y) * (X - x) = Y + y := by + rw [slope_of_X_ne hX, negY_eq ha₁ ha₃, div_mul_cancel₀ _ (sub_ne_zero.mpr hX)] + ring + ++omit [NeZero (2 : F)] ha₁ ha₃ in + /-- If `Q = m • P = (X, Y)` with `(m − 1) • P ≠ 0` and `(m + 1) • P ≠ 0`, then `X ≠ x`. -/ + theorem X_ne_of_smul {m : ℕ} (hm : 1 ≤ m) {X Y : F} {hQ : W.Nonsingular X Y} + (hmP : m • Point.some x y h = Point.some X Y hQ) +@@ -507,7 +518,7 @@ theorem good_even (hy : y ≠ 0) (m : ℕ) (hm : 2 ≤ m) + 2 * (-(μ * ((μ ^ 2 - W.a₂ - X - X) - X) + Y)) * eds W x y (2 * m) ^ 3 = + edsC W x y (2 * m) by + refine ⟨fun h0 => absurd h0 (by rwa [hcast]), fun _ => ⟨_, _, _, h2Q, ?_, ?_⟩⟩ +- · rw [hcast, addX_eq ha₁ ha₃]; exact key.1 ++ · rw [hcast, addX_eq ha₁]; exact key.1 + · rw [hcast, addY_eq ha₁ ha₃]; exact key.2 + have hc : (x - x₂) * (2 * y) ^ 2 = W.Ψ₃.eval x := by linear_combination -hX₂ + -- abbreviations +@@ -547,7 +558,7 @@ theorem good_even (hy : y ≠ 0) (m : ℕ) (hm : 2 ≤ m) + rw [hsmul, hmP, hQP0, smul_neg, hn2P] + rw [h2Q] at h2Q' + obtain ⟨hxq, hyq⟩ := Point.some.inj h2Q' +- rw [addX_eq ha₁ ha₃] at hxq ++ rw [addX_eq ha₁] at hxq + rw [addY_eq ha₁ ha₃] at hyq + rw [hyq, hxq, hny₂] + -- the sequence +@@ -593,7 +604,7 @@ theorem good_even (hy : y ≠ 0) (m : ℕ) (hm : 2 ≤ m) + rw [hsmul, hmP, hQP, h2P] + rw [h2Q] at h2Q' + obtain ⟨hxq, hyq⟩ := Point.some.inj h2Q' +- rw [addX_eq ha₁ ha₃] at hxq ++ rw [addX_eq ha₁] at hxq + rw [addY_eq ha₁ ha₃] at hyq + rw [hyq, hxq] + rw [hem1] at r_odd1 r_odd2 r_cm +@@ -631,18 +642,18 @@ theorem good_even (hy : y ≠ 0) (m : ℕ) (hm : 2 ≤ m) + obtain ⟨X', Y', h', hh, -, -⟩ := g₃.2 hep + rw [hh] at h0 + exact Point.some_ne_zero h' h0 +- have hXx : X ≠ x := X_ne_of_smul ha₁ ha₃ h (by omega) hmP hmm0 hpp0 ++ have hXx : X ≠ x := X_ne_of_smul h (by omega) hmP hmm0 hpp0 + obtain ⟨Xp, Yp, hQp, hpP, hXp, hYp⟩ := g₃.2 hep + obtain ⟨Xm, Ym, hQm, hmmP, hXm, hYm⟩ := g₁.2 hem1 + have hpP' := hpP +- rw [smul_succ h, hmP, add_eq_of_X_ne ha₁ ha₃ h hQ hXx] at hpP' ++ rw [smul_succ h, hmP, add_eq_of_X_ne h hQ hXx] at hpP' + obtain ⟨hXp', hYp'⟩ := Point.some.inj hpP' + have hmmP' := hmmP +- rw [smul_pred h (by omega), hmP, sub_eq_of_X_ne ha₁ ha₃ h hQ hXx] at hmmP' ++ rw [smul_pred h (by omega), hmP, sub_eq_of_X_ne h hQ hXx] at hmmP' + obtain ⟨hXm', hYm'⟩ := Point.some.inj hmmP' +- rw [addX_eq ha₁ ha₃] at hXp' hXm' ++ rw [addX_eq ha₁] at hXp' hXm' + rw [addY_eq ha₁ ha₃] at hYp' hYm' +- have hp : W.slope X x Y y * (X - x) = Y - y := slope_mul_of_X_ne ha₁ ha₃ Y y hXx ++ have hp : W.slope X x Y y * (X - x) = Y - y := slope_mul_of_X_ne Y y hXx + have hmn : W.slope X x Y (W.negY x y) * (X - x) = Y + y := slope_neg_mul ha₁ ha₃ hXx + have hI5 := Ident.double_X_sub (hQ_of ha₁ ha₃ hQ) (hQ_of ha₁ ha₃ h) hXx hp hmn hμ hY0 + have hI6 := Ident.double_Y_mul (hQ_of ha₁ ha₃ hQ) (hQ_of ha₁ ha₃ h) hXx hp hmn hμ hY0 +@@ -801,15 +812,15 @@ theorem good_odd (hy : y ≠ 0) (m : ℕ) (hm : 2 ≤ m) (g₁ : Good h (m - 1)) + -- `Q − Q⁺ = −P` and `Q⁺ − Q = P` + have hsub : Point.some X Y hQ - Point.some Xp Yp hQp = -Point.some x y h := by + rw [← hmP, ← hpP, smul_succ h]; abel +- rw [sub_eq_of_X_ne ha₁ ha₃ hQp hQ hXX, Point.neg_some] at hsub ++ rw [sub_eq_of_X_ne hQp hQ hXX, Point.neg_some] at hsub + obtain ⟨hsx, -⟩ := Point.some.inj hsub + have hsub' : Point.some Xp Yp hQp - Point.some X Y hQ = Point.some x y h := by + rw [← hmP, ← hpP, smul_succ h]; abel +- rw [sub_eq_of_X_ne ha₁ ha₃ hQ hQp (Ne.symm hXX)] at hsub' ++ rw [sub_eq_of_X_ne hQ hQp (Ne.symm hXX)] at hsub' + obtain ⟨hsx', hsy'⟩ := Point.some.inj hsub' +- rw [addX_eq ha₁ ha₃] at hsx hsx' ++ rw [addX_eq ha₁] at hsx hsx' + rw [addY_eq ha₁ ha₃] at hsy' +- have hl : W.slope X Xp Y Yp * (X - Xp) = Y - Yp := slope_mul_of_X_ne ha₁ ha₃ Y Yp hXX ++ have hl : W.slope X Xp Y Yp * (X - Xp) = Y - Yp := slope_mul_of_X_ne Y Yp hXX + have hn : W.slope Xp X Yp (W.negY X Y) * (Xp - X) = Yp + Y := + slope_neg_mul ha₁ ha₃ (Ne.symm hXX) + have hn' : W.slope X Xp Y (W.negY Xp Yp) * (X - Xp) = Y + Yp := slope_neg_mul ha₁ ha₃ hXX +@@ -838,7 +849,7 @@ theorem good_odd (hy : y ≠ 0) (m : ℕ) (hm : 2 ≤ m) (g₁ : Good h (m - 1)) + exact sub_eq_zero.mp ((mul_eq_zero.mp this).resolve_right + (mul_ne_zero (pow_ne_zero _ hem) hep)) + refine ⟨fun h0 => absurd h0 hEp0, fun _ => ⟨_, _, _, hQQ.symm, ?_, ?_⟩⟩ +- · rw [addX_eq ha₁ ha₃, h1, h4, h3] ++ · rw [addX_eq ha₁, h1, h4, h3] + linear_combination (-E1 ^ 4 * E2 ^ 4) * hD + · rw [addY_eq ha₁ ha₃, h1] + rw [h3, h4] at r_C +@@ -852,7 +863,7 @@ theorem good_odd (hy : y ≠ 0) (m : ℕ) (hm : 2 ≤ m) (g₁ : Good h (m - 1)) + + /-! ### The `2`-torsion points and the main theorem -/ + +-omit ha₁ ha₃ in ++omit [NeZero (2 : F)] ha₁ ha₃ in + /-- The odd terms of the auxiliary sequence with `b = 0` are nonzero when `c ≠ 0`. -/ + theorem preNormEDS'_odd_ne_zero {c d : F} (hc : c ≠ 0) (k : ℕ) : + preNormEDS' (0 : F) c d (2 * k + 1) ≠ 0 := by +@@ -863,7 +874,7 @@ theorem preNormEDS'_odd_ne_zero {c d : F} (hc : c ≠ 0) (k : ℕ) : + · simpa using hc + · rw [show 2 * (j + 2) + 1 = 2 * (j + 2) + 1 from rfl, preNormEDS'_odd] + rcases Nat.even_or_odd' j with ⟨i, rfl | rfl⟩ +- · rw [if_pos (even_two_mul i), if_pos (even_two_mul i)] ++ · rw [ite_eq_left (even_two_mul i), ite_eq_left (even_two_mul i)] + have h1 := ih i (by omega) + have h2 := ih (i + 1) (by omega) + rw [show 2 * i + 1 = 2 * i + 1 from rfl] at h1 +@@ -872,7 +883,7 @@ theorem preNormEDS'_odd_ne_zero {c d : F} (hc : c ≠ 0) (k : ℕ) : + simp only [mul_zero, mul_one, zero_sub, neg_ne_zero] + exact mul_ne_zero h1 (pow_ne_zero _ h2) + · have hodd : ¬Even (2 * i + 1) := Nat.not_even_iff_odd.mpr ⟨i, rfl⟩ +- rw [if_neg hodd, if_neg hodd] ++ rw [ite_eq_right hodd, ite_eq_right hodd] + have h1 := ih (i + 1) (by omega) + have h2 := ih (i + 2) (by omega) + rw [show 2 * (i + 1) + 1 = 2 * i + 1 + 2 by ring] at h1 +@@ -883,8 +894,9 @@ theorem preNormEDS'_odd_ne_zero {c d : F} (hc : c ≠ 0) (k : ℕ) : + omit [NeZero (2 : F)] ha₁ ha₃ in + /-- The even terms of `eₙ` vanish at a `2`-torsion point. -/ + theorem eds_eq_zero_of_even (hy : y = 0) {n : ℤ} (hn : Even n) : eds W x y n = 0 := by +- rw [eds, normEDS, if_pos hn, hy]; ring ++ rw [eds, normEDS, ite_eq_left hn, hy]; ring + ++omit [NeZero (2 : F)] in + include h in + /-- `Ψ₃(x) ≠ 0` at a `2`-torsion point `(x, 0)`: `Ψ₃(x) = −f'(x)²` there. -/ + theorem Ψ₃_ne_zero_of_y_eq_zero (hy : y = 0) : W.Ψ₃.eval x ≠ 0 := by +@@ -904,15 +916,17 @@ theorem Ψ₃_ne_zero_of_y_eq_zero (hy : y = 0) : W.Ψ₃.eval x ≠ 0 := by + rw [this, ← hf, zero_pow two_ne_zero, mul_zero, zero_sub, neg_ne_zero] + exact pow_ne_zero _ hf' + ++omit [NeZero (2 : F)] in + include h in + /-- The odd terms of `eₙ` do not vanish at a `2`-torsion point. -/ + theorem eds_ne_zero_of_odd (hy : y = 0) (k : ℕ) : eds W x y (2 * k + 1) ≠ 0 := by + have hc := Ψ₃_ne_zero_of_y_eq_zero ha₁ ha₃ h hy + have hodd : ¬Even (2 * (k : ℤ) + 1) := Int.not_even_iff_odd.mpr ⟨k, rfl⟩ +- rw [eds, normEDS, if_neg hodd, mul_one, hy, mul_zero, ++ rw [eds, normEDS, ite_eq_right hodd, mul_one, hy, mul_zero, + show (2 * (k : ℤ) + 1) = ((2 * k + 1 : ℕ) : ℤ) by push_cast; ring, preNormEDS_ofNat] + simpa using preNormEDS'_odd_ne_zero hc k + ++omit [NeZero (2 : F)] in + /-- `Good n` for every `n` at a `2`-torsion point `(x, 0)`. -/ + theorem good_of_y_eq_zero (hy : y = 0) (n : ℕ) : Good h n := by + have h2P : 2 • Point.some x y h = 0 := by +@@ -922,12 +936,13 @@ theorem good_of_y_eq_zero (hy : y = 0) (n : ℕ) : Good h n := by + · refine good_of_eq_zero h (eds_eq_zero_of_even hy ⟨k, by push_cast; ring⟩) ?_ + rw [mul_nsmul, h2P, smul_zero] + · have hne := eds_ne_zero_of_odd ha₁ ha₃ h hy k +- refine ⟨fun h0 => absurd (by push_cast; exact h0) hne, fun _ => ⟨x, y, h, ?_, ?_, ?_⟩⟩ ++ refine ⟨fun h0 => absurd h0 hne, fun _ => ⟨x, y, h, ?_, ?_, ?_⟩⟩ + · rw [succ_nsmul, mul_nsmul, h2P, smul_zero, zero_add] + · have e1 : eds W x y (((2 * k + 1 : ℕ) : ℤ) + 1) = 0 := + eds_eq_zero_of_even hy ⟨k + 1, by push_cast; ring⟩ + rw [e1, zero_mul, sub_zero] +- · rw [hy, edsC, complEDS₂, if_neg (Int.not_even_iff_odd.mpr ⟨k, by push_cast; ring⟩)]; ring ++ · rw [hy, edsC, complEDS₂, ite_eq_right (Int.not_even_iff_odd.mpr ⟨k, by push_cast; ring⟩)] ++ ring + + /-- **The division polynomials describe the multiples of a point**: for every nonsingular point + `P = (x, y)` of `y² = x³ + a₂x² + a₄x + a₆` and every `n`, `eₙ = ψₙ(x, y) = 0` iff `nP = 0`, and +diff --git a/Iut/Tower/SerreBound.lean b/Iut/Tower/SerreBound.lean +index 0129e14..c0d4d87 100644 +--- a/Iut/Tower/SerreBound.lean ++++ b/Iut/Tower/SerreBound.lean +@@ -116,7 +116,7 @@ theorem exists_mem_pow_intTrace_notMem (h𝔭 : 𝔭 ≠ ⊥) (e κ : ℕ) (J : + refine Ideal.IsMaximal.eq_of_le inferInstance (Ideal.IsPrime.ne_top inferInstance) ?_ + change maximalIdeal Rₚ ≤ 𝔓ₚ.comap (algebraMap Rₚ Sₚ) + rw [← Ideal.map_le_iff_le_comap, hpSₚ] +- exact Ideal.mul_le_right.trans (Ideal.pow_le_self he) ++ exact Ideal.mul_le_left.trans (Ideal.pow_le_self he) + haveI : Finite (Rₚ ⧸ maximalIdeal Rₚ) := + Finite.of_equiv _ (IsLocalization.AtPrime.equivQuotMaximalIdeal 𝔭 Rₚ).toEquiv + -- the contraction of `𝔪^n` to `A` is `𝔭^n` +@@ -186,7 +186,7 @@ theorem exists_mem_pow_intTrace_notMem (h𝔭 : 𝔭 ≠ ⊥) (e κ : ℕ) (J : + ((Ideal.isCoprime_iff_sup_eq.mpr hJₚ').pow_left).pow_right + letI : Algebra (Rₚ ⧸ maximalIdeal Rₚ ^ (κ + 1)) (Sₚ ⧸ Jₚ ^ (κ + 1)) := + Ideal.Quotient.algebraQuotientOfLEComap +- (by rw [← Ideal.map_le_iff_le_comap, hprod]; exact Ideal.mul_le_left) ++ (by rw [← Ideal.map_le_iff_le_comap, hprod]; exact Ideal.mul_le_right) + haveI : IsScalarTower Rₚ (Rₚ ⧸ maximalIdeal Rₚ ^ (κ + 1)) (Sₚ ⧸ Jₚ ^ (κ + 1)) := + IsScalarTower.of_algebraMap_eq' rfl + haveI : IsScalarTower Rₚ (Rₚ ⧸ maximalIdeal Rₚ ^ (κ + 1)) +diff --git a/Iut/Tower/SerreCore.lean b/Iut/Tower/SerreCore.lean +index 3d2a13f..ff3447b 100644 +--- a/Iut/Tower/SerreCore.lean ++++ b/Iut/Tower/SerreCore.lean +@@ -37,7 +37,7 @@ variable (e κ : ℕ) (J : Ideal B) + lemma pow_le_comap (hpB : 𝔭.map (algebraMap A B) = 𝔓 ^ e * J) : + 𝔭 ^ (κ + 1) ≤ (𝔓 ^ (e * (κ + 1))).comap (algebraMap A B) := by + rw [← Ideal.map_le_iff_le_comap, Ideal.map_pow, hpB, mul_pow, ← pow_mul] +- exact Ideal.mul_le_right ++ exact Ideal.mul_le_left + + /-- The `A/𝔭^{κ+1}`-algebra structure of `B/𝔓^{e(κ+1)}`. -/ + noncomputable def quotAlgebra (hpB : 𝔭.map (algebraMap A B) = 𝔓 ^ e * J) : +@@ -170,7 +170,7 @@ lemma exists_monic_root (he : e ≠ 0) (h𝔓 : 𝔓 ≠ ⊥) : + exact (hmemI _).mp hαa₀ + refine ⟨g, α, hgm, hgdeg.trans hg₀deg, hαg, fun y => ?_⟩ + have hy : y ∈ Algebra.adjoin (A ⧸ 𝔭) ({a₁} : Set (B ⧸ 𝔓)) := by +- rw [← IntermediateField.adjoin_simple_toSubalgebra_of_integral hint, ha₁] ++ rw [← IntermediateField.adjoin_simple_toSubalgebra_of_isAlgebraic hint.isAlgebraic, ha₁] + exact trivial + rw [Algebra.adjoin_singleton_eq_range_aeval] at hy + obtain ⟨q', hq'⟩ := hy +diff --git a/Iut/Tripod/Basic.lean b/Iut/Tripod/Basic.lean +index e7dc78f..4ab670d 100644 +--- a/Iut/Tripod/Basic.lean ++++ b/Iut/Tripod/Basic.lean +@@ -404,9 +404,9 @@ theorem finite_of_fieldOf_eq (F : IntermediateField ℚ Qbar) [FiniteDimensional + (fun x : Pt ↦ x.1) ⁻¹' (Subtype.val '' {y : F | Height.logHeight₁ y ≤ + max H 0 * Module.finrank ℚ F}) := by + rintro ⟨l, hl⟩ ⟨hFl, hH⟩ +- simp only [Set.mem_preimage, Set.mem_image, Set.mem_setOf_eq] + subst hFl + refine ⟨gen l, ?_, rfl⟩ ++ change Height.logHeight₁ (gen ((⟨l, hl⟩ : Pt) : Qbar)) ≤ _ + rw [← deg_mul_htCan ⟨l, hl⟩, ← deg_eq_finrank, mul_comm] + exact mul_le_mul_of_nonneg_right (hH.trans (le_max_left _ _)) (Nat.cast_nonneg _) + refine ((hF.image Subtype.val).preimage ?_).subset himg +diff --git a/Iut/Tripod/CyclicIsogeny.lean b/Iut/Tripod/CyclicIsogeny.lean +index cc96d31..9b14036 100644 +--- a/Iut/Tripod/CyclicIsogeny.lean ++++ b/Iut/Tripod/CyclicIsogeny.lean +@@ -556,7 +556,8 @@ lemma apply_genC_eq_one {v : FinitePlace (P.curve x).F} (hv : v ∉ (P.curve x). + /-- `|n|_v ≤ 1` at a finite place. -/ + lemma apply_natCast_le_one {T : Type*} [Field T] [NumberField T] (v : FinitePlace T) (n : ℕ) : + v (n : T) ≤ 1 := +- IsNonarchimedean.apply_natCast_le_one (f := v) (fun a b => FinitePlace.add_le v a b) ++ IsNonarchimedean.apply_natCast_le_one (f := v) (by simp) (by simp) ++ (fun a b => FinitePlace.add_le v a b) + + /-- `max(1, a)^d = max(1, a^d)` for `a ≥ 0`. -/ + lemma max_one_pow {a : ℝ} (ha : 0 ≤ a) (d : ℕ) : max 1 a ^ d = max 1 (a ^ d) := by +diff --git a/Iut/Tripod/CyclicLocal.lean b/Iut/Tripod/CyclicLocal.lean +index 52c4ce3..e876e7a 100644 +--- a/Iut/Tripod/CyclicLocal.lean ++++ b/Iut/Tripod/CyclicLocal.lean +@@ -349,6 +349,13 @@ variable {C : EllipticCurveData.{u}} {ℓ : ℕ} (R : C.ModEllRepData ℓ) + attribute [local instance 1100] Iut.EllipticCurveData.ModEllRepData.instDecidableEqTorsionFieldR + attribute [local instance] Iut.instGalRingOfIntegersAction Iut.instGalRingOfIntegersGaloisGroup + ++noncomputable local instance instTorsionFieldIdealAction : ++ MulAction (↥R.torsionField ≃ₐ[C.F] ↥R.torsionField) (Ideal (𝓞 ↥R.torsionField)) := by ++ letI : MulSemiringAction (↥R.torsionField ≃ₐ[C.F] ↥R.torsionField) (𝓞 ↥R.torsionField) := ++ Iut.instGalRingOfIntegersAction (k := C.F) (K := ↥R.torsionField) ++ exact (Ideal.pointwiseDistribMulAction : DistribMulAction ++ (↥R.torsionField ≃ₐ[C.F] ↥R.torsionField) (Ideal (𝓞 ↥R.torsionField))).toMulAction ++ + lemma graphLineAt_congrR {VBad : Set (FinitePlace ↥(fieldOfModuli C.F C.E))} + (TF : TateFamily C.E R.torsionField ℓ VBad) {w w' : FinitePlace ↥R.torsionField} (h : w = w') + (hw : IsBadPlace C.E R.torsionField VBad w) (hw' : IsBadPlace C.E R.torsionField VBad w') : +diff --git a/Iut/Tripod/CyclicTate.lean b/Iut/Tripod/CyclicTate.lean +index d899299..b1427c5 100644 +--- a/Iut/Tripod/CyclicTate.lean ++++ b/Iut/Tripod/CyclicTate.lean +@@ -132,7 +132,7 @@ theorem ratio_bound {ℓ : ℕ} (hℓ : Odd ℓ) (hcard : Fintype.card H = ℓ) + have hτ' : τ = -1 := Units.ext (by rw [hτ1]; simp) + have hρ' := half_class_minus_one S hRTm (hτ' ▸ hτ) hρ hρlo hρhi + rw [hr] +- refine Finset.prod_le_one (fun _ _ => by positivity) fun Q hQ => ?_ ++ refine Finset.prod_le_one₀ (fun _ _ => by positivity) fun Q hQ => ?_ + obtain ⟨hnum, hden⟩ := minus_one_bounds S.t h2 hρ' hℓ (hζℓ Q hQ) (hζ1 Q hQ) + rw [hτ'] + exact div_le_one_of_le₀ (hnum.trans hden) (norm_nonneg _) +@@ -142,7 +142,7 @@ theorem ratio_bound {ℓ : ℕ} (hℓ : Odd ℓ) (hcard : Fintype.card H = ℓ) + have hρ' := half_class_node S hRTm hτ hρ hτn hρlo hρhi + have hℓ0 : ℓ ≠ 0 := by rintro rfl; exact Nat.not_odd_zero hℓ + rw [hr, ← Finset.prod_pow, ← hcardnz, ← Finset.prod_const] +- refine Finset.prod_le_prod (fun _ _ => by positivity) fun Q hQ => ?_ ++ refine Finset.prod_le_prod₀ (fun _ _ => by positivity) fun Q hQ => ?_ + have hζn : ‖((ζ Q : kˣ) : k)‖ = 1 := by + have h := congrArg (fun u : kˣ => ‖(u : k)‖) (hζℓ Q hQ) + simp only [Units.val_pow_eq_pow_val, norm_pow, Units.val_one, norm_one] at h +diff --git a/Iut/Tripod/CyclicTorsion.lean b/Iut/Tripod/CyclicTorsion.lean +index 3d5a9fe..2b08938 100644 +--- a/Iut/Tripod/CyclicTorsion.lean ++++ b/Iut/Tripod/CyclicTorsion.lean +@@ -159,7 +159,7 @@ lemma mem_TKR_of_bcKR {P : (curveK C.E R.torsionField).toAffine.Point} + + /-- **The ℓ-torsion is rational over `K`**: `E(K)[ℓ] ≃ E(F̄)[ℓ]`. -/ + noncomputable def torsionEquivR : ↥R.TKR ≃+ ↥R.TFbarR := +- AddEquiv.ofBijective (R.bcKR.restrict R.TKR |>.codRestrict _ fun P => R.bcKR_mem_TFbarR P.2) ++ AddEquiv.ofBijective (R.bcKR.domRestrict R.TKR |>.codRestrict _ fun P => R.bcKR_mem_TFbarR P.2) + ⟨fun P P' h => Subtype.ext (R.bcKR_injective (congrArg Subtype.val h)), + fun Q => by + obtain ⟨P, hP⟩ := R.exists_bcKR_eq Q.1 Q.2 +diff --git a/Iut/Tripod/TorsionDegree.lean b/Iut/Tripod/TorsionDegree.lean +index 144d0f8..76a6b68 100644 +--- a/Iut/Tripod/TorsionDegree.lean ++++ b/Iut/Tripod/TorsionDegree.lean +@@ -75,7 +75,7 @@ theorem galAct_torsionBy (σ : Qbar ≃ₐ[K] Qbar) {n : ℕ} {P : (legendre l). + noncomputable def galTorsion (n : ℕ) (σ : Qbar ≃ₐ[K] Qbar) : + AddSubgroup.torsionBy (legendre l).toAffine.Point n →+ + AddSubgroup.torsionBy (legendre l).toAffine.Point n := +- ((galAct K hl σ).restrict (AddSubgroup.torsionBy (legendre l).toAffine.Point n)).codRestrict ++ ((galAct K hl σ).domRestrict (AddSubgroup.torsionBy (legendre l).toAffine.Point n)).codRestrict + (AddSubgroup.torsionBy (legendre l).toAffine.Point n) + (fun P => galAct_torsionBy K hl σ P.2) + +diff --git a/Iut/Tripod/TorsionNewton.lean b/Iut/Tripod/TorsionNewton.lean +index 9f2147f..103302e 100644 +--- a/Iut/Tripod/TorsionNewton.lean ++++ b/Iut/Tripod/TorsionNewton.lean +@@ -78,7 +78,8 @@ theorem apply_x_le {W : Affine K} (ha₁ : W.a₁ = 0) (ha₃ : W.a₃ = 0) (h + have h₃ : w W.a₃ ≤ 1 := by rw [ha₃, map_zero]; exact zero_le_one + have hroot : (W.ΨSq n).eval x = 0 := (Iut.Torsion.smul_eq_zero_iff_ΨSq ha₁ ha₃ h n).mp hP + have hn1 : (1 : ℝ) ≥ w (n : K) := +- IsNonarchimedean.apply_natCast_le_one (f := w) (fun a b => FinitePlace.add_le w a b) ++ IsNonarchimedean.apply_natCast_le_one (f := w) (map_zero_le w 1) (map_one w) ++ (fun a b => FinitePlace.add_le w a b) + by_cases hx : w x ≤ 1 + · exact mul_le_one₀ (pow_le_one₀ (n := 2) (apply_nonneg w _) hn1) (apply_nonneg w x) hx + rw [not_le] at hx +diff --git a/Iut/Tripod/TpdGalois.lean b/Iut/Tripod/TpdGalois.lean +index 2b4637c..ad28667 100644 +--- a/Iut/Tripod/TpdGalois.lean ++++ b/Iut/Tripod/TpdGalois.lean +@@ -168,11 +168,11 @@ noncomputable def tpdEquivAdjoinMod : + ↥(tpdC x h3 h5) ≃ₐ[modC x h3 h5] ↥((modC x h3 h5)⟮genC x h3 h5⟯) where + toFun t := ⟨t.1, (mem_adjoin_modC_iff x h3 h5 _).mpr ((mem_tpdC_iff x h3 h5 _).mp t.2)⟩ + invFun s := ⟨s.1, (mem_tpdC_iff x h3 h5 _).mpr ((mem_adjoin_modC_iff x h3 h5 _).mp s.2)⟩ +- left_inv _ := rfl +- right_inv _ := rfl +- map_mul' _ _ := rfl +- map_add' _ _ := rfl +- commutes' _ := rfl ++ left_inv _ := Subtype.ext rfl ++ right_inv _ := Subtype.ext rfl ++ map_mul' _ _ := Subtype.ext rfl ++ map_add' _ _ := Subtype.ext rfl ++ commutes' _ := Subtype.ext rfl + + /-- The sextic splits over `F_λ`. -/ + theorem sext_map_splits : +diff --git a/Iut/Tripod/TpdInertia.lean b/Iut/Tripod/TpdInertia.lean +index 78240c5..775a3dc 100644 +--- a/Iut/Tripod/TpdInertia.lean ++++ b/Iut/Tripod/TpdInertia.lean +@@ -131,7 +131,7 @@ theorem card_inertia_le_two_mul (w : FinitePlace (P.curve x).F) (f : (P.curve x) + 2 * Nat.card (inertiaPlus P x w) := by + haveI : IsGalois (tpd P x) (P.curve x).F := isGalois_tpd_curve' (P := P) (x := x) + set I := w.maximalIdeal.asIdeal.inertia ((P.curve x).F ≃ₐ[tpd P x] (P.curve x).F) with hI +- set ε := (signHom f hf hf0).restrict I with hε ++ set ε := (signHom f hf hf0).domRestrict I with hε + have h1 := Subgroup.card_mul_index ε.ker + have hidx : ε.ker.index ≤ 2 := by + rw [Subgroup.index_ker] +@@ -199,8 +199,8 @@ theorem card_inertiaPlus_le (w : FinitePlace (P.curve x).F) (h2 : residueChar w + haveI : Fact (Nat.Prime 5) := ⟨by norm_num⟩ + have hsub3 := torsionCoords_three_subset_fieldOf' x.1 + have hsub5 := torsionCoords_five_subset_fieldOf' x.1 +- set ρ₃ := (repF P x 3 hsub3).restrict (inertiaPlus P x w) with hρ₃ +- set ρ₅ := (repF P x 5 hsub5).restrict (inertiaPlus P x w) with hρ₅ ++ set ρ₃ := (repF P x 3 hsub3).domRestrict (inertiaPlus P x w) with hρ₃ ++ set ρ₅ := (repF P x 5 hsub5).domRestrict (inertiaPlus P x w) with hρ₅ + have hn3 : w.maximalIdeal.valuation _ ((3 : ℕ) : (P.curve x).F) = 1 := + (valuation_natCast_eq_one_iff w Nat.prime_three).2 h3 + have hn5 : w.maximalIdeal.valuation _ ((5 : ℕ) : (P.curve x).F) = 1 := +@@ -246,7 +246,7 @@ theorem card_inertiaPlus_le (w : FinitePlace (P.curve x).F) (h2 : residueChar w + card_le_of_forall_pow_eq_one ρ₃.range 3 16 hGL3 (by norm_num) fun τ hτ => by + obtain ⟨σ, rfl⟩ := hτ + exact hpow3 σ +- set ρ₅' := ρ₅.restrict ρ₃.ker with hρ₅' ++ set ρ₅' := ρ₅.domRestrict ρ₃.ker with hρ₅' + have hinj' : Function.Injective ρ₅' := by + intro σ τ h + have h' : ρ₅ σ.1 = ρ₅ τ.1 := h +diff --git a/Iut/Tripod/TpdTorsionRep.lean b/Iut/Tripod/TpdTorsionRep.lean +index 5b03838..bb36be0 100644 +--- a/Iut/Tripod/TpdTorsionRep.lean ++++ b/Iut/Tripod/TpdTorsionRep.lean +@@ -101,7 +101,7 @@ lemma toQbar_mem_torsionBy {R : (EF).Point} (hR : R ∈ AddSubgroup.torsionBy (E + noncomputable def torsionEquivF : + ↥(AddSubgroup.torsionBy (EF).Point n) ≃+ + ↥(AddSubgroup.torsionBy (legendre x.1).toAffine.Point n) := +- AddEquiv.ofBijective ((toQbar P x).restrict (AddSubgroup.torsionBy (EF).Point n) |>.codRestrict ++ AddEquiv.ofBijective ((toQbar P x).domRestrict (AddSubgroup.torsionBy (EF).Point n) |>.codRestrict + _ fun R => toQbar_mem_torsionBy P x n R.2) + ⟨fun R R' h => Subtype.ext (toQbar_injective P x (congrArg Subtype.val h)), + fun Q => by +@@ -145,7 +145,7 @@ lemma galF_mem_torsionBy (σ : (P.curve x).F ≃ₐ[tpd P x] (P.curve x).F) {R : + /-- The action on the `n`-torsion. -/ + noncomputable def galTorsionF (σ : (P.curve x).F ≃ₐ[tpd P x] (P.curve x).F) : + ↥(AddSubgroup.torsionBy (EF).Point n) →+ ↥(AddSubgroup.torsionBy (EF).Point n) := +- (galF P x σ).restrict _ |>.codRestrict _ fun R => galF_mem_torsionBy P x n σ R.2 ++ (galF P x σ).domRestrict _ |>.codRestrict _ fun R => galF_mem_torsionBy P x n σ R.2 + + omit [Fact n.Prime] hsub in + @[simp] lemma coe_galTorsionF (σ : (P.curve x).F ≃ₐ[tpd P x] (P.curve x).F) +diff --git a/lake-manifest.json b/lake-manifest.json +index c7312cb..819e49e 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,9 +1,7 @@ +-{ +- "version": "1.2.0", ++{"version": "1.2.0", + "packagesDir": ".lake/packages", +- "packages": [ +- { +- "url": "https://github.com/lana-agents/tempered-fundamental-groups", ++ "packages": ++ [{"url": "https://github.com/lana-agents/tempered-fundamental-groups.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -12,10 +10,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "2006651f52b70ea2fe3388238c7d9db14d21748f", + "inherited": false, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/oka.git", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/oka.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -24,10 +20,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", + "inherited": false, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/orbicurve-cores", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/orbicurve-cores.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -36,10 +30,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "61616dcd77fbe45c083a8ebfa7cc80728f86e841", + "inherited": false, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/pi1", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/pi1.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -48,10 +40,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "ca7def953193f861a462aa0831eec8f0a31ff69f", + "inherited": false, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/heights", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/heights.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -60,10 +50,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", + "inherited": false, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/genl", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/genl.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -72,10 +60,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "ea2846c877d1e16d8f0b911a5fed07f5ee69eaaf", + "inherited": false, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/tate-curves-theta", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/tate-curves-theta.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -84,22 +70,18 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "ca6c2279d3cea0690cdb01328e727118d5485d68", + "inherited": false, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover-community/mathlib4", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, +- "configFile": "lakefile.lean" +- }, +- { +- "url": "https://github.com/lana-agents/elliptic-curves", ++ "configFile": "lakefile.lean"}, ++ {"url": "https://github.com/lana-agents/elliptic-curves.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -108,10 +90,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "bebec3fc9f2602e81c83e5236789572a541c85fb", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/belyi.git", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/belyi.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -120,10 +100,8 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/lana-agents/formal-schemes", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/formal-schemes.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -132,106 +110,87 @@ + "manifestFile": "lake-manifest.json", + "inputRev": "51aa935079537bf4dc580751a6e70727fb23ca93", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover-community/plausible", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover-community/LeanSearchClient", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover-community/import-graph", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover-community/ProofWidgets4", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.lean" +- }, +- { +- "url": "https://github.com/leanprover-community/aesop", ++ "configFile": "lakefile.lean"}, ++ {"url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover-community/quote4", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover-community/batteries", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, +- "configFile": "lakefile.toml" +- }, +- { +- "url": "https://github.com/leanprover/lean4-cli", ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, +- "configFile": "lakefile.toml" +- } +- ], ++ "configFile": "lakefile.toml"}], + "name": "iut", + "lakeDir": ".lake", +- "fixedToolchain": false +-} +\ No newline at end of file ++ "fixedToolchain": false} +diff --git a/lakefile.toml b/lakefile.toml +index 46c5aaa..fee9e14 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["Iut", "Iut4Sec1", "Challenge", "Solution"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -12,14 +14,14 @@ warn.sorry = false # `sorry` is load-bearing in Comparator/Challenge.lean + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + # Tate q-parameters and the classical theta function (taxis #13/#37); consumed by + # the initial Θ-data and Corollary 3.12 variant strand (taxis #33). + [[require]] + name = "tate-curves-theta" +-git = "https://github.com/lana-agents/tate-curves-theta" ++git = "https://github.com/lana-agents/tate-curves-theta.git" + rev = "ca6c2279d3cea0690cdb01328e727118d5485d68" + + # Arithmetic elliptic curves in general position (taxis #2): the height formalism and +@@ -28,7 +30,7 @@ rev = "ca6c2279d3cea0690cdb01328e727118d5485d68" + # curves over number fields and its proof package (Genl.Curves, branch wp-height-theory). + [[require]] + name = "genl" +-git = "https://github.com/lana-agents/genl" ++git = "https://github.com/lana-agents/genl.git" + rev = "ea2846c877d1e16d8f0b911a5fed07f5ee69eaaf" + + # Heights and elliptic-curve height estimates (taxis #32): the complex uniformization of +@@ -36,7 +38,7 @@ rev = "ea2846c877d1e16d8f0b911a5fed07f5ee69eaaf" + # also the height machine on curves used by Genl.Curves (branch wp-integrate). + [[require]] + name = "heights" +-git = "https://github.com/lana-agents/heights" ++git = "https://github.com/lana-agents/heights.git" + rev = "721496ca4c158e511d25d8ccf6bfe8503eda73c1" + + # Étale fundamental groups (Galois-theoretic π₁, inertia) and cores of orbicurves +@@ -45,18 +47,17 @@ rev = "721496ca4c158e511d25d8ccf6bfe8503eda73c1" + # branch wp-core-basechange). + [[require]] + name = "pi1" +-git = "https://github.com/lana-agents/pi1" ++git = "https://github.com/lana-agents/pi1.git" + rev = "ca7def953193f861a462aa0831eec8f0a31ff69f" + + # [CanLift], Prop. 2.7 over ℂ (`OrbicurveCores.U2.canLift27C`, branch wp-u2), which together + # with `AffOrbicurve.canLift27_of_complex` discharges `AffOrbicurve.CanLift27`. + [[require]] + name = "orbicurve-cores" +-git = "https://github.com/lana-agents/orbicurve-cores" ++git = "https://github.com/lana-agents/orbicurve-cores.git" + rev = "61616dcd77fbe45c083a8ebfa7cc80728f86e841" + +-# Pinned directly so that one `oka` revision serves both `belyi` (which pins the ancestor +-# da228a2) and `orbicurve-cores` (which pins this revision, branch wp-u2). ++# One `oka` revision serves both `belyi` and `orbicurve-cores` (branch wp-u2). + [[require]] + name = "oka" + git = "https://github.com/lana-agents/oka.git" +@@ -66,7 +67,7 @@ rev = "75dcdc3faadd10b986afb9283e89902bcdddecd4" + # `Iut.Anabelian.TemperedPi1Theory` in `Iut/Anabelian/Tempered.lean`. + [[require]] + name = "tempered-fundamental-groups" +-git = "https://github.com/lana-agents/tempered-fundamental-groups" ++git = "https://github.com/lana-agents/tempered-fundamental-groups.git" + rev = "2006651f52b70ea2fe3388238c7d9db14d21748f" + + # Corollary 3.12 variant (IUT III) and the ABC target statement. +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f49..ba8ebf2 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/oka-lean4341.patch b/lean/patches/oka-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..b20f36aa681fc69e87757b3eca8976da4eb28b23 --- /dev/null +++ b/lean/patches/oka-lean4341.patch @@ -0,0 +1,2014 @@ +diff --git a/Oka/Algebra/Category/ModuleCat/Presheaf/PullbackStalk.lean b/Oka/Algebra/Category/ModuleCat/Presheaf/PullbackStalk.lean +index 470291bb7f5683f53077d88b015bb1242d86c7bb..480b1ff77217a7f6a59a354985edfd5dbdcb259f 100644 +--- a/Oka/Algebra/Category/ModuleCat/Presheaf/PullbackStalk.lean ++++ b/Oka/Algebra/Category/ModuleCat/Presheaf/PullbackStalk.lean +@@ -100,7 +100,6 @@ lemma ringStalkMap_germ (V : Opens Y) (hx : f x ∈ V) (s : S.obj (op V)) : + ((TopCat.Presheaf.stalkFunctor CommRingCat.{u} (f x)).map φ (S.germ V (f x) hx s)) = _ + rw [TopCat.Presheaf.stalkFunctor_map_germ_apply (C := CommRingCat.{u}) V (f x) hx φ s] + erw [TopCat.Presheaf.stalkPushforward_germ_apply] +- rfl + + /-- The morphism of presheaves of rings, at the `RingCat` spelling `pushforward` consumes. -/ + abbrev forgetRingHom : +diff --git a/Oka/Algebra/Category/ModuleCat/Presheaf/Submodule.lean b/Oka/Algebra/Category/ModuleCat/Presheaf/Submodule.lean +index ef73b01ddcad6f17fd86f665bb9b06acc2eb7b1e..bbd9cacb14234680212985f990aeae24fc441313 100644 +--- a/Oka/Algebra/Category/ModuleCat/Presheaf/Submodule.lean ++++ b/Oka/Algebra/Category/ModuleCat/Presheaf/Submodule.lean +@@ -11,10 +11,8 @@ public import Mathlib.CategoryTheory.Subfunctor.Basic + /-! + # A submodule of a presheaf of modules, as a subfunctor of the underlying presheaf of types + +-Material for `Mathlib/Algebra/Category/ModuleCat/Presheaf/Submodule.lean`; see `README.md` on the +-mirror tree. That file does not currently import `Mathlib.CategoryTheory.Subfunctor.Basic`, which +-the definition below names, so upstreaming it adds that import — **one** file to the target's own +-transitive closure, measured rather than estimated. ++Mathlib now provides the declarations described here with the same signatures and definitions. ++This module preserves the Oka import path while re-exporting the Mathlib implementation. + + `PresheafOfModules.Submodule` is a submodule of `M.obj X` for each object `X`, closed under the + restriction maps. `PresheafOfModules.Submodule.toSubfunctor` forgets the module structure and +@@ -32,32 +30,3 @@ it has content. + + - `PresheafOfModules.Submodule.toSubfunctor` + -/ +- +-@[expose] public section +- +-universe v v₁ u₁ u +- +-open CategoryTheory +- +-namespace PresheafOfModules +- +-variable {C : Type u₁} [Category.{v₁} C] {R : Cᵒᵖ ⥤ RingCat.{u}} +- +-namespace Submodule +- +-variable {M : PresheafOfModules.{v} R} (N : M.Submodule) +- +-/-- The subfunctor of the underlying type-valued presheaf of `M` induced by a submodule `N`. -/ +-def toSubfunctor : Subfunctor (M.presheaf ⋙ CategoryTheory.forget AddCommGrpCat.{v}) where +- obj X := {r : M.obj X | r ∈ N.obj X} +- map := fun {_ _} f _ hr ↦ N.map_mem f hr +- +-/-- Membership in the subfunctor is membership in the submodule. This is `Iff.rfl`; see the +-module docstring for why it is a `simp` lemma. -/ +-@[simp] +-lemma mem_toSubfunctor_obj {X : Cᵒᵖ} (r : M.obj X) : +- r ∈ N.toSubfunctor.obj X ↔ r ∈ N.obj X := Iff.rfl +- +-end Submodule +- +-end PresheafOfModules +diff --git a/Oka/Algebra/Category/ModuleCat/Sheaf/Annihilator.lean b/Oka/Algebra/Category/ModuleCat/Sheaf/Annihilator.lean +index 5ba4d73f420e77a1d1f58f55892f9b80a3475901..633cee2c72818e73eb15f03d549ab4d5fd4b2d6d 100644 +--- a/Oka/Algebra/Category/ModuleCat/Sheaf/Annihilator.lean ++++ b/Oka/Algebra/Category/ModuleCat/Sheaf/Annihilator.lean +@@ -48,6 +48,7 @@ noncomputable def annihilator : (unit R).Submodule where + (Module.annihilator (R.obj Y) (M.obj Y)).comap (R.map f).hom + map {X Y} f := by + intro r hr ++ change R.obj X at r + rw [Submodule.mem_comap, restrictₛₗ_apply] + -- characterise membership in the defining `iInf` at the honest type `R.obj _` + have mem : ∀ {W : Cᵒᵖ} (s : R.obj W), +@@ -115,6 +116,7 @@ noncomputable def annihilator : (SheafOfModules.unit R).Submodule where + (isSheaf_iff_isSheaf_of_type J _).mp + (GrothendieckTopology.HasSheafCompose.isSheaf _ M.isSheaf) + intro X s hmem ++ change R.obj.obj X at s + refine (mem_annihilator s).mpr fun W φ m ↦ ?_ + -- It suffices, by separatedness, that every restriction of `R.map φ s • m` vanishes. + apply (hsep _ (J.pullback_stable φ.unop hmem)).isSeparatedFor.ext +diff --git a/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Equivalence.lean b/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Equivalence.lean +index 33ffcac6dc3e20b079b039ba0814a3838c01efbc..2f4c90a80b2de7ed24accc9f6fd437aeeb84f98f 100644 +--- a/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Equivalence.lean ++++ b/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Equivalence.lean +@@ -145,7 +145,7 @@ lemma symm_H₁ : + rw [← Functor.map_comp, ← op_comp, Iso.inv_hom_id_app, op_id, + CategoryTheory.Functor.map_id] + have h' := h =≫ S.obj.map (eqv.unitInv.app X.unop).op +- rw [Category.assoc, Category.assoc] at h' ++ erw [Category.assoc, Category.assoc] at h' + erw [e] at h' + erw [Category.comp_id, Category.id_comp] at h' + exact h'.symm +@@ -164,7 +164,7 @@ lemma symm_H₂ : + 𝟙 _ := by + rw [← Functor.map_comp, ← op_comp, Iso.inv_hom_id_app, op_id, + CategoryTheory.Functor.map_id] +- rw [← Category.assoc, ← h] ++ erw [← Category.assoc, ← h] + exact e + + variable [HasPullbacks C] [HasPullbacks D] +diff --git a/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Presentation.lean b/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Presentation.lean +index df229ae96f1a84b77a00a89fa12d4751fc21d93e..f78b8e026223edb5287b08645aa0ff5feaefd63c 100644 +--- a/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Presentation.lean ++++ b/Oka/Algebra/Category/ModuleCat/Sheaf/Coherent/Presentation.lean +@@ -83,8 +83,12 @@ restriction preserves kernels (`SheafOfModules.overKernelIso`). Stated because i + generators of the relations *over `Y`* be read as relations of the restricted generators, which + is the whole of `SheafOfModules.GeneratingSections.presentationOver`. -/ + noncomputable def GeneratingSections.overKernelπIso (G : N.GeneratingSections) (Y : C) : +- (kernel G.π).over Y ≅ kernel ((G.map (overFunctor R Y) (Iso.refl _)).π) := +- overKernelIso G.π Y ≪≫ (kernelIsIsoComp _ _).symm ≪≫ ++ (kernel G.π).over Y ≅ kernel ((G.map (overFunctor R Y) (Iso.refl _)).π) := by ++ let e : free (R := R.over Y) G.I ≅ (overFunctor R Y).obj (free (R := R) G.I) := ++ mapFreeIso (overFunctor R Y) G.I (Iso.refl _) ++ have : IsIso e.hom := e.isIso_hom ++ exact overKernelIso G.π Y ≪≫ ++ (kernelIsIsoComp e.hom ((overFunctor R Y).map G.π)).symm ≪≫ + (kernelIsoOfEq (G.map_π_eq (overFunctor R Y) (Iso.refl _))).symm + + /-- **Generators of `N`, together with generators of their relations over `Y`, present +@@ -102,7 +106,7 @@ noncomputable def GeneratingSections.presentationOver (G : N.GeneratingSections) + instance GeneratingSections.isFinite_presentationOver (G : N.GeneratingSections) [G.IsFiniteType] + (Y : C) (H : ((kernel G.π).over Y).GeneratingSections) [H.IsFiniteType] : + (G.presentationOver Y H).IsFinite where +- isFiniteType_generators := inferInstanceAs (G.map (overFunctor R Y) (Iso.refl _)).IsFiniteType ++ isFiniteType_generators := ⟨inferInstanceAs (Finite G.I)⟩ + isFiniteType_relations := inferInstanceAs (H.ofEpi (G.overKernelπIso Y).hom).IsFiniteType + + /-- **Generators of `N` and a covering on which their relations are generated give quasicoherent +diff --git a/Oka/Algebra/Category/ModuleCat/Sheaf/PushforwardContinuous.lean b/Oka/Algebra/Category/ModuleCat/Sheaf/PushforwardContinuous.lean +index 6524079cc07ddc7880524860d4e5c35bf7be03a0..cdf79485d4ab61e66b2d0f4fef4cf0cf2131f739 100644 +--- a/Oka/Algebra/Category/ModuleCat/Sheaf/PushforwardContinuous.lean ++++ b/Oka/Algebra/Category/ModuleCat/Sheaf/PushforwardContinuous.lean +@@ -167,8 +167,14 @@ section + variable {C : Type u} [SmallCategory C] {J : GrothendieckTopology C} {R : Sheaf J RingCat.{u}} + [HasWeakSheafify J AddCommGrpCat.{u}] [J.WEqualsLocallyBijective AddCommGrpCat.{u}] + +-instance (X : C) : (overFunctor.{u} R X).IsRightAdjoint := +- inferInstanceAs (pushforward.{u} (𝟙 (R.over X))).IsRightAdjoint ++instance (X : C) : (overFunctor.{u} R X).IsRightAdjoint := by ++ let φ : R.over X ⟶ ++ ((Over.forget X).sheafPushforwardContinuous RingCat.{u} (J.over X) J).obj R := 𝟙 _ ++ let : (PresheafOfModules.pushforward.{u} φ.hom).IsRightAdjoint := ++ CategoryTheory.Functor.isRightAdjoint_of_leftAdjointObjIsDefined_eq_top ++ (PresheafOfModules.pullbackObjIsDefined_eq_top ++ (F := Over.forget X) (R := R.obj) φ.hom) ++ exact (PullbackConstruction.adjunction.{u} φ).isRightAdjoint + + variable [HasSheafify J AddCommGrpCat.{u}] [∀ (X : C), HasSheafify (J.over X) AddCommGrpCat.{u}] + [∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat.{u}] +diff --git a/Oka/Algebra/Category/ModuleCat/Sheaf/Submodule.lean b/Oka/Algebra/Category/ModuleCat/Sheaf/Submodule.lean +index b10f8c3b43ddc016d77045b940899be8951c4c77..ed660d7db04c0e4b3d94ccb19b40ff6e1f7a4053 100644 +--- a/Oka/Algebra/Category/ModuleCat/Sheaf/Submodule.lean ++++ b/Oka/Algebra/Category/ModuleCat/Sheaf/Submodule.lean +@@ -6,7 +6,7 @@ Authors: Yuichiro Hoshi, Junnosuke Koizumi, Christian Merten + module + + public import Oka.Algebra.Category.ModuleCat.Presheaf.Submodule +-public import Mathlib.Algebra.Category.ModuleCat.Sheaf ++public import Mathlib.Algebra.Category.ModuleCat.Sheaf.Submodule + + /-! + # Submodules of sheaves of modules +@@ -19,107 +19,6 @@ presheaf of modules whose membership condition is local. + - `SheafOfModules.Submodule`: a submodule of (the underlying presheaf of modules of) a sheaf of + modules whose membership is local. + - `SheafOfModules.Submodule.toSheafOfModules`: the associated sheaf of modules. +--/ +- +-@[expose] public section +- +-universe v v₁ u₁ u +- +-open CategoryTheory Opposite +- +-namespace SheafOfModules +- +-open PresheafOfModules +- +-variable {C : Type u₁} [Category.{v₁} C] {J : GrothendieckTopology C} +- {R : Sheaf J RingCat.{u}} +- +-/-- A submodule of a sheaf of modules `M`: a submodule `N` of the underlying presheaf of modules +-whose membership condition is local. -/ +-structure Submodule (M : SheafOfModules.{v} R) extends M.val.Submodule where +- isSheaf ⦃X : Cᵒᵖ⦄ (s : M.val.obj X) : +- toSubmodule.toSubfunctor.sieveOfSection s ∈ J X.unop → s ∈ toSubmodule.obj X +- +-namespace Submodule +- +-variable {M : SheafOfModules.{v} R} (N : M.Submodule) +- +-@[ext] +-lemma ext {N₁ N₂ : M.Submodule} (h : N₁.toSubmodule = N₂.toSubmodule) : N₁ = N₂ := by +- cases N₁ +- cases N₂ +- subst h +- rfl +- +-/-- The sheaf of modules associated to a submodule of a sheaf of modules. -/ +-noncomputable def toSheafOfModules : SheafOfModules.{v} R where +- val := N.toPresheafOfModules +- isSheaf := by +- suffices Presieve.IsSheaf J N.toSubfunctor.toFunctor by +- apply Presheaf.isSheaf_of_isSheaf_comp J (s := CategoryTheory.forget AddCommGrpCat) +- rwa [isSheaf_iff_isSheaf_of_type] +- rw [N.toSubfunctor.isSheaf_iff] +- · exact N.isSheaf +- · rw [← isSheaf_iff_isSheaf_of_type] +- exact GrothendieckTopology.HasSheafCompose.isSheaf _ M.isSheaf +- +-/-- The inclusion of the sheaf of modules associated to a submodule `N` into `M`. -/ +-noncomputable def ι : N.toSheafOfModules ⟶ M := +- ⟨N.toSubmodule.ι⟩ + +-@[simp] +-lemma ι_val : N.ι.val = N.toSubmodule.ι := rfl +- +-instance : Mono N.ι := +- (forget R).mono_of_mono_map <| inferInstanceAs (Mono N.toSubmodule.ι) +- +-instance : PartialOrder M.Submodule := +- PartialOrder.lift toSubmodule fun _ _ ↦ ext +- +-lemma le_iff {N₁ N₂ : M.Submodule} : N₁ ≤ N₂ ↔ N₁.toSubmodule ≤ N₂.toSubmodule := .rfl +- +-instance : InfSet M.Submodule where +- sInf s := +- { toSubmodule := sInf ((·.toSubmodule) '' s) +- isSheaf X x hx := by +- simp only [PresheafOfModules.Submodule.sInf_obj, Submodule.mem_iInf] +- rintro _ ⟨N', hN', rfl⟩ +- refine N'.isSheaf x (J.superset_covering (fun V f hf ↦ ?_) hx) +- exact (sInf_le (Set.mem_image_of_mem (·.toSubmodule) hN')) (op V) hf } +- +-instance : Min M.Submodule where +- min N₁ N₂ := +- { toSubmodule := N₁.toSubmodule ⊓ N₂.toSubmodule +- isSheaf := by +- rw [← sInf_pair, ← Set.image_pair (·.toSubmodule) N₁ N₂] +- exact (sInf {N₁, N₂}).isSheaf } +- +-noncomputable instance : CompleteLattice M.Submodule where +- __ := completeLatticeOfInf M.Submodule fun s ↦ +- ⟨fun _ hN ↦ le_iff.mpr (sInf_le (Set.mem_image_of_mem _ hN)), +- fun _ hb ↦ le_iff.mpr <| le_sInf <| by +- rintro _ ⟨N', hN', rfl⟩ +- exact le_iff.mp (hb hN')⟩ +- inf := (· ⊓ ·) +- inf_le_left := fun _ _ ↦ le_iff.mpr inf_le_left +- inf_le_right := fun _ _ ↦ le_iff.mpr inf_le_right +- le_inf := fun _ _ _ h₁ h₂ ↦ le_iff.mpr (le_inf (le_iff.mp h₁) (le_iff.mp h₂)) +- +-@[simp] +-lemma toSubmodule_sInf (s : Set M.Submodule) : +- (sInf s).toSubmodule = sInf ((·.toSubmodule) '' s) := +- rfl +- +-@[simp] +-lemma toSubmodule_iInf {ι : Sort*} (N : ι → M.Submodule) : +- (⨅ i, N i).toSubmodule = ⨅ i, (N i).toSubmodule := by +- rw [iInf, toSubmodule_sInf, ← Set.range_comp, iInf, Function.comp_def] +- +-@[simp] +-lemma toSubmodule_inf (N₁ N₂ : M.Submodule) : +- (N₁ ⊓ N₂).toSubmodule = N₁.toSubmodule ⊓ N₂.toSubmodule := +- rfl +- +-end Submodule +- +-end SheafOfModules ++Mathlib now provides these declarations. This module re-exports them to preserve Oka's import path. ++-/ +diff --git a/Oka/Algebra/Category/ModuleCat/Stalk.lean b/Oka/Algebra/Category/ModuleCat/Stalk.lean +index 6a7f5c96778f62d63aeb9a38d3191b8411419e99..0d0b5e53df579ebea57660ac7c5568200967df9e 100644 +--- a/Oka/Algebra/Category/ModuleCat/Stalk.lean ++++ b/Oka/Algebra/Category/ModuleCat/Stalk.lean +@@ -60,18 +60,20 @@ def stalkFunctor : + map_add' a b := map_add _ a b + map_smul' := by + intro r m ++ change _ = r • _ + obtain ⟨U, hxU, r, rfl⟩ := TopCat.Presheaf.exists_germ_eq R r + obtain ⟨V, hxV, m, rfl⟩ := TopCat.Presheaf.exists_germ_eq M.presheaf m ++ have hxUV : x ∈ U ⊓ V := ⟨hxU, hxV⟩ + rw [← TopCat.Presheaf.germ_res_apply R (homOfLE (inf_le_left : U ⊓ V ≤ U)) x +- ⟨hxU, hxV⟩ r, ++ hxUV r, + ← TopCat.Presheaf.germ_res_apply M.presheaf (homOfLE (inf_le_right : U ⊓ V ≤ V)) x +- ⟨hxU, hxV⟩ m, +- ← germ_smul] ++ hxUV m] ++ erw [← germ_smul] + erw [TopCat.Presheaf.stalkFunctor_map_germ_apply (C := AddCommGrpCat.{u}) +- (F := M.presheaf) (G := N.presheaf) (U ⊓ V) x ⟨hxU, hxV⟩ ((toPresheaf _).map f), ++ (F := M.presheaf) (G := N.presheaf) (U ⊓ V) x hxUV ((toPresheaf _).map f), + TopCat.Presheaf.stalkFunctor_map_germ_apply (C := AddCommGrpCat.{u}) +- (F := M.presheaf) (G := N.presheaf) (U ⊓ V) x ⟨hxU, hxV⟩ ((toPresheaf _).map f)] +- rw [RingHom.id_apply, ← germ_smul] ++ (F := M.presheaf) (G := N.presheaf) (U ⊓ V) x hxUV ((toPresheaf _).map f)] ++ erw [← germ_smul] + congr 1 + exact (Hom.app f (op (U ⊓ V))).hom.map_smul _ _ } + map_id M := by +diff --git a/Oka/Algebra/Homology/DerivedCategory/Ext/MapNatTrans.lean b/Oka/Algebra/Homology/DerivedCategory/Ext/MapNatTrans.lean +index 351a850eb42d360471fadd3e1da31ae767498919..609b9c0608dedcfddbee558165c3f4311c5b3a69 100644 +--- a/Oka/Algebra/Homology/DerivedCategory/Ext/MapNatTrans.lean ++++ b/Oka/Algebra/Homology/DerivedCategory/Ext/MapNatTrans.lean +@@ -6,6 +6,7 @@ Authors: Christian Merten + import Mathlib.Algebra.Homology.DerivedCategory.Ext.EnoughInjectives + import Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences + import Mathlib.Algebra.Homology.DerivedCategory.Ext.Map ++import Mathlib.CategoryTheory.Abelian.Exact + + /-! + # Naturality of `Ext.mapExactFunctor` in the functor +diff --git a/Oka/Algebra/MvPolynomial/PDeriv.lean b/Oka/Algebra/MvPolynomial/PDeriv.lean +index 4d721a8d3638dc1b39f918f700d70cc0433780fb..e84717ba891d18bb45b82c193564ef64fb211145 100644 +--- a/Oka/Algebra/MvPolynomial/PDeriv.lean ++++ b/Oka/Algebra/MvPolynomial/PDeriv.lean +@@ -58,7 +58,7 @@ vanish. The induction is `MvPolynomial.induction_on`, so no monomial expansion a + `classical`; the statement needs no `DecidableEq σ` and the `unusedDecidableInType` linter is + what says so. -/ + theorem coeff_single_one_taylorAlgHom (z : σ → R) (i : σ) (p : MvPolynomial σ R) : +- coeff (Finsupp.single i 1) (taylorAlgHom z p) = eval z (pderiv i p) := by ++ (taylorAlgHom z p).coeff (Finsupp.single i 1) = eval z (pderiv i p) := by + classical + induction p using MvPolynomial.induction_on with + | C a => +@@ -66,7 +66,8 @@ theorem coeff_single_one_taylorAlgHom (z : σ → R) (i : σ) (p : MvPolynomial + exact if_neg fun h ↦ by simpa using h.symm + | add p q hp hq => simp [hp, hq] + | mul_X p j hp => +- rw [map_mul, taylorAlgHom_X, mul_add, coeff_add, coeff_mul_X', mul_comm _ (C (z j)), ++ rw [map_mul, taylorAlgHom_X, mul_add, AddMonoidAlgebra.coeff_add, Finsupp.add_apply, ++ coeff_mul_X', mul_comm _ (C (z j)), + coeff_C_mul, hp, pderiv_mul, map_add, eval_mul, eval_mul, eval_X] + by_cases h : j = i + · subst h +diff --git a/Oka/AlgebraicGeometry/AlgClosed/Basic.lean b/Oka/AlgebraicGeometry/AlgClosed/Basic.lean +index a9d62d93ad0e92cd25050114c7bc153e54e46385..e4d46502cc27945f8e90243a9b8ced9ea69f164a 100644 +--- a/Oka/AlgebraicGeometry/AlgClosed/Basic.lean ++++ b/Oka/AlgebraicGeometry/AlgClosed/Basic.lean +@@ -41,7 +41,12 @@ theorem ext_of_apply_eq_of_formallyUnramified {X Y Z : Scheme.{u}} {K : Type u} + have : JacobsonSpace X := LocallyOfFiniteType.jacobsonSpace (f ≫ s ≫ i) + refine ext_of_fromSpecResidueField_eq_of_formallyUnramified s h fun x hx ↦ ?_ + rw [← cancel_epi (Spec.map (residueFieldIsoBase (f ≫ s ≫ i) x hx).hom)] +- refine ext_of_apply_closedPoint_eq (s ≫ i) ?_ ?_ (by simpa using H x hx) ++ refine ext_of_apply_closedPoint_eq (s ≫ i) ?_ ?_ (by ++ let p : Spec (X.residueField x) := ++ Spec.map (residueFieldIsoBase (f ≫ s ≫ i) x hx).hom (IsLocalRing.closedPoint K) ++ change f (X.fromSpecResidueField x p) = g (X.fromSpecResidueField x p) ++ rw [Scheme.fromSpecResidueField_apply] ++ exact H x hx) + · simp only [Category.assoc, ← SpecMap_residueFieldIsoBase_inv (f ≫ s ≫ i) x hx, + ← Spec.map_comp, Iso.inv_hom_id, Spec.map_id] + · simp only [Category.assoc, ← reassoc_of% h, ← SpecMap_residueFieldIsoBase_inv (f ≫ s ≫ i) x hx, +diff --git a/Oka/AlgebraicGeometry/GraphClosure.lean b/Oka/AlgebraicGeometry/GraphClosure.lean +index 3b5043fbf8c34bba45b676805660cb88e8b93e39..ed888d852b67b08c834e5dc5bae6819826bd207d 100644 +--- a/Oka/AlgebraicGeometry/GraphClosure.lean ++++ b/Oka/AlgebraicGeometry/GraphClosure.lean +@@ -67,9 +67,10 @@ theorem isClosedImmersion_morphismRestrict_of_graph (c : X ⟶ pullback sY sP) + have key : u ≫ γ' = (X.isoOfEq (by rfl : c ⁻¹ᵁ O = _)).inv ≫ (c ∣_ O) := by + rw [← cancel_mono O.ι, Category.assoc, hγ', Category.assoc, morphismRestrict_ι] + apply pullback.hom_ext +- · simp only [γ, Category.assoc, pullback.lift_fst, hu₂, Scheme.isoOfEq_inv_ι_assoc] +- · simp only [γ, Category.assoc, pullback.lift_snd, reassoc_of% hu₁, morphismRestrict_ι, +- Scheme.isoOfEq_inv_ι_assoc] ++ · simp only [γ, Category.assoc, pullback.lift_fst, hu₂] ++ erw [Scheme.isoOfEq_inv_ι_assoc] ++ · simp only [γ, Category.assoc, pullback.lift_snd, reassoc_of% hu₁, morphismRestrict_ι] ++ erw [Scheme.isoOfEq_inv_ι_assoc] + have : IsClosedImmersion (u ≫ γ') := key ▸ inferInstance + exact IsClosedImmersion.of_comp u γ' + +diff --git a/Oka/AlgebraicGeometry/Modules/CocycleTwist.lean b/Oka/AlgebraicGeometry/Modules/CocycleTwist.lean +index 005529b17e2c6432b15ae17e316d9ed9052dbe17..458526882116f655a1594e315f741e612254098d 100644 +--- a/Oka/AlgebraicGeometry/Modules/CocycleTwist.lean ++++ b/Oka/AlgebraicGeometry/Modules/CocycleTwist.lean +@@ -3,6 +3,7 @@ Copyright (c) 2026 Yuichiro Hoshi, Junnosuke Koizumi, Christian Merten. All righ + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Yuichiro Hoshi, Junnosuke Koizumi, Christian Merten + -/ ++import Mathlib.AlgebraicGeometry.AffineScheme + import Mathlib.AlgebraicGeometry.Modules.Sheaf + + /-! +diff --git a/Oka/AlgebraicGeometry/Modules/Coherent.lean b/Oka/AlgebraicGeometry/Modules/Coherent.lean +index 2e9ce25cda45c59e74487ee0b2a3f85d5a465f17..6d2efe7e806b4c9f9a64438354c72395b31c271a 100644 +--- a/Oka/AlgebraicGeometry/Modules/Coherent.lean ++++ b/Oka/AlgebraicGeometry/Modules/Coherent.lean +@@ -127,7 +127,7 @@ nothing else; it is stated because the rest of the file mixes the two spellings + lemma algebraMap_basicOpen_eq_res {U : X.Opens} (f : Γ(X, U)) (r : Γ(X, U)) : + algebraMap Γ(X, U) Γ(X, X.basicOpen f) r = + X.toLocallyRingedSpace.res (X.basicOpen_le f) r := by +- rw [RingHom.algebraMap_toAlgebra]; rfl ++ rw [RingHom.algebraMap_toAlgebra] + + /-- **A locally noetherian scheme has locally finitely generated relations.** + +diff --git a/Oka/AlgebraicGeometry/ProjectiveSpace/BaseChange.lean b/Oka/AlgebraicGeometry/ProjectiveSpace/BaseChange.lean +index 11f850b1d8982aa6b3ec36f555507f53a52c17ee..9f90b56e8c2490ac17f3dea3eb9236ef14482649 100644 +--- a/Oka/AlgebraicGeometry/ProjectiveSpace/BaseChange.lean ++++ b/Oka/AlgebraicGeometry/ProjectiveSpace/BaseChange.lean +@@ -52,7 +52,7 @@ lemma mapGradedHom_apply (p : MvPolynomial (Fin (n + 1)) R) : + /-- A polynomial lies in the irrelevant ideal iff its constant coefficient vanishes. -/ + lemma mem_irrelevant_iff_coeff_zero {S : Type u} [CommRing S] + (a : MvPolynomial (Fin (n + 1)) S) : +- a ∈ HomogeneousIdeal.irrelevant (homogeneousSubmodule (Fin (n + 1)) S) ↔ coeff 0 a = 0 := by ++ a ∈ HomogeneousIdeal.irrelevant (homogeneousSubmodule (Fin (n + 1)) S) ↔ a.coeff 0 = 0 := by + rw [HomogeneousIdeal.mem_irrelevant_iff, GradedRing.proj_apply] + exact (congrArg (· = 0) (decomposition.decompose'_apply a 0)).to_iff.trans (by + rw [homogeneousComponent_zero, C_eq_zero]) +diff --git a/Oka/AlgebraicGeometry/Spec.lean b/Oka/AlgebraicGeometry/Spec.lean +index 4aaf23470bd3fe66532d65e904edd81451db7763..cc8ca808898dac8f18c2514e40d326d7edab535e 100644 +--- a/Oka/AlgebraicGeometry/Spec.lean ++++ b/Oka/AlgebraicGeometry/Spec.lean +@@ -51,6 +51,11 @@ noncomputable section + + namespace AlgebraicGeometry.StructureSheaf + ++-- Keep the point typed as `PrimeSpectrum R` while selecting the locally ringed space instance. ++local instance (R : Type u) [CommRing R] (p : PrimeSpectrum R) : ++ IsLocalRing ((Spec.locallyRingedSpaceObj (CommRingCat.of R)).presheaf.stalk p) := ++ (Spec.locallyRingedSpaceObj (CommRingCat.of R)).isLocalRing p ++ + /-- **The germ at `p` of the global section of `𝒪_{Spec R}` attached to `a : R` lies in the + maximal ideal of the stalk exactly when `a` lies in `p`.** + +diff --git a/Oka/Analysis/Calculus/Implicit.lean b/Oka/Analysis/Calculus/Implicit.lean +index 10af3babeca73146707010cb3b88e27511bf370a..1d88d506068c1c7bb66acb60329fa8a976354881 100644 +--- a/Oka/Analysis/Calculus/Implicit.lean ++++ b/Oka/Analysis/Calculus/Implicit.lean +@@ -271,7 +271,7 @@ theorem isLocalHomeomorph_coordProj_comp_of_isEmbedding + (φ.injOn_rightFun_levelSet (hsub y y.2) (hsub y' y'.2) hyy')) + · intro W hW + obtain ⟨W', hW'open, rfl⟩ := isOpen_induced_iff.1 hW +- have himg : U.restrict (fun t ↦ g t ∘ e) '' (Subtype.val ⁻¹' W') = ++ have himg : U.domRestrict (fun t ↦ g t ∘ e) '' (Subtype.val ⁻¹' W') = + (fun t ↦ g t ∘ e) '' (U ∩ W') := by + rw [Set.restrict_eq, Set.image_comp, Subtype.image_preimage_coe] + rw [himg] +diff --git a/Oka/Analytic/DifferentiableTsum.lean b/Oka/Analytic/DifferentiableTsum.lean +index 1cc7593e2113393328c8b4aed04a8c2b6d2c7bec..3cda1414e87bf18fea90d11236466b4e236a7f1f 100644 +--- a/Oka/Analytic/DifferentiableTsum.lean ++++ b/Oka/Analytic/DifferentiableTsum.lean +@@ -109,7 +109,7 @@ theorem differentiableOn_tsum_of_locally_summable {ι : Type*} [Countable ι] {m + ∏ i, (ρ - ‖y i‖)⁻¹ := by + intro θ + rw [norm_prod] +- refine Finset.prod_le_prod (fun i _ ↦ norm_nonneg _) fun i _ ↦ ?_ ++ refine Finset.prod_le_prod₀ (fun i _ ↦ norm_nonneg _) fun i _ ↦ ?_ + rw [norm_inv] + have h2 := norm_sub_norm_le (torusMap (0 : Fin m → ℂ) (fun _ ↦ ρ) θ i) (y i) + rw [hnorm] at h2 +diff --git a/Oka/Analytic/HartogsRegular.lean b/Oka/Analytic/HartogsRegular.lean +index 432a16f62ac5ad92a90eca0977114d4d53d60010..46de5fc3caa70fb03ad1ef71d55289203c64cee7 100644 +--- a/Oka/Analytic/HartogsRegular.lean ++++ b/Oka/Analytic/HartogsRegular.lean +@@ -120,6 +120,8 @@ theorem exists_ne_zero_incl_mem_span_pair {W : (LocalOkaRing (Fin n))[X]} + simp only [smul_eq_mul, ← map_mul, Ideal.Quotient.eq] at hab ⊢ + rw [hdvd] at hab ⊢ + exact hreg _ (by rwa [mul_sub]) ++ have : Algebra.IsIntegral (LocalOkaRing (Fin n)) (LocalOkaRing (Fin (n + 1)) ⧸ I) := ++ Algebra.IsIntegral.of_finite _ _ + obtain ⟨c, hc0, hc⟩ := exists_ne_zero_algebraMap_mem_span_singleton + (R := LocalOkaRing (Fin n)) hx + obtain ⟨a, ha⟩ := Ideal.mem_span_singleton'.mp hc +diff --git a/Oka/Analytic/Laurent/Several.lean b/Oka/Analytic/Laurent/Several.lean +index d7ba12c980a5df7d310c21b8920f868e8dda3da7..c5b2408becda75420165c2e2340a0866b4cfcffb 100644 +--- a/Oka/Analytic/Laurent/Several.lean ++++ b/Oka/Analytic/Laurent/Several.lean +@@ -340,7 +340,7 @@ theorem exists_summable_bound_mcoeff {f : (Fin n → ℂ) → ℂ} + (norm_nonneg _) _) + _ = M * ∏ i, (σ i ^ (-k i) * ‖z i‖ ^ k i) := by rw [Finset.prod_mul_distrib, mul_assoc] + _ ≤ M * ∏ i, β i (k i) := by +- refine mul_le_mul_of_nonneg_left (Finset.prod_le_prod (fun i _ ↦ ?_) fun i _ ↦ ?_) hM0 ++ refine mul_le_mul_of_nonneg_left (Finset.prod_le_prod₀ (fun i _ ↦ ?_) fun i _ ↦ ?_) hM0 + · exact mul_nonneg (zpow_nonneg (hσ i).pos.le _) (zpow_nonneg (norm_nonneg _) _) + · obtain ⟨hz2, hz1⟩ := hz i + rcases le_or_gt 0 (k i) with hk | hk +@@ -561,7 +561,7 @@ theorem differentiableOn_tsum_monomial {b : (Fin n → ℤ) → ℂ} + refine le_trans ?_ (Finset.single_le_sum (f := fun s ↦ ‖b k‖ * ∏ i, τ s i ^ k i) + (fun s _ ↦ mul_nonneg (norm_nonneg _) + (Finset.prod_nonneg fun i _ ↦ zpow_nonneg (hτ s i).pos.le _)) (Finset.mem_univ s₀)) +- refine mul_le_mul_of_nonneg_left (Finset.prod_le_prod ++ refine mul_le_mul_of_nonneg_left (Finset.prod_le_prod₀ + (fun i _ ↦ zpow_nonneg (norm_nonneg _) _) fun i _ ↦ ?_) (norm_nonneg _) + obtain ⟨hz2, hz1⟩ := hz i + rcases le_or_gt 0 (k i) with hki | hki +@@ -604,7 +604,7 @@ theorem differentiableOn_tsum_indicator_mcoeff {f : (Fin n → ℂ) → ℂ} + (Finset.prod_nonneg fun i _ ↦ zpow_nonneg (norm_nonneg _) _)) fun k ↦ ?_ + by_cases hkS : k ∈ S + · rw [Set.indicator_of_mem hkS, norm_mul, norm_monomial] +- refine mul_le_mul_of_nonneg_left (Finset.prod_le_prod ++ refine mul_le_mul_of_nonneg_left (Finset.prod_le_prod₀ + (fun i _ ↦ zpow_nonneg (norm_nonneg _) _) fun i _ ↦ ?_) (norm_nonneg _) + by_cases h : r' i = r i + · rw [hw'eq i h] +diff --git a/Oka/Analytic/Puiseux.lean b/Oka/Analytic/Puiseux.lean +index 05afbc2ddb7910756d06fff090cb1b235dbba8e2..9a5249ab6704717c82c7bebc6a6038bf36ecab97 100644 +--- a/Oka/Analytic/Puiseux.lean ++++ b/Oka/Analytic/Puiseux.lean +@@ -126,7 +126,7 @@ theorem exists_prod_eq_of_mem_base (hG : Convex ℝ G) (hGo : IsOpen G) + exact (Φ ⟨c, ⟨z, hz⟩⟩).2 + have hgcont (c : Cm) : ContinuousOn (g c) (base G) := by + rw [continuousOn_iff_continuous_restrict] +- have : (base G).restrict (g c) = fun z ↦ (Φ ⟨c, z⟩).1.2 := funext fun z ↦ hg c z.2 ++ have : (base G).domRestrict (g c) = fun z ↦ (Φ ⟨c, z⟩).1.2 := funext fun z ↦ hg c z.2 + rw [this] + exact continuous_snd.comp (continuous_subtype_val.comp (Φ.continuous.comp continuous_sigmaMk)) + have hmemk (c : Cm) {z : E × ℂ} (hz : z ∈ base G) : (z.1, z.2 ^ (k c : ℕ)) ∈ base G := by +diff --git a/Oka/AnalyticSpace/Continuity.lean b/Oka/AnalyticSpace/Continuity.lean +index 38d7a2cdc65f7306d3996c08559e74c967a3de6f..fad2deea61f58d9a8ab9baedb5ae754ed1d37d8a 100644 +--- a/Oka/AnalyticSpace/Continuity.lean ++++ b/Oka/AnalyticSpace/Continuity.lean +@@ -244,7 +244,7 @@ theorem continuousAt_eval (z₀ : U) : + ((complexAffineSpace.{u} n).toLocallyRingedSpace.restrict V.isOpenEmbedding)).1 : + ULift.{u} (Fin n) → ℂ) ∈ V.isOpenEmbedding.isOpenMap.functor.obj A := + fun z ↦ ⟨i.base ⟨z.1.1, hWU₀ _ z.2⟩, hB'A (hmemB' _ z.2), rfl⟩ +- have hrestrict : (S.restrict fun z : U ↦ Z.eval z.1 z.2 g) = ++ have hrestrict : (S.domRestrict fun z : U ↦ Z.eval z.1 z.2 g) = + (fun y : V.isOpenEmbedding.isOpenMap.functor.obj A ↦ OkaRing.evalHom y.2 u) ∘ + fun z : S ↦ (⟨_, hmaps z⟩ : V.isOpenEmbedding.isOpenMap.functor.obj A) := + funext fun z ↦ hval _ (hmemB' _ z.2) +diff --git a/Oka/AnalyticSpace/EmptyBase.lean b/Oka/AnalyticSpace/EmptyBase.lean +index 85d680812a7c71b40edd40a65671bd3808a3afcb..be71d82fca9502fa48a0bf324c64537c4a19ea03 100644 +--- a/Oka/AnalyticSpace/EmptyBase.lean ++++ b/Oka/AnalyticSpace/EmptyBase.lean +@@ -195,7 +195,7 @@ are interchangeable because that class is a `Prop`. -/ + theorem SeparatedFiniteEtaleOver.not_galoisCategory_of_isEmpty : + ¬ GaloisCategory (SeparatedFiniteEtaleOver.{u} X) := by + intro h +- obtain ⟨F, ⟨hF⟩⟩ := h.hasFiberFunctor ++ obtain ⟨F, hF⟩ := h.hasFiberFunctor + exact SeparatedFiniteEtaleOver.not_isFiberFunctor_of_isEmpty F hF + + end ComplexAnalytic.AnalyticSpace +diff --git a/Oka/AnalyticSpace/FundamentalGroup.lean b/Oka/AnalyticSpace/FundamentalGroup.lean +index 786c99e8481fb3cf5c9030c61b6b8dae27a74791..a5b9eac5e2d3ca49ef7e8e6124a3a59688d063b3 100644 +--- a/Oka/AnalyticSpace/FundamentalGroup.lean ++++ b/Oka/AnalyticSpace/FundamentalGroup.lean +@@ -338,12 +338,12 @@ Galois cover with a morphism to it. + **No point of the base appears in the statement either, and here that takes an argument.** + `CategoryTheory.PreGaloisCategory.exists_hom_from_galois_of_connected` takes the fibre functor + explicitly, and every fibre functor this repository has is taken at a point of the base; +-`CategoryTheory.PreGaloisCategory.GaloisCategory.getFiberFunctor` is the one the class carries and ++`CategoryTheory.GaloisCategory.getFiberFunctor` is the one the class carries and + it takes none, so it is what this proof feeds the lemma. -/ + theorem SeparatedFiniteEtaleOver.exists_isGalois_hom (A : SeparatedFiniteEtaleOver.{u} X) + [PreGaloisCategory.IsConnected A] : + ∃ (B : SeparatedFiniteEtaleOver.{u} X) (_ : B ⟶ A), PreGaloisCategory.IsGalois B := + PreGaloisCategory.exists_hom_from_galois_of_connected +- (PreGaloisCategory.GaloisCategory.getFiberFunctor _) A ++ (GaloisCategory.getFiberFunctor _) A + + end ComplexAnalytic.AnalyticSpace +diff --git a/Oka/AnalyticSpace/GaloisCategory.lean b/Oka/AnalyticSpace/GaloisCategory.lean +index 98b350d8474d86cee8aa56421812b4cf3aef0f5c..5cc4b7f2ebbba6965005c32a4128b358452b2934 100644 +--- a/Oka/AnalyticSpace/GaloisCategory.lean ++++ b/Oka/AnalyticSpace/GaloisCategory.lean +@@ -338,8 +338,8 @@ of a fibre functor and is, at the commit that adds it, the whole of what this re + about that class. + + `hasFiberFunctor` is the only field. It is the instance above's fibre functor taken at +-`Classical.arbitrary`, and the `Nonempty` half of the field is `inferInstance`, which finds that +-instance: **the class asks for a functor and this repository's fibre functors ask for a point, so ++`Classical.arbitrary`, and `inferInstance` supplies its `FiberFunctor` instance: ++**the class asks for a functor and this repository's fibre functors ask for a point, so + `[Nonempty X]` is exactly the gap** and it is spent here and nowhere else in this file. + + **`[PreconnectedSpace X]` does not give the point**, `IsPreconnected` holding of the empty set, for +@@ -350,6 +350,6 @@ instance SeparatedFiniteEtaleOver.galoisCategory : + GaloisCategory (SeparatedFiniteEtaleOver.{u} X) where + hasFiberFunctor := + ⟨SeparatedFiniteEtaleOver.fintypeFiberFunctor.{u} (Classical.arbitrary (X : Type u)), +- ⟨inferInstance⟩⟩ ++ inferInstance⟩ + + end ComplexAnalytic.AnalyticSpace +diff --git a/Oka/AnalyticSpace/HartogsExtension.lean b/Oka/AnalyticSpace/HartogsExtension.lean +index a6f59b110183fd5e8670bd351e675f59c5ea33f8..67ea3ea9dbd892343a22425f0ebcf50dc6a76531 100644 +--- a/Oka/AnalyticSpace/HartogsExtension.lean ++++ b/Oka/AnalyticSpace/HartogsExtension.lean +@@ -76,7 +76,6 @@ theorem hasHartogsExtension_of_local {O : Z.Opens} + refine (res_res _ h₁ (hBΩ y hy.1) t).symm.trans ?_ + change Z.res h₁ (sectRes (SheafOfModules.unit Z.ringSheaf) (hBΩ y hy.1) t) = _ + rw [ht, hu] +- rfl + + /-- **Hartogs extension passes to larger opens.** -/ + theorem HasHartogsExtension.mono {O O' : Z.Opens} (h : HasHartogsExtension Z O) (hO : O ≤ O') : +diff --git a/Oka/AnalyticSpace/MonicSplitting.lean b/Oka/AnalyticSpace/MonicSplitting.lean +index 8af208f323257c36c0549e45b4c561e8c451a748..0dc537d129f8518ad5182bb16c8bcb866869a60a 100644 +--- a/Oka/AnalyticSpace/MonicSplitting.lean ++++ b/Oka/AnalyticSpace/MonicSplitting.lean +@@ -665,7 +665,7 @@ lemma isPiQuotient_germMap_zero (P : Fin 0 → (LocalOkaRing (Fin n))[X]) : + exact Ideal.zero_mem _ + · rw [MvPolynomial.eq_C_of_isEmpty f] + simp only [germMap_C, Ideal.mem_bot, MvPolynomial.C_eq_zero] +- exact ⟨fun h ↦ by rw [← h2 (MvPolynomial.coeff 0 f), h default, map_zero], ++ exact ⟨fun h ↦ by rw [← h2 (f.coeff 0), h default, map_zero], + fun h _ ↦ by rw [h, map_zero]⟩ + + /-- **Splitting in several variables**: for monic `P₁, …, P_m ∈ ℂ{x}[t]`, the germs at the +diff --git a/Oka/AnalyticSpace/MonoDirectSummand.lean b/Oka/AnalyticSpace/MonoDirectSummand.lean +index 05b2b984eec3188fca13ecbf990b502439105bf3..96dc86f474aef07e2fb8a15658cdda65c8b57cb9 100644 +--- a/Oka/AnalyticSpace/MonoDirectSummand.lean ++++ b/Oka/AnalyticSpace/MonoDirectSummand.lean +@@ -239,22 +239,17 @@ noncomputable def FiniteEtaleOver.selfProdSnd : FiniteEtaleOver.selfProd i ⟶ A + Its triangle over `X` is not `rfl` and is the one place the square is used at the level of + morphisms rather than of points: `A.hom` is `i.left ≫ B.hom` because `i` is a morphism over `X`, + and the two composites to `B.left` agree by +-`ComplexAnalytic.AnalyticSpace.baseChange_square`. **The two `rfl`s after the rewrites are the +-comma-category seam** — `A.hom`'s source is `(𝟭 ComplexAnalytic.AnalyticSpace).obj A.left` and not +-`A.left`, and a rewrite leaves the goal in the second spelling. **The step before them is a +-`change` and not a `show`**, for the reason `ComplexAnalytic.AnalyticSpace.mono_ofRestrict`'s +-docstring gives: the two spellings are `rfl`-equal and not syntactically equal, so +-`linter.style.show` fires and `lake build --wfail` turns the warning into an error, which +-`lake env lean` on a scratch file does not. -/ ++`ComplexAnalytic.AnalyticSpace.baseChange_square`. The `change` aligns the comma-category spelling ++of the target before applying these identities. -/ + noncomputable def FiniteEtaleOver.selfProdFst : FiniteEtaleOver.selfProd i ⟶ A := + haveI : IsFiniteEtale i.left := FiniteEtaleOver.isFiniteEtale_left i + MorphismProperty.Over.homMk (baseChangeFst i.left i.left) (by + have hw : i.left ≫ B.hom = A.hom := MorphismProperty.Over.w i + change baseChangeFst i.left i.left ≫ A.hom = baseChangeSnd i.left i.left ≫ A.hom + have e1 : baseChangeFst i.left i.left ≫ A.hom +- = (baseChangeFst i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw]; rfl ++ = (baseChangeFst i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw] + have e2 : baseChangeSnd i.left i.left ≫ A.hom +- = (baseChangeSnd i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw]; rfl ++ = (baseChangeSnd i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw] + rw [e1, e2, baseChange_square]) + + /-- **A monomorphism of covers is injective on points**, when the target's total space is +diff --git a/Oka/AnalyticSpace/PushforwardStalkCoherent.lean b/Oka/AnalyticSpace/PushforwardStalkCoherent.lean +index 9bef8e578acabf034c54926a2dd6b1e8d7cd2962..8869167716a5e14b1b58d499c35fc7850f661eee 100644 +--- a/Oka/AnalyticSpace/PushforwardStalkCoherent.lean ++++ b/Oka/AnalyticSpace/PushforwardStalkCoherent.lean +@@ -222,7 +222,6 @@ theorem isCoherent_pushUnit_of_stalks + rw [stalkAlgMap_germ] + erw [map_mul] + rw [germ_res_pushforward f (h'.trans h₁W)] +- rfl + obtain ⟨c, hc⟩ := hrel y' hy'W _ hgerm + choose U hyU γ hγ using fun l ↦ Y.presheaf.exists_germ_eq (c l) + obtain ⟨W₂, hyW₂, hW₂⟩ := exists_open_forall Y y' (fun l V ↦ V ≤ U l) +diff --git a/Oka/AnalyticSpace/SeparatedFiniteEtale.lean b/Oka/AnalyticSpace/SeparatedFiniteEtale.lean +index fe033bee08bdb493773cd588fb632bbbf4490b00..835d18362e97be53a54e500d797c6a0cc3ec0c18 100644 +--- a/Oka/AnalyticSpace/SeparatedFiniteEtale.lean ++++ b/Oka/AnalyticSpace/SeparatedFiniteEtale.lean +@@ -409,10 +409,9 @@ noncomputable def SeparatedFiniteEtaleOver.selfProdSnd (i : A ⟶ B) : + + The triangle is `ComplexAnalytic.AnalyticSpace.FiniteEtaleOver.selfProdFst`'s and the proof is + that one read here: `A.hom` is `i.left ≫ B.hom` because `i` is a morphism over `X`, and the two +-composites to `B.left` agree by `ComplexAnalytic.AnalyticSpace.baseChange_square`. **The `change` +-is not a `show` and the two `rfl`s are the comma-category seam**, both for the reasons that +-docstring gives; neither is a stylistic choice and `lake build --wfail` turns the second into an +-error. -/ ++composites to `B.left` agree by `ComplexAnalytic.AnalyticSpace.baseChange_square`. The `change` ++exposes the equality of underlying morphisms, and rewriting by the structure triangle aligns the ++two composites. -/ + noncomputable def SeparatedFiniteEtaleOver.selfProdFst (i : A ⟶ B) : + SeparatedFiniteEtaleOver.selfProd i ⟶ A := + haveI : IsFiniteEtale i.left := SeparatedFiniteEtaleOver.isFiniteEtale_left i +@@ -420,9 +419,9 @@ noncomputable def SeparatedFiniteEtaleOver.selfProdFst (i : A ⟶ B) : + have hw : i.left ≫ B.hom = A.hom := MorphismProperty.Over.w i + change baseChangeFst i.left i.left ≫ A.hom = baseChangeSnd i.left i.left ≫ A.hom + have e1 : baseChangeFst i.left i.left ≫ A.hom +- = (baseChangeFst i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw]; rfl ++ = (baseChangeFst i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw] + have e2 : baseChangeSnd i.left i.left ≫ A.hom +- = (baseChangeSnd i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw]; rfl ++ = (baseChangeSnd i.left i.left ≫ i.left) ≫ B.hom := by rw [Category.assoc, hw] + rw [e1, e2, baseChange_square]) + + /-- **A monomorphism of this category is injective on points**, over a Hausdorff base. +diff --git a/Oka/AnalyticSpace/SeparatedFiniteEtaleLimits.lean b/Oka/AnalyticSpace/SeparatedFiniteEtaleLimits.lean +index 8ff2c0ca4a569d5fcfd505a69f4ee81a59056fb8..76bc85f173d0ebc89e2811a8377f6b7107092b57 100644 +--- a/Oka/AnalyticSpace/SeparatedFiniteEtaleLimits.lean ++++ b/Oka/AnalyticSpace/SeparatedFiniteEtaleLimits.lean +@@ -290,13 +290,8 @@ def fibreProdSnd (i : A ⟶ C) (j : B ⟶ C) : fibreProd i j ⟶ B := + The triangle over `X` is where `ComplexAnalytic.AnalyticSpace.baseChange_square` is spent: `A.hom` + is `i.left ≫ C.hom` and `B.hom` is `j.left ≫ C.hom`, both because a morphism of this category + commutes with the structure maps, and the two composites into `C.left` agree by that square. +-**The `change` is not a `show` and the two `rfl`s at the ends of `e1` and `e2` are the comma +-category's seam**, for the reason +-`ComplexAnalytic.AnalyticSpace.SeparatedFiniteEtaleOver.selfProdFst`'s docstring gives of the same +-two lines: `CategoryTheory.MorphismProperty.Over` is a comma category over +-`CategoryTheory.Functor.id`, so a structure morphism's source is `(𝟭 _).obj A.left` rather than +-`A.left`, and a `rw` whose motive crosses that unifier fails on an instance argument rather than +-on the equation. -/ ++The `change` exposes the equality of underlying morphisms, and rewriting by the two structure ++triangles aligns the composites with the base-change square. -/ + def fibreProdFst (i : A ⟶ C) (j : B ⟶ C) : fibreProd i j ⟶ A := + haveI : IsFiniteEtale i.left := isFiniteEtale_left i + MorphismProperty.Over.homMk (baseChangeFst i.left j.left) (by +@@ -304,9 +299,9 @@ def fibreProdFst (i : A ⟶ C) (j : B ⟶ C) : fibreProd i j ⟶ A := + have hj : j.left ≫ C.hom = B.hom := MorphismProperty.Over.w j + change baseChangeFst i.left j.left ≫ A.hom = baseChangeSnd i.left j.left ≫ B.hom + have e1 : baseChangeFst i.left j.left ≫ A.hom +- = (baseChangeFst i.left j.left ≫ i.left) ≫ C.hom := by rw [Category.assoc, hi]; rfl ++ = (baseChangeFst i.left j.left ≫ i.left) ≫ C.hom := by rw [Category.assoc, hi] + have e2 : baseChangeSnd i.left j.left ≫ B.hom +- = (baseChangeSnd i.left j.left ≫ j.left) ≫ C.hom := by rw [Category.assoc, hj]; rfl ++ = (baseChangeSnd i.left j.left ≫ j.left) ≫ C.hom := by rw [Category.assoc, hj] + rw [e1, e2, baseChange_square]) + + /-- **The square commutes in this category.** +diff --git a/Oka/Analytification/GAGA/CartanApprox.lean b/Oka/Analytification/GAGA/CartanApprox.lean +index 581b56da7387628e1e8cbd2d04a85b54a7b5f8f7..7ff68a39f4b23872a67738eedb69456f2f9bcbfc 100644 +--- a/Oka/Analytification/GAGA/CartanApprox.lean ++++ b/Oka/Analytification/GAGA/CartanApprox.lean +@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE. + Authors: Christian Merten + -/ + import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff ++import Mathlib.Topology.Algebra.Group.Units + import Oka.Analytification.GAGA.CartanNearOne + + /-! +diff --git a/Oka/Analytification/GAGA/CechProjectiveAn.lean b/Oka/Analytification/GAGA/CechProjectiveAn.lean +index ed2fc5a4c0c28f13f73dce5965442ec38dfa1e31..1ef973c306c5469e0aee642766c9e454801391cc 100644 +--- a/Oka/Analytification/GAGA/CechProjectiveAn.lean ++++ b/Oka/Analytification/GAGA/CechProjectiveAn.lean +@@ -213,7 +213,7 @@ lemma SummableAt.of_le {a b : Coeff n} {w w' : Fin (n + 1) → ℂ} (h : Summabl + by_cases hk : a k = 0 + · simp only [hk, norm_zero, zero_mul] + exact mul_nonneg (norm_nonneg _) (Finset.prod_nonneg fun i _ ↦ zpow_nonneg (norm_nonneg _) _) +- · exact mul_le_mul (hab k hk).1 (Finset.prod_le_prod ++ · exact mul_le_mul (hab k hk).1 (Finset.prod_le_prod₀ + (fun i _ ↦ zpow_nonneg (norm_nonneg _) _) fun i _ ↦ (hab k hk).2 i) + (Finset.prod_nonneg fun i _ ↦ zpow_nonneg (norm_nonneg _) _) (norm_nonneg _) + +diff --git a/Oka/Analytification/GAGA/MittagLeffler.lean b/Oka/Analytification/GAGA/MittagLeffler.lean +index 711b9c7df2560db92075615b89aebac7fd9690b7..52bdc81437280d285be3c9d6c4d6310947d15841 100644 +--- a/Oka/Analytification/GAGA/MittagLeffler.lean ++++ b/Oka/Analytification/GAGA/MittagLeffler.lean +@@ -77,7 +77,7 @@ theorem differentiableOn_of_tendstoLocallyUniformlyOn {ι : Type*} {l : Filter + have hKle : ∀ θ, ‖∏ i, (torusMap (0 : Fin m → ℂ) (fun _ ↦ ρ) θ i - y i)⁻¹‖ ≤ Cy := by + intro θ + rw [norm_prod] +- refine Finset.prod_le_prod (fun i _ ↦ norm_nonneg _) fun i _ ↦ ?_ ++ refine Finset.prod_le_prod₀ (fun i _ ↦ norm_nonneg _) fun i _ ↦ ?_ + rw [norm_inv] + have h2 := norm_sub_norm_le (torusMap (0 : Fin m → ℂ) (fun _ ↦ ρ) θ i) (y i) + rw [hnorm] at h2 +diff --git a/Oka/Analytification/GAGA/Proper/CechProjectiveBox.lean b/Oka/Analytification/GAGA/Proper/CechProjectiveBox.lean +index bf41f8f5c8ed23452192f3404e1795f9d43356a7..0cbb53b33705b6acdbbf9a6b154f188559745578 100644 +--- a/Oka/Analytification/GAGA/Proper/CechProjectiveBox.lean ++++ b/Oka/Analytification/GAGA/Proper/CechProjectiveBox.lean +@@ -225,7 +225,7 @@ lemma tsum_proj_toCoeff_eq + have hmono : ∀ k, negSupp k = N → ‖monomial k w‖ ≤ ‖monomial k w'‖ := by + intro k hk + rw [norm_monomial, norm_monomial] +- refine Finset.prod_le_prod (fun i _ ↦ zpow_nonneg (norm_nonneg _) _) fun i _ ↦ ?_ ++ refine Finset.prod_le_prod₀ (fun i _ ↦ zpow_nonneg (norm_nonneg _) _) fun i _ ↦ ?_ + by_cases hi : i ∈ I ∧ i ∉ N + · have : 0 ≤ k i := not_lt.1 fun h ↦ hi.2 (hk ▸ mem_negSupp.2 h) + simp only [w', hi, not_false_eq_true, and_self, if_true, Complex.norm_real, +diff --git a/Oka/Analytification/GAGA/Proper/GAGA3.lean b/Oka/Analytification/GAGA/Proper/GAGA3.lean +index d4040ca5b5330f7b491348fb1e5ad38b0c933989..ee911b977eabb89db35f547769f37bd039194b38 100644 +--- a/Oka/Analytification/GAGA/Proper/GAGA3.lean ++++ b/Oka/Analytification/GAGA/Proper/GAGA3.lean +@@ -194,14 +194,14 @@ theorem genericAlgebraization_of_isProperℂ (H : RelativeAnalyticSerre.{u}) + exact hw + have b₁ := fA.bijective_stalkFunctor_map_unit hf M + have b₂ := fA.bijective_stalkFunctor_map_pushforward hf _ hμ +- have b₃ := (((analytification.obj T).toLocallyRingedSpace.stalkFunctor +- (fA.base (ιA.base q))).mapIso +- (asIso (inv (analytificationPushforwardBaseChange π +- (twistAlong j G m))))).toLinearEquiv.bijective ++ have b₃ := ConcreteCategory.bijective_of_isIso ++ (((analytification.obj T).toLocallyRingedSpace.stalkFunctor ++ (fA.base (ιA.base q))).map ++ (inv (analytificationPushforwardBaseChange π (twistAlong j G m)))) + change Function.Bijective (((analytification.obj T).toLocallyRingedSpace.stalkFunctor + (fA.base (ιA.base q))).map ψ) +- simp only [ψ, Functor.map_comp, ConcreteCategory.coe_comp] +- exact b₃.comp (b₂.comp b₁) ++ simpa only [ψ, Functor.map_comp, ConcreteCategory.coe_comp, Function.comp_assoc] using ++ b₃.comp (b₂.comp b₁) + + variable (X) in + /-- **GAGA-3 for proper schemes**, assuming the analytic relative Serre theorem +diff --git a/Oka/Analytification/GAGA/Proper/RelativeBaseChangeTwist.lean b/Oka/Analytification/GAGA/Proper/RelativeBaseChangeTwist.lean +index e79d757c932d7223beb60e4a36231f3d6ac50ce6..83de59ad652db961074bfbd69a4aeb609aa7743f 100644 +--- a/Oka/Analytification/GAGA/Proper/RelativeBaseChangeTwist.lean ++++ b/Oka/Analytification/GAGA/Proper/RelativeBaseChangeTwist.lean +@@ -258,7 +258,7 @@ lemma eval₂_monoPoly {e : ℕ} (s : MonoExp N e) (y : Fin m → ℂ) (v : Fin + /-- **A homogeneous polynomial is the sum of its monomials.** -/ + lemma eq_sum_monoPoly {e : ℕ} (p : 𝒜 e) : + (p : MvPolynomial (Fin (N + 1)) (RelBase.{u} m)) = +- ∑ s : MonoExp N e, C (coeff (monoExpFinsupp s) (p : MvPolynomial _ _)) * ++ ∑ s : MonoExp N e, C ((p : MvPolynomial _ _).coeff (monoExpFinsupp s)) * + (monoPoly.{u} (m := m) s : MvPolynomial (Fin (N + 1)) (RelBase.{u} m)) := by + refine MvPolynomial.ext _ _ fun d ↦ ?_ + simp only [monoPoly, coeff_sum, coeff_C_mul, coeff_monomial] +@@ -320,13 +320,14 @@ lemma globalSectionsEquiv_smul (hN : 1 ≤ N) (e : ℕ) (a : RelBase.{u} m) + `p = globalSectionsEquiv s`. -/ + lemma eq_sum_smul_monoSec (hN : 1 ≤ N) (e : ℕ) + (s : AlgSec (twistingSheaf N (RelBase.{u} m) e)) : +- s = ∑ t : MonoExp N e, coeff (monoExpFinsupp t) +- (globalSectionsEquiv hN e s : MvPolynomial (Fin (N + 1)) (RelBase.{u} m)) • monoSec hN t := by ++ s = ∑ t : MonoExp N e, ++ (globalSectionsEquiv hN e s : MvPolynomial (Fin (N + 1)) (RelBase.{u} m)).coeff ++ (monoExpFinsupp t) • monoSec hN t := by + apply (globalSectionsEquiv (R := RelBase.{u} m) hN e).injective + apply Subtype.ext + have h1 := map_sum (globalSectionsEquiv (R := RelBase.{u} m) hN e) +- (fun t ↦ coeff (monoExpFinsupp t) +- (globalSectionsEquiv hN e s : MvPolynomial (Fin (N + 1)) (RelBase.{u} m)) • monoSec hN t) ++ (fun t ↦ (globalSectionsEquiv hN e s : MvPolynomial (Fin (N + 1)) (RelBase.{u} m)).coeff ++ (monoExpFinsupp t) • monoSec hN t) + Finset.univ + refine Eq.trans ?_ (congrArg Subtype.val h1).symm + rw [Submodule.coe_sum] +@@ -373,8 +374,9 @@ lemma surjective_monoTensor (e : ℕ) : Function.Surjective (monoTensor.{u} D hN + induction x using TensorProduct.induction_on with + | zero => exact ⟨0, by simp [monoTensor]⟩ + | tmul f s => +- refine ⟨fun t ↦ polyToOka.{u} D (coeff (monoExpFinsupp t) +- (globalSectionsEquiv hN e s : MvPolynomial (Fin (N + 1)) (RelBase.{u} m))) * f, ?_⟩ ++ refine ⟨fun t ↦ polyToOka.{u} D ++ ((globalSectionsEquiv hN e s : MvPolynomial (Fin (N + 1)) (RelBase.{u} m)).coeff ++ (monoExpFinsupp t)) * f, ?_⟩ + conv_rhs => rw [eq_sum_smul_monoSec hN e s] + rw [TensorProduct.tmul_sum, monoTensor] + refine Finset.sum_congr rfl fun t _ ↦ ?_ +diff --git a/Oka/Analytification/RET/ES/BoundedSections.lean b/Oka/Analytification/RET/ES/BoundedSections.lean +index 1d5a6fa3eaecf2a4e1e242e0c0ca0386d022a1f4..323af19a698cee76c7cd2f63689e4af17ea83bd0 100644 +--- a/Oka/Analytification/RET/ES/BoundedSections.lean ++++ b/Oka/Analytification/RET/ES/BoundedSections.lean +@@ -153,7 +153,7 @@ lemma evalFun_of_mem {Z : AnalyticSpace.{u}} {O : Z.Opens} (a : Z.presheaf.obj ( + lemma continuousOn_evalFun {Z : AnalyticSpace.{u}} {O : Z.Opens} (a : Z.presheaf.obj (op O)) : + ContinuousOn (evalFun a) O := by + rw [continuousOn_iff_continuous_restrict] +- have : (O : Set Z).restrict (evalFun a) = fun z : O ↦ Z.eval z.1 z.2 a := ++ have : (O : Set Z).domRestrict (evalFun a) = fun z : O ↦ Z.eval z.1 z.2 a := + funext fun z ↦ evalFun_of_mem a z.2 + rw [this] + exact Z.continuous_eval a +@@ -391,7 +391,7 @@ theorem exists_local_sheets [T2Space W.left] {x₀ : Cn.{u} n} (hx₀ : x₀ ∈ + simp only [σ, dif_pos hxN, hG i _ hxU] + exact congrArg Subtype.val (hfG i _ hxU) + · rw [continuousOn_iff_continuous_restrict] +- have : B.restrict (σ i) = fun x : B ↦ ++ have : B.domRestrict (σ i) = fun x : B ↦ + (H.symm (⟨⟨x.1, (hB x.1 x.2).1⟩, (hB x.1 x.2).2⟩, i)).1 := by + funext x + simp only [Set.restrict_apply, σ, dif_pos (hB x.1 x.2).1, hG i _ (hB x.1 x.2).2] +diff --git a/Oka/Analytification/RET/ES/BoundedSectionsHartogs.lean b/Oka/Analytification/RET/ES/BoundedSectionsHartogs.lean +index b522e0bee17bfd58c8ad0c8d31227ee13ced1eee..374151aa665364f60f09866aa196f6254cdc5b57 100644 +--- a/Oka/Analytification/RET/ES/BoundedSectionsHartogs.lean ++++ b/Oka/Analytification/RET/ES/BoundedSectionsHartogs.lean +@@ -207,8 +207,8 @@ theorem mem_boundedSubring_of_map_mem [T2Space W.left] (hD : HasThinComplement N + obtain ⟨c', hc'⟩ := (bijective_map_of_regularPairFamily P hVU hV'V hV').2 (c k) + refine ⟨c', fun x hx hxN ↦ ?_⟩ + rw [← holFun_map hV'V c' hx, hc', hc k x hx hxN] +- congr 1 +- refine charPolyFun_congr W fun w hw ↦ ha' w ((mem_preim_iff h₀ W).2 (hw ▸ hx)) ++ exact congrArg (fun p : Polynomial ℂ ↦ p.coeff k) ++ (charPolyFun_congr W fun w hw ↦ ha' w ((mem_preim_iff h₀ W).2 (hw ▸ hx))) + choose c' hc' using hc' + -- a ball around `x₀` in `img V`, over which the number of sheets is constant + obtain ⟨ε, hε, hball⟩ := Metric.isOpen_iff.1 (img V).isOpen x₀ hx₀ +diff --git a/Oka/Analytification/RET/ES/CapExtension/ChartReverse.lean b/Oka/Analytification/RET/ES/CapExtension/ChartReverse.lean +index 8a4d84a8547b1140fd711465a10c7e6618a6d2b4..519a5c78ebf048be99ce17661e14b605b44c4692 100644 +--- a/Oka/Analytification/RET/ES/CapExtension/ChartReverse.lean ++++ b/Oka/Analytification/RET/ES/CapExtension/ChartReverse.lean +@@ -67,7 +67,9 @@ theorem hasLocalModuleRelationsAt_of {z : Z} (hM : HasLocalModuleRelationsAt M ( + refine ⟨C.pre W, hpreV, k, fun l i ↦ C.ψ (C.pre W) (Y.res hWe.le (g l i)), hzW, + fun l ↦ ?_, fun W' hW' a ha y hy ↦ ?_⟩ + · have := congrArg (fun s ↦ C.φ (C.pre W) (sectRes M hWe.le s)) (hrel l) +- simp only [sectRes_sum, sectRes_smul, C.φ_sum, sectRes_zero, map_zero] at this ++ simp only [sectRes_sum, sectRes_smul, C.φ_sum, sectRes_zero] at this ++ have hzero : C.φ (C.pre W) 0 = 0 := (C.φ (C.pre W)).map_zero ++ rw [hzero] at this + rw [← this] + refine Finset.sum_congr rfl fun i _ ↦ ?_ + rw [C.φ_smul, sectRes_sectRes, C.φ_res hpreV, φ_φInv] +@@ -92,6 +94,8 @@ theorem hasLocalModuleRelationsAt_of {z : Z} (hM : HasLocalModuleRelationsAt M ( + rw [C.ψ_res hpre, ψ_ψInv] + rw [e₁, ← Y.res_res hW''e.le hW'', this] + refine Finset.sum_congr rfl fun l _ ↦ ?_ ++ change C.ψ (C.pre W'') (Y.res hW''e.le ++ (c l * Y.res (hW''.trans hW'e) (g l i))) = _ + rw [res_mul, map_mul, Y.res_res, C.ψ_res_res _ (hpre.trans hW') hWe.le] + + end AlgebraicGeometry.LocallyRingedSpace.ModuleChart +diff --git a/Oka/Analytification/RET/ES/Codim2/BPointConfig.lean b/Oka/Analytification/RET/ES/Codim2/BPointConfig.lean +index 42cbba4b625bf4eedd6512f31b175e5b96c88a8a..33f963d8779e62c9d631495ab0359703f3f4d5ef 100644 +--- a/Oka/Analytification/RET/ES/Codim2/BPointConfig.lean ++++ b/Oka/Analytification/RET/ES/Codim2/BPointConfig.lean +@@ -268,7 +268,7 @@ lemma sec_mem_region {p : Cn.{u} n × ℂ} (hp : p.1 ∈ d.G') (ht : ‖p.2‖ < + lemma differentiableOn_Q_coeff (k : ℕ) : + DifferentiableOn ℂ (d.Q.coeff k) (d.G' ×ˢ ball 0 d.r) := by + have hsec : Differentiable ℂ d.sec := differentiableOn_univ.1 +- (differentiableOn_update (fun e _ ↦ ((differentiable_baseProj (it := d.it) (iw := d.iw) ++ (differentiableOn_update (fun (e : Cn.{u} n × ℂ) _ ↦ ((differentiable_baseProj (it := d.it) (iw := d.iw) + e.1).comp e differentiableAt_fst).differentiableWithinAt) + differentiable_snd.differentiableOn d.it) + have : d.Q.coeff k = fun p ↦ d.P.coeff k (d.sec p) := funext (d.Q_coeff k) +diff --git a/Oka/Analytification/RET/ES/Codim2/NormalCrossingsBasis.lean b/Oka/Analytification/RET/ES/Codim2/NormalCrossingsBasis.lean +index ef039b72945947b5f998d5ae0388d3928a9a992a..6866f4cdc162bc7fa5eff6c06bb1eca0c406b212 100644 +--- a/Oka/Analytification/RET/ES/Codim2/NormalCrossingsBasis.lean ++++ b/Oka/Analytification/RET/ES/Codim2/NormalCrossingsBasis.lean +@@ -121,7 +121,7 @@ lemma norm_val_le (i : K.ι) (w : W.left) : ‖K.val i w‖ ≤ 1 := by + by_cases h : ∃ u, K.Φ i.1 u = w + · obtain ⟨u, hu⟩ := h + rw [K.val_eq i hu, KummerPi.monomial, norm_prod] +- refine Finset.prod_le_one (fun _ _ ↦ norm_nonneg _) fun k _ ↦ ?_ ++ refine Finset.prod_le_one₀ (fun _ _ ↦ norm_nonneg _) fun k _ ↦ ?_ + rw [norm_pow] + exact pow_le_one₀ (norm_nonneg _) ((KummerPi.mem_base.1 u.2).2 k).2.le + · rw [K.val_eq_zero i fun u hu ↦ h ⟨u, hu⟩, norm_zero] +@@ -164,7 +164,7 @@ theorem exists_eval_eq_val (i : K.ι) : + dif_pos hz + have hΦ'c : ContinuousOn Φ' (KummerPi.base χ.B r) := by + rw [continuousOn_iff_continuous_restrict] +- have : (KummerPi.base χ.B r).restrict Φ' = K.Φ c := funext fun z ↦ hΦ' z.1 z.2 ++ have : (KummerPi.base χ.B r).domRestrict Φ' = K.Φ c := funext fun z ↦ hΦ' z.1 z.2 + rw [this] + exact K.continuous c + obtain ⟨O₁, hwO₁, hinj, -⟩ := exists_sheet W w +diff --git a/Oka/Analytification/RET/ES/Codim2/PuiseuxCoord.lean b/Oka/Analytification/RET/ES/Codim2/PuiseuxCoord.lean +index 7b372bc3b5887bd9987d5c7557b18322f7eff199..11746c11c844207227ba398ed8db69828a17134f 100644 +--- a/Oka/Analytification/RET/ES/Codim2/PuiseuxCoord.lean ++++ b/Oka/Analytification/RET/ES/Codim2/PuiseuxCoord.lean +@@ -378,7 +378,7 @@ lemma exists_norm_sub_zeta_pow_mul_lt {s : ℕ} (hs : 0 < s) {a b : ℂ} {r : + rw [hζ.pow_sub_pow_eq_prod_sub_mul a b hs, norm_prod] + calc r ^ s = ∏ _μ ∈ Polynomial.nthRootsFinset s (1 : ℂ), r := by + rw [Finset.prod_const, hζ.card_nthRootsFinset] +- _ ≤ _ := Finset.prod_le_prod (fun _ _ ↦ hr.le) hle ++ _ ≤ _ := Finset.prod_le_prod₀ (fun _ _ ↦ hr.le) hle + exact absurd h (not_lt.2 this) + + /-- **The preimage of a small neighbourhood off `t = 0` splits into `s` pieces.** Let `y'` be a +diff --git a/Oka/Analytification/RET/ES/CurveEtale.lean b/Oka/Analytification/RET/ES/CurveEtale.lean +index 1f1cd2b0a5ea2b932ae4ed78e97c6c11ba0671cf..d0efa5d5eace75f3f0da7be0822b314e89f41db1 100644 +--- a/Oka/Analytification/RET/ES/CurveEtale.lean ++++ b/Oka/Analytification/RET/ES/CurveEtale.lean +@@ -173,16 +173,18 @@ lemma exists_ltSeries_of_isIntegral (hinj : Function.Injective (algebraMap R S)) + (l : LTSeries (PrimeSpectrum R)) : + ∃ L : LTSeries (PrimeSpectrum S), L.length = l.length ∧ + L.last.asIdeal.comap (algebraMap R S) = l.last.asIdeal := by ++ have : FaithfulSMul R S := (faithfulSMul_iff_algebraMap_injective R S).mpr hinj + induction l using RelSeries.inductionOn' with + | singleton p => + obtain ⟨Q, -, hQ, hQp⟩ := Ideal.exists_ideal_over_prime_of_isIntegral p.asIdeal (⊥ : Ideal S) +- (by rw [← RingHom.ker_eq_comap_bot, (RingHom.injective_iff_ker_eq_bot _).1 hinj] ++ (by rw [Ideal.under_bot] + exact bot_le) + exact ⟨RelSeries.singleton _ ⟨Q, hQ⟩, rfl, hQp⟩ + | snoc l p hlp ih => + obtain ⟨L, hL, hLl⟩ := ih ++ have hLl' : Ideal.under R L.last.asIdeal = l.last.asIdeal := hLl + obtain ⟨Q, hQL, hQ, hQp⟩ := Ideal.exists_ideal_over_prime_of_isIntegral_of_isPrime +- p.asIdeal L.last.asIdeal (by rw [hLl]; exact le_of_lt hlp) ++ p.asIdeal L.last.asIdeal (by rw [hLl']; exact le_of_lt hlp) + have hlp' : l.last < p := hlp + have hlt : L.last < ⟨Q, hQ⟩ := lt_of_le_of_ne hQL fun h ↦ hlp'.ne (PrimeSpectrum.ext + (hLl.symm.trans ((congrArg (fun P : PrimeSpectrum S ↦ P.asIdeal.comap (algebraMap R S)) +@@ -211,8 +213,8 @@ theorem exists_finite_injective_of_ringKrullDim_eq_one {k A : Type*} [Field k] [ + letI := g.toRingHom.toAlgebra + haveI : Module.Finite (MvPolynomial (Fin s) k) A := hfin + have hdimP : ringKrullDim (MvPolynomial (Fin s) k) = s := by +- rw [MvPolynomial.ringKrullDim_of_isNoetherianRing, ringKrullDim_eq_zero_of_field, +- Nat.card_eq_fintype_card, Fintype.card_fin, zero_add] ++ rw [MvPolynomial.ringKrullDim_of_isNoetherianRing, ringKrullDim_eq_zero_of_field] ++ simp + have h1 := ringKrullDim_le_of_isIntegral (R := MvPolynomial (Fin s) k) (S := A) + have h2 := ringKrullDim_le_of_isIntegral_of_injective (R := MvPolynomial (Fin s) k) (S := A) + hinj +diff --git a/Oka/Analytification/RET/ES/CurveSections.lean b/Oka/Analytification/RET/ES/CurveSections.lean +index df0b02dc61ad7a8299c7f6e2fd8147131fed5625..9caecf1061ad875322897d1ce7f6b30880f6775c 100644 +--- a/Oka/Analytification/RET/ES/CurveSections.lean ++++ b/Oka/Analytification/RET/ES/CurveSections.lean +@@ -298,6 +298,34 @@ lemma eval_growthVal (f : W.presheaf.obj (op ⊤)) (k : ℕ) {V : (projectiveSpa + rw [growthVal, map_mul, eval_presheaf_map, eval_presheaf_map, + eval_c_app _ (toProjectiveLine ρ₀).isCLinear] + ++private lemma norm_eval_growthVal (f : W.presheaf.obj (op ⊤)) (k : ℕ) ++ {V : (projectiveSpaceAn.{u} 1).Opens} ++ (t : (pbTwist πP (twistCocycle.{u} k)).val.obj (op V)) (w : W) ++ (hw : (toProjectiveLine ρ₀).toLRSHom.base w ∈ V) ++ (hw1 : (toProjectiveLine ρ₀).toLRSHom.base w ∈ V ⊓ preimOpen πP (stdU 1)) : ++ ‖W.eval w hw (growthVal ρ₀ f k t)‖ = ++ ‖coord (ρ₀.toLRSHom.base w) ^ (-(k : ℤ))‖ * ++ ‖(projectiveSpaceAn.{u} 1).eval _ hw1 (pbComp t 1)‖ * ++ ‖W.eval (U := ⊤) w trivial f‖ := by ++ let z := coord (ρ₀.toLRSHom.base w) ++ let q := pointOfVec.{u} ![1, z] (by simp) ++ have hpt : (toProjectiveLine ρ₀).toLRSHom.base w = q := ++ chart_zero_eq_pointOfVec _ ++ have hp0 : (toProjectiveLine ρ₀).toLRSHom.base w ∈ V ⊓ preimOpen πP (stdU 0) := ++ ⟨hw, πP_chart_mem 0 _⟩ ++ have hq0 : q ∈ V ⊓ preimOpen πP (stdU 0) := hpt ▸ hp0 ++ have hq1 : q ∈ V ⊓ preimOpen πP (stdU 1) := hpt ▸ hw1 ++ have e0 := eval_pbComp_zero k t z hq0 hq1 ++ have echart : (projectiveSpaceAn.{u} 1).eval _ hp0 (pbComp t 0) = ++ z ^ (-(k : ℤ)) * (projectiveSpaceAn.{u} 1).eval _ hw1 (pbComp t 1) := ++ (eval_congr_point hpt hp0 hq0 (pbComp t 0)).trans ++ (e0.trans (congrArg (fun a : ℂ ↦ z ^ (-(k : ℤ)) * a) ++ (eval_congr_point hpt hw1 hq1 (pbComp t 1)).symm)) ++ have egrowth := (eval_growthVal ρ₀ f k t w hw).trans ++ (congrArg (fun a : ℂ ↦ a * W.eval (U := ⊤) w trivial f) echart) ++ exact (congrArg norm egrowth).trans ((norm_mul _ _).trans ++ (congrArg (· * ‖W.eval (U := ⊤) w trivial f‖) (norm_mul _ _))) ++ + lemma isBoundedNear_growthVal (f : W.presheaf.obj (op ⊤)) (k : ℕ) (C R : ℝ) (hR : 0 < R) + (hf : ∀ w : W, R < ‖coord (ρ₀.toLRSHom.base w)‖ → + ‖W.eval (U := ⊤) w trivial f‖ ≤ C * ‖coord (ρ₀.toLRSHom.base w)‖ ^ k) +@@ -317,18 +345,13 @@ lemma isBoundedNear_growthVal (f : W.presheaf.obj (op ⊤)) (k : ℕ) (C R : ℝ + set z := coord (ρ₀.toLRSHom.base w) + have hzR : R < ‖z‖ := (chart_zero_mem_nbd_iff hR _).1 hwN.2 + have hz0 : z ≠ 0 := norm_pos_iff.1 (hR.trans hzR) +- have hpt : (toProjectiveLine ρ₀).toLRSHom.base w = pointOfVec.{u} ![1, z] (by simp) := +- chart_zero_eq_pointOfVec _ + have hw1 : (toProjectiveLine ρ₀).toLRSHom.base w ∈ V ⊓ preimOpen πP (stdU 1) := by + refine ⟨hw, ?_⟩ + have := πP_chart_mem 1 (ofCoord z⁻¹) + rw [← chart_zero_eq_chart_one _ hz0] at this + exact this + have hbdt := hwN.1 ⟨_, hw1⟩ rfl +- rw [eval_growthVal] +- have e0 := eval_pbComp_zero k t z (hpt ▸ ⟨hw, πP_chart_mem 0 _⟩) (hpt ▸ hw1) +- rw [eval_congr_point hpt _ (hpt ▸ ⟨hw, πP_chart_mem 0 _⟩), e0, norm_mul, norm_mul, +- ← eval_congr_point hpt hw1 (hpt ▸ hw1)] ++ rw [norm_eval_growthVal ρ₀ f k t w hw hw1] + have hzk : ‖z ^ (-(k : ℤ))‖ * ‖z‖ ^ k = 1 := by + rw [norm_zpow, zpow_neg, zpow_natCast, inv_mul_cancel₀ (pow_ne_zero _ (norm_ne_zero_iff.2 hz0))] + calc ‖z ^ (-(k : ℤ))‖ * ‖(projectiveSpaceAn.{u} 1).eval _ hw1 (pbComp t 1)‖ * +@@ -386,13 +409,9 @@ lemma growthVal_res {V V' : (projectiveSpaceAn.{u} 1).Opens} (h : V' ≤ V) + · have := c_app_res (M := W.toLocallyRingedSpace) (toProjectiveLine ρ₀).toLRSHom + (inf_le_inf_right _ h : V' ⊓ preimOpen πP (stdU 0) ≤ V ⊓ preimOpen πP (stdU 0)) (pbComp t 0) + refine (congrArg (W.presheaf.map _).hom this).trans ?_ +- change W.presheaf.map _ (W.presheaf.map _ _) = W.presheaf.map _ (W.presheaf.map _ _) +- rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply, ← W.presheaf.map_comp, +- ← W.presheaf.map_comp] +- rfl +- · change _ = W.presheaf.map _ (W.presheaf.map _ f) +- rw [← ConcreteCategory.comp_apply, ← W.presheaf.map_comp] +- rfl ++ exact (res_res W.toLocallyRingedSpace _ _ (ρPull ρ₀ (pbComp t 0))).trans ++ (res_res W.toLocallyRingedSpace _ _ (ρPull ρ₀ (pbComp t 0))).symm ++ · exact (res_res W.toLocallyRingedSpace _ _ f).symm + + include hR hf in + /-- The section of the extension given by `t₀ · f`. -/ +diff --git a/Oka/Analytification/RET/ES/CurveSetup.lean b/Oka/Analytification/RET/ES/CurveSetup.lean +index ab3d6f13647c172f21ff20674d9988789f2e5a2f..8c31a79e2c9b84ee720797942c18f4ffad9b6e60 100644 +--- a/Oka/Analytification/RET/ES/CurveSetup.lean ++++ b/Oka/Analytification/RET/ES/CurveSetup.lean +@@ -117,15 +117,14 @@ lemma etale_restrictι_comp_toAffineSpace (f : Γ(V.obj.left, ⊤)) + (Scheme.ΓSpecIso (.of (MvPolynomial (Fin N) (ULift.{u} ℂ)))).inv _).1 + ((RingHom.Etale.respectsIso.cancel_right_isIso _ U.topIso.hom).1 ?_) + convert hf using 2 +- · rfl +- · refine RingHom.ext fun p ↦ ?_ +- change U.topIso.hom (U.ι.appTop ((SchemeLFTℂ.toAffineSpace s hs).hom.left.appTop +- ((Scheme.ΓSpecIso (.of (MvPolynomial (Fin N) (ULift.{u} ℂ)))).inv p))) = _ +- rw [SchemeLFTℂ.toAffineSpace_appTop] +- change (U.ι.appTop ≫ U.topIso.hom) (s p) = V.obj.left.presheaf.map _ (s p) +- rw [Scheme.Opens.ι_appTop, Scheme.Opens.topIso_hom] +- erw [← Functor.map_comp] +- rfl ++ refine RingHom.ext fun p ↦ ?_ ++ change U.topIso.hom (U.ι.appTop ((SchemeLFTℂ.toAffineSpace s hs).hom.left.appTop ++ ((Scheme.ΓSpecIso (.of (MvPolynomial (Fin N) (ULift.{u} ℂ)))).inv p))) = _ ++ rw [SchemeLFTℂ.toAffineSpace_appTop] ++ change (U.ι.appTop ≫ U.topIso.hom) (s p) = V.obj.left.presheaf.map _ (s p) ++ rw [Scheme.Opens.ι_appTop, Scheme.Opens.topIso_hom] ++ erw [← Functor.map_comp] ++ rfl + + end Etale + +diff --git a/Oka/Analytification/RET/ES/FiniteCoherent.lean b/Oka/Analytification/RET/ES/FiniteCoherent.lean +index 8a7bd9900ee3dee401920de065d542498da41e09..59834fd242ae5c33dfdb49bab139118fa01eb22e 100644 +--- a/Oka/Analytification/RET/ES/FiniteCoherent.lean ++++ b/Oka/Analytification/RET/ES/FiniteCoherent.lean +@@ -157,7 +157,7 @@ theorem isCoherent_pushUnit_analytification_map {Y S : SchemeLFTℂ.{u}} [IsAffi + simp [π, Fintype.linearCombination_apply, Algebra.smul_def, RingHom.algebraMap_toAlgebra] + · obtain ⟨x, rfl⟩ := (hbij s').2 z + obtain ⟨r, rfl⟩ := TensorProduct.exists_eq_sum_tmul_of_span_eq_top hb x +- exact ⟨r, by simp only [map_sum, pushforwardStalkTensorMap_tmul]; rfl⟩ ++ exact ⟨r, by simp only [map_sum, pushforwardStalkTensorMap_tmul]⟩ + · have h0 : pushforwardStalkTensorMap (analytification.map q) (analytificationΓ Y) + (analytificationΓ_naturality q) s' (∑ j, r j ⊗ₜ b j) = 0 := by + simp only [map_sum, pushforwardStalkTensorMap_tmul] +diff --git a/Oka/Analytification/RET/ES/NormalToSmooth.lean b/Oka/Analytification/RET/ES/NormalToSmooth.lean +index 89e66a7c9ceea3f8305196a9240f6535038fcecf..17e405dfbe767f501fa42224bed4c1f12bdfd762 100644 +--- a/Oka/Analytification/RET/ES/NormalToSmooth.lean ++++ b/Oka/Analytification/RET/ES/NormalToSmooth.lean +@@ -619,7 +619,6 @@ theorem bijective_res_of_isLocalIso (Ω : Z.Opens) : + refine (LocallyRingedSpace.res_res _ h₁ (hNΩ y hy.1) t).symm.trans ?_ + change Z.res h₁ (LocallyRingedSpace.sectRes (SheafOfModules.unit Z.ringSheaf) (hNΩ y hy.1) t) = _ + rw [ht, hu] +- rfl + end Sheet + + /-! ### Hartogs extension and normalisation -/ +diff --git a/Oka/Analytification/RET/ES/Normalization.lean b/Oka/Analytification/RET/ES/Normalization.lean +index 810f32cd7a3a30f17b5a1e44d39a8a85c04e2254..c53e2f27b06b041e8c92d987cca0be88aa4ad1da 100644 +--- a/Oka/Analytification/RET/ES/Normalization.lean ++++ b/Oka/Analytification/RET/ES/Normalization.lean +@@ -507,7 +507,11 @@ lemma surjective_specAlgebraHom (x : analytification.obj X) : + exact zero_mem _ + obtain ⟨q, -, hq, hqc⟩ := Ideal.exists_ideal_over_prime_of_isIntegral (affinePt x).asIdeal ⊥ hker + have hqm : q.IsMaximal := +- Ideal.isMaximal_of_isIntegral_of_isMaximal_comap q (by rw [hqc]; infer_instance) ++ Ideal.isMaximal_of_isIntegral_of_isMaximal_comap (algebraMap Γ(X.obj.left, ⊤) S) ++ (algebraMap_isIntegral_iff.mpr inferInstance) q (by ++ change (q.under Γ(X.obj.left, ⊤)).IsMaximal ++ rw [hqc] ++ infer_instance) + obtain ⟨y, hy⟩ := exists_specPt_eq (X := X) ⟨q, hq⟩ hqm + refine ⟨y, affinePt_injective ?_⟩ + rw [affinePt_specAlgebraHom, hy] +diff --git a/Oka/Analytification/RET/ES/ReflexiveHull.lean b/Oka/Analytification/RET/ES/ReflexiveHull.lean +index 554dea1b47636c108ba7fa7d9d9e6493ff81c936..105051040478dbff1661fa6a6544411e35cb6b7b 100644 +--- a/Oka/Analytification/RET/ES/ReflexiveHull.lean ++++ b/Oka/Analytification/RET/ES/ReflexiveHull.lean +@@ -294,7 +294,6 @@ def reflexiveHullData {U : (space N).Opens} (P : RegularPairFamily (img U : Set + τ_smul j V hV r a := by rw [mulSec_smul, trace_smul] + τ_res j V hV V' h a := by + rw [← sectRes_sectRes (boundedModule h₀ W) h hV, ← mulSec_map, trace_map] +- rfl + eq_zero_of_τ V hV a ha := eq_zero_of_trace_mulSec_eq_zero h₀ W hD P s + (fun y hy hyZ ↦ exists_span_of_isFreeSpanAt (hfree y hy fun h ↦ hyZ (hS h))) hV a ha + injective_res V hV := +diff --git a/Oka/Analytification/RET/ES/SmoothLocus.lean b/Oka/Analytification/RET/ES/SmoothLocus.lean +index 2e60cb37b692ff02841ec16207db3964879a58c7..09196574d7f84aea25f25f74b61050b3fab44885 100644 +--- a/Oka/Analytification/RET/ES/SmoothLocus.lean ++++ b/Oka/Analytification/RET/ES/SmoothLocus.lean +@@ -151,7 +151,7 @@ lemma exists_ringKrullDim_le_natCast (X : SchemeLFTℂ.{u}) [IsAffine X.obj.left + obtain ⟨k, f, hf⟩ := Algebra.FiniteType.iff_quotient_mvPolynomial''.mp + (inferInstance : Algebra.FiniteType ℂ Γ(X.obj.left, ⊤)) + refine ⟨k, (ringKrullDim_le_of_surjective f.toRingHom hf).trans_eq ?_⟩ +- rw [MvPolynomial.ringKrullDim_of_isNoetherianRing, ringKrullDim_eq_zero_of_field, zero_add, ++ rw [MvPolynomial.ringKrullDim_of_isNoetherianRing_of_finite, ringKrullDim_eq_zero_of_field, zero_add, + Nat.card_eq_fintype_card, Fintype.card_fin] + + /-- A nontrivial ring of dimension at most a natural number has dimension a natural number. -/ +diff --git a/Oka/Analytification/RET/ES/SmoothSections.lean b/Oka/Analytification/RET/ES/SmoothSections.lean +index c6fc7b660664da1ebc77c4120d2a7e56c2280cbe..9161b7eef76650d4b64b48f4b82fa9fbd724e84c 100644 +--- a/Oka/Analytification/RET/ES/SmoothSections.lean ++++ b/Oka/Analytification/RET/ES/SmoothSections.lean +@@ -473,13 +473,9 @@ lemma growthVal_res {V V' : (projectiveSpaceAn.{u} n).Opens} (h : V' ≤ V) + · have := c_app_res (M := W.toLocallyRingedSpace) (toProj ρ₀).toLRSHom + (inf_le_inf_right _ h : V' ⊓ preimOpen πP (stdU 0) ≤ V ⊓ preimOpen πP (stdU 0)) (pbComp t 0) + refine (congrArg (W.presheaf.map _).hom this).trans ?_ +- change W.presheaf.map _ (W.presheaf.map _ _) = W.presheaf.map _ (W.presheaf.map _ _) +- rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply, ← W.presheaf.map_comp, +- ← W.presheaf.map_comp] +- rfl +- · change _ = W.presheaf.map _ (W.presheaf.map _ f) +- rw [← ConcreteCategory.comp_apply, ← W.presheaf.map_comp] +- rfl ++ exact (res_res W.toLocallyRingedSpace _ _ (ρPull ρ₀ (pbComp t 0))).trans ++ (res_res W.toLocallyRingedSpace _ _ (ρPull ρ₀ (pbComp t 0))).symm ++ · exact (res_res W.toLocallyRingedSpace _ _ f).symm + + include hR hf in + /-- The section of the extension given by `t₀ · f`. -/ +diff --git a/Oka/Analytification/RET/ES/SmoothSetup.lean b/Oka/Analytification/RET/ES/SmoothSetup.lean +index f5303cbdb348140ce6f5f8629a36ae0018566c00..c192325f00bad81579d32a3732d9bc496ad891aa 100644 +--- a/Oka/Analytification/RET/ES/SmoothSetup.lean ++++ b/Oka/Analytification/RET/ES/SmoothSetup.lean +@@ -48,7 +48,7 @@ theorem exists_finite_injective_of_ringKrullDim_eq {k A : Type*} [Field k] [Comm + letI := g.toRingHom.toAlgebra + haveI : Module.Finite (MvPolynomial (Fin s) k) A := hfin + have hdimP : ringKrullDim (MvPolynomial (Fin s) k) = s := by +- rw [MvPolynomial.ringKrullDim_of_isNoetherianRing, ringKrullDim_eq_zero_of_field, ++ rw [MvPolynomial.ringKrullDim_of_isNoetherianRing_of_finite, ringKrullDim_eq_zero_of_field, + Nat.card_eq_fintype_card, Fintype.card_fin, zero_add] + have h1 := ringKrullDim_le_of_isIntegral (R := MvPolynomial (Fin s) k) (S := A) + have h2 := ringKrullDim_le_of_isIntegral_of_injective (R := MvPolynomial (Fin s) k) (S := A) +diff --git a/Oka/CategoryTheory/GlueData.lean b/Oka/CategoryTheory/GlueData.lean +index 850eece1ecb877738a92c5f04bca8f077ea535c1..abec33f687ac099fb2322275fa2c3be21cc1af5d 100644 +--- a/Oka/CategoryTheory/GlueData.lean ++++ b/Oka/CategoryTheory/GlueData.lean +@@ -233,7 +233,7 @@ theorem GlueData.ofGlueData'_comm {Y : C} (fY : ∀ i, D.U i ⟶ Y) + rcases eq_or_ne i j with rfl | hij + · rw [GlueData.ofGlueData'_f_self, GlueData.ofGlueData'_t_self] + simp +- · rw [← Category.assoc, GlueData.ofGlueData'_t_comp_f_of_ne D hij, ++ · erw [← Category.assoc, GlueData.ofGlueData'_t_comp_f_of_ne D hij, + GlueData.ofGlueData'_f_of_ne D hij] + dsimp only [GlueData.ofGlueData'] + rw [Category.assoc, Category.assoc, cancel_epi, Category.assoc] +@@ -253,7 +253,7 @@ theorem GlueData.comm_of_ofGlueData'_comm {Y : C} (fY : ∀ i, D.U i ⟶ Y) + {i j : D.J} (hij : i ≠ j) : + D.f i j hij ≫ fY i = D.t i j hij ≫ D.f j i hij.symm ≫ fY j := by + have hij' := h i j +- rw [← Category.assoc, GlueData.ofGlueData'_t_comp_f_of_ne D hij, ++ erw [← Category.assoc, GlueData.ofGlueData'_t_comp_f_of_ne D hij, + GlueData.ofGlueData'_f_of_ne D hij] at hij' + dsimp only [GlueData.ofGlueData'] at hij' + rw [Category.assoc, Category.assoc, cancel_epi, Category.assoc] at hij' +diff --git a/Oka/Geometry/RingedSpace/LocallyRingedSpace.lean b/Oka/Geometry/RingedSpace/LocallyRingedSpace.lean +index cbaafe504f2ecccafef096383cbcf4420f804956..3040fbcf45bf5ef15160f54058407d35989ffc7c 100644 +--- a/Oka/Geometry/RingedSpace/LocallyRingedSpace.lean ++++ b/Oka/Geometry/RingedSpace/LocallyRingedSpace.lean +@@ -294,6 +294,7 @@ lemma restrictStalkIso_hom_stalkAlgMap {R : Type*} [NonAssocSemiring R] + (X.restrictStalkIso U.isOpenEmbedding x).hom + ((X.restrict U.isOpenEmbedding).stalkAlgMap (X.resAlgMap α U) x c) = + X.stalkAlgMap α x.1 c := by ++ change U at x + change (X.restrictStalkIso U.isOpenEmbedding x).hom + ((X.restrict U.isOpenEmbedding).presheaf.germ ⊤ x trivial + ((X.presheaf.map (homOfLE le_top).op).hom (α c))) = _ +@@ -432,6 +433,7 @@ lemma germ_Γ_map_ofRestrict (X : LocallyRingedSpace.{u}) (U : Opens X) + ((X.restrict U.isOpenEmbedding).presheaf.germ ⊤ x trivial + ((Γ.map (X.ofRestrict U.isOpenEmbedding).op).hom s)) = + X.presheaf.germ ⊤ x.1 trivial s := by ++ change U at x + rw [Γ_map_ofRestrict_apply, restrictStalkIso_hom_eq_germ_apply] + exact X.presheaf.germ_res_apply (homOfLE le_top) x.1 _ s + +@@ -510,7 +512,7 @@ lemma germ_eq_stalkMap_ofRestrict (X : LocallyRingedSpace.{u}) (U : Opens X) + (homOfLE (U.isOpenEmbedding.isOpenMap.adjunction.unit.app O).le) w hO _) + refine congrArg ((X.restrict U.isOpenEmbedding).presheaf.germ O w hO) ?_ + change b = (X.presheaf.map _).hom ((X.presheaf.map _).hom b) +- rw [← ConcreteCategory.comp_apply, ← X.presheaf.map_comp] ++ erw [← ConcreteCategory.comp_apply, ← X.presheaf.map_comp] + exact (hid _).symm + + /-- `germ_eq_stalkMap_ofRestrict` at the top open, for a section written as a +@@ -673,7 +675,7 @@ lemma resAlgMap_eq_comp {R : Type*} [NonAssocSemiring R] (α : R →+* X.preshea + RingHom.ext fun c ↦ by + change (X.presheaf.map _).hom _ = (X.presheaf.map _).hom ((X.presheaf.map _).hom (α c)) + change _ = ((X.presheaf.map _) ≫ (X.presheaf.map _)).hom _ +- rw [← X.presheaf.map_comp] ++ erw [← X.presheaf.map_comp] + congr 2 + + section GlueAlgMap +@@ -718,7 +720,7 @@ lemma resAlgMap_glueAlgMap (i : ι) : + change (X.presheaf.map _).hom _ = (X.presheaf.map _).hom ((α i) c) + rw [← map_glueAlgMap hU α h i c] + change _ = ((X.presheaf.map _) ≫ (X.presheaf.map _)).hom _ +- rw [← X.presheaf.map_comp] ++ erw [← X.presheaf.map_comp] + congr 2 + + end GlueAlgMap +@@ -932,7 +934,8 @@ lemma exists_localLift_family (hsurj : ∀ x, Function.Surjective (i.stalkMap x) + ⟨hx, Set.mem_iInter.2 hxB⟩, fun j ↦ ?_⟩ + rw [c_app_res] + have h1 := congrArg (M.res (hB'j j)) (hres j) +- simp only [res_res] at h1 ⊢ ++ simp only [res_res] at h1 ++ erw [res_res] + exact h1 + + end LocalModel +diff --git a/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleOpenEmbedding.lean b/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleOpenEmbedding.lean +index c13cca0af65e6aabe5d8da5ff556d645ee89ef62..f292e79aad03fe01a387d0a21341a56c2486d5df 100644 +--- a/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleOpenEmbedding.lean ++++ b/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleOpenEmbedding.lean +@@ -251,7 +251,9 @@ theorem hasLocalModuleRelationsAt {z : Z} (hK : HasLocalModuleRelationsAt K z) : + let a' : Fin m → Z.presheaf.obj (op (C.pre W₁)) := fun i ↦ C.ψ (C.pre W₁) (Y.res hW₁e.le (a i)) + have ha' : ∑ i, a' i • sectRes K (hpre.trans hW'V) (f' i) = 0 := by + have := congrArg (fun s ↦ C.φ (C.pre W₁) (sectRes M hW₁e.le s)) ha +- simp only [sectRes_sum, sectRes_smul, C.φ_sum, sectRes_zero, map_zero] at this ++ simp only [sectRes_sum, sectRes_smul, C.φ_sum, sectRes_zero] at this ++ have hzero : C.φ (C.pre W₁) 0 = 0 := (C.φ (C.pre W₁)).map_zero ++ rw [hzero] at this + rw [← this] + refine Finset.sum_congr rfl fun i _ ↦ ?_ + rw [C.φ_smul, sectRes_sectRes, C.φ_sectRes_sectRes _ (hpre.trans hW'V) hVe.le] +diff --git a/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleSections.lean b/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleSections.lean +index 67de23265671ee899a5af4b661675acde8970d8d..c61b5b8108007c7c7459ebd6cca5d69171428db4 100644 +--- a/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleSections.lean ++++ b/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentModuleSections.lean +@@ -169,7 +169,6 @@ theorem hasLocalModuleRelations_of_isCoherent [M.IsCoherent] : HasLocalModuleRel + refine (key Z' b).trans (Eq.trans ?_ hrel) + refine Finset.sum_congr rfl (fun i _ ↦ ?_) + simp only [b, freeEval_freeEvalSymm] +- rfl + obtain ⟨n, hn⟩ := hlift (op Z') b hb + obtain ⟨S, hS, hS'⟩ := hs a Z' (Over.homMk (homOfLE hW') (Subsingleton.elim _ _)) n + rw [GrothendieckTopology.mem_over_iff] at hS +diff --git a/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentPushforwardClosedEmbedding.lean b/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentPushforwardClosedEmbedding.lean +index 50c1e96197465808bd065e51dd056b87d17a2b93..af3ce55bab52e432570e82a5447fb45f9f1dd3b0 100644 +--- a/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentPushforwardClosedEmbedding.lean ++++ b/Oka/Geometry/RingedSpace/LocallyRingedSpace/CoherentPushforwardClosedEmbedding.lean +@@ -355,9 +355,7 @@ lemma Hom.hasLocalModuleRelations_pushforward_of_mem (hf : IsClosedEmbedding f.b + erw [map_sub, map_sum, sub_eq_zero] + refine Eq.trans ?_ (e₂.trans (Finset.sum_congr rfl fun l _ ↦ ?_)) + · erw [Hom.c_app_res] +- rfl + · erw [map_mul, Hom.c_app_res, Hom.c_app_res, hc3, hd, res_res, res_res] +- rfl + -- Step 2: the remainder is locally a combination of the `h_j` + have hy'WI : y' ∈ WI := hWWI (hW' hy') + let b : Fin m → Y.presheaf.obj (op W4) := fun i ↦ Y.res h4 (a i) - +diff --git a/Oka/Geometry/RingedSpace/LocallyRingedSpace/HomSheafCoherent.lean b/Oka/Geometry/RingedSpace/LocallyRingedSpace/HomSheafCoherent.lean +index fb2ad81de60335236986de07b9f65b27cde369b7..5e6457c2fa7e9c37867489314b79903a9057e60b 100644 +--- a/Oka/Geometry/RingedSpace/LocallyRingedSpace/HomSheafCoherent.lean ++++ b/Oka/Geometry/RingedSpace/LocallyRingedSpace/HomSheafCoherent.lean +@@ -90,7 +90,10 @@ def homSheafBiprodIso (A B : SheafOfModules.{u} Y.ringSheaf) : + inr_fst := by rw [← homSheafMap_comp, biprod.inl_snd, homSheafMap_zero] + inr_snd := by rw [← homSheafMap_comp, biprod.inr_snd, homSheafMap_id] } + (by +- dsimp ++ change homSheafMap G (biprod.inl : A ⟶ A ⊞ B) ≫ ++ homSheafMap G (biprod.fst : A ⊞ B ⟶ A) + ++ homSheafMap G (biprod.inr : B ⟶ A ⊞ B) ≫ ++ homSheafMap G (biprod.snd : A ⊞ B ⟶ B) = 𝟙 (homSheaf (A ⊞ B) G) + rw [← homSheafMap_comp G biprod.fst biprod.inl, ← homSheafMap_comp G biprod.snd biprod.inr, + ← homSheafMap_add, biprod.total, homSheafMap_id])) + +diff --git a/Oka/Geometry/RingedSpace/LocallyRingedSpace/Modules.lean b/Oka/Geometry/RingedSpace/LocallyRingedSpace/Modules.lean +index 6d24d3bd90eb97ba8a0d60eec06f5517462a125f..71e83aa11c65abbe4699efcdee9586416d06d42d 100644 +--- a/Oka/Geometry/RingedSpace/LocallyRingedSpace/Modules.lean ++++ b/Oka/Geometry/RingedSpace/LocallyRingedSpace/Modules.lean +@@ -134,6 +134,16 @@ noncomputable def Hom.toRingSheafHom {X : LocallyRingedSpace.{u}} (f : X ⟶ Y) + RingCat.{u} _ _).obj X.ringSheaf where + hom := Functor.whiskerRight f.c _ + ++instance isRightAdjoint_pushforwardModules {X : LocallyRingedSpace.{u}} (f : X ⟶ Y) : ++ (SheafOfModules.pushforward.{u} f.toRingSheafHom).IsRightAdjoint := by ++ let φ : Y.ringSheaf ⟶ ((Opens.map f.base).sheafPushforwardContinuous ++ RingCat.{u} _ _).obj X.ringSheaf := f.toRingSheafHom ++ let : (PresheafOfModules.pushforward.{u} φ.hom).IsRightAdjoint := ++ CategoryTheory.Functor.isRightAdjoint_of_leftAdjointObjIsDefined_eq_top ++ (PresheafOfModules.pullbackObjIsDefined_eq_top ++ (F := Opens.map f.base) (R := X.ringSheaf.obj) φ.hom) ++ exact (SheafOfModules.PullbackConstruction.adjunction.{u} φ).isRightAdjoint ++ + variable {Y} in + /-- **Pullback of `𝒪`-modules along a morphism of locally ringed spaces.** + +diff --git a/Oka/Geometry/RingedSpace/ZeroLocus.lean b/Oka/Geometry/RingedSpace/ZeroLocus.lean +index a91f2e3a06bc79c15ebf6482a55919a21a2474aa..dcd61241e002bed47d0d244fe0687eab5b85effe 100644 +--- a/Oka/Geometry/RingedSpace/ZeroLocus.lean ++++ b/Oka/Geometry/RingedSpace/ZeroLocus.lean +@@ -278,7 +278,7 @@ theorem stalkMap_zeroLocusιHom (z : Y.zeroLocusSpace f) : + -- `TopCat.Presheaf` is a `def`, so `rw` refuses to look inside its category instance; `erw` + -- does. The final `rfl` is `stalkPullbackHom` unfolding to its definition. + erw [Functor.map_comp, Functor.map_comp, Functor.map_comp] +- rw [Category.assoc, Category.assoc, Category.assoc] ++ erw [Category.assoc, Category.assoc, Category.assoc] + erw [TopCat.Presheaf.stalkPushforward_naturality] + rfl + +@@ -325,9 +325,14 @@ modulo the ideal generated by the germs of the `f i`. -/ + def zeroLocusStalkQuotientEquiv (z : Y.zeroLocusSpace f) : + (Y.presheaf.stalk (Y.zeroLocusι f z) ⧸ + Ideal.span (Set.range fun i ↦ Y.presheaf.Γgerm (Y.zeroLocusι f z) (f i))) ≃+* +- (Y.zeroLocusPresheaf f).stalk z := +- (Ideal.quotEquivOfEq (Y.ker_stalkMap_zeroLocusιHom f z).symm).trans +- (RingHom.quotientKerEquivOfSurjective (Y.surjective_stalkMap_zeroLocusιHom f z)) ++ (Y.zeroLocusPresheaf f).stalk z := by ++ let q : Y.presheaf.stalk (Y.zeroLocusι f z) →+* (Y.zeroLocusPresheaf f).stalk z := ++ ((Y.zeroLocusιHom f).stalkMap z).hom ++ have hker : RingHom.ker q = ++ Ideal.span (Set.range fun i ↦ Y.presheaf.Γgerm (Y.zeroLocusι f z) (f i)) := ++ Y.ker_stalkMap_zeroLocusιHom f z ++ have hsurj : Function.Surjective q := Y.surjective_stalkMap_zeroLocusιHom f z ++ exact (Ideal.quotEquivOfEq hker.symm).trans (RingHom.quotientKerEquivOfSurjective hsurj) + + /-- The stalks of the structure sheaf of the zero locus are nonzero rings. -/ + instance nontrivial_zeroLocusPresheaf_stalk (z : Y.zeroLocusSpace f) : +diff --git a/Oka/LocalOkaRing.lean b/Oka/LocalOkaRing.lean +index eb90e4f2cb26c1972f2d281c91c366fa1b485ec1..e1eee2176b31a391fbb8fe5d8917cb3015eacba6 100644 +--- a/Oka/LocalOkaRing.lean ++++ b/Oka/LocalOkaRing.lean +@@ -304,7 +304,7 @@ omit [Fintype ι] in + lemma norm_evalMonomial_le (h : ∀ i, ‖x i‖ ≤ ‖y i‖) (d : ι →₀ ℕ) : + ‖evalMonomial d x‖ ≤ ‖evalMonomial d y‖ := by + simp only [evalMonomial, Finsupp.prod, norm_prod, norm_pow] +- exact Finset.prod_le_prod (fun i _ ↦ by positivity) ++ exact Finset.prod_le_prod₀ (fun i _ ↦ by positivity) + fun i _ ↦ pow_le_pow_left₀ (norm_nonneg _) (h i) _ + + omit [Fintype ι] in +@@ -418,7 +418,7 @@ lemma norm_monomialCMM_le (d : ι →₀ ℕ) (n : ℕ) : ‖monomialCMM d n‖ + rw [one_mul, ContinuousMultilinearMap.compContinuousLinearMap_apply, + ContinuousMultilinearMap.mkPiAlgebra_apply, norm_prod] + simp only [ContinuousLinearMap.proj_apply] +- exact Finset.prod_le_prod (fun _ _ ↦ norm_nonneg _) fun k _ ↦ norm_le_pi_norm _ _ ++ exact Finset.prod_le_prod₀ (fun _ _ ↦ norm_nonneg _) fun k _ ↦ norm_le_pi_norm _ _ + · simp + + variable (P) in +@@ -565,7 +565,7 @@ lemma norm_fpsCoeff_le (p : FormalMultilinearSeries ℂ (ι → ℂ) ℂ) (n : + refine Finset.sum_le_sum fun s _ ↦ ?_ + refine ((p n).le_opNorm _).trans ?_ + refine mul_le_of_le_one_right (norm_nonneg _) ?_ +- exact Finset.prod_le_one (fun _ _ ↦ norm_nonneg _) fun k _ ↦ norm_basisVec_le _ ++ exact Finset.prod_le_one₀ (fun _ _ ↦ norm_nonneg _) fun k _ ↦ norm_basisVec_le _ + + lemma sum_card_fibers (n : ℕ) : + ∑ d ∈ degFinset ι n, ((tupleFinset n d).card : ℝ) = (Fintype.card ι : ℝ) ^ n := by +@@ -578,7 +578,7 @@ lemma norm_evalMonomial_le_pow {ρ : ℝ} {y : ι → ℂ} (hy : ‖y‖ ≤ ρ) + (hd : d ∈ degFinset ι n) : ‖evalMonomial d y‖ ≤ ρ ^ n := by + have h1 : ∀ i, ‖y i‖ ≤ ρ := fun i ↦ (norm_le_pi_norm y i).trans hy + rw [norm_evalMonomial, ← mem_degFinset.mp hd, ← Finset.prod_pow_eq_pow_sum] +- exact Finset.prod_le_prod (fun i _ ↦ by positivity) ++ exact Finset.prod_le_prod₀ (fun i _ ↦ by positivity) + fun i _ ↦ pow_le_pow_left₀ (norm_nonneg _) (h1 i) _ + + /-- Absolute convergence can be checked after regrouping by total degree. -/ +@@ -802,7 +802,7 @@ theorem eq_zero_of_represents_zero [Finite ι] {R : MvPowerSeries ι ℂ} (hR : + refine MvPolynomial.funext fun y ↦ ?_ + rw [map_zero, map_sum] + simpa [MvPolynomial.eval_monomial, evalMonomial] using hall (∑ i, d i) y +- have h3 := congrArg (MvPolynomial.coeff d) hΦ ++ have h3 := congrArg (fun p : MvPolynomial ι ℂ ↦ p.coeff d) hΦ + rw [MvPolynomial.coeff_sum] at h3 + simp only [MvPolynomial.coeff_monomial, MvPolynomial.coeff_zero] at h3 + rw [Finset.sum_ite_eq' (degFinset ι (∑ i, d i)) d (fun e ↦ coeff e R)] at h3 +diff --git a/Oka/Nullstellensatz/Germ.lean b/Oka/Nullstellensatz/Germ.lean +index 9c3d3babe4e2f03cfb934f671a57c00197c8668f..a630f76a02023e4cb32970d26d51ecfb15ea43db 100644 +--- a/Oka/Nullstellensatz/Germ.lean ++++ b/Oka/Nullstellensatz/Germ.lean +@@ -62,7 +62,7 @@ theorem exists_incl_sub_mul_mem {W : (LocalOkaRing (Fin n))[X]} + (Ideal.Quotient.factorₐ (LocalOkaRing (Fin n)) hle).toLinearMap + (Ideal.Quotient.factor_surjective hle) + have hint : IsIntegral (LocalOkaRing (Fin n)) (Ideal.Quotient.mk P g) := +- Algebra.IsIntegral.isIntegral _ ++ IsIntegral.of_finite _ _ + have hne : Ideal.Quotient.mk P g ≠ 0 := by rwa [Ne, Ideal.Quotient.eq_zero_iff_mem] + have hlt := Ideal.comap_lt_comap_of_integral_mem_sdiff (R := LocalOkaRing (Fin n)) + (I := (⊥ : Ideal (LocalOkaRing (Fin (n + 1)) ⧸ P))) +diff --git a/Oka/OkaLemma.lean b/Oka/OkaLemma.lean +index e17e8fa32fdd36fb3f5750413c3146acc734e7f2..1e06a52aa9232b16a68b1d800a0f478a40601c7b 100644 +--- a/Oka/OkaLemma.lean ++++ b/Oka/OkaLemma.lean +@@ -167,10 +167,11 @@ lemma mapDomain_finInit_add_single_last (u : Fin (n + 1) →₀ ℕ) : + ext j + induction j using Fin.lastCases with + | last => +- rw [Finsupp.add_apply, Finsupp.mapDomain_notin_range _ _ (by simp), ++ rw [Finsupp.add_apply, Finsupp.mapDomain_of_notMem_range _ _ (by simp), + Finsupp.single_eq_same, zero_add] + | cast i => +- rw [Finsupp.add_apply, Finsupp.mapDomain_apply (Fin.castSucc_injective n), finInit_apply] ++ rw [Finsupp.add_apply, Finsupp.mapDomain_apply_of_injective (Fin.castSucc_injective n), ++ finInit_apply] + simp [(Fin.castSucc_lt_last i).ne] + + /-- The coefficients of `MvPowerSeries.fromPolynomial' Q` at an arbitrary exponent. -/ +diff --git a/Oka/RingTheory/IntegralClosureEtale.lean b/Oka/RingTheory/IntegralClosureEtale.lean +index 22d620ad0eed1f59e3d12d8706f3b7f5c5e7b1f0..37b331c92c9c51497a6e815ff6c4cb90cc8ccc30 100644 +--- a/Oka/RingTheory/IntegralClosureEtale.lean ++++ b/Oka/RingTheory/IntegralClosureEtale.lean +@@ -87,8 +87,7 @@ theorem exists_algebraMap_eq_of_isIntegral_tensor [Algebra.Smooth R S] + (congrArg Subtype.val ht).symm + rw [hy'] + clear ht hy' +- induction t with +- | zero => exact ⟨0, by simp⟩ ++ induction t using TensorProduct.inductionOn with + | add x y hx hy => + obtain ⟨a, ha⟩ := hx + obtain ⟨b, hb⟩ := hy +diff --git a/Oka/RingTheory/MilnorPatching.lean b/Oka/RingTheory/MilnorPatching.lean +index ef94de2518e2352d530fbfeeb8fde8803bf0a1b7..4edb36e268453696d149d78197669d80146167d5 100644 +--- a/Oka/RingTheory/MilnorPatching.lean ++++ b/Oka/RingTheory/MilnorPatching.lean +@@ -244,7 +244,6 @@ include hφ in + lemma surjective_of_isBaseChange : Function.Surjective φ := by + intro y + induction y using hφ.inductionOn with +- | zero => exact ⟨0, map_zero φ⟩ + | tmul m => exact ⟨m, rfl⟩ + | smul s n hn => + obtain ⟨m, rfl⟩ := hn +@@ -310,7 +309,6 @@ lemma mem_span_range_fst (p : P) : + exact Submodule.smul_mem _ s hx + have hq : φ p ∈ Submodule.span (S ⧸ I.map (algebraMap R S)) (Set.range ψ) := by + induction φ p using hψ.inductionOn with +- | zero => exact zero_mem _ + | tmul m => exact Submodule.subset_span ⟨m, rfl⟩ + | smul s n hn => exact Submodule.smul_mem _ s hn + | add n₁ n₂ h₁ h₂ => exact add_mem h₁ h₂ +diff --git a/Oka/RingTheory/MvPolynomial/LaurentAway.lean b/Oka/RingTheory/MvPolynomial/LaurentAway.lean +index 88222b85c4cbfe701696f5ee995643a918e53037..b2f15d3d79d4197f3dca8719c49c249ba766eed3 100644 +--- a/Oka/RingTheory/MvPolynomial/LaurentAway.lean ++++ b/Oka/RingTheory/MvPolynomial/LaurentAway.lean +@@ -86,8 +86,7 @@ lemma toLaurent_apply (p : MvPolynomial ι R) : toLaurent ι R p = mapDomain exp + + lemma coeff_toLaurent_expInt (p : MvPolynomial ι R) (e : ι →₀ ℕ) : + (toLaurent ι R p).coeff (expInt e) = p.coeff e := by +- rw [toLaurent_apply, coeff_mapDomain, Finsupp.mapDomain_apply expInt_injective] +- rfl ++ rw [toLaurent_apply, coeff_mapDomain, Finsupp.mapDomain_apply_of_injective expInt_injective] + + lemma coeff_toLaurent_eq_zero (p : MvPolynomial ι R) {a : ι →₀ ℤ} (ha : ¬ ∀ j, 0 ≤ a j) : + (toLaurent ι R p).coeff a = 0 := by +diff --git a/Oka/RingTheory/MvPolynomial/Localization.lean b/Oka/RingTheory/MvPolynomial/Localization.lean +index eadf5f3f75d156a3e2d13b0f324d502f614469d0..75ac33618a8ace657f0ec9458095bd494e4452bb 100644 +--- a/Oka/RingTheory/MvPolynomial/Localization.lean ++++ b/Oka/RingTheory/MvPolynomial/Localization.lean +@@ -185,7 +185,7 @@ theorem awayLift_awayBaseHom (a : MvPolynomial σ R ⧸ I) : + obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective a + have h := congrArg (fun φ : MvPolynomial σ R →ₐ[R] _ ↦ φ p) (awayAeval_comp_rename I f) + simp only [AlgHom.coe_comp, Function.comp_apply] at h +- simpa [awayLift, awayBaseHom] using h ++ exact h + + theorem awayLift_comp_awayInv : (awayLift I f).comp (awayInv I f) = AlgHom.id R _ := by + ext a +@@ -202,8 +202,14 @@ theorem awayInv_comp_awayLift : (awayInv I f).comp (awayLift I f) = AlgHom.id R + exact congrFun (congrArg DFunLike.coe h) p + apply MvPolynomial.algHom_ext + rintro (_ | i) +- · simp [awayLift, awayAeval, awayInv_invSelf] +- · simp [awayLift, awayAeval, awayInv_algebraMap, awayBaseHom] ++ · simp only [AlgHom.coe_comp, Function.comp_apply, Ideal.Quotient.mkₐ_eq_mk, ++ awayLift, Ideal.Quotient.liftₐ_apply] ++ erw [Ideal.Quotient.lift_mk] ++ simp [awayAeval, awayInv_invSelf] ++ · simp only [AlgHom.coe_comp, Function.comp_apply, Ideal.Quotient.mkₐ_eq_mk, ++ awayLift, Ideal.Quotient.liftₐ_apply] ++ erw [Ideal.Quotient.lift_mk] ++ simp [awayAeval, awayInv_algebraMap, awayBaseHom] + + /-- **The isomorphism with `Localization.Away`**, over `R`. This is the shape a consumer that + renames variables wants; `MvPolynomial.isLocalization_away_quotient_awayIdeal` is the shape a +diff --git a/Oka/RingTheory/SmoothCodimOne.lean b/Oka/RingTheory/SmoothCodimOne.lean +index b8bcdd3d26553ed2d056f92b823260a8c8f3fa0d..6983111ee22074dbd8f1abf53f03cc36488a2b2a 100644 +--- a/Oka/RingTheory/SmoothCodimOne.lean ++++ b/Oka/RingTheory/SmoothCodimOne.lean +@@ -80,7 +80,7 @@ theorem isSmoothAt_of_ringKrullDim_le_one {K A : Type*} [Field K] [CharZero K] [ + haveI : Ring.DimensionLEOne S := + ⟨fun hp hp' ↦ Ring.krullDimLE_one_iff_of_isPrime_bot.mp inferInstance _ hp hp'⟩ + haveI : IsDedekindDomain S := {} +- obtain ⟨ϖ, hϖ⟩ := ((IsDiscreteValuationRing.TFAE S hS).out 2 4).mp ‹IsDedekindDomain S› ++ obtain ⟨ϖ, hϖ⟩ := ((IsDiscreteValuationRing.TFAE S hS).out 3 5).mp ‹IsDedekindDomain S› + obtain ⟨a, s, rfl⟩ := IsLocalization.exists_mk'_eq q.primeCompl ϖ + have hm : maximalIdeal S = Ideal.span {algebraMap A S a} := by + rw [hϖ, Ideal.submodule_span_eq, IsLocalization.mk'_eq_mul_mk'_one, +diff --git a/Oka/Topology/Sheaves/Cohomology/ClosedEmbedding.lean b/Oka/Topology/Sheaves/Cohomology/ClosedEmbedding.lean +index 4ec3d7043c0523150fc12e8c8d9574317675f9ea..06ce561ad0ab99e36d9e3d1c39d49851d3f84fde 100644 +--- a/Oka/Topology/Sheaves/Cohomology/ClosedEmbedding.lean ++++ b/Oka/Topology/Sheaves/Cohomology/ClosedEmbedding.lean +@@ -118,7 +118,7 @@ theorem map_exact_pushforwardAb (hf : IsClosedEmbedding f) (S : ShortComplex (Ab + /-- Pushforward along a closed embedding preserves finite limits and finite colimits. -/ + theorem preservesFiniteLimitsAndColimits_pushforwardAb (hf : IsClosedEmbedding f) : + PreservesFiniteLimits (pushforwardAb f) ∧ PreservesFiniteColimits (pushforwardAb f) := +- ((Functor.exact_tfae (pushforwardAb f)).out 1 3).1 (map_exact_pushforwardAb hf) ++ ((Functor.exact_tfae (pushforwardAb f)).out 2 4).1 (map_exact_pushforwardAb hf) + + /-- **Pushforward along a closed embedding preserves finite colimits.** -/ + theorem preservesFiniteColimits_pushforwardAb (hf : IsClosedEmbedding f) : +diff --git a/Oka/Topology/Sheaves/Cohomology/MayerVietoris.lean b/Oka/Topology/Sheaves/Cohomology/MayerVietoris.lean +index e66d8343132ec9ac44817c1bd3f2a8a26c6b99e1..5b481b1e326399dfde46b19b5bee0e3439b2e79f 100644 +--- a/Oka/Topology/Sheaves/Cohomology/MayerVietoris.lean ++++ b/Oka/Topology/Sheaves/Cohomology/MayerVietoris.lean +@@ -88,14 +88,12 @@ theorem extComparison_bijective + simp only [AddMonoidHom.coe_comp, Function.comp_apply, extComparison_apply, + AddCommGrpCat.hom_ofHom, Ext.postcomp, AddMonoidHom.flip_apply, + Ext.bilinearComp_apply_apply, Ext.mapExactFunctor_comp, Ext.mapExactFunctor_mk₀] +- erw [AddMonoidHom.flip_apply, Ext.bilinearComp_apply_apply] + exact Ext.comp_assoc_of_third_deg_zero _ _ _ _) + (by + ext x + simp only [AddMonoidHom.coe_comp, Function.comp_apply, extComparison_apply, + AddCommGrpCat.hom_ofHom, Ext.postcomp, AddMonoidHom.flip_apply, + Ext.bilinearComp_apply_apply, Ext.mapExactFunctor_comp, Ext.mapExactFunctor_extClass] +- erw [AddMonoidHom.flip_apply, Ext.bilinearComp_apply_apply] + exact Ext.comp_assoc _ _ _ (zero_add n) rfl (by omega)) + ((ShortComplex.ab_exact_iff_function_exact _).mp + (Ext.covariant_sequence_exact₃' Z hS n (n + 1) rfl)) +@@ -125,7 +123,9 @@ noncomputable def freeYonedaHomEquiv (B : AbSheaf X) : + lemma freeYonedaHomEquiv_comp {B B' : AbSheaf X} (x : freeYoneda U ⟶ B) (g : B ⟶ B') : + freeYonedaHomEquiv U B' (x ≫ g) = g.hom.app (op U) (freeYonedaHomEquiv U B x) := by + simp only [freeYonedaHomEquiv, Equiv.trans_apply] +- erw [Adjunction.homEquiv_naturality_right, Equiv.trans_apply] ++ rw [(sheafificationAdjunction _ _).homEquiv_naturality_right x g, ++ Adjunction.homEquiv_naturality_right, yonedaEquiv_comp] ++ rfl + + + /-- Morphisms out of `ℤ_Y` are global sections. -/ +diff --git a/Oka/Topology/Sheaves/Cohomology/MayerVietorisNatural.lean b/Oka/Topology/Sheaves/Cohomology/MayerVietorisNatural.lean +index d429c3076f4d3efc98ca2c3b2e3f24ff02f4c58c..7b26d4091f364a803957a2a34fdec4bf35e8d219 100644 +--- a/Oka/Topology/Sheaves/Cohomology/MayerVietorisNatural.lean ++++ b/Oka/Topology/Sheaves/Cohomology/MayerVietorisNatural.lean +@@ -98,7 +98,7 @@ lemma freeYonedaHomEquiv_incl_comp (h : V ≤ U) {B : AbSheaf X} (s : freeYoneda + B.obj.map (homOfLE h).op (freeYonedaHomEquiv U B s) := by + simp only [freeYonedaHomEquiv, incl, Equiv.trans_apply] + erw [Adjunction.homEquiv_naturality_left] +- erw [Equiv.trans_apply, Equiv.trans_apply, Adjunction.homEquiv_naturality_left] ++ erw [Adjunction.homEquiv_naturality_left] + exact (yonedaEquiv_naturality _ _).symm + + /-- `(ℤ[U] ⟶ B) ≃ B(U)` is evaluation at the canonical section of `ℤ[U]` over `U`. -/ +diff --git a/Oka/Topology/Sheaves/Cohomology/PushforwardAcyclic.lean b/Oka/Topology/Sheaves/Cohomology/PushforwardAcyclic.lean +index 93347d22054fef6aa2b36c779c75e457204d38eb..9bf1b273f3aa47740e6d647856c113b6d027f5d8 100644 +--- a/Oka/Topology/Sheaves/Cohomology/PushforwardAcyclic.lean ++++ b/Oka/Topology/Sheaves/Cohomology/PushforwardAcyclic.lean +@@ -360,7 +360,6 @@ lemma pullbackAb_map_pullbackPushforwardBaseChangeApp_comp_pushforwardCounit (G + symm + erw [Category.assoc, Category.assoc, ← n₁, ← Functor.map_comp_assoc, ← n₂, Functor.map_comp, + ← Category.assoc, ← Category.assoc, t, Category.id_comp] +- rfl + + /-- The pullback maps along the two composites of a commutative square `f' ≫ g = g' ≫ f` agree + up to `f'⁻¹ g⁻¹ F ⟶ g'⁻¹ f⁻¹ F`. -/ +diff --git a/Oka/Topology/Sheaves/QuotientPresheaf.lean b/Oka/Topology/Sheaves/QuotientPresheaf.lean +index eaae9c85d5347893c8677fd16faf3a8be457f1e5..235fa9056abcc9db6122b96449720442dbeb4d24 100644 +--- a/Oka/Topology/Sheaves/QuotientPresheaf.lean ++++ b/Oka/Topology/Sheaves/QuotientPresheaf.lean +@@ -189,10 +189,17 @@ generated by the `f i`. -/ + theorem ker_stalkFunctor_map_toQuotientSpan : + RingHom.ker ((stalkFunctor CommRingCat.{u} y).map (F.toQuotientSpan f)).hom = + Ideal.span (Set.range fun i ↦ F.Γgerm y (f i)) := by ++ let q : F.stalk y →+* (F.quotientSpan f).stalk y := ++ ((stalkFunctor CommRingCat.{u} y).map (F.toQuotientSpan f)).hom ++ change RingHom.ker q = Ideal.span (Set.range fun i ↦ F.Γgerm y (f i)) + apply le_antisymm + · intro t ht ++ have ht : q t = 0 := RingHom.mem_ker.mp ht + obtain ⟨U, hy, s, rfl⟩ := F.exists_germ_eq t +- rw [RingHom.mem_ker, stalkFunctor_map_germ_apply U y hy _ s] at ht ++ have hq : q (F.germ U y hy s) = ++ (F.quotientSpan f).germ U y hy ((F.toQuotientSpan f).app (op U) s) := ++ stalkFunctor_map_germ_apply U y hy _ s ++ rw [hq] at ht + have ht0 : (F.quotientSpan f).germ U y hy ((F.toQuotientSpan f).app (op U) s) = + (F.quotientSpan f).germ U y hy 0 := by rw [map_zero]; exact ht + obtain ⟨W, hyW, iU, iV, hW⟩ := (F.quotientSpan f).germ_eq y hy hy _ _ ht0 +@@ -210,19 +217,25 @@ theorem ker_stalkFunctor_map_toQuotientSpan : + have h0 : ((F.toQuotientSpan f).app (op ⊤)) (f i) = 0 := + (F.toQuotientSpan_app_eq_zero_iff f (f i)).2 (by simpa using F.res_mem_spanIdeal f ⊤ i) + refine RingHom.mem_ker.2 ?_ +- change ((stalkFunctor CommRingCat.{u} y).map (F.toQuotientSpan f)).hom +- (F.Γgerm y (f i)) = 0 +- rw [show F.Γgerm y (f i) = F.germ ⊤ y True.intro (f i) from rfl, +- stalkFunctor_map_germ_apply ⊤ y True.intro _ (f i), h0, map_zero] +- rfl ++ change q (F.Γgerm y (f i)) = 0 ++ calc ++ q (F.Γgerm y (f i)) = ++ (F.quotientSpan f).germ ⊤ y True.intro ((F.toQuotientSpan f).app (op ⊤) (f i)) := ++ stalkFunctor_map_germ_apply ⊤ y True.intro _ (f i) ++ _ = 0 := by rw [h0, map_zero] + + /-- The stalk of the quotient presheaf at `y` is the quotient of the stalk of `F` at `y` by the + ideal generated by the germs at `y` of the `f i`. -/ + noncomputable def stalkQuotientSpanEquiv : + (F.stalk y ⧸ Ideal.span (Set.range fun i ↦ F.Γgerm y (f i))) ≃+* +- (F.quotientSpan f).stalk y := +- (Ideal.quotEquivOfEq (F.ker_stalkFunctor_map_toQuotientSpan f y).symm).trans +- (RingHom.quotientKerEquivOfSurjective (F.surjective_stalkFunctor_map_toQuotientSpan f y)) ++ (F.quotientSpan f).stalk y := by ++ let q : F.stalk y →+* (F.quotientSpan f).stalk y := ++ ((stalkFunctor CommRingCat.{u} y).map (F.toQuotientSpan f)).hom ++ have hker : RingHom.ker q = Ideal.span (Set.range fun i ↦ F.Γgerm y (f i)) := ++ F.ker_stalkFunctor_map_toQuotientSpan f y ++ exact (Ideal.quotEquivOfEq hker.symm).trans ++ (RingHom.quotientKerEquivOfSurjective (show Function.Surjective q from ++ F.surjective_stalkFunctor_map_toQuotientSpan f y)) + + @[simp] + lemma stalkQuotientSpanEquiv_mk (t : F.stalk y) : +diff --git a/Oka/Topology/Sheaves/Stalks.lean b/Oka/Topology/Sheaves/Stalks.lean +index a1c31610e9fc3530826868f7ee7d6c04dfaf9eca..53b30d4e0ca4a41d637049bf2ef3fe8aa120ea9b 100644 +--- a/Oka/Topology/Sheaves/Stalks.lean ++++ b/Oka/Topology/Sheaves/Stalks.lean +@@ -47,8 +47,8 @@ lemma stalkPushforward_naturality {X Y : TopCat.{v}} (g : X ⟶ Y) {F G : X.Pres + refine TopCat.Presheaf.stalk_hom_ext ((pushforward C g).obj F) fun U hU ↦ ?_ + -- `rw` cannot see through the definition of `TopCat.Presheaf` here, hence `erw`. + erw [stalkFunctor_map_germ_assoc] +- simp only [pushforward_map_app, stalkFunctor_obj, stalkPushforward_germ, +- stalkPushforward_germ_assoc] ++ simp only [pushforward_map_app, stalkFunctor_obj, stalkPushforward_germ] ++ erw [stalkPushforward_germ_assoc] + exact (stalkFunctor_map_germ (C := C) ((Opens.map g).obj U) x hU T).symm + + /-- **The specialization map between the stalks at two points which are in fact equal is an +diff --git a/Oka/Uniformization/CoveringLift.lean b/Oka/Uniformization/CoveringLift.lean +index a5ccc621c90bc562cfa5525f2f2e7e3b6616027a..ef64822db3f38d25a0c2c8a452b3ea44149f85f9 100644 +--- a/Oka/Uniformization/CoveringLift.lean ++++ b/Oka/Uniformization/CoveringLift.lean +@@ -89,12 +89,12 @@ theorem IsCoveringMapOn.eqOn_of_lift {f : E → X} {V : Set X} (hf : IsCoveringM + ⟨σ₁ a₀, hV a₀ ha₀⟩ + have hτ₁ : ContinuousOn τ₁ D := by + rw [continuousOn_iff_continuous_restrict] +- have : D.restrict τ₁ = fun a : D ↦ ⟨σ₁ a, hV a a.2⟩ := by funext a; simp [τ₁, a.2] ++ have : D.domRestrict τ₁ = fun a : D ↦ ⟨σ₁ a, hV a a.2⟩ := by funext a; simp [τ₁, a.2] + rw [this] + exact (h₁.restrict).subtype_mk _ + have hτ₂ : ContinuousOn τ₂ D := by + rw [continuousOn_iff_continuous_restrict] +- have : D.restrict τ₂ = fun a : D ↦ ⟨σ₂ a, hV₂ a a.2⟩ := by ++ have : D.domRestrict τ₂ = fun a : D ↦ ⟨σ₂ a, hV₂ a a.2⟩ := by + funext a; simp [τ₂, a.2] + rw [this] + exact (h₂.restrict).subtype_mk _ +@@ -119,8 +119,8 @@ theorem eqOn_of_sections [T2Space E] {f : E → X} {V : Set X} (hV : IsPreconnec + (hinj : ∀ v ∈ V, ∃ W ∈ 𝓝 (s₁ v), InjOn f W) {v₀ : X} (hv₀ : v₀ ∈ V) + (h₀ : s₁ v₀ = s₂ v₀) : EqOn s₁ s₂ V := by + haveI : PreconnectedSpace V := Subtype.preconnectedSpace hV +- set g₁ : V → E := V.restrict s₁ +- set g₂ : V → E := V.restrict s₂ ++ set g₁ : V → E := V.domRestrict s₁ ++ set g₂ : V → E := V.domRestrict s₂ + have hg₁ : Continuous g₁ := h₁.restrict + have hg₂ : Continuous g₂ := h₂.restrict + set A : Set V := {v | g₁ v = g₂ v} +@@ -243,6 +243,6 @@ theorem isCoveringMapOn_of_sections [T2Space E] {f : E → X} {B : Set X} + have := hsame (i := i) ht htf x hxV (hsx i) + refine mem_iUnion.mpr ⟨i, f e, he, ?_⟩ + rw [this he, hte]) +- exact .to_isEvenlyCovered_preimage (.of_trivialization (t := T) (by simpa [T] using hxV)) ++ exact .to_isEvenlyCovered_preimage (.of_trivialization (t := T) hxV) + + end Uniformization +diff --git a/Oka/Uniformization/Depth.lean b/Oka/Uniformization/Depth.lean +index 14e263fde75c44a64a19af5f2712d44c44e87368..70965c1739ea09fd21e3885d327ce5671dcb8b45 100644 +--- a/Oka/Uniformization/Depth.lean ++++ b/Oka/Uniformization/Depth.lean +@@ -214,7 +214,8 @@ theorem relIndex_ne_zero_of_mem_commensurator {G : Type*} [Group G] {Γ : Subgro + (Γ ⊓ Γ.comap (MulAut.conj δ).toMonoidHom).relIndex Γ ≠ 0 := by + have hδ' : δ⁻¹ ∈ Subgroup.Commensurable.commensurator Γ := inv_mem hδ + rw [Subgroup.Commensurable.commensurator_mem_iff] at hδ' +- have h := hδ'.1 ++ have h := hδ'.1.relIndex_ne_zero ++ change (ConjAct.toConjAct δ⁻¹ • Γ).relIndex Γ ≠ 0 at h + have heq : (ConjAct.toConjAct δ⁻¹ • Γ : Subgroup G) ⊓ Γ = + Γ ⊓ Γ.comap (MulAut.conj δ).toMonoidHom := by + ext x +diff --git a/Oka/Uniformization/FEtTransitive.lean b/Oka/Uniformization/FEtTransitive.lean +index fee3b419f88285966fd31025b20f086f5346fad7..bf78ec61adbdbf0dff71fd857bce4d2dbf891d54 100644 +--- a/Oka/Uniformization/FEtTransitive.lean ++++ b/Oka/Uniformization/FEtTransitive.lean +@@ -235,7 +235,7 @@ theorem exists_smul_eq (hhol : ∀ a, Unif.HolH (ι₀ a)) {n : ℕ} + · refine (PolyBdd.prod S (u := fun _ τ ↦ 1 + R τ) (fun _ _ ↦ (PolyBdd.const 1).add hR) + fun _ _ τ ↦ by positivity).mono fun τ ↦ ?_ + refine (norm_coeff_prod_X_sub_C_le _ _ k).trans ?_ +- exact Finset.prod_le_prod (fun _ _ ↦ by positivity) fun f hf ↦ by linarith [hfR f hf τ] ++ exact Finset.prod_le_prod₀ (fun _ _ ↦ by positivity) fun f hf ↦ by linarith [hfR f hf τ] + choose a ha using hcoeff + set Q : A[X] := X ^ m + ∑ i : Fin m, C (a i) * X ^ (i : ℕ) + have hQm : Q.Monic := monic_X_pow_add (degree_sum_fin_lt _) +diff --git a/Oka/Uniformization/Integrality.lean b/Oka/Uniformization/Integrality.lean +index fd22073e989755defe2b3e014904682fb5d0fe10..0c55e5b1349c97d3215c969e913da79ac779ccfa 100644 +--- a/Oka/Uniformization/Integrality.lean ++++ b/Oka/Uniformization/Integrality.lean +@@ -202,6 +202,7 @@ theorem le_commensurator {G : Type*} [Group G] (Γ : Subgroup G) : + Γ ≤ Subgroup.Commensurable.commensurator Γ := by + intro g hg + rw [Subgroup.Commensurable.commensurator_mem_iff] ++ change (ConjAct.toConjAct g • Γ).Commensurable Γ + have : ConjAct.toConjAct g • Γ = Γ := by + ext x + rw [Subgroup.mem_pointwise_smul_iff_inv_smul_mem, ← map_inv, ConjAct.smul_def, +@@ -268,7 +269,7 @@ theorem exists_monic_wpΨ_smul {δ : SL(2, ℝ)} + have hw1 : 1 ≤ 2 + w := by linarith [norm_nonneg (wpΨ U τ)] + refine (norm_coeff_prod_X_sub_C_le _ _ k).trans ?_ + rw [← Finset.prod_pow_eq_pow_sum, ← Finset.prod_mul_distrib] +- refine Finset.prod_le_prod (fun q _ ↦ by positivity) fun q _ ↦ ?_ ++ refine Finset.prod_le_prod₀ (fun q _ ↦ by positivity) fun q _ ↦ ?_ + have h1 : 1 ≤ (2 + w) ^ Nq q := one_le_pow₀ hw1 + have h2 := hq q τ + have h3 : Cq q * (2 + w) ^ Nq q ≤ |Cq q| * (2 + w) ^ Nq q := +diff --git a/Oka/Uniformization/PmDeck.lean b/Oka/Uniformization/PmDeck.lean +index b1d47aa62e690548727ab235db59d1bd60fff16e..c1bda015ad02de12045536b9ecdb9b1bef5bf8e7 100644 +--- a/Oka/Uniformization/PmDeck.lean ++++ b/Oka/Uniformization/PmDeck.lean +@@ -166,7 +166,9 @@ theorem relIndex_deckGroup_pmDeck_ne_zero : U.deckGroup.relIndex U.pmDeck ≠ 0 + theorem commensurator_pmDeck : + Subgroup.Commensurable.commensurator U.pmDeck = + Subgroup.Commensurable.commensurator U.deckGroup := by +- refine Subgroup.Commensurable.eq ⟨?_, U.relIndex_deckGroup_pmDeck_ne_zero⟩ ++ refine Subgroup.Commensurable.eq ⟨?_, ++ Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr U.relIndex_deckGroup_pmDeck_ne_zero⟩ ++ apply Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr + rw [Subgroup.relIndex_eq_one.mpr (U.deckGroup_le_pmDeck)]; exact one_ne_zero + + /-- A `Γ̃`-invariant function on `ℍ` as a function on `ℂ ∖ Λ` (and `0` on `Λ`). -/ +diff --git a/Oka/Uniformization/R3.lean b/Oka/Uniformization/R3.lean +index 20629bda471772eb929b2c64251022295155b93f..421e9b56a0c7fd31f7d5c113499f34a922cd9b51 100644 +--- a/Oka/Uniformization/R3.lean ++++ b/Oka/Uniformization/R3.lean +@@ -315,7 +315,7 @@ theorem exists_cosetPoly (hΓN : U.pmDeck ≤ N) + have hw1 : 1 ≤ 2 + w := by linarith [norm_nonneg (wpΨ U τ)] + refine (norm_coeff_prod_X_sub_C_le _ _ k).trans ?_ + rw [← Finset.prod_pow_eq_pow_sum, ← Finset.prod_mul_distrib] +- refine Finset.prod_le_prod (fun q _ ↦ by positivity) fun q _ ↦ ?_ ++ refine Finset.prod_le_prod₀ (fun q _ ↦ by positivity) fun q _ ↦ ?_ + have h1 : 1 ≤ (2 + w) ^ Nq q := one_le_pow₀ hw1 + have h2 := hq q τ + have h3 : Cq q * (2 + w) ^ Nq q ≤ |Cq q| * (2 + w) ^ Nq q := +diff --git a/Oka/Uniformization/SL2Facts.lean b/Oka/Uniformization/SL2Facts.lean +index aaf4432cb8f98dd785743a87b19f3eb4415475f3..9d0eb99ffd04bfe3a520ad32f40b43a85db3f7b3 100644 +--- a/Oka/Uniformization/SL2Facts.lean ++++ b/Oka/Uniformization/SL2Facts.lean +@@ -145,6 +145,8 @@ def conjFix (η : ℝ) : SL(2, ℝ) := + theorem conjFix_lowerLeft (η : ℝ) (g : SL(2, ℝ)) : + ((conjFix η)⁻¹ * g * conjFix η) 1 0 = + g 1 0 * η ^ 2 + (g 1 1 - g 0 0) * η - g 0 1 := by ++ rw [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_mul, ++ Matrix.SpecialLinearGroup.coe_inv] + simp [conjFix, Matrix.SpecialLinearGroup.coe_inv, Matrix.adjugate_fin_two, + Matrix.mul_apply, Fin.sum_univ_two, Matrix.vecMul, dotProduct] + ring +diff --git a/Oka/Uniformization/Uniqueness.lean b/Oka/Uniformization/Uniqueness.lean +index 57dd1eaca047eeaa4fa695db65f084adf79d64c0..eafbb89b7c83435aa070624a25cd2e644111846f 100644 +--- a/Oka/Uniformization/Uniqueness.lean ++++ b/Oka/Uniformization/Uniqueness.lean +@@ -179,16 +179,16 @@ theorem exists_section_of_graph (h : IsUniformization W A B π) (z : ℍ) {pr pr + refine (convex_ball a₀ ε).isPreconnected.image φ ?_ + rw [continuousOn_iff_continuous_restrict] + refine continuous_induced_rng.mpr ?_ +- have : (fun a : ball a₀ ε ↦ ((ball a₀ ε).restrict φ a).1) = fun a ↦ π (σ a.1) := by ++ have : (fun a : ball a₀ ε ↦ ((ball a₀ ε).domRestrict φ a).1) = fun a ↦ π (σ a.1) := by + funext a; exact hφ a a.2 + rw [Function.comp_def, this] + refine ContinuousOn.comp_continuous (s := {w : ℂ | 0 < w.im}) h.differentiableOn.continuousOn + ((hσc.mono hb₁).comp_continuous continuous_subtype_val fun a ↦ a.2) fun a ↦ (hb₂ a a.2).1 + · rw [continuousOn_iff_continuous_restrict] + refine isOpenEmbedding_coe.isInducing.continuous_iff.mpr ?_ +- have : (fun q : N ↦ ((N.restrict s q : ℍ) : ℂ)) = fun q : N ↦ σ (pr q.1.1) := by ++ have : (fun q : N ↦ ((N.domRestrict s q : ℍ) : ℂ)) = fun q : N ↦ σ (pr q.1.1) := by + funext q; exact hs_val q q.2 +- rw [Function.comp_def]; simp only [restrict_apply] at this ⊢ ++ rw [Function.comp_def]; simp only [domRestrict_apply] at this ⊢ + rw [this] + exact (hσc.mono hb₁).comp_continuous ((hpr.comp continuous_subtype_val).comp + continuous_subtype_val) fun q ↦ q.2.1 +diff --git a/Oka/Weierstrass.lean b/Oka/Weierstrass.lean +index 0d471db0ce70845ecde33a5dc724eb00556b9315..76d64d708f7ac1b75b2e5cbc9381946442169388 100644 +--- a/Oka/Weierstrass.lean ++++ b/Oka/Weierstrass.lean +@@ -3358,7 +3358,7 @@ theorem MvPowerSeries.exists_direction {p : ℕ} + ∑ e ∈ degFinset (Fin (n + 1)) (k i), MvPolynomial.monomial e (coeff e (P i)) with hhp + have hh : ∀ i, hpol i ≠ 0 := by + intro i hzero +- have h3 := congrArg (MvPolynomial.coeff (D i)) hzero ++ have h3 := congrArg (fun f : MvPolynomial (Fin (n + 1)) ℂ ↦ f.coeff (D i)) hzero + rw [hhp] at h3 + simp only [MvPolynomial.coeff_sum, MvPolynomial.coeff_monomial, + MvPolynomial.coeff_zero] at h3 +diff --git a/lake-manifest.json b/lake-manifest.json +index c1d5a66d8ec064b00b58871d4139a8628f14f416..497d95b2b92486861c747fc3d9e39301bc54a72a 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,31 +1,51 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/lana-agents/heights.git", ++ [{"url": "https://github.com/lana-agents/oka.git", + "type": "git", + "subDir": null, + "scope": "", +- "rev": "3539e2a12dd3470c057a4eb531dc3fd627d4c97b", ++ "rev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", ++ "name": "oka", ++ "manifestFile": "lake-manifest.json", ++ "inputRev": "75dcdc3faadd10b986afb9283e89902bcdddecd4", ++ "inherited": true, ++ "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/heights.git", ++ "type": "git", ++ "subDir": null, ++ "scope": "", ++ "rev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", + "name": "heights", + "manifestFile": "lake-manifest.json", +- "inputRev": "3539e2a12dd3470c057a4eb531dc3fd627d4c97b", ++ "inputRev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/mathlib4", ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, ++ {"url": "https://github.com/lana-agents/belyi.git", ++ "type": "git", ++ "subDir": null, ++ "scope": "", ++ "rev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "name": "belyi", ++ "manifestFile": "lake-manifest.json", ++ "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "inherited": true, ++ "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -35,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -65,7 +85,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -75,7 +95,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -85,7 +105,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -95,10 +115,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "oka", +diff --git a/lakefile.toml b/lakefile.toml +index d0589c058d6ab8b11ca5591af6f63caecb1850c9..d22800380c12ce35a302e598325148e01d56f365 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -8,6 +8,8 @@ lintDriver = "batteries/runLinter" + lintDriverArgs = ["Oka"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + autoImplicit = false + relaxedAutoImplicit = false +@@ -16,8 +18,8 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "Oka" +@@ -27,4 +29,4 @@ name = "Oka" + [[require]] + name = "heights" + git = "https://github.com/lana-agents/heights.git" +-rev = "3539e2a12dd3470c057a4eb531dc3fd627d4c97b" ++rev = "721496ca4c158e511d25d8ccf6bfe8503eda73c1" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/orbicurve-cores-lean4341.patch b/lean/patches/orbicurve-cores-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..1a21d9462474a261e43d234d2d098e64dce6e7d3 --- /dev/null +++ b/lean/patches/orbicurve-cores-lean4341.patch @@ -0,0 +1,695 @@ +diff --git a/OrbicurveCores/ArithTraces.lean b/OrbicurveCores/ArithTraces.lean +index c3a654502b15d737f9dfe7b668eda835b78264f1..6e00fbdb9aa6a8d6f1eaf5e95798a0919e5373ea 100644 +--- a/OrbicurveCores/ArithTraces.lean ++++ b/OrbicurveCores/ArithTraces.lean +@@ -57,12 +57,11 @@ lemma trace_int_of_mem_SL {M : GL (Fin 2) ℝ} (hM : M ∈ 𝒮ℒ) : + into `𝒮ℒ` by `g`. -/ + lemma exists_conj_pow_mem {g : GL (Fin 2) ℝ} (hg : g ∈ commensurator 𝒮ℒ) {u : GL (Fin 2) ℝ} + (hu : u ∈ 𝒮ℒ) : ∃ n : ℕ, 0 < n ∧ g⁻¹ * u ^ n * g ∈ 𝒮ℒ := by +- obtain ⟨n, hn, -, hmem⟩ := exists_pow_mem_of_relIndex_ne_zero hg.1 hu ++ obtain ⟨n, hn, -, hmem⟩ := exists_pow_mem_of_relIndex_ne_zero hg.1.relIndex_ne_zero hu + refine ⟨n, hn, ?_⟩ + have h := (Subgroup.mem_inf.mp hmem).1 + rw [mem_pointwise_smul_iff_inv_smul_mem] at h +- simpa only [MulEquiv.coe_toMonoidHom, ← ConjAct.toConjAct_inv, ConjAct.toConjAct_smul, +- inv_inv] using h ++ exact h + + /-- The lower unipotent generator of `SL(2, ℤ)`. -/ + def lowerL : SL(2, ℤ) := ⟨!![1, 0; 1, 1], by simp [det_fin_two]⟩ +@@ -85,6 +84,7 @@ lemma mapGL_lowerL_pow (n : ℕ) : + | zero => simp [Matrix.one_fin_two] + | succ n ih => + rw [pow_succ, map_mul, Units.val_mul, ih] ++ rw [mapGL_coe_matrix] + ext i j + fin_cases i <;> fin_cases j <;> simp [lowerL, mul_apply, Fin.sum_univ_two] + +@@ -215,7 +215,7 @@ theorem IsArithmeticSL.sq_tr_int {Γ : Subgroup SL(2, ℝ)} (hΓ : IsArithmeticS + -- `γ'` commensurates `𝒮ℒ` + have hγ'comm : γ' ∈ commensurator 𝒮ℒ := by + rw [← Commensurable.eq hcomm, Commensurable.commensurator_mem_iff, +- conjAct_pointwise_smul_eq_self (le_normalizer hγ')] ++ conj_smul_eq_self_of_mem hγ'] + -- traces + have trγ' : trace (γ' : Matrix (Fin 2) (Fin 2) ℝ) = tr γ := by + simp only [hγ'def, Units.val_mul, coe_GL_coe_matrix, tr] +@@ -229,7 +229,7 @@ theorem IsArithmeticSL.sq_tr_int {Γ : Subgroup SL(2, ℝ)} (hΓ : IsArithmeticS + have := tr_mul_tr_inv_mem_rat hγ'comm + rwa [trγ', trγ'inv, ← pow_two] at this + -- integrality +- obtain ⟨n, hn, -, hpow⟩ := exists_pow_mem_of_relIndex_ne_zero hcomm.2 hγ' ++ obtain ⟨n, hn, -, hpow⟩ := exists_pow_mem_of_relIndex_ne_zero hcomm.2.relIndex_ne_zero hγ' + obtain ⟨m, hm⟩ := trace_int_of_mem_SL hpow.1 + have hpow' : γ' ^ n = g * toGL (γ ^ n) * g⁻¹ := by + rw [hγ'def, conj_pow, map_pow] +@@ -240,7 +240,7 @@ theorem IsArithmeticSL.sq_tr_int {Γ : Subgroup SL(2, ℝ)} (hΓ : IsArithmeticS + have hint : IsIntegral ℤ (tr γ ^ 2) := (isIntegral_of_lucas_eq hn htr).pow 2 + obtain ⟨q, hq⟩ := hrat + have hq' : IsIntegral ℤ q := by +- rw [← isIntegral_algebraMap_iff (A := ℚ) (B := ℝ) (algebraMap ℚ ℝ).injective] ++ rw [← isIntegral_algebraMap_iff (A := ℚ) (B := ℝ)] + simpa [← hq] using hint + obtain ⟨k, hk⟩ := IsIntegrallyClosed.isIntegral_iff.mp hq' + refine ⟨k, ?_⟩ +diff --git a/OrbicurveCores/Core.lean b/OrbicurveCores/Core.lean +index 5805d0f2a3cfc2729ecf8b0b2f9fe8b6358590b6..d855d04e82d60840d7ffab8a100b04ead7035132 100644 +--- a/OrbicurveCores/Core.lean ++++ b/OrbicurveCores/Core.lean +@@ -65,8 +65,10 @@ lemma map_conjAct_smul (f : G →* H) (x : G) (K : Subgroup G) : + /-- Commensurators are transported along injective homomorphisms. -/ + lemma mem_commensurator_map_iff {f : G →* H} (hf : Function.Injective f) {x : G} + {K : Subgroup G} : f x ∈ commensurator (K.map f) ↔ x ∈ commensurator K := by +- simp only [Commensurable.commensurator_mem_iff, Commensurable, ← map_conjAct_smul, +- relIndex_map_map_of_injective _ _ hf] ++ rw [Commensurable.commensurator_mem_iff, Commensurable.commensurator_mem_iff] ++ change Commensurable (ConjAct.toConjAct (f x) • K.map f) (K.map f) ↔ ++ Commensurable (ConjAct.toConjAct x • K) K ++ rw [← map_conjAct_smul, Commensurable.map_injective_iff hf] + + end conj + +@@ -140,7 +142,7 @@ theorem IsArithmeticSL.not_admitsCore {Γ : Subgroup SL(2, ℝ)} (hΓ : IsArithm + hΓ'.is_commensurable.symm + -- `s = g⁻¹ r g` commensurates `Γ.map toGL` + have hsC : Commensurable (ConjAct.toConjAct s • ΓGL) ΓGL := by +- rw [Commensurable.commensurable_conj (ConjAct.toConjAct g)] ++ rw [← Commensurable.smul_iff (φ := ConjAct.toConjAct g)] + have e : ConjAct.toConjAct g • ConjAct.toConjAct s • ΓGL = ConjAct.toConjAct r • Γ' := by + simp only [Γ', ← mul_smul, ← map_mul, hs] + congr 2 +@@ -163,7 +165,9 @@ theorem IsArithmeticSL.not_admitsCore {Γ : Subgroup SL(2, ℝ)} (hΓ : IsArithm + c • (s : Matrix (Fin 2) (Fin 2) ℝ) := rfl + have hσC : σ ∈ commensurator Γ := by + rw [← mem_commensurator_map_iff (f := toGL) toGL_injective, +- Commensurable.commensurator_mem_iff, conjAct_smul_eq_of_scalar hc0 hσs] ++ Commensurable.commensurator_mem_iff] ++ change Commensurable (ConjAct.toConjAct (toGL σ) • Γ.map toGL) (Γ.map toGL) ++ rw [conjAct_smul_eq_of_scalar hc0 hσs] + exact hsC + -- no positive power of `σ` lies in `Γ` + obtain ⟨n, hn, hσn⟩ := hcore.exists_pow_mem hσC +diff --git a/OrbicurveCores/ForMathlib/ComplexEmbedding.lean b/OrbicurveCores/ForMathlib/ComplexEmbedding.lean +index d36a4269ff942b77372fe6e37dd3aff87fa7cafe..f980b285e995d7ed336db45c47898180a39fded4 100644 +--- a/OrbicurveCores/ForMathlib/ComplexEmbedding.lean ++++ b/OrbicurveCores/ForMathlib/ComplexEmbedding.lean +@@ -105,4 +105,6 @@ theorem exists_ringHom_real_complex_ne {x : ℝ} (hx : x ∉ Set.range ((↑) : + have h := RingHom.congr_fun he (Ideal.Quotient.mk I X) + simp only [RingHom.coe_comp, Function.comp_apply, f, g, Ideal.Quotient.lift_mk] at h + simp only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe, aeval_X] at h +- simpa [h] using hne ++ change e (x : ℂ) = y at h ++ change e (x : ℂ) ≠ (x : ℂ) ++ rwa [h] +diff --git a/OrbicurveCores/Fuchsian/Commensurator.lean b/OrbicurveCores/Fuchsian/Commensurator.lean +index 8726267371001ef40e3411ee8cddc0d7e78a184b..0114ed0e8da5893971ad0156d82151f0b8381341 100644 +--- a/OrbicurveCores/Fuchsian/Commensurator.lean ++++ b/OrbicurveCores/Fuchsian/Commensurator.lean +@@ -35,8 +35,9 @@ namespace Fuchsian + + lemma le_commensurator (Γ : Subgroup SL(2, ℝ)) : Γ ≤ commensurator Γ := by + intro γ hγ +- rw [Subgroup.Commensurable.commensurator_mem_iff, +- Subgroup.conjAct_pointwise_smul_eq_self (Subgroup.le_normalizer hγ)] ++ rw [Subgroup.Commensurable.commensurator_mem_iff] ++ change Subgroup.Commensurable (ConjAct.toConjAct γ • Γ) Γ ++ rw [Subgroup.conjAct_pointwise_smul_eq_self (Subgroup.le_normalizer hγ)] + + /-- If `1` is isolated in a subgroup, the subgroup is discrete. -/ + lemma discreteTopology_of_nhdsWithin_eq_bot {H : Subgroup SL(2, ℝ)} +diff --git a/OrbicurveCores/Fuchsian/DenseSubgroup.lean b/OrbicurveCores/Fuchsian/DenseSubgroup.lean +index bd64d8c57078a8fd5d6809339d6c2624ac8ceefc..7e4d97090814d1257d8f68300fc808fcae61fc32 100644 +--- a/OrbicurveCores/Fuchsian/DenseSubgroup.lean ++++ b/OrbicurveCores/Fuchsian/DenseSubgroup.lean +@@ -242,7 +242,9 @@ def wS : SL(2, ℝ) := ⟨!![0, -1; 1, 0], by simp [det_fin_two]⟩ + + lemma wS_conj_uU (t : ℝ) : wS * uU t * wS⁻¹ = uL (-t) := by + ext i j +- simp only [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_inv, wS, coe_uU, ++ rw [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_mul, ++ Matrix.SpecialLinearGroup.coe_inv] ++ simp only [wS, coe_uU, + coe_uL, adjugate_fin_two] + fin_cases i <;> fin_cases j <;> simp [Matrix.mul_apply, Fin.sum_univ_two] + +@@ -262,7 +264,9 @@ theorem uL_mem_of_tendsto {K : Subgroup SL(2, ℝ)} (hK : IsClosed (K : Set SL(2 + change wS * D * wS⁻¹ ∈ K + have : wS * D * wS⁻¹ = D⁻¹ := by + ext i j +- simp only [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_inv, wS, hD, ++ rw [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_mul, ++ Matrix.SpecialLinearGroup.coe_inv, Matrix.SpecialLinearGroup.coe_inv] ++ simp only [wS, hD, + adjugate_fin_two] + fin_cases i <;> fin_cases j <;> simp [Matrix.mul_apply, Fin.sum_univ_two] + rw [this]; exact inv_mem hDK +@@ -275,7 +279,9 @@ theorem uL_mem_of_tendsto {K : Subgroup SL(2, ℝ)} (hK : IsClosed (K : Set SL(2 + simpa [Function.comp_def] using this + have h01' : ∀ n, ((wS⁻¹ * g n * wS : SL(2, ℝ)) : Matrix (Fin 2) (Fin 2) ℝ) 0 1 ≠ 0 := by + intro n +- simp only [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_inv, wS, ++ rw [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_mul, ++ Matrix.SpecialLinearGroup.coe_inv] ++ simp only [wS, + adjugate_fin_two] + rw [eta_fin_two (g n : Matrix (Fin 2) (Fin 2) ℝ)] + simp only [Matrix.mul_fin_two] +diff --git a/OrbicurveCores/M2/BoundaryMeasure.lean b/OrbicurveCores/M2/BoundaryMeasure.lean +index 1e9c086241e6d946c523d37338a53a1d38d296a8..820fe96d4ad126e959e5d49ea1044d219ef6c9f0 100644 +--- a/OrbicurveCores/M2/BoundaryMeasure.lean ++++ b/OrbicurveCores/M2/BoundaryMeasure.lean +@@ -268,7 +268,8 @@ theorem tendsto_lintegral_comp_smul {F : OnePoint ℝ → ℝ} (hF : Measurable + rw [Real.norm_eq_abs]; exact hb x) + obtain ⟨φ, hφ, -⟩ := hmem.exists_boundedContinuous_eLpNorm_sub_le ENNReal.one_ne_top + (ENNReal.ofReal_pos.2 hη).ne' +- rw [eLpNorm_one_eq_lintegral_enorm] at hφ ++ rw [eLpNorm_one_eq_lintegral_enorm ++ (hF.sub φ.continuous.measurable).aestronglyMeasurable] at hφ + have hFφ : Measurable fun x ↦ ‖F x - φ x‖ₑ := (hF.sub φ.continuous.measurable).enorm + have hφφ : ∀ n, Measurable fun x ↦ ‖φ (g n • x) - φ (g₀ • x)‖ₑ := fun n ↦ + ((φ.continuous.measurable.comp (measurable_smul_bdry _)).sub +diff --git a/OrbicurveCores/M2/Final.lean b/OrbicurveCores/M2/Final.lean +index 67fd5f5954e86363fed1e27dfe19196db7074661..736750a0ecfd5825501624bbdd2d5dfffd7607fc 100644 +--- a/OrbicurveCores/M2/Final.lean ++++ b/OrbicurveCores/M2/Final.lean +@@ -119,6 +119,7 @@ end general + + lemma neg_one_mem_commensurator (Γ : Subgroup SL(2, ℝ)) : (-1 : SL(2, ℝ)) ∈ commensurator Γ := by + rw [Subgroup.Commensurable.commensurator_mem_iff] ++ change (ConjAct.toConjAct (-1 : SL(2, ℝ)) • Γ).Commensurable Γ + have : ConjAct.toConjAct (-1 : SL(2, ℝ)) • Γ = Γ := by + ext g + rw [Subgroup.mem_pointwise_smul_iff_inv_smul_mem, ConjAct.smul_def] +@@ -604,8 +605,11 @@ theorem margulisDenseOneInfty : MargulisDenseOneInfty := by + have hc := commensurable_signs hA'' hB'' + rw [hcl] at hc + have hinj := Matrix.SpecialLinearGroup.toGL_injective (n := Fin 2) (R := ℝ) +- exact ⟨by simpa [Subgroup.relIndex_map_map_of_injective _ _ hinj] using hc.1, +- by simpa [Subgroup.relIndex_map_map_of_injective _ _ hinj] using hc.2⟩ ++ constructor ++ · apply Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr ++ simpa [Subgroup.relIndex_map_map_of_injective _ _ hinj] using hc.1.relIndex_ne_zero ++ · apply Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr ++ simpa [Subgroup.relIndex_map_map_of_injective _ _ hinj] using hc.2.relIndex_ne_zero + have hcommeq : commensurator H'' = commensurator H := Subgroup.Commensurable.eq hcomm'' + -- conjugation + set P : Matrix (Fin 2) (Fin 2) ℝ := g.1 +diff --git a/OrbicurveCores/M2/Furstenberg.lean b/OrbicurveCores/M2/Furstenberg.lean +index 48ebc6847143f8eb47d97b8c781f2e0d2d052f72..1e1a7ed1ece0920854283d5f28998b52803d9134 100644 +--- a/OrbicurveCores/M2/Furstenberg.lean ++++ b/OrbicurveCores/M2/Furstenberg.lean +@@ -330,7 +330,7 @@ lemma integral_theta [OpensMeasurableSpace Y] (n : ℕ) (g : SL(2, ℝ)) (f : Y + + lemma theta_mul [BorelSpace Y] (n : ℕ) (γ₀ : Γ) (g : SL(2, ℝ)) : + theta D α y₀ n ((γ₀ : SL(2, ℝ)) * g) = +- (theta D α y₀ n g).map (α γ₀).continuous.measurable.aemeasurable := by ++ (theta D α y₀ n g).map (α γ₀) := by + apply ProbabilityMeasure.toMeasure_injective + ext A hA + rw [ProbabilityMeasure.toMeasure_map, Measure.map_apply (α γ₀).continuous.measurable hA, +@@ -509,7 +509,7 @@ lemma tendsto_comb_theta_mul_iff {p : SL(2, ℝ)} (hp : IsP p) (g : SL(2, ℝ)) + + lemma comb_theta_mul (γ₀ : Γ) (g : SL(2, ℝ)) (m : ℕ) : + (W.comb m fun k ↦ theta D α y₀ k ((γ₀ : SL(2, ℝ)) * g)) = +- (W.comb m fun k ↦ theta D α y₀ k g).map (α γ₀).continuous.measurable.aemeasurable := by ++ (W.comb m fun k ↦ theta D α y₀ k g).map (α γ₀) := by + rw [W.comb_map _ _ (α γ₀).continuous.measurable] + simp_rw [theta_mul] + +@@ -517,7 +517,7 @@ lemma comb_theta_mul (γ₀ : Γ) (g : SL(2, ℝ)) (m : ℕ) : + lemma tendsto_comb_theta_mul {γ₀ : Γ} {g : SL(2, ℝ)} {ν : ProbabilityMeasure Y} + (h : Tendsto (fun m ↦ W.comb m fun k ↦ theta D α y₀ k g) atTop (𝓝 ν)) : + Tendsto (fun m ↦ W.comb m fun k ↦ theta D α y₀ k ((γ₀ : SL(2, ℝ)) * g)) atTop +- (𝓝 (ν.map (α γ₀).continuous.measurable.aemeasurable)) := by ++ (𝓝 (ν.map (α γ₀))) := by + simp_rw [comb_theta_mul] + exact ((ProbabilityMeasure.continuous_map (α γ₀).continuous).tendsto ν).comp h + +@@ -615,7 +615,7 @@ theorem GoodLattice.exists_boundaryMap {Γ : Subgroup SL(2, ℝ)} (h : GoodLatti + have h3 := tendsto_nhds_unique (W.tendsto_lim ν₀ hy) h2 + rw [hsmul] + change (ψℝ y : Measure Y) = (ψℝ x : Measure Y).map (α γ) +- have h4 : ψℝ y = (ψℝ x).map (α γ).continuous.measurable.aemeasurable := h3 ++ have h4 : ψℝ y = (ψℝ x).map (α γ) := h3 + rw [h4, ProbabilityMeasure.toMeasure_map] + + /-- `GoodLattice.exists_boundaryMap` with the boundary map packaged as a Markov kernel. -/ +diff --git a/OrbicurveCores/M2/FurstenbergLimit.lean b/OrbicurveCores/M2/FurstenbergLimit.lean +index 7de16b7217602dbfe81c4aa7d071659763c52f94..59abb2f8652f171992b39f706598cf8b220f84ef 100644 +--- a/OrbicurveCores/M2/FurstenbergLimit.lean ++++ b/OrbicurveCores/M2/FurstenbergLimit.lean +@@ -80,7 +80,7 @@ lemma integral_comb [TopologicalSpace Y] [OpensMeasurableSpace Y] (n : ℕ) + + lemma comb_map {Z : Type*} [MeasurableSpace Z] (n : ℕ) (θ : ℕ → ProbabilityMeasure Y) + {h : Y → Z} (hh : Measurable h) : +- (W.comb n θ).map hh.aemeasurable = W.comb n fun k ↦ (θ k).map hh.aemeasurable := by ++ (W.comb n θ).map h = W.comb n fun k ↦ (θ k).map h := by + apply ProbabilityMeasure.toMeasure_injective + ext s hs + simp only [ProbabilityMeasure.toMeasure_map, coe_comb, combMeasure_apply, +diff --git a/OrbicurveCores/M2/HopfCoords.lean b/OrbicurveCores/M2/HopfCoords.lean +index fd3f5c06753b4d6541de6ffea2958e1c09c0b66c..55efd387b2954792580927d58f67ef652e56a38a 100644 +--- a/OrbicurveCores/M2/HopfCoords.lean ++++ b/OrbicurveCores/M2/HopfCoords.lean +@@ -80,6 +80,7 @@ lemma hopf_mul_diagA (p : ℝ × ℝ × ℝ) (σ : ℝ) : hopf p * diagA σ = ho + + lemma diagA_mul_unip (σ t : ℝ) : diagA σ * unip t = unip (exp (2 * σ) * t) * diagA σ := by + ext i j ++ rw [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_mul] + have h := exp_mul_exp_neg σ + fin_cases i <;> fin_cases j <;> + simp [diagA, unip, Matrix.mul_apply, Fin.sum_univ_two, exp_two_mul'] +diff --git a/OrbicurveCores/M2/Superrigid.lean b/OrbicurveCores/M2/Superrigid.lean +index 5afbfbbdec312eb205a6fe8f2d2ce74c4a14f800..dbc9b35a55b180f8b99c246ab18aa8c4690ca164 100644 +--- a/OrbicurveCores/M2/Superrigid.lean ++++ b/OrbicurveCores/M2/Superrigid.lean +@@ -81,7 +81,8 @@ theorem equivariant_commensurator {Γ Δ : Subgroup SL(2, ℝ)} (hΓΔ : Γ ≤ + simpa using this + have hfi : Γδ.relIndex Γ ≠ 0 := by + rw [Subgroup.inf_relIndex_right] +- exact (Subgroup.Commensurable.commensurator_mem_iff _ _).1 (inv_mem (hΔ hδ)) |>.1 ++ exact ((Subgroup.Commensurable.commensurator_mem_iff _ _).1 ++ (inv_mem (hΔ hδ))).1.relIndex_ne_zero + haveI : Countable Γδ := Set.Countable.to_subtype + ((Set.countable_coe_iff.1 ‹Countable Γ›).mono hle) + have hactδ : ActsOn Γδ a := hact.mono (hle.trans hΓΔ) +diff --git a/OrbicurveCores/M2/TraceField.lean b/OrbicurveCores/M2/TraceField.lean +index 611fcf2484e214940a56d559b25224ed665f2f60..69e24da9759dc8424a2ce2fa2a784fb3226e7911 100644 +--- a/OrbicurveCores/M2/TraceField.lean ++++ b/OrbicurveCores/M2/TraceField.lean +@@ -132,7 +132,9 @@ theorem slIn_of_mem_closure {A B : SL(2, ℝ)} (hA : SLIn F A) (hB : SLIn F B) { + /-- A power of each element of `Γ` is conjugated into `Γ` by a commensurating element. -/ + theorem exists_pow_conj_mem {Γ : Subgroup SL(2, ℝ)} {δ : SL(2, ℝ)} (hδ : δ ∈ commensurator Γ) + {P : SL(2, ℝ)} (hP : P ∈ Γ) : ∃ n, 0 < n ∧ δ⁻¹ * P ^ n * δ ∈ Γ := by +- obtain ⟨n, hn, -, hmem⟩ := Subgroup.exists_pow_mem_of_relIndex_ne_zero hδ.1 hP ++ have hδ' := hδ.1.relIndex_ne_zero ++ change (ConjAct.toConjAct δ • Γ).relIndex Γ ≠ 0 at hδ' ++ obtain ⟨n, hn, -, hmem⟩ := Subgroup.exists_pow_mem_of_relIndex_ne_zero hδ' hP + refine ⟨n, hn, ?_⟩ + have h := (Subgroup.mem_inf.mp hmem).1 + rw [Subgroup.mem_pointwise_smul_iff_inv_smul_mem, ConjAct.smul_def] at h +diff --git a/OrbicurveCores/S1/OrbLift.lean b/OrbicurveCores/S1/OrbLift.lean +index 302eeaa5a9d749cb10f7958c550cbb128ba59721..c250449c73aa675033e95bbb63dd3ef5904f55f6 100644 +--- a/OrbicurveCores/S1/OrbLift.lean ++++ b/OrbicurveCores/S1/OrbLift.lean +@@ -209,7 +209,7 @@ lemma exists_section {S : Set (ℂ × ℂ × ℂ)} {V : Set ℂ} {H : ℂ → + refine ⟨fun z ↦ if hz : z ∈ V then ⟨jet H z, hS z hz⟩ else q, ?_, fun z hz ↦ by simp [hz], + Subtype.ext (by simp [hq, hqH.symm])⟩ + rw [continuousOn_iff_continuous_restrict] +- have : V.restrict (fun z ↦ if hz : z ∈ V then (⟨jet H z, hS z hz⟩ : S) else q) = ++ have : V.domRestrict (fun z ↦ if hz : z ∈ V then (⟨jet H z, hS z hz⟩ : S) else q) = + fun z : V ↦ ⟨jet H z, hS z z.2⟩ := funext fun z ↦ dif_pos z.2 + rw [this] + exact (continuousOn_jet hd hV).restrict.subtype_mk _ +diff --git a/OrbicurveCores/S1/Rigidity/Lift.lean b/OrbicurveCores/S1/Rigidity/Lift.lean +index 87f401f9f9461b1ce08f50d15476c112a9ffa84a..ba7fdcaf2e0af119b662b0c1d8412ab8fbb971eb 100644 +--- a/OrbicurveCores/S1/Rigidity/Lift.lean ++++ b/OrbicurveCores/S1/Rigidity/Lift.lean +@@ -61,7 +61,7 @@ theorem exists_isLatticeLift {τ : ℍ} {A B : SL(2, ℝ)} + else Heights.latticeCurvePointInfinity τ + have hgc : ContinuousOn g {z : ℂ | 0 < z.im} := by + rw [continuousOn_iff_continuous_restrict] +- have : {z : ℂ | 0 < z.im}.restrict g = ++ have : {z : ℂ | 0 < z.im}.domRestrict g = + fun z : {z : ℂ | 0 < z.im} ↦ Heights.latticeCurvePointOfAffine τ ⟨π z, heq' z z.2⟩ := by + funext z + exact dif_pos z.2 +diff --git a/OrbicurveCores/Sharpness.lean b/OrbicurveCores/Sharpness.lean +index 3703e52b4d0bc57eb925d06d2f279f092716ed83..59c2d5e531a8f95280a905ac4fb0f1432754e6b7 100644 +--- a/OrbicurveCores/Sharpness.lean ++++ b/OrbicurveCores/Sharpness.lean +@@ -563,8 +563,10 @@ theorem isArithmeticSL_of_certs {C : CoverCert} {D : TransCert} + IsArithmeticSL (Subgroup.closure {A, B}) := + ⟨1, ⟨by + rw [map_one, one_smul] +- exact ⟨relIndex_ne_zero_of_coverOK hn hk hA hB hC, +- relIndex_ne_zero_of_transOK hn hk hA hB hD⟩⟩⟩ ++ exact ⟨Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr ++ (relIndex_ne_zero_of_coverOK hn hk hA hB hC), ++ Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr ++ (relIndex_ne_zero_of_transOK hn hk hA hB hD)⟩⟩⟩ + + end transversal + +diff --git a/OrbicurveCores/Takeuchi.lean b/OrbicurveCores/Takeuchi.lean +index 26c95a85ade249e67e71a93989b9463c922e218b..46ae78db9677953849e05966b17341ed8b24e864 100644 +--- a/OrbicurveCores/Takeuchi.lean ++++ b/OrbicurveCores/Takeuchi.lean +@@ -287,7 +287,8 @@ power of `T = [[1, 1], [0, 1]]`), in particular one with `γ⁴ ≠ 1`. -/ + lemma IsArithmeticSL.exists_pow_four_ne_one {Γ : Subgroup SL(2, ℝ)} (hΓ : IsArithmeticSL Γ) : + ∃ γ ∈ Γ, γ ^ 4 ≠ 1 := by + obtain ⟨g, hΓ'⟩ := hΓ +- obtain ⟨n, hn, -, hmem⟩ := exists_pow_mem_of_relIndex_ne_zero hΓ'.is_commensurable.1 ++ obtain ⟨n, hn, -, hmem⟩ := exists_pow_mem_of_relIndex_ne_zero ++ hΓ'.is_commensurable.1.relIndex_ne_zero + (⟨ModularGroup.T, rfl⟩ : mapGL ℝ ModularGroup.T ∈ 𝒮ℒ) + have h := (Subgroup.mem_inf.mp hmem).1 + rw [mem_pointwise_smul_iff_inv_smul_mem] at h +diff --git a/OrbicurveCores/U2/Assembly.lean b/OrbicurveCores/U2/Assembly.lean +index aba3d4e66450e6859f89fd1acd39a4f318244598..306edf8acd3ee21ece5a7c115ea0017b7eccfa84 100644 +--- a/OrbicurveCores/U2/Assembly.lean ++++ b/OrbicurveCores/U2/Assembly.lean +@@ -303,7 +303,7 @@ theorem toHemi_etale_aux (w : Ideal (puncturedRing E)) (hw : w.IsMaximal) : + w.ramificationIdx ℂ[X] = (hemi E).mult (w.comap (algebraMap ℂ[X] (puncturedRing E))) := by + haveI := hw + have hv : (w.comap (algebraMap ℂ[X] (puncturedRing E))).IsMaximal := +- Ideal.isMaximal_comap_of_isIntegral_of_isMaximal (R := ℂ[X]) w ++ Ideal.isMaximal_under_of_isIntegral_of_isMaximal (R := ℂ[X]) w + obtain ⟨c, hc⟩ := exists_eq_ker_aeval (w.comap (algebraMap ℂ[X] (puncturedRing E))) + have hlies : w ∈ (RingHom.ker (aeval c : ℂ[X] →ₐ[ℂ] ℂ)).primesOver (puncturedRing E) := + ⟨hw.isPrime, ⟨hc.symm⟩⟩ +@@ -361,7 +361,8 @@ theorem hom_hemi_f_X (hj : ∀ c ∈ excJ, E.j ≠ (c : ℂ)) {Y Z : AffOrbicurv + have hpC : p = C (p.coeff 0) := eq_C_of_natDegree_le_zero h0 + have := H.injective (a₁ := X - C (p.coeff 0)) (a₂ := 0) (by + change aeval (R := ℂ) p (X - C (p.coeff 0)) = aeval (R := ℂ) p 0 +- rw [map_sub, aeval_X, aeval_C, map_zero, algebraMap_eq, ← hpC, sub_self]) ++ rw [map_sub, aeval_X, aeval_C, map_zero (aeval (R := ℂ) p), algebraMap_eq, ← hpC, ++ sub_self]) + exact X_sub_C_ne_zero _ this + have hcond : ∀ w : ℂ, Uniformization.RatFuncPoly.ramIdx p w * + Uniformization.RatFuncPoly.mult (E₂ E) w = +diff --git a/OrbicurveCores/U2/CoreMap.lean b/OrbicurveCores/U2/CoreMap.lean +index 29feb2b8eba4b63afbeabc96bc3841473dc1dc81..5b4ab0325344fd50eca74764c05c4b5570fb4411 100644 +--- a/OrbicurveCores/U2/CoreMap.lean ++++ b/OrbicurveCores/U2/CoreMap.lean +@@ -138,7 +138,8 @@ theorem theoremG (hj : ∀ c ∈ excJ, E.j ≠ (c : ℂ)) {Y Z : AffOrbicurve + intro w hw + letI := algRing tΩ hLM + haveI : Algebra.IsIntegral (coordRing ℂ tΩ L) B := ⟨ringMap_isIntegral tΩ hLM⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal (R := coordRing ℂ tΩ L) w ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap tΩ hLM).toRingHom (ringMap_isIntegral tΩ hLM) w + have hmaxZ : ∀ w : Ideal (coordRing ℂ tΩ L), w.IsMaximal → + (w.comap ψZ.toRingEquiv.toRingHom).IsMaximal := fun w hw ↦ + Ideal.comap_isMaximal_of_surjective _ ψZ.surjective +diff --git a/OrbicurveCores/U2/GaloisClosure.lean b/OrbicurveCores/U2/GaloisClosure.lean +index cb16f5db6a239c8df9159254e0f67e80bdeae42d..a3ef69922a9718d5c3e9980b907f6e349a223e7c 100644 +--- a/OrbicurveCores/U2/GaloisClosure.lean ++++ b/OrbicurveCores/U2/GaloisClosure.lean +@@ -213,11 +213,13 @@ theorem ramificationIdx_closure_eq_one (ht : Transcendental k t) (hFL : F ≤ L) + letI := algRing t hLN + haveI : Algebra.IsIntegral (coordRing k t L) (coordRing k t N) := + ⟨ringMap_isIntegral t hLN⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal u' ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t hLN).toRingHom (ringMap_isIntegral t hLN) u' + haveI : (u.comap (ringMap t hLN)).IsMaximal := by + letI := algRing t hLN + haveI : Algebra.IsIntegral (coordRing k t L) (coordRing k t N) := ⟨ringMap_isIntegral t hLN⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal u ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t hLN).toRingHom (ringMap_isIntegral t hLN) u + rw [hm _ inferInstance, hm _ inferInstance, hcomap, hcomap, hover] + have E1 := ramificationIdx_mul_card t ht hFL hLN u + have E1' := ramificationIdx_mul_card t ht hFL hLN u' +@@ -316,9 +318,9 @@ theorem isIntegral_smul_toN (σ : N ≃ₐ[K₀ k t] N) (b : coordRing k t (clos + have h1 := isIntegral_of_mem_coordRing t b + haveI : IsScalarTower (A₀ k t) N Ω := IsScalarTower.of_algebraMap_eq fun _ => rfl + have h2 : IsIntegral (A₀ k t) (toN t b) := +- (isIntegral_algebraMap_iff (A := N) (B := Ω) (algebraMap N Ω).injective).mp h1 ++ (isIntegral_algebraMap_iff (A := N) (B := Ω)).mp h1 + have h3 := h2.map ((σ : N →ₐ[K₀ k t] N).restrictScalars (A₀ k t)) +- exact (isIntegral_algebraMap_iff (A := N) (B := Ω) (algebraMap N Ω).injective).mpr h3 ++ exact (isIntegral_algebraMap_iff (A := N) (B := Ω)).mpr h3 + + theorem toN_injective : Function.Injective (toN t (F := F) (L := L) (N := N)) := by + intro a b h +diff --git a/OrbicurveCores/U2/Noether.lean b/OrbicurveCores/U2/Noether.lean +index c775bc4196f4848ef28c3f7cb6c38774ea973ed1..79ee9a4f2dc7186f8427467bd6b4797daf5a3b46 100644 +--- a/OrbicurveCores/U2/Noether.lean ++++ b/OrbicurveCores/U2/Noether.lean +@@ -99,7 +99,10 @@ theorem exists_transcendental_isIntegral (hA : ¬ IsField A) : + have hP₁0 : P₁ ≠ ⊥ := by + intro h0 + apply MvPolynomial.X_ne_zero (R := k) i0 +- have : MvPolynomial.X i0 ∈ Ideal.comap (algebraMap R A) P₁ := hP₁q ▸ hX0 ++ have : MvPolynomial.X i0 ∈ Ideal.comap (algebraMap R A) P₁ := by ++ change MvPolynomial.X i0 ∈ P₁.under R ++ rw [hP₁q] ++ exact hX0 + rw [h0, Ideal.mem_comap, Ideal.mem_bot, hmap] at this + exact hinj (this.trans (map_zero g).symm) + have hmax : P₁.IsMaximal := hP₁.isMaximal hP₁0 +diff --git a/OrbicurveCores/U2/R3.lean b/OrbicurveCores/U2/R3.lean +index a3b8ce873bbd66079505f67a3663c5193d4c7929..4fc66ed0f4fe09c5735dc64b5f96565b8d01af75 100644 +--- a/OrbicurveCores/U2/R3.lean ++++ b/OrbicurveCores/U2/R3.lean +@@ -38,8 +38,11 @@ variable {G : Type*} [Group G] + lemma commensurator_smul (g : G) (H : Subgroup G) : + commensurator (ConjAct.toConjAct g • H) = ConjAct.toConjAct g • commensurator H := by + ext x +- rw [Subgroup.mem_pointwise_smul_iff_inv_smul_mem, commensurator_mem_iff, commensurator_mem_iff, +- commensurable_conj (ConjAct.toConjAct g)⁻¹, inv_smul_smul] ++ rw [Subgroup.mem_pointwise_smul_iff_inv_smul_mem, commensurator_mem_iff, commensurator_mem_iff] ++ change (ConjAct.toConjAct x • ConjAct.toConjAct g • H).Commensurable ++ (ConjAct.toConjAct g • H) ↔ ++ (ConjAct.toConjAct ((ConjAct.toConjAct g)⁻¹ • x) • H).Commensurable H ++ rw [← Subgroup.Commensurable.smul_iff (φ := (ConjAct.toConjAct g)⁻¹), inv_smul_smul] + have e : (ConjAct.toConjAct g)⁻¹ • x = g⁻¹ * x * g := by + rw [ConjAct.smul_def, map_inv, ConjAct.ofConjAct_toConjAct, inv_inv] + rw [e, map_mul, map_mul, map_inv, mul_smul, mul_smul] +@@ -47,8 +50,11 @@ lemma commensurator_smul (g : G) (H : Subgroup G) : + lemma relIndex_commensurator_of_le {H K : Subgroup G} (hHK : H ≤ K) (hi : H.relIndex K ≠ 0) + (h : H.relIndex (commensurator H) ≠ 0) : K.relIndex (commensurator K) ≠ 0 := by + have hc : Subgroup.Commensurable H K := by +- refine ⟨?_, ?_⟩ <;> +- first | exact hi | (rw [Subgroup.relIndex_eq_one.mpr hHK]; exact one_ne_zero) ++ constructor ++ · exact Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr hi ++ · apply Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr ++ rw [Subgroup.relIndex_eq_one.mpr hHK] ++ exact one_ne_zero + rw [← eq hc] + exact fun h0 ↦ h (Nat.eq_zero_of_zero_dvd (h0 ▸ Subgroup.relIndex_dvd_of_le_left _ hHK)) + +@@ -166,10 +172,13 @@ theorem r3 {A B : SL(2, ℝ)} {π : ℂ → ℂ × ℂ} (hπ : IsUniformization + intro δ hδ z + -- `g δ g⁻¹ ∈ Comm Γ = Comm Γ̃ = Γ̃` + have hcommP : commensurator (Subgroup.closure {A, B}) = commensurator P := by +- refine eq ⟨?_, ?_⟩ <;> +- first | exact relIndex_closure_pmGroup_ne_zero A B | +- (rw [Subgroup.relIndex_eq_one.mpr (IsUniformization.closure_le_pmGroup A B)]; +- exact one_ne_zero) ++ apply eq ++ constructor ++ · exact Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr ++ (relIndex_closure_pmGroup_ne_zero A B) ++ · apply Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr ++ rw [Subgroup.relIndex_eq_one.mpr (IsUniformization.closure_le_pmGroup A B)] ++ exact one_ne_zero + have hmem : g * δ * g⁻¹ ∈ U.pmDeck := by + rw [← hR, U.commensurator_pmDeck, hD, commensurator_smul, + Subgroup.mem_smul_pointwise_iff_exists] +diff --git a/OrbicurveCores/U2/Realize.lean b/OrbicurveCores/U2/Realize.lean +index 9f6e1525c8541a53cf902094f3627a11ae11d182..b1847524a44797940a7343e209a5d991756211a7 100644 +--- a/OrbicurveCores/U2/Realize.lean ++++ b/OrbicurveCores/U2/Realize.lean +@@ -53,7 +53,7 @@ theorem bijective_algebraMap_bot : + have h1 := isIntegral_of_mem_coordRing tΩ b + rw [← hz] at h1 + haveI : IsScalarTower (A₀ ℂ tΩ) (K₀ ℂ tΩ) Ωt := IsScalarTower.of_algebraMap_eq fun _ => rfl +- exact (isIntegral_algebraMap_iff (algebraMap (K₀ ℂ tΩ) Ωt).injective).mp h1 ++ exact isIntegral_algebraMap_iff.mp h1 + obtain ⟨a, ha⟩ := (IsIntegrallyClosed.isIntegral_iff (R := A₀ ℂ tΩ) (K := K₀ ℂ tΩ)).mp hzint + refine ⟨a, Subtype.ext (Subtype.ext ?_)⟩ + rw [← hz, ← ha] +diff --git a/OrbicurveCores/U2/TheoremG.lean b/OrbicurveCores/U2/TheoremG.lean +index df55e79122374a4286211abdb9d73e8f46974e4d..6ab2f68a70e9d68b91847d911ade083f094d0d36 100644 +--- a/OrbicurveCores/U2/TheoremG.lean ++++ b/OrbicurveCores/U2/TheoremG.lean +@@ -100,7 +100,9 @@ theorem mobius_mem_commensurator [W.IsElliptic] (h : IsUniformization W G₁ G + intro τ b + rw [mul_smul, mul_smul, hg', hδ, ← hg, AlgEquiv.apply_symm_apply] + have hgS : g ∈ Subgroup.Commensurable.commensurator S := by +- rw [Subgroup.Commensurable.commensurator_mem_iff, hconj] ++ rw [Subgroup.Commensurable.commensurator_mem_iff] ++ change (ConjAct.toConjAct g • S).Commensurable S ++ rw [hconj] + -- `Γ`-invariance of `ι₀` + have hΓ : ∀ γ ∈ Γ, ∀ (a : A) (τ : ℍ), ι₀ a (γ • τ) = ι₀ a τ := by + intro γ hγ a τ +@@ -147,7 +149,9 @@ theorem mobius_mem_commensurator [W.IsElliptic] (h : IsUniformization W G₁ G + exact Subgroup.index_ne_zero_of_finite + have hΓS : Γ.relIndex S ≠ 0 := fun h0 ↦ + relIndex_closure_pmGroup_ne_zero G₁ G₂ (Subgroup.relIndex_eq_zero_of_le_right hSpm h0) +- have hcomm : Subgroup.Commensurable S Γ := ⟨hSΓ, hΓS⟩ ++ have hcomm : Subgroup.Commensurable S Γ := ++ ⟨Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr hSΓ, ++ Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero.mpr hΓS⟩ + rwa [← Subgroup.Commensurable.eq hcomm] + + end Commensurator +diff --git a/lake-manifest.json b/lake-manifest.json +index 6f40b5794c7780f797aa603a89b70a2304f2ca0e..9f8e5f69b8288de7b36c38564cb680d224db498f 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -15,37 +15,37 @@ + "type": "git", + "subDir": null, + "scope": "", +- "rev": "e0266a572e2ef7c144227c2703c450e466984528", ++ "rev": "ca7def953193f861a462aa0831eec8f0a31ff69f", + "name": "pi1", + "manifestFile": "lake-manifest.json", +- "inputRev": "e0266a572e2ef7c144227c2703c450e466984528", ++ "inputRev": "ca7def953193f861a462aa0831eec8f0a31ff69f", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/mathlib4", ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/lana-agents/heights.git", + "type": "git", + "subDir": null, + "scope": "", +- "rev": "3539e2a12dd3470c057a4eb531dc3fd627d4c97b", ++ "rev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", + "name": "heights", + "manifestFile": "lake-manifest.json", +- "inputRev": "3539e2a12dd3470c057a4eb531dc3fd627d4c97b", ++ "inputRev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -65,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -75,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -85,7 +85,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -95,7 +95,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -105,20 +105,30 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, ++ {"url": "https://github.com/lana-agents/belyi.git", ++ "type": "git", ++ "subDir": null, ++ "scope": "", ++ "rev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "name": "belyi", ++ "manifestFile": "lake-manifest.json", ++ "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8", ++ "inherited": true, ++ "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "«orbicurve-cores»", +diff --git a/lakefile.toml b/lakefile.toml +index 54266d79c4524636ec1eb9099976f85816fe20af..af2e31383dbd51980ef00ad33ccb069254a4e3a7 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["OrbicurveCores"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -11,8 +13,8 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "OrbicurveCores" +@@ -20,10 +22,10 @@ name = "OrbicurveCores" + [[require]] + name = "pi1" + git = "https://github.com/lana-agents/pi1.git" +-rev = "e0266a572e2ef7c144227c2703c450e466984528" ++rev = "ca7def953193f861a462aa0831eec8f0a31ff69f" + + # Uniformisation of once-punctured elliptic curves (U1): `Uniformization.uniformization_oncePunctured`. +-# `oka` pins `lana-agents/heights` at 3539e2a; this is the only `heights` revision in this project. ++# The patched `oka` package uses `heights` at 721496ca, shared with the IUT dependency graph. + [[require]] + name = "oka" + git = "https://github.com/lana-agents/oka.git" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/pi1-lean4341.patch b/lean/patches/pi1-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..736ef7b5d82a19e114fe8e3f535d63ee9cf89e60 --- /dev/null +++ b/lean/patches/pi1-lean4341.patch @@ -0,0 +1,418 @@ +diff --git a/Pi1/FundamentalGroup/Galois.lean b/Pi1/FundamentalGroup/Galois.lean +index a2c4ab3051407e7c32f0e383f2490e0e8ff9c9fc..9eac7f2196a24cc78ef1cf86c36e14067de3a6ce 100644 +--- a/Pi1/FundamentalGroup/Galois.lean ++++ b/Pi1/FundamentalGroup/Galois.lean +@@ -610,7 +610,7 @@ instance galoisCategory [ConnectedSpace X] : GaloisCategory (FiniteEtale X) wher + let Ω : Type u := AlgebraicClosure k + let ξ : Spec (.of Ω) ⟶ X := + Spec.map (CommRingCat.ofHom <| algebraMap k Ω) ≫ X.fromSpecResidueField x +- exact ⟨fiber ξ, ⟨inferInstance⟩⟩ ++ exact ⟨fiber ξ, inferInstance⟩ + + /-- The étale fundamental group of a connected scheme `X` at the geometric point `ξ` is + the automorphism group of the fiber functor at `ξ`. -/ +diff --git a/Pi1/Mathlib/RingTheory/Geometric.lean b/Pi1/Mathlib/RingTheory/Geometric.lean +index 508409f0ad5c389ea2f281277c3d23a26112a5e1..334e49ce6706a1bd3e6957dd93c9bb89ad0a33aa 100644 +--- a/Pi1/Mathlib/RingTheory/Geometric.lean ++++ b/Pi1/Mathlib/RingTheory/Geometric.lean +@@ -37,8 +37,7 @@ lemma Algebra.TensorProduct.exists_intermediateField_isSeparable_and_mem_range + ∃ (K : IntermediateField k Ω), Algebra.IsSeparable k K ∧ Module.Finite k K ∧ + x ∈ Set.range + (Algebra.TensorProduct.map (IsScalarTower.toAlgHom k K Ω) (AlgHom.id k R)) := by +- induction x with +- | zero => exact ⟨⊥, inferInstance, inferInstance, 0, by simp⟩ ++ induction x using TensorProduct.inductionOn with + | add x y hx hy => + obtain ⟨K, hK₁, hK₂, ⟨x, rfl⟩⟩ := hx + obtain ⟨L, hL₁, hL₂, ⟨y, rfl⟩⟩ := hy +diff --git a/Pi1/Mathlib/RingTheory/TensorProduct/Basic.lean b/Pi1/Mathlib/RingTheory/TensorProduct/Basic.lean +index 5ce0f465a46056184814f3f8659a071e1d9f3479..8e0d9e5862786f9212862e26ec8a0327384f351d 100644 +--- a/Pi1/Mathlib/RingTheory/TensorProduct/Basic.lean ++++ b/Pi1/Mathlib/RingTheory/TensorProduct/Basic.lean +@@ -12,8 +12,7 @@ noncomputable def Algebra.TensorProduct.comm' {R S T : Type*} [CommRing R] + S ⊗[R] T ≃ₗ[S] T ⊗[R] S := + (_root_.TensorProduct.comm ..).toAddEquiv.toLinearEquiv <| by + intro c x +- induction x with +- | zero => simp ++ induction x using TensorProduct.inductionOn with + | add x y hx hy => + simp only [LinearEquiv.coe_toAddEquiv, LinearEquiv.coe_addEquiv_apply] at hx hy + simp [hx, hy] +diff --git a/Pi1/Orbicurve/BaseChange.lean b/Pi1/Orbicurve/BaseChange.lean +index 090ba0a7bd9ece77432f149024b04a0d97ae7b6b..70fdb5887ae555de87ccd0f44cfb88f8d4c60564 100644 +--- a/Pi1/Orbicurve/BaseChange.lean ++++ b/Pi1/Orbicurve/BaseChange.lean +@@ -662,8 +662,7 @@ theorem mem_K₀_of_isAlgebraic (htK : Transcendental K t) {x : Ω} (hx : x ∈ + obtain ⟨P, hP⟩ : ∃ P : K[X], aeval t P = g := by + have h1 : IsIntegral (A₀ K t) (⟨g, hgK⟩ : K₀ K t) := by + haveI : IsScalarTower (A₀ K t) (K₀ K t) Ω := IsScalarTower.of_algebraMap_eq fun _ => rfl +- exact (isIntegral_algebraMap_iff (algebraMap (K₀ K t) Ω).injective).mp +- (isIntegral_A₀_of t hgint) ++ exact isIntegral_algebraMap_iff.mp (isIntegral_A₀_of t hgint) + obtain ⟨a, ha⟩ := (IsIntegrallyClosed.isIntegral_iff (R := A₀ K t) (K := K₀ K t)).mp h1 + refine ⟨eK.symm a, ?_⟩ + rw [← coe_algEquivOfTranscendental htK, AlgEquiv.apply_symm_apply] +@@ -871,7 +870,8 @@ theorem ramificationIdx_bc (htK : Transcendental K t) + haveI hum : u.IsMaximal := Ideal.IsPrime.isMaximal inferInstance hune + refine ⟨?_, ?_⟩ + · rw [hwu] +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal' _ (ringMap_isIntegral t _) u ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t hF₂N).toRingHom (ringMap_isIntegral t hF₂N) u + · have hmc := ramificationIdx_mul_card t htk h hF₂N u + rw [← hwu] at hmc + have c1 := card_inertia_inf_fixSub hNN' htK (le_of_eq hN') (h.trans hF₂N) h₁ h₁' u' hune +@@ -954,7 +954,8 @@ theorem exists_comap_bc_eq [IsAlgClosed k] (htK : Transcendental K t) + letI := algRing t hbotN + haveI : Algebra.IsIntegral (coordRing k t (⊥ : IntermediateField (K₀ k t) Ω)) + (coordRing k t N) := ⟨ringMap_isIntegral t _⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal u ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t hbotN).toRingHom (ringMap_isIntegral t hbotN) u + set ek := coordRingBotEquiv (Ω := Ω) htk + set eK := coordRingBotEquiv (Ω := Ω) htK + set P : Ideal k[X] := p.comap ek.toRingEquiv.toRingHom +@@ -1028,7 +1029,8 @@ theorem exists_comap_bc_eq [IsAlgClosed k] (htK : Transcendental K t) + ← bcMap_smul] + exact Iff.rfl + refine ⟨u'.comap (ringMap t hF'N'), +- Ideal.isMaximal_comap_of_isIntegral_of_isMaximal' _ (ringMap_isIntegral t _) u', ?_⟩ ++ Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t hF'N').toRingHom (ringMap_isIntegral t hF'N') u', ?_⟩ + rw [← huw, ← hu'u] + ext x + exact Iff.rfl +diff --git a/Pi1/Orbicurve/CoreCriterion.lean b/Pi1/Orbicurve/CoreCriterion.lean +index f3abee6eff68fe5d793cd80047d547c57863272a..3acb520602d01e1d875e8f9ff8991245aa225db5 100644 +--- a/Pi1/Orbicurve/CoreCriterion.lean ++++ b/Pi1/Orbicurve/CoreCriterion.lean +@@ -87,7 +87,10 @@ lemma le_one_of_integral_mvPolynomial {R : Type*} [CommRing R] [IsDomain R] [Alg + exact zero_mem _ + haveI : (⊥ : Ideal R).IsPrime := Ideal.isPrime_bot + obtain ⟨Q1, -, hQ1, hQ1c⟩ := Ideal.exists_ideal_over_prime_of_isIntegral_of_isPrime p1 ⊥ hbot +- have hQ1c' : Q1.comap (algebraMap (MvPolynomial (Fin s) k) R) ≤ p2 := hQ1c ▸ hp12 ++ have hQ1c' : Q1.comap (algebraMap (MvPolynomial (Fin s) k) R) ≤ p2 := by ++ change Q1.under (MvPolynomial (Fin s) k) ≤ p2 ++ rw [hQ1c] ++ exact hp12 + obtain ⟨Q2, hQ12, hQ2, hQ2c⟩ := Ideal.exists_ideal_over_prime_of_isIntegral_of_isPrime p2 Q1 hQ1c' + have hQ1ne : Q1 ≠ ⊥ := by + rintro rfl +@@ -150,11 +153,10 @@ lemma bijective_algebraMap_coordRing_bot : + IsScalarTower.of_algebraMap_eq fun _ => rfl + have := b.2 + rw [mem_integralClosure_iff] at this +- exact (isIntegral_algebraMap_iff (A := (⊥ : IntermediateField (K₀ k t) Ω)) (B := Ω) +- (algebraMap (⊥ : IntermediateField (K₀ k t) Ω) Ω).injective).mpr this ++ exact (isIntegral_algebraMap_iff (A := (⊥ : IntermediateField (K₀ k t) Ω)) (B := Ω)).mpr this + rw [← hz] at h1 + haveI : IsScalarTower (A₀ k t) (K₀ k t) Ω := IsScalarTower.of_algebraMap_eq fun _ => rfl +- exact (isIntegral_algebraMap_iff (algebraMap (K₀ k t) Ω).injective).mp h1 ++ exact isIntegral_algebraMap_iff.mp h1 + obtain ⟨a, ha⟩ := (IsIntegrallyClosed.isIntegral_iff (R := A₀ k t) (K := K₀ k t)).mp hzint + refine ⟨a, Subtype.ext (Subtype.ext ?_)⟩ + rw [← hz, ← ha] +diff --git a/Pi1/Orbicurve/Descent.lean b/Pi1/Orbicurve/Descent.lean +index cc144f5107305081c45a2ab530aa2c977feaf399..441506695c68758cd178a77c46fcfad3f6f87e3d 100644 +--- a/Pi1/Orbicurve/Descent.lean ++++ b/Pi1/Orbicurve/Descent.lean +@@ -162,7 +162,7 @@ theorem isIntegral_A₀_of_bc [IsAlgClosed k] (htK : Transcendental K t) {x : Ω + haveI := isPrincipalIdealRing_A₀ htK + have h1 : IsIntegral (A₀ K t) (⟨_, hK⟩ : K₀ K t) := by + haveI : IsScalarTower (A₀ K t) (K₀ K t) Ω := IsScalarTower.of_algebraMap_eq fun _ => rfl +- exact (isIntegral_algebraMap_iff (algebraMap (K₀ K t) Ω).injective).mp hR ++ exact isIntegral_algebraMap_iff.mp hR + obtain ⟨a, ha⟩ := (IsIntegrallyClosed.isIntegral_iff (R := A₀ K t) (K := K₀ K t)).mp h1 + have hA : ((p.coeff i : K₀ k t) : Ω) ∈ A₀ K t := by + rw [← congrArg Subtype.val ha]; exact a.2 +diff --git a/Pi1/Orbicurve/EllipticSubfield.lean b/Pi1/Orbicurve/EllipticSubfield.lean +index bd714eb726fcb5b45f2ddebd2b9f4f0649373075..0f89de5c7e5d2cfe82e5cf3691fb1d3d9a86e2c5 100644 +--- a/Pi1/Orbicurve/EllipticSubfield.lean ++++ b/Pi1/Orbicurve/EllipticSubfield.lean +@@ -290,7 +290,9 @@ lemma multE_eq (w : Ideal (coordRing k (tE j) (fnFieldE j))) [hw : w.IsMaximal] + letI iR := algRing (tE j) (bot_le_fnFieldE j) + haveI : Algebra.IsIntegral (coordRing k (tE j) (⊥ : IntermediateField (K₀ k (tE j)) Ω)) + (coordRing k (tE j) (fnFieldE j)) := ⟨ringMap_isIntegral _ _⟩ +- haveI hv : v.IsMaximal := Ideal.isMaximal_comap_of_isIntegral_of_isMaximal w ++ haveI hv : v.IsMaximal := Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap (tE j) (bot_le_fnFieldE j)).toRingHom ++ (ringMap_isIntegral (tE j) (bot_le_fnFieldE j)) w + have hex : ∃ P : Ideal (coordRing k (tE j) (fnFieldE j)), P.IsPrime ∧ P.LiesOver v := + ⟨w, hw.isPrime, ⟨rfl⟩⟩ + unfold multE +diff --git a/Pi1/Orbicurve/Embed.lean b/Pi1/Orbicurve/Embed.lean +index 2ecb512486f83f0bcb61cf889da57aa497b42d2b..dd4cf874658c96a8958dd4c5230a07df02544d07 100644 +--- a/Pi1/Orbicurve/Embed.lean ++++ b/Pi1/Orbicurve/Embed.lean +@@ -47,7 +47,7 @@ lemma mem_coordRing_of_isIntegral {L : IntermediateField (K₀ k t) Ω} {x : Ω} + (h : IsIntegral (A₀ k t) x) : (⟨x, hx⟩ : L) ∈ coordRing k t L := by + haveI : IsScalarTower (A₀ k t) L Ω := IsScalarTower.of_algebraMap_eq fun _ => rfl + rw [mem_integralClosure_iff] +- exact (isIntegral_algebraMap_iff (A := L) (B := Ω) (algebraMap L Ω).injective).mp h ++ exact (isIntegral_algebraMap_iff (A := L) (B := Ω)).mp h + + omit [IsAlgClosed Ω] [FiniteDimensional (K₀ k t) B] in + lemma isIntegral_of_mem_coordRing {L : IntermediateField (K₀ k t) Ω} +@@ -55,7 +55,7 @@ lemma isIntegral_of_mem_coordRing {L : IntermediateField (K₀ k t) Ω} + haveI : IsScalarTower (A₀ k t) L Ω := IsScalarTower.of_algebraMap_eq fun _ => rfl + have := x.2 + rw [mem_integralClosure_iff] at this +- exact (isIntegral_algebraMap_iff (A := L) (B := Ω) (algebraMap L Ω).injective).mpr this ++ exact (isIntegral_algebraMap_iff (A := L) (B := Ω)).mpr this + + set_option maxHeartbeats 1000000 in + theorem exists_algEquiv_coordRing (g : coordRing k t B →ₐ[k] Z) (hg : Function.Injective g) +diff --git a/Pi1/Orbicurve/HemiTY.lean b/Pi1/Orbicurve/HemiTY.lean +index 8d0bcd5489998284c34d9df61cb0111351673942..72f5f321a530b773de7272af239e41dc17b4705b 100644 +--- a/Pi1/Orbicurve/HemiTY.lean ++++ b/Pi1/Orbicurve/HemiTY.lean +@@ -162,7 +162,8 @@ lemma multTY_eq (w : Ideal (coordRing F t (fnTY F t y))) [hw : w.IsMaximal] : + letI iR := algRing t hle + haveI : Algebra.IsIntegral (coordRing F t (⊥ : IntermediateField (K₀ F t) Ω)) + (coordRing F t (fnTY F t y)) := ⟨ringMap_isIntegral _ _⟩ +- haveI hv : v.IsMaximal := Ideal.isMaximal_comap_of_isIntegral_of_isMaximal w ++ haveI hv : v.IsMaximal := Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t hle).toRingHom (ringMap_isIntegral t hle) w + have hex : ∃ P : Ideal (coordRing F t (fnTY F t y)), P.IsPrime ∧ P.LiesOver v := + ⟨w, hw.isPrime, ⟨rfl⟩⟩ + unfold multTY +diff --git a/Pi1/Orbicurve/Lefschetz.lean b/Pi1/Orbicurve/Lefschetz.lean +index 4c16c738ccab27bf389bd2a04fd6c9cb85335eae..aecad2b4d42fe8de49372021ccacad5c5f3b7306 100644 +--- a/Pi1/Orbicurve/Lefschetz.lean ++++ b/Pi1/Orbicurve/Lefschetz.lean +@@ -162,7 +162,8 @@ theorem etale_bc + letI := algRing t h' + haveI : Algebra.IsIntegral (coordRing K t F₁') (coordRing K t F₂') := + ⟨ringMap_isIntegral t _⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal w' ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t h').toRingHom (ringMap_isIntegral t h') w' + by_cases hw : w = ⊥ + · rw [hbot hw, one_mul, hm₂ w' hw' hw, hm₁ _ inferInstance (by + rw [hv, hw]; exact Ideal.comap_bot_of_injective _ (ringMap_injective t h))] +@@ -199,7 +200,8 @@ theorem etale_of_bc [IsAlgClosed k] + letI := algRing t h' + haveI : Algebra.IsIntegral (coordRing K t F₁') (coordRing K t F₂') := + ⟨ringMap_isIntegral t _⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal w' ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t h').toRingHom (ringMap_isIntegral t h') w' + have hv0 : w.comap (ringMap t h) ≠ ⊥ := by + letI := algRing t h + haveI : Algebra.IsIntegral (coordRing k t F₁) (coordRing k t F₂) := +@@ -295,8 +297,9 @@ lemma coe_coordRingRangeEquiv {u : Ω} (L : IntermediateField (K₀ k u) Ω) (a + over `k[t]` and `t` over `k[s]`. -/ + noncomputable def rebaseEquiv (hst : IsIntegral (A₀ k t) s) (hts : IsIntegral (A₀ k s) t) : + coordRing k t F ≃+* coordRing k s (rebase F hs) := +- (coordRingRangeEquiv F).trans ((RingEquiv.subringCongr (range_coordRingVal_rebase hst hts)).trans +- (coordRingRangeEquiv (rebase F hs)).symm) ++ (coordRingRangeEquiv F).trans ((RingEquiv.subringCongr ++ (range_coordRingVal_rebase (F := F) (hs := hs) hst hts)).trans ++ (coordRingRangeEquiv (rebase F hs)).symm) + + lemma coordRingVal_rebaseEquiv (hst : IsIntegral (A₀ k t) s) (hts : IsIntegral (A₀ k s) t) + (a : coordRing k t F) : +diff --git a/Pi1/Orbicurve/Morphisms.lean b/Pi1/Orbicurve/Morphisms.lean +index 3acbb75d5d6f01f5f792e046904553b44a21bc6a..e56607fcfb6e87a1dbb76e3d8c92f6d1d5142cbf 100644 +--- a/Pi1/Orbicurve/Morphisms.lean ++++ b/Pi1/Orbicurve/Morphisms.lean +@@ -65,9 +65,7 @@ def Hom.comp {Z Y C : AffOrbicurve k} (φ : Hom Z Y) (ψ : Hom Y C) : Hom Z C wh + etale w hw := by + have h1 := ramificationIdx_comp ψ.f.toRingHom φ.f.toRingHom φ.injective w + have hq : (w.comap φ.f).IsMaximal := by +- letI := φ.f.toRingHom.toAlgebra +- haveI : Algebra.IsIntegral Y.A Z.A := ⟨φ.isIntegral⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal w ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal φ.f.toRingHom φ.isIntegral w + rw [show (φ.f.comp ψ.f).toRingHom = φ.f.toRingHom.comp ψ.f.toRingHom from rfl, h1, mul_assoc, + φ.etale w hw] + exact ψ.etale _ hq +diff --git a/Pi1/Orbicurve/Pullback.lean b/Pi1/Orbicurve/Pullback.lean +index b44d8bfacd13e025fbfca01c9825b1670a30f1d6..65649013234a4e1a00a57d4e30524f55cb954d3b 100644 +--- a/Pi1/Orbicurve/Pullback.lean ++++ b/Pi1/Orbicurve/Pullback.lean +@@ -259,9 +259,8 @@ theorem exists_pullback_subfield {B A Z : IntermediateField (K₀ k t) Ω} + have hmax : ∀ {F F' : IntermediateField (K₀ k t) Ω} (h : F ≤ F') (w : Ideal (coordRing k t F')), + w.IsMaximal → (w.comap (ringMap t h)).IsMaximal := by + intro F F' h w hw +- letI := algRing t h +- haveI : Algebra.IsIntegral (coordRing k t F) (coordRing k t F') := ⟨ringMap_isIntegral t h⟩ +- exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal (R := coordRing k t F) w ++ exact Ideal.isMaximal_comap_of_isIntegral_of_isMaximal ++ (ringMap t h).toRingHom (ringMap_isIntegral t h) w + -- the key divisibility + have hdiv : ∀ w : Ideal (coordRing k t L), w.IsMaximal → + eL w ∣ mB (w.comap (ringMap t hBL)) := by +diff --git a/Pi1/Orbicurve/SubfieldGalois.lean b/Pi1/Orbicurve/SubfieldGalois.lean +index cdf1cd9a59b1babed4ec0f7e6cba5b4dc4ffe77e..4a7f20bb7d45cf270c4af8a0742e6d29fcf8f46d 100644 +--- a/Pi1/Orbicurve/SubfieldGalois.lean ++++ b/Pi1/Orbicurve/SubfieldGalois.lean +@@ -125,6 +125,8 @@ theorem isGaloisGroup_fixSub (ht : Transcendental k t) : + Algebra.IsSeparable.of_algHom (F := K₀ k t) (E := F) (E' := N) (IntermediateField.inclusion hFN) + haveI := isDedekindDomain_ring t ht F + haveI : Algebra.IsIntegral (coordRing k t F) (coordRing k t N) := ⟨ringMap_isIntegral t hFN⟩ ++ have : FaithfulSMul F N := ++ (faithfulSMul_iff_algebraMap_injective F N).mpr (algebraMap F N).injective + haveI hG : IsGaloisGroup (fixSub t N F) F N := by + rw [fixSub_eq_fixingSubgroup_range t hFN] + exact IsGaloisGroup.of_isScalarTower (N ≃ₐ[K₀ k t] N) (K₀ k t) N F +diff --git a/Pi1/Orbicurve/ValuationInertia.lean b/Pi1/Orbicurve/ValuationInertia.lean +index 0ec7ebb8c00870e8772c67b93b3491957fc7a80c..d2f800ca2206762421dd68a3ccae78d6dcfece9f 100644 +--- a/Pi1/Orbicurve/ValuationInertia.lean ++++ b/Pi1/Orbicurve/ValuationInertia.lean +@@ -380,7 +380,7 @@ theorem exists_isInertialOn_restrictNormal_eq [IsGalois (K₀ k t) Ω] (ht : Tra + by rw [fixSub_bot]; trivial⟩ + rw [hr] + exact (mem_inertia_centerIdeal_iff hW M x).mp hx.1 (ringMap t hNM b) +- let f : H →* H' := (r.restrict H).codRestrict H' fun x => hmap x.1 x.2 ++ let f : H →* H' := (r.domRestrict H).codRestrict H' fun x => hmap x.1 x.2 + have hf : Function.Surjective f := by + apply MonoidHom.surjective_of_card_ker_le_div + rw [hcard, Nat.mul_div_cancel_left _ Nat.card_pos] +diff --git a/Pi1/RingTheory/FiniteEtale/Basic.lean b/Pi1/RingTheory/FiniteEtale/Basic.lean +index 5bac8ad46412db0bc8d51fc107aa78a9baae2a3a..665745890a7055fbd133742c1d0ab5a19f1c3294 100644 +--- a/Pi1/RingTheory/FiniteEtale/Basic.lean ++++ b/Pi1/RingTheory/FiniteEtale/Basic.lean +@@ -2,6 +2,7 @@ module + + public import Mathlib.Algebra.Lie.OfAssociative + public import Mathlib.RingTheory.RingHom.Etale ++public import Mathlib.RingTheory.RingHom.Finite + public import Mathlib.RingTheory.TotallySplit + public import Pi1.Mathlib.RingTheory.RingHom.Finite + +diff --git a/Pi1/RingTheory/UnramifiedValuation.lean b/Pi1/RingTheory/UnramifiedValuation.lean +index e3052f76fd99bb8c09ed2c8364190ac6ba3f3e93..59f7901ee950991de6a61672712368b0aa193c7d 100644 +--- a/Pi1/RingTheory/UnramifiedValuation.lean ++++ b/Pi1/RingTheory/UnramifiedValuation.lean +@@ -31,8 +31,7 @@ theorem algHom_eq_of_valuation [FormallyUnramified R B] [EssFiniteType R B] + let F : B ⊗[R] B →ₐ[R] K := Algebra.TensorProduct.lift f g fun _ _ => Commute.all _ _ + have key : ∀ x : B ⊗[R] B, F x ∈ W ∧ W.valuation (F x - f (TensorProduct.lmul' R x)) < 1 := by + intro x +- induction x with +- | zero => simp ++ induction x using TensorProduct.inductionOn with + | tmul a b => + refine ⟨?_, ?_⟩ + · simp only [F, Algebra.TensorProduct.lift_tmul] +diff --git a/lake-manifest.json b/lake-manifest.json +index b559cbefeef96f6d55a8eeb1843117b696d3b13d..10f9c460beb405874e4ad6663b1e9d96aed961ea 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,21 +1,21 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/leanprover-community/mathlib4", ++ [{"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -25,7 +25,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -35,7 +35,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +45,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -65,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -75,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -85,10 +85,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "pi1", +diff --git a/lakefile.toml b/lakefile.toml +index c40e8fb8855e624ac19e0d4228b417b7f6ed8cd8..173ffbb273086f7536c3ff500e6577634f3e5da3 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -16,8 +16,8 @@ backward.defeqAttrib.useBackward = true + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "Pi1" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/rellich-kondrachov-lean4341.patch b/lean/patches/rellich-kondrachov-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..212c832f65e69bad30f91ae888b20d80ae29ac5f --- /dev/null +++ b/lean/patches/rellich-kondrachov-lean4341.patch @@ -0,0 +1,2697 @@ +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/H1.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/H1.lean +index fcec4d8..6fa9227 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/H1.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/H1.lean +@@ -1,3 +1,9 @@ ++/- ++Copyright (c) 2026 Adam Benenson. All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Adam Benenson ++-/ ++ + import Mathlib.Analysis.Calculus.ContDiff.Operations + import Mathlib.Analysis.Calculus.FDeriv.Const + import Mathlib.Analysis.InnerProductSpace.Dual +@@ -5,12 +11,6 @@ import Mathlib.MeasureTheory.Function.LpSpace.Complete + import Mathlib.MeasureTheory.Function.LpSpace.Indicator + import Mathlib.Topology.Algebra.Support + +-/- +-Copyright (c) 2026 Adam Benenson. All rights reserved. +-Released under Apache 2.0 license as described in the file LICENSE. +-Authors: Adam Benenson +--/ +- + /-! + # `RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.H1` + +@@ -55,15 +55,19 @@ section + variable + {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] + +-local instance : MeasurableSpace E := borel E +-local instance : BorelSpace E := ⟨rfl⟩ +-local instance : OpensMeasurableSpace E := by infer_instance ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceH1 : MeasurableSpace E := borel E ++local instance instBorelSpaceH1 : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceH1 : OpensMeasurableSpace E := by infer_instance + + variable (μ : Measure E) [IsFiniteMeasureOnCompacts μ] + +-private abbrev L2ℝ : Type _ := ↥(E →₂[μ] ℝ) +-private abbrev L2E : Type _ := ↥(E →₂[μ] E) +-private abbrev H1Target : Type _ := L2ℝ (μ := μ) × L2E (μ := μ) ++/-- The space of square-integrable real-valued functions. -/ ++abbrev L2ℝ : Type _ := ↥(E →₂[μ] ℝ) ++/-- The space of square-integrable vector-valued functions. -/ ++abbrev L2E : Type _ := ↥(E →₂[μ] E) ++/-- The product space containing a function and its first derivative. -/ ++abbrev H1Target : Type _ := L2ℝ (μ := μ) × L2E (μ := μ) + + /-- `C¹` real-valued functions on `E` with compact support, as a submodule of `E → ℝ`. -/ + def C1c : Submodule ℝ (E → ℝ) where +@@ -78,7 +82,7 @@ def C1c : Submodule ℝ (E → ℝ) where + intro c f hf + refine ⟨hf.1.const_smul c, ?_⟩ + -- `HasCompactSupport` is stable under pointwise scalar multiplication. +- simpa using (HasCompactSupport.smul_left (f := fun _ : E => c) hf.2) ++ exact (HasCompactSupport.smul_left (f := fun _ : E => c) hf.2) + + /-- The pointwise gradient (as an `E`-valued function), via Riesz representation. -/ + noncomputable def grad (f : E → ℝ) : E → E := +@@ -88,21 +92,21 @@ lemma continuous_grad {f : E → ℝ} (hf : ContDiff ℝ 1 f) : Continuous (grad + have hcont : Continuous (fderiv ℝ f) := hf.continuous_fderiv one_ne_zero + have : Continuous fun x => (InnerProductSpace.toDual ℝ E).symm (fderiv ℝ f x) := + (InnerProductSpace.toDual ℝ E).symm.continuous.comp hcont +- simpa [grad] using this ++ exact this + + lemma hasCompactSupport_grad {f : E → ℝ} (hf : HasCompactSupport f) : + HasCompactSupport (grad (E := E) f) := by + -- Outside the support of `f`, `fderiv` is identically `0`, hence so is `grad`. + have hf' : HasCompactSupport (fderiv ℝ f) := hf.fderiv ℝ + -- `grad` is composition with a linear map sending `0` to `0`. +- simpa [grad] using ++ exact + (HasCompactSupport.comp_left (f := fderiv ℝ f) (g := (InnerProductSpace.toDual ℝ E).symm) + hf' (by simp)) + + lemma tsupport_grad_subset (f : E → ℝ) : tsupport (grad (E := E) f) ⊆ tsupport f := by + have hcomp : + tsupport (grad (E := E) f) ⊆ tsupport (fderiv ℝ f) := by +- simpa [grad, Function.comp] using ++ exact + (tsupport_comp_subset + (g := (InnerProductSpace.toDual ℝ E).symm) (hg := by simp) + (f := fderiv ℝ f)) +@@ -165,8 +169,8 @@ private lemma toL2_smul (c : ℝ) (f : ↥(C1c (E := E))) : + /-- Linear map sending `C¹_c` functions to their `L²` classes. -/ + noncomputable def toL2Linear : ↥(C1c (E := E)) →ₗ[ℝ] L2ℝ (μ := μ) where + toFun := toL2 (μ := μ) (E := E) +- map_add' := toL2_add (μ := μ) (E := E) +- map_smul' := toL2_smul (μ := μ) (E := E) ++ map_add' := by exact toL2_add (μ := μ) (E := E) ++ map_smul' := by exact toL2_smul (μ := μ) (E := E) + + private lemma toL2Grad_add (f g : ↥(C1c (E := E))) : + toL2Grad (μ := μ) (E := E) (f + g) = +@@ -226,8 +230,8 @@ private lemma toL2Grad_smul (c : ℝ) (f : ↥(C1c (E := E))) : + /-- Linear map sending `C¹_c` functions to the `L²` class of their gradient. -/ + noncomputable def toL2GradLinear : ↥(C1c (E := E)) →ₗ[ℝ] L2E (μ := μ) where + toFun := toL2Grad (μ := μ) (E := E) +- map_add' := toL2Grad_add (μ := μ) (E := E) +- map_smul' := toL2Grad_smul (μ := μ) (E := E) ++ map_add' := by exact toL2Grad_add (μ := μ) (E := E) ++ map_smul' := by exact toL2Grad_smul (μ := μ) (E := E) + + /-- The graph map `f ↦ (f, ∇f)` into `L² × L²(E)`. -/ + noncomputable def graph : ↥(C1c (E := E)) →ₗ[ℝ] H1Target (μ := μ) := +@@ -243,7 +247,7 @@ theorem isClosed_h1 : IsClosed (h1 (μ := μ) (E := E) : Set (H1Target (μ := μ + exact Submodule.isClosed_topologicalClosure (LinearMap.range (graph (μ := μ) (E := E))) + + /-- `H¹` is complete (a Hilbert space once the ambient `L²` spaces are). -/ +-instance instCompleteSpace_h1 : CompleteSpace (↥(h1 (μ := μ) (E := E))) := by ++instance instCompleteSpaceh1 : CompleteSpace (↥(h1 (μ := μ) (E := E))) := by + classical + exact (isClosed_h1 (μ := μ) (E := E)).isComplete.completeSpace_coe + +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Approximation.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Approximation.lean +index 1ae0860..e44c3dc 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Approximation.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Approximation.lean +@@ -1,3 +1,9 @@ ++/- ++Copyright (c) 2026 Adam Benenson. All rights reserved. ++Released under Apache 2.0 license as described in the file LICENSE. ++Authors: Adam Benenson ++-/ ++ + import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.Translation + import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Smoothing + import Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap +@@ -10,12 +16,6 @@ import Mathlib.MeasureTheory.Measure.Haar.Unique + import Mathlib.MeasureTheory.Function.L2Space + import Mathlib.Probability.Moments.Variance + +-/- +-Copyright (c) 2026 Adam Benenson. All rights reserved. +-Released under Apache 2.0 license as described in the file LICENSE. +-Authors: Adam Benenson +--/ +- + /-! + # `L²` compactness criterion: approximation-by-translation bounds (Euclidean) + +@@ -44,13 +44,14 @@ section Volume + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + +-local instance : MeasurableSpace E := borel E +-local instance : BorelSpace E := ⟨rfl⟩ +-local instance : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceApproximation : MeasurableSpace E := borel E ++local instance instBorelSpaceApproximation : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceApproximation : OpensMeasurableSpace E := by + infer_instance +-local instance : MeasurableAdd E := by ++local instance instMeasurableAddApproximation : MeasurableAdd E := by + infer_instance +-local instance : MeasurableNeg E := by ++local instance instMeasurableNegApproximation : MeasurableNeg E := by + infer_instance + + variable {K : Set E} (hK : IsCompact K) (hKm : MeasurableSet K) +@@ -81,7 +82,9 @@ lemma kernelMeasure_univ (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) ( + -- Conclude using `∫ ψ = 1`. + simpa [hψint] using (hwd.trans hlin) + +-local instance instIsProbabilityMeasure_kernelMeasure ++/-- The kernel measure `kernelMeasure ψ` is a probability measure when `ψ` is a continuous, ++compactly supported, nonnegative density integrating to `1`. -/ ++lemma isProbabilityMeasure_kernelMeasure + (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) + (hψ0 : ∀ x, 0 ≤ ψ x) + (hψint : ∫ x, ψ x ∂(volume : Measure E) = 1) : +@@ -96,7 +99,7 @@ lemma integral_kernelMeasure_eq_integral_smul (hψc : Continuous ψ) (hψ0 : ∀ + (hψc.measurable.ennreal_ofReal : Measurable fun x => ENNReal.ofReal (ψ x)) + have htop : + (MeasureTheory.ae (volume : Measure E)).Eventually +- (fun x => ENNReal.ofReal (ψ x) < ∞) := ++ (fun x => ENNReal.ofReal (ψ x) < (⊤ : ℝ≥0∞)) := + Filter.Eventually.of_forall (fun _ => by simp) + have hwd := + (integral_withDensity_eq_integral_toReal_smul (μ := (volume : Measure E)) +@@ -189,7 +192,7 @@ lemma norm_sq_translateL2_sub_extendByZeroL2_eq_integral_sq (t : E) + MeasureTheory.MeasurePreserving (fun x : E => x - t) + (volume : Measure E) (volume : Measure E) := + MeasureTheory.measurePreserving_sub_right (μ := (volume : Measure E)) t +- simpa [Function.comp] using (hmp.quasiMeasurePreserving.ae_eq_comp hF_ae) ++ exact (hmp.quasiMeasurePreserving.ae_eq_comp hF_ae) + -- TranslateL2 gives `F(x - t)` a.e. + have htrans : + ((translateL2 (μ := (volume : Measure E)) (-t)) F : E → ℝ) =ᵐ[(volume : Measure E)] +@@ -221,7 +224,7 @@ lemma norm_sq_translateL2_sub_extendByZeroL2_eq_integral_sq (t : E) + ∂(volume : Measure E) = + ∫ x, (f (x - t) - f x) ^ 2 ∂(volume : Measure E) := by + refine MeasureTheory.integral_congr_ae ?_ +- simpa using hdiff.pow_const 2 ++ exact hdiff.pow_const 2 + exact h1.trans h2 + simpa [F, f] using hcalc + +@@ -242,7 +245,7 @@ private lemma kernelMeasure_le_smul_volume (hψc : Continuous ψ) (hψcs : HasCo + simpa [Real.norm_eq_abs, abs_of_nonneg (hψ0 x)] using hx' + exact ENNReal.ofReal_le_ofReal hx + -- Unfold `withDensity` and bound the density by the constant `ENNReal.ofReal C`. +- simp [kernelMeasure, MeasureTheory.withDensity_apply, hs] ++ simp only [kernelMeasure, MeasureTheory.withDensity_apply, hs] + have hle : + (∫⁻ x in s, ENNReal.ofReal (ψ x) ∂(volume : Measure E)) ≤ + ∫⁻ x in s, ENNReal.ofReal C ∂(volume : Measure E) := by +@@ -262,9 +265,9 @@ lemma smoothFun_sub_extendByZeroFun_sq_le_integral_sq + ∂kernelMeasure (E := E) ψ := by + classical + let μ : Measure E := kernelMeasure (E := E) ψ +- haveI : MeasureTheory.IsProbabilityMeasure μ := +- instIsProbabilityMeasure_kernelMeasure (E := E) (ψ := ψ) hψc hψcs hψ0 hψint +- haveI : MeasureTheory.IsFiniteMeasure μ := by infer_instance ++ have : MeasureTheory.IsProbabilityMeasure μ := ++ isProbabilityMeasure_kernelMeasure (E := E) (ψ := ψ) hψc hψcs hψ0 hψint ++ have : MeasureTheory.IsFiniteMeasure μ := by infer_instance + rcases kernelMeasure_le_smul_volume (E := E) (ψ := ψ) hψc hψcs hψ0 with ⟨c, hc_top, hμle⟩ + let f : E → ℝ := extendByZeroFun (E := E) (K := K) u + have hf_vol : MeasureTheory.MemLp f (2 : ℝ≥0∞) (volume : Measure E) := by +@@ -288,7 +291,11 @@ lemma smoothFun_sub_extendByZeroFun_sq_le_integral_sq + (volume : Measure E) (volume : Measure E) := + MeasureTheory.measurePreserving_add_right + (μ := (volume : Measure E)) x +- simpa [sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using hadd.comp hneg ++ have hcomp : ((fun y : E => y + x) ∘ fun t : E => -t) = fun t : E => x - t := by ++ funext t ++ simp [sub_eq_add_neg, add_comm] ++ have := hadd.comp hneg ++ rwa [hcomp] at this + have hf_shift_vol : + MeasureTheory.MemLp (fun t : E => f (x - t)) + (2 : ℝ≥0∞) (volume : Measure E) := +@@ -334,10 +341,10 @@ lemma norm_sq_smoothL2_sub_extendByZeroL2_le_integral_norm_sq_translateL2_sub_ex + ∂kernelMeasure (E := E) ψ := by + classical + let μ : Measure E := kernelMeasure (E := E) ψ +- haveI : MeasureTheory.IsProbabilityMeasure μ := +- instIsProbabilityMeasure_kernelMeasure (E := E) (ψ := ψ) hψc hψcs hψ0 hψint +- haveI : MeasureTheory.IsFiniteMeasure μ := by infer_instance +- haveI : MeasureTheory.SFinite μ := by infer_instance ++ have : MeasureTheory.IsProbabilityMeasure μ := ++ isProbabilityMeasure_kernelMeasure (E := E) (ψ := ψ) hψc hψcs hψ0 hψint ++ have : MeasureTheory.IsFiniteMeasure μ := by infer_instance ++ have : MeasureTheory.SFinite μ := by infer_instance + let F : (E →₂[(volume : Measure E)] ℝ) := extendByZeroL2 (E := E) (K := K) hKm u + let f : E → ℝ := extendByZeroFun (E := E) (K := K) u + let S : (E →₂[(volume : Measure E)] ℝ) := smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u +@@ -361,7 +368,7 @@ lemma norm_sq_smoothL2_sub_extendByZeroL2_le_integral_norm_sq_translateL2_sub_ex + (∫ x, ((S - F) x) ^ 2 ∂(volume : Measure E)) = + ∫ x, (smoothFun (E := E) (K := K) ψ u x - f x) ^ 2 ∂(volume : Measure E) := by + refine MeasureTheory.integral_congr_ae ?_ +- simpa using hSF_ae.pow_const 2 ++ exact hSF_ae.pow_const 2 + exact h1.trans h2 + have hLHS_int : + MeasureTheory.Integrable (fun x : E => (smoothFun (E := E) (K := K) ψ u x - f x) ^ 2) +@@ -414,7 +421,7 @@ lemma norm_sq_smoothL2_sub_extendByZeroL2_le_integral_norm_sq_translateL2_sub_ex + MeasureTheory.Integrable (fun z : E × E => (f (z.1 - z.2)) ^ 2) + ((volume : Measure E).prod μ) := by + have := (hsub.integrable_comp hf_fst_sq_prod.aestronglyMeasurable).2 hf_fst_sq_prod +- simpa [Function.comp] using this ++ exact this + have hdom : + MeasureTheory.Integrable (fun z : E × E => (2 : ℝ) * ((f (z.1 - z.2)) ^ 2 + (f z.1) ^ 2)) + ((volume : Measure E).prod μ) := by +@@ -426,7 +433,7 @@ lemma norm_sq_smoothL2_sub_extendByZeroL2_le_integral_norm_sq_translateL2_sub_ex + MeasureTheory.AEStronglyMeasurable f + (Measure.map Prod.fst + ((volume : Measure E).prod μ)) := by +- simpa [Measure.map_fst_prod] using hf_mem.1 ++ simpa [Measure.map_fst_prod] using hf_mem.aestronglyMeasurable + exact MeasureTheory.AEStronglyMeasurable.comp_measurable + (μ := (volume : Measure E).prod μ) (f := Prod.fst) + (g := f) hf_map measurable_fst +@@ -436,7 +443,7 @@ lemma norm_sq_smoothL2_sub_extendByZeroL2_le_integral_norm_sq_translateL2_sub_ex + ((volume : Measure E).prod μ) := by + have := MeasureTheory.AEStronglyMeasurable.comp_measurePreserving (g := fun z : E × E => f z.1) + hf_fst_aesm hsub +- simpa [Function.comp] using this ++ exact this + have h_aesm : + MeasureTheory.AEStronglyMeasurable h ((volume : Measure E).prod μ) := by + -- Build up AE-strong measurability from the two components. +@@ -444,7 +451,7 @@ lemma norm_sq_smoothL2_sub_extendByZeroL2_le_integral_norm_sq_translateL2_sub_ex + MeasureTheory.AEStronglyMeasurable (fun z : E × E => f (z.1 - z.2) - f z.1) + ((volume : Measure E).prod μ) := + hf_shift_aesm.sub hf_fst_aesm +- simpa [h] using (hsub'.pow 2) ++ exact (hsub'.pow 2) + have hint_h : MeasureTheory.Integrable h ((volume : Measure E).prod μ) := by + refine MeasureTheory.Integrable.mono (μ := (volume : Measure E).prod μ) hdom h_aesm ?_ + refine Filter.Eventually.of_forall ?_ +@@ -507,7 +514,6 @@ lemma norm_sq_smoothL2_sub_extendByZeroL2_le_integral_norm_sq_translateL2_sub_ex + -- Restore the original statement. + simpa [S, F, μ] using hmain + +- + end Volume + + end +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/ArzelaAscoli.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/ArzelaAscoli.lean +index 37fe123..ff15e73 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/ArzelaAscoli.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/ArzelaAscoli.lean +@@ -1,15 +1,15 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Compactness +-import Mathlib.Analysis.Normed.Group.Bounded +-import Mathlib.Topology.ContinuousMap.Bounded.ArzelaAscoli +-import Mathlib.MeasureTheory.Function.L2Space +-import Mathlib.MeasureTheory.Integral.Bochner.Set +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Compactness ++import Mathlib.Analysis.Normed.Group.Bounded ++import Mathlib.Topology.ContinuousMap.Bounded.ArzelaAscoli ++import Mathlib.MeasureTheory.Function.L2Space ++import Mathlib.MeasureTheory.Integral.Bochner.Set ++ + /-! + # `L²` compactness criterion: Arzelà–Ascoli for the smoothing operator (Euclidean) + +@@ -42,13 +42,14 @@ section Volume + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + +-local instance instMeasurableSpaceE_L2CompactnessArzelaAscoli : MeasurableSpace E := borel E +-local instance instBorelSpaceE_L2CompactnessArzelaAscoli : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_L2CompactnessArzelaAscoli : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceEL2CompactnessArzelaAscoli : MeasurableSpace E := borel E ++local instance instBorelSpaceEL2CompactnessArzelaAscoli : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceEL2CompactnessArzelaAscoli : OpensMeasurableSpace E := by + infer_instance +-local instance instMeasurableAddE_L2CompactnessArzelaAscoli : MeasurableAdd E := by ++local instance instMeasurableAddEL2CompactnessArzelaAscoli : MeasurableAdd E := by + infer_instance +-local instance instMeasurableNegE_L2CompactnessArzelaAscoli : MeasurableNeg E := by ++local instance instMeasurableNegEL2CompactnessArzelaAscoli : MeasurableNeg E := by + infer_instance + + variable {K : Set E} {ψ : E → ℝ} +@@ -110,8 +111,309 @@ private lemma exists_norm_ψ_bound_on_diffSet (hK : IsCompact K) (hψc : Continu + exact ⟨hx, ht⟩ + exact hne ⟨(x : E) - t, this⟩ + ++private lemma smoothFun_image_mem_closedBall (hK : IsCompact K) ++ (hKm : MeasurableSet K) (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) {R : ℝ} ++ (hRpos : 0 < R) (Cψ : ℝ) (hCψ_nonneg : 0 ≤ Cψ) ++ (hψ_bound : ∀ x : ↥(Kψ (K := K) (ψ := ψ)), ∀ t : E, t ∈ K → ‖ψ ((x : E) - t)‖ ≤ Cψ) : ++ let mK : ℝ := ++ (MeasureTheory.measureUnivNNReal (volume.restrict K)) ^ ((2 : ℝ≥0∞).toReal⁻¹) ++ ∀ (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) (x : ↥(Kψ (K := K) (ψ := ψ))), ++ f ∈ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs '' ++ Metric.closedBall (0 : _) R) → ++ f x ∈ Metric.closedBall (0 : ℝ) (R * (mK * Cψ)) := by ++ intro mK ++ classical ++ have hR : 0 ≤ R := hRpos.le ++ have hμK : (volume : Measure E) K < (⊤ : ℝ≥0∞) := hK.measure_lt_top (μ := (volume : Measure E)) ++ have : Fact ((volume : Measure E) K < (⊤ : ℝ≥0∞)) := ⟨hμK⟩ ++ have : IsFiniteMeasure ((volume : Measure E).restrict K) := by infer_instance ++ let μ : Measure E := (volume : Measure E).restrict K ++ have hmK : 0 ≤ mK := by ++ have : 0 ≤ (MeasureTheory.measureUnivNNReal (volume.restrict K)) := by simp ++ exact Real.rpow_nonneg this _ ++ intro f x hfA ++ rcases hfA with ⟨u, hu_ball, rfl⟩ ++ have hu_norm : ‖u‖ ≤ R := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hu_ball ++ -- Build the `L²(K)` kernel element. ++ have hker : ++ MemLp (fun t : E => ψ ((x : E) - t)) (2 : ℝ≥0∞) (volume.restrict K) := by ++ refine MemLp.of_bound (μ := (volume.restrict K)) ++ (hf := (hψc.aestronglyMeasurable.comp_measurable ++ (measurable_const.sub measurable_id))) Cψ ?_ ++ filter_upwards ++ [MeasureTheory.ae_restrict_mem ++ (μ := (volume : Measure E)) hKm] with t ht ++ exact hψ_bound x t ht ++ let kx : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ := ++ hker.toLp (fun t : E => ψ ((x : E) - t)) ++ have hkx_norm : ‖kx‖ ≤ mK * Cψ := by ++ have h_ae : ++ ∀ᵐ t ∂(volume.restrict K), ‖(fun t : E => ψ ((x : E) - t)) t‖ ≤ Cψ := by ++ filter_upwards [MeasureTheory.ae_restrict_mem (μ := (volume : Measure E)) hKm] with t ht ++ exact hψ_bound x t ht ++ have := (MeasureTheory.Lp.norm_le_of_ae_bound ++ (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := kx) (hC := hCψ_nonneg) (by ++ -- transport the bound through the `toLp` representative ++ filter_upwards [h_ae, ++ MeasureTheory.MemLp.coeFn_toLp ++ (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := fun t : E => ψ ((x : E) - t)) ++ hker] with t ht hrep ++ simpa [kx, hrep] using ht)) ++ simpa [mK] using this ++ -- Express the smoothing value as an `L²` inner product, then apply Cauchy–Schwarz. ++ have hsmooth : ++ smoothFun (E := E) (K := K) ψ u (x : E) = ++ ∫ t, u t * kx t ∂(volume.restrict K) := by ++ have h_ae : ++ (fun t : E => u t * kx t) =ᵐ[volume.restrict K] fun t : E => u t * ψ ((x : E) - t) := by ++ filter_upwards [MeasureTheory.MemLp.coeFn_toLp ++ (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := fun t : E => ψ ((x : E) - t)) ++ hker] with t ht ++ simp [kx, ht] ++ -- rewrite `smoothFun` as an integral on `volume.restrict K` ++ rw [smoothFun_eq_integral_restrict ++ (E := E) (K := K) (ψ := ψ) (hKm := hKm) u (x : E)] ++ exact (MeasureTheory.integral_congr_ae h_ae.symm) ++ have hsmooth' : ++ smoothFun (E := E) (K := K) ψ u (x : E) = ++ ∫ t, kx t * u t ∂(volume.restrict K) := by ++ simp [hsmooth, mul_comm] ++ have hinner : ++ smoothFun (E := E) (K := K) ψ u (x : E) = ++ inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) kx := by ++ erw [MeasureTheory.L2.inner_def]; exact hsmooth' ++ have habs : ++ |smoothFun (E := E) (K := K) ψ u (x : E)| ≤ ‖u‖ * ‖kx‖ := by ++ simpa [hinner] using ++ (abs_real_inner_le_norm (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) kx) ++ have habs' : |smoothFun (E := E) (K := K) ψ u (x : E)| ≤ R * (mK * Cψ) := by ++ calc ++ |smoothFun (E := E) (K := K) ψ u (x : E)| ++ ≤ ‖u‖ * ‖kx‖ := habs ++ _ ≤ R * (mK * Cψ) := by ++ exact mul_le_mul hu_norm hkx_norm (norm_nonneg _) hR ++ have : dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) 0 ≤ R * (mK * Cψ) := by ++ simpa [smoothBCF_apply (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x, ++ dist_eq_norm, Real.norm_eq_abs] using habs' ++ simpa [Metric.mem_closedBall, dist_eq_norm] using this ++ + /-- Arzelà--Ascoli: smoothing maps `L²(K)` bounded sets into a precompact set + in `BCF(K + tsupport ψ)`. -/ ++private lemma uniformEquicontinuous_smoothBCF_closedBall (hK : IsCompact K) ++ (hKm : MeasurableSet K) (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) {R : ℝ} ++ (hRpos : 0 < R) (Cψ : ℝ) (hCψ_nonneg : 0 ≤ Cψ) ++ (hψ_bound : ∀ x : ↥(Kψ (K := K) (ψ := ψ)), ∀ t : E, t ∈ K → ‖ψ ((x : E) - t)‖ ≤ Cψ) : ++ let A : Set (BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) := ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs '' Metric.closedBall (0 : _) R ++ UniformEquicontinuous ((↑) : A → ↥(Kψ (K := K) (ψ := ψ)) → ℝ) := by ++ intro A ++ classical ++ have hR : 0 ≤ R := hRpos.le ++ have hR0 : R ≠ 0 := ne_of_gt hRpos ++ have hμK : (volume : Measure E) K < (⊤ : ℝ≥0∞) := hK.measure_lt_top (μ := (volume : Measure E)) ++ have : Fact ((volume : Measure E) K < (⊤ : ℝ≥0∞)) := ⟨hμK⟩ ++ have : IsFiniteMeasure ((volume : Measure E).restrict K) := by infer_instance ++ let μ : Measure E := (volume : Measure E).restrict K ++ let mK : ℝ := ++ (MeasureTheory.measureUnivNNReal (volume.restrict K)) ^ ((2 : ℝ≥0∞).toReal⁻¹) ++ have hmK : 0 ≤ mK := Real.rpow_nonneg (by simp) _ ++ let s : Set ℝ := Metric.closedBall (0 : ℝ) (R * (mK * Cψ)) ++ have in_s := ++ smoothFun_image_mem_closedBall (K := K) (ψ := ψ) hK hKm hψc hψcs ++ (R := R) hRpos Cψ hCψ_nonneg hψ_bound ++ rw [Metric.uniformEquicontinuous_iff] ++ intro ε hε ++ -- Handle the zero-measure case separately (then `mK = 0` and everything is constant). ++ by_cases hmK0 : mK = 0 ++ · refine ⟨1, by norm_num, ?_⟩ ++ intro x y _ f ++ -- With `mK = 0`, the range bound forces all values to be `0`. ++ set F : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ := ++ (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) with hF ++ have hzero : ∀ z, F z = 0 := by ++ intro z ++ have hmem : F z ∈ s := in_s (f := F) z f.property ++ have hle : dist (F z) 0 ≤ 0 := by ++ have : dist (F z) 0 ≤ R * (mK * Cψ) := by simpa [s, Metric.mem_closedBall] using hmem ++ simpa [hmK0] using this ++ exact dist_eq_zero.1 (le_antisymm hle dist_nonneg) ++ simpa [hzero x, hzero y] using hε ++ · have hRmK_ne : R * mK ≠ 0 := mul_ne_zero hR0 hmK0 ++ let ε2 : ℝ := ε / 2 ++ have hε2pos : 0 < ε2 := by ++ simpa [ε2] using half_pos hε ++ let ε' : ℝ := ε2 / (R * mK) ++ have hε'pos : 0 < ε' := ++ div_pos hε2pos (mul_pos hRpos (lt_of_le_of_ne hmK (Ne.symm hmK0))) ++ have hε'lt : R * mK * ε' = ε2 := by ++ dsimp [ε'] ++ field_simp [hRmK_ne, mul_assoc, mul_left_comm, mul_comm] ++ -- Use uniform continuity of `ψ` to get `deltaLoss`. ++ have hUC : UniformContinuous ψ := uniformContinuous_ψ (E := E) (ψ := ψ) hψc hψcs ++ rcases (Metric.uniformContinuous_iff.1 hUC) ε' hε'pos with ⟨deltaLoss, hδpos, hδ⟩ ++ refine ⟨deltaLoss, hδpos, ?_⟩ ++ intro x y hxy f ++ -- Work with the `smoothBCF` representative of `f`. ++ rcases f.property with ⟨u, hu_ball, hu_eq⟩ ++ have hu_eq' : ++ (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) = ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u := by ++ simpa using hu_eq.symm ++ have hu_norm : ‖u‖ ≤ R := by ++ simpa [Metric.mem_closedBall, dist_eq_norm] using hu_ball ++ -- Kernel elements at `x` and `y`. ++ have hkerx : ++ MemLp (fun t : E => ψ ((x : E) - t)) (2 : ℝ≥0∞) (volume.restrict K) := by ++ refine MemLp.of_bound (μ := (volume.restrict K)) ++ (hf := (hψc.aestronglyMeasurable.comp_measurable ++ (measurable_const.sub measurable_id))) Cψ ?_ ++ filter_upwards ++ [MeasureTheory.ae_restrict_mem ++ (μ := (volume : Measure E)) hKm] with t ht ++ exact hψ_bound x t ht ++ have hkery : ++ MemLp (fun t : E => ψ ((y : E) - t)) (2 : ℝ≥0∞) (volume.restrict K) := by ++ refine MemLp.of_bound (μ := (volume.restrict K)) ++ (hf := (hψc.aestronglyMeasurable.comp_measurable ++ (measurable_const.sub measurable_id))) Cψ ?_ ++ filter_upwards [MeasureTheory.ae_restrict_mem (μ := (volume : Measure E)) hKm] with t ht ++ exact hψ_bound y t ht ++ let kx : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ := ++ hkerx.toLp (fun t : E => ψ ((x : E) - t)) ++ let ky : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ := ++ hkery.toLp (fun t : E => ψ ((y : E) - t)) ++ -- AE bound on `‖kx - ky‖` by `ε'`. ++ have h_ae : ++ ∀ᵐ t ∂(volume.restrict K), ‖(kx - ky) t‖ ≤ ε' := by ++ filter_upwards [MeasureTheory.ae_restrict_mem (μ := (volume : Measure E)) hKm, ++ MeasureTheory.MemLp.coeFn_toLp (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := fun t : E => ψ ((x : E) - t)) hkerx, ++ MeasureTheory.MemLp.coeFn_toLp (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := fun t : E => ψ ((y : E) - t)) hkery, ++ (MeasureTheory.Lp.coeFn_sub (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) kx ky)] with ++ t ht hx_t hy_t hsub ++ have hxy' : dist ((x : E) - t) ((y : E) - t) < deltaLoss := by ++ rw [dist_sub_right] ++ exact hxy ++ have hψxy : dist (ψ ((x : E) - t)) (ψ ((y : E) - t)) < ε' := ++ hδ (a := (x : E) - t) (b := (y : E) - t) hxy' ++ have : ‖ψ ((x : E) - t) - ψ ((y : E) - t)‖ ≤ ε' := by ++ simpa [dist_eq_norm, sub_eq_add_neg] using le_of_lt hψxy ++ have hx' : kx t = ψ ((x : E) - t) := by simpa [kx] using hx_t ++ have hy' : ky t = ψ ((y : E) - t) := by simpa [ky] using hy_t ++ have hnorm : ‖kx t - ky t‖ ≤ ε' := by ++ simpa [hx', hy'] using this ++ have hsub' : (kx - ky) t = kx t - ky t := by ++ simpa [Pi.sub_apply] using hsub ++ simpa [hsub'.symm] using hnorm ++ have hkdiff : ‖kx - ky‖ ≤ mK * ε' := by ++ have := (MeasureTheory.Lp.norm_le_of_ae_bound (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := (kx - ky : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ)) (hC := le_of_lt hε'pos) h_ae) ++ simpa [mK, mul_comm, mul_left_comm, mul_assoc] using this ++ -- Bound the difference of values using Cauchy–Schwarz. ++ have hdist : ++ dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) ++ ≤ ‖u‖ * ‖kx - ky‖ := by ++ -- Express each value as an inner product. ++ have hx_val : ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x = ++ inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) kx := by ++ have hsmooth : ++ smoothFun (E := E) (K := K) ψ u (x : E) = ++ ∫ t, u t * kx t ∂(volume.restrict K) := by ++ have h_ae' : ++ (fun t : E => u t * kx t) =ᵐ[volume.restrict K] ++ fun t : E => u t * ψ ((x : E) - t) := by ++ filter_upwards [MeasureTheory.MemLp.coeFn_toLp ++ (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := fun t : E => ψ ((x : E) - t)) ++ hkerx] with t ht ++ simp [kx, ht] ++ rw [smoothFun_eq_integral_restrict ++ (E := E) (K := K) (ψ := ψ) (hKm := hKm) ++ u (x : E)] ++ exact (MeasureTheory.integral_congr_ae h_ae'.symm) ++ have hsmooth' : ++ smoothFun (E := E) (K := K) ψ u (x : E) = ++ ∫ t, kx t * u t ∂(volume.restrict K) := by ++ simp [hsmooth, mul_comm] ++ erw [smoothBCF_apply (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x, ++ MeasureTheory.L2.inner_def]; exact hsmooth' ++ have hy_val : ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y = ++ inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) ky := by ++ have hsmooth : ++ smoothFun (E := E) (K := K) ψ u (y : E) = ++ ∫ t, u t * ky t ∂(volume.restrict K) := by ++ have h_ae' : ++ (fun t : E => u t * ky t) =ᵐ[volume.restrict K] ++ fun t : E => u t * ψ ((y : E) - t) := by ++ filter_upwards [MeasureTheory.MemLp.coeFn_toLp ++ (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) ++ (f := fun t : E => ψ ((y : E) - t)) ++ hkery] with t ht ++ simp [ky, ht] ++ rw [smoothFun_eq_integral_restrict ++ (E := E) (K := K) (ψ := ψ) (hKm := hKm) ++ u (y : E)] ++ exact (MeasureTheory.integral_congr_ae h_ae'.symm) ++ have hsmooth' : ++ smoothFun (E := E) (K := K) ψ u (y : E) = ++ ∫ t, ky t * u t ∂(volume.restrict K) := by ++ simp [hsmooth, mul_comm] ++ erw [smoothBCF_apply (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y, ++ MeasureTheory.L2.inner_def]; exact hsmooth' ++ have : ++ ‖smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x - ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y‖ ≤ ++ ‖u‖ * ‖kx - ky‖ := by ++ have : ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x - ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y = ++ inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) (kx - ky) := by ++ simp [hx_val, hy_val, inner_sub_right] ++ have this' : ++ smoothFun (E := E) (K := K) ψ u (x : E) - smoothFun (E := E) (K := K) ψ u (y : E) = ++ inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) (kx - ky) := by ++ simpa [smoothBCF_apply (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs] using this ++ have hCS := ++ (abs_real_inner_le_norm (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) (kx - ky)) ++ simpa [this', dist_eq_norm, Real.norm_eq_abs] using hCS ++ simpa [dist_eq_norm] using this ++ have hle : ++ dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) ++ ≤ R * (mK * ε') := by ++ calc ++ dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) ++ ≤ ‖u‖ * ‖kx - ky‖ := hdist ++ _ ≤ ‖u‖ * (mK * ε') := by ++ exact mul_le_mul_of_nonneg_left hkdiff (norm_nonneg _) ++ _ ≤ R * (mK * ε') := by ++ have hmKε' : 0 ≤ mK * ε' := mul_nonneg hmK (le_of_lt hε'pos) ++ exact mul_le_mul_of_nonneg_right hu_norm hmKε' ++ have hRmkε' : R * (mK * ε') = ε2 := by ++ have : R * mK * ε' = ε2 := by ++ simpa [ε', mul_assoc] using hε'lt ++ simpa [mul_assoc] using this ++ have hle' : ++ dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) ≤ ε2 := by ++ simpa [hRmkε'] using hle ++ have hε2lt : ε2 < ε := by ++ simpa [ε2] using half_lt_self hε ++ have : ++ dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) < ε := ++ lt_of_le_of_lt hle' hε2lt ++ simpa [hu_eq'] using this ++ + theorem smoothBCF_image_closedBall_isCompact (hK : IsCompact K) (hKm : MeasurableSet K) + (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) {R : ℝ} (hR : 0 ≤ R) : + IsCompact +@@ -130,15 +432,15 @@ theorem smoothBCF_image_closedBall_isCompact (hK : IsCompact K) (hKm : Measurabl + simp [hball] + · have hRpos : 0 < R := lt_of_le_of_ne hR (Ne.symm hR0) + -- Compactness of the codomain. +- letI : CompactSpace ↥(Kψ (K := K) (ψ := ψ)) := ++ let : CompactSpace ↥(Kψ (K := K) (ψ := ψ)) := + isCompact_iff_compactSpace.1 (isCompact_Kψ (K := K) (ψ := ψ) hK hψcs) + let A : + Set (BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) := + smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs '' Metric.closedBall (0 : _) R + -- `volume.restrict K` is finite since `K` is compact. +- have hμK : (volume : Measure E) K < ∞ := hK.measure_lt_top (μ := (volume : Measure E)) +- letI : Fact ((volume : Measure E) K < ∞) := ⟨hμK⟩ +- haveI : IsFiniteMeasure (volume.restrict K) := by ++ have hμK : (volume : Measure E) K < (⊤ : ℝ≥0∞) := hK.measure_lt_top (μ := (volume : Measure E)) ++ let : Fact ((volume : Measure E) K < (⊤ : ℝ≥0∞)) := ⟨hμK⟩ ++ have : IsFiniteMeasure (volume.restrict K) := by + infer_instance + let μ : Measure E := (volume : Measure E).restrict K + let mK : ℝ := +@@ -227,211 +529,10 @@ theorem smoothBCF_image_closedBall_isCompact (hK : IsCompact K) (hKm : Measurabl + dist_eq_norm, Real.norm_eq_abs] using habs' + simpa [s, Metric.mem_closedBall, dist_eq_norm] using this + -- Equicontinuity for `A`. +- have H' : UniformEquicontinuous ((↑) : A → ↥(Kψ (K := K) (ψ := ψ)) → ℝ) := by +- rw [Metric.uniformEquicontinuous_iff] +- intro ε hε +- -- Handle the zero-measure case separately (then `mK = 0` and everything is constant). +- by_cases hmK0 : mK = 0 +- · refine ⟨1, by norm_num, ?_⟩ +- intro x y _ f +- -- With `mK = 0`, the range bound forces all values to be `0`. +- have hx0 : dist ((f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) x) 0 ≤ +- R * (mK * Cψ) := by +- have : +- (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) x ∈ s := +- in_s (f := (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ)) x f.property +- simpa [s, Metric.mem_closedBall] using this +- have hy0 : dist ((f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) y) 0 ≤ +- R * (mK * Cψ) := by +- have : +- (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) y ∈ s := +- in_s (f := (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ)) y f.property +- simpa [s, Metric.mem_closedBall] using this +- have hx0' : +- dist ((f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) x) 0 = 0 := by +- have : dist ((f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) x) 0 ≤ 0 := by +- simpa [hmK0] using hx0 +- exact le_antisymm this dist_nonneg +- have hy0' : +- dist ((f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) y) 0 = 0 := by +- have : dist ((f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) y) 0 ≤ 0 := by +- simpa [hmK0] using hy0 +- exact le_antisymm this dist_nonneg +- have hx : (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) x = 0 := +- dist_eq_zero.1 hx0' +- have hy : (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) y = 0 := +- dist_eq_zero.1 hy0' +- simpa [hx, hy] using hε +- · have hRmK_ne : R * mK ≠ 0 := mul_ne_zero hR0 hmK0 +- let ε2 : ℝ := ε / 2 +- have hε2pos : 0 < ε2 := by +- simpa [ε2] using half_pos hε +- let ε' : ℝ := ε2 / (R * mK) +- have hε'pos : 0 < ε' := +- div_pos hε2pos (mul_pos hRpos (lt_of_le_of_ne hmK (Ne.symm hmK0))) +- have hε'lt : R * mK * ε' = ε2 := by +- dsimp [ε'] +- field_simp [hRmK_ne, mul_assoc, mul_left_comm, mul_comm] +- -- Use uniform continuity of `ψ` to get `δ`. +- have hUC : UniformContinuous ψ := uniformContinuous_ψ (E := E) (ψ := ψ) hψc hψcs +- rcases (Metric.uniformContinuous_iff.1 hUC) ε' hε'pos with ⟨δ, hδpos, hδ⟩ +- refine ⟨δ, hδpos, ?_⟩ +- intro x y hxy f +- -- Work with the `smoothBCF` representative of `f`. +- rcases f.property with ⟨u, hu_ball, hu_eq⟩ +- have hu_eq' : +- (f : BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) = +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u := by +- simpa using hu_eq.symm +- have hu_norm : ‖u‖ ≤ R := by +- simpa [Metric.mem_closedBall, dist_eq_norm] using hu_ball +- -- Kernel elements at `x` and `y`. +- have hkerx : +- MemLp (fun t : E => ψ ((x : E) - t)) (2 : ℝ≥0∞) (volume.restrict K) := by +- refine MemLp.of_bound (μ := (volume.restrict K)) +- (hf := (hψc.aestronglyMeasurable.comp_measurable +- (measurable_const.sub measurable_id))) Cψ ?_ +- filter_upwards +- [MeasureTheory.ae_restrict_mem +- (μ := (volume : Measure E)) hKm] with t ht +- exact hψ_bound x t ht +- have hkery : +- MemLp (fun t : E => ψ ((y : E) - t)) (2 : ℝ≥0∞) (volume.restrict K) := by +- refine MemLp.of_bound (μ := (volume.restrict K)) +- (hf := (hψc.aestronglyMeasurable.comp_measurable +- (measurable_const.sub measurable_id))) Cψ ?_ +- filter_upwards [MeasureTheory.ae_restrict_mem (μ := (volume : Measure E)) hKm] with t ht +- exact hψ_bound y t ht +- let kx : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ := +- hkerx.toLp (fun t : E => ψ ((x : E) - t)) +- let ky : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ := +- hkery.toLp (fun t : E => ψ ((y : E) - t)) +- -- AE bound on `‖kx - ky‖` by `ε'`. +- have h_ae : +- ∀ᵐ t ∂(volume.restrict K), ‖(kx - ky) t‖ ≤ ε' := by +- filter_upwards [MeasureTheory.ae_restrict_mem (μ := (volume : Measure E)) hKm, +- MeasureTheory.MemLp.coeFn_toLp (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) +- (f := fun t : E => ψ ((x : E) - t)) hkerx, +- MeasureTheory.MemLp.coeFn_toLp (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) +- (f := fun t : E => ψ ((y : E) - t)) hkery, +- (MeasureTheory.Lp.coeFn_sub (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) kx ky)] with +- t ht hx_t hy_t hsub +- have hxy' : dist ((x : E) - t) ((y : E) - t) < δ := by +- simpa [sub_eq_add_neg, add_assoc] using hxy +- have hψxy : dist (ψ ((x : E) - t)) (ψ ((y : E) - t)) < ε' := +- hδ (a := (x : E) - t) (b := (y : E) - t) hxy' +- have : ‖ψ ((x : E) - t) - ψ ((y : E) - t)‖ ≤ ε' := by +- simpa [dist_eq_norm, sub_eq_add_neg] using le_of_lt hψxy +- have hx' : kx t = ψ ((x : E) - t) := by simpa [kx] using hx_t +- have hy' : ky t = ψ ((y : E) - t) := by simpa [ky] using hy_t +- have hnorm : ‖kx t - ky t‖ ≤ ε' := by +- simpa [hx', hy'] using this +- have hsub' : (kx - ky) t = kx t - ky t := by +- simpa [Pi.sub_apply] using hsub +- simpa [hsub'.symm] using hnorm +- have hkdiff : ‖kx - ky‖ ≤ mK * ε' := by +- have := (MeasureTheory.Lp.norm_le_of_ae_bound (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) +- (f := (kx - ky : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ)) (hC := le_of_lt hε'pos) h_ae) +- simpa [mK, mul_comm, mul_left_comm, mul_assoc] using this +- -- Bound the difference of values using Cauchy–Schwarz. +- have hdist : +- dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) +- ≤ ‖u‖ * ‖kx - ky‖ := by +- -- Express each value as an inner product. +- have hx_val : +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x = +- inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) kx := by +- have hsmooth : +- smoothFun (E := E) (K := K) ψ u (x : E) = +- ∫ t, u t * kx t ∂(volume.restrict K) := by +- have h_ae' : +- (fun t : E => u t * kx t) =ᵐ[volume.restrict K] +- fun t : E => u t * ψ ((x : E) - t) := by +- filter_upwards [MeasureTheory.MemLp.coeFn_toLp +- (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) +- (f := fun t : E => ψ ((x : E) - t)) +- hkerx] with t ht +- simp [kx, ht] +- rw [smoothFun_eq_integral_restrict +- (E := E) (K := K) (ψ := ψ) (hKm := hKm) +- u (x : E)] +- exact (MeasureTheory.integral_congr_ae h_ae'.symm) +- have hsmooth' : +- smoothFun (E := E) (K := K) ψ u (x : E) = +- ∫ t, kx t * u t ∂(volume.restrict K) := by +- simp [hsmooth, mul_comm] +- erw [smoothBCF_apply (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x, +- MeasureTheory.L2.inner_def]; exact hsmooth' +- have hy_val : +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y = +- inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) ky := by +- have hsmooth : +- smoothFun (E := E) (K := K) ψ u (y : E) = +- ∫ t, u t * ky t ∂(volume.restrict K) := by +- have h_ae' : +- (fun t : E => u t * ky t) =ᵐ[volume.restrict K] +- fun t : E => u t * ψ ((y : E) - t) := by +- filter_upwards [MeasureTheory.MemLp.coeFn_toLp +- (μ := (volume.restrict K)) (p := (2 : ℝ≥0∞)) +- (f := fun t : E => ψ ((y : E) - t)) +- hkery] with t ht +- simp [ky, ht] +- rw [smoothFun_eq_integral_restrict +- (E := E) (K := K) (ψ := ψ) (hKm := hKm) +- u (y : E)] +- exact (MeasureTheory.integral_congr_ae h_ae'.symm) +- have hsmooth' : +- smoothFun (E := E) (K := K) ψ u (y : E) = +- ∫ t, ky t * u t ∂(volume.restrict K) := by +- simp [hsmooth, mul_comm] +- erw [smoothBCF_apply (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y, +- MeasureTheory.L2.inner_def]; exact hsmooth' +- have : +- ‖smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x - +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y‖ ≤ +- ‖u‖ * ‖kx - ky‖ := by +- have : +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x - +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y = +- inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) (kx - ky) := by +- simp [hx_val, hy_val, inner_sub_right] +- have this' : +- smoothFun (E := E) (K := K) ψ u (x : E) - smoothFun (E := E) (K := K) ψ u (y : E) = +- inner ℝ (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) (kx - ky) := by +- simpa [smoothBCF_apply (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs] using this +- have hCS := +- (abs_real_inner_le_norm (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μ) (kx - ky)) +- simpa [this', dist_eq_norm, Real.norm_eq_abs] using hCS +- simpa [dist_eq_norm] using this +- have hle : +- dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) +- ≤ R * (mK * ε') := by +- calc +- dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) +- ≤ ‖u‖ * ‖kx - ky‖ := hdist +- _ ≤ ‖u‖ * (mK * ε') := by +- exact mul_le_mul_of_nonneg_left hkdiff (norm_nonneg _) +- _ ≤ R * (mK * ε') := by +- have hmKε' : 0 ≤ mK * ε' := mul_nonneg hmK (le_of_lt hε'pos) +- exact mul_le_mul_of_nonneg_right hu_norm hmKε' +- have hRmkε' : R * (mK * ε') = ε2 := by +- have : R * mK * ε' = ε2 := by +- simpa [ε', mul_assoc] using hε'lt +- simpa [mul_assoc] using this +- have hle' : +- dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) ≤ ε2 := by +- simpa [hRmkε'] using hle +- have hε2lt : ε2 < ε := by +- simpa [ε2] using half_lt_self hε +- have : +- dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u x) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u y) < ε := +- lt_of_le_of_lt hle' hε2lt +- simpa [hu_eq'] using this ++ have H' : ++ UniformEquicontinuous ((↑) : A → ↥(Kψ (K := K) (ψ := ψ)) → ℝ) := ++ uniformEquicontinuous_smoothBCF_closedBall (K := K) (ψ := ψ) hK hKm hψc hψcs ++ (R := R) hRpos Cψ hCψ_nonneg hψ_bound + have H : Equicontinuous ((↑) : A → ↥(Kψ (K := K) (ψ := ψ)) → ℝ) := H'.equicontinuous + -- Apply Arzelà–Ascoli. + simpa [A, s] using +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Compactness.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Compactness.lean +index 00cba3a..70360de 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Compactness.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Compactness.lean +@@ -1,15 +1,15 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Smoothing +-import Mathlib.MeasureTheory.Function.LpSeminorm.CompareExp +-import Mathlib.MeasureTheory.Measure.Typeclasses.Finite +-import Mathlib.Topology.Algebra.Monoid +-import Mathlib.Topology.UniformSpace.HeineCantor +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Smoothing ++import Mathlib.MeasureTheory.Function.LpSeminorm.CompareExp ++import Mathlib.MeasureTheory.Measure.Typeclasses.Finite ++import Mathlib.Topology.Algebra.Monoid ++import Mathlib.Topology.UniformSpace.HeineCantor ++ + /-! + # `L²` compactness criterion: compact smoothing operator (Euclidean) + +@@ -44,13 +44,14 @@ section Volume + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + +-local instance instMeasurableSpaceE_L2CompactnessCompactness : MeasurableSpace E := borel E +-local instance instBorelSpaceE_L2CompactnessCompactness : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_L2CompactnessCompactness : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceEL2CompactnessCompactness : MeasurableSpace E := borel E ++local instance instBorelSpaceEL2CompactnessCompactness : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceEL2CompactnessCompactness : OpensMeasurableSpace E := by + infer_instance +-local instance instMeasurableAddE_L2CompactnessCompactness : MeasurableAdd E := by ++local instance instMeasurableAddEL2CompactnessCompactness : MeasurableAdd E := by + infer_instance +-local instance instMeasurableNegE_L2CompactnessCompactness : MeasurableNeg E := by ++local instance instMeasurableNegEL2CompactnessCompactness : MeasurableNeg E := by + infer_instance + + variable {K : Set E} +@@ -65,14 +66,15 @@ lemma isCompact_Kψ (hK : IsCompact K) (hψcs : HasCompactSupport ψ) : + IsCompact (Kψ (K := K) (ψ := ψ)) := + IsCompact.add hK hψcs.isCompact + +-private def smoothOn (hKm : MeasurableSet K) (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) ++/-- Restrict the smoothed function to its compact domain as a continuous map. -/ ++def smoothOn (hKm : MeasurableSet K) (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) + (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume.restrict K)) : + C(↥(Kψ (K := K) (ψ := ψ)), ℝ) where + toFun x := smoothFun (E := E) (K := K) ψ u x + continuous_toFun := by + have : Continuous (smoothFun (E := E) (K := K) ψ u) := + continuous_smoothFun (E := E) (K := K) (ψ := ψ) (hKm := hKm) hψc hψcs u +- simpa using this.comp continuous_subtype_val ++ exact this.comp continuous_subtype_val + + /-- `smoothFun` packaged as a `BoundedContinuousFunction` on the compact set `K + tsupport ψ`. -/ + def smoothBCF (hK : IsCompact K) (hKm : MeasurableSet K) (hψc : Continuous ψ) +@@ -106,7 +108,7 @@ lemma uniformContinuous_ψ (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) + -- If `ψ x` is `ε`-far from `0`, then `ψ x ≠ 0`, hence `x` belongs to the support and therefore + -- to the topological support. + have hx' : ¬ dist (ψ x) 0 < ε := by +- simpa [Set.mem_compl_iff, Set.mem_setOf_eq] using hx ++ simpa [Set.mem_compl_iff, Set.mem_ofPred_eq] using hx + have hxε : ε ≤ dist (ψ x) 0 := le_of_not_gt (by simpa [gt_iff_lt] using hx') + have hx0 : ψ x ≠ 0 := by + intro hψ0 +@@ -130,10 +132,10 @@ private lemma integrable_norm_L2_restrict (hK : IsCompact K) + Integrable (fun x : E => ‖u x‖) (volume.restrict K) := by + classical + -- On a finite measure space, `L² ⊆ L¹`. +- have hμ : (volume : Measure E) K < ∞ := ++ have hμ : (volume : Measure E) K < (⊤ : ℝ≥0∞) := + (hK.measure_lt_top (μ := (volume : Measure E))) +- letI : Fact ((volume : Measure E) K < ∞) := ⟨hμ⟩ +- haveI : IsFiniteMeasure (volume.restrict K) := by ++ let : Fact ((volume : Measure E) K < (⊤ : ℝ≥0∞)) := ⟨hμ⟩ ++ have : IsFiniteMeasure (volume.restrict K) := by + infer_instance + have hu2 : MemLp (fun x : E => u x) (2 : ℝ≥0∞) (volume.restrict K) := + MeasureTheory.Lp.memLp u +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/FrechetKolmogorov.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/FrechetKolmogorov.lean +index 6af8031..35c2ec0 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/FrechetKolmogorov.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/FrechetKolmogorov.lean +@@ -1,13 +1,13 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Approximation +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Transfer +-import Mathlib.Topology.UniformSpace.Cauchy +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Approximation ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Transfer ++import Mathlib.Topology.UniformSpace.Cauchy ++ + /-! + # `L²` compactness criterion: Fréchet–Kolmogorov (Euclidean, compact support case) + +@@ -52,13 +52,14 @@ section Volume + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + +-local instance instMeasurableSpaceE_L2CompactnessFrechetKolmogorov : MeasurableSpace E := borel E +-local instance instBorelSpaceE_L2CompactnessFrechetKolmogorov : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_L2CompactnessFrechetKolmogorov : ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceEL2CompactnessFrechetKolmogorov : MeasurableSpace E := borel E ++local instance instBorelSpaceEL2CompactnessFrechetKolmogorov : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceEL2CompactnessFrechetKolmogorov : + OpensMeasurableSpace E := by infer_instance +-local instance instMeasurableAddE_L2CompactnessFrechetKolmogorov : MeasurableAdd E := by ++local instance instMeasurableAddEL2CompactnessFrechetKolmogorov : MeasurableAdd E := by + infer_instance +-local instance instMeasurableNegE_L2CompactnessFrechetKolmogorov : MeasurableNeg E := by ++local instance instMeasurableNegEL2CompactnessFrechetKolmogorov : MeasurableNeg E := by + infer_instance + + variable {K : Set E} {ψ : E → ℝ} +@@ -125,7 +126,7 @@ theorem totallyBounded_extendByZeroL2_image_of_forall_exists_translationIntegral + rcases Set.mem_iUnion.1 hSu_cover with ⟨y, hy⟩ + rcases Set.mem_iUnion.1 hy with ⟨hyT, hyBall⟩ + have hyDist : dist (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u) y < ε / 2 := by +- simpa [Metric.ball, Set.mem_setOf_eq] using hyBall ++ simpa [Metric.ball, Set.mem_ofPred_eq] using hyBall + have hdist_smooth_ext : + dist (extendByZeroL2 (E := E) (K := K) hKm u) + (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u) ≤ ε / 2 := by +@@ -156,7 +157,7 @@ theorem totallyBounded_extendByZeroL2_image_of_forall_exists_translationIntegral + lt_of_le_of_lt htri hlt + simpa [add_halves ε] using htmp + have hxBall : extendByZeroL2 (E := E) (K := K) hKm u ∈ Metric.ball y ε := by +- simpa [Metric.ball, Set.mem_setOf_eq] using hxDist ++ simpa [Metric.ball, Set.mem_ofPred_eq] using hxDist + exact Set.mem_iUnion.2 ⟨y, Set.mem_iUnion.2 ⟨hyT, hxBall⟩⟩ + + theorem isCompact_closure_extendByZeroL2_image_of_forall_exists_translationIntegral_small +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Kernels.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Kernels.lean +index 833b243..8543986 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Kernels.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Kernels.lean +@@ -1,22 +1,22 @@ +-import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension +-import Mathlib.MeasureTheory.Integral.Bochner.Set +-import Mathlib.Topology.Algebra.Support +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension ++import Mathlib.MeasureTheory.Integral.Bochner.Set ++import Mathlib.Topology.Algebra.Support ++ + /-! + # `L²` compactness criterion: existence of small-support probability kernels (Euclidean) + + This file provides a “kernel factory” for the Euclidean Fréchet–Kolmogorov / Riesz–Kolmogorov +-criterion: for any radius `δ > 0`, produce a continuous compactly supported function `ψ : E → ℝ` ++criterion: for any radius `deltaLoss > 0`, produce a continuous compactly supported function `ψ : E → ℝ` + such that: + + - `ψ ≥ 0`, +-- `tsupport ψ ⊆ Metric.ball 0 δ`, ++- `tsupport ψ ⊆ Metric.ball 0 deltaLoss`, + - `∫ ψ = 1` (so `kernelMeasure ψ` is a probability measure). + + The construction uses mathlib’s `exists_smooth_tsupport_subset` bump-function lemma and normalizes +@@ -41,21 +41,22 @@ section Volume + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + +-local instance instMeasurableSpaceE_L2CompactnessKernels : MeasurableSpace E := borel E +-local instance instBorelSpaceE_L2CompactnessKernels : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_L2CompactnessKernels : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceEL2CompactnessKernels : MeasurableSpace E := borel E ++local instance instBorelSpaceEL2CompactnessKernels : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceEL2CompactnessKernels : OpensMeasurableSpace E := by + infer_instance + +-/-- For any `δ > 0`, there exists a continuous compactly supported kernel `ψ` supported in +-`Metric.ball 0 δ`, with `ψ ≥ 0` and `∫ ψ = 1` (w.r.t. Lebesgue measure). -/ +-theorem exists_kernel_tsupport_subset_ball_integral_eq_one {δ : ℝ} (hδ : 0 < δ) : ++/-- For any `deltaLoss > 0`, there exists a continuous compactly supported kernel `ψ` supported in ++`Metric.ball 0 deltaLoss`, with `ψ ≥ 0` and `∫ ψ = 1` (w.r.t. Lebesgue measure). -/ ++theorem exists_kernel_tsupport_subset_ball_integral_eq_one {deltaLoss : ℝ} (hδ : 0 < deltaLoss) : + ∃ ψ : E → ℝ, Continuous ψ ∧ HasCompactSupport ψ ∧ (∀ x, 0 ≤ ψ x) ∧ +- (∫ x, ψ x ∂(volume : Measure E) = 1) ∧ tsupport ψ ⊆ Metric.ball (0 : E) δ := by ++ (∫ x, ψ x ∂(volume : Measure E) = 1) ∧ tsupport ψ ⊆ Metric.ball (0 : E) deltaLoss := by + classical +- -- Start from a smooth bump supported in `ball 0 δ` with value `1` at `0`. +- have hs : (Metric.ball (0 : E) δ) ∈ 𝓝 (0 : E) := Metric.ball_mem_nhds _ hδ ++ -- Start from a smooth bump supported in `ball 0 deltaLoss` with value `1` at `0`. ++ have hs : (Metric.ball (0 : E) deltaLoss) ∈ 𝓝 (0 : E) := Metric.ball_mem_nhds _ hδ + rcases exists_contDiff_tsupport_subset (n := ⊤) +- (E := E) (s := Metric.ball (0 : E) δ) (x := (0 : E)) hs with ++ (E := E) (s := Metric.ball (0 : E) deltaLoss) (x := (0 : E)) hs with + ⟨f, hf_tsupp, hf_cs, hf_smooth, hf_range, hf0⟩ + have hf_cont : Continuous f := hf_smooth.continuous + have hf_nonneg : ∀ x, 0 ≤ f x := by +@@ -77,9 +78,9 @@ theorem exists_kernel_tsupport_subset_ball_integral_eq_one {δ : ℝ} (hδ : 0 < + -- Normalize: `ψ = I⁻¹ • f`. + let ψ : E → ℝ := fun x => I⁻¹ * f x + have hψc : Continuous ψ := by +- simpa [ψ] using (continuous_const.mul hf_cont) ++ exact (continuous_const.mul hf_cont) + have hψcs : HasCompactSupport ψ := by +- simpa [ψ, smul_eq_mul] using ++ exact + (HasCompactSupport.smul_left (f := fun _x : E => I⁻¹) (f' := f) hf_cs) + have hψ0 : ∀ x, 0 ≤ ψ x := by + intro x +@@ -93,7 +94,7 @@ theorem exists_kernel_tsupport_subset_ball_integral_eq_one {δ : ℝ} (hδ : 0 < + simpa [ψ, I] using + (MeasureTheory.integral_const_mul (μ := (volume : Measure E)) (r := I⁻¹) (f := f)) + simp [this, hI0] +- have hψ_tsupp : tsupport ψ ⊆ Metric.ball (0 : E) δ := by ++ have hψ_tsupp : tsupport ψ ⊆ Metric.ball (0 : E) deltaLoss := by + -- Scaling does not enlarge topological support; use the bump support inclusion. + have hsub : tsupport ψ ⊆ tsupport f := by + simpa [ψ, smul_eq_mul] using (tsupport_smul_subset_right (f := fun _x : E => I⁻¹) (g := f)) +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Smoothing.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Smoothing.lean +index 3543832..8d6b0bb 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Smoothing.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Smoothing.lean +@@ -1,13 +1,13 @@ +-import RellichKondrachov.MeasureTheory.Function.LpSpace.Restrict +-import Mathlib.Analysis.Convolution +-import Mathlib.Topology.Algebra.Support +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.MeasureTheory.Function.LpSpace.Restrict ++import Mathlib.Analysis.Convolution ++import Mathlib.Topology.Algebra.Support ++ + /-! + # `L²` compactness criterion: smoothing setup (Euclidean) + +@@ -38,11 +38,12 @@ section + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] + +-local instance : MeasurableSpace E := borel E +-local instance : BorelSpace E := ⟨rfl⟩ +-local instance : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceSmoothing : MeasurableSpace E := borel E ++local instance instBorelSpaceSmoothing : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceSmoothing : OpensMeasurableSpace E := by + infer_instance +-local instance : MeasurableAdd E := by ++local instance instMeasurableAddSmoothing : MeasurableAdd E := by + infer_instance + + omit [InnerProductSpace ℝ E] [CompleteSpace E] in +@@ -68,11 +69,12 @@ section Volume + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + + -- `volume` is the canonical Haar measure on finite-dimensional real vector spaces. +-local instance : MeasurableSpace E := borel E +-local instance : BorelSpace E := ⟨rfl⟩ +-local instance : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceSmoothing1 : MeasurableSpace E := borel E ++local instance instBorelSpaceSmoothing1 : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceSmoothing1 : OpensMeasurableSpace E := by + infer_instance +-local instance : MeasurableAdd E := by ++local instance instMeasurableAddSmoothing1 : MeasurableAdd E := by + infer_instance + + variable {K : Set E} +@@ -116,7 +118,7 @@ lemma extendByZeroL2_eq_extendByZeroₗᵢ (hKm : MeasurableSet K) + (MeasureTheory.Lp.extendByZeroₗᵢ (μ := (volume : Measure E)) (E := ℝ) (p := (2 : ℝ≥0∞)) + (s := K) hKm) u := by + classical +- letI : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ ++ let : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ + refine MeasureTheory.Lp.ext ?_ + have h1 : + (extendByZeroL2 (E := E) (K := K) hKm u : E → ℝ) =ᵐ[(volume : Measure E)] +@@ -126,7 +128,6 @@ lemma extendByZeroL2_eq_extendByZeroₗᵢ (hKm : MeasurableSet K) + ((MeasureTheory.Lp.extendByZeroₗᵢ (μ := (volume : Measure E)) (E := ℝ) (p := (2 : ℝ≥0∞)) + (s := K) hKm) u : E → ℝ) =ᵐ[(volume : Measure E)] + extendByZeroFun (E := E) (K := K) u := by +- simp [extendByZeroFun] + exact + (MeasureTheory.Lp.extendByZeroₗᵢ_ae_eq (μ := (volume : Measure E)) (E := ℝ) + (p := (2 : ℝ≥0∞)) (s := K) hKm u) +@@ -136,7 +137,7 @@ lemma norm_extendByZeroL2 (hKm : MeasurableSet K) + (u : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume.restrict K)) : + ‖extendByZeroL2 (E := E) (K := K) hKm u‖ = ‖u‖ := by + classical +- letI : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ ++ let : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ + calc + ‖extendByZeroL2 (E := E) (K := K) hKm u‖ = + ‖(MeasureTheory.Lp.extendByZeroₗᵢ (μ := (volume : Measure E)) (E := ℝ) (p := (2 : ℝ≥0∞)) +@@ -172,7 +173,7 @@ lemma continuous_smoothFun + exact hf_memLp.locallyIntegrable h12 + simpa [smoothFun] using + (hψcs.continuous_convolution_right +- (L := ContinuousLinearMap.lsmul ℝ ℝ) ++ («L» := ContinuousLinearMap.lsmul ℝ ℝ) + (μ := (volume : Measure E)) hf_loc hψc) + + lemma hasCompactSupport_smoothFun (hK : IsCompact K) (hψcs : HasCompactSupport ψ) +@@ -181,7 +182,7 @@ lemma hasCompactSupport_smoothFun (hK : IsCompact K) (hψcs : HasCompactSupport + have hf : HasCompactSupport (extendByZeroFun (K := K) u) := + hasCompactSupport_extendByZeroFun (K := K) hK u + simpa [smoothFun] using +- (hf.convolution (L := ContinuousLinearMap.lsmul ℝ ℝ) ++ (hf.convolution («L» := ContinuousLinearMap.lsmul ℝ ℝ) + (μ := (volume : Measure E)) hψcs) + + lemma support_smoothFun_subset_add_tsupport +@@ -192,7 +193,7 @@ lemma support_smoothFun_subset_add_tsupport + Function.support (smoothFun (E := E) (K := K) ψ u) ⊆ + Function.support (extendByZeroFun (E := E) (K := K) u) + Function.support ψ := by + simpa [smoothFun] using +- (support_convolution_subset (L := ContinuousLinearMap.lsmul ℝ ℝ) (μ := (volume : Measure E)) ++ (support_convolution_subset («L» := ContinuousLinearMap.lsmul ℝ ℝ) (μ := (volume : Measure E)) + (f := extendByZeroFun (E := E) (K := K) u) (g := ψ)) + have h1 : Function.support (extendByZeroFun (E := E) (K := K) u) ⊆ K := by + simp [extendByZeroFun] +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Transfer.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Transfer.lean +index 51414a8..2be859b 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Transfer.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/Transfer.lean +@@ -1,13 +1,13 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.ArzelaAscoli +-import Mathlib.MeasureTheory.Function.LpSpace.Basic +-import Mathlib.Topology.MetricSpace.Pseudo.Basic +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.ArzelaAscoli ++import Mathlib.MeasureTheory.Function.LpSpace.Basic ++import Mathlib.Topology.MetricSpace.Pseudo.Basic ++ + /-! + # `L²` compactness criterion: transfer from `BCF` compactness to `L²` (Euclidean) + +@@ -39,32 +39,217 @@ section Volume + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + +-local instance instMeasurableSpaceE_L2CompactnessTransfer : MeasurableSpace E := borel E +-local instance instBorelSpaceE_L2CompactnessTransfer : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_L2CompactnessTransfer : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceEL2CompactnessTransfer : MeasurableSpace E := borel E ++local instance instBorelSpaceEL2CompactnessTransfer : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceEL2CompactnessTransfer : OpensMeasurableSpace E := by + infer_instance +-local instance instMeasurableAddE_L2CompactnessTransfer : MeasurableAdd E := by ++local instance instMeasurableAddEL2CompactnessTransfer : MeasurableAdd E := by + infer_instance +-local instance instMeasurableNegE_L2CompactnessTransfer : MeasurableNeg E := by ++local instance instMeasurableNegEL2CompactnessTransfer : MeasurableNeg E := by + infer_instance + + variable {K : Set E} {ψ : E → ℝ} + ++private lemma dist_smoothL2_le_mul_dist_smoothBCF (hK : IsCompact K) (hKm : MeasurableSet K) ++ (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) : ++ ∀ u v : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume.restrict K), ++ dist (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u) ++ (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs v) ≤ ++ (MeasureTheory.measureUnivNNReal ((volume : Measure E).restrict (Kψ (K := K) (ψ := ψ)))) ^ ++ ((2 : ℝ≥0∞).toReal⁻¹) * ++ dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs v) := by ++ classical ++ let : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ ++ let s : Set E := Kψ (K := K) (ψ := ψ) ++ have hs_compact : IsCompact s := isCompact_Kψ (K := K) (ψ := ψ) hK hψcs ++ have hs : MeasurableSet s := hs_compact.measurableSet ++ have hs_lt_top : (volume : Measure E) s < (⊤ : ℝ≥0∞) := ++ hs_compact.measure_lt_top (μ := (volume : Measure E)) ++ let μs : Measure E := (volume : Measure E).restrict s ++ have : Fact ((volume : Measure E) s < (⊤ : ℝ≥0∞)) := ⟨hs_lt_top⟩ ++ have : IsFiniteMeasure μs := by ++ infer_instance ++ let mS : ℝ := (MeasureTheory.measureUnivNNReal μs) ^ ((2 : ℝ≥0∞).toReal⁻¹) ++ intro u v ++ set Su := ++ smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u ++ set Sv := ++ smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs v ++ set Bu := ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u ++ set Bv := ++ smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs v ++ have hBuBv : 0 ≤ ‖Bu - Bv‖ := norm_nonneg _ ++ -- Work on `F := Su - Sv` and restrict to the finite-measure set `s`. ++ let F : (E →₂[(volume : Measure E)] ℝ) := Su - Sv ++ let g : E → ℝ := fun x => (F : E → ℝ) x ++ have hg : MeasureTheory.MemLp g (2 : ℝ≥0∞) (volume : Measure E) := MeasureTheory.Lp.memLp F ++ have hg_restrict : MeasureTheory.MemLp g (2 : ℝ≥0∞) μs := hg.restrict s ++ let Fs : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μs := hg_restrict.toLp g ++ -- Show `Fs` is pointwise bounded by `‖Bu - Bv‖` on `μs`. ++ have hF_ae : ++ (g =ᵐ[μs] fun x : E => ++ smoothFun (E := E) (K := K) ψ u x - ++ smoothFun (E := E) (K := K) ψ v x) := by ++ have hsub : ++ (F : E → ℝ) =ᵐ[(volume : Measure E)] (Su : E → ℝ) - (Sv : E → ℝ) := by ++ simpa [F, g, Su, Sv] using ++ (MeasureTheory.Lp.coeFn_sub (μ := (volume : Measure E)) Su Sv) ++ have hu : ++ (Su : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ u := ++ smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs u ++ have hv : ++ (Sv : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ v := ++ smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs v ++ have hF : ++ (F : E → ℝ) =ᵐ[(volume : Measure E)] ++ fun x : E => ++ smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x := by ++ have h := hsub.trans (hu.sub hv) ++ filter_upwards [h] with x hx ++ simpa [Pi.sub_apply] using hx ++ exact MeasureTheory.ae_restrict_of_ae (μ := (volume : Measure E)) (s := s) hF ++ have hFs_ae : ((Fs : E → ℝ) =ᵐ[μs] g) := by ++ simpa [Fs, g] using ++ (MeasureTheory.MemLp.coeFn_toLp (μ := μs) (p := (2 : ℝ≥0∞)) (f := g) hg_restrict) ++ have hbound : ++ ∀ᵐ x ∂μs, ‖Fs x‖ ≤ ‖Bu - Bv‖ := by ++ have hpoint : ++ ∀ x : E, x ∈ s → ‖smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x‖ ≤ ++ ‖Bu - Bv‖ := by ++ intro x hx ++ let x' : ↥(Kψ (K := K) (ψ := ψ)) := ⟨x, hx⟩ ++ have hBu : Bu x' = smoothFun (E := E) (K := K) ψ u x := by ++ simp [Bu, x'] ++ have hBv : Bv x' = smoothFun (E := E) (K := K) ψ v x := by ++ simp [Bv, x'] ++ have : ‖(Bu - Bv) x'‖ ≤ ‖Bu - Bv‖ := ++ (Bu - Bv).norm_coe_le_norm x' ++ simpa [hBu, hBv] using this ++ filter_upwards ++ [MeasureTheory.ae_restrict_mem (μ := (volume : Measure E)) hs, ++ hFs_ae, hF_ae] with x hx hFs hF ++ have := hpoint x hx ++ -- rewrite through the AE equalities ++ simpa [hFs, hF] using this ++ have hnorm_Fs : ‖Fs‖ ≤ mS * ‖Bu - Bv‖ := by ++ have := (MeasureTheory.Lp.norm_le_of_ae_bound (μ := μs) (p := (2 : ℝ≥0∞)) ++ (f := Fs) (hC := hBuBv) hbound) ++ simpa [mS] using this ++ -- Relate the `L²` norm on `volume` to the restricted norm on `μs` using extension-by-zero. ++ have hsupport : ++ ∀ x : E, x ∉ s → ++ smoothFun (E := E) (K := K) ψ u x - ++ smoothFun (E := E) (K := K) ψ v x = 0 := by ++ intro x hx ++ have hu_supp : Function.support (smoothFun (E := E) (K := K) ψ u) ⊆ s := by ++ exact ++ (support_smoothFun_subset_add_tsupport (E := E) (K := K) (ψ := ψ) u) ++ have hv_supp : Function.support (smoothFun (E := E) (K := K) ψ v) ⊆ s := by ++ exact ++ (support_smoothFun_subset_add_tsupport (E := E) (K := K) (ψ := ψ) v) ++ have hu0 : smoothFun (E := E) (K := K) ψ u x = 0 := by ++ have : x ∉ Function.support (smoothFun (E := E) (K := K) ψ u) := fun hx' => hx (hu_supp hx') ++ simpa [Function.support] using this ++ have hv0 : smoothFun (E := E) (K := K) ψ v x = 0 := by ++ have : x ∉ Function.support (smoothFun (E := E) (K := K) ψ v) := fun hx' => hx (hv_supp hx') ++ simpa [Function.support] using this ++ simp [hu0, hv0] ++ have hF0 : ++ ∀ᵐ x ∂(volume : Measure E), x ∉ s → g x = 0 := by ++ have hF_ae_full : ++ (g =ᵐ[(volume : Measure E)] ++ fun x : E => ++ smoothFun (E := E) (K := K) ψ u x - ++ smoothFun (E := E) (K := K) ψ v x) := by ++ have hsub : ++ (F : E → ℝ) =ᵐ[(volume : Measure E)] (Su : E → ℝ) - (Sv : E → ℝ) := by ++ simpa [F, g, Su, Sv] using ++ (MeasureTheory.Lp.coeFn_sub (μ := (volume : Measure E)) Su Sv) ++ have hu : ++ (Su : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ u := ++ smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs u ++ have hv : ++ (Sv : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ v := ++ smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs v ++ have hF : ++ (F : E → ℝ) =ᵐ[(volume : Measure E)] ++ fun x : E => ++ smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x := by ++ have h := hsub.trans (hu.sub hv) ++ filter_upwards [h] with x hx ++ simpa [Pi.sub_apply] using hx ++ simpa [g] using hF ++ filter_upwards [hF_ae_full] with x hx ++ intro hxnot ++ have : smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x = 0 := ++ hsupport x hxnot ++ simpa [hx] using this ++ have hF_ind : ++ (s.indicator g =ᵐ[(volume : Measure E)] g) := by ++ filter_upwards [hF0] with x hx ++ by_cases hxmem : x ∈ s ++ · simp [g, hxmem] ++ · have : g x = 0 := hx hxmem ++ simp [g, hxmem, this] ++ -- Conclude `‖F‖ = ‖Fs‖` using `extendByZeroₗᵢ` and the indicator identity. ++ let Fext : ++ MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume : Measure E) := ++ (MeasureTheory.Lp.extendByZeroₗᵢ (μ := (volume : Measure E)) (E := ℝ) (p := (2 : ℝ≥0∞)) ++ (s := s) hs) Fs ++ have hFext_ae : ++ ((Fext : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume : Measure E)) : ++ E → ℝ) =ᵐ[(volume : Measure E)] ++ s.indicator fun x : E => (Fs : E → ℝ) x := by ++ simpa [Fext] using ++ (MeasureTheory.Lp.extendByZeroₗᵢ_ae_eq ++ (μ := (volume : Measure E)) (p := (2 : ℝ≥0∞)) ++ (s := s) hs Fs) ++ have hFs_on : ++ ∀ᵐ x ∂(volume : Measure E), x ∈ s → (Fs : E → ℝ) x = g x := by ++ -- rewrite the AE equality `Fs = g` on the restricted measure as an implication on `volume` ++ have := (MeasureTheory.ae_restrict_iff' (μ := (volume : Measure E)) (s := s) hs).1 hFs_ae ++ simpa [g] using this ++ have hindicator : ++ (s.indicator (fun x : E => (Fs : E → ℝ) x) =ᵐ[(volume : Measure E)] s.indicator g) := by ++ filter_upwards [hFs_on] with x hx ++ by_cases hxmem : x ∈ s ++ · simp [hxmem, hx hxmem] ++ · simp [hxmem] ++ have hFext_ae' : ++ (Fext : E → ℝ) =ᵐ[(volume : Measure E)] g := by ++ exact hFext_ae.trans (hindicator.trans hF_ind) ++ have hFext_eq : Fext = F := by ++ refine MeasureTheory.Lp.ext ?_ ++ simpa [g, F] using hFext_ae' ++ have hnorm_F : ‖F‖ ≤ mS * ‖Bu - Bv‖ := by ++ -- use `‖F‖ = ‖Fs‖` via the isometry. ++ have hnorm_ext : ‖Fext‖ = ‖Fs‖ := by ++ simp [Fext] ++ -- `Fext = F` and `Fs` is bounded. ++ have : ‖Fext‖ ≤ mS * ‖Bu - Bv‖ := by ++ simpa [hnorm_ext] using hnorm_Fs ++ simpa [hFext_eq] using this ++ -- Convert to the `dist` statement. ++ simpa [Su, Sv, Bu, Bv, F, dist_eq_norm, mS, mul_assoc] using hnorm_F ++ + theorem smoothL2_image_closedBall_isCompact (hK : IsCompact K) (hKm : MeasurableSet K) + (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) {R : ℝ} (hR : 0 ≤ R) : + IsCompact + (closure + (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs '' Metric.closedBall (0 : _) R)) := by + classical +- letI : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ ++ let : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ + let s : Set E := Kψ (K := K) (ψ := ψ) + have hs_compact : IsCompact s := isCompact_Kψ (K := K) (ψ := ψ) hK hψcs + have hs : MeasurableSet s := hs_compact.measurableSet +- have hs_lt_top : (volume : Measure E) s < ∞ := ++ have hs_lt_top : (volume : Measure E) s < (⊤ : ℝ≥0∞) := + hs_compact.measure_lt_top (μ := (volume : Measure E)) + let μs : Measure E := (volume : Measure E).restrict s +- haveI : Fact ((volume : Measure E) s < ∞) := ⟨hs_lt_top⟩ +- haveI : IsFiniteMeasure μs := by ++ have : Fact ((volume : Measure E) s < (⊤ : ℝ≥0∞)) := ⟨hs_lt_top⟩ ++ have : IsFiniteMeasure μs := by + infer_instance + let mS : ℝ := (MeasureTheory.measureUnivNNReal μs) ^ ((2 : ℝ≥0∞).toReal⁻¹) + have hmS : 0 ≤ mS := by +@@ -79,178 +264,14 @@ theorem smoothL2_image_closedBall_isCompact (hK : IsCompact K) (hKm : Measurable + smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs '' U + have hA_compact : IsCompact (closure A) := + smoothBCF_image_closedBall_isCompact (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs (R := R) hR +- have hdist_smoothL2_le : +- ∀ u v : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume.restrict K), +- dist (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u) +- (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs v) ≤ +- mS * +- dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs v) := by +- intro u v +- set Su := +- smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u +- set Sv := +- smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs v +- set Bu := +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u +- set Bv := +- smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs v +- have hBuBv : 0 ≤ ‖Bu - Bv‖ := norm_nonneg _ +- -- Work on `F := Su - Sv` and restrict to the finite-measure set `s`. +- let F : (E →₂[(volume : Measure E)] ℝ) := Su - Sv +- let g : E → ℝ := fun x => (F : E → ℝ) x +- have hg : MeasureTheory.MemLp g (2 : ℝ≥0∞) (volume : Measure E) := MeasureTheory.Lp.memLp F +- have hg_restrict : MeasureTheory.MemLp g (2 : ℝ≥0∞) μs := hg.restrict s +- let Fs : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) μs := hg_restrict.toLp g +- -- Show `Fs` is pointwise bounded by `‖Bu - Bv‖` on `μs`. +- have hF_ae : +- (g =ᵐ[μs] fun x : E => +- smoothFun (E := E) (K := K) ψ u x - +- smoothFun (E := E) (K := K) ψ v x) := by +- have hsub : +- (F : E → ℝ) =ᵐ[(volume : Measure E)] (Su : E → ℝ) - (Sv : E → ℝ) := by +- simpa [F, g, Su, Sv] using +- (MeasureTheory.Lp.coeFn_sub (μ := (volume : Measure E)) Su Sv) +- have hu : +- (Su : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ u := +- smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs u +- have hv : +- (Sv : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ v := +- smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs v +- have hF : +- (F : E → ℝ) =ᵐ[(volume : Measure E)] +- fun x : E => +- smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x := by +- simpa [Pi.sub_apply] using hsub.trans (hu.sub hv) +- exact MeasureTheory.ae_restrict_of_ae (μ := (volume : Measure E)) (s := s) hF +- have hFs_ae : ((Fs : E → ℝ) =ᵐ[μs] g) := by +- simpa [Fs, g] using +- (MeasureTheory.MemLp.coeFn_toLp (μ := μs) (p := (2 : ℝ≥0∞)) (f := g) hg_restrict) +- have hbound : +- ∀ᵐ x ∂μs, ‖Fs x‖ ≤ ‖Bu - Bv‖ := by +- have hpoint : +- ∀ x : E, x ∈ s → ‖smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x‖ ≤ +- ‖Bu - Bv‖ := by +- intro x hx +- let x' : ↥(Kψ (K := K) (ψ := ψ)) := ⟨x, hx⟩ +- have hBu : Bu x' = smoothFun (E := E) (K := K) ψ u x := by +- simp [Bu, x'] +- have hBv : Bv x' = smoothFun (E := E) (K := K) ψ v x := by +- simp [Bv, x'] +- have : ‖(Bu - Bv) x'‖ ≤ ‖Bu - Bv‖ := +- (Bu - Bv).norm_coe_le_norm x' +- simpa [hBu, hBv] using this +- filter_upwards +- [MeasureTheory.ae_restrict_mem (μ := (volume : Measure E)) hs, +- hFs_ae, hF_ae] with x hx hFs hF +- have := hpoint x hx +- -- rewrite through the AE equalities +- simpa [hFs, hF] using this +- have hnorm_Fs : ‖Fs‖ ≤ mS * ‖Bu - Bv‖ := by +- have := (MeasureTheory.Lp.norm_le_of_ae_bound (μ := μs) (p := (2 : ℝ≥0∞)) +- (f := Fs) (hC := hBuBv) hbound) +- simpa [mS] using this +- -- Relate the `L²` norm on `volume` to the restricted norm on `μs` using extension-by-zero. +- have hsupport : +- ∀ x : E, x ∉ s → +- smoothFun (E := E) (K := K) ψ u x - +- smoothFun (E := E) (K := K) ψ v x = 0 := by +- intro x hx +- have hu_supp : Function.support (smoothFun (E := E) (K := K) ψ u) ⊆ s := by +- simpa [s] using +- (support_smoothFun_subset_add_tsupport (E := E) (K := K) (ψ := ψ) u) +- have hv_supp : Function.support (smoothFun (E := E) (K := K) ψ v) ⊆ s := by +- simpa [s] using +- (support_smoothFun_subset_add_tsupport (E := E) (K := K) (ψ := ψ) v) +- have hu0 : smoothFun (E := E) (K := K) ψ u x = 0 := by +- have : x ∉ Function.support (smoothFun (E := E) (K := K) ψ u) := fun hx' => hx (hu_supp hx') +- simpa [Function.support] using this +- have hv0 : smoothFun (E := E) (K := K) ψ v x = 0 := by +- have : x ∉ Function.support (smoothFun (E := E) (K := K) ψ v) := fun hx' => hx (hv_supp hx') +- simpa [Function.support] using this +- simp [hu0, hv0] +- have hF0 : +- ∀ᵐ x ∂(volume : Measure E), x ∉ s → g x = 0 := by +- have hF_ae_full : +- (g =ᵐ[(volume : Measure E)] +- fun x : E => +- smoothFun (E := E) (K := K) ψ u x - +- smoothFun (E := E) (K := K) ψ v x) := by +- have hsub : +- (F : E → ℝ) =ᵐ[(volume : Measure E)] (Su : E → ℝ) - (Sv : E → ℝ) := by +- simpa [F, g, Su, Sv] using +- (MeasureTheory.Lp.coeFn_sub (μ := (volume : Measure E)) Su Sv) +- have hu : +- (Su : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ u := +- smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs u +- have hv : +- (Sv : E → ℝ) =ᵐ[(volume : Measure E)] smoothFun (E := E) (K := K) ψ v := +- smoothL2_ae_eq (E := E) (K := K) (ψ := ψ) (hK := hK) (hKm := hKm) hψc hψcs v +- have hF : +- (F : E → ℝ) =ᵐ[(volume : Measure E)] +- fun x : E => +- smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x := by +- simpa [Pi.sub_apply] using hsub.trans (hu.sub hv) +- simpa [g] using hF +- filter_upwards [hF_ae_full] with x hx +- intro hxnot +- have : smoothFun (E := E) (K := K) ψ u x - smoothFun (E := E) (K := K) ψ v x = 0 := +- hsupport x hxnot +- simpa [hx] using this +- have hF_ind : +- (s.indicator g =ᵐ[(volume : Measure E)] g) := by +- filter_upwards [hF0] with x hx +- by_cases hxmem : x ∈ s +- · simp [g, hxmem] +- · have : g x = 0 := hx hxmem +- simp [g, hxmem, this] +- -- Conclude `‖F‖ = ‖Fs‖` using `extendByZeroₗᵢ` and the indicator identity. +- let Fext : +- MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume : Measure E) := +- (MeasureTheory.Lp.extendByZeroₗᵢ (μ := (volume : Measure E)) (E := ℝ) (p := (2 : ℝ≥0∞)) +- (s := s) hs) Fs +- have hFext_ae : +- ((Fext : MeasureTheory.Lp ℝ (2 : ℝ≥0∞) (volume : Measure E)) : +- E → ℝ) =ᵐ[(volume : Measure E)] +- s.indicator fun x : E => (Fs : E → ℝ) x := by +- simpa [Fext] using +- (MeasureTheory.Lp.extendByZeroₗᵢ_ae_eq +- (μ := (volume : Measure E)) (p := (2 : ℝ≥0∞)) +- (s := s) hs Fs) +- have hFs_on : +- ∀ᵐ x ∂(volume : Measure E), x ∈ s → (Fs : E → ℝ) x = g x := by +- -- rewrite the AE equality `Fs = g` on the restricted measure as an implication on `volume` +- have := (MeasureTheory.ae_restrict_iff' (μ := (volume : Measure E)) (s := s) hs).1 hFs_ae +- simpa [g] using this +- have hindicator : +- (s.indicator (fun x : E => (Fs : E → ℝ) x) =ᵐ[(volume : Measure E)] s.indicator g) := by +- filter_upwards [hFs_on] with x hx +- by_cases hxmem : x ∈ s +- · simp [hxmem, hx hxmem] +- · simp [hxmem] +- have hFext_ae' : +- (Fext : E → ℝ) =ᵐ[(volume : Measure E)] g := by +- exact hFext_ae.trans (hindicator.trans hF_ind) +- have hFext_eq : Fext = F := by +- refine MeasureTheory.Lp.ext ?_ +- simpa [g, F] using hFext_ae' +- have hnorm_F : ‖F‖ ≤ mS * ‖Bu - Bv‖ := by +- -- use `‖F‖ = ‖Fs‖` via the isometry. +- have hnorm_ext : ‖Fext‖ = ‖Fs‖ := by +- simp [Fext] +- -- `Fext = F` and `Fs` is bounded. +- have : ‖Fext‖ ≤ mS * ‖Bu - Bv‖ := by +- simpa [hnorm_ext] using hnorm_Fs +- simpa [hFext_eq] using this +- -- Convert to the `dist` statement. +- simpa [Su, Sv, Bu, Bv, F, dist_eq_norm, mS, mul_assoc] using hnorm_F ++ have hdist_smoothL2_le := ++ dist_smoothL2_le_mul_dist_smoothBCF (K := K) (ψ := ψ) hK hKm hψc hψcs + have hTB_B : TotallyBounded B := by + -- Use a finite `BCF` ε-net for `A` with centers in the image, then transfer to `L²`. + rw [Metric.totallyBounded_iff] + intro ε hε + by_cases hmS0 : mS = 0 +- · +- let c : (E →₂[(volume : Measure E)] ℝ) := ++ · let c : (E →₂[(volume : Measure E)] ℝ) := + smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs (0 : _) + refine ⟨{c}, by simp [c], ?_⟩ + intro w hw +@@ -260,9 +281,15 @@ theorem smoothL2_image_closedBall_isCompact (hK : IsCompact K) (hKm : Measurable + have hdist0 : + dist (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u) + c = 0 := by ++ have hmS0' : ++ (MeasureTheory.measureUnivNNReal ((volume : Measure E).restrict s) : ℝ) ^ ++ ((2 : ℝ≥0∞).toReal⁻¹) = 0 := hmS0 + have : + dist (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u) c ≤ 0 := by +- simpa [c, hmS0] using hle ++ have hle' := hle ++ simp only [s] at hmS0' ++ rw [hmS0', zero_mul] at hle' ++ simpa [c] using hle' + exact le_antisymm this dist_nonneg + refine mem_iUnion.2 ?_ + refine ⟨c, mem_iUnion.2 ?_⟩ +@@ -270,10 +297,10 @@ theorem smoothL2_image_closedBall_isCompact (hK : IsCompact K) (hKm : Measurable + -- membership in the open ball follows from `dist = 0` and `ε > 0` + simpa [Metric.mem_ball, hdist0] using hε + · have hmSpos : 0 < mS := lt_of_le_of_ne hmS (Ne.symm hmS0) +- let δ : ℝ := ε / mS +- have hδpos : 0 < δ := div_pos hε hmSpos ++ let deltaLoss : ℝ := ε / mS ++ have hδpos : 0 < deltaLoss := div_pos hε hmSpos + obtain ⟨t, htAsub, htFin, htCover⟩ := +- exists_finite_cover_balls_of_isCompact_closure (s := A) (ε := δ) hA_compact hδpos ++ exists_finite_cover_balls_of_isCompact_closure (s := A) (ε := deltaLoss) hA_compact hδpos + let tFin : Finset (BoundedContinuousFunction (↥(Kψ (K := K) (ψ := ψ))) ℝ) := + htFin.toFinset + have htFin_mem : +@@ -300,14 +327,14 @@ theorem smoothL2_image_closedBall_isCompact (hK : IsCompact K) (hKm : Measurable + rcases hw with ⟨u, huU, rfl⟩ + have hBu : (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) ∈ A := by + exact ⟨u, huU, rfl⟩ +- have : smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u ∈ ⋃ x ∈ t, Metric.ball x δ := ++ have : smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u ∈ ⋃ x ∈ t, Metric.ball x deltaLoss := + htCover hBu + rcases mem_iUnion.1 this with ⟨f, hf⟩ + rcases mem_iUnion.1 hf with ⟨hf_t, hf_ball⟩ + have hf_tFin : f ∈ tFin := (htFin_mem (f := f)).2 hf_t + let f' : ι := ⟨f, hf_tFin⟩ + have hf_ball' : +- dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) f < δ := hf_ball ++ dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) f < deltaLoss := hf_ball + have hdist : + dist (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs u) + (smoothL2 (E := E) (K := K) ψ hK hKm hψc hψcs (uOf f')) < ε := by +@@ -317,17 +344,17 @@ theorem smoothL2_image_closedBall_isCompact (hK : IsCompact K) (hKm : Measurable + simpa [f'] using huOfEq f' + have hdist' : + dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs (uOf f')) < δ := by ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs (uOf f')) < deltaLoss := by + simpa [hf_eq] using hf_ball' + have : mS * dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) + (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs (uOf f')) < ε := by + have : mS * dist (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs u) +- (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs (uOf f')) < mS * δ := by ++ (smoothBCF (E := E) (K := K) (ψ := ψ) hK hKm hψc hψcs (uOf f')) < mS * deltaLoss := by + exact mul_lt_mul_of_pos_left hdist' hmSpos +- have hmul : mS * δ = ε := by ++ have hmul : mS * deltaLoss = ε := by + have hmS_ne : mS ≠ 0 := ne_of_gt hmSpos + calc +- mS * δ = mS * (ε / mS) := by simp [δ] ++ mS * deltaLoss = mS * (ε / mS) := by simp [deltaLoss] + _ = mS * ε / mS := (mul_div_assoc mS ε mS).symm + _ = ε := by simpa using (mul_div_cancel_left₀ ε hmS_ne) + simpa [hmul] using this +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/TranslationIntegral.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/TranslationIntegral.lean +index cdb4346..6914c2a 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/TranslationIntegral.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/L2Compactness/TranslationIntegral.lean +@@ -1,13 +1,13 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Approximation +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.Translation +-import Mathlib.MeasureTheory.Integral.Bochner.Basic +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Approximation ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.Translation ++import Mathlib.MeasureTheory.Integral.Bochner.Basic ++ + /-! + # `L²` compactness criterion: bounding the translation-integral by a translation modulus + +@@ -38,59 +38,60 @@ section Volume + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + +-local instance instMeasurableSpaceE_L2CompactnessTranslationIntegral : MeasurableSpace E := borel E +-local instance instBorelSpaceE_L2CompactnessTranslationIntegral : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_L2CompactnessTranslationIntegral : ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceEL2CompactnessTranslationIntegral : MeasurableSpace E := borel E ++local instance instBorelSpaceEL2CompactnessTranslationIntegral : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceEL2CompactnessTranslationIntegral : + OpensMeasurableSpace E := by infer_instance +-local instance instMeasurableAddE_L2CompactnessTranslationIntegral : MeasurableAdd E := by ++local instance instMeasurableAddEL2CompactnessTranslationIntegral : MeasurableAdd E := by + infer_instance +-local instance instMeasurableNegE_L2CompactnessTranslationIntegral : MeasurableNeg E := by ++local instance instMeasurableNegEL2CompactnessTranslationIntegral : MeasurableNeg E := by + infer_instance + + variable {ψ : E → ℝ} + +-private lemma kernelMeasure_compl_ball_eq_zero_of_tsupport_subset {δ : ℝ} +- (hψsupp : tsupport ψ ⊆ Metric.ball (0 : E) δ) : +- kernelMeasure (E := E) ψ ((Metric.ball (0 : E) δ)ᶜ) = 0 := by ++private lemma kernelMeasure_compl_ball_eq_zero_of_tsupport_subset {deltaLoss : ℝ} ++ (hψsupp : tsupport ψ ⊆ Metric.ball (0 : E) deltaLoss) : ++ kernelMeasure (E := E) ψ ((Metric.ball (0 : E) deltaLoss)ᶜ) = 0 := by + classical +- have hψzero : ∀ x : E, x ∈ (Metric.ball (0 : E) δ)ᶜ → ψ x = 0 := by ++ have hψzero : ∀ x : E, x ∈ (Metric.ball (0 : E) deltaLoss)ᶜ → ψ x = 0 := by + intro x hx + have hx' : x ∉ tsupport ψ := by + intro hx_ts + exact hx (hψsupp hx_ts) + exact image_eq_zero_of_notMem_tsupport (f := ψ) hx' +- have hmeas : MeasurableSet ((Metric.ball (0 : E) δ)ᶜ) := +- (measurableSet_ball : MeasurableSet (Metric.ball (0 : E) δ)).compl ++ have hmeas : MeasurableSet ((Metric.ball (0 : E) deltaLoss)ᶜ) := ++ (measurableSet_ball : MeasurableSet (Metric.ball (0 : E) deltaLoss)).compl + have hEq : +- Set.EqOn (fun x : E => ENNReal.ofReal (ψ x)) 0 ((Metric.ball (0 : E) δ)ᶜ) := by ++ Set.EqOn (fun x : E => ENNReal.ofReal (ψ x)) 0 ((Metric.ball (0 : E) deltaLoss)ᶜ) := by + intro x hx + simp [hψzero x hx] + -- Expand `kernelMeasure` and note the density is identically `0` on the set. + simp [kernelMeasure, MeasureTheory.withDensity_apply, hmeas, + MeasureTheory.setLIntegral_eq_zero + (μ := (volume : Measure E)) +- (s := (Metric.ball (0 : E) δ)ᶜ) hmeas hEq] ++ (s := (Metric.ball (0 : E) deltaLoss)ᶜ) hmeas hEq] + + theorem integral_norm_sq_translateL2_sub_le_sq_of_tsupport_subset_ball + (hψc : Continuous ψ) (hψcs : HasCompactSupport ψ) (hψ0 : ∀ x, 0 ≤ ψ x) + (hψint : ∫ x, ψ x ∂(volume : Measure E) = 1) +- {δ η : ℝ} (hη : 0 ≤ η) (hψsupp : tsupport ψ ⊆ Metric.ball (0 : E) δ) ++ {deltaLoss η : ℝ} (hη : 0 ≤ η) (hψsupp : tsupport ψ ⊆ Metric.ball (0 : E) deltaLoss) + (F : (E →₂[(volume : Measure E)] ℝ)) + (hmod : +- ∀ t : E, t ∈ Metric.ball (0 : E) δ → ++ ∀ t : E, t ∈ Metric.ball (0 : E) deltaLoss → + ‖(translateL2 (μ := (volume : Measure E)) (-t)) F - F‖ ≤ η) : + ∫ t, + ‖(translateL2 (μ := (volume : Measure E)) (-t)) F - F‖ ^ 2 + ∂kernelMeasure (E := E) ψ ≤ η ^ 2 := by + classical + let μ : Measure E := kernelMeasure (E := E) ψ +- haveI : MeasureTheory.IsProbabilityMeasure μ := ++ have : MeasureTheory.IsProbabilityMeasure μ := + ⟨kernelMeasure_univ (E := E) (ψ := ψ) hψc hψcs hψ0 hψint⟩ +- have hμzero : μ ((Metric.ball (0 : E) δ)ᶜ) = 0 := by ++ have hμzero : μ ((Metric.ball (0 : E) deltaLoss)ᶜ) = 0 := by + simpa [μ] using kernelMeasure_compl_ball_eq_zero_of_tsupport_subset (E := E) (ψ := ψ) hψsupp +- have hAE_ball : (Metric.ball (0 : E) δ) ∈ MeasureTheory.ae μ := ++ have hAE_ball : (Metric.ball (0 : E) deltaLoss) ∈ MeasureTheory.ae μ := + (MeasureTheory.mem_ae_iff.2 hμzero) +- -- On `Metric.ball 0 δ`, the squared translation error is bounded by `η²`. ++ -- On `Metric.ball 0 deltaLoss`, the squared translation error is bounded by `η²`. + have hAE_bound : + ∀ᵐ t : E ∂μ, + ‖‖(translateL2 (μ := (volume : Measure E)) (-t)) F - F‖ ^ 2‖ ≤ η ^ 2 := by +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Rellich.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Rellich.lean +index 4cd9bb3..b133aa6 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Rellich.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Rellich.lean +@@ -1,19 +1,16 @@ +-import Mathlib.Analysis.Normed.Operator.Compact +-import Mathlib.MeasureTheory.Measure.Lebesgue.Basic +-import Mathlib.MeasureTheory.Function.LpSpace.Complete +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimateH1 +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.FrechetKolmogorov +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Kernels +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.TranslationIntegral +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + +-set_option linter.unusedTactic false +-set_option linter.unreachableTactic false ++import Mathlib.Analysis.Normed.Operator.Compact.Basic ++import Mathlib.MeasureTheory.Measure.Lebesgue.Basic ++import Mathlib.MeasureTheory.Function.LpSpace.Complete ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimateH1 ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.FrechetKolmogorov ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.Kernels ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.L2Compactness.TranslationIntegral + + /-! + # `RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.Rellich` +@@ -59,15 +56,16 @@ section Volume + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] + [CompleteSpace E] + +-local instance instMeasurableSpaceE_SobolevEuclideanRellich : MeasurableSpace E := borel E +-local instance instBorelSpaceE_SobolevEuclideanRellich : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_SobolevEuclideanRellich : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceRellich : MeasurableSpace E := borel E ++local instance instBorelSpaceRellich : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceRellich : OpensMeasurableSpace E := by + infer_instance +-local instance instMeasurableAddE_SobolevEuclideanRellich : MeasurableAdd E := by ++local instance instMeasurableAddRellich : MeasurableAdd E := by + infer_instance +-local instance instMeasurableNegE_SobolevEuclideanRellich : MeasurableNeg E := by ++local instance instMeasurableNegRellich : MeasurableNeg E := by + infer_instance +-local instance instFactOneLeTwo_SobolevEuclideanRellich : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ ++local instance instFactOneLeTwoSobolevEuclideanRellich : Fact (1 ≤ (2 : ℝ≥0∞)) := ⟨by norm_num⟩ + + /-! ### Supported `H¹` subspace -/ + +@@ -90,7 +88,6 @@ noncomputable def h1OnToL2 (K : Set E) (hKm : MeasurableSet K) : + + /-! ### Euclidean Rellich on fixed compact support -/ + +-set_option maxHeartbeats 2000000 in + /-- Euclidean Rellich–Kondrachov compactness (Lebesgue): on a fixed compact support `K`, the + inclusion `H¹ → L²` is a compact operator. -/ + theorem isCompactOperator_h1OnToL2 {K : Set E} (_hK : IsCompact K) (hKm : MeasurableSet K) : +@@ -105,10 +102,9 @@ theorem isCompactOperator_h1OnToL2 {K : Set E} (_hK : IsCompact K) (hKm : Measur + L2Compactness.extendByZeroL2 (E := E) (K := K) hKm u ∈ + T '' Metric.closedBall (0 : ↥(h1On (E := E) K hKm)) 1} + let C : ℝ := +- (h1ToL2 (μ := (volume : Measure E)) (E := E)).opNorm ++ ‖h1ToL2 (μ := (volume : Measure E)) (E := E)‖ + have hCnonneg : 0 ≤ C := by +- dsimp [C] +- exact (h1ToL2 (μ := (volume : Measure E)) (E := E)).opNorm_nonneg ++ exact norm_nonneg (h1ToL2 (μ := (volume : Measure E)) (E := E)) + have hA_ball : + A ⊆ + Metric.closedBall +@@ -119,7 +115,7 @@ theorem isCompactOperator_h1OnToL2 {K : Set E} (_hK : IsCompact K) (hKm : Measur + have hx' : ‖(x : H1vol)‖ ≤ (1 : ℝ) := by + -- `h1On` inherits the ambient norm, so this is definitional. + change ‖x‖ ≤ (1 : ℝ) +- exact (mem_closedBall_zero_iff.mp hx) ++ simpa only [Metric.mem_closedBall,dist_zero_right x] using hx + have hTx' : ‖T x‖ ≤ C := by + have hTx : ‖T x‖ ≤ C * ‖(x : H1vol)‖ := by + have h := +@@ -150,20 +146,20 @@ theorem isCompactOperator_h1OnToL2 {K : Set E} (_hK : IsCompact K) (hKm : Measur + have hδ : 0 < ε / 2 := by linarith + rcases + L2Compactness.exists_kernel_tsupport_subset_ball_integral_eq_one +- (E := E) (δ := ε / 2) hδ with ++ (E := E) (deltaLoss := ε / 2) hδ with + ⟨ψ, hψc, hψcs, hψ0, hψint, hψsupp⟩ + refine ⟨ψ, hψc, hψcs, hψ0, hψint, ?_⟩ + intro u huA + rcases huA with ⟨x, hx, hxEq⟩ + have hxH1 : ‖(x : H1vol)‖ ≤ (1 : ℝ) := by + change ‖x‖ ≤ (1 : ℝ) +- exact (mem_closedBall_zero_iff.mp hx) ++ simpa only [Metric.mem_closedBall,dist_zero_right x] using hx + have hmod : + ∀ t : E, t ∈ Metric.ball (0 : E) (ε / 2) → + ‖(translateL2 (μ := (volume : Measure E)) (-t)) (T x) - T x‖ ≤ ε / 2 := by + intro t ht + have ht' : ‖t‖ ≤ ε / 2 := le_of_lt (by +- simpa [Metric.ball, dist_eq_norm, mem_setOf_eq] using ht) ++ simpa [Metric.ball, dist_eq_norm, mem_ofPred_eq] using ht) + have hgrad_le : + ‖h1ToL2Grad (μ := (volume : Measure E)) (E := E) (x : H1vol)‖ ≤ ‖(x : H1vol)‖ := by + let V : Type _ := (E →₂[(volume : Measure E)] ℝ) × (E →₂[(volume : Measure E)] E) +@@ -192,7 +188,7 @@ theorem isCompactOperator_h1OnToL2 {K : Set E} (_hK : IsCompact K) (hKm : Measur + have hη : 0 ≤ ε / 2 := le_of_lt hδ + have hbound := + L2Compactness.integral_norm_sq_translateL2_sub_le_sq_of_tsupport_subset_ball +- (E := E) (ψ := ψ) hψc hψcs hψ0 hψint (δ := ε / 2) (η := ε / 2) hη hψsupp (T x) hmod ++ (E := E) (ψ := ψ) hψc hψcs hψ0 hψint (deltaLoss := ε / 2) (η := ε / 2) hη hψsupp (T x) hmod + simpa [hxEq] using hbound + have hcomp : IsCompact (closure (T '' Metric.closedBall (0 : ↥(h1On (E := E) K hKm)) 1)) := by + have hR : 0 ≤ C := hCnonneg +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Translation.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Translation.lean +index c009eb8..f3b80d4 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Translation.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/Translation.lean +@@ -1,15 +1,15 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.H1 +-import Mathlib.Analysis.Calculus.FDeriv.Add +-import Mathlib.MeasureTheory.Group.Measure +-import Mathlib.MeasureTheory.Function.LpSpace.Basic +-import Mathlib.Topology.Algebra.Group.Basic +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.H1 ++import Mathlib.Analysis.Calculus.FDeriv.Add ++import Mathlib.MeasureTheory.Group.Measure ++import Mathlib.MeasureTheory.Function.LpSpace.Basic ++import Mathlib.Topology.Algebra.Group.Basic ++ + /-! + # `RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.Translation` + +@@ -47,20 +47,21 @@ omit [CompleteSpace E] in + lemma contDiff_translate {f : E → ℝ} (hf : ContDiff ℝ 1 f) (a : E) : + ContDiff ℝ 1 (translate (E := E) a f) := by + -- `x ↦ x + a` is `C^∞`; compose. +- simpa [translate] using hf.comp (contDiff_id.add contDiff_const) ++ exact hf.comp (contDiff_id.add contDiff_const) + + omit [InnerProductSpace ℝ E] [CompleteSpace E] in + lemma hasCompactSupport_translate {F : Type*} [Zero F] {f : E → F} + (hf : HasCompactSupport f) (a : E) : HasCompactSupport (translate (E := E) a f) := by +- simpa [translate] using hf.comp_homeomorph (Homeomorph.addRight a) ++ exact hf.comp_homeomorph (Homeomorph.addRight a) + + lemma grad_translate (a : E) (f : E → ℝ) (x : E) : + grad (E := E) (translate (E := E) a f) x = grad (E := E) f (x + a) := by + classical + -- `fderiv` commutes with translation, hence so does `grad`. +- simp [grad] +- -- Reduce to the standard `fderiv` translation lemma. +- simpa [translate] using (fderiv_comp_add_right (𝕜 := ℝ) (f := f) (x := x) a) ++ -- Reduce to the standard `fderiv` translation lemma, applied under the Riesz dual map. ++ have hfderiv : fderiv ℝ (translate (E := E) a f) x = fderiv ℝ f (x + a) := ++ fderiv_comp_add_right (𝕜 := ℝ) (f := f) (x := x) a ++ simp only [grad, hfderiv] + + omit [CompleteSpace E] in + lemma mem_C1c_translate {f : E → ℝ} (hf : f ∈ C1c (E := E)) (a : E) : +@@ -83,11 +84,12 @@ section Measure + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] + +-local instance instMeasurableSpaceE_SobolevEuclideanTranslation : MeasurableSpace E := borel E +-local instance instBorelSpaceE_SobolevEuclideanTranslation : BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_SobolevEuclideanTranslation : OpensMeasurableSpace E := by ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceTranslation : MeasurableSpace E := borel E ++local instance instBorelSpaceTranslation : BorelSpace E := ⟨rfl⟩ ++local instance instOpensMeasurableSpaceTranslation : OpensMeasurableSpace E := by + infer_instance +-local instance instMeasurableAddE_SobolevEuclideanTranslation : MeasurableAdd E := by ++local instance instMeasurableAddTranslation : MeasurableAdd E := by + infer_instance + + variable (μ : Measure E) [μ.IsAddRightInvariant] +@@ -106,7 +108,7 @@ lemma translateL2_ae_eq {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] ( + (translateL2 (μ := μ) (F := F) a g : E → F) =ᵐ[μ] fun x => (g : E → F) (x + a) := by + classical + -- Reduce to `Lp.coeFn_compMeasurePreserving`. +- simpa [translateL2] using ++ exact + (MeasureTheory.Lp.coeFn_compMeasurePreserving (g := (g : MeasureTheory.Lp F (2 : ENNReal) μ)) + (hf := MeasureTheory.measurePreserving_add_right μ a)) + +@@ -125,7 +127,7 @@ lemma translateL2_toL2 (a : E) (f : ↥(C1c (E := E))) : + have hf' : + (fun x => (toL2 (μ := μ) (E := E) f : E → ℝ) (x + a)) =ᵐ[μ] fun x => f.1 (x + a) := by + -- Move the a.e. equality through a measure-preserving map. +- simpa [Function.comp, Pi.add_apply] using ++ exact + (Measure.QuasiMeasurePreserving.ae_eq_comp + (MeasureTheory.measurePreserving_add_right μ a).quasiMeasurePreserving hf) + exact (translateL2_ae_eq (μ := μ) (F := ℝ) a (toL2 (μ := μ) (E := E) f)).trans hf' +@@ -133,7 +135,7 @@ lemma translateL2_toL2 (a : E) (f : ↥(C1c (E := E))) : + (toL2 (μ := μ) (E := E) (translateC1c (E := E) a f) : E → ℝ) =ᵐ[μ] + fun x => f.1 (x + a) := by + -- `toL2` agrees a.e. with the underlying translated function. +- simpa [translateC1c, translate] using ++ exact + (memLp_of_mem_C1c (μ := μ) (E := E) (translateC1c (E := E) a f).2).coeFn_toLp + exact h₁.trans h₂.symm + +@@ -150,7 +152,7 @@ lemma translateL2_toL2Grad (a : E) (f : ↥(C1c (E := E))) : + have hf' : + (fun x => (toL2Grad (μ := μ) (E := E) f : E → E) (x + a)) =ᵐ[μ] + fun x => grad (E := E) f.1 (x + a) := by +- simpa [Function.comp, Pi.add_apply] using ++ exact + (Measure.QuasiMeasurePreserving.ae_eq_comp + (MeasureTheory.measurePreserving_add_right μ a).quasiMeasurePreserving hf) + exact +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimate.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimate.lean +index fcec373..7556a69 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimate.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimate.lean +@@ -1,15 +1,15 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.H1 +-import Mathlib.MeasureTheory.Integral.IntervalIntegral.ContDiff +-import Mathlib.Analysis.Calculus.Deriv.Comp +-import Mathlib.Analysis.Calculus.Deriv.Mul +-import Mathlib.Analysis.Calculus.Deriv.Add +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.H1 ++import Mathlib.MeasureTheory.Integral.IntervalIntegral.ContDiff ++import Mathlib.Analysis.Calculus.Deriv.Comp ++import Mathlib.Analysis.Calculus.Deriv.Mul ++import Mathlib.Analysis.Calculus.Deriv.Add ++ + /-! + # `RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimate` + +@@ -35,11 +35,12 @@ section + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] + +-local instance instMeasurableSpaceE_SobolevEuclideanTranslationEstimate : ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceTranslationEstimate : + MeasurableSpace E := borel E +-local instance instBorelSpaceE_SobolevEuclideanTranslationEstimate : ++local instance instBorelSpaceTranslationEstimate : + BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_SobolevEuclideanTranslationEstimate : ++local instance instOpensMeasurableSpaceTranslationEstimate : + OpensMeasurableSpace E := by + infer_instance + +@@ -85,10 +86,11 @@ lemma enorm_fderiv_apply_le_enorm_grad_mul (f : E → ℝ) (x a : E) : + -- Use the operator norm bound, then identify `‖fderiv‖` with `‖grad‖` via the Riesz isometry. + have h₁ : + ‖fderiv ℝ f x a‖ₑ ≤ ‖fderiv ℝ f x‖ₑ * ‖a‖ₑ := +- (ContinuousLinearMap.le_opNorm_enorm (f := fderiv ℝ f x) a) ++ (ContinuousLinearMap.le_opENorm (f := fderiv ℝ f x) a) + have h₂ : ‖grad (E := E) f x‖ₑ = ‖fderiv ℝ f x‖ₑ := by + -- `grad f x = (toDual).symm (fderiv f x)` and `toDual.symm` is an isometry. +- simpa [grad] using ++ simp only [grad] ++ exact + (LinearIsometry.enorm_map + (f := (InnerProductSpace.toDual ℝ E).symm.toLinearIsometry) + (fderiv ℝ f x)) +@@ -108,10 +110,10 @@ lemma enorm_deriv_comp_line_le (x a : E) {f : E → ℝ} (hf : ContDiff ℝ 1 f) + + lemma enorm_sub_le_enorm_mul_lintegral_grad (x a : E) {f : E → ℝ} (hf : ContDiff ℝ 1 f) : + ‖f (x + a) - f x‖ₑ ≤ +- ‖a‖ₑ * ∫⁻ t in Icc (0 : ℝ) 1, ‖grad (E := E) f (x + t • a)‖ₑ := by ++ ‖a‖ₑ * ∫⁻ t in Set.Icc (0 : ℝ) 1, ‖grad (E := E) f (x + t • a)‖ₑ := by + -- Apply FTC along the segment `t ↦ x + t • a`, then bound the derivative pointwise. + have hCont : +- ContDiffOn ℝ 1 (fun t : ℝ => f (x + t • a)) (Icc (0 : ℝ) 1) := by ++ ContDiffOn ℝ 1 (fun t : ℝ => f (x + t • a)) (Set.Icc (0 : ℝ) 1) := by + -- `t ↦ x + t • a` is `C^∞`; compose with `f`. + have hInner : ContDiff ℝ ⊤ (fun t : ℝ => x + t • a) := by + simpa [line] using +@@ -119,14 +121,14 @@ lemma enorm_sub_le_enorm_mul_lintegral_grad (x a : E) {f : E → ℝ} (hf : Cont + have hInner' : ContDiff ℝ 1 (fun t : ℝ => x + t • a) := hInner.of_le (by simp) + exact (hf.comp hInner').contDiffOn + have hFTC : +- ‖f (x + a) - f x‖ₑ ≤ ∫⁻ t in Icc (0 : ℝ) 1, ‖deriv (fun t : ℝ => f (x + t • a)) t‖ₑ := by ++ ‖f (x + a) - f x‖ₑ ≤ ∫⁻ t in Set.Icc (0 : ℝ) 1, ‖deriv (fun t : ℝ => f (x + t • a)) t‖ₑ := by + simpa using + (enorm_sub_le_lintegral_deriv_of_contDiffOn_Icc (f := fun t : ℝ => f (x + t • a)) + (a := (0 : ℝ)) (b := 1) hCont (by exact zero_le_one)) + refine hFTC.trans ?_ + have hDerivBound : + (fun t : ℝ => ‖deriv (fun t : ℝ => f (x + t • a)) t‖ₑ) +- ≤ᵐ[Measure.restrict volume (Icc (0 : ℝ) 1)] ++ ≤ᵐ[Measure.restrict volume (Set.Icc (0 : ℝ) 1)] + fun t : ℝ => ‖a‖ₑ * ‖grad (E := E) f (x + t • a)‖ₑ := by + -- Pointwise bound holds everywhere. + refine (ae_of_all _ fun t => ?_) +@@ -135,8 +137,8 @@ lemma enorm_sub_le_enorm_mul_lintegral_grad (x a : E) {f : E → ℝ} (hf : Cont + (enorm_deriv_comp_line_le (x := x) (a := a) (f := f) hf (t := t)) + -- Pull out the constant `‖a‖ₑ`. + have : +- (∫⁻ t in Icc (0 : ℝ) 1, ‖deriv (fun t : ℝ => f (x + t • a)) t‖ₑ) ≤ +- ∫⁻ t in Icc (0 : ℝ) 1, ‖a‖ₑ * ‖grad (E := E) f (x + t • a)‖ₑ := by ++ (∫⁻ t in Set.Icc (0 : ℝ) 1, ‖deriv (fun t : ℝ => f (x + t • a)) t‖ₑ) ≤ ++ ∫⁻ t in Set.Icc (0 : ℝ) 1, ‖a‖ₑ * ‖grad (E := E) f (x + t • a)‖ₑ := by + exact lintegral_mono_ae hDerivBound + refine this.trans ?_ + -- Pull out the constant factor. +@@ -151,10 +153,10 @@ lemma enorm_sub_le_enorm_mul_lintegral_grad (x a : E) {f : E → ℝ} (hf : Cont + have : Continuous (fun t : ℝ => x + t • a) := by + fun_prop + exact this)).measurable.enorm +- -- Now finish: `∫⁻ t in Icc, ‖a‖ * g t = ‖a‖ * ∫⁻ t in Icc, g t`. ++ -- Now finish: `∫⁻ t in Set.Icc, ‖a‖ * g t = ‖a‖ * ∫⁻ t in Set.Icc, g t`. + exact le_of_eq <| by + simpa [mul_assoc] using +- (MeasureTheory.lintegral_const_mul (μ := volume.restrict (Icc (0 : ℝ) 1)) (r := ‖a‖ₑ) ++ (MeasureTheory.lintegral_const_mul (μ := volume.restrict (Set.Icc (0 : ℝ) 1)) (r := ‖a‖ₑ) + (f := fun t : ℝ => ‖grad (E := E) f (x + t • a)‖ₑ) hMeas) + + end +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateH1.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateH1.lean +index 6bac2f7..4e7144c 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateH1.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateH1.lean +@@ -1,12 +1,12 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimateL2 +-import Mathlib.Topology.Order.OrderClosed +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimateL2 ++import Mathlib.Topology.Order.OrderClosed ++ + /-! + # `RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimateH1` + +@@ -33,14 +33,15 @@ section + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] + +-local instance instMeasurableSpaceE_SobolevEuclideanTranslationEstimateH1 : ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceTranslationEstimateH1 : + MeasurableSpace E := borel E +-local instance instBorelSpaceE_SobolevEuclideanTranslationEstimateH1 : ++local instance instBorelSpaceTranslationEstimateH1 : + BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_SobolevEuclideanTranslationEstimateH1 : ++local instance instOpensMeasurableSpaceTranslationEstimateH1 : + OpensMeasurableSpace E := by + infer_instance +-local instance instMeasurableAddE_SobolevEuclideanTranslationEstimateH1 : MeasurableAdd E := by ++local instance instMeasurableAddTranslationEstimateH1 : MeasurableAdd E := by + infer_instance + + variable (μ : Measure E) [μ.IsAddRightInvariant] [IsFiniteMeasureOnCompacts μ] [SFinite μ] +@@ -73,14 +74,14 @@ theorem norm_translateL2_sub_h1ToL2_le (a : E) (u : ↥(h1 (μ := μ) (E := E))) + have hsub : + Continuous fun v : V => + translateL2 (μ := μ) (F := ℝ) a v.1 - v.1 := by +- simpa [sub_eq_add_neg] using htr.sub hfst +- simpa using (continuous_norm.comp hsub) ++ exact htr.sub hfst ++ exact (continuous_norm.comp hsub) + have hg : + Continuous fun v : V => + ‖a‖ * ‖v.2‖ := by + have hsnd : Continuous fun v : V => v.2 := continuous_snd + have hnorm : Continuous fun v : V => ‖v.2‖ := continuous_norm.comp hsnd +- simpa [mul_assoc] using (continuous_const.mul hnorm) ++ exact (continuous_const.mul hnorm) + exact isClosed_le hf hg + have hRange : (LinearMap.range (graph (μ := μ) (E := E)) : Set V) ⊆ S := by + rintro v ⟨f, rfl⟩ +diff --git a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateL2.lean b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateL2.lean +index 9a903af..0264ad8 100644 +--- a/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateL2.lean ++++ b/RellichKondrachov/Analysis/FunctionalSpaces/Sobolev/Euclidean/TranslationEstimateL2.lean +@@ -1,14 +1,14 @@ +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.Translation +-import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimate +-import Mathlib.MeasureTheory.Integral.MeanInequalities +-import Mathlib.MeasureTheory.Measure.Prod +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.Translation ++import RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimate ++import Mathlib.MeasureTheory.Integral.MeanInequalities ++import Mathlib.MeasureTheory.Measure.Prod ++ + /-! + # `RellichKondrachov.Analysis.FunctionalSpaces.Sobolev.Euclidean.TranslationEstimateL2` + +@@ -40,19 +40,20 @@ section + + variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] + +-local instance instMeasurableSpaceE_SobolevEuclideanTranslationEstimateL2 : ++/-- Borel σ-algebra on the model space `E`. -/ ++local instance instMeasurableSpaceTranslationEstimateL2 : + MeasurableSpace E := borel E +-local instance instBorelSpaceE_SobolevEuclideanTranslationEstimateL2 : ++local instance instBorelSpaceTranslationEstimateL2 : + BorelSpace E := ⟨rfl⟩ +-local instance instOpensMeasurableSpaceE_SobolevEuclideanTranslationEstimateL2 : ++local instance instOpensMeasurableSpaceTranslationEstimateL2 : + OpensMeasurableSpace E := by + infer_instance +-local instance instMeasurableAddE_SobolevEuclideanTranslationEstimateL2 : MeasurableAdd E := by ++local instance instMeasurableAddTranslationEstimateL2 : MeasurableAdd E := by + infer_instance + + variable (μ : Measure E) [μ.IsAddRightInvariant] [IsFiniteMeasureOnCompacts μ] [SFinite μ] + +-private abbrev μI : Measure ℝ := (volume.restrict (Icc (0 : ℝ) 1)) ++private abbrev μI : Measure ℝ := (volume.restrict (Set.Icc (0 : ℝ) 1)) + + private lemma μI_univ : (μI : Measure ℝ) Set.univ = (1 : ℝ≥0∞) := by + simp [μI, Measure.restrict_apply, Real.volume_Icc] +@@ -92,7 +93,143 @@ private lemma lintegral_rpow_two_le_lintegral_rpow_two + (∫⁻ t, g t ^ (2 : ℝ) ∂(μI : Measure ℝ)) + (1 / (2 : ℝ)) (2 : ℝ)).symm)) + ++omit [IsFiniteMeasureOnCompacts μ] in + /-- `L²` translation estimate for `C¹_c` functions under a right-invariant measure. -/ ++private lemma lintegral_enorm_sub_sq_le (a : E) (f : ↥(C1c (E := E))) : ++ (∫⁻ x, ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ≤ ++ ‖a‖ₑ ^ (2 : ℝ) * (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by ++ -- Pointwise: Cauchy–Schwarz in `t`, then Tonelli in `(x,t)`. ++ have hpt : ++ ∀ x : E, ++ ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ≤ ++ ‖a‖ₑ ^ (2 : ℝ) * ++ ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) := by ++ intro x ++ have h0 := enorm_sub_le_enorm_mul_lintegral_grad (E := E) (x := x) (a := a) (f := f.1) ++ (hf := f.2.1) ++ -- Square both sides and apply Cauchy–Schwarz in `t`. ++ have h1 : ++ ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ≤ ++ (‖a‖ₑ * ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ∂(μI : Measure ℝ)) ^ (2 : ℝ) := by ++ exact ENNReal.rpow_le_rpow h0 (by norm_num) ++ have hcs : ++ (∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ∂(μI : Measure ℝ)) ^ (2 : ℝ) ≤ ++ ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) := by ++ refine lintegral_rpow_two_le_lintegral_rpow_two (g := fun t : ℝ => ++ ‖grad (E := E) f.1 (x + t • a)‖ₑ) ?_ ++ -- measurability from continuity of `grad`. ++ have hgrad : Continuous (grad (E := E) f.1) := continuous_grad (E := E) (f := f.1) f.2.1 ++ have hline : Continuous fun t : ℝ => x + t • a := by ++ fun_prop ++ exact (hgrad.comp hline).measurable.enorm.aemeasurable ++ -- Combine and rewrite. ++ calc ++ ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ++ ≤ (‖a‖ₑ * ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ∂(μI : Measure ℝ)) ^ (2 : ℝ) := h1 ++ _ = ‖a‖ₑ ^ (2 : ℝ) * ++ (∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ++ ∂(μI : Measure ℝ)) ^ (2 : ℝ) := by ++ simpa using ++ (ENNReal.mul_rpow_of_nonneg ‖a‖ₑ ++ (∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ++ ∂(μI : Measure ℝ)) ++ (show (0 : ℝ) ≤ (2 : ℝ) by norm_num)) ++ _ ≤ ‖a‖ₑ ^ (2 : ℝ) * ++ ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ++ ∂(μI : Measure ℝ) := by ++ gcongr ++ _ = ‖a‖ₑ ^ (2 : ℝ) * ++ ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ++ ∂(μI : Measure ℝ) := rfl ++ -- Integrate over `x` and apply Tonelli to swap integrals. ++ let F : E × ℝ → ℝ≥0∞ := ++ fun z => ‖grad (E := E) f.1 (z.1 + z.2 • a)‖ₑ ^ (2 : ℝ) ++ have hmeas : ++ AEMeasurable ++ F (μ.prod (μI : Measure ℝ)) := by ++ have hgrad : Continuous (grad (E := E) f.1) := continuous_grad (E := E) (f := f.1) f.2.1 ++ have hcont : Continuous fun z : E × ℝ => z.1 + z.2 • a := by ++ fun_prop ++ have hbase : Measurable fun z : E × ℝ => ‖grad (E := E) f.1 (z.1 + z.2 • a)‖ₑ := by ++ exact (hgrad.comp hcont).measurable.enorm ++ have hpow : Measurable fun r : ℝ≥0∞ => r ^ (2 : ℝ) := ++ (ENNReal.continuous_rpow_const (y := (2 : ℝ))).measurable ++ exact (hpow.comp hbase).aemeasurable ++ have hTonelli : ++ (∫⁻ x, ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ) = ++ ∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ) := by ++ -- Tonelli in both orders, via the product measure. ++ have hprod : ++ (∫⁻ z, F z ∂μ.prod (μI : Measure ℝ)) = ++ ∫⁻ x, ∫⁻ t, F (x, t) ∂(μI : Measure ℝ) ∂μ := ++ MeasureTheory.lintegral_prod (μ := μ) (ν := (μI : Measure ℝ)) F hmeas ++ have hprod_symm : ++ (∫⁻ z, F z ∂μ.prod (μI : Measure ℝ)) = ++ ∫⁻ t, ∫⁻ x, F (x, t) ∂μ ∂(μI : Measure ℝ) := ++ MeasureTheory.lintegral_prod_symm (μ := μ) (ν := (μI : Measure ℝ)) F hmeas ++ calc ++ (∫⁻ x, ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ) ++ = ∫⁻ z, F z ∂μ.prod (μI : Measure ℝ) := by ++ simpa [F] using hprod.symm ++ _ = ∫⁻ t, ∫⁻ x, F (x, t) ∂μ ∂(μI : Measure ℝ) := hprod_symm ++ _ = ∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ) := by ++ simp [F] ++ -- Now use measure-preserving translation in `x` and evaluate the `t`-integral. ++ have hShift : ++ (∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ)) = ++ ∫⁻ t, (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ∂(μI : Measure ℝ) := by ++ refine MeasureTheory.lintegral_congr fun t => ?_ ++ -- Change of variables `x ↦ x + t•a`. ++ have hmeas' : Measurable fun x : E => ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) := by ++ have hgrad : Continuous (grad (E := E) f.1) := continuous_grad (E := E) (f := f.1) f.2.1 ++ have hbase : Measurable fun x : E => ‖grad (E := E) f.1 x‖ₑ := hgrad.measurable.enorm ++ have hpow : Measurable fun r : ℝ≥0∞ => r ^ (2 : ℝ) := ++ (ENNReal.continuous_rpow_const (y := (2 : ℝ))).measurable ++ exact hpow.comp hbase ++ simpa [Function.comp, add_assoc] using ++ (MeasureTheory.measurePreserving_add_right μ (t • a)).lintegral_comp (μ := μ) (ν := μ) ++ (f := fun x : E => ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ)) hmeas' ++ have hEval : ++ (∫⁻ t, (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ∂(μI : Measure ℝ)) = ++ (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by ++ -- `μI` has total mass `1`. ++ simp [μI, Measure.restrict_apply, Real.volume_Icc] ++ -- Put everything together. ++ have hInt : ++ (∫⁻ x, ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ≤ ++ ‖a‖ₑ ^ (2 : ℝ) * (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by ++ calc ++ (∫⁻ x, ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ++ ≤ ∫⁻ x, ‖a‖ₑ ^ (2 : ℝ) * ++ ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ := by ++ refine MeasureTheory.lintegral_mono ?_ ++ intro x ++ exact hpt x ++ _ = ‖a‖ₑ ^ (2 : ℝ) * ++ (∫⁻ x, ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ) := by ++ -- Pull out the constant using `lintegral_const_mul''`. ++ have hInner : ++ AEMeasurable ++ (fun x : E => ++ ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ)) μ := by ++ -- Measurability of the inner integral follows ++ -- from `hmeas` via ++ -- `AEMeasurable.lintegral_prod_right'`. ++ simpa [F] using (hmeas.lintegral_prod_right' (μ := μ) (ν := (μI : Measure ℝ))) ++ simpa [mul_assoc] using ++ (MeasureTheory.lintegral_const_mul'' (μ := μ) (r := ‖a‖ₑ ^ (2 : ℝ)) ++ (f := fun x : E => ++ ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ)) hInner) ++ _ = ‖a‖ₑ ^ (2 : ℝ) * ++ (∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ)) := by ++ exact congrArg (fun z => ‖a‖ₑ ^ (2 : ℝ) * z) hTonelli ++ _ = ‖a‖ₑ ^ (2 : ℝ) * ++ (∫⁻ t, (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ∂(μI : Measure ℝ)) := by ++ exact congrArg (fun z => ‖a‖ₑ ^ (2 : ℝ) * z) hShift ++ _ = ‖a‖ₑ ^ (2 : ℝ) * (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by ++ exact congrArg (fun z => ‖a‖ₑ ^ (2 : ℝ) * z) hEval ++ exact hInt ++ + lemma enorm_translateL2_sub_toL2_le (a : E) (f : ↥(C1c (E := E))) : + ‖translateL2 (μ := μ) (F := ℝ) a (toL2 (μ := μ) (E := E) f) - + toL2 (μ := μ) (E := E) f‖ₑ ≤ +@@ -112,7 +249,7 @@ lemma enorm_translateL2_sub_toL2_le (a : E) (f : ↥(C1c (E := E))) : + (memLp_of_mem_C1c (μ := μ) (E := E) f.2).coeFn_toLp + have hf' : + (fun x => (toL2 (μ := μ) (E := E) f : E → ℝ) (x + a)) =ᵐ[μ] fun x => f.1 (x + a) := by +- simpa [Function.comp, Pi.add_apply] using ++ exact + (Measure.QuasiMeasurePreserving.ae_eq_comp + (MeasureTheory.measurePreserving_add_right μ a).quasiMeasurePreserving hf) + exact (translateL2_ae_eq (μ := μ) (F := ℝ) a (toL2 (μ := μ) (E := E) f)).trans hf' +@@ -159,144 +296,23 @@ lemma enorm_translateL2_sub_toL2_le (a : E) (f : ↥(C1c (E := E))) : + ‖a‖ₑ * MeasureTheory.eLpNorm (fun x : E => grad (E := E) f.1 x) (2 : ℝ≥0∞) μ := by + -- Expand the definition of `eLpNorm` at exponent `2`. + have h2_ne0 : (2 : ℝ≥0∞) ≠ 0 := by simp +- have h2_netop : (2 : ℝ≥0∞) ≠ ∞ := by simp +- simp_rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal +- h2_ne0 h2_netop, ENNReal.toReal_ofNat] at * ++ have h2_netop : (2 : ℝ≥0∞) ≠ (⊤ : ℝ≥0∞) := by simp ++ have hf_meas : MeasureTheory.AEStronglyMeasurable (fun x : E => f.1 x) μ := ++ (memLp_of_mem_C1c (μ := μ) (E := E) f.2).aestronglyMeasurable ++ have hshift_meas : ++ MeasureTheory.AEStronglyMeasurable (fun x : E => f.1 (x + a) - f.1 x) μ := by ++ have hshift : MeasureTheory.AEStronglyMeasurable (fun x : E => f.1 (x + a)) μ := ++ hf_meas.comp_quasiMeasurePreserving ++ (MeasureTheory.measurePreserving_add_right μ a).quasiMeasurePreserving ++ exact hshift.sub hf_meas ++ have hgrad_meas : ++ MeasureTheory.AEStronglyMeasurable (fun x : E => grad (E := E) f.1 x) μ := ++ (memLp_grad_of_mem_C1c (μ := μ) (E := E) f.2).aestronglyMeasurable ++ rw [MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal h2_ne0 h2_netop hshift_meas, ++ MeasureTheory.eLpNorm_eq_lintegral_rpow_enorm_toReal h2_ne0 h2_netop hgrad_meas, ++ ENNReal.toReal_ofNat] + -- It suffices to compare the squared integrals. +- have hsq : +- (∫⁻ x, ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ≤ +- ‖a‖ₑ ^ (2 : ℝ) * (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by +- -- Pointwise: Cauchy–Schwarz in `t`, then Tonelli in `(x,t)`. +- have hpt : +- ∀ x : E, +- ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ≤ +- ‖a‖ₑ ^ (2 : ℝ) * +- ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) := by +- intro x +- have h0 := enorm_sub_le_enorm_mul_lintegral_grad (E := E) (x := x) (a := a) (f := f.1) +- (hf := f.2.1) +- -- Square both sides and apply Cauchy–Schwarz in `t`. +- have h1 : +- ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ≤ +- (‖a‖ₑ * ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ∂(μI : Measure ℝ)) ^ (2 : ℝ) := by +- exact ENNReal.rpow_le_rpow h0 (by norm_num) +- have hcs : +- (∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ∂(μI : Measure ℝ)) ^ (2 : ℝ) ≤ +- ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) := by +- refine lintegral_rpow_two_le_lintegral_rpow_two (g := fun t : ℝ => +- ‖grad (E := E) f.1 (x + t • a)‖ₑ) ?_ +- -- measurability from continuity of `grad`. +- have hgrad : Continuous (grad (E := E) f.1) := continuous_grad (E := E) (f := f.1) f.2.1 +- have hline : Continuous fun t : ℝ => x + t • a := by +- fun_prop +- exact (hgrad.comp hline).measurable.enorm.aemeasurable +- -- Combine and rewrite. +- calc +- ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) +- ≤ (‖a‖ₑ * ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ∂(μI : Measure ℝ)) ^ (2 : ℝ) := h1 +- _ = ‖a‖ₑ ^ (2 : ℝ) * +- (∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ +- ∂(μI : Measure ℝ)) ^ (2 : ℝ) := by +- simpa using +- (ENNReal.mul_rpow_of_nonneg ‖a‖ₑ +- (∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ +- ∂(μI : Measure ℝ)) +- (show (0 : ℝ) ≤ (2 : ℝ) by norm_num)) +- _ ≤ ‖a‖ₑ ^ (2 : ℝ) * +- ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) +- ∂(μI : Measure ℝ) := by +- gcongr +- _ = ‖a‖ₑ ^ (2 : ℝ) * +- ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) +- ∂(μI : Measure ℝ) := rfl +- -- Integrate over `x` and apply Tonelli to swap integrals. +- let F : E × ℝ → ℝ≥0∞ := +- fun z => ‖grad (E := E) f.1 (z.1 + z.2 • a)‖ₑ ^ (2 : ℝ) +- have hmeas : +- AEMeasurable +- F (μ.prod (μI : Measure ℝ)) := by +- have hgrad : Continuous (grad (E := E) f.1) := continuous_grad (E := E) (f := f.1) f.2.1 +- have hcont : Continuous fun z : E × ℝ => z.1 + z.2 • a := by +- fun_prop +- have hbase : Measurable fun z : E × ℝ => ‖grad (E := E) f.1 (z.1 + z.2 • a)‖ₑ := by +- exact (hgrad.comp hcont).measurable.enorm +- have hpow : Measurable fun r : ℝ≥0∞ => r ^ (2 : ℝ) := +- (ENNReal.continuous_rpow_const (y := (2 : ℝ))).measurable +- simpa [F] using (hpow.comp hbase).aemeasurable +- have hTonelli : +- (∫⁻ x, ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ) = +- ∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ) := by +- -- Tonelli in both orders, via the product measure. +- have hprod : +- (∫⁻ z, F z ∂μ.prod (μI : Measure ℝ)) = +- ∫⁻ x, ∫⁻ t, F (x, t) ∂(μI : Measure ℝ) ∂μ := +- MeasureTheory.lintegral_prod (μ := μ) (ν := (μI : Measure ℝ)) F hmeas +- have hprod_symm : +- (∫⁻ z, F z ∂μ.prod (μI : Measure ℝ)) = +- ∫⁻ t, ∫⁻ x, F (x, t) ∂μ ∂(μI : Measure ℝ) := +- MeasureTheory.lintegral_prod_symm (μ := μ) (ν := (μI : Measure ℝ)) F hmeas +- calc +- (∫⁻ x, ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ) +- = ∫⁻ z, F z ∂μ.prod (μI : Measure ℝ) := by +- simpa [F] using hprod.symm +- _ = ∫⁻ t, ∫⁻ x, F (x, t) ∂μ ∂(μI : Measure ℝ) := hprod_symm +- _ = ∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ) := by +- simp [F] +- -- Now use measure-preserving translation in `x` and evaluate the `t`-integral. +- have hShift : +- (∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ)) = +- ∫⁻ t, (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ∂(μI : Measure ℝ) := by +- refine MeasureTheory.lintegral_congr fun t => ?_ +- -- Change of variables `x ↦ x + t•a`. +- have hmeas' : Measurable fun x : E => ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) := by +- have hgrad : Continuous (grad (E := E) f.1) := continuous_grad (E := E) (f := f.1) f.2.1 +- have hbase : Measurable fun x : E => ‖grad (E := E) f.1 x‖ₑ := hgrad.measurable.enorm +- have hpow : Measurable fun r : ℝ≥0∞ => r ^ (2 : ℝ) := +- (ENNReal.continuous_rpow_const (y := (2 : ℝ))).measurable +- exact hpow.comp hbase +- simpa [Function.comp, add_assoc] using +- (MeasureTheory.measurePreserving_add_right μ (t • a)).lintegral_comp (μ := μ) (ν := μ) +- (f := fun x : E => ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ)) hmeas' +- have hEval : +- (∫⁻ t, (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ∂(μI : Measure ℝ)) = +- (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by +- -- `μI` has total mass `1`. +- simp [μI, Measure.restrict_apply, Real.volume_Icc] +- -- Put everything together. +- have hInt : +- (∫⁻ x, ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ≤ +- ‖a‖ₑ ^ (2 : ℝ) * (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by +- calc +- (∫⁻ x, ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ∂μ) +- ≤ ∫⁻ x, ‖a‖ₑ ^ (2 : ℝ) * +- ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ := by +- refine MeasureTheory.lintegral_mono ?_ +- intro x +- exact hpt x +- _ = ‖a‖ₑ ^ (2 : ℝ) * +- (∫⁻ x, ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ) ∂μ) := by +- -- Pull out the constant using `lintegral_const_mul''`. +- have hInner : +- AEMeasurable +- (fun x : E => +- ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ)) μ := by +- -- Measurability of the inner integral follows +- -- from `hmeas` via +- -- `AEMeasurable.lintegral_prod_right'`. +- simpa [F] using (hmeas.lintegral_prod_right' (μ := μ) (ν := (μI : Measure ℝ))) +- simpa [mul_assoc] using +- (MeasureTheory.lintegral_const_mul'' (μ := μ) (r := ‖a‖ₑ ^ (2 : ℝ)) +- (f := fun x : E => +- ∫⁻ t, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂(μI : Measure ℝ)) hInner) +- _ = ‖a‖ₑ ^ (2 : ℝ) * +- (∫⁻ t, ∫⁻ x, ‖grad (E := E) f.1 (x + t • a)‖ₑ ^ (2 : ℝ) ∂μ ∂(μI : Measure ℝ)) := by +- exact congrArg (fun z => ‖a‖ₑ ^ (2 : ℝ) * z) hTonelli +- _ = ‖a‖ₑ ^ (2 : ℝ) * +- (∫⁻ t, (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ∂(μI : Measure ℝ)) := by +- exact congrArg (fun z => ‖a‖ₑ ^ (2 : ℝ) * z) hShift +- _ = ‖a‖ₑ ^ (2 : ℝ) * (∫⁻ x, ‖grad (E := E) f.1 x‖ₑ ^ (2 : ℝ) ∂μ) := by +- exact congrArg (fun z => ‖a‖ₑ ^ (2 : ℝ) * z) hEval +- exact hInt ++ have hsq := lintegral_enorm_sub_sq_le (μ := μ) a f + -- Take the `1/2` power on both sides and simplify. + have hsq' : + (∫⁻ x, ‖f.1 (x + a) - f.1 x‖ₑ ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) ≤ +@@ -333,12 +349,12 @@ lemma norm_translateL2_sub_toL2_le (a : E) (f : ↥(C1c (E := E))) : + have h := enorm_translateL2_sub_toL2_le (μ := μ) (E := E) a f + have hA_ne_top : + (‖translateL2 (μ := μ) (F := ℝ) a (toL2 (μ := μ) (E := E) f) - +- toL2 (μ := μ) (E := E) f‖ₑ : ℝ≥0∞) ≠ ∞ := by ++ toL2 (μ := μ) (E := E) f‖ₑ : ℝ≥0∞) ≠ (⊤ : ℝ≥0∞) := by + simp [enorm] + have hGrad_ne_top : +- (‖toL2Grad (μ := μ) (E := E) f‖ₑ : ℝ≥0∞) ≠ ∞ := by ++ (‖toL2Grad (μ := μ) (E := E) f‖ₑ : ℝ≥0∞) ≠ (⊤ : ℝ≥0∞) := by + simp [enorm] +- have hB_ne_top : (‖a‖ₑ * ‖toL2Grad (μ := μ) (E := E) f‖ₑ : ℝ≥0∞) ≠ ∞ := by ++ have hB_ne_top : (‖a‖ₑ * ‖toL2Grad (μ := μ) (E := E) f‖ₑ : ℝ≥0∞) ≠ (⊤ : ℝ≥0∞) := by + refine ENNReal.mul_ne_top ?_ hGrad_ne_top + simp [enorm] + have h' : +@@ -346,7 +362,7 @@ lemma norm_translateL2_sub_toL2_le (a : E) (f : ↥(C1c (E := E))) : + toL2 (μ := μ) (E := E) f‖ₑ).toReal ≤ + (‖a‖ₑ * ‖toL2Grad (μ := μ) (E := E) f‖ₑ).toReal := by + exact (ENNReal.toReal_le_toReal hA_ne_top hB_ne_top).2 h +- simpa [ENNReal.toReal_mul, toReal_enorm'] using h' ++ simpa only [ENNReal.toReal_mul, toReal_enorm] using h' + + end + +diff --git a/RellichKondrachov/MeasureTheory/Function/LpSpace/Restrict.lean b/RellichKondrachov/MeasureTheory/Function/LpSpace/Restrict.lean +index bb9c6e5..5d1561e 100644 +--- a/RellichKondrachov/MeasureTheory/Function/LpSpace/Restrict.lean ++++ b/RellichKondrachov/MeasureTheory/Function/LpSpace/Restrict.lean +@@ -1,16 +1,16 @@ +-import Mathlib.MeasureTheory.Function.LpSeminorm.Basic +-import Mathlib.MeasureTheory.Function.LpSpace.Basic +- + /- + Copyright (c) 2026 Adam Benenson. All rights reserved. + Released under Apache 2.0 license as described in the file LICENSE. + Authors: Adam Benenson + -/ + ++import Mathlib.MeasureTheory.Function.LpSeminorm.Basic ++import Mathlib.MeasureTheory.Function.LpSpace.Basic ++ + /-! + # `RellichKondrachov.MeasureTheory.Function.LpSpace.Restrict` + +-`L^p` extension-by-zero maps for restricted measures. ++`«L»^p` extension-by-zero maps for restricted measures. + + Mathlib provides the equivalence + +@@ -42,7 +42,8 @@ variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] + variable {p : ℝ≥0∞} [Fact (1 ≤ p)] + variable {s : Set α} (hs : MeasurableSet s) + +-private noncomputable def extendByZeroFun (f : Lp E p (μ.restrict s)) : Lp E p μ := ++/-- Extend an Lp function from a restricted measure by zero outside the set. -/ ++noncomputable def extendByZeroFun (f : Lp E p (μ.restrict s)) : Lp E p μ := + let hf : MemLp (fun x : α => f x) p (μ.restrict s) := Lp.memLp f + let hfi : MemLp (s.indicator fun x : α => f x) p μ := + (memLp_indicator_iff_restrict (μ := μ) (p := p) (s := s) (f := fun x : α => f x) hs).2 hf +@@ -63,7 +64,7 @@ noncomputable def extendByZeroₗ : Lp E p (μ.restrict s) →ₗ[ℝ] Lp E p μ + refine Lp.ext ?_ + have h_add_restrict : + (fun x : α => (f + g) x) =ᵐ[μ.restrict s] fun x : α => f x + g x := by +- simpa using (Lp.coeFn_add (μ := μ.restrict s) f g) ++ exact (Lp.coeFn_add (μ := μ.restrict s) f g) + have h_add_on : + ∀ᵐ x : α ∂μ, x ∈ s → (f + g) x = f x + g x := + (ae_restrict_iff' (μ := μ) (s := s) hs).1 h_add_restrict +@@ -95,8 +96,7 @@ noncomputable def extendByZeroₗ : Lp E p (μ.restrict s) →ₗ[ℝ] Lp E p μ + simp [hf, hg] + _ = (extendByZeroFun (μ := μ) (p := p) (s := s) hs f + + extendByZeroFun (μ := μ) (p := p) (s := s) hs g) x := hadd' +- · +- have hadd' : ++ · have hadd' : + extendByZeroFun (μ := μ) (p := p) (s := s) hs f x + + extendByZeroFun (μ := μ) (p := p) (s := s) hs g x = + (extendByZeroFun (μ := μ) (p := p) (s := s) hs f + +@@ -117,7 +117,7 @@ noncomputable def extendByZeroₗ : Lp E p (μ.restrict s) →ₗ[ℝ] Lp E p μ + refine Lp.ext ?_ + have h_smul_restrict : + (fun x : α => (c • f) x) =ᵐ[μ.restrict s] fun x : α => c • f x := by +- simpa using (Lp.coeFn_smul (μ := μ.restrict s) c f) ++ exact (Lp.coeFn_smul (μ := μ.restrict s) c f) + have h_smul_on : + ∀ᵐ x : α ∂μ, x ∈ s → (c • f) x = c • f x := + (ae_restrict_iff' (μ := μ) (s := s) hs).1 h_smul_restrict +@@ -141,8 +141,7 @@ noncomputable def extendByZeroₗ : Lp E p (μ.restrict s) →ₗ[ℝ] Lp E p μ + _ = c • s.indicator (fun x : α => f x) x := by simp [Set.indicator_of_mem, hx] + _ = c • extendByZeroFun (μ := μ) (p := p) (s := s) hs f x := by simp [hf] + _ = (c • extendByZeroFun (μ := μ) (p := p) (s := s) hs f) x := hsmul' +- · +- have hsmul' : ++ · have hsmul' : + c • extendByZeroFun (μ := μ) (p := p) (s := s) hs f x = + (c • extendByZeroFun (μ := μ) (p := p) (s := s) hs f) x := by + simpa [Pi.smul_apply] using hsmul.symm diff --git a/lean/patches/schoenflies-lean-lean4341.patch b/lean/patches/schoenflies-lean-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..96ec392010a1f4afca531fdf7afcd8a8d0d7e980 --- /dev/null +++ b/lean/patches/schoenflies-lean-lean4341.patch @@ -0,0 +1,2575 @@ +diff --git a/Schoenflies/Accessible.lean b/Schoenflies/Accessible.lean +--- a/Schoenflies/Accessible.lean ++++ b/Schoenflies/Accessible.lean +@@ -113,7 +113,7 @@ + have h1 : Continuous fun x : Plane => ‖x - p‖ := (continuous_id.sub continuous_const).norm + have h2 : Continuous fun x : Plane => inner ℝ v (x - p) := + continuous_const.inner (continuous_id.sub continuous_const) +- rw [accessCone, setOf_and] ++ rw [accessCone, ofPred_and] + exact (isOpen_lt h1 continuous_const).inter (isOpen_lt (h1.div_const 2) h2) + + /-- Membership in the cone in the form used by the blueprint: a unit direction `w` making an +diff --git a/Schoenflies/ArcCollars.lean b/Schoenflies/ArcCollars.lean +--- a/Schoenflies/ArcCollars.lean ++++ b/Schoenflies/ArcCollars.lean +@@ -1261,7 +1261,7 @@ + (min 1 (ε / (2 * ‖z - A.vertex (i + 1)‖))) • (z - A.vertex (i + 1)) - + A.vertex (i + 1) = + (min 1 (ε / (2 * ‖z - A.vertex (i + 1)‖))) • (z - A.vertex (i + 1)) := by module) +- · rw [Set.mem_setOf_eq, hsub] ++ · rw [Set.mem_ofPred_eq, hsub] + exact (smul_mem_arcCCW hδpos).2 harc + · rw [mem_ball, dist_eq_norm, hsub, norm_smul, Real.norm_eq_abs, abs_of_pos hδpos] + have h1 : min 1 (ε / (2 * ‖z - A.vertex (i + 1)‖)) ≤ 1 := min_le_left _ _ +@@ -1286,7 +1286,7 @@ + (min 1 (ε / (2 * ‖z - A.vertex (i + 1)‖))) • (z - A.vertex (i + 1)) - + A.vertex (i + 1) = + (min 1 (ε / (2 * ‖z - A.vertex (i + 1)‖))) • (z - A.vertex (i + 1)) := by module) +- · rw [Set.mem_setOf_eq, hsub] ++ · rw [Set.mem_ofPred_eq, hsub] + exact (smul_mem_arcCCW hδpos).2 harc + · rw [mem_ball, dist_eq_norm, hsub, norm_smul, Real.norm_eq_abs, abs_of_pos hδpos] + have h1 : min 1 (ε / (2 * ‖z - A.vertex (i + 1)‖)) ≤ 1 := min_le_left _ _ +diff --git a/Schoenflies/ArcComplement.lean b/Schoenflies/ArcComplement.lean +--- a/Schoenflies/ArcComplement.lean ++++ b/Schoenflies/ArcComplement.lean +@@ -154,7 +154,7 @@ + Graph.pointSet (segGraph S) segmentDrawing = ⋃ P ∈ S, P.seg := by + ext z + simp only [Graph.pointSet, mem_union, mem_iUnion, exists_prop, segGraph_vertexSet, +- mem_setOf_eq, segGraph_edgeSet, edgeArc_segmentDrawing] ++ mem_ofPred_eq, segGraph_edgeSet, edgeArc_segmentDrawing] + constructor + · rintro (⟨P, hP, hzP⟩ | ⟨P, hP, hzP⟩) + · refine ⟨P, hP, ?_⟩ +@@ -453,7 +453,7 @@ + intro z hz hz' + obtain ⟨j, hj, hj', hzj⟩ := exists_mem_frontier_of_mem_pointSet_familyChain hz + obtain ⟨k, hk, hk', hzk⟩ := exists_mem_frontier_of_mem_pointSet_familyChain hz' +- rw [Plane.frontier_closedSquare, mem_setOf_eq] at hzj hzk ++ rw [Plane.frontier_closedSquare, mem_ofPred_eq] at hzj hzk + have htri := Plane.supDist_triangle (c j) z (c k) + rw [Plane.supDist_comm (c j) z] at htri + exact absurd (hfar p q hp hq hpq j hj hj' k hk hk') (by rw [hzj, hzk] at htri; linarith) +@@ -525,7 +525,7 @@ + z ∈ Plane.closedSquare (c (p * m)) R := by + intro i hi hi' hzi + obtain ⟨j, hj, hj', hzj⟩ := exists_mem_frontier_of_mem_pointSet_familyChain hzi +- rw [Plane.frontier_closedSquare, mem_setOf_eq] at hzj ++ rw [Plane.frontier_closedSquare, mem_ofPred_eq] at hzj + have hjlo : p * m ≤ j := le_trans (Nat.mul_le_mul_right _ hi) hj + have hjhi : j ≤ p * m + m + m := by + have : i * m ≤ (p + 1) * m := Nat.mul_le_mul_right _ hi' +@@ -714,7 +714,7 @@ + (outerOnPairs_familyChain hcontain (hxfar u hmemu)) + have houtw := outer_face_familyChain hchain + (outerOnPairs_familyChain hcontain (hxfar w hmemw)) +- haveI : (Graph.chainUnion (familyChain c ((n + 1) * m) m r) 0 n).Finite := ++ have : (Graph.chainUnion (familyChain c ((n + 1) * m) m r) 0 n).Finite := + hchain.block_finite (i := 0) (m := n) (by omega) + have hdraw : Graph.IsDrawing (Graph.chainUnion (familyChain c ((n + 1) * m) m r) 0 n) + segmentDrawing := hchain.block_isDrawing (by omega) +diff --git a/Schoenflies/ArcComplementPrep.lean b/Schoenflies/ArcComplementPrep.lean +--- a/Schoenflies/ArcComplementPrep.lean ++++ b/Schoenflies/ArcComplementPrep.lean +@@ -441,7 +441,7 @@ + theorem mem_compl_closedSquare_iff (c : Plane) (r : ℝ) (x : Plane) : + x ∈ (closedSquare c r)ᶜ ↔ x - c ∈ beyondSquare r := by + rw [beyondSquare_eq_compl] +- simp only [mem_compl_iff, closedSquare, mem_setOf_eq, supDist_zero] ++ simp only [mem_compl_iff, closedSquare, mem_ofPred_eq, supDist_zero] + exact Iff.rfl + + theorem compl_closedSquare_eq_image (c : Plane) (r : ℝ) : +@@ -465,7 +465,7 @@ + (frontier (closedSquare c r))ᶜ = openSquare c r ∪ (closedSquare c r)ᶜ := by + ext z + rw [frontier_closedSquare] +- simp only [mem_compl_iff, mem_setOf_eq, mem_union, openSquare, closedSquare, not_le] ++ simp only [mem_compl_iff, mem_ofPred_eq, mem_union, openSquare, closedSquare, not_le] + constructor + · intro h + rcases lt_or_gt_of_ne h with h' | h' +diff --git a/Schoenflies/ArcMonotone.lean b/Schoenflies/ArcMonotone.lean +--- a/Schoenflies/ArcMonotone.lean ++++ b/Schoenflies/ArcMonotone.lean +@@ -86,7 +86,7 @@ + have h : ∃ s, s ∈ I ∧ f s = p := by + obtain ⟨s, hs, rfl⟩ := hp + exact ⟨s, hs, rfl⟩ +- rw [arcParam, dif_pos h] ++ rw [arcParam, dite_eq_left h] + exact h.choose_spec + + theorem arcParam_mem_I (hp : p ∈ f '' I) : arcParam f p ∈ I := (arcParam_spec hp).1 +diff --git a/Schoenflies/BoundaryAnchors.lean b/Schoenflies/BoundaryAnchors.lean +--- a/Schoenflies/BoundaryAnchors.lean ++++ b/Schoenflies/BoundaryAnchors.lean +@@ -119,7 +119,7 @@ + have harc := h.edge_isArcBetween hxy + apply Or.inr + exact Set.mem_iUnion₂.2 ⟨e, by +- rw [Graph.edgeSet_eq_setOf_exists_isLink] ++ rw [Graph.edgeSet_eq_setOfPred_exists_isLink] + exact ⟨x, y, (Graph.traceGraph_isLink D).2 + ⟨heD, hxy, heD harc.left_mem, heD harc.right_mem⟩⟩, hze⟩ + +@@ -246,7 +246,7 @@ + h.vertex_mem hlb.right_mem (hcase hlb hbnb hbC) + let K := Graph.traceGraph G drawing (inside C) + have hKle : K ≤ G := Graph.traceGraph_le _ +- letI : K.Finite := Graph.Finite.of_le hKle ++ let : K.Finite := Graph.Finite.of_le hKle + have hKpoint : Graph.pointSet K drawing = + Graph.interiorPart G drawing (inside C) := + Graph.pointSet_traceGraph_eq_interiorPart h.isDrawing (inside C) +@@ -793,7 +793,7 @@ + have hrTargetAdmissible : + r.pair.tgt.IsAdmissible modelCurve (Plane.closedSquare 0 1) := + r.pair.tgt_isAdmissible hrAdmissible.isConnected_nonboundary +- letI : r.pair.src.graph.Finite := CellStructure.Realization.finite_graph r.pair.src ++ let : r.pair.src.graph.Finite := CellStructure.Realization.finite_graph r.pair.src + have hsourceStage := hrAdmissible.isStageOn + have htargetStage : Graph.IsStageOn r.pair.tgt.graph r.pair.tgt.drawing + modelCurve (inside modelCurve) := by +diff --git a/Schoenflies/BoundaryContinuity2.lean b/Schoenflies/BoundaryContinuity2.lean +--- a/Schoenflies/BoundaryContinuity2.lean ++++ b/Schoenflies/BoundaryContinuity2.lean +@@ -494,7 +494,7 @@ + hsnot (mem_of_superset h (preimage_mono hWs)) + -- the filter of approach that stays away from `W` + set l' : Filter Plane := 𝓝[inside C] p ⊓ 𝓟 (F ⁻¹' Wᶜ) with hl' +- haveI : l'.NeBot := by ++ have : l'.NeBot := by + refine ⟨fun h => hWnot ?_⟩ + rw [hl', Filter.inf_principal_eq_bot] at h + simpa using h +@@ -521,7 +521,7 @@ + rw [le_principal_iff, mem_map] + filter_upwards [hl'in] with z hz using hF.mapsTo hz + set m : Filter Plane := 𝓝 q ⊓ map F l' with hm +- haveI : m.NeBot := hqcl ++ have : m.NeBot := hqcl + have hm1 : m ≤ 𝓝[Plane.openSquare 0 1] q := + le_inf inf_le_left (le_trans inf_le_right hmapO) + have h1 : Tendsto F' m (𝓝 (F' q)) := (hF.continuousOn_inv q hqopen).mono_left hm1 +diff --git a/Schoenflies/BoundaryCycles.lean b/Schoenflies/BoundaryCycles.lean +--- a/Schoenflies/BoundaryCycles.lean ++++ b/Schoenflies/BoundaryCycles.lean +@@ -148,7 +148,7 @@ + rw [CellStructure.pathCells, CellStructure.pathCells, + h₁.walkVertices_eq_covered hne₁, h₂.walkVertices_eq_covered hne₂] + ext σ +- simp only [Set.mem_union, Set.mem_setOf_eq, Graph.mem_coveredVertices_iff] ++ simp only [Set.mem_union, Set.mem_ofPred_eq, Graph.mem_coveredVertices_iff] + constructor + · rintro (hσ | ⟨e, he, hi⟩) + · exact Or.inl (hp.mem_iff.1 hσ) +diff --git a/Schoenflies/Bounded.lean b/Schoenflies/Bounded.lean +--- a/Schoenflies/Bounded.lean ++++ b/Schoenflies/Bounded.lean +@@ -38,7 +38,7 @@ + /-- The outside of a square is exactly the complement of the closed square. -/ + theorem beyondSquare_eq_compl (r : ℝ) : beyondSquare r = (closedSquare 0 r)ᶜ := by + ext x +- simp only [beyondSquare, closedSquare, mem_setOf_eq, mem_compl_iff, supDist_zero, supNorm, ++ simp only [beyondSquare, closedSquare, mem_ofPred_eq, mem_compl_iff, supDist_zero, supNorm, + max_le_iff, not_and_or, not_le] + + /-- A bounded set sits inside a closed square about the origin, of nonnegative radius. -/ +diff --git a/Schoenflies/CommonSubdivision.lean b/Schoenflies/CommonSubdivision.lean +--- a/Schoenflies/CommonSubdivision.lean ++++ b/Schoenflies/CommonSubdivision.lean +@@ -48,8 +48,8 @@ + let B : Graph Plane β := G.induce (V(G) \ G.component x) + have hAle : A ≤ G := G.induce_le component_subset_vertexSet + have hBle : B ≤ G := G.induce_le Set.sdiff_subset +- letI : A.Finite := Graph.Finite.of_le hAle +- letI : B.Finite := Graph.Finite.of_le hBle ++ let : A.Finite := Graph.Finite.of_le hAle ++ let : B.Finite := Graph.Finite.of_le hBle + have hAclosed : IsClosed (pointSet A drawing) := (hdraw.mono hAle).isClosed_pointSet + have hBclosed : IsClosed (pointSet B drawing) := (hdraw.mono hBle).isClosed_pointSet + have hcover : pointSet G drawing ⊆ pointSet A drawing ∪ pointSet B drawing := by +@@ -64,14 +64,14 @@ + · have hvC : v ∈ G.component x := mem_component_of_isLink huC huv + exact Or.inl (Or.inr (Set.mem_iUnion₂_of_mem + (show e ∈ E(A) by +- rw [edgeSet_eq_setOf_exists_isLink] ++ rw [edgeSet_eq_setOfPred_exists_isLink] + exact ⟨u, v, huv, huC, hvC⟩) hze)) + · have hvC : v ∉ G.component x := by + intro hvC + exact huC (mem_component_of_isLink hvC huv.symm) + exact Or.inr (Or.inr (Set.mem_iUnion₂_of_mem + (show e ∈ E(B) by +- rw [edgeSet_eq_setOf_exists_isLink] ++ rw [edgeSet_eq_setOfPred_exists_isLink] + exact ⟨u, v, huv, ⟨huv.left_mem, huC⟩, ⟨huv.right_mem, hvC⟩⟩) hze)) + have hAB : Disjoint (pointSet A drawing) (pointSet B drawing) := by + rw [Set.disjoint_left] +@@ -79,13 +79,13 @@ + rcases hzA with hzAV | hzAE <;> rcases hzB with hzBV | hzBE + · exact hzBV.2 hzAV + · obtain ⟨e, heB, hze⟩ := Set.mem_iUnion₂.1 hzBE +- rw [edgeSet_eq_setOf_exists_isLink] at heB ++ rw [edgeSet_eq_setOfPred_exists_isLink] at heB + obtain ⟨u, v, huv, huB, hvB⟩ := heB + have hzinc := hdraw.vertex_mem_edgeArc huv (component_subset_vertexSet hzAV) hze + rcases hzinc with rfl | rfl + exacts [huB.2 hzAV, hvB.2 hzAV] + · obtain ⟨e, heA, hze⟩ := Set.mem_iUnion₂.1 hzAE +- rw [edgeSet_eq_setOf_exists_isLink] at heA ++ rw [edgeSet_eq_setOfPred_exists_isLink] at heA + obtain ⟨u, v, huv, huA, hvA⟩ := heA + have hzinc := hdraw.vertex_mem_edgeArc huv hzBV.1 hze + rcases hzinc with rfl | rfl +@@ -97,7 +97,7 @@ + have hef : e ≠ f := by + intro hef + subst f +- rw [edgeSet_eq_setOf_exists_isLink] at heA hfB ++ rw [edgeSet_eq_setOfPred_exists_isLink] at heA hfB + obtain ⟨u, v, huv, huA, -⟩ := heA + obtain ⟨u', v', huv', huB, hvB⟩ := hfB + rcases huv.left_eq_or_eq huv' with h | h +@@ -105,7 +105,7 @@ + · exact hvB.2 (h ▸ huA) + obtain ⟨hzV, ⟨u, heu⟩, ⟨v, hfv⟩⟩ := + hdraw.edge_inter heG hfG hef hzeA hzfB +- rw [edgeSet_eq_setOf_exists_isLink] at heA hfB ++ rw [edgeSet_eq_setOfPred_exists_isLink] at heA hfB + obtain ⟨a, b, hab, haA, hbA⟩ := heA + obtain ⟨c, d, hcd, hcB, hdB⟩ := hfB + rcases heu.left_eq_or_eq hab with rfl | rfl <;> +@@ -135,7 +135,7 @@ + @[simp] theorem traceGraph_isLink (A : Set Plane) : + (traceGraph G drawing A).IsLink e x y ↔ + edgeArc drawing e ⊆ A ∧ G.IsLink e x y ∧ x ∈ A ∧ y ∈ A := by +- simp only [traceGraph, induce_isLink, restrict_isLink, Set.mem_setOf_eq, ++ simp only [traceGraph, induce_isLink, restrict_isLink, Set.mem_ofPred_eq, + Set.mem_inter_iff] + constructor + · rintro ⟨⟨hsub, hlink⟩, ⟨-, hxA⟩, ⟨-, hyA⟩⟩ +@@ -164,7 +164,7 @@ + rintro z (hz | hz) + · exact hz.2 + · obtain ⟨e, he, hze⟩ := Set.mem_iUnion₂.1 hz +- rw [edgeSet_eq_setOf_exists_isLink] at he ++ rw [edgeSet_eq_setOfPred_exists_isLink] at he + obtain ⟨x, y, hxy⟩ := he + exact (traceGraph_isLink A).1 hxy |>.1 hze + +@@ -185,7 +185,7 @@ + habsorb he ⟨z, ⟨hze, hzA, hzVG⟩⟩ + exact Or.inr (Set.mem_iUnion₂_of_mem + (show e ∈ E(traceGraph G drawing A) by +- rw [edgeSet_eq_setOf_exists_isLink] ++ rw [edgeSet_eq_setOfPred_exists_isLink] + obtain ⟨x, y, hxy⟩ := G.exists_isLink_of_mem_edgeSet he + have harc := hdraw.edge_isArcBetween hxy + exact ⟨x, y, (traceGraph_isLink A).2 +@@ -302,8 +302,8 @@ + Graph.edgesCover Hdraw D = edgeArc R.drawing e := by + let K := Graph.traceGraph H Hdraw (edgeArc R.drawing e) + have hKle : K ≤ H := Graph.traceGraph_le _ +- letI : H.Finite := hH.finite +- letI : K.Finite := Graph.Finite.of_le hKle ++ let : H.Finite := hH.finite ++ let : K.Finite := Graph.Finite.of_le hKle + have hpoint : pointSet K Hdraw = edgeArc R.drawing e := + edge_trace_pointSet hH hab.edge_mem + have haH : R.pos a ∈ V(H) := hH.vertexSet_subset (by +@@ -683,8 +683,8 @@ + ∃ D : List δ, K.IsPath a D b ∧ edgesCover Kdraw D = edgeArc Gdraw e := by + let T := Graph.traceGraph K Kdraw (edgeArc Gdraw e) + have hTK : T ≤ K := Graph.traceGraph_le _ +- letI : K.Finite := h.finite +- letI : T.Finite := Graph.Finite.of_le hTK ++ let : K.Finite := h.finite ++ let : T.Finite := Graph.Finite.of_le hTK + have hpoint : pointSet T Kdraw = edgeArc Gdraw e := h.edge_trace_pointSet hab.edge_mem + have haK : a ∈ V(K) := h.vertexSet_subset hab.left_mem + have hbK : b ∈ V(K) := h.vertexSet_subset hab.right_mem +@@ -1083,7 +1083,7 @@ + have hvertex : d.realizePos R t '' V(d.outer) = + insert (R.drawing d.edge t) (R.pos '' V(S.outerGraph)) := by + rw [CellStructure.SubdivData.outer, subdivGraph_vertexSet] +- simp only [d.outer_isLink he, and_true, Set.setOf_eq_eq_singleton, ++ simp only [d.outer_isLink he, and_true, Set.ofPred_eq_eq_singleton, + Set.image_union, Set.image_singleton, d.realizePos_newVertex] + rw [Set.union_comm] + congr 1 +@@ -1326,7 +1326,7 @@ + exact (P.src.isDrawing.edge_param heR).2.2.right_mem + have htIoo : t ∈ Set.Ioo (0 : ℝ) 1 := + ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0), lt_of_le_of_ne ht.2 ht1⟩ +- letI : Finite (Fin 3) := inferInstance ++ let : Finite (Fin 3) := inferInstance + obtain ⟨fresh, hfresh, havoid⟩ := + exists_injective_avoiding P.str.cells P.str.finite_cells (Fin 3) + have h01 : fresh 0 ≠ fresh 1 := fun h => by +diff --git a/Schoenflies/Concatenate.lean b/Schoenflies/Concatenate.lean +--- a/Schoenflies/Concatenate.lean ++++ b/Schoenflies/Concatenate.lean +@@ -84,11 +84,11 @@ + variable {f g : ℝ → Plane} + + theorem concatenate_of_le {t : ℝ} (ht : t ≤ 1 / 2) : concatenate f g t = f (2 * t) := +- if_pos ht ++ ite_eq_left ht + + theorem concatenate_of_not_le {t : ℝ} (ht : ¬t ≤ 1 / 2) : + concatenate f g t = g (2 * t - 1) := +- if_neg ht ++ ite_eq_right ht + + theorem concatenate_zero : concatenate f g 0 = f 0 := by + rw [concatenate_of_le (by norm_num)] +diff --git a/Schoenflies/Direction.lean b/Schoenflies/Direction.lean +--- a/Schoenflies/Direction.lean ++++ b/Schoenflies/Direction.lean +@@ -177,7 +177,7 @@ + have key : ∀ x : ℝ, 0 < r * x ↔ 0 < x := by + intro x + constructor <;> intro hx <;> nlinarith +- simp only [arcCCW, mem_setOf_eq, det_smul_left, det_smul_right, key] ++ simp only [arcCCW, mem_ofPred_eq, det_smul_left, det_smul_right, key] + + theorem dir_mem_arcCCW_iff (hd : d ≠ 0) : dir d ∈ arcCCW u w ↔ d ∈ arcCCW u w := by + obtain ⟨c, hc, hcd⟩ := dir_eq_smul hd +@@ -432,7 +432,7 @@ + by_cases h : 0 < det w u + · have : arcCCW u w = {d : Plane | 0 < det u d} ∪ {d : Plane | 0 < det d w} := by + ext d +- simp only [arcCCW, mem_setOf_eq, mem_union] ++ simp only [arcCCW, mem_ofPred_eq, mem_union] + constructor + · rintro (⟨h1, _⟩ | ⟨h2, _⟩ | ⟨_, h1⟩) <;> tauto + · rintro (hx | hx) +@@ -442,7 +442,7 @@ + exact h1.union h2 + · have : arcCCW u w = {d : Plane | 0 < det u d} ∩ {d : Plane | 0 < det d w} := by + ext d +- simp only [arcCCW, mem_setOf_eq, mem_inter_iff] ++ simp only [arcCCW, mem_ofPred_eq, mem_inter_iff] + constructor + · rintro (hx | ⟨_, hx⟩ | ⟨hx, _⟩) <;> [exact hx; exact absurd hx h; exact absurd hx h] + · exact Or.inl +diff --git a/Schoenflies/Endgame.lean b/Schoenflies/Endgame.lean +--- a/Schoenflies/Endgame.lean ++++ b/Schoenflies/Endgame.lean +@@ -112,28 +112,28 @@ + classical + refine ⟨fun z => if hz : z ∈ S then (e ⟨z, hz⟩ : Plane) else z, + fun w => if hw : w ∈ T then (e.symm ⟨w, hw⟩ : Plane) else w, +- ⟨?_, ?_, ?_, ?_, ?_, ?_⟩, fun z hz => dif_pos hz⟩ +- · exact fun z hz => by simp only [dif_pos hz]; exact (e ⟨z, hz⟩).2 +- · exact fun w hw => by simp only [dif_pos hw]; exact (e.symm ⟨w, hw⟩).2 +- · rw [continuousOn_iff_continuous_restrict] +- have heq : (S.restrict fun z => if hz : z ∈ S then (e ⟨z, hz⟩ : Plane) else z) = ++ ⟨?_, ?_, ?_, ?_, ?_, ?_⟩, fun z hz => dite_eq_left hz⟩ ++ · exact fun z hz => by simp only [dite_eq_left hz]; exact (e ⟨z, hz⟩).2 ++ · exact fun w hw => by simp only [dite_eq_left hw]; exact (e.symm ⟨w, hw⟩).2 ++ · rw [continuousOn_iff_continuous_domRestrict] ++ have heq : (S.domRestrict fun z => if hz : z ∈ S then (e ⟨z, hz⟩ : Plane) else z) = + fun z : ↥S => (e z : Plane) := by + funext z +- simp only [Set.restrict_apply, dif_pos z.2] ++ simp only [Set.domRestrict_apply, dite_eq_left z.2] + rw [heq] + exact continuous_subtype_val.comp e.continuous +- · rw [continuousOn_iff_continuous_restrict] +- have heq : (T.restrict fun w => if hw : w ∈ T then (e.symm ⟨w, hw⟩ : Plane) else w) = ++ · rw [continuousOn_iff_continuous_domRestrict] ++ have heq : (T.domRestrict fun w => if hw : w ∈ T then (e.symm ⟨w, hw⟩ : Plane) else w) = + fun w : ↥T => (e.symm w : Plane) := by + funext w +- simp only [Set.restrict_apply, dif_pos w.2] ++ simp only [Set.domRestrict_apply, dite_eq_left w.2] + rw [heq] + exact continuous_subtype_val.comp e.symm.continuous + · intro z hz +- simp only [dif_pos hz, dif_pos (e ⟨z, hz⟩).2] ++ simp only [dite_eq_left hz, dite_eq_left (e ⟨z, hz⟩).2] + exact congrArg Subtype.val (e.symm_apply_apply ⟨z, hz⟩) + · intro w hw +- simp only [dif_pos hw, dif_pos (e.symm ⟨w, hw⟩).2] ++ simp only [dite_eq_left hw, dite_eq_left (e.symm ⟨w, hw⟩).2] + exact congrArg Subtype.val (e.apply_symm_apply ⟨w, hw⟩) + + namespace IsHomeoOn +@@ -196,11 +196,11 @@ + + theorem paste_of_mem {S : Set Plane} {f₁ f₂ : Plane → Plane} {z : Plane} (hz : z ∈ S) : + paste S f₁ f₂ z = f₁ z := by +- classical exact if_pos hz ++ classical exact ite_eq_left hz + + theorem paste_of_notMem {S : Set Plane} {f₁ f₂ : Plane → Plane} {z : Plane} (hz : z ∉ S) : + paste S f₁ f₂ z = f₂ z := by +- classical exact if_neg hz ++ classical exact ite_eq_right hz + + /-! ### The square `Q` and its boundary `S` + +diff --git a/Schoenflies/FaceCyclesProof.lean b/Schoenflies/FaceCyclesProof.lean +--- a/Schoenflies/FaceCyclesProof.lean ++++ b/Schoenflies/FaceCyclesProof.lean +@@ -840,7 +840,7 @@ + (hint : ∀ y ∈ G.walkVertices a D', y ≠ a → y ≠ b → y ∉ V(B)) + (hnew : ∀ g ∈ D', g ∉ E(B)) : + HasFaceCycles (B.union (G.pathGraphOf a D')) drawing := by +- haveI : B.Finite := Finite.of_le hBG ++ have : B.Finite := Finite.of_le hBG + have hB : IsDrawing B drawing := h.mono hBG + have hne : D' ≠ [] := hpath.ne_nil hab + have hPG : G.pathGraphOf a D' ≤ G := pathGraphOf_le hpath.isWalk +diff --git a/Schoenflies/FiniteTransfer.lean b/Schoenflies/FiniteTransfer.lean +--- a/Schoenflies/FiniteTransfer.lean ++++ b/Schoenflies/FiniteTransfer.lean +@@ -735,7 +735,7 @@ + (ι : Type*) [Finite ι] : + ∃ fresh : ι → γ, Function.Injective fresh ∧ ∀ i, fresh i ∉ used := by + classical +- letI : Fintype ι := Fintype.ofFinite ι ++ let : Fintype ι := Fintype.ofFinite ι + let code : ι ↪ ℕ := (Fintype.equivFin ι).toEmbedding.trans Fin.valEmbedding + let supply : ℕ ↪ {x // x ∈ (usedᶜ : Set γ)} := + hused.infinite_compl.natEmbedding (usedᶜ : Set γ) +@@ -753,7 +753,7 @@ + ∀ x ∈ s, x ≠ a → x ≠ b → name x ∉ used := by + classical + let inner := {x : α // x ∈ s ∧ x ≠ a ∧ x ≠ b} +- letI : Finite inner := Set.finite_coe_iff.mpr (hs.subset fun x hx => hx.1) ++ let : Finite inner := Set.finite_coe_iff.mpr (hs.subset fun x hx => hx.1) + obtain ⟨fresh, hfresh, havoid⟩ := exists_injective_avoiding used hused inner + let name : α → γ := fun x => + if hxa : x = a then u else if hxb : x = b then v +@@ -1148,7 +1148,7 @@ + exact vname_fresh x hxQ (fun h => hxab (Or.inl h)) (fun h => hxab (Or.inr h)) hzCell + let edgeUsed : Set γ := T.str.cells ∪ newVertices + have hedgeUsed_fin : edgeUsed.Finite := T.str.finite_cells.union hnewVertices_fin +- letI : Finite E(Q) := Set.finite_coe_iff.mpr hQfinE ++ let : Finite E(Q) := Set.finite_coe_iff.mpr hQfinE + obtain ⟨freshEdge, freshEdge_inj, freshEdge_avoid⟩ := + exists_injective_avoiding edgeUsed hedgeUsed_fin E(Q) + let ename : γ → γ := fun e => if he : e ∈ E(Q) then freshEdge ⟨e, he⟩ else u +@@ -1383,7 +1383,7 @@ + (hsub : CommonSubdivision P H Hdraw) (hstep : EarStep P H Hdraw) : + ∃ (T : GeneratedPair S₀ srcOuter srcDom tgtOuter tgtDom) (par : γ → γ), + IsPartialTransferOf T P H Hdraw par := by +- haveI := hH.finite ++ have := hH.finite + obtain ⟨K, T₀, par₀, hK, hKH, hbase⟩ := hsub + refine hH.isTwoConnected.ear_decomposition + (motive := fun B => ∃ T par, IsPartialTransferOf T P B Hdraw par) +@@ -1549,7 +1549,7 @@ + exact fun hmem => Set.disjoint_left.1 + (P.tgt.disjoint_cell_skeletonSet P.tgt_isCellDecomposition hF) hmem + (P.tgt.pos_mem_skeletonSet hv) +- letI : (P.str.skel.map P.tgt.pos).Finite := { ++ let : (P.str.skel.map P.tgt.pos).Finite := { + finite_vertexSet := by + rw [Graph.vertexSet_map] + exact P.str.finite_vertexSet.image _ +diff --git a/Schoenflies/FiniteTransferTarget.lean b/Schoenflies/FiniteTransferTarget.lean +--- a/Schoenflies/FiniteTransferTarget.lean ++++ b/Schoenflies/FiniteTransferTarget.lean +@@ -561,7 +561,7 @@ + exact vname_fresh x hxQ (fun h => hxab (Or.inl h)) (fun h => hxab (Or.inr h)) hzCell + let edgeUsed : Set γ := T.str.cells ∪ newVertices + have hedgeUsed_fin : edgeUsed.Finite := T.str.finite_cells.union hnewVertices_fin +- letI : Finite E(Q) := Set.finite_coe_iff.mpr hQfinE ++ let : Finite E(Q) := Set.finite_coe_iff.mpr hQfinE + obtain ⟨freshEdge, freshEdge_inj, freshEdge_avoid⟩ := + exists_injective_avoiding edgeUsed hedgeUsed_fin E(Q) + let ename : γ → γ := fun e => if he : e ∈ E(Q) then freshEdge ⟨e, he⟩ else u +@@ -1128,8 +1128,8 @@ + T.str.OuterOnlyAt w.splitData.source) ∧ + (T.src.pos w.splitData.target ∈ srcOuter → + T.str.OuterOnlyAt w.splitData.target) := by +- letI : H.Finite := hH.finite +- letI : B.Finite := Graph.Finite.of_le hBH ++ let : H.Finite := hH.finite ++ let : B.Finite := Graph.Finite.of_le hBH + have hBdraw := hH.isDrawing.mono hBH + have hinside : Graph.edgesCover Hdraw D \ {a, b} ⊆ + T.tgt.cell w.splitData.face := by +@@ -1431,7 +1431,7 @@ + rw [← hGunion, Graph.pointSet_union] + change pointSet G T.src.drawing ∪ T.src.outerSet = _ + rw [T.src_isWeaklyAdmissible.outerSet_eq] +- letI : G.Finite := Graph.Finite.of_le Graph.deleteEdges_le ++ let : G.Finite := Graph.Finite.of_le Graph.deleteEdges_le + have hGdraw : G.IsDrawing T.src.drawing := T.src.isDrawing.mono Graph.deleteEdges_le + have hGpoly : ∀ e ∈ E(G), IsPolygonal (edgeArc T.src.drawing e) := by + intro e he +@@ -1441,7 +1441,7 @@ + have hFcells : T.src.cell F ∈ cells := ⟨F, hF, rfl⟩ + have hdisj : Disjoint (T.src.cell F) T.src.skeletonSet := + T.src.disjoint_cell_skeletonSet T.src_isCellDecomposition hF +- letI : O.Finite := Graph.Finite.of_le hOle ++ let : O.Finite := Graph.Finite.of_le hOle + have houterCompact : IsCompact srcOuter := by + rw [← T.src_isWeaklyAdmissible.outerSet_eq] + exact T.src.isCompact_skeletonSet.of_isClosed_subset +@@ -1794,7 +1794,7 @@ + (hsub : TargetCommonSubdivision P H Hdraw) (hstep : TargetEarStep P H Hdraw) : + ∃ (T : GeneratedPair S₀ srcOuter srcDom tgtOuter tgtDom) (par : γ → γ), + IsTargetPartialTransferOf T P H Hdraw par := by +- haveI := hH.finite ++ have := hH.finite + obtain ⟨K, T₀, par₀, hK, hKH, hbase⟩ := hsub + refine hH.isTwoConnected.ear_decomposition + (motive := fun B => ∃ T par, IsTargetPartialTransferOf T P B Hdraw par) +diff --git a/Schoenflies/FiniteTransferTargetMesh.lean b/Schoenflies/FiniteTransferTargetMesh.lean +--- a/Schoenflies/FiniteTransferTargetMesh.lean ++++ b/Schoenflies/FiniteTransferTargetMesh.lean +@@ -112,12 +112,12 @@ + · intro e he g hg heg + have hnames : freshName (⟨e, he⟩ : E(H)) = freshName ⟨g, hg⟩ := by + dsimp only [name] at heg +- rw [dif_pos he, dif_pos hg] at heg ++ rw [dite_eq_left he, dite_eq_left hg] at heg + exact heg + exact congrArg Subtype.val (hfreshName hnames) + · intro e he + dsimp only [name] +- rw [dif_pos he] ++ rw [dite_eq_left he] + exact havoid (⟨e, he⟩ : E(H)) + + /-- A finite square mesh can have all of its edges injectively renamed into any infinite cell +diff --git a/Schoenflies/FreshDenseSelection.lean b/Schoenflies/FreshDenseSelection.lean +--- a/Schoenflies/FreshDenseSelection.lean ++++ b/Schoenflies/FreshDenseSelection.lean +@@ -58,8 +58,8 @@ + have hforbiddenFinite : forbidden'.Finite := by + apply hforbidden.preimage + exact Set.injOn_of_injective Subtype.val_injective +- letI : ConnectedSpace C := Subtype.connectedSpace hC.isConnected +- letI : Nontrivial C := by ++ let : ConnectedSpace C := Subtype.connectedSpace hC.isConnected ++ let : Nontrivial C := by + obtain ⟨x, hx, y, hy, hxy⟩ := hC.exists_ne + exact ⟨⟨⟨x, hx⟩, ⟨y, hy⟩, fun h => hxy (congrArg Subtype.val h)⟩⟩ + have hcleanDense : Dense (eligible' \ forbidden') := +@@ -345,7 +345,7 @@ + StronglyAccessible (srcDom \ srcOuter) (P.homeo.invFun z)) ∧ + FreshAvoidsTargetNonouterEdges P fresh ∧ FreshDense fresh delta ∧ + FreshNet fresh delta := by +- letI : Graph.Finite P.tgt.graph := ++ let : Graph.Finite P.tgt.graph := + CellStructure.Realization.finite_graph P.tgt + have haccessibleSubset : accessibleTargetBoundary P ⊆ modelCurve := + fun _ hz => hz.1 +diff --git a/Schoenflies/GeneratedStructure.lean b/Schoenflies/GeneratedStructure.lean +--- a/Schoenflies/GeneratedStructure.lean ++++ b/Schoenflies/GeneratedStructure.lean +@@ -375,14 +375,14 @@ + + @[simp] theorem skeleton_vertexSet : V(d.skeleton) = insert d.newVertex V(S.skel) := by + ext z +- simp only [skeleton, subdivGraph_vertexSet, Set.mem_union, Set.mem_setOf_eq, ++ simp only [skeleton, subdivGraph_vertexSet, Set.mem_union, Set.mem_ofPred_eq, + Set.mem_insert_iff, d.isLink, and_true] + tauto + + @[simp] theorem skeleton_edgeSet : + E(d.skeleton) = insert d.newEdge₁ (insert d.newEdge₂ (E(S.skel) \ {d.edge})) := by + ext f +- simp only [skeleton, subdivGraph_edgeSet, Set.mem_union, Set.mem_setOf_eq, ++ simp only [skeleton, subdivGraph_edgeSet, Set.mem_union, Set.mem_ofPred_eq, + Set.mem_insert_iff, d.isLink, and_true] + tauto + +@@ -405,7 +405,7 @@ + theorem outer_edgeSet_of_mem (he : d.edge ∈ E(S.outerGraph)) : + E(d.outer) = insert d.newEdge₁ (insert d.newEdge₂ (E(S.outerGraph) \ {d.edge})) := by + ext f +- simp only [outer, subdivGraph_edgeSet, Set.mem_union, Set.mem_setOf_eq, ++ simp only [outer, subdivGraph_edgeSet, Set.mem_union, Set.mem_ofPred_eq, + Set.mem_insert_iff, d.outer_isLink he, and_true] + tauto + +@@ -1035,10 +1035,10 @@ + noncomputable def parent : γ → γ := fun σ => if σ ∈ d.newCells then d.edge else σ + + theorem parent_of_mem_newCells {σ : γ} (h : σ ∈ d.newCells) : d.parent σ = d.edge := by +- rw [parent]; exact if_pos h ++ rw [parent]; exact ite_eq_left h + + theorem parent_of_notMem_newCells {σ : γ} (h : σ ∉ d.newCells) : d.parent σ = σ := by +- rw [parent]; exact if_neg h ++ rw [parent]; exact ite_eq_right h + + theorem parent_of_mem_cells {σ : γ} (h : σ ∈ S.cells) : d.parent σ = σ := + d.parent_of_notMem_newCells (notMem_newCells_of_mem_cells h) +@@ -1361,10 +1361,10 @@ + noncomputable def parent : γ → γ := fun σ => if σ ∈ d.newCells then d.face else σ + + theorem parent_of_mem_newCells {σ : γ} (h : σ ∈ d.newCells) : d.parent σ = d.face := by +- rw [parent]; exact if_pos h ++ rw [parent]; exact ite_eq_left h + + theorem parent_of_notMem_newCells {σ : γ} (h : σ ∉ d.newCells) : d.parent σ = σ := by +- rw [parent]; exact if_neg h ++ rw [parent]; exact ite_eq_right h + + theorem parent_of_mem_cells {σ : γ} (h : σ ∈ S.cells) : d.parent σ = σ := + d.parent_of_notMem_newCells (notMem_newCells_of_mem_cells h) +@@ -1689,11 +1689,11 @@ + intro τ hτ + rw [subdivideEdge_cells] at hτ + ext z +- simp only [Set.mem_iUnion, Set.mem_setOf_eq, exists_prop] ++ simp only [Set.mem_iUnion, Set.mem_ofPred_eq, exists_prop] + rcases hτ with ⟨hτc, hτe⟩ | hτn + · -- a surviving cell: the index set gains the new cells exactly when it had `e` + rw [href.cell_eq hτc hτe, h.closure_eq hτc] +- simp only [Set.mem_iUnion, Set.mem_setOf_eq, exists_prop] ++ simp only [Set.mem_iUnion, Set.mem_ofPred_eq, exists_prop] + constructor + · rintro ⟨σ, ⟨hσc, hσsub⟩, hz⟩ + by_cases hσe : σ = d.edge +diff --git a/Schoenflies/Graph/Cycle.lean b/Schoenflies/Graph/Cycle.lean +--- a/Schoenflies/Graph/Cycle.lean ++++ b/Schoenflies/Graph/Cycle.lean +@@ -61,7 +61,7 @@ + edge lies on a cycle if and only if deleting it does not disconnect its endpoints", both + directions, with the finiteness the proof does not use dropped. The two halves are + `Graph.LiesOnCycle.deleteEdges_reaches` and `Graph.LiesOnCycle.of_deleteEdges_reaches`. +-* `Graph.IsBridge`, `Graph.isBridge_iff_not_reaches` — the bridges of ++* `Graph.IsSchoenfliesBridge`, `Graph.isBridge_iff_not_reaches` — the bridges of + `lem:subdivision-ear-preserve` ("a 2-connected graph has no bridge. Indeed, if `uv` were a + bridge, the two components of `G - uv` …"), stated as the separation of the two ends. + * `Graph.IsAcyclic`, `Graph.Connected.deleteEdges_singleton` — the acyclicity underneath +@@ -281,41 +281,41 @@ + + /-! ### Bridges -/ + +-/-- `G.IsBridge e` : an edge of `G` that lies on no cycle. Equivalently — and this is the ++/-- `G.IsSchoenfliesBridge e` : an edge of `G` that lies on no cycle. Equivalently — and this is the + form every use wants — an edge whose deletion separates its two ends + (`Graph.isBridge_iff_not_reaches`). -/ +-def IsBridge (G : Graph α β) (e : β) : Prop := e ∈ E(G) ∧ ¬ G.LiesOnCycle e +- +-theorem IsBridge.edge_mem (h : G.IsBridge e) : e ∈ E(G) := h.1 +- +-theorem IsBridge.not_liesOnCycle (h : G.IsBridge e) : ¬ G.LiesOnCycle e := h.2 ++def IsSchoenfliesBridge (G : Graph α β) (e : β) : Prop := e ∈ E(G) ∧ ¬ G.LiesOnCycle e ++ ++theorem IsSchoenfliesBridge.edge_mem (h : G.IsSchoenfliesBridge e) : e ∈ E(G) := h.1 ++ ++theorem IsSchoenfliesBridge.not_liesOnCycle (h : G.IsSchoenfliesBridge e) : ¬ G.LiesOnCycle e := h.2 + + /-- **Deleting a bridge separates its ends.** -/ +-theorem IsBridge.not_reaches (h : G.IsBridge e) (hl : G.IsLink e u v) : ++theorem IsSchoenfliesBridge.not_reaches (h : G.IsSchoenfliesBridge e) (hl : G.IsLink e u v) : + ¬ (G.deleteEdges {e}).Reaches u v := + fun hR ↦ h.not_liesOnCycle (LiesOnCycle.of_deleteEdges_reaches hl hR) + + /-- **An edge whose deletion separates its ends is a bridge.** -/ + theorem isBridge_of_not_reaches (hl : G.IsLink e u v) +- (h : ¬ (G.deleteEdges {e}).Reaches u v) : G.IsBridge e := ++ (h : ¬ (G.deleteEdges {e}).Reaches u v) : G.IsSchoenfliesBridge e := + ⟨hl.edge_mem, fun hc ↦ h (hc.deleteEdges_reaches hl)⟩ + + /-- **A bridge is exactly an edge whose deletion separates its ends** — the cycle criterion, + negated. -/ + theorem isBridge_iff_not_reaches (hl : G.IsLink e u v) : +- G.IsBridge e ↔ ¬ (G.deleteEdges {e}).Reaches u v := ++ G.IsSchoenfliesBridge e ↔ ¬ (G.deleteEdges {e}).Reaches u v := + ⟨fun h ↦ h.not_reaches hl, isBridge_of_not_reaches hl⟩ + + /-- A bridge is never a loop: a loop is a cycle. -/ +-theorem IsBridge.not_isLoopAt (h : G.IsBridge e) (x : α) : ¬ G.IsLoopAt e x := ++theorem IsSchoenfliesBridge.not_isLoopAt (h : G.IsSchoenfliesBridge e) (x : α) : ¬ G.IsLoopAt e x := + fun hloop ↦ h.not_liesOnCycle (liesOnCycle_of_isLoopAt hloop) + + /-- **A graph is acyclic exactly when every one of its edges is a bridge.** This is the form + the tree module wants acyclicity in: "it is a tree — an edge of a cycle could be deleted" + reads backwards as "no edge can be deleted without separating its ends". -/ +-theorem isAcyclic_iff_forall_isBridge : G.IsAcyclic ↔ ∀ e ∈ E(G), G.IsBridge e := ++theorem isAcyclic_iff_forall_isBridge : G.IsAcyclic ↔ ∀ e ∈ E(G), G.IsSchoenfliesBridge e := + ⟨fun h _ he ↦ ⟨he, h he⟩, fun h _ he ↦ (h _ he).not_liesOnCycle⟩ + +-theorem IsAcyclic.isBridge (h : G.IsAcyclic) (he : e ∈ E(G)) : G.IsBridge e := ⟨he, h he⟩ ++theorem IsAcyclic.isBridge (h : G.IsAcyclic) (he : e ∈ E(G)) : G.IsSchoenfliesBridge e := ⟨he, h he⟩ + + end Graph +diff --git a/Schoenflies/Graph/Degree.lean b/Schoenflies/Graph/Degree.lean +--- a/Schoenflies/Graph/Degree.lean ++++ b/Schoenflies/Graph/Degree.lean +@@ -231,23 +231,23 @@ + have hl : G.IsLoopAt e u := huv + have h1 : {x | G.Inc e x} = {u} := by + ext z +- simp only [Set.mem_setOf_eq, Set.mem_singleton_iff] ++ simp only [Set.mem_ofPred_eq, Set.mem_singleton_iff] + exact ⟨fun h => (hl.eq_of_inc h).symm, fun h => h ▸ hl.inc⟩ + have h2 : {x | G.IsLoopAt e x} = {u} := by + ext z +- simp only [Set.mem_setOf_eq, Set.mem_singleton_iff] ++ simp only [Set.mem_ofPred_eq, Set.mem_singleton_iff] + exact ⟨fun h => (hl.eq_of_inc h.inc).symm, fun h => h ▸ hl⟩ + rw [h1, h2] + simp + · -- A non-loop: two distinct vertices, one end at each, and no loop anywhere. + have h1 : {x | G.Inc e x} = {u, v} := by + ext z +- simp only [Set.mem_setOf_eq, Set.mem_insert_iff, Set.mem_singleton_iff] ++ simp only [Set.mem_ofPred_eq, Set.mem_insert_iff, Set.mem_singleton_iff] + exact ⟨fun h => h.eq_or_eq_of_isLink huv, + fun h => h.elim (fun hz => hz ▸ huv.inc_left) (fun hz => hz ▸ huv.inc_right)⟩ + have h2 : {x | G.IsLoopAt e x} = ∅ := by + ext z +- simp only [Set.mem_setOf_eq, Set.mem_empty_iff_false, iff_false] ++ simp only [Set.mem_ofPred_eq, Set.mem_empty_iff_false, iff_false] + intro hz + exact huv' ((hz.eq_of_inc huv.inc_left).symm.trans (hz.eq_of_inc huv.inc_right)) + rw [h1, h2, Set.ncard_pair huv'] +@@ -264,7 +264,7 @@ + rw [← Finset.card_filter p s, ← Set.ncard_coe_finset] + congr 1 + ext z +- simp only [Finset.coe_filter, Set.mem_setOf_eq] ++ simp only [Finset.coe_filter, Set.mem_ofPred_eq] + exact ⟨fun h => ⟨hsub z h, h⟩, fun h => h.2⟩ + + /-- **The handshake lemma.** The degrees of the vertices of a finite multigraph add up to +diff --git a/Schoenflies/Graph/K33Land.lean b/Schoenflies/Graph/K33Land.lean +--- a/Schoenflies/Graph/K33Land.lean ++++ b/Schoenflies/Graph/K33Land.lean +@@ -154,10 +154,10 @@ + have := ZMod.val_lt j; omega + have hw_lt : ∀ j : ZMod (n + 3), j.val < k → + w j = P.vertex (a + ((j.val : ℕ) : ZMod (m + 3))) := fun j hj => by +- rw [hwdef]; exact if_pos hj ++ rw [hwdef]; exact ite_eq_left hj + have hw_ge : ∀ j : ZMod (n + 3), ¬ j.val < k → + w j = P'.vertex (b + ((j.val - k : ℕ) : ZMod (m' + 3))) := fun j hj => by +- rw [hwdef]; exact if_neg hj ++ rw [hwdef]; exact ite_eq_right hj + have hsucc_lt : ∀ j : ZMod (n + 3), j.val < k → + w (j + 1) = P.vertex (a + ((j.val : ℕ) : ZMod (m + 3)) + 1) := by + intro j hj +diff --git a/Schoenflies/Graph/OuterFace.lean b/Schoenflies/Graph/OuterFace.lean +--- a/Schoenflies/Graph/OuterFace.lean ++++ b/Schoenflies/Graph/OuterFace.lean +@@ -90,7 +90,7 @@ + have hmem : Schoenflies.Plane.mk t 0 ∈ Schoenflies.Plane.beyondSquare r := + Or.inl (show r < |t| by rw [abs_of_nonneg ht0]; exact htr) + have hin := hs hmem +- simp only [Schoenflies.Plane.closedSquare, mem_setOf_eq, Schoenflies.Plane.supDist_zero, ++ simp only [Schoenflies.Plane.closedSquare, mem_ofPred_eq, Schoenflies.Plane.supDist_zero, + Schoenflies.Plane.supNorm, max_le_iff] at hin + have h1 : |t| ≤ s := hin.1 + rw [abs_of_nonneg ht0] at h1 +diff --git a/Schoenflies/Graph/PathGraph.lean b/Schoenflies/Graph/PathGraph.lean +--- a/Schoenflies/Graph/PathGraph.lean ++++ b/Schoenflies/Graph/PathGraph.lean +@@ -245,7 +245,7 @@ + theorem pathGraphOf_isLink : + (G.pathGraphOf u W).IsLink e x y ↔ + e ∈ W ∧ G.IsLink e x y ∧ x ∈ G.walkVertices u W ∧ y ∈ G.walkVertices u W := by +- simp only [pathGraphOf, induce_isLink, restrict_isLink, mem_setOf_eq] ++ simp only [pathGraphOf, induce_isLink, restrict_isLink, mem_ofPred_eq] + tauto + + theorem mem_vertexSet_pathGraphOf_self : u ∈ V(G.pathGraphOf u W) := mem_walkVertices_self +@@ -258,8 +258,8 @@ + walk, to know that an entry of `W` is an edge of `G` at all and that its ends are visited. -/ + theorem pathGraphOf_edgeSet (h : G.IsWalk u W v) : E(G.pathGraphOf u W) = {e | e ∈ W} := by + ext f +- rw [edgeSet_eq_setOf_exists_isLink] +- simp only [pathGraphOf_isLink, mem_setOf_eq] ++ rw [edgeSet_eq_setOfPred_exists_isLink] ++ simp only [pathGraphOf_isLink, mem_ofPred_eq] + refine ⟨fun ⟨_, _, hf, _⟩ ↦ hf, fun hf ↦ ?_⟩ + obtain ⟨a, b, hab⟩ := exists_isLink_of_mem_edgeSet (h.edge_mem hf) + exact ⟨a, b, hf, hab, mem_walkVertices_of_mem_covered ⟨f, hf, hab.inc_left⟩, +diff --git a/Schoenflies/Graph/Tree.lean b/Schoenflies/Graph/Tree.lean +--- a/Schoenflies/Graph/Tree.lean ++++ b/Schoenflies/Graph/Tree.lean +@@ -241,7 +241,7 @@ + refine h.anti deleteVerts_le ?_ fun g hg ↦ ?_ + · exact ⟨h.left_mem, hX u mem_walkVertices_self⟩ + · obtain ⟨p, q, hpq⟩ := exists_isLink_of_mem_edgeSet (h.edge_mem hg) +- simp only [edgeSet_deleteVerts, Set.mem_setOf_eq] ++ simp only [edgeSet_deleteVerts, Set.mem_ofPred_eq] + exact ⟨p, q, hpq, hX p (mem_walkVertices_of_mem_covered ⟨g, hg, hpq.inc_left⟩), + hX q (mem_walkVertices_of_mem_covered ⟨g, hg, hpq.inc_right⟩)⟩ + +@@ -249,7 +249,7 @@ + theorem edgeSet_deleteVerts_singleton (G : Graph α β) (x : α) : + E(G.deleteVerts {x}) = E(G) \ G.incidenceSet x := by + ext g +- simp only [edgeSet_deleteVerts, Set.mem_setOf_eq, Set.mem_sdiff, mem_incidenceSet, ++ simp only [edgeSet_deleteVerts, Set.mem_ofPred_eq, Set.mem_sdiff, mem_incidenceSet, + Set.mem_singleton_iff] + refine ⟨fun ⟨p, q, hpq, hp, hq⟩ ↦ ⟨hpq.edge_mem, fun hinc ↦ ?_⟩, fun ⟨hg, hninc⟩ ↦ ?_⟩ + · rcases hinc.eq_or_eq_of_isLink hpq with rfl | rfl +@@ -282,16 +282,16 @@ + induction n with + | zero => + intro G hfin hle hT +- haveI := hfin ++ have := hfin + obtain ⟨a, ha⟩ := hT.connected.nonempty + have := (Set.ncard_pos (finite_vertexSet G)).2 ⟨a, ha⟩ + omega + | succ n ih => + intro G hfin hle hT +- haveI := hfin ++ have := hfin + by_cases h2 : 2 ≤ V(G).ncard + · obtain ⟨x, hx⟩ := hT.has_leaf h2 +- haveI : (G.deleteVerts {x}).Finite := Finite.of_le deleteVerts_le ++ have : (G.deleteVerts {x}).Finite := Finite.of_le deleteVerts_le + have hT' : (G.deleteVerts {x}).IsTree := hT.delete_leaf hx h2 + have hV : V(G.deleteVerts {x}).ncard = V(G).ncard - 1 := by + rw [vertexSet_deleteVerts, Set.ncard_sdiff_singleton_of_mem hx.mem_vertexSet] +diff --git a/Schoenflies/GridAttach.lean b/Schoenflies/GridAttach.lean +--- a/Schoenflies/GridAttach.lean ++++ b/Schoenflies/GridAttach.lean +@@ -184,7 +184,7 @@ + Graph.SameLinks (pieceListGraph (subdivide pieces points)) (overlayGraph pieces points) := by + constructor + · ext v +- simp only [pieceListGraph_vertexSet, overlayGraph_vertexSet, endSet, mem_setOf_eq] ++ simp only [pieceListGraph_vertexSet, overlayGraph_vertexSet, endSet, mem_ofPred_eq] + constructor + · rintro ⟨P, hP, hv⟩ + exact ⟨orientPiece P, mem_overlayPieces.2 ⟨P, hP, rfl⟩, (orientPiece_ends P v).2 hv⟩ +@@ -346,12 +346,12 @@ + · rintro ⟨P, hP, hx⟩ + rw [List.mem_singleton] at hP + subst hP +- simp only [Graph.walkVertices, mem_insert_iff, Graph.coveredVertices, mem_setOf_eq] ++ simp only [Graph.walkVertices, mem_insert_iff, Graph.coveredVertices, mem_ofPred_eq] + rcases hx with h | h + · exact Or.inl h + · exact Or.inr ⟨(q₀, q₁), hmem, pieceListGraph_inc hmem (Or.inr h)⟩ + · intro hx +- simp only [Graph.walkVertices, mem_insert_iff, Graph.coveredVertices, mem_setOf_eq] at hx ++ simp only [Graph.walkVertices, mem_insert_iff, Graph.coveredVertices, mem_ofPred_eq] at hx + rcases hx with h | ⟨e, he, hinc⟩ + · exact ⟨(q₀, q₁), hmem, Or.inl h⟩ + · rw [List.mem_singleton] at he +diff --git a/Schoenflies/InitialPair.lean b/Schoenflies/InitialPair.lean +--- a/Schoenflies/InitialPair.lean ++++ b/Schoenflies/InitialPair.lean +@@ -154,28 +154,28 @@ + obtain ⟨h⟩ := hC.homeomorph_modelCurve + refine ⟨fun p => if hp : p ∈ C then (h ⟨p, hp⟩ : Plane) else 0, + fun q => if hq : q ∈ modelCurve then (h.symm ⟨q, hq⟩ : Plane) else 0, ?_, ?_, ?_, ?_, ?_, ?_⟩ +- · rw [continuousOn_iff_continuous_restrict] +- have : (C.restrict fun p => if hp : p ∈ C then (h ⟨p, hp⟩ : Plane) else 0) = ++ · rw [continuousOn_iff_continuous_domRestrict] ++ have : (C.domRestrict fun p => if hp : p ∈ C then (h ⟨p, hp⟩ : Plane) else 0) = + fun p : ↥C => (h p : Plane) := by +- funext p; simp [Set.restrict, p.2] ++ funext p; simp [Set.domRestrict, p.2] + rw [this] + exact continuous_subtype_val.comp h.continuous +- · rw [continuousOn_iff_continuous_restrict] +- have : (modelCurve.restrict fun q => if hq : q ∈ modelCurve then (h.symm ⟨q, hq⟩ : Plane) ++ · rw [continuousOn_iff_continuous_domRestrict] ++ have : (modelCurve.domRestrict fun q => if hq : q ∈ modelCurve then (h.symm ⟨q, hq⟩ : Plane) + else 0) = fun q : ↥modelCurve => (h.symm q : Plane) := by +- funext q; simp [Set.restrict, q.2] ++ funext q; simp [Set.domRestrict, q.2] + rw [this] + exact continuous_subtype_val.comp h.symm.continuous +- · intro p hp; simp only [dif_pos hp]; exact (h ⟨p, hp⟩).2 +- · intro q hq; simp only [dif_pos hq]; exact (h.symm ⟨q, hq⟩).2 ++ · intro p hp; simp only [dite_eq_left hp]; exact (h ⟨p, hp⟩).2 ++ · intro q hq; simp only [dite_eq_left hq]; exact (h.symm ⟨q, hq⟩).2 + · intro p hp + have hmem : (h ⟨p, hp⟩ : Plane) ∈ modelCurve := (h ⟨p, hp⟩).2 +- simp only [dif_pos hp, dif_pos hmem] ++ simp only [dite_eq_left hp, dite_eq_left hmem] + have : (⟨(h ⟨p, hp⟩ : Plane), hmem⟩ : ↥modelCurve) = h ⟨p, hp⟩ := rfl + rw [this, h.symm_apply_apply] + · intro q hq + have hmem : (h.symm ⟨q, hq⟩ : Plane) ∈ C := (h.symm ⟨q, hq⟩).2 +- simp only [dif_pos hq, dif_pos hmem] ++ simp only [dite_eq_left hq, dite_eq_left hmem] + have : (⟨(h.symm ⟨q, hq⟩ : Plane), hmem⟩ : ↥C) = h.symm ⟨q, hq⟩ := rfl + rw [this, h.apply_symm_apply] + +@@ -1444,10 +1444,10 @@ + d.cross (Function.invFunOn (tgtChord d.xa d.xb) I y) + + theorem skelMap_of_mem {x : Plane} (hx : x ∈ C) : d.skelMap x = d.u x := by +- simp only [skelMap, if_pos hx] ++ simp only [skelMap, ite_eq_left hx] + + theorem skelInv_of_mem {y : Plane} (hy : y ∈ modelCurve) : d.skelInv y = d.w y := by +- simp only [skelInv, if_pos hy] ++ simp only [skelInv, ite_eq_left hy] + + /-- **The skeleton map matches parameters on the crosscut.** -/ + theorem skelMap_cross {t : ℝ} (ht : t ∈ I) : +@@ -1458,7 +1458,7 @@ + simp [tgtChord] + · rw [d.skelMap_of_mem hmem, d.cross_one, d.u_b] + simp [tgtChord] +- · simp only [skelMap, if_neg hmem, d.injOn_cross.leftInvOn_invFunOn ht] ++ · simp only [skelMap, ite_eq_right hmem, d.injOn_cross.leftInvOn_invFunOn ht] + + theorem tgtChord_mem_modelCurve_iff {t : ℝ} (ht : t ∈ I) : + tgtChord d.xa d.xb t ∈ modelCurve ↔ t = 0 ∨ t = 1 := by +@@ -1486,7 +1486,7 @@ + simp [tgtChord] + · rw [d.skelInv_of_mem hmem, d.cross_one] + simp [tgtChord] +- · simp only [skelInv, if_neg hmem, d.injOn_tgtChord.leftInvOn_invFunOn ht] ++ · simp only [skelInv, ite_eq_right hmem, d.injOn_tgtChord.leftInvOn_invFunOn ht] + + /-! #### Continuity and inversion -/ + +diff --git a/Schoenflies/InitialPairFixed.lean b/Schoenflies/InitialPairFixed.lean +--- a/Schoenflies/InitialPairFixed.lean ++++ b/Schoenflies/InitialPairFixed.lean +@@ -307,7 +307,7 @@ + c ∈ faceCells k ↔ + c ∈ initialStructure.pathCells u (initBoundary (.face k)) := by + rw [mem_faceCells_iff] +- simp only [CellStructure.pathCells, Set.mem_union, Set.mem_setOf_eq, ++ simp only [CellStructure.pathCells, Set.mem_union, Set.mem_ofPred_eq, + Graph.mem_walkVertices_iff, Graph.mem_coveredVertices_iff] + constructor + · rintro (hc | hc) +diff --git a/Schoenflies/Inversion.lean b/Schoenflies/Inversion.lean +--- a/Schoenflies/Inversion.lean ++++ b/Schoenflies/Inversion.lean +@@ -172,8 +172,8 @@ + z.2 (mem_singleton_iff.2 (invert_eq_center_iff.1 (mem_singleton_iff.1 h)))⟩ + left_inv z := Subtype.ext (invert_invert a z) + right_inv z := Subtype.ext (invert_invert a z) +- continuous_toFun := ((continuousOn_invert a).restrict).subtype_mk _ +- continuous_invFun := ((continuousOn_invert a).restrict).subtype_mk _ ++ continuous_toFun := ((continuousOn_invert a).domRestrict).subtype_mk _ ++ continuous_invFun := ((continuousOn_invert a).domRestrict).subtype_mk _ + + /-! ### The image of a Jordan curve + +diff --git a/Schoenflies/LimitMap.lean b/Schoenflies/LimitMap.lean +--- a/Schoenflies/LimitMap.lean ++++ b/Schoenflies/LimitMap.lean +@@ -477,7 +477,7 @@ + + /-- **The characterising property of `F`.** -/ + theorem iInter_tgtStar_eq (hx : x ∈ L.dom) : ⋂ n, L.tgtStar n x = {L.F x} := by +- rw [F, dif_pos (L.exists_eq_singleton_iInter_tgtStar hx)] ++ rw [F, dite_eq_left (L.exists_eq_singleton_iInter_tgtStar hx)] + exact (L.exists_eq_singleton_iInter_tgtStar hx).choose_spec + + theorem F_mem_iInter (hx : x ∈ L.dom) : L.F x ∈ ⋂ n, L.tgtStar n x := by +@@ -863,7 +863,7 @@ + + theorem inv_spec (h : ∃ x, x ∈ L.region ∧ L.F x = y) : + L.inv y ∈ L.region ∧ L.F (L.inv y) = y := by +- rw [inv, dif_pos h] ++ rw [inv, dite_eq_left h] + exact h.choose_spec + + theorem inv_mem_region (hy : y ∈ L.region') : L.inv y ∈ L.region := +diff --git a/Schoenflies/LocallyPolygonal.lean b/Schoenflies/LocallyPolygonal.lean +--- a/Schoenflies/LocallyPolygonal.lean ++++ b/Schoenflies/LocallyPolygonal.lean +@@ -185,7 +185,7 @@ + centre in each coordinate separately. -/ + theorem mem_openSquare_iff (c : Plane) (r : ℝ) (x : Plane) : + x ∈ openSquare c r ↔ ∀ i, |x i - c i| < r := by +- simp only [openSquare, mem_setOf_eq, supDist, supNorm, sub_apply, max_lt_iff, ++ simp only [openSquare, mem_ofPred_eq, supDist, supNorm, sub_apply, max_lt_iff, + Fin.forall_fin_two] + + /-- The centre of a square of positive radius is in it. -/ +@@ -246,17 +246,17 @@ + rw [abs_lt] at hlt + cases b + · exact absurd (show x i ≤ c i - r from hmem) (by +- simp only [sideGap, cond_false] at hs; linarith [hlt.1]) ++ simp only [sideGap, Bool.cond_false] at hs; linarith [hlt.1]) + · exact absurd (show c i + r ≤ x i from hmem) (by +- simp only [sideGap, cond_true] at hs; linarith [hlt.2]) ++ simp only [sideGap, Bool.cond_true] at hs; linarith [hlt.2]) + + /-- If there is no room between `p` and a half-plane, `p` is in it. -/ + theorem mem_sideHalfPlane_of_sideGap_nonpos {c : Plane} {r : ℝ} {p : Plane} {i : Fin 2} + {b : Bool} (h : sideGap c r p i b ≤ 0) : p ∈ sideHalfPlane c r i b := by + cases b +- · simp only [sideGap, cond_false] at h ++ · simp only [sideGap, Bool.cond_false] at h + exact show p i ≤ c i - r by linarith +- · simp only [sideGap, cond_true] at h ++ · simp only [sideGap, Bool.cond_true] at h + exact show c i + r ≤ p i by linarith + + /-- Each piece the sides of one square cut a small square into is an axis-parallel rectangle — +@@ -346,7 +346,7 @@ + rintro c ⟨hcA, hcne⟩ + have : p ∉ closedSquare c (ρ c) := + Set.disjoint_left.1 (hdisj c₀ hc₀A c hcA fun h => hcne (h ▸ rfl)) hpc₀ +- simp only [closedSquare, mem_setOf_eq, not_le] at this ++ simp only [closedSquare, mem_ofPred_eq, not_le] at this + linarith + obtain ⟨s₁, hs₁, hs₁le⟩ := exists_pos_le_of_finite (hA.sdiff (t := {c₀})) + (f := fun c => supDist p c - ρ c) hfar +@@ -388,7 +388,7 @@ + have hfar : ∀ c ∈ A, 0 < supDist p c - ρ c := by + intro c hcA + have := hnear c hcA +- simp only [closedSquare, mem_setOf_eq, not_le] at this ++ simp only [closedSquare, mem_ofPred_eq, not_le] at this + linarith + obtain ⟨s, hs, hsle⟩ := exists_pos_le_of_finite hA (f := fun c => supDist p c - ρ c) hfar + refine isLocallyPolyConnAt_of_convex (isOpen_openSquare p s) +diff --git a/Schoenflies/MatchedSplit.lean b/Schoenflies/MatchedSplit.lean +--- a/Schoenflies/MatchedSplit.lean ++++ b/Schoenflies/MatchedSplit.lean +@@ -319,7 +319,7 @@ + theorem splitMap_of_mem_skeletonSet {x : Plane} (hx : x ∈ R₁.skeletonSet) : + splitMap g m x = g.toFun x := by + classical +- simp only [splitMap, if_pos hx] ++ simp only [splitMap, ite_eq_left hx] + + theorem splitMap_eqOn_skeletonSet : EqOn (splitMap g m) g.toFun R₁.skeletonSet := + fun _ hx => splitMap_of_mem_skeletonSet hx +@@ -327,12 +327,12 @@ + theorem splitInvMap_of_mem_skeletonSet {y : Plane} (hy : y ∈ R₂.skeletonSet) : + splitInvMap g m y = g.invFun y := by + classical +- simp only [splitInvMap, if_pos hy] ++ simp only [splitInvMap, ite_eq_left hy] + + theorem splitInvMap_of_notMem_skeletonSet {y : Plane} (hy : y ∉ R₂.skeletonSet) : + splitInvMap g m y = m.invFun y := by + classical +- simp only [splitInvMap, if_neg hy] ++ simp only [splitInvMap, ite_eq_right hy] + + variable (hE₁ : d.EarCrosscut R₁ earPos₁ earDraw₁) (hE₂ : d.EarCrosscut R₂ earPos₂ earDraw₂) + +@@ -345,13 +345,13 @@ + splitMap g m x = m.toFun x := by + classical + by_cases hs : x ∈ R₁.skeletonSet +- · rw [splitMap, if_pos hs] ++ · rw [splitMap, ite_eq_left hs] + have hends := hE₁.earSet_inter_skeletonSet ⟨hx, hs⟩ + simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hends + rcases hends with rfl | rfl + · rw [g.pos_apply d.source_mem_skel, m.toFun_pos_source hE₁ hE₂] + · rw [g.pos_apply d.target_mem_skel, m.toFun_pos_target hE₁ hE₂] +- · rw [splitMap, if_neg hs] ++ · rw [splitMap, ite_eq_right hs] + + theorem splitMap_eqOn_earSet : EqOn (splitMap g m) m.toFun (d.earSet earPos₁ earDraw₁) := + fun _ hx => splitMap_of_mem_earSet hE₁ hE₂ hx +@@ -362,7 +362,7 @@ + classical + intro y hy + by_cases hs : y ∈ R₂.skeletonSet +- · rw [splitInvMap, if_pos hs] ++ · rw [splitInvMap, ite_eq_left hs] + have hends := hE₂.earSet_inter_skeletonSet ⟨hy, hs⟩ + simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hends + rcases hends with rfl | rfl +@@ -370,7 +370,7 @@ + rw [h, m.invFun_pos_source hE₁ hE₂] + · have h : g.invFun (R₂.pos d.target) = R₁.pos d.target := g.symm.pos_apply d.target_mem_skel + rw [h, m.invFun_pos_target hE₁ hE₂] +- · rw [splitInvMap, if_neg hs] ++ · rw [splitInvMap, ite_eq_right hs] + + /-- **A point of the source ear off the old skeleton is carried off the old target skeleton.** + The image lies on the target ear, and the target ear meets the target skeleton only in the two +diff --git a/Schoenflies/ModelCurve.lean b/Schoenflies/ModelCurve.lean +--- a/Schoenflies/ModelCurve.lean ++++ b/Schoenflies/ModelCurve.lean +@@ -167,7 +167,7 @@ + theorem modelCurve_eq_sides : + modelCurve = (sideTop ∪ sideLeft) ∪ (sideBottom ∪ sideRight) := by + ext x +- simp only [modelCurve, mem_setOf_eq, mem_union, mem_sideTop, mem_sideLeft, mem_sideBottom, ++ simp only [modelCurve, mem_ofPred_eq, mem_union, mem_sideTop, mem_sideLeft, mem_sideBottom, + mem_sideRight, Plane.supNorm] + constructor + · intro h +@@ -373,7 +373,7 @@ + theorem modelCurve_eq_frontier : modelCurve = frontier (Plane.closedSquare 0 1) := by + rw [(Plane.isClosed_closedSquare 0 1).frontier_eq, interior_closedSquare_zero_one] + ext x +- simp only [modelCurve, mem_setOf_eq, mem_sdiff, mem_closedSquare_zero_one, ++ simp only [modelCurve, mem_ofPred_eq, mem_sdiff, mem_closedSquare_zero_one, + mem_openSquare_zero_one, not_lt] + exact ⟨fun h => ⟨h.le, h.ge⟩, fun h => le_antisymm h.1 h.2⟩ + +@@ -420,14 +420,14 @@ + ∃ h : ↥(f '' I) ≃ₜ ↥(g '' I), + ∀ (t : ℝ) (ht : t ∈ I), (h ⟨f t, mem_image_of_mem f ht⟩ : Plane) = g t := by + classical +- haveI : CompactSpace ↥I := isCompact_iff_compactSpace.mp isCompact_I +- haveI : CompactSpace ↥(f '' I) := ++ have : CompactSpace ↥I := isCompact_iff_compactSpace.mp isCompact_I ++ have : CompactSpace ↥(f '' I) := + isCompact_iff_compactSpace.mp (isCompact_I.image_of_continuousOn hf.continuousOn) + -- the two parametrizations, read as maps of subtypes + set q : ↥I → ↥(f '' I) := fun t => ⟨f t, mem_image_of_mem f t.2⟩ with hq + set q' : ↥I → ↥(g '' I) := fun t => ⟨g t, mem_image_of_mem g t.2⟩ with hq' +- have hqc : Continuous q := (hf.continuousOn.restrict).subtype_mk _ +- have hq'c : Continuous q' := (hg.continuousOn.restrict).subtype_mk _ ++ have hqc : Continuous q := (hf.continuousOn.domRestrict).subtype_mk _ ++ have hq'c : Continuous q' := (hg.continuousOn.domRestrict).subtype_mk _ + have hqs : Function.Surjective q := by + rintro ⟨z, t, ht, rfl⟩ + exact ⟨⟨t, ht⟩, rfl⟩ +diff --git a/Schoenflies/OuterChain.lean b/Schoenflies/OuterChain.lean +--- a/Schoenflies/OuterChain.lean ++++ b/Schoenflies/OuterChain.lean +@@ -309,13 +309,13 @@ + have harc : ∀ {W : List β}, (∀ g ∈ W, g ∈ D₁ ++ D₂) → + ∀ g ∈ W, g ∈ E(H.cycleGraph u e D) := by + intro W hW g hg +- rw [hcyc.cycleGraph_edgeSet, Set.mem_setOf_eq, List.mem_append] ++ rw [hcyc.cycleGraph_edgeSet, Set.mem_ofPred_eq, List.mem_append] + rcases List.mem_cons.1 (hcc.split.mem_iff.1 (hW g hg)) with rfl | h + · exact Or.inr (List.mem_singleton_self _) + · exact Or.inl h + have hnew : ∀ g ∈ R, g ∉ E(H.cycleGraph u e D) := by + intro g hg hmem +- rw [hcyc.cycleGraph_edgeSet, Set.mem_setOf_eq] at hmem ++ rw [hcyc.cycleGraph_edgeSet, Set.mem_ofPred_eq] at hmem + exact hcc.edges_new g hg hmem + have hint : ∀ y ∈ H.walkVertices a R, y ≠ a → y ≠ b → y ∉ V(H.cycleGraph u e D) := by + intro y hy hya hyb +@@ -779,7 +779,7 @@ + ¬ Bornology.IsBounded (face (chainUnion Γ 0 n) drawing x) := by + have hext := h.mem_exterior_chain hout + refine ⟨hext, fun hb => ?_⟩ +- haveI : (chainUnion Γ 0 n).Finite := h.block_finite (i := 0) (m := n) (by omega) ++ have : (chainUnion Γ 0 n).Finite := h.block_finite (i := 0) (m := n) (by omega) + exact h.not_encloses hout hdesc n 0 (by omega) + (encloses_of_isBounded_face (h.block_isDrawing (by omega)) (h.block_polygonal (by omega)) + (h.block_isTwoConnected (by omega)) hext hb) +diff --git a/Schoenflies/OverlayExtension.lean b/Schoenflies/OverlayExtension.lean +--- a/Schoenflies/OverlayExtension.lean ++++ b/Schoenflies/OverlayExtension.lean +@@ -22,7 +22,7 @@ + + namespace Schoenflies + +-open Graph ++open _root_.Schoenflies.Graph + + namespace IsPlaneSubdivisionExtension + +diff --git a/Schoenflies/OverlayGraph.lean b/Schoenflies/OverlayGraph.lean +--- a/Schoenflies/OverlayGraph.lean ++++ b/Schoenflies/OverlayGraph.lean +@@ -88,12 +88,12 @@ + + theorem orientPiece_of_precedes {P : Piece} (h : Precedes P.1 P.2) : orientPiece P = P := by + classical +- exact if_pos h ++ exact ite_eq_left h + + theorem orientPiece_of_not_precedes {P : Piece} (h : ¬ Precedes P.1 P.2) : + orientPiece P = (P.2, P.1) := by + classical +- exact if_neg h ++ exact ite_eq_right h + + /-- Orienting does not move the segment. -/ + @[simp] theorem orientPiece_seg (P : Piece) : (orientPiece P).seg = P.seg := by +@@ -247,7 +247,7 @@ + rcases hxy with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> rcases hvw with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> simp + edge_mem_iff_exists_isLink := by + intro P +- simp only [mem_setOf_eq] ++ simp only [mem_ofPred_eq] + exact ⟨fun hP => ⟨P.1, P.2, hP, Or.inl ⟨rfl, rfl⟩⟩, fun ⟨_, _, hP, _⟩ => hP⟩ + left_mem_of_isLink := by + rintro P x y ⟨hP, h⟩ +@@ -347,7 +347,7 @@ + rw [← overlayPieces_cover pieces points] + ext z + simp only [Graph.pointSet, mem_union, mem_iUnion, exists_prop, overlayGraph_vertexSet, +- endSet, mem_setOf_eq, overlayGraph_mem_edgeSet, edgeArc_segmentDrawing, cover] ++ endSet, mem_ofPred_eq, overlayGraph_mem_edgeSet, edgeArc_segmentDrawing, cover] + constructor + · rintro (⟨P, hP, hzP⟩ | ⟨P, hP, hzP⟩) + · refine ⟨P, hP, ?_⟩ +diff --git a/Schoenflies/Parity.lean b/Schoenflies/Parity.lean +--- a/Schoenflies/Parity.lean ++++ b/Schoenflies/Parity.lean +@@ -377,19 +377,22 @@ + by_cases hD : fwd u q < fwd u (meet u a b (hgt u q)) + · by_cases h1 : hgt u a ≤ hgt u q + · by_cases h2 : hgt u q < hgt u c +- · rw [if_pos ⟨h1, h2, hD⟩, if_neg (by rintro ⟨g, -, -⟩; linarith), +- if_pos ⟨h1, by linarith, hD⟩] ++ · rw [ite_eq_left ⟨h1, h2, hD⟩, ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_left ⟨h1, by linarith, hD⟩] + · push Not at h2 + by_cases h3 : hgt u q < hgt u b +- · rw [if_neg (by rintro ⟨-, g, -⟩; linarith), if_pos ⟨h2, h3, hD⟩, +- if_pos ⟨h1, h3, hD⟩] +- · rw [if_neg (by rintro ⟨-, g, -⟩; linarith), if_neg (by rintro ⟨-, g, -⟩; linarith), +- if_neg (by rintro ⟨-, g, -⟩; linarith)] ++ · rw [ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ite_eq_left ⟨h2, h3, hD⟩, ++ ite_eq_left ⟨h1, h3, hD⟩] ++ · rw [ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith)] + · push Not at h1 +- rw [if_neg (by rintro ⟨g, -, -⟩; linarith), if_neg (by rintro ⟨g, -, -⟩; linarith), +- if_neg (by rintro ⟨g, -, -⟩; linarith)] +- · rw [if_neg (by rintro ⟨-, -, g⟩; exact hD g), if_neg (by rintro ⟨-, -, g⟩; exact hD g), +- if_neg (by rintro ⟨-, -, g⟩; exact hD g)] ++ rw [ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith)] ++ · rw [ite_eq_right (by rintro ⟨-, -, g⟩; exact hD g), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD g), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD g)] + + private theorem crossings_split (hab : hgt u a ≠ hgt u b) (hc : c ∈ openSegment ℝ a b) + (q : Plane) : +@@ -690,52 +693,59 @@ + (meet u a b (hgt u q + s)) (hma _ (by linarith) hB.le) + (hha _).ge (by rw [hha]; linarith) (by rw [hha]; linarith) (hha _).le + by_cases hD : fwd u q < fwd u (meet u a b (hgt u q)) +- · rw [if_pos ⟨hA, by linarith, hD⟩, if_pos ⟨by linarith, hB, e.1 hD⟩, +- if_neg (by rintro ⟨g, -, -⟩; linarith), if_neg (by rintro ⟨-, g, -⟩; linarith)] ++ · rw [ite_eq_left ⟨hA, by linarith, hD⟩, ite_eq_left ⟨by linarith, hB, e.1 hD⟩, ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith)] + decide +- · rw [if_neg (by rintro ⟨-, -, g⟩; exact hD g), +- if_neg (by rintro ⟨-, -, g⟩; exact hD (e.2 g)), +- if_neg (by rintro ⟨g, -, -⟩; linarith), if_neg (by rintro ⟨-, g, -⟩; linarith)] ++ · rw [ite_eq_right (by rintro ⟨-, -, g⟩; exact hD g), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD (e.2 g)), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith)] + · rcases lt_or_ge (hgt u q) (hgt u b) with hB2 | hB2 + · -- the sweep passes the upper end + have e := hside (meet u a b (hgt u q)) (hma _ hA hB2.le) b hbseg + (hha _).ge (by rw [hha]; linarith) (by linarith) hB + by_cases hD : fwd u q < fwd u (meet u a b (hgt u q)) +- · rw [if_pos ⟨hA, hB2, hD⟩, if_neg (by rintro ⟨-, g, -⟩; linarith), +- if_neg (by rintro ⟨g, -, -⟩; linarith), if_pos ⟨hB2, hB, e.1 hD⟩] ++ · rw [ite_eq_left ⟨hA, hB2, hD⟩, ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ite_eq_left ⟨hB2, hB, e.1 hD⟩] + decide +- · rw [if_neg (by rintro ⟨-, -, g⟩; exact hD g), +- if_neg (by rintro ⟨-, g, -⟩; linarith), +- if_neg (by rintro ⟨g, -, -⟩; linarith), +- if_neg (by rintro ⟨-, -, g⟩; exact hD (e.2 g))] ++ · rw [ite_eq_right (by rintro ⟨-, -, g⟩; exact hD g), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD (e.2 g))] + · -- the edge is entirely below the sweep +- rw [if_neg (by rintro ⟨-, g, -⟩; linarith), if_neg (by rintro ⟨-, g, -⟩; linarith), +- if_neg (by rintro ⟨g, -, -⟩; linarith), if_neg (by rintro ⟨g, -, -⟩; linarith)] ++ rw [ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith)] + · rcases le_or_gt (hgt u a) (hgt u q + s) with hA2 | hA2 + · rcases lt_or_ge (hgt u q + s) (hgt u b) with hB | hB + · -- the sweep passes the lower end only + have e := hside (meet u a b (hgt u q + s)) (hma _ hA2 hB.le) a haseg + (by rw [hha]; linarith) (hha _).le (by linarith) hA2 + by_cases hD : fwd u q < fwd u a +- · rw [if_neg (by rintro ⟨g, -, -⟩; linarith), if_pos ⟨hA2, hB, e.2 hD⟩, +- if_pos ⟨hA, hA2, hD⟩, if_neg (by rintro ⟨-, g, -⟩; linarith)] ++ · rw [ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ite_eq_left ⟨hA2, hB, e.2 hD⟩, ++ ite_eq_left ⟨hA, hA2, hD⟩, ite_eq_right (by rintro ⟨-, g, -⟩; linarith)] + decide +- · rw [if_neg (by rintro ⟨g, -, -⟩; linarith), +- if_neg (by rintro ⟨-, -, g⟩; exact hD (e.1 g)), +- if_neg (by rintro ⟨-, -, g⟩; exact hD g), +- if_neg (by rintro ⟨-, g, -⟩; linarith)] ++ · rw [ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD (e.1 g)), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD g), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith)] + · -- the sweep passes both ends + have e := hside a haseg b hbseg (by linarith) hA2 (by linarith) hB + by_cases hD : fwd u q < fwd u a +- · rw [if_neg (by rintro ⟨g, -, -⟩; linarith), if_neg (by rintro ⟨-, g, -⟩; linarith), +- if_pos ⟨hA, hA2, hD⟩, if_pos ⟨by linarith, hB, e.1 hD⟩] ++ · rw [ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_left ⟨hA, hA2, hD⟩, ite_eq_left ⟨by linarith, hB, e.1 hD⟩] + decide +- · rw [if_neg (by rintro ⟨g, -, -⟩; linarith), if_neg (by rintro ⟨-, g, -⟩; linarith), +- if_neg (by rintro ⟨-, -, g⟩; exact hD g), +- if_neg (by rintro ⟨-, -, g⟩; exact hD (e.2 g))] ++ · rw [ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD g), ++ ite_eq_right (by rintro ⟨-, -, g⟩; exact hD (e.2 g))] + · -- the edge is entirely above the sweep +- rw [if_neg (by rintro ⟨g, -, -⟩; linarith), if_neg (by rintro ⟨g, -, -⟩; linarith), +- if_neg (by rintro ⟨-, g, -⟩; linarith), if_neg (by rintro ⟨-, g, -⟩; linarith)] ++ rw [ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨g, -, -⟩; linarith), ++ ite_eq_right (by rintro ⟨-, g, -⟩; linarith), ite_eq_right (by rintro ⟨-, g, -⟩; linarith)] + + /-- Sweeping the base point across the ray direction, without meeting the polygon, does not + change the parity. This is where the polygon has to be closed. -/ +@@ -882,7 +892,7 @@ + refine List.sum_eq_zero ?_ + intro x hx + obtain ⟨P, hP, rfl⟩ := List.mem_map.1 hx +- refine if_neg ?_ ++ refine ite_eq_right ?_ + rintro ⟨h1, h2, h3⟩ + exact absurd (h _ (mem_cover hP (meet_mem_seg (hL P hP) h1 h2.le))) (not_lt.2 h3.le) + +@@ -999,7 +1009,7 @@ + rintro ⟨-, -, g⟩ + rw [hgp, hfp, hmeetp] at g + linarith +- rw [mark, mark, if_pos hm1, if_neg hm2, add_zero] ++ rw [mark, mark, ite_eq_left hm1, ite_eq_right hm2, add_zero] + refine ⟨by rw [hneg]; exact hcov (-t) (by linarith) habsm, hcov t (ne_of_gt ht) habsp, ?_⟩ + have hz1 : (L₁.map (fun P => mark u P (p - t • u) + mark u P (p + t • u))).sum = 0 := by + refine List.sum_eq_zero ?_ +diff --git a/Schoenflies/ParitySplitting.lean b/Schoenflies/ParitySplitting.lean +--- a/Schoenflies/ParitySplitting.lean ++++ b/Schoenflies/ParitySplitting.lean +@@ -122,7 +122,9 @@ + theorem mark_swap' (u : Plane) (P : Piece) (q : Plane) : mark u (P.2, P.1) q = mark u P q := by + obtain ⟨a, b⟩ := P + by_cases h : hgt u a = hgt u b +- · rw [mark, mark, if_neg (not_crosses_of_level h.symm q), if_neg (not_crosses_of_level h q)] ++ · rw [mark, mark, ++ ite_eq_right (not_crosses_of_level h.symm q), ++ ite_eq_right (not_crosses_of_level h q)] + · exact mark_swap h q + + /-- Reordering the edges does not change the count. -/ +diff --git a/Schoenflies/PolyArcRealize.lean b/Schoenflies/PolyArcRealize.lean +--- a/Schoenflies/PolyArcRealize.lean ++++ b/Schoenflies/PolyArcRealize.lean +@@ -122,22 +122,22 @@ + intro k l hkl + dsimp only at hkl + by_cases hk : k < N <;> by_cases hl : l < N +- · rw [if_pos hk, if_pos hl] at hkl ++ · rw [ite_eq_left hk, ite_eq_left hl] at hkl + exact hv k hk l hl hkl + · -- A listed point cannot equal a padded one: its first coordinate is too small. + exfalso +- rw [if_pos hk, if_neg hl] at hkl ++ rw [ite_eq_left hk, ite_eq_right hl] at hkl + have h1 : v k 0 = M + 1 + (l : ℝ) := by rw [hkl]; exact Plane.mk_zero _ _ + have h2 : (0 : ℝ) ≤ (l : ℝ) := Nat.cast_nonneg l + have h3 := hM k hk + linarith + · exfalso +- rw [if_neg hk, if_pos hl] at hkl ++ rw [ite_eq_right hk, ite_eq_left hl] at hkl + have h1 : v l 0 = M + 1 + (k : ℝ) := by rw [← hkl]; exact Plane.mk_zero _ _ + have h2 : (0 : ℝ) ≤ (k : ℝ) := Nat.cast_nonneg k + have h3 := hM l hl + linarith +- · rw [if_neg hk, if_neg hl] at hkl ++ · rw [ite_eq_right hk, ite_eq_right hl] at hkl + have h1 : M + 1 + (k : ℝ) = M + 1 + (l : ℝ) := by + rw [← Plane.mk_zero (M + 1 + (k : ℝ)) 0, hkl]; exact Plane.mk_zero _ _ + exact_mod_cast (by linarith : (k : ℝ) = (l : ℝ)) +@@ -156,9 +156,9 @@ + /-- The index map that skips over vertex `i + 1`. -/ + def skipIdx (i k : ℕ) : ℕ := if k ≤ i then k else k + 1 + +-theorem skipIdx_of_le (h : k ≤ i) : skipIdx i k = k := if_pos h +- +-theorem skipIdx_of_lt (h : i < k) : skipIdx i k = k + 1 := if_neg (by omega) ++theorem skipIdx_of_le (h : k ≤ i) : skipIdx i k = k := ite_eq_left h ++ ++theorem skipIdx_of_lt (h : i < k) : skipIdx i k = k + 1 := ite_eq_right (by omega) + + theorem skipIdx_injective (i : ℕ) : Function.Injective (skipIdx i) := by + intro k l h +@@ -572,18 +572,18 @@ + -- The linear vertex list: the ends, in the order the arc reaches them, and then `b`. + set vf : ℕ → Plane := fun k => if h : k < n then f (par TF hcard ⟨k, h⟩) else b with hvf + have hvflt : ∀ (k : ℕ) (hk : k < n), vf k = f (tp ⟨k, hk⟩) := by +- intro k hk; rw [hvf]; simp only [dif_pos hk, htp] +- have hvfn : vf n = b := by rw [hvf]; simp only [dif_neg (lt_irrefl n)] ++ intro k hk; rw [hvf]; simp only [dite_eq_left hk, htp] ++ have hvfn : vf n = b := by rw [hvf]; simp only [dite_eq_right (lt_irrefl n)] + -- `f 1 = b` is the right end of the last gap, so the list has the right successor at each step. + have hvfsucc : ∀ (k : ℕ) (hk : k < n), vf (k + 1) = f (nx ⟨k, hk⟩) := by + intro k hk + by_cases hk1 : k + 1 < n + · rw [hvflt (k + 1) hk1, htp, hnx, parNext, +- dif_pos (show (⟨k, hk⟩ : Fin n).val + 1 < n from hk1)] ++ dite_eq_left (show (⟨k, hk⟩ : Fin n).val + 1 < n from hk1)] + rfl + · have : k + 1 = n := by omega + rw [this, hvfn, hnx, parNext, +- dif_neg (show ¬ ((⟨k, hk⟩ : Fin n).val + 1 < n) from hk1), hf1] ++ dite_eq_right (show ¬ ((⟨k, hk⟩ : Fin n).val + 1 < n) from hk1), hf1] + -- The vertex list is injective on `{0, …, n}`: `f` is, and the parameters are increasing. + have hvfinj : ∀ i < n + 1, ∀ j < n + 1, vf i = vf j → i = j := by + have hkey : ∀ i < n, ∀ j < n, vf i = vf j → i = j := by +diff --git a/Schoenflies/PolyLocal.lean b/Schoenflies/PolyLocal.lean +--- a/Schoenflies/PolyLocal.lean ++++ b/Schoenflies/PolyLocal.lean +@@ -277,7 +277,7 @@ + rintro c ⟨hcQ, hcne⟩ + have : p ∉ closedSquare c (ρ c) := + Set.disjoint_left.1 (hdisj c₀ hc₀Q c hcQ fun h => hcne (h ▸ rfl)) hpc₀ +- simp only [closedSquare, mem_setOf_eq, not_le] at this ++ simp only [closedSquare, mem_ofPred_eq, not_le] at this + linarith + obtain ⟨s, hs, hsle⟩ := exists_pos_le_of_finite (hQ.sdiff (t := {c₀})) + (f := fun c => supDist p c - ρ c) hfar +@@ -298,7 +298,7 @@ + have hfar : ∀ c ∈ Q, 0 < supDist p c - ρ c := by + intro c hcQ + have := hnear c hcQ +- simp only [closedSquare, mem_setOf_eq, not_le] at this ++ simp only [closedSquare, mem_ofPred_eq, not_le] at this + linarith + obtain ⟨s, hs, hsle⟩ := exists_pos_le_of_finite hQ (f := fun c => supDist p c - ρ c) hfar + refine isLocallyPolyConnAt'_of_nbhd_subset (isOpen_openSquare p s) (mem_openSquare_self hs) +diff --git a/Schoenflies/PrePolygonArc.lean b/Schoenflies/PrePolygonArc.lean +--- a/Schoenflies/PrePolygonArc.lean ++++ b/Schoenflies/PrePolygonArc.lean +@@ -623,13 +623,13 @@ + have hlt : j.val < m + 3 := ZMod.val_lt j + have hval : (emb j).val = j.val := by + rw [emb, ZMod.val_cast_of_lt (by omega)] +- rw [insVertex, if_pos (by rw [hval]; exact hlt), hval, ZMod.natCast_rightInverse j] ++ rw [insVertex, ite_eq_left (by rw [hval]; exact hlt), hval, ZMod.natCast_rightInverse j] + + theorem val_neg_one' : (-1 : ZMod (m + 1 + 3)).val = m + 3 := by + rw [neg_one_eq_cast, ZMod.val_cast_of_lt (by omega)] + + theorem insVertex_neg_one (P : PrePolygon m) (z : Plane) : insVertex P z (-1) = z := by +- rw [insVertex, if_neg (by rw [val_neg_one' (m := m)]; omega)] ++ rw [insVertex, ite_eq_right (by rw [val_neg_one' (m := m)]; omega)] + + /-- Away from the inserted vertex the edges are unchanged. -/ + theorem insEdge_of_lt {j : ZMod (m + 3)} (h : j.val + 1 < m + 3) : +@@ -688,12 +688,12 @@ + have hi := ZMod.val_lt i + have hj := ZMod.val_lt j + by_cases hli : i.val < m + 3 <;> by_cases hlj : j.val < m + 3 +- · rw [if_pos hli, if_pos hlj] at hij ++ · rw [ite_eq_left hli, ite_eq_left hlj] at hij + exact ZMod.val_injective _ + (ClosedPolygon.natCast_inj hli hlj (P.vertex_inj hij)) +- · rw [if_pos hli, if_neg hlj] at hij ++ · rw [ite_eq_left hli, ite_eq_right hlj] at hij + exact absurd hij (hzv _) +- · rw [if_neg hli, if_pos hlj] at hij ++ · rw [ite_eq_right hli, ite_eq_left hlj] at hij + exact absurd hij.symm (hzv _) + · exact ZMod.val_injective _ (by omega) + edges_meet := by +diff --git a/Schoenflies/QuantitativeForwardStages.lean b/Schoenflies/QuantitativeForwardStages.lean +--- a/Schoenflies/QuantitativeForwardStages.lean ++++ b/Schoenflies/QuantitativeForwardStages.lean +@@ -34,8 +34,8 @@ + rw [Plane.closedSquare_eq_inter] at hclosed + have hopen := hz.2 + rw [Plane.openSquare_eq_inter] at hopen +- simp only [Set.mem_inter_iff, Set.mem_setOf_eq] at hclosed +- simp only [Set.mem_inter_iff, Set.mem_setOf_eq, not_and_or, not_lt] at hopen ++ simp only [Set.mem_inter_iff, Set.mem_ofPred_eq] at hclosed ++ simp only [Set.mem_inter_iff, Set.mem_ofPred_eq, not_and_or, not_lt] at hopen + rcases hopen with hX | hY + · rcases hX with hleft | hright + · exact mem_cover_of_coord_eq hs hk (Nat.zero_le k) hz.1 (by +diff --git a/Schoenflies/QuantitativeRecursion.lean b/Schoenflies/QuantitativeRecursion.lean +--- a/Schoenflies/QuantitativeRecursion.lean ++++ b/Schoenflies/QuantitativeRecursion.lean +@@ -191,7 +191,7 @@ + + theorem denseQuantitativeSchedule_centresDense (hC : IsSeparating C) : + (denseQuantitativeSchedule hC).CentresDense := by +- letI : Nonempty (inside C) := hC.isConnected_inside.nonempty.to_subtype ++ let : Nonempty (inside C) := hC.isConnected_inside.nonempty.to_subtype + intro x hx δ hδ + obtain ⟨k, hk⟩ := + (TopologicalSpace.denseRange_denseSeq (inside C)).exists_dist_lt +diff --git a/Schoenflies/Realization.lean b/Schoenflies/Realization.lean +--- a/Schoenflies/Realization.lean ++++ b/Schoenflies/Realization.lean +@@ -876,7 +876,7 @@ + /-- The successor in `ZMod n`, read as a numeral below `n`. -/ + theorem zmod_val_succ {n : ℕ} (hn : 1 < n) (j : ZMod n) : + (j + 1).val = if j.val + 1 < n then j.val + 1 else 0 := by +- haveI : NeZero n := ⟨by omega⟩ ++ have : NeZero n := ⟨by omega⟩ + have h1 : (1 : ZMod n).val = 1 := by + rw [show (1 : ZMod n) = ((1 : ℕ) : ZMod n) by norm_num] + exact ZMod.val_cast_of_lt hn +@@ -1084,27 +1084,27 @@ + · exfalso + have hcond : ¬ ((⟨0, hn0⟩ : Fin n) : ℕ) + 1 < n := + fun hc => absurd (lt_of_le_of_lt (Nat.le_add_left 1 _) hc) (by omega) +- have hnx0 : nx ⟨0, hn0⟩ = 1 := by rw [hnx, parNext, dif_neg hcond] ++ have hnx0 : nx ⟨0, hn0⟩ = 1 := by rw [hnx, parNext, dite_eq_right hcond] + exact hfne ⟨0, hn0⟩ (by rw [htp0, hnx0]; exact hf.closes) + · exact hge +- haveI : NeZero n := ⟨by omega⟩ ++ have : NeZero n := ⟨by omega⟩ + -- The cyclic vertex list: the ends, in the order the loop reaches them. + set w : ZMod n → Plane := fun j => f (tp ⟨j.val, ZMod.val_lt j⟩) with hw + have hwsucc : ∀ j : ZMod n, w (j + 1) = f (nx ⟨j.val, ZMod.val_lt j⟩) := by + intro j + have hjlt := ZMod.val_lt j + by_cases hj : j.val + 1 < n +- · have hval : (j + 1).val = j.val + 1 := by rw [zmod_val_succ (by omega) j, if_pos hj] ++ · have hval : (j + 1).val = j.val + 1 := by rw [zmod_val_succ (by omega) j, ite_eq_left hj] + have hfin : (⟨(j + 1).val, ZMod.val_lt (j + 1)⟩ : Fin n) = ⟨j.val + 1, hj⟩ := + Fin.val_injective hval + simp only [hw, hfin] +- rw [hnx, parNext, dif_pos (show (⟨j.val, hjlt⟩ : Fin n).val + 1 < n from hj)] ++ rw [hnx, parNext, dite_eq_left (show (⟨j.val, hjlt⟩ : Fin n).val + 1 < n from hj)] + rfl +- · have hval : (j + 1).val = 0 := by rw [zmod_val_succ (by omega) j, if_neg hj] ++ · have hval : (j + 1).val = 0 := by rw [zmod_val_succ (by omega) j, ite_eq_right hj] + have hfin : (⟨(j + 1).val, ZMod.val_lt (j + 1)⟩ : Fin n) = ⟨0, hn0⟩ := + Fin.val_injective hval + simp only [hw, hfin] +- rw [htp0, hnx, parNext, dif_neg (show ¬ ((⟨j.val, hjlt⟩ : Fin n).val + 1 < n) from hj)] ++ rw [htp0, hnx, parNext, dite_eq_right (show ¬ ((⟨j.val, hjlt⟩ : Fin n).val + 1 < n) from hj)] + exact hf.closes + have hedgeq : ∀ j : ZMod n, + segment ℝ (w j) (w (j + 1)) = (pc ⟨j.val, ZMod.val_lt j⟩).seg := by +@@ -1141,7 +1141,7 @@ + omega + have hsucc1 : (1 : ZMod n) + 1 = 0 := by + refine ZMod.val_injective _ ?_ +- rw [zmod_val_succ (by omega) 1, hone, if_neg (by omega), ZMod.val_zero] ++ rw [zmod_val_succ (by omega) 1, hone, ite_eq_right (by omega), ZMod.val_zero] + have hw01 : w 0 ≠ w 1 := fun he => h01 (hwinj he) + obtain ⟨p, hp, hp1, hp2⟩ := PrePolygon.exists_mem_segment_ne hw01 + have hmem := hwmeet 0 1 h01 +diff --git a/Schoenflies/RealizeSplit.lean b/Schoenflies/RealizeSplit.lean +--- a/Schoenflies/RealizeSplit.lean ++++ b/Schoenflies/RealizeSplit.lean +@@ -501,11 +501,11 @@ + + theorem splitPos_of_mem_ear {z : γ} (hz : z ∈ V(d.ear)) : d.splitPos R earPos z = earPos z := by + classical +- simp only [splitPos, if_pos hz] ++ simp only [splitPos, ite_eq_left hz] + + theorem splitPos_of_notMem_ear {z : γ} (hz : z ∉ V(d.ear)) : d.splitPos R earPos z = R.pos z := by + classical +- simp only [splitPos, if_neg hz] ++ simp only [splitPos, ite_eq_right hz] + + theorem EarCrosscut.splitPos_eq (hE : d.EarCrosscut R earPos earDraw) {z : γ} + (hz : z ∈ V(S.skel)) : d.splitPos R earPos z = R.pos z := by +@@ -516,24 +516,24 @@ + theorem splitDrawing_of_mem_ear {f : γ} (hf : f ∈ E(d.ear)) : + d.splitDrawing R earDraw f = earDraw f := by + classical +- simp only [splitDrawing, if_pos hf] ++ simp only [splitDrawing, ite_eq_left hf] + + theorem splitDrawing_of_mem_skel {f : γ} (hf : f ∈ E(S.skel)) : + d.splitDrawing R earDraw f = R.drawing f := by + classical +- simp only [splitDrawing, if_neg (Set.disjoint_left.1 d.disjoint_edgeSet hf)] ++ simp only [splitDrawing, ite_eq_right (Set.disjoint_left.1 d.disjoint_edgeSet hf)] + + theorem splitCell_face₁ : d.splitCell R earPos earDraw d.face₁ = + inside (R.cellUnion d.cells₁ ∪ d.earSet earPos earDraw) := by + classical + unfold splitCell +- rw [if_pos rfl] ++ rw [ite_eq_left rfl] + + theorem splitCell_face₂ : d.splitCell R earPos earDraw d.face₂ = + inside (R.cellUnion d.cells₂ ∪ d.earSet earPos earDraw) := by + classical + unfold splitCell +- rw [if_neg (Ne.symm d.face_ne), if_pos rfl] ++ rw [ite_eq_right (Ne.symm d.face_ne), ite_eq_left rfl] + + theorem splitCell_of_mem_cells {σ : γ} (hσ : σ ∈ S.cells) : + d.splitCell R earPos earDraw σ = R.cell σ := by +@@ -546,7 +546,7 @@ + exacts [hnv d.source_mem_skel, hnv d.target_mem_skel] + have h₄ : σ ∉ E(d.ear) := fun h => d.edge_fresh h hσ + unfold splitCell +- rw [if_neg h₁, if_neg h₂, if_neg h₃, if_neg h₄] ++ rw [ite_eq_right h₁, ite_eq_right h₂, ite_eq_right h₃, ite_eq_right h₄] + + theorem EarCrosscut.splitCell_earVertex (hE : d.EarCrosscut R earPos earDraw) {z : γ} + (hz : z ∈ V(d.ear)) : d.splitCell R earPos earDraw z = {earPos z} := by +@@ -557,7 +557,9 @@ + · have h₁ : z ≠ d.face₁ := by rintro rfl; exact d.face₁_notMem_ear (Or.inl hz) + have h₂ : z ≠ d.face₂ := by rintro rfl; exact d.face₂_notMem_ear (Or.inl hz) + unfold splitCell +- rw [if_neg h₁, if_neg h₂, if_pos (show z ∈ V(d.ear) ∧ z ∉ V(S.skel) from ⟨hz, hz'⟩)] ++ rw [ite_eq_right h₁, ++ ite_eq_right h₂, ++ ite_eq_left (show z ∈ V(d.ear) ∧ z ∉ V(S.skel) from ⟨hz, hz'⟩)] + + theorem splitCell_earEdge {f : γ} (hf : f ∈ E(d.ear)) : + d.splitCell R earPos earDraw f = Graph.edgeArc earDraw f \ earPos '' V(d.ear) := by +@@ -567,7 +569,7 @@ + have h₃ : ¬ (f ∈ V(d.ear) ∧ f ∉ V(S.skel)) := fun h => + Set.disjoint_left.1 d.ear_disjoint h.1 hf + unfold splitCell +- rw [if_neg h₁, if_neg h₂, if_neg h₃, if_pos hf] ++ rw [ite_eq_right h₁, ite_eq_right h₂, ite_eq_right h₃, ite_eq_left hf] + + theorem edgeArc_splitDrawing_of_mem_skel {f : γ} (hf : f ∈ E(S.skel)) : + Graph.edgeArc (d.splitDrawing R earDraw) f = Graph.edgeArc R.drawing f := by +diff --git a/Schoenflies/RealizeSubdiv.lean b/Schoenflies/RealizeSubdiv.lean +--- a/Schoenflies/RealizeSubdiv.lean ++++ b/Schoenflies/RealizeSubdiv.lean +@@ -309,7 +309,7 @@ + R.drawing d.edge (d.rightParam R) = R.pos d.right := by + have hd := R.isDrawing.edge_param (d.edge_mem_edgeSet_graph R) + rcases (d.isLink_drawn_edge R).eq_and_eq_or_eq_and_eq hd.2.2 with ⟨h0, h1⟩ | ⟨h0, h1⟩ +- · have hL : d.leftParam R = 0 := if_pos h0.symm ++ · have hL : d.leftParam R = 0 := ite_eq_left h0.symm + refine ⟨by rw [hL]; exact h0.symm, ?_⟩ + have hR : d.rightParam R = 1 := by rw [rightParam, hL]; ring + rw [hR]; exact h1.symm +@@ -317,7 +317,7 @@ + -- endpoint values, which injectivity forbids. + have hne : ¬ (R.drawing d.edge 0 = R.pos d.left) := fun hcon => + zero_ne_one (hd.2.1 zero_mem_I one_mem_I (by rw [hcon, h0])) +- have hL : d.leftParam R = 1 := if_neg hne ++ have hL : d.leftParam R = 1 := ite_eq_right hne + refine ⟨by rw [hL]; exact h0.symm, ?_⟩ + have hR : d.rightParam R = 0 := by rw [rightParam, hL]; ring + rw [hR]; exact h1.symm +@@ -458,9 +458,10 @@ + variable {d R} + + @[simp] theorem realizePos_newVertex : d.realizePos R t d.newVertex = R.drawing d.edge t := +- if_pos rfl +- +-theorem realizePos_of_ne {z : γ} (h : z ≠ d.newVertex) : d.realizePos R t z = R.pos z := if_neg h ++ ite_eq_left rfl ++ ++theorem realizePos_of_ne {z : γ} (h : z ≠ d.newVertex) : d.realizePos R t z = R.pos z := ++ ite_eq_right h + + theorem realizePos_of_mem_cells {z : γ} (h : z ∈ S.cells) : d.realizePos R t z = R.pos z := + realizePos_of_ne (d.ne_newVertex_of_mem_cells h) +@@ -469,33 +470,38 @@ + realizePos_of_mem_cells (S.mem_cells_of_mem_vertexSet h) + + @[simp] theorem realizeDrawing_newEdge₁ : +- d.realizeDrawing R t d.newEdge₁ = subarc (R.drawing d.edge) (d.leftParam R) t := if_pos rfl ++ d.realizeDrawing R t d.newEdge₁ = subarc (R.drawing d.edge) (d.leftParam R) t := ite_eq_left rfl + + @[simp] theorem realizeDrawing_newEdge₂ : + d.realizeDrawing R t d.newEdge₂ = subarc (R.drawing d.edge) t (d.rightParam R) := by +- rw [realizeDrawing, if_neg d.newEdge_ne.symm, if_pos rfl] ++ rw [realizeDrawing, ite_eq_right d.newEdge_ne.symm, ite_eq_left rfl] + + theorem realizeDrawing_of_ne {f : γ} (h₁ : f ≠ d.newEdge₁) (h₂ : f ≠ d.newEdge₂) : +- d.realizeDrawing R t f = R.drawing f := by rw [realizeDrawing, if_neg h₁, if_neg h₂] ++ d.realizeDrawing R t f = R.drawing f := by rw [realizeDrawing, ite_eq_right h₁, ite_eq_right h₂] + + theorem realizeDrawing_of_mem_cells {f : γ} (h : f ∈ S.cells) : + d.realizeDrawing R t f = R.drawing f := + realizeDrawing_of_ne (d.ne_newEdge₁_of_mem_cells h) (d.ne_newEdge₂_of_mem_cells h) + + @[simp] theorem realizeCell_newVertex : d.realizeCell R t d.newVertex = {R.drawing d.edge t} := +- if_pos rfl ++ ite_eq_left rfl + + @[simp] theorem realizeCell_newEdge₁ : d.realizeCell R t d.newEdge₁ = + R.drawing d.edge '' uIcc (d.leftParam R) t \ {R.pos d.left, R.drawing d.edge t} := by +- rw [realizeCell, if_neg d.newVertex_ne₁.symm, if_pos rfl] ++ rw [realizeCell, ite_eq_right d.newVertex_ne₁.symm, ite_eq_left rfl] + + @[simp] theorem realizeCell_newEdge₂ : d.realizeCell R t d.newEdge₂ = + R.drawing d.edge '' uIcc t (d.rightParam R) \ {R.drawing d.edge t, R.pos d.right} := by +- rw [realizeCell, if_neg d.newVertex_ne₂.symm, if_neg d.newEdge_ne.symm, if_pos rfl] ++ rw [realizeCell, ++ ite_eq_right d.newVertex_ne₂.symm, ++ ite_eq_right d.newEdge_ne.symm, ++ ite_eq_left rfl] + + theorem realizeCell_of_mem_cells {c : γ} (h : c ∈ S.cells) : d.realizeCell R t c = R.cell c := by +- rw [realizeCell, if_neg (d.ne_newVertex_of_mem_cells h), if_neg (d.ne_newEdge₁_of_mem_cells h), +- if_neg (d.ne_newEdge₂_of_mem_cells h)] ++ rw [realizeCell, ++ ite_eq_right (d.ne_newVertex_of_mem_cells h), ++ ite_eq_right (d.ne_newEdge₁_of_mem_cells h), ++ ite_eq_right (d.ne_newEdge₂_of_mem_cells h)] + + /-! ### The two half arcs -/ + +diff --git a/Schoenflies/RefinementStars.lean b/Schoenflies/RefinementStars.lean +--- a/Schoenflies/RefinementStars.lean ++++ b/Schoenflies/RefinementStars.lean +@@ -132,7 +132,7 @@ + theorem carrier_spec [Nonempty γ] (R : S.Realization) (x : Plane) + (h : ∃ σ, σ ∈ S.cells ∧ x ∈ R.cell σ) : + R.carrier x ∈ S.cells ∧ x ∈ R.cell (R.carrier x) := by +- rw [carrier, dif_pos h] ++ rw [carrier, dite_eq_left h] + exact h.choose_spec + + namespace IsCellDecomposition +diff --git a/Schoenflies/SimpleArc.lean b/Schoenflies/SimpleArc.lean +--- a/Schoenflies/SimpleArc.lean ++++ b/Schoenflies/SimpleArc.lean +@@ -146,14 +146,14 @@ + · -- A repeated vertex contributes the point `u`, which the rest of the chain already + -- holds. + subst huv +- rw [if_pos rfl, segment_same] ++ rw [ite_eq_left rfl, segment_same] + have hmem : u ∈ poly (u :: rest) := mem_poly_of_mem (List.mem_cons_self ..) + rcases ih with h | ⟨h1, h2⟩ + · exact Or.inl (by rw [h, union_eq_self_of_subset_left (singleton_subset_iff.2 hmem)]) + · refine Or.inr ⟨h1, ?_⟩ + rw [union_eq_self_of_subset_left (singleton_subset_iff.2 hmem)] + exact h2 +- · rw [if_neg huv, cover_cons] ++ · rw [ite_eq_right huv, cover_cons] + refine Or.inl ?_ + rcases ih with h | ⟨h1, h2⟩ + · rw [h]; rfl +@@ -284,7 +284,7 @@ + -- And they carry disjoint sets: a common point is a vertex incident with an edge of each. + have hdisj : ∀ z, z ∈ S → z ∈ T → False := by + intro z hzS hzT +- simp only [hS, hT, mem_iUnion, mem_setOf_eq, exists_prop] at hzS hzT ++ simp only [hS, hT, mem_iUnion, mem_ofPred_eq, exists_prop] at hzS hzT + obtain ⟨P, ⟨hP, hPr⟩, hzP⟩ := hzS + obtain ⟨Q, ⟨hQ, hQr⟩, hzQ⟩ := hzT + have hPQ : P ≠ Q := by rintro rfl; exact hQr hPr +@@ -315,7 +315,7 @@ + hsub ⟨a, ha, fun h => hdisj a haS h⟩ ⟨b, hb, fun h => hdisj b h hbT⟩ + exact (hunion z hzc).elim hzS hzT + -- `b` is a vertex on an edge of the reachable class, hence an end of it. +- simp only [hS, mem_iUnion, mem_setOf_eq, exists_prop] at hbS ++ simp only [hS, mem_iUnion, mem_ofPred_eq, exists_prop] at hbS + obtain ⟨P, ⟨hP, hPr⟩, hbP⟩ := hbS + have hbend : b = P.1 ∨ b = P.2 := + hdraw.vertex_mem_edgeArc (hlink P hP) hbV (by rwa [edgeArc_segmentDrawing]) +diff --git a/Schoenflies/SkeletonAccess.lean b/Schoenflies/SkeletonAccess.lean +--- a/Schoenflies/SkeletonAccess.lean ++++ b/Schoenflies/SkeletonAccess.lean +@@ -648,8 +648,8 @@ + frontier (Plane.openSquare c s) ⊆ Plane.closedSquare c s \ Plane.openSquare c s := by + have hsub : Plane.openSquare c s ⊆ Plane.closedSquare c s := by + intro w hw +- simp only [Plane.openSquare, mem_setOf_eq] at hw +- simp only [Plane.closedSquare, mem_setOf_eq] ++ simp only [Plane.openSquare, mem_ofPred_eq] at hw ++ simp only [Plane.closedSquare, mem_ofPred_eq] + exact hw.le + rw [(Plane.isOpen_openSquare c s).frontier_eq] + exact Set.sdiff_subset_sdiff_left +diff --git a/Schoenflies/SkeletonLocal.lean b/Schoenflies/SkeletonLocal.lean +--- a/Schoenflies/SkeletonLocal.lean ++++ b/Schoenflies/SkeletonLocal.lean +@@ -213,9 +213,9 @@ + · exact one_pos + · exact dist_pos.2 (Ne.symm h) + · intro h1 +- exact le_trans (min_le_left _ _) (le_of_eq (if_neg h1)) ++ exact le_trans (min_le_left _ _) (le_of_eq (ite_eq_right h1)) + · intro h2 +- exact le_trans (min_le_right _ _) (le_of_eq (if_neg h2)) ++ exact le_trans (min_le_right _ _) (le_of_eq (ite_eq_right h2)) + · -- A piece missing `x` is a compact set at positive distance from `x`. + obtain ⟨ρ, hρ, hd⟩ := Plane.exists_dist_pos isCompact_singleton (isCompact_segment P.1 P.2) + (Set.disjoint_singleton_left.2 hx) +@@ -453,7 +453,7 @@ + theorem IsLocalRadius.ball_diff_eq_cone (h : IsLocalRadius S x r) : + ball x r \ S = Plane.cone x {u | u ≠ 0 ∧ Plane.dir u ∉ localDirs S x} r := by + ext z +- simp only [Set.mem_sdiff, mem_ball, Plane.mem_cone_iff, mem_setOf_eq, sub_ne_zero] ++ simp only [Set.mem_sdiff, mem_ball, Plane.mem_cone_iff, mem_ofPred_eq, sub_ne_zero] + constructor + · rintro ⟨hzb, hzS⟩ + have hiff := h.2 z hzb.le +diff --git a/Schoenflies/SkeletonSectors.lean b/Schoenflies/SkeletonSectors.lean +--- a/Schoenflies/SkeletonSectors.lean ++++ b/Schoenflies/SkeletonSectors.lean +@@ -178,19 +178,19 @@ + counterclockwise from `u` to `w` exactly when `w` lies on the arc counterclockwise from `d` to + `u`. -/ + theorem mem_arcCCW_rotate : d ∈ arcCCW u w ↔ w ∈ arcCCW d u := by +- simp only [arcCCW, mem_setOf_eq] ++ simp only [arcCCW, mem_ofPred_eq] + tauto + + /-- A bounding ray is not on its own arc. -/ + theorem left_notMem_arcCCW (u w : Plane) : u ∉ arcCCW u w := by + have h : det w u = -det u w := det_comm w u +- simp only [arcCCW, mem_setOf_eq, det_self, h] ++ simp only [arcCCW, mem_ofPred_eq, det_self, h] + rintro (⟨h1, _⟩ | ⟨h1, h2⟩ | ⟨_, h2⟩) <;> linarith + + /-- The other bounding ray is not on the arc either. -/ + theorem right_notMem_arcCCW (u w : Plane) : w ∉ arcCCW u w := by + have h : det w u = -det u w := det_comm w u +- simp only [arcCCW, mem_setOf_eq, det_self, h] ++ simp only [arcCCW, mem_ofPred_eq, det_self, h] + rintro (⟨_, h2⟩ | ⟨h1, _⟩ | ⟨_, h2⟩) <;> linarith + + /-- **Asymmetry.** Transposing the first two entries of the triple negates the cyclic order: +@@ -200,7 +200,7 @@ + have e1 : det v u = -det u v := det_comm v u + have e2 : det u w = -det w u := det_comm u w + have e3 : det w v = -det v w := det_comm w v +- simp only [arcCCW, mem_setOf_eq] at h ⊢ ++ simp only [arcCCW, mem_ofPred_eq] at h ⊢ + rw [e1, e3] + rcases h with ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> + rintro (⟨g1, g2⟩ | ⟨g1, g2⟩ | ⟨g1, g2⟩) <;> linarith +@@ -268,7 +268,7 @@ + transitive: if `w` comes before `v` and `v` before `d`, then `w` comes before `d`. This is what + makes a finite set of directions linearly ordered once a ray to cut at has been chosen. -/ + theorem arcCCW_trans (h₁ : w ∈ arcCCW u v) (h₂ : v ∈ arcCCW u d) : w ∈ arcCCW u d := by +- simp only [arcCCW, mem_setOf_eq] at h₁ h₂ ⊢ ++ simp only [arcCCW, mem_ofPred_eq] at h₁ h₂ ⊢ + have hv : det u v = -det v u := det_comm u v + rw [hv] at h₂ + exact trans_aux₁ (grassmann u w v d) h₁ h₂ +@@ -278,7 +278,7 @@ + counterclockwise from `w` to `d`. This is the step that turns "nothing of the finite set lies + between `u` and the extreme rays" into "nothing lies inside the sector". -/ + theorem arcCCW_trans' (h₁ : w ∈ arcCCW u v) (h₂ : v ∈ arcCCW u d) : v ∈ arcCCW w d := by +- simp only [arcCCW, mem_setOf_eq] at h₁ h₂ ⊢ ++ simp only [arcCCW, mem_ofPred_eq] at h₁ h₂ ⊢ + have hv : det u v = -det v u := det_comm u v + have hd : det d w = -det w d := det_comm d w + rw [hv] at h₂ +@@ -401,7 +401,7 @@ + ring + rw [he, mul_comm, mul_assoc] + exact mul_pos (inv_pos.2 hupos) (mul_self_pos.2 hne) +- simp only [arcCCW, mem_setOf_eq] ++ simp only [arcCCW, mem_ofPred_eq] + rw [hAB, hCB, hWV] + rcases key with h | h + · exact Or.inl h +@@ -446,7 +446,7 @@ + intro v; rw [hsm, det_smul_right, det_comm v u]; ring + have e2 : det (-u) u = 0 := by rw [hsm, det_smul_left, det_self, mul_zero] + ext v +- simp only [arcCCW, mem_setOf_eq, e1, e2] ++ simp only [arcCCW, mem_ofPred_eq, e1, e2] + constructor + · rintro (⟨h, _⟩ | ⟨_, h⟩ | ⟨h, _⟩) <;> linarith + · exact fun h => Or.inl ⟨h, h⟩ +@@ -461,7 +461,7 @@ + have hhalf : (0 : ℝ) < ρ / 2 := by linarith + refine ⟨⟨(ρ / 2) • perp u, ?_, ?_⟩, + ((convex_det_right_pos u).inter (convex_ball _ _)).isPreconnected⟩ +- · simp only [mem_setOf_eq, det_smul_right, det_perp_self, hu.norm, one_pow, mul_one] ++ · simp only [mem_ofPred_eq, det_smul_right, det_perp_self, hu.norm, one_pow, mul_one] + exact hhalf + · rw [mem_ball, dist_zero_right, norm_smul, Real.norm_eq_abs, norm_perp, hu.norm, mul_one, + abs_of_pos hhalf] +@@ -558,8 +558,8 @@ + rw [hwd, neg_neg] at hne + rw [hwd] + exact hne +- rw [harc, mem_setOf_eq, not_lt] at h +- rw [harc', mem_setOf_eq, hwd] ++ rw [harc, mem_ofPred_eq, not_lt] at h ++ rw [harc', mem_ofPred_eq, hwd] + have hdz : det d z ≠ 0 := by + intro hzero + rcases eq_dir_or_eq_neg_dir hd.ne_zero hz hzero with h1 | h1 +@@ -980,11 +980,11 @@ + (hs₂ : segment ℝ x (x + r • d₂) ⊆ edgeArc drawing e) + (hs₃ : segment ℝ x (x + r • d₃) ⊆ edgeArc drawing e) : False := by + obtain ⟨hcont, hinj, -⟩ := h.edge_param he +- haveI : CompactSpace ↥(I : Set ℝ) := isCompact_iff_compactSpace.1 isCompact_I +- set φ : ↥(I : Set ℝ) → Plane := Set.restrict I (drawing e) with hφdef ++ have : CompactSpace ↥(I : Set ℝ) := isCompact_iff_compactSpace.1 isCompact_I ++ set φ : ↥(I : Set ℝ) → Plane := Set.domRestrict I (drawing e) with hφdef + have hφi : Function.Injective φ := Set.injOn_iff_injective.1 hinj +- have hcm : IsClosedMap φ := (hcont.restrict).isClosedMap +- have hrange : Set.range φ = edgeArc drawing e := Set.range_restrict _ _ ++ have hcm : IsClosedMap φ := (hcont.domRestrict).isClosedMap ++ have hrange : Set.range φ = edgeArc drawing e := Set.range_domRestrict _ _ + -- The preimage of a radial segment is a connected set of parameters. + have hpre : ∀ dd : Plane, segment ℝ x (x + r • dd) ⊆ edgeArc drawing e → + IsPreconnected (Subtype.val '' (φ ⁻¹' segment ℝ x (x + r • dd))) := by +diff --git a/Schoenflies/SourceAttachment.lean b/Schoenflies/SourceAttachment.lean +--- a/Schoenflies/SourceAttachment.lean ++++ b/Schoenflies/SourceAttachment.lean +@@ -29,7 +29,7 @@ + + namespace Schoenflies + +-open Graph ++open _root_.Schoenflies.Graph + + variable {γ : Type*} {S₀ : CellStructure γ} + {srcOuter srcDom tgtOuter tgtDom : Set Plane} +@@ -312,7 +312,7 @@ + V(Q.crosscutOverlay J p s epsilon extra) := by + intro x hx + rw [localGrid_eq, pieceListGraph_vertexSet] at hx +- simp only [endSet, Set.mem_setOf_eq] at hx ++ simp only [endSet, Set.mem_ofPred_eq] at hx + obtain ⟨R, hR, hxR⟩ := hx + change x ∈ V(overlayGraph (Q.crosscutPieces J p s epsilon) + (attachPoints (Q.crosscutPieces J p s epsilon) +@@ -630,7 +630,7 @@ + w.drawing e = + (Q.crosscutOverlay J p s epsilon extra).relabelDrawing + w.name segmentDrawing e := by +- rw [drawing, if_neg] ++ rw [drawing, ite_eq_right] + obtain ⟨R, hR, rfl⟩ := he + exact fun heOuter => w.name_fresh R hR + (P.str.mem_cells_of_mem_edgeSet (P.str.outerGraph_le.edgeSet_mono heOuter)) +@@ -1071,7 +1071,7 @@ + vertexSet_subset := by + intro x hx + rw [pieceListGraph_vertexSet] at hx +- simp only [endSet, Set.mem_setOf_eq] at hx ++ simp only [endSet, Set.mem_ofPred_eq] at hx + obtain ⟨R, hR, hxR⟩ := hx + simp only [List.mem_singleton] at hR + subst R +diff --git a/Schoenflies/SourceJoining.lean b/Schoenflies/SourceJoining.lean +--- a/Schoenflies/SourceJoining.lean ++++ b/Schoenflies/SourceJoining.lean +@@ -24,7 +24,7 @@ + + namespace Schoenflies + +-open Graph ++open _root_.Schoenflies.Graph + + variable {γ : Type*} {S₀ : CellStructure γ} + {srcOuter srcDom tgtOuter tgtDom : Set Plane} +@@ -92,10 +92,10 @@ + | v :: rest => + rw [segsOf_cons_cons] + by_cases huv : u = v +- · rw [if_pos huv] ++ · rw [ite_eq_left huv] + subst u + exact ih (List.cons_ne_nil v rest) hne +- · rw [if_neg huv] ++ · rw [ite_eq_right huv] + constructor + · exact ⟨(u, v), List.mem_cons_self, Or.inl rfl⟩ + · by_cases hvlast : v = (v :: rest).getLast (List.cons_ne_nil v rest) +@@ -299,7 +299,7 @@ + u.drawing e = + (Q.joinedCrosscutOverlay J p s epsilon extra joins).relabelDrawing + u.name segmentDrawing e := by +- rw [drawing, if_neg] ++ rw [drawing, ite_eq_right] + obtain ⟨R, hR, rfl⟩ := he + exact fun heOuter => u.name_fresh R hR + (P.str.mem_cells_of_mem_edgeSet (P.str.outerGraph_le.edgeSet_mono heOuter)) +@@ -636,8 +636,8 @@ + _root_.Graph.edgesCover u.drawing D = cover joins := by + let T := _root_.Graph.traceGraph u.graph u.drawing (cover joins) + have hTle : T ≤ u.graph := _root_.Graph.traceGraph_le _ +- letI : u.graph.Finite := u.graph_finite +- letI : T.Finite := _root_.Graph.Finite.of_le hTle ++ let : u.graph.Finite := u.graph_finite ++ let : T.Finite := _root_.Graph.Finite.of_le hTle + have hpoint : _root_.Graph.pointSet T u.drawing = cover joins := + u.joinTrace_pointSet hs hJ hJgeom hwindow hjoins hjoinsOpen + have hxGraph : x ∈ V(u.graph) := u.joinEnds_subset_graph hs hJ hjoins hxEnd +diff --git a/Schoenflies/SourceOverlay.lean b/Schoenflies/SourceOverlay.lean +--- a/Schoenflies/SourceOverlay.lean ++++ b/Schoenflies/SourceOverlay.lean +@@ -314,7 +314,7 @@ + V(Q.localOverlay p s epsilon extra) := by + intro x hx + rw [localGrid_eq, pieceListGraph_vertexSet] at hx +- simp only [endSet, Set.mem_setOf_eq] at hx ++ simp only [endSet, Set.mem_ofPred_eq] at hx + obtain ⟨R, hR, hxR⟩ := hx + change x ∈ V(overlayGraph (Q.localPieces p s epsilon) + (attachPoints (Q.localPieces p s epsilon) +@@ -478,7 +478,7 @@ + have hxmono := (localGridX_strictMono (p := p) hs hk).monotone + have hymono := (localGridY_strictMono (p := p) hs hk).monotone + rw [Plane.closedSquare_eq_inter] +- simp only [Set.mem_inter_iff, Set.mem_setOf_eq, gridPt] ++ simp only [Set.mem_inter_iff, Set.mem_ofPred_eq, gridPt] + constructor + · constructor + · calc +@@ -668,7 +668,7 @@ + theorem drawing_of_inner {e : γ} (he : e ∈ E(w.innerGraph)) : + w.drawing e = + (Q.localOverlay p s epsilon extra).relabelDrawing w.name segmentDrawing e := by +- rw [drawing, if_neg] ++ rw [drawing, ite_eq_right] + obtain ⟨R, hR, rfl⟩ := he + exact fun heOuter => w.name_fresh R hR + (P.str.mem_cells_of_mem_edgeSet (P.str.outerGraph_le.edgeSet_mono heOuter)) +diff --git a/Schoenflies/Square.lean b/Schoenflies/Square.lean +--- a/Schoenflies/Square.lean ++++ b/Schoenflies/Square.lean +@@ -116,21 +116,21 @@ + + theorem convex_coord_le (i : Fin 2) (r : ℝ) : Convex ℝ {x : Plane | x i ≤ r} := by + intro x hx y hy a b ha hb hab +- simp only [mem_setOf_eq] at * ++ simp only [mem_ofPred_eq] at * + rw [smul_add_apply] + have hr : a * r + b * r = r := by rw [← add_mul, hab, one_mul] + nlinarith [mul_le_mul_of_nonneg_left hx ha, mul_le_mul_of_nonneg_left hy hb] + + theorem convex_coord_ge (i : Fin 2) (r : ℝ) : Convex ℝ {x : Plane | r ≤ x i} := by + intro x hx y hy a b ha hb hab +- simp only [mem_setOf_eq] at * ++ simp only [mem_ofPred_eq] at * + rw [smul_add_apply] + have hr : a * r + b * r = r := by rw [← add_mul, hab, one_mul] + nlinarith [mul_le_mul_of_nonneg_left hx ha, mul_le_mul_of_nonneg_left hy hb] + + theorem convex_coord_lt (i : Fin 2) (r : ℝ) : Convex ℝ {x : Plane | x i < r} := by + intro x hx y hy a b ha hb hab +- simp only [mem_setOf_eq] at * ++ simp only [mem_ofPred_eq] at * + rw [smul_add_apply] + have hr : a * r + b * r = r := by rw [← add_mul, hab, one_mul] + rcases eq_or_lt_of_le ha with rfl | ha' +@@ -140,7 +140,7 @@ + + theorem convex_coord_gt (i : Fin 2) (r : ℝ) : Convex ℝ {x : Plane | r < x i} := by + intro x hx y hy a b ha hb hab +- simp only [mem_setOf_eq] at * ++ simp only [mem_ofPred_eq] at * + rw [smul_add_apply] + have hr : a * r + b * r = r := by rw [← add_mul, hab, one_mul] + rcases eq_or_lt_of_le ha with rfl | ha' +@@ -167,7 +167,7 @@ + ({x : Plane | c 0 - r ≤ x 0} ∩ {x : Plane | x 0 ≤ c 0 + r}) ∩ + ({x : Plane | c 1 - r ≤ x 1} ∩ {x : Plane | x 1 ≤ c 1 + r}) := by + ext x +- simp only [closedSquare, supDist, supNorm, sub_apply, mem_setOf_eq, mem_inter_iff, ++ simp only [closedSquare, supDist, supNorm, sub_apply, mem_ofPred_eq, mem_inter_iff, + max_le_iff, abs_le] + constructor + · rintro ⟨⟨h1, h2⟩, h3, h4⟩; exact ⟨⟨by linarith, by linarith⟩, by linarith, by linarith⟩ +@@ -178,7 +178,7 @@ + ({x : Plane | c 0 - r < x 0} ∩ {x : Plane | x 0 < c 0 + r}) ∩ + ({x : Plane | c 1 - r < x 1} ∩ {x : Plane | x 1 < c 1 + r}) := by + ext x +- simp only [openSquare, supDist, supNorm, sub_apply, mem_setOf_eq, mem_inter_iff, ++ simp only [openSquare, supDist, supNorm, sub_apply, mem_ofPred_eq, mem_inter_iff, + max_lt_iff, abs_lt] + constructor + · rintro ⟨⟨h1, h2⟩, h3, h4⟩; exact ⟨⟨by linarith, by linarith⟩, by linarith, by linarith⟩ +@@ -223,7 +223,7 @@ + set B : Set Plane := {x : Plane | x 1 < -r} with hB + have hcover : beyondSquare r = R ∪ T ∪ L ∪ B := by + ext x +- simp only [beyondSquare, hR, hL, hT, hB, mem_setOf_eq, mem_union, lt_abs] ++ simp only [beyondSquare, hR, hL, hT, hB, mem_ofPred_eq, mem_union, lt_abs] + constructor + · rintro (h | h) <;> rcases h with h | h + · exact Or.inl (Or.inl (Or.inl h)) +diff --git a/Schoenflies/SquareCycle.lean b/Schoenflies/SquareCycle.lean +--- a/Schoenflies/SquareCycle.lean ++++ b/Schoenflies/SquareCycle.lean +@@ -650,7 +650,7 @@ + theorem sqCoord_top (hz : z ∈ segment ℝ (sqNE c r) (sqNW c r)) : + sqCoord c r z = dist (sqNE c r) z := by + classical +- rw [sqCoord, if_pos hz] ++ rw [sqCoord, ite_eq_left hz] + + theorem sqCoord_left (hr : 0 ≤ r) (hz : z ∈ segment ℝ (sqNW c r) (sqSW c r)) : + sqCoord c r z = 2 * r + dist (sqNW c r) z := by +@@ -658,8 +658,8 @@ + by_cases htop : z ∈ segment ℝ (sqNE c r) (sqNW c r) + · -- the shared corner, where the two formulas agree + obtain rfl := eq_sqNW_of_mem_top_left hr htop hz +- rw [sqCoord, if_pos htop, dist_sqNE_sqNW c hr, dist_self, add_zero] +- · rw [sqCoord, if_neg htop, if_pos hz] ++ rw [sqCoord, ite_eq_left htop, dist_sqNE_sqNW c hr, dist_self, add_zero] ++ · rw [sqCoord, ite_eq_right htop, ite_eq_left hz] + + theorem sqCoord_bottom (hr : 0 < r) (hz : z ∈ segment ℝ (sqSW c r) (sqSE c r)) : + sqCoord c r z = 4 * r + dist (sqSW c r) z := by +@@ -667,9 +667,9 @@ + have htop : z ∉ segment ℝ (sqNE c r) (sqNW c r) := notMem_top_of_mem_bottom hr hz + by_cases hleft : z ∈ segment ℝ (sqNW c r) (sqSW c r) + · obtain rfl := eq_sqSW_of_mem_left_bottom hr.le hleft hz +- rw [sqCoord, if_neg htop, if_pos hleft, dist_sqNW_sqSW c hr.le, dist_self, add_zero] ++ rw [sqCoord, ite_eq_right htop, ite_eq_left hleft, dist_sqNW_sqSW c hr.le, dist_self, add_zero] + ring +- · rw [sqCoord, if_neg htop, if_neg hleft, if_pos hz] ++ · rw [sqCoord, ite_eq_right htop, ite_eq_right hleft, ite_eq_left hz] + + theorem sqCoord_right (hr : 0 < r) (hz : z ∈ segment ℝ (sqSE c r) (sqNE c r)) + (hne : z ≠ sqNE c r) : sqCoord c r z = 6 * r + dist (sqSE c r) z := by +@@ -679,10 +679,13 @@ + have hleft : z ∉ segment ℝ (sqNW c r) (sqSW c r) := notMem_left_of_mem_right hr hz + by_cases hbot : z ∈ segment ℝ (sqSW c r) (sqSE c r) + · obtain rfl := eq_sqSE_of_mem_bottom_right hr.le hbot hz +- rw [sqCoord, if_neg htop, if_neg hleft, if_pos hbot, dist_sqSW_sqSE c hr.le, dist_self, ++ rw [sqCoord, ++ ite_eq_right htop, ++ ite_eq_right hleft, ++ ite_eq_left hbot, dist_sqSW_sqSE c hr.le, dist_self, + add_zero] + ring +- · rw [sqCoord, if_neg htop, if_neg hleft, if_neg hbot] ++ · rw [sqCoord, ite_eq_right htop, ite_eq_right hleft, ite_eq_right hbot] + + /-! ## Part 4: the overlay edges on one side + +diff --git a/Schoenflies/SquareMesh.lean b/Schoenflies/SquareMesh.lean +--- a/Schoenflies/SquareMesh.lean ++++ b/Schoenflies/SquareMesh.lean +@@ -110,7 +110,7 @@ + ext x + simp only [ringPieces, cover_cons, cover_nil, union_empty, mem_union, Piece.seg, + mem_segment_horiz, mem_segment_vert, segment_symm_Icc hr, segment_symm_Icc' hr, +- mem_Icc, ringSet, mem_setOf_eq, Plane.supNorm] ++ mem_Icc, ringSet, mem_ofPred_eq, Plane.supNorm] + -- On each side one coordinate is pinned to `±r` and the other is confined to `[-r, r]`; + -- which of the two is pinned is the only difference between the four sides. + have hleft : ∀ u v : ℝ, |u| = r → |v| ≤ r → max |u| |v| = r := by +@@ -275,9 +275,9 @@ + ∃ R ∈ splitAt p P, R.seg ⊆ P.seg ∧ (p = R.1 ∨ p = R.2) := by + classical + by_cases hp : p ∈ P.interior +- · refine ⟨(P.1, p), by rw [splitAt, if_pos hp]; simp, ?_, Or.inr rfl⟩ ++ · refine ⟨(P.1, p), by rw [splitAt, ite_eq_left hp]; simp, ?_, Or.inr rfl⟩ + exact (convex_segment P.1 P.2).segment_subset (left_mem_segment ℝ _ _) hmem +- · refine ⟨P, by rw [splitAt, if_neg hp]; simp, subset_rfl, ?_⟩ ++ · refine ⟨P, by rw [splitAt, ite_eq_right hp]; simp, subset_rfl, ?_⟩ + by_contra hcon + push Not at hcon + exact hp (mem_openSegment_of_ne_left_right (Ne.symm hcon.1) (Ne.symm hcon.2) hmem) +@@ -289,11 +289,11 @@ + by_cases hq : q ∈ P.interior + · have hqseg : q ∈ P.seg := openSegment_subset_segment ℝ _ _ hq + rcases h with rfl | rfl +- · refine ⟨(P.1, q), by rw [splitAt, if_pos hq]; simp, ?_, Or.inl rfl⟩ ++ · refine ⟨(P.1, q), by rw [splitAt, ite_eq_left hq]; simp, ?_, Or.inl rfl⟩ + exact (convex_segment P.1 P.2).segment_subset (left_mem_segment ℝ _ _) hqseg +- · refine ⟨(q, P.2), by rw [splitAt, if_pos hq]; simp, ?_, Or.inr rfl⟩ ++ · refine ⟨(q, P.2), by rw [splitAt, ite_eq_left hq]; simp, ?_, Or.inr rfl⟩ + exact (convex_segment P.1 P.2).segment_subset hqseg (right_mem_segment ℝ _ _) +- · exact ⟨P, by rw [splitAt, if_neg hq]; simp, subset_rfl, h⟩ ++ · exact ⟨P, by rw [splitAt, ite_eq_right hq]; simp, subset_rfl, h⟩ + + theorem splitAllAt_preserves_end (q : Plane) {p : Plane} {P : Piece} {pieces : List Piece} + (h : ∃ R ∈ pieces, R.seg ⊆ P.seg ∧ (p = R.1 ∨ p = R.2)) : +diff --git a/Schoenflies/SquareMeshClosed.lean b/Schoenflies/SquareMeshClosed.lean +--- a/Schoenflies/SquareMeshClosed.lean ++++ b/Schoenflies/SquareMeshClosed.lean +@@ -216,7 +216,7 @@ + Graph.edgesCover segmentDrawing (t.1 :: t.2.2.2.2) = modelCurve := by + obtain ⟨e, u, v, x, D, h₁, h₂, h₃⟩ := squareMesh_outer_cycle hfresh δ anchors + exact ⟨(e, u, v, x, D), h₁, h₂, h₃⟩ +- have hd : outerCycleData δ fresh anchors = h.choose := dif_pos h ++ have hd : outerCycleData δ fresh anchors = h.choose := dite_eq_left h + simpa [outerCycleEdge, outerCycleStart, outerCycleEnd, outerCycleThird, outerCycleDetour, hd] + using h.choose_spec + +@@ -745,7 +745,7 @@ + ∀ Q, Q ∈ W ↔ (Q ∈ E(meshGraph N fresh anchors) ∧ Q.seg ⊆ (spokePiece N z).seg) := + meshSubdividesToPath hN hfresh anchors _ (spokePiece_mem_meshSegments hz) + (spokePiece_nondeg hN (hfresh z hz)) +- rw [spokeWalk, dif_pos h] ++ rw [spokeWalk, dite_eq_left h] + exact h.choose_spec + + theorem spokeWalk_isPath {N : ℕ} (hN : 2 ≤ N) {fresh : List Plane} +@@ -834,7 +834,7 @@ + classical + have h : ∃ P : List Piece, (ringGraph N fresh anchors r).IsPath a P b := + (ringGraph_isTwoConnected hN hfresh anchors hr).connected.exists_isPath ha hb +- rw [ringArc, dif_pos h] ++ rw [ringArc, dite_eq_left h] + exact h.choose_spec + + /-- **The ear**: down the spoke at `z`, round the inner ring, and back up the spoke at `w`. -/ +diff --git a/Schoenflies/SquareMeshConnected.lean b/Schoenflies/SquareMeshConnected.lean +--- a/Schoenflies/SquareMeshConnected.lean ++++ b/Schoenflies/SquareMeshConnected.lean +@@ -314,7 +314,7 @@ + rcases hxy with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> rcases hvw with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> simp + edge_mem_iff_exists_isLink := by + intro P +- simp only [Set.mem_setOf_eq] ++ simp only [Set.mem_ofPred_eq] + exact ⟨fun hP => ⟨P.1, P.2, hP, Or.inl ⟨rfl, rfl⟩⟩, fun ⟨_, _, hP, _⟩ => hP⟩ + left_mem_of_isLink := by + rintro P x y ⟨hP, h⟩ +@@ -361,7 +361,7 @@ + + theorem endSet_append (l l' : List Piece) : endSet (l ++ l') = endSet l ∪ endSet l' := by + ext v +- simp only [endSet, Set.mem_setOf_eq, Set.mem_union, List.mem_append] ++ simp only [endSet, Set.mem_ofPred_eq, Set.mem_union, List.mem_append] + constructor + · rintro ⟨P, hP | hP, h⟩ + exacts [Or.inl ⟨P, hP, h⟩, Or.inr ⟨P, hP, h⟩] +@@ -378,7 +378,7 @@ + Graph.pointSet (pieceListGraph l) segmentDrawing = cover l := by + ext z + simp only [Graph.pointSet, Set.mem_union, Set.mem_iUnion, exists_prop, pieceListGraph_vertexSet, +- endSet, Set.mem_setOf_eq, pieceListGraph_mem_edgeSet, edgeArc_segmentDrawing, cover] ++ endSet, Set.mem_ofPred_eq, pieceListGraph_mem_edgeSet, edgeArc_segmentDrawing, cover] + constructor + · rintro (⟨P, hP, hzP⟩ | ⟨P, hP, hzP⟩) + · refine ⟨P, hP, ?_⟩ +@@ -662,9 +662,9 @@ + theorem bIdy_le {m n t : ℕ} (h : t ≤ 2 * m + 2 * n) : bIdy m n t ≤ n := by + unfold bIdy; split_ifs <;> omega + +-theorem bIdx_bottom {m n t : ℕ} (h : t ≤ m) : bIdx m n t = t := by unfold bIdx; exact if_pos h +- +-theorem bIdy_bottom {m n t : ℕ} (h : t ≤ m) : bIdy m n t = 0 := by unfold bIdy; exact if_pos h ++theorem bIdx_bottom {m n t : ℕ} (h : t ≤ m) : bIdx m n t = t := by unfold bIdx; exact ite_eq_left h ++ ++theorem bIdy_bottom {m n t : ℕ} (h : t ≤ m) : bIdy m n t = 0 := by unfold bIdy; exact ite_eq_left h + + theorem bIdx_right {m n t : ℕ} (h₁ : m ≤ t) (h₂ : t ≤ m + n) : bIdx m n t = m := by + unfold bIdx; split_ifs <;> omega +@@ -737,25 +737,29 @@ + unfold gridBoundaryEdge gridBoundaryPt gridGraph + rcases lt_or_ge t m with h₁ | h₁ + · -- along the bottom +- rw [if_pos h₁, bIdx_bottom (by omega), bIdy_bottom (by omega), bIdx_bottom (by omega), ++ rw [ite_eq_left h₁, bIdx_bottom (by omega), bIdy_bottom (by omega), bIdx_bottom (by omega), + bIdy_bottom (by omega)] + exact pieceListGraph_isLink_self (gridHEdge_mem_gridEdges h₁ (Nat.zero_le n) hn) + rcases lt_or_ge t (m + n) with h₂ | h₂ + · -- up the right side +- rw [if_neg (by omega), if_pos h₂, bIdx_right (by omega) (by omega), ++ rw [ite_eq_right (by omega), ite_eq_left h₂, bIdx_right (by omega) (by omega), + bIdy_right (by omega) (by omega), bIdx_right (by omega) (by omega), + bIdy_right (by omega) (by omega), show t + 1 - m = (t - m) + 1 by omega] + exact pieceListGraph_isLink_self (gridVEdge_mem_gridEdges le_rfl (by omega) hm) + rcases lt_or_ge t (2 * m + n) with h₃ | h₃ + · -- back along the top, so the walk runs against the edge's own orientation +- rw [if_neg (by omega), if_neg (by omega), if_pos h₃, bIdx_top (by omega) (by omega), ++ rw [ite_eq_right (by omega), ++ ite_eq_right (by omega), ++ ite_eq_left h₃, bIdx_top (by omega) (by omega), + bIdy_top (by omega) (by omega), bIdx_top (by omega) (by omega), + bIdy_top (by omega) (by omega), show 2 * m + n - (t + 1) = 2 * m + n - 1 - t by omega, + show 2 * m + n - t = 2 * m + n - 1 - t + 1 by omega] + exact (pieceListGraph_isLink_self (gridHEdge_mem_gridEdges + (show 2 * m + n - 1 - t < m by omega) le_rfl hn)).symm + · -- down the left side, again against the edge's orientation +- rw [if_neg (by omega), if_neg (by omega), if_neg (by omega), bIdx_left (by omega) (by omega), ++ rw [ite_eq_right (by omega), ++ ite_eq_right (by omega), ++ ite_eq_right (by omega), bIdx_left (by omega) (by omega), + bIdy_left (by omega) (by omega), bIdx_left (by omega) (by omega), + bIdy_left (by omega) (by omega), + show 2 * m + 2 * n - (t + 1) = 2 * m + 2 * n - 1 - t by omega, +@@ -814,23 +818,23 @@ + + theorem gridBoundaryEdge_bottom {xc yc : ℕ → ℝ} {m n i : ℕ} (h : i < m) : + gridBoundaryEdge xc yc m n i = gridHEdge xc yc i 0 := by +- unfold gridBoundaryEdge; rw [if_pos h] ++ unfold gridBoundaryEdge; rw [ite_eq_left h] + + theorem gridBoundaryEdge_right {xc yc : ℕ → ℝ} {m n j : ℕ} (h : j < n) : + gridBoundaryEdge xc yc m n (m + j) = gridVEdge xc yc m j := by + unfold gridBoundaryEdge +- rw [if_neg (by omega), if_pos (by omega), show m + j - m = j by omega] ++ rw [ite_eq_right (by omega), ite_eq_left (by omega), show m + j - m = j by omega] + + theorem gridBoundaryEdge_top {xc yc : ℕ → ℝ} {m n i : ℕ} (hn : 1 ≤ n) (h : i < m) : + gridBoundaryEdge xc yc m n (2 * m + n - 1 - i) = gridHEdge xc yc i n := by + unfold gridBoundaryEdge +- rw [if_neg (by omega), if_neg (by omega), if_pos (by omega), ++ rw [ite_eq_right (by omega), ite_eq_right (by omega), ite_eq_left (by omega), + show 2 * m + n - 1 - (2 * m + n - 1 - i) = i by omega] + + theorem gridBoundaryEdge_left {xc yc : ℕ → ℝ} {m n j : ℕ} (h : j < n) : + gridBoundaryEdge xc yc m n (2 * m + 2 * n - 1 - j) = gridVEdge xc yc 0 j := by + unfold gridBoundaryEdge +- rw [if_neg (by omega), if_neg (by omega), if_neg (by omega), ++ rw [ite_eq_right (by omega), ite_eq_right (by omega), ite_eq_right (by omega), + show 2 * m + 2 * n - 1 - (2 * m + 2 * n - 1 - j) = j by omega] + + /-- The realisation of the cycle is the union of the boundary edges, indexed by position on +diff --git a/Schoenflies/SquareMeshFixed.lean b/Schoenflies/SquareMeshFixed.lean +--- a/Schoenflies/SquareMeshFixed.lean ++++ b/Schoenflies/SquareMeshFixed.lean +@@ -133,7 +133,7 @@ + + theorem endSet_pair (a q b : Plane) : endSet [((a, q) : Piece), (q, b)] = {a, q, b} := by + ext x +- simp only [endSet, mem_setOf_eq, List.mem_cons, List.not_mem_nil, or_false, mem_insert_iff, ++ simp only [endSet, mem_ofPred_eq, List.mem_cons, List.not_mem_nil, or_false, mem_insert_iff, + mem_singleton_iff] + constructor + · rintro ⟨P, hP, hx⟩ +@@ -240,7 +240,7 @@ + induction l with + | nil => rfl + | cons R l ih => +- rw [splitAllAt, List.flatMap_cons, splitAt, if_neg (h R (List.mem_cons_self ..))] ++ rw [splitAllAt, List.flatMap_cons, splitAt, ite_eq_right (h R (List.mem_cons_self ..))] + rw [show l.flatMap (splitAt q) = splitAllAt q l from rfl, + ih fun S hS => h S (List.mem_cons_of_mem _ hS)] + rfl +@@ -256,22 +256,22 @@ + obtain ⟨S, hS, hRS⟩ := List.mem_flatMap.1 hR + by_cases hqS : q ∈ S.interior + · obtain rfl := huniq S hS hqS +- rw [splitAt, if_pos hqS] at hRS ++ rw [splitAt, ite_eq_left hqS] at hRS + exact Or.inr hRS +- · rw [splitAt, if_neg hqS] at hRS ++ · rw [splitAt, ite_eq_right hqS] at hRS + obtain rfl : R = S := List.mem_singleton.1 hRS + exact Or.inl ⟨hS, fun h => hqS (h ▸ hq)⟩ + · rintro (⟨hR, hRP⟩ | hR) + · have hqR : q ∉ R.interior := fun h => hRP (huniq R hR h) +- exact List.mem_flatMap.2 ⟨R, hR, by rw [splitAt, if_neg hqR]; simp⟩ +- · exact List.mem_flatMap.2 ⟨P, hP, by rw [splitAt, if_pos hq]; exact hR⟩ ++ exact List.mem_flatMap.2 ⟨R, hR, by rw [splitAt, ite_eq_right hqR]; simp⟩ ++ · exact List.mem_flatMap.2 ⟨P, hP, by rw [splitAt, ite_eq_left hq]; exact hR⟩ + + /-- The ends of a split list: the old ends and the cut point. -/ + theorem endSet_splitAllAt {l : List Piece} {P : Piece} {q : Plane} (hP : P ∈ l) + (hq : q ∈ P.interior) (huniq : ∀ S ∈ l, q ∈ S.interior → S = P) : + endSet (splitAllAt q l) = endSet l ∪ {q} := by + ext v +- simp only [endSet, mem_setOf_eq, mem_union, mem_singleton_iff] ++ simp only [endSet, mem_ofPred_eq, mem_union, mem_singleton_iff] + constructor + · rintro ⟨R, hR, hv⟩ + rcases (mem_splitAllAt_iff hP hq huniq).1 hR with ⟨hRl, -⟩ | hR2 +@@ -373,7 +373,7 @@ + (splitAt_interior_subset q' S₀ S hSS₀ hqS) + -- … and the two halves of one piece have disjoint interiors + by_cases hq'R : q' ∈ R₀.interior +- · rw [splitAt, if_pos hq'R] at hRR₀ hSS₀ ++ · rw [splitAt, ite_eq_left hq'R] at hRR₀ hSS₀ + simp only [List.mem_cons, List.not_mem_nil, or_false] at hRR₀ hSS₀ + have hnd₀ : R₀.Nondeg := hnd R₀ hR₀ + rcases hRR₀ with rfl | rfl <;> rcases hSS₀ with rfl | rfl +@@ -381,7 +381,7 @@ + · exact absurd (openSegment_halves_disjoint hnd₀ hq'R hqR hqS) not_false + · exact absurd (openSegment_halves_disjoint hnd₀ hq'R hqS hqR) not_false + · rfl +- · rw [splitAt, if_neg hq'R] at hRR₀ hSS₀ ++ · rw [splitAt, ite_eq_right hq'R] at hRR₀ hSS₀ + rw [List.mem_singleton.1 hRR₀, List.mem_singleton.1 hSS₀] + · rcases hq.2 with hnone | hend + · exact Or.inl fun R hR => by +diff --git a/Schoenflies/SquareMover.lean b/Schoenflies/SquareMover.lean +--- a/Schoenflies/SquareMover.lean ++++ b/Schoenflies/SquareMover.lean +@@ -96,10 +96,10 @@ + noncomputable def bend (r p q u : ℝ) : ℝ := + if u ≤ p then -r + (u + r) * (q + r) / (p + r) else r - (r - u) * (r - q) / (r - p) + +-theorem bend_of_le (h : u ≤ p) : bend r p q u = -r + (u + r) * (q + r) / (p + r) := if_pos h ++theorem bend_of_le (h : u ≤ p) : bend r p q u = -r + (u + r) * (q + r) / (p + r) := ite_eq_left h + + theorem bend_of_gt (h : p < u) : bend r p q u = r - (r - u) * (r - q) / (r - p) := +- if_neg (not_le.2 h) ++ ite_eq_right (not_le.2 h) + + theorem bend_left (h : -r ≤ p) : bend r p q (-r) = -r := by + rw [bend_of_le h]; simp +@@ -279,7 +279,7 @@ + c i + bend r (a + k * shearWeight c r b j z) (a + (k + k') * shearWeight c r b j z) + (z i - c i) := by + simp only [shear, PiLp.add_apply, PiLp.smul_apply, PiLp.single_apply, smul_eq_mul, +- if_true, mul_one] ++ ite_true, mul_one] + ring + + theorem shear_apply_ne (h : l ≠ i) : shear c r a b k k' i j z l = z l := by +@@ -585,13 +585,13 @@ + · rintro ⟨h1, h2⟩ + exact le_antisymm h1 (not_lt.1 h2) + · intro h +- exact ⟨le_of_eq h, by rw [openSquare, mem_setOf_eq, h]; exact lt_irrefl r⟩ ++ exact ⟨le_of_eq h, by rw [openSquare, mem_ofPred_eq, h]; exact lt_irrefl r⟩ + + /-- A mover is the identity on the boundary square `S`. -/ + theorem IsSquareMover.eqOn_frontier {M N : Plane → Plane} (h : IsSquareMover c r M N) : + EqOn M id (frontier (closedSquare c r)) := by + intro z hz +- rw [frontier_closedSquare, mem_setOf_eq] at hz ++ rw [frontier_closedSquare, mem_ofPred_eq] at hz + exact h.fixes z (le_of_eq hz) hz + + /-! ### The mover as a homeomorphism -/ +@@ -603,8 +603,8 @@ + invFun z := ⟨N z, h.mapsTo_inv z.2⟩ + left_inv z := Subtype.ext (h.invOn.1 z.2) + right_inv z := Subtype.ext (h.invOn.2 z.2) +- continuous_toFun := h.continuousOn.restrict.subtype_mk _ +- continuous_invFun := h.continuousOn_inv.restrict.subtype_mk _ ++ continuous_toFun := h.continuousOn.domRestrict.subtype_mk _ ++ continuous_invFun := h.continuousOn_inv.domRestrict.subtype_mk _ + + @[simp] theorem IsSquareMover.homeomorph_apply {M N : Plane → Plane} + (h : IsSquareMover c r M N) (z : closedSquare c r) : +diff --git a/Schoenflies/Strip.lean b/Schoenflies/Strip.lean +--- a/Schoenflies/Strip.lean ++++ b/Schoenflies/Strip.lean +@@ -207,7 +207,7 @@ + have harc : arcCCW u w = {d : Plane | det w d < 0} ∪ {d : Plane | det d u < 0} := by + ext d + rw [mem_arcCCW_rev_iff h'] +- simp only [mem_union, mem_setOf_eq] ++ simp only [mem_union, mem_ofPred_eq] + have hd0 : (-ε) • (u + w) ∈ ball (0 : Plane) ρ := + hball _ (by rw [abs_of_neg (neg_neg_iff_pos.2 hε), neg_neg]) + have hA : (-ε) • (u + w) ∈ {d : Plane | det w d < 0} := by +@@ -227,7 +227,7 @@ + have harc : arcCCW u w = {d : Plane | 0 < det u d} ∩ {d : Plane | 0 < det d w} := by + ext d + rw [mem_arcCCW_iff hpos] +- simp only [mem_inter_iff, mem_setOf_eq] ++ simp only [mem_inter_iff, mem_ofPred_eq] + have hmem : ε • (u + w) ∈ arcCCW u w ∩ ball (0 : Plane) ρ := by + refine ⟨?_, hball _ (abs_of_pos hε)⟩ + rw [harc] +@@ -275,7 +275,7 @@ + module + · rintro ⟨d, ⟨hd, hb⟩, rfl⟩ + have he : v + d - v = d := by module +- refine ⟨by rw [mem_setOf_eq, he]; exact hd, ?_⟩ ++ refine ⟨by rw [mem_ofPred_eq, he]; exact hd, ?_⟩ + rw [mem_ball, dist_eq_norm, he] + rw [mem_ball, dist_zero_right] at hb + exact hb +@@ -388,7 +388,7 @@ + ({x : Plane | t₁ < coordAlong a u x} ∩ {x : Plane | coordAlong a u x < t₂}) ∩ + ({x : Plane | s₁ < coordAcross a u x} ∩ {x : Plane | coordAcross a u x < s₂}) := by + ext y +- simp only [mem_strip_iff, mem_inter_iff, mem_setOf_eq] ++ simp only [mem_strip_iff, mem_inter_iff, mem_ofPred_eq] + tauto + rw [key] + exact ((isOpen_lt continuous_const (continuous_coordAlong a u)).inter +@@ -407,7 +407,7 @@ + simp only [coordAcross, det] + simp + ring +- simp only [mem_strip_iff, mem_inter_iff, mem_setOf_eq, h1, h2] ++ simp only [mem_strip_iff, mem_inter_iff, mem_ofPred_eq, h1, h2] + constructor + · rintro ⟨a1, a2, a3, a4⟩; exact ⟨⟨by linarith, by linarith⟩, ⟨by linarith, by linarith⟩⟩ + · rintro ⟨⟨a1, a2⟩, ⟨a3, a4⟩⟩; exact ⟨by linarith, by linarith, by linarith, by linarith⟩ +diff --git a/Schoenflies/StripLocal.lean b/Schoenflies/StripLocal.lean +--- a/Schoenflies/StripLocal.lean ++++ b/Schoenflies/StripLocal.lean +@@ -288,7 +288,7 @@ + (have hδpos : 0 < min 1 (ε / (2 * ‖z - P.vertex i‖)) := lt_min one_pos (by positivity) + have hsub : P.vertex i + (min 1 (ε / (2 * ‖z - P.vertex i‖))) • (z - P.vertex i) - + P.vertex i = (min 1 (ε / (2 * ‖z - P.vertex i‖))) • (z - P.vertex i) := by module) +- · rw [Set.mem_setOf_eq, hsub] ++ · rw [Set.mem_ofPred_eq, hsub] + exact (smul_mem_arcCCW hδpos).2 harc + · rw [mem_ball, dist_eq_norm, hsub, norm_smul, Real.norm_eq_abs, abs_of_pos hδpos] + have h1 : min 1 (ε / (2 * ‖z - P.vertex i‖)) ≤ 1 := min_le_left _ _ +@@ -309,7 +309,7 @@ + (have hδpos : 0 < min 1 (ε / (2 * ‖z - P.vertex i‖)) := lt_min one_pos (by positivity) + have hsub : P.vertex i + (min 1 (ε / (2 * ‖z - P.vertex i‖))) • (z - P.vertex i) - + P.vertex i = (min 1 (ε / (2 * ‖z - P.vertex i‖))) • (z - P.vertex i) := by module) +- · rw [Set.mem_setOf_eq, hsub] ++ · rw [Set.mem_ofPred_eq, hsub] + exact (smul_mem_arcCCW hδpos).2 harc + · rw [mem_ball, dist_eq_norm, hsub, norm_smul, Real.norm_eq_abs, abs_of_pos hδpos] + have h1 : min 1 (ε / (2 * ‖z - P.vertex i‖)) ≤ 1 := min_le_left _ _ +diff --git a/Schoenflies/Subarc.lean b/Schoenflies/Subarc.lean +--- a/Schoenflies/Subarc.lean ++++ b/Schoenflies/Subarc.lean +@@ -78,7 +78,8 @@ + theorem image_reparam_I : reparam a b '' I = uIcc a b := by + have h : (fun θ : ℝ => a + θ • (b - a)) '' Icc (0 : ℝ) 1 = uIcc a b := by + rw [← segment_eq_image' ℝ a b, segment_eq_uIcc] +- simpa [reparam, smul_eq_mul] using h ++ change (fun t : ℝ => a + t * (b - a)) '' Icc (0 : ℝ) 1 = uIcc a b ++ simpa only [smul_eq_mul] using h + + theorem mapsTo_reparam : MapsTo (reparam a b) I (uIcc a b) := + mapsTo_iff_image_subset.mpr image_reparam_I.subset +diff --git a/Schoenflies/TargetOverlay.lean b/Schoenflies/TargetOverlay.lean +--- a/Schoenflies/TargetOverlay.lean ++++ b/Schoenflies/TargetOverlay.lean +@@ -84,7 +84,7 @@ + theorem exists_targetSegmentCover + (P : GeneratedPair S₀ srcOuter srcDom tgtOuter tgtDom) : + Nonempty (TargetSegmentCover P) := by +- letI : Graph.Finite P.tgt.graph := ++ let : Graph.Finite P.tgt.graph := + CellStructure.Realization.finite_graph P.tgt + have hincident : ∀ z ∈ V(P.tgt.graph), ∃ e, P.tgt.graph.Inc e z := by + intro z hz +@@ -1024,7 +1024,7 @@ + A ∈ openTargetEdgePieces P ↔ + ∃ e ∈ E(P.str.skel), e ∉ E(P.str.outerGraph) ∧ + A = edgeArc P.tgt.drawing e \ modelCurve := by +- letI : P.str.skel.Finite := ++ let : P.str.skel.Finite := + ⟨P.str.finite_vertexSet, P.str.finite_edgeSet⟩ + simp only [openTargetEdgePieces, List.mem_map, Finset.mem_toList, Finset.mem_filter, + Graph.mem_edgeFinset] +diff --git a/lakefile.toml b/lakefile.toml +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -12,7 +12,7 @@ + [[require]] + name = "mathlib" + scope = "leanprover-community" +-rev = "v4.32.2" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "Schoenflies" +diff --git a/lean-toolchain b/lean-toolchain +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.2 ++leanprover/lean4:v4.34.1 +diff --git a/Schoenflies/Jordan.lean b/Schoenflies/Jordan.lean +index fef1405..ad432b8 100644 +--- a/Schoenflies/Jordan.lean ++++ b/Schoenflies/Jordan.lean +@@ -719,7 +719,7 @@ theorem not_three_components (harc : ∀ A : Set Plane, IsArc A → IsConnected + first + | exact absurd rfl hjl + | assumption +- | (rw [inter_comm]; assumption) ++ | rwa [inter_comm] + choose xx hxxΩ TT hTTarc hTTsub hTTmeet using htri + /- ### Assembling the `K(3,3)` -/ + have hTC : ∀ i j, TT i j ∩ f '' I = {f (t i j)} := by diff --git a/lean/patches/tate-curves-theta-lean4341.patch b/lean/patches/tate-curves-theta-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..e32c4d3cebc0669c3b24c28b88ec9c5b59b38172 --- /dev/null +++ b/lean/patches/tate-curves-theta-lean4341.patch @@ -0,0 +1,143 @@ +diff --git a/lake-manifest.json b/lake-manifest.json +index 5772203cbac85733227425f851da565f55eaf8d2..d476272f0c5c68c6ea0bdb3cea5ea14f93f13c5c 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,7 +1,7 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/lana-agents/formal-schemes", ++ [{"url": "https://github.com/lana-agents/formal-schemes.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -11,21 +11,21 @@ + "inputRev": "51aa935079537bf4dc580751a6e70727fb23ca93", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/mathlib4", ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -35,7 +35,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +45,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -65,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -75,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -85,7 +85,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -95,10 +95,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "«tate-curves-theta»", +diff --git a/lakefile.toml b/lakefile.toml +index 9b84bd9125231e37c29c21da2a84d83e9668197e..0d2775da50050fb49d958ce5c9b01199cd8ee0fb 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["TateCurvesTheta"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -11,12 +13,12 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[require]] + name = "formal-schemes" +-git = "https://github.com/lana-agents/formal-schemes" ++git = "https://github.com/lana-agents/formal-schemes.git" + rev = "51aa935079537bf4dc580751a6e70727fb23ca93" + + [[lean_lib]] +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/lean/patches/tempered-fundamental-groups-lean4341.patch b/lean/patches/tempered-fundamental-groups-lean4341.patch new file mode 100644 index 0000000000000000000000000000000000000000..68507f9bad16237886449c8ad046bed7d191a528 --- /dev/null +++ b/lean/patches/tempered-fundamental-groups-lean4341.patch @@ -0,0 +1,272 @@ +diff --git a/TemperedFundamentalGroups/Models/Projective.lean b/TemperedFundamentalGroups/Models/Projective.lean +index 0f8582d7e728987f7bf3a8c23c46c27b93aae30c..5ff142d2155f8401695f70661069691b55f445e1 100644 +--- a/TemperedFundamentalGroups/Models/Projective.lean ++++ b/TemperedFundamentalGroups/Models/Projective.lean +@@ -84,7 +84,7 @@ open MvPolynomial HomogeneousLocalization + variable {R} + + lemma isHomogeneous_fin_one {p : MvPolynomial (Fin (0 + 1)) R} {n : ℕ} (hp : p.IsHomogeneous n) : +- p = C (coeff (Finsupp.single 0 n) p) * X 0 ^ n := by ++ p = C (p.coeff (Finsupp.single 0 n)) * X 0 ^ n := by + ext d + rw [coeff_C_mul, coeff_X_pow] + by_cases hd : Finsupp.single 0 n = d +@@ -129,7 +129,7 @@ lemma bijective_fromZeroRingHom_projSpace_zero : + · obtain ⟨n, a, ha, rfl⟩ := Away.mk_surjective (homogeneousSubmodule (Fin (0 + 1)) R) + X_zero_mem_homogeneousSubmodule z + have ha' : a.IsHomogeneous n := by simpa using ha +- refine ⟨⟨C (coeff (Finsupp.single 0 n) a), isHomogeneous_C _ _⟩, ?_⟩ ++ refine ⟨⟨C (a.coeff (Finsupp.single 0 n)), isHomogeneous_C _ _⟩, ?_⟩ + apply val_injective + rw [Away.val_mk] + change Localization.mk _ 1 = _ +diff --git a/TemperedFundamentalGroups/Models/Specialization.lean b/TemperedFundamentalGroups/Models/Specialization.lean +index 00f4b73f89c33df5476307335fb0195af1b36ed5..e3dd586fa3e3eb43feb6b88c6b69f9778de9e3c3 100644 +--- a/TemperedFundamentalGroups/Models/Specialization.lean ++++ b/TemperedFundamentalGroups/Models/Specialization.lean +@@ -192,7 +192,12 @@ lemma spLift_unique [UniversallyClosed f] [IsSeparated f] (x : Spec (CommRingCat + lemma spLift_closedPoint_mem [UniversallyClosed f] (x : Spec (CommRingCat.of Ω) ⟶ X) + (hx : x ≫ f = Spec.map (CommRingCat.ofHom (valToField O))) : + (spLift (hV := hV) x hx).l (closedPoint V) ∈ specialFibre f := by +- rw [mem_specialFibre, ← Scheme.Hom.comp_apply, spLift_fac_right] ++ let ℓ : Spec (CommRingCat.of V) ⟶ X := (spLift (hV := hV) x hx).l ++ let v : Spec (CommRingCat.of V) := closedPoint V ++ have hℓ : ℓ ≫ f = Spec.map (CommRingCat.ofHom (valToVal O V hV)) := ++ spLift_fac_right x hx ++ change ℓ v ∈ specialFibre f ++ rw [mem_specialFibre, ← Scheme.Hom.comp_apply, hℓ] + exact valToVal_closedPoint O V hV + + end Specialization +@@ -228,10 +233,15 @@ lemma sp_comp {X' : Scheme.{u}} {f' : X' ⟶ Spec (CommRingCat.of O)} + (hx : x ≫ f = Spec.map (CommRingCat.ofHom (valToField O))) : + sp f' V hV (x ≫ ψ) (by rw [Category.assoc, hψ, hx]) = + specialFibreMap ψ hψ (sp f V hV x hx) := by ++ let ℓ : Spec (CommRingCat.of V) ⟶ X := (spLift (hV := hV) x hx).l ++ have hℓ_left : Spec.map (CommRingCat.ofHom (algebraMap V Ω)) ≫ ℓ = x := ++ spLift_fac_left x hx ++ have hℓ_right : ℓ ≫ f = Spec.map (CommRingCat.ofHom (valToVal O V hV)) := ++ spLift_fac_right x hx + ext +- rw [sp_eq_of_lift (x ≫ ψ) _ ((spLift (hV := hV) x hx).l ≫ ψ) +- (by rw [← Category.assoc, spLift_fac_left]) +- (by rw [Category.assoc, hψ]; exact spLift_fac_right x hx)] ++ rw [sp_eq_of_lift (x ≫ ψ) _ (ℓ ≫ ψ) ++ (by rw [← Category.assoc, hℓ_left]) ++ (by rw [Category.assoc, hψ, hℓ_right])] + rfl + + lemma coe_sp_comp {X' : Scheme.{u}} {f' : X' ⟶ Spec (CommRingCat.of O)} +@@ -268,22 +278,26 @@ lemma sp_galois [UniversallyClosed f] [IsSeparated f] (σ : Ω ≃ₐ[K] Ω) + congr 2 + ext a + simp [valToField]) = sp f V hV x hx := by ++ let ℓ : Spec (CommRingCat.of V) ⟶ X := (spLift (hV := hV) x hx).l ++ have hℓ_left : Spec.map (CommRingCat.ofHom (algebraMap V Ω)) ≫ ℓ = x := ++ spLift_fac_left x hx ++ have hℓ_right : ℓ ≫ f = Spec.map (CommRingCat.ofHom (valToVal O V hV)) := ++ spLift_fac_right x hx + ext +- rw [sp_eq_of_lift _ _ (Spec.map (CommRingCat.ofHom (restrictVal σ hσ)) ≫ +- (spLift (hV := hV) x hx).l)] +- · change (spLift (hV := hV) x hx).l _ = (spLift (hV := hV) x hx).l _ ++ rw [sp_eq_of_lift _ _ (Spec.map (CommRingCat.ofHom (restrictVal σ hσ)) ≫ ℓ)] ++ · change ℓ _ = ℓ _ + congr 1 + exact comap_closedPoint (restrictVal σ hσ) + · have e : (algebraMap V Ω).comp (restrictVal σ hσ) = (σ : Ω →+* Ω).comp (algebraMap V Ω) := by + ext; rfl + rw [← Category.assoc, ← Spec.map_comp, ← CommRingCat.ofHom_comp, e, +- CommRingCat.ofHom_comp, Spec.map_comp, Category.assoc, spLift_fac_left] ++ CommRingCat.ofHom_comp, Spec.map_comp, Category.assoc, hℓ_left] + · have e : (restrictVal σ hσ).comp (valToVal O V hV) = valToVal O V hV := by + ext a + exact σ.commutes (a : K) + rw [Category.assoc] + refine (congrArg (Spec.map (CommRingCat.ofHom (restrictVal σ hσ)) ≫ ·) +- (spLift_fac_right (hV := hV) x hx)).trans ?_ ++ hℓ_right).trans ?_ + rw [← Spec.map_comp, ← CommRingCat.ofHom_comp, e] + + end Specialization +diff --git a/TemperedFundamentalGroups/SemistableReduction/NodeNormal.lean b/TemperedFundamentalGroups/SemistableReduction/NodeNormal.lean +index 393ca04750fcc7b0bdfe5cb7426aac029e7d9ba4..0e073bd71f05f9fe197d96fdd1a68e4d573c5520 100644 +--- a/TemperedFundamentalGroups/SemistableReduction/NodeNormal.lean ++++ b/TemperedFundamentalGroups/SemistableReduction/NodeNormal.lean +@@ -74,7 +74,7 @@ lemma toLaurent_map_mem_integralLaurent (h : Polynomial O) : + lemma coeff_toLaurent_natCast (p : Polynomial K) (k : ℕ) : + (Polynomial.toLaurent p).coeff (k : ℤ) = p.coeff k := by + rw [coeff_toLaurent] +- exact Finsupp.mapDomain_apply Nat.cast_injective _ k ++ exact Finsupp.mapDomain_apply_of_injective Nat.cast_injective _ k + + lemma exists_map_eq_of_toLaurent_mem {p : Polynomial K} + (hp : Polynomial.toLaurent p ∈ integralLaurent O) : +diff --git a/lake-manifest.json b/lake-manifest.json +index e17bd4ffa0e881f9ab806a1a47c9b7cea8f8b24d..1927b94ca6e8b09e86ef5aeadc8b187ab9af7102 100644 +--- a/lake-manifest.json ++++ b/lake-manifest.json +@@ -1,17 +1,17 @@ + {"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": +- [{"url": "https://github.com/lana-agents/pi1", ++ [{"url": "https://github.com/lana-agents/pi1.git", + "type": "git", + "subDir": null, + "scope": "", +- "rev": "60129404bd759f1a3653e87c2c9e6fbb21ec995e", ++ "rev": "ca7def953193f861a462aa0831eec8f0a31ff69f", + "name": "pi1", + "manifestFile": "lake-manifest.json", +- "inputRev": "60129404bd759f1a3653e87c2c9e6fbb21ec995e", ++ "inputRev": "ca7def953193f861a462aa0831eec8f0a31ff69f", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/lana-agents/elliptic-curves", ++ {"url": "https://github.com/lana-agents/elliptic-curves.git", + "type": "git", + "subDir": null, + "scope": "", +@@ -21,21 +21,21 @@ + "inputRev": "bebec3fc9f2602e81c83e5236789572a541c85fb", + "inherited": false, + "configFile": "lakefile.toml"}, +- {"url": "https://github.com/leanprover-community/mathlib4", ++ {"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, +- "scope": "leanprover-community", +- "rev": "81a5d257c8e410db227a6665ed08f64fea08e997", ++ "scope": "", ++ "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "e12c1910fe855cbfc38803cd4e55543906d5fa62", ++ "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -45,7 +45,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "c5d5b8fe6e5158def25cd28eb94e4141ad97c843", ++ "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -55,7 +55,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "7e9612bf0b9ee66db3cb5b9988a35afc706f5a12", ++ "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -65,7 +65,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "6e311e2a844da9b2cc3971187df2fe0066947b93", ++ "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -75,7 +75,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "a7dbf0c63b694e47f425f3dcddbc0e178bb432d3", ++ "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -85,7 +85,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "38d591e778f100aec9762bb582f9c7f55f50e9dc", ++ "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", +@@ -95,7 +95,7 @@ + "type": "git", + "subDir": null, + "scope": "leanprover-community", +- "rev": "023ce7d62a0531e22a5331e20b587817a80d49ff", ++ "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", +@@ -105,10 +105,10 @@ + "type": "git", + "subDir": null, + "scope": "leanprover", +- "rev": "88679d088c9720c27ebdf2ba4dafe17341747f94", ++ "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", +- "inputRev": "v4.32.0", ++ "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "«tempered-fundamental-groups»", +diff --git a/lakefile.toml b/lakefile.toml +index 81e26b03d5eba16bfb14fdd53fd58f0907adbd16..3cfc8b854d4fa7a0b15b805fd877ec332914bc69 100644 +--- a/lakefile.toml ++++ b/lakefile.toml +@@ -4,6 +4,8 @@ keywords = ["math"] + defaultTargets = ["TemperedFundamentalGroups"] + + [leanOptions] ++# Preserve the type-unification behavior expected by the pinned upstream sources. ++backward.isDefEq.respectTransparency.types = false + pp.unicode.fun = true # pretty-prints `fun a ↦ b` + relaxedAutoImplicit = false + weak.linter.mathlibStandardSet = true +@@ -11,8 +13,8 @@ maxSynthPendingDepth = 3 + + [[require]] + name = "mathlib" +-scope = "leanprover-community" +-rev = "v4.32.0" ++git = "https://github.com/leanprover-community/mathlib4.git" ++rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + + [[lean_lib]] + name = "TemperedFundamentalGroups" +@@ -21,7 +23,7 @@ name = "TemperedFundamentalGroups" + # the removed set `E[ℓ] + M` of the model orbicurves is a finite (closed) set. + [[require]] + name = "elliptic-curves" +-git = "https://github.com/lana-agents/elliptic-curves" ++git = "https://github.com/lana-agents/elliptic-curves.git" + rev = "bebec3fc9f2602e81c83e5236789572a541c85fb" + + # The étale fundamental group of an affine orbifold `[Spec R / A]` (`Pi1.Orbifold.etalePi1`), its +@@ -29,5 +31,5 @@ rev = "bebec3fc9f2602e81c83e5236789572a541c85fb" + # (`Pi1.Orbifold.EtaleCode`, `SemilinearAut`, `LevelRing`), shared with the `pi1` project. + [[require]] + name = "pi1" +-git = "https://github.com/lana-agents/pi1" +-rev = "60129404bd759f1a3653e87c2c9e6fbb21ec995e" ++git = "https://github.com/lana-agents/pi1.git" ++rev = "ca7def953193f861a462aa0831eec8f0a31ff69f" +diff --git a/lean-toolchain b/lean-toolchain +index 94b9f495baff80fd9cb44aad8f4762cb3b2066fe..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5 100644 +--- a/lean-toolchain ++++ b/lean-toolchain +@@ -1 +1 @@ +-leanprover/lean4:v4.32.0 ++leanprover/lean4:v4.34.1 diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/README.md b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1db8b5c7b00bbc3e78a83147d5613c99958e4023 --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/README.md @@ -0,0 +1,21 @@ +# [A pointwise 2-converse for elliptic curves with rational two-torsion](paper.pdf) + +**Author:** OpenAI + +**Date:** October 7, 2026 + +## Citation + +```bibtex +@misc{OAI:A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026, + author = {{OpenAI}}, + title = {{A pointwise $2$-converse for elliptic curves with rational two-torsion}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/paper.pdf}{OAI:A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026}}, + year = {2026} +} +``` + +## Version note + +This version updates a citation to a revised manuscript in this collection; see the [previous version](../A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-September-24-2026/paper.pdf). diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/paper.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/paper.tex new file mode 100644 index 0000000000000000000000000000000000000000..8e458568b3384f2d59218e02fe3935503178f9b8 --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/paper.tex @@ -0,0 +1,80 @@ +\documentclass[11pt]{article} +\pdftrailerid{} +\input{glyphtounicode} +\input{glyphtounicode-cmex} +\pdfgentounicode=1 +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage[a4paper,margin=28mm]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools,mathrsfs} +\usepackage{booktabs,array,longtable,enumitem} +\usepackage{microtype} +\usepackage{xcolor} +\usepackage[nottoc]{tocbibind} +\usepackage[colorlinks=true,linkcolor=blue!45!black,citecolor=blue!45!black,urlcolor=blue!45!black,bookmarksnumbered=true,bookmarksdepth=2]{hyperref} +\usepackage{bookmark} +\numberwithin{equation}{section} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\newtheorem{claim}[theorem]{Claim} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{hypothesis}[theorem]{Hypothesis} +\newtheorem{assumption}[theorem]{Assumption} +\newtheorem{conjecture}[theorem]{Conjecture} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newtheorem{example}[theorem]{Example} +\newcommand{\Q}{\mathbb Q} +\newcommand{\Z}{\mathbb Z} +\newcommand{\F}{\mathbb F} +\newcommand{\C}{\mathbb C} +\newcommand{\R}{\mathbb R} +\newcommand{\Sha}{\operatorname{Sha}} +\DeclareMathOperator{\Sel}{Sel} +\DeclareMathOperator{\Gal}{Gal} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\End}{End} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\corank}{corank} +\DeclareMathOperator{\length}{length} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\coker}{coker} +\DeclareMathOperator{\Tr}{Tr} +\DeclareMathOperator{\Nm}{Nm} +\DeclareMathOperator{\adj}{adj} +\DeclareMathOperator{\id}{id} +\setlist{nosep,topsep=4pt} +\setlength{\emergencystretch}{1.5em} +\hypersetup{pdftitle={A pointwise 2-converse for elliptic curves with rational two-torsion},pdfsubject={Selmer coranks, integral interpolation, and pointwise quadratic-twist constructions},pdfauthor={OpenAI}} +\title{A pointwise $2$-converse\\for elliptic curves with rational two-torsion} +\author{OpenAI} +\date{October 7, 2026} +\begin{document} +\maketitle +\begin{abstract} +We prove a pointwise $2$-converse for elliptic curves over $\mathbf Q$ +with nonzero rational two-torsion: if the $2^\infty$-Selmer corank is +zero or one, then the analytic rank and Mordell--Weil rank equal that +corank, and the Shafarevich--Tate group is finite. The result allows +arbitrary reduction at $2$. +\end{abstract} +\setcounter{tocdepth}{1} +\tableofcontents +\clearpage +\input{sections/introduction} +\input{sections/preliminaries} +\input{sections/cyclotomic} +\input{sections/ring-limits} +\input{sections/ring-determinants} +\input{sections/nonvanishing} +\input{sections/coefficients} +\input{sections/graphs} +\input{sections/pointwise} +\bibliographystyle{plain} +\bibliography{references} +\end{document} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/references.bib b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..0a765a2b7cd45d2c515d859b4149df6f4871da5a --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/references.bib @@ -0,0 +1,355 @@ +@article{BCDT2001, + author={Breuil, Christophe and Conrad, Brian and Diamond, Fred and Taylor, Richard}, + title={On the modularity of elliptic curves over {$\mathbf Q$}: wild 3-adic exercises}, + journal={Journal of the American Mathematical Society},volume={14},number={4},pages={843--939},year={2001}, + note={\href{https://doi.org/10.1090/S0894-0347-01-00370-8}{doi:10.1090/S0894-0347-01-00370-8}} +} +@article{BirchSwinnertonDyer1965, + author={Birch, Bryan J. and Swinnerton-Dyer, H. P. F.}, + title={Notes on elliptic curves. {II}}, + journal={Journal f{\"u}r die reine und angewandte Mathematik},volume={218},pages={79--108},year={1965}, + note={\href{https://doi.org/10.1515/crll.1965.218.79}{doi:10.1515/crll.1965.218.79}} +} +@incollection{Tate1966, + author={Tate, John}, + title={On the conjectures of {Birch} and {Swinnerton-Dyer} and a geometric analog}, + booktitle={S{\'e}minaire Bourbaki},volume={9},pages={415--440},year={1966}, + publisher={Soci{\'e}t{\'e} math{\'e}matique de France}, + note={Expos{\'e} 306; \href{https://www.numdam.org/item/SB_1964-1966__9__415_0/}{primary text}} +} +@article{GrossZagier1986, + author={Gross, Benedict H. and Zagier, Don B.}, + title={Heegner points and derivatives of {$L$}-series}, + journal={Inventiones Mathematicae},volume={84},number={2},pages={225--320},year={1986}, + note={\href{https://doi.org/10.1007/BF01388809}{doi:10.1007/BF01388809}} +} +@incollection{Kolyvagin1990, + author={Kolyvagin, Viktor A.},title={Euler systems}, + booktitle={The Grothendieck Festschrift, Volume II}, + series={Progress in Mathematics},volume={87},pages={435--483}, + publisher={Birkh{\"a}user},year={1990}, + note={\href{https://doi.org/10.1007/978-0-8176-4575-5_11}{chapter reprint}} +} +@article{Skinner2020, + author={Skinner, Christopher}, + title={A converse to a theorem of {Gross}, {Zagier}, and {Kolyvagin}}, + journal={Annals of Mathematics},volume={191},number={2},pages={329--354},year={2020}, + note={\href{https://annals.math.princeton.edu/wp-content/uploads/annals-v191-n2-p01-s.pdf}{primary text}} +} +@article{Kim2023SoftConverse, + author={Kim, Chan-Ho}, + title={On the soft {$p$}-converse to a theorem of {Gross--Zagier} and {Kolyvagin}}, + journal={Mathematische Annalen},volume={387},pages={1961--1968},year={2023}, + note={\href{https://doi.org/10.1007/s00208-022-02511-8}{doi:10.1007/s00208-022-02511-8}; + text at \href{https://arxiv.org/abs/2109.12344v3}{arXiv:2109.12344v3}} +} +@article{Zhang2014Heegner, + author={Zhang, Wei}, + title={Selmer groups and the indivisibility of {Heegner} points}, + journal={Cambridge Journal of Mathematics},volume={2},number={2}, + pages={191--253},year={2014}, + note={\href{https://doi.org/10.4310/CJM.2014.v2.n2.a2}{doi:10.4310/CJM.2014.v2.n2.a2}} +} +@article{CGLS2022, + author={Castella, Francesc and Grossi, Giada and Lee, Jaehoon and Skinner, Christopher}, + title={On the anticyclotomic {Iwasawa} theory of rational elliptic curves at {Eisenstein} primes}, + journal={Inventiones Mathematicae},volume={227},number={2}, + pages={517--580},year={2022}, + note={\href{https://doi.org/10.1007/s00222-021-01072-y}{doi:10.1007/s00222-021-01072-y}; + text at \href{https://arxiv.org/abs/2008.02571v2}{arXiv:2008.02571v2}} +} +@article{BurungaleTian2026, + author={Burungale, Ashay A. and Tian, Ye}, + title={A rank zero {$p$}-converse to a theorem of {Gross--Zagier}, {Kolyvagin} and {Rubin}}, + journal={Annals of Mathematics},volume={203},number={1},pages={1--13},year={2026}, + note={\href{https://doi.org/10.4007/annals.2026.203.1.1}{doi:10.4007/annals.2026.203.1.1}; + Theorem~2.6 numbering in \href{https://arxiv.org/abs/2506.03465v1}{arXiv:2506.03465v1}} +} +@misc{KellerYin2024, + author={Keller, Timo and Yin, Mulun}, + title={{$p$}-converse theorems for elliptic curves of potentially good ordinary reduction at {Eisenstein} primes}, + year={2024},note={\href{https://arxiv.org/abs/2410.23241v1}{arXiv:2410.23241v1}} +} +@misc{Smith2025, + author={Smith, Alexander},title={The {Birch} and {Swinnerton-Dyer} conjecture implies {Goldfeld}'s conjecture}, + year={2025},note={\href{https://arxiv.org/abs/2503.17619v1}{arXiv:2503.17619v1}} +} +@article{DokchitserDokchitser2010, + author={Dokchitser, Tim and Dokchitser, Vladimir}, + title={On the {Birch--Swinnerton-Dyer} quotients modulo squares}, + journal={Annals of Mathematics},volume={172},number={1},pages={567--596},year={2010}, + note={\href{https://doi.org/10.4007/annals.2010.172.567}{doi:10.4007/annals.2010.172.567}} +} +@article{Kato2004, + author={Kato, Kazuya}, + title={{$p$}-adic {Hodge} theory and values of zeta functions of modular forms}, + journal={Ast{\'e}risque},volume={295},pages={117--290},year={2004}, + note={\href{https://www.numdam.org/item/AST_2004__295__117_0/}{primary text}} +} +@article{FerreroWashington1979, + author={Ferrero, Bruce and Washington, Lawrence C.}, + title={The {Iwasawa} invariant {$\mu_p$} vanishes for abelian number fields}, + journal={Annals of Mathematics},volume={109},number={2},pages={377--395},year={1979}, + note={\href{https://doi.org/10.2307/1971116}{doi:10.2307/1971116}} +} +@article{Chevalley1935, + author={Chevalley, Claude}, + title={D{\'e}monstration d'une hypoth{\`e}se de {M. Artin}}, + journal={Abhandlungen aus dem Mathematischen Seminar der Universit{\"a}t Hamburg}, + volume={11},pages={73--75},year={1935}, + note={\href{https://doi.org/10.1007/BF02940714}{doi:10.1007/BF02940714}} +} +@article{Warning1935, + author={Warning, Ewald}, + title={Bemerkung zur vorstehenden Arbeit von {Herrn Chevalley}}, + journal={Abhandlungen aus dem Mathematischen Seminar der Universit{\"a}t Hamburg}, + volume={11},pages={76--83},year={1935}, + note={\href{https://doi.org/10.1007/BF02940715}{doi:10.1007/BF02940715}} +} +@book{Nekovar2006, + author={Nekov{\'a}{\v r}, Jan},title={Selmer complexes}, + series={Ast{\'e}risque},volume={310},publisher={Soci{\'e}t{\'e} math{\'e}matique de France},year={2006}, + note={\href{https://www.numdam.org/item/AST_2006__310__R1_0/}{primary text}} +} +@article{Howard2012, + author={Howard, Benjamin},title={The {Heegner} point {Kolyvagin} system}, + journal={Compositio Mathematica},volume={140},number={6},pages={1439--1472},year={2004}, + note={\href{https://doi.org/10.1112/S0010437X04000569}{doi:10.1112/S0010437X04000569}; + text at \href{https://arxiv.org/abs/1202.6340v1}{arXiv:1202.6340v1}} +} +@article{CaiShuTian2014, + author={Cai, Li and Shu, Jie and Tian, Ye}, + title={Explicit {Gross--Zagier} and {Waldspurger} formulae}, + journal={Algebra \& Number Theory},volume={8},number={10},pages={2523--2572},year={2014}, + note={\href{https://doi.org/10.2140/ant.2014.8.2523}{doi:10.2140/ant.2014.8.2523}} +} +@article{Manin1972, + author={Manin, Yu. I.}, + title={Parabolic points and zeta-functions of modular curves}, + journal={Mathematics of the USSR-Izvestiya},volume={6},number={1}, + pages={19--64},year={1972}, + note={\href{https://doi.org/10.1070/IM1972v006n01ABEH001867}{doi:10.1070/IM1972v006n01ABEH001867}} +} +@article{Drinfeld1973, + author={Drinfeld, V. G.}, + title={Two theorems on modular curves}, + journal={Functional Analysis and Its Applications},volume={7},number={2}, + pages={155--156},year={1973}, + note={English translation of Funktsional'nyi Analiz i ego Prilozheniya 7 (1973), no.~2, 83--84; + \href{https://doi.org/10.1007/BF01078890}{doi:10.1007/BF01078890}} +} +@article{Cassels1965, + author={Cassels, J. W. S.}, + title={Arithmetic on curves of genus 1. {VIII}. On conjectures of {Birch} and {Swinnerton-Dyer}}, + journal={Journal f{\"u}r die reine und angewandte Mathematik},volume={217},pages={180--199},year={1965}, + note={\href{https://doi.org/10.1515/crll.1965.217.180}{doi:10.1515/crll.1965.217.180}} +} +@book{MilneADT2006, + author={Milne, J. S.},title={Arithmetic Duality Theorems}, + edition={Second},publisher={BookSurge},year={2006}, + note={\href{https://www.jmilne.org/math/Books/ADTnot.pdf}{author's electronic edition}} +} +@book{Serre1968, + author={Serre, Jean-Pierre}, + title={Abelian {$\ell$}-adic Representations and Elliptic Curves}, + publisher={W. A. Benjamin}, + address={New York}, + year={1968}, + note={\href{https://www.math.mcgill.ca/darmon/courses/18-19/gs/serre-mcgill.pdf}{1989 reprint of the 1968 text}} +} + +@article{Serre1972, + author={Serre, Jean-Pierre}, + title={Propri{\'e}t{\'e}s galoisiennes des points d'ordre fini des courbes elliptiques}, + journal={Inventiones Mathematicae},volume={15},pages={259--331},year={1972}, + note={\href{https://doi.org/10.1007/BF01405086}{doi:10.1007/BF01405086}} +} +@article{RadziwillSoundararajan2015, + author={Radziwi{\l}{\l}, Maksym and Soundararajan, K.}, + title={Moments and distribution of central {$L$}-values of quadratic twists of elliptic curves}, + journal={Inventiones Mathematicae},volume={202},number={3},pages={1029--1068},year={2015}, + note={\href{https://doi.org/10.1007/s00222-015-0582-z}{doi:10.1007/s00222-015-0582-z}; + \href{https://arxiv.org/abs/1403.7067}{arXiv:1403.7067}} +} +@article{Iwaniec1990, + author={Iwaniec, Henryk}, + title={On the order of vanishing of modular {$L$}-functions at the critical point}, + journal={S{\'e}minaire de th{\'e}orie des nombres de Bordeaux},volume={2},number={2},pages={365--376},year={1990}, + note={\href{https://www.numdam.org/item/JTNB_1990__2_2_365_0/}{primary text}} +} +@article{HeathBrown1995, + author={Heath-Brown, D. R.},title={A mean value estimate for real character sums}, + journal={Acta Arithmetica},volume={72},number={3},pages={235--275},year={1995}, + note={\href{https://doi.org/10.4064/aa-72-3-235-275}{doi:10.4064/aa-72-3-235-275}} +} +@book{FriedlanderIwaniec2010, + author={Friedlander, John and Iwaniec, Henryk},title={Opera de cribro}, + series={American Mathematical Society Colloquium Publications},volume={57}, + publisher={American Mathematical Society},year={2010}, + note={\href{https://doi.org/10.1090/coll/057}{doi:10.1090/coll/057}} +} +@article{HoffsteinLuo1997, + author={Hoffstein, Jeffrey and Luo, Wenzhi}, + title={Nonvanishing of {$L$}-series and the combinatorial sieve}, + journal={Mathematical Research Letters},volume={4},number={2--3}, + pages={435--444},year={1997}, + note={With an appendix by David E. Rohrlich; + \href{https://www.intlpress.com/site/pub/files/_fulltext/journals/mrl/1997/0004/0003/MRL-1997-0004-0003-a012.pdf}{primary text}} +} +@article{GelbartJacquet1978, + author={Gelbart, Stephen and Jacquet, Herv{\'e}}, + title={A relation between automorphic representations of {$\mathrm{GL}(2)$} and {$\mathrm{GL}(3)$}}, + journal={Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series={4},volume={11},number={4},pages={471--542},year={1978}, + note={\href{https://doi.org/10.24033/asens.1355}{doi:10.24033/asens.1355}} +} +@article{Waldspurger1981, + author={Waldspurger, Jean-Loup}, + title={Sur les coefficients de {Fourier} des formes modulaires de poids demi-entier}, + journal={Journal de Math{\'e}matiques Pures et Appliqu{\'e}es},volume={60},number={4},pages={375--484},year={1981}, + note={\href{https://mate.dm.uba.ar/~nsirolli/files/waldspurger.pdf}{complete text}} +} +@incollection{Waldspurger1983, + author={Waldspurger, Jean-Loup},title={Correspondances de {Shimura}}, + booktitle={Proceedings of the International Congress of Mathematicians, Warszawa, 1983}, + volume={1},pages={525--531},year={1984},publisher={PWN and Elsevier}, + note={\href{https://www.imj-prg.fr/wp-content/uploads/2020/prix/waldspurger1983.pdf}{primary text}} +} +@article{JetchevKane2010, + author={Jetchev, Dimitar and Kane, Ben}, + title={Equidistribution of {Heegner} points and ternary quadratic forms}, + journal={Mathematische Annalen},volume={350},number={3},pages={501--532},year={2011}, + note={\href{https://doi.org/10.1007/s00208-010-0568-5}{doi:10.1007/s00208-010-0568-5}; + section numbering in \href{https://arxiv.org/abs/0908.3905v1}{arXiv:0908.3905v1}} +} +@article{CornutJetchev2013, + author={Cornut, Christophe and Jetchev, Dimitar}, + title={Liftings of reduction maps for quaternion algebras}, + journal={Bulletin of the London Mathematical Society},volume={45}, + pages={370--386},year={2013}, + note={\href{https://doi.org/10.1112/blms/bds098}{doi:10.1112/blms/bds098}; + section numbering in the \href{https://webusers.imj-prg.fr/~christophe.cornut/papers/liftings.pdf}{authors' version}} +} +@article{Weil1964, + author={Weil, Andr{\'e}},title={Sur certains groupes d'op{\'e}rateurs unitaires}, + journal={Acta Mathematica},volume={111},pages={143--211},year={1964}, + note={\href{https://doi.org/10.1007/BF02391012}{doi:10.1007/BF02391012}} +} +@article{Faltings1983, + author={Faltings, Gerd}, + title={Endlichkeitss{\"a}tze f{\"u}r abelsche {Variet{\"a}ten} {\"u}ber {Zahlk{\"o}rpern}}, + journal={Inventiones Mathematicae},volume={73},number={3},pages={349--366},year={1983}, + note={\href{https://doi.org/10.1007/BF01388432}{doi:10.1007/BF01388432}} +} +@article{Bogomolov1981Points, + author={Bogomolov, F. A.}, + title={Points of finite order on an {Abelian} variety}, + journal={Mathematics of the USSR-Izvestiya},volume={17},number={1},pages={55--72},year={1981}, + note={English translation of Izv. Akad. Nauk SSSR Ser. Mat. 44 (1980), no. 4, 782--804; + \href{https://doi.org/10.1070/IM1981v017n01ABEH001329}{doi:10.1070/IM1981v017n01ABEH001329}} +} +@incollection{Deligne1969, + author={Deligne, Pierre},title={Formes modulaires et repr{\'e}sentations {$\ell$}-adiques}, + booktitle={S{\'e}minaire Bourbaki, 1968/69},series={Lecture Notes in Mathematics}, + volume={179},pages={139--172},publisher={Springer},year={1971}, + note={Expos{\'e} 355 (1969); \href{https://www.numdam.org/item/SB_1968-1969__11__139_0/}{primary text}} +} +@article{Carayol1986, + author={Carayol, Henri}, + title={Sur les repr{\'e}sentations {$\ell$}-adiques associ{\'e}es aux formes modulaires de {Hilbert}}, + journal={Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series={4},volume={19},number={3},pages={409--468},year={1986}, + note={\href{https://doi.org/10.24033/asens.1512}{doi:10.24033/asens.1512}} +} + +@article{Monsky1996, + author={Monsky, Paul}, + title={Generalizing the {Birch--Stephens} theorem. {I}. {Modular} curves}, + journal={Mathematische Zeitschrift},volume={221},number={3},pages={415--420},year={1996}, + note={\href{https://doi.org/10.1007/PL00004518}{doi:10.1007/PL00004518}} +} + +@misc{BurungaleSkinner2024Appendix, + author = {Burungale, Ashay and Skinner, Christopher}, + title = {A {$p$}-converse theorem for {CM} elliptic curves}, + year = {2024}, + howpublished = {Appendix A to Levent Alp{\"o}ge, Manjul Bhargava and Ari Shnidman, \emph{Integers expressible as the sum of two rational cubes}}, + eprint = {2210.10730v3}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/2210.10730v3}, + note = {Version 3, 19 October 2024; Theorems A.1, A.3 and Remark A.5; \href{https://arxiv.org/abs/2210.10730v3}{arXiv:2210.10730v3}} +} + +@article{BurungaleCastellaSkinnerTian2022, + author = {Burungale, Ashay and Castella, Francesc and Skinner, Christopher and Tian, Ye}, + title = {{$p^{\infty}$}-{Selmer} groups and rational points on {CM} elliptic curves}, + journal = {Annales math{\'e}matiques du Qu{\'e}bec}, + volume = {46}, + pages = {325--346}, + year = {2022}, + doi = {10.1007/s40316-022-00203-y}, + url = {https://link.springer.com/article/10.1007/s40316-022-00203-y}, + note = {\href{https://doi.org/10.1007/s40316-022-00203-y}{doi:10.1007/s40316-022-00203-y}} +} + +@misc{Kriz2022CM, + author = {Kriz, Daniel}, + title = {Supersingular main conjectures, {Sylvester}'s conjecture and {Goldfeld}'s conjecture}, + year = {2022}, + eprint = {2002.04767v5}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/2002.04767v5}, + note = {Preprint, version 5, 19 October 2022; \href{https://arxiv.org/abs/2002.04767v5}{arXiv:2002.04767v5}} +} + +@article{HeathBrownChevalleyWarning, + author={Heath-Brown, D. R.}, + title={A note on the {Chevalley--Warning} theorems}, + journal={Russian Mathematical Surveys},volume={66},number={2}, + pages={427--436},year={2011}, + note={\href{https://doi.org/10.1070/RM2011v066n02ABEH004744}{doi:10.1070/RM2011v066n02ABEH004744}; + equation numbering in \href{https://arxiv.org/abs/1009.3764v2}{arXiv:1009.3764v2}} +} + +@article{Chaiken1982, + author={Chaiken, Seth}, + title={A combinatorial proof of the all minors matrix tree theorem}, + journal={SIAM Journal on Algebraic and Discrete Methods}, + volume={3},number={3},pages={319--329},year={1982}, + note={\href{https://doi.org/10.1137/0603033}{doi:10.1137/0603033}} +} + +@incollection{Gross1987Heights, + author={Gross, Benedict H.}, + title={Heights and the special values of {$L$}-series}, + booktitle={Number theory (Montreal, Que., 1985)}, + editor={Kisilevsky, H. and Labute, J.}, + series={CMS Conference Proceedings},volume={7}, + publisher={American Mathematical Society},address={Providence, RI}, + year={1987},pages={115--187}, + note={\href{https://wstein.org/papers/bib/Gross-Heights_and_the_Special_Values_of_L-series.pdf}{primary text}} +} +@article{Shimura1973HalfIntegral, + author={Shimura, Goro}, + title={On modular forms of half integral weight}, + journal={Annals of Mathematics},series={2},volume={97},number={3}, + year={1973},pages={440--481}, + note={\href{https://doi.org/10.2307/1970831}{doi:10.2307/1970831}} +} +@article{Ramsey2006HalfIntegral, + author={Ramsey, Nick}, + title={Geometric and {$p$}-adic modular forms of half-integral weight}, + journal={Annales de l'Institut Fourier},volume={56},number={3}, + pages={599--624},year={2006}, + note={\href{https://doi.org/10.5802/aif.2195}{doi:10.5802/aif.2195}} +} + +@misc{OpenAIGoldfeldTwoConverse2026, + author={{OpenAI}}, + title={{Goldfeld's analytic density conjecture and the $2$-converse for elliptic curves}}, + howpublished={OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf}{OAI:Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026}}, + year={2026} +} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/coefficients.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/coefficients.tex new file mode 100644 index 0000000000000000000000000000000000000000..6b491ca3722ff4d91b72a45bc7b75203be4147bc --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/coefficients.tex @@ -0,0 +1,1028 @@ +\section{Coefficient systems and their contraction identities} +\label{co:section} + +We construct Fourier coefficients detecting central values and Heegner +points, then use arithmetic lower bounds to normalize their least nonzero +valuation. The resulting binary tests satisfy the contraction and isolation +identities used in Section~\ref{gr:section}. The even lower bound is already +available from Section~\ref{cy:section}; the odd detector is constructed +without one, and its normalization remains conditional until +Proposition~\ref{pw:odd-lower}. + +Throughout, $S$ contains $2$ and the primes dividing the +conductor $N$. A filter prescribes local unit squareclasses at $S$, together +with the infinite sign, and excludes finitely many further primes. Its +indices are $h=\sigma D$, where $D$ is positive and squarefree. All primes +adjoined subsequently are odd, good, and outside the current support. +Put $F=\mathbb Q(E[2])$. In the present residual range, $F$ is trivial or +quadratic. A prime split in $F$ has weight $1$, and a prime inert in $F$, +called simple, has weight $1/2$. We write $w(D)$ for the sum of these weights. +All valuations satisfy $v(2)=1$. + +We use the theta multiplier cubed for weight $3/2$. Local unit characters +and their associated Dirichlet characters are related by the usual inverse +idele convention. Thus, if a finite Schwartz function satisfies +$f(ux)=\alpha(u)f(x)$, its scalar classical character on the lower-right +entry is the Dirichlet character associated to $\alpha^{-1}$. +This convention removes a possible inverse ambiguity in the formulas below. + +\subsection{Even coefficients and exact comparison of ratios} + +\begin{proposition}[Even coefficient system]\label{co:even} +Fix an even-sign filter and a nonvanishing index $D_0$ in it. +There is a holomorphic cuspidal form $g=\sum_{n\geq1}a(n)q^n$ of weight +$3/2$, orthogonal to unary theta series, of level supported on a fixed +enlargement of $S$, and characters $\eta,\psi$ of $2$-power order such that +$\psi/\eta=\chi_{-\sigma}$ and +\begin{equation}\label{co:recurrence} + a(p^2n)=\bigl(\eta(p)a_p(E)-\psi(p)(-n/p)\bigr)a(n) + -p\eta(p)^2a(n/p^2)\qquad(p\notin S). +\end{equation} +Its coefficients are zero off the unit-squareclass filter. After +normalization at $D_0$, every squarefree coefficient is rational up to a +$2$-power root of unity. For two nonzero squarefree coefficients, +\begin{equation}\label{co:exact-ratio} + 2v\!\left(\frac{a(D)}{a(D_0)}\right) + =v\!\left(\frac{L_*(\sigma D)}{L_*(\sigma D_0)}\right). +\end{equation} +Moreover $a(D)\neq0$ exactly when $L(E^{(\sigma D)},1)\neq0$. +Consequently any previously established bound +$v(L_*(\sigma D))\geq2w(D)+s(\sigma D)-C$ gives +\begin{equation}\label{co:even-bound} + v(a(D))\geq w(D)+\tfrac12s(\sigma D)-C_g +\end{equation} +with $C_g$ fixed independently of $D$. +\end{proposition} + +\begin{proof} +Use the Shimura packet of $E^{(-\sigma)}$. Its positive index $D$ tests +the twist by $\chi_{-D}$, which is $E^{(\sigma D)}$. +The nonvanishing at $D_0$ selects a globally occurring member admitting +that Fourier functional. Take its spherical vector outside $S$ and its +holomorphic vector of weight $3/2$ at infinity. + +Here is the support-local vector selection. Start with a vector on which +the $D_0$ Fourier functional is nonzero. Projection under a sufficiently +large compact group of upper unipotents to additive frequency $D_0$ +restricts the potentially nonzero unit translates to arbitrarily small +neighborhoods of the two solutions of $u^2=1$. Choose a unit character +agreeing with the forced action at $-1$. It can have $2$-power order: +the image of $-1$ is detected in the $2$-primary quotient of the unit +group. The neighborhoods of $1$ and $-1$ then contribute with the same +sign, so this projection preserves the nonzero functional. Upper +integral translations act trivially, and smoothness gives sufficiently +deep lower-unipotent invariance. The vector therefore defines a +classical form at a level supported on $S$, allowing arbitrary depth at +$2$ and at the bad primes. The unit-squareclass and coprimality sieves +commute with good $T(p^2)$, since their conditions are unchanged by +multiplication of the index by $p^2$. The classical Hecke formula +\cite{Shimura1973HalfIntegral} gives +\eqref{co:recurrence}, with $\eta=\psi\chi_{-\sigma}$. + +At the level just chosen, let $V$ be the full space of weight-$3/2$ +cusp forms orthogonal to unary theta series, with scalar character +$\psi$ and good $T(p^2)$ eigenvalues $\eta(p)a_p(E)$. It contains +the constructed form, whose coefficient at $D_0$ is nonzero. For +$D/D_0$ a unit square at every support prime, Waldspurger's comparison +\cite[Corollary~2, pp.~483--484]{Waldspurger1981} gives, for every +$f\in V$, +\[ + a_f(D)^2= + \psi(D/D_0)\frac{L_*(\sigma D)}{L_*(\sigma D_0)}a_f(D_0)^2. +\] +Its hypothesis (H1) follows from the nonzero eigenspace +\cite[\S I.2, Proposition~2]{Waldspurger1981}; the final paragraph of +the comparison proof removes (H2) for these local squareclasses. +Factoring the displayed quadratic identity in the two coefficient +functionals shows that they are proportional on all of $V$, with one +scalar independent of $f$. This includes oldvectors and their linear +combinations; if the central value at $D$ vanishes, the first functional +is simply zero. + +Choose an algebraic form $g$ in the filtered subspace of $V$ with +$a(D_0)\ne0$. To justify this choice, multiplication by ordinary theta +embeds the space into an integral-weight space, and divisibility by +theta is specified by algebraic cusp conditions +\cite[\S\S3--4]{Ramsey2006HalfIntegral}. The character, good-Hecke +and filter conditions are algebraic linear conditions as well. +Since evaluation at $D_0$ is nonzero after extension to $\mathbb C$, +it is nonzero on some algebraic form. + +Let $u$ be an automorphism of $\overline{\mathbb Q}$ acting on the +character values by an odd power $e$, and put $\nu=\eta^{(e-1)/2}$. +The forms $g^u$ and $g\otimes\nu$ have the same scalar character +$\psi^e=\psi\nu^2$ and the same good eigenvalues +$\eta(p)^e a_p(E)=\nu(p)^2\eta(p)a_p(E)$; here $\psi/\eta$ is +quadratic. They belong to one good-Hecke eigenspace at a common level +still supported on $S$. Applying the preceding proportionality in +that nonzero space and normalizing at $D_0$ gives +\[ + u(\xi)=\nu(D/D_0)\xi,\qquad \xi=a(D)/a(D_0). +\] +Local square roots of $D/D_0$ at the conductor of $\eta$ give a value +$z$ of $\eta$ with $\eta(D/D_0)=z^2$. Then $u(z)=z^e$ and +$\nu(D/D_0)=z^{e-1}$, so $\xi/z$ is fixed by every algebraic +automorphism and is rational. Moreover the same local-square condition +gives $\psi(D/D_0)=\eta(D/D_0)=z^2$. The comparison therefore reads +\[ + (\xi/z)^2=\frac{L_*(\sigma D)}{L_*(\sigma D_0)}, +\] +which proves \eqref{co:exact-ratio} since $v(z)=0$. +There is no product over the new prime factors: the unramified +squarefree formula includes both local valuations zero and one. +No exceptional local representation at $2$ is excluded by the +same-local-class comparison. The vanishing assertion and +\eqref{co:even-bound} follow. +\end{proof} + +\subsection{A detecting Kummer functional} + +Fix now the positive odd-sign filter and its original support, including +the auxiliary class-group tests needed for arithmetic realization. +Choose a fixed negative odd +fundamental discriminant $h_*$ with $L(E^{(h_*)},1)\neq0$, whose local +squareclasses agree with those of the filter at $2N$. Adjoin its prime +factors to $S$, exclude them from the variable indices, and refine the +fixed unit tests there as required, all before varying $D$. +Choose it so that $|h_*|>4$ and one of its ramified primes +excludes the CM field of $E$, if there is one. Thus +\[ + K_D=\mathbb Q(\sqrt{Dh_*}) +\] +is imaginary, split at $2N$, and has only the units $\{1,-1\}$. +Fix a modular parametrization $\varphi$ +with $\varphi(\infty)=0$ throughout. With this normalization the +cuspidal constants in its Hecke and Atkin--Lehner relations are torsion; +see \cite{Manin1972,Drinfeld1973}. An arbitrary translation by a +rational point is not permitted. + +Let $H_D$ be the Hilbert class field of $K_D$. Choose an +$\mathcal O_{K_D}$-ideal $\mathfrak n_D$ with +$\mathcal O_{K_D}/\mathfrak n_D\simeq\mathbb Z/N\mathbb Z$, +fixing one orientation at each level prime, and let +$x_D\in X_0(N)(H_D)$ be its conductor-one CM point. The unramified +genus character $\chi_D$ attached to +$K_D(\sqrt{h_*})/K_D$ satisfies +$\chi_D([\mathfrak a])=\chi_{h_*}(\operatorname{Norm}\mathfrak a)$ +on ideals prime to $Dh_*$. Define the unaveraged character sum +\[ + P_D=\sum_{[\mathfrak a]\in\operatorname{Pic}(\mathcal O_{K_D})} + \chi_D([\mathfrak a])\varphi(x_D^{[\mathfrak a]}). +\] +These conductor-one genus sums over the varying fields $K_D$ are +distinct from the conductor-$|h|$ ring-class sums over a fixed field +$K$ defined in Section~\ref{rl:section}. +The point $P_D$ lies in $E(\mathbb Q(\sqrt D,\sqrt{h_*}))$, with the quadratic +interpretation when $D=1$. Its genus-character component over $K_D$ +is the sum of the $D$- and $h_*$-twist components over $\mathbb Q$. +The latter has rank zero because $L(E^{(h_*)},1)\ne0$. +Thus the free part of $P_D$ lies in the $D$-twist component, a line +when $E^{(D)}$ has a simple zero. We retain the unaveraged sum in the +theta comparison; a fixed integer $L$ kills bounded-degree torsion +and makes its comparison with a rational twist point integral. +At a simple zero write $j(P_D)$ for its index valuation in the free +rational twist line, allowing the fixed restriction and projection +indices. Put $j(P_D)=+\infty$ if the product derivative vanishes. + +\begin{lemma}[Kummer detection, including CM]\label{co:kummer} +Let $C$ act on $T=T_2E$ as complex conjugation, and choose a nonzero +integral row $b:T\longrightarrow\mathbb Z_2$ with $bC=b$. +For a fixed positive simple-zero witness $D_w$, there are arbitrarily +large precisions $M$ and good primes $\ell$ such that +\begin{equation}\label{co:ell-conditions} + \rho_T(\operatorname{Fr}_\ell)\equiv C\pmod {2^M},\qquad + (h_*/\ell)=-1,\qquad(D_w/\ell)=1. +\end{equation} +Evaluation at Frobenius squared defines an integral homomorphism +\[ + \lambda_M:E(\mathbb F_{\ell^2})\longrightarrow\mathbb Z/2^M\mathbb Z, + \qquad \lambda_M=b\kappa_M, +\] +of Frobenius sign $+1$. The valuation of +$\lambda_M(\operatorname{red}_\ell(LP_{D_w}))$ is bounded independently +of $M$, for a fixed nonzero integer $L$ making the twist comparison +integral. Extra fixed finite-field restrictions can be retained when they agree +with the chosen complex-conjugation coset, or when a compatible lift +has been specified. +\end{lemma} + +\begin{proof} +For every elliptic curve $A/\mathbb Q$, the rational Tate module $V_2A$ +is irreducible. Indeed Faltings' semisimplicity and endomorphism theorem +\cite[\S1, assertions (a),(b)]{Faltings1983} would turn a proper +summand into a nontrivial idempotent in +$\operatorname{End}_{\mathbb Q}(A)\otimes\mathbb Q_2=\mathbb Q_2$. +The equality of this endomorphism ring with $\mathbb Z$ includes CM +curves: a nonreal CM endomorphism is not defined over $\mathbb Q$. +The Tate image contains a nonidentity central scalar, by the homothety +theorem \cite[\S2, Theorem~3 and paragraph~7]{Bogomolov1981Points}. + +Let $Q\in A(\mathbb Q)$ be nontorsion and let $c_Q$ be its division +cocycle. On the kernel of the Tate action its image is a closed +$\mathbb Z_2$-submodule of $T_2A$, stable under the full Galois image. +If its rational span were zero, the rational Kummer class would factor +through the Tate image. A central scalar $z\neq1$ annihilates its +first cohomology: for a cocycle $c$ the equality of $c(zg)$ and $c(gz)$ +gives $(z-1)c(g)=(g-1)c(z)$, so $c$ is a coboundary over $\mathbb Q_2$. +This contradicts Kummer injectivity and the finite generation of +$A(\mathbb Q)$. Irreducibility consequently makes the translation +image contain $2^aT_2A$ for some $a$. Intersecting with the kernel of +additional finite data retains a full lattice. + +Apply this to the rational twist point supplied by $LP_{D_w}$ on +$A=E^{(D_w)}$. Since $D_w>0$, conjugation acts on its Tate module as +$C$. Modify a conjugation lift by an element of the simultaneous +kernel whose translation is $v$. The square of the modified element +has translation $(1+C)v$, and $b(1+C)v=2b(v)$. The full-lattice +property allows a choice with a fixed finite nonzero valuation. +Conjugation acts trivially on $\mathbb Q(\sqrt{D_w})$ and nontrivially +on $\mathbb Q(\sqrt{h_*})$. Chebotarev in each finite torsion, +division, and character extension gives \eqref{co:ell-conditions} +and the chosen finite nonzero detection. + +For good $\ell$, Lang's theorem and finite-field Kummer theory give +\[ + E(\mathbb F_{\ell^2})/2^M E(\mathbb F_{\ell^2}) + \simeq T/\bigl(2^MT+(\operatorname{Fr}_\ell^2-1)T\bigr)=T/2^MT. +\] +This is evaluation of a cocycle at arithmetic Frobenius squared. +Its equivariance and $bC=b$ prove the sign assertion. Reduction of +the division cocycle gives precisely the detection already arranged. +Finally $\det C=-1$ implies $\ell\equiv-1\pmod {2^M}$. +\end{proof} + +\subsection{The finite Schwartz function and its transformation} + +\begin{lemma}[Explicit weighted theta construction]\label{co:theta-bridge} +For $\ell$ as in Lemma~\ref{co:kummer}, the reduced modular +parametrization followed by $\lambda_M$ admits an integral weighted +ternary theta lift. After extraction of the coefficients at multiples +of $|h_*|$ it gives a classical holomorphic weight-$3/2$ form +$g_M=\sum a_M(n)q^n$, of level supported on $S\cup\{\ell\}$, with +\eqref{co:recurrence} modulo $2^M$. The associated characters have +$2$-power order and quadratic ratio. For squarefree admissible $D$, +\begin{equation}\label{co:weighted-comparison} + a_M(D)=c_0\,2^{\omega(N)}\zeta_M(D) + \lambda_M\bigl(\operatorname{red}_\ell(LP_D)\bigr) + \pmod {2^M}, +\end{equation} +where $\zeta_M(D)$ is a $2$-power root of unity and $c_0,L$ are fixed +integers independent of $D,M,\ell$. The extra index restriction at +$\ell$ is $(D/\ell)=1$. +\end{lemma} + +\begin{proof} +Let $B$ be ramified at $\ell$ and infinity, $R$ an Eichler order of +level $N$, and $V=B^0$ with $Q(x)=-x^2=\operatorname{Nrd}(x)$. +The root characters at the fixed level primes below are chosen once. +Let $\mathcal O$ be the valuation ring at a place above $2$ of the +field generated by their values. The other local weights are +quadratic, so this field is independent of $M$ and $\ell$. +In this construction integrality means membership in $\mathcal O$, +and congruences mean congruences modulo $2^M\mathcal O$. +\par\smallskip\noindent\emph{The supersingular coefficient function.} +The supersingular pairs on $X_0(N)$ are the finite set +\[ + X=B^\times\backslash\widehat B^\times/\widehat R^\times. +\] +This description permits every $N$ prime to $\ell$, including arbitrary +depth at $2$; see \cite[\S\S1.1--1.2,2.4--2.6]{JetchevKane2010}. +For $z\in X$ put $R_z=B\cap z\widehat Rz^{-1}$. +Choose $L$ killing the finite subgroup generated by the images of the +cuspidal constants in the Atkin--Lehner relations, and also all the +bounded-degree torsion used below. Then +\[ + P_M(z)=\lambda_M(L\varphi_\ell(z)), +\] +where $\varphi_\ell$ is the specialization of $\varphi$ to the +good-reduction special fiber. This function has Brandt eigenvalues +$a_p(E)$ away from $N\ell$, Atkin--Lehner +eigenvalue $w_{p^e}$ at $p^e\Vert N$, and eigenvalue $+1$ under the +right $\ell$-uniformizer. These identities are modulo $2^M$. +Choose any integer lifts of this finite list of values. + +\par\smallskip\noindent\emph{The local Schwartz weights.} +We now define the local functions, rather than appealing to an +unspecified weighted theta theorem. Off $2Nh_*\ell$ take the +characteristic function of $R_p^0$. At $p^e\Vert N$, use a model +\[ + R_p=\left\{\begin{pmatrix}a&b\\c&d\end{pmatrix} + :a,b,d\in\mathbb Z_p, c\in p^e\mathbb Z_p\right\}. +\] +Require the split fundamental unit squareclass and an integral +embedding. Its action on the cyclic level quotient selects one root +$r\in\mathbb Z_p^\times$ of $x^2$. Give $x$ weight $\alpha_p(r)$, +where $\alpha_p$ is a finite unit character of $2$-power order with +\begin{equation}\label{co:root-parity} + \alpha_p(-1)=w_{p^e}\chi_{h_*}(p)^e. +\end{equation} +Such a character exists for either prescribed sign. The root is a +locally constant function to any fixed character precision: the two +idempotents of the split integral quadratic algebra distinguish the +two summands of the cyclic quotient. Unit scaling $x\mapsto ux$ +multiplies this weight by $\alpha_p(u)$, and order-unit conjugation +preserves it. + +At $2$ require $(1+x)/2\in R_2$ and $x^2\in\mathbb Z_2^{\times2}$. +If $2\mid N$, the preceding selected-root rule is imposed using +$e_x=(1+x)/2$. Its two eigenvalues $(1+r)/2,(1-r)/2$ differ by the +odd unit $r$; hence the two idempotents remain distinct modulo $2$. +This verifies the construction at every exponent of $2$ in $N$. +Scaling by an odd $u$ preserves integrality, since +$(1+ux)/2=u(1+x)/2+(1-u)/2$. This is an invertible affine change of +the operator $e_x$, so it preserves its two summands individually. +The selected summand is selected by the cyclic level quotient, not +by declaring its eigenvalue to be $0$ or $1$ modulo $2$. On that same +summand $x$ acts as $r$ and $ux$ acts as $ur$. Even when +$u\equiv-1\pmod4$ interchanges the two eigenvalue parities, the root +weight therefore changes by exactly $\alpha_2(u)$. +If $2\nmid N$ there is no root weight at $2$. + +For $p\mid h_*$ require $x\in M_2(\mathbb Z_p)^0$ and +$v_p(Q(x))=1$. Its reduction is a nonzero nilpotent. Fix +$X_0=\left(\begin{smallmatrix}0&1\\0&0\end{smallmatrix}\right)$ and +define +\[ + \epsilon_p(gX_0g^{-1})=\left(\frac{\det g}{p}\right). +\] +The centralizer consists of +$\left(\begin{smallmatrix}a&b\\0&a\end{smallmatrix}\right)$, with +determinant $a^2$, so this is well-defined on the entire nonzero +nilpotent orbit. It obeys +\[ + \epsilon_p(uyu^{-1})=(\det u/p)\epsilon_p(y),\qquad + \epsilon_p(ay)=(a/p)\epsilon_p(y). +\] +The second equality follows by conjugating $X_0$ by +$\operatorname{diag}(a,1)$. Set $f_p(x)=\epsilon_p(\bar x)$ on the +specified support. Thus the right conjugation character is precisely +the local component of $\chi_{h_*}\circ\operatorname{Nrd}$. + +At $\ell$, let $\mathfrak P$ be the maximal ideal of the maximal +order. Its residue field is $\mathbb F_{\ell^2}$, and the reduction of +an integral trace-zero element lies on its one-dimensional trace-zero +line. Fix a nonzero basis vector $\beta$ on that line and put +\[ + f_\ell(x)=\left(\frac{t}{\ell}\right) + \quad\text{if }\bar x=t\beta\neq0, + \qquad f_\ell(x)=0\quad\text{otherwise}. +\] +Order units act trivially by conjugation on the residue field. +A uniformizer acts by its nontrivial automorphism and sends +$\beta$ to $-\beta$. Therefore its multiplier is $-1$, since +$\ell\equiv-1\pmod4$; scaling has character $(u/\ell)$. +Moreover $\beta^2$ is a nonsquare and $-1$ is a nonsquare modulo +$\ell$, so $Q(x)=-t^2\beta^2$ is a nonzero square. Because +$(|h_*|/\ell)=1$, the extracted indices automatically satisfy +$(D/\ell)=1$. No average over $\mathbb F_\ell^\times$ is used. + +All these functions have compact support and are locally constant. +Let $f=\prod f_p$, incorporating any additional fixed unit-squareclass +conditions by their characteristic functions. Those conditions are +stable under unit squares and change none of the scaling characters. +For $u\in\widehat R^\times$, +\begin{equation}\label{co:order-equivariance} + f(u^{-1}xu)=\chi_{h_*}(\operatorname{Nrd}u)^{-1}f(x). +\end{equation} +The product scaling character is even. Indeed its value at $-1$ is +\[ + \left(\prod_{p^e\Vert N}w_{p^e}\chi_{h_*}(p)^e\right) + \chi_{h_*}(-1)(-1)=1; +\] +the parenthesized factor is the even functional sign of $E^{(h_*)}$. +Denote its associated classical character by $\eta_B$. In the +inverse-idele convention fixed above, if $\alpha$ is this finite +scaling character, then $\eta_B(d)=\alpha(d)$ for positive integers +$d$ prime to the support: the inverse idele character becomes the +product of the finite unit values at the lower-right entry. + +\par\smallskip\noindent\emph{The scalar transformation law.} +Here are all the Weil-representation checks needed for scalar +modularity. For an additive character of conductor $\mathbb Z_p$, +write $n(b)=\left(\begin{smallmatrix}1&b\\0&1\end{smallmatrix}\right)$, +$m(u)=\operatorname{diag}(u,u^{-1})$, and +$n^-(c)=\left(\begin{smallmatrix}1&0\\c&1\end{smallmatrix}\right)$. +Use a Weyl lift $w$, its compatible self-dual Fourier transform, and +the Weil factors $\gamma_p(u),\gamma_p$ for this additive character. +The defining formulas are +\[ + \omega(n(b))f_p(x)=\mathbf e_p(bQ(x))f_p(x),\quad + \omega(m(u))f_p(x)=\gamma_p(u)|u|_p^{3/2}f_p(ux),\quad + \omega(w)f_p=\gamma_p\widehat f_p. +\] +They follow from the Weil construction and Poisson summation +\cite[I, no.~13]{Weil1964}. Integral $b$ fixes $f_p$, since $Q$ is integral on +its support. If $f_p$ is invariant under translations by a lattice +$L_p'$, its Fourier transform is supported on the dual lattice +$(L_p')^\vee$. Choose $A_p$ so that +$p^{A_p}Q((L_p')^\vee)\subset\mathbb Z_p$. Then $n(p^{A_p}b)$ fixes +$\widehat f_p$, and conjugating by $w$ proves that every +$n^-(p^{A_p}b)$ fixes $f_p$. This argument works without change at +$2$ and for all finite character depths. + +Relative to the ordinary theta multiplier cubed, the diagonal Weil +factor is $(\det Q,u)_p$. Indeed diagonalizing $Q$ and multiplying +the one-dimensional Weil-index identities +\cite[II, nos.~25, 28]{Weil1964} gives the Hilbert symbol +of the product of its three coefficients. In a presentation +$B=(-a,-b)$ that product is the determinant of +$aX^2+bY^2+abZ^2$, namely $(ab)^2$. Thus this additional factor is +$1$. The remaining diagonal action is exactly the scaling character +already computed. Increasing $A_2$ to the depth needed for the +standard metaplectic splitting, the factorization +\[ + \begin{pmatrix}a&b\\c&d\end{pmatrix} + =n^-(c/a)m(a)n(b/a),\qquad c\in p^{A_p}\mathbb Z_p, a\in\mathbb Z_p^\times, +\] +proves scalar transformation on the required local $\Gamma_0$. +Conjugation by $z$ commutes with these Weil actions and preserves $Q$. +Consequently the same level and scalar character work for every +summand. The Gaussian at infinity gives holomorphic weight $3/2$; +positive definiteness gives nonnegative exponents at every cusp. + +Choose an integer $c_0$ divisible by every possible $|R_z^\times|$. +Such a uniform choice exists because these unit groups embed in +$\operatorname{GL}_4(\mathbb Z)$ and their orders are bounded. +The theta series is +\begin{equation}\label{co:theta-sum} + H_M(n)=c_0\sum_{z\in X} + \frac{P_M(z)\chi_{h_*}(\operatorname{Nrd}z)}{|R_z^\times|} + \sum_{\substack{x\in B^0\\Q(x)=n}} f(z^{-1}xz). +\end{equation} +Equation~\eqref{co:order-equivariance} proves independence of right +representatives; rational reduced norms are positive, so the norm +character is trivial on the left rational action. The preceding Weil +calculation proves modularity \cite[III, Theorem~6]{Weil1964}, and +the choice of $c_0$ proves integral Fourier coefficients. More +precisely, each $c_0/|R_z^\times|$ is an integer, so changing a lift +of $P_M(z)$ by $2^M$ changes every coefficient by an element of +$2^M\mathcal O$. No precision is lost to a stabilizer denominator. +The chosen integer lifts need satisfy no characteristic-zero +eigenrelation. + +\par\smallskip\noindent\emph{The good-prime Hecke relation.} +For completeness, the good-prime relation can be checked in a matrix +order. Neighbors correspond to the lines in $\mathbb F_p^2$. +A nonzero primitive nilpotent reduction has exactly one invariant +line. For an integral element of nonzero reduction and norm $n$, +the number of invariant lines is $1+(-n/p)$; zero reduction contributes +the additional $p$ lines. If a primitive $y$ has $p^2\mid Q(y)$, +choose a basis in which its reduction is $X_0$. Its lower-left entry +is divisible by $p^2$, and exactly the neighbor for that invariant +line makes $y/p$ integral. These counts partition the three terms +of the theta Hecke operator. Scaling by $p$ at the support contributes +$\eta_B(p)$, and the reduced norm of a Brandt neighbor contributes +$\chi_{h_*}(p)$. Thus, with $A(n)=H_M(n)$, +\[ + A(p^2n)+\eta_B(p)(-n/p)A(n)+p\eta_B(p)^2A(n/p^2) + =\eta_B(p)\chi_{h_*}(p)a_p(E)A(n)\pmod {2^M}. +\] +The orbit-stabilizer weights in \eqref{co:theta-sum} are exactly the +weights in this neighbor count. Extracting +$a_M(n)=H_M(|h_*|n)$ gives +$\eta=\eta_B\chi_{h_*}$ and +$\psi=\eta_B(|h_*|/\cdot)$, proving \eqref{co:recurrence}. +Fixed-support coefficient sieves are exact zero-or-retain operations; +they preserve coefficient integrality and commute with this relation. + +\par\smallskip\noindent\emph{The weighted coefficient comparison.} +It remains to prove the weighted comparison; modularity alone does +not supply it. At $n=|h_*|D$ the counted elements are precisely the +optimal embeddings $\mathcal O_{K_D}\hookrightarrow R_z$, sending +$\sqrt{Dh_*}$ to $x$. The condition at $2$ is exactly the condition +on the integral generator $(1+\sqrt{Dh_*})/2$. +At a level prime there are two orientations. Indeed a stable lattice +splits into its two integral idempotent summands, and a cyclic quotient +of order $p^e$ lies wholly in one summand. At $\ell$ there are two +orientations, the two residue-field embeddings. At all remaining +primes there is a single local optimal-embedding orbit. + +Fix a rational embedding $x_0$ and an initial orientation tuple $z_0$. +The orbits with these orientations are indexed by +$\operatorname{Pic}(\mathcal O_{K_D})$, with representatives $az_0$ +for $a\in\widehat K_D^\times$. The equality +\[ + (az_0)^{-1}x_0(az_0)=z_0^{-1}x_0z_0 +\] +shows that the Schwartz weight is constant along that orbit. Its +remaining relative weight is +$\chi_{h_*}(\operatorname{Norm}_{K_D/\mathbb Q}a)$, exactly the +unramified genus character. The reduction correspondence commutes +with this ideal-class action and remembers the cyclic level subgroup +\cite[\S2]{JetchevKane2010}; a Galois-equivariant description of the +lift, class action and reduction is given in +\cite[\S3.2, \S\S4.6, 4.9--4.10 and Corollary~4.1]{CornutJetchev2013}. +We use these correspondences only for their geometry; the weight +identity has just been computed, and the multiplicity is computed next. + +An embedding stabilizer is $\mathcal O_{K_D}^\times=\{\pm1\}$. +An orbit in $R_z$ therefore contains $|R_z^\times|/2$ elements, giving +the factor $1/2$ in \eqref{co:theta-sum}. At $p^e\Vert N$, reversing +orientation multiplies its Schwartz factor by +$\alpha_p(-1)=w_{p^e}\chi_{h_*}(p)^e$, and its norm-weighted +parametrization value by the same sign. At $\ell$ both multipliers +are $-1$: one is the residue-line calculation and the other is +$\chi_{h_*}(\ell)$ times the Frobenius eigenvalue $+1$. +Every one of the $2^{\omega(N)+1}$ orientation tuples consequently +has the same contribution. The initial tuple has a $2$-power unit +phase. Combining this count with its factor $1/2$ gives exactly +\eqref{co:weighted-comparison}. There is no division by a class +number, and none of its rational multipliers grows with $\ell$ or +the number of factors of $D$. +\end{proof} + +\begin{proposition}[Odd coefficient detection]\label{co:odd} +The forms in Lemma~\ref{co:theta-bridge}, after a fixed adjustment of +precision, satisfy +\[ + v(a_M(D))\geq\min\{M,j(P_D)-C\},\qquad + v(a_M(D))\delta+w(D)\text{ or }D\text{ is off the filter}, + \end{cases} +\end{equation} +with a fixed minimum normalized depth $\delta$ and at least one +bounded-weight witness. For the odd source $a=a_M$ at an actual stage: +the numerical minimum and its divisibility statements stabilize at +every fixed finite weight bound. The finite symbol tables on arithmetic +labels will be stabilized separately in Section~\ref{pw:odd-stages}. +At a unit symbol, +\[ + v(L_*(\sigma D))\leq2w(D)+O(1) + \quad\text{or}\quad j(P_D)\leq w(D)+O(1), +\] +respectively, and the analytic order is respectively zero or one. +\end{lemma} + +\begin{proof} +For the even source normalize $a(D_0)=1$; the phase-removed squarefree +coefficients are rational by Proposition~\ref{co:even}. For the odd +source, \eqref{co:weighted-comparison} makes every visible squarefree +coefficient an integer times a root of unity modulo $2^M$. +Their finite valuations are therefore integers in both cases, not +arbitrary elements of a ramified coefficient field's value group. +The fractional part of $w(D)$ is fixed on the filter, +because the parity of the number of simple primes is its fixed +quadratic discriminant character. The lower bounds and a nonzero +witness therefore give a minimum for the even source. + +For the odd source choose a nonprincipal ultrafilter on the increasing +precisions. Minimize $v(a_M(D_M))-w(D_M)$ over sequences with bounded +weight and visible coefficient on an ultrafilter-large set. The +uniform lower bound, discrete values, and fixed witness give a finite +attained minimum. At each fixed weight cutoff $W$, failure of its +divisibility on an ultrafilter-large set would allow a choice of a +violating $D_M$ with $w(D_M)\leq W$, contrary to the minimum. +Hence every prescribed finite list of these divisibilities holds at +a sufficiently advanced actual stage. If larger weights arise in a +coefficient-integrality check, the coarse bound +$\min\{M,w(D)-C\}$ already pays any fixed normalization once both +$M$ and $w(D)$ exceed its fixed threshold. This also explains why +no infinite-precision modular lift is asserted or needed. +The last conclusions follow from the two coefficient comparisons. +\end{proof} + +Write $U_p\sum c(n)q^n=\sum c(pn)q^n$ and +$V_p\sum c(n)q^n=\sum c(n)q^{pn}$. For a squarefree set $U$ put +\begin{equation}\label{co:BU} + B_U=2^{-\lceil\delta+w(U)\rceil} + \prod_{p\in U}(U_p-\eta(p)V_p)g,\qquad + e_U=\lceil\delta+w(U)\rceil-\delta-w(U). +\end{equation} +We call $U$ matching if $e_U=0$ and opposite if $e_U=1/2$. +These operators introduce each new prime to level exponent one: +$V_p$ changes the character by $(p/\cdot)$ and raises the level by +$p$, while $U_p=U_{p^2}V_p$ on that raised level. +Thus the new character is $\psi_U=\psi\prod_{p\in U}(p/\cdot)$. + +\begin{lemma}[Coefficient bounds and unary removal]\label{co:operators} +For the even source let $U$ be arbitrary. For the odd source, fix +an integer $R\ge1$ and a weight bound $W$; all assertions below are +made at a sufficiently advanced actual stage, simultaneously for every +$U$ with $w(U)\le W$ and every Fourier index. +In these respective settings the coefficients of $B_U$ are integral. +Write uniquely +$n=Jrm^2$, with $J\subseteq U$, $r$ squarefree, and $(r,U)=1$. +The coefficient vanishes unless $D=(U/J)r$ belongs to the filter, +and for the even source otherwise +\begin{equation}\label{co:BU-bound} + v(B_U[n])\geq w(r)+\tfrac12\#\{p\in J:p\text{ simple}\}-e_U. +\end{equation} +At that stage the odd source satisfies this inequality for every +$U$ with $w(U)\le W$ and every $n$, with its right side replaced +by its minimum with $R$. +In particular the untruncated bound holds on any prescribed bounded +range of squarefree weights, after choosing $R$ and the stage. +For a split $p\in J$ the difference factor, after its unit phase and +one factor of $2$ are removed, has residue +\begin{equation}\label{co:cp} + c_p(D)=\frac{a_p(E)-(\psi/\eta)(p)(-D/p)-1}{2}\pmod2 +\end{equation} +at every square shell. For a simple $p$ this formula holds on the +first shell $p\nmid m$. + +Choose $i\in\{0,1\}$ such that $\eta\chi_{-4}^i$ is odd, and set +\[ + \Theta_J=\sum_{\substack{m>0\\(m,S)=1}} + \eta(m)\chi_{-4}(m)^i m q^{Jm^2}. +\] +For matching $U$ the modular form +\begin{equation}\label{co:HU} + H_U=\frac12\left(B_U- + \sum_{\substack{J\subseteq U\\J\text{ split only}}} + B_U[J]\Theta_J\right) +\end{equation} +has integral coefficients, with the same stage and weight restriction +in the odd case. For opposite $U$ put $H_U=B_U$. +The new primes in the level of $\Theta_J$ have exponent one, and its +character is $\eta\chi_{-4}^i(-J/\cdot)$. +\end{lemma} + +\begin{proof} +After removing the powers of $\eta(p)$, the square-index multipliers +in \eqref{co:recurrence} are +\[ + b_0=1,\quad b_1=a_p-\kappa,\quad + b_{s+1}=a_pb_s-pb_{s-1},\qquad + \kappa=(\psi/\eta)(p)(-D/p). +\] +If $p\mid D$, then $\kappa=0$ and $b_s$ alternates between $1$ and +$0$ modulo $2$, because $a_p$ is even. Thus the difference from +$p\in U/J$ is odd. If $p\nmid D$, all $b_s$ are odd and the +difference from $p\in J$ is even. Subtracting the normalization in +\eqref{co:BU} gives exactly +\[ + \delta+w((U/J)r)+\#J-\lceil\delta+w(U)\rceil + =w(r)+\tfrac12\#\{p\in J:p\text{ simple}\}-e_U. +\] +This is an integer on the allowed filter. Its only potential +negative value before imposing parity is $-1/2$, so it is nonnegative. + +For the odd source this calculation first applies on a fixed bounded +range of squarefree weights, with enough precision to pay the fixed +normalizing power of $2$. To obtain the global truncated assertion, +fix $R$ and a bound $W$ for $w(U)$. The normalizing exponents +$\lceil\delta+w(U)\rceil$ are uniformly bounded. Above a sufficiently large weight +threshold, the coarse bound $\min\{M,w(D)-C\}$ from +Lemma~\ref{co:minimum} pays that normalizing power and at least $R$ +further factors of $2$, once $M$ is large enough. Below the threshold +use the stabilized minimum and increase the precision again if needed. +The recurrence has integral multipliers, so errors modulo $2^M$ +remain divisible by $2^M$ at every square shell before normalization. +Thus at the chosen stage the truncated bound holds at every +coefficient for every $U$ with $w(U)\le W$, giving integrality +without asserting an unbounded valuation estimate for a fixed +finite-precision lift. + +For split $p$, rationality of $E[2]$ over $\mathbb F_p$ gives +$a_p\equiv p+1\pmod4$. With $\Delta_s=b_{s+1}-b_s$, every +$\Delta_s$ is even and +$\Delta_{s+1}=a_p\Delta_s-p\Delta_{s-1}$, so +$\Delta_{s+1}\equiv\Delta_{s-1}\pmod4$. +Direct calculation gives +\[ + \Delta_1-\Delta_0 + =a_p^2-a_p\kappa-2a_p+2\kappa+1-p\equiv0\pmod4. +\] +Consequently every $\Delta_s/2$ has the residue in \eqref{co:cp}. +At a simple prime only $\Delta_0$ is used. + +In matching parity the right side of \eqref{co:BU-bound} can vanish +only when $r=1$ and $J$ is split only. The same recurrence, retaining +the character phases, gives +$B_U[Jm^2]\equiv B_U[J]\eta(m)\pmod {2}$. +The corresponding coefficient of $\Theta_J$ has exactly that +residue, and different squarefree $J$ have disjoint supports. +The numerator in \eqref{co:HU} is therefore divisible by the integer +$2$, not just by the maximal ideal of a ramified character field. +The ordinary odd-character unary theta transformation and dilation +by $J$ give the asserted character and level. For the odd source +these calculations use the same sufficiently advanced stage, +uniformly for $w(U)\le W$, with precision paying the fixed +divisions as in Lemma~\ref{co:minimum}. +\end{proof} + +\subsection{Trace operators and omission of a whole rational prime} + +The next step turns changing a Frobenius label into a difference of +coefficient tests. Fix a coefficient valuation ring $\mathcal O$, +enlarging its field if needed for the finite eigensystem span below, +and write $\mathfrak m$ for its maximal ideal. Divisibility by $2^a$ +means divisibility in $2^a\mathcal O$; reduced traces and expansions +mean coefficientwise reduction of Fourier expansions modulo $\mathfrak m$. +These are different operations; no saturation of the integral module +below is assumed. +The normalized squarefree tests are binary because their phase-removed +values are rational $2$-adic integers (integer congruences at an odd +stage), and every $2$-power root of unity reduces to $1$. + +Multiply the form under consideration by +$\theta=1+2\sum_{m>0}q^{m^2}$. This gives a weight-two form with the +same reduced expansion. Work in the finite-dimensional sum of its +characteristic-zero good Hecke eigensystems, retaining old +multiplicity spaces and its diamond transforms. The associated +two-dimensional representations are the usual modular Galois +representations for cusp forms \cite{Deligne1969}, and the sums of +the two defining characters for Eisenstein series. Their commuting +trace and determinant operators are denoted by $t(u),d(u)$. +Arithmetic Frobenius at a good prime $q$ has trace $T_q$ and +determinant $q\langle q\rangle$. +Let $\mathcal M$ be the $\mathcal O$-module generated by this +weight-two vector and the undivided terms $\theta B_U[J]\Theta_J$, +together with all their good-Hecke and diamond translates. + +\begin{lemma}[Integral traces]\label{co:traces} +The module $\mathcal M$ is an integral Fourier lattice preserved by +the trace and determinant operators. On the coefficientwise reduced +trace orbit of the indicated vector, +\begin{equation}\label{co:trace-identities} + d(u)t(v)=t(v),\qquad + t(u)t(v)=t(uv)+t(uv^{-1}),\qquad t(1)=0. +\end{equation} +Every coefficient test of a finite product of traces can be performed +using distinct fresh primes avoiding the tested index. In particular +testing $t(u_1)\cdots t(u_a)$ at $n$ becomes testing the original +reduced coefficient at $nq_1\cdots q_a$. +\end{lemma} + +\begin{proof} +We first check integrality of the generators. Diamonds act by scalars +on $B_U$ and on each unary term. For \eqref{co:HU}, the only apparent +denominator is removed by +\[ + \langle u\rangle H_U=\psi_U(u)H_U+ + \frac12\sum_J B_U[J] + \bigl(\psi_U(u)-\eta(u)\chi_{-4}(u)^i(-J/u)\bigr)\Theta_J; +\] +the difference of the two characters is zero or twice a unit. +The same formula applies after multiplication by theta. +Good Hecke operators commute with diamonds, and their coefficient +formula preserves integrality. Thus all generators of $\mathcal M$ +are integral. Finitely many Fourier coefficients inject the ambient +finite-dimensional space into a finite-dimensional coefficient space, +so $\mathcal M$ embeds in $\mathcal O^r$ for some finite $r$. +It is consequently a finite, closed $\mathcal O$-module. +Continuity and simultaneous Chebotarev approximation on the finitely +many eigensystems approximate $t(u)$ and $d(u)$ by $T_q$ and +$q\langle q\rangle$ at every prescribed precision. These operators +preserve $\mathcal M$, so their limits do as well. They act by scalars +on each good eigensystem and by the identity on its old multiplicity +space, which retains the asserted commutation with level operators. + +The formula +$(T_qf)[n]=f[qn]+q(\langle q\rangle f)[n/q]$ has no second term +when $q\nmid n$. Successive distinct fresh primes therefore give +the coefficient assertion. On a single character system, +determinants reduce to $1$ because all characters have $2$-power +order and the cyclotomic character is odd. On a subtracted vector +the displayed diamond formula leaves unary corrections. A fresh +trace kills each correction modulo the maximal ideal: the tested +index $nq$ cannot have its prescribed squarefree part $J$ when +$q\nmid nJ$. This continues to hold after further fresh tests. +Thus $d(u)t(v)=t(v)$ on the reduced trace orbit. Apply the matrix +identity +\[ + \operatorname{tr}(A)\operatorname{tr}(B) + =\operatorname{tr}(AB)+\det(B)\operatorname{tr}(AB^{-1}) +\] +to each characteristic-zero system and use that determinant +identity. Finally $t(1)=2$ before reduction. +\end{proof} + +\begin{lemma}[The level-prime inertia identity]\label{co:inertia} +For $p\in U$, choose inertia $\tau_p$ on which the new ramified +quadratic character is $-1$, and an arithmetic Frobenius lift $\phi_p$ +in the same decomposition group. In characteristic zero, +\begin{equation}\label{co:inertia-identity} + U_p^{(2)}\bigl(t(g\tau_p\phi_p)-t(g\phi_p)\bigr) + =d(\phi_p)\bigl(t(g\tau_p)-t(g)\bigr). +\end{equation} +Here $U_p^{(2)}$ extracts $p$-multiples in weight two. The identity +commutes with further good traces. +\end{lemma} + +\begin{proof} +A constituent old from a level omitting $p$ has trivial inertia, so +both differences are zero, whatever $U_p^{(2)}$ does on its old +multiplicity space. Every other constituent has conductor exponent +one and primitive ramified quadratic determinant. The conductor +formula excludes monodromy and identifies it as principal series +with one unramified and one ramified character. Local compatibility +\cite[Theorem~(A)]{Carayol1986}, after converting its geometric +Frobenius convention to the arithmetic convention fixed above, +identifies its $U_p^{(2)}$ eigenvalue +with the Frobenius eigenvalue $\lambda$ on the unramified line. +Write +\[ + \rho(\tau_p)=\begin{pmatrix}1&0\\0&-1\end{pmatrix},\qquad + \rho(\phi_p)=\begin{pmatrix}\lambda&0\\0&\mu\end{pmatrix}. +\] +If $z$ is the lower-right entry of $\rho(g)$, the two trace +differences are $-2z\mu$ and $-2z$. Both sides of +\eqref{co:inertia-identity} equal $-2z\lambda\mu$. +The Eisenstein character pair has the same calculation. +A unary term is old if $p\notin J$, and has precisely this ramified +quadratic character if $p\in J$. This exhausts the constituents. +\end{proof} + +For the interface below a \emph{label} is the restriction of a +Frobenius element to an elementary $2$-extension unramified outside +the indicated support. Its coordinates are quadratic characters. +When $F$ is quadratic, choosing one of the two places at a split prime specifies an +orientation; changing its ramification bit means multiplying by the +image of inertia at that place. Product labels are the restrictions +of products of Frobenius elements, so their quadratic coordinates add. +Simple primes use rational quadratic labels. Section~\ref{gr:section} +will realize these labels simultaneously by primes and interpret the +independent inertia changes as graph edges. + +\begin{proposition}[Symbol interface]\label{co:symbol-interface} +Under the arithmetic lower bounds in Lemma~\ref{co:minimum}, the +symbols of either coefficient source have the following properties. +\begin{enumerate} +\item For matching $U$, the trace on split elements factors through +the maximal elementary $2$-extension of $F$ unramified outside +$S\cup U$. For opposite $U$, traces factor through the corresponding +rational elementary extension. Adding a split vertex $q$ is read +by coefficient $1$ of $t(\operatorname{Fr}_q)H_U$; adding a simple +vertex is read on the opposite $B_U$. +\item Let $p\in U$ and $g=\operatorname{Fr}_q$. Changing one +oriented ramification bit at $p$ changes the symbol by +\begin{equation}\label{co:contraction} + A\bigl((U\setminus\{p\})\cup\{q'\}\bigr),\qquad + \operatorname{Fr}_{q'}\sim g\phi_p, +\end{equation} +unless $p,q$ are both simple, in which case the change is zero. +The replacement has the product labels at all retained places. +Its coefficient system has support $S\cup(U\setminus\{p\})$: +the entire rational prime $p$, including both places above it when +it splits in $F$, is omitted. +\item A split vertex with trivial label in the elementary extension +for the other vertices has zero symbol. +\item In matching parity, insertion of two simple primes with equal +rational labels on the fixed support and at the existing split +vertices preserves the symbol if +$\#E(\mathbb F_q)/2$ is odd for that label. Their mutual simple +bits and their incidences with other simple vertices do not affect +this statement. +\end{enumerate} +These are coefficient identities. Simultaneous realization of +their labels by primes is a separate arithmetic construction. +\end{proposition} + +\begin{proof} +For an odd source choose the stage in Lemma~\ref{co:operators} with +cutoff $R\ge2$; only these fixed divisibilities and finitely many +bounded-weight coefficient tests are needed below. +Two fresh traces in matching parity, at least one split, add weight +at least $3/2$. The allowed valuation in \eqref{co:BU-bound} is an +integer, so it is at least $2$ before the unary division and the +result vanishes after it. In opposite parity any two fresh traces +add weight at least $1$; subtracting $e_U=1/2$ and using integral +valuation again gives vanishing. The estimates persist under +further tests. Hence respectively +$t(g)t(u)=0$ for split $u$, or $t(g)t(u)=0$ for every $u$. +Applying \eqref{co:trace-identities} to $t(gu)t(u)$ gives +$t(gu^2)=t(g)$. The quotient by the subgroup generated by squares +is elementary abelian, and the Galois systems are unramified off +their level. This proves the stated factorization. At coefficient +$q$ the fresh split weight $1$ pays exactly the division in $H_U$; +the fresh simple weight $1/2$ pays exactly $e_U$ in opposite parity. +No unary term survives. This proves the symbol-reading assertion. + +For contraction, apply \eqref{co:inertia-identity} at coefficient +$1$, so that its left side is a coefficient-$p$ test. Replace its +trace arguments by fresh primes. The first-shell calculation in +Lemma~\ref{co:operators} gives, in each of the split--split, +split--simple, and simple--split cases, +\[ + c_p(D')A(D'),\qquad D'=(U/p)q',\quad + \operatorname{Fr}_{q'}\sim g\phi_p. +\] +Here the omitted source is exactly $B_V$ or $H_V$, with +$V=U\setminus\{p\}$, constructed from the same original modular form +and the same $\eta,\psi,\delta$; +no new minimum or normalization is chosen. To check the integer +powers explicitly, put $n_U=\lceil\delta+w(U)\rceil$ and let +$m_U$ be $1$ in matching parity and $0$ otherwise. After fresh +tests kill the unary terms, the first shell relative to the +omitted-source test has multiplier +\[ + 2^{1+n_V-n_U-m_U+m_V}c_p(D'). +\] +For split $p$ the exponent is zero. For simple $p$ and matching +$U$ it is also zero. For simple $p$ and opposite $U$ it is one; +this is precisely the simple--simple case. The character change +$\psi_U/\psi_V=(p/\cdot)$ is already the Legendre factor in this +shell calculation. The phase is a unit and disappears on reduction. +Let $q_0',q_1'$ realize $g\phi_p,g\tau_p\phi_p$, respectively, +and put $D_i'=Vq_i'$. Applying inertia changes the Legendre term +in \eqref{co:cp} by a sign, so $c_p(D_1')=c_p(D_0')+1$. +Although these Frobenius elements may first be specified in the full +current elementary extension, their restrictions to the omitted-source +extension agree: inertia +at either place above $p$ is killed in that extension. Its original +characters are unramified at $p$, and its only new character factors +come from $V$. Thus it is unramified at the whole rational prime +$p$, giving $A(D_1')=A(D_0')$. If $\Delta_{\tau_p}A(Uq)$ denotes +the difference of the original tests with Frobenius labels $g\tau_p$ +and $g$, the reduced local identity is now explicitly +\[ + \Delta_{\tau_p}A(Uq) + =c_p(D_1')A(D_1')+c_p(D_0')A(D_0')=A(D_0'), +\] +which is \eqref{co:contraction}. When both vertices are simple the product +Frobenius is split and the first-shell valuation has a positive +excess; its reduction is zero. The entire-prime assertion follows +from the actual support of the omitted-$p$ coefficient form, rather +than from any convention about a chosen orientation. Isolation +is the same symbol-reading test with $t(1)=0$. + +For the final assertion first use two copies of a single simple +Frobenius trace on matching $H_U$. Put +$b=B_U[1]$, $\epsilon=\chi_{-4}(q)$, and +$\kappa=(\psi_U/\eta)(q)$. Substitution of +\eqref{co:recurrence} and of the unary character gives the two terms +in the coefficient-$1$ test of $T_q^2$, modulo $\mathfrak m$: +\begin{align*} + H_U[q^2]&=\frac{b\eta(q)}2 + (a_q-\kappa\epsilon-q\epsilon^i),\\ + q(\langle q\rangle H_U)[1]&=\frac{b\eta(q)}2 + q(\kappa-\epsilon^{i+1}). +\end{align*} +Their sum is +\[ + \frac{b\eta(q)}2 + \left(a_q+\kappa(q-\epsilon) + -q\epsilon^i(1+\epsilon)\right). +\] +For $q\equiv3\pmod4$ the parenthesized half has residue $a_q/2$; +for $q\equiv1\pmod4$ it has residue $a_q/2+1$. +In both cases it is $\#E(\mathbb F_q)/2$ modulo $2$. +Since $b$ reduces to $A(U)$, the squared trace has the required +coefficient. Fresh-prime testing replaces its two copies by +distinct primes. To pass to any pair with the specified labels, +vary one prime at a time. After that simple prime is omitted the +opposite-parity symbol depends only on rational elementary labels; +simple--simple changes vanish by the proved contraction rule. +Thus only the stated support and split-vertex labels matter. +\end{proof} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/cyclotomic.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/cyclotomic.tex new file mode 100644 index 0000000000000000000000000000000000000000..6316d4c0aeac420a87087cf7a3ebe28a782d9d90 --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/cyclotomic.tex @@ -0,0 +1,788 @@ +\section{Cyclotomic interpolation for extensions of trivial residual modules} +\label{cy:section} + +Throughout this section, $E/\mathbb Q$ is fixed, its conductor is $N$, and +$E[2]$ is an extension of two trivial $\mathbb F _2$-modules. Write +$T=T_2E$ and $V=T\otimes_{\mathbb Z _2}\mathbb Q _2$. The word +``ordinary'' applied to global cohomology below means that the real-place +modification has not been made. It imposes no ordinary-reduction hypothesis +at~$2$. + +The discriminants considered here are products of distinct signed primes +$q^*=(-1/q)q$, with $q\nmid 2N$. Fix their sign and local squareclasses at +$2N$. For such a discriminant $h$, put +\[ + t_q=\dim_{\mathbb F _2}E[2]^{\operatorname{Fr}_q},\qquad + 2w(h)=\sum_{q\mid h}t_q,\qquad + \mathcal L(h)=\frac{\sqrt{|h|}\,L(E^{(h)},1)}{\Omega_E^{\operatorname{sgn}(h)}}. +\] +Here fixed nonzero periods in the two period lines have been chosen once. +Changing these choices changes the bounds below by a constant depending +only on~$E$. Valuations of algebraic central values mean their $2$-adic +valuations, with $v_2(2)=1$. When $s_2(E^{(h)})=0$, the group +$\operatorname{Sha}(E^{(h)}/\mathbb Q)[2^\infty]$ is finite; set +\[ + s(h)=\operatorname{length}_{\mathbb Z _2} + \operatorname{Sha}(E^{(h)}/\mathbb Q)[2^\infty],\qquad + D(h)=v_2(\mathcal L(h))-2w(h)-s(h) +\] +when the central value is nonzero. By Lemma~\ref{pr:ranks}, $s(h)$ is +defined at a corank-zero base even before its central value is known to +be nonzero. Only the definition of $D(h)$ requires that nonvanishing. + +We prove the two assertions needed later. + +\begin{theorem}[Cyclotomic lower bound]\label{cy:lower-bound} +There is a constant $C_E$ such that, for every allowed $h$ with +$L(E^{(h)},1)\ne0$, +\[ + v_2(\mathcal L(h))\ \geq\ 2w(h)+s(h)-C_E. +\] +The constant is independent of the number and sizes of the primes dividing +$h$. +\end{theorem} + +\begin{theorem}[Transfer to the missing vertex]\label{cy:missing-vertex} +Let $h_0$ be an allowed discriminant with $s_2(E^{(h_0)})=0$. Suppose that +for arbitrarily large $b$ there are a finite set $Q$ of distinct primes +$q\nmid 2Nh_0$ and linear forms +$\lambda_q:\mathbb F _2^b\longrightarrow\mathbb F _2$ giving +\[ + h_x=h_0\prod_{q\in Q}(q^*)^{\lambda_q(x)},\qquad x\in\mathbb F _2^b, +\] +all in the fixed local and sign classes. Suppose that a number $B$, +independent of the family, satisfies +\[ + L(E^{(h_x)},1)\ne0,\qquad D(h_x)\leq B\qquad(x\ne0). +\] +Then $L(E^{(h_0)},1)\ne0$ and $D(h_0)\leq B+C_E$. +Here $C_E$ is independent of $h_0$, $Q$, and $b$; the dimension needed in +the proof is allowed to depend on the fixed precision being tested. +\end{theorem} + +\subsection{The integral scalar family and two algebraic steps} + +Put +\[ + \Lambda=\mathbb Z _2[[t]],\qquad + \mathcal O=\widehat{\Lambda_{(2)}},\qquad + \kappa=\mathcal O/2\mathcal O=\mathbb F _2((t)). +\] +The completion defining $\mathcal O$ is $2$-adic. An element of $\mathcal O$ +has, modulo any $2^M$, a Laurent expansion with a finite negative part. +There is no evaluation homomorphism $\mathcal O\to\mathbb Q _2$ given by +$t=0$. All central evaluations below are made on elements of +$\Lambda[1/2]$ before extending coefficients to~$\mathcal O$. + +For $G=(\mathbb Z/2\mathbb Z)^b$, index its characters by +$x\in\mathbb F _2^b$, and denote character evaluation by a subscript~$x$. + +The arithmetic construction below will produce a scalar family +$u\in\Lambda[1/2][G]$ with one uniform denominator: +\[ + 2^{C_{\mathrm{int}}}u\in\Lambda[G]. +\] +At a constituent with $s_2(E^{(h_x)})=0$, its central value $u_x(0)$ +will vanish exactly when $L(E^{(h_x)},1)$ does; in the nonvanishing case, +\[ + \bigl|v_2(u_x(0))-D(h_x)\bigr|\leq C_{\mathrm{loc}}. +\] +Both constants will be independent of the number and sizes of all varying +primes, including those of the base $h_0$. Integrality gives the lower +bound, while a congruence between the constant coefficients at $0$ and at +some nonzero address gives the missing-vertex theorem. + +Two different arguments establish the uniform denominator. Rational +divisibility will show $u_x\in\Lambda[1/2]$ character by character. +A fixed integral Kato construction will instead give +$2^{C_{\mathrm{int}}}u\in\mathcal O[G]$ before taking characters. +The first lemma combines these assertions without a loss depending on +$|G|$; the second supplies the congruence used at the end. + +\begin{lemma}[Integral Fourier intersection]\label{cy:fourier} +Suppose $u\in\mathcal O[1/2][G]$, all $u_x$ belong to $\Lambda[1/2]$, and +$2^C u\in\mathcal O[G]$. Then $2^C u\in\Lambda[G]$. +\end{lemma} +\begin{proof} +Fourier inversion in characteristic zero expresses every group-basis +coefficient of $u$ as a sum of the $u_x$ divided by $|G|$. Thus it belongs +to $\Lambda[1/2]$. The corresponding coefficient of $2^C u$ also belongs +to~$\mathcal O$. For a power series with bounded $2$-denominator, +nonnegative $\mathcal O$-valuation means that every coefficient is integral. +Consequently $\mathcal O\cap\Lambda[1/2]=\Lambda$, which proves the assertion +with the original exponent~$C$. +\end{proof} + +The common-zero parity step below is the characteristic-two case of the +Chevalley--Warning principle; see +\cite[Section~1, equation~(1)]{HeathBrownChevalleyWarning}. +We retain the elementary proof of this step. + +\begin{lemma}[Binary congruences]\label{cy:binary} +Let $z_1,\ldots,z_r\in\mathbb Z _2[G]$. Given $M\geq1$, if +$b>r(2^M-1)$, there is an $x\ne0$ such that +\[ + (z_j)_x\equiv(z_j)_0\pmod {2^M}\qquad(1\leq j\leq r). +\] +The bound depends on the number of tests and their precision, and not on +the group-ring coefficients. +\end{lemma} +\begin{proof} +Choose generators of $G$. Every character-value function $z(x)$ has an +expansion +\[ + z(x)=a_\varnothing+ + \sum_{\varnothing\ne I\subseteq\{1,\ldots,b\}} + 2^{|I|}a_I\prod_{i\in I}x_i, + \qquad a_I\in\mathbb Z _2. +\] +This follows by expanding each sign character as a product of factors +$1-2x_i$. The $j$th binary digit of a $2$-adic integer $a$ is +$\binom a{2^j}\bmod2$, equivalently the coefficient of $Y^{2^j}$ in +$(1+Y)^a$ over $\mathbb F _2$. On the Boolean cube, the contribution of +the monomial $x_I=\prod_{i\in I}x_i$ to this generating function is +\[ + 1+x_I\bigl((1+Y)^{2^{|I|}a_I}-1\bigr). +\] +Its nonconstant terms have $Y$-degree at least $2^{|I|}$. In a contribution +to $Y^{2^j}$, the sum of the quantities $2^{|I|}$ used is at most $2^j$. +Since $|I|\leq2^{|I|}$, the resulting Boolean polynomial has degree at +most~$2^j$. These formulas for $2$-adic exponents follow either by +continuity from nonnegative integers or in each finite coefficient +quotient. + +Express all $rM$ digit equalities as Boolean equations $P_{ij}(x)=0$. +Their total degree is at most $r(2^M-1)$. The indicator of their common +zero set is $\prod_{i,j}(1+P_{ij})$. The remaining count is the +Chevalley--Warning degree argument \cite{Chevalley1935,Warning1935}. +A Boolean polynomial of degree less than $b$ has even sum over +$\mathbb F _2^b$: every monomial omits a variable, +and summing over that variable gives zero in $\mathbb F _2$. Hence the +number of common zeros is even. Since $0$ is a common zero, another one +exists. +\end{proof} + +\subsection{The positive global complex} + +The scalar $u$ will be the coordinate of two cohomology classes in an +integral determinant line. One class comes from the real place and the +other from Kato's construction. We first construct the complex and show +that its localization at $(2)$ is free of rank two in degree one. + +Let $\Gamma=\operatorname{Gal}(\mathbb Q_\infty/\mathbb Q)$ be the real +cyclotomic $\mathbb Z _2$-group and identify its generator with $1+t$. +For a binary family, let $\psi:G_{\mathbb Q}\to G$ be its universal +quadratic character: evaluation at $x$ is $\chi_{h_x/h_0}$. Put +\[ + R=\Lambda[G],\qquad + \mathbb T=T\otimes_{\mathbb Z _2}R, +\] +with the fixed twist $\chi_{h_0}$, the universal twist $\psi$, and the +inverse cyclotomic action. One may replace $G$ by the actual image of +$\psi$ and subsequently extend scalars. In a family in +Theorem~\ref{cy:missing-vertex}, a nonzero character trivial on that image +already gives the conclusion directly. + +Let $S$ contain $2N$, the prime factors of $h_0$, and all the new primes. +Use continuous cochains with their completed coefficient topology, and set +\begin{equation}\label{cy:positive} + C_S^+(\mathbb T)= + \operatorname{Cone}\bigl(R\Gamma(G_{\mathbb Q,S},\mathbb T) + \longrightarrow R\Gamma(\mathbb R,\mathbb T)\bigr)[-1]. +\end{equation} +The real complex here uses ordinary cochains in nonnegative degrees. +There are no imposed local conditions at the finite places. + +\begin{lemma}[Perfection and the real-place class]\label{cy:perfect} +The complex \eqref{cy:positive} is perfect over $R$ and computes derived +coefficient specializations. There is a class $a\in H^1(C_S^+(\mathbb T))$ +whose rational span is the real-place summand. Its integral index in +that summand depends only on $E$ and the fixed real sign. +\end{lemma} +\begin{proof} +Here are the finiteness and coefficient issues in the use of global +cochains. For a finite coefficient quotient of $R$, continuous cochains +are filtered unions of finite products of free coefficient modules. +Refinement of finite partitions makes these modules flat; over an Artin +local coefficient ring they are free. For finite residual coefficients, +global cohomology is finite in each degree, and restriction to the real +places is an isomorphism in degrees greater than two. The latter is the +real-place clause of global duality. Thus the residual fiber has bounded +amplitude and finite-dimensional cohomology. The same amplitude bound +holds for every finite coefficient module, by a composition series and +the cohomology long exact sequence. + +This gives a bounded finite free model as follows. Over the residue +field split off the acyclic disks, leaving its finitely many cohomology +spaces. Lift each invertible disk differential over an Artin coefficient +quotient and cancel it. Invertibility of a lifted inverse follows from +nilpotence of the maximal ideal. Equivalently one can perform this on a +free resolution; a minimal free model cannot have an additional term +whose reduction has zero cohomology, because its residual differential +is zero. Hence the remaining ranks are the finite residual ranks and +are bounded independently of the coefficient quotient. Minimal models +identified by a homotopy equivalence over an Artin local ring are +isomorphic. Lifting their changes of basis therefore makes these models +compatible along $R/\mathfrak m^n$. Taking the inverse limit gives a +bounded finite free model over~$R$. The cochain construction with finite +free coefficients and the same cancellation also proves derived base +change. This is a fixed-$S$ argument; it does not assert uniform bounds +on the number of generators as $S$ varies. + +All the characters of the family have the same real sign, so the action +at the real place is the fixed action on $T\chi_{h_0}$ extended to $R$. +Choose a nonzero vector in its integral invariant line. Its connecting +image in the fiber is $a$. There are no global invariant vectors in the +rational elliptic representation, and consequently this connecting map +is injective rationally. The choice and its index are fixed. Notice also +that $H^1(\mathbb R,\mathbb T)$ is killed by~$2$; thus twice any ordinary +cohomology class lifts to the positive complex. These observations use +compact global duality, including the real-place extension +\cite[Sections~5.7 and~6.9.1]{Nekovar2006} of the complex formulation +in \cite[Theorem~6.3.4]{Nekovar2006}. +\end{proof} + +\begin{lemma}[Residual concentration]\label{cy:residual} +There is an isomorphism in the derived category +\[ + C_S^+(\mathbb T)\otimes_R\mathcal O[G] + \simeq \mathcal O[G]^2[-1]. +\] +\end{lemma} +\begin{proof} +The ring $\mathcal O[G]$ is local, with residue field $\kappa$ obtained +by setting $2=0$ and every $g=1$. Thus the quadratic characters disappear. +Since $E[2]$ has a filtration with trivial factors, it is enough first to +compute the positive residual complex for the trivial representation. + +Let $K_n$ be the real cyclotomic layer of degree $d_n=2^n$. The number +of finite primes of $K_n$ above a fixed $S$ is bounded with $n$: at $2$ +there is total ramification, and the Frobenius of each fixed odd prime +has nonzero image in $\Gamma$. The $2$-ranks of the class groups of +$K_n$ are also bounded. Indeed the cyclotomic $\mu$-invariant is zero +for this abelian tower \cite{FerreroWashington1979}; the structure theorem +and class-group control identify their $2$-ranks, up to bounded kernels +and cokernels, with those of the coinvariants of a finitely generated +$\mathbb Z _2$-module. The same bound holds for $S$-class groups. + +The signature map of units in $K_n$ is surjective. For $n\geq1$, let +$\zeta$ be a primitive $2^{n+2}$th root and put +$\epsilon=1+\zeta+\zeta^{-1}$. If $f_1(X)=X^2-2$ and +$f_{n+1}(X)=f_n(X^2-2)$, then $f_n$ is the minimal polynomial of +$\zeta+\zeta^{-1}$ and $f_n(-1)=-1$. Hence +$N_{K_n/\mathbb Q}(\epsilon)=-1$. Its signature vector has odd +augmentation. The embeddings form a regular set for the cyclic +$2$-group $\operatorname{Gal}(K_n/\mathbb Q)$, whose group algebra over +$\mathbb F _2$ is local. A vector with odd augmentation is a unit in +this group algebra, so its translates span every signature. For $n=0$ +the assertion follows from the unit~$-1$. + +We now use Kummer theory to isolate the one dimension that survives +after inverting $t$. +Writing $s_n$ for the number of finite support places and $c_n$ for the +$2$-rank of the $S$-class group, one has +\[ + \dim H^1(G_{K_n,S},\mu_2)=d_n+s_n+c_n. +\] +The real degree-one restriction is surjective by the signature result. +In degree two, the Kummer sequence has class-group term of dimension +$c_n$ and Brauer term. The Brauer invariants at the real and finite +support places have their single sum relation. Since a finite support +place above $2$ is present, restriction of the Brauer term to the real +places is surjective and has kernel of dimension $s_n-1$. Thus the +degree-two kernel of restriction to infinity is bounded. Restriction +is an isomorphism in higher degrees by global duality. The degree-zero +restriction is injective. The cohomology of the positive fiber is +therefore bounded in every degree except one; its degree-one dimension +is $d_n+O_S(1)$. + +Apply Lemma~\ref{cy:perfect} modulo $2$. Derived specialization to the +$n$th layer is specialization modulo $t^{2^n}$. For a perfect complex +over $\mathbb F _2[[t]]$, the universal-coefficient exact sequence shows +that a rank-$r$ cohomology module contributes $r2^n+O(1)$ to these +dimensions; the torsion terms contribute only $O(1)$. It follows that +after inverting $t$ the trivial-constituent fiber has dimension one in +degree one and vanishes in every other degree. Extensions preserve +this concentration, so the fiber for $E[2]$ has dimension two in degree +one. A minimal finite free complex over the local ring $\mathcal O[G]$ +has zero residual differentials. The concentration just proved forces +all its terms except the rank-two term in degree one to vanish. +No denominator is introduced by this exact freeness statement. +\end{proof} + +\subsection{Fixed-form zeta classes and the integral coefficient map} + +We need a global class whose denominator stays bounded as the tame +support grows. For this purpose every auxiliary trace will land in +the lattice of one fixed modular form. Let $f$ be the fixed weight-two +form of $E$, and choose its fixed integral cohomological lattice, with +the Tate twist making its +rational representation~$V$. Kato's classes (8.1.2)--(8.1.3), for a fixed +symbol $\xi\in\mathrm{SL}_2(\mathbb Z)$, exist for arbitrary $m$ and any +$S$ containing the prime factors of $mN$. The trace in Section~8.9 is +a homomorphism into the lattice +\[ + \mathbb Z _2[\operatorname{Gal}(\mathbb Q(\mu_m)/\mathbb Q)] + \otimes V_{2,\mathbb Z _2}(Y_1(N))(1). +\] +Section~8.11 then projects to the lattice of the fixed form. +Proposition~8.12 supplies its norm relations. These assertions hold at +the coefficient prime~$2$ \cite[Sections~5.1, 8.1, 8.9--8.12]{Kato2004}. +In particular, the auxiliary modular-curve level used to define a trace +does not become the level of the projected newform. + +Choose an isomorphism of the resulting fixed rational representation with +$V$. A single power $2^{c_E}$ sends its integral lattice into~$T$. +Choose fixed symbols with nonzero projections on the required period +lines; their existence and the construction with both signs are made +explicit in \cite[Sections~13.6 and 13.9]{Kato2004}. Taking a fixed linear +combination, if needed, costs another fixed denominator. + +Here is the coefficient map in this application. Let $m$ be odd and +divisible by the conductors of all the tame characters in the family, +including the odd part of $\chi_{h_0}$. At a sufficiently large +cyclotomic level write $A_{m,n}=\operatorname{Gal}(\mathbb Q(\mu_{m2^n})/ +\mathbb Q)$. Shapiro identifies the cohomology of the cyclotomic field +with global cohomology with induced group-ring coefficients. Push the +class along the ring homomorphism +\begin{equation}\label{cy:coefficient-map} + \mathbb Z _2[A_{m,n}]\longrightarrow + \mathbb Z _2[\Gamma_n\times G],\qquad + [\sigma]\longmapsto + \chi_{h_0}(\sigma)[\sigma|_{\Gamma_n}][\psi(\sigma)]. +\end{equation} +Use inverse actions on both sides if this is required by the chosen +Shapiro convention. This is a homomorphism of integral coefficient +modules and acts on actual cohomology classes. It requires neither +division by $|G|$ nor surjectivity of a cohomological specialization map. +The prime $2$ belongs to the fixed omitted support, so Proposition~8.12 +gives exact norm compatibility as $n$ increases. The pushed classes +therefore give an integral smoothed Iwasawa class with coefficients in +$\mathbb T$, up to the single fixed power~$2^{c_E}$. + +We next remove smoothing. In weight two and with $r=r'=1$, its factors +are +\begin{equation}\label{cy:smoothing} + (c^2-c\sigma_c)(d^2-d\sigma_d). +\end{equation} +This is the specialization of +\cite[Theorem~6.6 and (4.2.4)]{Kato2004}. Choose a fixed +$e\geq\max(2,v_2(N))$, increasing it to accommodate the finitely many +fixed symbol levels. The Chinese remainder theorem permits $c,d>1$, +prime to $6Nm$, such that +\[ + c,d\equiv1\pmod{3N_{\mathrm{odd}}m},\qquad + c,d\equiv1+2^e\pmod{2^{e+1}}. +\] +Their tame actions in \eqref{cy:coefficient-map} are trivial. If +$\sigma_c$ acts in $\Gamma$ as $(1+t)^{\kappa(c)}$, then +$v_2(\kappa(c))=e-2$. Modulo the maximal ideal of $\mathcal O[G]$ its +smoothing factor is +\[ + 1-(1+t)^{\kappa(c)}\ne0\quad\hbox{in }\mathbb F _2((t)). +\] +It is therefore a unit in $\mathcal O[G]$. Its central value is +$c(c-1)$, of valuation exactly~$e$. The same statements hold for $d$ +and for inverse-translate conventions. Thus unsmoothing introduces +neither a $2$-adic denominator at $(2)$ nor a growing central denominator. +The integers $c,d$ vary with $m$; the congruences fix the needed valuations, +not their exact cyclotomic group elements. + +Denote the resulting rational ordinary class by $z_S^{(0)}$. Theorem~9.7 of +\cite{Kato2004} applies to $k=2,r=r'=1$. In the character constituent +$x$, its central reciprocity formula reads +\begin{equation}\label{cy:reciprocity} + v_2\bigl(\exp_2^*z_{S,x}^{(0)}(0)\bigr) + =v_2(\mathcal L(h_x))+ + \sum_{\substack{q\in Q\,,\ q\nmid h_x}} + v_2\bigl(\#E^{(h_x)}(\mathbb F _q)\bigr)+O_E(1) +\end{equation} +when the value is nonzero, and a zero central value gives a zero dual +exponential. Fixed omitted primes are included in the error. +To check the normalization, the character sum in +\eqref{cy:coefficient-map} is the unnormalized sum, as in Kato's trace. +Its tame quadratic Gauss sum supplies $\sqrt{|h_x|}$ up to a root of +unity. Tame conductors and their Gauss sums are $2$-adic units. The +period vector is the fixed symbol vector of $f$. More explicitly, +in the required sign line write the period represented by +$\delta(f,1,\xi)^{\pm}$ as $c_\xi^{\pm}\Omega_E^{\pm}$. +The nonzero scalar $c_\xi^{\pm}$ is fixed: the character-sum formula +of \cite[Theorem~6.6]{Kato2004} uses this same $\delta(f,1,\xi)^{\pm}$ +for every tame character. The tame character enters through its +$L$-value and Gauss sum, not through a newly chosen period vector. +The comparison with the minimal differential of $E^{(h_x)}$ at $2$ has bounded valuation, +because there are only finitely many local twisting classes there. +At a good unused prime the omitted factor is +\[ + 1-\frac{a_q(E)\chi_{h_x}(\operatorname{Fr}_q)}q+\frac1q + =\frac{\#E^{(h_x)}(\mathbb F _q)}q; +\] +at a good ramified prime the local $L$-factor is~$1$. These account for +every varying factor in \eqref{cy:reciprocity}. + +\subsection{Rational divisibility and the local Euler corrections} + +The fixed-form construction controls the denominator at $(2)$. We now +prove the complementary assertion: the determinant coordinate has no +pole at any other height-one prime. This step is characterwise and uses +only rational divisibility. Write $A=\Lambda[1/2]$. Theorem~12.5(3) of +\cite{Kato2004} is a height-one divisibility over~$A$; its possible local +$H^2$ correction comes from Galois cohomology over $\mathbb Q_2$. +The global groups there use $j_*$ outside that prime. The stronger integral assertion +12.5(4) is not used. In the non-CM case, the large-image input in Kato's +proof follows from the open image theorem \cite{Serre1972}; see +\cite[Remark~12.8, (12.8.2), Theorem~13.4(v), and Section~13.13]{Kato2004}. +This is not an additional residual-image hypothesis in Theorem~12.5(3). +For CM the required rational statement at every prime, including~$2$, is supplied by +\cite[Theorem~2.6 and Remark~2.7]{BurungaleTian2026}. Neither statement +asserts uniform integrality in a quadratic group ring. + +Fix a character constituent $h$ and write $V_h=V\chi_h$. Let $C_{j_*}$ +be the rational Iwasawa complex in Kato's formulation and $C_S$ the +rational full global complex. At an odd prime put +\[ + W_q=H^1(I_q,V_h). +\] +The localization triangle has local cone +\begin{equation}\label{cy:local-block} + Q_q=R\Gamma\bigl(G_{\mathbb F _q}, + W_q\otimes A(\Gamma^\iota)\bigr)[-1] + =\left[W_q\otimes A + \xrightarrow{\ 1-\gamma_q\operatorname{Fr}_{W_q}\ } + W_q\otimes A\right] +\end{equation} +in degrees one and two. Here $\gamma_q$ denotes the scalar cyclotomic +Frobenius in the chosen convention. Its exponent is nonzero. Consequently +$D_q=\det(1-\gamma_q\operatorname{Fr}_{W_q})$ is a nonzero element of~$A$, +and the map in \eqref{cy:local-block} is injective. This remains true +after localization at a height-one prime dividing $D_q$: localization +does not mean reduction modulo that prime. Thus +\[ + H^1(Q_q)=0,\qquad + \operatorname{length}_{A_{\mathfrak p}}H^2(Q_q)_{\mathfrak p} + =v_{\mathfrak p}(D_q). +\] +The long exact sequence gives +\begin{equation}\label{cy:local-sequence} + \begin{gathered} + H^1(C_{j_*})\simeq H^1(C_S),\\ + 0\longrightarrow H^2(C_{j_*})\longrightarrow H^2(C_S) + \longrightarrow\bigoplus_{q\in S\setminus\{2\}}H^2(Q_q) + \longrightarrow H^3(C_{j_*}). + \end{gathered} +\end{equation} +In particular, the length of $H^2(C_S)$ is at most the length of +$H^2(C_{j_*})$ plus the sum of the local lengths. No assertion that +$H^3(C_{j_*})$ vanishes is required here. + +At a good unused prime, $W_q=V_h(-1)$, so, on including the quadratic +Frobenius sign in $Z$, +\begin{equation}\label{cy:good-euler} + D_q=P_q(Z),\qquad P_q(Z)=1-\frac{a_q(E)}q Z+\frac1q Z^2. +\end{equation} +At a good active prime, inertia acts by $-1$ on $V_h$. Its rational +inertia cohomology is zero, so $W_q=0$ and $D_q=1$. + +At fixed bad primes the general expression is $H^1(I_q,V_h)$ in +\eqref{cy:local-block}. Replacing it indiscriminately by $V_h^{I_q}(-1)$ +would be incorrect. For example, at split multiplicative reduction, +\[ + V_h^{I_q}=\mathbb Q _2(1),\qquad + H^1(I_q,V_h)=\mathbb Q _2(-1), +\] +and the correct determinant is $1-\gamma_q/q$, with nonzero central +value. The incorrect replacement would give $1-\gamma_q$. +In general $D_q(0)\ne0$ follows from local duality: +$H^2(\mathbb Q _q,V_h)=H^0(\mathbb Q _q,V_h)^*=0$, since elliptic torsion +over a local field is finite. The fixed bad-prime corrections therefore +have nonzero central values for every reduction type. + +Let $z_{\mathrm{BK},h}$ denote a generator of the rational Kato zeta +line in the real cyclotomic component with the fixed sign. Compare it +with the fixed-form class only after taking the character constituent. +In the chosen Euler convention the comparison is +\begin{equation}\label{cy:rational-comparison} + z_{S,h}^{(0)} + =c_h\epsilon_h(t)E_h^{\mathrm{fix}}(t) + \prod_{\substack{q\in Q\,,\ q\nmid h}} + P_q\bigl(\chi_h(\operatorname{Fr}_q)\gamma_q\bigr) + z_{\mathrm{BK},h}, +\end{equation} +where $c_h\in\mathbb Q_2^\times$ and $\epsilon_h$ is a group-like +unit of~$A$. The factor $E_h^{\mathrm{fix}}$ consists of the omitted +local $L$-polynomials away from $2$ at primes of $N$ and the fixed +auxiliary support. It ranges over a finite collection, because the +local twisting classes there are fixed. The primes of $h_0$ are good +ramified primes and contribute~$1$, regardless of their number. +These factors have nonzero central values: they are good-prime point +counts divided by the prime, multiplicative factors $1\mp1/q$, or~$1$. +They are not being identified with the local cohomology determinants +$D_q$ at bad primes; any discrepancy there will be cleared by a fixed +multiplier below. + +Here is the derivation of \eqref{cy:rational-comparison}. Both global +Iwasawa $H^1$ modules have rank one. The reciprocity formulas +\cite[Theorems~6.6, 9.7, 12.5(1), and Lemma~13.10(2)]{Kato2004} +compare the same fixed period vector and the relevant imprimitive +$L$-values. Their quotient supplies the displayed omitted Euler +factors; a good ramified prime contributes~$1$. Coprime Gauss-sum +factorization and the fixed period comparison supply $c_h$ and +$\epsilon_h$; restricting conductor exponents to either fixed parity +removes any factor $\chi_h(2)^n$. Infinitely many of these tests have +nonzero central value by cyclotomic nonvanishing, as used in +\cite[Theorem~13.5(2)]{Kato2004}. After clearing the finitely many +denominators of the scalar ratio, the difference is a power series +vanishing at infinitely many finite-order characters. Weierstrass +preparation forces that difference to be zero. This proves the generic +comparison without identifying the integral lattices of varying +twisted newforms. The scalar $c_h$ need not have a uniformly bounded +$2$-valuation: every such scalar is a unit of $A$ and does not affect +height-one divisibility over~$A$. The uniform integral and central bounds instead concern +the actual fixed-form class and the fixed period vector in +\eqref{cy:reciprocity}. + +Equations \eqref{cy:local-sequence}--\eqref{cy:good-euler} now show exactly +how the imprimitive factors enter divisibility. At any height-one +$\mathfrak p$ of $A$, enlarging the global complex increases its +degree-two length by at most $\sum_qv_{\mathfrak p}(D_q)$, whereas +multiplying the rank-one zeta generator by $\prod_qD_q$ adds exactly +that quantity to its index. To cover Kato's local correction at $2$, +multiply the class also by a fixed element $F_2\in\Lambda$ divisible over $A$ by the +characteristic ideal of the relevant local $H^2_{\mathrm{Iw}}$. +It may be chosen with $F_2(0)\ne0$. Indeed derived local control gives +\[ + H^2_{\mathrm{Iw}}(\mathbb Q _2,T\chi_h)_\Gamma\otimes\mathbb Q _2 + =H^2(\mathbb Q _2,V_h)=0, +\] +so the characteristic ideal has no factor $t$. Local twisting classes +at $2$ are fixed, and one element covers their finite set. + +Likewise any additional fixed Euler factors in the rational comparison +can be cleared by a fixed product with nonzero central value, using the +actual blocks \eqref{cy:local-block}. Denote the total fixed multiplier +by~$F_E$. Multiplying by it only changes the fixed constants in +\eqref{cy:reciprocity} and the integrality bound. Set +$z_S=F_Ez_S^{(0)}$. For this corrected class we have at every +height-one $\mathfrak p$ of~$A$ +\begin{equation}\label{cy:divisibility} + \operatorname{length}_{A_{\mathfrak p}}H^2(C_S)_{\mathfrak p} + \leq + \operatorname{length}_{A_{\mathfrak p}} + \bigl(H^1(C_S)/Az_{S,h}\bigr)_{\mathfrak p}. +\end{equation} + +We finish by checking that the chosen Euler convention can be imposed +integrally before character evaluation. If the original coefficient +map uses inverse Frobenius, the varying unused factors change as follows. +In $\mathcal O[G]$, both $P_q(Z)$ and $Z^2P_q(Z^{-1})$ are units: their +reductions are nonzero polynomials evaluated at the nonconstant +cyclotomic Frobenius. The identity +\[ + P_q(Z)-Z^2P_q(Z^{-1})=\frac{q-1}{q}(1-Z^2) +\] +shows that their ratio $r_q$ is $1$ modulo~$2$. If $g_q$ is the universal +inertia element, then +\begin{equation}\label{cy:euler-convention} + U_q=1+\frac{r_q-1}{2}(1+g_q)\in\mathcal O[G]^\times +\end{equation} +is integral. At an active character it is $1$; at an unused character +it is $r_q$. Its unused central value is $1$, since $Z=\pm1$ there. +Thus inverse Frobenius conventions can be reconciled before character +evaluation, without a denominator for each prime. Products of these +units have the same property. The resulting rational character +coordinates have the Euler convention in \eqref{cy:divisibility}. +We use this convention for $z_S$ from now on; these units alter neither +its uniform integrality bound nor its central reciprocity values. + +\subsection{The determinant and its central specialization} + +Choose a basis $\mathbf e$ of the invertible $R$-module +$\det_R^{-1}C_S^+(\mathbb T)$; $R$ is local, so such a basis exists. +Lift $2z_S$ to positive cohomology and take its wedge with $a$. +The factor $2$ is fixed, and two lifts differ by a real-place class, +which does not change this wedge. In generic cohomology, the inverse +determinant identifies with the exterior square of the rank-two +degree-one space. Define its scalar coordinate $u$ by +\[ + a\wedge\widetilde{2z_S}=u\mathbf e. +\] +Here $z_S$ already includes the fixed multiplier $F_E$ above. +The real-place summand introduces no height-one torsion over~$A$. Thus +\eqref{cy:divisibility} says that $u_x$ has no pole at any height-one +prime of $\Lambda$ except possibly $(2)$. Since $\Lambda$ is normal, +\begin{equation}\label{cy:rational-membership} + u_x\in\Lambda[1/2]\qquad\hbox{for every }x. +\end{equation} +On the other hand, the fixed integral trace, +\eqref{cy:coefficient-map}, unsmoothing over $\mathcal O[G]$, and +Lemma~\ref{cy:residual} give +\[ + 2^{C_{\mathrm{int}}}u\in\mathcal O[G] +\] +with $C_{\mathrm{int}}$ independent of $S$, $h_0$, $G$, and~$b$. +The determinant identification in a free complex introduces no further +index. Applying Lemma~\ref{cy:fourier} yields the crucial uniform statement +\begin{equation}\label{cy:uniform-integrality} + 2^{C_{\mathrm{int}}}u\in\Lambda[G]. +\end{equation} + +\begin{proposition}[Central determinant formula]\label{cy:central} +There is a constant $C_{\mathrm{loc}}$, depending only on the fixed curve +and local classes, with the following property. If $s_2(E^{(h_x)})=0$, +then $u_x(0)=0$ when $L(E^{(h_x)},1)=0$. Otherwise +\begin{equation}\label{cy:central-formula} + \bigl|v_2(u_x(0))-D(h_x)\bigr|\leq C_{\mathrm{loc}}. +\end{equation} +The rational positive complex at $t=0$ has cohomology only in degree one, +of dimension two, so these are specializations of the same determinant. +\end{proposition} +\begin{proof} +Abbreviate $T_h=T_2E^{(h_x)}$ and $A_h=E^{(h_x)}[2^\infty]$. +Use the integral Kummer subgroup +\[ + K_v=\operatorname{im}\bigl(E^{(h_x)}(\mathbb Q _v)^{\wedge}_2 + \longrightarrow H^1(\mathbb Q _v,T_h)\bigr) +\] +at every finite place. For $v\ne2$ it is all of $H^1(\mathbb Q _v,T_h)$. +One way to see this integrally is the inverse-limit Kummer exact sequence: +its quotient is $T_2H^1(\mathbb Q _v,E^{(h_x)})$, which is zero because +local Tate duality identifies the $2$-primary local Weil--Ch\^atelet group +with the dual of the finite $2$-completion of the local point group. +At $2$ the quotient +\[ + L_2=H^1(\mathbb Q _2,T_h)/K_2 +\] +is a free rank-one $\mathbb Z _2$-module. The same Kummer sequence and +local Tate duality identify it with the $\mathbb Z _2$-dual of the free +part of $E^{(h_x)}(\mathbb Q _2)^{\wedge}_2$. + +The dual exponential identifies $L_2\otimes\mathbb Q _2$ with the +one-dimensional de Rham target. Integrally its index depends only on +the local curve and the chosen differential. This follows from the +compatibility of the Kummer map and local Tate duality with the formal +elliptic logarithm: on a sufficiently small open formal subgroup that +logarithm is an isomorphism, and its adjoint is the dual exponential. +Every elliptic curve over $\mathbb Q _2$ has such a formal subgroup, +irrespective of reduction type. Since only finitely many local twists +occur, the indices are uniformly bounded. + +The assumption on the Selmer corank implies that the compact finite +Selmer group is torsion and that the discrete finite Selmer group has +length $s(h_x)$. Rational Poitou--Tate consequently identifies ordinary +global $H^1$ with the singular line at $2$, and gives ordinary global +$H^2=0$ rationally. Adding the real invariant line gives the claimed +dimension two in degree one. This equals the generic rank, so derived +base change of the perfect complex specializes its determinant without +a change of rational cohomological rank. + +The integral calculation explains the two subtractions in $D(h_x)$. +The index of global localization will cancel; the remaining local terms +will cancel the unused Euler factors and contribute $2w(h_x)$ at the +active primes. Let $J$ be the image of the free part of global +$H^1(G_{\mathbb Q,S},T_h)$ in $L_2$, and put +$i=\operatorname{length}(L_2/J)$. The compact/discrete Poitou--Tate +sequence for the mutually orthogonal Kummer conditions contains +\[ +\begin{aligned} + 0\longrightarrow L_2/J + &\longrightarrow \operatorname{Sel}_{2^\infty}(E^{(h_x)}/\mathbb Q)^\vee + \longrightarrow H^2(G_{\mathbb Q,S},T_h)\\ + &\longrightarrow \bigoplus_{q\in S}H^2(\mathbb Q _q,T_h) + \longrightarrow H^0(\mathbb Q,A_h)^\vee\longrightarrow0, +\end{aligned} +\] +with the usual real Tate-cohomology terms inserted. Those terms are +killed by $2$ and have dimensions bounded by the fixed dimension of~$T$. +Taking lengths and using local duality gives +\begin{equation}\label{cy:pt-length} + \operatorname{length}H^2(G_{\mathbb Q,S},T_h) + =s(h_x)-i+\sum_{q\in S}\operatorname{length}H^0(\mathbb Q _q,A_h) + +O_E(1). +\end{equation} +This sequence is the cohomology consequence of integral +Poitou--Tate duality with the finite local conditions; see +\cite[Theorem~6.3.4 and Section~6.9.1]{Nekovar2006}, with the real +Tate-cochain convention of \cite[Section~5.7.1.6]{Nekovar2006}. +No unramified condition replaces +the Kummer condition at a bad prime. Global torsion is bounded by its +injection into $E^{(h_x)}(\mathbb Q _2)[2^\infty]$, whose order is bounded +by the fixed local twisting classes. The finite terms at $2$ and at +fixed bad primes are bounded for the same reason. Passing between +ordinary and positive cohomology changes only these bounded real and +global torsion terms. + +Suppose first that the central value is nonzero. The coordinate of +$z_{S,x}(0)$ in the free global line has valuation +\[ + v_2(\exp_2^*z_{S,x}(0))-i+O_E(1). +\] +For the inverse determinant, torsion in degree two subtracts its length +and torsion in degree one adds its length. This sign can be checked on +the complex $[\mathbb Z _2\xrightarrow{2^a}\mathbb Z _2]$ in degrees one +and two: its inverse determinant lattice maps to $2^a\mathbb Z _2$ in +the rational determinant. A vector's coordinate thus loses~$a$. +Using \eqref{cy:pt-length}, the two appearances of $i$ cancel, leaving +\[ + v_2(u_x(0))= + v_2(\exp_2^*z_{S,x}(0))-s(h_x) + -\sum_{q\in S}\operatorname{length}H^0(\mathbb Q _q,A_h)+O_E(1). +\] + +At an active good prime, quadratic inertia acts by $-1$ on the Tate +module. Its invariants on $A_h$ are therefore exactly $E[2]$, and taking +Frobenius invariants gives length~$t_q$. At an unused good prime, reduction +identifies the local $2$-primary torsion with +$E^{(h_x)}(\mathbb F _q)[2^\infty]$, of length +$v_2(\#E^{(h_x)}(\mathbb F _q))$. These unused terms cancel exactly +those in \eqref{cy:reciprocity}. The active terms, including the primes +of $h_0$, sum to $2w(h_x)$. All other terms have already been bounded +independently of the growing support. This proves +\eqref{cy:central-formula}. + +If the central value is zero, reciprocity makes the dual exponential +zero. The rational ordinary specialization then satisfies the finite +condition at $2$, and it satisfies the finite conditions elsewhere +automatically. It lies in the rational finite Selmer group, which is +zero. Its wedge with the real-place class is therefore zero. The +constant-rank determinant specialization proves $u_x(0)=0$. +\end{proof} + +\subsection{Proofs of the interpolation theorems} + +\begin{proof}[Proof of Theorem~\ref{cy:lower-bound}] +Use the preceding construction for the single discriminant~$h$. +The forward analytic rank-zero theorem gives $s_2(E^{(h)})=0$ and +finiteness of its Shafarevich--Tate group. By +\eqref{cy:uniform-integrality}, $v_2(u_h(0))\geq-C_{\mathrm{int}}$. +Proposition~\ref{cy:central} then gives +$D(h)\geq-C_{\mathrm{int}}-C_{\mathrm{loc}}$. Every constant in the +construction came from the fixed form, a fixed real period line, or +the finite set of local twists at $2N$. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{cy:missing-vertex}] +At every nonzero address the forward rank-zero theorem gives Selmer +corank zero. Proposition~\ref{cy:central} gives +\[ + v_2(u_x(0))\leq B+C_{\mathrm{loc}}\qquad(x\ne0). +\] +Choose an integer $M$ such that +$M-C_{\mathrm{int}}>B+C_{\mathrm{loc}}$. By +\eqref{cy:uniform-integrality}, the constant coefficient of +$2^{C_{\mathrm{int}}}u$ belongs to $\mathbb Z _2[G]$. For sufficiently +large $b$, Lemma~\ref{cy:binary} gives an $x\ne0$ such that +\[ + v_2(u_x(0)-u_0(0))\geq M-C_{\mathrm{int}}. +\] +It follows that $u_0(0)$ is nonzero and +$v_2(u_0(0))\leq B+C_{\mathrm{loc}}$: either failure would contradict +the displayed upper bound at this $x$. The corank-zero hypothesis +at the base and Proposition~\ref{cy:central} imply +$L(E^{(h_0)},1)\ne0$ and +\[ + D(h_0)\leq B+2C_{\mathrm{loc}}. +\] +Taking $C_E$ large enough proves both theorems with a common constant. +In particular no loss proportional to $b$, $|Q|$, or the prime count of +$h_0$ has entered this argument. +\end{proof} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/graphs.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/graphs.tex new file mode 100644 index 0000000000000000000000000000000000000000..bcc942582ebb7c1ee6e63bc013b6a442c9473d6c --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/graphs.tex @@ -0,0 +1,646 @@ +\section{Arithmetic graphs and simultaneous addressing}\label{gr:section} + +Fix $b\ge1$. An \emph{address} is a point $x\in\mathbf F_2^b$; +a vertex with activation $\lambda\in(\mathbf F_2^b)^*$ is present at $x$ +when $\lambda(x)=1$. We will adjoin fresh primes with nonzero activations +to a given collection of primes. The goal is to make one or two binary +coefficient tests equal to $1$ at every $x\ne0$, while retaining all the +original primes and their residue data. No new prime is present at $0$. +The hypothesis is that each test, separately at each nonzero address, +is a nonzero polynomial in the available residue bits. + +The arithmetic identities are those of +Proposition~\ref{co:symbol-interface}, conditional on its coefficient +lower bounds. We first describe and realize their graph data, then state +the simultaneous-testing result. Its proof uses contraction operators +and two finite networks that isolate a prescribed derivative at one address. + +\subsection{Labels and arithmetic realization} + +Fix a finite set $S$ of rational primes, containing $2$ and all the ramified +primes in the fixed data. Let $F$ be either $\mathbf Q$ or a quadratic field. +For the rational two-torsion application $F=\mathbf Q(E[2])$; the construction +with full rational two-torsion also uses a quadratic auxiliary field in place +of $F$. Include in $S$ primes whose prime ideals generate the class group of +$F$, and include the infinite places in $S_F$. Put +\[ + V_S(F)=\{\alpha\in F^\times/F^{\times2}: + v_{\mathfrak p}(\alpha)\equiv0\pmod2 + \text{ for }\mathfrak p\notin S_F\}. +\] +This is a finite-dimensional $\mathbf F_2$-space: the valuation sequence +expresses it as an extension of the finite squareclass group of $S_F$-units +by a subgroup of the $2$-torsion of the $S_F$-class group. Its Kummer extension +is denoted $F_S^{(2)}=F(\sqrt{V_S(F)})$. + +A \emph{split vertex} is a rational prime $p\notin S$ split in $F$, together +with a choice $\mathfrak p\mid p$ if $F$ is quadratic. This choice is its +\emph{orientation}. Choose a generator $\pi_{\mathfrak p}$ with divisor +$\mathfrak p$ outside $S_F$; class-group generation makes this possible. +Conjugation supplies the generator for the other orientation, and +\begin{equation}\label{gr:norm} + N_{F/\mathbf Q}(\pi_{\mathfrak p})=p u_{\mathfrak p}, + \qquad u_{\mathfrak p}\text{ a signed rational }S\text{-unit}. +\end{equation} +For $F=\mathbf Q$ use the rational generator $p$. A \emph{simple vertex} +is an inert rational prime in the quadratic case, with rational generator +$p$. The fixed label of a split vertex is its Frobenius on $F_S^{(2)}$; +simple vertices have rational fixed-support labels. A \emph{type} may +additionally record the generators' local squareclasses, valuation parities, +real signs, and prescribed finite ray conditions at $S_F$. Only compatible, +individually realizable types will be prescribed. A \emph{filter} fixes the +total rational labels and sign of the signed-prime product +$\prod_p p^*$, where $p^*=(-1/p)p$. + +For a pair of split vertices in the quadratic case there are two independent +forward bits: the residues of $\pi_{\mathfrak p}$ and +$\overline{\pi_{\mathfrak p}}$ at the chosen place of the other vertex. +Write quadratic residues additively in $\mathbf F_2$. Reverse bits are +determined by Hilbert reciprocity and the fixed types. Rational norm bits +are determined by summing the two oriented bits and the fixed correction +in \eqref{gr:norm}. When at least one endpoint is simple, or $F=\mathbf Q$, +there is one rational forward bit. Self-residues are never graph data. +An \emph{arithmetic graph} is this collection of vertices, types, and bits. +A split vertex is \emph{primary} when its generator is a square unit at +every finite place of $S_F$ and positive at all real places. +Different symbols may read compatible projections of the same graph, for +example its rational norm graph. Here compatibility means that the +projection forgets fixed-label coordinates or takes rational norm data, +carries primary vertices to primary vertices, and commutes with the +omitted-vertex product substitution. For the norm projection a single +oriented-bit toggle changes the rational bit once. We use these arithmetic +projections throughout. + +\begin{lemma}[Finite realization and product labels]\label{gr:realization} +Fix finitely many old vertices, with all their mutual data, and +individually realizable new types. Every prescription of the independent +forward bits involving at least one new vertex has a realization by +distinct fresh primes, avoiding an arbitrary finite set. The old vertices +and their mutual data remain unchanged. The same holds +with further fixed local tests included in $S$. A contracted split cluster +may be represented by the product of its oriented generators, with +conjugations prescribed along its contraction tree; its support types and +external residue bits are the corresponding sums. A cluster containing +one simple vertex has the corresponding rational product data. + +For a symbol satisfying the omitted-vertex dependence in +Proposition~\ref{co:symbol-interface}, its value depends only on the graph +data. Products in the preceding assertion may therefore be replaced by +fresh prime representatives without changing the prescribed contracted +symbol. +\end{lemma} + +\begin{proof} +First note that the listed generators account for all the relevant radicals. +If $U$ is a finite set of new primes and a squareclass has even valuations +outside $S_F\cup U_F$, divide by the generators at the primes of $U_F$ +where its valuation is odd. The result belongs to $V_S(F)$. At an inert +rational prime its rational generator has valuation one at the unique place +of $F$. Thus fixed-support labels and the displayed residue bits determine +every Frobenius test in an extension with this allowed ramification. + +We describe the prime selection carefully. For a new split vertex take a +template $\pi_0$ of its prescribed type, with prime ideal +$\mathfrak p_0$ away from the old vertices. Weak approximation gives +$a\in F^\times$ which is sufficiently close to $1$ at $S_F$, positive at +the prescribed real places, and has any prescribed nonzero residues at the +old prime ideals. Choose those residues so that $a\pi_0$ has the desired +quadratic residues there. Use the ray modulus consisting of sufficiently +deep powers of the primes of $S_F$, all old prime ideals, and the real +places. Choose a prime ideal $\mathfrak q$ in the ray class of +$(a)\mathfrak p_0$. Then +\[ + \mathfrak q=(a\beta)\mathfrak p_0, + \qquad \beta\equiv1\pmod{\text{ray modulus}}, +\] +and $\pi_{\mathfrak q}=a\beta\pi_0$ is the required generator outside $S_F$. +There are infinitely many such degree-one prime ideals. Indeed, the +prime-ideal theorem in a ray class gives order $X/\log X$ prime ideals of +norm at most $X$, whereas prime ideals of residue degree greater than one +contribute only $O(X^{1/2})$ in a quadratic field. Degree one gives a split +rational prime, and finite exclusions remove only finitely many choices. + +At an old inert prime with residue field $\mathbf F_{p^2}$, prescribe the +norm of the nonzero residue. The norm onto $\mathbf F_p^\times$ is +surjective, so either rational residue bit is possible. For a new simple +vertex the requirements are rational congruences, together with the inert +class in $F$. The Chinese remainder theorem and Dirichlet's theorem supply +fresh primes. Successively adjoining vertices proves simultaneous finite +realization. At every step reciprocity determines the reverse bits: +the local Hilbert symbols at the support are fixed, and the only other +contributions are the two endpoint residues. Taking norms gives exactly +\eqref{gr:norm}, so it imposes no additional independent bit. + +The same argument applies to a product template. Its valuations and local +squareclasses at $S_F$ are those of the product, and its residues at the +remaining vertices multiply. The ray-class construction replaces that +template by a degree-one prime with those data. In a simple cluster we +instead use rational congruences for the norm labels. No residue at a prime +inside the cluster is imposed on its replacement. + +In particular this preserves the rational filter, including its norm +correction. Write $\pi=\prod_i\pi_i$ for the oriented product template +and $\pi'=a\beta\pi$ for its fresh representative; $a\beta$ is a square unit at +$S_F$ and positive at its real places. The support valuations of $\pi'$ +and $\pi$ agree exactly. Hence +\[ + N\pi=(\prod_i p_i)u,\qquad N\pi'=q u +\] +with the same signed rational $S$-unit $u$: all its valuations and its +sign agree. The quotient $q/\prod_i p_i=N(a\beta)$ is a local square at +the rational support. Its squareclass at $2$ also identifies +$q^*$ with $\prod_i p_i^*$ at those fixed tests. Thus no free choice +of an untracked $S$-unit has entered a product replacement. + +Finally, compare two disjoint realizations with identical graph data. +Introduce fresh bridge vertices with matching bits to both realizations, +and replace vertices one at a time. At each replacement the omitted-vertex +elementary Frobenius tests agree, by the generator description in the first +paragraph. The symbol interface gives equal values. A preliminary bridge +removes any overlap between the original realizations. The same reasoning +applies to the product replacements. +\end{proof} + +Primary types are realized by the preceding construction, starting with the principal +ray class. Reciprocity makes their fixed radical labels trivial. Their +signed rational contributions are squares at the fixed rational tests. +If stationary vertices are also to have neutral incidences with an +auxiliary, include their primes among these local tests. In particular, +including the support of a fixed quadratic discriminant $k$ ensures that +every such primary auxiliary splits in $\mathbf Q(\sqrt{k})$. + +\subsection{The simultaneous-testing statement} + +Separate the given vertices into \emph{terminals} and, if present, +stationary external vertices. Terminals may be always present or may +have nonzero linear activations; external vertices have fixed types and +incidences throughout. At each nonzero address the symbol +is a function of the independent bits between the active terminals, with +those types and external data fixed. We call its unique multilinear +polynomial over $\mathbf F_2$ the \emph{terminal polynomial}. Its variables +describe formal changes of the terminal bits, while the prescribed prime +realization supplies a fixed evaluation point. + +For a bit $z$ define the finite difference +$\Delta_z f=f|_{z=0}+f|_{z=1}$. On a multilinear polynomial it is the +formal partial derivative. In particular, differences commute and +$\Delta_z^2=0$. + +\begin{definition}[Witnesses and permitted partitions]\label{gr:partitionable} +A \emph{witness} is a finite graph on which the +symbol is $1$. A graph is \emph{partitionable} for the symbol if its vertices +can be partitioned into nonempty clusters, each with at most one simple +vertex, with a choice of oriented contraction trees whose contracted graph +is a witness. +This definition includes a specified contraction certificate; it makes no +assertion about a Selmer group. +\end{definition} + +\begin{theorem}[Address lemma]\label{gr:address} +Suppose the binary symbols under consideration depend only on the +arithmetic graph data and satisfy the contraction, whole-rational-prime +omission, and primary-isolation rules of +Proposition~\ref{co:symbol-interface}, with the realization freedoms +of Lemma~\ref{gr:realization}. Contraction includes the product labels +and external incidences, and the zero rule for two simple vertices. +These identities are required only on nonempty configurations and for +contractions with nonempty output. +Fix $b\ge1$ and either of the following terminal arrangements. +\begin{enumerate} +\item One symbol, a nonempty set of always active terminals, and a +nonzero polynomial in their independent pair bits. +\item One or two symbols on terminals with nonzero linear activations, +including at least one terminal for every nonzero linear form. At each +$x\ne0$ each symbol separately is a nonzero polynomial in the active +terminal bits. The symbols may read different compatible projections +of a common graph alphabet and may have fixed stationary external data. +\end{enumerate} +Suppose also that at each nonzero address the total active terminal data, +together with any stationary external data, obey the required filter. +Starting from any fixed realization of the terminal and stationary +vertices, one can adjoin finitely many fresh primary auxiliary vertices, +activated by nonzero linear forms, and choose only incidences involving +these new vertices so that every symbol equals $1$ at every $x\ne0$. +All data on the original vertices remain unchanged. No auxiliary is +present at $0$. All auxiliaries may satisfy the fixed splitting and +neutral external-incidence conditions incorporated into the primary type. + +It is enough that a terminal polynomial have a nonzero evaluation or +a nonzero iterated edge difference. In particular a partitionability +certificate suffices for the stationary hypothesis. +\end{theorem} + +The proof has two algebraic steps. Forests of auxiliary vertices act as +finite-difference operators on the original terminal polynomial. We then +build networks whose degree-one terms select a chosen derivative at a +single address. Applying them to top-degree coefficients will give the +simultaneous value $1$, independently of the fixed terminal bits. + +\subsection{From arithmetic contraction to forest operators} + +\begin{lemma}[Oriented forests]\label{gr:forest} +Assume the graph-symbol rules stated in Theorem~\ref{gr:address}. +Differentiation in a tree of graph +bits contracts the tree, adding product labels and external incidences; +its value is zero if the tree contains two simple vertices. Differentiation +in any collection of edge variables containing a cycle is zero, even when +different edges use incompatible relative orientations. Two different +oriented variables on the same pair count as a cycle of length two. +\end{lemma} + +\begin{proof} +The one-edge assertion is precisely the arithmetic contraction rule, +with product replacements justified by Lemma~\ref{gr:realization}. +Induction proves the tree assertion: a split--split merger is split, a +split--simple merger is simple, and the first merger of two components +containing simple vertices has zero derivative. Along a tree there is +a unique choice of relative orientations once one root orientation is +fixed. Its product template depends on support types and external bits, +not on the internal bits being differentiated. + +For clarity, consider first the two variables on a split pair $p,q$. +Differentiation in the inertia bit at one place over $p$ gives the symbol +formed with the \emph{entire rational prime $p$ omitted}. Its elementary +extension is unramified at both places over $p$. Differentiating in the +other oriented bit is therefore zero. Repetition of the same variable +is zero by $\Delta_z^2=0$. This argument would not follow from omission +of only one oriented prime ideal. + +For a longer cycle, first contract a spanning path. By the product-label +rule the closing variable has become internal to the merged cluster. +Its change affects neither the product's support data nor any incidence +to a remaining vertex. Equivalently it is an inertia change at an omitted +endpoint, covered by the preceding unramifiedness argument. Thus its +derivative vanishes. Possible conjugation of the product generator only +changes the induced orientation and does not reintroduce that endpoint. +Since there is no self-residue among the inputs to the replacement symbol, +there is no extra closing-edge datum to retain. Additional derivatives +commute with this zero derivative. + +For example, contract the aligned edge $12$ in a triangle. With +$\pi_{12}=\pi_1\pi_2$, the two bits toward vertex $3$ are +$t_0=z_{13}^0+z_{23}^0$ and $t_1=z_{13}^1+z_{23}^1$, up to fixed +type corrections. An aligned edge $23$ then differentiates $t_0$; +a conjugately aligned closing edge $31$ differentiates $t_1$. +Their mixed derivative is the omitted-endpoint zero just proved. +If the closing edge is aligned instead, both become the same +difference and its square is zero. Contracting a longer spanning +path reduces to exactly these two alternatives. +\end{proof} + +Fix a realizable baseline terminal graph and let $P$ be its terminal +polynomial. A \emph{network} consists of additional primary +vertices and programmed edges, with no direct terminal--terminal edges. +All unprogrammed incidences of its primary vertices are neutral. Within +one network choose one orientation at each terminal and consistently use +the corresponding edge alignment. Networks may choose different +alignments. The \emph{degree} of a contraction is the number of terminal +vertices it removes by merging them. + +\begin{lemma}[Network expansion and its first two degrees]\label{gr:network} +A network acts on $P$ by a sum of finite-difference operators. A surviving +term is a forest in which every component containing a primary vertex +meets a terminal. A component meeting $t$ terminals acts by a contraction +of degree $t-1$; a component containing two simple terminals is zero. +Networks on disjoint sets of internal vertices, with no edges between +those sets, multiply as operators on the same terminal polynomial. +Consequently an operator of degree greater than $\deg P$ annihilates $P$. + +Let $Q$ be the grounded Laplacian on the internal vertices: $Q_{ij}$ for +$i\ne j$ records the internal edge $ij$, while $Q_{ii}$ is the total +incidence at $i$, including its terminal edges. Let $(c_a)_i$ record the +incidence from internal vertex $i$ to terminal $a$. All entries are in +$\mathbf F_2$. The constant and pair-contraction coefficients of the +operator are respectively +\begin{equation}\label{gr:forest-coefficients} + \det Q,\qquad c_a^{\mathsf t}\operatorname{adj}(Q)c_b\quad(a\ne b). +\end{equation} +The second coefficient multiplies the terminal difference in the alignment +selected by the network. A prohibited pair multiplies the zero operator. +\end{lemma} + +\begin{proof} +Expand the evaluation at the programmed incidences from the graph with +all primary incidences zero. For a set $E_0$ of programmed bits this is +the elementary identity +\[ + f(\mathbf1)=\sum_{T\subseteq E_0}(\Delta_T f)(\mathbf0). +\] +Lemma~\ref{gr:forest} kills cyclic $T$. A tree component meeting no +terminal contracts to an isolated primary vertex, and the isolation rule +kills it. This includes an untouched primary vertex. In any remaining +component all primary labels are trivial and all external primary bits +at the expansion baseline are zero. Its contracted label and its +incidences are exactly those obtained by contracting its terminal +vertices in the original graph. Choose any terminal tree inducing its +relative orientations; the corresponding terminal differences therefore +give the same value. Its degree is the number of lost terminal vertices, +namely $t-1$. This establishes the operator interpretation, rather than +merely a count of possible contraction degrees. + +Expanding two disjoint networks at once gives the composition of these +operators: the product-label rule gives the same final labels in either +order, and any cycles created between networks vanish by +Lemma~\ref{gr:forest}. Ordinary polynomial differentiation now proves +the asserted degree bound. + +This argument also explains the compatible projections. Taking norms +commutes with every oriented product in a forest; primary factors have +neutral norm corrections, and each programmed oriented toggle projects +to its one rational toggle. Thus the projected forest acts by the +corresponding differences on the projected \emph{original} terminal +polynomial at every degree. If projected differences repeat an edge +or merge two simple clusters, that term is zero. Forgetting fixed-label +coordinates plainly commutes with the same products. Each projected +network therefore acts on the original projected terminal polynomial. + +The determinant counts are instances of the all-minors matrix-tree +theorem \cite[\S1]{Chaiken1982}. We give the Cauchy--Binet proof +in the form needed here, including singular $Q$. Let $I$ +be the internal vertex set and $A$ the terminal set. Write the full +Laplacian as $L=DD^{\mathsf t}$, where a column of the incidence matrix +$D$ has ones at its edge's endpoints. Cauchy--Binet applied to +$L_{I,I}=Q$ counts edge sets whose incidence matrix with the terminal +rows deleted is invertible. Such an edge set is a forest with exactly +one terminal in each component: a cycle gives dependent columns; a +component with no deleted row gives dependent rows; and for a tree with +one row deleted, leaf removal proves invertibility. These are exactly +the degree-zero terms. + +For the pair coefficient apply Cauchy--Binet with row set $I\cup\{a\}$ +and column set $I\cup\{b\}$. Each counted forest has one root from +$A\setminus\{a\}$ and one from $A\setminus\{b\}$ in each component. +This requires that $a,b$ lie together and that every other terminal lie +in its own component. The corresponding Laplacian minor is +\[ + \det\begin{pmatrix}Q&c_b\\c_a^{\mathsf t}&0\end{pmatrix} + =c_a^{\mathsf t}\operatorname{adj}(Q)c_b. +\] +The corner is zero because the network has no direct terminal edge; +signs disappear in characteristic two. The determinant identity uses +the adjugate and so remains valid when $Q$ is singular. +\end{proof} + +\subsection{Two networks which select one address} + +Fix a nonzero target $x_*$ and a terminal bit $z$ joining two terminals +$a_0,a_1$ active at $x_*$. In the +moving case assume that some terminal has each nonzero activation form; +in the stationary case all terminals are always present. + +Choose a basis $\lambda_1,\ldots,\lambda_b$ of the dual space with +$\lambda_i(x_*)=1$ for every $i$. To obtain it, choose $\lambda_1(x_*)=1$ +and replace a basis $\mu_2,\ldots,\mu_b$ of the annihilator of $x_*$ by +$\lambda_1+\mu_2,\ldots,\lambda_1+\mu_b$. +Make $b$ groups of three primary vertices, group $i$ activated by +$\lambda_i$. Since these forms are a basis, all groups are present +exactly at $x_*$. At every other address at least one group is absent. +In each physical three-dimensional vertex space choose +a basis $(e_i,u_i,v_i)$ with $e_i=(1,1,1)$. Thus the physical coordinate +change is block diagonal by groups. + +Prescribe a symmetric bilinear form $Q$ by making the $e_i$ orthonormal +and orthogonal to all $u_j,v_j$, and putting on the remaining coordinates +\begin{equation}\label{gr:H} + H(T,B)=\begin{pmatrix}0&T\\T^{\mathsf t}&B\end{pmatrix}. +\end{equation} +Matrix entries in the physical coordinates are denoted by the same +letter $Q$. For a subset $J$ of active groups, $Q_J$ means its physical +principal restriction. Define the column $h_i=Qe_i$. +It is supported on group $i$: in adapted coordinates it is the covector +dual to $e_i$, and the coordinate change does not mix groups. Its value +is independent of $T$ and $B$. + +Attach $h_i$ to an anchor terminal with activation $\lambda_i$. In the +stationary case attach it to any fixed terminal instead. The support +property gives, on every address, +\[ + \sum_{i\in J}h_i|_J=Q_J\mathbf1_J. +\] +Program internal edges using the off-diagonal +physical entries of $Q$. A matrix is their grounded Laplacian precisely +when the sum of the terminal incidence columns is its row-sum vector, +so these anchor columns give exactly $Q_J$, including its diagonal. + +We shall also attach the same additional column $c$ to $a_0$ and $a_1$. +In the moving case with distinct activation forms $\alpha,\beta$, attach +$c$ also to a terminal of activation $\alpha+\beta$; this terminal is +inactive at $x_*$. If $\alpha=\beta$, no third column is needed. The +sum of the additional active columns is zero at every address, since +$\alpha+\beta+(\alpha+\beta)=0$. In the stationary case the two columns +cancel directly. Coincident terminal roles mean addition of their +columns. This preserves the prescribed grounded matrix after every +restriction. + +For a concrete instance, take $b=1$, target $x_*=1$, and two always-active +split terminals $a_0,a_1$ with selected bit $z$. Label the three primary +vertices $1,2,3$, all activated by $x$. Choose +$e=(1,1,1)^{\mathsf t}$, $u=(1,0,0)^{\mathsf t}$, +$v=(0,1,0)^{\mathsf t}$, and $T=(0)$, $B=(1)$. +The form in this adapted basis is $\operatorname{diag}(1,0,1)$. +In physical coordinates $h=Qe=(0,0,1)^{\mathsf t}$ and the covector +dual to $u$ is $c=(1,0,1)^{\mathsf t}$. Using $a_0$ as the anchor gives +\[ + Q=\begin{pmatrix}0&0&0\\0&1&1\\0&1&0\end{pmatrix},\qquad + c_{a_0}=h+c=\begin{pmatrix}1\\0\\0\end{pmatrix},\qquad + c_{a_1}=c=\begin{pmatrix}1\\0\\1\end{pmatrix}. +\] +Thus the programmed graph is the path +$a_0\! -\! 1\! -\! a_1\! -\! 3\! -\! 2$. +Here $\det Q=0$ and $\operatorname{adj}(Q)=uu^{\mathsf t}$, so +$c_{a_0}^{\mathsf t}\operatorname{adj}(Q)c_{a_1}=1$. +There are only two terminals, so no higher contraction degree occurs: +the network acts exactly by $\Delta_z$ at $1$. At $0$ all three primary +vertices are absent, and the network acts by the identity. + +Write $O_{\ge d}$ for a sum of contraction operators of degrees at least +$d$; it is a filtration notation, not an estimate. + +\begin{lemma}[The two address programs]\label{gr:programs} +With the preceding grounding convention one has the following programs +for every $b\ge1$. +\begin{enumerate} +\item A network $\mathcal S$ with +\[ + \mathcal S_{x_*}=\Delta_z+O_{\ge2},\qquad + \mathcal S_x=1+O_{\ge1}\quad(x\ne x_*). +\] +\item Two networks on the same activated sites, indexed by +$\varepsilon\in\mathbf F_2$, with +\[ + \mathcal N_x^{(\varepsilon)}=1+O_{\ge1},\qquad + \mathcal N_x^{(1)}+\mathcal N_x^{(0)} + =\begin{cases}\Delta_z+O_{\ge2},&x=x_*,\\ + O_{\ge2},&x\ne x_*. + \end{cases} +\] +\end{enumerate} +All nonzero-activation sites are absent at $0$. Unspecified incidences, +including those to stationary external vertices, may remain neutral. +\end{lemma} + +\begin{proof} +For the first program take $T=I+P$, where $P$ is the cyclic permutation +matrix on $b$ coordinates, and $B$ diagonal with exactly one nonzero +entry. A proper principal group restriction of $P$ is a union of +directed paths, hence nilpotent. Thus $T_J$ is invertible for every +proper $J$, and so is $H(T_J,B_J)$: its kernel equations first give +$v=0$ and then $u=0$. This includes the empty restriction, whose +determinant is $1$. + +On the full group set, both $\ker T$ and $\ker T^{\mathsf t}$ are +spanned by the all-one vector. A radical vector of $H$ has +$v=t\mathbf1$; summing the equation $T^{\mathsf t}u+Bv=0$ gives $t=0$ +because $\mathbf1^{\mathsf t}B\mathbf1=1$. Thus the full $Q$ has +one-dimensional radical spanned by $r=\sum_i u_i$. In characteristic +two its adjugate is $rr^{\mathsf t}$. Indeed a rank-$n-1$ matrix has a +nonzero rank-one adjugate with image its kernel; symmetry identifies +the two factors, and the only nonzero scalar is $1$. +Choose $c$ to be the covector dual to $u_1$, so $c^{\mathsf t}r=1$. +All anchors pair to zero with $r$. At $x_*$ the only columns pairing +nontrivially with $r$ are consequently those of $a_0,a_1$. Formula +\eqref{gr:forest-coefficients} gives zero constant and exactly +$\Delta_z$ in degree one. At every other address the group subset is +proper and the constant is $1$. When $b=1$, $I+P=0$ and $B=(1)$, +so the same radical calculation applies without an exception. + +For the second program let $T=I+L$, where $L$ is the consecutive lower +shift, and take $B_\varepsilon=\varepsilon E_{bb}$. Every group +restriction of $T$ is invertible, and block multiplication gives +\begin{equation}\label{gr:inverse} + H(T,B)^{-1}= + \begin{pmatrix}T^{-\mathsf t}BT^{-1}&T^{-\mathsf t}\\ + T^{-1}&0\end{pmatrix}. +\end{equation} +Again take $c$ dual to $u_1$. On a group subset $J$, the change of +$c^{\mathsf t}Q_J^{-1}c$ is +\[ + \bigl((T_J^{-1})_{b1}\bigr)^2, +\] +interpreted as zero if $1$ or $b$ is absent. Since +$(I+L_J)^{-1}=I+L_J+L_J^2+\cdots$, that entry is $1$ precisely when +the entire path $1,2,\ldots,b$ is present. This is exactly the target +address. Pairings involving an anchor do not change: +$Q_J^{-1}h_i=e_i$, and the vectors $e_i,h_i,c$ do not depend on +$\varepsilon$. At the target the balancing terminal is absent, so +the only changed pair coefficient is the one for $a_0,a_1$. +Every constant is $1$. Lemma~\ref{gr:network} proves the claims, +including $b=1$, when the path consists of its single vertex. +\end{proof} + +\subsection{Proof of the address lemma} + +\begin{proof}[Proof of Theorem~\ref{gr:address}] +Use the prescribed realization of the terminal and stationary vertices +as a common baseline for all terminal bits. Regard +their toggles as common variables, omitting variables invisible to a +given symbol. A nonzero iterated difference implies that the polynomial +is nonzero. Conversely, the unique multilinear polynomial of a +nonzero function has a top monomial with nonzero coefficient. These +observations also explain the last assertion using +Lemma~\ref{gr:forest}. +Every nonzero address has an active terminal, and contractions never +remove the last vertex. Thus only nonempty configurations are used. + +First consider one symbol. At each $x\ne0$ let $P_x$ have degree $d_x$ +and choose a monomial with coefficient $1$ in its top homogeneous part. +For each variable of this monomial add a separate singular program +$\mathcal S$ targeted at $x$. Give all these networks disjoint internal +vertices. At address $x$, its own $d_x$ networks each have zero constant, +so every surviving term spends at least $d_x$ contraction degrees. +An extra degree from any network kills $P_x$. Thus only the designated +degree-one contractions of its own networks and the constant terms +of all other networks survive. Their value is the chosen top +coefficient, namely $1$. A nonzero constant polynomial needs no +network and already has value $1$. This argument applies equally to +always active terminals, since Lemma~\ref{gr:programs} supplies their +stationary anchors. + +For two symbols write their polynomials at address $x\ne0$ as +$P_x,R_x$, of degrees $d_x,e_x$, and let $P_x^{\rm top},R_x^{\rm top}$ +be their top homogeneous parts. Multiply these parts in the ordinary +polynomial ring +$\mathbf F_2[z_1,\ldots,z_m]$, \emph{before} imposing any Boolean +relations. That ring is an integral domain, so choose a coefficient +equal to $1$ at a monomial +\begin{equation}\label{gr:chosen-monomial} + M_x=\prod_z z^{\nu_{xz}},\qquad + \nu_{xz}\in\{0,1,2\},\qquad + \sum_z\nu_{xz}=d_x+e_x. +\end{equation} +For $\nu_{xz}=2$ add one singular program for $z$ targeted at $x$. +For $\nu_{xz}=1$ add one nonsingular program for $z$ targeted at $x$, +with its own choice $\varepsilon_{xz}\in\mathbf F_2$. All internal +vertices of different programs are disjoint. Let +\[ + \Phi(\varepsilon)=\prod_{x\ne0} + \bigl(\text{final evaluation of }P_x\bigr) + \bigl(\text{final evaluation of }R_x\bigr). +\] +We prove that the sum of $\Phi$ over all choices of $\varepsilon$ is $1$. +This proves that some single choice has all the required evaluations +equal to $1$. + +Expand every program in contraction degree using +Lemma~\ref{gr:network}. A singular program targeted at $x$ has zero +constant in both factors there, so it costs at least one degree in +$P_x$ and one in $R_x$. A nonsingular program has constant $1$ +independent of its choice. In the sum over that choice, a term using +only its constants in all factors cancels. Every remaining term must +therefore spend at least one degree somewhere for this program. The +sum of these minimum costs is exactly +\begin{equation}\label{gr:budget} + D=\sum_{x\ne0}(d_x+e_x), +\end{equation} +by \eqref{gr:chosen-monomial}. A nonzero term cannot exceed this total: +if it did, some factor would receive more differences than its degree. +Hence every surviving term uses every minimum cost exactly. + +It follows that a singular program spends exactly one degree in each +factor at its target and zero elsewhere. Its degree-one term there +is precisely $\Delta_z$. Each nonsingular program spends exactly one +degree in exactly one factor. After summing its choice, that +degree-one contribution is zero away from its target, and is +$\Delta_z$ at its target. All other occurrences of these programs +contribute their common constant $1$. Thus no unknown higher forest +coefficient enters the surviving calculation. + +At a fixed address, let $Z_2$ be the variables with exponent two and +$Z_1$ those with exponent one. The local allocation sum is +\[ + \sum_{J\subseteq Z_1} + [z_{Z_2}z_J]P_x^{\rm top}\, + [z_{Z_2}z_{Z_1\setminus J}]R_x^{\rm top} + =[M_x](P_x^{\rm top}R_x^{\rm top})=1. +\] +Coefficients of the wrong degree in this display are zero. Every +factor must in fact receive its full degree, since the total is $D$ +and none can exceed its own degree. Therefore its final derivative +is exactly the displayed top coefficient, independent of the chosen +baseline values. Allocations at different addresses are independent, +so their product is $1$, as asserted. This also covers a constant +factor, whose degree is zero. For example, when both top forms are +$z$, their ordinary product is $z^2$ and the singular program +differentiates each factor once; Boolean reduction would lose this +allocation. + +In the two-symbol case, choose the program parameters for which +$\Phi=1$. In either case, apply Lemma~\ref{gr:realization} to adjoin +the resulting finite networks to +the fixed original vertices. Only new vertices and incidences involving +them have been prescribed. The primary types preserve the filters. +All activations are nonzero linear forms, +so no new vertex appears at $0$, and the stipulated neutral and +splitting conditions persist. +\end{proof} + +The theorem is finite for each $b$; it does not assert a single infinite +array of primes. For a stabilized symbol, first choose $b$, its finite +terminal data, and all the networks above. Their total weight and the +list of coefficient tests are then finite. A sufficiently advanced +stage at which the symbol interface holds for that weight range +realizes the construction. Required precision and the number of +auxiliaries may grow with $b$. The arithmetic valuation constant +attached to a unit symbol must still be supplied by the coefficient +construction independently of $b$; no determinant or forest count in +this section proves that uniformity. diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/introduction.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..792eab3c00737a168b001b2d46645f309c78420f --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/introduction.tex @@ -0,0 +1,173 @@ +\section{Introduction}\label{sec:introduction} + +The Birch--Swinnerton-Dyer conjecture predicts that the order of vanishing +of the $L$-function of an elliptic curve equals its Mordell--Weil rank, +and that its Shafarevich--Tate group is finite; its refined form also +specifies the leading coefficient \cite{BirchSwinnertonDyer1965,Tate1966}. +For analytic order zero or one, the rank equality and finiteness are +theorems of Gross--Zagier and Kolyvagin +\cite{GrossZagier1986,Kolyvagin1990}. +The converse problem begins with algebraic information and seeks the +corresponding analytic order. + +The appropriate algebraic hypothesis here is the corank of the full +$2$-power Selmer group. It records a possible divisible contribution +from the Shafarevich--Tate group as well as the Mordell--Weil rank. +With the usual local Kummer conditions, put +\[ +s_2(E)=\corank_{\Z_2}\Sel_{2^\infty}(E/\Q). +\] +Our main result is the following pointwise statement. + +\begin{theorem}[The rational-two-torsion $2$-converse]\label{thm:main} +Let $E/\Q$ be an elliptic curve with $E(\Q)[2]\ne0$ and +$s_2(E)\in\{0,1\}$. Then +\[ +\ord_{s=1}L(E,s)=\rank_{\Z}E(\Q)=s_2(E), +\qquad +\Sha(E/\Q)\text{ is finite}. +\] +\end{theorem} + +The statement includes one rational two-torsion line and full rational +two-torsion, CM and non-CM curves, every rational isogeny configuration, +and every reduction type at $2$ and at the bad primes. It is a +$2$-converse in this residual range. It does not assert the full +Birch--Swinnerton-Dyer leading-coefficient formula, nor does a bound +$\rank E(\Q)\le1$ alone imply its Selmer hypothesis. + +The broader companion \cite[Theorem~1.1]{OpenAIGoldfeldTwoConverse2026} +proves the $2$-converse without the rational-two-torsion hypothesis. +Here we give a separate full treatment of the rational-two-torsion case, +developing its integral interpolation and finite twist constructions +within this paper; the broader converse is not an input to the proof. + +The converse with the stronger hypotheses +$\rank E(\Q)=1$ and $\Sha(E/\Q)$ finite is known for every +elliptic curve over $\Q$; see \cite[\S1]{Kim2023SoftConverse}. +The fixed-prime problem asks instead whether a low Selmer corank +alone forces the analytic order. Skinner and Wei Zhang established +general rank-one converses at good ordinary odd primes under residual +and local hypotheses \cite{Skinner2020,Zhang2014Heegner}. +For odd Eisenstein primes, Castella, Grossi, Lee and Skinner prove +the good-reduction converse under a local-character restriction +\cite[Theorem~E]{CGLS2022}; Keller and Yin treat potentially good +ordinary reduction without that restriction +\cite[Theorem~B]{KellerYin2024}. Smith's theorem gives the $50/50$ +distribution of $2^\infty$-Selmer coranks in every fixed quadratic-twist +family, counting twist parameters of both signs \cite{Smith2025}; +this density statement does not decide a prescribed member. + +The CM case includes pointwise results at the prime $2$. +Burungale and Tian prove the rank-zero $p$-converse for CM curves at +every prime \cite{BurungaleTian2026}. In rank one, Burungale and +Skinner treat good ordinary primes and, with a localization hypothesis, +good supersingular primes +\cite[Theorems~A.1 and~A.3, Remark~A.5]{BurungaleSkinner2024Appendix}. +The earlier ordinary CM converse of Burungale, Castella, Skinner and +Tian retains a Hecke-conductor condition +\cite{BurungaleCastellaSkinnerTian2022}. +Kriz's preprint gives rank-zero and rank-one converses for maximal-order +CM curves at primes ramified in the CM field, including the pointwise +$2$-converse for the congruent-number family +\cite[Theorems~1.1 and~10.17(2)]{Kriz2022CM}. +These results already treat individual curves in their stated ranges; +the theorem here includes non-CM curves with rational two-torsion and +imposes no reduction condition at $2$. + +The proof brings together two arithmetic interpolation constructions and a +finite construction with quadratic twists. Kato's zeta classes provide +the cyclotomic input \cite{Kato2004}; Ferrero--Washington's +vanishing theorem controls the residual cyclotomic cohomology +\cite{FerreroWashington1979}. Heegner points and their derivative +classes provide the ring-class input, following the Euler-system method +of Kolyvagin and its cohomological formulation by Howard +\cite{Kolyvagin1990,Howard2012}. We retain integral local conditions and +duality maps in the framework of Selmer complexes \cite{Nekovar2006}. +The coefficient tests use the half-integral weight theory of Shimura +and Waldspurger's relation between coefficients and central values +\cite{Shimura1973HalfIntegral,Waldspurger1981}. Their ternary theta +construction lies in the definite quaternion framework developed by +Gross \cite{Gross1987Heights}; we use the Weil representation and the +reduction description of Jetchev and Kane for the weighted Heegner-point +tests \cite{Weil1964,JetchevKane2010}. +Each of these inputs has a precise role; none supplies the pointwise +conclusion by itself. + +Here is the common interpolation problem. Fix the curve that is to be +tested, and index a finite family of quadratic twists by +$x\in\mathbb F_2^b$, with $x=0$ denoting that curve. Each auxiliary +prime divides the twist parameter according to a linear form in $x$. +We construct these families so that every nonzero address has the +required analytic order and a uniform normalized valuation bound. +An integral interpolation argument then recovers the value or derivative +at the missing address $0$. The number and sizes of the auxiliary +primes may grow with $b$; the valuation bound may not. + +For Selmer corank zero, the required nonzero values are central +$L$-values. Their normalized valuations are measured by coefficients +of half-integral weight forms. The cyclotomic determinant makes these +values part of one integral family, and a congruence on a sufficiently +large binary cube recovers the missing value. This also supplies the +even estimate needed to normalize the rank-one construction. + +The rank-one construction requires a further preparation. Fix a negative +quadratic discriminant $h_*$ with $L(E^{(h_*)},1)\ne0$. +For positive $h$ in the prescribed local squareclasses, the +genus-character Heegner sum $P_h$ attached to $\Q(\sqrt{hh_*})$ +detects a simple zero of $E^{(h)}$: its height measures +$L'(E^{(h)},1)L(E^{(h_*)},1)$. To normalize the corresponding coefficient tests +uniformly, we first bound the $2$-divisibility of $P_h$ from below +in terms of the prime factors of $h$, with a constant independent +of their number. +For each parameter $h$ of known analytic rank one, a different negative companion +$k'(h)$, with a bounded number of prime factors, combines the even +estimate with a ring-class lower bound to give this uniform bound. +Only after that argument do we normalize the odd coefficients and use +their minimum-depth values as binary nonvanishing tests. + +For the return to a prescribed corank-one curve, choose one final +negative discriminant $k$ with $L(E^{(k)},1)\ne0$, and fix +$K=\Q(\sqrt{k})$. This companion does not vary with $h$ or with the +cube dimension. The quadratic corank identity gives $s_2(E/K)=1$. +We construct families with every new prime split in $K$ for which, +at every nonzero address, $E^{(h)}$ has a simple zero and $E^{(hk)}$ +has nonzero central value. The two coefficient tests together bound +the normalized index of the ring-class Heegner sum over $K$. +Ring-class interpolation then recovers the derivative at $h=1$. +Thus $h_*$ defines the detector, $k'(h)$ proves its lower bound, +and the fixed $k$ permits the final transfer. + +The arithmetic difficulty is uniform integral control at the prime $2$. +Residual irreducibility is unavailable here. On the cyclotomic side we +use Kato classes from one fixed modular-form lattice, separating rational +divisibility from uniform integrality. On the ring-class side we retain +the full integral Kummer conditions at the bad places and actual maps +from finite free models to Galois cochains. Heegner derivative operations +preserve the determinant valuation even when a localized class is +divisible by $2$. These constructions give the missing-vertex +Theorems~\ref{cy:missing-vertex} and~\ref{rd:missing-vertex}. + +The finite construction has a different task: it must make the required +coefficient tests nonzero at every nonzero address simultaneously. +The variables are quadratic residue symbols between auxiliary primes. +Changing one such symbol contracts two prime labels; repeated changes +are governed by forests. Finite networks of new primes then isolate +one address at a time. For rank one, the derivative test and its +central-value partner may be separately nonzero without taking nonzero +values on the same assignment of residue symbols. Theorem~\ref{gr:address} +adjoins prime networks making both tests equal to $1$ at every nonzero +address. + +Figure~\ref{fig:proof-roadmap} records the order in which the valuation +bounds are obtained and used. Section~\ref{sec:preliminaries} fixes the +Selmer and local conventions. Section~\ref{cy:section} proves the +cyclotomic interpolation statements; Sections~\ref{rl:section} +and~\ref{rd:section} construct the ring-class deformation and prove its +bounds and transfer theorem. Section~\ref{sec:nonvanishing} supplies +auxiliary twists with prescribed local behavior and a bounded number of +prime factors where needed. Sections~\ref{co:section} +and~\ref{gr:section} give the coefficient tests and finite networks. +Section~\ref{pw:section} assembles these results at the prescribed curve. + +\input{sections/proof-roadmap-figure} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/nonvanishing.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/nonvanishing.tex new file mode 100644 index 0000000000000000000000000000000000000000..c06489d567e33b153e9401142996173be959149f --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/nonvanishing.tex @@ -0,0 +1,425 @@ +\section{Auxiliary twists with prescribed local behavior}\label{sec:nonvanishing} + +We need auxiliary twists with specified local behavior and nonzero +central value or derivative. For a fixed witness, no bound on the prime +count is needed. When the curve itself varies, we also need central-value +witnesses with a uniformly bounded number of prime factors. In both cases +their primes can be chosen beyond any previously specified finite set. + +\begin{proposition}[Local witnesses]\label{nv:local-witness} +Fix an elliptic curve $A/\Q$ and a nonempty filter of fundamental +discriminants prime to $2N_A$, with specified real sign and unit +squareclasses at finitely many primes. If the root number in the filter +is $+1$, it contains $d$ of arbitrarily large absolute value with +$L(A^{(d)},1)\ne0$. +If the root number is $-1$, it contains such $d$ with +$L'(A^{(d)},1)\ne0$. Any additional finite set of primes may be excluded. +\end{proposition} + +\begin{proposition}[Bounded-factor completion]\label{nv:rough} +There is an absolute integer $A_0$ with the following property. +In the positive-root-number case of Proposition~\ref{nv:local-witness}, +one can require $\omega(d)\le A_0$ and require every prime divisor of +$d$ to exceed any fixed bound. +The size threshold for the resulting $d$ may depend on the curve, the +filter, and the excluded primes; $A_0$ does not. +\end{proposition} + +The use of a nonnegative first moment and a lower linear sieve to obtain +bounded-factor twists goes back to Hoffstein--Luo +\cite[\S2]{HoffsteinLuo1997}. We retain an arbitrary fixed progression +and track an absolute factor-count bound without optimizing it. +The central moment follows the model of +\cite[Proposition~2]{RadziwillSoundararajan2015}, which has a sharper +divisor error; the derivative calculation adapts the first-moment +argument of \cite{Iwaniec1990}. The enlarged modulus and the absolute +exponents needed here are retained in the proof below. + +A nonzero first moment alone supplies the derivative witness. For the +central-value completion, positivity allows us to sieve the first +moment, so we also need an error term for each prescribed squarefree +divisor of the twist parameter. + +Write $f$ for the weight-two newform of $A$, normalized so that its +central point is $1/2$, and write $\lambda(n)$ for its normalized Hecke +eigenvalues. Thus +\[ +L(s,f\otimes\chi)=\sum_{n\ge1}\lambda(n)\chi(n)n^{-s}, +\qquad |\lambda(n)|\le d(n). +\] +Choose $H$ divisible by $8N_A$, a reduced residue class $a\bmod H$, and +$\sigma\in\{1,-1\}$ such that $\sigma a\equiv1\bmod4$. +The required twists have discriminant $\sigma n$ with +$n>0$ squarefree and $n\equiv a\bmod H$. A filter is a finite union of +such progressions, so it suffices to use one of them. Fix a nonnegative +smooth nonzero $\Phi$ supported in $(1,2)$. + +\begin{lemma}[A fixed-progression moment]\label{nv:moment} +There are absolute constants $\eta>0$ and $B>0$ such that the +following assertions hold. For squarefree $b$ prime to $H$, put +\[ +S_{j,b}(X)= +\sum_{\substack{n>0\ {\rm squarefree}\\ n\equiv a\ (H)\\b\mid n}} + L^{(j)}(1/2,f\otimes\chi_{\sigma n})\Phi(n/X). +\] +If the common root number is $+1$, then +\[ +S_{0,b}(X)=cX\prod_{p\mid b}\beta_p+ + O_{f,H,\Phi}(b^B X^{1-\eta}), +\qquad +c>0,\quad 0<\beta_p<1,\quad +\beta_p=\frac1p+O(p^{-2}). +\] +The last implied constant is absolute. If the common root number is +$-1$, then +\[ +S_{1,1}(X)=cX\log X+c_1X+ + O_{f,H,\Phi}(X^{1-\eta}),\qquad c>0. +\] +\end{lemma} + +\begin{proof} +We first control the square-divisor tail, then use Poisson summation to +separate a positive main term from a power-saving error. Tracking the +dependence on the imposed divisor $b$ will give the absolute exponents. +Let $G(z)=e^{z^2}$ and +\[ + V_j(y)=\frac1{2\pi i}\int_{(2)} + G(z)\Gamma(1+z)y^{-z}\frac{dz}{z^{j+1}}. +\] +Writing $Q_A=\sqrt{N_A}/(2\pi)$, the symmetric approximate functional +equation in the required sign is +\begin{equation}\label{nv:afe} +L^{(j)}(1/2,f\otimes\chi_{\sigma n}) +=2\sum_{u\ge1}\frac{\lambda(u)\chi_{\sigma n}(u)}{\sqrt u} + V_j\!\left(\frac{u}{Q_A n}\right). +\end{equation} +For $j=1$, differentiating the completion contributes no central-value +term, because that value is zero. + +\par\smallskip\noindent\emph{Square-divisor truncation.} +The quadratic large sieve +\cite[Theorem~1 and Corollary~1]{HeathBrown1995}, with the approximate functional equation, +gives for fixed $\delta>0$ +\begin{equation}\label{nv:second} + \sum_{\substack{0Y$, +and their multiplicity is at most the divisor count of $v$. +Let $L^{(v)}(s,f\otimes\chi_{\sigma t})$ be the primitive-twist +$L$-function with its Euler factors at primes dividing $v$ removed. +For $0<\delta_{\mathrm M}<\rho/8$, Mellin inversion gives +\[ + \mathcal A_j(tv^2)=\frac{2}{2\pi i} + \int_{(\delta_{\mathrm M})} + G(z)\Gamma(1+z)(Q_Atv^2)^z + L^{(v)}(1/2+z,f\otimes\chi_{\sigma t}) + \frac{dz}{z^{j+1}}. +\] +Choose the large-sieve and divisor exponents smaller still. +On this line the removed Euler +factors cost an arbitrarily small fixed power of $v$. Cauchy's +inequality and Equation~\eqref{nv:second} give, for suitably small +$\rho'>0$, +\[ + \sum_{t\le2X/v^2}^{\!*} + |L(1/2+\delta_{\mathrm M}+i\tau,f\otimes\chi_{\sigma t})| + \ll_{f,\rho',\delta_{\mathrm M}} + (X/v^2)^{1+\rho'}(1+|\tau|)^C, +\] +where the star retains the primitive discriminant conditions. +The gamma factors control the integral. The divisor count, the removed +Euler factors, and $X^{\delta_{\mathrm M}}$ are absorbed in $X^\rho$, +leaving $X^{1+\rho}\sum_{v>Y}v^{-2}\ll X^{1+\rho}/Y$. +The factor $z^{-2}$ changes only the constant. + +\par\smallskip\noindent\emph{Poisson summation and the main term.} +Only $(d,H)=1$ occurs, because $n\equiv a\bmod H$ is a reduced +class. For $d\le Y$ put $J=[d^2,b]$ and +$c_J\equiv aJ^{-1}\bmod H$, which is therefore defined. +Write $u=u_1q$ with $u_1\mid H^\infty$ and $(q,H)=1$, and put +$\kappa(u_1)=\chi_{\sigma a}(u_1)$. Define +\[ + G_\nu(q)=\sum_{y\bmod q}\left(\frac yq\right)e(\nu y/q), +\quad + W_j(z,R)=\int_0^\infty + \Phi(x)V_j\!\left(\frac z{Q_Ax}\right)e(-Rx)\,dx, +\] +where $e(x)=e^{2\pi ix}$. Put +\[ + T_j(J)=\sum_{\substack{n>0,\ n\equiv a\ (H)\\J\mid n}} + \mathcal A_j(n)\Phi(n/X). +\] +Poisson summation in the fixed progression gives the exact identity +\begin{align}\label{nv:poisson} + T_j(J) + &=\frac{2X}{HJ} + \sum_{u_1\mid H^\infty}\frac{\lambda(u_1)\kappa(u_1)}{\sqrt{u_1}} + \sum_{(q,H)=1}\frac{\lambda(q)}{q^{3/2}} + \left(\frac{\sigma JH}{q}\right) \\ + &\hspace{14mm}\cdot + \sum_{\nu\in\Z}G_\nu(q)e(\nu c_J\bar q/H) + W_j\!\left(\frac{u_1q}{X},\frac{\nu X}{HJq}\right). + \nonumber +\end{align} +Here $q\bar q\equiv1\bmod H$. The arithmetic factor follows directly by +applying the Chinese remainder theorem to +\[ +\sum_{\substack{x\bmod Hq\\x\equiv c_J\ (H)}} + \left(\frac xq\right)e(\nu x/(Hq)) +=e(\nu c_J\bar q/H)\left(\frac Hq\right)G_\nu(q). +\] +When $(q,J)>1$, the additional Jacobi symbol is zero. + +At zero frequency only square $q$ occur. Put +\[ + H_p(z)=1+(1-p^{-1}) + \sum_{r\ge1}\lambda(p^{2r})p^{-r(1+2z)},\qquad H_p=H_p(0), +\] +\[ + L_H(z)=\sum_{u_1\mid H^\infty} + \lambda(u_1)\kappa(u_1)u_1^{-1/2-z}, + \qquad F_J(z)=\prod_{p\nmid HJ}H_p(z). +\] +The zero-frequency term is +\[ +\frac{2X}{HJ}\frac1{2\pi i}\int_{(2)} +G(z)\Gamma(1+z)(Q_AX)^z\widehat\Phi_0(z)L_H(z)F_J(z) +\frac{dz}{z^{j+1}}, +\quad +\widehat\Phi_0(z)=\int_0^\infty\Phi(x)x^z\,dx . +\] +For the Satake parameters $\alpha_p,\alpha_p^{-1}$, with +$|\alpha_p|=1$, we have +\[ + \sum_{r\ge0}\lambda(p^{2r})x^r + =\frac{1+x}{(1-\alpha_p^2x)(1-\alpha_p^{-2}x)}. +\] +Thus $F_J$ factors through $L(1+2z,\operatorname{sym}^2f)$ and a +correction product convergent near $\Re z\ge-1/16$. Omitting a prime +dividing $J$ removes its correction factor and inserts an inverse +symmetric-square Euler polynomial; it creates no pole even when +$H_p(z)$ has zeros. The omitted factors cost at most $J^{B_1}$ for an +absolute $B_1$. Symmetric-square continuation, including the CM case +\cite[Theorem~9.3 and Remark~9.9]{GelbartJacquet1978}, and the +polynomial strip bounds from its functional equation therefore give an error +$O_{f,H,\Phi}(J^{B_1}X^{1-1/16})$ when shifting to $\Re z=-1/16$. + +The residues have a positive leading coefficient. Indeed +\[ + F_p^{\rm ev}=\sum_{r\ge0}\lambda(p^{2r})p^{-r} + =\frac{1+p^{-1}}{(1-\alpha_p^2/p)(1-\alpha_p^{-2}/p)}>0,\quad + H_p=p^{-1}+(1-p^{-1})F_p^{\rm ev}>p^{-1}. +\] +The fixed Euler factors are positive at the center, and +$L(1,\operatorname{sym}^2f)>0$ by the Rankin--Selberg residue formula. +This also holds for CM forms. Summing the residue over the square +divisor gives, at $p\nmid Hb$, the factor $H_p-p^{-2}$, and at +$p\mid b$ the factor $p^{-1}-p^{-2}$. Consequently +\[ + \beta_p=\frac{p-1}{p^2H_p-1} + =\frac1{1+pF_p^{\rm ev}} + =p^{-1}+O(p^{-2}). +\] +For $j=1$, the double pole gives $cX\log X+c_1X$ with the same +positive leading coefficient. Extending the residue sum from $d\le Y$ +to all $d$ costs $O(b^{B_2}X^{1+\rho}/Y)$; the $d^{-2+\rho}$ tail +also permits differentiation of that sum. + +\par\smallskip\noindent\emph{The nonzero frequencies.} +It remains to obtain a power saving with polynomial dependence on $J$. +Put $\epsilon_q=1$ or $i$ according as $q\equiv1$ or $3\bmod4$ +and $\widetilde G_\nu(q)=\epsilon_q^{-1}G_\nu(q)$. This is multiplicative +in $q$. Since $4\mid H$, expand +$\epsilon_q e(\nu c_J\bar q/H)$ in characters $\psi\bmod H$. +For $\nu\ne0$ the resulting Dirichlet series is +\[ + D_{\psi,J,\nu}(s)= + \sum_{(q,H)=1}\frac{\lambda(q)}{q^s} + \frac{\widetilde G_\nu(q)}{\sqrt q} + \left(\frac{\sigma JH}{q}\right)\psi(q) + =L(s,f\otimes\xi_{\rm prim})C_{\psi,J,\nu}(s), +\] +where $\xi(q)=\psi(q)(\sigma JH\nu/q)$. +At $p\nmid2HJ\nu$ its local factor is +$1+\lambda(p)\xi(p)p^{-s}$; dividing by the $\mathrm{GL}_2$ Euler +factor leaves a polynomial $1+O(p^{-2\Re s})$. +The bound at primes dividing $\nu$ has an absolute exponent. +Indeed, for an odd prime $p$, put $a=v_p(\nu)$. Directly summing +over the lifts of a residue modulo $p$ gives +\[ +G_\nu(p^r)= +\begin{cases} + \varphi(p^r),&r\text{ even},\ r\le a,\\ + -p^{r-1},&r\text{ even},\ r=a+1,\\ + \epsilon_p p^{r-1/2} + \left(\dfrac{\nu/p^{r-1}}p\right), + &r\text{ odd},\ r=a+1,\\ + 0,&\text{otherwise}. +\end{cases} +\] +For even $r$ this is the Ramanujan sum; for odd $r$ the inner +sum of lifts vanishes unless $p^{r-1}\mid\nu$, after which +the primitive quadratic Gauss sum gives the displayed value. +In particular +$|\widetilde G_\nu(p^r)/p^{r/2}|\le p^{r/2}$, and the local +polynomial on $\Re s\ge3/4$ is bounded by +$\sum_{r\ge0}(r+1)p^{-r/4}\le C_0$ with $C_0$ absolute. +The inverse degree-two Euler polynomial is bounded by another +absolute constant $C_1$. Primes dividing $J$ simply remove the +local sum, and have the same bound after multiplication by that +inverse Euler polynomial. Thus all primes dividing $J\nu$ cost +at most $(C_0C_1)^{\omega(J\nu)}\le (2J|\nu|)^C$, for an +absolute $C$. The remaining correction product converges +absolutely on $\Re s\ge3/4$, since its local error is +$O(p^{-3/2})$. Hence the correction is holomorphic on +$\Re s>1/2$ and has the asserted polynomial bound with absolute exponent. +The conductor of $\xi_{\rm prim}$ is at most $4HJ|\nu|$, and the +twisted cuspidal $L$-function is entire. Thus, with absolute $C$, +\[ + |D_{\psi,J,\nu}(3/4+i\tau)| + \ll_{f,H}(J|\nu|)^C(1+|\tau|)^C. +\] + +Integration by parts in both weight variables gives, for fixed $r,s$ +and any $K>0$, +\[ + |(z\partial_z)^r(R\partial_R)^sW_j(z,R)| + \ll_{f,\Phi,r,s,K}(1+z)^{-K}(1+|R|)^{-K}(1+|\log z|). +\] +The logarithm is needed only for $j=1$ and is $O(\log X)$ on the +actual sums, where $z\ge X^{-1}$. +For an absolute small $\rho>0$ the sums can therefore be restricted to +\[ + u_1q\ll X^{1+\rho},\qquad + 0<|\nu|\ll_H JX^{2\rho},\qquad + q\gg_H X^{1-\rho}/J, +\] +at a negligible cost with polynomial dependence on $J$. +A trivial bound $|G_\nu(q)|\le q$ gives a polynomial majorant for the +discarded tails. To identify the sum to be shifted, write +$D_{\psi,J,\nu}(s)=\sum_q\gamma(q)q^{-s}$. On a dyadic range +$q\asymp T$, take a fixed smooth cutoff $\vartheta$ and put +\[ + w_T(y)=\vartheta(y) + W_j\!\left(\frac{u_1Ty}{X},\frac{\nu X}{HJTy}\right). +\] +Each dyadic $q$-sum after the character expansion is therefore +\[ + \sum_q\frac{\gamma(q)}q w_T(q/T) + =\frac1{2\pi i}\int_{(1)} + \widehat w_T(s)T^sD_{\psi,J,\nu}(1+s)\,ds, +\] +where $\widehat w_T(s)=\int_0^\infty w_T(y)y^{s-1}\,dy$. +The weight bounds permit a contour shift to $\Re s=-1/4$, giving +\[ + O_{f,H,\Phi}\bigl((J|\nu|)^C X^{C'\rho}T^{-1/4}\bigr). +\] +There is no residue. Summing over $\nu$, over the dyadic ranges, +and over $u_1$ (for which +$\sum_{u_1\mid H^\infty}|\lambda(u_1)|/\sqrt{u_1}<\infty$) +is bounded, up to a further $X^{O(\rho)}$, by +\[ + \frac XJ\,J^C(JX^{2\rho})^{C+1} + (X^{1-\rho}/J)^{-1/4} + =J^{2C+1/4}X^{3/4+O(\rho)}. +\] +This gives $O(J^{B_3}X^{3/4+C''\rho})$. Choose $\rho$ so that this is +$O(J^{B_3}X^{7/8})$. + +\par\smallskip\noindent\emph{Choosing the truncation.} +Since $J\le bd^2$, summing the two contour errors for $d\le Y$, +and adjoining Equation~\eqref{nv:tail}, gives +\[ + O_{f,H,\Phi}\bigl( + b^{B_4}Y^{2B_4+1}X^{1-\kappa} + +b^{B_4}X^{1+\rho}/Y\bigr) +\] +for absolute $\kappa>0$ and $B_4$. +Take $Y=X^\delta$ with $(2B_4+1)\delta<\kappa/2$, and then +$\rho<\delta/4$. Both errors have the form in the statement, +with absolute positive saving. This proves the lemma. +\end{proof} + +\begin{proof}[Proof of Propositions~\ref{nv:local-witness} and~\ref{nv:rough}] +For negative root number, Lemma~\ref{nv:moment} gives a nonzero sum of +derivatives in every sufficiently large dyadic interval. One derivative +is nonzero, and its central zero is already forced by the sign. + +For positive root number, use the nonnegative sequence +\[ + a_n=\mu^2(n)\mathbf1_{n\equiv a\ (H)} + L(1/2,f\otimes\chi_{\sigma n})\Phi(n/X). +\] +Its nonnegativity follows from the Waldspurger formula +\cite{Waldspurger1981}. The lemma gives a dimension-one sieve density +$\beta_p$ and an absolute exponent of distribution: +choose $\theta>0$ with $(B+1)\theta<\eta$ and put $D=X^\theta$. +The total remainder for squarefree $b\le D$ is +\[ + O_{f,H,\Phi}(D^{B+1}X^{1-\eta})=o(X/\log X). +\] +The density estimate also gives the interval product condition +\[ + \prod_{\substack{w\le p2$, therefore gives positive +remaining weight. Since $z=X^{\theta/s}$ tends to infinity, its +surviving parameters eventually avoid all primes up to any prescribed bound. +Every surviving parameter is prime to $H$ and has all other prime +factors at least $z$. Since $n<2X$, its number of prime factors is +bounded by any fixed integer greater than $2s/\theta$ for sufficiently +large $X$. This proves Proposition~\ref{nv:rough} and the positive-sign +part of Proposition~\ref{nv:local-witness}. Enlarging $H$ and choosing +a reduced CRT lift excludes any additional finite prime set. +\end{proof} + +The constants in the size threshold may change when the curve or +the support is changed. The exponent $\theta$ and the factor-count +bound do not. In particular, a previously chosen twist can be +absorbed into the curve before this proposition is applied. diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/pointwise.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/pointwise.tex new file mode 100644 index 0000000000000000000000000000000000000000..77863cddea71a68a25d417058e5dbf82be67dc6f --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/pointwise.tex @@ -0,0 +1,1058 @@ +\section{Assembly at a fixed curve}\label{pw:section} + +Fix $E/\mathbb Q$ with nonzero rational two-torsion. The even construction +has two uses: it proves the corank-zero case and supplies the uniform +estimate needed to normalize the odd coefficients. After that normalization, +the corank-one argument fixes a nonvanishing companion and constructs the +two simultaneous coefficient tests required for ring-class transfer. + +\subsection{Interfaces and conventions}\label{pw:interfaces-section} + +We use the fixed-support conventions of Section~\ref{sec:preliminaries}. +Thus all variable prime factors are odd primes of good reduction, +$p^*=(-1/p)p$, and a filter fixes the real sign and unit squareclasses +at a finite support containing $2N$, with finitely many further exclusions. +Recall +\[ + t_p=\dim_{\mathbb F_2}E[2]^{\operatorname{Fr}_p},\qquad + w(h)=\frac12\sum_{p\mid h}t_p. +\] +Whenever the two-primary group is finite, we write +\[ +s(h)=\log_2|\Sha(E^{(h)}/\mathbb Q)[2^\infty]|. +\] +This includes a base of Selmer corank zero and every parameter of analytic +order zero or one. It is distinct from $s_2(E^{(h)})$, the Selmer corank. +The normalized central value is denoted $L_*(h)$, and $v=v_2$ with +$v(2)=1$. + +Here are the preceding results in the form used below. Their roles are +different: coefficient units give upper bounds, interpolation returns those +bounds to an unknown base, and the ring-class lower bound makes the odd +normalization possible. The latter step is carried out in +Proposition~\ref{pw:odd-lower}. + +\begin{proposition}[Collected interfaces]\label{pw:interfaces} +The following statements hold for the fixed curve and fixed local data. +\begin{enumerate} +\item The cyclotomic missing-vertex statement of +Theorem~\ref{cy:missing-vertex} applies to any fixed base $h_0$ of Selmer +corank zero. If arbitrarily large binary cubes based at $h_0$, with no old +prime removed, have nonzero central values at every other address and satisfy +\[ + v(L_*(h_x))-2w(h_x)-s(h_x)\le B\quad(x\ne0), +\] +then the base central value is nonzero and satisfies the same inequality +with $B$ replaced by $B+C$. The constant $C$ depends only on the fixed curve +and local data, not on $h_0$, its number of prime factors, or the cube +dimension. The dimension required for the argument may depend on the base. +The cyclotomic lower bound at an analytically nonvanishing parameter is also +available. +\item Corollary~\ref{rd:ring-lower} has the following uniform form. If +$k<0$ is an odd fundamental discriminant with at most $A$ prime factors, +$K=\mathbb Q(\sqrt{k})$ is neither an extra-unit field nor the CM field, +$k$ is a square at $2Nh$, and the twists $h,hk$ have respective analytic +orders one and zero, then their ring-class Heegner sum has free-line index +$j_h(k)$ satisfying +\begin{equation}\label{pw:ring-lower-interface} + 2j_h(k)\ge 4w(h)+s(h)+s(hk)-C_{E,A}. +\end{equation} +For a fixed such $k$, Theorem~\ref{rd:missing-vertex} applies to +cubes based at $h=1$ whose new primes all split in $K$. If +$s_2(E/K)=1$ and the nonzero addresses have product analytic order one and +uniformly bounded +$2j_h(k)-4w(h)-s(h)-s(hk)$, the base product has analytic order one. +\item The even coefficient system, exact same-filter square comparison, +divided operators, and trace identities of +Proposition~\ref{co:even} and Lemmas~\ref{co:operators}, +\ref{co:traces}, and \ref{co:inertia} are available. +After a uniform lower bound for the relevant point indices has been proved, +the moving odd coefficient system and its stabilized minimum are available +as in Proposition~\ref{co:odd} and Lemma~\ref{co:minimum}. The resulting unit symbols +satisfy the contraction, good-twin, and primary-isolation rules of +Proposition~\ref{co:symbol-interface}. An even unit gives +\begin{equation}\label{pw:even-unit-interface} + L_*(h)\ne0,\qquad v(L_*(h))\le 2w(h)+C; +\end{equation} +an odd unit gives analytic order one and +\begin{equation}\label{pw:odd-unit-interface} + j(P_h)\le w(h)+C. +\end{equation} +The constants are independent of the number and sizes of the variable +primes. The fixed genus partner used to define $P_h$ is denoted $h_*$. +\item Arithmetic realization and the forest and address statements of +Lemmas~\ref{gr:realization} and \ref{gr:forest} and +Theorem~\ref{gr:address} hold. +In particular, separate nonzero terminal polynomials may be addressed +simultaneously. Primary auxiliaries preserve all fixed local classes, +have neutral incidence to specified stationary external vertices, and may +be required to split in any compatible fixed fields. They contribute no +prime at address zero. +\end{enumerate} +\end{proposition} + +\begin{proof} +These are the cited results, with the arithmetic ring-class hypotheses +verified by Proposition~\ref{rd:assembly}. The even coefficient minimum +uses the cyclotomic lower bound; the odd detector of +Proposition~\ref{co:odd} still needs the arithmetic lower bound for +Lemma~\ref{co:minimum}. Neither interpolation statement nor the even +symbol uses that odd normalization. +\end{proof} + +The analytic witnesses and the rough completion used below are supplied by +Propositions~\ref{nv:local-witness} and \ref{nv:rough}; the latter has an absolute +prime-count bound. The bounds in Proposition~\ref{pw:interfaces}, unlike the +eventual sizes of the primes chosen by nonvanishing or Chebotarev, must be +uniform in the parameters indicated there. + +\begin{lemma}[Isogeny orientation and coranks]\label{pw:isogeny-corank} +Recall that a rational isogeny preserves analytic rank, Mordell--Weil rank, +and $2^\infty$-Selmer corank. If $k$ is a quadratic discriminant and +$K=\mathbb Q(\sqrt{k})$, then +\begin{equation}\label{pw:quadratic-corank} + s_2(E/K)=s_2(E/\mathbb Q)+s_2(E^{(k)}/\mathbb Q). +\end{equation} +For every $E/\mathbb Q$ one has, separately, +\begin{equation}\label{pw:kummer-corank} + s_2(E)=r(E)+ + \operatorname{corank}_{\mathbb Z_2}\Sha(E/\mathbb Q)[2^\infty]. +\end{equation} +\end{lemma} + +\begin{proof} +These are Lemmas~\ref{pr:invariance} and \ref{pr:ranks}. In particular, +the quadratic identity is an identity of coranks, not an integral +direct-sum decomposition. +\end{proof} + +If the isogeny class contains a curve with full rational two-torsion, we use +that curve. Otherwise choose a rational two-isogeny $E\to E'$ and write +$F=\mathbb Q(E[2])$, $F'=\mathbb Q(E'[2])$; both fields are quadratic. +A prime split in $F$ is called split, and one inert in $F$ is called simple. +Their weights are respectively $1$ and $1/2$. A simple prime is good if it +is also inert in $F'$. At such a prime +\begin{equation}\label{pw:good-simple} + \#E(\mathbb F_p)\equiv2\pmod4. +\end{equation} +Indeed there is exactly one nonzero rational two-torsion point in the +reduction. If the group order were divisible by four, its two-primary +subgroup would contain a rational point of order four. Its image under the +two-isogeny would supply on $E'$ a rational two-torsion point different from +the dual kernel, contradicting inertness in $F'$. Thus the good-twin rule +applies. When $F=F'$, every simple prime is good. +A prime split in $F$ and inert in $F'$ is a \emph{donor}: attaching its +label to a bad simple label makes that label good. This terminology +describes finite label operations; the required prime supplies will be +constructed below. + +\subsection{Seeds and finite supplies}\label{pw:seeds-section} + +The word ``label'' below means an individually realizable fixed-support +elementary Frobenius label, with orientations when required. It does not +include a self-residue of a prime generator. All contractions and +comparisons are those of Proposition~\ref{co:symbol-interface} and +Lemma~\ref{gr:forest}. + +\begin{lemma}[Minimum seeds]\label{pw:minimum-seeds} +\begin{enumerate} +\item In an all-split alphabet, suppose a unit symbol has a nonempty +witness. At the least positive vertex count $r$ of such a witness, all +mutual edge bits are immaterial. The symbol is determined by the individual +fixed-support labels. This remains true if the empty configuration is a +unit, provided no contraction to the empty configuration is used. +\item In the quadratic case, suppose the symbol has a nonzero witness, +the alphabet is closed under the allowed contractions, and it contains +the good twin operations. There are +$r\ge0$ and $s_1\ge1$ such that for every $s\ge s_1$ of the permitted simple +parity, the minimum split count of a unit with $s$ simple vertices is $r$. +At these counts all edge bits are immaterial. A chosen minimum seed may be +padded by arbitrarily many good twin pairs. +\end{enumerate} +\end{lemma} + +\begin{proof} +For the first assertion, a derivative in an edge of an $r$-vertex graph is a +symbol on $r-1$ vertices. If $r\ge2$, this graph remains nonempty and has +value zero by minimality. If $r=1$, there is no edge. The omitted-vertex +description then leaves exactly the fixed-support labels. + +For the second assertion let $r(s)$ be the minimum split count at simple +count $s$, with value $+\infty$ when no witness exists. Once a finite value +occurs, good-twin insertion gives $r(s+2)\le r(s)$. A nonincreasing sequence +of nonnegative integers stabilizes. Choose $s_1\ge1$ in that range. A +derivative of an edge with a split endpoint reduces the split count and +preserves the simple count; it is therefore zero at the minimum. A +simple--simple derivative is zero by the symbol rule. Twin insertion gives +the last assertion. +\end{proof} + +Call a list partitionable if some permitted contraction forest has a unit +symbol as its output. A contraction certificate proves that its terminal +polynomial is nonzero: the indicated iterated finite difference is nonzero. + +\begin{lemma}[Finite label reserves]\label{pw:reserves} +Fix a minimum seed and a finite label alphabet. +\begin{enumerate} +\item In the all-split rational alphabet, a list with the same total label +as the seed and sufficiently many copies of its labels is partitionable. +\item In the quadratic alphabet, retain $r$ split anchors with the seed +labels, and suppose the list and seed have the same total rational label +on the projection used by the symbol. Suppose there are sufficiently +many simple vertices of the required parity and sufficiently many split +reserves of each realizable rational shift. If $F\ne F'$, also suppose +\begin{equation}\label{pw:donor-balance} + \Delta=\#\{p:\ p\text{ split in }F\text{ and inert in }F'\} + -\#\{p:\ p\text{ inert in }F\text{ and split in }F'\}>C_0. +\end{equation} +Here $C_0$ depends only on the anchors and the reserves. Then all other +split vertices can be attached to simple vertices so that the result is +the minimum seed and good twin pairs. The twins may match a prescribed +finite enrichment of the rational labels. The base simple labels may be +specified on any projection on which the required total agrees. +\end{enumerate} +All reserve requirements depend only on the finite alphabets, seed, and +projection. They do not depend on the original list length. +\end{lemma} + +\begin{proof} +In the first case retain the first $r-1$ seed labels and merge all other +vertices to the last cluster. Sufficient copies ensure that this cluster +is nonempty. Its label is forced by the total, hence is the last seed +label. Lemma~\ref{pw:minimum-seeds} makes its unknown edges immaterial. + +For the second case, the rational labels of split attachments form the +subgroup with trivial $F$-coordinate. They act transitively on the simple +coset, so every prescribed change of a simple label has a realizable split +shift. Reserve sufficiently many representatives of every such shift. +Remove these reserves and the anchors from the donor pool. If $F\ne F'$, +\eqref{pw:donor-balance}, with $C_0$ exceeding the number removed, leaves a +distinct donor for each bad simple vertex. Attach these donors; every +simple vertex is now good. If $F=F'$, this operation was unnecessary. + +Pair equal enriched good labels. By withholding a bounded number of pairs, +leave between $s_1$ and $s_1+C_1$ unpaired vertices, with the correct parity; +$C_1$ depends only on the number of enriched labels. Use reserved shifts +to turn the excess unpaired vertices into good pairs and to set the first +$s_1-1$ base positions to the desired seed labels. The seed labels +themselves need not all be good. Attach every remaining nonanchor split +vertex to the last base position. Its projected label is forced by the +total, the anchors, the other base positions, and the twin pairs. It is +the required last seed label. Each cluster contains one simple vertex, +so every contraction is permitted. Only a bounded number of reserve +shifts was used. + +When incidences to a retained split anchor are needed only to remove twins, +they can be prescribed after the contracted labels are fixed, by the +independent terminal-edge realization. Fixed stationary vertices instead +enter the finite label enrichment from the outset. These two uses do not +increase the number of label types with the original list length. +\end{proof} + +\begin{lemma}[Neutral packets]\label{pw:packets} +For any of the finite reserve problems above with prescribed rational total +zero, one can choose a finite packet of terminal labels with rational total +zero such that every nonempty union of copies of the packet has the required +supplies. In the quadratic case with \(F\ne F'\), its donor surplus +may be made arbitrarily large. When \(F=F'\), every simple label is +good and no donor surplus is required. Compatible fixed splitting +conditions may be included whenever +the needed individual labels and shifts remain realizable. +\end{lemma} + +\begin{proof} +Choose ample copies of every required label, including anchors and shifts. +In the quadratic case with \(F\ne F'\), add enough donors to exceed +all the losses from the +other labels and the prescribed reserve margin. Duplicate every full +label in the resulting list. Duplication gives total zero in every +rational elementary coordinate and preserves any strict donor surplus. +Choose the margins so that after reserving the finitely many anchors in +any one packet, the union of any positive number of packets still meets +the reserve requirements. All labels are realized by distinct fresh +primes; duplication never means repeating an actual prime factor. +\end{proof} + +\subsection{The even estimate and the corank-zero case} +\label{pw:lower-section} + +\begin{proposition}[Partitionable even estimate]\label{pw:partitionable-even} +Fix an even symbol furnished by Proposition~\ref{pw:interfaces}. For every +partitionable parameter $h$ on its filter with $s_2(E^{(h)})=0$, +\begin{equation}\label{pw:partitionable-bound} + L_*(h)\ne0,\qquad v(L_*(h))-2w(h)-s(h)\le C. +\end{equation} +The constant depends only on the symbol and fixed local data. +\end{proposition} + +\begin{proof} +If the parameter has no prime factors, a contraction certificate means +that the empty symbol itself is a unit. Equation~\eqref{pw:even-unit-interface} +then proves the assertion directly. Otherwise the stationary terminal +set is nonempty. +Keep the prime factors of $h$ stationary. Their terminal polynomial is +nonzero by its contraction certificate. The stationary one-symbol case +of Theorem~\ref{gr:address} gives arbitrarily large binary cubes based at +$h$, with only primary new primes, whose other addresses have unit symbol. +Equation~\eqref{pw:even-unit-interface} and $s(h_x)\ge0$ give the uniform +upper bound required by the cyclotomic transfer. The base corank is zero, +so that transfer gives \eqref{pw:partitionable-bound}. A base-dependent +dimension threshold does not affect the asserted constant. +\end{proof} + +The original corank-zero base can now be treated without any odd +coefficient system or companion field. + +\begin{proposition}[Even original base]\label{pw:even-base} +If $s_2(E)=0$, then $a(E)=0$. +\end{proposition} + +\begin{proof} +Lemma~\ref{pr:invariance} gives even functional sign. Fix an even symbol +on the filter of $1$, including all auxiliary class-group tests. If its +value at $1$ is a unit, analytic nonvanishing is already detected. +Otherwise use a nonempty minimum seed in the full-torsion case, or a +stabilized quadratic seed in the other case. + +For each $b$, assign a neutral packet from Lemma~\ref{pw:packets} to +every nonzero linear form on $\mathbb F_2^b$, and activate its primes +by that form. At every nonzero address at least one packet is active; +their union satisfies the reserve problem and has a nonzero terminal +polynomial. At zero no terminal is active. The single-symbol case of +Theorem~\ref{gr:address} adds primary auxiliaries and makes the symbol a +unit at every nonzero address. All local classes remain those of $1$. +Equation~\eqref{pw:even-unit-interface}, followed by cyclotomic transfer +at the original corank-zero base, gives $a(E)=0$. +\end{proof} + +\subsection{The lower bound needed by the odd coefficients} +\label{pw:odd-lower-section} + +For the odd construction, first fix the original coefficient and +class-group support and its unit tests. Then choose the genus partner +$h_*$ as in Section~\ref{co:section}, adjoin its prime factors to the +support, and refine the unit tests there. All variable $h$ avoid this +support. The positive filter below is this prepared filter, fixed before +$h$ varies or the odd coefficients are normalized. + +We next use the even estimate at analytically nonvanishing parameters, +not the corank-zero conclusion just proved. The companion $k'=k'(h)$ +in this step may vary with $h$, but its number of prime factors will be +bounded. It is distinct from both the detector's fixed genus partner +$h_*$ and the fixed companion used in the final ring-class transfer. + +At a parameter already known to have analytic rank zero, the estimate +\eqref{pw:partitionable-bound} transfers between either orientation of a +fixed two-isogeny. The isogeny formula for the BSD quotient gives a bounded +change in $s(h)+2w(h)$. At an active odd good prime the component-group +valuation is $t_p$, and the two active contributions are included in the +two weights. At the fixed support only finitely many local twisting +classes occur. Differential, period, and torsion indices are bounded by +the fixed isogeny and its reverse, and there is no regulator at rank zero. +This uses an isogeny identity for known finite groups, not BSD or converse +finiteness at an unknown parameter. + +\begin{lemma}[A bounded companion for a varying odd parameter] +\label{pw:rough-companion} +Fix a positive odd-sign filter, including the coefficient and class-group +support used below, and a negative genus partner $h_*$ with +$L(E^{(h_*)},1)\ne0$, chosen using Proposition~\ref{nv:local-witness} and then +excluded from the variable parameters. There are constants $A,C$ such +that every $h$ on this filter of analytic order one admits a negative odd +fundamental discriminant $k'$ for which +\begin{enumerate} +\item $(k',2Nh)=1$, $k'$ is a square at every place of $2Nh$, and +$\mathbb Q(\sqrt{k'})$ is nonexceptional; +\item $\omega(k')\le A$; +\item $L(E^{(hk')},1)\ne0$ and +\begin{equation}\label{pw:rough-bound} + v(L_*(hk'))\le 2w(hk')+s(hk')+C. +\end{equation} +\end{enumerate} +\end{lemma} + +\begin{proof} +At the fixed class-group support and the other fixed label tests, prepare +an even negative-index symbol for each possible total type at this +support, and for both isogeny orientations if needed. +There are finitely many such preparations. The positive index $|hk'|$ +has nonzero total rational type: its negative-discriminant parity is +already nontrivial among the tests at $2$. Thus in the full-torsion case +a unit seed has positive count. In the quadratic case use the stabilized +seed of Lemma~\ref{pw:minimum-seeds}. + +When $F\ne F'$, interchanging the isogeny orientation interchanges the two +counts in \eqref{pw:donor-balance}. Select the orientation with initial +balance at least zero. The existing donors can then pay for arbitrarily +many existing bad simples. They do not have to be supplied by new primes. + +Let $R$ be the absolute prime-count bound in Proposition~\ref{nv:rough}. Insert +in $k'$ a finite dummy supply that meets the anchors, minimum simple count, +and reserve requirements for every one of the finitely many prepared +symbols. When \(F\ne F'\), add donor slack paying for every reserved +loss, the new dummy bad simples, and a further possible loss of $R$ +from the later rough factor. When \(F=F'\), all simple primes, +including the later rough primes, are already good; only the simple +and split-reserve supplies are needed. Add a fresh ramified prime if +needed to exclude the exceptional +imaginary fields. The number of dummy primes is bounded independently +of $h$. Their labels and initial incidences may be chosen by +Lemma~\ref{gr:realization}. + +Absorb $h$ and the dummy product into the curve. Apply +Proposition~\ref{nv:rough} to complete $k'$ by a squarefree factor coprime to all +primes already used. Prescribe its sign and its local unit classes so +that the final $k'$ is an odd negative fundamental discriminant, is a +square at $2Nh$, and has the required original local classes at $2N$. +These conditions give a nonempty reduced progression by the Chinese +remainder theorem. Its root number is even: since $E^{(h)}$ has odd +sign and $k'$ is negative and square at every prime of $2Nh$, +the quadratic twist formula multiplies that sign by +$\chi_{k'}(-N_{E^{(h)}})=-1$. Thus this is the positive-root-number +case of Proposition~\ref{nv:rough} for the absorbed curve. +Additional fixed primes may be excluded. The proposition makes the +central value at $hk'$ nonzero with at most $R$ new factors. Its size +threshold may depend on $h$ and all these congruences; $R$ does not. + +No particular resulting unit class at the auxiliary class-group support +was assumed in advance: dummy supplies were prepared for every possible +total there. For the actual total, Lemma~\ref{pw:reserves} makes $hk'$ +partitionable. Analytic nonvanishing gives Selmer corank zero by the +forward theorem. Proposition~\ref{pw:partitionable-even} therefore gives +\eqref{pw:rough-bound}, with the isogeny comparison above if the other +orientation was used. The finite preparation and the bound on dummy and +rough factors give $A,C$ independent of $h$. +\end{proof} + +\begin{lemma}[Height comparison]\label{pw:height-comparison} +Here $j_h(k)$ is the index of the conductor-$|h|$ ring-class sum over +$\mathbb Q(\sqrt{k})$, whereas $j(P_h)$ is the index of the conductor-one +genus sum over $\mathbb Q(\sqrt{hh_*})$. +With the fixed modular parametrization and the fixed genus partner $h_*$, +the explicit Gross--Zagier formula gives, whenever the relevant factors +have analytic orders one and zero, +\begin{equation}\label{pw:height-ratio} + 2j_h(k)-2j(P_h)=v(L_*(hk))+O(1). +\end{equation} +For $k$ with bounded prime count as in +Lemma~\ref{pw:rough-companion}, the error is uniform in $h,k$; for a fixed +$k$ it is uniform in $h$. +\end{lemma} + +\begin{proof} +Use the character-sum normalization of the explicit Gross--Zagier formula +in \cite[Theorem~1.1]{CaiShuTian2014}. The restriction of $\chi_h$ to +$\mathbb Q(\sqrt{k})$ has exact ring-class conductor $|h|$: each odd +prime dividing $h$ splits and retains its ramified quadratic character. +The genus character over $\mathbb Q(\sqrt{hh_*})$ is unramified, so the +sum defining $P_h$ has conductor one. Their canonical +heights are fixed modular factors times, respectively, +\[ + |h|\sqrt{|k|}\,L'(E^{(h)},1)L(E^{(hk)},1), + \qquad + \sqrt{|hh_*|}\,L'(E^{(h)},1)L(E^{(h_*)},1). +\] +In that theorem the multiplier is $c\sqrt{|D|}$, the level-discriminant +factor is $2^{\mu(N,D)}$, and the unit factor is +$[\mathcal O_c^\times:\mathbb Z^\times]^2$. Here every level prime +splits, so $(N,D)=1$ and $\mu(N,D)=0$; the excluded extra-unit fields +make the unit factor $1$ in both applications. +Take their ratio. The derivative and the rank-one regulator cancel; +the remaining varying real factor is $\sqrt{|hk|}$, precisely the factor +in $L_*(hk)$. Comparison of the rational free line with its two quadratic +projections has bounded index because their composites are multiplication +by $2$. The modular parametrization and the factor involving $h_*$ are +fixed. The level is split and the discriminant and conductor are prime +to it; no growing conductor-prime product occurs in this normalization. +Local differential and period comparisons have finitely many possibilities +at the fixed support. The extra-unit fields have been excluded, and the +number of additional places in the varying $k$ case is bounded. These +observations give the asserted bounded valuation error. +\end{proof} + +\begin{proposition}[Uniform lower bound for the odd detector] +\label{pw:odd-lower} +Every analytically rank-one $h$ in the prepared positive filter of +Lemma~\ref{pw:rough-companion} satisfies +\begin{equation}\label{pw:odd-lower-bound} + 2j(P_h)\ge 2w(h)+s(h)-C. +\end{equation} +In particular $j(P_h)\ge w(h)-C$ uniformly in $h$ and its prime count. +\end{proposition} + +\begin{proof} +Choose $k'$ by Lemma~\ref{pw:rough-companion}. Combine +\eqref{pw:ring-lower-interface}, \eqref{pw:height-ratio}, and +\eqref{pw:rough-bound}. Since the factors are coprime, +$w(hk')=w(h)+w(k')$, and $w(k')\le\omega(k')\le A$. Hence +\begin{align*} + 2j(P_h) + &\ge 4w(h)+s(h)+s(hk')-v(L_*(hk'))-C\\ + &\ge 2w(h)+s(h)-2w(k')-C\\ + &\ge 2w(h)+s(h)-C'. +\end{align*} +Only even symbols and independently nonvanishing companions were used. +Thus this proof precedes, and does not assume, the odd minimum-depth +normalization. +\end{proof} + +\subsection{From the moving odd coefficients to finite graphs} +\label{pw:odd-stages} + +Proposition~\ref{pw:odd-lower} now supplies the arithmetic premise of +Lemma~\ref{co:minimum}. We obtain an odd symbol with fixed minimum +normalized depth and the uniform unit bound +\eqref{pw:odd-unit-interface}. To use the finite seed and packet lemmas, +we also need to stabilize its graph labels and values, not just this +numerical depth. + +Keep the ultrafilter used in Lemma~\ref{co:minimum}. The intrinsic fixed +support includes the genus partner $h_*$; at an actual stage it also +includes the detecting prime $\ell$. That prime adds at most two places +in any fixed quadratic field. The unit and class-group description of +$V_S(F)$ therefore bounds the dimension of the elementary label space +independently of the stage. At $\ell$ the Schwartz function in +Lemma~\ref{co:theta-bridge} uses only the quadratic residue-line character: +increasing the Kummer precision does not impose a character of growing +order on the variable primes. The old-support characters are fixed. + +Choose bases and restrict to an ultrafilter-large set of stages on which +the finite label spaces, their addition tables, conjugation and projection +maps have one abstract form. At every fixed weight bound there are only +finitely many typed graphs and symbol truth tables. Select the table +occurring on an ultrafilter-large set. These selected tables are +compatible under restriction and define one limit symbol. Its contraction +and twin identities follow from the finite-stage identities. The witness +sequence of Lemma~\ref{co:minimum} has bounded weight, hence takes only +finitely many graph types in this alphabet; one type is a witness in the +selected limit table. + +If the empty configuration is a unit, a sufficiently advanced actual stage +already detects analytic order one at $h=1$. Otherwise the limit witness +is nonempty, so Lemma~\ref{pw:minimum-seeds} supplies the minimum seeds +and stabilized simple count needed below. Fix them in this remaining +case; Lemmas~\ref{pw:reserves} and \ref{pw:packets} apply to their finite +label alphabets. Every +particular contraction or twin comparison uses only a bounded graph. +Its selected truth table agrees with the actual symbol on an +ultrafilter-large set of stages. Thus any prescribed finite collection +of such comparisons holds at one sufficiently advanced stage. + +Later we will add the fixed support of a separate companion and the label +projection read by its even test. Once compatible lifts have been +verified, we may stabilize this finite enrichment by restricting the +\emph{same} ultrafilter. This preserves the intrinsic odd symbol, its +minimum, and its chosen seeds. The actual stage is selected only after +the cube dimension and all its finite networks have been chosen: their +maximum weight gives a finite list of table and precision requirements. +No intersection over all weight bounds, and no single stage working for +every cube dimension, is required. + +\subsection{A nonempty split-field symbol with full two-torsion} +\label{pw:split-section} + +We give the extra argument required when $E[2]$ is rational. It addresses +the possibility that the usual even minimum is attained only at the empty +configuration after restricting all new primes to split in the companion +field. + +\begin{lemma}[Recurrence congruences]\label{pw:recurrence} +Let $p$ be odd, $a\equiv p+1\pmod4$, and let +\[ + b_0=1,\quad b_1=a-\kappa,\quad + b_{s+1}=ab_s-pb_{s-1}. +\] +If $\kappa=\pm1$, then $b_{s+1}-b_s$ is even and +\[ + \frac{b_{s+1}-b_s}{2}\equiv\frac{a-\kappa-1}{2}\pmod2 + \quad(s\ge0). +\] +If $\kappa=0$, put $b_{-1}=0$; then $b_s-b_{s-1}$ is odd for every +$s\ge0$. Finally, for $\kappa=1$, if $a\equiv p+1\pmod{2^m}$ then +$b_s\equiv p^s\pmod{2^m}$ for every $s\ge0$. +\end{lemma} + +\begin{proof} +Modulo $2$ the recurrence is $b_{s+1}=b_{s-1}$. Its initial values prove +the parity assertions. For $d_s=b_{s+1}-b_s$, the recurrence for $d_s$ +is the same. Directly, +$d_1-d_0\equiv(p-1)(p-\kappa)\equiv0\pmod4$ when $\kappa=\pm1$. +Thus $d_s/2$ is constant modulo $2$. The last assertion follows by +substituting the sequence $p^s$ in the recurrence and checking its first +two terms. +\end{proof} + +\begin{lemma}[Nonempty $K$-split witness]\label{pw:split-witness} +Suppose $E[2]$ is rational. Choose a negative unit $k$ of a fixed even +symbol for $E$, prime to all previous fixed support and to the ramification +support of $E[8]$. Put $K=\mathbb Q(\sqrt{k})$, chosen nonexceptional. +Let $S_0$ contain the complete fixed support of the coefficient system, +$2N$, the primes of $k$, and primes generating the class group of $K$. +On the positive filter of $1$ square at $S_0$, there is an +even unit test on nonempty products of primes split in $K$ with these +properties: +\begin{enumerate} +\item it has a nonempty witness; +\item it satisfies the oriented split contraction and primary-isolation +rules over $K$, for contractions with nonempty output; +\item a unit at $D$ implies +\begin{equation}\label{pw:split-unit-bound} + L(E^{(kD)},1)\ne0,\qquad v(L_*(kD))\le 2\omega(D)+C_k. +\end{equation} +\end{enumerate} +This conclusion uses the integral trace and local identities in +Proposition~\ref{pw:interfaces}(3). +\end{lemma} + +\begin{proof} +If the ordinary coefficient test already has a nonempty split witness, +there is nothing to construct. Otherwise we first obtain an additional +trace congruence modulo $8$. That congruence makes one further division +of the coefficient form integral. We verify its contraction identities, +then use a prime inert in $K$ to force a nonzero test at a split prime. + +\emph{Extra depth if the ordinary test has no witness.} +Use the ordinary even coefficient form for $E^{(k)}$, normalized by +$a(1)=1$. The positive filter is chosen so that $kD$ lies in the original +negative filter. Since $k$ attains its least normalized depth, the exact +ratio comparison of Proposition~\ref{co:even} gives +\begin{equation}\label{pw:split-basic-depth} + v(a(D))\ge\omega(D) +\end{equation} +at every allowed squarefree $D$. The factor $|k|$ cancels from this ratio; +one is not subtracting unrelated bounded-error inequalities. + +If equality holds at a nonempty product of $K$-split primes, use the usual +even bit, projected from oriented $K$-labels to rational labels. It has +all the required properties by Proposition~\ref{co:symbol-interface}. We +therefore assume for the rest of the proof that equality never occurs +there. By the rational-phase assertion in Proposition~\ref{co:even}, +normalization by $a(1)=1$ makes each nonzero squarefree coefficient a +rational number times a root of unity. Its valuation is an integer, +not just an element of the possibly ramified coefficient field's +discrete value group. Thus strict inequality implies +\begin{equation}\label{pw:split-extra-depth} + v(a(D))\ge\omega(D)+1 + \quad\text{for every nonempty allowed all-$K$-split }D. +\end{equation} + +Write $g=\sum a(n)q^n$ for the form. Its characters satisfy +$\psi/\eta=\chi_{-4}$, so $\eta$ is odd. For a set $U$ of $K$-split +primes put +\[ + B_U=2^{-|U|}\prod_{p\in U}(U_p-\eta(p)V_p)g, + \qquad + \Theta_J=\sum_{m>0,\ (m,S_0)=1}\eta(m)m q^{Jm^2}. +\] +All expansions retain the prescribed support sieves. The ordinary divided +form is +\[ + H_U=\frac12\left(B_U-\sum_{J\subseteq U}B_U[J]\Theta_J\right). +\] +Here $B_U[J]$ denotes its coefficient at the squarefree index $J$. + +\emph{The resulting trace congruence.} +We first prove +\begin{equation}\label{pw:split-mod8} + a_p(E^{(k)})\equiv p+1\pmod8 + \quad\text{for every allowed good }p\text{ split in }K. +\end{equation} +Apply the ordinary $H_{\{p\}}$ trace at a Frobenius lift $\phi_p$, +testing coefficient $p^2$ after theta multiplication. The form +$H_{\{p\}}$ is already integral, and $\theta\equiv1\pmod2$; +hence theta multiplication does not alter any of its reduced +coefficients after these divisions. On the +conductor-one ramified principal-series part the identity is +\[ + U_p^2t(\phi_p)=U_p^3+d(\phi_p)U_p. +\] +On the unraised unary part it is the ordinary good-prime coefficient +identity. These are the only two types in this expression. Consequently +\[ + (t(\phi_p)f)[p^2]=f[p^3]+(d(\phi_p)f)[p]. +\] +Replace the trace by a fresh split prime $p'$ with the same finite data, +including every support-unit test. At each rational quadratic character +unramified outside $S_0$, a Frobenius lift at $p$ has the character value +of $p$. Hence the matched $p'$ has the same value, and $pp'$ has value +$1$. Equivalently, $p'$ has the same unit squareclasses as $p$ at all +places of $S_0$, so their product is square at all of them, including $2$. +Since $\phi_p\in G_K$, the new prime is also split in $K$. +Its coefficient on the left tests $pp'$; by +\eqref{pw:split-extra-depth} it is zero modulo the maximal ideal after +the two divisions. The determinant term on the right is zero: the +unary summand at $p$ has the same character and cancels there. + +On the right, the indices $p$ and $p^3$ in $B_{\{p\}}$ have underlying +squarefree index $1$; they involve only $a(1),a(p^2),a(p^4)$. The +$J=\varnothing$ unary term has no coefficient at either nonsquare +index. Thus no other squarefree coefficient contributes there. +For $a=a_p(E^{(k)})$, the phase-free square coefficients are +$1,a-1,a(a-1)-p$. Hence the remaining coefficient is, up to a unit, +\[ + H_{\{p\}}[p^3] + =\frac{a^2-2a-p+1-p(a-2)}4 + =\frac{(a-1)(a-p-1)}4. +\] +It is zero modulo $2$. Full rational two-torsion makes $a$ even, so +$a-1$ is odd; this proves \eqref{pw:split-mod8}. No individual total +filter condition on $p$ was needed: its matched prime $p'$ makes $pp'$ +lie on the filter, and the square-index terms on the right come from $1$. + +\emph{One further integral division.} +Now define +\begin{equation}\label{pw:four-divided-form} + \widetilde H_U=\frac14 + \left(B_U-\sum_{J\subseteq U}B_U[J]\Theta_J\right). +\end{equation} +We verify integrality at every coefficient. Write a test index uniquely +as $Jrm^2$, where $J\subseteq U$ and $r$ is squarefree and disjoint from +$U$. The underlying squarefree coefficient is at +$D=(U/J)r$. Removing the unit phases, a prime of $U/J$ contributes an odd +factor $b_s-b_{s-1}$ with $\kappa=0$, and a prime of $J$ contributes +$b_{s+1}-b_s$ with $\kappa=(D/p)$. Thus +\begin{equation}\label{pw:shell-valuation} + v(B_U[Jrm^2])\ge\omega(r) +\end{equation} +by \eqref{pw:split-basic-depth}, with one additional unit of valuation +when $D$ is nonempty and all its primes split in $K$. + +If $r\ne1$ and all primes of $D$ split in $K$, the last inequality is +at least $\omega(r)+1\ge2$. If $D$ contains an inert prime, then $r$ +contains at least two: the total rational $K$-character is trivial on +the filter, and all primes of $U$ split. Then +\eqref{pw:shell-valuation} is again at least $2$. No unary term has +this squarefree part. This proves divisibility by $4$ for $r\ne1$. + +Suppose $r=1$ and $J\ne U$. Then $D=U/J$ is nonempty and all split, +so $B_U[J]$ is even. This cancellation can be checked without dividing +by a leading multiplier, which may be zero. Factor from both shell +coefficients the common phase and the scalar +$2^{-|U|+|J|}a(U/J)$, whose valuation is at least $1$ by +\eqref{pw:split-extra-depth}. The remaining factors are the odd +differences at $U/J$, the integral divided differences at $J$, and +the ordinary square-index factors outside $U$. By +Lemma~\ref{pw:recurrence}, their product is congruent modulo $2$ to +the product of their leading values, even when one of those values +is zero modulo $2$. Since $m$ is odd, multiplication by $m$ preserves +this congruence. The common scalar supplies the second factor $2$. +Retaining the phase $\eta(m)$ therefore gives +\[ + B_U[Jm^2]\equiv B_U[J]\eta(m)m\pmod4. +\] +This is exactly the cancellation with $B_U[J]\Theta_J$. + +Finally let $J=U$, so $D=1$. At a prime outside $U$ the recurrence gives +$b_s\equiv p^s\pmod4$. At a prime of $U$, +\eqref{pw:split-mod8} gives $b_s\equiv p^s\pmod8$, and hence +\[ + \frac{b_{s+1}-b_s}{2} + \equiv \frac{a_p-2}{2}\,p^s\pmod4. +\] +Multiplying these congruences, again retaining the phases, gives +$B_U[Um^2]\equiv B_U[U]\eta(m)m\pmod4$. This proves integrality in +the last case and establishes \eqref{pw:four-divided-form}. + +For the trace argument we specify the integral module being used. +Write $\psi_U$ for the character of $B_U$. The character of $\Theta_U$ +is also $\psi_U$, so its diamond correction is zero. For the proper +subsets the diamond formula is +\[ + \langle u\rangle\widetilde H_U + =\psi_U(u)\widetilde H_U+ + \sum_{J\subsetneq U}\frac{B_U[J]}2 + \frac{\psi_U(u)-\eta(u)(-J/u)}2\Theta_J. +\] +Each $B_U[J]/2$ here is integral, and each divided character difference +is zero or a unit. Let $\widetilde{\mathcal M}_U$ be the $\mathcal O$-module +generated by $\theta\widetilde H_U$ and +$\theta(B_U[J]/2)\Theta_J$ for $J\subsetneq U$, together with all their +good-Hecke and diamond translates. Its generators are integral by this +formula and the good-Hecke coefficient formula. The finite-module and +Chebotarev-continuity argument of Lemma~\ref{co:traces} therefore applies +to $\widetilde{\mathcal M}_U$. A fresh trace kills every displayed unary +correction after coefficientwise reduction, also after further fresh +tests. Thus the same coefficientwise reduced determinant and trace +identities hold on the required orbit. + +\emph{The contraction and isolation identities.} +On $\theta\widetilde H_U$, two fresh traces in $G_K$ give zero after +reduction at every coefficient. To see this, start with an arbitrary +test index $Jrm^2$ and choose the two fresh primes outside that index +and the level. The filter imposes $\chi_K(D)=1$; since $U$ is all split, +the number of inert factors in $r$ is either zero or at least two. +The fresh traces replace $r$ by $rq_1q_2$, with both $q_i$ split. +In the first case the valuation after division by $4$ is at least +$\omega(r)+2+1-2=\omega(r)+1\ge1$. In the second case it is at least +$\omega(r)+2-2=\omega(r)\ge2$. The unary terms disappear under these +fresh tests. Additional fresh $G_K$ traces only improve these estimates, +so vanishing holds on the entire reduced trace orbit. The trace identity +therefore gives +\[ + t(gu^2)=t(g)\qquad(g,u\in G_K) +\] +on this reduced trace orbit. Thus the tests factor through the elementary +extension of $K$ unramified off the level. + +A single fresh $K$-split trace at coefficient $1$ reads the bit +\begin{equation}\label{pw:deeper-bit} + \widetilde A(D)= + \left(2^{-\omega(D)-1}a(D)\text{ with its phase removed}\right)\bmod2 +\end{equation} +for a nonempty all-split configuration. The contraction rule follows +from the same integral local identity as in Lemma~\ref{co:inertia}. +For completeness its first shell, with $p\in U$ and a fresh trace $q$, +has underlying configuration $D'=(U/p)q$, which is still nonempty, and +its reduction is +\[ + c_p(D')\widetilde A(D'),\qquad + c_p(D')=\frac{a_p-(D'/p)-1}{2}\bmod2. +\] +Changing the oriented inertia bit changes $c_p$ once. The omitted-prime +identity gives the product label and removes the entire rational prime +$p$ from the new ramification support. Consequently its repeated +contraction has precisely the forest interpretation of +Lemma~\ref{gr:forest}. An omitted-vertex label equal to the identity has +trace zero, which is primary isolation. No contraction to the empty +configuration has occurred. + +\emph{A nonempty witness for the deeper test.} +It remains to prove that this deeper test has a witness. Fresh +ramification gives $K\not\subseteq\mathbb Q(E[8])$. By Chebotarev there +is a good prime $p$ inert in $K$ and trivial on the original $E[8]$. +Then +\[ + p\equiv1\pmod8,\qquad a_p(E^{(k)})\equiv-2\pmod8. +\] +On $\widetilde H_\varnothing$, whose coefficient at $1$ is zero, test +$t(u)^2$ at coefficient $1$, where $u=\operatorname{Fr}_p$. The square +coefficient and matching unary character give, up to a unit, +\[ + \frac{a_p(E^{(k)})-1-p}{4}\bmod2=1. +\] +The determinant term at coefficient $1$ cancels. In characteristic two, +$t(u^2)=t(u)^2$, so a single trace in $G_K$ is nonzero. A fresh prime +realizing this finite trace test is split in $K$. Moreover $u^2$ is +trivial on every rational quadratic character, so the prime lies on the +required total rational filter. It is a nonempty witness for +\eqref{pw:deeper-bit}. Finally the exact coefficient ratio gives +\eqref{pw:split-unit-bound}, with the additional depth at most one. +\end{proof} + +\begin{lemma}[Orientation correction]\label{pw:coinvariants} +Let $K$ be imaginary quadratic, let $S_0$ contain $2$ and its ramification +support, and let $V_0$ be the elementary label space over $K$ unramified +off $S_0$. Complex conjugation acts on $V_0$ by $c$. If the rational +total of an oriented prime configuration is zero on every rational +quadratic character unramified off $S_0$, then its oriented total belongs +to $(1+c)V_0$. A reserved supply containing every label allows its +orientations to be flipped to realize any prescribed change in +$(1+c)V_0$. +\end{lemma} + +\begin{proof} +Complex conjugation has order two outside $G_K$, so +$G_{\mathbb Q}=G_K\rtimes\langle c\rangle$. A $c$-invariant quadratic +character of $G_K$ extends by giving $c$ value zero. At a rational prime +outside $S_0$, inertia lies in $G_K$ and the character is trivial there; +thus its extension remains unramified outside $S_0$. The assumed total +therefore annihilates $(V_0^*)^c$. + +For a finite vector space with involution, the annihilator of +$\ker(1+c^*)=(V_0^*)^c$ is $\operatorname{im}(1+c)$. This proves the +first assertion. Flipping a vertex of label $v$ changes its oriented +label from $v$ to $cv$, and hence changes the total by $(1+c)v$. +Reserve one representative for every preimage needed to express the +desired element of the image. Their independent flips give the second +assertion. These flips preserve every rational norm label. +\end{proof} + +\subsection{The corank-one original base}\label{pw:assembly-section} + +\begin{proposition}[Odd original base]\label{pw:odd-base} +If $s_2(E)=1$, then $a(E)=1$. +\end{proposition} + +\begin{proof} +Parity gives odd functional sign. Use the normalized odd limit symbol +on the positive filter of $1$ from Section~\ref{pw:odd-stages}, with +its fixed support, genus partner $h_*$, and chosen ultrafilter. If it +detects the base, a sufficiently advanced actual stage proves the result. +Otherwise choose its nonempty minimum seed. The moving detecting prime +$\ell$ is not an extra fixed support requirement. + +\emph{Fixing the companion.} +Choose a separate even symbol for negative discriminants square at $2N$, +excluding the fixed odd support, the relevant torsion ramification, and +the exceptional imaginary fields. Choose a unit $k$ of that symbol. +Then $L(E^{(k)},1)\ne0$. Fix this $k$ and +$K=\mathbb Q(\sqrt{k})$ for the rest of the proof, before choosing any +cube dimension. Its fresh ramification makes it independent of the old +fixed label extensions. At sufficiently advanced stages $\ell$ avoids +$k$. The intrinsic odd label tests continue to omit the primes of $k$. + +We construct common terminal packets, individually split in $K$, such +that the odd terminal polynomial and an even terminal polynomial testing +$hk$ are separately nonzero at each nonzero address. They need not have +a common unit evaluation yet; the address lemma will supply that step. + +\emph{The quadratic residual case.} +First suppose $F,F'$ are quadratic. Keep the original even symbol +evaluated on $hk$, treating the vertices of $k$ as stationary external +data. Enrich the rational labels of the $h$-vertices by the primes of +$k$. Their total there and at the even support is required to be zero. +Let $V$ be the resulting rational elementary label space, including the +$F,F'$ and $K$ coordinates and all relations among these characters. +The allowed simple labels form the affine set +$\{v\in V:\chi_F(v)=1,\ \chi_K(v)=0\}$, in additive notation. +The difference of any two of its elements belongs to +$\ker\chi_F\cap\ker\chi_K$, precisely the realizable rational labels +of the permitted split attachments. Translation by this subgroup is +therefore transitive. The fields $F,F'$ are unramified outside the old +support, whereas $K$ has a fresh ramified prime; thus $K$ is independent +of their compositum. When $F\ne F'$, this realizes both the good-simple +pattern $(1,1,0)$ and the donor pattern $(0,1,0)$ in their three +coordinates. When $F=F'$, all simple labels are good. + +For the old odd projection, take a normal closure of its finite label +extension at any stage with $\ell$ avoiding $k$. It is unramified outside +the old support and $\ell$. Once $\ell$ avoids +$k$, a prime ramified in $K$ remains outside that set. Hence $K$ +has trivial intersection with this normal closure, and every old odd +label can be realized together with splitting in $K$. This applies +also to oriented split anchors over $F$. The added stationary $k$ +coordinates may have relations, but they are already included in $V$; +they do not impose extra requirements on the omitted odd projection. +These compatible lifts let us stabilize the common alphabet and its +projection maps on the same ultrafilter, as in Section~\ref{pw:odd-stages}. +The intrinsic odd minimum and seed are unchanged. Choose the following +packets in this fixed abstract alphabet, before selecting an actual stage. + +Use packets with sufficiently large simple supply and reserves in this +kernel, and with donor slack when \(F\ne F'\). For the even test, take +no split anchors. If the fields are distinct, correct all bad simples +to good ones; if they coincide, every simple is already good. Pair +equal enriched labels, and +retain a nonempty good base pair. Use reserves to match the pair and +the remaining good pairs, and attach every leftover split vertex to the +last base position. Its label is forced by total zero. The output is +a collection of good twin pairs, each matching also at every split +vertex of $k$. Twin insertion into the unit at $k$ proves that this +output has even symbol one. Thus the even terminal polynomial is +nonzero. + +For the odd test, project away the newly added tests at $k$. The same +packets contain enough split anchors, simple vertices and reserve shifts +to contract to the stabilized odd seed and good pairs, by +Lemma~\ref{pw:reserves}. Its total on that projection is the prescribed +zero total. Incidences between the retained anchors and the good pairs +can be set after contraction, by independent edge choices. The odd +polynomial is therefore nonzero as well. This odd test does not include +the stationary vertices of $k$. + +\emph{Full rational two-torsion.} +Now suppose the curve has full rational two-torsion. Use the even test +of Lemma~\ref{pw:split-witness}, with $K$-oriented labels on its support +$S_0$, and let $v_1,\ldots,v_r$ be a minimum nonempty witness. Its +oriented total $v_1+\cdots+v_r$ lies in $(1+c)V_0$, by +Lemma~\ref{pw:coinvariants}. This even test uses the oriented elementary +extension of $K$, whereas the odd test reads only its rational projection; +the even contraction rule is needed only for nonempty outputs. +Every odd seed label lifts to a $K$-split prime because $K$ was freshly +ramified outside its intrinsic support. Each even label also has a +compatible lift to the common alphabet. Stabilize the finite common +alphabet and projections on the same ultrafilter, preserving the +intrinsic odd symbol as in Section~\ref{pw:odd-stages}. + +Choose packets containing ample copies of every needed even label, all +odd seed labels on their rational projection, and orientation-shifting +reserves. Arbitrary pairs of projected labels need not lift: take a +union of sufficiently many compatible lifts for each projection +separately. Duplicate each full label, so the packet has rational +total zero. + +For the even contraction, retain anchors with labels +$v_1,\ldots,v_{r-1}$. After reserving these anchors, use orientation +flips to make the total equal to $\sum v_i$; this is possible by +Lemma~\ref{pw:coinvariants}. In a contraction certificate these flips +are choices of conjugations along the forest, as permitted by +Lemma~\ref{gr:realization}; they do not change the common terminal data +separately at different addresses. Merge all remaining vertices into the +last cluster. Its label is $v_r$. The cluster is nonempty, and the +minimum nonempty count makes the output a unit independently of its +mutual edges. For the odd contraction, use its rational projection. +Retain all but the last odd seed label and merge the remainder. Total +zero gives the last label, +so this is also a unit. Orientation corrections for the even test did +not change these rational labels. + +\emph{Simultaneous addressing and an actual stage.} +Now fix $b$ and put a sufficient common packet at every nonzero linear +form on $\mathbb F_2^b$. Each nonzero address has two separately +nonzero terminal polynomials. In the fixed abstract alphabet, +Theorem~\ref{gr:address} gives finite primary-auxiliary networks making +both symbols one there. Require their primary types to split in $K$ +(and $F$ in the quadratic case) and to be neutral at the stationary +primes of $k$. They are primary at every support coordinate used by +either projection, so both symbol identities apply to the same common +graph data. + +Let $W_b$ bound all graph weights required by these finite networks. +A finite intersection of ultrafilter-large sets supplies an actual stage +with the same truth table through $W_b$, all +required divisibilities and trace identities, and sufficient precision +for the prescribed divisions. The moving prime also avoids the fixed +companion $k$. Realize the resulting finite graph at that stage using +Lemma~\ref{gr:realization}. All active products $h$ are positive and +square at the fixed tests, and all their primes split in $K$. No +auxiliary appears at address zero. The depth constant and fixed +companion remain unchanged as $b$ grows. + +\emph{Returning to the original curve.} +At every nonzero address the analytic orders of $E^{(h)}$ and $E^{(hk)}$ +are respectively one and zero. The odd unit bound, the even unit bound +(or \eqref{pw:split-unit-bound}), and +Lemma~\ref{pw:height-comparison} with fixed $k$ give +\[ + 2j_h(k)\le 4w(h)+C. +\] +The finite Sha lengths at these addresses are nonnegative, so this also +bounds $2j_h(k)-4w(h)-s(h)-s(hk)$ from above. + +At address zero, $L(E^{(k)},1)\ne0$ gives $s_2(E^{(k)})=0$ by the +forward theorem. Lemma~\ref{pw:isogeny-corank} therefore gives +$s_2(E/K)=1$. Ring-class missing-vertex transfer now makes the base +product $L(E,s)L(E^{(k)},s)$ have a simple zero. Its second factor is +nonzero at $1$, and hence $a(E)=1$. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:main}] +Use Lemma~\ref{pw:isogeny-corank} to choose the indicated isogeny +orientation before constructing either coefficient system. +The even coefficient system and cyclotomic transfer give both +Proposition~\ref{pw:partitionable-even} and the corank-zero conclusion +of Proposition~\ref{pw:even-base}. The bounded varying companion, +ring-class lower bound, and height comparison then establish +Proposition~\ref{pw:odd-lower}. This discharges the arithmetic premise +before the odd normalization and finite-graph construction of +Section~\ref{pw:odd-stages}. + +For the corank-one case, Proposition~\ref{pw:odd-base} fixes a nonvanishing +even companion before the cube dimension, constructs simultaneous unit +vertices, and applies ring-class transfer at the original base. This gives +$a(E)=s_2(E)$ in both cases. The established Gross--Zagier--Kolyvagin implication in +analytic rank zero or one gives $r(E)=a(E)$ and finiteness of the whole +Shafarevich--Tate group. Equation~\eqref{pw:kummer-corank} remains the +underlying corank identity throughout. In particular, neither a finite +two-Selmer dimension nor Mordell--Weil rank was substituted for the +original Selmer corank hypothesis. +\end{proof} + +\begin{remark}[The prescribed base]\label{pw:status} +The final companion has Selmer corank zero because it was chosen with +nonzero central value. Thus \eqref{pw:quadratic-corank} supplies the +required corank over $K$; it is not an additional companion hypothesis. +Only the finite realizations and their precisions change as the cube +grows. The valuation constants remain fixed, so transfer applies to the +prescribed original curve without deleting a density-zero set of bases. +\end{remark} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/preliminaries.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/preliminaries.tex new file mode 100644 index 0000000000000000000000000000000000000000..351a54d5ce1d0609383452a181060c396687348d --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/preliminaries.tex @@ -0,0 +1,151 @@ +\section{Selmer coranks and fixed local data}\label{sec:preliminaries} + +For an elliptic curve $A/\Q$, put +\[ + r(A)=\rank_{\Z}A(\Q),\qquad + a(A)=\ord_{s=1}L(A,s),\qquad + s_2(A)=\corank_{\Z_2}\Sel_{2^\infty}(A/\Q). +\] +The Selmer group uses the local Kummer image at every place. +The analytic continuation and functional equation are supplied by modularity +\cite{BCDT2001}. Write $\varepsilon(A)\in\{1,-1\}$ for the root number. + +\begin{lemma}[The three ranks]\label{pr:ranks} +There is an exact sequence +\[ +0\longrightarrow A(\Q)\otimes\Q_2/\Z_2 +\longrightarrow \Sel_{2^\infty}(A/\Q) +\longrightarrow \Sha(A/\Q)[2^\infty]\longrightarrow0. +\] +Consequently +\[ +s_2(A)=r(A)+\corank_{\Z_2}\Sha(A/\Q)[2^\infty]. +\] +If $a(A)\in\{0,1\}$, then $r(A)=a(A)$ and the whole group +$\Sha(A/\Q)$ is finite. In that case $s_2(A)=a(A)$. +\end{lemma} + +\begin{proof} +The Kummer sequences for multiplication by $2^n$, with the local +Kummer conditions imposed, give +\[ +0\longrightarrow A(\Q)/2^n A(\Q) +\longrightarrow \Sel_{2^n}(A/\Q) +\longrightarrow \Sha(A/\Q)[2^n]\longrightarrow0. +\] +Their direct limit is the displayed sequence. Taking $\Z_2$-coranks proves +the identity. The analytic-rank-zero and analytic-rank-one assertions are +the Gross--Zagier--Kolyvagin theorem +\cite{GrossZagier1986,Kolyvagin1990}; see also the precise unrestricted +forward statement in \cite[\S1]{Skinner2020}. +\end{proof} + +No finite $2$-Selmer dimension will be substituted for $s_2$. +In particular, $s_2(A)=1$ does not supply a rational point of infinite order: +the exact sequence allows a contribution from the divisible part of $\Sha$. + +\begin{lemma}[Parity and change of curve]\label{pr:invariance} +For every elliptic curve $A/\Q$, +\[ +(-1)^{s_2(A)}=\varepsilon(A). +\] +A rational isogeny preserves $a$, $r$, and $s_2$. If +$K=\Q(\sqrt{k})$ is quadratic, then +\[ +s_2(A/K)=s_2(A/\Q)+s_2(A^{(k)}/\Q). +\] +\end{lemma} + +\begin{proof} +The $2$-parity assertion is due to Monsky \cite{Monsky1996}; +see also \cite[Theorems~1.4 and~4.19]{DokchitserDokchitser2010}, +which states the Selmer-parity result for every prime and credits +Monsky for the case $2$. +For an isogeny and its dual, both composites are multiplication by the +degree. The corresponding maps on rational points and on Selmer groups +respect the Kummer conditions. After rationalizing their Tate modules, +the maps are inverse up to a nonzero scalar; hence the ranks and coranks +agree. The equality of $L$-functions is isogeny invariance. + +Over $K$, identify $A^{(k)}$ with $A$, and let $c$ be the nontrivial +element of $\Gal(K/\Q)$. Restriction and the two conjugation +projections $1+c$ and $1-c$ define maps between the sum of the two +Selmer groups over $\Q$ and the Selmer group over $K$ whose composites are +multiplication by $2$. Functoriality of local Kummer images gives these +maps at every place. Rationalization therefore gives the stated corank +identity. This argument does not assert an integral direct-sum +decomposition of the Selmer groups. +\end{proof} + +Fix a curve $E/\Q$ of conductor $N$. A finite support $S$ always contains +the primes dividing $2N$. It may be enlarged by finitely many primes when +the fixed construction is prepared. A \emph{local filter} consists of a +real sign and unit squareclasses at $S$ for the variable fundamental +discriminant. The filter is imposed on every relevant Fourier index, +not just the squarefree indices. Its root number is constant. +All variable primes lie outside $S$. + +For an odd prime $p$, set +\[ +p^*=\left(\frac{-1}{p}\right)p. +\] +Nonempty products of distinct $p^*$ are odd fundamental discriminants. +We also admit the empty product $h=1$, which denotes the untwisted +curve rather than a quadratic field. For a squarefree product $h$ of +such factors, set +\[ + t_p=\dim_{\F_2} E[2]^{\operatorname{Fr}_p}, + \qquad + w(h)=\frac12\sum_{p\mid h}t_p. +\] +In the rational-two-torsion range, $t_p$ is $1$ or $2$. +Whenever the $2$-primary group below is finite, write +\[ +s(h)=\length_{\Z_2}\Sha(E^{(h)}/\Q)[2^\infty]. +\] +Thus $s(h)$ is a finite length, whereas $s_2(E^{(h)})$ is a corank. +In particular $s(h)$ is defined when $s_2(E^{(h)})=0$: the exact +sequence in Lemma~\ref{pr:ranks} and finite generation of the dual +Selmer group make its $2$-primary quotient finite. This conclusion +concerns the $2$-primary group; the low-analytic-rank theorem supplies +finiteness of the whole group after analytic nonvanishing is proved. +Let $v$ be a valuation above $2$, normalized by $v(2)=1$. +After the coefficient field has been fixed, its value group is discrete. + +The notation $L_*(h)$ denotes $L(E^{(h)},1)\sqrt{|h|}$ divided by the +fixed real or imaginary period appropriate to the filter. +The notation $\mathcal L(h)$ in Section~\ref{cy:section} denotes +this same normalized value. +Every modular parametrization used to form Heegner points is normalized +to send the cusp $\infty$ to the identity of the elliptic curve. +Changing among fixed nonzero modular parametrizations, isogenous curves, +or period conventions contributes only bounded constants to valuations. +Every such dependence is fixed before a binary cube is allowed to grow. +Dependence on a growing number of prime factors will always be stated +explicitly. + +The following ledger records the order of choices used in the proof. +It distinguishes bounds from the sizes and precisions needed to realize +the auxiliary primes. +\begin{center} +\small +\begin{tabular}{@{}>{\raggedright\arraybackslash}p{0.29\textwidth}>{\raggedright\arraybackslash}p{0.65\textwidth}@{}} +\toprule +Data or bound & Allowed dependence and order of choice \\ +\midrule +Fixed arithmetic constants & The curve, its parametrization and periods, +the fixed part of the support, and the chosen local classes; these are fixed before +the varying prime support or cube dimension. \\ +Varying quadratic companions & The same data and a bound $A$ for +the number of prime factors of the companion discriminant; its prime +sizes do not enter. \\ +Fixed-companion transfer & The companion field is fixed before the +cube dimension. Constants may depend on its fixed base Selmer data, +as specified in Section~\ref{rd:section}. \\ +Finite realization & Choose the cube dimension and finite networks, +then the required coefficient precision and a sufficiently late +arithmetic stage. Prime sizes and stage thresholds may depend on +these choices. \\ +\bottomrule +\end{tabular} +\end{center} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/proof-roadmap-figure.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/proof-roadmap-figure.tex new file mode 100644 index 0000000000000000000000000000000000000000..442cb894fd21b5d9eaded729b502477147cba259 --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/proof-roadmap-figure.tex @@ -0,0 +1,44 @@ +\begin{figure}[htbp] +\centering +\small +\setlength{\tabcolsep}{6pt} +\begin{tabular}{c} +\fbox{\parbox{0.86\textwidth}{\centering +Even coefficients, finite prime networks and cyclotomic transfer\\ +\begin{tabular}{@{}c@{\qquad}c@{}} +$\swarrow$ & $\searrow$\\ +Uniform even estimate & Corank-zero conclusion\\ +(Proposition~\ref{pw:partitionable-even}) & (Proposition~\ref{pw:even-base}) +\end{tabular}}} +\\[5pt] +Even estimate $\Downarrow$\\[5pt] +\fbox{\parbox{0.86\textwidth}{\centering +Fix $h_*$ to define $P_h$; choose a bounded-factor companion $k'(h)$\\ +Even estimate + ring-class lower bound\\ +$\Downarrow$\\ +Uniform lower bound for the $2$-divisibility of $P_h$\\ +and odd coefficient normalization}} +\\[5pt] +$\Downarrow$\\[5pt] +\fbox{\parbox{0.86\textwidth}{\centering +Fix $k$ with $L(E^{(k)},1)\ne0$ and put $K=\Q(\sqrt{k})$\\ +Odd and even tests + finite prime networks split in $K$\\ +$\Downarrow$\\ +Simple zeros for $E^{(h_x)}$ and nonzero values for $E^{(h_xk)}$\\ +with a common normalized index bound, for every $x\ne0$}} +\\[5pt] +$\Downarrow$\\[5pt] +\fbox{\parbox{0.86\textwidth}{\centering +Fixed-$K$ ring-class transfer and $s_2(E/K)=1$\\ +$\Downarrow$\\ +Analytic rank one at the original vertex $x=0$}} +\end{tabular} +\caption{The even construction proves the corank-zero case and a uniform +estimate; the latter supplies the bound needed to normalize the odd coefficients. +The detector partner $h_*$ is fixed, the bounded-factor companion $k'(h)$ +varies only in the lower-bound step, and the final companion $k$ is fixed +before the simultaneous families are constructed. The families and +auxiliary primes may grow with the cube dimension; the normalized +index bound may not.} +\label{fig:proof-roadmap} +\end{figure} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/ring-determinants.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/ring-determinants.tex new file mode 100644 index 0000000000000000000000000000000000000000..cbd7c23e294a676956a60c3e82360e30c8f97232 --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/ring-determinants.tex @@ -0,0 +1,1769 @@ +\section{Ring-class switches, determinant lattices, and transfer} +\label{rd:section} + +This section constructs the derivative classes and proves the determinant +and transfer statements. The arithmetic models, the character \(\Psi\), and their +evaluation maps are those of Lemmas~\ref{rl:finite-model}, +\ref{rl:finite-limits}, \ref{rl:evaluation}, and \ref{rl:kernel}, +and Propositions~\ref{rl:characters} and \ref{rl:outer-evaluation}. +There are two outputs. Corollary~\ref{rd:ring-lower} bounds a +Heegner-point index at a known simple zero, uniformly in the conductor +and with dependence only on a bound for the number of companion primes. +Theorem~\ref{rd:missing-vertex} instead fixes the companion field and +recovers an unknown base derivative from a family of known simple zeros. +The first step is an integral switch: adding a derivative prime replaces +a finite local condition by its singular counterpart without changing +the determinant valuation. Repeated switches then give the uniform +lower bound. For the missing vertex we need more: the determinants +must occur in one group-ring family with a uniformly bounded clearing +factor. We construct the arithmetic diagrams before applying these two +arguments, and verify their specialization and family properties where +they are used. + +Fix \(E/\mathbb Q\), put \(T=T_2(E)\), and normalize \(v(2)=1\). Let +\[ + \Lambda=\mathbb Z_2[[t]],\qquad + \mathcal O=\widehat{\Lambda_{(2)}},\qquad + \Omega=\mathbb F_2((t)). +\] +For a perfect cohomological complex \(C\), use the inverse determinant line +\begin{equation} + \mathcal D(C)=\bigotimes_i(\det C^i)^{(-1)^{i+1}}. + \label{rd:det-convention} +\end{equation} +In particular, for a complex in degrees one and two this is +\(\det C^1\otimes(\det C^2)^{-1}\). A basis of this integral line is fixed +whenever a determinant coordinate is mentioned. Changing it multiplies +the coordinate by an integral unit. + +The ring data consist of an imaginary quadratic field \(K=\mathbb Q(\sqrt k)\) +split at \(2N\), a product \(h\) of signed good odd primes split in \(K\), +and \((h,k)=1\). The fields with extra units and the CM field of \(E\) +are excluded. Write +\begin{equation} + t_p=\dim_{\mathbb F_2} E[2]^{\operatorname{Fr}_p},\qquad + w(h)=\frac12\sum_{p\mid h}t_p. +\label{rd:weights} +\end{equation} +Choose the modular parametrization \(\pi:X_0(N)\to E\) +normalized by \(\pi(\infty)=0\), translating it by the rational +point \(-\pi(\infty)\) first if necessary. By the Manin--Drinfeld theorem +\cite{Manin1972,Drinfeld1973}, images of cusp +differences are torsion, so one fixed integer kills every +cuspidal ambiguity. No assertion that an arbitrary translate +has torsion value at \(\infty\) is used. +The scalar deformation is trivial at \(2N\), has unit exponent on the +auxiliary conductor inertia, and odd exponent at the indicated split +conductor Frobenii. Its auxiliary prime \(r\) is allowed to change with +the precision. The trace bound in Proposition~\ref{rl:characters} is part of +the data. + +\subsection{The local switch and its integral determinant} +\label{rd:local-subsection} + +\begin{lemma}[The split local model]\label{rd:local-model} +Let a sequence of inert good primes \(\ell\) have rational Frobenius +lifts tending on \(T\) to a fixed complex conjugation \(J\). +At the unique prime of \(K\) above \(\ell\), the limiting local complex +has +\begin{equation} + H^0=M,\qquad H^1=F\oplus S=M\oplus M,\qquad H^2=M, + \label{rd:local-cohomology} +\end{equation} +with zero differentials in a free split model. Here \(M=T\otimes\Lambda\) +with the relevant scalar coefficient structure. The two degree-one +coordinates of a cocycle are +\begin{equation} + f(c)=c(\gamma^2),\qquad s(c)=c(\sigma), + \label{rd:coordinates} +\end{equation} +where \(\gamma\) is the chosen rational Frobenius lift and +\(\sigma\) is an oriented pro-\(2\) tame generator. The plane +conditions \(F=\{s=0\}\) and \(S=\{f=0\}\) include \(H^0\) and exclude +\(H^2\). Each is its own orthogonal complement for conjugate-Weil +duality. The strict condition \(H^0\) and the relaxed condition +\(H^0\oplus H^1[-1]\) are mutually dual. All four inclusions can be +equipped with compatible integral duality triangles. +\end{lemma} + +\begin{proof} +The prime-to-\(\ell\) local cochains are computed by the tame inertia and +residue-field directions. In these two directions the differentials +are formed from inertia minus one and Frobenius minus one, with the +usual Frobenius action on tame inertia. On \(M\), inertia is trivial at +the derivative prime. The square of a rational Frobenius is trivial +on every ring-class character. In the limit it is also the identity on +\(T\), while \(\ell^2\) tends to one. Thus both differentials become zero, +giving \eqref{rd:local-cohomology}. + +Here is a finite-precision check of the pairing, needed at \(2\). +At a retained quotient killed by \(2^a\), impose also +\(q=\ell^2\equiv1\pmod{2^{a+1}}\), as well as trivial +Frobenius-square action on the coefficient module at this quotient. +The tame two-generator complex then has zero differentials, +with the coordinates in \eqref{rd:coordinates}. Its degree-one +scalar generators are the unramified and tame characters. +More explicitly, use the presentation +\(\phi\sigma\phi^{-1}\sigma^{-q}=1\). +After augmentation with trivial coefficient action its Fox +resolution has terms of ranks \(1,2,1\), with +\(d^0=0\) and \(d^1=(0,1-q)\), in the ordered finite and +tame coordinates. The diagonal from the same resolution +has zero pure-finite term, unit mixed terms, and pure-tame +coefficient \(\pm\binom q2\). The latter coefficient is +the augmented second derivative of \(\sigma^{-q}\) +together with its adjacent \(\sigma\) in the relation. +Both \(1-q\) and \(\binom q2\) vanish modulo \(2^a\) +under the imposed congruence. Thus this is an actual +split complex and an actual pure-plane zero pairing +at the retained precision. +The field contains the \(2^{a+1}\)-st roots of unity, so +\(-1\) is a \(2^a\)-th power. The norm-residue identity +\((x,x)=(x,-1)\) for the \(2^a\)-Hilbert symbol therefore +makes the square of each scalar generator zero. +The two generators form a basis; local Tate duality makes +their cross pairing a unit. The same calculation applies +coefficientwise to the free Artin coefficient module, including +its nilpotent \(t\) and quadratic variables. Thus the pure +plane restrictions are already zero at every retained quotient. +All these congruences can be imposed simultaneously with the +derivative Frobenius conditions by increasing their precision. +Taking the compatible limit proves integral vanishing of the +pure squares. It is not deduced from skew symmetry in +characteristic two. + +Equivalently, in the limiting tame presentation +\(\phi\sigma\phi^{-1}=\sigma^q\) with \(q\to1\), the +rank-\((1,2,1)\) resolution specializes to the exterior +resolution for two procyclic directions. The finite +Hilbert-symbol calculation specifies the cup product on +its split cohomology and rules out a hidden square term. +Conjugation transports the finite Tate coordinate by \(J\) and the +singular coordinate by \(-J\), with possible scalar units coming from +the orientations. Consequently the cross pairing is +\begin{equation} + \beta(x,y)=\epsilon\,\langle x,Jy\rangle,\qquad + \epsilon\in\Lambda^\times,\quad x\in F,\ y\in S, + \label{rd:cross-pairing} +\end{equation} +where \(\langle\, ,\,\rangle\) is the perfect alternating Weil form. +This proves the assertions about orthogonal complements. Since the +restrictions of this explicit pairing to either pure plane are zero as +maps of the split complexes, their isotropy homotopies may be chosen to +be zero. Only a product of two degree-one terms could map to the +degree-two local invariant target; the degree-zero terms introduce +no additional restriction. These zero homotopies agree on the +strict subcomplex. These are the actual +orthogonality data required in the Selmer duality construction +\cite[Theorem~6.3.4]{Nekovar2006}; the compatibility assertion is therefore +an assertion about these displayed complexes and maps. Lemma~ +\ref{rl:finite-limits} is used to retain this finite diagram together +with the unchanged local data. +\end{proof} + +We now construct global classes with these local coordinates, using +the CM points \(y_m\in E(H_m)\) fixed in Section~\ref{rl:section}. +For the fixed twist put +\(c=|h|\). If \(I\) is a finite set of derivative primes, put +\(n=\prod_{\ell\in I}\ell\); the points used for this set have +conductor \(crn\). + +Let \(C_I\) denote the limiting Selmer complex with coefficients +\(T\chi_h\Psi\). Its local conditions are Kummer at \(2N\), full +at the active primes dividing \(h\) and at \(r\), singular at the +primes in \(I\), and unramified elsewhere. At a new derivative +prime \(\ell\notin I\), the unramified condition is the finite +plane \(F_\ell\) of Lemma~\ref{rd:local-model}. Both plane +conditions retain local \(H^0\) and omit \(H^2\), as in that +lemma. The next result constructs the class \(P_I\) in this +complex; its two displayed localizations are taken at the newly added +prime \(\ell\). + +\begin{lemma}[Descent and the switch at \(2\)]\label{rd:derivative} +Perform each finite ring-class construction and its weighted transfer +before retaining its target-side data by the construction following +Lemma~\ref{rl:finite-limits}. There is one +integer \(L\ne0\), depending on the fixed curve, parametrization and +fixed local types, such that the classes obtained from the Heegner +derivatives of \(L\) times the point satisfy, for every finite switched +set \(I\), +\begin{equation} + P_I\in H^1(C_I),\qquad + f(P_{I\cup\{\ell\}})=0,\qquad + s(P_{I\cup\{\ell\}})=J f(P_I). + \label{rd:switch} +\end{equation} +The same \(L\) works for every number of active and derivative primes. +The previously imposed singular conditions are retained. +\end{lemma} + +\begin{proof} +We use Kolyvagin's derivative operators \cite{Kolyvagin1990}, keeping +their integral descent explicit at $2$. Choose the orientations +coherently. The relative ring-class group at +an inert prime \(\ell\) is cyclic of order \(\ell+1\). For distinct new +primes these groups form a product: the ring-class exact sequence has +kernel the product of the local residue-unit quotients, and the only +global units here are \(1,-1\), whose images in these quotients are +trivial. Choose a generator \(\sigma_\ell\) compatibly with the +tame orientation in Lemma~\ref{rd:local-model}; its pro-\(2\) +component gives the coordinate \(s\) at the retained precision. +Set +\[ + D_\ell=\sum_{i=1}^{\ell} i\sigma_\ell^i,\qquad + D_I=\prod_{\ell\in I}D_\ell. +\] +Direct multiplication gives +\begin{equation} + (\sigma_\ell-1)D_\ell=(\ell+1)- + \sum_{i=0}^{\ell}\sigma_\ell^i. + \label{rd:derivative-identity} +\end{equation} +The Hecke correspondence and reduction of its CM isogenies give, for +every class-group translate, +\begin{equation} + \operatorname{Tr}(y_{c r n})=a_\ell y_{c r n/\ell}, + \qquad + \widetilde y_{c r n}=\operatorname{Fr}_\ell + \widetilde y_{c r n/\ell}. + \label{rd:heegner-relations} +\end{equation} +These are the point relations, not an application of a residual +irreducibility theorem. A fixed multiple of the parametrization removes +cuspidal terms. + +There is a uniform bound on the \(2\)-primary torsion over the union of +the ring-class fields in use. To see this, choose a fixed nonidentity +scalar homothety in the \(2\)-adic Tate image. Square a lift so that it +belongs to every quadratic subgroup under consideration. Multiply it +by its conjugate under complex conjugation. Its action on each +ring-class field is trivial, because conjugation inverts the abelian +ring-class action, while its action on \(T\) is still a fixed +nonidentity scalar. Write that scalar minus one as \(2^e\) times +a unit. Then \(2^e\) kills the torsion in question. The existence of +this fixed scalar, including the CM case, is the Tate-image input +used in Lemma~\ref{rl:kernel}. + +Work first with coefficients modulo \(2^a\). Require \(a_\ell\) and +\(\ell+1\) to vanish to a precision substantially larger than \(a\). +Equations \eqref{rd:derivative-identity} and +\eqref{rd:heegner-relations} then make the derivative Kummer class +invariant under the relative ring-class group. In the +inflation--restriction sequence, both the obstruction to descent and +the ambiguity of descent are killed by \(2^e\), since their +coefficient module is killed by \(2^e\). Multiplication by \(2^{2e}\) +therefore gives a descent independent of this ambiguity: descend +\(2^e\) times the class and multiply its lift by \(2^e\). +There is no repetition of this factor for individual primes; descent +is performed once from the field with the complete conductor. + +The target coefficient module is obtained by an integral transfer. +For a finite Artin coefficient ring \(A\), let +\(\Delta=\operatorname{Gal}(H_{cr}/K)\), through which the +finite scalar and quadratic characters factor. Shapiro's +cochain map and the coefficient homomorphism +\[ + A[\Delta]\longrightarrow A,\qquad + [\sigma]\longmapsto\chi_h(\sigma)\Psi(\sigma) + \] +send the descended class to coefficients \(T\chi_h\Psi\). +For a universal quadratic family, replace the quadratic +value by its group element in \(A[G]\), also including the +fixed base character. Choose inverse actions on both +sides when using that Shapiro convention. Explicitly, +these maps are finite coset sums with the indicated scalar +weights; there is no division by \(\#\Delta\). +These chain maps, in all degrees, are used at this finite stage. +Naturality of restriction and Kummer corestriction supplies their local +lifts and comparison homotopies. Apply the maps to the classes and +these witnesses before passing to bounded target models. Neither +the complex over \(H_{cr}\) nor its induced coefficient module +\(A[\Delta]\) is retained in the limiting diagram. We check the +required target local conditions next. + +At a place over \(2N\) these descent extensions are unramified. +For the identity component of a Neron model, the obstruction to +unramified descent vanishes. Indeed, Lang's theorem gives the assertion +on the connected special fiber, and the successive formal-group +quotients are additive residue-field modules, whose unramified cyclic +cohomology vanishes by the normal-basis and trace calculation. +Passing to the inverse limit of these quotients preserves the assertion. +The remaining obstruction is killed by the geometric component-group +order. Those orders have a uniform bound over unramified extensions +of the finitely many fixed local twisting types. Include their product, +the descent factor, and the parametrization factor in \(L\). +Thus the descended class has the integral Kummer condition at \(2N\). +No good-ordinary or semistability condition was used. Transfer with +the scalar character preserves this condition because \(\Psi=1\) +there. + +Here is the local calculation, including the division by two. Apply +the derivatives at all primes other than \(\ell\), and write \(X,Y\) +for the resulting lower and upper points. Put \(F_\ell=\operatorname{Fr}_\ell\). +The lower field splits at the \(K\)-prime \((\ell)\), since that ideal +is principal. Reduction therefore gives \(F_\ell^2\widetilde X=\widetilde X\). +Good reduction identifies the prime-to-\(\ell\) torsion with the +torsion of the reduced curve. In the following coordinate formulas, +\(F_\ell\) acts on reduced points, where it satisfies its +Frobenius polynomial. If \(Q\) is a \(2^a\)-division point +of \(LX\), the finite coordinate +of its Kummer class is +\begin{equation} + f=(F_\ell^2-1)\widetilde Q= + \bigl(a_\ell F_\ell-(\ell+1)\bigr)\widetilde Q. + \label{rd:finite-formula} +\end{equation} +We give the descent-cocycle calculation of the other coordinate. +Choose \(Z\) with \(2^aZ=LD_\ell Y\), and choose the descended +cocycle \(b\) so that on the upper-field Galois group it is +\(b(g)=(g-1)Z\). A change by the already bounded descent ambiguity +has no effect on the eventual limit. The crossed identity gives +\[ + U=(\sigma_\ell-1)Z-b(\sigma_\ell) + \in E(H_{crn}). + \] +For \(g\) in the upper-field Galois group, compare the two +expansions of \(b(g\sigma_\ell)\); they give \(gU=U\). +Moreover, +\[ + 2^aU=L\bigl((\ell+1)Y-a_\ell X\bigr). + \] +Both integers \(\ell+1,a_\ell\) are divisible by \(2^a\). +Consequently +\[ + U_0=L\frac{\ell+1}{2^a}Y- + L\frac{a_\ell}{2^a}X + \] +is an actual upper-field point with the same \(2^a\)-multiple +as \(U\). Thus \(U-U_0\) is upper-field torsion of bounded +exponent. This comparison with an actual integer quotient +is what bounds the ambiguity; arbitrary division points +would not give this bound. Reduction makes +\(\sigma_\ell\) act trivially and +\(\widetilde Y=F_\ell\widetilde X\). Therefore +reduction of \(b(\sigma_\ell)=-U\) gives its singular coordinate +\begin{equation} + s=\bigl(a_\ell-(\ell+1)F_\ell\bigr)\widetilde Q + \label{rd:singular-formula} +\end{equation} +up to the uniformly bounded descent torsion already described. +The Frobenius polynomial yields the exact operator identity +\begin{equation} + (F_\ell-a_\ell) + \bigl(a_\ell F_\ell-(\ell+1)\bigr) + =a_\ell-(\ell+1)F_\ell. + \label{rd:exact-frobenius} +\end{equation} +Thus \(s=(F_\ell-a_\ell)f\); when \(a_\ell\) vanishes at the +retained torsion precision, this is \(s=F_\ell f\). Taking the +Frobenius limit gives \(s=Jf\). + +For the new finite coordinate, reduction of the derivative point is +\begin{equation} + \sum_{i=1}^{\ell}iF_\ell\widetilde X + =\frac{\ell(\ell+1)}2F_\ell\widetilde X. + \label{rd:half-factor} +\end{equation} +The conductor extension at \(\ell\) is totally ramified, so a +Frobenius lift may be chosen in the upper-field local Galois group. +There the descended cocycle restricts to the Kummer cocycle of the +derivative point. If \(v_2(\ell+1)\ge a+1\), its displayed +reduction is \(2^a\) times an \(F_\ell^2\)-fixed point. +Its finite Kummer coordinate is therefore zero modulo \(2^a\). +The additional \(1\) is essential at +\(2\). It is imposed in the choice of the next precision, and does +not multiply the class by a new denominator. Bounded torsion +ambiguities disappear on passing from \(E[2^a]\) to \(E[2^m]\) with +\(a-m\ge e\). Choose \(a\) and the Frobenius precision successively +faster than \(m\). + +The calculation is compatible with every translate in the transfer: +transport the place and its Frobenius before applying that translate. +The scalar weight on the lower and upper class is identical. Applying +the same calculation at each \(\ell\in I\) proves the earlier +singular conditions as well. + +Finally complete the weighted transfer at each stage and retain the +resulting target Selmer-cone cycles and their local lifts. An equality +of the transferred local classes gives a boundary witness in the +target local complex; retain that witness after contraction as well. +For instance, retain the degree-zero vectors whose boundaries are the +differences in the two switch identities. Include the split local Fox +complexes, their zero isotropy homotopies, and the target comparison +matrices. The target-side construction in Section~\ref{rl:section} proves +that this is a bounded diagram for each fixed active support and +finite switched set. Its bound is independent of the degrees of +the ring-class fields. +When a further derivative prime is selected, extend the +same original finite-stage diagram and its contraction +maps, using the same inner ultrafilter. Do not construct +an unrelated cohomologically equivalent old complex. +The earlier evaluations, including all degree-two +cocycle identities, are consequently retained by the +same contraction maps after each new switch. Lemma~ +\ref{rl:finite-limits} applies to these extended diagrams. +Their limiting classes give +\eqref{rd:switch}. The displayed local formulas agree with the +calculation underlying \cite[Proposition~1.7.4]{Howard2012}; Howard's +odd-prime global hypotheses are not being asserted at \(2\). +\end{proof} + +\paragraph{The paired arithmetic determinant.} +All the target classes and comparison maps are constructed in the same +finite diagram. +At each Artin precision, use the character of +Proposition~\ref{rl:characters}, the global Selmer cone, and the +Kummer complexes at \(2N\). At a derivative prime impose enough +Frobenius precision for Lemma~\ref{rd:derivative} and also +\(\ell^2\equiv1\pmod{2^{a+1}}\) at every retained quotient killed +by \(2^a\). Lemma~\ref{rd:local-model} then gives the finite, +singular, strict and relaxed inclusions with their common zero +isotropy homotopies. Applying the actual global duality morphism +\eqref{rl:global-duality} constructs their integral localization +and duality triangles. Perform the descent and weighted transfers of +Lemma~\ref{rd:derivative} at each finite stage. Include their target +cycles, local Kummer lifts and target boundary witnesses in this +diagram before applying Lemmas~\ref{rl:finite-model} and +\ref{rl:finite-limits}, using only the target-side data. +All remaining maps have bounded target models as both source and +target; the ring-class source complexes are not among these objects. + +A further switch extends these original finite stages, their +contractions and their fixed inner ultrafilter. Theorem~ +\ref{rl:limit-evaluation-package} therefore retains the same +degree-zero, degree-one and degree-two evaluations and the +exact-kernel restrictions. In particular, the old evaluations +are not replaced by maps on an independently chosen equivalent +complex. + +Here is how a class produces its paired functional. Work over a +height-one localization where the full local complexes at the active +primes and \(r\) are acyclic. By Lemma~\ref{rl:local-acyclic} +this includes \(\mathcal O\) and every characteristic-zero test +used below. These complexes have integral contractions. They +identify the relaxed Selmer complex with its orthogonal complex; +at switched primes the plane condition is already self-dual, and +at \(2N\) the integral Kummer condition is self-dual. Lift the +class through this comparison and compose it with the retained +global duality map. The result is a closed degree-two functional +\(\lambda_I\), integral up to the single initial multiplier and +any fixed old-support correction. Thus it is not an arbitrarily +chosen rational cohomology dual. + +When the generic cohomology has dimension one in degrees one and +two and is zero elsewhere, define \(u_I\) to be the coordinate of +\[ + [P_I]\otimes[\lambda_I]\in + H^1(C_I)\otimes H^2(C_I)^* + \simeq\mathcal D(C_I) +\] +over the fraction field, in the fixed integral determinant basis. +For an acyclic constituent set this class-dual coordinate to zero. +The generic functional is determined by the same derived duality +at all localizations; different local contractions represent that +functional, not one cochain asserted to be integral everywhere. +For \(I=\varnothing\) write \(u_h\). The rank-one assertions +needed for the arithmetic applications are verified below by +rational central specialization. + +The arithmetic switch must now be compared in these determinant +lattices. A localized class may be divisible by \(2\); the next +lemma shows that such a division does not cost a factor at each switch. + +\begin{lemma}[Exact determinant switch over a DVR]\label{rd:det-switch} +Let \(O\) be a DVR with fraction field \(F_O\). Suppose that integral +perfect complexes \(C_{\rm str},C_F,C_S,C_{\rm rel}\), their +localization triangles, and their dualities are the base changes of +the diagram in Lemma~\ref{rd:local-model}. Suppose the generic cohomology of these four global complexes is +concentrated in degrees one and two, that +\(H^1(C_F\otimes F_O)=F_OA\), and +\[ + f(A)=v_0\ne0,\qquad s(B)=Jv_0,\qquad f(B)=0 +\] +for a class \(B\) in the switched complex. The determinant tensors +are formed from each class and its functional under these same +dualities. Then the switched generic cohomology has rank one, +is spanned by \(B\), and +\begin{equation} + v_O(u_F)=v_O(u_S). + \label{rd:valuation-switch} +\end{equation} +Neither localization is required to be primitive. +\end{lemma} + +\begin{proof} +For this proof only, cohomology without a coefficient ring means +cohomology over \(F_O\). Nonzero localization of \(A\) gives +\(H^1(C_{\rm str})=0\). The relaxed localization image is +self-annihilating in \(F\oplus S\), so it has dimension two. +It contains the two independent vectors \((v_0,0)\) and +\((0,Jv_0)\) in the opposite planes. Its intersections with either plane are therefore +exactly one-dimensional. This proves the generic rank assertions. + +Put \(V=H^1(C_{\rm rel})\), with ordered basis \(A,B\). +Duality identifies \(H^2(C_{\rm str})\) with \(V^*\); denote the +dual basis by \(A^*,B^*\). The two integral triangles are +\begin{equation} + C_{\rm str}\longrightarrow C_F\longrightarrow F[-1]\longrightarrow, + \qquad + C_{\rm str}\longrightarrow C_S\longrightarrow S[-1]\longrightarrow. + \label{rd:triangles} +\end{equation} +Their fraction-field exact sequences are +\[ + 0\longrightarrow F_OA\longrightarrow F + \xrightarrow{\delta_F}V^* + \longrightarrow F_OA^*\longrightarrow0 +\] +and the same sequence with \(A,F,A^*\) replaced by \(B,S,B^*\). +The boundary is the dual of the relaxed localization. In view of +\eqref{rd:cross-pairing} and \(s(B)=Jv_0\), it satisfies +\begin{equation} + \delta_F(x)=\epsilon_F\langle x,v_0\rangle B^*, + \qquad \epsilon_F\in O^\times. + \label{rd:boundary} +\end{equation} +Choose \(x\in F\otimes F_O\) with \(\delta_F(x)=B^*\). +Then \(v_0\wedge x\) has unit volume in the integral determinant +lattice \(\det_O F\), because the alternating form on \(F\) is +unimodular and \(\langle x,v_0\rangle\) is a unit. Although \(x\) +can be nonintegral, this assertion about its exterior product is +an equality of lattices. Similarly choose \(y\in S\otimes F_O\) +mapping to \(A^*\). The volume of \(Jv_0\wedge y\) is a unit in +\(\det_O S\). + +The determinant isomorphisms of the two exact sequences send +\[ + A\otimes(A^*)^* + \quad\hbox{and}\quad B\otimes(B^*)^* +\] +respectively, up to units and the irrelevant determinant sign, to +\begin{equation} + (A^*\wedge B^*)^*\otimes(v_0\wedge x), + \qquad + (A^*\wedge B^*)^*\otimes(Jv_0\wedge y). + \label{rd:common-tensor} +\end{equation} +These comparisons take place in +\(\mathcal D(C_{\rm str})\otimes\det F\) and +\(\mathcal D(C_{\rm str})\otimes\det S\). +The two plane determinants are identified by a unimodular map. +Hence the two coordinates have the same valuation. + +This also explains exactly where the finite indices go. For a +two-term elementary summand +\([O\xrightarrow{\pi^d}O]\) in degrees one and two, its contribution +to the coordinate in \(\mathcal D\) is \(\pi^{-d}\). +Such summands, including those arising from nonprimitive +localization, occur inside the integral isomorphisms +\eqref{rd:triangles}. They are not discarded when writing +\eqref{rd:common-tensor}. All strict torsion contributions are common +to the two sides. The argument does not ask for an integral +complement to \(v_0\); for example \(v_0=2^de_1\) is paired with +the fractional vector \(2^{-d}e_2\), whose exterior product with +\(v_0\) has unit volume. +\end{proof} + +\subsection{Rank reduction and the outer DVR} +\label{rd:outer-subsection} + +The local switch preserves a determinant valuation. We now use it to +reduce the dimension of any larger specialized Selmer space until a +nonzero minor controls that valuation. The first argument handles each +characteristic-zero height-one prime. A second, outer limit turns a +hypothetical sequence of unbounded losses at $(2)$ into the same rank +reduction problem. + +\begin{lemma}[Selecting a rank-two evaluation]\label{rd:rank-two} +Let \(\mathcal G\) be a group, \(H\) a normal subgroup acting trivially +on an absolutely irreducible representation \(W\) over a field \(F_O\), +and suppose that restriction of the relevant cohomology classes to +\(H\) is injective. For two independent classes, their joint +evaluations on \(H\) span \(W\oplus W\). If the finite localization +is the rank-two projection supplied by \(1+\tau\) on the induced +representation, some actual evaluation has rank two. One of the +two classes may be any prescribed nonzero class. +\end{lemma} + +\begin{proof} +On \(H\) a crossed homomorphism is an additive homomorphism, and its +image is equivariant for \(\mathcal G\). A proper submodule of +\(W\oplus W\) dominating both factors would impose a nonzero +scalar linear relation on the two evaluations: the direct sum of +two simple modules is semisimple, and +\(\operatorname{End}_{\mathcal G}(W)=F_O\). +That relation, followed by injectivity of restriction, would +contradict independence of the classes. Thus the joint span is +the whole direct sum. Projecting by \(1+\tau\) gives all pairs +in the two-dimensional finite plane. + +It remains to pass from a span to a single element of the additive +evaluation image \(U\). If the determinant quadratic polynomial +\(Q\) vanished on \(U\), then its polar form +\(Q(u+v)-Q(u)-Q(v)\) would vanish for \(u,v\in U\). +Consequently +\[ + Q\Bigl(\sum_i a_i u_i\Bigr) + =\sum_i a_i^2 Q(u_i) + +\sum_{i1\), Lemma~\ref{rd:rank-two} +and the finite Chebotarev realization in Lemma~\ref{rl:chebotarev-evaluation} +give a derivative prime with rank-two finite localization, +nonzero on the chosen primitive vector. + +Poitou--Tate duality now determines the effect on the fiber. +The relaxed localization image is a self-annihilating plane. +It contains the whole finite plane, and hence equals that plane. +The strict kernel has dimension \(s-2\), and its replacement by +the singular condition adds no new class. The fiber dimension +therefore drops by two. On the generic field, the localization +is nonzero, so Lemmas~\ref{rd:derivative} and +\ref{rd:det-switch} preserve generic rank one, the nonzero +derivative class, and the determinant valuation. + +If \(\Psi^2=1\), use conjugation, including its action +\((1+t)\mapsto(1+t)^{-1}\), to split the fiber into two signs. +All prior plane conditions are stable under this involution in +the split local model. The two Galois summands are nonisomorphic +absolutely irreducible representations; the only CM quadratic +self-twist has been excluded. Each sign has one finite and one +singular coordinate. The local pairing in a sign is a +nondegenerate symmetric hyperbolic pairing, whose only isotropic +lines in characteristic zero are the finite and singular axes. +If both signs occur globally, choose one class from each, including +a nonzero component of the primitive vector, to obtain the same +rank-two reduction. + +If only one sign occurs and \(s>1\), choose a rank-one finite +localization nonzero on that vector. In this sign the relaxed +image is the finite line. In the other sign its intersection +with the finite line is zero, and self-duality forces it to be +the singular line. A switch retains the old strict kernel of +dimension \(s-1\ge1\), introduces the other sign, and preserves +the total dimension. The next rank-two switch reduces it. +After finitely many such operations the fiber dimension is one. +It cannot fall below one, since a primitive vector from the +generic rank-one kernel survives after each switch. + +At fiber dimension one, a minimal self-dual model over the DVR +has one free term in each of degrees one and two and zero +differential. The class and paired functional are integral at +this height-one prime. Their determinant coordinate is +therefore integral. Reversing +\eqref{rd:valuation-switch} proves nonnegative valuation at +\(\mathfrak p\). Applying this at every height-one prime other +than \((2)\), and using that the normal ring \(\Lambda\) is the +intersection of its height-one valuation rings inside its fraction +field, gives membership in \(\Lambda[1/2]\). + +For the stated arithmetic instances, the rational central +specialization has Selmer dimension one and no invariants. +Upper semicontinuity bounds the generic dimension by one. +If the generic class is nonzero, it spans this space. This +uses Selmer corank at an unknown base and does not replace that +corank by Mordell--Weil rank. +\end{proof} + +\begin{lemma}[The terminal minor estimate]\label{rd:minor} +Let +\[ + C_i=[\,O_i^n\xrightarrow{D_i}O_i^n\,] +\] +be based complexes over DVRs with uniformizer \(2\), with generic +rank-one kernel. Let \(z_i\in\ker D_i\) be integral, and let +\(\lambda_i\in 2^{-a}(O_i^n)^*\) annihilate \(\operatorname{im}D_i\), +where \(a\) is fixed. If an \((n-1)\)-minor \(\Delta_i\) has +\(v(\Delta_i)\le b\), the determinant coordinate \(u_i\) of +\(z_i\otimes\lambda_i\) satisfies +\begin{equation} + v(u_i)\ge-a-b. + \label{rd:minor-bound} +\end{equation} +\end{lemma} + +\begin{proof} +Permute rows and columns so that the minor is the upper-left block +\(A_i\). Write \(D_i=\left(\begin{smallmatrix}A_i&b_i\\c_i&d_i +\end{smallmatrix}\right)\). Since its rank is \(n-1\), its Schur +complement is zero. Over the fraction field, use the triangular +basis changes with entries \(A_i^{-1}b_i,c_iA_i^{-1}\) to leave +\(A_i\) and a zero one-by-one block. These triangular changes +have determinant one. If \(\alpha_i\) is the last coordinate +of \(z_i\) and \(\beta_i\) the value of \(\lambda_i\) on the last +target basis vector, cancellation gives exactly +\begin{equation} + u_i=\pm\frac{\alpha_i\beta_i}{\det A_i}. + \label{rd:minor-formula} +\end{equation} +Here \(\alpha_i\in O_i\) and \(\beta_i\in2^{-a}O_i\). +This proves \eqref{rd:minor-bound}. If \(n=1\), the empty +minor is \(1\) and the same formula applies. +\end{proof} + +\begin{proposition}[Uniform residual valuation from outer rank reduction] +\label{rd:outer-bound} +Assume all of the following properties of a collection of primitive +ring instances: +\begin{enumerate} +\item after any fixed number of switches, minimal \(\mathcal O\)-models +have size bounded independently of \(h\) and of \(K\) with +\(\omega(k)\le A\); +\item the all-sequence evaluation and exact-kernel restriction of +Proposition~\ref{rl:outer-evaluation}, and the finite Chebotarev +realization of Lemma~\ref{rl:chebotarev-evaluation}, hold for these +models, retaining their degree-two cocycle identities; +\item the integral localization and duality diagrams and the +derivative classes of Lemma~\ref{rd:derivative} survive this same +outer limit; the class and its closed dual functional have a common +bounded clearing exponent. +\end{enumerate} +Then there is \(C(E,A)\) such that +\begin{equation} + v_{(2)}(u)\ge-C(E,A) + \label{rd:residual-bound} +\end{equation} +for every simple-zero ring instance. The hypotheses refer to a +single simultaneous construction. In particular, separate +abstract models realizing its individual cohomology groups do +not establish this proposition's arithmetic applicability. +\end{proposition} + +\begin{proof} +The preceding paired-diagram construction supplies the common +clearing exponent in the arithmetic application. The bound on +minimal sizes is Lemma~\ref{rl:residual-bound}; in particular, +active conductor primes do not contribute to that size after +residual localization. + +Suppose that \(v_{(2)}(u_i)\to-\infty\). All these coordinates +are nonzero. First put the complexes into square two-term form. +At the residual \(\Omega\)-test, moving-prime inertia excludes +global invariants, and the local degree-zero conditions identify +Selmer invariants with those global invariants. Thus \(H^0=0\). +The retained self-duality gives \(H^3=0\) and equal dimensions +in degrees one and two. A minimal \(\mathcal O\)-model therefore +has only two free terms, of equal rank, in those degrees; all other +terms cancel in integral disks. Fix a nonprincipal ultrafilter +\(\mathcal U\) and fix the bounded rank on an ultrafilter-large +set. Write these models as +\[ + C_i=[\,O_i^n\xrightarrow{D_i}O_i^n\,]. +\] + +Transport the class, the uniformly cleared functional, all evaluation +matrices, and the finitely many retained comparison maps and boundary +witnesses through these integral disk contractions. Their entries +remain integral and their identities remain exact. The individual +active-place complexes, whose number may grow with the outer instance, +are not retained as an outer list of objects. Their effect has already +been incorporated in the target cone and its determinant; only the +bounded minimal models and the fixed number of switch diagrams enter +this limit. + +Apply Proposition~\ref{rl:outer-evaluation} to these models and +their retained integral diagrams. It gives a DVR \(O_\infty\) +with uniformizer \(2\), characteristic-zero fraction field +\(F_\infty\), and injective all-sequence evaluation, including +restriction to the product of the exact inner kernels. +The induced representation uses one simultaneous complex +conjugation, so the sequence group over the quadratic fields has +index two in the rational sequence group. Lemma~ +\ref{rl:irreducibility} gives absolute irreducibility over +\(F_\infty\): the moving inertia character has infinite order, +and the finite Tate-matrix witness survives the outer quotient. + +The outer complex may have more cohomology than any inner generic +complex. Its new cycles can be represented by vectors \(w_i\) +for which \(v(D_iw_i)\to+\infty\), without exact inner lifts. +The retained degree-two evaluation matrices are integral, so the +evaluations of \(D_iw_i\) also tend to zero. This is the part of +Proposition~\ref{rl:outer-evaluation} that makes these new classes +available for the following rank reduction. + +Choose in each inner generic kernel a primitive vector \(v_i\). +Some coordinate is a unit on a set in \(\mathcal U\), so its +outer limit is nonzero. Thus the outer kernel has dimension +at least one. If that dimension is \(s>1\), apply +Lemma~\ref{rd:rank-two} to two outer classes, one the surviving +primitive vector. Realize their rank-two evaluation by inner +derivative primes. This realization only asks for finite +quotients at each stage. For an approximate inner cocycle +one chooses the retained precision below the valuation of +its coboundary; no exact inner lift of the extra outer class +is being assumed. + +More explicitly, retain the original inner index \(i\) +for outer instance \(j\), its ultrafilter \(\mathcal U_j\), +and the outer ultrafilter \(\mathcal U\). Represent the +selected kernel element by \(u_j=(u_{j,i})_i\). +At stage \((j,i)\), apply finite Chebotarev to this actual +element and the old finite data to choose \(\ell_{j,i}\). +Adjoin its local complexes, the derivative cocycle and +the pairing homotopies to the same original stage +diagram with its old contractions. Take the same +\(\mathcal U_j\) and then the same \(\mathcal U\). +The retained coefficient precision may increase more +slowly, but cofinally; the earlier maps and their +arbitrary evaluations are not reconstructed by an +independent choice of subsequence or model. + +The localization of \(v_i\) is generically nonzero on a set +in \(\mathcal U\): its outer image is nonzero. Therefore +the original inner spanning class also localizes nontrivially, +even if its multiple of \(v_i\) has large valuation. +Lemma~\ref{rd:det-switch} preserves each inner determinant +valuation exactly. On the outer field, the relaxed image +is the finite plane and the singular switch lowers \(s\) +by two, by the same localization exact sequence as in +Proposition~\ref{rd:away-two}. The new inner generic kernels +again supply primitive vectors, so the outer rank remains +at least one. + +Only finitely many switches are necessary: the initial outer +rank is bounded and drops by two. After each fixed number +of switches the required model-size bound remains available. +At the terminal outer rank one, the outer differential has +a nonzero maximal boundary minor. Its inner determinants +\(\Delta_i\) have one finite valuation on a set in +\(\mathcal U\), by the definition of \(O_\infty\). +Lemma~\ref{rd:minor} then gives a fixed lower bound on +\(v(u_i)\), a contradiction. + +This proof uses the minor only after rank reduction. Bounded +matrix size alone would not suffice: the matrices \([2^i]\) +have bounded size and unbounded torsion length. In that +example the entire matrix becomes zero in the outer quotient; +the rank-reduction and evaluation hypotheses would have to +supply additional arithmetic operations before a nonzero +terminal minor could be used. +\end{proof} + +\subsection{Central specialization and the local indices} +\label{rd:specialization-subsection} + +The preceding bounds concern the deformed determinant. We next identify +its value at $t=0$ with the index of the original Heegner point and the +finite Shafarevich--Tate lengths. The comparison retains the whole +integral complex; in particular, every active split conductor prime has +an explicit local contribution. + +\begin{lemma}[Derived specialization at constant rational rank] +\label{rd:derived-specialization} +Let \(C\) be a perfect \(\Lambda\)-complex and put +\(C_0=C\otimes_\Lambda^{\mathbf L}\mathbb Z_2\), where \(t=0\). +Suppose its generic rational cohomology and its central rational +cohomology both have dimension one in degrees one and two and +are zero in other degrees. Put \(A=\Lambda_{(t)}\), with residue field \(\mathbb Q_2\). +Let \(z\) be a degree-one cycle and \(\lambda\) a closed +degree-two functional in a finite free model of \(C\otimes_\Lambda A\), +and let \(z_0,\lambda_0\) be their images under \(A\to\mathbb Q_2\). +Then the generic determinant tensor \([z]\otimes[\lambda]\) is +regular at \((t)\) and specializes, under the determinant base-change +isomorphism, to \([z_0]\otimes[\lambda_0]\). Its central valuation is +computed from the entire integral complex \(C_0\), including +its torsion cohomology. It cannot be computed by substituting +the naive quotient of \(H^1(C)\) by \(t\). +\end{lemma} + +\begin{proof} +Represent \(C\) by a bounded free complex. Derived reduction +is its termwise reduction, so the determinant line itself +commutes with specialization. For clarity, the cohomology +base-change sequence is +\begin{equation} + 0\longrightarrow H^i(C)/tH^i(C) + \longrightarrow H^i(C_0) + \longrightarrow H^{i+1}(C)[t]\longrightarrow0. + \label{rd:tor-basechange} +\end{equation} +These last terms are the relevant \(\operatorname{Tor}_1\) +terms. Diagonalize the complex over the DVR \(A\), or over its +completion \(\mathbb Q_2[[t]]\). A nonunit pivot +would create an additional central cohomology class in its +two adjacent degrees. The assumed constant dimensions +exclude such pivots. Thus over \(\mathbb Q_2[[t]]\) there +are only invertible disks and the two free cohomology lines. +The rational class-dual tensor consequently specializes +to the stated central tensor. Over \(\mathbb Z_2\), all +elementary divisors of \(C_0\), including the torsion supplied +by \eqref{rd:tor-basechange}, remain in its determinant +isomorphism. This proves the assertion. +\end{proof} + +\begin{lemma}[A ramified good odd place]\label{rd:active-local} +Let \(F_v/\mathbb Q_p\) be unramified, \(p\ne2\), and let +\(T'=T_2(E)\otimes\chi\), where \(E\) has good reduction +and \(\chi\) is ramified quadratic. Then +\begin{equation} + H^0(F_v,T')=0,\qquad + H^1(F_v,T')=E^\chi(F_v)^{\wedge}_2,\qquad + \operatorname{length}_{\mathbb Z_2}H^2(F_v,T') + =\dim_{\mathbb F_2}E[2]^{\operatorname{Fr}_v}. + \label{rd:local-length} +\end{equation} +The quotient of the full local complex by the integral Kummer +condition therefore contributes precisely this last length +in degree two. +\end{lemma} + +\begin{proof} +The pro-\(2\) tame inertia generator acts by \(-1\). +Its complex has differential \(-2\), so its cohomology is +zero in degree zero and \(T'/2T'\) in degree one. +Taking residue-field cohomology gives +\[ + H^1(F_v,T')\simeq E[2]^{\operatorname{Fr}_v},\qquad + H^2(F_v,T')\simeq E[2]/(\operatorname{Fr}_v-1)E[2]. + \] +The possible residue-cardinality factor on inertia cohomology +is one modulo \(2\). Kernel and cokernel of an endomorphism +of a finite vector space have the same dimension, proving +the length assertion. + +The integral local Kummer exact sequence identifies the +\(2\)-adic completion of the points with all of \(H^1(F_v,T')\). +Indeed the inverse Tate module of the local Weil--Chatelet +group is zero here: local duality identifies its +\(2\)-primary part with the dual of the finite completion +of the point group. The point completion is finite because +the residue characteristic is odd. Equivalently, inertia +\(-1\) implies that the local \(2\)-primary torsion is +exactly the Frobenius-fixed \(2\)-torsion. The Kummer +complex includes the derived invariants of this finite +module on reduction, as in Lemma~\ref{rl:kummer}. +The quotient therefore has exactly the degree-two +cohomology displayed above. +\end{proof} + +\begin{proposition}[The central determinant formula] +\label{rd:central-formula} +Suppose the product +\[ + L(E^{(h)},s)L(E^{(hk)},s) +\] +has a simple zero at \(s=1\). +Use the primitive Heegner sum \(P_h\) and its free-line index +\(j_h\) defined at the start of Section~\ref{rl:section}, and put +\[ + s(h)=\operatorname{length}_{\mathbb Z_2} + \Sha(E^{(h)}/\mathbb Q)[2^\infty]. + \] +Use the primitive Selmer determinant coordinate \(u_h\) +with the fixed class multiplier of Lemma~\ref{rd:derivative}. +For the primitive Selmer diagrams constructed above, we have +\begin{equation} + \begin{split} + v(u_h(0)) + &=2j_h- + \operatorname{length}_{\mathbb Z_2} + \Sha(E^{(h)}/K)[2^\infty] + -2\sum_{p\mid h}t_p+O_E(1)\\ + &=2j_h-s(h)-s(hk)-4w(h)+O_{E,A}(1), + \qquad \omega(k)\le A . + \end{split} + \label{rd:central-value} +\end{equation} +The first error includes the auxiliary prime and the fixed +parametrization multiplier. The second has no dependence +on the number of primes dividing \(h\). +\end{proposition} + +\begin{proof} +The two rational twists have analytic ranks zero and one. +The forward low-analytic-rank theorems give finiteness of +their whole Shafarevich--Tate groups; equivalently the +Heegner simple-zero theorem over \(K\) gives rank one +and finite Shafarevich--Tate group there. Thus all finite +lengths in this proof refer to known finite groups. + +The specialization comparison is made at each finite stage, before +the target data are retained. Put \(c=|h|\). At the split auxiliary +prime \(r_i\), the point distribution relation is +\[ + \operatorname{Tr}_{H_{cr_i}/H_c}(y_{cr_i}) + =(a_{r_i}-\sigma_{r_i}-\sigma_{\bar r_i})y_c, +\] +where the two Artin symbols have inverse ring-class actions. At +\(t=0\), the scalar character is trivial, while the rational quadratic +character has value \(\chi_h(r_i)\) on both symbols. The completed +weighted sum therefore gives exactly +\(L m_i P_h\), where \(m_i=a_{r_i}-2\chi_h(r_i)\). + +This point identity is retained on bounded target complexes as follows. +Let \(C_h^{\rm Kum}\) be a fixed free model of the ordinary Kummer Selmer complex +over \(K\), and let \(b_h\) represent the Kummer class of \(P_h\). +At the retained coefficient precision, enlargement of the ramification +set and relaxation at the active and auxiliary primes give a target +comparison \(j_i:C_h^{\rm Kum}/2^i\to C_i/(t)\). Each retained local +condition is an isomorphism on degree zero and an injection on degree +one, so the Selmer-cone exact sequence injects its degree-one +cohomology into global cohomology. Kummer naturality and the point +relation therefore give, after contraction, a target degree-zero vector +\(v_i\) with +\[ + z_i(0)-L m_i j_i(b_h)=d v_i. +\] +Include this vector, the comparison matrix, and the associated local +localization triangles in the same target diagram. Their ranks are +bounded for this fixed \(h,K\), independently of \(r_i\) and of +\([H_{cr_i}:K]\). All statements are reduced to the same slower +cofinal precision if needed. Lemma~\ref{rl:finite-limits} now retains +the displayed boundary identity. The trace bound gives +\(v_2(m_i)\le c_E\); hence their limit \(m\in\mathbf Z_2\) on the +same ultrafilter is nonzero and has \(v_2(m)\le c_E\). +The active local quotients specialize +to Lemma~\ref{rd:active-local}, and the Kummer conditions at +\(2N\), including their differential lattices, are unchanged. +The central point is therefore nonzero, so generic +and central rational cohomology both have rank one. + +To specialize the paired functional, choose its representative +over \(\Lambda_{(t)}\). At an active ramified prime, inertia +minus one is \(-2\), a unit in this ring. At \(r\), the +central Frobenius determinants are nonzero by the trace bound. +Their local complexes thus contract over \(\Lambda_{(t)}\). +Composing these contractions with retained global duality gives +the same generic functional as the contractions over +\(\mathcal O\), and specializes to rational central Kummer +duality. Lemma~\ref{rd:derived-specialization} applies to this +representative; no regularity is claimed for an arbitrary +\(\mathcal O\)-cochain representing the functional. + +The ordinary integral Kummer complex has compact Selmer +cohomology in degree one. Its degree-two torsion has +length equal to that of the finite quotient of the +discrete Selmer group by its maximal divisible subgroup. +This follows by derived base change to +\(\mathbb Q_2/\mathbb Z_2\) and the exact local Kummer +conditions; the base-change terms must be retained. +Here that quotient is \(\Sha(E^{(h)}/K)[2^\infty]\). +The free parts of degrees one and two are paired +unimodularly by integral duality. Torsion in degree +one and its dual contribution in degree three have +bounded length, by the fixed-scalar bound on global +torsion. + +For completeness, an elementary divisor of size \(2^d\) +whose cokernel is in degree \(i\) contributes +\((-1)^{i+1}d\) to the coordinate in the inverse +determinant. Consequently the degree-two +Shafarevich--Tate torsion subtracts its length. On +the free line, a point of index \(2^{j_h}\) and its +functional each contribute \(j_h\), giving \(2j_h\). + +At an active prime \(p\mid h\), both primes of \(K\) +above \(p\) are governed by +Lemma~\ref{rd:active-local}, each with length \(t_p\). +Relaxation therefore subtracts exactly \(2t_p\). +There is no bound hiding an error at every such prime. +At \(r\), the central scalar character is trivial; +the local degree-two determinant has the valuation +of \(r+1-a_r\chi_h(r)\) at each split place. +The trace condition +\[ + v_2(2-a_r),\ v_2(2+a_r)\le c_E,\qquad + v_2(r-1)>c_E + \] +makes both valuations at most \(c_E\). It also bounds +the trace multiplier +\(a_r-2\chi_h(r)\) on the central point. +At primes over \(2N\) the integral Kummer condition +is retained. The local twisting types form a fixed +finite set and \(K\) is split there; all comparison +indices, including those of Neron differential +lattices at \(2\), are therefore bounded in terms +of \(E\). This proves the first equality, using +Lemma~\ref{rd:derived-specialization} to compare +the generic tensor with the central tensor. + +We spell out the quadratic comparison needed for +the second equality. Set +\[ + A_h=\operatorname{Res}_{K/\mathbb Q}(E^{(h)}_K), + \qquad B_h=E^{(h)}\times E^{(hk)}. + \] +There are isogenies in both directions whose +composites are multiplication by \(2\). +The isogeny-invariance identity for the BSD quotient, +with finite Shafarevich--Tate groups, is +\begin{equation} + \frac{\#\Sha(A_h)\operatorname{Reg}(A_h) + \operatorname{Per}(A_h)\prod_p c_p(A_h)} + {\#A_h(\mathbb Q)_{\rm tors} + \#A_h^\vee(\mathbb Q)_{\rm tors}} + = + \frac{\#\Sha(B_h)\operatorname{Reg}(B_h) + \operatorname{Per}(B_h)\prod_p c_p(B_h)} + {\#B_h(\mathbb Q)_{\rm tors} + \#B_h^\vee(\mathbb Q)_{\rm tors}} . + \label{rd:isogeny-identity} +\end{equation} +Regulators and periods are taken with compatible +dual and Neron normalizations. This is the +Cassels--Tate isogeny identity. The elliptic-curve local-measure +formula is due to Cassels \cite[Theorem~1.1]{Cassels1965}. +For the general abelian-variety identity used here, see the proof of +\cite[I, Theorem~7.3, especially (7.3.1), pp.~97--100]{MilneADT2006} +and \cite[Section~4.1]{DokchitserDokchitser2010}. This identity requires +finite Shafarevich--Tate groups, as already established at these +noncentral twists, but does not assume the BSD conjecture. +The fixed-degree composites bound the rank-one +regulator indices, the torsion ratios, and the +differential and period indices by fixed powers +of \(2\). The identity is essential: a statement +that the maps on Shafarevich--Tate groups have +kernel and cokernel killed by \(2\) would not +bound their lengths uniformly. + +At every split prime of \(K/\mathbb Q\) the component +factors of \(A_h\) and \(B_h\) agree. In particular +this cancels all primes dividing \(h\). +At an odd prime \(p\mid k\) outside \(2N\), the curve +over \(K\) has good reduction. Its Weil restriction +has connected special fiber: the reduction of +Weil restriction over the ramified quadratic +extension is an extension of the good special +fiber by a connected additive group. Thus its +component factor is \(1\). Of the two rational +twists, one is good and the other is ramified +quadratic with good original curve. The latter +has \(2\)-part of its component number equal to +\(2^{t_p}\). This follows as well from the +ramified tame description in +Lemma~\ref{rd:active-local}: its connected +reduction is unipotent, and its local +\(2\)-primary torsion is the fixed +\(2\)-torsion. At other good nonsplit places +the component factors are \(1\); at \(2N\) +there are only the fixed local comparisons. +Taking valuations in \eqref{rd:isogeny-identity} +therefore gives +\begin{equation} + \operatorname{length}\Sha(E^{(h)}/K)[2^\infty] + =s(h)+s(hk)+\sum_{p\mid k}t_p+O_E(1). + \label{rd:sha-comparison} +\end{equation} +Since \(0\le t_p\le2\), the sum over \(k\) is at +most \(2A\). Substituting this equality and +\(2\sum_{p\mid h}t_p=4w(h)\) proves the result. +\end{proof} + +\begin{proof}[Proof of Corollary~\ref{rd:ring-lower}] +The arithmetic diagrams constructed with Lemma~\ref{rd:derivative}, +their paired functionals, and the model bound of +Lemma~\ref{rl:residual-bound} give the hypotheses of +Propositions~\ref{rd:away-two} and \ref{rd:outer-bound}. +Those propositions give nonnegative height-one valuations +away from \((2)\) and a lower bound \(-C(E,A)\) at \((2)\). +Normality of \(\Lambda\) gives \(2^{C(E,A)}u_h\in\Lambda\). +Its constant coefficient has valuation at least \(-C(E,A)\). +Apply \eqref{rd:central-value}. +\end{proof} + +\subsection{The universal correction and bounded clearing} +\label{rd:clearing-subsection} + +For transfer to a missing vertex, the individual determinant coordinates +must belong to one quadratic group-ring family. We first remove the +Euler factors at primes unused by a character. We then clear the +remaining denominators with a factor whose central valuation and +negative Laurent support are bounded independently of the cube size. +The base curve and the companion field are fixed in this argument. + +Fix \(K\) and a binary family \eqref{rd:binary-data}, based at +\(h_0=1\). Put +\[ + G=(\mathbb Z/2\mathbb Z)^b,\qquad R=\Lambda[G]. +\] +Let \(g_q\in G\) be the inertia bit: +\(g_q(x)=(-1)^{\lambda_q(x)}\). +Augmentation is denoted by subscript \(0\). + +The universal class is constructed before making any character +evaluation. Fix this finite family and \(G\). At precision \(i\) +take the Heegner point of conductor \(r_i\prod_{q\in Q}q\). +Let \(\varepsilon:G_K\to G\) be the universal quadratic character. +In the finite Shapiro transfer of Lemma~\ref{rd:derivative}, use +the coefficient map +\[ + A_i[\operatorname{Gal}(H_{r_i\prod q}/K)] + \longrightarrow A_i[G],\qquad + [\sigma]\longmapsto\Psi_i(\sigma)[\varepsilon(\sigma)], +\] +with the same inverse-action convention on both sides. Complete +this weighted coset sum to obtain a target Selmer-cone cycle over +\(A_i[G]\), with local lifts and boundary witnesses, and then +contract these target data. The target-side rank bound applies +for this fixed family and gives one trace class over \(\Lambda[G]\). +Evaluation at \(x\) commutes with the finite coefficient map and +every target identity, so gives the full trace for that character. +If scalar models have already been chosen, compare the evaluated +model with them through the original target cochains and retain the +resulting comparison matrices and contraction homotopies. There are +only finitely many characters for this fixed \(G\). At \(t=0\), the +universal split-prime multiplier is +\[ + a_{r_i}-2[\varepsilon(\operatorname{Fr}_{\mathfrak r_i})]. +\] +The conjugate Frobenius values agree because the character values +have exponent two. Its evaluation at \(x\) is +\(a_{r_i}-2\chi_{h_x}(r_i)\), so the central boundary comparison +used in Proposition~\ref{rd:central-formula} is retained in this +same group-ring diagram before character evaluation. +It includes Euler factors at primes unused by \(x\), which the next +lemma removes. No inverse limit over growing \(G\) or growing active +support is used in this construction. + +The accompanying dual functional is constructed over +\(\mathcal O[G]\), not separately at its characters. At a new +prime and at \(r\), the full local complex is acyclic modulo +the maximal ideal by Lemma~\ref{rl:local-acyclic}, hence has an +integral contraction over this local ring. Use these contractions +to lift the class to the orthogonal Selmer complex, and then apply +the retained integral global duality. This gives a closed integral +functional, up to one fixed old-support power of \(2\) when such +a support is included. The present base is \(h_0=1\). + +\begin{lemma}[Removing unused primes in the group ring] +\label{rd:unused} +Suppose the universal relaxed trace class and its duality +diagram have been constructed over \(R\). +There is \(\eta\in\mathcal O[G]\) such that +\(\eta u_{\rm rel}\) has each character coordinate +equal to the primitive determinant coordinate, up +to a \(\Lambda\)-unit. The correction has no +denominator accumulating with \(\#Q\). +\end{lemma} + +\begin{proof} +At an unused split prime \(q\), write \(z\) for the +full scalar Frobenius at one orientation. Conjugation +gives \(z^{-1}\) at the other orientation. The +point trace contributes +\[ + e_q=a_q-z-z^{-1}, + \] +whereas relaxation of the singular quotient contributes +\begin{equation} + l_q= + \det(1-q^{-1}z\operatorname{Fr}_q\mid T) + \det(1-q^{-1}z^{-1}\operatorname{Fr}_q\mid T). + \label{rd:unused-factors} +\end{equation} +Using reciprocal Frobenius conventions changes only +the corresponding unit conventions in the paired +determinant. The localization triangle gives +\(u_{\rm rel}=e_q^2u_{\rm prim}/l_q\) at this +unused prime. The square is required because the +point and its dual both occur. + +Both factors are units in the local ring +\(\mathcal O[G]\). To check this it suffices to +reduce modulo its maximal ideal, generated by \(2\) +and the augmentation ideal. There the scalar +is \((1+t)^m\) with \(m\) odd, and the residual +Frobenius polynomial is nonzero at this nonconstant +scalar. More precisely, before character +evaluation the following identity holds modulo \(2\): +\begin{equation} + (1+a_qz+z^2)(1+a_qz^{-1}+z^{-2}) + =a_q^2+z^2+z^{-2} + =(a_q+z+z^{-1})^2 . + \label{rd:residual-euler} +\end{equation} +Thus \(l_q/e_q^2-1\in2\mathcal O[G]\), and +\begin{equation} + \eta= + \prod_{q\in Q} + \left(1+ + \frac{l_q/e_q^2-1}{2}(1+g_q)\right) + \in\mathcal O[G]. + \label{rd:eta} +\end{equation} +Its factor evaluates to \(l_q/e_q^2\) when \(q\) +is unused and to \(1\) when \(q\) is active. +This proves the claim. The apparent inertia +projector denominator is canceled inside each +factor before taking the product. +\end{proof} + +\begin{lemma}[Laurent expansion and simultaneous elimination] +\label{rd:schur} +There is a natural identification +\begin{equation} + \mathcal O/2^M\mathcal O + =(\mathbb Z/2^M\mathbb Z)((t)). + \label{rd:laurent} +\end{equation} +Suppose \(A=\operatorname{diag}(A_1,\ldots,A_m)\) +has entries in \(\Lambda\), each residual determinant +is nonzero, and +\(\operatorname{ord}_t(\det\overline A_j)\le h\). +If \(B=A+2E\) with \(E\) over \(\Lambda\), then +every entry of \(B^{-1}\bmod2^M\) has no term below +\(t^{-Mh}\). The same bound holds for a Schur +complement \(P-QB^{-1}S\), where \(P,Q,S\) +have power-series entries. The bound is independent +of \(m\). +\end{lemma} + +\begin{proof} +For a denominator \(s\in\Lambda\setminus(2)\), +write \(s=t^d v+2w\), with \(v\) a power-series +unit. Its inverse modulo \(2^M\) is its finite +geometric expansion about \(t^dv\), which has +finite negative support. Conversely all Laurent +series of finite negative support occur after +inverting \(t\). This proves \eqref{rd:laurent}. +It also proves that an element of \(\mathcal O\) +has a unique series \(\sum a_nt^n\), \(a_n\in\mathbb Z_2\), +with \(v(a_n)\to+\infty\) as \(n\to-\infty\), +and that its valuation is \(\min_n v(a_n)\). + +Write \(\det A_j=t^{d_j}v_j+2w_j\), with +\(d_j\le h\), and put +\[ + C_j=\frac{\operatorname{adj}(A_j)}{t^{d_j}v_j}, + \qquad C=\operatorname{diag}(C_j). + \] +Each entry of \(C\) has pole at most \(h\), and +\(BC=1+2F\), where entries of \(F\) have the same +pole bound. Therefore +\begin{equation} + B^{-1}\equiv C\sum_{j=0}^{M-1}(-2F)^j + \pmod{2^M}. + \label{rd:inverse-expansion} +\end{equation} +The \(j\)-th summand has pole at most \((j+1)h\). +Adding more entries in a matrix product cannot +worsen this pole bound. Multiplication by +power-series matrices proves the Schur assertion. + +For a block over \(R\) whose augmentation is \(A\), +the block is invertible over \(\mathcal O[G]\): +its residual determinant in the local ring is a +unit. Each sign evaluation is \(A+2E_x\) with +power-series entries, so the same estimate holds +at all characters. If \(S_0=0\), its Schur +complement has augmentation exactly \(P_0\). +\end{proof} + +\begin{lemma}[Clearing a bounded complex]\label{rd:clearing} +Let \(D\) be a based complex of finite free +\(\mathcal O[G]\)-modules of total graded rank +at most \(r_0\), with \(D_0\) defined over +\(\Lambda\). Suppose \(D_0\otimes_\Lambda^{\mathbf L}\mathbb Z_2\) +has rational cohomology of dimension one in degrees +one and two, zero elsewhere, and total integral +torsion length at most \(h_1\). +Let \(z\) be an integral cycle and let +\(\lambda\in2^{-a_0}(D^2)^*\) be a closed functional. +Assume every character constituent is either +generically acyclic or has the same generic rank-one pattern; +in the generically acyclic case its determinant coordinate +is defined to be zero. Multiplication of these +coordinates by any \(\eta\in\mathcal O[G]\) +is permitted. Then there are \(f,d\in\mathcal O[G]\) +such that +\begin{equation} + f_xu_x=d_x,\qquad + f_0\in\Lambda,\qquad + v(f_0(0))\le C(r_0,h_1,a_0)<\infty. + \label{rd:clearing-equations} +\end{equation} +If all entries of \(D_x\) have bounded negative +Laurent support at each precision, uniformly +in \(b\), the same is true of \(f_x\). +No such bound on \(d_x,z,\lambda,\eta\) is required. +\end{lemma} + +\begin{proof} +Put the central integral complex into elementary-divisor +bases over \(\mathbb Z_2\). Its positive pivot +valuations sum to at most \(h_1\). Lift these +constant integral basis changes. Formally cancel +the same pivot positions upstairs, recording the +pivot numerators and all denominators in the +resulting rational basis changes and determinant +comparison. There are at most \(r_0\) such +operations. A product \(P\) of sufficiently +large, but bounded, powers of their numerators +clears every denominator. Its degree in the +differential entries is bounded in terms of +\(r_0\); its augmentation belongs to \(\Lambda\) +and has central valuation bounded in terms of +\(r_0,h_1\). + +On constituents where \(P_x\ne0\), the remaining +complex is one-by-one in degrees one and two. +If its differential is nonzero, the cycle +identity forces the projected cycle to be zero, +so the same rational determinant expression +gives the stipulated zero coordinate. Otherwise +the expression is the product of the projected +cycle and functional, with the canceled-pivot +factor. Clearing denominators gives +\[ + u_x=2^{-a_0}\eta_x Q_x/P_x,\qquad + Q\in\mathcal O[G]. + \] +Take \(f=2^{a_0}P^2\) and \(d=\eta P Q\). +On a constituent where a pivot first vanishes, +\(P_x=0\), so both sides of \(f_xu_x=d_x\) +are zero. Thus the identity holds on every +character. Since \(f\) is a polynomial of +bounded degree in the bounded differential +entries, its central valuation and pole +properties follow. All unused-prime +corrections and eliminated-block units occur +in \(d\); none is inserted into \(f\). +\end{proof} + +\begin{proposition}[The bounded clearing factor for the family] +\label{rd:family-clearing} +Assume the compatible universal Selmer and Heegner +diagrams and their primitive specializations. +Suppose every character constituent of the universal Selmer complex +is generically acyclic or has generic +cohomology of dimension one in degrees one and two and zero +elsewhere. If the fixed base has \(2^\infty\)-Selmer corank +one over \(K\), the corrected coordinates of +Lemma~\ref{rd:unused} admit the factorization +\eqref{rd:clearing-equations}, with central +valuation and fixed-precision pole bounds +independent of \(b\) and \(\#Q\). +\end{proposition} + +\begin{proof} +Use the integral universal class and paired functional just +constructed. To apply Lemma~\ref{rd:clearing}, it remains to +reduce the complex to bounded size without losing uniform control +of its negative Laurent powers. + +At augmentation, the localization triangles +present the complex as the old complex extended +by a direct sum of singular local blocks in +degrees one and two, one block for each new +prime. Its differential is upper triangular, +with the old complex a subcomplex. This graded +model lifts over \(R\): split disks over the +augmentation local ring, identify the minimal +parts, and lift the invertible basis changes. +This is an application of the actual finite +diagram construction, rather than just an +equality of Euler characteristics. + +Each new block has determinant \(l_{q,0}\). +Its residual \(t\)-order is uniformly bounded. +In the reducible residual range the residual +Frobenius polynomial is \((X+1)^2\), and an +odd scalar exponent gives order two at each +split place; thus order four suffices for the +two-place block. Eliminate the entire new +block over \(\mathcal O[G]\). By +Lemma~\ref{rd:schur}, the resulting complex +\(D\) has the bounded old size, has augmentation +equal to the old complex, and has a uniform +pole bound at every fixed precision. + +The central cohomology of the old complex is +the fixed base Kummer cohomology, modified only +by the bounded auxiliary-prime terms. Its +rational dimension is one in degrees one and +two. The quotient of the discrete Selmer +group by its maximal divisible subgroup is +finite because its Pontryagin dual is a +finitely generated \(\mathbb Z_2\)-module. +For this fixed \(K,E\), its length is a finite +constant, even when the Shafarevich--Tate +group itself is not known to be finite. +Together with global torsion and the trace +bound at \(r\), this bounds all central +torsion lengths of \(D_0\). + +Apply Lemma~\ref{rd:clearing}. The determinant +of the eliminated block is a unit over +\(\mathcal O[G]\), so its inverse is an +allowed integral multiplier. Include it +and \(\eta\) from \eqref{rd:eta} in the +numerator multiplier of that lemma. +This proves the assertion. + +The dependence here is on fixed \(K,E\); +it is different from the uniform +\(C(E,A)\) of Proposition~\ref{rd:outer-bound}. +No uniform bound on the finite Selmer quotient +as \(K\) varies is asserted or needed for +the missing-vertex argument. +\end{proof} + +\begin{proposition}[Assembly of the arithmetic diagrams] +\label{rd:assembly} +For the ring data stated at the start of this section, the actual +finite Heegner and Selmer constructions satisfy the simultaneous +diagram hypotheses of Propositions~\ref{rd:away-two}, +\ref{rd:outer-bound}, and \ref{rd:central-formula}. +The bounds needed for the lower-bound argument depend only on +\(E\), the fixed local data, and a bound \(A\) on \(\omega(k)\). +For the binary data \eqref{rd:binary-data} with fixed \(E,K\) +and base Selmer corank one, assume in addition that every +character constituent of the universal Selmer complex is generically acyclic +or has generic cohomology of +dimension one in degrees one and two and zero elsewhere. +Then the constructions satisfy all the hypotheses of +Proposition~\ref{rd:family-clearing}, with +bounds independent of the cube dimension and of its +new-prime support. +\end{proposition} + +\begin{proof} +The paired arithmetic diagram constructed after +Lemma~\ref{rd:derivative} contains the actual weighted target classes, +local Kummer lifts, target comparison and boundary witnesses, and +simultaneous duality triangles. The target-side construction +gives its inner rank bound for each fixed finite conductor support; +no ring-class source complex is passed to the limit. +Theorem~\ref{rl:limit-evaluation-package} retains +their evaluations and exact-kernel restrictions. The same-stage +extension in Proposition~\ref{rd:outer-bound} shows explicitly +that these data remain compatible after each further switch. + +Lemma~\ref{rl:residual-bound} bounds the minimal models in terms +of \(E,A\) and the number of retained derivative primes, not the +active conductor support. Outer rank reduction uses only a bounded +number of switches, hence only finitely many of these bounds. +The paired functional has the common clearing exponent established +above. These are the three hypotheses of +Proposition~\ref{rd:outer-bound}; the characteristic-zero +evaluations and local acyclicity give those of +Proposition~\ref{rd:away-two}. The actual central trace and +\(\Lambda_{(t)}\)-representative, together with the local +quotients of Lemma~\ref{rd:active-local}, were verified in the +proof of Proposition~\ref{rd:central-formula}. + +For a binary family, Section~\ref{rd:clearing-subsection} +constructs the universal trace and its dual functional over the +group ring before evaluating characters. Lemma~\ref{rd:unused} +then removes the unused-prime factors integrally. The bounded +complex in Proposition~\ref{rd:family-clearing} comes from the +actual localization triangles and simultaneous Schur elimination, +with the order-four residual local bound. Its central torsion is +controlled by the finite quotient of the fixed base Selmer group +and the bounded auxiliary-prime terms. Together with the stated +constituent-rank assumption, these give all the hypotheses of +Lemma~\ref{rd:clearing}. + +For varying \(K\), only its bounded ramification count enters +the residual-model and local-comparison constants. For the final +binary argument \(K\) is fixed, so its finite base Selmer +quotient may enter the clearing constants. At \(2N\) the +original Kummer conditions have been retained throughout; the +construction imposes no ordinary or semistable hypothesis. +\end{proof} + +\subsection{Coefficient comparison and the missing vertex} +\label{rd:transfer-subsection} + +The bounded clearing factor reduces the last step to finitely many +coefficient congruences. A parity argument on a sufficiently large +binary cube makes a nonzero address agree with the base to the required +precision. If the base derivative were zero, that congruence would +contradict the upper bound already supplied at every nonzero address. + +The common-zero count in the following proof is the characteristic-two +Chevalley--Warning principle +\cite[Section~1, equation~(1)]{HeathBrownChevalleyWarning}; its short parity +proof is included here. + +\begin{lemma}[A nonzero address with prescribed coefficient bits] +\label{rd:bits} +Let \(A_1(x),\ldots,A_q(x)\) be specified Laurent +coefficients of sign evaluations of elements of +\(\mathcal O[G]\). For \(M\ge1\), if +\begin{equation} + b>q(2^M-1), + \label{rd:bit-threshold} +\end{equation} +there is \(x\ne0\) with +\(A_i(x)\equiv A_i(0)\pmod{2^M}\) for every \(i\). +\end{lemma} + +\begin{proof} +Write the element supplying the \(i\)-th test as +\(a_i=\sum_{g\in G}a_{i,g}(t)g\), and let \(n_i\) be the Laurent +degree being tested. Lemma~\ref{rd:schur} gives integral Laurent +coefficients, so +\[ + z_i=\sum_{g\in G}[t^{n_i}]a_{i,g}(t)\,g\in\mathbb Z_2[G]. +\] +The group \(G\) is finite, hence coefficient extraction commutes +with character evaluation: \((z_i)_x=A_i(x)\). Apply +Lemma~\ref{cy:binary} to these \(q\) integral group-ring elements. +Its bound is exactly \eqref{rd:bit-threshold}; no bound on the +Laurent degrees or on the coefficients enters this argument. +\end{proof} + +\begin{lemma}[Transfer through the bounded factor] +\label{rd:binary-transfer} +Suppose \(f,d\in\mathcal O[G]\), +\(u_x\in\Lambda[1/2]\), and \(f_xu_x=d_x\) +for every character. Suppose +\(f_0\in\Lambda\) and +\(c=v(f_0(0))<\infty\). +If every \(f_x\bmod2^M\) has no powers below +\(-L(M)\), then for +\[ + M>c,\qquad + b>(L(M)+2)(2^M-1) + \] +there is \(x\ne0\) satisfying +\begin{equation} + v\bigl(u_x(0)-u_0(0)\bigr)\ge M-2c. + \label{rd:binary-congruence} +\end{equation} +\end{lemma} + +\begin{proof} +Apply Lemma~\ref{rd:bits} to the coefficients +of \(f_x\) in degrees \(-L(M),\ldots,0\) +and the constant coefficient of \(d_x\). +At its nonzero solution, all negative +coefficients of \(f_x\) are divisible by +\(2^M\), and its constant coefficient is +congruent to \(f_0(0)\). Hence the latter +has valuation \(c\), and +\(v_{\mathcal O}(f_x)\le c\). +Since \(d_x\) is integral over \(\mathcal O\), +\(v_{\mathcal O}(u_x)\ge-c\), and the same +holds for \(u_0\). The Laurent expansion +in Lemma~\ref{rd:schur} then shows that all +their coefficients lie in \(2^{-c}\mathbb Z_2\). +They have no negative coefficients because +they belong to \(\Lambda[1/2]\). + +The constant-term convolution converges +\(2\)-adically, and gives +\[ + [t^0]d_x\equiv [t^0]f_x\,u_x(0) + \pmod{2^{M-c}}, + \qquad + [t^0]d_0=f_0(0)u_0(0). + \] +Use the imposed congruences and divide by +\(f_0(0)\). This proves +\eqref{rd:binary-congruence}. The possibly +large negative support of \(d_x\) was never +tested; only its constant coefficient was used. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{rd:missing-vertex}] +For every character the primitive generic +cohomology has rank at most one. At nonzero +vertices this follows from the simple-zero +theorem; at zero it follows from +\eqref{rd:base-corank} and rational +specialization. There are no generic invariants, and duality +pairs degrees one and two; thus each primitive constituent is acyclic +or has exactly the rank-one pattern. The unused-prime local blocks +are acyclic over the fraction field, by the nonzero factors +\eqref{rd:unused-factors}. The universal Selmer complex has the +same generic pattern, as required by +Proposition~\ref{rd:family-clearing}. With this hypothesis +verified, Proposition~\ref{rd:assembly} supplies the compatible +universal arithmetic construction. By Proposition~\ref{rd:away-two} +and Lemma~\ref{rd:unused}, the corrected +coordinates belong to \(\Lambda[1/2]\). +Proposition~\ref{rd:central-formula} gives +\[ + v(u_x(0))\le B_1\quad(x\ne0) + \] +for a constant \(B_1\) depending only on +\(B,E,K\) and the fixed local data. + +If the base derivative vanished, the +Gross--Zagier formula would make the +central Heegner sum torsion: its canonical +height is a fixed nonzero multiple of +that derivative. Here only the conductor-one formula at +the fixed base \(h=1\) is used, with the corrected primitive +sum and the split Heegner data of +\cite[Theorem~1.1]{CaiShuTian2014}. +At the base this implies \(u_0(0)=0\). +Indeed, if the generic rank is zero the +coordinate was defined to be zero. If the +generic rank is one, its central rank is +also one by \eqref{rd:base-corank}, so +Lemma~\ref{rd:derived-specialization} +identifies its specialized class with +the zero rational Kummer class of that +torsion point. + +Proposition~\ref{rd:family-clearing} supplies +\(f,d\) with a common bound \(c_*\) on +\(v(f_0(0))\) and common pole bounds +\(L(M)\). Choose +\[ + M>\max\{c_*,B_1+2c_*\} + \] +and then take \(b\) above the threshold +of Lemma~\ref{rd:binary-transfer}. +That lemma gives a nonzero vertex with +\(v(u_x(0))\ge M-2c_*>B_1\), a +contradiction. Thus the base derivative +is nonzero. The classical split Heegner +sign is odd, so the base product has +a simple zero. +\end{proof} + +\begin{remark}[The simultaneous arithmetic interface] +\label{rd:interface-status} +The determinant argument can be reused only with +the simultaneous arithmetic construction verified +in Proposition~\ref{rd:assembly} and +Theorem~\ref{rl:limit-evaluation-package}. +Neither the published duality theorem nor the +classical Heegner formulas alone supplies that +interface. +\end{remark} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/ring-limits.tex b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/ring-limits.tex new file mode 100644 index 0000000000000000000000000000000000000000..9af6f164e313c77c54259ebfd1fb5b6823b22a62 --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/build/sections/ring-limits.tex @@ -0,0 +1,981 @@ +\section{Ring-class interpolation and integral deformations} +\label{rl:section} + +The ring-class argument has two outputs: a lower bound for the index of +a Heegner point at a known simple zero, and a transfer of nonvanishing to +an unknown base. The first is uniform as the companion field varies +with bounded ramification; the second fixes that field before a binary +family grows. We state both outputs before constructing their cochain +and evaluation maps. Their determinant proofs occupy +Section~\ref{rd:section}. + +Fix $E/\mathbf Q$ of conductor $N$, and write $T=T_2E$ and +$\Lambda=\mathbf Z_2[[t]]$. The imaginary quadratic field +$K=\mathbf Q(\sqrt k)$ satisfies the split Heegner hypothesis at $2N$. +We omit the two fields with extra units and, when $E$ has complex +multiplication, its CM field. Let $h$ be a product of distinct signed +good odd primes, all split in $K$, with $(h,k)=1$; $h=1$ is allowed. +The primes dividing $h$ are called the \emph{active conductor primes}. +The character $\chi=\chi_h$ is the corresponding quadratic character +over $\mathbf Q$. + +Fix a modular parametrization $\pi:X_0(N)\to E$ with $\pi(\infty)=0$. +Write $H_c$ for the ring-class field of $K$ of conductor $c$, and $y_c$ +for the image under $\pi$ of a conductor-$c$ CM point, with fixed CM +orientations. The restriction of $\chi_h$ to $G_K$ factors through +$\operatorname{Gal}(H_{|h|}/K)$. The primitive weighted Heegner sum is +\[ + P_h=\sum_{\sigma\in\operatorname{Gal}(H_{|h|}/K)} + \chi_h(\sigma)\,\sigma(y_{|h|}). +\] +Through the quadratic-twist identification, it is a point of +$E^{(h)}(K)$. When the product of $L(E^{(h)},s)$ and $L(E^{(hk)},s)$ +has a simple zero, +the Heegner-point theorem makes $P_h$ nontorsion and +$E^{(h)}(K)$ has rank one. Let $j_h$ be the $2$-adic index valuation of $P_h$ +in the free rank-one lattice +$E^{(h)}(K)^\wedge_2/\mathrm{torsion}$. The quantities $w(h)$, +$s(h)$, and $s(hk)$ have the meanings fixed in +Section~\ref{sec:preliminaries}; the two Shafarevich--Tate lengths are +finite in this simple-zero case. + +\begin{corollary}[Ring-class lower bound] +\label{rd:ring-lower} +Every simple-zero ring instance in the stated data satisfies +\begin{equation} + 2j_h\ge 4w(h)+s(h)+s(hk)-C(E,A), + \qquad \omega(k)\le A. + \label{rd:ring-lower-equation} +\end{equation} +\end{corollary} + +For the second output, fix $K$ and the base $h_0=1$. A binary family +has the form +\begin{equation} + h_x=\prod_{q\in Q}(q^*)^{\lambda_q(x)},\qquad + \lambda_q:\mathbb F_2^b\longrightarrow\mathbb F_2\text{ linear}, + \quad x\in\mathbb F_2^b. + \label{rd:binary-data} +\end{equation} +All primes in $Q$ are good, odd, disjoint from the fixed support, and +split in $K$. All vertices have the same local squareclasses at $2N$ +and the same required real sign. + +\begin{theorem}[The fixed-\(K\) missing-vertex implication] +\label{rd:missing-vertex} +Fix the ring data \(E,K\), with +\begin{equation} + \operatorname{corank}_{\mathbb Z_2} + \operatorname{Sel}_{2^\infty}(E/K)=1. + \label{rd:base-corank} +\end{equation} +Suppose binary families \eqref{rd:binary-data} +exist for arbitrarily large \(b\), and for +every nonzero \(x\) the product +\(L(E^{(h_x)},s)L(E^{(h_xk)},s)\) has a simple zero and +\begin{equation} + 2j_{h_x}-4w(h_x)-s(h_x)-s(h_xk)\le B + \label{rd:nonzero-bound} +\end{equation} +with \(B\) independent of the family. Then +\begin{equation} + \operatorname{ord}_{s=1} + \bigl(L(E,s)L(E^{(k)},s)\bigr)=1. + \label{rd:missing-conclusion} +\end{equation} +This implication does not assume Mordell--Weil +rank one or finite Shafarevich--Tate group +at the base. +\end{theorem} + +To prove these assertions, we compare the Heegner-point indices with +integral Selmer determinants. The present section constructs the +limiting complexes and the maps needed to test their classes at new +primes. Taking limits of differential matrices alone would not suffice: +a cycle in the limit may lift only to approximate cycles at finite +precision, and its localization must still be evaluation of a crossed +cocycle. + +There are two passages to a limit. In the inner construction $K$ and a +finite active support are fixed while an auxiliary scalar-conductor +prime $r_i$ and the coefficient precision vary. Additional inert +\emph{derivative primes} will realize evaluations and switch local +conditions. In the outer construction $K$ and the active support may +vary, but $\omega(k)$ and the number of retained derivative primes are +bounded. This second passage gives the uniform lower bound; the final +fixed-$K$ transfer instead uses the bounded clearing factor of +Proposition~\ref{rd:family-clearing}. + +We use +\[ + A_i=(\mathbf Z/2^i\mathbf Z)[t]/(t^i). +\] +The same constructions work over $A_i[G]$ and $\Lambda[G]$, where $G$ is a +fixed finite elementary abelian $2$-group and the additional character has +values in $G$. Statements uniform in the number of generators of $G$ will +be identified separately; finite-diagram compactness by itself is a statement +for fixed $G$. + +\subsection{Free models with maps to the original cochains} + +\begin{lemma}[Finite Artin models]\label{rl:finite-model} +Let $(A,\mathfrak m,k)$ be an Artin local ring, and let $D$ be a complex of +flat $A$-modules. Suppose $H^*(D\otimes_A k)$ is finite dimensional and +supported in $[a,b]$. There is a bounded finite free complex $C$, with +\[ + \operatorname{rank}_A C^j=\dim_k H^j(D\otimes_A k), +\] +and a strong deformation retraction +\[ + i:C\longrightarrow D,\qquad p:D\longrightarrow C,\qquad + pi=1,\qquad 1-ip=dh+hd. +\] +Thus maps to the original complex, as well as maps between finite models, +are available. Any fixed finite collection of chain maps, homotopies, +triangles, and perfect pairings can be transported to these models. +\end{lemma} + +\begin{proof} +Flat modules over an Artin local ring are free, including modules of infinite +rank. Here is a useful version of the argument. Lift a basis of $M/\mathfrak +mM$ to a flat module $M$, and map the corresponding free module to $M$. +Its cokernel is zero because $\mathfrak m$ is nilpotent. Flatness shows that +the kernel has zero reduction, and nilpotence again makes the kernel zero. + +Split the residual complex as its cohomology, with zero differential, plus +contractible two-term disks. Lift all the graded bases. These lifts are +graded isomorphisms: an inverse modulo $\mathfrak m$ lifts to an inverse by +a finite geometric series. Let $d_0$ be the lifted disk differential and +write $d=d_0+\epsilon$. All coefficients of $\epsilon$ belong to +$\mathfrak m$. For the disk contraction $(i_0,p_0,h_0)$, arrange +$h_0^2=h_0i_0=p_0h_0=0$ and +$1-i_0p_0=d_0h_0+h_0d_0$. The operators +$1+h_0\epsilon$ and $1+\epsilon h_0$ have finite geometric inverses. +The elementary perturbation identities give the differential +\[ + d_C=p_0\epsilon(1+h_0\epsilon)^{-1}i_0 +\] +on the lifted residual cohomology, and give +\[ + i=(1+h_0\epsilon)^{-1}i_0,\quad + p=p_0(1+\epsilon h_0)^{-1},\quad + h=h_0(1+\epsilon h_0)^{-1}. +\] +Substitution, using $(d_0+\epsilon)^2=0$, proves the asserted contraction +identities. These calculations are valid for infinite disk sums: each +operator is a module homomorphism and every geometric series terminates +at the nilpotence exponent of $\mathfrak m$. + +For a map between original complexes use $p'fi$; insert the contraction +homotopies when composing maps. A quasi-isomorphism between bounded free +complexes has a contractible cone and hence a homotopy inverse. This gives +the stated finite-diagram assertion, including the homotopies expressing +triangles and perfect duality. +\end{proof} + +For a profinite group and a finite free coefficient module over $A$, +continuous inhomogeneous cochains are flat: locally constant functions are +the filtered union of the modules of functions on finite clopen partitions, +and these modules are finite free. Their reduction is the cochain complex +with reduced coefficients. The same observations apply to restrictions, +mapping cones, and local conditions given by finite free complexes. In the +applications below the groups are Galois groups of totally imaginary number +fields or nonarchimedean local fields. Their $2$-cohomological dimension and +the usual finiteness theorems give the bounded residual cohomology required +in Lemma~\ref{rl:finite-model}. + +\begin{lemma}[Limits of specified diagrams]\label{rl:finite-limits} +Suppose diagrams over $A_i$, or over $A_i[G]$, have uniformly bounded cohomological amplitudes and graded free +ranks, and include the chain homotopies and inverses for every asserted +identity or equivalence. After taking a cofinal subsequence, or a +nonprincipal ultrafilter limit, their matrices define the same diagram of +perfect complexes over $\Lambda$, or $\Lambda[G]$. + +Moreover, the contractions into the original cochains may be retained for +the evaluation construction in Lemma~\ref{rl:evaluation}. Adding finitely +many new objects or maps does not require changing already chosen models +for the old objects. +\end{lemma} + +\begin{proof} +There are finitely many possible graded ranks. Fix them on an +ultrafilter-large set. At a fixed precision $j$, all matrix entries belong +to the finite ring $A_j$ (or $A_j[G]$), so have unique ultrafilter limits. +These limits are compatible as $j$ varies. Matrix identities, including +the homotopy-inverse identities, are finite polynomial identities and pass +to the limit. New models and maps may be mapped to old models by their +already fixed contractions. Passing to any slower cofinal precision has +the same old limits. For the all-sequence evaluation statements below, +fix this ultrafilter once and for all, and keep the original contraction +at every stage. Later arithmetic diagrams must extend these same +stages. Restriction to an ultrafilter-large set and passage to slower +cofinal coefficient precision preserve every old evaluation on every +old group sequence. An arbitrary later subsequence or a different +ultrafilter is not allowed in this assertion. Notice that this argument preserves specified +arithmetic maps; it does not create an arithmetic map from a formal +description of its expected properties. +\end{proof} + +\paragraph{Target-side data.} +The ring-class fields used to construct a class need not have bounded +degree. Their cochain complexes are not objects of the limiting diagram. +At each finite stage, first perform descent, Shapiro transfer, the +coefficient weighting, and every coset sum. These operations give +cochains on the fixed target field \(K\), with their local lifts. Only +then apply Lemma~\ref{rl:finite-model} to the target global and local +complexes and their Selmer cones. + +Here is the required inner rank bound. Fix \(K\), the active support, +a finite set of derivative slots, and, when used, \(G\). The permitted +ramification set \(S_i\) consists of this fixed support and a bounded +number of moving primes. Modulo the maximal ideal of \(A_i\) or +\(A_i[G]\), all scalar characters are trivial and the representation is +\(E[2]\). Put \(F=K(E[2])\), a fixed field. Kummer theory bounds +\(H^1(G_{F,S_i},\mathbf F_2)\) by the rank of the \(S_i\)-unit group +and the dimension of the fixed group \(\operatorname{Cl}(F)[2]\). +Both bounds are uniform: the number of primes above \(S_i\) is bounded +and passing to the \(S_i\)-class group only decreases the required +class-group bound. The fixed finite group +\(\operatorname{Gal}(F/K)\) and inflation--restriction then bound +\(H^1(G_{K,S_i},E[2])\). Degree zero is bounded by two, and the global +Euler characteristic bounds degree two; higher degrees vanish because +\(K\) is totally imaginary. Local cohomology has uniform bounds as +well: the local degrees over \(\mathbf Q\) are at most two, there are +only finitely many fixed local conditions at \(2N\), and the moving +good-prime and derivative complexes have fixed ranks. The Selmer-cone +exact sequence gives the same conclusion for every target local +condition used below. Thus Lemma~\ref{rl:finite-model} gives uniformly +bounded target ranks. This inner bound may depend on the fixed active +support and is not a bound for a sequence of growing binary families. +The separate uniform bound after completion at \((2)\) is +Lemma~\ref{rl:residual-bound}; binary-family uniformity is obtained only +after the elimination in Proposition~\ref{rd:family-clearing}. + +For clarity, let \(D_i\) be a target cochain complex and write its +contraction as \((\iota_i,p_i,h_i)\). A transferred cycle \(z_i\) +is retained as the vector \(p_i z_i\). Its representative in the +original target cochains differs from \(z_i\) by the boundary +\(d h_i z_i\). If an arithmetic identity is +\(z_i-z'_i=d b_i\), retain the target vectors +\(p_i z_i,p_i z'_i,p_i b_i\); their identity is exact. For a target +comparison map \(f_i:D_i\to D'_i\), retain +\(p'_i f_i\iota_i\), together with the contraction homotopy. For +example, +\[ + p'_i f_i z_i-p'_i f_i\iota_i p_i z_i + =d\bigl(p'_i f_i h_i z_i\bigr). +\] +Apply this also to local lifts in the Selmer cone, specialization +comparisons, and the homotopies expressing duality and local switches. +Each specified cycle or boundary witness is a vector in a bounded-rank +target term, so adds only finitely many coordinates. Boundary witnesses +are compressed after transfer and have target rank; no list indexed by +the ring-class cosets is retained. The lemma therefore retains all +these identities without retaining a source cochain complex or a +growing transfer matrix. The original target contractions remain +available in degrees zero, one, and two for all-sequence evaluation. +All operations use the same original stages and ultrafilter; a loss of +precision is accommodated by one common slower cofinal precision for +the entire finite diagram. Adding derivative slots means extending +each old stage by finitely many target objects, not taking a limit with +an unbounded number of objects. + +\subsection{Kummer conditions, including their derived degree zero} + +\begin{lemma}[Integral Kummer local condition]\label{rl:kummer} +Let $F$ be a finite extension of a nonarchimedean local field of +characteristic zero, and let $B/F$ be any elliptic curve. Put +$M_F=B(F)^\wedge_2=\varprojlim_n B(F)/2^nB(F)$. There is a perfect local +condition +\[ + U_F=M_F[-1]\longrightarrow R\Gamma(F,T_2B). +\] +For every $n\geq1$, derived reduction has +\[ + H^0(U_F\otimes^{\mathbf L}\mathbf Z/2^n)=B(F)[2^n],\qquad + H^1(U_F\otimes^{\mathbf L}\mathbf Z/2^n)=B(F)/2^nB(F). +\] +Its map in degree zero is the isomorphism onto +$H^0(F,B[2^n])$, and its map in degree one is the finite Kummer injection. +The condition is its own exact orthogonal complement under local Tate +duality. These assertions hold at $F\mid2$, for all reduction types, and +without a condition on $B[2]$. +\end{lemma} + +\begin{proof} +The local analytic description of $B(F)$ shows that $M_F$ is a finitely +generated $\mathbf Z_2$-module. Its torsion is the finite group +$B(F)[2^\infty]$. Consequently $M_F$ has a free resolution of length at +most one. Also $H^0(F,T_2B)=0$, since $B(F)[2^\infty]$ has bounded +exponent. The integral Kummer injection into $H^1(F,T_2B)$ therefore +defines the displayed morphism using the truncation in degrees at most +one of $R\Gamma(F,T_2B)$. + +Tensor the free resolution of $M_F$ with $\mathbf Z/2^n$. Its two +cohomology groups are $M_F[2^n]$ and $M_F/2^nM_F$. The inverse limits of +the ordinary Kummer exact sequences identify their maps with the two +maps in the statement. In particular finite torsion invariants have not +been discarded. + +For orthogonality, compose cup product and the Weil pairing with the local +invariant map. A morphism +\[ + M_F[-1]\otimes^{\mathbf L}M_F[-1] + \longrightarrow\mathbf Z_2[-2] +\] +is determined by its homomorphism $M_F\otimes M_F\to\mathbf Z_2$: +the possible $\operatorname{Tor}_1$ is in degree one and gives no extra +degree-zero morphism to this target. The indicated homomorphism vanishes, +because the finite Kummer image annihilates itself at every level by local +Tate duality \cite[I, Theorem~3.2 and Corollary~3.4]{MilneADT2006}. +Choose a nullhomotopy in free models. The induced morphism +\[ + R\Gamma(F,T_2B)/U_F + \longrightarrow R\operatorname{Hom}_{\mathbf Z_2} + (U_F,\mathbf Z_2)[-2] +\] +is a quasi-isomorphism. This can be checked after reduction modulo $2$: +degree one is the perfect pairing of the finite Kummer quotient with the +Kummer image, and degree two is dual to $B(F)[2]$. Its perfect cone is +therefore zero by derived Nakayama. This proves exact orthogonality and +also its compatibility with derived reduction. The derived duality of +the ambient local cochains is \cite[Proposition~5.2.4]{Nekovar2006}; +the Kummer condition and its orthogonality have been constructed above. +No part of the proof uses an ordinary filtration or a classification of +reduction types. +\end{proof} + +Where the scalar deformation is trivial, extend this local condition by +derived scalar extension to $A_i$ or $A_i[G]$. For a finite free +coefficient representation $M$ unramified at a good prime $v$, use the +inflated residue-field complex +\[ + U_v=[\,M\xrightarrow{\operatorname{Fr}_v-1}M\,] + \quad\text{in degrees }0,1. +\] +Its quotient in full local cochains is the singular local complex. +The full local condition is the identity on local cochains, and its +orthogonal strict condition is zero. The conditions at a derivative +prime are different: once its local cochains have the split model +constructed in Lemma~\ref{rd:local-model}, they are the truncations +specified below. Write that model as +\[ + L_v=D^0\oplus(F_v\oplus S_v)[-1]\oplus D^2[-2], +\] +where the differential is zero, $D^0$ is dual to $D^2$, and the finite +and transverse planes $F_v,S_v$ are each isotropic. Put +\[ + U_{\rm str}=D^0,\qquad + U_{\rm rel}=D^0\oplus(F_v\oplus S_v)[-1],\qquad + U_F=D^0\oplus F_v[-1],\qquad U_S=D^0\oplus S_v[-1]. +\] +Then $U_{\rm str}^{\perp}=U_{\rm rel}$ and each plane condition is +its own orthogonal complement. Every displayed condition maps +isomorphically onto local $H^0$ and injectively into local $H^1$. +Thus they satisfy precisely the detection hypotheses used below. +Lemma~\ref{rd:local-model} proves their finite arithmetic realization +and supplies the isotropic-plane nullhomotopies. These truncated +conditions are not identified with the full local condition. + +For a finite permitted set $S$ the Selmer complex is, by definition, +\begin{equation}\label{rl:selmer-definition} + C_S=\operatorname{Cone}\left( + R\Gamma(G_{K,S},M)\oplus\bigoplus_{v\in S}U_v + \longrightarrow\bigoplus_{v\in S}R\Gamma(K_v,M) + \right)[-1]. +\end{equation} +At $2N$ take the Kummer conditions just constructed. Restriction and +localization triangles are the triangles of this cone. The finite rings +$A_i$ and $A_i[G]$ are Frobenius coefficient rings; alternatively the +duality maps may be checked after reduction to their residue field. +Exact local orthogonality and global duality therefore give +\begin{equation}\label{rl:global-duality} + C_S\simeq R\operatorname{Hom}(C_S^{\perp},A_i)[-3], +\end{equation} +with the appropriate dual representation. This application uses the +orthogonality hypotheses of +\cite[Theorem~6.3.4]{Nekovar2006}; the theorem is not being used to assert +the existence of a varying-prime limit. Complex places contribute zero +Tate complexes. If the character is inverted by the nontrivial +automorphism of $K/\mathbf Q$, conjugate transport followed by the Weil +pairing identifies the two representations over the same scalar ring. +All maps and nullhomotopies in this paragraph are finite diagrams to +which Lemma~\ref{rl:finite-limits} applies. + +\subsection{The moving conductor character} + +\begin{proposition}[Finite-precision ring-class characters]\label{rl:characters} +Fix finitely many split primes of $K$ above odd rational primes, outside +$2N$, and orient one prime in each conjugate pair. There are distinct +split rational primes $r_i$ avoiding all the fixed data and characters +\[ + \xi_i:\operatorname{Gal}(H_{r_i}/K)\longrightarrow + \mathbf Z/2^{n_i}\mathbf Z, + \qquad n_i\longrightarrow\infty, +\] +such that $\xi_i$ is surjective on the inertia quotient at $r_i$, is zero +at the primes above $2N$, and has odd value at each prescribed oriented +prime. We can require $r_i\to1$ in $\mathbf Z_2$ and +\begin{equation}\label{rl:trace-bound} + v_2(2+a_{r_i}(E)),\quad v_2(2-a_{r_i}(E)),\quad + v_2\det(1\pm\operatorname{Fr}_{r_i}\mid T)\ \leq c_E. +\end{equation} +The constant $c_E$ is independent of the list and of $K$. +\end{proposition} + +\begin{proof} +We give the compatibility argument before imposing the Tate condition. +Choose prime ideals $\mathfrak p_1,\ldots,\mathfrak p_s$ with pairwise +disjoint conjugate pairs, including the oriented prescribed primes and +the primes above $2N$, and enough additional split prime ideals to +generate $\operatorname{Cl}(K)$. Such additional ideals may avoid any +fixed finite set. Put weight $w_j=1$ at a prescribed odd prime and +$w_j=0$ at every additional prime and every prime above $2N$. +The conjugate weight is $-w_j$. Let +\[ + R=\ker\bigl(\mathbf Z^s\longrightarrow\operatorname{Cl}(K)\bigr), +\] +choose a basis $m^{(a)}$ of $R$, and choose $\beta_a\in K^\times$ with +$(\beta_a)=\prod_j\mathfrak p_j^{m_j^{(a)}}$. + +Work first over $F_\infty=K(\mu_{2^\infty})$ and adjoin $2^n$-th roots +of the finitely many $\beta_a/\overline\beta_a$. Prescribe on these +roots the multipliers +\begin{equation}\label{rl:kummer-prescription} + \zeta_{2^n}^{\,-\sum_j m_j^{(a)}w_j}. +\end{equation} +The minus sign fixes the choice of connecting map in the ring-class +sequence and could be reversed throughout. These prescriptions respect +every Kummer relation. Indeed, if +\[ + \prod_a(\beta_a/\overline\beta_a)^{b_a} + \in(F_\infty^\times)^{2^n}, +\] +take its valuation at a prime above each $\mathfrak p_j$ of nonzero +weight. These odd primes are unramified in $F_\infty/K$. Thus +$2^n$ divides $\sum_a b_am_j^{(a)}$ for each such $j$, proving the +required compatibility of~\eqref{rl:kummer-prescription}. Primes over +$2$ have weight zero and impose no division by a ramification index. +Units impose no additional weighted relation. Kummer duality supplies +the prescribed automorphism of the radical extension over $F_\infty$. + +At a rational prime $r$ split in a sufficiently large finite cyclotomic +subfield, the power-residue character of $\mathbf F_r^\times$ is +surjective onto $\mu_{2^n}$. The split ring-class exact sequence is +\[ + 1\longrightarrow + (\mathcal O_K/r\mathcal O_K)^\times/(\mathbf Z/r\mathbf Z)^\times + \longrightarrow\operatorname{Pic}(\mathbf Z+r\mathcal O_K) + \longrightarrow\operatorname{Cl}(K)\longrightarrow1. +\] +There is no unit correction under our exclusion of the extra-unit +fields. The first group is $\mathbf F_r^\times$, with a principal +relation measured by $\beta/\overline\beta$ at the oriented prime over +$r$. Consequently~\eqref{rl:kummer-prescription} says exactly that its +primitive power-residue character extends to the class group with the +specified values $w_j$. Since the ring-class extension is unramified at +$2N$, value zero on Frobenius means that the resulting local character +is trivial there. Conjugation acts by inversion. + +We now show that imposing these finitely many radical conditions cannot +force either forbidden Tate trace. In the non-CM case the image of +$G_{K(\mu_{2^\infty})}$ is an open subgroup of +$\operatorname{SL}_2(\mathbf Z_2)$, by the open-image theorem +\cite{Serre1972}. Its index in the corresponding fixed-$E$ image changes +by at most two when $K$ changes. Its commutator subgroup contains a +fixed open subgroup $U_E$ of $\operatorname{SL}_2(\mathbf Z_2)$. +One may see uniformity by starting with a principal congruence subgroup +in the fixed image: every index-two subgroup contains its squares, and +the commutators of the resulting fixed congruence subgroup are open. +Because the radical extension over $F_\infty$ is abelian, these +commutators act trivially on it. Hence every permitted Tate coset +contains a translate of $U_E$. + +For completeness, in the CM case let $M$ be the CM field. The image over +$KM(\mu_{2^\infty})$ contains a fixed open subgroup of the norm-one +Cartan; the index changes by a bounded factor, as $[KM:\mathbf Q]\leq4$. +Choose $\gamma\in G_{KM}$ with +$\chi_{\rm cyc}(\gamma)=5^4=625$. This is possible uniformly: the +cyclotomic image of $G_{KM}$ has index at most four in +$\mathbf Z_2^\times$, so contains fourth powers. On the radical Galois +group, conjugation by $\gamma$ is raising to $625$, because all the +radicands lie in $K$. On the Tate image over $KM$, conjugation is +trivial. Therefore +\[ + \gamma u\gamma^{-1}u^{-625},\qquad + u\in G_{KM(\mu_{2^\infty})}, +\] +fixes every prescribed radical and acts on $T$ as $\rho_T(u)^{-624}$. +Raising to the fixed nonzero power $624$ carries an open subgroup of the +one-dimensional norm-one Cartan onto an open subgroup. This proves the +required uniform kernel statement also in the CM case. The open Cartan +image used here is the CM part of the usual $\ell$-adic image theorem +\cite[Chapter~IV, \S2.2, Remark]{Serre1968}. + +On a coset of an open subgroup of $\operatorname{SL}_2$, trace is not +identically $2$ or $-2$. The same holds on a coset of an open norm-one +Cartan subgroup; on the other Cartan-normalizer component trace is zero. +The relevant determinant-one sets are compact and have finitely many +cosets modulo the fixed open subgroup. Choose in each coset an element +whose trace is neither forbidden value. The largest of the finitely +many resulting valuations is a constant depending only on $E$. + +Finally restrict the prescribed radical automorphism and such a Tate +lift to a finite Galois extension, including as many roots of unity as +required. Chebotarev gives infinitely many rational primes with this +Frobenius class; choose the place over the prime to realize the chosen +representative. They split in $K$ and have arbitrarily high prescribed +congruence to $1$. Since +$\det(1\pm\operatorname{Fr}_r)=1\pm a_r+r$, a congruence precision +larger than the fixed trace bound gives all of~\eqref{rl:trace-bound}. +This is a finite Chebotarev condition at each stage, not a demand that +one prime split in an infinite extension. +\end{proof} + +Choose $n_i$ large enough that $1+t$ has order dividing $2^{n_i}$ in +$A_i^\times$, and put $\Psi_i=(1+t)^{\xi_i}$. For example $n_i\geq2i$ +is sufficient. After the matrix limits, the inertia exponent at the +moving prime is a unit of $\mathbf Z_2$, and a prescribed oriented +Frobenius exponent is odd. We can orient the generator of inertia so +its action is exactly $1+t$. + +\begin{lemma}[Local height-one tests]\label{rl:local-acyclic} +For the individual coefficient system $T\chi_h\Psi$, use full local +conditions at the moving prime $r$ and the active primes dividing $h$, +without adding primes from a larger binary family. The limiting full +local complexes are acyclic over every height-one residue field of +$\Lambda$ of characteristic zero. At $(2)$, with residue field +$\Omega=\mathbf F_2((t))$, the $r$-complex is acyclic, and so are the +complexes at active split primes whose prescribed exponent is odd. +These full conditions therefore agree with their orthogonal conditions +on the stated tests. +\end{lemma} + +\begin{proof} +Use tame inertia and unramified Frobenius, or the Hochschild--Serre +complex for these two procyclic directions. At $r$, inertia minus one +is multiplication by $t$ times a unit. It is invertible on all the +indicated fields except the characteristic-zero fiber $t=0$. There, +$r\to1$, and the two remaining Frobenius differentials have nonzero +determinant by~\eqref{rl:trace-bound}, including either sign of the +quadratic twist. The bound also ensures that the integral local +torsion at this central fiber has bounded length. + +At an active odd conductor prime, inertia of the quadratic character +acts by $-1$. Its differential is thus $-2$ and is invertible in +characteristic zero. In characteristic two the quadratic character +disappears. At a split prime the Frobenius action is $zB$, where +$B\in\operatorname{GL}_2(\mathbf F_2)$ and +$z=(1+t)^a$ has odd $a\in\mathbf Z_2$. Its coefficient of $t$ is one, +so $z$ is nonconstant. No nonzero polynomial over the finite constant +field vanishes at $z$. Thus both Frobenius complexes, with operators +$zB-1$ and $q^{-1}zB-1$, are invertible over $\Omega$; here $q=1$ in +the residue field. This argument applies also to a reducible residual +representation. + +The orthogonal full and strict conditions agree when full local cochains +are acyclic. Equation~\eqref{rl:global-duality} then gives self-duality. +The global degree-zero assertion will follow from the evaluation maps +in Lemma~\ref{rl:evaluation}. +\end{proof} + +\begin{lemma}[Uniform residual sizes]\label{rl:residual-bound} +Suppose $\omega(\operatorname{disc}K)\leq A$, the local twisting classes +at $2N$ belong to a fixed finite list, and all active conductor primes +are split with odd exponent. After localization and completion at +$(2)$, the minimal free ranks of the Selmer complexes are bounded in +terms of $E,A$, and the number of retained derivative primes. They do +not depend on the number of active conductor primes. +\end{lemma} + +\begin{proof} +Reduce first over $\mathbf F_2[[t]]$. The quadratic character is now +trivial. Removing the active conductor primes from the permitted +ramification set changes the global complex by their singular local +complexes. These, and their unramified local complexes, are acyclic +after inverting $t$, by Lemma~\ref{rl:local-acyclic}. The resulting +smaller-support complex, including its comparison maps, can be +constructed at the original Artin stages before taking the limit. +Its support consists of $2N,r$, and the retained derivative primes. +Its $\mathbf F_2((t))$ cohomology dimensions are bounded by those at +$t=0$: choose a minimal finite free model over $\mathbf F_2[[t]]$. + +Here is a uniform bound for the latter residual cohomology. Put +$F=\mathbf Q(E[2])$, a fixed field. Then $FK/F$ is at most quadratic. +Enlarge the allowed set of primes of $F$ by those ramified in $K$. +Its cardinality is bounded by a constant depending on $E,A$ and the +number of derivative primes. Kummer theory bounds the number of +generators of the maximal pro-$2$ Galois group over $F$ unramified +outside this set, using the fixed unit group, the fixed $2$-class group, +and the allowed valuations. The subgroup defining $FK$ has index at +most two; the elementary Schreier bound bounds its generator number. +Every finite Galois $2$-extension of $FK$ with this ramification has +Galois closure of $2$-power degree over $F$, so this subgroup indeed +controls the required pro-$2$ extensions of $FK$. + +Over $FK$ the residual Tate module is trivial. Restriction and +inflation--restriction therefore bound the residual $H^1$ over $K$. +The $H^0$ bound is immediate, and the global Euler characteristic or +global duality bounds $H^2$. The local terms at the remaining bounded +set have bounded dimensions, with degrees of the local fields at most +two over the fixed rational local fields. At $2N$ there are only +finitely many local quadratic twisting classes. The same bounds +apply to the Selmer cone. Lemma~\ref{rl:finite-model} now bounds the +minimal ranks. No bound on a torsion exponent is inferred from these +rank bounds. +\end{proof} + +\subsection{Evaluation on every sequence, rather than only a chosen list} + +\begin{lemma}[All-sequence evaluation]\label{rl:evaluation} +Fix $K$ and a sequence of the finite cochain constructions above. Keep +the contraction maps into the original global cochains. Let +$\Gamma_K=\prod_i G_K$ and +$\Gamma=\Gamma_K\rtimes\langle\tau\rangle\subset\prod_iG_{\mathbf Q}$, +with simultaneous complex conjugation $\tau$. Thus $\Gamma_K$ has +index two in $\Gamma$; the larger unrestricted product of rational +Galois groups is not used for induction. The matrix limit defines a +coefficient action of $\Gamma_K$ on $\Lambda^2$. For every field $L$ +receiving a map from $\Lambda$, there is a natural injection +\[ + H^1(C\otimes_\Lambda L)\longrightarrow + H^1_{\rm abs}(\Gamma_K,L^2), +\] +where the right side denotes abstract crossed-homomorphism classes. +Degree-zero evaluation likewise injects +$H^0(C\otimes_\Lambda L)$ into $(L^2)^{\Gamma_K}$. +Here $C$ may be the global complex or a Selmer complex whose local +condition maps induce isomorphisms on local $H^0$ and injections on +local $H^1$. The same statement holds for the induced representation +of $\Gamma$. + +There are evaluation maps on arbitrary sequences, not just on the +finite list used to detect cohomology. Their degree-two identities +remain valid after arbitrary coefficient extension. +\end{lemma} + +\begin{proof} +Let $C_i$ be a finite model and let $\iota_i$ be its chosen map to the +original global cochains, using the projection from the Selmer cone +when appropriate. For every $g=(g_i)$ and $h=(h_i)$ define matrices +\[ + e^0_i:C_i^0\to A_i^2,\quad + e^1_{g,i}:C_i^1\to A_i^2,\quad + e^2_{g,h,i}:C_i^2\to A_i^2 +\] +by evaluating $\iota_i$ in degrees zero, one, and two. Their source +ranks are fixed and their entries belong to $A_i$. Thus each has a +coefficientwise ultrafilter limit, for every choice of $g,h$. +No diagonal selection over the set of group elements is necessary: +one fixed ultrafilter defines all these limits. Likewise +$\rho(g)=\lim_i\rho_i(g_i)$ is a representation. The original +cochain identities imply +\begin{align} + e^1_g d&=(\rho(g)-1)e^0,\label{rl:eval-boundary}\\ + e^2_{g,h}d&=\rho(g)e^1_h-e^1_{gh}+e^1_g. + \label{rl:eval-cocycle} +\end{align} +All identities pass to the limit because their matrix expressions +have finitely many terms. A cycle $x\in C^1\otimes L$ consequently +gives the crossed homomorphism $g\mapsto e^1_g(x)$, and a boundary +gives a coboundary. + +We prove injectivity in a way that also controls base change. At each +finite stage let $k=\mathbf F_2$ be the residual field. Choose a +space of representatives for residual $H^1$. Evaluate pairs $(c,m)$, +where $c$ is in this space and $m\in k^2$, by +$b_c(g)-(\rho(g)-1)m$. The intersection of the kernels of all +these evaluations consists precisely of pairs $(0,m)$ with $m$ an +invariant. Since the vector space is finite dimensional, a list of +at most $\dim H^1+2$ elements already has this intersection. For +these elements evaluation is a chain map +\[ + C_i\longrightarrow D_i= + [\,A_i^2\xrightarrow{((\rho_i(g_j)-1))_j}(A_i^2)^d\,] +\] +in degrees zero and one, inducing an isomorphism on residual $H^0$ +and an injection on residual $H^1$. For Selmer complexes this uses +the exact sequence of~\eqref{rl:selmer-definition}: the indicated +local degree-zero isomorphisms give $H^0(C_i)=H^0_{\rm glob}$ and +$H^1(C_i)\hookrightarrow H^1_{\rm glob}$ residually. + +Retain these matrices and their chosen group-element sequences. The +cone of the limiting map $C\to D$ has zero residual cohomology in +degrees at most zero. Successively cancel its unit differential +blocks. The resulting bounded free cone starts in degree one. +After every coefficient extension it still starts in degree one; +the long exact sequence therefore makes $H^1(C\otimes L)\to +H^1(D\otimes L)$ injective. A crossed cocycle that is a coboundary +on all of $\Gamma_K$ is in particular a coboundary on the detecting +list, proving the desired injection. The same cone gives an +isomorphism on $H^0$ after coefficient extension. Since $H^0(D\otimes L)$ +is a subspace of $L^2$, degree-zero evaluation is injective; by +\eqref{rl:eval-boundary}, its image is fixed by every element of +$\Gamma_K$, not merely by the detecting list. For induction the same proof +has coefficient rank four and the detecting bound is $\dim H^1+4$. +\end{proof} + +We can now exclude global invariants on the tests of +Lemma~\ref{rl:local-acyclic}. In characteristic two the nontrivial +$r$-inertia scalar excludes coefficient invariants. In characteristic +zero the same argument works unless that scalar is trivial. In the +latter case $t=0$, and $T\otimes\mathbf Q_2$ over $G_K$ is absolutely +irreducible: for non-CM curves this follows from the open image, and +for CM curves from the open Cartan and its nontrivial normalizer +component, since $K$ is not the CM field. Twisting by $\chi_h$ does +not alter its invariant subspaces. The degree-zero injection just +proved therefore gives $H^0=0$ for the limiting Selmer complex. +Together with \eqref{rl:global-duality}, this leaves degrees one and +two paired and kills degree three as well. + +\begin{lemma}[The exact common kernel]\label{rl:kernel} +In the notation of Lemma~\ref{rl:evaluation}, let $H$ be the group of +sequences each of whose entries acts trivially on the full Tate module, +on all ring-class fields of $K$, and on the quadratic characters in +use. Restriction from the crossed classes in that Lemma to $H$ is +injective at every characteristic-zero test. It is also injective +at the residual $(2)$ test. The characteristic-zero annihilator +needed for this assertion can be chosen with a fixed finite +$2$-valuation depending only on $E$, also as $K$ varies. +\end{lemma} + +\begin{proof} +The Tate image contains an open subgroup of scalar homotheties, both +in the CM and non-CM cases +\cite[\S2, Theorem~3 and paragraph~7]{Bogomolov1981Points}. Choose once and for all +$g\in G_{\mathbf Q}$ with Tate action $u\,1$, where +$u\in1+4\mathbf Z_2$ and $u\ne1$. Its square belongs to every +quadratic subgroup. Put +\[ + z=g^2\tau g^2\tau^{-1}. +\] +The generalized dihedral property of every ring-class extension +implies that $z$ is ring-class trivial. It is also trivial on every +quadratic character, and its Tate action is the fixed scalar $u^4$. +For every sequence in $\Gamma_K$, its commutator with the constant +sequence $z$ is in the exact group $H$, since its Tate commutator and +all its abelian character images are trivial. Thus $z$ is central in +$\Gamma_K/H$ and acts on the coefficients by $u^4$. + +Here the elementary central-scalar argument suffices. If a crossed +cocycle $b$ is defined on a group with such a central element, comparison +of $b(zg)$ and $b(gz)$ gives +\[ + (u^4-1)b(g)=(g-1)b(z). +\] +In characteristic zero this makes $b$ a coboundary. Inflation--restriction +then gives injectivity on $H$. The valuation of $u^4-1$ is fixed. + +In characteristic two use instead, at the $i$-th stage, an inertia +element at $r_i$ mapping to the chosen generator of $\xi_i$. Its +Tate action is trivial and its ring-class image commutes with all +ring-class images. The associated sequence is therefore central +modulo $H$, and its coefficient action is $1+t$. Since $t$ is +invertible in $\mathbf F_2((t))$, the same calculation applies. +It is essential here that $H$ is defined by the exact actions at each +stage, not merely by an action converging to the identity. +\end{proof} + +\subsection{The outer characteristic-zero test} + +\begin{proposition}[Integral evaluation through the outer limit] +\label{rl:outer-evaluation} +Let $C_j$ be any family of the preceding limiting complexes, completed +over $\mathcal O_j=\widehat{\Lambda_{(2)}}$, possibly for different +quadratic fields $K_j$. Suppose their minimal ranks are bounded. +Keep their actual evaluation matrices, and transport them through the +integral contractions to these minimal models. For a nonprincipal +ultrafilter $\mathcal U$, put +\[ + \mathcal O_\infty= + \left(\prod_{\mathcal U}\mathcal O_j\right)/\mathfrak a, + \qquad + \mathfrak a=\{(x_j): + \{j:v_2(x_j)\geq n\}\in\mathcal U\text{ for every }n\}. +\] +Then $\mathcal O_\infty$ is a DVR with uniformizer $2$ and a +characteristic-zero fraction field $L_\infty$. The outer complex has +an injection of its $H^1$ over $L_\infty$ into crossed classes on the +product of the inner sequence groups. Its restriction to the product +of their exact common kernels is injective. All arbitrary-sequence +degree-two evaluation identities survive. These conclusions also +hold after retaining any fixed finite collection of additional +integral diagrams. +\end{proposition} + +\begin{proof} +A nonzero element of the quotient has a representative whose +valuations are bounded on an ultrafilter-large set. A finite +partition then makes its valuation equal to a single integer $n$ +on such a set. It is $2^n$ times a unit. Products add these finite +valuations, so the quotient is a domain, and every nonzero ideal has +an element of smallest valuation. It is consequently a DVR. The +integer $2^n$ is nonzero for every $n$, so its fraction field has +characteristic zero. + +For each $j$, all-sequence evaluation maps originally have entries +in $\Lambda$. Extension to $\mathcal O_j$ and composition with an +integral contraction still give integral matrices. Thus evaluation +on any sequence of inner group elements has an entrywise image in +$\mathcal O_\infty$. Equations~\eqref{rl:eval-boundary} and +\eqref{rl:eval-cocycle} survive for all such sequences. In particular, +if an outer cycle is represented by vectors $x_j$ for which +$d_jx_j$ has valuation tending to infinity, the evaluation of +$d_jx_j$ does too: the degree-two evaluation matrix is integral. +This proves the crossed identity for an outer cycle without replacing +the $x_j$ by genuine inner cycles. + +Over the inner residue field $\Omega_j$, choose a detecting list as +in Lemma~\ref{rl:evaluation}; its length is at most +$\dim_{\Omega_j}H^1(C_j\otimes\Omega_j)+\operatorname{rank}M$. +These lengths are bounded. Include in the integral diagrams the +evaluation map to its two-term complex and a contraction of its cone +to a complex starting in degree one. Such a contraction uses only +unit pivots over $\mathcal O_j$ and has bounded graded sizes. +All its matrices, including inverses and homotopies, are integral +and pass to the quotient. Its cone still starts in degree one +after extension to $L_\infty$. This proves injectivity just as in +Lemma~\ref{rl:evaluation}. + +Let $H_j$ be the inner exact kernel. The product of the central +elements of Lemma~\ref{rl:kernel} is central modulo $\prod_jH_j$. +Its scalar is the same fixed $u^4$ in every component, and +$u^4-1$ remains nonzero in $\mathcal O_\infty$. The explicit +central-scalar calculation and inflation--restriction give the +claimed restriction injection. Additional fixed finite diagrams +are treated by the same entrywise operations. +\end{proof} + +\begin{lemma}[Irreducibility on the characteristic-zero tests] +\label{rl:irreducibility} +On an inner or outer characteristic-zero test where $\Psi^2\ne1$, +the four-dimensional representation induced from $T\chi\Psi$ is +absolutely irreducible. If $\Psi^2=1$ on an inner test, it splits +as two inequivalent absolutely irreducible quadratic twists. In +the outer test $\Psi$ has infinite order. +\end{lemma} + +\begin{proof} +The two induced summands are distinguished by $r$-inertia, whose +scalars are $\Psi$ and $\Psi^{-1}$. On either summand, multiplying +the Tate matrices by scalars does not alter invariant subspaces. +The Tate representation restricted to $G_K$ is absolutely +irreducible under the exclusions already specified. These facts +give absolute irreducibility of the induction when the two inertia +characters differ. + +For the outer argument this assertion requires a uniform finite +witness. The images of the quadratic subgroups have index at most +two in the fixed compact $2$-adic Tate image. A compact $2$-adic +analytic group is topologically finitely generated and hence has +only finitely many closed subgroups of index at most two. Choose +one on an ultrafilter-large set. Its absolutely irreducible +representation has finitely many matrices spanning +$M_2(\mathbf Q_2)$; the determinant expressing this spanning +property is a fixed nonzero $2$-adic number. Every one of these +Tate matrices is realized by choices of Galois elements in each +component. Their accompanying character scalars are units and +do not change the spanning assertion. Its determinant remains +nonzero in $L_\infty$. This proves absolute irreducibility in +that field. Also $1+t$ has infinite order already in every +$\Omega_j$: for a nonzero integer $n$, the first nonzero term of +$(1+t)^n-1$ occurs in finite degree. It remains a unit modulo +$2$ in every component, so no such power becomes one in the +outer field. + +If $\Psi^2=1$, extension across conjugation gives the two quadratic +twists. They are inequivalent, since a quadratic self-twist of the +Tate representation here would make its restriction to $G_K$ +reducible over an algebraic closure. In the CM case this would +force $K$ to be the CM field, which was excluded. +\end{proof} + +\begin{lemma}[Simultaneous finite Chebotarev realization] +\label{rl:chebotarev-evaluation} +For any element $u$ of an exact kernel in Lemma~\ref{rl:kernel}, +derivative primes can be chosen, at increasing finite precision, +whose rational Frobenius is $\tau u$ on all retained data. Their +finite localization is evaluation on $(\tau u)^2$. The assertion +is compatible with the outer construction of +Proposition~\ref{rl:outer-evaluation} and with any fixed finite +list of previous derivative operations. +\end{lemma} + +\begin{proof} +At one Artin stage, a coordinate of a cochain in the image of a +finite model is a locally constant function. The finitely many +coordinates being used factor through one finite quotient of the +absolute Galois group. Enlarge it to contain the Tate action at +the required precision, the finitely many ring-class fields and +quadratic characters currently in use, and all old finite data. +Chebotarev realizes the conjugacy class of $\tau u$ on this finite +quotient, with a chosen place realizing the desired representative. +It gives a rational prime inert in $K$, outside the old finite set. +Because $u$ is exactly Tate-trivial, its Frobenius tends to +$\rho_T(\tau)$; in particular $a_\ell\to0$ and $\ell\to-1$. +Because $u$ is exactly ring-class trivial, the square Frobenius on +the $K$-prime is the identity on every retained ring-class field. +The unramified local coordinate is therefore the stated +Frobenius-square evaluation. + +Repeat at each finite stage with increasing precision. All +conditions remain finite, and no density bound or prime-size +bound is required. For an outer sequence do this separately +for each inner sequence, retaining the relevant finite evaluation +matrices and degree-two identities before taking the outer +quotient. Approximate inner cycles cause no problem, by the +integrality calculation in Proposition~\ref{rl:outer-evaluation}. +Previously imposed finite diagrams are unchanged. +\end{proof} + +In induced-module notation, restriction to the exact kernel is additive. +For a crossed cocycle $b$ and an exact-kernel element $u$, +\[ + b((\tau u)^2)=(1+\tau)b(u). +\] +Indeed $\tau^2=1$, $u$ acts trivially on the coefficients, and the +cocycle identity cancels the two occurrences of $b(\tau)$. Projection +to either induced summand identifies $\operatorname{im}(1+\tau)$ +with a two-dimensional coefficient module, also in characteristic two. + +\begin{theorem}[The limit and evaluation interface] +\label{rl:limit-evaluation-package} +For the ring data fixed at the start of this section, retain the finite +target-side arithmetic diagrams with their maps to original cochains, homotopies, +and dualities as in Lemma~\ref{rl:finite-limits}. The moving characters, +local conditions, and evaluation constructions then have the following +simultaneous properties: +\begin{enumerate} +\item Every specified finite target-side arithmetic diagram admits a bounded free +model together with maps to its original cochains; the specified +maps, homotopies and dualities survive the inner limit. +\item At the stated height-one tests the relaxed active local +complexes are acyclic, and the Selmer duality pairs degrees one +and two. Integral Kummer conditions at $2N$ include their full +derived degree-zero invariants. +\item The residual sizes needed for the outer construction are +bounded independently of the active conductor support, with +dependence only on $E$, the bound on $\omega(\operatorname{disc}K)$, +and the number of retained derivative primes. +\item Inner and outer $H^1$ are detected by actual crossed +cocycles, including on the exact common kernel. The evaluations +and their degree-two identities can be realized by finite +Chebotarev conditions without disturbing earlier finite data. +\end{enumerate} +These assertions do not assert an Euler-system reciprocity law or +an integral derivative class that has not first been constructed +at finite level. Once those finite arithmetic diagrams are +constructed, this Theorem supplies their limit compatibility. +\end{theorem} + +\begin{proof} +Combine Lemmas~\ref{rl:finite-model} and~\ref{rl:finite-limits}, +Lemma~\ref{rl:kummer}, Proposition~\ref{rl:characters}, +Lemmas~\ref{rl:local-acyclic} and~\ref{rl:residual-bound}, +Lemmas~\ref{rl:evaluation} and~\ref{rl:kernel}, +Proposition~\ref{rl:outer-evaluation}, and +Lemma~\ref{rl:chebotarev-evaluation}. Every passage uses actual +integral matrices of bounded size; arbitrary evaluations are +retained by their original contraction maps, not by an inference +from a finite list of identities. +\end{proof} diff --git a/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/paper.pdf b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..5fb9efddd5b856cc3920fb72821060605251b5b5 --- /dev/null +++ b/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df42f33f68fbef7766e5679b298e68e910157f78f2266889fb757824b9e44939 +size 893027 diff --git a/preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/README.md b/preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1395e66f89b3385d7eb0a7c70d7fd76ae3069f14 --- /dev/null +++ b/preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [Abelian covers, Gale correspondences, and the Hodge conjecture for powers](paper.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026, + author = {{OpenAI}}, + title = {{Abelian covers, Gale correspondences, and the Hodge conjecture for powers}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/paper.pdf}{OAI:Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version updates citations to revised manuscripts in this collection; see the [previous version](../Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-September-30-2026/paper.pdf). diff --git a/preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/build/paper.tex b/preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/build/paper.tex new file mode 100644 index 0000000000000000000000000000000000000000..c9b5fecfe5f9fead4176fd99d336804aef0af284 --- /dev/null +++ b/preprints/Abelian-covers-Gale-correspondences-and-the-Hodge-conjecture-for-powers-October-6-2026/build/paper.tex @@ -0,0 +1,3779 @@ +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools,mathrsfs} +\usepackage{microtype} +\usepackage{enumitem} +\usepackage[colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref} +\hypersetup{pdftitle={Abelian covers, Gale correspondences, and the Hodge conjecture for powers},pdfauthor={OpenAI}} +\newcommand{\Q}{\mathbb Q} +\newcommand{\C}{\mathbb C} +\newcommand{\Z}{\mathbb Z} +\newcommand{\Qbar}{\overline{\mathbb Q}} +\newcommand{\PP}{\mathbb P} +\newcommand{\A}{\mathbb A} +\newcommand{\Gm}{\mathbb G_m} +\newcommand{\CH}{\operatorname{CH}} +\newcommand{\Gr}{\operatorname{Gr}} +\newcommand{\Jac}{\operatorname{Jac}} +\newcommand{\Conf}{\operatorname{Conf}} +\newcommand{\pr}{\operatorname{pr}} +\newcommand{\id}{\operatorname{id}} +\newcommand{\kk}{\overline{\Q}} +\newcommand{\U}{\mathcal U} +\newcommand{\D}{\mathcal D} +\newcommand{\V}{\mathbb V} +\newcommand{\cY}{\mathcal Y} +\theoremstyle{plain} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{companionresults}[theorem]{Companion results} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\numberwithin{equation}{section} +\title{Abelian covers, Gale correspondences,\\ +and the Hodge conjecture for powers} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\maketitle + +\begin{abstract} +We prove the rational Hodge conjecture on every self-power of the +Jacobian at each tensor Hodge-generic point of the full marked variation +of a connected abelian cover of curves. This holds in every base genus +and for every compatible branching pattern. For any CM abelian variety, +the conclusion also holds for every self-power of its product with the +Jacobian, on the same Hodge-generic locus. +We also prove the conjecture on every self-power of a very general +member of the full smooth labelled family of diagonal complete +intersections cut out by at most two equations of a common degree, in +every dimension and every degree at least two. +\end{abstract} + +\tableofcontents + +\section{Introduction} + +For a smooth projective complex variety \(X\), the rational Hodge +conjecture asserts that the cycle class map +\[ + \CH^p(X)_\Q\longrightarrow + H^{2p}(X,\Q)\cap H^{p,p}(X,\C) +\] +is surjective for every \(p\). Its assertion for all self-powers +\(X^u\) controls classes coupling different copies of \(X\) and is +stronger than the assertion for \(X\) alone. We prove all-self-power +results for two families. The first concerns Jacobians of connected +abelian covers of curves. The second concerns diagonal complete +intersections; their cohomology is supplied by correspondences from +the cover Jacobians and CM abelian varieties. + +\subsection{Abelian covers} + +Fix a compact connected oriented surface \(B_{\mathrm{top}}\), a finite +labelled set \(D\) of branch points, a point \(*\notin D\), a finite +abelian group \(P\), and an epimorphism +\[ + \phi:\pi_1(B_{\mathrm{top}}\setminus D,*)\longrightarrow P +\] +whose branch meridians have nonidentity image. The associated cover is +connected; denote its compact covering surface by \(C_{\mathrm{top}}\) +and retain a chosen point over \(*\). Empty branching and the +trivial group are allowed. Vary the full marked complex structure of +the pointed base, including all branch positions, and give the cover +the induced complex structure. Add labelled unbranched auxiliary +points only when needed for stability. Denote the connected marked +parameter manifold by \(\mathcal T_\phi\), its fibers by \(C_s\), and its marked +rational first cohomology by +\(H_\Q=H^1(C_{\mathrm{top}},\Q)\). + +Let \(\mathcal T_\phi^{\mathrm{Hg}}\) consist of the parameters \(s\) +with the following property: for every \(a\geq0\), any rational tensor +in \(H_\Q^{\otimes 2a}\) of type \((a,a)\) at \(s\) has that type +throughout \(\mathcal T_\phi\). Lemma~\ref{p4:generic-tensors} proves +that this is the complement of a countable union of proper closed +analytic tensor Hodge loci. A CM abelian variety here means one whose +degree-one Hodge group is a torus; a point is allowed. + +\begin{theorem}[Powers of abelian-cover Jacobians] +\label{p4:abelian-covers} +For each fixed connected topological abelian cover as above, every +\(s\in\mathcal T_\phi^{\mathrm{Hg}}\), every complex CM abelian variety +\(M\), and every integer \(N\geq1\), the rational Hodge conjecture holds +in every codimension of +\[ + \bigl(\Jac(C_s)\times M\bigr)^N. +\] +It also holds for \(C_s^a\times M^b\) for all integers \(a,b\geq0\), +where a zeroth power means a point. The point \(s\) is chosen before +\(M\): the same Hodge-generic locus works for every CM companion. +\end{theorem} + +The theorem allows every base genus and every branching pattern +compatible with the fixed connected cover. Its genericity is taken in +the full marked variation. Applying it to a constrained algebraic +family requires a comparison with that variation and a check that its +exceptional tensor loci pull back properly. The second part of this +paper carries out both steps for the curves arising from Gale duality. + +\subsection{Diagonal complete intersections} + +Fix an integer \(n\geq2\). For a rank-\(c\) matrix +\(A=(a_{\alpha i})\) with \(m\) columns, let +\[ + X_A=\left\{[x_1:\cdots:x_m]\in\PP^{m-1}: + \sum_{i=1}^m a_{\alpha i}x_i^n=0 + \quad(1\leq\alpha\leq c)\right\}. +\] +Changing the row basis of \(A\) does not change \(X_A\). We parametrize +these intersections by the row space in \(\Gr(c,m)\), retaining the +labels of the projective coordinates. Write +\[ + \D_{c,m}=\{Q\in\Gr(c,m):\text{every maximal coordinate minor + of \(Q\) is nonzero}\}. +\] +Proposition~\ref{prop:smooth-locus} proves that this is exactly the +smooth locus when \(1\leq c\leq m-1\). The dimension there is +\(d=m-c-1\). For \(c=0\) the parameter space is a point and +\(X=\PP^{m-1}\). + +\begin{theorem}[Powers of diagonal complete intersections] +\label{thm:main} +Fix \(n\geq2\), +\(d\geq0\), \(c\in\{0,1,2\}\), and put \(m=d+c+1\). +Outside a countable union of proper closed algebraic subsets of +\(\D_{c,m}\), the rational Hodge conjecture holds in every codimension +on \(X_A^u\) for every \(u\geq1\). For \(c\leq1\), or for \(d=0\), +no exceptional subset is needed. +\end{theorem} + +This is the full smooth family of labelled diagonal presentations of +the indicated rank, not the moduli space of the underlying abstract +varieties. The Gale construction itself applies at every smooth +parameter. The very-general restriction enters only when its dual +curve is placed in the locus of Theorem~\ref{p4:abelian-covers}. + +\subsection{Earlier work} + +The determinant construction for curves has direct precedent in +Schoen's phase-kernel and permutation quotient +\cite[Section~1, Lemmas~1.1--1.2]{Schoen}. His algebraicity theorem +there treats an even-rank setting with a pairable branch tuple +\cite[Theorem~2.0]{Schoen}. His construction also uses the distinguished +Abel fiber \cite[Section~2, pp.~12--13]{Schoen}. We isolate the top +exterior character line by this quotient and obtain arbitrary-branch +correspondence supply by dominating the distinguished fiber with +bundles over Fermat hypersurfaces. +The Fermat domination is due to Shioda and Katsura~\cite{SK}. The supply +uses full cohomology of CM sources; an individual unbalanced determinant +need not itself be a Hodge class. + +The character local systems and their sphere signatures belong to the +framework of Deligne and Mostow +\cite[Corollary~2.21 and Section~2.23]{DeligneMostow1986}. +For cyclic covers of the projective line, Rohde proves the full +special-unitary connected monodromy of each mixed non-real character eigenspace +\cite[preprint, Theorem~5.1.1]{Rohde2009}; Moonen records these +projections, including the symplectic order-two case, in his study of +special subvarieties \cite[Proposition~4.7]{Moonen2010}. + +The Kodaira--Spencer period differential is classical +\cite[Theorem~1.27]{Griffiths1968PeriodsII}; we give the equivariant +calculation needed also when the covering curve has genus one. For +mapping-class representations of covers, Landesman, Litt, and Sawin +identify connected monodromy with the derived group of the symplectic +centralizer in high-genus ranges, including base genus at least four +for abelian deck groups \cite[Theorem~1.3]{LandesmanLittSawin2025}. +Our proof gives the required all-genus character projections and +within-cover links directly; the low-genus comparisons do not follow +from that theorem. The use of globally Hodge tensors to control +monodromy is closely related to Andr\'e's argument +\cite[Section~4, Lemma~4]{Andre1992FixedPart}. + +The second geometric construction uses classical Gale association: +linear orthogonality modulo diagonal rescaling for labelled projective +configurations. It is treated systematically by +Dolgachev--Ortland~\cite{DO} and Eisenbud--Popescu~\cite{EP}; the latter +identifies association by complementary linear series +\cite[preprint, Corollary~3.2]{EP}. +Earlier work on complete intersections of Fermat type includes +Aoki~\cite{AokiCI} and Terasoma~\cite{Terasoma}. We give the +character-level algebraic correspondence argument used here in full, +including its support conditions, zero-dimensional endpoints, and Tate +shifts. Its evaluation quotient uses the same graded +alternating-character mechanism as Schoen's quotient. + +The dual curve in codimension two is a generalized Fermat curve. +Its diagonal model, abelian deck group, and normalized branch +parameters occur in Gonz\'alez-Diez--Hidalgo--Leyton~\cite{GDL} and +Hidalgo--Kontogeorgis--Leyton-\'Alvarez--Paramantzoglou~\cite{HKLP}. +In our notation, the moduli discussion in +\cite[author proof, Section~4.2]{GDL} assumes \((m-2)(n-1)>2\). +The Hodge application requires the relative family with a fixed based +deck datum, not only its fiberwise model. Section~\ref{sec:family} +supplies the finite coordinate-root base change, the based lift, and +the pathwise comparison with every marked fiber, including the +genus-zero and elliptic boundary cases. + +The Fermat factors in the Gale correspondence are essential. Classical +Hodge results for Fermat varieties include Aoki's proof of the rational +Hodge conjecture for individual Fermat varieties of prime-power degree +\cite[Corollary~2-3]{AokiFermat}. Our all-powers deduction instead uses +full-cohomology source maps from CM abelian varieties, combined with +Theorem~\ref{p4:abelian-covers} for mixed powers with one cover Jacobian. + +\subsection{The proof in outline} + +The common Hodge input is the rational Hodge theorem for every complex +CM abelian variety \cite[Theorem~1.1]{OpenAICM}. The shared tensor tools +from the companion paper on abelian powers reduce balanced degree-one +tensors to pairings and top exterior lines. Pairings are algebraic +divisor classes. A determinant line is \emph{CM-supplied} when it lies +in the span of images of full cohomology groups of CM abelian varieties +under rational algebraic correspondences, with the required Tate +shifts. A rational Hodge class in that span has a rational Hodge lift +to the sources and is therefore algebraic. Section~\ref{sec:shared} +records exactly the definitions and companion statements used here. + +Section~\ref{p4:sec:determinants} supplies each character determinant +for an abelian cover. A nontrivial character passes to its faithful +cyclic quotient; the invariant character uses the polarization. On a +finite quotient of a curve power, the relevant character cohomology is +the top alternating line. An Abel map concentrates it on one fiber, +which is dominated by varieties whose full cohomology is CM-supplied. +Deligne's weight theorem +detects the line on these sources, and a correspondence returns it to +the curve power. The same section supplies full Fermat cohomology +from CM abelian varieties. + +Section~\ref{p4:sec:covers} supplies the other input to the tensor +criterion: the derived Hodge action at the marked Hodge-generic points. +Disk and handle twists force standard character projections. +Comparisons of the full mapping-class actions identify the spaces +supported by the same simple Hodge ideal, compatibly with Hodge types +at every scalar conjugate. These identifications and the supplied +determinants give saturated data, so the tensor criterion remains +applicable after adjoining any CM abelian variety. + +For the diagonal theorem, assume \(c\in\{1,2\}\); projective space is +handled directly. For a subspace \(R\subset\C^r\), write +\[ + X_R=\{[x_i]\in\PP^{r-1}:(x_1^n,\ldots,x_r^n)\in R\}. +\] +Put \(P=\ker A\), so \(X_P=X_A\). For a character of the phase +group \((\mu_n)^m/\mu_n\), its support is the set of coordinates +with nonzero exponent. Section~\ref{sec:roots} shows that projection +to this support preserves the corresponding nontrivial cohomology. + +Write \(F_n^a=\{z_1^n+\cdots+z_{a+2}^n=0\}\subset\PP^{a+1}\). +For the ordinary bilinear pairing, let \(Q=P^\perp\). Coordinate +multiplication defines +\[ + X_P\times X_Q\longrightarrow F_n^{m-2},\qquad + ([x_i],[y_i])\longmapsto[x_i y_i]. +\] +Section~\ref{sec:gale} proves that a full-support Fermat character line +pulls back to a perfect tensor between the two character spaces. +At planes obtained by evaluating polynomials at distinct points, it is +the exterior coproduct on one curve's first cohomology; constancy of +rank then gives perfectness at every +smooth parameter. For a general support \(S\), contraction gives a +forward rational correspondence from +\[ + F_n^{|S|-2}\times X_{(\pr_S P)^\perp} +\] +whose image contains the corresponding part of \(H^d(X_P)\). +These are maps on whole rational cohomology degrees. If \(c=2\), +the only possible positive-dimensional dual source is the connected curve +\(C=X_{P^\perp}\); all other dual sources, and every dual source for +\(c=1\), are finite. Each source retains its Fermat factor. + +Section~\ref{sec:family} identifies the coefficient quotient with the +full ordered branch-configuration space. Finite coordinate-root +choices identify the algebraic families; configuration paths with +transported based lifts reach every marked cover fiber. Tensor +Hodge loci then give the algebraic very-general set on which the +dual curve satisfies Theorem~\ref{p4:abelian-covers}. + +Finally, the Fermat correspondences and the Abel map replace all source +factors by products \(\Jac(C)^v\times M\) with \(M\) CM; in the +one-equation case the Jacobian factor is absent. Section~\ref{sec:assembly} +checks the degree shifts and applies the shared correspondence-transfer +lemma. The cover locus is independent of \(M\), so the same parameter +works for every self-power. + +\section{Shared algebraic and tensor tools} +\label{sec:shared} + +This section fixes the notation needed by the determinant construction +and records the precise companion results used in its Hodge-theoretic +assembly. Their proofs belong to the companion paper +\cite[Section~2]{OpenAIAbelianPowers}. +No result on split Weil classes is used in this paper. + +All varieties are complex, cohomology is singular cohomology, and +algebraic correspondences have rational coefficients unless stated +otherwise. Put \(k=\Qbar\subset\C\). A scalar automorphism of \(k/\Q\) +acts on coefficients in the cohomology of the fixed complex variety; +it does not conjugate the variety. Our Tate convention is +\(V(r)^{p,q}=V^{p+r,q+r}\), so \(V(r)\) has weight +\(\operatorname{wt}(V)-2r\). A class is algebraic over \(k\) if it is +in the \(k\)-linear span of rational algebraic cycle classes. +For a rational vector space \(V\), write \(V_k=V\otimes_\Q k\). + +For a smooth projective variety \(X\), define +\[ + \mathcal C^d(X)= + \sum_{B,j,\Gamma}\operatorname{im}\!\left( + \Gamma_*:H^{d-2j}(B,\Q)\longrightarrow H^d(X,\Q)\right), + \qquad + \Gamma\in\CH^{\dim B+j}(B\times X)_\Q , +\] +where \(B\) ranges over CM abelian varieties, including a point, and +\(j\) ranges over integers for which the displayed groups and cycles exist. +The displayed map is a Hodge map from \(H^{d-2j}(B,\Q)(-j)\). +A subspace of \(H^d(X,k)\) is \emph{CM-supplied} if it lies in +\(\mathcal C^d(X)\otimes_\Q k\). Thus the definition uses the full +cohomology of the sources. The CM Hodge theorem and the equivalence of +this toric CM convention with its convention are +\cite[Theorem~1.1 and Lemma~2.3]{OpenAICM}. + +Let \(X\) be an abelian variety or a smooth connected projective curve. +A subspace \(W\subset H^1(X,k)\) is \emph{admissible} if it is the image +of a \(k\)-linear idempotent whose every scalar conjugate preserves the +Hodge decomposition after extension to \(\C\). A map between such +spaces, or between finite external direct sums of them, is admissible +if it preserves the Hodge decomposition after every scalar conjugation. +Write \(\overline W\) for scalar complex conjugation. A \emph{pair +tensor} between \(W,W'\) is a tensor in \(W\otimes W'\) inducing an +isomorphism \(W^*\to W'\), whose every scalar conjugate has type +\((1,1)\). Symmetry and alternation refer to ordinary tensor +interchange, before the cohomological Koszul sign. For \(r=\dim W\), put +\[ + D(W)=\bigwedge^rW\subset W^{\otimes r}\subset H^r(X^r,k), + \qquad D(0)=k +\] +on separate tensor slots, with \(D(0)\) carried by a point. + +For a polarizable rational weight-one Hodge structure \(H\) of types +\((1,0),(0,1)\), write \(\operatorname{Hdg}(H)\) for the smallest +rational algebraic subgroup of \(\operatorname{GL}(H)\) containing the +Hodge circle. It is connected reductive and lies in the symplectic +group of a polarization. A tensor in \(H^{\otimes 2a}\) is +\emph{balanced} when it has type \((a,a)\). + +\begin{companionresults}[Algebraic operations and degree-one tensors] +\label{comp:tools} +\leavevmode +\begin{enumerate}[label=\textup{(\roman*)}] +\item \emph{CM operations.} CM supply is preserved by external +products, permutations, cup products, rational algebraic +correspondences, \(k\)-linear combinations of such correspondences, +and scalar conjugation. Every rational Hodge class in a CM-supplied +subspace is algebraic. +\cite[Lemma~2.1]{OpenAIAbelianPowers}. + +\item \emph{Admissible operations.} Every admissible map is induced on +the indicated summands by a \(k\)-linear combination of rational +algebraic correspondences. Pair tensors are algebraic over \(k\), and +contraction by the inverse pairing is an algebraic cohomological +operation. If \(W\) is admissible, then \(\overline W\) is admissible +and paired with \(W\). Alternation and these operations factor +determinant lines across admissible direct sums and contract paired +determinants nontrivially; an alternating self-pair supplies its top +exterior line. +\cite[Lemma~2.2 and its determinant consequences]{OpenAIAbelianPowers}. + +\item \emph{Tensor stabilizer.} Inside the symplectic group of \(H\), +\(\operatorname{Hdg}(H)\) is the pointwise stabilizer of all rational +balanced tensors in \(H^{\otimes 2a}\), for all \(a\geq0\). +\cite[Lemma~2.3]{OpenAIAbelianPowers}. + +\item \emph{Toric summands.} If \(H\subset H^1(A,\Q)\) is a rational +Hodge summand of a complex abelian variety and \(\operatorname{Hdg}(H)\) +is a torus, then \(H\simeq H^1(B,\Q)\) for a CM isogeny factor \(B\) of +\(A\). Its scalar extension decomposes into CM embedding lines, with +repeated occurrences distinguished. +\cite[Lemma~2.4]{OpenAIAbelianPowers}. +\end{enumerate} +\end{companionresults} + +\begin{companionresults}[Saturated determinant criterion] +\label{comp:saturated} +Let \(A\) be a complex +abelian variety, \(H=H^1(A,\Q)\), \(J=\operatorname{Hdg}(H)\), and +\(R=J^{\mathrm{der}}\). The following data are called saturated: +\begin{enumerate}[label=\textnormal{(\alph*)}] +\item a rational Hodge summand \(H_0\subset H\) with toric Hodge group, +together with a decomposition of \(H_{0,k}\) into CM embedding lines, +with repeated occurrences distinguished; +\item a decomposition of the complement of \(H_{0,k}\) into blocks of +nonzero admissible spaces, each admissibly identified with an actual +representative \(V_i\) carrying an alternating or symmetric self-pair, +or, in a linear block with \(\dim V_i\geq2\), with \(V_i\) or +\(\overline V_i\), paired with each other; in every block \(V_i\) is +chosen as an actual summand of that block; +\item containment in the image of \(R_k\) of the product +\[ + \prod_{i\in I_{\mathrm{Sp}}}\operatorname{Sp}(V_i) + \times\prod_{i\in I_{\mathrm{SO}}}\operatorname{SO}(V_i) + \times\prod_{i\in I_{\mathrm{SL}}}\operatorname{SL}(V_i), +\] +acting standardly on its own copies, dually on the opposite linear +copies, and trivially on all other blocks and on \(H_{0,k}\); +\item CM supply for every singleton \(D(V_i)\) in an orthogonal or +linear block, without a balance condition. +\end{enumerate} +The symplectic and orthogonal forms in \textnormal{(c)} are inverse to +the specified pair tensors. The pair in a linear block identifies +\(\overline V_i\) with \(V_i^*(-1)\) as a Hodge-graded space and with +the dual as a group representation. Saturated data imply that every +rational balanced tensor is algebraic on its separate \(A\)-slots and +that the rational Hodge conjecture holds on every self-power of \(A\). +For every CM abelian variety \(M\), the induced data on \(A\times M\) +remain saturated and give the same conclusions on all its powers. +This is the saturated clause of +\cite[Theorem~2.5]{OpenAIAbelianPowers}. +\end{companionresults} + +Its separate determinant supply is what makes the cover locus +independent of the CM companion. The exact all-period +determinant-balance criterion and its proof remain in the companion. + +\begin{companionresults}[Correspondence transfer] +\label{comp:transfer} +Let \(\mathscr S\) be a +collection of smooth projective varieties such that the rational Hodge +conjecture holds on every finite product of its members. Suppose that, +for each smooth projective \(Y_i\) in a finite list and each degree +\(q\), the group \(H^q(Y_i,\Q)\) is spanned by maps +\[ + \Gamma_*:H^{q-2j}(S,\Q)\longrightarrow H^q(Y_i,\Q), + \qquad + \Gamma\in\CH^{\dim S+j}(S\times Y_i)_\Q,\quad S\in\mathscr S . +\] +Then the rational Hodge conjecture holds on every finite product of +the \(Y_i\), with repetitions and with additional members of +\(\mathscr S\). The same holds for restrictions of maps from +\(k\)-linear combinations of rational algebraic correspondences if +their images span the full target degree after scalar extension. +\cite[Lemma~2.6]{OpenAIAbelianPowers}. +\end{companionresults} +\section{CM sources for character determinants} +\label{p4:sec:determinants} + +For an abelian cover, the invariant-tensor theorem will require the +top alternating line of each character space in first cohomology. +The construction below realizes that line on a finite quotient of a +power of the curve. The relevant character cohomology is detected +on a distinguished Abel fiber; in the branched case, bundles over +Fermat hypersurfaces dominate that fiber, while in the unramified case +it is a union of projective spaces. We first give the precise +algebraic supply of those hypersurfaces. The same supply will +later feed the Gale correspondence in Section~\ref{sec:gale}. + +\subsection{Fermat cohomology from CM abelian varieties} + +\begin{lemma}[Finite quotient cohomology]\label{lem:quotient} +If a finite group \(G\) acts algebraically on a projective variety +\(V\), the quotient map \(q:V\to V/G\) induces +\begin{equation} + \label{p4:finite-quotient} + q^*:H^i(V/G,\Q)\xrightarrow{\;\sim\;}H^i(V,\Q)^G. +\end{equation} +The assertion remains true after extending coefficients. Pullback is +a morphism of mixed Hodge structures; if \(V\) is smooth and projective, +the cohomology of \(V/G\) is pure of the indicated degree. +\end{lemma} +\begin{proof} +The fibers of \(q\) are finite, so proper base change gives +\(R^j q_*\Q=0\) for \(j>0\). Each fiber is one \(G\)-orbit, hence +\((q_*\Q)^G=\Q\). Averaging makes invariants exact, and Leray gives +\eqref{p4:finite-quotient}, also after extending coefficients. +Pullback respects mixed Hodge structures. If \(V\) is smooth and +projective, strictness of the weight filtration and the displayed +injection into \(H^i(V,\Q)\) give purity. +\end{proof} + +\begin{lemma}[Bundle and blowup supply] +\label{p4:bundle-blowup-supply} +If the full cohomology of a smooth projective variety $S$ is +CM-supplied, the same holds for every projective bundle over $S$. +If $Z\subset X$ is a nonempty smooth closed subvariety of pure +codimension $c\ge1$ in a smooth projective variety, and the full +cohomologies of $X$ and $Z$ are CM-supplied, the same holds for +$\operatorname{Bl}_Z X$. +In both assertions finite correspondence supplies for the inputs +give finite supplies for the output in each degree. +\end{lemma} + +\begin{proof} +For a projective bundle $p:\mathbb P(E)\to S$ of relative +dimension $e-1$, put $\xi=c_1(\mathcal O_{\mathbb P(E)}(1))$. +The projective-bundle formula is +\[ + H^q(\mathbb P(E),\Q) + =\bigoplus_{i=0}^{e-1} + \xi^i p^*H^{q-2i}(S,\Q). +\] +The powers of $\xi$ restrict to a basis on each fiber, which proves +the formula by Leray--Hirsch. Every displayed map is algebraic. + +For a blowup $b:\widetilde X\to X$ of a center of codimension +$c$, let $j:E_Z\hookrightarrow\widetilde X$ be the exceptional +divisor and $p:E_Z=\mathbb P(N_{Z/X})\to Z$. With +$\xi=c_1(\mathcal O_{E_Z}(1))$, the blowup formula is +\[ + H^q(\widetilde X,\Q)=b^*H^q(X,\Q) + \oplus\bigoplus_{i=1}^{c-1} + j_*\bigl(\xi^{i-1}p^*H^{q-2i}(Z,\Q)\bigr). +\] +For completeness, the map of relative pairs +$(\widetilde X,E_Z)\to(X,Z)$ induces an isomorphism in relative +cohomology, since it is an isomorphism off the closed subsets and +the quotient spaces obtained by collapsing those subsets agree. +On $E_Z$, the projective-bundle formula and +$j^*j_*\eta=-\xi\eta$ show that subtracting the displayed +exceptional terms leaves a class whose restriction comes from +$Z$. The long exact sequences of the pairs then show that the +remaining class comes from $b^*H^q(X)$. The sum is direct: +$b_*b^*=\operatorname{id}$, $b_*$ kills these exceptional +terms, and their restrictions have independent positive powers +of $\xi$ on $E_Z$. All maps in the formula are algebraic. +Companion results~\ref{comp:tools}\textup{(i)} prove both supply assertions. +The formulas contain only finitely many summands, proving the +last assertion. +\end{proof} + +\begin{proposition}[Fermat supply] +\label{p4:fermat-supply} +For integers $n\ge2$ and $a\ge0$, let +\[ + F_n^a=\{x_0^n+\cdots+x_{a+1}^n=0\} + \subset\mathbb P^{a+1}_\C. +\] +For every degree $q$, there are finitely many CM abelian varieties +$B_\nu$, integers $j_\nu$, and rational algebraic correspondences +$\Gamma_\nu\in\CH^{\dim B_\nu+j_\nu}(B_\nu\times F_n^a)_\Q$ +such that the sum of their maps +\[ + \bigoplus_\nu H^{q-2j_\nu}(B_\nu,\Q)(-j_\nu) + \xrightarrow{\;\sum_\nu(\Gamma_\nu)_*\;} + H^q(F_n^a,\Q) +\] +is surjective. One may take every $B_\nu$ to be a power of the +CM abelian variety $\operatorname{Jac}(F_n^1)$, allowing its +zeroth power, a point. In dimension zero the finite reduced +scheme $F_n^0$ is supplied component by component by points. +\end{proposition} + +\begin{proof} +The Fermat hypersurfaces are smooth. The dimension-zero assertion +is immediate. The plane curve $F_n^1$ is connected: distinct +positive-degree components in $\mathbb P^2$ would meet by +B\'ezout's theorem, making their union singular. For this curve, +the coordinate power map +is the quotient by +$G=(\mu_n)^3/\mu_n$ onto the line +$z_0+z_1+z_2=0$ in $\mathbb P^2$, branched only at its three +coordinate points. The invariant part of first cohomology vanishes +by \eqref{p4:finite-quotient}. For a nontrivial character +$\chi$ of $G$, its summand of the finite pushforward of the +constant sheaf is a rank-one local system off the branch points +where $\chi$ is nontrivial on inertia, and has zero stalk at +those points. At a point where $\chi$ kills inertia it extends +across the point, as one sees by passing to the quotient by +$\ker\chi$. If there are $r\le3$ active points, its Euler +characteristic is $2-r$. The connected curve has no nontrivial +character in degrees zero or two, so +\[ + \dim_k H^1(F_n^1,k)_\chi=r-2\le1. +\] +Here a character occurring in first cohomology necessarily has +$r\ge2$. The Hodge group of the Jacobian commutes with the +algebraic deck action. Over $k$ its centralizer on first +cohomology is a product of multiplicative groups, since every +occurring character has multiplicity one. The connected Hodge +group is therefore a torus. Thus $\operatorname{Jac}(F_n^1)$ +is CM. The Abel map supplies the curve's first cohomology from +this Jacobian, and point correspondences supply degrees zero and +two. + +We recall the explicit domination associated with Shioda and +Katsura \cite{SK}, including its resolution so that +the maps used for supply are algebraic. For $a,b\ge1$, choose +$\varepsilon\in\C$ with $\varepsilon^n=-1$. There is a +rational map +\begin{equation} + \label{p4:eq:fermat-map} + \begin{split} + F_n^a\times F_n^b&\dashrightarrow F_n^{a+b},\\ + (x,y)&\longmapsto + \bigl((x_i y_{b+1})_{0\le i\le a}, + (\varepsilon x_{a+1}y_j)_{0\le j\le b}\bigr). + \end{split} +\end{equation} +Summing the $n$th powers of the two blocks gives the target +equation. To see dominance, take a target point whose first +block has nonzero power sum. Rescale its projective coordinates +so that this sum is $-1$; the second block then has power sum +$1$. Set $x_{a+1}=y_{b+1}=1$, use the first block for +$(x_0,\ldots,x_a)$ and $\varepsilon^{-1}$ times the second +for $(y_0,\ldots,y_b)$. These are preimages on the two Fermat +hypersurfaces. Source and target have equal dimension, so the +map is generically finite. + +The base locus is the smooth codimension-two subvariety +\[ + Z=\{x_{a+1}=y_{b+1}=0\} + \simeq F_n^{a-1}\times F_n^{b-1}. +\] +Near each of its points some $x_i$ and some $y_j$ in the +displayed blocks are units in projective coordinates. The base +ideal of \eqref{p4:eq:fermat-map} is consequently exactly the +ideal generated by $x_{a+1},y_{b+1}$. Blowing up $Z$ +removes this ideal and extends the map to a morphism +$f:\widetilde X\to F_n^{a+b}$ from a smooth projective variety. + +Induct on the target dimension, using $a=1$, $b=d-1$ in +dimension $d\ge2$. The product $F_n^1\times F_n^{d-1}$ +and the center $F_n^0\times F_n^{d-2}$ are supplied by +finitely many correspondence maps from powers of $\operatorname{Jac}(F_n^1)$, +by the induction hypothesis and external products. +The center may be disconnected; the blowup formula and supply +apply to its finitely many smooth components. +Lemma~\ref{p4:bundle-blowup-supply} gives the same supply for +$\widetilde X$. If $e>0$ is the generic degree of $f$, +the projection formula gives $f_*f^*=e\,\operatorname{id}$ +on rational cohomology. Thus $f_*$ is surjective, and composing +the supply maps with it supplies the full target cohomology. +Every source remains a power of the same Jacobian, and each +stage uses finitely many correspondence maps in each degree. +\end{proof} + +\subsection{Character determinants on curves} + +Every nontrivial character of an abelian deck group becomes faithful +on the cyclic quotient by its kernel. We first construct the supply +for a cyclic cover, then +transfer it to the original curve in +Corollary~\ref{p4:abelian-determinants}. + +We will use the following elementary vanishing. For a rank-one +$k$-local system on a circle with monodromy $a\ne1$, the cellular +cochain complex is $k\xrightarrow{a-1}k$, hence is acyclic. +The cellular complex for a product of circles is the tensor +product of the circle complexes. It follows that a rank-one +local system with at least one nontrivial monodromy has zero +cohomology on $(\C^\times)^s$, and also on its product with +an affine space. Its compactly supported cohomology vanishes +as well, by Poincar\'e duality with the dual local system. +The same cellular argument gives ordinary cohomology vanishing +for a nontrivial rank-one local system on a compact real torus. + +\begin{lemma}[Faithful cyclic determinants] +\label{p4:cyclic-determinant} +Let $q:C\to B$ be a connected cyclic cover of smooth connected +projective complex curves, with group $\Delta$ of order $m\ge2$. +Let $\chi:\Delta\to k^\times$ be faithful and put +$V_\chi=H^1(C,k)_\chi$, using inverse pullbacks for the group +action. Then $D(V_\chi)$ is CM-supplied on its product of +curve slots. The assertion includes $V_\chi=0$. + +More precisely, the CM sources in the defining correspondence +span may all be taken to be powers of the fixed CM abelian variety +$\operatorname{Jac}(F_m^1)$, allowing its zeroth power, a point. +\end{lemma} + +\begin{proof} +The group-algebra character idempotents and all their scalar +conjugates preserve the Hodge decomposition, so $V_\chi$ is +admissible and its determinant has the meaning fixed in +Section~\ref{sec:shared}. We use only the closure assertions +of Companion results~\ref{comp:tools}\textup{(i)}, not the Hodge-class conclusion. + +Let $g$ be the genus of $B$ and let +$D=t_1+\cdots+t_r$ be its reduced branch divisor. +The images of the branch meridians have product one in $\Delta$, +by the relation in the punctured surface group and commutativity +of $\Delta$. Thus $r=0$ or $r\ge2$. The $\chi$-part of +$q_*k_C$ is a rank-one local system on $B\setminus D$, with +zero stalk at every point of $D$, because $\chi$ is faithful +on each nontrivial inertia group. Its Euler characteristic is +$2-2g-r$. Since $C$ is connected, the nontrivial character +does not occur in $H^0(C,k)$ or $H^2(C,k)$. Hence +\begin{equation} + \label{p4:eq:cyclic-rank} + n:=\dim_k V_\chi=2g+r-2. +\end{equation} +There is no nontrivial connected unramified cover of a genus-zero +base, whose fundamental group is trivial. The numerical cases +$n=0$ are therefore $g=0,r=2$ and $g=1,r=0$; in either case +the determinant is the unit supplied by a point. We assume +$n>0$ from now on. + +\paragraph{The determinant on a finite quotient.} +Set $X=C^n$ and $G=\Delta^n\rtimes\mathfrak S_n$. +Multiplication of the cyclic coordinates is a homomorphism +$G\to\Delta$; let $N$ be its kernel. The finite quotients are +\begin{equation} + \label{p4:eq:cyclic-quotients} + Q:X\longrightarrow Z=X/N,\qquad + \pi:Z\longrightarrow Z/\Delta + =B^{(n)}:=\operatorname{Sym}^n B . +\end{equation} +The symmetric power is smooth: in a small disk about each +distinct point of a divisor, elementary symmetric functions +are coordinates for its cluster of points. + +By \eqref{p4:finite-quotient}, the pullback of +$H^n(Z,k)_\chi$ is the subspace of $H^n(X,k)$ on which +$(\delta_1,\ldots,\delta_n;\tau)$ acts by +$\chi(\delta_1\cdots\delta_n)$. On each curve factor this +nontrivial character excludes degrees zero and two. The only +possible K\"unneth summand is therefore $V_\chi^{\otimes n}$. +A geometric permutation of these degree-one factors includes +its Koszul sign, so invariance under $\mathfrak S_n$ means +ordinary antisymmetry. Consequently +\begin{equation} + \label{p4:eq:cyclic-determinant-line} + Q^*H^n(Z,k)_\chi=D(V_\chi). +\end{equation} +In particular $H^n(Z,k)_\chi$ is a line. + +Put $U=(B\setminus D)^{(n)}$ and +$\mathcal L=(\pi_*k_Z)_\chi$. At a divisor meeting a branch +point, the stabilizer of a lifted tuple contains the inertia +acting in that coordinate. Its image under the product +character is nontrivial. The $\chi$-part of the permutation +representation on that fiber is therefore zero. + +Over $U$, the map $\pi$ is a $\Delta$-torsor, including along +the diagonals. Indeed, suppose that a deck tuple followed by a +permutation fixes a lifted tuple. Around each cycle of the +permutation, the product of the deck displacements fixes one +point of the unramified cover and hence is the identity. Their +total product is therefore the identity, so the residual +$\Delta$-action is free. To check local triviality at repeated +points, choose disjoint disks about the distinct points of the +base divisor and label the unramified sheets over each disk. +Quotienting the sheet labels by $N$ retains only their total +product, while the coordinate permutations give the symmetric +powers of the disks. This yields $m$ local copies of the +base neighborhood. Thus $\mathcal L$ is extension by zero +of a rank-one local system on $U$. + +Its monodromy can be read from moving divisors. Follow the +$n$ points along a loop and multiply the deck displacements +of their lifted paths; their order at the endpoint may be +permuted. Closing these paths to a fixed base point cancels +the auxiliary paths because $\Delta$ is abelian. The product +is the original cover monodromy on the sum of the moving +paths in $H_1(B\setminus D,\mathbf Z)$, with multiplicities. +One may first make this calculation off the diagonals and +perturb a loop to avoid them; the local triviality just proved +gives the same rule on all of $U$. + +For both cases below, let +\[ + u:B^{(n)}\longrightarrow\operatorname{Pic}^n B +\] +be the Abel map, sending an effective divisor to its line bundle. +The fiber over $L$ is its complete linear system +$|L|=\mathbb P H^0(B,L)$, where projective space parametrizes +lines. In both cases $\deg K_B(D)=n$. Put +\[ + L_0=K_B(D),\qquad + T=(\pi^{-1}(|L_0|))_{\mathrm{red}}. +\] +Schoen's construction also uses this distinguished Abel fiber +\cite[Section~2, pp.~12--13]{Schoen}. +We will show that restriction to $T$ detects $H^n(Z,k)_\chi$ +and construct a proper surjection onto $T$ from smooth projective +varieties with CM-supplied cohomology. Detection maps the determinant +into source cohomology. After the two geometric cases, purity and +Poincar\'e duality will turn this detection into supply in the required +direction, through a correspondence obtained from the fiber product +with $C^n\to Z$. + +\paragraph{Localization in the branched case.} +Suppose $r>0$. Then $n\ge2g$. For $L\ne L_0$, the evaluations +\begin{equation} + \label{p4:eq:cyclic-evaluations} + H^0(B,L)\longrightarrow\bigoplus_{i=1}^r L|_{t_i} +\end{equation} +are surjective. In fact, $H^1(B,L)=0$ since +$\deg L=n>2g-2$. By the evaluation sequence and Serre duality, +the obstruction is dual to +$H^0(B,K_B\otimes L^{-1}(D))$. This is the space of sections +of a nontrivial degree-zero line bundle and is zero. +Riemann--Roch gives kernel dimension $g-1$. +If an $L\ne L_0$ exists then $g\ge1$, since +$\operatorname{Pic}^n\mathbb P^1$ is a point. +Coordinates adapted to the independent evaluations give +\begin{equation} + \label{p4:eq:cyclic-generic-complement} + |L|\cap U\simeq\mathbb A^{g-1}\times(\C^\times)^{r-1}. +\end{equation} + +The restriction of $\mathcal L$ to this complement is nontrivial. +Choose a section on one evaluation hyperplane and no other, +and take a transverse analytic disk through it in $|L|$. +The chosen evaluation has a simple zero in the disk parameter. +Even if the section has a multiple zero at that branch point, +Weierstrass preparation says that the product of the nearby +root coordinates is that evaluation times a nonvanishing +function. On the boundary of the disk the sum of the winding +numbers of those roots about the branch point is therefore one. +All other roots remain in disks away from the branch set. +The moving-divisor rule identifies the monodromy with the +nontrivial inertia character there. Collisions away from +the branch set can be perturbed apart, by local triviality +across the diagonals. + +The torus vanishing above now makes the compactly supported +cohomology of \eqref{p4:eq:cyclic-generic-complement} with +these coefficients zero. Because $\mathcal L$ is extension +by zero and $|L|$ is compact, this is +$H^*(|L|,\mathcal L|_{|L|})$. Proper base change shows that +each $R^j u_*\mathcal L$ is supported at $L_0$. A sheaf +supported at one closed point has no higher cohomology. +The Leray edge map, followed by proper base change for $\pi$, +therefore gives the restriction isomorphism +\begin{equation} + \label{p4:eq:cyclic-exceptional-restriction} + H^n(Z,k)_\chi\xrightarrow{\;\sim\;}H^n(T,k)_\chi. +\end{equation} +When $g=0$ there is no other Picard fiber, so the same +conclusion is immediate. Reduction does not change the +underlying cohomology. + +\paragraph{Fermat sources over the exceptional fiber.} +We next construct a proper surjection onto $T$ from smooth +projective varieties whose full cohomology is CM-supplied. +The residue sequence and the residue theorem give an exact +sequence +\[ + 0\longrightarrow G_0:=H^0(B,K_B) + \longrightarrow H^0(B,K_B(D)) + \longrightarrow + R:=\{(w_1,\ldots,w_r)\in\C^r:\textstyle\sum_iw_i=0\} + \longrightarrow0 . +\] +The surjectivity on the right also follows by Riemann--Roch. +Choose a vector-space splitting, so +$|L_0|=\mathbb P(G_0\oplus R)$. Its evaluation hyperplane +at $t_i$ is $w_i=0$: a meromorphic differential with at most +a simple pole there vanishes at $t_i$ as a section of $K_B(D)$ +exactly when its residue is zero. These hyperplanes are +distinct for $r\ge3$; the two hyperplanes coincide for $r=2$. + +The finite reduced map $T\to|L_0|$ is still a quotient by +$\Delta$. Averaging shows that invariants commute with +quotienting the ideal defining $|L_0|$, and taking reductions +leaves its reduced quotient unchanged. Every component of +$T$ dominates $|L_0|$. At least one does, since the finitely +many closed images of the components cover an irreducible base. +Its image is then the whole base, so it meets every fiber. +Each fiber is a single $\Delta$-orbit, and its translates +therefore cover $T$. Every component is one of those translates. + +Let $F=\C(|L_0|)$. Over $F$ the cover is a possibly disconnected +$\mu_m$-torsor, after identifying $\Delta$ with $\mu_m$. +Kummer theory writes its algebra as $F[z]/(z^m-f)$ for some +$f\in F^\times$. It is unramified away from the distinct +evaluation hyperplanes. Thus the valuation of $f$ at every +other prime divisor is divisible by $m$: a Kummer class extending +over that divisor's discrete valuation ring is represented there +by a unit times an $m$th power. + +Write the distinct hyperplanes as $H_i=\{\ell_i=0\}$, +$1\le i\le s$, with $\ell_i$ chosen among the residue coordinates. +For $i\ge2$, choose an integer $a_i$ representing the valuation +of $f$ at $H_i$ modulo $m$. The degree of a principal divisor +is zero. Since each $H_i$ has degree one and every other +valuation is divisible by $m$, the valuation at $H_1$ is +$-\sum_{i\ge2}a_i$ modulo $m$. Hence +\[ + \operatorname{div}\left( + f\Big/\prod_{i=2}^s(\ell_i/\ell_1)^{a_i}\right)=mE +\] +for an integral divisor $E$ on $|L_0|$. The Picard group of +projective space is torsion-free, so $E$ is principal. +It follows that +\begin{equation} + \label{p4:eq:cyclic-kummer-class} + f=c h^m\prod_{i=2}^s(\ell_i/\ell_1)^{a_i}, + \qquad c\in\C^\times,\quad h\in F^\times. +\end{equation} +This includes all prime divisors, not only those in an affine +chart. When $r=2$ we have $s=1$, so the product is empty and +the generic torsor splits. + +The coordinate power map +\[ + s_m:F_m^{r-2}\longrightarrow\mathbb P R,\qquad + [u_1:\cdots:u_r]\longmapsto[u_1^m:\cdots:u_r^m] +\] +is finite and surjective. Form the smooth projective bundle +\begin{equation} + \label{p4:eq:cyclic-fermat-bundle} + Y=\mathbb P_{F_m^{r-2}} + \left((G_0\otimes\mathcal O)\oplus + s_m^*\mathcal O_{\mathbb P R}(-1)\right). +\end{equation} +The tautological subline of $R$ defines a morphism +$Y\to\mathbb P(G_0\oplus R)=|L_0|$. On each component this +map is dominant and generically finite: away from zero +$R$-coordinate its fibers are the finite fibers of $s_m$. +The pullbacks of the hyperplane ratios in +\eqref{p4:eq:cyclic-kummer-class} are $(u_i/u_1)^m$. +The scalar $c$ also has an $m$th root in $\C$. The generic +torsor algebra therefore splits over the function field of +each component of $Y$. Evaluating at its roots gives rational +lifts to every prescribed component of $T$. + +Each rational lift extends to a morphism. Indeed, for a normal +integral variety mapping to a base, a rational lift to a scheme +finite over that base sends each element of the finite affine +algebra to a rational function integral over every local ring +of the source. Normality makes it regular; the resulting local +lifts glue. The image here is closed by properness and contains +the generic point of the prescribed component of $T$, so the +lift surjects onto it. Taking disjoint copies of the required +components of $Y$ gives a proper surjection +\begin{equation} + \label{p4:eq:cyclic-smooth-surjection} + Y'\longrightarrow T +\end{equation} +from smooth projective components of dimension $g+r-2$. +Proposition~\ref{p4:fermat-supply} and +Lemma~\ref{p4:bundle-blowup-supply} supply their full cohomology. +The vector space $G_0$ in \eqref{p4:eq:cyclic-fermat-bundle} +is constant, so this construction uses no cohomology of $B$. +For $r=2$, $F_m^0$ is a finite set and $Y'$ is a union of +projective spaces, as needed. + +\paragraph{Localization and supply in the unramified case.} +Suppose instead that $r=0$. Since $n>0$, +\eqref{p4:eq:cyclic-rank} gives $g\ge2$ and $n=2g-2$. +The character of the cover factors through $H_1(B,\mathbf Z)$, +the period lattice of $\operatorname{Jac}(B)$. It defines a +nontrivial rank-one local system $\mathcal E$ on +$\operatorname{Pic}^n B$, after choosing an origin on that +torsor. The moving-divisor rule gives $\mathcal L=u^*\mathcal E$. + +Riemann--Roch and Serre duality give +\[ + h^0(B,L)=g-1\quad(L\ne K_B),\qquad h^0(B,K_B)=g. +\] +Thus the fibers of $u$ are $\mathbb P^{g-2}$ except for the +fiber $\mathbb P^{g-1}$ over $K_B$. Choose an ample line +bundle on $B^{(n)}$. Its $j$th Chern power restricts to a +nonzero generator in degree $2j$ on every fiber for +$0\le j\le g-2$. It defines, by proper base change, a +stalkwise isomorphism $k\simeq R^{2j}u_*k$ in each such +degree. All odd direct images vanish, and the only remaining +one is $R^{2g-2}u_*k$, a rank-one skyscraper at $K_B$. + +By the projection formula the direct images for $u^*\mathcal E$ +are these sheaves tensored with $\mathcal E$. The cohomology +of $\mathcal E$ on the compact real torus underlying +$\operatorname{Pic}^n B$ vanishes by the calculation at the +start of the subsection. Leray leaves only the skyscraper +term. Here $L_0=K_B$, so the Leray edge map and proper base change +give the same restriction isomorphism +\eqref{p4:eq:cyclic-exceptional-restriction}. +The torsor on +$|K_B|=\mathbb P^{g-1}$ splits, since this projective space +is simply connected. Hence $T$ itself is a disjoint union +of projective spaces of dimension $g-1$. We may take $Y'=T$; +its full cohomology is supplied by points. + +\paragraph{Detection on a smooth source and return to the curve product.} +In either case we have a proper surjection +$Y'\to T$ from smooth projective components whose full +cohomology is CM-supplied. We use the following precise +consequence of proper cohomological descent: +if $T$ is proper and $Y'\to T$ is a proper surjection with +$Y'$ smooth, then +\begin{equation} + \label{p4:eq:cyclic-weight-kernel} + \ker\big(H^n(T,\Q)\longrightarrow H^n(Y',\Q)\big) + =W_{n-1}H^n(T,\Q). +\end{equation} +This is Deligne's Proposition~8.2.5 +\cite[Proposition~8.2.5, p.~39]{Deligne1974}: its proof +injects the weight-$n$ quotient into $H^n(Y',\Q)$. +Properness of $T$ bounds its weights above by $n$, and the +proper smooth $Y'$ has pure degree-$n$ cohomology, giving the +displayed kernel equality. The proposition requires neither +$T$ irreducible nor $Y'$ connected, so applies here. + +By \eqref{p4:finite-quotient}, $H^n(Z,\Q)$ is pure of weight +$n$, since it injects into $H^n(X,\Q)$ and $X=C^n$ is smooth +and projective. Restriction to $T$ is a morphism of mixed +Hodge structures. Strictness therefore gives +\[ + \operatorname{im}\big(H^n(Z,\Q)\to H^n(T,\Q)\big) + \cap W_{n-1}H^n(T,\Q)=0. +\] +Extend scalars to $k$ and take a nonzero +$\alpha\in H^n(Z,k)_\chi$. Its restriction is nonzero by +\eqref{p4:eq:cyclic-exceptional-restriction}. It survives +on some component $Y_0$ of $Y'$ by +\eqref{p4:eq:cyclic-weight-kernel}. Write +$p:Y_0\to T\to Z$ and $d=\dim Y_0$. Poincar\'e duality +provides +\[ + \beta\in H^{2d-n}(Y_0,k),\qquad + \int_{Y_0}p^*\alpha\smile\beta\ne0. +\] +Here $(d,2d-n)=(g+r-2,r-2)$ in the branched case and +$(d,2d-n)=(g-1,0)$ in the unramified case. In particular +these are valid degrees. The class $\beta$ is CM-supplied +because the full cohomology of $Y_0$ is. + +Choose an irreducible component of the finite surjection +$Y_0\times_Z X\to Y_0$ which dominates $Y_0$, and resolve it +projectively. The resulting smooth projective variety +$\widetilde Y$ fits into the commutative square +\[ + \begin{array}{ccc} + \widetilde Y & \xrightarrow{\ l\ } & X=C^n\\ + {\scriptstyle h}\big\downarrow && \big\downarrow{\scriptstyle Q}\\ + Y_0 & \xrightarrow{\ p\ } & Z, + \end{array} +\] +where $p$ factors as $Y_0\to T\to Z$, $h$ has positive generic degree +$e$, and $Ql=ph$. The component $Y_0$ has full CM supply and detects +$p^*\alpha$; the resolving variety $\widetilde Y$ is used only to realize +the return correspondence $l_*h^*$. +The algebraic correspondence +\[ + \Gamma=(h,l)_*[\widetilde Y]\in\CH^n(Y_0\times X)_\Q +\] +induces $l_*h^*$. Its cohomological degree shift is +$2(n-d)$, so it sends $\beta$ to $H^n(X,k)$. +This image is CM-supplied by Companion results~\ref{comp:tools}\textup{(i)}. +Only the pullback of $\beta$ is used; no supply assertion +about the cohomology of $\widetilde Y$ is required. +Projection formula gives +\begin{equation} + \label{p4:eq:cyclic-return-pairing} + \int_X Q^*\alpha\smile\Gamma_*\beta + =\int_{\widetilde Y}h^*(p^*\alpha\smile\beta) + =e\int_{Y_0}p^*\alpha\smile\beta\ne0. +\end{equation} + +Let $\rho:G\to k^\times$ be +$\rho(\delta_1,\ldots,\delta_n;\tau) +=\chi(\delta_1\cdots\delta_n)$. The inverse-character +idempotent is +\[ + P_{\rho^{-1}}=\frac1{|G|}\sum_{a\in G}\rho(a)a. +\] +It is a $k$-linear combination of algebraic automorphism +graphs. The integration pairing is $G$-invariant, while +$Q^*\alpha$ transforms by $\rho$. Averaging +\eqref{p4:eq:cyclic-return-pairing} therefore gives +\[ + \int_X Q^*\alpha\smile P_{\rho^{-1}}\Gamma_*\beta + =\int_X Q^*\alpha\smile\Gamma_*\beta\ne0. +\] +The calculation for \eqref{p4:eq:cyclic-determinant-line} +identifies the image of $P_{\rho^{-1}}$ in degree $n$ with +$D(H^1(C,k)_{\chi^{-1}})$; the inverse character has the same +rank $n$ by \eqref{p4:eq:cyclic-rank}. This determinant line +is thus CM-supplied. Complex conjugation of coefficient +scalars sends $\chi^{-1}$ to $\chi$, since its values are +roots of unity. It preserves the rational correspondence +span by Companion results~\ref{comp:tools}\textup{(i)}, proving the assertion +for $D(V_\chi)$. + +Finally, in the branched case +Proposition~\ref{p4:fermat-supply} starts the supply in +\eqref{p4:eq:cyclic-fermat-bundle} from powers of +$\operatorname{Jac}(F_m^1)$. The projective-bundle maps +and all subsequent maps merely compose those rational +correspondences, and coefficient conjugation preserves their +rational image span. The unramified and zero-rank cases +use a point. This proves the stated fixed-source refinement. +\end{proof} + +\begin{corollary}[Determinants for abelian covers] +\label{p4:abelian-determinants} +Let a finite abelian group $P$ act faithfully on a smooth connected +projective complex curve $C$, and put $B=C/P$. For every +character $\chi:P\to k^\times$, the line +$D(H^1(C,k)_\chi)$ is CM-supplied. This includes the zero +character spaces. For the trivial character the line is +generated by a rational algebraic cycle class. + +For $\chi\ne1$, let $r_\chi$ be the number of branch points of +$C/\ker\chi\to B$. Then +\[ + \dim_k H^1(C,k)_\chi=2g(B)+r_\chi-2. +\] +The number $r_\chi$ counts precisely the original branch points +whose inertia is not killed by $\chi$. + +For a fixed $P$, the CM sources for all these lines can be taken +to be powers of one fixed product of Fermat-curve Jacobians +depending only on $P$, not on the complex structure of $C$. +\end{corollary} + +\begin{proof} +Suppose first that $\chi\ne1$ and put $K=\ker\chi$. +The quotient $C_\chi=C/K$ is a smooth connected projective +curve; locally the quotient of a smooth curve by its finite +stabilizer has parameter $t^e$. The residual group $P/K$ +is cyclic and $\chi$ is faithful on it. Its action on +$C_\chi$ is effective. Indeed, choose a point of $C$ with +trivial $P$-stabilizer, outside the finitely many fixed points +of nonidentity automorphisms. If a coset acted trivially on +$C/K$, it would send this point into its $K$-orbit, forcing +the coset to be the identity. + +Equivariantly for the residual action, +\eqref{p4:finite-quotient} identifies +\[ + H^1(C_\chi,k)_\chi\xrightarrow{\;\sim\;}H^1(C,k)_\chi +\] +by quotient pullback. A point of $B$ is branched in +$C_\chi\to B$ exactly when its original inertia has nontrivial +image in $P/K$. Lemma~\ref{p4:cyclic-determinant} applies to +this connected cyclic quotient and gives its determinant supply; +\eqref{p4:eq:cyclic-rank} gives the dimension formula. +The tensor power of the rational graph pullback sends that determinant line to +$D(H^1(C,k)_\chi)$, by Companion results~\ref{comp:tools}\textup{(i)}. +If the character space is zero both lines are the unit. +This includes a quotient that becomes unramified although +the original cover is branched. + +For $\chi=1$, quotient pullback identifies the character +space with $H^1(B,k)$. Choose a point $b\in B$. +The rational algebraic class +\[ + [\Delta_B]-[b\times B]-[B\times b] +\] +is the $H^1(B)\otimes H^1(B)$ component of the diagonal and, +up to the cup-pairing convention, is the inverse symplectic +tensor. If $g=g(B)$, antisymmetrizing its $g$th external +power gives a nonzero multiple of the top exterior power +of this nondegenerate alternating tensor. It therefore +generates $D(H^1(B,k))$ by a rational algebraic class. +For $g=0$ this is the unit. Pullback on the curve slots +proves the assertion. + +For the last assertion, let $\mathcal O(P)$ be the finite set +of orders of nontrivial characters of $P$, and set +\[ + M_P=\prod_{m\in\mathcal O(P)}\operatorname{Jac}(F_m^1), +\] +with the empty product interpreted as a point. The faithful +lemma uses powers of the indicated factor for a character +of order $m$, and the trivial case uses a point. Each such +factor power is supplied from the corresponding power of +$M_P$ by its algebraic factor inclusion and projection. +The product $M_P$ is CM. This proves the uniform choice +of sources. +\end{proof} + +\section{Abelian covers with full marked variation} +\label{p4:sec:covers} + +We now apply the determinant criterion to Jacobians of abelian covers. +The determinant of each nontrivial character space is supplied by its +cyclic quotient, and the invariant determinant by the polarization. +The remaining task is to describe the derived Hodge action: +individual character projections must be standard, and characters on +which the same simple ideal acts must be identified by algebraic +correspondences. The second point is essential in small base genus. + +\subsection{The marked family and its Hodge-generic locus} + +Fix a compact connected oriented surface $B_{\mathrm{top}}$ of genus +$h\ge0$, a finite labelled set $D\subset B_{\mathrm{top}}$, a point +$*\notin D$, a finite abelian group $P$, and an epimorphism +\[ + \phi:\pi_1(B_{\mathrm{top}}\setminus D,*)\longrightarrow P. +\] +The meridian of every point in $D$ is required to have nonidentity +image. The images of the meridians multiply to one, by the surface +relation, and together with the handle images generate $P$. +The epimorphism describes a connected unramified $P$-cover off $D$; +compactifying at a meridian of order $e$ uses the local map $u\mapsto +u^e$. Denote the resulting compact surface by $C_{\mathrm{top}}$. +The trivial group and the empty branch set are permitted. + +Add labelled unbranched auxiliary points if needed so that the marked +base, including $*$, is stable. On the additionally punctured surface, +extend $\phi$ by sending their meridians to the identity element. +Let $\mathcal T_\phi$ be the connected +Teichm\"uller manifold of the resulting labelled surface. We vary its +\emph{full} marked complex structure: no branch positions or +base-complex-structure directions are held fixed. Lifting the charts +off $D$ and filling with the fixed local power maps gives a smooth +proper holomorphic family of compact curves $C_s$, locally on +$\mathcal T_\phi$. Its first cohomology is a marked polarized +variation on +\[ + H_\Q=H^1(C_{\mathrm{top}},\Q),\qquad + H_{\mathbb Z}=H^1(C_{\mathrm{top}},\mathbb Z). +\] +As in Section~\ref{sec:shared}, put $k=\Qbar$ and write +$H_K=H_\Q\otimes_\Q K$ for $K=k,\C$. +Auxiliary points do not alter these curves or their cohomology. +They only provide stable marked parameter spaces in the small cases. + +Let $\Gamma$ be the stabilizer of the exact epimorphism $\phi$ in the +pure based mapping class group, with all the labels fixed. It has +finite index because there are finitely many homomorphisms from the +finitely generated surface group to $P$. After choosing a point above +$*$, every element of $\Gamma$ has a unique lift fixing that point. +The lift commutes with $P$ and acts integrally and symplectically on +$H_\Q$. It respects the marked variation. We use inverse pullbacks +for left actions; replacing all actions by their opposites would not +change the algebraic closures. These are the standard marked-surface +and Dehn-twist conventions; see +\cite[Chapters~2, 3, and~6]{FarbMargalit2012}. + +\begin{lemma}[The Hodge-generic locus of the marked family] +\label{p4:generic-tensors} +For $a\ge0$ and $t\in H_\Q^{\otimes 2a}$, let +\[ + Z_t=\{s\in\mathcal T_\phi: + t_\C\in F^a(H_\C^{\otimes 2a})_s\},\qquad + \mathcal T_\phi^{\mathrm{Hg}} + =\mathcal T_\phi\setminus + \bigcup_{\substack{a\ge0,\ t\in H_\Q^{\otimes 2a}\\ + Z_t\ne\mathcal T_\phi}}Z_t. +\] +Each $Z_t$ is closed complex analytic. The complement +$\mathcal T_\phi^{\mathrm{Hg}}$ is nonempty and is the complement of a +countable union of proper closed analytic subsets. At a point in this +complement, every rational balanced tensor is balanced throughout +$\mathcal T_\phi$. + +Here $H_s$ denotes $H_\Q$ with the Hodge structure at $s$. +Let $J_s=\operatorname{Hdg}(H_s)$ and let $L$ be the rational Zariski +closure of $\Gamma$ in the symplectic group of $H_\Q$. At every +$s\in\mathcal T_\phi^{\mathrm{Hg}}$ one has +$L^\circ\subset J_s$, and the whole $\Gamma$ normalizes $J_s$. +\end{lemma} + +\begin{proof} +A rational tensor is real. In weight $2a$, it has type $(a,a)$ +exactly when it belongs to $F^a$: reality then also places it in +$\overline{F^a}$, whose intersection with $F^a$ is the $(a,a)$ part. +Membership in the holomorphic subbundle $F^a$ is the vanishing of the +induced section of its quotient bundle, so $Z_t$ is closed analytic. +There are countably many rational tensors. A proper analytic subset +of the connected complex manifold is nowhere dense, and Baire's theorem +proves the nonemptiness assertion. Odd tensor degrees have no balanced +vectors, since the circle element $-1$ acts on them by $-1$. + +At a point in the displayed complement, the balanced rational tensors +are exactly those balanced at every marked parameter. The latter +spaces are preserved by $\Gamma$, because it acts equivariantly on the +whole variation. By Companion results~\ref{comp:tools}\textup{(iii)}, their pointwise +stabilizer in the symplectic group is $J_s$. Thus every element of +$\Gamma$ normalizes $J_s$. + +An individual globally balanced tensor has finite $\Gamma$-orbit. +We use the finite-action argument of +\cite[Section~4, Lemma~4]{Andre1992FixedPart}. +If its denominator is $q$ in the integral tensor lattice, every +translate still lies in $q^{-1}H_{\mathbb Z}^{\otimes 2a}$, and +its tensor-polarization norm is unchanged by transport. At a fixed +fiber all its translates lie in the real balanced subspace. The tensor +polarization, with its fixed weight sign, is definite on that subspace. +A fixed norm sphere there is compact and contains only finitely many +points of this lattice. The orbit is therefore finite. +The connected algebraic group $L^\circ$ fixes every such tensor, so +Companion results~\ref{comp:tools}\textup{(iii)} give $L^\circ\subset J_s$. +\end{proof} + +The definition of $\mathcal T_\phi^{\mathrm{Hg}}$ specifies the entire +exceptional locus used below. It is a locus in the full marked family; +a proper subfamily inherits the conclusion only after verifying that +these tensor loci pull back properly. + +\begin{proposition}[Saturated data for the marked cover family] +\label{p4:cover-saturation} +For every connected topological abelian cover and full marked family +defined above, and every \(s\in\mathcal T_\phi^{\mathrm{Hg}}\), the +Jacobian \(\operatorname{Jac}(C_s)\) admits saturated data in +Companion results~\ref{comp:saturated}. +\end{proposition} + +This proposition supplies the tensor input for +Theorem~\ref{p4:abelian-covers}. Write $C\to B$ for a fiber of the +fixed marked family. Its character decomposition is +\[ + H_k=\bigoplus_\chi W_\chi,\qquad + W_\chi=e_\chi H_k,\qquad + e_\chi=\frac1{|P|}\sum_{g\in P}\chi(g)^{-1}g\in k[P]. +\] +Every scalar conjugate of $e_\chi$ is again a deck-character projector, +so it preserves the Hodge decomposition. Thus the $W_\chi$ are +admissible in the sense of Section~\ref{sec:shared}. The marking +identifies these spaces and the mapping-class operators across all fibers. + +Corollary~\ref{p4:abelian-determinants} already supplies their +determinant lines. We must establish two properties of their +Hodge-group action. First, every character space with nontrivial +derived action has standard special linear or symplectic projection. +Second, when one simple Hodge Lie ideal acts on several such spaces, +their standard or dual identifications must preserve the Hodge circle +at every scalar conjugate. Rank-one twist operators give the +projections; the comparison of spaces will depend on whether the base +has positive genus or is a sphere. + +\subsection{A rank-one criterion for standard actions} + +\begin{lemma}[Rank-one nilpotents]\label{p4:cover-rank-one} +Let $V$ be a finite-dimensional vector space over $k=\Qbar$, and let a +connected reductive algebraic +subgroup of $\operatorname{GL}(V)$ act irreducibly. If its Lie algebra contains a +rank-one nilpotent, its derived image is the standard special linear or +standard symplectic group on $V$. +\end{lemma} + +\begin{proof} +It is enough to prove the Lie algebra assertion, since the groups in the +conclusion are connected. Extending scalars from $k$ to $\C$ preserves +irreducibility, semisimplicity, and the rank condition, so we work over +$\C$. In the symplectic alternative the invariant alternating form +descends to $k$: invariant forms are the kernel of linear equations +over $k$, and the determinant is nonzero on a suitable alternating +form with coefficients in $k$. Equality of the connected group images then descends under +scalar extension. The center +acts by scalars. The Jordan decomposition in an algebraic Lie algebra +shows that a nilpotent element has zero central component and nilpotent +components in its simple ideals. Write the irreducible representation +of the semisimple image as a tensor product $\bigotimes_i V_i$ of +nontrivial irreducibles for its simple ideals. + +Let $N$ be the given rank-one nilpotent. In particular $N^2=0$. If two +of its simple-ideal components $N_i,N_j$ were nonzero, choose length-two +terminal Jordan strings in $V_i,V_j$ and kernel vectors in the other +factors. On the tensor product of the top vectors of these strings, +$N^2$ is $2N_i\otimes N_j\ne0$. This is impossible. If just $N_i$ is +nonzero, its rank on $V$ is +$\operatorname{rank}(N_i)\prod_{j\ne i}\dim V_j$. Rank one therefore forces the +semisimple image to be simple. + +Put $N$ in the nilradical of a Borel subalgebra of this simple image. +A generic one-parameter subgroup of its maximal torus, together with +a scalar rescaling, degenerates $N$ to a nonzero root vector $x_\alpha$. +The locus of matrices of rank at most one is closed, so $x_\alpha$ has +rank one. Every root vector for a root of the same length has rank one, +by Weyl conjugacy. Restriction to the corresponding root +$\mathfrak{sl}_2$ consequently consists of one standard doublet and +trivial representations: the rank of the raising operator on an +irreducible $\mathfrak{sl}_2$-module of dimension $a$ is $a-1$. +Thus each reflection in a root of that length exchanges exactly two +weights, both of multiplicity one, and fixes every other weight. + +Here is the root-system check that finishes the argument. We use the +usual classification and weight lattices of reduced irreducible root +systems, as in \cite[Sections~23--25 and~30]{Etingof2024Lie}. The roots +of a specified length form a full-rank simply laced root system, not +necessarily a closed root subsystem of the ambient root system: the whole +system in simply laced type; $D_\ell$ or $A_1^\ell$ in types $B_\ell$ +and $C_\ell$; $D_4$ in type $F_4$; and $A_2$ in type $G_2$. Use the +small-rank conventions $D_3=A_3$ and $D_2=A_1\sqcup A_1$. + +The simple reflections of this root system act as distinct +transpositions on the weights. They are distinct because the weights +span the dual Cartan space. Orthogonal simple roots give disjoint +transpositions, while adjacent simple roots give transpositions sharing +one endpoint. A branching vertex of the Dynkin diagram would require +three disjoint transpositions each meeting the same two-element set, +which is impossible. A connected full-rank path $A_\ell$ therefore +acts on precisely $\ell+1$ moved weights as successive transpositions +on a path. All other weights, being fixed by this full-rank root system, +are zero. The moved weights form its standard regular simplex: their +successive differences are the simple roots with a consistent choice +of sign, as follows by pairing with adjacent simple coroots. In full +type $A_\ell$ the highest weight is thus the first or last fundamental +weight. Irreducibility gives the standard representation or its dual. +If this path arose instead from $G_2$, $B_3$, or $C_3$, the full Weyl +group contains negation, whereas this simplex, for $\ell\ge2$, is not +stable under negation. Those cases are excluded. + +It remains to consider the orthogonal-axis root system $A_1^\ell$. +Its transpositions are disjoint. A moved weight for one axis is fixed +by every other axis reflection, so lies on that axis; the doublet +condition makes its two weights $\pm\alpha/2$. For the long roots +$2e_i$ in $C_\ell$, this gives the weights $\pm e_i$, and the highest +weight is that of the symplectic standard representation. For the +short roots $e_i$ in $B_\ell$, the vectors $\pm e_i/2$ are not weights +when $\ell\ge2$. In the rank-two $D_2$ root system the half-roots +$(\pm e_1\pm e_2)/2$ are not weights of $C_2$; in $B_2$ they give its +spin representation, which is the standard representation under +$B_2=C_2$. Rank one gives the ordinary $\mathfrak{sl}_2$ standard. +These are exactly the alternatives in the statement. +\end{proof} + +\subsection{Character cohomology and disk twists} + +We next construct the rank-one operators to which the preceding lemma +will apply. Their formulas also let us compare different characters. + +For a character $\chi:P\to k^\times$, the space +$W_\chi$ is $H^1(C,k)_\chi$. Inverting all character conventions makes no +difference; choose the convention in which $W_\chi$ is computed by the +rank-one character $t=\chi\phi$ below. The trivial character gives +$W_{\mathbf1}=H^1(B,k)$, by quotient pullback. For a nontrivial +character, pass to its cyclic quotient and fill every puncture whose +local multiplier is one. Write the remaining multipliers as +$t_1,\ldots,t_r\ne1$. Then $r=0$ or $r\ge2$, and +\begin{equation}\label{p4:character-dimension} + \dim W_\chi=2h+r-2. +\end{equation} + +For a nonzero complex character space, \emph{pure} and \emph{mixed} +mean respectively that just one, or both, of its $(1,0)$ and +$(0,1)$ parts are nonzero. + +\begin{lemma}[Cocycles and twists]\label{p4:twist-model} +For a nontrivial $t$, the character space is the space of crossed +homomorphisms +\begin{equation}\label{p4:cocycles} + z(uv)=z(u)+t(u)z(v), + \qquad z(u)\sim z(u)+(1-t(u))b\quad(b\in k). +\end{equation} +Use generators $a_j,b_j$ for the handles and positively based meridians +$g_i$, with relation $\prod_j[a_j,b_j]\prod_i g_i=1$. Values of $z$ on +these generators satisfy just the crossed-homomorphism relation on this +word, followed by the one-dimensional coboundary quotient. + +Let $\alpha$ be an embedded arc between two active punctures. A twist +about the boundary of its two-puncture disk acts, in adapted coordinates +and after choosing one of the two twist conventions, by +\begin{equation}\label{p4:pair-twist} + T_\alpha=1+u_\alpha\ell_\alpha,\qquad + u_\alpha=(-t_i,1),\qquad + \ell_\alpha(z)=(1-t_j)z(g_i)+(t_i-1)z(g_j), +\end{equation} +with $u_\alpha$ supported on these two meridians. Its exceptional +eigenvalue is $t_it_j$. A different choice of lift can multiply this +formula by a finite-order scalar. + +For a nontrivial such transformation, its fixed hyperplane is the +Hermitian orthogonal complement of its image direction. If a collection +of these directions has connected nonorthogonality graph and their fixed +hyperplanes have zero intersection, the group they generate acts +irreducibly. These statements apply also to ordinary transvections +arising from simple closed curves with trivial $t$-monodromy. +\end{lemma} + +\begin{proof} +The eigenspace on the unbranched cover is the cohomology of the +corresponding rank-one local system on the punctured base, by averaging +over the finite deck group. Filling an inactive puncture gives ordinary +cohomology on the filled base. At an active puncture the local complex +is $k\xrightarrow{t_i-1}k$, which is acyclic, so no local term changes +the character cohomology. The cellular cochain model, or the standard +crossed-homomorphism model of degree-one group cohomology, gives +Equation~\eqref{p4:cocycles}. Euler characteristic gives +Equation~\eqref{p4:character-dimension}; in the unramified case both degree zero +and degree two vanish for a nontrivial rank-one system. + +For the twist, conjugate the two meridians by their product +$\delta=g_ig_j$ and fix the exterior generators. The identity +\[ + z(fuf^{-1})=(1-t(u))z(f)+t(f)z(u) +\] +gives Equation~\eqref{p4:pair-twist} by direct subtraction. In +particular $\ell_\alpha(u_\alpha)=t_it_j-1$. All such disk twists +preserve $\phi$: they act trivially on the abelianization of the +punctured surface group. For other mapping classes preserving $t$, a +positive power preserves $\phi$, which suffices for all Lie-algebra +statements. + +Set $s_i=z(g_i)/(1-t_i)$. These are the fixed points of the affine +transformations represented by the meridians. The fixed-hyperplane +condition is $s_i=s_j$ after transport along $\alpha$. More explicitly, +if $\alpha$ is represented by $p_i^{-1}xp_j$ in terms of based access +paths and a based loop $x$, it is +\begin{equation}\label{p4:fixed-points} + s_i=z(x)+t(x)s_j. +\end{equation} +This description is unchanged by endpoint windings. For $r\ge3$ the +image vector in Equation~\eqref{p4:pair-twist} is nonzero modulo +coboundaries, since another active meridian has zero coordinate in it. +When $r=2$, if that vector is a coboundary, all exterior multipliers are +one; the surface relation then also makes $\ell_\alpha$ zero. + +The polarization pairs opposite character spaces perfectly and gives +a nondegenerate Hermitian form on $W_{\chi,\C}$, preserved by the +monodromy. If $T=1+u\ell$ is a nontrivial isometry, every fixed vector +is orthogonal to $(T-1)W=ku$. Both spaces have codimension one, proving +the fixed-hyperplane assertion. A common zero intersection of fixed +hyperplanes makes the directions span by nondegeneracy. A nonzero +invariant subspace contains a vector moved by one transformation, hence +contains its image direction. Nonorthogonality then propagates this +inclusion along the graph and gives the whole space. + +Finally, if a simple closed curve has trivial $t$-monodromy, lift its +annulus to the cyclic cover and twist simultaneously about its lifts. +The ordinary intersection formula restricts on a character space to +rank at most one: the projected lift classes are scalar multiples of +each other. If evaluation of the cocycle on one closed lift is nonzero, +the intersection-dual projected class is nonzero as well, by the perfect +opposite-character pairing. The resulting transformation is a +nontrivial rank-one unipotent. Its logarithm, or a nonzero integral +multiple obtained by taking a power, belongs to the Lie algebra of +connected monodromy. +\end{proof} + +\begin{lemma}[Connected irreducibility]\label{p4:connected-irreducibility} +Suppose a subgroup of $\operatorname{GL}(V)$ acts irreducibly and is generated, +up to scalars, by rank-one changes of the identity. If the Lie algebra +of its Zariski closure contains a rank-one nilpotent, the identity +component of that closure acts irreducibly. +\end{lemma} + +\begin{proof} +The unipotent radical of the identity component is normal in the full +closure. Its common fixed subspace is nonzero and is invariant under +the full group, so it is all of $V$; the radical is trivial in the +given faithful image. The identity component is therefore reductive. +Its isotypic summands are permuted transitively by the full group. +A rank-one nilpotent can act nontrivially on only one isotypic summand, +and there with multiplicity one; that summand has dimension at least +two. Transitivity gives the same two properties for every summand. +A scalar multiple of a rank-one change cannot permute two summands of +dimension at least two: its difference from that scalar identity +would have rank at least two. Thus all the generators preserve every +summand. Irreducibility forces a single summand, with multiplicity +one, as required. +\end{proof} + +\subsection{Positive base genus} + +We now assume $h\ge1$. The handle character can be concentrated on one +generator: +\begin{equation}\label{p4:handle-character} + t(a_j)=t(b_j)=1\quad(j1$. + +An operator normalizing this isotypical action has the form +$B\otimes D$, with $B\in\operatorname{GL}(S)$ and $D\in\operatorname{GL}(A)$. +To see this, choose an intertwiner $B$ for the induced automorphism +of the irreducible representation on $S$; what remains centralizes +that representation and is $1\otimes D$ by Schur's lemma. +A nontrivial semisimple pseudoreflection cannot have this form +when both factors have dimension at least two. Indeed the factors +must themselves be semisimple (a nontrivial unipotent Jordan part +would survive on the tensor product). Their eigenvalue products +would then form a rectangular grid with just one exceptional +entry. A two-by-two subrectangle containing that entry contradicts +the equality of the products of its two diagonal pairs. Hence +$\dim A=1$, and the connected action is irreducible. + +The only remaining reducible case has distinct one-dimensional +isotypical summands. The Hermitian form pairs each such line +nondegenerately with exactly one other line: for characters +$a,b$ of the connected group, a nonzero pairing requires +$a\overline b=1$ on the finite-index monodromy subgroup dense in +that group. Distinct characters preclude two choices of $b$. +Hermitian symmetry makes this a pairing involution on the set of +lines. Each pair twist preserves the involution and permutes the +lines by either the identity or one transposition. Indeed, a +permutation cycle of length $\ell$ contributes rank at least $\ell-1$ +to the difference from a scalar identity, and disjoint cycles +contribute independently; here that rank is one. The permutation +group generated by the twists is transitive, by irreducibility. +If the pairing involution had no fixed point, a transposition +commuting with it would have an invariant two-element support, so +could only exchange the members of one of its pairs. Such +transpositions cannot act transitively on at least +three lines. Thus there is a fixed point, and transitivity makes +every line self-paired. Distinct lines are orthogonal; transitivity +also makes their signs equal. The Hermitian form is definite. + +The decomposition into distinct one-dimensional connected +isotypicals and the pseudoreflection action are algebraic +properties over $k$. They persist at every scalar translate. +The same argument therefore makes the Hermitian form definite on +every translated character space. By +Lemma~\ref{p4:sphere-determinant-finite} the rational orbit +monodromy is finite, a contradiction. This proves connected +irreducibility in the remaining case. + +Use now a pair twist with eigenvalue ratio +$\lambda\ne\pm1$. After a scalar normalization it is +$R=\operatorname{diag}(\lambda,1,\ldots,1)$ for a decomposition +$W_\chi=L\oplus U$, $\dim L=1$. Conjugation by $R$ preserves +$\mathfrak m=\operatorname{Lie}(M_\chi^\circ)$ and has the three distinct +eigenvalues $1,\lambda,\lambda^{-1}$ on +\[ + \operatorname{End}(L)\oplus\operatorname{End}(U),\qquad + \operatorname{Hom}(U,L),\qquad \operatorname{Hom}(L,U), +\] +respectively. Polynomial projection onto these eigenspaces +preserves $\mathfrak m$. Connected irreducibility implies that +some off-diagonal component is nonzero, since otherwise $L$ and +$U$ would be invariant. A nonzero element of either off-diagonal +space has rank one and square zero. It supplies the asserted +nilpotent. +\end{proof} + +The preceding lemma determines the infinite projections. The finite +case is toric by Lemma~\ref{p4:sphere-finite-pure}. +For cyclic covers of $\PP^1$, the monodromy projections for mixed +characters with $\chi^2\ne1$ are computed in +\cite[preprint, Theorem~5.1.1]{Rohde2009}; +\cite[Proposition~4.7]{Moonen2010} also includes the symplectic +projection for order-two characters. The following +statement collects exactly the alternatives needed for the tensor +criterion. + +\begin{proposition}[Sphere projections]\label{p4:sphere-projections} +At every $s\in\mathcal T_\phi^{\mathrm{Hg}}$ the following assertions hold. +\begin{enumerate}[label=\textup{(\roman*)}] +\item If $n\ge3$, then either $M_\chi$ is finite and the Hodge +action on its rational scalar orbit is toric, or +\[ + M_\chi^\circ= + \begin{cases} + \operatorname{Sp}(W_\chi),&\chi^2=1,\\ + \operatorname{SL}(W_\chi),&\chi^2\ne1. + \end{cases} +\] +In the infinite case the derived Hodge projection is the same +standard group. +\item In dimensions at most two every non-toric character space +has dimension two and has standard derived Hodge projection +$\operatorname{SL}_2$. +\end{enumerate} +Here the symplectic group is for the restricted polarization on +the order-two character space. Each non-toric character space +is supported by a single simple ideal of $\operatorname{Lie}(J^{\mathrm{der}})_k$. +\end{proposition} + +\begin{proof} +For $n\ge3$, Lemmas~\ref{p4:sphere-connected-irreducible} and +\ref{p4:cover-rank-one} give either the full standard special linear or +the full standard symplectic derived algebra of connected +monodromy. Its determinant is finite, so its connected scalar +center is trivial. In the symplectic case all of $M_\chi$ +normalizes the connected symplectic group and hence preserves +its unique invariant alternating form up to scalar. + +In dimension at least four a semisimple pseudoreflection with +ratio different from $1$ cannot be such a similitude. Normalize +its fixed hyperplane $U$ to have eigenvalue $1$. The alternating +form does not vanish identically on $U$, since $\dim U=n-1>n/2$; +thus the similitude multiplier is $1$. Its exceptional eigenline +must then be orthogonal to $U$ and to itself, and hence be in the +radical, an impossibility. It follows that every active pair +product is $1$. With at least three active points this forces +all $t_i=-1$. The sphere meridians generate the deck group, so +$\chi$ has order two. Conversely an order-two character space +has a nondegenerate alternating polarization and monodromy +contained in its symplectic group. Its pair twists are nontrivial +unipotents, so the symplectic alternative occurs. This proves +the stated connected monodromy groups. + +The algebraic image of $L_k$ on $W_\chi$ is closed and is the Zariski +closure of the character action, hence is $M_\chi$. The image of +$L_k^\circ$ is $M_\chi^\circ$, by the identity-component property of +algebraic group images. By Lemma~\ref{p4:generic-tensors}, +$L^\circ\subset J$, so connected character monodromy is contained in +the image of $J_k$ on $W_\chi$. In the special linear case its action already contains +the full traceless algebra. In the order-two case the Hodge group +also preserves the restricted alternating polarization. Hence +the derived Hodge projections are exactly the groups asserted +in (i). Finite monodromy gives the toric conclusion by +Lemma~\ref{p4:sphere-finite-pure}. + +A connected reductive subgroup of $\operatorname{GL}_2$ either acts through a +torus or, when its derived image is nontrivial, has the full +standard $\operatorname{SL}_2$ as its derived image. Indeed a reducible +two-dimensional representation of a reductive group is a sum of +characters, while the only nonzero semisimple subalgebra of +$\mathfrak{sl}_2$ is $\mathfrak{sl}_2$ itself. Dimension one is +toric, and dimension zero is omitted. This proves (ii). +Finally each displayed derived image is simple, and a +surjective map from a semisimple Lie algebra to a simple one is +supported by exactly one simple ideal. +\end{proof} + +We have identified each projection, but a single simple Hodge ideal +may act on several character spaces. To identify those copies by +algebraic maps, we must compare the whole mapping-class actions. +The only additional numerical calculation occurs for four active +points, where the standard spaces have dimension two. + +\begin{lemma}[Four-point signatures]\label{p4:sphere-four-signatures} +Suppose $r=4$ and write $t_i=\exp(2\pi i v_i)$ with +$00$. Its identity action fixes the projective scalar +in the comparison, even when the full operator is a nontrivial +unipotent extension of the identity. We obtain +\[ + t_i't_j't_\ell'=t_it_jt_\ell. +\] +Equation~\eqref{p4:sphere-pair-products} makes every ratio +$t_i'/t_i$ equal to a common sign; the triple equality makes +that sign $1$. All local multipliers are equal. Since sphere +meridians generate the deck group, the characters coincide +after the permitted inversion. This proves the first part +of (i). The symplectic assertion follows from +Proposition~\ref{p4:sphere-projections}: its character has +order two, so complex conjugation acts internally and exchanges +its two Hodge parts. Both parts have dimension $n/2$ at every +translate. + +Now suppose $n=2$, so the common active set has four points. +The eigenvalue ratio of a projective two-by-two operator is +defined up to inversion. Hence +\begin{equation}\label{p4:sphere-four-pair-products} + t_i't_j'\in\{t_it_j,(t_it_j)^{-1}\}. +\end{equation} +Put $A=t_1t_2$, $B=t_1t_3$, and $D=t_1t_4$. +The Klein four permutations on the four indices give the +following triples of pair products: +\[ +\begin{array}{c|c} + \pi&(t_{\pi(1)}t_{\pi(2)}, + t_{\pi(1)}t_{\pi(3)},t_{\pi(1)}t_{\pi(4)})\\ \hline + 1&(A,B,D)\\ + (12)(34)&(A,B^{-1},D^{-1})\\ + (13)(24)&(A^{-1},B,D^{-1})\\ + (14)(23)&(A^{-1},B^{-1},D) +\end{array} +\] +Uniformly inverting the four entries supplies the other four +inversion patterns. Choose $\pi$ in this Klein four group and +$\epsilon\in\{1,-1\}$ realizing the three choices in +\eqref{p4:sphere-four-pair-products} involving index $1$. +Since $t_1^2=ABD$, recovery of the four entries from these +three products leaves only a common sign. Thus +\begin{equation}\label{p4:sphere-four-tuple} + t_i'=\delta\,t_{\pi(i)}^\epsilon\quad(1\le i\le4), + \qquad \delta\in\{1,-1\}. +\end{equation} +The choices $\delta,\epsilon,\pi$ are made once and are +unchanged at every scalar translate of this identity. + +This classifies only the projective twist data. It remains to use the +shared ideal to align pure and mixed behavior and to make one fixed choice +between the original model and its polarized dual for every scalar translate. + +Mixedness agrees between the two character spaces at each +translate. To justify this without any assumption about the +pure orientations, split the infinitesimal Hodge-circle action +into its central scalar part and its component in the shared +simple ideal. On a standard two-dimensional module, the +ideal component is zero precisely when the circle is scalar, +that is, precisely when the character space is pure. The +same ideal component acts on both equivalent modules, and +this observation remains valid after every scalar translation. + +We compare the two pure orientations. Permuting the four +multipliers has no effect on their signatures; uniformly +inverting them reverses the two pure signatures by +Lemma~\ref{p4:sphere-four-signatures}. Consider therefore +the additional common sign $\delta=-1$. At a fixed translate +write the four entries before this sign change as +$\exp(2\pi i v_i)$, $0c\), +and the Jacobian has rank \(c\). Conversely, a vanishing +\(c\)-minor gives a nonzero dependence on those columns. Taking +\(n\)th roots of its nonzero coefficients and setting the other +coordinates to zero gives a point with Jacobian rank below \(c\). +Here \(n\geq2\) makes the zero coordinates give zero Jacobian +columns. The Jacobian criterion proves the equivalence. + +Projection \(\ker A\to\C^S\), for \(|S|=m-c\), is an isomorphism +exactly when no nonzero vector of \(\ker A\) is supported on the +complementary \(c\) coordinates. This is the nonvanishing of that +complementary minor, proving the coordinate-generality assertion. +\end{proof} + +\begin{lemma}[Cohomology outside the middle degree]\label{lem:ambient} +Let \(X_A\) be a smooth diagonal complete intersection as in +Proposition~\ref{prop:smooth-locus}, of dimension \(d\geq1\), +and put \(h=c_1(\mathcal O_{X_A}(1))\). For \(0\leq k\leq2d\) +and \(k\ne d\), +\[ + H^k(X_A,\Q)= + \begin{cases} + \Q h^{k/2},&k\text{ even},\\ + 0,&k\text{ odd}. + \end{cases} +\] +In particular \(X_A\) is connected. +\end{lemma} +\begin{proof} +We first choose a smooth partial-intersection flag. Let \(Q\) be the +row space of \(A\), of dimension \(c\). For every \(j\leq c\) +and every \(j\)-element coordinate set \(I\), the projection +\(Q\to\C^I\) is surjective: a dependent set of \(j\) columns +could be extended to a dependent set of \(c\) columns, contrary +to Proposition~\ref{prop:smooth-locus}. In the complete flag +variety of \(Q\), the condition that this projection restricts +to an isomorphism on the \(j\)-plane is a nonempty open condition. +It is nonempty by choosing a complement of the projection kernel +and extending it to a flag. The flag variety is irreducible, so +the intersection of these finitely many nonempty opens is nonempty. +Choose such a flag \(0=Q_0\subset Q_1\subset\cdots\subset Q_c=Q\). + +Let \(Y_j\) be the diagonal zero locus of \(Q_j\), with +\(Y_0=\PP^{m-1}\). Every maximal minor of \(Q_j\) is nonzero, +so Proposition~\ref{prop:smooth-locus} makes \(Y_j\) smooth of +dimension \(m-j-1\). Choose an equation basis adapted to the +flag. Under the degree-\(n\) Veronese embedding of \(\PP^{m-1}\), +the next degree-\(n\) equation is a hyperplane, so \(Y_j\) is a +hyperplane section of \(Y_{j-1}\) in that embedding. + +The Lefschetz hyperplane theorem in +\cite[Corollary~7.3, p.~41]{Milnor} says that for a projective +variety \(V\) of dimension \(k\) and a hyperplane containing its +singular locus, the inclusion of the section induces homology +isomorphisms in degrees below \(k-1\). Here \(Y_{j-1}\) is +smooth, so its singular locus is empty. Applying the theorem +successively gives +\[ + H_i(X_A,\Z)\xrightarrow{\sim}H_i(\PP^{m-1},\Z)\quad(i0\); +vanishing of any \(h^r\), \(0\leq r\leq d\), would force +\(h^d=0\). Thus it spans the one-dimensional even cohomology +above the middle as well. +\end{proof} + +\begin{lemma}[Root-cover geometry]\label{lem:geometry} +For \(P\in\U_{d,m}\), \(X_P\) is a smooth projective complete +intersection of dimension \(d\), connected if \(d\geq1\). +The map \(q_P\) is finite and is the quotient by \(G_{m,n}\). +The coordinate hyperplanes on \(\PP(P)\) and their reduced inverse +images on \(X_P\) have simple normal crossings. For \(d=0\), +\(X_P\) is a \(G_{m,n}\)-torsor of reduced points. + +The open \(\U_{d,m}\) is nonempty and connected, and the \(X_P\) +form a smooth projective family over it with its phase action. +\end{lemma} +\begin{proof} +Any at most \(d+1\) coordinate restrictions to \(P\) are independent. +Thus at most \(d\) coordinates vanish at a point of \(\PP(P)\). +If \(a\) vanish, their ratios to a nonvanishing coordinate have +independent differentials and extend to relative local coordinates +\(t_1,\ldots,t_d\). After an \'{e}tale base change taking roots of +the remaining units, the cover has equations +\[ + z_1^n=t_1,\ldots,z_a^n=t_a +\] +and free coordinates \(t_{a+1},\ldots,t_d\). It is smooth, with +normal-crossing boundary \(z_1\cdots z_a=0\). The same calculation +on the universal projective bundle proves the relative assertions. +Proposition~\ref{prop:smooth-locus} gives the complete-intersection +description. + +Fibers of the coordinate-power map are exactly phase orbits, giving +the finite quotient. In dimension zero the base point has no zero +coordinate, so its inverse image is a free transitive phase set. +For \(d\geq1\), Lemma~\ref{lem:ambient} gives connectedness and +ambient cohomology outside the middle degree. + +For distinct \(a_1,\ldots,a_m\in\C\), the subspace +\(\{(f(a_1),\ldots,f(a_m)):\deg f\leq d\}\) has nonzero maximal +minors by the Vandermonde determinant. Thus \(\U_{d,m}\) is a +nonempty open in an irreducible Grassmannian, hence connected as a +complex manifold. The universal incidence equations are projective +over it; the local calculation proves smoothness and respects phases. +\end{proof} + +\subsection{Evaluation covers and character ranks} +Identify a character of \(G_{m,n}\) with +\[ + b=(b_1,\ldots,b_m)\in(\Z/n)^m,\quad \sum_i b_i=0,\quad + \chi_b([\zeta_i])=\prod_i\zeta_i^{b_i}. +\] +Subscripts \(b\) mean eigenspaces for pullback \(g^*\). Put +\(S(b)=\{i:b_i\ne0\}\), \(s(b)=|S(b)|\), and +\(W_{P,b}=H^d(X_P,\kk)_b\). Full support means \(s(b)=m\). + +In positive dimension we first use subspaces obtained by evaluating +polynomials at distinct points. Multiplication of linear polynomials +realizes the corresponding root cover as a finite quotient of a power +of one curve. The phase action and the +signs from permuting degree-one factors then identify its nontrivial +character cohomology with an exterior power. This is the graded +alternating-character mechanism of +\cite[Lemmas~1.1--1.2]{Schoen}; here we identify the quotient explicitly. + +\begin{lemma}[Evaluation quotient]\label{lem:evaluation} +Choose distinct \(a_1,\ldots,a_m\in\C\), \(m\geq3\), and put +\[ + P_j=\{(f(a_1),\ldots,f(a_m)):\deg f\leq j\} + \quad(1\leq j\leq m-2),\qquad C=X_{P_1}. +\] +Coordinate multiplication defines a finite surjective morphism +\[ + \mu_j:C^j\to X_{P_j},\qquad + (x^{(1)},\ldots,x^{(j)})\mapsto + [\prod_{\nu=1}^j x_i^{(\nu)}]_{i=1}^m, +\] +which identifies the target with +\[ + C^j\big/\left(\ker(G_{m,n}^j\xrightarrow{\prod}G_{m,n}) + \rtimes\mathfrak S_j\right). +\] +For \(b\ne0\), pullback identifies +\[ + H^j(X_{P_j},\kk)_b\simeq\bigwedge^j V_b,\qquad + V_b=H^1(C,\kk)_b, +\] +with the exterior power embedded by antisymmetrization. +\end{lemma} +\begin{proof} +Each curve point has at most one zero coordinate. Since \(j0\), and put \(N=m-2=d+d'\). +Choose the evaluation planes of Lemma~\ref{lem:evaluation}, and set +\[ + c_i=\prod_{h\ne i}(a_i-a_h)^{-1}. +\] +Lagrange interpolation gives +\[ + \sum_i c_i a_i^e=0\qquad(0\leq e\leq m-2), +\] +by comparing the coefficient of \(z^{m-1}\) in the interpolation +formula for \(z^e\). Products of polynomials of degrees at most +\(d,d'\) have degree at most \(m-2\); the identities and dimension +give +\[ + P_d^\perp=\operatorname{diag}(c_i)P_{d'},\qquad + \{(z_i):\sum_i z_i=0\}=\operatorname{diag}(c_i)P_N. +\] +Choose \(\xi_i^n=c_i\), and let +\(s_\xi([z_i])=[\xi_i z_i]\) be coordinate scaling. +It restricts to phase-equivariant isomorphisms +\[ + s_\xi:X_{P_{d'}}\xrightarrow{\sim}X_{P_d^\perp}, + \qquad + s_\xi:X_{P_N}\xrightarrow{\sim}F_n^N. +\] +The actual evaluation maps of Lemma~\ref{lem:evaluation} give +the commutative square +\[ +\begin{array}{ccc} + C^N=C^d\times C^{d'} + &\xrightarrow{\ \mu_d\times(s_\xi\circ\mu_{d'})\ }& + X_{P_d}\times X_{P_d^\perp}\\[3pt] + {\scriptstyle s_\xi\circ\mu_N}\Big\downarrow + &&\Big\downarrow{\scriptstyle f_{P_d}}\\[3pt] + F_n^N&\xrightarrow{\ \id\ }&F_n^N . +\end{array} +\] +Indeed, both composites send an ordered tuple +\((x^{(1)},\ldots,x^{(N)})\) to +\([\xi_i\prod_{\nu=1}^N x_i^{(\nu)}]_{i=1}^m\). +With \(V=H^1(C,\kk)_b\), pullback in this square and +Lemma~\ref{lem:evaluation} identify the three character spaces as +\[ + L_b\simeq\bigwedge^N V,\qquad + W_{P_d,b}\simeq\bigwedge^d V,\qquad + W_{P_d^\perp,b}\simeq\bigwedge^{d'}V. +\] +Full support gives \(\dim V=N\). +Use the unnormalized alternating inclusion +\[ + \iota_j(v_1\wedge\cdots\wedge v_j) + =\sum_{\sigma\in\mathfrak S_j}\operatorname{sgn}(\sigma) + v_{\sigma(1)}\otimes\cdots\otimes v_{\sigma(j)}. +\] +More precisely, Lemma~\ref{lem:evaluation} says that \(\mu_j^*\) +identifies its character space with \(\operatorname{im}\iota_j\). +The exact equality of coordinate-product maps shows that the +induced pullback from the Fermat line is the exterior coproduct +\[ + \bigwedge^N V\longrightarrow\bigwedge^d V\otimes\bigwedge^{d'}V: +\] +after \(\iota_d\otimes\iota_{d'}\) it is \(\iota_N\), and these +inclusions are injective. For a basis \(v_1,\ldots,v_N\), it is +\[ + v_1\wedge\cdots\wedge v_N\longmapsto + \sum_{\substack{I\subset\{1,\ldots,N\}\\ |I|=d}} + \operatorname{sgn}(I,I^c)\,v_I\otimes v_{I^c}. +\] +Each wedge uses increasing order. Complementary wedge bases are +paired bijectively with nonzero coefficients, proving full rank +\(\binom{N}{d}\). + +The map \(P\mapsto P^\perp\) is algebraic; the bilinear, not +Hermitian, orthogonal complement is essential here. The maps +\(f_P\) form a morphism from the smooth projective product family +over \(\U_{d,m}\) to the fixed Fermat variety. Cohomological +pullback is a morphism of local systems. In flat character frames +the tensor is constant, so its matrix rank is locally constant. +Connectedness extends the computed rank to every \(P\). + +If \(d=0\), choose a root point \(x\) above \(\PP(P)\). +Every \(x_i\ne0\), and multiplication by \(x\) identifies +\(X_Q\) with \(F_n^{m-2}\). The restriction of \(f_P\) to +\(\{x\}\times X_Q\) is this isomorphism. Its pullback on \(L_b\) +is nonzero. A nonzero eigenfunction on the finite torsor \(X_P\) +is nonzero at every point, so evaluation at \(x\) detects a nonzero +\((b,b)\) tensor. Both character ranks are one, hence it has +full rank. The case \(d'=0\) is symmetric, including \(m=2\) +when all the varieties are finite. +\end{proof} + +\subsection{A rational correspondence supplying cohomology} +The next objective is a forward source map to \(X_P\). For a +support \(S\) with \(|S|\geq d+2\), project to \(P_S=\pr_S P\), then contract the +perfect Gale tensor against opposite-character cohomology of +\(Y_S=X_{P_S^\perp}\). The source is \(F_n^{|S|-2}\times Y_S\). +The resulting graph cycle is rational, so the character calculation +after scalar extension will prove spanning for the cycle's action on +a whole rational source degree. + +For a smooth projective source \(T\), a correspondence +\(\Gamma\in\CH^{\dim T+j}(T\times X)_\Q\) acts by +\[ + \Gamma_*\alpha=(\pr_X)_*(\pr_T^*\alpha\smile[\Gamma]). +\] +It sends \(H^{k-2j}(T,\Q)(-j)\) to \(H^k(X,\Q)\) as a Hodge +map. Pullback by a morphism is represented by its transpose graph. + +\begin{proposition}[Gale cohomology supply]\label{prop:supply} +Let \(P\in\U_{d,m}\). For each \(S\subset\{1,\ldots,m\}\) +with \(s=|S|\geq d+2\), put +\[ + P_S=\pr_S P,\quad Q_S=P_S^\perp,\quad Y_S=X_{Q_S}, + \quad h_S=s-d-2. +\] +There is a rational algebraic correspondence from +\(F_n^{s-2}\times Y_S\) to \(X_P\), with degree shift +\(-2h_S\), whose image after scalar extension contains +\(W_{P,b}\) for every character with support \(S\). + +Together with hyperplane cycles from a point, these finitely many +maps span the full rational cohomology of \(X_P\). In the middle +degree the source maps may be taken on the entire groups +\[ + H^{d+2h_S}(F_n^{s-2}\times Y_S,\Q)(h_S). +\] +\end{proposition} +\begin{proof} +First target \(X=X_{P_S}\). Put \(h=h_S\), \(F=F_n^{s-2}\), +and \(Y=Y_S\). Thus \(\dim F=d+h\), \(\dim X=d\), and +\(\dim Y=h\). +The graph embedding +\[ + X\times Y\longrightarrow(F\times Y)\times X,\qquad + (x,y)\longmapsto(f_{P_S}(x,y),y,x) +\] +defines \(\Gamma_S\in\CH^{d+h}(F\times Y\times X)_\Q\). +The source dimension is \(d+2h\), so the shift is \(-2h\). +On a K\"unneth tensor its action is +\[ + \alpha\otimes\beta\longmapsto + (\pr_X)_*\bigl(f_{P_S}^*\alpha\smile\pr_Y^*\beta\bigr). +\] +For a character \(b\) with support \(S\), put \(b_S=b|_S\) and +\(L_{b_S}=H^{s-2}(F,\kk)_{b_S}\). +The invariant Poincar\'{e} pairing on \(Y\) pairs only opposite +characters and is perfect on each opposite pair, by its full +nondegeneracy and the direct character decomposition. This also +holds for the sum pairing on a finite torsor. It identifies +\(H^h(Y,\kk)_{-b_S}(h)\) with the dual of +\(H^h(Y,\kk)_{b_S}\). Theorem~\ref{thm:gale} therefore makes the +displayed graph action an isomorphism of Hodge-graded spaces +\[ + L_{b_S}\otimes H^h(Y,\kk)_{-b_S}(h) + \xrightarrow{\;\sim\;} H^d(X,\kk)_{b_S}. +\] +Composing with \(p_S^*\) fills \(W_{P,b}\). + +Both the graph cycle and the transpose graph for \(p_S^*\) have +rational coefficients. Apply them to the entire source degree, +without character projectors. After scalar extension their images +contain all the character pieces just described. Hyperplane cycles +from a point supply the invariant cohomology, including every degree +outside the middle. The sum of these finite rational maps is thus +surjective after extension to \(\kk\); its rational cokernel is +already zero. No algebraic K\"unneth projector is required. +\end{proof} + +\begin{lemma}[Sources in codimension at most two]\label{lem:one-curve} +Let \(X_P\) have dimension \(d\) and codimension +\(c=m-d-1\in\{1,2\}\), and write \(S=S(b)\) for the support of a +character \(b\). +\begin{enumerate}[label=\textup{(\roman*)}] +\item If \(c=1\), every nontrivial character \(b\) with \(W_{P,b}\ne0\) +has full support, and its dual source \(Y_S\) in +Proposition~\ref{prop:supply} is finite. +\item If \(c=2\), every nontrivial character \(b\) with \(W_{P,b}\ne0\) +has support of size \(m\) or \(m-1\). The full-support source is the one connected +curve \(C=X_{P^\perp}\). If \(S=\{1,\ldots,m\}\setminus\{i\}\), +then \(Y_S\) is the reduced \(i\)th boundary fiber of \(C\), with +the zero coordinate omitted, and consists of \(n^{m-2}\) points. +\end{enumerate} +\end{lemma} +\begin{proof} +For \(b\ne0\), put \(S=S(b)\) and \(s=|S|\). If \(W_{P,b}\ne0\), +then \(s\geq d+2\), and \(\dim Y_S=s-d-2\). If \(c=1\), \(m=d+2\), so \(s=m\) is the +only possibility and the source dimension is zero. If \(c=2\), +\(m=d+3\), so \(s=m\) gives dimension one and \(s=m-1\) gives +dimension zero. The full-support source is \(X_{P^\perp}\), +connected by Lemma~\ref{lem:geometry}. + +For a missing-one support, zero extension identifies +\[ + (\pr_S P)^\perp=\{q|_S:q\in P^\perp,\ q_i=0\}. +\] +This is the coordinate-general line cut from the dual two-plane +by its \(i\)th coordinate hyperplane. Its root torsor is precisely +the reduced fiber \(\{y_i=0\}\) on \(C\) after forgetting that +coordinate. The phase group has size \(n^{m-2}\). Distinct +boundary fibers are disjoint because a root-curve point has at +most one zero coordinate. +\end{proof} + +Finite dual sources require only point classes. The only possible +contributing positive-dimensional dual source is therefore the +full-support curve in codimension two. Its Fermat factor remains +in the cohomology supply. + +\section{The full branch-configuration family}\label{sec:family} +For the curve of Lemma~\ref{lem:one-curve}, we compare every marked +cover fiber with transport in its normalized root family. This will +verify that its tensor-generic parameters belong to +$\mathcal T_\phi^{\mathrm{Hg}}$, as required by +Theorem~\ref{p4:abelian-covers}. +The normalized diagonal curves are the standard generalized +Fermat models of \cite{GDL,HKLP}; the relative roots and based +marking needed here are specified below. + +\subsection{The coefficient space as a product} +Let \(m\geq3\). For a frame \(A=(a_1,\ldots,a_m)\) of +\(Q\in\D_{2,m}\), put \(\Delta_{ij}=\det(a_i,a_j)\). +The coordinate form on \(\PP(Q)\) is +\(\ell_i(s,t)=a_{1i}s+a_{2i}t\), with zero +\(p_i=[-a_{2i}:a_{1i}]\). Let +\[ + M_m=\{(z_4,\ldots,z_m)\in(\A^1\setminus\{0,1\})^{m-3}: + z_i\ne z_j\}, +\] +with \(M_3\) a point. Normalizing the first three labelled points +to \(\infty=[1:0]\), \(0=[0:1]\), \(1=[1:1]\) identifies +\(M_m\) with \(M_{0,m}\). + +\begin{proposition}[The branch map]\label{prop:parameter} +The normalized branch configuration is the regular morphism +\[ + \lambda:\D_{2,m}\to M_m,\qquad + z_i=\frac{\Delta_{2i}\Delta_{13}}{\Delta_{1i}\Delta_{23}} + \quad(i\geq4). +\] +There is a global product isomorphism +\(\D_{2,m}\simeq M_m\times(\Gm)^{m-1}\) under which \(\lambda\) +is projection. It is smooth and surjective, and the quotient by +the effective coefficient torus \((\Gm)^m/\Gm\) is \(M_m\). +\end{proposition} +\begin{proof} +The ratios are row-basis independent and their denominators are +units. The Pl\"ucker relations give +\[ + z_i-1=\frac{\Delta_{12}\Delta_{3i}}{\Delta_{1i}\Delta_{23}}, + \qquad + z_i-z_j=-\frac{\Delta_{12}\Delta_{13}\Delta_{ij}} + {\Delta_{23}\Delta_{1i}\Delta_{1j}}, +\] +so the values lie in \(M_m\). + +Let \(A_0(z)\) have columns +\[ + (0,1)^t,\ (1,0)^t,\ (1,-1)^t,\ + (1,-z_4)^t,\ldots,(1,-z_m)^t. +\] +Set \(t_1=1\) and +\[ + t_2=\frac{\Delta_{23}}{\Delta_{13}},\quad + t_3=\frac{\Delta_{23}}{\Delta_{12}},\quad + t_i=\frac{\Delta_{1i}\Delta_{23}}{\Delta_{12}\Delta_{13}} + \quad(i\geq4). +\] +All are nonzero regular functions of \(Q\). With \(B=(a_1,a_2)\), +left multiplication by +\[ + H=\begin{pmatrix}0&t_2\\1&0\end{pmatrix}B^{-1} +\] +gives, by Cramer's rule, +\[ + Ha_1=(0,1)^t,\quad Ha_2=(t_2,0)^t,\quad + Ha_3=(t_3,-t_3)^t,\quad Ha_i=(t_i,-t_i z_i)^t . +\] +Hence \(Q=\operatorname{row}(A_0(z)\operatorname{diag}(t_i))\). +Conversely, substituting this form into the ratios recovers +\(z,t_2,\ldots,t_m\). These are inverse regular maps for the +product isomorphism. The effective coefficient torus acts freely +and transitively on the second factor, giving the quotient claim. +\end{proof} + +\begin{remark} +On framed coefficient matrices the map to \(\Conf_m(\PP^1)\) +is a principal \((\Gm)^m\)-bundle: fixing the zero points leaves +one independent nonzero scalar for each coordinate covector. +A row change \(A\mapsto gA\) acts on the points by \(g^{-t}\). +Thus the framed coefficient space surjects onto +\(\Conf_m(\PP^1)\). After row changes are removed, the quotient +\(\D_{2,m}/((\Gm)^m/\Gm)\), not \(\D_{2,m}\) itself, is \(M_{0,m}\). +\end{remark} + +\subsection{Coordinate roots and the fixed cover} +Put \(Q_0(z)=\operatorname{row}A_0(z)\) and +\(P_0(z)=Q_0(z)^\perp\). The normal form gives +\[ + Q(t,z)=\operatorname{diag}(t_i)Q_0(z),\qquad + P(t,z)=\operatorname{diag}(t_i^{-1})P_0(z). +\] +The normalized dual curves form a smooth projective family +\(\cY_0\to M_m\) by Lemma~\ref{lem:geometry}. +Let \(\iota_z:\PP^1\xrightarrow{\sim}\PP(Q_0(z))\) be the +projective isomorphism induced by the row frame \(A_0(z)\). +Write +\[ + q_z:=\iota_z^{-1}\circ q_{Q_0(z)}:X_{Q_0(z)}\longrightarrow\PP^1, + \qquad D_z:=\{\infty,0,1,z_4,\ldots,z_m\}. +\] +The points of \(D_z\) retain this order and are regarded as a +reduced divisor. + +\begin{proposition}[The normalized root family and its fixed deck datum]\label{prop:cover-family} +The map +\[ + \rho:\widetilde\D_{2,m,n}:=M_m\times(\Gm)^{m-1}\to\D_{2,m}, + \qquad (z,h_2,\ldots,h_m)\mapsto(z,h_2^n,\ldots,h_m^n) +\] +is a connected finite \'{e}tale cover of degree \(n^{m-1}\). +Set \(h_1=1\). Over it, the algebraic maps +\([y_i]\mapsto[h_i y_i]\) and \([x_i]\mapsto[h_i^{-1}x_i]\) +identify the normalized dual and original root families with +the families for \(Q(t,z)\) and \(P(t,z)\), respectively. +They commute with \(G_{m,n}\). + +Every \(q_z\) is a connected \(G_{m,n}\)-cover of \(\PP^1\), +with ordered branch points +\((\infty,0,1,z_4,\ldots,z_m)\). Identify +\[ + G_{m,n}\simeq(\Z/n)^m/\langle(1,\ldots,1)\rangle +\] +using \(\zeta_n=\exp(2\pi i/n)\). Its ordered positive local +monodromies are the images \((\bar e_1,\ldots,\bar e_m)\) of +the standard basis. The family runs over all ordered branch +configurations with this fixed deck datum. +\end{proposition} +\begin{proof} +The map is the \(n\)-power map on a torus times the identity. +It is finite locally free of degree \(n^{m-1}\) and \'{e}tale +because \(n h_i^{n-1}\) is a unit. Its source is irreducible. +The coordinate scalings satisfy the root equations by the +preceding formulas for \(P,Q\); their inverses and phase +equivariance are immediate. + +On the normalized base \([s:t]\), the coordinate forms are +\[ + t,\ s,\ s-t,\ s-z_4t,\ldots,s-z_m t. +\] +Their ordered zeros are the stated branch points. On \(t\ne0\), +put \(v=s/t\), \(w_i=y_i/y_1\). The function field is +\[ + w_2^n=v,\qquad w_3^n=v-1,\qquad w_i^n=v-z_i\quad(i\geq4). +\] +Valuations at the distinct finite points show that these \(m-1\) +functions are independent in \(\C(v)^*/\C(v)^{*n}\). +Kummer theory gives degree \(n^{m-1}\). Equivalently, adjoin +the roots successively and use an Eisenstein test at the new +branch point, where the earlier functions are units with local +roots. Thus the cover is connected and its phase group is +its full deck group. + +At a finite point indexed by \(i\geq2\), a positive meridian +multiplies \(w_i\) by \(\zeta_n\) and fixes the other local roots, +giving \(\bar e_i\). At infinity all right sides have simple +poles, so a meridian multiplies every \(w_i\), \(i\geq2\), by +\(\zeta_n^{-1}\). This is +\(\bar e_1=-\sum_{i\geq2}\bar e_i\). The entries have order +\(n\), sum to zero, and generate the group. + +For \(*\in\PP^1\setminus D_z\), positive meridians generate the +punctured-sphere fundamental group with their product as the +single relation. The displayed +epimorphism is precisely abelianization modulo \(n\): +\[ + \pi_1(\PP^1\setminus D_z,*)\to H_1(\PP^1\setminus D_z,\Z/n) + \simeq(\Z/n)^m/\langle(1,\ldots,1)\rangle . +\] +A pure orientation-preserving mapping class conjugates each positive +peripheral meridian, so it fixes this epimorphism. The standard +classification of connected covers by epimorphisms shows that the +ordered tuple determines the single fixed cover type here. For +each complex structure on the pointed base, pullback charts off +the punctures and the local ramification power charts give the +unique complex structure on its compact covering surface. The +root equations realize it for every configuration in \(M_m\). +\end{proof} + +The coefficient normalization and the coordinate-root cover have +now realized every normalized unmarked cover with its fixed deck +datum. A based topological marking is additional data: it retains +an isotopy class relative to the labels. We will reach each such +marking by a configuration path with a transported lift. +The following sphere-isotopy fact provides the required paths. + +\begin{lemma}[Sphere isotopy]\label{lem:sphere-isotopy} +Every orientation-preserving self-homeomorphism of \(S^2\) is +isotopic to the identity through self-homeomorphisms, with no +marked points required to stay fixed during the isotopy. +\end{lemma} +\begin{proof} +We use the planar Schoenflies theorem in its annulus form: +the region between two nested Jordan curves is an annulus. +It gives the following disk extension fact. If \(D_0,D_1\) +are closed disks in the interior of a closed disk \(U\), then +an orientation-preserving homeomorphism \(D_0\to D_1\) extends +to a homeomorphism of \(U\) which is the identity on \(\partial U\). +Indeed, the two complementary regions in \(U\) are annuli. +In annulus coordinates, the prescribed maps on their two boundary +circles extend across the annulus: orientation-preserving circle +homeomorphisms are isotopic, as is seen by taking increasing lifts +to \(\mathbb R\) and linearly interpolating the lifts. Gluing this annulus +map to the given disk map proves the extension fact. + +Let \(g\) be the given sphere homeomorphism. Choose \(p\in S^2\), +a point \(q\) different from \(p\) and \(g(p)\), and a small closed disk \(D\) +about \(p\) for which both \(D\) and \(g(D)\) avoid \(q\). +Their compact union lies in the interior of a closed disk +\(U\subset S^2\setminus\{q\}\). The disk extension fact gives +a homeomorphism \(f\) of \(U\), fixed on its boundary, which +agrees with \(g\) on \(D\). Extend \(f\) by the identity outside +\(U\). The Alexander trick isotopes \(f\) to the identity, +supported in \(U\): in unit-disk coordinates a boundary-fixed +map \(F\) is deformed by +\[ + F_t(x)= + \begin{cases} + tF(x/t),&|x|\leq t,\\ + x,&|x|\geq t, + \end{cases} + \qquad F_0=\id,\quad 00\), enlarged to a multiple +of the Cartier index fixed over \(k_0\), for which the Cartier +line bundle \(M=\OO_{X_{k_0}}(m(K_{X_{k_0}}+B_{k_0}))\) becomes +globally generated over \(\C\). Proper flat base change for sections +identifies +\[ + H^0(X_{k_0},M)\otimes_{k_0}\C + = H^0(X_{\C},M_{\C}). +\] +The cokernel of the evaluation map for \(M\) therefore becomes zero +after the faithfully flat extension \(k_0\subset\C\), and is already +zero over \(k_0\). Base change from \(k_0\) to \(k\) preserves this +surjectivity. The same integer \(m\) proves the required +semiampleness over \(k\). +\end{proof} + +Together with Proposition~\ref{proj:prop:field-descent}, the complex proof +establishes Theorem~\ref{proj:thm:main} in its stated generality. diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_exclusions.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_exclusions.tex new file mode 100644 index 0000000000000000000000000000000000000000..752f78b5d1399204b65297226453d148037cc01b --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_exclusions.tex @@ -0,0 +1,809 @@ +\section{Geometric exclusions for a nonvanishing counterexample} +\label{proj:sec:exclusions} + +Throughout this section we assume the lower-dimensional good-model +hypothesis of Assumption~\ref{proj:mmp:lower-models}. We suppose, towards a +contradiction, that \(X\) is smooth projective of dimension \(n>0\) and +\begin{equation}\label{proj:ex:counterexample} + K_X\ \text{is pseudo-effective}, + \qquad \kappa(X,K_X)=-\infty. +\end{equation} +These properties persist on smooth projective birational models. All +varieties in this section are complex. Numerical dimension for a +pseudo-effective divisor means Nakayama's numerical dimension +\(\kappa_\sigma\); for a nef divisor it agrees with the intersection +definition used in Theorem~\ref{proj:thm:signed}. + +\subsection{The Albanese reduction and algebraic webs} + +\begin{lemma}\label{proj:ex:irregularity} +Every smooth projective birational model of \(X\) has irregularity zero. +Consequently, on such a model, or on a projective \(\Q\)-factorial +terminal birational model, numerical equivalence of rational divisors +implies their \(\Q\)-linear equivalence. +\end{lemma} +\begin{proof} +If \(q(X)>0\), resolve the Stein factorization of the Albanese map to +obtain a morphism \(f:W\to B\) with connected fibers, with \(W,B\) +smooth projective and \(\dim B>0\). The map from \(B\) to a subvariety +of \(\Alb(X)\) is generically finite. Wedges of invariant one-forms +on the abelian variety therefore give a nonzero section of \(K_B\): +at the generic point, choose \(\dim B\) independent pulled-back +one-forms. Thus \(\kappa(B,K_B)\geq0\). + +For a very general smooth fiber \(F\), the restriction of the +pseudo-effective class \(K_W\) is pseudo-effective. For example, restrict +a positive current representing it to almost every fiber, or use +effective approximations with arbitrarily small ample error. +Adjunction identifies this restriction with \(K_F\). If \(F\) has +positive dimension, the induction hypothesis gives +\(\kappa(F,K_F)\geq0\); for a point the same assertion holds by +convention. Applying Assumption~\ref{proj:asm:iitaka} with both boundaries +empty gives \(\kappa(W,K_W)\geq0\), contradicting +\eqref{proj:ex:counterexample}. + +This is the only use of Assumption~\ref{proj:asm:iitaka} in the proof. +Irregularity is a smooth birational invariant. Finally, when +\(\Pic^0=0\), a numerically trivial line bundle is torsion, since the +group of numerically trivial line bundles modulo \(\Pic^0\) is +finite. Clear denominators for rational divisors. On a terminal +\(\Q\)-factorial model, pull back to a smooth resolution and then +descend the rational linear equivalence. +\end{proof} + +We use covering families of proper subvarieties through very general +points. They can be parameterized in countably many algebraic +families, using Hilbert schemes followed by resolution and +stratification. After shrinking a parameter space, the domains form +a smooth projective family with integral fibers and have a dominant +evaluation map. If the fiber maps are generically finite onto their +images, general ample cuts of the parameter space make the total +evaluation generically finite and still dominant. We always resolve +and compactify this evaluation when applying ramification. +Invariance of plurigenera for smooth projective families +\cite[Theorem~1]{Proj-Paun2007} permits the same construction for the +Iitaka fibers of general members: choose a divisible pluricanonical +system on the general member, spread it by base change, and resolve +its relative rational map. + +\begin{lemma}[Algebraic web quotient]\label{proj:ex:web} +Let a smooth projective variety be dominated generically finitely by +the total space of a family with smooth integral projective general +fibers. On a dense regular open, form the distribution generated by +the tangent spaces of the fiber images, taking spans, saturation, +and Lie brackets. Its general leaves are dense opens of algebraic +subvarieties. Their closures are the general fibers of a rational +map, which has connected general fiber after Stein factorization. +\end{lemma} +\begin{proof} +Shrink to an open \(U\) where the evaluation has finitely many etale +sheets, the parameter map is smooth, and the generated involutive +distribution \(\mathcal F\) has constant rank. Its construction is +algebraic: spans and brackets stabilize at the generic point after +finitely many operations, and descend from the etale sheets. The +nonempty open parts of the integral parameter fibers are connected. +We use only chains of fiber-image steps lying in \(U\). + +For \(x\in U\), endpoints of chains of at most \(k\) steps form a +constructible set, by the algebraic fiber-product construction and +Chevalley's theorem. Every endpoint lies in the analytic leaf +through \(x\). A locally closed smooth variety contained in an +analytic leaf has dimension at most \(\rk\mathcal F\). Indeed, in a +Frobenius chart the leaf meets at most countably many plaques: use +finite plaque chains in a countable foliation atlas. The transverse +coordinate map on any connected smooth piece then has countable +image and is constant. + +There is therefore a maximal dimension among the closures of all +such endpoint loci; it is attained for some finite \(k\). The loci +are nested because we allow at most \(k\) steps, including the +identity step. Choose an irreducible component \(V\) of maximal +dimension and a dense open \(O\subset V\) of reachable points. +For each etale sheet, restrict its fiber-equivalence relation to +first coordinate in \(O\), and take the component through the +diagonal section. Its second-image closure contains \(O\), hence +\(V\), while its second image consists of endpoints reachable +in at most \(k+1\) steps. Maximality forces that closure to +equal \(V\). At a general +diagonal point, smoothness of the parameter map identifies its +vertical tangent with the corresponding web tangent. Every web +tangent is consequently tangent to \(V\), and so is every bracket. Hence +\(\dim V\geq\rk\mathcal F\), while the reverse inequality was proved +above. A plaque is thus open in \(V\). The equations of \(V\), +pulled back to the connected immersed leaf, vanish on a nonempty +open and hence on the entire leaf. Its closure is exactly \(V\). + +These rank-dimensional invariant subvarieties have countably many +Hilbert or Chow parameter spaces. Tangency on the regular locus is +an algebraic condition after stratification, so one such family +dominates. An invariant irreducible variety meeting \(U\) contains +the leaf through any of its points in \(U\): the tangent vector +fields preserve its reduced ideal, first on its smooth locus and +then everywhere by closure. A rank-dimensional leaf closure is +therefore unique through a general point. Assigning that closure +gives the desired rational map. Resolve its graph and take the +Stein factorization. +\end{proof} + +For positive closed \((1,1)\)-currents we shall use this quotient in +the following way. If a current vanishes on almost every parameter +fiber away from a fixed removed divisor, it annihilates the +corresponding fiber tangents on a dense open. In submersion +coordinates, choose locally integrable plurisubharmonic potentials. +Fubini's theorem makes the pure fiber Hessian zero as a +distribution; positivity then makes the mixed coefficients in +fiber directions zero as well. A generically etale evaluation +transfers this assertion to the target. Annihilation passes to +brackets by the identities +\[ + \mathcal L_v T=d(\iota_vT)+\iota_v(dT),\qquad + \iota_{[v,w]}T=\mathcal L_v(\iota_wT)-\iota_w(\mathcal L_vT). +\] +Pullbacks by dominant morphisms and restrictions to almost every +smooth parameter fiber are defined by the same local potentials. + +\subsection{The general-type exclusion} + +\begin{proposition}\label{proj:prop:general-type} +Every positive-dimensional proper subvariety through a very general +point of \(X\) is of general type on resolution. The assertion holds +also on every projective birational model. +\end{proposition} +\begin{proof} +Otherwise take a covering family of nongeneral-type subvarieties, +with smooth domains \(V\), and slice its parameters as above. +Restricting the ramification formula of its generically finite +total evaluation shows that \(K_V\) dominates the restriction of +the pulled-back \(K_X\) by an effective divisor. Thus \(K_V\) is +pseudo-effective. The induction hypothesis gives a good minimal +model of \(V\), so \(\kappa(V)\geq0\). Since \(V\) is not of general +type, its general Iitaka fibers have positive dimension and +Kodaira dimension zero. Spreading these fibers gives another +covering family with smooth domains \(G\), of dimension less than +\(n\), and \(\kappa(G)=0\). Each \(G\) has a good minimal model and +\(\kappa_\sigma(K_G)=0\). + +Fix a positive current \(T\) representing \(K_X\). After slicing and +resolving the total evaluation of the \(G\)'s, its restriction to +almost every parameter fiber, plus the effective restricted +ramification divisor, is a positive current in \(K_G\). +Every positive current in that class is supported on the fixed +canonical divisor of \(G\). To see this, take a common resolution +with its good minimal model. The latter has torsion canonical +divisor, so the canonical divisor upstairs is effective exceptional. +Intersection with a pullback of an ample class to the power +\(\dim G-1\) forces any such positive current to vanish off the +exceptional locus. The support theorem makes it divisorial, and +independence of exceptional divisor classes, by negativity, fixes +its coefficients. Pushing down proves the assertion on \(G\). +The excluded support is algebraic in the family: it is the fixed +divisor of a sufficiently divisible relative pluricanonical +system after shrinking the parameter space. + +It follows that \(T\) annihilates the web distribution of the +\(G\)'s on a dense open. If that distribution has full rank, \(T\) +is supported on a proper algebraic set. The support theorem for +positive closed \((1,1)\)-currents expresses it as a finite +nonnegative real combination of prime divisors +\cite{Proj-Siu1974,Proj-Demailly2012}. Its rational cohomology class then has +a nonnegative rational representative: solve the finite rational +linear system for the coefficients on the same face of the +nonnegative orthant. Lemma~\ref{proj:ex:irregularity} converts numerical +effectivity to \(\Q\)-linear effectivity, a contradiction. + +Otherwise Lemma~\ref{proj:ex:web} gives a rational quotient with general +smooth fiber \(F\) on a smooth resolved graph, where +\(0<\dim F0\). +Consequently, if \(\alpha\neq0\) is a supporting functional of the +pseudo-effective cone with \(\alpha(K_Y)=0\), then +\(\alpha(P)>0\). +\end{corollary} +\begin{proof} +Resolve a moving subsystem of a multiple of \(P\). If its map is +generically finite, \(P\) is big and the assertion follows from +pseudoeffectivity of \(K_Y\). Otherwise its general fiber is a +proper positive-dimensional subvariety through very general +points and is of general type by Proposition~\ref{proj:prop:general-type}. +The canonical divisor of the smooth resolution is relatively big, +so adding a sufficiently large ample pullback from the image makes +it big. Since that pullback is bounded by a multiple of the +resolved moving subsystem, pushforward gives \(K_Y+aP\) big for +some \(a>0\). Convexity with the pseudo-effective \(K_Y\), and then +addition of the pseudo-effective \(P\), gives the assertion for +every \(c>0\). A nonzero nonnegative functional on a closed convex +cone is strictly positive on its interior. Applying it to +\(K_Y+cP\) proves the last assertion. +\end{proof} + +\subsection{Valuations and positive currents} + +For a positive closed \((1,1)\)-current \(T\) on a smooth projective +variety \(V\), let \(\nu_E(T)\) denote the generic Lelong number of +its pullback at a divisorial valuation \(E\). The normalization is +such that a reduced smooth divisor has generic number one. We +write \(A_V(E)=a(E;V,0)\) for log discrepancy. + +\begin{lemma}\label{proj:ex:valuation-acc} +For a fixed \(T\) and a fixed \(M\), the set +\[ + \{\nu_E(T): A_V(E)\leq M\} +\] +satisfies the ascending chain condition. +\end{lemma} +\begin{proof} +We induct on the integer part of \(M\); discrepancies over a +smooth variety are positive integers. Suppose that a strictly +increasing sequence exists, and discard initial terms so its +members exceed a fixed positive number \(c\). +Skoda integrability and change of variables give +\begin{equation}\label{proj:ex:skoda-valuation} + \nu_E(T)\leq A_V(E)\nu_x(T) +\end{equation} +at a general point \(x\) of the center. Indeed every exponent +smaller than \(1/\nu_x(T)\) is locally integrable, whereas +integrability after pullback imposes the corresponding +discrepancy bound. Hence all centers lie in the fixed proper Siu +locus \(\{\nu_x(T)\geq c/M\}\), which is algebraic by Siu +analyticity and projectivity \cite{Proj-Siu1974}. + +If, after passage to a subsequence, the centers lie in a fixed +codimension-at-least-two subvariety, principalize its ideal. +All lifted centers lie in the exceptional locus, where the +relative canonical divisor has positive integral order. +The discrepancy bound for the new smooth ambient space has +therefore decreased by at least one. Pull back \(T\) and apply +induction. + +Otherwise the centers lie in a fixed prime divisor \(D\) of the +Siu locus. Write \(T=c_D[D]+T'\) with \(T'\) positive and with +zero generic Lelong number along \(D\). The integers +\(\ord_E(D)\) are bounded: the fixed effective divisor \(D\) has +positive log canonical threshold, and +\(\operatorname{lct}(D)\ord_E(D)\leq A_V(E)\). +Pass to a constant order. The residual numbers \(\nu_E(T')\) +are still strictly increasing, and after discarding a term have +a positive lower bound. Equation~\eqref{proj:ex:skoda-valuation} +places their centers in a fixed Siu locus of \(T'\), which does +not contain \(D\). Their intersection with \(D\) has codimension +at least two, so the preceding case applies. +\end{proof} + +We also record the multiplier-ideal approximation used below +\cite[Theorems~5.11, 6.27, and 14.2]{Proj-Demailly2012}. On a smooth projective variety, if \(\{T\}\) +is a real algebraic class, one can choose integral line bundles +\(L_k\) such that \(c_1(L_k)-k\{T\}\) stays in a bounded, +uniformly sufficiently ample set and +\(L_k\otimes\mathcal J(kT)\) is globally generated. Round the +coefficients of \(k\{T\}\) in a fixed integral basis and add a +fixed sufficiently positive integral class. Nadel vanishing and +Castelnuovo--Mumford regularity give generation. For every +divisorial valuation, +\begin{equation}\label{proj:ex:multiplier-order} + \ord_E\mathcal J(kT)\leq k\nu_E(T). +\end{equation} +The local Bergman weight is bounded below by the original weight +up to a constant; this inequality persists after pullback and +gives \eqref{proj:ex:multiplier-order}. These are statements for a +fixed current, not uniform assertions over all currents. + +\begin{proposition}\label{proj:prop:no-pullback} +Let \(Y\) be a fixed projective \(\Q\)-factorial terminal +birational model of \(X\), with \(K_Y\) nonbig. A positive current +in the pullback class of \(K_Y\) on a smooth resolution cannot, +on a dense regular Zariski open, annihilate the tangent spaces +of the general fibers of a rational fibration of positive +relative dimension. +\end{proposition} +\begin{proof} +Suppose otherwise, and choose a connected-fiber quotient of +minimal base dimension \(b\). If \(b=0\), the current vanishes on +a dense open; the divisorial-current argument in +Proposition~\ref{proj:prop:general-type} contradicts +\eqref{proj:ex:counterexample}. Thus \(00\), constant on \(B^0\), by closedness. +The projection formula therefore gives +\[ + c^{-1}h_*(T'\wedge\omega^d)|_{B^0}=S^0. +\] +The left side defines a global positive closed extension. +Its class is real algebraic, since \(\{T'\}\) is the +algebraic class \(p^*K_Y\) minus real divisor classes and +algebraic intersection and pushforward preserve such +classes. Remove its divisorial parts along +\(B\setminus B^0\), and call the result \(S\). +On a dense open \(T=h^*S\). Their difference is again closed +of order zero, so the same support theorem leaves only a +signed divisor sum. It has nonnegative coefficients at every +prime dominating a base prime. For the latter assertion, the +generic local map is a transverse power map times a +submersion. A current with zero generic Lelong number along +the base prime has zero generic number at such an upstairs +prime: local target balls of a radius equal to a fixed power +of the source radius give the usual Lelong comparison. +The only possible negative coefficients lie over base +codimension at least two and are exceptional over \(Y\). +It follows that +\begin{equation}\label{proj:ex:descent-domination} + K_Y-T_B\{S\}\quad\text{is pseudo-effective}. +\end{equation} +Horizontal parts subtracted above merely contribute effective +divisors to this difference. + +\smallskip +\noindent\emph{A negative canonical direction on the base.} +Choose a nonzero supporting functional \(\alpha\) of the +pseudo-effective cone at \(K_Y\), and put +\(\eta=T_B^*\alpha\). The corresponding functionals \(\eta'\) +on higher smooth base models are movable classes by +pseudo-effective/movable duality \cite[Theorem~0.2]{BDPP}. +They annihilate base-exceptional divisors. Equation +\eqref{proj:ex:descent-domination} gives \(\eta\cdot\{S\}=0\). + +Only finitely many prime divisors on \(B\) have positive +divisorial Lelong coefficient for \(S\). Otherwise their +nonzero strict pullbacks are effective divisors on \(Y\) +killed by \(\alpha\), with pairwise disjoint prime supports. +The supports are disjoint because a nonexceptional prime of +\(Y\) cannot map into the intersection of two base primes. +Only finitely many base primes have zero strict pullback, +since their total pullbacks are supported in the finite +exceptional locus of \(p\). In the finite-dimensional rational +space of divisor classes, infinitely many remaining strict +pullbacks have a rational relation. Its positive and negative +sides are nonzero effective divisors with disjoint support; +Lemma~\ref{proj:ex:irregularity} makes the relation +\(\Q\)-linear. They define a moving pencil killed by +\(\alpha\), contradicting Corollary~\ref{proj:ex:supporting}. + +We claim that +\begin{equation}\label{proj:ex:negative-base} + K_B\cdot\eta<0. +\end{equation} +The smooth general fiber \(F\) of \(h\) is of general type by +Proposition~\ref{proj:prop:general-type}. The relative-positivity +theorem of Kov\'acs--Patakfalvi +\cite[Theorem~9.9]{Proj-KovacsPatakfalvi2017} applies to a log +canonical fiber space with smooth base, SNC total pair, and +log-general-type geometric generic fiber; for a rational base +divisor \(M\) with \(\kappa(M)\geq0\), it gives relative +subadditivity with the term \(h^*M\). Here both spaces are +smooth projective, the boundary is zero, and we take \(M=0\). +Invariance of plurigenera on the smooth locus identifies the +generic-fiber Kodaira dimension with that of \(F\). Thus +\begin{equation}\label{proj:ex:relative-positive} + \kappa(W,K_W-h^*K_B)\geq \kappa(F,K_F)=n-b>0. +\end{equation} +This is an established general-type-fiber theorem, not another +use or strengthening of Assumption~\ref{proj:asm:iitaka}. +Choose compatible canonical divisors and set +\(P=K_Y-T_B(K_B)=p_*(K_W-h^*K_B)\). +For every sufficiently divisible \(m\), pushing forward an +effective divisor +\(\operatorname{div}_W(\varphi)+m(K_W-h^*K_B)\) +gives +\(\operatorname{div}_Y(\varphi)+mP\geq0\). +The resulting injection of sections preserves their ratios, +so \(\kappa(Y,P)\geq1\). Corollary~\ref{proj:ex:supporting} now gives +\(0<\alpha(P)=-K_B\cdot\eta\), proving +\eqref{proj:ex:negative-base}. + +\smallskip +\noindent\emph{Rational curves and an exact zero gap.} +Apply the multiplier approximation to \(S\) on \(B\), and +principalize \(\mathcal J(kS)\) by \(r_k:B_k\to B\). +If \(F_k\) is its divisor, the class +\[ + P_k=\frac{r_k^*L_k-F_k}{k} +\] +is nef. Put \(\eta_k=T_{B_k}^*\alpha\). Since it kills +exceptional divisors and \(L_k-k\{S\}\) stays bounded, +\[ + 0\leq P_k\cdot\eta_k=O(k^{-1}),\qquad + K_{B_k}\cdot\eta_k=K_B\cdot\eta<0. +\] +For a fixed ample \(H\) on \(B\), polarize by +\(P_k+k^{-1}r_k^*H\) plus a sufficiently small rational ample +class on \(B_k\). Approximate \(\eta_k\) by positive sums of +covering-curve classes. Discard terms with nonnegative +canonical degree. Some remaining covering curve has the ratio +of polarization degree to anticanonical degree \(O(k^{-1})\). +Quantitative bend-and-break +\cite[Theorem~5]{Proj-MiyaokaMori1986} supplies rational curves +through its general points with polarization degree at most +\(2\dim B\) times that ratio. Parameterization and +uncountability give a covering family of rational curves +\(R_k\) satisfying +\begin{equation}\label{proj:ex:small-curves} + P_k\cdot R_k=O(k^{-1}),\qquad + H\cdot r_{k*}R_k=O(1). +\end{equation} +The general parametrized member is free in characteristic +zero. Consequently \(K_{B_k}\cdot R_k\leq-2\), and +\begin{equation}\label{proj:ex:contact-bound} + 0\leq K_{B_k/B}\cdot R_k + =K_{B_k}\cdot R_k-K_B\cdot r_{k*}R_k=O(1). +\end{equation} +Here the upper bound follows from the fixed ample-degree +bound in \eqref{proj:ex:small-curves}. + +Write \(\bar R_k=r_{k*}R_k\). Every positive contact with an +exceptional prime contributes a positive integer discrepancy +times a positive integer contact degree to +\eqref{proj:ex:contact-bound}. Thus the number of such contacts, +their discrepancies, and their contact degrees are uniformly +bounded. Contacts with the finitely many strict transforms +of divisorial Lelong components of \(S\) are bounded by their +fixed degrees against \(\bar R_k\). Subtracting these +divisorial parts from \(r_k^*S\) leaves a positive current. +Using \eqref{proj:ex:multiplier-order} and +\eqref{proj:ex:small-curves} gives +\begin{equation}\label{proj:ex:zero-gap} + \begin{split} + 0&\leq \{S\}\cdot\bar R_k + -\sum_E\nu_E(S)\,E\cdot R_k\\ + &\leq \{S\}\cdot\bar R_k-(F_k/k)\cdot R_k + \leq O(k^{-1}). + \end{split} +\end{equation} +The sum includes exceptional primes and those strict +divisorial components; terms with zero contact are irrelevant. + +Bounded ample degree gives only finitely many numerical +classes of the integral cycles \(\bar R_k\). Pass to one +class. By Lemma~\ref{proj:ex:valuation-acc}, the sums in +\eqref{proj:ex:zero-gap} belong to an ACC set: there are a bounded +number of terms, their nonnegative integral multiplicities +are bounded, and all relevant discrepancies are bounded. +Finite sums of this kind preserve ACC, by successively +taking nonincreasing subsequences of their entries. +The nonnegative gaps in \eqref{proj:ex:zero-gap} must therefore +equal zero for some covering families. Otherwise a sequence +tending to zero has a strictly decreasing positive +subsequence, giving a strictly increasing sequence of the +complementary sums. + +For such a family the residual positive current restricts +to degree zero on almost every \(R_k\), and hence vanishes +there. Off its removed divisors it is the original current. +The discussion following Lemma~\ref{proj:ex:web} and that lemma +itself yield a positive-relative-dimensional rational +quotient of \(B\) whose vertical directions are annihilated +by \(S\) on an open. Composing with \(h\) gives a quotient +of smaller base dimension whose vertical directions are +annihilated by \(T\), contradicting the choice of \(b\). +\end{proof} + +\subsection{Excluding normalized bounded curves} + +Run a canonical LMMP on \(X\) with scaling of a fixed very ample +rational divisor \(A\). For rational \(t>0\), its positive-threshold +stages give terminal \(\Q\)-factorial models \(Y_t\) on which +\(K_t+tA_t\) is nef, big, and semiample +\cite{BCHM}. There are only finitely many divisorial +contractions, since each lowers Picard number. Fix a late model +\(Y\) after the last such contraction. All subsequent maps +\(Y\dashrightarrow Y_t\) are small, and are canonical +nonpositive birational maps. If the program terminates, use +the last model repeatedly. Define +\begin{equation}\label{proj:ex:volume-scale} + \mu_t=\vol(K_X+tA)^{1/n}. +\end{equation} +Since \(K_X\) is not big, \(\mu_t\to0\). In particular \(K_Y\) +is nonbig. The transform \(A_t\) is effective up to rational +linear equivalence; all intersections below use general +covering curves, which are not contained in a chosen such +representative. + +\begin{lemma}[Exceptional current comparison]\label{proj:ex:current-comparison} +Fix a positive current \(T\) on a smooth resolution in the +pullback class of \(K_Y\). On a common smooth resolution of +\(Y\dashrightarrow Y_t\), write +\[ + p^*K_Y=p_t^*K_t+J_t,\qquad J_t\geq0, +\] +where \(J_t\) is exceptional over \(Y_t\). +Then \(\nu_E(T)\geq\operatorname{coeff}_E J_t\) for every +prime on that resolution. +\end{lemma} +\begin{proof} +Pass to a common smooth model \(V\) also dominating the +fixed resolution carrying \(T\). Choose on the fixed +resolution a sufficiently positive line bundle \(H\). +For sufficiently divisible \(k\), multiplier approximation +gives a globally generated +\(\OO(kp^*K_Y+H)\otimes\mathcal J(kT)\). +Pull this system to \(V\). A general member \(D_k\) of its +underlying effective divisor system has, at every specified +prime \(E\), multiplicity +\(\ord_E\mathcal J(kT)\); global generation after removal +of the ideal ensures no additional generic vanishing. +Here the notation \(H\) also denotes its pullback to \(V\). + +Put \(D'_k=p_{t*}D_k\) and \(H_t=p_{t*}H\). The first is +effective, and both are \(\Q\)-Cartier because \(Y_t\) is +\(\Q\)-factorial. Pushing the rational linear relation gives +\[ + D'_k\sim_\Q kK_t+H_t. +\] +Thus the exceptional divisor +\(D_k-p_t^*D'_k\) is rationally equivalent to +\[ + kJ_t+H-p_t^*H_t. +\] +The two exceptional divisors are equal: their difference is +numerically trivial and exceptional, so the negativity lemma +applied with both signs makes it zero. Since +\(p_t^*D'_k\) is effective, +\[ + \operatorname{coeff}_E D_k + \geq k\operatorname{coeff}_E J_t + +\operatorname{coeff}_E(H-p_t^*H_t). + \] +The last coefficient is fixed for this model and \(t\). +Combining with \eqref{proj:ex:multiplier-order}, dividing by +\(k\), and letting \(k\to\infty\) proves the assertion. +The same proof can be made on each common model, so the +comparison applies to all divisorial valuations needed +later. No uniformity in \(t\) of the fixed error is required. +\end{proof} + +\begin{proposition}\label{proj:prop:bounded-curves} +There are no sequences \(t_j\downarrow0\) and covering +families of curves on \(Y_{t_j}\), with smooth projective +domains \(C_j\), for which both +\[ + g(C_j),\qquad + \frac{(K_{t_j}+t_jA_{t_j})\cdot C_j}{\mu_{t_j}} +\] +are bounded by a fixed constant. Degrees mean degrees on +the domains, or equivalently intersection with their +pushforward cycles. +\end{proposition} +\begin{proof} +Suppose such families exist. Slice their parameters and +resolve total evaluation, the map to the fixed \(Y\), the +fixed smooth resolution carrying \(T\), and the common +models comparing \(Y\) and \(Y_t\). Denote the resulting +generically finite dominant morphism by \(q_t:U_t\to Y\). +The source is smooth near its complete general parameter +fiber and has dimension \(n\), with parameter space of +dimension \(n-1\). Rational maps from this smooth source +to each required proper target extend at codimension-one +points by the valuative criterion of properness. Their +indeterminacy loci consequently have codimension at least +two, and their images cannot dominate the parameter space. +Shrink that space to avoid these finitely many images, +and resolve and compactify preserving the remaining open. +Equivalently, nontrivial smooth-center blowups have +codimension-at-least-two centers; a codimension-one +Cartier-center blowup is the identity. Thus the complete +smooth general parameter fiber is still \(C_t\), unchanged +as a curve, and its genus is unchanged. + +For a prime \(Z\) of \(U_t\) exceptional over \(Y\), the +restricted valuation of its function field is +\(r_Z\ord_E\) for a divisorial valuation \(E\) over \(Y\). +The coefficient of \(Z\) in the ramification difference is +\begin{equation}\label{proj:ex:ramification-cost} + \operatorname{coeff}_Z(K_{U_t}-q_t^*K_Y) + =r_Za(E;Y,0)-1. +\end{equation} +This follows by factoring through a model extracting \(E\) +and calculating the tame ramification of DVRs. It is +positive and bounded away from zero: \(Y\) is terminal, +so \(a(E;Y,0)>1\), and a fixed Cartier index of \(K_Y\) +puts discrepancies in a fixed rational lattice. The +remaining ramification coefficients are nonnegative. +On the general parameter fiber, +\[ + K_{U_t}\cdot C_t=2g(C_t)-2,\qquad + q_t^*K_Y\cdot C_t\geq0. + \] +The latter inequality follows from pseudoeffectivity and +the covering property. Therefore the total ramification +cost is bounded. Formula~\eqref{proj:ex:ramification-cost} +bounds the number of positive exceptional contacts, +their discrepancies, their ramification indices, and +their integral contact degrees. Moreover +\(q_t^*K_Y\cdot C_t\) lies in a fixed rational lattice +inside a bounded interval, so takes only finitely many +values. + +The generic Lelong number of \(q_t^*T\) at \(Z\) is +\(r_Z\nu_E(T)\). Extract \(E\), remove its generic +divisorial part, and use the transverse-power-map +comparison for the zero-generic-number remainder. +Lemma~\ref{proj:ex:current-comparison} shows that these +coefficients dominate the coefficients of the pulled-back +canonical difference \(J_t\). Its support is exceptional +over \(Y\) as well as \(Y_t\), since the map between these +models is small. Subtracting all exceptional divisorial +parts of \(q_t^*T\) leaves a positive current. Consequently +\begin{equation}\label{proj:ex:bounded-gap} + \begin{split} + 0&\leq q_t^*K_Y\cdot C_t + -\sum_{Z\ {\rm exceptional}} + r_Z\nu_E(T)\,Z\cdot C_t\\ + &\leq K_t\cdot C_t + \leq (K_t+tA_t)\cdot C_t + =O(\mu_t). + \end{split} +\end{equation} +All divisor contacts used here are nonnegative, since the +curves cover the total space. + +On the fixed smooth resolution \(W\to Y\), one has +\[ + a(E;W,0)=a(E;Y,0) + -\ord_E(K_W-p^*K_Y)\leq a(E;Y,0), +\] +because the relative canonical divisor is effective. +Thus Lemma~\ref{proj:ex:valuation-acc} applies with a fixed +bound. The sums in \eqref{proj:ex:bounded-gap} form an ACC +set, their number of terms and integral multiplicities +being bounded. Pass to a fixed value of +\(q_t^*K_Y\cdot C_t\). Since \(\mu_t\to0\), the +exact-zero argument of \eqref{proj:ex:zero-gap} gives a family +for which the left gap is zero. + +The residual positive current then restricts to zero on +almost every curve in that family. On the dense open +away from the removed exceptional divisors it agrees +with the original current. Its curve tangents therefore +generate, by Lemma~\ref{proj:ex:web}, an annihilated rational +fibration of positive relative dimension on \(Y\). +This contradicts Proposition~\ref{proj:prop:no-pullback}. +\end{proof} + +\subsection{The signed alternative} + +\begin{proposition}\label{proj:prop:signed-alternative} +On any model \(Y_t\), let a signed rational divisor +represent \(K_t\) up to \(\Q\)-linear equivalence. On a +log resolution \(p:W\to Y_t\), let \(D\) be the reduced +SNC divisor consisting of its strict support and all +exceptional divisors. Then \(K_W+D\) is big. +\end{proposition} +\begin{proof} +Put \(P=K_W+D\), and suppose it is not big. It cannot +have Iitaka dimension at least one: by +Corollary~\ref{proj:ex:supporting}, \(K_W+cP\) would be big, +and +\((1+c)P=(K_W+cP)+D\) would then be big as well. +Hence \(\kappa(W,P)\leq0\). + +Run the dlt LMMP for \(P\) with ample scaling. +The divisor \(P\) has a signed rational representative +supported on the floor \(D\), and its transforms retain +that property. Every negative flip must meet the floor: +on its complement the representing rational section is +nowhere vanishing, so the adjoint has zero degree on +every complete curve there. By +Proposition~\ref{proj:prop:special-termination}, an infinite +sequence would eventually have all flips disjoint from +the floor, a contradiction. Divisorial contractions +are finite in number. Thus the program terminates at +a \(\Q\)-factorial dlt log minimal model +\((Z,D_Z)\). + +The boundary is reduced, \(K_Z\) is pseudo-effective +as the birational pushforward of \(K_W\), and the nef +adjoint has a signed rational representative supported +on \(D_Z\). Its restriction to \(D_Z\) is semiample +by Proposition~\ref{proj:prop:boundary-restriction}. +Theorem~\ref{proj:thm:signed} applies, with the +pseudo-effective perturbation \(K_Z\), and gives +abundance. Since the Iitaka dimension is at most zero, +the numerical dimension is zero. Intersecting +\(K_Z+D_Z\equiv0\) with an ample +\((n-1)\)-fold product, and using pseudoeffectivity of +\(K_Z\), forces \(D_Z=0\). The signed relation then +gives \(K_Z\sim_\Q0\). + +On a common resolution, the pullback of \(K_W\) is +rationally equivalent to a signed divisor exceptional +over \(Z\). It is pseudo-effective. A positive current +in that class has zero intersection with a pullback +of an ample class on \(Z\) to the power \(n-1\), +so is supported on the exceptional locus. The support +theorem makes it effective divisorial, and independence +of exceptional divisor classes by negativity says that +the original signed coefficients are these nonnegative +coefficients. Thus \(K_W\) is \(\Q\)-linearly effective, +contradicting \eqref{proj:ex:counterexample}. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_frobenius.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_frobenius.tex new file mode 100644 index 0000000000000000000000000000000000000000..d1522da2b89b6c7553a498f1d36e0c5de0d822c6 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_frobenius.tex @@ -0,0 +1,515 @@ +\section{Frobenius comparison and smooth nonvanishing} +\label{proj:fr:section} + +We now turn the two opposite jet estimates into a contradiction. +The reduction to positive characteristic is used only for this comparison: +no minimal-model statement or pseudo-effectivity assertion will be +specialized to positive characteristic. + +\begin{theorem}[The smooth nonvanishing step] +\label{proj:thm:smooth-nonvanishing} +Assume Assumption~\ref{proj:asm:iitaka} and the lower-dimensional +real-boundary good-model hypothesis of Assumption~\ref{proj:mmp:lower-models}. +If \(X\) is a smooth projective complex variety of dimension \(n\) and +\(K_X\) is pseudo-effective, then \(\kappa(X,K_X)\geq0\). +\end{theorem} + +The assertion is immediate in dimension zero. On a smooth curve, +pseudo-effectivity of \(K_X\) gives \(g(X)\geq1\), hence +\(h^0(X,K_X)=g(X)>0\). We therefore suppose \(n\geq2\) and argue by +contradiction. We use the late terminal model \(Y\), the divisors +\(K=K_Y\) and \(A=A_Y\), and the scaling models of the preceding +section. Fix \(m>0\) with \(mK\) Cartier, and write +\[ + \mu_t=\vol(K_X+tA_X)^{1/n},\qquad + L=r(K+tA). +\] +As before, \(r\) is a positive integer chosen so that +\(r\mu_t\longrightarrow\epsilon\) as \(t\downarrow0\). +Choose the rational number \(\epsilon>0\) sufficiently small for +Propositions~\ref{proj:prop:scalar-jets} and~\ref{proj:prop:large-seshadri}, and also +so that +\begin{equation} +\label{proj:fr:epsilon} + (14\epsilon)^n<\frac14,\qquad + 80\epsilon<\frac34. +\end{equation} +The inequalities are strict. We next fix a sufficiently large integer +\(q\) as in Proposition~\ref{proj:prop:large-seshadri}, and then fix a +sufficiently small positive rational \(t\). In particular, we may require +\(r>qm+1\). All subsequent characteristic-zero choices will be made with +these data fixed. + +\subsection{A small polarization and an actual moving curve} + +Choose a smooth common resolution \(W\) of \(Y\) and the scaling model +for \(K+tA\). In this section \(K,A,L\) also denote their pullbacks to +\(W\), and +\[ + K_W=K+E,\qquad E\geq0. +\] +Let \(H_0\) be the pullback of the nef semiample positive part \(N_0\) of +\(L\) on its scaling model. The comparison of canonical pullbacks and +moving parts gives +\begin{equation} +\label{proj:fr:limit-intersections} + H_0^n\longrightarrow\epsilon^n,\qquad + LH_0^{n-1}=H_0^n,\qquad + K_WH_0^{n-1}=KH_0^{n-1}\leq\frac{H_0^n}{r}. +\end{equation} +The maps \(Y\dashrightarrow Y_t\) are small by the choice of the late +model, so every divisor exceptional over \(Y\) is also exceptional +over \(Y_t\). +Indeed, the differences being discarded are exceptional over the +scaling model, and the transform of \(A\) is effective up to rational +linear equivalence. Their intersections with \(H_0^{n-1}\) therefore +give the displayed equalities and inequality. For a fixed ample divisor +\(H_{\mathrm{amp}}\), choose a sufficiently small positive rational +\(\eta\) and put \(H=H_0+\eta H_{\mathrm{amp}}\). By continuity, after +the preceding choices of \(t\) and \(r\), we have +\begin{equation} +\label{proj:fr:intersection-bounds} + H^n\leq(2\epsilon)^n,\qquad + K_WH^{n-1}\leq\frac{2H^n}{r},\qquad + (2L+qmK)H^{n-1}\leq4H^n. +\end{equation} + +The canonical divisor of \(W\) is pseudo-effective. Generic +semipositivity, applied with empty boundary +\cite[Theorem~2.1]{Proj-CampanaPaun2015}, and restriction to a sufficiently +general complete-intersection curve give the following fixed data. +Choose \(l>0\) such that \(h=lH\) is integral and sufficiently very +ample, and choose a smooth complete-intersection flag +\[ + W=W_n\supset W_{n-1}\supset\cdots\supset W_1=C, + \qquad W_{i-1}\in |h|_{W_i}, +\] +for which +\begin{equation} +\label{proj:fr:generic-nef} + \mu_{\min}(\Omega_W^1|_C)\geq0. +\end{equation} +Here and below slopes on \(C\) mean degree divided by rank. One may +obtain the flag by applying restriction to the finitely many +Harder--Narasimhan quotients of \(\Omega_W^1\). + +Choose also a very general point \(x\in W\), away from the exceptional +loci, and let \(\pi_x:\widehat W\to W\) be its blowup, with exceptional +divisor \(J\). Set +\[ + D^+=2r(K+2tA)+2E. +\] +This divisor is big. Its sections, pushed to \(Y\), are the scalar +sections in Proposition~\ref{proj:prop:scalar-jets}; the added exceptional +part does not change them. If +\(\rho=\vol(2r(K+2tA))^{1/n}\), then +\[ + \rho\leq4r\mu_t\leq8\epsilon +\] +for our sufficiently small \(t\). Thus every section of a sufficiently +divisible multiple of \(D^+\) has normalized order at \(x\) at most +\(4\rho\leq32\epsilon\). + +It follows that \(\pi_x^*D^+-40\epsilon J\) is not pseudo-effective. +Otherwise its convex combination with the big class \(\pi_x^*D^+\) +would make \(\pi_x^*D^+-cJ\) big for some rational +\(32\epsilon0. +\end{equation} +For precision, the strict negative pairing can first be detected by a +strongly movable curve: take the pushforward of a general complete +intersection of very ample divisors on one fixed smooth birational +model of \(\widehat W\). Fix this model, its divisors, and the resulting +covering family. This choice is finite algebraic data, rather than a +limiting real movable class. Positivity of \(J\cdot\gamma\) follows +from the strict inequality and pseudo-effectivity of \(\pi_x^*D^+\). + +\subsection{Fixed jets and reduction modulo primes} + +On \(W\times W\), let +\[ + Z=\PP(mK_1\oplus mK_2),\qquad + \xi=\OO_Z(1),\qquad + M=L_1+L_2+q\xi, +\] +with the symmetric-power convention for the projective bundle. +Proposition~\ref{proj:prop:large-seshadri} gives a semiample big model whose +Seshadri constant exceeds \(2n+2\) at a very general torus point. +On the open set where its birational contraction is an isomorphism, +the jet interpretation of the Seshadri constant consequently gives +an integer \(k_0>0\) such that \(|k_0M|\) generates jets of order +at least \((2n+2)k_0\) at a fixed smooth torus point \(z_*\in Z\). +Indeed, on the ample model choose a rational number \(c\) strictly +between \(2n+2\) and its Seshadri constant. On the blowup of the +selected smooth point, the pullback of the ample class minus \(c\) +times the exceptional divisor is ample. Serre vanishing and the +exceptional-divisor sequence then give jets of order \(kc-1\) for +all sufficiently divisible large \(k\). Pulling sections back on the +isomorphic open gives the asserted bound. +Enlarge \(k_0\) to clear every denominator, in particular that of \(L\), +and fix finitely many sections realizing this jet surjection. + +Spread the varieties, maps, divisors, flag, points, covering family, +and these finitely many sections over an integral finitely generated +\(\Z\)-algebra of characteristic zero. Shrink its spectrum so that the +relevant fibers and flag are smooth, the maps defining the covering +family remain dominant, and the fixed jet evaluation remains +surjective. Spread also the Harder--Narasimhan filtration of +\(\Omega_W^1|_C\). Its quotients are vector bundles on the curve; their +semistability is open, and their degrees are constant in the family. +After another shrinking, Equation~\eqref{proj:fr:generic-nef} holds on each +reduction. Such an open set has closed points in arbitrarily large +prime characteristics. We work over algebraic closures of their +residue fields, retaining the notation \(W,C,h,x,\gamma\). + +In particular, all numbers in +Equations~\eqref{proj:fr:intersection-bounds} and~\eqref{proj:fr:curve-test} +are unchanged. We use the spread covering family to test effective +divisors after reduction. We do not assert that the characteristic-zero +pseudo-effective cones, or the scaling models, specialize. + +Choose a fixed sufficiently ample integral divisor \(T_0\) on \(W\), +also spread with suitable sections, and for a prime \(p\) put +\begin{equation} +\label{proj:fr:bp} + N_p=\left\lfloor\frac p{k_0}\right\rfloor,\qquad + B_p=k_0N_pL+T_0. +\end{equation} +The difference \(B_p-pL\) belongs to a fixed finite set of rational +divisor classes. The system +\[ + |pq\xi+B_{p,1}+B_{p,2}| +\] +contains products of \(N_p\) members of \(|k_0M|\), multiplied by a +filler nonvanishing at \(z_*\). To see that one \(T_0\) suffices, write +\(p=k_0N_p+d\), where \(0\leq d(2n+1)(p-1) +\] +for all sufficiently large \(p\), the same system surjects onto the +quotient of the local ring at \(z_*\) by the \(p\)-th powers of its +\(2n+1\) regular parameters. + +\subsection{Full rank away from the diagonal} + +Let \(F:W\to W'\) be relative Frobenius, and put +\[ + S_0=mK,\qquad + \mathcal E=F_*\OO_W(B_p),\qquad + s=\rk\mathcal E=p^n,\qquad + U_a=H^0(W,\OO_W(B_p+paS_0)) + \quad(0\leq a\leq q). +\] +Primes on line bundles indicate the base twist, so +\(F^*S'_0=pS_0\). Projection formula gives an evaluation map +\begin{equation} +\label{proj:fr:evaluation} + \bigoplus_{a+b=q} + U_a\otimes U_b\otimes + \OO_{W'\times W'}(-aS'_{0,1}-bS'_{0,2}) + \longrightarrow\mathcal E\boxtimes\mathcal E. +\end{equation} +Its generic rank is \(s^2\). + +Here is a coordinate verification of this assertion. Choose local +frames of the projective-bundle axes and let \(z\) be a torus coordinate +at \(z_*\), with value \(z_0\ne0\). On its Frobenius fiber the relation +is \(z^p=z_0^p\). Over the two base Frobenius fibers, the fiber-coordinate +part of the quotient is free with basis \(1,z,\ldots,z^{p-1}\). +Project the jet surjection just obtained to its coefficient of \(1\). +The monomial \(z^j\) survives precisely when \(p\) divides \(j\), in +which case it becomes the nonzero scalar \(z_0^j\). +The global section formula for the projective bundle has weights +\(0\leq j\leq pq\). Its surviving terms \(j=pa\) are exactly +\[ + H^0(W,B_p+paS_0)\otimes + H^0(W,B_p+p(q-a)S_0). +\] +They therefore span the tensor product of the two base Frobenius +fibers. These have dimensions \(s\) each, proving the rank assertion. +The two base points used for this argument need not coincide with \(x\). + +\subsection{A small rank on the diagonal} + +Let +\[ + \Delta_F=W\times_{W'}W=(F\times F)^{-1}(\Delta_{W'}). +\] +On this scheme the two copies of \(pS_0\) are canonically identified, +since both descend from \(S'_0\) on the diagonal. All source twists +in Equation~\eqref{proj:fr:evaluation} restrict on \(\Delta_{W'}\) to +\(\OO_{W'}(-qS'_0)\), with these identifications pulled back to +\(\Delta_F\). Consequently every column, after restriction to +the diagonal and this common one-dimensional twist, is evaluated from a +global section on \(\Delta_F\) of +\[ + \mathcal L_p= + \OO_{\Delta_F}(B_{p,1}+B_{p,2}+pqS_{0,1}). +\] +The rank on the diagonal is therefore at most +\(h^0(\Delta_F,\mathcal L_p)\). + +The first projection \(\Delta_F\to W\) is finite flat of degree \(s\). +Filter its direct image by powers of the ideal of the reduced +diagonal. \'{E}tale-locally in smooth coordinates its algebra is +\[ + \OO_W[\delta_1,\ldots,\delta_n]/ + (\delta_1^p,\ldots,\delta_n^p). +\] +Its graded pieces, after the line twist, are thus the vector bundles +\begin{equation} +\label{proj:fr:graded-pieces} + \mathcal G_j= + \OO_W(2B_p+pqS_0)\otimes A_j(\Omega_W^1), + \qquad 0\leq j\leq u=n(p-1), +\end{equation} +where \(A_j(V)\) is the degree-\(j\) piece of the symmetric algebra of +\(V\) modulo \(p\)-th powers. This coordinate calculation is also the +canonical Frobenius filtration +\cite[Theorem~3.7]{Proj-Sun2008}. If \(e_j=\rk A_j(\Omega_W^1)\), then +\begin{equation} +\label{proj:fr:ranks} + \sum_{j=0}^u e_j=p^n=s. +\end{equation} +The sum is \(s\), rather than \(s^2\); the second factor of \(s\) will +come from the bound for sections. + +\begin{lemma}[Uniform slope bound] +\label{proj:fr:slope} +With all characteristic-zero choices fixed, uniformly for +\(0\leq j\leq n(p-1)\), +\[ + \mu_{\max}(\mathcal G_j|_C) + \leq 7p\,l^{n-1}H^n+O(1). +\] +The constant implicit in \(O(1)\) is independent of \(p\) and \(j\). +\end{lemma} + +\begin{proof} +Put \(V=\Omega_W^1|_C\). For a vector bundle on the smooth curve \(C\), +write +\[ + L_{\min}(V)= + \lim_{e\to\infty} + \frac{\mu_{\min}((F_C^e)^*V)}{p^e}. +\] +Langer's Frobenius-instability estimate +\cite[Corollary~2.5]{Proj-Langer2004} states that +\[ + \mu_{\min}(V)-L_{\min}(V) + \leq \frac{(n-1)\deg A_C}{p-1} +\] +if \(A_C\) is nef and \(T_C(A_C)\) is globally generated. +The genus is fixed, so \(A_C\) can be chosen with degree bounded +independently of \(p\). Equation~\eqref{proj:fr:generic-nef} yields +\begin{equation} +\label{proj:fr:asymptotic-slope} + L_{\min}(V)\geq-\frac{c}{p-1} +\end{equation} +with one fixed \(c\). + +We need an estimate for tensor powers whose exponent grows with \(p\). +For every \(i\geq0\), +\begin{equation} +\label{proj:fr:tensor-slope} + \mu_{\min}(V^{\otimes i})\geq iL_{\min}(V). +\end{equation} +To prove this directly, twist \((F_C^e)^*V\) by a line bundle of +degree at most +\(-\mu_{\min}((F_C^e)^*V)+2g(C)+2\) so that it is globally generated. +This follows from Serre duality and the slope criterion for the +vanishing of \(H^1\) after subtracting any point. The \(i\)-th tensor +power is then globally generated with the corresponding \(i\)-fold +twist. Pull back any quotient of \(V^{\otimes i}\), take degrees, +divide by \(p^e\), and let \(e\) tend to infinity. The bounded genus +term disappears, proving Equation~\eqref{proj:fr:tensor-slope}. +Thus every quotient of a tensor power with \(i\leq n(p-1)\) has +minimum slope at least \(-nc\). + +Multiplication to the socle of the truncated polynomial algebra is +a perfect pairing in complementary degrees. The top monomial +transforms by \((\det V)^{p-1}\), so, equivariantly, +\[ + A_j(V)^*\otimes(\det V)^{p-1}\simeq A_{u-j}(V). +\] +The right side is a quotient of \(V^{\otimes(u-j)}\). Therefore +\[ + \mu_{\max}(A_j(V))\leq(p-1)\deg K_W|_C+nc. +\] +By Equations~\eqref{proj:fr:bp} and~\eqref{proj:fr:intersection-bounds}, +\begin{align*} + (2B_p+pqS_0)\cdot C + &\leq4p\,l^{n-1}H^n+O(1),\\ + (p-1)K_W\cdot C + &\leq\frac{2p}{r}\,l^{n-1}H^n. +\end{align*} +Since \(r>1\), their sum is bounded by the claimed expression, +with slack in its coefficient \(7\). +\end{proof} + +\begin{lemma}[Uniform section bound] +\label{proj:fr:sections} +For the bundles in Equation~\eqref{proj:fr:graded-pieces}, +\[ + h^0(W,\mathcal G_j) + \leq e_jp^n\bigl(7^nH^n+o(1)\bigr), +\] +uniformly in \(j\). Consequently, for all sufficiently large \(p\), +\begin{equation} +\label{proj:fr:diagonal-rank} + h^0(\Delta_F,\mathcal L_p)\leq\frac{s^2}{4}. +\end{equation} +\end{lemma} + +\begin{proof} +Choose \(M_p=7p\,l^{n-1}H^n+c_0\), where \(c_0\) bounds the error in +Lemma~\ref{proj:fr:slope}, and put \(d_C=h\cdot C=l^nH^n\). +A bundle of rank \(e_j\) and maximal slope at most \(M_p\) has at +most \(e_j(M_p+1)\) sections: evaluation at +\(\lfloor M_p\rfloor+1\) distinct points is injective. +Its twist by \(-kh\) has no sections if \(kd_C>M_p\). + +The divisor sequences on the fixed flag give +\[ + h^0(W,\mathcal G_j) + \leq + \sum_{k_1,\ldots,k_{n-1}\geq0} + h^0\bigl(C,\mathcal G_j|_C + (-(k_1+\cdots+k_{n-1})h)\bigr). +\] +One obtains this by successively summing the restriction inequalities; +the remainders vanish for sufficiently negative ample twists at each +stage. At most +\((1+\lfloor M_p/d_C\rfloor)^{n-1}\) tuples contribute. Hence +\[ + h^0(W,\mathcal G_j) + \leq e_j(M_p+1)(1+M_p/d_C)^{n-1} + =e_jp^n\bigl(7^nH^n+o(1)\bigr). +\] +The powers of \(l\) cancel in the leading coefficient. +All error constants are fixed before \(p\), and the same bound applies +to every \(j\). Summing over the filtration and using +Equation~\eqref{proj:fr:ranks} gives +\[ + h^0(\Delta_F,\mathcal L_p) + \leq s^2\bigl(7^nH^n+o(1)\bigr). +\] +Now \(7^nH^n\leq(14\epsilon)^n<1/4\) by +Equations~\eqref{proj:fr:epsilon} and~\eqref{proj:fr:intersection-bounds}. +This proves Equation~\eqref{proj:fr:diagonal-rank}. +\end{proof} + +\subsection{The determinant contradiction} + +Put \(R=s^2\). Choose \(R\) columns of +Equation~\eqref{proj:fr:evaluation} with nonzero determinant. Their +determinant is a nonzero section \(\sigma\) of an external product +\(\mathcal Q_1\boxtimes\mathcal Q_2\) of line bundles on \(W'\times W'\). +Indeed +\(\det(\mathcal E\boxtimes\mathcal E) + =(\det\mathcal E)^s\boxtimes(\det\mathcal E)^s\), +and the column twists add the sums of their respective weights. +Consequently, under numerical identification with the base twists, +\begin{equation} +\label{proj:fr:slot-class} + \frac{c_1(\mathcal Q_i)}{R} + =\frac{c_1(\mathcal E)}s+\lambda_iS_0 + =\frac{B_p}{p}+\frac{p-1}{2p}K_W+\lambda_i mK, + \qquad 0\leq\lambda_i\leq q. +\end{equation} +The last equality is degree-one Grothendieck--Riemann--Roch for +Frobenius \cite[Lemma~4.2]{Proj-Sun2008}: +\[ + c_1(F_*\OO_W(B_p)) + =p^{n-1}B'_p+\frac{p^n-p^{n-1}}2K_{W'}. +\] +Here numerical identification through the base-field twist must not +be confused with Frobenius pullback, which multiplies divisor classes +by \(p\). + +For \(0\leq\lambda\leq q\), write +\(Q_\lambda=L+K_W/2+\lambda mK\). Direct calculation gives +\begin{equation} +\label{proj:fr:slot-domination} + D^+-Q_\lambda + =(r-\tfrac12-\lambda m)K+3rtA+\tfrac32E. +\end{equation} +This is pseudo-effective in characteristic zero because +\(r>qm+1\), \(K\) is pseudo-effective, and \(A,E\) are effective up +to the indicated equivalence. Pairing with the fixed class \(\gamma\) +therefore bounds \(Q_\lambda\cdot\gamma\) by +\((\pi_x^*D^+)\cdot\gamma\). This numerical inequality survives the +spread: it concerns only intersections of fixed divisors with the +fixed family. The difference between +Equation~\eqref{proj:fr:slot-class} and \(Q_{\lambda_i}\) is \(O(1/p)\) +in a fixed finite-dimensional space, uniformly in the chosen columns. + +Let \(x'\in W'\) be the twist of \(x\). For a nonzero section of +\(\mathcal Q_i\), its effective divisor, strictly transformed on the +blowup at \(x'\), has nonnegative intersection with the spread moving +curve. Dividing this inequality by \(R\,J\cdot\gamma\) and using +Equations~\eqref{proj:fr:curve-test}--\eqref{proj:fr:slot-domination} yields +\begin{equation} +\label{proj:fr:slot-order} + \frac{\ord_{x'}(\tau)}R\leq40\epsilon+o(1) + \quad\text{for every }0\ne\tau\in H^0(W',\mathcal Q_i). +\end{equation} +This bounds all sections on the reduction, not merely the sections +spread from characteristic zero. + +An external-product section can have order at \((x',x')\) at most +the sum of the two maximal slot orders. To verify this despite +possible cancellation, choose bases in each section space adapted to +its filtration by order at \(x'\). Their leading homogeneous terms +are linearly independent within each degree. Tensor products of +these terms are independent in each bidegree in the two disjoint +sets of local parameters. Thus the first nonzero homogeneous part +of a nonzero tensor cannot be cancelled beyond the sum of the slot +maxima. K\"unneth's formula identifies the external-product section +space with this tensor product. In particular, +\begin{equation} +\label{proj:fr:det-upper} + \ord_{(x',x')}(\sigma)\leq R(80\epsilon+o(1)). +\end{equation} + +On the other hand, Equation~\eqref{proj:fr:diagonal-rank} says that the +matrix of the chosen columns has rank at most \(R/4\) at \((x',x')\). +Trivialize its line bundles locally and perform invertible row and +column operations on the constant matrix. At least \(3R/4\) of the +resulting rows have every entry in the maximal ideal. Every term +of the determinant consequently has order at least \(3R/4\), so +\begin{equation} +\label{proj:fr:det-lower} + \ord_{(x',x')}(\sigma)\geq\frac{3R}{4}. +\end{equation} +This is a pointwise maximal-ideal estimate; no stronger assertion +about an order along the whole diagonal is required. +Equations~\eqref{proj:fr:det-upper} and~\eqref{proj:fr:det-lower} contradict +\(80\epsilon<3/4\) for all sufficiently large \(p\). + +We have made the choices in the order +\[ + n,\ \epsilon,\ q,\ (t,r),\ + (W,H,h,\text{flag},x,\gamma),\ + (k_0,T_0,\text{fixed sections}),\ p. +\] +In particular every constant suppressed in the estimates is fixed +before the last prime tends to infinity. This contradiction excludes +the assumed counterexample and proves +Theorem~\ref{proj:thm:smooth-nonvanishing}. diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_hodge.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_hodge.tex new file mode 100644 index 0000000000000000000000000000000000000000..89e74d00a2ee431ce5907ead9a1e1fb8e5845652 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_hodge.tex @@ -0,0 +1,531 @@ +\section{Hodge theory and formal lifting}\label{proj:sec:hodge} + +We retain the geometric package of +Proposition~\ref{proj:prop:signed-construction}. In particular, +\(\mathcal P=\sqrt[\ell]{\OO_{\PP^s}(1)}\) is a root gerbe, \(C\) is +its tautological line bundle, and +\[ + g:S\longrightarrow\mathcal Y + \xrightarrow{p}\mathcal P +\] +is a representable projective morphism followed by a smooth projective +bundle. The Stein image \(\mathcal T\subset\mathcal Y\) is finite over +\(\mathcal P\), and \(g_*\OO_S=\OO_{\mathcal T}\). The reduced Cartier +divisor \(S\subset\mathcal X\) has dimension \(N=n-1\). If +\(J=(S\cap T)_{\mathrm{red}}\), then \(S,J\) are Du Bois, +\(\mathcal I_{J/S}\) is maximal Cohen--Macaulay, and +\begin{equation}\label{proj:hg:geometric-lines} + \mathcal B:= + \mathcal Hom_S(\mathcal I_{J/S},\omega_S) + \simeq \OO_S(aS)=g^*C^a, + \qquad + \OO_S(S)=g^*C, +\end{equation} +where \(a>0\) is an integer. Off \(T\), the fixed ambient isomorphism +\(\omega_{\mathcal X}(S)\simeq\OO_{\mathcal X}(aS)\) supplies these +identifications by adjunction. We prove that functions and transverse +parameters can be lifted through every infinitesimal neighborhood of +\(S\). + +\subsection{A global vanishing statement} + +We use graded-polarizable mixed Hodge modules on ordinary complex +algebraic varieties. The needed established results are projective +strictness and the usual functorial operations +\cite[Theorem~2.14 and Section~4]{Proj-Saito1990}, the comparison with the +Du Bois complex and its coherent dual +\cite[Theorem~0.2 and Corollary~0.3]{Proj-Saito2000}, and +Kodaira--Saito vanishing \cite[Proposition~2.33]{Proj-Saito1990}. +No Hodge-module theory on stacks is assumed. Our objects on smooth +stacks will be compatible systems on scheme etale charts, whose +filtered differential modules descend. + +Throughout this section, differential modules are right modules with +increasing filtration. The module itself is in degree zero in its +Spencer de Rham complex. Thus, on a smooth chart \(V\), the term in +degree \(-i\) of \(\Gr^F_k\DR_V(M)\) is +\[ + \Gr^F_{k-i}M\otimes_{\OO_V}\bigwedge^iT_V. +\] +In particular, if \(F_{<0}M=0\), the lowest graded de Rham complex is +the sheaf \(F_0M\) in degree zero. + +\begin{lemma}\label{proj:hg:negative-vanishing} +Let \(M\) be a compatible system of mixed Hodge modules in perverse +degree zero on the scheme etale charts of \(\mathcal Y\). Suppose +its support is finite over \(\mathcal P\). Then, for every integer +\(k\), every positive integer \(b\), and every \(j<0\), +\[ + \mathbb H^j\!\left( + \mathcal Y,\Gr^F_k\DR_{\mathcal Y}(M)\otimes p^*C^{-b} + \right)=0. +\] +Here the graded de Rham complex is the descended coherent complex. +\end{lemma} + +\begin{proof} +Because \(p\) is finite on the support, its direct image has only +perverse cohomology in degree zero. Denote that system on +\(\mathcal P\) by \(M'\). Projective strictness on the ordinary +scheme charts gives +\begin{equation}\label{proj:hg:graded-direct-image} + Rp_*\Gr^F_k\DR_{\mathcal Y}(M) + \simeq \Gr^F_k\DR_{\mathcal P}(M'). +\end{equation} +We first explain why this is a global identity of descended complexes, +rather than a claim of local vanishing. + +For right differential modules, the direct image is formed from the +filtered transfer bimodule +\[ + \mathcal D_{\mathcal Y\to\mathcal P} + = + \OO_{\mathcal Y}\otimes_{p^{-1}\OO_{\mathcal P}} + p^{-1}\mathcal D_{\mathcal P}, +\] +with its order filtration, by derived tensor over +\(\mathcal D_{\mathcal Y}\) and derived direct image. These operations +may equivalently be performed on Rees modules. Applying de Rham on +the base means further derived tensor with \(\OO_{\mathcal P}\), +whose filtration begins in degree zero. The filtered Spencer +resolution, associativity of derived tensor, and projection formula +identify the result with the direct image of de Rham upstairs: +the transfer module tensored over the base differential operators +with its structure sheaf is \(\OO_{\mathcal Y}\). +These are canonical sheaf constructions on the etale site; the +Spencer resolutions are locally free over differential operators. +They therefore respect chart changes before passing to associated +gradeds. Strictness and the concentration in perverse degree zero +can be checked on the base charts by the ordinary projective +direct-image theorem. Coherent cohomology on those charts is +unchanged by using their etale sites. This proves +Equation~\eqref{proj:hg:graded-direct-image} as an identity that computes +global coherent hypercohomology. The same argument applies to the +representable finite morphism used next. + +There is a representable finite surjective morphism +\[ + v:\PP^s_z\longrightarrow\mathcal P +\] +defined by the power map +\([z_0:\cdots:z_s]\mapsto[z_0^\ell:\cdots:z_s^\ell]\) +and the root \(\OO_{\PP^s_z}(1)\). In particular, +\(v^*C=\OO_{\PP^s_z}(1)\). On the standard affine opens of \(\PP^s\) +choose the trivial root, obtaining scheme etale charts +\(\check U_i\to\mathcal P\). On \(z_i\ne0\), the morphism \(v\) +factors through \(\check U_i\). Pull back \(M'\) on these charts +and take perverse cohomology in degree zero. Functoriality and the +chosen root identify these objects on overlaps, giving a system +\(H\) on the Zariski opens of \(\PP^s_z\). + +For completeness, this is a global graded-polarizable mixed Hodge +module on \(\PP^s_z\). The perverse, filtered, and weight data glue. +The pure weight gradeds have strict-support decompositions, which +glue by uniqueness. On a smooth connected dense stratum of an +irreducible support, a polarization from a nonempty Zariski open +extends as a flat pairing: the fundamental group of that open +surjects onto the fundamental group of the stratum. Its Hodge +compatibility extends by continuity; nondegeneracy and positivity +persist for the extended flat pairing. Quasi-unipotence at the +boundary is already supplied by the local Hodge modules. Saito's +extension theorem for polarizable variations +\cite[Section~3.b]{Proj-Saito1990} and uniqueness of strict-support +extension identify this global pure object with the glued one. +There is no additional boundary at infinity, since \(\PP^s_z\) is +projective. The weight extensions then give the stated mixed +object. + +The system \(M'\) is a retract of \(v_+H\). To see this on a chart, +use the \emph{whole} base-changed finite cover. Over \(\check U_i\) +it is a disjoint union of copies of the corresponding affine +coordinate chart of \(\PP^s_z\). The unit on unshifted constants +and its dual trace, using smooth duality in equal dimensions, have +composition multiplication by the degree. On the finite etale +locus the trace is summation over sheets. On each connected +smooth base chart, the shifted constant Hodge module is the +rank-one intersection complex and has endomorphism ring \(\Q\); +its endomorphisms are determined on a dense open. Thus the +composition equals the degree globally, with no additional term +supported on the branch locus. Ramification is therefore +allowed. Tensoring with \(M'\), applying proper +projection formula, and taking perverse cohomology in degree zero +gives the claimed retraction, since finite direct image is +perverse exact. Divide the trace by the degree. All maps are +canonical under etale base change, so the retraction descends also +on filtered differential modules. + +Now apply the finite version of +Equation~\eqref{proj:hg:graded-direct-image} and projection formula. +The desired hypercohomology is a direct summand of +\[ + \mathbb H^j\!\left( + \PP^s_z,\Gr^F_k\DR(H)\otimes\OO_{\PP^s_z}(-b) + \right). +\] +This is zero for \(j<0\) by ordinary negative-ample +Kodaira--Saito vanishing. One may apply it to the pure weight +gradeds and then use the exact sequences of the weight filtration; +the Hodge filtrations of those sequences are strict. +\end{proof} + +\subsection{The lowest Hodge piece} + +Take a separated quasi-projective scheme etale chart +\(U\to\mathcal Y\), of finite type. Write +\(S_U=S\times_{\mathcal Y}U\), \(J_U=J\times_{\mathcal Y}U\), +and again \(g:S_U\to U\) for the induced projective morphism. +For \(j:S_U\setminus J_U\hookrightarrow S_U\), put +\[ + A^\bullet_U=\mathbf D\!\left( + j_!\Q^H_{S_U\setminus J_U}[N]\right), + \qquad + A_{0,U}={}^{p}\!H^0A^\bullet_U, + \qquad + M_U={}^{p}\!H^1g_*A_{0,U}. +\] +All these constructions commute with etale restriction. The \(M_U\) +form a system supported on \(\mathcal T\), to which +Lemma~\ref{proj:hg:negative-vanishing} applies. + +\begin{lemma}\label{proj:hg:lowest-piece} +The following identifications hold compatibly on the charts: +\[ + F_{<0}A_{0,U}=0,\qquad F_0A_{0,U}=\mathcal B|_{S_U}, + \qquad + F_{<0}M_U=0,\qquad + F_0M_U=R^1g_*(\mathcal B|_{S_U}). +\] +In a smooth ambient embedding \(S_U\hookrightarrow V\) of +codimension \(c\), the underlying module of \(A_{0,U}\) is +\(\mathcal H^c_{S_U}(\omega_V)\), localized off \(J_U\). +The lowest-piece inclusion is the adjunction, or Ext-to-support, +inclusion off \(J_U\), extended by meromorphic localization. +\end{lemma} + +\begin{proof} +The difference triangle for the constant objects of \(S_U\) and +\(J_U\), together with Du Bois comparison, identifies its +degree-zero graded de Rham complex with +\(\mathcal I_{J_U/S_U}\). Coherent duality and the +maximal-Cohen--Macaulay property therefore give +\begin{equation}\label{proj:hg:derived-lowest} + \Gr^F_k\DR(A^\bullet_U)=0\quad(k<0), + \qquad + \Gr^F_0\DR(A^\bullet_U)=\mathcal B|_{S_U}[0]. +\end{equation} +The shift \([N]\) cancels the dimension shift in the dualizing +complex. In the smooth case this convention says +\(\mathbf D(\Q^H[N])=\Q^H[N](N)\); its right differential module +has lowest piece \(\omega\) at index zero. + +We spell out the passage from the complex to perverse cohomology. +Let \(q\) be the smallest filtration index occurring in any +perverse cohomology object of \(A^\bullet_U\), locally on a fixed +chart. Such a lower bound exists because the complex is bounded +and its filtrations are good. At index \(q\), the graded Spencer +complex of every perverse cohomology object has only its +degree-zero term. The spectral sequence from perverse truncation +therefore has a single nonzero row and gives +\[ + \mathcal H^i\Gr^F_q\DR(A^\bullet_U) + =F_q\,{}^p\!H^iA^\bullet_U. +\] +If \(q<0\), this contradicts Equation~\eqref{proj:hg:derived-lowest}. +Thus all these objects have \(F_{<0}=0\). Applying the same +argument at index zero gives \(F_0A_{0,U}=\mathcal B|_{S_U}\), +and gives zero for the lowest piece of the other perverse +cohomology objects. No perversity assertion about the shifted +constant complex is required. + +For the unfiltered description, duality identifies the dual of the +reduced constant complex, in the ambient \(V\), with +\[ + R\Gamma_{[S_U]}(\omega_V)[c]. +\] +Its degree-zero module is the first nonzero support cohomology +\(\mathcal H^c_{S_U}(\omega_V)\). The support of \(J_U\) is locally +set-theoretically principal in \(S_U\), by the construction. +Invert a local defining function, lifted to \(V\); this exact +meromorphic localization realizes \(j_*\) on the underlying +module. It yields the asserted description of \(A_{0,U}\). + +We also need compatibility of the two descriptions of its lowest +piece. On the smooth locus of \(S_U\setminus J_U\), filtered +duality and smooth graph pushforward identify it with the ordinary +dualizing sheaf included by residue. This is the Ext-to-support +inclusion, with the normalization fixed by the ambient adjunction +isomorphism. Naturality in smooth etale coordinates fixes the +same scalar on every chart. Agreement extends over +\(S_U\setminus J_U\): the first support-cohomology module has no +sections supported on a smaller-dimensional subset. For example, +this follows from the Cousin resolution of the smooth dualizing +sheaf, whose first term supported on \(S_U\) is a sum of injective +modules at its codimension-\(c\) generic points. It extends across +\(J_U\) by localization. Hence the inclusion is the one stated +in the lemma, not merely an abstract isomorphism of coherent +sheaves. + +Finally use a graph embedding followed by a smooth projection to +compute \(g_+\). At filtration zero the relative Spencer complex +has only its top term, namely the direct image of +\(\mathcal B|_{S_U}\) on the graph. Projective strictness gives +\[ + F_{<0}M_U=0,\qquad + F_0M_U=R^1g_*(\mathcal B|_{S_U}), +\] +and identifies this sheaf with its actual submodule in the +unfiltered degree-one direct image. The constructions used here +are canonical on etale changes of charts. +\end{proof} + +\subsection{Lifting through the infinitesimal neighborhoods} + +Let \(I=\OO_{\mathcal X}(-S)\). The etale object \(S_U\to S\) +extends uniquely and compatibly over every nilpotent thickening +\(qS\); denote its extension by \(qS_U\). +These are quasi-projective schemes by +Proposition~\ref{proj:prop:signed-construction}: they are separated +and quasi-finite over \(X\), hence are open in schemes finite over +the projective variety \(X\). Powers and quotients of \(I\) below +are pulled back to the respective thickenings. + +\begin{proposition}\label{proj:prop:formal-lifting} +For every such chart \(U\), every \(j\geq0\), and every \(k\geq1\), +the transition +\[ + g_*(I^j/I^{j+k+1}) + \longrightarrow g_*(I^j/I^{j+k}) +\] +is surjective as a map of sheaves of abelian groups. Its kernel is +\(\OO_{\mathcal T_U}\otimes C^{-j-k}\), where +\(\mathcal T_U=\mathcal T\times_{\mathcal Y}U\). +The statements are compatible with further etale changes of +charts. On an affine chart, these transitions are also +surjective on global sections. +\end{proposition} + +\begin{proof} +Define +\[ + E_{j,k}=g_*(I^j/I^{j+k}),\qquad j\geq0,\quad k\geq1. +\] +Here \(g_*\) uses the underlying topological map. We do not +assume that a thickening already has a ringed-space map to \(U\). +The first graded layer is +\[ + E_{j,1}=\OO_{\mathcal T_U}\otimes C^{-j}. +\] +The exact sequence for adjacent lengths has kernel +\(g_*\OO_{S_U}\otimes C^{-j-k}\), and its connecting homomorphism +takes values in +\[ + R^1g_*\OO_{S_U}\otimes C^{-j-k}. +\] + +Induct on \(k\), proving the assertion simultaneously for all \(j\). +Assume all shorter transitions are surjective. A section of +\(E_{j,k}\) with zero length-one term comes from \(E_{j+1,k-1}\) +when \(k>1\). By induction it locally lifts from \(E_{j+1,k}\), +so its connecting class is zero. Also \(E_{j,k}\to E_{j,1}\) +is surjective. For \(k=1\) the factorization is immediate. +The obstruction therefore factors through a map \(D_k\) on the +graded algebra of length-one layers, with graded shift \(k\). +Choose local lifts and take their Cech differences. The +difference of a product is the sum of the two first-order +differences; products of the errors vanish in the layer at issue. +Thus \(D_k\) is a \(\C\)-derivation from this graded algebra to +the graded \(R^1g_*\OO_{S_U}\)-module. + +In degree zero, restrict it along +\(\OO_U\to\OO_{\mathcal T_U}\). The resulting derivation factors +through \(\Omega_U^1\), hence defines a section of +\(T_U\otimes R^1g_*\OO_{S_U}\otimes C^{-k}\). +These local sections descend to +\begin{equation}\label{proj:hg:obstruction-section} + e\in H^0\!\left( + \mathcal Y,T_{\mathcal Y}\otimes R^1g_*\OO_S\otimes C^{-k} + \right) + = + H^0\!\left( + \mathcal Y,T_{\mathcal Y}\otimes F_0M\otimes C^{-(a+k)} + \right). +\end{equation} +The equality uses Equation~\eqref{proj:hg:geometric-lines}, +Lemma~\ref{proj:hg:lowest-piece}, and projection formula. +For descent, lifts of functions pull back on the unique etale +thickenings. Their Cech classes pull back by ordinary flat base +change for the coherent obstruction sheaves on the reductions. +Differentials pull back and generate under an etale map, proving +the asserted compatibility. + +Shrink \(U\) and take etale coordinates \(t_1,\ldots,t_d\), +where \(d=\dim U\), and a frame of \(C^{-1}\). Its pullback is +a conormal frame, denoted by \(y\). By induction lift the +coordinates along \(g\) modulo \(I^k\), and lift \(y\) to +\(I/I^{k+1}\). On an open cover of \(S_U\), lift these one step +further, obtaining functions \(h_{i,\lambda}\) modulo \(I^{k+1}\) +and generators \(y_i\) modulo \(I^{k+2}\). Formal etaleness of +the coordinate map makes each \(h_i\) a local map from +\((k+1)S_U\) to \(U\). On overlaps write +\begin{equation}\label{proj:hg:coordinate-errors} + h_{j,\lambda}-h_{i,\lambda} + =e_{ij,\lambda}y_i^k, + \qquad + y_j-y_i=\eta_{ij}y_i^{k+1}. +\end{equation} +The reduced coefficients are Cech cocycles representing +\(D_k(t_\lambda)\) and \(D_k(y)\) in the chosen frames. +Let \(\sigma=y^{-a}\) denote the induced frame of +\(\mathcal B|_{S_U}\). + +Off \(J_U\), the fixed adjunction isomorphism gives +\[ + \omega_{(k+1)S_U} + \simeq\OO_{\mathcal X}((a+k)S)|_{(k+1)S_U}. +\] +It therefore defines local dualizing sections +\(b_i=y_i^{-(a+k)}\). Under the trace inclusion +\(\omega_{S_U}\hookrightarrow\omega_{(k+1)S_U}\), the identities +\begin{equation}\label{proj:hg:dualizing-errors} + b_j-b_i=-(a+k)\eta_{ij}\sigma,\qquad + y_i^kb_i=\sigma,\qquad y_i^{k+1}b_i=0 +\end{equation} +hold when the dualizing sheaves are realized in support +cohomology. Indeed the first identity is the binomial expansion +of \((1+\eta_{ij}y_i^k)^{-(a+k)}\); its quadratic terms vanish +because \(2k\geq k+1\). The other two identities describe +Cartier trace and the annihilator of the thickening. + +Embed \((k+1)S_U\) as a closed subscheme of a smooth open +\(Z\subset\overline Z=\PP^m\). The graph of the reduced map +\(g\) is closed in \(\overline Z\times U\), by its properness over +\(U\). Use this reduced graph for an ambient realization of +\(A_{0,U}\). Each local graph lift \(h_i\) maps \(b_i\), by +Ext-to-support cohomology, to a section \(\delta_i(b_i)\) of the +underlying graph module. We claim that +\begin{equation}\label{proj:hg:graph-identity} + \delta_j(b_j)-\delta_i(b_i) + = + -(a+k)\eta_{ij}\sigma + +\sum_{\lambda=1}^d + (e_{ij,\lambda}\sigma)\cdot\partial_{t_\lambda}. +\end{equation} +The reduced dualizing sections on the right use the inclusion +of Lemma~\ref{proj:hg:lowest-piece}. + +Here is the local calculation, including the non-smooth case. +Put \(c_0=\dim Z-N\). +The Ext-to-support map identifies the dualizing sheaf of the +thickening with its annihilator submodule in +\(\mathcal H^{c_0}_{S_U}(\omega_Z)\). One can obtain this from +the support-cohomology spectral sequence: there is no support +cohomology below \(c_0\), so in total degree \(c_0\) the Ext +group is the homomorphisms from the thickening's structure sheaf +into that first support-cohomology module. Thus the calculation +does not require \(S_U\) to be a local complete intersection in +\(Z\). + +Lift \(h_{i,\lambda}\) locally to functions on \(Z\). In +\(Z\times U\), the graph inclusion on a thickness-dualizing +section \(b\) is the generalized fraction +\[ + \frac{b\,dt_1\wedge\cdots\wedge dt_d} + {\prod_{\lambda=1}^d(t_\lambda-h_{i,\lambda})}. +\] +This is successive support cohomology in the additional +coordinate equations, or equivalently the Koszul residue for +the graph. It may be computed etale-locally near the graph +branch. After first taking support cohomology from \(Z\), the +translated new coordinates form a regular sequence, so their +support cohomology is concentrated in their top number. +Localization in either set of translated coordinates gives the +same localization on this support-torsion module: the two +translations differ nilpotently on every section. + +Changing from \(h_i\) to \(h_j\) therefore gives a finite Taylor +expansion on \(b_j\). Products of two differences in +Equation~\eqref{proj:hg:coordinate-errors} annihilate \(b_j\), again +because \(2k\geq k+1\). Its linear term uses +\[ + (h_{j,\lambda}-h_{i,\lambda})b_j + =e_{ij,\lambda}\sigma. +\] +For a top differential form the right action satisfies +\[ + \left(\frac{dt_\lambda}{t_\lambda-h}\right) + \cdot\partial_{t_\lambda} + =\frac{dt_\lambda}{(t_\lambda-h)^2}. +\] +Consequently the doubled pole has the positive sign displayed in +Equation~\eqref{proj:hg:graph-identity}. Together with +Equation~\eqref{proj:hg:dualizing-errors}, this proves that identity. +The calculation initially takes place off \(J_U\). The sections +and identities extend meromorphically across \(J_U\) in the +\emph{unfiltered} localized module; arbitrary finite pole orders +there are allowed. + +Now push by \(\overline Z\times U\to U\), using relative +Spencer. If \(i\) denotes the closed reduced graph embedding and +\(\pi\) the projection, closed direct image is perverse exact and +\(\pi_+i_+A_{0,U}=g_+A_{0,U}\). Thus degree-one holonomic +differential-module cohomology of this Spencer direct image is +precisely the underlying module of +\(M_U={}^{p}\!H^1g_*A_{0,U}\). +The cochain \((\delta_i(b_i))\) lies in its top, +degree-zero term, which has no outgoing relative Spencer +differential. Its Cech difference is therefore a boundary in +total degree one. A sufficiently refined ambient cover around +the closed graph computes this assertion; all sheaves involved +are supported there. The reduced cocycles in +Equation~\eqref{proj:hg:graph-identity} represent their +\(R^1g_*\mathcal B\) classes inside \(F_0M\), by +Lemma~\ref{proj:hg:lowest-piece}. Right differentiation in the +\(U\)-coordinates acts on the pushforward complex. +Hence the right side of Equation~\eqref{proj:hg:graph-identity} +represents zero in the unfiltered module \(M\). + +That right side lies in \(F_1M\); the term involving \(\eta\) +lies in \(F_0M\). Since \(F_1M\) is an actual subsheaf of \(M\), +its vanishing in \(M\) is vanishing in \(F_1M\). Taking the +order-one symbol thus says that the global section \(e\) of +Equation~\eqref{proj:hg:obstruction-section} is killed by +\begin{equation}\label{proj:hg:symbol-map} + T_{\mathcal Y}\otimes F_0M + \longrightarrow \Gr^F_1M, +\end{equation} +after twisting by \(C^{-(a+k)}\). +This reasoning places no Hodge-filtration bound on the +auxiliary cochain \((b_i)\). + +There is no term preceding degree \(-1\) in +\(\Gr^F_1\DR(M)\), because \(F_{<0}M=0\). Its degree-\(-1\) +hypercohomology after the indicated twist is therefore precisely +the space of global sections of the kernel of +Equation~\eqref{proj:hg:symbol-map}. Since \(a+k>0\), +Lemma~\ref{proj:hg:negative-vanishing} makes that space zero. +We conclude that \(e=0\). + +In a local coordinate and line trivialization, this says that +every class \([e_{ij,\lambda}\sigma]\) is already zero in +\(F_0M\), hence in \(M\). Its actual differential-operator image +is consequently zero, before taking symbols. The unfiltered +relation now gives +\[ + (a+k)[\eta_{ij}\sigma]=0. +\] +Lowest-piece injectivity and \(a+k>0\) imply \(D_k(y)=0\). +The degree-zero derivation is zero as well: it vanishes on +\(\OO_U\), which surjects onto \(\OO_{\mathcal T_U}\). +Locally the whole graded length-one algebra is generated by +that coefficient algebra and the conormal frame \(y\). +Thus \(D_k=0\) in every degree, proving the induction and all +sheaf transitions. + +Their kernels are the coherent sheaves +\(\OO_{\mathcal T_U}\otimes C^{-j-k}\). On an affine \(U\) +these have no first cohomology. The exact sequences of sheaves +of abelian groups therefore also give surjectivity on global +sections. Choosing lifts successively gives compatible formal +lifts of any chosen functions on \(\mathcal T_U\), and, when +\(C\) is trivialized, of its transverse conormal frame. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_induction.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_induction.tex new file mode 100644 index 0000000000000000000000000000000000000000..4b47fd3837dd90188eb0b2487cd13598b67c9f89 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_induction.tex @@ -0,0 +1,484 @@ +\section{The inductive framework}\label{proj:sec:induction} + +All varieties in this section are projective over \(\C\). +We first isolate the established minimal-model results that will be +used, and explain exactly where the new signed-representative theorem +enters the induction. + +For an effective real boundary \(\Delta\), a good log minimal model of +\((X,\Delta)\) is a log minimal model on which the adjoint divisor is +semiample. For real divisors, semiampleness means real linear equivalence +to the pullback of an ample real divisor by a contraction. We allow the +usual definition of a log minimal model in which extracted prime +divisors are included in its boundary with coefficient one. +For a pseudo-effective divisor \(A\), we use +\(\kappa_\sigma(X,A)\) for Nakayama's numerical dimension. When \(A\) +is nef this agrees with the intersection-theoretic numerical dimension +\(\nu(X,A)\). + +Fix an integer \(n\geq 1\). +\begin{assumption}[Lower-dimensional good models]\label{proj:mmp:lower-models} +Every projective log canonical pair of dimension less than \(n\), +with real boundary and pseudo-effective adjoint divisor, has a good +log minimal model. +\end{assumption} + +The dimension-zero case is immediate. Our inductive step will first +prove smooth nonvanishing in dimension \(n\) under +Assumption~\ref{proj:mmp:lower-models}, and then apply +Proposition~\ref{proj:prop:inductive-reduction} below. +The propositions on boundary restrictions and special termination +preceding that reduction do not assume smooth nonvanishing in +dimension \(n\). + +\subsection{Comparison and boundary restrictions} + +\begin{lemma}[Comparison with a nef model]\label{proj:mmp:comparison} +Let \((X,\Delta)\) be log canonical and let \((X',\Delta')\) +be a log minimal model. On a common resolution +\[ + X \xleftarrow{u} W \xrightarrow{v} X' +\] +there is an effective \(v\)-exceptional divisor \(F\) such that +\begin{equation}\label{proj:mmp:comparison-equation} + u^*(K_X+\Delta)=v^*(K_{X'}+\Delta')+F. +\end{equation} +If \(K_X+\Delta\) is nef, then \(F=0\). Consequently a nef +rational adjoint is semiample whenever it has a good log minimal +model. If \((X,\Delta)\) is klt, its log minimal model is klt and +extracts no divisors. +\end{lemma} + +\begin{proof} +Put \(F=u^*(K_X+\Delta)-v^*(K_{X'}+\Delta')\). +Discrepancy improvement on divisors of \(X\) gives \(u_*F\geq 0\), +while \(-F\) is \(u\)-nef because \(K_{X'}+\Delta'\) is nef. +The negativity lemma therefore gives \(F\geq 0\). +At a prime of \(W\) that is not \(v\)-exceptional, the coefficient +of \(F\) is zero unless that prime is extracted on \(X'\). +In the latter case it equals the negative of its log discrepancy +over \((X,\Delta)\). It is therefore nonpositive, and hence zero. +Thus \(F\) is \(v\)-exceptional. If the source adjoint is nef, +then \(F\) is also \(v\)-nef, so the negativity lemma gives \(F=0\). + +Equality of the pullbacks transfers semiampleness, since a proper +birational morphism onto a normal variety has direct image of its +structure sheaf equal to the structure sheaf. More explicitly, +global sections of a Cartier multiple and its pullback coincide; +generation upstairs implies generation downstairs. +Finally, for a klt source the coefficient at an extracted prime +would be strictly negative, which is impossible. The remaining +discrepancy inequalities show that the model is klt. +\end{proof} + +\begin{proposition}[Semiampleness on the reduced boundary] +\label{proj:prop:boundary-restriction} +Assume Assumption~\ref{proj:mmp:lower-models}. Let \((V,D)\) be a +projective \(\Q\)-factorial dlt \(n\)-fold with \(D\) reduced and +\(M=K_V+D\) nef. Then \(M|_D\) is semiample as a rational line +bundle on the reduced scheme \(D\). +\end{proposition} + +\begin{proof} +The ambient variety \(V\) is klt. The reduced floor of a +\(\Q\)-factorial dlt pair is \(S_2\), and it has ordinary double +crossings in codimension one; its irreducible components are normal. +For the \(S_2\) assertion one can work locally with the cyclic +class cover of the \(\Q\)-Cartier divisor \(D\). This cover is +quasi-\'etale and klt, hence Cohen--Macaulay. The eigensheaf +\(\OO_V(-D)\), being a direct summand of its finite direct image, +is Cohen--Macaulay. The divisor sequence then shows that \(D\) +is Cohen--Macaulay. + +Divisorial adjunction on the normalization +\(\coprod D_i\to D\) gives lc pairs +\((D_i,\operatorname{Diff}_{D_i}(D-D_i))\). +The different includes the conductor with coefficient one. +Removing that conductor contribution defines an effective boundary +on \(D\); together with \(D\) it is an slc pair whose adjoint +line bundle is \(M|_D\). The divisible residue identifications +hold in codimension one, with even powers eliminating residue +signs at double crossings, and extend by \(S_2\). + +Each normalized adjoint is nef and semiample by +Assumption~\ref{proj:mmp:lower-models} and +Lemma~\ref{proj:mmp:comparison}. +Semiampleness descends from the normalization by the slc gluing +theorem \cite[Theorem~1.5, equivalently Theorem~4.3] +{FujinoGongyoPluricanonical}. This gives the required statement on the +whole reduced scheme, not merely on its individual components. +\end{proof} + +\subsection{The special termination needed below} + +\begin{proposition}[Special termination over a point] +\label{proj:prop:special-termination} +Assume Assumption~\ref{proj:mmp:lower-models}. +Let \((V,\Delta)\) be a projective \(\Q\)-factorial dlt +\(n\)-fold with rational boundary and pseudo-effective adjoint. +Choose an effective ample rational divisor \(A\) such that +\((V,\Delta+A)\) is dlt and \(K_V+\Delta+A\) is nef. +The LMMP for \(K_V+\Delta\) with scaling of \(A\) has special +termination: if the program is infinite, its flipping loci +are eventually disjoint from the round-down of the boundary. + +In particular, if at every stage the adjoint is rationally linearly +equivalent to a signed divisor supported on that round-down, the +program terminates at a log minimal model. +\end{proposition} + +\begin{proof} +In an infinite ample-scaling program the scaling limit is zero: +a positive limit is covered by the termination theorem for a +dlt pair with an ample summand in the scaling divisor +\cite[Theorem~1.9(ii), equivalently Theorem~4.1(ii)] +{Proj-Birkar2012Special}. Discard the finitely many divisorial +contractions and write the flips as \(V_i\dashrightarrow V_{i+1}/Z_i\), +with scaling numbers \(\lambda_i>0\) tending to zero. +Fix a component \(S_1\) of \(\lfloor\Delta_1\rfloor\), write +\(S_i\) for its normal strict transform, and let \(T_i\) be the +normalization of its image in \(Z_i\). Since the ambient contraction +is small, \(S_i\to T_i\) is projective birational. The standard +discrepancy argument makes \(S_i\dashrightarrow S_{i+1}\) +an isomorphism in codimension one after finitely many steps +\cite[proof of Lemma~3.6]{Proj-Birkar2010}. + +Here are the precise auxiliary relative programs in that argument. +Take a small projective \(\Q\)-factorialization +\(p_i:S'_i\to S_i\), and put +\[ + D_i=K_{S'_i}+B_i=p_i^*((K_{V_i}+\Delta_i)|_{S_i}), + \qquad C_i=p_i^*(A_i|_{S_i}). +\] +Adjunction gives a dlt pair \((S'_i,B_i)\), with \(B_i,C_i\geq0\), +and \((S'_i,B_i+\lambda_i C_i)\) is lc. The scaling divisor +has no floor component, so its restriction is effective. +The number \(\lambda_i\) is rational, being the ratio of +intersections of rational divisors on the contracted rational curve. +The globally nef divisor +\(L_i=K_{V_i}+\Delta_i+\lambda_i A_i\) descends rationally +linearly across \(V_i\to Z_i\). Indeed, for sufficiently small +rational \(\delta>0\), the pair +\((V_i,(1-\delta)\Delta_i)\) is klt and its negative adjoint +is ample over \(Z_i\). Relative basepoint freeness applies to a +Cartier multiple of \(L_i\); its numerical triviality and the +connected fibers give descent. Restricting and pulling back yields +\[ + D_i+\lambda_i C_i\sim_{\Q}0/T_i. +\] + +By \cite[Theorem~1.1(3)]{Proj-Birkar2012Special}, a \(D_i\)-LMMP +over \(T_i\) with scaling of a fresh ample divisor terminates. +The theorem applies to the effective rational lc boundary +\(B_i+\lambda_i C_i\), with \(\lambda_i C_i\) rational Cartier +and the driving pair \(\Q\)-factorial dlt. Since the base map +is birational, the endpoint is a log minimal model, not a Mori +fiber space. Comparison with the relatively ample model +\(S_{i+1}\) identifies this endpoint with a small +\(\Q\)-factorialization \(S'_{i+1}\), as in +\cite[Remarks~2.9--2.10]{Proj-Birkar2012Special}. + +These finite relative programs are genuine pieces of an absolute +program with scaling of the transforms of \(C_1\). +Throughout the \(i\)-th piece, \(D_i+\lambda_i C_i\) remains +the pullback of a nef divisor on \(T_i\), hence is globally nef. +Every contracted negative ray has positive \(C_i\)-degree, +so its global scaling threshold is exactly \(\lambda_i\). +The relative cone is a face of the absolute cone, cut out by +the pullback of an ample divisor on the projective base \(T_i\); +its extremal rays are therefore absolute extremal rays. +Thus the pieces concatenate as asserted in the cited remarks. +Rescaling the initial scaling divisor by \(\lambda_1\), if +necessary, makes its sum with the initial boundary lc and nef. + +If the concatenation were infinite, its positive scaling numbers +would tend to zero. Its initial adjoint is pseudo-effective: +for each late scaling value, pull back the corresponding nef +scaled adjoint and use the effective comparison divisor for +the preceding nonpositive steps, then take the limit. +Assumption~\ref{proj:mmp:lower-models} therefore gives an absolute +log minimal model for that initial pair. The concatenation +terminates by \cite[Theorem~1.9(iii)]{Proj-Birkar2012Special}, since +its zero limit is never attained. The floor-component argument +of \cite[Lemma~3.6]{Proj-Birkar2010} now gives special termination. +No effective representative in dimension \(n\), nor any +arbitrary relative good-model assertion, has been used. + +For the final assertion, a curve disjoint from the round-down +has degree zero against any signed divisor supported there. +It therefore cannot generate an adjoint-negative flipping ray. +Special termination rules out all sufficiently late flips. +There are only finitely many divisorial contractions, since +each lowers the Picard number, and pseudo-effectivity excludes +a Mori fiber space as the endpoint. Thus the endpoint is nef. +\end{proof} + +\subsection{A uniform trivial-perturbation argument} + +\begin{lemma}\label{proj:mmp:trivial-perturbation} +Let \((Z,\Delta)\) be a projective \(\Q\)-factorial dlt rational +pair, and suppose \(L=K_Z+\Delta\) is nef. +Set \(P=\Delta\) if the pair is klt and +\(P=\lfloor\Delta\rfloor\) otherwise. +Fix \(m>0\) such that \(mL\) is Cartier. +For every rational +\[ + 0<\epsilon<\frac{1}{4nm+2}, +\] +every step of an LMMP for \(L-\epsilon P\) is \(L\)-trivial. +On all its models, the transform of \(L\) is nef and its +multiple by the same integer \(m\) is Cartier. +\end{lemma} + +\begin{proof} +Both \(\Delta-\epsilon P\) and \(\Delta-\tfrac12P\) are +effective klt boundaries. If \(R\) is a ray negative for +\(L-\epsilon P\), nefness of \(L\) shows that \(R\) is also +negative for \(L-\tfrac12P\). +Choose a rational curve \(C\) spanning this ray and satisfying +the length bound +\[ + -\bigl(L-\tfrac12P\bigr)\cdot C\leq 2n. +\] +Writing \(a=L\cdot C\geq 0\) and \(p=P\cdot C\), we have +\[ + p\leq 2a+4n,\qquad a<\epsilon p, + \qquad + (1-2\epsilon)a<4n\epsilon. +\] +Our choice of \(\epsilon\) gives \(a<1/m\). +Since \(ma\) is a nonnegative integer, \(a=0\). + +For the driving klt contraction, the line bundle +\(\OO_Z(mL)\) is numerically trivial over the contraction base. +The line-bundle clause of the contraction theorem gives its +descent as a line bundle, with no change of \(m\) +\cite[Theorem~3.74(3)]{Proj-Fujino2017}. +One may also see the unchanged index directly from relative +basepoint freeness: two consecutive sufficiently large powers +descend, so their quotient descends. +For a flip, pull this descended line bundle back on the other +side. The transformed \(L\) is nef, and \(mL\) remains Cartier. + +The driving boundary remains klt throughout its LMMP. +The transformed \(\Delta-\tfrac12P\) remains effective and +is smaller than the driving boundary, so it too is klt. +The same estimate and the same integer \(m\) apply inductively +at every subsequent step. +\end{proof} + +\subsection{Completion of the good-model step} + +\begin{proposition}[Inductive reduction to smooth nonvanishing] +\label{proj:prop:inductive-reduction} +Assume Assumption~\ref{proj:mmp:lower-models}. Assume in addition that +every smooth projective \(n\)-fold with pseudo-effective +canonical divisor has nonnegative Kodaira dimension. +Then every projective lc \(n\)-fold with real boundary and +pseudo-effective adjoint has a good log minimal model. +In particular, every nef rational lc adjoint in dimension \(n\) +is semiample. +\end{proposition} + +\begin{proof} +Hashizume's reduction gives nonvanishing and log minimal models +for projective lc pairs with real boundary in dimensions at most +\(n\) \cite[Theorem~1.4]{Proj-Hashizume2018}. +Thus we may pass to a \(\Q\)-factorial dlt log minimal model. +Fix the support of its boundary, impose the rational affine +constraints that its coefficient-one components remain equal +to one, and take a sufficiently small rational polytope around +the given boundary within those constraints. On a fixed log +resolution witnessing dlt, the strict discrepancy inequalities +remain strict in this neighborhood; thus its boundaries remain +dlt. The rational-polytope theorem for nef adjoints +\cite[Remark~3.1 and Proposition~3.2(3)]{Proj-Birkar2011II}, applied +to all extremal rays and intersected with this neighborhood, +expresses the given real boundary in a finite rational simplex +of dlt boundaries with nef adjoints. +It is enough to prove semiampleness for these +rational adjoints. Their positive real combinations are +semiample, using the product of the associated contractions. +For a rational adjoint, real semiampleness can also be +rationalized: the finite linear equations expressing its +divisor and principal-divisor coefficients have rational data, +so a real solution with positive coefficients has a rational +solution with the same positivity. + +We therefore work with a rational dlt pair \((Z,\Delta)\) and +\(L=K_Z+\Delta\) nef. +Real nonvanishing gives rational nonvanishing in this case: +retain the finitely many divisors and principal divisors in +an effective real representative and solve the resulting +rational linear system with nonnegative rational coefficients. +If \(\kappa(Z,L)\geq 1\), lower-dimensional good models give a +good minimal model by \cite[Lemma~3.5]{Proj-FujinoGongyoRings2014}. +Lemma~\ref{proj:mmp:comparison} transfers semiampleness back to \(Z\). +It remains to treat +\[ + \kappa(Z,L)=0. +\] + +\paragraph{The non-pseudo-effective perturbation.} +Put \(P=\Delta\) in the klt case and +\(P=\lfloor\Delta\rfloor\) in the other case. +Suppose \(L-\epsilon P\) is not pseudo-effective for every +sufficiently small \(\epsilon>0\). +Choose rational \(\epsilon\) as in +Lemma~\ref{proj:mmp:trivial-perturbation}, and run the klt LMMP +with scaling to a Mori fiber space +\[ + (Z,\Delta-\epsilon P)\dashrightarrow + (Z',\Delta'-\epsilon P')\xrightarrow{f} T. +\] +Existence and termination in the non-pseudo-effective case are +the established klt results of \cite{BCHM}. +The program is crepant for \(L\). +The line-bundle descent in +Lemma~\ref{proj:mmp:trivial-perturbation}, applied also to the final +contraction, gives a nef rational divisor \(A\) on \(T\) with +\[ + K_{Z'}+\Delta'\sim_{\Q}f^*A. +\] +The base has dimension less than \(n\). + +If \((Z,\Delta)\) is klt, the transformed original pair +\((Z',\Delta')\) is klt as well. Ambro's descent theorem +\cite[Theorem~0.2]{Proj-Ambro2005} gives an effective rational +boundary \(\Delta_T\) such that \((T,\Delta_T)\) is klt and +\[ + A\sim_{\Q}K_T+\Delta_T. +\] +All its hypotheses hold: the total pair is globally klt and +effective, \(f\) is a projective contraction, and its adjoint +is rationally linearly pulled back. In particular, this use +requires no conjecture about semiampleness of a moduli divisor. +Assumption~\ref{proj:mmp:lower-models} and +Lemma~\ref{proj:mmp:comparison} make \(A\) semiample. + +Otherwise \(P'\) is effective and relatively ample, since +\(K_{Z'}+\Delta'-\epsilon P'\) is relatively antiample. +Some component of the floor therefore dominates \(T\). +On a dlt blowup of the original lc pair \((Z',\Delta')\), +choose the strict transform \(S\) of such a component. +Adjunction produces an lc pair on \(S\) whose nef adjoint +is the pullback of \(A\). +It is semiample by the lower-dimensional hypothesis. +Semiampleness of a rational line bundle descends along a proper +surjection: use the equality of sections for its connected-fiber +Stein factor, and norms for the remaining finite morphism. +For the latter assertion, a basepoint-free system has a section +nonzero at every point of a chosen finite fiber; its norm is +nonzero at the point downstairs. Hence \(A\) is semiample +also in this case. Crepancy transfers the conclusion back to \(L\). + +\paragraph{The klt pseudo-effective perturbation.} +We next settle the klt case when \(L-\epsilon\Delta\) is +pseudo-effective for some small rational \(\epsilon>0\). +Nonvanishing gives +\[ + L\sim_{\Q}G_0:=H_0+\epsilon\Delta,\qquad H_0\geq 0. +\] +Take a resolution \(p\colon W\to Z\) with reduced SNC divisor +\(D\) consisting of all exceptionals and the strict support of +\(H_0+\Delta\). We have +\[ + K_W+D=p^*L+R,\qquad R\geq 0. +\] +Here every component of \(D\) has positive coefficient in +\[ + G_W:=p^*G_0+R\sim_{\Q}K_W+D. +\] +Indeed, at strict boundary components the difference between +coefficient one and a klt boundary coefficient is positive, +and at exceptional components the coefficient contributed by +the adjoint comparison is the positive log discrepancy. +The pushforward \(p_*G_W\) is bounded coefficientwise by a +fixed multiple of \(G_0\). Section spaces inject under +birational pushforward, so +\[ + 0\leq\kappa(W,K_W+D)\leq\kappa(Z,G_0)=0. +\] + +Take a \(\Q\)-factorial dlt log minimal model +\((V,D_V)\) of \((W,D)\). +Its boundary is reduced. On a common resolution, the comparison +divisor in Lemma~\ref{proj:mmp:comparison} is exceptional over \(V\). +Pushing the pullback of \(G_W\) to \(V\) therefore gives +\[ + K_V+D_V\sim_{\Q}G_V=\sum_i b_iD_i,\qquad b_i>0, + \qquad \Supp G_V=D_V. +\] +For completeness, positivity at a component extracted on \(V\) +also holds: its log discrepancy over \((W,D)\) is zero, its +center lies in \(D\), and the pullback of the full-support +effective \(G_W\) has positive order there. +There is no comparison-divisor coefficient at a prime retained +on \(V\). +Effectivity and exceptionality in the comparison preserve the +adjoint section ring, so the nef adjoint on \(V\) still has +Iitaka dimension zero. + +The small-perturbation hypothesis of +Theorem~\ref{proj:thm:signed} is now explicit. +If \(D_V\neq 0\), choose rational \(c\) with +\(00\) so that both +\[ + L-\epsilon P,\qquad L-2\epsilon P, + \qquad P=\lfloor\Delta\rfloor, +\] +are pseudo-effective klt adjoints. +Their Iitaka dimensions are zero: nonvanishing gives the lower +bound, and adding the effective perturbation bounds each by +\(\kappa(Z,L)=0\). +The klt result just proved gives good models for both. +Consequently their Nakayama numerical dimensions are zero. +Since +\[ + 2(L-\epsilon P) + =L+(L-2\epsilon P) +\] +and the last summand has an effective rational representative, +monotonicity and homogeneity of \(\kappa_\sigma\) give +\[ + \kappa_\sigma(Z,L) + \leq\kappa_\sigma\bigl(Z,2(L-\epsilon P)\bigr)=0. +\] +The nef divisor \(L\) is therefore numerically trivial. +Nonvanishing is already available in this finishing step: +write \(L\sim_{\Q}E\geq 0\). +For an ample divisor \(H\), the equality +\(E\cdot H^{n-1}=0\) forces \(E=0\). +Thus \(L\sim_{\Q}0\), without any additional nonvanishing or +abundance premise. + +All rational nef dlt adjoints are now semiample. +The polytope reduction gives the real-boundary good-model +assertion, and Lemma~\ref{proj:mmp:comparison} gives the final +statement for every nef rational lc adjoint. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_introduction.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..ced1776fd97184c1da6745346af0428df259119c --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_introduction.tex @@ -0,0 +1,137 @@ +\section{Conditional projective log abundance}\label{proj:sec:introduction} + +Appendices~\ref{proj:sec:introduction}--\ref{proj:sec:completion} +establish the conditional projective abundance theorem used in the main +proof. Its logarithmic-Iitaka premise, +Assumption~\ref{proj:asm:iitaka}, follows from the reduction in Lemma~\ref{red:log-iitaka}. We give the complete argument, including +its signed-boundary, current-theoretic, and Frobenius constructions. + + + +The log abundance conjecture asserts that a nef log canonical divisor +on a projective log canonical pair is semiample. Its conclusion turns a +numerical positivity condition into a morphism defined by pluricanonical +sections. In the minimal model program, abundance complements the +existence of minimal models: a nef adjoint should determine the +appropriate canonical fibration. The existence and finite-generation +theorems for big klt adjoints are central foundations of this program +\cite{BCHM}. The lower-dimensional reductions relevant here are +developed in \cite{Proj-Hashizume2018,Proj-FujinoGongyoRings2014}. + +These appendices prove the full rational-boundary assertion under one +explicit subadditivity assumption. The result is a positive +\emph{conditional} resolution of the log abundance conjecture. +It is not an unconditional abundance theorem. + +\subsection{The assumption and the theorem} + +\begin{assumption}[Logarithmic Iitaka subadditivity]\label{proj:asm:iitaka} +Let \(f:X\to Y\) be a surjective morphism with connected fibers between +smooth connected projective complex varieties. Let \(D_X,D_Y\) be +reduced effective simple normal crossing divisors, allowing zero +boundaries, such that +\[ + \Supp(f^*D_Y)\subseteq\Supp(D_X). +\] +For a very general smooth fiber \(F\), put \(D_F=D_X|_F\). Then +\[ + \kappa(X,K_X+D_X)\ge + \kappa(F,K_F+D_F)+\kappa(Y,K_Y+D_Y). +\] +Here \(D_F\) is reduced with simple normal crossings and +\(K_F+D_F\sim(K_X+D_X)|_F\). The convention +\((-\infty)+b=-\infty\) applies also when \(b=-\infty\), and the zero +divisor on a point has Iitaka dimension zero. +\end{assumption} + +Assumption~\ref{proj:asm:iitaka} requires no nefness, abundance, bigness, +or good-model hypothesis, and does not require \(f\) to be smooth +away from the boundary. The divisor \(D_X\) may contain additional +components. No fractional-boundary, +orbifold, nonprojective, Hodge-conjectural, or arithmetic extension is +assumed. In fact, the proof uses only \(D_X=D_Y=0\), in the Albanese +reduction in Appendix~\ref{proj:sec:exclusions}. + +\begin{theorem}[Conditional log abundance]\label{proj:thm:main}\label{proj:main}\label{proj:conditional-log-abundance} +Assume Assumption~\ref{proj:asm:iitaka}. Let \(k\) be an algebraically closed +field of characteristic zero, and let \((X,B)\) be a normal projective log +canonical pair over \(k\), where \(B\) is an effective \(\Q\)-divisor +and \(K_X+B\) is \(\Q\)-Cartier. If \(K_X+B\) is nef, then it is +semiample: for some integer \(m>0\), the divisor \(m(K_X+B)\) is +Cartier and \(\OO_X(m(K_X+B))\) is generated by its global sections. +\end{theorem} + +\subsection{Main constructions} + +The proof proceeds by simultaneous induction on smooth nonvanishing +and existence of good log minimal models, as set out in +Appendix~\ref{proj:sec:induction}. Its principal constructions are as follows. + +First, Appendices~\ref{proj:sg:section}--\ref{proj:sg:descent} prove an abundance +criterion for a nef reduced dlt adjoint +that has a \emph{signed} rational representative supported on its +boundary. Semiampleness on that boundary is supplied inductively. +A normalized root construction separates its positive and negative +parts. An infinitesimal obstruction is placed in the lowest piece of +a projective Hodge-module direct image. Negative-ample vanishing on +a finite cover of a root gerbe kills the obstruction. Algebraization +then produces compact numerically trivial subvarieties, and nef +reduction yields rational-linear descent to a big divisor on a base. + +Second, Appendix~\ref{proj:sec:exclusions} subjects a hypothetical smooth +nonvanishing counterexample to geometric exclusions. Algebraic webs and positive currents force +very-general proper subvarieties to be of general type. An ascending +chain condition for the Lelong numbers of a fixed current at valuations +of bounded discrepancy converts asymptotically small intersection gaps +into exact zero gaps. This rules out canonical-class positive currents +that are pulled back from a lower-dimensional base on a dense open, +as well as moving curves of bounded normalized degree and genus. + +Third, Appendices~\ref{proj:sec:jets} and~\ref{proj:fr:section} compare two jet +estimates. Moving base-locus estimates on a projective bundle over a +product create a large Seshadri constant while the corresponding +one-factor section orders remain small. After all geometric choices +have been fixed, reduction modulo large primes converts these two +estimates into incompatible determinant multiplicities. The Frobenius +diagonal filtration and a uniform curve-slope bound are the numerical +ingredients of this final comparison. + +These constructions are proved below; they are not additional parts +of Assumption~\ref{proj:asm:iitaka}. Established results from the minimal +model program, Hodge modules, and positivity theory are invoked with +their hypotheses at the point of use. The order of the induction is +important: the proof of smooth nonvanishing in dimension \(n\) uses +good models only in dimensions below \(n\). +Appendix~\ref{proj:sec:completion} closes the induction and transfers the +complex conclusion to arbitrary algebraically closed fields of +characteristic zero. + +\subsection{Conventions} + +A variety is integral. Canonical divisors are chosen compatibly on +birational models. For a divisor \(E\) on a smooth model +\(p:W\to X\), our log discrepancy is +\[ + a(E;X,B)=1+\ord_E\bigl(K_W-p^*(K_X+B)\bigr). +\] +Log canonicity means nonnegative log discrepancies, and klt means +strictly positive log discrepancies. We use the usual dlt and slc +conventions. A \(\Q\)-Cartier divisor \(L\) is nef if \(L\cdot C\ge0\) +for every integral curve \(C\). Its numerical dimension, when nef, is +\[ + \nu(L)=\max\{j: L^jH^{\dim X-j}>0\}, +\] +with \(H\) ample. For non-nef pseudo-effective divisors, statements +about numerical dimension use Nakayama's \(\kappa_\sigma\), as +specified in the relevant reduction. These notions are not +interchanged without a hypothesis that justifies doing so. + +The Iitaka dimension is the maximum dimension of the images of the +complete systems of integral multiples, and is \(-\infty\) when all +these systems are empty. Numerical and rational-linear equivalence +are denoted by \(\equiv\) and \(\sim_{\Q}\), respectively. Unless a +different base field is specified, the constructions are over \(\C\). +A very general point avoids a countable union of proper closed +subvarieties. The transfer to arbitrary algebraically closed +characteristic-zero fields is made only after the complex argument +has been completed. diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_jets.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_jets.tex new file mode 100644 index 0000000000000000000000000000000000000000..98a6cf5177646912b5040d9f3f46467af1959ed7 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_jets.tex @@ -0,0 +1,800 @@ +\section{Very-general jet estimates}\label{proj:sec:jets} + +We retain the counterexample in Equation~\eqref{proj:ex:counterexample} +and the induction hypothesis of Assumption~\ref{proj:mmp:lower-models}. +Thus \(X\) is smooth projective, +\(K_X\) is pseudo-effective, and \(\kappa(X,K_X)=-\infty\), whereas +good minimal models exist in smaller dimensions. We use +Propositions~\ref{proj:prop:general-type}, \ref{proj:prop:bounded-curves}, and +\ref{proj:prop:signed-alternative}. Dimension one is impossible, since a +smooth curve with pseudo-effective canonical divisor has genus at least +one. Hence \(n=\dim X\ge2\). + +Fix the late terminal \(\Q\)-factorial model \(Y\) from +Proposition~\ref{proj:prop:bounded-curves}. Write \(K=K_Y\) and \(A=A_Y\). +The subsequent scaling models \(Y_t\) are small modifications of \(Y\); +the transforms \(A_t\) are effective up to \(\Q\)-linear equivalence, +and \(K_t+tA_t\) is nef, big, and semiample. Put +\[ + \mu_t=\vol(X,K_X+tA)^{1/n}. +\] +Here, in the volume on \(X\), \(A\) denotes the original ample divisor. +We have \(\mu_t\to0\). Choose an integer \(m>0\) with \(mK\) Cartier. + +\subsection{Normalization and two local tools} + +Fix a small rational number \(\epsilon>0\). An integer \(q>0\) will +be chosen after \(\epsilon\) and before \(t\). As rational \(t\downarrow0\), +choose positive integers \(r=r(t)\) with +\begin{equation}\label{proj:jet:normalization} + r\mu_t\longrightarrow\epsilon,\qquad + L=r(K+tA),\qquad L_b=L+bmK\quad(0\le b\le q). +\end{equation} +Only rational weights \(b\) are used for model constructions; +volume functions in integrals are extended continuously to real weights. +The positive part of \(L_b\) is +the nef semiample class +\[ + N_b=(r+bm)(K_s+sA_s) + \quad\hbox{on }Y_s,\qquad s=\frac{rt}{r+bm}. +\] +When emphasizing the weight, denote this axis model by \(Y(b)=Y_s\) +and write \(A_b\) for its transform of \(A\). +All references to positive parts below mean these classes on their +scaling models, or their pullbacks to common resolutions. Monotonicity +of volume in pseudo-effective order gives +\begin{equation}\label{proj:jet:volume-comparison} + \vol(L)\le \vol(L_b)\le + \left(1+\frac{qm}{r}\right)^n\vol(L). +\end{equation} +Indeed \(L_b-L=bmK\) is pseudo-effective, and +\((1+bm/r)L-L_b=bmtA\) is effective up to equivalence. +Consequently \(N_b^n\) is bounded above and bounded away from zero, +uniformly for \(b\in[0,q]\), and tends uniformly to \(\epsilon^n\). +More explicitly, for every fixed \(q\), once \(t\) is sufficiently +small depending on \(q\), +\begin{equation}\label{proj:jet:uniform-normalized-volume} + \frac{\epsilon^n}{2}\le N_b^n\le2\epsilon^n + \qquad(0\le b\le q). +\end{equation} +The displayed constants are independent of \(q\). +All unspecified constants in this section may depend on +\(n,\epsilon,q,Y,A,m\), but not on sufficiently small \(t\) or on \(b\). + +A family of curves with uniformly bounded geometric genus and +\(N_b\)-degree cannot cover the corresponding \(Y_s\) for arbitrarily +small \(t\). In fact \(s/t\to1\) uniformly in \(b\), and +\[ + (r+bm)\mu_s=\vol(L_b)^{1/n} +\] +is bounded above and away from zero. Thus such curves would have +uniformly bounded \((K_s+sA_s)\)-degree divided by \(\mu_s\), contrary +to Proposition~\ref{proj:prop:bounded-curves}. We call this consequence the +\emph{normalized curve exclusion}. + +The following numerical form of subadjunction is useful because an +auxiliary pair need only be lc at the generic point of its center. +All intersections with a divisor on a possibly nonnormal center mean +intersections after normalization and resolution. + +\begin{lemma}[Numerical subadjunction]\label{proj:jet:subadjunction} +Let \(Z\) be projective and \(\Q\)-factorial klt, let +\(\Theta\ge0\) be rational, and let \(V\) be an lc center of +\((Z,\Theta)\) at whose generic point the pair is lc. +If \(f=\dim V>0\), \(P\) is a nef \(\Q\)-Cartier class on \(V\), and +\(V^*\to V\) is a resolution, then +\begin{equation}\label{proj:jet:subadjunction-bound} + K_{V^*}P^{f-1}\le (K_Z+\Theta)|_V P^{f-1}. +\end{equation} +\end{lemma} + +\begin{proof} +The dlt modification for an arbitrary effective boundary +\cite[Theorem~2.10]{Proj-FujinoHashizume2023}, applied after truncating +coefficients exceeding one, gives +\[ + K_Q+B+E=p^*(K_Z+\Theta), +\] +where \(Q\) is \(\Q\)-factorial, \((Q,B)\) is dlt, and \(E\ge0\) +is supported above the non-lc locus. Choose, over the generic point +of \(V\), a minimal lc stratum, and denote its closure by \(S\). +The divisor \(E\) does not contain \(S\). Iterated dlt adjunction, +including the effective restriction of \(E\), produces an effective +divisor \(B_S\) with +\[ + K_S+B_S\sim_{\Q} + (p|_S)^*((K_Z+\Theta)|_V). +\] +The pair is klt over the generic point of \(V\); singularities elsewhere +are not asserted to be klt. + +Factor \(S\to V^\nu\) through its Stein base \(V'\). This is a +klt-trivial fibration: generic klt, effectivity of the boundary, and +connected fibers give the rank-one condition. The canonical bundle +formula, in precisely this generically subklt form, gives a +discriminant and a b-nef moduli b-divisor +\cite[Definition~3.1 and Theorem~3.5]{Proj-FujinoGongyoModuli2014}. +The discriminant trace on \(V'\) is effective. To see the sign, +over a generic base prime a divisor in its inverse image has +multiplicity at least one and a nonnegative boundary coefficient; +the lc threshold of the fiber is therefore at most one. +Coefficients exceeding one in the discriminant cause no difficulty +for the present inequality. + +Intersect the resulting base formula with the pullback of \(P^{f-1}\). +The moduli term is nonnegative: on a model where it is nef this is a +nef intersection, and exceptional terms vanish on pushing down. +The effective discriminant is also nonnegative. Finally the +codimension-one ramification formula for the finite map +\(V'\to V^\nu\), followed by projection, can only increase the +canonical intersection. Discrepancy terms on resolutions have +images of codimension at least two and pair trivially with the +pulled-back \(P^{f-1}\). Dividing by the finite degree gives +Equation~\eqref{proj:jet:subadjunction-bound}. +\end{proof} + +\begin{lemma}[Tracking a moving base component]\label{proj:jet:tracking} +Let \(P\) be nef, semiample, and big on a projective \(d\)-fold \(Z\). +Work at very general smooth marked points \(x\). Choose \(d+1\) +levels +\[ + \tau_0<\tau_1<\cdots<\tau_d,\qquad + \tau_{i+1}-\tau_i=\delta>0. +\] +Suppose, in sufficiently large divisible degree \(k\), all the spaces +\[ + {\cal V}_{i,x} + =H^0\bigl(Z,kP\otimes\mathfrak m_x^{\lceil k\tau_i\rceil}\bigr) +\] +are nonzero, and the base locus of \({\cal V}_{0,x}\) has a +positive-dimensional component through \(x\). +Then one obtains an algebraic family of integral components \(V=V_x\) +sweeping \(Z\), of dimension \(01\), cut by +\(f-1\) general members of \(|H|\). The resulting integral curves +have bounded \(P\)-degree and are birational to linear curve +sections of a projective variety of bounded degree. Generic plane +projection bounds their geometric genus. For \(f=1\), the +canonical-degree bound already bounds the genus. +The same argument works for a log smooth pair of log general type +with reduced boundary, using coefficients in the fixed set +\(\{1\}\) in effective birationality. + +If such components sweep an ambient space mapping to \(Y\), and +their curves project nonconstantly with \(N_b\)-degree bounded by +their \(P\)-degree, we obtain forbidden covering curves on \(Y_s\). +Nonconstant projection follows by choosing the complete intersections +generally for the big birational system. The curves can be +parameterized in covering algebraic families: the components sweep, +the choices can avoid any prescribed countable exceptional union, +and Hilbert schemes and spaces of maps have only countably many +components. We will use this consequence of +Equation~\eqref{proj:jet:curve-input} repeatedly. + +\begin{proposition}[Scalar jet bound]\label{proj:prop:scalar-jets} +For sufficiently small \(t\), let \(P\) be the positive part of +\(2r(K+2tA)\), and put \(\rho=(P^n)^{1/n}\). +At a very general point, every nonzero section of every divisible +multiple \(kP\) has order at most \(4k\rho\). +The same statement holds on a common resolution after adding an +effective exceptional divisor that does not change the section +spaces. Moreover +\[ + 2r\mu_t\le\rho\le4r\mu_t, +\] +so in particular \(\rho\le8\epsilon\) for small \(t\). +\end{proposition} + +\begin{proof} +The volume bounds follow from pseudo-effectivity of \(K\): +\[ + \vol(K+tA)\le\vol(K+2tA)\le2^n\vol(K+tA). +\] +Suppose the asserted order bound fails for arbitrarily small \(t\). +Taking powers of the offending section permits arbitrarily large +divisible degrees. Choose \(n+1\) levels strictly between \(\rho\) +and \(4\rho\), with equal gaps comparable to \(\rho\). +All corresponding subseries are nonzero. The base point at the +lowest level cannot be isolated: local Bezout for \(n\) general +members would exceed the total intersection \(k^nP^n\). +Lemma~\ref{proj:jet:tracking} therefore supplies a moving proper +positive-dimensional component \(V\). + +The component is of general type by +Proposition~\ref{proj:prop:general-type}. On the scaling model for +\(K+2tA\), the effective transform of \(A\) does not contain a +general such component, and +\(K_Z|_V\le(2r)^{-1}P|_V\) in effective order. +Equations~\eqref{proj:jet:tracking-estimates} consequently imply +Equation~\eqref{proj:jet:curve-input} with constants uniform in \(t\); +the gap is bounded above and away from zero because +\(\rho\) is comparable to the fixed \(\epsilon\). +The resulting bounded-genus, bounded-normalized-degree covering +curves contradict Proposition~\ref{proj:prop:bounded-curves}. +Exceptional additions preserve sections and their orders at +general points, proving the additional assertion. +\end{proof} + +\subsection{The two-slot bundle} + +On \(Y\times Y\), let +\begin{equation}\label{proj:jet:two-slot} + Z_0=\PP(mK_1\oplus mK_2),\qquad + \xi=\OO_{Z_0}(1),\qquad M=L_1+L_2+q\xi. +\end{equation} +We use the convention that sections of \(k\xi\) are symmetric powers +of the indicated direct sum. Fixing one base slot gives the +one-slot bundle +\(\PP(\OO_Y\oplus mK)\), with class \(L+q\xi\), up to a constant +line from the fixed slot. We call it a \emph{slice}. +The torus open in either bundle is the complement of its two axes. + +\begin{lemma}[Models, volume, and weights]\label{proj:jet:bundle-models} +Both the total class \(M\) and the slice class have big semiample +positive parts \(P\) on \(\Q\)-factorial klt models \(Z\), with +\[ + K_Z+\Delta\sim_{\Q}c_tP,\qquad \Delta\ge0, +\] +where \(c_t\) is bounded independently of small \(t\). +Their volumes satisfy, respectively, +\begin{align} + \vol(M)&=\frac{(2n+1)!}{(n!)^2} + \int_0^q\vol(L_b)\vol(L_{q-b})\,db,\label{proj:jet:total-volume}\\ + \vol(L+q\xi)&=(n+1)\int_0^q\vol(L_b)\,db.\label{proj:jet:slice-volume} +\end{align} +In particular both volumes are bounded above and below by positive +constants times \(q\). For each rational weight, on common +resolutions, +\begin{equation}\label{proj:jet:weight-domination} + P\sim_{\Q}N_{b,1}+N_{q-b,2}+E_b,\qquad E_b\ge0, +\end{equation} +with the analogous one-term formula on slices. +At a generic point of a base divisor of a slice, and on a general +torus fiber, the full system has no fixed subtraction. +\end{lemma} + +\begin{proof} +The product \(Y\times Y\) is \(\Q\)-factorial. Indeed on a product +resolution the Picard group has no cross term because the smooth +models have irregularity zero; the two factorwise +\(\Q\)-factorial descent statements then apply. Products of +canonical singularities are canonical, and the projective bundles +are klt. The two disjoint Cartier axes form a plt boundary \(D\), +and +\[ + K_{Z_0}+D=K_{\rm sum},\qquad + D\sim2\xi-mK_{\rm sum}. +\] +The notation \(K_{\rm sum}\) means \(K_1+K_2\), or \(K\) on a slice. + +For \(0<\sigma\le1\), put +\[ + \gamma=2\sigma+\frac{q(1+\sigma m)}r,\qquad + \Xi_t\sim_{\Q}\xi+ + \frac{(1+\sigma m)t}{\gamma}A_{\rm sum}. +\] +Both endpoint weight systems are big, so there are effective +rational representatives of \(\Xi_t\) containing neither axis. +We first obtain a threshold bound independent of \(\sigma\). +Restrict to \(00\) on the original space. +The same reasoning on the axes gives, after decreasing \(\eta\), +the same bound for both restricted divisors. + +Now choose rational \(0<\sigma<\min\{1,\eta/4\}\), independently of +\(q,t\), and then take \(t\) small enough that +\(t\le\sigma/(1+m)\) and \(q(1+\sigma m)/r<\sigma\). +It follows that \(\gamma<3\sigma<\eta\). +Inversion of adjunction with the disjoint coefficient-one axes +gives plt near them; away from them the threshold bound gives klt. +Lowering their coefficients to \(1-\sigma\) consequently shows that +\[ + (Z_0,(1-\sigma)D+\gamma\Xi_t) +\] +is klt. This choice respects the order: first \(\epsilon\), then +\(q\), then sufficiently small \(t\) with \(r\) as in +Equation~\eqref{proj:jet:normalization}. +A direct calculation gives its adjoint class +\[ + K_{Z_0}+(1-\sigma)D+\gamma\Xi_t + \sim_{\Q}\frac{1+\sigma m}{r}M. +\] +The big klt adjoint has a good minimal model by +\cite{BCHM}. Pushing the boundary to this model gives the stated +\(\Delta\) and \(c_t=(1+\sigma m)/r\). + +For the volumes, the weight-\(l\) summand in degree \(k\) has base +classes \(kL_{l/k}\) and \(kL_{q-l/k}\); on a slice there is one +such factor. The section decomposition and asymptotic Riemann--Roch +give Equations~\eqref{proj:jet:total-volume}--\eqref{proj:jet:slice-volume} +as Riemann sums. One can justify passage to the integral without +assuming uniform asymptotic Riemann--Roch: partition \([0,q]\) into +rational bins, compare weight classes in each bin by adding and +subtracting the bin width times a fixed very ample divisor +dominating both \(mK\) and \(-mK\), take divisible-degree limits, +and then shrink the bins. Volume continuity gives the formulas. +Equation~\eqref{proj:jet:volume-comparison} supplies their uniform bounds +and, in particular, proves bigness used above. +In the range of Equation~\eqref{proj:jet:uniform-normalized-volume}, +the bounds needed when choosing \(q\) are explicitly +\[ + \vol(M)\ge \frac{(2n+1)!}{4(n!)^2}\,q\epsilon^{2n}, + \qquad + \vol(L+q\xi)\le2(n+1)q\epsilon^n. +\] +Their coefficients are independent of \(q\); the smallness threshold +for \(t\) is allowed to depend on \(q\). + +Compare a complete system on a common resolution with the subsystem +at a fixed rational weight. The latter has fixed divisor consisting +of its toric monomial and the base-model fixed differences. +Subtracting the fixed divisor of the full system leaves an effective +divisor \(E_b\); its moving class is precisely the sum of the +pullbacks of the indicated \(N_b\)'s. This proves +Equation~\eqref{proj:jet:weight-domination}. The same comparison in +individual sufficiently divisible degrees shows that every section +at that weight, after the full fixed subtraction, contains the +corresponding multiple of \(E_b\). + +At a generic base-divisor point the small base-model maps are +isomorphisms. The two endpoint systems are free there in divisible +degree, so together they have no common zero on the projective-line +fiber. The full system therefore has no fixed subtraction there. +The same holds on a general fiber. Finally, when restricting +Equation~\eqref{proj:jet:weight-domination} to a component sweeping the +torus open, choose a general component not contained in +\(\Supp E_b\). There are only countably many rational weights, so +these effective restrictions can be required simultaneously. +\end{proof} + +For a nef \(\Q\)-Cartier class \(P\) on a projective variety \(Z\) +and a smooth point \(x\in Z\), its Seshadri constant is +\[ + \varepsilon(P;x)= + \inf_{\substack{C\subset Z\ \mathrm{integral\ curve}\\x\in C}} + \frac{P\cdot C}{\mult_x C}. +\] + +\begin{proposition}[Large two-slot Seshadri constant]\label{proj:prop:large-seshadri} +For each fixed sufficiently small \(\epsilon>0\), there is an integer +\(q>0\) such that, for all sufficiently small rational \(t>0\) and +\(r\) as in Equation~\eqref{proj:jet:normalization}, the positive part +\(P\) of Equation~\eqref{proj:jet:two-slot} has +\[ + \varepsilon(P;x)>2n+2 +\] +at a very general smooth point of its torus open. +In particular, for some sufficiently divisible integer \(k>0\), +the complete system \(|kP|\) separates jets of order strictly +greater than \((2n+2)k\) at such a point. +The section spaces and these general-point jets agree on the +original bundle and on common birational resolutions. +\end{proposition} + +\begin{proof} +Write \(d=2n+1\). Choose \(q\) sufficiently large that the volume +root in Equation~\eqref{proj:jet:total-volume} admits \(d+1\) levels above +\(2n+3\), with equal gap \(\delta\) as large as needed below. +This is possible uniformly for small \(t\), since the volume is +bounded below by a positive constant times \(q\). +Assume that the Seshadri assertion fails for arbitrarily small \(t\). +Jet counts show that the systems at all these levels are nonzero +in sufficiently large divisible degree. A curve through the marked +point with degree-to-multiplicity ratio below the lowest level is +contained in that system's base locus. Such a curve exists from +the assumed Seshadri bound, whether or not the infimum defining +the constant is attained. Lemma~\ref{proj:jet:tracking} supplies a +moving proper component \(V\) and both estimates +\eqref{proj:jet:tracking-estimates}. + +For all moving components under consideration, the effective +boundary \(\Delta\) of Lemma~\ref{proj:jet:bundle-models} does not contain +the component. Thus \(K_Z|_V\le c_tP|_V\) in effective order. +Whenever \(V\) is of general type, the curve construction following +Equation~\eqref{proj:jet:curve-input} and weight domination give a +contradiction. We must also handle components that are not +generically finite over a proper base image. + +\paragraph{Restriction to a slice.} +Fix a general value of one slot projection of \(V\), and suppose +the corresponding fiber component \(F\) has +\(0<\dim F0\). We construct a small adjoint on \(W\), since the +ruled \(F\) itself need not be of general type. In degree \(k\), +expand every section of the high-vanishing slice subseries into +its toric weights. At the generic point of \(W\), let \(I_l\) be +the ideal generated by the coefficients of the nonzero weight \(l\) +over all these sections. Put \(h=\lceil k\delta/2\rceil\). +All \(I_l\) lie in \(\mathfrak m_W^h\): vanishing along the generic +torus fiber says that the coefficient of every Laurent monomial +vanishes to this order. Their sum is +\(\mathfrak m_W\)-primary. Otherwise its larger common zero germ, +times the generic torus fiber, would contradict isolation of \(F\). + +Work in the regular local ring at the generic point of \(W\), of +dimension \(c=\codim W\). Resolve the finitely many ideals +simultaneously and consider the rational lc polytope +\[ + u_l\ge0,\qquad + \sum_lu_l\ord_E(I_l)\le a(E;Y,0). +\] +Include the exceptional divisor of the blowup of the closed point. +Since every \(I_l\subset\mathfrak m_W^h\), it gives +\(\sum_lu_l\le c/h\). The polytope is compact and has a positive +rational maximum for \(\sum_lu_l\). At a maximizing point, each +coordinate participates with positive order in an active +inequality; otherwise that coordinate could be increased. +The corresponding lc center \(C_l\) is contained in \(V(I_l)\) +and contains the generic point of \(W\). Their intersection is +contained in \(V(\sum_l I_l)\), which is \(W\) locally. The +intersection property for lc centers +\cite[Theorem~1.7]{Proj-KollarKovacs2010}, applied to the identity +morphism on the lc open, therefore makes \(W\) an lc center +generically. To realize the ideals, choose an integer +\(M_0>\max_l u_l\) and \(M_0\) general coefficient divisors +\(D_{l,j}\) from each system. Set +\(\Theta=\sum_l(u_l/M_0)\sum_{j=1}^{M_0}D_{l,j}\). +On the simultaneous resolution its fixed crepant coefficients are +at most one, and its general moving divisors meet transversely +with coefficients below one. Thus the pair is lc near the generic +point of \(W\), and every active valuation remains an lc place. +The intersection argument therefore applies to this actual +effective rational divisor. It also applies when some maximizing +coordinate \(u_l\) is zero: the active valuation blocking that +coordinate still has center in \(V(I_l)\). + +Set +\[ + b=\frac{\sum_lu_l(l/k)}{\sum_lu_l}, + \qquad c'=k\sum_lu_l\le\frac{kc}{h}. +\] +Its class on the base is \(c'L_b\). Transform to the small scaling +model for \(L_b\), which is unchanged at the generic point under +consideration. There its class is \(c'N_b\). Lemma +\ref{proj:jet:subadjunction}, effective \(A_b\), and +Equation~\eqref{proj:jet:saturated-degree} give bounded adjoint +intersection and bounded \(N_b^w\)-degree for \(W\). +Since \(c'\) is bounded by a dimension-dependent multiple of +\(1/\delta\), these bounds are uniform in \(t\). +The variety \(W\) is of general type by +Proposition~\ref{proj:prop:general-type}; normalized curve exclusion +again gives a contradiction. + +\paragraph{A slice multisection.} +The remaining proper positive-dimensional slice case is +\(\dim F=n\), with \(F\) generically finite of degree \(e\) over +the whole base. Weight comparison and the slice degree bound give +\[ + eN_b^n\le P^n.F, +\] +so \(e\) is bounded uniformly in \(t\). +The closure of \(F\) on the original bundle is neither axis. +Its intersections with the two axes push to effective integral +Weil divisors \(D_1,D_2\) on \(Y\), and the projective-bundle +relation gives +\begin{equation}\label{proj:jet:axis-signed} + D_1-D_2\sim_{\Q} \pm emK. +\end{equation} +At the appropriate endpoint weight \(b\in\{0,q\}\), the difference +\(E_b|_F\) contains the corresponding toric-axis intersection with +coefficient \(q\). There is no full fixed subtraction above +generic base-divisor points by Lemma~\ref{proj:jet:bundle-models}. +Intersecting with \(N_b^{n-1}\) and using mixed nef comparison yields +\[ + qN_b^{n-1}.D_i\le P^n.F. +\] +The other divisor has bounded degree for the same \(N_b\), because +of Equation~\eqref{proj:jet:axis-signed} and +\[ + 0\le K_{Y(b)}N_b^{n-1}\le\frac{N_b^n}{r+bm}. +\] +On a log resolution add the reduced strict support of +\(D_1+D_2\) and all exceptional divisors to the canonical divisor. +This log canonical divisor is big by +Proposition~\ref{proj:prop:signed-alternative}. +Its intersection with the pulled-back \(N_b^{n-1}\) is bounded: +exceptionals vanish under projection, and reduced support has +degree no larger than \(D_1+D_2\). +Log effective birationality and the curve construction therefore +contradict normalized curve exclusion on the base itself. + +\paragraph{Reduction to a correspondence.} +We have excluded fiber dimensions strictly between zero and +\(n+1\) over either slot. A full \((n+1)\)-dimensional fiber over +one slot would mean that \(V\) contains the whole opposite slice +over its first image \(W\). Its fiber dimension over the other +slot would then be \(\dim W+1\), strictly between zero and \(n+1\), +unless \(V\) were the full total space. That is impossible. +Hence \(V\) projects generically finitely in both slots and +\(\dim V\le n\). If either image is proper, general type and the +total-space estimates give the previous curve contradiction. +The same is true if \(V\) is of general type. +Only the case \(\dim V=n\), dominant with bounded degree over both +copies of \(Y\), remains. + +\paragraph{Moving branch divisors.} +Take the dominating algebraic family of these correspondences, +resolving maps after shrinking the parameter space. Suppose a +divisorial branch component of one projection moves. On a +resolution \(V^*\), choose a ramified divisor \(R\) above its generic +point. There is a rational weight \(b\) for which the effective +difference \(E_b|_{V^*}\) does not contain \(R\). +Indeed take a fixed free divisible degree of \(P\); some section +does not vanish generically on \(R\). Monomial-weight sections +span that degree, so one of them does not vanish there. +Only finitely many weights are tested in this fixed family; their +model comparisons can be resolved simultaneously. + +Let \(J\) be the branch divisor on the corresponding small axis +model. Nef comparison on \(R\), ramification into a terminal +target, and pseudo-effectivity of its canonical divisor give +\begin{equation}\label{proj:jet:branch-degree} + N_b^{n-1}.J\le P^{n-1}.R + \le K_{V^*}P^{n-1}\le C_q. +\end{equation} +The ramification coefficient of \(R\) is a positive integer, so is +at least one; the other ramification and exceptional terms are +nonnegative. The last bound is the total-space subadjunction +estimate. + +We spell out the adjunction needed for \(J\), without assuming +\((Y(b),J)\) globally lc. Terminal \(Y(b)\) is smooth in codimension +two. Thus normalization and conductor adjunction along \(J\) +give +\[ + K_{J^\nu}+C=(K_{Y(b)}+J)|_{J^\nu},\qquad C\ge0 +\] +in codimension one. On resolving \(J^\nu\), exceptional divisors +map to codimension at least two and pair trivially with the +pulled-back \(N_b^{n-2}\). Consequently, with +\(d_J=N_b^{n-1}.J\), +\begin{align} + K_{J^*}N_b^{n-2} + &\le (K_{Y(b)}+J)J N_b^{n-2}\notag\\ + &\le \frac{d_J}{r+bm}+\frac{d_J^2}{N_b^n} + \le C'_q d_J.\label{proj:jet:branch-adjunction} +\end{align} +For the second line, a general moving \(J\) is not a component of +a fixed effective representative of \(A_b\), giving the first +term; mixed Hodge index gives the second. The lower bound for +\(N_b^n\) and Equation~\eqref{proj:jet:branch-degree} give the final +uniform constant. + +A moving \(J\) sweeps very general base points and is of general +type by Proposition~\ref{proj:prop:general-type}. +Equations~\eqref{proj:jet:branch-degree}--\eqref{proj:jet:branch-adjunction} +therefore give forbidden bounded curves. Branch components can +be named after a finite parameter extension and shrinking. +It follows that, for all sufficiently small \(t\), all divisorial +branch components in the chosen family are fixed. + +\paragraph{Fixed covers.} +For each such fixed \(t\), remove the fixed branch divisors and +the singular locus from \(Y\). Normalization and purity identify +the covers over the resulting smooth open with finite etale +covers. Their degrees are bounded. The topological fundamental +group of a smooth complex quasi-projective variety is finitely +generated, so it has only finitely many subgroups of bounded +index. There are therefore only finitely many possible covers +in each slot, up to isomorphism; their finite normalizations over +\(Y\) are determined by these restrictions. + +Some algebraic family of graphs of birational isomorphisms between +two fixed covers must still dominate the base product. To justify +the family assertion, parameterize the graphs by their Hilbert +schemes, shrink for flatness and birationality of the two +projections, and use countability of these parameter spaces +together with the finite cover choices. Identify the two covers +by one such birational isomorphism. The resulting birational +selfmaps of a fixed cover move a general point densely through +that cover, since their projected graphs dominate \(Y\times Y\). + +The cover is non-uniruled, being generically finite over the +non-uniruled \(Y\). Hanamura's non-uniruled birational-group +theorem gives a smooth projective birational model for which the +reduced birational group is a group scheme, locally of finite type, +and its identity component is an abelian variety +\cite[Theorems~2.1--2.2]{Proj-Hanamura1988}; +see also \cite[Proposition~3.7 and Theorems~3.8--3.9]{Proj-Blanc2017}. +After conjugating the maps to that model, shrink the irreducible +parameter variety anew so that their graph closures are flat +and both graph projections remain birational on every fiber. +They then define a morphism to the represented birational scheme; +because the parameter variety is reduced, this morphism factors +through its reduction. Its connected image lies in a single +component, hence in a translate of the identity component. +Dominance of evaluation makes the corresponding +abelian variety action generically transitive. Its orbit is an +abelian-variety quotient, so the fixed cover is birational to an +abelian variety. + +This is impossible for the original counterexample. Resolve the +generically finite rational map from that abelian variety to \(X\): +on a smooth model \(U\), ramification gives +\[ + K_U=f^*K_X+R,\qquad R\ge0, +\] +whereas \(K_U\) is an effective divisor exceptional over the +abelian variety. Let \(T\) be a positive current in \(K_X\). +The current \(f^*T+[R]\) is positive and represents \(K_U\). +Intersecting with powers of the ample class pulled back from the +abelian variety shows that this sum is supported on the exceptional +locus. Its positive summand \(f^*T\) is therefore supported there +as well, and the support theorem makes \(f^*T\) divisorial. +Push forward this summand alone: \(f_*(f^*T)\) is a positive +divisorial current whose class is \(\deg(f)c_1(K_X)\) by the +projection formula. Rationality of the numerical class supplies +a rational effective representative, and irregularity zero turns +numerical effectivity into nonvanishing, as in +Lemma~\ref{proj:ex:irregularity}. This contradicts +\(\kappa(X,K_X)=-\infty\). + +All possible \(V\) have now been excluded. This proves the +Seshadri assertion. At a very general point the big semiample +contraction is an isomorphism onto its image near that point. +The jet interpretation of the Seshadri constant for the ample +class downstairs gives the stated divisible jet-separating +multiple. Complete systems agree under the model comparisons, +so this conclusion transfers to the original torus open and to +common resolutions. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_signed_descent.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_signed_descent.tex new file mode 100644 index 0000000000000000000000000000000000000000..27e5164b946bed6ce97dfb48ab88d7b1295c54f9 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_signed_descent.tex @@ -0,0 +1,282 @@ +\section{Compact null families and descent} +\label{proj:sg:descent} + +We return to the setting of Theorem~\ref{proj:thm:signed}, with +$00$. + +Consequently $G_Y=\pi^*G$ is vertical and is relatively +nef, since $G_Y\sim_{\Q}\pi^*L$. Lemma~\ref{proj:sg:vertical-descent} +gives +\[ + \pi^*L\sim_{\Q}f^*G_B +\] +for a $\Q$-divisor $G_B$ on the smooth base. +It is nef: every curve of $B$ is dominated by a curve +of $Y$, on which the pullback has nonnegative degree. +The intersection formula for a pullback gives +$\nu(X,L)\le b$. Combined with $b\le v$, this yields +$b=v$ and $G_B^b>0$. Therefore $G_B$ is big. +Pulling back sections gives +$\kappa(X,L)\ge b=v$, and the general inequality +$\kappa(X,L)\le\nu(X,L)$ for a nef divisor proves +abundance. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_signed_geometry.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_signed_geometry.tex new file mode 100644 index 0000000000000000000000000000000000000000..4646d9db1b3331b12a62a3ee2ff4654f345a6935 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/appendices/projective_signed_geometry.tex @@ -0,0 +1,391 @@ +\section{Geometry of a signed boundary representative} +\label{proj:sg:section} + +The next statement isolates the extension argument needed in the +induction. Its boundary is reduced, but its prescribed representative +need not be effective. + +\begin{theorem}[Signed representative]\label{proj:thm:signed} +Let $(X,D)$ be a projective $\Q$-factorial dlt pair over $\C$, with +$D=\sum_iD_i$ reduced. Suppose that +\[ + L=K_X+D\quad\text{is nef},\qquad L-cD\quad\text{is pseudo-effective} + \quad\text{for some }c>0, +\] +and that +\[ + L\sim_{\Q}G=\sum_i a_iD_i,\qquad a_i\in\Q. +\] +If $L|_D$ is semiample as a rational line bundle on the reduced scheme +$D$, then $L$ is abundant: +\[ + \kappa(X,L)=\nu(X,L). +\] +\end{theorem} + +The proof occupies this section, the Hodge-theoretic lifting argument +of Proposition~\ref{proj:prop:formal-lifting}, and the descent argument in +Appendix~\ref{proj:sg:descent}. No Iitaka subadditivity assumption is used +in this theorem. + +\subsection{The positive boundary and its small intersections} + +Write +\[ + G=G_+-G_-,\qquad D_0=\sum_{a_i=0}D_i, +\] +where $G_+$ and $G_-$ are effective with disjoint prime supports. +Choose a positive integer $m$ such that $mG_\pm$, $mD_0$, and $mL$ +are integral Cartier divisors and +\[ + N_0=\OO_X(mG)\simeq\OO_X(mL). +\] +Increase $m$ so that $N_0|_D$ is generated by global sections. Fix the +resulting morphism +\[ + \phi:D\longrightarrow P=\PP^s,\qquad + N_0|_D\simeq\phi^*\OO_P(1), +\] +and let $s_0$ be the rational section of $N_0$ with divisor $mG$. +Set $n=\dim X$ and $v=\nu(X,L)$, and fix an ample Cartier divisor $H$. + +\begin{lemma}\label{proj:sg:numerical-boundary} +If $v=n$, then $L$ is big. If $v=0$, then $D=0$ and +$L\sim_{\Q}0$. In the remaining case $00$. On a component of $D$, the numerical dimension +of $L|_D$ equals its image dimension under $\phi$. The preceding +vanishing gives the upper bound $r$. On the other hand, +\[ + 00$, and +\[ + a(F;V',0)=a(F;V',B')+\ord_F(B')>0. +\] +Divisors with positive pair discrepancy remain positive +after dropping the boundary. This proves that $V'$ is +klt, including at higher-codimension singular loci. Set +$S=S'_+$ and $T=S'_-+E+p_1^*S_0$ for the moment. +Near $S$, the disjoint divisor $S'_-$ contributes its unit +section, and the fixed linear equivalence becomes +\[ + \omega(S+T)\simeq\OO(aS). +\] +The ambient charts remain klt and hence Cohen--Macaulay. +Since all displayed boundary divisors are Cartier, this +isomorphism also makes those charts Gorenstein. + +The strict divisor $S$ is finite over $S_+$. +Before normalization it lies in the zero section of the +projective ratio coordinate: its fibers over $S_+$ have at +most one point. The morphism is proper, and normalization is +finite. In particular a codimension-one point of $S\cap T$ +lies over a codimension-two intersection downstairs. The +generic SNC description above shows that $T|_S$ is generically +reduced. It is Cartier on the Cohen--Macaulay scheme $S$, +so it is reduced everywhere. + +We next remove the root characters that will not be used. +The line $\OO(S-S'_-)$ has $\ell$-th power equal to the pullback +of $N_0$. It defines a morphism to the gerbe of $\ell$-th roots +of $N_0$ on $X$. Take the relative coarse space over this +gerbe and call it $\mathcal X$. On a trivializing chart this +means quotienting by the kernel of the finite group character +acting on the indicated root line. These are ordinary +quasi-projective quotient schemes: the preceding covers are +finite, the blowup is projective, and a finite quotient preserves +quasi-projectivity. The chartwise construction patches. + +Retain $S,T$ for their reduced images. Near $S$, the pole +section is a unit, so both the line of $S$ and its section +descend through this kernel quotient. Thus $S$ remains +Cartier. A finite-group norm of a local equation for the +upstairs $T$ shows that its image is set-theoretically +principal; we do not need reduced $T$ to be Cartier. +The only divisorial ramification is on the boundary. +Log ramification therefore preserves the lc pair and descends +the equivariant adjoint isomorphism to +\eqref{proj:sg:ambient-adjunction}. Cohen--Macaulayness of the +ambient chart and of $S$ follows from the finite CM covers +and their invariant direct summands. For clarity, the +coarse kernel acts trivially on the retained root line, +and hence on $\OO(aS)$. Equivariance of the fixed adjoint +isomorphism gives the same kernel character on +$\omega(S+T)$. Taking invariants therefore descends the +isomorphism, with log ramification identifying the +invariant log dualizing sheaf. Off $T$ the descended +adjoint isomorphism makes the canonical sheaf invertible, +giving the claimed Gorenstein property there. + +The reduced supports $S$ and $J$ are unions of log canonical +centers: intersections of lc centers are again unions of +lc centers. Hence both are Du Bois by +\cite[Theorems~1.4 and~1.7]{Proj-KollarKovacs2010}. +For the more precise coherent statement, on one quotient +chart write $S^{\mathrm{up}}\to S$ for the finite cover used +above. Since $T^{\mathrm{up}}|_{S^{\mathrm{up}}}$ is reduced, +\[ + \mathcal I_{J/S} + = + \bigl(f_*\OO_{S^{\mathrm{up}}} + (-T^{\mathrm{up}}|_{S^{\mathrm{up}}})\bigr)^{\mathrm{inv}}. +\] +Indeed an invariant function vanishes on the reduced quotient +image precisely when its pullback vanishes on this reduced +preimage. The sheaf on the right is maximal Cohen--Macaulay: +upstairs it is invertible on a CM scheme, finite pushforward +has the same depth over the quotient, and invariants are a +direct summand in characteristic zero. + +Finite-map duality with trace, followed by invariants, gives +\[ + \mathcal Hom_S(\mathcal I_{J/S},\omega_S) + = + \bigl(f_*\omega_{S^{\mathrm{up}}} + (T^{\mathrm{up}}|_{S^{\mathrm{up}}})\bigr)^{\mathrm{inv}} + \simeq\OO_S(aS). +\] +This use of duality allows ramification and does not assert +that $\omega_S$ itself is invertible. The last isomorphism +is upstairs Cartier adjunction followed by descent of the +$S$ line. Off $J$ it is the ordinary residue determined by +the fixed ambient isomorphism. Normalized trace preserves +that convention, proving compatibility on overlaps. + +Restricted to $S$, the root gerbe of $N_0$ is +$D\times_P\mathcal P$. The strict-divisor finiteness already +proved, together with removal of the relative inertia kernel, +makes $S\to D\times_P\mathcal P$ finite and representable. +Its image covers the positive boundary, and its root line is +$\OO_S(S)=C$. Lemma~\ref{proj:sg:numerical-boundary} gives all the +asserted image-dimension bounds, including the bound for $J$. +The resulting $h:S\to\mathcal P$ is representable projective. + +Its Stein algebra defines a finite stack +$\mathcal T=\Spec_{\mathcal P}h_*\OO_S$ over $\mathcal P$. +There are enough vector bundles on $\mathcal P$ to generate +this coherent algebra as a module. Namely, decompose by the +finitely many inertia characters, twist each summand by a +power of $C$ to descend it to $P$, and apply Serre generation. +A vector-bundle surjection gives an embedding of $\mathcal T$ +in a vector bundle over $\mathcal P$. Its closure in the +projective completion is still $\mathcal T$, since it is +proper over the base. This gives $\mathcal Y$ and $g$. +The Stein construction supplies $g_*\OO_S=\OO_{\mathcal T}$ +and the required line identities. + +Finally, etale morphisms extend uniquely over nilpotent +thickenings, compatibly as $q$ varies. The reduction $S_U$ +is a scheme. The extension $qS_U$ has trivial inertia and +is an algebraic space. It is separated over $X$: the chosen +chart is separated, the morphism to the root gerbe is finite, +and that gerbe has finite diagonal. Its finite-type +geometric fibers over $X$ are zero-dimensional, and this is +unchanged by nilpotents. Thus $qS_U\to X$ is separated and +quasi-finite. Zariski's main theorem embeds it in a scheme +finite over $X$, proving that it is a quasi-projective +scheme. This completes the construction. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/figures/proof_map.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/figures/proof_map.tex new file mode 100644 index 0000000000000000000000000000000000000000..217ad43e5886d0483666e390351735fba08cfcac --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/figures/proof_map.tex @@ -0,0 +1,49 @@ +\begin{figure}[!t] +\centering +\begin{tikzpicture}[ + box/.style={draw,thin,align=center,font=\small, + text width=4.15cm,inner sep=5pt}, + wide/.style={box,text width=10.5cm}, + flow/.style={-{Stealth[length=2mm]},thin}] +\node[wide] (endpoint) at (0,0) + {Assumption~\ref{hyp:mmp}, retaining Assumption~\ref{hyp:campana}\\ + Original nef endpoint \((Y,\Delta)\), \(J=K_Y+\Delta\)}; +\node[box,anchor=north] (projective) at (-5,-1.9) + {Projective case\\ + Lemma~\ref{red:log-iitaka} and Theorem~\ref{proj:thm:main}\\ + Corollary~\ref{red:projective}}; +\node[box,anchor=north] (direct) at (0,-1.9) + {Uniruled or irregular case\\ + Lemmas~\ref{red:uniruled} and~\ref{red:irregular}}; +\node[box,anchor=north] (canonical) at (5,-1.9) + {Remaining smooth canonical case\\ + \(W\) non-uniruled, non-Moishezon, \(q(W)=0\)\par\smallskip + \(a(W)>0\): Proposition~\ref{pos:nonvanishing}\\ + \(a(W)=0\): Theorem~\ref{end:canonical}, using Sections~\ref{met:section}--\ref{floor:sec}}; +\node[wide] (nonvanishing) at (0,-6.3) + {Theorem~\ref{thm:nonvanishing}: \(\kappa(Y,J)\geq0\)\\ + Nonvanishing on the original nef pair}; +\node[wide] (good) at (0,-8.1) + {Theorem~\ref{thm:main}: a Cartier multiple of \(J\) + is globally generated on \(Y\)}; +\draw[flow] (endpoint.south) -- (0,-1.05) -- (-5,-1.05) -- (projective.north); +\draw[flow] (0,-1.05) -- (direct.north); +\draw[flow] (0,-1.05) -- (5,-1.05) -- (canonical.north); +\node[fill=white,inner sep=2pt,font=\small] at (0,-1.05) + {Section~\ref{red:section}; Proposition~\ref{red:reduction}}; +\draw[flow] (projective.south) -- (-5,-5.6) -- (nonvanishing.north west); +\draw[flow] (direct.south) -- (nonvanishing.north); +\draw[flow] (canonical.south) -- (5,-5.6) -- (nonvanishing.north east); +\draw[flow] (nonvanishing.south) -- node[right,font=\small] + {Final use of Assumption~\ref{hyp:effective-abundance}} (good.north); +\end{tikzpicture} +\caption{Reading map under Assumptions~\ref{hyp:campana}--\ref{hyp:effective-abundance}. +Lemma~\ref{red:log-iitaka} derives the sole premise of Theorem~\ref{proj:thm:main} +from Assumption~\ref{hyp:campana}, +so the projective appendices add no independent conditional input. +The groupings indicate uses in this proof, not the full scope of the +component lemmas. Assumption~\ref{hyp:effective-abundance} also enters +intermediate constructions. All routes return nonvanishing to the +original nef pair before its final application on that endpoint.} +\label{fig:proof-map} +\end{figure} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/main.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..ac0dd38ba8361c71ac1942516f5c3a3be48160a0 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/main.tex @@ -0,0 +1,48 @@ +\documentclass[11pt,letterpaper]{article} +\input{preamble} +\title{Conditional good minimal models\\for compact K\"ahler fourfolds} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\maketitle +\begin{abstract} +Assuming orbifold Iitaka subadditivity and abundance for nef fourfold adjoints +of nonnegative Kodaira dimension, we prove the existence of good minimal +models for globally strongly \(\Q\)-factorial compact K\"ahler klt +fourfold pairs with effective rational boundary and analytically +pseudo-effective actual \(\Q\)-Cartier adjoint. The ordinary fourfold +minimal model program supplies the nef endpoint. We prove nonvanishing by +fibration arguments and, in algebraic dimension zero, by singular +metrics, holomorphic foliations, and extension from a reduced boundary. +The projective abundance argument used in the proof is included in full. +\end{abstract} +\tableofcontents +\newpage +\part{Compact K\"ahler fourfolds} +\input{sections/introduction} +\input{sections/premises} +\input{sections/reductions} +\input{sections/positive_dimension} +\input{sections/minimal_metric} +\input{sections/empty_divisor} +\input{sections/birational} +\input{sections/floor} +\input{sections/completion} +\clearpage +\appendix +\part{Projective abundance from logarithmic subadditivity} +\input{appendices/projective_introduction} +\input{appendices/projective_induction} +\input{appendices/projective_signed_geometry} +\input{appendices/projective_hodge} +\input{appendices/projective_signed_descent} +\input{appendices/projective_exclusions} +\input{appendices/projective_jets} +\input{appendices/projective_frobenius} +\input{appendices/projective_completion} +\clearpage +\phantomsection +\addcontentsline{toc}{section}{References} +\bibliographystyle{plain} +\bibliography{references,projective_references} +\end{document} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/preamble.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/preamble.tex new file mode 100644 index 0000000000000000000000000000000000000000..29a607f1fa3270c29f731462115213275e426675 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/preamble.tex @@ -0,0 +1,64 @@ +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{enumitem,booktabs,array,graphicx} +\usepackage{tikz,tikz-cd} +\usetikzlibrary{arrows.meta,positioning,fit} +\usepackage{microtype} +\usepackage{xcolor} +\definecolor{linkteal}{RGB}{0,83,91} +\usepackage{needspace} +\usepackage{xurl} +\usepackage[colorlinks=true,allcolors=linkteal]{hyperref} +\hypersetup{pdftitle={Conditional good minimal models for compact Kahler fourfolds}, + pdfauthor={OpenAI},pdflang={en-US}, + pdfsubject={Conditional nonvanishing and good minimal models for compact Kahler fourfolds}} +\newcommand{\Q}{\mathbb{Q}} +\newcommand{\R}{\mathbb{R}} +\newcommand{\C}{\mathbb{C}} +\newcommand{\Z}{\mathbb{Z}} +\newcommand{\PP}{\mathbb{P}} +\newcommand{\OO}{\mathcal{O}} +\newcommand{\cO}{\mathcal{O}} +\newcommand{\cF}{\mathcal{F}} +\newcommand{\cL}{\mathcal{L}} +\newcommand{\dd}{\mathrm{d}} +\newcommand{\ii}{\sqrt{-1}} +\newcommand{\ddc}{\mathrm{d}\mathrm{d}^{c}} +\newcommand{\NA}{\overline{\mathrm{NA}}} +\newcommand{\BC}{\mathrm{BC}} +\DeclareMathOperator{\Spec}{Spec} +\DeclareMathOperator{\Proj}{Proj} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\Alb}{Alb} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\rk}{rk} +\DeclareMathOperator{\codim}{codim} +\DeclareMathOperator{\mult}{mult} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\vol}{vol} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\Gr}{Gr} +\DeclareMathOperator{\DR}{DR} +\DeclareMathOperator{\id}{id} +\DeclareMathOperator{\tr}{tr} +\DeclareMathOperator{\Exc}{Exc} +\DeclareMathOperator{\NS}{NS} +\DeclareMathOperator{\divisor}{div} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{assumption}[theorem]{Assumption} +\newtheorem{notation}[theorem]{Notation} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\setlist{itemsep=3pt,topsep=5pt,leftmargin=*} +\allowdisplaybreaks[1] +\setlength{\emergencystretch}{2em} +\setcounter{tocdepth}{2} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/projective_references.bib b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/projective_references.bib new file mode 100644 index 0000000000000000000000000000000000000000..7eb128423c30d795a3f1163943ae3b53bb2f1df8 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/projective_references.bib @@ -0,0 +1,319 @@ + +@article{Proj-Hashizume2018, + author = {Hashizume, Kenta}, + title = {On the non-vanishing conjecture and existence of log minimal models}, + journal = {Publications of the Research Institute for Mathematical Sciences}, + volume = {54}, + number = {1}, + year = {2018}, + pages = {89--104}, + doi = {10.4171/PRIMS/54-1-3}, + eprint = {1609.00121}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/1609.00121v4}, + note = {Theorem 1.4; arXiv version 4. Version cited: \url{https://arxiv.org/abs/1609.00121v4}} +} + +@incollection{Proj-FujinoGongyoRings2014, + author = {Fujino, Osamu and Gongyo, Yoshinori}, + title = {On log canonical rings}, + booktitle = {Higher Dimensional Algebraic Geometry in honour of Professor Yujiro Kawamata's sixtieth birthday}, + series = {Advanced Studies in Pure Mathematics}, + volume = {74}, + publisher = {Mathematical Society of Japan}, + address = {Tokyo}, + year = {2017}, + pages = {159--169}, + eprint = {1302.5194}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/log-ring-aspm.pdf}, + note = {Lemma 3.5. Final author version: \url{https://www.math.kyoto-u.ac.jp/~fujino/log-ring-aspm.pdf}} +} + +@article{Proj-Birkar2011II, + author = {Birkar, Caucher}, + title = {On existence of log minimal models {II}}, + journal = {Journal f{\"u}r die reine und angewandte Mathematik}, + volume = {658}, + year = {2011}, + pages = {99--113}, + doi = {10.1515/crelle.2011.062}, + eprint = {0907.4170}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/0907.4170v1}, + note = {Theorem 1.5 and Corollary 1.7 in the cited arXiv version. Version cited: \url{https://arxiv.org/abs/0907.4170v1}} +} + +@article{Proj-Birkar2010, + author = {Birkar, Caucher}, + title = {On existence of log minimal models}, + journal = {Compositio Mathematica}, + volume = {146}, + number = {4}, + year = {2010}, + pages = {919--928}, + doi = {10.1112/S0010437X09004564}, + eprint = {0706.1792}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/0706.1792v3}, + note = {Lemma 3.6 in the cited arXiv version. Version cited: \url{https://arxiv.org/abs/0706.1792v3}} +} + +@article{Proj-Birkar2012Special, + author = {Birkar, Caucher}, + title = {Existence of log canonical flips and a special {LMMP}}, + journal = {Publications Math{\'e}matiques de l'IH{\'E}S}, + volume = {115}, + year = {2012}, + pages = {325--368}, + doi = {10.1007/s10240-012-0039-5}, + eprint = {1104.4981}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {Theorem 1.9, restated as Theorem 4.1. Version cited: \url{https://arxiv.org/abs/1104.4981v3}} +} + +@article{Proj-Ambro2005, + author = {Ambro, Florin}, + title = {The moduli b-divisor of an lc-trivial fibration}, + journal = {Compositio Mathematica}, + volume = {141}, + number = {2}, + year = {2005}, + pages = {385--403}, + doi = {10.1112/S0010437X04001071}, + note = {Theorem 0.2} +} + +@misc{Proj-Fujino2017, + author = {Fujino, Osamu}, + title = {Introduction to the log minimal model program for log canonical pairs}, + year = {2009}, + howpublished = {Unpublished manuscript, \url{https://www.math.kyoto-u.ac.jp/~fujino/MMP21.pdf}}, + eprint = {0907.1506}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/MMP21.pdf}, + note = {Version 6.01, January 8, 2009; Theorem 3.74(3), p. 109} +} + +@article{Proj-GongyoLehmann2013, + author = {Gongyo, Yoshinori and Lehmann, Brian}, + title = {Reduction maps and minimal model theory}, + journal = {Compositio Mathematica}, + year = {2013}, volume = {149}, number = {2}, pages = {295--308}, + doi = {10.1112/S0010437X12000553}, + url = {https://www.ms.u-tokyo.ac.jp/~gongyo/papers/redmapsmmp-final.pdf}, + note = {Read with the numerical-dimension erratum on Lehmann's research page. Erratum: \url{https://sites.bc.edu/lehmann/research/}. Final author version: \url{https://www.ms.u-tokyo.ac.jp/~gongyo/papers/redmapsmmp-final.pdf}} +} + +@article{Proj-Fujino2019Numerical, + author = {Fujino, Osamu}, + title = {Corrigendum to ``{On} subadditivity of the logarithmic {Kodaira} dimension''}, + journal = {Journal of the Mathematical Society of Japan}, + year = {2020}, volume = {72}, number = {4}, pages = {1181--1187}, + doi = {10.2969/jmsj/82568256}, + eprint = {1904.11639}, archivePrefix = {arXiv}, primaryClass = {math.AG}, + url = {https://www.jstage.jst.go.jp/article/jmath/72/4/72_1181/_article/-char/ja}, + note = {Accepted author version: \url{https://www.math.kyoto-u.ac.jp/~fujino/corrigendum-fujino.pdf}} +} + +@article{Proj-KovacsPatakfalvi2017, + author = {Kov{\'a}cs, S{\'a}ndor J. and Patakfalvi, Zsolt}, + title = {Projectivity of the moduli space of stable log-varieties and subadditivity of log-{Kodaira} dimension}, + journal = {Journal of the American Mathematical Society}, + year = {2017}, volume = {30}, number = {4}, pages = {959--1021}, + doi = {10.1090/jams/871}, + url = {https://sites.math.washington.edu/~kovacs/current/papers/Kovacs_Patakfalvi__Projectivity.pdf}, + note = {Theorem 9.9 in the author version. Version cited: \url{https://sites.math.washington.edu/~kovacs/current/papers/Kovacs_Patakfalvi__Projectivity.pdf}} +} + +@article{Proj-CampanaPaun2015, + author = {Campana, Fr{\'e}d{\'e}ric and P{\u a}un, Mihai}, + title = {Orbifold generic semi-positivity: an application to families of canonically polarized manifolds}, + journal = {Annales de l'Institut Fourier}, + year = {2015}, volume = {65}, number = {2}, pages = {835--861}, + doi = {10.5802/aif.2945}, + url = {https://www.numdam.org/item/AIF_2015__65_2_835_0/} +} + +@article{Proj-Langer2004, + author = {Langer, Adrian}, + title = {Semistable sheaves in positive characteristic}, + journal = {Annals of Mathematics}, + year = {2004}, volume = {159}, number = {1}, pages = {251--276}, + doi = {10.4007/annals.2004.159.251}, + url = {https://annals.math.princeton.edu/2004/159-1/p04} +} + +@article{Proj-Sun2008, + author = {Sun, Xiaotao}, + title = {Direct images of bundles under {Frobenius} morphism}, + journal = {Inventiones Mathematicae}, + year = {2008}, volume = {173}, number = {2}, pages = {427--447}, + doi = {10.1007/s00222-008-0125-y}, + eprint = {math/0611360v2}, archivePrefix = {arXiv}, primaryClass = {math.AG}, + url = {https://arxiv.org/abs/math/0611360v2}, + note = {Theorem 3.7 and Lemma 4.2 cited from arXiv version 2. Version cited: \url{https://arxiv.org/abs/math/0611360v2}} +} + +@article{Proj-FujinoHashizume2023, + author = {Fujino, Osamu and Hashizume, Kenta}, + title = {Existence of log canonical modifications and its applications}, + journal = {European Journal of Mathematics}, + year = {2023}, volume = {9}, number = {1}, + note = {Paper No. 13, 32 pp.; Theorem 2.10 in the accepted author version. Version cited: \url{https://www.math.kyoto-u.ac.jp/~fujino/lc-model-fujino-hashizume-draft-7-EJM-rev-normalstylefile.pdf}}, + doi = {10.1007/s40879-023-00598-0}, + url = {https://link.springer.com/article/10.1007/s40879-023-00598-0} +} + +@article{Proj-FujinoGongyoModuli2014, + author = {Fujino, Osamu and Gongyo, Yoshinori}, + title = {On the moduli b-divisors of lc-trivial fibrations}, + journal = {Annales de l'Institut Fourier}, + year = {2014}, volume = {64}, number = {4}, pages = {1721--1735}, + doi = {10.5802/aif.2894}, + url = {https://www.numdam.org/item/AIF_2014__64_4_1721_0/} +} + +@incollection{Proj-HMX2018, + author = {Hacon, Christopher D. and McKernan, James and Xu, Chenyang}, + title = {Boundedness of varieties of log general type}, + booktitle = {Algebraic Geometry: Salt Lake City 2015, Part 1}, + series = {Proceedings of Symposia in Pure Mathematics}, + volume = {97.1}, pages = {309--348}, + publisher = {American Mathematical Society}, year = {2018}, + doi = {10.1090/pspum/097.1/01677}, + url = {https://www.claymath.org/wp-content/uploads/2022/03/Hacon-AG2015.pdf}, + note = {Published Theorem 4.0.1; Theorem 3.0.1 in arXiv version 2. Published offprint: \url{https://www.claymath.org/wp-content/uploads/2022/03/Hacon-AG2015.pdf}} +} + +@article{Proj-Saito1990, + author = {Saito, Morihiko}, + title = {Mixed {Hodge} modules}, + journal = {Publications of the Research Institute for Mathematical Sciences}, + year = {1990}, volume = {26}, number = {2}, pages = {221--333}, + doi = {10.2977/PRIMS/1195171082}, + url = {https://ems.press/journals/prims/articles/3552} +} + +@article{Proj-Saito2000, + author = {Saito, Morihiko}, + title = {Mixed {Hodge} complexes on algebraic varieties}, + journal = {Mathematische Annalen}, + year = {2000}, volume = {316}, number = {2}, pages = {283--331}, + doi = {10.1007/s002080050014}, + eprint = {math/9906088}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/9906088v1}, + note = {Theorem 0.2 and Corollary 0.3 in arXiv version 1. Version cited: \url{https://arxiv.org/abs/math/9906088v1}} +} + +@article{Proj-MustataPopa2022, + author = {Musta{\c t}{\u a}, Mircea and Popa, Mihnea}, + title = {{Hodge} filtration on local cohomology, {Du Bois} complex and local cohomological dimension}, + journal = {Forum of Mathematics, Pi}, + year = {2022}, volume = {10}, + doi = {10.1017/fmp.2022.15}, + note = {Paper No. e22; Theorem C and Proposition 13.1}, + url = {https://people.math.harvard.edu/~mpopa/papers/Filtration_LC_Pi.pdf} +} + +@article{Proj-KollarKovacs2010, + author = {Koll{\'a}r, J{\'a}nos and Kov{\'a}cs, S{\'a}ndor J.}, + title = {Log canonical singularities are {Du Bois}}, + journal = {Journal of the American Mathematical Society}, + year = {2010}, volume = {23}, number = {3}, pages = {791--813}, + doi = {10.1090/S0894-0347-10-00663-6}, + url = {https://sites.math.washington.edu/~kovacs/current/papers/Kollar_Kovacs__Log_canonical_singularities_are_Du_Bois.pdf} +} + +@incollection{Proj-BauerEtAl2002, + author = {Bauer, Thomas and Campana, Fr{\'e}d{\'e}ric and Eckl, Thomas and Kebekus, Stefan and Peternell, Thomas and Rams, S{\l}awomir and Szemberg, Tomasz and Wotzlaw, Lorenz}, + title = {A reduction map for nef line bundles}, + booktitle = {Complex Geometry: Collection of Papers Dedicated to {Hans Grauert}}, + publisher = {Springer}, address = {Berlin}, + year = {2002}, pages = {27--36}, + doi = {10.1007/978-3-642-56202-0_2}, + url = {https://arxiv.org/abs/math/0106147v1}, + note = {Theorem 2.1 in arXiv version 1. Version cited: \url{https://arxiv.org/abs/math/0106147v1}} +} + +@misc{Proj-StacksExistence, + author = {{The Stacks Project Authors}}, + title = {The {Stacks Project}: {Grothendieck}'s existence theorem, {I}}, + year = {2026}, + howpublished = {\url{https://stacks.math.columbia.edu/tag/087V}}, + note = {Tag 087V, Lemmas 30.24.1 and 30.24.3; accessed September 18, 2026} +} + +@article{Proj-Taji2014, + author = {Taji, Behrouz}, + title = {Birational positivity in dimension $4$}, + journal = {Annales de l'Institut Fourier}, + year = {2014}, volume = {64}, number = {1}, pages = {203--216}, + doi = {10.5802/aif.2845}, + url = {https://aif.centre-mersenne.org/articles/10.5802/aif.2845/} +} + +@article{Proj-Hanamura1988, + author = {Hanamura, Masaki}, + title = {Structure of birational automorphism groups, {I}: non-uniruled varieties}, + journal = {Inventiones Mathematicae}, + year = {1988}, volume = {93}, pages = {383--403}, + doi = {10.1007/BF01394338}, + note = {Theorems 2.1--2.2; statements also reproduced in Blanc, Theorems 3.8--3.9} +} + +@incollection{Proj-Blanc2017, + author = {Blanc, J{\'e}r{\'e}my}, + title = {Algebraic structures of groups of birational transformations}, + booktitle = {Algebraic Groups: Structure and Actions}, + series = {Proceedings of Symposia in Pure Mathematics}, + volume = {94}, year = {2017}, pages = {17--30}, + publisher = {American Mathematical Society}, + doi = {10.1090/pspum/094/01620}, + url = {https://algebra.dmi.unibas.ch/blanc/articles/structurebir.pdf}, + note = {Theorems 3.8--3.9} +} + +@article{Proj-Siu1974, + author = {Siu, Yum-Tong}, + title = {Analyticity of sets associated to {Lelong} numbers and the extension of closed positive currents}, + journal = {Inventiones Mathematicae}, + year = {1974}, volume = {27}, pages = {53--156}, + doi = {10.1007/BF01389965} +} + +@book{Proj-Demailly2012, + author = {Demailly, Jean-Pierre}, + title = {Analytic Methods in Algebraic Geometry}, + series = {Surveys of Modern Mathematics}, + volume = {1}, year = {2012}, + publisher = {International Press and Higher Education Press}, + address = {Somerville, MA, and Beijing}, + isbn = {978-1-57146-234-3}, + url = {https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/analmeth_book.pdf}, + note = {Theorem numbering refers to the author manuscript dated July 2011. Version cited: \url{https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/analmeth_book.pdf}} +} + +@article{Proj-MiyaokaMori1986, + author = {Miyaoka, Yoichi and Mori, Shigefumi}, + title = {A numerical criterion for uniruledness}, + journal = {Annals of Mathematics}, + year = {1986}, volume = {124}, number = {1}, pages = {65--69}, + doi = {10.2307/1971387}, + url = {https://annals.math.princeton.edu/1986/124/p03} +} + +@article{Proj-Paun2007, + author = {P{\u a}un, Mihai}, + title = {{Siu}'s invariance of plurigenera: a one-tower proof}, + journal = {Journal of Differential Geometry}, + year = {2007}, volume = {76}, number = {3}, pages = {485--493}, + url = {https://archive.ymsc.tsinghua.edu.cn/pacm_download/21/685-JDG-76-3-485-493.pdf}, + note = {Theorem 1} +} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/references.bib b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..9ec98c89f30e21b82947a0586b49e96d684ae204 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/references.bib @@ -0,0 +1,618 @@ + +@misc{GrantCampana, + author = {{OpenAI}}, + title = {{Orbifold and logarithmic Iitaka subadditivity}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Orbifold-and-logarithmic-Iitaka-subadditivity-September-26-2026/paper.pdf}{OAI:Orbifold-and-logarithmic-Iitaka-subadditivity-September-26-2026}}, + year = {2026}, + note = {Theorem 1.1} +} + +@misc{GrantMMP, + author = {{OpenAI}}, + title = {{Finite ordinary minimal model programs on compact K\"ahler fourfolds}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf}{OAI:Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026}}, + year = {2026}, + note = {Theorem 6.24, Lemma 3.2, and Propositions 3.4 and 6.23} +} + +@misc{GrantEffectiveAbundance, + author = {{OpenAI}}, + title = {{Abundance after nonvanishing for compact K\"ahler fourfolds}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Abundance-after-nonvanishing-for-compact-Kahler-fourfolds-September-27-2026/paper.pdf}{OAI:Abundance-after-nonvanishing-for-compact-Kahler-fourfolds-September-27-2026}}, + year = {2026}, + note = {Theorem 1.1; semiampleness of the actual nef adjoint under nonnegative Kodaira dimension} +} + +@misc{OuUniruledness, + author = {Ou, Wenhao}, + title = {A characterization of uniruled compact {K\"ahler} manifolds}, + year = {2025}, + eprint = {2501.18088}, + archivePrefix = {arXiv}, + note = {Version 1, 30 January 2025}, + url = {https://arxiv.org/abs/2501.18088v1}, + howpublished = {\url{https://arxiv.org/abs/2501.18088v1}} +} + +@article{NamikawaProjectivity, + author = {Namikawa, Yoshinori}, + title = {Projectivity criterion of {Moishezon} spaces and density of projective symplectic varieties}, + journal = {International Journal of Mathematics}, + volume = {13}, + number = {2}, + year = {2002}, + pages = {125--135}, + doi = {10.1142/S0129167X02001277}, + url = {https://arxiv.org/abs/math/0101019v6} +} + +@article{CampanaOrbifolds, + author = {Campana, Fr{\'e}d{\'e}ric}, + title = {Orbifolds, special varieties and classification theory}, + journal = {Annales de l'Institut Fourier}, + volume = {54}, + number = {3}, + year = {2004}, + pages = {499--630}, + doi = {10.5802/aif.2027}, + url = {https://numdam.org/item/AIF_2004__54_3_499_0/} +} + +@article{CampanaRationalQuotient, + author = {Campana, Fr{\'e}d{\'e}ric}, + title = {Orbifolds, special varieties and classification theory: an appendix}, + journal = {Annales de l'Institut Fourier}, + volume = {54}, + number = {3}, + year = {2004}, + pages = {631--665}, + doi = {10.5802/aif.2028}, + url = {https://www.numdam.org/item/AIF_2004__54_3_631_0/} +} + +@article{CampanaAlgebraicConnectedness, + author = {Campana, Fr{\'e}d{\'e}ric}, + title = {Cor{\'e}duction alg{\'e}brique d'un espace analytique faiblement k{\"a}hl{\'e}rien compact}, + journal = {Inventiones Mathematicae}, + volume = {63}, + year = {1981}, + pages = {187--223}, + doi = {10.1007/BF01393876} +} + +@incollection{CampanaPeternellSurvey, + author = {Campana, Fr{\'e}d{\'e}ric and Peternell, Thomas}, + title = {Recent developments in the classification theory of compact {K\"ahler} manifolds}, + booktitle = {Several Complex Variables}, + editor = {Schneider, Michael and Siu, Yum-Tong}, + series = {Mathematical Sciences Research Institute Publications}, + volume = {37}, + publisher = {Cambridge University Press}, + year = {1999}, + pages = {113--159}, + url = {https://library.slmath.org/books/Book37/files/campana.pdf} +} + +@article{GraberHarrisStarr, + author = {Graber, Tom and Harris, Joe and Starr, Jason}, + title = {Families of rationally connected varieties}, + journal = {Journal of the American Mathematical Society}, + volume = {16}, + number = {1}, + year = {2003}, + pages = {57--67}, + doi = {10.1090/S0894-0347-02-00402-2}, + url = {https://arxiv.org/abs/math/0109220} +} + +@article{DasOuAbundanceI, + author = {Das, Omprokash and Ou, Wenhao}, + title = {On the log abundance for compact {K\"ahler} threefolds}, + journal = {Manuscripta Mathematica}, + volume = {173}, + year = {2024}, + pages = {341--404}, + doi = {10.1007/s00229-023-01467-6}, + url = {https://arxiv.org/abs/2201.01202v3} +} + +@misc{DasOuAbundanceII, + author = {Das, Omprokash and Ou, Wenhao}, + title = {On the log abundance for compact {K\"ahler} threefolds {II}}, + year = {2025}, + eprint = {2306.00671}, + archivePrefix = {arXiv}, + note = {Version 4, 12 June 2025; first submitted 2023}, + url = {https://arxiv.org/abs/2306.00671v4}, + howpublished = {\url{https://arxiv.org/abs/2306.00671v4}} +} + +@article{FujinoGongyoPluricanonical, + author = {Fujino, Osamu and Gongyo, Yoshinori}, + title = {Log pluricanonical representations and the abundance conjecture}, + journal = {Compositio Mathematica}, + volume = {150}, + number = {4}, + year = {2014}, + pages = {593--620}, + doi = {10.1112/S0010437X13007495}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/fg-comp-final.pdf}, + note = {Theorem 1.1 (finiteness of log pluricanonical representations); Theorem 1.5, restated as Theorem 4.3 (projective slc gluing). Final author version: \url{https://www.math.kyoto-u.ac.jp/~fujino/fg-comp-final.pdf}} +} + +@misc{FujinoAnalyticMMP, + author = {Fujino, Osamu}, + title = {Minimal model program for projective morphisms between complex analytic spaces}, + year = {2022}, + eprint = {2201.11315}, + archivePrefix = {arXiv}, + note = {Version 1, 27 January 2022; theorem numbering follows this version}, + url = {https://arxiv.org/abs/2201.11315v1}, + howpublished = {\url{https://arxiv.org/abs/2201.11315v1}} +} + +@misc{FujinoAnalyticCone, + author = {Fujino, Osamu}, + title = {Cone and contraction theorem for projective morphisms between complex analytic spaces}, + year = {2023}, + note = {Author manuscript, version 0.00, 9 October 2023; Theorem 4.3.1 and Remark 4.3.4}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/cone-and-contraction.pdf}, + howpublished = {\url{https://www.math.kyoto-u.ac.jp/~fujino/cone-and-contraction.pdf}} +} + +@article{KawamataTerminalDiscrepancy, + author = {Kawamata, Yujiro}, + title = {The minimal discrepancy of a {$3$}-fold terminal singularity}, + journal = {Russian Academy of Sciences. Izvestiya Mathematics}, + volume = {40}, + number = {1}, + year = {1993}, + pages = {193--195}, + note = {Appendix to V. V. Shokurov, Three-fold log flips}, + url = {https://www.mathnet.ru/eng/im960} +} + +@article{DPSHardLefschetz, + author = {Demailly, Jean-Pierre and Peternell, Thomas and Schneider, Michael}, + title = {Pseudo-effective line bundles on compact {K\"ahler} manifolds}, + journal = {International Journal of Mathematics}, + volume = {12}, + number = {6}, + year = {2001}, + pages = {689--741}, + doi = {10.1142/S0129167X01000861}, + url = {https://arxiv.org/abs/math/0006205} +} + +@article{KebekusSchnellExtension, + author = {Kebekus, Stefan and Schnell, Christian}, + title = {Extending holomorphic forms from the regular locus of a complex space to a resolution of singularities}, + journal = {Journal of the American Mathematical Society}, + volume = {34}, + number = {2}, + year = {2021}, + pages = {315--368}, + doi = {10.1090/jams/962}, + url = {https://arxiv.org/abs/1811.03644v4} +} + +@article{BoucksomDivisorialZariski, + author = {Boucksom, S{\'e}bastien}, + title = {Divisorial {Zariski} decompositions on compact complex manifolds}, + journal = {Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series = {4}, + volume = {37}, + number = {1}, + year = {2004}, + pages = {45--76}, + doi = {10.1016/j.ansens.2003.04.002}, + url = {https://numdam.org/item/ASENS_2004_4_37_1_45_0/} +} + +@article{CCE, + author = {Campana, Fr{\'e}d{\'e}ric and Claudon, Beno{\^i}t and Eyssidieux, Philippe}, + title = {Repr{\'e}sentations lin{\'e}aires des groupes k{\"a}hl{\'e}riens: factorisations et conjecture de {Shafarevich} lin{\'e}aire}, + journal = {Compositio Mathematica}, + volume = {151}, + number = {2}, + year = {2015}, + pages = {351--376}, + doi = {10.1112/S0010437X14007751}, + url = {https://arxiv.org/abs/1302.5016v3} +} + +@article{GongyoNumericallyTrivial, + author = {Gongyo, Yoshinori}, + title = {Abundance theorem for numerically trivial log canonical divisors of semi-log canonical pairs}, + journal = {Journal of Algebraic Geometry}, + volume = {22}, + number = {3}, + year = {2013}, + pages = {549--564}, + doi = {10.1090/S1056-3911-2012-00593-1}, + url = {https://arxiv.org/abs/1005.2796} +} + +@incollection{KollarSources, + author = {Koll{\'a}r, J{\'a}nos}, + title = {Sources of log canonical centers}, + booktitle = {Minimal Models and Extremal Rays}, + series = {Advanced Studies in Pure Mathematics}, + volume = {70}, + publisher = {Mathematical Society of Japan}, + address = {Tokyo}, + year = {2016}, + pages = {29--48}, + url = {https://arxiv.org/abs/1107.2863} +} + +@misc{DasSDLT, + author = {Das, Swapnajit}, + title = {Failure of the semi log canonical abundance for compact {K\"ahler} threefolds}, + year = {2026}, + eprint = {2604.28085}, + archivePrefix = {arXiv}, + note = {Version 1, 30 April 2026. Version 2 has a different title and revised claims; this record identifies the exact comparison source}, + url = {https://arxiv.org/abs/2604.28085v1}, + howpublished = {\url{https://arxiv.org/abs/2604.28085v1}} +} + +@article{KeelMatsukiMcKernan, + author = {Keel, Sean and Matsuki, Kenji and McKernan, James}, + title = {Log abundance theorem for threefolds}, + journal = {Duke Mathematical Journal}, + volume = {75}, + number = {1}, + year = {1994}, + pages = {99--119}, + doi = {10.1215/S0012-7094-94-07504-2}, + note = {Read with the 2004 corrections} +} + +@article{KeelMatsukiMcKernanCorrection, + author = {Keel, Sean and Matsuki, Kenji and McKernan, James}, + title = {Corrections to ``{Log} abundance theorem for threefolds''}, + journal = {Duke Mathematical Journal}, + volume = {122}, + number = {3}, + year = {2004}, + pages = {625--630}, + doi = {10.1215/S0012-7094-04-12236-5}, + url = {https://arxiv.org/abs/math/0302360} +} + +@article{KawamataViehwegVanishing, + author = {Kawamata, Yujiro}, + title = {A generalization of {Kodaira--Ramanujam}'s vanishing theorem}, + journal = {Mathematische Annalen}, + volume = {261}, + number = {1}, + year = {1982}, + pages = {43--46}, + doi = {10.1007/BF01456407}, + note = {For the relative formulation used here, see also Koll{\'a}r--Mori, Birational Geometry of Algebraic Varieties, Theorem 2.64} +} + +@book{BHPV, + author = {Barth, Wolf P. and Hulek, Klaus and Peters, Chris A. M. and van de Ven, Antonius}, + title = {Compact Complex Surfaces}, + edition = {Second enlarged}, + series = {Ergebnisse der Mathematik und ihrer Grenzgebiete, 3. Folge}, + volume = {4}, + publisher = {Springer-Verlag}, + address = {Berlin, Heidelberg}, + year = {2004}, + doi = {10.1007/978-3-642-57739-0} +} + +@book{BirationalGeometry, + author = {Koll{\'a}r, J{\'a}nos and Mori, Shigefumi}, + title = {Birational Geometry of Algebraic Varieties}, + series = {Cambridge Tracts in Mathematics}, + volume = {134}, + publisher = {Cambridge University Press}, + address = {Cambridge}, + year = {1998}, + doi = {10.1017/CBO9780511662560} +} + +@book{ThreefoldFlipsAbundance, + editor = {Koll{\'a}r, J{\'a}nos}, + title = {Flips and abundance for algebraic threefolds}, + series = {Ast{\'e}risque}, + number = {211}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + year = {1992}, + doi = {10.24033/ast.198}, + url = {https://numdam.org/item/AST_1992__211__1_0/} +} + +@book{SerreArithmetic, + author = {Serre, Jean-Pierre}, + title = {A Course in Arithmetic}, + series = {Graduate Texts in Mathematics}, + volume = {7}, + publisher = {Springer-Verlag}, + address = {New York}, + year = {1973}, + doi = {10.1007/978-1-4684-9884-4} +} + +@misc{DemaillyComplexAnalyticGeometry, + author = {Demailly, Jean-Pierre}, + title = {Complex Analytic and Differential Geometry}, + year = {2012}, + note = {Online book, version of 21 June 2012}, + url = {https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/agbook.pdf}, + howpublished = {\url{https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/agbook.pdf}} +} + +@article{HironakaResolution, + author = {Hironaka, Heisuke}, + title = {Bimeromorphic smoothing of a complex-analytic space}, + journal = {Acta Mathematica Vietnamica}, + volume = {2}, + number = {2}, + year = {1977}, + pages = {103--168}, + url = {https://math.ac.vn/acta/1977-volume2/2} +} + +@article{VarouchasKahler, + author = {Varouchas, Jean}, + title = {{K\"ahler} spaces and proper open morphisms}, + journal = {Mathematische Annalen}, + volume = {283}, + year = {1989}, + pages = {13--52}, + doi = {10.1007/BF01457500} +} + +@article{BDPP, + author = {Boucksom, S{\'e}bastien and Demailly, Jean-Pierre and P{\u a}un, Mihai and Peternell, Thomas}, + title = {The pseudo-effective cone of a compact {K\"ahler} manifold and varieties of negative {Kodaira} dimension}, + journal = {Journal of Algebraic Geometry}, + volume = {22}, + number = {2}, + year = {2013}, + pages = {201--248}, + doi = {10.1090/S1056-3911-2012-00574-8}, + eprint = {math/0405285}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0405285v1}, + note = {The uniruledness equivalence in this source is stated for projective manifolds. Theorem locators refer to arXiv version 1: \url{https://arxiv.org/abs/math/0405285v1}}, + primaryClass = {math.AG} +} + +@article{DemaillyRegularization, + author = {Demailly, Jean-Pierre}, + title = {Regularization of closed positive currents and intersection theory}, + journal = {Journal of Algebraic Geometry}, + volume = {1}, + number = {3}, + year = {1992}, + pages = {361--409}, + url = {https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/regularization.pdf} +} + +@article{GuedjZeriahiCapacity, + author = {Guedj, Vincent and Zeriahi, Ahmed}, + title = {Intrinsic capacities on compact {K\"ahler} manifolds}, + journal = {The Journal of Geometric Analysis}, + volume = {15}, + number = {4}, + year = {2005}, + pages = {607--639}, + doi = {10.1007/BF02922247}, + url = {https://www.math.univ-toulouse.fr/~guedj/fichierspdf/JGA05.pdf} +} + +@article{DemaillyKollar, + author = {Demailly, Jean-Pierre and Koll\'ar, J\'anos}, + title = {Semi-continuity of complex singularity exponents and + {K\"ahler--Einstein} metrics on {Fano} orbifolds}, + journal = {Annales scientifiques de l'\'Ecole Normale Sup\'erieure}, + series = {4}, + volume = {34}, + number = {4}, + year = {2001}, + pages = {525--556}, + doi = {10.1016/S0012-9593(01)01069-2}, + url = {https://numdam.org/item/ASENS_2001_4_34_4_525_0/} +} + +@incollection{DemaillyL2, + author = {Demailly, Jean-Pierre}, + title = {{$L^2$} vanishing theorems for positive line bundles and adjunction theory}, + booktitle = {Transcendental Methods in Algebraic Geometry}, + editor = {Catanese, Fabrizio and Ciliberto, Ciro}, + series = {Lecture Notes in Mathematics}, + volume = {1646}, + publisher = {Springer}, + address = {Berlin, Heidelberg}, + year = {1996}, + pages = {1--97}, + doi = {10.1007/BFb0094302}, + eprint = {alg-geom/9410022}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/alg-geom/9410022v3} +} + +@article{SkodaIntegrability, + author = {Skoda, Henri}, + title = {Sous-ensembles analytiques d'ordre fini ou infini dans {$C^n$}}, + journal = {Bulletin de la Soci\'et\'e Math\'ematique de France}, + volume = {100}, + year = {1972}, + pages = {353--408}, + doi = {10.24033/bsmf.1743}, + url = {https://www.numdam.org/item/BSMF_1972__100__353_0/} +} + +@article{AubinMongeAmpere, + author = {Aubin, Thierry}, + title = {{\'E}quations du type {Monge--Amp\`ere} sur les vari\'et\'es + k\"ahl\'eriennes compactes}, + journal = {Bulletin des Sciences Math\'ematiques}, + series = {2}, + volume = {102}, + number = {1}, + year = {1978}, + pages = {63--95} +} + +@article{YauCalabi, + author = {Yau, Shing-Tung}, + title = {On the {Ricci} curvature of a compact {K\"ahler} manifold and + the complex {Monge--Amp\`ere} equation, {I}}, + journal = {Communications on Pure and Applied Mathematics}, + volume = {31}, + number = {3}, + year = {1978}, + pages = {339--411}, + doi = {10.1002/cpa.3160310304}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/cpa.3160310304} +} + +@book{AubinBook1998, + author = {Aubin, Thierry}, + title = {Some Nonlinear Problems in Riemannian Geometry}, + series = {Springer Monographs in Mathematics}, + publisher = {Springer-Verlag}, + address = {Berlin, Heidelberg}, + year = {1998}, + doi = {10.1007/978-3-662-13006-3}, + url = {https://link.springer.com/book/10.1007/978-3-662-13006-3} +} + +@article{HPMinimalModels, + author = {H{\"o}ring, Andreas and Peternell, Thomas}, + title = {Minimal models for {K{\"a}hler} threefolds}, + journal = {Inventiones Mathematicae}, + volume = {203}, + number = {1}, + year = {2016}, + pages = {217--264}, + doi = {10.1007/s00222-015-0592-x}, + eprint = {1304.4013}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/1304.4013v3} +} + +@misc{HLLNonvanishing, + author = {H{\"o}ring, Andreas and Lazi{\'c}, Vladimir and Lehn, Christian}, + title = {Nonvanishing results for {K{\"a}hler} varieties}, + year = {2025}, + eprint = {2508.14634}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {Version 2, 21 October 2025}, + url = {https://arxiv.org/abs/2508.14634v2}, + howpublished = {\url{https://arxiv.org/abs/2508.14634v2}} +} + +@article{DHPFourfoldMMP, + author = {Das, Omprokash and Hacon, Christopher and P{\u a}un, Mihai}, + title = {On the {$4$}-dimensional minimal model program for {K{\"a}hler} varieties}, + journal = {Advances in Mathematics}, + volume = {443}, + year = {2024}, + pages = {109615}, + doi = {10.1016/j.aim.2024.109615}, + eprint = {2205.12205}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/2205.12205v3} +} + +@article{BCHM, + author = {Birkar, Caucher and Cascini, Paolo and Hacon, Christopher D. and McKernan, James}, + title = {Existence of minimal models for varieties of log general type}, + journal = {Journal of the American Mathematical Society}, + volume = {23}, + number = {2}, + year = {2010}, + pages = {405--468}, + doi = {10.1090/S0894-0347-09-00649-3}, + eprint = {math/0610203}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://www.ams.org/jams/2010-23-02/S0894-0347-09-00649-3/viewer/} +} + +@article{CHPAbundance, + author = {Campana, Fr{\'e}d{\'e}ric and H{\"o}ring, Andreas and Peternell, Thomas}, + title = {Abundance for {K{\"a}hler} threefolds}, + journal = {Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series = {4}, + volume = {49}, + number = {4}, + year = {2016}, + pages = {971--1025}, + doi = {10.24033/asens.2301} +} + +@misc{CHPAbundanceErratum, + author = {Campana, Fr{\'e}d{\'e}ric and H{\"o}ring, Andreas and Peternell, Thomas}, + title = {Erratum and addendum to the paper: Abundance for {K{\"a}hler} threefolds}, + year = {2023}, + eprint = {2304.10161}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.2304.10161}, + url = {https://arxiv.org/abs/2304.10161v1}, + howpublished = {\url{https://arxiv.org/abs/2304.10161v1}}, + note = {Version 1, 20 April 2023} +} + +@article{GuenanciaPaunBogomolovGieseker, + author = {Guenancia, Henri and P{\u a}un, Mihai}, + title = {{Bogomolov--Gieseker} inequality for log terminal {K{\"a}hler} threefolds}, + journal = {Communications on Pure and Applied Mathematics}, + volume = {78}, + number = {11}, + year = {2025}, + pages = {2206--2244}, + doi = {10.1002/cpa.70000}, + eprint = {2405.10003}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {With an appendix by Fr{\'e}d{\'e}ric Campana, Andreas H{\"o}ring, and Thomas Peternell} +} + +@article{DemaillyPeternellNonvanishing, + author = {Demailly, Jean-Pierre and Peternell, Thomas}, + title = {A {Kawamata--Viehweg} vanishing theorem on compact {K{\"a}hler} manifolds}, + journal = {Journal of Differential Geometry}, + volume = {63}, + number = {2}, + year = {2003}, + pages = {231--277}, + eprint = {math/0208021}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0208021} +} + +@misc{Touzet2014, + author = {Touzet, Fr{\'e}d{\'e}ric}, + title = {Feuilletages holomorphes admettant une mesure transverse invariante}, + year = {2014}, + eprint = {1409.3445}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/1409.3445v1}, + howpublished = {\url{https://arxiv.org/abs/1409.3445v1}} +} + +@misc{Vikash2026, + author = {Vikash, Pisya}, + title = {Classification of Smooth Minimal {K\"ahler} Fourfolds Without Effective Divisors and Surfaces}, + year = {2026}, + eprint = {2607.04536}, + archivePrefix = {arXiv}, + note = {Version 1, 5 July 2026}, + howpublished = {\url{https://arxiv.org/abs/2607.04536v1}} +} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/birational.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/birational.tex new file mode 100644 index 0000000000000000000000000000000000000000..1e07b7ee39001f53287c52fc41043816c7b53466 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/birational.tex @@ -0,0 +1,1480 @@ +\section{Birational constructions and reduced-boundary models} +\label{bir:section} + +This section supplies the ordinary dlt constructions needed in the +algebraic-dimension-zero argument. We prove special termination through +dimension four, using arbitrary klt termination through dimension three, +and then apply Assumption~\ref{hyp:mmp} only to ordinary effective klt +fourfold pairs. In particular, arbitrary dlt fourfold termination is not +an input. + +\subsection{Conventions, comparison, and integral descent} +\label{bir:conventions} + +All pairs in this section are ordinary rational pairs with effective +boundary and rationally invertible adjoint. Auxiliary programs start +on normal globally strongly $\Q$-factorial compact K\"ahler spaces. +Thus every global coherent rank-one reflexive sheaf has an invertible +reflexive power. This condition will be used for global sheaves; no +claim of $\Q$-factoriality on arbitrary analytic open subsets is made. +Divisors over a space mean divisorial places represented on proper +modifications, identified on common higher models. This convention +does not distinguish places by their action on global meromorphic +functions. + +\begin{definition}[Elementary birational steps] +\label{bir:elementary} +An elementary step for an adjoint $J=K_T+B$ is either a nontrivial +projective bimeromorphic divisorial contraction, with the pair pushed +forward, or a diagram +\begin{equation} + T\xrightarrow{f} Z\xleftarrow{f^+}T^+, + \label{bir:small-diagram} +\end{equation} +whose morphisms are projective, bimeromorphic, and small, with strict +transform boundary on $T^+$. The base is normal compact K\"ahler, and +the source and next space are normal globally strongly $\Q$-factorial +compact K\"ahler spaces. All curves contracted by the negative +morphism span one nonzero ray for degrees of global rational line +bundles. The line $-J$ is relatively ample; in a small step $J^+$ is +relatively ample. No positive-side Bott--Chern rank condition is +imposed in this definition. +\end{definition} + +A projective morphism here has a relatively ample holomorphic line +bundle. In the relative constructions, ``relatively nef'' means +nonnegative degree on curves in its fibers. Absolute nefness continues +to mean analytic nefness. + +We use common projective resolutions and the natural meromorphic +comparisons of canonical bundles, defined by Jacobians in local +canonical frames, together with boundary pullback. No global +meromorphic canonical frame is presumed. A global rank-one reflexive +sheaf is transported through a bimeromorphic correspondence by +pullback to a common resolution, proper direct image, and double dual. +For a small correspondence this is the unique reflexive strict +transform. + +\begin{lemma}[Exceptional comparison of global sheaves] +\label{bir:sheaf-comparison} +Let $h:Y\to T$ be a projective modification of normal spaces and let +$\mathcal P$ be a global rank-one reflexive sheaf on $Y$. Suppose that +$(h_*\mathcal P)^{**}$ is rationally invertible. Then, for some positive +integer $l$, an invertible sheaf $M$ on $T$ and an integral +$h$-exceptional Weil divisor $E$ satisfy +\begin{equation} + \mathcal P^{[l]}\simeq + \bigl(h^*M\otimes\OO_Y(E)\bigr)^{**}. + \label{bir:exceptional-sheaf} +\end{equation} +\end{lemma} + +\begin{proof} +Choose $l$ so that the corresponding reflexive power of +$(h_*\mathcal P)^{**}$ is invertible. This is +$(h_*\mathcal P^{[l]})^{**}$, since the two sheaves agree where $h$ is an +isomorphism, including the general points of all prime divisors of +$T$. Call this line $M$. Evaluation of local sections of +$h_*\mathcal P^{[l]}$, and their images in $M$, gives meromorphic +comparisons with $h^*M$. These comparisons are the same on their common +domain and hence define a divisorial comparison globally. Its orders +vanish away from the exceptional primes. The resulting integral +exceptional divisor gives~\eqref{bir:exceptional-sheaf} in codimension +one and therefore everywhere by reflexivity. Local meromorphic +generators are enough for this argument; it does not represent an +arbitrary global line bundle by a global divisor. +\end{proof} + +We shall use the projective analytic negativity lemma +\cite{FujinoAnalyticMMP,BirationalGeometry}: if a rational Cartier +divisor on a projective bimeromorphic morphism is relatively nef and +has nonpositive pushforward, it is nonpositive. The local-over-target +proof of \cite[Lemma~3.39]{BirationalGeometry} applies in this setting. + +\begin{lemma}[Comparison in an elementary step] +\label{bir:comparison} +On a common smooth projective resolution of an elementary step, with +projections $p$ to the negative model and $q$ to the next model, the +natural adjoint comparison is +\begin{equation} + p^*J=q^*J'+F,\qquad F\geq0,\qquad q_*F=0. + \label{bir:effective-comparison} +\end{equation} +Log discrepancies do not decrease. They increase strictly for a +place whose center on either side is contained over the non-isomorphism +locus in the contraction base. Consequently an elementary step +preserves klt, respectively dlt, singularities. +\end{lemma} + +\begin{proof} +The codimension-one comparison gives $q_*F=0$. The signs of the two +adjoints make $-F$ nef over the contraction base, and hence over the +target of $q$. Negativity gives $F\geq0$. + +In a small diagram the non-isomorphism sets in $Z$ are the same on +both sides. Otherwise, over a region where one side is an isomorphism, +smallness identifies the other adjoint with a pullback, contradicting +its relative ample sign on a contracted curve. A non-isomorphism +fiber is positive-dimensional by normality. Over any such point, +lift a negative curve to the common resolution. Its $F$-degree is +strictly negative, so the fiber meets $\Supp F$. A connected +projective fiber meeting the support of an effective relatively +anti-nef Cartier divisor is contained in that support: if a component +outside the support met it, a curve section through an intersection +point would have positive intersection. Clearing denominators gives +the same statement for $F$. Thus $\Supp F$ contains the full fibers +in question. Pullback to any higher model now proves strict increase +at each specified place. + +For dlt preservation use the characterization by log canonicity and an +SNC open set meeting every lc center. A new discrepancy-zero place +was already a zero place, and strictness keeps the general point of +its center out of the surgery. The SNC characterization, checked on +global log resolutions, is therefore preserved. The klt assertion is +immediate. Finally, on a globally strongly $\Q$-factorial dlt pair, +slightly decreasing the coefficients of the floor gives a klt pair: +the floor is effective rational Cartier, and every discrepancy-zero +place has center in it and positive order on its pullback. +\end{proof} + +We recall several analytic projective facts used in these arguments. +Projective modifications and projective spaces over compact K\"ahler +bases are K\"ahler, also for singular spaces. To see the needed +positivity directly, give a relatively ample line a metric by local +relative embeddings and Fubini--Study metrics on a finite base cover, +scaling back from the relatively very ample powers. Patch weights on +the actual line by a partition from the base. In a local embedding, +the active coordinates and frame changes lift to ambient holomorphic +germs. Base cutoffs have zero first and second derivatives in +vertical directions, so the patched weight has positive Levi form on +vertical Zariski tangent vectors. Add a large multiple of a pulled-back +base K\"ahler potential. One multiplier works on compact regions: +otherwise a sequence of unit tangent vectors on shrinking compact +charts would limit to a vertical tangent vector contradicting the +strict vertical positivity. The Zariski tangent spaces vary in a +closed set in a fixed local embedding. Squared absolute values of +defining equations adjust the extensions to strict ambient +positivity. This also treats finite morphisms, for which the trivial +line is relatively ample; compare \cite{VarouchasKahler}. + +Common resolutions in projective diagrams are obtained by graph or +fiber products followed by projective log resolution. Relative +ampleness composes after adding sufficiently large pullback multiples +from below, locally over compacta. A curve on the base of a +projective surjection has a curve lift: pull back to its normalization, +a projective curve, and use relative generation and base twists to +make the total space projective; then take curve sections. This +justifies all curve lifts above and below. Individual projective +fibers permit the usual curve sections and the projective Kleiman +criterion. + +The established local inputs are the relative klt cone and base point +free theorems for projective analytic morphisms over Stein +neighborhoods of compacta satisfying property (P), and the big-klt +adjoint finite-generation theorem. We can take arbitrarily small +compact coordinate neighborhoods cut out by balls or polydiscs, with +Stein ambient neighborhoods and the required finite-component +intersection property. We use the cone theorem with its finite +negative-ray decomposition after a positive relatively ample +truncation. We use base point freeness in the following integral +form: if $L$ is relatively nef Cartier and +$aL-(K+\Gamma)$ is relatively ample for some positive integer $a$, +then every sufficiently high integral power of $L$ is relatively +generated after shrinking. See +\cite[Theorems~6.2, 6.5, and 7.2]{FujinoAnalyticMMP}. + +\begin{lemma}[Integral klt descent] +\label{bir:integral-descent} +Let $f:T\to Z$ be projective bimeromorphic with normal target. Suppose +an ordinary klt adjoint is $f$-antiample. If an integral line bundle +$L$ has degree zero on every contracted curve, then $f_*L$ is a line +bundle and evaluation is an isomorphism +\begin{equation} + f^*(f_*L)\simeq L. + \label{bir:integral-pullback} +\end{equation} +\end{lemma} + +\begin{proof} +The line $L$ is relatively nef, and the base point free hypothesis +holds by fiberwise ampleness. Locally over a smaller base neighborhood, +all sufficiently high powers are generated. The induced maps are +constant on each connected fiber, since their tautological lines have +degree zero on every curve there. They factor through $Z$: the graph +projection is finite bimeromorphic onto the normal base. The pulled-back +tautological lines descend two consecutive powers of $L$, and their +quotient descends $L$ itself. The projection formula identifies the +descent with $f_*L$ and the pullback map with evaluation. These +intrinsic identifications agree on overlaps. +\end{proof} + +\subsection{Finite generation, nonextraction, and continuation} +\label{bir:finite-generation} + +The finite-generation result we use is +\cite[Theorem~3.1]{DHPFourfoldMMP}: on a smooth space projective over +the indicated analytic base, multigraded rings of rational adjoints +with simultaneous SNC effective subunit boundaries and a common +relatively ample rational part are locally finitely generated, after +clearing denominators. The relevant sums are klt. All applications +here are over bimeromorphic projective bases, so the relative bigness +conditions hold. The analytic projective big-klt framework and +finiteness of models are also described in +\cite[Theorem~E]{FujinoAnalyticMMP}. Neither citation is used as an +arbitrary termination theorem over a nonprojective base. + +We spell out the reduction to that theorem. Over a Stein base in the +bimeromorphic case, the direct image of either sign of an actual line +bundle is a coherent sheaf of generic rank one. Cartan generation +therefore supplies a nonzero section after shrinking. Thus both signs +have local-over-base effective meromorphic representatives. Local +canonical representatives can be obtained in the same way, or from +forms pulled back from general local projections downstairs. + +For finitely many effective rational klt boundaries containing a +common positive relatively ample part, take a simultaneous projective +log resolution $a:S\to T$. Add effective exceptional corrections to +their log pullbacks so that the resulting SNC boundaries +$\Gamma'_j$ are effective and have exceptional coefficients strictly +between zero and one. Choose an effective exceptional divisor $E$ +with $-E$ resolution-ample, by composing the exceptional antiample +choices for the successive blowups. If $H$ is the common effective +ample part below, then $a^*H-\beta E$ is relatively ample for sufficiently +small $\beta>0$. A common small multiple can be removed from each +$\Gamma'_j$ while preserving effectiveness and subunit coefficients: +the strict transforms contain the common part, and the exceptional +coefficients have positive margins. Relatively ample summands may +also be represented by divided free general divisors after relative +generation, Stein sections, and analytic Bertini. The smooth theorem +applies. Effective exceptional corrections leave the cleared adjoint +rings unchanged by projection to a normal space. The finitely many +actual bundle identifications can be powered and tensored +simultaneously, so they identify the multigraded rings multiplicatively. + +In particular, a single rational klt adjoint has locally finitely +generated ring in this setting. Add a sufficiently small positive +rational multiple of the sum of effective representatives of opposite +relatively ample integral bundles. Their sum is actually linearly +equivalent to zero. The addition supplies the common ample part and +preserves klt on a fixed resolution near the compactum. This +replacement uses the projective bimeromorphic Stein setting +essentially. + +\begin{lemma}[Relative Proj extracts no divisors] +\label{bir:proj-nonextraction} +Let $X_0$ be normal and projective bimeromorphic over a normal compact +base $T_0$. Let $L$ be a rational line whose cleared relative ring is +locally finitely generated. The normalized main component $Y$ of the +relative Proj is projective bimeromorphic over $T_0$; +$X_0\dashrightarrow Y$ extracts no divisors, and the reflexive trace +of $L$ on $Y$ is an actual relatively ample rational line. +\end{lemma} + +\begin{proof} +Compactness permits a common divisible integer $m$ such that the +relative ring of $mL$ is generated in degree one. Resolve its base +ideal and graph, and denote the maps to $X_0$ and $Y$ by $p$ and $q$. +The map to Proj lifts to the normalization. There is an actual +moving/fixed decomposition +\begin{equation} + p^*(mL)=q^*H+G,\qquad G\geq0, + \label{bir:proj-decomposition} +\end{equation} +where $H$ is the relatively ample tautological line on $Y$. Degree-one +generation and projection show that every relative section of +$p^*(kmL)$ has vanishing at least $kG$. + +First, $G$ is $q$-exceptional. If a component mapped to a prime on +$Y$, then $q$ would be an isomorphism at its general point. For large +$k$, relative ample generation of +$q_*\OO(G)\otimes H^{\otimes k}$ gives a local-over-base section having +a pole at that prime relative to $H^{\otimes k}$. Multiplying its +pullback by the section of $(k-1)G$ gives a section of $p^*(kmL)$ whose +vanishing is less than $kG$, a contradiction. + +Second, every $p$-exceptional prime $P$ is $q$-exceptional. Otherwise +relative generation of $q_*\OO(P)\otimes H^{\otimes k}$ gives a section +with a pole at the image prime. Add $kG$ to obtain a section of +$p^*(kmL)+P$. Since $p_*\OO(P)=\OO_{X_0}$ by normality, it comes from +the original ring. As a section of the enlarged line it must vanish +once along $P$, whereas the chosen pole prevents that vanishing. +Here the coefficient of $G$ at $P$ is zero by the first part. This is +again a contradiction. Thus no divisor is extracted. Taking the +trace of~\eqref{bir:proj-decomposition} gives $L_Y=H/m$ as actual +rational lines. +\end{proof} + +\begin{lemma}[Finitely many marked models] +\label{bir:finite-models} +For a rational polytope of actual adjoints satisfying the preceding +local multigraded finite-generation hypotheses, only finitely many +marked normalized main relative Proj models occur at rational +parameters. +\end{lemma} + +\begin{proof} +After a common Veronese and shrinking, choose finitely many homogeneous +generators of the multigraded ring. Diagonal rings on rational degree +rays are finitely generated by the semigroup argument for monomial +degrees. Their Proj charts can be taken with homogeneous monomials as +denominators. The subsets of generators that occur as supports of +monomials on the specified positive degree ray form a finite pattern. +Localization at such a monomial inverts exactly its support, and the +multidegree-zero subring is the degree-zero localization of the +diagonal ring. Intersections use unions of supports with the +canonical localization maps. Thus parameters with the same pattern +have the same charts and gluing. Taking the main component and +normalization preserves finiteness. + +The base identification fixes the marking on the common bimeromorphic +open. A finite collection of the smaller neighborhoods covers the +compact base. If two marked models agree on each neighborhood, their +identifications over the base agree on the common dense open, hence +everywhere, and glue uniquely. There are consequently only finitely +many global marked possibilities. +\end{proof} + +\begin{proposition}[Relative continuation in the global strong category] +\label{bir:continuation} +Let $(T,B)$ be an effective rational klt or dlt pair satisfying the +conventions above, and suppose $T$ is projective bimeromorphic over a +normal compact K\"ahler space $V$. If $K_T+B$ is not curve-nef over +$V$, there is an elementary negative step over $V$. Its next space +remains projective over $V$, compact K\"ahler, and globally strongly +$\Q$-factorial, and the appropriate singularity type is preserved. +\end{proposition} + +\begin{proof} +Use the finite-dimensional space of degrees of global rational line +bundles on curves contracted over $V$; finite dimensionality follows +from first Chern classes in finite-dimensional cohomology. For a +fixed relatively ample $H$, the closed curve cone has a compact slice +of $H$-degree one. Indeed, for every global line $L$, both +$kH+L$ and $kH-L$ are relatively ample for sufficiently large $k$, so +all coordinates on the normalized slice are bounded. + +Choose a negative extremal ray. For dlt input decrease the floor +coefficients rationally just enough to obtain a klt adjoint $J_0$ +still negative on this ray; for klt input let $J_0=K_T+B$. Cover the +base by interiors of finitely many Stein compacta as above. Projecting +the local cone decompositions to global degrees shows that, for each +positive rational $\delta$, the normalized slice lies in the convex +hull of its compact part $J_0+\delta H\geq0$ and finitely many points +of actual contracted curves. A projected remainder stays in the +global closed cone, and a remainder of zero $H$-degree contributes +zero. The stated convex hull is compact. + +Choose $\delta$ so that the selected ray is strictly in the truncated +negative region. It is therefore represented by an actual curve. +Separating its point on the slice from the compact hull of the +remaining generators and remainder gives a supporting nef class +vanishing only on this ray. In the open set of such supports one can +choose a rational global line $N$ in the rational annihilator of the +ray, so that a positive multiple of $N$ minus $J_0$ is relatively +ample. Strict positivity on the compact slice and fiberwise +ampleness give this last assertion. Local klt base point freeness on +the finite cover generates a common multiple of $N$. Its section +morphism and Stein factorization give a projective bimeromorphic +contraction $f:T\to Z$ over $V$, with normal target and connected +fibers, contracting precisely the ray. The line $-J_0$ is +$f$-ample by fiberwise ampleness. + +If an exceptional prime $E$ exists, it is rational Cartier and +negativity gives $E$ strictly negative degree on the ray. All +contracted curves lie in $E$; they cover the nontrivial fibers. There +can be no second exceptional prime, since its negative ray degree +would force the same curves, and hence $E$, into it. For a global +rank-one reflexive sheaf on $Z$, take its reflexive pullback to $T$. +It is rationally invertible. Add a rational multiple of $E$ to kill +its ray degree and apply Lemma~\ref{bir:integral-descent} after +clearing denominators. The descended rational line agrees with the +given sheaf off codimension two on $Z$ and hence everywhere by +reflexivity. Thus $Z$ has the required global strong property. + +If $f$ is small, apply the preceding finite generation over $Z$ to +$J_0$. Lemma~\ref{bir:proj-nonextraction} gives a projective positive +model with no extracted divisors; it is therefore small over $Z$. +The transformed adjoint is relatively ample and rationally invertible. +For any global line $L$ on $T$, killing the ray degree and applying +integral descent gives an actual rational identity +\begin{equation} + L=cJ_0+f^*M,\qquad c\in\Q. + \label{bir:one-ray-identity} +\end{equation} +Smallness gives the corresponding identity on the positive model. +Any global rank-one reflexive sheaf there first transports to $T$, +where a power is such an $L$. Transforming back and using +\eqref{bir:one-ray-identity} proves the global strong property on the +positive model. The positive morphism cannot be an isomorphism, +since that would make $J_0$ a pullback from $Z$. + +For dlt input the unperturbed adjoint has negative degree on the ray. +Its version of~\eqref{bir:one-ray-identity} has $c>0$, so its transform +has the positive sign as well. Lemma~\ref{bir:comparison} preserves +the required singularities. All resulting spaces are projective +bimeromorphic over $V$ and hence compact K\"ahler, so the construction +can continue whenever relative curve-nefness fails. +\end{proof} + +\subsection{Two finiteness counts and transversal adjunction} +\label{bir:counts} + +\begin{lemma}[Divisorial count] +\label{bir:cycle-count} +A sequence of bimeromorphic transformations extracting no divisors +between normal irreducible compact K\"ahler $n$-folds contracts +divisors only finitely often. +\end{lemma} + +\begin{proof} +Count the dimension of the span of prime $(n-1)$-cycle classes in +$H_{2n-2}(-,\R)$. This is a finite nonnegative integer, since compact +analytic spaces are triangulable and have finite-dimensional homology. +Nonextraction provides common isomorphic opens whose complement in +the target has dimension at most $n-2$. The localization sequence +identifies the target's degree-$2n-2$ homology with the Borel--Moore +homology of that open. Restriction from the source maps its prime-cycle +span onto the target's span by strict transforms, killing the classes +of lost primes. Each lost prime has nonzero class by its positive +K\"ahler volume, so the count strictly drops. + +For completeness, that volume detects a topological class also on a +normal singular space. K\"ahler potentials with pluriharmonic +differences determine a class in $H^2(-,\R)$ through the real-part +sequence +$0\to\ii\R\to\OO\to\mathcal{PH}\to0$, with a fixed normalization. +If pluriharmonicity is initially known only on the regular locus, +pull the difference to a resolution. Its smooth pullback is +pluriharmonic. Near the compact fiber over a point, choose holomorphic +real-part primitives and adjust imaginary constants to make their +values on that fiber agree. The real part is constant there, and +each irreducible fiber germ forces the holomorphic primitive to be +constant there. The primitives therefore agree on overlaps near +the fiber. A finite cover and smaller neighborhoods glue them on a +neighborhood of the whole fiber, and properness and normality descend +them. Thus the original difference is locally a holomorphic real +part. Resolving a compact prime cycle now evaluates the corresponding +class power as the strictly positive integral of the pulled-back +K\"ahler form. Its fundamental class pushes to the stated cycle +class. +\end{proof} + +\begin{lemma}[Strict low-discrepancy counts] +\label{bir:low-count} +For a compact ordinary rational klt pair there exists +$0<\epsilon\leq1$ such that every discrepancy is at least $\epsilon$ +and only finitely many exceptional places have log discrepancy +strictly less than $1+\epsilon$. In particular all exceptional places +of discrepancy at most one can be realized on a single projective +SNC resolution. For a terminal pair with largest boundary +coefficient $b_0$ (zero for empty boundary), the exceptional places +of discrepancy strictly less than $2-b_0$ are finite. For an lc +pair the first assertion has the same form when restricted to +centers not contained in its non-klt locus. +\end{lemma} + +\begin{proof} +On an SNC resolution let the log-pullback coefficients be $d_j<1$, +put $w_j=1-d_j$, and take +$\epsilon=\min(1,\min_jw_j)$, with value one if the list is empty. +For a place still exceptional over this resolution, choose at the +general point of its center normal coordinates $x_1,\ldots,x_s$, +the first $b$ defining the boundary components through the center. +The top exterior Jacobian calculation gives +\begin{equation} + a_E\ \geq\ \sum_{j=1}^{b}w_j\ord_E(x_j) + +\sum_{j=b+1}^{s}\ord_E(x_j). + \label{bir:jacobian-bound} +\end{equation} +At most one differential saves one order by normal differentiation +along the place. This proves the lower bound. A place in the +strict cutoff must have center a stratum: an additional normal +coordinate would give at least $1+\epsilon$ (or at least two if no +boundary is present). + +Blow up that closed stratum. Its new SNC weight is the sum of the +passing weights, and the next center lies in the new exceptional +component. Until the place is divisorial, only strata of codimension +at least two can occur; each next weight increases by at least +$\epsilon$. The fixed strict cutoff bounds the chain length, and +there are finitely many strata at each stage. The finitely many +exceptionals already on the starting resolution complete the count. +All these blowups can be made globally and projectively. + +For a terminal pair, exceptional log-pullback coefficients are +negative. The same calculation uses the strict cutoff $2-b_0$; +non-stratum centers and centers involving such exceptional +components cannot contribute new places below it. For the lc +version take the minimum of one and the strictly positive weights. +A center not contained in the non-klt locus meets no zero-weight +component generically, so the same argument applies. +\end{proof} + +\begin{lemma}[Transversal surface calculation] +\label{bir:transversal} +Let a normal analytic space carry an ordinary rational Weil boundary +with rationally Cartier adjoint. At an analytically general point +of a codimension-two irreducible locus, a general transversal surface +cut is normal and the crepant formula on a simultaneous log resolution +restricts to its exact surface crepant formula. For a coefficient-one +prime, normalized divisorial adjunction is computed by normalized +curve adjunction on this cut. +\end{lemma} + +\begin{proof} +Choose local parameters $t_1,\ldots,t_{n-2}$ along the locus from an +embedding. Take a sufficiently general nearby common value, regular +on the smooth locus, upstairs on a projective log resolution, and on +all relevant smooth strata; discard images of nondominating strata. +The cut upstairs is a smooth surface, with the required SNC support, +and no component is exceptional. Codimension-two bad loci are cut +to isolated points. + +The surface downstairs has dimension two and is regular in +codimension one. It is Cohen--Macaulay as well. Indeed the +non-Cohen--Macaulay locus of +a normal analytic space has codimension at least three, by the local +depth/coherent Ext criterion and normality at height at most two. +Thus at the chosen general point the parameters are a regular +sequence. The cut is generically reduced and Cohen--Macaulay, hence +reduced; Serre's criterion gives normality. Read the restricted +boundary transversely as a cycle and take its closure. Complete +intersection adjunction off the isolated bad set, followed by +reflexive extension, identifies the restricted rational adjoint with +$K_S+B_S$, using division by the same parameter volume form upstairs +and downstairs. The restriction of the crepant formula has the +correct nonexceptional coefficients. Any difference from the +surface crepant formula is exceptional and relatively numerically +zero, hence zero by both signs of negativity. This also restricts +klt formulas, or dlt formulas from resolutions preserving an SNC +good open, with their stated discrepancies. + +For a coefficient-one prime, first subtract its smooth strict +transform in the resolved formula, then take residue and push to +its normalization. At general points over the chosen +codimension-two locus, the cut of that strict transform is a smooth +curve germ, finite and generically an isomorphism onto its branch of +the reduced surface curve. It is therefore the curve normalization. +Transversality preserves coefficient orders. Restricting first to +the surface and then taking residue gives the same result. Only +the indicated sums need be rational Cartier on the normalization; +the individual canonical and boundary terms need not be. +\end{proof} + +\subsection{Extraction of prescribed low places} +\label{bir:extraction-section} + +\begin{proposition}[Low extraction] +\label{bir:low-extraction} +Let $(T,B)$ be an ordinary rational klt pair on a normal globally +strongly $\Q$-factorial compact K\"ahler space. Any specified set of +exceptional places of log discrepancy at most one can be extracted, +and no other exceptional prime extracted, by a projective crepant +morphism $Y\to T$ with effective klt boundary, where $Y$ is normal, +compact K\"ahler, and globally strongly $\Q$-factorial. +\end{proposition} + +\begin{proof} +The set is finite by Lemma~\ref{bir:low-count}. Choose a projective +SNC resolution $h:R\to T$ carrying it. Put an effective SNC klt +boundary $\Theta$ on $R$, retaining the strict boundary and the +crepant coefficients of the specified primes, and choosing every +other exceptional coefficient strictly above its crepant value. +With $J=K_T+B$ this gives +\begin{equation} + D(0)=K_R+\Theta=h^*J+P,\qquad P\geq0, + \label{bir:extraction-origin} +\end{equation} +where $P$ is supported exactly on the undesired exceptionals. + +Fix an $h$-ample line $H_0$ and let $E_1,\ldots,E_N$ be all +exceptional primes of $R$. On a small full-dimensional rational +polytope in formal coefficient space consider +\begin{equation} + D(u)=D(0)+u_0H_0+\sum_{i=1}^{N}u_iE_i, + \qquad u_0\geq0,\quad |u_i|\leq\eta u_0. + \label{bir:extraction-polytope} +\end{equation} +Choose $\eta>0$ small enough that the perturbation is relatively ample +at every nonzero parameter, and then make the polytope small enough. +On the finitely many Stein neighborhoods choose effective +representatives of $H_0,-H_0$, and $\pm E_i$. A small common positive +multiple of the effective sum representing $H_0-H_0\sim0$ supplies a +common ample part. Taking the other coefficients sufficiently small +on a simultaneous resolution gives equivalent ordinary klt adjoints +at the vertices. Lemmas~\ref{bir:proj-nonextraction} +and~\ref{bir:finite-models} give finitely many marked normal relatively +ample models over $T$ for all rational parameters. + +For each model occurring arbitrarily near zero, take the affine spans +of its parameter sets in successively smaller punctured +neighborhoods. These nested affine spaces eventually stabilize. +Discard models not accumulating at zero. If every eventual span +were proper, finitely many proper affine subspaces would cover all +sufficiently small rational points in the full-dimensional cone, +which is impossible. Thus one marked model $Y$ occurs arbitrarily +near zero with full eventual affine span. + +Choose affinely independent rational parameters for this model. +Their actual ample adjoint traces solve a rational linear system for +the traces of $D(0),H_0,E_1,\ldots,E_N$ in the group of rank-one +reflexive sheaves tensored with $\Q$. All these traces are therefore +actual rational line bundles. A sequence of its parameters tending +to zero makes $D(0)_Y$ curve-nef over $T$. Taking +\eqref{bir:extraction-origin} in codimension one gives the actual +identity $D(0)_Y=h_Y^*J+P_Y$, with $P_Y$ effective exceptional. +Negativity forces $P_Y=0$. + +No specified prime is lost. At a nonzero parameter defining $Y$, +the relative system of a divisible power of $D(u)$ contains the +system of the ample perturbation, multiplied by the section of the +corresponding power of $P$ and a base pullback. It embeds relatively +at general points outside $\Supp P$. Every specified prime has +generic point there, including a discrepancy-one prime whose +crepant boundary coefficient is zero. It cannot be contracted. +Thus $Y\to T$ is crepant with precisely the prescribed exceptional +primes and effective klt boundary. + +Each surviving exceptional prime is rational Cartier by the traces +of the $E_i$. For an arbitrary global rank-one reflexive sheaf on +$Y$, its trace on $T$ has an invertible power by the global strong +hypothesis. Lemma~\ref{bir:sheaf-comparison} expresses the +corresponding power upstairs as a pullback line with an integral +exceptional correction. Clearing the rational Cartier denominators +of that correction makes a further power invertible. This proves +the global strong property. Projectivity over the compact K\"ahler +base gives the remaining category assertions. +\end{proof} + +\subsection{Arbitrary klt birational termination through dimension three} +\label{bir:threefolds} + +\begin{proposition}[Terminal threefold termination] +\label{bir:terminal-termination} +An arbitrary sequence of elementary birational steps for an effective +rational terminal pair of dimension at most three is finite. Here +terminal means that all exceptional log discrepancies are greater +than one. No pseudo-effectivity hypothesis is required. +\end{proposition} + +\begin{proof} +In dimensions at most two there are no nontrivial small diagrams, and +Lemma~\ref{bir:cycle-count} handles divisorial contractions. In +dimension three discard a finite prefix to make all steps small. +Terminality persists by Lemma~\ref{bir:comparison}. The underlying +threefold singularities are ordinary terminal: deleting the effective +rational Cartier boundary does not decrease discrepancies. In +particular they are smooth at general curve points. This conclusion +also holds for local analytic places. On a global resolution the +exceptional coefficients for the empty boundary are negative; local +places still exceptional over that smooth resolution have ordinary +log discrepancy at least two. + +Let $b$ be the largest boundary coefficient, or zero for empty +boundary. The coefficient set is fixed under small steps. If $b>0$, +test each step whose positive side has a flipped curve contained in +a coefficient-$b$ component. If $b=0$, test every step with any +flipped curve; a nontrivial positive side exists by the ample-sign +argument in Lemma~\ref{bir:comparison}. Blowing up the generic point +of that curve on the positive side gives an exceptional place with +log discrepancy +\begin{equation} + t=2-\sum_j m_jb_j\leq2-b, + \label{bir:terminal-test} +\end{equation} +where $m_j$ are nonnegative integral multiplicities. One can realize +this place by the normalized blowup of the whole curve. Positivity +and the fixed boundary denominators make the possible $t$ a finite +set. For each such $t$, the number of exceptional places with +discrepancy strictly below $t$ is finite by +Lemma~\ref{bir:low-count}. These counts do not increase. At a tested +step its tested place had discrepancy strictly below $t$ before the +step and equals $t$ afterwards, so the corresponding count drops. +Only finitely many tested steps occur. + +If $b>0$, consider the normalizations of the finitely many +coefficient-$b$ surfaces on the remaining tail. Both sides map +bimeromorphically to the normalization of their common image in the +contraction base. The positive map contracts no curve and is +therefore an isomorphism. The negative normalization consequently +maps projectively bimeromorphically to the next normalization, +contracting a curve whenever the corresponding surface contains a +flipping curve. These are compact K\"ahler surfaces. The cycle +count leaves a tail on which no maximal-coefficient component +contains a contracted curve on either side. + +Remove all maximal-coefficient components from the boundary on this +tail. The new adjoint is still negative, because an effective +rational Cartier divisor has nonnegative degree on a curve not +contained in it. Its one-ray identity with the original adjoint, +obtained by Lemma~\ref{bir:integral-descent}, has a positive rational +coefficient. Smallness then makes its transform relatively positive. +Terminality persists after decreasing the boundary. Induct on the +number of distinct positive boundary coefficients. The empty-boundary +case was handled by testing every step, so the sequence is finite. +\end{proof} + +We require a uniform index statement to pass from klt to terminal +pairs. The local terminal-point results used are the classical +complex analytic threefold theorems of Mori--Reid and Kawamata. If a +terminal point has canonical index $r>1$, there is an exceptional +place centered there with ordinary log discrepancy $1+1/r$; see +\cite{KawamataTerminalDiscrepancy}. Also, the index of every integral +$\Q$-Cartier Weil divisor germ divides $r$, including when $r=1$. +For the latter statement, the analytic index-one cover is smooth or +an isolated cDV hypersurface, with simply connected punctured small +neighborhood. The connectivity theorem for isolated hypersurface +links and the analytic Kummer sequence make its germ divisor class +group torsion-free. Pulling up a $\Q$-Cartier divisor therefore makes +it principal, and the norm gives the divisibility downstairs. The +small-discrepancy place can be detected globally on a compact +terminal space: on a global resolution the empty-boundary exceptional +coefficients are negative, so a local place still exceptional over +the resolution has discrepancy at least two. A place of discrepancy +$1+1/r<2$ must already be a component of its restricted exceptional +divisor and hence a global exceptional place. + +\begin{lemma}[A surface estimate for a single extraction] +\label{bir:surface-estimate} +Let $h:U\to T$ extract only a prime $P$ from an effective rational +klt threefold pair as in Proposition~\ref{bir:low-extraction}. Write +its crepant boundary as $B^{\mathrm{str}}+(1-a)P$, where $00$ such +that $\mathcal F^{[I(n,\epsilon)]}$ is invertible for every global +rank-one reflexive sheaf $\mathcal F$ on each such space. +\end{proposition} + +\begin{proof} +For $n=0$ the underlying space is terminal with the ordinary +exceptional discrepancy gap $1+\epsilon$. The terminal-point +statement above bounds every canonical index by +$\lfloor1/\epsilon\rfloor$. A global rank-one reflexive sheaf has +$\Q$-Cartier germs by the global strong hypothesis, so its local +indices divide those canonical indices. Their bounded common +multiple gives $I(0,\epsilon)$. + +Induct on $n$, seeking a multiple of previous bounds. If there is no +low place use the previous case. Otherwise extract only a place +$P$ of discrepancy $a\in[\epsilon,1]$ by +Proposition~\ref{bir:low-extraction}. The pair on $U$ has effective +crepant boundary $B^{\mathrm{str}}+(1-a)P$. Its exceptional places +are exceptional downstairs, except that $P$ is no longer counted; +all hypotheses hold with $n-1$. Set $I'=I(n-1,\epsilon)$. + +For the curve in Lemma~\ref{bir:surface-estimate}, crepancy and +effectiveness of $B^{\mathrm{str}}$ give +\begin{equation} + -3\leq (K_U+P+B^{\mathrm{str}})\cdot C + =aP\cdot C<0. + \label{bir:index-degree} +\end{equation} +Let $\mathcal F$ be a global rank-one reflexive sheaf on $T$, and +let $\mathcal F_U$ denote its reflexive sheaf pullback. Distinguish +this from the rational line pullback defined by an invertible power +of $\mathcal F$. Their meromorphic comparison has the actual +rational-line form +\begin{equation} + h^*\mathcal F=\mathcal F_U+sP. + \label{bir:index-correction} +\end{equation} +Both $I'\mathcal F_U$ and $I'P$ are integral lines. Degree zero of +the left side on $C$ gives +\begin{equation} + s=\frac{I'\mathcal F_U\cdot C}{-I'P\cdot C}, + \qquad 1\leq -I'P\cdot C\leq\frac{3I'}{\epsilon}. + \label{bir:index-denominator} +\end{equation} +The numerator and denominator are integers. Put +\begin{equation} + I=I'\operatorname{lcm} + \{1,\ldots,\lceil3I'/\epsilon\rceil\}. + \label{bir:index-recursion} +\end{equation} +Then $I$ and $Is$ are multiples of $I'$, so +$I\mathcal F_U+(Is)P$ is an integral line of zero degree on all +contracted curves. Increase the crepant coefficient of $P$ by a +sufficiently small positive rational number. The pair remains klt, +and its adjoint is relatively antiample because $-P$ is ample. +Lemma~\ref{bir:integral-descent} descends this integral line. Its +descent agrees with $\mathcal F^{[I]}$ away from the codimension-two +center of the extraction, hence everywhere by reflexivity. This +proves the induction. +\end{proof} + +\begin{theorem}[Klt termination through dimension three] +\label{bir:klt-termination} +Every arbitrary sequence of elementary birational steps for effective +rational klt pairs of dimension at most three is finite, without a +pseudo-effectivity hypothesis. +\end{theorem} + +\begin{proof} +Only dimension three remains. Suppose there is an infinite +sequence; after the cycle count all steps are small. The finite sets +of exceptional places of discrepancy at most one are nonincreasing, +so stabilize to a set $\mathcal E$. There is a uniform positive +$\epsilon$ of the type in Proposition~\ref{bir:index} on this tail. +Indeed start with Lemma~\ref{bir:low-count} on its first model. Only +finitely many places lie below its strict cutoff $1+\epsilon_0$; +outside $\mathcal E$ their discrepancies are greater than one, with +a positive minimum gap. Take the minimum of this gap, +$\epsilon_0$, and the positive starting discrepancy lower bound. +All subsequent comparisons are nondecreasing. + +The boundary denominators are fixed. Proposition~\ref{bir:index} +gives a common denominator for the actual adjoints on all models of +the tail, and hence for all discrepancies by the crepant formulas. +The nondecreasing values on $\mathcal E$, bounded above by one, +therefore eventually become constant. Over the first model of this +stabilized tail extract exactly $\mathcal E$ crepantly. The +resulting pair is terminal with effective boundary and is globally +strongly $\Q$-factorial. + +Lift a flip $X_-\dashrightarrow X_+$ over $Z$ from its extracted +terminal model $Y_0\to X_-$. Run relative elementary steps over $Z$ +using Proposition~\ref{bir:continuation}. On a common projective +resolution of any finite prefix ending at $Y$, denote the pulled-back +adjoints of $Y_0,Y,X_+$ by $P_0,P,P_+$ respectively. The comparisons +give +\begin{equation} + P_0=P+G=P_++F, + \qquad G,F\geq0, + \label{bir:terminal-lift} +\end{equation} +where $G$ is exceptional over $Y$ and $F$ is exceptional over $X_+$. +The line $P_+$ is nef over $Z$. Over $Y$ the divisor +$G-F=P_+-P$ is nef and has nonpositive pushforward; negativity gives +$G\leq F$, before any termination is known. A lost prime of $Y_0$ +would have positive coefficient in $G$, but zero coefficient in $F$: +this follows from smallness below for old primes and from constancy +of discrepancies on $\mathcal E$ for the extracted ones. Thus no +prime is lost. The run stays small and terminal, so +Proposition~\ref{bir:terminal-termination} makes it finite. Its +endpoint has $P$ nef over $Z$. + +At the endpoint negativity over $X_+$ applied to $F-G=P-P_+$ gives +the opposite inequality, hence $P=P_+$. Since the adjoint on $X_+$ +is relatively ample, its projection from the common resolution is +constant on the fibers over $Y$: otherwise a curve in a connected +projective fiber would have positive pullback degree. Factoring the +graph over the normal space $Y$ gives a projective crepant morphism +$Y\to X_+$. It extracts the same places, by smallness below and the +absence of lost primes, so the construction repeats. + +Each nontrivial flip below forces a negative step in its lift, by +lifting a negative curve. Infinitely many flips would concatenate +to an infinite small terminal sequence with effective strictly +transformed boundary, contrary to +Proposition~\ref{bir:terminal-termination}. This proves the theorem. +\end{proof} + +\subsection{Adjunction and special termination for dlt pairs} +\label{bir:dlt-section} + +\begin{lemma}[Actual adjunction on normalized strata] +\label{bir:stratum-adjunction} +Let $(V,A)$ be an ordinary effective rational dlt pair, and let $T$ +be the normalization of an lc center, with map $\nu:T\to V$. A +chain of coefficient-one primes through its generic SNC stratum +gives an effective dlt adjunction pair $(T,A_T)$ and an actual +rational-line identification +\begin{equation} + J_T=K_T+A_T=\nu^*(K_V+A). + \label{bir:stratum-line} +\end{equation} +Its lc centers map to proper lc subcenters of the given center. +If the ambient coefficients belong to a DCC subset of $[0,1]$, the +adjunction coefficients belong to a DCC set depending only on that +set and the chain length. In sufficiently divisible even powers, +the identification is the canonical meromorphic residue +identification, independent of the resolution and of the order of +the generic residues. No global strong $\Q$-factoriality of $T$ is +asserted. +\end{lemma} + +\begin{proof} +The lc centers are the images of the finitely many coefficient-one +strata on a log resolution, and each is generically an SNC floor +stratum. Order the floor components defining the chosen generic +chain. Take a projective log resolution isomorphic over an SNC +open meeting all lc centers. Successively restrict its crepant +formula to the smooth strict strata by residue, then push the +adjunction boundaries in codimension one to their normalizations. +At each stage the SNC log pullback has coefficients at most one, +and its rational adjoint is the restriction of the ambient actual +line. Reflexive extension gives~\eqref{bir:stratum-line}; any +exceptional difference from the crepant comparison is numerically +zero and vanishes by both signs of negativity. A discrepancy-zero +stratum of a restricted formula comes from an ambient +coefficient-one stratum whose image meets the good open. This gives +the sub-dlt discrepancy and good-open properties, and identifies +nested lc centers by the generic SNC calculation. + +There is also a canonical meromorphic comparison, not merely an +abstract equality of line classes. On a smooth strict stratum the +residue of the ambient log-pullback frame has exactly the pole and +zero orders of the remaining crepant boundary. It therefore gives +the frame of the pushed adjunction in codimension one on the +normalization. Extending the line identification reflexively and +composing with the natural embedding of its divisorial adjoint +sheaf into meromorphic pluricanonical tensors gives the claimed +map. Different resolutions give the same map on the dense generic +SNC stratum, and hence everywhere meromorphically. Permuting the +residues changes only signs, removed in even degree. Sequential +adjunction through normalized intermediate strata agrees with this +strict-chain calculation by the same dense-open test. In +particular all codimension-one boundary orders agree. + +We prove effectivity and the DCC assertion at one restriction step; +iteration then proves the statement. By +Lemma~\ref{bir:transversal}, a tested different coefficient is a +normalized-curve coefficient on a normal dlt surface with a +coefficient-one branch. If the tested point is an lc center, the +surface pair is SNC there. Indeed on a sliced log resolution +preserving the good open, a zero center must lift to the intersection +of two strict floor curves, with no exceptional locus through it; +the resolution is an isomorphism there. + +Otherwise deleting the boundary leaves a numerically klt surface +germ. The Mumford numerical pullbacks of effective terms are +effective by negative definiteness. We recall why this is ordinary +klt even if rational Cartierness of the separate canonical term has +not yet been established. On the minimal resolution of the +singular germ, write +\[ + M=(E_i\cdot E_j)<0,\qquad + K_S-\pi^*_{\mathrm{num}}K=\sum_i a_iE_i. +\] +The numerical klt condition gives $a_i>-1$. Relative nefness of +$K_S$, from minimality and curve adjunction, gives $Ma\geq0$ and +hence $a_i\leq0$. For any nonzero effective integral exceptional +cycle $Y=\sum n_iE_i$, set $c_i=n_i+a_i>0$ on its support and +$c_i=0$ elsewhere. Off-diagonal entries of $M$ are nonnegative, so +\begin{equation} + c^{\mathsf t}M(n+a)\leq c^{\mathsf t}Mc<0. + \label{bir:numerical-surface} +\end{equation} +Thus some supported $E_i$ has $(K_S+Y)\cdot E_i<0$. +Consequently $\OO_{E_i}(-Y+E_i)$ has degree greater than +$2p_a(E_i)-2$ and has zero $H^1$ by curve duality. Peeling off such +components with the cycle exact sequences proves +$H^1(\OO_Y)=0$ for every exceptional cycle $Y$. Grauert formal +functions gives rationality; multiples of the full exceptional +curve are cofinal with the maximal-ideal thickenings. + +An integral multiple of the numerical pullback of any Weil divisor +is now a line-bundle divisor on the resolution with all exceptional +degrees zero. Its class restricts to zero in $H^2$ of the +exceptional curve, by normalization and the degree description of +the curve's top cohomology. Continuity around the compact fiber, +or topological proper base change, makes that class zero after +shrinking. On the preimage of a small Stein neighborhood, +$H^1(\OO)=0$ by rationality. The exponential sequence makes this +line actually trivial there. Pushing in codimension one proves +that the original Weil divisor is rational Cartier; in particular +the canonical divisor is. The numerical klt test is therefore the +ordinary one. + +The analytic log-terminal surface classification now realizes the +germ as a smooth germ modulo a small finite group +\cite[Chapter~4]{BirationalGeometry}. Pull up the full boundary by +canonical pullback, which is \mbox{\'etale} in codimension one. No +exceptional place over the origin on the chart has nonpositive +discrepancy, by finite discrepancy comparison with positive +ramification factor. The point blowup therefore tests total +boundary multiplicity strictly below two. There is exactly one +smooth coefficient-one branch. The finite group preserves it and +acts faithfully on its tangent: finite actions linearize, and a +nonidentity element with trivial tangential eigenvalue would be a +quasi-reflection. Thus the group is cyclic of order $r$, also the +branch ramification index; $r=1$ is allowed. + +Residue and ramification give $1-1/r$ for the branch alone. Other +components of coefficients $d_j$ contribute intersection +multiplicities $k_j\geq0$ on the chart. The different coefficient +is consequently +\begin{equation} + 1-\frac1r+\frac{\sum_jk_jd_j}{r}, + \qquad 0\leq\sum_jk_jd_j\leq1. + \label{bir:different-coefficients} +\end{equation} +The upper bound follows from the sub-lc resolution formula. This +proves effectivity and hence the full dlt condition at this step. +Positive elements of a nonnegative DCC set have a positive minimum, +if any occur. The sums in~\eqref{bir:different-coefficients} thus +have a bounded number of positive terms, counted with multiplicity, +and satisfy DCC. In a decreasing sequence of coefficients below +one, $r$ is bounded as well, since $1-1/r$ is a lower bound. This +proves DCC for each restriction and for its iterations. +\end{proof} + +\begin{lemma}[Strict comparison on strata] +\label{bir:stratum-comparison} +Suppose a small dlt elementary step preserves the generic points of +an lc center and its chosen adjunction chain. The normalized +strata on both sides map projectively bimeromorphically to the +normalization $S$ of their common image in the contraction base. +Their adjoints are relatively antiample and ample, respectively. +On a common higher model their canonical pullback comparison +satisfies +\begin{equation} + P_T-P_{T^+}\geq0. + \label{bir:stratum-increase} +\end{equation} +The resulting discrepancy increase is strictly positive at any +place whose center on either stratum maps into the ambient +exceptional locus on that side. +\end{lemma} + +\begin{proof} +The morphisms are the restrictions of the ambient projective +morphisms followed through finite normalizations. The relative +ample signs restrict as stated. Choose a common ambient resolution +preserving the generic SNC chain. By +Lemma~\ref{bir:comparison} its effective pullback difference has +support containing the full fibers over the non-isomorphism set. +Restrict the two crepant formulas along the common strict chain. +The same coefficient-one terms are subtracted, and +Lemma~\ref{bir:stratum-adjunction} identifies the remaining canonical +comparisons. Their difference is precisely the restriction of that +effective divisor. The stratum itself is not contained in its +support, since its generic point is preserved. The full inverse +image of any indicated center is contained in the support, so +pullback gives strictly positive multiplicity at each such place. +This proves both assertions for actual crepant boundaries, rather +than only for restricted first Chern classes. +\end{proof} + +\begin{theorem}[Dlt special termination and modifications] +\label{bir:special-termination} +The following hold for ordinary rational pairs in the analytic +projective setting above. +\begin{enumerate}[label=\textup{(\roman*)}] +\item In dimension $d\leq4$, any dlt elementary sequence has a tail +whose exceptional loci on both sides are disjoint from every lc +center. +\item An ordinary rational lc pair of dimension $d\leq4$ on a +normal compact K\"ahler space, with rationally invertible adjoint, +has a projective crepant dlt modification whose total space is +globally strongly $\Q$-factorial and compact K\"ahler. The boundary +is effective, and every exceptional prime has coefficient one. +\item For $d\leq3$, every dlt elementary sequence is finite. +\end{enumerate} +The bases of the elementary steps may vary. Assertion \textup{(iii)} +is not asserted in dimension four. +\end{theorem} + +\begin{proof} +We induct simultaneously on dimension. The order within a +dimension is (i), then (ii), then (iii) when $d\leq3$. Dimension +zero is immediate. In proving (i) in dimension $d$, discard a +prefix so that all steps are small, by +Lemma~\ref{bir:cycle-count}. A zero-discrepancy place on a new +space was already a zero place. Strictness in +Lemma~\ref{bir:comparison} excludes containment of its center in +the exceptional locus. The finite lists of lc centers therefore +stabilize, and the generic point of every remaining center is +preserved at every subsequent step. + +Induct increasingly on the dimension $e$ of a surviving center; +the point case is already settled by preservation of its generic +point. Normalize its successive transforms and use the same +generic adjunction chain. By the smaller-center conclusion, the +stratum diagrams and adjunction pairs are isomorphisms near their +non-klt loci on a tail. Their discrepancies are nondecreasing by +Lemma~\ref{bir:stratum-comparison}. + +If a prime is extracted by a stratum transformation, it lies on +the new side over the ambient exceptional locus. Its earlier +discrepancy is strictly smaller than its new discrepancy, the latter +being at most one by effectivity. At the start of this tail it +therefore had discrepancy less than one and center outside the +non-klt locus, since the diagrams are unchanged near that locus. +Lemma~\ref{bir:low-count} gives finitely many possible exceptional +places; the possible nonexceptional positive-boundary primes add +only finitely many. For each such place, repeated extraction would +give a strictly decreasing sequence of boundary coefficients, by +the strict comparisons. The fixed adjunction DCC set of +Lemma~\ref{bir:stratum-adjunction} excludes infinitely many such +occurrences. After discarding a prefix there are no stratum +extractions. + +The cycle count then leaves no prime contractions by stratum +transformations either; for normal curves the diagrams are already +isomorphisms. The primes now match. Their coefficients do not +increase, and finite positive support and DCC stabilize the whole +boundary. Neither morphism of a stratum diagram to $S$ can +contract a prime on this tail: its generic point would lie over +the ambient exceptional locus, and strict discrepancy increase +would contradict the matched coefficients. Thus the stratum +diagrams are small, allowing isomorphisms, and their effective +pullback differences are exceptional over the positive stratum. +If the stratum transformation is an isomorphism, its discrepancies +agree, and strictness excludes any ambient exceptional intersection +with the stratum. One may test a divisor over a point of such an +intersection, or the point itself for a curve. + +For each remaining nontrivial stratum diagram, its dimension is +$e0, +\end{equation} +where $\mathcal M_M$ is the sheaf of meromorphic functions. Put +\begin{equation}\label{fol:canonical-comparison} + L=p^*K_Y,\qquad K_M=L+C,\qquad \alpha=2\pi c_1(L). +\end{equation} +Here $C$ is the rational exceptional discrepancy divisor, and the middle +identity is an identity of actual rational line bundles, using the +canonical comparison on the isomorphism locus of $p$. No sign is imposed +on $C$. Every prime divisor on $M$ is $p$-exceptional, because $Y$ has +none. We use the weight convention $\ddc=\ii\partial\bar\partial$, so a +metric weight on $L$ has curvature class $\alpha$. + +\subsection{Virtual vanishings and holomorphic forms} + +The starting Euler-characteristic/Hodge-theoretic route to holomorphic +forms was informed by the related forms strategy of Vikash \cite{Vikash2026}. +That work considers smooth minimal fourfolds without effective divisors +or surfaces. The present normal klt setting has different hypotheses, +and the required vanishings and forms construction are proved below. + +\begin{lemma}\label{fol:virtual-vanishing} +Let $f\colon N\to M$ be a proper surjective generically finite morphism, +where $N$ is a connected smooth compact K\"ahler manifold. Then +\begin{equation}\label{fol:virtual-data} + a(N)=q(N)=0,\qquad K_N\text{ is pseudo-effective}. +\end{equation} +and no positive tensor power of $K_N$ has a nonzero meromorphic section. +These conclusions also hold after any further smooth compact K\"ahler +modification or finite cover followed by resolution. +\end{lemma} + +\begin{proof} +First consider meromorphic functions and tensors. A proper generically +finite map of normal complex spaces factors, by Stein factorization, as a +proper modification followed by a finite map. Meromorphic functions on a +modification descend to the normal target, and finite maps have local +meromorphic traces and norms. These constructions use local meromorphic +function fields and therefore do not require a global meromorphic frame. + +If $u$ is a meromorphic function on $N$, its characteristic polynomial over +$M$, computed on the finite part of the factorization, has meromorphic +coefficients on $M$. These coefficients are constant because $a(M)=0$. +Thus $u$ satisfies a polynomial with constant coefficients. Connectedness +then makes $u$ constant, and $a(N)=0$. + +Suppose that $s$ is a nonzero meromorphic section of $mK_N$. Over a +coordinate neighborhood $U\subset M$, choose a nowhere vanishing local +frame $\tau$ of $mK_M$. The differential pullback $f^*\tau$ is a +holomorphic pluricanonical tensor, generically nonzero, so +$s/(f^*\tau)$ is a meromorphic function over $f^{-1}U$; zeros of the +Jacobian merely contribute a meromorphic divisor to this quotient. +If $d$ is the generic degree of $f$, its norm is the coefficient of a +meromorphic section of $mdK_M$: replacing $\tau$ by $g\tau$ divides the +norm by $g^d$. The local sections consequently glue and are nonzero. +This contradicts \eqref{fol:no-meromorphic}. The ordinary Jacobian +formula +\[ + K_N=f^*K_M+R_f,\qquad R_f\geq0, +\] +proves pseudo-effectivity of $K_N$. + +It remains to prove $q(N)=0$. If $q(N)>0$, the Albanese map has a +positive-dimensional image. Let $h\colon N\to B$ be its Stein +factorization onto its normal image. The space $B$ is finite over a +subvariety of a torus. On a smooth compact K\"ahler model $B'$ of $B$, +the pullbacks of suitable ambient one-forms have a nonzero wedge of +degree $\dim B$. Hence $\kappa(B')\geq0$. On every neat smooth model +used to compute the invariant base in Assumption~\ref{hyp:campana}, the +orbifold boundary is effective; birational invariance of ordinary +Kodaira dimension therefore gives +\[ + \kappa(h\mid0)\geq\kappa(B')\geq0. +\] +This comparison concerns the invariant base term, not a boundary on an +arbitrarily chosen initial model. + +Choose a positive singular metric on $K_N$. Its local potentials restrict +to almost every smooth fiber of $h$, by local integrability and Fubini's +theorem. We may choose such a fiber outside the countably many proper +analytic subsets excluded by the very-general-fiber convention in +Assumption~\ref{hyp:campana}. If $F$ is that fiber, then $K_F$ is +pseudo-effective and $\dim F\leq3$. Ordinary canonical nonvanishing for +smooth compact K\"ahler manifolds of dimension at most three gives +$\kappa(F)\geq0$. In dimension three this follows from the K\"ahler +threefold minimal model theorem and abundance for nef normal compact +K\"ahler threefold pairs; see +\cite{HPMinimalModels,DasOuAbundanceII}. In dimensions at most two it is +the classical curve and surface statement. Applying +Assumption~\ref{hyp:campana} to $(N,0)$ and $h$ gives +\[ + \kappa(N)\geq\kappa(F)+\kappa(h\mid0)\geq0, +\] +contrary to the absence of a meromorphic pluricanonical section on $N$. +The same proof applies to any further morphism of the stated kind. +\end{proof} + +In particular, $q(M)=0$. Moreover, +\begin{equation}\label{fol:nonzero-alpha} + \alpha\ne0. +\end{equation} +Indeed, if $c_1(L)=0$ in real cohomology, a multiple of $L$ has torsion +integral first Chern class. After a further multiple that class vanishes. +The exponential sequence and $H^1(M,\OO_M)=0$ make that line bundle +trivial. Equation~\eqref{fol:canonical-comparison} would then give a +meromorphic section of a positive multiple of $K_M$. + +\begin{lemma}\label{fol:eventual-vanishing} +For every holomorphic vector bundle $\mathcal V$ on $M$, +\[ + H^0(M,\mathcal V\otimes\OO_M(mL))=0 +\] +for every sufficiently large positive integer $m$ divisible by the index +of $L$. Furthermore, +\begin{equation}\label{fol:forms-dimensions} + \chi(M,\OO_M)=0,\qquad h^{2,0}(M)\geq1,\qquad h^{3,0}(M)\geq2. +\end{equation} +\end{lemma} + +\begin{proof} +Choose an integer $r>0$ such that $A=rL$ is a line bundle. A section of +$\mathcal V\otimes A^k$ is a morphism $A^{-k}\to\mathcal V$. Among +all nonzero sections with $k>0$, choose a tuple +$s_1,\ldots,s_t$, of twists $k_1,\ldots,k_t$, which is generically +independent and has maximal possible cardinality. If there are no such +sections the assertion is immediate. Otherwise $t\leq\rk\mathcal V$. +Let $\mathcal W\subset\mathcal V$ be the saturation of the image of the +corresponding direct sum of line bundles. Every further section lies in +$\mathcal W$ generically, by maximality, and hence everywhere as a map +into this saturated subsheaf. + +A further nonzero section $s$ of twist $k$ replaces at least one $s_i$ +while preserving generic independence. The two determinants are nonzero +sections, respectively, of +\[ + \det\mathcal W\otimes A^{\sum k_j} + \quad\text{and}\quad + \det\mathcal W\otimes A^{\sum k_j+k-k_i}, +\] +where determinants are reflexive. Their ratio is a nonzero meromorphic +section of $A^{k-k_i}$. For $k>\max_i k_i$, this is a positive multiple +of $L$. After clearing denominators in $C$, multiplication by its +canonical meromorphic divisor section converts it into a meromorphic +section of a positive multiple of $K_M$, contradicting +\eqref{fol:no-meromorphic}. This proves the eventual vanishing without +choosing a meromorphic frame of $A$. + +By Lemma~\ref{met:zero-lelong}, $L$ has a semipositive metric with zero +Lelong numbers everywhere. The multiplier ideal of every positive +integral multiple of this metric is trivial by Skoda integrability +\cite{SkodaIntegrability}. The hard Lefschetz theorem with multiplier +ideals \cite[Theorem~0.1]{DPSHardLefschetz} therefore gives, for every +$0\leq j\leq4$, a surjection +\[ + H^0(M,\Omega_M^{4-j}\otimes\OO_M(mL)) + \longrightarrow H^j(M,\OO_M(K_M+mL)) +\] +for divisible $m>0$. The source is zero for all sufficiently large such +$m$. Riemann--Roch makes $\chi(M,\OO_M(K_M+mL))$ a polynomial in $m$; +its vanishing on all these multiples implies that its constant term +$\chi(M,\OO_M(K_M))$ is zero. Serre duality in dimension four yields +$\chi(M,\OO_M)=0$. + +Equation~\eqref{fol:no-meromorphic} gives $h^{4,0}=0$, and +Lemma~\ref{fol:virtual-vanishing} gives $h^{1,0}=0$. If $h^{2,0}=0$, +then all of $H^2(M,\R)$ is of type $(1,1)$. Approximating a K\"ahler +class by a rational one and applying the Kodaira embedding theorem would +make $M$ projective, contrary to $a(M)=0$. Thus $h^{2,0}\geq1$. +Finally, Hodge symmetry and the Euler characteristic identity give +$h^{3,0}=1+h^{2,0}\geq2$. +\end{proof} + +\subsection{A saturated integrable conormal line} + +Write $K=K_M$. Choose $0\ne\sigma\in H^0(M,\Omega_M^2)$. Holomorphic +forms on $M$ are closed, and $\sigma^2=0$ because it is a canonical +section. Thus $\sigma$ has rank two wherever it is nonzero. The kernel +of $\sigma$ is integrable there, and its saturated conormal is a rank-two +subsheaf +\[ + F\subset\Omega_M^1,\qquad G=\Omega_M^1/F. +\] +All determinants and line factors below are taken reflexively. The form +$\sigma$ is a nonzero section of $\det F$, so +\begin{equation}\label{fol:F-and-G} + \det F=\OO_M(H),\qquad \det G=\OO_M(K-H) +\end{equation} +for an effective divisor $H$. + +We use the natural identification +$\Omega_M^3\simeq K\otimes T_M$, obtained by contraction with a local +volume form. Global linearly independent three-forms are generically +independent: coefficients of a dependence relative to a maximal +generically independent tuple are global meromorphic functions, hence +constants. The same observation applies to their projections into +$F^*\otimes K$. + +If $v$ and $w$ are the $K$-valued vector fields associated with two +three-forms, then $\sigma(v,w)$ is a section of $2K$, so it is zero. +Since the form induced by $\sigma$ on the rank-two quotient of $T_M$ is +nondegenerate at a general point, the projections of all these vector +fields to $F^*\otimes K$ have rank at most one. On the other hand, two +generically independent tangent vector fields would have a nonzero +wedge in +\[ + 2K\otimes(\det G)^*=\OO_M(K+H). +\] +Removing the divisor factor would give a prohibited meromorphic +canonical section. The space of global three-forms has dimension at +least two, so we can choose associated vector fields $v_1,v_2$ such that +$v_1$ is nonzero and tangent to the kernel of $\sigma$, while $v_2$ is +not tangent. Denote their three-forms by $\beta_1,\beta_2$. + +Let $E\subset F$ be the saturation of the line defined by the nonzero +$K$-valued one-form +\[ + \boldsymbol\eta=\iota_{v_2}\sigma. +\] +It follows that +\begin{equation}\label{fol:E-class} + E=\OO_M(-K+e) +\end{equation} +for a divisor $e$ (its divisorial zero divisor). Saturation makes $E$ a +reflexive rank-one sheaf, hence a line bundle on $M$. Its inclusion in +$\Omega_M^1$ is a subbundle away from a set of codimension at least two. +Likewise, all the rank-two sheaves and quotients just used are vector +bundles at general points of every prime divisor. + +The rank-two identity +\[ + K\otimes G^*\simeq\OO_M(H)\otimes G +\] +turns $v_1$ into a section of $\OO_M(H)\otimes G$. Saturating its image +produces a line factor $\OO_M(j-H)\subset G$, where $j$ is a divisor; +by the determinant identity the other factor is $\OO_M(K-j)$. + +\begin{lemma}\label{fol:Bott-integrability} +The line $E$ is an integrable saturated conormal. On a dense open set, +its line is the intersection of the degree-one wedge annihilators of +$\sigma$ and $\beta_2$. +\end{lemma} + +\begin{proof} +Work first on the complement of a codimension-at-least-two set where +$F,G,E$ and the line factors above are bundles. Let $D\subset T_M$ be +the integrable distribution annihilated by $F$. Lie derivative along +$D$ defines the partial Bott connection on $F$. Its second fundamental +form for $E$ is a morphism +\begin{equation}\label{fol:Bott-tensor} + B_E\colon E\longrightarrow(F/E)\otimes D^* + =(F/E)\otimes G. +\end{equation} +For clarity, this is tensorial in both variables: for $w\in D$ and a +local section $s$ of $E$, the terms introduced by replacing $s$ by $fs$ +are multiples of $s$, while the additional term in $\mathcal L_{fw}s$ +is $s(w)\,\dd f=0$. + +If the composite of $B_E$ with the second line factor of $G$ is nonzero, +it is a nonzero section of the line bundle of class +\[ + (H-E)+(K-j)-E=3K+H-j-2e. +\] +If that composite vanishes and $B_E\ne0$, it factors through the first +line factor and gives a nonzero section of class +\[ + (H-E)+(j-H)-E=2K+j-2e. +\] +These sections extend across the omitted set by reflexivity and Hartogs' +theorem. Removing their divisor factors gives a nonzero meromorphic +section of $3K$ or $2K$, respectively, contradicting +\eqref{fol:no-meromorphic}. Thus $B_E=0$. + +In local Frobenius coordinates for $D$, write its transverse coordinates +as $(z_1,z_2)$ and a frame of $E$ as $a\,\dd z_1+b\,\dd z_2$. +Vanishing of $B_E$ says that the ratio $a/b$, where defined, is constant +along the plaques of $D$. After multiplication by an invertible local +function, the frame is therefore a one-form on the two-dimensional +transversal. Every rank-one conormal on a smooth surface is integrable. +The resulting Frobenius identity extends to the entire regular locus +of $E$ by holomorphic equality, including general points of divisorial +zeros of the original forms. + +The wedge annihilator of $\sigma$ in degree one is $F$. The annihilator +of $\beta_2$ is the hyperplane of one-forms vanishing on $v_2$. Since +$v_2$ is not tangent to $D$, their intersection is a line. It contains +$\iota_{v_2}\sigma$, which both wedges to zero with $\sigma$ and +evaluates to zero on $v_2$. Hence that line is $E$. +\end{proof} + +\begin{lemma}\label{fol:annihilation} +For every closed positive $(1,1)$-current $T$ in the class $\alpha$, one has +\begin{equation}\label{fol:annihilations} + T\wedge\sigma\wedge\bar\sigma=0,\qquad + T\wedge\beta_2\wedge\bar\beta_2=0 +\end{equation} +on the open subset where $p$ is an isomorphism onto a smooth open subset +of $Y$. In particular, +\begin{equation}\label{fol:T-eta} + T\wedge\boldsymbol\eta=0 +\end{equation} +on a dense open subset with analytic complement. +\end{lemma} + +\begin{proof} +Off the singular set of the saturated codimension-one foliation, whose +codimension is at least two, holomorphic first integrals give frames +$\dd z$ for $E$. If $\dd z_a=g_{ab}\dd z_b$ on an overlap, then +$\dd\log g_{ab}$ belongs to $E$: differentiating the transition identity +gives $\dd g_{ab}\wedge\dd z_b=0$. Consequently the first Chern cocycle +wedges to zero with both $\sigma$ and $\beta_2$ there. + +These vanishings extend in Dolbeault cohomology to all of $M$. Indeed, +for a locally free sheaf $\mathcal V$ on a smooth manifold and an analytic +set $A$ of codimension at least two, +$\mathcal H^j_A(\mathcal V)=0$ for $j=0,1$, by depth and Hartogs' +theorem. The local-to-global sequence for cohomology with support +therefore gives an injection +$H^1(M,\mathcal V)\to H^1(M\setminus A,\mathcal V)$. +Apply it to $\Omega_M^3$ and $\Omega_M^4$. We obtain +\begin{equation}\label{fol:Bott-Chern} + c_1(E)\wedge[\sigma]=0,\qquad + c_1(E)\wedge[\beta_2]=0. +\end{equation} + +We next dispose of the exceptional divisor terms. Fix a K\"ahler form +$\omega_Y$ on $Y$. For every exceptional prime $P$ on $M$, +\begin{equation}\label{fol:exceptional-integrals} + \int_P \sigma\wedge\bar\sigma\wedge p^*\omega_Y=0,\qquad + \int_P \ii\beta_2\wedge\bar\beta_2=0. +\end{equation} +Here and below integration on a prime divisor can be computed on a +smooth resolution. To see the assertion, rationality of klt +singularities gives $Rp_*\OO_M=\OO_Y$, hence +$H^k(Y,\OO_Y)\simeq H^k(M,\OO_M)$. Resolve $P$ and the image $p(P)$, +and resolve the graph so that the resulting smooth compact K\"ahler +space $\widehat P$ maps to a smooth model $B$ of $p(P)$. Functoriality +of restriction makes the classes of $\bar\sigma|_{\widehat P}$ and +$\bar\beta_2|_{\widehat P}$ pullbacks from $H^2(B,\OO_B)$ and +$H^3(B,\OO_B)$, respectively. Conjugation and compact K\"ahler Hodge +theory give the corresponding pullback assertions for their de Rham +classes. The class of $p^*\omega_Y$ restricts from $B$ as well. +Since $\dim B\leq2$, the degree-six products in +\eqref{fol:exceptional-integrals} vanish. + +By \eqref{fol:E-class} and \eqref{fol:canonical-comparison}, +$c_1(E)=-c_1(L)$ modulo exceptional divisor classes. Combining +\eqref{fol:Bott-Chern} and \eqref{fol:exceptional-integrals} gives +\[ + \int_M T\wedge\sigma\wedge\bar\sigma\wedge p^*\omega_Y=0, + \qquad + \int_M T\wedge\ii\beta_2\wedge\bar\beta_2=0. +\] +The integrands are nonnegative: $\sigma$ is decomposable wherever +nonzero, and every three-form on a four-dimensional vector space is +decomposable. The form $p^*\omega_Y$ is strictly positive on the +isomorphism locus. Thus the zero-mass equalities imply +\eqref{fol:annihilations} there. + +This positivity argument applies to currents as well as smooth forms. +Locally, write the coefficient matrix of $T$ as a positive semidefinite +matrix of Radon--Nikodym derivatives with respect to its trace measure. +The two wedge equalities imply, almost everywhere for that measure, that +each one-form direction of the matrix annihilates both $\sigma$ and +$\beta_2$ by wedge product. Lemma~\ref{fol:Bott-integrability} identifies +their intersection with $E$. This proves \eqref{fol:T-eta}. +\end{proof} + +\subsection{Index charts and a closed transverse current} + +We will repeatedly use the following local integrability fact. All +integrals in its proof are computed in fixed smooth coordinate volumes. + +\begin{lemma}\label{fol:Jacobian-integrability} +Let $f\colon V\to U$ be a proper generically finite holomorphic map +between smooth complex manifolds of the same dimension. Let $\phi$ be +a plurisubharmonic function on $U$ such that +$e^{-s\phi}\in L^1_{\mathrm{loc}}(U)$ for every $s>0$. Then +\[ + e^{-s(\phi\circ f)}\in L^1_{\mathrm{loc}}(V) + \qquad(s>0). +\] +The assertion is locally uniform for a family of functions for which +all the indicated exponential integrals downstairs are locally uniformly +bounded. +\end{lemma} + +\begin{proof} +Take relatively compact coordinate charts upstairs and downstairs so that +$f$ maps the former into the latter. Let $J$ be the local holomorphic +Jacobian determinant; it is not identically zero. A sufficiently small +negative power of $|J|$ is locally integrable. Choose $P>1$ large enough +that $|J|^{-2/(P-1)}$ is integrable on the chosen compact set. H\"older's +inequality gives +\begin{equation}\label{fol:Jacobian-Holder} + \int e^{-s\phi\circ f} + \leq + \left(\int e^{-sP\phi\circ f}|J|^2\right)^{1/P} + \left(\int |J|^{-2/(P-1)}\right)^{(P-1)/P}. +\end{equation} +Change of variables bounds the first factor by the degree of $f$ times +the corresponding exponential integral downstairs, up to fixed +coordinate-volume constants. Covering compact sets by finitely many +charts proves both assertions. +\end{proof} + +A positive closed $(1,1)$-current with zero Lelong numbers has no mass +on any proper analytic subset. We recall precisely the form used here. +The Skoda--El Mir extension theorem says that restricting such a current +off an analytic set and then extending by zero gives a closed current. +The difference is a positive closed current supported on that set. The +support theorem reduces it to its divisorial components, whose +coefficients are the corresponding generic Lelong numbers, so the +difference is zero. These current-theoretic facts, together with Skoda +integrability and Siu decomposition below, are used in their ordinary +smooth-manifold forms; see \cite{DemaillyComplexAnalyticGeometry}. + +\begin{lemma}\label{fol:transverse-current} +Let $T$ be a positive current in $\alpha$ with zero Lelong numbers +everywhere. Choose local plurisubharmonic metric weights $\phi$ for +$T$ on $L$. On the isomorphism locus of $p$, write +$\boldsymbol\eta=\eta\otimes\tau$ in the corresponding local canonical +frame $\tau$. The expression +\begin{equation}\label{fol:Theta-definition} + \Theta_T=\ii e^{-\phi}\eta\wedge\bar\eta +\end{equation} +has a canonical extension to a nonzero positive closed $(1,1)$-current +on $M$. This extension has no mass on proper analytic subsets and satisfies +\begin{equation}\label{fol:Theta-orthogonality} + \alpha\smile[\Theta_T]=0. +\end{equation} +The weights are understood with a fixed global additive normalization +when $\Theta_T$ is compared for different currents. +\end{lemma} + +\begin{proof} +We first specify the extension through the singular model. Cover $Y$ +by neighborhoods $U$ on which a Cartier pluricanonical power has a +nowhere vanishing frame. Take the ordinary local index cover +$\widehat U\to U$ defined by a root of that frame, and normalize. +The cover is quasi-\'etale and klt, by the index-cover discrepancy +formula; in particular it has rational singularities. On its smooth +locus the root is a canonical frame. + +Resolve a main component of +$\widehat U\times_U p^{-1}(U)$, obtaining a diagram +\[ + \begin{tikzcd} + \widetilde U \arrow[r] \arrow[d,"f"'] & \widehat U \arrow[d]\\ + p^{-1}(U) \arrow[r] & U . + \end{tikzcd} +\] +Here $f$ is proper and generically finite. The resolution is chosen +isomorphic over the dense smooth open where the index cover is +unramified and $p$ is an isomorphism. The coefficient $\eta$ in the +root frame is an ordinary holomorphic one-form on that open. +It extends reflexively to $\widehat U$ by Hartogs' theorem, since the +complement of the relevant smooth locus downstairs has codimension at +least two. The extension theorem for rational complex spaces then +extends it holomorphically to $\widetilde U$; we use +\cite[Corollary~1.8]{KebekusSchnellExtension}. +We continue to write $\eta$ for this holomorphic form and $\phi$ for the +pulled metric weight in the root frame. + +Zero Lelong numbers downstairs give +$e^{-s\phi}\in L^1_{\mathrm{loc}}$ for every $s>0$. By +Lemma~\ref{fol:Jacobian-integrability}, the same is true on +$\widetilde U$. In particular the pulled weight has zero Lelong +numbers, and the pulled curvature has no analytic-subset mass. +The upstairs expression in \eqref{fol:Theta-definition} has +$L^r_{\mathrm{loc}}$ coefficients for every finite $r$. This holds +also after multiplication by $\phi$: on a compact set $\phi$ is +bounded above, while $|\phi|e^{-\phi}$ is bounded by a constant times +$1+e^{-2\phi}$. + +Define $\Theta_T$ on $p^{-1}(U)$ as $f_*$ of this expression divided +by $\deg f$. On the good open this is the original formula. It is +independent of the root frame: if $\tau'=g\tau$, then +$\eta'=g^{-1}\eta$ and $\phi'=\phi-\log|g|^2$. +A pushforward of the indicated $L^r$ coefficient forms has no mass on +the analytic complement, because its inverse image is a proper +analytic subset and hence has zero smooth volume upstairs. +Consequently these local pushforwards agree on overlaps and define +a global positive current. It is nonzero since +$\boldsymbol\eta$ is generically nonzero. + +We now prove closedness, rather than assuming that a transverse-looking +density is closed. On $\widetilde U$, the saturation of the line defined +by $\eta$ gives an integrable codimension-one conormal. Integrability +holds first on the good open by Lemma~\ref{fol:Bott-integrability} and +then everywhere by holomorphic equality. Its singular set $A$ has +codimension at least two. On a regular foliated chart, including one +through a divisorial zero of $\eta$, write +\begin{equation}\label{fol:local-foliation} + \eta=f_0\,\dd z +\end{equation} +with $z$ a holomorphic submersion and $f_0$ holomorphic. +Lemma~\ref{fol:annihilation} gives +$\ddc\phi\wedge\dd z=0$ on the good part where $f_0\ne0$. +It holds on the whole chart because the positive closed curvature +has no mass on the remaining analytic set. + +In coordinates $(z,w_1,w_2,w_3)$, positivity shows that the only +coefficient of $\ddc\phi$ is its +$\ii\,\dd z\wedge\dd\bar z$ coefficient. Closedness of that current +makes this coefficient independent, as a distribution, of every $w_j$ +and $\bar w_j$. Thus it is the pullback of a positive measure on the +$z$-disc. Taking a one-variable subharmonic potential and then solving +the pluriharmonic difference on a smaller polydisc gives +\begin{equation}\label{fol:split-weight} + \phi=\phi_0(z)+g+\bar g,\qquad g\text{ holomorphic}. +\end{equation} +With $h=f_0e^{-g}$, the upstairs current becomes +\[ + \ii e^{-\phi_0(z)}|h(z,w)|^2\,\dd z\wedge\dd\bar z. +\] +Its $\ddc$ is positive. More explicitly, only differentiation in the +$w$ directions survives wedging with +$\dd z\wedge\dd\bar z$, and +\begin{equation}\label{fol:leaf-Hessian} + \ddc\Theta_T + = + e^{-\phi_0(z)} + \ii\partial_w h\wedge\bar\partial_w\bar h + \wedge\ii\,\dd z\wedge\dd\bar z + \ \geq\ 0 +\end{equation} +on the regular foliated chart. This is a distributional identity; +the one-variable coefficient is locally integrable, and no transverse +derivative of it contributes to the displayed wedge. + +We give the extension estimate across $A$. On a relatively compact +coordinate ball, choose smooth cutoffs $\chi_\epsilon$ equal to zero +on an $\epsilon$-tube around $A$ and equal to one outside a +$3\epsilon$-tube, with +\[ + |\nabla\chi_\epsilon|\leq C\epsilon^{-1}, + \qquad + |\nabla^2\chi_\epsilon|\leq C\epsilon^{-2}. +\] +They may be constructed by smoothing the distance cutoffs. The tubes +have volume $O(\epsilon^4)$. To justify the bound also when $A$ is +singular, use locally finite area for its analytic components and +monotonicity to bound the number of disjoint balls of radius +$\epsilon/4$ centered on each component by +$C\epsilon^{-2d}$, where $d\leq2$ is its complex dimension. +Enlarging this cover to the tube gives volume +$O(\epsilon^{8-2d})=O(\epsilon^4)$; a compact subset meets finitely +many local components. + +If $B$ denotes either $\Theta_T$ or $\phi\Theta_T$ upstairs and +$r>2$, then for any fixed smooth test form the second-derivative +cutoff terms are bounded by +\begin{equation}\label{fol:cutoff-estimate} + C\epsilon^{-2}\|B\|_{L^r} + \operatorname{vol}(N_{3\epsilon}(A))^{1-1/r} + \leq C_r\|B\|_{L^r}\epsilon^{\,2-4/r} + \longrightarrow0. +\end{equation} +Terms with only one derivative are smaller. Testing +\eqref{fol:leaf-Hessian} against $\chi_\epsilon$ times a positive +test form and passing to the limit therefore proves +$\ddc\Theta_T\geq0$ on all of $\widetilde U$. + +Proper pushforward commutes with $\ddc$, so $\ddc\Theta_T$ is a +global positive exact $(2,2)$-current on $M$. Pairing with the square +of a K\"ahler form gives zero; positivity then makes it the zero +current. On the good open the chart maps are local biholomorphisms. +All branch contributions to the pushforward are positive, so each +upstairs Hessian in \eqref{fol:leaf-Hessian} vanishes there separately. +Since $e^{-\phi_0}>0$ almost everywhere, the holomorphic derivatives +$\partial_w h$ vanish there, and hence on every regular foliated chart +by holomorphic continuation. Thus +\begin{equation}\label{fol:leaf-constancy} + h=f_0e^{-g}\text{ depends only on }z. +\end{equation} + +Equations~\eqref{fol:split-weight} and \eqref{fol:leaf-constancy} imply, +on these charts, +\[ + \dd\Theta_T=0,\qquad \ddc(\phi\Theta_T)=0. +\] +For the second identity, the coefficient depending only on $z$ causes +no derivative after wedging with $\dd z\wedge\dd\bar z$, while the +remaining $g+\bar g$ is pluriharmonic in the leaf directions. +The first- and second-derivative versions of +\eqref{fol:cutoff-estimate} extend both identities across $A$. + +Finally choose a smooth reference metric on $L$, with local weights +$\psi$ and curvature $\theta$. The difference $u=\phi-\psi$ is a +global function downstairs. The local pushforwards defining +$u\Theta_T$ agree: upstairs they are locally integrable by the +exponential estimates, they agree on the good open, and they have +no analytic-subset mass. Closedness and the last displayed identities +give the global current identity +\begin{equation}\label{fol:potential-identity} + \ddc(u\Theta_T)=-\theta\wedge\Theta_T. +\end{equation} +It proves \eqref{fol:Theta-orthogonality}. +\end{proof} + +\subsection{Hodge index and the space of positive currents} + +\begin{lemma}\label{fol:nonnegative-square} +Let $X$ be a smooth compact K\"ahler fourfold, with K\"ahler form +$\omega$, and let $R$ be a positive closed $(1,1)$-current with no +divisorial mass. Then +\[ + \int_X [R]^2[\omega]^2\geq0. +\] +\end{lemma} + +\begin{proof} +Regularization with analytic singularities gives currents +$R_k\in[R]$ and numbers $\epsilon_k\downarrow0$ such that +$R_k\geq-\epsilon_k\omega$ and +$\nu(R_k,x)\leq\nu(R,x)$ at every point; see +\cite[Theorem~2.1(ii)]{BoucksomDivisorialZariski}. +In particular the analytic pole sets of $R_k$ have codimension at least +two. Resolve these pole sets by a projective modification +$f_k\colon X_k\to X$. For +$\beta_k=[R]+\epsilon_k[\omega]$, the pulled positive current has a +decomposition +\[ + f_k^*\beta_k=P_k+[D_k], +\] +where $D_k$ is an effective exceptional real divisor and $P_k$ is nef. +With the usual smooth-remainder version of analytic regularization, +$P_k$ is represented by a smooth semipositive form. The +bounded-remainder version gives a positive residual current with bounded +potentials, which is nef by a further regularization. + +Since $f_{k*}[D_k]=0$, the projection formula gives +\[ + \int_{X_k} f_k^*\beta_k\,[D_k]\,(f_k^*[\omega])^2=0. +\] +Consequently +\begin{equation}\label{fol:square-resolution} + \int_X\beta_k^2[\omega]^2 + = + \int_{X_k} f_k^*\beta_k\,P_k\,(f_k^*[\omega])^2 + \geq0. +\end{equation} +The inequality pairs a pseudo-effective class with three nef classes. +It follows by approximating the nef factors by K\"ahler classes and +pairing with a positive current. Passing to the limit proves the lemma. +In particular, no positivity of the self-intersection of the +exceptional divisor has been used. +\end{proof} + +For a K\"ahler form $\omega$ on $M$, write +\[ + Q_\omega(\xi,\zeta)=\int_M\xi\zeta[\omega]^2 + \qquad(\xi,\zeta\in H^{1,1}(M,\R)). +\] +The Hodge index theorem says that this quadratic form has signature +$(1,h^{1,1}-1)$. We use its following elementary consequence: +two nonzero classes with nonnegative square, positive pairing with +$[\omega]$, and zero mutual pairing must both lie on the same isotropic +ray. + +Choose the zero-Lelong current supplied by +Lemma~\ref{met:zero-lelong}, and let $\Theta$ be the current of +Lemma~\ref{fol:transverse-current}. The nef class $\alpha$ has +nonnegative square, and Lemma~\ref{fol:nonnegative-square} applies to +$\Theta$. Both classes have positive mass against $\omega^3$; +\eqref{fol:nonzero-alpha} is used here. Their mutual pairing is zero by +\eqref{fol:Theta-orthogonality}. Thus +\begin{equation}\label{fol:isotropic-ray} + Q_\omega(\alpha,\alpha)=0,\qquad [\Theta]=c\alpha + \quad\text{for some }c>0. +\end{equation} +In fact, +\begin{equation}\label{fol:alpha-square-zero} + \alpha^2=0\quad\text{in }H^4(M,\R). +\end{equation} +To check the stronger assertion, choose K\"ahler representatives of +$\alpha+\epsilon[\omega]$. Their positive squares have mass against +$\omega^2$ tending to zero by \eqref{fol:isotropic-ray}. Their +cohomology classes tend to $\alpha^2$, whereas their currents tend +weakly to zero, because their positive masses tend to zero. Thus the +limiting cohomology class is zero. + +\begin{lemma}\label{fol:all-zero-Lelong} +Every positive closed current in $\alpha$ has zero Lelong numbers +everywhere. +\end{lemma} + +\begin{proof} +Suppose $T\in\alpha$ has a positive Lelong number at a point, and let +$f\colon X\to M$ be its blowup. The pullback has a positive generic +Lelong number on the exceptional divisor. Write its Siu decomposition +as +\begin{equation}\label{fol:Siu-decomposition} + f^*T=R+\sum_j a_j[D_j], + \qquad a_j>0, +\end{equation} +where $R$ has no divisorial mass and the sum is not zero. +Fix a K\"ahler form $\omega_X$ on $X$, and set $\alpha_X=f^*\alpha$. +The class $\alpha_X$ is nef, nonzero, and +$\alpha_X^2=0$. Pairing \eqref{fol:Siu-decomposition} with +$\alpha_X[\omega_X]^2$ gives zero. All terms are nonnegative, +since a nef class paired with a positive current and two K\"ahler +classes has nonnegative intersection. Therefore +\[ + Q_{\omega_X}(\alpha_X,[R])=0,\qquad + Q_{\omega_X}(\alpha_X,[D_j])=0 + \quad\text{for every }j. +\] +Lemma~\ref{fol:nonnegative-square} and Hodge index give +$[R]=b\alpha_X$ with $b\geq0$; this includes $b=0$ when $R=0$. +Comparing masses in \eqref{fol:Siu-decomposition} gives $b<1$, +because the divisorial sum has positive mass. Hence +\begin{equation}\label{fol:divisor-span} + (1-b)\alpha_X=\sum_j a_j\,c_1(\OO_X(D_j)). +\end{equation} + +The real span of the integral classes $c_1(\OO_X(D_j))$ is a +finite-dimensional, hence closed, subspace. The convergent series in +\eqref{fol:divisor-span} therefore places the rational class +$c_1(f^*L)=\alpha_X/(2\pi)$ in that real span. Choose a finite subset +of these integral classes forming a basis of the span. Solving the +corresponding rational linear system shows that a rational vector in +their real span is in their rational span. Thus, for some rational +divisor $D$ with finite support, +\[ + c_1(f^*L)=c_1(\OO_X(D)) + \quad\text{in }H^2(X,\Q). +\] +After clearing denominators and integral torsion, the difference line +bundle has zero integral first Chern class. By +Lemma~\ref{fol:virtual-vanishing}, $q(X)=0$, so the exponential sequence +makes this difference line bundle trivial. A positive multiple of +$f^*L$ consequently has a nonzero meromorphic section. The discrepancy +identity for $X\to M\to Y$ converts it to a meromorphic section of a +positive multiple of $K_X$, contradicting +Lemma~\ref{fol:virtual-vanishing}. +\end{proof} + +The normalized-current fixed-point construction is inspired by Touzet's +method \cite{Touzet2014}. The singular extension, including continuity +on the higher charts, is proved here. + +\begin{lemma}\label{fol:fixed-point} +There is a positive current $T\in\alpha$ such that, on all the smooth +index charts constructed in Lemma~\ref{fol:transverse-current}, +\begin{equation}\label{fol:fixed-point-equation} + \ii\partial\bar\partial\phi + =\ii b e^{-\phi}\eta\wedge\bar\eta +\end{equation} +for one constant $b>0$. On these charts $\phi$ is smooth and +\begin{equation}\label{fol:eta-derivative} + \dd\eta=\partial\phi\wedge\eta. +\end{equation} +\end{lemma} + +\begin{proof} +Fix a smooth reference weight for $L$, with curvature $\theta$, and a +smooth probability volume on $M$. The set +\[ + \mathcal C_\alpha= + \{T\geq0:\ T\text{ closed of type }(1,1),\ [T]=\alpha\} +\] +is nonempty, compact, and convex in the weak topology of currents. +Its mass against $\omega^3$ is fixed. Write +$T=\theta+\ddc u_T$, uniquely normalized by +$\int_Mu_T\,\dd V=0$. Thus all local weights used for $T$ have +a fixed common additive normalization. + +By Lemma~\ref{fol:all-zero-Lelong}, the construction of +Lemma~\ref{fol:transverse-current} applies to every $T\in\mathcal C_\alpha$. +Applying Hodge index as in \eqref{fol:isotropic-ray} shows that +$[\Theta_T]$ is a positive multiple of $\alpha$. Define +\begin{equation}\label{fol:fixed-point-map} + \mathcal F(T)= + \frac{\int_M\alpha[\omega]^3}{\int_M\Theta_T\wedge\omega^3}\,\Theta_T. +\end{equation} +This is a selfmap of $\mathcal C_\alpha$. + +We verify continuity, including on the higher charts. If $T_j\to T$ +weakly, compactness for quasi-plurisubharmonic functions with fixed lower +curvature bound and the chosen normalization gives +$u_{T_j}\to u_T$ in $L^1$. Indeed every subsequential limit has the same +$\ddc$ and normalization as $u_T$. On a coordinate chart the metric +weights are plurisubharmonic and converge in $L^1$. +All complex singularity exponents of the limit are infinite, by +Lemma~\ref{fol:all-zero-Lelong} and Skoda integrability. +The effective semicontinuity theorem +\cite[Theorem~0.2(2)]{DemaillyKollar} consequently gives locally uniform +bounds for $e^{-s\phi_j}$ for every fixed $s>0$, and in fact convergence +of these exponentials in $L^1$ on smaller neighborhoods. + +Apply \eqref{fol:Jacobian-Holder} on the fixed proper chart diagrams. +It gives locally uniform upstairs bounds for every inverse exponential +power as well. After extraction, the weights converge almost everywhere +off the exceptional and critical analytic sets. Pullback preserves +almost-everywhere convergence there, because the chart maps are local +biholomorphisms; the omitted analytic sets have measure zero. +Uniform $L^r$ bounds for some $r>1$ then give convergence in $L^1$ +of the densities defining $\Theta_{T_j}$ upstairs. Proper +pushforward gives $\Theta_{T_j}\to\Theta_T$ downstairs. The argument +applies to each subsequence and so proves continuity for the whole +sequence. Their masses also converge, and the limiting mass is positive. +Thus $\mathcal F$ is continuous. The Schauder--Tychonoff fixed-point +theorem yields a fixed point. + +Let $b$ be the positive normalization factor in +\eqref{fol:fixed-point-map} at this fixed point. Its equality +$T=b\Theta_T$ holds upstairs on the good locus, giving +\eqref{fol:fixed-point-equation}. Both sides extend with no +analytic-subset mass, so the equality holds on each entire smooth +higher chart. + +Taking a smooth Euclidean trace on a smaller coordinate ball gives a +scalar Poisson equation whose right side belongs to every finite $L^r$, +because $\eta$ is holomorphic and all inverse exponential moments of +$\phi$ are finite. Interior elliptic regularity gives +$\phi\in W^{2,r}_{\mathrm{loc}}$ for every finite $r$. +Choosing $r>8$ gives continuous first derivatives, after which the +semilinear equation and ordinary elliptic bootstrap make $\phi$ smooth. +On a regular foliated chart, +\eqref{fol:split-weight} and \eqref{fol:leaf-constancy} give +$\eta=e^g h(z)\,\dd z$. Therefore +$\dd\eta=\dd g\wedge\eta=\partial\phi\wedge\eta$ there. +Both sides are now smooth on the entire higher chart, and the identity +extends by density. This proves \eqref{fol:eta-derivative}. +\end{proof} + +\subsection{Spherical developing maps and boundary meridians} + +Fix the current given by Lemma~\ref{fol:fixed-point}. On a smooth higher +chart put +\begin{equation}\label{fol:unitary-forms} + \gamma=\sqrt{b/2}\,e^{-\phi/2}\eta,\qquad + a=\frac{\partial\phi-\bar\partial\phi}{2}. +\end{equation} +Equations~\eqref{fol:fixed-point-equation} and +\eqref{fol:eta-derivative} imply +\begin{equation}\label{fol:structure-equations} + \dd\gamma=a\wedge\gamma,\qquad + \dd a=-2\gamma\wedge\bar\gamma. +\end{equation} +Indeed differentiating $e^{-\phi/2}\eta$ gives the first identity, while +$\dd a=-\partial\bar\partial\phi$ gives the second. Consequently the +matrix-valued one-form +\begin{equation}\label{fol:flat-matrix} + A= + \begin{pmatrix} + a/2 & \bar\gamma\\ + -\gamma & -a/2 + \end{pmatrix} +\end{equation} +is skew-Hermitian, trace-free, and satisfies +$\dd A+A\wedge A=0$. On a simply connected small ball it therefore +has the form $U^{-1}\dd U$ with $U$ valued in $\mathrm{SU}(2)$. + +The map +\[ + F\colon x\longmapsto U(x)\C e_1\in\PP^1 +\] +is holomorphic. In fact, +$\bar\partial(Ue_1)=\tfrac12a^{0,1}Ue_1$, because $\gamma$ has type +$(1,0)$; hence the line spanned by $Ue_1$ is a holomorphic line. +This argument remains valid at zeros of $\eta$. +For the Fubini--Study normalization +$\omega_{\mathrm{FS}}=\ii\partial\bar\partial\log(1+|z|^2)$, +the usual unitary-frame computation gives +$F^*\omega_{\mathrm{FS}}=\ii\gamma\wedge\bar\gamma$. +Thus, with $\omega_{\mathrm{sph}}=2\omega_{\mathrm{FS}}$, +\begin{equation}\label{fol:spherical-pullback} + F^*\omega_{\mathrm{sph}}=T +\end{equation} +on the higher chart, where the right side is pulled back from $M$. + +Choose a connected dense open subset $S\subset M$ with analytic +complement such that $p$ identifies $S$ with a smooth open subset of +$Y$, the relevant forms have their generic ranks, and +$\boldsymbol\eta$ is nowhere zero on $S$. The index charts are +unramified over $S$, and their resolutions can be chosen isomorphic +there. Equation~\eqref{fol:spherical-pullback} gives local holomorphic +submersions from $S$ to $\PP^1$. Two such submersions with the same +pullback form differ locally by a constant element of +$\mathrm{PU}(2)$. Indeed their kernels agree, so one factors locally +through the other on a transverse disc; the resulting local holomorphic +isometry of the round sphere is the restriction of a projective unitary +transformation. The transformation is unique on each connected +overlap because the image of a submersion contains an open subset. + +These local maps and their constant transitions give a developing map +and a monodromy homomorphism +\begin{equation}\label{fol:developing-map} + \operatorname{dev}\colon\widetilde S\to\PP^1,\qquad + \rho\colon\pi_1(S)\to\mathrm{PU}(2). +\end{equation} +The developing map is nonconstant and is equivariant for $\rho$. + +\begin{lemma}\label{fol:finite-meridians} +Let $X$ be a smooth space with a proper generically finite map to $M$ +that is unramified over $S$, and let $S_X$ be the inverse image of $S$. +After any further modification supported outside $S_X$, the monodromy +of a small meridian about every prime divisor in the complement of +$S_X$ has finite order. +\end{lemma} + +\begin{proof} +The assertion is local at a general point of a boundary prime $D$. +Choose a small disc $\Delta$ transverse to $D$ at a smooth point not +on another boundary component, with $\Delta^*=\Delta\setminus\{0\}$ +contained in $S_X$. Choose an original proper higher chart over a +neighborhood of the image point in $M$, take its fiber product with +$X$, and resolve a main component. The resulting map +$g\colon W\to X$ is proper and generically finite, and is unramified +over $S_X$. Near every point of $W$ there is an ambient holomorphic +map to $\PP^1$: compose its map to the original higher chart with the +map constructed in \eqref{fol:flat-matrix}. Over the good open these +maps agree with the developing germs up to constant projective +unitary transformations. + +A component of the inverse image of $\Delta$ dominating $\Delta$ +is a curve, finite over $\Delta^*$. Its normalization has a point over +$0$, and its local map to $\Delta$ can be written, after changing a +parameter, as $t\mapsto t^r$ for some positive integer $r$. +For a sufficiently small circle in the $t$-disc, the lifted loop stays +inside one neighborhood on which an ambient map to $\PP^1$ is +defined. Continuing this ambient map around the lifted loop returns +the same germ. On the punctured part, $g$ is locally biholomorphic, +so this is the analytic continuation of the original developing germ +around the $r$-th power of the meridian. + +A projective unitary transformation fixing that germ must be the +identity, since it is a submersive ambient germ on the good open. +Thus the meridian has monodromy whose $r$-th power is the identity. +It is essential here to use the ambient germ: even if the transverse +disc happens to be tangent to the foliation, the argument does not +infer identity of holonomy merely from its action on the values of +the map along that disc. The same fiber-product construction applies +after the further modifications specified in the statement. +\end{proof} + +We record the compactification fact in the precise analytic category +needed here. + +\begin{lemma}\label{fol:cover-compactification} +Let $X$ be a smooth compact K\"ahler manifold and $D$ a simple normal +crossing divisor. Every finite unramified cover of $X\setminus D$ +extends to a finite normal cover of $X$. It has a smooth compact +K\"ahler resolution which is unchanged over the original cover, and +whose complement of that cover can be made a simple normal crossing +divisor. +\end{lemma} + +\begin{proof} +Near a point of $D$, choose a polydisc on which its complement is +$(\Delta^*)^r\times\Delta^{n-r}$. Each connected finite cover is +described by a finite-index subgroup of its fundamental group +$\Z^r$. Such a subgroup contains $N\Z^r$ for some $N>0$. +The cover is consequently dominated by the coordinate power cover +\[ + (t_1,\ldots,t_r,w)\longmapsto(t_1^N,\ldots,t_r^N,w). +\] +It extends across the coordinate hyperplanes as the normal quotient +of the full polydisc power cover by the corresponding finite subgroup +of its deck group. The normal finite extensions glue uniquely: +an isomorphism on the dense punctured locus extends between the +normal finite algebras, equivalently by their integral closures. +This gives a finite normal cover $\overline X\to X$. + +For completeness, a finite source over a compact K\"ahler space is +K\"ahler in the local-embedding sense. Over finitely many small base +neighborhoods choose relative embeddings of the finite source into +products with affine spaces, with relative coordinates $w_a$. +Choose a smooth partition of unity $\lambda_a$ on the base and put +\[ + h=\sum_a(\lambda_a\circ f)|w_a|^2 +\] +on the source, extending each summand by zero outside its support. +This is a smooth function on the complex space. At a point where +$\lambda_a>0$, use the corresponding relative embedding. +The other relative coordinate functions have local holomorphic +extensions to its ambient space. On vertical tangent directions the +Levi form of $h$ is +$\sum_a\lambda_a|\dd w_a|^2$ and is strictly positive. The terms +arising from derivatives of the partition have a base-direction +factor. A sufficiently large multiple of the pulled base K\"ahler +form dominates their horizontal and mixed contributions. Compactness +allows one such multiple on the finite cover. Thus +\[ + C f^*\omega_X+\ddc h +\] +has strictly plurisubharmonic local potentials in the chosen ambient +embeddings and defines a K\"ahler form on the normal source. +Finally take a projective resolution and then an embedded resolution +of the boundary, both unchanged over the smooth covered open. +Projective modifications of compact K\"ahler spaces remain K\"ahler, +by the usual relative ample curvature construction. This proves the +claim. +\end{proof} + +Resolve $M\setminus S$ by a projective modification, unchanged on $S$, +so that the complement is a simple normal crossing divisor. +The fundamental group of $S$ is finitely generated: a complement of +this kind in a compact smooth manifold has the homotopy type of a +finite complex, or one may retract onto a compact manifold with +corners obtained by removing sufficiently small tubular neighborhoods. + +The group $\mathrm{PU}(2)$ is linear, for example through the adjoint +embedding into $\mathrm{GL}_3(\C)$. Selberg's lemma therefore gives +a finite-index torsion-free subgroup of $\rho(\pi_1(S))$. +Take the connected finite unramified cover $S_0\to S$ associated with +its inverse image in $\pi_1(S)$. By +Lemma~\ref{fol:cover-compactification}, it is contained in a smooth +compact K\"ahler manifold $M_0$, with simple normal crossing +complement, and there is a proper generically finite morphism +$M_0\to M$. Its monodromy image is torsion-free. + +Every boundary meridian of $M_0\setminus S_0$ has finite-order +monodromy by Lemma~\ref{fol:finite-meridians}, hence trivial +monodromy. The inclusion $S_0\hookrightarrow M_0$ induces a +surjection of fundamental groups whose kernel is normally generated +by those meridians. One way to see both assertions is to put loops +and homotopies in general position relative to the normal crossing +divisor: loops avoid it, and a homotopy meets its smooth part in +finitely many transverse points, each contributing a meridian; it +avoids the intersections of components. Consequently the +representation descends to +\begin{equation}\label{fol:compact-representation} + \rho_0\colon\pi_1(M_0)\to\mathrm{PU}(2). +\end{equation} + +\subsection{Finite holonomy and the contradiction} + +\begin{lemma}\label{fol:finite-unitary-image} +Let $X$ be a connected smooth compact K\"ahler manifold such that +$a(X)=0$ and $q(X')=0$ for every connected finite \'etale cover +$X'\to X$. Every representation +$\pi_1(X)\to\mathrm{PU}(2)$ with torsion-free image has trivial image. +\end{lemma} + +\begin{proof} +Let $\Gamma$ be the image, and take its complex Zariski closure in +$\mathrm{PSL}_2(\C)$, regarded as a linear algebraic group through +the adjoint representation. + +If this closure is all of $\mathrm{PSL}_2(\C)$, apply the +semisimple Shafarevich theorem +\cite[Theorem~1]{CCE}. Its hypotheses are exactly a smooth compact +K\"ahler source and a representation Zariski dense in a semisimple +linear group; for torsion-free image the Shafarevich base is normal +projective of general type, and the representation factors through +a smooth model of that base. Algebraic dimension zero forces this +base to be a point: a positive-dimensional projective base would +supply a nonconstant meromorphic function on $X$. Factorization +through a point makes $\Gamma$ trivial, contradicting its supposed +Zariski density. + +If the Zariski closure is proper, its identity component is solvable, +by the classification of proper connected algebraic subgroups of +$\mathrm{PSL}_2(\C)$. Thus $\Gamma$ is virtually solvable. Pass to +a finite-index subgroup whose image $\Gamma_0$ is solvable and let +$X_0\to X$ be the corresponding finite \'etale cover. +For every further finite-index subgroup $H$ of $\pi_1(X_0)$, its +abelianization is finite: it is the first integral homology of a +compact K\"ahler finite cover with $q=0$, hence is finitely generated +of rank $2q=0$. + +Now induct along the derived series of $\Gamma_0$. +The quotient $\Gamma_0/\Gamma_0'$ is an image of +$\pi_1(X_0)^{\mathrm{ab}}$, so it is finite. +Its preimage has finite index in $\pi_1(X_0)$; that subgroup again +has finite abelianization, making $\Gamma_0'/\Gamma_0''$ finite. +Repeating gives finite successive indices down to the identity, +because the derived series has finite length. +Thus $\Gamma_0$, and then $\Gamma$, is finite. +A finite torsion-free group is trivial. +\end{proof} + +Lemma~\ref{fol:virtual-vanishing} supplies the hypotheses of +Lemma~\ref{fol:finite-unitary-image} for $M_0$ and all its finite +\'etale covers. The representation +\eqref{fol:compact-representation} is therefore trivial. The +developing map descends to a single-valued nonconstant holomorphic map +\[ + F_0\colon S_0\longrightarrow\PP^1. +\] + +We finish by proving its meromorphic extension, rather than appealing +to compactness of the target. Over a neighborhood in $M_0$, form the +proper generically finite higher charts used in +Lemma~\ref{fol:finite-meridians}. Each small ball upstairs has an +ambient sphere map obtained by composition from +\eqref{fol:flat-matrix}. On the good part of the ball this map and +the lift of $F_0$ have the same transverse round metric, so they differ +by a constant projective unitary transformation. The good part, +being the complement of a proper analytic subset in a ball, is +connected; uniqueness on submersive germs makes that transformation +constant throughout it. After this transformation the ambient map +extends the lift of $F_0$. The extensions agree on intersections +by density and glue to a holomorphic map on the higher chart. + +Choose a scalar projective coordinate on $\PP^1$. Composing with +these extensions gives a meromorphic function on each proper +generically finite chart. Its meromorphic trace, divided by the +chart degree, is a meromorphic function on the base neighborhood. +To define the trace, first descend through the proper modification +in the chart's Stein factorization and then take the ordinary trace +of the finite normal map. On the good open every branch is the +same pullback of the chosen coordinate of $F_0$, so its trace is +exactly the degree times that coordinate. The resulting local +meromorphic functions on $M_0$ consequently agree on overlaps and +give a global meromorphic extension of the coordinate of $F_0$. +It is nonconstant, contradicting $a(M_0)=0$ from +Lemma~\ref{fol:virtual-vanishing}. + +This contradiction proves Proposition~\ref{fol:empty-case}. diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/floor.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/floor.tex new file mode 100644 index 0000000000000000000000000000000000000000..cdf2abd543fb284c6df7ae54501782d8a2211594 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/floor.tex @@ -0,0 +1,1458 @@ +\section{A section on the entire reduced boundary} +\label{floor:sec} + +This section proves the adjunction statement needed on the reduced-boundary +model. The distinction between a section on one component and a section on +the whole reduced boundary is essential. In particular, none of the gluing +below follows merely from abundance on the normal components. + +\begin{proposition}[Whole-boundary nonvanishing] +\label{floor:section} +Let $(V,D)$ be the compact K\"ahler dlt fourfold supplied by +Proposition~\ref{bir:reduced-model}, where $V$ is globally strongly +$\Q$-factorial and $D\ne0$ is reduced. Put +\[ + J=K_V+D. +\] +If the actual rational adjoint line bundle $J$ is analytically nef, then, +for some positive integer $m$ for which $mJ$ is Cartier on $V$, +\begin{equation} + \label{floor:goal} + H^0\bigl(D,\OO_D(mJ)\bigr)\ne0. +\end{equation} +\end{proposition} + +We prove the proposition by constructing sections on the normalized +components with matching canonical residues. All adjunction boundaries +in the argument are the full effective rational differents; their +fractional parts are never discarded. All sufficiently divisible degrees +will also be even. Evenness removes the sign obtained by interchanging +two residue operations, but does not permit a change of the actual +adjunction line bundle. + +\subsection{Adjunction and the descent locus} + +Write $D=\sum_iD_i$ and let $Y_i=D_i^\nu$ denote the normalization of a +component. Dlt chain adjunction gives an effective rational dlt pair +$(Y_i,\Gamma_i)$ and an equality of actual rational line bundles +\begin{equation} + \label{floor:component-adjunction} + J_i:=J|_{Y_i}=K_{Y_i}+\Gamma_i. +\end{equation} +Here and below restriction includes pullback by the indicated +normalization. Further adjunction is always performed with the full +boundary in \eqref{floor:component-adjunction}. + +We use the good SNC opens and chain-adjunction construction of +Lemma~\ref{bir:stratum-adjunction}. Every lc center is +generically a stratum of distinct coefficient-one primes. In the +particular modification used here, this can also be seen by following a +discrepancy-zero place from the starting SNC resolution: strict +discrepancy increase over a nonisomorphism locus, as in +Lemma~\ref{bir:stratum-comparison}, forces the general point +of its center to remain unchanged at every step. The distinct primes at +that stratum consequently remain distinct. + +Keeping only one component $D_i$ in the ambient boundary gives a plt +pair. Indeed, any exceptional place with zero log discrepancy for +$(V,D_i)$ would also have zero log discrepancy for $(V,D)$ and would +have its center generically in one of these unchanged SNC strata. For a +single smooth coefficient-one branch there is no such exceptional +zero-discrepancy place. Comparisons are legitimate because the +components are effective rationally Cartier divisors. Adjunction for +$(V,D_i)$ therefore supplies an effective rational klt pair on $Y_i$. +In particular, $Y_i$ has rational singularities. A Moishezon $Y_i$ is +projective by Namikawa's theorem, since it is also compact K\"ahler +\cite{NamikawaProjectivity}. + +\begin{lemma}[Codimension-one matching suffices] +\label{floor:descent} +The reduced space $D$ is $S_2$ and has only smooth points and ordinary +double crossings in codimension one. Its codimension-one conductor +branches are the normalizations of the primes of +$\lfloor\Gamma_i\rfloor$. They are paired between distinct components +$D_i,D_j$. For a sufficiently divisible even $m$, a tuple +\[ + s_i\in H^0(Y_i,\OO_{Y_i}(mJ_i)) +\] +descends to $H^0(D,\OO_D(mJ))$ if its restrictions agree on every paired +normalized conductor surface under the canonical adjunction +identifications. +\end{lemma} + +\begin{proof} +First, both $\OO_V$ and $\OO_V(-D)$ are Cohen--Macaulay. The first +assertion follows from klt rationality: decreasing the reduced dlt +boundary makes the zero-boundary space klt. For the second, work +locally and trivialize a Cartier multiple of the integral Weil divisor +$D$. The resulting normal cyclic index cover is \emph{\'etale in +codimension one}: divisorial orders in the defining equation are +multiples of the index. The cover is klt by the finite canonical +pullback and discrepancy formula, hence Cohen--Macaulay. The desired +divisorial sheaf is an eigensummand of the pushforward of its structure +sheaf, so is Cohen--Macaulay as well. Normality identifies the reduced +ideal of $D$ with $\OO_V(-D)$. The sequence +\[ + 0\longrightarrow\OO_V(-D)\longrightarrow\OO_V + \longrightarrow\OO_D\longrightarrow0 +\] +now shows that $D$ is Cohen--Macaulay, in particular $S_2$. + +For the codimension-one description, take general transverse surface +germs in the dlt adjunction calculation. At a single coefficient-one +branch the plt local model is a cyclic quotient of a smooth pair, and +its boundary curve is smooth. At two coefficient-one branches, the +different and the sub-lc condition give an ordinary double SNC point; +these are precisely the generic deeper lc strata described above. The +branches come from distinct primes. To lift the assertion about a +single-branch transverse curve to regularity at the corresponding +point of $D$, note that the transverse boundary curve is generically +reduced and has no embedded points by Cohen--Macaulayness. Its +regularity lifts by lifting generators of the maximal ideal through +the transverse parameters. This proves the asserted codimension-one +description. + +Let $S$ be a normalized conductor surface on $Y_i$. Chain adjunction +gives +\begin{equation} + \label{floor:surface-adjunction} + J_S=K_S+\Xi_S=J|_S. +\end{equation} +The matching branch on $Y_j$ is the normalization of the same image, +and the two normalizations agree. At a general SNC point the two +iterated residue maps differ by the sign from interchanging two +differentials. Their even powers are equal. On a common smooth model +the two invertible pullback subsheaves of meromorphic pluricanonical +forms are therefore equal: they have the same invertible domain and +the same meromorphic map on a dense open. Thus this is an equality of +the actual residue lines, not only a numerical comparison. The same +argument applies to further normalized lc strata. Proper subcenters +are generically deeper SNC strata, so the chains on either side +identify the same further centers and the same even residue maps. + +At an ordinary double point the usual two-branch local calculation +glues sections precisely when their values agree on the intersection. +Hence a matching tuple is a section of the ambient invertible +restriction away from a subset of codimension at least two in $D$. +For a reduced $S_2$ analytic ring, regularity of a meromorphic element +is tested in its height-one localizations. Applied after trivializing +$\OO_D(mJ)$, this extends the section across the omitted subset. +Equivalently, the class of the normalization-pushforward section +modulo the invertible sheaf has support of codimension at least two +and vanishes by the $S_2$ Hartogs criterion. The residue comparisons +used here are the comparisons induced by the one ambient line bundle; +no arbitrary scalar choices in adjunction enter the descent. +\end{proof} + +\begin{lemma}[Systems on the normal components] +\label{floor:component-systems} +Each $J_i$ is semiample as an actual rational line bundle. There is a +holomorphic connected-fiber map to a normal projective variety and an +ample rational line bundle such that +\begin{equation} + \label{floor:stein-system} + f_i:Y_i\longrightarrow Z_i,\qquad J_i=f_i^*H_i. +\end{equation} +\end{lemma} + +\begin{proof} +The normal compact K\"ahler threefold log-abundance theorem applies to +the effective rational adjunction pair +\eqref{floor:component-adjunction}: its actual adjoint is analytically +nef. One may first pass to a projective crepant dlt modification and +use the $\Q$-factorial dlt form of the theorem. We use here +Das--Ou's normal threefold theorem, together with their dlt-modification +theorem \cite[Corollary~1.3]{DasOuAbundanceII} +\cite[Theorem~5.2]{DasOuAbundanceI}. Generation on the modification +descends by projection to the normal target. These inputs concern +normal pairs; no nonnormal gluing assertion is being invoked. + +For completeness, the passage to divisor representatives in these +theorems does not impose an additional global-frame hypothesis. One +can first produce a section of a power of $J_i$ as follows. If $Y_i$ +is projective, use projective threefold log abundance. Otherwise +resolve it by a smooth compact K\"ahler space. If that space is +non-uniruled, smooth threefold canonical nonvanishing gives a section +which pushes to $J_i$, since $\Gamma_i\ge0$. If it is uniruled and +non-Moishezon, take a resolved rational quotient. Its smooth +non-uniruled compact K\"ahler base has nonnegative Kodaira dimension, +and its very general smooth quotient fibers are projective of +dimension at most two. On a simultaneous resolution of the pair, +use the strict boundary and all reduced exceptional divisors as an +effective SNC boundary $\widetilde\Gamma$. Log canonicity gives +\[ + K_{\widetilde Y}+\widetilde\Gamma + =p^*J_i+E,\qquad E\ge0\quad\hbox{$p$-exceptional}. +\] +This adjoint restricts pseudo-effectively on a very general quotient +fiber. Projective log nonvanishing in dimensions one and two supplies +fiberwise sections. Assumption~\ref{hyp:campana}, including unit +coefficients and its invariant-base interpretation, now supplies a +section upstairs exactly as in the rational-quotient reduction. It +pushes to a section of an actual power of $J_i$ by normality and +reflexivity. The rational-quotient and uniruledness inputs are used in +their smooth compact K\"ahler scopes +\cite{CampanaRationalQuotient,OuUniruledness}. + +Cancelling the boundary contribution in such a section gives a +meromorphic pluricanonical tensor. Its divisor divided by its degree +is a rational canonical representative, compatible with pullback to +resolutions. The discrepancies are the local canonical +discrepancies, and the divisible systems are still the actual +systems of $J_i$. Thus the divisor formulation of threefold +abundance gives precisely the claimed semiampleness. The Stein +factorization of a sufficiently high generated system yields +\eqref{floor:stein-system}. +\end{proof} + +\subsection{Dominant clusters and a finite-product construction} + +Set $r_i=\dim Z_i$ and $r=\max_i r_i$. At a vertex with $r_i=r$, +call a normalized conductor surface $S$ \emph{dominant} when it +surjects onto $Z_i$. By \eqref{floor:surface-adjunction} and +\eqref{floor:stein-system}, this is equivalent to +$\kappa(S,J_S)=r$. On the opposite side of a matched conductor +surface, the same equality forces $r_j=r$, and the surface is +dominant there too. Thus dominance is symmetric. + +Form the finite graph whose vertices have $r_i=r$ and whose edges +are the dominant conductor surfaces. Fix a connected component +of this graph, called a \emph{cluster}. It is enough to construct a +nonzero matching tuple on this cluster which vanishes on every +nondominant branch, including nondominant edges within the cluster; +we then put zero on every other component. The finitely many +nondominant images are proper subvarieties of the relevant $Z_i$. +An ample power has a nonzero section vanishing on their union. +An isolated vertex is therefore immediate. If $r=0$, there are no +nonempty nondominant branch images. If the cluster has an edge, +then $r\le2$, since an edge is a surface. This also settles any +vertex with $r=3$. + +We shall use normalized strata with the full chain adjunction +\[ + (L,\Delta_L),\qquad J_L=K_L+\Delta_L=J|_L. +\] +Each chosen object $L$ dominates the corresponding $Z_i$ and has +semiample $J_L$. An arrow between objects means a $B$-bimeromorphic +comparison: on a common resolution, the actual adjunction lines and +their meromorphic pluricanonical pullback maps agree. In sufficiently +divisible even degrees, arrows consequently give isomorphisms of +section spaces. These isomorphisms commute with multiplication. + +\begin{lemma}[Finite products of transported sections] +\label{floor:products} +Consider finitely many such objects and invertible arrows. Suppose +that in one sufficiently divisible even degree $m$ the image of +every group of loops on its section space is finite. At each object +choose a nonzero section in that degree, obtained by restricting a +base section which vanishes on the prescribed nondominant images. +Then, in a common higher degree, there are nonzero sections at all +objects, invariant under every arrow, and retaining the prescribed +vanishing. +\end{lemma} + +\begin{proof} +Fix one orbit of objects. At an object $L$, take the set of all +sections transported to $L$ from all chosen initial sections in that +orbit, along all paths. The set is finite: there are finitely many +starting objects, and two paths from the same object differ by a +loop, whose image is finite. Arrows biject these finite sets. +Multiply all their distinct members. The resulting section is +nonzero because the object is irreducible, and the products are +carried to one another because pullback is multiplicative. They +have equal degree within the orbit. The initial section at $L$ +occurs among its factors, so its prescribed zeros remain. Taking +further powers makes the degrees equal across the finitely many +orbits. +\end{proof} + +In each application with $r>0$ we shall verify that the invariant +sections on the objects descend to sections of the node's base +polarization. This will also preserve the required vanishing: a +dominating object's section contains the pullback of the initial +vanishing base section as a factor. + +We record the residue calculation used to construct internal arrows. +Suppose a log rational-curve fibration has, on its general fiber, +two distinct coefficient-one points. The total horizontal weighted +degree of the boundary is two, so there are no other horizontal +markings. After ordering the points, choose a rational coordinate +$x$ with them as zero and infinity. A local base frame of an +adjoint power has, in relative log differentials, the form +\begin{equation} + \label{floor:dlog-residues} + a\,(d\log x)^{\otimes m}, +\end{equation} +where $a$ is constant on the compact general rational fiber. The +residues at zero and infinity differ by $(-1)^m$, and hence agree +for even $m$. A change $x\mapsto c\,x$ adds a base differential, +which disappears in the top-form expression. This proves that +pairing the two marks preserves restrictions of base sections. +For two degree-one branches it gives a bimeromorphic map between +their normalizations; for one degree-two branch it gives the +involution exchanging the two generic sheets. The latter is +defined by normalization of the other main component of the +relative fiber square. Since the lines on a common resolution +pull back the same base line, equality of the meromorphic residue +maps on this dense open proves the full $B$-crepant comparison. + +\subsection{Clusters containing a non-Moishezon vertex} + +We first describe the geometry of such a vertex; as before we omit +its subscript and write $(Y,\Gamma)$, $J_Y=f^*H$, and $Z$. + +\begin{lemma}[The rational-quotient surface] +\label{floor:quotient-surface} +At a non-Moishezon vertex with a dominant conductor branch there is +a diagram of compact K\"ahler spaces +\begin{equation} + \label{floor:quotient-diagram} + \begin{tikzcd}[column sep=large] + W \arrow[r,"g"] \arrow[d,"p"'] & P \arrow[d,"u"]\\ + Y \arrow[r,"f"'] & Z + \end{tikzcd} +\end{equation} +in which $W$ is smooth and resolves the pair, $P$ is a smooth +nonprojective compact K\"ahler surface, both $g$ and $u$ have +connected fibers, the very general $g$-fiber is $\PP^1$, and every +$p$-exceptional divisor is vertical over $P$. The horizontal +crepant boundary on $W$ is effective, with weighted degree two on +a general $g$-fiber. Moreover $r\le1$ and +$H^0(P,K_P)\ne0$. +\end{lemma} + +\begin{proof} +On an initial smooth projective log resolution of $Y$, restrict the +crepant equality +\[ + K_W+\Gamma_W=p^*J_Y +\] +to a very general smooth connected fiber of the map to $Z$. +Its right side is trivial. Pair with the appropriate power of the +pullback of a K\"ahler class from $Y$. Exceptional terms have zero +pairing, because their images have codimension at least two on this +general fiber, or they do not meet it. Strict boundary terms have +nonnegative pairing; a dominant coefficient-one branch gives a +strictly positive term. Hence the canonical class of this smooth +fiber is not pseudo-effective. Ou's theorem implies that the +fiber is uniruled \cite{OuUniruledness}. For $r=0$ this argument is +applied to the total space. + +Take the almost holomorphic rational quotient of the smooth +K\"ahler resolution. Its fiber has positive dimension, since the +rational curves through very general points of the fibers just +considered are quotient-contracted +\cite{CampanaRationalQuotient}. Its base cannot have dimension +at most one. Indeed, rational connectedness of the general quotient +fibers and the differential sequence would then force every +holomorphic two-form on a resolved total space to vanish. The +K\"ahler projectivity criterion would make that total space +projective, a contradiction. The quotient base is therefore a +surface, and the general quotient fiber is a smooth rational curve. +Those curves are vertical over $Z$, so $f$ factors meromorphically +through the quotient. Resolving the graphs and the base gives +\eqref{floor:quotient-diagram}. Stein factorization and very +general connectedness give connected $g$-fibers; the fibers of $u$ +are connected as images of the connected fibers of $fp$. + +If $P$ were projective, the rational-curve fibration would have +Moishezon total space. For example, coherence and GAGA give +meromorphic sections of $g_*\OO_W(-K_{W/P})$ generating its general +fibers. Evaluation embeds the general smooth rational fiber, and +these sections together with base functions give full algebraic +dimension. Thus $P$ is nonprojective. + +Every exceptional prime of the initial projective resolution of +$Y$ is projective over a compact curve or a point, hence Moishezon. +It cannot dominate $P$: a dominant generically finite map of +surfaces preserves algebraic dimension, by the norm or +characteristic-polynomial argument after finite Stein +factorization. The strict transform of a Moishezon prime remains +Moishezon. The further graph resolutions can be made isomorphisms +over a general quotient-base open, so their new exceptional primes +are vertical too. Consequently all horizontal crepant boundary +terms are strict transforms of effective boundary components. +Adjunction on the general rational fiber makes their weighted +degrees sum to two. + +A nonprojective compact K\"ahler surface has a nonzero holomorphic +two-form, again by the K\"ahler projectivity criterion. Finally, +if $r=2$, then $P\to Z$ would be generically finite over a +projective surface, forcing $P$ to be Moishezon and projective. +Thus $r\le1$. +\end{proof} + +We use two elementary consequences of nonprojectivity for surfaces. +If $Q$ is a smooth nonprojective compact K\"ahler surface, then the +intersection form on +\[ + N_Q=\NS(Q)_{\R} +\] +is nonpositive. Indeed, a positive-square vector in this rational +subspace can be approximated by a rational one, with sign chosen to +have positive K\"ahler degree. The corresponding line bundle has +quadratic section growth by Riemann--Roch: its high powers have no +top cohomology by Serre duality and the K\"ahler degree test. This +would make $Q$ Moishezon and hence projective. Moreover, if +$Q\to C$ is a map to a projective curve, $Q$ has no multisection. +For a curve $B$ dominating $C$, the class $B+tF$, with $F$ the +rational fiber class and $t\gg0$, would have positive square. + +\begin{lemma}[Horizontality, including fractional boundaries] +\label{floor:horizontality} +Every dominant conductor branch at the non-Moishezon vertex of +Lemma~\ref{floor:quotient-surface} is horizontal over $P$. A +cluster containing such a vertex consists entirely of +non-Moishezon vertices. At a vertex there are at most two dominant +branches, counted with their generic degrees over $P$. +\end{lemma} + +\begin{proof} +If $r=1$, a vertical surface which dominates $Z$ would have image +a curve in $P$ dominating $Z$. This contradicts the preceding +no-multisection observation. It remains to prove horizontality +when $r=0$, so that $J_Y\sim_\Q0$. + +Choose a nonzero $\eta\in H^0(P,K_P)$. On the general rational +fiber write the distinct horizontal marked points and their +coefficients as +\[ + b_1,\ldots,b_q\in\Q,\qquad + 00$ such that +\begin{equation} + \label{floor:incidence-weights} + \sum_{j0$, and $I_n^*$ +for $n>0$, have infinite monodromy. Euler addition with at +most two critical values would therefore give $e(Q)\le20$, +contrary to \eqref{floor:euler-lower}. The finite set of +critical values is preserved by the base action, and an +automorphism of $\PP^1$ fixing three points is the identity. +The base image is finite in this final case too. + +Pass to the finite-index kernel fixing both $C$ and all +holomorphic top forms. Choose a nonzero holomorphic top form +$\eta$ on $Q$. Any meromorphic $m$-canonical tensor, divided +by $\eta^{\otimes m}$, is a meromorphic function and hence +comes from $C$. The kernel fixes it. It therefore fixes all +the adjoint section spaces under their meromorphic canonical +realizations. The original loop action has finite image. +\end{proof} + +\begin{lemma}[Matching in non-Moishezon clusters with $r=1$] +\label{floor:nonprojective-r1} +Such a cluster admits the required nonzero matching tuple, +with zero restriction on every nondominant branch. +\end{lemma} + +\begin{proof} +Use the dominant surfaces as objects, with conductor matchings +and the internal arrows just constructed. Lemma +\ref{floor:nonprojective-loops} supplies loop finiteness, so +Lemma~\ref{floor:products} gives invariant nonzero sections +in a common degree $m'$. + +We verify their descent at each node. A degree-one branch +$S$ is bimeromorphic to $P$, so its general fibers over $Z$ +are connected. Its section of $m'J_S$ is therefore pulled +back from $m'H$ on $Z$. When there are two such branches, +the internal arrow makes these base sections identical. +For a degree-two branch, resolve $S\dashrightarrow P$. +Over a general $z\in Z$, every component of the fiber +dominates the connected smooth curve $P_z$, with total +degree two. Indeed, an exceptional or bad curve on $P$ +cannot dominate $Z$, by the no-multisection observation. +Divide the section by the pullback of a local frame of +$m'H$. This holomorphic function is constant on each +compact connected component of the fiber. Invariance under +the sheet-exchange arrow equates the two generic values. +It descends meromorphically to $Z$, and then holomorphically: +a meromorphic function on a normal base whose pullback by a +proper surjection is regular has no pole, as can also be +checked through finite Stein factorization. + +Pull these base sections back to $Y$. Their restrictions +match along dominant edges because the object sections do. +They vanish on the prescribed nondominant images because +the invariant object sections retain the initial vanishing +factor and dominate $Z$. This gives the desired tuple. +\end{proof} + +\begin{lemma}[Matching in non-Moishezon clusters with $r=0$] +\label{floor:nonprojective-r0} +Such a cluster also admits a nonzero matching tuple. +\end{lemma} + +\begin{proof} +All node adjoints are torsion. Choose a common sufficiently +divisible even degree and a trivializing section at each +node. Conductor comparison across an edge is multiplication +by a nonzero constant on these sections. A graph with no +cycles permits all comparisons to be solved by rescaling. +In general it is enough to prove that the oriented product +of these constants around each cycle is a root of unity, +and then to take one further common power. + +The graph has degree at most two by +Lemma~\ref{floor:horizontality}. At a node on a cycle, +including a cycle formed by parallel edges, the two distinct +branches must each have degree one over its $P_i$. The +section from the proof of Lemma~\ref{floor:horizontality} +is now a power of $d\log x\wedge\eta_i$: the two unit +points exhaust the horizontal weighted degree. Its even +residues on the two branches are the corresponding powers +of the base top form $\eta_i$. Following the cycle gives +bimeromorphic identifications of the $P_i$ and hence +isomorphisms of their smooth minimal models $Q_i$, since +they have nonnegative Kodaira dimension. The cycle +constant is the scalar on $\eta^{\otimes m}$, or its +inverse, for the resulting automorphism $\phi$ of one +minimal model $Q$. + +The existence of a single ambient K\"ahler class restricts +this automorphism. Fix a K\"ahler form $\omega$ on $V$. +At the two branches of a cycle node, choose smooth branch +resolutions and maps +\[ + r_k:B_k\longrightarrow W_i,\qquad + \alpha_k:B_k\longrightarrow Q_i,\qquad k=1,2, +\] +where $\alpha_k$ is bimeromorphic. Put +\[ + v_k=(\alpha_k)_*r_k^*p_i^*[\omega] + \in H^{1,1}(Q_i,\R). +\] +Each $v_k$ has positive square. In fact, the pulled-back +ambient class $\beta_k$ on $B_k$ has positive square because +the branch maps generically birationally onto its surface +image in $V$. Write +$\beta_k=\alpha_k^*v_k+e_k$ with $e_k$ exceptional. +Orthogonality and negative definiteness of exceptional +surface classes give +\begin{equation} + \label{floor:positive-branch-class} + v_k^2=\beta_k^2-e_k^2>0. +\end{equation} + +Furthermore, +\begin{equation} + \label{floor:node-congruence} + v_1-v_2\in\NS(Q_i)_\R. +\end{equation} +Indeed, the rational Hodge morphism +\[ + (\alpha_1)_*r_1^*-(\alpha_2)_*r_2^* + :H^2(W_i,\Q)\longrightarrow H^2(Q_i,\Q) +\] +kills $H^{2,0}$ and $H^{0,2}$. Holomorphic two-forms are +basic on the smooth rational-fiber open, by the differential +sequence and the absence of fiberwise one-forms; their +restrictions to the two birational sections agree. Hence +the rational image of this Hodge morphism has type $(1,1)$, +and is contained in the rational N\'eron--Severi space. +Apply it to the ambient real class to obtain +\eqref{floor:node-congruence}. Across a conductor edge the +corresponding branch maps to $V$ agree on a common higher +model. The transported $v_k$ therefore agree across that +edge. Going around the cycle yields +\begin{equation} + \label{floor:cycle-congruence} + \phi^*v-v\in N:=\NS(Q)_\R,\qquad v^2>0. +\end{equation} + +The form on $N$ is nonpositive. If it is negative definite +(including $N=0$), project $v$ orthogonally to $N^\perp$. +The result $w$ has positive square and is fixed by $\phi^*$, +by \eqref{floor:cycle-congruence}. The Hodge index theorem +makes the $(1,1)$ complement of $w$ negative definite; +the real $(2,0)+(0,2)$ summand is positive definite. +Together these give a positive definite real norm on +$H^2(Q,\R)$ preserved by the integral action. The cyclic +image is finite, so in particular its eigenvalues on +$H^{2,0}(Q)$ are roots of unity. If $N$ has a radical, +the Hodge index theorem makes it a rational invariant +isotropic line. Its orthogonal quotient has the definite +Hodge summands and integral lattice used in +\eqref{floor:isotropic-quotient}; the image on $H^{2,0}$ +is again finite. + +These exhaust the possibilities for $N$. Since +$\phi^*\eta^{\otimes m}$ is proportional to +$\eta^{\otimes m}$, the nonzero form $\eta$ itself is an +eigenform: its meromorphic ratio to its pullback has an +$m$th power which is constant, and hence is constant. +Its eigenvalue, and thus the cycle constant, is a root of +unity. Taking a common power over the finitely many +cycles and then rescaling the node sections solves all +conductor comparisons. +\end{proof} + +\subsection{Projective clusters and log-trivial linking} + +Every remaining cluster consists of projective vertices. Indeed, +Lemma~\ref{floor:horizontality} excludes a dominant edge from a +non-Moishezon vertex to a Moishezon one, and a Moishezon vertex is +projective by the klt-type and Namikawa argument above. All the +strata and birational diagrams used in such a cluster are +algebraic in characteristic zero. + +For loop finiteness we use the projective +$B$-pluricanonical-representation theorem: for a projective lc +pair with effective rational boundary and semiample rational +adjoint, its $B$-birational group acts with finite image on +sufficiently divisible log-pluricanonical systems +\cite[Theorem~1.1]{FujinoGongyoPluricanonical}. This applies to +our normal projective stratum objects with their full +adjunction boundaries. The remaining issue is to specify enough +internal arrows so that the invariant object sections descend +to the nodes. We give the required linking arguments. + +\begin{lemma}[Connected components of the non-klt locus] +\label{floor:nklt-components} +Let two effective projective lc pairs be crepant bimeromorphic, +and suppose each is klt after decreasing its floor. On a common +projective log resolution write their common crepant +subboundary as $\Theta$, and put +\[ + T_\Theta=\Theta^{=1},\qquad + N=-\lfloor\Theta^{<1}\rfloor. +\] +Then $N$ is effective and exceptional for each projection, and +$T_\Theta$ maps with connected fibers onto the non-klt locus +of either pair. In particular their floor supports have the +same number of connected components. +\end{lemma} + +\begin{proof} +Fix either projection $d$. Nonexceptional coefficients are +those of an effective subboundary, so the negative part +contributing to $N$ is exceptional. The divisor +\[ + N-T_\Theta=-\lfloor\Theta\rfloor +\] +differs from the smooth klt adjoint $K+\{\Theta\}$ by +$-(K+\Theta)$, a pullback from the base. It is thus relatively +nef and big; relative bigness here uses that $d$ is birational. +Relative Kawamata--Viehweg vanishing gives +\begin{equation} + \label{floor:kv-connectedness} + R^1d_*\OO(N-T_\Theta)=0 +\end{equation} +\cite{KawamataViehwegVanishing}. Normality gives +$d_*\OO(N)=\OO$. The divisor sequence and +\eqref{floor:kv-connectedness} therefore give a surjection +\[ + \OO\longrightarrow d_*\OO_{T_\Theta}(N). +\] +It factors through $d_*\OO_{T_\Theta}$, which injects into +$d_*\OO_{T_\Theta}(N)$ because $N$ has no component in +$T_\Theta$. Thus $d_*\OO_{T_\Theta}$ is the structure +sheaf of the reduced image of $T_\Theta$. This image is +the non-klt locus. Stein factorization, or the absence of +nontrivial fiberwise idempotents in this equality, shows +that the fibers are connected. A proper surjection with +connected fibers induces a bijection on connected +components. The common $T_\Theta$ gives the assertion +for both projections. Since the pairs become klt after +decreasing the floor, their non-klt loci are exactly their +floor supports. +\end{proof} + +We also use the following elementary consequence of relative +degree zero. Let $E\ge0$ be a rationally Cartier divisor on a +connected projective fiber of a contraction, with $E\cdot C=0$ +for every contracted curve $C$. If the fiber meets $E$, its +whole support is contained in $E$. Otherwise a chain of +projective curves joining the part in $E$ to a point outside +it contains a curve not in $E$ which meets $E$. Its +intersection with $E$ is positive, a contradiction. We shall +refer to this as the \emph{whole-fiber property}. In particular, +a vertical floor prime of degree zero which meets a fiber +meets every horizontal floor component, since each horizontal +component surjects onto the contraction base. + +\begin{lemma}[Log-trivial internal linking in dimension at most three] +\label{floor:trivial-linking} +Let $(Y,\Gamma)$ be a connected normal projective dlt pair of +dimension at most three, with effective rational boundary, +nonempty floor, and +$K_Y+\Gamma\sim_\Q0$. Suppose the underlying space admits +an effective rational klt pair. Then the normalized minimal +lc centers, with chain adjunction, can be connected by +$B$-birational comparisons preserving the canonical residues +of a common trivializing log-pluricanonical section in +sufficiently divisible even degrees. +\end{lemma} + +\begin{proof} +Take a projective small $\Q$-factorialization for the +underlying klt pair \cite{BCHM}. It is crepant for the full +adjunction pair and isomorphic at general SNC stratum +points. The full pair remains dlt, its centers correspond +bimeromorphically, and the chain adjunctions and even residue +maps correspond on common resolutions. We may therefore +work on this $\Q$-factorial model. + +Proceed by dimension. In dimension one, a unit marking on +a log-trivial curve forces a rational curve; there are at +most two unit markings. For two markings the even residues +of the logarithmic generator agree by +\eqref{floor:dlog-residues}. A single marking requires no +comparison. + +Suppose first that $\lfloor\Gamma\rfloor$ is connected. +Each normalized floor component with full adjunction again +has a dlt log-trivial pair, and it admits a klt pair by +adjunction keeping only that component in the ambient +boundary. Within it use induction if there are proper +lc subcenters; otherwise that component is itself the +minimal lc center. For two successive intersecting floor +components choose a minimal lc center in their intersection. +Such centers exist by ordinary dlt stratum adjunction; +intersecting distinct unit primes meet in lc strata, as is +also seen on a general transverse surface. The two even +chain restrictions through this shared center agree. +Connectedness of the floor then links all the minimal +centers. + +Suppose instead that the floor is disconnected. Decrease +all its coefficients by one fixed small positive rational +$\epsilon$. The resulting pair is klt, and its adjoint +is $\Q$-linearly equivalent to +$-\epsilon\lfloor\Gamma\rfloor$, so is not +pseudo-effective. The projective klt MMP in dimension at +most three ends in a $\Q$-factorial elementary Mori fiber +space +\[ + Y'\longrightarrow P +\] +\cite{ThreefoldFlipsAbundance,BCHM}. These steps are +crepant for the full log-trivial pair. One may see this +by transporting a trivializing pluricanonical tensor: +there is no extraction, its divisor remains the negative +of the corresponding multiple of the pushed full boundary, +and the resulting pullback formulas agree. Equivalently, +the exceptional comparison of the full, relatively +numerically trivial adjoints is zero by negativity. + +The pushed floor is relatively ample and supports the +entire non-klt locus, because its decrease is klt. +Lemma~\ref{floor:nklt-components} shows that it is still +disconnected. Some floor component is horizontal by +relative ampleness. A vertical floor prime has degree +zero on the Mori ray, since it misses a general fiber. +By the whole-fiber property it contains every fiber it +meets, and so meets every horizontal floor component. +Every other vertical prime is likewise connected to the +horizontal components. The presence of any vertical +floor would consequently connect the entire floor. +There are therefore no vertical floor primes. + +Disconnectedness is now visible on a general fiber, since +every component is horizontal. That fiber must be a +curve. Indeed, on a normal projective Cohen--Macaulay +fiber of dimension at least two an effective ample +divisor has connected support. To check this, take a +large Cartier multiple $A$ of it. Serre duality and +Serre vanishing give $H^1(\OO(-kA))=0$ for $k\gg0$; +the divisor sequence then gives +$H^0(\OO_{kA})=\C$, implying connected support. +The general fiber here is of klt type and hence +Cohen--Macaulay, and the floor restricts to an effective +ample divisor. Its restriction is lc and becomes klt +after decreasing the floor, as can be checked on the +restricted common log resolution. + +The general fiber is consequently a rational curve with +exactly two degree-one unit markings: it has a nonempty +boundary and log-trivial adjoint, the total weighted +degree is two, and disconnectedness gives two different +horizontal components. Over a smooth projective model +$R$ of $P$ we obtain a bimeromorphic model +$\PP^1\times R$ with these marks as zero and infinity. +The trivializing tensor is, over the function field and +hence meromorphically, a power of the two-pointed +$d\log$ generator times a meromorphic pluricanonical +tensor on $R$. Resolving its divisor on $R$, the +crepant subboundary on the product is therefore +\begin{equation} + \label{floor:product-subboundary} + \{0\}\times R+\{\infty\}\times R + +\operatorname{pr}_R^*B_R, +\end{equation} +where $B_R$ may be signed, is log smooth, and has all +coefficients at most one. + +No vertical coefficient in +\eqref{floor:product-subboundary} can equal one. Such +a prime would connect the two sections by an SNC path +of unit components. This path remains connected +through unit components on a common resolution mapping +to $Y'$. Explicitly, when a smooth blowup separates +two adjacent unit components at their general +codimension-two crossing, its exceptional divisor has +coefficient one and joins their strict transforms. +Blowups not separating that crossing leave the +connection. The image of the path would lie in the +non-klt locus of $Y'$ and meet both disconnected floor +components, a contradiction. + +All vertical coefficients are therefore strictly below +one. The log-smooth discrepancy formula now says that +the only zero-log-discrepancy places are the two +horizontal sections themselves. In fact zero places +of a log-smooth subboundary with coefficients at most +one are generated by its unit strata; here the two +unit divisors are disjoint and there are no deeper +unit strata. Both section valuations occur as +divisors on the original pair, since its floor is +disconnected. They are exactly its minimal lc +centers. Pair them bimeromorphically through $R$. +Their residue restrictions from the common generator +agree in even powers by \eqref{floor:dlog-residues}. +Since these restrictions trivialize their adjunction +lines, equality as meromorphic tensors on a common +resolution gives $B$-crepancy. This finishes the +disconnected case and the induction. +\end{proof} + +\begin{lemma}[Matching in projective clusters with $r=0$] +\label{floor:projective-r0} +Every projective cluster with $r=0$ has a nonzero matching +tuple. +\end{lemma} + +\begin{proof} +Use as objects the normalized minimal lc centers of the +nodes, with their iterated full adjunction pairs. +Their adjoints are torsion. Lemma +\ref{floor:trivial-linking} supplies internal arrows +connecting all objects at a node and preserving even +restrictions from a trivializing node section. + +For a matched conductor surface choose a minimal lc +center inside it. More precisely, choose a minimal +ambient lc stratum contained in the double stratum. +It is a minimal center for the chains on both sides: +any further subcenter would again be a nested ambient +stratum, by the generic SNC description. Its shared +normalization gives an arrow between the two node +objects, with the symmetric even residue comparison +from $V$. + +The projective representation theorem gives finite +loop images. Lemma~\ref{floor:products} therefore +provides nonzero invariant sections in a common +degree. They are trivializing sections on the +objects. At a fixed node, their scalar ratios to +restrictions of one trivializing node section agree +by the internal arrows, so one node section induces +all of them. Across a conductor surface the two +node restrictions are trivializations of the same +torsion line. Their ratio is constant on that +connected normal surface. It is one on the chosen +minimal center by the even residue comparison, so +it is one everywhere. The node sections thus match +on every conductor surface. +\end{proof} + +The preceding linking argument also explains the +usual construction of pre-admissible sections; compare +\cite[Section~5]{GongyoNumericallyTrivial} +and \cite{KollarSources}. We have given it here to retain +the actual residue comparisons needed for the present +ambient line. + +\begin{lemma}[Matching in projective clusters with $r=2$] +\label{floor:projective-r2} +Every projective cluster with $r=2$ admits a nonzero +matching tuple vanishing on all nondominant branches. +\end{lemma} + +\begin{proof} +At a node with a dominant branch, the general +$f_i$-fiber is a smooth connected rational curve. +Indeed it has +$K_F+\Gamma_F\sim_\Q0$ and a unit marking, so +adjunction forces genus zero and horizontal weighted +boundary degree two. Use dominant surface branches +as objects. If there are two degree-one unit +branches, or one degree-two unit branch, the +two-mark calculation +\eqref{floor:dlog-residues} gives their internal +comparison or sheet-exchange involution over $Z_i$. +These are $B$-crepant and preserve restrictions of +base sections. A single degree-one unit branch +needs no internal comparison, even if other +horizontal markings have fractional coefficients. + +Combine these arrows with conductor matchings and +apply the projective representation theorem and +Lemma~\ref{floor:products}. At a degree-one object, +a section descends to the base by the birational +comparison. At a degree-two object, divide by a +local base frame. Invariance under the involution +equates the two generic values, so the ratio is a +meromorphic base function; normality and properness +give holomorphic descent. For two degree-one +objects the internal arrow equates their descended +sections. Pulling back gives the desired node +sections. Conductor matchings and the retained +initial vanishing factors give exactly the required +matching and nondominant vanishing. +\end{proof} + +\subsection{Projective clusters with a curve system} + +It remains to treat $r=1$. Fix a projective node +$(Y,\Gamma)$ with system map $f:Y\to Z$, where $Z$ +is a projective curve. On sufficiently general fibers, +including fibers on simultaneous log resolutions, we +have a connected normal projective dlt log surface +\begin{equation} + \label{floor:surface-fiber} + (F,\Gamma_F),\qquad + K_F+\Gamma_F\sim_\Q0,\qquad + \Sigma_F:=\lfloor\Gamma_F\rfloor\ne0. +\end{equation} +Normality follows from the general-slice and +Cohen--Macaulay properties, and dlt follows from the +restricted discrepancy formula and general +transversality. Horizontal boundary components +restrict reduced, while vertical components are +absent on this general fiber. The floor curves are +smooth and their intersections are ordinary double +lc points. Effective curve adjunction shows that a +floor curve meeting another is rational and meets +the other floor curves at at most two points. If +there are two points, its entire log boundary is +precisely these two unit markings. + +\begin{lemma}[Disconnected floor on a general surface fiber] +\label{floor:disconnected-fiber} +If $\Sigma_F$ in \eqref{floor:surface-fiber} is +disconnected, it consists of exactly two disjoint +floor curves and there is no deeper lc center in +$F$. The corresponding dominant floor data on +$Y$ admit an internal pairing over an intermediate +projective surface $P\to Z$ with connected general +fibers. Generically they are the two unit markings +of log rational-curve fibers on a model crepant +over $Z$. The two curves over a general $z\in Z$ +are bimeromorphic to the same smooth connected +curve $P_z$. Globally the pairing is either +between two surfaces or an involution of one +surface. +\end{lemma} + +\begin{proof} +Start on a projective crepant $\Q$-factorial dlt +model of $Y$. Decrease all floor coefficients +by a fixed small rational $\epsilon>0$ and run +the projective klt threefold MMP over $Z$. +The decreased adjoint restricts to a negative +multiple of the nonzero effective floor on +a general fiber, so it is not relatively +pseudo-effective. The program ends in a +relatively elementary Mori fiber contraction +\begin{equation} + \label{floor:relative-mori} + Y'\longrightarrow P\longrightarrow Z, +\end{equation} +with $Y'$ $\Q$-factorial. The full adjoint +remains the actual pullback of $H$ at every +step: all steps are over $Z$ and extract no +divisors, and negativity kills the exceptional +relatively numerically trivial comparison. +Thus the full lc data are crepant throughout. +The transformed floor $\Sigma'$ is relatively +ample over $P$ and supports the full non-klt +locus, since its decrease is klt. Both maps +in \eqref{floor:relative-mori} have connected +fibers; for the second this also follows by +pushing the structure sheaf of the connected +system map through the first. + +On a common smooth projective resolution of +the general fibers $F$ and $F'=Y'_z$, the +crepant subboundary is the same. Lemma +\ref{floor:nklt-components}, applied to these +surfaces, shows that the floor support on +$F'$ remains disconnected. This application +does not require that the transformed full +pair be dlt: it is lc, and its decrease is +klt, which are the hypotheses used in that +lemma. + +If $\dim P=1$, the floor on $F'$ would be +ample and connected. One may use the +connected-support argument in the proof of +Lemma~\ref{floor:trivial-linking}, or the +surface Hodge index theorem: a disjoint +splitting of an ample rational divisor would +give orthogonal classes with positive square. +Consequently $\dim P=2$. A general Mori +fiber over $P$ is rational, with total +horizontal weighted boundary degree two and +at least one unit marking. A vertical floor +prime has degree zero on the Mori ray. If +it dominates $Z$, the whole-fiber property +gives, on a general $F'$, a full fiber over +a point of $P_z$, meeting every horizontal +floor curve. Every other vertical floor +contribution likewise joins the horizontal +ones. All components restricted from a +horizontal surface dominate $P_z$ for +general $z$, after discarding the finitely +many nongeneral base values. Thus such a +vertical floor prime would connect the +entire floor of $F'$, which is impossible. + +There are therefore no vertical floor +contributions on general $F'$. Disconnectedness +and the degree sum two force exactly two +disjoint degree-one floor curves over $P_z$. +The curve $P_z$ is smooth and connected for +general $z$: the normal surface base has +only isolated singularities, and generic +smoothness and connected fibers apply. + +We also need to exclude hidden deeper +zero-discrepancy places. Choose the rational +fiber coordinate $x$ over $P_z$ with these +two curves as zero and infinity. This gives +a bimeromorphic product model +$\PP^1\times P_z$ of $F'$. A divisible +pluricanonical tensor trivializing its full +log adjoint is, in relative notation, +\begin{equation} + \label{floor:surface-dlog-product} + (d\log x)^{\otimes m}\otimes\gamma, +\end{equation} +where $\gamma$ is a meromorphic +$m$-canonical tensor on $P_z$. There are +no other horizontal boundary terms because +the two unit marks exhaust the degree. +The crepant subboundary on the product is +the two unit sections and vertical fibers +with coefficients +$-\ord_p(\gamma)/m\le1$. + +A coefficient-one vertical fiber would +join the two sections by an SNC unit path. +Successive point blowups preserve this +path through unit components: a blowup at +a crossing of two unit components inserts +a unit exceptional curve. On a common +resolution its image in $F'$ would join +the two disconnected floor curves inside +the non-klt locus. Thus every vertical +coefficient is strictly below one. The +log-smooth discrepancy calculation now +leaves only the two horizontal sections +as zero-log-discrepancy places. They +must both appear as divisors on $F$, since +its floor is disconnected. Hence its +floor consists of those two curves and +has no deeper lc center. + +In particular, no zero-discrepancy place +horizontal over $Z$ is extracted or lost +between $Y$ and $Y'$: restricting such a +place to a general surface fiber would +give another zero-discrepancy place there. +The two Mori marks consequently correspond +bimeromorphically to the original dominant +floor data. Pair them over $P$, using +normalization of the degree-two cover when +the two marks belong globally to one +surface. The full crepant equalities over +$Z$ transport local base frames, and the +even $d\log$-residue calculation gives +the asserted internal $B$-comparison. +\end{proof} + +Classify a node as \emph{type I} if it has a +deeper curve lc center dominating $Z$, and as +\emph{type II} otherwise. In type I the floor +of the general surface fiber is connected and +has crossings, by +Lemma~\ref{floor:disconnected-fiber}. Every +dominant floor surface contains a deeper +dominant center: every vertex of the connected +floor graph meets another, and its crossings +trace such centers. In type II the floor is +either a single smooth curve, or the +disconnected pair of that lemma. These types +are constant across dominant edges. A shared +surface has the same full adjunction on both +sides; a further lc center which dominates +the system curve on one side does so on the +other, equivalently because its curve +adjoint, the restriction of $J$, has positive +degree. The generic SNC nesting identifies +the further center on both chains. Since +every branch of a type I node contains such +a center, the type propagates through the +cluster. + +\begin{lemma}[Type II matching] +\label{floor:projective-r1-II} +A type II projective cluster with $r=1$ +admits a nonzero matching tuple with the +required nondominant vanishing. +\end{lemma} + +\begin{proof} +Use dominant surface branches as objects. +For a single smooth floor curve on a +general fiber, the corresponding surface +has connected general fibers over $Z$, +so its sections come from $Z$. In the +disconnected case use the internal arrows +of Lemma~\ref{floor:disconnected-fiber}. +Over a general $z$, the two curves are +bimeromorphic to the connected curve +$P_z$. The values of a section relative +to a local base frame are constant on +each of them, and internal invariance +equates the constants. This remains true +when the two curves are in one global +surface and the arrow is an involution. +Thus invariant sections descend +meromorphically and then holomorphically +to $Z$, using normality and properness. + +The projective representation theorem +and Lemma~\ref{floor:products} provide +the invariant nonzero object sections. +Their descended base sections pull back +to node sections. Matching follows +from the conductor arrows, and vanishing +from the retained initial base factors. +\end{proof} + +\begin{lemma}[Type I matching by flagged curves] +\label{floor:projective-r1-I} +A type I projective cluster with $r=1$ +also admits a nonzero matching tuple with +the required nondominant vanishing. +\end{lemma} + +\begin{proof} +The objects now are normalized curve +strata, \emph{flagged} by the node $Y_i$, +a dominant surface branch $S$ at that +node, and a further normalized curve +branch on $S$ dominating $Z_i$. The +flag records the actual chain of residue +maps. Give each curve its full effective +adjunction boundary and the actual +restricted line $J_L$. + +There are three kinds of arrows. +First, identify the corresponding +flags across a shared conductor surface. +Second, identify the flags through the +two surface branches at a deeper curve +center within one node. The generic SNC +calculation and even residues identify +these chains. Third, consider a fixed +$S$ and the curve Stein factor of +$S\to Z_i$. If a general connected +fiber has two floor crossings, pair +these two markings over that Stein +curve. They give a bimeromorphic map +between curve objects or an involution +of one object. By the surface-fiber +description preceding +Lemma~\ref{floor:disconnected-fiber}, +this fiber is log rational with exactly +these two unit points. Thus +\eqref{floor:dlog-residues}, now applied +to the full adjunction on $S$, gives a +$B$-crepant arrow preserving restrictions +of base sections. A floor fiber curve +with only one crossing requires no +internal pairing of points. + +These arrows connect all flagged +crossing points over a general +$z\in Z_i$ within a node. Indeed, the +whole floor graph of $F$ is connected, +each floor curve meets another at one +or two points, the two crossings on a +curve are paired by the third kind of +arrow, and the two flags at a crossing +are paired by the second. This connects +the flags along every path in the +connected graph. + +All curve objects are projective lc +pairs with semiample adjoints, so the +projective representation theorem gives +finite loop images. Apply +Lemma~\ref{floor:products}, with initial +sections pulled from the respective +node bases and vanishing on the required +nondominant images. In the common final +degree, divide the invariant curve +sections by a local pulled-back base +frame. The preceding connectivity says +that their values coincide on all flag +sheets over a general $z$. They +therefore define one meromorphic base +section. It is holomorphic, since its +pullbacks to the finite dominating +curve covers are holomorphic and the +base is normal. Pulling it back gives +a section on the node. + +Across a dominant conductor surface +$S$, equality on a chosen dominant +further curve implies equality of the +two node restrictions on all of $S$. +To see this precisely, both restrictions +are sections of the semiample actual +line $mJ_S$, hence are pulled from its +connected-fiber Stein system base. +That base is a curve, and the chosen +curve stratum dominates it, since it +dominates $Z_i$. Pullback of sections +to that stratum is injective. The +canonical even adjunction compares +these pullbacks, which agree by the +first kind of arrow; hence the original +restrictions agree. Finally, the +initial vanishing factors and dominance +of the objects show that the node +sections vanish on every nondominant +branch. This proves the claim. +\end{proof} + +\subsection{Completion of whole-boundary nonvanishing} + +\begin{proof}[Proof of Proposition~\ref{floor:section}] +Take a cluster of vertices of maximal system +dimension $r$. If it is isolated, choose a +nonzero high base section vanishing on all +nondominant branch images, as explained +above. Otherwise $r\le2$. A cluster +containing a non-Moishezon vertex is entirely +non-Moishezon and has $r\le1$; Lemmas +\ref{floor:nonprojective-r1} and +\ref{floor:nonprojective-r0} handle its two +possibilities. Every other cluster is +projective. Lemmas +\ref{floor:projective-r0}, +\ref{floor:projective-r2}, +\ref{floor:projective-r1-II}, and +\ref{floor:projective-r1-I} cover all its +possibilities. + +In each case we have, in one sufficiently +divisible even degree, a nonzero tuple of +node sections matching on dominant edges +and vanishing on all nondominant branches. +Put zero on components outside the chosen +cluster and take a further common power +if necessary so that $mJ$ is Cartier on +the ambient $V$. At every conductor +surface either the two sections match +by construction or both restrictions +are zero. Lemma~\ref{floor:descent} +therefore descends the tuple to an +actual section of $\OO_D(mJ)$. It is +nonzero because its restriction to a +node in the chosen cluster is nonzero. +This proves \eqref{floor:goal} on the +whole reduced boundary. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/introduction.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..7a86e7ff243bdbccffbadd9610b507ecfb389f28 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/introduction.tex @@ -0,0 +1,153 @@ +\section{Introduction}\label{sec:introduction} + +The good minimal model problem asks whether a pseudo-effective +canonical adjoint can be made nef and generated by its sections on a +birational model. It joins two different questions: construction of a +minimal model and abundance of its nef adjoint. In the compact +K\"ahler category, the existence of the first pluricanonical section +is itself a substantial part of the problem. Positivity is analytic, +and even the passage from a cohomological identity to an identity of +holomorphic line bundles must be kept explicit. + +The projective minimal model program provides the birational framework +\cite{BirationalGeometry,BCHM}. In dimension three the K\"ahler +theory has developed through nonvanishing, minimal models and +abundance \cite{DemaillyPeternellNonvanishing,HPMinimalModels, +CHPAbundance,CHPAbundanceErratum,GuenanciaPaunBogomolovGieseker}. +Work on fourfolds and on +pseudo-effective adjoints supplies further analytic and birational +tools \cite{DHPFourfoldMMP,HLLNonvanishing}. Our concern is the +precise additional nonvanishing argument needed when a +pseudo-effective fourfold MMP and abundance after nonvanishing are +available. + +Section~\ref{sec:premises} records three inputs: full orbifold +Iitaka subadditivity in Fujiki class \(\mathcal C\), the specified +pseudo-effective klt fourfold MMP, and abundance for nef klt fourfold +adjoints of nonnegative Kodaira dimension. The MMP input is supplied +by \cite[Theorem~6.24 and Proposition~3.4]{GrantMMP}, independently +of subadditivity, as detailed after Assumption~\ref{hyp:mmp}. +Assumption~\ref{hyp:mmp} records the precise program used below; +the remaining conditional premises are orbifold Iitaka subadditivity +and effective fourfold abundance. We prove the good-minimal-model +assertion in the following category. + +\begin{theorem}[Conditional good minimal models]\label{thm:main} +Assume Assumptions~\ref{hyp:campana}, \ref{hyp:mmp}, and +\ref{hyp:effective-abundance}. Let \(X\) be a normal connected +compact K\"ahler fourfold, and let \(B\) be an effective rational +Weil divisor. Suppose that \((X,B)\) is klt, that its actual adjoint +\(D=K_X+B\) is \(\Q\)-Cartier and analytically +pseudo-effective, and that \(X\) is globally strongly +\(\Q\)-factorial in the sense of Definition~\ref{def:strong}. + +Then there are a normal connected globally strongly +\(\Q\)-factorial compact K\"ahler fourfold \(Y\) and a +bimeromorphic map \(\phi:X\dashrightarrow Y\) such that: +\begin{enumerate}[label=\textup{(\roman*)}] +\item \(\phi\) extracts no prime divisor, and + \(B_Y=\phi_*B\); +\item \((Y,B_Y)\) is klt and its actual adjoint + \(D_Y=K_Y+B_Y\) is \(\Q\)-Cartier and analytically nef; +\item \(a(E;Y,B_Y)\ge a(E;X,B)\) for every prime divisor over + the models, with strict inequality for each prime on \(X\) + contracted by \(\phi\); +\item for some \(m>0\), the Cartier line bundle + \(\OO_Y(mD_Y)\) is globally generated. +\end{enumerate} +\end{theorem} + +The exponent may depend on the pair. Zero boundary, smooth fourfolds +and all numerical dimensions are included. Global strong +\(\Q\)-factoriality concerns all rank-one reflexive sheaves on +the whole space; it is not an assumption of local analytic +\(\Q\)-factoriality on every open subset. The conclusion concerns +the actual holomorphic adjoint line on the specified endpoint. + +Assumption~\ref{hyp:mmp} already produces a nef minimal model with +properties~\textup{(i)}--\textup{(iii)}. The new conclusion needed +before Assumption~\ref{hyp:effective-abundance} can be applied is +the following. + +\begin{theorem}[Nonvanishing on the nef endpoint] +\label{thm:nonvanishing} +Under Assumptions~\ref{hyp:campana}, \ref{hyp:mmp}, and +\ref{hyp:effective-abundance}, let \((Y,\Delta)\) be an ordinary +klt pair on a normal connected globally strongly +\(\Q\)-factorial compact K\"ahler fourfold. If \(\Delta\) +is effective and rational and the actual \(\Q\)-Cartier adjoint +\(J=K_Y+\Delta\) is analytically nef, then +\(\kappa(Y,J)\ge0\). +\end{theorem} + +\subsection{Structure of the proof} + +The projective case uses conditional projective log abundance. We +include its complete proof in +Appendices~\ref{proj:sec:introduction}--\ref{proj:sec:completion}; +Lemma~\ref{red:log-iitaka} derives its precise logarithmic-Iitaka +premise from Assumption~\ref{hyp:campana}. Thus the projective +branch introduces no further conditional premise. For a +nonprojective endpoint, rational quotients, the Albanese map and +lower-dimensional nonvanishing reduce the problem to canonical +nonvanishing on a smooth non-uniruled fourfold, principally with +irregularity zero. + +When algebraic dimension is positive, we first construct an actual +canonical pullback model over a projective base. The construction +uses sufficiently large ample twists, whose sections are already +known, and steps of a single empty-boundary program. Relative +rationality allows the twist to be chosen separately at each stage +without changing that program. The base has dimension at most three. +For a surface base, fiber powers convert subadditivity into the +intersection inequality needed for nonvanishing. For a threefold +base, the genus-one Hodge line and two modular forms give an +explicit crepant klt adjoint on the base. Their common divisorial +order is determined by one integrability calculation, including +exceptional base valuations. + +The algebraic-dimension-zero argument has four parts. +\begin{enumerate} +\item A nef ordinary klt adjoint has a metric of minimal +singularities with zero Lelong numbers. The proof combines a +volume-normalized capacity estimate, a differentiated +Monge--Amp\`ere equation and a Bochner transport estimate. The +comparison at the end controls a concentrating residual measure +on the same sublevel set. +\item If the divisorial locus is empty and no signed canonical +frame exists, holomorphic forms produce a transverse spherical +structure. A fixed point on the full compact convex set of positive +currents and the compactification of its holonomy lead to a +contradiction with algebraic dimension zero. +\item Relative analytic constructions produce nef reduced-boundary +models while retaining actual line identities and the global +reflexive-sheaf condition. The required dlt special termination is +proved in the dimension order used by the construction. +\item Adjunction and gluing give a section on the \emph{whole} +reduced floor. In the nonprojective torsion case, the ambient +K\"ahler class controls the pluricanonical scalars around gluing +cycles. This extra structure is what makes the cycle argument +finite. +\end{enumerate} +Finally, finite divisorial support and hard Lefschetz with multiplier +ideals extend a high power of the floor section if ambient +nonvanishing were to fail. Two choices of reduced boundary, according +to whether a signed meromorphic pluricanonical tensor exists, finish +canonical nonvanishing. The result then returns to the original nef +endpoint of the stipulated MMP. + +Several of these constructions have a scope beyond their immediate +use here: the metric lemma is dimension independent; the relative +descent argument treats global reflexive sheaves directly; the +genus-one calculation determines actual crepant orders; and the +floor argument isolates the role of a single ambient K\"ahler +class in nonprojective gluing. The long projective appendices are +organized separately so that the nonprojective argument can be read +with their precise theorem statement, while every new argument used +by that theorem remains available in the same manuscript. + +Figure~\ref{fig:proof-map} records these uses and the return to the +original nef endpoint. In the projective appendices, +Assumption~\ref{proj:mmp:lower-models} is the lower-dimensional induction +hypothesis, discharged in Appendix~\ref{proj:sec:completion}. +\input{figures/proof_map} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/minimal_metric.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/minimal_metric.tex new file mode 100644 index 0000000000000000000000000000000000000000..25e1329677723d5db06dd06a7e0fc66a64b5bdf7 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/minimal_metric.tex @@ -0,0 +1,871 @@ +\section{Minimal singularities of nef klt adjoints} +\label{met:section} + +We prove the metric statement needed in the remaining nonprojective +case. The proof does not require sections of a positive twist. We use +\(\ddc=\ii\partial\bar\partial\), and identify the class of a line bundle +with its curvature class; thus the usual factor \(2\pi\) in its first +Chern class is understood. Weights on a rational line bundle mean +weights obtained by taking a root of a metric on a fixed Cartier power. +All the line identifications below are actual rational line-bundle +identifications. + +\begin{lemma}[Minimal metric of a nef klt adjoint] +\label{met:zero-lelong} +Let \(p\colon M\to Z\) be a compact K\"ahler log resolution of a normal +compact K\"ahler klt pair \((Z,\Delta)\), where \(\Delta\geq0\) is rational +and \(K_Z+\Delta\) is a nef rational line bundle. Then a semipositive +metric with minimal singularities on +\[ + L=p^*(K_Z+\Delta) +\] +has zero Lelong numbers at every point of \(M\). +\end{lemma} + +\begin{proof} +We may suppose that \(M\) is connected. The assertion is immediate in +dimension zero, so write \(n=\dim M>0\). + +The proof is by contradiction from a positive Lelong number. We construct +the normalized Monge--Amp\`ere family \eqref{met:ma-family} and transport +its tail to obtain \eqref{met:endpoint-tail}. Keeping the potentially +concentrating residual measure, we compare on the same sublevel set to +obtain \eqref{met:residual-capacity}. We then take \(k\to\infty\) at +fixed \(t\); the upper Lelong estimate \eqref{met:limit-lelong-upper} +contradicts the lower bound \eqref{met:lelong-lower} as \(t\to0\). + +\subsection*{Resolution data and regularized measures} + +The log pullback gives +\begin{equation} + \label{met:adjoint-data} + L=K_M+\sum_i g_iD_i, + \qquad g_i<1, + \qquad g_i<0\Longrightarrow D_i\text{ is }p\text{-exceptional}, +\end{equation} +with simple normal crossings support. Choose a smooth weight \(\ell\) +on \(L\), pulled back from downstairs, and write \(\theta\) for its +curvature. Fix K\"ahler forms \(\omega\) on \(M\) and \(\omega_Z\) on +\(Z\), and a smooth probability volume \(dV\) on \(M\). On a singular +space, smooth forms and weights are understood through smooth local +potentials. + +For \(00, + \qquad + \int_{D_i}(\beta_t^0)^{n-1}=0\quad\text{if }g_i<0. +\end{equation} +The second equality follows from the dimension of the image of an +exceptional divisor and the fact that \(\beta_t^0\) is pulled back. + +Nefness and weak compactness give a positive current in \([\theta]\). +Let +\begin{equation} + \label{met:minimal-envelope} + \Phi=V_\theta + :=\left(\sup\{v\in\operatorname{PSH}(M,\theta):v\leq0\}\right)^*. +\end{equation} +The weight \(\ell+\Phi\) has minimal singularities. Suppose, for a +contradiction, that its Lelong number is positive at a point. In local +coordinates \(x\) centered at that point, choose \(\lambda>0\) such that +\begin{equation} + \label{met:assumed-pole} + \Phi(x)\leq\lambda\log|x|^2+O(1). +\end{equation} + +In a local frame for \(\OO(D_i)\), write \(s_i\) for its canonical +section and \(d_i=\log|s_i|^2\). Set \(b=\sum_i g_i d_i\). +The actual identification \eqref{met:adjoint-data} defines a global +volume \(\mu_b\): locally its density is \(e^{\ell-b}\), with the +coordinate volume associated with the canonical frame. Choose smooth +weights \(d_i^0\) on \(\OO(D_i)\) and set +\begin{equation} + \label{met:regularized-density} + d_{i,\varepsilon} + =\log\bigl(|s_i|^2+\varepsilon e^{d_i^0}\bigr), + \qquad + \mu_\varepsilon=e^{\ell-\sum_i g_i d_{i,\varepsilon}}, + \qquad 0<\varepsilon\leq1. +\end{equation} +These local expressions respect the line transitions. The measures +\(\mu_\varepsilon\) are smooth and positive, and their densities converge +almost everywhere to that of \(\mu_b\). The simple normal crossings +description and \(g_i<1\) give constants \(p>1\) and \(C\) such that +\begin{equation} + \label{met:density-moments} + \left\|\frac{\mu_\varepsilon}{dV}\right\|_{L^p(dV)}\leq C, + \qquad + \int_M\left(\frac{\mu_b}{dV}\right)^{-s/(1-s)}dV<\infty +\end{equation} +for some fixed \(0\frac{n}{s\lambda}. +\end{equation} + +Let \(t\downarrow0\) along a sequence, and for each \(t\) take +\(k=1,2,\ldots\). We shall choose +\[ + 0<\delta=\delta_{t,k}\leq\min(t,1/k), + \qquad + \beta=\beta_t^0+\delta\omega, + \qquad + V=\int_M\beta^n. +\] +The class of \(\beta\) is K\"ahler, although the chosen smooth +representative \(\beta\) need not be positive. After choosing +\(\delta\), choose a smooth \(\beta\)-psh function \(\psi=\psi_{t,k}\) +such that +\begin{equation} + \label{met:psi-approximation} + \begin{split} + q_t-k-1&\leq\psi\leq1,\\ + \bigl\|\psi-\max(\Phi,q_t-k)\bigr\|_{L^1(dV)} + &\leq\min(t,1/k). + \end{split} +\end{equation} +The maximum is bounded and \(\beta_t^0\)-psh. Regularization with +arbitrarily small curvature loss gives smooth approximants because +the bounded potential has no positive Lelong numbers +\cite{DemaillyRegularization}. A smooth convex regularized maximum with +\(q_t-k\), and the upper bound from Hartogs' lemma, give the stated +pointwise bounds. Finally choose +\(0<\varepsilon=\varepsilon_{t,k}\leq\min(t,1/k)\). +Additional smallness requirements on \(\delta\) and \(\varepsilon\) +will be imposed below, in this order. None of these data depends on +the parameter \(c\). + +For \(0\leq c\leq C_0\), solve +\begin{equation} + \label{met:ma-family} + T=\beta+\ddc u>0, + \qquad + \rho=\frac{T^n}{V} + =e^{(1+c)u-c\psi}\mu_\varepsilon + =e^{u+cH}\mu_\varepsilon, + \qquad H=u-\psi. +\end{equation} +Here and below \(\rho\) denotes a probability measure. The +Aubin--Yau theorem applies in the K\"ahler class +\cite{AubinMongeAmpere,YauCalabi}. More precisely, the positive +coefficient \(1+c\) is the negative-\(\lambda\) case of +\cite[Theorem 7.14]{AubinBook1998}; it gives uniqueness and an +invertible linearized operator. Thus \(u\) depends smoothly on \(c\). + +\subsection*{A capacity estimate independent of the class volume} + +We first establish estimates uniform in \(t,k,\delta,\varepsilon,c\) +whenever the displayed conditions hold. All the representatives +\(\beta\) have a common upper bound by a fixed multiple of \(\omega\). +We use the following standard uniform integrability consequence of +Skoda's theorem and semicontinuity of complex singularity exponents: +for fixed \(B\), there are \(a_B,C_B>0\) such that +\begin{equation} + \label{met:uniform-skoda} + \sup_M v=0,\quad \ddc v\geq-B\omega + \quad\Longrightarrow\quad + \int_M e^{-a_Bv}dV\leq C_B. +\end{equation} +One obtains uniformity by compactness of normalized quasi-psh +functions, local Skoda integrability at each limit, and +Demailly--Koll\'ar semicontinuity +\cite{SkodaIntegrability,DemaillyKollar}. + +Put \(E=V_\beta\), with the same envelope convention as in +\eqref{met:minimal-envelope}. For each of our K\"ahler classes, \(E\) +is bounded and \(\sup E=0\). Define the normalized capacity by +\begin{equation} + \label{met:capacity} + \operatorname{cap}_\beta(A) + =\frac1V\sup_{\substack{v\in\operatorname{PSH}(M,\beta)\\E-1\leq v\leq E}} + \int_A(\beta+\ddc v)^n. +\end{equation} +We suppress the subscript when there is no ambiguity. In particular, +\(0\leq\operatorname{cap}(A)\leq1\). + +There are constants \(a,C>0\), independent of the class volume \(V\), +such that +\begin{equation} + \label{met:exponential-capacity} + \mu_\varepsilon(A) + \leq C\exp\bigl(-a\operatorname{cap}(A)^{-1/n}\bigr) +\end{equation} +for every Borel set \(A\), with the usual value zero on the right when +the capacity is zero. Here is the normalization argument. For a +compact nonpluripolar set \(A\), let \(F_A\) be the upper regularization +of the global \(\beta\)-psh extremal with obstacle zero on \(A\), and +put \(m=\sup_M F_A\). The compact K\"ahler extremal theory gives a +bounded function, at most zero on \(A\) outside a pluripolar set, +maximal outside \(A\), with Monge--Amp\`ere mass \(V\) carried by \(A\) +\cite[Sections 5--7]{GuedjZeriahiCapacity}. + +These statements also hold for our possibly nonpositive smooth +representative. Indeed the defining family has a bounded competitor. +If its suprema were unbounded, sup-normalization, quasi-psh compactness +and a rapidly convergent weighted sum would produce a quasi-psh pole +on \(A\), contradicting nonpluripolarity. The obstacle constraint +survives upper regularization outside a pluripolar set. A +quasi-everywhere constraint gives the same envelope: mix a competitor +with arbitrarily small weight on a nonpositive \(\beta\)-psh function +having a pole on the exceptional pluripolar set, whose existence is +the global pluripolarity theorem in a K\"ahler class. Finally local +balayage off \(A\) proves maximality there. This explains why no +normalization \(E=0\) is being assumed. + +By its defining property and sup-normalization, +\[ + E\leq F_A\leq E+m. +\] +If \(b_A=\max(m,1)\), then +\[ + E+\frac{F_A-E}{b_A}-1 +\] +is admissible in \eqref{met:capacity}. Positivity of mixed products +and the mass support of \(F_A\) give +\begin{equation} + \label{met:volume-cancellation} + \operatorname{cap}(A) + \geq\frac{1}{b_A^nV}\int_A(\beta+\ddc F_A)^n + =b_A^{-n}. +\end{equation} +In particular \(b_A\geq\operatorname{cap}(A)^{-1/n}\). The volume +has canceled exactly. The function \(F_A-m\) satisfies +\eqref{met:uniform-skoda}, and is at most \(-m\) on \(A\) almost +everywhere. Hence \(dV(A)\leq C e^{-a m}\). If the capacity is less +than one, \eqref{met:volume-cancellation} implies +\(m\geq\operatorname{cap}(A)^{-1/n}\); capacity one is absorbed in the +constant. H\"older and \eqref{met:density-moments} prove +\eqref{met:exponential-capacity}. Pluripolar compact sets have zero +volume, and inner approximation proves the Borel-set assertion. + +\subsection*{Initial comparison and a uniformly small shell} + +First, +\begin{equation} + \label{met:upper-u} + \sup_M u\leq C. +\end{equation} +Otherwise normalize \(u\) by its supremum and take an almost-everywhere +convergent subsequence using quasi-psh compactness. The limits are +finite almost everywhere. The measures \(\mu_\varepsilon\) also +subconverge almost everywhere to a density positive almost everywhere, +including when \(\varepsilon\to0\). Since \(\psi\leq1\), Fatou's +lemma applied to \eqref{met:ma-family} would make its total mass tend +to infinity. This contradicts \(\int_M\rho=1\). + +Fix +\[ + \frac{C_0}{1+C_0}0\), \(\psi\leq1\), and \(E\leq0\). +The Bedford--Taylor comparison principle on this same set \(B\) +and mixed-product positivity therefore give +\begin{equation} + \label{met:first-comparison} + \tau^n\operatorname{cap}(A_{l+\tau}) + \leq C e^{-l}\mu_\varepsilon(A_l). +\end{equation} + +For completeness, write \(g(l)=\operatorname{cap}(A_l)^{1/n}\). +A fixed \(\tau>0\) in \eqref{met:first-comparison} first makes +\(g(l)\) uniformly small for large \(l\). Then +\eqref{met:exponential-capacity} gives, after enlarging a uniform +constant, +\[ + \tau g(l+\tau)\leq C_1 g(l)^2. +\] +Choose an initial \(l\) so that \(2C_1g(l)\leq1-r\), and successively +take \(\tau=2C_1g(l)\). Each step halves \(g\), and the sum of the +increments is bounded by a geometric series. Monotonicity gives +zero capacity above the limiting level. The resulting almost +everywhere inequality extends to the quasi-psh representatives. +Thus +\begin{equation} + \label{met:first-lower-bound} + u\geq r\psi+(1-r)E-C. +\end{equation} +Since \(E\geq\psi-1\), and \(\psi\) has a uniform lower \(L^1\) +bound by \eqref{met:psi-approximation}, we obtain +\begin{equation} + \label{met:H-normalization} + H\geq-C, + \qquad -C\leq\sup_M u\leq C. +\end{equation} +In particular, \(u\) and \(H\) have two-sided pointwise bounds +depending on \(t,k\), but independent of the extra smallness of +\(\delta,\varepsilon\), and independent of the permissible choice of +\(\psi\). + +In the rest of the proof, \(o(1)\) means a quantity tending to zero +as \(t\to0\), uniformly in \(k\) and \(c\), after the choices specified +below. We can choose one fixed large \(R\) for which +\begin{equation} + \label{met:small-volume-tail} + dV\{H>R-1\}=o(1). +\end{equation} +To see the uniformity, consider any sequence with \(t\to0\), allowing +both \(k\) and \(c\) to vary. A subsequence of \(u\) converges in +\(L^1\) and almost everywhere to a \(\theta\)-psh function bounded +above by \(\Phi+C\). Moreover, +\[ + \| (\Phi-\psi)_+\|_{L^1(dV)}\leq t. +\] +The asserted tail estimate follows by taking \(R>C+2\). +Absolute continuity for \(\mu_b\), the uniform \(L^p\) bound for +\(\mu_\varepsilon\), and \eqref{met:ma-family} now imply that the +shell +\begin{equation} + \label{met:shell} + \mathcal S=\{R\leq H\leq R+1\} +\end{equation} +has \(o(1)\) mass for \(\mu_b,\mu_\varepsilon,\rho\). +At \(c=0\), the whole tail \(\{H>R\}\) has \(\rho\)-mass \(o(1)\). +At a general \(c\), only the bounded-shell assertion has so far +been proved. + +\subsection*{Differentiating the Monge--Amp\`ere equation} + +Set +\[ + h=-\partial_cu, + \qquad \Delta_T=\tr_T\ddc. +\] +Differentiating both sides of \eqref{met:ma-family} gives +\begin{equation} + \label{met:differentiated-ma} + \partial_c\rho + =\bigl(H-(1+c)h\bigr)\rho + =-\Delta_T h\,\rho, + \qquad + \Delta_T h=(1+c)h-H. +\end{equation} +Also +\[ + \Delta_T H + =n-\tr_T(\beta+\ddc\psi)\leq n. +\] +At a minimum of \(h\), the last equation in +\eqref{met:differentiated-ma} and \(H\geq-C\) give \(h\geq-C\). +If \(F=(1+c)h-H\), then +\(\Delta_TF\geq(1+c)F-n\); the maximum principle gives +\begin{equation} + \label{met:h-bounds} + h\geq-C, + \qquad + (1+c)h\leq H+\frac{n}{1+c}. +\end{equation} +Consequently +\begin{equation} + \label{met:parameter-variation} + |\partial_c\rho|\leq C(1+H_+)\rho. +\end{equation} +For every fixed \(a>0\), integration by parts on the compact manifold +gives +\begin{equation} + \label{met:h-energy} + a\int_M e^{-ah}|\partial h|_T^2\rho + =\int_M e^{-ah}\Delta_T h\,\rho + \leq n\int_Me^{-ah}\rho + \leq C_a. +\end{equation} +Choose a fixed \(C_*\) so large that \(h+C_*>0\), and put +\begin{equation} + \label{met:transport-form} + G=(h+C_*)\frac{nT^{n-1}}V. + \qquad + \ddc G=-\partial_c\rho. +\end{equation} +The last identity is spatial: at a fixed value of \(c\), \(T\) is +closed, so no parameter derivative of \(T^{n-1}\) enters it. + +\subsection*{The order of the smallness choices} + +Set +\[ + M_i=\max(0,\lceil-g_i\rceil), + \quad N=\sum_i M_iD_i, + \quad d_{N,\varepsilon}=\sum_i M_i d_{i,\varepsilon}, +\] +and let \(s_N\) be the canonical section of \(N\). We impose +\begin{equation} + \label{met:exceptional-errors} + \begin{split} + \sup_M(h+C_*)\int_M + |\tr_T(\ddc d_{N,\varepsilon})|\,\rho&=o(1),\\ + \int_M\bigl(1-|s_N|_{d_{N,\varepsilon}}^2\bigr) + |\partial_c\rho|&=o(1). + \end{split} +\end{equation} +We verify that these choices respect the order already prescribed. + +For fixed \(t,k\), Equations \eqref{met:psi-approximation}, +\eqref{met:upper-u}, and \eqref{met:h-bounds} give a bound +\(B_{t,k}\) for \(\sup(h+C_*)\) before choosing \(\delta\), +\(\psi\), or \(\varepsilon\). The signed trace integral is +\begin{equation} + \label{met:signed-trace} + \int_M\tr_T(\ddc d_{N,\varepsilon})\rho + =\frac{n(2\pi)c_1(N)[\beta]^{n-1}}V. +\end{equation} +At \(\delta=0\), its numerator is zero by +\eqref{met:exceptional-degree}, and its denominator is positive for +this fixed \(t\). Choose \(\delta\), still at most \(\min(t,1/k)\), +so that \(B_{t,k}\) times the modulus of +\eqref{met:signed-trace} is at most \(t\). Now choose \(\psi\) as in +\eqref{met:psi-approximation}. + +It remains to control an absolute trace, not just its signed integral. +The regularization satisfies +\begin{equation} + \label{met:negative-curvature-tube} + \ddc d_{i,\varepsilon} + \geq-C\frac{\varepsilon} + {|s_i|^2e^{-d_i^0}+\varepsilon}\,\omega. +\end{equation} +For fixed \(t,k,\delta\), the measures +\(T^{n-1}\wedge\omega\) are controlled uniformly in +\(\varepsilon,c\) by a multiple of ordinary \(\omega\)-capacity. +Here is a direct way to make the dependence explicit. We have +\(\beta\leq A\omega\) and \(|u|\leq B\), for constants fixed at this +stage. Take \(L_0\geq\max(2A,2B,1)\), enlarging it if necessary, +and set \(v=(u-B)/L_0\). Then \(-1\leq v\leq0\), +\(\omega+\ddc v\geq\omega/2\), and +\(T\leq L_0(\omega+\ddc v)\). Thus +\[ + T^{n-1}\wedge\omega + \leq2L_0^{n-1}(\omega+\ddc v)^n. +\] +The capacity of tubes shrinking to a divisor tends to zero. The +factor on the right of \eqref{met:negative-curvature-tube} is uniformly +bounded and tends uniformly to zero outside any fixed such tube. +Consequently the negative part of the trace integral tends to zero +uniformly in \(c\) as \(\varepsilon\to0\), at this fixed +\(t,k,\delta\). The elementary inequality +\[ + \int|f|\,\rho + \leq\left|\int f\,\rho\right|+2\int f_-\,\rho +\] +then proves the first assertion of \eqref{met:exceptional-errors}, +with an error \(O(t)\), after decreasing \(\varepsilon\). + +For the second assertion, observe that +\(0\leq|s_N|_{d_{N,\varepsilon}}^2\leq1\), with convergence to one +almost everywhere. At this stage +\(|\partial_c\rho|\leq C_{t,k}\mu_\varepsilon\). +Uniform integrability from \eqref{met:density-moments} gives the +assertion, again with an error at most \(t\) after decreasing +\(\varepsilon\). We have therefore chosen \(\delta\), then +\(\psi\), then \(\varepsilon\), for every \(t,k\); all errors are +\(O(t)\), and all choices are independent of \(c\). + +\subsection*{A Bochner estimate with a residual term} + +Choose a smooth nondecreasing cutoff \(\chi\) with +\[ + \chi(H)=0\text{ for }H\leq R, + \qquad \chi(H)=1\text{ for }H\geq R+1. +\] +Choose a smooth convex function \(f\) on \(\R\) and a constant \(d\) +such that +\[ + C_0+2\leq f'\leq d-1, + \qquad f''>0\text{ on }[-R-1,-R]. +\] +Define +\begin{equation} + \label{met:transport-weight} + W_0=e^{-f(-H)-cH}. +\end{equation} +It is bounded above on \(\mathcal S\). Since \(H\geq-C\), the lower +bound for \(f'\) and \eqref{met:h-bounds} give, with fixed positive +constants, +\begin{equation} + \label{met:weight-domination} + W_0\geq C^{-1}e^{2H}, + \qquad + W_0\geq C^{-1}(1+H_+^2), + \qquad + W_0\geq C^{-1}(h+C_*), + \qquad + W_0\geq C^{-1}e^h. +\end{equation} + +On \(M^\circ=M\setminus\bigcup_iD_i\), use the following weight on +\(-K_M+N\): +\begin{equation} + \label{met:bochner-weight} + P=-\ell-u+b+\sum_iM_i d_i+f(-H). +\end{equation} +The divisor weights are pluriharmonic on this open set. Therefore +\begin{align} + \label{met:bochner-curvature} + \ddc P + &=-T+(\beta-\theta)-f'(-H)\ddc H + +f''(-H)\ii\partial H\wedge\bar\partial H\notag\\ + &\geq-dT+f''(-H)\ii\partial H\wedge\bar\partial H. +\end{align} +We used \(\beta-\theta=t p^*\omega_Z+\delta\omega\geq0\) and +\(\ddc H=T-(\beta+\ddc\psi)\leq T\). + +We claim that there is an \(N\)-valued section +\(w=s_N\chi(H)-U\) on \(M^\circ\) such that +\begin{equation} + \label{met:bochner-result} + \int_{M^\circ} + \left(|U|_{d_{N,\varepsilon}}^2 + +|\bar\partial w|_{d_{N,\varepsilon},T}^2\right) + W_0\,\rho=o(1). +\end{equation} +The residual derivative in this assertion is essential: the curvature +lower bound in \eqref{met:bochner-curvature} is not semipositive. + +Identify \(N\)-valued sections with top-degree forms valued in +\(-K_M+N\). Choose a complete K\"ahler form \(\Omega\) on +\(M^\circ\), using logarithmic cusp terms along the simple normal +crossings divisor, and use the complete metrics +\(T_\kappa=T+\kappa\Omega\), \(\kappa>0\). Let +\[ + g=\bar\partial(s_N\chi(H)) + =s_N\chi'(H)\bar\partial H. +\] +This is a closed square-integrable \((n,1)\)-form for fixed parameters. +For a \(\bar\partial\)-closed \((n,1)\)-form \(\zeta\) in the domain +of \(\bar\partial^*\), complete-metric Bochner--Kodaira and +\eqref{met:bochner-curvature} yield +\begin{equation} + \label{met:closed-test-estimate} + |\langle g,\zeta\rangle|^2 + \leq C\left(\int_{\mathcal S}e^{u-f(-H)}\mu_b\right) + \bigl(\|\bar\partial^*\zeta\|^2+d\|\zeta\|^2\bigr). +\end{equation} +For clarity, on \((n,1)\)-forms the curvature contribution of +\(-dT\) is bounded below by \(-d\|\zeta\|^2\), because +\(T\leq T_\kappa\). The positive rank-one curvature term controls +contraction with \(\bar\partial H\). Cauchy--Schwarz in that +direction gives \eqref{met:closed-test-estimate}, since +\((\chi')^2/f''(-H)\) is bounded on the shell. The squared top-form +density of \(s_N\) in the weight \(P\) is exactly +\(e^{u-f(-H)}\mu_b\). This density, and hence the estimate's +constant, is independent of the complete base metric. Approximation +on a complete K\"ahler manifold justifies the indicated weak tests; +see \cite[Sections 4--5]{DemaillyL2}. + +The integral in \eqref{met:closed-test-estimate} is \(o(1)\) by the +shell estimate. Apply the Riesz representation theorem to the +functional defined on pairs +\[ + \bigl(\bar\partial^*\zeta,\sqrt d\,\zeta\bigr) + \longmapsto\langle g,\zeta\rangle. +\] +After extending this bounded functional, and projecting its second +component to the closed subspace \(\ker\bar\partial\), we obtain +\begin{equation} + \label{met:residual-riesz} + \bar\partial U+\sqrt d\,V_1=g, + \qquad \bar\partial V_1=0, + \qquad \|U\|^2+\|V_1\|^2=o(1). +\end{equation} +Although the initial tests were closed, this is an equation against +all appropriate tests. Indeed, orthogonal projection of a test +\(\zeta\in\operatorname{Dom}\bar\partial^*\) to +\(\ker\bar\partial\) preserves its adjoint domain and adjoint value: +the range of \(\bar\partial\) from \((n,0)\)-forms is contained in +that kernel. It also preserves its pairings with the closed forms +\(g,V_1\). + +Let \(\kappa\downarrow0\). The norms of top-degree \((n,0)\)-forms +are unchanged by the base metric, while the \((n,1)\)-norms increase +to the norm for \(T\). For a countable decreasing sequence of +\(\kappa\)'s, weak compactness in each preceding norm and a diagonal +subsequence give limits satisfying \eqref{met:residual-riesz} for +\(T\). Monotone convergence of the norms preserves its bound. + +Finally, the ratio of the \(P\)-density for sections to the density +\(|\,\cdot\,|_{d_{N,\varepsilon}}^2W_0\rho\) is +\begin{equation} + \label{met:density-ratio} + \prod_i\left( + \frac{|s_i|^2+\varepsilon e^{d_i^0}}{|s_i|^2} + \right)^{g_i+M_i}\geq1. +\end{equation} +The same comparison applies to derivative norms measured with \(T\). +Since \(\bar\partial w=\sqrt d\,V_1\), this proves +\eqref{met:bochner-result}. + +For fixed parameters, its smooth positive weights imply ordinary +\(L^2\) bounds on \(w\) and its displayed derivative up to the +divisor. To extend the derivative distributionally, use simple +normal crossings cutoffs whose derivatives are \(O(\tau^{-1})\) on +tubes of volume \(O(\tau^2)\). Their derivative \(L^2\) norms are +bounded. The boundary error is bounded by this fixed bound times +the \(L^2\) norm of \(w\) on the shrinking tubes, and tends to zero +by absolute continuity. Thus \(\bar\partial w\) extends as its +distributional derivative across the divisor. Ellipticity on +sections gives +\begin{equation} + \label{met:sobolev-extension} + w\in W^{1,2}(M,N). +\end{equation} + +\subsection*{The nonholomorphic logarithm and one-sided transport} + +Write \(d_N=d_{N,\varepsilon}\) for this subsection and put +\(z=1+|w|_{d_N}^2\). For a smooth section, set +\[ + A_w=\frac{\langle\bar\partial w,w\rangle_{d_N}}z, +\] +where the Hermitian pairing is linear in the first variable. In a +holomorphic frame normal for the line metric at the point, direct +differentiation gives +\begin{equation} + \label{met:log-identity} + \begin{split} + \ddc\log z={}&\ii\partial A_w + -\ii\bar\partial\overline{A_w} + -\frac{|w|_{d_N}^2}{z}\ddc d_N\\ + &+\frac{\ii}{z^2} + \bigl(\partial w\wedge\bar\partial\bar w + -\partial\bar w\wedge\bar\partial w\bigr). + \end{split} +\end{equation} +The last line is evaluated in that normal frame, or equivalently +using the Chern derivatives. Its first summand is nonnegative; its +negative summand is controlled by \(|\bar\partial w|^2\). Thus no +estimate for the positive \(\partial w\) term is required. + +Integrate \eqref{met:log-identity} against the positive form \(G\) +in \eqref{met:transport-form}. By +\eqref{met:weight-domination} and \eqref{met:bochner-result}, the +negative-gradient contribution is at most +\[ + C\int_M(h+C_*)|\bar\partial w|_{d_N,T}^2\rho=o(1). +\] +The curvature cost is bounded by the first error in +\eqref{met:exceptional-errors}. For the two exact terms, integration +by parts differentiates only \(h\), since \(T\) is closed. Using +\(|w|/(1+|w|^2)\leq1/2\), their absolute value is at most +\begin{equation} + \label{met:log-exact-errors} + C\left( + \int_M|\bar\partial w|_{d_N,T}^2W_0\rho + \int_M|\partial h|_T^2W_0^{-1}\rho + \right)^{1/2}=o(1). +\end{equation} +The second integral is bounded by \eqref{met:h-energy} and +\(W_0^{-1}\leq C e^{-h}\). Approximation by smooth sections in +\(W^{1,2}\) justifies these calculations for +\eqref{met:sobolev-extension}: the logarithm has bounded first and +second derivatives as a function of the section, and the derivative +products converge in \(L^1\) for fixed smooth data. We conclude +\begin{equation} + \label{met:log-integral} + \int_M\ddc\log z\wedge G\geq-o(1), + \qquad + \int_M\log z\,\partial_c\rho\leq o(1). +\end{equation} +The second assertion follows from \eqref{met:transport-form} by +integration by parts. + +We can replace \(\log z\) in the last integral by +\(\log(1+\chi(H)^2)\). First the globally Lipschitz radial function +\(\xi\mapsto\log(1+|\xi|^2)\), followed by Cauchy--Schwarz, gives +\begin{align*} + &\int_M\left| + \log(1+|w|_{d_N}^2) + -\log(1+|s_N\chi(H)|_{d_N}^2)\right|\,|\partial_c\rho|\\ + &\hspace{2em}\leq + C\int_M|U|_{d_N}(1+H_+)\rho=o(1). +\end{align*} +Here \(W_0\geq C^{-1}(1+H_+^2)\) pays for the second +Cauchy--Schwarz factor. Next, +\[ + \left|\log(1+|s_N|_{d_N}^2\chi^2)-\log(1+\chi^2)\right| + \leq1-|s_N|_{d_N}^2, +\] +so the second error in \eqref{met:exceptional-errors} pays for this +replacement. + +Set +\[ + \eta(H)=\frac{\log(1+\chi(H)^2)}{\log2}. +\] +The preceding estimate, \(\partial_cH=-h\leq C\), and the shell +support of the bounded nonnegative function \(\eta'\) give +\begin{equation} + \label{met:one-sided-transport} + \partial_c\int_M\eta(H)\rho + =\int_M\eta(H)\partial_c\rho + +\int_M\eta'(H)(-h)\rho + \leq o(1). +\end{equation} +The section \(w\) need not be chosen smoothly in \(c\): its estimate +was used separately at each \(c\), whereas the left side here +depends only on the smooth family \eqref{met:ma-family}. +At \(c=0\) the integral is \(o(1)\) by the initial tail estimate. +Integrating \eqref{met:one-sided-transport} up to \(C_0\) proves, +uniformly in \(k\), +\begin{equation} + \label{met:endpoint-tail} + \int_{\{H>R+1\}}\rho=o(1) + \qquad(c=C_0). +\end{equation} + +\subsection*{Canceling the residual measure on the comparison set} + +Work now at \(c=C_0\). Take a smooth cutoff \(\xi(H)\) which is zero +for \(H\leq R+1\), one for \(H\geq R+2\), and lies between zero +and one. The smooth positive measure +\(\xi(H)\rho+t\,dV\) has mass \(a_{t,k}>0\), with +\(a_{t,k}\leq m_t\to0\) uniformly in \(k\), by +\eqref{met:endpoint-tail}. Solve the prescribed-volume equation +\cite{YauCalabi} +\[ + \frac{(\beta+\ddc v)^n}{V} + =\frac{\xi(H)\rho+t\,dV}{a_{t,k}}, + \qquad \sup_Mv=0. +\] +The complementary part of \(\rho\) has \(H\leq R+2\). Therefore +\begin{equation} + \label{met:residual-domination} + \rho\leq C_R\mu_\varepsilon + +m_t\frac{(\beta+\ddc v)^n}{V}. +\end{equation} +Choose \(r_t\to0\) with \(r_t^n\geq m_t\). We may assume +\(r_t\leq1/2\) for all the remaining \(t\)'s. + +We prove a uniform estimate +\begin{equation} + \label{met:residual-lower-bound} + u\geq r_tv+(1-r_t)E-C. +\end{equation} +Put \(v_*=r_tv+(1-r_t)E\), and for an arbitrary capacity test +\(\varphi\) and \(0<\tau\leq1-r_t\), put +\[ + v_\tau=r_tv+(1-r_t-\tau)E+\tau\varphi, + \qquad A_l=\{u0\), and let \(k\to\infty\). +Quasi-psh compactness, \eqref{met:H-normalization}, and \(\sup v=0\) +give a subsequence converging in \(L^1\) and almost everywhere to +\(\beta_t^0\)-psh functions \(u_t,v_t\). Since \(E\geq q_t\), +Equation \eqref{met:residual-lower-bound} gives +\begin{equation} + \label{met:limit-lelong-upper} + u_t\geq r_tv_t-C_t, + \qquad \nu(u_t,x)\leq r_t\nu(v_t,x)\leq C r_t. +\end{equation} +The last constant is independent of \(t\): the normalized potentials +\(v_t\) have a common lower curvature bound, so their Lelong numbers +are uniformly bounded, for example by \eqref{met:uniform-skoda}. +The additive constant \(C_t\) is allowed to depend on \(t\) and +does not affect Lelong numbers. + +At fixed \(t\), Equation \eqref{met:psi-approximation} gives +\(\psi_{t,k}\to\Phi\) in \(L^1\). Choose the subsequence also to +converge almost everywhere. Since \(\varepsilon_{t,k}\to0\), +Fatou's lemma in \eqref{met:ma-family} at \(c=C_0\) gives +\begin{equation} + \label{met:fatou-endpoint} + \int_M e^{(1+C_0)u_t-C_0\Phi}\mu_b\leq1. +\end{equation} +Writing \(f_b=\mu_b/dV\), H\"older and the second moment in +\eqref{met:density-moments} yield +\begin{align*} + \int_M e^{s(1+C_0)u_t-sC_0\Phi}dV + &\leq + \left(\int_M e^{(1+C_0)u_t-C_0\Phi}f_b\,dV\right)^s + \left(\int_M f_b^{-s/(1-s)}dV\right)^{1-s}\!<\infty. +\end{align*} +By \eqref{met:assumed-pole}, this implies near the chosen point +\begin{equation} + \label{met:weighted-integrability} + \int e^{a u_t(x)}|x|^{-2b_0}dV(x)<\infty, + \qquad a=s(1+C_0),\quad b_0=sC_0\lambda>n. +\end{equation} +Add a local smooth potential for \(\beta_t^0\) to make \(u_t\) +plurisubharmonic. Its exponential is subharmonic, and the smooth +addition changes the following estimates only by bounded factors. +For \(x\neq0\) sufficiently close to zero, the submean inequality +on \(B(x,|x|/2)\) gives +\begin{align*} + e^{a u_t(x)} + &\leq C_t|x|^{-2n} + \int_{B(x,|x|/2)} e^{a u_t(y)}dV(y)\\ + &\leq C'_t|x|^{2b_0-2n}, +\end{align*} +where the second inequality uses +\eqref{met:weighted-integrability} and \(|y|\asymp|x|\) on that +ball. Hence +\begin{equation} + \label{met:lelong-lower} + u_t(x)\leq + \frac{sC_0\lambda-n}{s(1+C_0)}\log|x|^2+O_t(1). +\end{equation} +The coefficient is positive and independent of \(t\), contradicting +\eqref{met:limit-lelong-upper} as \(t\to0\). Thus \(\Phi\) has zero +Lelong numbers everywhere. Any two metrics with minimal +singularities differ by bounded weights, so the conclusion holds +for every such metric on \(L\). +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/positive_dimension.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/positive_dimension.tex new file mode 100644 index 0000000000000000000000000000000000000000..578b1f3aef7d06092521fcb32272a653c03977b6 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/positive_dimension.tex @@ -0,0 +1,749 @@ +\section{Positive algebraic dimension} +\label{pos:section} + +\begin{proposition}\label{pos:nonvanishing} +Assume Assumptions~\ref{hyp:campana}, \ref{hyp:mmp}, and +\ref{hyp:effective-abundance}. Let \(W\) be a smooth non-uniruled +compact Kähler fourfold with \(q(W)=0\) and \(00\) be an integer such that \(kJ\) is Cartier, +and let \(L\) be a line bundle with \(L\cdot R>0\). For any +nontrivial fiber \(F\) of \(\pi\), +\begin{equation}\label{pos:index-bound} + r_F:=\sup\{u:L+uJ\text{ has nonnegative degree on all curves of }F\} + \geq\frac{1}{k(n+1)}. +\end{equation} +No local analytic \(\Q\)-factoriality is required. +In particular, this applies to the contractions in +Assumption~\ref{hyp:mmp}, with \(n=4\). +\end{lemma} + +\begin{proof} +Every curve \(C\) in \(F\) has nonzero class, since a Kähler class +has positive degree on it, and its class belongs to \(R\). Therefore +\[ + r_F=\frac{L\cdot C}{-J\cdot C}>0 +\] +is independent of \(C\). The restriction of \(L\) to the projective +fiber is numerically a positive multiple of the relatively ample +rational line \(-J\). It is thus ample on \(F\), and the openness of +fiberwise ampleness makes \(L\) relatively ample after shrinking around +the image point of \(F\). + +Work over a small Stein neighborhood of that point, with compactum +equal to the point. At \(r_F\), the restriction of \(L+r_FJ\) is +numerically trivial, hence nef but not ample on the nontrivial fiber. +Fujino's relative rationality theorem applies to this finite positive +threshold: in lowest terms its denominator is at most +\(k(\dim F+1)\) \cite[Theorem~4.3.1]{FujinoAnalyticCone}. The +non-lc-locus condition is empty for a klt pair, and the singleton +compactum satisfies the required local condition on the Stein base. +The relative numerical space over it is finite dimensional, as is also +seen by restriction to the projective fiber. The theorem consequently +gives \(r_F\geq1/(k(\dim F+1))\), which implies +\eqref{pos:index-bound}. + +The line-bundle formulation is expressly permitted by +\cite[Remark~4.3.4]{FujinoAnalyticCone}; the nearby ampleness assertion +is \cite[Lemma~2.2.4]{FujinoAnalyticCone}. Canonical divisors in that +theorem may be handled locally, in its formal canonical-class +convention. Alternatively, over the Stein neighborhood the proper +direct image of a rank-one canonical sheaf is coherent of rank one, +since the contraction is bimeromorphic. Cartan's theorem supplies a +generically nonzero section, hence a meromorphic canonical +representative there. This requires no global meromorphic canonical +frame on the compact source and no local \(\Q\)-factoriality. The +Cartier index used in the bound belongs to this stage alone. +\end{proof} + +\subsection{An actual canonical pullback} + +Put \(d=a(W)\). Resolve a map defined by \(d\) algebraically independent +meromorphic functions on \(W\). Stein factorization has a projective +base, since its finite map has projective image. Resolving that base +and the main graph, we may replace \(W\) by a smooth compact Kähler +model on which there is a fibration +\[ + b:W\longrightarrow S_0, + \qquad S_0\text{ smooth connected projective},\quad\dim S_0=d. +\] +The generic fibers remain connected through these modifications; Stein +factorization over the normal resolved base gives connected fibers +everywhere. Fix a very ample line bundle \(H\) on \(S_0\). + +Since \(K_W\) is pseudo-effective and \(4-d\leq3\), the restriction +and parameter argument in Section~\ref{red:section} gives +\(\rk b_*\OO_W(\ell K_W)>0\) for some positive integer \(\ell\). +Coherence and ample twisting on the projective base imply that +\(b_*\OO_W(\ell K_W)\otimes H^{\ell N}\) has a nonzero global +section for every sufficiently large integer \(N\). Thus there is +\(N_0\) such that +\begin{equation}\label{pos:all-large-twists} + \kappa(K_W+Nb^*H)\geq0 + \qquad\text{for every integer }N\geq N_0. +\end{equation} + +\begin{proposition}[The pullback model]\label{pos:pullback-model} +There are a canonical globally strongly \(\Q\)-factorial compact +Kähler fourfold \(V\), a normal projective variety \(T\) of dimension +\(d\), a fibration \(g:V\to T\), and an actual rational line bundle +\(A_T\in\Pic(T)\otimes\Q\), such that +\begin{equation}\label{pos:canonical-pullback} + K_V\sim_{\Q}g^*A_T. +\end{equation} +The space \(V\) is obtained from the current smooth \(W\) by a finite +empty-boundary \(K\)-program allowed by Assumption~\ref{hyp:mmp}, and +\(K_V\) remains pseudo-effective. +\end{proposition} + +\begin{proof} +At a stage \(V_i\) of the empty-boundary program that still maps to +\(S_0\), write \(b_i:V_i\to S_0\) and \(H_i=b_i^*H\). +All these stages are canonical. Indeed, a common projective resolution +of a negative canonical step gives the comparison +\begin{equation}\label{pos:canonical-step-comparison} + p^*K_{\mathrm{before}}\sim_{\Q}q^*K_{\mathrm{after}}+G, + \qquad G\geq0, +\end{equation} +with \(G\) exceptional over the after model. The comparison follows +from the projective analytic negativity lemma over the contraction +base: there is no extraction, and canonical negativity supplies the +relative sign. For flips both sides and their common resolution are +projective over that base. Compatible local canonical comparisons +glue to the intrinsic discrepancy divisor in +\eqref{pos:canonical-step-comparison}. Discrepancies therefore do not +decrease. Starting from smooth \(W\), this preserves canonicity. The +remaining category and pseudo-effectivity properties are part of +Assumption~\ref{hyp:mmp}. + +Choose a Cartier index \(k_i\) for \(K_{V_i}\), and choose an integer +\begin{equation}\label{pos:stage-choice} + N\geq N_0,\qquad N>5k_i. +\end{equation} +This choice is made anew at the current stage. The actual line +\(K_{V_i}+NH_i\) has an effective rational klt boundary representative: +take a general divisor in a sufficiently high free multiple of +\(NH_i\) and divide by that multiple. On a fixed log resolution the +system has no fixed exceptional component, and Bertini makes the +chosen member transverse to the exceptional strata; its small +coefficient preserves klt. Its adjoint is pseudo-effective because +\(K_{V_i}\) is pseudo-effective and \(H_i\) is semipositive. + +If this adjoint is not analytically nef, Assumption~\ref{hyp:mmp} +supplies an extremal ray on which \(K_{V_i}+NH_i\) is negative. +Since \(H_i\) is the pullback of a semipositive form, the ray is also +\(K_{V_i}\)-negative. Take its contraction and its negative step for +the empty-boundary program. In fact +\begin{equation}\label{pos:base-line-zero-on-ray} + H_i\cdot R_i=0. +\end{equation} +Otherwise Lemma~\ref{pos:rationality}, with \(L=H_i\) and +\(J=K_{V_i}\), gives +\[ + \frac{1}{5k_i} + \leq\frac{H_i\cdot C}{-K_{V_i}\cdot C} + <\frac1N +\] +on any curve of a nontrivial contraction fiber, contrary to +\eqref{pos:stage-choice}. + +Every connected projective fiber of the contraction maps to a point +under \(b_i\). If its image had positive dimension, some curve in that +fiber would map nontrivially to the projective base and have positive +\(H_i\)-degree. Proper descent over the normal contraction target +therefore factors \(b_i\) through it. In a flip, composition with the +positive-side morphism gives \(b_{i+1}\). Thus the actual pullback line +\(H_i\), not merely its numerical class, continues to be the pullback +of the fixed \(H\). + +Repeat this procedure as long as the selected twist is not nef. +Every step actually taken is a step of the single empty-boundary +\(K\)-program starting from \(W\). The changing integers \(N\) +select rays; they do not change that program's boundary. If the +procedure were infinite, it would contradict the arbitrary termination +assertion in Assumption~\ref{hyp:mmp}. It therefore reaches a stage +\(V_i\) at which its selected \(K_{V_i}+NH_i\) is nef. In particular, +if the canonical program reaches a nef canonical class, the selected +semipositive twist is nef there as well. + +For this final value of \(N\), \eqref{pos:all-large-twists} already +gave a section on the original \(W\). Clear the finitely many Cartier +indices of the chosen program. Since no step extracts a prime and all +maps agree to \(S_0\), that section pushes through every step as a +section of the corresponding actual twisted canonical power. +Reflexive extension across codimension two on each normal target +justifies the pushforward. Hence +\(\kappa(K_{V_i}+NH_i)\geq0\) before abundance is invoked. +Assumption~\ref{hyp:effective-abundance}, applied to the klt +representative above, makes this actual line semiample. + +Set \(V=V_i\), choose a free integral multiple +\(m(K_V+NH_i)\), and let \(h:V\to\PP^r\) be its morphism. +Take the Stein factorization \(g:V\to T\) of \((b_i,h)\). +The variety \(T\) is normal and finite over the projective image, +hence projective. Let \(a:T\to S_0\) and \(c:T\to\PP^r\) be the +induced maps. We have \(\dim T\geq d\) because \(a\) is surjective, +and \(\dim T\leq a(V)=d\) because \(T\) is projective. Define +\begin{equation}\label{pos:actual-base-line} + A_T=\frac1m c^*\OO_{\PP^r}(1)-N a^*H + \quad\text{in }\Pic(T)\otimes\Q. +\end{equation} +The defining evaluation isomorphism for \(h\) and the actual identity +\(H_i=g^*a^*H\) prove \eqref{pos:canonical-pullback}. +\end{proof} + +Choose a smooth projective resolution \(\mu:S\to T\), and resolve +the main graph to obtain a smooth compact Kähler \(M\) with +\(p:M\to V\) and a fibration \(f:M\to S\). Put \(A=\mu^*A_T\). +Canonicity and the fixed actual isomorphism in +\eqref{pos:canonical-pullback} give +\begin{equation}\label{pos:resolved-pullback} + K_M\sim_{\Q}f^*A+R, + \qquad R\geq0\text{ and }R\text{ is }p\text{-exceptional}. +\end{equation} +This is an identity of rational line bundles; all further resolutions +use its canonical transform. Pullback of holomorphic one-forms gives +\(q(S)\leq q(M)=q(W)=0\). + +The rational line \(A\) is pseudo-effective. To see this with the +analytic definition, pull a positive representative \(\Theta\) of +\(c_1(K_V)\), with local potentials, to \(M\). The map \(p\) is +dominant, so its plurisubharmonic potentials do not become identically +minus infinity. If \(\omega\) is a Kähler form on \(M\), then +\[ + f_*(p^*\Theta\wedge\omega^{4-d}) +\] +is a closed positive \((1,1)\)-current. The projection formula puts its +class in \(v\,c_1(A)\), where the degree-zero closed current +\(f_*(\omega^{4-d})=v\) is the positive constant volume of a smooth +general fiber. Division by \(v\) proves the assertion. Since \(S\) +is projective, this also gives numerical divisor pseudo-effectivity +\cite{BDPP}. + +It remains to prove \(\kappa(S,A)\geq0\). A section then pulls back +through \eqref{pos:resolved-pullback}, multiplied by the effective +exceptional section, to a canonical plurisection on \(M\), and hence +on \(W\). If \(d=1\), the smooth projective curve \(S\) has +\(q(S)=0\), so it is \(\PP^1\); a pseudo-effective rational line on +it has nonnegative degree and has a section at a divisible multiple. +The two remaining dimensions require more information from the +fibration. + +\subsection{A surface base and fiber powers} + +Assume \(d=2\). Fix a sufficiently divisible positive integer \(m_0\) +for \eqref{pos:resolved-pullback}. On very general smooth fibers one +has +\begin{equation}\label{pos:surface-fiber-rank} + h^0(F,mK_F)=1\qquad(m>0,\ m_0\mid m). +\end{equation} +At least one section is supplied by the effective divisor \(R|_F\). +If for a fixed divisible \(m\) the generic dimension were at least +two, generic base change and ample twisting of +\(f_*\OO_M(mK_M)\) would give two sections whose ratio is nonconstant +on a general fiber. Together with meromorphic functions from the +two-dimensional projective base this would give algebraic dimension +at least three, contrary to \(a(M)=2\). The analytic jumping loci +for the countably many \(m\)'s can be excluded simultaneously, proving +\eqref{pos:surface-fiber-rank}. + +\begin{lemma}[A base intersection inequality]\label{pos:surface-inequality} +There are nonnegative rational numbers \(c_P\), indexed by the +finitely many \(\mu\)-exceptional curves on \(S\), such that +\begin{equation}\label{pos:surface-intersection} + \left(A-K_S+\sum_Pc_PP\right)\cdot H'\geq0 +\end{equation} +for every ample divisor \(H'\) on \(S\). +\end{lemma} + +\begin{proof} +Choose a dense open set of \(S\) over which \(f\) is smooth and the +generator supplied by \eqref{pos:resolved-pullback} is not identically +zero on any fiber. This requires deleting a proper analytic subset: +a horizontal divisor cannot contain a whole fiber over a divisor in +the base without being vertical, by the fiber-dimension theorem; the +remaining degeneracies are proper analytic images or jumping loci. +Include all \(\mu\)-exceptional curves among the finitely many +complementary curves. + +For each such curve \(P\), fix a component \(D\) of \(f^*P\) +dominating \(P\), write +\[ + e=\ord_D(f^*P),\qquad h=\operatorname{coeff}_D R, +\] +and make these choices before choosing any ample test curve or fiber +power. If \(P\) is not exceptional over \(T\), take \(D\) with +\(h=0\). Indeed, over a general point of its image divisor in the +normal \(T\), a local equation pulls back under the holomorphic +\(g\) to a divisor on \(V\) dominating that base divisor. The strict +transform of one such component has zero coefficient in the +\(p\)-exceptional \(R\). For an exceptional \(P\), set +\begin{equation}\label{pos:exceptional-pole-allowance} + c_P=h/e. +\end{equation} + +Replace \(H'\) by a sufficiently large very ample multiple and choose +a smooth member \(C\) of genus at least one. It can be chosen +transverse to all complementary curves at their general points, +avoiding their finitely many excluded points and any isolated bad +base points. Moreover, \(M_C=f^{-1}(C)\) is smooth by Bertini for +the pulled-back free system, and connected because \(f\) has connected +fibers. To retain \eqref{pos:surface-fiber-rank}, choose \(C\) through +one parameter where all those countably many equalities hold. A high +enough linear system through that point is free away from it; on its +fiber \(f\) is a submersion, so the same Bertini conclusion holds +there. Each jumping locus then cuts a proper analytic subset of +\(C\). Thus very general fibers of \(f_C:M_C\to C\) satisfy all +the equalities in \eqref{pos:surface-fiber-rank}. + +By adjunction, +\begin{equation}\label{pos:curve-relative-canonical} + K_{M_C/C}\sim_{\Q} f_C^*((A-K_S)|_C)+R_C, + \qquad R_C=R|_{M_C}\geq0. +\end{equation} +At each \(z\in C\cap P\), a general point of the chosen component +\(D\) over \(z\) admits coordinates \((x,y_1,y_2)\) on \(M_C\) +and a parameter \(t\) on \(C\) in which +\begin{equation}\label{pos:surface-local-chart} + t=x^e,\qquad R_C=h\{x=0\} +\end{equation} +in that chart. A unit in the pullback equation is absorbed into \(x\). +Such charts exist over general points of \(P\): the map \(D\to P\) +is generically submersive, and its intersections with the other +divisorial supports have smaller generic fiber dimension. Properness +and the fiber-dimension theorem allow the exceptional base points to +be discarded before \(C\) is chosen. These choices are independent of +the next integer \(r\). + +For \(r\geq1\), take the main component of the \(r\)-fold fiber +product of \(M_C\) over \(C\), and a smooth compact Kähler resolution +\(Z_r\) of it. Over the good open set this fiber product is smooth +with connected fibers \(F^r\), hence has a unique main component. +It is an analytic subspace of a product of compact Kähler spaces; +the required Kähler resolution and connected-fiber morphism to \(C\) +follow as above. The general fiber has a canonical section by +\eqref{pos:surface-fiber-rank}, and \(\kappa(C)\geq0\). +Assumption~\ref{hyp:campana}, with zero boundary and in dimension +\(2r+1\), gives a nonzero section of \(mK_{Z_r}\) for some \(m>0\). +By taking a power, make \(m\) divisible by \(m_0\) and all indices +in use. It may depend on \(r\) and \(C\). + +Over good parameters, the product formula and +\eqref{pos:surface-fiber-rank} make the fiberwise pluriform space +one-dimensional. The chosen section is therefore the product of the +\(r\) relative generators in +\eqref{pos:curve-relative-canonical}, times a base pluriform and a +scalar base coefficient. This coefficient is a section on the good +open of the line +\begin{equation}\label{pos:fiber-power-coefficient-line} + \OO_C\bigl(m(K_C+r(A-K_S)|_C)\bigr). +\end{equation} +Indeed, its quotient by the displayed product is constant on very +general fibers; local submersion sections and analytic continuation +give meromorphic descent to that open. Evaluation at points where the +product does not vanish identically on the fiber makes the descended +coefficient holomorphic there. + +We compute its order at a missing point \(z\). In +\eqref{pos:surface-local-chart}, a frame of +\(\OO_C(m(A-K_S)|_C)\) maps, up to a unit, to +\[ + x^{mh}\left(\frac{dx\wedge dy_1\wedge dy_2}{dt}\right)^{\!m}. +\] +On a normalization branch of the local \(r\)-fold product we have +\(x_1=x\), \(x_j=\zeta_jx\), where \(\zeta_j^e=1\). Multiplying +the \(r\) relative factors by one base factor \((dt)^m\), and using +\(dt=ex^{e-1}dx\), gives order +\begin{equation}\label{pos:fiber-power-order} + m\bigl(rh-(r-1)(e-1)\bigr) +\end{equation} +along \(x=0\). This smooth normalization branch belongs to the main +component, being a closure of points with \(t\ne0\). The global +pluriform on \(Z_r\) has no pole at its generic divisor, by birational +comparison. Its scalar coefficient \(u\), pulled back by \(t=x^e\), +therefore extends meromorphically, with +\[ + e\,\ord_z(u)+m\bigl(rh-(r-1)(e-1)\bigr)\geq0. +\] +In particular, +\begin{equation}\label{pos:fiber-power-pole-bound} + \ord_z(u)\geq-\frac{mrh}{e}. +\end{equation} +There is no pole allowance at a nonexceptional base curve, where +\(h=0\). The exceptional allowances are exactly +\(mr c_P\), with the fixed \(c_P\) in +\eqref{pos:exceptional-pole-allowance}. + +The nonzero meromorphic coefficient in +\eqref{pos:fiber-power-coefficient-line}, with these pole bounds, +implies +\[ + \deg K_C+r\left(A-K_S+\sum_Pc_PP\right)\cdot C\geq0. +\] +Divide by \(r\) and let \(r\to\infty\), keeping \(C\) fixed. +Since \(C\) is a positive multiple of \(H'\), this proves +\eqref{pos:surface-intersection}. +\end{proof} + +Take the surface Zariski decomposition \cite{BHPV} +\begin{equation}\label{pos:zariski-decomposition} + A=P_0+N_0, +\end{equation} +where \(P_0\) is nef, \(N_0\geq0\) has negative-definite support +if nonzero, and \(P_0\) is orthogonal to every component of \(N_0\). +The negative-part linear equations give rational coefficients, so +\(P_0=A-N_0\) remains an actual rational line. For a +\(\mu\)-exceptional curve \(P\), \(A\cdot P=0\). If \(P\) belongs +to \(\Supp N_0\), orthogonality gives \(P_0\cdot P=0\); otherwise +both \(P_0\cdot P\) and \(N_0\cdot P\) are nonnegative, and their +sum is zero. Hence every such \(P\) is orthogonal to \(P_0\). + +If \(P_0\equiv0\), the equality \(q(S)=0\) makes a divisible +multiple of \(P_0\) torsion, so \(P_0\) is zero in +\(\Pic(S)\otimes\Q\). If \(P_0^2>0\), the nef line \(P_0\) is +big. Either case supplies sections of a positive multiple of \(A\). +In the remaining case, \(P_0\not\equiv0\) and \(P_0^2=0\). +Test \eqref{pos:surface-intersection} on ample classes approaching +\(P_0\). The exceptional terms and \(A\cdot P_0\) vanish, giving +\(K_S\cdot P_0\leq0\). For large divisible \(\ell\), +\begin{equation}\label{pos:surface-riemann-roch} + \chi(S,\ell P_0) + =\chi(\OO_S)-\frac{\ell}{2}K_S\cdot P_0>0, +\end{equation} +since \(\chi(\OO_S)=1+h^{2,0}(S)>0\). Serre duality gives +\(H^2(S,\ell P_0)=0\) for large \(\ell\): the divisor +\(K_S-\ell P_0\) has negative degree against a fixed ample divisor. +Thus \(h^0(S,\ell P_0)>0\); multiplication by the section of +\(\ell N_0\) proves \(\kappa(S,A)\geq0\). + +\subsection{A threefold base and genus-one orders} + +Assume \(d=3\). The general fibers of \(g:V\to T\) are smooth +connected genus-one curves. Indeed, the singular locus of normal +\(V\) has dimension at most two, so misses a general fiber; generic +smoothness then applies, and \eqref{pos:canonical-pullback} makes its +canonical line torsion. Also all components of \(R\) in +\eqref{pos:resolved-pullback} are vertical over \(S\): their images +on \(V\) have dimension at most two. + +Choose one integer \(m>0\), divisible by \(12\), that clears the +Cartier data and the actual isomorphism in +\eqref{pos:canonical-pullback}. It clears +\eqref{pos:resolved-pullback} on every smooth model subsequently +used. In fact, the pullback of a local frame of the Cartier line +\(\OO_V(mK_V)\), regarded on the regular locus as an +\(m\)-pluriform, has integral orders on every resolution. Those +orders are precisely \(m\operatorname{coeff}_E R\). There is thus +no need to choose a new index after a base blowup. + +\subsubsection{The actual Hodge line and its growth} + +Shrink to a dense open \(U\subset T_{\mathrm{reg}}\), also viewed +on \(S\), on which the family is smooth and agrees with its resolution. +Let \(\mathcal H\) be its line of holomorphic fiberwise one-forms. +It is a holomorphic line by Grauert base change; periods against local +integral cycles are holomorphic. Give it the Hodge norm, so that +\(\|\alpha\|^2\) is, up to a fixed convention, the fiber integral +of \(\ii\alpha\wedge\overline\alpha\). + +Evaluation \(f^*\mathcal H\to\omega_{M/U}\) is an isomorphism: +a nonzero holomorphic one-form on a smooth genus-one curve has no zero. +Its \(m\)-th power, together with the fixed actual pullback identity, +gives an isomorphism of pullbacks of lines on \(U\). Applying +\(f_*\) and \(f_*\OO_M=\OO_U\) yields the actual identification +\begin{equation}\label{pos:actual-hodge-line} + \mathcal H^{\otimes m}\simeq\mathcal L_m|_U, + \qquad\mathcal L_m=\OO_S\bigl(m(A-K_S)\bigr). +\end{equation} +It is compatible on all birational base models over their common +open. No section of the genus-one fibration is needed: its first +integral cohomology, periods, and invariant differentials are defined +without an origin. In particular, \eqref{pos:actual-hodge-line} +leaves no unspecified flat line factor. + +Let \(E_4\) and \(\Delta_{\mathrm{mod}}\) be the classical modular +forms of weights four and twelve for \(\mathrm{SL}_2(\Z)\) +\cite[Chapter~VII]{SerreArithmetic}. A local symplectic period basis +gives a parameter \(\tau\) in the upper half-plane and a normalized +Hodge frame with periods \(1,\tau\). The weight transformation laws +compensate the frame transformation, so these forms define sections +of \(\mathcal H^4\) and \(\mathcal H^{12}\). Define sections of +\(\mathcal L_m|_U\) by +\begin{equation}\label{pos:modular-sections} + e_1=E_4^{m/4},\qquad e_2=\Delta_{\mathrm{mod}}^{m/12}, +\end{equation} +where the tensor powers of the normalized frame are understood. + +Near a general point of a complementary prime divisor on any smooth +base model, let \(t=0\) be its equation. There are positive constants +\(c,C,b\), locally uniform in the remaining coordinates, such that +\begin{equation}\label{pos:modular-growth} + c\leq\bigl(\|e_1\|+\|e_2\|\bigr)^{2/m} + \leq C(1+|\log|t||)^b\qquad(t\ne0). +\end{equation} +Here is the full growth argument. In the standard fundamental domain +the normalized frame has squared norm proportional to +\(\operatorname{Im}\tau\). Both scalar modular forms are bounded +there, \(\Delta_{\mathrm{mod}}\) has no zero in the upper half-plane, +and \(E_4\to1\) at the cusp. On the compact part their joint norm has +a positive minimum; at the cusp the \(E_4\) term supplies the same +positive lower bound. This also covers the case where \(e_1\) is +identically zero on the given family. + +For the upper bound, restrict to punctured disks transverse to the +prime, with the other parameters in a small compact set and with +\(t\ne0\) inside \(U\). Lift the period map to universal covers. +Schwarz--Pick makes it distance-decreasing for the hyperbolic metrics. +The radial hyperbolic distance in a punctured disk, from a fixed +radius to \(|t|\), is +\(O(1)+O(\log|\log|t||)\). Starting period representatives at that +radius can be chosen in a bounded part of the fundamental domain, +uniformly in angle and the other parameters, by compactness inside +the smooth locus. Since \(\log\operatorname{Im}\tau\) changes by +at most hyperbolic distance, both \(\operatorname{Im}\tau\) and its +inverse are bounded by powers of \(1+|\log|t||\) along the lifted +radial paths. Returning to the fundamental domain preserves such a +bound, because for \(\gamma\in\mathrm{SL}_2(\Z)\), +\[ + \operatorname{Im}(\gamma\tau) + \leq\max\{\operatorname{Im}\tau,(\operatorname{Im}\tau)^{-1}\}. +\] +The bounded scalar modular forms and the Hodge-frame norm now prove +the upper inequality in \eqref{pos:modular-growth}. + +\subsubsection{The integration threshold and meromorphic extension} + +Fix a prime \(P\subset S\), a local parameter \(t\) at its general +point, and a frame \(s\) of \(\mathcal L_m\). On a simultaneous log +resolution of \(R\) and \(f^*P\), recompute \(R\) by the canonical +comparison in \eqref{pos:resolved-pullback}. Define +\begin{equation}\label{pos:threshold-definition} + t_P=\min_{E\mapsto P} + \frac{1+\operatorname{coeff}_E R}{\ord_E(f^*P)}. +\end{equation} +The minimum is taken over components above the general point of +\(P\). It is positive because \(R\geq0\). + +\begin{lemma}[The divisorial order identity]\label{pos:order-identity} +The sections \(e_1,e_2\) extend meromorphically to \(S\). If +\[ + \ell_P=\min_i\ord_P(e_i/s), +\] +omitting an identically zero section, then +\begin{equation}\label{pos:modular-order} + \frac{\ell_P}{m}=1-t_P. +\end{equation} +The same identity holds on every subsequent smooth base model, using +its actual line \(\OO(m(A-K_S))\) and the fixed integer \(m\). +\end{lemma} + +\begin{proof} +First identify the weighted integrability threshold of the frame: +\begin{equation}\label{pos:integrability-threshold} + t_P=\sup\left\{u\in\R: + |t|^{-2u}\|s\|^{2/m}\text{ is locally integrable near general }P + \right\}. +\end{equation} +Multiply \(s\) by a local \(m\)-canonical base frame. Under +\eqref{pos:resolved-pullback}, the resulting total-space +pluriform has divisor \(mR\). On a smooth good fiber it is the +\(m\)-th tensor of a one-form, up to a scalar, so integrating its +\(2/m\)-density along the fiber gives \(\|s\|^{2/m}\) times the +smooth base coordinate density. Fubini and change of variables +therefore identify the weighted base integral with the total-space +integral. In simple normal crossing coordinates the latter has, at +a component \(E\), a factor +\[ + |x_E|^{2(h_E-u e_E)},\qquad + h_E=\operatorname{coeff}_E R,\quad e_E=\ord_E(f^*P). +\] +Such a factor is integrable exactly when \(h_E-u e_E>-1\). +Choose the point of \(P\) generally to exclude components not +dominating it, and use properness for a finite covering of its inverse +image. The conditions are exactly those in +\eqref{pos:threshold-definition}, proving +\eqref{pos:integrability-threshold}. + +We next establish a polynomial lower bound on the Hodge norm of +\(s\), without assuming meromorphic extension of the modular +coefficients. Choose one component \(E\) above general \(P\), of +multiplicity \(e\) and coefficient \(h\) in \(R\). At a general +point of \(E\), the map has local coordinates +\[ + (t,z_1,z_2)=(x^e,z_1,z_2) +\] +on the base, with one further fiber coordinate \(y\) on the source. +The map \(E\to P\) is submersive there, units have been absorbed +into \(x\), and no other divisorial support meets the chart. The +total pluriform associated with \(s\) is a unit times +\(x^{mh}(dx\wedge dz_1\wedge dz_2\wedge dy)^m\). +After division by the base pluriform, its relative coefficient is +a unit times \(x^{m(h-e+1)}\). Integrating on a fixed smaller disk +in the \(y\)-coordinate gives +\begin{equation}\label{pos:polynomial-lower-bound} + \|s\|^{2/m}\geq c\,|t|^{2(h-e+1)/e}. +\end{equation} +These charts are available above every point of \(P\) outside a +proper analytic subset. Indeed, the non-submersive locus and +intersections with the removed supports are proper subsets of \(E\); +those that dominate \(P\) have strictly smaller generic fiber +dimension. Properness and the fiber-dimension theorem show that a +general fiber of \(E\to P\) is not exhausted by them. We also omit +the singular and intersection loci of complementary base divisors. + +On the punctured chart, write \(e_i=a_i s\). Combining +\eqref{pos:modular-growth} with +\eqref{pos:polynomial-lower-bound} gives an upper bound for +\(|a_i|\) by a fixed power of \(|t|^{-1}\), after absorbing a +logarithmic power into an arbitrarily small additional power. Thus +\(a_i\) has at most a pole across general \(P\). The integer pole +allowance can be fixed for that prime because the exponent in +\eqref{pos:polynomial-lower-bound} depends on the one fixed component +\(E\). There are finitely many complementary prime divisors. Twist +\(\mathcal L_m\) by their bounded pole allowances; both sections +are then holomorphic away from an analytic set of codimension at +least two. Hartogs extension on the smooth \(S\) gives global +meromorphic sections of the original \(\mathcal L_m\). + +At a general point of \(P\), the two meromorphic scalar coefficients +satisfy +\[ + |a_1|+|a_2|\asymp |t|^{\ell_P}. +\] +Equation~\eqref{pos:modular-growth} therefore gives +\begin{equation}\label{pos:frame-order-growth} + c|t|^{-2\ell_P/m} + \leq\|s\|^{2/m} + \leq C|t|^{-2\ell_P/m}(1+|\log|t||)^b. +\end{equation} +The supremum of the exponents \(u\) for which the weighted expression +is integrable is consequently \(1-\ell_P/m\): it is integrable for +strictly smaller \(u\), and the lower bound makes it nonintegrable +for strictly larger \(u\). Its possible behavior at the endpoint +does not change the supremum. Comparison with +\eqref{pos:integrability-threshold} proves +\eqref{pos:modular-order}. At a good divisor the identity is immediate. + +On a further smooth base modification the same argument uses its +canonical line and a simultaneous resolution of the total space. +The integer \(m\) still clears the actual identity, as explained +above. The sections agree on the common open by +\eqref{pos:actual-hodge-line}, and hence over the meromorphic field. +Thus the calculation applies with the same \(m\) on every model +needed below. +\end{proof} + +For a prime \(P\) that is not exceptional over \(T\), one also has +\begin{equation}\label{pos:nonexceptional-threshold} + t_P\leq1. +\end{equation} +Indeed, as in the surface argument, a component of the inverse image +of its image divisor on \(T\) is a divisor on \(V\) dominating it. +Its strict transform has coefficient zero in \(R\) and positive +integral pullback multiplicity. It is one of the components tested in +\eqref{pos:threshold-definition}. No such upper bound is required +for a base-exceptional prime. + +\subsubsection{A klt adjoint on the original base} + +Resolve the meromorphic pencil \([e_1:e_2]\) by projective blowups +of \(S\), and then resolve the divisorial supports, including the +exceptional locus over \(T\). A constant pencil is allowed. If +\(\rho:S'\to S\) is such a smooth modification, its actual line is +\begin{equation}\label{pos:base-canonical-transform} + \mathcal L'_m + =\rho^*\mathcal L_m\otimes\OO_{S'}(-mK_{S'/S}). +\end{equation} +Consequently both section divisors transform by their pullbacks minus +the same relative canonical Jacobian term. Resolving the pencil and +subtracting its full signed fixed divisor therefore leaves a free +moving system; subsequent blowups pull back that free system and +preserve its freeness. + +Rename this smooth model \(S\). Its fixed divisor is +\(\sum_P\ell_PP\), with simple normal crossing support. A general +complex linear combination \(e\) of \(e_1,e_2\) has +\begin{equation}\label{pos:crepant-boundary-upstairs} + \frac1m\divisor_S(e) + =\sum_P(1-t_P)P+\frac1mQ=:B_S, +\end{equation} +where \(Q\) is a general member of the free moving system, possibly +zero. Bertini makes it smooth, reduced, and transverse to all the +chosen strata, with no fixed component. Every coefficient of this +simple normal crossing divisor is strictly less than one: the fixed +coefficients are \(1-t_P<1\), and the moving coefficient is +\(1/m<1\). The fixed coefficients over exceptional primes may be +negative. + +Regard \(e\) downstairs as a rational section of the rank-one +reflexive difference \(mA_T-mK_T\), and define +\begin{equation}\label{pos:base-boundary} + \Xi=\frac1m\divisor_T(e). +\end{equation} +Equation~\eqref{pos:nonexceptional-threshold} shows that +\(\Xi\geq0\). There is an actual rational-linear identity +\begin{equation}\label{pos:base-adjoint} + K_T+\Xi\sim_{\Q}A_T. +\end{equation} +To verify both this identity and crepancy, choose over the rational +function field a frame \(a\) of \(mA_T\) and a rational canonical +form \(\omega\), and write \(e=u\,a/\omega^m\). With canonical +divisor chosen by \(\omega\), +\[ + m(K_T+\Xi)=\divisor(u)+\divisor(a). +\] +The right side is Cartier. Pull it back to \(S\) and subtract +\(m\divisor_S(\omega)\); the result is precisely +\(\divisor_S(e)\), with the canonical Jacobian term in +\eqref{pos:base-canonical-transform}. Thus +\begin{equation}\label{pos:actual-crepant-identity} + K_S+B_S=\mu^*(K_T+\Xi) +\end{equation} +for compatible rational divisor representatives. This proves that +\((T,\Xi)\) is klt: \(B_S\) is its simple normal crossing crepant +boundary with every coefficient less than one. Only the sum +\(K_T+\Xi\) has been proved \(\Q\)-Cartier; a separate +\(\Q\)-Gorenstein hypothesis on \(T\) was not used. + +Finally put \(\Gamma_S=(B_S)_+\). It is an effective rational klt +simple normal crossing boundary, and +\[ + K_S+\Gamma_S\sim_{\Q}A+E_S, + \qquad E_S\geq0\text{ and }E_S\text{ is }\mu\text{-exceptional}. +\] +The exceptionality follows from \(\Xi\geq0\): negative coefficients +of the crepant boundary occur only over \(T\)'s codimension-two +locus. This adjoint is numerically pseudo-effective on the smooth +projective threefold \(S\). Projective klt threefold nonvanishing, +in the scope recalled in Section~\ref{red:section}, gives a section +of a positive multiple of \(K_S+\Gamma_S\). Push it to \(T\). +The exceptional pole allowance disappears in codimension one, and +normality extends the section of the actual line \(mA_T\) across +codimension two, after taking a common multiple. Hence +\(\kappa(T,A_T)\geq0\), as required. + +\begin{proof}[Proof of Proposition~\ref{pos:nonvanishing}] +Proposition~\ref{pos:pullback-model} gives +\eqref{pos:resolved-pullback} with \(A\) pseudo-effective and +\(q(S)=0\). The curve, surface, and threefold arguments above each +give \(\kappa(S,A)\geq0\) in the corresponding dimension. Pull a +divisible section back to \(M\) and multiply by the section of +\(mR\) in \eqref{pos:resolved-pullback}. This gives a nonzero +canonical plurisection on \(M\), and smooth birational invariance +gives \(\kappa(W,K_W)\geq0\). +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/premises.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/premises.tex new file mode 100644 index 0000000000000000000000000000000000000000..36643e0ef3289b89f1d1e943df5184dd6fab3911 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/premises.tex @@ -0,0 +1,280 @@ +\section{Conventions and the three inputs}\label{sec:premises} + +All spaces are over \(\C\), unless a statement in the projective +appendices explicitly specifies another field of characteristic zero. +A compact K\"ahler space means a complex analytic space with a +K\"ahler form given by local smooth strictly plurisubharmonic potentials +on local embeddings. Our spaces are normal and connected, hence +irreducible. Smooth compact K\"ahler resolutions and resolutions of +meromorphic maps are obtained by projective modifications. We use the +usual resolution and K\"ahler modification theorems +\cite{HironakaResolution,VarouchasKahler}. + +\subsection{Actual adjoints and positivity} + +The canonical object on a normal space \(X\) is its reflexive canonical +sheaf \(\omega_X\). For an effective rational Weil divisor \(B\), the +notation \(D=K_X+B\) is an actual rational holomorphic line bundle +when, for some positive integer \(r\) clearing the coefficients of +\(B\), +\[ + L_r=\bigl(\omega_X^{[r]}\otimes\OO_X(rB)\bigr)^{**} +\] +is invertible. Its positive tensor powers define \(\OO_X(krD)\). +Here \(\omega_X^{[r]}=(\omega_X^{\otimes r})^{**}\), and divisorial +sheaves and their products are interpreted reflexively. An identity +\(D_1\sim_{\Q}D_2\) means an isomorphism of actual holomorphic line +bundles after a common positive integral multiple. Numerical equivalence +alone is never used to infer this identity. + +Canonical divisor calculations can be performed with compatible local +canonical divisors on a common smooth model \(p:W\to X\). We use log +discrepancies +\begin{equation}\label{eq:discrepancy} + a(E;X,B)=1+\operatorname{coeff}_E + \bigl(K_W-p^*(K_X+B)\bigr). +\end{equation} +The pair is klt if these numbers are positive for every prime divisor +over \(X\), including primes on \(X\). In particular the boundary +coefficients are less than one. We do not assume at the outset that a +positive canonical power has a nonzero meromorphic section. + +The adjoint \(D\) is \emph{analytically pseudo-effective} if +\(c_1(L_r)/r\) is represented by a closed positive \((1,1)\)-current +with local potentials. It is \emph{analytically nef} if this class is +in the closure of the K\"ahler cone in real Bott--Chern cohomology. +Equivalently, for a fixed K\"ahler form \(\omega\) and every +\(\varepsilon>0\), the line bundle has a smooth Hermitian metric +whose curvature, divided by \(r\), is bounded below by +\(-\varepsilon\omega\). On singular spaces the forms and potentials +are understood through local embeddings. Nonnegativity on compact +curves is a consequence of nefness, not its definition. + +The Iitaka dimension \(\kappa(X,D)\) is \(-\infty\) if all positive +Cartier multiples have zero sections. Otherwise it is the maximum +dimension of the images of their complete linear systems. A rational +line bundle is \emph{semiample} if some positive Cartier multiple is +globally generated. In particular, a semiample rational line of Iitaka +dimension zero is torsion as an actual rational line bundle. +We write \(a(X)\) for algebraic dimension, and +\(q(M)=h^1(M,\OO_M)\) on smooth compact K\"ahler models. + +\begin{definition}[Global strong \(\Q\)-factoriality] +\label{def:strong} +A normal compact space \(X\) is globally strongly +\(\Q\)-factorial if every coherent rank-one reflexive sheaf +\(\cF\) on the whole \(X\) has an invertible positive reflexive +power \(\cF^{[m]}=(\cF^{\otimes m})^{**}\). +\end{definition} + +Definition~\ref{def:strong} is a condition on global sheaves. It does +not assert the same condition on every analytic open subset. Smooth +spaces satisfy it. The constructions below retain this global +condition when it is required; local analytic factoriality is not +inserted as an intermediate assumption. + +\subsection{Orbifold subadditivity} + +We give the model convention in the first hypothesis because the +distinction between the invariant base and the base on an arbitrary +model is used in the proof. + +For a smooth compact space \(Z\) with an effective rational SNC +boundary \(\Gamma\) having coefficients in \([0,1]\), set +\[ + m_\Gamma(E)= + \begin{cases} + (1-\operatorname{coeff}_E\Gamma)^{-1},& + \operatorname{coeff}_E\Gamma<1,\\ + \infty,&\operatorname{coeff}_E\Gamma=1 + \end{cases} +\] +for every prime divisor \(E\). Thus the multiplicity off the boundary +is one; finite multiplicities need not be integers. If +\(g:(Z,\Gamma)\to S\) is a surjective morphism with connected +fibers and smooth base, put +\begin{equation}\label{eq:orbifold-base} + \begin{split} + m(g,\Gamma;P)&= + \min_{E:\,g(E)=P}\bigl(\ord_E(g^*P)m_\Gamma(E)\bigr),\\ + B(g,\Gamma)&=\sum_P\left(1-\frac1{m(g,\Gamma;P)}\right)P. + \end{split} +\end{equation} +Only divisors dominating \(P\) enter the minimum; the convention is +\(1/\infty=0\). The sum has finite support. This is the +inf-multiplicity convention. + +An elementary equivalence of smooth source/base fibrations is a +commuting bimeromorphic diagram +\[ +\begin{tikzcd} + (Z',\Gamma')\arrow[r,"p"]\arrow[d,"g'"']& + (Z,\Gamma)\arrow[d,"g"]\\ + S'\arrow[r,"q"]&S, +\end{tikzcd} +\] +where the maps are proper holomorphic modifications, +\(p_*\Gamma'=\Gamma\), and \(p\) is an orbifold morphism: for +every prime \(D\) on \(Z\) and every prime \(E\) on \(Z'\) with +\(t=\ord_E(p^*D)>0\), +\begin{equation}\label{eq:orbifold-morphism} + t\,m_{\Gamma'}(E)\ge m_\Gamma(D). +\end{equation} +Infinite multiplicities are compared in the usual order, with +\(\infty\ge\infty\). All boundaries in these diagrams are rational +SNC boundaries in \([0,1]\). Equivalence is generated by these +diagrams with arrows allowed in either direction, not by arbitrary +boundary changes on a fixed space. Define +\begin{equation}\label{eq:orbifold-invariant} + \kappa(g\mid\Gamma)= + \inf_{g'\sim g}\kappa\bigl(S',K_{S'}+B(g',\Gamma')\bigr). +\end{equation} +For an initially normal possibly singular base, first resolve that +base and the main fiber product. On the resulting smooth source use +the strict transform of the original boundary plus the full reduced +exceptional divisor, and resolve the total support to SNC. These +modifications are isomorphisms over very general base points. The +invariant is independent of these choices. + +A smooth-base fibration is \emph{neat} if there is a proper +bimeromorphic orbifold morphism of its source pair to a smooth pair, +with the boundary pushing forward, which contracts every source prime +mapping to codimension at least two in the given base. The hypothesis +below includes existence of suitable neat models and the formula +\begin{equation}\label{eq:neat-formula} + \kappa(g\mid\Gamma)=\kappa\bigl(S,K_S+B(g,\Gamma)\bigr) + \qquad\text{on a neat model}. +\end{equation} + +\begin{assumption}[Full orbifold Iitaka subadditivity] +\label{hyp:campana} +Let \(X\) be a smooth compact connected manifold in Fujiki class +\(\mathcal C\), let \(\Delta\) be an effective rational SNC +boundary with coefficients in \([0,1]\), and let \(f:X\to Y\) be +a surjective holomorphic map with connected fibers onto a normal +compact irreducible complex space. In arbitrary dimensions, +\begin{equation}\label{eq:campana} + \kappa(X,K_X+\Delta)\ge + \kappa(F,K_F+\Delta|_F)+\kappa(f\mid\Delta), +\end{equation} +where \(F\) is a very general smooth fiber with SNC boundary +restriction, and the invariant base is defined by +\eqref{eq:orbifold-base}--\eqref{eq:neat-formula}. +\end{assumption} + +Here very general means outside a countable union of proper closed +analytic subsets, as well as the critical values and unsuitable +boundary-stratum loci. The zero boundary is allowed, a point has +Kodaira dimension zero, and a sum with \(-\infty\) is +\(-\infty\). Neither source nor base need be projective. There is +no abundance, positivity or good-model premise in +Assumption~\ref{hyp:campana}. The displayed statement is the orbifold +subadditivity theorem of \cite[Theorem~1.1]{GrantCampana}. For later use, +on a smooth base the invariant +is at least \(\kappa(Y,K_Y)\), by effectivity of the orbifold +boundaries and smooth birational invariance. + +\subsection{The pseudo-effective fourfold program} + +The closed analytic cone \(\NA(X)\) consists of positive closed +bidimension-\((1,1)\) currents, modulo their pairings with all real +Bott--Chern \((1,1)\)-classes. We use its negative extremal rays in +the following hypothesis. + +\begin{assumption}[Pseudo-effective fourfold MMP] +\label{hyp:mmp} +Assume Assumption~\ref{hyp:campana}. Start from an ordinary klt pair +\((X,B)\), where \(X\) is a normal irreducible globally strongly +\(\Q\)-factorial compact K\"ahler fourfold, \(B\) is effective +and rational, and the actual adjoint \(D=K_X+B\) is +\(\Q\)-Cartier and analytically pseudo-effective. No initial +modification is inserted. The following program exists and +terminates. + +At every non-nef stage \((X_i,B_i)\) there is a nonzero +\(D_i\)-negative extremal ray of \(\NA(X_i)\), and every such +ray \(R\) may be chosen. It has a nef supporting class \(\alpha\) +with +\[ + \NA(X_i)\cap\alpha^\perp=R, + \qquad \alpha-c_1(D_i)\text{ K\"ahler}. +\] +For every chosen ray there is a projective surjective bimeromorphic +contraction with connected fibers +\(f_i:X_i\to Z_i\), where \(Z_i\) is normal compact K\"ahler, +\(\rho_{\BC}(X_i/Z_i)=1\), and \(-D_i\) is relatively ample. +For some K\"ahler class \(\omega_i\) on \(Z_i\), +\[ + \NA(X_i)\cap(f_i^*\omega_i)^\perp=R. +\] +A divisorial contraction gives the next pair by pushforward. For a +small contraction the canonical log-canonical-positive flip is the +relative analytic Proj of +\[ + \bigoplus_{m\ge0}(f_i)_*\OO_{X_i}(mrD_i) +\] +for a sufficiently divisible positive Cartier index \(r\). This +algebra is locally finitely generated. Its Proj is normal and its +map to \(Z_i\) is projective, small and has connected fibers. The +boundary is strictly transformed; the new actual adjoint is +relatively ample, and its divisible Cartier multiple is the +tautological line bundle. Passing to a Veronese does not change the +model. + +Each new pair is klt, compact K\"ahler and globally strongly +\(\Q\)-factorial, with \(\Q\)-Cartier analytically +pseudo-effective actual adjoint. Every nonterminal finite prefix +can be extended. Every program so obtained has finitely many steps, +irrespective of the choices of negative rays. It ends at an +analytically nef pair. The composite map extracts no prime and +satisfies the minimal-model discrepancy inequalities, weakly for +every prime over the models and strictly for every original prime +contracted. +\end{assumption} + +Assumption~\ref{hyp:mmp} follows from +\cite[Theorem~6.24; Lemma~3.2; Propositions~3.4 and~6.23]{GrantMMP} +in the intrinsic canonical-sheaf formulation and the +pseudo-effective case. Global strong \(\Q\)-factoriality supplies +the global Weil \(\Q\)-factoriality and the canonical rational +line bundle required there. The program starts on the given pair, +allows every negative extremal ray, and preserves the strong +factoriality condition. The cited ordinary-step proposition identifies +its flips with the canonical relative Proj models, and the +finite-program theorem gives termination for every choice of rays +and the stated discrepancy inequalities. +This input is independent of Assumption~\ref{hyp:campana}. +The assumption gives neither a first plurisection +nor semiampleness. It includes no non-pseudo-effective program and +no dlt or generalized-pair extension. Fiber-type contractions are +not stopping outcomes in this program. The Cartier index may change +at every stage; no positive-side relative Bott--Chern dimension or +identification of absolute Bott--Chern spaces across a flip is +assumed. Trivial flops, inserted blowups and arbitrary birational +walks are not steps of the program. These distinctions matter when +auxiliary boundaries are used below. + +\subsection{Abundance after nonvanishing} + +\begin{assumption}[Effective fourfold abundance] +\label{hyp:effective-abundance} +Let \(X\) be a normal connected compact K\"ahler fourfold and +\(\Delta\) an effective rational boundary such that +\((X,\Delta)\) is klt and the actual adjoint +\(J=K_X+\Delta\) is \(\Q\)-Cartier. If \(J\) is analytically +nef and \(\kappa(X,J)\ge0\), then a positive Cartier multiple of +\(J\) is globally generated. +\end{assumption} + +Assumption~\ref{hyp:effective-abundance} is the abundance-after-nonvanishing +theorem of \cite[Theorem~1.1]{GrantEffectiveAbundance}. It needs no strong +factoriality hypothesis and includes the actual torsion conclusion +when \(\kappa=0\). Its nonvanishing premise is explicit. No +auxiliary statement from its proof is granted separately. + +The proof uses these three inputs. Apart from them, established +literature is invoked at its stated scope. The separate projective +abundance theorem used in the Moishezon branch is proved in +Appendices~\ref{proj:sec:introduction}--\ref{proj:sec:completion}; +Lemma~\ref{red:log-iitaka} establishes its sole subadditivity premise +from Assumption~\ref{hyp:campana}. diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/reductions.tex b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/reductions.tex new file mode 100644 index 0000000000000000000000000000000000000000..0f6e28faaf14df3ddec30c35e4ceaa3e67360fec --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/build/sections/reductions.tex @@ -0,0 +1,311 @@ +\section{Reductions to canonical nonvanishing} +\label{red:section} + +We first discharge the hypothesis of the projective theorem proved in +the appendices. We then reduce the remaining problem to canonical +nonvanishing on a smooth compact Kähler fourfold of irregularity zero. +Throughout, a fibration means a surjective holomorphic map with connected +fibers. Smooth source and target spaces do not mean that the map is +everywhere a submersion. + +\subsection{The projective case} + +\begin{lemma}[The logarithmic premise]\label{red:log-iitaka} +Assumption~\ref{hyp:campana} implies the following statement. Let +\(f:M\to S\) be a fibration between smooth connected complex projective +varieties, and let \(D_M,D_S\) be reduced effective simple normal crossing +divisors, possibly zero, such that +\begin{equation}\label{red:boundary-compatibility} + \Supp(f^*D_S)\subseteq\Supp(D_M). +\end{equation} +For a very general smooth fiber \(F\), with \(D_F=D_M|_F\), one has +\begin{equation}\label{red:log-iitaka-inequality} + \kappa(M,K_M+D_M) + \geq \kappa(F,K_F+D_F)+\kappa(S,K_S+D_S). +\end{equation} +The usual convention for a \(-\infty\) summand applies. +\end{lemma} + +\begin{proof} +It suffices to prove +\begin{equation}\label{red:invariant-base-bound} + \kappa(f\mid D_M)\geq\kappa(S,K_S+D_S), +\end{equation} +because Assumption~\ref{hyp:campana} can then be applied to the original +pair \((M,D_M)\). We construct a neat model in the precise equivalence +class occurring in that assumption. + +Flatten \(f\) by a projective modification of its base and resolve that +base, obtaining \(q:S'\to S\) with \(S'\) smooth projective. The main +strict transform before resolving the source can be taken +equidimensional over \(S'\). Indeed, start with the flat strict transform +provided by flattening and then base-change to the smooth resolved +base. Flatness persists; the unchanged smooth connected generic fiber +is irreducible, and flatness rules out vertical components. The main +space consequently has pure fibers of dimension \(\dim M-\dim S\). +Resolve it and its boundary to obtain a commuting diagram +\[ +\begin{tikzcd} + M' \arrow[r,"p"] \arrow[d,"f'"'] & M \arrow[d,"f"]\\ + S' \arrow[r,"q"'] & S . +\end{tikzcd} +\] +Here \(p\) is a projective birational morphism, \(M'\) is smooth +projective, and \(f'\) has connected fibers: its general fiber is +connected, so Stein factorization over the normal base \(S'\) has trivial +finite factor. Set \(D_{M'}\) equal to the strict transform of \(D_M\) +plus the full reduced \(p\)-exceptional divisor, and arrange that its +support is simple normal crossing. + +This is an allowed orbifold modification of the source pair. It pushes +\(D_{M'}\) to \(D_M\). If a prime upstairs has positive pullback order +over a coefficient-one prime of \(D_M\), it is either that prime's +strict transform or a \(p\)-exceptional prime; in both cases its +coefficient upstairs is one. Thus the infinite-multiplicity condition +in the definition of an orbifold morphism is satisfied. + +Moreover, \(p\) witnesses neatness. Let \(E\subset M'\) be a divisor +whose image in \(S'\) has codimension \(c\geq2\). In the equidimensional +main space its image has dimension at most +\[ + (\dim S-c)+(\dim M-\dim S)=\dim M-c. +\] +Its image in \(M\) therefore has codimension at least two, so \(E\) is +\(p\)-exceptional. Subsequent resolutions preserve this argument. + +Let \(B_{f'}\) be the orbifold base divisor on \(S'\). Every component +of a pullback over a prime of +\((q^{-1}\Supp D_S)_{\mathrm{red}}\) belongs to \(D_{M'}\): this follows +from \eqref{red:boundary-compatibility} if it is not exceptional over +\(M\), and from the definition of \(D_{M'}\) otherwise. The multiplicity +assigned to each such source component is infinite. Consequently +\begin{equation}\label{red:orbifold-boundary-dominates} + B_{f'}\geq(q^{-1}\Supp D_S)_{\mathrm{red}}. +\end{equation} +There is also an effective \(q\)-exceptional divisor \(E_S\) such that +\begin{equation}\label{red:log-base-comparison} + K_{S'}+(q^{-1}\Supp D_S)_{\mathrm{red}} + =q^*(K_S+D_S)+E_S +\end{equation} +for compatible canonical divisors. Above the boundary, this is the +nonnegativity of log discrepancies of the simple normal crossing pair +\((S,D_S)\); away from the boundary, it is the nonnegativity of the +ordinary discrepancies of the smooth space \(S\). Equivalently, a +blowup of a smooth center of codimension \(c\) contained in \(s\) boundary +components contributes \(c-s\) if the center lies in the boundary, and +\(c-1\) otherwise, both nonnegative. + +The neat-model formula in Assumption~\ref{hyp:campana}, followed by +\eqref{red:orbifold-boundary-dominates} and +\eqref{red:log-base-comparison}, now gives +\[ + \kappa(f\mid D_M) + =\kappa(S',K_{S'}+B_{f'}) + \geq\kappa(S,K_S+D_S). +\] +This proves \eqref{red:invariant-base-bound}. In particular, the infimum +in the definition of the invariant has been computed on an allowed neat +model, rather than replaced by the divisor of an arbitrary base model. +\end{proof} + +\begin{corollary}[Projective abundance in the present setting] +\label{red:projective} +Under Assumption~\ref{hyp:campana}, a nef \(\Q\)-Cartier adjoint of a +normal projective log canonical pair over \(\C\), with effective rational +boundary, is semiample. +\end{corollary} + +\begin{proof} +Lemma~\ref{red:log-iitaka} is exactly the logarithmic-Iitaka hypothesis +of Theorem~\ref{proj:conditional-log-abundance}. Apply that theorem, +whose full proof is included in the appendices. +\end{proof} + +In particular, the Moishezon case of Theorem~\ref{thm:nonvanishing} is +settled. A compact Kähler Moishezon space with rational singularities is +projective by Namikawa's criterion \cite{NamikawaProjectivity}. Analytic klt +singularities are rational; this follows as well from relative vanishing +on a projective log resolution \cite{FujinoAnalyticMMP}. Thus a +Moishezon klt endpoint \((Y,\Delta)\) of +Assumption~\ref{hyp:mmp} is projective. Its rational analytic boundary +and adjoint are algebraic by Chow's theorem and GAGA, and analytic +nefness implies nonnegative degree on every curve. Corollary +\ref{red:projective} applies to its actual adjoint line. + +\subsection{Lower-dimensional inputs and restriction to fibers} + +We use smooth compact Kähler resolutions of spaces, pairs, and graphs. +The resolution and Kähler-modification theorems ensure that these can +be obtained by projective modifications and remain Kähler +\cite{HironakaResolution,VarouchasKahler}. A space in Fujiki class \(\mathcal C\) +has a smooth compact Kähler model. The quantities +\(\kappa(K_W)\), \(q(W)=h^0(W,\Omega_W^1)\), and \(a(W)\) for smooth +compact Kähler \(W\) are bimeromorphic invariants. + +We recall precisely the lower-dimensional nonvanishing facts used +below. A smooth non-uniruled compact Kähler manifold of dimension at +most three has nonnegative canonical Kodaira dimension. In +nonprojective dimension three this is +\cite[Corollary~1.4]{HPMinimalModels}. More explicitly, take a terminal +minimal model by Höring--Peternell and apply canonical nonvanishing +\cite[Theorem~0.3]{DemaillyPeternellNonvanishing} to its nef canonical +class. Terminal discrepancy comparison pulls its plurisections back +to the smooth model. +In the projective case, the klt minimal model program and log abundance +in dimensions at most three imply nonvanishing for every effective +rational klt pair with pseudo-effective adjoint \cite{ThreefoldFlipsAbundance,KeelMatsukiMcKernan,KeelMatsukiMcKernanCorrection}. +Finally, Ou's Theorem~1.1 identifies non-uniruledness of a smooth compact +Kähler manifold with analytic pseudo-effectivity of its canonical class +\cite{OuUniruledness}. These inputs have no four-dimensional nonvanishing +conclusion. + +We will repeatedly use the following elementary parameter observation. +Let \(f:Z\to S\) be a proper fibration between smooth compact complex +manifolds, and let a pseudo-effective rational adjoint on \(Z\) have a +closed positive representative with local potentials. Its restriction +to a smooth fiber is defined and positive for almost every parameter: +local plurisubharmonic potentials restrict unless they are identically +minus infinity, and Fubini excludes the latter event for almost every +parameter. This full-measure set meets the complement of any countable +union of proper analytic subsets. If the lower-dimensional results give +nonvanishing on those fibers, a fixed multiple has sections generically. +Indeed, on a connected smooth parameter open set the loci +\[ + \{s:h^0(Z_s,mL|_{Z_s})\geq1\}, +\] +for divisible positive integers \(m\), are analytic jumping loci by +proper semicontinuity. If every one were proper, their union would have +measure zero. Some such locus is therefore the whole open set. Generic +base change gives a direct image of positive rank. The same reasoning +allows all required very-general smoothness and boundary conditions to +be imposed simultaneously. + +\subsection{The uniruled and irregular cases} + +\begin{lemma}[The uniruled reduction]\label{red:uniruled} +Assume Assumption~\ref{hyp:campana}. +Let \((Y,\Delta)\) be a non-Moishezon compact Kähler klt fourfold with +effective rational boundary and pseudo-effective \(\Q\)-Cartier adjoint +\(J=K_Y+\Delta\). If a smooth compact Kähler resolution of \(Y\) is +uniruled, then \(\kappa(Y,J)\geq0\). +\end{lemma} + +\begin{proof} +Take the almost-holomorphic rational-chain quotient of a smooth +resolution \(W\) of \(Y\). Campana's rational quotient theorem in class +\(\mathcal C\) gives a quotient with base in that class and very general +fibers rationally connected after resolution +\cite[Theorem~2.6]{CampanaRationalQuotient}. Resolve the quotient and +the pair simultaneously to a fibration +\[ + f:W'\longrightarrow T,\qquad p:W'\longrightarrow Y, +\] +with \(W',T\) smooth compact Kähler. The very general fibers are +projective: rational-chain-connected manifolds in class \(\mathcal C\) +are Moishezon by Campana's algebraic connectedness criterion +\cite{CampanaAlgebraicConnectedness}, and a smooth Kähler Moishezon +manifold is projective. They are then rationally connected. + +The quotient base is not uniruled; see also \cite[Lemma~8.10]{OuUniruledness}. +For completeness, suppose otherwise and choose a covering rational +curve through a very general point of \(T\). Pull the fibration back +to its normalization \(\PP^1\) and resolve the main component, obtaining +a smooth compact Kähler space \(Z\) over \(\PP^1\) with rationally +connected very general fiber. Such a fiber has no holomorphic one- or +two-forms. A global two-form on \(Z\) restricts to zero on those fibers; +the relative differential sequence over the smooth locus then places +it in the base-one-form times relative-one-form piece. Its restriction +there is again zero, so the two-form vanishes on a dense open and hence +everywhere. Thus \(H^0(Z,\Omega_Z^2)=0\). Rational approximation of a +Kähler class, followed by Kodaira's criterion, makes \(Z\) projective. +The Graber--Harris--Starr theorem supplies a section of +\(Z\to\PP^1\) \cite{GraberHarrisStarr}. + +The chosen base point can be taken so that its original quotient fiber +is not contained in any of the countably many analytic exceptional +sets in the very-general quotient property. This follows from the +proper fiber-dimension theorem on the resolved quotient. Consequently +the rational curve is contained in none of the corresponding bad +parameter sets. Choose two distinct good parameters on it. In each +smooth projective rationally connected fiber, rational chains join a +very general point to the point of the section. The section joins +these two chains. Their projection to \(W\) is a rational chain joining +points of different very general rational-quotient fibers, where the +original almost-holomorphic quotient is defined. This contradicts the +quotient property. Hence \(T\) is not uniruled. Its dimension is +positive, since a point quotient would make \(W\) Moishezon, and is at +most three; the fiber dimension is likewise between one and three. + +On the simultaneous log resolution write +\begin{equation}\label{red:klt-resolution} + K_{W'}+\Gamma\sim_{\Q}p^*J+E, + \qquad 0\leq\Gamma<1,\quad E\geq0, +\end{equation} +where \(\Gamma\) is simple normal crossing and \(E\) is +\(p\)-exceptional. Concretely, take the nonnegative part of the crepant +log pullback boundary; its negative part becomes \(E\). +The adjoint in \eqref{red:klt-resolution} is pseudo-effective. At a +very general smooth fiber \(F\) we can impose the klt simple normal +crossing restriction and also restrict its positive current, by the +parameter observation above. Projective nonvanishing in dimension at +most three gives \(\kappa(F,K_F+\Gamma|_F)\geq0\). The non-uniruled +base similarly satisfies \(\kappa(T,K_T)\geq0\). + +For a smooth base, the invariant orbifold-base dimension is at least +its ordinary canonical Kodaira dimension: on every equivalent smooth +model the orbifold divisor is effective, and the smooth canonical +Kodaira dimension is birationally invariant. Assumption +\ref{hyp:campana} therefore gives +\(\kappa(W',K_{W'}+\Gamma)\geq0\). A resulting section pushes through +\eqref{red:klt-resolution} to a section of a positive multiple of +\(J\). The exceptional pole allowance disappears away from a +codimension-two subset of the normal target, and reflexive extension +fills that subset. +\end{proof} + +\begin{lemma}[Irregular canonical nonvanishing]\label{red:irregular} +Assume Assumption~\ref{hyp:campana}. If \(W\) is a smooth non-uniruled +compact Kähler fourfold with \(q(W)>0\), then \(\kappa(W,K_W)\geq0\). +\end{lemma} + +\begin{proof} +Resolve the Stein-factor base of the Albanese map and its main pullback. +This gives a fibration on smooth compact Kähler models, with a +positive-dimensional smooth base \(T\) mapping generically with full +rank to the Albanese torus. A suitable wedge of the invariant +one-forms on that torus pulls back to a nonzero section of \(K_T\). +The very general fiber has dimension at most three; if its dimension +is zero, it is a point. The pseudo-effective canonical class of the +total space restricts to the canonical class of almost every smooth +fiber. Lower-dimensional canonical nonvanishing and the parameter +observation supply \(\kappa(K_F)\geq0\) on very general fibers. +Assumption~\ref{hyp:campana}, with zero boundary, now gives canonical +nonvanishing on the resolved total space and hence on \(W\). +\end{proof} + +\begin{proposition}[Canonical reduction]\label{red:reduction} +Under the three assumptions of the main theorem, it is enough for +Theorem~\ref{thm:nonvanishing} to prove canonical nonvanishing for every +smooth non-uniruled non-Moishezon compact Kähler fourfold \(W\) with +\(q(W)=0\). +\end{proposition} + +\begin{proof} +Let \((Y,\Delta)\) be the nef klt endpoint in +Theorem~\ref{thm:nonvanishing}, and put \(J=K_Y+\Delta\). The +Moishezon case was settled by Corollary~\ref{red:projective}. Let +\(W\) be a smooth compact Kähler resolution in the remaining case. +If \(W\) is uniruled, Lemma~\ref{red:uniruled} applies. Otherwise +Ou's theorem makes \(K_W\) pseudo-effective. A section of a divisible +canonical power on \(W\) pushes to the corresponding reflexive +canonical power on \(Y\), and multiplication by the effective boundary +section, at a common multiple, gives a section of \(J\). Thus canonical +nonvanishing on \(W\) suffices. Lemma~\ref{red:irregular} handles +\(q(W)>0\), leaving exactly the stated case. + +Once nonvanishing on this original endpoint is established, +Assumption~\ref{hyp:effective-abundance} makes its adjoint semiample. +Its other good-minimal-model and discrepancy properties have already +been supplied by Assumption~\ref{hyp:mmp}. None of the auxiliary +models constructed later needs to replace this endpoint. +\end{proof} diff --git a/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/paper.pdf b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..64312d2a1ead94a3896367505c3a10b4a97da7f2 --- /dev/null +++ b/preprints/Conditional-good-minimal-models-for-compact-Kahler-fourfolds-October-6-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eebddaadef6935c3072a8c1eb556a002bbab27788c337bbba2f9e579bc81b6d3 +size 1075564 diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/README.md b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0dcc0a38557b75ce68ffbea61da6f08f621117d7 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/README.md @@ -0,0 +1,21 @@ +# [Deforming hypersymplectic four-manifolds to hyperkähler triples](paper.pdf) + +**Author:** OpenAI + +**Date:** October 7, 2026 + +## Citation + +```bibtex +@misc{OAI:Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026, + author = {{OpenAI}}, + title = {{Deforming hypersymplectic four-manifolds to hyperk\"ahler triples}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/paper.pdf}{OAI:Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026}}, + year = {2026} +} +``` + +## Version note + +This version clarifies the prescribed cohomology-class criterion used in the deformation argument, removes an unnecessary cone-comparison citation, and updates the companion-paper citation; see the [previous version](../Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-September-23-2026/paper.pdf). diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/figures/endpoint-path.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/figures/endpoint-path.tex new file mode 100644 index 0000000000000000000000000000000000000000..4e6b878eb1fe09c553103143a428680c9336cd4c --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/figures/endpoint-path.tex @@ -0,0 +1,33 @@ +\begin{figure}[htbp] +\centering +\begin{tikzpicture}[ + box/.style={draw=blue!45!black,rounded corners=2pt, + fill=blue!3,align=center,text width=3.35cm,minimum height=1.05cm, + inner sep=5pt,font=\small}, + aux/.style={box,draw=green!35!black,fill=green!3,text width=4.1cm}, + route/.style={-{Stealth[length=2mm]},thick,draw=blue!50!black}, + aid/.style={-{Stealth[length=2mm]},dashed,draw=green!35!black}, + lab/.style={font=\scriptsize,align=center,fill=white,inner sep=2pt} +] +\node[box] (start) at (0,0) {Prepared triple\\$A,C,B$}; +\node[box] (move) at (4.65,0) {Moving triple\\$A,C_t,B_t$}; +\node[box] (finish) at (9.3,0) {Hyperk\"ahler triple\\$A,C_1,B_1$}; +\draw[route] (start) -- node[lab,above=20pt] {$C_t\in[C]$\\$B_t\in[B]$} (move); +\draw[route] (move) -- node[lab,above=20pt] {prescribed\\endpoint} (finish); +\node[aux] (auxiliary) at (4.65,-2.25) + {Auxiliary closed form $D$\\$AD=CD=0$,\quad $D^2=A^2$}; +\draw[aid] (start.south) -- ++(0,-1.725) -- + node[lab,below] {small fiber area} (auxiliary.west); +\draw[aid] (auxiliary.north) -- node[lab,right] + {K\"ahler step for $A\pm iD$\\in $[C]$; taming criterion for $[B]$} (move.south); +\draw[aid] (auxiliary.east) -- (finish.south |- auxiliary.east) -- + node[lab,right] {using $C_1$ and\\a tamer in $[B]$:\\K\"ahler step for\\$A\pm iC_1$} (finish.south); +\end{tikzpicture} +\caption{The final deformation. Solid arrows trace the deformation; dashed +arrows indicate auxiliary dependencies. The upper row consists of +actual triples in the original classes. The auxiliary form supplies the +first integrable pair and the numerical control that keeps $[B]$ +available along the moving pair. After both K\"ahler steps, the tamers +$B_t$ are chosen with initial value $B$ and final value $B_1$.} +\label{fig:endpoint-path} +\end{figure} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/main.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..23577300c0605794421bd1ac5cc5c6f5ece55c51 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/main.tex @@ -0,0 +1,28 @@ +\documentclass[11pt]{amsart} +\input{preamble} +\title[Deforming hypersymplectic four-manifolds]{Deforming hypersymplectic four-manifolds to hyperk\"ahler triples} +\author{OpenAI} +\date{October 7, 2026} +\begin{document} +\begin{abstract} +Every smooth normalized positive triple of closed two-forms on a closed +connected oriented four-manifold admits a smooth deformation, with each +cohomology class fixed, to a hyperk\"ahler triple. +This resolves Donaldson's hypersymplectic deformation conjecture. +\end{abstract} +\maketitle +\input{sections/01-introduction} +\tableofcontents +\input{sections/02-definite-pairs} +\input{sections/03-current-energy} +\input{sections/04-density-splitting} +\input{sections/05-families} +\input{sections/06-lattice-chamber} +\input{sections/07-pencil} +\input{sections/08-local-models} +\input{sections/09-regular-preparation} +\input{sections/10-auxiliary-volume} +\input{sections/11-endpoint} +\bibliographystyle{amsplain} +\bibliography{references} +\end{document} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/preamble.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/preamble.tex new file mode 100644 index 0000000000000000000000000000000000000000..1933dace67c0d4d13c5a32fc3732e8d69b3c7e9f --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/preamble.tex @@ -0,0 +1,45 @@ +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\input{glyphtounicode-cmex.tex} +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools,mathrsfs} +\usepackage{microtype} +\usepackage{enumitem,booktabs,array,longtable,needspace} +\usepackage{graphicx,xcolor} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning,calc,fit} +\usepackage[colorlinks=true,linkcolor=blue!45!black,citecolor=green!35!black,urlcolor=blue!55!black]{hyperref} +\hypersetup{pdftitle={Deforming hypersymplectic four-manifolds to hyperkahler triples},pdfauthor={OpenAI},pdfsubject={Hypersymplectic deformation in fixed cohomology classes}} +\usepackage[capitalise,nameinlink,noabbrev]{cleveref} +\numberwithin{equation}{section} +\theoremstyle{plain} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{notation}[theorem]{Notation} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newcommand{\R}{\mathbb R} +\newcommand{\C}{\mathbb C} +\newcommand{\Z}{\mathbb Z} +\newcommand{\Q}{\mathbb Q} +\newcommand{\N}{\mathbb N} +\newcommand{\dd}{\mathrm d} +\newcommand{\eps}{\varepsilon} +\DeclareMathOperator{\Id}{Id} +\DeclareMathOperator{\dist}{dist} +\DeclareMathOperator{\supp}{supp} +\DeclareMathOperator{\spt}{spt} +\DeclareMathOperator{\vol}{vol} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\tr}{tr} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\PD}{PD} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\sgn}{sgn} +\setlist{itemsep=3pt,topsep=5pt} +\setcounter{tocdepth}{1} +\emergencystretch=1.5em diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/references.bib b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..f2d62af4653fb71d5634047d849d5944d4e82aff --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/references.bib @@ -0,0 +1,729 @@ +@incollection{Donaldson2006, + author = {Donaldson, S. K.}, + title = {Two-forms on four-manifolds and elliptic equations}, + booktitle = {Inspired by {S. S. Chern}}, + series = {Nankai Tracts in Mathematics}, + volume = {11}, + publisher = {World Scientific}, + address = {Hackensack, NJ}, + year = {2006}, + pages = {153--172}, + doi = {10.1142/9789812772688_0007}, + eprint = {math/0607083}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/math/0607083v1} +} + +@article{FineYao2017, + author = {Fine, Joel and Yao, Chengjian}, + title = {Hypersymplectic 4-manifolds, the {$G_2$}-{Laplacian} flow, + and extension assuming bounded scalar curvature}, + journal = {Duke Mathematical Journal}, + volume = {167}, + number = {18}, + year = {2018}, + pages = {3533--3589}, + doi = {10.1215/00127094-2018-0040}, + eprint = {1704.07620}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/1704.07620v2} +} + +@article{FineYao2020, + author = {Fine, Joel and Yao, Chengjian}, + title = {A report on the hypersymplectic flow}, + journal = {Pure and Applied Mathematics Quarterly}, + volume = {15}, + number = {4}, + year = {2019}, + pages = {1219--1260}, + doi = {10.4310/PAMQ.2019.v15.n4.a7}, + eprint = {2001.11755}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/2001.11755v2} +} + +@article{FineHeYao2024, + author = {Fine, Joel and He, Weiyong and Yao, Chengjian}, + title = {Convergence of the hypersymplectic flow on {$\mathbb T^4$} + with {$\mathbb T^3$}-symmetry}, + journal = {Journal of the London Mathematical Society}, + series = {2}, + volume = {111}, + number = {6}, + year = {2025}, + pages = {e70217}, + doi = {10.1112/jlms.70217}, + eprint = {2404.15016}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/2404.15016v1} +} + +@article{FineHeYao2025, + author = {Fine, Joel and He, Weiyong and Yao, Chengjian}, + title = {Hypersymplectic structures invariant under an effective + circle action}, + journal = {International Mathematics Research Notices}, + volume = {2025}, + number = {16}, + year = {2025}, + pages = {rnaf252}, + doi = {10.1093/imrn/rnaf252}, + eprint = {2503.05272}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/2503.05272v2} +} + +@misc{Petcu2026, + author = {Petcu, Amanda Maria}, + title = {The hypersymplectic flow descended from the + {$G_2$}-{Laplacian} coflow}, + year = {2026}, + eprint = {2604.18554}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/2604.18554v1}, + note = {Preprint, version 1, 20 April 2026; arXiv:2604.18554v1} +} + +@misc{YaoZhou2026, + author = {Yao, Chengjian and Zhou, Ziyi}, + title = {Closed {$G_2$}-structures with {$\mathbb T^3$}-symmetry + and hypersymplectic structures}, + year = {2026}, + eprint = {2601.13747}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/2601.13747v3}, + note = {Preprint, corrected version 3, 12 May 2026; arXiv:2601.13747v3} +} + +@article{Bauer2008, + author = {Bauer, Stefan}, + title = {Almost complex 4-manifolds with vanishing first + {Chern} class}, + journal = {Journal of Differential Geometry}, + volume = {79}, + number = {1}, + year = {2008}, + pages = {25--32}, + doi = {10.4310/jdg/1207834656}, + eprint = {math/0607714}, + archivePrefix = {arXiv}, + primaryClass = {math.GT}, + url = {https://arxiv.org/abs/math/0607714} +} + +@article{RiviereTian2009, + author = {Rivi{\`e}re, Tristan and Tian, Gang}, + title = {The singular set of 1-1 integral currents}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {169}, + number = {3}, + year = {2009}, + pages = {741--794}, + doi = {10.4007/annals.2009.169.741}, + url = {https://annals.math.princeton.edu/2009/169-3/p02} +} + +@article{Preiss1987, + author = {Preiss, David}, + title = {Geometry of measures in {$\mathbf R^n$}: + Distribution, rectifiability, and densities}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {125}, + number = {3}, + year = {1987}, + pages = {537--643}, + doi = {10.2307/1971410}, + url = {https://annals.math.princeton.edu/1987/125-3/p05} +} + +@incollection{Li2010SCY, + author = {Li, Tian-Jun}, + title = {Symplectic {Calabi--Yau} surfaces}, + booktitle = {Handbook of Geometric Analysis, No. 3}, + series = {Advanced Lectures in Mathematics}, + volume = {14}, + publisher = {International Press}, + address = {Somerville, MA}, + year = {2010}, + pages = {231--356} +} + +@article{LiLiu2001, + author = {Li, Tian-Jun and Liu, Ai-Ko}, + title = {Family {Seiberg--Witten} invariants and wall crossing + formulas}, + journal = {Communications in Analysis and Geometry}, + volume = {9}, + number = {4}, + year = {2001}, + pages = {777--823}, + doi = {10.4310/CAG.2001.v9.n4.a5}, + eprint = {math/0107211}, + archivePrefix = {arXiv}, + primaryClass = {math.GT}, + url = {https://arxiv.org/abs/math/0107211v2} +} + +@article{Taubes1994, + author = {Taubes, Clifford Henry}, + title = {The {Seiberg--Witten} invariants and symplectic forms}, + journal = {Mathematical Research Letters}, + volume = {1}, + number = {6}, + year = {1994}, + pages = {809--822}, + doi = {10.4310/MRL.1994.v1.n6.a15}, + url = {https://doi.org/10.4310/MRL.1994.v1.n6.a15} +} + +@article{Taubes1996, + author = {Taubes, Clifford Henry}, + title = {{$\mathrm{SW}\Rightarrow\mathrm{Gr}$}: From the + {Seiberg--Witten} equations to pseudo-holomorphic curves}, + journal = {Journal of the American Mathematical Society}, + volume = {9}, + number = {3}, + year = {1996}, + pages = {845--918}, + doi = {10.1090/S0894-0347-96-00211-1}, + url = {https://www.ams.org/jams/1996-9-03/S0894-0347-96-00211-1/S0894-0347-96-00211-1.pdf}, + note = {Revised reprint in the author's 2000 collected volume} +} + +@article{Taubes1999, + author = {Taubes, Clifford Henry}, + title = {{Seiberg--Witten} invariants and pseudo-holomorphic + subvarieties for self-dual, harmonic 2-forms}, + journal = {Geometry \& Topology}, + volume = {3}, + year = {1999}, + pages = {167--210}, + doi = {10.2140/gt.1999.3.167}, + eprint = {math/9907199}, + archivePrefix = {arXiv}, + primaryClass = {math.SG}, + url = {https://arxiv.org/abs/math/9907199v1} +} + +@article{GritsenkoHulekSankaran2009, + author = {Gritsenko, V. and Hulek, K. and Sankaran, G. K.}, + title = {Abelianisation of orthogonal groups and the fundamental + group of modular varieties}, + journal = {Journal of Algebra}, + volume = {322}, + number = {2}, + year = {2009}, + pages = {463--478}, + doi = {10.1016/j.jalgebra.2009.01.037}, + eprint = {0810.1614}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/0810.1614v1} +} + +@article{OhZhu2008, + author = {Oh, Yong-Geun and Zhu, Ke}, + title = {Embedding property of {$J$}-holomorphic curves in + {Calabi--Yau} manifolds for generic {$J$}}, + journal = {Asian Journal of Mathematics}, + volume = {13}, + number = {3}, + year = {2009}, + pages = {323--340}, + doi = {10.4310/AJM.2009.v13.n3.a4}, + eprint = {0805.3581}, + archivePrefix = {arXiv}, + primaryClass = {math.SG}, + url = {https://arxiv.org/abs/0805.3581v3} +} + +@article{Wendl2010, + author = {Wendl, Chris}, + title = {Automatic transversality and orbifolds of punctured + holomorphic curves in dimension four}, + journal = {Commentarii Mathematici Helvetici}, + volume = {85}, + number = {2}, + year = {2010}, + pages = {347--407}, + doi = {10.4171/CMH/199}, + eprint = {0802.3842}, + archivePrefix = {arXiv}, + primaryClass = {math.SG}, + url = {https://arxiv.org/abs/0802.3842v4} +} + +@article{GrossWilson2000, + author = {Gross, Mark and Wilson, P. M. H.}, + title = {Large complex structure limits of {K3} surfaces}, + journal = {Journal of Differential Geometry}, + volume = {55}, + number = {3}, + year = {2000}, + pages = {475--546}, + doi = {10.4310/jdg/1090341262}, + eprint = {math/0008018}, + archivePrefix = {arXiv}, + primaryClass = {math.DG}, + url = {https://arxiv.org/abs/math/0008018v3} +} + +@article{Buchdahl1999, + author = {Buchdahl, Nicholas}, + title = {On compact {K{\"a}hler} surfaces}, + journal = {Annales de l'Institut Fourier}, + volume = {49}, + number = {1}, + year = {1999}, + pages = {287--302}, + doi = {10.5802/aif.1674}, + url = {https://numdam.org/articles/10.5802/aif.1674/} +} + +@article{Lamari1999, + author = {Lamari, Ahc{\`e}ne}, + title = {Courants k{\"a}hl{\'e}riens et surfaces compactes}, + journal = {Annales de l'Institut Fourier}, + volume = {49}, + number = {1}, + year = {1999}, + pages = {263--285}, + doi = {10.5802/aif.1673}, + url = {https://numdam.org/articles/10.5802/aif.1673/} +} + +@article{DemaillyPaun2004, + author = {Demailly, Jean-Pierre and P{\u{a}}un, Mihai}, + title = {Numerical characterization of the {K{\"a}hler} cone + of a compact {K{\"a}hler} manifold}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {159}, + number = {3}, + year = {2004}, + pages = {1247--1274}, + doi = {10.4007/annals.2004.159.1247}, + url = {https://annals.math.princeton.edu/2004/159-3/p05} +} + +@article{Yau1978, + author = {Yau, Shing-Tung}, + title = {On the {Ricci} curvature of a compact {K{\"a}hler} + manifold and the complex {Monge--Amp{\`e}re} equation. {I}}, + journal = {Communications on Pure and Applied Mathematics}, + volume = {31}, + number = {3}, + year = {1978}, + pages = {339--411}, + doi = {10.1002/cpa.3160310304}, + url = {https://onlinelibrary.wiley.com/doi/10.1002/cpa.3160310304} +} + +@book{McDuffSalamon2012, + author = {McDuff, Dusa and Salamon, Dietmar}, + title = {{$J$}-holomorphic curves and symplectic topology}, + edition = {2nd}, + series = {American Mathematical Society Colloquium Publications}, + volume = {52}, + publisher = {American Mathematical Society}, + address = {Providence, RI}, + year = {2012}, + isbn = {978-0-8218-8746-2}, + url = {https://bookstore.ams.org/coll-52-r/} +} + +@book{Taubes2000, + author = {Taubes, Clifford Henry}, + title = {{Seiberg Witten} and {Gromov} Invariants for Symplectic + 4-Manifolds}, + series = {First International Press Lecture Series}, + volume = {2}, + publisher = {International Press}, + address = {Somerville, MA}, + year = {2000}, + isbn = {1-57146-061-6} +} + +@book{BerlineGetzlerVergne1992, + author = {Berline, Nicole and Getzler, Ezra and + Vergne, Mich{\`e}le}, + title = {Heat Kernels and {Dirac} Operators}, + series = {Grundlehren der mathematischen Wissenschaften}, + volume = {298}, + publisher = {Springer-Verlag}, + address = {Berlin}, + year = {1992}, + isbn = {978-3-540-53340-5}, + url = {https://sites.northwestern.edu/getzler/papers/} +} + +@book{TaylorPDEII2011, + author = {Taylor, Michael E.}, + title = {Partial Differential Equations {II}: Qualitative + Studies of Linear Equations}, + edition = {2}, + series = {Applied Mathematical Sciences}, + volume = {116}, + publisher = {Springer}, + address = {New York}, + year = {2011}, + isbn = {978-1-4419-7051-0}, + doi = {10.1007/978-1-4419-7052-7}, + url = {https://link.springer.com/book/10.1007/978-1-4419-7052-7} +} + +@article{Grauert1960, + author = {Grauert, Hans}, + title = {Ein {Theorem} der analytischen {Garbentheorie} und die + {Modulr{\"a}ume} komplexer {Strukturen}}, + journal = {Publications Math{\'e}matiques de l'IH{\'E}S}, + volume = {5}, + year = {1960}, + pages = {5--64}, + doi = {10.1007/BF02684746}, + url = {https://numdam.org/articles/10.1007/BF02684746/}, + note = {Correction in volume 16 (1963), pages 35--36, + doi:10.1007/BF02684291} +} + + +@article{Sullivan1976, + author = {Sullivan, Dennis}, + title = {Cycles for the dynamical study of foliated manifolds and complex manifolds}, + journal = {Inventiones Mathematicae}, + volume = {36}, + pages = {225--255}, + year = {1976}, + doi = {10.1007/BF01390011}, + url = {https://www.math.stonybrook.edu/~dennis/publications/PDF/DS-pub-0033.pdf} +} + +@article{HarveyLawson1983, + author = {Harvey, Reese and Lawson, Jr., H. Blaine}, + title = {An intrinsic characterization of {K\"ahler} manifolds}, + journal = {Inventiones Mathematicae}, + volume = {74}, + number = {2}, + pages = {169--198}, + year = {1983}, + doi = {10.1007/BF01394312}, + url = {https://doi.org/10.1007/BF01394312} +} + +@article{LiZhang2009, + author = {Li, Tian-Jun and Zhang, Weiyi}, + title = {Comparing tamed and compatible symplectic cones and + cohomological properties of almost complex manifolds}, + journal = {Communications in Analysis and Geometry}, + volume = {17}, + number = {4}, + pages = {651--683}, + year = {2009}, + doi = {10.4310/CAG.2009.v17.n4.a4}, + url = {https://arxiv.org/abs/0708.2520} +} + +@misc{Kinnunen2026, + author = {Kinnunen, Juha}, + title = {Real Analysis}, + year = {2026}, + howpublished = {Lecture notes, Department of Mathematics, Aalto University}, + note = {2026 lecture notes; accessed 23 September 2026. + \url{https://math.aalto.fi/~jkkinnun/files/real_analysis.pdf}}, + url = {https://math.aalto.fi/~jkkinnun/files/real_analysis.pdf} +} + +@article{HuangWangYao2018, + author = {Huang, Hongnian and Wang, Yuanqi and Yao, Chengjian}, + title = {Cohomogeneity-one {$G_2$}-{Laplacian} flow on the 7-torus}, + journal = {Journal of the London Mathematical Society}, + volume = {98}, number = {2}, year = {2018}, pages = {349--368}, + doi = {10.1112/jlms.12137}, + url = {https://arxiv.org/abs/1709.02149v2} +} + +@article{PicardSuan2024, + author = {Picard, S{\'e}bastien and Suan, Caleb}, + title = {Flows of {$G_2$}-structures associated to {Calabi--Yau} manifolds}, + journal = {Mathematical Research Letters}, + volume = {31}, number = {6}, year = {2024}, pages = {1837--1877}, + doi = {10.4310/MRL.250211003545}, + url = {https://arxiv.org/abs/2209.03411v2} +} + +@article{KarigiannisPicardSuan2026, + author = {Karigiannis, Spiro and Picard, S{\'e}bastien and Suan, Caleb}, + title = {Flows of conformally coclosed {$G_2$}-structures with dilaton}, + journal = {The Journal of Geometric Analysis}, + volume = {36}, year = {2026}, pages = {171}, + doi = {10.1007/s12220-026-02416-x}, + url = {https://arxiv.org/abs/2511.21055v2} +} + +@article{Grauert1963, + author = {Grauert, Hans}, + title = {Berichtigung: {Ein Theorem} der analytischen {Garbentheorie} und die {Modulr\"aume} komplexer {Strukturen}}, + journal = {Publications Math\'ematiques de l'IH\'ES}, + volume = {16}, + year = {1963}, + pages = {35--36}, + doi = {10.1007/BF02684291}, + url = {https://numdam.org/articles/10.1007/BF02684291/} +} + +@article{GibbonsHawking1978, + author = {Gibbons, Gary W. and Hawking, Stephen W.}, + title = {Gravitational multi-instantons}, + journal = {Physics Letters B}, + volume = {78}, + number = {4}, + year = {1978}, + pages = {430--432}, + doi = {10.1016/0370-2693(78)90478-1} +} + +@article{OoguriVafa1996, + author = {Ooguri, Hirosi and Vafa, Cumrun}, + title = {Summing up {D}-instantons}, + journal = {Physical Review Letters}, + volume = {77}, + number = {16}, + year = {1996}, + pages = {3296--3298}, + doi = {10.1103/PhysRevLett.77.3296}, + eprint = {hep-th/9608079}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/hep-th/9608079} +} + +@book{Wendl2020, + author = {Wendl, Chris}, + title = {Lectures on Contact 3-Manifolds, Holomorphic Curves and Intersection Theory}, + series = {Cambridge Tracts in Mathematics}, + volume = {220}, + publisher = {Cambridge University Press}, + year = {2020}, + doi = {10.1017/9781108608954}, + url = {https://arxiv.org/abs/1706.05540v2}, + note = {Prepublication version arXiv:1706.05540v2, August 16, 2019} +} +@misc{Wendl2014Lectures, + author = {Wendl, Chris}, + title = {Lectures on Holomorphic Curves in Symplectic and Contact Geometry}, + year = {2014}, + eprint = {1011.1690}, + archivePrefix = {arXiv}, + primaryClass = {math.SG}, + url = {https://arxiv.org/abs/1011.1690v2}, + note = {Version 3.2; arXiv:1011.1690v2} +} + +@book{MilnorStasheff1974, + author = {Milnor, John W. and Stasheff, James D.}, + title = {Characteristic Classes}, + series = {Annals of Mathematics Studies}, volume = {76}, + publisher = {Princeton University Press}, address = {Princeton, NJ}, + year = {1974}, doi = {10.1515/9781400881826}, + url = {https://doi.org/10.1515/9781400881826} +} + +@article{Rokhlin1952, + author = {Rokhlin, Vladimir A.}, + title = {New results in the theory of four-dimensional manifolds}, + journal = {Doklady Akademii Nauk SSSR}, + volume = {84}, number = {2}, year = {1952}, pages = {221--224}, + note = {Russian original; French translation in + \emph{{\`A} la recherche de la topologie perdue}, + Progress in Mathematics 62, Birkh{\"a}user, 1986, article IV, pp. 17--21} +} + +@book{Serre1973, + author = {Serre, Jean-Pierre}, title = {A Course in Arithmetic}, + series = {Graduate Texts in Mathematics}, volume = {7}, + publisher = {Springer-Verlag}, address = {New York}, year = {1973}, + doi = {10.1007/978-1-4684-9884-4}, + url = {https://doi.org/10.1007/978-1-4684-9884-4} +} + +@article{NewlanderNirenberg1957, + author = {Newlander, A. and Nirenberg, Louis}, + title = {Complex analytic coordinates in almost complex manifolds}, + journal = {Annals of Mathematics}, series = {2}, + volume = {65}, number = {3}, year = {1957}, pages = {391--404}, + doi = {10.2307/1970051}, + url = {https://doi.org/10.2307/1970051} +} + +@article{Smale1965, + author = {Smale, Stephen}, + title = {An infinite dimensional version of {Sard}'s theorem}, + journal = {American Journal of Mathematics}, + volume = {87}, number = {4}, year = {1965}, pages = {861--866}, + doi = {10.2307/2373250}, + url = {https://doi.org/10.2307/2373250} +} + +@article{Ludewig2019, + author = {Ludewig, Matthias}, + title = {Strong short-time asymptotics and convolution approximation + of the heat kernel}, + journal = {Annals of Global Analysis and Geometry}, + volume = {55}, year = {2019}, pages = {371--394}, + doi = {10.1007/s10455-018-9630-4}, + url = {https://doi.org/10.1007/s10455-018-9630-4} +} + +@article{Ludewig2018, + author = {Ludewig, Matthias}, + title = {Heat kernel asymptotics, path integrals and + infinite-dimensional determinants}, + journal = {Journal of Geometry and Physics}, + volume = {131}, year = {2018}, pages = {66--88}, + doi = {10.1016/j.geomphys.2018.04.012}, + note = {Consulted prepublication version arXiv:1607.05891v3}, + url = {https://arxiv.org/abs/1607.05891v3} +} + +@misc{TaylorHodge2010, + author = {Taylor, Michael E.}, + title = {Hypoelliptic (and non-hypoelliptic) {Hodge} theory}, + year = {2010}, note = {Author's notes, revised August 2010. + \url{https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2018/04/hodge.pdf}}, + url = {https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2018/04/hodge.pdf} +} + +@misc{TaylorFunctionalNotes, + author = {Taylor, Michael E.}, title = {Outline of functional analysis}, + howpublished = {Author's notes}, + note = {Undated; accessed 23 September 2026. + \url{https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2018/04/fctnl.pdf}}, + url = {https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2018/04/fctnl.pdf} +} + +@misc{KiselevRoquejoffreRyzhik2012, + author = {Kiselev, Alexander and Roquejoffre, Jean-Michel and Ryzhik, Lenya}, + title = {{PDEs} for a Metro Ride}, + year = {2012}, note = {Lecture notes, 30 November 2012. + \url{https://math.stanford.edu/~ryzhik/STANF272-12/lect-notes-12.pdf}}, + url = {https://math.stanford.edu/~ryzhik/STANF272-12/lect-notes-12.pdf} +} + +@misc{OpenAITaming2026, + author = {{OpenAI}}, + title = {{Taming implies compatibility on four-manifolds}}, + howpublished = {OpenAI Math Release preprint + OAI:Taming-implies-compatibility-on-four-manifolds-October-6-2026}, + year = {2026} +} + +@misc{TaylorPseudodifferentialNotes, + author = {Taylor, Michael E.}, + title = {Pseudodifferential Operators}, + howpublished = {Author's Chapter 7 notes}, + note = {Undated author-posted chapter; accessed 23 September 2026. + \url{https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2018/04/chap7.pdf}}, + url = {https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2018/04/chap7.pdf} +} + +@article{KenigPreissToro2009, + author = {Kenig, Carlos E. and Preiss, David and Toro, Tatiana}, + title = {Boundary structure and size in terms of interior and exterior + harmonic measures in higher dimensions}, + journal = {Journal of the American Mathematical Society}, + volume = {22}, number = {3}, year = {2009}, pages = {771--796}, + doi = {10.1090/S0894-0347-08-00601-2}, + url = {https://doi.org/10.1090/S0894-0347-08-00601-2} +} + +@article{Lejmi2006, + author = {Lejmi, Mehdi}, + title = {Strictly nearly {K}{\"a}hler 6-manifolds are not compatible + with symplectic forms}, + journal = {Comptes Rendus Math{\'e}matique}, + volume = {343}, + number = {11--12}, + pages = {759--762}, + year = {2006}, + doi = {10.1016/j.crma.2006.10.017}, + url = {https://arxiv.org/abs/math/0610806v3} +} + +@article{DraghiciZhang2012, + author = {Draghici, Tedi and Zhang, Weiyi}, + title = {A note on exact forms on almost complex manifolds}, + journal = {Mathematical Research Letters}, + volume = {19}, + number = {3}, + pages = {691--697}, + year = {2012}, + doi = {10.4310/MRL.2012.v19.n3.a13}, + url = {https://doi.org/10.4310/MRL.2012.v19.n3.a13} +} + +@article{McLean1998, + author = {McLean, Robert C.}, + title = {Deformations of calibrated submanifolds}, + journal = {Communications in Analysis and Geometry}, + volume = {6}, + number = {4}, + pages = {705--747}, + year = {1998}, + doi = {10.4310/CAG.1998.v6.n4.a4}, + url = {https://doi.org/10.4310/CAG.1998.v6.n4.a4} +} + +@article{ElkhadhraMimouni2007, + author = {Elkhadhra, Fredj and Mimouni, Souad Khemiri}, + title = {Sur l'existence du nombre de {Lelong} d'un courant positif + psh d{\'e}fini sur une vari{\'e}t{\'e} presque complexe}, + journal = {Comptes Rendus Math{\'e}matique}, + volume = {344}, + number = {12}, + pages = {753--758}, + year = {2007}, + doi = {10.1016/j.crma.2007.04.006}, + url = {https://www.numdam.org/item/10.1016/j.crma.2007.04.006.pdf} +} + +@misc{TaylorNonlinearEllipticNotes, + author = {Taylor, Michael E.}, + title = {Nonlinear Elliptic Equations}, + howpublished = {Author's notes}, + note = {Undated author-posted excerpt; accessed 23 September 2026. + \url{https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2020/08/nlellip.pdf}}, + url = {https://mtaylor.web.unc.edu/wp-content/uploads/sites/16915/2020/08/nlellip.pdf} +} + +@article{Boyer1988, + author = {Boyer, Charles P.}, + title = {A note on hyperhermitian four-manifolds}, + journal = {Proceedings of the American Mathematical Society}, + volume = {102}, + number = {1}, + year = {1988}, + pages = {157--164}, + doi = {10.2307/2046051}, + url = {https://doi.org/10.2307/2046051} +} + +@incollection{Kodaira1970, + author = {Kodaira, Kunihiko}, + title = {On homotopy {K3} surfaces}, + booktitle = {Essays on Topology and Related Topics}, + publisher = {Springer}, + address = {Berlin, Heidelberg}, + year = {1970}, + pages = {58--69}, + doi = {10.1007/978-3-642-49197-9_6}, + url = {https://link.springer.com/chapter/10.1007/978-3-642-49197-9_6} +} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/01-introduction.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..2fbdf27d19fe6c5b9756c24c0004a65d4baa1e8f --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/01-introduction.tex @@ -0,0 +1,335 @@ +\section{Introduction}\label{sec:introduction} + +A \emph{hypersymplectic structure} on an oriented four-manifold is a triple +of closed real two-forms whose pointwise span is three-dimensional and +positive definite for the wedge product. Such a triple determines a conformal structure, +but its forms need not be parallel. After a constant normalization of +their intersection matrix, the question is whether one can deform the +forms to a hyperk\"ahler triple while retaining their three cohomology +classes. + +\begin{theorem}\label{thm:main} +Let $X$ be a closed connected oriented smooth four-manifold, and let +$\omega=(\omega_1,\omega_2,\omega_3)$ be a smooth hypersymplectic structure +normalized by +\begin{equation}\label{eq:intro-normalization} + \int_X\omega_i\wedge\omega_j=\delta_{ij}. +\end{equation} +There is a smooth family of hypersymplectic structures $\omega(t)$, +$0\le t\le1$, such that +\[ + \omega(0)=\omega,\qquad [\omega_i(t)]=[\omega_i] + \quad (i=1,2,3), +\] +and a positive volume form $\mu_1$ with +\begin{equation}\label{eq:intro-endpoint} + \omega_i(1)\wedge\omega_j(1)=2\delta_{ij}\mu_1. +\end{equation} +The endpoint forms are parallel and self-dual for a hyperk\"ahler metric. +\end{theorem} + +For an arbitrary positive volume form $\mu$, write +$\omega_i\wedge\omega_j=2\mathcal Q_{ij}\mu$. There is a unique choice +of $\mu$ for which $\det\mathcal Q=1$, and +\eqref{eq:intro-endpoint} is exactly $\mathcal Q=I_3$ in this convention. +The statement is unaffected by a constant orthogonal change of the +ordered triple. + +The normalization also specifies the conclusion for any initial positive +closed triple. Let $G_{ij}=\int_X\omega_i\wedge\omega_j$; this matrix is +positive definite. Choose a constant invertible real matrix $L$ with +$LGL^{\mathsf T}=I_3$ and apply \Cref{thm:main} to $L\omega$. +Applying $L^{-1}$ to the resulting path preserves positivity and each +original class. Its endpoint satisfies +\[ + \omega_i(1)\wedge\omega_j(1)=2G_{ij}\mu_1, +\] +where $\mu_1$ is the volume form of the normalized endpoint metric. +Thus the original basis consists of parallel self-dual forms for a +hyperk\"ahler metric, with its original Gram matrix $G$. + +\begin{corollary}[Individual K\"ahler realizations]\label{cor:individual-kahler} +Let $X$ be a closed connected oriented smooth four-manifold with a smooth +positive triple $\omega$ of closed real two-forms. For every fixed +$c\in\mathbb R^3\setminus\{0\}$, the form $\alpha_c=\sum_i c_i\omega_i$ +is a K\"ahler form for a parallel integrable complex structure $J_c$ of +some hyperk\"ahler metric $g_c$ on $X$: +\[ + \alpha_c(v,w)=g_c(J_cv,w). +\] +The compatible structure is chosen separately for each $c$; no simultaneous +transport of the triple is asserted. +\end{corollary} +\begin{proof} +Use the fixed-class path for the original basis described above and put +$\alpha_t=\sum_i c_i\omega_i(t)$. Positivity of the pointwise wedge-product +matrix gives $\alpha_t\wedge\alpha_t>0$. Thus $\alpha_t$ is symplectic, +and its class is fixed because each $[\omega_i(t)]$ is fixed. + +For the endpoint metric $g$, set $r_c=(c^{\mathsf T}Gc)^{1/2}>0$. +The endpoint identities show that $\alpha_1/r_c$ is parallel and self-dual +with $g$-norm $\sqrt2$. It therefore defines a parallel integrable complex +structure $J^{\mathrm{end}}_c$ with +$\alpha_1/r_c=g(J^{\mathrm{end}}_c\,\cdot,\cdot)$. +Hence $\alpha_1$ is its K\"ahler form for the hyperk\"ahler metric $r_cg$. + +Since $X$ is closed, Moser's theorem gives an isotopy $\phi_{c,t}$ with +$\phi_{c,0}=\mathrm{id}$ and $\phi_{c,t}^*\alpha_t=\alpha_c$. +Pulling back $r_cg$ and $J^{\mathrm{end}}_c$ by $\phi_{c,1}$ gives the +claimed hyperk\"ahler metric and compatible integrable structure on $X$. +Fine and Yao note this Moser implication for a constituent in +\cite[Section~1]{FineYao2017}. +\end{proof} + +\begin{corollary}[Smooth type]\label{cor:smooth-type} +Let $X$ be a closed connected smooth four-manifold admitting a smooth +positive triple of closed real two-forms. Then $X$ is diffeomorphic to +the standard K3 manifold or to $T^4$. +\end{corollary} +\begin{proof} +Give $X$ the orientation induced by the triple. The normalization above +and \Cref{thm:main} give a global hyperk\"ahler triple on $X$. Choosing +one of its complex structures makes $X$ a compact K\"ahler surface with +a nowhere-vanishing holomorphic two-form. The compact hyperk\"ahler +surface classification \cite[Section~2, p.~162]{Boyer1988} therefore +identifies $X$ itself as a complex two-torus or a K3 surface. A complex +two-torus is smoothly $T^4$, while every complex K3 surface is +diffeomorphic to a nonsingular quartic surface in $\mathbf P^3$, the +standard K3 manifold \cite[p.~58]{Kodaira1970}. +\end{proof} + +\subsection{History and significance} + +Donaldson's study of closed two-forms on four-manifolds links their +pointwise wedge-product geometry to nonlinear elliptic equations +\cite{Donaldson2006}. His Question~3 in Section~5.3 asks whether a +compact oriented four-manifold carrying a positive closed triple +admits a hyperk\"ahler structure. In the same section he proposes a +prescribed-volume continuity argument in the simply connected case, +conditional on a priori estimates and an auxiliary involution. The +involution keeps the evolving form in a fixed cohomology class +\cite[Section~5.3]{Donaldson2006}. +Fine and Yao formulate the normalized +deformation problem, retaining all three cohomology classes, as +Conjecture~1.1 of \cite{FineYao2017}. +\Cref{thm:main} resolves this deformation conjecture positively. +Keeping the classes connects the given triple to a metric with its +prescribed periods, beyond existence of some hyperk\"ahler metric on +the same manifold. + +The main analytic approach has been the hypersymplectic flow. +Fine and Yao obtained this flow by reducing the $G_2$-Laplacian flow +on the product with a three-torus. They proved that a finite-time +solution extends while the associated seven-dimensional scalar +curvature, equivalently the torsion, remains bounded +\cite[Theorem~1.3]{FineYao2017}. Their later work gives an integral +torsion extension criterion, global existence near pointwise +orthogonality, and subsequential convergence of global solutions under +additional geometric bounds +\cite[Theorems~4.7, 4.10, 4.15 and~4.16]{FineYao2020}. + +Several restricted classes admit complete convergence results. +Huang, Wang and Yao proved convergence, after pullback by +diffeomorphisms, for simple-type hypersymplectic structures on +the standard four-torus, a diagonal one-variable class +\cite[Theorems~3.5 and~3.6]{HuangWangYao2018}. +Picard and Suan treated $G_2$ flows associated with K\"ahler +Calabi--Yau data; their complex-dimension-two case supplies a +hypersymplectic convergence theorem +\cite[Theorem~1.3]{PicardSuan2024}. +Fine, He and Yao extended the simple-type convergence result, modulo +diffeomorphisms, to +$T^3$-invariant triples on $T^4$ in symmetric normal form +\cite[Theorem~1.5]{FineHeYao2024}. They subsequently proved +a linear cohomologous isotopy to a hyperk\"ahler triple when an +effective smooth circle action preserves the initial triple +\cite[Theorem~1.2]{FineHeYao2025}. +Related reductions and coflow constructions appear in work of Petcu, +Yao and Zhou, and Karigiannis, Picard and Suan +\cite{Petcu2026,YaoZhou2026,KarigiannisPicardSuan2026}. +These results retain their stated symmetry or integrability hypotheses. +The path constructed here starts from an arbitrary positive closed +triple; its existence is a separate question from convergence or +uniqueness for the hypersymplectic flow. + +The topology already places strong restrictions on such a triple. +Any two of its forms determine an almost-complex structure whose +canonical line is trivial, and the third form tames that structure. +Here a real two-form $\beta$ \emph{tames} $J$ if +$\beta(v,Jv)>0$ for every nonzero vector $v$; it is +\emph{compatible} if it is also $J$-invariant. A closed tamer is +symplectic. Bauer's bound for symplectic four-manifolds with torsion +first Chern class \cite[Corollary~1.2]{Bauer2008}, together with the +three positive period classes, gives $b^+=3$, where $b^+$ is the +positive index of the intersection form. The resulting free +intersection lattice is the K3 lattice or three hyperbolic planes. +These facts supply the lattice used below; they do not presuppose a +smooth identification of the initial manifold with a K3 surface or torus. + +For controlling closed positive forms, Sullivan's structure currents +provide the cone-duality framework \cite{Sullivan1976}. +Harvey and Lawson developed the positive-current characterization of +K\"ahler geometry \cite{HarveyLawson1983}. +A separate article proves that every tamed smooth +almost-complex structure on a closed connected real four-manifold admits a compatible +symplectic form \cite[Theorem~1.1]{OpenAITaming2026}. Its current +estimates and density-splitting argument are also used here, with the +needed proofs included in \Cref{sec:current-energy,sec:density-splitting}. +In particular, smooth density-weight closedness already appears in +the proof in Section~6 of that article. Its compatible class is +unrestricted. The prescribed taming class is obtained instead from +\Cref{thm:taming-cone}, under its closed definite-pair and $b^+=3$ +hypotheses. Its proof uses the class separator and converts closed +normalized density thresholds into curves, using Preiss's +rectifiability theorem and Rivi\`ere--Tian's regularity theorem for +integral cycles \cite{Preiss1987,RiviereTian2009}. This supplies the +prescribed taming class needed along the deformation, independently of +a general comparison between the tame and compatible cones. + +\subsection{The main ideas} + +The proof organizes the deformation around a pair of forms. Write an +ordered triple as $(A,C,B)$, and write products of forms for wedge +products. The positive plane spanned by $A,C$ +determines an almost-complex structure $J$, with sign chosen so that +$B$ tames it. A pair deformation gives the desired triple deformation +provided the original third class continues to contain a tamer. +The argument first proves a criterion for this availability, then +constructs a fibration and an auxiliary equal-square pair, and finally +uses two classical K\"ahler steps to reach the endpoint. + +\paragraph{Currents and a prescribed class.} +Separation of the cone of positive forms gives a positive current +obstructing a desired closed form. Quadratic mass estimates bound its +mass in a ball of radius $r$ by $Kr^2$ for a fixed constant $K$. +Resolvent regularization also +controls how its complex-line directions vary on that scale. +Together these estimates prove closedness after weighting by smooth +functions of the two-dimensional density. The zero-density part can +then be handled by the intersection form, while normalized thresholds +of the positive-density part give integral pseudoholomorphic cycles. +Compatibility is proved before the integral-cycle regularity theorem +is applied, so that its local symplectic hypothesis is available. + +The output is \Cref{thm:tamed-compatible,thm:taming-cone}. +For the second theorem, let $V$ be the intersection-orthogonal +complement of $[A],[C]$. It has Lorentz signature because $b^+=3$. +A positive-square class $H\in V$ is a taming class if it is in the +same positive component as a known positive-square taming class $U\in V$ and +pairs positively with every irreducible closed $J$-curve. The +criterion will keep $[B]$ available as the pair changes. + +\paragraph{Marked curves and a torus fibration.} +The initial triple supplies an entire coefficient sphere of +almost-complex structures: for $v\in S^2$, the forms +$a\cdot\omega$ with $a\cdot v=0$ constitute its anti-invariant plane +(a form $\xi$ is anti-invariant when $\xi(Ju,Jw)=-\xi(u,w)$), +and $v\cdot\omega$ tames the +corresponding structure. Compatible forms can be selected smoothly +over this sphere by a constant-rank elliptic correction. After projecting +their classes to the original positive period plane and normalizing, +one obtains a degree-one map to its unit sphere. +Li proposed using such winding sphere families, parametrized wall crossing, +and Taubes's curve correspondence to construct elliptic fibrations +\cite[Section~7.4.1]{Li2010SCY}. The marked-family construction below +carries out this approach for the coefficient sphere of the initial triple. +Li--Liu's families wall-crossing and index formulas +\cite{LiLiu2001}, together with Taubes's canonical nonvanishing and +large-parameter curve extraction +\cite{Taubes1994,Taubes1996,Taubes1999}, then give curves through every +point in a chosen nonzero integral square-zero class. +To impose passage through a chosen point, the proof requires one +component of the Seiberg--Witten spinor to vanish there. As the parameter moves +over the sphere, the line containing that component also varies and +has degree of absolute value one. Its contribution must be retained +in the marked wall-crossing calculation, even though the underlying +Spin-c structure is fixed throughout the family. + +The integral class is chosen to prevent any such curve configuration +from splitting. Eichler's criterion supplies the lattice normal form +\cite[Proposition~3.3(i)]{GritsenkoHulekSankaran2009}; a further +finite-coset argument works for the arbitrary real positive period +plane of the original triple. Pseudoholomorphic adjunction and +positivity of intersections then reduce the possible fibers to tori +and rational curves with one singularity +\cite{McDuffSalamon2012,Wendl2020}. +To obtain ordinary nodes, we prove transversality using exact +perturbations of $A,C$ with $B$ fixed. The first-jet method is related +to that of Oh and Zhu \cite{OhZhu2008}, but the allowable closed-form +variations require their own cokernel calculation. Relative nodal +replacement and local deformation theory now produce the fibration +of \Cref{thm:pencil}: a proper map from $X$ to a closed oriented +surface, with torus regular fibers and rational singular fibers having +one ordinary node. + +\paragraph{An auxiliary volume equation.} +The fibration supplies classes with small positive fiber area. +Near a nodal fiber we use the Gibbons--Hawking construction +\cite{GibbonsHawking1978} and the periodic Ooguri--Vafa model +\cite{OoguriVafa1996}. Gross and Wilson developed the corresponding +mathematical collapsing and semi-flat gluing methods for elliptic +K3 surfaces \cite{GrossWilson2000}. Here the nodal holomorphic model +is constructed independently, since a global complex structure is +not yet available. On fixed annuli the model and regular data agree +up to exponentially small error. Matching the fiber area and the +period on the surface swept out by the monodromy-invariant fiber +cycle ensures that the discrepancy has a primitive. + +After exact preparation of the pair, these local forms glue to an +approximate auxiliary form of fiber area $\epsilon$. +The correction in \Cref{thm:auxiliary-solution} is solved on exact +two-forms. For any Riemannian metric on the oriented closed four-manifold, let +$h^+$ denote the self-dual part of an exact two-form $h$. The exact-form +identity used in Donaldson's elliptic formulation +\cite[Section~2, proof of Proposition~1; Section~4, Lemma~1]{Donaldson2006} +\[ + \|h\|_{L^2}^2=2\|h^+\|_{L^2}^2\qquad(h\text{ exact}) +\] +controls the inverse while the fibers collapse. The remaining finite +Sobolev estimates lose only powers of $\epsilon^{-1}$, which are +absorbed by the exponentially small gluing error. This produces a +closed form $D$ satisfying $AD=CD=0$ and $D^2=A^2$. +The class inequality in \Cref{prop:auxiliary-class} holds for all +later curves at one fixed choice of $\epsilon$; it transfers +positivity from $[D]$ to the original class $[B]$. + +\paragraph{Two K\"ahler steps in the original classes.} +The closed equal-square pair $A,D$ defines an integrable complex +structure with holomorphic two-form $A\pm iD$, choosing the sign +so that $C$ tames it. The compact-surface +criteria of Buchdahl and Lamari, and the numerical K\"ahler-cone +criterion, put $[C]$ in the K\"ahler cone +\cite{Buchdahl1999,Lamari1999,DemaillyPaun2004}. +Yau's volume theorem \cite{Yau1978} gives $C_1\in[C]$ with +$C_1^2=A^2$. Interpolate from $C$ to $C_1$; the uniform class +inequality and the taming criterion keep $[B]$ available throughout. +The pair $A,C_1$ is now itself an integrable equal-square pair. +A second K\"ahler step in $[B]$ gives $B_1$, completing the +hyperk\"ahler triple. Smooth selection of the third forms, with both +endpoints prescribed, gives the actual path $(A,C_t,B_t)$ shown in +\Cref{fig:endpoint-path}. Every component retains its original class. + +\subsection{Organization and conventions} + +\Cref{sec:definite-pairs} establishes the preliminary geometry and +topology. The positive-current results occupy +\Cref{sec:current-energy,sec:density-splitting}. +\Cref{sec:families,sec:lattice-chamber,sec:pencil} construct the +torus fibration, and +\Cref{sec:local-models,sec:regular-preparation,sec:auxiliary-volume} +construct the auxiliary equal-square pair. The proof of +\Cref{thm:main} is completed in \Cref{sec:endpoint}. + +We write products of two-forms for wedge products and products of +degree-two cohomology classes for their intersection pairing. +Curve classes are identified with their Poincar\'e duals in cohomology. +Integral lattice statements use +\[ + \Lambda=H^2(X;\Z)/\operatorname{torsion}. +\] +The original positive period plane is +$P=\operatorname{span}\{[\omega_1],[\omega_2],[\omega_3]\}$. +No rationality of this plane is assumed. All deformations of forms are +smooth in the manifold variable; parameter regularity is stated where +it is used. Constants in local estimates may depend on fixed smooth +background data and on the indicated finite differentiation order. diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/02-definite-pairs.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/02-definite-pairs.tex new file mode 100644 index 0000000000000000000000000000000000000000..6a695b49b05dcddd1e911aeabc19a6465001df08 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/02-definite-pairs.tex @@ -0,0 +1,204 @@ +\section{Definite pairs and the coefficient sphere}\label{sec:definite-pairs} + +We first associate an almost-complex structure to a definite pair and +identify the condition on a third form that makes the triple positive. +This converts the later deformation problem into the choice of taming +forms in a prescribed class. We also establish the topological +restrictions and the degree-one sphere of structures needed to produce +curves in \Cref{sec:families}. + +\begin{definition} +A pair $(A,C)$ of real two-forms is \emph{definite} if its wedge-product +matrix is positive definite at every point. A two-form $B$ \emph{tames} +an almost-complex structure $J$ if $B(v,Jv)>0$ for every nonzero tangent +vector $v$. It is \emph{compatible} if, in addition, +$B(Ju,Jv)=B(u,v)$. When these forms are called symplectic, closedness is +included. +\end{definition} + +\begin{lemma}\label{lem:definite-pair} +A definite pair $(A,C)$ on an oriented four-manifold determines an +almost-complex structure up to sign. Its anti-invariant real two-form +bundle is pointwise spanned by $A,C$, and its canonical complex line +bundle is trivial. A third form $B$ completes a positive triple if and +only if it tames one of the two signs of this almost-complex structure. +On a connected manifold the sign is fixed by $B$. + +A real two-plane is Lagrangian for both $A$ and $C$ if and only if it is +a complex line, without specifying its orientation. +\end{lemma} + +\begin{proof} +Ratios of positive four-forms are smooth functions. Set +\begin{equation}\label{eq:pair-normalization} + x=\frac{AC}{A^2},\qquad + y=\left(\frac{C^2}{A^2}-x^2\right)^{1/2}>0,\qquad + T=\frac{C-xA}{y}. +\end{equation} +Then $AT=0$ and $T^2=A^2>0$. Consequently +\[ + \Omega=A+iT,\qquad \Omega^2=0,\qquad + \Omega\overline\Omega=2A^2>0. +\] +The form $\Omega$ is complex decomposable and its kernel in the +complexified tangent bundle is complementary to its conjugate. Taking +this kernel as $T^{0,1}$ defines an almost-complex structure with the +given orientation. Replacing $y$ by $-y$ conjugates $\Omega$ and changes +$J$ to $-J$. The real and imaginary parts of $\Omega$ span the +anti-invariant forms, and $\Omega$ is a nowhere-zero section of the +canonical bundle. + +Choose any Hermitian metric for $J$. The invariant two-forms are the +wedge-orthogonal complement of $\operatorname{span}(A,C)$ and have +signature $(1,3)$. For the decomposition +$B=B^{1,1}+B^{2,0+0,2}$, the positive-triple condition is exactly +$(B^{1,1})^2>0$. A real $(1,1)$ form in complex dimension two has positive +square precisely when its two Hermitian eigenvalues have the same +strict sign. The positive component is the cone of forms positive on +every complex line. The anti-invariant summand vanishes on such lines, +so this is equivalent to taming by $B$. The other component is positive +for $-J$. Connectedness fixes the choice continuously and globally. + +Finally, for independent real vectors $u,v$, +$A(u,v)=C(u,v)=0$ is equivalent to $\Omega(u,v)=0$. +In a complex two-dimensional vector space with a nondegenerate complex +volume form, this says that $u,v$ are complex dependent, equivalently +that their real span is a complex line. +\end{proof} + +In particular, for fixed $J$ the space of taming two-forms is an open +convex cone. Its intersection with the closed representatives of any +one class is also convex. The associated notion of positivity will +always use the sign of $J$ fixed by a stated tamer. + +\begin{proposition}\label{prop:topology} +If $X$ carries a positive closed triple, then +\[ + b^+(X)=3,\qquad + (b_1(X),b^-(X))=(0,19)\ \text{or}\ (4,3). +\] +The free integral intersection lattice is respectively +$3H\oplus2(-E_8)$ or $3H$, where $H$ is the hyperbolic plane. +Every almost-complex structure obtained from a definite pair in the +triple has vanishing integral first Chern class. +\end{proposition} + +\begin{proof} +By \Cref{lem:definite-pair}, one member of the triple is a symplectic +form taming an almost-complex structure whose canonical bundle is +trivial. The first Chern class of this symplectic form therefore +vanishes: the space of its tamed almost-complex structures is +contractible and contains compatible structures. Bauer's bound for a +closed symplectic four-manifold with torsion first Chern class gives +$b^+\le3$ \cite[Corollary~1.2]{Bauer2008}. The three independent +positive cohomology classes give the reverse inequality. + +The characteristic-number identity $c_1^2=2\chi+3\sigma$, obtained +from $p_1=c_1^2-2c_2$, the Euler-number identity and the signature +theorem \cite[Corollaries~11.12 and~15.5, Theorem~19.4]{MilnorStasheff1974}, +together with $b^+=3$, gives +\[ + 0=19-4b_1-b^-,\qquad \sigma=4b_1-16. +\] +Moreover $w_2\equiv c_1=0\pmod2$, so $X$ is spin +\cite[Problem~14-B]{MilnorStasheff1974}. Rokhlin's theorem makes +$\sigma$ divisible by $16$ \cite{Rokhlin1952}. +Since $b^-\ge0$, these relations give +$b_1\in\{0,4\}$ and the displayed alternatives. Poincar\'e duality +makes the free intersection form unimodular, and the Wu formula makes +it even \cite[Theorem~11.14]{MilnorStasheff1974}. Classification of +indefinite even unimodular lattices now gives the two stated forms +\cite[Chapter~V, Section~2.2, Theorems~5--6]{Serre1973}. +Only the intersection lattice has been classified at this stage. +\end{proof} + +The positive three-plane bundle spanned by the triple is the +self-dual bundle of a unique oriented conformal structure. Choose one +metric $g_0$ in that conformal class. Since the original forms are +closed and self-dual, they are harmonic, and +\begin{equation}\label{eq:pair-harmonic-basis} + \mathcal H^+_{g_0} + =\operatorname{span}_{\R}\{\omega_1,\omega_2,\omega_3\} +\end{equation} +by \Cref{prop:topology}. Here the span is the vector space of global +forms, with constant coefficients. + +For $v\in S^2\subset\R^3$, let $B_v=v\cdot\omega$ and let +$\mathcal A_v$ be the plane of forms $a\cdot\omega$ with $a\perp v$. +Choosing the sign tamed by $B_v$ defines an almost-complex structure +$J_v$. This construction uses the plane $\mathcal A_v$ itself and does +not require a global choice of its ordered basis over $S^2$. + +\begin{lemma}\label{lem:twistor-degree} +The family $J_v$ is smooth and is Hermitian for $g_0$. At every point +of $X$ its map to the twistor sphere has degree of absolute value one. +The closed $J_v$-anti-invariant forms form the two-dimensional space +$\mathcal A_v$. +\end{lemma} + +\begin{proof} +The first assertion follows from the construction and the +self-dual description of Hermitian almost-complex structures in +dimension four. At a fixed point, let $K$ be the positive Gram matrix +of the triple for $g_0$. A vector normal to the coefficient plane +$v^\perp$, for this Gram matrix, has coefficients $K^{-1}v$. +Its pairing with $B_v$ is positive. Thus, after normalization, the +fundamental forms give the map +\[ + v\longmapsto\frac{K^{-1}v}{|K^{-1}v|} +\] +in radial coefficient coordinates. Positive definite matrices connect to the +identity through positive definite matrices, so this map has degree +one. The orientation convention identifying coefficient and twistor +spheres can change only its sign. + +A closed anti-invariant form is self-dual for $g_0$, hence harmonic. +By \eqref{eq:pair-harmonic-basis} it is a constant combination of the +original triple. It is anti-invariant for $J_v$ exactly when that +coefficient vector lies in $v^\perp$. This proves the final assertion. +\end{proof} + +After a constant orthogonal change of coefficients we will denote a +chosen original ordered triple by $(A,C,B)$. For all later exact +deformations of the pair, set +\begin{equation}\label{eq:pair-lorentz-space} + V=[A]^\perp\cap[C]^\perp\subset H^2(X;\R). +\end{equation} +This space has signature $(1,b^-)$, and $[B]\in V$ is a unit timelike +vector. It determines the future component of the timelike cone. + +\begin{lemma}\label{lem:complex-symplectic} +Let $A,D$ be closed real two-forms with +$AD=0$ and $A^2=D^2>0$ pointwise. Then $A+iD$ defines an integrable +complex structure, and is a nowhere-zero holomorphic two-form for it. +If a closed third form $C$ has $AC=DC=0$ and $C^2=A^2$, then the +resulting triple is hyperk\"ahler, after choosing the sign of the +complex structure so that $C$ is positive. +\end{lemma} + +\begin{proof} +Set $\Omega=A+iD$ and use its kernel as $T^{0,1}$ as in +\Cref{lem:definite-pair}. For vector fields $U,V$ in that kernel, +Cartan's formula and $\dd\Omega=0$ give +\[ + \mathcal L_U\Omega=0,\qquad + \iota_{[U,V]}\Omega + =\mathcal L_U(\iota_V\Omega)-\iota_V(\mathcal L_U\Omega)=0. +\] +The kernel is involutive. The smooth Newlander--Nirenberg theorem +therefore gives integrability \cite{NewlanderNirenberg1957}, and +closedness of the $(2,0)$ form +$\Omega$ gives holomorphicity. + +Under the additional assumptions, $C$ is a positive closed $(1,1)$ +form, hence a K\"ahler form. Its metric volume is $C^2/2=A^2/2$. +The ratio $\Omega\overline\Omega/C^2$ is constant, so the holomorphic +volume form has constant pointwise norm. The Chern connection of the +canonical line then makes $\Omega$ parallel. For a K\"ahler metric +this is the connection induced by the Levi-Civita connection. +Thus $A,D,C$ are parallel; their normalized self-dual algebra gives +the hyperk\"ahler structure. Explicitly, if +$(\eta_1,\eta_2,\eta_3)=(A,D,C)$ and $\mu=A^2/2$, then +$\eta_i\wedge\eta_j=2\delta_{ij}\mu$; thus their normalized +matrix $\mathcal Q$ from the introduction is the identity. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/03-current-energy.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/03-current-energy.tex new file mode 100644 index 0000000000000000000000000000000000000000..227f8f8f901f65f87b7d34d04fd47856e1c97c36 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/03-current-energy.tex @@ -0,0 +1,704 @@ +\section{Separation, quadratic mass, and angular energy} +\label{sec:current-energy} + +The two separation arguments below produce a positive current, possibly with +an anti-invariant correction. We first control its trace measure at the +two-dimensional scale. An intersection pairing then controls the correction +and the variation of the complex-line directions. These estimates will +permit the density decomposition in \Cref{sec:density-splitting}. + +Separation by positive currents follows the framework of Sullivan and +Harvey--Lawson \cite{Sullivan1976,HarveyLawson1983}, with the +almost-complex formulation of Li--Zhang +\cite[Section~3]{LiZhang2009}. The closed lift, +quadratic mass estimate and resolvent argument also occur in +\emph{Taming implies compatibility on four-manifolds} +\cite[Sections~2--4]{OpenAITaming2026}. We develop the estimates for +both separators together. In the prescribed-class application, the +closed current can have nonzero cohomology class, and its square must +remain in the energy identity. + +\subsection{Conventions and separation} + +Fix a smooth almost-complex structure $J$ on the closed four-manifold $X$, +give $X$ its complex orientation, and choose a smooth $J$-Hermitian metric +$g$. Its fundamental form is +\[ + G(u,v)=g(Ju,v). +\] +The pointwise orthogonal decomposition is +\begin{equation}\label{eq:current-bundles} + \Lambda^2=I\oplus E, + \qquad I=\Lambda_J^+=\R G\oplus\Lambda_g^-, + \qquad E=\Lambda_J^-\subset\Lambda_g^+. +\end{equation} +Let $R$ denote the orthogonal projection onto $E$. A unit complex-line +bivector is $\ell=e\wedge Je$, where $|e|_g=1$. We use $g$ to identify +bivectors and two-forms. Consequently +\begin{equation}\label{eq:current-line-normalization} + |\ell|_g=1,\qquad \ell^+=G/2,\qquad G(\ell)=1, + \qquad |G|_g^2=2. +\end{equation} +The bundle of these bivectors is denoted by $\mathcal L\longrightarrow X$. + +A two-current is a continuous real linear functional on +$\Omega^2(X)=C^\infty(X,\Lambda^2)$. Under the metric identification its +coefficient is a distributional two-form, denoted by the same letter: +$T(\xi)=\langle T,\xi\rangle$. Thus +\begin{equation}\label{eq:current-dual-convention} + T\text{ is closed}\ \Longleftrightarrow\ + T(\dd\alpha)=0\text{ for all }\alpha\in\Omega^1(X) + \ \Longleftrightarrow\ \dd^*T=0 + \ \Longleftrightarrow\ \dd(*T)=0. +\end{equation} +The cohomology class dual to a closed current is $[*T]\in H^2(X;\R)$. +For smooth coefficients this convention gives +$T(\xi)=\int_X\xi\wedge *T$. Inner products between $L^2$ coefficients +will be written $\langle\ ,\ \rangle_2$. + +Let +\[ + \mathcal P_J=\{\xi\in\Omega^2(X):\xi(\ell)>0 + \text{ for every }\ell\in\mathcal L\}, + \qquad + \mathcal Z_J=\{\xi\in C^\infty(X,I):\dd\xi=0\}. +\] +The set $\mathcal P_J$ is an open convex cone in the smooth topology; +openness already holds in the uniform topology. Its closed elements are +precisely the symplectic forms taming $J$. The elements of +$\mathcal P_J\cap\mathcal Z_J$ are the compatible symplectic forms. + +\begin{lemma}[The two separators]\label{lem:current-separators} +The following statements hold. +\begin{enumerate}[label=\textup{(\roman*)}] +\item If $\mathcal P_J\cap\mathcal Z_J$ is empty, there is a nonzero current + $N$ which annihilates $\mathcal Z_J$ and all anti-invariant forms, and is + nonnegative on semipositive invariant forms. +\item If $H\in H^2(X;\R)$ has no representative in $\mathcal P_J$, there + is a nonzero positive invariant current $N$ which is closed and satisfies + $N(H)\le0$. +\end{enumerate} +In either case one can normalize $N(G)=1$ and choose a positive Borel +measure $\lambda$ on $\mathcal L$ such that +\begin{equation}\label{eq:current-line-measure} + N(\xi)=\int_{\mathcal L}\xi_y(\ell)\,\dd\lambda(y,\ell), + \qquad \mu=(\operatorname{pr}_X)_*\lambda, + \qquad \mu(X)=1. +\end{equation} +In particular $N$ has order zero and belongs to $H^{-3}(X,\Lambda^2)$. +\end{lemma} + +\begin{proof} +For \textup{(i)}, apply separation of an open convex set and a disjoint +linear subspace in the real locally convex space $C^\infty(X,I)$. +The separating continuous functional vanishes on $\mathcal Z_J$ and is +nonnegative on its positive cone. Extend it to all two-forms by +precomposing with $1-R$. Adding a positive multiple of $G$ and taking +a limit proves nonnegativity on every semipositive invariant form. + +For \textup{(ii)}, choose a smooth closed representative $\beta$ of $H$ +and separate the open cone $\mathcal P_J$ from the affine subspace +$\beta+\dd\Omega^1(X)$ in $\Omega^2(X)$. If $N$ is the separating +functional, the unbounded translation directions in this affine subspace +give $N(\dd\alpha)=0$. Every positive form can be multiplied by any +positive scalar, so the separation inequalities imply both +$N(\mathcal P_J)\ge0$ and $N(\beta)\le0$. Adding an arbitrary real +multiple of an anti-invariant form to an element of $\mathcal P_J$ shows +that $N$ annihilates anti-invariant forms. The same limiting argument +gives positivity on semipositive invariant forms. + +For either functional, comparison of an invariant form with sufficiently +large positive multiples of $G$ gives +\[ + |N(\xi)|\le C N(G)\|\xi\|_{C^0}. +\] +If $N(G)$ were zero, this inequality and anti-invariance would make the +functional zero. Normalize $N(G)=1$. Locally, the functional is therefore +represented by a positive Hermitian matrix of measures. Its trace is a +positive measure $\mu$; the Radon--Nikodym matrix relative to $\mu$ is +positive semidefinite with trace one. A measurable spectral decomposition +of this $2\times2$ matrix expresses it as a convex combination of rank-one +Hermitian projections. Borel local frames and a Borel partition of $X$ +give the global measure $\lambda$ in +\Cref{eq:current-line-measure}. Finally $H^3\hookrightarrow C^0$ in real +dimension four, so every such measure coefficient belongs to $H^{-3}$. +\end{proof} + +\subsection{A closed lift of anti-invariant forms} + +\begin{lemma}[Closed lift]\label{lem:closed-lift} +There is a classical pseudodifferential operator +$D:C^\infty(X,E)\longrightarrow\Omega^2(X)$ of order zero with +\begin{equation}\label{eq:current-lift-identities} + \dd D=0,\qquad RD=\Id. +\end{equation} +It maps distributions to distributions. For the separator in +\Cref{lem:current-separators}\textup{(i)}, define +\begin{equation}\label{eq:current-correction} + Q(\xi)=-N(DR\xi),\qquad T=N+Q. +\end{equation} +Then $Q$ is anti-invariant and self-dual, $Q,T\in H^{-3}$, and $T$ +annihilates every closed smooth two-form. In particular $T$ is a closed +current and $[*T]=0$. + +For a smooth family of $(J,g)$ with constant dimension of the space of +closed anti-invariant forms, these lifts can be chosen smoothly in the +parameter as operators between the corresponding smooth bundles. +\end{lemma} + +\begin{proof} +On sections of $E$ consider $P=R\dd\dd^*$. If $a$ is self-dual, then +the self-dual projection of $\xi\wedge\iota_\xi a$ is +$|\xi|^2a/2$: in a frame with first covector $\xi/|\xi|$, the two +self-dual halves of $a$ have equal length. Hence +\[ + \sigma_2(P)(x,\xi)=\tfrac12|\xi|_g^2\Id_E, + \qquad \langle Pa,a\rangle_2=\|\dd^*a\|_2^2. +\] +Thus $P$ is elliptic, self-adjoint, and nonnegative. Its kernel consists +of smooth sections with $\dd^*a=0$. Since $a=*a$, these sections also +satisfy $\dd a=0$, and hence are harmonic. Conversely a closed +anti-invariant form is self-dual and therefore harmonic and in the kernel. + +Let $H_0$ be the orthogonal projection onto this finite-dimensional +kernel, and let $L$ be the inverse of $P$ on its orthogonal complement, +extended by zero on the kernel. Elliptic Fredholm theory and the +parametrix give $L$ as a classical operator of order $-2$, with +$H_0$ smoothing and $PL=\Id-H_0$; see +\cite[Sections~4--5 and~10]{TaylorPseudodifferentialNotes}. +Indeed, if $B_0P=\Id+K$ is a parametrix identity with $K$ smoothing, +then $B_0(\Id-H_0)=L+KL$. Elliptic regularity makes $KL$ smoothing, +which gives the asserted order of $L$. Set +\begin{equation}\label{eq:current-lift-definition} + D=\dd\dd^*L+H_0. +\end{equation} +The image of both summands is closed, and +$RD=PL+H_0=\Id$. This proves +\Cref{eq:current-lift-identities}. + +For closed $\xi$, the form $\xi-DR\xi$ is closed and invariant, so +$T(\xi)=N(\xi-DR\xi)=0$. The functional $Q$ only depends on $R\xi$, +which proves its anti-invariance and self-duality. Its $H^{-3}$ membership +follows because an order-zero operator and its adjoint act boundedly on +every Sobolev space +\cite[Proposition~5.5]{TaylorPseudodifferentialNotes}. +The vanishing on exact forms makes $T$ closed. +Its pairings with all closed two-forms vanish, so Poincare duality, or the +harmonic projection of $*T$, gives $[*T]=0$. + +For the family assertion, identify the varying bundles locally in the +parameter and use a smooth unitary identification of the $L^2$ spaces. +The elliptic operators then have common domain $H^2$ in a fixed +Hilbert space. Choose a spectral contour enclosing only zero at one +parameter value. The resolvent identity and elliptic regularity give +a smooth family of resolvents on this contour after shrinking the +parameter neighborhood. Its spectral projection has locally constant +rank. Since the kernel dimension is constant with that rank, the +enclosed spectral subspace consists exactly of the kernel. Thus $H_0$ +depends smoothly on the parameter, and so does +\[ + L=(P+H_0)^{-1}(\Id-H_0) +\] +on every Sobolev scale. \Cref{eq:current-lift-definition} gives the +required smooth lifts. +\end{proof} + +The projected elliptic operator also underlies Lejmi's local +compatibility construction \cite[Theorem~2.1]{Lejmi2006}; the related +global linear correction appears in +\cite[Proposition~3.1]{DraghiciZhang2012}. The harmonic projection in +\Cref{eq:current-lift-definition} records the possibly nonzero kernel. +The lift provides closedness and the prescribed anti-invariant part. +The estimates below will address existence of a positive closed +invariant form. + +From now on we use one of the two following setups: +\begin{enumerate}[label=\textup{(\Alph*)}] +\item $N$ is the normalized separator in + \Cref{lem:current-separators}\textup{(i)}, and $Q,T$ are given by + \Cref{eq:current-correction}; +\item $N$ is a normalized positive invariant closed current, $Q=0$, and + $T=N$. +\end{enumerate} +The second setup includes \Cref{lem:current-separators}\textup{(ii)}. +In both cases $T$ is closed, but the obstructions to be removed are +different. In setup \textup{(A)}, we will prove $Q=0$: the positive +current $N=T$ would then annihilate every closed form, which is +impossible when $J$ has a closed tamer. In setup \textup{(B)}, a class separator +satisfies $N(H)\le0$; the task is instead to prove $N(H)>0$ from the +hypotheses on the proposed taming class. The estimates below apply to +both setups. They first put $Q$ in $L^2$ and control nearby line +directions; \Cref{sec:density-splitting} will then eliminate the two +obstructions. + +Constants below can depend on $J,g$ and +the fixed operators, but are independent of the center, the small scale, +and the choice of submeasure of $\lambda$. + +\subsection{The quadratic mass estimate} + +We will use the following elementary consequence of the order-zero +calculus. The proof records the dependence on the radial scale. + +\begin{lemma}[Radial order-zero estimate]\label{lem:current-radial-operator} +Let $A$ be a fixed classical operator of order zero between smooth vector +bundles on a compact four-manifold. Fix a coordinate radius below the +injectivity radius. Suppose that smooth sections $a_{s,p}$, supported in +that coordinate neighborhood of $p$, satisfy, for $00$ for uniform normal coordinates and a smooth +radial cutoff which is one on $B_{2\rho_0}(p)$ and supported in +$B_{3\rho_0}(p)$. This cutoff will not change when a smaller inner +radius is chosen below. The logarithmic potential will detect the mass +of $B_s(p)$, while a square-root potential will dominate the +inverse-distance errors caused by varying $J$ and by the closed lift. +With $t=\dist(p,\cdot)$ define the globally +smooth cut-off functions +\[ + u_s=\chi(t)\log\sqrt{s^2+t^2},\qquad + h_s=\chi(t)\sqrt{s^2+t^2},\qquad + \dd_J^cu=-\dd u\circ J. +\] +Smoothness at $p$ follows from the dependence on $t^2$ and from $s>0$. +For a function $f$, put +\[ + \beta(f)= + \begin{cases} + (1-DR)\dd\dd_J^cf,&\text{in setup \textup{(A)}},\\ + \dd\dd_J^cf,&\text{in setup \textup{(B)}}. + \end{cases} +\] +In setup \textup{(A)}, $\beta(f)$ is closed and invariant, and in setup +\textup{(B)} it is exact. Hence $N(\beta(f))=0$ in both cases. + +The principal symbol of $\dd\dd_J^c$ on functions is a multiple of +$\xi\wedge J^*\xi$, which is $J$-invariant. Thus +$R\dd\dd_J^c$ is a first-order operator. Differentiating the radial +functions gives, for $0\le j\le6$, +\[ + |\nabla^jR\dd\dd_J^cu_s|\le C_j(s+t)^{-1-j},\qquad + |\nabla^jR\dd\dd_J^ch_s|\le C_j(s+t)^{-j}. +\] +On the cutoff annulus these inputs and their derivatives are uniformly +bounded. \Cref{lem:current-radial-operator} applied to $D$ therefore +bounds the two correction terms by +$C/(s+t)$ and $C(1+|\log(s+t)|)$ respectively. + +For clarity, the positive part of the test can be computed in a fixed +Hermitian Euclidean space. If $f=f(t)$ and $\ell$ is a unit complex +line, its Hessian trace is +\[ + \dd\dd_{J_p}^cf(\ell) + =2f'(t)/t+\bigl(f''(t)-f'(t)/t\bigr)a, + \qquad 0\le a\le1, +\] +where $a$ is the squared length of the radial unit vector projected onto +the line. For the two functions without cutoff this gives +\begin{align} + \dd\dd_{J_p}^c\log\sqrt{s^2+t^2}(\ell) + &\ge \frac{2s^2}{(s^2+t^2)^2},\label{eq:current-log-trace}\\ + \dd\dd_{J_p}^c\sqrt{s^2+t^2}(\ell) + &\ge \frac1{\sqrt{s^2+t^2}}.\label{eq:current-root-trace} +\end{align} +In normal coordinates $g-g_p=O(t^2)$ and $J-J_p=O(t)$, while the first +derivatives of $J$ are bounded. Replacing the frozen complex line and +operator by the actual ones changes these estimates by at most +$C/(s+t)$ for $u_s$ and $C$ for $h_s$. Indeed the Hessian errors are +bounded by $Ct|\nabla^2f|$ and the coefficient-derivative errors by +$C|\nabla f|$. With $\delta=s+t$, it follows that on +$B_{\rho_0}(p)$ +\begin{align} + \beta(u_s)(\ell)&\ge c_1s^2\delta^{-4}-C_1\delta^{-1}, + \label{eq:current-log-corrected}\\ + \beta(h_s)(\ell)&\ge c_2\delta^{-1} + -C_2(1+|\log\delta|). + \label{eq:current-root-corrected} +\end{align} +The inequalities include setup \textup{(B)}, where the correction terms +are absent. + +All constants just obtained use the already fixed cutoff. Now choose +$0<\rho<\rho_0$ so small that +\[ + C_2(1+|\log\delta|)\le c_2/(2\delta) + \qquad(0<\delta\le2\rho). +\] +Next choose a fixed multiplier $M\ge2C_1/c_2$. If $s\le\rho$ and +$t\le\rho$, \Cref{eq:current-log-corrected,eq:current-root-corrected} +give $\beta(u_s+Mh_s)(\ell)\ge c_1s^2\delta^{-4}$. +On $X\setminus B_\rho(p)$ all terms are bounded independently of $s$, +including the nonlocal corrections, by the last assertion of +\Cref{lem:current-radial-operator}. Since $\delta\le2s$ on $B_s(p)$, +we conclude globally that +\[ + \beta(u_s+Mh_s)(\ell)\ge c s^{-2}\mathbf1_{B_s(p)}-C. +\] +Apply $N$ and use $N(\beta(u_s+Mh_s))=0$ and $\mu(X)=1$ to obtain +\Cref{eq:current-quadratic-mass} for $s\le\rho$. For larger $s$ the +same assertion follows from $\mu(X)=1$. Compactness makes all choices +uniform in $p$. +\end{proof} + +\subsection{The resolvent kernel and positive pairings} + +We now have a uniform mass bound at the two-dimensional scale. The +next step is to compare directions of nearby complex lines. Smoothing +allows this comparison through an intersection pairing while keeping +the error controlled by the mass bound just proved. + +Let $\Delta=\dd\dd^*+\dd^*\dd$ be the nonnegative Hodge Laplacian and +set +\begin{equation}\label{eq:current-smoothing} + S_s=(1+s^2\Delta)^{-3},\qquad 00\}\) as \(U\), and satisfies +\[ + H\cdot d>0 +\] +for every irreducible closed \(J\)-holomorphic curve of class \(d\), then +\(H\) contains a smooth symplectic form taming \(J\). +\end{theorem} + +We first combine \Cref{prop:angular-energy} with the tangent-measure +analysis to prove closedness of density weights in +\Cref{prop:density-weights}. The general splitting argument and its +smooth density-weight conclusion are shared with +\cite[Theorem~5.1 and Section~6, ``Passing to the positive-density set'']{OpenAITaming2026}; +we give the argument with the conventions used here. The diffuse pairing then proves +\Cref{thm:tamed-compatible} without integral-current regularity. +Finally, the integral threshold cycles of +\Cref{lem:density-integral-thresholds} give \Cref{thm:taming-cone}; +integral-current regularity enters only this last step. + +\subsection{Densities and almost-everywhere planar tangents} + +We use the conventions and separator constructions of +\Cref{lem:current-separators,prop:angular-energy}. Thus \(g\) is a smooth +\(J\)-Hermitian metric with fundamental form \(G\), +\[ + N(\xi)=\int \xi_y(\ell)\,d\lambda(y,\ell),\qquad + \mu=(\operatorname{pr}_X)_*\lambda, + \qquad T=N+Q, +\] +where \(\ell\) ranges over the unit positively oriented complex-line +bivectors. The current \(T\) is closed, \(Q\) is anti-invariant and belongs +to \(L^2\), and +\begin{equation}\label{eq:density-basic-bounds} + \mu(B_s(p))\le Cs^2,\qquad + \mathcal A_s:= + \iint_{\dist(y,z)0\), the matrix +\(M(p)\) is a single unit complex-line bivector \(\ell_p\), the +conditional measure \(\lambda_p\) is supported on that line, and +\[ + s^{-2}(\exp_p^{-1}/s)_*\mu + \ \longrightarrow\ + \frac{\vartheta(p)}{\pi}\, + \mathcal H^2\!\restriction P_p +\] +locally weakly on \(T_pX\), where \(P_p\) is the plane of \(\ell_p\). +The pushforward here is restricted to the normal-coordinate ball before +rescaling. +\end{lemma} + +\begin{proof} +Choose a positive-density point where differentiation of the bounded +matrix \(M\) with respect to \(\mu\) holds in a fixed Euclidean +coordinate chart and smooth local trivialization +\cite[Theorem~4.33 and Corollary~4.34]{Kinnunen2026}. This excludes a +set of zero \(\mu\)-measure. No doubling hypothesis is needed: for +fixed \(R\), enclose \(B_{Rs}(p)\) in a coordinate ball \(E_s\) of +radius comparable to \(Rs\). Quadratic growth bounds +\(s^{-2}\mu(E_s)\), while differentiation makes the mean oscillation +of \(M\) on \(E_s\) tend to zero. Therefore +\[ + s^{-2}\int_{B_{Rs}(p)}|M(y)-M(p)|\,d\mu(y)\longrightarrow0. +\] +A smooth change of frame adds a vanishing \(O(s)\) error after this +normalization. The +quadratic mass bound gives subsequential locally weak limits +\(\gamma\) of the rescaled scalar measures on all of \(T_pX\simeq\R^4\). +The existence of the density, followed by approximation of balls from +inside and outside, gives +\begin{equation}\label{eq:density-tangent-ball-mass} + \gamma(B_R)=\vartheta(p)R^2\qquad(R>0). +\end{equation} +In particular every centered sphere has zero \(\gamma\)-measure. +The rescaled \(Q\) mass on that ball satisfies the sharper estimate +\begin{equation}\label{eq:density-rescaled-correction} + s^{-2}\int_{B_{Rs}(p)}|Q|\,dV_g + \le CR^2\|Q\|_{L^2(B_{Rs}(p))}\longrightarrow0. +\end{equation} +Passing to the limit in closedness of the rescaled \(T\) therefore +shows that the constant-coefficient current \(M(p)\gamma\) is closed. + +Identify \(M(p)\) with a constant skew-symmetric matrix. The equation +\(\partial(M(p)\gamma)=0\) says that all distributional derivatives +of \(\gamma\) in the column space of that matrix vanish. Equivalently, +\(\gamma\) is translation invariant along \(\im M(p)\). +The nonzero positive Hermitian matrix \(M(p)\) has real rank two or +four. Rank four would make \(\gamma\) a nonzero multiple of Lebesgue +measure on \(\R^4\), which contradicts +\Cref{eq:density-tangent-ball-mass}. Thus its rank is two. +Trace-one normalization then makes \(M(p)=\ell_p\), the unit bivector +of a complex line \(P_p\). The rank-one positive Hermitian matrix is +an extreme point of the trace-one positive matrices: if its +quadratic form vanishes on a vector, positivity forces almost every +matrix in any convex decomposition to vanish there too. Hence +\(\lambda_p\) is concentrated on \(\ell_p\). + +A locally finite measure invariant under translations in \(P_p\) +has the form +\(\mathcal H^2\!\restriction P_p\otimes\sigma\), with \(\sigma\) a +locally finite measure on \(P_p^\perp\). Equation +\eqref{eq:density-tangent-ball-mass} now becomes +\[ + \vartheta(p)= + \pi\int_{P_p^\perp} + \bigl(1-|z_\perp|^2/R^2\bigr)_+\,d\sigma(z_\perp) + \qquad(R>0). +\] +Each integrand is nondecreasing in \(R\), and is strictly increasing +once \(R>|z_\perp|>0\). Constancy for all \(R\) forces \(\sigma\) +to be supported at zero. Its mass is \(\vartheta(p)/\pi\). +Every convergent subsequence has consequently the same limit, proving +the asserted convergence. +\end{proof} + +\begin{corollary}[Integrated transverse estimate] +\label{cor:density-transverse} +With the plane projection taken in \(T_yX\), one has +\begin{equation}\label{eq:density-transverse} + \mathcal T_s:= + \int d\lambda(y,\ell) + \int_{B_s(y)} + \left|\operatorname{pr}_{\ell^\perp} + \exp_y^{-1}(z)/s\right|^2\,d\mu(z) + =o(s^2). +\end{equation} +\end{corollary} + +\begin{proof} +At the positive-density points covered by +\Cref{lem:density-planar-tangents}, divide the inner integral by +\(s^2\) and pass to the planar tangent measure. The integrand vanishes +on that plane, and the limiting sphere has zero measure. +At zero-density points the same normalized integral is bounded by +\(s^{-2}\mu(B_s(y))\), which tends to zero. These two arguments apply +for \(\lambda\)-almost every \((y,\ell)\). The quadratic mass bound +gives a uniform integrable bound, so dominated convergence proves +\Cref{eq:density-transverse}. +\end{proof} + +\subsection{Closedness of density weights} + +The tangent measures now show that displacement normal to the local +complex line has a vanishing averaged contribution. We combine this +with the angular estimate to control derivatives of a smoothed density. +That control will allow the density weights to preserve closedness. + +\begin{proposition}[Closed density weights]\label{prop:density-weights} +For either separator construction of \Cref{lem:current-separators}, +let \(\vartheta\) be the density in \Cref{lem:density-existence}. +If \(b\colon\R\to\R\) is smooth and bounded with \(b(0)=0\), then +the current \(b(\vartheta)N\) is closed. +The currents +\begin{equation}\label{eq:density-weighted-restrictions} + N^+=\mathbf1_{\{\vartheta>0\}}N, + \qquad + I_a=\mathbf1_{\{\vartheta>a\}}\frac{\pi}{\vartheta}N + \quad(a>0) +\end{equation} +are also closed. In particular, if +\(N^d=\mathbf1_{\{\vartheta=0\}}N\), then \(N^d+Q\) is closed. +\end{proposition} + +\begin{proof} +We first smooth the scalar density. Fix a nonnegative function +\(h\in C_c^\infty((0,1))\), normalized by +\(\int_0^1h(u)\,du=1\). For small \(s\), put +\begin{equation}\label{eq:density-smoothed} + f_s(y)=s^{-2}\int_X + h\bigl(\dist(y,z)^2/s^2\bigr)\,d\mu(z), + \qquad M_s(z)=\mu(B_s(z)). +\end{equation} +The function \(f_s\) is smooth: the support lies inside the injectivity +radius, and the cutoff vanishes near its boundary. The mass bound +makes \(f_s\) uniformly bounded. Integration with respect to the +radial distribution of \(\mu\) gives +\[ + f_s(y)=-\int_0^1 h'(u)\, + \frac{\mu(B_{s\sqrt u}(y))}{s^2}\,du + \longrightarrow + -\vartheta(y)\int_0^1u h'(u)\,du=\vartheta(y). +\] +There are no atoms by quadratic growth, so no endpoint term occurs +at \(u=0\). Thus \(f_s\to0\) volume-almost-everywhere as well. + +Fix a smooth one-form \(\alpha\). To prove that \(b(\vartheta)N\) +is closed, apply closedness of \(T=N+Q\) before passing to the +density limit: +\begin{equation}\label{eq:density-weight-product-rule} + 0=T\bigl(d(b(f_s)\alpha)\bigr) + =T\bigl(b(f_s)d\alpha\bigr) + +T\bigl(b'(f_s)\,df_s\wedge\alpha\bigr). +\end{equation} +The first term has the required limit. Indeed, dominated convergence +gives +\[ + b(f_s)N\longrightarrow b(\vartheta)N,\qquad + b(f_s)Q\longrightarrow0 +\] +as currents. The second convergence uses \(b(0)=0\), the +volume-almost-everywhere convergence of \(f_s\), and domination +by \(C|Q|\). + +It remains to show that the derivative term in +\eqref{eq:density-weight-product-rule} vanishes. The derivative of +\(b\) is bounded on the common bounded range of the \(f_s\). +Write \(|df_s|_\ell\) for the norm of the restriction to the plane +of \(\ell\). The \(N\) contribution is bounded by a constant times +\(\|\alpha\|_{C^0}\int |df_s|_\ell\,d\lambda\), and the \(Q\) +contribution is bounded by a constant times +\(\|\alpha\|_{C^0}\int |Q|\,|df_s|\,dV_g\). +We therefore need exactly two estimates: +\begin{equation}\label{eq:density-two-gradient-estimates} + \int_X |Q|\,|df_s|\,dV_g=o(1), + \qquad + \int |df_s|_\ell\,d\lambda(y,\ell)=o(1). +\end{equation} +\smallskip +\noindent\emph{The derivative against \(Q\).} +Differentiating the radial kernel gives +\(|df_s(z)|\le Cs^{-3}M_s(z)\). Fubini and the volume bound give +\[ + \int_X M_s\,dV_g + =\int_X\vol_g(B_s(y))\,d\mu(y)\le Cs^4. +\] +Moreover \(M_s/s^2\) is uniformly bounded and tends to zero +volume-almost-everywhere. Therefore +\begin{align} + s^{-3}\int_X |Q|M_s\,dV_g + &\le + \left(\int_X |Q|^2\frac{M_s}{s^2}\,dV_g\right)^{1/2} + \left(s^{-4}\int_X M_s\,dV_g\right)^{1/2}\notag\\ + &=o(1). + \label{eq:density-q-gradient} +\end{align} +The first factor tends to zero by dominated convergence against +\(|Q|^2dV_g\), and the second is bounded. This proves the first +estimate in \Cref{eq:density-two-gradient-estimates}. + +\smallskip +\noindent\emph{The tangential derivative.} +Closedness will convert tangential differentiation into normal +derivatives. The radial kernel then supplies a transverse displacement +factor, multiplied by the difference between nearby complex-line +directions. The transverse estimate of \Cref{cor:density-transverse} +and the angular-energy bound will control these two factors together. + +Fix a center and line \((y,\ell)\). Choose an orthonormal basis of +\(T_yX\) whose first two vectors span the oriented plane of \(\ell\), +and let \(\zeta_1,\ldots,\zeta_4\) be the corresponding normal +coordinates. The estimates below are uniform in this choice, so a +measurable choice of such bases suffices when integrating in +\((y,\ell)\). Write +\[ + k_s^y(z)=h(|\zeta|^2/s^2),\qquad + q_i(z)=\partial_{\zeta_i}k_s^y(z),\qquad + \omega_{12}=d\zeta_1\wedge d\zeta_2. +\] +First variation of squared distance yields +\begin{equation}\label{eq:density-first-variation} + df_s(y)(e_i)=-s^{-2}\int q_i(z)\,d\mu(z), + \qquad i=1,2. +\end{equation} +The sign comes from differentiating the center; the displayed +\(q_i\) differentiates the radial expression in its coordinate +variable. + +We replace this scalar integral by \(T(q_i\omega_{12})\). +On \(B_s(y)\), normal coordinates and parallel transport differ by +\(O(s^2)\), and hence +\begin{align} + \omega_{12}(m) + &=\langle\ell,\tau_{zy}m\rangle+O(s^2),\notag\\ + |1-\omega_{12}(m)| + &\le C\bigl(s^2+|\ell-\tau_{zy}m|^2\bigr). + \label{eq:density-tangent-form-error} +\end{align} +The second identity uses that both bivectors have unit length. +Since \(|q_i|\le C/s\), the integrated replacement error is at most +\begin{align} + &s^{-2}\int + \left|\int q_i\,d\mu-T(q_i\omega_{12})\right|d\lambda(y,\ell) + \notag\\ + &\hspace{1cm}\le + Cs^{-3}\left( + s^2\iint_{\dist(y,z)0\}}\) on \([0,\infty)\), and vanish at zero. +For fixed \(a>0\), the functions +\[ + b_{a,n}(t)= + \begin{cases} + \pi\,\chi(n(t-a))/t,&t>0,\\ + 0,&t\le0 + \end{cases} +\] +are smooth, vanish near zero, and are uniformly bounded by \(\pi/a\). +They converge at every \(t\ge0\) to +\(\mathbf1_{\{t>a\}}\pi/t\), with value zero at \(t=a\). +Dominated convergence and closedness of each smooth-weight current +prove \Cref{eq:density-weighted-restrictions}. No derivative bound +uniform in \(n\) is used: the smoothing limit was taken first for +each \(n\). Finally \(N^d+Q=T-N^+\) is closed. +\end{proof} + +\subsection{The diffuse pairing and compatible forms} + +We can now subtract the closed positive-density part of the current. +On the remaining zero-density set, the negative kernel error tends to +zero. The resulting intersection pairing first proves compatibility +and then gives the nonnegative square needed for the class criterion. + +\begin{lemma}[Vanishing of the diffuse kernel error] +\label{lem:density-diffuse-error} +Set +\[ + B_s(z)=s^{-2}\int_X(1+\dist(y,z)/s)^{-6}\,d\mu(y). +\] +These functions are uniformly bounded, and \(B_s(z)\to0\) whenever +\(\vartheta(z)=0\). In particular, +\begin{equation}\label{eq:density-diffuse-error} + \int_X B_s(z)\,d\mu^d(z)\longrightarrow0,\qquad + \mu^d=\mathbf1_{\{\vartheta=0\}}\mu. +\end{equation} +\end{lemma} + +\begin{proof} +For each dyadic shell, quadratic growth gives the summable bound +\[ + s^{-2}(1+2^j)^{-6}\mu(B_{2^{j+1}s}(z)) + \le C\,2^{-4j}. +\] +The same estimate holds once the radius exceeds a fixed small +radius, by increasing \(C\) and using the finite total mass. +This proves uniform boundedness. If \(\vartheta(z)=0\), each fixed +shell contribution tends to zero, because +\(s^{-2}\mu(B_{2^{j+1}s}(z))\to0\). +The summable bound then proves pointwise convergence. A second +application of dominated convergence proves +\Cref{eq:density-diffuse-error}. +\end{proof} + +For closed currents \(S,S'\) under consideration, the smoothing +operator \(S_s=(1+s^2\Delta_g)^{-3}\) preserves their cohomology classes +and commutes with the Hodge star. Hodge decomposition therefore gives +\begin{equation}\label{eq:density-smoothed-intersection} + \langle S_sS,*S_sS'\rangle_{L^2} + =\mathfrak c(S)\cdot\mathfrak c(S'), +\end{equation} +independently of \(s\). Their Sobolev regularity after smoothing is +sufficient for this identity; it can also be obtained by an +additional heat regularization and passage to the limit. + +\begin{proof}[Proof of \Cref{thm:tamed-compatible}] +Suppose that no compatible symplectic form exists. +The separator in \Cref{lem:current-separators} gives a nonzero positive +current \(N\), normalized to have trace mass one, and an +anti-invariant \(Q\) such that \(T=N+Q\) annihilates all smooth closed +two-forms. In particular \(T\) is closed and +\(\mathfrak c(T)=0\). +The preceding results apply to this separator. + +By \Cref{prop:density-weights}, \(T^d=N^d+Q\) is closed. Equation +\eqref{eq:density-smoothed-intersection} gives +\begin{align} + 0 + &=\langle S_sT,*S_sT^d\rangle\notag\\ + &=\langle S_sN,*S_sN^d\rangle + +\langle S_sN,S_sQ\rangle + +\langle S_sQ,S_sN^d\rangle + +\|S_sQ\|_2^2 . + \label{eq:density-compatibility-pairing} +\end{align} +The self-duality of \(Q\) accounts for the signs in this expansion. +Both mixed terms tend to zero by \Cref{prop:angular-energy}. +The positive-current lower bound of +\Cref{lem:current-positive-pairing}, applied with second submeasure +\(\lambda^d=\mathbf1_{\{\vartheta=0\}}\lambda\), gives +\[ + \langle S_sN,*S_sN^d\rangle + \ge -C\int_XB_s\,d\mu^d=o(1). +\] +Since \(S_sQ\to Q\) in \(L^2\), taking a limit inferior in +\Cref{eq:density-compatibility-pairing} forces \(\|Q\|_2^2=0\). +Thus \(T=N\) is a nonzero positive current annihilating all closed +forms. + +Let \(\eta\) be a taming symplectic form. Compactness of the bundle +of unit complex lines and strict taming give +\(\eta_y(\ell)\ge c_\eta>0\). Consequently +\[ + N(\eta)\ge c_\eta\mu(X)>0, +\] +contradicting its annihilation property. +This proves compatible-form existence. The proof has used neither +rectifiability nor a theorem representing integral cycles by curves. +\end{proof} + +\begin{lemma}[Nonnegative diffuse square]\label{lem:density-diffuse-square} +If \(Q=0\), then \(N^d\) is closed and +\(\mathfrak c(N^d)^2\ge0\). +\end{lemma} + +\begin{proof} +Closedness follows from \Cref{prop:density-weights}. By +\Cref{eq:density-smoothed-intersection,lem:current-positive-pairing}, +\[ + \mathfrak c(N^d)^2 + =\langle S_sN^d,*S_sN^d\rangle + \ge -C\int_X B_s\,d\mu^d. +\] +The right side tends to zero by +\Cref{lem:density-diffuse-error}. +\end{proof} + +\subsection{Integral thresholds and positivity of the class} + +To use the hypothesis on curve classes, we must turn the +positive-density current into integral cycles. The factor +\(\pi/\vartheta\) in \(I_a\) is chosen to make their multiplicity +one. Rectifiability and closedness will be checked before applying +the regularity theorem that produces curves. + +\begin{lemma}[The threshold cycles]\label{lem:density-integral-thresholds} +For every \(a>0\), the current \(I_a\) in +\Cref{eq:density-weighted-restrictions} is an integral two-cycle with +positive \(J\)-complex tangent orientation. If \(J\) is tamed, it is a +finite sum of currents of integration over irreducible closed +\(J\)-holomorphic curves, with positive integer multiplicities. +Moreover the identity +\begin{equation}\label{eq:density-layer-cake} + N^+=\frac1\pi\int_0^\infty I_a\,da +\end{equation} +holds as an absolutely convergent integral of currents. +\end{lemma} + +\begin{proof} +Put \(E_+=\{\vartheta>0\}\) and \(\mu^+=\mathbf1_{E_+}\mu\). +At \(\mu^+\)-almost every \(p\), Euclidean coordinate-ball +differentiation of \(\mathbf1_{E_+}\) gives value one. The +coordinate-ball enclosure argument in +\Cref{lem:density-planar-tangents}, applied to this bounded function, +gives +\[ + s^{-2}(\mu-\mu^+)(B_{Rs}(p))\longrightarrow0 + \qquad(R<\infty\text{ fixed}). +\] +Thus \(\mu^+\) has the same positive finite two-density and the same +planar tangent measure as \(\mu\) at almost every such point. +Under a smooth coordinate change its limit is the +linear image of the same plane measure. Thus, in any fixed coordinate +chart, the Euclidean two-density exists and is positive and finite +almost everywhere for the pushed-forward measure: every Euclidean +sphere has zero mass for the limiting plane measure. Preiss's +rectifiability theorem therefore makes \(\mu^+\) a two-rectifiable measure +\cite{Preiss1987}; see also the theorem's formulation in +\cite[p.~771, opening paragraph]{KenigPreissToro2009}. +On a countably rectifiable carrier \(E\) it has +the representation +\begin{equation}\label{eq:density-rectifiable-measure} + \mu^+=\frac{\vartheta}{\pi}\, + \mathcal H_g^2\!\restriction E. +\end{equation} +Here \(\pi\) is the area of the Euclidean unit two-disk. The density +identification follows from differentiation on a rectifiable +carrier. Its approximate tangent plane agrees almost everywhere +with the unique plane in \Cref{lem:density-planar-tangents}. +Thus \(N^+\) is integration over \(E\) with that complex tangent +orientation and multiplicity \(\vartheta/\pi\). + +Multiplying by the weight defining \(I_a\) cancels this multiplicity: +\(I_a\) is integration with integer multiplicity one over +\(E\cap\{\vartheta>a\}\). Its mass is at most +\(\pi\mu(X)/a\), and its boundary vanishes by +\Cref{prop:density-weights}. It is consequently an integral current: +it is integer rectifiable, has finite mass, and has the zero integral +current as its boundary. + +Suppose now that \(J\) is tamed. By the already proved +\Cref{thm:tamed-compatible}, a compatible symplectic form exists. +In particular, the local compatibility hypothesis of the +Rivi\`ere--Tian regularity theorem holds. That theorem applies to +integer rectifiable almost complex cycles and represents them by +\(J\)-holomorphic curves, with only isolated singularities +\cite[Theorem~I.1]{RiviereTian2009}. +Integral multiplicity and complex orientation do not depend on the +choice of Hermitian metric, so we may use the metric of this +compatible symplectic form for that application. +Normalize the resulting curve by separating its local branches at +the isolated singularities; the local completion is part of the +curve representation \cite[Section~VIII]{RiviereTian2009}. +Its normalization components are closed. Compactness and local +finiteness give only finitely many global components; equivalently, +small-ball monotonicity gives a uniform positive lower area for each +nonconstant closed component, whereas the total mass is finite. +Factoring each component through its somewhere-injective image gives +the asserted finite sum of irreducible closed curves with positive +integer multiplicities. + +Finally, pointwise on \(\{\vartheta>0\}\), +\[ + \int_0^\infty + \mathbf1_{\{\vartheta>a\}}\frac{\pi}{\vartheta}\,da=\pi. +\] +For a smooth two-form \(\alpha\), Fubini is justified by +\[ + \int_0^\infty |I_a(\alpha)|\,da + \le \pi\|\alpha\|_{C^0}\mu^+(X). +\] +This proves \Cref{eq:density-layer-cake} with its stated normalization. +\end{proof} + +\begin{proof}[Proof of \Cref{thm:taming-cone}] +Assume that the class \(H\) has no taming representative. +The class separator of \Cref{lem:current-separators} gives a nonzero +closed positive current \(N\), with \(Q=0\), satisfying +\begin{equation}\label{eq:density-cone-separator} + H\cdot\mathfrak c(N)\le0. +\end{equation} +Its positive-density and diffuse parts are separately closed. +The anti-invariance of \(A,C\) implies +\[ + \mathfrak c(N^d)\cdot[A]=N^d(A)=0,\qquad + \mathfrak c(N^d)\cdot[C]=N^d(C)=0. +\] +Thus \(w=\mathfrak c(N^d)\) lies in \(V\), and +\(w^2\ge0\) by \Cref{lem:density-diffuse-square}. + +If \(N^d\ne0\), choose a taming form \(\eta\) in \(U\). Strict +taming on the compact bundle of unit complex lines gives +\[ + U\cdot w=N^d(\eta)>0. +\] +In particular \(w\ne0\). Since \([A],[C]\) span a positive +two-plane and \(b^+=3\), the intersection form on \(V\) has signature +\((1,b^-)\). The conditions \(w^2\ge0\) and \(U\cdot w>0\) put +\(w\) in the nonzero closed time cone determined by \(U\). +Every timelike \(H\) in that component has \(H\cdot w>0\). +Explicitly, take a unit timelike vector \(u\) in the direction of +\(U\), and write \(H=h_0u+h_-\), \(w=w_0u+w_-\), with orthogonal +negative components. Then +\[ + h_0>|h_-|,\qquad w_0\ge|w_-|,\qquad w_0>0, +\] +so +\[ + H\cdot w\ge h_0w_0-|h_-|\,|w_-|>0. +\] +If \(N^d=0\), its pairing is instead zero. This distinguishes the +nonzero diffuse case required for strict positivity. + +For every \(a>0\), \Cref{lem:density-integral-thresholds} expresses +\(I_a\) as a positive integral sum of irreducible closed +\(J\)-holomorphic curves. The hypothesis on \(H\) therefore gives +\[ + H\cdot\mathfrak c(I_a)\ge0, +\] +with strict inequality whenever \(I_a\ne0\). +If \(N^+\ne0\), the layer identity has positive total mass, so the +set of \(a\) for which \(I_a\ne0\) has positive Lebesgue measure. +Pairing \Cref{eq:density-layer-cake} with any smooth representative +of \(H\) then gives \(H\cdot\mathfrak c(N^+)>0\). +The pairing is zero when \(N^+=0\). +At least one of \(N^d,N^+\) is nonzero, and hence +\[ + H\cdot\mathfrak c(N) + =H\cdot\mathfrak c(N^d)+H\cdot\mathfrak c(N^+)>0. +\] +This contradicts \Cref{eq:density-cone-separator} and proves the +theorem. A smooth closed taming representative is symplectic by +pointwise nondegeneracy. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/05-families.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/05-families.tex new file mode 100644 index 0000000000000000000000000000000000000000..afe287c32bb6a696991528328b2f837004b2465d --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/05-families.tex @@ -0,0 +1,982 @@ +\section{The coefficient sphere and curves through a point} +\label{sec:families} + +The sphere of almost-complex structures associated with a definite triple +has one more useful feature than an individual tamed structure: its +symplectic perturbations wind once around the Seiberg--Witten wall. +The use of this winding sphere to construct an elliptic fibration +realizes the program proposed in \cite[Section~7.4.1]{Li2010SCY}. +We calculate the resulting families invariant, including the line bundle +involved in evaluating a spinor at a point. Only the existence and +compactness direction of Taubes's theorem is needed. + +Throughout this section, curve classes are identified with their +Poincare duals. An integral class written in +\(\Lambda=H^2(X;\Z)/\mathrm{torsion}\) may be lifted to +\(H^2(X;\Z)\) when specifying a line bundle. Curve configurations and +their total classes will only be required modulo torsion. +By \Cref{prop:topology}, +\begin{equation} + \label{eq:families-topology} + b^+=3,\qquad + (b_1,\sigma)=(0,-16)\ \text{or}\ (4,0),\qquad + 2\chi+3\sigma=0. +\end{equation} +Let \(J_v\), \(v\in S^2\), be the coefficient sphere of +\Cref{lem:twistor-degree}, with sign chosen so that +\(B_v=v\cdot\omega\) tames \(J_v\). Write +\(P=\operatorname{span}\{[\omega_1],[\omega_2],[\omega_3]\}\) for the +original positive period plane. + +A positive curve configuration is a finite sum of irreducible closed +pseudoholomorphic curves with positive integer multiplicities. The +main output of the section is the following existence statement. + +\begin{theorem} + \label{thm:family-curves} + Let \(F\in\Lambda\) be nonzero with \(F^2=0\), and write + \(F^+=\operatorname{pr}_P F\). For every \(p\in X\), + there exists a finite positive \(J_v\)-holomorphic configuration + of total class \(F\) whose support contains \(p\). + Its parameter is necessarily the coefficient direction + \[ + v=\frac{F^+}{|F^+|}, + \] + where \(P\) is identified with \(\R^3\) by the normalized + ordered period basis. Thus the almost-complex structure is the + same for all prescribed points. +\end{theorem} + +The proof uses the wall-crossing calculation to force a zero of the +first spinor component at a prescribed point, then retains that point +in a large-parameter curve limit. It produces configurations; the +choice of class in \Cref{sec:lattice-chamber} will make each of them +one reduced irreducible curve. + +\subsection{A smooth compatible family} + +\begin{lemma} + \label{lem:compatible-family} + There is a smooth family of closed \(J_v\)-compatible forms + \(\eta_v\). Orthogonal projection to the original positive plane + \(P\) satisfies + \[ + \operatorname{pr}_P[\eta_v]=a(v)[B_v],\qquad a(v)>0. + \] + Consequently the normalized period projection of this family has + degree one in the coefficient coordinates. +\end{lemma} + +\begin{proof} +Fix a metric \(g_0\) in the conformal class determined by the original +triple. All \(J_v\) are orthogonal for \(g_0\), and the three closed +self-dual forms \(\omega_i\) span its self-dual harmonic forms because +\(b^+=3\). Denote by \(R_v\) the projection to the +\(J_v\)-anti-invariant two-forms, and consider +\[ + L_v^{\mathrm{ell}}=R_v\dd\dd^* + \quad\text{on the anti-invariant forms}, +\] +where the adjoint is taken with respect to \(g_0\). +This is the nonnegative elliptic operator in +\Cref{lem:closed-lift}. Its kernel consists exactly of the closed +anti-invariant forms: its quadratic form is \(\|\dd^*\xi\|_2^2\), +and an anti-invariant form is self-dual, so coclosedness implies +closedness. Its kernel is therefore precisely +\[ + \left\{\sum_{i=1}^3 a_i\omega_i:a\cdot v=0\right\}, +\] +a smooth vector bundle of rank two over \(S^2\). + +Let \(H_v\) be the projection onto this explicit kernel. In local +parameter coordinates, identify the varying anti-invariant bundles by +their orthogonal projections. The kernel projection is then smooth, +and \(L_v^{\mathrm{ell}}+H_v\) is invertible from \(H^{s+2}\) +to \(H^s\). The inverse identity and elliptic regularity give +smooth dependence on each Sobolev scale, as in the parameter statement +of \Cref{lem:closed-lift}. Thus the generalized inverse is +\[ + G_v=(L_v^{\mathrm{ell}}+H_v)^{-1}(\Id-H_v), +\] +and +\begin{equation} + \label{eq:families-closed-correction} + D_v=\dd\dd^*G_v+H_v, + \qquad R_vD_v=\Id, + \qquad \dd D_v=0 +\end{equation} +is a smooth family of closed lifts. + +For any \(v_0\), \Cref{thm:tamed-compatible} supplies a compatible +form \(\eta\) for \(J_{v_0}\). For \(v\) near \(v_0\), set +\(\eta_v^{(v_0)}=\eta-D_vR_v\eta\). These forms are closed and +\(J_v\)-invariant, equal \(\eta\) at \(v_0\), and remain positive +after shrinking the parameter neighborhood. A finite parameter +partition of unity patches these local families. Since its +coefficients depend only on \(v\), this operation preserves +closedness on \(X\); positivity and invariance are preserved by +convexity. + +The class \([\eta_v]\) is orthogonal to the classes of the two +anti-invariant forms, so its projection to \(P\) is a multiple of +\([B_v]\). Moreover +\(\int_X\eta_v\wedge B_v>0\): the invariant part of \(B_v\) is +positive, and its anti-invariant part wedges trivially with +\(\eta_v\). Since \([B_v]^2=1\), the multiple is positive. +\end{proof} + +\subsection{The fixed spin-c structure and the equations} + +Fix the canonical \(\mathrm{Spin}^c\) structure of one \(J_v\), +and denote its isomorphism type by \(\mathfrak s_0\). +The structures \(J_v\) form a connected family, so all their +canonical structures have this same fiberwise isomorphism type. +For \(E\in H^2(X;\Z)\), let +\(\mathfrak s_E=\mathfrak s_0\otimes L_E\), where +\(c_1(L_E)=E\). +We use the extension of this fixed structure +over the contractible space of metrics; there is no twist from the +parameter base. Its determinant class and dimensions are +\begin{equation} + \label{eq:families-dimensions} + c_1(\det\mathfrak s_E)=2E, + \qquad d(\mathfrak s_E)=E^2, + \qquad \operatorname{ind}_{\C}\not D_E + =\frac{4E^2-\sigma}{8}. +\end{equation} +Fix a homology orientation once and for all. + +Given a compatible pair \((\eta,J)\), put +\(g(u,w)=\eta(u,Jw)\). Then \(\eta\) is self-dual and has length +\(\sqrt2\). For a fixed \(\mathrm{Spin}^c\) structure with positive +spinor bundle \(W^+\) and determinant line \(L\), we use the +following normalization of the symplectic Seiberg--Witten equations: +\begin{equation} + \label{eq:families-taubes-equations} + \not D_{\mathcal A}\psi=0, + \qquad + F_{\mathcal A}^{+} + =r\,\mathfrak q_g(\psi)-\frac{ir}{4}\eta, + \qquad r\ge1. +\end{equation} +Here \(\mathcal A\) is a unitary determinant connection and +\(\mathfrak q_g\) is the quadratic map with the normalization of +\cite[Equation~(2.9)]{Taubes1999}. The spinor is normalized by +\(r^{-1/2}\) relative to the usual unscaled equations. + +Clifford multiplication by \(\eta\) splits +\(W^+=\mathcal E\oplus K_J^{-1}\mathcal E\), with +\(\psi=(\alpha,\beta)\); the first summand is its +\(-i\sqrt2|\eta|=-2i\) eigenspace. Equivalently, +\begin{equation} + \label{eq:families-first-component} +\alpha=\frac12\left(\Id+\frac i2c^+(\eta)\right)\psi. +\end{equation} +This is the convention of \cite[Equation~(3.17) and +Section~6]{Taubes1999}, which is used in its zero-support proof. +In particular this is an intrinsic projection in a fixed +\(\mathrm{Spin}^c\) structure, and its zero set does not depend on +a local identification with the canonical structure. + +For the coefficient family \(J_v\) and the fixed structure +\(\mathfrak s_E\), the Spin-c twisting action, together with the +actual homotopy of the canonical structures, identifies this first +summand on every fiber with a line of integral Chern class \(E\). +This identification uses the Spin-c structure itself: equality of +determinant Chern classes alone would lose possible two-torsion. + +\begin{lemma}[Compact-family Taubes compactness with incidence] + \label{lem:families-taubes-compactness} + Let \((\eta_n,J_n,g_n)\) be compatible symplectic backgrounds on + \(X\) converging in \(C^\infty\) to + \((\eta_\infty,J_\infty,g_\infty)\), with + \(g_n=\eta_n(\cdot,J_n\cdot)\). Fix a + \(\mathrm{Spin}^c\) structure. Suppose that + \(r_n\to\infty\) and that \((\mathcal A_n,\psi_n)\) solves + \Cref{eq:families-taubes-equations} for the \(n\)-th background. + If the first eigenline has Chern class \(E\) on each fiber, there + is a subsequence and a possibly empty finite positive + \(J_\infty\)-holomorphic configuration + \[ + \mathcal C=\sum_a m_a C_a,\qquad m_a\in\N, + \qquad [\mathcal C]=E\quad\text{in }H^2(X;\R). + \] + Every limit of points \(p_n\in\alpha_n^{-1}(0)\) belongs to + \(\spt\mathcal C\). In particular, if \(E=0\) over \(\R\), + then no such sequence of zeros exists. Over any compact smooth + family of compatible backgrounds, all first components in this + zero-class case are nowhere zero for sufficiently large \(r\), + with one threshold for the whole family. +\end{lemma} + +The proof, including the passage to the limiting almost-complex structure +and retention of the point constraint, is given in +\Cref{subsec:families-varying-compactness}. + +\begin{remark} + \label{rem:families-exact-equations} +Equation~\eqref{eq:families-taubes-equations} uses no additional +bounded curvature term in its perturbation. This is the exact +normalization of \cite[Theorem~2.2]{Taubes1999}. Adding the usual bounded +canonical-curvature term gives the same large-parameter chamber, +but such a change is unnecessary here. Canonical determinant +connections will enter the curvature current in the compactness proof; +only their restrictions and curvatures along \(X\) occur. No +connection in parameter directions is required by the equations. +\end{remark} + +\subsection{The spherical wall coefficient} + +For \(p\in X\), quotient the irreducible configuration space first +by the gauge transformations equal to one at \(p\). Its remaining +circle bundle defines a degree-two class \(U_p\). Choose its sign +so that, on a reducible link given by projectivizing Dirac kernels, +it restricts to \(c_1(\mathcal O(1))\). +The spinor gauge action has weight one in this convention. + +Write +\[ + \Pic^0(X)=H^1(X;\R)/\operatorname{im}\bigl(H^1(X;\Z) + \longrightarrow H^1(X;\R)\bigr) +\] +for the torus of topologically trivial unitary flat line bundles. +It is the identity component of the space of unitary flat line bundles; +the universal line over \(X\times\Pic^0(X)\) is normalized at \(p\). + +\begin{lemma}[Critical spherical wall crossing] + \label{lem:families-wall-crossing} + Suppose \(E^2\ge-2\), and put \(q=(E^2+2)/2\). + For the product manifold family over \(S^2\), with the fixed + \(\mathfrak s_E\) just specified, the difference between two + chamber evaluations of \(U_p^q\) is + \begin{equation} + \label{eq:families-wall-formula} + \pm\deg(\text{difference of wall sections}) + \int_{\Pic^0(X)} + s_{b_1/2}(\operatorname{Ind}\not D_E). + \end{equation} + Here \(s\) denotes the inverse total Chern class, and the Dirac + family over \(\Pic^0(X)\) uses the universal flat twisting line + normalized at \(p\). The constant family evaluation is zero. + For the large-parameter family + \Cref{eq:families-taubes-equations} associated with \(\eta_v\), + the degree difference from a constant family has absolute value + one. +\end{lemma} + +\begin{proof} +The critical wall-crossing theorem and its section-class version are +\cite[Theorem~4.10 and Proposition~4.11]{LiLiu2001}. We check the +normalization and degree relevant here. +A transverse homotopy between two families meets the harmonic wall +at isolated parameters in \(S^2\times[0,1]\), because its normal +rank is \(b^+=3\). Above such a parameter the reducibles form the +torus \(\Pic^0(X)\). Represent the complex Dirac index on this +torus as \(K-O\), with ranks \(k,o\), using a stabilization when +necessary. Write \(x=c_1(\mathcal O(1))\) on the projective +bundle of lines \(\pi:\mathbb P(K)\to\Pic^0(X)\). +The obstruction bundle contributes +\(e(\mathcal O(1)\otimes O)=\sum_i x^{o-i}c_i(O)\). +Projective pushforward therefore gives +\begin{align} + \label{eq:families-projective-pushforward} + \pi_*\left(x^q\sum_i x^{o-i}c_i(O)\right) + &=\sum_i s_{q+o-(k-1)-i}(K)c_i(O)\\ + &=s_{b_1/2}(K-O),\notag +\end{align} +since \Cref{eq:families-topology,eq:families-dimensions} imply +\(q+o-(k-1)=b_1/2\). +The normal crossing signs sum to the degree difference, giving +\Cref{eq:families-wall-formula}. + +The based-gauge normalization makes the universal flat line trivial +at \(p\). Thus no Picard-base line is added to \(x\). +Writing a determinant connection as a canonical connection plus +twice a twisting connection does not alter this conclusion: the +remaining circle acts on the spinor with weight one, as used in +\Cref{eq:families-projective-pushforward}. + +For a constant regular family, negative ordinary expected dimension +gives an empty moduli space. Otherwise the moduli space is the +product of an ordinary \(E^2\)-dimensional moduli space with +\(S^2\), while \(U_p^q\) is pulled back from the former and has +degree \(E^2+2\). Its pairing is therefore zero. + +Every maximal positive harmonic plane projects isomorphically to +\(P\): the kernel would lie in the negative definite space +\(P^\perp\). This identifies the harmonic-wall bundle with the +fixed oriented vector space \(P\). For the perturbation in +\Cref{eq:families-taubes-equations}, its wall section has leading +term \((r/4)[\eta_v]\), with a bounded shift from \(2E\). +By \Cref{lem:compatible-family}, it is nonzero for all sufficiently +large \(r\) and its normalization has degree one. The same is +true after sufficiently small generic family perturbations. +\end{proof} + +All families pairings below are computed with such generic +perturbations in the indicated chamber. The following elementary +compactness observation specifies how we return to the exact +equations. At a fixed \(r\), consider a sequence of backgrounds +in a compact smooth parameter family and a sequence of smooth +perturbations converging in \(C^\infty\). Any corresponding +sequence of solutions has, modulo gauge, a smoothly convergent +subsequence solving the limiting equations. +This follows from the spinor Weitzenbock bound, the abelian +curvature equation, gauge fixing and elliptic bootstrapping; see +\cite[Section~2.1]{LiLiu2001}. Thus nonemptiness for perturbations +tending to zero gives a solution of the exact equations. If all +the perturbed solutions chosen satisfy \(\alpha(p)=0\), that +condition is retained. In using +\Cref{lem:families-taubes-compactness} we first take this +perturbation limit at each fixed \(r\), and only then let +\(r\to\infty\). + +\subsection{The evaluation line over the coefficient sphere} + +For \(E^2=0\), write \(\operatorname{FSW}_E(U_p)\) for the +spherical pairing of \(U_p\) in the large-parameter chamber, and +\(\operatorname{SW}_X(E)\) for the ordinary dimension-zero invariant +of \(\mathfrak s_E\). Denote by \(\pi\) the projection of the +regular family moduli space to \(S^2\). + +Let \(h\in H^2(S^2;\Z)\) be the oriented generator. The first +eigenline in the fixed spin-c family is a line bundle +\(\mathcal E_E\to X\times S^2\), whose restriction to each +fiber has Chern class \(E\). + +\begin{lemma} + \label{lem:families-evaluation-line} + There is an integer \(e\), with \(|e|=1\), such that + \[ + c_1(\mathcal E_E)=E+eh. + \] + If \(E^2=0\), first-component evaluation at \(p\) on a regular + two-dimensional family moduli space is a section of a line bundle + with first Chern class \(U_p+e\pi^*h\). Consequently, if that + evaluation is nowhere zero, + \begin{equation} + \label{eq:families-evaluation-identity} + \operatorname{FSW}_E(U_p)+e\operatorname{SW}_X(E)=0. + \end{equation} + If the left side is nonzero, the exact large-parameter family has + a solution with \(\alpha(p)=0\). +\end{lemma} + +\begin{proof} +Since \(H^1(S^2)=0\), the Kunneth decomposition shows that +\(c_1(\mathcal E_E)=E+eh\) for some integer \(e\). +At \(p\), deform the compatible metrics to \(g_0\) through +\(J_v\)-Hermitian metrics. The fixed spin-c extension over metric +space identifies the positive spinor bundles along this homotopy. +For \(g_0\), the first eigenspaces give the tautological line in +the projective spinor sphere, pulled back by the coefficient sphere +map. The latter has degree of absolute value one by +\Cref{lem:twistor-degree}, proving \(|e|=1\). + +The evaluation transforms with the same gauge weight as the +spinor. Its sign can also be checked on a reducible link: evaluation +on a kernel line \(\ell\) is a map +\(\ell\to\mathcal E_E|_p\), hence lies in +\(\operatorname{Hom}(\ell,\mathcal E_E|_p) +=\mathcal O(1)\otimes\mathcal E_E|_p\). +On the quotient it is therefore a section of the +tensor product of the based-gauge evaluation line with the +pullback of \(\mathcal E_E|_{\{p\}\times S^2}\). +Its Chern class is \(U_p+e\pi^*h\). Pairing \(\pi^*h\) +with the family moduli cycle gives the ordinary dimension-zero +invariant \(\operatorname{SW}_X(E)\); equivalently, restrict +the family to a regular base point. A nowhere-zero evaluation +section trivializes its line, giving +\Cref{eq:families-evaluation-identity}. + +For the last assertion, suppose the exact family had no evaluation +zero. Fixed-\(r\) compactness would give the same absence for all +sufficiently small perturbations: otherwise a sequence of their +zeros would limit to an exact zero. Apply the preceding identity +to a regular such perturbation to obtain a contradiction. +\end{proof} + +The parameter line just computed also explains the globalization +of the spinor splitting. The varying canonical determinant over +\(X\times S^2\) has Chern class \(-2eh\), while +\(c_1(\mathcal E_E)=E+eh\). Hence +\[ + c_1(K^{-1}\mathcal E_E^2)=-2eh+2(E+eh)=2E, +\] +as required for the fixed determinant family. Fiberwise canonical +identifications may therefore be used on parameter charts, with +their natural transition maps, even though the canonical family +itself is not the pulled-back fixed family. The vertical canonical +connections and their curvature two-forms are globally defined. + +\subsection{The Picard-torus calculation} + +For \(b_1=0\), the integral in +\Cref{eq:families-wall-formula} equals one. For \(b_1=4\) we +must calculate rather than assume a torus cohomology ring. +Let +\(u\in H^1(X;\Z)\otimes H^1(\Pic^0(X);\Z)\) +be the mixed Chern class of the normalized universal flat line. +The families index theorem, in the form used in +\cite[Section~4.2]{LiLiu2001}, gives +\begin{equation} + \label{eq:families-index-character} + \operatorname{ch}(\operatorname{Ind}\not D_E) + =\int_X e^{E+u}\widehat A(TX), + \qquad + \operatorname{ch}_1=\int_X\frac{Eu^2}{2}, + \quad + \operatorname{ch}_2=\int_X\frac{u^4}{24}. +\end{equation} +In degree four on the Picard torus, +\begin{equation} + \label{eq:families-segre-two} + s_2=c_1^2-c_2=\frac12\operatorname{ch}_1^2 + +\operatorname{ch}_2. +\end{equation} + +The real cohomology-ring conclusion is known for symplectic +Calabi--Yau surfaces with \(b_1=4\); see +\cite[Proposition~7.8(4)]{Li2010SCY}. We recover it here from the +marked family calculation, which also gives the Segre pairing needed +below. + +\begin{proposition} + \label{prop:cup-product} + If \(b_1=4\), the quadruple cup product on \(H^1(X;\R)\) + is nonzero. The cup-product map + \(\bigwedge^2H^1(X;\R)\to H^2(X;\R)\) is an isomorphism, + and every spherical homology class vanishes over \(\R\). + For every \(E\) with \(E^2=0\), + \[ + \int_{\Pic^0(X)}s_2(\operatorname{Ind}\not D_E)\ne0. + \] +\end{proposition} + +\begin{proof} +First take \(E=0\). Taubes's canonical nonvanishing theorem +\cite{Taubes1994} gives +\(|\operatorname{SW}_X(0)|=1\), since \(b^+>1\). +By \Cref{lem:families-taubes-compactness}, the exact symplectic +family has no first-component zeros for all sufficiently large +\(r\). Fixed-\(r\) compactness transfers this absence to +sufficiently small regular perturbations. Applying +\Cref{eq:families-evaluation-identity} gives +\(|\operatorname{FSW}_0(U_p)|=1\). On the other hand, +\Cref{lem:families-wall-crossing} and +\Cref{eq:families-index-character,eq:families-segre-two} identify +this number, up to sign, with +\[ + \int_{\Pic^0(X)}\int_X\frac{u^4}{24}, +\] +because \(\operatorname{ch}_1=0\) when \(E=0\). +It follows that the quadruple cup product is nonzero. + +Here is an explicit calculation of the remaining assertion. Choose +a basis \(a_1,\ldots,a_4\) of \(H^1(X;\R)\), let +\(t_1,\ldots,t_4\) be the corresponding Picard-torus basis, and +write +\[ + \delta=\int_Xa_1a_2a_3a_4\ne0, + \qquad u=\sum_i a_it_i. +\] +The wedge pairing on \(\bigwedge^2H^1(X;\R)\) induced by this +nonzero volume element is nondegenerate. Thus the cup-product map +into \(H^2(X;\R)\) is injective. Both spaces have dimension +six, by \Cref{prop:topology}, so it is an isomorphism. +We may consequently write +\(E=\sum_{i0\) such +that, whenever \(Cr^{-1/2}\le s\le s_0\), +\begin{equation} + \label{eq:families-taubes-monotonicity} + \mathscr E_r(B_s(x))\le Cs^2, + \qquad + x\in\alpha^{-1}(0)\ \Longrightarrow\quad + \mathscr E_r(B_s(x))\ge cs^2. +\end{equation} +This is \cite[Proposition~4.1]{Taubes1999}, with its universal +normalizing factor absorbed into the constants. Consequently the +zero sets have covers by at most \(Cs^{-2}\) such balls. + +Here is also the scale and derivative dependence in the local +compactness step. Use normal coordinates for each individual +\(g_n\), rescale by \(r_n^{1/2}\), and compare on a ball of fixed +radius \(R\). After identifying the center with Euclidean +\(\C^2\), the rescaled coefficients satisfy +\begin{align} + \label{eq:families-taubes-rescaling} + \|g_n'-g_{\mathrm E}\|_{C^0(B_R)}&\le C_Rr_n^{-1}, + &\|\partial^kg_n'\|_{C^0(B_R)}&\le C_{R,k}r_n^{-k/2} + &&(k\ge2),\\ + \|\eta_n'-\eta_n'(0)\|_{C^0(B_R)}&\le C_Rr_n^{-1/2}, + &\|\partial^k\eta_n'\|_{C^0(B_R)}&\le C_{R,k}r_n^{-k/2} + &&(k\ge1).\notag +\end{align} +The first derivatives of \(g_n'\) are \(O_R(r_n^{-1})\). +The scale in \cite[Equation~(5.1)]{Taubes1999} is +\((r_n|\eta_n|)^{1/2}=2^{1/4}\sqrt{r_n}\). +A fixed dilation therefore converts these coordinates to that +paper's flat-model normalization; all estimates below absorb this +fixed factor, and curvature integrals are unchanged by it. +These estimates follow by Taylor expansion in each metric's own +normal coordinates; compare \cite[Section~6, Step~4]{Taubes1999}. +For every fixed \(R,k\), the rescaled equations therefore have +uniform coefficient bounds through order \(k\). Gauge fixing and +interior elliptic estimates give the rescaled local approximation in +any prescribed \(C^k\) norm by the flat model, as in +\cite[Proposition~5.2]{Taubes1999}. Its quantifiers are: for each +\(R,k,\eps>0\), a common lower bound on \(r\) makes the +approximation error smaller than \(\eps\). We retain smooth +background convergence, so every derivative order required in this +argument is available; no assertion about a minimal finite +regularity threshold is needed. + +Let \(\mathcal A_{\mathrm{can},n}\) be the canonical connection +on \(K_{J_n}^{-1}\). The first eigenline connection \(a_n\) +has curvature +\(F_{a_n}=\tfrac12(F_{\mathcal A_n} + -F_{\mathcal A_{\mathrm{can},n}})\). +The corresponding closed currents +\begin{equation} + \label{eq:families-taubes-current} + T_n(\zeta)=\frac{i}{2\pi}\int_XF_{a_n}\wedge\zeta +\end{equation} +have uniformly bounded mass by +\Cref{eq:families-taubes-mass}. Their periods on closed test forms +are those of \(E\). +On the complement of the first-component zero set, its unit section +identifies the determinant with the canonical determinant. In that +identification the further estimate is +\begin{equation} + \label{eq:families-taubes-off-zeros} + |\mathcal A-\mathcal A_{\mathrm{can}}| + +|F_{\mathcal A}-F_{\mathcal A_{\mathrm{can}}}| + \le Cr^{-1}+Cr\exp\bigl(-\sqrt r\, + \dist(x,\alpha^{-1}(0))/C\bigr) +\end{equation} +when the distance is at least \(r^{-1/2}\) +\cite[Proposition~6.1]{Taubes1999}. + +The ball covers, the lower bound at zeros, and +\Cref{eq:families-taubes-off-zeros} now give a subsequence whose +zero sets converge to the support \(Z_*\) of a weak limit of +\(T_n\); the support has finite two-dimensional Hausdorff measure. +These are the arguments of +\cite[Equations~(7.1)--(7.5) and Lemma~7.1]{Taubes1999}, using +exactly the uniform estimates just listed. + +We give the disk argument needed when the backgrounds vary. Write +\[ + f_n=\frac{i}{2\pi}F_{a_n} + =\frac{i}{4\pi}(F_{\mathcal A_n} + -F_{\mathcal A_{\mathrm{can},n}}). +\] +The sharper estimate +\cite[Proposition~4.2, Equation~(4.9)]{Taubes1999}, specialized to +\(|\eta_n|=\sqrt2\), is +\begin{equation} + \label{eq:families-taubes-sharp} + |F_{\mathcal A_n}^-| + \le \frac{r_n}{2\sqrt2}(1-|\alpha_n|^2)+C. +\end{equation} +Its constants have the same uniform geometric dependence as the +estimates above. If \(\ell\) is a unit, positively oriented +\(J_n\)-complex bivector, then +\(\ell^+=\eta_n/2\), \(|\ell^-|=1/\sqrt2\), and the +curvature equation gives +\[ + iF_{\mathcal A_n}^+(\ell) + =\frac{r_n}{4}(1-|\alpha_n|^2+|\beta_n|^2), + \qquad + iF_{\mathcal A_n}^-(\ell) + \ge-\frac{r_n}{4}(1-|\alpha_n|^2)-C. +\] +The leading terms cancel. The canonical curvatures are uniformly +bounded, so there is one constant \(C_0\ge1\) such that every +\(J_n\)-holomorphic disk \(u\) satisfies +\begin{equation} + \label{eq:families-disk-lower-bound} + u^*f_n\ge-C_0\,\dd A_u. +\end{equation} +Here \(\dd A_u\) is the induced area density, counted on the +source; the inequality also holds at critical points. This derives +the disk bound directly for our normalization, including the factor +one half in the twisting connection. + +\smallskip +\noindent\emph{The relative integer assignment.} +First construct the integer assignment independently of positivity. +A smooth disk \(u\) is admissible when its boundary misses \(Z_*\). +For large \(n\), \(u^*\alpha_n\) is nonzero on a boundary +collar and defines a relative Chern number \(k_n(u)\in\Z\). +The unit first component trivializes the eigenline there, and +\Cref{eq:families-taubes-off-zeros} gives +\begin{equation} + \label{eq:families-relative-degree} + \int_Du^*f_n=k_n(u)+o(1). +\end{equation} +The error is uniform for disks with bounded first derivatives whose +boundary collars have a common positive distance from \(Z_*\). +For each sufficiently large \(n\), relative Chern numbers agree +along any fixed admissible homotopy. The same conclusion holds for +the varying homotopies below: pointwise short geodesics between +uniformly close boundary maps stay in one fixed zero-free +neighborhood of the original boundary. Thus their pulled-back +unit sections extend over the boundary homotopy, uniformly in +large \(n\). + +For an immersed disk, take small normal translates, with a smooth +averaging function in the two normal parameters. The normal bundle +is taken over the source, so self-intersections cause no difficulty. +All these disks have the same \(k_n\). Cut off the source near its +boundary collar; the removed flux tends to zero by +\Cref{eq:families-taubes-off-zeros}. The averaged remaining flux is +the pairing of \(T_n\) with a fixed smooth two-form: the normal +coordinate map is a local diffeomorphism, and a finite partition of +unity pushes the compactly supported averaging forms to \(X\). +Weak convergence of \(T_n\) proves convergence of these averages. +Thus \(k_n\), being integer valued, is eventually constant. A +general admissible smooth disk has an arbitrarily close immersed +perturbation, connected to it by an admissible homotopy, and hence +has the same conclusion. Denote the eventual integer by \(I(u)\). +It is zero for disks missing \(Z_*\), invariant under admissible +homotopy, additive under subdivision, and multiplied by the degree +under proper disk maps; these are the corresponding properties of +relative first Chern numbers. This is the Stokes and averaging +construction of \cite[Proposition~5.6 and Lemma~6.2]{Taubes1996}. +Only positivity for the limiting complex structure remains. + +\smallskip +\noindent\emph{Disk deformations with prescribed incidences.} +We need the following elementary disk deformation fact. For a +holomorphic map on a slightly larger disk, with no boundary +condition, the linearized Cauchy--Riemann operator has a bounded +right inverse even after prescribing values and complex-linear +first derivatives at any finite set of distinct interior source +points. Work, for example, in \(H^k\to H^{k-1}\), \(k\ge4\), +so these evaluations are continuous. Extend the bundle and +operator to a closed surface, and extend the target sections by a +bounded Sobolev extension. The closed-surface operator augmented +by the finite evaluations is Fredholm. Finitely many smooth +forcing terms supported outside the larger disk make it onto. +Indeed, an annihilator of all such exterior terms vanishes there. +Away from the specified points it is smooth by elliptic regularity +and vanishes everywhere by unique continuation for the adjoint +real Cauchy--Riemann operator +\cite[Theorem~2.78 and Proposition~3.12]{Wendl2014Lectures}. +It is therefore a sum of distributions supported at the specified +points. The invertible principal symbol eliminates derivatives of +point masses of positive order: their highest derivative after +applying the adjoint has order at least two, whereas the evaluation +constraints have order at most one. The remaining term at each +point is \(q\delta\). Testing independently the complex-linear +and anti-complex-linear first derivatives eliminates both \(q\) +and the first-derivative constraint covector; testing the value +then eliminates its covector. The annihilator is zero, proving +the assertion about exterior forcing. A bounded right inverse of +this surjective Fredholm operator, restricted to the disk, proves +the claimed right inverse. + +The implicit function theorem and interior regularity consequently +give nearby holomorphic disks for nearby almost-complex structures, +with those finite values and complex-linear derivatives prescribed. +All domain restrictions are chosen first, and all constraints lie +in the smaller disk. The right-inverse bounds persist for nearby +operators. Constants may depend on the chosen finite set of +points and on a fixed neighborhood of the original map; this is +harmless because these choices precede \(n\to\infty\). In +particular, while retaining finitely many incident values, one may +choose the tangent line at each of them independently in a nonempty +open cap. At a critical point one first chooses a sufficiently +small nonzero complex-linear derivative. This gives a fixed small +\(J_\infty\)-holomorphic perturbation of the original disk; +its \(J_n\)-holomorphic transfers converge smoothly to that +perturbation on the smaller closed disk. They need not converge +to the unperturbed disk, and admissible boundary homotopy is what +identifies their integers. + +\smallskip +\noindent\emph{Positive flux at a retained incidence.} +Here is the positive contribution at each retained incidence. +Choose actual zeros \(p_{j,n}\) tending to the finitely many +specified values in \(Z_*\). After a joint subsequence, rescaling +at these zeros gives centered flat models on all fixed balls. +Their first components vanish at the origin. The quadratic energy +bound excludes the identically zero first component. Each limiting +model has a polynomial divisor by +\cite[Proposition~5.1]{Taubes1999}. +For any nonempty open cap of complex lines through the origin, +choose a direction where the highest homogeneous part of that +polynomial is nonzero; only finitely many directions are excluded. +Along the chosen line, distance from the divisor grows linearly +at infinity. The exponential off-divisor estimate in +\cite[Proposition~5.1]{Taubes1999} makes the boundary connection +term tend to zero. Stokes' theorem therefore identifies the total +line flux \((i/2\pi)\int F_{a_0}\) with the positive degree +\(m_j\ge1\) of the restricted divisor, which contains the +origin. The determinant connection in +\cite[Proposition~5.2]{Taubes1999} converges to \(2a_0\), so +this is precisely the limiting normalization of \(f_n\), with +the bounded canonical curvature disappearing under rescaling. +Choose a fixed +large radius \(R_j\) so that the boundary is zero-free and the +flux differs from \(m_j\) by less than \(1/8\). +These are the polynomial-model and line-selection steps in +\cite[Proposition~5.6, Steps~3--4]{Taubes1996}, using the flat +limits of \cite[Proposition~5.2]{Taubes1999}. + +Prescribe those good tangent directions in the disk deformation +just constructed. Choose a fixed approximation tolerance making +the flux error on each model disk less than \(1/8\); only then +take \(n\) large. Because the prescribed derivatives are +nonzero and the disk maps have uniform higher derivative bounds, +the rescaled maps on microscopic source disks converge to the +chosen complex-linear maps. Each resulting source core therefore +contributes more than \(m_j-1/4\ge3/4\) to the flux. +The finitely many core radii tend to zero, so the cores are +source-disjoint. Distinct source incidences may have the same +target value: the flux is integrated on the source, and this does +not affect the argument. The nonzero derivative sizes, the caps, +the models, \(R_j\), and the approximation tolerances are all +fixed before the final lower bound on \(n\) is imposed. + +\smallskip +\noindent\emph{Positivity for the limiting complex structure.} +We now prove positivity for any admissible +\(J_\infty\)-holomorphic disk \(u\) meeting \(Z_*\), +allowing critical points and self-intersections. Shrink its domain +inside a slightly larger disk so that every incidence lies in its +interior and its boundary collar has a fixed positive gap from +\(Z_*\). First fix a small \(C^1\) neighborhood in which +this gap persists and all disk areas are bounded by a number +\(A_*\). Put \(S=u^{-1}(Z_*)\). + +If \(S\) is finite, retain all its points. Choose disjoint +fixed neighborhoods of them whose total induced area, for all +sufficiently close disks, is less than \(1/(4C_0)\). On the +compact complement the original disk has a positive distance from +\(Z_*\); shrink the allowed disk neighborhood to preserve half +that distance. Choose the good tangent caps and the fixed small +holomorphic perturbation within this neighborhood, and transfer it +to \(J_n\), retaining the chosen zeros. The cores contribute +at least \(3/4\) each. Their complement inside the selected +neighborhoods contributes more than \(-1/4\) by +\Cref{eq:families-disk-lower-bound}. On the remaining compact +domain the flux tends to zero by +\Cref{eq:families-taubes-off-zeros}. Thus the limiting integer +in \Cref{eq:families-relative-degree} is positive. + +If \(S\) is infinite, choose a finite number \(N\) of distinct +source points in it with +\(3N/4>C_0A_*+1\). The area bound was fixed before \(N\). +Apply the same finite-constraint construction at these points, +keeping the perturbed disks in the chosen area neighborhood. +The \(N\) source-disjoint cores contribute more than \(3N/4\), +whereas their full complement contributes at least \(-C_0A_*\). +The flux is therefore bounded below by a positive number. Its +limit is the unchanged integer \(I(u)\), so again \(I(u)>0\). +Every choice was finite and fixed before the last passage to large +\(n\); no rate relating \(J_n\to J_\infty\) and +\(r_n\to\infty\) has been imposed. + +\smallskip +\noindent\emph{Curve recognition and retention of the marked point.} +In particular the positivity axiom for embedded holomorphic test +disks holds. The resulting positive cohomology assignment permits +the corrected recognition theorem to be applied to the fixed +structure \(J_\infty\), as in +\cite[Lemmas~7.2--7.3 and Proposition~7.1]{Taubes1999} +and \cite{Taubes2000}. +The recognized normalization map is proper. Since \(X\) is +compact, its source is compact and has finitely many components; +its locally finite exceptional set is finite as well. +The multiplicity of a resulting curve at a smooth point is the +integer \(I\) of a small transverse disk there. The averaging +construction identifies this same integer with the transverse +coefficient of the weak curvature current: on each smooth branch, +a closed current of order zero supported there is a constant +multiple of its oriented integration current. The remaining +difference is supported on the finite singular set, where a +closed two-current of order zero must vanish. Thus the recognized +configuration has current equal to the weak limit of \(T_n\), +as in \cite[Proposition~7.1 and Equation~(7.12) in the proof of +Lemma~7.4]{Taubes1999}; in particular its class is +\(E\). + +The support convergence retains every limit of first-component +zeros. If \(E=0\), a retained zero would give a nonempty positive +configuration with +\(\int_{\mathcal C}\eta_\infty=E[\eta_\infty]=0\), which +is impossible. Failure of the final uniform assertion would supply +a sequence with \(r_n\to\infty\); compactness of the parameter +space would reduce it to the situation just proved. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/06-lattice-chamber.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/06-lattice-chamber.tex new file mode 100644 index 0000000000000000000000000000000000000000..c00f937304fd23a50895bf620c8ad7eaf82f5919 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/06-lattice-chamber.tex @@ -0,0 +1,367 @@ +\section{An integral null class with a uniform chamber} +\label{sec:lattice-chamber} + +The curve-existence result of \Cref{thm:family-curves} applies to every +nonzero integral null class. We now choose one for which a positive curve +configuration cannot split. The choice depends only on the original +period plane, so the resulting restrictions on curve classes persist +under later deformations of the definite pair that preserve its two +periods. +The arithmetic step is to find a primitive null class whose projection +direction avoids a finite set of obstructions. Adjunction then relates +this arithmetic choice to curve classes. Taming and the resulting class alternatives rule out splitting or +multiplicity in a positive configuration in the chosen class; positivity +of intersections makes distinct curves in that class disjoint. + +We use the free lattice +\[ + \Lambda=H^2(X;\Z)/\mathrm{torsion},\qquad + \Lambda_{\Q}=\Lambda\otimes_{\Z}\Q,\qquad + \Lambda_{\R}=\Lambda\otimes_{\Z}\R. +\] +A curve class will mean the image in \(\Lambda\) of its integral +Poincar\'e dual, with the complex orientation of the curve. Equalities +of integral classes in this section are therefore equalities modulo +torsion. This convention does not affect intersections or integrals of +closed real forms. The original positive period plane is denoted by +\(P\), and \(d^+\) denotes the orthogonal projection of +\(d\in\Lambda_{\R}\) to \(P\). By \Cref{prop:topology}, +\[ + \Lambda\simeq 3U\oplus 2E_8(-1) + \quad\hbox{or}\quad + \Lambda\simeq 3U, +\] +where \(U\) is the hyperbolic plane. In particular, \(P^\perp\) is +negative definite. No rationality of \(P\) is assumed. + +\begin{proposition}[Choice of chamber class] +\label{prop:chamber-class} +There is a primitive class \(F\in\Lambda\) with \(F^2=0\) such that the +following implication holds for every \(d\in\Lambda\) and every real +number \(c>0\): +\begin{equation} +\label{eq:lattice-chamber-implication} + d^2\geq-2,\qquad d^+=cF^+,\qquad d\cdot F\leq0 + \quad\Longrightarrow\quad + c\in\Z_{>0},\qquad d\cdot F=0. +\end{equation} +Moreover, \(F^+\ne0\). +\end{proposition} + +\begin{proof} +We first construct a rational null subspace with enough integral +directions, and then exclude finitely many of those directions. + +\smallskip +\noindent\emph{A positive integral vector and a null lattice.} +Set +\[ + W_{\Q}=\Lambda_{\Q}\cap P^\perp,\qquad + W_{\R}=\operatorname{span}_{\R}W_{\Q}. +\] +The subspace \(W_{\R}\) is rational and negative definite. Hence its +orthogonal complement is rational and contains \(P\). Positive square +is an open condition, so density of rational vectors in this complement +gives a positive rational vector in \(W_{\R}^\perp\). Clearing +denominators and dividing out the common integral divisor produces a +primitive vector \(l\in\Lambda\) satisfying +\begin{equation} +\label{eq:lattice-positive-vector} + l^2>0,\qquad l\cdot W_{\Q}=0. +\end{equation} + +Write \(l^2=2n\), where \(n\in\Z_{>0}\). We use the following form of +Eichler's criterion: in an even lattice containing two orthogonal +hyperbolic planes, the orbit of a primitive vector under the stable +orthogonal group is determined by its square and its normalized class +in the discriminant group +\cite[Proposition~3.3(i)]{GritsenkoHulekSankaran2009}. +Here the lattice is unimodular. Thus its discriminant group is zero, +and every primitive vector has divisibility one. The criterion sends +\(l\) to \(e_1+n f_1\), where +\[ + e_i^2=f_i^2=0,\qquad e_i\cdot f_i=1 +\] +are standard bases of the three mutually orthogonal copies of \(U\). +In these coordinates the lattice generated by \(f_1,e_2,e_3\) is +primitive and totally null. Pulling it back gives a rational +three-dimensional totally null subspace \(L_{\R}\) and its lattice +\(L=\Lambda\cap L_{\R}\), with an element \(f_0\in L\) such that +\begin{equation} +\label{eq:lattice-affine-slice} + l\cdot f_0=1. +\end{equation} +Consequently +\[ + \mathcal F=\{F\in L:l\cdot F=1\} +\] +is an affine lattice of rank two. Every \(F\in\mathcal F\) is primitive +in \(\Lambda\), since a nontrivial integral divisor of \(F\) would +divide \(l\cdot F=1\). It is also nonzero and null. Its projection to +\(P\) is nonzero by negative definiteness of \(P^\perp\). + +\smallskip +\noindent\emph{Only finitely many cosets can obstruct a direction.} +The set +\[ + K=\{r\in P^\perp:r^2\geq-2\} +\] +is compact. Suppose temporarily that \(F\in\mathcal F\), \(d\in\Lambda\), +and \(c>0\) satisfy the three conditions on the left side of +\Cref{eq:lattice-chamber-implication}. Then +\begin{equation} +\label{eq:lattice-bounded-residual} + r=d-cF\in P^\perp,\qquad + r^2=d^2-2c(d\cdot F)\geq-2, +\end{equation} +so \(r\in K\). + +Let \(q:\Lambda_{\R}\to\Lambda_{\R}/L_{\R}\) be the quotient map. +Because \(L_{\R}\) is rational and \(L\) is saturated, a basis of \(L\) +extends to an integral basis of \(\Lambda\); the remaining basis +vectors project to a lattice basis in the real quotient. Thus +\(q(\Lambda)\) is discrete and \(\ker(q|_\Lambda)=L\). +Since \(q(d)=q(r)\in q(K)\), only finitely many cosets \(d+L\) can occur +in \Cref{eq:lattice-bounded-residual}. This finite set is independent +of \(F\). + +\smallskip +\noindent\emph{Avoiding irrational points in a torus.} +Orthogonal projection restricts to an isomorphism +\[ + \pi:L_{\R}\longrightarrow P: +\] +its kernel is null and lies in the negative-definite space \(P^\perp\), +and both spaces have dimension three. Hence \(\pi(L)\) is a lattice +in \(P\). Each of the finitely many cosets just found determines one +point of +\[ + \mathbb T=P/\pi(L), +\] +because adding an element of \(L\) changes the projection by an +element of \(\pi(L)\). + +For a primitive \(F\in L\), let +\[ + \mathbb S_F=\{t\pi(F)+\pi(L):t\in\R\}\subset\mathbb T. +\] +Two such circles with different directions intersect only in torsion +points. Indeed, if +\(t\pi(F)-s\pi(F')\in\pi(L)\) and \(F,F'\) are not collinear, choose +an integral linear functional on \(L\) which vanishes on \(F\) and is +nonzero on \(F'\). Applying it to +\(tF-sF'\in L\) shows that \(s\in\Q\), so the common point is torsion. +In particular, any non-torsion point of \(\mathbb T\) lies on at most +one primitive direction circle. + +The elements of \(\mathcal F\) have distinct directions: two collinear +elements with \(l\)-pairing one are equal. Since \(\mathcal F\) is +infinite, we can choose \(F\in\mathcal F\) whose circle contains none +of the non-torsion points among the finitely many possible coset +points. + +For this \(F\), every \(d,c\) satisfying the hypotheses of +\Cref{eq:lattice-chamber-implication} gives a torsion point +\[ + d^++\pi(L)=c\pi(F)+\pi(L). +\] +There is therefore an integer \(k>0\) with \(kcF\in L\). Pairing with +\(l\) shows that \(kc\in\Z\), so \(c\in\Q\). It follows that +\(r=d-cF\in W_{\Q}\), and \Cref{eq:lattice-positive-vector} now gives +\begin{equation} +\label{eq:lattice-integral-coefficient} + c=l\cdot d\in\Z_{>0}. +\end{equation} +If \(m=d\cdot F<0\), then \(m\) is a negative integer and +\[ + r^2=d^2-2cm\geq-2+2c\geq0. +\] +Negative definiteness of \(P^\perp\) forces \(r=0\), which would imply +\(m=0\). This contradiction proves \(d\cdot F=0\), and completes the +proof. +\end{proof} + +Fix \(F\) as in \Cref{prop:chamber-class}. Make a constant orthogonal +change of the coefficient basis of the original triple and denote the +result by \((A,C,B)\), choosing +\begin{equation} +\label{eq:lattice-adapted-periods} + [B]=\frac{F^+}{\lVert F^+\rVert},\qquad + [A]\cdot F=[C]\cdot F=0,\qquad + \beta=[B]\cdot F=\lVert F^+\rVert>0. +\end{equation} +Here the norm is the positive intersection norm on \(P\). The three +classes remain orthonormal, and +\[ + V=[A]^\perp\cap[C]^\perp +\] +has signature \((1,b^-)\). The following conclusion is deliberately +stated for arbitrary later definite pairs with these two periods. + +\begin{corollary}[Curve-class alternatives] +\label{cor:curve-signs} +Let \(\widetilde A,\widetilde C\) be any smooth closed definite pair on +\(X\) with +\[ + [\widetilde A]=[A],\qquad [\widetilde C]=[C], +\] +and let \(J\) be either of its associated almost complex structures. +For every nonconstant irreducible closed \(J\)-holomorphic curve whose +class \(d\in\Lambda\) is nonzero, there is a real number \(c\ne0\) with +\(d^+=cF^+\). Exactly one of the following alternatives holds: +\begin{enumerate}[label=\textup{(\roman*)}] +\item \(d\cdot F\ne0\), and + \(\sgn(d\cdot F)=\sgn(c)=\sgn([B]\cdot d)\); +\item \(d=cF\) in \(\Lambda\), with \(c\in\Z\setminus\{0\}\). +\end{enumerate} +If \(J\) admits a closed taming form, every nonconstant irreducible closed +\(J\)-holomorphic curve has nonzero real class, so the nonzero-class +hypothesis is automatic. +\end{corollary} + +\begin{proof} +Represent the irreducible image by a somewhere-injective +\(J\)-holomorphic map \(u:\Sigma\to X\), with its covering +multiplicity factored out. The standard adjunction and singularity +theorems for simple curves in real dimension four give +\begin{equation} +\label{eq:lattice-adjunction} + d^2=c_1(TX,J)\cdot d+2g(\Sigma)-2+2\delta(u), + \qquad \delta(u)\in\Z_{\geq0}, +\end{equation} +where \(\delta(u)\) is the weighted singularity defect and is zero +precisely for an embedding; see +\cite[Theorem~2.8]{Wendl2020}, using the numbering of the cited +prepublication version throughout. Positivity of intersections of +distinct simple images is +\cite[Theorem~2.3 and Corollary~2.4]{Wendl2020}. +The critical points are isolated, and a simple curve is locally +injective, including at critical points +\cite[Propositions~B.26 and~B.41]{Wendl2020}. +These facts prevent accumulation of distinct double-point pairs at the +diagonal of the product of the source with itself. Local intersection +isolation, unique continuation, and simplicity prevent accumulation off +the diagonal. +Compactness therefore makes the critical and noninjective sets finite. +The definite pair trivializes the canonical bundle by +\Cref{lem:definite-pair}, so \(c_1(TX,J)=0\) for either sign of \(J\). +In particular, \(d^2\geq-2\). + +Both members of the pair vanish on complex lines. Integrating their +pullbacks gives \([A]\cdot d=[C]\cdot d=0\); hence +\[ + d^+=cF^+,\qquad [B]\cdot d=\beta c +\] +for a real number \(c\). +If \(c=0\), the nonzero integral class \(d\) lies in \(P^\perp\). +Evenness, negative definiteness, and \(d^2\geq-2\) force \(d^2=-2\). +When \(b_1=0\), this contradicts \Cref{prop:root-exclusion}. +When \(b_1=4\), \Cref{eq:lattice-adjunction} gives +\(g(\Sigma)=\delta(u)=0\), so \(d\) is the class of an embedded sphere. +This contradicts the vanishing of spherical real classes in +\Cref{prop:cup-product}. Thus \(c\ne0\). + +Suppose first that \(c>0\). By \Cref{prop:chamber-class}, +\(d\cdot F<0\) is impossible. If \(d\cdot F>0\), alternative +\textup{(i)} holds. If \(d\cdot F=0\), the same proposition gives +\(c\in\Z_{>0}\), so \(r=d-cF\) is integral and lies in \(P^\perp\). +Moreover \(r^2=d^2\geq-2\). Either \(r=0\), or negative definiteness +and evenness give \(r^2=d^2=-2\). The latter is excluded by +\Cref{prop:root-exclusion} when \(b_1=0\); when \(b_1=4\), it would +make the original curve \(u\) an embedded sphere by +\Cref{eq:lattice-adjunction}, again contradicting +\Cref{prop:cup-product}. Therefore \(d=cF\). + +If \(c<0\), apply the same lattice argument to \(-d\), whose square +is still at least \(-2\). This use of +\Cref{prop:chamber-class} is purely arithmetic and does not require +a \(J\)-holomorphic representative of \(-d\). It gives +\(d\cdot F<0\) or \(d=cF\) with \(c\in\Z_{<0}\). +Indeed, a nonzero residual in \(P^\perp\) would again have square +\(d^2=-2\). In the \(b_1=4\) case, adjunction is applied to the +original curve in class \(d\), making it an embedded sphere and giving +the same contradiction to \Cref{prop:cup-product}. +The two alternatives are disjoint because \(F^2=0\). + +Finally, the integral of a closed taming form over any nonconstant +curve is strictly positive. Its real homology class, and hence its +image in \(\Lambda\), cannot vanish. +\end{proof} + +\Needspace{12\baselineskip} +\begin{proposition}[No splitting in the fiber class] +\label{prop:nonsplitting} +Let \((\widetilde A,\widetilde C,\widetilde B)\) be any smooth closed +positive triple with the same three cohomology classes as \((A,C,B)\), +and let \(J\) be the structure associated to its first two members +and tamed by \(\widetilde B\). Then: +\begin{enumerate}[label=\textup{(\roman*)}] +\item Every positive \(J\)-holomorphic curve configuration whose + total class is \(F\) in \(\Lambda\) consists of one reduced + irreducible component of class \(F\). +\item Through every point of \(X\) there is such a component, and + distinct components of class \(F\) are disjoint. +\item Every simple parametrization of such a component is either an + embedded torus or a rational curve with total adjunction defect + one. If the rational parametrization is immersed, its image has + exactly one transverse positive double point and no other + singularity. +\end{enumerate} +These statements in particular hold after any exact perturbation of +the triple that preserves positivity. +\end{proposition} + +\begin{proof} +Write a positive configuration as +\[ + F=\sum_{i=1}^r n_i d_i\quad\hbox{in }\Lambda, + \qquad n_i\in\Z_{>0}, +\] +where the \(d_i\) are the classes of its distinct irreducible images. +Taming excludes zero real component classes. In the notation of +\Cref{cor:curve-signs}, +\[ + 0<\int_{d_i}\widetilde B=[B]\cdot d_i=\beta c_i, +\] +so \(c_i>0\). The corollary gives \(m_i=d_i\cdot F\geq0\), whereas +\[ + 0=F^2=\sum_{i=1}^r n_i m_i. +\] +Every \(m_i\) therefore vanishes. Again by the corollary, +\(d_i=c_iF\) with \(c_i\in\Z_{>0}\), and comparison of the total +classes yields +\begin{equation} +\label{eq:lattice-no-splitting} + \sum_{i=1}^r n_i c_i=1. +\end{equation} +There is exactly one summand, with \(n_1=c_1=1\). This proves +\textup{(i)}, including the exclusion of a nontrivial covering +multiplicity. + +Apply \Cref{thm:family-curves} to the present triple. Its period +plane is still \(P\), and \Cref{eq:lattice-adapted-periods} forces the +direction of the configuration to be precisely the one whose +anti-invariant plane is +\(\operatorname{span}(\widetilde A,\widetilde C)\) and whose tamer is +\(\widetilde B\). Thus the theorem gives a positive \(J\)-holomorphic +configuration in \(F\) through any prescribed point. Part +\textup{(i)} makes it a single reduced component. Two distinct +components of class \(F\) cannot meet: their intersection number is +\(F^2=0\), while any intersection of distinct simple images has +positive local intersection number. This proves \textup{(ii)}. + +For the remaining assertion, adjunction becomes +\[ + 0=F^2=2g(\Sigma)-2+2\delta(u), + \qquad\text{or equivalently}\qquad g(\Sigma)+\delta(u)=1. +\] +If \(g(\Sigma)=1\), the defect is zero and the curve is embedded. +If \(g(\Sigma)=0\), the total defect is one; critical points of the +parametrization have not yet been excluded. When the map is +immersed, its singular defect is the sum of positive intersection +multiplicities between distinct local branches. Total defect one +then forces exactly one pair of branches meeting with multiplicity +one, which is a transverse positive double point. A tangency has +larger multiplicity, and a point with three or more branches +contributes at least three. There can be no additional singularity. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/07-pencil.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/07-pencil.tex new file mode 100644 index 0000000000000000000000000000000000000000..3cd38ae5ddff75199bac244546c1416f48ab575b --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/07-pencil.tex @@ -0,0 +1,791 @@ +\section{A torus pencil with ordinary nodes}\label{sec:pencil} + +We keep the notation of \Cref{prop:nonsplitting}. In particular, curve +classes are identified with their Poincar\'e duals modulo torsion, and +$F$ is primitive, $F^2=0$, $[A]F=[C]F=0$, and $[B]F>0$. +The form $B$ will remain fixed throughout the construction. +There is already a unique curve image through every point. To turn +these images into the fibers of a smooth map, we first remove critical +points of their sphere parametrizations using exact pair variations. +The normal equation will then supply foliated neighborhoods of the +embedded tori. Finally, exact local changes near the remaining nodal +spheres will supply the corresponding charts at singular fibers. + +\begin{theorem}[The pencil]\label{thm:pencil} +There are smooth one-forms $a_t,c_t$, $0\leq t\leq1$, with +$a_0=c_0=0$, such that +\[ + A_t=A+\dd a_t,\qquad C_t=C+\dd c_t +\] +and $(A_t,C_t,B)$ is a positive closed triple for every $t$. +For the structure $J$ determined by $(A_1,C_1)$ and tamed by $B$, the +irreducible curves of class $F$ are precisely the fibers of a smooth +proper map +\[ + p_X:X\longrightarrow S +\] +to a closed connected oriented surface. Each regular fiber is an +embedded torus. The singular fibers, if any, are finitely many immersed +rational curves, each with one transverse positive double point. + +Every singular fiber has a neighborhood identified with a proper +holomorphic elliptic fibration $p_Y:Y\to\Delta$ with smooth total space, +a section, and one ordinary nodal central fiber. In this identification +there are constants $x_i\in\R$, $y_i\in\R\setminus\{0\}$ such that +\begin{equation}\label{eq:pencil-model-pair} + A_1=\operatorname{Re}\Sigma_i,\qquad + C_1=x_i\operatorname{Re}\Sigma_i+y_i\operatorname{Im}\Sigma_i. +\end{equation} +Here $\Sigma_i$ is a nowhere-zero holomorphic two-form, and the model +can be chosen with punctured-disk presentation +\begin{equation}\label{eq:pencil-model-periods} + z=a+\tau(s)b\pmod{\Z+\tau(s)\Z},\qquad + \tau(s)=\frac{\log s}{2\pi i},\qquad + \Sigma_i=h_i\,\dd s\wedge\dd z, + \quad h_i\in\C\setminus\{0\}. +\end{equation} +Both $A_1$ and $C_1$ vanish on every fiber. +\end{theorem} + +Only the qualitative existence of the holomorphic model in +\Cref{thm:nodal-model} is needed in this section. Its construction is +local and independent of the pencil; none of the estimates involving +the collapsing parameter is used here. + +\subsection{Curve compactness in the primitive class} + +We use closed pseudoholomorphic curve theory for smooth almost complex +structures tamed by a symplectic form. The particular inputs are +factorization of nonconstant maps into a simple map and a branched +cover \cite[Proposition~2.5.1]{McDuffSalamon2012}, positivity of +intersections in dimension four, and the adjunction formula with its +nonnegative weighted singularity defect +\cite[Theorem~2.3, Corollary~2.4, and Theorem~2.8]{Wendl2020}. +For compactness we use the genus-zero theory, including marked spheres +and their stable limits +\cite[Theorems~5.3.1 and~5.5.5]{McDuffSalamon2012}. +These results do not require regularity of the moduli space. Our later +genericity argument must instead work within the allowed exact +variations of the pair, with $B$ fixed. + +For every triple used below, \Cref{prop:nonsplitting} gives a curve of +class $F$ through every point, and every positive configuration of total +class $F$ consists of one simple image with multiplicity one. Two +different such images are disjoint: an intersection would contribute +positively to their intersection number $F^2=0$. A simple +parametrization $u:L\to X$ has +\begin{equation}\label{eq:pencil-adjunction} + g(L)+\delta(u)=1. +\end{equation} +Consequently it is an embedded torus or a rational curve of defect one. +The latter may initially have a critical point. The singularity +theorem for a simple curve implies that its critical and noninjective +points on the normalization form a finite set +\cite[Propositions~B.26 and~B.41 and Theorem~2.3]{Wendl2020}. +If it is immersed, +\Cref{eq:pencil-adjunction} says that it has exactly one double point, +and that its two branches meet transversely. + +\begin{lemma}[Compactness without bubbling]\label{lem:pencil-compactness} +Let $(A_\nu,C_\nu,B_\nu)$ converge smoothly to a positive closed triple, +with all three cohomology classes equal to $[A],[C],[B]$, respectively. +Let $u_\nu:S^2\to X$ be simple curves of class $F$ for the structures +determined by $(A_\nu,C_\nu)$ and tamed by $B_\nu$. After passage to a +subsequence and reparametrization, $u_\nu$ converges smoothly to a simple +sphere of class $F$. The same statement holds with one marked point. +In particular, the absence of critical points on all such spheres is +open in a sufficiently high finite differentiability topology. +\end{lemma} + +\begin{proof} +Let $B_\infty$ be the limiting third form. It tames the limiting +structure with a positive lower bound on the unit tangent bundle of a +fixed metric. Smooth convergence therefore makes this same fixed form +tame every sufficiently late structure. Its area on each sphere is +$[B_\infty]F=[B]F$. The fixed-tamer hypotheses and uniform energy +bound in the cited Gromov compactness theorem are consequently satisfied. +The nonconstant components in the stable +limit give a positive configuration of total class $F$ for the limiting +triple. By \Cref{prop:nonsplitting}, there is exactly one simple image +and its total multiplicity is one. In particular, the surviving map +is not a nontrivial cover. + +The domain of a genus-zero stable limit is a tree of spheres. With +only one nonconstant vertex, a nonempty tree of constant vertices would +have a constant leaf with at most one node and the one permitted mark. +It would have at most two special points and hence would be unstable. +There are therefore no constant components. Gromov convergence is now +smooth convergence on the whole sphere after reparametrization, and +the marked points converge as well. The same argument gives convergence +in the corresponding finite differentiability orders when the +backgrounds converge in a sufficiently high finite order. + +If the limiting triple had no critical spheres but nearby triples had +such spheres, mark a critical point on each. The conclusion just proved +would give a critical point on a limiting sphere. This contradiction +proves openness. This argument applies uniformly on any compact +parameter set of positive triples with the stipulated periods. +\end{proof} + +\subsection{Transversality using exact variations of the pair} + +The two closed pullback equations have two unavoidable integral +constraints. We include the coefficient sphere in the universal +problem to account for them explicitly. + +\begin{lemma}[Restricted first-jet transversality]\label{lem:pencil-jets} +An arbitrarily small smooth exact perturbation of $(A,C)$, with $B$ +fixed and the triple positive, makes every simple sphere in class $F$ +immersed. The same assertion holds for a path of such pairs, relative +to immersed endpoints. + +These perturbations may preserve any finite set of specified immersed +$F$-spheres that are common Lagrangians throughout the path. At an +endpoint they may also leave fixed closed model subdisks already +foliated by $F$-curves. +\end{lemma} + +\begin{proof} +We prove universal surjectivity in the allowed space of perturbations. +We reduce an annihilator to two constants arising from the pullback +periods and a distribution supported at the marked point. The elliptic +symbol and first-jet tests remove the point-supported part; variations +of the coefficient sphere remove the two constants. +Fix the complex structure $j$ on $S^2$. Write $v_0=(0,0,1)$ for the +coefficient direction of $B$. For $v$ close to $v_0$, a convenient +closed anti-invariant pair for the structure $J_v$ is +\begin{equation}\label{eq:pencil-coefficient-pair} + A_v=A-\frac{v_1}{v_3}B,\qquad + C_v=C-\frac{v_2}{v_3}B. +\end{equation} +For any map $u$ in class $F$, the two pullback periods are +\[ + \left(\int_{S^2}u^*A_v,\int_{S^2}u^*C_v\right) + =-[B]F\left(\frac{v_1}{v_3},\frac{v_2}{v_3}\right). +\] +Both pullbacks vanish when $u$ is $J_v$-holomorphic, so every +$F$-curve forces $v=v_0$. Exact changes of $A,C$ leave the two +periods unchanged, whereas varying $v$ supplies both period directions +in the universal linearization. Thus this auxiliary parameter removes +the period constraints without adding solutions in other coefficient +directions. We retain it in the section +\begin{equation}\label{eq:pencil-universal-section} + (u,z,v;A,C)\longmapsto + \left(\overline\partial_{j,J_v}u, + \partial_{j,J_v}u(z)\right). +\end{equation} +The second component is valued in the real rank-four bundle of complex +linear maps $T_zS^2\to T_{u(z)}X$. On the zero set of the first +component, its vanishing is exactly $\dd u(z)=0$. + +Use $W^{k,p}$ maps with $p>2$, $k\geq8$, and backgrounds of finite +class $C^r$, with $r\geq k+8$. The first target is $W^{k-1,p}$. +Sobolev embedding gives $W^{k,p}\subset C^{k-1,\alpha}$ for some +$\alpha>0$, so first-jet evaluation at the moving mark is at least +$C^{k-2}$, hence $C^6$. The background regularity gives the same +$C^6$ regularity for the composition maps in the first component. +Perturbing forms are $\dd\beta_A,\dd\beta_C$, +where the primitives belong to the $C^{r+1}$ closure of smooth +one-forms in the indicated support class. This gives separable +Banach spaces. We use the ordinary Banach bundle construction for +\Cref{eq:pencil-universal-section}; compare the first-jet framework in +\cite[Sections~2--3]{OhZhu2008}. The surjectivity argument for our +restricted perturbations is given next. + +Suppose $(\eta,\lambda)$ annihilates the derivative of +\Cref{eq:pencil-universal-section} at a simple critical sphere. +Here $\eta$ is a distribution dual to the Cauchy--Riemann target and +$\lambda$ is a covector on the jet target. Testing map variations +supported away from $z$ gives $D_u^*\eta=0$ there. Elliptic +regularity makes $\eta$ continuously differentiable away from $z$, +with the further finite regularity supplied by the coefficients. +The choice of $r$ gives more derivatives than are needed for all +distributional products and integrations by parts below. + +\emph{Removal of tangential coefficients.} +Although the index uses a fixed $j$, we may test every infinitesimal +variation $\dot j$ of the domain complex structure. On $S^2$ the map +$\xi\mapsto\mathcal L_\xi j$ is onto: its cokernel is +$H^{0,1}(TS^2)=0$, by the line-bundle surjectivity criterion since +$\deg TS^2=2>-2$ \cite[Theorem~3.23]{Wendl2014Lectures}. +Naturality under a domain diffeomorphism, with the +marked point moved by the inverse diffeomorphism, expresses the +$\dot j$ test as a combination of the already allowed map and mark +tests. The direct variation of the jet with respect to $j$ vanishes +at $z$, because $\dd u(z)=0$. Thus +\[ + \eta\left(\tfrac12J\dd u\,\dot j\right)=0 + \quad\text{for every }\dot j. +\] +At an immersion point these variations span the tangential +Cauchy--Riemann residuals. Hence $\eta$ annihilates that tangential +subbundle away from $z$. + +\emph{The two pullback coefficients.} +There are bundle maps $L_A,L_C$, with the regularity of the coefficients, +from Cauchy--Riemann residuals +to real two-forms on the domain such that, at a solution, +\begin{equation}\label{eq:pencil-pullback-linearization} + \delta(u^*A_v)=L_A\,\delta(\overline\partial u),\qquad + \delta(u^*C_v)=L_C\,\delta(\overline\partial u). +\end{equation} +These identities hold also for variations of the background pair and +of $v$. To see that they extend without loss of regularity at a critical point, choose +$j\partial_s=\partial_t$ and put +$e=(u_s+Ju_t)/2$. Anti-invariance gives the exact identity +\[ + A_v(u_s,u_t)=-2A_v(u_s,Je), +\] +and the same identity holds for $C_v$. Differentiation at $e=0$ +proves \Cref{eq:pencil-pullback-linearization}. In particular the +maps $L_A,L_C$ contain $\dd u$, not its inverse, and extend continuously +across every critical point. At an immersion point they vanish on +tangential residuals and identify the real two-dimensional normal +residual with the two pullback values: contraction with a nonzero +complex tangent vector by a nonzero complex volume form pairs the +complex normal line isomorphically with $\C$. + +Consequently, on the injective immersion locus away from $z$, there +are unique continuously differentiable real functions $f_A,f_C$ such that +\begin{equation}\label{eq:pencil-annihilator-coefficients} + \eta(e)=\int_{S^2}\bigl(f_A L_Ae+f_C L_Ce\bigr) +\end{equation} +for tests supported in that locus. Let $U$ be a relatively compact +injective disk in the locus. A neighborhood of its image can be +chosen to meet no other part of the curve. Restrictions of smooth +ambient one-forms supported in this neighborhood are dense in +$\Omega^1_c(U)$ in the $C^1$ topology. Indeed, the available regularity +of $u$ gives a compactly supported $C^2$ ambient extension of any such +source one-form in tubular coordinates. Approximate this extension +in $C^1$ by smooth ambient one-forms, keeping their supports in the +same isolated neighborhood. Their pullbacks converge in $C^1$. +Testing the variations $\dd\beta_A$ for these smooth primitives with +$u$ fixed and passing to the limit gives +\[ + \int_U f_A\,\dd\theta=0 + \quad\text{for every }\theta\in\Omega^1_c(U), +\] +since $f_A$ is continuous on the compact source support. +The jet contribution of this background variation is zero because +$\dd u(z)=0$. Integration by parts proves $\dd f_A=0$ on $U$; +independent variations of $C$ prove $\dd f_C=0$. The complement of +the finite exceptional set in $S^2$ is connected, so these functions +are global constants $k_A,k_C$ on that locus. + +Define on the whole source the distribution with continuous coefficients +\[ + \eta_0(e)=k_A\int_{S^2}L_Ae+k_C\int_{S^2}L_Ce. +\] +Continuity of the $L$'s and elliptic regularity away from $z$ show +that $\eta-\eta_0$ is supported at $z$, including when there are other +critical or double points. For every map variation $w$, closedness +of the two forms gives +\[ + \eta_0(D_uw) + =k_A\int_{S^2}\dd\bigl(u^*\iota_wA\bigr) + +k_C\int_{S^2}\dd\bigl(u^*\iota_wC\bigr)=0. +\] + +\emph{Elimination of the point-supported remainder.} +Set $R=\eta-\eta_0$. The annihilator equation for map variations is +\begin{equation}\label{eq:pencil-point-distribution} + D_u^*R=-\mathcal J_z^*\lambda, +\end{equation} +where $\mathcal J_z$ is the linearization of the complex-linear first +jet, with the mark fixed. The right side has distributional order at +most one and is supported at $z$. A point-supported distribution is +a finite sum of derivatives of the Dirac delta. If its largest +nonzero order were $m\geq1$, its homogeneous coefficient polynomial +$R_m(\xi)$ would satisfy +\[ + \sigma(D_u)^*(\xi)R_m(\xi)=0 + \quad(\xi\in T_z^*S^2). +\] +There are enough coefficient derivatives for this comparison: a +point-supported functional on $W^{k-1,p}$ in real dimension two has +order at most $k-2$ when $p>2$, while $r\geq k+8$. +The first-order Cauchy--Riemann symbol is invertible for every real +$\xi\ne0$, so this polynomial must vanish identically, a +contradiction. Hence $R=q\delta_z$ for a single covector $q$. +Test \Cref{eq:pencil-point-distribution} on variations with $w(z)=0$. +Since $\dd u(z)=0$, the values of $D_uw$ and $\mathcal J_zw$ at +$z$ are respectively the complex-antilinear and complex-linear parts +of $\nabla w(z)$. These parts can be specified independently by a +smooth variation supported near $z$. It follows that $q=0$ and +$\lambda=0$. + +Finally, variation of $v$ in \Cref{eq:pencil-coefficient-pair} gives +\begin{equation}\label{eq:pencil-period-cokernel} + \delta\left(\int_F A_v,\int_F C_v\right) + =-[B]F\,(\dot v_1,\dot v_2). +\end{equation} +This map is onto $\R^2$. Applying the remaining annihilator +$\eta_0$ to these tests yields $k_A=k_C=0$. Thus the universal +derivative is onto. Its range is closed: the map-and-jet operator +with background fixed is Fredholm and has finite-codimensional +closed range, and adding parameter directions preserves this +property. + +\emph{Index and allowed genericity.} +The parametrized sphere operator has real index $4$, since +$c_1(u^*TX)=0$ \cite[Theorem~3.22]{Wendl2014Lectures}. +Adding $v$ and the mark and imposing the first-jet +constraint gives +\begin{equation}\label{eq:pencil-critical-index} + 4+2+2-4=4. +\end{equation} +For a path, allowing its parameter adds one and gives index $5$. +The projection from the universal zero set to the space of perturbing +primitives is therefore Fredholm of index $4$, or $5$ for paths. +The projection is $C^6$, and $6>5$, so Sard--Smale applies with the +chosen regularities \cite[Theorem~1.3]{Smale1965}. For a regular +parameter its fiber would be a manifold of that dimension. But the +six-dimensional group $\operatorname{PSL}(2,\C)$ acts freely on +simple parametrized spheres, with the marked point transformed +contragrediently, and preserves the fiber. Freeness follows because +a reparametrization fixing a simple map fixes its injective locus and +hence is the identity. A manifold of dimension $4$ or $5$ cannot +contain this six-dimensional orbit. The fiber is empty. + +For a path, the local perturbations just used may be multiplied by +arbitrary bumps in the path parameter, supported away from its +endpoints. If finitely many immersed $F$-spheres are retained, a +critical simple $F$-sphere cannot have one of those images. It is +therefore disjoint from all of them by positivity of intersections, +so every injective disk needed in the proof still admits the allowed +local variations. Use the closure of smooth primitives supported +off the retained images; this preserves them exactly without requiring +a fixed forbidden tubular neighborhood. At a fixed model subdisk, +every point already lies on a model $F$-curve. A competing critical +sphere is disjoint from the whole subdisk for the same reason. The +endpoint assertion follows with perturbations supported in its +complement. + +There are countably many map-space charts and homotopy components, +so the regular parameter choices can be made simultaneously for all +of them. The conclusions are open by \Cref{lem:pencil-compactness}. +Approximation in the defining closures by smooth primitives therefore +gives smooth perturbations with the same conclusion and the same +support restrictions. For paths with immersed endpoints, openness +allows fixed small parameter collars at both ends. Smallness ensures +positivity with $B$ fixed; the straight segment realizes the initial +small perturbation by an exact positive-pair path. +\end{proof} + +\Needspace{13\baselineskip} +\subsection{Deforming immersed curves} + +The identification of normal deformations with one-forms follows the +approach of McLean's deformation theory for compact special Lagrangians +\cite[Theorem~3.6 and Corollary~3.9]{McLean1998}. +Here the definite pair leads to a variable-coefficient operator, which +we solve directly. + +\begin{lemma}[The normal operator]\label{lem:pencil-normal} +Let $u:L\to X$ be a closed connected common Lagrangian immersion for a definite +closed pair $(A,C)$, with the complex orientation chosen by $B$. +Nearby common Lagrangian immersions represented as normal graphs over +$u$ form a smooth manifold of real dimension $b_1(L)$. +Its linearized kernel is naturally isomorphic to $H^1(L;\R)$. +If $u$ is simple, this also describes the local unparametrized moduli. +These descriptions hold with smoothly varying pairs whose periods on +$[u(L)]$ remain zero. + +An immersed $F$-sphere is isolated and continues uniquely under small +pair variations. Near an embedded $F$-torus the nearby $F$-curves +form a smooth foliation of an open neighborhood. +\end{lemma} + +\begin{proof} +Represent nearby immersions by normal graphs over $u$, removing the +infinitesimal reparametrizations. If $u$ is simple, its stabilizer under +reparametrization is trivial: an automorphism fixing the map fixes its +injective locus and hence is the identity. The normal-graph slice then +also parametrizes the local unparametrized moduli. For a multiply +covered immersion we make the smoothness assertion only for this slice. +The symplectic form $A$ identifies the real normal bundle with $T^*L$ +by $w\mapsto\alpha=u^*\iota_wA$. Write along the source +\begin{equation}\label{eq:pencil-volume-normalization} + H=\frac{C-xA}{y},\qquad \Omega=A+iH,\qquad + x=\frac{A\wedge C}{A^2},\qquad + y^2=\frac{C^2}{A^2}-x^2, +\end{equation} +where the nonzero sign of $y$ is the one giving $J$ tamed by $B$. +Let $*_L$ be the star on one-forms for the induced conformal structure +and orientation, with $*_L\alpha=-\alpha\circ j$. +The complex volume identity gives +\[ + u^*\iota_wC=x\alpha+y*_L\alpha. +\] +Cartan's formula now gives the normal derivative +\begin{equation}\label{eq:pencil-normal-operator} + \mathcal D\alpha + =\left(\dd\alpha,\dd(x\alpha+y*_L\alpha)\right). +\end{equation} +The nonlinear pullbacks and their derivatives take values in pairs +of exact two-forms: their integrals are the two fixed zero periods. + +For completeness we solve \Cref{eq:pencil-normal-operator}. Given +exact two-forms $\zeta_1,\zeta_2$, choose $\alpha_0$ with +$\dd\alpha_0=\zeta_1$. Adding $\dd f$ changes only the second +equation, by +\begin{equation}\label{eq:pencil-scalar-operator} + \mathcal P f + =\dd(x\dd f+y*_L\dd f) + =\dd x\wedge\dd f+\dd(y*_L\dd f). +\end{equation} +After division by a positive area form its principal part is the +nonzero signed multiple $y\Delta f$ of the scalar Laplacian. +Its sign is constant on connected $L$, it has no zeroth-order term, +and the strong maximum principle shows that its kernel consists exactly +of constants \cite[Chapter~1, Theorem~1.6]{KiselevRoquejoffreRyzhik2012}. +Here one first adjusts the overall sign of the operator and then applies +the principle at a maximum on the connected closed surface. +It has index zero, by homotopy through scalar elliptic operators to the +signed Laplacian, with the sign of $y$ held fixed; the Fredholm index is +constant along this homotopy +\cite[Section~7, Propositions~7.3--7.4]{TaylorFunctionalNotes}. +Its image has integral zero by Stokes' theorem. Its cokernel has +dimension one, so its range is exactly the integral-zero two-forms. +We can therefore solve +\[ + \mathcal P f=\zeta_2-\dd(x\alpha_0+y*_L\alpha_0). +\] +This proves surjectivity onto the asserted target, with bounded +elliptic right inverses in the usual Sobolev or H\"older spaces. + +If $\mathcal D\alpha=0$, then $\alpha$ is closed. Every class in +$H^1(L;\R)$ has a unique representative of this kind: start with any +closed representative and solve \Cref{eq:pencil-scalar-operator} for +an exact correction. Uniqueness follows from the constant kernel of +$\mathcal P$. Thus +\begin{equation}\label{eq:pencil-kernel-cohomology} + \ker\mathcal D\longrightarrow H^1(L;\R),\qquad + \alpha\longmapsto[\alpha] +\end{equation} +is an isomorphism. The implicit function theorem applied to the +pullback equations, with exact two-forms as target, proves the first +assertion and its parameter version. For $L=S^2$ the derivative is +an isomorphism, giving isolation and unique continuation. + +For an embedded torus, the kernel has dimension two. In complex +normal notation its elements solve the real-linear normal +Cauchy--Riemann equation. Indeed, the normal projection of a +linearized map equation is unchanged by variation of the source +complex structure, and the two maps in +\Cref{eq:pencil-pullback-linearization} identify that normal equation +with \Cref{eq:pencil-normal-operator}. The complex normal line has +degree $F^2=0$. The similarity principle says that a nonzero solution +has isolated positive zeros, whose total number with multiplicity is +the degree; in the closed case this is the zero formula of +\cite[Section~2.2, Equation~(2.7)]{Wendl2010}. Therefore every nonzero +kernel section is nowhere vanishing. Evaluation at each point of the +torus is consequently an isomorphism from the two-dimensional kernel +to its real normal plane. + +Let $u_q$, $q\in\R^2$ small, be the family supplied by the implicit +function theorem. The derivative of $(x,q)\mapsto u_q(x)$ is an +isomorphism at every $(x,0)$. Compactness of the torus gives a common +small parameter disk on which this is a local diffeomorphism. The +individual maps remain embeddings; different images cannot meet by +$F^2=0$ and positivity. The immersion slice distinguishes the images, +so evaluation is injective after shrinking the disk. It is thus a +diffeomorphism onto an open tube, foliated by the $u_q(L)$. +\end{proof} + +\begin{corollary}[The number of nodes along a path] +\label{cor:pencil-node-count} +If all $F$-spheres for a triple are immersed, there are finitely many +of them. Along a compact smooth path of triples with the original +periods and with all $F$-spheres immersed, their number is constant. +\end{corollary} + +\begin{proof} +The unparametrized sphere space is compact by +\Cref{lem:pencil-compactness} and discrete by +\Cref{lem:pencil-normal}, so it is finite. Over a path, the total +space of such spheres is compact and, by the parameter version of +\Cref{lem:pencil-normal}, its projection to the path interval is a +local diffeomorphism, also in relative half-interval charts at the +endpoints. Hence it is a finite covering of the interval. Equivalently, +each isolated sphere has a unique local continuation, and compactness +prevents any additional sphere from entering those local descriptions. +The number is constant. +\end{proof} + +\subsection{Exact insertion of holomorphic nodal neighborhoods} + +\begin{lemma}[Insertion while retaining the sphere] +\label{lem:pencil-insertion} +Let $K$ be the image of an immersed $F$-sphere with one transverse +positive double point. Inside an arbitrarily small neighborhood of +$K$, an exact path of the pair, with $B$ fixed, makes the pair equal +near $K$ to \Cref{eq:pencil-model-pair} for a model satisfying +\Cref{eq:pencil-model-periods}. The triple stays positive and the +same immersed sphere is a common Lagrangian throughout. The +construction may be performed in disjoint neighborhoods of finitely +many such spheres. +\end{lemma} + +\begin{proof} +Denote the node by $p$ and its two preimages on the normalization by +$p_+,p_-$. We first identify the model with a neighborhood of $K$ +so that straight interpolation of the two pairs stays positive. +We then localize this interpolation by two exact changes. At the node, +equality of the forms as tensors makes the radial cutoff correction small. Along +the rest of the sphere, the difference of the pairs need not be small; +a logarithmic transverse cutoff makes its cutoff error small while +retaining the positive interpolation. + +Use $x,y,\Omega$ from +\Cref{eq:pencil-volume-normalization} on a neighborhood of $K$. +Choose the qualitative model of \Cref{thm:nodal-model}; write its +normalization as $u_Y:S^2\to Y$ with node preimages $q_+,q_-$. +Uniformization supplies a biholomorphism $f$ of the normalized +spheres carrying $p_\pm$ to $q_\pm$. + +\emph{Matching the derivative and the complex volume.} +At $p$, the two complex tangent lines of the branches are transverse. +Their prescribed tangent maps, obtained from $f$, define one complex +linear isomorphism +\[ + T:T_pX\longrightarrow T_{p_Y}Y. +\] +Choose the nonzero complex scale $h$ of the model volume so that +$T^*\Sigma_Y=\Omega(p)$. Along each smooth point of the +normalization, the tangent map and equality of complex volumes +determine the map on the normal quotient. More explicitly, a +nonvanishing complex volume identifies the complex normal line with +the dual of the tangent line. The prescribed tangent map therefore +gives the required normal-line isomorphism globally. The possible +lifts to a map of the two ambient complex plane bundles form an +affine bundle with fiber the complex-linear maps from the normal +line to the target tangent line. A smooth section exists by +partitions of unity. Its values at both preimages of the node can +be chosen to equal the single map $T$. + +These prescribed first derivatives need only be realized to arbitrary +accuracy along $K$, with exact realization at the node. Here is a +construction that addresses the crossing. First straighten the two +transverse branches by smooth ambient charts in the source and target. +Writing the restrictions of $f$ in these charts as $f_+(u)$ and +$f_-(v)$, the product map +$\Phi_0(u,v)=(f_+(u),f_-(v))$ is a genuine local diffeomorphism +carrying the branches by $f$ and having derivative $T$ at $p$. +Its derivative along either branch +and the prescribed complex-linear derivative have the same tangent +restriction and agree at $p$. They are consequently arbitrarily +close on sufficiently short branch collars. On those collars +interpolate their normal derivative data, keeping $\Phi_0$ near +$p$ and the prescribed data away from the collars. The interpolated +derivatives remain invertible when the collars are sufficiently +short. + +Away from the crossing the normal tubular construction realizes these +jets: in normal coordinates send the zero section by $f$ and use the +prescribed normal derivative on the normal coordinate. This can be +patched to $\Phi_0$ where the jets already agree; a partition in +normal coordinates preserves the prescribed first jets. Shrinking +the tubes gives a diffeomorphism $\Phi$ of neighborhoods of the nodal +images. To check injectivity, any hypothetical pair of coincident +images in arbitrarily shrinking neighborhoods would limit to two +points of $K$ with the same image. The map on the nodal image is a +homeomorphism, and the map is a local diffeomorphism at every point, +including the crossing. These facts rule out such a pair. +We have arranged that +\begin{equation}\label{eq:pencil-volume-matching} + \Phi^*\Sigma_Y=\Omega\quad\text{at }p, + \qquad + \Phi^*\Sigma_Y\text{ is arbitrarily close to }\Omega + \quad\text{along }K. +\end{equation} +Both volumes vanish when pulled back to the normalization. + +Put $x_p=x(p)$, $y_p=y(p)$ and set on this neighborhood +\[ + A_*=\operatorname{Re}\Phi^*\Sigma_Y,\qquad + C_*=x_p\operatorname{Re}\Phi^*\Sigma_Y + +y_p\operatorname{Im}\Phi^*\Sigma_Y. +\] +These forms are closed. If the volume matching along $K$ were exact, +their pointwise relation to the old pair would be +\begin{equation}\label{eq:pencil-triangular-matching} + A_*=A,\qquad + C_*=\left(x_p-\frac{y_px}{y}\right)A+\frac{y_p}{y}C. +\end{equation} +The ratio $y_p/y$ is positive. Thus every straight interpolation of +the two pairs in \Cref{eq:pencil-triangular-matching} has the same +positive anti-invariant plane and remains in the same component +relative to $B$. In particular its triple Gram matrix has a uniform +positive lower bound along $K$, with the interpolation parameter in +$[0,1]$. Choose the approximation in +\Cref{eq:pencil-volume-matching} small compared with this bound. +The actual straight interpolation between $(A,C)$ and $(A_*,C_*)$ +is then positive along $K$, and on a smaller neighborhood by +compactness and continuity. +The biholomorphism $f$ uses the complex orientation selected by $B$, +so $B$ is positive on the transported model's complex tangent line at +each smooth point of $K$. Together with positivity of the triple, +this selects the model complex structure as the sign tamed by $B$. +That sign persists on a smaller connected model neighborhood, +independently of whether $y_p$ is positive or negative. + +\emph{The first exact correction, at the crossing.} +For either closed difference $\xi=A_*-A$ or $\xi=C_*-C$, one has +$\xi(p)=0$ as a tensor, and the pullback of $\xi$ to each branch +vanishes. In a crossing chart with $p=0$, the radial homotopy +primitive is +\begin{equation}\label{eq:pencil-radial-primitive} + \beta_z(v)=\int_0^1 t\,\xi_{tz}(z,v)\,\dd t, + \qquad \dd\beta=\xi. +\end{equation} +It satisfies $|\beta(z)|\leq C|z|^2$. Since radial contraction +preserves each straightened branch, $\beta$ pulls back to zero on +both branches. Choose $\chi_r$ equal to one on the ball of radius +$r$, supported in the ball of radius $2r$, and satisfying +$|\dd\chi_r|\leq C/r$. The exact change +$\dd(\chi_r\beta)$ has norm $O(r)$: the two terms +$\chi_r\xi$ and $\dd\chi_r\wedge\beta$ both have that bound. +For sufficiently small $r$ its scalar multiples preserve positivity +with $B$ fixed. They preserve the common Lagrangian sphere because +the primitive restricts to zero there. Do this for both differences. +The resulting pair $(A',C')$ equals $(A_*,C_*)$ on the ball of +radius $r$ and differs from $(A,C)$ by $O(r)$ near that ball. + +\emph{The exact correction along the rest of the sphere.} +The remaining differences $\xi'=A_*-A'$ and $\xi'=C_*-C'$ are +closed, vanish on a neighborhood of the crossing, and pull back to +zero on the source. Outside a smaller crossing ball, take normal +tubes of the embedded part of the source. Normal contraction +$h_t(s,n)=(s,tn)$ gives a relative primitive $\beta'$ satisfying +\begin{equation}\label{eq:pencil-tubular-primitive} + \dd\beta'=\xi',\qquad + |\beta'|\leq C d, + \qquad d=|n|. +\end{equation} +This is the homotopy identity +$\dd\beta'=\xi'-\pi^*u^*\xi'$. Choose the tubes in the inner +collars so that the contraction stays where $\xi'=0$. Then +$\beta'=0$ on those collars and extends by zero into the crossing +ball. The two branch tubes are disjoint outside that ball after +shrinking. This gives a single smooth relative primitive on the +required tubular region, without a compatibility condition left at +the node. + +Choose a transverse cutoff equal to one for $d\leq r_{\rm in}$ and +zero for $d\geq r_{\rm out}$, where the outer tube is already small. +Using a fixed smooth function of +$\log(d/r_{\rm in})/\log(r_{\rm out}/r_{\rm in})$ gives +\begin{equation}\label{eq:pencil-log-cutoff} + d\,|\dd\chi|\leq + \frac{C}{\log(r_{\rm out}/r_{\rm in})}. +\end{equation} +The inner radius can be made sufficiently small that the right +side is any prescribed $\eta>0$. For $0\leq t\leq1$, the exact +change is +\[ + A'+t\dd(\chi\beta'_A) + =A'+t\chi(A_*-A')+t\dd\chi\wedge\beta'_A, +\] +and likewise for $C'$. The last terms have norm at most $C\eta$ +by \Cref{eq:pencil-tubular-primitive,eq:pencil-log-cutoff}. +The first terms are pointwise straight interpolation with parameter +$t\chi\in[0,1]$. Taking $r$ small in the first correction preserves +the positive margin already established along $K$. Shrinking the +outer tubes preserves that margin throughout them. Finally take +$\eta$ small compared with the margin. These choices prove +positivity along the entire exact path. + +The final pair agrees with the model on a neighborhood of the whole +nodal image, and its primitives have compact support in the original +chosen neighborhood. A sufficiently small complete model subdisk +lies in this region: properness of $p_Y$ and compactness of its +central fiber imply that $p_Y^{-1}(\Delta_\rho)$ lies in any chosen +neighborhood of that fiber when $\rho$ is sufficiently small. +Every modification restricts to zero on the normalization, so the +same sphere is retained. Disjoint supports prove the last assertion. +\end{proof} + +\subsection{Retaining the nodes and forming the base} + +\begin{proof}[Proof of \Cref{thm:pencil}] +First apply \Cref{lem:pencil-jets} to make a small exact perturbation +with $B$ fixed so that all $F$-spheres are immersed. Connect it to +the starting pair by a small straight segment of positive pairs. +There is no assertion about immersion along this initial segment. +By \Cref{cor:pencil-node-count} the perturbed pair has finitely many +nodal spheres $K_1,\ldots,K_N$, all disjoint. If $N=0$, the torus +argument below already applies. + +For $N>0$, use \Cref{lem:pencil-insertion} at all the $K_i$, keeping +$B$ fixed and retaining every $K_i$ along the resulting path. +Choose smaller closed model subdisks at its endpoint. Make the +endpoint generic by an arbitrarily small exact perturbation outside +those subdisks. The relative assertion of \Cref{lem:pencil-jets} +applies because any competing $F$-curve is disjoint from every +model fiber. The endpoint now has no critical spheres, and the +smaller model neighborhoods remain unchanged. Extend this endpoint +perturbation a short distance into the path using a parameter cutoff; +all retained $K_i$ are still common Lagrangians. + +The two ends of this latter path have only immersed spheres. Apply +the path version of \Cref{lem:pencil-jets}, keeping its endpoints +and every $K_i$ fixed, to remove all critical spheres from its +interior. The resulting smooth path stays positive with $B$ fixed. +By \Cref{cor:pencil-node-count}, its endpoints have the same number +of nodal spheres. All the original $N$ spheres were retained, so +they exhaust the endpoint spheres. This argument is needed to +exclude additional immersed spheres outside the inserted model +regions. + +We now work at the endpoint. By \Cref{prop:nonsplitting}, every +point of $X$ lies on a unique simple $F$-curve image. Each is an +embedded torus or one of the $K_i$. Define $S$ as the set of these +images, with quotient map $p_X$. For a torus, +\Cref{lem:pencil-normal} supplies an open tube diffeomorphic to +$T^2\times\Delta$. It is saturated: any other $F$-curve meeting +a torus in this tube must equal it by intersection positivity. +For a nodal sphere choose an open model subdisk. Its fibers also +represent $F$, since they are homologous to its central fiber. +The same argument makes this open subset saturated. Its quotient +is its base disk, since the proper holomorphic model projection is +open and has connected fibers. Thus the torus tubes and the model +subdisks give disk neighborhoods in $S$ and cover it. + +These saturated neighborhoods can be chosen arbitrarily small +around an entire fiber. For tori this follows by shrinking the +parameter disk in the tube; for nodes it follows from properness of +the model projection. Two distinct fibers are disjoint compact +subsets of $X$, so they admit disjoint ambient neighborhoods. +Choose saturated neighborhoods inside them. Their images are +disjoint open neighborhoods of the two points of $S$. The quotient +is therefore Hausdorff. + +The disk charts have smooth transition maps. To verify this even +at a singular value, choose a smooth point of the corresponding +fiber. Near that point both local quotient projections are smooth +submersions with the same fibers. A local section of either +submersion expresses the other base coordinate as a smooth function +of it; interchanging the two gives its smooth inverse. The charts +therefore make $S$ a smooth surface without boundary and $p_X$ a +smooth map. They also make $p_X$ open. Since $X$ is second +countable, images of a countable open basis under this open +surjection form a countable basis for $S$. Compactness and +connectedness of $X$ give compactness and connectedness of $S$. + +On regular fibers use their complex orientation and the complex +orientation of the normal plane to orient the base. Evaluation +along a connected torus preserves this choice, and the holomorphic +model gives the same orientation on its regular part. Hence the +orientation extends across each singular value. The map is proper +because its domain is compact and its base is Hausdorff. Its +singularities are precisely the ordinary holomorphic nodes of the +models (locally $s=z_1z_2$ after complex coordinate changes). +The pair vanishes on every fiber by construction, and the prescribed +model identities hold on the unchanged smaller neighborhoods. + +All paths used above consist of exact changes to $A,C$ and keep +$B$ fixed. Their finitely many joins can be made smooth by +reparametrizations constant to infinite order at the join times. +Concatenating them proves the theorem. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/08-local-models.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/08-local-models.tex new file mode 100644 index 0000000000000000000000000000000000000000..7b30bf47a60b64a3dabe1bc0ebe12bbb7e47d568 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/08-local-models.tex @@ -0,0 +1,677 @@ +\section{The collapsing nodal model}\label{sec:local-models} + +We construct a holomorphic elliptic fibration over a disk with one +ordinary node, together with a fixed holomorphic symplectic form and +K\"ahler forms of decreasing fiber area. This local construction +supplies the model used in the insertion argument of +\Cref{lem:pencil-insertion}; it starts independently of the global +pencil. We use the Gibbons--Hawking ansatz +\cite{GibbonsHawking1978} in the periodic form of Ooguri--Vafa +\cite{OoguriVafa1996}, with the collapsing and semi-flat comparison +developed by Gross--Wilson \cite[Section~3]{GrossWilson2000}. + +There are two further requirements for its later use. The holomorphic +family and its symplectic form must stay fixed as the area decreases, +and the local K\"ahler form must have the same two annular periods as +its translation-invariant approximation. We first normalize the +periodic potential and complete its node. We then identify the +completed complex families and prove the annular comparison and +intrinsic metric estimates needed in \Cref{sec:auxiliary-volume}. + +Write \(\Delta_R=\{s\in\C:|s|0\) there is a +K\"ahler form \(D^{\mathrm{loc}}_\epsilon\) on \(Y\), with metric +\(g_\epsilon\), such that +\begin{equation}\label{eq:nodal-exact-identities} + \begin{gathered} + D^{\mathrm{loc}}_\epsilon\wedge\operatorname{Re}\Sigma + =D^{\mathrm{loc}}_\epsilon\wedge\operatorname{Im}\Sigma=0,\qquad + (D^{\mathrm{loc}}_\epsilon)^2=(\operatorname{Re}\Sigma)^2,\\ + \int_{p^{-1}(s)}D^{\mathrm{loc}}_\epsilon=\epsilon\quad(s\ne0). + \end{gathered} +\end{equation} +These three forms are parallel, mutually orthogonal and of equal +square, and \(\vol_{g_\epsilon}=(\operatorname{Re}\Sigma)^2/2\). +Moreover: +\begin{enumerate}[label=\textup{(\roman*)}] +\item On each fixed closed annulus +\(K=\{r_-\le |s|\le r_+\}\subset\Delta_R\setminus\{0\}\), the form +\begin{equation}\label{eq:nodal-semiflat} + D^{\mathrm{sf}}_\epsilon + =\epsilon\,da\wedge db+ + \frac{|h|^2}{\epsilon}\tau_2(s)\,dx_1\wedge dx_2, + \qquad s=x_1+ix_2, +\end{equation} +is well-defined and closed. For every integer \(m\ge0\), in fixed +smooth charts on this annular bundle, +\begin{equation}\label{eq:nodal-exponential-estimate} + \|D^{\mathrm{loc}}_\epsilon-D^{\mathrm{sf}}_\epsilon\|_{C^m} + \le C_m e^{-c_m/\epsilon}, + \qquad C_m,c_m>0. +\end{equation} +\item These forms have the same real cohomology class on \(p^{-1}(K)\). +Their periods are \(\epsilon\) on a fiber and zero on the torus +sweeping the invariant \(a\)-circle at \(b=0\) around the base annulus. +That swept torus bounds in \(Y\). +\item On \(p^{-1}(\overline{\Delta_r})\), for every fixed \(m\) there +is a finite coordinate cover with smaller concentric domains still +covering this set, such that the number of charts, the reciprocals +of their radii and interior margins, and the \(C^m\) bounds for +the metric coefficients and their inverses are at most +\(C_m\epsilon^{-N_m}\). All intrinsic curvature derivatives of +fixed finite order have polynomial bounds as well. +\end{enumerate} +All disks, annuli and \(h\) are fixed before \(\epsilon\) tends to zero. +The charts in \textup{(iii)} may depend on \(\epsilon\). +\end{theorem} + +Thus, for fixed real \(x_0,y_0\), \(y_0\ne0\), the pair +\[ + A=\operatorname{Re}\Sigma,\qquad + C=x_0\operatorname{Re}\Sigma+y_0\operatorname{Im}\Sigma +\] +is orthogonal to \(D^{\mathrm{loc}}_\epsilon\). Its span with this +form is positive, and its metric in volume \(A^2/2\) is \(g_\epsilon\). +No normalization of \(A,C\) relative to one another is required. + +\subsection{The periodic potential} + +The normalization follows the periodic-potential construction in +\cite[Lemma~3.1 and Proposition~3.2]{GrossWilson2000}. +First take \(h=1\), and denote the area parameter by \(\rho\). +On \((\Delta_R\times\R/\rho\Z)\setminus\{(0,0)\}\) use coordinates +\((x_1,x_2,t)\). +For a precise choice of the additive constant define +\begin{equation}\label{eq:nodal-unit-potential} +\begin{split} + \mathcal V(u,v)=\frac{1}{4\pi}\bigg\{ + &\frac{1}{\sqrt{|v|^2+u^2}}\\ + &+\sum_{n=1}^\infty + \left(\frac{1}{\sqrt{|v|^2+(u+n)^2}}+ + \frac{1}{\sqrt{|v|^2+(u-n)^2}}-\frac2n\right)\bigg\}. +\end{split} +\end{equation} +The paired summands are \(O(n^{-3})\) locally, with locally uniformly +convergent differentiated series away from the poles. The resulting +function is smooth, harmonic, and periodic with period one in \(u\). +Its mean is +\begin{equation}\label{eq:nodal-unit-mean} + \int_{-1/2}^{1/2}\mathcal V(u,v)\,du + =-\frac{\log|v|}{2\pi} + +\frac{\log2-\gamma_{\mathrm E}}{2\pi}, +\end{equation} +where \(\gamma_{\mathrm E}\) is Euler's constant. Indeed, the integral +of the sum truncated at \(|n|\le N\), before the factor \(1/(4\pi)\), +is +\[ + 2\operatorname{arsinh}\frac{N+1/2}{|v|} + -2\sum_{n=1}^N\frac1n + \longrightarrow 2\log(2/|v|)-2\gamma_{\mathrm E}. +\] +Consequently +\begin{equation}\label{eq:nodal-scaled-potential} + V_\rho(s,t)=\frac1\rho + \left\{\mathcal V\left(\frac t\rho,\frac s\rho\right) + -\frac{\log\rho}{2\pi} + +\frac{\gamma_{\mathrm E}-\log2}{2\pi}\right\} +\end{equation} +has a positive unit monopole \(1/(4\pi\sqrt{|s|^2+t^2})\), and +\begin{equation}\label{eq:nodal-mean} + \frac1\rho\int_0^\rho V_\rho(s,t)\,dt + =\frac{\tau_2(s)}{\rho}. +\end{equation} +The term \(-(\log\rho)/(2\pi)\) in the scaled potential is essential +for keeping the periods fixed. + +For \(s\ne0\), its Fourier expansion is +\begin{equation}\label{eq:nodal-fourier} + V_\rho(s,t)=\frac{\tau_2(s)}{\rho} + +\frac1{2\pi\rho}\sum_{n\ne0}e^{2\pi int/\rho} + K_0\left(\frac{2\pi|ns|}{\rho}\right). +\end{equation} +It follows by the Gaussian integral representation of the Newton +kernel and integration in the periodic variable. The nonzero +Fourier coefficient is proportional to +\[ + \int_0^\infty \ell^{-1} + \exp\left(-\ell|s/\rho|^2-\frac{\pi^2n^2}{\ell}\right)d\ell. +\] +Alternatively \(K_0(a)=\int_0^\infty e^{-a\cosh u}\,du\). +These representations, including their differentiated versions, give +for each fixed annulus and each \(m\) +\begin{equation}\label{eq:nodal-potential-tail} + \left\|V_\rho-\frac{\tau_2}{\rho}\right\|_{C^m + (\{r_-\le|s|\le r_+\}\times\R/\rho\Z)} + \le C_m\rho^{-N_m}e^{-2\pi r_-/\rho}. +\end{equation} +Derivatives in \(t\) are taken on periodic local lifts. +Differentiation introduces powers of \(\rho^{-1}\) and \(|n|\); +the exponential decay makes the corresponding sums convergent. +Any smaller positive exponential rate absorbs the polynomial +prefactors. + +The function \(V_\rho\) is positive on the whole punctured solid +torus when \(\rho\) is sufficiently small. Choose \(L>1\) large +enough that the Fourier tail of \(\rho V_\rho\) on +\(|s|/\rho\ge L\) is less than \(-(\log R)/(4\pi)\). +Its mean is at least \(-(\log R)/(2\pi)>0\), proving positivity +there. On the remaining compact scaled region \(|s|/\rho\le L\), +the function \(\mathcal V\) is bounded below, including near its +positive pole. The additive term \(-(\log\rho)/(2\pi)\) then +proves positivity there also. This argument gives a positive lower +bound for \(\rho V_\rho\) off a fixed scaled pole neighborhood. + +\subsection{The metric and the smooth nodal fiber} + +The Euclidean Hodge star uses the orientation +\(dx_1\wedge dx_2\wedge dt\). +The form \(*dV_\rho\) has integral \(-1\) on a small positively +oriented linking sphere. That sphere generates the second homology +of the punctured solid torus. Hence it is the curvature of a real +connection \(\theta\) on a principal \(\R/\Z\)-bundle, normalized by +integral one on its circle fibers: +\begin{equation}\label{eq:nodal-connection} + d\theta=*dV_\rho. +\end{equation} +In this period-one convention the curvature itself represents the +first Chern class. We may change \(\theta\) by a closed basic +one-form. + +With \(x_3=t\), set, for cyclic \((i,j,k)\), +\begin{equation}\label{eq:nodal-gh-triple} + \begin{split} + g_\rho&=V_\rho(dx_1^2+dx_2^2+dt^2)+V_\rho^{-1}\theta^2,\\ + \gamma_i&=dx_i\wedge\theta+V_\rho\,dx_j\wedge dx_k. + \end{split} +\end{equation} +The signs follow directly from +\[ + d(dx_i\wedge\theta)=-\partial_iV_\rho\,dx_1\wedge dx_2\wedge dx_3, + \qquad + d(V_\rho dx_j\wedge dx_k)=\partial_iV_\rho\,dx_1\wedge dx_2\wedge dx_3. +\] +Thus all three forms are closed. In the coframe +\(V_\rho^{1/2}dx_i,V_\rho^{-1/2}\theta\) they form the standard +orthogonal equal-square self-dual frame, with the induced +four-dimensional orientation. To check parallelness, write the +connection on this frame in terms of three real one-forms \(a_i\). +After a consistent choice of frame signs, the equations for +closedness are +\[ + I_2a_3-I_3a_2=0,\qquad + I_3a_1-I_1a_3=0,\qquad + I_1a_2-I_2a_1=0, +\] +where \(I_i\alpha=*(\alpha\wedge\gamma_i)\), with an overall +sign chosen so \(I_1I_2=I_3\). +The first two equations give \(a_3=-I_1a_2\) and +\(a_1=-I_2a_3=-I_3a_2\). +The third then gives \(2I_1a_2=0\), so all \(a_i\) vanish. +The frame is parallel. +In particular +\begin{equation}\label{eq:nodal-gh-complex-form} + \Omega_\rho=\gamma_1+i\gamma_2 + =ds\wedge(\theta-iV_\rho dt). +\end{equation} +It is decomposable and has positive product with its conjugate. +Its kernel defines the complex structure for which \(\gamma_3\) +is K\"ahler. This kernel is involutive: closedness and Cartan's +formula give \(\iota_{[U,W]}\Omega_\rho=0\) whenever \(U,W\) +annihilate \(\Omega_\rho\). The function \(s\) is holomorphic. + +Here is the completion and the quantitative information at its pole. +In scaled coordinates \(\mathbf X=(x_1,x_2,t)/\rho\), write +\begin{equation}\label{eq:nodal-pole-split} + W=\rho V_\rho=W_m+H_\rho,\qquad W_m=\frac1{4\pi r},\quad + r=|\mathbf X|. +\end{equation} +On a fixed ball of radius less than \(1/4\), +\(H_\rho=H_0-(\log\rho)/(2\pi)\), where \(H_0\) is smooth harmonic +and independent of \(\rho\). +A local gauge gives \(\theta=\theta_m+\beta\), where +\(d\theta_m=*dW_m\) and \(\beta\) is smooth basic with +\(d\beta=*dH_0\). Its derivatives on a smaller ball are bounded +independently of \(\rho\). + +The charge-one Hopf chart completes +\(W_m\,d\mathbf X^2+W_m^{-1}\theta_m^2\) to a flat smooth +four-dimensional ball. In this chart \(\mathbf X\) and \(r\) are +smooth quadratic expressions, and \(r\theta_m\) is smooth. +The coefficient \(1/(4\pi)\), with connection period one, is the +smooth Hopf normalization. Now +\begin{equation}\label{eq:nodal-pole-inverse} + W^{-1}=\frac{4\pi r}{1+4\pi rH_\rho},\qquad + \frac{W^{-1}-W_m^{-1}}{r^2} + =-\frac{(4\pi)^2H_\rho}{1+4\pi rH_\rho}. +\end{equation} +It follows that +\[ + g_\rho/\rho=W\,d\mathbf X^2+ + W^{-1}(\theta_m+\beta)^2 +\] +is smooth at the added point. In particular, the coefficient of +the apparently singular squared-connection difference is smooth +by the second identity in \Cref{eq:nodal-pole-inverse}. +Subtracting the flat Hopf triple in +\[ + \gamma_i/\rho=dX_i\wedge(\theta_m+\beta)+W\,dX_j\wedge dX_k +\] +shows that the forms also extend smoothly. At the added point +their values are the flat triple, so they remain nondegenerate. +We obtain a smooth hyperk\"ahler surface \(Y_\rho\), and its +holomorphic function \(s\) extends over the added point. + +At that point \(ds=0\). The quadratic term of \(s\) is the +nondegenerate holomorphic quadratic of the Hopf map; in linear +complex coordinates it is a nonzero multiple of \(w_1w_2\). +The holomorphic Morse lemma therefore gives an ordinary node. +Away from this point the central fiber is a circle bundle over +\((\R/\rho\Z)\setminus\{0\}\). Completing its two ends at the pole +gives a reduced irreducible nodal curve with spherical normalization. +The fibers for \(s\ne0\) are two-tori, and their relative holomorphic +one-form from \(\Omega_\rho\) has no zeros; they are elliptic curves. +The projection \(p_\rho:Y_\rho\to\Delta_R\) is proper: over a compact +base set its complement of a pole neighborhood is a circle bundle +over a compact set, and the missing part is a compact subset of +the completed Hopf chart. + +The potential is invariant under \(t\mapsto\rho-t\), so the +curvature restricts to zero on \(t=\rho/2\). +The flat circle connection over this disk has a horizontal section +\(S_\rho\). It is holomorphic: its tangent space has +\(dt=\theta=0\), so \(\Omega_\rho\) vanishes there, while \(ds\) +is an isomorphism to the base tangent. It avoids the critical point. + +Integrate the relative holomorphic differential from this section +to obtain the Abel coordinate \(z\) on each smooth fiber. +The connection circle has period one. Orient the other cycle in +the negative \(t\)-direction. Its period \(\tau_\rho\) then satisfies +\[ + \operatorname{Im}\tau_\rho(s) + =\int_0^\rho V_\rho(s,t)\,dt=\tau_2(s). +\] +The periods are holomorphic on each branch of the regular base. +Thus \(\tau_\rho-\tau\) is a real constant. +Adding a real multiple of \(dt/\rho\) to \(\theta\) changes exactly +this real period; we choose it to make \(\tau_\rho=\tau\). +An integral change only changes the cycle basis. +This does not affect curvature or the horizontal section in the +midpoint slice. In the resulting coordinates +\(\Omega_\rho=ds\wedge dz\). + +\subsection{The fixed complex surface across the node} + +The common periods identify the regular elliptic families, +preserving their sections and relative differentials. +The following argument extends the identification across zero. + +\begin{lemma}\label{lem:nodal-fixed-family} +The preceding identifications extend to holomorphic symplectic +isomorphisms of the completed families \(Y_\rho\to\Delta_R\). +\end{lemma} +\begin{proof} +We compare the families through the degree-three divisors given by +three times their sections. Their line bundles embed the fibers as +plane cubics. Laurent coefficients at the section, measured in the +normalized Abel coordinate, will identify the three-dimensional spaces +of sections across the puncture; taking closures will then identify +the completed families. + +Each \(p_\rho\) is a flat proper family of connected reduced curves. +For flatness, the local ring of the smooth total surface has no +torsion over the local ring of the one-dimensional smooth base, +since \(p_\rho-s_0\) is not a zero divisor. Torsion-free modules +over this discrete valuation ring are flat. +The fibers have arithmetic genus one, and \(S_\rho\) is a Cartier +divisor in the fiberwise smooth locus. + +Set \(\mathcal L_\rho=\mathcal O_{Y_\rho}(3S_\rho)\). +This line bundle is flat over the base, since it is locally free on +the flat family. +Its restriction to each fiber is a degree-three very ample line +bundle, with \(h^0=3\) and \(h^1=0\). +For the complex-linear Dolbeault operator on a line bundle of +degree \(d\) over a closed connected Riemann surface of genus \(g\), the complex +index is \(d+1-g\), and \(d>2g-2\) gives surjectivity +\cite[Section~3.4, Theorems~3.22--3.23]{Wendl2014Lectures}. +On a smooth genus-one fiber this gives the asserted dimensions. +After imposing any length-two subscheme, the remaining degree is +one and the first cohomology still vanishes. This proves very +ampleness on those fibers. +For the nodal curve one can check the assertion explicitly. +Normalize it by \(\mathbb P^1\), with the two preimages of the +node at \(0,\infty\). A degree-three line bundle pulls back to +\(\mathcal O_{\mathbb P^1}(3)\), with a nonzero gluing parameter +\(\lambda\) for its fibers at these points. +Its sections are degree-at-most-three polynomials with +constant coefficient \(\lambda\) times the leading coefficient. +The basis \(w,w^2,w^3+\lambda\) gives the map +\[ + w\longmapsto[w:w^2:w^3+\lambda]. +\] +It identifies exactly \(0\) and \(\infty\); away from these +points the ratio of the second coordinate to the first is \(w\). +At \(0\) and \(\infty\) the two tangent lines are distinct, as +is seen in the affine chart about \([0:0:1]\). +Thus it embeds the nodal curve as a nodal cubic. To compute its +cohomology directly, let \(N\) denote the nodal fiber, +\(\nu:\mathbb P^1\to N\) its normalization, and +\(L=\mathcal L_\rho|_N\). The gluing condition gives the exact sequence +\[ + 0\longrightarrow L\longrightarrow + \nu_*\mathcal O_{\mathbb P^1}(3) + \xrightarrow{\operatorname{ev}_0-\lambda\operatorname{ev}_\infty} + \C_{\mathrm{node}}\longrightarrow0, +\] +where the last sheaf is supported at the node and its fiber is \(\C\). +In the polynomial trivializations just used, the map on global +sections is the constant coefficient minus \(\lambda\) times the +leading coefficient. It is surjective. The normalization is finite, +so the cohomology of its direct image is that of +\(\mathcal O_{\mathbb P^1}(3)\). The latter has \(h^0=4\) and +\(h^1=0\). The cohomology exact sequence therefore gives +\(h^0(N,L)=3\) and \(h^1(N,L)=0\). + +We use the following proper holomorphic base-change theorem: for a +proper holomorphic map to a reduced base and a coherent sheaf flat +over that base, constancy of the fiber dimensions \(h^q\) implies +that the \(q\)-th direct image is locally free and its restriction +to each base point is the cohomology of that fiber; see +\cite[Section~7, Satz~5]{Grauert1960} and the correction +\cite{Grauert1963}. Our map is proper and +surjective, the disk is reduced, and \(\mathcal L_\rho\) is flat +over it. Applying the theorem with \(q=0\) and the constant value +\(h^0=3\) gives a holomorphic rank-three bundle +\[ + E_\rho=(p_\rho)_*\mathcal L_\rho +\] +with those spaces as fibers. Evaluation gives a relative closed +embedding in \(\mathbb P(E_\rho^*)\). +Indeed the fiberwise embeddings and base change give the +evaluation and separation properties locally over the base. +At the nodal point, the fiber's Zariski tangent space is the whole +tangent space of the smooth total surface, so tangent separation +there also gives an immersion of the total surface. Properness +then gives the closed embedding. + +Near the section \(p_\rho\) is a submersion. Write +\(\Omega_\rho=f(s,w)\,ds\wedge dw\), with \(w=0\) on the section. +The coordinate +\[ + z(s,w)=\int_0^w f(s,u)\,du +\] +is holomorphic, has nonzero relative derivative, and is zero on +the section. It extends the normalized local Abel coordinate +also across \(s=0\). +Regard sections of \(\mathcal L_\rho\) as meromorphic functions +with poles of order at most three on \(S_\rho\). +Their Laurent coefficients in degrees \(-3,-2,-1,0\) define +\begin{equation}\label{eq:nodal-jet-map} + E_\rho\longrightarrow\mathcal O_{\Delta_R}^{\,4}. +\end{equation} +This map is fiberwise injective. A function in its kernel has +no pole and hence is constant on the compact connected reduced +fiber; its zero constant coefficient makes it zero. +Thus its image is a rank-three subbundle, including over zero. + +The images agree on the punctured disk by the regular elliptic +identifications. Continuity of their Grassmannian-valued maps +makes them agree also at zero, identifying the bundles \(E_\rho\). +Their relative cubic images agree as well: each is the closure +of its image over the punctured disk, and both are reduced +analytic subspaces. This gives an isomorphism of the completed +families. The holomorphic two-forms agree on the regular part +and therefore everywhere. +\end{proof} + +Fix one small reference parameter and take its surface as \(Y\). +Using \Cref{lem:nodal-fixed-family}, the form +\(\Sigma_0=ds\wedge dz\) is fixed on \(Y\), while the transported +forms \(\gamma_3\) are its varying K\"ahler forms. +In particular the qualitative model existence used to insert +nodes does not assume a global fibration. + +\subsection{Comparison and periods on fixed annuli} + +The complex family is now fixed. To glue its K\"ahler forms later, +we need estimates in the same smooth annular coordinates for every +area parameter, together with equality of their annular classes. +Work over a fixed annulus with positive inner radius and on +bounded branches relative to the midpoint section. The imaginary +part of the Abel coordinate is +\begin{equation}\label{eq:nodal-q-coordinate} + q=\operatorname{Im}z=\int_t^{\rho/2}V_\rho(s,u)\,du. +\end{equation} +Consequently \Cref{eq:nodal-potential-tail} gives +\begin{equation}\label{eq:nodal-q-tail} + q=\frac{\rho/2-t}{\rho}\tau_2(s)+E_\rho(s,t),\qquad + \|E_\rho\|_{C^m}\le C_m\rho^{-N_m}e^{-c/\rho}. +\end{equation} +The interval of integration has length \(O(\rho)\); differentiated +endpoints cost only powers of \(\rho^{-1}\). +Since \(q=\tau_2b\) and \(\tau_2\) is bounded above and below, +\begin{equation}\label{eq:nodal-inverse-t} + b=\frac{\rho/2-t}{\rho}+O(e^{-c'/\rho}),\qquad + t=\frac{\rho}{2}-\rho b+O(e^{-c'/\rho}) +\end{equation} +with all fixed finite-order derivatives in the corresponding +coordinates. For the inverse statement, +\(\partial_tb=-V_\rho/\tau_2\) has absolute value bounded below +by a constant times \(\rho^{-1}\). Successive differentiation +of the inverse relation introduces only polynomial factors, +absorbed by reducing \(c'>0\). + +There is a complex function \(k\) on each branch such that +\begin{equation}\label{eq:nodal-connection-comparison} + dz-(\theta-iV_\rho dt)=k\,ds. +\end{equation} +The difference gives zero relative differential and has zero +wedge with \(ds\), by \Cref{eq:nodal-gh-complex-form}. +Its imaginary part says +\[ + \operatorname{Im}(k\,ds)=d_s q + =b\,d\tau_2+O(e^{-c'/\rho}), +\] +where \(t\) is held fixed. Since \(\tau\) is holomorphic, +\(\operatorname{Im}(b\tau'(s)\,ds)=b\,d\tau_2\). +The real-linear map taking \(k\) to \(\operatorname{Im}(k\,ds)\) +is an isomorphism onto real base one-forms. Thus +\(k=b\tau'(s)+O(e^{-c'/\rho})\). +Substituting \(dz=da+\tau\,db+b\tau'(s)\,ds\) in +\Cref{eq:nodal-connection-comparison} gives +\begin{equation}\label{eq:nodal-theta-tail} + \theta=da+\operatorname{Re}\tau\,db+O(e^{-c'/\rho}). +\end{equation} +All the errors here have their fixed finite-order derivative +bounds in the fixed \((s,a,b)\) charts. Therefore +\begin{equation}\label{eq:nodal-area-one-comparison} + \begin{split} + \gamma_3&=dt\wedge\theta+V_\rho dx_1\wedge dx_2\\ + &=\rho\,da\wedge db+ + \frac{\tau_2(s)}{\rho}\,dx_1\wedge dx_2 + +O(e^{-c'/\rho}). + \end{split} +\end{equation} +The fiber sign follows from +\((-\,\rho\,db)\wedge da=\rho\,da\wedge db\). +Its exact area is \(\rho\), since on a fiber +\(\gamma_3=dt\wedge\theta\), and the two periods are \(\rho\) +and one, with this complex orientation. + +Under monodromy \(\tau\mapsto\tau+1\), the angle change is +\((a,b)\mapsto(a-b,b)\). It preserves \(da\wedge db\), and +\(\tau_2\) is single-valued. Hence the invariant comparison +form and the finite-chart estimates descend to the annular bundle. + +To identify the periods that test exactness on the annular bundle, +we first determine the topology of the completed disk neighborhood. +A one-critical-point Lefschetz fibration over a disk has the +homotopy type of a regular fiber with its vanishing thimble attached. +Here this description follows by trivializing over a slit disk: +the circle over a path to the critical value collapses to the Hopf +point and gives the one attached disk, while the complement of +that path is a trivial smooth fibration. The vanishing circle is +the primitive connection circle \(a\). +Thus the cellular description is a torus with one additional +two-cell attached along \(a\). Collapsing that cell together +with \(a\) leaves a one-cell \(b\) and the torus two-cell with +trivial attaching map, so the homotopy type is \(S^1\vee S^2\). +More precisely its cellular boundary sends the additional +two-cell to \(a\) and sends the torus two-cell to zero. +Consequently its second real homology is generated by the +original torus fiber, as asserted. + +\begin{lemma}\label{lem:nodal-annular-periods} +The two forms in \Cref{eq:nodal-area-one-comparison} have the same +real cohomology class on the annular bundle: their periods are +\(\rho\) on a fiber and zero on the invariant-cycle sweep. +\end{lemma} +\begin{proof} +We use the two-cycle comparison from +\cite[proof of Lemma~4.3]{GrossWilson2000}. +The annular bundle retracts to the mapping torus of one shear. +Its homology exact sequence is +\[ + 0\longrightarrow H_2(T^2;\R) + \longrightarrow H_2(p^{-1}(K);\R) + \longrightarrow\ker(T_*-1:H_1(T^2;\R)\to H_1(T^2;\R)) + \longrightarrow0. +\] +The first term is generated by a fiber, and the last by the +invariant \(a\)-circle. This circle has a sweep at \(b=0\). +These two cycles thus test all real two-periods. + +The fiber periods were computed above. The sweep is the +connection circle bundle over a base circle in \(t=\rho/2\). +The connection circle bundle over the full base disk in this +slice is a solid torus bounding it in \(Y\). +On the sweep \(dt=0\), and the base has only one tangent +direction, so the restriction of +\(dt\wedge\theta+V_\rho dx_1\wedge dx_2\) is zero. +The invariant comparison form also has zero restriction, because +\(db=0\) and the same dimensional observation applies. +\end{proof} + +\subsection{Polynomial intrinsic geometry} + +The annular estimates use a fixed smooth atlas, as the gluing requires. +For the remaining metric estimates the charts may instead vary with +\(\rho\): we transport each metric together with its own controlled +charts. This is enough to bound intrinsic derivatives on the model +cores in \Cref{sec:auxiliary-volume}. We prove these bounds on a fixed +smaller disk. + +Near the pole use the Hopf chart of \Cref{eq:nodal-pole-split}. +For small \(\rho\), the function \(H_\rho\) is positive on this +chart; its positive-order derivatives are bounded and +\(|H_\rho|\le C(1+|\log\rho|)\). +The formulas \Cref{eq:nodal-pole-inverse} show that the +coefficients of \(g_\rho/\rho\) and their derivatives have +polynomial bounds in \(1+|\log\rho|\). +For the inverse bounds compare +\[ + W\,d\mathbf X^2+W^{-1}(\theta_m+\beta)^2 + \quad\hbox{with}\quad + W_m\,d\mathbf X^2+W_m^{-1}\theta_m^2. +\] +The ratio \(W/W_m=1+4\pi rH_\rho\) and its reciprocal have +polynomial bounds. Replacing \(\theta_m\) by +\(\theta_m+\beta\) is a shear with smooth bounded coefficients +in the flat Hopf metric, because \(\beta\) is basic and smooth +in the quadratic base coordinates. This gives upper and lower +polynomial metric comparisons. Differentiation of the matrix +inverse gives its derivative estimates. Restoring the factor +\(\rho\) yields polynomial bounds in \(\rho^{-1}\). + +Off a smaller scaled pole neighborhood, use fixed-radius balls +in scaled coordinates \((s/\rho,t/\rho)\). +On such balls over \(\overline{\Delta_r}\), the periodic sum and +the Fourier formula give, for every multi-index, +\begin{equation}\label{eq:nodal-scaled-regular-bounds} + c\le W,\qquad W\le C(1+|\log\rho|),\qquad + |\partial^\alpha W|\le C_\alpha(1+|\log\rho|). +\end{equation} +The lower bound follows from positivity on the fixed larger +disk. Bounded scaled distance uses the periodic sum; large +scaled distance uses the mean and Fourier tails. +The curvature is \(*dW\) in these coordinates, so radial local +gauges give connection coefficients with the same finite-order +bounds. Cover the period-one connection circle by fixed +coordinate intervals. The metric in these charts is +\[ + \rho\{W\,d\mathbf X^2+ + W^{-1}(d\vartheta+\beta)^2\}. +\] +\Cref{eq:nodal-scaled-regular-bounds} gives polynomial bounds for +its coefficients, inverse and all fixed derivatives. + +There are polynomially many charts with the required margins. +The scaled base disk has radius \(O(\rho^{-1})\), and its +periodic direction has length one. A grid of fixed-radius balls, +with a fixed number of circle charts above each, uses at most +\(C\rho^{-2}\) charts off the pole. Refining the grid by a +fixed factor makes smaller concentric balls still cover. +Use similarly smaller circle intervals. The fixed gap \(R-r\) +supplies room at the outer boundary, and the Hopf chart covers +the omitted pole region. Coordinate formulas for the connection +and curvature, with the inverse metric estimates, also give +polynomial bounds for each fixed intrinsic curvature derivative. + +These bounds survive transport to the fixed complex surface. +If \(I_\rho:Y\to Y_\rho\) is the isomorphism from +\Cref{lem:nodal-fixed-family}, transport the charts by +\(I_\rho^{-1}\) and the metric by \(I_\rho^*\). +Their metric coefficients are exactly the coefficients already +estimated, and +\[ + I_\rho^*(\gamma_1+i\gamma_2)=\Sigma_0. +\] +Thus the fixed real and imaginary parts of \(\Sigma_0\) and the +transported \(\gamma_3\) are parallel, and the volume is the +fixed form \((\operatorname{Re}\Sigma_0)^2/2\). +No bound for derivatives of \(I_\rho\) in a separately fixed +smooth atlas is used. On annuli, where a fixed atlas is needed +for gluing, \Cref{eq:nodal-q-coordinate,eq:nodal-theta-tail} +give that distinct estimate. + +\begin{proof}[Completion of the proof of \Cref{thm:nodal-model}] +The construction and \Cref{lem:nodal-fixed-family} give the +fixed holomorphic nodal disk. For general \(h=|h|e^{i\phi}\), +rotate \(\gamma_1+i\gamma_2\) by \(e^{i\phi}\), scale the full +triple and the metric by \(|h|\), and take +\[ + \rho=\epsilon/|h|,\qquad + D^{\mathrm{loc}}_\epsilon=|h|\gamma_3,\qquad + g_\epsilon=|h|g_\rho. +\] +The holomorphic two-form becomes \(\Sigma=h\,ds\wedge dz\), the fiber area +becomes \(\epsilon\), and the equal-square identities give +\Cref{eq:nodal-exact-identities}. The scaled annular expression +is precisely \Cref{eq:nodal-semiflat}, with coefficient +\(|h|^2/\epsilon\). The exponential comparison and both period +identities follow from +\Cref{eq:nodal-area-one-comparison,lem:nodal-annular-periods}. +The polynomial estimates persist because \(h\) is fixed and +nonzero. This proves all assertions. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/09-regular-preparation.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/09-regular-preparation.tex new file mode 100644 index 0000000000000000000000000000000000000000..984275ee63c3572d63a4d8b3f0dfa307763a5246 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/09-regular-preparation.tex @@ -0,0 +1,512 @@ +\section{Preparing the regular fibers}\label{sec:regular-preparation} + +The torus fibration gives a way to average the pair along its regular +fibers. We use this averaging to construct an invariant pair and a +closed form of unit fiber area orthogonal to both members. These are +the data needed for the auxiliary volume equation in +\Cref{sec:auxiliary-volume}. Every change to the pair is exact, and the +curve criterion keeps a taming form in the original third class +throughout the preparation. + +Write $p\colon X\to S$ for the fibration of \Cref{thm:pencil}, and let +$\Delta\subset S$ be its finite set of critical values. Put +\[ + S^\circ=S\setminus\Delta, + \qquad X^\circ=p^{-1}(S^\circ). +\] +The fiber and base orientations are the complex orientations supplied by +that theorem. We identify the class of an oriented fiber with its +Poincar\'e dual $F\in H^2(X;\Z)/\mathrm{torsion}$. In particular, if +$\nu_S$ is a positive area form with $\int_S\nu_S=1$, then +\begin{equation}\label{eq:regular-basic-class} + [p^*\nu_S]=F. +\end{equation} +For example, this follows by first taking a representative of the unit +class supported near a regular value, whose pullback is a Thom form for +the corresponding fiber. + +\begin{proposition}\label{prop:regular-preparation} +Let $(A_0,C_0,B_0)$ and $p\colon X\to S$ be the positive triple and +fibration obtained in \Cref{thm:pencil}. Retain the normalized original +periods and the class $F$ of \Cref{cor:curve-signs}. On disjoint disks +$U_j$ about the critical values, use the models of +\Cref{thm:nodal-model}, with +\begin{equation}\label{eq:regular-input-model} + \Sigma_j=h_j\,\dd s\wedge\dd z, + \qquad A_0=\Re\Sigma_j, + \qquad C_0=x_j\Re\Sigma_j+y_j\Im\Sigma_j, + \qquad y_j\ne0, +\end{equation} +where $h_j\ne0$, $x_j$, and $y_j$ are constants and +$z=a+\tau(s)b$ modulo the elliptic period lattice. + +There are smaller disks $U'_j\Subset U_j$ and a smooth path of positive +closed triples $(A_t,C_t,B_t)$, $0\le t\le1$, starting at +$(A_0,C_0,B_0)$, with the following properties. +\begin{enumerate}[label=\textup{(\roman*)}] +\item Each of the three cohomology classes is constant. The restrictions +of $A_t,C_t$ to the fibers vanish, and the pair equals $(A_0,C_0)$ on +$p^{-1}(U'_j)$ for every $t$. +\item The endpoint pair $A=A_1$, $C=C_1$ is invariant under the torus +group bundle acting on $X^\circ$ by the action-angle translations of +$A_0$. This is also the torus action determined by $A$. +\item There is a smooth closed invariant two-form $\Psi$ on $X^\circ$ +such that +\begin{equation}\label{eq:regular-prepared-data} + \int_{p^{-1}(s)}\Psi=1, + \qquad \Psi\wedge A=\Psi\wedge C=0 + \quad\text{on }X^\circ. +\end{equation} +On each punctured $p^{-1}(U'_j\setminus\{s_j\})$ it equals +$\dd a\wedge\dd b$. In particular, $\Psi^2$ vanishes there. +\end{enumerate} +The fibration and its smaller nodal models remain fixed. All of these +choices are made before introducing the parameter $\eps$ in the +auxiliary-volume construction. +\end{proposition} + +We first describe averaging and the positive pair paths it permits. + +\subsection{Fiber translations and exact averaging} + +The regular torus fibration is a torsor: there are local choices of an +origin in each fiber, but a global choice is unnecessary. Here is a +direct description of its translations. If $\alpha_s\in T_s^*S^\circ$, +the equation +\[ + \iota_{Y_\alpha}A_0=-p^*\alpha +\] +defines a unique vertical vector field along $p^{-1}(s)$, since the fibers +are Lagrangian for $A_0$. Locally take $\alpha=\dd f$ on the base. The +fields $Y_{\dd f}$ are Hamiltonian; their brackets vanish because their +Hamiltonians are pulled back from the base and their fields are vertical. +Their complete flows on each compact fiber therefore give a transitive +$T_s^*S^\circ$-action with a rank-two stabilizer lattice $\mathcal L_s$. +The lattices vary smoothly locally: choose a local origin section and +apply the implicit function theorem to the return equation for each +member of a lattice basis. The derivative in the orbit parameter is +an isomorphism onto the vertical tangent plane, so the two periods +continue smoothly and remain a lattice basis after shrinking the base +chart. + +A local smooth section $\alpha$ of $\mathcal L$ is a closed one-form. +Indeed, its vertical flow $\phi_t$ has $\phi_1=\Id$, whereas Cartan's +formula gives +\[ + \phi_t^*A_0=A_0-tp^*(\dd\alpha). +\] +Putting $t=1$ proves $\dd\alpha=0$. A local lattice basis thus consists +of closed one-forms, and these are differentials of local base +coordinates. The corresponding period-one flows define translations +by constant angles in $\R^2/\Z^2$, and each such translation preserves +$A_0$. In two overlapping choices of angle coordinates the change has +the form +\begin{equation}\label{eq:regular-angle-transition} + \theta'=M\theta+g(s),\qquad M\in\operatorname{GL}(2,\Z) + \text{ locally constant}. +\end{equation} +Thus translation by $u$ in one chart is translation by $Mu$ in the +other, independently of the base-dependent change of origin $g$. + +On a model disk, the translations are exactly +$z\mapsto z+a_0+\tau(s)b_0$ for constant real $a_0,b_0$ modulo integers. +They preserve $\Sigma_j$, since the extra term in $\dd z$ is a multiple +of $\dd s$. Equivalently, contraction of $A_0$ with the period-one +fields $\partial_a,\partial_b$ gives the closed base one-forms +$-\Re(h_j\dd s)$ and $-\Re(h_j\tau(s)\dd s)$. They form the period +basis just described. Both model forms in +\Cref{eq:regular-input-model} are consequently invariant. + +\begin{lemma}\label{lem:regular-averaging} +There is a well-defined averaging projection +$\operatorname{Av}\colon\Omega^*(X^\circ)\to\Omega^*(X^\circ)$ onto +forms invariant under these local translations, and it commutes with +$\dd$. If a closed form $\xi$ satisfies $\operatorname{Av}\xi=0$, then +$\xi=\dd\beta$ for a smooth form $\beta$ with +$\operatorname{Av}\beta=0$. The primitive can be chosen without +enlarging support over the base: if $\xi$ vanishes over an open set in +$S^\circ$, then so does $\beta$. + +In particular, a closed form and its average represent the same class +on $X^\circ$. If their difference is supported over a compact subset +of $S^\circ$, the primitive extends by zero over the nodal neighborhoods +and gives exactness on $X$. +\end{lemma} + +\begin{proof} +In a local translation chart define the average by integrating pullbacks +against normalized Haar measure on $\R^2/\Z^2$. The conjugacy in +\Cref{eq:regular-angle-transition} and invariance of Haar measure make +the definitions agree on overlaps. Each pullback commutes with $\dd$, +which proves the assertion about differentiation. + +For exactness, choose a translation-invariant horizontal splitting of +$TX^\circ\to p^*TS^\circ$ and a smoothly varying invariant flat metric +on the vertical tori. Such choices exist: make them locally and patch +horizontal lifts and vertical inner products by partitions of unity +pulled back from the base. The transition rule above preserves +invariance, and the relevant sets of choices are affine or convex. + +Filter differential forms by horizontal degree. On the associated +graded complex the leading differential is the vertical exterior +derivative $\dd_v$. For each horizontal degree, fiberwise Hodge theory +\cite[Equations~(1.11)--(1.22)]{TaylorHodge2010} +provides a homotopy $H_v=\dd_v^*G_v$ on the vertical complex, with the +usual sign for its horizontal degree. Here $G_v$ is the inverse of the +vertical Laplacian on the complement of its kernel. Its harmonic forms +are precisely the translation-invariant forms. On the zero-average +subspace, therefore, +\begin{equation}\label{eq:regular-vertical-homotopy} + \dd_v H_v+H_v\dd_v=\Id. +\end{equation} +These operators act smoothly in the base: in a local torus chart they +are the inverses on nonzero Fourier modes for a smoothly varying flat +metric. They preserve zero average and use no values at other base +points. + +Suppose the smallest horizontal degree of the closed zero-average form +$\xi$ is $r$, and denote its component of that degree by $\xi_r$. +Closedness gives $\dd_v\xi_r=0$. By +\Cref{eq:regular-vertical-homotopy}, subtracting +$\dd(H_v\xi_r)$ removes $\xi_r$, and the remainder is closed, has zero +average, and has horizontal degree at least $r+1$. Repeat this step. +The horizontal degree is at most two, so the procedure terminates. A +component of vertical degree zero that is vertically closed and has +zero average is already zero. The sum of the primitives gives $\beta$. +Every operation is local in the base, including the differentiations +used in the successive remainders. Hence the support assertion follows. +Applying the construction to $\xi-\operatorname{Av}\xi$ proves the +remaining claims. +\end{proof} + +\subsection{The positive cone and the third class} + +\begin{lemma}\label{lem:regular-mixed-cone} +Fix a symplectic two-form $A$ with $A^2>0$ and a Lagrangian two-plane $L$ in an +oriented four-dimensional vector space. Among two-forms $C$ satisfying +$C|_L=0$, each component of the condition that $(A,C)$ be a definite +pair is convex. Adding a two-form pulled back from the quotient by +$L$ to either member of the pair does not change its wedge-product +matrix. + +Consequently the path from $C$ to its translation average, with $A$ +fixed, preserves definiteness for a fiber-Lagrangian pair on $X^\circ$. +Basic additions to either member do so as well. Along these paths the +fiber complex orientation and the quotient complex orientation remain +the ones fixed at the start. +\end{lemma} + +\begin{proof} +Choose covectors $e_1,e_2$ vanishing on $L$ and complementary covectors +$f_1,f_2$ so that +\[ + A=e_1\wedge f_1+e_2\wedge f_2, + \qquad + C=\sum_{i,j=1}^2 M_{ij}e_i\wedge f_j+c\,e_1\wedge e_2. +\] +Direct wedge multiplication yields +\[ + A\wedge C=\tfrac12\tr(M)A^2, + \qquad C^2=\det(M)A^2. +\] +Writing $h=\tr(M)/2$ and $T=M-h\Id$ gives +\begin{equation}\label{eq:regular-mixed-square} + (rA+tC)^2=\bigl((r+th)^2+t^2\det T\bigr)A^2. +\end{equation} +Thus the pair is definite exactly when $\det T>0$. Set +\[ + T=\begin{pmatrix}u&v\\w&-u\end{pmatrix},\qquad + q=\tfrac12(v-w),\qquad r_0=\tfrac12(v+w). +\] +Then $\det T=q^2-r_0^2-u^2$. Its two positive components are +$q>\sqrt{r_0^2+u^2}$ and $q<-\sqrt{r_0^2+u^2}$, both convex; $h$ and +$c$ are unrestricted. This proves the first assertion. A quotient +two-form wedges to zero with both members of a fiber-Lagrangian pair, +and its own square vanishes. This proves the assertion about basic +additions, also when both members change. + +At a fixed point all translated pullbacks of $C$ lie in one of the two +components: translations preserve $A$ and can be connected to the +identity within the torus. Their compact average remains strictly +inside that convex component, as does the segment to the average. +The common Lagrangian plane is a complex line by +\Cref{lem:definite-pair}. Continuing the choice of sign of the almost +complex structure along the path keeps its orientation on this plane, +and hence the quotient orientation, fixed. +\end{proof} + +The next lemma separates the smooth choice of representatives from the +pointwise question of whether a class contains a tamer. It will also +be used when the final endpoint representatives have been chosen. + +\begin{lemma}\label{lem:smooth-tamers} +Let $J_t$, $0\le t\le1$, be a smooth family of almost-complex +structures on a compact manifold. Suppose each $J_t$ admits a closed +tamer in one fixed class $H$. Given such representatives $\beta_0$ +and $\beta_1$ at the endpoints, there is a smooth family of closed +tamers $\beta_t\in H$ with those endpoints. +\end{lemma} + +\begin{proof} +A fixed tamer for $J_{t_0}$ remains a tamer on a parameter neighborhood +of $t_0$, by openness and compactness of $X$. Choose finitely many +such neighborhoods and corresponding fixed representatives. Near +$0$ and $1$ use the prescribed representatives. Choose a subordinate +smooth nonnegative partition of unity in the parameter, with the +endpoint representative having weight one sufficiently near its +endpoint. Their weighted sum is closed on $X$ and represents $H$, +because all coefficients depend only on $t$ and sum to one. It tames +$J_t$ by convexity of the taming cone. +\end{proof} + +\begin{lemma}\label{lem:regular-tamer-path} +Suppose $(A_t,C_t)$ is a smooth compact path of definite closed pairs +with the original two periods. Suppose the fibers of $p$ remain common +Lagrangians with the original complex orientation, and the pair equals $(A_0,C_0)$ on smaller nodal neighborhoods. Then the class $[B_0]$ +contains a taming form for the associated almost complex structure at +every parameter. If the initial pair is $(A_0,C_0)$, these representatives +can be chosen smoothly starting at $B_0$; an endpoint representative +can also be prescribed whenever it tames the endpoint structure. +\end{lemma} + +\begin{proof} +Let $J_t$ be the structures defined by the pair, with the continued +sign. First produce a convenient taming class. On the regular region, +$J_t$ preserves the vertical tangent planes and induces an oriented +complex structure on each quotient $T_xX/\ker\dd p_x$. This quotient +structure need not be independent of the point in the fiber. Nevertheless +the positive base form satisfies +\[ + p^*\nu_S(\zeta,J_t\zeta)>0 + \quad\text{whenever }\dd p(\zeta)\ne0, +\] +and it vanishes on vertical vectors. The restriction of $B_0$ to the +oriented vertical planes stays positive. + +On a compact regular region containing the supports of the pair +changes, use a smooth splitting $\zeta=v+h$ into vertical and +horizontal vectors and any fixed background norm. Compactness in +space and parameter gives positive constants $a,b$ and a finite $M$ +such that +\begin{align*} + B_0(\zeta,J_t\zeta)&\ge a|v|^2-M|v||h|-M|h|^2 + \ge \tfrac a2|v|^2-M'|h|^2,\\ + p^*\nu_S(\zeta,J_t\zeta)&\ge b|h|^2. +\end{align*} +Thus $B_0+Kp^*\nu_S$ tames for one sufficiently large $K>0$. +On the unchanged nodal neighborhoods, $B_0$ already tames and +$p^*\nu_S$ is semipositive. Indeed, the model matching in +\Cref{lem:pencil-insertion} chooses its complex structure with the +sign tamed by $B_0$, and its projection is holomorphic for that sign. +The same $K$ therefore works on all of $X$ and at every parameter. + +Put $H_K=[B_0]+KF$ and +$V=[A_0]^\perp\cap[C_0]^\perp$. By +\Cref{eq:regular-basic-class}, $H_K$ is the class just constructed. +It belongs to $V$, and +\[ + H_K^2=1+2K[B_0]F>0,\qquad + H_K[B_0]=1+K[B_0]F>0. +\] +Consequently $H_K$ and $[B_0]$ lie in the same timelike component of +$V$. To apply \Cref{thm:taming-cone}, let $d$ be the class, identified +with its Poincar\'e dual, of a nonconstant irreducible $J_t$-curve. +It has $H_Kd>0$. By \Cref{cor:curve-signs}, either $Fd\ne0$ and its +sign is the sign of the coefficient $c$ in $d^+=cF^+$, or $d=cF$. +Also $[B_0]d=c[B_0]F$, with $[B_0]F>0$. If $[B_0]d$ were +nonpositive, the alternatives would give $c<0$ and $Fd\le0$, so +$H_Kd=[B_0]d+KFd<0$, a contradiction. Thus every such curve pairs +positively with $[B_0]$. The hypotheses of +\Cref{thm:taming-cone} hold with the already tamed class $H_K$, and that +theorem supplies a tamer in $[B_0]$. + +When the initial pair is $(A_0,C_0)$, apply \Cref{lem:smooth-tamers} +to the family $J_t$ and the fixed class $[B_0]$, using $B_0$ at the +initial endpoint and any prescribed endpoint tamer. This gives the +asserted smooth representatives. +By \Cref{lem:definite-pair}, their triples with $(A_t,C_t)$ are positive. +\end{proof} + +\subsection{Construction of the prepared pair} + +We have established that averaging and basic additions preserve the +definite pair, and that the original third class remains available +along the resulting paths. It remains to arrange the two orthogonality +equations for the unit-fiber-area form without changing the nodal data. + +\begin{proof}[Proof of \Cref{prop:regular-preparation}] +We first average the pair and construct a closed invariant form of +unit fiber area. We then adjust its two total pairings so that exact +basic changes of the pair can impose pointwise orthogonality. +Throughout, disks may be replaced by smaller nested disks, with +closures inside the original model disks. + +\emph{Averaging the second form.} +On $X^\circ$ set $\overline C=\operatorname{Av}C_0$. It is closed +and equals $C_0$ on every model disk, so it extends smoothly over $X$. +The difference $\overline C-C_0$ is supported over a compact subset +of $S^\circ$ and is exact on $X$ by +\Cref{lem:regular-averaging}. The path +\[ + (A_0,(1-t)C_0+t\overline C) +\] +is a definite pair path by \Cref{lem:regular-mixed-cone}, with the same +periods and the same oriented fiber planes. It admits a completion in +$[B_0]$ by \Cref{lem:regular-tamer-path}. For the remaining construction +write $A=A_0$ and $C=\overline C$. Both are invariant. + +\emph{A closed form of unit fiber area.} +The positive number $q_0=[B_0]F$ is the common integral of $B_0$ over +the regular fibers. Start with +\[ + \Psi^{(0)}=\operatorname{Av}(B_0/q_0) + \quad\text{on }X^\circ. +\] +This is closed and invariant, and its restriction to every fiber is +the invariant two-form of integral one. + +We next make it equal to $\dd a\wedge\dd b$ near every puncture. +On a punctured model disk, the two real two-homology generators are +the fiber and the torus obtained by sweeping the invariant $a$-cycle +around a base circle at $b=0$. One can see this from the homology +sequence for a torus mapping torus: the monodromy is one shear, so +the fiber contributes one generator and the invariant part of its +first homology contributes one more. The second generator bounds a +three-chain in the full nodal neighborhood, as described in +\Cref{thm:nodal-model}. The smooth closed form $B_0/q_0$ consequently +has periods $1$ and $0$ on these generators. Averaging does not change +them, by \Cref{lem:regular-averaging}. The form +$\dd a\wedge\dd b$ has the same periods: its fiber integral is one, +and its restriction to the sweep at $b=0$ is zero. It is a well-defined +closed form under the shear transition of the angular coordinates. + +It follows that +$\Psi^{(0)}-\dd a\wedge\dd b=\dd\beta_j$ on the punctured +neighborhood. Replace $\beta_j$ by its average, so it is invariant. +Choose a basic cutoff $\chi_j$ that is one on a smaller punctured +disk and zero near the outer boundary, and replace $\Psi^{(0)}$ there +by +\[ + \Psi^{(0)}-\dd\bigl((p^*\chi_j)\beta_j\bigr). +\] +These disjoint modifications give a smooth closed invariant form +$\Psi^{(1)}$ on $X^\circ$, equal to $\dd a\wedge\dd b$ near the +punctures. Its fiber restriction is unchanged: the two invariant +forms being compared already have the same restriction of integral +one, and a differential of a basic cutoff has zero vertical +restriction. + +\emph{The obstruction to an exact orthogonality correction.} +The form $\Psi^{(1)}$ has the required fiber restriction and nodal +behavior. It remains to arrange orthogonality to the pair while +preserving the pair's cohomology classes. Invariance reduces these +pointwise equations to a calculation on the base. + +Let $\Phi$ be an invariant two-form on $X^\circ$ whose restriction +to each fiber has integral one. For any invariant four-form $\Xi$, +we have the pointwise identity +\begin{equation}\label{eq:regular-invariant-top-form} + \Phi\wedge p^*(p_*\Xi)=\Xi. +\end{equation} +Indeed, only the vertical restriction of $\Phi$ contributes to its +wedge with a basic two-form. Invariant top forms have constant +vertical density on each fiber and are therefore determined by their +fiber integral; both sides of +\Cref{eq:regular-invariant-top-form} have the same integral on every +fiber after fixing two base tangent vectors. + +In particular, replacing $A$ by +$A-p^*p_*(\Phi\wedge A)$ makes it orthogonal to $\Phi$, and the +same holds for $C$. On the closed oriented surface $S$, a smooth +two-form is exact precisely when its integral is zero. We therefore +first adjust $\Psi^{(1)}$ so that both resulting base two-forms have +zero integral. Their vanishing near the punctures will allow us to +regard them as smooth forms on all of $S$. + +\emph{Removing the two total pairings.} +There are smooth closed invariant forms $\widetilde A,\widetilde C$ +on $X$, representing $[A],[C]$, supported over a compact subset of +$S^\circ$, and vanishing on vertical planes. To construct them, +observe that a full one-node neighborhood has the homotopy type of a +torus with its primitive vanishing cycle collapsed; its real second +homology is generated by the fiber. Hence $A,C$ are exact there, +since their fiber integrals vanish. Subtract differentials of local +primitives multiplied by basic cutoffs equal to one near the nodal +fiber. This gives global cohomologous forms that vanish on smaller +model neighborhoods. Their restrictions to vertical planes remain +zero, because both the original forms and the differentials of the +cutoffs have that property in the required restriction. Averaging +these forms, and extending by zero near the nodes, gives +$\widetilde A,\widetilde C$. Their cohomology classes are unchanged +by \Cref{lem:regular-averaging}. + +On a punctured model disk, $\Sigma_j=h_j\dd s\wedge(\dd a+\tau\dd b)$: +the term $b\tau'(s)\dd s$ in $\dd z$ disappears after wedging with +$\dd s$. Thus $A,C$ have only mixed base--fiber terms there, and +\[ + (\dd a\wedge\dd b)\wedge A + =(\dd a\wedge\dd b)\wedge C=0. +\] +Consequently the integrals +\[ + I_A=\int_{X^\circ}\Psi^{(1)}\wedge A, + \qquad + I_C=\int_{X^\circ}\Psi^{(1)}\wedge C +\] +are well-defined: their integrands vanish over smaller punctured +disks. The matrix of pairings of $\widetilde A,\widetilde C$ with +$A,C$ is their cohomology Gram matrix, hence the identity under our +normalization. Set +\begin{equation}\label{eq:regular-psi-class-correction} + \Psi=\Psi^{(1)}-I_A\widetilde A-I_C\widetilde C. +\end{equation} +The form $\Psi$ remains closed, invariant, of unit fiber area, and +equal to $\dd a\wedge\dd b$ near the punctures. By construction, +\begin{equation}\label{eq:regular-zero-total-pairings} + \int_{X^\circ}\Psi\wedge A + =\int_{X^\circ}\Psi\wedge C=0. +\end{equation} +Without the normalization one would solve the same two equations +using the positive invertible period Gram matrix. + +\emph{Removing the pointwise pairings.} +Fiber integration of the invariant four-forms gives base two-forms +\[ + \zeta_A=p_*(\Psi\wedge A),\qquad + \zeta_C=p_*(\Psi\wedge C). +\] +They vanish near the punctures and so extend by zero to smooth forms +on $S$. Their integrals are zero by +\Cref{eq:regular-zero-total-pairings}. Since $S$ is a closed connected +oriented surface, there are smooth one-forms $\kappa_A,\kappa_C$ on +$S$ with +$\zeta_A=\dd\kappa_A$ and $\zeta_C=\dd\kappa_C$. + +Now make the simultaneous basic deformation +\begin{equation}\label{eq:regular-final-basic-path} + A_t'=A-tp^*\zeta_A, + \qquad C_t'=C-tp^*\zeta_C, + \qquad 0\le t\le1. +\end{equation} +Both changes are globally exact, since the primitives are the smooth +pullbacks of $\kappa_A,\kappa_C$. The changed forms are invariant, +have zero vertical restriction, and agree with the original pair +on smaller model neighborhoods. Their wedge-product matrix is +unchanged by \Cref{lem:regular-mixed-cone}, so the path remains +definite. \Cref{eq:regular-invariant-top-form} shows that its endpoint +satisfies +\[ + \Psi\wedge A_1'=\Psi\wedge C_1'=0. +\] +Moreover, contraction of a basic two-form with a vertical vector is +zero. Hence the vertical Hamiltonian fields of base functions for +$A_t'$ are the same as those for $A$, and their period lattice and +torus translations are unchanged. + +Finally concatenate the two pair paths, making their parameters flat +at the join. They preserve the original pair periods, oriented +fibers, and smaller nodal models. \Cref{lem:regular-tamer-path} gives +a smooth completion by forms in $[B_0]$, with initial value $B_0$. +This proves all the assertions. We henceforth denote the endpoint +pair again by $A,C$ and its chosen third form by $B$. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/10-auxiliary-volume.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/10-auxiliary-volume.tex new file mode 100644 index 0000000000000000000000000000000000000000..aa6733b2a92debd381dbde08ae3ab5816f5b31ec --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/10-auxiliary-volume.tex @@ -0,0 +1,708 @@ +\section{An auxiliary prescribed-volume solution} +\label{sec:auxiliary-volume} + +We retain the fibration and prepared forms supplied by +\Cref{prop:regular-preparation}. Thus the closed definite pair $(A,C)$ has +the original periods, both forms vanish on the fibers, and on the regular +locus they are invariant under the fiber torus translations. The closed +invariant form $\Psi$ has fiber integral one and satisfies +\begin{equation} + \Psi\wedge A=\Psi\wedge C=0. + \label{eq:auxiliary-prepared-orthogonality} +\end{equation} +Near each punctured nodal fiber it is the form $\dd a\wedge\dd b$ of +\Cref{thm:nodal-model}. All the model disks, smaller disks, and annuli in +this section are fixed before the parameter $\eps$ is chosen. We write +$F$ for the Poincar\'e dual of an oriented fiber and +\[ + V=[A]^\perp\cap[C]^\perp. +\] +In particular $F\in V$, $F^2=0$, and $[B]F>0$. + +\begin{theorem}[Auxiliary volume equation] +\label{thm:auxiliary-solution} +For every sufficiently small $\eps>0$ there is a smooth closed real +two-form $D_\eps$ such that +\begin{equation} + A\wedge D_\eps=C\wedge D_\eps=0, + \qquad D_\eps^2=A^2, + \label{eq:auxiliary-exact-equations} +\end{equation} +and $(A,C,D_\eps)$ is a positive triple. Its sign agrees with positive +area on the oriented fibers. The construction uses an auxiliary +cohomology class, whose relation to the required class $[B]$ is stated in +\Cref{prop:auxiliary-class}. +\end{theorem} + +The form $D_\eps$ supplies a known taming class for the later pair +deformation. To recover the original third class, we need the following +comparison, with one choice of $\eps$ valid for every curve that may +appear along that deformation. + +\begin{proposition}[Class and chamber of the auxiliary form] +\label{prop:auxiliary-class} +Fix a norm on the finite-dimensional space $V$. The forms of +\Cref{thm:auxiliary-solution} can be chosen so that +\begin{equation} +\begin{split} + [D_\eps]&=\lambda_\eps F+\eps u_\eps,\qquad u_\eps\in V,\\ + \|u_\eps\|&\le K,\qquad u_\eps F\ge a_0>0,\\ + c_0\eps^{-1}&\le\lambda_\eps\le c_1\eps^{-1}, +\end{split} +\label{eq:auxiliary-class-expansion} +\end{equation} +for fixed positive constants and all sufficiently small $\eps$. +Moreover $[D_\eps]$ and $[B]$ belong to the same component of the +positive cone of $V$. + +There is a single sufficiently small choice of $\eps$ with the +following property. For every definite closed pair with periods +$[A],[C]$, with either associated almost-complex sign, and every +irreducible closed curve for that structure with class +$d\in H^2(X;\Z)/\mathrm{torsion}$, +\begin{equation} + [D_\eps]d>0\quad\Longrightarrow\quad[B]d>0. + \label{eq:auxiliary-uniform-transfer} +\end{equation} +The choice depends only on the prepared construction and its period +data, and is independent of the later pair or curve. +\end{proposition} + +We first glue an invariant solution on the regular region to the exact +nodal models and impose three cohomological moments. The remaining +errors are exponential in $\eps^{-1}$, whereas the inverse and +multiplication estimates needed to correct them have only polynomial +losses. This balance between exponential gluing error and polynomial +analytic loss follows the collapsing strategy of Gross--Wilson +\cite[Sections~4--5]{GrossWilson2000}. Here the correction is an exact +two-form: a global complex structure, needed for a scalar complex +Monge--Amp\`ere equation, is not yet available. The final subsection +proves \Cref{prop:auxiliary-class} by computing $[D_\eps]$ from the +prepared fibration and excluding all curve classes with negative fiber +pairing at once. + +\subsection{The invariant solution and its gluing} + +On the regular part define +\begin{equation} +\begin{split} + \beta_\eps + &=\frac{1}{2\eps}p_*(A^2) + -\frac{\eps}{2}p_*(\Psi^2),\\ + D^{\mathrm{sf}}_\eps&=\eps\Psi+p^*\beta_\eps. +\end{split} +\label{eq:auxiliary-semiflat} +\end{equation} +Here $p_*$ is integration along the oriented torus fibers. Every +two-form on the two-dimensional base is closed, so +$D^{\mathrm{sf}}_\eps$ is closed. Since $A$ and $C$ have zero vertical +restriction, their products with a basic two-form vanish. Thus +\Cref{eq:auxiliary-prepared-orthogonality} gives +\[ + D^{\mathrm{sf}}_\eps\wedge A + =D^{\mathrm{sf}}_\eps\wedge C=0. +\] +For any invariant top form $\zeta$ on the regular part, +\begin{equation} + \zeta=\Psi\wedge p^*(p_*\zeta). + \label{eq:auxiliary-fiber-integration} +\end{equation} +This is the invariant fiber-integration identity +\eqref{eq:regular-invariant-top-form} for the prepared form $\Psi$. +Expanding the square in \Cref{eq:auxiliary-semiflat} and using +\Cref{eq:auxiliary-fiber-integration}, we obtain +\begin{equation} +\begin{split} + (D^{\mathrm{sf}}_\eps)^2 + &=\eps^2\Psi^2+2\eps\Psi\wedge p^*\beta_\eps\\ + &=\eps^2\Psi^2+ + \Psi\wedge p^*\bigl(p_*(A^2)-\eps^2p_*(\Psi^2)\bigr) + =A^2. +\end{split} +\label{eq:auxiliary-semiflat-square} +\end{equation} +The resulting triple is positive, and the sign of its third form is +specified by its vertical restriction, which has integral $\eps>0$. + +In a nodal disk with holomorphic volume form +$\Sigma=h\,\dd s\wedge\dd z$, the prepared data are +\[ + A=\operatorname{Re}\Sigma,\qquad + C=x_0\operatorname{Re}\Sigma+y_0\operatorname{Im}\Sigma, + \qquad y_0\ne0, +\] +with $x_0,y_0$ constant. On its regular part +$\Psi=\dd a\wedge\dd b$, so $\Psi^2=0$. Consequently +\Cref{eq:auxiliary-semiflat} is precisely +\begin{equation} + \eps\,\dd a\wedge\dd b + +\frac{|h|^2}{\eps}\operatorname{Im}\tau(s)\, + \dd x_1\wedge\dd x_2, + \qquad s=x_1+i x_2. + \label{eq:auxiliary-model-semiflat} +\end{equation} +The form $D^{\mathrm{loc}}_\eps$ of \Cref{thm:nodal-model} has the same +two periods on a regular annular torus bundle and differs from +\Cref{eq:auxiliary-model-semiflat} exponentially in every fixed finite +number of derivatives. + +Here is an explicit bounded primitive construction for this gluing. +After choosing a radial trivialization, a fixed annular bundle is +$M\times[r_0,r_1]$, where $M$ is its compact three-dimensional mapping +torus. If $\zeta$ is an exact closed two-form on this annulus, radial +homotopy gives +\[ + \zeta=\pi_M^*(\zeta|_{M\times\{r_*\}})+\dd K\zeta, + \qquad + K\zeta(r)=\int_{r_*}^{r}\iota_{\partial_r}\zeta(u)\,\dd u. +\] +The restriction at $r_*$ is exact. For a fixed metric on $M$, let +$G_M$ be the Green operator on the complement of harmonic forms. +Then $\dd_M^*G_M(\zeta|_{r_*})$ is a primitive of that restriction. +Adding its pullback to $K\zeta$ produces a primitive on a slightly +smaller annulus. Fixed-geometry elliptic estimates on $M$ and the radial +integral bound its $C^j$ norm by finitely many $C^\ell$ norms of $\zeta$. +All these operators and domains are independent of $\eps$. + +Apply this construction to +$D^{\mathrm{loc}}_\eps-D^{\mathrm{sf}}_\eps$. Exactness follows from +the two annular period equalities in \Cref{thm:nodal-model}. We obtain +a primitive $\alpha_\eps$ with exponential finite-order bounds. For a +fixed cutoff $\chi$ equal to one at the inner edge and zero at the outer +edge, replace $D^{\mathrm{sf}}_\eps$ on the annulus by +\[ + D^{\mathrm{sf}}_\eps+\dd(\chi\alpha_\eps). +\] +It equals $D^{\mathrm{loc}}_\eps$ at the inner edge and +$D^{\mathrm{sf}}_\eps$ at the outer edge. Filling the inner disk with +$D^{\mathrm{loc}}_\eps$ gives a smooth closed form $E_\eps$ on $X$. +The differences from the exact equations are supported on the fixed +gluing annuli and have exponential finite-order bounds there. In +particular the wedge Gram matrix remains positive for small $\eps$. +When there are no nodal fibers, simply take +$E_\eps=D^{\mathrm{sf}}_\eps$ on all of $X$. + +The remaining correction will be exact. It therefore cannot change +$\int_X A\wedge D$, $\int_X C\wedge D$, or $\int_X D^2$ for a closed +form $D$. We must first impose the values required by the three target +equations: zero for the first two integrals and one for the third. Set +\begin{equation} +\begin{aligned} + a_\eps&=\int_X E_\eps\wedge A,& + b_\eps&=\int_X E_\eps\wedge C,\\ + \widehat E_\eps&=E_\eps-a_\eps A-b_\eps C,& + q_\eps&=\int_X\widehat E_\eps^2,\\ + r_\eps&=q_\eps^{-1/2},& + D^0_\eps&=r_\eps\widehat E_\eps . +\end{aligned} +\label{eq:auxiliary-normalization} +\end{equation} +The period normalization gives +$\int A^2=\int C^2=1$ and $\int A\wedge C=0$. Thus +\begin{equation} + \int_X A\wedge D^0_\eps + =\int_X C\wedge D^0_\eps=0,\qquad + \int_X(D^0_\eps)^2=1. + \label{eq:auxiliary-exact-moments} +\end{equation} +The approximate equations give +$a_\eps,b_\eps=O(e^{-c/\eps})$ and +$q_\eps=1+O(e^{-c/\eps})$, after reducing $c>0$ if necessary. +Hence $q_\eps>0$ and $r_\eps=1+O(e^{-c/\eps})$. +Subtracting constant multiples of $A,C$ and multiplying the third form +by a positive constant do not change the pointwise three-plane spanned +by the triple. + +\subsection{Polynomial geometry and Sobolev bounds} + +Let $g_\eps$ be the metric whose self-dual three-plane is +$\operatorname{span}(A,C,D^0_\eps)$ and whose volume form is +\begin{equation} + \nu=\frac{A^2}{2}. + \label{eq:auxiliary-fixed-volume} +\end{equation} +The preceding span observation allows us to use $E_\eps$ in this +definition as well. In particular $\vol_{g_\eps}(X)=1/2$. +Sobolev norms in the rest of this section are intrinsic norms for +$g_\eps$, using its covariant derivative and volume. + +\begin{lemma}[Bounds for the approximate triple] +\label{lem:auxiliary-geometry} +For every fixed nonnegative integer $k$, the following statements hold +for sufficiently small $\eps$. +\begin{enumerate}[label=\textup{(\roman*)}] +\item +The metric has a finite coordinate cover whose cardinality, inverse +coordinate radii, inverse interior margins, metric and inverse-metric +comparisons, and coefficient derivatives through any prescribed finite +order are bounded by powers of $\eps^{-1}$. +\item +The frame $(A,C,D^0_\eps)$ and the inverse of its pointwise Gram matrix +have polynomial intrinsic derivative bounds through order $k$. The +Gram matrix itself is uniformly positive and bounded. +\item +Sobolev embedding and multiplication at a fixed sufficiently large +order have polynomial constants. In particular, for an integer +$k\ge6$ there are constants $C,q$ such that +\begin{equation} + \|h\wedge \widetilde h\|_{H^k} + \le C\eps^{-q}\|h\|_{H^k}\|\widetilde h\|_{H^k} + \label{eq:auxiliary-product} +\end{equation} +for two-forms $h,\widetilde h$. +\item +The three free residuals +\begin{equation} + \mathcal R_\eps= + \left(-A\wedge D^0_\eps,\, + -C\wedge D^0_\eps,\, + \frac{A^2-(D^0_\eps)^2}{2}\right) + \label{eq:auxiliary-residual} +\end{equation} +satisfy, for some $C,s,c>0$ depending on the chosen finite order, +\begin{equation} + \|\mathcal R_\eps\|_{H^k} + \le C\eps^{-s}e^{-c/\eps}. + \label{eq:auxiliary-residual-estimate} +\end{equation} +\end{enumerate} +\end{lemma} + +\begin{proof} +We first check the three types of region in the construction. On a +model core, $A$ and $C$ are fixed constant linear combinations of the +two parallel real components of $\Sigma$, and $E_\eps$ is the local +parallel K\"ahler form. The model metric has volume $A^2/2$. +Consequently it is exactly $g_\eps$ there. The intrinsic charts and +bounds of \Cref{thm:nodal-model} therefore apply. This argument +transports the metric, forms, and charts together through the +holomorphic identification of the model disks. It requires no bound +on derivatives of that identification in a separate fixed smooth +atlas. + +On the complement of smaller nodal disks, use finitely many fixed +regular bundle charts. The coefficients in +\Cref{eq:auxiliary-semiflat} and all their fixed-order derivatives +grow at most polynomially in $\eps^{-1}$. Its products with $A,C$ +vanish and its square is $A^2$. The remaining two-by-two wedge block +is that of the fixed definite pair. It is uniformly positive on this +compact region, and the same assertion holds on the cores because +there its coefficients are fixed constants. The exponential annular +gluing errors preserve these bounds on all of $X$. + +For completeness, the passage from these form bounds to metric bounds +is algebraic. Normalize the frame by the positive square root of its +wedge Gram matrix, obtaining $\Theta_1,\Theta_2,\Theta_3$ with +$\Theta_i\wedge\Theta_j=2\delta_{ij}\nu$ and with the frame orientation +chosen for a positive metric. In oriented coordinates, the identity +\begin{equation} + g_\eps(v,w)\nu + =\frac16\sum_{i,j,\ell=1}^3 + \epsilon_{ij\ell} + (\iota_v\Theta_i)\wedge(\iota_w\Theta_j)\wedge\Theta_\ell + \label{eq:auxiliary-metric-algebra} +\end{equation} +follows by evaluating on a standard self-dual orthonormal frame. +In the fixed regular charts this gives polynomial coefficient and +derivative bounds for $g_\eps$. Its determinant in these charts is +fixed by $\nu$, so the adjugate formula gives polynomial bounds for +the inverse metric as well. The core metric and inverse bounds were +already supplied by the transported model charts. Matrix square +roots and inverses have bounded derivatives on the uniformly positive +Gram matrices in question. This also proves the claimed frame +bounds. On the fixed annuli all comparisons remain polynomial after +the exponential changes. Curvature and any fixed number of its +covariant derivatives are consequently polynomially bounded. + +We spell out why local chart control gives a polynomial global +cover. Shrink the charts uniformly by powers of $\eps$ so that +every point has a chart containing an intrinsic ball of radius +$\rho_\eps\ge c_1\eps^{a_1}$. In that chart both the coordinate +domain radius and the upper and lower metric eigenvalue bounds are +controlled by powers of $\eps$. A coordinate ball of polynomial +radius lies in a fixed smaller intrinsic ball, and its volume density +has a polynomial lower bound. It follows that every intrinsic ball +of radius, say, $\rho_\eps/8$ has volume at least +$c_2\eps^{a_2}$, after a further common polynomial shrinkage if needed. +A maximal disjoint collection of these balls has at most +$(2c_2\eps^{a_2})^{-1}$ members because the total volume is $1/2$. +Their enlarged balls cover $X$ and still fit in controlled charts. +Coordinate cutoff functions and a normalized partition of unity have +polynomial derivative bounds. Even the crude overlap bound by the +number of charts is polynomial. This proves (i) with the asserted +global control. + +Euclidean Sobolev estimates on this cover, followed by the polynomial +coordinate and covariant-derivative comparisons, give polynomial +intrinsic Sobolev constants. Since the dimension is four and +$k\ge6$, derivatives of order at most $\lfloor k/2\rfloor$ are bounded +in $L^\infty$ by the $H^k$ norm with such a constant. Apply the +intrinsic product rule to each derivative of $h\wedge\widetilde h$, +placing the factor with fewer derivatives in $L^\infty$ and the +other in $L^2$. This proves \Cref{eq:auxiliary-product}. + +Before normalization the residuals vanish on the cores and outside +the gluing annuli. On the annuli their fixed-coordinate derivatives +are exponentially small; all conversions just described cost only +powers of $\eps^{-1}$. The constant corrections in +\Cref{eq:auxiliary-normalization} introduce exponentially small +coefficients multiplying forms with polynomial intrinsic bounds. +The fixed total volume then gives +\Cref{eq:auxiliary-residual-estimate} and proves (iv). +\end{proof} + +\subsection{An inverse on exact two-forms} + +The three moment equations now allow us to invert the linearized wedge +equations on exact two-forms. Stokes' theorem will control their full +$L^2$ norm by their self-dual part. Estimating the exact two-form itself +in this way avoids a spectral estimate for its one-form primitive in +the collapsing metrics. The exact-form elliptic framework and the +Stokes identity occur in Donaldson's study of closed two-forms +\cite[Section~2, Proposition~1, and Section~4, Lemma~1]{Donaldson2006}; +the estimates below track the constants through the collapsing family. + +\begin{lemma}[Exact-form inverse] +\label{lem:auxiliary-inverse} +For fixed $\eps$, let $f=(f_1,f_2,f_3)$ be top forms with +$\int_X f_i=0$. There is a unique exact two-form +$h=\mathcal L_\eps f$ satisfying +\begin{equation} + A\wedge h=f_1,\qquad C\wedge h=f_2,\qquad + D^0_\eps\wedge h=f_3. + \label{eq:auxiliary-linear-system} +\end{equation} +For each fixed integer $k\ge0$, this inverse extends to the corresponding +Sobolev spaces and satisfies +\begin{equation} + \|\mathcal L_\eps f\|_{H^k} + \le P_\eps\|f\|_{H^k}, + \qquad P_\eps\le C_k\eps^{-p_k}. + \label{eq:auxiliary-inverse-bound} +\end{equation} +No lower bound for the first positive eigenvalue on one-forms is +required. +\end{lemma} + +\begin{proof} +Put $E_1=A$, $E_2=C$, and $E_3=D^0_\eps$, and let $M$ be their +pointwise inner-product Gram matrix for $g_\eps$. The equations +uniquely specify the self-dual part $\phi=h^+$: if +$f_i=t_i\nu$, then +\begin{equation} + \phi=\sum_{j=1}^3(M^{-1}t)_jE_j. + \label{eq:auxiliary-selfdual-data} +\end{equation} +Moreover +\begin{equation} + \langle\phi,E_i\rangle_{L^2}=\int_X f_i=0. + \label{eq:auxiliary-cokernel-moments} +\end{equation} +Each $E_i$ is closed and self-dual, hence harmonic. +\Cref{prop:topology} gives $b^+(X)=3$, so these three linearly +independent forms are a basis of the harmonic self-dual forms. +Thus \Cref{eq:auxiliary-cokernel-moments} is exactly the solvability +condition for $\dd^+a=\phi$. + +One may see existence directly from the Hodge Green operator $G$ for +$g_\eps$ \cite[Equations~(2.1)--(2.2)]{TaylorHodge2010}. +Since $\phi$ is orthogonal to the harmonic self-dual +forms and the Hodge Laplacian commutes with the star, $G\phi$ is +self-dual and $\Delta G\phi=\phi$. For a self-dual two-form $\psi$, +$2(\dd\dd^*\psi)^+=\Delta\psi$. Therefore +\begin{equation} + h=2\dd\dd^*G\phi + \label{eq:auxiliary-green-formula} +\end{equation} +is exact and has self-dual part $\phi$. This formula proves +existence for each fixed metric; we will not estimate the Green +operator itself. + +If $h$ is exact, Stokes' theorem gives +\begin{equation} + 0=\int_Xh\wedge h + =\|h^+\|_2^2-\|h^-\|_2^2, + \qquad + \|h\|_2=\sqrt2\,\|h^+\|_2. + \label{eq:auxiliary-exact-ltwo} +\end{equation} +In particular an exact anti-self-dual two-form is zero, proving +uniqueness. This identity is also the required $L^2$ estimate, +independent of any positive spectral gap. + +For higher derivatives use +\begin{equation} + \dd h=0,\qquad \dd(*h)=2\dd\phi,\qquad + \dd^*h=-2*\dd\phi. + \label{eq:auxiliary-divergence-identities} +\end{equation} +The integrated Weitzenb\"ock identity for two-forms gives +\[ + \|\nabla h\|_2^2 + \le 4\|\dd\phi\|_2^2 + +C\|\operatorname{Rm}\|_\infty\|h\|_2^2. +\] +To iterate, apply the same identity to the tensor-valued form +$\nabla^j h$. Commuting covariant differentiation with alternating +derivative and divergence produces only curvature derivatives +multiplied by lower derivatives of $h$. Using +\Cref{eq:auxiliary-divergence-identities}, this yields, for fixed $j$, +\[ + \|\nabla^{j+1}h\|_2 + \le C_j\|\phi\|_{H^{j+1}} + +K_{j,\eps}\|h\|_{H^j}, +\] +where $K_{j,\eps}$ is a polynomial in finitely many suprema of +curvature and its derivatives. Those suprema are polynomially +bounded by \Cref{lem:auxiliary-geometry}. Induction starting with +\Cref{eq:auxiliary-exact-ltwo} thus bounds $\|h\|_{H^k}$ by a +polynomial multiple of $\|\phi\|_{H^k}$, without losing derivatives. +Finally \Cref{eq:auxiliary-selfdual-data} and the frame and +inverse-Gram bounds give the same estimate in terms of $f$. +Smooth approximation, or the fixed-metric Green formula, gives the +Sobolev version. Uniqueness is always asserted for $h$, rather than +for its one-form primitive. +\end{proof} + +\subsection{The nonlinear correction} + +\begin{proof}[Proof of \Cref{thm:auxiliary-solution}] +Fix once and for all an integer $k\ge6$. Every constant and exponent +in the following argument uses only finitely many derivatives at +this order. Let $\mathcal E^k_\eps$ be the closed subspace of +$H^k$ two-forms consisting of exact forms. Equivalently, its elements +are distributionally closed and have zero harmonic projection; they +possess $H^{k+1}$ primitives for this fixed metric. + +Writing $D_\eps=D^0_\eps+h$, the desired equations become the +fixed-point equation +\begin{equation} + h=\mathcal T_\eps(h):= + \mathcal L_\eps + \left(-A\wedge D^0_\eps,\, + -C\wedge D^0_\eps,\, + \frac{A^2-(D^0_\eps)^2-h\wedge h}{2}\right). + \label{eq:auxiliary-contraction-map} +\end{equation} +This map is defined on all of $\mathcal E^k_\eps$. Indeed, the +first two data have integral zero by +\Cref{eq:auxiliary-exact-moments}, as does the free term in the +third slot. For each exact iterate, including Sobolev iterates, +$\int_Xh\wedge h=0$ by approximation and Stokes' theorem. +Thus every iteration satisfies precisely the three mean conditions +of \Cref{lem:auxiliary-inverse}. + +Let $\delta_\eps=\|\mathcal R_\eps\|_{H^k}$, let $P_\eps$ be an +inverse bound from \Cref{eq:auxiliary-inverse-bound}, and let +$Q_\eps$ be a multiplication bound from +\Cref{eq:auxiliary-product}. Increasing them if necessary, write +\begin{equation} + P_\eps\le C\eps^{-p},\qquad + Q_\eps\le C\eps^{-q},\qquad + \delta_\eps\le C\eps^{-s}e^{-c/\eps}. + \label{eq:auxiliary-polynomial-losses} +\end{equation} +On the ball of radius $R_\eps=2P_\eps\delta_\eps$ in +$\mathcal E^k_\eps$, +\begin{align} + \|\mathcal T_\eps(h)\|_{H^k} + &\le P_\eps\delta_\eps+ + \tfrac12P_\eps Q_\eps R_\eps^2, + \label{eq:auxiliary-ball-bound}\\ + \|\mathcal T_\eps(h)-\mathcal T_\eps(\widetilde h)\|_{H^k} + &\le P_\eps Q_\eps R_\eps\, + \|h-\widetilde h\|_{H^k}. + \label{eq:auxiliary-lipschitz-bound} +\end{align} +Choose $\eps$ so small that +\begin{equation} + 2P_\eps^2Q_\eps\delta_\eps<\frac12. + \label{eq:auxiliary-smallness} +\end{equation} +This is possible because its left side is at most +$C\eps^{-(2p+q+s)}e^{-c/\eps}$, which tends to zero. +The ball is invariant and the Lipschitz constant is less than +$1/2$. The contraction theorem gives an exact solution with +\begin{equation} + \|h\|_{H^k}\le 2P_\eps\delta_\eps. + \label{eq:auxiliary-correction-size} +\end{equation} +If the residual is zero, the same conclusion follows directly by +taking $h=0$. Polynomial losses can always be absorbed by replacing +$c$ with any fixed smaller positive exponent. Thus the correction +is exponentially small also in $C^0$, by the polynomial Sobolev +embedding bound. The uniformly positive Gram matrix of the +approximate triple stays positive, with the same choice of sign. +\Cref{eq:auxiliary-contraction-map} gives +\Cref{eq:auxiliary-exact-equations} exactly. + +We finish by proving spatial smoothness; no simultaneous estimate +over infinitely many derivative orders is needed. For the now fixed +$\eps$, choose a Coulomb primitive $a\in H^{k+1}$ of $h$, so +$\dd a=h$ and $\dd^*a=0$. The three equations for +$D^0_\eps+\dd a$, together with this gauge, form a first-order +nonlinear system for the four components of $a$. +At the solution the principal symbol of its linearization sends a covector-valued +unknown $b$ at a nonzero covector $\xi$ to the three wedge slots +of $\xi\wedge b$ against $A,C,D_\eps$, together with +$\iota_{\xi^\sharp}b$. +If the three wedge slots vanish, $\xi\wedge b$ belongs to the +negative-definite wedge-orthogonal complement of the positive +three-plane. But $(\xi\wedge b)^2=0$, so $\xi\wedge b=0$. +It follows that $b$ is a multiple of $\xi$, and the gauge slot +then forces $b=0$. The symbol is square, hence invertible. + +Since $k\geq6$ in real dimension four, the initial Sobolev order gives +$a\in C^{4,\alpha}$ and at least $C^{3,\alpha}$ coefficients +for this elliptic linearization, for some $0<\alpha<1$. +Differentiate the system in a smooth coordinate chart. The +derivative of $a$ satisfies the linearized elliptic system, with +right-hand side involving only smooth background derivatives and +already controlled first derivatives of $a$. These coefficients and +the right-hand side are $C^{3,\alpha}$, so local first-order elliptic +estimates with finitely differentiable coefficients +\cite[Section~4, Theorem~4.3]{TaylorNonlinearEllipticNotes} +give $\partial a\in C^{4,\alpha}$ and hence +$a\in C^{5,\alpha}$. Repeating this argument gives smoothness. +All constants in this bootstrap may depend on the fixed $\eps$. +The resulting $D_\eps$ is therefore smooth and proves the theorem. +\end{proof} + +\subsection{The auxiliary class and a uniform chamber estimate} + +We now prove \Cref{prop:auxiliary-class}. The prepared fibration lets +us compute the class modulo $\R F$. The resulting estimate will apply +to every later definite pair with the same periods, even when the fibers +are no longer complex lines for that pair. + +\begin{proof}[Proof of \Cref{prop:auxiliary-class}] +We identify integral curve classes with their Poincar\'e duals. +Choose disjoint closed nodal neighborhoods $N_i$ whose boundaries +lie outside all gluing cutoffs, and put +$U=X\setminus\bigcup_i\operatorname{int}N_i$. The restriction of +$E_\eps$ to $U$ is $D^{\mathrm{sf}}_\eps$. If there is at least +one node, $U$ fibers over a compact surface with nonempty boundary, +whose second real cohomology is zero. Thus the basic term in +\Cref{eq:auxiliary-semiflat} is exact on $U$, and +\begin{equation} + [D^0_\eps]|_U + =r_\eps\bigl(\eps[\Psi]|_U + -a_\eps[A]|_U-b_\eps[C]|_U\bigr). + \label{eq:auxiliary-restriction-class} +\end{equation} +In particular its restriction divided by $\eps$ is bounded. + +When there is a node, the kernel of the restriction map +$H^2(X;\R)\longrightarrow H^2(U;\R)$ is exactly $\R F$. +To verify this assertion, excision and +Poincar\'e--Lefschetz duality identify +\[ + H^2(X,U;\R) + \simeq\bigoplus_i H^2(N_i,\partial N_i;\R) + \simeq\bigoplus_i H_2(N_i;\R). +\] +A one-node neighborhood has the homotopy type of a torus with its +primitive vanishing cycle killed, and its second homology is generated +by the fiber. Under the map to $H^2(X;\R)$ these generators give +the Poincar\'e dual fiber classes, all equal to the nonzero class $F$. +The long exact sequence of the pair gives the assertion. +Hence restriction induces an injective map from +$H^2(X;\R)/\R F$ onto its image. Its inverse on that +finite-dimensional image is bounded. \Cref{eq:auxiliary-restriction-class} proves that the class +$[D^0_\eps]$ modulo $\R F$ is $O(\eps)$. + +The nonlinear correction is exact, so +$[D_\eps]=[D^0_\eps]\in V$. Choose a fixed linear complement of +$\R F$ in $V$ and use it to lift the quotient class divided by +$\eps$ to a bounded vector $u_\eps$. This gives +$[D_\eps]=\lambda_\eps F+\eps u_\eps$. +Choose any regular fiber outside the gluing region. The original +glued form has integral $\eps$ there; the subtracted forms $A,C$ +have zero fiber integrals, and the correction is exact. Therefore +\begin{equation} + [D_\eps]F=r_\eps\eps,\qquad u_\eps F=r_\eps=1+O(e^{-c/\eps}). + \label{eq:auxiliary-fiber-area} +\end{equation} +The square normalization and $F^2=0$ now give +\begin{equation} + \lambda_\eps + =\frac{1-\eps^2u_\eps^2}{2\eps(u_\eps F)}. + \label{eq:auxiliary-lambda} +\end{equation} +Boundedness of $u_\eps$ and +\Cref{eq:auxiliary-fiber-area} prove +\Cref{eq:auxiliary-class-expansion}. + +If there are no nodal fibers, $\Psi$ is defined on all of $X$ and +the basic term in \Cref{eq:auxiliary-semiflat} is a multiple of +$F$ in cohomology. The form $D^{\mathrm{sf}}_\eps$ already solves +the equations, so one takes it for $D_\eps$; the same conclusions +follow with $u_\eps=[\Psi]$, $r_\eps=1$, and the coefficient +computed by \Cref{eq:auxiliary-lambda}. + +It remains to establish the uniform implication. By +\Cref{cor:curve-signs}, every curve class under consideration with +$[D_\eps]d>0$ satisfies $d^2\ge-2$ and the following exhaustive +alternatives: either $m=Fd\ne0$ has the same sign as $[B]d$, +or $d=cF$ for a nonzero real number $c$. The latter alternative +has no sign difficulty, since both $[D_\eps]F$ and $[B]F$ are +positive. + +Choose a null vector $G_1\in V$ with $FG_1=1$. Such a choice is +obtained from any vector pairing to one with $F$ by subtracting +half its square times $F$. The orthogonal complement of +$\operatorname{span}(F,G_1)$ in the Lorentzian space $V$ is +negative definite. Decompose +\[ + d=mG_1+nF+z,\qquad + u_\eps=\alpha_\eps G_1+\beta_\eps F+w_\eps, +\] +where $z,w_\eps$ lie in that complement, and use the Euclidean norm +$|z|^2=-z^2$ there. We have +$\alpha_\eps=u_\eps F\ge a_0$ and uniform bounds for +$\alpha_\eps,\beta_\eps,w_\eps$. + +Suppose that $m<0$. Integrality of $F$ and $d$ means +$m=-a$ for an integer $a\ge1$. The square bound gives +\begin{equation} + -2an-|z|^2=d^2\ge-2, + \qquad + n\le\frac{2-|z|^2}{2a}. + \label{eq:auxiliary-negative-intersection} +\end{equation} +Complete the square in the negative-definite component: +\begin{align} + u_\eps d + &\le\frac{\alpha_\eps}{a} + -\frac{\alpha_\eps|z|^2}{2a} + +|w_\eps||z|+|\beta_\eps|a \notag\\ + &\le\frac{\alpha_\eps}{a} + +a\left(\frac{|w_\eps|^2}{2\alpha_\eps} + +|\beta_\eps|\right) + \le Ka. + \label{eq:auxiliary-completed-square} +\end{align} +The constant $K$ is independent of $a,z,d$, and of the future +almost-complex structure. It follows that +\begin{equation} + [D_\eps]d + =-\lambda_\eps a+\eps u_\eps d + \le a\left(-\frac{c_0}{\eps}+K\eps\right)<0 + \label{eq:auxiliary-chamber-exclusion} +\end{equation} +whenever $\eps^20$ and excludes every +negative integer $m$ simultaneously. The remaining alternative +$m>0$ gives $[B]d>0$, proving +\Cref{eq:auxiliary-uniform-transfer}. + +Finally, both $[D_\eps]$ and $[B]$ have positive square and +pair positively with the same nonzero null vector $F$. In a +Lorentzian space the two components of the positive cone are +distinguished by the sign of pairing with a fixed nonzero null +vector: no positive vector is orthogonal to it. Thus the two +classes are in the same component. All restrictions on $\eps$ +in this proof depend only on fixed construction data and the +original periods. They can therefore be imposed before choosing +any later pair deformation. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/11-endpoint.tex b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/11-endpoint.tex new file mode 100644 index 0000000000000000000000000000000000000000..df7f8b61f73d132ccd3d89da24ee13d7e7c6ae59 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/build/sections/11-endpoint.tex @@ -0,0 +1,185 @@ +\section{The hyperk\"ahler endpoint}\label{sec:endpoint} + +We now use the auxiliary form $D$ to construct the endpoint while the +actual triples retain the three original classes. The first K\"ahler +step produces $C_1\in[C]$; the uniform chamber estimate keeps $[B]$ +available along the segment from $C$ to $C_1$; and the second K\"ahler +step produces its prescribed endpoint $B_1\in[B]$. We then choose +the third form smoothly along that segment with both endpoint values +fixed, using \Cref{lem:smooth-tamers}. We first record the classical +class and volume criteria used in the two K\"ahler steps. + +\begin{lemma}\label{lem:endpoint-kahler-class} +Let $(X,J)$ be a compact connected complex surface with even first +Betti number. Suppose a real $(1,1)$ class $H$ has $H^2>0$ and contains +a closed form $\beta$ taming $J$. Then $H$ is a K\"ahler class. +If $\nu$ is a smooth positive four-form with $\int_X\nu=H^2$, there is +a K\"ahler form $\beta_1\in H$ with $\beta_1^2=\nu$. +\end{lemma} + +\begin{proof} +The compact-surface K\"ahler criterion gives a K\"ahler form $\kappa$ +because $b_1$ is even \cite[Theorem~11]{Buchdahl1999}; see also +\cite[Corollaire~5.7]{Lamari1999}. Taming gives +\[ + H\cdot[D]>0 + \quad\text{for every nonzero effective curve }D, + \qquad H\cdot[\kappa]>0. +\] +For the second inequality, pointwise +$\beta\kappa=\beta^{1,1}\kappa>0$, since the invariant part of a tamer +is positive definite. Together with $H^2>0$, these inequalities are +the numerical K\"ahler-class criterion on a surface +\cite[Corollary~15]{Buchdahl1999}. Equivalently, the segment from +$[\kappa]$ to $H$ has positive square and remains positive on every +curve, so the component condition in the numerical characterization +of the K\"ahler cone is satisfied +\cite[Theorem~0.1]{DemaillyPaun2004}. + +Choose a K\"ahler representative $\kappa_H\in H$ and set +$f=\log(\nu/\kappa_H^2)$. The volume hypothesis says +$\int_X e^f\kappa_H^2=\int_X\kappa_H^2$. Yau's theorem produces a +smooth cohomologous K\"ahler form $\beta_1$ with +$\beta_1^2=e^f\kappa_H^2=\nu$ +\cite[Section~4, Theorem~1]{Yau1978}. +\end{proof} + +\begin{lemma}\label{lem:endpoint-hodge-type} +Let $X$ be a compact connected K\"ahler surface with a nowhere-zero +holomorphic two-form $\Omega$. A real degree-two class $H$ is of type +$(1,1)$ if and only if it is intersection-orthogonal to +$[\Re\Omega]$ and $[\Im\Omega]$. +\end{lemma} + +\begin{proof} +Every holomorphic two-form is $f\Omega$ for a global holomorphic +function $f$, hence is a constant multiple of $\Omega$. Thus +$H^{2,0}(X)=\C[\Omega]$. The real plane generated by its real and +imaginary parts is nondegenerate and positive for the intersection +form: their squares are equal and positive and their mixed product +vanishes. Hodge decomposition and type considerations make its +orthogonal complement exactly $H^{1,1}(X;\R)$. +\end{proof} + +\input{figures/endpoint-path} + +\begin{proof}[Proof of \Cref{thm:main}] +We trace the actual form paths and then construct the endpoint; +\Cref{fig:endpoint-path} summarizes the final stages. +All coefficient changes below are constant orthogonal changes, and +will be undone at the end. + +\paragraph{\emph{The prepared pair.}} +Choose the primitive null class $F$ of \Cref{prop:chamber-class} and +rotate the coefficient basis so that $[B]$ points in the direction of +$F^+$ and the pair $[A],[C]$ spans its orthogonal plane in $P$. +The rotated initial triple is denoted $(A,C,B)$; its cohomology Gram +matrix is still the identity. + +The families result and \Cref{prop:nonsplitting,thm:pencil} give an +exact pair deformation to a torus fibration with the stated standard +nodal neighborhoods, keeping $B$ fixed. +\Cref{prop:regular-preparation} then gives a further path of positive +closed triples to invariant regular data with the auxiliary form +$\Psi$. Both stages preserve the three individual classes and start +at the actual representatives supplied by the preceding stage. +Retain the notation +$(A,C,B)$ for the resulting triple. In particular +\begin{equation}\label{eq:endpoint-periods} + [A]^2=[C]^2=[B]^2=1,\qquad + [A][C]=[A][B]=[C][B]=0. +\end{equation} + +\paragraph{\emph{The auxiliary solution.}} +Fix a sufficiently small $\epsilon>0$ for +\Cref{thm:auxiliary-solution,prop:auxiliary-class}, and set +$D=D_\epsilon$. The form $D$ is closed and smooth and satisfies +\begin{equation}\label{eq:endpoint-auxiliary} + AD=CD=0,\qquad D^2=A^2>0. +\end{equation} +The triple with forms $A,C,D$ is positive. The same choice of +$\epsilon$ gives the numerical conclusion of +\Cref{prop:auxiliary-class} for every later definite pair with the +classes $[A],[C]$. These choices precede the K\"ahler constructions +that follow. + +\paragraph{\emph{The first K\"ahler step.}} +By \Cref{lem:complex-symplectic}, $A\pm iD$ is a nowhere-zero +holomorphic two-form for an integrable complex structure $I$; choose the +sign so that $C$ tames $I$. This is possible by +\Cref{lem:definite-pair} and positivity of $(A,D,C)$. +\Cref{prop:topology} gives even $b_1$, so the surface is K\"ahler. +The period relations \eqref{eq:endpoint-periods} and +\eqref{eq:endpoint-auxiliary} give +$[C][A]=[C][D]=0$. Therefore \Cref{lem:endpoint-hodge-type} puts +$[C]$ in real type $(1,1)$. + +Apply \Cref{lem:endpoint-kahler-class} with +$H=[C]$ and $\nu=A^2$. Its integral condition holds by +\eqref{eq:endpoint-periods}. We obtain a K\"ahler representative +$C_1\in[C]$ satisfying +\begin{equation}\label{eq:endpoint-first-yau} + AC_1=DC_1=0,\qquad C_1^2=A^2. +\end{equation} +Let $C_t=(1-t)C+tC_1$. Both endpoints tame $I$, so the entire segment +does. Thus $(A,D,C_t)$ is +positive, and $(A,C_t)$ is a definite pair in the original pair +classes. Moreover $D$ tames its associated almost-complex structure +with the continuously chosen sign. Indeed $D$ is wedge-orthogonal +to both pair forms by \eqref{eq:endpoint-auxiliary} and +\eqref{eq:endpoint-first-yau}, and has positive square. + +\paragraph{\emph{Keeping the third class.}} +Let $J_t$ now denote the structure associated with the moving pair +$(A,C_t)$ and tamed by $D$. For every irreducible $J_t$ curve, its +class $d$ has $[D]d>0$. \Cref{prop:auxiliary-class} implies +$[B]d>0$, and places $[B]$ and $[D]$ in the same open timelike cone +of the fixed space $V$ from \eqref{eq:pair-lorentz-space}. +The hypotheses of \Cref{thm:taming-cone} therefore hold with +$U=[D]$ and $H=[B]$. Thus $[B]$ contains a tamer for every $J_t$. + +At $t=0$ this sign of $J_t$ agrees with the sign previously tamed by +the actual third form $B$. To check this pointwise, take a regular +fiber with its prepared orientation. Both $B$ and $D$ restrict +positively to its tangent planes, which are complex lines for the +prepared pair. They therefore select the same sign there. On the +connected manifold $X$ this choice of sign cannot jump, so $B$ tames +$J_0$ everywhere. We will choose the family of tamers after fixing its +final representative in the next step. + +\paragraph{\emph{The second K\"ahler step.}} +The final pair $(A,C_1)$ is orthogonal with equal square by +\eqref{eq:endpoint-first-yau}. Thus the structure $J_1$ already +selected by $D$ is integrable, with holomorphic volume form +$A\pm iC_1$ for the corresponding sign. The preceding step supplies +a representative of $[B]$ taming this same $J_1$. Even $b_1$ gives +K\"ahlerness again, and \eqref{eq:endpoint-periods} together with +\Cref{lem:endpoint-hodge-type} puts $[B]$ in type $(1,1)$. +Apply \Cref{lem:endpoint-kahler-class} with $H=[B]$ and $\nu=A^2$. +This yields a K\"ahler representative $B_1\in[B]$ such that +\begin{equation}\label{eq:endpoint-final-identities} + AB_1=C_1B_1=0,\qquad B_1^2=A^2=C_1^2. +\end{equation} +Now apply \Cref{lem:smooth-tamers} to the family $J_t$, prescribing +the actual prepared form $B$ at $t=0$ and the newly constructed +$B_1$ at $t=1$. It gives closed tamers $B_t\in[B]$ with these two +endpoint values. Thus $(A,C_t,B_t)$ is a path of positive closed +triples in the original classes, joining the prepared triple to +$(A,C_1,B_1)$ itself. + +Concatenate the finitely many triple paths, reparametrizing each to be +constant to all orders at its endpoints. This produces a smooth path +on $[0,1]$. Each component is closed and remains in its original +class, and positivity holds at every parameter. By +\eqref{eq:endpoint-first-yau} and +\eqref{eq:endpoint-final-identities}, if +$(\eta_1,\eta_2,\eta_3)=(A,C_1,B_1)$ and $\mu_1=A^2/2$, then +\[ + \eta_i\wedge\eta_j=2\delta_{ij}\mu_1. +\] +By \Cref{lem:complex-symplectic}, these forms are parallel and +self-dual for a hyperk\"ahler metric with volume $\mu_1$. +Finally undo the initial orthogonal change of coefficients. +Orthogonality preserves the displayed identity and restores the +original ordered classes, proving the theorem. +\end{proof} diff --git a/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/paper.pdf b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..7c0860665249f38402aa43373c5c944370f06d77 --- /dev/null +++ b/preprints/Deforming-hypersymplectic-four-manifolds-to-hyperkahler-triples-October-7-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92c36602fb4968087ec043e7b3816473b15ab21d0072899f31154337676b2bec +size 848832 diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/README.md b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..34347e38064bc9d4a50522930501d29cea11bfd8 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/README.md @@ -0,0 +1,21 @@ +# [Exact Birch–Swinnerton-Dyer Formula from Low Selmer Corank](exact-bsd-low-selmer-corank.pdf) + +**Author:** OpenAI + +**Date:** October 7, 2026 + +## Citation + +```bibtex +@misc{OAI:Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026, + author = {{OpenAI}}, + title = {{Exact Birch--Swinnerton-Dyer Formula from Low Selmer Corank}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/exact-bsd-low-selmer-corank.pdf}{OAI:Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026}}, + year = {2026} +} +``` + +## Version note + +This version removes an obsolete supporting citation and updates citations to revised manuscripts in this collection; see the [previous version](../Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-3-2026/exact-bsd-low-selmer-corank.pdf). diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/main.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..6b3ef3fb401ddb5cfc5003e066bfdabba506e4c7 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/main.tex @@ -0,0 +1,82 @@ +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage[margin=1.05in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{mathrsfs} +\numberwithin{equation}{section} +\usepackage{microtype} +\usepackage{enumitem,booktabs,array,longtable} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning,calc} +\usepackage{xcolor} +\usepackage[hypertexnames=false,colorlinks=true,linkcolor=blue!45!black,citecolor=green!35!black,urlcolor=blue!45!black]{hyperref} +\hypersetup{pdftitle={Exact Birch--Swinnerton-Dyer Formula from Low Selmer Corank},pdfauthor={OpenAI}} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\newtheorem{claim}[theorem]{Claim} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{hypothesis}[theorem]{Hypothesis} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newcommand{\Q}{\mathbb Q} +\newcommand{\Z}{\mathbb Z} +\newcommand{\F}{\mathbb F} +\newcommand{\C}{\mathbb C} +\newcommand{\R}{\mathbb R} +\newcommand{\N}{\mathbb N} +\DeclareMathOperator{\Sel}{Sel} +\DeclareMathOperator{\Sha}{Sha} +\DeclareMathOperator{\Reg}{Reg} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\corank}{corank} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\length}{length} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\Gal}{Gal} +\DeclareMathOperator{\Frob}{Frob} +\DeclareMathOperator{\Frac}{Frac} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\Tr}{Tr} +\DeclareMathOperator{\Spec}{Spec} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\coker}{coker} +\DeclareMathOperator{\Ann}{Ann} +\DeclareMathOperator{\Tor}{Tor} +\DeclareMathOperator{\rec}{rec} +\setlist{topsep=4pt,itemsep=3pt,parsep=0pt} +\setlength{\emergencystretch}{1.5em} +\clubpenalty=10000 +\widowpenalty=10000 +\displaywidowpenalty=10000 +\title{Exact Birch--Swinnerton-Dyer Formula\protect\\from Low Selmer Corank} +\author{OpenAI} +\date{October 7, 2026} +\begin{document} +\maketitle +\begin{abstract} +We prove the full Birch--Swinnerton-Dyer leading-term formula for every +elliptic curve over $\Q$ whose full $q$-power Selmer group has corank zero +or one at some prime $q$. The analytic and Mordell--Weil ranks equal +that corank, and the Tate--Shafarevich group is finite. The formula +includes all prime factors and requires no additional hypotheses on +reduction, rational torsion, isogenies, complex multiplication, or +residual Galois representations. +\end{abstract} +\tableofcontents +\input{sections/01-introduction} +\input{sections/02-classical} +\input{sections/03-models} +\input{sections/04-vertical} +\input{sections/05-single} +\input{sections/06-pair} +\input{sections/07-theta} +\input{sections/08-extraction} +\input{sections/09-unit} +\input{sections/10-center} +\input{references} +\end{document} diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/references.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/references.tex new file mode 100644 index 0000000000000000000000000000000000000000..2a639dc012f45c0e15b3b6f9861fcb4ea2b6696d --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/references.tex @@ -0,0 +1,230 @@ +\begin{thebibliography}{99} + +\bibitem{BirchSwinnertonDyer} +B.~J. Birch and H.~P.~F. Swinnerton-Dyer, +\emph{Notes on elliptic curves. II}, +J. Reine Angew. Math. \textbf{218} (1965), 79--108. +\href{https://doi.org/10.1515/crll.1965.218.79}{doi:10.1515/crll.1965.218.79}. + +\bibitem{BlochKato} +S. Bloch and K. Kato, +\emph{$L$-functions and Tamagawa numbers of motives}, +in \emph{The Grothendieck Festschrift}, Vol.~I, +Progr. Math. \textbf{86}, Birkh\"auser, Boston, 1990, 333--400. +\href{https://doi.org/10.1007/978-0-8176-4574-8_9}{Publisher's reprint}. + +\bibitem{Bogomolov} +F.~A. Bogomolov, +\emph{Points of finite order on an abelian variety}, +Izv. Akad. Nauk SSSR Ser. Mat. \textbf{44} (1980), no.~4, 782--804; +English translation, Math. USSR-Izv. \textbf{17} (1981), no.~1, 55--72. +\href{https://doi.org/10.1070/IM1981v017n01ABEH001329}{English edition}. + +\bibitem{BCDT} +C. Breuil, B. Conrad, F. Diamond, and R. Taylor, +\emph{On the modularity of elliptic curves over $\mathbb Q$: +wild $3$-adic exercises}, +J. Amer. Math. Soc. \textbf{14} (2001), no.~4, 843--939. +\href{https://doi.org/10.1090/S0894-0347-01-00370-8}{doi:10.1090/S0894-0347-01-00370-8}. + +\bibitem{BurungaleFlach} +A.~A. Burungale and M. Flach, +\emph{The conjecture of Birch and Swinnerton-Dyer for certain +elliptic curves with complex multiplication}, +Cambridge J. Math. \textbf{12} (2024), no.~2, 357--415. +Theorem locators follow +\href{https://arxiv.org/abs/2206.09874v3}{arXiv:2206.09874v3}, +4 September 2023. + +\bibitem{Cassels} +J.~W.~S. Cassels, +\emph{Arithmetic on curves of genus $1$. VIII. +On conjectures of Birch and Swinnerton-Dyer}, +J. Reine Angew. Math. \textbf{217} (1965), 180--199. +\href{https://doi.org/10.1515/crll.1965.217.180}{doi:10.1515/crll.1965.217.180}. + +\bibitem{ChaiOrd} +C.-L. Chai, +\emph{Families of ordinary abelian varieties: canonical coordinates, +$p$-adic monodromy, Tate-linear subvarieties and Hecke orbits}, +preprint, 30 July 2003. +\href{https://www2.math.upenn.edu/~chai/papers_pdf/fam_ord_av.pdf}{Author's manuscript}. + +\bibitem{DeligneRapoport} +P. Deligne and M. Rapoport, +\emph{Les sch\'emas de modules de courbes elliptiques}, +in \emph{Modular Functions of One Variable II}, +Lecture Notes in Math. \textbf{349}, Springer, Berlin, 1973, 143--316. +\href{https://doi.org/10.1007/978-3-540-37855-6_4}{Publisher record}. + +\bibitem{ManinDrinfeld} +V.~G. Drinfeld, +\emph{Two theorems on modular curves}, +Funct. Anal. Appl. \textbf{7} (1973), no.~2, 155--156. +\href{https://doi.org/10.1007/BF01078890}{doi:10.1007/BF01078890}. + +\bibitem{GanQiuTakeda} +W.~T. Gan, Y. Qiu, and S. Takeda, +\emph{The regularized Siegel--Weil formula (the second term identity) +and the Rallis inner product formula}, +Invent. Math. \textbf{198} (2014), no.~3, 739--831. +\href{https://doi.org/10.1007/s00222-014-0509-0}{doi:10.1007/s00222-014-0509-0}. + +\bibitem{GodementJacquet} +R. Godement and H. Jacquet, +\emph{Zeta Functions of Simple Algebras}, +Lecture Notes in Math. \textbf{260}, Springer-Verlag, +Berlin--Heidelberg, 1972. +\href{https://doi.org/10.1007/BFb0070263}{doi:10.1007/BFb0070263}. + +\bibitem{GrossZagier} +B.~H. Gross and D.~B. Zagier, +\emph{Heegner points and derivatives of $L$-series}, +Invent. Math. \textbf{84} (1986), no.~2, 225--320. +\href{https://doi.org/10.1007/BF01388809}{doi:10.1007/BF01388809}. + +\bibitem{HidaMu} +H. Hida, +\emph{The Iwasawa $\mu$-invariant of $p$-adic Hecke $L$-functions}, +Ann. of Math. (2) \textbf{172} (2010), no.~1, 41--137. +\href{https://doi.org/10.4007/annals.2010.172.41}{doi:10.4007/annals.2010.172.41}. + +\bibitem{JetchevSkinnerWan} +D. Jetchev, C. Skinner, and X. Wan, +\emph{The Birch and Swinnerton-Dyer formula for elliptic curves +of analytic rank one}, +Cambridge J. Math. \textbf{5} (2017), no.~3, 369--434. +\href{https://archive.intlpress.com/site/pub/files/_fulltext/journals/cjm/2017/0005/0003/CJM-2017-0005-0003-a002.pdf}{Published article}. + +\bibitem{Kato} +K. Kato, +\emph{$p$-adic Hodge theory and values of zeta functions of modular forms}, +Ast\'erisque \textbf{295} (2004), 117--290. +\href{https://www.numdam.org/item/AST_2004__295__117_0/}{Article and bibliographic record}. + +\bibitem{KatzMazur} +N.~M. Katz and B. Mazur, +\emph{Arithmetic Moduli of Elliptic Curves}, +Annals of Mathematics Studies \textbf{108}, +Princeton University Press, Princeton, NJ, 1985. +\href{https://doi.org/10.1515/9781400881710}{Publisher's digital edition}. + +\bibitem{Kolyvagin} +V.~A. Kolyvagin, +\emph{Euler systems}, +in \emph{The Grothendieck Festschrift}, Vol.~II, +Progr. Math. \textbf{87}, Birkh\"auser, Boston, 1990, 435--483. +\href{https://doi.org/10.1007/978-0-8176-4575-5_11}{Publisher's reprint}. + +\bibitem{Manin} +Yu.~I. Manin, +\emph{Parabolic points and zeta-functions of modular curves}, +Math. USSR-Izv. \textbf{6} (1972), no.~1, 19--64. +\href{https://doi.org/10.1070/IM1972v006n01ABEH001867}{doi:10.1070/IM1972v006n01ABEH001867}. + +\bibitem{MilneBSD} +J.~S. Milne, +\emph{On the arithmetic of abelian varieties}, +Invent. Math. \textbf{17} (1972), 177--190. +\href{https://doi.org/10.1007/BF01425446}{doi:10.1007/BF01425446}. + +\bibitem{Milne} +J.~S. Milne, +\emph{Arithmetic Duality Theorems}, second edition, +BookSurge, 2006. +\href{https://www.jmilne.org/math/Books/adt.html}{Author's edition and corrections}. + +\bibitem{Nekovar} +J. Nekov\'a\v{r}, +\emph{Selmer complexes}, +Ast\'erisque \textbf{310} (2006), viii+559 pp. +\href{https://www.numdam.org/item/AST_2006__310__R1_0/}{Book}. + +\bibitem{Goldfeld} +OpenAI, +\emph{Goldfeld's analytic density conjecture and the $2$-converse for elliptic curves}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf}{OAI:Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026}, +2026. + +\bibitem{C} +OpenAI, +\emph{The Selmer converse for elliptic curves at every prime}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/The-Selmer-converse-for-elliptic-curves-at-every-prime-October-7-2026/main.pdf}{OAI:The-Selmer-converse-for-elliptic-curves-at-every-prime-October-7-2026}, +2026. + +\bibitem{B} +OpenAI, +\emph{The two-primary Birch--Swinnerton-Dyer formula in Selmer corank at most one}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/The-two-primary-Birch-Swinnerton-Dyer-formula-in-Selmer-corank-at-most-one-October-6-2026/paper.pdf}{OAI:The-two-primary-Birch-Swinnerton-Dyer-formula-in-Selmer-corank-at-most-one-October-6-2026}, +2026. + +\bibitem{Rubin} +K. Rubin, +\emph{The ``main conjectures'' of Iwasawa theory +for imaginary quadratic fields}, +Invent. Math. \textbf{103} (1991), 25--68. +\href{https://doi.org/10.1007/BF01239508}{doi:10.1007/BF01239508}. + +\bibitem{Serre} +J.-P. Serre, +\emph{Propri\'et\'es galoisiennes des points d'ordre fini +des courbes elliptiques}, +Invent. Math. \textbf{15} (1972), 259--331. +\href{https://doi.org/10.1007/BF01405086}{doi:10.1007/BF01405086}. + +\bibitem{SkinnerUrban} +C. Skinner and E. Urban, +\emph{The Iwasawa main conjectures for $\mathrm{GL}_2$}, +Invent. Math. \textbf{195} (2014), no.~1, 1--277. +\href{https://doi.org/10.1007/s00222-013-0448-1}{doi:10.1007/s00222-013-0448-1}. + +\bibitem{Smith} +A. Smith, +\emph{The Birch and Swinnerton-Dyer conjecture implies +Goldfeld's conjecture}, +\href{https://arxiv.org/abs/2503.17619v1}{arXiv:2503.\allowbreak17619v1}, 2025. + +\bibitem{TateBSD} +J. Tate, +\emph{On the conjectures of Birch and Swinnerton-Dyer +and a geometric analog}, +S\'eminaire Bourbaki \textbf{9} (1966), Exp.~306, 415--440. +\href{https://www.numdam.org/item/SB_1964-1966__9__415_0/}{Article and bibliographic record}. + +\bibitem{TaylorWiles} +R. Taylor and A. Wiles, +\emph{Ring-theoretic properties of certain Hecke algebras}, +Ann. of Math. (2) \textbf{141} (1995), no.~3, 553--572. +\href{https://doi.org/10.2307/2118560}{doi:10.2307/2118560}. + +\bibitem{Waldspurger} +J.-L. Waldspurger, +\emph{Sur les valeurs de certaines fonctions $L$ automorphes +en leur centre de sym\'etrie}, +Compos. Math. \textbf{54} (1985), no.~2, 173--242. +\href{https://www.numdam.org/item/CM_1985__54_2_173_0/}{Article and bibliographic record}. + +\bibitem{Wiles} +A. Wiles, +\emph{Modular elliptic curves and Fermat's Last Theorem}, +Ann. of Math. (2) \textbf{141} (1995), no.~3, 443--551. +\href{https://doi.org/10.2307/2118559}{doi:10.2307/2118559}. + +\bibitem{Yamana} +S. Yamana, +\emph{On the Siegel--Weil formula: The case of singular forms}, +Compos. Math. \textbf{147} (2011), no.~4, 1003--1021. +\href{https://doi.org/10.1112/S0010437X11005379}{doi:10.1112/S0010437X11005379}. + +\bibitem{Zarhin} +Yu.~G. Zarhin, +\emph{Abelian varieties over fields of finite characteristic}, +Cent. Eur. J. Math. \textbf{12} (2014), no.~5, 659--674. +Theorem locators follow +\href{https://arxiv.org/abs/1301.5594v4}{arXiv:1301.5594v4}, +16 April 2015. + +\end{thebibliography} diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/01-introduction.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..38b31af4b6045d14caab3d50c190ec17dc1c0bc9 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/01-introduction.tex @@ -0,0 +1,281 @@ +\section{Introduction}\label{sec:intro} + +The Birch--Swinnerton-Dyer formula relates the first nonzero Taylor +coefficient of an elliptic curve's $L$-function to its periods, rational +points, local components, and Tate--Shafarevich group. Knowing the order +of vanishing and the finiteness of the Tate--Shafarevich group does not +determine that coefficient. The problem addressed here is the remaining +integral comparison when a full Selmer group has corank zero or one. + +\subsection{Statement and normalization} + +Let $E/\Q$ be an elliptic curve. For a prime $p$, let +$\Sel_{p^\infty}(E/\Q)$ denote the full $p$-power Selmer group, defined +using the local Kummer images at every place, and write +\[ + s_p(E)=\corank_{\Z_p}\Sel_{p^\infty}(E/\Q),\qquad + a(E)=\ord_{s=1}L(E,s),\qquad r(E)=\rank E(\Q). +\] +Here $L(E,s)$ is the uncompleted Hasse--Weil $L$-function with all its +finite Euler factors. Its center is $s=1$. We write +\[ + \Sha(E/\Q)=\ker\left(H^1(\Q,E)\longrightarrow + \prod_v H^1(\Q_v,E)\right). +\] + +Choose a global minimal Weierstrass equation and its Neron differential +$\omega_E$. Our real period and finite component factors are +\[ + \Omega_E=\int_{E(\R)}|\omega_E|, + \qquad c_\ell(E)=[E(\Q_\ell):E_0(\Q_\ell)]. +\] +Thus the real period includes both connected components when there are +two. No separate real-component factor is used. + +We fix the height convention as well. If $x(P)=a/b$ in lowest terms, +$b>0$, put $h_x(P)=\log\max\{|a|,b\}$ and $h_x(O)=0$. Define +\begin{equation}\label{eq:height-convention} + H(P)=\lim_{n\to\infty}4^{-n}h_x([2^n]P),\qquad + B(P,Q)=\frac{H(P+Q)-H(P)-H(Q)}2. +\end{equation} +For a basis $P_1,\ldots,P_r$ of the full free group +$E(\Q)/E(\Q)_{\rm tors}$, set +$\Reg_E=\det(B(P_i,P_j))$; in rank zero set $\Reg_E=1$. +In particular $B(P,P)=H(P)$. An index-$d$ sublattice has pairing +determinant $d^2\Reg_E$. + +\begin{theorem}\label{thm:main} +Let $E/\Q$ be an elliptic curve and let $q$ be any prime. If +$s_q(E)\in\{0,1\}$, then +\[ + r(E)=a(E)=s_q(E),\qquad \#\Sha(E/\Q)<\infty, +\] +and, with $r=r(E)$ and the preceding normalizations, +\begin{equation}\label{eq:bsd-main} + \frac{L^{(r)}(E,1)}{r!} + =\frac{\Omega_E\Reg_E\,\#\Sha(E/\Q) + \prod_{\ell\text{ finite}}c_\ell(E)} + {\#E(\Q)_{\rm tors}^{2}}. +\end{equation} +There are no additional hypotheses on reduction, rational torsion, +isogenies, complex multiplication, or residual Galois representations. +\end{theorem} + +The rank and finiteness assertions are the unrestricted low-corank +converse of \cite{C}; the two-primary leading-term equality is supplied +by \cite{B}. We state these inputs precisely in +Section~\ref{sec:classical}. The new assertion proved here is the exact +valuation of the leading-term formula at every odd prime, independently +of the prime $q$ in the hypothesis. The low-Selmer-corank hypothesis is +essential to the stated scope: it is not replaced here by a hypothesis +on Mordell--Weil rank alone. + +\subsection{Historical context and the integral problem} + +Birch and Swinnerton-Dyer formulated their conjectures from the +relationship between the arithmetic of rational points and the behavior +of the Euler product \cite{BirchSwinnertonDyer}. Tate's account +\cite{TateBSD} placed the rank prediction and the leading-term formula +in the broader arithmetic of abelian varieties. The leading coefficient +contains information that the rank alone cannot see: finite local +components, torsion, the index of a point lattice, and the order of +\(\Sha\) must be compared simultaneously. Cassels's isogeny formula +\cite{Cassels} explains why this combined expression, rather than any +individual factor, is the natural arithmetic invariant. + +The modularity theorems of Wiles, Taylor--Wiles, and +Breuil--Conrad--Diamond--Taylor +\cite{Wiles,TaylorWiles,BCDT} supply the analytic continuation and +functional equation of the \(L\)-function of every elliptic curve over +\(\Q\). Gross--Zagier's height formula \cite{GrossZagier} identifies +a derivative of a quadratic base-change \(L\)-function with the height +of a Heegner point. Kolyvagin's Euler-system argument +\cite{Kolyvagin} then gives rank equality and finiteness of the whole +Tate--Shafarevich group in analytic ranks zero and one. These results +are indispensable here, but their rank and finiteness conclusions do +not by themselves identify every prime valuation of the leading term. + +Iwasawa theory provides a route to those integral refinements. +Rubin's main-conjecture theorem for imaginary quadratic fields +\cite{Rubin} gives leading-term consequences for CM elliptic curves. +Kato's zeta elements and explicit reciprocity law \cite{Kato} +connect modular \(L\)-values with Galois cohomology. In the non-CM +setting, the work of Skinner--Urban \cite{SkinnerUrban} yields +ordinary rank-zero leading-term results under residual and +ramification hypotheses. Jetchev--Skinner--Wan +\cite{JetchevSkinnerWan} prove rank-one formulas for semistable +curves at good primes under irreducibility hypotheses, including +ordinary and supersingular settings in their stated ranges. +These theorems make precise integral comparisons, with their own +local and residual assumptions; they are not used here as +unrestricted odd-primary formulas. + +For CM curves, Burungale--Flach \cite{BurungaleFlach} prove the full +rank-zero BSD formula for their abelian torsion-field class. +Their rational descent applies to CM elliptic curves over \(\Q\). +That theorem supplies the rank-zero CM input in our final step. +The unrestricted low-corank converse \cite{C} and the two-primary +formula \cite{B} are distinct companion inputs. The auxiliary +twist-density theorem \cite{Goldfeld}, whose proof uses Smith's +Selmer-distribution results \cite{Smith}, permits simultaneous +choices of the two imaginary quadratic fields. We state the +scope of each input where it is used. + +The cohomological language of the proof belongs to the arithmetic +duality and Selmer-complex framework +\cite{BlochKato,Milne,Nekovar}. In particular, exact local +orthogonality and determinant lines organize the local factors; +they do not remove the need to compute the integral lattices. +The moving-prime constructions use the Galois-image principles +of Serre and Bogomolov \cite{Serre,Bogomolov}, while analytic +primitivity uses the elliptic tame-stalk independence proved below +by the Chai--Hida rigidity and monodromy method +\cite{ChaiOrd,HidaMu}. The finite-model, switching, and theta +methods of \cite{B,C} provide the starting constructions. +The work below extends the relevant comparisons to residual +tests and to nonaugmentation theta tests with growing \(p\)-level, +and explains why these extensions give an exact center. + +\subsection{The arithmetic discrepancy} + +For an elliptic curve of analytic rank at most one, put +$r=r(E)=a(E)$ and define +\begin{equation}\label{eq:normalized-quotient} + Q_E=\frac{L^{(r)}(E,1)\,\#E(\Q)_{\rm tors}^{2}} + {r!\,\Omega_E\Reg_E\prod_\ell c_\ell(E)}, + \qquad + X_p(E)=v_p(Q_E)-v_p(\#\Sha(E/\Q)), +\end{equation} +where $v_p(p)=1$. These quantities are defined: the analytic low-rank +theorem gives the rank and finiteness statements, and the two-primary +input gives $Q_E\in\Q_{>0}$. The latter applies because the Kummer exact +sequence gives $s_2(E)=r$ once the whole Tate--Shafarevich group is +finite. + +Fix an odd prime $p$. The proof has two distinct outputs: +\begin{align} + X_p(E)&\geq0 &&\text{if $E$ is non-CM and $a(E)\leq1$}, + \label{eq:intro-inequality}\\ + X_p(E)+X_p(E^D)&=0 &&\text{for a suitable imaginary quadratic twist}, + \label{eq:intro-pair} +\end{align} +where $a(E)+a(E^D)=1$. Applying the first inequality to both curves +in the second identity gives $X_p(E)=0$ in the non-CM case. The same +pair identity handles CM curves of analytic rank one after the CM +rank-zero formula is used. This separation is useful: the first +comparison is a one-sided integral statement, whereas the second +requires a unit, not just an integral quotient. + +\subsection{Integral comparisons and the role of theta series} + +The integral objects are finite free models of Galois cochain diagrams +over rings +\[ + R=\Z_p[[t,u_1,\ldots,u_m]]. +\] +The variable $t$ is a genuine cyclotomic or anticyclotomic character +variable. The $u_i$ are limits of tame characters at varying auxiliary +primes. Every finite stage retains $T_pE$, the local conditions, and +the maps, pairings, and homotopies needed for derived specialization. +The tame variables make it possible to test and change the residual +cohomology while retaining an exact integral center. + +The first comparison transfers Kato's modular-symbol construction into +these diagrams. Complementary local-condition comparisons prove that +its normalized determinant coordinate is integral. Exact calibration +against modular symbols in rank zero and a tame height formula in rank +one identifies its central valuation with $X_p(E)$. This proves +\eqref{eq:intro-inequality}; it does not require the normalized coordinate +to be a unit. + +For the pair comparison, one works over +$K=\Q(\sqrt D)$, where $p$ splits as $w\bar w$. There are two determinant +series $L_w,L_{\bar w}$, obtained by imposing the strict (zero) local +condition at one of these places and the full (unrestricted) local +condition at the other. The analytic +series $B_w,B_{\bar w}$ are constructed from bounded CM measures. +After an integral coefficient descent, the relevant quotients are +\[ + U_w=B_w/L_w,\qquad U_{\bar w}=B_{\bar w}/L_{\bar w}. +\] +These formulas initially define elements of a fraction field. The +first task is to prove that they belong to $R$; the second is to prove +that they belong to $R^\times$. + +Two different tests establish integrality and vertical primitivity. +Residual cohomology over $\Frac\F_p[[\mathbf u]]$ makes the determinants +regular in the tame variables modulo $(p,t)$. At sufficiently ramified +finite characters of $t$, local-condition comparisons give divisibility +after inverting $p$. Integral Weierstrass division then gives +$L_w\mid B_w$ over $R$. Independently, linear independence on the +ordinary modular curve proves $p\nmid B_w$. Thus $U_w$ is integral +and has no factor $p$. This does not yet exclude its other irreducible +factors. + +Theta series are used for that remaining purpose. This part of the +proof allows a fixed loss of $p$-adic precision. At a characteristic-zero +divisor where an undepleted CM period vanishes, a theta-to-cusp +comparison produces a nonzero class satisfying a one-sided strict +condition, either for $E$ or for a fixed companion twist. The +comparison needs values at a nontrivial test character, not just the +augmentation. Its proof consequently allows increasing $p$-level and +proves a uniform bound for position-cut moments. A product-character +argument gives the required content bound at every interior test. + +The theta implications make every possible quotient factor regular in +the tame variables. High-character association and the integral +character-division test then identify the two quotient ideals, including +their multiplicities. Adding +finitely many further tame variables then makes their possible +simultaneous strict jumps have codimension at least two. A quotient +divisor has codimension one, so no such divisor remains. Specializing +the added variables to zero is integral, and a unit remains a unit. +This last fact is what permits an exact central comparison; the +rationalized theta construction is not itself read as a formula for +the order of a finite $p$-primary group. + +\begin{figure}[htbp] +\centering +\begin{tikzpicture}[ + box/.style={draw,align=center,text width=5.5cm,inner sep=6pt}, + >=Stealth,node distance=9mm] + \node[box] (integral) {Integral character division\\ + $U_w,U_{\bar w}\in R$, $p\nmid U_wU_{\bar w}$}; + \node[box,below=of integral] (theta) {Theta regularity and character division\\ + $(U_w)=(U_{\bar w})$}; + \node[box,below=of theta] (remove) {New tame directions exclude\\ + simultaneous jumps in codimension one}; + \node[box,below=of remove] (unit) {$U_w,U_{\bar w}\in R^\times$\\ + Exact integral specialization at the center}; + \draw[->] (integral)--(theta); + \draw[->] (theta)--(remove); + \draw[->] (remove)--(unit); +\end{tikzpicture} +\caption{The pair comparison separates integral divisibility from +divisor removal. The theta implication is used on characteristic-zero +divisors; the final specialization takes place in the integral ring.} +\label{fig:pair-comparison} +\end{figure} + +The reusable parts of this argument are the marked residual +obstruction calculation, the integral character-division test, and the +uniform position-cut and product-character estimates. Their roles are +different: the first controls determinant factors above $p$, the +second transfers divisibility from highly ramified characters, and the +third supplies the vanishing implication needed to remove horizontal +factors. We prove the changes needed for these applications rather +than inferring them from the conclusions of the companion papers. + +\subsection{Organization} + +Section~\ref{sec:classical} fixes the arithmetic inputs and the exact +height and period comparisons. Sections~\ref{sec:models} +and~\ref{sec:vertical} construct the integral diagrams and establish +the residual determinant tests. Section~\ref{sec:single} proves the +single-curve inequality, and Section~\ref{sec:pair} constructs the +integral pair quotients. Sections~\ref{sec:theta} +and~\ref{sec:extraction} prove the theta implication, including the +increasing-level and nonaugmentation estimates. +Section~\ref{sec:unit} removes the quotient divisors. +Section~\ref{sec:center} computes the central arithmetic volume and +completes the proof of Theorem~\ref{thm:main}. diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/02-classical.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/02-classical.tex new file mode 100644 index 0000000000000000000000000000000000000000..85ba7cc42ac3a05acf0979d7b0a79a4f072a4c92 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/02-classical.tex @@ -0,0 +1,326 @@ +\section{Arithmetic inputs and exact normalizations}\label{sec:classical} + +The two comparisons will be carried out at a fixed odd prime. This +section explains the reduction to that problem, constructs the +quadratic fields used in the pair comparison, and records the real +arithmetic identity that converts a Heegner-point index into a sum of +BSD discrepancies. None of these reductions asserts an odd-primary +leading-term equality. + +\subsection{The two low-corank inputs} + +For a number field $M$, the compact local Kummer condition for the +Tate lattice $T_pE$ is the image of the completed point module +\[ + E(M_v)^{\wedge}_p=\varprojlim_n E(M_v)/p^nE(M_v) + \longrightarrow H^1(M_v,T_pE). +\] +For discrete coefficients, the local condition is the image of +$E(M_v)\otimes\Q_p/\Z_p$ in $H^1(M_v,E[p^\infty])$. The full Selmer +group uses these conditions at every place. The Kummer exact sequence +is +\begin{equation}\label{eq:kummer-exact} + 0\longrightarrow E(\Q)\otimes\Q_p/\Z_p + \longrightarrow\Sel_{p^\infty}(E/\Q) + \longrightarrow\Sha(E/\Q)[p^\infty]\longrightarrow0. +\end{equation} + +\begin{theorem}[Unrestricted low-corank converse]\label{classical:low-corank} +For every elliptic curve $A/\Q$, every prime $q$, and $u\in\{0,1\}$, +the equality $s_q(A)=u$ implies +\[ + a(A)=r(A)=u,\qquad \#\Sha(A/\Q)<\infty. +\] +\end{theorem} + +This is \cite[Theorem~1.1]{C}. We use its stated conclusion; +we do not interpret its rationalized cohomological construction as +an integral leading-term formula. + +\begin{theorem}[Two-primary leading term]\label{classical:two-primary} +For every elliptic curve $A/\Q$ with $s_2(A)\leq1$, the quotient +$Q_A$ of \eqref{eq:normalized-quotient}, with the total real period +and the full-lattice regulator of \eqref{eq:height-convention}, is a +positive rational number, and +\[ + v_2(Q_A)=v_2(\#\Sha(A/\Q)). +\] +\end{theorem} + +This is \cite[Theorem~1.1]{B}. Its role here is exactly +the assertion at two, together with positivity and rationality. +After Theorem~\ref{classical:low-corank}, +\eqref{eq:kummer-exact} gives $s_p(E)=r(E)$ at every prime. Thus +Theorem~\ref{classical:two-primary} applies to the curve in +Theorem~\ref{thm:main}. + +We also use the forward analytic theorem, in order to apply these +conventions to auxiliary twists chosen by analytic nonvanishing. + +\begin{theorem}[Analytic rank zero and one]\label{classical:analytic-low-rank} +If an elliptic curve $A/\Q$ has $a(A)\leq1$, then +$r(A)=a(A)$ and the entire group $\Sha(A/\Q)$ is finite. +\end{theorem} + +This is the Gross--Zagier--Kolyvagin theorem, using modularity +\cite{GrossZagier,Kolyvagin,BCDT}. By \eqref{eq:kummer-exact} and +Theorem~\ref{classical:two-primary}, $Q_A\in\Q_{>0}$ for every such +$A$. Hence $X_p(A)$ is defined for all the twists used below. +From now on, $p>2$ is fixed, $v=v_p$ on constants, and we abbreviate +$X_p(A)$ to $X(A)$. + +\begin{proposition}[Isogeny invariance]\label{classical:isogeny} +Suppose $A$ and $A'$ are isogenous elliptic curves over $\Q$ of +analytic rank at most one. Then +\[ + \frac{Q_A}{\#\Sha(A/\Q)} + =\frac{Q_{A'}}{\#\Sha(A'/\Q)}. +\] +In particular $X(A)=X(A')$. Over a number field, the corresponding +analytic-to-arithmetic BSD ratio is likewise invariant under isogeny +when the Tate--Shafarevich groups are finite. It is compatible with +products and restriction of scalars. +\end{proposition} + +\begin{proof} +These are the arithmetic-volume identities of Cassels and the +restriction-of-scalars comparison of Milne \cite{Cassels,MilneBSD}. +The ratio is formed with the period lattice, full point lattice, +torsion, component factors, and finite Tate--Shafarevich group; +the kernel and cokernel factors of an isogeny cancel in this combined +ratio. The analytic $L$-function is isogeny invariant. Finiteness in +the rational low-rank applications is supplied by +Theorem~\ref{classical:analytic-low-rank}; it passes to the products +and restrictions used here. Thus no conjectural equality of either +ratio with one is required. +\end{proof} + +\subsection{Auxiliary quadratic fields} + +The pair comparison uses simultaneous nonvanishing for three twists. +We record precisely the density input used for that choice. + +\begin{theorem}[Analytic twist densities]\label{classical:twist-density} +For every elliptic curve $A/\Q$, among nonzero squarefree integers +$d$ ordered by $|d|$, the twists $A^d$ of analytic rank zero and one +each have density $1/2$. Consequently the set of $d$ with +$a(A^d)\geq2$ has density zero. +\end{theorem} + +We use the theorem at the scope stated in \cite[Theorem~1.2]{Goldfeld}. +Its use below requires no uniform estimate as $A$ varies: one first +chooses one discriminant and then applies the theorem to two fixed +curves. This is the auxiliary-field argument of \cite[Section~2]{C}. + +\begin{lemma}[Compatible auxiliary fields]\label{classical:auxiliary-fields} +Let $E/\Q$ have conductor $N$ and analytic rank $r\in\{0,1\}$. +There exist coprime negative odd fundamental discriminants $D,D'<-4$ +such that, for +\[ + K=\Q(\sqrt D),\qquad F=\Q(\sqrt{DD'}),\qquad + L=\Q(\sqrt D,\sqrt{D'}), +\] +the following statements hold. +\begin{enumerate}[label=\textup{(\roman*)}] +\item Every prime dividing $2Np$ splits in both imaginary quadratic +fields, and $\left(\frac{D}{|D'|}\right)=1$. +\item The analytic ranks of $E^D,E^{D'},E^{DD'}$ are respectively +$1-r,1-r,r$. +\item The extension $L/F$ is CM and unramified at every finite place, +and $L$ has only the roots of unity $\{\pm1\}$. +\item One may require $L\cap\Q(E[p])=\Q$ and, when $E$ has CM, +that $L$ not contain its CM field. +\end{enumerate} +Finitely many additional splitting conditions and exclusions of +quadratic fields can be imposed. Both $L(E/K,s)$ and +$L(E^{D'}/K,s)$ have a simple zero at $s=1$. +\end{lemma} + +\begin{proof} +Negative odd fundamental discriminants in an admissible fixed +congruence class have positive density. Prescribe splitting at +$2Np$, impose any additional splitting conditions, and exclude a +finite set of quadratic fields. The zero-density exceptional set +in Theorem~\ref{classical:twist-density} cannot exhaust these classes. +We can therefore choose $D$ so that $a(E^D)\leq1$. + +Keep $D$ fixed. Choose $D'$ prime to $D$, subject to the same +splitting conditions and, in addition, +$D'\equiv-1\pmod{|D|}$. Together with a sufficiently divisible +modulus supported at $2Np$ and any other prescribed primes, these +conditions contain admissible classes of positive density. Since +$|D'|\equiv1\pmod{|D|}$, quadratic reciprocity gives the required +Jacobi symbol. Apply Theorem~\ref{classical:twist-density} to the +two fixed curves $E$ and $E^D$. The union of their exceptional sets +still has density zero. Thus one can arrange both +$a(E^{D'})\leq1$ and $a(E^{DD'})\leq1$. + +For a fundamental discriminant $b$ prime to $N$, the root-number +multiplier is $\chi_b(-N)$. Our splitting and sign prescriptions +make this multiplier $-1$ for $D$ and $D'$, and $+1$ for $DD'$. +The functional equation and the ranks at most one therefore give +the ranks in (ii). The two quadratic factorizations of the +$L$-functions over $K$ prove the last assertion. + +The three quadratic subfields of $L$ have discriminants $D,D',DD'$. +The biquadratic discriminant formula yields +\[ + |\operatorname{disc}L|=D^2(D')^2 + =\operatorname{disc}(F)^2. +\] +The relative discriminant of $L/F$ has norm one, so it is trivial. +The field $F$ is real and $L/F$ is CM. Excluding the finitely many +quadratic subfields responsible for additional roots of unity gives +the last assertion of (iii). + +The finite Galois extension $\Q(E[p])/\Q$ has only finitely many +quadratic subfields. A nontrivial intersection with the biquadratic +field $L$ would contain one of the three quadratic subfields of +$L$. Exclude these possibilities when choosing $D$ and $D'$: +after $D$ is fixed, prescribing either $\Q(\sqrt{D'})$ or +$\Q(\sqrt{DD'})$ excludes only finitely many choices of $D'$. +The same argument excludes the CM field. Finite exclusions do not +alter the preceding positive-density argument. +\end{proof} + +For the rest of the pair construction, fix such $D,D',K,F,L$ and +write $E'=E^{D'}$ for the companion. In particular $p$ splits +completely in $L$. The rational compact Selmer group over $K$ for +each of $E,E'$ has dimension one. Indeed restriction of scalars is +isogenous to the product of the corresponding two rational twists, +whose analytic ranks sum to one and whose Tate--Shafarevich groups +are finite. A nonzero point in either rank-one line has nonzero +local logarithm at both places above $p$: the kernel of the local +elliptic logarithm on local points is torsion. + +\subsection{Heegner points and the height formula} + +Put $d_K=|D|$. Let $f\in S_2(\Gamma_0(N))$ be the normalized +rational eigenform attached to $E$. Choose an oriented ideal of +$\mathcal O_K$ of norm $N$ with cyclic quotient, and let $P_X$ +be the sum, once over the ideal class group of $K$, of the associated +maximal-order Heegner divisor minus the cusp $\infty$ on $X_0(N)$. +Thus $P_X\in J_0(N)(K)$. There is no division by the class number. + +Let $\phi:X_0(N)\to E$ be a rational modular parametrization taking +$\infty$ to zero. We write $\phi_*$ for its map on degree-zero +divisors, and define +\begin{equation}\label{eq:manin-constant} + P_K=\phi_*P_X,\qquad + \phi^*\omega_E=c_E f(q)\,\frac{dq}{q},\qquad + q=e^{2\pi i\tau}. +\end{equation} +The nonzero rational constant $c_E$ is retained exactly; no claim +that it is a $p$-adic unit is used. Write $(f,f)_N$ for the +unnormalized Petersson integral on the ordinary +$\Gamma_0(N)$ quotient, and put +\[ + A_E=\int_{E(\C)}|\omega_E\wedge\overline{\omega_E}|. +\] + +Over a number field, $H_{\rm abs}$ denotes the height of +\eqref{eq:height-convention} formed from the absolute logarithmic +$x$-height. It restricts to $H$ over $\Q$. On the Jacobian, use +the Poincare pairing and the orthogonal projector onto the rational +newform factor with its restricted polarization; denote the +resulting absolute diagonal by $H_{\rm abs,f}$. + +\begin{theorem}[Split Gross--Zagier normalization] +\label{classical:gross-zagier} +With the preceding conventions, $D$ odd fundamental, $(D,N)=1$, +all level primes split, and $\mathcal O_K^\times=\{\pm1\}$, one has +\begin{align} + \frac{\sqrt{d_K}}{8\pi^2(f,f)_N}L'(f/K,1) + &=2H_{\rm abs,f}(P_X),\label{eq:classical-gz}\\ + L'(E/K,1)&=\frac{A_E}{\sqrt{d_K}\,c_E^2}\cdot + 2H_{\rm abs}(P_K). + \label{eq:classical-gz-elliptic} +\end{align} +In the simple-zero case $P_K$ is nontorsion. +\end{theorem} + +The first formula is the conductor-one split Gross--Zagier formula +in the normalization used in \cite[Chapters~I and~V]{GrossZagier}; +the conversion is also recorded in \cite[Section~2]{B}. For clarity, +the conversion to the second formula uses the projection formula +for $\phi_*$ and +\[ + (\deg\phi)A_E=8\pi^2c_E^2(f,f)_N. +\] +The relative height over $K$ is $[K:\Q]H_{\rm abs}=2H_{\rm abs}$. +This explains the factor two in both displays. The canonical height +of the origin divisor is $H_{\rm abs}/2$; its Poincare-pairing +diagonal is $H_{\rm abs}$. Thus this convention agrees with +\eqref{eq:height-convention}, without an additional halving. + +\subsection{The real arithmetic comparison} + +The following equality is needed at odd primes. It is an equality +of real arithmetic ratios before any valuation is taken. + +\begin{proposition}[Full-index discrepancy identity] +\label{classical:discrepancy-identity} +Assume $L(E/K,s)$ has a simple zero under the hypotheses of +Theorem~\ref{classical:gross-zagier}. Then +\begin{equation}\label{eq:real-discrepancy} + \frac{Q_E}{\#\Sha(E/\Q)} + \frac{Q_{E^D}}{\#\Sha(E^D/\Q)} + =\frac{[E(K):\Z P_K]^2} + {c_E^2\prod_\ell c_\ell(E)^2\,\#\Sha(E/K)}. +\end{equation} +The index on the right is the full group index, including torsion. +Consequently, at any prime $p$, if +\[ + n_P=v_p\bigl([E(K)/E(K)_{\rm tors}:\Z\overline P_K]\bigr), + \qquad \tau_g=v_p(\#E(K)_{\rm tors}), +\] +then +\begin{equation}\label{eq:classical-discrepancy} + X_p(E)+X_p(E^D) + =2(n_P+\tau_g)-2v_p(c_E) + -2\sum_\ell v_p(c_\ell(E))-v_p(\#\Sha(E/K)). +\end{equation} +\end{proposition} + +\begin{proof} +Consider $A=\operatorname{Res}_{K/\Q}E_K$. It is isogenous over +$\Q$ to $E\times E^D$. Its point group and Tate--Shafarevich group +are $E(K)$ and $\Sha(E/K)$, and its $L$-function is $L(E/K,s)$. +Its Neron period is $A_E/\sqrt{d_K}$. To see the discriminant +factor, use an integral quadratic basis for $\mathcal O_K$ in the +restriction of the invariant differential; the determinant of the +dual Lie lattice has real Jacobian $1/\sqrt{d_K}$. +The differential stays minimal over $K$: primes of bad reduction +split, and good reduction stays good. + +The finite component product for $A$ is +$\prod_\ell c_\ell(E)^2$. At a bad prime, the two split places +each contribute $c_\ell(E)$. At a ramified prime of good reduction, +the special restriction fiber is an extension of the good special +fiber by a vector group and is connected, so there is no extra +component factor. At the remaining good primes the component +factor is one. These period and component calculations are the +restriction-of-scalars arithmetic comparison +\cite{MilneBSD,B}. + +Let $P_0$ generate the full free group $E(K)/E(K)_{\rm tors}$, +and write $P_K=mP_0$ modulo torsion. The rank-one regulator for +$A$ is $2H_{\rm abs}(P_0)$; hence +\[ + \frac{2H_{\rm abs}(P_K)}{\Reg_A}=m^2, + \qquad [E(K):\Z P_K]=|m|\,\#E(K)_{\rm tors}. +\] +Dividing \eqref{eq:classical-gz-elliptic} by the BSD arithmetic +volume just computed gives the right side of +\eqref{eq:real-discrepancy}. Proposition~\ref{classical:isogeny} +identifies the same ratio with the product on its left. Taking +$v_p$ gives \eqref{eq:classical-discrepancy}. +\end{proof} + +In \cite[Section~2]{B}, this real identity is subsequently evaluated +at two. The proof above explains why the identity itself applies +at any prime: neither the restriction-of-scalars calculation nor +the Gross--Zagier height identity used a two-primary BSD equality. +What remains in the present paper is to compute the odd-primary +index and Tate--Shafarevich terms on the right of +\eqref{eq:classical-discrepancy} by an exact integral comparison. diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/03-models.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/03-models.tex new file mode 100644 index 0000000000000000000000000000000000000000..3fdd1cca19e7720e413b1a54c5259c863afe209b --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/03-models.tex @@ -0,0 +1,651 @@ +\section{Integral cohomology and determinant comparisons}\label{sec:models} + +Fix an odd prime $p$. The arithmetic comparisons below will take place +over power-series rings with coefficients in $\Z_p$, before any +rationalization. Three features of these comparisons are essential: +specialization is derived, local conditions retain their torsion, and +the duality maps are retained together with the complexes. We develop +these features first. The last part of the section records the +specialization criteria that will turn characterwise comparisons into +integral divisibility. + +\subsection{Complexes and finite models} + +Put $T=T_pE$ and $V=T\otimes_{\Z_p}\Q_p$. The Weil pairing identifies +$T$ with its Tate dual $T^*(1)$. Cohomological Frobenius is arithmetic. +Character weights in a theta sum or an Euler factor may therefore use +the inverse of a cohomological character; each such comparison will +specify its convention. Character corestriction is the unnormalized +sum of translates. Its restriction to a field killing the character +is the weighted sum with the character giving the required inverse +equivariance, without division by the degree. + +For a number field $F$ and a support $S$ containing the places above $p$ +and infinity, write +\[ + G(M)=C^\bullet(G_{F,S},M),\qquad L_v(M)=C^\bullet(F_v,M). +\] +Here $M$ is a finite free coefficient module, initially over a finite +local Artin ring. A local condition is a map $U_v\longrightarrow L_v$. +With $Q_v=\operatorname{cone}(U_v\to L_v)$, its Selmer complex is +\begin{equation}\label{models:selmer-complex} + C(U,M)=\operatorname{fib}\left(G(M)\longrightarrow\bigoplus_vQ_v\right), + \qquad \operatorname{fib}=\operatorname{cone}[-1]. +\end{equation} +A full condition is the identity and a strict condition is zero. +Global duality uses modified localization at infinity. Since $p$ is +odd, real Tate complexes are contractible. The Euler characteristic +of ordinary global cohomology is the negative of the sum of the +negative eigenspace dimensions at real places and the coefficient +ranks at complex places. + +The finite-model construction of \cite[Section 3, ``Finite models and +matrix limits'']{B} has the following integral form. We +give the construction because the residual specialization used in +Section~\ref{sec:vertical} is not a characteristic-zero formal germ. + +\begin{lemma}[Finite models and marked operations]\label{models:finite-models} +Consider continuous-cochain diagrams over finite local Artin rings of +$p$-power characteristic, with finite free coefficient modules and +compatible coefficient lifts. Assume that residual cohomology +dimensions are bounded uniformly, and vanish outside a uniformly +bounded range for every complex for which a bounded model is required. +Then the diagrams admit bounded finite free models with derived base +change. Restriction, unramified inflation, local cones, cup products, +invariant maps, conjugation, and specified comparison homotopies can be +retained simultaneously. + +Suppose the scalar rings at the stages identify with every fixed Artin +precision of a complete local ring $R$ with finite residue field. On a +fixed nonprincipal ultrafilter $\mathcal U$, the model matrices have compatible +limits over $R$. Their marked identities survive arbitrary derived +base change, in particular to residue fields of primes of $R$, +including primes containing $p$. Fixed-group diagrams whose actions +stabilize at every precision compute the actual cohomology of that +group. A finite diagram may be enlarged on the same stages while +retaining its previous models and markings. +\end{lemma} + +\begin{proof} +Continuous cochains with free coefficients over an Artin ring $A$ are +flat: continuous functions are filtered colimits of finite free modules +indexed by finite clopen partitions. Tensoring them with a finite +scalar module gives the corresponding continuous cochains. A flat +module over a local Artin ring is free. Indeed, lift a basis modulo the +maximal ideal; nilpotence proves surjectivity, and flatness followed by +nilpotence proves that the kernel is zero. + +Split the residual complex into its cohomology and contractible disks, +and lift the graded bases. Write $d_0$ for the disk differential and +$i,q,h$ for the inclusion, projection, and contraction, normalized by +$h^2=hi=qh=0$ and $1-iq=d_0h+hd_0$. For $d=d_0+\epsilon$, the formulas +\begin{equation}\label{models:contraction} + \begin{aligned} + I&=(1+h\epsilon)^{-1}i,&Q&=q(1+\epsilon h)^{-1},\\ + H&=h(1+\epsilon h)^{-1},& + d_{\rm small}&=q\epsilon(1+h\epsilon)^{-1}i + \end{aligned} +\end{equation} +are finite series in the nilpotent maximal ideal. Substitution, using +$d^2=0$, gives $dI=Id_{\rm small}$, $Qd=d_{\rm small}Q$, $QI=1$, +and $dH+Hd=1-IQ$. The remaining ranks are the residual cohomology +dimensions; hence they have the asserted bounds. Inserting $I,Q$ +transfers maps, and inserting $H$ transfers their composition +homotopies. Tensoring the contractions transfers the cup maps and +their homotopies. Cones may be formed from transferred maps and then +contracted. + +Functions lift across coefficient quotients, so the contractions can +be chosen compatibly. At a fixed precision the matrices belong to +finite sets. Their ultrafilter values are therefore defined, and all +finite matrix identities survive passage to the limit. Exact +triangles survive by retaining their cone identifications; duality +survives by retaining its maps and contracting the comparison cones. +Because the models are free, ordinary tensor of these models is +derived tensor. No inversion of $p$ enters this argument. + +For a fixed group, compare the limiting model at each precision with +a contraction of its actual cochains. The two compositions are +homotopic to the identities. These comparisons preserve the marked +maps. Passing to compact inverse limits introduces no $\lim^1$ term, +by finiteness and compactness. When the diagram is enlarged, keep the +old contractions, transfer the additional maps, and decrease the +working precision along the ultrafilter if necessary. Any finite list +of new identities is then retained at a cofinal sequence of precisions. +\end{proof} + +The hypotheses hold for the diagrams used here. The residual +representations belong to a fixed finite list, and the support has +bounded cardinality. Pass to a fixed finite extension trivializing +these representations and containing $\mu_p$. Kummer theory bounds +degree one by the fixed unit and class groups and the bounded number +of allowed valuations. Inflation--restriction, local and global +duality, and the odd-primary cohomological-dimension bounds give the +remaining bounds. Thus the number of moving primes matters, but +their ramification degrees need not be bounded. + +\subsection{Localization and exact orthogonality} + +At a non-$p$ place where $M$ is unramified, the unramified complex is +\[ + U_v^{\rm ur}=[M\xrightarrow{\Frob_v-1}M]\quad\text{in degrees }0,1. +\] +Its quotient in the full local complex is residue cohomology on +$M(-1)$, in degrees $1,2$. Allowing such a place globally while imposing +$U_v^{\rm ur}$ gives the original global complex, by unramified +inflation. These are the usual localization and purity comparisons; +they hold for the models with their maps, not just for dimensions of +cohomology. + +For completeness, the $G_{F,S}$ comparison can be checked after finite +covers trivializing residual coefficients. In the universal cover, +degree-one classes die as torsors. Brauer classes die after adjoining +sufficient $p$-power roots of unity, whose local degrees grow at the +finitely many required places, and Picard classes die after +principalization. Purity, cohomological dimension, and Brauer +reciprocity give higher vanishing. Real groups have order prime to +$p$. This proves the comparison on residual coefficients, and the +finite-model construction lifts it to all the coefficients in use. + +Locally, first take invariants under the pro-prime-to-$p$ kernel of +inertia, an exact operation, and then use the procyclic tame +$p$-inertia resolution. A change of generator $z\mapsto z^b$ acts on +its degree-one term by $(z^b-1)/(z-1)$. If the conjugating powers tend +to $1$ at the retained precisions, both the powers and these geometric +sums tend to $1$. This observation fixes the local comparison when +the residue cardinalities of moving primes tend to $1$. + +After inversion of $p$, at a place with fixed possibly ramified Tate +action and varying unramified scalar, use residue cochains on $V^{I_v}$. +The singular quotient uses $V_{I_v}(-1)$ in degrees $1,2$. Inertia has +constant linear algebra before the Frobenius scalar is introduced. +These unramified conditions contain all $H^0$ and inject into field +$H^1$. Their paired cup is nullhomotopic through residue cochains. +On a field fiber their degree-one dimension is $h^0$, and local +duality and Euler characteristic zero identify their exact +complements. + +\begin{lemma}[Exact local complements]\label{models:orthogonality} +Let paired perfect local maps $U_v\to L_v$ and $U'_v\to L'_v$ have +a specified nullhomotopy of their cup restriction. Suppose the +induced morphism +\[ + L'_v/U'_v\longrightarrow U_v^\vee[-2] +\] +is an equivalence, where $\vee$ denotes derived linear dual before +shifting. Then their Selmer complexes are perfect duals with shift +$-3$. The localization boundaries for nested such conditions are +adjoint under this duality. These assertions hold over the model +rings and after localization or derived specialization. +\end{lemma} + +\begin{proof} +Let $G_c$ be the compact-support fiber of global localization. +Poitou--Tate pairs $G_c$ with the unrestricted dual global complex +with shift $-3$, and local Tate duality pairs $L_v,L'_v$ with shift +$-2$. Dualizing $G_c\to C(U)\to\bigoplus_vU_v$ and using the given +local equivalences identifies the dual fiber with $C(U')$. The same +triangle identifies the boundary maps as adjoints. + +At finite precision these are the cup, invariant, and compact trace +diagrams of local and global duality \cite{Milne,Nekovar}. The top +scalar local and compact cohomology groups, in degrees two and three, +are the coefficient ring; their traces are compatible with reduction +and corestriction. Retain these maps and the reciprocity homotopy in +Lemma~\ref{models:finite-models}. Perfectness is checked on the +residue field and lifted by contracting the comparison cone. This +also proves compatibility after specialization. For split local +complexes the required nullhomotopies are checked on the split +cohomology; for unramified conditions they are supplied by the residue +factorization above. +\end{proof} + +Conjugate transport may identify a coefficient over an imaginary +quadratic field with its Tate dual. In that convention complements +are imposed at conjugate places. Under Shapiro, compact and local +invariants are compatible with corestriction; no factor equal to the +quadratic degree is inserted. Exact orthogonality over the testing +ring is needed throughout. Orthogonality only after passage to its +fraction field would not suffice for the determinant comparisons. + +\subsection{Detection of classes after residual specialization} + +The models also allow classes to be tested on sequences of Galois +elements. This will let Chebotarev produce new primes whose +first-order effects distinguish specified classes. + +\begin{lemma}[Evaluation detection]\label{models:evaluations} +Let $G_R(M)$ be an unrestricted limiting global model as in +Lemma~\ref{models:finite-models}. After any field specialization, +including $R\to\Frac(\F_p[[\mathbf u]])$, its degree-one cohomology +injects into abstract crossed-homomorphism classes on the product of +the stage absolute Galois groups. The action is obtained by taking +entrywise coefficient limits before specialization. Invariants are +detected in the same way. The assertion holds for a Selmer complex +whenever its local conditions contain all local $H^0$ and inject into +local field $H^1$. +\end{lemma} + +\begin{proof} +Keep the inclusions of the finite models into actual cochains. At +residual precision a bounded list of group elements detects +invariants and detects whether the values of a model cocycle have +the form $g a-a$ for one $a$ in the coefficient module. The bound +comes from linear equations in the coefficient space and in the +bounded model space. Mark the resulting evaluation map to +$[M\to M^{\rm list}]$ in degrees zero and one. It is an isomorphism +on residual $H^0$ and injective on residual $H^1$. Its cone has zero +residual cohomology in degrees at most zero. A minimal model of the +cone therefore has zero terms there. This remains true after every +field base change and proves the required injection. + +For every sequence of group elements, and every pair or finite tuple +of sequences, the evaluation matrices have compatible limits. +The cocycle and coboundary equations consequently hold on their +product group. Conjugation identities hold on classes by the marked +homotopies. The Selmer assertion follows from the localization +sequence and the hypotheses on the local maps. +\end{proof} + +Here are two consequences that we will use. If a normal joint kernel +$J$ acts trivially on the coefficients, restriction gives additive, +equivariant evaluations on $J$. It detects classes whenever the +quotient has vanishing $H^1$. A central scalar whose difference from +$1$ is invertible gives this vanishing directly from the crossed +homomorphism identity. In characteristic zero another useful +quotient test is a normal subgroup consisting of arbitrary sequences +in a fixed deep $\operatorname{SL}_2(\Z_p)$ subgroup, with its standard +plane action and trivial scalar twists. To see vanishing of even +abstract $H^1$, use a constant diagonal $(m,m^{-1})$, with integer +$m>1$ sufficiently close to $1$, to kill the cocycle on the diagonal. +Conjugation multiplies the upper-unipotent parameter by $m^2$; the +crossed relation and the $m^2$-power formula then kill the upper +unipotent values, since the resulting coefficient matrix is +invertible. Use the inverse diagonal for lower unipotents, and +Gaussian factorization for arbitrary sequences. Such a subgroup +remains available in a non-CM Tate image in the presence of competing +data of bounded derived length: sufficiently iterated derived groups +kill those data and still contain a deep special linear subgroup. + +For an absolutely simple coefficient representation with scalar +endomorphisms, evaluations of independent detected classes span the +full tuple of coefficient spaces. Otherwise their equivariant span, +a submodule of a sum of copies of that simple representation, would +give a scalar relation among the classes. The same holds jointly for +pairwise nonisomorphic simples. This statement is valid in the +residual fields; it requires neither characteristic-zero +semisimplicity of the Galois group nor an assertion about polynomial +avoidance on a finite field. We will use its linear span and +bilinearity there. + +Finally, a finite table of the evaluations and other continuous +arithmetic data factors through a finite quotient at each retained +precision. Chebotarev realizes it by a Frobenius representative once +the prescribed splitting conditions are compatible. Adding primes +uses unramified inflation with its marked homotopies, so evaluations +already made are preserved. Cup-primitive equations solved in a +field-specialized model are interpreted on these evaluation cochains +using the same inclusions and homotopies. Reciprocity in this use is +the transferred arithmetic invariant identity, not a reciprocity +assertion for an abstract product group. Over a fixed finite extension +of $\Q_p$, fixed denominators can be cleared and equations lifted to +increasing precision. Such clearing is used only after inversion of +$p$. + +\subsection{Determinant volumes and switching lemmas} + +For a perfect complex define its inverse determinant by +\[ + \mathcal D(C)=\bigotimes_i(\det C^i)^{(-1)^{i+1}}. +\] +At a DVR $A$, let $d(C,y)$ be the valuation of a generic tensor $y$ +relative to a generator of this line. A torsion cohomology group of +length $b$ in degree $i$ contributes $(-1)^{i+1}b$. In particular, for +a generically acyclic square complex in degrees $1,2$, +\begin{equation}\label{models:determinant-sign} + d(C,1)=-v(\det d^1). +\end{equation} +Determinants multiply in exact triangles. Bases and their signs are +understood up to integral units. + +The following statements give the precise interfaces of the algebra +lemmas in \cite[Lemmas 3.5 and 3.6]{B}. Their hypotheses will be verified +at the primes where the switches are used. + +Here is the local diagram used in both statements. At one place +choose conditions +\[ + U_-\subset U_f,U_s\subset U_+, + \qquad U_f\cap U_s=U_-,\qquad U_f+U_s=U_+, +\] +whose quotients are split free in degree one: +\[ + U_f/U_-=F[-1],\qquad U_s/U_-=S[-1],\qquad + U_+/U_-=(F\oplus S)[-1]. +\] +The conditions contain all local $H^0$; $U_+$ omits local $H^2$. +Write +$C_-,C_f,C_s,C_+$ for the global complexes with these respective +conditions, keeping all other places fixed. The localization +maps from $H^1(C_f)$ to $F$ and from $H^1(C_s)$ to $S$ are denoted +by $f$ and $s$. The dual coefficient has the exactly complementary +diagram, and the mixed pairing between the corresponding finite +and transverse quotients is perfect. A fiber means derived +tensor with the DVR residue field; a generic line has a primitive +fiber reduction by taking a generator of its saturated kernel in +the two-term free model. The opposite condition in the line +lemma is the complementary condition on the dual coefficient. + +\begin{lemma}[Line switch]\label{models:line-switch} +Over a DVR $A$ with residue field $k$, suppose local finite and transverse coordinates are split +free lines in degree one, with perfect mixed pairing. The lower +condition contains all $H^0$, the upper condition omits $H^2$, and the +global lower and upper diagrams have exact complementary duality. +Assume the finite and transverse global complexes have amplitude +$[1,2]$ on the generic and residual tests. Suppose the finite complex +has only a generic degree-one line. At a fiber with +$\dim H^1(C_f\otimes_A k)=h>1$, +assume nonzero finite evaluation both for a primitive reduction of +that line and for some degree-one class of the opposite condition. +Then switching lowers the degree-one dimension by one, and leaves one +generic degree-one line. If integral classes $Y,Y'$ satisfy +$s(Y')=f(Y)$ under a unit-volume isomorphism of coordinates, then +\[ + d(C_f,Y)=d(C_s,Y'). +\] +Successive switches ending at dimension one prove nonnegativity of +this common valuation. +\end{lemma} + +\begin{proof} +The generic finite evaluation is nonzero, so the lower complex is +generically acyclic. In the fiber, reciprocity against the nonzero +opposite finite evaluation prohibits a transverse contribution. +The two localization triangles therefore lower the dimension by one. +Those same triangles identify the class tensors through the common +lower tensor $1$; the local isomorphism changes its volume only by a +unit. At dimension one the minimal model is a free line in degree +one, and the integral class has nonnegative coordinate valuation. +\end{proof} + +\begin{lemma}[Square switch]\label{models:square-switch} +In the preceding local diagram over a DVR $A$ with residue field +$k$, let $F,S$ be split free planes. Retain all $H^0$ in the lower +condition and omit $H^2$ from the upper condition. Assume amplitude +$[1,2]$ for both switched global complexes on their generic and +residual tests, exact self-duality of the lower and upper diagrams, +and perfect mixed pairing. The pure finite and transverse planes +are isotropic, with their compatible cup nullhomotopies retained. +On a common plane let $e$ be unimodular +alternating and $J$ an integral involution, with cross pairing +$e(x,Jy)$ up to a unit. Suppose the finite complex has generic rank +one in degrees one and two, with class $Y$ and $f(Y)\ne0$, and an +integral transverse class satisfies $s(Y')=Jf(Y)$ up to a unit. Then +the transverse complex has the same generic ranks and +\[ + d(C_f,(Y,Y^\vee))=d(C_s,(Y',(Y')^\vee)), +\] +where the dual tensor uses the pairing functional on degree two. +If finite evaluation has rank two at a fiber with +$\dim H^1(C_f\otimes_A k)>1$ and is nonzero +on a primitive reduction of $Y$, the switch lowers its degree-one +dimension by two. Ending at dimension one gives nonnegative +valuation for the class-functional tensor. +\end{lemma} + +\begin{proof} +Adjunction identifies the annihilator of the upper localization +image with that same image, so the image is self-annihilating in the +four coordinates. The two generic classes form a basis of the upper +degree-one space. In the dual basis of $H^2(C_-)$, write +$Y^*,(Y')^*$ for the functionals normalized to take value one on +their respective upper basis vectors. These are dual basis +vectors, distinct from the pairing functionals $Y^\vee,(Y')^\vee$ +used in the determinant tensors. Choose a rational complement +$x$ to $f(Y)$ whose boundary is $(Y')^*$. The cross-pairing gives +$e(x,J s(Y'))$ a unit value, and $s(Y')=Jf(Y)$ therefore makes +$f(Y)\wedge x$ a unit plane volume. The complement need not be +integral: if both classes are multiplied by a uniformizer +$\varpi$, the normalized dual $(Y')^*$ and this complement +are divided by $\varpi$. +Interchanging the planes gives +the same volume. Thus both triangles identify the class-functional +tensors with the same lower tensor, proving the equality. At a +rank-two fiber the upper image is exactly the finite plane, giving +the dimension drop. At the terminal fiber the model is two free +lines with zero differential and unimodular pairing. The tensor is +integral there. Compatible nullhomotopies on the lower comparisons +are part of exact duality and are retained at all unchanged places. +\end{proof} + +\begin{lemma}[Strict versus finite conditions]\label{models:strict-finite} +At a split pair $w,\bar w$, let $C_*$ be strict at $w$ and full at +$\bar w$, and let $C_F$ impose exactly complementary finite +conditions $U_w,U_{\bar w}$. Keep all other conditions fixed with +conjugate duality. Suppose these comparisons are perfect over a DVR, +$U_w$ is generically a line in degree one, $C_*$ is generically +acyclic, and $Y\in H^1(C_F)$ has nonzero localization. If +$\operatorname{loc}_wY=a e$ in a generic basis $e$ of $U_w$, then +\begin{equation}\label{models:strict-finite-volume} + d(C_F,(Y,Y^\vee))=d(C_*,1)+2\bigl(v(a)+d(U_w,e)\bigr). +\end{equation} +Moreover $C_F$ has exactly one generic line in each of degrees one +and two. Conversely, these line assertions and the nonzero +localization imply the strict acyclicity. +\end{lemma} + +\begin{proof} +Use $C_0$, strict at $w$ and finite at $\bar w$, and the triangles +$C_0\to C_F\to U_w$ and $C_0\to C_*\to L_{\bar w}/U_{\bar w}$. +The latter quotient is $U_w^\vee[-2]$. Its boundary of $e^*$ pairs +with $Y$ by $a$. The two triangles therefore compare the tensors +with a factor $a^2$, and their local lattice volumes are dual. This +gives the formula and the rank assertions; the converse follows by +the same nonzero adjoint boundary. This is the determinant +calculation of \cite[Lemma 3.4]{B}. +\end{proof} + +\subsection{The Kummer lattice and its volume} + +At an actual scalar specialization the integral local condition is +\[ + U_v^{\rm Kum}=E(F_v)^{\wedge}_p[-1] + \longrightarrow C^\bullet(F_v,T). +\] +The completed point module includes its torsion. Its derived +reduction modulo $p^n$ therefore has the invariant $p^n$-torsion in +degree zero and the finite Kummer image in degree one. The +Bockstein identifies the former with the integral torsion Kummer +classes. Finite Kummer orthogonality and derived base change show +that these conditions are exact complements. More explicitly the +cup restriction is null: morphisms from the derived Kummer tensor +to scalars in degree two are detected in top degree, and finite +Kummer pairings vanish for every $n$. The resulting local quotient +duality is an equivalence on the residue field and hence integrally. + +Compact local duality gives +\[ + 0\longrightarrow E(F_v)^{\wedge}_p\longrightarrow H^1(F_v,T) + \longrightarrow + \Hom(E^\vee(F_v)^{\wedge}_p,\Z_p)\longrightarrow0. +\] +In particular at a non-$p$ finite place the compact degree-one +cohomology is entirely Kummer. Over $F_v/\Q_p$, the rational +abelian-variety comparison of Bloch--Kato gives +\begin{equation}\label{models:log-exp-pairing} + \operatorname{inv}_v(z\cup x) + =\pm\Tr_{F_v/\Q_p}\bigl(\exp^*z\cdot\log x\bigr). +\end{equation} +For $F_v=\Q_p$ and $\exp^*z=\alpha\omega_E$, this is +$\pm\alpha\log_{\omega_E}x$. This rational comparison includes bad +reduction; it makes no assertion that exponential coordinates are +integral quotient bases \cite{BlochKato}. + +\begin{lemma}[Local Haar factors]\label{models:haar} +For the minimal differential, write $P_\ell(1)=L_\ell(E,1)^{-1}$, +$\tau_\ell=\length E(\Q_\ell)[p^\infty]$, and +$\log_{\omega_E}E(\Q_p)=p^l\Z_p$. Then +\begin{equation}\label{models:haar-identities} + \tau_\ell=v_p(c_\ell P_\ell(1))\quad(\ell\ne p),\qquad + \tau_p-l=v_p(c_pP_p(1)). +\end{equation} +The connected real period $\Omega_0$ on a primitive positive Betti +cycle satisfies $\Omega_E/\Omega_0=\#\pi_0(E(\R))$, a $p$-adic unit. +\end{lemma} + +\begin{proof} +The measure of the identity-component points for the minimal +differential is the nonsingular residue size divided by $\ell$, +namely $P_\ell(1)$. Multiplication by the component number gives +$c_\ell P_\ell(1)$. Away from $p$, the formal subgroup has pro-$\ell$ +order and contributes no $p$-primary valuation. At $p$, a sufficiently +small subgroup is identified by formal logarithm with its additive +lattice. The $p$-primary part of the logarithm's finite kernel has +size $p^{\tau_p}$, and its image has measure $p^{-l}$; the +prime-to-$p$ kernel contributes a valuation unit. This gives the +second identity. The real +identity follows by translation of the minimal differential across +the components. +\end{proof} + +\begin{lemma}[Global Kummer volume]\label{models:kummer-volume} +Let $K$ be imaginary quadratic, suppose $E(K)$ has rank one and +$\Sha(E/K)$ is finite, and let $C_{\rm Kum}$ impose the full integral +Kummer conditions. Put $\tau_g=v_p(\#E(K)_{\rm tors})$ and +$s_K=v_p(\#\Sha(E/K))$. For a nontorsion point $P$ let $n_P$ be +the valuation of its index in $E(K)/E(K)_{\rm tors}$. Then +\begin{equation}\label{models:kummer-volume-formula} + d(C_{\rm Kum},(P,P^\vee))=2n_P+2\tau_g-s_K. +\end{equation} +\end{lemma} + +\begin{proof} +Derived Kummer reduction gives the usual finite Selmer groups; +passage to divisible coefficients gives the usual Kummer sequence. +Whole-Sha finiteness therefore identifies integral degree one with +the compact Mordell--Weil module. The torsion in degree two is the +finite quotient in the compact-to-divisible comparison and has +length $s_K$. Duality gives torsion length $\tau_g$ in degree three, +as well as a unimodular pairing on the free parts in degrees one and +two. The torsion lengths in degrees one, two, three are consequently +$\tau_g,s_K,\tau_g$. Their inverse-determinant contribution is +$2\tau_g-s_K$, and the point and its pairing functional each +contribute $n_P$. This proves the formula, including under +conjugate-field duality; compare \cite[Section 3, ``Central Kummer +lattices and local measures'']{B}. +\end{proof} + +\subsection{Bounded series and specialization} + +A bounded series has coefficients in a fixed complete DVR, or in its +fraction field with one common denominator. This condition excludes +general formal power series over the fraction field. For measure +coefficients we also use +\[ + \mathcal V=W(\overline{\F}_p),\qquad + \mathcal V^*=\varprojlim_j\prod_{\mathcal U}(\mathcal V/p^j) + =W\left(\prod_{\mathcal U}\overline{\F}_p\right). +\] +This is again a complete integer DVR; fixed finite ramification may +be adjoined. Arithmetic model matrices are first formed over the +smaller rings with finite residual coefficients. Bounded measures +may then use this larger constant ring. Fixed character substitution +and fixed finite group quotients commute with the limits. A tame +cyclic generator is denoted by $1+u$; its relation disappears at every +fixed Artin precision when its $p$-power order tends to infinity. + +\begin{lemma}[Division from high characters]\label{models:series-division} +Let $\mathcal O$ be one of these complete integer DVRs and let +$L,B\in\mathcal O[[t,\mathbf u]]$. Suppose +$L\not\equiv0\pmod{(\varpi,t)}$, where $\varpi$ is a uniformizer. +If, for every sufficiently high finite $p$-power character $\theta$ +of $1+t$, the specialization $B(\theta,\mathbf u)$ is divisible by +$L(\theta,\mathbf u)$ after inversion of $p$, then $L$ divides $B$ +integrally. The assertion applies simultaneously to finite products +of such divisors and after the fixed constant extensions above. +\end{lemma} + +\begin{proof} +Choose integers $n_j$, one equal to $1$ and the others with suitably +large successive $p$-adic valuations, so that restriction to +$1+u_j=(1+x)^{n_j}$ separates a nonzero leading monomial of the +reduction. Extend this to a group-power coordinate change. Then +$L$ is distinguished, up to a unit, in one tame coordinate. +Applying this to a product handles a finite list. Prescribed +characteristic-zero generic ranks and nonvanishings at $t=0$ may also +be retained: their leading homogeneous forms in logarithmic +coordinates impose finitely many proper conditions on the integer +choices, which can be avoided within the specified congruences. + +Divide $B$ by the monic Weierstrass polynomial of $L$. At each high +$\theta$ its distinguished degree is unchanged, and its quotient +module is $p$-torsion-free. Thus divisibility after inversion of $p$ +makes the integral remainder zero. Every coefficient of this +remainder, considered as a bounded series in $t$, vanishes at all +high finite characters and is therefore zero by one-variable +Weierstrass preparation. The argument also applies componentwise +to finite coefficient orders embedded in products of DVRs when the +same residual regularity is retained. It is the proof of +\cite[Lemma 3.10]{B}, with $p$ +in place of two. +\end{proof} + +Two further forms of this principle will be useful. First, a +nonzero bounded one-variable series has, at sufficiently high +characters, valuation equal to its minimum coefficient valuation +plus the first degree attaining that minimum times the valuation +of $\theta-1$. This is unique dominance; it also proves finite +character avoidance for several variables by iteration. + +\begin{lemma}[Persistence of poles]\label{models:poles} +Suppose integral stage numerators and denominators in a genuine +variable converge coefficientwise along the ultrafilter, with +nonzero limiting denominator. If every stage numerator is +divisible by its denominator after inversion of $p$, each zero +of the limiting denominator in the open unit disk is a zero +of the limiting numerator with at least the same multiplicity. +\end{lemma} + +\begin{proof} +Coefficientwise converging integral series converge uniformly on +smaller closed disks. A zero of multiplicity $m$ of a nonzero +limiting denominator can be isolated on such a disk. Weierstrass +preparation there retains its zero count on an ultrafilter-large +set. If stage numerators are divisible by stage denominators after +inversion of $p$, the limiting numerator has at least that +multiplicity. This pole test permits uncontrolled stage +denominators because boundedness is imposed on numerator and +denominator separately. Tame characters, when present, are fixed +before this one-variable argument. +\end{proof} + +\begin{lemma}[Points on a horizontal divisor]\label{models:field-points} +For a characteristic-zero height-one divisor in a bounded +$\Z_p$-power-series ring, finitely many functions nonzero on that +divisor can be kept nonzero at a point whose coordinates lie in the +open unit disk of a finite extension of $\Q_p$. +\end{lemma} + +\begin{proof} +Its prime generator is not divisible by $p$. A weighted coordinate +change makes it distinguished in one variable. Modulo its +Weierstrass polynomial the norms of the finitely many nonzero +functions to the remaining power-series ring are nonzero. Choose +the other coordinates, in finite extensions and in their open +unit disks, avoiding these norms; bounded-series avoidance gives +such a choice. A root of the distinguished polynomial is also +interior and belongs to a finite extension. It gives the required +point. +\end{proof} + +\begin{remark}[Central determinant coordinates]\label{models:central-pivots} +When the generic and specialized cohomology dimensions agree, a +determinant coordinate specializes using any surviving set of +Gaussian pivots. One need not keep a particular rational pivot +formula whose denominator vanishes at the point. At actual central +stage calculations, bounds on torsion lengths and the corresponding +rank tests keep suitable minors nonzero in the limit. Numerator, +denominator, and class coordinates then converge by their finite +matrix formulas. This is why retaining torsion in the integral +models is necessary for central valuations. +\end{remark} diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/04-vertical.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/04-vertical.tex new file mode 100644 index 0000000000000000000000000000000000000000..3c2525ddc5eb485aa9d32392dcb3303c2b9e89ca --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/04-vertical.tex @@ -0,0 +1,629 @@ +\section{Auxiliary primes and residual concentration}\label{sec:vertical} + +The characterwise comparisons of the later sections will invert $p$. +They cannot detect a power of $p$ in a determinant. The purpose of +this section is to choose finitely many tame variables so that the +relevant determinant already has nonzero reduction modulo $p$. +We do this by making first-order deformations separate every +surviving residual Selmer class. We give both the arithmetic construction +and the residual-field argument, including reducible representations. + +\subsection{The two coefficient families} + +Use the fields $K,F,L$ and discriminants $D,D'$ of +Section~\ref{sec:classical}. In particular $p$ splits completely in +$L$, the residual division field is disjoint from $L$, and both +$E/K$ and $E^{D'}/K$ have rank one and finite Tate--Shafarevich group. +There will be two separate tuples of auxiliary primes. Over $\Q$ +the true variable $t$ is the torsion-free cyclotomic variable, and +this comparison is used only for a non-CM curve. Over $K$ it is the +anticyclotomic variable, with +\[ + \Gamma\simeq\Z_p +\] +the maximal free pro-$p$ quotient of the ring-class tower at $p$. +The order-class exact sequence shows that inertia at either +$p$-place has open image in $\Gamma$. + +Fix supports stable under conjugation. Over $\Q$ include $p$ and +all bad primes. For $E/K$ include only places over split rational +primes, including both $p$-places and all bad places. For the +companion also include the primes dividing $D'$. Any nonsplit place +in this extra support has no inertia invariant, even on residual +composition factors: $E$ has good reduction there, whereas the +quadratic twist is ramified and $p$ is odd. In each problem over +$K$, include split good prime ideals whose classes generate the +$p$-part of the ideal class group. Degree-one representatives exist +by Chebotarev. Additional fixed split good primes may be included; +we may also prescribe exponents at fixed split test primes without +adding them to the cohomological support. Outside the support the +condition is unramified. + +A tame variable $u_j$ comes from a sequence of distinct good primes +$r_{j,i}$, leaving every finite set and tending $p$-adically to $1$. +Over $K$ these primes split completely in $L$. Its stage character +has cyclic $p$-power order tending to infinity. Over $\Q$ it is a +conductor-$r_{j,i}$ cyclotomic character. Over $K$ it is given by a +surjection +\[ + \lambda_{j,i}:\Pic(\mathcal O_{r_{j,i}})\longrightarrow\Z/p^{n_{j,i}}\Z +\] +which is surjective on inertia at each of the two places over +$r_{j,i}$ and satisfies $\lambda_{j,i}^c=-\lambda_{j,i}$. A chosen +cyclic generator is represented by $1+u_j$. Rational characters of +$p$-power order are automatically even. + +\begin{lemma}[Auxiliary tuples]\label{vertical:auxiliary-tuples} +For any finite list of fixed split support and test primes, the tame +tuple may be chosen to have the following properties. +\begin{enumerate} +\item Its limiting elliptic Frobenius actions have determinant one +and $V(\gamma_j)-1$ invertible. Over $K$ the same holds for the +companion. The weight character $\mathcal C$ used in the theta +construction has nontorsion value on each $\gamma_j$, and its +$\Gamma$ value is nonzero. +\item The vectors of Frobenius exponents in the artificial variables +at the prescribed primes are linearly independent over $\Q_p$, +one vector for each rational prime and with one place chosen in +each split pair. The list includes the coefficient prime $p$. +\item There are at least two moving primes. Each moving inertia +group maps onto its own cyclic quotient and trivially to the +others. All fixed conductors and any prescribed finite set of +primes are avoided. +\end{enumerate} +Here $\mathcal C$ is the algebraic anticyclotomic character with +infinity type one and split conductor used in +\cite[Sections 2 and 4]{C}. Finitely many such fixed characters may +be treated simultaneously. In the rational case the conditions on +$\mathcal C$ and $\Gamma$ are omitted. +\end{lemma} + +\begin{proof} +First prescribe power-residue data. In the rational case the +radicands are the fixed primes themselves. In the imaginary case +choose ideal-class generators away from the prescribed places, +generators of their principal power relations, and generators for +expressions of the prescribed prime ideals in those classes. Include +the conjugates. For a split prime $\mathfrak q$, take a class-number +power $\mathfrak q^h=(a_{\mathfrak q})$. The corresponding +anticyclotomic residue exponent is, up to its common generator +normalization, the Kummer exponent of +$a_{\mathfrak q}/\overline{a_{\mathfrak q}}$. These elements are +independent by their valuations at the chosen split pairs. + +Their Kummer image over the cyclotomic tower has full $\Z_p$-rank. +One way to see the required restriction injectivity modulo $p^a$ +is to use a central cyclotomic element whose scalar differs from +$1$ by a unit; such an element exists since $p$ is odd and splits +in the fixed fields. A further fixed finite extension loses at +most a bounded power of $p$. A $\Z_p$ relation annihilating the +Kummer image would consequently give power relations modulo +arbitrarily high $p$-powers, contradicting the independent +valuations. Thus sufficiently deep prescribed exponents can be +chosen independently. + +To extend an inertia logarithm across the class group, write the +fixed class-group relations in invariant-factor form. Require the +power-residue exponents to be divisible by the fixed $p$-parts of +these invariant factors, and divide the relations to assign the +values on the ideal generators. Principal relations then define +the whole character. Anti-invariance is imposed using the +conjugate generators. The fixed divisions change neither the full +rational span of the limiting exponents nor their independence. +Finite Chebotarev conditions on roots of unity and on this radical +list realize these power-residue prescriptions. Taking enough +moving primes gives the independent row vectors in the assertion. + +We next check compatibility with the elliptic and fixed character +conditions. Adjoin all $p$-power roots of elements of the base to +the cyclotomic tower, and consider the joint compact $p$-adic +analytic image of the Tate representation and the fixed characters. +The common Lie quotient with the radical translation group is +abelian. In the non-CM case it kills the $\mathfrak{sl}_2$ factor +of the Tate image, by Serre's open image theorem \cite{Serre}. +In the CM case, after a fixed extension, the connected Tate image +is a torus. Conjugation on the remaining abelian analytic quotient +is trivial after a finite extension, whereas conjugation on radical +translations is multiplication by the cyclotomic character. +Choosing that character different from $1$ proves that the common +Lie quotient is zero. Hence fixing all radicals removes no Lie +dimension from the analytic image. + +Make the prescribed radical data sufficiently deep that an identity +neighborhood remains available. Its determinant-one Tate projection +contains an open special linear subgroup, or an open norm-one CM +torus. The equation $\det(V(\gamma)-1)=0$ is a proper analytic +condition there. The weight character is nonconstant by its +nonparallel labelled $p$-adic exponents, and the true +anticyclotomic character is nonconstant by its inertia description. +After shrinking the neighborhood, the torsion condition on the +weight is the zero-logarithm locus. Avoiding these finitely many +proper analytic loci gives the required Frobenius limits. The +companion has the same Tate action on $G_L$. + +Only finite radical and coefficient tables are used at any stage. +They can therefore be combined into finite Chebotarev prescriptions +with accuracy tending to infinity. If a bound on +$v_p(r_{j,i}-1)-n_{j,i}$ is required, perturb by a sufficiently high +power of a fixed near-identity element with nontorsion cyclotomic +projection. Its radical geometric sums vanish to the required +precision, while its cyclotomic displacement has valuation +$n_{j,i}+O(1)$. +No boundedness of the unramified $p$-local degrees of the full +conductor fields is used. +\end{proof} + +Put $R=\Z_p[[t,\mathbf u]]$ and let $\chi$ be the product of the +true and artificial character scalars. Over $\Q$ let $G$ be the +ordinary global complex for $T\chi$, with the moving places allowed. +Over $K$ use the full global complex, also allowing the moving +places, and set +\[ + C_w=\operatorname{fib}(G\longrightarrow L_w^{\rm loc}), + \qquad w\mid p, +\] +where the condition at the other $p$-place is full. The residual +restriction kills global $H^0$, and the complementary restriction +at the other $p$-place kills dual $H^0$. Euler characteristic is +zero. Thus $C_w$ has a square free model in degrees $1,2$; let +$L_w$ denote its differential determinant, up to a unit. Use +$L'_w$ for the companion. Inverting all character conventions +gives the same assertions. + +\begin{proposition}[Residual concentration]\label{vertical:tests} +After adjoining finitely many more tame variables, the separate +rational and imaginary tuples satisfy +\begin{equation}\label{eq:source-1}\tag{1} + \begin{array}{ll} + \mathrm{(a)}&G\otimes_RR_{(p)}\text{ is a free line in degree one};\\[2pt] + \mathrm{(b)}&L_w,L'_w\not\equiv0\pmod{(p,t)} + \quad\text{for both }w\mid p. + \end{array} +\end{equation} +\end{proposition} + +The proof occupies the rest of the section. We first describe the +residual cohomology and its parity, then produce a deformation that +kills each residual strict space. + +\subsection{Residual spaces and the scalar primitive} + +Initially specialize to +\[ + k_r=\Frac(\F_p[[\mathbf u]]),\qquad t=0. +\] +The residual elliptic representation is either absolutely simple or +has character constituents. Indeed its image contains an element +acting with eigenvalues $1,-1$, even after restriction to $G_K$, +by the disjointness imposed in Section~\ref{sec:classical}. An +irreducible plane cannot have a quadratic endomorphism field +commuting with this element. In the reducible case the two +characters are distinct, also over $K$. Test each simple +constituent, extending the finite coefficient field when necessary, +and include the $\chi$ twist. Its paired Tate dual has the inverse +twist. + +At every finite place in these tests $H^0=H^2=0$. At fixed split +places the nonconstant Frobenius scalar gives $H^0=0$; at nonsplit +exceptional places inertia does so; at a moving place its own +inertia variable does so. Apply the same argument to the dual to +obtain $H^2=0$. Away from $p$, Euler characteristic zero then +makes the full local complex acyclic. Global invariants vanish +as well. The strict Selmer degree-one spaces consequently inject +into unrestricted cohomology by Lemma~\ref{models:evaluations}. + +Over $\Q$, write $s$ for the dimension of the dual all-strict +space. Its paired unrestricted primal space has dimension $s+a$, +where $a$ is the negative dimension of the primal constituent at +infinity. Killing the former space will kill primal $H^2$. +Over $K$, pair the $w$-strict space with the dual $\bar w$-strict +space. Exact orthogonality and Euler characteristic make their +dimensions equal, say $s$. + +\begin{lemma}[Scalar localization]\label{vertical:scalar-localization} +For the constant roots coefficient, global degree-two localization +is injective on these residual tests. In particular a cup of two +paired classes which is locally zero has a global cochain primitive. +\end{lemma} + +\begin{proof} +At residual arithmetic precision, the dual of the localization +kernel is the space of everywhere locally trivial constant +$\F_p$-characters, by Poitou--Tate. Such a character is unramified +everywhere and split at the support; it is therefore a class-group +character killed by the chosen generating prime classes. Over +$\Q$ the same group is zero. The scalar representation and its +cohomological comparison do not depend on the artificial variables. +Tensoring its residual diagram with $\F_p[[\mathbf u]]$ and then +its fraction field preserves this injection. Equivalently retain +the injectivity cone in Lemma~\ref{models:finite-models}. Thus a +locally zero degree-two scalar class is zero, giving the primitive. +\end{proof} + +\begin{lemma}[Conjugate parity]\label{vertical:parity} +For an absolutely simple residual elliptic plane over $K$, each +one-sided strict space above has even dimension. The same +alternation statement holds on characteristic-zero localizations +with unramified conditions at fixed non-$p$ places and constant +inertia action. +\end{lemma} + +\begin{proof} +Keep $t=0$ and lift the residual test to the $(p)$-DVR of +$\Z_p[[\mathbf u]]$. Non-$p$ local complexes are contractible +there, since their residual tests are acyclic. The remaining +one-sided problem is perfect in degrees $1,2$, with conjugate +self-duality. It is generically acyclic. To check this last +assertion, specialize centrally in characteristic zero. The +moving-place singular determinants are nonzero because +$V(\gamma_j)-1$ is invertible. Inflation therefore gives the +fixed-support problem. The simple-zero choices give one compact +Selmer line from points, and its localization at either $p$-place +is nonzero because the local logarithm has torsion kernel. At +non-$p$ places the rational local elliptic cohomology vanishes by +the absence of elliptic invariants, local duality, and Euler +characteristic zero. The strict--finite triangles of +Lemma~\ref{models:strict-finite} now give strict acyclicity. A +nonzero central determinant is nonzero generically. + +We spell out the sign that controls specialization. On the induced +coefficient, in its two $K$-coordinates, the pairing is +\begin{equation}\label{vertical:induced-pairing} + ((a,b),(a',b'))\longmapsto e(a,b')+e(b,a'), +\end{equation} +where $e$ is the elliptic alternating pairing. This is alternating +and Tate-equivariant, including under complex conjugation, which +swaps the coordinates and reverses $e$. Its compact cup gives a +graded skew pairing of shift $-3$. Split-coordinate local +conditions are isotropic. Unramified conditions have the residue +cup nullhomotopy, and contractible local conditions may be replaced +by zero. At a newly allowed discriminant place the Tate module is +unramified over $K$; quadratic inertia on the induced coefficient +swaps the two coordinates. Its invariants form the graph of a +character unit. Restriction to this graph has the same residue +nullhomotopy, since the residue group has cohomological dimension +one and the quadratic index is invertible. The real Tate terms +are zero. + +Graded cup commutativity, the cone cup, and their homotopies are +identities at finite $p$-power precision. Transfer them by +Lemma~\ref{models:finite-models}. Antisymmetrization is allowed +because $2$ is a unit. On a minimal two-term model the resulting +perfect pairing between degrees one and two identifies the +differential with an alternating matrix: if $P$ denotes the +degree-three pairing, its chain identity gives +$P(x,dy)=P(dx,y)=-P(y,dx)$. The residual and generic nullities of +an alternating matrix have the same parity. Generic acyclicity +therefore gives even residual nullity. + +This also explains the precise extension of the conjugate +Bockstein argument in \cite[Lemma 12.1 and Corollary 12.2]{B}. +No characteristic-zero division is used in +transferring the pairing to the residual field. For the later +characteristic-zero localizations the same calculation applies +with the constant-inertia unramified comparisons of +Section~\ref{sec:models}; their nullhomotopies are again the +residue ones. +\end{proof} + +\subsection{A new tame direction and its lifting obstruction} + +Adjoin a new split tame prime sequence with logarithm $\lambda$. +Require $\lambda$ to vanish at all old places, including the old +moving places, at every stage. This is achieved by imposing +sufficient radical precision on their ideal relations. Require +also that the old artificial character on its limiting Frobenius +$\gamma$ have a nonzero exponent. When the new variable is set +to zero, its local complex is then acyclic over $k_r$; unramified +inflation identifies the enlarged specialization with the old +diagram. + +These requirements are compatible with prescribed old evaluations. +Start with an element fixing all radicals from the base and having +the Tate and fixed-character conditions of +Lemma~\ref{vertical:auxiliary-tuples}. Adjust the old scalar +exponents by old moving-prime inertia. Such inertia is trivial +on the full Tate module, on the fixed splitting fields and +characters, and on the true anticyclotomic character. To make +an adjustment fix all radicals too, multiply an inertia element +by its conjugate under an element over the base acting by $-1$ +on $\mu_{p^\infty}$. The radical translations cancel whereas +the old abelian character exponents double. This factor of two +is invertible. Existence of the conjugating element follows +from the splitting of $p$ in the fixed fields. Make these +adjustments term by term, retaining the finite evaluation tables. + +\begin{lemma}[Necessary first-order lift test]\label{vertical:lift-test} +Let $x$ be an old strict class and $d$ a class in its paired opposite +space. Choose a primitive $u$ of their scalar cup, +$du=x\cup d$. For whole spaces of such classes, fix cochain +representatives on bases, choose the primitives on pairs of basis +elements, and extend these choices bilinearly. Suppose $x$ lifts +in the new direction, with +derivative satisfying $dx_1=-\lambda\cup x$ in the chosen character +convention. Put +\[ + A=(M_x(\gamma)-1)^{-1}x(\gamma), +\] +where $M_x$ is the coefficient representation of $x$. Then the +Frobenius evaluation $z_\gamma$ of $u-A\cup d$ vanishes, up to a +common nonzero sign or coordinate factor. Over $K$ the necessary +equation is its difference with the conjugate evaluation, since +the conjugate tame logarithm has the opposite sign. The test is +linear in the new direction and bilinear in $x,d$, and is valid +over $k_r$ as well as over the characteristic-zero field tests. +\end{lemma} + +\begin{proof} +The primitive exists by Lemma~\ref{vertical:scalar-localization}. +At each $p$-place one of the paired classes is strict, with the +specified local nullhomotopy; away from $p$ the residual local +complexes are acyclic. At the later horizontal tests the paired +unramified cups instead vanish through the residue complex of +cohomological dimension one. Thus the cup is locally zero. +Apply the +arithmetic sum of local invariants to the degree-two cochain +\begin{equation}\label{vertical:primitive-cup} + x_1\cup d-\lambda\cup u, +\end{equation} +with the simultaneous sign convention making it closed. At old +places $\lambda$ is zero and the local condition removes the +remaining cup. At the new place $x,d,u$ are unramified. The +Frobenius-minus-one operator is invertible, and $A$ trivializes +$x$ in the residue complex. Subtracting this coboundary leaves +the unramified scalar cochain $u-A\cup d$. Cup with the tame +direction has invariant equal, up to sign, to its Frobenius value. +Here the Frobenius fixes the $p$-power roots of unity, and the +direction is normalized by the power-residue exponent in the +compatible root basis. The mixed residue--inertia cup is therefore +the usual local reciprocity pairing. Over $K$ the two places +give the indicated difference. If several new directions are +combined, the logarithm of one is unramified at the other new +places and gives no additional mixed contribution. + +We verify the residual interpretation explicitly. Mark the old +global cochain inclusions and their values on the Frobenius +sequences, then use the inflation homotopies in adjoining the +new primes. Their restrictions to new inertia are zero, and +the induced residue representatives have the Frobenius values +just prescribed. The invertible residue operator removes their +degree-one cohomology, leaving exactly the scalar residue +cochain above. Mark its root basis and the mixed cup map too. +All the coboundary corrections, restriction homotopies, and the +compact invariant equation are finite matrix identities from +actual arithmetic diagrams. + +To use classes over $k_r$, clear their finitely many denominators +in $\F_p[[\mathbf u]]$, including those in the solution for $u$ +and in the inverse residue operator. The resulting equations +hold in the corresponding localized finite free models. Any +equation which holds only after that localization becomes an +equation over $\F_p[[\mathbf u]]$ after multiplication by one +more common nonzero parameter denominator. Now use the Artin +rings $A_b=\F_p[[\mathbf u]]/(\mathbf u)^b$, with the first-order +new variables adjoined as needed. The prime $p$ is zero +throughout this residual calculation. The cochain inclusions +and homotopies identify its equations with the corresponding +actual stage arithmetic identities over $A_b$; no lift of an +arbitrary residual solution to $\Z/p^n$ is asserted. Passing +to the limit in $b$ and then inverting the same +nonzero parameter denominators proves the stated equation over +$k_r$. This does not divide by $p$. It also shows that further +field extensions preserve the test. For characteristic-zero +field points one may instead clear fixed scalar denominators +and increase the arithmetic precision, as in +Lemma~\ref{models:finite-models}. Thus the primitive computation applies +with its residual arithmetic identities established explicitly. +\end{proof} + +\subsection{Spanning the obstruction matrices} + +Choose bases $x_1,\ldots,x_s$ of a strict space and +$d_1,\ldots,d_{s+a}$ of the paired opposite space in the rational +case, or $d_1,\ldots,d_s$ in the imaginary case. For a new +direction use the fixed pairwise primitives $u_{ij}$ with +$du_{ij}=x_i\cup d_j$, extended bilinearly as above. Its +\emph{necessary lift matrix} at Frobenius $\gamma$ +has $(i,j)$-entry $z_\gamma(x_i,d_j)$ from +Lemma~\ref{vertical:lift-test}, or the conjugate difference there +over $K$. A lifted class with row of coefficients $\alpha$ must +satisfy $\alpha Z_\gamma=0$. Thus a matrix with zero left kernel +excludes every nonzero lift in that direction. + +\begin{lemma}[Obstruction span]\label{vertical:obstruction-span} +For the residual tests above, finitely many new tame directions +have necessary lift matrices whose linear span contains every +$s\times(s+a)$ matrix over $k_r$ in the rational problem, every +$s\times s$ matrix for a reducible constituent in the imaginary +problem, and every alternating $s\times s$ matrix for an +absolutely simple plane in the imaginary problem. Previously +prescribed Tate actions, radical data, old character actions, +and acyclicity of the new local complexes can all be retained. +\end{lemma} + +\begin{proof} +Let $J$ be the termwise joint kernel of the full Tate and old +character actions, including $L$ and the fixed splitting data +over $K$. It is harmless to retain the fixed character data +as well. On $J$ the evaluations of $x,d$ are additive. +They detect their classes: old inertia at one moving prime +gives a central element in the quotient image whose scalar +difference from $1$ is invertible. Apply +Lemma~\ref{models:evaluations}. Independent classes in a simple +representation have evaluations spanning their full tuple, +jointly for nonisomorphic representations. + +In the rational case the opposite representations are already +nonisomorphic on old inertia, which sees $\chi$ and $\chi^{-1}$. +In the imaginary reducible case include the conjugate evaluations. +The resulting four representations are distinct: the elliptic +characters are distinct, and opposite infinite scalar twists +cannot be identified. For an absolutely simple plane take +$d_j=x_j^c$ under conjugate duality. The two oppositely twisted +planes are nonisomorphic for the same inertia reason. + +Multiply a chosen Frobenius representative by a commutator +$[v,w']$ with $v,w'\in J$. Since the full Tate action is fixed, +both elements fix the cyclotomic tower. Their radical actions +are translations in an abelian group. The commutator therefore +fixes all radicals, as well as the Tate and old character data. +The additive evaluations of $x,d$ on the commutator are zero, +so the local correction involving $A$ is unchanged. The +primitive equation changes its scalar evaluation by +\begin{equation}\label{vertical:commutator-change} + -e(x(v),d(w'))+e(x(w'),d(v)), +\end{equation} +up to the fixed sign convention. + +Joint spanning and bilinearity now give elementary rectangular +matrices in the rational problem and elementary square matrices +in a character problem. For a plane over $K$, take the +conjugate difference. With $d_j=x_j^c$, the transposed +comparison has the opposite sign by Weil skew-symmetry; hence +the changes span $E_{ij}-E_{ji}$, the elementary alternating +matrices. This uses linear span over $k_r$, not an assertion +that every vector in that span is a single Galois evaluation. +Only finitely many commutators are needed to span the finite +matrix spaces. Differences from the initial Frobenius test +belong to the span of the resulting directions, so their +linear span has the asserted size. + +Realize the required Frobenius representatives by Chebotarev at +increasing finite precision, preserving the radical and +evaluation tables of Lemma~\ref{vertical:lift-test}. Normalize +all root and tangent bases in the same diagrams. A common +nonzero sign, or a nonzero scalar multiplying an entire tangent +direction, does not change its span. For conjugate places use +the transported marking, so the two entries are compared with +the same normalization. +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{vertical:tests}] +If a tested strict space is zero no new direction is needed. +Otherwise Lemma~\ref{vertical:obstruction-span} supplies a +linear combination of directions whose necessary lift test has +zero left kernel. In the plane case this uses +Lemma~\ref{vertical:parity}: $s$ is even and an alternating +matrix with $s/2$ invertible skew blocks is nonsingular. + +Work in the enlarged residual ring, localized where the old +variables have fraction field $k_r$ and all new variables are +zero. The new local complexes are acyclic at this point, so +the specialized global diagrams are the old ones. Cancel their +unit differential blocks. In the remaining minimal complex, +the derivative of a lifted degree-one vector in a new tangent +direction is the first-order differential. A vector in its +kernel would pass every necessary cup test. The chosen test +has zero kernel, so this first-order differential has full +column rank in that direction. Some maximal minor of the +actual differential has a nonzero initial term. It is +therefore nonzero over the enlarged generic residual field, +which kills that strict space. + +Take the union of the finite direction lists for all simple +constituents, both sides, and both imaginary curves. Each test +retains its own slice, since every new local prime was chosen +Frobenius-acyclic there. Long exact sequences for the residual +composition filtration then give the desired vanishing for +the original representation, including nonsplit extensions. + +Over $\Q$ the dual strict vanishing gives $H^2=0$ for the +primal full complex. Its Euler characteristic is $-1$, so it +has one residual degree-one line. Minimality first at +$(p,t)$ and then at $(p)$ gives a free line over $R_{(p)}$. +Over $K$, one-sided $H^1$ and $H^2$ vanish at the generic +residual test. The square determinant consequently has +nonzero reduction modulo $(p,t)$, on both sides and for the +companion. This is~\eqref{eq:source-1}. +\end{proof} + +\subsection{Further directions and characteristic-zero tests} + +The same construction will be needed when removing horizontal +divisors. We record what can be retained, so that the later +commutative algebra need not repeat the arithmetic choices. + +Here a \emph{horizontal field test} means the derived fiber over +$k(\mathfrak P)=\Frac(R/\mathfrak P)$ for a height-one prime +$\mathfrak P$ of $R=\Z_p[[t,\mathbf u]]$ with $p\notin\mathfrak P$. +Its local testing ring is the DVR $R_{\mathfrak P}$. This field +need not be a finite extension of $\Q_p$. The finite-extension +interior points of Lemma~\ref{models:field-points} are points of +the divisor at which finitely many specified denominators remain +nonzero. Comparisons then specialize from the localization of +$R/\mathfrak P$ at those denominators, not from its entire +fraction field. In an enlargement by new variables $\mathbf v$, retaining +an old test means localization at $(\mathfrak P,\mathbf v)$ and +specialization $\mathbf v=0$ before its field fiber is taken. + +\begin{lemma}[Preservation under enlargement]\label{vertical:enlargement} +Property~\eqref{eq:source-1}(b) persists when further tame primes +are adjoined, provided each has a nonzero Frobenius exponent +in the preceding artificial variables. On setting the new +variables to zero, unramified inflation identifies the old +diagram, with the full new-place singular factors retained. +Those factors have nonzero reduction on the residual test. +\end{lemma} + +\begin{proof} +At the old residual test the new prime has unramified scalar +Frobenius involving an old variable with nonzero exponent. +Its Frobenius-minus-one determinants are nonzero; the local +complex is acyclic over the residual fraction field. The +localized full-to-unramified triangle multiplies the +determinant by a nonzero residual singular factor. Hence +specialization of each enlarged determinant remains nonzero +at the old residual test, which proves the assertion. +\end{proof} + +\begin{lemma}[Directions at horizontal tests]\label{vertical:horizontal-directions} +Fix finitely many characteristic-zero height-one field tests +of a tuple satisfying~\eqref{eq:source-1}(b), with at least two +old artificial variables. One may adjoin finitely many tame +directions, locally zero on all old support, so that the new +prime complexes are acyclic at all these fields and the +necessary lift tests of Lemma~\ref{vertical:lift-test} retain +their commutator-spanning property. The construction is +compatible with further field extension and with the +primitive unramified conditions at fixed non-$p$ places. +\end{lemma} + +\begin{proof} +At a height-one test at least one old inertia scalar has +infinite order: two independent variables cannot both +specialize to roots of unity on a single prime divisor. +Adjust the old Frobenius exponents of a new prime as above. +On a line in an infinite-order coordinate, an elliptic +eigenvalue exception excludes only boundedly many integer +choices. A sufficiently large finite grid in all the old +exponents therefore avoids the exceptions for the finite +list of fields and both representations. Keep the +nonzero-exponent requirement, all Tate and fixed character +conditions, and the radical conditions making the new +logarithms zero at old places. This gives simultaneous +Frobenius acyclicity. + +Exact orthogonality at the old unramified places uses +Lemma~\ref{models:orthogonality}. Their cup contributions +and first-order contributions vanish through its residue +nullhomotopy, since the new logarithm is locally zero. +Scalar localization is obtained from the constant model +and Lemma~\ref{vertical:scalar-localization}; it remains +injective after these characteristic-zero specializations. +The marked cup and primitive proof now gives the lift +identity at each field. On the joint kernel, evaluations +are detected by the central old inertia scalar, and the +commutator formula~\eqref{vertical:commutator-change} +preserves all the imposed data. For any finite list of +fields take the union of their direction lists. Each +retains its own spanning slice; it is unnecessary to +prescribe independent matrices at all fields with a single +prime. Clearing the finitely many denominators and slowing +precision preserves the comparison identities, also after +field extension. +\end{proof} + +The vertical part of the comparison is now fixed integrally. +The later sections may test horizontal divisibility after +inversion of $p$ while retaining the nonzero residual +determinants in~\eqref{eq:source-1}. diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/05-single.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/05-single.tex new file mode 100644 index 0000000000000000000000000000000000000000..d958f770a6b37ded17f2437a41eb3bf7075b2e3e --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/05-single.tex @@ -0,0 +1,1379 @@ +\section{The single-curve determinant and its central value}\label{sec:single} + +Fix an odd prime \(p\). In this section \(E/\Q\) is non-CM and has +analytic rank zero or one. The purpose is to prove +\(X(E)\geq0\), where +\[ + X(E)=v_p(Q_E)-v_p\bigl(\#\Sha(E/\Q)\bigr). +\] +The rank and finiteness conclusions of +Theorem~\ref{classical:analytic-low-rank} are in force. +We first construct an integral element of a power-series +ring. Its value at the trivial character will be computed separately: +by the dual exponential in rank zero, and by an exact logarithmic +comparison in rank one. These are different assertions, and both are +needed for the inequality. + +We use the inverse determinant and the local-condition conventions of +Section~\ref{sec:models}. In particular, if a two-term acyclic complex +in degrees \(1,2\) has determinant of differential \(a\), then the +coordinate of its canonical rational trivialization has valuation +\(-v_p(a)\). This sign will account for the local Euler factors below. + +\subsection{Integral Siegel classes and their period coordinate} +\label{single:siegel} + +Let \(N\) be the conductor of \(E\) and \(f\) its normalized +newform. We construct the integral +classes needed for the single-curve comparison and determine their exact +dual-exponential coordinate. The normalization follows the construction +in \cite[Section~4]{B}; the coefficient prime in that source is two, so +we verify the changes in the construction at an odd prime explicitly. + +Let \(E_0\) be the optimal elliptic quotient of \(J_1(N)\), and let +\(C_{\rm cusp}\subset E_0(\overline{\Q})\) be generated by geometric +cusp differences. Manin--Drinfeld makes this a finite Galois-stable +subgroup. Replace the curve within its isogeny class by +\(E=E_0/C_{\rm cusp}\); Proposition~\ref{classical:isogeny} preserves +\(X(E)\). The Abel map, followed by this quotient, gives +\(\pi:(X_1(N),D_N)\longrightarrow(E,O)\), where \(D_N\) is the cusp set; +the map is independent of the base cusp used for the Abel map. +Put \(T=H^1(\overline E,\Z_p)(1)=T_pE\), using the principal pairing, +and \(V=T\otimes\Q_p\). +For \(A=p^k\), \(k\geq0\), put \(L_0=NA\) and let +\(\Pi:(X_1(L_0),D_{L_0})\to(E,O)\) be the \(A\)-degeneracy followed +by \(\pi\). At the mark \(1/L_0\) the degeneracy is +\(\tau\mapsto A\tau\). Thus, for a minimal differential \(\omega\), +\[ + \Pi^*\omega=c_FF\,\frac{dq}{q},\qquad + F(\tau)=Af(A\tau),\qquad q=e^{2\pi i\tau},\quad c_F\in\Q^\times. +\] +Let \(a\) be the primitive generator of +\(H_1(E(\C),\Z)^{G_{\R}}\) oriented by +\(\Omega_0=\int_a\omega>0\). For \(\xi\in\mathrm{SL}_2(\Z)\), +define \(\delta_\xi\in H^1(E(\C),\Z)\) as the Poincare dual of +\(\Pi_*\xi\{0,\infty\}\), with convention +\(\int_E\omega\wedge\delta_\xi=\int_{\Pi_*\xi\{0,\infty\}}\omega\). + +\begin{lemma}[The relative lattice]\label{single:relative-lattice} +Relative pullback and Poincare duality give an integral Galois map +\[ + H^1(\overline{Y_1(L_0)},\Z_p)(1)\longrightarrow T. +\] +For \(A=1\), an integral combination \(\delta=\sum_\xi n_\xi\delta_\xi\) +of finitely many symbols satisfies \(\delta(a)=1\). +\end{lemma} +\begin{proof} +Write \(E_0(\C)=\C/\Lambda_0\). The connected optimal kernel makes +the map on integral homology onto \(\Lambda_0\). Quotienting by +\(C_{\rm cusp}\) replaces \(\Lambda_0\) by the lattice generated by it +and lifts of the cusp images. Relative paths between cusps supply +exactly these additional generators. Consequently +\(H_1(X_1(N)(\C),D_N;\Z)\to H_1(E(\C),\Z)\) is onto. +The Farey triangulation generates the relative group by the Manin edges +\(\xi\{0,\infty\}\). The invariant sublattice is saturated, so \(a\) +is primitive; unimodularity of the intersection form now gives the +asserted integral combination. Pullback by the map of pairs is integral, +and relative Poincare duality gives the displayed etale map. This is +the Betti and relative-cohomology argument of +\cite[Section~4, ``The integral relative lattice'']{B}, before any choice +of coefficient prime; no Hecke projector is involved. +\end{proof} + +We use two level patterns, always with \(v_p(M)\geq6\). +In square order, \(n_1=n_2=M\), \(L_0\mid M\), and the row +\(l=(l_1,l_2)\) is \((0,1)\xi\). +In rectangular order put \(b=N/p^{v_p(N)}\), require +\((b,M)=1\) and \(p^{v_p(L_0)}\mid M\), and take +\[ + n_1=b_1M,\qquad n_2=bM,\qquad l=(Ns,1)=(0,1)\xi, +\] +where \(b_1\mid b\) is a product of complete prime powers dividing \(b\). +The unfilled pattern means \(b_1=1\). +The curve \(Y(n_1,n_2)\) parametrizes elliptic curves with independent +points \(P,Q\) of orders \(n_1,n_2\); independence means that they +embed \(\Z/n_1\oplus\Z/n_2\). The maps to the marked curve and the +cyclotomic field are specified by +\begin{equation}\label{single:mark-root} + C=\frac{l_1n_1}{L_0}P+\frac{l_2n_2}{L_0}Q,\qquad + \eta_M=e_M((n_1/M)P,(n_2/M)Q). +\end{equation} +The coefficients of \(C\) are integers in both patterns; \(C\) has +order \(L_0\), and \(\eta_M\) is primitive of order \(M\). +Fix compatible roots in the algebraic, complex, and \(p\)-adic +realizations, with complex root \(e^{2\pi i/m}\) at order \(m\). + +Choose \(c,d>1\) prime to \(6pn_2\), with +\(c,d\equiv1\pmod{L_0}\). On the universal elliptic curve \(\mathcal E\) +let \({}_c\theta_{\mathcal E}\) be Kato's normalized function of divisor +\(c^2(0)-\mathcal E[c]\), and put +\({}_cg_P=P^*{}_c\theta_{\mathcal E}\), \({}_dg_Q=Q^*{}_d\theta_{\mathcal E}\). +Its norm under \([s]\) is itself if \((s,c)=1\) +\cite[Sections~1--2]{Kato}. +At precision \(p^j\), replace the orders by \(p^jn_1,p^jn_2\), and +let \(P',Q'\) range over their independent division lifts of \(P,Q\). +Take the unnormalized trace of the Kummer cup +\begin{equation}\label{single:K1} + ({}_cg_{P'})\cup({}_dg_{Q'})\otimes + e_{p^j}(n_1P',n_2Q')^\vee. +\end{equation} +Here the dual basis sends the displayed primitive root to \(1\), so the +coefficient is \(\Z/p^j(1)\). Apply the arithmetic edge map, trace +along \eqref{single:mark-root}, and push to \(T/p^j\) by +Lemma~\ref{single:relative-lattice}. Passage to the inverse limit +defines a class in \(H^1(G_{\Q,S}, +T\otimes\Z_p[\Gal(\Q(\mu_M)/\Q)])\), for \(S\) containing the +primes of \(pn_2\) and infinity. +For a finite character \(\nu\) of this Galois group, send the basis +vector at \(\sigma\) to \(\nu(\sigma)\); write \(z_\nu\) for the result +with coefficients in \(T\otimes\Z_p[\nu]\). +All traces, including this character push, are unnormalized. + +\begin{proposition}[Integrality and traces]\label{single:siegel-traces} +The classes just constructed are integral away from \(pn_2\infty\) +and compatible with division traces and with corestriction as the +\(p\)-part of \(M\) grows with \(A,c,d,\xi\) fixed. +If \(\ell\nmid cdn_2L_0\) is a fresh prime and is adjoined to both +orders and the root index, the rational norm multiplier is +\begin{equation}\label{single:good-norm} + 1-\frac{a_\ell(f)[\ell]}{\ell}+\frac{[\ell]^2}{\ell}, +\end{equation} +where \([\ell]\) sends the determinant root to its \(\ell\)-th power. +For \(q_0^a\parallel b\), \(q_0\nmid b_1\), filling \(q_0^a\) +into the first row gives, at a finite even character \(\nu\), +\begin{equation}\label{single:bad-row} + z_{\rm filled}=(1-a_{q_0}(f)\nu(q_0)/q_0)z_{\rm before}. +\end{equation} +The trace maps themselves are integral in both assertions. +\end{proposition} +\begin{proof} +Further \(p\)-division gives a Cartesian product of the two lift sets: +independence is automatic since the old tuple is already a basis at +\(p\). At the old precision the inverse-root twists agree. Base +change and the projection formula turn the trace of the cup into +the cup of the traces, and distribution recovers the old class. +The mark and lower root also agree when the base \(p\)-level grows. +The functions and their inverses are integral away from the level. +Indeed horizontal valuations follow from their divisors; on a smooth +full-level model every geometric fiber component meets a cusp, where +the Tate leading terms are signs, roots of unity, and powers of +\(1-\zeta\) for nontrivial level roots. These are units away from +the level. This also checks quotients of level after pullback. +The relative open curve has lisse geometric cohomology away from this +support, vanishing above degree one. Its arithmetic edge map lands in +\(H^1(G_{\Q,S},H^1(\overline{Y(n_1,n_2)},\Z/p^j)(1))\). +Edge maps commute with traces and maps of pairs. Finiteness in degree +zero gives the Mittag--Leffler property needed for compact passage; +the subsequent lattice and coefficient maps are integral. + +At \(\ell\), start with the Cartesian division sets, subtract the +tuples whose \(\ell\)-parts lie in a common line \(I\subset\mathcal E[\ell]\), +and add back \(\ell\) times the double-prime-to-\(\ell\) lift. The zero +pair was subtracted \(\ell+1\) times, which explains this multiplicity. +Distribution on \(\mathcal E/I\) identifies the line sums with the +good Hecke correspondence. Quotient isogenies raise the Weil roots +to \(\ell\), giving \([\ell]\) and twist scalar \(\ell^{-1}\); +the relative elliptic push has Hecke eigenvalue \(a_\ell(f)\). +This last assertion holds for relative maps because pullback has zero +endpoint-function coordinates and the equality of eigenforms also +holds on path integrals. The added-back multiplication isogeny raises +the roots to \(\ell^2\); its scalar \(\ell^{-2}\), multiplied by +\(\ell\), gives the last term of \eqref{single:good-norm}. + +For row filling, fix \(Q\). A discarded \(q_0^a\)-division lift of +\(P\) has its \([q_0^{a-1}]\)-image in the order-\(q_0\) line \(I_Q\). +For \(\rho:\mathcal E\to\mathcal E/I_Q\), these lifts are precisely +the preimages under \(\rho[q_0^{a-1}]\) of the prime-to-\(q_0\) point +\(\widetilde P\) satisfying \(\rho^\vee\widetilde P=P\). +Express the other unit by distribution over +\(\rho^\vee\widetilde Q=Q\). The points \(\widetilde Q\) have order +\(n_2\), and their order-\(q_0\) lines differ from \(\ker\rho^\vee\). +In reverse, the discarded sum is indexed by all lines other than the +line of the source mark, since \(l=(Ns,1)\). Its branches at mark +\(1/L_0\) are \(\tau\mapsto(\tau+i)/q_0\), \(i\bmod q_0\). +Thus it is \(U_{q_0}\), acting on \(Af(A\tau)\) by \(a_{q_0}(f)\) +because \((A,q_0)=1\). Root translation and inverse twist contribute +\(\nu(q_0)/q_0\). This proves \eqref{single:bad-row}, including +\(q_0=2\). The argument reproduces the geometric correspondences of +\cite[Section~4, ``Good-prime norms and rectangular filling'']{B}; +every denominator displayed here is a unit at \(p\). +\end{proof} + +We next fix the rational differential coordinate, retaining the absolute +normalization needed for divisibility. For a nonzero torsion label +\(P=[x\tau+y]\), let \(E_P\) be the algebraic weight-one form +\[ + E_P=-\frac1{2\pi i}\left. + \sum_{(m,n)\in(x,y)+\Z^2} + \frac{(\operatorname{Im}\tau)^w} + {(m\tau+n)|m\tau+n|^{2w}}\right|_{w=0}, +\] +where the value is obtained by regular continuation. + +\begin{lemma}[Full-level calibration]\label{single:kato-calibration} +In square order, before projection to the elliptic curve, the dual +exponential of \eqref{single:K1} is +\begin{equation}\label{single:full-differential} + \pm M^{-2}(c^2E_P-cE_{cP})(d^2E_Q-dE_{dQ})\,\frac{dq}{q}. +\end{equation} +The sign is determined by cup, pairing, and orientation conventions +and is common to the determinant components. +\end{lemma} +\begin{proof} +Initially impose \(c,d\equiv1\pmod M\). Apply +\cite[Theorem~9.5]{Kato} with \(k=2\), \(r=r'=1\), and equal level +orders \(M,M\). The prime-support containment is automatic, the +range conditions are satisfied, and \(p\mid M\) selects the branch +without an additional Euler operator. The symmetric power has degree +zero. Its negative Tate moment is exactly the inverse determinant +\(e_{p^j}(MP',MQ')^\vee\) on the basis coset of division tuples. +The weight-one shifted and Fourier-dual forms agree under the fixed +conventions \cite[Proposition~3.11(1) and Section~4.2]{Kato}. +The theorem therefore gives proportionality to the two brackets in +\eqref{single:full-differential}. We determine the scalar by residues. + +Put \(\Theta(t,q)=(1-t)\prod_{h\geq1}(1-q^ht)(1-q^h/t)\). +The normalized Tate function is +\[ + {}_c\theta(t)=(-1)^{(c-1)/2}q^{(c^2-1)/12}t^{-c(c-1)/2} + \frac{\Theta(t,q)^{c^2}}{\Theta(t^c,q)}. +\] +The relation \(\Theta(qt,q)=-t^{-1}\Theta(t,q)\) verifies periodicity +and the divisor; multiplication over \([s]\)-preimages verifies norm +invariance for \((s,c)=1\). These norms fix the constant uniquely: +the norms under \([2]\) and \([3]\) force its third and eighth powers +to be one. For \(01\) generically, choose the two nonzero evaluations above. +Equation~\eqref{single:finite-singular} makes the derived primal +class nonzero on the singular line. Its pairing with the old +dual class is then nonzero at this prime and zero at all other +places, contradicting reciprocity. Thus \(h=1\) generically. +At a DVR where the fiber has \(h>1\), use the primitive reduction +of the generic line and a nonzero fiber dual class. The exact +line-switch Lemma~\ref{models:line-switch} reduces \(h\) by one +and preserves the determinant valuation, because the comparison in +\eqref{single:finite-singular} is a unit. After finitely many +switches the complex is a free line in degree one and its class +is integral. The factor \(L_*\) is a unit at this DVR. Reading +the equalities backwards proves \eqref{eq:source-4}. +\end{proof} + +\subsection{Removing the smoothing and Euler divisors} + +\begin{proof}[Proof of Proposition~\ref{single:integral}] +At \((p)\), \eqref{eq:source-1}(a) identifies \(G\) with a free +line in degree one. The class is integral and the normalizing +factors are units there. This proves nonnegative order at the +vertical divisor once generic nonvanishing is known. + +For that nonvanishing, use the second setting in +Lemma~\ref{single:line}. Rohrlich's finite-support twist +nonvanishing, in the form \cite[Theorem 13.5(2)]{Kato}, applies to +the fixed weight-two newform and characters with conductor +supported at \(p\). Infinitely many sufficiently ramified even +characters have nonzero central value. The period formula +\eqref{eq:source-2} therefore makes the fixed-support square class +generically nonzero: a torsion class over the one-variable +power-series ring would vanish at all but finitely many such +characters. Lemma~\ref{single:line} gives one generic line. +Setting all \(u_j=0\) in the full diagram adds acyclic singular +quotients, since the moving Frobenius limits have +\(\det(1-g_j)\ne0\), where \(g_j\) is the limiting Frobenius +at the \(j\)-th moving prime. The good norm relations multiply the class +by the nonzero constants \(2-\Tr(g_j)\). Thus the full diagram +also has a nonzero class on a single generic line. The first +setting of the lemma now treats every horizontal divisor outside +the fixed factors. + +It remains to remove the fixed factors. Express \(U=g_0/f_0\) +using integral determinant pivot formulas, with \(f_0\ne0\), and +retain integral stage expressions \(g_{0,i},f_{0,i}\). Specialize +the tame variables to finite nontrivial values +\(u_j=\eta_j-1\), avoiding identically zero denominators and +the prohibited Frobenius values at \(p\). These specializations +still detect bounded series: repeated one-variable Weierstrass +preparation permits avoidance of any finite collection of +nonzero conditions. The conditions also hold at sufficiently +precise original stages. + +Fix such a stage and a horizontal prime of \(\Lambda_\eta\). +Use a rectangular system with unfilled first row, with +\(b=N_{p'}\), and \(M\) supported only at \(p\) and the active +tame conductors. Choose a degeneracy \(A=p^k\) and a symbol +with nonzero evaluation. Smoothing integers \(c',d'\) can be +chosen so that \(\Delta'\) is a unit at this prime. Indeed +preparation realizes its \(t\)-value as an algebraic point of +the open unit disk. Use CRT to choose integers tending to one +\(p\)-adically, congruent to one on the required fixed symbol +orders, and with a prescribed nontrivial \(\eta\)-value at one +active conductor and trivial values at the others. All +coprimalities can be maintained. At the selected \(t\)-value, +the cyclotomic factor tends to one whereas the chosen constant +weight is nontrivial, so the smoothing factor is eventually +nonzero. Fix one such choice while applying the line comparison. + +Call the resulting class \(z'\). It has primitive Euler factors +away from \(p\): the only other omitted primes are ramified +conductors of \(\eta\), where the twisted local factor is one. +The same nonvanishing theorem makes \(z'\) generically nonzero. +Lemma~\ref{single:line} gives its integral determinant order with +unramified old conditions. On changing those conditions to full, +the order changes by +\(-\sum_{q\ne p}v(D_{q,\eta})\). + +In the common generic full cohomology line the ratio of the +square and rectangular classes, apart from their nonzero +constant symbol ratio, is +\begin{equation}\label{single:class-ratio} + \frac{\Delta\prod_{q\in S_f\setminus\{p\}}P_q} + {\Delta'}. +\end{equation} +To verify the identity rather than merely its character values, +evaluate the two classes at the infinitely many sufficiently +ramified cyclotomic characters with nonzero central value. +Formula~\eqref{eq:source-2} gives exactly the displayed ratio; +omissions at active conductors contribute one. Clearing the +generic denominators and applying one-variable preparation proves +the identity. Squaring first gives the same valuation conclusion +if the common orientation sign has not been fixed. Consequently +the tested quotient \(g_{0,i}/f_{0,i}\) has no horizontal pole, +that is, +\[ + g_{0,i}(t,\boldsymbol\eta-1)/f_{0,i}(t,\boldsymbol\eta-1) + \in\Lambda_\eta[1/p]. +\] +There is no assertion of a uniform denominator for these stage +quotients. + +Every remaining possible pole of \(U\) divides a factor regular +in \(t\). For such a factor \(H\), take a distinguished +representative and divide the integral numerator by \(H^a\), +where \(a=v_H(f_0)\). At each permitted finite tame +specialization, the limiting numerator contains all the zeros +of the limiting denominator with their multiplicities. This +follows from Lemma~\ref{models:poles}: on a smaller closed disk about a zero, +the initially integral numerator and denominator converge +uniformly, and Weierstrass preparation preserves the number of +zeros with multiplicity. Thus the specialized division +remainder is zero. Finite-character detection makes the +remainder zero in \(R\). There are therefore no remaining +height-one poles. Since \(R\) is factorial, \(U\in R\), proving +the proposition. +\end{proof} + +\subsection{A tame height in analytic rank one} + +The preceding argument established integrality without identifying +the central coordinate. In rank one that identification requires +the following exact rational equality. Return to a fixed support +\(S\), with no moving primes. Choose its square order to have +prime support exactly \(S_f\). Let \(z_b\) be the smoothed +class at the trivial character and put +\[ + d_0=\Delta(0)\prod_{q\in S_f}P_q(1),\qquad + P_q(1)=L_q(E,1)^{-1}. +\] +If the analytic rank is one, \eqref{eq:source-2} makes the +central dual exponential zero. At non-\(p\) places rational +elliptic cohomology is zero, by local duality and the Euler +characteristic. Thus \(z_b\) lies in the rational compact +Selmer line. Finite \(\Sha\) identifies this line with +\(E(\Q)\otimes\Q_p\), so \(\log_\omega z_b\) means its +local elliptic logarithm. A nontorsion rational point has +nonzero local logarithm, since the kernel on local points is +torsion. + +\begin{proposition}[Exact logarithmic comparison]\label{single:logarithm} +If \(\ord_{s=1}L(E,s)=1\) and \(P\in E(\Q)\) is nontorsion, +then +\begin{equation} + \frac{\log_\omega z_b}{(\log_\omega P)^2} + =\pm d_0\frac{L'(E,1)}{\Omega_0H(P)}. + \tag{5}\label{eq:source-5} +\end{equation} +The right-hand quotient is rational, and is interpreted in +\(\Q_p\). The height is exactly the height \(H\) fixed in the +introduction. +\end{proposition} + +Choose \(K_b=\Q(\sqrt{-D})\), with \(-D<-4\) an odd fundamental +discriminant, so that all primes of \(2Np\) and the other fixed +data split, and +\(L(f\otimes\varepsilon,1)\ne0\), where +\(\varepsilon=\varepsilon_{K_b}\). +Lemma~\ref{classical:auxiliary-fields} applies because \(w(E)=-1\). Choose +an integral polynomial \(\mathcal A\) in Hecke operators away +from \(NDp\) that kills every other level-\(N\) eigensystem and +the Eisenstein types unramified away from \(N\) with conductor +dividing \(N\), including the weight-two trivial pair, while +\(\mathcal A_f\ne0\). +Also choose a good inert prime \(\ell\nmid6NDp\), away from +the Hecke primes occurring in \(\mathcal A\), with +\(a_f(\ell)\ne0\). Multiplicity one gives the first choice; +open image and Chebotarev give the second. The finitely many +Hecke coefficient tests have indices \(n\) prime to \(ND\), +with odd \(\ell\)-valuation. + +A horizontal sequence consists of primes \(r_i\), integers +\(m_i\to\infty\), and surjections +\[ + \lambda_i:(\Z/r_i\Z)^\times\longrightarrow\Z/p^{m_i}\Z. +\] +The primes \(r_i\) avoid the level, all fixed Hecke primes, and +all the finitely many tested indices. +We require \(r_i\equiv1\pmod{ND}\), \(r_i\to1\) in \(\Z_p\), +and splitting in the Hilbert class field of \(K_b\). The +characters kill \(p\), the fixed support, smoothing integers, +\(2,3,D\), all tested indices, and the finite model and lift +exceptions introduced below. Their limiting Tate Frobenius +has determinant one and trace \(a_*\ne\pm2\), with eigenvalues +not roots of unity. These characters are automatically even +because \(p\) is odd. Viewed idelically, \(\lambda_i\) has +uniformizer value \(\lambda_i(q)\) at \(q\ne r_i\), negative +residue character at \(r_i\), and zero uniformizer value there. +Over an extension it is composed with the norm. + +\begin{lemma}[A nonzero height direction]\label{single:height-direction} +The horizontal sequence can be chosen to define bilinear tame +heights whose rational limits satisfy +\[ + h_\lambda^{K_b}(P_1,P_2)=2h_\lambda^\Q(P_1,P_2) + \quad(P_1,P_2\in E(\Q)),\qquad + h_\lambda^\Q(P,P)\ne0. +\] +These heights are compatible with trace in the second argument. +\end{lemma} + +\begin{proof} +Let \(G_y\) be the extension of \(E\) by \(\mathbb G_m\) defined +by the Poincare biextension at \(y=\operatorname{pol}(P)\). +Choose a rational lift \(B_P\) of \(P\). The fiber is a line +torsor, so this lift exists. Splitting its underlying Tate +modules gives an upper-right Galois block \(\beta(g)g_T\); +\(\beta\) is the Kummer cocycle of \(y\), up to the fixed +polarization sign. At finite order this follows by identifying +division points of \(y\) with splittings of the extension and +using the Weil pairing to compare two splittings. Write the +Kummer cocycle of \(B_P\) as \((k,x)\). Then +\[ + dk=-\beta\cup x. +\] +Include all ramification and nonintegrality primes of these +data in the finite killed list. + +Adjoin to a fixed normal splitting field all cyclotomic +\(p\)-power roots and all \(p\)-power radicals of the killed +primes. Its relative Galois group has bounded derived length, +so the Tate image over this field still contains a deep +\(\operatorname{SL}_2\). On the additional Tate kernel the +values of \(x\) span the plane. Indeed nonzero Kummer classes +remain nonzero over a fixed finite extension; a central +homothety in the open Tate image detects them on its kernel. +The further radical quotient has scalar cyclotomic conjugation, +so cannot support the irreducible Tate plane as a quotient. +Choose an element \(g\) fixing the splitting and radical data, +with determinant-one Tate action of the required trace, and +\begin{equation}\label{single:height-cocycle} + k(g)-\beta(g)g_T(g_T-1)^{-1}x(g)\ne0. +\end{equation} +For existence, on the joint kernel the commutator of two +elements has \(x=\beta=0\) and \(k\)-value +\(\pm2e(x(h_1),x(h_2))\), where \(e\) denotes the Weil form. +Full span supplies a nonzero value. +Multiplying the chosen \(g\) by such a commutator changes the +left side of \eqref{single:height-cocycle} without changing its +Tate action. Chebotarev and compatible power-residue bases now +give the asserted \(r_i,\lambda_i\). + +We use the biextension construction of \cite[Section~6, +``Tame heights and trace compatibility'']{B}, verifying its +\(p\)-power version here. Over an extension +containing a ring class field of positive \(r_i\)-power +conductor, the normed character is unramified also above +\(r_i\). Indeed the split order class sequence identifies the +two residue-unit factors modulo the diagonal and the global +units \(\{\pm1\}\). For units at one specified split place, +the other component is one. The local norm subgroup therefore +has residue in \(\{\pm1\}\), which the even character kills. +Sum the local character valuations of a rational +biextension lift relative to its rigidified integral fibers. +Reciprocity gives independence of the lift, and the two +biextension laws give bilinearity. On a Jacobian this is the +Deligne-pairing intersection formula for disjoint generic +supports, with the common orientation sign. + +To define the same height downstairs, note that +\(\#E(\F_{r_i})\to2-a_*\ne0\) \(p\)-adically. One fixed +\(p^b\) therefore removes every finite \(p\)-primary reduction +part. After multiplying the first argument by \(p^b\), divide +it by \(p^{m_i}\) in the uniquely \(p\)-divisible local factor. +For lifts \(\mathcal B,\mathcal B'\) before and after division, +apply the local character to +\[ + \mathcal B/([p^{m_i}]_1\mathcal B'). +\] +Changing \(\mathcal B'\) changes this scalar by a +\(p^{m_i}\)-th power. The two laws give bilinearity; comparison +with integral lifts gives the unramified construction after +extension. Norming lifts in the second argument proves trace +compatibility. Passing to limits and dividing by \(p^b\) +defines the stated rational heights. + +For the fixed lift \(B_P\), all places except \(r_i\) contribute +zero. Put \(w_i=(g_{i,T}-1)^{-1}x(g_i)\), with \(p^bw_i\) +integral after enlarging the fixed \(b\). Correcting division +points by this coboundary leaves the fiber cocycle +\(p^b(k-\beta\cup w_i)\). Its Frobenius value is the power +residue character of the scalar ratio above. Thus the limiting +height is, up to sign, \eqref{single:height-cocycle}, and is +nonzero. Trace over \(K_b/\Q\) contributes its degree two. +\end{proof} + +Use the square classes with the additional prime \(r_i\), and +write \(\chi_b=(1+u)^{\lambda_i}\). Since \(\lambda_i(p)=0\), +the local coefficients at \(p\) are split. Let \(Z_i(u)\) be +the group polynomial of dual-exponential coordinates in +\(\omega\). Local splitting makes every group coefficient +pass through the same fixed map +\(\exp^*:H^1(\Q_p,T)\to\Q_p\omega\). Its image has a +fixed denominator lattice, so the denominators of \(Z_i\) +are bounded independently of \(i\). Moreover \(Z_i(0)=0\). +For nontrivial characters, +\[ + Z_i=\pm d_0 L(f,\overline{\chi_b},1)/\Omega_0. +\] +All these characters are primitive at \(r_i\); there is no +omitted \(r_i\)-factor in this formula. Write \(Z'\) for the +linear coefficient of the bounded-series limit. + +\begin{lemma}[Cup comparison]\label{single:cup} +For the sequence of Lemma~\ref{single:height-direction}, +\begin{equation} + Z'\log_\omega P + =\pm(2-a_*)\frac{\log_\omega z_b}{\log_\omega P} + h_\lambda^\Q(P,P). + \tag{6}\label{eq:source-6} +\end{equation} +\end{lemma} + +\begin{proof} +At stage \(i\), write a cocycle modulo \((p^{m_i},u^2)\) as +\(z_0+uz_1\). Then \(dz_1=-\lambda_i\cup z_0\). +The good norm relation and one fixed clearing factor permit +the adjustment +\[ + z_0=\alpha_i\beta,\qquad + \alpha_i=\pm\left(1-\frac{a_f(r_i)}{r_i}+\frac1{r_i}\right) + \frac{\log_\omega z_b}{\log_\omega P}. +\] +The clearing is uniform because the degree-one torsion has +bounded exponent. The scalar two-cocycle +\(z_1\cup x+\alpha_i\lambda_i\cup k\) is closed. Its local +invariant at \(p\) tends to \(Z'\log_\omega P\), by the +logarithm--dual-exponential pairing. At the other fixed places +the character is killed and the rational local class is a +coboundary. At \(r_i\), use \(dw_i=x\) to obtain +\(\alpha_i\lambda_i\cup(k-\beta\cup w_i)\). Its invariant is +\(\pm\alpha_i h_i^\Q(P,P)\), by the scalar-ratio computation +in Lemma~\ref{single:height-direction}. The sum of local +invariants is zero. Passing to the limit, the Euler factor +tends to \(2-a_*\), giving \eqref{eq:source-6}. +\end{proof} + +\subsection{The exact spectral comparison} + +Fix a rational modular parametrization \(\phi:X_0(N)\to E\), +of degree \(\delta_\phi\). Let \(P_X\in J_0(N)(K_b)\) be the +single oriented Hilbert-class trace based at \(\infty\), and +put \(Q_X=\phi_*P_X\). With unnormalized Petersson integral set +\[ + C_0=\frac{\sqrt D}{8\pi^2(f,f)_N}. +\] +Choose a real primitive period \(\Omega_{\rm tw}\) for the +negative twist. The period relations are +\[ + C_0\Omega_0\Omega_{\rm tw}\in\Q^\times, + \qquad L(f\otimes\varepsilon,1)/\Omega_{\rm tw}\in\Q^\times. +\] +The second is modular-symbol rationality. For the first, if +\(\phi^*\omega=c_\phi f\,dq/q\), the complex area of \(E\) +is \(8\pi^2c_\phi^2(f,f)_N/\delta_\phi\); the twist period is a +rational multiple of the anti-invariant period divided by +\(\sqrt D\). This also specifies the rational normalization +in which the following identities are embedded in \(\Q_p\). + +\begin{lemma}[Spectral-height identity]\label{single:spectral} +For the horizontal sequence just constructed, +\begin{equation} + C_0\Omega_0L(f\otimes\varepsilon,1)\frac{Z'}{d_0} + =\pm(2-a_*)\frac{h_\lambda^{K_b}(Q_X,Q_X)}{\delta_\phi}. + \tag{7}\label{eq:source-7} +\end{equation} +\end{lemma} + +\begin{proof} +The proof evaluates the same finite differences of kernel +coefficients in two ways. Projection onto the \(f\)-block +expresses them through \(Z'\); their intersection interpretation +expresses them through \(h_\lambda^{K_b}(Q_X,Q_X)\). Matching +the two evaluations, with their constants, gives the identity. +We first specify the finite-character formulas and then prove +their interpolation in the present \(p\)-power direction. +They are the complex coefficient and geometric intersection +identities in \cite[Section 6, ``The traced coefficient,'' +``Fricke transformation and unfolding,'' and +``Intersection realization'']{B}. +Their hypotheses are an odd fundamental discriminant \(-D<-4\), +split Heegner level \(N\), a prime \(r\nmid ND\) split in the +Hilbert class field with \(r\equiv1\pmod{ND}\), an even +prime-conductor character \(\chi\) with \(\chi^2\ne1\), and +indices \(nr^h\) with \((n,ND)=1\) and odd valuation at the +chosen inert prime \(\ell\). None of these identities has a +coefficient-prime hypothesis. + +Here are their precise normalizations. Choose integral ideal +representatives \(C\) of \(\Pic(\mathcal O_{K_b})\), prime to +\(D\), and put \(a_C=\mathrm NC\). +Let \(e(x)=\exp(2\pi i x)\) and +\[ + \theta(z)=\frac12\sum_C\sum_{x\in C}e(\mathrm Nx\,z/a_C). +\] +Its positive coefficient is +\(\rho(n)=\sum_{d\mid n}\varepsilon(d)\). If \(\theta_\chi\) +is its Fourier twist, define +\[ + E_{\chi,s}(z)=\frac12 + \sum_{\substack{(c_1,d_1)\ne(0,0)\\ND\mid c_1}} + \varepsilon(d_1)\bar\chi^2(c_1) + \frac{\operatorname{Im}(z)^s} + {(c_1z+d_1)|c_1z+d_1|^{2s}}, + \qquad + I_\chi=\left.\frac{\sqrt D}{2\pi} + \Tr_{NDr^2/Nr^2}(\theta_\chi E_{\chi,s})\right|_{s=0}. +\] +Characters are extended by zero at nonunits; the trace is +unnormalized. The continuation is holomorphic. Poisson +summation pairs the odd row weights, eliminates the +nonholomorphic modes, and permits pairing with cusp tests. + +For every tested index \(n\) and \(h\ge1\), regard the +coefficient at \(nr_i^h\) as a polynomial +\(D_{i,h}(n;u)\) in +\(\Z_p[u]/((1+u)^{p^{m_i}}-1)\): in the following sum +\(r=r_i\) and \(\chi(x)=(1+u)^{\lambda_i(x)}\). +\begin{equation}\label{single:kernel-coefficient} + D_{i,h}(n;u)=\frac12 + \sum_{\substack{C,\ y\in C,\ b>0\\ + a=\mathrm Ny/a_C>0\\ a+Nb=nr^hD}} + \sum_{\substack{kl=b\\\gcd(k,l,D)=1}} + W(k)\chi(a/D)\bar\chi^2(Nk), +\end{equation} +where +\[ + W(k)=\prod_{\substack{q\mid D\\q\mid k}}(l/q) + \prod_{\substack{q\mid D\\q\nmid k}}(-a_CNk/q). +\] +Write \(\epsilon_q(x)=(x/q)\). The local partial Fourier +transform at \(q\mid D\) has scalar +\(\kappa_q=q^{-1}\tau_q\epsilon_q(-a_CD/q)\), with +\(\tau_q=\sum_{x\bmod q}\epsilon_q(x)e(x/q)\). +Multiplying the partial traces +and the Poisson factor \(-2\pi i/D\) leaves common scalar one, +because the primitive Gauss sum of \(\varepsilon\) is +\(i\sqrt D\). This explains in particular the factor \(1/2\) +in \eqref{single:kernel-coefficient}. For a trace matrix +\(\gamma=\left(\begin{smallmatrix}a_\gamma&b_\gamma\\ +c_\gamma&d_\gamma\end{smallmatrix}\right)\in\Gamma_0(Nr^2)\), +translation of the theta twist multiplies its weight by +\(\chi(a_\gamma^{-2})\), canceled by the Eisenstein row +weight \(\chi^2(a_\gamma)\). Thus these +finite-character computations apply to our characters as soon +as \(\chi^2\ne1\), which holds for every nontrivial +\(p\)-power character. + +Use the same marked Artin limits as before to define +\(D_h(n;u)=\lim_i D_{i,h}(n;u)\) and +\(D'_h(n)=[u]D_h(n;u)\). Only terms with \(a\) a unit at +\(r\) occur in \eqref{single:kernel-coefficient}. Since +\(r\mid nr^h\), this is equivalent to \(k,l\) being units +there. The identity \(W(l)=-W(k)\) cancels the +divisor-independent terms in the derivative of the character +weight. Hence \(D'_h(n)\) is the limit of the masked sum +with weight \(-2\lambda_i(k)\). + +For \(h\ge0\), define \(B_{i,h}(n)\in\Z/p^{m_i}\Z\) by +the same sum with the mask removed and character weight +replaced by \(-2\lambda_i(k/r_i^{v_{r_i}(k)})\). Write +\(B_h(n)\) for its Artin limit, put \(B_h(n)=0\) for +\(h<0\), and set \(C_h(n)=B_h(n)-B_{h-2}(n)\). +Stripping a common power \(r^j\) from \(a,b\) shows that, +for \(h\ge2\), +\begin{equation}\label{single:mask} + C_{h+1}-2C_h+C_{h-1}=D'_{h+1}+2D'_h+D'_{h-1}. +\end{equation} +For completeness, when the primitive index is positive the +\(C_h\)-multiplicities are \(1,4,8,12,\ldots\); their second +differences are \(1,2,1\). At primitive index zero they are +affine and the second difference is zero. The off-\(r\) +weights do not change, since the primes over \(r\) are principal +and \(r\equiv1\pmod D\). This proves the identity for +\(\Z/p^{m_i}\)-valued weights and then on their limits, with +no alteration of constants. + +The symbols \(D'_h,B_h,C_h\) will also denote these coefficient +functions of \(n\). The Hecke polynomial \(\mathcal A\) +acts on them by the weight-two coefficient rule +\((T_s a)(n)=a(sn)+s a(n/s)\), with the second term zero +unless \(s\mid n\). All its primes are away from \(NDr_i\). +The finite set of tested indices was chosen to contain the +indices needed to evaluate this polynomial at \(n=\ell\). + +We next project its holomorphic side. At level \(Nr^2\) use +\(f_j=r^jf(r^jz)\), \(0\le j\le2\), and write +\(\tau(\chi)=\sum_{x\bmod r}\chi(x)e(x/r)\). +The finite-character Fricke and unfolding identities are +\begin{equation}\label{single:old-pairings} + \frac{(I_\chi,f_2)_{Nr^2}}{(f,f)_{Nr^2}} + =\frac{C_0}{r+1}\frac{\tau(\chi)}{\tau(\bar\chi)} + L(f,\bar\chi,1)L(f\otimes\varepsilon,\bar\chi,1), + \qquad (I_\chi,f_1)_{Nr^2}=0. +\end{equation} +The exact constants arise from the kernel factor +\(\sqrt D/(2\pi)\), the Fricke factor \(r\), the Mellin integral +\(1/(4\pi)\), and the level index \(r(r+1)\). +At primes of \(N\), use the primitive degree-at-most-one +polynomial and \(\varepsilon(q)=1\); at primes of \(D\) the +twisted local factor is one; at \(r\) both twisted factors +are one. The total nebentypus is trivial. The conductor-\(r\) +new cuspidal block is therefore Steinberg, with \(U_r=\pm1\), +and its complementary raises have eigenvalue zero. The +conductor-\(r^2\) cuspidal block has \(U_r=0\). In a +ramified Eisenstein pair both characters are ramified at \(r\), +so its \(U_r\)-eigenvalue is also zero. +Thus \(U_r^h(U_r^2-1)\) kills these blocks for sufficiently +large \(h\). The remaining old blocks come from level \(N\); +the fixed operator \(\mathcal A\) kills all of them except +the \(f\)-block. + +Write \(a_h=a_f(r^h)\) and \(a=a_f(r)\). The normalized +Gram matrix of \(f_0,f_1,f_2\) has entries \(g_{|i-j|}\), where +\[ + g_0=1,\qquad g_1=\frac a{r+1},\qquad rg_2=ag_1-1. +\] +The coefficient vector at index \(nr^h\), after removing its +\(n\)-factor, is \((a_h,ra_{h-1},r^2a_{h-2})\). The +coefficient of the Gram row for \(f_2\) is +\[ + s_h=\frac{r^2a_{h-2}-g_1ra_{h-1}}{1-g_1^2}. +\] +Its denominators have bounded \(p\)-valuation because +\(a_*\ne\pm2\). Set +\(\gamma_h=\lim_i(a_f(r_i^h)-a_f(r_i^{h-2}))\). The +Hecke recurrence gives +\[ + \lim_i\frac{s_h}{r_i+1} + =\frac{\gamma_h}{(a_*-2)(a_*+2)}. +\] + +All factors in \eqref{single:old-pairings} have bounded group +polynomial realizations. The Gauss ratio is +\(\tau(\chi)^2/r\); its coefficients are integral and fixed +by \(p\)-Frobenius because \(\lambda_i(p)=0\), and its +limiting augmentation is one. The first \(L\)-value factor +is \(Z_i/d_0\). For the companion, use the even additive +modular-symbol sum multiplied by \(\tau(\bar\chi)/r\). +Its denominators are bounded by the fixed relative period +lattices. Before Gauss multiplication its augmentation is +\[ + r\sum_{r\mid j}\frac{a_{f\otimes\varepsilon}(j)}j + -L(f\otimes\varepsilon,1) + =(a_f(r)-2)L(f\otimes\varepsilon,1), +\] +by the Hecke recurrence and Mellin continuation. The trivial +Gauss sum is \(-1\), so its limiting normalized augmentation +is \((2-a_*)L(f\otimes\varepsilon,1)/\Omega_{\rm tw}\). +Multiply the finite-character identity by \((1+u)^2-1\) to +remove the excluded character values, pass to bounded-series +limits, and cancel the nonzero multiplier. Since \(Z_i(0)=0\), +only that companion augmentation contributes to the derivative. +We obtain +\begin{equation}\label{single:projected-derivative} + \begin{split} + [\mathcal A(D'_{h+2}-D'_h)](\ell) + ={}&\pm\mathcal A_fa_f(\ell) + \frac{\gamma_{h+2}-\gamma_h}{(a_*-2)(a_*+2)}\\ + &\hspace{4mm}\cdot C_0\Omega_0\frac{Z'}{d_0} + (2-a_*)L(f\otimes\varepsilon,1). + \end{split} +\end{equation} +This interpolation uses bounded denominators, not a +coefficient-prime restriction; in particular it applies when +\(p=3\). + +For the geometric side, the coefficient-prime-independent +intersection identity cited above applies at +\(q\nmid6NDnr^h\). Its local divisor sum, with weight +\(-2v_q(k)\) and the original factor \(1/2\), is zero unless +\(q\) is inert, \(d_q=v_q(b)\) is odd, and +\(\varepsilon_{K_b,s}(-bNa_C)=1\) for all \(s\mid D\), where +\(\varepsilon_{K_b,s}\) is the local quadratic norm character +of \(K_b/\Q\) at \(s\), distinguished from the residue symbols +\(\epsilon_q\) above. +When these conditions hold it equals +\[ + -\frac{1+d_q}{2}\rho(b/q) + 2^{\#\{s\mid D:s\mid b\}}. +\] +Its negative is the intersection of the oriented ordered +Hilbert-class sums, based respectively at \(\infty\) and +\(0\), with the second acted on by \(T_{nr^h}\), weighted by +residue degree over \(q\). The generic supports are disjoint +by the odd inert \(\ell\)-valuation. The remaining fixed +primes have character zero. This yields all the required +height contributions except those at \(r_i\). + +The difference \(C_h=B_h-B_{h-2}\) keeps cyclic paths in the +second Hecke divisor; its second difference eliminates the two +continuing maximal-order paths. Every other orbit is a trace +from an extension containing a positive-\(r\)-conductor ring +class field. After pulling up the first divisor, intersections +at \(r\) are zero. Indeed ordinary CM reduction gives linear +or conjugate-semilinear maps over the unramified quadratic +\(\ell\)-adic algebra, whose norm degrees have even +\(\ell\)-valuation; they cannot produce the prescribed odd +index. Cusps remain disjoint. The missing contributions may +therefore be added as zeros. Lemma~\ref{single:height-direction} +now identifies the resulting intersections with full trace +heights: the normed characters are unramified over exactly the +extensions just obtained. + +Applying \(\mathcal A\) at \(\ell\) inserts the projector +\(\phi^*\phi_*/\delta_\phi\), with scalar +\(\mathcal A_fa_f(\ell)\). The Hecke second difference acts +on the second point with eigenvalue \(\gamma_h\). Thus the +geometric side of \eqref{single:mask}, after the additional +\(h\mapsto h+2\) difference, is +\[ + \pm\mathcal A_fa_f(\ell)(a_*-2)(\gamma_{h+2}-\gamma_h) + \frac{h_\lambda^{K_b}(Q_X,Q_X)}{\delta_\phi}. +\] +All projector denominators and the fixed first-argument +multiplier \(p^b\) cancel in these rational identities. +Cusp torsion has zero rational height. On the holomorphic +side, the coefficients \(1,2,1\) in \eqref{single:mask} +insert \(a_*+2\) into \eqref{single:projected-derivative}. +Cancel \(\mathcal A_fa_f(\ell)\) and +\(\gamma_{h+2}-\gamma_h\). The latter is nonzero for some +sufficiently large \(h\), since the limiting eigenvalues are +distinct and not roots of unity. The remaining scalar +\((a_*+2)(2-a_*)/((a_*-2)(a_*+2))=-1\) gives +\eqref{eq:source-7}. +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{single:logarithm}] +The companion has analytic rank zero. Hence +\(E(K_b)\otimes\Q=E(\Q)\otimes\Q\), and we may write +\(Q_X=t_PP\) modulo torsion, with \(t_P\in\Q\). The exact +split Gross--Zagier formula of Theorem~\ref{classical:gross-zagier}, for +this single Hilbert-class trace, is +\begin{equation}\label{single:gross-zagier} + C_0L'(f,1)L(f\otimes\varepsilon,1) + =\frac{2t_P^2H(P)}{\delta_\phi}. +\end{equation} +In particular \(t_P\ne0\). Trace compatibility gives +\(h_\lambda^{K_b}(Q_X,Q_X)=2t_P^2h_\lambda^\Q(P,P)\). +The same factor two occurs in \eqref{single:gross-zagier}. +Substituting both identities into \eqref{eq:source-7} gives +\[ + Z'=\pm d_0(2-a_*)\frac{L'(f,1)}{\Omega_0H(P)} + h_\lambda^\Q(P,P). +\] +Compare with \eqref{eq:source-6}. The factors +\(2-a_*\), \(h_\lambda^\Q(P,P)\), and \(\log_\omega P\) +are nonzero. Their cancellation proves +\eqref{eq:source-5}, with no unit ambiguity other than the +common orientation sign. +\end{proof} + +\subsection{The central integral calculation} + +\begin{proposition}[Central coordinate]\label{single:center} +The element \(U\) of Proposition~\ref{single:integral} satisfies +\begin{equation} + X(E)=v_p(U(0))\ge0. + \tag{8}\label{eq:source-8} +\end{equation} +This holds at every odd coefficient prime, for all reduction +types and all residual representations of the non-CM curve. +\end{proposition} + +\begin{proof} +Compute first at an actual stage with trivial characters and +support \(S'=S\cup\{r_1,\ldots,r_k\}\). Put +\[ + O^j=H^j(G_{\Q,S'},T),\quad + s_0=v_p(\#\Sha(E/\Q)),\quad + \tau_g=v_p(\#E(\Q)_{\rm tors}),\quad + \tau_v=v_p(\#E(\Q_v)[p^\infty]). +\] +Let \(p^l\Z_p=\log_\omega E(\Q_p)\). The singular quotient +\(J_p\) of local degree-one cohomology by compact Kummer is a +free line, perfectly dual to compact Kummer modulo torsion. +At non-\(p\) places Kummer fills compact degree one. Integral +Poitou--Tate therefore gives +\begin{equation}\label{single:pt} + \begin{split} + O^1\longrightarrow J_p\longrightarrow\Sel_{p^\infty}(E/\Q)^\vee + \longrightarrow O^2\longrightarrow + \bigoplus_{v\in S'_f}H^2(\Q_v,T) + \longrightarrow E(\Q)[p^\infty]^\vee\longrightarrow0. + \end{split} +\end{equation} +Real Tate terms vanish because \(p\) is odd. The local +degree-two groups have lengths \(\tau_v\). Also \(O^0=0\), +\(\rank O^1=1\), and \(\length O^1_{\rm tors}=\tau_g\). + +In rank zero, put +\(j=\length(J_p/\im O^1)\). Equation~\eqref{single:pt} gives +\[ + \length O^2=s_0-j+\sum_{v\in S'_f}\tau_v-\tau_g. +\] +If \(z_i^\circ\) is the central stage class and +\(\exp^*z_i^\circ=\alpha_i\omega\), logarithm--exponential +duality gives its valuation in \(J_p\) as \(v_p(\alpha_i)+l\). +Its valuation in \(O^1/O^1_{\rm tors}\) is therefore +\(v_p(\alpha_i)+l-j\). Adding degree-one torsion and +subtracting degree-two torsion gives raw determinant order +\begin{equation}\label{single:raw-zero} + v_p(\alpha_i)+l+2\tau_g-s_0-\sum_{v\in S'_f}\tau_v. +\end{equation} + +In rank one, let \(P\) generate the full free Mordell--Weil +group modulo torsion. The map from \(J_p\) to the dual of +the divisible global point subgroup is injective, with +cokernel of length \(v_p(\log_\omega P)-l\). Consequently +\[ + \length O^2=s_0+v_p(\log_\omega P)-l + +\sum_{v\in S'_f}\tau_v-\tau_g. +\] +Finite \(\Sha\) identifies \(O^1\) with compact global points. +The free coordinate of the class has valuation +\(v_p(\log_\omega z_i^\circ)-v_p(\log_\omega P)\). +The same signed torsion sum therefore gives +\begin{equation}\label{single:raw-one} + v_p\left(\frac{\log_\omega z_i^\circ} + {(\log_\omega P)^2}\right) + +l+2\tau_g-s_0-\sum_{v\in S'_f}\tau_v. +\end{equation} +The logarithm is nonzero by \eqref{eq:source-5}. When restoring +the moving omissions, the good norms multiply the fixed class +by \(\prod_r(1-a_f(r)/r+1/r)\), with exactly these factors. + +Lemma~\ref{models:haar} gives the local Haar identities for +the minimal differential: +\[ + \tau_q=v_p(c_qP_q(1))\quad(q\ne p),\qquad + \tau_p-l=v_p(c_pP_p(1)). +\] +They include all reduction types: the nonsingular reduction +measure is its point count divided by the residue cardinality, +and the formal logarithm accounts for the finite torsion kernel +at \(p\). Substitute \eqref{eq:source-2} into +\eqref{single:raw-zero}, or \eqref{eq:source-5} into +\eqref{single:raw-one}. Every omitted Euler factor cancels +against its Haar factor. The result in either case is +\[ + X(E)+v_p(\Delta(0)). +\] +In rank one the use of a generator of the full free group makes +\(H(P)=\Reg_E\). The ratio \(\Omega_E/\Omega_0\) is a +power of two and has zero \(p\)-valuation. Thus neither a +Mordell--Weil index nor a real-component factor remains. + +Finally pass from the stage calculation to the central value +of the limit. The moving local torsion lengths are bounded, +because their Frobenius traces tend to values different from +two. The displayed cohomology formulas bound the remaining +torsion lengths. Hence determinant pivots of the same ranks +survive the limit by Remark~\ref{models:central-pivots}. +The raw valuation is unchanged. +Each \(D_q/P_q\) has central value one; division by +\(\Delta(0)\) leaves \(v_p(U(0))=X(E)\). +Proposition~\ref{single:integral} now gives the inequality. +\end{proof} diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/06-pair.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/06-pair.tex new file mode 100644 index 0000000000000000000000000000000000000000..663df233ba88f40758d53dc39216ae3d84446a40 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/06-pair.tex @@ -0,0 +1,1089 @@ +\section{The analytic series and the pair comparison}\label{sec:pair} + +Fix an odd prime \(p\). We retain the imaginary quadratic field \(K\), +the auxiliary field \(L\), and the tuple of tame directions constructed +in Sections~\ref{sec:classical} and~\ref{sec:vertical}. Thus \(p=w\bar w\) +in \(K\), every rational prime below the fixed finite support for +\(E/K\) splits in \(K\), and +\[ + R=\Z_p[[t,u_1,\ldots,u_d]] +\] +has one genuine anticyclotomic variable \(t\). Its group is the maximal +free pro-\(p\) quotient \(\Gamma\simeq\Z_p\) of the ring-class tower at +\(p\). The variables \(\mathbf u=(u_1,\ldots,u_d)\) arise from the +moving tame conductors. Write \(L_w\in R\) for the determinant of the +strict-at-\(w\), full-at-\(\bar w\) complex, with full conditions at the +non-\(p\) places of the support. It is defined up to an integral unit. +The tuple satisfies +\[ + L_w\not\equiv0\pmod{(p,t)} +\] +for either choice of \(w\), and likewise for the companion curve, by +\eqref{eq:source-1}. + +Our aim here is to construct a bounded analytic series \(B_w\), with its +exact central value, and to prove that \(B_w/L_w\) is integral and has +no factor \(p\). We will also compare the two choices of \(p\)-adic +place at finite characters. These statements retain possible +horizontal divisors of the quotient; their removal is the task of +Section~\ref{sec:unit}. + +Choose a modular parametrization \(\phi:X_0(N)\longrightarrow E\), +based at the cusp \(\infty\), and write +\[ + \phi^*\omega_E=c_E f\,dq_{\rm Tate}/q_{\rm Tate}. +\] +The Manin factor \(c_E\) will remain in every exact formula. Let +\(S^\circ\) be the fixed set of rational primes away from \(p\) in the +\(E/K\) comparison. These primes split in \(K\). Enlarging the fixed +support for the companion is allowed; it does not change the meaning +of \(S^\circ\) for \(E\). + +The arguments below include CM curves. The characteristic-zero +representations \(V|_{G_K}\) and the analogous representation for the +companion are absolutely simple. For a non-CM curve this follows from +the open image theorem \cite{Serre}. For a CM curve, \(K\) and \(L\) +were chosen to avoid the CM field. The two inducing characters remain +distinct on the compositum, as is seen from their CM types, or from +the distinct weights of their \(p\)-adic avatars. Restriction therefore +preserves absolute simplicity in this case also. + +\subsection{Integral primitives on the ordinary locus} + +For every rational prime \(q\), put +\[ + P_q(Z)=1-\frac{a_q}{q}Z+\frac{\epsilon_q}{q}Z^2,\qquad + \epsilon_q= + \begin{cases} + 1,&q\nmid N,\\ + 0,&q\mid N. + \end{cases} +\] +At a split prime away from \(p\), choose an oriented cyclic level, +raised as necessary to define the quotient operator \(V_q\). +Normalize \(V_q\) by the substitution \(q_{\rm Tate}\mapsto +q_{\rm Tate}^q\). At \(p\) use only the canonical multiplicative +cyclic level. On a CM disk at \(w\), let +\[ + G(X)=c_E^{-1}\log_{\omega_E}\phi(X). +\] +Let \(d_{\rm mod}\) be ordinary modular differentiation: on Tate +charts it is \(q_{\rm Tate}\partial_{q_{\rm Tate}}\), and on the +Igusa tower it is dual to the Kodaira--Spencer differential in the +square of the trivialized invariant differential. +The following construction adapts the ordinary-locus arguments of +\cite[Section~8, \emph{Integral depleted primitive}, +\emph{Support of the disk measure}, and +\emph{The exact logarithmic primitive}]{B}. +We give the argument at odd \(p\), including the case \(p\mid N\). +Here \emph{ordinary} refers to the elliptic curves parametrized by +the modular source. It imposes no ordinary-reduction hypothesis +on the target \(E\): the depletion and inverse-derivative limit +use the coefficients \(a_n\), without choosing a unit root. + +\begin{proposition}[Integral logarithmic primitive]\label{pair:primitive} +On the canonical ordinary locus define +\[ + f^{[p]}=(1-a_pV_p+p\epsilon_pV_p^2)f,\qquad + F_0=\lim_{j\to\infty}d_{\rm mod}^{(p-1)p^j-1}f^{[p]},\qquad + F=\prod_{q\in S^\circ}P_q(V_q)F_0. +\] +The limits are integral weight-zero functions. They satisfy +\[ + d_{\rm mod}F_0=f^{[p]},\qquad + F=\sum_{\substack{n\ge1\\(n,p\prod_{q\in S^\circ}q)=1}} + \frac{a_n}{n}q_{\rm Tate}^n +\] +at a Tate cusp with all cyclic groups of multiplicative type. +If \(z\) is a Serre--Tate coordinate with \(z=1\) at the canonical +lift, the expansion \(F(z)\) is the transform of a bounded integral +measure \(\mu\) on \(\Z_p\), supported on \(\Z_p^\times\). +On every interior CM disk one has the exact identity +\begin{equation} + F_0=P_p(V_p)G. + \tag{9}\label{eq:source-9} +\end{equation} +\end{proposition} + +\begin{proof} +Work first on a fine full prime-to-\(p\) level over +\(\mathcal V=W(\overline{\F}_p)\). The ordinary elliptic moduli and +Serre--Tate theory \cite{DeligneRapoport,KatzMazur} provide the +canonical connected subgroup and the +Igusa tower trivializing the multiplicative formal group. The dual of +the Kodaira--Spencer differential, expressed using the square of the +trivialized invariant differential, defines \(d_{\rm mod}\); on Tate +charts it is \(q_{\rm Tate}\partial_{q_{\rm Tate}}\). +For quotient maps we use the target differential whose pullback has +the corresponding degree factor. These are precisely the +ordinary-moduli conventions used in the cited lemmas. + +The initial algebraic pullbacks have bounded denominators on the +quasi-compact ordinary formal region, including its Tate charts. +Integrality can then be tested by successive division by the +uniformizer and expansion at cusps. The special-fiber determinant +components of the fine tame curve are irreducible, and every +component of a finite trivialization level surjects onto its ordinary +component. Thus expansions at all trivialization lifts of a +multiplicative cusp detect zero reduction on every component. +Modulo any fixed precision, a section on the completed tower uses a +finite level, so the same test applies there. + +The \(p\)-depletion has no terms whose index is divisible by \(p\). +For \(n\in\Z_p^\times\), the numbers +\(n^{(p-1)p^j-1}\) tend uniformly to \(n^{-1}\). +The weights \(2(p-1)p^j\) tend to zero on +\(\Z_p^\times\). Consequently the differentiated expansions converge +integrally on every trivialization. The expansion test just proved +gives convergence on the tower. The limit is invariant under the +full \(\Z_p^\times\)-action on differential trivializations, so +torsor descent gives \(F_0\) on the ordinary formal curve at the +fixed fine tame level. Its reduction modulo \(p\) is consequently +a regular function on that curve's ordinary special fiber. +The Hecke recursions give the displayed +fully depleted expansion of \(F\). This construction uses the +canonical multiplicative \(p\)-structure, so it also applies when +\(p\mid N\). + +Mahler duality identifies the integral expansion in \(z-1\) with a +bounded measure. The trace of \(F\) along the canonical quotient is +zero: on the parameter it is the finite flat map \(z\mapsto z^p\), +reducing to Frobenius, and at a Tate cusp the trace kills every +prime-to-\(p\) exponent. Expansion detection therefore gives +\[ + \sum_{\zeta^p=1}F(\zeta z)=0. +\] +In the measure transform this sum multiplies the restriction to +\(p\Z_p\) by \(p\) and kills its complement. Uniqueness of transforms +and torsion-freeness show that this restriction is zero. + +It remains to identify the constant in the antiderivative. +The map to \(E\) extends by the Neron mapping property on the smooth +ordinary charts carrying the canonical \(p\)-subgroup. Such a chart +has the same deformation germ as its tame chart: a subgroup lifting +the connected special subgroup has zero image in the etale quotient +and must be the canonical multiplicative subgroup. In a Neron +residue tube the formal group logarithm, translated by the value at +the center, is analytic. Multiplication into a smaller formal +neighborhood and division by that integer gives the same analytic +logarithm throughout the interior disk. This proves analyticity of +\(G\), including when the elliptic target has bad reduction. + +The differentials of \(F_0\) and \(P_p(V_p)G\) agree. Indeed +differentiating \(V_pG\) introduces a factor \(p\), and +differentiating \(V_p^2G\) introduces \(p^2\). Their difference is +therefore constant on the disk. The noncanonical quotient sources +of a target \(B\) give, by the \(T_p\) or \(U_p\) correspondence, +\[ + \sum_{\zeta^p=1}G(\zeta z) + =a_pG(B)-\epsilon_pG(V_pB). +\] +Cuspidal differences are torsion \cite{Manin,ManinDrinfeld} and +disappear under the logarithm. +When \(p\mid N\), the noncanonical quotients retain the required +canonical level, so the same identity uses \(U_p\). +It follows that \(P_p(V_p)G\), like \(F_0\), has trace zero. +The \(p\) sources lie in the same residue disk. The trace of their +constant difference is consequently \(p\) times that difference, +which is zero in characteristic zero. This proves +\eqref{eq:source-9}. Equivalently the same normalization is the +elliptic weight-two case of \cite[Section~5, \emph{Raw toric periods +and the inverse Katz derivative}]{C}; the preceding argument specifies its +extension to a potentially bad target and to the canonical +\(p\)-structures used here. +\end{proof} + +\subsection{CM orbits and exact interpolation} + +At a finite stage let \(s\) be the product of the moving tame +conductors; the case \(s=1\) is included. The canonical centers have +endomorphism order \(\mathcal O_s\). At a primitive root +\(z=\zeta_{p^m}^{\,j}\), \(j\in(\Z/p^m)^\times\), endomorphism +lifting gives order \(\mathcal O_{p^ms}\). The point, with its cyclic +level, is defined over the ring-class field \(H_{p^ms}\): +the completed order units preserve the canonical \(p\)-level and +the oriented prime-to-\(p\) level. Here \(\mathcal O_K^\times=\{\pm1\}\). + +The kernel of the order-class map to conductor \(s\) acts simply +transitively on the primitive roots in each disk. In Serre--Tate +coordinates its action is the ratio of the connected and etale local +unit actions. The order-class exact sequence thus gives a map +\[ + \eta_\Gamma:\Z_p^\times\longrightarrow\Gamma +\] +independent of \(s\), with kernel \(\mu_{p-1}\) and open image. +We use the actual Artin labels for this map. Inverting all reciprocity +conventions simultaneously makes no change to the assertions below. +These coordinate facts are the odd-\(p\) version of +\cite[Section~8, \emph{CM disk coordinates}]{B}: +the endomorphism-lifting condition is equality of the two local +actions modulo \(p^m\), and the corresponding class kernel is +\((\Z/p^m)^\times\). + +Choose compatible ideals \(\mathfrak a\), prime to conductors and +levels, representing \(\Pic(\mathcal O_s)\). Let +\(t_{\mathfrak a}\in\Gamma\) be their compatible Artin values and +\(\delta_{\mathfrak a}\in\Z_p^\times\) the exponents that transport +the Serre--Tate frames from the base disk. Let +\(\psi_s\) be the tuple character in the finite tame group rings. +For \(y\in\Gamma\) write \([y]\) for its group-like power of \(1+t\). +If \(\mu_{\mathfrak a}\) is the measure in +Proposition~\ref{pair:primitive} on the disk indexed by \(\mathfrak a\), +define +\[ + b_s(t,\mathbf u)= + \sum_{\mathfrak a\in\Pic(\mathcal O_s)} + [\,t_{\mathfrak a}-\eta_\Gamma(\delta_{\mathfrak a})\,]\, + \psi_s(\mathfrak a) + \int_{\Z_p^\times}[-\eta_\Gamma(x)]\,d\mu_{\mathfrak a}(x). +\] +This is a bounded integral series with finite group-ring tame +coefficients. Form it with two opposite non-\(p\) orientations, +using the same canonical \(p\)-level and underlying disks. +Passing to the bounded coefficient limits of Section~\ref{sec:models} +gives \(b_w^+\), \(b_w^-\), and +\(B_w=b_w^+b_w^-\). The coefficient ring is initially +\(\mathcal V^*[[t,\mathbf u]]\), where +\(\mathcal V^*=W(\overline{\F}_p^{\,*})\) is the unramified +coefficient enlargement defined there. + +\begin{proposition}[Finite characters and the center]\label{pair:interpolation} +Let \(\theta\) be a sufficiently high finite character of \(\Gamma\), +and let \(\theta_l=\theta\circ\eta_\Gamma\) have primitive conductor \(p^m\). +Put \(\chi=\theta\psi_s\), and let \(X\) be the point with parameter +\(\zeta_{p^m}\) in the base disk at the original primitive level. +Then +\begin{equation} + \left(\sum_{j\bmod p^m}\theta_l(j)\zeta_{p^m}^{\,j}\right) + b_s(\theta,\mathbf u) + = + \left(\sum_{\rho\in\Gal(H_{p^ms}/K)} + \chi(\rho)G(X^\rho)\right) + \prod_{q\in S^\circ}P_q(\chi(\sigma_q)). + \tag{10}\label{eq:source-10} +\end{equation} +The character is extended by zero on nonunits in the Gauss sum, and +\(\sigma_q\) is inverse translation by the oriented \(V_q\)-action. +Let \(b_w^0\) denote the first limiting series formed with \(F_0\), +without the non-\(p\) depletions. Then, over the integral coefficient +enlargement, +\begin{equation} + \begin{split} + B_w&=\text{\rm unit}\cdot(b_w^0)^2D,\\ + D&=\prod_{q\in S^\circ} + P_q(\chi(\Frob_{v_q})) + P_q(\chi(\Frob_{v_q})^{-1}), + \end{split} + \tag{11}\label{eq:source-11} +\end{equation} +where in this identity \(\chi\) is the universal power-series +character and either place \(v_q\mid q\) may be chosen. +For conductor \(s=1\), the central value is +\begin{equation} + B_w^{s=1}(0)= + \pm c_E^{-2}\log_{\omega_E}(P_K)^2P_p(1)^2 + \prod_{q\in S^\circ}P_q(1)^2, + \tag{12}\label{eq:source-12} +\end{equation} +where \(P_K\) is the single Hilbert-class trace of the conductor-one +Heegner point under \(\phi\). +\end{proposition} + +\begin{proof} +Finite Fourier summation on \((\Z/p^m)^\times\) multiplies the inverse +moment of a measure by the displayed Gauss sum. Transporting the +frame in disk \(\mathfrak a\) changes the root exponent by +\(\delta_{\mathfrak a}\). The correction +\([t_{\mathfrak a}-\eta_\Gamma(\delta_{\mathfrak a})]\) therefore makes its +weight exactly the Artin character \(\chi\). +The class-kernel description identifies the resulting sum over roots +and disk centers with the sum over \(\Gal(H_{p^ms}/K)\). + +Apply \eqref{eq:source-9}. For sufficiently large \(m\), the \(V_p\) +and \(V_p^2\) terms factor through lower-conductor orbits, so their +sums against the primitive character vanish. Each remaining +quotient \(V_q\) translates the orbit by \(\sigma_q\), with its level +choices retained. This proves \eqref{eq:source-10}, with no averaging +factor. + +Atkin--Lehner at the non-\(p\) part of the primitive level reverses +the non-\(p\) orientations. On the newform quotient it acts by a +sign; the change of base cusp is torsion. The raw logarithmic sum +therefore changes only by that sign and a translation character. +The same assertion holds when a subset of the non-\(p\) orientations +is reversed. The translating ideals are prime to \(p\), so these +translations can be chosen compatibly in the \(p\)-tower. Applying +\eqref{eq:source-10} at all high characters, followed by uniqueness +for bounded series, gives \eqref{eq:source-11}. At the moving stages +the group-like translations likewise have coefficientwise limits. + +At the trivial character, integration is evaluation at the disk +center. Formula \eqref{eq:source-9} now retains the \(p\)-Euler +factor, because \(V_p\) acts by translation on the conductor-one +centers. The sum is taken once over the class group. The two +orientation sums are translates of the same Hilbert trace up to +sign. Recalling \(G=c_E^{-1}\log_{\omega_E}\phi\) gives +\eqref{eq:source-12}. +\end{proof} + +\begin{lemma}[Removal of tame conductor variables]\label{pair:trace} +Choose each new base disk by a descending isogeny from the preceding +conductor. Setting a new tame variable equal to zero multiplies +each single analytic series by +\begin{equation} + a_r-\chi_{\rm old}(\Frob_{v_r}) + -\chi_{\rm old}(\Frob_{v_r})^{-1}. + \tag{13}\label{eq:source-13} +\end{equation} +The notation denotes the limit of the stage coefficients and +character values. The determinant \(L_w\) is multiplied by the +square of this factor up to an integral unit. These assertions hold +successively for any subset of the new variables, including removal +of all tame variables. +\end{lemma} + +\begin{proof} +The good Hecke correspondence at \(r\), after subtracting its two +horizontal split translations, is the trace from conductor \(rs\) +to conductor \(s\). Its action on the character sum in +\eqref{eq:source-10} is \eqref{eq:source-13}. +Transport the frames by polarization. Their exponents are +\(r_i^{\pm1}\), which tend to \(1\) modulo every fixed \(p^m\). +Thus the same identity holds at each fixed sufficiently high +\(\theta\), simultaneously in the group rings of the tame variables +that remain. The expressions defining \(b_s\) are bounded as group +polynomials. We can consequently pass to limits in those group +rings; bounded character projectors are not required. + +For the arithmetic determinant, unramified inflation restores the +full pair over each removed prime. The two singular determinants +are the unramified Tate Euler polynomials at that pair. +Since \(r_i\to1\), their product is the square of +\eqref{eq:source-13} up to an integral unit. This is an identity of +the marked integral determinant triangles, not a comparison after +rationalization. Iterating with the old tuple fixed proves all the +stated specializations. The factor need not be a unit at the +central specialization. +\end{proof} + +\begin{lemma}[Descent of the analytic ideals]\label{pair:descent} +The principal ideals generated by \(b_w^+\), \(b_w^-\), \(b_w^0\), +and \(B_w\) descend to \(R\). Each actual series differs from a +generator over \(R\) by an integral unit. +\end{lemma} + +\begin{proof} +Extend arithmetic unramified Frobenius \(\varphi\) at \(w\) to fix +the cyclotomic \(p\)-power roots. At every finite stage, +\eqref{eq:source-10} identifies its action on a raw CM sum with +translation by a fixed local Artin element: the ring-class extension +is abelian over \(K\), so this action commutes with all labels. +The Gauss coordinates are fixed. Passing to limits and testing at +high finite characters gives, for each series in question, +\[ + \varphi(b)=\kappa b, +\] +where \(\kappa\) is group-like of augmentation \(1\). +On \(\mathcal V^*\), \(\varphi\) is Witt Frobenius. +There is a unit \(e\), with constant coefficient \(1\), satisfying +\(\varphi(e)=\kappa e\). Solve recursively in total degree: at each +step the remaining equation is \(\varphi(a)-a=b_0\). +It is soluble modulo \(p\) because the residue field is algebraically +closed, and successive lifting solves it in \(\mathcal V^*\). +Then \(b/e\) has coefficients fixed by Witt Frobenius, hence in +\(\Z_p\). Products give the assertion for \(B_w\). +We continue to use the actual analytic series for value formulas +and the descended generators for height-one ideal comparisons. +\end{proof} + +\subsection{Primitivity of the analytic series} + +The preceding construction controls the period and Euler factors. +The next argument provides the separate vertical input: no fixed +power of \(p\) is lost in the analytic series. We prove the required +tame-stalk independence by ordinary deformation theory and monodromy. + +\begin{proposition}[Vertical analytic primitivity]\label{pair:vertical-primitivity} +For each of the tuples under consideration and either \(p\)-adic +place, +\begin{equation} + p\nmid B_w. + \tag{14}\label{eq:source-14} +\end{equation} +\end{proposition} + +\begin{proof} +We first establish the independence statement in the elliptic case. +Let \(k=\overline{\F}_p\), let \(x\) be an ordinary maximal-order +CM point with endomorphism ring \(\mathcal O_K\), and let \(\mathscr R\) +be its algebraic local ring on the prime-to-\(p\) modular tower. +Thus a finite set of elements of \(\mathscr R\) comes from a common +finite tame level; we do not replace \(\mathscr R\) by its completion. +For \(a_1,\ldots,a_h\in\Z_p^\times\), consider +\[ + \Phi:\mathscr R^{\otimes_k h}\longrightarrow k[[z-1]],\qquad + f_1\otimes\cdots\otimes f_h\longmapsto + \prod_{i=1}^h f_i(z^{a_i}). +\] +We will prove that \(\Phi\) is injective when the \(a_i\) have +pairwise inequivalent ratios under +\[ + \{\alpha/\bar\alpha: + \alpha\in K^\times,\ \alpha\text{ a unit at both primes over }p\}. +\] + +Suppose the prime kernel of \(\Phi\) is nonzero and choose \(h\) +minimal. Let \(X\) be its irreducible relation locus in the product +of the tame towers. Its projections to every proper product of +factors are dominant by minimality. The common CM stabilizer +preserves the kernel: its scalar Serre--Tate substitutions commute +with all the \(a_i\). Weak approximation in \(K\) makes the ratios +of its two local unit actions dense in \(\Z_p^\times\). The local +rigidity and normalization argument +of \cite[Proposition~3.11 and Corollary~3.13]{HidaMu} therefore gives +a finite tame-level model and a normalized branch over +\((x,\ldots,x)\) whose completion is a formal subtorus. This branch +contains \((z^{a_1},\ldots,z^{a_h})\). Write \(Y\) for the +normalization of the irreducible model. Dominance onto \(h-1\) +factors and properness give \(\dim Y=h-1\). + +Here is the global constraint on that formal subtorus. Pull back the +product of the universal elliptic schemes to \(Y\). The global +canonical-coordinate map of \cite[Sections~2 and~5]{ChaiOrd} has, +on a normal base, a cotorsion-free smooth kernel. Its annihilator +\(\mathscr N\) is a smooth cocharacter subsheaf. Its rank can be +evaluated on the chosen formal branch, where it is \(h-1\). +The proof of \cite[Proposition~5.3]{ChaiOrd}, applied to the +normalization and this branch, consequently gives a dense smooth +open \(U\subset Y\) on which the same rank is \(h-1\). +The elliptic-factor idempotents of the product abelian scheme place +\(\mathscr N\) inside the direct sum of its \(h\) diagonal +Serre--Tate cocharacter lines. Each coordinate projection of +\(\mathscr N\) is nonzero. Otherwise that elliptic deformation +would be formally constant on \(U\), contrary to the dominance of +the corresponding projection of \(X\). This construction uses the +canonical-coordinate relation sheaf on a normal base; the ranks of +two-coordinate projections alone do not determine its rank. + +Descend \(Y\), \(U\), the elliptic schemes, and their +canonical-coordinate sheaves to a finite field. Suppose first that +the \(h\) generic elliptic factors are pairwise +nonisogenous over an algebraic closure. Choose an odd prime +\(\ell\ne p\). After a finite etale cover of a smaller open +\(U\), all generic endomorphisms are defined and the joint +arithmetic algebraic \(\ell\)-adic monodromy group is connected. +The semisimplicity and isogeny theorems apply to its finitely +generated function field \cite[Theorems~1.2 and~1.4]{Zarhin}. +Each nonconstant elliptic factor +has derived monodromy \(\mathrm{SL}_2\). The Lie algebra of the +derived group is a subdirect product of these simple nonabelian +Lie algebras. The Lie-algebra Goursat argument decomposes it into +diagonal blocks: the kernel of a projection is an ideal, and a +simple factor is either independent or identified with one of the +preceding simple factors. A block meeting two factors identifies +their standard two-dimensional representations on the derived +group. The connected center acts on these representations by +scalar characters whose squares agree, because their determinants +are equal. The two characters therefore agree. The intertwiner +is equivariant for the whole connected group, and the isogeny +theorem over finitely generated fields of characteristic \(p\) +makes the two generic elliptic curves isogenous. Thus no such block +is possible, and the derived monodromy group is +\(\mathrm{SL}_2^h\). Passing to the connected group has also +removed possible finite quadratic-twist correlations. These are +the endomorphism and monodromy inputs used in +\cite[proof of Corollary~3.16]{HidaMu}. + +Chebotarev gives a closed point \(u\in U\) at which the elliptic +Frobenius traces +\(c_1,\ldots,c_h\) have pairwise distinct squares: the equations +\(c_i^2=c_j^2\) define proper closed subsets of the monodromy +group, whose \(h\) derived factors vary independently. +Let \(\alpha_i\) be the \(p\)-adic unit root at \(u\), and put +\(q_u=\#k(u)\). If \(\alpha_i^2=\alpha_j^2\), then +\[ + c_i=\alpha_i+q_u/\alpha_i + =\pm(\alpha_j+q_u/\alpha_j)=\pm c_j, +\] +a contradiction. Arithmetic Galois descent Frobenius acts on the +\(i\)-th Serre--Tate character line by \(\alpha_i^2\), since that +line is the tensor square of the etale Tate line; it acts on the +cocharacter line by \(\alpha_i^{-2}\). These are distinct +eigenvalues. The stable subspace \(\mathscr N_u\otimes\Q_p\) +must therefore be a sum of coordinate axes: each eigenprojection +is a polynomial in Frobenius. Its nonzero projection to every +coordinate forces it to contain every axis, contradicting its +rank \(h-1\). + +There is consequently a generically isogenous pair. Extend its +isogeny over a normal finite cover of \(Y\); homomorphisms between +abelian schemes extend over a normal base. At a point above the +chosen CM branch its specialization is a nonzero +\(\alpha\in\operatorname{End}^0(x)=K\). Serre--Tate functoriality +and the formal curve in that branch give +\(a_i/a_j=\alpha/\bar\alpha\), up to simultaneous inversion. +One may see this before inverting \(p\) by clearing denominators +in the two local actions of \(\alpha\) and comparing exponents in +\(k[[z-1]]\); the map \(b\mapsto z^b\) from \(\Z_p\) is +injective. Since \(a_i/a_j\) is a unit, the two valuations of +\(\alpha\) above \(p\) agree. Rational scaling makes both zero +without changing their ratio. This contradicts the stipulated +inequivalence and proves injectivity of \(\Phi\). In particular, +a sum of functions from distinct slots is constant only if every +slot function is constant. + +We now work at \(s=1\), with one of the two non-\(p\) orientations. +The functions here are regular weight-zero ordinary functions at a +maximal-order CM point. The weight-zero torsor descent in +Proposition~\ref{pair:primitive} places their reductions on the tame +ordinary special fiber, not merely on a finite Igusa cover. +The canonical multiplicative \(p\)-structure has the same deformation +germ as this tame curve. Their germs therefore belong to the +algebraic prime-to-\(p\) stalks just considered. + +Suppose \(b_1\) is zero modulo \(p\). Restrict its measure to the +open subgroup \(\eta_\Gamma(\Z_p^\times)\) of \(\Gamma\). +For each contributing class choose +\(\lambda_{\mathfrak a}\in\Z_p^\times\) with +\(\eta_\Gamma(\lambda_{\mathfrak a})=t_{\mathfrak a}\). +Pushing the measure through \(\eta_\Gamma\) folds it over its kernel +\(\mu_{p-1}\). On transforms the assumed vanishing becomes +\[ + \sum_{\mathfrak a}\sum_{\zeta\in\mu_{p-1}} + F_{\mathfrak a} + \bigl(z^{\zeta\delta_{\mathfrak a}/\lambda_{\mathfrak a}}\bigr) + =0\pmod p. +\] +The class sum includes exactly those classes that contribute to +the indicated open subgroup. Pull back by the ideal isogenies that +transport the frames to a common prime-to-\(p\) level. This absorbs +\(\delta_{\mathfrak a}\) into the pulled-back function, so the +exponent whose slot is to be tested is +\(\zeta/\lambda_{\mathfrak a}\). Combine equivalent slots before +applying the injectivity of \(\Phi\). +An equivalence \(\alpha/\bar\alpha\) is realized by the germ of a CM +quasi-isogeny. Since this ratio is a \(p\)-unit, rational scaling +makes the isogeny prime to \(p\). + +We describe the slot equivalent to \(1\). Put \(h=h_K\) and +\(\mathfrak a^h=(x)\). The class-sequence description gives +\[ + \lambda_{\mathfrak a}^{\,h} + =(x/\bar x)\xi +\] +up to simultaneous inversion, where \(\xi\) is a torsion unit. +If \(\zeta/\lambda_{\mathfrak a}=\alpha/\bar\alpha\), raise to a +power killing \(\xi\) and \(\zeta\), and compare ideal valuations. +The group of fractional ideals is torsion-free; cancellation of +that power and of \(h\) shows that a principal scaling of +\(\mathfrak a\) is conjugation invariant. This is cancellation in +the fractional ideal group, not division by \(h\) in \(\Z_p\). +Such a class is represented by a product of ramified prime ideals, +each used once or omitted. + +Conversely, choose those ramified products as representatives. +Their squares are rational principal ideals, so their images +\(t_{\mathfrak a}\) in the torsion-free group \(\Gamma\) are zero; +we may take \(\lambda_{\mathfrak a}=1\). +Only \(\zeta=\pm1\) can belong to the slot of \(1\), since a torsion +element of \(K^\times\) is then a sign. +The ramified products represent these classes twice, paired by +complementary subsets. To check the multiplicity, if a ramified +product is \((\alpha)\), then \(\alpha/\bar\alpha=\pm1\). +The plus sign makes \(\alpha\) rational and forces the subset to be +empty; since the discriminant is odd and fundamental, the minus +sign makes it a rational multiple of +\(\sqrt{\operatorname{disc}(K)}\) and forces the subset to be full. +The scaling between complementary products has conjugate ratio +\(-1\). Thus the two expansions with exponents +\(\pm\delta_{\mathfrak a}\) are exactly the two pullbacks indexed +by the complementary ramified products. + +This combined function is nonconstant. Indeed pass to a common +tame level and choose a Tate cusp at which all these prime kernels +are multiplicative. They occur at distinct primes, disjoint from +the oriented split level, so the choices can be made simultaneously; +retain multiplicative type for those oriented cyclic groups too. +The identity translate has first positive Fourier coefficient +\(1\). Every other ramified product has degree greater than one, +and its quotient expansion begins at a larger index. No cancellation +of that coefficient is possible. +The injectivity of \(\Phi\) now contradicts the displayed zero sum. +Hence the conductor-one series is nonzero modulo \(p\) for each +orientation. + +Finally apply Lemma~\ref{pair:trace}. Each new factor +\eqref{eq:source-13} remains nonzero modulo \(p\): its true +\(\Gamma\)-exponent is nonzero by the tuple construction. +Its powers therefore vary nontrivially in \(\F_p[[t]]\), and the +displayed Laurent polynomial cannot vanish identically. +After setting the new variables to zero we obtain a product of +nonzero reductions. The full series consequently has nonzero +reduction, proving \eqref{eq:source-14}. +\end{proof} + +\subsection{Local comparison at high finite characters} + +Fix a sufficiently high finite character \(\theta\) of \(\Gamma\) +and put +\[ + A_\theta=\Z_p[\theta][[\mathbf u]][1/p]. +\] +First adjoin the unramified measure coefficients, obtaining +\[ + \widetilde A_\theta=\mathcal V^*[\theta][[\mathbf u]][1/p]. +\] +Let \(A_\theta'\) be a finite coefficient extension of this ring +containing the Gauss coordinates \(\mu_{p^m}\) and the normal +resolvents for the fixed ramified local character fields used below. +More precisely, take the complete valuation ring of their +compositum with \(\Frac(\mathcal V^*[\theta])\), form its power-series +ring in \(\mathbf u\), and invert \(p\). +This finite extension is faithfully flat and may depend on +\(\theta\). No bound on its ramification as \(\theta\) varies is +asserted or needed. +Since \(p\) is now inverted, these fixed nonzero constants, together +with the point-clearing factors, are units. They will be allowed +only in this characteristic-zero comparison. Divisibility of +series already in \(\widetilde A_\theta\) descends along this +faithfully flat extension, as does equality of their principal +ideals. Proposition~\ref{pair:vertical-primitivity} supplies the +separate integral information at \(p\). + +\begin{proposition}[Divisibility at high finite characters] +\label{pair:finite-divisibility} +For every sufficiently high finite \(\theta\), +\begin{equation} + B_w(\theta,\mathbf u)\in + L_w(\theta,\mathbf u)A_\theta'. + \tag{15}\label{eq:source-15} +\end{equation} +With the same global character variable, the two nonzero quotients +for \(w\) and \(\bar w\) are associates in \(A_\theta'\). +\end{proposition} + +To prove the proposition, we first identify the two \(p\)-local +Kummer lines and then express the quotient valuations through the +all-Kummer determinant. The final step will be a sequence of +horizontal switches that preserves these valuations. + +At a height-one prime of \(A_\theta\), the moving-place local +complexes are acyclic. Their inertia detects their own variable +\(u_j\). On the divisor \(u_j=0\), Frobenius-minus-one is still +generically invertible: its scalar contains the true exponent of +that moving prime, whose \(\theta\)-value has arbitrarily high +order. For large \(\theta\), even setting the other variables to +zero cannot give either of the two elliptic eigenvalue exceptions. +The cardinality twist tends to \(1\). + +At fixed \(q\in S^\circ\), replace the full condition by the +unramified condition after inverting \(p\). The conditions are +exactly orthogonal, by the local comparison in +Section~\ref{sec:models}. The product of the removed singular +determinants is \(D\) in \eqref{eq:source-11}, and is nonzero at +these tests. The same replacement is available on horizontal +height-one localizations of \(R\). Its strict determinant is +therefore \(L_w/D\), up to a unit. This calculation uses the inverse +determinant convention throughout. + +\begin{lemma}[The two local Kummer lines]\label{pair:local-lines} +At each \(p\)-adic place and after fixing \(\theta\) as above, +degree-one local cohomology splits over \(A_\theta\) into a free +Kummer line and its +free complementary line. The paired Kummer conditions at conjugate +places are exactly orthogonal. After extension to \(A_\theta'\), +the logarithm identifies the Kummer line with a free line, and its +value on the weighted CM point classes is +\eqref{eq:source-10}, with the factor \(c_E\) restored for +\(\log_{\omega_E}\). These assertions hold for bad reduction at +\(p\) as well. +\end{lemma} + +\begin{proof} +Let \(P_v/K_v\) be the finite totally ramified extension cut out by +the inertia part of \(\theta\), and separate its unramified part. +Write \(G_v=\Gal(P_v/K_v)\), +\(\mathcal O_\theta=\Z_p[\theta]\), and +\(\Delta=\Gal(D_\infty^{\rm loc}/K_v)\simeq\Z_p\), where +\(D_j^{\rm loc}/K_v\) is the unramified extension of degree \(p^j\). +Choose its arithmetic Frobenius generator \(\gamma_{\rm ur}\). +The Shapiro coefficient ring before finite-character projection is +\[ + \mathcal O_\theta[G_v][[\Delta]][1/p]. +\] +Project by the character idempotent corresponding to the chosen +cohomological character. The resulting scalar ring is +\(\Lambda_\theta=\mathcal O_\theta[[X]][1/p]\), with +\(1+X=\gamma_{\rm ur}\). +If \(e_{vj}\in\Z_p\) are the tame Frobenius exponents at \(v\), its +map to the comparison ring is +\[ + \Lambda_\theta\longrightarrow A_\theta,\qquad + 1+X\longmapsto + \alpha_v\prod_{j=1}^d(1+u_j)^{e_{vj}}, + \quad \alpha_v=\theta_{\rm ur}(\Frob_v). +\] +The exponent vector is nonzero. Divide it by its largest common +power \(p^a\), then complete the resulting primitive vector to a +\(\mathrm{GL}_d(\Z_p)\) coordinate change. In the new group-power +coordinates the image is \(\alpha_v(1+y_1)^{p^a}\). +The equation +\[ + (1+y_1)^{p^a}=\alpha_v^{-1}(1+X) +\] +is monic and distinguished of degree \(p^a\) in \(y_1\). +It makes the one-variable substitution finite flat; adjoining the +remaining variables preserves flatness. The marked local models +can therefore be base-changed through this map. + +We first control lattices uniformly in \(j\), with constants allowed +to depend on \(\theta\). A sufficiently small additive lattice +exponentiates because the ramification is fixed. For an upper bound +pass to a fixed extension with semistable reduction. The component +groups are bounded after adjoining \(P_v\) and making unramified +base changes. Choose \(\theta\) nontrivial on sufficiently deep +inertia over this fixed field. After multiplication by the bounded +component exponent, inertia acts trivially on the special points of +the identity component. The Neron base-change map is surjective +on these geometric semiabelian points: its map on rational +auxiliary-adic Tate modules identifies the inertia invariants, +which are unchanged under finite extension once inertia is +unipotent. Thus an inertia difference takes points into the formal +kernel. A further fixed multiple takes them into a small logarithm +lattice. On the projected eigenspace that difference is a nonzero +constant, giving the upper bound. Use the unnormalized integral +projection to obtain the same bounded-exponent assertion for the +torsion logarithm kernel. The argument applies to the inverse +character as well. Trace-dual bounds follow from the bounded +different of the fixed ramified extension. + +Integral Kummer and local duality on the Shapiro tower give an +exact sequence with ends the compact points and the dual of compact +points; transitions are norms and dual inclusions. Compactness +makes the inverse limit exact. One can identify both ends +explicitly from trace-compatible +integral normal generators in the unramified tower. Choose their +successive traces compatibly and their total trace equal to \(1\). +Modulo \(p\), a unit augmentation generates the cyclic group-algebra +module, so these are normal generators integrally as well. +For the fixed ramified factor use a rational normal basis and its +bounded trace dual. Before projection, the additive inverse limit +is the regular rank-one module over +\(\mathcal O_\theta[G_v][[\Delta]][1/p]\). Apply the +finite-character idempotent to this additive module. The projected +logarithm lattice bounds identify the projected compact point +module with it after inverting \(p\); the projected torsion kernel +is killed by the fixed bound already proved. Thus the compact +point endpoint is free of rank one over \(\Lambda_\theta\). +The bounded trace-dual comparison gives the same conclusion for its +dual endpoint. Applying the displayed flat substitution yields the +two free lines over \(A_\theta\). The torsion bounds kill higher cohomology; +invariants vanish too. The full local complex consequently splits. +Shapiro compatibility of the cup product, finite Kummer isotropy, +and local duality give exact orthogonality, including the +nullhomotopies in these split complexes. + +Form the logarithmic group polynomials with the unnormalized +character weights before making the substitution. The normal +resolvent on the ramified factor is nonzero; on the unramified +factors the compatible resolvent is a unit because its total trace +is \(1\). Thus logarithm is the stated line isomorphism. +To identify transferred point classes, specialize first to bounded +cyclic quotients. Freeness with coset bases identifies the +substitution with the corresponding finite unramified layer. +At sufficiently large stages the local ring-class fields contain +that layer, by the nonzero Frobenius exponent, and contain the +fixed ramified character field. Trace the stage classes to these +fixed local fields and apply the finite-level logarithmic +calculation. Membership in the Kummer line is detected on all +these finite quotients of its free complementary quotient. +The logarithmic expressions are detected in the same way. +The fixed-ramification bounds remain valid through the unramified +growth at \(p\), so passage to the bounded limits gives exactly +\eqref{eq:source-10}. +\end{proof} + +\subsection{Horizontal switches and divisibility} + +We now compare the order of the analytic series with the arithmetic +determinant at a height-one prime \(\mathfrak p\) of \(A_\theta\). +Write \(v_{\mathfrak p}\) for its normalized valuation. +Let \(Z\) be the Kummer class obtained by unnormalized weighted +corestriction of the CM points of conductor \(p^ms\). +One common fixed point multiple clears all descent requirements. +Use unramified conditions at the fixed non-\(p\) support, the two +Kummer lines at \(p\), and full conditions at moving primes. +Denote this complex by \(C_F\). At \(\mathfrak p\) it is self-dual +under conjugate transport and the Weil pairing; the moving full +complexes are acyclic. + +In a basis of the Kummer line at \(w\), let \(p_0\in A_\theta\) +be the localization of \(Z\). By +Lemma~\ref{pair:local-lines} and \eqref{eq:source-10}, +\[ + B_w(\theta,\mathbf u) + =\text{unit in }A_\theta'\cdot p_0^2D. +\] +The constants included here are \(c_E\), the Gauss sum, and the +common clearing factors; they are units only because \(p\) has +already been inverted. Both \(B_w(\theta,\mathbf u)\) and +\(L_w(\theta,\mathbf u)\) are nonzero for all sufficiently high +\(\theta\), by primitivity, \eqref{eq:source-1}, and bounded-series +preparation. Hence \(p_0\ne0\). The strict comparison shows that +the generic ranks of \(C_F\) are one in degrees one and two. +For its point and the calibrated class-functional dual, the +determinant triangle gives +\begin{equation} + d\bigl(C_F,(Z,Z^\vee)\bigr) + =2v_{\mathfrak p}(p_0) + -v_{\mathfrak p}(L_w/D). + \tag{16}\label{eq:source-16} +\end{equation} +This is the line comparison of +\cite[Section~3, equation (D)]{B}, with the integral +pairings and inverse determinant of Section~\ref{sec:models}. + +\begin{lemma}[Inert derivative coordinates]\label{pair:derivatives} +There are fresh inert good prime sequences \(\ell\), with +\(\ell\to-1\) and Tate Frobenius tending to +\(J=\rho_T(\tau)\) for complex conjugation \(\tau\), for which +the limiting local degree-one cohomology splits into finite and +transverse planes. Their mixed pairing is, up to a unit, +\(\langle x,Jy\rangle\), and both planes are self-annihilating. +For each fixed finite sequence of switches, there is a compatible +family of descended weighted Kummer classes \(Z_I\), indexed by +the subsets occurring in that sequence, with \(Z_\varnothing=Z\). +The class \(Z_I\) uses the product of the ring-class derivatives +\(D_\ell\) for \(\ell\in I\); its local conditions are transverse +at \(I\) and the original conditions at the other places. +These classes satisfy +\[ + f_{\rm loc}(Z_{I\cup\ell})=0,\qquad + s_{\rm loc}(Z_{I\cup\ell})=Jf_{\rm loc}(Z_I). +\] +All prior local conditions can be retained, with one common point +scaling for the classes in the fixed finite sequence. +\end{lemma} + +\begin{proof} +Choose the Frobenius sequence \(\gamma_i\to\tau\) on the full Tate +module. Then \(a_f(\ell)\to0\), while +\(\gamma_i^2\) acts trivially on the ring-class fields by the +dihedral relation. The old characters are unramified at \(\ell\). +In the cyclic inertia resolution the residue conjugating power +tends to \(1\). Thus the limiting full local cohomology is split +free. Evaluation on \(\gamma_i^2\) and on a tame generator gives +the finite and transverse coordinates. Retain invariants in the +lower condition and omit \(H^2\) in the upper condition, as required +by the square-switch lemma. Conjugate transport through +\(\gamma_i\), together with local reciprocity, gives mixed pairing +\(\langle x,Jy\rangle\). Pure scalar cups vanish and the mixed +scalar cup is a unit. These are exactly the Weil-plane hypotheses +of that lemma. + +Here is the derivative calculation, following +\cite[Section~9, \emph{Inert derivative identity}, equation (K)]{B}, with the +odd-\(p\) precision specified. The relative ring-class order at +an inert prime is \(\ell+1\), since the only order units are signs. +For its generator \(\sigma_\ell\) use +\[ + D_\ell=\sum_{j=1}^{\ell}j\sigma_\ell^j. +\] +Writing \(\operatorname{Tr}_\ell=\sum_{j=0}^{\ell}\sigma_\ell^j\), +the group-ring identity is +\[ + (\sigma_\ell-1)D_\ell=(\ell+1)-\operatorname{Tr}_\ell. +\] +If \(Y\) is the upper point and \(X\) the lower point, the Hecke +trace gives \(a_\ell X\), after the common cusp multiple, and +supersingular reduction gives +\(\widetilde Y=F_\ell\widetilde X\). +Choose growing precision \(p^a\) slowly enough that +\(p^a\mid \ell+1\), \(p^a\mid a_\ell\), and +\(\gamma_i^2=1\) modulo \(p^a\). +The group-ring derivative identity then makes the upper Kummer +class invariant to that precision. + +Inflation and restriction descend it after a fixed multiple. +The needed uniform bound on invariant torsion follows from +Bogomolov's homothety theorem \cite{Bogomolov}: take +\(h\in G_K\) scalar sufficiently close to \(1\), with square +different from \(1\). The element \(h\tau h\tau\) kills every +ring-class action and acts on the Tate module by that scalar +squared. It bounds torsion over all fields in use. At the old +\(p\)-places, descent is unramified and retains the Kummer +condition after a fixed component multiple. Lang's theorem handles +the connected special points; the formal-group assertion follows +from induced additive successive quotients and passage to the +limit. Component groups remain bounded under unramified base +change above the fixed ramified extensions. The same argument +retains unramified conditions at the old non-\(p\) support. Include +all these multiples in one scale for every switched class. + +To verify the coordinates, suppress that scale and choose +\(p^aQ=X\), \(p^aW=D_\ell Y\). If \(b\) is the descended upper +cocycle, the crossed identity makes +\((\sigma_\ell-1)W-b(\sigma_\ell)\) fixed by the upper-field +subgroup. Multiplication by \(p^a\) gives +\((\ell+1)Y-a_\ell X\), so it differs from +\[ + ((\ell+1)/p^a)Y-(a_\ell/p^a)X +\] +by bounded-exponent torsion. After reduction, inertia is trivial. +Thus, to the retained precision, \(b(\sigma_\ell)\) gives +\[ + (a_\ell-(\ell+1)F_\ell)\widetilde Q + =(F_\ell-a_\ell)(F_\ell^2-1)\widetilde Q, +\] +where the equality is Eichler--Shimura. The lower Kummer cocycle, +evaluated on the residue Frobenius \(\gamma_i^2\), has finite +coordinate +\[ + f_{\rm loc}(Z_I)=(F_\ell^2-1)\widetilde Q +\] +at the retained precision. The displayed value of +\(b(\sigma_\ell)\) is the transverse coordinate of the upper class. +Consequently it equals +\((F_\ell-a_\ell)f_{\rm loc}(Z_I)\). +Passing to the prescribed limit gives \(F_\ell-a_\ell\to J\), +which proves the asserted transverse identity. +For the upper finite coordinate, +\(\widetilde{D_\ell Y}\) has an \(F_\ell^2\)-fixed +\(p^a\)-division obtained using +\(\ell(\ell+1)/(2p^a)\) times \(F_\ell\widetilde X\); +the ambiguity is killed by \(F_\ell^2-1\). Reduction detects +prime-to-\(\ell\) torsion, proving the zero finite coordinate. +The calculation applies on each translate before weighted +corestriction, with any earlier derivative factors already present. +It therefore proves the two identities simultaneously at all +previous switches and with the identical common scale. +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{pair:finite-divisibility}] +We show that \eqref{eq:source-16} is nonnegative at every height-one +test. If fiber degree one has dimension greater than one, choose +two independent classes, one being a primitive reduction from the +generic line. They admit a rank-two evaluation on the finite +plane at a suitable inert prime. + +We spell out this detection because the same assertion must hold +after previous switches. Lemma~\ref{models:evaluations} +realizes the fiber classes on the product +of the stage Galois groups. Restriction to the joint kernel of +the full Tate and ring-class actions detects them: on the image +quotient the central element \(h\tau h\tau\) just used has scalar +difference from \(1\) invertible. Global invariants vanish. +The Selmer classes inject into unrestricted cohomology by the +local hypotheses, and the complexes have amplitude \(1,2\) by +duality. Let \(\kappa(\mathfrak p)\) be the testing residue field, +and write +\[ + W=(V\otimes\kappa(\mathfrak p))\chi,\qquad + W^c\simeq(V\otimes\kappa(\mathfrak p))\chi^{-1}. +\] +Conjugate transport makes these the two summands of the induced +representation after adjoining diagonal \(\tau\); the element +\(\tau\) exchanges them through the elliptic involution \(J\). +They are absolutely simple and nonisomorphic: their scalar +twists have distinct determinants because the inertia character +has sufficiently high order. For the two independent classes +and their conjugates, joint evaluations on the kernel therefore +span \(W^2\oplus(W^c)^2\). +For an element \(\eta_b\) of that kernel, evaluation on +\((\tau\eta_b)^2\) is additive in the kernel evaluations. +On a tuple \((a_1,a_2;b_1,b_2)\), the operator \(1+\tau\) +followed by projection to \(W^2\) gives +\[ + (a_1+Jb_1,\ a_2+Jb_2). +\] +This map is surjective, so its evaluations still span both copies +needed for a rank-two test. +An additive subgroup contains the integer grid generated by any +finite spanning set; in characteristic zero this grid cannot lie +in a proper rank-defect locus. A rank-two choice follows. +Finite Chebotarev realizes these evaluations to increasing +precision by primes whose Frobenius agrees with +\(\tau\eta_b\). + +Apply Lemma~\ref{models:square-switch}, using +Lemma~\ref{pair:derivatives}. The fiber dimension drops by two; +the generic ranks and the valuation of the point/class-functional +tensor are preserved. The fiber dimension cannot become zero: +upper semicontinuity bounds it below by the generic rank one. +Thus the repeated two-dimensional drops end at dimension one. +There the complex is homotopy equivalent to two free lines with +zero differential and perfect duality. Its integral point tensor +has nonnegative determinant valuation. All fixed scales are +units at this test. Thus \eqref{eq:source-16} is nonnegative. +The height-one criterion in the UFD \(A_\theta\), and its +coefficient extension, gives +\[ + p_0^2/(L_w/D)\in A_\theta', +\] +which is \eqref{eq:source-15}. + +For the association assertion, keep the global character unchanged +and perform the same comparison at \(\bar w\). +At conductor \(p^ms\), for large \(m\), the canonical connected +quotient lowers the Serre--Tate parameter order by \(p\). +It is the unique ascending edge in the CM isogeny graph. +The required fixed number of cyclic \(p\)-level edges therefore +gives the same level along the class orbit for the two choices +of \(p\)-adic place. Their points agree up to the non-\(p\) +Atkin--Lehner operations and translations already considered. +The weighted classes differ only by units in \(A_\theta\); +the cuspidal differences are killed. Hence the all-Kummer +complex and its tensor in \eqref{eq:source-16} are the same up to +units at every height-one test. The two quotient valuations +coincide, and the quotients are associates. Contracting the equal +principal ideals along the finite faithfully flat coefficient +extension gives the same association over +\(\widetilde A_\theta\). +The high-conductor +condition is essential here; this argument does not compare two +arbitrarily normalized logarithmic lines at a low-conductor +specialization. +\end{proof} + +\begin{corollary}[The integral comparison quotient] +\label{pair:integral-quotient} +Using the descended analytic ideals, the fraction +\[ + U_w=B_w/L_w +\] +is represented by an integral series, and \(p\nmid U_w\). +Removing any newly added tame variables specializes it to the +old quotient times an integral unit. This includes removal of +all tame variables, leaving the genuine anticyclotomic line. +\end{corollary} + +\begin{proof} +By \eqref{eq:source-1}, \(L_w\) is nonzero modulo \((p,t)\). +Lemma~\ref{models:series-division} +therefore applies to Proposition~\ref{pair:finite-divisibility}. +For clarity, make \(L_w\) distinguished in one tame variable by +an integral group-power change and divide \(B_w\) by it +integrally. At every sufficiently high character of \(t\), the +remainder is zero after inverting \(p\) and extending coefficients +to \(A_\theta'\). Faithful flatness descends this vanishing to +\(\widetilde A_\theta\); the monic quotient has +no \(p\)-torsion, so it is zero integrally there. Each bounded +coefficient of the remainder vanishes at all those characters +and hence vanishes identically by one-variable Weierstrass +preparation. This proves integral divisibility. Since +\(p\nmid B_w\), the integral quotient has no factor \(p\). + +Lemma~\ref{pair:trace} restores the same squared factor in +numerator and denominator on setting each new variable to zero. +That factor is nonzero, and the determinant comparison unit is +integral. Cancelling in the fraction field proves the asserted +specialization identity. Integrality of the larger quotient +then makes the specialization integral as well. There is no +loss of precision in this step. +\end{proof} + +We have obtained the integral quotient, its exact specialization +law, and association of its high-character specializations at the +two \(p\)-adic places. Its possible horizontal divisors remain. +The next two sections construct the theta implication needed to +exclude them. diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/07-theta.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/07-theta.tex new file mode 100644 index 0000000000000000000000000000000000000000..a676ff9e80bf483f347c32cd3c4b297062b1385a --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/07-theta.tex @@ -0,0 +1,1082 @@ +\section{Theta congruences at a characteristic-zero point} +\label{sec:theta} + +Fix the odd prime $p$ and the fields $K,F,L$ chosen in +Section~\ref{sec:classical}. This section supplies the analytic input +for the theta implication. Its input is a zero of the undepleted +series $b_w^0$ of Section~\ref{sec:pair}, at a characteristic-zero point +of the deformation space. Its output is a sequence of integral +ordinary theta sections whose constant Fourier--Jacobi coefficients +tend uniformly to zero at that point. The next section supplies a +nonconstant coefficient of bounded valuation and extracts a Selmer +class. Both parts must use the same finite group characters, including +the characters of increasing conductor at $p$. + +We retain the CM type induced by the distinguished place $w$ of $K$. +Write $\mathcal C$ for the algebraic character of the norm-one torus +of $K/\Q$ with infinity type $s\mapsto s$, and also for its norm +pullback to $L/F$. Its finite conductor is supported at fixed split +places away from $p$. Its $p$-avatar is denoted by +$\widehat{\mathcal C}$. In the distinguished unit position coordinates +the avatar contributes the first power of the coordinate; after norm +pullback it contributes the product of the two coordinates. This is +the character and the reciprocity normalization of +\cite[Section 2, ``Coefficient, character, and measure conventions'']{C}. +Fix a sufficiently narrow weight branch. We require that difference +powers of $\widehat{\mathcal C}$ on this branch factor through the +free anticyclotomic group $\Gamma$ used in Section~\ref{sec:pair}. +Indeed a fixed power kills its finite conductors away from $p$ and its +torsion character; the anticyclotomic ray-class group unramified away +from $p$ has free rank one. The resulting character on $\Gamma$ has +nonzero logarithmic direction, as is seen on the distinguished local +units. Narrowing this branch does not restrict how large its positive +integer weights can be. + +\subsection{Auxiliary tests and the point of evaluation} + +The compact theta source and the target are the unitary groups of +\[ + A=(L^2,1_2),\qquad + W=B\oplus\mathbb H,\qquad + B=(L^2,b_0\sqrt D\,1_2),\qquad + \mathbb H=Le\oplus Lf. +\] +Here $A$ is Hermitian, $W$ is skew-Hermitian, $b_0\in F^{\times,+}$ +is a $p$-unit, and the line coefficients have the even valuation +required for matched self-dual lattices at nonsplit finite places. +The auxiliary-field conditions, including $(D/|D'|)=1$, give this +choice by the norm-invariant calculation in +\cite[Equations (4.1)--(4.2)]{C}. The target has signature $(3,1)$ at +both real places of $F$. Use the trace additive character and unit +self-dual position coordinates at $p$. Order the distinguished +columns as $(e,B_1,B_2,f)$, with $e$ in the multiplicative direction. + +Let $\pi$ be the compact automorphic representation obtained from the +weight-two form of $E$ by real quadratic base change and +Jacquet--Langlands transfer. Its infinity type and central character +are trivial. Its standard base change to $L$ is cuspidal, because the +auxiliary fields avoid the inducing field in the CM case. Its +elliptic local parameters are tempered. At nonsplit finite places it +has the spherical vectors prescribed by the matched lattices; the +level primes split completely in $L$. These are precisely the +cuspidality and local hypotheses used for the compact theta and +binary period constructions in \cite[Sections 4--5]{C}. We make no +assumption on $\pi_p$. + +\begin{lemma}[Auxiliary tests]\label{theta:auxiliary-data} +One may choose two sets of fixed finite theta data with the following +properties. Their extra rational good primes requiring nonspherical +target controls are split completely in $L$, are different from $p$, +and the two sets are disjoint. Outside these sets and the elliptic +bad primes, the target tests are spherical. At an unramified-twist +Steinberg place the source vector is Iwahori invariant and the target +test has line-stabilizer parahoric level. At an additive place fixed +nonspherical tests are permitted. + +For either set there are a compact vector $\varphi\in\pi^\vee$ and a +finite-order character $d_0$ of +$[T]=T(F)\backslash T(\mathbb A_F)$, where $T=\mathrm U(Le_2)$, +such that +\[ + I_T(\varphi,d_0)=\int_{[T]}\varphi(s)d_0(s)\,ds\ne0. +\] +They retain the stated spherical and Iwahori conditions, and $d_0$ is +unramified there. For the two lines $LB_j$ in $B$, let +$\vartheta_{j,d}$ denote the unary theta function with normalized +position monomial of degree $d$. Its splitting character contributes +a fixed shift $c_j$ to the infinity weight, with $c_1+c_2=1$. +There are compatible characters $\xi_{j,d}$ of weight $d+c_j$ +such that, when $d_1+d_2+1=m$, +\[ + \xi_{1,d_1}\xi_{2,d_2}=\mathcal C^m d_0,\qquad + T_j(d)=\int_{[\mathrm U(1)]} + \vartheta_{j,d}(s)\xi_{j,d}(s)^{-1}\,ds. +\] +The tests with unit position support at $p$ can be chosen so that +$T_1(d_{10})$ and $T_2(d_{20})$ are separately nonzero at positive +integers $d_{10},d_{20}$. The integer $d_{10}+d_{20}+1$ is divisible by the +fixed torsion orders and by an arbitrarily prescribed fixed power +of $p$. +\end{lemma} + +\begin{proof} +The ray-character construction allows its additional conductors at +arbitrarily chosen sufficiently deep split places: imposing that the +ratio of a principal idele to its conjugate be $1$ at such a place +removes the finite unit obstruction, after which the character extends +over the finite ray-class quotient. The same construction gives the +weight and inverse unary splitting characters. Neat level may also +be imposed at a new split place. Carry out these choices twice, +avoiding the finite set already used. + +The required spherical tests at an unmarked split place can be seen +in matrix coordinates. Choose integral $e,B_1,B_2$ columns, and +scale the $f$ column dually to the additive conductor. Their mixed +position lattice contains the primitive norm-one orbit. Conjugate +the hyperspecial to these bases if necessary. On a split unary +line, the integral lattice test is torus-unit invariant and its +diagonal Mellin integral is the nonzero central Tate integral. +The absolute-value half shift in the oscillator and temperedness +give its nonzero value; fixed volume and uniformizer powers are +nonzero. Thus these local tests may be retained in the unary +nonvanishing construction. At nonsplit places use the matched +hyperspecial tests. Refining a metaplectic multiplier or cusp level +for an auxiliary calculation does not impose a new target Hecke +control at that place. + +Start with a nonzero compact vector having the required invariances. +Translate at a free split place until its restriction to $T$ is +nonzero. More explicitly, the torus supplies determinants, and +strong approximation for $\mathrm{SU}(A)$ away from that split place +places the other components in their prescribed compact opens. +Fourier expansion of this nonzero function on the compact torus +quotient gives $d_0$. Its unramifiedness at the retained compact +places follows from invariance. A fixed diagonal translation at +$p$ makes the vector invariant under the integral lower unipotent +without making its torus period zero. + +Apply the simultaneous unary nonvanishing lemma of +\cite[Lemma 6.2]{C}. +Its inputs here are coherent matched line pairs, unramified data at +nonsplit finite places, self-dual critical unary characters of +parallel infinity weights $d_j+c_j$ with nonnegative remaining type, +a reduction prime greater than two split completely in $L$, and a +split degree-one variation prime. Those primes can avoid all the +fixed sets just prescribed. Inverse variation of the two characters +preserves their product. The split-line calculation above retains +the prescribed unramified tests; the one-dimensional local Hom space +identifies them with the nonzero local functional. At $p$ use the +unit-character and unit-cut tests of that lemma. Its congruence +choice gives the asserted sum of weights. The analyticity branches +depend on powers of $\mathcal C$ and on fixed CM scales, not on the +new finite-order coefficients; hence they can be narrowed, including +the $\Gamma$ condition above, before making the nonvanishing choices. +\end{proof} + +Include the fixed split primes in both sets in the exponent conditions +for the moving-prime tuple. Distinct such primes have linearly +independent exponent vectors, as specified in the tuple construction. +They need not be inserted into the depleted set $S^\circ$: at a +primitive strict test, adding an unramified good place does not change +the complex. + +Write $R=\Z_p[[t,\mathbf u]]$ for the deformation ring, with the fixed +coefficient extension understood when needed. An interior point is +a tuple $z=(t,\mathbf u)$ in the maximal ideal of the integers of a +finite extension of $\Q_p$. A horizontal divisor is a height-one +prime not containing $p$. + +For either elliptic representation, a primitive strict test at a +specified side $a\in\{w,\bar w\}$ uses the strict condition at +$a$, the full condition at the other $p$-place, unramified +conditions at the fixed places away from $p$, and the permitted +full conditions at moving places. We will use open sets where +the local invariant groups vanish, so the global degree-one +cohomology is the corresponding Selmer group. + +The fixed-place exceptional polynomials below have two concrete +sources. A spanning denominator is a nonzero minor of a finite +matrix expressing specified Schwartz vectors as combinations of +controlled translates. A binary separation polynomial is a +product of resultants between the two-dimensional elliptic factor +and the final factors $|\cdot|^{-1/2},|\cdot|^{1/2}$ in the standard +theta parameter, after norm-power shifts with exponents between +$-4$ and $4$; its nonvanishing excludes linkage between these +factors by the norm powers occurring in the local separation test. +At a moving +prime the inverse fake Euler factor is the degree-two reciprocal +of the central local Euler factor formed from the bare elliptic +Satake parameters and the scalar uniformizer value, discarding +scalar inertia. These definitions identify the tests needed for +point selection before their use in the binary comparison. + +\begin{lemma}[Choice of a point]\label{theta:test-point} +Let $\mathfrak p$ be a horizontal divisor on which $b_w^0$ vanishes. +Fix a strict side for each of the two elliptic representations, and +suppose both corresponding primitive strict cohomology groups +vanish generically on $\mathfrak p$. There is an interior point +$z_0=(t_0,\mathbf u_0)$ on this divisor, over a fixed finite extension +$k/\Q_p$, retaining their vanishing and the following properties. + +The local $H^0,H^2$ vanishings at $p$ and the acyclicity of the moving +local complexes hold for both elliptic representations, with the +conjugate and $L$-restricted tests as required. One of the two sets +of auxiliary tests in Lemma~\ref{theta:auxiliary-data} has nonzero +fixed-place spanning and binary separation denominators at $z_0$. +At every moving prime the inverse fake Euler factor can be chosen +nonzero in the limiting test. Binary separation there can be tested +on inertia when the tested character is ramified, and on Frobenius +when it is unramified. +\end{lemma} + +\begin{proof} +The cohomological conditions are open conditions on the divisor: +they are the nonvanishing of minors of the finite free models. +Their generic validity was proved for the horizontal tests in +Sections~\ref{sec:models} and~\ref{sec:pair}. The asserted absence of +the two jumps is another such open condition. + +At a fixed split good prime the additional exceptional conditions +are zeros of finitely many Laurent polynomials in its unramified +scalar parameter. These are the spanning denominators of +\cite[Lemma 6.4]{C} and the +Frobenius separation resultants of +\cite[Equation (8.11) and Lemma 8.6]{C}. +They are nonzero at trivial scalar and weight zero. The parameters +at the two $F$-places are powers or inverse powers of the single +parameter at the rational prime. Two different rational primes +cannot both give exceptional identities on $\mathfrak p$: their +independent exponent vectors make equations fixing both parameters +to algebraic values have codimension at least two. One may verify +this after a finite flat power change of multiplicative coordinates, +which diagonalizes the two exponent vectors. At most one rational +prime is therefore identically exceptional, and one of the two +disjoint auxiliary sets avoids it. Avoid the remaining finitely +many zero loci at the point. + +For a moving prime, the inverse fake Euler factor is a polynomial of +degree at most two in the character value of a uniformizer. Changing +the uniformizer by a unit leaves the cleared formula unchanged: +the only term using the fake factor as an actual Euler factor is +multiplied by the unit norm sum, on which the character is trivial. +If the tested unit character is nontrivial, it has at least three +values, since $p$ is odd. A unit change avoids the two possible +roots. If it is identically trivial on the divisor, its own +coordinate is $u_j=0$, and the trace condition in the moving-prime +construction makes the limiting Euler determinant nonzero. +The same trace condition gives the Frobenius separation resultants +in this case. In the ramified case choose a unit with nontrivial +tested value; it separates the elliptic head from the two trivial +inertia eigenvalues. Preserve these finitely many nonvanishings. + +The interior algebraic points are dense in each nonempty affinoid +open subset of a characteristic-zero divisor. The bounded-series +specialization argument therefore supplies $z_0$ outside the listed +proper zero loci. Enlarge its finite field of definition for the +fixed data only. +\end{proof} + +Fix such a point. Label finite ring-class characters so that the +toric integral with weight $\eta^{-1}$ has the Galois character +weight $\chi$ in \eqref{eq:source-10}. A class character trivial on +the base ideles descends along $z\mapsto z/z^c$ to the norm-one +torus; pulling back that descended character gives the original +class character, rather than its square. Pull it to $L$ by norm. +There are two simultaneous inverse conventions. Choose one once +at all places. In the later Galois extraction it gives +$V\otimes\chi^{\pm1}$; if the inverse occurs, conjugation identifies +its strict condition with the opposite strict condition for $\chi$. +For the construction using $\bar w$ make the conjugate choice. Thus +the two constructions exchange sides and use the same global scalar +character in the determinant problems. + +Let $G_i$ be the product of the finite tame groups and +$\Gamma/\Gamma^{p^{a_i}}$, with $a_i\to\infty$, and let $\nu_i$ be +its universal character. Denote the group coefficient ring by +$\mathcal O[G_i]$, allowing finite extensions for the values of +Schwartz tests. Substitution at $z_0$ is a ring homomorphism modulo +a precision tending to infinity. For example, +$(1+t_0)^{p^{a_i}}\to1$, and the analogous relations hold for the +tame variables. Integer lifts of exponents give the same value +modulo that precision. A uniformly bounded group polynomial stays +bounded after substitution; products and limits of bounded series +are respected because tails tend uniformly to zero on every closed +interior polydisc. Coefficient fields of classical theta sections +may vary with $i$. Only the field $k$ of the comparison values is +fixed. + +\subsection{The ordinary branch and increasing depth} + +Set $\eta=\mathcal C^m\nu_i$, where $m>0$ is on the fixed branch. +With the even splitting characters trivial, the upper theta integral is +\[ + \Theta_{i,m}(g) + =\int_{[\mathrm U(A)]}\theta_{\Phi_{i,m}}(g,h) + \varphi(h)\eta^{-1}(\det h)\,dh. +\] +The archimedean Fock vector has determinant degree $m-1$. Its +source type is $\det^m$, including the vacuum determinant. Its +target weight is $(m,m,1;-1)$. Use the lattice dual to the monomial +lattice in the $2\times2$ minors, so extraction of a monomial does +not introduce a binomial coefficient. The normalized creation +operators and CM periods are those of +\cite[Section 4, ``Frames, periods, and unary moments'']{C}: creation +has leading linear position coordinate, and fixed algebraic unit +scales are restored after computing in Igusa differential frames. + +At both distinguished $p$-places put +\begin{equation} + \Phi_p(Y)=\phi_p(Y_{[e,B_1]}) + \nu_{i,p}(\det Y_{[e,B_1]}) + \mathbf 1_{M_{2,2}(\Z_p)}(Y_{[B_2,f]}), + \qquad \operatorname{supp}\phi_p\subset\mathrm{GL}_2(\Z_p). + \tag{18}\label{eq:source-18} +\end{equation} +The bare function $\phi_p$ has fixed depth. The determinant factor +cancels the determinant character in source integration; hence the +source compact and its volume remain fixed. Choose $s_i$ large +enough for the locally constant tests, and use the subgroup $J(s_i)$ +of upper block type $(2,1,1)$: its upper radical and final two unit +groups are full, its head Levi is principal congruence at depth +$s_i$, and its lower blocks have sufficient depth. This level marks +a rank-two flag and frame inside the rank-three multiplicative +subgroup. It does not mark a splitting of the etale quotient. + +\begin{lemma}[Canonical levels]\label{theta:canonical-levels} +At each finite depth $s$, the ordinary branch of the normalization +in level $J(s)$ on which the rank-three flag is multiplicative adds +only finite etale character-group flags and frames. At a toroidal +cusp it does not ramify the center Fourier parameter. Every +component of this branch meets a compatible ordinary cusp, and +reduction of all Fourier--Jacobi expansions detects divisibility of +an integral section by the uniformizer. These assertions hold +after every finite coefficient extension, with no loss of $p$-adic +precision depending on $s$. +\end{lemma} + +\begin{proof} +The multiplicative subgroup of an ordinary $p$-divisible group is +canonical at every finite level. Cartier duality identifies its +subflags and frames with quotients and markings of a finite etale +character group. Once the rank-three member is this subgroup, the +remaining level data are exactly these etale data. The full upper +radical is what removes any choice of a lift of the etale quotient. +The corresponding generic-fiber choices form an open and closed +branch after normalization. Idempotents extend over the ordinary +completion; normalization commutes with that completion by +excellence. + +At a rank-one boundary the semiabelian object is an extension of a +binary abelian object by a torus. The preimage of its binary +multiplicative torsion is of multiplicative type. Its character +group and flags are constructed before division by the Raynaud +period lattice, so they do not involve the center Fourier +parameter. The resulting chart covers are finite etale covers of +the abelian extension-data charts. Pointing such a cover over a +strict henselian boundary base makes it an abelian scheme and the +covering an isogeny, by lifting addition through the etale cover. +This is the geometric construction in +\cite[Lemma 7.1]{C}, applied +separately at depth $s$; no numerical bound in its proof depends on +$s$. + +The hyperspecial base has ordinary cusps on every component. +Each connected finite etale component maps onto its base component +and consequently meets its cusp charts. The expansion principle +on these charts detects a zero reduced section. Repeated division +by a uniformizer proves saturation at every precision. These are +statements about reduction and etale covers, so finite ramification +of the coefficient field changes neither the assertion nor the +valuation normalized by $v_p(p)=1$. +\end{proof} + +\begin{lemma}[The two $p$-operators]\label{theta:p-operators} +For every $i,m$, the unnormalized right-coset operators +$U_j=[J(s_i)\operatorname{diag}(1_j,p^{-1}1_{4-j})J(s_i)]$, +$j=2,3$, act on \eqref{eq:source-18} by $p^2$. In weight +$(m,m,1;-1)$ the integral ordinary normalization is $p^{-2}U_j$, +so both normalized comparison values are $1$. +\end{lemma} + +\begin{proof} +The upper shifts are indexed by $M_{j,4-j}(\F_p)$. On the support +of the test the head has rank two modulo $p$, so the expanding +columns can become divisible by $p$ in exactly +$p^{(j-2)(4-j)}$ ways. None of these equations changes the head +function, including its determinant character. The split Weil +action supplies $p^{4-j}$. Their product is +$p^{(j-1)(4-j)}=p^2$ for $j=2,3$. The computation uses the full +upper radical and is independent of its opposite depth and of +the head character's conductor. +\end{proof} + +At a moving $q$ use the integral open-pivot test +\[ + \mathbf1_{\mathrm{GL}_2(\mathcal O_q)}(Y_{[e,B_1]}) + \eta_q(\det Y_{[e,B_1]}) + \mathbf1_{M_{2,2}(\mathcal O_q)}(Y_{[B_2,f]}). +\] +Its equivariance also cancels the source determinant character on +the full source compact. In particular source integration never +divides by the order of a growing character quotient. The fixed +tests elsewhere are those already specified, or one of finitely many +fixed variants. The spherical parameter at an unmarked split place is +\[ + (\pi\otimes\eta)\oplus|\cdot|^{-1/2}\oplus|\cdot|^{1/2}, +\] +by the matched unramified theta calculation of +\cite[Lemma 4.2 and Equation (4.10)]{C}. + +\subsection{A moment bound independent of the position cut} + +The increasing conductor in \eqref{eq:source-18} requires more than +the fixed-level statement of the unary-moment lemma in +\cite[Section 4]{C}. We now prove the extension that will be used. +An integral position lattice in this statement means the lattice in +the fixed Igusa frame, before restoring algebraic CM unit scales. +If those scales are instead included in the coordinates, the norm +is taken on the resulting scaled compact lattice; a coefficient-field +unit is not identified with an element of $\Z_p$. + +\begin{lemma}[Bounded cuts of unary moments]\label{theta:cut-moments} +Fix the integral position lattices, additive characters, Igusa +frames, and the finite tests away from $p$ used for a finite product +of unary theta functions. Moving tame tests may have bounded +group-ring coefficients and additive Fourier normalizations that +are $p$-units. At $p$ let $c$ be any locally constant function on +the position lattices, with +coefficients in any finite extension or finite group algebra and +$\|c\|\leq1$. Its conductor is unrestricted. + +For every finite polynomial combination $P$ of normalized position +moments, the value of the corresponding period-normalized theta +jets at a fixed integral ordinary CM object satisfies +\[ + \bigl|\mathcal J(cP)\bigr|_p + \leq C\,\|P\|_{\mathrm{pos}}. +\] +The constant $C$ depends only on the fixed data. It is independent +of the moment degrees, the conductor of $c$, the moving tame levels, +and the coefficient extension. The same bound applies to the +canonical cusp expansions used to test ordinary integrality. +The uncut moment functional is a bounded measure on the compact +position lattice. When $c$ is invariant under the coordinate +signs, inserting $c$ multiplies that measure by $c$. +\end{lemma} + +\begin{proof} +We first prove a scalar estimate. If a cut or test has values in +a group algebra, write it in the group basis and apply the scalar +argument to each coefficient. Coefficients of products are sums +of products, so the ultrametric inequality retains the same bound, +independently of the group order. In particular we take squares +of scalar coefficient jets, rather than infer coefficientwise +integrality from a square in the group algebra. + +Fix a finite list of scalar cuts and polynomials. All their +conductors and degrees are finite. Choose the initial integral +position frame with first vector in the multiplicative direction +at the fixed CM object, and use this same finite marking in the +level construction. For these unary theta +functions use the ordinary Hilbert modular Igusa tower with the +fixed tame Schwartz level and its multiplicative differential +trivializations, as in \cite[Lemma 4.4]{C}. At each split $p$-factor +the multiplicative height is one. Marking its character group at +a deeper level is finite etale, and does not mark a lift of the +etale quotient. Over a toroidal cusp it leaves the Fourier +parameter unramified. To see which cusps detect this branch, +include the toroidal boundary in this construction. At a Tate +cusp its multiplicative group is the Tate torus, and its +character-group markings are finite etale unit markings of that +torus. A connected component of this finite etale cover maps onto +its connected base component and hence has a point over the chosen +ordinary Tate cusp. Choose its adelic cusp representative integral +at $p$, using Iwasawa decomposition and approximation in the cusp +parabolic, and realizing this level marking. Relative to the +fixed initial position frame, its marked connected vector is +$ue$ modulo $p^s$ with $u$ a unit, at each Hilbert $p$-factor. +Its integral symplectic comparison matrix $g$ therefore has +lower-left entry divisible by $p^s$. In a two-dimensional factor, +write $g=\left(\begin{smallmatrix}a&b\\c&d\end{smallmatrix}\right)$. +Since $a,d$ are units and $c\in p^s\Z_p$, explicitly +\[ + g= + \begin{pmatrix}d^{-1}&b\\0&d\end{pmatrix} + \begin{pmatrix}1&0\\c/d&1\end{pmatrix}. +\] +The second matrix is congruent to the identity in the lower +direction. Take $s$ at least the stabilizer depth of the finite +list of tests. The second matrix then fixes those tests. +Thus every component has a detecting cusp representative in +$B(\Z_p)\operatorname{Stab}(c)$ relative to the original position +frame. No preliminary symplectic transformation of the cut is +being made. The Fourier interchange of the two +directions would mark the etale direction instead and does not +describe this canonical branch. The scalar Hilbert +expansion map on this canonical branch is therefore saturated, +by the same reduction argument as in +Lemma~\ref{theta:canonical-levels}. This is the scalar Hilbert +tower, rather than the unitary target of that lemma. +We may compare the finite list on one sufficiently deep such +level. We shall remove every denominator introduced in making +that comparison, rather than bound it in terms of the level. + +For integral positions the upper integral unipotent acts through +the additive quadratic phase and is in the stabilizer with our +unit self-dual normalization. The diagonal stabilizer can be made +as deep as the local constancy of the cuts requires. Smoothness +supplies a lower stabilizer of some finite depth; equivalently one +may choose that depth after bounding the Fourier-transform support +of this individual finite list. These statements put all the tests +on the canonical multiplicative levels just described. + +Here is the effect on moments of these compatible frame changes. +The preceding construction compares each detecting cusp directly +with the fixed CM position frame through +$B(\Z_p)\operatorname{Stab}(c)$. Their effective changes are +therefore upper triangular: they +rescale positions by units, permute the tests, and multiply by unit +phases. For a diagonal unit $u$, the test reads $\phi(ux)$, while +the multiplicative marking changes the differential by $u^{-1}$. +The normalized degree-$d$ moment therefore reads $(ux)^d$ in the +same position coordinate. An upper unipotent contributes a phase +common to the polynomial moments. Thus both the cut and the +polynomial are transformed in the same coordinate. We use no +uniform bound on the Fourier transform of fine cuts at $p$; a +Fourier interchange with the opposite position direction is not +among these compatible changes. + +Consequently the coefficient at index $\beta$ of a polynomial +combination at such a cusp is +\begin{equation}\label{theta:position-coefficient} + \sum_{Q(x)=\beta}\phi(x)c(x)P(x). +\end{equation} +The sum is finite, and $Q$ has unit quadratic coefficient in the +normalized position frame. It has absolute value at most the +fixed bound for $\phi$ times $\|P\|_{\mathrm{pos}}$. The same +calculation holds for several positions. Additive transforms away +from $p$ have normalization a residue-characteristic power or a root +of unity and cost only the fixed denominators already included in +$C$. Moving determinant characters have unit group coefficients. +The bound in \eqref{theta:position-coefficient} is thus independent +of every changing depth. + +We justify that saturation applies to these analytic jets. At any +individual set of degrees and levels, enlarge the tame multiplier +level, including the level at two, so that products of two base +half-weight theta functions are algebraic integral-weight forms. +Leibniz and Gauss--Manin express products of their normalized jets +as rational expressions in jets of the base products. There are +no horizontal poles: locally in characteristic zero the square of +a base theta has even divisor, and after removing that divisor an +etale square-root frame makes the connection and its fixed iterates +regular. Cross-products fix the signs and descend these products. +The logarithmic cusp calculation is the same. Projection to the +ordinary unit-root splitting therefore makes the square of every +finite linear combination an element of the ordinary tower ring +with $p$ inverted. At an ordinary CM object this splitting agrees +with the CM splitting. These algebraicity and comparison facts are +the finite-level facts proved in the unary-moment argument of +\cite[Lemma 4.4]{C}; they require +finiteness of the chosen list, not a uniform bound for its depth. + +Let $G$ be such a square, multiplied by the fixed clearing factor +predicted by \eqref{theta:position-coefficient}. Its expansions +are integral at all compatible cusps. If $\varpi^rG$ is integral +with $r$ minimal and positive, every expansion of $\varpi^rG$ +vanishes modulo $\varpi$. By the scalar Hilbert expansion +principle just established, its reduction is zero on every +component. Division by $\varpi$ +contradicts minimality. Thus $r=0$. Evaluation and taking the +square root give the claimed bound for the original combination. +This argument removes its whole initial vertical denominator, even +when that denominator depends on the cut. It is unchanged over a +ramified coefficient extension with the valuation normalized by +$v_p(p)=1$. + +For a general cut, separate the parity pieces of the finite +tests and polynomial jets with +$2^{-r}\sum_{\varepsilon\in\{\pm1\}^r} +\varepsilon^e[\varepsilon]$. These projectors have norm at most +one because $p$ is odd. In each coordinate write the degree as +$e_0+2j$, with $e_0\in\{0,1\}$; the corresponding base unary +theta has weight $1/2+e_0$, and its $j$th normalized jet has +position factor $x^{e_0}Q(x)^j$. Carry out the preceding square +argument for these parity bases; their cross-products supply +the common descent. Each expansion still has the form +\eqref{theta:position-coefficient}. Thus the estimate applies to +arbitrary cuts, including coset cuts obtained by decomposing a +matrix determinant character; it does not require invariance under +the separate signs of its entries. + +With the cut equal to one, the estimate gives a bounded linear +functional on all polynomial parity pieces, and polynomial density +extends it to a bounded measure. For the additional identification +of a cut with multiplication of this fixed measure, assume that +$c$ is sign invariant. Approximate it uniformly by sign-invariant +polynomials, using symmetrization. Apply the same bound to the +difference between a cut moment and its polynomial approximation. +In \eqref{theta:position-coefficient} that difference is exactly +$\phi(x)(c(x)-P_n(x))P(x)$ in the same frame. Its norm tends to +zero. Hence the measure with the cut is $c$ times the uncut +measure. All these arguments are coefficientwise for finite group +algebras, so their bounds do not involve the group order. +\end{proof} + +Positive degrees tending to infinity remove the nonunit positions. +On the units, fixing the torsion component makes +$x^d=\omega(x)^d\exp(d\log\langle x\rangle)$ analytic in $d$ on a +sufficiently narrow branch. Lemma~\ref{theta:cut-moments} makes this +convergence uniform for bounded cuts. Restoring fixed CM unit-scale +powers preserves the bound and is analytic after narrowing the +branch once. This is the interpolation of unary periods used for +the nonconstant coefficient in the next section. + +\begin{proposition}[Integral theta sections]\label{theta:integral-family} +There is a fixed integer $c\geq0$ such that $p^c\Theta_{i,m}$ is an +integral ordinary section on the canonical branch, coefficientwise +in $\mathcal O[G_i]$. The same $c$ works for all increasing depths +$s_i$, all sufficiently large positive weights on the fixed branch, +all the fixed test variants, and bounded locally constant cuts in +the head of \eqref{eq:source-18} that retain the source determinant +equivariance on a fixed compact. The two trailing columns keep +their full integral lattice tests; the canonical cusp changes +preserve their integral-translation invariance, as proved below. +Its +Fourier--Jacobi coefficients are integral in the monomial-dual +differential lattice. +\end{proposition} + +\begin{proof} +Choose canonical cusp representatives integral at $p$ and preserving +the multiplicative member modulo the chosen deep level. In the +mixed expansion the $f$ column is Fourier-dualized to the position +$x$. It remains invariant under integral translations: a change +of that column affects the head of \eqref{eq:source-18} only at +depth $s_i$, and preserves the trailing integrality tests. The +Fourier transform therefore has integral support and introduces no +nonunit normalization at $p$. Partition the remaining position +tests by cosets and decompose them into products of unary tests. +Their coefficients retain the same supremum bound, so +Lemma~\ref{theta:cut-moments} applies to their monomial moments. + +The column-degree filtration of the differential bundle identifies +these moments with the mixed coefficients. Binary columns have +the normalized unary moments, and the hyperbolic column contributes +integral position powers. Logarithmic frames and prime-to-$p$ +Jacobi torsion evaluations split the required differential +sequences integrally. These are the mixed-expansion identities of +\cite[Lemma 4.5]{C}; the argument +above checks the only changing input, the increasing $p$-depth. + +At moving and fixed finite places choose the boundary +representatives by approximation, with the required integral +conditions and the deep $p$-condition simultaneously. Detecting +Jacobi torsions remain prime to $p$. Source integration has a fixed +volume denominator because the determinant equivariance cancels +the character on the fixed source compact, including at $p$. +Thus all expansion coefficients have one fixed denominator. +Saturation on the canonical branch, supplied at every depth by +Lemma~\ref{theta:canonical-levels}, gives the assertion for the +sections themselves. This concerns the canonical ordinary lattice; +it makes no assertion about an unrelated generic-level lattice. +\end{proof} + +\subsection{Toric periods and Fourier cancellation at \texorpdfstring{$p$}{p}} + +We next identify the limit of the toric period entering the constant +term. At a split place write $a(x)=\operatorname{diag}(x,1)$ and +$n(y)=\left(\begin{smallmatrix}1&y\\0&1\end{smallmatrix}\right)$. +In Mellin notation put $\chi_p^{\mathrm{Mell}}=\eta_p^{-1}$, and +choose the Kirillov function +\[ + W_{\chi_p^{\mathrm{Mell}}}(a(x)) + =(\chi_p^{\mathrm{Mell}})^{-1}(x) + \mathbf1_{\Z_p^\times}(x). +\] +This compactly supported function occurs in every generic local +elliptic representation. With unit-group volume one its central +Mellin integral against $\chi_p^{\mathrm{Mell}}$ is $1$, whether +that character is ramified or unramified. Its unit equivariance +cancels the torus weight, so integration again has fixed volume. + +Let $W_0(a(x))=\mathbf1_{\Z_p^\times}(x)$, the canonical +$p$-depletion test, and let $b_p$ be large enough for the character +on units. Finite Fourier inversion in the Kirillov model gives +\begin{equation} + W_{\chi_p^{\mathrm{Mell}}} + =p^{-b_p}\sum_{j\bmod p^{b_p}} + \left(\sum_{\substack{x\bmod p^{b_p}\\p\nmid x}} + (\chi_p^{\mathrm{Mell}})^{-1}(x) + \psi_{\mathrm{add}}(-xj/p^{b_p})\right) + n(j/p^{b_p})W_0. + \tag{19}\label{eq:source-19} +\end{equation} +The translations are right translations. Their meaning in CM +coordinates is needed before one estimates this expression. + +\begin{lemma}[CM translations and bounded Fourier projection] +\label{theta:fourier-measure} +Choose connected and etale Tate coordinates $e_p,f_p$ at a split +ordinary CM point. The translation $n(j/p^b)$ gives the lattice +\[ + \Z_pe_p+\Z_p\bigl(f_p+(j/p^b)e_p\bigr). +\] +It corresponds, up to a fixed sign and a unit root-basis choice, +to the Serre--Tate parameter $\zeta_{p^b}^{cj}$ with +$c\in\Z_p^\times$, and preserves the connected differential frame +integrally. Suppose $F(z)=\int_{\Z_p}z^y\,d\mu(y)$ for a bounded +measure $\mu$, and $\chi$ has conductor dividing $p^b$ on units. +For every $\delta\in\Z_p^\times$, +\begin{equation}\label{theta:fourier-cancellation} + p^{-b}\sum_{j\bmod p^b}\sum_{x\in(\Z/p^b)^\times} + \chi^{-1}(x)\zeta_{p^b}^{-xj} + F(\zeta_{p^b}^{c\delta j}) + =\int_{\Z_p^\times}\chi^{-1}(c\delta y)\,d\mu(y). +\end{equation} +Its norm is at most $\|\mu\|$, independently of $b$. +\end{lemma} + +\begin{proof} +An ordinary deformation is the extension of the etale group by the +multiplicative group classified by its Serre--Tate unit $z$. +For $z=\zeta_{p^b}^j$, pulling back on the etale generator by $p^b$ +makes the extension split. Relative to that rational splitting, +the compatible roots $\zeta_{p^{a+b}}^j$ of $z$ shift an etale +lift at level $a$ by $j/p^b$ in the connected coordinate. This +gives the displayed lattice and parameter; changing the compatible +root basis or reciprocity sign gives the fixed unit $c$. + +The lattice intersects the connected rational line in precisely +$\Z_pe_p$, and its image in the etale rational line is precisely +$\Z_pf_p$. Thus the rational comparison transports the connected +lattice integrally, not by multiplication by a power of $p$. +One can also realize it by canonical connected quotients followed +by etale quotients with the chosen roots; dividing the resulting +isogeny by the common scalar gives the same integral connected +comparison. Its multiplicative differential changes by a unit. +Canonical levels in $W_0$ remain canonical, and the rational CM +splitting agrees with the ordinary unit-root splitting by the CM +idempotents. In particular no factor $p^{bm}$ appears in a weight +comparison. + +Substitute the measure expression for $F$ into the left side of +\eqref{theta:fourier-cancellation}. The finite sum over $j$ is +$p^b$ when $x\equiv c\delta y\pmod{p^b}$ and zero otherwise. +There is exactly one such unit $x$ if $y$ is a unit, and none if +$y$ is not. Division by $p^b$ gives the right side. This proves +the equality and the bound without estimating the Fourier +coefficients separately. +\end{proof} + +Let $P_{0,i}(m)$ and $P_{1,i}(m)$ be the raw toric periods for the +forms of $E$ and $E^{D'}$, respectively. Their definition is the +CM toric sum in \cite[Section 5]{C}, with +\eqref{eq:source-19} at $p$, the raw factors $q-1$ and translations +$n(1/q)$ at the moving primes, and the oriented fixed local tests +specified below. Raw means that conductor-class sums are not +averaged by their growing orders. + +\begin{proposition}[The toric weight limits]\label{theta:toric-limit} +At every fixed stage $i$, the periods $P_{j,i}(m)$ have coefficientwise +limits as positive $m$ tends to zero on the chosen $p$-adic branch +and tends to infinity ordinarily. The limits, as group polynomials, +have uniformly bounded coefficients as $i$ varies. Up to a fixed +nonzero scalar and group-like units, the limit of $P_{0,i}(m)$ is +the stage image of the undepleted series $b_w^0$. +Consequently, when $b_w^0(z_0)=0$, weights may be chosen at each +stage with arbitrary prescribed additional precision so that +\[ + P_{0,i}(m_i)(z_0)\longrightarrow0, + \qquad \sup_i|P_{1,i}(m_i)(z_0)|_p<\infty. +\] +\end{proposition} + +\begin{proof} +First keep $i$ and $b_p$ fixed. The CM/Katz comparison and +Proposition~\ref{pair:primitive} identify the weight limit for the +first form with $F_0=d_{\mathrm{mod}}^{-1}f^{[p]}$ in integral +Igusa frames. The CM representatives at the moving tame conductor +can be chosen with $p$-component one. Transport reference algebraic +CM frames through their toric calculations and use the corresponding +Igusa frames for the derivative limit. All degree-dependent +comparison factors are then fixed unit powers. The translations +in \eqref{eq:source-19} preserve those frames by +Lemma~\ref{theta:fourier-measure}. Thus the branch conditions are +compatible; no new nonunit raised to the weight is introduced. + +For the disk indexed by $\mathfrak a$, a prime-to-$p$ isogeny +changes the root parameter to $\zeta_{p^{b_p}}^{c\delta_{\mathfrak a}j}$. +The unit action $a(u)n(j/p^{b_p})$ changes the index to $uj$. +CM reciprocity therefore expresses the unit character in +\eqref{eq:source-19} through the exponent map +$\eta_\Gamma:\Z_p^\times\to\Gamma$ of Section~\ref{sec:pair}. +Formula~\eqref{theta:fourier-cancellation} gives the inverse moment +label +$[-\eta_\Gamma(y)-\eta_\Gamma(\delta_{\mathfrak a})]$, up to the common group-like +unit coming from $c$. The represented torus class contributes +$[t_{\mathfrak a}]\psi_s(\mathfrak a)$. Summing the disk expressions +is exactly the formula for the undepleted $b_s^0$ in +Proposition~\ref{pair:interpolation}. Changes of basepoint, root +basis, or non-$p$ orientation introduce only its fixed sign and +translation units. This establishes the identification including +the global scalar labels. + +For the second form the identical local Fourier calculation suffices +for a bound. Its fixed toric tests away from $p$ are finite +expressions of translates of the primitive form with fixed +differential constants. Its inverse-derivative functions on the +ordinary CM disks give bounded measures. Unit restriction, +prime-to-$p$ translations, and the raw conductor sums preserve a +common bound. The first form has the same bound from the explicit +$b_s^0$ formula. The two limits are therefore uniformly bounded +group polynomials. + +There is no assertion here that inverse Fourier transform at all +stages has uniformly bounded norm. At fixed $i$, its denominator +$p^{b_p}$ is fixed, and weight convergence may be taken to any +precision before letting $i$ grow. Equivalently, characterwise +convergence in the fixed characteristic-zero group algebra implies +coefficientwise convergence with a finite stage-dependent loss, +which is paid by taking the weight sufficiently close to zero. +The resulting limiting polynomials have the uniform bound proved +above. Substitution at the interior point respects their limits. +Since $b_w^0(z_0)=0$, the stage limits for the first period tend to +zero there; the second limits remain bounded. Approximating each +limit to any prescribed stage precision proves the assertion. +\end{proof} + +\subsection{The binary comparison and its denominators} + +At zero Fourier--Jacobi index the mixed expansion sets the +hyperbolic position equal to zero. Every polynomial containing a +hyperbolic-column minor vanishes. The remaining determinant +monomial gives a binary theta value on $\mathrm U(B)$. +At a split finite place its local intertwiner, on the bare source +space, is +\begin{equation}\label{theta:binary-map} + J_v(\Phi,z)=\int_{\mathrm{GL}_2(F_v)} + \Phi({}^th)|\det h|_v\, + \pi_v^\vee(h)\eta_v^{-1}(\det h)z\,d^\times h, + \qquad \operatorname{vol}\mathrm{GL}_2(\mathcal O_{F_v})=1. +\end{equation} +The output uses inverse transpose. This is the central +Godement--Jacquet zeta map \cite{GodementJacquet}, with rational +continuation when required. +The compact-model multiplicity statement of +\cite[Section 5, ``The binary scalar and its multiplicity'']{C} expresses the global +binary map as one scalar times the local maps. Its hypotheses here +are the spherical nonsplit components and cuspidality of the base +change already checked above. + +For precision about the comparison being used, write +$\chi=\eta_v^{-1}$ in the distinguished split coordinate. The +matrix zeta function and the toric Mellin function are +\[ + \begin{split} + Z_G(\Phi,c,\chi,s) + &=\int_{\mathrm{GL}_2(F_v)} + \Phi(g)c(g)\chi(\det g)|\det g|^{s+1/2}\,d^\times g,\\ + M(W,\chi,s) + &=\int_{F_v^\times}W(a(x))\chi(x)|x|^{s-1/2}\,d^\times x. + \end{split} +\] +Their dual functional equations use the same +$\gamma(s,\pi_v\otimes\chi,\psi_{\mathrm{add}})$: +\[ + \begin{split} + Z_G(\widehat\Phi,c^\vee,\chi^{-1},1-s) + &=\gamma(s,\pi_v\otimes\chi,\psi_{\mathrm{add}}) + Z_G(\Phi,c,\chi,s),\\ + M(W^w,\chi^{-1},1-s) + &=\gamma(s,\pi_v\otimes\chi,\psi_{\mathrm{add}}) + M(W,\chi,s). + \end{split} +\] +The Weyl involution uses trivial central character. These are the +normalizations in \cite[Equations (5.8) and (5.10)]{C}. They hold for arbitrary +smooth twists, including special local representations. In the +bilinear pairing there is one functional-equation factor, with the +same orientation on the matrix and toric sides. + +The global identity is the equal-rank, anisotropic binary +Siegel--Weil/Rallis identity \cite{Yamana,GanQiuTakeda} combined +with the two Waldspurger identities \cite{Waldspurger}, with the +specific normalization of \cite[Equation (5.6)]{C}. +The source groups are +compact, their base-change parameters cuspidal and tempered, their +zero-space theta lifts vanish, and the torus characters have the +compatible opposite central characters in the two bilinear slots. +The central standard $L$-value factors as the two central Rankin +values for $E$ and $E^{D'}$ over $K$. Thus these are value +identities, not residue or derivative identities. Keeping partial +$L$-functions and raw exceptional local integrals gives the +comparison without dividing by a global $L$-value. We record the +local changes required by our test point and increasing $p$-depth. + +At $p$ the Mellin test above has value exactly one. Since $p$ splits +completely in $L$, both local matrix gamma factors match the two +toric gamma factors, including their conductors. They cancel +without any bound on their separate valuations. The local +unramified-twist assumption in the fixed-depth calculation of +\cite[Section 5]{C} was used to choose its Mellin-one test; the test +\eqref{eq:source-19} supplies that property for our ramified +characters. Duality exchanges the distinguished coordinates by +unit scales, so its remaining factors are character values on +units and fixed unit powers. + +At a moving prime let $L_q^{\mathrm{fake}}$ be the degree-two +unramified central Euler factor formed from the uniformizer value +of $\chi_q^{\mathrm{Mell}}$, ignoring its tame inertia. Put +$D_q^{\mathrm f}=(L_q^{\mathrm{fake}})^{-1}$. The translated +spherical Whittaker expansion gives +\begin{equation}\label{theta:moving-clearing} + \begin{split} + H_q^{\mathrm f} + &=D_q^{\mathrm f}(q-1)M(W,\chi_q^{\mathrm{Mell}},1/2)\\ + &=D_q^{\mathrm f} + \sum_{a\in\F_q^\times}\chi_q^{\mathrm{Mell}}(a) + \psi_{\mathrm{add}}(a/q) + +(1-D_q^{\mathrm f}) + \sum_{a\in\F_q^\times}\chi_q^{\mathrm{Mell}}(a). + \end{split} +\end{equation} +Both factors have bounded group coefficients. Our uniformizer +choice makes $D_q^{\mathrm f}(z_0)$ tend to a nonzero value. +The additive sum in \eqref{theta:moving-clearing} is a unit at the +test: modulo the maximal ideal all the group elements specialize +to one, and its augmentation is $-1$. The plain unit sum tends +to zero at the test. It is an integral multiple of the norm +element of its own inertia group; the geometric-sum formula gives +convergence to zero when $u_{j0}\ne0$, and at $u_{j0}=0$ its value +is an integral multiple of the group order, which also tends to +zero. Hence +$H_q^{\mathrm f}(z_0)$ is nonzero with uniformly bounded valuation. +The additive sums may lie in varying coefficient fields; no +convergence of those unit sums in a fixed finite field is required. +The period comparison uses these full raw factors. No inverse +of $q-1$ or conductor projector remains. + +At a fixed split $q\ne p$, take the oriented toric newvector. Its +Mellin integral is +$L(1/2,\pi_{j,q}\otimes\chi_q^{\mathrm{Mell}})$, $j=0,1$, +up to fixed volume, unit, and monomial factors with bounded inverse +at $z_0$. Kill fixed $\mathcal C^m$ inertia by the weight branch. +Divide the binary map \eqref{theta:binary-map} at $v\mid q$ by +$L(1/2,\pi_{F,v}^\vee\otimes\chi_v^{\mathrm{Mell}})$. +For fixed Schwartz and matrix-coefficient data, the +Godement--Jacquet zeta identity says that coefficients of this +divided map are Laurent polynomials in the unramified parameter. +Their finitely many coefficients have a fixed denominator. +Local base change identifies the product over $v\mid q$ of the +binary Euler factors with the product of the two elliptic factors. +This includes +ramified quadratic base change at $q$, since $K_q$ is split. +Induction of local epsilon factors matches the gamma products, +up to the fixed lambda factor for the chosen additive characters. +Thus the Euler factors of the toric Mellins cancel those moved +into the binary scalar. This is a rational identity before +evaluation, so it holds even when an inverse Euler polynomial +vanishes at $z_0$; no inversion of that vanishing polynomial is +made after specialization. + +At fixed places where $K_q$ is nonsplit the variable scalar is +locally trivial: it is unramified and anticyclotomic of $p$-power +order, with $p$ odd. The fixed nonzero-pairing tests and no-pole +estimates of \cite[Section 5]{C} apply, including the companion's +ramified toric functional. At all remaining places use spherical +normalizations. + +Finally, the determinant Fock norm of degree $m-1$ has ratio +$(m-1)!m!$ to the vacuum norm. The raised quaternionic weight-two +vector has the same ratio. These factorials cancel in the +archimedean comparison. The CM period normalization has weight +$2m$ at each real embedding on both sides. The remaining frame +factors are fixed algebraic unit powers, and global measures, +adjoint norms, and zeta factors contribute fixed scalars. Their +algebraicity follows by evaluating any nonzero normalized +comparison; if no such comparison exists, the cross-multiplied +numerator identity is already zero. This is the algebraic, +bilinear comparison, so the squares below are algebraic squares. + +\begin{proposition}[Vanishing of all constant terms] +\label{theta:boundary-small} +Assume $b_w^0(z_0)=0$, and choose the auxiliary tests and local +parameters of Lemma~\ref{theta:test-point}. After the fixed clearing +of Proposition~\ref{theta:integral-family}, weights $m_i$ may be +chosen so that all constant Fourier--Jacobi coefficients of +$\Theta_{i,m_i}$ at $z_0$ tend uniformly to zero. The weights tend +to zero on the fixed $p$-adic branch and to infinity ordinarily. +At each fixed stage they can satisfy arbitrarily strong additional +weight-approximation requirements. The assertion holds +simultaneously for the finitely many fixed variants used for +nonconstant content and for their integral prime-to-$p$ translates. +\end{proposition} + +\begin{proof} +Let $a_{i,m}$ be any constant coefficient in an integral ordinary +frame. It is the binary scalar times the local intertwiners +applied to the corresponding projected tests. Square this +expression and use the bilinear comparison just described. +After cross-multiplication it has the form +\begin{equation}\label{theta:cleared-boundary} + A_{i,m}\,a_{i,m}^{2} + =B_{i,m}\,P_{0,i}(m)^2P_{1,i}(m)^2. +\end{equation} +Here $A_{i,m}$ and $B_{i,m}$ have uniformly bounded group +coefficients, and $A_{i,m}(z_0)$ is nonzero with valuation bounded +above, when $m$ is sufficiently close to zero at stage $i$. +We verify that this bound is uniform in the cusp, rather than +only for the reference binary test. + +At a moving prime the projected test has integral support, +depends on reduction modulo $q$, and is determinant-equivariant +under the full source compact. On a deficient-rank stratum the +stabilizer determinant surjects onto the inertia group. Its group +coefficient is therefore an integral multiple of the norm element: +all coefficients are equal, without division by the group order. +The remaining untwisted-unit integral is a sum over image +lattices. Express an exact reduced line or zero image by +subtraction from containment conditions. Each containment sum is +a translate and a power of $q$ times the full-lattice fake Euler +series. Thus $D_q^{\mathrm f}$ clears its denominator, while +$H_q^{\mathrm f}$ clears the raw toric factors. Their bounded +powers have the bounded evaluated valuations just proved. This +argument also applies to bounded integral sums of pivot +translates; powers of $q$ are $p$-units. + +At $p$ the canonical projection has integral matrix support, by +the Fourier-support calculation in +Proposition~\ref{theta:integral-family}. Its determinant +equivariance cancels the source twist on a fixed compact under +which the bare vector is invariant. Expanding +\eqref{theta:binary-map} by determinant valuation gives the factor +\[ + p^{(m-1)v_p(\det h)}. +\] +Right-coset volume denominators are fixed, even though the target +depth grows. The translates of the fixed compact automorphic +function have bounded sup norm. For sufficiently large positive +$m$ this integral-matrix series converges with a uniform bound. +Its finite determinant truncations are the +Godement--Jacquet series and hence compute the same rational zeta +operator. No projector onto a deep $p$-character space is used. + +At a fixed split place the divided intertwiners above have Laurent +polynomial bounds on the finite spaces of tests. Integral cusp +representatives and their fixed variants give the same bound. +Fixed nonsplit denominators have bounded inverse at $z_0$; +unmarked places have spherical normalization. Boundary +approximation chooses representatives integral at the designated +finite places, and at $p$ preserving the deep canonical flag. +Compact-model evaluations and frame changes therefore introduce +only the fixed factors and unit character values already +accounted for. These observations prove the claimed uniformity +of \eqref{theta:cleared-boundary}. + +The period identities first hold at actual finite characters. +Those characters separate the characteristic-zero group algebra, +so the cross-multiplied identity holds coefficientwise. The +uniform bounds permit substitution at $z_0$ to the increasing +precision for which the finite-group relations hold. By +Proposition~\ref{theta:toric-limit}, its right side tends to zero, +and the valuation of the nonzero left multiplier stays bounded. +Thus $v_p(a_{i,m_i}(z_0))\to\infty$, uniformly in the coefficient. +Taking a square root of this valuation inequality merely divides +the required precision by two. + +For clarity, the parameters are chosen in the following order. +Fix the finite group stage and its required $p$-depth. At that +stage take the positive weight sufficiently close to zero to pay +every finite Fourier-inversion loss and approximate the two +toric limits to the desired precision. Increase its ordinary +size to meet the convergent-series and holomorphy requirements. +Then let the group orders increase and retain a precision +tending to infinity more slowly than their relation precision +and the resulting constant-term precision. Fixed losses are +absorbed in this retained precision. Additional finitely many +weight congruences and lower bounds can be imposed at the first +step. In particular the degree choices used to retain +nonconstant content in Section~\ref{sec:extraction} are compatible +with this construction. +\end{proof} diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/08-extraction.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/08-extraction.tex new file mode 100644 index 0000000000000000000000000000000000000000..947d2ea86832e7f82241dc328d8b003e480a3f43 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/08-extraction.tex @@ -0,0 +1,1033 @@ +\section{Content at a character and extraction of a primitive class} +\label{sec:extraction} + +The boundary calculation in Section~\ref{sec:theta} is useful only if +the theta section itself does not tend to zero at the character being +tested. We prove this assertion first. We then lift the sections to +cusp forms and extract a Galois extension. All precision losses in +this section are bounded independently of the stage. We require only +a nonzero extension over a characteristic-zero field, not an integral +length formula. + +We retain the notation of Section~\ref{sec:theta}. Write $\chi$ +for the universal scalar character over $K$, and $\chi_z$ for +its specialization at a field test $z$. Its character on $L$ +is its restriction, equivalently its norm pullback in the idelic +description. Write $V'=V\otimes\chi_{D'}$ for the companion plane. + +For a field test $z$ and $a\in\{w,\bar w\}$, let +$H^1_{\mathrm{prim},a}(K,V\chi;z)$ mean the degree-one group of the +marked Selmer complex with strict condition at $a$, full condition at +the other place above $p$, and unramified condition at every fixed +place away from $p$. The moving-place conditions are those of the +deformation; their local complexes are acyclic at the tests in use. +Use the same definition for $V'$. This defines these groups on the +finite-model field fibers as well as at $z_0$. A \emph{jump} means +that the indicated group is nonzero. + +\begin{proposition}[Theta implication] +\label{extraction:theta-implication} +Let $\mathfrak p$ be a horizontal height-one prime of the deformation +ring, with the auxiliary tuple conditions of Section~\ref{sec:theta}. +If $b_w^0\in\mathfrak p$, then, over $\Frac(R/\mathfrak p)$, +at least one of +\[ + H^1_{\mathrm{prim},a}(K,V\chi),\qquad + H^1_{\mathrm{prim},a}(K,V'\chi) +\] +is nonzero. Here $a$ is one fixed side determined by the reciprocity +convention of Section~\ref{sec:theta}. Replacing $w$ by $\bar w$ +replaces $a$ by its conjugate. Both alternatives use the scalar +character of the determinant problem. +\end{proposition} + +We prove the proposition by contradiction. If both groups vanish +over the divisor field, the open conditions in +Lemma~\ref{theta:test-point} give a point $z_0$ at which both still +vanish, all required local invariants vanish, and the separation +polynomials are nonzero. Fix this point for the rest of the section. +It is defined over a finite extension $k/\Q_p$; from now on abbreviate +$\chi_{z_0}$ to $\chi$. The finite characters $\nu_i$ are evaluated +at $z_0$ modulo precisions tending to infinity. + +\subsection{A positive coefficient at the chosen point} + +Use the auxiliary vector $\varphi$, stabilizer character $d_0$, and +unary nonvanishing degrees $d_{10},d_{20}$ of +Lemma~\ref{theta:auxiliary-data}. The stabilizer of $e_1\in A$ is +the torus $\mathrm U(Le_2)$. Write its nonzero period as +\[ + I_{\mathrm{stab}} + =\int_{[\mathrm U(Le_2)]}\varphi(s)d_0(s)\,ds\ne0. +\] +The one-index unfolding of \cite[Lemma~6.1]{C} concerns the primitive +index $e_1$ and the integral monomial +\[ + [e,B_1]^{d_1}[e,B_2]^{d_2}, + \qquad d_1+d_2+1=m. +\] +The brackets are the indicated two-column determinants. At $Y_e=e_1$ +they read the second-row coordinates of $B_1,B_2$. We now specify +the changes to its finite tests; the integral monomial lattice is +unchanged. + +At $p$, put the fixed unary unit test in the second-row $B_1$ +coordinate and retain the integer test in $B_2$. Multiply by the +determinant character in \eqref{eq:source-18}. At the $j$th moving +prime introduce another copy $v'_j$ of its cyclic parameter. Factor +the corresponding global character into the slot characters with +parameters $v'_j$ and +$(1+u_j)/(1+v'_j)-1$. This factorization is global, so it includes +their unramified values at the other places. Require both heads +$Y_{[e,B_1]}$ and $Y_{[e,B_2]}$ to be integral and invertible, and +insert the respective determinant characters. All other entries +retain their integral tests. For the moment these moving tests have +no prescribed target control. + +These are bounded integral sums of translates of the original pivot +test. In fact, write the trailing columns as $Y_{\mathrm{head}}S$, +partition $S$ modulo the moving uniformizer, and subtract +$Y_{\mathrm{head}}S_0$ on a residue class. Dilating the remaining +trailing coordinates identifies that summand with the pivot test. +The second invertibility condition is a residue condition on $S_0$; +its character factor is the character of its invertible residue +determinant. All coefficients are integral group elements. The +scales are powers of the moving residue characteristic, hence +$p$-units. Although the number of summands may grow, their supremum +norm and the nonarchimedean bound for their sum do not grow. In +particular no inverse order of a residue unit group occurs. + +At an unramified-twist Steinberg place use a line-stabilizer +parahoric on the target and an Iwahori-fixed source vector. In +split coordinates the test consists of integral columns with the +second coordinate of $Y_e$ zero modulo the uniformizer. The +integral vector--covector pairs with pairing one and this condition +form a single source-Iwahori orbit: complete the first vector, +whose reduction is in the prescribed line, by a vector in the +kernel of the covector. The two row-two unary tests are therefore +spherical. At places kept hyperspecial use the single primitive +norm-one orbit. At the remaining fixed split places, including +the additive ones, temporarily use the fixed-level tests permitting +the one-index unfolding. + +Unfolding now separates a row-one Heisenberg theta function from +\[ + \int_{[\mathrm U(Le_2)]}\varphi(s)\eta^{-1}(s) + \vartheta_{1,d_1}(sb_1)\vartheta_{2,d_2}(sb_2)\,ds. +\] +Here the determinant character cancels the source character in the +compact integration at $p$. Thus its increasing conductor does not +shrink that integration domain. On setting $Y_e=e_1$, its remaining +factor is precisely $\nu_{i,p}$ on the row-two $B_1$ unit coordinate. +The row-one function does not see this factor. At a moving prime, +the two heads give the two row-two unit cuts, with their separate +slot characters; the primitive orbit volume is unchanged. + +Assign the true character to the first unary character, and assign +the two moving slot characters to the corresponding unary +characters. With the splitting characters of +Lemma~\ref{theta:auxiliary-data} their product is $\eta d_0$. +Averaging in $b_1,b_2$ against the inverse unary characters therefore +gives +\begin{equation} + I_{\mathrm{stab}}\,T_1(d_1)T_2(d_2). +\tag{20}\label{eq:source-20} +\end{equation} +Here +\[ + T_j(d)=\int_{[\mathrm U(1)]}\vartheta_{j,d}(s)\xi_j(s)^{-1}\,ds +\] +is the corresponding unary period. Its assigned scalar parameters +are included in $\xi_j$ and will be displayed when necessary. + +This averaging has a fixed denominator. On local torus units the +weight cancels the characters in the tests, including the deep test +at $p$, so the integrand descends through a fixed compact subgroup. +There are consequently fixed finite torus representatives; by +approximation their $p$-components may be one, and no new moving +component is needed. For each representative the row-one function +is nonzero at a fixed prime-to-$p$ Jacobi torsion, as in the proof +following the cited unfolding lemma. The needed Jacobi translations +can be integral at $p$: they preserve $e$ and add multiples of $Y_e$ +to the $B$ columns, leaving each determinant twist identically +unchanged. They preserve the canonical branch and may instead be +included in its Fourier trivialization. The differential comparison +at these torsions is the fixed prime-to-$p$ isogeny comparison. +Thus a bound for \eqref{eq:source-20} detects the content in the +ordinary Fourier--Jacobi lattice, without degree-dependent divided +powers or conductor-dependent averages. + +\subsection{The product character in the unary moment measure} + +The extra parameters are needed because the two unary periods need +not be simultaneously nonzero at their respective trivial moving +characters. We first explain why each period is a nonzero analytic +function even when the true parameter has the prescribed value $t_0$. + +All degree variables below lie on the narrow branches fixed in +Lemma~\ref{theta:auxiliary-data}. A bounded measure on integral +positions gives convergent analytic unit moments on these branches. +For integer degrees tending to infinity, the nonunit positions have +moments tending uniformly to zero. Hence the degree limits of the +actual $B_2$ integer test are its unit-cut moments. The same bound +applies after inserting any of the character cuts, by +Lemma~\ref{theta:cut-moments}. On a closed interior character disk, +the finite group power $(1+t)^{n_i(x)}$ converges uniformly to the +true character: if two exponents agree modulo $p^{a_i}$, their power +ratio tends uniformly to one. The binomial coefficients are +integral and $a_i\to\infty$. The degree-power series have uniform +tails after the branch has been narrowed. We may therefore pass +coefficientwise to limits in the joint degree and character series. + +For completeness, the varying coefficient fields cause no +compactness assumption here. Take bounded arrays in $\C_p$ with +seminorm $\lim_{\mathcal U}|\cdot|_p$, quotient by the arrays of +seminorm zero, and complete the result to a field $\mathcal K$. +An array of positive limiting norm has a bounded inverse on a +filter-large set, which proves the field assertion before +completion. A nonzero element of $\mathcal K$ records a uniform +upper bound on valuation on a filter-large set of stages. Whenever +we use such a bound, we restrict to that set and relabel the stages; +all previous limits are preserved. The moment bounds and uniform series +tails just established justify the analytic limits in $\mathcal K$. +All evaluation parameters chosen below will nevertheless lie in +$\Z_p$ or a fixed finite extension of $k$. + +Put the moving slot parameters of $T_1$ equal to zero, and omit +its moving unit cuts for the moment. There is then a bounded +measure $\mu$ on the true character group $\Gamma\simeq\Z_p$, +with coefficients in a fixed scalar extension, and a nowhere-zero +analytic unit factor $u(d)$, such that its unary period is +$u(d)$ times the evaluation of $\mu$ at +\begin{equation} + \widehat{\mathcal C}^{\,d-d_{10}}\nu_t. +\tag{21}\label{eq:source-21} +\end{equation} +The hat denotes the $p$-avatar; the two factors are pulled to $L$ +by the norm. More explicitly write the degree branch as +$d=d_{10}+hn$, $n\in\Z_p$, where the fixed positive integer $h$ +kills the finite conductor and torsion factors of +$\widehat{\mathcal C}$. Put +$\mathcal C_\Gamma=\widehat{\mathcal C}^{\,h}$, a character of $\Gamma$. +The first factor in \eqref{eq:source-21} means $\mathcal C_\Gamma^n$; +we do not require $\widehat{\mathcal C}$ itself to descend to +$\Gamma$. + +Here is the measure identity underlying this assertion. Express +the torus integral using its fixed finite representatives $r$ with +$p$-component one, translate their finite tests to one fixed CM +object, and evaluate all moments in that object's fixed frames. +Concretely, the unary moment construction is linear in the finite +Schwartz test. For $r$ replace that test by its finite Weil translate, +leaving the CM object and its differential and Igusa frames fixed. +This changes the measure, not the position-power rule or its period +normalization. The only representative-dependent degree factor +outside that measure is the toric character at $r$. +Let $\mu_r$ be the resulting bounded measure on its two unit +positions $x=(x_\sigma)$. Absorb the fixed degree $d_{10}$ and all +fixed character factors into $\mu_r$. The remaining factor of +degree $d-d_{10}$ and true character $t$ is +\[ + \bigl(\widehat{\mathcal C}^{\,d-d_{10}}\nu_t\bigr)(r)^{-1} + \prod_\sigma x_\sigma^{d-d_{10}} + \nu_{t,\sigma}(x_\sigma). +\] +By the weight-character convention and CM reciprocity used in +Section~\ref{sec:theta}, the product on the right is this same +character evaluated at the image $\theta(x)\in\Gamma$ of the +local units. In this description $r$ in a character argument +denotes the norm-reciprocity image of the torus representative in +$\Gamma$; its finite components outside that quotient were already +absorbed into $\mu_r$. Thus the displayed factor is +$\bigl(\widehat{\mathcal C}^{\,d-d_{10}}\nu_t\bigr) +(r^{-1}\theta(x))$. Push each $\mu_r$ forward by +$x\mapsto r^{-1}\theta(x)$ and take their fixed finite weighted +sum to obtain $\mu$. Its norm is bounded by the fixed moment and +volume bounds. The coordinate and CM-frame powers that were +removed are common to the moment evaluation, independent of $r$, +and give $u(d)$. This proves \eqref{eq:source-21} as a measure +identity. In particular it is not an inference from nonvanishing +at augmentation. If the local-unit map has image a proper open +subgroup of $\Gamma$, the pushforward construction still gives +exactly the same identity, with the corresponding power map. + +Let $\gamma$ be the generator of $\Gamma$ used to define $t$. +The measure transform +$F(Z)=\int_\Gamma(1+Z)^{\ell(g)}\,d\mu(g)$ is a bounded series, +where $g=\gamma^{\ell(g)}$. At $d=d_{10},t=0$ its value is +nonzero by the auxiliary unary nonvanishing. Hence $F\ne0$. +For fixed $t=t_0$ its argument, in the branch coordinate $n$, is +\[ + Z(n)=(1+t_0)\mathcal C_\Gamma(\gamma)^n-1. +\] +The logarithm of $\mathcal C_\Gamma(\gamma)$ on this branch +is nonzero, since its local-unit weight has a nonzero logarithmic +direction. Therefore $Z(n)$ is nonconstant on every degree disk. +If $F(Z(n))$ vanished there identically, one-variable analytic +uniqueness, applied at an interior accumulation point of the +distinct $Z(n)$, would give $F=0$. This proves nonvanishing of the +first period as a function of degree at the prescribed $t_0$. +The corresponding assertion for $T_2$, which has no true-character +factor, follows directly from its nonzero value at $d_{20}$. + +Restore the moving unit cuts while leaving each period's own +moving character trivial. Subtracting the uniformizer translate +of an integer unary test expresses each cut by the factors +\[ + 1-\alpha_v\mathcal C(\gamma_v)^{\pm d}. +\] +This is the torus-equivariance calculation of \cite[equation~(6.7)]{C}. +It also includes +the unramified true-character value in $\alpha_v$ for the first +period. The coefficient $\alpha_v$ is a nonzero $p$-unit, +independent of $d$ for fixed $t$. The tuple conditions make +$\mathcal C(\gamma_v)$ nontorsion. Each factor is consequently +a nonzero analytic function of degree, so neither unary period +becomes identically zero. + +It follows that, with the original variables fixed at $z_0$, the +two analytic functions +\[ + T_1(a;\mathbf v'),\qquad + T_2\bigl(-1-a;(1+\mathbf u_0)/(1+\mathbf v')-1\bigr) +\] +are nonzero: for the first use $\mathbf v'=0$; for the second +use $\mathbf v'=\mathbf u_0$. Their product is nonzero in the +ring of analytic functions on a closed polydisk strictly inside +the open parameter disks and containing both these settings. +Choose $a\in\Z_p$ on its degree branch and $\mathbf v'$ in a +fixed finite extension at which the product is nonzero. To see +that such choices suffice even over $\mathcal K$, vary one +coordinate at a time over infinite subsets of that fixed field +having interior accumulation points. Repeated one-variable +uniqueness says that vanishing on their product would force the +series to be zero. + +Choose positive integers $d_{1i},d_{2i}$ on the prescribed branches +converging respectively to $a,-1-a$, with both tending to infinity +in the usual order. At each stage their congruences can be made +arbitrarily accurate and their lower bounds arbitrarily large. +Thus $m_i=d_{1i}+d_{2i}+1$ can simultaneously meet every fixed-stage +weight approximation required by Proposition~\ref{theta:boundary-small}. +The compatibility of the two degree branches was imposed in +Lemma~\ref{theta:auxiliary-data}. Equation~\eqref{eq:source-20} +then has uniformly bounded valuation at $z_0$. + +\begin{lemma}[Content with the local controls] +\label{extraction:content} +There are controlled theta sections at $z_0$, of weights $m_i$ +as above and depths $s_i$, whose constant terms tend uniformly to +zero and whose ordinary positive Fourier--Jacobi content has +valuation bounded above by a constant independent of $i$. +\end{lemma} + +\begin{proof} +The preceding argument proves the content assertion for the +temporary tests. Restore the controls at each fixed split place +by the spanning argument of \cite[Lemma~6.4]{C}. At the auxiliary good +places its finitely many Laurent denominators are nonzero at +$z_0$ by Lemma~\ref{theta:test-point}. At an additive place the +same local rank filtration works at the present unramified scalar. +A supercuspidal head has no proper Jacquet module. For a ramified +principal or special head with elliptic determinant trivial on +inertia, both inducing-position characters are ramified. Neither +can match the unramified lower-rank orbit character. Thus the +lower-rank coinvariants vanish for every unramified scalar, and +there is no norm linkage between this head and the trailing +unramified binary block. The open-orbit induction is the +unlinked parabolic product, hence irreducible; a nontrivially +paired pivot generates it. In a fixed finite-level model choose +a spanning minor nonzero at $z_0$. Cramer's rule gives the +required expression over a Laurent ring with that single minor +inverted. This supplies the asserted finite denominators at the +additive places as well. + +Cross-multiply these expressions before evaluating the group +algebras. Their clearing factors have nonzero limits at $z_0$ +and bounded inverse valuation. Prime-to-$p$ target translations +preserve ordinary integrality, since their differential maps are +units and base change of the canonical level is integral. This +includes the possibly long integral sums at the moving primes: +the nonarchimedean bound for their coefficients is one, and there +is no averaging. If every controlled section had content tending +to zero, so would every such expression, contradicting +\eqref{eq:source-20}. We may therefore select a controlled +section with bounded content at each stage. Only a bounded +number of kinds of fixed local tests is needed. At every upper +$(2,2)$ control retain the two positive binary operators, the +invertible center expansion and the full last spherical block. +The pivot calculation is unaffected by a determinant twist on +the head. Finally Proposition~\ref{theta:boundary-small} applies +to all these bounded test variants simultaneously, proving the +constant-term assertion. +\end{proof} + +\subsection{Cusp lifting with increasing depth} + +We give the depth dependence of the cusp lifting explicitly. +The geometric inputs are \cite[Lemmas~7.1--7.2]{C}: the target has split hyperspecial +PEL datum, multiplicative height three and etale height one at +$p$, and its upper $(2,1,1)$ level marks a rank-two flag and frame +inside the multiplicative rank-three flag. The last two unit +factors and the upper radical are full. No splitting of the +etale quotient is marked. These are exactly our levels $J(s_i)$. + +\begin{lemma}[Uniform cusp congruence] +\label{extraction:cusp} +After one fixed reduction of precision, the sections in +Lemma~\ref{extraction:content} give finite integral operator +orders $\mathbb T_i^0$ on classical cusp spaces and maps +\[ + \lambda_i^0:\mathbb T_i^0\longrightarrow + \mathcal O_k/(p^{M_i}),\qquad M_i\longrightarrow\infty. +\] +The maps have the tested theta values on the split good and +controlled operators. Both normalized $p$-operators have value +one. No upper bound on $s_i$ is required. +\end{lemma} + +\begin{proof} +At each depth normalize the good toroidal model in the generic +level, after the finite extension needed for its cyclotomic +frames. On its canonical ordinary branch the extra level is +finite etale on the Cartier-dual character group of the +multiplicative subgroup. At a boundary chart this adds a finite +etale cover of the abelian extension-data scheme and leaves the +center Fourier parameter unchanged. This description holds for +each integer $s_i$; it introduces no division by the degree of +that cover. + +A section whose constant terms vanish modulo $p^M$ has positive +Fourier--Jacobi indices. At such an index the Jacobi line bundle +is ample on the abelian chart. The differential bundle has its +integral column-degree filtration with constant graded pieces, +so positive cohomology vanishes after tensoring with that ample +line bundle. This remains true on each finite etale abelian +cover. Cohomology and base change lift the positive coefficients +modulo $p^M$. Neatness removes the finite stabilizers of positive +indices, permitting transport of lifts along the free index +orbits without dividing by an orbit order. Formal functions +then identifies these lifts with the cusp sheaf on the ordinary +open. This proves the base-change assertion at each $s_i$ with +zero loss of precision, also over ramified finite coefficient +extensions. Extend by zero on the other ordinary branches. + +Multiply by a sufficiently high power of Hasse to extend across +the complement of the ordinary open. Local lifts of Hasse +differ by a multiple of $p$; sufficiently divisible powers glue +modulo $p^M$ and equal one in multiplicative differential frames. +Serre vanishing after a further ample twist lifts the resulting +global section to characteristic zero. These exponents may +depend on $i,s_i,M$; the surjectivity statements themselves cost +no precision. Choose the resulting shift $H_i$ arbitrarily +large and tending to zero on every weight branch in use. The +classical weights are +\[ + \lambda'_i=(m_i+H_i,m_i+H_i,1+H_i;-1-H_i). +\] + +The integral normalized operators remain uniform in depth. +In Serre--Tate coordinates $q_1,q_2,q_3$, each graph for $U_j$ +adjoins $j$ roots $u_a^p=q_a$. Its monomial basis gives +\[ + \Tr\bigl(\mathcal O[u_1,\ldots,u_j]/(u_a^p-q_a)\bigr) + \subset p^j\mathcal O. +\] +The transported multiplicative flags and frames depend on the +graph, not on the chosen roots, even when marked modulo +$p^{s_i}$. They may therefore be taken outside this trace. +The differential scalings have lower bounds +$\lambda'_3+\lambda'_4$ for $j=2$ and $\lambda'_4$ for $j=3$, +exactly as in \cite[Lemma~7.3]{C}. Thus +\[ + \widetilde U_2=p^{-(2+\lambda'_3+\lambda'_4)}U_2, + \qquad + \widetilde U_3=p^{-(3+\lambda'_4)}U_3 +\] +preserve the integral lattice. The graph sum introduces no +denominator. The Hasse shift changes these exponents by $0,-H_i$; +its determinant factor changes by exactly the same amounts. +Take $H_i$ divisible enough that all remaining unit frame factors +are one modulo the chosen precision. The two comparison values +are then one. Prime-to-$p$ operators preserve the lattice and +their comparison values for the same reason. + +Use the intersection of the classical cusp space with the +ordinary integral section module as its lattice. It is a full +bounded lattice and is saturated for divisibility by $p^M$: +its definition as an intersection makes this immediate. The +commuting integral operators generate an $\mathcal O_k$-algebra +$\mathbb T_i^0$ inside the endomorphisms of that lattice over +a finite model extension of $k$. This is a finite torsion-free +$\mathcal O_k$-order: the endomorphism lattice is finite over +$\mathcal O_k$, so its submodule generated by the operators is +finite. The scalar ring of the order is always $\mathcal O_k$; +only its rank and the field representing the lattice may vary +with $i$. Denote the lifted section by $\mathfrak s_i$. +If $P$ is any integral polynomial relation among these operators, +application to that section gives +\[ + P(\hbox{comparison values})\,\mathfrak s_i + \equiv0\pmod {p^{M_i}}. +\] +Every polynomial has this precision because all its operators +are integral. Evaluate a positive coefficient of valuation at +most $C$ from Lemma~\ref{extraction:content}. The scalar +$P(\hbox{comparison values})$ is divisible by $p^{M_i-C}$. +It lies in $k$, so the divisibility descends from the evaluation +field. This is the length-one version of content cancellation, +performed at $z_0$ itself. The initial clearing, $C$, and the +neat descent index are fixed; there is no other loss. Decrease +and relabel $M_i$, also slowing it so that every evaluated finite +group relation holds. The scalar evaluation factors through +the entire order, giving $\lambda_i^0$. Its local target selects +the residual local summand of that order, on which both +$\widetilde U_j$ are units. +\end{proof} + +\subsection{Local Galois controls and reduction of the order} + +The congruence now has to pass to actual cusp eigensystems. +We retain their local subquotients and inertia identities while +removing operator nilpotents, so that these identities survive +in the common limiting matrix algebra. + +Apply \cite[Proposition~8.5]{C} at each stage. Its hypotheses +are the group $\mathrm U(B+\mathbb H)$, discrete holomorphic +infinity of weight $\lambda'_i$ with the two sufficiently large +gaps, the indicated split levels, and hyperspecial level at +places nonsplit over $F$. These hold here. It supplies +semisimple four-dimensional representations $\rho_\pi$ with +\[ + \rho_\pi^c\simeq\rho_\pi^\vee\epsilon^{-3},\qquad + (h_1,h_2,h_3,h_4) + =(1-m_i-H_i,2-m_i-H_i,2-H_i,1+H_i) +\] +at a distinguished $p$-place. At split places their +Weil--Deligne parameters have the stated local Langlands +semisimplification and the monodromy upper bound of that +proposition. They are unramified at nonsplit finite places. +These are characteristic-zero statements at each individual +level. + +The positive Jacquet module at $J(s_i)$ allocates unramified +characters to its last two slots. If their Frobenius roots are +$\alpha_3,\alpha_4$, the normalizations just proved give +\[ + \widetilde U_2=p^{h_3+h_4}/(\alpha_3\alpha_4),\qquad + \widetilde U_3=p^{h_4}/\alpha_4. +\] +Their unit values give slopes $h_3,h_4$ for the allocated +roots. The other two slopes sum to $h_1+h_2$. The sum of the +lowest two slopes is at most this sum and, by weak admissibility, +at least $h_1+h_2$; equality gives the contact at dimension two. +The same argument with the other two roots and $\alpha_3$ +gives the contact at dimension three. The strict Hodge gaps +force strict Newton gaps at these contacts. On each low-slope +subspace the induced Hodge number is at least the sum of the +corresponding lowest Hodge weights and at most its Newton +number, so equality makes that subspace weakly admissible. +Its canonicity also retains the descent data after a +potentially semistable extension. Thus +\cite[Lemma~8.6]{C} gives +a stable flag of dimensions $2,3,4$ with last quotient +\[ + X_w=\epsilon^{-h_4}\operatorname{unr}(\widetilde U_3^{-1}) +\] +and, at the conjugate place, a first subline +$Y_{\bar w}=X_w^{-c}\epsilon^{-3}$. The character comparisons +hold on all local elements, uniformly, with limits +$x=\epsilon^{-1}$ and $y=\epsilon^{-2}$. This argument uses +the two full last unit factors of $J(s_i)$, its positive Jacquet +module, and the weight gaps; none depends on a bound for $s_i$. + +We also need binary projections when a Frobenius separation can +vanish at $z_0$. At a safe auxiliary good place use the full +resultant of \cite[equation~(8.10)]{C}, which excludes ratios by +$Q_v^d$, $|d|\leq4$, between the head and the final binary roots. +At an additive place choose an inertia element $\iota_v$ for +which both comparison head eigenvalues differ from one. Such +an element exists: elliptic semisimple inertia is nontrivial, +has determinant one, and is finite; in the ramified special +case use an element in the ramifying component. At a moving +place with nontrivial tested unit character choose a unit on +which it is nontrivial; both head eigenvalues on it are that +scalar. If the unit character is trivial use the Frobenius +separation retained by Lemma~\ref{theta:test-point}. + +For an inertia-tested place let $P_{v,\iota}(Z)$ be the full +degree-four characteristic polynomial. Its coefficients belong +to the operator order: good split Frobenius coefficients +approximate them simultaneously on the finitely many systems, +and the finite integral operator subalgebra is closed. Monic +division by $(Z-1)^2$ gives a quadratic $C_{v,\iota}$ in that +order; put $\Delta_v=C_{v,\iota}(1)$. On each actual system +the remainder is zero, since the allocated unramified final +Jacquet block supplies two inertia eigenvalues one. The tested +value of $\Delta_v$ is nonzero. Let $\Delta$ be the product of +these factors and the good-place resultants. + +\begin{lemma}[Binary separation at an inertia test] +\label{extraction:binary} +On an actual system with $\Delta_v\ne0$, the generalized +$1$-primary projection $P_v^{\mathrm{bin}}$ of +$\rho_\pi(\iota_v)$ is defined and satisfies +\[ + (\rho_\pi(\iota)-1)P_v^{\mathrm{bin}}=0 + \qquad(\iota\in I_v). +\] +Together with the Frobenius-separated projections, these identities +give an exponent $C_0$ independent of stage and depth for which +\[ + \Delta^{C_0}\ker(\mathbb T_i^0\longrightarrow\mathbb T_i)=0, +\] +where $\mathbb T_i$ is the image order in characteristic-zero +eigensystems. +\end{lemma} + +\begin{proof} +The chosen element has exactly two eigenvalues one, counted +with multiplicity. Both are already supplied by the final +unramified Jacquet block, so the complementary Weil positions +cannot contain any inertia-trivial constituent. Thus the +entire inertia-trivial Weil summand is this binary allocation. +An unramified norm twist does not change inertia, so no segment +can cross these allocations. The segment classification +therefore identifies the allocated final binary representation +with its unramified spherical block, whose predicted monodromy +is zero. It is necessary to check actual monodromy as well: +the Galois construction in the cited proposition is a direct sum +of shifted copies of the Galois representations of generic +unitary cuspidal factors. Inside one copy, the selected local +segments have length one; a longer segment would cross the +inertia separation or violate binary sphericity. Two such +unramified length-one data in a generic unitary factor have real +exponents in an interval of width strictly less than one, so +their quotient cannot be $Q_v$. Thus monodromy cannot link +them. It cannot link different copies, which are direct +summands, or link to the head, which is inertia-separated. +The selected subspace consequently has trivial actual inertia. +It has dimension two and is precisely the generalized +$1$-primary space of the chosen element, proving the identity. +The projection can be written explicitly. Suppress $v$ and +write $P_{\iota_v}(Z)=(Z-1)^2C(Z)$ and $\Delta_v=C(1)$. +The polynomial +\[ + E(Z)=C(Z)\bigl(\Delta_v^{-1} + -C'(1)\Delta_v^{-2}(Z-1)\bigr) +\] +is one modulo $(Z-1)^2$ and zero modulo $C(Z)$. +Consequently $P_v^{\mathrm{bin}}=E(\rho_\pi(\iota_v))$. +This gives an algebraic identity with only powers of +$\Delta_v$ in its denominator, suitable for passage to the +limiting corner algebra. The element $\iota_v$ need not +generate inertia. + +For the order, apply the geometric-lemma filtration on each +joint generalized controlled-operator space. There are at +most $4!$ allocation terms at each controlled place. Taking +the required compact Levi invariants and a generalized +eigenspace is exact in characteristic zero. At an +inertia-separated place the two final unramified inducing +positions are forced: no head position can occupy an +unramified slot, because its inertia eigenvalue on +$\iota_v$ differs from one. At a Frobenius-separated place +the resultants force the allocation. The full spherical +binary invariants are one-dimensional, so its two operators +are scalars on the surviving grade. At $p$ the two contacts +force the allocation to the $(2,1,1)$ Levi; both final center +operators are scalars there at every depth. Permutations +inside the head lie in the Levi Weyl group and do not create +additional grades. Hence the separated generalized space +has a single grade and no operator nilpotents. + +On a component where $\Delta$ has zero eigenvalue, it acts +as zero on every allocation grade and lowers this filtration. +The bounded number of control places therefore gives a fixed +power, for example the product of their bounds $24$, killing +that component. The good spherical algebra is already +semisimple; hence the kernel of eigensystem detection vanishes +on the separated components and is killed by this power on +the others. This is an operator identity in characteristic +zero, and the integral order is torsion-free. It therefore +holds in $\mathbb T_i^0$ itself. +\end{proof} + +The comparison values $\lambda_i^0(\Delta)$ have uniformly +bounded valuation, since they tend to the nonzero test values. +Cancellation in Lemma~\ref{extraction:binary} costs at most +$C_0v_p(\lambda_i^0(\Delta))$. After decreasing precision by +one constant we obtain +\begin{equation} + \lambda_i:\mathbb T_i\longrightarrow\mathcal O_k/(p^{M_i}), + \qquad M_i\longrightarrow\infty. +\label{extraction:reduced-orders} +\end{equation} +At a line-stabilizer parahoric the other local control is +$\rank(\rho_\pi(\iota)-1)\leq1$ and unipotent inertia. +Indeed a single-step flag can separate at most two positions +in a Steinberg block and at most one such block; its predicted +monodromy has rank at most one and square zero. The Galois +monodromy bound gives the same assertion for actual inertia. +This is also the proof of \cite[Lemma~8.8]{C}, for either orientation +of the line parahoric. + +\subsection{The limiting corners and the highest-weight line} + +The remaining task is to obtain a nonzero extension of the last +character by the elliptic constituent of the limiting +four-dimensional representation. We construct the corner +modules encoding these extensions and retain the local identities +just proved. + +We use the finite matrix construction of \cite[Section~9, +Lemmas~9.1--9.3]{C} over the field test, namely with +its Artin length equal to one. We record both its hypotheses +and the resulting objects. Put $B_i=\mathbb T_i[\rho_i]$, where +$\rho_i$ is the product of all characteristic-zero systems and +stable integral lattices are chosen. Characteristic coefficients +of all Galois elements lie in $\mathbb T_i$. The residual +coefficient-prime characteristic polynomials are fixed: reduction +kills every varying group character and every weight-branch +difference. The ramified supports have bounded cardinality. +After one fixed extension killing the residual semisimplification, +the images are pro-$p$; the global class-field bound for their +number of generators depends on the fixed extension and number +of support places, not their depths. Cayley--Hamilton together +with the polynomial-identity bound for four-by-four matrices +therefore gives a fixed number of monomials generating $B_i$ +over $\mathbb T_i$. + +Let $\mathcal A=\prod_{\mathcal U}\mathbb T_i$ and let +$\mathfrak q$ be the kernel of the compact limit +$\mathcal A\to\mathcal O_k$ furnished by +\eqref{extraction:reduced-orders}. Set +\[ + \mathscr T=(\mathcal A_{\mathfrak q})^h, + \qquad \lambda:\mathscr T\longrightarrow k, + \qquad \mathscr B=(\prod_{\mathcal U}B_i)\otimes_{\mathcal A}\mathscr T. +\] +The ring $\mathscr T$ has residue field $k$: its construction +inverts every nonzero constant in $\mathcal O_k$. Define +\[ + \mathscr D_0=\prod_{\mathcal U}\prod_{\pi\text{ at stage }i} + \overline{\Q}_p, + \qquad + \mathscr D=\mathscr D_0\otimes_{\mathcal A}\mathscr T. +\] +The embeddings $\mathcal A\hookrightarrow\mathscr D_0$ and +$\prod_{\mathcal U}B_i\hookrightarrow M_4(\mathscr D_0)$ +remain injective under the flat localization and henselization. +Thus $\mathscr T\hookrightarrow\mathscr D$ and +$\mathscr B\hookrightarrow M_4(\mathscr D)$ are faithful. +The first ring $\mathscr D_0$ is absolutely flat and reduced; +localization and etale base change preserve these properties, +so $\mathscr D$ is also absolutely flat and reduced. Its +field evaluations are realized in algebraically closed residue +ultraproducts of the actual systems, with ultrafilters prolonging +$\mathcal U$. The finite etale choices split in those fields. +These are the ambient realization statements of +\cite[Section~9.1]{C}. +The limiting diagonal blocks are +\begin{equation} + f=V(-2)\chi^{\pm1},\qquad + x=\epsilon^{-1},\qquad y=\epsilon^{-2}. +\label{extraction:blocks} +\end{equation} +Here and below $\chi$ is restricted to $G_L$. These identities +hold on all sequences of group elements: the theta polynomial +comparison holds at split good Frobenius elements, +$\mathcal C^{m_i}$ tends uniformly to one, and at each stage +Frobenius approximation can be taken more accurate than the +chosen precision. The blocks are absolutely simple and +pairwise distinct; the simplicity of $V|_{G_L}$ was part of +the auxiliary-field choice. +Write $\rho_*$ for the representation in $\mathscr B$ induced +by the arrays $\rho_i$, on the ultraproduct of the stage Galois +groups with their marked local subgroups. + +The desired coefficient is $\Hom(y,f)=V\chi^{\pm1}$. +The direct corner from $y$ to $f$ must be nonzero, while paths +through $x$ must not obstruct the triangular quotient. This +explains the order of the next two lemmas: eliminate the +cyclotomic $y$-to-$x$ extension, then force the $y$-to-$f$ +corner to be nonzero by its highest Hodge weight. + +The perfect trace pairing on $M_2(k)\times k\times k$ makes +this diagonal representation factor through $\mathscr B$. +Lift the four orthogonal rank-one idempotents by henselian +factorization of an element with four distinct residual +eigenvalues, and lift the inverse matrix units identifying +the two $f$ positions. For $u,v\in\{f,x,y\}$ let $D_{uv}$ +be the finite $\mathscr T$-module of a single-entry corner +from $v$ to $u$. Diagonal corners are $\mathscr T$, and +\begin{equation} + \lambda(D_{uv}D_{vu})=0\quad(u\ne v). +\label{extraction:cycles} +\end{equation} +The corner-minor lemma transports a zero determinant of +stacked matrices to the corresponding corner identity: in +each determinant monomial its directed edges decompose into +one path from the surplus column to the surplus row and +diagonal cycles. This description also covers two-by-two +minors and is preserved under an algebra map from +$\mathscr B$. + +An algebra map from $\mathscr B$ to matrices over $k$ gives +admissible cochains. Indeed its values on the fixed finite +monomial generators have one common denominator. Choose +coefficient expressions on the finite quotients of $B_i$, +apply $\lambda_i$, and approximate those fixed matrix values. +This gives continuous matrix functions with increasing uniform +precision and that one denominator. A relation valid on +all sequences is uniformly valid to increasing precision; +otherwise a violating sequence contradicts it. The same +argument applies to local splittings. + +We need the comparison in the direction from these admissible +cochains to the finite models, not only detection of model +classes by evaluations. Use the integral contractions +$I_i,Q_i,H_i$ of Lemma~\ref{models:finite-models}, with +$Q_iI_i=1$ and +$1-I_iQ_i=dH_i+H_id$, after the evaluated coefficient base +change modulo the current precision. Clear the one fixed +denominator in an admissible cocycle $c_i$. Its cocycle +defect tends uniformly to zero, so $Q_ic_i$ is a model +cocycle to the same increasing precision. The model has +bounded finite rank over the compact coefficient quotients; +passing to its coefficient limits gives an actual cocycle +over $k$. The homotopy identity shows that its image under +$I_i$ differs from $c_i$ by the coboundary $dH_ic_i$ and an +error tending to zero. It therefore represents the original +admissible class. If the model class were a coboundary, its +image would be an admissible coboundary by the same identity. +Apply the construction to the marked global-local cone, +including its local splitting coordinates. Its restriction +homotopies preserve every specified local condition. This +proves the required identification with the field tests. +Thus no bounded local index is an +extra hypothesis of this use of the cited matrix lemmas. + +\begin{lemma}[The cyclotomic corner] +\label{extraction:cyclotomic} +The corner modules satisfy $D_{xy}=D_{xf}D_{fy}$. +\end{lemma} + +\begin{proof} +Let $Q=D_{xy}/(D_{xf}D_{fy}+\mathfrak mD_{xy})$, where +$\mathfrak m=\ker\lambda$. A functional $Q\to k$ gives +an extension of $y$ by $x$ with a separate $f$ block; all +discarded products vanish by \eqref{extraction:cycles} and +the definition of $Q$. If its Galois class splits, the +splitting is preserved by the algebra generated by the +group, hence by the corner idempotents, and the functional +is zero. We thus obtain an injection into admissible +$H^1(L,k(1))$. + +At $\bar w$, stack the matrices +$\rho_*(g)-Y_{\bar w}(g)$. Their common kernel makes every +four-row determinant zero. The vanishing of +$\Hom_{G_{L_{\bar w}}}(y,f)$ at $z_0$ and $x\ne y$ +supplies three rows with an invertible minor on the competing +columns $f_1,f_2,x$. Matrix units allow either $f$ coordinate +to be used in either of the two output rows. Solve these +three equations with $y$ coordinate one. Each remaining +equation follows from its vanishing four-row corner minor. +This gives a local $y$-eigenline, hence a splitting. At $w$ +apply the transposed argument to the common quotient $X_w$; +the competing minor uses +$\Hom_{G_{L_w}}(f,x)=0$. These are exactly the local +invariant conditions retained in Lemma~\ref{theta:test-point}. +The extension is therefore strict at every place above $p$. + +At a binary place the projection of +Lemma~\ref{extraction:binary}, or its Frobenius version, +is the identity on the $x,y$ extension and makes inertia +trivial there. At a parahoric place its two-by-two minors +give $(f(\iota)-1)_{ab}u(\iota)=0$ for every entry, where +$u$ is the cyclotomic extension entry. Some elliptic +inertia difference is nonzero. Hence $u(\iota)=0$ whenever +that difference is nonzero; multiplying an element in its +kernel by a fixed element outside the kernel and using the +cocycle law gives zero there too. Elsewhere hyperspecial +unramifiedness applies. In particular the class is +unramified at the moving places and descends by the +admissible comparison to the fixed field $L$. + +Kummer theory identifies the resulting group with $p$-units +tensored with $k$, with zero valuations and logarithms at +all $p$-places. Zero valuations leave the global units. +The CM biquadratic field $L$ has unit rank one. A nontrivial +fundamental unit has nonzero $p$-adic logarithm at a split +$p$-place: a unit of $\Q_p$ with zero logarithm is a root +of unity, and the field embedding is injective. Thus this +one-dimensional space has no element with all local +logarithms zero. The extension vanishes, so $Q=0$. +Nakayama for the finite module $D_{xy}/D_{xf}D_{fy}$ proves +the assertion. +\end{proof} + +\begin{lemma}[Exclusion of the last stable line at arbitrary depth] +\label{extraction:no-line} +The image of $D_{fy}$ is nonzero in every characteristic-zero +field evaluation of the ambient ring. Consequently +$\operatorname{Fitt}_{0,\mathscr T}(D_{fy})=0$. +\end{lemma} + +\begin{proof} +If $D_{fy}$ vanished at such a field, then +Lemma~\ref{extraction:cyclotomic} would make $D_{xy}$ vanish +there as well. The last idempotent line would be globally +stable. The competing-column minor used at $\bar w$ is +a unit in $\mathscr T$. In a matrix with this last line +stable its upper-right column is zero. The common +$Y_{\bar w}$ kernel, with this competing minor invertible, +must therefore be the last line, so its character is +$Y_{\bar w}$. + +These finite matrix relations pass to a filter-large set of +actual systems, as in \cite[proof of Lemma~9.5]{C}. More explicitly, +stability uses only the bounded algebra generators; the +idempotent, matrix-unit, and competing-minor relations use +finitely many further matrices. The algebraically closed +residue ultraproduct realizes the henselian choices, so their +finite equalities and inequalities hold on actual systems. +Thus each such system has a global one-dimensional +constituent $\xi$ restricting to $Y_{\bar w}$. + +The character $\xi$ is de Rham and hence an algebraic Hecke +character. Its conjugate weight sums are parallel, by the +relation on the units of the real subfield. Its weight at +$\bar w$ is $3-h_4$, the isolated lowest weight. In the +construction of the Galois package it cannot belong to a +factor of Arthur length greater than one: successive +copies would also supply an adjacent integer weight, +whereas the next weight is separated by $h_4-h_3$. +Thus its factor has length one. The strict unitary generic +bounds on the unramified cuspidal roots place its absolute +Frobenius size strictly between $Q$ and $Q^2$ after the +cohomological shift. A character of parallel conjugate +weight sum $j\in\Z$ has size $Q^{j/2}$, so $j=3$. + +In particular the weight of $\xi$ at $w$ is $h_4$. +Let $F_3\rho_\pi$ be the rank-three local subrepresentation +at the second Hodge--Newton contact. Its weights are +$h_1,h_2,h_3$, so the $\xi$ line cannot be contained in it: +the de Rham functor is exact and a subrepresentation's +weights occur in this multiset. Its map to +$\rho_\pi/F_3\rho_\pi=X_w$ is therefore nonzero, and is an +isomorphism of characters. This identifies the entire +local character of $\xi$ at $w$, including its smooth +factor, without a bound on conductor. For every local +$g$ we now have the exact identity +\[ + \xi(g)\xi(g^c) + =X_w(g)Y_{\bar w}(g^c)=\epsilon(g)^{-3}. +\] + +Choose one fixed inertia element $g$ with $\epsilon(g)$ +nontorsion and include $g,g^c$ in the finite matrix list. +The preceding identity makes +\[ + (e_y\rho_*(g)e_y)(e_y\rho_*(g^c)e_y) + -\epsilon(g)^{-3}e_y +\] +zero in the field evaluation. It is, however, a unit in +$\mathscr T e_y$: its residue under $\lambda$ is +$(\epsilon(g)^{-4}-\epsilon(g)^{-3})e_y\ne0$. +This contradiction proves the nonvanishing of $D_{fy}$. +An element annihilating $D_{fy}$ consequently vanishes in +every ambient field, hence is zero by reducedness and +faithfulness. The zeroth Fitting ideal of a finite module +is contained in its annihilator by the adjugate identity. +This proves its asserted vanishing. +\end{proof} + +\subsection{The extracted class is primitive} + +Put $M=D_{fy}\otimes_{\mathscr T,\lambda}k$. Fitting ideals +commute with base change, so Lemma~\ref{extraction:no-line} +gives $M\ne0$. A nonzero functional $M\to k$ defines an +extension of $y$ by $f$, keeping $x$ as a separate block. +The only additional path relation is respected because +\[ + D_{fx}D_{xy}=D_{fx}D_{xf}D_{fy} +\] +and the first two factors on the right are a crossing +cycle, killed by \eqref{extraction:cycles}. The other +discarded products are killed by the diagonal +representation or the same cycle identity. Thus this is +an algebra representation and yields a nonzero admissible +class with coefficients +\[ + \Hom(y,f)=V\chi^{\pm1}. +\] +Nonzeroness follows as in Lemma~\ref{extraction:cyclotomic}: +a Galois splitting would be preserved by the full algebra +and its idempotents, forcing the functional to be zero. +The common-kernel argument with rows of types $f,f,x,f$ +and the same invertible competing minor makes this +extension split at every conjugate $p$-place. It has the +full condition at the other half of the $p$-places. + +It remains to check unramifiedness at fixed bad places; +this is stronger than the relaxed conclusion used in +\cite[Proposition~9.7]{C}. At a binary-controlled +place the separated projection is an inertia-fixed +projection whose image maps identically to the $y$ +quotient. Apply it to any lift of that quotient to obtain +an inertia-fixed lift. The extension class is therefore +unramified there. + +At an unramified-twist Steinberg place write the extracted +inertia matrix, after twisting by $y^{-1}$, as +\[ + \begin{pmatrix}F(\iota)&c(\iota)\\0&1\end{pmatrix}. +\] +Here $F=V\chi^{\pm1}$ has its fixed elliptic unipotent +inertia, since the scalar is unramified at this fixed place. +The two-by-two minors on the $f$ rows and the $f,y$ columns +vanish by the parahoric rank bound and the corner-minor +identity. Consequently $c(\iota)$ belongs to +$\im(F(\iota)-1)$ whenever $F(\iota)\ne1$. +Write $F(\iota)=1+t_p(\iota)N$, where $N\ne0$ has rank +one and $N^2=0$. Its image $\ell$ is fixed by inertia. +Choose $h$ with $t_p(h)\ne0$. If $t_p(\iota)=0$, apply +the already proved assertion to $\iota h$ and $h$; +the cocycle law gives $c(\iota)\in\ell$. Hence all values +of $c$ lie in $\ell$, and $c$ is an additive continuous +homomorphism from inertia to $\ell$. In residue +characteristic different from $p$, every such homomorphism +factors through the one-dimensional tame pro-$p$ quotient. +Thus $c(\iota)=t_p(\iota)v$ for some $v\in\ell$. +Choose $b$ with $Nb=v$. Then +$c(\iota)=(F(\iota)-1)b$, an inertia coboundary. +The fixed-local admissible comparison supplies an ordinary +continuous representative, and changing that representative +by a coboundary preserves the argument. At the other fixed +places hyperspecial unramifiedness applies. At moving +places retain the allowed full conditions. + +Finally descend from $L$ to $K$. Since $[L:K]=2$ is +invertible in $k$, induction gives +\[ + \operatorname{Ind}_{G_L}^{G_K}(V\chi^{\pm1}|_{G_L}) + \simeq V\chi^{\pm1}\oplus V'\chi^{\pm1}. +\] +This is an isomorphism of the marked local diagrams. The +strict half of the $p$-places descends from $K$; the full +half does also. At a fixed non-$p$ place, restriction to +a finite-index inertia subgroup detects unramifiedness in +characteristic zero: restriction followed by corestriction +is multiplication by its nonzero index. Unramified +inflation contracts any superfluous fixed support. +The same identities pass to our admissible cochains and +finite models. Applying Shapiro's lemma stagewise and then +passing through the marked comparisons therefore decomposes the +nonzero extracted class into the two primitive one-sided +field tests for $V,V'$; at least one component is nonzero. +If the inverse scalar occurs, complex conjugation identifies +this group with the $\chi$ group on the opposite side, as +fixed in Section~\ref{sec:theta}. This contradicts the +choice of $z_0$ and proves +Proposition~\ref{extraction:theta-implication}. diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/09-unit.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/09-unit.tex new file mode 100644 index 0000000000000000000000000000000000000000..eec9dab63d73e495d39dd689f6f553d26ad5598e --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/09-unit.tex @@ -0,0 +1,449 @@ +\section{Removing the divisors of the integral quotient}\label{sec:unit} + +Fix the odd prime $p$ and the auxiliary fields of +Lemma~\ref{classical:auxiliary-fields}. The integral quotients constructed +in Section~\ref{sec:pair} are +\[ + R=\Z_p[[t,u_1,\ldots,u_d]],\qquad U_w=B_w/L_w\in R, + \qquad w\in\{\mathfrak p,\bar{\mathfrak p}\}. +\] +Here $t$ is the true anticyclotomic parameter. We use the descended +generators of the analytic ideals; changing a descent generator changes +these expressions only by a unit. The purpose of this section is to +prove that $U_w$ is a unit. The distinction between integrality and +being a unit is essential: the former has been proved by high finite +character tests, whereas the latter requires the theta implication of +Proposition~\ref{extraction:theta-implication}. + +Write $V_0=V_pE$ and $V_1=V_p(E^{D'})$. For a horizontal prime +$\mathfrak q$ of $R$, meaning a height-one prime different from $(p)$, +let $C^{\rm pr}_{a,J}$ denote the following complex over $R_{\mathfrak q}$: +the coefficient is $V_a\chi$, the condition at every fixed non-$p$ +place is unramified, the condition at a moving place is full, and the +condition at a $p$-place is strict if it belongs to +$J\subseteq\{\mathfrak p,\bar{\mathfrak p}\}$ and full otherwise. +Unramified conditions here include their degree-zero terms. They are +the exact complementary complexes of Section~\ref{sec:models}, not +merely subspaces of rational degree-one cohomology. We call a nonzero +degree-one cohomology group on a field fiber a \emph{jump}. Thus +$C^{\rm pr}_{a,\varnothing}$ and +$C^{\rm pr}_{a,\{\mathfrak p,\bar{\mathfrak p}\}}$ are respectively the +both-full and both-strict complexes. + +\subsection{Which divisors can occur?} + +We first relate quotient divisors to jumps. This also supplies the +regularity needed to use finite characters of the true parameter. + +\begin{lemma}\label{unit:quotient-regularity} +At a horizontal height-one prime the primitive one-sided complexes are +perfect of amplitude $[1,2]$ and Euler characteristic zero. If +$M_{a,w}$ is the determinant of their differential, then +\[ + L_{0,w}=D_0M_{0,w},\qquad L_{1,w}=D_1M_{1,w} +\] +up to units in the testing DVR. Here $L_{0,w}=L_w$, $L_{1,w}=L'_w$, +and $D_a$ is the product of the singular Euler determinants at the +fixed non-$p$ places. Every irreducible divisor of either $U_w$ is +horizontal and has nonzero reduction modulo $(p,t)$. +\end{lemma} + +\begin{proof} +The local invariant tests can be checked before replacing the fixed +conditions. At a $p$-place, an inertia element with nonzero true +exponent gives an equation in $t$ for any invariant vector. A +Frobenius lift gives a second equation with a nonzero exponent vector +in the artificial variables. No height-one prime can contain both +equations. This applies to the coefficient and its dual, so local +$H^0$ and $H^2$ vanish. At a moving prime, inertia makes the complex +acyclic unless its own variable is zero. On that divisor the +Frobenius determinant is nonzero: setting all parameters to zero +gives the chosen Tate action without eigenvalue one. Hence the +moving local complexes are acyclic on every horizontal height-one +test. Global invariants vanish because the untwisted planes are +absolutely simple and a scalar twist cannot create a stable line. + +The unramified complexes at the remaining places include $H^0$ and +are exact complements under duality. The same holds at the +companion's nonsplit ramified places, where the inertia invariants +are zero. The invariant vanishings, Poitou--Tate duality, and Euler +characteristic calculation therefore give the asserted amplitude +and equal ranks. The localization triangles identify the quotient +of a full fixed-place condition by its unramified condition with +residue cochains on inertia coinvariants, twisted by $(-1)$ and +shifted to degrees $1,2$. Its determinant is the corresponding +Euler factor. Multiplication of determinant lines gives the two +displayed identities. In particular $v_{\mathfrak q}(M_{a,w})\geq0$, +and $M_{a,w}$ vanishes on the field fiber exactly when that +one-sided complex jumps. + +By \eqref{eq:source-11}, at this DVR +\[ + U_w=\text{unit}\cdot (b_w^0)^2/M_{0,w}. +\] +Consequently $v_{\mathfrak q}(U_w)>0$ implies +$v_{\mathfrak q}(b_w^0)>0$, even when $D_0$ also vanishes. +Proposition~\ref{extraction:theta-implication} then gives a one-sided +jump for one of the two representations. Thus $\mathfrak q$ divides +one of $L_{0,\mathfrak p},L_{0,\bar{\mathfrak p}}, +L_{1,\mathfrak p},L_{1,\bar{\mathfrak p}}$. +Each of these determinants has nonzero reduction modulo $(p,t)$ by +\eqref{eq:source-1}. A factor of such a determinant also has nonzero +reduction modulo $(p,t)$, since $R/(p,t)$ is a domain. +Finally $p\nmid B_w$ by \eqref{eq:source-14}; integrality of $U_w$ +and $B_w=L_wU_w$ imply $p\nmid U_w$. +\end{proof} + +\begin{lemma}[Equality of the two quotient ideals]\label{unit:association} +For every auxiliary tuple satisfying the preceding requirements, +\begin{equation} + (U_w)=(U_{\bar w}) + \tag{17}\label{eq:source-17} +\end{equation} +in $R$. +\end{lemma} + +\begin{proof} +The preceding lemma and factoriality show that $U_w$ has nonzero +reduction modulo $(p,t)$: it is a unit times a finite product of +factors with that property. The same is true for $U_{\bar w}$. +Proposition~\ref{pair:finite-divisibility} says that their +specializations at every sufficiently high finite $p$-power +character of $t$ are associates after inverting $p$ and extending +the constants. + +Both quotients are bounded integral series, so the regularity +just verified is precisely the hypothesis of +Lemma~\ref{models:series-division}. Apply it first with +$(L,B)=(U_w,U_{\bar w})$ and then with the two interchanged. +The characterwise association supplies divisibility, with all +multiplicities, in each application. The constant extension is +faithfully flat; equivalently the integral Weierstrass remainder +in that lemma vanishes after extension and hence before it. +We obtain $U_w\mid U_{\bar w}$ and $U_{\bar w}\mid U_w$ in $R$. +Mutual divisibility in this domain proves \eqref{eq:source-17}. +\end{proof} + +\subsection{The algebra of simultaneous jumps} + +We will add finitely many tame variables. Their first-order cup +tests detect liftability of classes. The following algebra explains +why the available tests exclude a divisor, rather than merely a +generic jump. We prove the augmented alternating-matrix and tangent-minor +lemmas, as well as the simultaneous version needed for the two elliptic +representations. + +\begin{lemma}[Augmented alternating matrices]\label{unit:augmented-alternating} +Let $k$ have characteristic zero and let $s\geq1$. On +\[ + W_s=\operatorname{Alt}_s(k)\oplus\operatorname{Mat}_{s,2}(k) +\] +the locus where $[A\mid B]$ has rank less than $s$ has codimension +at least two. If $s_0,s_1$ are positive even integers, the locus +\[ + \{(A_0,A_1):\det A_0=\det A_1=0\} + \subseteq\operatorname{Alt}_{s_0}(k)\oplus + \operatorname{Alt}_{s_1}(k) +\] +also has codimension at least two. +\end{lemma} + +\begin{proof} +For the first assertion introduce $[v]\in\mathbf P^{s-1}$ and +impose $v^{\mathsf t}A=0$ and $v^{\mathsf t}B=0$. For fixed $[v]$ +these are $(s-1)+2$ independent linear conditions: after a change +of basis they are the nontrivial entries of the first row of $A$ +and the two entries of the first row of $B$. If $N=\dim W_s$, +the incidence variety has dimension $N-2$. Projection from its +projective factor is proper and its image is exactly the +rank-defect locus, which proves the assertion. + +For a positive even size the determinant of an alternating matrix +is a nonzero nonconstant polynomial: it vanishes at zero and is +nonzero on a block diagonal matrix with blocks +$\left(\begin{smallmatrix}0&1\\-1&0\end{smallmatrix}\right)$. +Its zero locus is therefore a hypersurface. The two loci in the +second assertion involve disjoint coordinate sets; their product +has codimension two. +\end{proof} + +\begin{lemma}[First-order tests and formal codimension]\label{unit:tangent-minors} +Let $(A,\mathfrak m,k)$ be a regular local ring with +$\operatorname{char}k=0$. Let $D:A^s\to A^r$, $r\geq s\geq1$, +have entries in $\mathfrak m$, and let $D_1$ be its linear part on +the tangent space $T_A=\Hom_k(\mathfrak m/\mathfrak m^2,k)$. +Suppose there is a linear injection $\iota:W_s\to T_A$ such that, +over every extension field $k'/k$, +\[ + \ker D_1(\iota(A_0,B)) + \subseteq\ker[A_0\mid B]^{\mathsf t}. +\] +Then the maximal-minor ideal $I_s(D)$ has height at least two. + +There is also a simultaneous version. Let $D_a:A^{s_a}\to A^{r_a}$, +$r_a\geq s_a>0$, for $a=0,1$, have zero residue, with $s_a$ even. +Suppose a linear injection +\[ + \iota:\operatorname{Alt}_{s_0}(k)\oplus + \operatorname{Alt}_{s_1}(k)\longrightarrow T_A +\] +satisfies, for every extension $k'/k$, every $(A_0,A_1)$ over +$k'$, and each $a=0,1$, +\[ + \ker\bigl((D_a)_1(\iota(A_0,A_1))\bigr)\subseteq\ker A_a. +\] +Then $I_{s_0}(D_0)+I_{s_1}(D_1)$ has height at least two. +\end{lemma} + +\begin{proof} +In the first case the rank-defect locus on the slice is contained +in the locus of Lemma~\ref{unit:augmented-alternating}. The full +tangent rank-defect locus is a homogeneous closed cone. A +codimension-one component, after algebraic closure of $k$, would +have a nonconstant homogeneous defining polynomial $h$. Its +restriction to the slice is either zero, in which case the entire +slice lies in the rank-defect locus, or is homogeneous of positive +degree, in which case a hypersurface of the slice lies there. +Both conclusions contradict the codimension-two bound on the +slice. The tangent rank-defect locus thus has codimension at least +two. + +Each nonzero maximal minor of $D_1$ is the degree-$s$ initial form +of the corresponding minor of $D$. Hence +\[ + I_s(D_1)\subseteq\operatorname{in}_{\mathfrak m} I_s(D). +\] +The associated graded ring of $A$ is a polynomial ring over $k$, +and passage to the initial ideal preserves the dimension of the +quotient. The asserted height bound follows. + +For the simultaneous assertion use the closed cone defined by the +sum of the two tangent minor ideals. Its intersection with the +slice is contained in the simultaneous alternating-defect locus, +which has codimension two by the second part of +Lemma~\ref{unit:augmented-alternating}. The same homogeneous +restriction argument applies. Initial forms of the minors of +each size lie in the initial ideal of the sum, so the same +dimension argument proves the simultaneous assertion. +\end{proof} + +\subsection{Adding directions at the possible divisors} + +There are only finitely many irreducible factors of $U_wU_{\bar w}$. +For each corresponding old horizontal prime $\mathfrak q$, write +$k_{\mathfrak q}=\Frac(R/\mathfrak q)$. We now apply the arithmetic +direction construction to these finitely many fields. The +new variables will be denoted $y_1,\ldots,y_n$, and +$S=R[[y_1,\ldots,y_n]]$. +For any such enlarged tuple, form its marked global and local +models over $S$. Over +$A_{\mathfrak q}=S_{(\mathfrak q,\mathbf y)}$ replace the fixed +non-$p$ conditions by the unramified complexes, using the +constant inertia action and varying unramified scalar. This +defines complexes $\widetilde C^{\rm pr}_{a,J}$ over +$A_{\mathfrak q}$ with exactly the same conditions as +$C^{\rm pr}_{a,J}$ above. In what follows their jump loci mean +the loci where $H^1$ of the derived field fiber is nonzero. +For the one-sided and both-strict complexes used below, amplitude +$[1,2]$ and nonnegative Euler characteristic identify these with +the closed loci defined by maximal minors of the degree-one +differential. + +\begin{proposition}\label{unit:simultaneous-jumps} +The new tame directions can be chosen so that, for every such +$\mathfrak q$, the following two loci have codimension at least two +in $\Spec S_{(\mathfrak q,\mathbf y)}$: +\begin{enumerate} +\item the locus where both one-sided primitive complexes for a +single representation jump; +\item for each allocation of sides, the locus where one one-sided +primitive complex for each of $V_0,V_1$ jumps. +\end{enumerate} +The old complexes are recovered on setting $\mathbf y=0$, and +the determinant and analytic specialization identities of +Lemma~\ref{pair:trace} remain integral identities up to units. +\end{proposition} + +\begin{proof} +There are finitely many old tests, the tuple satisfies +\eqref{eq:source-1}(b), and at least two independent old inertia +variables remain. These are the hypotheses of +Lemma~\ref{vertical:horizontal-directions}. Apply that lemma to +both representations and all old tests. It makes each new prime +Frobenius-acyclic at every test, retains a nonzero old exponent at +that prime, and preserves the Tate, weight, radical, and fixed +theta prescriptions. Its construction also shows that at least +one old inertia scalar has infinite order at each test; we use +that scalar in the evaluation argument below. + +The new logarithms are zero at the old support, including the old +moving primes. Unramified inflation and the marked comparisons +of Lemma~\ref{models:finite-models} identify the specialized +complexes with the old ones. The same comparisons hold after +localization at $(\mathfrak q,\mathbf y)$ and at all its +generizations. All local conditions remain exact complements; +in particular the unramified fixed-place comparisons retain +their cup nullhomotopies. Their perfect complexes have the +amplitudes used below. + +For one representation, the conjugate self-duality and +Lemma~\ref{vertical:parity} make a minimal one-sided differential +alternating. Its generic fiber is acyclic by +\eqref{eq:source-1}. It follows that every one-sided jump has even +dimension. If the both-strict degree-one dimension on a field +fiber is $s$, duality and Euler characteristic make the both-full +dimension $s+2$. The two one-sided spaces embed in the both-full +space and have intersection the both-strict space. In particular, +if $s=0$ they cannot both be nonzero: each would have dimension at +least two inside a two-dimensional space, and their intersection +would then be nonzero. Thus the locus in assertion (1) is +contained in the both-strict jump locus. + +At the old field $k_{\mathfrak q}$ let $x_1,\ldots,x_s$ be a basis +of the both-strict space and let $d_1,\ldots,d_{s+2}$ be a basis +of the conjugate both-full space, with the first $s$ vectors +corresponding to the conjugates of the $x_i$. Scalar localization +in degree two is injective by the scalar models of +Section~\ref{sec:vertical}. We can therefore form the cup +primitives used in Lemma~\ref{vertical:lift-test}. For a new +direction $\lambda$, a first-order correction $x^{(1)}$ to $x$ must +satisfy $dx^{(1)}=-\lambda\cup x$. Pairing with $d$ and applying the +transferred invariant sum gives the Frobenius test of that lemma. +At old places $\lambda=0$. At another new prime $\lambda$ is +unramified; after the local acyclic trivialization both factors +are unramified, and their invariant cup is zero. Thus these tests +add linearly when several new directions are used. + +For completeness, their span has precisely the form needed in +Lemma~\ref{unit:tangent-minors}. On the termwise joint kernel of +the Tate and old character actions, the evaluations of the +$x_i,d_j$ are additive and detect their classes by +Lemma~\ref{models:evaluations}. The absolutely simple coefficient +planes with opposite scalar twists are nonisomorphic, as detected +on the infinite-order old inertia scalar. Joint evaluations +therefore span the full tuples. Multiplying a Frobenius address +by a commutator $[v,v']$ in this kernel preserves its Tate and old +character values and all radical prescriptions, since its action +on the radical extension is abelian. The cup-primitive value +changes by +\[ + -e(x(v),d(v'))+e(x(v'),d(v)), +\] +with the conjugate expression subtracted at the other prime. +Elementary evaluation pairs consequently span all skew entries +in the first $s$ columns and all entries in the last two columns. +This is the space $[A\mid B]$ of +Lemma~\ref{unit:augmented-alternating}. Finitely many addresses +suffice; finite-precision Chebotarev realizes them with the old +markings retained, as proved in +Lemma~\ref{vertical:obstruction-span}. + +Put $A=A_{\mathfrak q}=S_{(\mathfrak q,\mathbf y)}$; this is +regular local with residue field $k_{\mathfrak q}$ of +characteristic zero. Cancel the invertible differential blocks +there. The both-strict model becomes +$D:A^s\to A^{s+2}$ with zero residue. A vector in the kernel of +its first-order differential is a liftable class and hence is +annihilated by the cup tests. Choosing a linear section of their +span gives the injected tangent slice in +Lemma~\ref{unit:tangent-minors}. The identities are identities of +finite matrices, so this kernel inclusion persists over every +extension of $k_{\mathfrak q}$. That lemma proves codimension at +least two. If $s=0$, the minimal degree-one term is zero and +there is no jump in this local spectrum. This proves assertion +(1). + +For assertion (2) use the two indicated one-sided spaces, of +dimensions $s_0,s_1$. If either is zero there is again no joint +jump in the local spectrum. Otherwise both dimensions are even. +The four coefficient planes, consisting of each representation +with each of the two opposite scalar twists, are pairwise +nonisomorphic. Opposite twists are distinguished by old inertia. +For the remaining comparison, $V_0|_{G_L}$ is absolutely simple. +An isomorphism $V_0\simeq V_0\otimes\chi_{L/K}$ would restrict to +a scalar on $G_L$ by Schur's lemma, and its intertwining equation +on the other coset would say that a nonzero scalar equals its +negative. Such an isomorphism is impossible. This also applies +to the twisted planes. + +Joint evaluation spanning and the same commutator calculation +therefore provide an independent slice +$\operatorname{Alt}_{s_0}\oplus\operatorname{Alt}_{s_1}$ for the +two one-sided differentials. Apply the simultaneous part of +Lemma~\ref{unit:tangent-minors}. It gives codimension at least two +for the joint jump locus, proving assertion (2). + +Finally take the union of the finite direction lists for every +old test and every allocation of sides. Every new prime was +made acyclic at every test. Hence adjoining another list changes +none of the old field spaces, and the vanishing of the cross-prime +invariants proved above preserves each list's tangent slice. +This proves the simultaneous assertion. The nonzero old exponent +also preserves \eqref{eq:source-1} after adjoining a prime: on +$\mathbf y=0$ its singular determinant is nonzero modulo $(p,t)$. +The remaining tuple prescriptions, including the fixed theta +tests, were retained in the finite tables. The exact norm and +localization identities of Lemma~\ref{pair:trace} therefore +apply to the enlarged tuple. +\end{proof} + +\subsection{The integral unit comparison} + +We can now exclude every factor, including factors whose high +finite-character specializations are units. The argument uses +specialization in the new tame variables over $\Z_p$. + +\begin{theorem}\label{unit:unit-comparison} +The two quotients $U_w$ are units. Their specialization with all +artificial variables zero gives an integral unit comparison +between the analytic series and strict determinant on the true +anticyclotomic line. +\end{theorem} + +\begin{proof} +Choose the enlargement in Proposition~\ref{unit:simultaneous-jumps} +and put tildes on its quotients. By +Corollary~\ref{pair:integral-quotient}, +\[ + \widetilde U_w(t,\mathbf u,0) + =\varepsilon_w(t,\mathbf u)U_w(t,\mathbf u), + \qquad \varepsilon_w\in R^\times. +\] +Indeed both numerator and denominator acquire the same square +of each factor in \eqref{eq:source-13}. Those factors are nonzero; +cancellation in the fraction field proves the identity, and +the marked integral determinant triangles make $\varepsilon_w$ +an integral unit. + +Suppose an irreducible $F$ divided one enlarged quotient. It is +horizontal by Lemma~\ref{unit:quotient-regularity}. Its +specialization $F_0=F(t,\mathbf u,0)$ is nonzero, since it divides +the nonzero specialized quotient. It is a nonunit: a unit +specialization would give a unit constant term of $F$ in the +local ring $S$. Choose an irreducible factor $f$ of $F_0$ in +$R$. The displayed identity makes $f$ an old quotient divisor; +in particular $f\ne p$. Moreover +$F\in(f,\mathbf y)$, so $(F)$ survives as a height-one prime in +$S_{(f,\mathbf y)}$. + +Equation~\eqref{eq:source-17} for the enlarged tuple shows that +$F$ divides both enlarged quotients. The calculation in +Lemma~\ref{unit:quotient-regularity} makes both undepleted +analytic series vanish on this prime. Applying the two conjugate +theta implications, either one representation jumps on both +sides, or a one-sided complex for each representation jumps. +Each possibility is excluded at a height-one prime of +$S_{(f,\mathbf y)}$ by Proposition~\ref{unit:simultaneous-jumps}. +This contradiction proves that the enlarged quotients are units. +Their specialization, and the displayed identity, imply that +the original quotients are units too. If there were no old +divisors, the original quotients were already units and the +argument requires no enlargement. + +Removing all artificial variables uses the same integral +specialization identity. The restored factors +\eqref{eq:source-13} are nonzero even if they are not units at +the center, and occur with the same multiplicity on both sides. +Their cancellation leaves a unit in $\Z_p[[t]]$. No loss of +$p$-adic precision occurs in this passage. +\end{proof} diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/10-center.tex b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/10-center.tex new file mode 100644 index 0000000000000000000000000000000000000000..d099c1a25017b59637e3334f17099834fbf23f46 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/build/sections/10-center.tex @@ -0,0 +1,271 @@ +\section{The central value and the exact formula}\label{sec:center} + +The unit comparison now identifies the central valuation of the +strict determinant with the logarithmic expression of +\eqref{eq:source-12}. We compute that determinant in the full Tate +lattice. This is where the point index, torsion, and every local +component number enter the equality. + +\subsection{The central determinant volume} + +Keep $p>2$ fixed. Put $K=\Q(\sqrt D)$ as in +Lemma~\ref{classical:auxiliary-fields}, and let +$P_K\in E(K)$ be the single Hilbert-class trace used in +\eqref{eq:source-12}. The simple zero of $L(E/K,s)$ and +Theorem~\ref{classical:gross-zagier} make $P_K$ nontorsion. +The group $E(K)$ has rank one and $\Sha(E/K)$ is finite: the two +rational factors have analytic ranks adding to one, and the +quadratic restriction-of-scalars isogeny transfers rank and +finiteness. Define +\[ + n_P=v_p\bigl([E(K)/E(K)_{\rm tors}:\Z\overline P_K]\bigr), + \quad \tau_g=v_p(\#E(K)_{\rm tors}), + \quad s_K=v_p(\#\Sha(E/K)). +\] +For a rational finite prime $q$ write +$\tau_q=v_p(\#E(\Q_q)[p^\infty])$, and write +$\log_{\omega_E}E(\Q_p)=p^l\Z_p$. +All primes in the fixed support $S^\circ$ of the $E/K$ comparison +are split in $K$; thus their two local quantities equal the +corresponding rational quantities. The modular differential +factor is the actual rational number $c_E$ in +$\phi^*\omega_E=c_E f\,dq/q$. + +\begin{proposition}\label{center:exact-factor} +Let $C_w^{s=1}(0)$ be the actual central strict/full complex after +all artificial variables have been removed. Its differential +determinant satisfies +\begin{equation} + \begin{split} + -v_p(L_w^{s=1}(0)) + &=d(C_w^{s=1}(0),1)\\ + &=2n_P+2\tau_g-s_K + -2\bigl(v_p(\log_{\omega_E}P_K)-l+\tau_p\bigr) + -2\sum_{q\in S^\circ}\tau_q . + \end{split} + \tag{22}\label{eq:source-22} +\end{equation} +Consequently +\begin{equation} + 2(n_P+\tau_g)=s_K+2v_p(c_E)+2\sum_q v_p(c_q(E)), + \tag{23}\label{eq:source-23} +\end{equation} +where the last sum ranges over all rational finite primes. +\end{proposition} + +\begin{proof} +After removal of the artificial variables, the marked arithmetic +models compute the fixed-support complex over $K$ itself by +Lemma~\ref{models:finite-models}. Central specialization is +derived specialization of its finite free model. In particular +it retains the finite local Kummer modules and their invariant +torsion. The strict/full complex is rationally acyclic: the +global compact Selmer space is the line generated by $P_K$, +and its localization at each $p$-place is nonzero, since the +kernel of the elliptic logarithm on local points is torsion. +Exact complementary duality, or +Lemma~\ref{models:strict-finite}, then gives the acyclicity. +The inverse-determinant convention consequently gives the first +line of \eqref{eq:source-22}. + +Begin with the all-Kummer complex. By +Lemma~\ref{models:kummer-volume}, its class-functional tensor has +valuation +\[ + d(C_{\rm Kum},(P_K,P_K^\vee))=2n_P+2\tau_g-s_K. +\] +Here the torsion lengths in degrees one, two, three are +$\tau_g,s_K,\tau_g$, and both occurrences of the point contribute +its index $n_P$. Thus this is a calculation on the full lattice. + +First compare the paired $p$-adic Kummer lines with strict at $w$ +and full at $\bar w$, keeping the Kummer conditions at every +non-$p$ place. Denote this intermediate complex by +$C_w^{\rm Kum-away}$; it differs from $C_w^{s=1}(0)$ only at the +non-$p$ support places. The unchanged conditions are thus still exact +complements, as required by Lemma~\ref{models:strict-finite}. +Choose a free local Kummer generator $e$ +with logarithm generating $p^l\Z_p$. Localization of $P_K$ has +free coordinate of valuation +$v_p(\log_{\omega_E}P_K)-l$. The local Kummer complex also +contains degree-one torsion of length $\tau_p$; its volume in +this rational basis is therefore $\tau_p$. The two paired +localization triangles in +\eqref{models:strict-finite-volume} subtract twice the sum of +these two quantities, giving +\[ + d(C_w^{\rm Kum-away},1)=2n_P+2\tau_g-s_K + -2\bigl(v_p(\log_{\omega_E}P_K)-l+\tau_p\bigr). +\] + +Now relax the conditions at the non-$p$ support places. At +such a place compact $H^1$ is already the completed point module, +while the quotient of full cochains by the Kummer condition has +degree-two torsion of length $\tau_q$, by local duality. +Its inverse-determinant valuation is $-\tau_q$. Each rational +$q\in S^\circ$ gives two places of $K$, hence a total change +$-2\sum_{q\in S^\circ}\tau_q$. These last comparisons use +determinant multiplication in localization triangles and do not +require full local conditions to be self-complementary. +Combining the two changes proves \eqref{eq:source-22}. +In particular the torsion term $\tau_p$ +cannot be discarded by replacing the point module by its free +quotient. + +By Theorem~\ref{unit:unit-comparison} the analytic series and +strict determinant on the true line differ by an integral unit. +Their values at $t=0$ are therefore of the same valuation. +Equation~\eqref{eq:source-12} gives +\[ + v_p(L_w^{s=1}(0)) + =-2v_p(c_E)+2v_p(\log_{\omega_E}P_K) + +2v_p(P_p(1))+2\sum_{q\in S^\circ}v_p(P_q(1)). +\] +Every argument of $v_p$ in this display is nonzero. In particular $P_q(1)$ is a +nonzero inverse local Euler factor, and the point logarithm is +nonzero as observed above. + +Set $h=v_p(\log_{\omega_E}P_K)$, $e_q=v_p(P_q(1))$, and +$c=v_p(c_E)$. Equating this last expression with the negative +of \eqref{eq:source-22}, then cancelling $2h$, gives +\[ + 2n_P+2\tau_g + =s_K+2c+2(\tau_p-l-e_p) + +2\sum_{q\in S^\circ}(\tau_q-e_q). +\] +The Haar identities of Lemma~\ref{models:haar} identify the +parentheses with $v_p(c_p(E))$ and $v_p(c_q(E))$, respectively. +All bad primes are in the fixed support, and every omitted good +prime has component number one. This proves +\eqref{eq:source-23} with the sum over all finite primes. +\end{proof} + +\begin{corollary}\label{center:pair-discrepancy} +For every elliptic curve of analytic rank zero or one, including +CM curves, and for the imaginary twist in +Lemma~\ref{classical:auxiliary-fields}, +\begin{equation} + X(E)+X(E^D)=0. + \tag{24}\label{eq:source-24} +\end{equation} +\end{corollary} + +\begin{proof} +The full group index in +Proposition~\ref{classical:discrepancy-identity} has valuation +\[ + v_p([E(K):\Z P_K])=n_P+\tau_g. +\] +Substitute \eqref{eq:source-23} into the resulting valuation +identity \eqref{eq:classical-discrepancy}. Its right-hand side +is zero, proving \eqref{eq:source-24}. That arithmetic-volume +identity already uses the total real periods, full-lattice +regulator, and height diagonal $H$. The field-degree factor +over $K$ is included there; none is appended here. +\end{proof} + +\subsection{CM curves and assembly} + +The single-curve inequality applies to non-CM curves. The +rank-zero CM case instead has the following independent input, +which we state at its exact scope. + +\begin{lemma}\label{center:cm-zero} +If $E/\Q$ has complex multiplication and $L(E,1)\ne0$, the exact +BSD formula holds for $E$ with the normalizations of +Section~\ref{sec:intro}. +\end{lemma} + +\begin{proof} +Let $M$ be the CM field. Theorem 1.1 and Corollary 1 of +Burungale--Flach~\cite{BurungaleFlach} give exact BSD for an +elliptic curve $A/F$ with CM by the maximal order of $M$, provided +$F(A_{\rm tors})/M$ is abelian and the associated Hecke +$L$-value at one is nonzero. We verify these hypotheses after an +isogeny over $M$. + +All CM endomorphisms of $E_M$ are defined over $M$. If the +endomorphism order is not maximal, at each prime $\ell$ replace +$T_\ell E$ by its span under $\mathcal O_M\otimes\Z_\ell$ in +$V_\ell E$. These are Galois-stable lattices, equal to the +original lattices except at the finitely many primes dividing +the conductor of the order. Their finite quotients define a +finite Galois-stable subgroup of $E$, and quotienting gives an +elliptic curve $A/M$ isogenous to $E_M$ with maximal-order CM. +Its Tate modules have rank one over the corresponding local CM +orders. The Galois actions commute with those orders, so their +images, and hence the full torsion extension over $M$, are +abelian. + +Choose a nonzero trace-zero CM endomorphism after multiplying +by an integer to make it integral. Galois conjugation outside +$M$ sends it to its negative. The twisting descent criterion +therefore gives a $\Q$-isogeny from the quadratic twist $E^M$ to +$E$. In particular +\[ + L(E/M,s)=L(E/\Q,s)L(E^M/\Q,s)=L(E/\Q,s)^2. +\] +This has nonzero value at one. Isogeny does not change that +$L$-function, and its factorization into the Hecke character +and conjugate Hecke character $L$-functions shows that the +nonvanishing hypothesis of Burungale--Flach holds for $A$. +Their theorem gives exact BSD over $M$, and isogeny invariance +transfers it to $E_M$. + +Finally restriction of scalars is compatible with the BSD +arithmetic volume, and +\[ + \operatorname{Res}_{M/\Q}E_M\ \sim_{\Q}\ E\times E^M + \ \sim_{\Q}\ E^2. +\] +Thus the normalized BSD discrepancy for $E$ has square one. +It is positive: analytic rank zero gives rank zero and finite +$\Sha$, so the two-primary result supplies positivity +and rationality. It is therefore one. This is the descent +argument of Burungale--Flach, Corollary 2, using the +restriction-of-scalars and isogeny compatibilities of +\cite{Cassels,MilneBSD}; the preceding lattice argument supplies +the additional nonmaximal-order case. +\end{proof} + +\begin{proposition}\label{center:odd-valuations} +For every elliptic curve $E/\Q$ of analytic rank zero or one and +every odd prime $p$, +\[ + v_p(Q_E)=v_p(\#\Sha(E/\Q)). +\] +\end{proposition} + +\begin{proof} +For a non-CM curve, the single-curve inequality +\eqref{eq:source-8} gives $X(E)\geq0$. Its twist $E^D$ is +also non-CM and has the complementary analytic rank, so the +same inequality gives $X(E^D)\geq0$. Their sum is zero by +\eqref{eq:source-24}; hence $X(E)=0$. + +For a CM curve of analytic rank zero use +Lemma~\ref{center:cm-zero}. For a CM curve of analytic rank one, +the companion $E^D$ is CM of analytic rank zero. That lemma and +\eqref{eq:source-24} again give $X(E)=0$. The construction was +made for an arbitrary odd $p$, including $p=3$, so the displayed +equality holds at every odd prime. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:main}] +Apply the low-corank converse +(Theorem~\ref{classical:low-corank}) at the prime $q$ in the +hypothesis. It gives +$a(E)=r(E)=s_q(E)\in\{0,1\}$ and finiteness of the whole +$\Sha(E/\Q)$. The Kummer exact sequence then gives +$s_p(E)=r(E)$ for every prime $p$, in particular $s_2(E)\leq1$. +The two-primary formula +(Theorem~\ref{classical:two-primary}) gives positivity and +rationality of $Q_E$ and its correct $2$-adic valuation. +Proposition~\ref{center:odd-valuations} supplies its correct +valuation at every odd prime, independently of $q$. +Consequently the positive rational number +$Q_E/\#\Sha(E/\Q)$ has zero valuation at every rational prime. +Its prime factorization is empty, so it equals one. Substituting +the definition of $Q_E$ is exactly the asserted real formula, +with the total real period and full Mordell--Weil regulator. +\end{proof} diff --git a/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/exact-bsd-low-selmer-corank.pdf b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/exact-bsd-low-selmer-corank.pdf new file mode 100644 index 0000000000000000000000000000000000000000..562ce7dc254d434219f5a73f5dcb05836f91eb73 --- /dev/null +++ b/preprints/Exact-Birch-Swinnerton-Dyer-Formula-from-Low-Selmer-Corank-October-7-2026/exact-bsd-low-selmer-corank.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64b46603e174462e5bb32d242852eb7f0afe6e519f26534e42fd3f178a16b885 +size 874353 diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/README.md b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b775daf929e0ea55428fd45d3a227e2103acf41b --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [Finite ordinary minimal model programs on compact Kähler fourfolds](paper.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026, + author = {{OpenAI}}, + title = {{Finite ordinary minimal model programs on compact K{\"a}hler fourfolds}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf}{OAI:Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version adds carrier-positivity and multiplier-ideal arguments and revises the contraction induction for ordinary negative-ray programs; see the [previous version](../Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-5-2026/paper.pdf). diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/figures/dependencies.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/figures/dependencies.tex new file mode 100644 index 0000000000000000000000000000000000000000..5e4777d0c32541ba679b2ea73aebfe3ff43b803c --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/figures/dependencies.tex @@ -0,0 +1,37 @@ +\begin{figure}[htbp] +\centering +\begin{tikzpicture}[ + box/.style={draw=linkblue!65,rounded corners=2pt,align=center, + fill=linkblue!3,text width=5.4cm,inner sep=7pt,font=\small}, + shared/.style={box,text width=11.8cm}, + edge/.style={-{Stealth[length=2mm]},draw=linkblue!80,thick}] +\node[shared] (common) {Analytic contractions and exact bundle descent\\ +Compact cycle counts and ordinary terminal fourfold termination}; +\node[box,below=9mm of common.south west,anchor=north west] (relative) + {Rational relative programs\\ +Threefold and special termination}; +\node[box,below=9mm of common.south east,anchor=north east] (supporting) + {Supporting contractions\\ +Bounded-dimensional induction}; +\node[box,below=8mm of relative] (companion) + {Companion flip termination\\ +Compact cycle counts}; +\node[box,below=8mm of supporting] (ordinary) + {Global line-bundle detectors\\ +Ordinary projective steps}; +\node[shared,below=8mm of companion.south west,anchor=north west] (finite) + {Every maximal ordinary negative-ray program terminates\\ +Theorem~\ref{thm:finite}}; +\draw[edge] (common.south -| relative.north)--(relative.north); +\draw[edge] (common.south -| supporting.north)--(supporting.north); +\draw[edge] (relative)--(supporting); +\draw[edge] (relative)--(companion); +\draw[edge] (supporting)--(ordinary); +\draw[edge] (companion.south)--(finite.north -| companion.south); +\draw[edge] (ordinary.south)--(finite.north -| ordinary.south); +\end{tikzpicture} +\caption{Dependencies in the proof of Theorem~\ref{thm:finite}. The +relative and lower-dimensional results support the contraction induction +and the companion flip-termination theorem.} +\label{fig:dependencies} +\end{figure} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/main.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..bb3c57d2eafa33a5a48c55e60dcde63a04c6ab21 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/main.tex @@ -0,0 +1,93 @@ +\documentclass[11pt,reqno]{amsart} +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools,mathrsfs} +\usepackage{microtype} +\usepackage{graphicx,booktabs,array,longtable,enumitem} +\usepackage{flafter} +\usepackage{xcolor} +\definecolor{linkblue}{RGB}{24,64,105} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning,fit,calc,matrix} +\usepackage[colorlinks=true,linkcolor=linkblue,citecolor=linkblue,urlcolor=linkblue]{hyperref} +\usepackage[capitalise,nameinlink,noabbrev]{cleveref} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{hypothesis}[theorem]{Hypothesis} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{convention}[theorem]{Convention} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\numberwithin{equation}{section} +\newcommand{\C}{\mathbb C} +\newcommand{\R}{\mathbb R} +\newcommand{\Q}{\mathbb Q} +\newcommand{\Z}{\mathbb Z} +\newcommand{\N}{\mathbb N} +\newcommand{\Pbb}{\mathbb P} +\newcommand{\cO}{\mathcal O} +\newcommand{\cF}{\mathcal F} +\newcommand{\cG}{\mathcal G} +\newcommand{\cL}{\mathcal L} +\newcommand{\cM}{\mathcal M} +\newcommand{\cR}{\mathcal R} +\newcommand{\cA}{\mathcal A} +\newcommand{\cB}{\mathcal B} +\newcommand{\cI}{\mathcal I} +\newcommand{\NA}{\overline{\mathrm{NA}}} +\newcommand{\BC}{H^{1,1}_{\mathrm{BC}}} +\DeclareMathOperator{\Exc}{Exc} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\Spec}{Spec} +\DeclareMathOperator{\Proj}{Proj} +\DeclareMathOperator{\rk}{rk} +\DeclareMathOperator{\codim}{codim} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\Cl}{Cl} +\DeclareMathOperator{\vol}{vol} +\DeclareMathOperator{\lct}{lct} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\coker}{coker} +\newcommand{\id}{\mathrm{id}} +\newcommand{\simq}{\sim_{\Q}} +\newcommand{\num}{\equiv} +\newcommand{\ddc}{\mathrm{d}\mathrm{d}^{c}} +\newcommand{\bM}{\mathbf M} +\newcommand{\bP}{\mathbf P} +\setlist[enumerate]{leftmargin=*,itemsep=4pt} +\setlist[itemize]{leftmargin=*,itemsep=3pt} +\setcounter{tocdepth}{1} +\hypersetup{pdftitle={Finite ordinary minimal model programs on compact Kähler fourfolds},pdfauthor={OpenAI}} +\title[Minimal model programs on Kähler fourfolds]{Finite ordinary minimal model programs\\on compact Kähler fourfolds} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\begin{abstract} +We prove that every maximal ordinary negative-ray program starting from a compact Kähler klt fourfold pair with effective rational boundary in the global Weil-divisor $\Q$-factorial category terminates. It ends at a nef model when the adjoint is pseudo-effective and at a projective Mori fibre space otherwise. +\end{abstract} +\maketitle +\tableofcontents +\input{sections/01-introduction} +\input{sections/02-analytic} +\input{sections/03-steps} +\input{sections/04-terminal} +\input{sections/05-scaling} +\input{sections/06-perturbation} +\input{sections/07-endpoints} +\input{sections/08-resolutions} +\input{sections/08-relative} +\input{sections/09-threefold} +\input{sections/10-special} +\input{sections/11-threshold} +\input{sections/12-supply} +\appendix +\input{sections/13-local-convention} +\bibliographystyle{amsplain} +\bibliography{references} +\end{document} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/references.bib b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..87d8188244590ee5b215f60c84ca7557526346a8 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/references.bib @@ -0,0 +1,631 @@ + +@misc{HP2024, + author = {Hacon, Christopher and P{\u{a}}un, Mihai}, + title = {On the Canonical Bundle Formula and Adjunction for Generalized {K{\"a}hler} Pairs}, + year = {2024}, + eprint = {2404.12007v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.2404.12007}, + url = {https://arxiv.org/abs/2404.12007v1}, + note = {Preprint, \href{https://arxiv.org/abs/2404.12007v1}{arXiv:2404.12007v1}, 18 April 2024; theorem numbering follows this version} +} + +@misc{HX2026, + author = {Hacon, Christopher and Xie, Lingyao}, + title = {On the {K{\"a}hler} {MMP} and the transcendental base-point-free theorem}, + year = {2026}, + eprint = {2607.24986v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.2607.24986}, + url = {https://arxiv.org/abs/2607.24986v1}, + note = {Preprint, \href{https://arxiv.org/abs/2607.24986v1}{arXiv:2607.24986v1}, 27 July 2026} +} + +@misc{HLX2026, + author = {Hacon, Christopher and Li, Yi and Xie, Lingyao}, + title = {{Fujiki} Class {C} Varieties and a {K{\"a}hler} Criterion}, + year = {2026}, + eprint = {2608.20588v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.2608.20588}, + url = {https://arxiv.org/abs/2608.20588v1}, + note = {Preprint, \href{https://arxiv.org/abs/2608.20588v1}{arXiv:2608.20588v1}, 20 August 2026} +} + +@article{DHP2024, + author = {Das, Omprokash and Hacon, Christopher and P{\u{a}}un, Mihai}, + title = {On the 4-dimensional minimal model program for {K{\"a}hler} varieties}, + journal = {Advances in Mathematics}, + volume = {443}, + year = {2024}, + pages = {109615}, + doi = {10.1016/j.aim.2024.109615}, + eprint = {2205.12205v3}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/2205.12205v3}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/2205.12205v3}{arXiv:2205.12205v3}, 9 April 2024} +} + +@misc{Fujino2022, + author = {Fujino, Osamu}, + title = {Minimal model program for projective morphisms between complex analytic spaces}, + year = {2022}, + eprint = {2201.11315v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.2201.11315}, + url = {https://arxiv.org/abs/2201.11315v1}, + note = {Preprint, \href{https://arxiv.org/abs/2201.11315v1}{arXiv:2201.11315v1}, 27 January 2022; author version 0.01} +} + +@misc{FujinoCompact2026, + author = {Fujino, Osamu}, + title = {On the minimal model program for projective morphisms between compact complex analytic spaces}, + year = {2026}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/MMPforCompact2.pdf}, + note = {\href{https://www.math.kyoto-u.ac.jp/~fujino/MMPforCompact2.pdf}{Author preprint}, version 0.03, 1 May 2026} +} + +@article{CT2023, + author = {Chen, Guodu and Tsakanikas, Nikolaos}, + title = {On the termination of flips for log canonical generalized pairs}, + journal = {Acta Mathematica Sinica, English Series}, + volume = {39}, + number = {6}, + year = {2023}, + pages = {967--994}, + doi = {10.1007/s10114-023-0116-3}, + eprint = {2011.02236v2}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/2011.02236v2}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/2011.02236v2}{arXiv:2011.02236v2}, 21 January 2023} +} + +@article{LMT2022, + author = {Lazi{\'c}, Vladimir and Moraga, Joaqu{\'i}n and Tsakanikas, Nikolaos}, + title = {Special termination for log canonical pairs}, + journal = {Asian Journal of Mathematics}, + volume = {27}, + number = {3}, + year = {2023}, + pages = {423--440}, + doi = {10.4310/AJM.2023.v27.n3.a5}, + eprint = {2007.06458v2}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/2007.06458v2}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/2007.06458v2}{arXiv:2007.06458v2}, 17 April 2023} +} + +@article{Moraga2020, + author = {Moraga, Joaqu{\'i}n}, + title = {Termination of pseudo-effective 4-fold flips}, + journal = {Mathematische Zeitschrift}, + volume = {310}, + number = {4}, + pages = {Paper No. 73}, + year = {2025}, + doi = {10.1007/s00209-025-03766-y}, + eprint = {1802.10202v4}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/1802.10202v4}, + note = {32 pp.; theorem numbering follows \href{https://arxiv.org/abs/1802.10202v4}{arXiv:1802.10202v4}, 5 August 2025} +} + +@article{HaconMoraga2020, + author = {Hacon, Christopher and Moraga, Joaqu{\'i}n}, + title = {On weak {Zariski} decompositions and termination of flips}, + journal = {Mathematical Research Letters}, + volume = {27}, + number = {5}, + year = {2020}, + pages = {1393--1421}, + doi = {10.4310/MRL.2020.v27.n5.a6}, + eprint = {1805.01600v3}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/1805.01600v3}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/1805.01600v3}{arXiv:1805.01600v3}, 25 March 2020} +} + +@article{HXACC2023, + author = {Hacon, Christopher D. and Xie, Lingyao}, + title = {{ACC} for generalized log canonical thresholds for complex analytic spaces}, + journal = {Science China Mathematics}, + volume = {69}, + number = {7}, + year = {2026}, + pages = {1759--1766}, + doi = {10.1007/s11425-023-2260-4}, + eprint = {2303.00993v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/2303.00993v1}, + note = {Published online 7 February 2024; theorem numbering follows \href{https://arxiv.org/abs/2303.00993v1}{arXiv:2303.00993v1}, 2 March 2023} +} + +@incollection{KMM1987, + author = {Kawamata, Yujiro and Matsuda, Katsumi and Matsuki, Kenji}, + title = {Introduction to the Minimal Model Problem}, + booktitle = {Algebraic Geometry, Sendai, 1985}, + editor = {Oda, Tadao}, + series = {Advanced Studies in Pure Mathematics}, + volume = {10}, + pages = {283--360}, + publisher = {Kinokuniya and North-Holland}, + year = {1987}, + doi = {10.2969/aspm/01010283} +} + +@book{KM1998, + author = {Koll{\'a}r, J{\'a}nos and Mori, Shigefumi}, + title = {Birational Geometry of Algebraic Varieties}, + series = {Cambridge Tracts in Mathematics}, + volume = {134}, + publisher = {Cambridge University Press}, + address = {Cambridge}, + year = {1998}, + note = {With the collaboration of C. H. Clemens and A. Corti}, + doi = {10.1017/CBO9780511662560} +} + +@article{Kawamata1988, + author = {Kawamata, Yujiro}, + title = {Crepant blowing-up of 3-dimensional canonical singularities and its application to degenerations of surfaces}, + journal = {Annals of Mathematics. Second Series}, + volume = {127}, + number = {1}, + pages = {93--163}, + year = {1988}, + doi = {10.2307/1971417}, + url = {https://annals.math.princeton.edu/1988/127-1/p03} +} + +@article{KawamataAppendix1992, + author = {Kawamata, Yujiro}, + title = {The minimal discrepancy of a 3-fold terminal singularity}, + journal = {Russian Academy of Sciences. Izvestiya Mathematics}, + volume = {40}, + number = {1}, + pages = {193--195}, + year = {1993}, + note = {Appendix to V. V. Shokurov, 3-fold log flips; Russian original published in 1992, pp. 201--203}, + url = {https://webhomes.maths.ed.ac.uk/cheltsov/shokurov/pdf/logflip1.pdf} +} + +@article{MoriProkhorov2021, + author = {Mori, Shigefumi and Prokhorov, Yuri G.}, + title = {Threefold extremal curve germs with one non-{Gorenstein} point}, + journal = {Izvestiya: Mathematics}, + volume = {83}, + number = {3}, + pages = {565--612}, + year = {2019}, + doi = {10.1070/IM8833}, + url = {https://www.mathnet.ru/im8833} +} + +@book{Milnor1968, + author = {Milnor, John}, + title = {Singular Points of Complex Hypersurfaces}, + series = {Annals of Mathematics Studies}, + volume = {61}, + publisher = {Princeton University Press}, + address = {Princeton, NJ}, + year = {1968} +} + +@article{Mori1985, + author = {Mori, Shigefumi}, + title = {On 3-dimensional terminal singularities}, + journal = {Nagoya Mathematical Journal}, + volume = {98}, + pages = {43--66}, + year = {1985}, + doi = {10.1017/S0027763000021358}, + url = {https://doi.org/10.1017/S0027763000021358} +} + +@misc{DeJongEtAl1998, + author = {de Jong, Theo and Persson, Ulf and Stevens, Jan and van Straten, Duco}, + title = {Lectures on Deformation Theory}, + year = {1998}, + url = {https://download.uni-mainz.de/mathematik/Algebraische%20Geometrie/DvS-Publikationen/DvS_Deformation%20Theory%2C%20Lectures%20on_van%20Straten_de%20Jong_Persson_Stevens_1998.pdf}, + howpublished = {\href{https://download.uni-mainz.de/mathematik/Algebraische\%20Geometrie/DvS-Publikationen/DvS_Deformation\%20Theory\%2C\%20Lectures\%20on_van\%20Straten_de\%20Jong_Persson_Stevens_1998.pdf}{Author-hosted lecture notes}}, + note = {Unpublished; year follows the hosting filename, cover undated} +} + +@book{Kollar2013, + author = {Koll{\'a}r, J{\'a}nos}, + title = {Singularities of the Minimal Model Program}, + series = {Cambridge Tracts in Mathematics}, + volume = {200}, + publisher = {Cambridge University Press}, + address = {Cambridge}, + year = {2013}, + note = {With a collaboration of S{\'a}ndor Kov{\'a}cs}, + doi = {10.1017/CBO9781139547895}, + isbn = {978-1-107-03534-8} +} + +@misc{Ou2025, + author = {Ou, Wenhao}, + title = {A characterization of uniruled compact {K{\"a}hler} manifolds}, + year = {2025}, + eprint = {2501.18088v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.2501.18088}, + url = {https://arxiv.org/abs/2501.18088v1}, + note = {Preprint, \href{https://arxiv.org/abs/2501.18088v1}{arXiv:2501.18088v1}, 30 January 2025} +} + +@article{Campana2004, + author = {Campana, Fr{\'e}d{\'e}ric}, + title = {Orbifolds, special varieties and classification theory: an appendix}, + journal = {Annales de l'Institut Fourier}, + year = {2004}, + volume = {54}, + number = {3}, + pages = {631--665}, + doi = {10.5802/aif.2028}, + url = {https://aif.centre-mersenne.org/articles/10.5802/aif.2028/} +} + +@article{Campana1981, + author = {Campana, Fr{\'e}d{\'e}ric}, + title = {Cor{\'e}duction alg{\'e}brique d'un espace analytique faiblement {K{\"a}hl{\'e}rien} compact}, + journal = {Inventiones Mathematicae}, + year = {1981}, + volume = {63}, + pages = {187--223}, + doi = {10.1007/BF01393876}, + url = {https://link.springer.com/article/10.1007/BF01393876} +} + +@article{CampanaMain2004, + author = {Campana, Fr{\'e}d{\'e}ric}, + title = {Orbifolds, special varieties and classification theory}, + journal = {Annales de l'Institut Fourier}, + year = {2004}, + volume = {54}, + number = {3}, + pages = {499--630}, + doi = {10.5802/aif.2027}, + eprint = {math/0110051v9}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/math/0110051v9}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/math/0110051v9}{arXiv:math/0110051v9}, entitled Special Varieties and Classification Theory} +} + +@article{GHS2003, + author = {Graber, Tom and Harris, Joe and Starr, Jason}, + title = {Families of rationally connected varieties}, + journal = {Journal of the American Mathematical Society}, + year = {2003}, + volume = {16}, + number = {1}, + pages = {57--67}, + doi = {10.1090/S0894-0347-02-00402-2}, + eprint = {math/0109220v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/math/0109220v1} +} + +@article{HP2016, + author = {H{\"o}ring, Andreas and Peternell, Thomas}, + title = {Minimal models for {K{\"a}hler} threefolds}, + journal = {Inventiones Mathematicae}, + year = {2016}, + volume = {203}, + number = {1}, + pages = {217--264}, + doi = {10.1007/s00222-015-0592-x}, + eprint = {1304.4013v3}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/1304.4013v3}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/1304.4013v3}{arXiv:1304.4013v3}} +} + +@article{DP2003, + author = {Demailly, Jean-Pierre and Peternell, Thomas}, + title = {A {Kawamata--Viehweg} vanishing theorem on compact {K{\"a}hler} manifolds}, + journal = {Journal of Differential Geometry}, + year = {2003}, + volume = {63}, + number = {2}, + pages = {231--277}, + doi = {10.4310/jdg/1090426678}, + eprint = {math/0208021v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/math/0208021v1}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/math/0208021v1}{arXiv:math/0208021v1}} +} + +@article{BDPP2013, + author = {Boucksom, S{\'e}bastien and Demailly, Jean-Pierre and P{\u{a}}un, Mihai and Peternell, Thomas}, + title = {The pseudo-effective cone of a compact {K{\"a}hler} manifold and varieties of negative {Kodaira} dimension}, + journal = {Journal of Algebraic Geometry}, + year = {2013}, + volume = {22}, + number = {2}, + pages = {201--248}, + doi = {10.1090/S1056-3911-2012-00574-8}, + eprint = {math/0405285v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/math/0405285v1}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/math/0405285v1}{arXiv:math/0405285v1}} +} + +@article{KMMAbundance1994, + author = {Keel, Sean and Matsuki, Kenji and McKernan, James}, + title = {Log abundance theorem for threefolds}, + journal = {Duke Mathematical Journal}, + year = {1994}, + volume = {75}, + number = {1}, + pages = {99--119}, + doi = {10.1215/S0012-7094-94-07504-2}, + url = {https://mathweb.ucsd.edu/~jmckerna/Papers/abu.pdf} +} + +@misc{MatsukiCorrection2003, + author = {Matsuki, Kenji}, + title = {A correction to the paper ``Log Abundance Theorem for Threefolds''}, + year = {2003}, + eprint = {math/0302360v1}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.math/0302360}, + url = {https://arxiv.org/abs/math/0302360v1}, + note = {Preprint, \href{https://arxiv.org/abs/math/0302360v1}{arXiv:math/0302360v1}, 28 February 2003} +} + +@book{Demailly1985, + author = {Demailly, Jean-Pierre}, + title = {Mesures de {Monge-Amp\`ere} et caract\'erisation + g\'eom\'etrique des vari\'et\'es alg\'ebriques affines}, + series = {M\'emoires de la Soci\'et\'e Math\'ematique de France, + Nouvelle S\'erie}, + number = {19}, + year = {1985}, + publisher = {Soci\'et\'e Math\'ematique de France}, + pages = {1--124}, + doi = {10.24033/msmf.320}, + note = {\href{https://doi.org/10.24033/msmf.320}{doi:10.24033/msmf.320}}, + url = {https://www.numdam.org/item/MSMF_1985_2_19__1_0/} +} + +@misc{FujinoFundamental2010, + author = {Fujino, Osamu}, + title = {Fundamental theorems for the log minimal model program}, + year = {2010}, + note = {\href{https://www.math.kyoto-u.ac.jp/~fujino/fundamental12.pdf}{Author manuscript}, version 6.08, 15 July 2010}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/fundamental12.pdf} +} + +@misc{FujinoInversion2023, + author = {Fujino, Osamu}, + title = {On inversion of adjunction for log canonicity}, + year = {2023}, + note = {\href{https://www.math.kyoto-u.ac.jp/~fujino/on-inversion-of-adjunction9.pdf}{Author manuscript}, version 0.09, 23 April 2023}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/on-inversion-of-adjunction9.pdf} +} + +@misc{DHY2023, + author = {Das, Omprokash and Hacon, Christopher and Y{\'a}{\~n}ez, Jos{\'e} Ignacio}, + title = {{MMP} for Generalized Pairs on {K{\"a}hler} 3-folds}, + year = {2026}, + eprint = {2305.00524v3}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + doi = {10.48550/arXiv.2305.00524}, + url = {https://arxiv.org/abs/2305.00524v3}, + note = {To appear in Annali della Scuola Normale Superiore di Pisa, Classe di Scienze; theorem numbering follows \href{https://arxiv.org/abs/2305.00524v3}{arXiv:2305.00524v3}, 29 June 2026} +} + +@article{CMM2017, + author = {Coman, Dan and Ma, Xiaonan and Marinescu, George}, + title = {Equidistribution for sequences of line bundles on normal {K{\"a}hler} spaces}, + journal = {Geometry \& Topology}, + volume = {21}, + year = {2017}, + pages = {923--962}, + doi = {10.2140/gt.2017.21.923}, + url = {https://webusers.imj-prg.fr/~xiaonan.ma/mypubli/CMM_GT17.pdf} +} + +@misc{DemaillyCADG2012, + author = {Demailly, Jean-Pierre}, + title = {Complex Analytic and Differential Geometry}, + year = {2012}, + howpublished = {\href{https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/agbook.pdf}{Author's online book}}, + note = {Version of 21 June 2012}, + url = {https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/agbook.pdf} +} + +@article{DemaillyPaun2004, + author = {Demailly, Jean-Pierre and P{\u{a}}un, Mihai}, + title = {Numerical characterization of the {K{\"a}hler} cone of a compact {K{\"a}hler} manifold}, + journal = {Annals of Mathematics. Second Series}, + volume = {159}, + number = {3}, + year = {2004}, + pages = {1247--1274}, + doi = {10.4007/annals.2004.159.1247}, + url = {https://annals.math.princeton.edu/2004/159-3/p05} +} + +@misc{FujinoVanishing2026, + author = {Fujino, Osamu}, + title = {On vanishing theorems for non-compact analytic spaces}, + year = {2026}, + howpublished = {\href{https://www.math.kyoto-u.ac.jp/~fujino/fujiki-vanishing3.pdf}{Author manuscript}}, + note = {Version 0.25, 29 April 2026}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/fujiki-vanishing3.pdf} +} + +@article{Fujino2004, + author = {Fujino, Osamu}, + title = {Termination of 4-fold canonical flips}, + journal = {Publications of the Research Institute for Mathematical Sciences}, + volume = {40}, + number = {1}, + year = {2004}, + pages = {231--237}, + doi = {10.2977/PRIMS/1145475971}, + url = {https://ems.press/content/serial-article-files/40849} +} + +@article{Fujino2005Addendum, + author = {Fujino, Osamu}, + title = {Addendum to ``Termination of 4-fold canonical flips''}, + journal = {Publications of the Research Institute for Mathematical Sciences}, + volume = {41}, + number = {1}, + year = {2005}, + pages = {251--257}, + doi = {10.2977/PRIMS/1145475410}, + url = {https://www.kurims.kyoto-u.ac.jp/~prims/pdf/41-1/41-1-9.pdf} +} + +@article{Birkar2009, + author = {Birkar, Caucher}, + title = {Log minimal models according to {Shokurov}}, + journal = {Algebra \& Number Theory}, + volume = {3}, + number = {8}, + year = {2009}, + pages = {951--958}, + url = {https://msp.org/ant/2009/3-8/ant-v3-n8-p04-s.pdf}, + note = {Theorem numbering follows the published version} +} + +@article{Douady1974, + author = {Douady, Adrien}, + title = {Le th{\'e}or{\`e}me des images directes de {Grauert} [d'apr{\`e}s {Kiehl--Verdier}]}, + journal = {Ast{\'e}risque}, + volume = {16}, + year = {1974}, + pages = {49--62}, + url = {https://www.numdam.org/item/AST_1974__16__49_0/} +} + +@misc{Reid, + author = {Reid, Miles}, + title = {Projective morphisms according to {Kawamata}}, + year = {1983}, + howpublished = {Warwick preprint; \href{https://mreid.warwick.ac.uk/3folds/Ka.pdf}{author's electronic version}}, + note = {36 pp.}, + url = {https://mreid.warwick.ac.uk/3folds/Ka.pdf} +} + +@incollection{AraujoKollar2003, + author = {Araujo, Carolina and Koll{\'a}r, J{\'a}nos}, + title = {Rational Curves on Varieties}, + booktitle = {Higher Dimensional Varieties and Rational Points}, + editor = {B{\"o}r{\"o}czky, Jr., K{\'a}roly and Koll{\'a}r, J{\'a}nos and Szamuely, Tam{\'a}s}, + series = {Bolyai Society Mathematical Studies}, + volume = {12}, + publisher = {Springer}, + address = {Berlin--Heidelberg}, + year = {2003}, + pages = {13--68}, + eprint = {math/0203173v2}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0203173v2}, + note = {Theorem numbering follows \href{https://arxiv.org/abs/math/0203173v2}{arXiv:math/0203173v2}, 13 November 2002} +} + +@incollection{Teissier1982, + author = {Teissier, Bernard}, + title = {Vari{\'e}t{\'e}s polaires. {II}. Multiplicit{\'e}s polaires, sections planes, et conditions de {Whitney}}, + booktitle = {Algebraic Geometry ({La R{\'a}bida}, 1981)}, + series = {Lecture Notes in Mathematics}, + volume = {961}, + publisher = {Springer}, + year = {1982}, + pages = {314--491}, + url = {https://webusers.imj-prg.fr/~bernard.teissier/documents/VarPol2.pdf} +} + +@misc{Mather1970, + author = {Mather, John}, + title = {Notes on Topological Stability}, + year = {1970}, + howpublished = {Harvard University lecture notes}, + note = {July 1970; \href{https://webhomes.maths.ed.ac.uk/~v1ranick/surgery/mather.pdf}{electronic transcription}}, + url = {https://webhomes.maths.ed.ac.uk/~v1ranick/surgery/mather.pdf} +} + +@article{Goresky1978, + author = {Goresky, R. Mark}, + title = {Triangulation of stratified objects}, + journal = {Proceedings of the American Mathematical Society}, + volume = {72}, + number = {1}, + year = {1978}, + pages = {193--200}, + url = {https://www.math.ias.edu/~goresky/pdf/triangulations.pdf} +} + +@article{Boucksom2004, + author = {Boucksom, Sébastien}, + title = {Divisorial {Zariski} decompositions on compact complex manifolds}, + journal = {Annales scientifiques de l'École Normale Supérieure}, + series = {4}, + volume = {37}, + year = {2004}, + pages = {45--76}, + doi = {10.1016/j.ansens.2003.04.002}, + url = {https://doi.org/10.1016/j.ansens.2003.04.002} +} + +@misc{FujinoMiyamoto2020, + author = {Fujino, Osamu and Miyamoto, Keisuke}, + title = {Nakai--Moishezon ampleness criterion for real line bundles}, + year = {2020}, + url = {https://www.math.kyoto-u.ac.jp/~fujino/Nakai-Moishezon3.pdf}, + note = {\href{https://www.math.kyoto-u.ac.jp/~fujino/Nakai-Moishezon3.pdf}{Author preprint}, version 0.09, 29 November 2020} +} + +@misc{ClaudonHoring2024, + author = {Claudon, Benoît and Höring, Andreas}, + title = {Projectivity criteria for {Kähler} morphisms}, + year = {2024}, + eprint = {2404.13927}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/2404.13927}, + note = {Preprint, \href{https://arxiv.org/abs/2404.13927}{arXiv:2404.13927}} +} + +@misc{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026, + author = {{OpenAI}}, + title = {{Termination of generalized log canonical flips on compact K{\"a}hler fourfolds}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/termination-generalized-lc-kahler-fourfolds.pdf}{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026}}, + year = {2026} +} + +@article{Grauert1962, + author = {Grauert, Hans}, + title = {{\"U}ber Modifikationen und exzeptionelle analytische Mengen}, + journal = {Mathematische Annalen}, + volume = {146}, + year = {1962}, + pages = {331--368}, + doi = {10.1007/BF01441136}, + url = {https://doi.org/10.1007/BF01441136} +} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/01-introduction.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..0836dbcd262ecf09071abacc32a532ee8c10b9b7 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/01-introduction.tex @@ -0,0 +1,191 @@ +\section{Introduction}\label{sec:introduction} + +A minimal model program replaces a pair by successive birational models +on which its adjoint becomes more positive. For compact Kähler klt fourfold +pairs with effective rational boundary in the global Weil $\Q$-factorial +category, we prove that every maximal ordinary negative-ray program +terminates, starting on the given pair without an initial modification. +Its endpoint has nef adjoint when the initial adjoint is pseudo-effective; +otherwise it carries a projective Mori fibre space. Auxiliary generalized +pairs enter the proof, while every step of the resulting program is ordinary. + +\subsection{Category and main theorem} + +All varieties are reduced irreducible second-countable complex analytic +spaces. A Kähler form on a normal space has smooth strictly +plurisubharmonic local potentials in local embeddings. Projectivity of a +morphism means the existence of a relatively ample holomorphic line +bundle. + +\begin{definition}\label{def:global-factoriality}\label{def:strong-factoriality} +A normal compact space $X$ is \emph{globally Weil $\Q$-factorial} if +every prime Weil divisor defined on the whole of $X$ is $\Q$-Cartier and +some positive reflexive power of its canonical sheaf $\omega_X$ is a line +bundle. It is \emph{globally strongly $\Q$-factorial} if every coherent +rank-one reflexive sheaf $\cF$ on $X$ has an invertible positive reflexive +power $\cF^{[m]}=(\cF^{\otimes m})^{**}$. +\end{definition} + +The Weil convention is that of \cite[Definition~2.1]{DHY2023}; +the strong convention is used in \cite[Section~2]{HX2026}. +The strong condition implies the Weil +condition. Neither definition imposes $\Q$-factoriality on every analytic +local ring. The distinction matters even for projective varieties; an +example is given in Appendix~\ref{sec:local-convention}. + +We write $K_X$ additively for the canonical sheaf. When a canonical Weil +divisor is given, we keep that representative and transport it through +the program. We will also prove the intrinsic variant in which only the +canonical rational line bundle is specified. In that variant, identities +of adjoints mean isomorphisms of holomorphic line bundles after a common +positive multiple. Relative canonical divisors are defined using +compatible local canonical generators. In particular, a numerical +identity alone never specifies such a divisor. + +For an effective rational boundary $\Delta$, put $D=K_X+\Delta$. +We use \emph{log discrepancies} throughout: +\[ + a(E;X,\Delta) + =1+\operatorname{coeff}_E\bigl(K_W-p^*(K_X+\Delta)\bigr) +\] +on a smooth model $p:W\to X$ carrying $E$. A pair is klt when all these +numbers are positive. It is terminal when it is klt and they are greater +than one for every exceptional divisor over $X$. The same convention +will apply to the auxiliary real and generalized pairs. + +Let $\BC(X)$ denote real Bott--Chern cohomology of closed $(1,1)$-forms +with local potentials, and let $\NA(X)$ be the closed cone of positive +currents of bidimension $(1,1)$ modulo their pairings with these classes. +A class is \emph{nef} if it belongs to the closure of the Kähler cone, +and \emph{pseudo-effective} if it contains a closed positive +$(1,1)$-current with local potentials. These terms for a rational line +bundle refer to its first Chern class. A class is \emph{big} if it +contains a Kähler current, meaning a closed current that dominates +a positive multiple of a Kähler form. +For a projective contraction +$f:X\to Z$, write $\rho(X/Z)$ for the dimension of the space of global +real line-bundle classes modulo zero degree on every contracted curve, +and put +\[ + \rho_{\mathrm{BC}}(X/Z) + =\dim_{\R}\bigl(\BC(X)/f^*\BC(Z)\bigr). +\] + +An \emph{ordinary $D$-negative step} is a projective divisorial +contraction, or the flip of a projective small contraction, of a +$D$-negative extremal ray of $\NA(X)$. The contraction has connected +fibres and a normal compact Kähler target; its relative rank is one and +$-D$ is relatively ample. For a flip the transformed adjoint is ample +over the same target. The boundary is pushed forward in a divisorial +step and strictly transformed in a flip. A \emph{Mori fibre space} has +the same contraction properties and a base of strictly smaller +dimension. + +\begin{theorem}[Termination of ordinary programs]\label{thm:finite} +Let $X$ be a normal globally Weil $\Q$-factorial compact Kähler +fourfold, with a canonical Weil divisor $K_X$, and let $\Delta\geq0$ +be a rational divisor such that $(X,\Delta)$ is klt. Then every maximal +ordinary negative-ray program starting on $(X,\Delta)$ terminates. +Its birational steps form a finite sequence +\[ + (X,\Delta)=(X_0,\Delta_0)\dashrightarrow\cdots + \dashrightarrow(X_n,\Delta_n). +\] +Every $X_i$ is normal, compact Kähler and globally Weil +$\Q$-factorial; every $(X_i,\Delta_i)$ is klt, and +$D_i=K_{X_i}+\Delta_i$ is $\Q$-Cartier. The canonical divisors are +the transforms of the specified datum. The following alternatives hold. +\begin{enumerate}[label=\textup{(\roman*)}] +\item If $D=K_X+\Delta$ is pseudo-effective, then $D_n$ is nef. +The composite $\phi:X\dashrightarrow X_n$ extracts no prime divisor, +and +\[ + a(E;X,\Delta)\leq a(E;X_n,\Delta_n) +\] +for every prime divisor over the two models, with strict inequality +for every prime on $X$ contracted by $\phi$. +\item If $D$ is not pseudo-effective, there is a projective surjective +morphism $g:X_n\to S$ with connected fibres, where $S$ is normal +compact Kähler, $\dim S<4$, $\rho(X_n/S)=1$, and $-D_n$ is +$g$-ample. +\end{enumerate} +For each negative contraction, including $g$, the relative +Bott--Chern dimension is one. If $X$ is globally strongly +$\Q$-factorial, so is every $X_i$. + +The same conclusions hold in the intrinsic formulation with the +canonical rational line bundle in place of a chosen canonical Weil +divisor. In either formulation the first model is exactly $X$. +\end{theorem} + +The endpoint conclusion in the pseudo-effective case is nefness; no +abundance assertion is made. + +\subsection{Prior work and proof ingredients} + +Höring--Peternell established minimal models for non-uniruled compact +Kähler threefolds~\cite{HP2016}. For fourfolds, +Das--Hacon--Păun proved the compact klt result when the adjoint is +$\Q$-linearly equivalent to an effective divisor~\cite{DHP2024}. +Fujino's analytic relative MMP supplies ordinary cone, base-point-free, +and flip theorems for projective morphisms~\cite{Fujino2022}. +The generalized cone theorem of Hacon--Xie supplies the analytic +negative rays and their finite form when the boundary plus nef part is +big~\cite[Theorem~1.3]{HX2026}. + +For the supporting contractions needed here, Section~\ref{sec:contractions} +proves a bounded-dimensional base-point-free statement. Its induction +uses ordinary rational programs in dimensions at most three, all with +global line-bundle polarizations. A divisorial negative-part comparison +then supplies descent from a selected lower-dimensional good model. +The ordinary rational adjoint detects each fourfold negative ray and +gives a global algebra for its flip. + +The companion theorem on generalized log canonical flips +\cite[Theorem~1.1]{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026} +proves termination for the resulting existing rational flip sequences. +Compact analytic cycle classes bound the number of divisorial steps. +The companion uses the independent low-place, relative-program, +extraction, and special-termination results proved below; the supporting +contraction argument does not use the finite-program theorem itself. + +Two ingredients have uses beyond this deduction. First, actual line +bundles that are numerically trivial over the relevant birational +contractions descend without taking an additional power. Second, +ordinary terminal fourfold flips terminate with effective \emph{real} +boundary in our compact Kähler setting. The proof adapts the +discrepancy and homology methods of Kawamata--Matsuda--Matsuki and +Fujino, including the treatment of low-discrepancy places in his addendum +\cite{KMM1987,Fujino2004,Fujino2005Addendum}. + +\subsection{Proof outline} + +Sections~\ref{sec:analytic}--\ref{sec:counts} establish the common +analytic, birational and termination tools. The proof of +Theorem~\ref{thm:finite} then has three stages. +\begin{enumerate}[label=\textup{\arabic*.}] +\item The cone theorem gives a supporting nef class for each ordinary +negative ray. Once its contraction is constructed, the ordinary +rational adjoint provides one global relative polarization and one +global flip algebra. +\item A dimension induction proves the supporting contraction +statement through dimension four. Its lower-dimensional ordinary +programs are projective from their first step, and a negative-part +comparison gives descent without lifting a generalized program from +the lower-dimensional base. +\item The companion flip-termination theorem excludes an infinite +flip tail, while compact cycle counts bound the divisorial steps. +Section~\ref{sec:endpoints} identifies the endpoint from +pseudo-effectivity and gives the required discrepancy inequalities. +\end{enumerate} +All auxiliary constructions are separate from the ordinary sequence, +which begins on $X$ itself. + +The rational relative constructions in Section~\ref{sec:relative} +feed threefold termination and the dimension induction for special +termination. These results support both the contraction induction and +the companion flip-termination theorem. Their nef data are actual rational +line bundles on higher models, denoted by $\mathbf M$, distinct from the +possibly transcendental nef classes used in the contraction argument. + +\input{figures/dependencies} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/02-analytic.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/02-analytic.tex new file mode 100644 index 0000000000000000000000000000000000000000..7fc3e24d9cae2f96b580888fb784f39736647681 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/02-analytic.tex @@ -0,0 +1,482 @@ +\section{Classes, currents, and exceptional divisors}\label{sec:analytic} + +The scaling argument transports one K\"ahler form from the original +space through several birational models. Its trace need not be smooth, +or even have local potentials without further argument. We establish +the precise trace relation, its positivity, and the comparison rules +used below. Equalities between Bott--Chern classes will be distinguished +from equalities between divisors or currents. + +\subsection{Pullback of classes} + +We use the following cohomological descent theorem. A space is in +\emph{Fujiki's class $\mathcal C$} if it is bimeromorphic to a compact +K\"ahler manifold. + +\begin{lemma}[Pullback and descent]\label{lem:pullback-image} +Let $f:T\to Z$ be a proper surjective morphism with connected fibres between normal +compact analytic spaces with rational singularities. Suppose that $T$ +is in class $\mathcal C$ and that either the general fibre is rationally +connected or $R^jf_*\cO_T=0$ for every $j>0$. Then +\[ + f^*: \BC(Z)\longrightarrow\BC(T) +\] +is injective, and its image consists exactly of the classes having +degree zero on every $f$-vertical curve. If $T$ and $Z$ are K\"ahler, +a class on $Z$ is nef if and only if its pullback is nef. +\end{lemma} + +\begin{proof} +The pullback assertion is \cite[Lemma~2.39]{HX2026}; nef descent is +\cite[Lemma~2.38]{DHP2024}. In particular, the first assertion applies +to any proper bimeromorphic morphism between compact spaces with +rational singularities whose source is in class $\mathcal C$: its +general fibre is a point. For a projective klt log Fano contraction, +relative vanishing supplies the higher-direct-image hypothesis once +rationality of the base has been established. +\end{proof} + +\subsection{Positive currents on a normal model} + +An $f$-exceptional real divisor is a finite real linear combination of +prime divisors whose images have codimension at least two. +We next give the descent statement needed when an exceptional +correction has either sign. Pseudo-effectivity requires a positive +current with local plurisubharmonic potentials; we do not assume +that an arbitrary positive current on a singular space has them. + +\begin{lemma}[Exceptional descent]\label{lem:positive-descent} +Let $p:U\to T$ be a resolution of a normal compact K\"ahler space, +with $U$ compact K\"ahler. Let $\alpha\in\BC(T)$ and let $E$ be a +$p$-exceptional real divisor. If $p^*\alpha+[E]$ is pseudo-effective, +then $\alpha$ is pseudo-effective. No sign condition on $E$ is needed. +Pseudo-effective classes pull back to resolutions, and nef classes +on $T$ are pseudo-effective. +\end{lemma} + +\begin{proof} +Choose a smooth representative $\theta$ of $\alpha$ with local smooth +potentials. On the smooth compact K\"ahler space $U$, a positive +representative of the given class has the form +\begin{equation}\label{eq:positive-upstairs} + S=p^*\theta+[E]+\ddc v +\end{equation} +for a global distribution $v$. Remove from $T$ its singular locus +and the image of the exceptional locus, obtaining a smooth open set +$T^\circ$ whose complement has codimension at least two. The map +$p$ is an isomorphism there. Equation~\eqref{eq:positive-upstairs} +gives a global $\theta$-plurisubharmonic function $v^\circ$ on +$T^\circ$. We do not assert that $v$ is quasi-plurisubharmonic along +$E$. + +On a coordinate neighbourhood where $\theta=\ddc\rho$, extend +$\rho+v^\circ$ first across the removed codimension-two subset of +the regular locus, and then across the singular locus. The first +extension is the plurisubharmonic Hartogs theorem; the second is its +normal-space version of Grauert--Remmert, recalled in +\cite[Section~2.1, pp.~927--928]{CMM2017}. These extensions are unique. +On overlaps their differences are the original smooth +pluriharmonic differences of the functions $\rho$. Subtracting +$\rho$ therefore gives a global potential $v_T$, and +\[ + \theta+\ddc v_T\geq0 +\] +is a current with local plurisubharmonic potentials representing +exactly $\alpha$. This proves descent, including for signed $E$. + +For pullback, compose local plurisubharmonic potentials with the +resolution. They cannot become identically $-\infty$ on a nonempty +open subset, since a resolution is an isomorphism on a dense open +set. Thus they define the pulled-back positive current; see +\cite[Section~2.1, p.~928]{CMM2017}. + +Finally, if $\alpha$ is nef, then $p^*\alpha$ is nef on $U$. +For a K\"ahler form $\omega_U$, choose positive representatives of +$p^*\alpha+\varepsilon[\omega_U]$. Their masses are bounded as +$\varepsilon\downarrow0$, so a weak limit is a positive current in +$p^*\alpha$. On the smooth K\"ahler manifold $U$ it has local +plurisubharmonic potentials. The first part, with $E=0$, descends +this current to the required class on $T$. +\end{proof} + +\subsection{Generalized pairs and negativity} + +We recall the generalized-pair language in the form needed here +\cite[Section~2.1 and Definition~2.7]{DHY2023}. A closed \emph{b-$(1,1)$ +current} is a compatible collection of closed $(1,1)$-currents on +proper birational models: pushforward along a morphism between models +recovers the current on the lower model. It \emph{descends} to a +model $U$ if its trace there and all higher traces have local +potentials, and the classes of the higher traces are pullbacks of +its class on $U$. +It is \emph{b-nef} if that class is nef on some such model. +We also use the relative version for real combinations of line-bundle +data on a carrier projective over a specified base. Here nefness +means nonnegative degree on curves contracted to that base. The +structure equation and discrepancy definition below are unchanged. + +A generalized pair on $T$ consists of a boundary $B\geq0$, a b-nef +datum $\mathbf M$, and a log resolution $\nu:U\to T$ on which the +datum descends, together with an actual real divisor $B_U$ such that +$\nu_*B_U=B$ and +\begin{equation}\label{eq:generalized-structure} + [K_U+B_U]+[\mathbf M_U]=\nu^*L, + \qquad L\in\BC(T). +\end{equation} +The support of $B_U$ may be taken to have simple normal crossings. +Negativity makes this structure boundary unique; passing to higher +resolutions gives the other structure boundaries. The generalized +log discrepancy of a prime $P$ on such a resolution is +\[ + a(P,T,B+\mathbf M)=1-\operatorname{coeff}_P B_U. +\] +The pair is generalized klt, or \emph{gklt}, if all these discrepancies +are positive, and generalized log canonical, or \emph{glc}, if they +are all nonnegative. The \emph{gklt locus} is the open subset where +all discrepancies of primes centred there are positive; its +complement is the generalized non-klt locus. We use the word +\emph{terminal} for an ordinary or +generalized klt pair whose discrepancies at all exceptional primes +are strictly greater than one. Negative coefficients are permitted +in $B_U$, although the boundary $B$ on the model is effective. +Generalized klt spaces have rational singularities +\cite[Theorem~2.19]{DHY2023}. + +The negativity lemma concerns actual divisors, not arbitrary +Bott--Chern classes. We record also the strict form needed for +fourfold termination. + +\begin{lemma}[Negativity and strict comparison]\label{lem:negativity} +\leavevmode +\begin{enumerate}[label=\textup{(\roman*)}] +\item Let $f:T\to Z$ be a proper bimeromorphic morphism of normal +complex spaces and let $E$ be a real Cartier divisor such that $-E$ +is $f$-nef. Then $E\geq0$ if and only if $f_*E\geq0$. +Consequently an $f$-exceptional, $f$-numerically trivial real Cartier +divisor is zero. +\item If, in addition, $f$ has connected projective fibres and +$E\geq0$ is $f$-anti-nef, then every fibre is either contained in +$\Supp E$ or disjoint from $\Supp E$. +\item Consider a nontrivial small birational diagram +\[ + T\xrightarrow{\ f\ }Z\xleftarrow{\ f^+\ }T^+ +\] +of normal compact spaces, with projective contractions on both +sides. Let $B\geq0$ be a real boundary, let $B^+$ be its strict +transform, and suppose the ordinary adjoints +$D=K_T+B$ and $D^+=K_{T^+}+B^+$ are real Cartier, with $-D$ relatively +ample on the left and $D^+$ relatively ample on the right. +The two exceptional loci have the same image $A\subset Z$. On a +common resolution $p:V\to T$, $q:V\to T^+$, +\begin{equation}\label{eq:ordinary-flip-comparison} + p^*D-q^*D^+=F,\qquad F\geq0, +\end{equation} +where $F$ is an actual divisor exceptional over both models. +For every prime divisor $P$ over these spaces, +\[ + a(P,T^+,B^+)\geq a(P,T,B), +\] +and the inequality is strict if the centre of $P$ on either side +is contained in that side's exceptional locus. +\item For the diagram in \textup{(iii)}, if $\dim T=4$, then $\dim A\leq1$ and +\[ + \dim\Exc(f)+\dim\Exc(f^+)\geq3. +\] +\item The discrepancy conclusions in \textup{(iii)} also hold for +generalized pairs with the same fixed b-nef datum and transformed +boundaries in a projective small diagram, provided the source log +class has negative degree on every curve contracted on that side, +and the target log class has positive degree on every curve +contracted on the other side. They hold likewise for a projective divisorial +contraction $f:T\to T'$ when the target boundary is the pushforward, +the b-datum is unchanged, and the source log class has negative +degree on every $f$-vertical curve. In this divisorial case strictness holds at every prime +whose source centre lies in $\Exc(f)$. +This part also applies when the fixed b-datum is nef only over a +specified base. +\end{enumerate} +\end{lemma} + +\begin{proof} +Part~(i) is the analytic negativity lemma +\cite[Lemma~2.5]{HX2026}; apply it to both signs for the last assertion. +For (ii), points of a connected projective fibre can be joined by a +chain of irreducible curves. If the fibre met both $\Supp E$ and +its complement, some curve in such a chain would meet the support +without being contained in it. Its intersection with the effective +real Cartier divisor would be strictly positive, contrary to +$f$-anti-nefness. The assertion for a real Cartier divisor follows +locally from positive combinations of effective rational Cartier +divisors, as explained below. + +For (iii), let $G$ be the normalization of the graph in +$T\times_ZT^+$, with projections $p_G,q_G$ and map $h:G\to Z$. +Compatible canonical data give the actual real Cartier divisor +\[ + F_G=p_G^*D-q_G^*D^+. +\] +This difference is defined locally by compatible meromorphic canonical +generators and therefore glues, even when the canonical sheaves were +specified as $\Q$-line bundles. Smallness makes it exceptional over +both sides. It is effective by (i), applied over $T$: on a +$p_G$-vertical curve the degree of $-F_G$ is the degree of +$q_G^*D^+$, which is nonnegative. + +For every $h$-vertical curve $C$ one has +\begin{equation}\label{eq:graph-strict-degree} + F_G\cdot C<0. +\end{equation} +Indeed, normalization is finite onto the graph, so the two projections +cannot both contract $C$. The nonzero degrees contributed by $p_G^*D$ +and $-q_G^*D^+$ are both negative. An effective real Cartier divisor +has nonnegative degree on a curve outside its support. For completeness, +this fact and its strict pullback analogue hold even if its individual +prime components are not $\Q$-Cartier: locally express it in the real +span of finitely many Cartier divisors. Vanishing of coefficients +outside its support and nonnegativity of the remaining coefficients +are rational linear conditions. The resulting rational polyhedral +cone expresses it as a positive real combination of effective +$\Q$-Cartier divisors. The usual effective Cartier assertions apply +to each term; summing the nonnegative local intersection numbers +gives the asserted global degree inequality. In particular, the pullback has positive coefficient +at every prime whose centre is contained in the support. + +The morphism $p_G$ has connected fibres because $T$ is normal; +hence $h=f p_G$ has connected fibres. Its fibres are projective +because $G$ is finite over the graph in the fibre product. Each +point of a positive-dimensional fibre lies on a curve in that fibre. Equation +\eqref{eq:graph-strict-degree} therefore places the entire fibre in +$\Supp F_G$. To identify the relevant fibres, suppose $f$ is an +isomorphism over an open subset of $Z$. There the log divisor on +$T^+$ is pulled back from $Z$, by smallness and agreement in codimension +one. Relative ampleness excludes an $f^+$-vertical curve there; +projectivity, connectedness and normality then make $f^+$ an +isomorphism there as well. Interchanging the sides proves that their +exceptional images coincide. Thus $h^{-1}(A)\subset\Supp F_G$. + +Pull $F_G$ back to a resolution on which $P$ appears. Its coefficient +at $P$ is exactly +$a(P,T^+,B^+)-a(P,T,B)$, with our log-discrepancy convention. +Effectivity gives monotonicity, and the support assertion gives the +claimed strictness. This proves (iii). + +For (iv), a small exceptional locus in a fourfold has dimension at +most two and has positive-dimensional fibres, so its image has +dimension at most one. Moreover $F_G\ne0$ by +\eqref{eq:graph-strict-degree}. A component of its support has +dimension three and maps finitely into +$\Exc(f)\times_Z\Exc(f^+)$. The dimension of this product is at most +the sum of the dimensions of its two factors. This proves (iv). + +For (v), choose a common smooth resolution $p:V\to T$, +$q:V\to T'$ carrying the fixed b-datum and projective over the +common contraction base. Such a resolution is obtained by taking +projective modifications of the graph that resolve the maps to a +carrier of the datum. Subtract the actual +structure boundaries to obtain a real Cartier divisor +$F=B_{T,V}-B_{T',V}$. Its coefficients are the differences of +generalized log discrepancies, and cancellation of the fixed +b-part gives +\[ + [F]=p^*L_T-q^*L_{T'}. +\] +Let $h:V\to Z$ be the morphism to the common contraction base; +in the divisorial case $Z=T'$ and $q=h$. It is projective by this +choice and has connected fibres because it is bimeromorphic onto +the normal space $Z$. The boundary-pushforward +condition makes $F$ exceptional over $Z$. The relative signs of +the log classes give $F\cdot C\leq0$ on every $h$-vertical curve, +with strict inequality whenever $p(C)$ or, in the small case, +$q(C)$ is a curve. Thus (i) gives $F\geq0$. + +If $y$ lies in an exceptional image, a vertical curve downstairs +can be lifted to a curve on $V$ dominating it: use a component of +its projective inverse image and cut by relatively ample +hyperplanes. Such a curve has negative $F$-degree and hence lies +in $\Supp F$. Part~(ii) now puts the entire fibre $h^{-1}(y)$ in +the support. Pullback to a higher resolution has positive +coefficient at every prime centred in this support. This proves +all the strict discrepancy inequalities, including for a centre +on the flipped side. No trace current on the normalized graph +is assumed to be Cartier; the actual divisor is constructed from +the structure boundaries on the smooth resolution. +\end{proof} + +\subsection{A fixed nef b-part and its traces} + +For the finite-program proof, fix a K\"ahler form $h$ on the original +space $X$, and set $H=[h]$. It defines a positive b-current +$\mathbf H$: for a marked birational model $T$, choose a common +resolution $p:V\to T$, $q:V\to X$ and put +\begin{equation}\label{eq:actual-H-trace} + \mathbf H_T=p_*q^*h. +\end{equation} +Compatibility on higher resolutions makes this independent of the +choice of resolution \cite[Claim~2.5]{DHY2023}. Throughout the proof +this is one fixed current datum; we do not replace it by arbitrary +cohomologous currents. The class of the trace, when it exists, will +be denoted by $H_T$. + +\begin{lemma}[The exceptional trace relation]\label{lem:class-trace} +Let $T$ be a normal compact K\"ahler space with rational singularities, +marked birationally to $X$. Suppose that on a common smooth K\"ahler +resolution $p:V\to T$, $q:V\to X$ there are a class $H_T\in\BC(T)$ +and an actual $p$-exceptional real divisor $J_T$ satisfying +\begin{equation}\label{eq:class-trace} + p^*H_T=q^*H+[J_T]. +\end{equation} +Then $J_T\geq0$. The class $H_T$ and the divisor $J_T$ are unique, +and the correction on a higher resolution is the pullback of $J_T$. + +For an effective boundary $B_T$ with real Cartier ordinary adjoint, +the generalized structure boundary for the nef datum $t\mathbf H$ is +\begin{equation}\label{eq:trace-boundary} + B_{T,V}(t)=p^*(K_T+B_T)-K_V+tJ_T,\qquad t\geq0. +\end{equation} +In particular, decreasing $t$ increases every generalized log +discrepancy. If the generalized pair is gklt, its ordinary pair is +klt; if all its exceptional log discrepancies exceed one, the +ordinary pair is terminal. + +Conversely, suppose $t>0$ and a generalized pair with boundary $B_T$ +and this fixed datum $t\mathbf H$ is given by +\eqref{eq:generalized-structure}, with log class $L$ and real Cartier +ordinary adjoint. Then \eqref{eq:class-trace} holds with +\[ + H_T=\frac{L-[K_T+B_T]}{t}. +\] +\end{lemma} + +\begin{proof} +On every $p$-vertical curve, $-J_T$ has the same degree as the nef +class $q^*H$. Lemma~\ref{lem:negativity}(i) gives $J_T\geq0$. +Subtract two possible relations. The difference of the correction +divisors is $p$-exceptional and numerically trivial over $T$, hence +zero. Pullback injectivity from Lemma~\ref{lem:pullback-image} then +gives uniqueness of the class as well. + +Pulling back \eqref{eq:class-trace} to a higher resolution gives the +claimed correction there by uniqueness. Conversely, if the relation +is initially known on a higher resolution $r:V'\to V$, push its +correction down to $V$. The difference between the upstairs +correction and the pullback of this pushforward is $r$-exceptional +and numerically trivial over $V$, so is zero. Injectivity of $r^*$ +gives the relation on $V$. + +Equation~\eqref{eq:trace-boundary} follows by adding $K_V$ and the +fixed nef class $tq^*H$ to its two sides. Its coefficients give +\[ + a(P,T,B_T+t\mathbf H) + =a(P,T,B_T)-t\operatorname{coeff}_P J_T +\] +on every sufficiently high resolution. This proves the discrepancy +assertions. + +For the converse, let $B_V$ be the given actual generalized structure +boundary and put $B_V^{\rm ord}=p^*(K_T+B_T)-K_V$. Both push forward +to $B_T$, so +\[ + J_T=\frac{B_V-B_V^{\rm ord}}{t} +\] +is an actual $p$-exceptional divisor. Subtract the ordinary log class +from \eqref{eq:generalized-structure} to obtain +\eqref{eq:class-trace}. This constructs the divisor before applying +negativity; it does not infer a divisor from an arbitrary class +difference. +\end{proof} + +The converse is particularly useful for an extraction carrying a +pulled-back generalized log class. It shows that the divided +difference defining its trace is the same class whenever the marked +model is the same, even if its boundary was obtained at a different +scaling parameter. + +\begin{corollary}[Positivity of the trace]\label{cor:big-trace} +Under the hypotheses of Lemma~\ref{lem:class-trace}, the actual trace +$\mathbf H_T$ has local plurisubharmonic potentials and represents +$H_T$. The class $H_T$ is big. +\end{corollary} + +\begin{proof} +The positive current $q^*h+[J_T]$ represents $p^*H_T$. +The proof of Lemma~\ref{lem:positive-descent} constructs a positive +current $S_T$ in $H_T$ with local potentials. On the big open where +$p$ is an isomorphism and the correction is absent, it agrees with +$p_*q^*h$. Their difference is a closed current of order zero +supported in codimension at least two. Such a current vanishes: +after a local embedding it has bidimension +$(\dim T-1,\dim T-1)$, whereas its support has smaller dimension +\cite[Chapter~III, Corollary~2.11]{DemaillyCADG2012}. +Thus $S_T$ is precisely the actual trace in +\eqref{eq:actual-H-trace}. This step is needed because a trace of +a positive b-current need not have local potentials a priori +\cite[Remark~2.6(ii)]{DHY2023}. + +The class $q^*H$ is nef and has positive top self-intersection: +$q^*h$ is semipositive and is positive on the dense open where $q$ +is an isomorphism. By \cite[Theorem~0.5]{DemaillyPaun2004}, it contains +a K\"ahler current $R\geq\delta\omega_V$ for some $\delta>0$ and +some K\"ahler form $\omega_V$. Fix a K\"ahler form $\omega_T$ and +choose $C>0$ with $p^*\omega_T\leq C\omega_V$. For +$0<\varepsilon<\delta/C$, +\[ + R+[J_T]-\varepsilon p^*\omega_T\geq0. +\] +Its class is $p^*(H_T-\varepsilon[\omega_T])$. +Lemma~\ref{lem:positive-descent} shows that +$H_T-\varepsilon[\omega_T]$ is pseudo-effective. Hence $H_T$ +contains a K\"ahler current, as required. +\end{proof} + +\subsection{Comparison with the same nef datum} + +The preceding results supply the positivity needed for scaling. We +finish with the comparison that later excludes divisorial steps in +the limiting program and identifies the two nef pullbacks in the +final contradiction. + +\begin{lemma}[Small-model comparison]\label{lem:small-comparison} +Let $(T,B_T+\mathbf M)$ and $(T',B_{T'}+\mathbf M)$ be generalized +pairs with the same b-nef datum, whose log classes are $L_T$ and +$L_{T'}$. Suppose the marked birational map $T\dashrightarrow T'$ +extracts no divisors and $B_{T'}$ is the pushforward of $B_T$. +On a common sufficiently high resolution $p:V\to T$, $q:V\to T'$, put +\[ + F=B_{T,V}-B_{T',V}. +\] +Then $F$ is an actual divisor exceptional over $T'$, and +\begin{equation}\label{eq:small-comparison} + p^*L_T-q^*L_{T'}=[F],\qquad + \operatorname{coeff}_P F + =a(P,T',B_{T'}+\mathbf M)-a(P,T,B_T+\mathbf M). +\end{equation} +If the map is small, $F$ is exceptional over both models. In this +case nefness of $L_{T'}$ implies $F\geq0$, and nefness of both log +classes implies $F=0$. These conclusions also hold relatively over +a common base. In particular equal pullback classes imply equality +of the structure boundaries. +\end{lemma} + +\begin{proof} +Subtract the two structure equations on $V$. The trace of the fixed +b-datum cancels, giving \eqref{eq:small-comparison}. At a prime +dominating a divisor on $T'$, the corresponding boundary coefficient +on $T$ is unchanged, so its coefficient in $F$ is zero. This proves +exceptionality over $T'$. Smallness gives the same assertion over +$T$. + +If $L_{T'}$ is nef, then $-F$ is $p$-nef, because its degree on a +$p$-vertical curve is the degree of $q^*L_{T'}$. Negativity gives +$F\geq0$. If $L_T$ is also nef, then $F$ is $q$-nef, so applying +negativity with the opposite sign gives $F\leq0$. The same proof +uses only relative nefness when the models lie over a common base. +For equal pullback classes, the already constructed exceptional +divisor is relatively numerically trivial, and is zero by +Lemma~\ref{lem:negativity}(i). +\end{proof} + +All equalities of pulled-back log classes in this lemma are +cohomological. Equality of actual currents was used only in the +separate trace-identification argument. These distinctions allow +the ordinary steps and the generalized auxiliary constructions to +share one fixed nef datum. diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/03-steps.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/03-steps.tex new file mode 100644 index 0000000000000000000000000000000000000000..0d8b72cffa98d8df44b8128d25377963174c7443 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/03-steps.tex @@ -0,0 +1,449 @@ +\section{Ordinary steps on the given space}\label{sec:absolute} + +We construct the contraction and flip of every negative analytic ray in +arbitrary dimension. The input is an ordinary rational klt pair in the +\emph{global Weil-divisor} category. Generalized pairs enter only through +the cone and base-point-free theorems; the steps themselves are ordinary. +The main point is to preserve actual line bundles, including their fixed +Cartier indices, rather than only numerical classes. + +\subsection{Integral descent} + +Bundles are written additively in numerical expressions. For example, +$L-(K_T+C)$ denotes the rational line bundle obtained from $L$ and the +rational adjoint. All degrees in the following lemma are degrees on +compact curves contracted by the indicated morphism. + +\begin{lemma}[Integral descent]\label{lem:descent} +Let $f:T\to Z$ be a projective bimeromorphic contraction of normal complex +spaces, and let $L$ be a line bundle numerically trivial over $Z$. +Suppose that every point of $Z$ has a neighbourhood $U$ on which there is +an ordinary rational klt pair $(f^{-1}U,C_U)$ with rational adjoint and +\[ + L-(K_{f^{-1}U}+C_U)\quad\text{$f$-nef over $U$}. +\] +Then $f_*L$ is a line bundle and the evaluation map is an isomorphism +\begin{equation}\label{eq:integral-descent} + f^*f_*L\simeq L. +\end{equation} +In particular the conclusion applies if the local ordinary adjoints are +relatively antiample. It also applies to a global ordinary rational klt +pair $(T,C)$ whenever $L-(K_T+C)$ is $f$-nef. Clearing one denominator +therefore descends a rational line bundle as an actual rational line +bundle. +\end{lemma} + +\begin{proof} +Fix $z\in Z$ and shrink to a connected Stein neighbourhood $U$ on which +the stated pair is defined. A line bundle $M$ on $f^{-1}U$ has a +Cartier-divisor representative there: the coherent direct image $f_*M$ +has rank one over the nonempty open where $f$ is an isomorphism, so +Cartan's Theorem~A supplies a nonzero section. Its pullback is a section +of $M$ that is not identically zero, and its zero divisor is Cartier. +This argument takes place over $U$, not on the whole compact space. + +Every rational line bundle $N$ on $f^{-1}U$ is also relatively big. +Indeed, choose $q>0$ with $qN$ a line bundle and an $f$-ample line bundle +$A$. The same direct-image argument gives a nonzero section of +$qN-A$, hence +\[ + N\simq q^{-1}A+q^{-1}E\qquad(E\geq0). +\] +This is relative bigness in the analytic sense +\cite[Definition~2.46]{Fujino2022}. Apply it to +$N=L-(K_T+C_U)$. The klt base-point-free theorem gives, after shrinking +around $z$, relative generation of $L^k$ for \emph{every} sufficiently +large integer $k$ \cite[Theorem~6.2 and Remark~6.3]{Fujino2022}. + +Choose finitely many such generating sections near the compact fibre +$F=f^{-1}(z)$. The morphism they define on the projective reduced fibre +$F_{\mathrm{red}}$ is constant on each irreducible component: a +positive-dimensional image would yield a curve with positive degree +against the pullback of the hyperplane bundle, contrary to the +numerical triviality of $L^k$. Such a curve is obtained by successive +general hyperplane sections of a component. Connectedness of $F$ makes +the images of all its components the same point. A linear combination +of the generating sections is consequently nonzero at every point of +$F_{\mathrm{red}}$. + +This section is a generator of $L^k$ in the local ring at every point of +$F$: its residue is nonzero, and hence its representing function is a +unit. This also treats a nonreduced fibre. Properness allows us to +shrink $U$ away from the image of the section's zero set. Thus $L^k$ is +trivial on $f^{-1}U$. Apply the argument to consecutive integers $k$ and +$k+1$, and use one common neighbourhood. Their quotient trivializes +$L$ itself. Since $f_*\cO_T=\cO_Z$, on this neighbourhood $f_*L\simeq +\cO_U$, and evaluation is an isomorphism. These local conclusions give +\eqref{eq:integral-descent} globally. No additional tensor power enters +the integral conclusion. +\end{proof} + +The nef variant is important even when the adjoint has degree zero over +$f$. For example, if $P=K_T+C$ is a rational klt adjoint, $\ell P$ is +Cartier, and $P$ is numerically trivial over $f$, apply +Lemma~\ref{lem:descent} to $L=\ell P$. Its difference from the adjoint +is $(\ell-1)P$, so the \emph{same} index $\ell$ descends. + +\subsection{Supporting classes and projectivity} + +A class is \emph{modified big} if it is the birational pushforward of a big class +\cite[Definition~2.8]{HX2026}. In particular, a big class is modified big. + +We use the generalized cone theorem +\cite[Theorem~1.3]{HX2026}. For a compact K\"ahler gklt pair with a +descending nef part $\beta$, the cone $\NA(T)$ is the sum of its +adjoint-nonnegative part and rays of rational curves. Only finitely many +rays are needed when the boundary plus $\beta$ is big. The supporting +contractions needed in dimensions at most four are proved in +Proposition~\ref{repair:prop:supporting-contraction}. Their projectivity +will be obtained from the ordinary rational adjoint. + +\begin{lemma}[Supports with a K\"ahler margin]\label{lem:absolute-support} +Let $(T,B)$ be an ordinary rational klt pair on a normal compact K\"ahler +space. Assume that $B$ is $\Q$-Cartier and that $D=K_T+B$ is a rational +line bundle. If $D$ is not nef, $\NA(T)$ has a $D$-negative extremal ray. +Every such ray $R$ is generated by a rational curve and has a nonempty +relatively open set $\mathcal U_R\subset R^\perp$ of classes satisfying +\begin{equation}\label{eq:absolute-support} + \alpha\text{ is nef},\qquad + \NA(T)\cap\alpha^\perp=R,\qquad + \alpha-c_1(D)\text{ is K\"ahler}. +\end{equation} +\end{lemma} + +\begin{proof} +Fix a K\"ahler class $\omega$ and write $d=c_1(D)$. Cone duality applies +because klt singularities are rational. The slice +\[ + S=\{v\in\NA(T):\omega\cdot v=1\} +\] +is compact. Indeed, fix smooth representatives of a basis of $\BC(T)$. +Each is bounded above and below by a multiple of a K\"ahler form, so all +its pairings on $S$ are bounded; the slice is closed. If $D$ is not nef, +the minimum of $d$ on $S$ is negative. An extreme point of its minimum +face gives a negative extremal ray. + +Fix any such ray and let $r\in S$ be its normalized point. Choose +$\varepsilon>0$ with $(d+\varepsilon\omega)\cdot r<0$. The descending +nef part $\varepsilon\omega$ changes no discrepancy, and +$B+\varepsilon\omega$ is big since $B$ is effective and $\Q$-Cartier. +The finite form of the cone theorem gives +\begin{equation}\label{eq:absolute-finite-cone} + \NA(T)=\NA(T)_{d+\varepsilon\omega\geq0} + +\sum_{j=1}^{N}\R_{\geq0}[C_j], +\end{equation} +where the $C_j$ are rational curves. Normalize their classes in $S$ +and discard repetitions. By extremality, $r$ is one of these points, +say $r_1$. Let $K$ be the convex hull of the others and of +$S\cap\{d+\varepsilon\omega\geq0\}$. This is compact and excludes +$r$; otherwise extremality of $r$ would fail. + +If $K$ is nonempty, strict separation gives a linear functional $h$ +with $h(r)=0$ and $h>0$ on $K$, after subtracting a multiple of $\omega$. +Regard it as a Bott--Chern class by duality. For all sufficiently small +$\delta>0$, $h-\delta d$ is strictly positive on $K$ and at $r$. +Since $S=\operatorname{conv}(\{r\}\cup K)$, it is strictly positive on +$S$, hence K\"ahler. Thus $\alpha=h/\delta$ has the required properties. +Its positive minimum on $K$ persists under small perturbations in +$R^\perp$; openness of the K\"ahler cone also preserves +$\alpha-d$. These perturbations give $\mathcal U_R$. If $K$ is empty, +then $S=\{r\}$ and $-d$ is K\"ahler; a small neighbourhood of $0$ in +$R^\perp$ has the required properties. This includes the case +$R^\perp=\{0\}$. +\end{proof} + +\begin{lemma}[Relative positivity]\label{lem:relative-positivity} +Let $f:T\to Z$ be a proper morphism of compact complex spaces, with $T$ +and $Z$ K\"ahler. Suppose that $L$ is a rational line bundle and +\[ + c_1(L)=\kappa-f^*\gamma, +\] +where $\kappa$ is K\"ahler on $T$ and $\gamma$ is a smooth real +Bott--Chern class on $Z$. Then $L$ is $f$-ample and $f$ is projective. +Conversely, a normal space projective over a compact K\"ahler space is +compact K\"ahler if it has a global relatively ample line bundle. +\end{lemma} + +\begin{proof} +Clear the denominator of $L$. Its Bott--Chern identity permits a smooth +Hermitian metric whose curvature is the indicated difference of forms. +On every fibre its curvature is positive. Positivity of a line bundle +on a compact complex space implies ampleness, and for a proper analytic +map ampleness on every fibre is equivalent to relative ampleness +\cite[Corollary~1.12 and Definition~3.1--Remark~3.2]{FujinoVanishing2026}. +This criterion does not presuppose projectivity and applies to +nonreduced fibres as well. Existence of the relatively ample line bundle +makes $f$ projective. + +For the converse, local relative embeddings give metrics on a relatively +ample bundle with positive curvature in fibre directions. Glue their +weights by a partition of unity on the base. The resulting metric +retains that positivity. Add a sufficiently large multiple of a base +K\"ahler form to its curvature. The sum is strictly positive; compactness +allows one multiple to work everywhere. +\end{proof} + +\subsection{The ordinary contraction and flip} + +We can now perform each step and preserve the category. The next +proposition records both the numerical ranks of the negative contraction +and the actual canonical algebra of a flip. The latter description will +also be used in the termination argument for arbitrary choices of negative rays. + +\begin{proposition}[Ordinary negative steps]\label{prop:ordinary-step} +Let $(T,B)$ be an ordinary rational klt pair on a normal compact K\"ahler +space of dimension at most four, globally $\Q$-factorial in the Weil-divisor sense, with canonical +sheaf a rational line bundle. Put $D=K_T+B$. Every $D$-negative +extremal ray $R\subset\NA(T)$ has a projective contraction $f:T\to Z$ +with connected fibres and normal compact K\"ahler target, such that +\begin{equation}\label{eq:ordinary-negative-bc} + f^*\BC(Z)=R^\perp,\qquad + \rho(T/Z)=1,\qquad -D\text{ is }f\text{-ample}. +\end{equation} +Here $\rho$ is the rank of global line-bundle degrees on contracted +curves. The target has rational singularities and +$R^j f_*\cO_T=0$ for $j>0$. If $\dim Z<\dim T$, this is a Mori fibre +space. Otherwise $f$ is bimeromorphic, and precisely one of the +following occurs. +\begin{enumerate}[label=\textup{(\roman*)}] +\item The exceptional locus is one prime divisor $E$. Put $T'=Z$, +$B'=f_*B$ and $D'=K_{T'}+B'$. Then +\begin{equation}\label{eq:ordinary-divisorial-difference} + D=f^*D'+eE\qquad(e>0). +\end{equation} +\item The contraction is small. For an adjoint Cartier index $r>0$, +the intrinsic algebra +\begin{equation}\label{eq:ordinary-flip-algebra} + \cR_r=\bigoplus_{m\geq0}f_*\cO_T(mrD) +\end{equation} +is locally finitely generated, and $T'=\Proj_Z\cR_r$ is the ordinary +flip. It has a small projective morphism $f^+:T'\to Z$ with connected +fibres. Put $B'=\phi_*B$ and $D'=K_{T'}+B'$, where +$\phi:T\dashrightarrow T'$ is the induced small map. For a sufficiently +divisible choice of $r$ there is an actual isomorphism +\begin{equation}\label{eq:ordinary-tautological} + \cO_{\Proj_Z\cR_r}(1)\simeq\cO_{T'}(rD'). +\end{equation} +In particular $D'$ is a rational line bundle and is $f^+$-ample. +Passing to a sufficiently divisible Veronese leaves $T'$ unchanged. +\end{enumerate} +In both birational cases, $T'$ is compact K\"ahler and globally +Weil-divisor $\Q$-factorial, its canonical sheaf is a rational line +bundle, and $(T',B')$ is klt. Strong global $\Q$-factoriality is +preserved when imposed on $T$. A supplied global canonical Weil divisor +is transported to a canonical Weil divisor on $T'$. No prime divisor is +extracted. All log discrepancies weakly increase; the increase is strict +for every original prime contracted by the step, and, for a flip, for +every place centred in either exceptional locus. +\end{proposition} + +\begin{proof} +Choose $\alpha\in\mathcal U_R$ from Lemma~\ref{lem:absolute-support} +and put $\kappa=\alpha-c_1(D)$. Proposition~\ref{repair:prop:supporting-contraction} +gives $f:T\to Z$ and $\gamma$ K\"ahler with $\alpha=f^*\gamma$. +Thus $c_1(-D)=\kappa-f^*\gamma$, and +Lemma~\ref{lem:relative-positivity} proves projectivity and relative +ampleness. This establishes projectivity without strong factoriality. +For every curve $C\subset T$, +\begin{equation}\label{eq:ordinary-contracted-curves} + f(C)\text{ is a point}\quad\Longleftrightarrow\quad + \alpha\cdot C=0\quad\Longleftrightarrow\quad[C]\in R. +\end{equation} +The rational curve generating $R$ is contracted, so $f$ is nontrivial. + +Relative vanishing gives $R^j f_*\cO_T=0$ for $j>0$ +\cite[Theorem~5.2]{Fujino2022}; the log Fano base has rational +singularities \cite[Lemma~8.8]{DHP2024}. Lemma~\ref{lem:pullback-image} +now identifies $f^*\BC(Z)$ with the classes of degree zero on all +vertical curves, which is exactly $R^\perp$. The global line-bundle +rank is also one, since all those curves are proportional and the +rational line bundle $D$ detects their ray. This proves +\eqref{eq:ordinary-negative-bc}. The lower-dimensional case has all +the stated Mori fibre-space properties. In equal dimension, +connectedness gives generic degree one, so $f$ is bimeromorphic. + +\smallskip\noindent +\emph{Divisorial contractions.} +Suppose $E$ is an exceptional prime. It is $\Q$-Cartier. If +$E\cdot R\geq0$, it would be $f$-nef, contradicting negativity for a +nonzero effective exceptional divisor. Thus $E\cdot R<0$. Every +vertical curve lies in $E$, since an effective $\Q$-Cartier divisor +has nonnegative degree on a curve outside its support. Every +positive-dimensional projective fibre is covered by curves. A +zero-dimensional local component of a connected fibre would be isolated, +and the birational form of Zariski's main theorem would make $f$ an +isomorphism there. Consequently $\Exc(f)=E$. + +For a prime Weil divisor $A_Z$ on $Z$, let $A_T$ be its strict transform. +Choose $t\in\Q$ so $(A_T+tE)\cdot R=0$. The coefficient is rational +by taking the ratio of the two rational degrees on one integral curve. +A Cartier multiple of $A_T+tE$ descends by Lemma~\ref{lem:descent}: +its difference from $D$ is relatively ample. The descended line bundle +agrees with the corresponding reflexive power of $\cO_Z(A_Z)$ off +$f(E)$, a subset of codimension at least two. Reflexivity identifies +them everywhere. Hence every global prime on $Z$ is $\Q$-Cartier. + +If a global canonical Weil divisor is given, push it forward. It agrees +with the canonical sheaf on the big open where $f$ is an isomorphism, so +reflexivity shows that it remains a canonical Weil representative. +Alternatively, start with an invertible reflexive power of $\omega_T$, +adjust it by a rational multiple of $E$ to degree zero, and descend after +clearing denominators. On the same big open the result is a reflexive +power of $\omega_Z$; hence that power is invertible everywhere. This +proves the canonical assertion without assuming a global meromorphic +canonical section. + +Now $D'$ is a rational line bundle and its canonical identification away +from $E$ gives \eqref{eq:ordinary-divisorial-difference}. Intersection +with $R$ gives $e>0$. If $b_E$ is the coefficient of $E$ in $B$, then +\[ + a(E;Z,B')=1-b_E+e>1-b_E=a(E;T,B)>0. +\] +Pullback of the effective divisor $eE$ gives weak increase for all other +log discrepancies. Thus the target pair is klt. + +\smallskip\noindent +\emph{The small canonical model.} +Suppose $f$ is small. Finite generation of the ordinary relative log +canonical ring \cite[Theorem~1.18]{Fujino2022} gives local finite +generation of \eqref{eq:ordinary-flip-algebra}. When canonical data are +written as sheaves, this application can be made over each Stein open +in $Z$: nonzero sections of rank-one proper direct images provide the +meromorphic representatives there. Changing representatives induces +compatible graded isomorphisms of the intrinsic algebra. + +The ordinary analytic flip theorem \cite[Theorem~1.14]{Fujino2022} +constructs precisely its relative canonical model. It has no local +factoriality hypothesis. Its proof glues the unique local log canonical +models, giving a normal small projective $f^+:T'\to Z$ globally. The +fibres are connected because $Z$ is normal. A finite cover of the +compact base permits one common sufficiently divisible Veronese +generated in degree one. Replace $r$ by that multiple. The resulting +tautological bundle is relatively ample and agrees with +$\cO_T(rD)$ on the common big open. Its reflexive extension is +$\cO_{T'}(rD')$, proving \eqref{eq:ordinary-tautological} as an actual +bundle isomorphism. This also proves that $D'$ is a rational line +bundle. The relative Proj is invariant under this Veronese operation. +By Lemma~\ref{lem:relative-positivity}, $T'$ is compact K\"ahler. + +For a global prime $A'$ on $T'$, transform it to $A$ on $T$ and choose +$t\in\Q$ so $(A+tD)\cdot R=0$. Descend a Cartier multiple by +Lemma~\ref{lem:descent}. On $T'$ its pullback agrees on the common big +open with the same multiple of $A'+tD'$. Reflexivity extends the +identification; since $D'$ is already a rational line bundle, $A'$ is +$\Q$-Cartier. This proves global Weil-divisor factoriality. A given +canonical Weil divisor is transported on that common open and then +reflexively. In the sheaf formulation, repeat the descent argument with +an invertible power of $\omega_T$ adjusted by $tD$; undoing the twist +by $tD'$ proves the rational-line-bundle property of $\omega_{T'}$. + +On a common smooth resolution $p:V\to T$, $q:V\to T'$, +Lemma~\ref{lem:negativity} gives the actual discrepancy divisor +\begin{equation}\label{eq:ordinary-small-difference} + p^*D=q^*D'+F,\qquad F\geq0, +\end{equation} +exceptional over both sides, with the asserted strictness over the +flipping and flipped loci. This also proves klt preservation. + +\smallskip\noindent +\emph{Optional strong factoriality.} +In the divisorial case, take any coherent rank-one reflexive sheaf +$\cF$ on $Z$. Its reflexive pullback to $T$ is coherent of rank one. +Strong factoriality supplies an invertible reflexive power. Adjust it +by a rational multiple of $E$, descend as above, and compare off $f(E)$. +A reflexive power of $\cF$ is therefore a line bundle. + +In the small case start with such a sheaf $\cF'$ on $T'$. On a common +smooth resolution put +\[ + \cM=(q^*\cF'/\text{torsion})^{**},\qquad + \cF=(p_*\cM)^{**}. +\] +Here $\cM$ is a line bundle and $\cF$ is coherent reflexive of rank one; +both give the required transform on the common big open. An invertible +power of $\cF$, adjusted by a rational multiple of $D$, descends. +Pull back the descended bundle and undo the twist by $D'$. After +clearing denominators, reflexivity identifies the resulting line bundle +with a reflexive power of $\cF'$. Thus the strong condition is +preserved. Only sheaves defined on the whole compact spaces have been +used. + +\end{proof} + +\subsection{Transport of Bott--Chern classes} + +For later scaling we need to transport one fixed nef datum. The following +construction uses the rank of the negative contraction only. It makes +no assertion that all Bott--Chern classes on a flipped space come from +the preceding space. + +\begin{lemma}[Class transport]\label{lem:class-transport} +For a birational step of Proposition~\ref{prop:ordinary-step}, let +$f':T'\to Z$ mean $f^+$ in the small case and $\id_Z$ in the divisorial +case. Every $\theta\in\BC(T)$ has a unique expression +$\theta=f^*\eta+s\,c_1(D)$, with $\eta\in\BC(Z)$ and $s\in\R$. +Define +\begin{equation}\label{eq:class-transport} + \theta'= (f')^*\eta+s\,c_1(D'). +\end{equation} +On a common resolution, $p^*\theta-q^*\theta'$ is the class of an +actual divisor exceptional over $T'$. This rule sends the class of a +global Weil divisor to that of its transform or pushforward. Moreover, +it propagates the fixed-nef-part trace relation of +Lemma~\ref{lem:class-trace}, with an actual effective exceptional +correction on the new model. The same conclusions hold for the ordinary +real-boundary steps of Proposition~\ref{repair:prop:real}. +\end{lemma} + +\begin{proof} +Since $D\cdot R\ne0$, subtracting a unique multiple of $c_1(D)$ makes +$\theta$ vanish on $R$. Equation~\eqref{eq:ordinary-negative-bc} and +pullback injectivity give the unique $\eta$. On a common resolution +over $Z$ the two pullbacks of $\eta$ agree. Therefore +\[ + p^*\theta-q^*\theta' + =s\,[p^*D-q^*D']. +\] +The expression in brackets is the actual exceptional discrepancy +divisor already constructed in the proof of the proposition. + +If $\theta=c_1(A)$ for a global Weil divisor $A$, the difference +$p^*A-q^*A'$ is likewise exceptional over $T'$, where $A'$ is its +transform or pushforward. Subtracting the two identities represents +$q^*(\theta'-c_1(A'))$ by a $q$-exceptional divisor. That divisor is +numerically trivial over $q$, so negativity in both signs makes it +zero. Pullback injectivity gives $\theta'=c_1(A')$. + +Finally suppose the old trace $H_T$ of a fixed nef class on an earlier +model has, on a common high resolution, the relation +\[ + p^*H_T=p_0^*H+[J_T]. +\] +If $H_T=f^*\eta+s\,c_1(D)$, the new correction is the actual divisor +\[ + J_{T'}=J_T-s(p^*D-q^*D'),\qquad + q^*H_{T'}=p_0^*H+[J_{T'}]. +\] +Every old exceptional divisor remains exceptional +over $T'$: neither kind of step extracts divisors. The resulting +correction $J_{T'}$ is therefore an actual $q$-exceptional divisor. +Its negative is $q$-nef because $p_0^*H$ is nef. Negativity gives +$J_{T'}\geq0$, and uniqueness and compatibility are those of +Lemma~\ref{lem:class-trace}. + +For the stated real-boundary extension, +Proposition~\ref{repair:prop:real} supplies the ordinary step and its +negative-side Bott--Chern rank. The difference $p^*D-q^*D'$ is an actual +exceptional real discrepancy divisor, as shown in +Section~\ref{repair:sec:real}. The decomposition, transport formula, +and correction argument above therefore apply unchanged. +\end{proof} + +\begin{remark}\label{rem:ordinary-continuation} +Proposition~\ref{prop:ordinary-step} starts on the given pair and can be +reapplied after every finite prefix of ordinary steps. It allows every +negative ray. Its construction is independent of any termination +claim, and makes no assertion about the positive-side quotient +$\BC(T')/(f^+)^*\BC(Z)$ or about equality of the full Bott--Chern ranks +across a flip. +\end{remark} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/04-terminal.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/04-terminal.tex new file mode 100644 index 0000000000000000000000000000000000000000..f1d2b85a123f7621d58200840d5d5106e310bb49 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/04-terminal.tex @@ -0,0 +1,587 @@ +\section{Termination for ordinary terminal fourfold pairs}\label{sec:counts} + +We prove termination of ordinary flips for compact K\"ahler fourfold +pairs with effective real boundary and log discrepancy $a(E)>1$ +for every exceptional place. Two finite counts +replace projectivity of the ambient fourfold: analytic cycle classes +control contractions, and low-discrepancy places control flipped surfaces. +The bases of successive projective contractions may vary. +We first establish these counts, including their generalized-pair form +needed for extraction later in the proof. + +\subsection{Loss of analytic cycle classes} + +For a compact complex analytic space $V$ and an integer $k\geq 0$, put +\[ + \begin{split} + \mathcal C_k(V) + &:=\operatorname{span}_{\R}\{[S]\in H_{2k}(V,\R): + S\subset V\text{ irreducible compact analytic},\ \dim S=k\},\\ + c_k(V)&:=\dim_{\R}\mathcal C_k(V). + \end{split} +\] +Fundamental classes here use the complex orientation on the regular loci. +Compact analytic spaces admit finite triangulations compatible with any +specified finite collection of closed analytic subsets, with simplicial +dimension at most twice the complex dimension. Thus $c_k(V)$ is finite. +We recall the abstract-space reduction to make the topology used here +explicit. Teissier's compatible Whitney stratification +\cite[Chapter~III, Propositions~1.5 and~2.2.2]{Teissier1982} has finitely +many strata on a compact space. Choose finitely many analytic charts +$z_j:U_j\hookrightarrow\C^{N_j}$ and nonnegative smooth cutoffs +$\rho_j$ compactly supported in these charts whose positivity sets +cover the space. Extend $\rho_j$ and $\rho_j z_j$ by zero. The map +\[ + x\longmapsto\bigl(\rho_j(x),\rho_j(x)z_j(x)\bigr)_j +\] +is a topological embedding into a Euclidean space. Near a point where +$\rho_j>0$, its components extend smoothly to the ambient chart and the +$j$-th block has the smooth left inverse $(t,w)\mapsto w/t$. +It is therefore locally an ambient smooth embedding, which preserves +the Whitney conditions. Mather's control data +\cite[Section~7, Proposition~7.1, and Section~8]{Mather1970} and +Goresky's triangulation theorem \cite[Section~5]{Goresky1978} now give +a compatible triangulation, smooth on each stratum. Compactness makes +it finite, and smoothness on strata gives the dimension bound. +Borel--Moore localization below is then the relative simplicial-chain +sequence for a closed analytic subset and its complement. + +If $V$ is K\"ahler and $S$ is such a subspace, then +\begin{equation}\label{eq:positive-cycle} + \langle[\omega]^k,[S]\rangle=\int_{S_{\mathrm{reg}}}\omega^k>0 +\end{equation} +for a K\"ahler form $\omega$ on $V$. Thus $[S]\neq 0$, including when +$V$ or $S$ is singular. + +\begin{lemma}[Cycle loss]\label{lem:cycle-loss} +Let $X\dashrightarrow Y$ be a bimeromorphic transformation of compact +K\"ahler spaces, represented by a proper bimeromorphic diagram. +Suppose it identifies +\[ + U=X\setminus A\simeq Y\setminus B, +\] +where $A$ and $B$ are closed analytic subspaces and $\dim Bc_k(Y)$. + +Consequently, in a sequence of bimeromorphic transformations of +$n$-dimensional compact K\"ahler spaces which extract no prime divisors, +only finitely many transformations contract a prime divisor. A small +transformation preserves $c_{n-1}$. +\end{lemma} + +\begin{proof} +The Borel--Moore localization sequence for $B\subset Y$ contains +\[ + H_{2k}(B,\R)\longrightarrow H_{2k}(Y,\R) + \xrightarrow{\ j_Y^*\ }H_{2k}^{\mathrm{BM}}(U,\R) + \longrightarrow H_{2k-1}(B,\R). +\] +The outside groups vanish: the real dimension of $B$ is at most $2k-2$. +Thus $j_Y^*$ is an isomorphism. Compose restriction from $X$ with its +inverse to obtain a linear map +\[ + H_{2k}(X,\R)\xrightarrow{\ j_X^*\ }H_{2k}^{\mathrm{BM}}(U,\R) + \xrightarrow{\ (j_Y^*)^{-1}\ }H_{2k}(Y,\R). +\] +For an irreducible $k$-cycle $S\subset X$ not contained in $A$, its +restriction is the fundamental class of $S\cap U$. Closing its image in +$Y$ gives its strict transform: analyticity follows by taking the proper +image of the corresponding strict transform in the given diagram. +The displayed map therefore sends $[S]$ to this transformed cycle class. +It sends $[S]$ to zero when $S\subset A$. + +Conversely, no $k$-dimensional subspace of $Y$ is contained in $B$. +Its strict transform in $X$ consequently maps to its fundamental class. +This proves the asserted surjection of cycle spans. If $S\subset A$ +has dimension $k$, its nonzero class, by \eqref{eq:positive-cycle}, is +in the kernel. This proves the strict inequality. + +For a transformation extracting no prime divisor, choose the common +isomorphic open so that the complement in the target has codimension +at least two. Every contracted source prime lies in the source +complement. Apply the result with $k=n-1$ at every step. The +nonnegative integer $c_{n-1}$ cannot decrease infinitely often. For a +small transformation both complements have codimension at least two, +so applying the result in both directions gives equality. +\end{proof} + +This argument does not assert surjectivity on full homology, and does +not compare the Bott--Chern spaces of the two models. + +\subsection{Low places on compact log smooth data} + +We use generalized discrepancies in the sense of +Section~\ref{sec:analytic}. A place is called exceptional over $X$ when +its center on $X$ has codimension at least two. + +\begin{lemma}[Low places and their projective realization]\label{lem:low-places} +Let $(X,B+\bM)$ be a generalized pair on a compact normal complex +space, with effective real boundary of finite support and nef +b-$(1,1)$ data descending to a model projective over $X$. Fix a projective log resolution $p:W\to X$ carrying those data. +\begin{enumerate}[label=\textup{(\roman*)}] +\item If the pair is generalized klt, there is $\epsilon>0$ such that +every prime divisor over $X$ has log discrepancy at least $\epsilon$, +and only finitely many exceptional places have +\[ + a(E;X,B+\bM)<1+\epsilon. +\] +\item If the pair is generalized terminal and +$b=\max(\{0\}\cup\{\operatorname{coeff}_D B\})$, there are only +finitely many exceptional places with +\[ + a(E;X,B+\bM)<2-b. +\] +\item If the pair is generalized lc and $U\subset X$ is its generalized +klt locus, there is $\epsilon>0$ for which the assertion in \textup{(i)} +holds for places whose centers meet $U$. +\end{enumerate} +In each assertion the finite set of exceptional places can be represented +simultaneously by prime divisors on a smooth model projective over $X$. +In particular, any prescribed finite set of exceptional places with +$a(E;X,B+\bM)\leq 1$ for a generalized klt pair has such a realization. +This conclusion does not use an extraction or termination theorem. +\end{lemma} + +\begin{proof} +Let $L\in\BC(X)$ be the generalized log class and let +$M_W=[\bM_W]$ be the nef trace class on $W$. Write the crepant formula as +\begin{equation}\label{eq:carrier-boundary-count} + [K_W+\Delta]+M_W=p^*L. +\end{equation} +This is the crepant boundary identity defining generalized +discrepancies; it is an equality of Bott--Chern classes when the nef +data are transcendental. The boundary $\Delta$ is an actual real +divisor with simple normal crossing support. Since the nef data +descend to $W$, every further generalized discrepancy is the ordinary +discrepancy for $(W,\Delta)$. The coefficients of $\Delta$ need not be +nonnegative. We may enlarge its listed simple normal crossing divisor +by components of coefficient zero. +Here a closed stratum means an irreducible component of an intersection +of listed components; it is smooth, and is the closure of its open +stratum. + +We give the local estimate and the realization argument explicitly; +they are the log smooth calculations underlying +\cite[Proposition~2.36]{KM1998} and +\cite[Proposition~2.8]{CT2023}. +Write $\Delta=\sum_j d_jD_j$ and put $w_j=1-d_j$. +Suppose first that every $w_j$ is positive, and set +\[ + \delta=\min\bigl(\{1\}\cup\{w_j\}_j\bigr)>0. +\] +Let $E$ be exceptional over a smooth model with this log smooth +boundary. At a general point of its center $C$, let $c=\codim C$, +and choose local parameters $x_1,\ldots,x_c$ for $C$ so that the +boundary components containing $C$ are $x_1=0,\ldots,x_r=0$. +For $v=\operatorname{ord}_E$, the Jacobian calculation gives +\begin{equation}\label{eq:coordinate-discrepancy-count} + a(E;W,\Delta)\geq + \sum_{j=1}^{r}(1-d_j)v(x_j)+\sum_{j=r+1}^{c}v(x_j). +\end{equation} +Indeed, on a smooth model containing $E$, with local parameter $t$ +for $E$, write $x_j=t^{v(x_j)}u_j$ at its general point. In a top +exterior differential at most one factor can use the term involving +$dt$ that lowers the order by one. Thus the relative Jacobian has +order at least $\sum_{j=1}^c v(x_j)-1$. Adding one and subtracting +the boundary orders proves \eqref{eq:coordinate-discrepancy-count}. +The remaining coordinates along $C$ are holomorphic and contribute +no negative orders. + +In particular every discrepancy is at least $\delta$: for a divisor +already on the smooth model it is its listed weight, or one if it is +not listed; for an exceptional divisor use +\eqref{eq:coordinate-discrepancy-count}. If $C$ is not a stratum of +the listed simple normal crossing divisor, then $c>r$. When $r>0$, +the right hand side is at least $\delta+1$; when $r=0$, it is at +least $c\geq 2\geq\delta+1$. Hence +\begin{equation}\label{eq:nonstratum-cutoff} + C\text{ not a stratum}\quad\Longrightarrow\quad + a(E;W,\Delta)\geq 1+\delta. +\end{equation} + +Now fix a place $E$ with discrepancy strictly below $1+\delta$. +If it is not already a divisor on $W$, its center is a stratum by +\eqref{eq:nonstratum-cutoff}. Blow up that closed stratum. +The center is smooth, the blowup is projective, and the new listed +boundary is again simple normal crossing. If the center is the +intersection of the components indexed by $J$, then the new exceptional +component has weight +\begin{equation}\label{eq:stratum-weight-sum} + w_{\mathrm{new}}=\sum_{j\in J}w_j. +\end{equation} +Thus all weights remain at least $\delta$, so the same argument +applies on the next model. It excludes a non-stratum center at +every stage until $E$ becomes a divisor. + +This process is finite. While $E$ is exceptional, a blowup of its +smooth center of codimension $c\geq2$ changes its ordinary +empty-boundary discrepancy by +\[ + a(E;W_{\mathrm{new}},0) + =a(E;W_{\mathrm{old}},0)-(c-1)v(\mathcal I_C). +\] +The subtracted quantity is a positive integer, whereas an ordinary +log discrepancy over a smooth space is a positive integer. +Consequently only finitely many such blowups are possible. +Thus $E$ is obtained by successive stratum blowups, which is the +meaning of a \emph{toroidal place} here. This also realizes it on a projective model without first assuming +that the original model on which $E$ was given was projective over $X$. + +For completeness, there are only finitely many such toroidal places. +A toroidal prime over a fixed irreducible stratum is determined by a +primitive nonzero vector $(m_j)_{j\in J}$ of nonnegative integers +in the normal boundary directions. Its discrepancy is +\begin{equation}\label{eq:monomial-discrepancy-count} + \sum_{j\in J}m_jw_j. +\end{equation} +These statements follow also directly from the successive stratum +blowups: a blowup inserts the sum of the relevant coordinate rays, +and the discrepancy transforms by \eqref{eq:stratum-weight-sum}. +The vector determines the monomial order and is unchanged when a +boundary equation is multiplied by a unit. There are finitely many +irreducible strata on the compact model. Since each $w_j\geq\delta$, +an upper bound $T$ on \eqref{eq:monomial-discrepancy-count} bounds +every $m_j$ by $T/\delta$. This leaves finitely many vectors and +hence finitely many places. Add the finitely many prime divisors +already on $W$ which are exceptional over $X$. + +For a generalized klt pair, all weights in +\eqref{eq:carrier-boundary-count} are positive. The preceding +argument with $\epsilon=\delta$ proves \textup{(i)} and its projective +realization assertion. In particular $a\leq1$ lies strictly below +$1+\delta$. + +No rationality of the weights was used: their fixed positive minimum +bounds the nonnegative integer vectors. Thus the conclusion applies +to real boundaries and real nef data. + +For a generalized terminal pair, the coefficient of every +$p$-exceptional component in $\Delta$ is negative, since its +log discrepancy is greater than one. The other coefficients are +the original boundary coefficients and are at most $b<1$. +All the weights on $W$ are therefore at least $1-b$. +Repeat the argument with $\delta=1-b$ and $T=2-b$ to prove +\textup{(ii)}. Subsequent stratum blowups preserve this lower bound +by \eqref{eq:stratum-weight-sum}. + +For \textup{(iii)}, the weights on $W$ are nonnegative. Set +\[ + \delta=\min\bigl(\{1\}\cup\{w_j:w_j>0\}\bigr)>0. +\] +The coefficient-one components have image in $X\setminus U$. +Thus, at the general center on $W$ of a place whose center on $X$ +meets $U$, no zero-weight component occurs. Work there over $U$. +The same estimates and stratum blowups use only positive weights, +so give the uniform lower bound and the strict cutoff $1+\delta$. +The strata in question are restrictions of the finitely many global +strata, and the blowups can be performed along their smooth closed +closures on the compact model. Meeting a zero-weight component +elsewhere does not change a weight computed at the general point +of the center. This proves finiteness and projective realization +also in this case. + +Finally, to represent the entire finite set at once, take the +dominating component of the fiber product of the finitely many +projective realizations over $W$, normalize, and resolve projectively. +The strict transforms of the designated prime divisors remain +divisors on this common model. Its composite map to $X$ is projective. +\end{proof} + +\begin{remark}\label{rem:strict-low-cutoff} +The strict inequalities in Lemma~\ref{lem:low-places} are necessary. +For example, in $\mathbf P^n$, $n\geq3$, let $H$ be a hyperplane +with coefficient $b\in[0,1)$. Blowing up any codimension-two linear +subspace contained in $H$ gives log discrepancy $2-b$ for +$(\mathbf P^n,bH)$. There are infinitely many such places, although +this pair is terminal. With empty boundary their discrepancy is two. +Below we count places strictly below a threshold and use a step at +which a place reaches that threshold to obtain a strict decrease. +\end{remark} + + +\subsection{Surface centres of low-discrepancy places} + +The terminal termination argument must allow many places of discrepancy +below two above a moving boundary surface. The next lemma identifies +exactly the infinite families that will be harmless. We use the treatment +of successive blowups above each surface in +\cite[Proposition~3.1 and Lemma~3.2]{Fujino2005Addendum}. + +\begin{lemma}\label{lem:terminal-codim-two} +Let $(T,\Phi)$ be an ordinary klt pair on a normal complex fourfold, +with effective real boundary, $K_T$ a $\Q$-line bundle, and +$a(E;T,\Phi)>1$ for every exceptional prime divisor $E$ over $T$. +Then $T$ is smooth in codimension two. +\end{lemma} + +\begin{proof} +Dropping the effective boundary shows that $T$ has terminal +singularities. Suppose its singular locus has a codimension-two +component. Near a general smooth point of this component choose a +holomorphic projection to $\C^2$ submersive along it. Take a general +fibre transverse both to the regular locus and, on a fixed log +resolution, to the exceptional divisor and its strata. These +transversality conditions hold after shrinking and choosing a general +value. The resulting surface is a complete intersection in the +Cohen--Macaulay space $T$, since klt singularities are rational, and is +regular outside isolated points. It is therefore normal. + +Adjunction of a local Cartier pluricanonical power, first on the regular +locus and then by reflexivity, restricts the relative canonical equality +to the surface resolution. All its exceptional discrepancy coefficients +are positive. A normal surface germ with this property is smooth. +Indeed, negative definiteness of the exceptional intersection matrix +shows that a positive exceptional discrepancy divisor has negative +intersection with some exceptional curve. That curve has negative +canonical degree; adjunction makes it a smooth rational $(-1)$-curve. +Contract it smoothly and repeat. The remaining discrepancy coefficients +stay positive by pushforward. Eventually no exceptional curve remains, +and the proper bimeromorphic map to the normal surface is an isomorphism. + +On the other hand, a slice of a singular fourfold point by two equations +has embedding dimension at least the ambient embedding dimension minus +two, and hence greater than two. The chosen surface is singular there, +a contradiction. +\end{proof} + +\begin{lemma}\label{lem:terminal-low-centres} +Let $(T,\Phi)$ be an ordinary klt pair on a compact normal complex +fourfold, where $\Phi\geq0$ is real and +$a(E;T,\Phi)>1$ for every exceptional prime divisor $E$ over $T$. +Apart from finitely many exceptional places, every exceptional place with +$a(E;T,\Phi)<2$ has centre a surface $S\subset T$ with the following +properties: $T$ and the reduced support of $\Phi$ are generically smooth +along $S$, exactly one positive boundary component contains $S$, and, +if its coefficient is $b$, then +\[ + a(E;T,\Phi)\geq 2-b. +\] +All places above such a surface are allowed in this conclusion, not just +the exceptional divisor of its first blowup. +\end{lemma} + +\begin{proof} +Choose a log resolution on which the positive strict boundary components +are smooth and mutually disjoint. Starting with simple normal crossing +support, blow up intersections of the positive components to separate +them. Every exceptional crepant coefficient is negative by terminality. +Thus the only positive components on this resolution are those disjoint +strict transforms, with their original coefficients. + +Consider a place not already on the resolution. At its general centre, +apply \eqref{eq:coordinate-discrepancy-count}, dropping negative boundary +coefficients. A centre of codimension at least three has log discrepancy +at least $3-b>2$, if it lies in a positive component of coefficient $b$, +and at least three otherwise. A codimension-two centre outside the +positive support has log discrepancy at least two. Thus a place with +$a<2$ has codimension-two centre in one positive component, and its log +discrepancy is at least $2-b$. + +If this centre lies in the exceptional locus, it is an irreducible +component of the intersection of that positive component and an +exceptional divisor. There are finitely many such centres on the compact +resolution. We check that each supports only finitely many places with +$a<2$. It suffices to retain only the smooth component of coefficient +$b$, since deleting the negative coefficients lowers discrepancies. +Blow up the fixed centre at its general point. Unless the given place +has appeared, the same estimate forces its next centre to be the +intersection of the positive strict transform and the new exceptional +divisor. This intersection is unique over the general point of the +original centre. The successive exceptional log discrepancies are +\[ + 1+k(1-b),\qquad k=1,2,\ldots. +\] +At each further stage the negative coefficient of the newest exceptional +divisor adds $k(1-b)$ to the lower bound $2-b$. Hence only +$k<1/(1-b)$ can occur before the cutoff two is reached. This proves +finiteness over every fixed exceptional centre. These generic blowups +are realized globally by blowing up the closures of the centres. + +Add the finitely many exceptional primes on the chosen resolution. +All other centres under consideration lie outside its exceptional locus +at their general points, where the resolution is an isomorphism. Their +images are precisely the surfaces described in the statement. +\end{proof} + +We now have the two counts needed for termination. A flipped surface +will give a place whose discrepancy strictly increases into a fixed +finite set. Once such surfaces disappear, a compact surface-class rank +will decrease at every remaining step. + +\subsection{Real terminal pairs} + +\begin{proposition}\label{prop:terminal-real-four} +Let $(T_0,\Phi_0)$ be an ordinary klt pair on a normal globally +$\Q$-factorial compact K\"ahler fourfold, with $K_{T_0}$ a +$\Q$-line bundle and effective real boundary. Suppose +$a(E;T_0,\Phi_0)>1$ for every exceptional prime divisor $E$ over $T_0$. +Every sequence of ordinary $(K_{T_i}+\Phi_i)$-flips starting at this +pair terminates, provided all models are normal globally $\Q$-factorial +compact K\"ahler fourfolds, each $K_{T_i}$ is a $\Q$-line bundle, and +each flip is given by projective small contractions +\[ + T_i\xrightarrow{\ f_i\ }Z_i + \xleftarrow{\ f_i^+\ }T_{i+1} +\] +with $-(K_{T_i}+\Phi_i)$ relatively ample for $f_i$ and +$K_{T_{i+1}}+\Phi_{i+1}$ relatively ample for $f_i^+$. +Here $\Phi_{i+1}$ is the strict transform of $\Phi_i$. +No pseudo-effectivity or bigness assumption is required. +\end{proposition} + +\begin{proof} +By Lemma~\ref{lem:negativity}, discrepancies do not decrease, and they +increase strictly for a place centred in either exceptional locus. +Since the maps are small, the exceptional places are the same on all +models. Thus every pair remains terminal in the stated sense, and its +ambient fourfold is smooth in codimension two by +Lemma~\ref{lem:terminal-codim-two}. + +Write the distinct positive coefficients of the boundary in decreasing +order. We successively remove, by discarding finitely many initial +steps, every flipping and flipped surface contained in a component of +each coefficient. After the positive coefficients we treat the value +zero, at which stage every flipped surface is considered. + +\smallskip\noindent +\emph{Eliminating flipped surfaces.} +Fix the current coefficient $b$, and suppose that no flipping or flipped +surface is contained in a component of coefficient greater than $b$. +For $b=0$ assume that all positive coefficients have already been treated. +If $S$ is a flipped surface contained in a coefficient-$b$ component, +or any flipped surface when $b=0$, blow it up at its general point. +The exceptional prime $E$ has new log discrepancy +\begin{equation}\label{eq:surface-witness-values} + a(E;T_{i+1},\Phi_{i+1}) + =2-\sum_{l=1}^{s}b_l\operatorname{mult}_{S}\Phi_{l,i+1}, + \qquad 1b$. +That centre persists as a surface in this component at every later +step: at each step the map is an isomorphism at its general point, +since otherwise the centre itself would be a flipping surface in a +higher-coefficient component. It cannot become a flipped surface +either, by the same higher-coefficient exclusion. Thus it cannot be +the place just constructed. All these witness places belong to a +fixed finite set. + +Each member of that finite set is used only finitely often. Between +uses its discrepancy does not decrease, and at each use it strictly +increases to one of the finitely many values +\eqref{eq:surface-witness-values}. Consequently only finitely many +steps have a flipped surface of the current kind. Pass beyond them. + +\smallskip\noindent +\emph{Eliminating flipping surfaces inside the boundary.} +Suppose $b>0$. Fix a coefficient-$b$ component and normalize its +transforms on the two sides of a flip. Denote the normalizations by +$D_i^\nu,D_{i+1}^\nu$, and normalize their common image in $Z_i$ to +obtain $B_i$. The induced maps to $B_i$ are proper and bimeromorphic. +They are isomorphisms away from the inverse image of the common +exceptional image in $Z_i$, whose dimension is at most one by +Lemma~\ref{lem:negativity}. Finite normalization preserves this bound. +On $D_{i+1}^\nu$ its inverse image also has dimension at most one, +because no flipped surface is contained in the boundary component. + +Every compact surface in $B_i$ has a strict transform on $D_i^\nu$, +so pushforward gives a surjection +\[ + \mathcal C_2(D_i^\nu)\longrightarrow\mathcal C_2(B_i). +\] +On the other side, Borel--Moore localization along the exceptional +subset of dimension at most one makes restriction in degree four +injective. Compatibility with proper pushforward and the common +isomorphic open therefore gives an injection +\[ + \mathcal C_2(D_{i+1}^\nu)\lhook\joinrel\longrightarrow + \mathcal C_2(B_i). +\] +These are assertions about surface spans; no surjectivity on the full +fourth homology of the negative side is needed. + +If a flipping surface lies in this boundary component, a surface above +it on $D_i^\nu$ maps to a set of dimension at most one in $B_i$. +Its class is nonzero: its image in $T_i$ is a surface, and the square +of a K\"ahler class on $T_i$ has strictly positive integral over it. +One may compute this integral on a resolution of the surface. +The finite normalization has positive generic degree on this surface, +so the same nonvanishing holds upstairs. Its class is a nonzero +kernel vector in the displayed surjection. Hence +\[ + c_2(D_i^\nu)\geq c_2(D_{i+1}^\nu), +\] +with strict inequality whenever the component contains a flipping +surface. Summing over the finitely many coefficient-$b$ components +shows that only finitely many such steps occur. This completes the +induction at $b$. + +\smallskip\noindent +\emph{The remaining flips.} +After the positive coefficients have been treated, perform the +flipped-surface argument with $b=0$. No flipped surface remains. +For every remaining flip, Lemma~\ref{lem:negativity} gives +\[ + \dim\Exc(f_i)+\dim\Exc(f_i^+)\geq3. +\] +Smallness bounds both dimensions by two, so $\Exc(f_i)$ contains a +surface and $\dim\Exc(f_i^+)\leq1$. Apply +Lemma~\ref{lem:cycle-loss} with $k=2$ to the common isomorphic open. +It gives $c_2(T_i)>c_2(T_{i+1})$ at every remaining step, impossible +for an infinite sequence of nonnegative integers. +\end{proof} + +The algebraic discrepancy and cycle-count strategy originates in +\cite[Theorem~5-1-15 and Lemmas~5-1-16--5-1-17]{KMM1987} +and \cite{Fujino2004,Fujino2005Addendum}. +The proof above supplies the real-boundary argument and uses compact +analytic cycle classes with K\"ahler positivity. It applies those +geometric tools one step at a time, without a common projective base. + +\begin{corollary}\label{prop:terminal-four} +Let $X_0$ be a normal globally strongly $\Q$-factorial compact +K\"ahler fourfold with terminal singularities. +Every sequence starting at $X_0$ of ordinary empty-boundary negative +divisorial contractions and flips, with the projectivity and compact +K\"ahler conclusions of Proposition~\ref{prop:ordinary-step}, terminates. +No pseudo-effectivity hypothesis is required for this assertion about +birational sequences. +\end{corollary} + +\begin{proof} +For flips, terminality persists by Lemma~\ref{lem:negativity}. +For a divisorial contraction, \eqref{eq:ordinary-divisorial-difference} +gives $K_{X_i}=f^*K_{X_{i+1}}+eE$ with $e>0$. +The lost prime has target log discrepancy $1+e>1$; every other +exceptional place has target discrepancy at least its source +discrepancy, which was greater than one. Thus terminality persists +throughout the sequence. +Lemma~\ref{lem:cycle-loss} with $k=3$ bounds the number of divisorial +steps. Any infinite sequence would therefore have a tail consisting +only of flips, contrary to Proposition~\ref{prop:terminal-real-four} +with zero boundary. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/05-scaling.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/05-scaling.tex new file mode 100644 index 0000000000000000000000000000000000000000..0d08f5a200bd7d763ed7d41c73a8532be8faaa6f --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/05-scaling.tex @@ -0,0 +1,98 @@ +\section{The ordinary scaling construction}\label{sec:scaling} + +We record the ordinary scaling construction used in the +lower-dimensional induction of Section~\ref{sec:contractions}. The +construction starts on the given pair and uses only ordinary negative +steps, with a fixed Kähler class as the scaling direction. + +Fix a smooth Kähler form \(h\) on \(X\), with class \(H\), large enough +that \(K_X+\Delta+H\) is nef. Throughout this section +\(\mathbf H\) denotes the fixed b-nef datum obtained by pulling back +this very form. On subsequent models its trace class is denoted by +\(H_T\), as in Lemma~\ref{lem:class-trace}. We do not replace the +fixed datum by arbitrary cohomologous current representatives. + +\subsection{Constructing the scaling program} + +\begin{proposition}\label{prop:scaling-construction} +Let \((X,\Delta)\) satisfy the hypotheses of Theorem~\ref{thm:finite}. +There is an ordinary negative-ray program, finite or infinite, +\[ + (X,\Delta)=(X_0,\Delta_0)\dashrightarrow + (X_1,\Delta_1)\dashrightarrow\cdots, +\] +in the same global Weil-divisor \(\Q\)-factorial compact Kähler +category. It stops when the ordinary adjoint is nef or a negative ray +has a Mori fibre contraction. Put +\[ + D_i=K_{X_i}+\Delta_i,\qquad + L_i(t)=D_i+tH_i,\qquad H_i=H_{X_i},\qquad \lambda_{-1}=1. +\] +At every stage before stopping there is a parameter +\(0<\lambda_i\leq\lambda_{i-1}\) and a contracted extremal ray +\(R_i\) such that +\[ + D_i\cdot R_i<0,\qquad L_i(\lambda_i)\cdot R_i=0, + \qquad L_i(\lambda_i)\text{ is nef}. +\] +The generalized pairs \((X_i,\Delta_i+t\mathbf H)\) are gklt for +\(0\leq t\leq\lambda_{i-1}\). A birational step is crepant for the +data at \(t=\lambda_i\), and discrepancies do not decrease across +that step for any \(0\leq t\leq\lambda_i\). +\end{proposition} + +\begin{proof} +On \(X_0\), the nef datum descends, so its addition changes no +discrepancies. Thus all the initial generalized pairs are gklt. +Suppose the assertions have been established through \(X_i\). +If \(D_i\) is nef, stop. Otherwise define +\[ + \lambda_i=\min\{t\in[0,\lambda_{i-1}]:L_i(t)\text{ is nef}\}. +\] +The set is nonempty by induction and is closed and convex. Its minimum +is positive because \(D_i\) is not nef. + +We first find a ray at this threshold. Choose +\(t_k\uparrow\lambda_i\) with \(\lambda_i/20\), so \(D_i\cdot R_i<0\). + +Apply Proposition~\ref{prop:ordinary-step} to this ordinary negative +ray, and denote its contraction by \(f_i:X_i\to Z_i\). A fibre +contraction gives the stopping alternative. Otherwise make the +ordinary divisorial step or flip. Lemma~\ref{lem:class-transport} +transports the trace \(H_i\) to \(H_{i+1}\) while preserving its +relation to the fixed b-datum. By Lemma~\ref{lem:pullback-image}, the +class \(L_i(\lambda_i)\) descends to \(Z_i\). Its descended class +is nef, and its pullback on the new model is +\(L_{i+1}(\lambda_i)\). Thus the two threshold classes have equal +pullbacks on a common resolution. Their difference is represented by +the actual exceptional discrepancy divisor, which vanishes by +negativity as in Lemma~\ref{lem:small-comparison}. The step is +consequently generalized crepant at the threshold. + +For completeness, this also proves the induction on singularities. +On a common resolution, the log discrepancy at each prime \(E\) is +affine in \(t\). Its difference across the step is zero at +\(t=\lambda_i\) and is the ordinary discrepancy increase at zero. +Consequently +\begin{align} + &a(E,X_{i+1},\Delta_{i+1}+t\mathbf H) + -a(E,X_i,\Delta_i+t\mathbf H)\notag\\ + &\qquad=\left(1-\frac{t}{\lambda_i}\right) + \bigl(a(E,X_{i+1},\Delta_{i+1})-a(E,X_i,\Delta_i)\bigr) + \geq0\label{eq:scaling-interpolation} +\end{align} +for \(0\leq t\leq\lambda_i\). The generalized pairs on this +interval remain gklt, and the new upper-threshold class is nef. The +ordinary steps preserve all the stated properties of the original +category by Proposition~\ref{prop:ordinary-step}. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/06-perturbation.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/06-perturbation.tex new file mode 100644 index 0000000000000000000000000000000000000000..8308289f6c0551eb64a1f0ef8a11e393da3e5f7b --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/06-perturbation.tex @@ -0,0 +1,2614 @@ +\section{Supporting contractions and finite ordinary programs} +\label{sec:perturbation}\label{sec:contractions} + +The generalized pairs in this section have an effective real boundary and +a fixed nef Bott--Chern class on a smooth carrier projective over the +initial space. Their structure boundaries on higher models define +generalized log discrepancies; generalized klt means that these +discrepancies are positive. Equalities of $(1,1)$-classes mean +Bott--Chern equality. Equalities of line bundles are actual isomorphisms +after clearing the stated denominators. + +The proof uses Theorem~1.1 of \cite{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026} only for existing +rational flip sequences. That theorem uses the low-place, relative-program, +extraction, and special-termination results proved in +Lemma~\ref{lem:low-places} and +Sections~\ref{sec:relative}--\ref{sec:special}. Those results precede +this use logically and do not depend on Theorem~\ref{thm:finite}. +In particular, the lower-dimensional +termination theorem used below is Theorem~\ref{thm:gklt-three}, proved +from the projective relative constructions in Section~\ref{sec:relative}. +When the ordinary-step construction is used in lower dimensions, it is +applied only after the corresponding assertion $\mathsf B_d$ has been +established in the induction. + +\subsection{Projectivity when a rational line bundle detects the ray} + +We use the cone duality and finite-dimensional real Bott--Chern +spaces of Section~\ref{sec:analytic}. A rational line bundle means an +element of $\Pic(T)\otimes\Q$. Relative ampleness always means a +single global line bundle, after clearing a denominator. + +\begin{lemma}\label{repair:lem:polarization} +Let $f:T\to Z$ be a proper contraction between normal compact +K\"ahler spaces. Suppose $\gamma$ is K\"ahler on $Z$ and +\[ + \alpha=f^*\gamma,\qquad + \NA(T)\cap\alpha^\perp=R +\] +is a nonzero ray. If a global rational line bundle $D$ has +$D\cdot R<0$, then $-D$ is relatively ample and $f$ is projective. +\end{lemma} +\begin{proof} +Fix a K\"ahler class $\omega$ on $T$ and normalize $\NA(T)$ by +$\omega\cdot z=1$. The resulting slice $S$ is compact. Its unique +point on $R$ has negative $D$-degree, so $d=c_1(D)$ is negative on +a neighborhood of that point in $S$. On the complementary compact +set, $\alpha$ has a strictly positive minimum, while $d$ is bounded. +For all sufficiently small $s>0$, the class $\alpha-sd$ is therefore +strictly positive on $S$ and is K\"ahler by cone duality. + +Choose an integer $m>0$ making $mD$ integral. Then +\[ + c_1(-mD)+f^*((m/s)\gamma)=(m/s)(\alpha-sd) +\] +is K\"ahler. On a neighborhood in the base with a potential for +$\gamma$, absorb that potential in a smooth metric on the same global +line bundle $-mD$. Its curvature is positive on the fibres. The analytic +positive-line-bundle criterion and the fibrewise relative-ampleness +criterion make $-mD$ relatively ample. The line bundle was global +throughout, so no gluing of unrelated local polarizations is required. +\end{proof} + +If, as in Proposition~\ref{prop:ordinary-step}, $\alpha-c_1(D)$ is already K\"ahler, +one can apply this metric argument directly with $s=1$. +This proves projectivity after the contraction exists; it does not +construct that contraction. + +\subsubsection{Constructing a generalized flip from one global line bundle} + +The next argument supplies a global flip algebra whenever a projective +negative contraction has an actual line bundle detecting its ray. It will +allow the lower-dimensional reductions to use ordinary rational flips. + +\begin{proposition}[A global algebra for a detected flip] +\label{repair:prop:detector-flip} +Let $(T,B+\mathbf M)$ be a gklt pair on a normal compact K\"ahler +space which is globally strongly $\Q$-factorial, and let $A\in\BC(T)$ +be its adjoint class. Let $f:T\to Z$ be a projective small contraction +onto a normal compact K\"ahler space. Suppose that the classes of all +$f$-vertical curves lie on one ray $R\subset\NA(T)$, that $A\cdot R<0$, +and that a global line bundle $L$ satisfies $L\cdot R<0$. + +Then $\bigoplus_{m\geq0}f_*L^m$ is locally finitely generated. The +relative Proj of a sufficiently divisible Veronese is a projective +small contraction $f^+:T^+\to Z$, where $T^+$ is compact K\"ahler and +globally strongly $\Q$-factorial. The reflexive transform $L^+$ is a +rational line bundle, with a positive power equal to the relatively +ample tautological bundle. The transformed boundary and the same +b-nef datum define a gklt pair on $T^+$, with relatively K\"ahler +adjoint $A^+$. This is the generalized flip, with the usual +strict discrepancy increase at centres in either exceptional locus. + +Moreover, if $t=(A\cdot C)/(L\cdot C)>0$ for an $f$-vertical curve $C$, +then there is a unique $\eta\in\BC(Z)$ such that +\[ + A=t\,c_1(L)+f^*\eta,\qquad + A^+=t\,c_1(L^+)+(f^+)^*\eta. +\] +Every class on $T$ has the corresponding forward transport with an +actual exceptional-divisor correction. No assertion of surjectivity +on Bott--Chern groups is required. +\end{proposition} + +\begin{proof} +Since $f$ has a global relatively ample bundle and all its vertical +curves lie on $R$, numerical invariance of ampleness on the projective +fibres shows that $-L$ is $f$-ample. + +\smallskip\noindent +\emph{A local rational ordinary adjoint.} +Fix $z\in Z$ and a relatively compact Stein neighbourhood $U$. +Take a projective log resolution $p:V\to T_U$ carrying $\mathbf M$, +and put $\rho=f p$. Write its actual structure boundary as $B_V$, so +\[ + [K_V+B_V]+[\mathbf M_V]=p^*A. +\] +Every coefficient of $B_V$ is less than one. Canonical divisors and a +Cartier representative $D_L$ of $L$ can be chosen over $U$: the relevant +proper direct images have rank one on the birational isomorphism locus, +and Cartan's Theorem~A supplies sections nonzero there. Choose compatible +canonical representatives and set +\[ + N=t p^*D_L-K_V-B_V. +\] +For every $\rho$-vertical curve, its degree equals that of $\mathbf M_V$. +Thus $N$ is $\rho$-nef. + +It is also $\rho$-big. Indeed, write $N$ as a positive convex combination +of finitely many rational Cartier divisors $N_j$ in its finite Cartier +span. If $P$ is $\rho$-ample and $q_jN_j$ is integral, Cartan's +Theorem~A applied to the rank-one sheaf $\rho_*(q_jN_j-P)$ gives +$q_jN_j\sim P+E_j$ with $E_j\geq0$. Hence $N\sim_{\R}H+E$ with $H$ +relatively ample and $E\geq0$. +Choose $\epsilon>0$ small enough that $(V,B_V+\epsilon E)$ is sub-klt. +The divisor $(1-\epsilon)N+\epsilon H$ is relatively ample. Express it +as a positive combination of rational ample divisors and take general +members of sufficiently high multiples. Relative Bertini +\cite[Theorem~2.20]{DHP2024}, applied on a log resolution of $B_V+E$, +gives an effective $\Theta\sim_{\R}N$ such that $(V,B_V+\Theta)$ is +sub-klt. The high multiples make the added coefficients arbitrarily +small. All choices are made near the compact fibre; shrink $U$ once +to retain them. + +Put $\Delta=p_*(B_V+\Theta)\geq0$. Pushing down the finite +principal-divisor expression and pulling it back again give +\[ + K_{T_U}+\Delta\sim_{\R}tD_L, + \qquad p^*(K_{T_U}+\Delta)=K_V+B_V+\Theta. +\] +Thus $(T_U,\Delta)$ is klt. Any finitely many base line bundles in a +relative linear equivalence can first be trivialized by shrinking $U$. +Record the resulting equality as +\begin{equation}\label{repair:eq:detector-rationalization} + K_{T_U}+\sum_i d_iD_i=tD_L+\sum_j b_j\operatorname{div}(g_j), + \qquad d_i>0, +\end{equation} +using the positive support of $\Delta$. After a further relatively +compact shrinking, the displayed divisors have finitely many prime +components: their locally finite supports meet a compact inverse image. +Equality of coefficients in \eqref{repair:eq:detector-rationalization} is a +finite rational affine system in $(d_i,t,b_j)$. The klt condition is +open within this system, as seen on one log resolution; the pullbacks +of its adjoints vary linearly by the displayed identity. A nearby +rational solution therefore gives a rational effective klt boundary +$\Delta_q$ and $t_q\in\Q_{>0}$ with +\begin{equation}\label{repair:eq:detector-local-adjoint} + K_{T_U}+\Delta_q\sim_{\Q}t_qD_L. +\end{equation} +The individual local primes $D_i$ need not be $\Q$-Cartier: the identity +ensures that the total adjoint is $\Q$-Cartier. + +\smallskip\noindent +\emph{One global flip algebra.} +The adjoint in \eqref{repair:eq:detector-local-adjoint} is $f_U$-antiample. +Its ordinary flip and local finite generation follow from +\cite[Theorems~1.14 and~1.18]{Fujino2022}. Clearing the displayed +linear equivalence identifies a Veronese of its canonical algebra +with a Veronese of $\mathcal R:=\bigoplus_{m\geq0}f_*L^m$ over $U$. +Hence $\mathcal R$ is locally finitely generated by +\cite[Lemma~2.26]{Fujino2022}. The graded pieces are coherent, and +the section algebra over a connected open set is an integral domain, +as is seen using a meromorphic generator of $L$. +Compactness supplies one sufficiently divisible Veronese +$\mathcal R^{(r)}$ generated in degree one. Its relative Proj $T^+$ +restricts to the ordinary flip over every such $U$. It is therefore +normal and small over $Z$, and has the global relatively ample bundle +$\mathcal O_{T^+}(1)$. On the common big open this bundle is $L^r$. +Reflexivity gives +\[ + (L^+)^{[r]}\simeq\mathcal O_{T^+}(1). +\] +This proves that $L^+$ is a rational line bundle before any assertion +of factoriality. Relative positivity over the compact K\"ahler base +makes $T^+$ compact K\"ahler. + +For any global rank-one reflexive sheaf $\mathcal F^+$ on $T^+$, +take its coherent reflexive transform $\mathcal F$ on $T$ using a +common resolution. Some $M=\mathcal F^{[m]}$ is a line bundle. +Choose $c\in\Q$ so that $(M+cL)\cdot C=0$, and clear its denominator +to obtain an integral bundle $J=n(M+cL)$ numerically trivial over $f$. +The local rational klt pairs \eqref{repair:eq:detector-local-adjoint} satisfy +$J-(K_{T_U}+\Delta_q)$ relatively nef. Integral descent (Lemma~\ref{lem:descent}) yields +one global line bundle $J_Z$ with $J=f^*J_Z$. +On $T^+$, pull back $J_Z$, undo the rational twist $ncL^+$, and compare +on the common big open. After clearing the already established index +of $L^+$, reflexivity gives an invertible positive reflexive power of +$\mathcal F^+$. This proves global strong factoriality. + +\smallskip\noindent +\emph{The original generalized pair.} +The local log-Fano pairs above give $R^if_*\mathcal O_T=0$ for $i>0$ +by relative vanishing. They make $T$ locally klt, hence rational. +Leray for a projective resolution then shows that $Z$ is rational. +By \cite[Lemma~8.7]{DHP2024}, $f^*\BC(Z)=R^\perp$ and pullback is +injective. Thus $A=t c_1(L)+f^*\eta$ for a unique $\eta$. +Define $A^+=t c_1(L^+)+(f^+)^*\eta$; it is relatively K\"ahler. + +To construct its actual discrepancy divisor, let $\mathcal I$ be the +ideal defined by +\[ + \operatorname{im}(f^*f_*L^r\longrightarrow L^r) + =\mathcal I\otimes L^r. +\] +Principalize $\mathcal I$ on a common resolution $p:W\to T$, +$q:W\to T^+$ carrying $\mathbf M$. If +$\mathcal I\mathcal O_W=\mathcal O_W(-F_L)$, the tautological quotient +gives the actual bundle identity +\[ + q^*\mathcal O_{T^+}(1)=p^*L^r\otimes\mathcal O_W(-F_L). +\] +Hence $E_L=F_L/r$ is effective and exceptional over both sides, and +$[E_L]=p^*c_1(L)-q^*c_1(L^+)$. If $B_W$ is the original structure +boundary, put $B_W^+=B_W-tE_L$. Then +\[ + [K_W+B_W^+]+[\mathbf M_W]=q^*A^+. +\] +Its pushforward is $B^+$, and its discrepancies do not decrease. +The local ordinary comparison in \eqref{repair:eq:detector-local-adjoint} +has discrepancy divisor $t_qE_L$, so its strictness proves the stated +strictness for $tE_L$ as well. Thus the original pair remains gklt. + +Finally, write any $\theta\in\BC(T)$ uniquely as +$\theta=f^*\eta_\theta+s c_1(L)$ and set +$\theta^+=(f^+)^*\eta_\theta+s c_1(L^+)$. Its correction is the actual +divisor $sE_L$. For a global divisor class this is its strict transform: +the difference between the two candidate corrections is exceptional +and numerically trivial over $T^+$, hence zero by negativity. +\end{proof} + +\subsection{Ordinary real boundaries and forward transport}\label{repair:sec:real} + +Its rational-step input is the proof of Proposition~\ref{prop:ordinary-step}, +with its supporting contraction supplied by +Proposition~\ref{repair:prop:supporting-contraction} below and its projectivity +supplied by Lemma~\ref{repair:lem:polarization}. + +\begin{proposition}\label{repair:prop:real} +Let $T$ be normal compact K\"ahler and globally Weil $\Q$-factorial, +with canonical sheaf a rational line bundle. Let $B\geq0$ be a real +boundary with $(T,B)$ klt. Assume the rational ordinary-step result +of Proposition~\ref{prop:ordinary-step} for $T$ and its subsequent models. Then every +$(K_T+B)$-negative extremal analytic ray has an ordinary step with +projective contractions, compact K\"ahler models, and the expected +opposite relative ample signs. Global Weil factoriality is preserved; +global strong factoriality is preserved when imposed initially. +\end{proposition} +\begin{proof} +Put $D=K_T+B$ and fix a $D$-negative extremal ray $R$. On the finite +positive support of $B$, effectiveness, the klt condition and negativity +on $R$ persist under small coefficient changes. Klt openness is checked +on one log resolution of this support. Choose nearby effective rational +klt boundaries $B_0,\ldots,B_m$ and positive real numbers $u_j$ with +\[ + B=\sum_j u_jB_j,\qquad \sum_j u_j=1, + \qquad D_j\cdot R<0,\quad D_j=K_T+B_j. +\] +For $B=0$ take just $B_0=0$. Every $D_j$ is a global rational line +bundle. The rational-step theorem for $(T,B_0)$ provides a projective +contraction $f:T\to Z$, a compact K\"ahler base, and +\[ + f^*\BC(Z)=R^\perp,\qquad \rho(T/Z)=1, + \qquad -D_0\text{ relatively ample}. +\] +Let $C$ be a rational curve spanning $R$, and set +$a_j=(D_j\cdot C)/(D_0\cdot C)\in\Q_{>0}$. On every projective +fibre, $-D_j$ is numerically equivalent to the positive multiple +$-a_jD_0$. Numerical invariance of ampleness on that fibre, followed +by the relative-ampleness criterion, makes $-D_j$ relatively ample. +The positive combination $-D$ is relatively ample as a real line +bundle. This also handles a fibre-type contraction. + +Suppose henceforth that $f$ is birational. A Cartier multiple +$M_j=n_j(D_j-a_jD_0)$ is numerically trivial over $Z$ and +$M_j-D_0$ is relatively nef. Integral descent, Lemma~\ref{lem:descent}, +applied to the rational klt pair $(T,B_0)$ gives a rational line bundle +$A_j$ on $Z$ with the actual identity +\begin{equation}\label{repair:eq:descent} + D_j=a_jD_0+f^*A_j. +\end{equation} +Here and below an identity of rational line bundles means an isomorphism +after a common integral multiple. The descent lemma is used only for +birational $f$. + +For a small $f$, let $f^+:T^+\to Z$ be its rational $D_0$-flip. +The rational theorem supplies a global relatively ample adjoint +$D_0^+$ and preserves the stated factoriality and canonical-sheaf +conditions. The other transformed adjoints $D_j^+$ are therefore +rational line bundles. Transform \eqref{repair:eq:descent} on the common +big open and extend by reflexivity to obtain +\[ + D_j^+=a_jD_0^++(f^+)^*A_j. +\] +All $D_j^+$ are relatively ample, as is +$D^+=\sum_j u_jD_j^+$. Thus this same small map is the required +ordinary real-boundary flip. The real ordinary discrepancy comparison +proves that $(T^+,B^+)$ is klt and gives the strict increases at +exceptional centres. + +For a divisorial contraction, write +$D_0=f^*D_0'+e_0E$ with $e_0>0$. Transforming +\eqref{repair:eq:descent} on the target and summing yields +\[ + D-f^*D'=\left(\sum_j u_ja_j\right)e_0E. +\] +This coefficient is positive. The same discrepancy comparison proves +the required assertions. The ambient category was already preserved +by the rational step in both cases. +\end{proof} + +\subsubsection{Forward transport only} +For a birational step of Proposition~\ref{repair:prop:real}, write +$f':T'\to Z$ for the positive contraction, or the identity in the +divisorial case. Negative-side rank one gives, uniquely, +\[ + \theta=f^*\eta+s\,c_1(D),\qquad + \theta'=(f')^*\eta+s\,c_1(D'). +\] +On a common resolution $p:V\to T$, $q:V\to T'$, +\[ + p^*\theta-q^*\theta'=s[p^*D-q^*D']. +\] +The expression in brackets is the actual exceptional discrepancy +divisor. This proves the forward transport used in Lemma~\ref{lem:class-transport}. If $p^*H_T=p_0^*H+[J_T]$ is the fixed-nef-datum relation, +then +\[ + J_{T'}=J_T-s(p^*D-q^*D'),\qquad + q^*H_{T'}=p_0^*H+[J_{T'}]. +\] +No divisor is extracted, so $J_{T'}$ is $q$-exceptional. Its negative +is $q$-nef because $p_0^*H$ is nef; negativity gives $J_{T'}\geq0$. +There is no assertion of a surjection onto all of $\BC(T')$ or of +positive-side relative rank one. + +\subsection{Ingredients for the contraction theorem} +\label{repair:subsec:bounded-bpf-induction} + +We isolate the part of the transcendental base-point-free argument that +is needed here. The induction below uses ordinary rational termination +only in dimensions at most three. In particular, it does not use a +finiteness theorem for generalized minimal models. + +For an integer $d\geq0$, consider the following statements, each in +dimensions at most $d$. +\begin{description} +\item[$\mathsf B_d$.] +If $(X,B+\mathbf M)$ is a compact K\"ahler gklt pair, +$B+\mathbf M_X$ is modified big, and +$\alpha=[K_X+B+\mathbf M_X]$ is nef, then there is a Moishezon +contraction $h:X\to Y$ onto a compact K\"ahler space and a K\"ahler +class $\omega_Y$ such that $\alpha=h^*\omega_Y$. +\item[$\mathsf C_d$.] +Let $(X,B+\mathbf M)$ be a compact K\"ahler generalized pair, with +$B+\mathbf M_X$ modified big and +$\alpha=[K_X+B+\mathbf M_X]$ nef and NQC. If the restriction of +$\alpha$ to the closed subspace defined by +$\mathcal J(X,B+\mathbf M)$ has a Moishezon contraction, then +$\alpha$ has a Moishezon contraction. +Write $\mathsf C_{d,\mathrm{big}}$ for this assertion with the +additional assumption that $\alpha$ is big. +\item[$\mathsf G_d$.] +If $(X,B+\mathbf M)$ is a globally strongly $\Q$-factorial compact +K\"ahler gklt pair, $B+\mathbf M_X$ is modified big, and its adjoint +class $A$ is pseudo-effective, then it has a good minimal model. +One may obtain this model from a smooth modification by finitely many +ordinary rational klt steps. The induced map from $X$ extracts no +divisor and is $A$-nonpositive. +\end{description} +Here ``NQC'' has the cohomological meaning of +\cite[Definition~2.43]{HX2026}: the class is a positive real +combination of rational classes in $H^2$ that are nonnegative on +curves. All uses below require only this weak version. A Moishezon +contraction has the meaning of \cite[Definition~2.32]{HX2026}; in +particular its fibres are connected by chains of compact curves. + +We first record a polarization fact for actual line bundles. It is +the only promotion from a Moishezon map to a projective map used in +the non-klt gluing construction. + +\begin{lemma}[Polarization by an actual real line bundle] +\label{repair:lem:actual-line-polarization} +Let $f:T\to Z$ be a proper Moishezon map, where $T$ is a compact +K\"ahler space. Suppose that $L\in\operatorname{Pic}(T)\otimes\R$ +and a K\"ahler class $\omega$ satisfy +\[ + L\cdot C=\omega\cdot C + \quad\text{for every compact curve $C$ contracted by $f$.} +\] +Then $L$ is relatively ample and $f$ is projective. +\end{lemma} + +\begin{proof} +Let $V$ be an irreducible positive-dimensional subspace of a reduced +fibre. It is Moishezon. Normalize $V$ and take a smooth projective +modification $\pi:\widetilde V\to V^{\mathrm n}$, chosen so that +an effective exceptional divisor $E$ has $-E$ relatively ample. +The pullback of the K\"ahler class from $V$ to its normalization is +K\"ahler. Consequently +$\pi^*\omega-\delta[E]$ is K\"ahler for sufficiently small +$\delta>0$. On the projective manifold $\widetilde V$ the actual +real line bundle $\pi^*L-\delta E$ has the same curve degrees as +that K\"ahler class, and is therefore ample. For example, subtract +a sufficiently small positive multiple of a fixed ample class from +the K\"ahler class; the corresponding real line bundle is nef by +the projective numerical criterion. Also $\pi^*L$ is nef, and the +decomposition +\[ + \pi^*L=(\pi^*L-\delta E)+\delta E +\] +shows that it is big. Thus +\[ + L^{\dim V}\cdot V=(\pi^*L)^{\dim V}>0. +\] +The real Nakai--Moishezon criterion for proper algebraic spaces +\cite[Theorem~1.6]{FujinoMiyamoto2020}, applied to the algebraizations +of the Moishezon fibres, proves that $L$ is ample on every reduced +fibre. The criterion is insensitive to nilpotents and reducible +components. Fibrewise ampleness is open for a proper analytic map; +in the finite-dimensional span of the finitely many line bundles +occurring in $L$, compactness therefore gives a neighbourhood of +$L$ whose rational points are relatively ample. This proves relative +ampleness of $L$ and supplies a global relatively ample rational +line bundle. Clearing its denominator proves projectivity. +\end{proof} + +\begin{remark} +The proof uses only positivity of the top self-intersections of +$L$. Equality of curve degrees with $\omega$ does not assert +equality of their higher intersection numbers or of their +Bott--Chern classes. +\end{remark} + + + +\subsubsection{Relative algebraicity over the fixed smooth base} +\label{repair:sec:fixed-smooth-base-algebraicity} + +\begin{lemma}[A rational Hodge correction over a smooth base] +\label{repair:lem:fixed-smooth-base-algebraicity} +Let $f:T\to S$ be an already projective surjective morphism of normal +compact K\"ahler spaces. Assume that $S$ is smooth, $T$ has strongly +$\mathbb{Q}$-factorial klt singularities, and, for a projective resolution +$r:W\to T$, the morphism $g=f\circ r$ satisfies +\[ + g^*:H^0(S,\Omega_S^2)\xrightarrow{\ \simeq\ } + H^0(W,\Omega_W^2). +\] +Then every $\alpha\in H^{1,1}_{\mathrm{BC}}(T)$ can be written +\[ + \alpha=c_1(L)+f^*\gamma, +\] +where $L\in\operatorname{Pic}(T)\otimes_{\mathbb Z}\mathbb R$ is a +finite real combination of global line bundles and +$\gamma\in H^{1,1}(S,\mathbb R)$. +\end{lemma} + +\begin{proof} +The composition $g$ is projective, since all the spaces are compact. +Choose a $g$-ample line bundle on $W$, with integral Chern class $H$. +Set $d=\dim W-\dim S$ and +\[ + c=g_*(H^d)>0. +\] +Thus $c$ is the positive degree of $H^d$ on a general fibre. The +cohomological pushforward here is the usual pushforward between the +smooth compact manifolds $W$ and $S$, defined over $\mathbb Q$ and of +Hodge bidegree $(-d,-d)$. + +Define a rational linear operator on degree-two cohomology by +\[ + \Pi(\eta)=\eta-g^*\!\left(\frac{g_*(\eta\smile H^d)}{c}\right). +\] +Every class of type $(2,0)$ on $W$ is pulled back from $S$, and the +same holds for type $(0,2)$. The projection formula therefore shows +that $\Pi$ kills both types. It preserves type $(1,1)$. Consequently +\[ + \Pi(H^2(W,\mathbb Q))\subset + H^2(W,\mathbb Q)\cap H^{1,1}(W). +\] +By the Lefschetz $(1,1)$ theorem the image consists of rational Chern +classes of global line bundles. Applying $\Pi$ to $r^*\alpha$ gives +\[ + r^*\alpha=c_1(L_W)+g^*\gamma, + \qquad L_W\in\operatorname{Pic}(W)\otimes\mathbb R, + \qquad + \gamma=\frac{g_*(r^*\alpha\smile H^d)}{c}\in H^{1,1}(S,\mathbb R). +\] +For example, express $r^*\alpha$ in a rational basis of $H^2(W,\mathbb Q)$ +and apply $\Pi$ to each basis vector. This gives the required finite +real combination $L_W$. + +Write $L_W=\sum_j a_jL_j$ with actual line bundles $L_j$ on $W$. +For each $j$, let +\[ + \mathcal F_j=(r_*L_j)^{**}. +\] +It is a rank-one reflexive coherent sheaf. Strong +$\mathbb Q$-factoriality gives an integer $m_j>0$ for which +$M_j=\mathcal F_j^{[m_j]}$ is a line bundle on $T$. +The canonical identification over the isomorphism locus of $r$ gives +\[ + L_j^{\otimes m_j}\simeq r^*M_j\otimes\mathcal O_W(E_j) +\] +for an integral $r$-exceptional divisor $E_j$. +One may obtain this comparison directly from the evaluation map for +$r_*L_j$: the two coherent rank-one sheaves agree away from the +exceptional locus, so their invertible transforms differ by an +exceptional divisor. No global meromorphic frame of $L_j$ or of the +canonical sheaf is required. + +Set $L=\sum_j(a_j/m_j)M_j$ and +$E=\sum_j(a_j/m_j)E_j$. The preceding identities yield +\[ + r^*(\alpha-c_1(L)-f^*\gamma)=[E]. +\] +The divisor $E$ is $r$-exceptional and is numerically trivial on every +$r$-contracted curve. The exceptional negativity lemma applied in both +signs gives $E=0$. Injectivity of pullback by a resolution, or pushforward +of the equality of currents, now gives +$\alpha=c_1(L)+f^*\gamma$. +\end{proof} + +\paragraph{What this proves about the relative curve spaces.} +On real combinations of curves contracted by $f$, numerical equivalence +tested by global line bundles is exactly numerical equivalence tested +by all Bott--Chern classes. Indeed, the displayed decomposition makes +every Bott--Chern pairing on such curves a pairing with $c_1(L)$, while +the pullback term pairs to zero. The converse implication is immediate. +The resulting finite-dimensional isomorphism identifies the closures +of the cones generated by the contracted curves, and therefore their +extremal rays. This statement does not assert that every class on an +arbitrary birational model transfers backwards, or that every +numerically trivial class descends under an arbitrary morphism. + +\paragraph{Persistence during the initial relative program.} +Suppose a finite prefix of a projective relative MMP over this fixed +smooth $S$ has produced $T_i\to S$. Its morphism to $S$ is projective by +the projective relative MMP construction, and its strong +$\mathbb Q$-factorial klt property is preserved. Take a common +resolution of $T_i$ and the initial $T$ over $S$. Holomorphic two-forms +on smooth compact K\"ahler manifolds are invariant under modifications. +The isomorphism of holomorphic two-forms in the lemma therefore holds +for every projective resolution of $T_i$. The lemma applies anew on +each $T_i$; no projectivity-descent theorem is being used to establish +this persistence. + +\paragraph{Application to the smooth MRC base.} +For a smooth holomorphic model $W\to S$ of the MRC fibration, the +pullback of holomorphic two-forms is an isomorphism, since the general +fibres are rationally connected. Projectivity of this smooth model is +the smooth-base, holomorphic-two-form part of the projectivity +criterion. Its rational Hodge correction proof is independent of the +singular projectivity-descent assertion. Once that projective model +has been chosen, the lemma above gives the relative real line bundles +needed for the initial MMP over $S$. + +\paragraph{Local divisor representatives.} +The global objects furnished by the lemma are real combinations of +line bundles. Over each sufficiently small Stein open subset of $S$ +they have actual meromorphic divisor representatives: after twisting a +line bundle by a sufficiently high power of a relatively ample line +bundle, relative generation and Cartan's theorem~A provide nonzero +sections; taking the quotient of two such sections gives a meromorphic +section of the original line bundle. Hence the ordinary projective +theorems can be used on the finite Stein cover with the intrinsic +global line bundles and their section algebras. A global effective +divisor representative is not an additional hypothesis. + +\paragraph{NQC transport is a separate one-way assertion.} +\label{repair:par:one-way-nqc} +The rational Hodge correction above is not a substitute for descent +along a contracted ray. For a nef class $\alpha$ whose contraction is +$\alpha$-trivial, use its already established Bott--Chern descent +$\alpha=\pi^*\alpha_Z$. If $V_{\mathbb Q}\subset H^2(T,\mathbb Q)$ is +the minimal rational subspace containing $\alpha$, then +\[ + V_{\mathbb Q}\subset\pi^*H^2(Z,\mathbb Q), +\] +because the right-hand side is a rational subspace containing +$\alpha$. Choose the NQC summands in $V_{\mathbb Q}$: intersect the +rational polyhedral cone generated by any initial NQC summands with +$V_{\mathbb Q}\otimes\mathbb R$, and express $\alpha$ using rational +generators of this intersection. Those generators remain nonnegative +on curves. These rational NQC summands therefore descend and can be +pulled forward to the flipped model. For nonnegativity, lift a curve +on the new model to a curve on a common projective resolution that +maps onto it with some positive degree. Equality of the pulled-back +classes shows that its pairing is nonnegative; dividing by this +positive degree preserves the sign. This proves weak NQC on the new +model. It does not preserve a specified denominator, and no +degree-one lift is asserted. Below, the initial relative program +preserves its denominators by integral line-bundle descent, whereas +the lower-dimensional absolute program chooses a new bound on each +model. Neither argument requires surjectivity of the forward +Bott--Chern map or equality of the two models' Bott--Chern dimensions. + +\subsubsection{Fixed relative degree denominators by integral descent} +\label{repair:subsec:relative-nqc-integral} + +The initial program over the fixed smooth MRC base has a stronger +property than is needed for arbitrary birational maps: its rational +cohomology classes can be represented by rational line bundles modulo +that base. Integral descent of those line bundles preserves their +degree denominators. This avoids any assertion that a curve has a +degree-one lift through a resolution. + +\begin{lemma}[Integral descent at a projective log-Fano contraction] +\label{repair:lem:relative-nqc-integral-descent} +Let $h:T\to Y$ be a projective bimeromorphic contraction of normal +complex spaces. Suppose that each point of $Y$ has a neighbourhood +$U$ on which an effective real boundary $\Theta_U$ gives an ordinary +klt pair $(h^{-1}U,\Theta_U)$ and +$-(K_{h^{-1}U}+\Theta_U)$ is $h$-ample. If $L$ is an actual line +bundle with $L\cdot C=0$ for every $h$-contracted curve, then +$h_*L$ is a line bundle and the natural evaluation map is an +isomorphism +\[ + h^*h_*L\simeq L. +\] +In particular no additional tensor power is needed. +\end{lemma} + +\begin{proof} +Fix $y\in Y$ and shrink to a Stein neighbourhood on which the boundary +is defined. A Cartier-divisor representative of $L$ exists there: +$h_*L$ is coherent and has rank one on the bimeromorphic isomorphism +locus, so Cartan's theorem~A supplies a section nonzero on that locus. +Its pullback is a nonzero meromorphic frame of $L$ and gives the +required Cartier divisor. + +The line bundle $L$ is $h$-nef. Numerical invariance of ampleness on +the projective fibres gives +\[ + L-(K_T+\Theta_U)\quad\text{$h$-ample}. +\] +The analytic base-point-free theorem +\cite[Theorem~6.2]{Fujino2022} applies to this Cartier divisor and the +real klt boundary. It states that $L^m$ is relatively generated for +\emph{every} sufficiently large integer $m$ near the compact fibre +$h^{-1}(y)$, rather than only for divisible $m$. + +Choose finitely many generating sections. The resulting map from +the reduced projective fibre to projective space is constant on each +irreducible component, since a positive-dimensional image would give +a curve of positive $L^m$-degree. The fibre is connected, so these +constant values agree. A suitable linear combination of the sections +therefore has no zero on the reduced fibre. In the local ring at a +point of the possibly nonreduced fibre it is a unit, so it is a +generator there as well. Properness allows the base neighbourhood to +be shrunk so that this section trivializes $L^m$ throughout its +inverse image. + +Apply this to two consecutive sufficiently large integers $m,m+1$. +Taking the quotient of the two trivializations trivializes $L$. +Since $h_*\mathcal O_T=\mathcal O_Y$, it follows locally that +$h_*L\simeq\mathcal O_Y$ and evaluation is an isomorphism. These are +intrinsic assertions and hence glue over $Y$. This also explains why +possible torsion in a fibre Picard group introduces no new index. +The conclusion is recorded directly for extremal contractions in +\cite[Theorem~7.2(2)(iii)]{Fujino2022}; its proof allows real +boundaries. The argument above gives the intrinsic global form needed +here and does not require the contraction to have relative Picard +rank one in every local analytic neighbourhood. +\end{proof} + +\begin{proposition}[A uniform relative NQC bound] +\label{repair:prop:relative-nqc-uniform} +Let $f_0:U\to Z$ be an already projective surjective morphism with +connected fibres between smooth compact +K\"ahler manifolds, and suppose that +\[ + f_0^*:H^0(Z,\Omega_Z^2)\longrightarrow H^0(U,\Omega_U^2) +\] +is an isomorphism. Let $\alpha_0$ be a nef class with an expression +\[ + \alpha_0=\sum_{j=1}^k r_j\eta_{j,0},\qquad + r_j>0,\quad \eta_{j,0}\in H^2(U,\mathbb Q), +\] +where $\eta_{j,0}$ has nonnegative degree on every curve vertical +over $Z$. Let $D_0=K_U+\Delta_U+\mathbf M_U$ be a generalized klt +adjoint. Consider its projective relative program for +$D_0+a\alpha_0$, under the projective local ordinary reduction described in the +proof of Proposition~\ref{repair:prop:restricted-bpf-induction}. + +If $\alpha_0=0$, triviality is immediate. Otherwise there are +positive integers $m_j$, chosen once on $U$, and a number +\[ + \delta=\min_j\frac{r_j}{m_j}>0 +\] +such that, for $a\delta>2\dim U$, the entire relative program is +$\alpha_0$-trivial. The same number $a$ works at every step. +\end{proposition} + +\begin{proof} +\emph{Rational classes modulo the fixed base.} +Choose an $f_0$-ample line bundle with integral Chern class $H$, and +put $e=\dim U-\dim Z$ and $c=f_{0*}(H^e)>0$. The rational operator +\[ + \Pi(\eta)=\eta- + f_0^*\!\left(\frac{f_{0*}(\eta\smile H^e)}{c}\right) +\] +preserves type $(1,1)$ and kills types $(2,0)$ and $(0,2)$. +Indeed these latter classes are pulled back from $Z$, and the +projection formula applies. Thus +$\Pi(H^2(U,\mathbb Q))\subset H^{1,1}(U)\cap H^2(U,\mathbb Q)$. +By the Lefschetz $(1,1)$ theorem, choose an actual line bundle +$L_{j,0}$ and an integer $m_j>0$ with +\[ + \eta_{j,0}=\frac1{m_j}c_1(L_{j,0})+f_0^*\gamma_j, + \qquad \gamma_j\in H^2(Z,\mathbb Q). +\] +The original summands $\eta_{j,0}$ need not have type $(1,1)$. +Their base components account for this. Their weighted sum gives +\begin{equation}\label{repair:eq:relative-nqc-line-expression} + \alpha_0=\sum_j\frac{r_j}{m_j}c_1(L_{j,0})+f_0^*\Gamma, + \qquad \Gamma=\sum_jr_j\gamma_j\in H^{1,1}(Z,\mathbb R). +\end{equation} +The final assertion follows because $f_0^*$ is an injective Hodge +map and the other terms have type $(1,1)$. The identity is therefore +also one of Bott--Chern classes. +Each $L_{j,0}$ has nonnegative integral degree on every +$Z$-vertical curve. + +\smallskip\noindent +\emph{Induction across an actual contraction.} +Suppose at a finite stage $f_i:U_i\to Z$ we have actual line bundles +$L_{j,i}$, nef over $Z$, and +\[ + \alpha_i=\sum_j\frac{r_j}{m_j}c_1(L_{j,i})+f_i^*\Gamma. +\] +Assume also that $\alpha_i$ is nef and that the transformed +$D_i$ is generalized klt. These assertions hold initially. +Let $R$ be a $(D_i+a\alpha_i)$-negative extremal ray over $Z$. +It is $D_i$-negative because $\alpha_i$ is nef. The projective +relative cone theorem supplies a rational generator $C$ with +\[ + 0<-D_i\cdot C\leq2\dim U. +\] +All $L_{j,i}\cdot C$ are nonnegative integers. If +$\alpha_i\cdot C>0$, one of them is at least one, and hence +$\alpha_i\cdot C\geq\delta$. Therefore +\[ + (D_i+a\alpha_i)\cdot C + \geq-2\dim U+a\delta>0, +\] +a contradiction. We have $\alpha_i\cdot C=0$ and +$L_{j,i}\cdot C=0$ for every $j$. Every curve contracted by the +projective extremal contraction $h_i:U_i\to Y_i$ has class on +$R$ when tested by global line bundles, so the same vanishing +holds for all of them. + +On each fixed Stein chart of $Z$, choose the effective real +ordinary representative of the initial relatively ample nef +datum once, before running the program. Its actual real linear +equivalence to the fixed real line-bundle representative persists +under pushforward. The Bott--Chern comparison with the generalized +adjoint modulo the fixed base class persists separately by +exceptional negativity, as detailed below. +Thus every $h_i$ is, locally on $Y_i$, a contraction with an +ordinary real klt log-Fano boundary. This verifies exactly the +hypothesis of Lemma~\ref{repair:lem:relative-nqc-integral-descent}. +Consequently +\[ + M_{j,i}:=(h_i)_*L_{j,i}\ \text{is a line bundle},\qquad + h_i^*M_{j,i}=L_{j,i}. +\] +For a divisorial contraction set $L_{j,i+1}=M_{j,i}$. +For a flip $h_i^+:U_{i+1}\to Y_i$, set +$L_{j,i+1}=(h_i^+)^*M_{j,i}$. +These are actual line bundles with the \emph{same} integers $m_j$. +The descended Bott--Chern class +\[ + \alpha_{Y_i} + =\sum_j\frac{r_j}{m_j}c_1(M_{j,i})+f_{Y_i}^*\Gamma +\] +satisfies $h_i^*\alpha_{Y_i}=\alpha_i$. +It is nef by descent of nefness through the projective surjection +$h_i$; its pullback to the next model is $\alpha_{i+1}$. +This proves that the step is crepant for $\alpha_i$. Hence it is +also a $D_i$-negative step, and the original generalized pair +remains gklt. + +Finally each $M_{j,i}$ is nef over $Z$. For a $Z$-vertical curve +$B\subset Y_i$, projectivity supplies a curve $B'\subset U_i$ +mapping onto it with some positive degree $d_B$. Then +\[ + d_B(M_{j,i}\cdot B)=L_{j,i}\cdot B'\geq0. +\] +No assertion $d_B=1$ is required. Pullback preserves this relative +nefness, so the induction applies on $U_{i+1}$. Its curve degrees +are again integers because the transported objects are line +bundles, not because any curves were lifted with degree one. +This proves the fixed bound through the whole program. +\end{proof} + +\begin{remark}[Scope of the degree grid] +The transported rational classes +\[ + \eta_{j,i}=\frac1{m_j}c_1(L_{j,i})+f_i^*\gamma_j +\] +have degrees in $m_j^{-1}\mathbb Z_{\geq0}$ on curves vertical over +the fixed smooth base $Z$. This relative assertion is exactly what +the initial projective program requires. It does not assert +nonnegativity of these individual classes on all curves of every +birational model, and uses neither rational connectedness of +resolution fibres nor Graber--Harris--Starr. +\end{remark} + + +\subsubsection{Adaptive bounds for the lower-dimensional program} + +\begin{lemma}[Adaptive NQC bounds] +\label{repair:lem:adaptive-nqc-program} +Let $1\leq d\leq3$, and assume $\mathsf B_d$ and ordinary rational +klt termination in dimension at most $d$. Let $X_0$ be a globally +strongly $\mathbb Q$-factorial compact K\"ahler klt space of dimension +$d$, and let $\alpha_0$ be a nef, weakly NQC Bott--Chern class which +is not big. Assume that +\[ + Q_0:=\alpha_0-c_1(K_{X_0}) +\] +is big. Then there is a finite sequence of ordinary $K$-negative +divisorial contractions and flips, all $\alpha_0$-trivial, ending in +an ordinary Mori fibre space $f:X_m\to Z$. The class $\alpha_m$ +descends to a nef weakly NQC class on $Z$. +\end{lemma} + +\begin{proof} +We first explain the one-way NQC transport that will be used. Let +$f_i:X_i\to Z_i$ be a projective ordinary $K_{X_i}$-negative ray +contraction, and suppose that $\alpha_i$ vanishes on its ray. The +ordinary contraction theorem gives +\[ + \alpha_i=f_i^*\beta_i. +\] +This is Bott--Chern descent on the already projective log Fano +contraction, by Lemma~\ref{lem:pullback-image}; the target has rational +singularities and the required higher direct images vanish. We will also use +injectivity of +$f_i^*:H^2(Z_i,\mathbb Q)\to H^2(X_i,\mathbb Q)$. +For clarity, it follows from relative vanishing and the usual +pluriharmonic-function sequence. Indeed, +$(f_i)_*\mathcal O_{X_i}=\mathcal O_{Z_i}$, +$R^1(f_i)_*\mathcal O_{X_i}=0$, and +$(f_i)_*\mathcal H_{X_i}=\mathcal H_{Z_i}$ imply +$R^1(f_i)_*\mathbb R=0$; the Leray sequence gives injectivity on +$H^2(-,\mathbb R)$, and hence on rational cohomology. + +Choose a weak NQC expression +\[ + \alpha_i=\sum_{j=1}^{r_i}a_{ij}\xi_{ij}, + \qquad a_{ij}>0,\qquad + \xi_{ij}\in H^2(X_i,\mathbb Q),\qquad + \xi_{ij}\cdot C\geq0 +\] +for every compact curve $C\subset X_i$, with the $\xi_{ij}$ in +the minimal rational subspace containing $\alpha_i$. +Since the image of $f_i^*$ on rational cohomology is a rational +subspace and its realification contains $\alpha_i$, that minimal +subspace lies in the image. Thus +\[ + \xi_{ij}=f_i^*\eta_{ij},\qquad + \eta_{ij}\in H^2(Z_i,\mathbb Q),\qquad + \beta_i=\sum_j a_{ij}\eta_{ij}. +\] +The last equality follows from injectivity. In the birational case, +write $g_i:X_{i+1}\to Z_i$ for the positive-side map, using the +identity map for a divisorial contraction, and set +\[ + \alpha_{i+1}=g_i^*\beta_i,\qquad + \xi_{ij}^+=g_i^*\eta_{ij}. +\] +On a common projective resolution $p:W\to X_i$, $q:W\to X_{i+1}$, +we have $p^*\xi_{ij}=q^*\xi_{ij}^+$. For a curve +$C^+\subset X_{i+1}$, projectivity of $q$ supplies a curve +$\widetilde C\subset W$ mapping onto it with some degree $e>0$. +Consequently +\[ + e\,\xi_{ij}^+\cdot C^+ + =\xi_{ij}\cdot p_*\widetilde C\geq0. +\] +Thus $\alpha_{i+1}$ is weakly NQC. This uses a positive-degree +multisection, not a degree-one lift. Its rational components may +acquire different integral denominators on $X_{i+1}$. +Nefness follows from equality of the pullbacks and descent of nef +Bott--Chern classes under a proper surjective morphism. In the +fibre-type case, lifting curves from $Z_i$ through the projective +morphism $f_i$ proves weak NQC for $\beta_i$; its nefness again +follows by descent from $f_i^*\beta_i=\alpha_i$. + +We now choose each step separately. At a current model $X_i$, take +any weak NQC expression as above, and choose integers $l_{ij}>0$ +such that $l_{ij}\xi_{ij}$ is integral. Choose +\begin{equation}\label{repair:eq:adaptive-nqc-bound} + t_i>2d\max_j\frac{l_{ij}}{a_{ij}}. +\end{equation} +If $\alpha_i=0$, take any $t_i>0$ and omit the bound. +As long as $Q_i:=\alpha_i-c_1(K_{X_i})$ is big and $\alpha_i$ +is not big, the class $c_1(K_{X_i})+t_i\alpha_i$ cannot be +pseudoeffective. Otherwise +\[ + (t_i+1)\alpha_i + =(c_1(K_{X_i})+t_i\alpha_i)+Q_i +\] +would be big. The nef datum $t_i\alpha_i$ descends to $X_i$, so +adding it to the ordinary klt pair $(X_i,0)$ changes no discrepancy. +In particular this generalized klt adjoint is not nef, so the +analytic cone theorem provides a negative analytic +extremal ray $R_i$. Nefness of $\alpha_i$ makes $R_i$ an ordinary +$K_{X_i}$-negative ray. Choose its ordinary length-bounded rational +curve $C_i$, so that +\[ + 0<-K_{X_i}\cdot C_i\leq2d. +\] +If $\alpha_i\cdot C_i>0$, some $\xi_{ij}\cdot C_i$ is positive +and hence is at least $1/l_{ij}$. Then +\[ + (K_{X_i}+t_i\alpha_i)\cdot C_i + \geq-2d+t_i a_{ij}/l_{ij}>0, +\] +a contradiction. Therefore $\alpha_i\cdot R_i=0$. + +Apply the ordinary rational step theorem to $(X_i,0)$ and $R_i$. +Its supporting nef class has the form $c_1(K_{X_i})+\kappa_i$ +with $\kappa_i$ K\"ahler. Hence $\mathsf B_d$ supplies its +contraction, and the ordinary relative-positivity and flip arguments +give the projective contraction and its ordinary flip when needed. +All spaces remain compact K\"ahler, globally strongly +$\mathbb Q$-factorial, and klt. The preceding NQC transport applies. + +It remains to check the positivity hypotheses at the next stage. +For a birational step, on a common resolution write +\[ + p^*K_{X_i}=q^*K_{X_{i+1}}+F_i, + \qquad F_i\geq0, + \qquad p^*\alpha_i=q^*\alpha_{i+1}. +\] +Here $F_i$ is the actual ordinary discrepancy divisor. Thus +\[ + q^*Q_{i+1}=p^*Q_i+[F_i] +\] +is big, so $Q_{i+1}$ is big. Equality of the $\alpha$-pullbacks +also preserves non-bigness. We can therefore recompute the NQC +denominators and choose a fresh $t_{i+1}$ by +\eqref{repair:eq:adaptive-nqc-bound}. In the non-klt application, +$Q_i=B_i+\mathbf M_{X_i}$; the equality of the $\alpha$-pullbacks +preserves the original generalized adjoint and its b-datum. + +If this procedure never reached a fibre-type contraction, it would +give an infinite sequence of ordinary rational klt $K$-negative +birational steps. Divisorial steps are finite by the strict decrease +of the span of analytic divisor classes, while small steps preserve +that span, as in the cycle-rank argument of Lemma~\ref{lem:cycle-loss}. +The remaining infinite flip tail would contradict ordinary rational +termination (Theorem~\ref{thm:gklt-three}). Hence it reaches an +ordinary Mori fibre space after finitely many steps. The final +$\alpha$-class descends to a nef weakly NQC class on its base by +the fibre-type argument above. No uniform bound for the $l_{ij}$, +and no application of a section theorem for rationally connected +fibres, is required. +\end{proof} + + +\subsubsection{Selected lower-dimensional good models} + +\begin{lemma}[A selected good model in dimension at most three] +\label{repair:lem:lower-dimensional-good-model} +Fix $1\leq d\leq3$. Assume the generalized analytic cone theorem in +dimension $d$, the semiampleness assertion $B_d$, and termination of +ordinary rational klt programs of dimension at most three. Here $B_d$ +means that a nef generalized klt adjoint with modified-big +boundary-plus-nef part is the pullback of a K\"ahler class under a +Moishezon contraction to a normal compact K\"ahler space. Its conclusion does not +include projectivity of that contraction. For ordinary rational +termination one may use Theorem~\ref{thm:gklt-three}, with zero nef +b-divisor. + +Let $(X,B+\mathbf M)$ be a generalized klt pair on a normal compact +K\"ahler space of dimension $d$. Suppose that +\[ + A=K_X+B+\mathbf M_X +\] +is pseudoeffective and that $B+\mathbf M_X$ is modified big. +Then it has a good minimal model +$\phi:X\dashrightarrow X^{\rm m}$, where $X^{\rm m}$ is compact +K\"ahler and globally strongly $\mathbb Q$-factorial. The map extracts +no divisor. It can be selected so that every class in +$H^{1,1}_{\rm BC}(X)$ has a forward trace on $X^{\rm m}$. +No finiteness theorem for nearby generalized pairs is needed. +\end{lemma} + +\begin{proof} +We first record precisely the elementary positivity input used in +passing to a smooth model. The modified-bigness resolution lemma +\cite[Lemma~2.5]{HLX2026} gives a projective smooth carrier +$\pi:Y\to X$ and an effective $\pi$-exceptional divisor $P$ such that, +on writing +\[ + K_Y+B_Y+M_Y=\pi^*A, +\] +the class $B_Y^++M_Y+\varepsilon P$ is big for every +$\varepsilon>0$. Here $M_Y$ is nef and $B_Y=B_Y^+-B_Y^-$, with +disjoint effective positive and negative parts. We can replace $P$ by +an effective divisor whose support contains every $\pi$-exceptional +prime. This positivity lemma follows directly from the definition of +modified bigness, the support theorem for a modification, and the +convexity of the big cone; it uses no contraction or termination theorem. +All the modifications here can be chosen projective. + +For clarity, if $X$ is globally strongly $\mathbb Q$-factorial, that +input also has the following direct verification. The class +$C=B+\mathbf M_X=A-K_X$ is a big Bott--Chern class. Put +$Q=B_Y^++M_Y$, which is pseudoeffective. The difference +\[ + J=\pi^*C-Q=(K_Y-\pi^*K_X)-B_Y^- +\] +is an actual $\pi$-exceptional real divisor class. Given a positive +divisor $P$ supported on all exceptional primes, choose $s>0$ small +enough that $\varepsilon P-sJ\geq0$. Then +\[ + Q+\varepsilon P + =(1-s)Q+s\pi^*C+(\varepsilon P-sJ) +\] +is big. This uses only that pullback preserves bigness and that adding +a pseudoeffective class to a big class preserves bigness. + +We choose $\pi$ to resolve the supports just used. Choose +$\varepsilon>0$ small enough that +$\Delta=B_Y^++\varepsilon P$ has all coefficients below one. +Its support is simple normal crossing, so $(Y,\Delta)$ is klt and +\begin{equation}\label{repair:eq:good-model-first-error} + K_Y+\Delta+M_Y=\pi^*A+F_Y, + \qquad F_Y=B_Y^-+\varepsilon P\geq0. +\end{equation} +The support of $F_Y$ contains every $\pi$-exceptional prime, and +$\Delta+M_Y$ is big. + +\smallskip\noindent +\emph{Smooth reduction with a K\"ahler nef part.} +Regularize a K\"ahler current in $\Delta+M_Y$ and resolve its analytic +singularities. This gives a projective modification $q:U\to Y$, +with $U$ smooth and compact K\"ahler, and +\[ + q^*(\Delta+M_Y)=\omega+[G],\qquad G\geq0, +\] +where $\omega$ is a K\"ahler class. To obtain a K\"ahler class rather +than a semipositive pullback, subtract a sufficiently small effective +exceptional class from the smooth part and add it to $G$. This is the +usual K\"ahler-current proof of the analytic Kodaira decomposition. +We resolve the supports involved at the same time. Write +$K_U=q^*K_Y+K_{U/Y}$; the divisor $K_{U/Y}$ is effective and +$q$-exceptional. For sufficiently small $\delta>0$, set +\[ + \beta=(1-\delta)q^*M_Y+\delta\omega, + \qquad + \Gamma_\delta=(1-\delta)q^*\Delta+\delta G-K_{U/Y}. +\] +The class $\beta$ is K\"ahler. At $\delta=0$ the second expression +is the crepant boundary of the klt pair $(Y,\Delta)$. Since its +support is fixed and finite, for small $\delta$ all coefficients of +$\Gamma_\delta$ remain below one. Its negative components are +$q$-exceptional. If $P_q$ is supported positively on every +$q$-exceptional prime, choose $\eta>0$ small enough that +\[ + \Gamma=\Gamma_\delta^++\eta P_q +\] +still has all coefficients below one. Its support is simple normal +crossing, so $(U,\Gamma)$ is klt. Put $\mu=\pi q$. We obtain +\begin{equation}\label{repair:eq:good-model-smooth-error} + \widetilde A:=K_U+\Gamma+\beta + =\mu^*A+E_\mu, + \qquad + E_\mu=q^*F_Y+\Gamma_\delta^-+\eta P_q\geq0. +\end{equation} +The support of $E_\mu$ contains every $\mu$-exceptional prime. +In particular $\widetilde A$ is pseudoeffective. + +Choose a rational effective boundary $B_0$ sufficiently close to +$\Gamma$, on the same positive support, and put +\[ + H=\beta+[\Gamma-B_0],\qquad D=K_U+B_0. +\] +Openness of the K\"ahler cone makes $H$ K\"ahler, and $(U,B_0)$ +remains klt. Fix a K\"ahler form representing $H$ and use its +pullbacks as one fixed nef b-datum. Thus +\begin{equation}\label{repair:eq:good-model-rationalization} + \widetilde A=D+H, +\end{equation} +where $D$ is an ordinary rational klt adjoint. This auxiliary nef +b-datum need not equal the original $\mathbf M$. + +\smallskip\noindent +\emph{Scaling only above one.} +Choose $T>1$ such that $D+TH$ is nef. Run the ordinary $D$-program +with scaling of this fixed $H$, stopping as soon as the forward trace +of $D+H$ is nef. Write its traces as $D_i,H_i$ and its successive +thresholds as $\lambda_i$, with $\lambda_{-1}=T$. The construction +of Proposition~\ref{prop:scaling-construction} applies in dimension +$d$: at a positive threshold it uses the generalized cone theorem, +finiteness of the negative rays for the big +boundary-plus-nef part, and the ordinary rational step proposition. +The latter uses precisely $B_d$ together with the integral descent +and relative-positivity arguments of Section~\ref{sec:absolute}. + +More explicitly, if $D_i+H_i$ is not nef, convexity of the nef cone +gives $\lambda_i>1$, and there is an analytic extremal ray $R_i$ +such that +\[ + D_i\cdot R_i<0,\qquad + (D_i+\lambda_iH_i)\cdot R_i=0,\qquad H_i\cdot R_i>0. +\] +For the existence of a ray at the threshold, take parameters $t<\lambda_i$ +increasing to $\lambda_i$. On a ray negative for $D_i+tH_i$, +nefness of the preceding upper-threshold class implies $H_i\cdot R>0$. +Thus, once $t>\lambda_i/2$, that ray is also negative for +$D_i+(\lambda_i/2)H_i$. The latter has only finitely many negative +rays. Its boundary-plus-nef trace is big, and +the pair is generalized klt by the interpolation argument below. +Every step performed is therefore negative for $D_i+H_i$. + +Each birational step is an ordinary rational klt step contracting a +single analytic ray. It is projective on both sides, stays in the +compact K\"ahler globally strongly $\mathbb Q$-factorial category, +and has the forward class transport of +Section~\ref{repair:sec:real}. If $F_i\geq0$ is its ordinary +discrepancy divisor on a common resolution, crepancy at the scaling +threshold gives the discrepancy divisor +\begin{equation}\label{repair:eq:good-model-scaling-discrepancy} + (1-1/\lambda_i)F_i\geq0 +\end{equation} +for $D_i+H_i$. More generally the divisor at parameter +$0\leq t\leq\lambda_i$ is $(1-t/\lambda_i)F_i$. +This proves the required generalized klt induction and makes the +next upper-threshold class nef. It also shows that +$q_i^*H_{i+1}=p_i^*H_i+F_i/\lambda_i$ on the common resolution; +in particular the forward traces $H_i$ stay big. + +A Mori fibre step cannot occur while $\lambda_i>1$. Indeed the +pseudoeffective class $D_i+H_i$ would be negative on every curve in +a positive-dimensional fibre. Restrict a positive current in this +class to a general projective fibre, and then to a smooth resolution +of that fibre. Such a restriction is defined for a general fibre by +the local-potential definition and Fubini's theorem. Its intersection +with a power of an ample class is nonnegative, whereas a general +complete-intersection curve has class in $R_i$ and gives a negative +intersection. This is a contradiction. Pseudoeffectivity throughout +the program follows either by pushing forward positive currents, or +from the effective exceptional comparison and +Lemma~\ref{lem:positive-descent}. + +The program cannot have infinitely many birational steps, by ordinary +rational termination in dimension at most three. If $D_i$ becomes +nef or a threshold reaches $[0,1]$, the convex interval between it +and the preceding nef upper-threshold class contains $D_i+H_i$. +Consequently the stopping rule produces a model $X^{\rm m}$ with +\[ + A_{\rm m}=D_{\rm m}+H_{\rm m}\quad\text{nef}. +\] +Every step actually performed had $\lambda_i>1$. + +\smallskip\noindent +\emph{Removing all the divisors introduced by the resolution.} +Take a common projective resolution with maps +$r:W\to U$, $v:W\to X^{\rm m}$ and $s=\mu r:W\to X$. +The comparisons \eqref{repair:eq:good-model-scaling-discrepancy} accumulate +to a Bott--Chern comparison with an actual effective divisor +\[ + r^*\widetilde A=v^*A_{\rm m}+[E], + \qquad E\geq0,\quad E\text{ is }v\text{-exceptional}. +\] +Its coefficient is positive on the strict transform of every prime +on $U$ contracted by the program. Set +\[ + G_0=r^*E_\mu-E. +\] +By \eqref{repair:eq:good-model-smooth-error}, +$[G_0]=v^*A_{\rm m}-s^*A$. Hence $G_0$ is $s$-nef and +$s_*G_0=-s_*E\leq0$. The negativity lemma, applied to $-G_0$, +gives $G_0\leq0$. Thus +\begin{equation}\label{repair:eq:good-model-original-comparison} + s^*A=v^*A_{\rm m}+[E-r^*E_\mu], + \qquad E-r^*E_\mu\geq0. +\end{equation} +Since $E$ is $v$-exceptional and $E_\mu$ has positive coefficient on +every $\mu$-exceptional prime, every such prime was contracted. +The induced map $\phi:X\dashrightarrow X^{\rm m}$ therefore +extracts no divisor. The error in +\eqref{repair:eq:good-model-original-comparison} is $v$-exceptional and +has positive coefficient on each $\phi$-exceptional prime of $X$: +the subtracted term has coefficient zero on those primes. + +We now return to the original nef b-datum $\mathbf M$. Keep it on +the same common carrier $W$. The generalized boundary defining the +original pair on $W$ is changed by subtracting the actual effective +divisor $E-r^*E_\mu$ in +\eqref{repair:eq:good-model-original-comparison}. It pushes forward to +$\phi_*B$ because $\phi$ extracts no divisor. It defines +$K_{X^{\rm m}}+\phi_*B+\mathbf M_{X^{\rm m}}=A_{\rm m}$, and +its coefficients are below one because the original pair is gklt. +Thus $X^{\rm m}$ is a minimal model of the original generalized +pair, with its original b-datum. No assertion that the original +boundary remains effective or generalized klt on the intermediate +auxiliary models is required. + +Finally the auxiliary generalized pair +$(X^{\rm m},B_{0,\rm m}+\overline H)$ is gklt, and its +boundary-plus-nef trace is big. Apply $B_d$ to this pair to see that +$A_{\rm m}$ is semiample, so the model is good. For any original +class $\theta\in H^{1,1}_{\rm BC}(X)$, start with $\mu^*\theta$ +and use the forward transport across each ordinary analytic-ray +step. This defines a class $\theta_{\rm m}$ on $X^{\rm m}$ and +an actual exceptional-divisor comparison on $W$. In particular +\eqref{repair:eq:good-model-original-comparison} identifies the forward +trace of $A$ with $A_{\rm m}$. Only this forward transport is +asserted; no surjectivity from all Bott--Chern classes on the final +model is used. +\end{proof} + + +\subsection{Negative parts and lower-dimensional good models} +\label{repair:sec:negative-part-replacement} + +All equalities between $(1,1)$-classes in this section are equalities in +Bott--Chern cohomology. Equalities between divisors are stated separately. +The spaces are normal compact K\"ahler spaces with rational singularities; +resolutions and the morphisms called projective carry actual relatively +ample line bundles. We write $N_\sigma(\xi)$ for the divisorial negative +part of a pseudoeffective class. On a singular space it is defined by +pushing forward the negative part on a resolution. + +We use the following properties of the negative part: +\begin{enumerate} +\item A nef class has zero negative part. If $\xi=P+[F]$, with $P$ nef +and $F\geq0$ an effective real Cartier divisor, then +$N_\sigma(\xi)\leq F$. +\item If $r:W\to T$ is a modification, $\xi$ is pseudoeffective, and +$E\geq0$ is $r$-exceptional, then +\[ + N_\sigma(r^*\xi+[E])=N_\sigma(r^*\xi)+E, + \qquad r_*N_\sigma(r^*\xi)=N_\sigma(\xi). +\] +\item Minimal multiplicities are subadditive and homogeneous. In +particular, adding a nef class can only decrease them. For a K\"ahler +class $\omega$, +\[ + \nu(\xi,Q)=\lim_{\varepsilon\downarrow0} + \nu(\xi+\varepsilon\omega,Q). +\] +On a big class the minimal multiplicity is the infimum of the generic +Lelong numbers of its closed positive currents. +\end{enumerate} +These are the usual properties of the divisorial Zariski decomposition +\cite[\S3]{Boucksom2004}. For the exceptional-divisor identity and its +extension to normal spaces, only +\cite[Appendix~A, Lemmas~A.3, A.5 and A.7]{DHY2023} are needed. +No assertion about transporting arbitrary Bott--Chern classes across a +small bimeromorphic map is used here. + +\subsubsection{The initial relative program} + +\begin{lemma}[The absolute negative part after a relative program] +\label{repair:lem:negative-part-relative-program} +Let $\mu:U\to X$ be a projective resolution, let $\alpha$ be nef on $X$, +let $c>0$, and let $F_U\geq0$ be $\mu$-exceptional. Put +\[ + D_U=c\mu^*\alpha+[F_U]. +\] +Suppose that $\phi:U\dasharrow V$ is a finite $D_U$-negative program, +possibly relative to another base, and denote its transformed class and +divisor by $D_V$ and $F_V=\phi_*F_U$. Then +\[ + N_\sigma(D_V)=F_V. +\] +\end{lemma} + +\begin{proof} +Take a common projective resolution $p:W\to U$, $q:W\to V$. +The negativity comparison for the finite program is +\[ + p^*D_U=q^*D_V+[E], + \qquad E\geq0,\quad E\text{ is }q\text{-exceptional}. +\] +This comparison is valid for a relative negative program: its proof +uses the negativity of the contracted rays and the positive adjoint on +each flipped side, not absolute nefness of the final adjoint. +Since $p^*F_U$ is effective and exceptional over $X$, the exceptional +identity and nefness of $(\mu p)^*\alpha$ give +\[ + N_\sigma(p^*D_U)=p^*F_U + =N_\sigma(q^*D_V)+E. +\] +Pushing forward by $q$ proves the assertion. In particular, the +negative part in this statement is absolute, even when the program +that produced $V$ was relative. +\end{proof} + +\subsubsection{Descent of the effective vertical divisor} + +\begin{lemma}[Vertical numerical triviality] +\label{repair:lem:negative-part-vertical-descent} +Let $g:V\to S$ be a projective surjective morphism with connected fibres. +Assume that $S$ is globally Weil $\mathbb{Q}$-factorial. Let $F\geq0$ be +an effective real Cartier divisor on $V$, vertical over $S$, such that +\[ + F\cdot C=0 + \quad\text{for every curve }C\text{ contracted by }g. +\] +Then there is an effective real Cartier divisor $F_S$ on $S$ such that, +as actual divisors, +\[ + F=g^*F_S. +\] +\end{lemma} + +\begin{proof} +For a prime divisor $P\subset S$, write $m_Q$ for the multiplicity of +$Q$ in $g^*P$, where $Q$ ranges over the prime divisors dominating $P$. +These multiplicities may be computed over the smooth generic locus of +$P$, where $P$ is Cartier. Put +\[ + b_P=\min_{g(Q)=P}\frac{\operatorname{coeff}_Q F}{m_Q}, + \qquad F_S=\sum_P b_PP. +\] +Only finitely many $b_P$ are nonzero, since any such $P$ is the image of +a component of $F$. Thus $F_S$ is a genuine effective Weil real divisor. +Global Weil $\mathbb{Q}$-factoriality makes this finite divisor real +Cartier. + +We first check equality over codimension one in $S$. Work near a +general point of $P$ and restrict to a transverse disk. Resolving the +source, and cutting by general relative ample hypersurfaces if the +relative dimension exceeds one, reduces to a projective surface over +that disk with connected fibres. These operations can be performed +over a relatively compact Stein neighbourhood; they do not require +global sections on $S$. The intersection matrix of the components of +the special fibre is negative semidefinite, with kernel generated by +the full fibre with its multiplicities. The restriction of $F$ has +zero intersection with every fibre component. Its coefficients are +therefore proportional to those multiplicities. Equivalently, all the +ratios in the definition of $b_P$ are equal. When $g$ is birational this +assertion over the generic point of $P$ is immediate. + +Consequently +\[ + G=F-g^*F_S +\] +is a signed real Cartier divisor supported over a subset of codimension +at least two in $S$. Moreover, $G$ is numerically trivial over $S$. +We check that such a signed exceptional divisor is zero. The assertion +is local on $S$. Over a relatively compact Stein neighbourhood, take +$d=\dim V-\dim S$ general relative ample hypersurfaces and resolve their +intersection. They give a projective generically finite morphism +$H\to S$. The cuts may be chosen to meet any prescribed component of +$G$ in a nonzero divisorial trace. After normalization and Stein +factorization, $H\to S$ factors as a projective birational morphism +$H\to S'$ followed by a finite morphism $S'\to S$. The restricted +divisor $G|_H$ is exceptional for $H\to S'$ and numerically trivial +over $S'$. Applying the ordinary exceptional negativity lemma to both +$G|_H$ and $-G|_H$ gives $G|_H=0$. The choice of the cuts therefore +excludes every nonzero component of $G$. Hence $G=0$. + +The surface argument above is also the usual proof of the +degenerate-divisor negativity statement: after subtracting the minimum +multiple of the full fibre, an effective residual fibre divisor omits +a component and cannot be numerically trivial. Notice that projectivity +of $g$ was a hypothesis; it was not deduced from factoriality. +\end{proof} + +\subsubsection{The negative part on the lower-dimensional base} + +\begin{lemma}[Detecting the negative part by pullback currents] +\label{repair:lem:negative-part-base} +Let $g:V\to S$ be a surjective morphism. Suppose that $\alpha_S$ is nef, +$F_S\geq0$ is real Cartier, $c>0$, and +\[ + D_S=c\alpha_S+[F_S],\qquad D_V=g^*D_S,\qquad + N_\sigma(D_V)=g^*F_S. +\] +Then $N_\sigma(D_S)=F_S$. +\end{lemma} + +\begin{proof} +Nefness gives $N_\sigma(D_S)\leq F_S$. Fix a prime divisor $P\subset S$ +and a prime divisor $Q\subset V$ dominating it. Write +$m=\operatorname{mult}_Q(g^*P)>0$ and $b=\operatorname{coeff}_P F_S$. +At their generic smooth points, pullback of positive currents satisfies +\[ + \nu(g^*T,Q)=m\nu(T,P). +\] +Indeed, the divisorial term $\nu(T,P)[P]$ pulls back with multiplicity +$m$, and the residual current has zero generic Lelong number there. + +Choose K\"ahler forms $\omega_S,\omega_V$ and a constant $C>0$ for which +$C\omega_V-g^*\omega_S$ is K\"ahler. For $\varepsilon>0$, let $T_\varepsilon$ +be any positive current in the big class $D_S+\varepsilon[\omega_S]$. +Minimality of the multiplicity and monotonicity under adding a nef +class give +\begin{align*} + m\nu(T_\varepsilon,P) + &=\nu(g^*T_\varepsilon,Q)\\ + &\geq\nu(D_V+\varepsilon g^*[\omega_S],Q)\\ + &\geq\nu(D_V+C\varepsilon[\omega_V],Q). +\end{align*} +Taking the infimum over $T_\varepsilon$, and then letting +$\varepsilon\downarrow0$, gives +\[ + m\nu(D_S,P)\geq\nu(D_V,Q) + =\operatorname{coeff}_Q(g^*F_S)=mb. +\] +This proves the reverse inequality for every $P$. +All multiplicities are unchanged by resolving away from the generic +points in question, so the same argument applies to the normal spaces +under consideration. + +The $\varepsilon$ perturbation is necessary: at a pseudoeffective +boundary class, the infimum over its exact positive currents need not +equal its minimal multiplicity. The argument uses that equality only +for the big perturbed classes. +\end{proof} + +\begin{lemma}[Pullback when the positive part is nef] +\label{repair:lem:negative-part-nef-pullback} +Suppose +\[ + \xi=P+[F],\qquad P\text{ nef},\quad F\geq0\text{ real Cartier}, + \qquad N_\sigma(\xi)=F. +\] +For every projective resolution $p:W\to S$, +\[ + N_\sigma(p^*\xi)=p^*F. +\] +\end{lemma} + +\begin{proof} +Write $N'=N_\sigma(p^*\xi)$. Since $p^*P$ is nef, $N'\leq p^*F$. +Birational invariance gives $p_*N'=F$, so +$E=p^*F-N'\geq0$ is $p$-exceptional. The positive part of $p^*\xi$ is +\[ + p^*P+[E], +\] +and is modified nef. If $E\neq0$, exceptional negativity in its +covering-curve form provides a component of $E$ covered by curves $C_t$ +contracted by $p$, with $E\cdot C_t<0$ +\cite[Appendix~A, Lemma~A.3]{DHY2023}. A modified nef class has nonnegative +intersection with a general member of a family of curves covering a +prime divisor: use regularization to choose currents with analytic singularities, +arbitrarily small negative part, and zero generic divisorial Lelong number; +then restrict to a general member and let the negative bound tend to zero. But here +\[ + (p^*P+E)\cdot C_t=E\cdot C_t<0, +\] +a contradiction. Thus $E=0$. +\end{proof} + +\begin{proposition}[Any lower-dimensional good model suffices] +\label{repair:prop:negative-part-good-model} +Suppose the initial relative program has the data in +Lemma~\ref{repair:lem:negative-part-relative-program}. Assume in addition that $F_V$ is a real Cartier divisor, that +$\alpha_V$ is nef and agrees with $\mu^*\alpha$ on a common +resolution, and that there is an already projective connected-fibre +morphism $g:V\to S$ with +\[ +\alpha_V=g^*\alpha_S,\qquad D_V=g^*D_S. +\] +Suppose there is a projective small modification +$s:S^{\mathrm q}\to S$ such that $S^{\mathrm q}$ is globally Weil +$\mathbb Q$-factorial; the identity is allowed. Assume that the +lower-dimensional adjoint $s^*D_S$ has a good model: +there are a normal compact K\"ahler space $S_m$, a common projective +resolution $p:W\to S^{\mathrm q}$, $q:W\to S_m$, and a nef semiample +class $D_m$ such that +\[ + p^*s^*D_S=q^*D_m+[E], + \qquad E\geq0,\quad E\text{ is }q\text{-exceptional}. +\] +Then $\alpha$ is semiample on $X$. If the contraction defining +semiampleness of $D_m$ is Moishezon, the resulting contraction of +$\alpha$ is Moishezon as well. In particular, it is unnecessary to +lift a program on $S$ to $V$, or to require that a chosen program +producing $S_m$ preserve $\alpha_S$ at every intermediate step. +\end{proposition} + +\begin{proof} +Nefness descends under the surjective morphism $g$, so $\alpha_S$ is nef. +The class of $F_V$ is pulled back from $S$, so $F_V$ is numerically +trivial over $S$. It is therefore vertical: an effective horizontal +component would restrict to a nonzero effective divisor on a general +projective fibre, with positive intersection against a suitable power +of an ample class, contradicting numerical triviality. For a +birational $g$, verticality is automatic by dimension. +First take a projective resolution $\pi:\widetilde V\to V$ of the main +component of $V\times_S S^{\mathrm q}$. The induced map +$\widetilde g:\widetilde V\to S^{\mathrm q}$ is projective and has +connected fibres. Pull back $\alpha_V,D_V,F_V$ along $\pi$, and pull +back $\alpha_S,D_S$ along $s$. All displayed class identities are +preserved, and $\pi^*F_V$ remains an effective vertical divisor. +Lemma~\ref{repair:lem:negative-part-relative-program} gives +$N_\sigma(D_V)=F_V$ before this modification. Because +$D_V=c\alpha_V+[F_V]$ with $\alpha_V$ nef, +Lemma~\ref{repair:lem:negative-part-nef-pullback} then gives +\[ + N_\sigma(\pi^*D_V)=\pi^*F_V. +\] +We may therefore replace $(V,S,g)$ by +$(\widetilde V,S^{\mathrm q},\widetilde g)$ and suppress the new +superscripts in the rest of the proof. The good-model comparison now +reads $p^*D_S=q^*D_m+[E]$. No assertion that the crepant subboundary on +$\widetilde V$ is effective is needed: this space is used only for +classes, currents and the effective divisor $\pi^*F_V$. The +lower-dimensional generalized pair is the crepant pullback to the +small model $S^{\mathrm q}$. + +The class identity $[F_V]=g^*(D_S-c\alpha_S)$ shows that $F_V$ is +numerically trivial over $S$. Lemma~\ref{repair:lem:negative-part-vertical-descent} +gives an actual effective real Cartier divisor $F_S$ with +$F_V=g^*F_S$. Injectivity of pullback yields +\[ + D_S=c\alpha_S+[F_S]. +\] +The established identity $N_\sigma(D_V)=F_V$ and +Lemma~\ref{repair:lem:negative-part-base} therefore give +$N_\sigma(D_S)=F_S$, and +Lemma~\ref{repair:lem:negative-part-nef-pullback} gives +\[ + N_\sigma(p^*D_S)=p^*F_S. +\] +On the other hand $q^*D_m$ is nef, so the exceptional-divisor identity +applied to the good-model comparison gives +\[ + N_\sigma(p^*D_S)=E. +\] +Thus $E=p^*F_S$ as actual divisors. Subtracting them from the comparison +proves the exact class equality +\[ + q^*D_m=c\,p^*\alpha_S. +\] +This proves the needed preservation of $\alpha_S$ from the final good +model, without an assumption about its intermediate models. + +Choose a contraction $h:S_m\to T$ to a normal compact K\"ahler space +and a K\"ahler class $\kappa$ on $T$ with $D_m=h^*\kappa$. Taking a +resolution of the main component of $V\times_S W$, and then a common +projective resolution with $U$, produces a projective modification +$r:R\to X$ and a holomorphic map $\ell:R\to T$ satisfying +\[ + r^*\alpha=\frac1c\ell^*\kappa. +\] +For every curve $C$ in a fibre of $r$ this equality implies +$\ell(C)$ is a point, since a K\"ahler class has positive degree on +every nonconstant image curve. The fibres of the projective modification +$r$ are connected projective complex spaces, hence are connected by +chains of curves. Therefore $\ell$ is +constant on each fibre of $r$. The factorization theorem for a proper +map onto a normal space gives a holomorphic map $f:X\to T$ with +$\ell=f\circ r$. Pushing forward the class equality by $r$ gives +\[ + \alpha=f^*(\kappa/c). +\] +The maps from the main fibre-product component to $S_m$ have connected +general fibres; their Stein factorizations are finite birational over +the normal space $S_m$, hence have connected fibres everywhere. +Together with the connected fibres of $h$, this shows that $\ell$, +and therefore $f$, has connected fibres. This is the required +semiampleness of $\alpha$. + +Finally, $R\to S_m$ is projective: it is obtained from the projective +map $g$ by base change, followed by projective resolutions and the +projective map $q$. If $h$ is Moishezon, choose a projective surjection +$H\to S_m$ such that $H\to T$ is projective. A component of +$R\times_{S_m}H$ dominating $R$ is projective and surjective over $X$, +and its map to $T$ is projective. This is a Moishezon witness for $f$. +\end{proof} + + +\subsubsection{Positive carriers and the non-klt closed subspace} + +The following preparations separate positivity on a carrier from +positivity of its trace. All structure equations in this subsection +are equalities of Bott--Chern classes, with actual structure +subboundaries on the chosen resolutions. + +\begin{lemma}[A K\"ahler margin with the adjoint fixed] +\label{repair:lem:carrier-margin} +Let $(X,B+\mathbf M)$ be a generalized pair on a globally strongly +$\Q$-factorial compact K\"ahler space, with adjoint $A$. +The trace $\mathbf M_X$ is pseudo-effective; if the nef datum is +big on a carrier, its trace is big. If +$Q=A-c_1(K_X)$ is big, one can replace the generalized pair, +without changing $A$, so that its nef datum is K\"ahler on a +projective log resolution and +\[ + \mathcal J(X,B+\mathbf M)\subseteq + \mathcal J(X,B^{\rm new}+\mathbf M^{\rm new}). +\] +The new trace boundary is effective. A gklt input remains gklt. +\end{lemma} + +\begin{proof} +On a projective log resolution $p:W\to X$ carrying the nef datum, +write +\[ + [K_W+B_W]+\mathbf M_W=p^*A. +\] +Strong $\Q$-factoriality makes $K_X+B$ real Cartier. Thus +\[ + p^*\mathbf M_X=\mathbf M_W+[J],\qquad + J=B_W-\bigl(p^*(K_X+B)-K_W\bigr) +\] +with $J$ an actual exceptional real divisor. The divisor $-J$ is +$p$-nef, so negativity gives $J\geq0$. Exceptional descent of +positive currents proves that $\mathbf M_X$ is pseudo-effective. +If $\mathbf M_W$ is big, subtract a small pullback of a K\"ahler +class on $X$ first; the same argument proves bigness of the trace. +This comparison also shows that a generalized klt pair on a +strongly $\Q$-factorial space has ordinary klt underlying space. + +Suppose now that $Q$ is big. Regularization of a K\"ahler current +with analytic singularities, followed by a projective log resolution, +gives +\[ + p^*Q=H+[G], + \qquad H\ \text{K\"ahler},\qquad G\geq0. +\] +Choose $p$ also to carry the original nef datum and to resolve all +divisors involved. The K\"ahler correction on a further blowup is +obtained by subtracting a small effective exceptional divisor from +the pulled-back positive part and adding it to $G$. +Put $B_W^*=G-K_{W/X}$. Its pushforward is effective, and +\[ + [K_W+B_W^*]+H=p^*A. +\] +For sufficiently small $t>0$, the structure data +\[ + B_W^{\rm new}=(1-t)B_W+tB_W^*,\qquad + \mathbf M_W^{\rm new}=(1-t)\mathbf M_W+tH +\] +have K\"ahler nef part and effective trace boundary. There are only +finitely many coefficients to check; choose $t$ so that +$\lfloor B_W^{\rm new}\rfloor\leq\lfloor B_W\rfloor$. +The resolution formula +$\mathcal J=p_*\cO_W(-\lfloor B_W\rfloor)$ proves the ideal +inclusion. If the input is gklt, choose $t$ also so that every new +coefficient is less than one. On higher carriers these data are +always taken by log pullback. +\end{proof} + +In particular, if $X\to S$ is a morphism to a compact K\"ahler +space, a sufficiently small pullback of a K\"ahler class on $S$ +can be subtracted from the new nef datum on its K\"ahler carrier. +This changes the adjoint by that pullback and leaves every structure +boundary, hence every discrepancy and multiplier ideal, unchanged. + +For brevity, say that a class has \emph{EMC} if it is endowed with +a Moishezon contraction in the sense of +\cite[Definitions~2.32 and~2.34]{HX2026}: the contraction has +pushforward structure sheaf equal to the structure sheaf of its +target, contracts exactly the curves of degree zero, and admits a +projective surjective witness whose map to the target is projective. +This definition applies to nonreduced compact complex spaces. + +\begin{lemma}[EMC under projective contractions and restriction] +\label{repair:lem:emc-transfer} +Let $r:L\to M$ be a projective contraction of compact complex +spaces, possibly nonreduced. A class on $M$ has EMC if and only if +its pullback to $L$ has EMC. A class with EMC restricts to a class +with EMC on every closed analytic subspace. +\end{lemma} + +\begin{proof} +For ascent, compose the contraction of $M$ with $r$. A Moishezon +witness is obtained by base change of the witness over $M$; both +required maps are projective. A curve has zero pullback degree +precisely when it is vertical over $M$ or its image is a +zero-degree curve on $M$. + +For descent, the EMC map of $L$ is constant on each $r$-fibre. +Indeed the reduced connected projective fibre is connected by +chains of curves, and all those curves have degree zero. The map +therefore factors through $M$ as a map of underlying spaces. It +factors holomorphically, including on structure sheaves, because +$r_*\cO_L=\cO_M$: locally embed the target in a polydisc and +descend its coordinate functions using this equality. The +factorization has the contraction property. A projective witness +upstairs remains a projective witness over $M$ by composition. +Every curve of $M$ is dominated by a curve of $L$: base-change to +the normalization of the curve and use a multisection of the +resulting projective family. The projection formula then gives +the required characterization of contracted curves on $M$. + +For a closed subspace, restrict the EMC map and take its Stein +factorization. Its finite second map changes neither the contracted +curves nor their degree test. Restrict the projective witness too; +its map to the Stein target is projective by fibrewise relative +ampleness. This proves the assertion for the full closed-subspace +structure. +\end{proof} + +\begin{lemma}[The multiplier-ideal scheme on a resolution] +\label{repair:lem:multiplier-scheme-transfer} +Let $p:W\to T$ be a projective log resolution of a generalized +pair with effective trace boundary, carrying its nef datum. +Write $[K_W+B_W]+\mathbf M_W=p^*A$ and +\[ + \lfloor B_W\rfloor=F-P, + \qquad F,P\geq0,\qquad \Supp F\cap\Supp P + \ \text{has no divisorial component}. +\] +Let $N\subset T$ be the closed subspace defined by the generalized +multiplier ideal. Then $F\to T$ factors through a projective +contraction $F\to N$, and +\[ + p_*\cO_F=\cO_N. +\] +Consequently EMC on $N$ transports across a projective crepant +comparison of generalized pairs with effective trace boundaries. +\end{lemma} + +\begin{proof} +The negative part $P$ is $p$-exceptional, and +$\mathcal J=p_*\cO_W(P-F)$. Relative Kawamata--Viehweg vanishing +gives +\[ + R^1p_*\cO_W(P-F)=0. +\] +Indeed the difference between the actual line bundle $P-F$ and +$K_W+\{B_W\}$ has class $\mathbf M_W-p^*A$, which is nef over +$T$ and big over $T$ since $p$ is birational. This is the usual +projective-relative vanishing statement, applied locally over the +base; the fractional-part boundary is ordinary klt. +Because $p_*\cO_W(P)=\cO_T$, the divisor exact sequence yields +\[ + 0\longrightarrow\mathcal J\longrightarrow\cO_T + \longrightarrow p_*\cO_F(P)\longrightarrow0. +\] +The last map factors through $p_*\cO_F$. Multiplication by the +canonical section of $P$ gives an injection +$\cO_F\hookrightarrow\cO_F(P)$: in the SNC coordinates no +component of $P$ is a component of $F$, even with their respective +multiplicities. Surjectivity in the displayed sequence therefore +identifies $p_*\cO_F$ with $\cO_T/\mathcal J=\cO_N$ as an +algebra, not only as a module. Its support is $p(\Supp F)$, so the +induced map $F\to N$ is surjective and is a projective contraction. + +For a crepant comparison take a common projective log resolution. +The actual structure subboundary there is the same on both sides, +and the classes whose curves are tested have equal pullbacks. +Apply Lemma~\ref{repair:lem:emc-transfer} to the two contractions +from the same divisor scheme $F$. This also applies one step at a +time across flips. If $F$ is empty, the assertion is vacuous. +\end{proof} + +\begin{lemma}[Positivity on a surface Mori base] +\label{repair:lem:surface-base-positivity} +Let $f:X\to Z$ be a projective contraction from a normal compact +K\"ahler threefold to a normal compact K\"ahler surface. Suppose that +$X$ is klt and globally strongly $\Q$-factorial and that $-K_X$ is +$f$-ample. Let $\gamma\in\BC(Z)$ and $\alpha=f^*\gamma$. Assume that +$\alpha$ is the adjoint class of a generalized pair with effective +boundary, that $\alpha-[K_X]$ is big, and that its generalized +non-klt locus does not dominate $Z$. Then $Z$ is klt and globally +strongly $\Q$-factorial, and $\gamma-[K_Z]$ is big. +\end{lemma} + +\begin{proof} +First establish the singularities of the base, independently of the +pair defining $\alpha$. Fix a K\"ahler class $\omega_Z$ on $Z$. +Relative ampleness gives a sufficiently large $t>0$ for which +\[ + -[K_X]+t f^*\omega_Z +\] +is K\"ahler. With zero boundary and this descending nef datum, $X$ +is generalized klt and its adjoint is $t f^*\omega_Z$. The projective +canonical bundle formula \cite[Theorem~2.3]{HP2024} makes $Z$ +generalized klt. Take its projective small strong factorialization. +A small proper bimeromorphic morphism of normal surfaces is an +isomorphism, so $Z$ is globally strongly $\Q$-factorial. The +comparison in Lemma~\ref{repair:lem:carrier-margin} then makes +$Z$ klt. In particular $K_Z$ is $\Q$-Cartier. + +Apply Lemma~\ref{repair:lem:carrier-margin} to the pair defining +$\alpha$. This keeps the adjoint class and an effective boundary +trace, and does not enlarge the non-klt locus. On a projective log +resolution $r:W_0\to X$ carrying the new data, write +\[ + [K_{W_0}+B_{W_0}]+M_{W_0}=(fr)^*\gamma, + \qquad M_{W_0}\ \text{K\"ahler}. +\] +The pair is generalized klt over a nonempty open subset of $Z$. +Choose $\varepsilon>0$ small enough that +$M_{W_0}-\varepsilon(fr)^*\omega_Z$ remains K\"ahler. This changes +the adjoint to $f^*(\gamma-\varepsilon\omega_Z)$ without changing +any boundary coefficient. + +Choose a projective resolution $\tau:S\to Z$, and resolve the main +component of the corresponding base change together with $W_0$. +After a further log resolution there are projective morphisms +\[ + \mu:W\to X,\qquad l:W\to S,\qquad \tau l=f\mu, +\] +with $W,S$ smooth compact K\"ahler, $B_W$ having simple normal +crossings support, and +\begin{equation}\label{repair:eq:surface-base-adjoint} + [K_W+B_W]+M'_W + =l^*\tau^*(\gamma-\varepsilon\omega_Z), + \qquad M'_W\ \text{nef}. +\end{equation} +Here $B_W$ is the log-pullback boundary of the replaced pair. The +map $l$ has connected fibres: its Stein factor is finite and +bimeromorphic over the normal surface $S$, hence is $S$. + +Put $E=B_W^-$, the effective negative part of the divisor $B_W$. +Since the boundary trace on $X$ is effective, $E$ is +$\mu$-exceptional. Each of its components has image of dimension at +most one in $X$, and consequently cannot dominate $S$. Choose an +effective rational divisor $E'\geq E$ with the same support, and set +\[ + \widehat B=B_W+E' + =B_W^++(E'-E)\geq0. +\] +The pair $(W,\widehat B+M'_W)$ is generalized klt over an open +subset of $S$: the horizontal coefficients are unchanged and the +added divisor is vertical. Moreover $\mathcal O_W(E')$ is a +$\Q$-line bundle with a nonzero section in every sufficiently +divisible positive power on a general fibre of $l$; on such a +fibre it is trivial. Thus \cite[Theorem~2.2]{HP2024}, applied to +\[ + [K_W+\widehat B]+M'_W + =l^*\tau^*(\gamma-\varepsilon\omega_Z)+[E'], +\] +shows that +\begin{equation}\label{repair:eq:surface-relative-positive} + l^*\bigl(\tau^*(\gamma-\varepsilon\omega_Z)-[K_S]\bigr)+[E'] + \quad\text{is pseudo-effective}. +\end{equation} + +We remove the resolution errors before descending this positivity. +Choose a K\"ahler form $\omega_X$ on $X$, in the local smooth-potential +sense, and put +$\Omega=\mu^*\omega_X$, a smooth closed semipositive form on $W$. +Fibre integration gives the positive constant +\[ + c=l_*\Omega=\int_{W_s}\Omega + =\int_{X_z}\omega_X>0 +\] +for general $s\in S$ and $z=\tau(s)$; the maps defining the +birational modifications are isomorphisms along a general fibre. +Let $T$ be a closed positive current representing +\eqref{repair:eq:surface-relative-positive}. The current +$U=l_*(T\wedge\Omega)$ is closed and positive, and the projection +formula gives +\[ + [U]=c\bigl(\tau^*(\gamma-\varepsilon\omega_Z)-[K_S]\bigr)+[P], + \qquad [P]=l_*([E']\wedge\Omega). +\] +The current on the right defining $[P]$ is positive, closed, and +supported on the finitely many curves and points in $l(E')$. +The support theorem therefore identifies it with the integration +current of an effective real divisor $P$ on $S$. Furthermore, +\[ + \tau_*[P] + =f_*\mu_*([E']\wedge\mu^*\omega_X) + =f_*(\mu_*[E']\wedge\omega_X)=0, +\] +since $E'$ is $\mu$-exceptional. Hence $P$ is $\tau$-exceptional. +Write $K_S=\tau^*K_Z+K_{S/Z}$, with $K_{S/Z}$ an actual +$\tau$-exceptional rational divisor. Dividing the class of $U$ by +$c$ shows that +\[ + \tau^*(\gamma-\varepsilon\omega_Z-[K_Z]) + +[c^{-1}P-K_{S/Z}] + \quad\text{is pseudo-effective}. +\] +Lemma~\ref{lem:positive-descent} applies to the signed exceptional +divisor $c^{-1}P-K_{S/Z}$ and yields pseudo-effectivity of +$\gamma-\varepsilon\omega_Z-[K_Z]$. Adding +$\varepsilon\omega_Z$ proves that $\gamma-[K_Z]$ is big. +\end{proof} + + +\subsection{Closing the contraction induction} +\begin{proposition}[The restricted induction] +\label{repair:prop:restricted-bpf-induction} +Let $\mathsf T_d$ denote termination of existing ordinary rational +klt programs in dimension at most $d$, including the bound on +divisorial steps. The following implications hold: +\begin{align*} + \mathsf C_{d-1}&\Longrightarrow\mathsf C_{d,\mathrm{big}},\\ + \mathsf C_{d,\mathrm{big}}+\mathsf B_{d-1}+\mathsf G_{d-1} + &\Longrightarrow\mathsf B_d \qquad (2\leq d\leq4),\\ + \mathsf B_d+\mathsf T_d + &\Longrightarrow\mathsf G_d \qquad (d\leq3),\\ + \mathsf B_d+\mathsf C_{d-1}+\mathsf T_d + &\Longrightarrow\mathsf C_d \qquad (d\leq3). +\end{align*} +Consequently $\mathsf B_4$ holds. No assertion $\mathsf G_4$ or +$\mathsf C_4$ is required. +\end{proposition} + +\begin{proof} +The inputs are the cone theorem, projective relative vanishing and +minimal-model theory, projective small factorializations and dlt +modifications, and the nef-and-big K\"ahler criterion from +\cite{HX2026,HLX2026}. The higher-carrier canonical bundle formula +\cite[Theorem~2.3]{HP2024} is applied to globally gklt pairs; +\cite[Theorem~2.2]{HP2024} supplies the relative positivity used +in Lemma~\ref{repair:lem:surface-base-positivity}. Each application +below starts with a projective morphism. + +\smallskip\noindent +\emph{The big non-klt contraction.} +Apply the construction of \cite[Section~3]{HX2026}. On its smooth +modification $\nu:U\to X$ it writes +\[ + \nu^*\alpha=[D_U]+\eta_U, + \qquad D_U\geq0,\quad \eta_U\text{ K\"ahler}. +\] +The induction over the jumping coefficients of the multiplier +ideal reduces the new reduced stratum to dimension at most $d-1$. +The given contraction on the old non-klt subspace and +$\mathsf C_{d-1}$ provide the Moishezon maps of those strata. +Every map that is promoted to a projective map in that construction +contracts exactly the curves on which $\nu^*\alpha$ vanishes. +On each such curve the actual real line bundle $-D_U$ has degree +$\eta_U\cdot C$. On a further projective common resolution +$q:U''\to U$, choose an effective exceptional divisor $E$ with +$-E$ relatively ample and choose $\varepsilon>0$ sufficiently small. +Use the decomposition +\[ + q^*\nu^*\alpha=[D'']+\eta'',\qquad + D''=q^*D_U+\varepsilon E,\qquad + \eta''=q^*\eta_U-\varepsilon[E]. +\] +Here $\eta''$ is K\"ahler, and the actual real line bundle $-D''$ +has degree $\eta''\cdot C$ on every contracted curve. Restrict this +decomposition to the smooth reduced components in the gluing +construction. Lemma~\ref{repair:lem:actual-line-polarization} then supplies +precisely the relative ampleness needed in place of +\cite[Lemma~2.42]{HX2026}, including the common-resolution step in its +Claim~3.5. The exceptional correction $-\varepsilon[E]$ makes the +positive part $\eta^{\prime\prime}$ K\"ahler on the common resolution. + +The exact sequences of multiplier ideals, relative vanishing, +finite pushouts, and extension from sufficiently thickened +$\operatorname{Supp}D_U$ in that proof then apply unchanged. +They give the birational Moishezon contraction in +$\mathsf C_{d,\mathrm{big}}$. In particular the gluing step uses +neither generalized termination nor a projectivity criterion for +an undetected ray. + +\smallskip\noindent +\emph{Preparation for both cases of $\mathsf B_d$.} +The modified-big perturbation +\cite[Lemma~2.23]{HX2026} supplies a nef datum that dominates a +K\"ahler class on its carrier. Subtracting a sufficiently small +multiple of the pullback of a K\"ahler class $\omega_X$ still leaves +a nef datum on that carrier. Thus +$\alpha$ is a gklt adjoint plus $\varepsilon\omega_X$, and the cone +argument of \cite[Lemma~2.45]{HX2026} makes $\alpha$ NQC. +This preparation applies whether or not $\alpha$ is big. + +\smallskip\noindent +\emph{The nef-and-big case of $\mathsf B_d$.} +For a gklt pair the multiplier ideal is the unit ideal, so the +preceding big non-klt assertion now applies and gives a birational +contraction $h:X\to Y$. +On a projective resolution $p:W\to X$ chosen projective over $Y$, +relative Kawamata--Viehweg vanishing for the effective exceptional +divisor $-\lfloor B_W\rfloor$ gives +$R^ih_*\mathcal O_X=0$ for $i>0$. Thus $Y$ has rational +singularities. Proper birational Bott--Chern descent +\cite[Lemma~8.7]{DHP2024} gives $\alpha=h^*\gamma$. +The descended adjoint is gklt, nef and big, and has no trivial +curve. The criterion \cite[Theorem~4.3]{HLX2026} makes $\gamma$ +K\"ahler. + +For completeness, the projectivity input in that criterion is +restricted to a map $S\to Z'$ between smooth compact K\"ahler +manifolds with rationally connected general fibre: $S$ is the +chosen smooth divisor on a resolution and $Z'$ is the resolution +of the null-locus component. The smooth-source, smooth-base +argument in \cite[Theorem~3.1, Step~1]{ClaudonHoring2024} applies. Its subsequent +relative program starts with this projective map. Thus no general singular-source projectivity assertion is needed +for this application of the criterion. + +\smallskip\noindent +\emph{The non-big case of $\mathsf B_d$.} +Use a projective small factorialization and the modified-big +perturbation of the pair. The non-pseudo-effectivity of $K_X$ +gives an MRC fibration by \cite{Ou2025}. Choose a smooth K\"ahler +MRC base $Z$ and a smooth modification $\mu:U\to X$ such that +$U\to Z$ is projective. Only the smooth case of +\cite[Theorem~3.1, Step~1]{ClaudonHoring2024} is needed: pullback identifies +the holomorphic two-forms since the general fibre is rationally +connected. The same rational Hodge correction identifies any +$(1,1)$-class on $U$, modulo a class pulled back from $Z$, with +an actual real line bundle. + +Write, as in \cite[Theorem~4.1, Claim~4.1]{HX2026}, +\[ + D_U(a)=K_U+\Delta_U+\mathbf M_U+a\alpha_U + =(a+1)\alpha_U+F_U, + \quad \alpha_U=\mu^*\alpha,\quad + \Delta_U,F_U\geq0, +\] +where $\Delta_U$ is klt and $F_U$ is $\mu$-exceptional. +The modified-big replacement is chosen, as in the cited Claim~4.1, +so that the nef datum $\mathbf M_U$ on this smooth carrier is +K\"ahler. If a further projective resolution is needed, subtract a +sufficiently small effective exceptional divisor from its nef part +and add that divisor to the subboundary; this preserves the +adjoint and the klt inequalities. +Choose $a_0$ using the uniform bound of +Proposition~\ref{repair:prop:relative-nqc-uniform}. It makes the relative +$D_U(a_0)$-program $\alpha_U$-trivial and preserves that choice +through every step. This is a +\emph{projective} relative program from its first step: the nef +data are represented by real line bundles modulo $Z$. +Lemma~\ref{repair:lem:fixed-smooth-base-algebraicity} applies on every +intermediate model over this fixed smooth base. +More precisely, put $r:U\to Z$ and choose one actual global real +line bundle $L$ with +\[ + \mathbf M_U+a_0\alpha_U=c_1(L)+r^*\gamma. +\] +The bundle $L$ is relatively ample, because $\mathbf M_U$ is +K\"ahler and $\alpha_U$ is nef. On each of a fixed finite collection +of relatively compact Stein charts of $Z$, choose an effective +real divisor $\Theta$ representing $L$, with $(U,\Delta_U+\Theta)$ +klt. The representatives can retain a positive relatively ample +part in their boundaries. Here the equality +$K_U+\Delta_U+\Theta\sim_{\R}K_U+\Delta_U+L$ is an actual +real linear equivalence of line bundles; the equality with +$D_U(a_0)$ modulo $r^*\gamma$ is separately an equality of +Bott--Chern classes. + +For the ample-model comparison below, make the following additional +choices before running the program. Take the fixed finite cover in +the form $W_\ell\Subset Y_\ell\subset Z$, where $Y_\ell$ is a Stein +coordinate chart and $W_\ell$ is a closed coordinate polydisc, with +the interiors of the $W_\ell$ covering $Z$. Each $W_\ell$ is a +semianalytic Stein compact, so it satisfies condition~(P4) of +\cite{Fujino2022}; thus condition~(P) holds for the restriction of every +normal projective model over $Z$ to $Y_\ell$. + +Write +\[ + \alpha_i=c_1(N_i)+f_i^*\Gamma +\] +for the real line bundles $N_i$ transported in +Proposition~\ref{repair:prop:relative-nqc-uniform}; put $N_i=0$ if +$\alpha_U=0$. These bundles are nef over $Z$ and pull back from +each contraction target, on both sides of a flip. Set $a_j=a_0+j$ +for $j=1,2$. The real line bundles $L+jN_U$ are relatively ample. +On each initial chart choose, once and for all, +\[ + \Theta_j\geq0,\qquad \Theta_j\sim_{\R}L+jN_U, + \qquad (U,\Xi_{j,U}:=\Delta_U+\Theta_j)\ \text{klt}. +\] +Such representatives are obtained from general sufficiently +divisible relative sections; their boundaries are relatively big +because $L+jN_U$ is relatively ample and $\Delta_U\geq0$. +With $\Xi_{0,U}:=\Delta_U+\Theta$, these are actual real linear +equivalences +\[ + K_U+\Xi_{j,U}\sim_{\R}K_U+\Xi_{0,U}+jN_U +\] +on each chart, separately from the Bott--Chern comparison with the +fixed base classes. + +Let $\Xi_{j,i}$ denote their birational transforms. Pushforward of +these linear equivalences and the actual descent of $N_i$ give +\[ + K_{U_i}+\Xi_{j,i} + \sim_{\R}K_{U_i}+\Xi_{0,i}+jN_i +\] +at every step. Thus the contracted adjoints have the same degrees +on the negative side, and the flipped adjoints have the same degrees +on the positive side. Every step of the chosen program is therefore +also a $(K_{U_i}+\Xi_{j,i})$-negative step. Ordinary discrepancy +negativity preserves klt for these fixed pairs. Their boundaries +remain effective, and relative bigness is preserved by these +birational pushforwards, as in the proof of +\cite[Lemma~11.16]{Fujino2022}. + +Fix these ordinary pairs on the initial charts. Their actual +linear equivalences push forward throughout the program. On a +common resolution at each step, exceptional negativity preserves +the Bott--Chern comparison with $D_U(a_0)$ modulo the fixed base +class. Thus every subsequent contraction or flip is a step for +these fixed ordinary pairs. The projective ordinary theorems +\cite{Fujino2022,FujinoCompact2026} apply. In particular, the finiteness +of weak log canonical models in \cite[Theorem~E]{Fujino2022} does not +require local $\Q$-factoriality of each intermediate model. Applied +on the finite chart cover, its chamber argument gives termination +of the global projective program with scaling. Each small step +is constructed by its global rational detector algebra as above; +uniqueness of the relatively ample model identifies the local +ordinary flips on overlaps. This supplies a good +minimal model $U\dasharrow V$ over $Z$. Here one uses the projective case of +\cite[Proposition~2.30]{HX2026}, not its general part~(3). + +Here is an explicit ample-model comparison that gives the required +descent of $\alpha_V$. Both $D_V(a_0)$ and $\alpha_V$ are nef over +$Z$. For $j=1,2$, the ordinary adjoint $K_V+\Xi_{j,V}$ is +$\R$-Cartier and represents +\[ + D_V(a_j)-f_V^*(\gamma+j\Gamma) + =D_V(a_0)+j\alpha_V-f_V^*(\gamma+j\Gamma). +\] +It is consequently nef over every $W_\ell$. The pair +$(V,\Xi_{j,V})$ is klt and its effective boundary is relatively +big. Apply \cite[Lemma~11.15]{Fujino2022} with +$A=\Xi_{j,V}$ and $B=0$. Its condition on non-klt centres is +vacuous. After shrinking around $W_\ell$, it gives +\[ + \Xi_{j,V}\sim_{\R}A_j+B_j,\qquad + A_j\geq0\ \text{relatively ample},\quad B_j\geq0, + \qquad (V,A_j+B_j)\ \text{klt}. +\] +In particular this pair is log canonical, supplies the klt boundary +required in \cite[Theorem~8.3]{Fujino2022}, and its adjoint is +$\R$-Cartier and nef over $W_\ell$. That theorem makes +$K_V+\Xi_{j,V}$ semiample on a neighbourhood of $W_\ell$. +The pushed-forward actual linear equivalences identify these local +adjoints with restrictions of the same global real line-bundle +data. Their ample models therefore agree on overlaps by uniqueness +and glue as above. Hence $D_V(a_1)$ and $D_V(a_2)$ have projective +relative ample-model contractions over $Z$. Their zero curves are exactly the common zero +curves of $D_V(a_0)$ and $\alpha_V$. Their projective ample-model +contractions therefore have the same fibres: these fibres are +connected by curves, and each contraction is constant on the +fibres of the other. Identify the two normal targets, writing the +common contraction as $g:V\to S$. If +$D_V(a_j)=g^*\lambda_j$, with $\lambda_j$ relatively K\"ahler over +$Z$, subtraction gives +\[ + \alpha_V=g^*(\lambda_2-\lambda_1)=g^*\alpha_S. +\] +This is an equality of Bott--Chern classes, not merely of curve +degrees. Since the initial program is $\alpha_U$-trivial, it is +also $D_U(a_1)$-negative. From now on put $a=a_1$ and suppress +the argument in $D_U(a)$ and $D_V(a)$. + +The maps $V\to Z$ and $S\to Z$ are projective. Moreover $g$ is +projective: a relatively ample bundle for $V\to Z$ restricts to +an ample bundle on every fibre of $g$, and hence is $g$-ample. +The argument of \cite[Theorem~4.1, Claim~4.2]{HX2026}, using +projective relative semipositivity, gives $\dim S0$ so small that the pullback of +$\varepsilon\omega_S$ can be subtracted from the K\"ahler nef +datum. The resulting pair is globally gklt, its trace boundary is +effective, and its adjoint is +$g^*(D_S-\varepsilon\omega_S)$. On a projective log resolution +$r:P\to V$ its structure equation is +\[ + [K_P+B_P]+\mathbf M_P^{\rm new} + =(gr)^*(D_S-\varepsilon\omega_S), + \qquad \mathbf M_P^{\rm new}\ \text{nef}. +\] +All hypotheses of \cite[Theorem~2.3]{HP2024} now hold: $g$ is a +projective contraction of normal compact K\"ahler spaces, the pair +is globally generalized klt, and the adjoint equality is a +Bott--Chern pullback. The theorem gives generalized klt data on +$S$ with effective trace boundary and adjoint exactly +$D_S-\varepsilon\omega_S$. On a sufficiently high smooth +carrier $u:S_1\to S$ these satisfy +\[ + u^*(D_S-\varepsilon\omega_S) + =[K_{S_1}+B_{S_1}]+\mathbf N_{S_1}, + \qquad \mathbf N_{S_1}\ \text{nef}. +\] +The subboundary $B_{S_1}$ can have negative coefficients. +Add $\varepsilon\overline{\omega_S}$ to the nef b-datum. +This restores the exact adjoint $D_S$ and preserves every boundary +and discrepancy. Its carrier trace +$\mathbf N_{S_1}+\varepsilon u^*\omega_S$ is nef and big. +Consequently the effective trace boundary plus nef trace on $S$ +is modified big: lift the effective boundary by strict transform +to a common carrier and push down the resulting big class. +The nef datum throughout is a datum on the carrier. + +Take a projective small strong $\Q$-factorialization +$s:S^{\mathrm q}\to S$ and resolve the main component of $V\times_S S^{\mathrm q}$. +The resulting maps $\pi:\widetilde V\to V$ and +$\widetilde g:\widetilde V\to S^{\mathrm q}$ are projective, +and $\widetilde V$ is compact K\"ahler. Pull back $D_V$, +$\alpha_V$ and $F_V$ to $\widetilde V$, and $D_S$ and +$\alpha_S$ to $S^{\mathrm q}$. The pair on $S^{\mathrm q}$ is +gklt and its boundary-plus-nef class remains modified big: smallness +preserves the effective boundary trace, and on a common carrier +the nef datum is still nef and big. +Lemma~\ref{repair:lem:negative-part-relative-program} first gives +$N_\sigma(D_V)=F_V$. Lemma~\ref{repair:lem:negative-part-nef-pullback} then gives +$N_\sigma(\pi^*D_V)=\pi^*F_V$. The new total space is used only as a +carrier for this equality and for pullbacks of positive currents; +no effective boundary on it is needed. Rename these spaces $V$ +and $S$. No extra relative program from Claim~4.4 of the cited proof is needed. + +The vertical-divisor descent and negative-part lemmas above now +give actual effective divisors $F_S,F_V$ with +\[ + F_V=g^*F_S,\qquad + D_S=(a+1)\alpha_S+[F_S],\qquad N_\sigma(D_S)=F_S. +\] +Apply $\mathsf G_{d-1}$ to the generalized pair with adjoint $D_S$. +On a common resolution $p:W\to S$, $q:W\to S_m$ of the resulting +good model, write +\[ + p^*D_S=q^*D_m+[E],\qquad E\geq0 + \text{ exceptional over }S_m. +\] +The negative-part comparison proved above gives +$E=p^*F_S$, and hence +\[ + q^*D_m=(a+1)p^*\alpha_S. +\] +Since $D_m$ is semiample, $\alpha_S$ is semiample after descent +through $p$. Pulling back by $g$ and using the +$\alpha$-trivial initial program gives semiampleness of +$\alpha$ on $X$. The target is compact K\"ahler, and the +resulting map is Moishezon, as follows by taking common projective +modifications of the maps just constructed. The holomorphic descent and the Moishezon witness are those of +Proposition~\ref{repair:prop:negative-part-good-model}. + +\smallskip\noindent +\emph{Selected good models in dimensions at most three.} +Lemma~\ref{repair:lem:lower-dimensional-good-model} gives +$\mathsf G_d$ from $\mathsf B_d$ and ordinary rational +termination. Its smooth input has the form +\[ + \mu^*A+[E_\mu]=K_U+B_q+H, + \qquad B_q\text{ rational klt},\quad H\text{ K\"ahler}, +\] +where $E_\mu$ is effective with all $\mu$-exceptional divisors in +its support. The ordinary $(K_U+B_q)$-program with scaling of $H$ +is stopped at the first threshold at most one. Every performed +step is negative for the displayed adjoint. Termination is the +ordinary specialization of Theorem~\ref{thm:gklt-three}, +with zero nef b-divisor. Its proof uses the projective relative and +discrepancy arguments of Section~\ref{sec:threefold}, not +$\mathsf B_d$ or $\mathsf G_d$. +The final nef adjoint is semiample by $\mathsf B_d$. +Negativity removes the added exceptional divisors and gives the +claimed model of $X$. All forward transforms used here are those +of the detected ordinary steps; no inverse identification of +Bott--Chern groups is needed. + +\smallskip\noindent +\emph{The non-big non-klt contraction in dimensions at most three.} +Assume $\mathsf B_d$, $\mathsf C_{d-1}$ and termination of +existing ordinary rational klt programs in dimensions at most $d$, +where $2\leq d\leq3$. The big case having been proved, let +$\alpha$ be non-big. Take a projective dlt modification and a +projective small strong factorialization, as in +\cite[Theorems~2.26 and~2.27]{HX2026}. Denote their composite by +$p:T\to X$ and use the full crepant generalized boundary on $T$. +The underlying space $T$ is klt, compact K\"ahler and globally +strongly $\Q$-factorial. The crepant boundary is effective: +its nonexceptional coefficients are the original ones, and each +extracted prime has log discrepancy at most zero. The pulled-back +class $\alpha_T$ remains nef, weakly NQC and non-big. +Lemma~\ref{repair:lem:multiplier-scheme-transfer} transports the +EMC hypothesis on the multiplier-ideal closed subspace to $T$. + +We verify the bigness needed for the ordinary program. On $T$ put +\[ + Q_T=\alpha_T-c_1(K_T)=B_T+\mathbf M_T. +\] +The modified-bigness resolution lemma +\cite[Lemma~2.10]{HX2026} gives bigness after adding an effective +exceptional divisor $E$ whose support contains all modification +exceptional primes. Each of these primes already occurs in $B_T$ +with positive coefficient. Since $\mathbf M_T$ is pseudo-effective +by Lemma~\ref{repair:lem:carrier-margin}, for sufficiently small +$s>0$ the identity +\[ + Q_T=s(Q_T+[E])+(1-s)\mathbf M_T+ + [(1-s)B_T-sE] +\] +expresses $Q_T$ as a big class plus a pseudo-effective class. +For the small factorialization alone the exceptional divisor is +empty. Hence $Q_T$ is big. + +Lemma~\ref{repair:lem:adaptive-nqc-program} gives a finite ordinary +$K$-negative, $\alpha_T$-trivial program ending in a projective Mori +fibre contraction +\[ + f:Y\to Z. +\] +Its class descends in Bott--Chern cohomology: +$\alpha_Y=f^*\gamma$, with $\gamma$ nef and weakly NQC on the +normal compact K\"ahler base. Transport the generalized nef +b-datum and the full crepant boundary along the program. On common +resolutions the adjoints and structure subboundaries agree; since +no step extracts a divisor, the boundary remains effective. +The ordinary discrepancy comparison gives +\[ + q^*(\alpha_{i+1}-c_1(K_{Y_{i+1}})) + =p^*(\alpha_i-c_1(K_{Y_i}))+[F_i],\qquad F_i\geq0, +\] +so $Q_Y=\alpha_Y-c_1(K_Y)$ remains big. +Lemmas~\ref{repair:lem:emc-transfer} +and~\ref{repair:lem:multiplier-scheme-transfer} transport both the +EMC hypothesis on the multiplier-ideal scheme and, once obtained, +the EMC conclusion across these projective comparisons. +It therefore suffices to prove EMC for $\gamma$ on $Z$. + +If $\dim Z\leq1$, this follows from degree on a normal compact +curve, using the identity for positive degree and the map to a +point for degree zero. The only remaining case is +$\dim Y=3$, $\dim Z=2$. The auxiliary application of +\cite[Theorem~2.3]{HP2024} in +Lemma~\ref{repair:lem:surface-base-positivity} shows that $Z$ is +klt and globally strongly $\Q$-factorial. + +Apply Lemma~\ref{repair:lem:carrier-margin} on $Y$ with adjoint +$\alpha_Y$. The multiplier ideal can only increase, so its new +closed subspace $N$ is a closed subspace of the previous one. +It has EMC for $\alpha_Y|_N$ by +Lemma~\ref{repair:lem:emc-transfer}. On a projective log resolution +$r:W_0\to Y$ the new data satisfy +\[ + [K_{W_0}+B_{W_0}]+\mathbf M_{W_0}=(fr)^*\gamma, + \qquad \mathbf M_{W_0}\ \text{K\"ahler}. +\] + +Suppose first that $N$ dominates $Z$. Write +$\mathcal J=r_*\cO_{W_0}(-\lfloor B_{W_0}\rfloor)$. +Relative Kawamata--Viehweg vanishing for $fr$ gives +\[ + R^1(fr)_*\cO_{W_0}(-\lfloor B_{W_0}\rfloor)=0: +\] +the difference with $K_{W_0}+\{B_{W_0}\}$ is the relatively +nef and big class $\mathbf M_{W_0}-(fr)^*\gamma$. +The low-degree Leray sequence implies $R^1f_*\mathcal J=0$. +The exact sequence of the actual multiplier-ideal scheme therefore +gives a surjection +\[ + \cO_Z\longrightarrow f_*\cO_N. +\] +It is injective because $Z$ is reduced and $N$ dominates it. +Thus $N\to Z$ is a projective contraction, including on structure +sheaves. EMC on $N$ descends to $Z$ by +Lemma~\ref{repair:lem:emc-transfer}. + +Suppose next that $N$ does not dominate $Z$. The pair is gklt +over a nonempty open subset of $Z$. +Lemma~\ref{repair:lem:surface-base-positivity}, applied to these +data, gives +\[ + \gamma-c_1(K_Z)\ \text{big}. +\] +If $\gamma$ is not big, apply +Lemma~\ref{repair:lem:adaptive-nqc-program} in dimension two to +$(Z,\gamma)$. Its klt, factoriality, nefness, NQC and bigness +hypotheses have all been verified; $\mathsf B_2$ and termination +of existing ordinary surface programs are available. Its +class-trivial Mori contraction has base of dimension at most one. +EMC there, followed by the projective comparisons of +Lemma~\ref{repair:lem:emc-transfer}, gives EMC on $Z$. + +Finally suppose $\gamma$ is big. Take a projective resolution +$\tau:S\to Z$ with $S$ smooth and compact K\"ahler. +The class $\tau^*\gamma$ is big and nef. Its +null curves are finite: a K\"ahler current with analytic +singularities in this class has positive degree on every curve +not contained in its singular locus. Their intersection matrix is +negative definite. Indeed Hodge index is negative definite on the +orthogonal complement of $\tau^*\gamma$, whose square is positive. +The null-curve classes are independent: a relation can be written +as equality of classes of two effective real divisors with disjoint +component supports; their mutual intersection is nonnegative, +contradicting negative definiteness unless the common class is +zero, which its positive K\"ahler degree excludes. +Grauert's contraction criterion \cite{Grauert1962} gives a +contraction of precisely these curves onto a normal compact complex +surface. The contraction is projective: solve +using their negative-definite matrix for an integral combination +having positive degree on every contracted curve, and apply +fibrewise relative ampleness. This is EMC on $S$, and it descends +to $Z$ by Lemma~\ref{repair:lem:emc-transfer}. +Thus $\mathsf C_d$ holds in all required dimensions. + +\smallskip\noindent +\emph{Order of the induction.} +The assertions in dimensions zero and one are immediate from +the degree of a class on a compact curve (and the ordinary curve +minimal model program). For $d=2,3$, prove successively +\[ + \mathsf C_{d,\mathrm{big}},\quad + \mathsf B_d,\quad \mathsf G_d,\quad\mathsf C_d. +\] +At $d=4$ prove only $\mathsf C_{4,\mathrm{big}}$ and +$\mathsf B_4$. The ordinary rational termination invoked at the +intermediate stages has dimension at most three. This closes +the induction without using \cite[Theorems~1.5 or~5.15]{HX2026}. +\end{proof} +\subsection{Termination of ordinary programs}\label{repair:sec:reduction} + +\begin{corollary}\label{repair:cor:existing} +Using Theorem~1.1 of \cite{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026}, every existing sequence of ordinary +rational klt flips in the global Weil $\Q$-factorial compact K\"ahler +fourfold category terminates, provided both sides of every small +diagram are projective and the ordinary adjoints have the specified +opposite ample signs. In this first formulation, compatible actual +canonical divisor representatives are fixed on the models. The contraction +bases are required to be normal compact K\"ahler, and the morphisms to +have connected fibres. +\end{corollary} +\begin{proof} +Take the fixed nef b-divisor in \cite{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026} to be zero, represented on +any projective log resolution of the initial space. Its class is nef. +Klt implies log canonical; +the boundary is rational and is transported by strict transform. All +the remaining conditions in that theorem are exactly the hypotheses +just stated. No pseudo-effectivity or scaling parameter is needed. +\end{proof} + +\subsubsection{The intrinsic canonical-sheaf formulation} +The printed theorem in \cite{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026} specifies actual canonical divisors. +For zero nef part, its proof also has the following intrinsic +formulation; this observation is necessary to preserve the intrinsic +formulation of Theorem~\ref{thm:finite}. + +For each finite comparison diagram, choose a sufficiently divisible +integer $m$ clearing the boundary denominators and the adjoint indices +on its models, and put +\[ + \mathcal D_{T,m} + =\bigl(\omega_T^{[m]}\otimes\cO_T(mB)\bigr)^{**}. +\] +It is an invertible sheaf. On a common resolution of two models, the +canonical identification on their common smooth open defines a +distinguished meromorphic section of +\[ + p^*\mathcal D_{T,m}\otimes(q^*\mathcal D_{T',m})^{-1}. +\] +The relative canonical Jacobians and the boundary equations give its +finite meromorphic orders along exceptional divisors. Its divisor +divided by $m$ is the actual discrepancy-change divisor. It is +independent of the chosen divisible index and is compatible with +further pullback. No global meromorphic section of $\omega_T$ has +been chosen. The integer $m$ may change from one finite diagram to +another; no uniform bound on the canonical indices of an infinite +sequence is asserted. + +In the zero-nef-part proof, negativity and the support comparisons +use precisely these exceptional divisors. The local adjoint algebras +are intrinsically the direct sums of the sheaves +$f_*\mathcal D_{T,m}$, and the adjunction comparisons are comparisons +of dualizing sheaves. The relative canonical divisor occurring in the +companion's branch argument is already defined in this manner. +Its local small factorialization uses the corresponding crepant +identity of reflexive canonical sheaves, and its globalization uses +the intrinsic relative canonical divisor. The Hodge, parameter-space +and monodromy steps use constant sheaves and ordinary line bundles; +they do not require a global canonical form. + +The fixed denominator in the difficulty clears the finitely +many initial boundary coefficients and the fixed extracted-label +coefficients, exactly as in \cite{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026}. It is separate from the +diagram-dependent adjoint indices above. In the smooth-centre +positive-surface witness calculation with zero nef part, the formula +$a^+=2-\operatorname{ord}_E(B)$ needs only the initial boundary +denominators. Neither that calculation nor the difficulty +requires a uniform canonical Cartier index along the sequence. +Replacing the canonical representatives by these canonical local +comparisons therefore leaves that proof unchanged and proves the +intrinsic version of Corollary~\ref{repair:cor:existing}. + +\subsubsection{The supporting contraction statement} + +\begin{proposition}[Supporting contractions]\label{repair:prop:supporting-contraction} +Let $(T,B)$ be an ordinary rational klt pair on a normal globally Weil +$\Q$-factorial compact K\"ahler space of dimension $1\leq d\leq4$, +with canonical sheaf a rational line bundle. Put $D=K_T+B$. For every $D$-negative extremal +ray $R$ and every supporting class with the K\"ahler margin +\[ + \alpha\text{ nef},\qquad \NA(T)\cap\alpha^\perp=R, + \qquad \alpha-c_1(D)\text{ K\"ahler}, +\] +there is a proper surjective morphism $f:T\to Z$ with connected +fibres onto a normal compact K\"ahler space and a K\"ahler class +$\gamma$ on $Z$ such that $\alpha=f^*\gamma$. +Moreover $f$ is projective and $-D$ is $f$-ample. +\end{proposition} +\begin{proof} +Write $\kappa=\alpha-c_1(D)$ and regard its pullbacks as a nef +b-class. The generalized pair $(T,B+\overline\kappa)$ is gklt: +the nef datum descends on $T$, so its discrepancies are exactly +those of $(T,B)$. Its boundary-plus-nef class $[B]+\kappa$ is big. +The assertion $\mathsf B_d$, proved in +Proposition~\ref{repair:prop:restricted-bpf-induction}, gives $f$ and +$\gamma$. This assertion applies to gklt spaces without a strong +factoriality hypothesis, as explained in that induction by a +projective small factorialization followed by descent. +Lemma~\ref{repair:lem:polarization}, with detector $D$, makes $-D$ +relatively ample. The equality of the null cone with $R$ is exactly +the required contraction property. +\end{proof} + +Lemma~\ref{lem:absolute-support} constructs the supporting classes by the ordinary +cone theorem. The proposition above supplies the required contraction. It can be applied after every finite prefix of the +ordinary program. + +\begin{theorem}[Finite ordinary programs] +\label{repair:thm:reduction} +Let $(X,B)$ be a rational klt pair on a normal globally Weil +$\Q$-factorial compact K\"ahler fourfold. The canonical datum may +be a specified canonical Weil divisor or the intrinsic canonical +rational line bundle. Then every maximal ordinary negative-ray +program starts on $X$ and terminates. All models remain normal, +compact K\"ahler, globally Weil $\Q$-factorial and klt; global +strong $\Q$-factoriality is preserved when imposed initially. +Every negative contraction is projective, with relative +line-bundle rank and relative Bott--Chern dimension one. + +If $K_X+B$ is pseudo-effective, the endpoint has nef adjoint. The +composite extracts no divisor, discrepancies do not decrease, and +strictly increase for every prime on $X$ that is contracted. If +$K_X+B$ is not pseudo-effective, the endpoint has a projective +Mori fibre contraction to a normal compact K\"ahler space of +smaller dimension, with connected fibres and relatively +antiample adjoint. In particular, these conclusions imply Theorem~\ref{thm:finite}. +\end{theorem} +\begin{proof} +Start on the given pair. If its adjoint is not nef, choose a negative +extremal ray. Proposition~\ref{repair:prop:supporting-contraction} supplies its contraction; +Lemma~\ref{repair:lem:polarization} supplies the global relative polarization +from the ordinary rational adjoint. The remaining proof of Proposition~\ref{prop:ordinary-step} gives the rational flip when the contraction +is small, and preserves klt singularities, the global factoriality +category, canonical data and the negative-side numerical ranks. +These steps use the projective analytic ordinary flip theorem +\cite{Fujino2022} and actual line-bundle descent. In the globally Weil +case this is the argument of Proposition~\ref{prop:ordinary-step}: the rational +adjoint itself gives the global flip algebra, and the transform of +each global prime is made rationally Cartier by adjusting it by a +rational multiple of that adjoint and applying integral descent. +The same argument applied to global rank-one reflexive sheaves +preserves the strong category. Relative vanishing and cohomological +descent give the one-dimensional negative-side quotient. The +argument can be repeated after each finite prefix. + +Let $c_3(T)$ be the dimension of the span in $H_6(T,\R)$ of compact +analytic three-dimensional cycle classes. It is finite. A small +transformation preserves it, while a divisorial contraction strictly +decreases it: an exceptional divisor has nonzero class detected by +the cube of a K\"ahler form, and its image has dimension at most two. +The Borel--Moore localization argument is Lemma~\ref{lem:cycle-loss}. +There are therefore only finitely many divisorial steps in a run. +An infinite run would have an infinite flip tail, contrary to +Corollary~\ref{repair:cor:existing}, or its intrinsic formulation above. +Thus the run is finite. + +A maximal run ends with a nef adjoint or a Mori fibre contraction, +since each negative ray otherwise admits continuation. Across each +birational step the comparison on a common resolution has the form +\[ + p^*(K_T+B)=q^*(K_{T'}+B')+E,\qquad E\geq0 +\] +with $E$ exceptional over $T'$. Positive-current pullback and +exceptional descent preserve pseudo-effectivity. A relatively +antiample adjoint on a Mori fibre space is not pseudo-effective: +restrict a putative positive current to a fibre curve through a +point where a local potential is finite, and its nonnegative degree +contradicts relative antiampleness. A nef adjoint is pseudo-effective. +These observations distinguish the two endpoint cases exactly as +in Section~\ref{sec:endpoints}. Finally, the effective discrepancy +comparisons add along the finite run, with strict increase at each +contracted original divisor. They give the stated minimal-model +discrepancy inequalities. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/07-endpoints.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/07-endpoints.tex new file mode 100644 index 0000000000000000000000000000000000000000..656205ad811b7cc9af4061d3db5c3c208aba82ac --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/07-endpoints.tex @@ -0,0 +1,112 @@ +\section{The two endpoints}\label{sec:endpoints} + +The ordinary program is finite by Theorem~\ref{repair:thm:reduction}. +We now identify its endpoint from the pseudo-effectivity of the original +adjoint. Only ordinary birational comparisons are needed for this last step. + +\begin{lemma}\label{lem:pe-step} +Let $(T,B)\dashrightarrow(T',B')$ be an ordinary negative divisorial +contraction or flip between normal compact Kähler klt pairs, with rational +boundaries and rational line-bundle adjoints. Then $K_T+B$ is pseudo-effective if +and only if $K_{T'}+B'$ is pseudo-effective. +\end{lemma} + +\begin{proof} +Set $D=K_T+B$ and $D'=K_{T'}+B'$. The ordinary comparison in +Proposition~\ref{prop:ordinary-step} and Lemma~\ref{lem:negativity} gives, +on a common smooth compact Kähler resolution $p:V\to T$, $q:V\to T'$, +\[ + p^*D=q^*D'+F,\qquad F\geq0, +\] +where $F$ is an actual divisor exceptional over $T'$. +If $D'$ is pseudo-effective, its pullback plus $[F]$ is pseudo-effective; +descent along $p$ shows that $D$ is pseudo-effective. +Conversely, if $D$ is pseudo-effective, exceptional descent along $q$ +applied to $q^*D'+[F]$ proves that $D'$ is pseudo-effective. +Both uses of pullback and descent are justified by +Lemma~\ref{lem:positive-descent}. +\end{proof} + +\begin{lemma}\label{lem:mori-not-pe} +Let $g:Y\to S$ be a projective surjective morphism of normal compact Kähler +varieties with $\dim S<\dim Y$. If a rational line bundle $D$ satisfies +$-D$ $g$-ample, then $D$ is not pseudo-effective. +\end{lemma} + +\begin{proof} +Suppose that $c_1(D)$ contains a closed positive current $T$ with local +plurisubharmonic potentials. Choose a point $y$ where such a potential is +finite and which lies on a positive-dimensional component of a fibre of +$g$. This is possible on the dense open locus of fibres of the expected +dimension: the pole set of a plurisubharmonic potential contains no open +subset. That fibre component is projective, so hyperplane sections through +$y$ give an integral curve $C$ through $y$ contained in the fibre. +Let $\nu:C^\nu\to Y$ denote its normalization followed by inclusion. + +Local potentials pull back under $\nu$ to subharmonic functions or to the +constant $-\infty$. Finiteness at a preimage of $y$ excludes the latter +alternative on the connected curve. Thus they define a positive current +$\nu^*T$ in the class $\nu^*c_1(D)$, and +\[ + D\cdot C=\int_{C^\nu}\nu^*T\geq0. +\] +This contradicts $D\cdot C<0$, which follows from relative ampleness. +The choice of $y$ is essential: no restriction of $T$ to a curve contained +in its pole set has been used. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:finite}] +Choose a maximal ordinary negative-ray program on the given pair +$(X,\Delta)$. Proposition~\ref{prop:ordinary-step} supplies each step, +and Theorem~\ref{repair:thm:reduction} proves that the program stops +after finitely many such steps. Write its endpoint as $(Y,\Gamma)$. +All intermediate varieties are normal compact Kähler fourfolds, all +boundaries are the rational transforms of $\Delta$, and all pairs remain +ordinary klt and globally Weil-divisor $\Q$-factorial with the stipulated +canonical datum. The optional strong global property is preserved by the +same Proposition. The auxiliary constructions in +Section~\ref{sec:contractions} do not change this program, which starts +on $X$ itself. + +The stopping rule gives either a nef adjoint $K_Y+\Gamma$ or a Mori +contraction $g:Y\to S$. In the latter case +Proposition~\ref{prop:ordinary-step} supplies a normal compact Kähler base, +a projective surjective morphism with connected fibres, $\dim S<4$, +relative numerical rank $\rho(Y/S)=1$, and relative ampleness of +$-(K_Y+\Gamma)$. These are precisely the required Mori fibre space +conditions, with relative rank computed from global Cartier classes. +The same Proposition gives relative Bott--Chern dimension one for every +negative contraction, including $g$. + +By Lemma~\ref{lem:pe-step}, the adjoint at every stage has the same +pseudo-effectivity status as $K_X+\Delta$. If the latter is +pseudo-effective, Lemma~\ref{lem:mori-not-pe} excludes the Mori alternative, +so the endpoint is nef. If it is not pseudo-effective, the endpoint +cannot be nef, since nef classes are pseudo-effective by +Lemma~\ref{lem:positive-descent}; hence the endpoint has the asserted Mori +fibre structure. + +For completeness, the nef endpoint has the discrepancy properties of a +log minimal model. No step extracts a divisor. On a common resolution of +the finite sequence, with maps $p:V\to X$ and $q:V\to Y$, the ordinary +effective comparison divisors add to +\[ + p^*(K_X+\Delta)=q^*(K_Y+\Gamma)+F, + \qquad F\geq0, +\] +with $F$ exceptional over $Y$. Consequently, for every prime divisor $E$ +over these models, +\[ + a(E,Y,\Gamma)\geq a(E,X,\Delta). +\] +If a prime divisor on $X$ is contracted, its discrepancy increases strictly +at the divisorial step that contracts its transform and never decreases +thereafter. Thus the displayed inequality is strict for every such +prime. Here $a$ denotes the log discrepancy, as throughout the paper. + +If the initial adjoint is nef, the construction takes no steps; conversely, +a zero-step nef outcome requires the initial adjoint to be nef. In the +non-pseudo-effective case a zero-step program is also allowed when the +first selected contraction already gives a Mori fibre structure on $X$. +This completes both endpoint assertions. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/08-relative.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/08-relative.tex new file mode 100644 index 0000000000000000000000000000000000000000..71a2ed557aef85cae826ceccbd2c73f5071c9222 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/08-relative.tex @@ -0,0 +1,823 @@ +\section{Relative programs for rational nef line data}\label{sec:relative} + +Rational line bundles on projective modifications provide the relative +constructions used in the contraction induction and the companion +flip-termination theorem. We establish ordinary representatives over Stein +neighborhoods, elementary relative steps, a finite auxiliary program, +and extraction of prescribed divisors. All these constructions take +place over a fixed compact base. Their numerical spaces use degrees +of global line bundles, rather than the full Bott--Chern space of the +ordinary contractions above. + +The nef data in this section are rational line bundles, distinct from the +possibly transcendental nef classes used in the supporting-contraction proof. + +\subsection{Rational bundles and generalized pairs} + +\begin{convention}\label{conv:rational-bundles} +A rational line bundle is an element of $\Pic(T)\otimes_{\Z}\Q$. +An equality of rational line bundles means an isomorphism of holomorphic +line bundles after a positive common multiple. A rank-one reflexive +sheaf is rationally invertible if one of its positive reflexive powers +is invertible. We use additive notation for these objects, their +tensor products, and their reflexive transforms. In particular, $K_T$ +denotes the reflexive canonical sheaf, without a choice of a global +meromorphic canonical form. + +For a projective morphism $T\to V$, the words relatively nef and +relatively ample, applied to rational line bundles, refer respectively +to degrees on curves in the fibers and ampleness of a positive integral +power. Real combinations of rational line bundles have the corresponding +numerical meanings. Absolute nefness of a bundle on a compact K\"ahler +space implies relative nefness in this sense. +\end{convention} + +\begin{definition}\label{def:generalized-data} +Rational generalized b-line data on a normal compact space $T$ consist +of an effective rational divisor $B$, a projective modification +$p\colon W\to T$, and a rational line bundle $M_W$ on $W$. +The bundle is pulled back on every higher model; this b-object is denoted +by $\bM$. We require $M_W$ to be nef, or to be nef over a specified +base in a relative argument. Its trace on $T$ is obtained by taking a +proper direct image of a cleared power and then its double dual. The +adjoint +\[ + D_T=K_T+B+M_T +\] +is required to be rationally invertible. We may increase $W$ to a smooth +projective log resolution carrying the data. On such a model the +boundary $B_W$ is determined by the crepant formula +\begin{equation}\label{eq:generalized-crepant} + K_W+B_W+M_W=p^*D_T. +\end{equation} +The equality uses the natural meromorphic identifications over the +isomorphism locus. Log discrepancy is +$a(E;T,B+\bM)=1-\operatorname{coeff}_E B_W$, evaluated on a model +carrying $E$. Generalized klt and generalized lc, abbreviated gklt and +glc, mean that all these discrepancies are positive and nonnegative, +respectively. A generalized terminal pair is gklt and has +$a(E;T,B+\bM)>1$ for every exceptional prime divisor over $T$. + +A generalized dlt pair, abbreviated gdlt, is a glc pair for which there +is a Zariski open set $T^\circ\subset T$ such that +$(T^\circ,B|_{T^\circ})$ is simple normal crossing, the b-data descend +there, and $T^\circ$ contains the general point of every +zero-discrepancy center. We choose the carrier and subsequent log +resolutions to be isomorphisms on this open set. Thus the centers in +$T^\circ$ are strata of the coefficient-one boundary. +\end{definition} + +We also allow real combinations of a fixed finite set of rational data +for local cone arguments and real scaling. The extraction and termination +statements below use rational +data. + +\begin{lemma}[Traces and exceptional comparisons]\label{lem:trace} +Let $p\colon W\to T$ be a projective modification of normal compact +spaces. +\begin{enumerate}[label=\textup{(\roman*)}] +\item For a line bundle $L$ on $W$, $(p_*L)^{**}$ is coherent and +rank one. If its appropriate reflexive power is invertible, the natural +comparison between that power pulled back to $W$ and the corresponding +power of $L$ is an exceptional Cartier divisor. This assertion uses +actual bundles and is compatible with further pullback. +\item Rank-one reflexive sheaves can be transported coherently across +a bimeromorphic map by pullback, proper direct image, and double dual on +a common projective resolution. Their transforms agree on the common +codimension-one open set and are independent of the chosen resolution +when the map is small. +If $L=L'+G$ is an identity of rational bundles on the carrier with +$G$ a rational divisor, their reflexive traces satisfy +$L_T=L'_T+p_*G$. The trace of $K_W$, or of its pullback to a higher +model, is $K_T$. +\item If $T$ is globally strongly $\Q$-factorial and $\bM$ is nef +over a base over which $p$ is projective, then +\begin{equation}\label{eq:nef-trace-defect} + F_M:=p^*M_T-M_W\geq0 +\end{equation} +is exceptional. Consequently, forgetting the nef part of a gklt, +respectively gdlt, pair on $T$ gives an ordinary klt, respectively dlt, +pair. A gdlt pair becomes gklt after replacing $B$ by +$B-\epsilon\lfloor B\rfloor$, for every sufficiently small +$\epsilon>0$. +\end{enumerate} +\end{lemma} + +\begin{proof} +Proper direct image preserves coherence. On the isomorphism locus its +rank is one, and double dual gives a rank-one reflexive sheaf on the +normal target. Locally on $T$, choose meromorphic generators of this +coherent sheaf and of a cleared invertible power. Pulling back their +comparison gives a meromorphic comparison with the bundle upstairs. +One can see that the comparison is meromorphic, rather than merely +defined on a punctured open set, by using a local finite presentation +of $p_*L$: its generators evaluate to holomorphic sections of $L$, and +their ratios supply local denominators. The comparisons agree on +overlaps because they agree on the isomorphism locus. Their divisor +is exceptional. This also proves compatibility with powers and +pullback. A global meromorphic frame was not used. + +For a common resolution $W$ with maps to the two spaces, first pull +back the sheaf, remove torsion, and take its double dual; after an +additional projective principalization it is a line bundle. Proper +direct image to the other space followed by double dual is coherent. +On a common codimension-one open set it is the required transform. +Normality gives uniqueness of a reflexive extension across codimension +at least two, proving the assertion for small maps. +The additive trace identity is checked at every codimension-one point +of $T$, where the modification is an isomorphism, and then extended +reflexively. The same observation applies to canonical sheaves and +their pullbacks. It requires compatible local canonical forms only. + +Global strong $\Q$-factoriality makes $M_T$ rationally invertible, so +the first assertion defines $F_M$. Its negative is $p$-nef and has +zero pushforward. Lemma~\ref{lem:negativity} gives $F_M\geq0$. The ordinary crepant boundary is $B_W-F_M$: +\eqref{eq:generalized-crepant} gives explicitly +\[ + p^*(K_T+B)-K_W=B_W+M_W-p^*M_T=B_W-F_M. +\] +Thus ordinary log discrepancies are at least the generalized ones. +Every ordinary zero center is a generalized zero center and is +therefore generically in the specified simple normal crossing open +set. This proves the klt and dlt assertions. + +The effective divisor $\lfloor B\rfloor$ is rational Cartier on $T$. +Decreasing it subtracts the effective divisor +$\epsilon p^*\lfloor B\rfloor$ from the crepant boundary. A former +positive discrepancy stays positive. Every former zero-discrepancy +place has center in the floor, since its center is generically a +coefficient-one stratum, and hence has strictly positive order on the +pullback of the floor. Its new discrepancy is positive as well. The +boundary on $T$ remains effective for $0<\epsilon<1$. +\end{proof} + +\subsection{Ordinary representatives over Stein neighborhoods} + +We use the following local analytic inputs with their stated domains. +A Stein compact has property \textup{(P)} if its intersections with +analytic sets defined near the compact have finitely many connected +components. +For a projective morphism over a Stein compact satisfying property +\textup{(P)}, the ordinary klt cone theorem has finitely many rays in +each region truncated by a relatively ample divisor +\cite[Theorem~7.2]{Fujino2022}. The base point free theorem generates +every sufficiently large integral power of a nef line bundle $L$ when +$aL-(K+\Delta)$ is relatively ample +\cite[Theorems~6.2 and~6.5]{Fujino2022}. Ordinary klt flips exist for +small projective morphisms of normal analytic spaces without a +$\Q$-factoriality assumption \cite[Theorem~1.14]{Fujino2022}. Finally, on +a smooth source the multigraded adjoint ring with simultaneous SNC +subunit rational boundaries and a common relatively ample rational +part is locally finitely generated +\cite[Theorem~3.1]{DHP2024}. We explain the passages from these local +statements to our data and compact base. + +\begin{lemma}[Local ordinary representatives]\label{lem:ordinary-representative} +Let $\pi\colon T\to V$ be projective and bimeromorphic, let +$(T,B+\bM)$ be gklt rational data, and suppose the carrier is +projective over $T$ and $M_W$ is nef over $V$. Let $H$ be a +$\pi$-ample rational line bundle. Near any sufficiently small Stein +compact in $V$ there are an effective ordinary klt boundary $\Delta$, +an effective rational divisor $H_0\simq H$, and $\eta>0$ such that +\begin{equation}\label{eq:ordinary-replacement} + K_T+\Delta\simq D_T,\qquad \Delta\geq\eta H_0. +\end{equation} +These are actual rational line-bundle equivalences on that +neighborhood. For $0\leq\delta\leq\eta/2$, +$\Delta-\delta H_0$ is effective klt and represents $D_T-\delta H$. +For finitely many rational adjoints of this type on a common initial +space, the representatives can have a common positive ample part. +Their convex combinations have the same properties. The local cone +conclusions also hold for gklt real combinations of finitely many +rational data. +\end{lemma} + +\begin{proof} +Write $p\colon W\to T$ for a smooth carrier, with $p$ projective, and put +$\rho=\pi p$. Work on a Stein neighborhood $U$ of the prescribed +compact. Choose a $\rho$-ample rational line bundle $A$. For an +integer $m$ clearing denominators, the sheaf +\[ + \rho_*\cO_W\bigl(m(M_W-A)\bigr) +\] +is coherent and has rank one over the bimeromorphic isomorphism locus. +It is nonzero. Cartan's Theorem~A gives a nonzero section over $U$, +whose pullback defines an effective divisor. Hence, after division +by $m$, +\begin{equation}\label{eq:relative-kodaira-section} + M_W\simq A+E,\qquad E\geq0. +\end{equation} +This proves relative bigness directly, including when $M_W=0$. +The divisor $E$ need not be exceptional. The equivalence comes from +a section of the specified bundle, and introduces no unspecified +numerical or base twist. + +Keep $W$ and the $\rho$-ample bundle $A$ fixed. Choose an auxiliary +log resolution of the finite fixed supports only to test the +singularities. On that auxiliary resolution there are finitely many +crepant coefficients over the compact preimage, all strictly below +one. Hence a sufficiently small rational $\epsilon>0$ makes +$(W,B_W+\epsilon E)$ sub-klt. +The rational bundle +\[ + A_\epsilon=(1-\epsilon)M_W+\epsilon A +\] +is $\rho$-ample. Choose a rational $\eta>0$ such that +$A_\epsilon-\eta p^*H$ is still $\rho$-ample. On a smaller +neighborhood, sufficiently large powers of these relatively ample +bundles are relatively generated. Cartan's Theorem~A supplies finitely +many sections generating over the compact preimage; shrink once more +so that they generate throughout. Divided general members give +\[ + H_0\geq0,\quad H_0\simq H, + \qquad G\geq0,\quad + G\simq A_\epsilon-\eta p^*H. +\] +Choose the members on $T$ and $W$, respectively, with large +denominators, and test generality on the auxiliary log resolution. +Their pulled-back systems remain free; we do not claim that a pulled-back +ample bundle stays ample. Analytic +Bertini gives +\[ + C_W=B_W+\epsilon E+G+\eta p^*H_0 +\] +sub-klt. Here generation is used for the ample systems only; the +nonzero section producing $E$ was not claimed to generate its bundle. +The analytic generation and Bertini statements used in this step are +\cite[Theorems~2.12 and~2.20]{DHP2024}. + +Push down to obtain +\[ + \Delta=B+\epsilon p_*E+p_*G+\eta H_0\geq\eta H_0. +\] +Only exceptional coefficients of $B_W$ could be negative, so +$\Delta$ is effective. The actual upstairs identity is +$K_W+C_W\simq p^*D_T$. Choose an integer clearing this identity, +push forward the resulting line-bundle isomorphism, and take double +duals. Agreement in codimension one gives +\begin{equation}\label{eq:replacement-cartier} + \cO_T\bigl(m(K_T+\Delta)\bigr)\simeq\cO_T(mD_T). +\end{equation} +In particular, the new ordinary adjoint is rational Cartier. We have +not inferred Cartierness of newly chosen local divisors from global +strong $\Q$-factoriality. The divisor +\[ + K_W+C_W-p^*(K_T+\Delta) +\] +is exceptional and $p$-numerically trivial by the same line-bundle +identity. Lemma~\ref{lem:negativity} in both signs makes it zero. +Thus $C_W$ is the ordinary crepant boundary, and $(T,\Delta)$ is klt. +Subtracting $\delta H_0$ gives the asserted representation of +$D_T-\delta H$ and leaves the common ample part $(\eta/2)H_0$. + +For finitely many vertices, use one carrier and one $H_0$, choose their +effective divisors in \eqref{eq:relative-kodaira-section}, and resolve +all fixed supports together. Take a common sufficiently small +$\epsilon$ and then a common $\eta$. Choose the finitely many free +members generally. On the resulting common resolution all the +crepant coefficients are uniformly below one. Convex combinations +are therefore klt and keep the same ample part. The parameter space +can be the simplex of vertex weights; no affine independence of the +original vertices is required. + +For real data, first express the bundle in a finite real span of +rational bundles on the carrier. Every signed rational generator has +an effective representative over the Stein neighborhood by the same +Cartan argument. Thus a real nef bundle also has an expression +$M_W\sim_{\R}A+E$ with $A$ relatively ample and $E\geq0$ in a fixed +finite divisor span. The preceding small-$\epsilon$ construction +applies. A real relatively ample bundle can be written as a positive +combination of finitely many nearby rational relatively ample bundles; +divided general members of those bundles give the required real +boundary. The ordinary real klt cone theorem is consequently +applicable. Only the rational construction is used for line-bundle +descent and for the finite adjoint rings. +\end{proof} + +Lemma~\ref{lem:ordinary-representative} also supplies the hypothesis +needed to apply integral descent to a relatively antiample generalized +klt adjoint. Indeed its ordinary representative is klt and has the +same relative line-bundle class. If an integral line bundle $L$ has +zero degree on every contracted curve, then +$aL-(K_T+\Delta)$ is relatively ample. Lemma~\ref{lem:descent} +therefore gives the actual identity $L=f^*f_*L$; the consecutive-power +argument in its proof introduces no extra integral multiple. Clearing +one denominator gives the corresponding assertion for rational line +bundles. The representatives may differ on the Stein neighborhoods: +the descended bundle and its evaluation map are intrinsic and glue. + +\subsection{Global relative degrees and elementary steps} + +For a projective morphism $\pi\colon T\to V$ of compact spaces, let +$N^1_{\mathrm{gl}}(T/V)_{\Q}$ be the space of global rational line +bundles modulo equality of degrees on all curves contracted by $\pi$. +Put $N^1_{\mathrm{gl}}(T/V)=N^1_{\mathrm{gl}}(T/V)_{\Q}\otimes\R$, +and let $N_{1,\mathrm{gl}}(T/V)$ be the dual space generated by relative +curve functionals. These spaces are finite-dimensional: pull back to +a compact resolution and use the first Chern class in its finite +dimensional cohomology. Write +\[ + \overline{\mathrm{NE}}_{\mathrm{gl}}(T/V) + \subset N_{1,\mathrm{gl}}(T/V) +\] +for the closed cone generated by these functionals. A relatively ample +global line bundle gives a compact normalized slice of this cone. + +Here are details about the compactness and the local cone statements +which will be used. Choose a finite cover of $V$ by interiors of +Stein compacts $W_\nu$ in Stein open sets $U_\nu$. We choose them +semianalytic in coordinate charts, so they satisfy property +\textup{(P)}. On each chart the ordinary +relative numerical cone has a compact slice normalized by the +restriction of a fixed global relatively ample bundle $H$. Restricting +global bundles defines a linear projection from the local curve space +to $N_{1,\mathrm{gl}}(T/V)$. The image of that slice is compact and +still lies in $H=1$. The convex hull of these finitely many compact +images is compact and is precisely the global normalized slice. +Indeed every relative curve lies over one of the compacts, and passage +to closure commutes with this finite compact convex hull. + +Apply Lemma~\ref{lem:ordinary-representative} on the charts to a gklt +adjoint $J$. The local cone theorem and projection show that, for each +$c>0$, only finitely many generating curve rays are needed in the +global region $(J+cH)<0$. The remaining summand is in +$(J+cH)\geq0$. If $J$ is nef, apply the same argument to the +ordinary representative of $J-\delta H$, with a further ample +perturbation $(\delta/2)H$. In the slice $H=1$ this gives a finite +set of curve rays near $J=0$ and a remainder on which +$J\geq\delta/2$. In particular the face $J=0$ is generated by +finitely many curves. It also gives the following useful openness +statement: if a linear perturbation is positive on that zero face, +it is positive on the whole slice for all sufficiently small positive +parameters. This follows by checking the finite rays and using the +uniform $\delta/2$ margin on the remainder. + +For a rational gklt adjoint, every negative global extremal ray has a +rational supporting line bundle. To see this, use the finite +decomposition in a truncated negative neighborhood of that ray. +The normalized point of an extremal ray is outside the compact convex +hull of the other generators and the remaining nonnegative part. +Separation gives a nef functional vanishing only on that ray, with a +strict margin on the other part. These functionals contain an open +subset of its perpendicular hyperplane. The ray is generated by a +curve, so the hyperplane is rational; choose a rational functional +there. It is a rational line-bundle class by the definition of +$N^1_{\mathrm{gl}}$. Subtracting a sufficiently small positive +multiple of the adjoint is strictly positive on the normalized slice. +After rescaling the support, its difference from the adjoint is +relatively ample. Strict positivity here implies ampleness on each +projective fiber by Kleiman's criterion, and relative ampleness follows +over a neighborhood of each fiber. This reasoning involves line +bundle degrees on projective fibers only. + +\begin{lemma}[Sheaves and signs across a step]\label{lem:sheaf-step} +Let $T$ be globally strongly $\Q$-factorial. Suppose a projective +bimeromorphic contraction $f\colon T\to Z$ has all its contracted +curves in one nonzero ray for global rational line-bundle degrees. +Let $J$ be a rational line bundle with $-J$ $f$-ample, admitting the +local klt representatives required in Lemma~\ref{lem:descent}. +\begin{enumerate}[label=\textup{(\roman*)}] +\item If $f$ is divisorial, its exceptional locus is a single prime +$E$, with $E\cdot R<0$, and $Z$ is globally strongly $\Q$-factorial. +Every adjoint pushed down to $Z$ is rational Cartier. +\item If $f$ is small and its $J$-positive small projective model +$f^+\colon T^+\to Z$ exists, then $T^+$ is globally strongly +$\Q$-factorial. Every global rational line bundle $L$ on $T$ has a +rationally invertible transform $L^+$, and +\begin{equation}\label{eq:step-line-adjustment} + L=f^*A+cJ\quad\Longrightarrow\quad + L^+=(f^+)^*A+cJ^+ +\end{equation} +for an actual rational line bundle $A$ on $Z$, where +$c=(L\cdot R)/(J\cdot R)\in\Q$. In particular, a negative, zero, +or positive degree for $L$ becomes respectively relative ampleness, +relative triviality, or relative antiampleness for $L^+$. +\end{enumerate} +\end{lemma} + +\begin{proof} +For an exceptional prime $E$, global strong $\Q$-factoriality makes $E$ +rational Cartier. If it were $f$-nef, +Lemma~\ref{lem:negativity}\textup{(i)} applied to $-E$ would give +$-E\geq0$. Thus $E\cdot R<0$. Every contracted curve +must lie in $E$, since an effective rational Cartier divisor has +nonnegative intersection with a curve not contained in its support. +Every point of a nontrivial projective fiber lies on a curve in that +fiber. Hence the entire exceptional locus is $E$, and no second +exceptional prime exists. + +For a global rank-one reflexive sheaf $\cF$ on $Z$, form its reflexive +pullback to $T$. A positive power is a line bundle. Subtract a +rational multiple of $E$ so that its degree is zero on $R$ and apply +Lemma~\ref{lem:descent}. The descended rational bundle agrees with +$\cF$ to that power on the complement of a codimension-two set in +$Z$. Reflexivity extends the identity. This proves the global strong +condition and, in particular, applies to the pushed-forward canonical, +boundary, and nef-trace sheaves. + +In the small case, $L-cJ$ has zero degree and descends by +Lemma~\ref{lem:descent}. The right-hand side of +\eqref{eq:step-line-adjustment} is a rational line bundle on $T^+$ +and agrees with the transform of $L$ on the common open set. It is +therefore the reflexive transform. The sign conclusions follow from +relative ampleness of $J^+$ and the sign of $c$. + +Conversely, transport an arbitrary global rank-one reflexive sheaf +$\cG$ on $T^+$ to $T$ as in Lemma~\ref{lem:trace}. A reflexive power +of its transform is invertible on $T$. The preceding argument makes +its transform a rational line bundle on $T^+$. It agrees with the +corresponding reflexive power of $\cG$ on the common codimension-one +open set, and hence everywhere. This is global strong $\Q$-factoriality +on $T^+$; no assertion about arbitrary open subsets is involved. +\end{proof} + +\begin{definition}\label{def:relative-elementary} +An elementary relative step is a +projective divisorial contraction +or a small projective negative-to-positive adjoint surgery over a +normal compact K\"ahler base, with globally strongly $\Q$-factorial +source and output. All contracted curves on the negative side span +one nonzero ray when paired with global rational line bundles. The +boundary is pushed forward or strictly transformed, and the same +b-data are used on common higher models. The small positive model is +the relative Proj of the actual adjoint algebra. No condition on its +relative Bott--Chern dimension is included. +\end{definition} + +\begin{proposition}[Relative continuation]\label{prop:relative-steps} +Let $\pi\colon T\to V$ be a projective bimeromorphic morphism of +normal compact K\"ahler spaces. Assume $T$ is globally strongly +$\Q$-factorial and $(T,B+\bM)$ is rational gdlt, with projective +carrier and nef data over $V$. If its adjoint is not curve-nef over +$V$, there is an elementary negative step over $V$. Its target is +projective over $V$, compact K\"ahler, globally strongly +$\Q$-factorial, and gdlt with the transformed data. The construction +is available after every finite prefix whose final adjoint is not +curve-nef over $V$. For gklt data one may choose +any negative extremal ray in the global degree cone. +\end{proposition} + +\begin{proof} +First assume gklt. The global cone construction above gives a negative +ray and a nef rational supporting line bundle $L$ which vanishes +precisely on that ray and for which a multiple minus the adjoint is +relatively ample. Apply the ordinary base point free theorem on the +finite Stein cover, using Lemma~\ref{lem:ordinary-representative}. +It generates a common positive power of $L$ relative to $V$. +The relative section morphism and its Stein factorization give +$f\colon T\to Z$ with connected fibers and normal target, contracting +exactly the curves on the selected ray. The target is projective over +$V$: it is finite over the image in the projectivization of the +coherent sheaf of relative sections. Since $T\to V$ is bimeromorphic, +$Z$ has the same dimension and $f$ is bimeromorphic. The negative +adjoint is relatively ample, because on every $f$-fiber its class is +a positive multiple of a relatively ample class in the one-dimensional +global degree space. + +If $f$ is divisorial, apply Lemma~\ref{lem:sheaf-step}. If it is +small, apply Lemma~\ref{lem:ordinary-representative} locally over +$Z$, followed by the ordinary analytic klt flip theorem +\cite[Theorem~1.14]{Fujino2022}. Equivalently, the actual relative +adjoint algebra is locally finitely generated by +\cite[Corollary~3.7]{DHP2024}; the flip theorem also supplies its +normality and smallness. The local models glue by the intrinsic +algebra. Compactness permits a common Veronese generated in degree +one. On the common codimension-one open set its tautological bundle +is the stated adjoint power. Both sheaves are reflexive on the normal +positive side, so this identity extends globally. Thus the positive +adjoint is rational Cartier and relatively ample as an actual bundle. +Lemma~\ref{lem:sheaf-step} gives global strong $\Q$-factoriality. + +All spaces constructed are projective over a compact K\"ahler space. +A relatively ample line bundle has a metric with positive curvature +in the fiber directions; adding a sufficiently large pullback of a +K\"ahler form on the base gives a K\"ahler form. Thus the spaces are +compact K\"ahler. The common carrier remains projective over the +models: take the main component of the graph over $Z$ and resolve it. +The pulled-back nef data are still nef over $V$. + +For gdlt data, replace $B$ by +$B-\epsilon\lfloor B\rfloor$ with small rational $\epsilon>0$. +By Lemma~\ref{lem:trace} this is gklt; denote its adjoint by $D_\epsilon$. +Normalize by a relatively ample bundle $H$, and choose a relative +curve class $z$ with $H\cdot z=1$ and $D\cdot z=-a<0$. +Choose $\epsilon$ so that +$|(D_\epsilon-D)\cdot u|0$ put +$A=\tau(a^*H-F)$. The finitely many exceptional coefficients of the +$\Gamma_j$ have positive margins from both zero and one. Then +$\Gamma_j-A$ is effective with coefficients below one; their +supports, including that of $F$, are SNC. One can either use this +relatively ample rational divisor $A$ directly or replace it by a +divided general member and make the corresponding simultaneous +linear-equivalence changes in the boundaries. + +The multigraded ring of the $K_S+\Gamma_j$ is locally finitely +generated by \cite[Theorem~3.1]{DHP2024}. For nonnegative integers +$n_j$, the correction $\sum n_jE_j$ is effective and exceptional +over $T$. Normality gives +$a_*\cO_S(\sum n_jE_j)=\cO_T$. The projection formula therefore +identifies every multigraded piece with the corresponding piece for +the $D_j$, compatibly with multiplication. Passing to one common +Veronese removes all rounding. Thus their actual multigraded ring +is locally finitely generated as well. + +For completeness, finite generation gives the required finiteness as +follows. On a sufficiently small neighborhood choose homogeneous +generators with multidegrees $d_1,\ldots,d_N\in\N^{s+1}$. For a +rational weight $w$ in the simplex, a point of the relative spectrum +is semistable for the diagonal ring of weight $w$ precisely when +$w$ is in the cone generated by those $d_i$ whose generators are +nonzero at the point. To verify this equivalence, clear the rational +coefficients of such a cone expression and form the corresponding +monomial; conversely a nonvanishing homogeneous section contains a +nonvanishing monomial of that weight. There are only finitely many +subsets of the generators and hence finitely many resulting open +sets. The diagonal Proj is the quotient of its open set, obtained by +the degree-zero localizations of these monomials. Uniqueness of this +quotient shows that weights with the same open set give the same +ample model. All identifications commute with the map from $T$, +which is determined on the bimeromorphic isomorphism locus. A finite +cover of the Stein compact makes the number of possibilities finite +there. This is also the marked finite-model conclusion of +\cite[Theorem~E]{Fujino2022}, now with the ordinary representatives +and the smooth reduction justified. +\end{proof} + +\begin{proposition}[A finite relative gklt run]\label{prop:relative-finite} +In the setting of Proposition~\ref{prop:relative-steps}, assume the +pair is gklt. There is a finite sequence of elementary steps over +$V$ whose final adjoint is curve-nef over $V$. +\end{proposition} + +\begin{proof} +Let $D=K_T+B+M_T$. We may suppose $D$ is not already relatively +nef. + +\smallskip +\noindent\emph{A scaling class valid on every later model.} +Choose global rational line bundles $L_1,\ldots,L_r$ whose +degrees form a basis of $N^1_{\mathrm{gl}}(T/V)_{\Q}$, and write +the class of $D$ as $d\in\Q^r$. + +These bundles continue to span the degree space after every finite +sequence of elementary steps. Indeed every line bundle on a later +model can be transported to a rational line bundle on the preceding +one by Lemma~\ref{lem:trace} and global strong $\Q$-factoriality. +For a divisorial contraction its pullback is also such a bundle; +exceptional-divisor adjustments are available on the source. +Moreover a bundle numerically trivial over $V$ remains so after a +step. It first descends across that contraction by +Lemma~\ref{lem:descent}. Any curve on the new side over $V$ has a +projective lift to a common model and then a curve upstairs mapping +onto it with positive degree. Intersecting the pullbacks of the +descended bundle proves its zero degree. Thus every later relative +curve determines a rational functional $v\in\Q^r$, nonzero because +the later space has a relatively ample line bundle. + +Choose a real vector $h\in\R^r$ defining a real linear combination +$H$ of the chosen rational line bundles, with $H$ and $D+H$ +relatively ample. We choose it outside +the following countable family of proper rational hyperplanes: +\begin{align} + v(h)&=0 &&(0\ne v\in\Q^r),\label{eq:scaling-generic1}\\ + v(d)w(h)-w(d)v(h)&=0 + &&\left(\begin{array}{l}v,w\in\Q^r\text{ independent},\\ + (v(d),w(d))\ne(0,0)\end{array}\right). + \label{eq:scaling-generic2} +\end{align} +The ample conditions define a nonempty open set, and a countable +union of proper hyperplanes cannot exhaust it. The rational +functionals here range over all possibilities, so this single choice +works at every later model; no enumeration of the models is required. + +\smallskip +\noindent\emph{The scaling steps and their strictly decreasing thresholds.} +On a current model, let $D_i$ be the reflexive transform of $D$, +and let $H_i$ be the same real linear combination of the reflexive +transforms of the rational line bundles defining $H$; across a +divisorial step these transforms are the corresponding pushforwards. +Regard $H$ +also as nef b-data over $V$, carried on the initial space. Its +pullback to a common carrier is relatively nef, so for every +$t\geq0$ the initial generalized pair with adjoint $D+tH$ is gklt. +At each preceding step of threshold $t_j$, its adjoint has negative +degree for $0\leq t0$ so that $L=\cO_Z(r(K_Z+\Gamma))$ is a line bundle. Give $L$ +a singular Hermitian metric of nonnegative curvature. Its local weights +are plurisubharmonic. In product coordinates for the submersion over +$T^\circ$, their local integrability and Fubini's theorem show that the +weights restrict to plurisubharmonic functions, rather than identically +$-\infty$, on almost every fiber. A countable cover gives this assertion +simultaneously for the local weights; their transition identities are +preserved under restriction. Thus $L|_{F_t}$ is analytically +pseudo-effective for almost every $t\in T^\circ$. + +\smallskip\noindent +\emph{Projective nonvanishing on the fibers.} +For almost every such parameter the fiber is also projective: the +exceptions to the very-general projectivity assumption have measure +zero. On a smooth projective manifold the analytic pseudo-effective +cone restricted to divisor classes is the closure of the effective +divisor cone, by \cite[Proposition~1.2]{BDPP2013}. Hence the projective +klt pair $(F_t,\Gamma|_{F_t})$ has pseudo-effective adjoint. The +projective log MMP in dimensions at most three produces a nef model. +For example, in dimension three the ordinary cone and flip theorems, +together with \cite[Theorem~1.2]{CT2023} with zero nef part, give +termination; pseudo-effectivity excludes a Mori fiber space. The +projective log abundance theorem +\cite[Theorem~1.1]{KMMAbundance1994}, together with +\cite[\S6.1]{MatsukiCorrection2003}, gives a nonzero section of a +multiple of the nef adjoint. Dimensions one and two use the classical +log abundance theorem. The effective pullback comparison on a common +resolution pulls this section back to a section of a multiple of the +original adjoint. It descends to $F_t$ by the projection formula for the +modification. Consequently +\begin{equation}\label{eq:supply-ae-nonvanishing} + H^0(F_t,L^{\otimes m_t}|_{F_t})\ne0 + \quad\text{for some }m_t>0 +\end{equation} +for almost every $t\in T^\circ$. If the fiber is a point this assertion +holds directly. + +\smallskip\noindent +\emph{A common positive degree.} +To obtain the required quantifier, put +\[ + A_m=\bigl\{t\in T^\circ: + h^0(F_t,L^{\otimes m}|_{F_t})\geq1\bigr\}, + \qquad m=1,2,\ldots . +\] +These are closed analytic jumping loci: the restricted family is proper +and smooth, and $L^{\otimes m}$ is locally free and flat over its base, +so proper holomorphic cohomology and base change apply +\cite[\S8, Theorem~3, p.~62]{Douady1974}. By +\eqref{eq:supply-ae-nonvanishing}, their countable union contains almost +every point of $T^\circ$. If every $A_m$ were proper, that union would +have measure zero. Therefore some $A_m$ equals $T^\circ$, since this +base is connected. This proves both assertions. In particular, +almost-everywhere restriction of a metric has not been identified with +the very-general assertion by definition. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/09-threefold.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/09-threefold.tex new file mode 100644 index 0000000000000000000000000000000000000000..fc06cfc980df0ccedc5942e7048ec0e0efa22d3c --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/09-threefold.tex @@ -0,0 +1,600 @@ +\section{Arbitrary termination in dimension three}\label{sec:threefold} + +We establish the lower-dimensional termination needed for special +termination. Throughout this section we use the rational generalized +pairs and elementary steps of Section~\ref{sec:relative}. +The spaces are compact K\"ahler and globally +strongly $\Q$-factorial, and the elementary steps have the negative-side +one-ray condition for degrees of global rational line bundles. All higher +nef data are fixed as a rational b-line bundle. The projective bases of the +steps may change. No pseudo-effectivity assumption is made in this section. +We first treat generalized terminal pairs. We then bound Cartier indices +under uniform discrepancy bounds and use that bound to lift a general +sequence to generalized terminal models. This follows the threefold +strategy of \cite[Section~3]{CT2023}; the surface, index, and lifting +arguments below establish its analytic form with varying bases. + +\subsection{Generalized terminal pairs} + +\begin{proposition}\label{prop:terminal-three} +Let $(X_0,B_0+\bM)$ be a rational generalized terminal pair on a normal +globally strongly $\Q$-factorial compact K\"ahler threefold, with fixed +rational b-line data as in Definition~\ref{def:generalized-data}. +Every sequence of small elementary steps in the sense of +Section~\ref{sec:relative} starting from +this pair terminates. The contraction bases may vary. Here generalized +terminal means generalized klt with all exceptional log discrepancies +greater than one. +\end{proposition} + +\begin{proof} +Write the sequence as +\[ + (X_i,B_i+\bM)\dashrightarrow (X_{i+1},B_{i+1}+\bM), + \qquad X_i\xrightarrow{f_i}Z_i\xleftarrow{f_i^+}X_{i+1}. +\] +The boundary is transformed strictly, so its coefficients belong to one +finite set. Smallness and Lemma~\ref{lem:negativity} preserve generalized +terminality. Forgetting the effective boundary and the effective nef defect +increases discrepancies, so each $X_i$ is an ordinary terminal threefold. +In particular its singularities are isolated, and the general point of every +flipped curve is smooth. + +Choose an integer $p>0$ for which $p\bM$ is represented by an integral line +bundle on a carrier, and an integer $N$ divisible by $p$ and by the +denominators of the boundary coefficients. These integers continue to work +on higher carriers throughout any finite part of the sequence. If $C$ is +a flipped curve on $X_{i+1}$, the exceptional valuation $E_C$ of its generic +blowup has log discrepancy +\begin{equation}\label{eq:curve-discrepancy-three} + a(E_C;X_{i+1},B_{i+1}+\bM) + =2-\sum_j m_jb_j-\frac{q}{p}, + \qquad m_j,q\in\Z_{\geq0}. +\end{equation} +Indeed, the ordinary blowup contribution is two, the $m_j$ are the generic +multiplicities of the boundary components, and the remaining term is the +coefficient of the nef defect. At this smooth generic point the integral +trace of $p\bM$ is Cartier. The defect therefore has coefficients in +$p^{-1}\Z$ and is effective by Lemma~\ref{lem:trace}. This proves +\eqref{eq:curve-discrepancy-three}, including its signs. + +Let $b$ be the largest boundary coefficient, with $b=0$ when the boundary +is empty. For $b>0$ test the flipped curves contained in a coefficient-$b$ +component; for $b=0$ test every flipped curve. The value in +\eqref{eq:curve-discrepancy-three} belongs to the fixed finite set +\[ + \mathcal A_b=N^{-1}\Z\cap(0,2-b]. +\] +For each $t\in\mathcal A_b$, set +\[ + d_t(i)=\#\{E\text{ exceptional over }X_i: + a(E;X_i,B_i+\bM)0$. On a tail, no flipped curve is contained in any of the +coefficient-$b$ components. Fix such a component $D_i$, and let +$D_i^\nu$ denote its normalization. The two images of $D_i$ and +$D_{i+1}$ in $Z_i$ agree, because the ambient transformation is an +isomorphism in codimension one. Denote the normalization of this common +image by $V_i$. There are projective birational morphisms +\[ + D_i^\nu\longrightarrow V_i\longleftarrow D_{i+1}^\nu. +\] +The morphism on the right contracts no curve and is therefore finite: +every positive-dimensional projective fiber contains a curve. A finite +birational morphism to a normal space is an isomorphism. Hence there is a +projective birational morphism $D_i^\nu\to D_{i+1}^\nu$. It contracts +exactly the curves whose images in $X_i$ are flipping curves contained in +$D_i$. By Lemma~\ref{lem:cycle-loss}, with $k=1$, each such contraction +strictly decreases the dimension of the span of curve classes of the compact +normalized surface. There are finitely many coefficient-$b$ components, +so only finitely many further steps have a flipping curve contained in one +of them. + +On the resulting tail put $D_i^{\max}=\sum_{b_j=b}D_{i,j}$ and replace +$B_i$ by $B_i-bD_i^{\max}$. Every contracted curve $C$ has +$D_i^{\max}\cdot C\geq0$, because it is not contained in this effective +$\Q$-Cartier divisor. Thus the new adjoint +\[ + A_i'=K_{X_i}+B_i-bD_i^{\max}+M_{X_i} +\] +is negative on the old ray. To check its positive transform, write +$A_i=K_{X_i}+B_i+M_{X_i}$ and choose the rational number +$c=(A_i'\cdot C)/(A_i\cdot C)>0$. The global one-ray condition and +Lemma~\ref{lem:descent} give an actual identity of rational line bundles +\[ + A_i'=cA_i+f_i^*L_i,\qquad L_i\in\Pic(Z_i)\otimes\Q. +\] +Its strict transform is +$A_{i+1}'=cA_{i+1}+(f_i^+)^*L_i$, which is $f_i^+$-ample. +Consequently the same tail is a sequence of elementary steps for the new +generalized pair. Decreasing the effective boundary preserves generalized +terminality. Induction on the number of distinct positive boundary +coefficients proves the proposition. +\end{proof} + +\subsection{Uniform indices for the terminal lift} + +To lift a generalized klt sequence to generalized terminal models, we +will need the discrepancies of the finitely many exceptional places with +log discrepancy at most one to stabilize. A uniform Cartier index will +put those discrepancies in a fixed rational grid. We first establish +the local index statement and the surface estimate used to obtain that +uniform bound. + +\begin{lemma}\label{lem:terminal-local-index} +Let $(T,x)$ be a complex analytic terminal threefold germ of canonical +Cartier index $r$. If $D$ is an integral Weil divisor germ that is +$\Q$-Cartier, then $rD$ is Cartier. If $r>1$, there is an exceptional +valuation centered at $x$ with ordinary log discrepancy $1+1/r$. +\end{lemma} + +\begin{proof} +For the first assertion, use the analytic index-one cover +$\pi:(T^\sharp,x^\sharp)\to(T,x)$, a cyclic cover of degree $r$ that is +\'etale away from the distinguished point. The terminal threefold +classification makes $T^\sharp$ smooth or an isolated cDV hypersurface +germ; see \cite{Mori1985}. A sufficiently small punctured representative +$U^\sharp$ is simply connected, by the connectivity theorem for links of +isolated hypersurfaces \cite[Theorems~2.10 and~5.2]{Milnor1968}. For a convergent +analytic defining equation, finite determinacy gives an analytically +equivalent sufficiently high Taylor polynomial +\cite[Theorem~6.2, p.~24]{DeJongEtAl1998}, so the same connectivity +statement applies; the smooth case has the same property. For every +$m>0$, the analytic Kummer sequence implies +that the $m$-torsion of $\Pic(U^\sharp)$ is an image of +$H^1(U^\sharp,\boldsymbol\mu_m)=0$. The local divisor class group +injects into this Picard group: a rank-one reflexive sheaf trivial on the +punctured normal germ is trivial on the germ by reflexive extension. +It follows that the local class group of $T^\sharp$ is torsion-free. + +Since $D$ is $\Q$-Cartier, the integral divisor $\pi^*D$ has torsion class +and is therefore principal, say $\pi^*D=\operatorname{div}(u)$ for a +meromorphic germ $u$. The meromorphic norm gives +\[ + \operatorname{div}\operatorname{Norm}_{\pi}(u) + =\pi_*\operatorname{div}(u) + =\pi_*\pi^*D=rD. +\] +Thus $rD$ is Cartier; compare the index divisibility statement in +\cite[Lemma~5.1]{Kawamata1988}. The argument above proves the analytic +assertion for divisor germs already known to be $\Q$-Cartier. + +The second assertion is the terminal small-discrepancy theorem +\cite[Appendix, pp.~193--195]{KawamataAppendix1992}. Its proof uses the +analytic quotient classification and gives ordinary discrepancy $1/r$, or +log discrepancy $1+1/r$ in our convention. +\end{proof} + +When the germ lies on a compact terminal space, the last valuation can be +seen on a global resolution. In fact, its ordinary crepant boundary has +only negative exceptional coefficients. A valuation still exceptional +over that smooth resolution has ordinary log discrepancy at least two. +Thus a local valuation of discrepancy $1+1/r<2$ is already represented by +an exceptional component of the restricted global resolution. Since its +center on $T$ is the isolated point $x$, that component gives a global +exceptional prime. This observation permits the use of +Lemma~\ref{lem:terminal-local-index} with global discrepancy bounds. + +\begin{lemma}\label{lem:exceptional-surface-curve} +Let $h:U\to T$ be a projective bimeromorphic morphism of normal compact +complex threefolds. Suppose that $U$ is klt and that $P$ is an exceptional +prime divisor with $K_U+P$ rational Cartier. Given finitely many effective +$\Q$-Cartier divisors $D_j$ on $U$, none having $P$ as a component, there +is a curve $C\subset P$ contracted by $h$, contained in none of the $D_j$, +such that +\[ + (K_U+P)\cdot C\geq-3. +\] +\end{lemma} + +\begin{proof} +Let $\nu:P^\nu\to P$ be the normalization and let +$\mu:S\to P^\nu$ be its minimal resolution. Divisorial adjunction gives +\begin{equation}\label{eq:arbitrary-prime-different} + \nu^*((K_U+P)|_P)=K_{P^\nu}+\Delta_{P^\nu}, + \qquad \Delta_{P^\nu}\geq0, +\end{equation} +as an identity of rational adjoint bundles. Neither normality of $P$ nor +log canonicity of $(U,P)$ is needed for effectivity of the different in this +formula. This is the ordinary different of a reduced prime, computed at +codimension-two points of $U$; the construction and effectivity are given in +\cite[Section~14.1(i)--(iii), pp.~40--41]{FujinoFundamental2010}, +and analytic adjunction is included in +\cite[Theorem~1.1 and the following setup, p.~1]{FujinoInversion2023}. +Here is the local analytic effectivity argument. On a transverse klt +surface $T$, take a small smooth quotient $q:V\to T$ and write +$P_T$ for the reduced boundary curve and $C=(q^{-1}P_T)_{\mathrm{red}}$. +The quotient is unramified at the general points of these curves, so +$q^*(K_T+P_T)=K_V+C$. Let $\rho:C^\nu\to P_T^\nu$ be the induced +map of normalizations. Residue adjunction for the reduced plane curve +$C$ has an effective conductor divisor $A$, and the canonical +ramification formula for $\rho$ has an effective divisor $R$. +Compatibility of residues with pullback gives +\[ + \rho^*\operatorname{Diff}_{P_T^\nu}(0)=A+R. +\] +At a branch of ramification degree $e$, its coefficient downstairs is +$(c+e-1)/e\geq0$, where $c$ is the conductor coefficient. This proves +the analytic effectivity in \eqref{eq:arbitrary-prime-different} +without an lc hypothesis on $(U,P)$ or normality of $P$. + +The sum on the right of \eqref{eq:arbitrary-prime-different} is rational +Cartier; its individual canonical term need not be. If that term is used +separately, take its numerical pullback in the sense of Mumford, determined +by intersection zero with all exceptional curves. The negative definite +exceptional intersection matrix makes this pullback linear and makes the +pullback of an effective divisor effective. In particular the calculation +does not presume $\Q$-factoriality of $P^\nu$. + +For completeness, the effective correction can also be checked directly +on $S$. For every irreducible $\mu$-exceptional curve $E$, adjunction on +the smooth surface gives +\[ + K_S\cdot E=2p_a(E)-2-E^2\geq0. +\] +Indeed, an exceptional smooth rational $(-1)$-curve is excluded by +minimality over $P^\nu$; every other exceptional curve satisfies the +displayed inequality. The pullback of the adjoint in +\eqref{eq:arbitrary-prime-different} therefore has the form +\begin{equation}\label{eq:surface-effective-correction} + (\nu\mu)^*((K_U+P)|_P)=K_S+\Delta_S, + \qquad \Delta_S\geq0. +\end{equation} +To obtain the sign, the residue comparison defines $\Delta_S$ as a rational +divisor with pushforward $\Delta_{P^\nu}\geq0$. Since $K_S$ is +$\mu$-nef, the divisor $-\Delta_S$ is $\mu$-nef. Apply +Lemma~\ref{lem:negativity}\textup{(i)} to $E=\Delta_S$ to obtain +$\Delta_S\geq0$. This is equivalently the +numerical-pullback calculation above, and proves +\eqref{eq:surface-effective-correction} as an actual bundle comparison. + +The image $h(P)$ has dimension zero or one. In the latter case, general +smooth fiber components of $S\to h(P)$ are moving curves $F$ with +$K_S\cdot F=2g(F)-2\geq-2$. One may use the Stein factorization to +describe these fibers over a smooth compact curve. Choose a general fiber +component not contained in $\Supp\Delta_S$, the conductor, or the +pullbacks of the $D_j$. + +If $h(P)$ is a point, $P$ is a projective fiber subspace, and $S$ is a +smooth projective surface. Take a surface minimal model $\rho:S\to S_0$. +If $K_{S_0}$ is nef, use general ample curves on $S_0$. Otherwise the +classification of smooth projective surfaces gives ruling fibers with +canonical degree $-2$, or lines on $\mathbb P^2$ with canonical degree +$-3$. Their general strict transforms $F$ satisfy $K_S\cdot F\geq-3$, +because $K_S-\rho^*K_{S_0}$ is effective. In all cases the curves cover +$S$, so $F$ may be chosen not contained in the finitely many excluded +divisors. This is the surface argument also used in +\cite[Lemma~3.3]{CT2023}. + +The curve $F$ maps birationally to a curve $C\subset P$: it is not +contained in the exceptional or conductor locus. By the projection +formula and \eqref{eq:surface-effective-correction}, +\[ + (K_U+P)\cdot C=(K_S+\Delta_S)\cdot F + \geq K_S\cdot F\geq-3. +\] +Its choice also ensures $C\not\subset\Supp D_j$ for every $j$. +\end{proof} + +The surface estimate bounds the denominator introduced by extracting one +exceptional place of log discrepancy at most one. We now turn it into a +bound for every global rank-one reflexive sheaf. + +\begin{lemma}\label{lem:index-bound} +For every integer $n\geq0$ and $\varepsilon>0$, there is an integer +$I(n,\varepsilon)>0$ with the following property. Let +$(T,B+\bM)$ be a rational generalized klt compact K\"ahler threefold pair, +with $T$ globally strongly $\Q$-factorial. Suppose that +\begin{enumerate}[label=\textup{(\roman*)}] + \item every log discrepancy is at least $\varepsilon$; + \item at most $n$ exceptional valuations have log discrepancy at most one; + \item every exceptional log discrepancy greater than one is at least + $1+\varepsilon$. +\end{enumerate} +Then $\cF^{[I(n,\varepsilon)]}$ is invertible for every global coherent +rank-one reflexive sheaf $\cF$ on $T$. +\end{lemma} + +\begin{proof} +We induct on the number of exceptional places with log discrepancy at +most one. The terminal case is controlled by local canonical indices. +For the induction step, extract one place, bound its intersection degree +using the preceding surface estimate, and descend an integral line bundle. + +Replace $\varepsilon$ by $\min\{\varepsilon,1\}$, so assume +$0<\varepsilon\leq1$. We construct integers divisible by those from the +preceding induction stage. When $n=0$, the pair is generalized terminal. +The underlying space is ordinary terminal and +\[ + a(E;T,0)\geq a(E;T,B+\bM)\geq1+\varepsilon +\] +for every exceptional valuation. By +Lemma~\ref{lem:terminal-local-index} and the observation following that +lemma, every canonical point index $r>1$ satisfies +$r\leq1/\varepsilon$. Each local representative of $\cF$ is +$\Q$-Cartier by the global strong condition, and its Cartier index divides +$r$. Thus one may take +\[ + I(0,\varepsilon)=\operatorname{lcm} + \{1,\ldots,\lfloor1/\varepsilon\rfloor\}. +\] +Local invertibility of this reflexive power at every point is precisely +global invertibility; no trivialization on all of $T$ is asserted. + +Suppose $n>0$ and put $I'=I(n-1,\varepsilon)$. If there is no exceptional +valuation of discrepancy at most one, the preceding case applies. Otherwise +choose one such place, of discrepancy $a\in[\varepsilon,1]$, and apply +Proposition~\ref{prop:extraction} to obtain a projective extraction +$h:U\to T$ with that single exceptional prime $P$. Write its effective +crepant boundary as +\[ + B_U=B_U^{\mathrm{str}}+(1-a)P. +\] +Crepancy preserves all discrepancies and lowers the number of exceptional +low places by one. The induction hypotheses therefore hold on $U$, so +$I'$ clears the index of every global rank-one reflexive sheaf on $U$. + +First, $-P$ is $h$-ample. If $H$ is an $h$-ample line bundle, its reflexive +pushforward is rational Cartier on $T$. Lemma~\ref{lem:trace} gives +\[ + H=h^*H_T+cP +\] +as a rational bundle comparison. The divisor $cP$ is $h$-ample and +$h$-exceptional, hence is nonpositive by negativity. Since $h$ has a +positive-dimensional fiber, $c\neq0$, and therefore $c<0$. + +The same trace comparison for the nef data gives +\[ + M_U=h^*M_T-sP,\qquad s\geq0. +\] +Apply Lemma~\ref{lem:exceptional-surface-curve} with the components of +$B_U^{\mathrm{str}}$ as the excluded divisors. For its contracted curve +$C\subset P$, the other boundary has nonnegative degree and +$M_U\cdot C=-sP\cdot C\geq0$. Crepancy yields +\[ + -3\leq(K_U+P+B_U^{\mathrm{str}}+M_U)\cdot C + =aP\cdot C<0. +\] +Consequently +\begin{equation}\label{eq:exceptional-degree-bound} + 0<-P\cdot C\leq\frac{3}{\varepsilon}. +\end{equation} + +Now let $\cF$ be any global rank-one reflexive sheaf on $T$, and let +$\cF_U$ be its reflexive strict transform. In additive rational-bundle +notation, Lemma~\ref{lem:trace} gives +\begin{equation}\label{eq:sheaf-extraction-comparison} + h^*\cF=\cF_U+qP,\qquad q\in\Q. +\end{equation} +This comparison is defined by local meromorphic frames agreeing off the +exceptional locus, and requires no global meromorphic section of $\cF$. +The sheaves $\cF_U^{[I']}$ and $\cO_U(I'P)$ are line bundles. Intersecting +\eqref{eq:sheaf-extraction-comparison} with $C$ gives +\[ + q=\frac{I'\cF_U\cdot C}{-I'P\cdot C}, + \qquad k:=-I'P\cdot C\in\Z, + \quad 1\leq k\leq\frac{3I'}{\varepsilon}. +\] +The numerator is an integer. Define +\begin{equation}\label{eq:index-recurrence} + I(n,\varepsilon) + =I'\operatorname{lcm} + \{1,\ldots,\lceil3I'/\varepsilon\rceil\}. +\end{equation} +Then $I:=I(n,\varepsilon)$ is divisible by $I'$ and $Iq\in I'\Z$. +Thus $I\cF_U+(Iq)P$ represents an integral line bundle $L$ on $U$, +with its prescribed comparison to $h^*\cF^{[I]}$ off the exceptional +locus. Equation~\eqref{eq:sheaf-extraction-comparison} shows that $L$ has +degree zero on every $h$-contracted curve. + +Increase the coefficient $1-a$ of $P$ by a sufficiently small positive +rational number $\delta$. On a fixed log resolution carrying the data, +the inequalities defining generalized klt remain strict for all sufficiently +small $\delta$, so the new pair is effective and generalized klt. Its +adjoint is +\[ + h^*(K_T+B+M_T)+\delta P, +\] +which is $h$-antiample. Lemma~\ref{lem:descent} now descends $L$ +\emph{integrally}. More explicitly, local ordinary klt replacement and +the analytic base-point-free theorem generate $L^m$ for every sufficiently +large integer $m$; descend two consecutive powers and take their quotient. +No further index is introduced. The descended line bundle agrees with +$\cF^{[I]}$ away from $h(P)$, a set of codimension at least two in $T$. +Reflexive extension identifies them on $T$. This proves the induction, +including the case $a=1$. +\end{proof} + +\subsection{Nef endpoints and terminal lifting} + +The uniform index bound will make the low discrepancies constant on a +tail of any small sequence. After extracting those places, we must compare +each lifted relative program with the prescribed positive model downstairs. +The next Lemma provides both the discrepancy comparison during the run +and the crepant morphism at its nef endpoint. It will also be used for +strata and threshold lifts. + +\begin{lemma}\label{lem:nef-end-comparison} +Let $Y_0,Y,T_+$ be normal compact spaces projective and bimeromorphic over +a normal space $S$, and let $W$ be a common smooth modification +projective over each of the three spaces, with maps +$p_0:W\to Y_0$, $p:W\to Y$, and $q:W\to T_+$. +Let $A_0,A,A_+$ be rational line bundles on the respective spaces. +Suppose their prescribed meromorphic comparisons give +\begin{equation}\label{eq:two-target-comparison} + P_0=P+G=P_++F, + \qquad P_0=p_0^*A_0,\quad P=p^*A,\quad P_+=q^*A_+, +\end{equation} +where $G$ is effective and $p$-exceptional, and $F$ is effective and +$q$-exceptional. If $A_+$ is nef over $S$, then $F-G\geq0$. +If also $A$ is nef over $S$, then $P=P_+$. If, in addition, $A_+$ is +ample over $S$, the induced bimeromorphic map $Y\dashrightarrow T_+$ +is a projective morphism $g$, and $A=g^*A_+$ as rational line bundles +with the given comparison. +\end{lemma} + +\begin{proof} +Set $E=P-P_+=F-G$. Over $Y$, the divisor $-E=P_+-P$ is nef, while +\[ + p_*(-E)=-p_*F\leq0, +\] +since $G$ is $p$-exceptional. Lemma~\ref{lem:negativity} gives +$-E\leq0$, proving the first assertion. If $A$ is nef over $S$, then +$E$ is nef over $T_+$ and +\[ + q_*E=-q_*G\leq0, +\] +since $F$ is $q$-exceptional. Negativity gives $E\leq0$, and hence +$E=0$. The two exceptional supports need not coincide. + +Assume $A_+$ is relatively ample. A fiber of $p$ maps by $q$ into a +projective fiber of $T_+\to S$. Equality $p^*A=q^*A_+$ gives degree zero +on every curve in that fiber. A nonconstant image would be detected by a +curve of positive degree against $A_+$, so $q$ is constant on each +connected fiber of $p$. Proper factorization through the normal space +$Y$ gives $q=g\circ p$. The map $g$ is projective because $Y\to S$ is +projective and $T_+\to S$ is separated. Finally, pullback by $p$ is +injective on rational line bundles, by $p_*\cO_W=\cO_Y$ and the +projection formula; therefore $A=g^*A_+$. This proves the actual bundle +identity, not merely numerical equality. Compare +\cite[Lemma~2.12]{LMT2022} for the algebraic form of this comparison. +\end{proof} + +\begin{theorem}\label{thm:gklt-three} +Let $(X_0,B_0+\bM)$ be a rational generalized klt pair of dimension at +most three on a normal globally strongly $\Q$-factorial compact K\"ahler +space, with fixed rational b-line data as in +Definition~\ref{def:generalized-data}. Every sequence of elementary +birational steps in the sense of +Section~\ref{sec:relative} starting from this pair terminates. The +compact K\"ahler contraction bases may vary. +\end{theorem} + +\begin{proof} +In dimension at most two there are no nontrivial small birational +contractions, and Lemma~\ref{lem:cycle-loss} gives the result. In dimension +three that lemma first removes a finite divisorial prefix. Relabel the +remaining small sequence as +\[ + (X_i,B_i+\bM)\dashrightarrow(X_{i+1},B_{i+1}+\bM),\qquad i\geq1. +\] +All boundaries are now strict transforms of $B_1$. + +By Lemma~\ref{lem:low-places}, there is $\varepsilon_0>0$ such that the +initial set of exceptional valuations with discrepancy below +$1+\varepsilon_0$ is finite. Since discrepancies increase and small maps +preserve exceptionality, the sets +\[ + \mathcal L_i=\{E\text{ exceptional over }X_i: + a(E;X_i,B_i+\bM)\leq1\} +\] +form a decreasing sequence of finite sets. After discarding a finite +prefix, they equal one set $\mathcal L=\{E_1,\ldots,E_n\}$. +At the first model of this tail, the finitely many exceptional values in +$(1,1+\varepsilon_0)$ have a positive minimum distance from one; use +$\varepsilon_0$ itself if there are no such values. Choose +$\varepsilon>0$ no larger than this distance, than $\varepsilon_0$, than +one, and than the positive lower bound for all discrepancies of the initial +gklt pair furnished by Lemma~\ref{lem:low-places}. Monotonicity and the +stabilization of $\mathcal L$ show that, on every model of this tail, +all discrepancies are at least $\varepsilon$, and every exceptional +discrepancy greater than one is at least $1+\varepsilon$. + +Apply Lemma~\ref{lem:index-bound} with these fixed $n$ and +$\varepsilon$. Let $r$ clear the coefficients of $B_1$ and let $p$ clear +the higher nef datum. For example +\[ + J=I(n,\varepsilon)\operatorname{lcm}(r,p) +\] +makes each $J(K_{X_i}+B_i+M_{X_i})$ an integral line bundle, and makes +$J\bM$ integral on every higher carrier. Comparing the actual adjoint +bundles on a smooth carrier shows that every discrepancy belongs to +$J^{-1}\Z$: the canonical bundle there is integral and the coefficients +of the corresponding integral divisor difference are integers. The same +argument applies after any further resolution. Thus each nondecreasing +sequence +\[ + a(E_\ell;X_i,B_i+\bM)\in J^{-1}\Z\cap[\varepsilon,1] +\] +is eventually constant. After another finite prefix, all these values +are constant simultaneously. + +Use Proposition~\ref{prop:extraction} to extract exactly +$E_1,\ldots,E_n$ over the first model of this final tail: +\[ + h_1:(Y_1,\Delta_1+\bM)\longrightarrow(X_1,B_1+\bM). +\] +The boundary is effective and crepant. Every valuation exceptional over +$Y_1$ is exceptional over $X_1$ and is not in $\mathcal L$, so its +discrepancy is greater than one. Hence this is a globally strongly +$\Q$-factorial generalized terminal model. If $n=0$, take $h_1=\id$. + +Consider the first remaining flip over $Z_1$. Starting from $Y_1$, use +Proposition~\ref{prop:relative-steps} to take relative steps over $Z_1$ +while the adjoint is not nef. We show that no divisorial contraction can +occur in this run. At any finite stage $Y_j$, a common smooth model gives +\[ + P_0=P_j+G_j=P_++F, +\] +where $P_0$ is pulled back from $Y_1$, $P_j$ from the current lifted +adjoint, and $P_+$ from $K_{X_2}+B_2+M_{X_2}$. These are the prescribed +adjoint comparisons. The accumulated error $G_j$ is effective and +exceptional over $Y_j$; the error $F$ of the original flip is effective +and exceptional over $X_2$. The positive adjoint is ample over $Z_1$. +The first assertion of Lemma~\ref{lem:nef-end-comparison}, which does not +require nefness on $Y_j$, gives $G_j\leq F$. + +If a divisor were lost, its strict transform from $Y_1$ would have a +positive coefficient in $G_j$, by the strict discrepancy comparison at +its contraction. But every divisor on $Y_1$ is either the transform of a +divisor on $X_1$, or one of the $E_\ell$. In the first case its +coefficient in $F$ is zero because the original map is small. In the +second case that coefficient is +\[ + a(E_\ell;X_2,B_2+\bM)-a(E_\ell;X_1,B_1+\bM)=0 +\] +by stabilization. Both cases contradict $G_j\leq F$. Thus the entire +lifted run is small. It stays generalized terminal, and +Proposition~\ref{prop:terminal-three} forces it to reach a nef endpoint +after finitely many steps. + +At that endpoint, Lemma~\ref{lem:nef-end-comparison} gives equality of +the two adjoint pullbacks and a projective crepant morphism +\[ + h_2:(Y_2,\Delta_2+\bM)\longrightarrow(X_2,B_2+\bM). +\] +Here $Y_2$ denotes the endpoint, rather than the first intermediate model +of the finite run. Since the lifted transformations were small, the +exceptional primes of $h_2$ are exactly the same $E_\ell$, with the same +boundary coefficients. We may therefore repeat this construction over +each successive base $Z_i$. + +Each nontrivial flip below forces at least one step above. Indeed, take a +negative curve $C\subset X_i$ over $Z_i$. Projectivity of $h_i$ supplies +a curve $\Gamma\subset Y_i$ mapping onto $C$ with positive degree. The +crepant identity gives +\[ + (K_{Y_i}+\Delta_i+M_{Y_i})\cdot\Gamma + =\deg(\Gamma/C)(K_{X_i}+B_i+M_{X_i})\cdot C<0. +\] +Thus the starting lifted adjoint is not nef over $Z_i$. +An infinite original sequence would consequently concatenate to an +infinite sequence of small generalized terminal elementary steps, with +fixed rational boundary coefficients and the same rational nef b-line +data. All spaces remain compact K\"ahler and globally strongly +$\Q$-factorial. The bases may change, exactly as allowed in +Proposition~\ref{prop:terminal-three}, which gives the contradiction. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/10-special.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/10-special.tex new file mode 100644 index 0000000000000000000000000000000000000000..8e1a2df72e5ebc1d00ac56c2849c5282985bce98 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/10-special.tex @@ -0,0 +1,687 @@ +\section{Adjunction and special termination}\label{sec:special} + +We use the generalized pairs and elementary steps of +Section~\ref{sec:relative}. In particular, an elementary step is +projective over its own normal compact K\"ahler contraction base, is +negative for the adjoint on the negative side, and has a relatively +ample transformed adjoint on the positive side. The models on which +elementary programs are run are globally strongly $\Q$-factorial. +The bases in a sequence need not be the same. All boundaries and +higher line-bundle data in this section are rational. The higher +data are nef and are carried by projective modifications. + +Our goal is special termination: eventually both exceptional loci +avoid every generalized log canonical center. Restriction to a center +reduces its proof to termination in a smaller dimension. The center +need not satisfy the global strong factoriality condition, so we also +construct a crepant gdlt modification before running the smaller +program. + +These assertions are proved in a fixed order. Special termination +in dimension $d$ uses gdlt modifications and gdlt termination only in +dimensions less than $d$. It then gives gdlt modifications in +dimension $d$. For $d\leq3$, removing the floor and applying +Theorem~\ref{thm:gklt-three} gives gdlt termination in dimension $d$. +The induction ends with special termination and crepant gdlt +modifications in dimension four; it uses full gdlt termination only +through dimension three. +We first establish adjunction and discrepancy comparison on the +normalized centers. + +\subsection{Adjunction on normalized strata} + +We write $\operatorname{Nklt}(V,A+\bM)$ for the union of the +generalized log canonical centers of a glc pair. A stratum below +means the closure of a coefficient-one stratum on the good snc open +set in the definition of gdlt. Its normalization is always taken +before adjunction is iterated. + +\begin{lemma}[Adjunction with a fixed higher denominator] +\label{lem:stratum-adjunction} +Let $(V,A+\bM)$ be a rational gdlt pair on a globally strongly +$\Q$-factorial normal compact K\"ahler space. Suppose that $pM_W$ +is a holomorphic line bundle on a projective carrier $W\to V$, for +an integer $p>0$. If $T$ is the normalization of a generalized log +canonical center, then iterated divisorial adjunction along a +coefficient-one chain gives a rational gdlt pair +$(T,A_T+\bM^T)$ with effective boundary and an identity of rational +holomorphic adjoint bundles +\begin{equation}\label{eq:stratum-adjunction} + K_T+A_T+M_T^T + =\nu^*(K_V+A+M_V), +\end{equation} +where $\nu:T\to V$ is the natural map. The b-line $\bM^T$ is +represented by restricting $\bM$ to the strict stratum on a higher +model; its denominator divides $p$. Its generalized log canonical +centers map to generalized log canonical centers of $V$ properly +contained in $\nu(T)$. + +More precisely, for a nonnegative coefficient set $I\subset[0,1]$ +define +\begin{equation}\label{eq:adjunction-coefficients} + \mathcal D_p(I)= + \left\{ + 1-\frac1r+\frac{\sum_{j=1}^{\ell}k_jd_j+k/p}{r} + \ \middle|\ + \begin{array}{l} + r\in\N_{>0},\ \ell,k,k_j\in\Z_{\geq0},\\ + d_j\in I,\ \sum_{j=1}^{\ell}k_jd_j+k/p\leq1 + \end{array} + \right\}. +\end{equation} +If the coefficients of $A$ belong to $I$, those after $c$ +successive adjunctions belong to $\mathcal D_p^{\circ c}(I)$, +where the superscript denotes the $c$-fold iterate. +If $I$ satisfies the descending chain condition (DCC), so does every +one of these sets. No global +strong $\Q$-factoriality, or uniform Cartier index for $A_T$, is +asserted for $T$. +\end{lemma} + +\begin{proof} +Choose a projective log resolution $h:W\to V$ carrying the nef +data which is an isomorphism at the general points of the good +strata under consideration. We may replace $W$ further whenever +necessary, preserving these general points. Since $V$ is globally +strongly $\Q$-factorial, the trace $M_V$ is a rational line bundle. +Lemma~\ref{lem:trace} and Lemma~\ref{lem:negativity} give +\begin{equation}\label{eq:adjunction-nef-defect} + H=h^*M_V-M_W\geq0, + \qquad H\text{ is }h\text{-exceptional}. +\end{equation} +Use compatible local canonical representatives to write +\[ + K_W+A_W+M_W=h^*(K_V+A+M_V),\qquad + K_W+A_W^{\rm o}=h^*(K_V+A). +\] +These are actual rational sheaf comparisons, and +$A_W=A_W^{\rm o}+H$. + +We first justify the ordinary companion in this construction. +The inequality above says that ordinary log discrepancies of +$(V,A)$ are at least the generalized log discrepancies. In +particular $(V,A)$ is lc. An ordinary zero-discrepancy place is +also a generalized zero-discrepancy place. Its center therefore +meets the good open set. Conversely, every generalized center +meets that set, where $H=0$, the data descend, and the log formula +is the ordinary snc formula. Such a center is an ordinary +coefficient-one stratum. Thus $(V,A)$ is ordinary dlt and its lc +centers are exactly the generalized ones. This argument also +explains why forgetting the nef part does not introduce an +additional zero center outside the good open set; compare the +algebraic formulation in \cite[Remark~2.6(1)]{CT2023}. + +Let $S\subset V$ be a prime component of $\lfloor A\rfloor$ and +let $S_W$ be its strict transform. It is smooth after the chosen +resolution. The coefficient of $S_W$ is one in both formulas. +The residue isomorphism restricts them to $S_W$ as +\begin{align*} + (K_W+A_W+M_W)|_{S_W} + &=K_{S_W}+(A_W-S_W)|_{S_W}+M_W|_{S_W},\\ + (K_W+A_W^{\rm o})|_{S_W} + &=K_{S_W}+(A_W^{\rm o}-S_W)|_{S_W}. +\end{align*} +The normal space $S_W$ maps to the normalization $S^\nu$. +Push forward the indicated boundaries and the nef trace to +$S^\nu$. Over its smooth large open set, the residue +identification is the adjunction identification of the canonical +sheaf. It therefore defines, by reflexive extension, the +rational adjoint bundle on $S^\nu$ as the pullback of the +ambient adjoint. This construction gives an actual line-bundle +isomorphism after a common positive multiple. The prescribed +residue identification, and not equality of first Chern classes, +specifies the comparison. + +The restricted log boundary on $S_W$ is snc with coefficients at +most one. Thus the resulting generalized pair is sub-lc before +effectivity is checked. Every zero stratum of that restricted +log formula is an intersection of $S_W$ with coefficient-one +components of the ambient log formula. Its image is an ambient +generalized center and hence meets the good open set. Over that +set the restriction is snc and its nef data descend. The same +reasoning applies to the ordinary companion. In particular, +after effectivity is established, both restricted pairs have the +appropriate dlt good-open property. Their zero centers agree: +on a common carrier their log boundaries differ by the effective +restriction of $H$, while every generalized zero center meets +the open set where that restriction vanishes. + +Here is the local effectivity and coefficient calculation, with +the issue of nonfactorial intermediate strata made explicit. +Suppose at some stage of the chain that $U$ is the normal space +already obtained, $C$ is its effective generalized boundary, and +$S\subset\lfloor C\rfloor$ is the next prime. Carry along the +ordinary dlt companion just constructed. Its floor has the same +strata. Both adjoints are rational Cartier, although the +individual trace $M_U$ need not be rational Cartier on $U$. +Fix a prime divisor on $S^\nu$ whose coefficient is to be +computed, and work at an analytically general point of its image, +a codimension-two locus of $U$. + +Take a general transverse surface slice there. This operation +can be performed by fixing general values of local parameters +along that locus on a simultaneous embedded resolution. We +choose the parameters transverse to the finitely many resolution +strata dominating the locus. At a general point in question +the normal ambient space is Cohen--Macaulay: a normal space is +$S_2$, and its non-Cohen--Macaulay locus has codimension at least +three. The sliced surface is $S_2$ and regular in codimension +one, hence normal. The transverse restrictions of the +resolution formulas are crepant surface formulas, by +complete-intersection adjunction. One can check this first +away from the distinguished point and then extend the +isomorphism of the rational Cartier adjoints. In particular, +the ordinary surface pair is dlt along the coefficient-one +branch. The boundary multiplicities computed on the slice are +the multiplicities at the original general point. + +We use the following local surface fact. An ordinary dlt +surface germ along a coefficient-one branch is either snc for +the reduced boundary, or is a plt germ with a smooth pair +chart modulo a small cyclic group of some order $r$. The +branch in the chart is a coordinate curve. The different of +that branch alone is $1-1/r$, and the local Cartier index of +any integral divisorial sheaf divides $r$. This is the log +surface classification of +\cite[Theorem~4.15(1),(3), pp.~119--120, and Proposition~4.18]{KM1998}. +Its use here +is in the analytic-germ category: the numerical plt resolution +criterion gives a Hirzebruch--Jung string with the strict +boundary meeting an end; the corresponding normal analytic +surface germ is the cyclic quotient. It is a classification +of the surface germ, and does not assert local factoriality +of the higher-dimensional space $U$. In the snc case set +$r=1$. + +Write the additional effective boundary on the slice as a sum +with coefficients $d_j$. Pulling to the cyclic chart and +restricting to its smooth coordinate branch gives nonnegative +integral intersection multiplicities $k_j$. Its contribution +to the different is $\sum_j k_jd_j/r$. For the generalized +part, restrict a common higher model and the line bundle +representing $p\bM$ to the higher surface. Define its trace on +the sliced surface by this proper pushforward; the restricted +higher log formula fixes the identification on the punctured +surface. This avoids interchanging an arbitrary reflexive +hull with specialization. The cyclic quotient fact makes +$rp$ times this trace Cartier. Consequently its pullback +minus the higher nef bundle is an exceptional divisor with +denominator dividing $rp$. It is effective by +Lemma~\ref{lem:negativity}, because the higher bundle is nef +on every curve of the projective surface resolution. It +does not contain the strict coefficient-one branch, and its +restriction to that branch has coefficient $k/(rp)$ for +some $k\in\Z_{\geq0}$. The resulting coefficient is therefore +\begin{equation}\label{eq:surface-generalized-different} + 1-\frac1r+\frac{\sum_jk_jd_j+k/p}{r}. +\end{equation} +This proves effectivity of the generalized different. +Omitting the nef correction proves effectivity of the ordinary +different carried along in the construction. The coefficient +is at most one by the sub-lc log formula already established. +The local analytic adjunction and nef-defect calculation also +appears explicitly in the proof of +\cite[Lemma~3.1, pp.~5--6]{HXACC2023}; the local gdlt +modification in that proof is not used here as a global +modification theorem. + +We can now repeat the construction. On a resolution the chosen +chain is a chain of snc strata, and its successive restrictions +have the two log formulas just considered. A zero stratum of +any restricted formula is a zero stratum of the preceding one; +its image is therefore an ambient center meeting the original +good open set. This proves the center and gdlt assertions at +every stage. Closures and normalizations introduce no finite +cover of the chosen center: each selected component is +generically isomorphic over it, so its normalization is its +unique normalization. The restricted higher model is +projective over that normalization and is compact K\"ahler. +The higher line bundle remains nef, and its denominator still +divides $p$, under restriction and subsequent pullback. +This proves \eqref{eq:stratum-adjunction} and the asserted +description of the b-data. A fixed chain on a common higher +model also shows that these b-data are compatible under any +birational comparison which preserves the general points of +the chain. + +It remains to prove the DCC assertion rather than infer a +bound on all Cartier indices. If $I$ is DCC, its positive +elements, when present, have a positive minimum. The same is +true after adjoining $1/p$. A sum of such elements bounded +by one consequently has a bounded number of nonzero summands. +Finite sums of a nonnegative DCC set satisfy DCC: from any +sequence of tuples of a fixed length one can successively +choose a subsequence on which each coordinate is +nondecreasing. Thus the numerator sums in +\eqref{eq:adjunction-coefficients} satisfy DCC. For bounded +$r$, their images in that formula satisfy DCC. In a strictly +decreasing sequence of displayed coefficients with first +term $c_0<1$, the inequality +\[ + 1-\frac1r\leq c\leq c_0 + \quad\Longrightarrow\quad r\leq\frac1{1-c_0} +\] +bounds $r$. A sequence starting at one reduces to this case +after its first strict decrease. Therefore +$\mathcal D_p(I)$ is DCC, and induction proves the same for +each finite iterate. +\end{proof} + +\subsection{Comparison on a stratum} + +Adjunction supplies an effective generalized boundary with coefficients +in a fixed DCC set. To use those coefficients along a sequence, we need +monotonicity of the restricted discrepancies. Strictness must also +detect an ambient exceptional intersection of arbitrary codimension +on the stratum. + +\begin{lemma}[Restricted discrepancy comparison] +\label{lem:stratum-comparison} +Suppose that +\[ + (V,A+\bM)\dashrightarrow (V^+,A^++\bM) +\] +is a small elementary gdlt step over $Z$. Let $T$ be a +normalized generalized log canonical center whose general +point and coefficient-one chain are unchanged by the step, +and let $T^+$ denote the corresponding normalization on the +positive side. Put +$D_T=K_T+A_T+M_T^T$ and $D_{T^+}=K_{T^+}+A_{T^+}+M_{T^+}^T$. +Both strata map projectively and bimeromorphically to the +normalization $S$ of their common image in $Z$. The adjoints +are respectively antiample and ample over $S$. + +On a common smooth higher model, with projective maps $p$ and +$q$ to $T$ and $T^+$, respectively, +\begin{equation}\label{eq:restricted-positive-difference} + p^*D_T-q^*D_{T^+}=F_T\geq0. +\end{equation} +For every prime divisor $E$ on a proper bimeromorphic analytic model +of the stratum, the generalized discrepancies do not decrease. +They increase strictly if its center on either stratum is +contained in the corresponding ambient exceptional locus. +\end{lemma} + +\begin{proof} +The restricted morphisms factor through $S$ by normality. +They are projective, since restriction and this finite +factorization preserve relative ampleness; they are +bimeromorphic because the ambient step is an isomorphism +at the general point of the stratum. Restriction of the +relatively ample adjoint, and then pullback by the +normalization, gives the asserted signs. + +Take a common projective log resolution of the ambient step, +carrying its common nef data and preserving the general +points of the chosen snc chain. If $a,b$ are its projections, +Lemma~\ref{lem:negativity} gives the actual divisor comparison +\[ + F=a^*(K_V+A+M_V)-b^*(K_{V^+}+A^++M_{V^+})\geq0. +\] +This difference is anti-nef over $Z$. Its support contains +the full fibers over the non-isomorphism locus in $Z$: +opposite relative ampleness makes the difference nontrivial +over each such point, and the fiber-support assertion of +Lemma~\ref{lem:negativity} applies. The strict transform of +the chosen stratum is not contained in $\Supp F$, since its +general point lies in the common isomorphism open set. + +Restrict the two log formulas along the common snc chain. +At each restriction the residue canonical bundles are the +same, and the common higher nef bundles are the same. +They cancel. Each restricted difference is effective, +because the next strict stratum is not contained in its +support. At the last stage this gives +\eqref{eq:restricted-positive-difference} as an equality +with its prescribed meromorphic identification. The +coefficient of $E$ in this difference is the increase of its +generalized log discrepancy. + +For strictness, first make $E$ divisorial on a smooth higher +stratum. This can be achieved by projective blowups of its +successive centers; perform the same blowups in the ambient +resolution and resolve further, preserving the generic +chain. If the center of $E$ is in the ambient exceptional +locus, its entire inverse image in the common ambient model +lies in $\Supp F$, by the full-fiber assertion. Therefore +the center on the higher stratum lies in the support of the +restricted effective Cartier divisor. Its defining local +equation has positive order at $E$. This proves strictness +on either side. In particular, the argument detects an +intersection in arbitrary codimension on the original +stratum; it does not require that intersection already to +be a divisor there. The algebraic counterparts are +\cite[Lemma~2.8]{LMT2022} and +\cite[Proposition~3.2]{Moraga2020}; the argument above uses +the analytic projective negativity statement directly. +\end{proof} + +\subsection{The triangular induction} + +We state the three assertions together to make their dependency order +explicit. The first stops steps near the generalized log canonical +centers; the second constructs crepant models; the third supplies the +lower-dimensional termination used in the next induction stage. + +\begin{theorem}[Special termination]\label{thm:special} +Let $d\leq4$, and let +\[ + (V_0,A_0+\bM)\dashrightarrow(V_1,A_1+\bM) + \dashrightarrow\cdots +\] +be a sequence of elementary steps for a rational gdlt pair +on globally strongly $\Q$-factorial normal compact K\"ahler +spaces of dimension $d$, with fixed higher nef b-line data. +There exists $i_0$ such that, for every $i\geq i_0$, the +exceptional loci on both sides of the step are disjoint +from all generalized log canonical centers on those sides. +No common contraction base for the sequence is assumed. +\end{theorem} + +\begin{proposition}[Crepant gdlt modification] +\label{prop:gdlt-mod} +Let $(V,A+\bM)$ be a rational glc pair of dimension at most +four on a normal compact K\"ahler space. Its higher nef +line data are carried by a projective modification, and +$K_V+A+M_V$ is a rational holomorphic line bundle. +There is a projective bimeromorphic morphism $h:Y\to V$ +such that $Y$ is normal compact K\"ahler and globally +strongly $\Q$-factorial, $(Y,A_Y+\bM)$ is gdlt with +$A_Y\geq0$, and +\[ + K_Y+A_Y+M_Y=h^*(K_V+A+M_V). +\] +Every $h$-exceptional prime has coefficient one in $A_Y$, +or equivalently has generalized log discrepancy zero over +$(V,A+\bM)$. Global strong $\Q$-factoriality is not assumed +for $V$. +\end{proposition} + +\begin{theorem}[Gdlt termination in dimensions at most three] +\label{thm:gdlt-three} +Every sequence as in Theorem~\ref{thm:special} in dimension +at most three is finite. The assertion concerns arbitrary +choices of the permitted elementary steps, and does not +assume pseudo-effectivity of the adjoint. +\end{theorem} + +\begin{proof}[Joint proof of Theorem~\ref{thm:special}, +Proposition~\ref{prop:gdlt-mod}, and Theorem~\ref{thm:gdlt-three}] +For each $d$ in increasing order we prove special +termination, then the modification assertion, and, if +$d\leq3$, gdlt termination. In dimension zero these +statements are immediate. Fix $d>0$, assume all the +appropriate assertions in smaller dimensions, and first +prove special termination in dimension $d$. + +\smallskip +\noindent\emph{Stabilizing centers.} +There are only finitely many divisorial steps, by +Lemma~\ref{lem:cycle-loss}; hence we may discard a finite +prefix and consider only small steps. Generalized +discrepancies do not decrease. A zero-discrepancy place on +the positive side was consequently a zero-discrepancy +place before the step, and strictness in +Lemma~\ref{lem:negativity} excludes its center from either +exceptional locus. Thus every new center is the transform +of an old center with unchanged general point. If the +exceptional locus contains the general point of an old +center, that center disappears. There are finitely many +centers on the initial model, so after another finite +prefix their list is unchanged and all steps are +isomorphisms at their general points. + +For each center choose a chain of coefficient-one strata +at its general point. Transform this choice along the +sequence. Lemma~\ref{lem:stratum-adjunction} gives the +corresponding normalized strata $T_i$ and their adjoints +$D_{T_i}$. The b-line data on these strata are the same +under their birational identifications, with one fixed +higher denominator. The ambient boundary coefficients +belong to a fixed finite set. The coefficients after +adjunction therefore belong to one fixed DCC set, depending +only on that set, the denominator, and the length of the +chosen chain. + +We now induct on the dimension $e$ of a surviving center +to show eventual disjointness. A point center is already +disjoint after the stabilization just made. For a center +of positive dimension $e$, its proper zero substrata have +smaller dimension and there are finitely many of them. +Discarding a further finite prefix, we may assume that +both exceptional loci avoid every such substratum at +every remaining step. In particular, the induced maps +on $T_i$ are isomorphisms in neighborhoods of their +non-gklt loci. + +\smallskip +\noindent\emph{Finitely many extractions on the stratum.} +Identify divisorial places over the $T_i$ through common proper +bimeromorphic analytic models. If a prime +divisor $E$ is extracted by $T_i\dashrightarrow T_{i+1}$, +then $E$ is a divisor on $T_{i+1}$ and its center there is +contained in the ambient exceptional locus. Otherwise +the ambient isomorphism near its general point would +provide its strict transform as a divisor on $T_i$. +Lemma~\ref{lem:stratum-comparison} gives +\[ + a(E;T_i,A_{T_i}+\bM^T) + 0$, put +$c_E=\operatorname{coeff}_E C_W$. The log-smooth discrepancy criterion +gives +\begin{equation}\label{eq:rational-threshold-formula} + s=\min_{h_E>0}\frac{1-c_E}{h_E}. +\end{equation} +Indeed all coefficients of $C_W+aH$ are strictly below one, and components +with $h_E=0$ impose no new bound. Formula~\eqref{eq:rational-threshold-formula} +proves finiteness, rationality, attainment, and $s>a$, as well as the +claimed singularities at and below $s$. +\end{proof} + +At the threshold we need a generalized dlt model to use special +termination. The next lemma lifts each step of an infinite sequence to +a finite, nonempty string on such models. It uses the existence of a +finite relative generalized klt run from +Proposition~\ref{prop:relative-finite}; all comparisons concern one flip +base at a time. + +\begin{lemma}\label{lem:threshold-lift} +Consider an infinite sequence of small elementary transformations +\[ + X_i\dashrightarrow X_{i+1},\qquad + X_i\xrightarrow{f_i}Z_i\xleftarrow{f_i^+}X_{i+1}, +\] +between globally strongly $\Q$-factorial compact K\"ahler spaces of +dimension at most four. Let +$B_i,N_i\geq0$ be strict transforms of rational divisors, let $\bM$ be +fixed rational nef b-line data, and put +\[ + T_i=N_i+M_{X_i},\qquad A_i(t)=K_{X_i}+B_i+tT_i. +\] +Suppose that for rational numbers $0\leq a0$ makes $pM_{W_0}$ integral on the +original nef carrier $W_0$. At every repetition, the new boundary and testing +coefficients are obtained solely by omissions from the previous ones, +as in~\eqref{eq:retained-threshold-coefficients}. Newly extracted +coefficient-one primes are removed before the next threshold input. +The boundary coefficients therefore stay in $I$, the testing-boundary +coefficients stay in $J$, and the nef part at parameter zero remains +zero. On every required higher model the testing nef data are +$\frac1p$ times the pullback of the same integral nef line bundle. +The denominator $p$ is fixed. Common projective models are needed only +for finitely many maps at a time and do not change $p$. + +We verify explicitly that each $s_j$ belongs to the analytic generalized +threshold set with these data. Choose a general point of a computing +center on its compact input, and a relatively compact Stein neighborhood +$U$ of that point. Restrict a projective log resolution carrying the +data to $U$, and denote it by $g:W\to U$. The computing place still +meets this restriction. Hence the local threshold equals $s_j$: the +pair is lc at $s_j$, whereas the same place has negative discrepancy +for every larger parameter. + +Let $\cL$ represent the integral line bundle $pM_W$. The coherent sheaf +$g_*\cL$ has rank one on the isomorphism locus of $g$. Cartan's +Theorem~A supplies a section nonzero at a point of that locus, and thus +a nonzero section of $\cL$ on $W$. Its divisor $P'$ is Cartier and +represents $\cL$. In particular $P'$ is $g$-nef and $M_W$ is represented +by $\frac1pP'$. The induced meromorphic identification gives precisely +the original trace and pullback defect. Compatible local canonical +representatives may be chosen in the same way from the coherent +canonical sheaf. Neither choice changes the boundary or testing-boundary +coefficients, the discrepancies, or the factor $1/p$. The testing +boundary is rational Cartier because its components are restrictions +of global rational Cartier divisors on the strongly $\Q$-factorial input. + +The analytic generalized threshold theorem +\cite[Theorem~1.1 and Theorem~3.3; see also Definition~2.3 and +Remark~2.5]{HXACC2023} consequently applies in dimension four with the +fixed DCC sets $I,J$. Its nef summands are actual relatively nef Cartier +divisors with the fixed weight $1/p$; it requires no common bound for +Cartier indices of their downstairs traces. It prohibits the strictly +increasing sequence~\eqref{eq:increasing-thresholds}. This contradiction +proves the theorem. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/12-supply.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/12-supply.tex new file mode 100644 index 0000000000000000000000000000000000000000..808ffcc655f9bdbfa78dbfc6b51c7cfa9e18c8d9 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/12-supply.tex @@ -0,0 +1,126 @@ +\section{Nef b-line decompositions}\label{sec:supply} + +\begin{proposition}\label{prop:expression} +Let $(X,B)$ be a globally strongly $\Q$-factorial compact Kähler +fourfold pair, with $B$ effective and rational, $(X,B)$ klt, and +$D=K_X+B$ rational Cartier and analytically pseudo-effective. Suppose +there is a projective log resolution $p:W\to X$, with $W$ smooth and +compact Kähler, such that $W$ is non-uniruled or Moishezon. Then there +exist a smooth compact Kähler manifold $U$, a +projective modification $r:U\to X$, an analytically nef rational +holomorphic line bundle $M_U$, and an effective rational divisor $N$ on +$X$ such that, for the rational b-line bundle $\bM$ determined by $M_U$, +\begin{equation}\label{eq:supply-expression} + D\simq N+M_X. +\end{equation} +The equivalence is an identity of actual rational reflexive sheaves. +\end{proposition} + +\begin{proof} +Choose a projective log resolution $p:W\to X$ as in the statement. +We first describe how to transfer a nef adjoint on a minimal model reached +by a finite program from $W$ to a rational b-line summand over $X$. + +Suppose that a finite program on $W$ ends at a model +$Y$, and that $H_W$ and $H_Y$ are its initial and final actual rational +adjoints. Both morphisms defining each step are projective. The main +components of the successive fiber products of their graphs, followed +by normalization and resolution, therefore give a diagram +\[ + \begin{array}{ccc} + &U&\\[-2pt] + a\swarrow&&\searrow q\\[-2pt] + W&&Y + \end{array} +\] +whose two arrows are projective modifications. The construction uses +only the finitely many steps of this program: projectivity follows +successively by base change and composition. In particular $r=pa$ is +projective over the original $X$, and $U$ is compact Kähler. + +The stepwise comparisons in Lemma~\ref{lem:negativity}, pulled back to +this common model, give +\begin{equation}\label{eq:supply-common-comparison} + a^*H_W\simq q^*H_Y+G,\qquad G\geq0. +\end{equation} +Set $M_U=q^*H_Y$. When $H_Y$ is nef, so is $M_U$: pull back metrics with +arbitrarily small negative curvature and compare the pulled-back fixed +form with a Kähler form on $U$. In the projective case $U$ is itself +projective, and the pullback of a nef rational bundle is analytically +nef by the projective metric characterization. For a common multiple +$m$, the trace of $M_U$ is +represented by the rank-one reflexive sheaf +\[ + \bigl(r_*\cO_U(mM_U)\bigr)^{**}. +\] +Coherence follows from properness, and global strong $\Q$-factoriality +on $X$ makes a further reflexive power invertible. By +Lemma~\ref{lem:trace}, tracing \eqref{eq:supply-common-comparison} gives +\begin{equation}\label{eq:supply-trace-comparison} + \operatorname{Tr}_r(a^*H_W)\simq M_X+r_*G. +\end{equation} +Indeed this is the usual tensor identity at each codimension-one point +of $X$, where $r$ is an isomorphism, and both sides extend reflexively. +It retains the actual identifications of the line bundles. In +particular, no global meromorphic frame of either canonical bundle or +of $M_U$ is chosen. + +\medskip\noindent +\textit{Non-uniruled resolution.} +By \cite[Theorem~1.1]{Ou2025}, $K_W$ is analytically pseudo-effective. +Starting with the smooth empty-boundary pair $(W,0)$, apply +Lemma~\ref{lem:absolute-support} and Proposition~\ref{prop:ordinary-step} +whenever the current canonical bundle is not nef. +Lemma~\ref{lem:pe-step} preserves its +pseudo-effectivity, and Lemma~\ref{lem:mori-not-pe} excludes a +fiber-type contraction at every stage. Terminality persists by +Lemma~\ref{lem:negativity}. Corollary~\ref{prop:terminal-four} rules +out an infinite sequence. Continuation from every non-nef model thus +gives a finite program ending at a terminal compact Kähler $Y$ with +analytically nef actual rational canonical bundle $K_Y$. + +Apply \eqref{eq:supply-common-comparison} with $H_W=K_W$ and $H_Y=K_Y$. +The reflexive trace of $a^*K_W$ on $X$ is $K_X$: over the common +codimension-one open set the canonical sheaves are canonically +identified, and normality determines their reflexive extensions. +Equation~\eqref{eq:supply-trace-comparison} therefore yields +\[ + K_X+B\simq M_X+(r_*G+B). +\] +Take $N=r_*G+B$. This argument uses the trace of $K_W$; it does not +require the discrepancies comparing $K_W$ with $p^*D$ to be +nonnegative. The terminal fourfold result used here was established +independently of Theorem~\ref{thm:expression-termination}. + +\medskip\noindent +\textit{Uniruled Moishezon resolution.} +The smooth Kähler manifold $W$ is then projective. By +Lemma~\ref{lem:supply-log-resolution}, choose an effective rational SNC +klt boundary $\Gamma$ satisfying +\begin{equation}\label{eq:supply-projective-start} + H_W:=K_W+\Gamma\simq p^*D+E_0, + \qquad E_0\geq0\quad\text{and }E_0\text{ is }p\text{-exceptional}. +\end{equation} +This adjoint is analytically pseudo-effective, hence numerically +pseudo-effective in the projective sense by +\cite[Proposition~1.2]{BDPP2013}. + +Run the ordinary projective klt MMP on $(W,\Gamma)$. Divisorial steps +are finite, and every remaining flip sequence terminates by +\cite[Theorem~1.1]{CT2023}, applied to a pseudo-effective NQC lc +fourfold with zero nef part. These are projective varieties over a +point, as required by that theorem's conventions. Pseudo-effectivity +persists by Lemma~\ref{lem:pe-step}, so Lemma~\ref{lem:mori-not-pe} +excludes a fiber-type negative contraction. The resulting model $Y$ has nef +rational adjoint $H_Y=K_Y+\Gamma_Y$. + +Form \eqref{eq:supply-common-comparison} for this finite program. +Since $E_0$ is exceptional over $X$, the reflexive trace of +$a^*H_W$ in \eqref{eq:supply-projective-start} is $D$. Thus +\eqref{eq:supply-trace-comparison} gives +\[ + D\simq M_X+r_*G. +\] +Take $N=r_*G$. The projective fourfold theorem has supplied a nef +adjoint; fourfold abundance is not used. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/13-local-convention.tex b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/13-local-convention.tex new file mode 100644 index 0000000000000000000000000000000000000000..c6e640bd09e6eeff1b679d1415014cfb2622437f --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/build/sections/13-local-convention.tex @@ -0,0 +1,162 @@ +\section{Why analytic local factoriality is different} +\label{sec:local-convention} + +Global Weil-divisor $\Q$-factoriality does not require every analytic local +ring to be $\Q$-factorial. The distinction already occurs for projective +threefolds with one ordinary double point; see +\cite[Definition~5.1, Remark~(b)]{Reid}. The following product example +explains why the stronger local requirement cannot be inserted into +Theorem~\ref{thm:finite}. + +\begin{proposition}\label{prop:local-convention} +There is a smooth projective fourfold $X$ with pseudo-effective, non-nef +canonical divisor for which no ordinary $K_X$-negative program can reach a +nef model while keeping every model analytically locally +$\Q$-factorial. Its unique possible first negative birational contraction +is divisorial. Its target is nevertheless globally factorial and admits +a nef canonical divisor. +\end{proposition} + +\begin{proof} +\emph{Construction.} +Let $b:B\to\Pbb^4$ be the blowup of a point, let +$H=b^*\cO_{\Pbb^4}(1)$, and let $F$ be the exceptional divisor. +The graph of projection from that point embeds $B$ in +$\Pbb^4\times\Pbb^3$, and the restriction of $\cO(1,1)$ is $2H-F$. +Thus $2H-F$ is very ample. Since $H$ is globally generated, +\[ + 6H-2F=2(2H-F)+2H +\] +is very ample as well. Take a general smooth member +$U\in|6H-2F|$. +Its image $U_0\subset\Pbb^4$ is smooth away from the blown-up point. +The quadratic jets of the defining sextics at that point are arbitrary, +so a general member has a nondegenerate quadratic initial term. +The holomorphic Morse lemma identifies its unique singularity with +\[ + xy-zw=0. +\] +The restriction $\pi:U\to U_0$ resolves this node, with exceptional +quadric +\[ + E=F|_U\simeq\Pbb^1\times\Pbb^1, + \qquad \cO_U(E)|_E=\cO_E(-1,-1). +\] +Adjunction gives +\begin{equation}\label{eq:local-example-canonical} + K_U=H|_U+E, +\end{equation} +since $K_B=-5H+3F$. + +Weak Lefschetz for the smooth ample threefold $U\subset B$ gives +\[ + H^1(U,\Z)=0, + \qquad H^2(U,\Z)=\Z[H|_U]\oplus\Z[E]. +\] +This is the blowup calculation underlying the classical example in +\cite[Definition~5.1, Remark~(b)]{Reid}. +Let $C$ be a smooth elliptic curve and set $X=U\times C$. +Its canonical divisor is the pullback of \eqref{eq:local-example-canonical}, +so is effective. If $\ell$ is either ruling in $E\times\{c\}$, then +$K_X\cdot\ell=-1$; in particular $K_X$ is not nef. + +\emph{All negative contractions have the same target.} +Put $D=E\times C$ and let $h=\{e\}\times C$ be a horizontal curve. +A curve not contained in $D$ has nonnegative degree against both the +effective divisor $D$ and the nef hyperplane pullback. Thus every +$K_X$-negative curve lies in $D$. +The two rulings of $E$ have the same class in $H_2(U,\R)$: both have degrees +$0,-1$ against the displayed basis of $H^2(U,\R)$. +Künneth and $H^1(U,\R)=0$ now show that every integral curve +$\gamma\subset D$ has class +\begin{equation}\label{eq:local-example-curve} + [\gamma]=a[\ell]+b[h],\qquad a,b\geq0. +\end{equation} +Here $a$ is the sum of the projection degrees to the two factors of +$E=\Pbb^1\times\Pbb^1$, and $b$ is the projection degree to $C$. +Moreover $K_X\cdot\gamma=-a$, so negativity means $a>0$. + +Let $f:X\to Z$ be any nontrivial projective birational contraction with +connected fibres, normal compact Kähler target, and $-K_X$ relatively +ample. Choose a Kähler class $\omega_Z$ and set $\alpha=f^*\omega_Z$. +For a curve, vanishing of its degree against $\alpha$ is equivalent to +being contracted by $f$. +In particular $\alpha\cdot\ell\geq0$ and $\alpha\cdot h>0$: the +horizontal curve cannot be contracted because $K_X\cdot h=0$. +A contracted curve $\gamma$ has the form +\eqref{eq:local-example-curve} with $a>0$, and +\[ + 0=\alpha\cdot\gamma + =a(\alpha\cdot\ell)+b(\alpha\cdot h). +\] +It follows that $b=0$ and $\alpha\cdot\ell=0$. +Thus all rulings in every $E\times\{c\}$ are contracted, and $f$ is not +small. + +Set $q=\pi\times\id_C:X\to U_0\times C$. +Its nontrivial fibres are the quadrics $E\times\{c\}$, which are connected +by their rulings, so $f$ is constant on every $q$-fibre. +Conversely, every curve in an $f$-fibre has the form +\eqref{eq:local-example-curve} with $b=0$, and is contracted by $q$. +A connected projective fibre is connected by chains of curves, so $q$ is +constant on every $f$-fibre. The two targets are isomorphic: the reduced +image of $(q,f)$ in their product projects properly, bijectively and +bimeromorphically to each normal target, hence finitely and isomorphically. +Therefore $q$ is the only possible first negative birational contraction. +It is divisorial, and its relative numerical rank is one because both +quadric rulings have the same nonzero numerical class. + +\emph{Failure of analytic local $\Q$-factoriality.} +Near the singular locus of $U_0\times C$, consider the prime analytic +divisor +\[ + P=\{x=z=0\}\times\text{(a disk)} + \ \subset\ \{xy-zw=0\}\times\text{(a disk)}. +\] +On the blowup of the singular axis, its strict transform meets each +exceptional quadric in a ruling line. If $nP$ were Cartier near an axis +point for some integer $n>0$, its pullback would have the form +$n\widetilde P+kE_{\mathrm{exc}}$. +The associated line bundle restricts trivially to the quadric over that +point, because it is pulled back from a line bundle at a point. +On the other hand its restriction is +\[ + \cO_{\Pbb^1\times\Pbb^1}(n-k,-k), +\] +up to interchanging the factors. Triviality forces $k=0$ and $n=0$, a +contradiction. The target is not analytically locally $\Q$-factorial. +Since $K_X$ is not nef and there is no small negative contraction, +there is no permissible first step under that local convention. + +\emph{Compatibility with the global convention.} +The same example has a valid one-step global program. Indeed, +$-E$ is $\pi$-ample, so $-K_X$ is $q$-ample, and adjunction on $U_0$ gives +\[ + \cO_{U_0\times C}(K_{U_0\times C}) + \simeq\operatorname{pr}_1^*\cO_{U_0}(1), +\] +which is nef. On the blowup of the node the exceptional divisor has log +discrepancy two; its smooth product with $C$ is a log resolution with the +same log discrepancy. Hence the target is terminal, in particular klt. + +It remains to check that the local divisor $P$ is not a global +factoriality obstruction. The displayed integral cohomology of $U$ and +Hodge decomposition give $H^1(U,\cO_U)=H^2(U,\cO_U)=0$ and +$\Pic(U)=\Z[H|_U]\oplus\Z[E]$. +The exponential sequence and Künneth therefore give +\[ + \Pic(X)=\Z[H]\oplus\Z[D]\oplus\operatorname{pr}_C^*\Pic(C). +\] +Strict transform and divisor pushforward identify +\[ + \Cl(U_0\times C)=\Pic(X)/\Z[D]. +\] +Every surviving class descends to a Cartier class, either from the +hyperplane bundle on $U_0$ or from a line bundle on $C$. +Chow's theorem makes every global analytic Weil divisor on this projective +target algebraic, so every such divisor is Cartier. +GAGA identifies its global coherent +rank-one reflexive sheaves with algebraic divisorial sheaves, which are +therefore invertible as well. The plane $P$ is defined only on an analytic +neighbourhood; it need not extend to a divisor on the whole compact space. +\end{proof} diff --git a/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..93f2d96f3ee58258ed5b5e476542d61341f48a89 --- /dev/null +++ b/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1b9511572d6c717db55176347c5fdb90013f93df7b20fa95dd8801c86b19172 +size 871298 diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/README.md b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..92ff7cb69d2ebcdd7213e3213c1d94a1ca17abab --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [Fontaine–Mazur modularity at the prime 2](paper.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026, + author = {{OpenAI}}, + title = {{Fontaine--Mazur modularity at the prime 2}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/paper.pdf}{OAI:Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version updates citations to revised manuscripts in this collection; see the [previous version](../Fontaine-Mazur-modularity-at-the-prime-2-September-23-2026/paper.pdf). diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/main.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..d9ae50345440006f2baee4f79ec463ccd6b16875 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/main.tex @@ -0,0 +1,91 @@ +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools,mathrsfs} +\usepackage{microtype} +\usepackage{enumitem} +\usepackage{booktabs} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning} +\usepackage{xurl} +\usepackage[colorlinks=true,linkcolor=blue!45!black,citecolor=blue!45!black,urlcolor=blue!45!black]{hyperref} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newtheorem{example}[theorem]{Example} +\newcommand{\OO}{\mathcal O} +\newcommand{\EE}{E} +\newcommand{\QQ}{\mathbb Q} +\newcommand{\ZZ}{\mathbb Z} +\newcommand{\FF}{\mathbb F} +\newcommand{\kk}{k} +\newcommand{\eps}{\varepsilon} +\newcommand{\Qbar}{\overline{\mathbb Q}} +\newcommand{\Fbar}{\overline{\mathbb F}} +\newcommand{\GQ}{G_{\mathbb Q}} +\newcommand{\GQtwo}{G_{\mathbb Q_2}} +\DeclareMathOperator{\GL}{GL} +\DeclareMathOperator{\SL}{SL} +\DeclareMathOperator{\PGL}{PGL} +\DeclareMathOperator{\Gal}{Gal} +\DeclareMathOperator{\Spec}{Spec} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\Frac}{Frac} +\DeclareMathOperator{\tr}{tr} +\DeclareMathOperator{\ad}{ad} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\End}{End} +\DeclareMathOperator{\Ind}{Ind} +\DeclareMathOperator{\cInd}{c-Ind} +\DeclareMathOperator{\WD}{WD} +\DeclareMathOperator{\HT}{HT} +\DeclareMathOperator{\Fil}{Fil} +\DeclareMathOperator{\Ann}{Ann} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\coker}{coker} +\DeclareMathOperator{\codim}{codim} +\setlist[enumerate]{itemsep=3pt,topsep=5pt} +\setlist[itemize]{itemsep=3pt,topsep=5pt} +\setcounter{tocdepth}{2} +\title{Fontaine--Mazur modularity at the prime 2} +\author{OpenAI} +\date{October 6, 2026} + +\hypersetup{pdftitle={Fontaine--Mazur modularity at the prime 2},pdfauthor={OpenAI},pdfsubject={Odd regular two-dimensional Fontaine--Mazur modularity at 2}} + +\begin{document} +\maketitle +\begin{abstract} +We prove that every continuous, irreducible, odd two-dimensional +\(2\)-adic representation of \(G_{\mathbb Q}\), unramified outside +finitely many primes and de Rham at \(2\) with distinct Hodge--Tate +weights, is modular up to Tate twist. This resolves the odd, regular +two-dimensional Fontaine--Mazur conjecture over \(\mathbb Q\) at \(2\), +including all residual representations. +\end{abstract} + +\input{sections/introduction} +\clearpage +\begingroup +\small +\tableofcontents +\endgroup +\clearpage +\input{sections/preliminaries} +\input{sections/deformation} +\input{sections/completed_forms} +\input{sections/patching} +\input{sections/fields} +\input{sections/connectedness} +\input{sections/classicality} + +\bibliographystyle{plain} +\bibliography{references} +\end{document} diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/references.bib b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..b37cd7abbd1b70c38fad81eed34cc3a4162f64a6 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/references.bib @@ -0,0 +1,753 @@ + + + +@incollection{FM1995, + author = {Fontaine, Jean-Marc and Mazur, Barry}, + title = {Geometric {Galois} representations}, + booktitle = {Elliptic curves, modular forms, and {Fermat}'s last theorem}, + editor = {Coates, John and Yau, Shing-Tung}, + series = {Series in Number Theory}, + volume = {I}, + publisher = {International Press}, + address = {Cambridge, MA}, + year = {1995}, + pages = {41--78}, + isbn = {978-1-57146-026-4}, + note = {Hong Kong, 1993}, + url = {https://www.imo.universite-paris-saclay.fr/~fontaine/mazur.pdf} +} + +@article{Pan2022, + author = {Pan, Lue}, + title = {The {Fontaine--Mazur} conjecture in the residually reducible case}, + journal = {Journal of the American Mathematical Society}, + volume = {35}, + number = {4}, + year = {2022}, + pages = {1031--1169}, + doi = {10.1090/jams/991}, + eprint = {1901.07166}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/1901.07166v2} +} + +@misc{Zhang2025, + author = {Zhang, Xinyao}, + title = {On the {Fontaine--Mazur} conjecture for {$p=3$}}, + year = {2025}, + eprint = {2412.06812}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Preprint, arXiv:2412.06812v4, 22 July 2025}, + url = {https://arxiv.org/abs/2412.06812v4} +} + +@misc{Thorne2026, + author = {Thorne, Jack A.}, + title = {Towards the {Fontaine--Mazur} conjecture for {$\mathrm{GL}_2$}}, + year = {2026}, + eprint = {2608.07186}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Preprint, arXiv:2608.07186v1, 7 August 2026}, + url = {https://arxiv.org/abs/2608.07186v1} +} + + +@article{BIP, + author = {B{\"o}ckle, Gebhard and Iyengar, Ashwin and Pa{\v s}k{\=u}nas, Vytautas}, + title = {On local {Galois} deformation rings}, + journal = {Forum of Mathematics, Pi}, + volume = {11}, + year = {2023}, + eid = {e30}, + note = {Article e30; cited numbering from arXiv:2110.01638v2}, + pages = {1--54}, + doi = {10.1017/fmp.2023.25}, + url = {https://arxiv.org/abs/2110.01638v2}, + eprint = {2110.01638}, + archivePrefix = {arXiv}, + primaryClass = {math.NT} +} + +@incollection{Chenevier2014, + author = {Chenevier, Ga{\"e}tan}, + title = {The {$p$}-adic analytic space of pseudocharacters of a profinite group and pseudorepresentations over arbitrary rings}, + booktitle = {Automorphic Forms and {Galois} Representations. Vol. 1}, + editor = {Diamond, Fred and Kassaei, Payman L. and Kim, Minhyong}, + series = {London Mathematical Society Lecture Note Series}, + volume = {414}, + publisher = {Cambridge University Press}, + address = {Cambridge}, + year = {2014}, + pages = {221--285}, + doi = {10.1017/CBO9781107446335.008}, + url = {https://arxiv.org/abs/0809.0415v2}, + eprint = {0809.0415}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Theorem and proposition locators in this manuscript refer to arXiv:0809.0415v2} +} + +@article{WangErickson2018, + author = {Wang-Erickson, Carl}, + title = {Algebraic families of {Galois} representations and potentially semi-stable pseudodeformation rings}, + journal = {Mathematische Annalen}, + volume = {371}, + year = {2018}, + pages = {1615--1681}, + doi = {10.1007/s00208-017-1557-8}, + url = {https://doi.org/10.1007/s00208-017-1557-8} +} + +@article{Demushkin, + author = {Labute, John P.}, + title = {Classification of {Demushkin} Groups}, + journal = {Canadian Journal of Mathematics}, + volume = {19}, + year = {1967}, + pages = {106--132}, + doi = {10.4153/CJM-1967-007-8}, + url = {https://doi.org/10.4153/CJM-1967-007-8} +} + +@book{SGA2, + author = {Grothendieck, Alexander}, + title = {Cohomologie locale des faisceaux coh{\'e}rents et th{\'e}or{\`e}mes de {Lefschetz} locaux et globaux ({SGA} 2)}, + series = {Documents Math{\'e}matiques}, + volume = {4}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + address = {Paris}, + year = {2005}, + isbn = {2-85629-169-4}, + url = {https://arxiv.org/abs/math/0511279}, + note = {Recomposed and annotated edition of the 1968 original, edited by Yves Laszlo; with an expos{\'e} by Mich{\`e}le Raynaud} +} + +@book{Milne2006, + author = {Milne, J. S.}, + title = {Arithmetic Duality Theorems}, + edition = {Second}, + publisher = {BookSurge LLC}, + year = {2006}, + isbn = {1-4196-4274-X}, + url = {https://www.jmilne.org/math/Books/ADTnot.pdf} +} + +@misc{Tabaa2020, + author = {Taba{\^a}, Mohamed}, + title = {On the completed tensor product of two algebras on a field}, + year = {2020}, + eprint = {2002.02727}, + archivePrefix = {arXiv}, + primaryClass = {math.AC}, + url = {https://arxiv.org/abs/2002.02727v2}, + note = {Preprint, arXiv:2002.02727v2, 10 February 2020}, + howpublished = {\url{https://arxiv.org/abs/2002.02727v2}} +} + +@misc{StacksProject, + author = {{The Stacks Project Authors}}, + title = {The {Stacks Project}}, + year = {2026}, + url = {https://stacks.math.columbia.edu}, + howpublished = {\url{https://stacks.math.columbia.edu}}, + note = {Exact tags cited in the text; accessed 23 September 2026} +} + + +@article{PaskunasTung2021, + author = {Pa{\v s}k{\=u}nas, Vytautas and Tung, Shen-Ning}, + title = {Finiteness properties of the category of mod {$p$} representations of {$\mathrm{GL}_2(\mathbf Q_p)$}}, + journal = {Forum of Mathematics, Sigma}, + volume = {9}, + year = {2021}, + eid = {e80}, + note = {Article e80}, + pages = {1--39}, + doi = {10.1017/fms.2021.72}, + eprint = {2104.08948}, + archivePrefix = {arXiv}, + url = {https://doi.org/10.1017/fms.2021.72} +} + +@article{CDP2014, + author = {Colmez, Pierre and Dospinescu, Gabriel and Pa{\v s}k{\=u}nas, Vytautas}, + title = {The {$p$}-adic local {Langlands} correspondence for {$\mathrm{GL}_2(\mathbf Q_p)$}}, + journal = {Cambridge Journal of Mathematics}, + volume = {2}, + number = {1}, + year = {2014}, + pages = {1--47}, + doi = {10.4310/CJM.2014.v2.n1.a1}, + url = {https://doi.org/10.4310/CJM.2014.v2.n1.a1} +} + +@incollection{Colmez2010, + author = {Colmez, Pierre}, + title = {Repr{\'e}sentations de {$\mathrm{GL}_2(\mathbf Q_p)$} et {$(\varphi,\Gamma)$}-modules}, + booktitle = {Repr{\'e}sentations {$p$}-adiques de groupes {$p$}-adiques {II}: Repr{\'e}sentations de {$\mathrm{GL}_2(\mathbf Q_p)$} et {$(\varphi,\Gamma)$}-modules}, + editor = {Berger, Laurent and Breuil, Christophe and Colmez, Pierre}, + series = {Ast{\'e}risque}, + number = {330}, + year = {2010}, + pages = {281--509}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + url = {https://numdam.org/item/AST_2010__330__281_0/} +} + +@incollection{BergerBreuil2010, + author = {Berger, Laurent and Breuil, Christophe}, + title = {Sur quelques repr{\'e}sentations potentiellement cristallines de {$\mathrm{GL}_2(\mathbf Q_p)$}}, + booktitle = {Repr{\'e}sentations {$p$}-adiques de groupes {$p$}-adiques {II}: Repr{\'e}sentations de {$\mathrm{GL}_2(\mathbf Q_p)$} et {$(\varphi,\Gamma)$}-modules}, + editor = {Berger, Laurent and Breuil, Christophe and Colmez, Pierre}, + series = {Ast{\'e}risque}, + number = {330}, + year = {2010}, + pages = {155--211}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + url = {https://numdam.org/item/AST_2010__330__155_0/} +} + +@incollection{BreuilEmerton2010, + author = {Breuil, Christophe and Emerton, Matthew}, + title = {Repr{\'e}sentations {$p$}-adiques ordinaires de {$\mathrm{GL}_2(\mathbf Q_p)$} et compatibilit{\'e} local-global}, + booktitle = {Repr{\'e}sentations {$p$}-adiques de groupes {$p$}-adiques {III}: m{\'e}thodes globales et g{\'e}om{\'e}triques}, + series = {Ast{\'e}risque}, + number = {331}, + year = {2010}, + pages = {255--315}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + url = {https://numdam.org/item/AST_2010__331__255_0/} +} + +@incollection{Paskunas2010, + author = {Pa{\v s}k{\=u}nas, Vytautas}, + title = {Extensions for supersingular representations of {$\mathrm{GL}_2(\mathbf Q_p)$}}, + booktitle = {Repr{\'e}sentations {$p$}-adiques de groupes {$p$}-adiques {III}: m{\'e}thodes globales et g{\'e}om{\'e}triques}, + series = {Ast{\'e}risque}, + number = {331}, + year = {2010}, + pages = {317--353}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + url = {https://www.numdam.org/item/AST_2010__331__317_0/} +} + +@incollection{Emerton2010OrdinaryI, + author = {Emerton, Matthew}, + title = {Ordinary parts of admissible representations of {$p$}-adic reductive groups {I}. {Definition} and first properties}, + booktitle = {Repr{\'e}sentations {$p$}-adiques de groupes {$p$}-adiques {III}: m{\'e}thodes globales et g{\'e}om{\'e}triques}, + series = {Ast{\'e}risque}, + number = {331}, + year = {2010}, + pages = {355--402}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + url = {https://numdam.org/item/AST_2010__331__355_0/} +} + +@article{GeeNewton2022, + author = {Gee, Toby and Newton, James}, + title = {Patching and the completed homology of locally symmetric spaces}, + journal = {Journal of the Institute of Mathematics of Jussieu}, + volume = {21}, + number = {2}, + year = {2022}, + pages = {395--458}, + doi = {10.1017/S1474748020000158}, + eprint = {1609.06965}, + archivePrefix = {arXiv}, + url = {https://doi.org/10.1017/S1474748020000158} +} + + +@book{JacquetLanglands1970, + author = {Jacquet, Herv{\'e} and Langlands, Robert P.}, + title = {Automorphic Forms on {GL}(2)}, + series = {Lecture Notes in Mathematics}, + volume = {114}, + publisher = {Springer-Verlag}, + address = {Berlin--New York}, + year = {1970}, + url = {https://publications.ias.edu/sites/default/files/automorphic-forms-on-gl2-rpl_1.pdf} +} + +@book{ArthurClozel1989, + author = {Arthur, James and Clozel, Laurent}, + title = {Simple Algebras, Base Change, and the Advanced Theory of the Trace Formula}, + series = {Annals of Mathematics Studies}, + volume = {120}, + publisher = {Princeton University Press}, + address = {Princeton, NJ}, + year = {1989}, + url = {https://www.claymath.org/library/cw/arthur/pdf/30.pdf} +} + +@book{Langlands1980, + author = {Langlands, Robert P.}, + title = {Base Change for {GL}(2)}, + series = {Annals of Mathematics Studies}, + volume = {96}, + publisher = {Princeton University Press}, + address = {Princeton, NJ}, + year = {1980}, + url = {https://publications.ias.edu/sites/default/files/base-change-for-gl2_rpl.pdf} +} + +@article{BLGGT2014, + author = {Barnet-Lamb, Thomas and Gee, Toby and Geraghty, David and Taylor, Richard}, + title = {Potential Automorphy and Change of Weight}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {179}, + number = {2}, + year = {2014}, + pages = {501--609}, + doi = {10.4007/annals.2014.179.2.3}, + url = {https://annals.math.princeton.edu/wp-content/uploads/annals-v179-n2-p03-p.pdf} +} + +@article{BLGGTLocalGlobal2014, + author = {Barnet-Lamb, Thomas and Gee, Toby and Geraghty, David and Taylor, Richard}, + title = {Local-Global Compatibility for {$l=p$}, {II}}, + journal = {Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series = {4}, + volume = {47}, + number = {1}, + year = {2014}, + pages = {165--179}, + doi = {10.24033/asens.2212}, + url = {https://www.numdam.org/item/10.24033/asens.2212.pdf} +} + +@article{KhareWintenberger2009, + author = {Khare, Chandrashekhar and Wintenberger, Jean-Pierre}, + title = {{Serre}'s Modularity Conjecture ({I})}, + journal = {Inventiones Mathematicae}, + volume = {178}, + number = {3}, + year = {2009}, + pages = {485--504}, + doi = {10.1007/s00222-009-0205-7}, + url = {https://www.math.ucla.edu/~shekhar/papers/results.pdf} +} + +@article{KhareWintenberger2009II, + author = {Khare, Chandrashekhar and Wintenberger, Jean-Pierre}, + title = {{Serre}'s Modularity Conjecture ({II})}, + journal = {Inventiones Mathematicae}, + volume = {178}, + number = {3}, + year = {2009}, + pages = {505--586}, + doi = {10.1007/s00222-009-0206-6} +} + +@article{Kisin2009, + author = {Kisin, Mark}, + title = {Modularity of {$2$}-Adic {Barsotti--Tate} Representations}, + journal = {Inventiones Mathematicae}, + volume = {178}, + number = {3}, + year = {2009}, + pages = {587--634}, + doi = {10.1007/s00222-009-0207-5}, + url = {https://doi.org/10.1007/s00222-009-0207-5} +} + +@incollection{Kisin2005Survey, + author = {Kisin, Mark}, + title = {Modularity of {$2$}-Dimensional {Galois} Representations}, + booktitle = {Current Developments in Mathematics, 2005}, + publisher = {International Press}, + year = {2007}, + pages = {191--230}, + url = {https://www.intlpress.com/site/pub/files/_fulltext/journals/cdm/2005/2005/0001/CDM-2005-2005-0001-a007.pdf} +} + + +@incollection{BlochKato1990, + author = {Bloch, Spencer and Kato, Kazuya}, + title = {{$L$}-functions and {Tamagawa} numbers of motives}, + booktitle = {The {Grothendieck} Festschrift, Vol. {I}}, + editor = {Cartier, Pierre and Illusie, Luc and Katz, Nicholas M. and Laumon, G{\'e}rard and Manin, Yuri I. and Ribet, Kenneth A.}, + series = {Progress in Mathematics}, + volume = {86}, + pages = {333--400}, + publisher = {Birkh{\"a}user Boston}, + address = {Boston, MA}, + year = {1990}, + url = {https://virtualmath1.stanford.edu/~conrad/BSDseminar/refs/BKTamagawa.pdf} +} + +@article{Berger2002, + author = {Berger, Laurent}, + title = {Repr{\'e}sentations {$p$}-adiques et {\'e}quations diff{\'e}rentielles}, + journal = {Inventiones Mathematicae}, + volume = {148}, + pages = {219--284}, + year = {2002}, + doi = {10.1007/s002220100202}, + eprint = {math/0102179}, + archivePrefix = {arXiv}, + note = {Theorem locators refer to arXiv:math/0102179v3}, + url = {https://arxiv.org/abs/math/0102179v3} +} + +@article{Brumer1967, + author = {Brumer, Armand}, + title = {On the units of algebraic number fields}, + journal = {Mathematika}, + volume = {14}, + number = {2}, + pages = {121--124}, + year = {1967}, + doi = {10.1112/S0025579300003703}, + url = {https://doi.org/10.1112/S0025579300003703} +} + +@article{Fresnel1969, + author = {Fresnel, Jean}, + title = {Rang {$p$}-adique du groupe des unit{\'e}s d'un corps de nombres}, + journal = {S{\'e}minaire de th{\'e}orie des nombres de Bordeaux}, + year = {1968--1969}, + pages = {1--18}, + note = {Expos{\'e} no. 9}, + url = {https://www.numdam.org/item/STNB_1968-1969____A9_0/} +} + +@book{Serre1989Abelian, + author = {Serre, Jean-Pierre}, + title = {Abelian {$l$}-adic Representations and Elliptic Curves}, + series = {Advanced Book Classics}, + publisher = {Addison-Wesley}, + address = {Redwood City, CA}, + year = {1989}, + isbn = {0-201-09384-7}, + note = {Updated reprint of the 1968 original}, + url = {https://www.math.mcgill.ca/darmon/courses/18-19/gs/serre-mcgill.pdf} +} + + +@misc{MilneCFT, + author = {Milne, J. S.}, + title = {Class Field Theory}, + year = {2020}, + url = {https://www.jmilne.org/math/CourseNotes/CFT.pdf}, + howpublished = {\url{https://www.jmilne.org/math/CourseNotes/CFT.pdf}}, + note = {Version 4.03, 6 August 2020} +} + + +@misc{MilneANT, + author = {Milne, J. S.}, + title = {Algebraic Number Theory}, + year = {2020}, + note = {Course notes, version 3.08, 19 July 2020, 166 pages}, + howpublished = {\url{https://www.jmilne.org/math/CourseNotes/ANT.pdf}}, + url = {https://www.jmilne.org/math/CourseNotes/ANT.pdf} +} + + +@incollection{Katz1973, + author = {Katz, Nicholas M.}, + title = {{$p$}-adic properties of modular schemes and modular forms}, + booktitle = {Modular Functions of One Variable {III}}, + series = {Lecture Notes in Mathematics}, + volume = {350}, + pages = {69--190}, + publisher = {Springer}, + address = {Berlin}, + year = {1973}, + doi = {10.1007/978-3-540-37802-0_3}, + url = {https://web.math.princeton.edu/~nmk/old/padicpropMFMS.pdf} +} + +@book{KatzMazur1985, + author = {Katz, Nicholas M. and Mazur, Barry}, + title = {Arithmetic Moduli of Elliptic Curves}, + series = {Annals of Mathematics Studies}, + volume = {108}, + publisher = {Princeton University Press}, + address = {Princeton, NJ}, + year = {1985}, + url = {https://www.jstor.org/stable/j.ctt1b9s05p} +} + + +@incollection{Deligne1971, + author = {Deligne, Pierre}, + title = {Formes modulaires et repr{\'e}sentations {$\ell$}-adiques}, + booktitle = {S{\'e}minaire Bourbaki, Vol. 1968/69: Expos{\'e}s 347--363}, + series = {S{\'e}minaire Bourbaki}, + number = {11}, + publisher = {Springer-Verlag}, + year = {1971}, + pages = {139--172}, + note = {Expos{\'e} no. 355}, + url = {https://www.numdam.org/item/SB_1968-1969__11__139_0/} +} + +@book{MilneAlgebraicGroups, + author = {Milne, J. S.}, + title = {Algebraic Groups: The Theory of Group Schemes of Finite Type over a Field}, + publisher = {Cambridge University Press}, + year = {2022}, + isbn = {9781009018586}, + url = {https://www.jmilne.org/math/Books/iAG2022.pdf}, + note = {Corrected reprint of the 2017 edition; author manuscript dated 5 October 2021} +} + +@article{BreuilMezard2002, + author = {Breuil, Christophe and M{\'e}zard, Ariane}, + title = {Multiplicit{\'e}s modulaires et repr{\'e}sentations de {$\mathrm{GL}_2(\mathbf Z_p)$} et de {$\mathrm{Gal}(\overline{\mathbf Q}_p/\mathbf Q_p)$} en {$\ell=p$}}, + journal = {Duke Mathematical Journal}, + volume = {115}, + number = {2}, + year = {2002}, + pages = {205--310}, + doi = {10.1215/S0012-7094-02-11522-1}, + note = {With Appendix A, ``Sur l'unicit{\'e} des types pour {GL}$_2$'', by Guy Henniart}, + url = {https://www.imo.universite-paris-saclay.fr/~christophe.breuil/PUBLICATIONS/multiplicite.pdf} +} + +@article{BarthelLivne1994, + author = {Barthel, Laure and Livn{\'e}, Ron}, + title = {Irreducible modular representations of {$\mathrm{GL}_2$} of a local field}, + journal = {Duke Mathematical Journal}, + volume = {75}, number = {2}, year = {1994}, pages = {261--292}, + doi = {10.1215/S0012-7094-94-07508-X} +} + +@article{BarthelLivne1995, + author = {Barthel, Laure and Livn{\'e}, Ron}, + title = {Modular representations of {$\mathrm{GL}_2$} of a local field: the ordinary, unramified case}, + journal = {Journal of Number Theory}, + volume = {55}, number = {1}, year = {1995}, pages = {1--27} +} + +@article{Breuil2003I, + author = {Breuil, Christophe}, + title = {Sur quelques repr{\'e}sentations modulaires et {$p$}-adiques de {$\mathrm{GL}_2(\mathbf Q_p)$}. {I}}, + journal = {Compositio Mathematica}, + volume = {138}, number = {2}, year = {2003}, pages = {165--188}, + doi = {10.1023/A:1026191928449} +} + +@article{TaylorWiles1995, + author = {Taylor, Richard and Wiles, Andrew}, + title = {Ring-theoretic properties of certain {Hecke} algebras}, + journal = {Annals of Mathematics}, + series = {2}, volume = {141}, number = {3}, + year = {1995}, pages = {553--572}, + url = {https://virtualmath1.stanford.edu/~rltaylor/hecke.pdf} +} + +@article{Kisin2009FiniteFlat, + author = {Kisin, Mark}, + title = {Moduli of finite flat group schemes, and modularity}, + journal = {Annals of Mathematics}, + series = {2}, volume = {170}, number = {3}, + year = {2009}, pages = {1085--1180}, + url = {https://annals.math.princeton.edu/wp-content/uploads/annals-v170-n3-p03-p.pdf} +} + +@article{Tung2021Dyadic, + author = {Tung, Shen-Ning}, + title = {On the modularity of {$2$}-adic potentially semi-stable deformation rings}, + journal = {Mathematische Zeitschrift}, + volume = {298}, + number = {1-2}, + year = {2021}, + pages = {107--159}, + doi = {10.1007/s00209-020-02588-4}, + eprint = {1908.06174}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/1908.06174v3}, + note = {Theorem locators refer to arXiv:1908.06174v3} +} + +@misc{EGPZ2026, + author = {Emerton, Matthew and Gee, Toby and Pan, Lue and Zhu, Xinwen}, + title = {Prescribed lifts of {$2$}-dimensional representations}, + year = {2026}, + eprint = {2606.25485}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Preprint, arXiv:2606.25485v1, 24 June 2026}, + url = {https://arxiv.org/abs/2606.25485v1} +} + +@article{Pan2026Classicality, + author = {Pan, Lue}, + title = {On locally analytic vectors of the completed cohomology of modular curves {II}}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {203}, + number = {1}, + year = {2026}, + pages = {121--281}, + doi = {10.4007/annals.2026.203.1.3}, + eprint = {2209.06366}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://annals.math.princeton.edu/2026/203-1/p03}, + note = {Theorem 7.1.2 is cited in arXiv:2209.06366v1} +} + +@article{Serre1987, + author = {Serre, Jean-Pierre}, + title = {Sur les repr{\'e}sentations modulaires de degr{\'e} 2 de + {$\operatorname{Gal}(\overline{\mathbf Q}/\mathbf Q)$}}, + journal = {Duke Mathematical Journal}, + volume = {54}, number = {1}, year = {1987}, pages = {179--230}, + doi = {10.1215/S0012-7094-87-05413-5} +} + +@article{Wiles1995, + author = {Wiles, Andrew}, + title = {Modular elliptic curves and {Fermat}'s last theorem}, + journal = {Annals of Mathematics}, + volume = {141}, number = {3}, year = {1995}, pages = {443--551}, + doi = {10.2307/2118559} +} + +@article{SkinnerWiles1999, + author = {Skinner, Christopher M. and Wiles, Andrew J.}, + title = {Residually reducible representations and modular forms}, + journal = {Publications Math{\'e}matiques de l'IH{\'E}S}, + volume = {89}, year = {1999}, pages = {5--126}, + doi = {10.1007/BF02698855} +} + +@article{SkinnerWiles2001, + author = {Skinner, Christopher M. and Wiles, Andrew J.}, + title = {Nearly ordinary deformations of irreducible residual representations}, + journal = {Annales de la Facult{\'e} des Sciences de Toulouse. Math{\'e}matiques}, + series = {6}, volume = {10}, number = {1}, year = {2001}, pages = {185--215}, + url = {https://www.numdam.org/item/AFST_2001_6_10_1_185_0/} +} + +@article{Allen2014, + author = {Allen, Patrick B.}, + title = {Modularity of nearly ordinary 2-adic residually dihedral {Galois} representations}, + journal = {Compositio Mathematica}, + volume = {150}, number = {8}, year = {2014}, pages = {1235--1346}, + doi = {10.1112/S0010437X1300780X}, + url = {https://arxiv.org/abs/1301.1113v2}, + note = {Manuscript locators refer to arXiv:1301.1113v2} +} + +@article{Kisin2009FM, + author = {Kisin, Mark}, + title = {The {Fontaine--Mazur} conjecture for {$\mathrm{GL}_2$}}, + journal = {Journal of the American Mathematical Society}, + volume = {22}, number = {3}, year = {2009}, pages = {641--690}, + doi = {10.1090/S0894-0347-09-00628-6} +} + +@misc{Emerton2011, + author = {Emerton, Matthew}, + title = {Local-global compatibility in the {$p$}-adic {Langlands} programme for {$\mathrm{GL}_2/\mathbf Q$}}, + year = {2011}, + note = {Author draft, 23 March 2011}, + url = {https://math.uchicago.edu/~emerton/pdffiles/lg.pdf} +} + +@book{Voight2021, + author = {Voight, John}, + title = {Quaternion Algebras}, + series = {Graduate Texts in Mathematics}, + volume = {288}, + publisher = {Springer}, + address = {Cham}, + year = {2021}, + doi = {10.1007/978-3-030-56694-4}, + url = {https://doi.org/10.1007/978-3-030-56694-4} +} + +@article{BillereyMenares2016, + author = {Billerey, Nicolas and Menares, Ricardo}, + title = {On the modularity of reducible mod {$l$} {Galois} representations}, + journal = {Mathematical Research Letters}, + volume = {23}, + number = {1}, + pages = {15--41}, + year = {2016}, + url = {https://lmbp.uca.fr/~billerey/Research/Published/Menares_Modularity.pdf} +} + +@article{DeligneSerre1974, + author = {Deligne, Pierre and Serre, Jean-Pierre}, + title = {Formes modulaires de poids {1}}, + journal = {Annales scientifiques de l'{\'{E}}cole Normale Sup{\'e}rieure}, + series = {4}, + volume = {7}, + number = {4}, + year = {1974}, + pages = {507--530}, + doi = {10.24033/asens.1277}, + url = {https://www.numdam.org/articles/10.24033/asens.1277/} +} + +@incollection{Mazur1989, + author = {Mazur, Barry}, + title = {Deforming {Galois} representations}, + booktitle = {Galois groups over {$\mathbb{Q}$}}, + editor = {Ihara, Yasutaka and Ribet, Kenneth A. and Serre, Jean-Pierre}, + series = {Mathematical Sciences Research Institute Publications}, + volume = {16}, + publisher = {Springer}, + address = {New York}, + year = {1989}, + pages = {385--437}, + doi = {10.1007/978-1-4613-9649-9_7}, + url = {https://doi.org/10.1007/978-1-4613-9649-9_7} +} + + +@incollection{Serre1964Demushkin, + author = {Serre, Jean-Pierre}, + title = {Structure de certains pro-{$p$}-groupes}, + booktitle = {S{\'e}minaire Bourbaki: ann{\'e}es 1962/63--1963/64, expos{\'e}s 241--276}, + series = {S{\'e}minaire Bourbaki}, + number = {8}, + year = {1964}, + pages = {145--155}, + note = {Expos{\'e} 252, February 1963}, + publisher = {Soci{\'e}t{\'e} math{\'e}matique de France}, + url = {https://www.numdam.org/item/SB_1962-1964__8__145_0/} +} + +@misc{OpenAIH10Q2026, + author = {{OpenAI}}, + title = {{Hilbert's tenth problem over the rational numbers}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/main.pdf}{OAI:Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026}}, + year = {2026}, + note = {Section~4} +} + +@article{Ramakrishna2002, + author = {Ramakrishna, Ravi}, + title = {Deforming {Galois} representations and the conjectures of {Serre} and {Fontaine--Mazur}}, + journal = {Annals of Mathematics}, + volume = {156}, + number = {1}, + year = {2002}, + pages = {115--154}, + doi = {10.2307/3597186}, + url = {https://annals.math.princeton.edu/2002/156-1/p04} +} + +@article{Tang2019, + author = {Tang, Shiang}, + title = {Algebraic monodromy groups of {$l$}-adic representations of {$\mathrm{Gal}(\overline{\mathbb Q}/\mathbb Q)$}}, + journal = {Algebra \& Number Theory}, + volume = {13}, + number = {6}, + year = {2019}, + doi = {10.2140/ant.2019.13.1353}, + url = {https://msp.org/ant/2019/13-6/ant-v13-n6-p05-s.pdf} +} diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/classicality.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/classicality.tex new file mode 100644 index 0000000000000000000000000000000000000000..1d637ad2685bc993e6766097f2c0c8bc588a9172 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/classicality.tex @@ -0,0 +1,758 @@ +\section{Classicality and descent}\label{sec:classicality} + +Theorem~\ref{thm:potential-promodularity} places the target representation +in the closed Hecke support after a solvable totally real base change. +We now produce a locally algebraic vector with its eigensystem. +The additional work is needed when the local representation at~$2$ is +reducible: the two possible orders in a unitary principal series need +not have the same locally algebraic vectors. +Throughout this section the target $r$ is not virtually solvable, as +arranged in the preliminary reductions. In particular, its restriction +to every finite extension is absolutely irreducible. + +We retain the conventions of Section~\ref{sec:completed}: +$\chi=\det r$, the central character of completed forms is +$\psi=\chi\eps$, and the local block parameter is $r\otimes\eps$. +Cyclotomic exponents are counted with $\operatorname{exp}(\eps)=1$. +Thus a de Rham character of exponent $a$ has Hodge--Tate weight $-a$ +in the convention used by the ordinary modularity theorem below. +The field $F$ will always be totally real, solvable over~$\QQ$, of even +degree, and split completely at~$2$. +Until the final subsection, assume that $r|_{\GQtwo}$ is reducible. +We will retain its higher-exponent line in a global family, show that +the joint trace-and-character support is finite over weight space, and +use dense points that become modular after normalization and dualization. +Those points determine the inducing order to retain at the target. +Specialization will then give an actual vector, whose local algebraicity +is proved directly. The locally absolutely irreducible case will use +Proposition~\ref{prop:block-comparison} in the final subsection. + +\subsection{The local line and its global family} + +We first record the rank-one consequence of Bloch--Kato that fixes the +orientation. For a de Rham character $\theta$ of $G_{\QQ_2}$, write +$H^1_g(\QQ_2,\theta)$ for the subspace of de Rham extension classes. +The local Euler characteristic, duality, and the Bloch--Kato formulas give +\begin{align} + \dim H^1(\QQ_2,\theta) + &=1+\dim H^0(\QQ_2,\theta) + +\dim H^0(\QQ_2,\theta^{-1}\eps),\label{eq:rank-one-euler}\\ + \dim H^1_g(\QQ_2,\theta) + &=\dim D_{\mathrm{dR}}(\theta)/\Fil^0 + +\dim H^0(\QQ_2,\theta) + +\dim D_{\mathrm{cris}}(\theta^{-1}\eps)^{\varphi=1}. + \label{eq:rank-one-geometric} +\end{align} +The second formula follows from the exact annihilators of +\cite[Proposition~3.8]{BlochKato1990}, the $H^1_f$ and $H^1_e$ +dimension formulas of \cite[Corollary~3.8.4]{BlochKato1990}, and local +duality; it is the rank-one consequence used here. +These formulas have no restriction excluding~$2$. + +\begin{lemma}\label{lem:higher-line} +If $r|_{\GQtwo}$ is reducible and has distinct cyclotomic exponents, +it has an invariant line whose exponent is greater than that of the +quotient. +\end{lemma} +\begin{proof} +Characters occurring as subquotients of a de Rham representation are +de Rham. Suppose a chosen subcharacter has smaller exponent than the +quotient, and let $\theta$ be their ratio. Its exponent is strictly +negative, so $D_{\mathrm{dR}}(\theta)/\Fil^0=0$ and +$H^0(\QQ_2,\theta)=0$. The character $\theta^{-1}\eps$ has strictly +positive exponent. If its finite inertial part is nontrivial, its +crystalline module is zero; otherwise its crystalline Frobenius +eigenvalue has nonzero valuation and cannot be~$1$. +Equation~\eqref{eq:rank-one-geometric} therefore gives $H^1_g=0$. +The extension splits, and its other summand is the required line. +\end{proof} + +\begin{lemma}\label{lem:ordinary-character-family} +Suppose $r|_{\GQtwo}$ is reducible, and record the line of +Lemma~\ref{lem:higher-line}. Fix $\chi=\det r$. +After enlarging coefficients, there is a +complete local integral $\OO$-algebra $\mathscr D$, together with its +fixed global determinant $\chi$, its global trace, and a recorded local subcharacter +$\eta_1$, with the following properties. +\begin{enumerate} +\item $\mathscr D$ is horizontal, contains the target point, and + $\dim\mathscr D\ge2$. Put $\eta_2=\chi\eta_1^{-1}$. + On its globally absolutely irreducible locus the local + representation has subcharacter $\eta_1$ and quotient $\eta_2$. +\item For one field $F$ as above, the restricted trace lies in the + Hecke support of completed forms at a fixed tame level. +\item $\mathscr D$ is finite over the closed image of the global + pseudodeformation ring for $F$. It is also finite over the + image of the product of the dyadic pseudodeformation rings. +\end{enumerate} +\end{lemma} +\begin{proof} +Use a framed global deformation chart with fixed determinant and an +invariant line at~$2$, in an integral basis for the target and its line. +Consider its completed local ring at the characteristic-zero target +point. Corollary~\ref{cor:charzero-line-dimension} gives dimension +at least five for the local line chart and dimension two for the odd +real factor, over the characteristic-zero coefficient field. +The relative presentation of Proposition~\ref{prop:relative-presentation} +has generators minus relations at least $-3$: its dual invariant term +vanishes because the global representation is not virtually solvable. +The global completed local ring therefore has dimension at least +$5+2-3=4$. The characteristic-zero dimension comparison in +Lemma~\ref{lem:curve-completion} then gives a horizontal integral +component through the target in the original chart of dimension at +least five. + +Contract that component to its global trace and local subcharacter +values. On the absolutely irreducible locus the only positive +dimensional fibers are conjugacy fibers, of dimension three. The local +characters are distinct on a dense open set, so recording the character +does not leave an extra moving-line fiber there. The dimension +comparison of Lemma~\ref{lem:dimension-comparison} gives a domain +$\mathscr D$ of dimension at least two. Properness of the invariant-line +incidence preserves the recorded subcharacter condition on the +irreducible locus. Theorem~\ref{thm:potential-promodularity}, applied to +an unrestricted framed component containing this family, gives one +common $F$ and one tame level with the asserted trace support. + +We give the finiteness argument, including the recorded character. +Write $T_{\mathscr D}$ for the trace of the family. +Let $A\subset\mathscr D$ be the closed restricted trace image, and let +$q=[G_{\QQ}:G_F]$. For every $g\in G_{\QQ}$, $g^q\in G_F$ after +replacing $q$ by the order of the finite quotient if necessary. +The identity +\[ + T_{\mathscr D}(g^q)=P_q\bigl(T_{\mathscr D}(g),\chi(g)\bigr) +\] +has $P_q(X,Y)$ monic of degree $q$ in~$X$. Hence every downstairs +trace is integral over~$A$. A local character value satisfies +\[ + \eta_1(g)^2-T_{\mathscr D}(g)\eta_1(g)+\chi(g)=0, + \qquad g\in G_{\QQ_2}, +\] +and is integral as well. The global determinant algebra has finitely +many topological trace generators, and a continuous local character is +determined topologically by its values on the uniformizer, $-1$, and~$5$. +Adjoining these finitely many integral elements to~$A$ gives a finite +complete algebra, hence a closed subalgebra of~$\mathscr D$; it contains +its topological generators and is all of~$\mathscr D$. +Finally, Proposition~\ref{prop:block-comparison} makes the Hecke algebra +finite over the product of the local central pseudodeformation images. +Transitivity of finiteness proves the last assertion. +\end{proof} + +We may discard the proper globally reducible loci, including reducibility +after restriction to~$F$. We may also require +\begin{equation}\label{eq:generic-ordinary-ratios} + \eta_1\eta_2^{-1}\notin\{1,\eps,\eps^{-1}\}. +\end{equation} +Indeed, each exceptional equality and the fixed determinant imply +$\eta_1^2=\chi\eps^a$ for $a\in\{0,1,-1\}$. The local trace image +then has dimension at most one: its character values are integral over +the fixed coefficient ring. Because $2$ splits in~$F$ and the family +comes from~$\QQ$, the same holds at all dyadic factors. Finiteness in +Lemma~\ref{lem:ordinary-character-family} shows that none of these loci +contains $\Spec\mathscr D$. Characteristic-zero points with finite +coefficient fields satisfying these conditions are consequently dense. + +\subsection{The ordinary torsion module} + +We now have a family carrying both global traces and the chosen local +character. To control its character parameter, we construct a torsion +space on which the traces and torus act jointly. Its finiteness over +torus weight space will constrain the dimension of $\mathscr D$. + +Fix the Hecke summand of the completed forms over~$F$ carrying the +restricted family, and write +$\mathcal H$ for its torsion function space with coefficients +$\EE/\OO$. Put +\[ + G_2=\prod_{v\mid2}\GL_2(\QQ_2),\quad + N_0^-=\prod_{v\mid2}n^-(\ZZ_2),\quad + T_1=\prod_{v\mid2}(1+4\ZZ_2)^2, +\] +where +\[ + n^-(a)=\begin{pmatrix}1&0\\a&1\end{pmatrix},\qquad + n^+(x)=\begin{pmatrix}1&x\\0&1\end{pmatrix},\qquad + \mathbf p=\bigl(\operatorname{diag}(1,2)\bigr)_{v\mid2}. +\] +All matrix formulas involving several places are interpreted +coordinatewise. On $\mathcal H^{N_0^-}$ define +\begin{equation}\label{eq:ordinary-U} + U=\sum_{a\in(\ZZ/2\ZZ)^{[F:\QQ]}}n^-(a)\mathbf p. +\end{equation} +The actions are the right translation actions with the representation +group law. Let +\[ + W=\{f\in\mathcal H^{N_0^-}:U^Nf=f\text{ for some }N>0\}, + \qquad M=W^\vee, + \qquad \Omega=\OO[[T_1]]. +\] +The dual is the compact Pontryagin dual. We transpose the commuting +operator actions without inversion, so their scalar eigenvalues retain +the conventions above. + +\begin{proposition}[Ordinary weight finiteness] +\label{prop:ordinary-weight-finiteness} +The space $W$ is an $\OO$-submodule stable under $T_1$, the tame Hecke +operators, and $U^{\pm1}$, and these actions commute. Its dual $M$ is +finite over~$\Omega$. The closed commutative algebra generated by these +actions on~$M$ is finite over~$\Omega$. +\end{proposition} +\begin{proof} +In one factor the identity +\begin{equation}\label{eq:U-representatives} + n^-(a+2b)\operatorname{diag}(1,2) + =n^-(a)\operatorname{diag}(1,2)n^-(b) +\end{equation} +proves independence of representatives and preservation of lower +invariance. Conjugation by $t=\operatorname{diag}(u_1,u_2)\in T_1$ +replaces $a$ by $(u_2/u_1)a$, which permutes the residue classes. +Thus $tU=Ut$ on the lower-invariant space. The tame Hecke actions commute +with these local actions. A common multiple of two periods is a period +of the sum of the corresponding vectors. Finally $U$ is bijective +on~$W$: on a vector of period $N$, its inverse is $U^{N-1}$, independently +of the chosen period. + +We show that one compact open subgroup fixes $W[\varpi]^{T_1}$. +For $j\ge2$, $x\in2^j\ZZ_2$, and $a\in\ZZ_2$, direct multiplication +gives +\begin{align} + n^+(x)n^-(a)\operatorname{diag}(1,2) + ={}&n^-\!\left(\frac{a}{1+xa}\right) + \operatorname{diag}(1,2)\notag\\ + &\cdot\operatorname{diag}(1+xa,(1+xa)^{-1}) + n^+\!\left(\frac{2x}{1+xa}\right). + \label{eq:U-upper-improvement} +\end{align} +If $f$ is $T_1$-fixed and upper-$2^{j+1}$-invariant, the final two +factors fix~$f$. The map $a\mapsto a/(1+xa)$ permutes the lower +residue classes, and \eqref{eq:U-representatives} absorbs the changes +of lift. Thus $Uf$ is upper-$2^j$-invariant. Once upper-$4$ invariance +is reached, it is preserved by the same identity. + +Each smooth vector of $W[\varpi]^{T_1}$ starts at some finite upper +level. Iterate the preceding improvement far enough, taking an +iteration number divisible by its period. The resulting vector is the +original vector, so it is fixed by the single open compact subgroup +generated by $N_0^-$, $T_1$, and $\prod_{v\mid2}n^+(4\ZZ_2)$. +Proposition~\ref{prop:completed-forms} gives smooth admissibility; +therefore $W[\varpi]^{T_1}$ is finite-dimensional over~$\kk$. +Compact Nakayama now gives finite generation of~$M$ over~$\Omega$. + +Since $\Omega$ is noetherian and $M$ is finite, $\End_\Omega(M)$ is +finite over~$\Omega$. The closed algebra in the statement is an +$\Omega$-submodule of this finite module, and hence is finite too. +\end{proof} + +Let $R$ denote the fixed-determinant global pseudodeformation ring +over~$F$. The trace and torus actions define +\[ + Q=R\widehat\otimes_{\OO}\Omega + \longrightarrow\End_\Omega(M). +\] +Write $S$ for its image. It is finite over~$\Omega$ and is closed: +the source is compact and the target is Hausdorff. The larger action +algebra in Proposition~\ref{prop:ordinary-weight-finiteness}, denoted +by~$\mathcal A$, is finite over~$S$ and contains both $U$ and $U^{-1}$. + +\subsection{Finite joint images and the weight map} + +Set +\[ + \Lambda=\OO[[1+4\ZZ_2]]\simeq\OO[[T]],\qquad + [5]=1+T. +\] +The map $\Lambda\to\mathscr D$ sends $[5]$ to $\eta_1(5)$, using local +reciprocity. At each place of~$F$ above~$2$, there are two possible +inducing assignments +\begin{equation}\label{eq:two-ordinary-orders} + (\eta_1\eps,\eta_2),\qquad (\eta_2\eps,\eta_1). +\end{equation} +For each choice $s$ of an assignment at every dyadic place, the fixed +determinant and these formulas define a homomorphism +$s:\Omega\to\Lambda$. Only characters on $1+4\ZZ_2$ enter this map; +the unramified character values remain in the trace algebra. + +\begin{lemma}[Finite joint-image argument]\label{lem:joint-image} +Let $\mathscr D$ be the domain of +Lemma~\ref{lem:ordinary-character-family}, let $M=W^\vee$ be the +ordinary module above, and use the weight map +$\Lambda\to\mathscr D$ defined by $[5]\mapsto\eta_1(5)$. +Suppose a dense set of finite-coefficient characteristic-zero points +of~$\mathscr D$ occurs in the joint trace-and-weight support of~$M$, +with one of the finitely many assignments~$s$ in +\eqref{eq:two-ordinary-orders} at each point. Then +$\mathscr D$ is finite and dominant over~$\Lambda$; in particular, +$\dim\mathscr D=2$. +\end{lemma} +\begin{proof} +For each $s$, form $S_s=S\widehat\otimes_{\Omega,s}\Lambda$, and let +$T_s$ be the image of $R\widehat\otimes_{\OO}\Lambda$ in~$S_s$. +Both are finite $\Lambda$-algebras, and their images are closed. Let +$I_s$ be the kernel of the latter map. Each point in the dense set +kills some $I_s$ after mapping to~$\mathscr D$. Hence +\[ + \Spec\mathscr D=\bigcup_s V(I_s\mathscr D). +\] +The spectrum is irreducible, so one of these finitely many closed sets +is the whole spectrum. Equivalently, the prime kernel of +$R\widehat\otimes\Lambda\to\mathscr D$ contains one~$I_s$. +The closed trace-plus-weight image $B$ in~$\mathscr D$ is therefore a +quotient of~$T_s$ and is finite over~$\Lambda$. + +By Lemma~\ref{lem:ordinary-character-family}, $\mathscr D$ is finite +over the restricted trace image $A$, and $A\subset B$. The same finite +set of $A$-module generators generates $\mathscr D$ as a $B$-module. +Thus $\mathscr D$ is finite over~$\Lambda$. Its dimension is at least +two, whereas $\dim\Lambda=2$; a nonzero prime kernel in the domain +$\Lambda$ would lower that dimension. The map is therefore injective, +and the dimension is exactly two. +\end{proof} + +The hypotheses of the lemma hold here. At each finite-coefficient +characteristic-zero point outside the excluded loci, +Proposition~\ref{prop:block-comparison} +supplies a Banach subrepresentation of completed forms whose local +factors are unitary continuous inductions in one of the orders +\eqref{eq:two-ordinary-orders}; the two possibilities are precisely +those of \cite[Corollary~6.10(3)]{PaskunasTung2021} +for the normalized parameter $r\otimes\eps$. +In $\Ind_B^{\GL_2(\QQ_2)}(\delta_1\otimes\delta_2)$, with $B$ the +upper Borel and unnormalized induction, take the function supported +on $Bn^-(\ZZ_2)$ and equal to~$1$ on $n^-(\ZZ_2)$. +It is lower-invariant and has torus character $(\delta_1,\delta_2)$. +Subdivision into the two lower disks shows that its $U$-eigenvalue is +$\delta_2(2)$, a unit. The product vector has the analogous properties +at all dyadic places. + +Its nonzero image in completed forms can be scaled into the integral +lattice. Modulo every power of the coefficient uniformizer its unit +eigenvalue has finite multiplicative order, so the reduction belongs +to~$W$. Duality consequently places this trace-and-weight point in +$\Spec S$. Finite coefficient extension is harmless, either by flat +extension of the torsion space or by taking scalar coordinates. +Lemma~\ref{lem:joint-image} applies. + +Thus the family is finite and dominant over the one-variable weight +space. We can now choose a dense set of character values there and +lift them to the family. At these points the local extension will +satisfy the ordinary modularity theorem after the normalization and +dualization described next. + +\subsection{A dense set of ordinary modular points} + +Let $w=\operatorname{exp}(\chi)$. After a finite extension of~$\EE$, +choose $c$ with $c^2=5^{w+1}$. Consider weights +\begin{equation}\label{eq:translated-torsion-weights} + \eta_1(5)=c\zeta, + \qquad \zeta\in\mu_{2^\infty}. +\end{equation} +These are continuous characters of $1+4\ZZ_2$: this group is procyclic +with generator~$5$, and $c\zeta$ lies in the open unit neighborhood +of~$1$ in its finite coefficient field. We are specifying a character +value, not asserting that $(w+1)/2$ is an integral Hodge--Tate weight. + +The weights in \eqref{eq:translated-torsion-weights} are Zariski dense +in~$\Spec\Lambda$. Indeed, after dividing by its maximal scalar power, +a nonzero element of $\OO[[T]]$ is a unit times a distinguished +polynomial by Weierstrass preparation and has only finitely many zeros +in the open unit disk. Finite dominance then gives a dense set of +coefficient points of~$\mathscr D$ above these weights, even after +removing any prescribed proper closed subset. To see the last assertion +directly, a nonzero ideal of the finite integral domain $\mathscr D$ +meets~$\Lambda$ nontrivially: an integral equation of minimal degree for +a nonzero element of the ideal has nonzero constant term. Thus every +proper closed subset has proper closed image in~$\Spec\Lambda$. + +On inertia, the ratio at these points has the form +\begin{equation}\label{eq:ordinary-ratio-xi} + \eta_1\eta_2^{-1}=\eps\xi, +\end{equation} +where $\xi$ has finite order. This follows from +$\eta_1^2/\chi$ on $1+4\ZZ_2$, and the remaining unit quotient is +finite. The finite part of $\chi$ is fixed; at most finitely many +choices of~$\zeta$ make $\xi$ trivial. We discard them, as well as the +globally reducible loci before and after restriction to~$F$. + +There is a single continuous normalizing character over the family. +The character $\eta_2$ on inertia factors through the local unit group +$\ZZ_2^\times$ by local class field theory. Denote this unit character +by $\eta_{2,\mathrm{u}}$, and put +\begin{equation}\label{eq:normalizing-character} + \lambda(g)=\eta_{2,\mathrm{u}}\bigl(\eps(g)\bigr)^{-1}, + \qquad g\in G_{\QQ}. +\end{equation} +This character is continuous and unramified outside~$2$. At a point +chosen above, write $r'=r_x\otimes\lambda_x$ and +$\eta'_j=\eta_{j,x}\lambda_x$. Then +\begin{equation}\label{eq:normalized-ordinary-characters} + \eta'_1=u_h\xi\eps, + \qquad\eta'_2=u_l, +\end{equation} +with $u_h,u_l$ unramified and $\xi$ of nontrivial finite inertia. + +\begin{lemma}\label{lem:dense-Thorne-points} +Every representation $r'$ just constructed is odd, absolutely +irreducible, finitely ramified, ordinary, and potentially crystalline +with cyclotomic exponents $\{1,0\}$. It is modular. +\end{lemma} +\begin{proof} +The two diagonal characters in +\eqref{eq:normalized-ordinary-characters} are de Rham. Their ratio +$\theta=(u_h/u_l)\xi\eps$ has +$H^0(\theta)=H^0(\theta^{-1}\eps)=0$, the latter because the finite +inertial character is nontrivial. Thus \eqref{eq:rank-one-euler} gives +$\dim H^1(\QQ_2,\theta)=1$. In +\eqref{eq:rank-one-geometric} the de Rham tangent term has dimension +one, while the other two terms vanish. Hence every extension class +belongs to $H^1_g$ and $r'$ is de Rham. + +The $p$-adic monodromy theorem makes it potentially semistable +\cite[Theorems~0.6 and~5.19]{Berger2002}. Its two finite inertial +characters are distinct. Monodromy commutes with inertia, so it +preserves their two eigenspaces; it vanishes on each by nilpotence. +Thus it is potentially crystalline. + +Twisting preserves absolute irreducibility and finite ramification. +For a complex conjugation $c_\infty$, $\lambda(c_\infty)^2=1$, so +the determinant remains odd. Finally, in the convention +$\HT(\eps)=-1$, the dual has weights $\{0,1\}$ and ordinary shape +\[ + (r')^\vee|_{\GQtwo}\sim + \begin{pmatrix} + u_l^{-1}&*\\0&\eps^{-1}u_h^{-1}\xi^{-1} + \end{pmatrix}. +\] +All the hypotheses of \cite[Theorem~D]{Thorne2026} are now satisfied. +That theorem makes the dual modular, and hence makes $r'$ modular. +\end{proof} + +The modular representations in this lemma have a common bound for +their tame conductors. Indeed, the original noetherian Galois family +has, at each non-dyadic bad prime, a common open inertia subgroup on +which its action is unipotent, as in +Lemma~\ref{lem:inertia-basechange}. The finite inertial quotient is +fixed, and the rank-two monodromy contribution is bounded. This bounds +the Artin conductor after the fixed base change to~$F$. +The normalizing characters add no non-dyadic inertia. Consequently, +after replacing the tame compact subgroup by one smaller subgroup, +all these modular forms occur at a single tame level. Solvable base +change, iterated through prime-degree cyclic extensions, and +Jacquet--Langlands put them in the definite forms over~$F$; +see \cite[Chapter~11, Lemma~11.3 and Proposition~11.4]{Langlands1980}, +\cite[Chapter~III, Theorems~4.2 and~5.1]{ArthurClozel1989}, and +\cite[Theorem~16.1]{JacquetLanglands1970}. + +\subsection{The required inducing order} + +We next track the order at the dense modular points, rather than +selecting it from a semisimple Banach fiber. In the geometric +reciprocity convention $\eps=x|x|$, one has $\WD(\eps)=|\cdot|$. +For the normalized characters \eqref{eq:normalized-ordinary-characters}, +the two characters of $\WD(r'\otimes\eps)$ are +\[ + \theta_h=u_h\xi|\cdot|^2, + \qquad\theta_l=u_l|\cdot|. +\] +Here the same notation for a finite or unramified character denotes +its character under local reciprocity. A regular algebraic Hilbert +form on $\GL_2$ is essentially self-dual via its central character. +Local--global compatibility +identifies the smooth principal series: the underlying semisimple Weil +representation has these distinct inertial characters, and no +monodromy can join them. This also follows from the compatibility up +to the monodromy order of +\cite[Corollary~1.2]{BLGGTLocalGlobal2014}, since that order preserves +the underlying semisimple Weil representation and monodromy is zero +in this case. + +In the conventions of Proposition~\ref{prop:block-comparison}, put the +smooth inducing characters in the order +\[ + (\theta_l,\theta_h|\cdot|^{-1}) + =(u_l|\cdot|,u_h\xi|\cdot|). +\] +The algebraic factor at cyclotomic exponents $\{1,0\}$ is $\det$. +Multiplication by that factor changes the pair to +\[ + (u_l\eps,u_h\xi\eps) + =(\eta'_2\eps,\eta'_1). +\] +For unnormalized smooth induction, the intertwiner changes an inducing +pair $(A,B)$ to $(B|\cdot|,A|\cdot|^{-1})$. The two orders here are +therefore intertwined with the appropriate modulus factors, with no +exceptional ratio because their inertial characters differ. +Equivalently, this is the +weight-two instance of the ordinary universal completion formula +\cite[Proposition~2.2.1]{BreuilEmerton2010}; that proposition applies +at~$2$ and concerns the locally algebraic induction. +In particular, the lower-disk vector used above already belongs to +this locally algebraic representation. + +Undo the twist by multiplying definite functions by +$\lambda_x^{-1}$ evaluated on the reduced norm, via global reciprocity. +Rational reduced norms are totally positive, so this is well-defined +on the definite quotient. It changes the central character back to +$\chi\eps$ and changes the inducing assignment to +\begin{equation}\label{eq:favorable-ordinary-order} + (\eta_2\eps,\eta_1) + \quad\text{at every }v\mid2. +\end{equation} +Lower invariance is preserved, and the $U$-eigenvalue is multiplied by +a unit. All dyadic places have the same order because they are split +over~$\QQ$ and the family and normalizing character descend from~$\QQ$. + +At this common tame level, let $M$ and $S$ again denote the ordinary +dual and its joint trace-and-weight image algebra. Write +$s_{\mathrm{fav}}:\Omega\to\Lambda$ for the single assignment +\eqref{eq:favorable-ordinary-order}, and set +\[ + S_{\mathrm{fav}} + =S\widehat\otimes_{\Omega,s_{\mathrm{fav}}}\Lambda, + \qquad + I_{\mathrm{fav}} + =\ker\bigl(R\widehat\otimes_{\OO}\Lambda + \longrightarrow S_{\mathrm{fav}}\bigr). +\] +Let $T_{\mathrm{fav}}$ be the image of this map. The untwisted vectors +just constructed show that $I_{\mathrm{fav}}$ vanishes at the dense +family points used in Lemma~\ref{lem:dense-Thorne-points}. Its image +in the domain $\mathscr D$ is therefore zero. In particular, the +original target defines a coefficient point of $T_{\mathrm{fav}}$, +including when its local character ratio satisfies one of the +exceptional equalities excluded from the dense testing set. + +The algebra $S_{\mathrm{fav}}$ is finite over $T_{\mathrm{fav}}$, +so lying over lifts this point to $S_{\mathrm{fav}}$ after a finite +coefficient extension. Its restriction to $S$ has the target trace +and the torus character prescribed by $s_{\mathrm{fav}}$. +Since $M$ is finite over $S$ and the $S$-action is faithful, +$\Supp_S M=\Spec S$. Thus this point belongs to the joint +trace-and-weight support needed below. + +The favorable character order has now reached the target. To use it +in a classicality argument, we still need a nonzero vector carrying +that order. The next step obtains one from a scalar quotient of the +finite action module, without assuming that ordinary vectors or locally +algebraic vectors commute with specialization. + +\subsection{Specialization to a genuine vector} + +\begin{lemma}[Eigenvector specialization] +\label{lem:eigenvector-specialization} +Let $S$ be the joint trace-and-weight image algebra acting on $M=W^\vee$ +at the fixed tame level above, and let $\mathcal A$ be its finite faithful +action algebra containing $U^{\pm1}$, as in +Proposition~\ref{prop:ordinary-weight-finiteness}. Let a +finite-coefficient characteristic-zero point of $\Spec S$ belong to +the support of $M$. After a finite coefficient extension it gives a +nonzero vector in completed forms with the +specified trace and torus eigencharacters, invariant under~$N_0^-$, +and with a unit $U$-eigenvalue. +\end{lemma} +\begin{proof} +The algebra $\mathcal A$ containing $U^{\pm1}$ is finite over~$S$. +Since it is the faithful action algebra of~$M$, and $M$ is finite over +it, its spectrum is the support of~$M$. Lying over the given point +and passing to a finite coefficient field $E'$ therefore gives a +joint scalar quotient of $M[1/2]$. Write $\OO'$ for its ring of +integers, with uniformizer~$\varpi'$. + +The corresponding nonzero map +\[ + M\otimes_{\OO}\OO'\longrightarrow E' +\] +is continuous. Indeed, $M$ is finite over weight space and its weight +values lie in the formal open unit disk. Its image is a compact +$\OO'$-submodule spanning $E'$, hence a lattice; rescale it to~$\OO'$. +The scalar actions preserve this lattice. In particular the +$U$-eigenvalue is a unit because $U^{-1}$ preserves it as well. + +Applying $\OO'$-linear Pontryagin duality, with values in $E'/\OO'$, +produces an equivariant injection +\[ + E'/\OO'\lhook\joinrel\longrightarrow + W_{\OO'}\subset\mathcal H_{\OO'}. +\] +The image $f_n$ of $\varpi'^{-n}$ has exact order $\varpi'^n$ and +satisfies $\varpi'f_{n+1}=f_n$. Taking the Tate module gives a nonzero +continuous integral completed-forms vector. Explicitly, a compatible +sequence of continuous functions modulo $\varpi'^n$ determines a +continuous $\OO'$-valued function, because each of its reductions is +continuous; conversely every such integral function gives that +sequence. Exact orders ensure that the resulting vector is nonzero. +All Hecke and torus eigenrelations, lower invariance, and the +$U$-eigenrelation pass to this inverse limit. This construction finds +a divisible copy inside~$W$; it does not require $W$ itself to be +divisible. +\end{proof} + +Apply the lemma to the target. Its torus eigencharacter, restricted +to a sufficiently small open subgroup, is algebraic with exponents +$e_{1,v},e_{2,v}$ satisfying +\begin{equation}\label{eq:nonnegative-algebraic-degree} + e_{2,v}-e_{1,v} + =\operatorname{exp}(\eta_1)-\operatorname{exp}(\eta_2)-1\ge0. +\end{equation} +The inequality follows from the choice of the higher line and the +integrality and distinctness of the target weights. +We have therefore obtained a genuine ordinary eigenvector whose torus +exponents have the order needed for an algebraic representation. It +remains to identify the algebraic form of its orbit on a sufficiently +small open subgroup. + +\subsection{A unit ordinary vector is locally algebraic} + +\begin{lemma}\label{lem:polynomial-orbit} +Let $V$ be a continuous unitary Banach representation of~$G_2$ over a +finite extension $E'/\QQ_2$. Suppose $0\ne f\in V$ is fixed by +$N_0^-$, has torus character with integral exponents +$e_{1,v},e_{2,v}$ on a sufficiently small open subgroup, and satisfies +$Uf=\alpha f$ with $\alpha\in\OO'^\times$. If +$\delta_v=e_{2,v}-e_{1,v}\ge0$ for all~$v$, then $f$ is locally +algebraic, of algebraic type +\[ + A=\bigotimes_{v\mid2} + \det^{e_{1,v}}\operatorname{Sym}^{\delta_v}(E'^2). +\] +\end{lemma} +\begin{proof} +Choose $m\ge2$ so the stated torus character holds on +$\prod_v(1+2^m\ZZ_2)^2$, and put +$X=(2^m\ZZ_2)^{[F:\QQ]}$. Lower invariance gives +\[ + U^jf=\sum_{b\bmod 2^j}n^-(b)\mathbf p^jf, +\] +independently of the integral lifts of~$b$. For $x\in X$ the map +$a\mapsto a/(1-xa)$ permutes these residue classes. With +$c=1-xa$, direct matrix multiplication gives +\begin{equation}\label{eq:polynomial-Gauss} + n^+(x)n^-\!\left(\frac a{1-xa}\right)\mathbf p^j + =n^-(a)\mathbf p^j + \operatorname{diag}(c^{-1},c)n^+(2^jxc). +\end{equation} +Define the $V$-valued polynomial +\[ + P_j(x)=\alpha^{-j}\sum_{a\bmod2^j} + \prod_v(1-x_va_v)^{\delta_v}\, + n^-(a)\mathbf p^jf. +\] +Its multidegree is bounded by~$\delta$. Use a $G_2$-invariant +nonarchimedean norm on~$V$. The torus eigenrelation, +\eqref{eq:polynomial-Gauss}, and the ultrametric inequality give +\begin{equation}\label{eq:polynomial-uniform-error} + \sup_{x\in X}\|n^+(x)f-P_j(x)\| + \le \sup_{y\in(2^{j+m}\ZZ_2)^{[F:\QQ]}} + \|n^+(y)f-f\|\longrightarrow0. +\end{equation} +There is no factor for the number of residue classes: the norm of a +sum is bounded by the largest norm of a summand. The unit eigenvalue +and unitarity also introduce no growing factor. Continuity at the +identity proves the final convergence. + +For each~$v$, choose $\delta_v+1$ distinct points in $2^m\ZZ_2$. +Evaluation on their product grid and inversion of the resulting +Vandermonde matrices recover all coefficients of a polynomial of +multidegree at most~$\delta$, continuously in its values. This +polynomial space is therefore closed in $C(X,V)$. +Equation~\eqref{eq:polynomial-uniform-error} implies +\begin{equation}\label{eq:upper-orbit-polynomial} + n^+(x)f=\sum_{0\le\nu\le\delta}x^\nu v_\nu. +\end{equation} + +For completeness, we identify an algebraic representation containing +the resulting orbit. Put +$H=\prod_v(1+2^mM_2(\ZZ_2))$ and write +$h_v=\left(\begin{smallmatrix}A_v&B_v\\C_v&D_v\end{smallmatrix}\right)$. +Its Gauss decomposition is +\[ + h_v=n^+(B_v/D_v) + \operatorname{diag}(\det(h_v)/D_v,D_v)n^-(C_v/D_v). +\] +Every factor lies in the neighborhoods already considered. Hence +\begin{equation}\label{eq:algebraic-orbit-coefficients} + hf=\sum_{0\le\nu\le\delta} + \prod_v\det(h_v)^{e_{1,v}} + B_v^{\nu_v}D_v^{\delta_v-\nu_v}\,v_\nu. +\end{equation} +These are regular algebraic functions on~$G_2$, also when some +$e_{1,v}$ is negative, since powers of the determinant are invertible +in its coordinate ring. + +Let $z_0=\bigotimes_ve_2^{\delta_v}\in A$, with the determinant +factors understood. In the binomially scaled monomial basis $E_\nu$ +of~$A$, one has $n^+(x)z_0=\sum_\nu x^\nu E_\nu$. +Define $\Theta:A\to V$ by $\Theta(E_\nu)=v_\nu$. +Formula~\eqref{eq:algebraic-orbit-coefficients} says +$\Theta(hz_0)=hf$ for $h\in H$. +The vectors $kz_0$, $k\in H$, span~$A$, by the same upper-unipotent +interpolation. Thus +\[ + \Theta(hkz_0)=hkf=h\Theta(kz_0),\qquad h,k\in H, +\] +proves that $\Theta$ is $H$-equivariant. Since $H$ is Zariski dense, +its invariant subspace $\ker\Theta\subset A$ is an algebraic +subrepresentation. The representation $A$ is irreducible and +$\Theta(z_0)=f\ne0$, so $\Theta$ is injective. Its image contains~$f$ +and has algebraic type~$A$. This proves local +algebraicity without any assertion that algebraic vectors commute +with specialization. +\end{proof} + +The vector of Lemma~\ref{lem:eigenvector-specialization} meets these +hypotheses by \eqref{eq:nonnegative-algebraic-degree}. It is therefore +a nonzero locally algebraic vector with the target eigensystem. + +\subsection{Completion of the proof over \texorpdfstring{$\QQ$}{Q}} + +If $r|_{\GQtwo}$ is absolutely irreducible, the preceding ordinary +argument is unnecessary. Proposition~\ref{prop:block-comparison} +and the local correspondence give nonzero locally algebraic vectors +in the target eigenmodule: for an absolutely irreducible parameter, +regular de Rham is exactly the required condition +\cite[Theorems~1.1 and~1.3]{CDP2014}, +\cite[Theorem~0.20]{Colmez2010}. The all-prime correspondence covers +the scalar residual case at~$2$. Since $2$ splits completely in~$F$, +this applies at every dyadic factor. +The parameter in this application is $r\otimes\eps$. We translate +the opposite Hodge--Tate sign convention in these local correspondence +sources using cyclotomic exponents, obtaining the algebraic factor fixed +in Proposition~\ref{prop:block-comparison}. + +In either local case, the definite-forms comparison of +Proposition~\ref{prop:completed-forms} now gives a regular algebraic +automorphic eigensystem on the definite quaternion algebra over~$F$. +It cannot be a reduced-norm character, since its global Galois +representation is absolutely irreducible. Jacquet--Langlands therefore +gives a regular algebraic Hilbert cusp form +\cite[Theorem~14.4]{JacquetLanglands1970}. Its Galois representation +exists at~$2$ by \cite[Theorem~2.1.1]{BLGGT2014} and agrees with +$r|_{G_F}$ by the unramified Hecke identities and Chebotarev. + +Finally choose a tower of prime-degree cyclic extensions from~$\QQ$ to a solvable +Galois closure of~$F$, replacing $F$ by that closure if needed. +At each stage the Hilbert representation upstairs is invariant under +the cyclic Galois group: its conjugates have the same unramified +eigensystems because the Galois representation extends downstairs, so +strong multiplicity one identifies them +\cite[Chapter~3, Lemma~3.1]{Langlands1980}. Cyclic descent supplies a +cuspidal representation downstairs, unique up to characters of that +cyclic extension +\cite[Chapter~III, Theorems~4.2(d) and~5.1]{ArthurClozel1989}; see also +the original degree-two construction in +\cite[Chapter~11, Lemma~11.3 and Proposition~11.4]{Langlands1980}. +When needed, apply the cited unitary formulation after twisting by a +power of the idelic norm, and undo that twist after descent. Every +real place splits in the totally real extension, so the corresponding +local extension is $\mathbb R/\mathbb R$; archimedean base change +therefore preserves the regular algebraic real-place type. +The Galois representation of the descended packet and the given +representation become isomorphic on +restriction upstairs; absolute irreducibility of that restriction +implies that they differ by a character of the cyclic quotient. +Twist the descended automorphic representation by the inverse finite +Hecke character to correct this difference, and continue down the +tower. Over~$\QQ$ the resulting representation is attached to a +classical cusp eigenform, with the Tate twist dictated by the original +weights. This proves Theorem~\ref{thm:main}. diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/completed_forms.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/completed_forms.tex new file mode 100644 index 0000000000000000000000000000000000000000..7e1c6835d06af4d67d6fe5a31a1c709f767457a3 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/completed_forms.tex @@ -0,0 +1,786 @@ +\section{Completed forms and their local parameters}\label{sec:completed} + +In this section \(F,S,\chi,\psi\) have the meaning fixed in +Section~\ref{sec:preliminaries}. We construct completed forms and +identify their integral local-block action with the restriction of +the global Galois action. This comparison gives finiteness over the +local pseudodeformation base and describes the Banach coefficient +fibers needed for classicality. We then prove a lower bound on every +Hecke component and exact auxiliary-level identities preserving the +old deformation action; these are the inputs to patching. All local +groups at \(2\) +are \(\GL_2(\mathbb Q_2)\), since \(2\) splits completely in \(F\). + +\subsection{Integral forms and classical density} + +Fix an open tame level \(U^2\), hyperspecial outside \(S\). +We may also prescribe a finite-order transformation character +at the tame level, compatible with the central character. +Write \(\widetilde S_\psi(U^2,\OO)\) for the continuous +\(\OO\)-valued functions on +\[ + D_F^\times\backslash(D_F\otimes_F\mathbb A_F^\infty)^\times +\] +with the prescribed right tame transformation and central +transformation \(f(gz)=\psi(z)f(g)\). Its scalar extension to +\(E\) is a unitary Banach representation of +\[ + G_2=\prod_{v\mid2}\GL_2(F_v). +\] +The torsion version has values in \(E/\OO\) and is smooth. +The compact dual of the integral space is denoted by \(M\); +equivalently, it is the Pontryagin dual of the torsion space. +We also use this notation for a residual Hecke summand. + +\begin{proposition}\label{prop:completed-forms} +For the tame level \(U^2\), central character \(\psi=\chi\eps\), +and full compact forms module \(M\) just defined, the following +properties hold. In the second assertion weights and local parameters +use the normalization of Section~\ref{sec:preliminaries}. +\begin{enumerate} +\item For a sufficiently small product \(K\) of uniform open +subgroups of \(\SL_2(F_v)\), the full compact module \(M\) +is finite free over \(\OO[[K]]\). The integral and torsion +function spaces are admissible and commute with reduction +of coefficients. +\item Locally algebraic vectors are classical definite +quaternionic forms of the corresponding algebraic weight. +Their regular noncharacter eigenpackets transfer to Hilbert +cuspidal eigenforms. They have Galois representations of +determinant \(\chi\), with the local compatibility described +below. +\item The regular classical vectors are dense in the Banach +space. They remain dense if, at each \(v\mid2\), one fixes a +smooth principal-series type with two distinct inertial +characters and varies the algebraic factor with the +prescribed central degree. +\item Every residual local factor \(\mathbb T\) of the +completed Hecke algebra away from \(S\) is a complete quotient +of \(R_F^{\mathrm{ps},\chi}\). It is reduced and +\(\OO\)-torsion-free, and its spectrum is the closure of its +classical coefficient points. +\end{enumerate} +\end{proposition} +\begin{proof} +Finiteness of quaternion ideal classes gives finitely many double +cosets at compact open level \cite[Main Theorem~17.7.1]{Voight2021}; +passing to a smaller compact level has finite fibers. Stabilizers +modulo the center are finite as well. Their reduced norms have even +valuation at every finite place. The group +\[ + \{a\in F^\times:v(a)\in2\mathbb Z\text{ for every finite }v\} + /(F^\times)^2 +\] +is finite: the class of the half-valuation ideal maps it to +\(\operatorname{Cl}(F)[2]\), with kernel given by unit squareclasses, +and both groups are finite \cite[Theorems~4.4 and~5.1]{MilneANT}. +The kernel of reduced norm modulo squares has, after scalar +rescaling, norm-one representatives in a fixed compact subgroup; +these are finite by total definiteness +\cite[Lemma~17.7.13]{Voight2021}. Shrink \(K\) until +it meets none of these finite projective stabilizers +nontrivially. Choosing local sections for the central and +tame transformations identifies the function space with +continuous functions on a finite disjoint union of copies +of \(K\). Its compact dual is a finite direct sum of +\(\OO[[K]]\). This also proves admissibility and exact +coefficient reduction. Compatibility of the transformation +characters on their intersections is part of the definition; +the central character is totally even, since both \(\chi\) +and \(\eps\) are odd. + +The identification of locally algebraic vectors is the +definite double-coset description of algebraic automorphic +forms. Jacquet--Langlands transfers the regular noncharacter +packets to Hilbert cusp forms +\cite[Theorems~14.4 and 16.1]{JacquetLanglands1970}; their +Galois representations, weights and de Rhamness are given by +\cite[Theorem~2.1.1]{BLGGT2014}. At the dyadic places we use the potentially +semistable comparison, including ramified types: +\cite[Corollary~1.2]{BLGGTLocalGlobal2014}. For the principal +types used here, the two distinct inertial characters +force monodromy to be zero. Thus the local representation +is potentially crystalline and crystabelian, with the +weights specified by the algebraic factor. + +We spell out the density assertion with fixed type. +Let \(K_0=\prod_{v\mid2}\GL_2(\OO_{F_v})\). +Matrix coefficients of algebraic representations of +central degree zero form a subalgebra of the continuous +functions on \(K_0/Z(K_0)\). They contain constants and +separate points: the adjoint representation is faithful +on the projective group. Nonarchimedean polynomial +approximation, equivalently Stone--Weierstrass for this +compact totally disconnected space, makes this algebra +dense. + +Choose a nonzero smooth type \(\tau\) and an algebraic +representation \(V\) with the needed central degree. +The matrix coefficients \(a_1,\ldots,a_N\) of +\(\tau\otimes V\) have no common zero, since every +representation matrix is invertible. For a continuous +section \(f\) with the prescribed central transformation, +choose a finite clopen partition subordinate to sets on +which some \(a_i\) is bounded away from zero. The functions +\(f/a_i\) on these clopens, extended by zero, are continuous +of central degree zero. Approximate them by the algebra +just described and multiply by \(a_i\). +Every resulting product is a matrix coefficient of +\(\tau\otimes V\otimes A\), where \(A\) is algebraic of +central degree zero. Complete reducibility in characteristic +zero decomposes \(V\otimes A\) into algebraic irreducibles +of exactly the same central degree. The smooth factor +\(\tau\) is unchanged. Averaging over the finitely many +projective stabilizers gives density in the double-coset +function space; its fixed denominators cause no problem +over \(E\). + +At every dyadic factor we can choose the two inertial +characters to be distinct with the required product, +using characters of sufficiently large \(2\)-power order. +The associated compact principal-series type forces the +smooth local representation to be principal series of +that type. Here we use Henniart's compact types +\cite[Appendix~A, Sections~A.1.1--A.1.4 and A.2.3--A.2.4]{BreuilMezard2002}, +whose scope includes residue cardinality two. In particular it excludes norm characters. +The algebraic central degree is common at all embeddings, +as required for classical weights. This proves the +assertion about a dense span of regular cuspidal packets. + +\emph{The integral Hecke algebra and its residual factors.} +Form the Hecke algebra as the closure +of the integral Hecke operators in the endomorphisms of +the finite Iwasawa module. Reduction modulo its maximal +augmentation ideal gives a finite-dimensional commuting +algebra. Its topologically nilpotent kernel permits +lifting idempotents, giving finitely many residual factors. + +\emph{Interpolation as an identity of integral operators.} +We next construct a continuous Galois trace in this integral Hecke +algebra. To pass from classical traces to actual operators, we first +specify finite tests for the operator topology. Work with +the full compact module +\(M\simeq\Lambda_K^r\), where +\(\Lambda_K=\OO[[K]]\) and +\(\mathfrak a=(\varpi,\ker(\Lambda_K\to\OO))\). +The topology on \(\End_{\Lambda_K}(M)\) is its +\(\mathfrak a\)-adic matrix topology. An operator \(A\) +is zero at depth \(j\) precisely when +\(A(M)\subseteq\mathfrak a^jM\), or equivalently +when its dual kills the finite \(\OO\)-module +\[ + Q_j=\Hom_\OO(M/\mathfrak a^jM,E/\OO). +\] +Choose finitely many generators of \(Q_j\). Exact +coefficient reduction in the function model represents +them by \(\varpi^{-e_i}f_i\) modulo integral functions, +with each \(f_i\) integral. Thus the finitely many tests +\(A^\vee f_i\in\varpi^{e_i}\widetilde S_\psi(U^2,\OO)\) +detect depth \(j\). + +Approximate these \(f_i\), to the required precisions, +by finite sums of classical eigenvectors. Clear the +denominators of this finite collection once. Continuity +of the finitely many classical Galois traces then makes +the corresponding Hecke operators agree to those +precisions on the approximations whenever their Frobenius conjugacy +classes are sufficiently close. Integral Hecke operators +and their differences have norm at most one, so the +approximation errors are controlled uniformly. Hence +a Chebotarev sequence approaching any Galois conjugacy +class is Cauchy at every depth \(j\). Completeness gives +a unique integral limit, independent of the sequence; +the same finite tests prove continuity of the resulting +trace function. Restriction to the integral Hecke-idempotent +summands gives the assertion for each residual factor, +with its inherited operator topology. + +\emph{The pseudodeformation quotient and its support.} +The determinant is the fixed character \(\chi\). +The polynomial identities for a two-dimensional +determinant hold on all classical packets and hence +on their dense span. Boundedness and torsion-freeness +make these identities integral. The universal property +gives a continuous map from +\(R_F^{\mathrm{ps},\chi}\) onto the completed trace +algebra: the Frobenius traces generate its dense +subalgebra, and the source is compact. + +An operator vanishing at every classical eigenpacket +vanishes on the dense classical span, hence is zero. +Classical Hecke actions are semisimple. A nilpotent +operator therefore vanishes there, proving reducedness; +the action on integral functions proves +\(\OO\)-torsion-freeness. The same test proves the +asserted closure of the classical coefficient points. +\end{proof} + +\subsection{Blocks, integral finiteness, and Banach fibers} + +Fix a residual factor \(\mathbb T\). Extend \(k\) so that +the residual local parameters and the simple objects of +the corresponding local blocks are absolutely split. +For each \(v\mid2\), choose one representative from each simple +isomorphism class in the smooth block with central character +\(\psi_v\). Let \(P_v\) be the projective envelope of the direct +sum of their duals, taken in the compact dual category, and put +\(E_v=\End(P_v)\). This is the standard block generator of +\cite[Section~4.1]{PaskunasTung2021}. +The block parameter is the semisimplification of +\(\bar r_v\otimes\bar\eps\). +Denote the corresponding local pseudodeformation ring +by \(R_v^{\mathrm{ps}}\); its determinant is +\(\psi_v\eps=\chi_v\eps^2\). +Set +\[ + R_{\mathrm{loc}}^{\mathrm{ps}} + =\widehat\bigotimes_{v\mid2,\OO} R_v^{\mathrm{ps}}, + \qquad + E_{\mathrm{loc}} + =\widehat\bigotimes_{v\mid2,\OO} E_v, + \qquad + P=\widehat\bigotimes_{v\mid2,\OO}P_v. +\] +Untwisting by \(\eps\) identifies this local base with the +fixed-\(\chi_v\) local parameters of the global problem. + +\begin{proposition}\label{prop:block-comparison} +The residual Hecke summand belongs to the product block +just specified. The exact projective-generator functor gives +\[ + L=\Hom_{\mathrm{cts},G_2}(P,M), +\] +taken in the compact dual category of the specified product block, +with the right \(E_{\mathrm{loc}}\)-action by precomposition. It is +faithful over \(\mathbb T\), finite over +\(R_{\mathrm{loc}}^{\mathrm{ps}}\), and finite over +\(\mathbb T\). The local pseudodeformation action on \(L\) +is the restriction of the global Galois action, with the +stated cyclotomic twist. In particular, +\(\mathbb T\) is finite over \(R_{\mathrm{loc}}^{\mathrm{ps}}\). + +At a coefficient point \(x:\mathbb T\to E'\), after finite +extension of \(E'\), its Banach Hecke eigenspace contains +\[ + \widehat\bigotimes_{v\mid2}\Pi_v, +\] +where \(\Pi_v\) is an irreducible unitary Banach +representation with local parameter +\((r_x|_{G_{F_v}}\otimes\eps)^{\mathrm{ss}}\), of determinant +\(\chi_v\eps^2\), in the block normalization of +Section~\ref{sec:preliminaries}. If every local parameter is absolutely +irreducible, de Rham, and regular, the eigenspace has a +nonzero locally algebraic vector. If the untwisted +parameter at \(v\) is +\(\gamma_{1,v}\oplus\gamma_{2,v}\), with ratio outside +\(\{1,\eps,\eps^{-1}\}\), the possibilities are the +continuous unnormalized upper-Borel inductions +\[ + \Ind_B^{\GL_2(\mathbb Q_2)} + (\gamma_{i,v}\eps\otimes\gamma_{j,v}), + \qquad \{i,j\}=\{1,2\}. +\] +\end{proposition} +\begin{proof} +\emph{The one-factor input.} +We first specify the one-factor results. +The integral center map and finiteness theorem of +Pa\v{s}k\=unas--Tung apply to every block, including the +scalar residual block at \(2\) +\cite[Theorems~1.1--1.4]{PaskunasTung2021}. +In particular \(E_v\) is finite over \(R_v^{\mathrm{ps}}\); +an integral-surjectivity claim about the center is +unnecessary. More precisely, integral finiteness is Theorem~1.3; +the center comparison in Theorem~1.4 can have integral cokernel killed +by~\(2\). Their compact projective-generator +equivalence is exact. Their generic reducible and +absolutely irreducible characteristic-zero fibers are +described in \cite[Corollary~6.10 and +Proposition~6.11]{PaskunasTung2021}. +The all-prime correspondence and locally algebraic +comparison are supplied by +\cite[Theorems~1.1 and 1.3]{CDP2014} and +\cite[Theorem~0.20]{Colmez2010}. +Thus the old residual-scalar restriction at \(2\) does not +enter the present application. + +\emph{The product category.} +These statements extend to the required product category +by the argument of \cite[Lemmas~B.7--B.8]{GeeNewton2022}, +adapted from the projective group to a fixed central +character using the all-prime inputs just stated. +Here are the details. Given a smooth admissible vector, fix compact +opens in all but one factor. Its cyclic span under the +remaining factor is finitely generated and admissible, +so is finite length by +\cite[Lemma~2.3.6 and Theorem~2.3.8]{Emerton2010OrdinaryI}. +The commuting actions give a surjection from the tensor +product of the one-factor cyclic spans onto the full +cyclic span. Absolutely split simple factors tensor to +simple product objects; filtering proves finite length. +Hence the smooth product representation is locally finite. + +Apply the one-factor compact equivalences successively. +On dual finite-length objects this can be checked on simple +tensors and extended by exactness. Taking inverse limits +gives the equivalence for the compact locally finite +category, with endomorphism ring \(E_{\mathrm{loc}}\). +Admissibility gives finite multiplicities in the cosocle: +a homomorphism from a simple is detected by a nonzero +compact-fixed generating vector. There are only finitely +many simples in the block. Compact Nakayama therefore +makes \(\Hom(P,M)\) finite over \(E_{\mathrm{loc}}\). + +\emph{Identifying the actual local and global actions.} +It remains to identify the block and its central action +with the global Galois restriction. Test one factor at a +time on the dense classical principal types of +Proposition~\ref{prop:completed-forms}. Local-global +compatibility gives a regular crystabelian Galois +parameter with distinct inertial characters. +For an irreducible parameter, the universal unitary +completion of its algebraic-smooth principal series is +the corresponding Banach representation by +\cite[Theorem~4.3.1 and Corollaries~5.3.1--5.3.4]{BergerBreuil2010} +and the locally algebraic comparison in \cite{CDP2014}. +Distinct inertia excludes both equal-root and special +degeneracies. + +For an ordinary parameter with cyclotomic exponents +\(a>b\), the algebraic factor is +\[ + \operatorname{Sym}^{a-b-1} E^2\otimes\det^{b+1}. +\] +The ordinary completion theorem +\cite[Proposition~2.2.1]{BreuilEmerton2010} identifies the +relevant locally algebraic induction with a dense +subspace of the continuous unitary induction in the order +\[ + (\eta_l\eps,\eta_h), +\] +where \(\eta_h,\eta_l\) have exponents \(a,b\). +The following character calculation fixes the inducing order on the +dense ordinary test types; that order will matter again in +Section~\ref{sec:classicality}. For the precise normalization, put \(n=a-b-1\geq0\) and +\(\delta=(\eta_l\eps)\eta_h^{-1}\). Twisting by the full +unitary character \(\eta_h^{-1}\circ\det\) reduces this +induction to \(\Ind_B^{\GL_2(\QQ_2)}(\delta\otimes1)^{C^0}\). +With \(x\) the identity character and \(\eps=x|\cdot|\), +the source characters in the cited proposition, with \(k=n+2\), are +\[ + \chi_1=|\cdot|x^{-n},\qquad + \chi_2=\delta|\cdot|^{-1}x^n. +\] +Since \(\delta\) is unitary of algebraic exponent \(-n\), +both \(\chi_2\) and \((\chi_2/\chi_1)x^{-n}\) are smooth, and +\[ + v_2(\chi_1(2))=-n-1,\qquad + v_2(\chi_2(2))=n+1. +\] +The two characters in its completion formula are +\(\chi_1|\cdot|^{-1}x^n=1\) and +\(\chi_2|\cdot|x^{-n}=\delta\), in the reversed inducing +order \((\delta,1)\). Twisting back by +\(\eta_h\circ\det\) gives the displayed order and changes +the algebraic factor \(\det^{-n}\operatorname{Sym}^n\) into +\(\det^{b+1}\operatorname{Sym}^{a-b-1}\). +On each lower-coordinate disk its vectors are precisely +bounded-degree polynomial sections. The theorem concerns this +locally algebraic subspace, not the whole locally analytic induction. +When \(n=0\), the excluded equality +\(\chi_1=\chi_2|\cdot|^2\) is exactly \(\delta=1\), +which is ruled out by the distinct finite inertial characters. +The ordinary and nonordinary statements together supply +every test type used in the density argument; see also +\cite[Propositions~5.3--5.6]{PaskunasTung2021}. + +A map from such a classical constituent into completed +forms extends continuously from its universal unitary +completion. After scaling lattices, it is a bounded map +in the compact block category. Naturality of the center +then identifies the central trace action on its image +with the Galois parameter given by classical +local-global compatibility. The normalizations give +\(\rho\otimes\eps\), as stipulated above. +The dense classical span proves equality of the two +actions on the whole Banach space. Torsion-freeness of +the integral lattice gives integral equality and shows +that every other block projection vanishes. + +\emph{Integral finiteness and coefficient fibers.} +It follows from integral Pa\v{s}k\=unas--Tung finiteness +that \(L\) is finite over +\(R_{\mathrm{loc}}^{\mathrm{ps}}\). +Exactness and the equivalence imply that the action of +\(\mathbb T\) on \(L\) is faithful. The same finite +generators generate \(L\) over \(\mathbb T\). +Moreover, +\[ + \mathbb T\lhook\joinrel\longrightarrow + \End_{R_{\mathrm{loc}}^{\mathrm{ps}}}(L); +\] +the right side is finite over the noetherian local base. +Thus \(\mathbb T\) is finite over that base. + +At \(x\), the quotient of \(L[1/2]\) by the Hecke maximal +ideal is nonzero and finite-dimensional. Select a simple +quotient after a finite coefficient extension. The +commuting images of the factor endomorphism rings generate +a finite-dimensional algebra. Their radicals kill the +simple quotient; their central idempotents select +semisimple factors; after splitting those factors, the +quotient is a tensor product of simple modules for matrix +algebras. The original integral actions preserve a +lattice. All full finite lattices in this quotient are +commensurable. Under the inverse compact equivalence, +the tensor lattice corresponds to the completed tensor +product of the individual Banach lattices. Dualizing +the quotient therefore embeds the asserted Banach +tensor product in the eigenspace. + +For an absolutely irreducible regular de Rham parameter, +the local factor has a nonzero locally algebraic vector, +so their tensor does as well. For a generic reducible +parameter, substituting +\(\gamma_i\eps\) into the fiber formula of +\cite[Corollary~6.10]{PaskunasTung2021} gives exactly the +two displayed inducing orders. +\end{proof} + +\subsection{A lower bound on every Hecke component} + +We next obtain a dimension bound that will supply the +initial support size for patching. For a finitely +generated compact \(k[[K]]\)-module, its growth degree is +the degree of growth of its length modulo powers of +the augmentation ideal. + +\begin{lemma}\label{lem:simple-growth} +Let \(k\) be the characteristic-two residue coefficient field of +Section~\ref{sec:preliminaries}. The compact dual of an absolutely +irreducible admissible smooth \(k\)-representation of +\(\GL_2(\mathbb Q_2)\) with central +character has growth degree at most one on a sufficiently +deep determinant-one compact subgroup. Finite-length +objects for \(d\) factors have growth degree at most \(d\). +\end{lemma} +\begin{proof} +Write \(K_n=1+2^nM_2(\mathbb Z_2)\), \(n\ge2\). +Characters have bounded invariant dimension. For a +principal series, the double cosets indexed by +\(\mathbb P^1(\mathbb Z/2^n\mathbb Z)\) give +\(O(2^n)\) invariants. The Steinberg case follows from +the constants--principal-series--Steinberg exact +sequence: its possible \(H^1(K_n,k)\) correction is +bounded, since \(K_n\) has four generators. + +For a supersingular \(\pi\), let +\[ + I_1=\begin{pmatrix}1+2\mathbb Z_2&\mathbb Z_2\\ + 2\mathbb Z_2&1+2\mathbb Z_2\end{pmatrix}, + \qquad \Pi=\begin{pmatrix}0&1\\2&0\end{pmatrix}. +\] +Thus \(I_1\) is the standard pro-\(2\) Iwahori subgroup. +Let \(M_\pi\) be the span of the translates of \(\pi^{I_1}\) +under \(\left(\begin{smallmatrix}2^n&b\\0&1\end{smallmatrix}\right)\), +where \(n\ge0\) and \(b\in\mathbb Z_2\); +this space is Iwahori-stable +\cite[Definition~4.5 and Lemma~4.6]{Paskunas2010}. +Use the exact sequence of Iwahori representations +\[ + 0\longrightarrow \pi^{I_1}\longrightarrow + M_\pi\oplus\Pi M_\pi\longrightarrow\pi\longrightarrow0 +\] +from \cite[Theorem~1.2, proved as Theorem~6.3]{Paskunas2010}. +That statement explicitly includes \(p=2\). +By \cite[Proposition~4.7 and Lemma~4.10]{Paskunas2010}, +\(M_\pi\) is the sum of two injective envelopes for the +upper unipotent group \(\mathbb Z_2\). Each has +\(2^n\)-dimensional invariants under \(2^n\mathbb Z_2\). +Conjugation by \(\Pi\) shifts the congruence level by +at most one. Since \(\dim\pi^{I_1}=2\), the invariants +sequence gives +\[ + \dim_k\pi^{K_n}\le 2\cdot2^n+2\cdot2^{n+1}+8. +\] +The last term bounds \(H^1(K_n,\pi^{I_1})\). +The classification of Barthel--Livn\'e and Breuil +\cite{BarthelLivne1994,BarthelLivne1995}, in the form of +\cite[Corollary~1.2]{Breuil2003I}, shows that the cases above exhaust +the irreducible admissible smooth representations with central character. + +Let \(I\) be the augmentation ideal of a fixed deep +uniform compact group. In characteristic two, the +operators \(g^{2^n}-1=(g-1)^{2^n}\) belong to +\(I^{2^n}\). Thus the compact quotient modulo +\(I^{2^n}\) is bounded in dimension by the dual +\(K_{n+c}\)-invariants, for a fixed shift \(c\). +Choosing \(2^n\) comparable to an arbitrary exponent +gives linear augmentation growth. +The central character is trivial on a sufficiently +deep scalar subgroup, and the product of that subgroup +with a deep determinant-one subgroup has finite index. +The same upper bound therefore holds on the latter. +Finite extensions preserve upper growth bounds, and +tensor products add them. This proves the product +assertion. +\end{proof} + +\begin{proposition}\label{prop:hecke-dimension} +For every irreducible component \(C\) of +\(\Spec\mathbb T\), +\[ + \dim C\ge1+2d. +\] +\end{proposition} +\begin{proof} +Reducedness and prime avoidance give an element of +\(\mathbb T\) that vanishes on every component except +\(C\) and is nonzero on \(C\). Its image on \(M\) is +a nonzero submodule \(M'\) supported on \(C\). +The full \(M\) is finite free over a sufficiently deep +Iwasawa algebra \(A=\OO[[K]]\). +The residual summand and \(M'\) embed in this free module. + +The maximal augmentation filtration, including +\(\varpi\), has polynomial associated graded ring of +dimension \(1+3d\), after taking \(K\) sufficiently +deep. A nonzero submodule of a finite free \(A\)-module +has that full growth degree: it contains a cyclic +copy of \(A\), and Artin--Rees compares its induced +filtration with its intrinsic filtration. +Consequently \(M'\) has growth degree \(1+3d\). + +Let \(r=\dim C\), and choose \(r\) parameters of the +supporting Hecke quotient. Write \(J\) for their ideal. +Proposition~\ref{prop:block-comparison} and exactness of +the block functor show that \(M'/JM'\) is dual finite +length. Lemma~\ref{lem:simple-growth} bounds its growth +degree by \(d\). +Each Hecke parameter is topologically nilpotent; on the +finite quotient \(M'/\mathfrak m_A M'\), some fixed +power is zero. Hence there is \(c>0\) such that +\[ + J^{cn}M'\subseteq\mathfrak m_A^nM' + \quad(n\ge1). +\] +Filter \(M'/\mathfrak m_A^nM'\) by \(J\). +The degree-\(j\) layer is a quotient of at most +\(\binom{j+r-1}{r-1}\) copies of +\[ + (M'/JM')/\mathfrak m_A^n(M'/JM'). +\] +Only \(cn\) layers occur. Their total length is therefore +\(O(n^{r+d})\). +Comparing with the degree \(1+3d\) gives +\(1+3d\le r+d\), which is the claim. +\end{proof} + +\subsection{Auxiliary level and solvable base change} + +The dimension bound supplies the initial support size. Patching +also requires that removing auxiliary level recover the original +operators, not just modules of the same rank. The following exact +statements connect completed forms +to the finite stages of localized patching. An auxiliary +prime has residue cardinality \(q_v\equiv1\pmod{2^n}\). +Inside its Iwahori group, take the kernel of the +diagonal-ratio map to a cyclic quotient of residue units +of order \(2^n\). This subgroup contains the scalars. +For \(h\) auxiliary primes, the deck group is +\(\Delta=(\mathbb Z/2^n)^h\). + +\begin{lemma}\label{lem:auxiliary-level} +Assume that \(\chi\) is unramified at the auxiliary +primes. Localize at a characteristic-two point of the +completed Hecke spectrum at which their Frobenii have +distinct eigenvalues. The point may be the generic +point of an enhanced curve, rather than the original +finite-field residual point. The following assertions +hold for the localized completed-forms block modules, +and continue to hold after the coefficient extensions, +completions, and smooth framings used in +Section~\ref{sec:propagation}. +\begin{enumerate} +\item The auxiliary-level module is flat over +\(\OO[\Delta]\). Diamond augmentation is the Iwahori +module; after localization at the indicated point it is the +direct sum of \(2^h\) copies of the old hyperspecial +module, with its Galois-ring action factoring through +the old unramified quotient. +\item If \(U_j\) is a diamond generator and +\(\tau_j\) is the corresponding tame inertia element, +then +\[ + U_j^2-T(\tau_j)U_j+1=0. +\] +Congruent tame transformation characters give +isomorphic residue modules with the same deformation +actions. +\item A quadratic character trivial above \(2\) and at +infinity, unramified away from the auxiliary primes, +and factoring through the auxiliary character +quotient, acts by twisting forms. It gives an actual +semilinear isomorphism of the block module with its +Galois twist, preserving the central character, the +level, and the characteristic-two completion point. +\end{enumerate} +\end{lemma} +\begin{proof} +The finite disjoint-union function model used in +Proposition~\ref{prop:completed-forms} is free under the +deck action, since the ratio quotient kills scalars +and the level was chosen to remove projective +stabilizers. Its compact dual is therefore flat over +\(\OO[\Delta]\), with augmentation equal to the +Iwahori-level module. Apply the exact projective +functor to the finite-presentation ideal tests for +flatness. This proves flatness of the block module +and commutation of reduction with that functor. + +At one auxiliary prime, let +\(\alpha:M_{\mathrm{old}}^{\oplus2}\to M_{\mathrm{Iw}}\) +be the two degeneracy maps and +\(\beta:M_{\mathrm{Iw}}\to M_{\mathrm{old}}^{\oplus2}\) +their trace maps. Their composite \(C=\beta\alpha\) +has diagonal entries \(q_v+1\) and off-diagonal entries +given by the unramified Hecke operator, up to central +units. Write \(D=\det C\). On the Iwahori module, +\(D\) denotes the same scalar expression in the +interpolated Frobenius trace and central operators. +In particular this is one compatible scalar operator +on both levels, not a determinant defined only on +the old module. The standard degeneracy calculation +expresses it, up to a central unit, as +\[ + (q_v+1)^2-q_v\chi(\phi_v)^{-1}T(\phi_v)^2, +\] +where \(\phi_v\) is a Frobenius lift. At the chosen +characteristic-two point, its value is a unit times +the nonzero square of the Frobenius trace. Thus +\(D\) becomes invertible in this localization. + +Before inverting \(D\), we have the integral identity +\[ + \alpha\operatorname{adj}(C)\beta + =D\,\operatorname{id}_{M_{\mathrm{Iw}}}. +\] +The local alternatives here are the Iwahori component of Henniart's +description \cite[Appendix~A, Sections~A.1.3 and~A.2.3]{BreuilMezard2002}. +Indeed an Iwahori-spherical classical cuspidal local +representation is unramified principal series or +special. In the former case its two Iwahori vectors +are spanned by the degeneracies, and the identity +follows from the matrix adjugate identity. In the +latter case the old space is zero and the Frobenius +eigenvalue ratio is \(q_v^{\pm1}\), so the displayed +scalar expression for \(D\) is zero as well. +Classical density and torsion-freeness prove the +identity on integral completed forms and their +compact duals. Consequently +\(D^{-1}\operatorname{adj}(C)\beta\) is both a +left and a right inverse to \(\alpha\) after the +selected localization. Iterating gives \(2^h\) old +copies. + +The maps are Hecke equivariant. Interpolation +identifies their Galois trace actions; at the +absolutely irreducible enhanced curve, the framed +representation action is consequently the actual +old unramified action. Thus the augmentation +factors through the old deformation quotient, +with its original action, rather than only having +the same multiplicity. The flatness and Iwahori +augmentation established before localization +remain valid at the selected point on both sides. +The exact block functor and the finite-ideal tests +used in Section~\ref{sec:propagation} preserve them +under the indicated flat coefficient extensions, +localizations, completions, and smooth framings. + +On a classical point with a diamond eigencharacter, +local Langlands gives semisimple inertia characters +equal to that character and its inverse, because +\(\chi\) is unramified. Their sum is \(T(\tau_j)\). +The displayed monic quadratic identity follows at +every such point, and hence on the integral module +by density. Fixed tame character transformations +congruent modulo \(\varpi\) identify their residue +function spaces. The associated trace comparisons +show that this identification also preserves the +residue deformation actions. + +For the last assertion, multiply a form by the +quadratic character composed with reduced norm. +The central character is unchanged because its value +on a scalar norm is a square. On the ratio-defined +auxiliary subgroup, the two residue diagonal entries +have the same image in the character quotient; their +product is therefore killed by a quadratic character. +Thus the level is preserved. Triviality at \(2\) and +infinity preserves the local actions there, and the +Galois parameter twists by the same character. +Its residual reduction is one, so it fixes the +characteristic-two point and its residual frames. +This gives the asserted semilinear intertwiner. + +Finally, adding a coefficient variable preserves +flatness by the complete-module local criterion. +Localization, completion of finite noetherian +modules, and smooth framing extension preserve the +stated flatness and module identities. The +intertwiners are local and preserve maximal-ideal +filtrations. Hence every assertion survives the +operations used at the finite patching stages. +\end{proof} + +\begin{lemma}\label{lem:forward-basechange} +Let \(F'/F\) be a solvable totally real Galois extension split +completely at \(2\). The restriction to \(F'\) of a pro-modular +trace locus over \(F\) is pro-modular over \(F'\), at one common +tame level for the whole restricted locus. +If all its bad inertial types are killed, this level +can be taken Iwahori at the bad non-dyadic primes +and hyperspecial elsewhere away from \(2\). +For a general solvable totally real extension split completely +at \(2\), the restricted locus is potentially pro-modular. +\end{lemma} +\begin{proof} +First suppose that \(F'/F\) is Galois. Transfer the dense classical +points by solvable base change, iterated +through prime-degree cyclic extensions +\cite[Chapter~III, Theorems~4.2 and~5.1]{ArthurClozel1989}; for the +original \(\GL_2\) construction see +\cite[Chapter~11, Lemma~11.3 and Proposition~11.4]{Langlands1980}. Apply +the unitary formulation after a norm twist when necessary, then undo +the twist. Use +Jacquet--Langlands \cite[Theorems~14.4 and 16.1]{JacquetLanglands1970}. +A regular +cuspidal packet stays cuspidal along each prime-degree cyclic +step: a loss of cuspidality would make it induced +from a character of a totally real quadratic field, +whose parallel algebraic exponents contradict +regularity. Local-global compatibility and the +uniform inertia control of +Lemma~\ref{lem:inertia-basechange} bound the +conductors at a fixed finite set of places. +The wild kernel is common and the rank is two, so +the possible tame monodromy contribution is +uniformly bounded. Thus a single tame level +contains every transferred packet. + +Their trace closure contains the restricted locus +by density and continuity. Thus this locus is pro-modular over +the specified field \(F'\), at the common tame level just chosen. +After the inertial types are killed, only unramified principal or +special local factors remain at a bad +non-dyadic prime, both with Iwahori invariants. +The stated level follows. + +For a general solvable extension, pass to its solvable Galois +closure. It is still totally real and completely split at \(2\). +The Galois case then proves potential pro-modularity of the +restricted locus. We use only this forward +base-change assertion here; classical descent +is applied later to an actual cuspidal packet. +\end{proof} diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/connectedness.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/connectedness.tex new file mode 100644 index 0000000000000000000000000000000000000000..c71e259e9223480c0e9e7ef69e74a0c6ca8203a5 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/connectedness.tex @@ -0,0 +1,583 @@ +\section{Connectedness and potential pro-modularity} +\label{sec:connectedness} + +We now connect a modular seed to the target. The field +construction of Section~\ref{sec:fields} makes the reducible +locus small after recording local lines at selected dyadic +primes. The unrestricted propagation theorem of +Section~\ref{sec:propagation} can then cross successive +component intersections. + +\begin{theorem}\label{thm:potential-promodularity} +Let \(r\) satisfy the hypotheses of Theorem~\ref{thm:main} and be not +virtually solvable. Then \(r\) is pro-modular over +some solvable totally real Galois extension of +\(\mathbb Q\), of even degree and split completely +at \(2\). + +More generally, fix a complete integral framed deformation family over +\(\mathbb Q\), with determinant \(\chi=\det r\), containing the +coefficient point defined by \(r\), and with ramification confined +to a finite set. The closed trace image of this family is pro-modular +after restriction to one common extension of the stated kind, at +one fixed tame level. +\end{theorem} + +To prove the family assertion, we will compare a curve in a Hecke +component with a curve in an unrestricted deformation component +containing the target family. The first curve requires a cuspidal +lift of the target's semisimple residue. We choose that lift before +preparing the fields, so that its tame primes belong to the fixed +allowed set used in the field estimates. + +\subsection{A modular residual seed} + +\begin{lemma}\label{lem:modular-seed} +Every semisimple two-dimensional residual +representation arising from the target has a +classical cuspidal lift over \(\mathbb Q\), after +finite coefficient extension and allowing a +finite enlargement of the tame level. +\end{lemma} +\begin{proof} +For absolutely irreducible residue this is +Serre's modularity theorem, including +characteristic two +\cite[Theorem~0.2]{Kisin2005Survey}; +the results are due to +Khare--Wintenberger and Kisin +\cite{KhareWintenberger2009,KhareWintenberger2009II,Kisin2009}. +The characteristic-two parity condition is +automatic. + +For reducible residue, the existence of a cuspidal lift, including +in characteristic two, is already proved by Billerey--Menares +\cite[Theorem~2.1]{BillereyMenares2016}. The geometric argument below +uses the same Eisenstein difference as their +\cite[Theorem~2.3]{BillereyMenares2016}; we retain the details of +integrality, cuspidality, and lifting needed here. + +Write the reducible residue as +\(\bar\chi_1\oplus\bar\chi_2\) and put +\(\alpha=\bar\chi_1/\bar\chi_2\). After a finite-order twist +it suffices to lift the eigensystem of +\(1\oplus\alpha\). +The character \(\alpha\) has odd order, +is unramified at \(2\), and has an even +Dirichlet lift of odd conductor. +Choose an even weight \(k'\ge4\) and a normalized +Eisenstein series \(f\) with this character pair +and \(a_1(f)=1\). Take an odd level \(N\ge5\) +divisible by the conductor. Let \(\ell\) be a +prime congruent to one modulo \(N2^a\), where +\(a\) will be sufficiently large. Put +\[ + g(\tau)=f(\tau)-f(\ell\tau). +\] +Regard this as a form of level \(\Gamma_1(N\ell)\). +Its positive Fourier coefficients at infinity +are \(2\)-integral, and its constant term there +is zero. The tame modular curve has good +reduction, with geometrically integral special +fiber \cite[Corollary~10.9.5(2) and Table~10.9.6]{KatzMazur1985}. +The \(q\)-expansion principle +\cite[Theorem~1.6.1 and Corollary~1.6.2]{Katz1973} therefore +extends \(g\) integrally: a vertical pole would +be detected at that component's cusp expansion. + +We verify cuspidality modulo \(\varpi\) at every +cusp. For a cusp matrix \(\gamma\in\SL_2(\mathbb Z)\), +the primitive-column decomposition is +\[ + \begin{pmatrix}\ell&0\\0&1\end{pmatrix}\gamma + =\gamma' + \begin{pmatrix}e&t\\0&\ell/e\end{pmatrix}, + \qquad e\in\{1,\ell\}. +\] +Since \(\ell\equiv1\pmod N\), one can choose +\(\gamma'\equiv\gamma\pmod N\). +The two constant terms in \(g|_{k'}\gamma\) +therefore differ by the factor +\[ + 1-(\ell/e)^{-k'}. +\] +There are only finitely many constant terms of +\(f\) at level \(N\). Choose \(a\) larger than +their denominator valuations, with an additional +power sufficient for reduction modulo +\(\varpi\). The displayed factor makes every +constant term of \(g\) vanish in the residue +field. Its coefficient of \(q\) is one, so the +reduction is nonzero. Away from \(N\ell\), it +is an eigenvector with the Eisenstein residual +eigensystem \(1\oplus\alpha\). + +This mod-\(\varpi\) cusp form lifts to the +characteristic-zero cuspidal space in the same +weight. Indeed on the tame modular curve, +Kodaira--Spencer gives +\(\Omega^1\simeq\omega^2(-\mathrm{cusps})\). +For this formula and positivity of \(\omega\), use +\cite[Section~1.5 and Appendix~A1.5.4]{Katz1973}: +after adjoining the required roots of unity, a symplectic +full-level component maps to the \(\Gamma_1\)-curve +by a finite cover of odd degree. The logarithmic +Kodaira--Spencer isomorphism descends along this tame +cover, and positivity descends along the finite map. +On the special fiber, Serre duality +\cite[Lemma~53.4.1 and Remark~53.4.3, Tags~0BS2 and~0BS4]{StacksProject} +identifies the obstruction +\(H^1(\omega^{k'}(-\mathrm{cusps}))\) with +the dual of \(H^0(\omega^{2-k'})\), which is +zero for \(k'\ge4\). The corresponding integral \(H^1\)-module +is finite by proper coherent cohomology +\cite[Lemma~30.19.2, Tag~02O6]{StacksProject}. +The multiplication-by-\(\varpi\) exact sequence and the special-fiber +vanishing make multiplication by \(\varpi\) surjective on this module. +Nakayama's lemma makes it zero, so reduction of cuspidal sections is +surjective. +The finite integral cuspidal Hecke module has +a characteristic-zero eigenpacket specializing +to this residual eigensystem: its Hecke algebra +is finite and torsion-free over \(\OO\), and +the residual maximal ideal lies above a +horizontal minimal prime. Finally undo the +finite-order twist. The construction also +covers \(\alpha=1\). +\end{proof} + +\subsection{Field choices} + +Fix the target's semisimple residue \(\bar r\) and determinant +\(\chi\). Choose a cuspidal lift of this residue by +Lemma~\ref{lem:modular-seed}, and fix a finite allowed set over +\(\mathbb Q\) containing the bad primes of the target, the prescribed +family when present, and this lift. This choice precedes the field construction below; +it ensures that the bound for the number of allowed primes also +covers the modular seed. In the reducible case write +\(\bar r^{\mathrm{ss}}=\bar\chi_1\oplus\bar\chi_2\) and +\(\alpha=\bar\chi_1/\bar\chi_2\). Use the fields +\[ + \mathbb Q\subset A\subset F +\] +of Proposition~\ref{prop:field-preparation}, with +\(d_A=[A:\mathbb Q]\), \(d=[F:\mathbb Q]\). +There are no marks when \(\bar r\) is absolutely +irreducible or \(\alpha|_{G_{\mathbb Q_2}}\ne1\). +Otherwise choose the distinguished place \(v_0\) of \(A\) +and mark its \(m=[F:A]\) lifts to \(F\). +The numbers \(u_A,u_F\) of allowed non-dyadic primes +are uniformly bounded as these degrees grow. + +Choose the degrees sufficiently large that +\begin{equation}\label{eq:degree-choices} + d>u_F+4,\qquad + m>u_F+4\quad\text{if there are marks},\qquad + 2d-2m-4-u_F>d. +\end{equation} +In the unmarked case set \(m=0\). +Since \(m/d=1/d_A\) in the marked case and \(m/d=0\) +otherwise, the further fixed lower bounds on \(d_A\) +below can be imposed simultaneously. + +\subsection{Charts with transverse local lines} + +Over the characteristic-two fixed-determinant pseudo-base, +take the finite-type framed representation scheme and +adjoin a local invariant projective line at every mark. +Call the resulting scheme \(Y\). +In its closed residual fiber, call a point \emph{transverse} +if none of its marked lines is globally invariant. +The condition is geometric: it must hold after extending +its residue field to an algebraic closure. +There is no additional condition when there are no marks. +The transverse locus is open in the residual fiber, +since the incidence of a global invariant line equal +to a specified marked line is proper. + +At a transverse point with marks, the local residual +representation at each mark is scalar after untwisting. +Indeed there is a global invariant line, and the +different marked invariant line splits its restriction. +The two local semisimple characters coincide. +This simple observation is responsible for the strict +Selmer condition in the next lemma. + +\begin{lemma}\label{lem:good-connectedness} +Let \(F\), the marked set, and the fixed-determinant representation +scheme \(Y\) be as above, with the degree inequalities +\eqref{eq:degree-choices}. Let \(y\) be a transverse closed residual +point of \(Y\), with finite residue field, and let \(R'_y\) be +the completion of \(Y\) at \(y\). Every component of +\(\Spec R'_y\) has dimension at least \(2d-m\). +Its components can be joined by a chain whose successive +intersections have dimension at least \(2d-m-1\). +The globally reducible locus has dimension strictly +less than \(2d-m-1\). +\end{lemma} +\begin{proof} +Retain the real local problems and the \(m\) marked +dyadic line problems as the local base. Reducing this +base changes no spectrum. By +Lemma~\ref{lem:marked-local-base}, it is a complete +local domain of dimension +\[ + 2d+5m. +\] +The relative framed presentation of +Proposition~\ref{prop:relative-presentation} has +generators minus relations at least +\[ + 3-6m-h^0((\ad^0)^\vee(1))\ge-6m. +\] +The last inequality uses the three-dimensionality of +\((\ad^0)^\vee(1)\). A quotient of a complete local +domain with this presentation has all components of +dimension at least \(2d-m\). Grothendieck's +connectedness theorem gives connectedness in dimension +at least \(2d-m-1\): in the form used here, cutting a +complete local domain of dimension \(N\), after adding +\(a\) formal variables, by \(b\) equations gives +connectedness in dimension at least \(N+a-b-1\). +This is the component-chain formulation of the +connectedness theorem \cite[Expos\'e~XIII, Th\'eor\`eme~2.1]{SGA2}. + +We bound the reducible locus separately. +It is empty for absolutely irreducible residue. +Otherwise add a global invariant line by proper +incidence. At a closed point of that incidence, +choose an adapted basis and first hold this line +fixed. Its movement costs one parameter. +The diagonal global characters with fixed product +vary in dimension at most one, by abelian +Leopoldt over \(F\); see +Lemma~\ref{lem:pseudo-bad-loci}. +Freeze those character parameters. + +At a marked place the closed local matrices are +scalar and the marked line is transverse to the +chosen global line. An infinitesimal upper extension, +with diagonal characters frozen, must therefore +vanish locally: a nonzero upper nilpotent matrix +cannot preserve a second transverse line. +Thus its cohomology class is strict at the marks. +Moving a marked line costs at most one further +tangent parameter, giving \(m\) in total. +There is at most one upper coboundary parameter. +The strict Selmer bounds in \eqref{eq:strict-selmer} +therefore give the following dimensions: +\[ + \begin{cases} + d+u_F+3,&\alpha|_{G_{\mathbb Q_2}}\ne1,\\ + 2d-2m+u_F+3,&\alpha|_{G_{\mathbb Q_2}}=1. + \end{cases} +\] +Here the three remaining parameters account for +the diagonal base, the global line, and the +possible coboundary. The relative tangent estimate +bounds the number of generators over the diagonal +base, so it is an upper bound for the whole formal +reducible chart, not only for its tangent space at +a fixed diagonal character. Properness of the +global-line incidence transfers the bound to +its image. Finite residue extensions do not +affect these dimensions. + +The first two inequalities in +\eqref{eq:degree-choices} make both bounds smaller +than \(2d-m-1\). This proves the lemma. +\end{proof} + +\begin{lemma}\label{lem:chart-propagation} +At a transverse closed residual point, either every +component of \(Y\) through that point has potentially +pro-modular pseudo-image, or none does. It suffices +to begin with one component whose pseudo-image +contains a potentially pro-modular, +non-virtually-solvable curve having finite local +images at the allowed non-dyadic places. +\end{lemma} +\begin{proof} +Work first in the completed chart. +By Lemma~\ref{lem:good-connectedness}, two successive +components in a connecting chain intersect in +dimension at least \(2d-m-1\). +Choose an irreducible component of maximal dimension +in that intersection. Its generic global representation +is absolutely irreducible, because the reducible locus +has smaller dimension. +Pass first to the completed trace-and-character image, +retaining the characters on the marked lines. +Forgetting the global frame and the line choices loses +at most \(3+m\) dimensions, by +Lemma~\ref{lem:dimension-comparison}. +Proposition~\ref{prop:rep-space} makes this image finite +over its trace image, so forgetting the recorded characters +causes no further dimension loss. +Thus the pseudo-image of the chosen component has dimension at least +\[ + 2d-2m-4. +\] +At each allowed non-dyadic prime impose that the +trace of a chosen Frobenius lift equal its residual +value. These \(u_F\) equations leave a closed locus +of dimension at least +\(2d-2m-4-u_F>d\). +The bad pseudo-locus bounds of +Lemma~\ref{lem:pseudo-bad-loci} and curve avoidance +therefore produce a non-virtually-solvable curve +in it. Lemma~\ref{lem:inertia-basechange} gives +finite local images at the non-dyadic allowed +places. + +If the preceding component is potentially +pro-modular, this curve is potentially pro-modular. +Theorem~\ref{thm:localized-propagation} makes the +next component potentially pro-modular. +A starting curve as in the statement first makes +its containing component potentially pro-modular +by that same theorem. Iterating crosses the +entire chain. Only finitely many extensions and +levels occur. Take the compositum of their Galois +closures and a common deeper level, using +Lemma~\ref{lem:forward-basechange}. + +Completion is faithfully flat. Every component +of \(Y\) through the closed point is the +contraction of a minimal prime of the completed +chart. The component pseudo-images are the +corresponding trace contractions. The conclusion +therefore descends from the chart to \(Y\). +\end{proof} + +The local chart statement must next be joined across +different residual extension classes. The transverse +residual condition was chosen so that this joining +does not require changing the semisimple residue. + +\begin{lemma}\label{lem:transverse-fiber} +If nonempty, the transverse closed residual fiber +of \(Y\) is geometrically connected. Consequently, +if one transverse chart has potentially pro-modular +component images, every transverse chart does. +\end{lemma} +\begin{proof} +Work over an algebraic closure of the residue field. +For scalar residue with marks, a transverse residual +representation is a nonzero additive extension after +a scalar twist. It has a unique global invariant line. +Its cocycle is zero at the marks. With the global +line fixed, these cocycles form a vector space with +the origin removed. The marked complementary lines +form products of affine line charts. Conjugating +the basis gives a connected parameter space whose +image is the entire transverse fiber. + +For distinct residual characters, use both upper +triangular orientations. In either orientation, +with its global line fixed, the extension cocycles +form a vector space. In the marked case they +vanish locally at the marks. The allowed choices +of marked lines form a nonempty open subset of +the product with projective lines, hence an +irreducible parameter space. Varying the basis +preserves connectedness. The two orientations +meet at the split representation; when there +are marks, choose lines avoiding both global +invariant lines. Without marks there is no +transversality condition, and the same two +families meet at that split representation. +For absolutely irreducible residue, the +residual fiber is a conjugacy orbit. +These parameter spaces are finite-dimensional +algebraic spaces of cocycles: this follows either +from the residual representation scheme or from +the finite-dimensional residual \(H^1\). +This proves geometric connectedness. + +There are finitely many components of the noetherian +scheme \(Y\). Their nonempty intersections with the +transverse residual fiber form a finite closed cover. +Make a graph with these components as vertices, joining +two vertices when they meet in that fiber. The graph +is connected because the fiber is connected. +Choose a spanning tree and, for each edge, a closed point +of the corresponding intersection in the transverse locus, +after a finite coefficient extension. At that point +Lemma~\ref{lem:chart-propagation} gives the same potential +pro-modularity status to the two components. + +Only finitely many such points and completed-chart +component chains are needed. Their field extensions +have a common Galois compositum, and forward base change gives +one common deeper tame level. Thus the conclusion +holds simultaneously for every component meeting the +transverse fiber, and hence for every transverse chart. +Every component through a transverse point is accounted +for by completion, as in the preceding lemma. The +finite coefficient extensions are harmless because the +integral forms and their Hecke support commute with them. +\end{proof} + +\subsection{From the two curves to the target family} + +The proof first constructs large seed and target loci over \(A\), +then chooses a characteristic-two curve in each. Appropriate lattices +put both curves in transverse charts over \(F\). Connectedness transfers +potential pro-modularity from the seed curve to the target curve; +unrestricted propagation then reaches the entire containing target locus. + +\begin{proof}[Proof of Theorem~\ref{thm:potential-promodularity}] +\emph{The seed and target loci over \(A\).} +For the seed and fields already chosen, solvable base change and Jacquet--Langlands +give a cuspidal residual packet over \(A\). +It remains cuspidal by regularity, as in +Lemma~\ref{lem:forward-basechange}. + +Its central character need agree with +\(\psi=\chi\eps\) only modulo \(\varpi\). +At a sufficiently deep tame level their +transformations coincide on reduction. +The exact integral function model of +Proposition~\ref{prop:completed-forms} therefore +gives residual occurrence also for the +specified central character \(\psi\). +Proposition~\ref{prop:hecke-dimension} supplies +a pro-modular component \(C_{\mathrm{seed}}\) +in the fixed-determinant pseudo-base over \(A\) +with +\[ + \dim C_{\mathrm{seed}}\ge1+2d_A. +\] + +Independently choose an unrestricted global +fixed-determinant framed component through +\(r|_{G_A}\), or containing the restricted +framed support of the prescribed family. +Such a component exists by taking a minimal +prime below that support. Its generic +representation is absolutely irreducible +because it contains the absolutely irreducible +target point. +The relative presentation over the real +local rings gives dimension at least +\[ + 1+2d_A+3-h^0((\ad^0)^\vee(1)) +\] +before forgetting the frame. The loss under +trace contraction is at most three. +Its pseudo-image \(C_{\mathrm{target}}\) +therefore has dimension at least +\(2d_A-2\). This large unrestricted component +contains the trace image of the initially +prescribed family; no lower dimension +bound on that smaller family is required. + +\smallskip +\noindent\emph{Choosing curves in the two loci.} +In each of \(C_{\mathrm{seed}}\) and +\(C_{\mathrm{target}}\), pass to the special +fiber and prescribe residual Frobenius trace +at every bad non-dyadic place. If there are +marks, prescribe in addition that the +entire local pseudorepresentation at +\(v_0\) is its constant residual one. +This last condition costs at most the +number of topological generators of one +fixed local pseudo-ring for \(\mathbb Q_2\), +a constant independent of \(d_A\). +All the other costs are bounded by +\(1+u_A\), with a fixed additional constant +for the target dimension estimate. +Taking \(d_A\) sufficiently large leaves +dimension greater than \(d_A\). +By Lemma~\ref{lem:pseudo-bad-loci}, each locus +contains a non-virtually-solvable curve. +The Frobenius constraints make its bad +local images finite. + +\smallskip +\noindent\emph{Entering the transverse fiber over \(F\).} +We explain why both curves enter transverse +charts over \(F\). +Without marks, any stable lattice suffices. +With marks, the local pseudo at \(v_0\) is +constant and scalar after untwisting, +so the curve-field representation has an +invariant line there after a finite +coefficient extension. +Choose a nonzero vector \(v\) on this line +and let +\[ + \mathcal V=\sum_{g\in G_A} k'[[t]]\,\rho(g)v. +\] +Compactness bounds this module inside a fixed +lattice. Global irreducibility makes it +full rank, and it is stable by construction. +The vector \(v\) is primitive in +\(\mathcal V\): if it belonged to +\(t\mathcal V\), all its translates would, +and Nakayama would force +\(\mathcal V=0\). +Its reduction lies in no global invariant +line, since its orbit spans +\(\mathcal V/t\mathcal V\). + +Restrict the lattice to \(G_F\). No new global invariant +line appears in the residue. For distinct residual +characters, a nonsplit extension remains nonsplit by +the restriction injectivity in +Proposition~\ref{prop:field-preparation}; a split +representation retains its two distinct character lines. +For scalar semisimplification, the spanning property +above rules out a split scalar residue, and its nonzero +additive extension remains nonzero by the same injectivity. +These descriptions hold after extending the residue field. +Since \(F/A\) is Galois, \(G_A\) permutes the globally +invariant lines of the restricted residue. Transporting +the chosen local line to every prime over \(v_0\) therefore +preserves its avoidance of all these lines. Hence every +transported marked line is transverse. +Both curves pass through transverse points +of the same residual scheme \(Y\). + +\smallskip +\noindent\emph{Returning from the target curve to its containing locus.} +The seed curve remains potentially +pro-modular after restriction to \(F\). +Its finite bad local images allow +Theorem~\ref{thm:localized-propagation} to +start the propagation in its transverse +chart. Lemma~\ref{lem:transverse-fiber} +then gives potentially pro-modular images +at every transverse chart. +In particular the restricted target curve is potentially +pro-modular. By definition, the original target curve +over \(A\) is therefore potentially pro-modular as well. +Apply Theorem~\ref{thm:localized-propagation} +over \(A\) to this original curve and its containing +locus \(C_{\mathrm{target}}\). +The whole locus, and therefore the target +and the prescribed family trace image, +becomes pro-modular after a common allowed +extension. + +The finite component graph in +Lemma~\ref{lem:transverse-fiber} and the finite chains +inside its selected charts require only finitely many +propagation steps. Replace their fields by one Galois +compositum and their levels by one deeper tame level, +using forward base change. Total reality, complete +splitting at \(2\), and solvability over \(\mathbb Q\) +are preserved. +This proves both assertions. +\end{proof} + +The distinction between the two spaces in this proof +is important. Marks and transverse lines produce +connectedness in the global special fiber. +The propagation theorem subsequently applies to +unrestricted dyadic deformation loci. +No ordinary or potentially crystalline restriction +has been imposed on the target. The next section +extracts its classical vectors. diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/deformation.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/deformation.tex new file mode 100644 index 0000000000000000000000000000000000000000..556b243b8943e34aad14d93c259205aab463461f --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/deformation.tex @@ -0,0 +1,1074 @@ +\section{Deformations and local geometry}\label{sec:deformation} + +We establish the deformation-theoretic tools used in both propagation and +connectedness. The two points requiring particular care are deformation +theory at a characteristic-two curve and the geometry of several local +conditions imposed simultaneously. We retain determinant characters +throughout. In particular, in characteristic two a pseudorepresentation +means a two-dimensional determinant, not merely its trace. + +There are three outputs. First, finite trace-and-character spaces +let us compare dimensions before and after forgetting frames and +lines. Second, curve completion gives legitimate continuous local +and global deformation problems with a common coefficient field. +Third, two distinct local geometries serve different later uses: +unrestricted dyadic factors enter propagation, whereas marked scalar +factors enter connectedness. + +\subsection{Representation spaces and formal dimensions} + +The groups occurring below, namely local Galois groups and the groups +$G_{F,S}$ with $S$ finite and containing the dyadic and infinite places, +satisfy Mazur's finiteness condition $\Phi_2$: for every open +subgroup $H$, the set $\Hom_{\mathrm{cts}}(H,\ZZ/2\ZZ)$ is finite. +We use continuous +deformation functors. A frame is a specified basis; a local line, when +recorded, is part of the deformation data. This is the framed form +of the deformation framework of \cite{Mazur1989}. + +\begin{proposition}[Representation spaces]\label{prop:rep-space} +Let $G$ satisfy $\Phi_2$, let $\overline D$ be a continuous +two-dimensional determinant over the finite field $\kk$, and fix a +continuous lift $\chi$ of its determinant character. The following +statements hold. +\begin{enumerate} +\item The determinant deformation functor is represented by a complete +Noetherian local $\OO$-algebra $R^{\mathrm{ps}}$. There is a finite +$R^{\mathrm{ps}}$-algebra $\mathscr E$ carrying its universal Cayley--Hamilton +representation. Matrix representations of $\mathscr E$ compatible with the +universal determinant form an affine scheme of finite type over +$R^{\mathrm{ps}}$. Its completion at a closed residual matrix +representation is that representation's framed deformation space. +\item Invariant lines at finitely many closed subgroups can be imposed +by closed incidence conditions in products of projective lines. On the +absolutely irreducible global locus, existence of such a line with a +specified character is closed in the trace and character parameters. +\item Suppose the subgroups' abelianizations have finitely generated +maximal pro-$2$ quotients. Adjoining the characters on the specified +lines gives a finite extension of the completed trace-and-determinant +image. +\item At an absolutely irreducible representation over a coefficient +field, determinants classify unframed deformations. After a splitting +extension, the framed fiber is a conjugacy orbit of dimension three. +\end{enumerate} +These assertions do not require the residual determinant to be +multiplicity-free. +\end{proposition} + +\begin{proof} +For representability under $\Phi_2$, we use +\cite[Propositions~3.3 and~3.7, Remark~3.5]{Chenevier2014}, with the +numbering of the cited arXiv version. Finiteness of the universal +Cayley--Hamilton algebra and the algebraization of its compatible +matrix representations are +\cite[Propositions~3.2 and~3.6, Theorems~3.7 and~3.8]{WangErickson2018}. +Compatibility here includes the characteristic-polynomial equations; +no generalized matrix algebra at a scalar residual point is being +assumed. Fixing $\chi$ is a base change of these statements. + +For clarity, finite type has a direct algebraic explanation. Choose +finitely many algebra generators for the finite algebra $\mathscr E$, assign a +$2\times2$ matrix to each, and impose the multiplication and +characteristic-polynomial identities. These are polynomial equations +over the Noetherian base. Completing at a residual matrix point +recovers continuity and the chosen residual representation, including +its extension class. + +Line invariance and the prescribed action on a line are closed +equations in the relative projective line. Over the absolutely +irreducible locus the Cayley--Hamilton algebra is an Azumaya algebra of +rank four; one may split it faithfully flat locally and then descend +the proper incidence image. This proves the closedness assertion. + +If $g_1,\ldots,g_a$ topologically generate the relevant abelian +character quotient, every recorded character value $\lambda(g_j)$ +satisfies +\[ + X^2-T(g_j)X+\chi(g_j)=0. +\] +Modulo the maximal ideal of the trace image, the corresponding +parameters are nilpotent after the chosen residual roots have been +fixed. The closed fiber of the completed character algebra is +therefore finite. Complete Nakayama proves finiteness of that algebra +over the trace image. Finite torsion generators cause no change. + +Finally, the absolutely irreducible determinant theorem identifies the +Cayley--Hamilton algebra with a matrix algebra after a splitting +extension \cite[Theorem~2.22 and Corollary~2.23]{Chenevier2014}. Two compatible representations are conjugate and their +stabilizer consists of scalars. This gives the final assertion. +\end{proof} + +In dimension two the fixed-determinant ring is topologically generated +by traces. There is no division by two in this statement: for group +elements $g_j$ the determinant of a formal sum is +\[ +D\Bigl(\sum_j t_jg_j\Bigr) +=\sum_jt_j^2\chi(g_j) + +\sum_{j0$. +Lying-over gives a one-dimensional prime of $A$ avoiding $f$. +Excellence makes its normalization finite; a complete +equicharacteristic discrete valuation ring with finite residue field +has the asserted form. + +In the second case choose sufficiently small integral values for the +variables on which the selected nonzero series does not vanish. +Existence follows successively from the one-variable preparation +theorem. A prime above this specialization has a finite extension of +$\EE$ as fraction field. Integrality puts the image of $A$ in its +ring of integers; locality and finiteness make the map continuous. +Again $f$ does not vanish. Applying this to an element of the ideal of +the excluded closed subset proves density. +\end{proof} + +\subsection{Continuous deformations at a curve} + +Deformation theory over Laurent-series residue fields, with integral +residual bases and finite coefficient orders, is developed in +\cite[Section~3.5, Proposition~3.34 and Lemmas~3.35--3.37]{BIP}. +We give the completion argument needed here with its global frames +and incidence data. Keeping the Laurent topology makes continuous +cocycles and obstructions the correct ones. + +Let $\rho_*:G\to\GL_2(K)$ be a continuous curve representation, where +$K=\kk((t))$. After a finite extension of constants and of the curve, +choose a stable lattice and write its matrices in $\GL_2(\kk[[t]])$. +Let $\overline\rho$ be their reduction at $t=0$. A restriction of the +curve to a local group need not generate all of $K$ from its matrix +entries. Introduce a new variable $z$, send it to $t$, and carry this +same variable through every local and global deformation ring. Their +enhanced curve maps then have the common residue field $K$. +The enhanced coefficient ring is +\[ +\mathcal L=\widehat{\OO[[z]]_{(\varpi)}}. +\] +It is a complete discrete valuation ring with residue field $K$, and +\[ +\mathcal L/\varpi^a=(\OO/\varpi^a)((z)). +\] +Finite-length $\mathcal L$-modules carry their Laurent-series topology. +In particular $K$ is not given the discrete topology. + +\begin{lemma}[The curve completion]\label{lem:curve-completion} +Let $R$ be the framed deformation ring of $\overline\rho$, with the +specified determinant and any of the incidence data above. Let +$\mathfrak p$ be the kernel of the enhanced curve map +$R[[z]]\to\kk[[t]]$. Then +\[ +R_*:=\widehat{(R[[z]])_{\mathfrak p}} +\] +classifies continuous deformations of $\rho_*$ to finite-length local +Artinian $\mathcal L$-algebras with residue $K$. This identification +commutes with restriction to local groups, with frames and invariant +lines, and with fixing the determinant. The analogous assertion holds +for determinants; on the absolutely irreducible locus it agrees with +unframed matrix deformation theory. + +If a component of the original complete local ring has dimension $e$ +and contains the curve, its enhanced completed localization has +dimension $e$. At a characteristic-zero coefficient point the +corresponding assertion uses the usual completion over its finite +$2$-adic coefficient field, without adjoining $z$; a horizontal +integral component of dimension $e$ then gives a completed local +component of dimension $e-1$. +\end{lemma} + +\begin{proof} +We first prove the integral-order assertion underlying the functorial +claim. Let $C$ be one of the Artinian algebras, with maximal ideal +$\mathfrak n$, $\mathfrak n^N=0$, and $\varpi^a C=0$. Write +\[ +A_0=\im\bigl((\OO/\varpi^a)[[z]]\longrightarrow C\bigr). +\] +The inverse image of $\kk[[t]]$ under $C\to K$ is +$A_0+\mathfrak n$. A bounded subset of this inverse image lies in a +finite $A_0$-order: subtract coefficientwise lifts of its residual +entries, choose a finite $A_0$-lattice $U\subset\mathfrak n$ containing +the resulting bounded differences, and put +\begin{equation}\label{eq:curve-order} +B=A_0+U+U^2+\cdots+U^{N-1}. +\end{equation} +Powers here mean finite module spans of products. Nilpotence makes +$B$ an algebra finite over $A_0$. Its quotient by +$B\cap\mathfrak n$ is $\kk[[t]]$, with nilpotent kernel. Hence $B$ +is local with residue field $\kk$. The finite local ring $B/zB$ is +Artinian, so a power of $\mathfrak m_B$ is contained in $zB$. +Its maximal-ideal topology is therefore its finite-module topology; +$B$ is complete and compact. + +Apply this to the compact set of matrix entries of a continuous lift +of $\rho_*$. These entries have integral residues because the +residual basis was chosen above. Their determinants have residual +values in $\kk[[t]]^\times$, and so are units of $B$. We obtain a +continuous representation in $\GL_2(B)$ reducing to precisely +$\overline\rho$. Negative powers of $z$ in nilpotent entries belong +to $B\cap\mathfrak n$ and disappear at that closed residual point. +There is no uniform lower valuation bound as $C$ varies, nor is one +needed. The same construction simultaneously contains any finite +collection of local data, and two such orders admit a common +enlargement. + +Universality gives a map $R\to B$. Adjoin $z$ using its coefficient +value. Elements outside $\mathfrak p$ have nonzero residue in $K$, +so are units in $C$, while $\mathfrak p^N$ maps to zero after +increasing $N$. The map factors uniquely through $R_*$. Conversely, +a local map $R_*\to C$ factors through a finite jet. Write the +original formal coordinates as integral lifts of their curve values +plus nilpotent increments. Expansion in the increments has only +finitely many terms at this jet depth; the residual coordinates, +after their constants are removed, lie in $(t)$. Substitution in +each original formal series consequently converges in the +Laurent-series topology. It is continuous, and so gives a continuous +lift of the universal representation. The two constructions are +inverse. They plainly preserve determinant equations, line +incidences, and restriction maps. For determinants use their +characteristic coefficients, followed on the absolutely irreducible +locus by the matrix-algebra identification in +Proposition~\ref{prop:rep-space}. + +For dimensions, adjoining $z$ increases a component dimension from +$e$ to $e+1$, while the enhanced curve quotient has dimension one: +the map on $\kk[[z]]$ is already onto $\kk[[t]]$. The dimension +formula for complete equidimensional excellent local rings gives +height $e$ at the enhanced prime. Localization and completion have +dimension $e$; see also the dimension and catenarity facts in +\cite[Tags~00KW, 032C, 0ECF and~07NV]{StacksProject}. +At a horizontal characteristic-zero coefficient point the integral +quotient again has dimension one, but no new variable has been +adjoined. Its height and completed dimension are therefore $e-1$. +The deformation functor uses the usual $2$-adic topology. +\end{proof} + +The restriction to the inverse image of $\kk[[t]]$ in +\eqref{eq:curve-order} is essential. For example, the bounded +singleton $\{z^{-1}\}$ cannot lie in a finite order having integral +residual image. + +For a representation $V$ over its coefficient field $L$, write +$h^i(G,V)=\dim_L H^i_{\mathrm{cts}}(G,V)$, omitting $G$ when +understood. For global $V$, write +$h^i_v(V)=\dim_L H^i_{\mathrm{cts}}(G_{F_v},V)$. +These are ordinary cohomology dimensions; at real places the +duality pairings use Tate cohomology, as specified below. + +\begin{lemma}[Curve-field cohomology]\label{lem:curve-cohomology} +Let $V$ be a finite-dimensional continuous $K$-representation of a +local Galois group or of $G_{F,S}$. Continuous cohomology is finite +dimensional and satisfies local duality, local and global Euler +characteristics, and Poitou--Tate duality with arbitrary linear local +conditions. The twist in characteristic two is the residual Tate +twist. At real places local duality uses Tate cohomology; the +$h^0_v$ appearing in the Euler and Selmer formulas below still +denotes the dimension of ordinary invariants. In particular, if +$F$ is totally real of degree $d$ and +$\dim_KV=r$, then +\begin{align} +h^0_v(V)-h^1_v(V)+h^2_v(V)&=-r[F_v:\QQ_2] + &&(v\mid2),\\ +h^0(V)-h^1(V)+h^2(V)&=-rd+\sum_{v\mid\infty}h^0_v(V). +\label{eq:global-euler-curve} +\end{align} +At a real place the local contribution to a Selmer dimension +difference is $\dim L_v-h^0_v(V)$, where +$L_v\subset H^1(F_v,V)$. The same formulas, with the usual real-place +interpretation, hold for finite $2$-adic coefficient fields. +\end{lemma} + +\begin{proof} +Choose a stable $\kk[[t]]$-lattice $T\subset V$. Continuous cochains +with values in $T$ are the inverse limit of the cochain complexes for +$T/t^nT$. Finite-level cohomology is finite, so the derived inverse +limits vanish and cohomology commutes with this inverse limit. +The resulting compact cohomology modules are finite over +$\kk[[t]]$: their quotients by $t$ inject into the appropriate +finite-level cohomology group, and compact Nakayama applies. +Every continuous cochain into $V$ has bounded image, since its domain +is compact. Thus its cochain complex is obtained by inverting $t$, +and the same is true of cohomology. + +Apply finite-coefficient local duality and Poitou--Tate to $T/t^nT$ +and the dual torsion lattice, then pass to the inverse limit and +invert $t$. This gives the perfect field-valued pairings, with +Tate cohomology at real places, and the exact global sequence. +Taking lengths in the finite-level Euler +formulas and dividing by $n$ gives the displayed dimensions; bounded +torsion contributes zero in the limit. The real-place terms pass +through the same calculation and must not be discarded at $2$. +Intersections with lattices and saturation allow any linear local +condition and its annihilator. The finite-coefficient inputs are +\cite[I, Corollary~2.3, Theorems~2.8, 2.13, 4.10 and~5.1]{Milne2006}. +The identical lattice argument with an $\OO$-lattice gives the +finite-$2$-adic-field version. +\end{proof} + +\subsection{Relative presentations} + +Curve completion has now identified the deformation functors, and +the preceding cohomology calculation supplies their tangent and +obstruction spaces. We turn these data into a bound on actual +relations cutting out the global ring over its local base. At real +places the displayed invariant dimensions are ordinary \(H^0\), +while the duality argument uses Tate-modified groups. + +Put $D=\ad^0(\rho)$ for a fixed-determinant two-dimensional +representation. Its dimension is three, also in characteristic two. +Its dual there is $\ad(\rho)/\text{scalars}$, not in general $D$ +itself. + +\begin{proposition}[Relative relation bounds]\label{prop:relative-presentation} +Let $F$ be totally real of degree $d$, let $S$ contain the real and +dyadic places, and let $\rho$ be a representation over a finite +residue field, a curve field as above, or a finite $2$-adic field. +Use one global frame and a fixed determinant. Let $T\subset S$ +consist of all real places and $m$ dyadic places, each isomorphic to +$\QQ_2$. Over the completed product of the unrestricted local framed +deformation rings at $T$, the global framed ring has a power-series +presentation with $g$ relative variables and $r$ relations satisfying +\begin{equation}\label{eq:relative-one-frame} +g-r\ge 3-6m-h^0\bigl(D^\vee(1)\bigr). +\end{equation} +Local quotient conditions and local line charts may then be imposed +by base change without changing this bound. This includes replacing +the local base by its reduction. + +For the variable-determinant problem with independent frames at the +places of $S$, the relative tangent dimension over the local framed +base is +\begin{equation}\label{eq:relative-independent-frames} +h^1_{\mathrm{Sel}}(\ad\rho) + +\sum_{v\in S}h^0_v(\ad\rho)-h^0(\ad\rho), +\end{equation} +where the Selmer condition is zero at $S$ and any other prescribed +conditions are included in the Selmer group. On the absolutely +irreducible locus, forgetting these independent frames has smooth +fiber dimension $4|S|-1$. +\end{proposition} + +\begin{proof} +The relative tangent space in the one-frame problem is the kernel of +restriction on $Z^1(D)$. We spell out the obstruction bound since +it is also used at enhanced curves. Across a small extension, choose +continuous matrix lifts with the prescribed determinant. +Multiplication errors form a continuous $2$-cocycle. Given the +specified local lifts, its class belongs to the kernel of restriction +on $H^2(D)$. If that class vanishes, correct the matrices to a global +representation. Its differences from the chosen local lifts are +$1$-cocycles, and the second obstruction belongs to the cokernel of +restriction on $Z^1(D)$. Continuous set sections of finite-length +coefficient modules suffice: coefficientwise digit sections supply +them. The determinant map on invertible matrices is smooth, so +determinant correction needs no division by two. + +Consequently the relation number is at most the sum of these two +obstruction dimensions. One can verify that this bounds actual +minimal relations as follows. For a minimal relative presentation +$H\twoheadrightarrow R$ with kernel $I$, test the small extension +\[ +H/(\mathfrak m_HI+\mathfrak m_H^j) + \longrightarrow H/(I+\mathfrak m_H^j) +\] +for $j$ large enough that its kernel is $I/\mathfrak m_HI$. +The two obstruction maps must jointly detect its dual relation +directions. Indeed, quotient the kernel onto an undetected +one-dimensional direction. Vanishing of both obstructions would give +a lift compatible with the local base. Its relative coordinates differ +from the tautological ones by elements of the small kernel, which is +killed by $\mathfrak m_H$. Changing these coordinates therefore alters +a relation only through its residual linear terms in the relative +variables. Those terms vanish by minimality, so the nonzero surviving +relation cannot become zero. This contradicts the existence of the +lift and proves the relation bound for the complete rings. + +Poitou--Tate bounds the first obstruction dimension by +\[ +h^2(D)-\sum_{v\in T}h^2_v(D)+h^0(D^\vee(1)). +\] +Subtracting it and the $Z^1$ cokernel from the tangent dimension gives +\begin{align*} +g-r +&\ge 3(1-|T|) + -\bigl(h^0-h^1+h^2\bigr)(D)\\ +&\qquad +\sum_{v\in T} + \bigl(h^0_v-h^1_v+h^2_v\bigr)(D) + -h^0(D^\vee(1))\\ +&=3(1-d-m)+3d-3m-h^0(D^\vee(1)). +\end{align*} +For the last equality, the real terms in +\eqref{eq:global-euler-curve} cancel the real local terms; the dyadic +Euler characteristic is $-3$. This proves +\eqref{eq:relative-one-frame} in both coefficient characteristics. +Base change carries the same presentation to the extra local +conditions. + +For independent frames, first choose a global cohomology class +vanishing at the prescribed local places. Local choices of +trivialization contribute the local invariant spaces, and a common +global infinitesimal automorphism is quotiented out. This gives +\eqref{eq:relative-independent-frames}. If the global representation +is absolutely irreducible, the common automorphisms are exactly the +scalars; the quotient of the $|S|$ frame spaces therefore has +dimension $4|S|-1$. +\end{proof} + +\begin{corollary}[A characteristic-zero line chart] +\label{cor:charzero-line-dimension} +For a two-dimensional representation of $G_{\QQ_2}$ over a finite +$2$-adic field with a chosen invariant line and fixed determinant, +every component of its framed line-deformation chart has dimension +at least five. The odd fixed-determinant real chart has dimension +two. In particular, over $\QQ$, the relative bound for these two +local charts is $-3$ whenever $h^0(D^\vee(1))=0$. +\end{corollary} + +\begin{proof} +Hold the line fixed in an adapted basis. The coefficient Lie algebra +is the trace-zero upper triangular algebra of dimension two. The +local Euler formula gives +$\dim Z^1-\dim H^2=4$, so the relation bound gives local dimension +at least four. Moving the line adds one formal variable. At a real +place the odd involution has two distinct eigenvalues in +characteristic zero and its conjugacy orbit has dimension two. +The final assertion is \eqref{eq:relative-one-frame} with $d=m=1$. +\end{proof} + +\subsection{Small pseudodeformation loci and control of inertia} + +\begin{lemma}[Virtually solvable loci]\label{lem:pseudo-bad-loci} +Let $F$ be totally real of degree $d$, let $S$ contain its dyadic and +infinite places, and fix the determinant. In the characteristic-two +pseudodeformation space, the irreducible dihedral curve points lie in +a closed subset of dimension at most $d$. Finite-projective-image +curve points give only the residual pseudorepresentation. If +$F/\QQ$ is abelian, the reducible locus is closed and has dimension +at most one. +\end{lemma} + +\begin{proof} +There are only finitely many quadratic extensions of $F$ unramified +outside $S$. This follows from Hermite--Minkowski, since fixed local +degree bounds the finitely many possible local discriminants. For +each such extension $F'/F$, use the character deformation space of +$G_{F',S}$ with the product of the character and its conjugate fixed. +Class field theory identifies its free pro-$2$ parameters with a +quotient of the dyadic local units; non-dyadic unit groups and class +groups contribute only finite groups. The dyadic unit rank over +$F'$ is $2d$, and its minus rank for the quadratic involution is +$d$. Fixing the product fixes the plus part up to finite groups: +multiplication by two is an isogeny of the relevant free +$\ZZ_2$-modules even though two is not a unit. Thus the reduced +special character space has dimension at most $d$. + +Its map to pseudorepresentations has finite image algebra. Indeed +the finitely many generating character values satisfy the +characteristic polynomials of the induced traces, and complete +Nakayama applies as in Proposition~\ref{prop:rep-space}. Its image +is consequently closed and has dimension at most $d$. Taking the +finite union gives the dihedral bound. The argument applies to +curve points after finite coefficient and curve extensions, and +Lemma~\ref{lem:formal-point-density} gives the asserted closed-locus +formulation. + +If the projective image is finite, each scalar in the representation +has square fixed by its determinant. The determinant has finite +image in the special fiber, so the scalar image, and hence the whole +image, is finite. Its traces are algebraic over a finite field. An +element of $\kk'[[t]]$ algebraic over a finite field is constant; +its constant reduction is already prescribed. Thus these traces +give exactly the residual pseudorepresentation. + +Finally, a reducible determinant is a pair of characters with fixed +product, so one character determines the other. For an abelian +totally real $F$, Brumer's theorem on Leopoldt's conjecture +\cite{Brumer1967}, in the form proved in +\cite[Theorem~1 and Proposition~8, pp.~9-08--9-09 and 9-14]{Fresnel1969}, +gives free pro-$2$ character rank one. +The same finite character-image argument +therefore gives a closed locus of dimension at most one. +\end{proof} + +\begin{lemma}[Inertia and solvable base change] +\label{lem:inertia-basechange} +Consider finitely many complete deformation or pseudodeformation +families over finite-residue coefficient rings, and a finite set of +places not above two. After a fixed finite local extension at each +place, all their field-valued representations have unipotent inertia. +For a characteristic-two curve in such a family whose determinant +has finite image, imposing the residual value of a Frobenius trace +makes the local image finite. + +Any further finite local extensions needed to kill these finite +images, to kill the finitely many inertial types, to make the fixed +determinant unramified, or to arrange residue cardinalities +congruent to $1$ modulo $4$, can be realized inside a totally real +solvable base change which splits completely at the dyadic places. +One may take its Galois closure over $\QQ$. New ramification of the +base field away from the original allowed set creates no new +ramification of the restricted representations. +\end{lemma} + +\begin{proof} +Use the finite universal Cayley--Hamilton algebra $\mathscr E$ for each +family. Its reduction modulo the base maximal ideal is finite. +After killing that finite residual group image locally, the group +acts through the pro-$2$ group $1+\mathfrak m\mathscr E$. At a place of +residue characteristic $\ell\ne2$, wild inertia and the non-$2$ +part of tame inertia therefore act trivially. Write $\tau$ for the +remaining tame generator and $\phi$ for arithmetic Frobenius, so that +\[ +\phi\tau\phi^{-1}=\tau^q. +\] +At any field-valued point the multiset of eigenvalues of $\tau$ is +stable under the $q$th-power map. Each eigenvalue consequently has +order dividing $q^2-1$. A further fixed tame extension kills this +semisimple inertia at every point, leaving unipotent inertia. The +same finite extension works for the finite list of source families. + +In characteristic two a unipotent $2\times2$ matrix has square one. +After these extensions the inertia image is therefore finite: it is +generated by the image of the single pro-$2$ tame generator. The +original inertia image is finite as well, since the inertia subgroup +upstairs has finite index in the original one. Now use the Frobenius +chosen in the original local group, whose trace is prescribed by the +curve constraint. Its characteristic polynomial has coefficients in a +finite field, since that trace is the residual constant and the +determinant has finite image. Its eigenvalues have finite order, and +its possible Jordan part has order at most two. This original +Frobenius consequently has finite order. The full local image is an +extension of the finite inertia image by the finite quotient generated +by Frobenius, and is therefore finite. + +Every finite Galois group over a nonarchimedean local field is +solvable: wild inertia is an $\ell$-group, and the successive tame +inertia and residue quotients are cyclic. A composition tower +therefore realizes each required local extension through cyclic +prime-degree steps. At each step the prime-degree case of the +Grunwald--Wang theorem +\cite[Chapter~VIII, Theorem~2.4]{MilneCFT} +prescribes the finitely many local extensions while imposing +splitting at dyadic and real places. For degree two this is simply +weak approximation for squareclasses; no higher-power +Grunwald--Wang assertion is needed. Composita and Galois closure +preserve solvability, total reality, and complete dyadic splitting. +An unramified local extension of even degree makes an odd residue +cardinality $1$ modulo $4$. The determinant's finite non-dyadic +inertia can be killed at the same time. + +Finally, inertia in the enlarged field maps into inertia downstairs. +A representation unramified at a place outside the original allowed +set remains unramified after restriction, even if the field extension +itself ramifies there. This proves the last assertion. +\end{proof} + +The unipotent assertion may be carried to closures of restricted +pseudorepresentation images. On the globally absolutely irreducible +locus this can be checked by characteristic polynomials and by +traces against a matrix-algebra basis of group elements. For +example, the equations +\[ +\tr\bigl((\rho(\tau)-1)^2\rho(g)\bigr)=0 +\] +for such a basis force $(\rho(\tau)-1)^2=0$ by the perfect trace +pairing on $M_2$. Thus these are closed identities on the locus +where the corresponding trace Gram matrix is invertible. This +justifies the set-theoretic use of the uniform inertia assertion on +the source-image closures below. + +\subsection{The local product used in propagation} + +We now define the local model independently of any patched global +ring. Fix $d$ real factors and $d$ dyadic factors, the latter all +over $\QQ_2$. At each use the prescribed fixed determinant, odd at +the real places. Start with integral residual bases over a common +finite field, take the completed product of the framed local rings, +and form its enhanced completion at any chosen curve as in +Lemma~\ref{lem:curve-completion}. Denote the resulting +$\mathcal L$-algebra by $A^{\mathrm{rd}}$. + +We enlarge $\OO$ once so that it contains $i$ with $i^2=-1$. +Choose $u$ odd residue cardinalities $q_j\equiv1\pmod4$, and $g\ge0$. +Put +\[ +A=A^{\mathrm{rd}}[[X_1,\ldots,X_g]]. +\] +For $\eta\in\{1,i\}$ define $B_\eta$ by adjoining at each of the $u$ +places two formal invertible matrices $\tau_j,\phi_j$, both reducing +to the identity at the curve, and imposing +\begin{equation}\label{eq:tame-model} +\tr\tau_j=\eta+\eta^{-1},\qquad +\det\tau_j=1,\qquad +\phi_j\tau_j\phi_j^{-1}=\tau_j^{q_j}. +\end{equation} +There is no condition on $\det\phi_j$. This is the raw completed +matrix quotient: we do not silently replace it by its reduction. +At characteristic-zero field points the $i$-condition gives the two +distinct inertia eigenvalues $i,-i$, whereas the $1$-condition makes +inertia unipotent. Both $i$ and $-i$ reduce to one in characteristic +two. The two conditions thus have identical special-fiber equations +but different characteristic-zero component geometry, described below. + +\begin{proposition}[Local component geometry]\label{prop:local-geometry} +The ring $A^{\mathrm{rd}}$ is a flat complete-intersection normal +domain over $\mathcal L$, of dimension $1+8d$, and its special fiber +is a normal domain of dimension $8d$. Set +\[ +e=1+8d+4u+g. +\] +Then the following statements hold for the model +\eqref{eq:tame-model}. +\begin{enumerate} +\item $\Spec B_i$ is irreducible of dimension $e$, and its unique +irreducible component is horizontal. +\item The two rings have a canonical common special fiber, compatible +with their universal matrices and the variables $X_1,\ldots,X_g$. +Its irreducible components have dimension $e-1$ and are indexed by a +choice, at each tame place, of the unramified component or the closure +of the nontrivial-unipotent component. +\item The irreducible components of $\Spec B_1$ are horizontal and +have dimension $e$. They are indexed by the same choices. The +specialization of each has precisely its corresponding special-fiber +component as underlying support. In particular the generic point +of a special-fiber component lies on exactly one component of +$\Spec B_1$. +\end{enumerate} +The assertions remain valid after finite extension of the constants +and curve field and the resulting enhanced completion. No condition +on the dyadic curve representations is required. +\end{proposition} + +\begin{proof} +\emph{The unrestricted real and dyadic base.} +We first establish the assertion about $A^{\mathrm{rd}}$. An odd +real framed ring is given by trace zero and determinant $-1$. +These equations are equivalent to the involution relation with that +determinant, by Cayley--Hamilton and invertibility. At the scalar +residual point it has the form +\[ +\OO[[a,b,c]]/(a^2+2a+bc). +\] +Its special fiber $a^2+bc=0$ is a geometrically normal surface: it is +an integral hypersurface whose singular locus has codimension two +\cite[Tag~031S]{StacksProject}. +At a non-scalar residual involution one obtains a smooth chart of +the same relative dimension two. + +For a dyadic factor, the fixed-determinant framed deformation theorem +\cite[Theorem~1.5]{BIP} gives a flat complete-intersection normal +domain of dimension seven and a normal special-fiber domain of +dimension six. The theorem applies at $2$, including scalar and +reducible residual representations; the prime restriction on a +different density theorem is not being used. The same statement +holds after each finite coefficient extension. + +The completed tensor product of these special-fiber rings over the +finite, hence perfect, field is a normal domain. Here we use the +completed tensor-product normality theorem +\cite[Theorem~3.3 and Proposition~3.1]{Tabaa2020}; the residue tensor +product is the field itself, so the product is local and connected. +Its dimension is $8d$. The mixed-characteristic completed product +is a flat complete intersection: concatenate presentations, first +checking the regular sequences modulo $\varpi$, and then lift them +together with the nonzerodivisor $\varpi$. Its special fiber is the +normal domain just obtained, and the regular-element normality +criterion makes the product normal. It is a domain as well: the +lowest nonzero $\varpi$-adic terms of a putative product of two +nonzero elements could not multiply to zero in the special fiber. + +Adjoining $z$, localizing at the enhanced curve, and completing +preserve normality by excellence +\cite[Tags~07QW and~0C23]{StacksProject}. They preserve the asserted +dimensions by Lemma~\ref{lem:curve-completion}, and the same applies +to the special fiber. The element $\varpi$ remains a +nonzerodivisor, so the enhanced ring is flat over the discrete +valuation ring $\mathcal L$. This proves the assertion about +$A^{\mathrm{rd}}$ and also shows why no special dyadic hypothesis is +needed. The construction can be repeated after any of the finite +extensions in the statement. + +\emph{The integral incidence for the \(i\)-type.} +We prove the tame assertions using proper incidences, keeping their +images distinct from the incidences themselves. In the $i$-case, +Cayley--Hamilton gives $\tau_j^2=-1$, hence +$\tau_j^{q_j}=\tau_j$. Adjoin a $\phi_j$-stable $i$-eigenline for +each $\tau_j$. This gives a closed proper incidence $Y_i$ in a +product of projective lines over $\Spec B_i$. In an adapted basis +on a slope chart, its matrices are +\[ +\tau_j=\begin{pmatrix}i&n_j\\0&-i\end{pmatrix},\qquad +\phi_j=\begin{pmatrix}1+d_j+x_j&h_j\\0&1+d_j\end{pmatrix}, +\] +and their sole remaining equation is +\begin{equation}\label{eq:i-incidence} +x_jn_j=2i h_j. +\end{equation} +The line slopes are free chart coordinates. + +Here is a completion argument which also works for all places at +once. On a product of affine slope charts put +\[ +C=\widehat{A[s_1,\ldots,s_u]}^{\,\mathfrak m_A}. +\] +This is completion along the entire closed fiber, not at a selected +slope origin. Restricted coefficient series embed it into +$A[[s_1,\ldots,s_u]]$, so $C$ is a domain. Exactness of completion +identifies $C/\varpi C$ with the corresponding restricted-series +ring over $A/\varpi A$, also a domain. Completion of the incidence +chart along that fiber is +\begin{equation}\label{eq:i-incidence-completion} +C[[x_j,n_j,h_j,d_j:1\le j\le u]]/ + (x_jn_j-2ih_j)_{j=1}^u. +\end{equation} +Reduce each monomial by replacing paired factors $x_jn_j$ by +$2ih_j$ until they never occur together. Assign weights $1,1,2$ +to $x_j,n_j,h_j$. Reduction preserves weight, so it converges in +the power-series topology and yields a normal form. The difference +between a monomial and its reduction is a sum of the relations +\eqref{eq:i-incidence} times series whose weights are lower by two; +these series converge as well. The +substitution +\[ +h_j\longmapsto x_jn_j/(2i) +\] +embeds these normal forms into +$\Frac(C)[[x_j,n_j,d_j:1\le j\le u]]$. Indeed the two output exponents +recover the exponent of $h_j$ as their minimum, and each output +coefficient receives only finitely many input terms. This proves +uniqueness of the normal form and shows that +\eqref{eq:i-incidence-completion} is a domain. This argument needs +no uniform bound on denominators. It also shows that the successive +relations are nonzerodivisors and gives dimension +$\dim A+4u=e$ on the incidence. + +We explain why chart completions suffice. At every point of the +closed fiber, localization of the chart maps faithfully flatly to a +localization of its completed chart. The latter is a domain, so the +incidence is locally integral there. Every irreducible component of +a proper scheme over a local base meets the closed fiber; so does +any nonempty closed intersection of components. Local integrality +therefore makes the components disjoint. The closed fiber is +$(\mathbf P^1_K)^u$, which is connected, hence there is only one +component. A nonempty nilradical support would also meet the closed +fiber, so the incidence is reduced. Thus $Y_i$ is integral. + +After inverting two the eigenline is uniquely given by the idempotent +$(\tau_j+i)/(2i)$, and the incidence projection is an isomorphism. +In characteristic two, commuting matrices have a common eigenline +after algebraic extension, so the proper projection covers every +geometric point as well. Its image is therefore all of +$\Spec B_i$ set-theoretically. The integral incidence is horizontal +and generically finite over that image. This proves assertion (1). +It does not assert that the raw ring $B_i$ is reduced. + +\emph{The horizontal unipotent patterns.} +For $\eta=1$, write $N_j=\tau_j-1$. The equations give +$N_j^2=0$ and $\phi_jN_j=q_jN_j\phi_j$. At a field point either +$N_j=0$, or its kernel and image are the same line. The first +alternative is the unramified factor, with $\phi_j$ unrestricted. +For the closure of the second alternative use the proper line +incidence with adapted matrices +\begin{equation}\label{eq:unipotent-incidence} +\tau_j=\begin{pmatrix}1&n_j\\0&1\end{pmatrix},\qquad +\phi_j=\begin{pmatrix}q_j(1+d_j)&h_j\\0&1+d_j\end{pmatrix}. +\end{equation} +At a nonzero $N_j$ the relation forces exactly this diagonal ratio. +Its chart has three formal matrix coordinates and one slope. + +Choose either alternative at each place. The resulting proper +incidence has free completed slope charts over $A$, so the same +closed-fiber argument proves that it is integral, horizontal, and +of dimension $e$. Its projection is an isomorphism where every +chosen ramified $N_j$ is nonzero, because the line is then +$\im N_j=\ker N_j$. Each image is consequently an integral +horizontal closed subset of dimension $e$. These finitely many +images cover all geometric points of $\Spec B_1$. + +\emph{Specialization and uniqueness of the containing component.} +The dimension calculation alone is not enough for support transfer: +we must know exactly which horizontal component contains each generic +special-fiber point. It remains to identify their specializations and +distinguish them. +The two raw presentations reduce to the same one modulo $\varpi$, +since $i\equiv1$ and $q_j$ is odd. At one place write +\[ +\tau=\begin{pmatrix}1+a&b\\c&1+a\end{pmatrix},\qquad +\phi=\begin{pmatrix}1+d&e'\\f&1+g'\end{pmatrix}. +\] +The common special matrix factor is +\begin{equation}\label{eq:tame-special-ring} +K[[a,b,c,d,e',f,g']]/ + (a^2+bc,\ b(d+g'),\ c(d+g'),\ bf+ce'). +\end{equation} +Its two reduced components are +\[ +U:\ a=b=c=0, +\qquad +R:\ g'=d,\quad a^2+bc=bf+ce'=0. +\] +Both have dimension four and are geometrically integral. For $R$, +prove this first in the homogeneous polynomial quotient. On $b\ne0$ +one eliminates $c=a^2/b$ and $f=a^2e'/b^2$, obtaining a domain. +The locus $b=0$ has dimension three, whereas every component of the +two-equation quotient has dimension at least four. There is thus +only one component, generically reduced. The quotient is a +complete intersection and has no embedded primes, so it is a +domain. Completion is the product of its finite homogeneous pieces; +lowest-degree nonzero terms show that it remains a domain. The +same proof works over every field extension. This argument is +made before completion; it does not substitute into arbitrary +formal series after inverting $b$. + +For several places over $A/\varpi A$, the polynomial products of +the chosen $U$ and $R$ factors are flat over that base and have +geometrically integral generic fiber. They are domains, and the +same homogeneous completion argument applies, completing the base +coefficients and then the positive-degree variables. Each pattern +therefore gives an integral special-fiber component of dimension +$e-1$. Reduction of its proper incidence is integral and maps +onto precisely this component. Proper surjectivity onto the image +is preserved by base change, so this is the entire underlying +specialization of the corresponding horizontal image. + +The patterns are distinct. On the generic ramified special piece +$\tau_j\ne1$, whereas every unramified piece has $\tau_j=1$. +On the generic unramified piece $\tr\phi_j\ne0$, whereas every +ramified special piece has $\tr\phi_j=0$. Thus no horizontal image +contains the generic special point of a different pattern. The +images already cover the raw spectrum, proving assertions (2) and +(3), including uniqueness of the horizontal component through +each special-fiber generic point. +\end{proof} + +\begin{remark} +The common raw special fiber need not be reduced. In +\eqref{eq:tame-special-ring}, the element $a(d+g')$ can be nonzero +with square zero. The proper incidence is also not a normalization: +over $\tau=\phi=1$ its fiber contains $\mathbf P^1$. Our conclusions +concern precisely the spectra, components, and universal matrix +actions required for support propagation, and do not make either +of these stronger assertions. +\end{remark} + +\subsection{Several marked scalar places} + +The marked local condition used in connectedness is different from +the unrestricted dyadic condition. At a scalar residual dyadic +representation, record an invariant line and retain no other local +restriction. We need the reduced characteristic-two local base, +jointly with the real factors, to be integral. Connectedness will use +this entire completed product as a domain, so integrality of each +individual dyadic factor does not suffice. + +\begin{lemma}[Simultaneous marked factors]\label{lem:marked-local-base} +Over a finite characteristic-two field, take $d$ fixed-determinant +real framed factors and $m$ dyadic framed factors whose residual +matrices are scalar, with one invariant line recorded at each +dyadic factor. The determinant is fixed, and after the residual +scalar twist its dyadic reduction is one. The reduction of their +completed local product is an integral complete-intersection base +of dimension +\[ +2d+5m. +\] +It remains integral after a finite extension of the residue field. +Equivalently, one may first kill the nilpotent torsion parameters in +the diagonal character rings; the resulting completed product is +already reduced and integral and has the same spectrum as the +original product. +\end{lemma} + +\begin{proof} +Move a marked line in its one-dimensional formal chart and choose +the corresponding adapted basis. After the scalar twist, the +diagonal entries are characters $\lambda,\lambda^{-1}$ congruent +to one. Their reduced character ring is +\[ +C_0=\kk[[x,y]]. +\] +Indeed $\QQ_2^\times$ has maximal pro-$2$ quotient +$\ZZ/2\ZZ\times\ZZ_2^2$, and the first factor contributes only a +nilpotent character parameter in characteristic two. + +The maximal pro-$2$ Galois group of $\QQ_2$ has three generators +and one relation. The odd-degree dyadic case was established by +Serre \cite[Sections~4.4 and~8]{Serre1964Demushkin}; in Labute's +classification, the $q=2$, odd-local-degree case gives generators +with relation +$g_1^2g_2^4[g_2,g_3]=1$ +\cite[\S5, Theorem~8]{Demushkin}. If $b(g)$ is the upper-right entry +of the triangular matrix with diagonal entries +$\lambda(g),\lambda(g)^{-1}$, put $c(g)=\lambda(g)b(g)$. Matrix +multiplication gives the left-cocycle identity +\[ +c(gh)=c(g)+\lambda(g)^2c(h). +\] +Its values $u_j=c(g_j)$ satisfy one homogeneous linear equation +\begin{equation}\label{eq:marked-cocycle} +a_1(x,y)u_1+a_2(x,y)u_2+a_3(x,y)u_3=0. +\end{equation} +All these deformations factor through the maximal pro-$2$ quotient: +their reduction is the identity and their finite coefficient +quotients have pro-$2$ congruence image. Thus this presentation +does describe the complete triangular deformation ring after the +diagonal reduction, rather than just a subfunctor of it. + +Write $B=1+x=\lambda(g_2)$ and $C=1+y=\lambda(g_3)$. +The reduced diagonal relation gives $\lambda(g_1)=B^{-2}$. +Using $[g_2,g_3]=g_2^{-1}g_3^{-1}g_2g_3$ and this left-cocycle +identity, direct substitution gives +\[ + (a_1,a_2,a_3)= + \left(\frac{x^4}{B^4},\; + \frac{x^6}{B^8}+\frac{y^2}{B^2C^2},\; + \frac{x^2}{B^2C^2}\right). +\] +Multiply \eqref{eq:marked-cocycle} by the unit $B^2C^2$ and set +\[ + v=u_3+\frac{x^2C^2}{B^2}u_1+\frac{x^4C^2}{B^6}u_2. +\] +This triangular formal change of variables transforms the relation +into $x^2v+y^2u_2=0$. Thus the coefficient ideal is exactly +$(x^2,y^2)$ and its radical is $(x,y)$; the ideal itself is not +radical. + +Let $A_\infty$ be the completed real special-fiber product. The +real calculation in Proposition~\ref{prop:local-geometry} makes it +an excellent Cohen--Macaulay domain of dimension $2d$. Adjoin the +independent pairs $x_j,y_j$ and the line variables $s_j$, obtaining +\[ +A_0=A_\infty[[x_j,y_j,s_j:1\le j\le m]]. +\] +Before completing the upper entries, form the graded algebra +\begin{equation}\label{eq:marked-polynomial-product} +P=A_0[u_{jr}:1\le j\le m,\ 1\le r\le3]/(f_1,\ldots,f_m), +\end{equation} +where each $f_j$ is the corresponding relation +\eqref{eq:marked-cocycle}. The coefficients of $f_j$ involve only +$x_j,y_j$ and have common-zero locus $(x_j,y_j)$. + +On a base stratum where exactly $r$ coefficient rows vanish, the +base loses $2r$ dimensions and the upper-entry fiber gains only +$r$ dimensions. Thus the corresponding locus in $\Spec P$ has +dimension at most +\[ +\dim A_0+2m-r. +\] +Every minimal prime of the homogeneous relation ideal is homogeneous +and is contained in $(\mathfrak m_{A_0},u_{jr})$. In that excellent +equidimensional local ambient ring, the height theorem for the +$m$ equations makes every component have dimension at least +$\dim A_0+2m$. No component can therefore lie over a nonempty +rank-drop stratum. Where all coefficient rows are nonzero, the +quotient is a vector bundle of rank $2m$ over an integral base. +There is consequently only one component, generically reduced. + +The same argument for every initial subset of the equations shows +that their heights are the expected ones. They form a regular +sequence in the Cohen--Macaulay ambient ring. The quotient has no +embedded associated primes, and generic reducedness now proves +that $P$ is a domain. + +Finally, each homogeneous piece $P_n$ is a finite, torsion-free +$A_0$-module. Over $F_0=\Frac(A_0)$ the $m$ independent linear +relations eliminate one upper-entry variable in each triple, so +\[ +\prod_{n\ge0}P_n + \lhook\joinrel\longrightarrow +\prod_{n\ge0}(P_n\otimes_{A_0}F_0) + \simeq F_0[[v_1,\ldots,v_{2m}]] +\] +is an embedding of rings. Since $A_0$ and its finite modules are +complete, the left side is precisely the completed local product +in question. It is a domain, of dimension +$\dim A_0+2m=2d+5m$. It is also a complete intersection by the +regular sequence already exhibited. + +Killing the original diagonal torsion parameters changes no prime +ideal: each is nilpotent, and the ideal they generate is +nilpotent. The obtained quotient is already reduced, proving the +assertion about the original reduction. The real normality and +the cocycle and dimension arguments hold after every finite +constant extension, proving the final assertion. +\end{proof} + +The two local outputs will be used separately. Propagation uses the +unrestricted real--dyadic base and the correspondence between the +horizontal tame components and their common special fiber. +Connectedness uses the integral marked base of dimension \(2d+5m\). +The latter statement includes no normality assertion, and neither +construction replaces the raw tame rings by their incidences. diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/fields.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/fields.tex new file mode 100644 index 0000000000000000000000000000000000000000..c424b3490f529b1a1a92e457af417248f0790619 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/fields.tex @@ -0,0 +1,789 @@ +\section{Fields with controlled Selmer groups}\label{sec:fields} + +The connectedness argument needs large totally real fields, very few allowed +non-dyadic primes, and a strict Selmer bound at a small proportion of the +dyadic places. We construct these fields here. The original allowed set, +including the primes needed for the modular seed, is fixed before this +construction. + +Let $\Sigma$ be a finite set of odd rational primes, and let $\bar r$ be a +semisimple representation of $G_{\QQ}$ over a sufficiently large finite +field $k$ of characteristic two, unramified outside $\Sigma\cup\{2\}$. +If $\bar r$ is reducible, write its two characters as +$\bar\chi_1,\bar\chi_2$ and put $\alpha=\bar\chi_1/\bar\chi_2$. +Thus $\alpha$ has odd order, is even, and is unramified at $2$. +The last assertion follows from +$\ZZ_2^\times$ being a pro-$2$ group. Write $\alpha_2$ for its +restriction to $G_{\QQ_2}$. +For a number field $E$ and a finite set $S_E$ containing the dyadic and +real places, all Selmer groups below are subspaces of +$H^1(G_{E,S_E},k(\beta))$; at places outside $S_E$ their local condition +is unramified. + +\begin{proposition}[Field preparation]\label{prop:field-preparation} +There is a constant $U$, depending only on the fixed residual data and +$\Sigma$, with the following property. One can construct abelian, +totally real $2$-extensions +\[ + \QQ\subset A\subset F +\] +in which $2$ splits completely, together with allowed sets $S_A,S_F$, +such that the following assertions hold. +\begin{enumerate} +\item The allowed sets contain the real and dyadic places and all places +above $\Sigma$. Their numbers $u_A,u_F$ of non-dyadic finite places +are at most $U$. The degrees $d_A=[A:\QQ]$ and $[F:A]$ can be +made arbitrarily large, with $d=[F:\QQ]=[F:A]d_A$. +\item If $\bar r$ is absolutely irreducible, its restriction to $G_F$ +is absolutely irreducible. In this case there are no marked places. +\item In the reducible case, the characters remain distinct on $G_F$ +if they were distinct on $G_{\QQ}$. If $\alpha_2\ne1$, there are +again no marked places. If $\alpha_2=1$, there is a dyadic place +$v_0$ of $A$ and the marked set $M$ consists of all its extensions +to $F$. Set $m=|M|$; thus $m=[F:A]$ and $m/d=1/d_A$ in the +marked case, whereas $m=0$ otherwise. +\item In the reducible case, for $\beta=\alpha,\alpha^{-1}$ the +following group is zero: +\begin{equation}\label{eq:dual-vanishing} + \left\{c\in H^1(G_{F,S_F},k(\beta)): + \operatorname{loc}_v(c)=0\text{ for every }v\in S_F\setminus M + \right\}=0. +\end{equation} +Here the zero conditions include all real places. The condition at a +marked place is unrestricted. +\item In the reducible case, restriction preserves residual extension +classes: for either ratio +$\beta$, the map +\[ + H^1(G_{A,S_A},k(\beta))\longrightarrow H^1(G_{F,S_F},k(\beta)) +\] +is injective. +\end{enumerate} +In the reducible case let $H^1_{\mathrm{str}}(F,k(\beta))$ denote the +Selmer group with zero condition at $M$, full condition at +$S_F\setminus M$ (including the real places), and unramified condition +elsewhere. Then +\begin{equation}\label{eq:strict-selmer} + \dim_k H^1_{\mathrm{str}}(F,k(\beta))\le + \begin{cases} + d+u_F,&\alpha_2\ne1,\\ + 2d-3m+u_F,&\alpha_2=1. + \end{cases} +\end{equation} +\end{proposition} + +The field construction has three cases. For absolutely irreducible +residue, a cyclic extension disjoint from the residual splitting field +will suffice. For scalar residue, a narrow-class-group argument will +give the required vanishing. For distinct residual characters, we will +choose conductor primes successively so that changing the local Selmer +conditions removes classes without introducing new ones. In each case +we must bound the number of allowed primes independently of the degrees +of the fields; this is what permits the strict dimension inequalities +used in Section~\ref{sec:connectedness}. + +We use class field theory with real places in the modulus +\cite[Chapter~V, Theorems~1.7, 3.5, and~3.6]{MilneCFT}, the Kummer +identification, and inflation--restriction. Local and global duality +give the following Selmer dimension formula for a finite coefficient +module $V$ and linear local conditions $\mathcal L$: +\begin{equation}\label{eq:field-selmer-formula} + \begin{aligned} + \dim H^1_{\mathcal L}(V)-\dim H^1_{\mathcal L^\perp}(V^\vee(1)) + &=h^0(V)-h^0(V^\vee(1))\\ + &\quad+\sum_v\bigl(\dim\mathcal L_v-h^0_v(V)\bigr). + \end{aligned} +\end{equation} +This is obtained by taking dimensions in Poitou--Tate and using the +global Euler formula +\cite[Chapter~I, Theorems~4.10 and~5.1, Remark~5.2(a)]{Milne2006}. +The real places are retained; their $h^0_v$ in this formula is ordinary +invariant dimension. Our coefficient characters are trivial at real +places, so local $H^1$ there has dimension one. + +\subsection{Cyclic fields and a scalar genus argument} + +Fix integers $n>a\ge1$. If an odd prime $r$ satisfies +\begin{equation}\label{eq:conductor-power} + r\equiv1\pmod{2^{n+1}},\qquad + 2\in(\FF_r^\times)^{2^n}, +\end{equation} +the degree-$2^n$ cyclic subfield $L(r,n)$ of $\QQ(\zeta_r)$ is real +and has $2$ split completely. It is totally ramified at $r$ and +unramified at other finite primes. For an odd prime $\ell\ne r$, +the Frobenius of $\ell$ generates its Galois group precisely when +$\ell$ is a nonsquare modulo $r$. Indeed, both assertions are read +in the cyclic quotient of $\FF_r^\times$ of order $2^n$; an element +generates that quotient if and only if its exponent in +$\FF_r^\times$ is odd. + +The power conditions in \eqref{eq:conductor-power} say that $r$ splits +in the Galois $2$-extension +\[ + E_n=\QQ(\zeta_{2^{n+1}},2^{1/2^n}). +\] +This extension is unramified at odd primes. Consequently, independent +square-root conditions at specified odd primes are compatible with +splitting in $E_n$: any nontrivial product of their squareclasses is +ramified at an odd prime, whereas every quadratic subfield of $E_n$ +is unramified there. Chebotarev +\cite[Chapter~V, Theorem~3.23]{MilneCFT} therefore supplies $r$ satisfying +\eqref{eq:conductor-power} with every $\ell\in\Sigma$ nonsquare +modulo $r$. One can avoid any further fixed finite set of primes. + +This already proves the field assertion for absolutely irreducible +$\bar r$: take $F=L(r,n)$ and its degree-$2^a$ subfield for $A$. +Choose $r$ unramified in the residual splitting field. Every nontrivial +subextension of $F/\QQ$ is ramified at $r$, so $F$ is disjoint from +that splitting field. The residual image is therefore unchanged. +Each $\ell\in\Sigma$ has one prime above it at every cyclic layer. +The prime $r$ need not be allowed, since restricting a representation +does not introduce ramification at a prime where it was unramified. + +This completes the construction for absolutely irreducible residue: +the residual image is unchanged and the number of allowed primes is +bounded independently of the cyclic degree. For scalar residue we +also need the Selmer vanishing in \eqref{eq:dual-vanishing}. We obtain +it from a different fixed base field and the following elementary +form of the one-prime genus argument. + +\begin{lemma}\label{lem:one-prime-genus} +Suppose that $K/E$ is a quadratic extension of totally real fields +and that exactly one finite prime of $E$ ramifies. If the narrow +class number of $E$ is odd, the narrow class number of $K$ is odd. +For every totally real field with odd narrow class number, each +totally positive unit is a square. +\end{lemma} + +\begin{proof} +If the narrow class number of $K$ were even, the nonzero +$\FF_2$-space $\operatorname{Cl}^+(K)/2$ would have a nonzero +invariant linear functional for $\Gal(K/E)$. Here we use the +elementary fact that a nonzero module of a finite $2$-group in +characteristic two has nonzero invariants, applied to the dual module. +Class field theory would give a quadratic extension $H/K$, +unramified at every finite prime, which is Galois over $E$. +The group $G=\Gal(H/E)$ has order four. Above the unique finite prime +ramified in $K/E$, its inertia group $I$ has order two and maps +isomorphically to $\Gal(K/E)$. It thus has trivial intersection with +$\Gal(H/K)$. This excludes $G\simeq\ZZ/4\ZZ$, whose only subgroup +of order two is $\Gal(H/K)$. Hence $G$ is the Klein four group. +All inertia groups above that prime equal $I$, since $G$ is abelian, +and all other finite inertia groups are trivial. The quadratic +extension $H^I/E$ is consequently unramified at all finite primes, +contrary to oddness of the narrow class number of $E$. Ramification +at infinity is allowed by the narrow class field and causes no +exception to this argument. + +For the last assertion, the signature cokernel of the units is a +$2$-group embedded in the narrow class group, so it is zero. +For a totally real field of degree $e$, Dirichlet's unit theorem +\cite[Theorem~5.1]{MilneANT} gives +$|\mathcal O_E^\times/(\mathcal O_E^\times)^2|=2^e$. +The signature map from this group onto $\{\pm1\}^e$ is therefore +an isomorphism. Its kernel is the group of totally positive units +modulo squares. +\end{proof} + +Now suppose $\alpha=1$. Put +\[ + B=\QQ(\sqrt{17}),\qquad + \pi=\frac{5+\sqrt{17}}2. +\] +The Minkowski bound \cite[Theorem~4.3]{MilneANT}, here +$\sqrt{17}/2<3$, says that every ideal class of +$B$ has a representative of norm one or two. Both primes above two +are principal, generated by $\pi$ and its conjugate, so the ordinary +class number is one. The units $-1$ and $4+\sqrt{17}$ realize every +signature; the latter has norm $-1$. Thus the narrow class number +is also one. + +Choose $r$ as above, additionally inert in $B$, and put +\[ + F=B L(r,n),\qquad A=B L(r,n)_a, +\] +where the subscript denotes the degree-$2^a$ layer. Inertness in +$B$ is the extra condition that $17$ be a nonsquare modulo $r$. +It is compatible with all the preceding conditions, including when +$17\in\Sigma$, in which case it repeats an existing condition. +Each quadratic step of $B L(r,n)/B$ has exactly one finite ramified +prime, the prime over $r$. Lemma~\ref{lem:one-prime-genus} implies +that $F$ has odd narrow class number and that its totally positive +units are squares. Take $S_A,S_F$ to contain only the prescribed +places above $\Sigma$, two, and infinity; in particular $r$ is not +allowed. There are at most two primes above any $\ell\in\Sigma$. + +Let $w_1$ be the dyadic prime of $B$ generated by $\pi$, and $w_2$ +the other dyadic prime. Both embeddings of $\pi$ into $\mathbb R$ are +positive. At $w_2$ it is a unit congruent to seven modulo eight: +the odd root of $X^2-5X+2$ is seven modulo eight. Thus $\pi$ is not +a square in $B_{w_2}=\QQ_2$. + +Choose any $v_0$ of $A$ above $w_1$. We prove a stronger version of +\eqref{eq:dual-vanishing}, allowing arbitrary localization at every +place of $F$ above $w_1$. It suffices to work with $\FF_2$ +coefficients. By Kummer theory a class in this enlarged group is +represented by a totally positive $x\in F^\times$ modulo squares. +Its valuations are even outside the set $T$ of dyadic places above +$w_1$, and it is locally a square at all places above $w_2$. +The valuation-parity map +\begin{equation}\label{eq:scalar-parity} + [x]\longmapsto (v(x)\bmod2)_{v\in T} + \quad\hbox{into }\FF_2^T +\end{equation} +is injective even on the larger space of totally positive squareclasses +with even valuations outside $T$. Indeed, zero parity gives +$(x)=\mathfrak a^2$; odd ordinary class number makes $\mathfrak a$ +principal, and division by a square leaves a totally positive unit, +which is a square by Lemma~\ref{lem:one-prime-genus}. + +Our Selmer subspace is stable under the $2$-group $\Gal(F/B)$. +If nonzero, it has a nonzero invariant vector. The action on $T$ is +transitive, so injectivity of \eqref{eq:scalar-parity} forces the +parity vector of that invariant to be the all-ones vector. +The unique totally positive squareclass with this parity is $[\pi]$: +it has valuation one at every place above $w_1$, and the injectivity +just proved gives uniqueness. But $\pi$ is nonsquare at every place +above $w_2$, since these completions are still $\QQ_2$. +This contradiction proves the required vanishing, also after extending +coefficients from $\FF_2$ to $k$. + +Finally, the kernel of restriction of scalar $H^1$ from $A$ to $F$ +consists of characters factoring through the cyclic group $\Gal(F/A)$. +It is generated over $k$ by the unique nonzero $\FF_2$-valued +quadratic character, and every nonzero multiple is ramified above $r$. +As $r\notin S_A$, these characters are excluded. This proves the +restriction assertion in the scalar case. + +\subsection{Switching local conditions} + +The scalar case is now complete. With distinct residual characters, +we will replace the class-group argument by successive changes of local +conditions. The next lemma explains why a switch removes classes when +the opposite Selmer group supplies enough local evaluations. + +For the rest of the construction assume $\alpha\ne1$. Put +$k_0=\FF_2(\alpha)$ and $q=|k_0|\ge4$. Both $\alpha$ and +$\alpha^{-1}$ are defined over $k_0$; the desired conclusions over +$k$ follow by extension of scalars, since the continuous cochain +complexes and all the specified local conditions commute with this +finite scalar extension. Write $K_\alpha$ for the cyclic, +totally real, odd-degree field cut out by $\alpha$. + +This construction uses the viewpoint of Ramakrishna's auxiliary-prime +switching strategy~\cite{Ramakrishna2002}; see also the exposition in +Tang~\cite[Section~3A2, proof of Theorem~3.4]{Tang2019}. +The rank-one characteristic-two variant needed here is proved below, +rather than obtained by applying either reference's lifting theorem. + +We first record the exact local switch used below. At an odd place +where the coefficient character is trivial and the residue cardinality +is one modulo four, local $H^1$ is two-dimensional. Its unramified +line $L_{\mathrm{ur}}$ is self-orthogonal. Any line generated by a +ramified quadratic character is transverse to it and is also +self-orthogonal, for the pairing with the opposite coefficient. +Indeed, the mod-two Hilbert pairing is alternating when $-1$ is a +local square, and a line in a two-dimensional nondegenerate alternating +space is its own annihilator. + +\begin{lemma}[Local switching]\label{lem:selmer-switch} +Let $X$ be a Selmer group over a number field $E$ with one-dimensional +coefficient $k_0(\beta)$, and let $Y$ be the Selmer group with coefficient +$k_0(\beta^{-1})$ and orthogonal local conditions. Let $T$ be a finite +set of odd places of $E$ where the coefficient character is trivial +and the residue cardinality is one modulo four. Suppose that $X$ has +the unramified local condition at every place in $T$, and that evaluation +of $Y$ on unramified Frobenius gives a surjection +\[ + Y\longrightarrow k_0^T. +\] +Replacing the unramified lines at $T$ by arbitrary transverse ramified +lines changes $X$ to +\[ + \ker\bigl(X\longrightarrow k_0^T\bigr). +\] +In particular the switch introduces no new classes, and it strictly +decreases $X$ if its own evaluation is nonzero. +\end{lemma} + +\begin{proof} +Let $X^{\mathrm{rel}}$ have full condition at $T$ and the old +conditions elsewhere. The relevant part of the Poitou--Tate comparison +sequence is +\[ + 0\longrightarrow X\longrightarrow X^{\mathrm{rel}} + \longrightarrow\bigoplus_{v\in T} H^1_v/L_{\mathrm{ur},v} + \longrightarrow Y^\vee. +\] +The last arrow is the transpose of localization on $Y$ under the +perfect pairings +$H^1_v/L_{\mathrm{ur},v}\times L_{\mathrm{ur},v}\to k_0$. +It is injective by the hypothesis, so $X^{\mathrm{rel}}=X$. +The new Selmer group is a subspace of this unchanged relaxed group. +Its localizations must belong both to the old unramified line and the +new transverse line, hence must be zero. This gives the asserted +kernel exactly. +\end{proof} + +\subsection{Frobenius evaluations with splitting conditions} + +Take $B=\QQ$ if $\alpha_2\ne1$. If $\alpha_2=1$, choose a prime +$q_0\notin\Sigma\cup\{2\}$ with +\[ + q_0\equiv1\pmod8,\qquad + \alpha(\operatorname{Frob}_{q_0})\ne1, +\] +and take $B=\QQ(\sqrt{q_0})$. Such a prime exists by Chebotarev, +since the odd-degree extension $K_\alpha$ is disjoint from +$\QQ(\zeta_8)$. In this second case let $w_1,w_2$ be the two +dyadic places of $B$ and let $\sigma$ be its nontrivial automorphism. + +All later conductor primes will satisfy \eqref{eq:conductor-power}, +split in $K_\alpha$, and avoid the original primes and $q_0$. +The first conductor $r_1$ also splits in $B$, with every +$\ell\in\Sigma$ nonsquare modulo $r_1$. Compatibility follows +from the independence of the odd squareclasses just used and from +the coprimality of $[K_\alpha:\QQ]$ with every auxiliary $2$-degree. +For each subsequent conductor $r$, require every +$\ell\in\Sigma$ and every earlier conductor to be a square modulo +$r$. These conditions say that $r$ splits in a finite Galois +$2$-extension $E_2$ obtained by adjoining $E_n$ and those square roots. +In the quadratic-$B$ case, $E_2$ is unramified at $q_0$. +Consequently $B\cap E_2=\QQ$; the same is true of +$B\cap K_\alpha E_2$. We can therefore impose either splitting or +inertness in $B$ at a new conductor. In particular, $B$ is not included +among the fields required to split at the final inert step. + +\begin{lemma}[Evaluation freedom]\label{lem:field-evaluations} +Fix finitely many cohomology classes over $B$ with coefficients +$k_0(\beta)$, where $\beta=\alpha$ or $\alpha^{-1}$, and impose +the preceding splitting conditions in $K_\alpha E_2$. +Evaluations use chosen places above the rational prime and chosen +Frobenius representatives in a common finite quotient through which +the coefficient actions and the finitely many cocycles factor. +Numerical prescriptions refer to these choices. +\begin{enumerate} +\item At primes split also in $B$, a Frobenius evaluation on any +$k_0$-linearly independent collection of classes can be prescribed +arbitrarily. If $B$ is quadratic, the pair of evaluations on a +space $W$ at the two places above such a prime is given by one +functional restricted to $W$ and $\sigma W$. It is uniformly +distributed as two independent functionals on $W$ whenever +$W\cap\sigma W=0$. +\item In the quadratic case, for primes inert in $B$ the evaluations +on $W$ are uniformly distributed in $W^\vee$ whenever +$1+\sigma$ is injective on $W$. The evaluations on $c$ and +$\sigma c$ at the single place above such a prime are equal. +\item Collections for different Frobenius orbits of coefficient +characters can be prescribed independently. If +$\alpha^{-1}=\alpha^{2^j}$, coefficient Frobenius identifies the +two collections semilinearly, and preserves all zero and rank +conditions used here. +\end{enumerate} +Every compatible prescription is realized, for suitable choices of +these places and representatives, at infinitely many rational primes. +Uniform distribution refers to the finite evaluation quotients used +for this choice; no analytic density estimate is required. +Chebotarev determines simultaneous conjugacy classes. The applications +below use only rank and nonvanishing conditions, unchanged by the +resulting coefficient scalings and interchange of the two split places. +\end{lemma} + +\begin{proof} +Set $N=G_{B K_\alpha E_2}$. The finite quotient +\[ + \Gal(B K_\alpha E_2/B)=C\times P +\] +has $C=\Gal(K_\alpha/\QQ)$ of odd order and $P$ a $2$-group. +On $k_0(\beta)$ the group $C$ acts nontrivially. Averaging over $C$ +and using $k_0(\beta)^C=0$ gives +$H^i(C\times P,k_0(\beta))=0$ for all $i\ge0$. +Inflation--restriction thus makes restriction to $N$ injective. +On $N$ the coefficients are trivial, so cocycles are additive +homomorphisms and coboundaries are zero. + +For independent classes $c_1,\ldots,c_t$, their joint evaluation map +$N\to k_0^t$ has additive image stable under multiplication by +$\beta(C)$. These scalars generate $k_0$ over $\FF_2$, so its +image is a $k_0$-subspace. If it were proper, a nonzero linear +functional annihilating it would give a nontrivial linear combination +of the $c_i$ restricting to zero on $N$, a contradiction. Its image +is therefore all of $k_0^t$. The paired assertion follows by applying +this to $W+\sigma W$; trivial intersection makes its two summands +independent. The conjugation formula for cocycles identifies these +with the evaluations at the two conjugate places. + +For the inert assertion choose $g\in G_{\QQ}$ acting nontrivially +on $B$ and trivially on $K_\alpha E_2$. Then $g^2\in N$, and +$g$ represents $\sigma$ on cohomology. Since $\beta(g)=1$, for +$h\in N$ the cocycle identity gives +\begin{equation}\label{eq:inert-evaluation} + c((gh)^2)=c(g^2)+\operatorname{ev}_h((1+\sigma)c). +\end{equation} +The first term is a fixed affine offset. The proven evaluation +surjectivity on $(1+\sigma)W$ shows that this expression is uniform +in $W^\vee$ if $1+\sigma$ is injective on $W$. Also +$c(g^2)=(\sigma c)(g^2)$ and +$(1+\sigma)\sigma c=(1+\sigma)c$ in cohomology. Evaluations on +$N$ do not see coboundaries, so \eqref{eq:inert-evaluation} gives +equality for $c$ and $\sigma c$, including the affine offset. + +For different Frobenius orbits, regard these evaluation images as +$\FF_2[C]$-modules. They have different simple isotypes; semisimplicity +of $\FF_2[C]$ makes their joint image the product of the individual +images. In the remaining case the automorphism $x\mapsto x^{2^j}$ +of $k_0$ carries cocycles with coefficient $\alpha$ to those with +coefficient $\alpha^{-1}$. It commutes with restriction, +conjugation, and evaluation. Every ramified line below is generated +by an $\FF_2$-valued quadratic character, so these lines, as well as +the zero, full, and unramified conditions, are preserved. All +evaluation matrices are entrywise Frobenius transforms and have the +same ranks. + +The finite collection of cocycles factors through a finite quotient +after adjoining their coefficient fields. Chebotarev realizes the +conjugacy class of the chosen element of this quotient. Choosing a +place in the corresponding finite Galois extension above the rational +prime then chooses a Frobenius representative; +one may choose the prescribed representative in that class. +Conjugacy scales coefficient evaluations and may interchange the +two split places, which preserves every rank and nonvanishing +condition in use. Removing finitely many primes leaves infinitely +many choices. +\end{proof} + +\subsection{The distinct-character construction} + +Given the chosen conductors $r_1,\ldots,r_t$, take a diagonal cyclic +quotient of the product of the degree-$2^n$ fields $L(r_j,n)$: +if $\gamma_j:G_{\QQ}\to\ZZ/2^n\ZZ$ defines its $j$th factor, +use $\gamma=\sum_j c_j\gamma_j$ with every $c_j$ odd. Let $L$ +be the field of $\gamma$, let $L_a$ be its degree-$2^a$ layer, and +write +\[ + F=BL,\qquad A=BL_a,\qquad \delta=\gamma\bmod2. +\] +When $B$ is quadratic, choose any $v_0$ of $A$ above $w_1$ and +mark all its extensions to $F$. +The character $\delta$ is the quadratic sum of the conductor +characters. Every $r_j$ is totally ramified in $L$, and $2$ is +split. At each original $\ell\in\Sigma$, the first summand of +$\gamma(\operatorname{Frob}_\ell)$ is odd and all later summands +are even, so its Frobenius has order $2^n$. +At a previous conductor, adjoining a new conductor does not change +the local quadratic line $k_0\delta$: the new quadratic character +is unramified and trivial there. This follows from the imposed +square conditions and quadratic reciprocity, since all conductors +are one modulo four. + +The allowed sets now include primes above all the $r_j$, in addition +to the original allowed places. They do not need to include $q_0$. +For $\beta=\alpha,\alpha^{-1}$ define $X_B^\beta$ as follows: +\begin{itemize} +\item its real conditions are zero; +\item if $B=\QQ$, its dyadic condition is zero; if $B$ is quadratic, +its dyadic conditions are full at $w_1$ and zero at $w_2$; +\item its other conditions are unramified, except above the $r_j$, +where they are the lines $k_0\delta$. +\end{itemize} +At a conductor the coefficient is trivial, since $r_j$ splits in +$K_\alpha$. These definitions therefore make sense, including at +a possible inert conductor. + +The remaining objective is to kill both spaces $X_B^\beta$ while +keeping the number of conductors bounded. First we explain why this +vanishing gives the desired Selmer condition over the large field $F$; +we then construct the switches that achieve it. + +Killing both spaces $X_B^\beta$ suffices for +\eqref{eq:dual-vanishing}. To see this, in the quadratic case first +enlarge the possible marked set to all places above $w_1$. +The resulting Selmer space over $F$ is stable under the cyclic +$2$-group $\Gal(F/B)$. If it were nonzero it would have a nonzero +invariant class. Since $k_0(\beta)^{G_F}=0$, +inflation--restriction identifies these invariant classes with +classes over $B$. At two and infinity the local conditions descend +unchanged, because these places split completely. Away from the +conductors, $F/B$ is unramified, so a class whose restriction is +locally unramified has unramified localization downstairs. This +applies both outside the allowed set and where localization was +required to vanish. At a conductor +the local extension is cyclic and totally ramified of degree $2^n$, +and the kernel of local restriction is precisely the line of its +quadratic character, namely $k_0\delta$. Thus the descended class +belongs to $X_B^\beta$, giving the asserted sufficiency. For +$B=\QQ$ the same argument has no enlarged marked set. + +\smallskip +\noindent\emph{The case $B=\QQ$.} +Suppose first that $B=\QQ$, so $\alpha_2\ne1$. For $X_B^\beta$ +the Selmer dimension formula gives +\begin{equation}\label{eq:q-selmer-difference} + \dim X_B^\beta-\dim (X_B^\beta)^{\mathrm{dual}}=-1. +\end{equation} +Here the dual group has coefficient $\beta^{-1}$ and orthogonal +conditions. The real zero condition contributes $-1$; the dyadic +zero condition contributes zero, since its local invariants vanish; +all other local conditions contribute zero. Both global invariant +terms vanish. Each opposite dual is therefore nonzero. + +Append a conductor split in $K_\alpha E_2$ at which every opposite +dual has nonzero evaluation, and every nonzero $X_B^\beta$ also has +nonzero evaluation. Such a choice exists by +Lemma~\ref{lem:field-evaluations}: per coefficient isotype there +are at most two required nonvanishings, and the failure probability +is at most $2/q<1$. Different isotypes can be prescribed separately; +Frobenius-conjugate inverse characters impose identical conditions. +Lemma~\ref{lem:selmer-switch} says that neither space gains classes +and that each nonzero space decreases. Repeating kills both spaces. + +\smallskip +\noindent\emph{Preparing the quadratic case.} +It remains to carry out this argument when $B$ is quadratic, so +$\alpha_2=1$. We first impose an auxiliary vanishing over $\QQ$. +Let $X_0^\beta$ have zero dyadic condition, full real condition, and +the same non-dyadic conditions as $X_B^\beta$ (unramified away from +the conductors, and $k_0\delta$ at them). Its dimension minus that +of its opposite dual is again $-1$: the dyadic contribution is +$-1$, the real contribution is zero, and all other contributions +are zero. Restriction +$H^1(G_{\QQ},k_0(\beta))\to H^1(G_B,k_0(\beta))$ is injective, +since $H^0(G_B,k_0(\beta))=0$. Rational classes and their opposite +duals can therefore be included in the evaluation spaces over $B$ +in Lemma~\ref{lem:field-evaluations}. Use the preceding +one-coordinate switching argument to +kill both $X_0^\beta$, requiring all the added conductors to split +also in $B$. Lemma~\ref{lem:field-evaluations} permits this extra +splitting. Keep all the resulting local switches. + +Let $Y_B^\beta$ be the group with coefficient $\beta$ whose +conditions are dual to those of $X_B^{\beta^{-1}}$. Thus its real +conditions are full, and its dyadic conditions are zero at $w_1$ +and full at $w_2$. Its other conditions are the same as those of +$X_B^\beta$. The dimension formula and conjugation give +\begin{equation}\label{eq:b-selmer-comparison} + \dim Y_B^\beta=\dim X_B^{\beta^{-1}}+1, + \qquad \sigma X_B^\beta\subset Y_B^\beta. +\end{equation} +Indeed, for $X_B$ the two dyadic contributions are $2$ and $-1$, +the two real contributions are $-1$ each, and the remaining +contributions vanish. The inclusion follows from the local +conditions: conjugation exchanges the dyadic conditions and the +real zero conditions are contained in the full ones. + +The following table summarizes the four groups used in the quadratic +case. Every row has coefficient $k_0(\beta)$, and ``full'' means the +full local $H^1$. The two entries for $B$ are ordered as $(w_1,w_2)$; +the single entry for $\QQ$ is the condition at $2$. +\begin{center} +\small +\begin{tabular}{@{}llcc@{}} +\toprule +Group & Base field & Real places & Dyadic places \\ +\midrule +$X_B^\beta$ & $B$ & $0$ & $(\mathrm{full},0)$ \\ +$Y_B^\beta$ & $B$ & $\mathrm{full}$ & $(0,\mathrm{full})$ \\ +$X_0^\beta$ & $\QQ$ & $\mathrm{full}$ & $0$ \\ +$(X_0^{\beta^{-1}})^{\mathrm{dual}}$ & $\QQ$ & $0$ & $\mathrm{full}$ \\ +\bottomrule +\end{tabular} +\end{center} +At every selected conductor all four groups use the line $k_0\delta$, +and at every other non-dyadic finite place they use the unramified +condition. The rational +opposite dual in the last row will keep $X_0=0$ while the paired +conditions over $B$ are switched. + +\begin{lemma}\label{lem:disjoint-conjugate-selmer} +As long as all conductors used so far split in $B$ and both +$X_0^\beta$ are zero, one has +\[ + W\cap\sigma W=0 + \quad\text{for }W=X_B^\beta\text{ and }W=Y_B^\beta. +\] +\end{lemma} + +\begin{proof} +The intersection is stable under $\sigma$. If nonzero it has a +nonzero invariant class, which descends to $\QQ$ because +$k_0(\beta)^{G_B}=0$. Its dyadic localization is zero: intersecting +either pair of conjugate dyadic conditions imposes zero at both +$w_1$ and $w_2$. At infinity it satisfies at least the full condition +defining $X_0^\beta$; this observation also covers $W=Y_B^\beta$. +At every conductor, splitting in $B$ makes descent of the rational +line $k_0\delta$ immediate. At other primes unramified in $B/\QQ$, +the unramified condition descends by restriction to inertia. +There is no condition to check at $q_0$: the coefficient is +unramified with nontrivial Frobenius there, so local $H^0$ and +$H^2$ vanish and the local Euler formula gives $H^1=0$. +Thus the nonzero descended class lies in $X_0^\beta$, a contradiction. +\end{proof} + +We have arranged $X_0^\beta=0$ for both coefficient characters. +The next split switches must preserve these vanishings while decreasing +the nonzero spaces $X_B^\beta$. The preceding lemma, together with +Lemma~\ref{lem:field-evaluations}, supplies the freedom to choose +paired evaluations needed for each new split conductor. + +\smallskip +\noindent\emph{Split switches.} +Now suppose both $X_B$ spaces are nonzero. Include the restrictions +of the rational opposite-dual classes in the evaluation spaces just +described. Choose a new split conductor +with the following three properties, for each coefficient isotype: +\begin{enumerate} +\item the paired evaluation on $Y_B^\beta$ has rank two; +\item the paired evaluation on $X_B^\beta$ is nonzero; +\item the evaluation on the opposite dual of the zero space +$X_0^{\beta^{-1}}$ is nonzero. +\end{enumerate} +The third dual has dimension one, by its dimension difference. +The first space has dimension at least two by +\eqref{eq:b-selmer-comparison}. Lemmas~\ref{lem:field-evaluations} +and~\ref{lem:disjoint-conjugate-selmer} make the paired evaluations +on each of the first two spaces independent uniform functionals. +For $t=\dim Y_B^\beta\ge2$, the rank failure probability is +\[ + 1-(1-q^{-t})(1-q^{1-t})\le q^{-1}+q^{-2}. +\] +The second failure probability is at most $q^{-2}$, and the third +is $q^{-1}$. Their sum satisfies +\begin{equation}\label{eq:split-switch-probability} + (q^{-1}+q^{-2})+q^{-2}+q^{-1}<1. +\end{equation} +No independence between these three failure events is needed for +this union bound. Different character isotypes are independent; +conjugate inverse characters give identical requirements under +coefficient Frobenius. Hence an admissible conductor exists. + +Switching at its two places makes both $X_B$ spaces smaller and +introduces no new classes. The third requirement has a separate +purpose: Lemma~\ref{lem:selmer-switch}, now over $\QQ$, preserves +$X_0^\beta=0$. Thus Lemma~\ref{lem:disjoint-conjugate-selmer} +remains applicable at the next split step. Continue until both +$X_B$ spaces vanish or exactly one remains. + +\smallskip +\noindent\emph{The final inert switch.} +In the latter situation write $X_B^\beta\ne0$ and +$X_B^{\beta^{-1}}=0$. Formula~\eqref{eq:b-selmer-comparison} +implies +\begin{equation}\label{eq:one-survivor} + \dim X_B^\beta=\dim Y_B^\beta=1, + \qquad Y_B^\beta=\sigma X_B^\beta. +\end{equation} +If the inverse characters were Frobenius conjugate, their $X_B$ +spaces would have equal dimension, so this case could not arise. + +Choose one final conductor inert in $B$, still split in +$K_\alpha E_2$. Immediately before this step +Lemma~\ref{lem:disjoint-conjugate-selmer} holds, so $1+\sigma$ is +injective on each relevant $X_B$ and $Y_B$: its kernel would be a +fixed vector in $W\cap\sigma W$. +At this conductor require nonzero evaluation on both opposite duals +$Y_B^\alpha,Y_B^{\alpha^{-1}}$ and on the remaining $X_B^\beta$. +There is no third independent demand in the surviving isotype. +By \eqref{eq:one-survivor} and the exact equality in +Lemma~\ref{lem:field-evaluations}, the evaluations on $Y_B^\beta$ +and $X_B^\beta$ coincide. The affine offset in +\eqref{eq:inert-evaluation} does not change this equality. +Uniform evaluation and the union bound give the conservative failure +bound $2/q<1$ per isotype. The switch at the single place over this +inert prime therefore kills the last $X_B$ space, while the opposite +zero space stays zero. This is the final step: preservation of +$X_0=0$ after it is neither required nor asserted. Its pre-step +vanishing was used precisely to justify injectivity of $1+\sigma$. + +\subsection{Uniformity, restriction, and the numerical bounds} + +The constructions now give the required dual Selmer vanishing. +To finish Proposition~\ref{prop:field-preparation}, we bound the number +of conductors, check preservation of residual data, and convert that +vanishing into the strict Selmer bounds. The conductor count is the +point that allows both cyclic exponents to grow. + +The number of conductors in the preceding argument is bounded +independently of $n$ and $a$. Here is an explicit accounting which +also avoids making any uniformity assumption about their sizes. +Let $b=[B:\QQ]\le2$, and let +\[ + C_E=\sum_{\beta\in\{\alpha,\alpha^{-1}\}} + \dim_{k_0}H^1(G_{E,T_E},k_0(\beta)),\qquad E=\QQ,B, +\] +where $T_E$ is the fixed set above $\Sigma$, two, and infinity. +In the quadratic case one may include $q_0$ in $T_B$ without change +to the relevant local cohomology. Count both characters in this +sum even if they are Frobenius conjugate; the resulting bound is +only larger. Allowing one new rational prime freely adds at most +$2b$ to each global $H^1$ dimension over $B$, by restriction to +inertia or by the localization sequence. Thus it adds at most +$4b$ to their sum. This deliberately generous bound applies +uniformly to every conductor and every quadratic line chosen there. + +After the first conductor, the sum of the two dimensions over $\QQ$ +is at most $C_{\QQ}+4$. The first loop killing the auxiliary $X_0$ +spaces therefore has length +\[ + N_0\le C_{\QQ}+4. +\] +During it, the sum of the $B$-dimensions is at most +$C_B+4b(1+N_0)$. Every later split switch decreases that sum by +at least one and never increases either space. There is at most +one final inert switch. Hence in the quadratic case the total +number $t$ of conductors satisfies, for example, +\begin{equation}\label{eq:uniform-conductor-count} + t\le 2+C_B+4b+(1+4b)(C_{\QQ}+4). +\end{equation} +For $B=\QQ$ the direct loop gives the simpler bound +$t\le1+C_{\QQ}+4$. These constants depend only on the fixed +original data and the fixed choice of $B$. + +Every original $\ell\in\Sigma$ has full Frobenius order in $L$ and +its degree-$2^a$ layer, so has at most $b$ primes in either $A$ or +$F$. Every conductor is totally ramified in both cyclic layers, +so likewise has at most $b$ primes. Consequently +\[ + u_A,u_F\le b(|\Sigma|+t). +\] +The analogous scalar bound is $2|\Sigma|$, and the absolutely +irreducible bound is $|\Sigma|$. This proves the required common +constant $U$. The degrees are $d_A=b2^a$, $d=b2^n$, and +$m=2^{n-a}$ in the marked cases. Taking $a$ and $n-a$ large makes +$d_A$ and $[F:A]$ large independently. In the marked cases this +makes $m$ large and gives $m/d=1/d_A$. + +Since $K_\alpha/\QQ$ has odd degree, $\alpha$ remains nontrivial +on every field constructed in the distinct-character case. +Inflation--restriction, with +$H^0(G_F,k(\beta))=0$, proves injectivity of restriction from $A$ +to $F$. Together with the scalar and absolutely irreducible cases +proved above, this establishes all the field and restriction +assertions of Proposition~\ref{prop:field-preparation}. + +It remains to derive \eqref{eq:strict-selmer}. Since the mod-two +cyclotomic character is trivial, the Tate dual of $k(\beta)$ is +$k(\beta^{-1})$. Its Selmer conditions dual to the strict ones +are exactly those in \eqref{eq:dual-vanishing}. The dual Selmer +group is zero. The global invariant terms in the Selmer dimension +formula cancel, whether $\beta=1$ or $\beta\ne1$. At a real place, +the full condition contributes +$\dim H^1_v-h^0_v=1-1=0$. At an unmarked dyadic place, local +Euler characteristic gives contribution one if $\alpha_2\ne1$ +and two if $\alpha_2=1$. At a marked place the zero condition +contributes $-h^0_v=-1$. At a non-dyadic allowed place the full +condition contributes $h^2_v\le1$, and an unramified condition +elsewhere contributes zero. Adding these terms gives exactly the +two bounds in \eqref{eq:strict-selmer}. + +For later use, the degree choices can in particular ensure the strict +inequalities +\begin{align} + d+u_F+3&<2d-1 &&\text{in the unmarked reducible case},\label{eq:field-unmarked-gap}\\ + 2d-2m+u_F+3&<2d-m-1 &&\text{in the marked case},\label{eq:field-marked-gap}\\ + 2d-2m-4-u_F&>d.\label{eq:field-curve-gap} +\end{align} +For example, it is enough in the marked case to have +$m>U+4$ and $m(d_A-2)>U+4$. The same freedom makes $d_A$ +larger than any prescribed fixed cost in the initial trace cuts. +These choices are legitimate because \eqref{eq:uniform-conductor-count} +and the bounds for $u_A,u_F$ are independent of both cyclic exponents. diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/introduction.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..b0ad2e04a09e58eb2aa5bcfc4ca76fe4154f0767 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/introduction.tex @@ -0,0 +1,280 @@ +\section{Introduction}\label{sec:introduction} + +The Fontaine--Mazur conjecture predicts that irreducible \(p\)-adic +Galois representations satisfying suitable finiteness and local +conditions arise from algebraic geometry \cite{FM1995}. Modular forms supply +a central class of examples through Deligne's cohomological construction +\cite[Sections~3.9--3.12 and~5.2--5.5]{Deligne1971}. Over +\(\mathbb Q\), its odd two-dimensional form has a more precise +modularity formulation. A continuous representation +\[ + r:G_{\mathbb Q}\longrightarrow\GL_2(\overline{\mathbb Q}_p) +\] +is \emph{odd} if \(\det r(c)=-1\) for a complex conjugation \(c\). +It is \emph{regular de Rham} at \(p\) if its restriction to +\(G_{\mathbb Q_p}\) is de Rham and has two distinct Hodge--Tate +weights. The conjecture asserts that an irreducible such +representation, unramified outside finitely many primes, comes +from a classical cuspidal eigenform, allowing a Tate twist. + +\begin{theorem}\label{thm:main} +Let +\[ + r:G_{\mathbb Q}\longrightarrow\GL_2(\overline{\mathbb Q}_2) +\] +be continuous and irreducible. Suppose that \(r\) is odd, is +unramified outside finitely many primes, and is de Rham at \(2\) +with distinct Hodge--Tate weights. Then \(r\) is isomorphic to +a Tate twist of the \(2\)-adic Galois representation associated +with a classical cuspidal eigenform. +\end{theorem} + +Thus Theorem~\ref{thm:main} resolves the odd, regular two-dimensional +Fontaine--Mazur conjecture over \(\mathbb Q\) at \(2\). Its scope includes +every semisimple residual representation, including scalar and reducible +ones. Together with the odd-prime results discussed below, it gives the +stated modularity conclusion at every prime. The geometric realization +of modular representations also gives the geometric-origin conclusion +in this odd, regular setting. + +Theorem~\ref{thm:main}, in particular its absence of a residual-image +hypothesis, supplies the weight-two modularity input in the height argument +of \emph{Hilbert's tenth problem over the rational numbers} +\cite[Section~4]{OpenAIH10Q2026}, whose undecidability proof also uses +substantial additional arithmetic and logical constructions. + +\subsection{Background and the dyadic problem} + +The deformation-theoretic approach to modularity lifting developed +by Wiles and Taylor--Wiles compares Galois deformation rings with +Hecke algebras \cite{Wiles1995,TaylorWiles1995}. Serre's conjecture +concerns the residual starting point \cite{Serre1987}; its proof by +Khare--Wintenberger and Kisin supplies modularity for odd absolutely +irreducible residual representations, including characteristic two +\cite{KhareWintenberger2009,KhareWintenberger2009II,Kisin2009}. +The existence of a residual modular form still leaves the problem +of proving modularity for a specified characteristic-zero lift. +For a reducible residual representation, even the modular seed +must be obtained by a different construction. + +Skinner and Wiles developed ordinary families and pro-modularity +arguments for residually reducible representations and then for +nearly ordinary deformations of irreducible residual representations +\cite{SkinnerWiles1999,SkinnerWiles2001}. Allen adapted this family +method to nearly ordinary dyadic representations with solvable +absolutely irreducible residual image \cite{Allen2014}. +Kisin brought local deformation geometry and the $p$-adic +Langlands correspondence into the regular Fontaine--Mazur problem +\cite{Kisin2009FM}. Emerton's local--global compatibility work +separated occurrence in completed cohomology from the production +of classical vectors \cite{Emerton2011}. These developments +explain why both stages of the proof below are needed, and why +ordinary auxiliary families can be useful without ordinarity +being imposed on the final target. + +At odd primes, Pan's work treats the residually reducible case and, +together with preceding modularity lifting theorems, establishes the +regular conjecture apart from one local residual configuration at~$3$ +\cite[Theorems~1.0.2 and~1.0.4]{Pan2022}. Zhang removes that +configuration, obtaining the stated odd, regular theorem for every +odd prime \cite[Theorem~1.0.2]{Zhang2025}. At~$2$, Tung removes +the remaining local restriction in a modularity lifting theorem whose +global residual image is nonsolvable +\cite[Theorem~A]{Tung2021Dyadic}. Thus local scalar residual +behavior and a globally scalar residual representation must be +distinguished: a local theorem covering the former does not by +itself settle the latter. + +The proof has a useful precedent in the passage from unrestricted +pro-modularity to classicality developed by Pan, and in Zhang's +potential pro-modularity argument \cite{Pan2022,Zhang2025}. +The present dyadic problem requires integral control of the local +actions and of deformation families even when their residual +representation is scalar. We first construct potential occurrence +in completed definite forms, then extract classical vectors, and +finally descend. The distinction between occurrence and classicality +also appears in Pan's theorem for representations in the completed +cohomology of modular curves: that theorem assumes occurrence as +a hypothesis \cite[Theorem~7.1.2]{Pan2026Classicality}. + +Thorne's theorem supplies an essential set of classical points: +ordinary, potentially crystalline representations of weights +$\{0,1\}$ are modular at every prime, without a residual +irreducibility hypothesis \cite[Theorem~D]{Thorne2026}. +After a global normalization and passage to the dual, our family +construction makes this theorem applicable at a dense +set of points, and the subsequent specialization argument recovers +the original target's arbitrary weight gap. Prescribing global +lifts with chosen local components, as in Emerton--Gee--Pan--Zhu +\cite[Theorem~1.1.1]{EGPZ2026}, is a different conclusion; +their dyadic theorem also retains a nonsolvable residual-image +hypothesis. + +The local input is the \(p\)-adic Langlands correspondence of +Colmez~\cite{Colmez2010}, in the all-prime form of Colmez, Dospinescu +and Pa\v{s}k\=unas~\cite{CDP2014}. Pa\v{s}k\=unas and Tung's block +finiteness theorem~\cite{PaskunasTung2021} supplies an integral local +pseudodeformation action even in scalar residual blocks. This resolves +a local representation-theoretic obstacle, but leaves a global one: +a trace does not record a residual extension class, and globally +reducible families can be too large for a direct connectedness argument. +We work with actual representations and temporarily record local +invariant lines to obtain the necessary dimension loss. These auxiliary +marks are used in connectedness; the propagation theorem imposes no +ordinary condition at the dyadic places. + +\subsection{From occurrence to classicality and descent} + +A \emph{pro-modular locus} is a closed trace locus in a Galois +pseudodeformation spectrum defined by a completed Hecke algebra of +definite quaternionic forms. No local condition is imposed at~\(2\). +Its characteristic-zero points give Hecke eigensystems in completed +forms. The central problem is to pass from this occurrence statement +to a classical cuspidal form with the prescribed Galois representation. +We do so in three stages, summarized in Figure~\ref{fig:proof-route}. + +\paragraph{Potential occurrence for a whole family.} +The first stage places the target and the deformation families needed +later in one pro-modular trace locus over a common solvable totally +real extension \(F\), completely split at~\(2\). Two constructions +work together. Localized propagation starts at a characteristic-two +curve whose generic representation remains absolutely irreducible +under finite restriction. If the curve is pro-modular and has finite +local images at the allowed non-dyadic primes, patching gives +potential pro-modularity of every irreducible deformation locus +containing it (Theorem~\ref{thm:localized-propagation}). The local +deformation problem at~\(2\) is unrestricted. + +To produce the curves to which this result applies, we construct +abelian \(2\)-extensions \(\mathbb Q\subset A\subset F\), keeping the +number of allowed ramified primes under control while their degrees +grow. In the scalar and reducible cases we mark a small proportion of +the dyadic places. Recording an invariant line at those places retains +information that traces alone would lose. We select the open part of +the residual fiber on which the marked lines are transverse to every +globally invariant line. A Selmer calculation makes the globally +reducible locus too small to disconnect these charts. A modular seed +and a curve cut from a component containing the target enter the same +connected residual fiber. Applying propagation along it yields +Theorem~\ref{thm:potential-promodularity}. The conclusion concerns the +whole closed trace image of the prescribed family at one common tame +level; it does not require that this family itself have the dimension +of the larger component used to find the curve. + +\paragraph{Classical vectors at the target.} +When the local representation at~\(2\) is irreducible, the local +Langlands correspondence supplies locally algebraic vectors. For a +reducible local target, we choose an invariant line with the larger +cyclotomic exponent and retain its character as a parameter. The +resulting family records trace and character jointly and is finite +over a one-dimensional weight space. Its continuous members are not +all de Rham; the useful points are a dense set of specially chosen +weights. After a global twist the corresponding representations have +cyclotomic exponents \(\{1,0\}\), or Hodge--Tate weights +\(\{-1,0\}\). Their \emph{duals} have Hodge--Tate weights +\(\{0,1\}\) and satisfy the ordinary potentially crystalline +hypotheses of Thorne's theorem. + +Those classical points determine the order of the two characters in +the ordinary induction. A finite closed joint support transports this +order to the target. A quotient, lattice and Tate-module construction +then supplies a genuine eigenvector in the target eigenspace. Finally, +a direct polynomial-orbit argument turns its character and exponent +inequality into a nonzero locally algebraic vector. This last step +avoids assuming that algebraic vectors commute with specialization. + +\paragraph{Descent of a classical packet.} +The vector gives a regular cuspidal automorphic representation over +\(F\). We descend along prime-degree cyclic steps in a solvable tower. +At each step, a finite-character discrepancy between the descended +Galois representation and the target is removed by a Hecke-character +twist. Descent is applied only after classicality has been established; +no descent statement for pro-modular loci is needed. + +\begin{figure}[tp] +\centering +\begin{tikzpicture}[ + box/.style={draw,rounded corners=2pt,align=center,font=\small, + text width=5.7cm,inner sep=7pt}, + arr/.style={-{Latex[length=2mm]},thick},node distance=9mm] +\node[box] (prop) {Unrestricted propagation at a curve\\ +Sections~\ref{sec:deformation}--\ref{sec:propagation}}; +\node[box,right=7mm of prop] (conn) {Controlled fields and transverse connectedness\\ +Sections~\ref{sec:fields}--\ref{sec:connectedness}}; +\draw[arr] (prop.east) -- (conn.west); +\node[box,below=14mm of prop,xshift=3.2cm,text width=8cm] (occ) +{Potential pro-modularity of the target family\\over one common field \(F\)}; +\draw[arr] (prop.south) -- (occ.north west); +\draw[arr] (conn.south) -- (occ.north east); +\node[box,below=13mm of occ,xshift=-3.2cm] (irr) +{Locally irreducible target:\\local Langlands correspondence}; +\node[box,below=13mm of occ,xshift=3.2cm] (red) +{Locally reducible target:\\finite ordinary support,\\dense classical points\\and polynomial orbit}; +\draw[arr] (occ.south) -- (irr.north); +\draw[arr] (occ.south) -- (red.north); +\node[box,below=14mm of irr,xshift=3.2cm,text width=8cm] (vec) +{Locally algebraic target vector\\and cuspidal packet over \(F\)\\ +Section~\ref{sec:classicality}}; +\draw[arr] (irr.south) -- (vec.north west); +\draw[arr] (red.south) -- (vec.north east); +\node[box,below=of vec,text width=8cm] (end) +{Prime-degree cyclic descent and finite-character corrections\\ +Classical cuspidal eigenform over \(\mathbb Q\)\\up to Tate twist}; +\draw[arr] (vec) -- (end); +\end{tikzpicture} +\caption{The proof route. The connectedness construction uses the +propagation theorem; the two upper boxes are cooperating inputs to +occurrence. The target enters through that construction. The common +field \(F\) is solvable, totally real, of even degree and completely +split at~\(2\). The ordinary family is used in the reducible local +branch. Both branches produce a classical packet before descent.} +\label{fig:proof-route} +\end{figure} + +\subsection{The constructions used in the proof} + +Several established methods must be kept compatible at the +characteristic-two curve. B\"ockle--Iyengar--Pa\v{s}k\=unas develop +local deformation theory with Laurent-series residue fields and +coefficient orders, including the auxiliary-variable comparison of +completions \cite[Section~3.5]{BIP}. We use this framework +with an extra coefficient variable and global representation and +incidence spaces. Lemma~\ref{lem:curve-completion} proves the resulting +identification of continuous deformation and obstruction problems, +including the topology on the residue field and the dimension change. + +The propagation construction follows the auxiliary-level method of +Taylor--Wiles, Kisin's formulation relative to local deformation rings, +and the characteristic-two determinant-twist argument of +Khare--Wintenberger +\cite{TaylorWiles1995,Kisin2009FiniteFlat,KhareWintenberger2009II}. +Pan's localization at one-dimensional primes is the direct global +precedent \cite{Pan2022}; Zhang's potential formulation is used in +the same overall progression \cite{Zhang2025}. At the Laurent-series +residue field we patch finite jets, meaning quotients by fixed powers +of the local maximal ideal. The exactness argument works with +filtrations whose successive quotients are fixed old-level modules. +A uniform Artin--Rees bound preserves their actual old deformation +actions. Determinant twists and explicit quadratic sign intertwiners +then give support on every local component. All of these action +comparisons are retained integrally. + +The marked-line construction serves a different purpose. Its local +factors are integral even over the characteristic-two real-place +base, and transversality gives a strict Selmer loss at every mark. +The number of marks grows more slowly than the total degree, so this +loss is compatible with the global dimension estimates. The argument +uses the unrestricted propagation theorem after entering a transverse +chart; it does not replace that theorem by ordinary patching. + +\paragraph{Organization.} +Section~\ref{sec:preliminaries} fixes conventions and removes the +virtually solvable case. Section~\ref{sec:deformation} constructs the +representation spaces, their curve completions and the local models. +Section~\ref{sec:completed} compares the actual Galois and local +block actions on completed forms and proves the Hecke-dimension bound. +Section~\ref{sec:propagation} proves localized propagation. +Section~\ref{sec:fields} supplies the field and Selmer estimates, and +Section~\ref{sec:connectedness} combines them with a modular seed to +obtain potential pro-modularity. Section~\ref{sec:classicality} +constructs classical vectors and carries out solvable descent. diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/patching.tex b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/patching.tex new file mode 100644 index 0000000000000000000000000000000000000000..f1831c7ea5ec2ded4caaf8330b5f18811e1f7905 --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/build/sections/patching.tex @@ -0,0 +1,896 @@ +\section{Propagation from a characteristic-two curve} +\label{sec:propagation} + +The input to this section is a pro-modular curve whose generic +representation is not virtually solvable. We prove that completed forms +have full support on the deformation germ at that curve. The residue +field of the germ is a Laurent-series field; accordingly, the patching +argument below uses finite jets, rather than compactness of a finite +residue field. + +The argument follows the auxiliary-level framework of +Taylor--Wiles~\cite{TaylorWiles1995}, its formulation relative to local +rings by Kisin~\cite[Section~3.3]{Kisin2009FiniteFlat}, and the +characteristic-two determinant-twist construction of +Khare--Wintenberger~\cite[Section~9.1.3]{KhareWintenberger2009II}. +Pan's localized propagation argument is the global predecessor +\cite{Pan2022}. Here the curve residue field requires explicit control +of finite jets and fixed old-level quotients. We first construct +finite auxiliary stages, then preserve their filtration in the limit, +and finally use twists, sign intertwiners and diamond augmentation to +recover support with the original deformation action. + +\begin{theorem}[Localized propagation]\label{thm:localized-propagation} +Let \(F\) be a totally real solvable field of even degree, completely +split at~\(2\), and let \(S\) contain its real and dyadic places and +the allowed finite ramification. Fix the determinant +\(\chi=\det r=\chi_{\mathrm{fin}}\eps^w\) of a target \(r\) as in +Section~\ref{sec:preliminaries}, a semisimple residual representation +with determinant \(\bar\chi\), and let +\(R_F^{\mathrm{ps},\chi}\) be the corresponding complete local global +pseudodeformation ring. Let $C$ be a characteristic-two curve in +\(\Spec R_F^{\mathrm{ps},\chi}\). Suppose that $C$ is potentially pro-modular, +that its generic representation is not virtually solvable, and that its +local images at the non-dyadic finite places in $S$ are finite. Every +irreducible closed locus of \(\Spec R_F^{\mathrm{ps},\chi}\) +containing $C$ is potentially pro-modular, with ramification allowed +only at the specified set \(S\) before base change. +\end{theorem} + +We will prove the theorem at the end of the section. First make a +totally real solvable Galois base change, split completely above $2$, on which +the curve is pro-modular. Lemma~\ref{lem:inertia-basechange}, applied +both to the source deformation rings and to the Hecke algebras, permits +a further such base change with the following properties: the curve +representation is trivial at every bad finite place; the determinant +$\chi$ is unramified there; the source has unipotent inertia there; and +each bad residue cardinality is $1$ modulo $4$. By +Lemma~\ref{lem:forward-basechange}, the curve is then in +the support of forms with Iwahori level at the bad places and +hyperspecial level elsewhere away from $2$. The assertion about the +source is set-theoretic, which is sufficient for the theorem. + +Retain the notation $F,S$ after these base changes, and put +\[ + d=[F:\QQ],\qquad + u=\#\{v\in S:v\nmid 2\infty\},\qquad s=2d+u. +\] +Use Lemma~\ref{lem:curve-completion} to enhance the curve by $z$ and +complete. Its coefficient ring and residue field are +\[ + \mathcal L=\widehat{\OO[[z]]_{(\varpi)}},\qquad K=\kk((t)), + \qquad z\longmapsto t. +\] +Finite extensions of these coefficients are allowed throughout. Write +$\rho_*:G_{F,S}\to\GL_2(K)$ for the curve representation. It is +absolutely irreducible, and remains so under the base changes just made. +All local and global deformation rings in this section are completed +at this same enhanced curve and have residue field $K$. + +\subsection{Auxiliary primes and characters} + +Character twists will enlarge the support obtained from completed +forms. Since twisting multiplies the determinant by the square of the +character, we need a variable-determinant problem as well as the +fixed-determinant one. In the former, the determinant is fixed at +the dyadic and real +places and on bad inertia, but is allowed to vary globally. Enlarge +$\OO$ so that $i^2=-1$ belongs to it. At a bad place, choose a tame +inertia generator $\tau$ and an arithmetic Frobenius $\phi$ with +$\phi\tau\phi^{-1}=\tau^{q_v}$. For $\eta\in\{1,i\}$ impose +\[ + \det\rho(\tau)=1,\qquad + \tr\rho(\tau)=\eta+\eta^{-1}. +\] +The determinant of $\rho(\phi)$ is unrestricted in the variable +problem. The local curve is trivial, so wild inertia and prime-to-two +tame inertia disappear in these completed problems. Denote the +completed product of the framed local rings at $S$ by +$R_{\mathrm{loc},\eta}$. +The $\eta=1$ condition contains the source with unipotent bad inertia. +The $\eta=i$ condition provides an irreducible comparison model: +Proposition~\ref{prop:local-geometry} identifies its special fiber +with that of the $1$-model and specifies the horizontal components +through each generic special-fiber point. We will use this comparison +to transfer support to every component of the $1$-model. + +For a set $Q_n$ of auxiliary primes, let $R_{\eta,n}$ be the +$S$-framed global ring with these local conditions and unrestricted +additional ramification at $Q_n$. A superscript $f$ denotes the +quotient imposing the global determinant $\chi$. Write $R_\eta$ and +$R_\eta^f$ for the corresponding rings without $Q_n$. Thus forgetting +the additional ramification gives quotient maps +\[ + R_{\eta,n}\twoheadrightarrow R_\eta, + \qquad R_{\eta,n}^f\twoheadrightarrow R_\eta^f. +\] +The deformation interpretation over $\mathcal L$ and noetherianity +follow from Lemma~\ref{lem:curve-completion} and the relative tangent +and obstruction calculation of Proposition~\ref{prop:relative-presentation}. + +\begin{lemma}[Auxiliary-prime bound]\label{lem:auxiliary-primes} +There is a sufficiently large integer $h$, independent of $n$, and +sets $Q_n$ of $h$ primes outside $S$ such that: +\begin{enumerate} +\item every prime in $Q_n$ splits in +$F(\zeta_{2^n},2^{1/2^n})$ and has residue cardinality $1$ modulo $2^n$; +\item its $\rho_*$-Frobenius is regular semisimple, with both eigenvalues +in one fixed finite extension of $K$; +\item there are surjections +\begin{equation}\label{eq:patching-presentation} + B_\eta:=R_{\mathrm{loc},\eta}[[X_1,\ldots,X_g]] + \twoheadrightarrow R_{\eta,n},\qquad g=2h+1. +\end{equation} +\end{enumerate} +The two sets of maps in \eqref{eq:patching-presentation}, for $\eta=1,i$, +can be chosen to agree modulo $\varpi$. For each \(\eta\), their +composites with \(R_{\eta,n}\twoheadrightarrow R_\eta\) can also be +chosen independently of \(n\). +\end{lemma} + +\begin{proof} +Put $M=\ad\rho_*$. The pairing $(A,B)\mapsto\tr(AB)$ on $M_2(K)$ +is perfect also in characteristic two. Thus the dual coefficient +module is again $M$: the mod-two cyclotomic twist is trivial. The +relative Selmer condition is zero at $S$ and full at $Q_n$. The dual +condition therefore consists of classes unramified outside $S$ whose +localizations at $Q_n$ vanish. + +Set +\[ + F_\infty=F(\zeta_{2^\infty},2^{1/2^\infty}),\qquad + H=\ker(G_{F,S}\longrightarrow\Gal(F_\infty/F)). +\] +The tower group is solvable. Nonvirtual solvability of $\rho_*$ +therefore implies that the geometric reduced Zariski closure of +$\rho_*(H)$ contains $\SL_2$; the same is true for every open subgroup +of $H$. Indeed, take the closure over an algebraic closure of \(K\). +Its smooth connected derived group lies in \(\SL_2\). If proper, +it has dimension at most two and is solvable, forcing the identity +component itself to be solvable, a contradiction +\cite[Corollaries~6.19 and~17.27]{MilneAlgebraicGroups}. +Consequently regular semisimple elements are dense in every open +coset of $H$. + +We give the detection argument explicitly. +Let $c\in Z^1(G_{F,S},M)$ have zero diagonal evaluation at every +regular semisimple $\sigma\in H$. Then the first-order +representation +\[ + \rho_c(\sigma)=(1+\epsilon c(\sigma))\rho_*(\sigma), + \qquad \epsilon^2=0, +\] +has the same trace as $\rho_*$ on those elements. Indeed, the quotient +\[ + M/(\operatorname{Ad}(\rho_*(\sigma))-1)M +\] +is the diagonal subspace in an eigenbasis, and zero evaluation kills +both diagonal entries. Continuity and the +density just observed give equality of traces on all of $H$. + +Choose $h_1,\ldots,h_4\in H$ such that $A_j=\rho_*(h_j)$ form a +basis of $M_2(K)$. The lifts $\rho_c(h_j)$ form a basis over +$K[\epsilon]$. The Gram matrix $\tr(A_jA_k)$ is invertible, and +equality of traces on products of two and three group elements shows +that this Gram matrix and all multiplication structure constants are +unchanged after lifting. The linear map taking $A_j$ to +$\rho_c(h_j)$ is therefore an algebra automorphism of $M_2(K[\epsilon])$, +reducing to the identity. Such an automorphism is conjugation by a +matrix congruent to the identity: this follows, for example, by +carrying a system of matrix units to its image and choosing the +corresponding basis. Pairing with the four basis matrices then shows +that this conjugation carries $\rho_*|_H$ to $\rho_c|_H$ on every +element of $H$. Hence $[c]|_H=0$. + +The invariants $M^H$ are the scalars. Inflation--restriction bounds +the kernel of all these evaluations by +\[ + H^1(\Gal(F_\infty/F),K). +\] +This space has dimension at most two. To see the last assertion, +the corresponding tower over $\QQ$ is pro-two and unramified away +from $2$. Its quadratic subfields are +$\QQ(i)$, $\QQ(\sqrt2)$, and $\QQ(\sqrt{-2})$. +Its elementary two-character rank is therefore two. +The field $F$ is disjoint from that tower: a nontrivial +intersection would have a quadratic subfield, whereas none of these +three fields has $2$ split completely. Thus the tower group over +$F$ has the same two-character rank. + +The ambient cohomology space is finite dimensional. A finite list of +regular elements consequently detects its quotient by a subspace of +dimension at most two. Extend $K$ once to split the eigenvalues of +this list. Both regular split eigenvalues and the nonvanishing minors +of the evaluation matrix persist on sufficiently small neighborhoods. +For each $n$, Chebotarev approximation supplies Frobenius elements in +these neighborhoods which are trivial at the required finite stage +of the tower \cite[V, Theorem~3.23]{MilneCFT}. +All conditions concern finite quotients after the +neighborhoods have been chosen. Extra such primes can be added, so +the cardinality can be any fixed sufficiently large $h$. The dual +Selmer dimension is then at most two. + +The auxiliary evaluations have reduced the undetected dual Selmer +space to at most two scalar tower directions. The next count turns +this into the uniform presentation bound \(g=2h+1\). +For completeness, write $h^j_v=\dim_K H^j(G_{F_v},M)$. +Local duality and Euler characteristics give +\[ + h^1_v= + \begin{cases} + 2h^0_v+4[F_v:\QQ_2],&v\mid2,\\ + 2h^0_v-4,&v\text{ real},\\ + 2h^0_v,&v\nmid2\infty. + \end{cases} +\] +For trivial complex conjugation, the dimensions are +$(h^0_v,h^1_v)=(4,4)$. +For nontrivial unipotent complex conjugation they are $(2,0)$. +Thus the dyadic contribution $4d$ cancels the real contribution +$-4d$. The localization image in the direct sum of the local +$H^1$ spaces is its own annihilator under Poitou--Tate. +For a subspace of local conditions $L$, elementary linear algebra +therefore gives the Selmer difference as +$\dim L-\tfrac12\sum_v h^1_v$. +Here $L$ is zero at $S$ and full at $Q_n$. +At each auxiliary prime regularity gives $h^0_v=2$ and $h^1_v=4$. +Consequently the identity is +\[ + h^1_{\mathrm{Sel}}(M)-h^1_{\mathrm{Sel}^{\perp}}(M) + =-\sum_{v\in S}h^0_v+2h. +\] +The finite-coefficient formulas are +\cite[I, Corollary~2.3, Theorems~2.8, 2.13, 4.10, and~5.1]{Milne2006}; +their passage to $K$ is the lattice-and-limit argument of +Lemma~\ref{lem:curve-cohomology}. +With independent $S$-frames the relative tangent dimension is +\[ + h^1_{\mathrm{Sel}}(M)+\sum_{v\in S}h^0_v-h^0(G_{F,S},M) + =h^1_{\mathrm{Sel}^{\perp}}(M)+2h-1 + \leq 2h+1. +\] +\emph{Generators with a fixed old composite.} +To obtain the last assertion as well as the variable bound, write +\(A_\eta=R_{\mathrm{loc},\eta}\) and +\(I_{\eta,n}=\ker(R_{\eta,n}\to R_\eta)\). The relative cotangent +spaces are +\[ + Q_{\eta,n}=\mathfrak m_{\eta,n}/ + (\mathfrak m_{\eta,n}^2+\mathfrak m_{A_\eta}R_{\eta,n}), + \qquad + Q_\eta=\mathfrak m_\eta/ + (\mathfrak m_\eta^2+\mathfrak m_{A_\eta}R_\eta). +\] +The first maps onto the second. Its kernel is the image of the +actual ideal \(I_{\eta,n}\): if a representative maps into +\(\mathfrak m_\eta^2+\mathfrak m_{A_\eta}R_\eta\), lift a +decomposition of its image into +\(\mathfrak m_{\eta,n}^2+\mathfrak m_{A_\eta}R_{\eta,n}\) and +subtract it. This leaves a representative in \(I_{\eta,n}\) of the +same relative cotangent class. + +Choose a basis of the old space \(Q_\eta\) with fixed representatives +\(r_{\eta,1},\ldots,r_{\eta,q}\) in \(R_\eta\). Choose their +reductions first in the common special-fiber diagram and then lift +to both values of \(\eta\). Their relative cotangent spaces agree +modulo \(\varpi\), so the number \(q\) is the same. For each \(n\), +lift these fixed old representatives to \(R_{\eta,n}\) and complete +their independent cotangent classes to a basis using representatives +in \(I_{\eta,n}\). The tangent bound just proved shows that at most +\(g=2h+1\) elements are needed; pad the list with zeros to length +\(g\). + +These choices can have identical reductions for \(\eta=1,i\). +First choose the lifts and the kernel-complement elements in the +common special-fiber diagram. Lift an element arbitrarily to +\(R_{\eta,n}\). If its image in \(R_\eta\) differs from the required +fixed old value by \(\varpi a\), subtract \(\varpi\) times any +preimage of \(a\) in \(R_{\eta,n}\). This preserves the chosen +special-fiber reduction and makes the old image exact. For a +kernel-complement element the required old image is zero. No +flatness of the old global ring over the coefficient DVR is used. + +Complete relative Nakayama now gives +\eqref{eq:patching-presentation}. Every composite to \(R_\eta\) +sends the first \(q\) variables to the fixed \(r_{\eta,j}\) and +all remaining variables to zero, independently of \(n\). The two +presentations still agree modulo \(\varpi\). The variable count, +and hence every later ambient dimension, is unchanged. +\end{proof} + +\begin{lemma}[Rank of auxiliary character twists]\label{lem:twist-rank} +Increase $h$ so that \mbox{$b=h-2d+2>0$}. There are +quotients +\[ + A_n=(\ZZ/2^{a_n}\ZZ)^b,\qquad a_n\longrightarrow\infty, +\] +of the ray class groups defining characters trivial at every dyadic +and real place and unramified outside $Q_n$. At $Q_n$ they use only +the residue-unit quotients of order $2^n$. +\end{lemma} + +\begin{proof} +Let $S_2$ be the dyadic places. Take the ordinary ray class group +of modulus $\prod_{q\in Q_n}q$, and quotient by the dyadic ideal +classes. Omitting real places from the modulus requires them to +split; at the dyadic places, both the units and uniformizers are +trivial in this quotient. The ray class exact sequence is +\[ + \OO_{F,S_2}^{\times}\longrightarrow + \prod_{q\in Q_n}\kk(q)^\times\longrightarrow + \Gamma_n\longrightarrow\operatorname{Cl}_{S_2}(F) + \longrightarrow0 . +\] +This is the usual ideal-theoretic ray sequence, with the primes +in $S_2$ inverted \cite[V, Theorem~1.7]{MilneCFT}. +The group of dyadic $S$-units has free rank +\[ + (d-1)+d=2d-1. +\] +Here we use the $S$-unit theorem +\cite[Theorem~5.11]{MilneANT}. +The direction generated by $2$ is primitive in its free part: its +valuation at each dyadic prime is one, since $2$ splits completely +in $F$. Since $F$ is totally real, generators for these units may +therefore be chosen as $-1,2$ and $2d-2$ further units. +For $n\geq2$, put $a_n=n-1$ and take the cyclic residue-unit +quotient of order $2^{a_n}$ at each auxiliary prime. +Both $-1$ and $2$ vanish in these quotients: the first is a +$2^{a_n}$th power because $\mu_{2^{a_n+1}}$ is present, and the +second is such a power by the imposed Kummer splitting. +The elementary divisor theorem shows that quotienting +$(\ZZ/2^{a_n}\ZZ)^h$ by the images of the remaining $2d-2$ +generators leaves a quotient +$(\ZZ/2^{a_n}\ZZ)^{h-2d+2}$. +The image of the local units in $\Gamma_n$ thus has such a +quotient. A finite abelian group containing a subgroup with +this quotient also has this quotient: in invariant-factor form, +the subgroup forces at least this many factors of order at least +$2^{a_n}$ in the containing group. Apply this to $\Gamma_n$. +Class field theory turns its quotient into the required +characters \cite[V, Theorems~5.3 and~5.5]{MilneCFT}. +Discarding the first finitely many indices is harmless. +\end{proof} + +The resulting \(b=h-2d+2\) character parameters will supply the +support dimensions missing from the fixed-determinant estimate. +Their vanishing at the old local conditions is what permits twisting +without changing those conditions. Let $H_n$ denote the formal +character group of $A_n$, completed at +the trivial character and $\varpi$. Its coordinate ring is +\[ + \mathcal L[[l_1,\ldots,l_b]]/ + \bigl((1+l_j)^{2^{a_n}}-1:1\leq j\leq b\bigr). +\] +Its tautological Galois character will be denoted $\theta_n$. +Twisting a fixed-determinant representation by $\theta_n$ preserves +the prescribed determinants at the dyadic and real places and on +bad inertia. It therefore defines a map from the variable global +problem to the fixed global problem with these character parameters. + +The local product $R_{\mathrm{loc},\eta}$ in +\eqref{eq:patching-presentation} is obtained from the enhanced +real--dyadic base $A^{\mathrm{rd}}$ of +Proposition~\ref{prop:local-geometry} by adjoining the $u$ raw tame +factors of \eqref{eq:tame-model}, with $\det\phi_j$ unrestricted. +Adjoining the $g=2h+1$ presentation variables gives +the rings $B_\eta$ of that proposition. They therefore have dimension +\begin{equation}\label{eq:patching-ambient-dimension} + e=1+8d+4u+g=8d+4u+2h+2. +\end{equation} +Their special fibers are identified. The underlying spectrum of +$B_i$ is irreducible and nonvertical. All components of $B_1$ +are horizontal of dimension $e$, and correspond bijectively to +the top-dimensional components of its special fiber, of dimension +$e-1$. The generic point of each such special-fiber component lies +on just its corresponding component of $B_1$. These precise +component assertions, and not only the dimension in +\eqref{eq:patching-ambient-dimension}, will be used below. + +\subsection{The modules and their finite-level actions} + +Let $N_{\eta,n}$ be the block module of completed forms at the +auxiliary ratio level $U_1(Q_n)$, with tame type +$(\eta,\eta^{-1})$ at the bad places. Add $z$, make the enhanced +completion, and pull back to the independent $S$-frame space. +Define $N_\eta$ in the same way at old level. The modules are +finite over $R_{\eta,n}^f$ and $R_\eta^f$, respectively, by +Propositions~\ref{prop:completed-forms} and~\ref{prop:block-comparison}. +We also regard them as modules for the variable-determinant rings +through their fixed-determinant quotients. + +Choose the quotient of the diamond group +$\Delta_n=(\ZZ/2^n\ZZ)^h$, with generators $U_1,\ldots,U_h$, +and write $V_j=U_j-1$. Lemma~\ref{lem:auxiliary-level} gives +\begin{align} + &N_{\eta,n}\text{ is flat over }\mathcal L[\Delta_n], + \label{eq:auxiliary-flatness}\\ + &N_{\eta,n}/(V_1,\ldots,V_h)N_{\eta,n} + \simeq N_\eta^{\oplus 2^h}, \label{eq:old-level-action}\\ + &\overline N:=N_1/\varpi N_1\simeq N_i/\varpi N_i\ne0, + \qquad \dim\Supp\overline N\geq 2d+4s-1. \label{eq:old-residue-dimension} +\end{align} +The isomorphism \eqref{eq:old-level-action} is an isomorphism of +$R_{\eta,n}$-modules through $R_{\eta,n}\twoheadrightarrow R_\eta$. +In particular, it identifies the actual Galois-ring actions. +The $n$-level modules and their ring and diamond actions for the two +values of $\eta$ likewise agree modulo $\varpi$. + +We recall why the operations just performed preserve the assertions. +Flatness over $\OO[\Delta_n]$ holds in the definite function-space +model and passes through the exact block functor. The $z$-adic +flatness criterion applies after adjoining $z$, and base change +from $\OO[[z]]$ to $\mathcal L$ preserves flatness. +The subsequent localizations, noetherian completions, and smooth +frame extensions are flat maps of the commuting deformation rings. +Tensoring a finite-ideal flatness test over $\mathcal L[\Delta_n]$ +with these flat extensions preserves injectivity, proving +\eqref{eq:auxiliary-flatness} after all the stated operations. +The degeneracy maps giving +\eqref{eq:old-level-action} are Hecke equivariant. At the regular +Frobenius curve their composite is invertible, and the special +contribution is absent. The augmented Galois action is consequently +unramified at $Q_n$ and factors through the old quotient; the +classical comparison identifies it with the old action. Finally, +Proposition~\ref{prop:hecke-dimension} gives dimension at least +$1+2d$ on each Hecke component. Enhanced completion preserves this +dimension, independent $S$-frames add $4s-1$, and reduction by +$\varpi$ loses at most one. This proves the bound in +\eqref{eq:old-residue-dimension}. Nonvanishing follows from the +pro-modular curve and the faithfulness of the old block module. + +For chosen tame inertia elements $\tau_{j,n}$ at the auxiliary +primes, the commuting diamond actions also satisfy +\begin{equation}\label{eq:diamond-quadratic} + U_j^2-T(\tau_{j,n})U_j+1=0. +\end{equation} +Here $T$ denotes the trace of the Galois deformation acting on the +module. This is an identity of operators, as supplied by +Lemma~\ref{lem:auxiliary-level}. + +We will need actual twist isomorphisms, rather than only a numerical +invariance of support. For every sign tuple +$\sigma\in\{1,-1\}^b$, specialize $\theta_n$ to the quadratic +character $\theta_{\sigma,n}$. Multiplication of forms by +$\theta_{\sigma,n}\circ\operatorname{Nrd}$ gives a semilinear +isomorphism of $N_{\eta,n}$ for the corresponding automorphism of +$R_{\eta,n}^f$. The central character is unchanged because this +character is quadratic. It is trivial above $2$ and at infinity +and unramified on bad inertia. It preserves the ratio level: on +that level the two diagonal character values agree, so their +product is one. Its reduction is one, hence the enhanced curve +and its residual frames are fixed. These observations prove that +the isomorphisms act on precisely the completed modules under +consideration. + +\subsection{Exact patching with finite jets} + +Fix a nonprincipal ultrafilter $\mathfrak U$ on the positive integers. +For a fixed complete noetherian local ring $(B,\mathfrak m)$, define +\[ + B^*=\varprojlim_j\prod_{\mathfrak U} B/\mathfrak m^j. +\] +Its residue field is the ultrapower $K^*$ of the residue field $K$. +This deliberate auxiliary scalar extension is separate from the +finite coefficient extensions used to define the original curves +and representations. +For a fixed finite $B$-module $M$, use the same definition with +$M/\mathfrak m^jM$. For varying quotients of $B$ and varying finite +modules, a subscript $\infty$ will denote this construction using +the maximal-ideal filtration induced by $B$. + +\begin{lemma}[Finite jets and uniform exactness]\label{lem:jet-exactness} +The following assertions hold. +\begin{enumerate} +\item The ring $B^*$ is complete noetherian local, and $B\to B^*$ +is faithfully flat. For fixed finite modules the construction is +exact and equals extension of scalars. It preserves their support +dimensions. If $B$ is a domain, so is $B^*$. +\item For varying quotients of $B$ and modules generated by a bounded +number of elements, the patched objects are finite over $B^*$. +Surjections and cokernels of a fixed finite number of compatible +operators commute with patching. +\item Let $(D,\mathfrak a)$ be a fixed noetherian local ring and $C$ +a fixed finite $D$-module. For arbitrary finite-module extensions +\[ + 0\longrightarrow P_n\longrightarrow H_n\longrightarrow C + \longrightarrow0 +\] +there is a constant $c$, independent of the extension, such that +\begin{equation}\label{eq:uniform-artin-rees} + P_n\cap\mathfrak a^jH_n\subseteq\mathfrak a^{j-c}P_n + \quad(j\geq c). +\end{equation} +Thus a filtration of fixed length with fixed successive quotients +patches exactly whenever its ambient jet filtration is uniformly +cofinal with the $\mathfrak a$-adic filtrations on its pieces. +\end{enumerate} +\end{lemma} + +\begin{proof} +At each depth, taking an ultrapower extends the scalars in each +finite-dimensional associated graded piece from $K$ to $K^*$. +Thus the graded ring of $B^*$ is generated by the images of any +fixed finite set of generators of $\mathfrak m$. Successive +expansion in these generators, followed by completeness, identifies +the jet filtration with powers of the ideal they generate. +The complete filtered-ring argument then proves noetherianity: +initial ideals are finitely generated in the noetherian associated +graded ring, and successive approximation lifts those generators. + +For an exact sequence of fixed finite modules, Artin--Rees makes +the induced and intrinsic filtrations on its submodule cofinal. +Use the induced filtration to obtain exact sequences of jets; +cofinality identifies their inverse limits with the construction +using intrinsic filtrations. The resulting limit is exact. A fixed +finite presentation identifies $M^*$ with $B^*\otimes_B M$. +This gives flatness by the finite-ideal criterion, and the nonzero +residue extension gives faithful flatness. Lengths of the graded +pieces are unchanged after residue-field extension, so their +Hilbert growth, and hence the support dimension, is unchanged. + +Suppose next that $B$ is a domain and is not a field. Choose a +discrete valuation $v$ of its fraction field centered at +$\mathfrak m$, for example one supplied by the normalized blowup +of $\mathfrak m$. It is positive on $\mathfrak m$. The ideals +\[ + I_a=\{x\in B:v(x)\geq a\} +\] +have zero intersection. Chevalley's lemma for a complete local +ring implies that for every $q$ there is an $a(q)$ with +$I_{a(q)}\subseteq\mathfrak m^q$. Thus being nonzero modulo a +fixed $\mathfrak m^q$ bounds $v(x)$ from above, uniformly in $x$. +If $c_0>0$ is the minimum valuation of fixed generators of +$\mathfrak m$, then $v(\mathfrak m^r)\geq rc_0$. +For two fixed nonzero jets, these inequalities give a depth at +which the product of any representatives of the two jets is +nonzero. Applied on a set belonging to $\mathfrak U$, they show +that the product of two nonzero elements of $B^*$ cannot vanish. +The assertion is immediate when $B$ is a field. + +For the varying construction, choose a uniform number of generators +at each level. Each jet ultraproduct is then a quotient of a fixed +finite free module over the corresponding jet of $B^*$ and has +finite length. Images of kernels at any fixed depth form a +descending chain in a finite-length module, hence stabilize. +The Mittag--Leffler argument gives surjectivity on inverse limits +and a finite generating set over $B^*$. The same argument applied +to a right-exact sequence proves the cokernel assertion. This +does not assert exactness for arbitrary varying submodules. + +For the uniform assertion, choose one finite free presentation +$F\twoheadrightarrow C$, with kernel $L$, and lift it to +$f_n:F\to H_n$. Then $H_n=P_n+f_n(F)$. If +$x\in P_n\cap\mathfrak a^jH_n$, write +\[ + x=p+f_n(y),\qquad p\in\mathfrak a^jP_n, + \quad y\in\mathfrak a^jF. +\] +Since $x$ maps to zero in $C$, we have $y\in L$. +Artin--Rees for the one fixed inclusion $L\subset F$ gives +$y\in\mathfrak a^{j-c}L$, with $c$ independent of $n$. +As $f_n(L)\subset P_n$, this proves +\eqref{eq:uniform-artin-rees}. Applying this successively to +the fixed quotients of a finite filtration gives uniform +strictness for each inclusion. Uniform cofinality transfers +these bounds to the ambient jets, proving the final statement. +\end{proof} + +We now use the jet lemma in three specific ways: scalar extension +of fixed modules, bounded-generation patching of the auxiliary +modules, and uniform strictness of filtrations with fixed old +quotients. It is the fixed quotient in the third assertion, not +arbitrary varying-module exactness, that preserves the regular +sequence below. + +The domain assertion in Lemma~\ref{lem:jet-exactness} can be applied +to each quotient by a minimal prime. Exactness and nilpotence of +the nilradical then show that a fixed finite list of irreducible +components is preserved by starring. The same applies to the +special fiber and to inclusions between its components and the +ambient components. In particular all the geometric assertions +following \eqref{eq:patching-ambient-dimension} remain valid for +$B_\eta^*$. This observation does not require $B_i$ itself to be +reduced. + +Apply the construction to the surjections +$B_\eta\twoheadrightarrow R_{\eta,n}$ and their fixed-determinant +quotients. The module generator numbers are uniformly bounded. +Indeed modulo the maximal ideal of $R_{\eta,n}$, +\eqref{eq:diamond-quadratic} gives $V_j^2=0$. +The quotient by all the $V_j$ is the fixed old module in +\eqref{eq:old-level-action}. The monomials +$V_1^{e_1}\cdots V_h^{e_h}$ with $0\leq e_j\leq1$ therefore +give a uniform bound, and Nakayama supplies the required generators. +We obtain finite $N_{\eta,\infty}$ and surjections +\[ + B_\eta^*\twoheadrightarrow R_{\eta,\infty} + \twoheadrightarrow R_{\eta,\infty}^f + \twoheadrightarrow(R_\eta^f)^*. +\] +The commuting $U_j$ patch as well. They satisfy the patched +versions of \eqref{eq:diamond-quadratic}; the joint action algebra +is consequently module finite over $R_{\eta,\infty}$. +Modulo its original maximal ideal all the $V_j$ are nilpotent, +so adjoining their actions does not change the complete separated +module topology. + +\begin{proposition}[The patched regular sequence] +\label{prop:patched-regular-sequence} +On $N_{\eta,\infty}$ the sequence +$\varpi,V_1,\ldots,V_h$ is regular. Moreover +\begin{align} + \dim\Supp_{R_{\eta,\infty}}N_{\eta,\infty} + &\geq2d+4s+h, \label{eq:patched-dimension}\\ + N_{\eta,\infty}/(V_1,\ldots,V_h)N_{\eta,\infty} + &\simeq (N_\eta^{\oplus2^h})^*. \label{eq:patched-augmentation} +\end{align} +\end{proposition} + +\begin{proof} +\emph{Polynomial layers with a fixed old action.} +Fix $\eta$, and write $\mathfrak m$ for the maximal ideal of +$B_\eta$. The presentations of Lemma~\ref{lem:auxiliary-primes} +give surjections $B_\eta\to R_{\eta,n}$ whose composites to +$R_\eta$ are independent of $n$. Regard +\[ + C=\overline N^{\oplus2^h} +\] +as a fixed finite $B_\eta$-module through this common composite. +Let $J=(\varpi,V_1,\ldots,V_h)$ denote the ideal of commuting +operators on the auxiliary modules and on their patched limit. + +Fix a truncation length $r$. For all sufficiently large $n$, the +relations $(1+V_j)^{2^n}-1$ have $J$-order greater than $r$. +Flatness in \eqref{eq:auxiliary-flatness}, together with the actual +old-action identification \eqref{eq:old-level-action}, gives +multiplication isomorphisms +\begin{equation}\label{eq:finite-polynomial-layers} + \operatorname{gr}_J^{b\), where +\(\eta_2=\chi/\eta_1\) has exponent \(b\). The favorable upper-Borel, +unnormalized inducing pair is \((\eta_2\eps,\eta_1)\). \\ +Algebraic factor & \(\operatorname{Sym}^{a-b-1}\det^{b+1}\). +The continuous family retaining \(\eta_1\) need not be de Rham. \\ +Curve coefficients & \(K=k((t))\) has its Laurent topology; +\(\mathcal L=\widehat{\OO[[z]]_{(\varpi)}}\), with \(z\mapsto t\). +The auxiliary ultrapower in Section~\ref{sec:propagation} is specified +separately. \\ +Dual actions & Group duals use the indicated contragredient action. +On scalar eigenspaces the commuting Hecke, torus and \(U\) operators +are transposed without inversion, as in Section~\ref{sec:classicality}. \\ +Support & Images in pseudodeformation spectra are closed images; +pro-modular support containments are set-theoretic. \\ +\bottomrule +\end{tabular} +\caption{Conventions used at the interfaces of the proof. The +character orientation in the table concerns the chosen target and +the normalized dense points, not every member of the family.} +\label{tab:conventions} +\end{table} + +\subsection{Coefficients and cyclotomic exponents} + +Write \(\OO\) for the ring of integers in a sufficiently large +finite extension \(E/\mathbb Q_2\), \(\varpi\) for a uniformizer, +and \(k\) for its residue field. Finite coefficient extensions +are allowed. A lattice means a finite free \(\OO\)-module of +full rank. The cyclotomic character is denoted by \(\eps\). +We count weights as \emph{cyclotomic exponents}, so that +\(\eps\) has exponent \(1\). In the Hodge--Tate convention +\(\HT(\eps)=\{-1\}\), exponents are the negatives of +Hodge--Tate weights. + +We use geometric Frobenius and local reciprocity sending a +uniformizer to geometric Frobenius. Thus, as a character of +\(\mathbb Q_2^\times\), +\[ + \eps=x|x|,\qquad x(a)=a. +\] +The determinant of a Galois representation is denoted by +\(\chi\). For a representation in Theorem~\ref{thm:main}, +de Rham class field theory gives +\[ + \chi=\chi_{\mathrm{fin}}\eps^w +\] +for a finite-order character \(\chi_{\mathrm{fin}}\) and an +integer \(w\). Indeed, Tate's local algebraicity theorem +\cite[Chapter~III, Section~1.2]{Serre1989Abelian} gives the integral +cyclotomic exponent at~\(2\). Removing this power leaves a character +locally constant at every finite place. Finite ramification and global +reciprocity make it a character of a finite ray class group, hence of +finite order. +In the convention for quaternionic forms +used below, the central character is +\[ + \psi=\chi\eps. +\] +The normalized local block parameter attached to a Galois +representation \(\rho\) is that of \(\rho\otimes\eps\). +These conventions agree with \cite[Sections~3.1--3.5]{Pan2022}. + +For the statement of Theorem~\ref{thm:main}, one may use the arithmetic +normalization \(V_f\) of the representation of a primitive eigenform +of weight \(k\) and nebentype \(\psi_f\): at a good prime \(q\), +\[ + \tr V_f(\operatorname{Frob}^{\mathrm{ar}}_q)=a_q(f),\qquad + \det V_f=\psi_f\eps^{k-1}. +\] +These trace and determinant formulas use the normalization of +\cite[Theorem~6.1]{DeligneSerre1974}; arithmetic Frobenius is fixed +there in Section~3.1. The cyclotomic exponents of \(V_f\) are +\(\{0,k-1\}\). Evaluating the same +representation at geometric Frobenius inverts its eigenvalues; it +does not change the representation into its dual. If a construction +instead produces \(V_f^\vee\), the wedge pairing gives +\[ + V_f^\vee\simeq V_f\otimes\psi_f^{-1}\eps^{1-k} + \simeq V_g\otimes\eps^{1-k}, +\] +where \(g\) is the primitive form associated with the finite-character +twist \(f\otimes\psi_f^{-1}\). Thus an expression +\(r\simeq V_f^\vee\eps^n\) becomes +\(r\simeq V_g\eps^{n+1-k}\). The up-to-Tate-twist conclusion of the +main theorem is unchanged by this conversion. + +\begin{lemma}\label{lem:finite-coefficients} +A continuous finite-dimensional representation of a profinite +group on \(\overline{\mathbb Q}_2^n\) is defined over a finite +extension of \(\mathbb Q_2\) and admits a stable lattice there. +\end{lemma} +\begin{proof} +There are countably many finite subextensions of +\(\overline{\mathbb Q}_2/\mathbb Q_2\). For each one \(E\), +the set of group elements whose representation matrices +lie in \(\GL_n(E)\) is a closed subgroup. These subgroups +cover the profinite group. By Baire's theorem, one has +nonempty interior, hence is open. Enlarge \(E\) to contain +the finitely many matrix entries of coset representatives. +Then every matrix lies in that finite extension. + +The image is compact. Its entries, and the entries of its +inverses, have bounded valuations. The \(\OO\)-submodule +generated by the orbit of \(\OO^n\) therefore lies between +two scalar multiples of \(\OO^n\). It is a stable lattice. +\end{proof} + +We apply Lemma~\ref{lem:finite-coefficients} whenever a +characteristic-zero representation is first introduced. +Over a curve field, the analogous compact-image lattice +argument gives an integral realization over \(k'[[t]]\). + +\subsection{The virtually solvable case} + +For a representation over any field, after extending scalars +to an algebraic closure, call it \emph{virtually solvable} +if the identity component of the reduced Zariski closure of its image +is solvable. The closure here is taken over the algebraic closure, +so that the resulting algebraic group is smooth. This property is unchanged by restriction to +a finite-index subgroup. + +\begin{lemma}\label{lem:solvable-reduction} +Theorem~\ref{thm:main} holds for virtually solvable +representations. A representation satisfying its hypotheses +and not virtually solvable remains absolutely irreducible +and not virtually solvable over every finite extension of +\(\mathbb Q\). +\end{lemma} +\begin{proof} +Let \(H\) be the algebraic monodromy group of an irreducible +two-dimensional representation over an algebraic closure. +Lie--Kolchin and the structure of connected solvable groups +\cite[Theorems~17.4 and~16.33]{MilneAlgebraicGroups} give the following +alternatives. If \(H^\circ\) is solvable and has a nontrivial unipotent +radical, the latter has a unique fixed line; normality +makes that line \(H\)-stable, contradicting irreducibility. +The remaining possibilities are that \(H^\circ\) is scalar, +or that its two distinct character lines are permuted by +\(H\). + +In the scalar case the projective image is finite. After a +finite extension of the base field, the representation is +a scalar character on a two-dimensional space. Its two +Hodge--Tate weights are equal, which is excluded. In the +second case the action on the two lines gives a quadratic +extension \(L/\mathbb Q\) and +\[ + r\simeq\Ind_{G_L}^{G_{\mathbb Q}}\theta +\] +for a continuous character \(\theta\). +The character is de Rham and finitely ramified, hence is the +\(2\)-adic avatar of an algebraic Hecke character, by the +following rank-one consequence of Tate's theorem and the construction +in \cite[Chapter~III, Sections~1.2 and~2.3]{Serre1989Abelian}. +The integral algebraic exponents on open local units obey the global +unit relation. Principal ideals in a suitable ray subgroup therefore +receive the prescribed algebraic monomials. A positive power of each +of finitely many ray-class representatives is principal in that +subgroup, so its character value is algebraic. Adjoining these values +places all ideal-character values in one number field and constructs +the algebraic Hecke character. This argument does not assume that the +given character was initially rational over a number field. +If \(L\) +is real quadratic, its algebraic exponents at the two real +embeddings are equal by the unit theorem: a unit of infinite +order forces their difference to vanish in the algebraic +character relation. This again contradicts regularity. +For imaginary quadratic \(L\), the theta-series construction +gives the required cuspidal eigenform, with its algebraic +Tate normalization; equivalently, use quadratic automorphic +induction \cite[Proposition~12.1]{JacquetLanglands1970}. + +Finally, restriction to finite index preserves \(H^\circ\). +If a restriction of a non-virtually-solvable representation +were reducible, its identity component would lie in a +Borel subgroup and be solvable. This is impossible. +\end{proof} + +Henceforth the target \(r\) is not virtually solvable. +In particular, its restriction to every field used below +is absolutely irreducible. + +\subsection{Fields, deformation spaces, and trace loci} + +All auxiliary base fields \(F\) are totally real, solvable +over \(\mathbb Q\), of even degree, and split completely at +\(2\). We may replace them by Galois closures. Let +\(S\) contain the real places, all places above \(2\), and +a finite set of other places. Set +\[ + d=[F:\mathbb Q],\qquad + u=\#\{v\in S:v\nmid 2,\ v\text{ finite}\},\qquad + s=2d+u. +\] +The group \(G_{F,S}\) is the Galois group of the maximal +extension of \(F\) unramified outside \(S\). + +A two-dimensional pseudorepresentation means a determinant +in the sense of Chenevier, with its determinant character +retained. In particular, no division by \(2\) is used to +recover a determinant from traces. Fixing \(\chi\) and a +semisimple residual representation gives a complete local +pseudodeformation ring, denoted by \(R_F^{\mathrm{ps},\chi}\). +Framed representation rings and schemes, including those +with specified local invariant lines, will be constructed +in Section~\ref{sec:deformation}. Whenever a component is +mapped to a pseudodeformation spectrum, its \emph{image} +means the closure of its image unless stated otherwise. + +There is a unique quaternion algebra \(D_F/F\), up to +isomorphism, ramified at all real places and at no finite +place. The evenness of \(d\) makes this possible, by the classification by +ramification sets \cite[Main Theorem~14.6.1]{Voight2021}. +A completed Hecke algebra of definite \(D_F^\times\)-forms, +with central character \(\psi=\chi\eps\), defines a closed +trace locus in \(\Spec R_F^{\mathrm{ps},\chi}\). +We call such a locus \emph{pro-modular}. The tame level is +open, is hyperspecial away from \(S\), and is unrestricted +at the places above \(2\). A closed trace locus is +\emph{potentially pro-modular} if its restriction becomes +pro-modular after a further solvable totally real extension +split completely at \(2\). All support containments in this +terminology are set-theoretic. + +A \emph{characteristic-two curve} is a one-dimensional +domain quotient of a complete local \(k\)-algebra. After +finite extension, its normalization has the form +\(k'[[t]]\); its generic point has residue field +\(k'((t))\). We also use the word curve for this generic +point and its associated representation when there is +no ambiguity. Whenever such a representation is used, +we choose a compact-image lattice. Agreement of traces +and determinants modulo the maximal ideal determines +the semisimple residual representation, but need not +determine a residual extension class. The latter +distinction will be important in the marked-line +connectedness argument. + +The reductions now leave a fixed determinant and a target that remains +absolutely irreducible after every finite restriction. We next construct +the spaces in which its trace, and when needed its local line character, +can vary. The distinction between these data is essential: a trace +space is sufficient for completed-form occurrence, whereas the final +reducible classicality argument also needs the chosen character. diff --git a/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/paper.pdf b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..38034f532e7d58733bdadd05789d3f74ec9ca3ee --- /dev/null +++ b/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c8797c7d468cdcccbfedf719c9a758a083954ba3c3005975736eb911d26a636 +size 767547 diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/README.md b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dc4b14c11f2206ef7d6ecfb81cee7fc7558591d1 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [Gaussian free-field limits of weighted integer Lipschitz heights](paper.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026, + author = {{OpenAI}}, + title = {{Gaussian free-field limits of weighted integer Lipschitz heights}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/paper.pdf}{OAI:Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version supplies the annulus proof of the circuit estimate used in the discrete argument; see the [previous version](../Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-September-25-2026/paper.pdf). diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/annulus-stepped-domain.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/annulus-stepped-domain.tex new file mode 100644 index 0000000000000000000000000000000000000000..6a019c104edb9e78767a2379944f97ca16537acc --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/annulus-stepped-domain.tex @@ -0,0 +1,32 @@ +\begin{tikzpicture}[x=0.9cm,y=3.0cm,>=Latex,font=\small] + \definecolor{annulusplus}{RGB}{25,90,150} + \definecolor{annulusminus}{RGB}{150,65,45} + \fill[black!4] (0,1.25)--(6,1.25)--(6,.5)--(7,.5)--(7,-.25)--(1,-.25)--(1,.5)--(0,.5)--cycle; + \fill[annulusplus!10] (1.25,-.25) rectangle (5.75,1.25); + \fill[annulusplus!22] (1.25,.3) rectangle (5.75,.7); + \draw[annulusplus,very thick] (0,1.25)--(6,1.25) node[midway,above] {$+$}; + \draw[annulusplus,very thick] (1,-.25)--(7,-.25) node[midway,below] {$+$}; + \draw[annulusminus,thick] (0,1.25)--(0,.5)--(1,.5)--(1,-.25); + \draw[annulusminus,thick] (6,1.25)--(6,.5)--(7,.5)--(7,-.25); + \node[annulusminus,left] at (0,.58) {$-$}; + \node[annulusminus,right] at (7,.42) {$-$}; + \draw[annulusplus,thick] (0,.94) .. controls (.8,.86) and (1.3,.98) .. (2,.89) + .. controls (2.8,.79) and (3.1,.96) .. (4,.87) + .. controls (4.9,.79) and (5.2,.98) .. (6,.9); + \draw[annulusplus,thick] (1,.1) .. controls (1.8,.17) and (2.3,.05) .. (3,.13) + .. controls (3.8,.22) and (4.1,.04) .. (5,.15) + .. controls (5.8,.21) and (6.3,.02) .. (7,.11); + \node[annulusplus,above] at (3.4,.99) {$\Gamma_L$}; + \node[annulusplus,below] at (4,.05) {$\Gamma_R$}; + \foreach \u/\v in {0/.94,6/.9,1/.1,7/.11}{ + \fill[orange!65] (\u,\v) ellipse [x radius=.11,y radius=.035]; + } + \draw[dashed,black!60] (1.25,-.25)--(1.25,1.25); + \draw[dashed,black!60] (5.75,-.25)--(5.75,1.25); + \node at (3.5,.5) {$E:\ \text{central vertical crossing}$}; + \node[below] at (1.25,-.28) {$5\ell/4$}; + \node[below] at (5.75,-.28) {$23\ell/4$}; + \node[right] at (6.1,1.25) {$5\ell/4$}; + \node[right] at (7.1,-.25) {$-\ell/4$}; + \node[above left] at (0,1.25) {$S$}; +\end{tikzpicture} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/boundary-attachment.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/boundary-attachment.tex new file mode 100644 index 0000000000000000000000000000000000000000..45af3c9c4b7154f808b74ccfae48c82bda1afc33 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/boundary-attachment.tex @@ -0,0 +1,73 @@ +\begin{tikzpicture}[x=5.65cm,y=0.66cm, + font=\fontsize{9}{11}\selectfont,line cap=round,line join=round] +\path[use as bounding box] (-1.29,-9.0) rectangle (1.36,5.05); +\foreach \panelshift in {0,-7.2} { + \begin{scope}[shift={(0,\panelshift)}] + \fill[black!7] (-1.16,-0.95) rectangle (1.16,-0.1); + \fill[black!3] (-1.16,-0.1) rectangle (1.16,0.1); + \draw[black!45,densely dotted] (-1.16,-0.1) -- (1.16,-0.1); + \draw[black!45,densely dotted] (-1.16,0.1) -- (1.16,0.1); + \draw[black!35,densely dashed] (-1.16,1) -- (1.16,1); + \draw[black!35,densely dotted] (-1.16,3) -- (1.16,3); + \node[anchor=east,fill=white,inner sep=1pt] at (-1.19,1) {$s$}; + \node[anchor=east,fill=white,inner sep=1pt] at (-1.19,3) {$3s$}; + \node[anchor=east,inner sep=1pt] at (-1.19,0) {$0$}; + \draw[line width=0.7pt] + (-1.16,0.02) -- (-1.00,0.04) -- (-0.87,-0.025) -- (-0.80,0.06) + -- (-0.83,0.005) -- (-0.80,0.06) -- (-0.66,0.015) + -- (-0.51,-0.02) -- (-0.39,0.04) -- (-0.26,0.015) + -- (-0.22,-0.025) -- (-0.245,0.035) -- (-0.22,-0.025) + -- (-0.125,0.015) -- (0,0.04) -- (0.125,0.015) + -- (0.22,-0.03) -- (0.35,0.04) -- (0.48,0.005) + -- (0.55,0.055) -- (0.515,-0.025) -- (0.55,0.055) + -- (0.67,0.02) -- (0.82,-0.01) -- (1,0.04) -- (1.16,0.015); + \draw[line width=2pt] (-0.125,0.015) -- (0,0.04) -- (0.125,0.015); + \draw[line width=1pt] (-0.667,0.9) ellipse [x radius=0.105,y radius=1.3]; + \draw[line width=1pt] (0.667,0.9) ellipse [x radius=0.105,y radius=1.3]; + \foreach \a in {-0.667,0.667} { + \node[anchor=south,fill=white,inner sep=1pt] at (\a,2.42) {$K\le -2$}; + } + \fill (0,3) circle [radius=1.6pt]; + \node[anchor=north] at (-0.667,-0.47) {$-2b/3$}; + \node[anchor=north] at (0.667,-0.47) {$2b/3$}; + \node[anchor=north,fill=black!7,inner sep=1pt] at (0,-0.32) {high patch}; + \node[anchor=west,inner sep=0pt] at (-1.145,-0.68) {actual exterior}; + \end{scope} +} +\node[anchor=west,font=\fontsize{9}{11}\selectfont\bfseries] at (-1.16,4.65) + {(a) A boundary-tied zero lip reaches depth $s$}; +\draw[line width=1.7pt] + (-0.085,0.025) .. controls (-0.29,0.75) and (-0.31,2.1) .. (-0.29,3.16) + .. controls (-0.28,3.73) and (0.29,3.82) .. (0.32,3.17) + .. controls (0.34,2.03) and (0.30,0.76) .. (0.085,0.025); +\node[anchor=west,align=left,fill=white,inner sep=1.5pt] at (0.40,3.62) + {exposed lip $K=0$}; +\draw[thin] (0.405,3.5) -- (0.30,3.46); +\node[align=center,fill=white,inner sep=1.5pt] at (0,1.92) {high side}; +\node[anchor=north,fill=white,inner sep=1.5pt] at (0,2.84) {$z=(0,3s)$}; +\node[anchor=west,inner sep=0pt] at (-1.15,-1.50) + {The real boundary walk, including repetitions, lies in $|\mathrm{depth}|] (0.03,3) -- (0.93,3); + \draw[dashed,line width=0.85pt,->] (1,3) -- (1,0.13); + \draw[dashed,line width=0.85pt] (0.93,3) -- (1,3); + \draw[fill=white,line width=0.8pt] (1,0.04) circle [radius=2pt]; + \node[anchor=south,fill=white,inner sep=2pt] at (0.56,3.23) + {geometric route; no exposed contour crossed}; + \node[anchor=west,fill=white,inner sep=1.5pt] at (1.035,1.83) {descent}; + \node[anchor=west,inner sep=1pt] at (1.035,0.49) {low hit}; + \node[anchor=north,inner sep=1pt] at (1,-0.38) {$t\simeq b$}; + \node[anchor=west,inner sep=0pt] at (-1.15,-1.50) + {The descent stops at its first real walk hit, where the synthetic trace is low.}; +\end{scope} +\end{tikzpicture} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/cell-cut.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/cell-cut.tex new file mode 100644 index 0000000000000000000000000000000000000000..c1de1648263375b2b45bccdcb4f96e94b8b8a667 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/cell-cut.tex @@ -0,0 +1,142 @@ +\begin{tikzpicture}[x=1cm,y=1cm,font=\fontsize{9}{11}\selectfont, + line cap=round,line join=round] +\path[use as bounding box] (0,-1.25) rectangle (15,5.3); +\node[anchor=west,font=\fontsize{9}{11}\selectfont\bfseries] at (0,5.05) + {(a) An open interaction cell}; +\draw[thin,fill=black!3] (0.65,1.35) -- (3.85,1.35) -- (2.25,4.12) -- cycle; +\draw[line width=1.3pt] (1.45,2.735) -- (2.25,2.273) -- (3.05,2.735); +\node[anchor=south east] at (1.44,2.78) {$\gamma$}; +\fill (2.25,2.273) circle (2.3pt); +\node[anchor=north] at (2.25,2.13) {$\tau_y=+$}; +\foreach \a/\b in {0.65/1.35,3.85/1.35,2.25/4.12} + \draw[fill=white] (\a,\b) circle (2.3pt); +\node[anchor=south,align=center] at (2.25,4.2) {$B=+$, $W_3$ free}; +\node[anchor=north,align=center] at (0.65,1.18) {$B=+$\\$W_1$ free}; +\node[anchor=north,align=center] at (3.85,1.18) {$B=+$\\$W_2$ free}; +\node[align=center] at (2.25,-0.35) + {Cell weight $q=x^2$\\independent of $(W_1,W_2,W_3)$}; +\node[anchor=west,font=\fontsize{9}{11}\selectfont\bfseries] at (5.65,5.05) + {(b) A prescribed open-cell circuit}; +\begin{scope}[shift={(10.35,2.55)},scale=1.02] +\fill[black!6] (-3.45,-2.13) rectangle (3.85,2.14); +\fill[white] (-1.500000,-0.288675) -- (-1.500000,0.288675) -- (-1.000000,0.577350) -- (-1.000000,1.154701) -- (-0.500000,1.443376) -- (0.000000,1.154701) -- (0.500000,1.443376) -- (1.000000,1.154701) -- (1.000000,0.577350) -- (1.500000,0.288675) -- (1.500000,-0.288675) -- (1.000000,-0.577350) -- (1.000000,-1.154701) -- (0.500000,-1.443376) -- (0.000000,-1.154701) -- (-0.500000,-1.443376) -- (-1.000000,-1.154701) -- (-1.000000,-0.577350) -- cycle; +\draw[black!25,line width=0.3pt] (-2.500000,-0.288675) -- (-2.500000,0.288675); +\draw[black!25,line width=0.3pt] (-2.500000,-0.288675) -- (-2.000000,-0.577350); +\draw[black!25,line width=0.3pt] (-2.500000,0.288675) -- (-2.000000,0.577350); +\draw[black!25,line width=0.3pt] (-2.000000,-1.154701) -- (-2.000000,-0.577350); +\draw[black!25,line width=0.3pt] (-2.000000,-1.154701) -- (-1.500000,-1.443376); +\draw[black!25,line width=0.3pt] (-2.000000,-0.577350) -- (-1.500000,-0.288675); +\draw[black!25,line width=0.3pt] (-2.000000,0.577350) -- (-2.000000,1.154701); +\draw[black!25,line width=0.3pt] (-2.000000,0.577350) -- (-1.500000,0.288675); +\draw[black!25,line width=0.3pt] (-2.000000,1.154701) -- (-1.500000,1.443376); +\draw[black!25,line width=0.3pt] (-1.500000,-2.020726) -- (-1.500000,-1.443376); +\draw[black!25,line width=0.3pt] (-1.500000,-2.020726) -- (-1.000000,-2.309401); +\draw[black!25,line width=0.3pt] (-1.500000,-1.443376) -- (-1.000000,-1.154701); +\draw[black!25,line width=0.3pt] (-1.500000,-0.288675) -- (-1.500000,0.288675); +\draw[black!25,line width=0.3pt] (-1.500000,-0.288675) -- (-1.000000,-0.577350); +\draw[black!25,line width=0.3pt] (-1.500000,0.288675) -- (-1.000000,0.577350); +\draw[black!25,line width=0.3pt] (-1.500000,1.443376) -- (-1.500000,2.020726); +\draw[black!25,line width=0.3pt] (-1.500000,1.443376) -- (-1.000000,1.154701); +\draw[black!25,line width=0.3pt] (-1.500000,2.020726) -- (-1.000000,2.309401); +\draw[black!25,line width=0.3pt] (-1.000000,-2.309401) -- (-0.500000,-2.020726); +\draw[black!25,line width=0.3pt] (-1.000000,-1.154701) -- (-1.000000,-0.577350); +\draw[black!25,line width=0.3pt] (-1.000000,-1.154701) -- (-0.500000,-1.443376); +\draw[black!25,line width=0.3pt] (-1.000000,-0.577350) -- (-0.500000,-0.288675); +\draw[black!25,line width=0.3pt] (-1.000000,0.577350) -- (-1.000000,1.154701); +\draw[black!25,line width=0.3pt] (-1.000000,0.577350) -- (-0.500000,0.288675); +\draw[black!25,line width=0.3pt] (-1.000000,1.154701) -- (-0.500000,1.443376); +\draw[black!25,line width=0.3pt] (-1.000000,2.309401) -- (-0.500000,2.020726); +\draw[black!25,line width=0.3pt] (-0.500000,-2.020726) -- (-0.500000,-1.443376); +\draw[black!25,line width=0.3pt] (-0.500000,-2.020726) -- (0.000000,-2.309401); +\draw[black!25,line width=0.3pt] (-0.500000,-1.443376) -- (0.000000,-1.154701); +\draw[black!25,line width=0.3pt] (-0.500000,-0.288675) -- (-0.500000,0.288675); +\draw[black!25,line width=0.3pt] (-0.500000,-0.288675) -- (0.000000,-0.577350); +\draw[black!25,line width=0.3pt] (-0.500000,0.288675) -- (0.000000,0.577350); +\draw[black!25,line width=0.3pt] (-0.500000,1.443376) -- (-0.500000,2.020726); +\draw[black!25,line width=0.3pt] (-0.500000,1.443376) -- (0.000000,1.154701); +\draw[black!25,line width=0.3pt] (-0.500000,2.020726) -- (0.000000,2.309401); +\draw[black!25,line width=0.3pt] (0.000000,-2.309401) -- (0.500000,-2.020726); +\draw[black!25,line width=0.3pt] (0.000000,-1.154701) -- (0.000000,-0.577350); +\draw[black!25,line width=0.3pt] (0.000000,-1.154701) -- (0.500000,-1.443376); +\draw[black!25,line width=0.3pt] (0.000000,-0.577350) -- (0.500000,-0.288675); +\draw[black!25,line width=0.3pt] (0.000000,0.577350) -- (0.000000,1.154701); +\draw[black!25,line width=0.3pt] (0.000000,0.577350) -- (0.500000,0.288675); +\draw[black!25,line width=0.3pt] (0.000000,1.154701) -- (0.500000,1.443376); +\draw[black!25,line width=0.3pt] (0.000000,2.309401) -- (0.500000,2.020726); +\draw[black!25,line width=0.3pt] (0.500000,-2.020726) -- (0.500000,-1.443376); +\draw[black!25,line width=0.3pt] (0.500000,-2.020726) -- (1.000000,-2.309401); +\draw[black!25,line width=0.3pt] (0.500000,-1.443376) -- (1.000000,-1.154701); +\draw[black!25,line width=0.3pt] (0.500000,-0.288675) -- (0.500000,0.288675); +\draw[black!25,line width=0.3pt] (0.500000,-0.288675) -- (1.000000,-0.577350); +\draw[black!25,line width=0.3pt] (0.500000,0.288675) -- (1.000000,0.577350); +\draw[black!25,line width=0.3pt] (0.500000,1.443376) -- (0.500000,2.020726); +\draw[black!25,line width=0.3pt] (0.500000,1.443376) -- (1.000000,1.154701); +\draw[black!25,line width=0.3pt] (0.500000,2.020726) -- (1.000000,2.309401); +\draw[black!25,line width=0.3pt] (1.000000,-2.309401) -- (1.500000,-2.020726); +\draw[black!25,line width=0.3pt] (1.000000,-1.154701) -- (1.000000,-0.577350); +\draw[black!25,line width=0.3pt] (1.000000,-1.154701) -- (1.500000,-1.443376); +\draw[black!25,line width=0.3pt] (1.000000,-0.577350) -- (1.500000,-0.288675); +\draw[black!25,line width=0.3pt] (1.000000,0.577350) -- (1.000000,1.154701); +\draw[black!25,line width=0.3pt] (1.000000,0.577350) -- (1.500000,0.288675); +\draw[black!25,line width=0.3pt] (1.000000,1.154701) -- (1.500000,1.443376); +\draw[black!25,line width=0.3pt] (1.000000,2.309401) -- (1.500000,2.020726); +\draw[black!25,line width=0.3pt] (1.500000,-2.020726) -- (1.500000,-1.443376); +\draw[black!25,line width=0.3pt] (1.500000,-1.443376) -- (2.000000,-1.154701); +\draw[black!25,line width=0.3pt] (1.500000,-0.288675) -- (1.500000,0.288675); +\draw[black!25,line width=0.3pt] (1.500000,-0.288675) -- (2.000000,-0.577350); +\draw[black!25,line width=0.3pt] (1.500000,0.288675) -- (2.000000,0.577350); +\draw[black!25,line width=0.3pt] (1.500000,1.443376) -- (1.500000,2.020726); +\draw[black!25,line width=0.3pt] (1.500000,1.443376) -- (2.000000,1.154701); +\draw[black!25,line width=0.3pt] (2.000000,-1.154701) -- (2.000000,-0.577350); +\draw[black!25,line width=0.3pt] (2.000000,-0.577350) -- (2.500000,-0.288675); +\draw[black!25,line width=0.3pt] (2.000000,0.577350) -- (2.000000,1.154701); +\draw[black!25,line width=0.3pt] (2.000000,0.577350) -- (2.500000,0.288675); +\draw[black!25,line width=0.3pt] (2.500000,-0.288675) -- (2.500000,0.288675); +\draw[line width=1.25pt] (-1.500000,-0.288675) -- (-1.500000,0.288675) -- (-1.000000,0.577350) -- (-1.000000,1.154701) -- (-0.500000,1.443376) -- (0.000000,1.154701) -- (0.500000,1.443376) -- (1.000000,1.154701) -- (1.000000,0.577350) -- (1.500000,0.288675) -- (1.500000,-0.288675) -- (1.000000,-0.577350) -- (1.000000,-1.154701) -- (0.500000,-1.443376) -- (0.000000,-1.154701) -- (-0.500000,-1.443376) -- (-1.000000,-1.154701) -- (-1.000000,-0.577350) -- cycle; +\draw[fill=white,line width=0.7pt] (-1.500000,-0.288675) circle (1.9pt); +\fill (-1.500000,0.288675) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (-1.000000,0.577350) circle (1.9pt); +\fill (-1.000000,1.154701) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (-0.500000,1.443376) circle (1.9pt); +\fill (0.000000,1.154701) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (0.500000,1.443376) circle (1.9pt); +\fill (1.000000,1.154701) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (1.000000,0.577350) circle (1.9pt); +\fill (1.500000,0.288675) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (1.500000,-0.288675) circle (1.9pt); +\fill (1.000000,-0.577350) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (1.000000,-1.154701) circle (1.9pt); +\fill (0.500000,-1.443376) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (0.000000,-1.154701) circle (1.9pt); +\fill (-0.500000,-1.443376) circle (1.9pt); +\draw[fill=white,line width=0.7pt] (-1.000000,-1.154701) circle (1.9pt); +\fill (-1.000000,-0.577350) circle (1.9pt); +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-2.000000,0.000000) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-1.500000,0.866025) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-1.000000,1.732051) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-1.500000,-0.866025) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-1.000000,0.000000) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-0.500000,0.866025) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (0.000000,1.732051) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-1.000000,-1.732051) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (-0.500000,-0.866025) {$+$}; +\fill (0.000000,0.000000) circle (1pt); +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (0.500000,0.866025) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (1.000000,1.732051) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (0.000000,-1.732051) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (0.500000,-0.866025) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (1.000000,0.000000) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (1.500000,0.866025) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (1.000000,-1.732051) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (1.500000,-0.866025) {$+$}; +\node[font=\fontsize{9}{11}\selectfont,inner sep=0.6pt,circle,fill=white] at (2.000000,0.000000) {$+$}; +\node[fill=white,inner sep=2pt] at (0,-0.35) {interior}; +\node[anchor=west,fill=black!6,inner sep=2pt] at (1.85,1.76) {tested side}; +\node[anchor=west,fill=black!6,inner sep=1pt] at (1.9,0.7) {$\gamma$}; +\end{scope} +\fill (6.15,-0.13) circle (1.9pt); +\node[anchor=west] at (6.28,-0.13) {$Y$-cell on $\gamma$: $\tau_y=+$}; +\node[anchor=west] at (10.5,-0.13) {$+$: prescribed $B$ site}; +\node[anchor=west] at (6.05,-0.72) + {$W$ is unobserved; no $E_0$ edge crosses $\gamma$.}; +\end{tikzpicture} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/pins-five-moves.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/pins-five-moves.tex new file mode 100644 index 0000000000000000000000000000000000000000..08cb139b27af4accf817425cd9c25c31cdd16080 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/figures/pins-five-moves.tex @@ -0,0 +1,126 @@ +\begingroup +\colorlet{pinsplus}{blue!60!black} +\colorlet{pinsminus}{orange!65!black} +\tikzset{ + pins gap/.style={densely dashed,black!45,line width=.45pt}, + pins move/.style={-{Stealth[length=2mm]},line width=.8pt}, + pins title/.style={font=\small\bfseries}, + pins order/.style={font=\footnotesize,align=center}, + pins axis/.style={-{Stealth[length=1.5mm]},black!50,line width=.4pt} +} +\newcommand{\pinsgroup}[4]{% + \begin{scope}[shift={(#1,#2)}] + \draw[draw=#4,fill=#4!8,line width=.65pt] + (0,0) ellipse[x radius=.34cm,y radius=.23cm]; + \fill[#4] (-.23,.03) circle[radius=.018cm]; + \fill[#4] (.20,.10) circle[radius=.018cm]; + \fill[#4] (.23,-.09) circle[radius=.018cm]; + \node[font=\small,inner sep=0pt] at (0,0) {$#3$}; + \end{scope}% +} +\newcommand{\pinskzero}{% + \draw[draw=black!60,fill=black!6,line width=.65pt] + (0,0) circle[radius=.23cm]; + \node[font=\footnotesize,inner sep=0pt] at (0,0) {$K_0$}; +} +\newcommand{\pinsprojection}[6]{% + \draw[pins axis] (-2.30,-1.95)--(2.30,-1.95) + node[right,black,font=\scriptsize] {$\pi_{#1}$}; + \draw[#3,line width=2.3pt] (-1.75,-1.95)--(-1.05,-1.95); + \draw[black!65,line width=2.3pt] (-.35,-1.95)--(.35,-1.95); + \draw[#6,line width=2.3pt] (1.05,-1.95)--(1.75,-1.95); + \node[pins order,anchor=north] at (-1.40,-2.03) {$#2$}; + \node[pins order,anchor=north] at (0,-2.03) {$#4$}; + \node[pins order,anchor=north] at (1.40,-2.03) {$#5$}; +} +\begin{tikzpicture}[x=1cm,y=1cm,font=\footnotesize] + \begin{scope} + \node[pins title] at (0,2.15) {(a) Initial placement}; + \draw[pins gap] (-2.30,.46)--(2.30,.46) + node[right,black] {$\ell_+$}; + \draw[pins gap] (-2.30,-.46)--(2.30,-.46) + node[right,black] {$\ell_-$}; + \pinskzero + \pinsgroup{0}{.95}{T}{pinsplus} + \pinsgroup{0}{-.95}{B}{pinsminus} + \pinsgroup{-1.70}{0}{L}{pinsminus} + \pinsgroup{1.70}{0}{R}{pinsplus} + \draw[pins move,pinsplus] (0,1.23)--(0,1.72) + node[midway,right=3pt] {$(1)\ a_+e$}; + \draw[pins move,pinsminus] (0,-1.23)--(0,-1.72) + node[midway,right=3pt] {$(2)\ {-a_-e}$}; + \pinsprojection{e}{B}{pinsminus}{K_0,L,R}{T}{pinsplus} + \node[pins order,text width=6.1cm] at (0,-2.80) + {$L<_uK_0<_uR$;\\the two horizontal gaps are strict.}; + \end{scope} + + \begin{scope}[shift={(7.15,0)}] + \node[pins title] at (0,2.15) {(b) After moves 1--2}; + \draw[pins gap] (1.414,-1.45)--(-.260,1.45); + \draw[pins gap] (.260,-1.45)--(-1.414,1.45); + \pinskzero + \pinsgroup{.90}{.95}{T}{pinsplus} + \pinsgroup{1.60}{.05}{R}{pinsplus} + \pinsgroup{-.90}{-.95}{B}{pinsminus} + \pinsgroup{-1.60}{-.05}{L}{pinsminus} + \node[text=pinsplus] at (1.60,1.45) {$Q_+=T\cup R$}; + \node[text=pinsminus] at (-1.60,-1.45) {$Q_-=B\cup L$}; + \draw[pins move,pinsplus] (2.00,.27)--(2.69,.67) + node[midway,above=4pt] {$(3)\ bu$}; + \draw[pins move,pinsminus] (-2.00,-.27)--(-2.69,-.67) + node[midway,below=4pt] {$(4)\ {-cu}$}; + \pinsprojection{u}{Q_-}{pinsminus}{K_0}{Q_+}{pinsplus} + \node[pins order,text width=6.1cm] at (0,-2.80) + {Move each entire family outwards\\across its $u$-gap.}; + \end{scope} + + \begin{scope}[shift={(0,-5.65)}] + \node[pins title] at (0,2.15) {(c) After moves 3--4}; + \draw[pins gap] (-1.299,-1.45)--(.375,1.45); + \draw[pins gap] (-.375,-1.45)--(1.299,1.45); + \pinskzero + \pinsgroup{1.80}{1.18}{T}{pinsplus} + \pinsgroup{2.28}{.55}{R}{pinsplus} + \pinsgroup{-1.80}{-1.18}{B}{pinsminus} + \pinsgroup{-2.28}{-.55}{L}{pinsminus} + \node[text=pinsplus] at (1.95,1.63) {$Q_+$}; + \node[text=pinsminus] at (-1.85,-1.63) {$Q_-$}; + \draw[pins move,pinsminus] (-2.38,-.17)--(-2.99,.18) + node[midway,above=5pt] {$(5)\ du'$}; + \pinsprojection{u'}{Q_+}{pinsplus}{K_0}{Q_-}{pinsminus} + \node[pins order,text width=6.1cm] at (0,-2.80) + {$K_0<_eQ_+$;\\now $Q_-$ is the extreme high $u'$-side.}; + \end{scope} + + \begin{scope}[shift={(7.15,-5.65)}] + \node[pins title] at (0,2.15) {(d) After move 5}; + \draw[pins gap] (-2.70,.40)--(2.70,.40) + node[right,black] {$\vartheta$}; + \pinskzero + \pinsgroup{1.30}{1.33}{T}{pinsplus} + \pinsgroup{2.10}{.80}{R}{pinsplus} + \pinsgroup{-1.30}{.80}{B}{pinsminus} + \pinsgroup{-2.10}{1.33}{L}{pinsminus} + \node[text=pinsplus] at (1.80,1.77) {$Q_+$}; + \node[text=pinsminus] at (-1.80,1.77) {$Q_-$}; + \node[anchor=north] at (0,-.29) {$X_\delta$ stays fixed in $K_0$}; + \begin{scope}[shift={(0,-1.47)}] + \draw[pins move,black!70] (0,0)--(0,.56) + node[above,black] {$e$}; + \draw[pins move,black!70] (0,0)--(.65,.375) + node[right,black] {$u$}; + \draw[pins move,black!70] (0,0)--(-.65,.375) + node[left,black] {$u'$}; + \end{scope} + \draw[pins axis] (-2.30,-1.95)--(2.30,-1.95) + node[right,black,font=\scriptsize] {$\pi_e$}; + \draw[black!65,line width=2.3pt] (-1.75,-1.95)--(-1.05,-1.95); + \draw[pinsplus,line width=2.3pt] (.55,-1.92)--(1.75,-1.92); + \draw[pinsminus,line width=2.3pt] (.55,-1.98)--(1.75,-1.98); + \node[pins order,anchor=north] at (-1.40,-2.03) {$K_0$}; + \node[pins order,anchor=north] at (1.15,-2.03) {$Q_+\cup Q_-$}; + \node[pins order,text width=6.1cm] at (0,-2.80) + {A horizontal reflection row\\separates the insertion.}; + \end{scope} +\end{tikzpicture} +\endgroup diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/main.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..a33c0525f03e1b85734e64adc6e5927833d41417 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/main.tex @@ -0,0 +1,73 @@ +\PassOptionsToPackage{hyphens}{url} +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amsthm,amssymb,mathtools} +\usepackage{microtype} +\usepackage{graphicx,xcolor,tikz} +\usepackage{placeins} +\usetikzlibrary{arrows.meta,calc,decorations.pathreplacing,patterns} +\definecolor{linkblue}{RGB}{24,66,112} +\usepackage[colorlinks=true,linkcolor=linkblue,citecolor=linkblue,urlcolor=linkblue]{hyperref} +\hypersetup{pdftitle={Gaussian free-field limits of weighted integer Lipschitz heights},pdfauthor={OpenAI}} + +\newcommand{\T}{\mathbb T} +\newcommand{\hexlat}{\mathbb H} +\newcommand{\R}{\mathbb R} +\newcommand{\Z}{\mathbb Z} +\newcommand{\N}{\mathbb N} +\newcommand{\E}{\mathbb E} +\newcommand{\Prob}{\mathbb P} +\newcommand{\ind}{\mathbf 1} +\newcommand{\dd}{\,\mathrm d} +\newcommand{\TV}{\mathrm{TV}} +\DeclareMathOperator{\Var}{Var} +\DeclareMathOperator{\Cov}{Cov} +\DeclareMathOperator{\dist}{dist} +\DeclareMathOperator{\diam}{diam} +\DeclareMathOperator{\supp}{supp} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\numberwithin{equation}{section} + +\title{Gaussian free-field limits\\of weighted integer Lipschitz heights} +\author{OpenAI} +\date{October 6, 2026} + +\begin{document} +\maketitle +\begin{abstract} +We prove a Gaussian free field scaling limit for weighted integer Lipschitz +heights on the triangular lattice. With zero boundary values and a factor $x$ +for each edge on which the height changes, the field converges after division +by a positive constant depending only on $x$ to the zero-Dirichlet Gaussian +free field, for every fixed $x\in[1/\sqrt2,1]$. The convergence holds as a +random distribution on every bounded $C^2$ Jordan domain under inside lattice +approximations with uniformly convergent boundary parametrizations. This +includes the uniform height model and the predicted critical endpoint. +\end{abstract} + +\tableofcontents + +\input{sections/01-introduction} +\input{sections/02-discrete} +\input{sections/03-moments} +\input{sections/04-plane} +\input{sections/05-pins} +\input{sections/06-boundary} +\input{sections/07-limit} + +\appendix +\input{sections/08-scalar-spectra} +\input{sections/09-annulus} + +\bibliographystyle{plain} +\bibliography{references/references} +\end{document} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/references/references.bib b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/references/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..cee2440e7c7e3be479942d2bb867d6465854ff7d --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/references/references.bib @@ -0,0 +1,181 @@ +@incollection{Schramm2007, + author = {Schramm, Oded}, + title = {Conformally invariant scaling limits: an overview and a collection of problems}, + booktitle = {Proceedings of the International Congress of Mathematicians, Madrid, 2006}, + volume = {I}, + editor = {Sanz-Sol{\'e}, Marta and Soria, Javier and Varona, Juan L. and Verdera, Joan}, + publisher = {European Mathematical Society}, + address = {Z{\"u}rich}, + year = {2007}, + pages = {513--543}, + doi = {10.4171/022-1/20}, + note = {\href{https://arxiv.org/abs/math/0602151v2}{arXiv:math/0602151v2}, Problem~2.2} +} + +@article{DGPS2021, + author = {Duminil-Copin, Hugo and Glazman, Alexander and Peled, Ron and Spinka, Yinon}, + title = {Macroscopic loops in the loop {$O(n)$} model at {Nienhuis'} critical point}, + journal = {Journal of the European Mathematical Society}, + volume = {23}, + number = {1}, + year = {2021}, + pages = {315--347}, + doi = {10.4171/JEMS/1012} +} + +@article{GM2021, + author = {Glazman, Alexander and Manolescu, Ioan}, + title = {Uniform {Lipschitz} functions on the triangular lattice have logarithmic variations}, + journal = {Communications in Mathematical Physics}, + volume = {381}, + number = {3}, + year = {2021}, + pages = {1153--1221}, + doi = {10.1007/s00220-020-03920-z}, + note = {Revised version: \href{https://arxiv.org/abs/1810.05592v3}{arXiv:1810.05592v3} (2023)} +} + +@article{GL2025, + author = {Glazman, Alexander and Lammers, Piet}, + title = {Delocalisation and continuity in {2D}: loop {$O(2)$}, six-vertex, and random-cluster models}, + journal = {Communications in Mathematical Physics}, + volume = {406}, + number = {5}, + year = {2025}, + pages = {Article 108}, + doi = {10.1007/s00220-025-05259-9}, + note = {All numbered statements cited here refer to + \href{https://arxiv.org/abs/2306.01527v3}{arXiv:2306.01527v3} + (27 October 2023), in particular Appendix~A, equation~(55)} +} + +@article{KlartagLehec2019, + author = {Klartag, Bo'az and Lehec, Joseph}, + title = {Poisson processes and a log-concave {Bernstein} theorem}, + journal = {Studia Mathematica}, + volume = {247}, + number = {1}, + year = {2019}, + pages = {85--107}, + doi = {10.4064/sm180212-30-7}, + note = {\href{https://arxiv.org/abs/1802.04176v2}{arXiv:1802.04176v2}, Theorem~1.4} +} + +@article{GRST2019, + author = {Gozlan, Nathael and Roberto, Cyril and Samson, Paul-Marie and Tetali, Prasad}, + title = {Transport proofs of some discrete variants of the {Pr{\'e}kopa--Leindler} inequality}, + journal = {Annali della Scuola Normale Superiore di Pisa, Classe di Scienze}, + series = {5}, + volume = {22}, + number = {3}, + year = {2021}, + pages = {1207--1232}, + doi = {10.2422/2036-2145.201906_002}, + note = {Numbered citations refer to + \href{https://arxiv.org/abs/1905.04038v1}{arXiv:1905.04038v1}, + in particular Theorem~3 and Theorem~8, equation~(9)} +} + +@misc{UniformIntegerGFF, + author = {{OpenAI}}, + title = {{The Gaussian free field limit of integer Lipschitz heights with two-arc boundary data}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/paper.pdf}{OAI:The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026}}, + year = {2026}, + note = {Sections~5, 7, 9, and 10} +} + +@article{GKS1968, + author = {Kelly, D. G. and Sherman, S.}, + title = {General {Griffiths}' Inequalities on Correlations in {Ising} Ferromagnets}, + journal = {Journal of Mathematical Physics}, + volume = {9}, + number = {3}, + pages = {466--484}, + year = {1968}, + doi = {10.1063/1.1664600} +} + +@article{FKG1971, + author = {Fortuin, C. M. and Kasteleyn, P. W. and Ginibre, J.}, + title = {Correlation Inequalities on Some Partially Ordered Sets}, + journal = {Communications in Mathematical Physics}, + volume = {22}, + pages = {89--103}, + year = {1971}, + doi = {10.1007/BF01651330} +} + +@article{Holley1974, + author = {Holley, Richard}, + title = {Remarks on the {FKG} Inequalities}, + journal = {Communications in Mathematical Physics}, + volume = {36}, + pages = {227--231}, + year = {1974}, + doi = {10.1007/BF01645980} +} + +@article{FILS1978, + author = {Fr{\"o}hlich, J{\"u}rg and Israel, Robert and Lieb, Elliott H. and Simon, Barry}, + title = {Phase transitions and reflection positivity. {I}. {General} theory and long range lattice models}, + journal = {Communications in Mathematical Physics}, + volume = {62}, + year = {1978}, + pages = {1--34}, + doi = {10.1007/BF01940327} +} + +@misc{Usui2012, + author = {Usui, Kouta}, + title = {A Note on Reflection Positivity and the {Umezawa--Kamefuchi--K\"all\'en--Lehmann} Representation of Two Point Correlation Functions}, + year = {2012}, + note = {\href{https://arxiv.org/abs/1201.3415v3}{arXiv:1201.3415v3}, Sections 3--4} +} + +@misc{DCKLM2026, + author = {Duminil-Copin, Hugo and Kozlowski, Karol Kajetan and Lammers, Piet and Manolescu, Ioan}, + title = {Gaussian free field convergence of the six-vertex model with {$-1\le\Delta\le-1/2$}}, + year = {2026}, + note = {\href{https://arxiv.org/abs/2603.06268v1}{arXiv:2603.06268v1}, March 6, 2026} +} + +@article{Kenyon2001, + author = {Kenyon, Richard}, + title = {Dominos and the {Gaussian} Free Field}, + journal = {The Annals of Probability}, + volume = {29}, + number = {3}, + year = {2001}, + pages = {1128--1137}, + doi = {10.1214/aop/1015345599}, + note = {Numbered citations refer to + \href{https://arxiv.org/abs/math-ph/0002027v1}{arXiv:math-ph/0002027v1}} +} + +@misc{BalancedSixVertexGFF2026, + author = {{OpenAI}}, + title = {{The Gaussian free field limit of the balanced six-vertex model with variance multiplier $1/\arcsin(c/2)$}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026/The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026.pdf}{OAI:The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026}}, + year = {2026} +} + +@article{Nienhuis1982, + author = {Nienhuis, Bernard}, + title = {Exact Critical Point and Critical Exponents of {$O(n)$} Models in Two Dimensions}, + journal = {Physical Review Letters}, + volume = {49}, + number = {15}, + pages = {1062--1065}, + year = {1982}, + doi = {10.1103/PhysRevLett.49.1062} +} + +@misc{GHZ2025, + author = {Glazman, Alexander and Harel, Matan and Zelesko, Nathan}, + title = {Planar percolation and the loop {$O(n)$} model}, + year = {2025}, + note = {\href{https://arxiv.org/abs/2508.20917v3}{arXiv:2508.20917v3}, + revised 19 April 2026} +} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/01-introduction.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..bce068bc55bb10b6033b508a797365f7ee9768ce --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/01-introduction.tex @@ -0,0 +1,305 @@ +\section{Introduction}\label{sec:introduction} + +An integer Lipschitz function on the triangular lattice is a discrete +surface with a hard constraint on its nearest-neighbor slopes. We weight +each unit height change by a parameter $x$. The associated contours form +the loop $O(2)$ model on the hexagonal lattice. We prove that the smoothly +averaged surface has a Gaussian free field limit throughout +$1/\sqrt2\le x\le1$, including the predicted critical endpoint. The +normalization is independent of the domain and of its lattice approximation. + +\subsection{Model, approximation, and theorem} + +Let $\hexlat$ be the hexagonal lattice embedded in $\R^2$ so that its face +centers form the triangular lattice +\[ + \T=\Z(1,0)+\Z(1/2,\sqrt3/2). +\] +Two faces are adjacent when they share an edge. We identify each face with +its center whenever using the triangular-lattice description. + +\begin{definition}[Inside approximation]\label{def:approximation} +Let $D\subset\R^2$ be a bounded simply connected domain with $C^2$ Jordan +boundary. For each mesh $\delta$ in a sequence tending to zero, let +$\gamma_\delta$ be a simple cycle in $\delta\hexlat$, let $D_\delta$ be its +bounded interior, and include every lattice vertex and edge on or inside +the cycle. We require $D_\delta\subset D$, that every compact subset of +$D$ is eventually contained in $D_\delta$, and that there are +parametrizations +\[ + \gamma_\delta:S^1\longrightarrow\partial D_\delta, + \qquad \gamma:S^1\longrightarrow\partial D, + \qquad \|\gamma_\delta-\gamma\|_\infty\longrightarrow0. +\] +Here each parametrization is a homeomorphism onto the indicated curve. +Write $F_\delta$ for the hexagonal faces enclosed by $\gamma_\delta$, and +$\partial F_\delta$ for those adjacent to the boundary cycle. +\end{definition} + +Fix $x\in[1/\sqrt2,1]$. An admissible height is a function +$h:F_\delta\to\Z$ such that +\[ + h=0\quad\text{on }\partial F_\delta, + \qquad |h(u)-h(v)|\le1\quad\text{whenever }u\sim v. +\] +Its probability is +\begin{equation}\label{eq:model} + \Prob_{\delta,x}(h)=\frac{x^{N_\delta(h)}}{Z_{\delta,x}}, + \qquad + N_\delta(h)=\sum_{\{u,v\}\subset F_\delta:\,u\sim v} + \ind_{\{h(u)\ne h(v)\}}. +\end{equation} +The sum counts each unordered adjacent pair once. The admissible set is +finite, since the height at any face is bounded in absolute value by its +graph distance to $\partial F_\delta$. It contains the zero function, so +$Z_{\delta,x}$ is finite and positive. Height reflection preserves +\eqref{eq:model}; in particular, $\E h_\delta(u)=0$. + +Extend $h_\delta$ as a constant on each enclosed face and by zero outside +$D_\delta$. For $f\in C_c^\infty(D)$ we always use the Euclidean area +pairing +\begin{equation}\label{eq:area-pairing} + h_\delta(f)=\int_D h_\delta(z)f(z)\dd z + =\sum_{u\in F_\delta} w_{\delta,f}(u)h_\delta(u), + \qquad w_{\delta,f}(u)=\int_{\text{face at }u}f(z)\dd z. +\end{equation} +For small enough $\delta$, these weights sum to $\int_D f$ exactly. + +Let $\Phi_D$ denote the real zero-Dirichlet Gaussian free field with +covariance +\begin{equation}\label{eq:gff-covariance} + \E[\Phi_D(f)\Phi_D(g)] + =\iint_{D\times D} f(z)G_D(z,w)g(w)\dd z\dd w, + \qquad G_D=(-\Delta_D)^{-1}. +\end{equation} +The Laplacian is the Euclidean Laplacian. Thus the singular part of +$G_D(z,w)$ is $(2\pi)^{-1}\log(1/|z-w|)$. + +\begin{theorem}\label{thm:main} +For every fixed $x\in[1/\sqrt2,1]$ there exists +$\sigma(x)\in(0,\infty)$, independent of $D$ and of the inside approximation +in Definition~\ref{def:approximation}, such that +\[ + \frac{h_\delta}{\sigma(x)}\ \Longrightarrow\ \Phi_D + \qquad\text{in }\mathcal D'(D). +\] +In particular, the fields are tight as random distributions and, for every +$k\ge1$ and $f_1,\ldots,f_k\in C_c^\infty(D)$, the vector +$(h_\delta(f_i)/\sigma(x))_{i=1}^k$ converges to +$(\Phi_D(f_i))_{i=1}^k$. All mixed moments of these vectors converge. +\end{theorem} + +There is no logarithmic rescaling of the amplitude. The logarithmic growth +of point variances \cite[Section~1.2.4]{GL2025} is compatible with finite fluctuations after smooth +spatial averaging. The theorem is for each fixed $x$; it neither specifies +a formula for $\sigma(x)$ nor asserts that this constant is independent of +$x$. + +The loop description is exact. At each interior vertex of $\hexlat$, the +three incident face heights have range at most one. Consequently either +zero or two incident edges separate unequal heights. The occupied edges +therefore form mutually vertex-disjoint loops away from the boundary +cycle. Conversely, such a loop family, together with an independent +choice of one of its two orientations for each loop, determines an +admissible height by summing its signed nesting increments from the zero +exterior. Thus its un-oriented weight is +\begin{equation}\label{eq:loop-weight} + 2^{\#\text{loops}}x^{\#\text{occupied edges}}. +\end{equation} +Theorem~\ref{thm:main} concerns the field law; no convergence claim for the +individual loops or their ensemble is needed. + +\subsection{Context and significance} + +Schramm's problem collection asks for Gaussian free field behavior of the +uniform odd-integer Lipschitz height on the triangular lattice with two +boundary arcs, and separately asks about its interface +\cite[Problem~2.2]{Schramm2007}. That formulation has a different boundary +condition and height convention from \eqref{eq:model}. It motivates the +field question studied here. The real-valued model in his Problem~2.3 is +another distinct model. + +The loop description belongs to the classical solid-on-solid viewpoint: +Nienhuis relates honeycomb loop weights to integer heights on the +triangular lattice \cite[p.~1062]{Nienhuis1982}. +The predicted critical curve discussed in +\cite[Section~1.4.1]{GL2025} gives $x_c(2)=1/\sqrt2$. +Throughout this paper, the phrase \emph{predicted critical endpoint} +refers to that prediction; a sharp description of the complete phase +diagram is not part of the theorem. + +At $x=1/\sqrt2$, macroscopic loops and the resulting logarithmic height +variances were established by Duminil-Copin, Glazman, Peled and Spinka +\cite[Theorem~1 and Section~1.2]{DGPS2021}. +Glazman and Manolescu established logarithmic height variances for the uniform +integer Lipschitz model and developed its two-spin representation and +associated correlation and crossing estimates \cite{GM2021}. +Glazman and Lammers proved delocalization and logarithmic variance +estimates in a broader loop-parameter regime, and related these estimates +to the predicted Gaussian free field limit +\cite[Section~1.2.4]{GL2025}. More recently, Glazman, Harel and Zelesko +gave another proof of delocalization: for $n=2$ and every +$x\in[1/\sqrt2,1]$, each translation-invariant loop Gibbs measure +has infinitely many loops surrounding every face +\cite[Theorem~2]{GHZ2025}. These are roughness results, distinct from +the field limit proved here. + +The proof develops the reflection and moment method of +the companion article \cite[Sections~5, 7, 9, and 10]{UniformIntegerGFF} +for the weighted family \eqref{eq:model}. That article treats uniform +odd integer heights with two boundary arcs. Table~\ref{tab:integer-models} +records the different inputs and conclusions. +The two-spin representation of Glazman--Manolescu and the weighted +percolation augmentation of Glazman--Lammers provide the starting point +for the conditional cuts \cite{GM2021,GL2025}. The extension requires +order inequalities after restricted observations and estimates for +moments conditioned on rare weighted pinning events. We prove these +statements below and give the ensuing spectral, boundary, and moment +arguments in full. + +\begin{table}[!htbp] +\centering +\small +\renewcommand{\arraystretch}{1.22} +\begin{tabular}{p{0.18\textwidth}p{0.35\textwidth}p{0.35\textwidth}} +\hline + & Uniform two-arc companion & Present weighted model \\ +\hline +Height & Odd integers, adjacent differences $0$ or $2$ & +Integers, adjacent differences at most $1$ \\ +Law & Uniform; $H=(h-1)/2$ gives unit-weight increments & +Weight $x$ for each unequal adjacent pair \\ +Boundary & Two marked arcs with values $+1$ and $-1$ & +Zero on the boundary layer of an inside approximation \\ +Cuts & Uniform spin cuts and loop estimates & +The $x$-dependent open-cell table and complete first-color/status histories \\ +Normalization & An absolutely convergent finite-volume series & +An implicit positive constant $\sigma(x)$ for each fixed $x$ \\ +Limit & Harmonic boundary profile plus a Dirichlet GFF & +A zero-Dirichlet GFF \\ +\hline +\end{tabular} +\caption{The two integer-height articles retain separate model-specific +proofs. The common reflection, pin-motion, and moment strategy does not +identify their normalization constants or extend the weighted theorem +to two-arc boundary data.} +\label{tab:integer-models} +\end{table} +\FloatBarrier + +Reflection positivity provides a classical route from spatial symmetries +to positive transfer operators; see Fr\"ohlich--Israel--Lieb--Simon +\cite{FILS1978} and the spectral discussion of Usui +\cite[Sections~3--4]{Usui2012}. Here the original edge interaction +factorizes across a row of sites. We prove the associated positive +normal transfer, including its phase-augmented form, directly. +Appendix~\ref{sec:scalar-spectra} constructs the scalar measures needed +for its Cauchy representation and for analytic translation. + +The six-vertex GFF theorem of Duminil-Copin, Kozlowski, Lammers, and +Manolescu provides substantial methodological precedents through transfer +spectra, analytic translation, and harmonic multipoint functions +\cite[Section~4.5; Lemma~7.4; Section~7.2]{DCKLM2026}. Their result concerns a +full-plane zero-slope state on the square lattice for +$a=b=1$ and $c\in[\sqrt3,2]$. Its covariance normalization uses +surface tension and Bethe ansatz. Our plane coefficient is fixed by a +three-mirror angular identity and a signed cutoff limit; the passage to +the actual bounded-domain boundary additionally uses weighted rare-pin +comparisons and boundary attachment. The final collision-to-moment +argument also has a precedent in Kenyon's identification of dimer-height +correlations \cite[Lemma~3.1 and Proposition~3.2]{Kenyon2001}. In the present model the +collision coefficient comes from conditional local matching and +logarithmic harmonic expansions. + +A related six-vertex result \cite[Theorem~1.1]{BalancedSixVertexGFF2026} +establishes the GFF limit for $a=b=1$ and every fixed $c\in(0,2]$, in the +zero-slope plane law defined by its prescribed iterated limit of balanced tori. + +The conclusion strengthens logarithmic variance estimates to a limit +law for the entire distribution-valued field. Identifying a covariance +is only one part of this conclusion: the proof also establishes Gaussian +higher moments, the zero boundary condition, and tightness. The parameter +interval includes both the uniform height model $x=1$ and its predicted +critical endpoint $x=1/\sqrt2$. + +\subsection{Structure of the proof} + +\paragraph{Exact weighted cuts and conditional order.} +Section~\ref{sec:discrete} encodes a height modulo four by two spins and +augments each upward triangular cell with a status. An open circuit fixes +the first spin while leaving the second spin free. The resulting cell +factorization gives an exact conditional cut. The order statement is +proved for histories which record every first-spin site of an observed +cell. This restriction is essential: conditioning on a status alone need +not preserve positive association. Stopped explorations then give local +mixing and multiplicative comparisons for separated pins. + +\paragraph{Uniform moments and the plane coefficient.} +Section~\ref{sec:moments} proves moment bounds for smeared heights, +including irregular domains exposed by explorations. A discrete midpoint +inequality of Klartag--Lehec \cite[Theorem~1.4]{KlartagLehec2019}, in the +nonnegative-function form of \cite[Theorem~3]{GRST2019}, amplifies central +probability bounds to all moments. We derive the finite-support zero +case directly from \cite[Theorem~8]{GRST2019}, then verify the +multidimensional application and rounding conditions explicitly. +In Section~\ref{sec:plane}, +site reflection positivity gives a positive normal transfer operator. +Its covariance is a mixture of Cauchy kernels in normal frequency. +An angular identity using all three mirror directions forces every +scaling limit of the spectral measure to be $c\,\dd p/|p|^2$. +A signed cutoff identity proves uniqueness of $c$, and a two-disk variance +bound proves $c>0$. With our Fourier convention, +\begin{equation}\label{eq:normalization} + v=(2\pi)^2c,\qquad \sigma(x)=\sqrt v. +\end{equation} + +\paragraph{Pins, reflection, and the true boundary.} +Section~\ref{sec:pins} compares the field with upper and lower pinning +brackets. Uniform normalized moment bounds allow analytic movement of +separated pins in three directions. Averaging their phases and then +closing the gaps transfers the reflection-null Laplace insertion from +the plane to these brackets. Section~\ref{sec:boundary} proves the +boundary attachment estimate: a synthetic boundary law gives a favorable +level path, and a deterministic attachment argument connects it to the +required boundary segment. Iterating in tubes yields boundary arches, +makes the bracket means vanish, and controls boundary reference averages. + +\paragraph{Harmonic moments and the full field law.} +Section~\ref{sec:limit} first establishes distributional tightness and +uniform integrability. The ordered coupling and the vanishing bracket +means then identify the bracket limits with the true field and transfer +the insertion identity to it. The insertion and boundary references +make every limiting moment distribution separately harmonic away from +collisions. Logarithmic moment bounds exclude distributions supported +on the diagonals. Local comparison with the plane fixes the coefficient +of every collision singularity. Subtracting the corresponding Green +functions gives Wick's recursion, which determines the Gaussian law. +This completes the proof of Theorem~\ref{thm:main}. + +\subsection{Conventions} + +The parameter $x$ is fixed. Constants may depend on $x$ and on a stated +fixed macroscopic arrangement; this dependence is not asserted to be +uniform over the parameter interval. The symbols $C,c,\alpha$ denote +positive constants whose value may change between occurrences. A test +at radius $r$ has support in a ball of that radius and magnitude +$O(r^{-2})$. A zero-total test has integral zero. On the full plane we +use +\[ + \widehat f(p)=\int_{\R^2}e^{-ip\cdot z}f(z)\dd z, + \qquad + \langle f,(-\Delta)^{-1}g\rangle + =\frac1{(2\pi)^2}\int_{\R^2} + \frac{\overline{\widehat f(p)}\widehat g(p)}{|p|^2}\dd p +\] +for real smooth compactly supported zero-total tests. The symbol $H$ +denotes a generic integer lift in the discrete representations; it is +distinct from the hexagonal lattice $\hexlat$. + +Every argument involving collars, windows, disks, or tubes first fixes +their positive macroscopic widths and separations, then sends +$\delta\downarrow0$. Limits that close gaps, shrink windows, or approach +the boundary are taken afterward. A bound for fixed geometry is not +used uniformly for a degenerating geometry. Explorations are stopped +before inspecting the interior region whose conditional Gibbs law is +subsequently used. diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/02-discrete.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/02-discrete.tex new file mode 100644 index 0000000000000000000000000000000000000000..315ef9c4d10d298339034abeec03bf73e361bd8f --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/02-discrete.tex @@ -0,0 +1,991 @@ +\section{Exact cuts and conditional comparison}\label{sec:discrete} + +Throughout this section $x\in[1/\sqrt2,1]$ is fixed. We first work in lattice +units. A finite ambient graph $G=(V,E)$ is a connected induced subgraph of +$\T$ whose bounded faces are elementary triangles and whose union is a +topological disk. We can always take a +large regular hexagon. Holes in a height domain will be represented by fixed +sites in such an ambient graph, rather than by deleting triangles. This +distinction is needed in the wall factorization below. + +The cell representation below will provide three conclusions: an exact conditional +factorization across open circuits, order under observations that record a +cell together with all its first-spin sites, and a multiplicative comparison +for separated pin events. The last comparison remains useful when each pin +event has probability tending to zero. We first construct the cell law +whose open circuits make all three statements possible. + +\subsection{Spins, cells, and exact cuts} + +Associate to an integer $H$ the two spins $(B,W)$ given by +\begin{equation}\label{discrete:gray} +\begin{array}{c|cccc} +H\pmod4&0&1&2&3\\ \hline +(B,W)&(+,+)&(+,-)&(-,-)&(-,+). +\end{array} +\end{equation} +Call a spin pair coherent if on each edge at least one of its two spins is +constant. Its free weight on $G$ is +\begin{equation}\label{discrete:pair-weight} + \prod_{uv\in E}x^{\ind\{(B_u,W_u)\ne(B_v,W_v)\}}\, + \ind\{(B,W)\text{ is coherent}\}. +\end{equation} +All ambient finite-volume laws in this section use this edge convention. + +\begin{lemma}[Integer lift]\label{lem:spin-lift} +Every coherent pair on $G$ has an integer Lipschitz lift, unique up to addition +of a multiple of four once the correspondence \eqref{discrete:gray} is fixed. +For the oriented edge $uv$ its increment is +\begin{equation}\label{discrete:increment} + H_v-H_u=\frac{W_uB_v-B_uW_v}{2}. +\end{equation} +The free spin law induces the weighted height-increment law with one height +anchored. Fixing a constant pair on a connected skeleton, and fixing the lift +there, induces the usual weighted height Gibbs law in each bounded face of +the skeleton. +\end{lemma} +\begin{proof} +The right side of \eqref{discrete:increment} is $0$, $1$, or $-1$, and has +the required residue in \eqref{discrete:gray}. A triangle cannot have both +spins nonconstant: each nonconstant binary spin changes on two triangle +edges, and these two pairs of edges must intersect. If $B$ is constant on a +triangle, \eqref{discrete:increment} is $-B\,dW/2$ there; if $W$ is constant, +it is $W\,dB/2$. Its circulation therefore vanishes. Every cycle of the +triangulated disk is a sum of its triangle boundaries, so the increments +integrate to $H$. The four choices of the anchor residue give four equally +weighted spin representations of each anchored increment configuration: +cyclic rotation of the states in \eqref{discrete:gray} preserves all +increments and the weight. Finally each disagreeing pair contributes exactly +one factor $x$. Fixing the connected trace fixes the lift on the whole +skeleton, and the remaining edge factors are precisely those of the height +Gibbs specification. +\end{proof} + +Let $Y$ be the centers of the upward-pointing elementary triangles, viewed +as one partite class of the dual honeycomb lattice. Each primal edge belongs +to exactly one such triangle. At the ambient boundary a cell can be clipped +to a single edge; cells containing at most one site have no interaction. +For an interacting cell $y$ write $V_y$ for its two or three sites and put +\[ + q_y=\begin{cases}x^2,&|V_y|=3,\\ x,&|V_y|=2.\end{cases} +\] +Introduce an open/closed variable by the following joint weights: +\begin{equation}\label{discrete:cell-table} +\begin{array}{c|c|c} + \text{status}&\text{allowed spins}&\text{weight}\\ \hline + \text{open}&B\text{ constant on }V_y,\ W\text{ arbitrary}&q_y\\ + \text{closed}&B,W\text{ both constant on }V_y&1-q_y\\ + \text{closed}&B\text{ nonconstant},\ W\text{ constant on }V_y&q_y. +\end{array} +\end{equation} +An open cell is denoted $+$ or $-$ according to its constant $B$ value, +and a closed cell is denoted $0$; thus $\tau_y\in\{-,0,+\}$. +An interior nonconstant triangle has two changing edges. Summing +\eqref{discrete:cell-table} consequently gives +\eqref{discrete:pair-weight}, including the clipped edge convention. + +We permit arbitrary deterministic $B$ pins and deterministic equalities +$W_u=W_v$ on a set $E_0\subset E$. These equalities are not prescribed +component labels. Given $(B,\tau)$, form the graph containing the edges of +all closed cells and all edges of $E_0$, with isolated sites included. +The conditional $W$ law labels its connected components by independent +fair signs. In particular, if $m$ connected subgraphs have already been +required to have constant $W$, the conditional probability that all their +labels are plus lies in $[2^{-m},1]$. This includes singleton subgraphs and +allows several prescribed subgraphs to belong to the same component. + +A honeycomb edge is \emph{authorized with sign $s$} if its endpoint in $Y$ +has $\tau_y=s$. A good path or circuit of sign $s$ uses authorized edges. +We only use these paths away from clipped ambient cells. The faces adjacent +to a good path have $B=s$ and their connected face chain therefore has a +height trace in one pair of consecutive integers. A nearest-neighbor path +of good $Y$ vertices can be converted into a honeycomb walk by joining +successive vertices through their common honeycomb neighbor. The +displacement is bounded in lattice units. A closed walk with nonzero winding +around a target contains a simple surrounding circuit. All geometric +constructions below have positive clearance, so this conversion preserves +their requirements for sufficiently fine mesh. + +\begin{samepage} +\begin{lemma}[Open-cell cut]\label{lem:cell-cut} +Let $\gamma$ be a simple honeycomb circuit strictly inside the ambient graph. +Prescribe $\tau_y=s$ at every $y\in Y\cap\gamma$. Suppose no edge of $E_0$ +crosses $\gamma$. Conditional on these prescriptions and any deterministic +constraints on the two respective sides, the two sides are independent +after their prescribed first-spin layers are identified. On the inside, +all cells centered strictly inside retain their original weights; crossing +cells contribute constants and impose no condition on $W$. This inside law +depends only on $\gamma$, $s$, and the constraints inside. Given the complete +height trace of the inside boundary layer, its free sites have the ordinary +weighted height Gibbs law, with any additional inside constraints retained. +\end{lemma} +\end{samepage} +\begin{proof} +Every interacting cell meeting both sides has its honeycomb center on +$\gamma$. Its open prescription fixes every incident first spin to $s$, +and its factor in \eqref{discrete:cell-table} is the constant $q_y$ for +every choice of its second spins. All remaining factors involve sites on +one side only. Equality edges do not cross by assumption. The product +weight and its partition sum thus factor. In particular, complementary +components cannot cross the circuit. After specifying the complete inner +height layer, the spin lift and the edge weights in +Lemma~\ref{lem:spin-lift} give the claimed height specification. No +first-spin agreement event without the open-cell prescriptions has been +used in this factorization. +\end{proof} + +\begin{figure}[tbp] + \centering + \input{figures/cell-cut.tex} + \caption{An exact open-cell cut. In (a), prescribing $B=+$ and + $\tau_y=+$ gives the constant cell weight $q=x^2$ for every second-spin + assignment. In (b), filled circuit vertices are open-plus $Y$ cells; + plus signs mark their prescribed first-spin sites. The tested exterior + is shaded. No equality edge crosses $\gamma$, and the unobserved second + spins have no component joining its two sides. Strictly interior cells + retain their original interactions.} + \label{discrete:fig-cut} +\end{figure} + +\begin{samepage} +Here is the crossing estimate used throughout the discrete argument. +Appendix~\ref{sec:annulus} gives its annulus proof. +The boundary convention in its statement is part of the theorem. + +\begin{theorem}[Annulus circuit estimate]\label{thm:circuit-input} +For $r\ge0$, let $\Lambda_r$ be the ball of radius $r$ in the triangular +graph metric, with its bounding honeycomb contour; thus +$\Lambda_r=\Lambda_{\lfloor r\rfloor}$. For $a>1$ and an integer +$n\in\N$, consider on +$\Lambda_{an}$ the cell spin law whose +interior cells have weight $(x^2)^{\ind\{B\text{ or }W\text{ nonconstant}\}}$ +and whose boundary $Y$ cells are excluded. Fix $B=-$ on the boundary face +layer and leave $W$ free. There is $c=c(x,a)>0$ such +that, for $n\ge 3/(a-1)$, the probability of an occupied open-plus cell +circuit surrounding $\Lambda_n$ and contained in $\Lambda_{an}$ is at +least $c$. The same statement holds with the signs or the two spin colors +interchanged. +\end{theorem} +\end{samepage} + +The conclusion is equation (55) in Appendix A of the third arXiv version +of \cite{GL2025}, with Definitions 3.2 and 3.5. Its augmentation includes a +cell whenever $W$ is nonconstant, excludes it whenever $B$ is nonconstant, +and otherwise includes it with probability $x^2$. It is therefore exactly +\eqref{discrete:cell-table}. The source uses +$Y(\Omega)=(Y\cap V(\Omega))\setminus V(\partial\Omega)$; simply pinning +$B=-$ in our edge-weight law would still charge certain boundary $W$ +changes. Lemma~\ref{lem:cell-cut} instead identifies the source law with +the law inside a prescribed regular open-minus circuit: the excluded +boundary factors become constants. This is also the conditional law +described by Lemma 3.8 of \cite{GL2025}. We use the theorem only through +this exact identification, with fixed slack for lattice rounding. In +particular its validity includes $x=1/\sqrt2$. + +\subsection{Restricted histories and the two-law inequality} + +A \emph{history} fixes some first-spin sites and some cell statuses, with +the rule that it fixes \emph{all} first-spin sites of every observed cell. +The equality set $E_0$ remains deterministic. No second-spin component +labels are part of a history. Order first spins by $-<+$ and statuses by +$-<0<+$. Ordered histories have the same observation sets and ordered +values. They may also have additional deterministic plus $B$ pins only in +the upper law, or additional deterministic minus $B$ pins only in the +lower law, compatible with the common pins. + +\begin{proposition}[Association and conditional order]\label{prop:history-order} +For every feasible history, the unobserved $(B,\tau)$ variables are +positively associated. Two laws with ordered histories and common $E_0$ +are stochastically ordered, including the unequal extreme pins just +described. Extra prescribed open-plus cells only in the upper law, or +open-minus cells only in the lower law, can be incorporated by observing +those cells and all their first-spin sites also in the other law. These +claims hold for clipped cells and at $x=1$. +\end{proposition} + +We first prove two finite-weight inequalities used in the proof of this +proposition, then apply them to the cell law. + +We use the finite association inequality of Fortuin--Kasteleyn--Ginibre +\cite{FKG1971}, including weights that vanish. Its precise form follows +from the rounded-midpoint inequality stated and tensorized in +Theorem~\ref{thm:midpoint}: for nonnegative finitely supported arrays, +the premise +$f(b)g(c)\le u(\lfloor(b+c)/2\rfloor)v(\lceil(b+c)/2\rceil)$ +implies $(\sum f)(\sum g)\le(\sum u)(\sum v)$. +Indeed, on a Boolean cube the rounded +midpoints of $b,c$ are their coordinatewise minimum $b\wedge c$ and +maximum $b\vee c$. If a nonnegative weight $w$ satisfies +$w(b)w(c)\le w(b\wedge c)w(b\vee c)$ and $F,G$ are nonnegative +increasing functions, then +\[ + w(b)F(b)w(c)G(c) + \le w(b\wedge c)w(b\vee c)F(b\vee c)G(b\vee c). +\] +Apply the midpoint inequality to $wF,wG,w,wFG$, extended by zero +outside the cube. Its conclusion is +$(\sum wF)(\sum wG)\le(\sum w)(\sum wFG)$, which is association +after normalization. Encode an element of a finite chain by a prefix +of ones followed by zeros. The encoded product of chains is closed +under minimum and maximum, so extension by zero proves the same result +there. Adding constants to bounded increasing functions covers signed +functions. This deduction explains every finite association use below; +the midpoint tensorization itself uses no association statement. + +The wall decomposition below expresses the first-spin weight using two +partition sums for the complementary spin. We record the two properties +of those sums needed to compare first-spin configurations. + +\begin{lemma}[The complementary-spin partition sum] +\label{discrete:ising-partition} +For $a\in[0,1]^E$ define +\begin{equation}\label{discrete:ising-Z} + Z(a)=\sum_{\sigma\in\{-,+\}^{V}} + \prod_{e=uv\in E}a_e^{\ind\{\sigma_u\ne\sigma_v\}}, + \qquad 0^0=1. +\end{equation} +Then $Z$ is increasing in every coordinate and is log-supermodular: +\begin{equation}\label{discrete:Z-lattice} + Z(a\wedge b)Z(a\vee b)\ge Z(a)Z(b). +\end{equation} +\end{lemma} +\begin{proof} +Monotonicity follows term by term. For positive coordinates the second assertion follows by differentiating in $\log a_e$. +For distinct edges $e=uv$ and $f=st$, +\[ + \frac{\partial^2\log Z}{\partial\log a_e\,\partial\log a_f} + =\Cov(\ind\{\sigma_u\ne\sigma_v\}, + \ind\{\sigma_s\ne\sigma_t\}) + =\tfrac14\Cov(\sigma_u\sigma_v,\sigma_s\sigma_t)\ge0. +\] +The last inequality is a special case of the second Griffiths inequality +\cite{GKS1968}; we recall its random-cluster proof \cite[p.~102]{FKG1971}. Put +$J_e=-\frac12\log a_e\ge0$ and $p_e=1-e^{-2J_e}=1-a_e$. Expanding +\[ + e^{J_e\sigma_u\sigma_v} + =e^{J_e}\bigl((1-p_e)+p_e\ind\{\sigma_u=\sigma_v\}\bigr) +\] +over edges gives a joint spin--bond law whose bond marginal on +$\omega\subset E$ has weight +\[ + 2^{k(\omega)}\prod_{e\in\omega}p_e + \prod_{e\notin\omega}(1-p_e), +\] +where $k(\omega)$ counts all connected components, including isolated +vertices. This weight satisfies the lattice condition. Indeed, if +$\mathcal C(A)$ is the binary cycle space of the edge set $A$, then +$\mathcal C(A)\cap\mathcal C(B)=\mathcal C(A\cap B)$ and +$\mathcal C(A)+\mathcal C(B)\subset\mathcal C(A\cup B)$. +Taking dimensions and using +$k(A)=|V|-|A|+\dim\mathcal C(A)$ proves supermodularity of $k$; +the remaining edge factors are modular. The FKG theorem +\cite{FKG1971} therefore associates increasing bond events. +Conditional on $\omega$, the spins are independent fair signs on its +components. Consequently +$\E(\sigma_u\sigma_v)=\Prob(u\leftrightarrow v)$, while the +conditional expectation of $\sigma_u\sigma_v\sigma_s\sigma_t$ is +one precisely when each component contains an even number of the four +listed vertices, counted with multiplicity, and is zero otherwise. In +particular +\[ + \E(\sigma_u\sigma_v\sigma_s\sigma_t) + \ge\Prob(u\leftrightarrow v,\ s\leftrightarrow t) + \ge\Prob(u\leftrightarrow v)\Prob(s\leftrightarrow t). +\] +This proves the required covariance inequality, also when the edges share +vertices. The cases $p_e\in\{0,1\}$ follow by continuity. Integrating +the nonnegative mixed derivatives over coordinate rectangles gives +\eqref{discrete:Z-lattice}; continuity of the polynomial $Z$ includes its +zero-coordinate cases. + +\end{proof} + + +\begin{proof}[Proof of Proposition~\ref{prop:history-order}] +We first sum the second spins by splitting their walls according to the +first-spin sign. Lemma~\ref{discrete:ising-partition} will give the +two-law inequality for this marginal. We then restore the statuses. + +Fix a first-spin configuration $b$. A binary edge set is a second-spin +wall precisely when it has even intersection with every triangle boundary. +Indeed this condition makes its mod-two integral independent of the path +from a fixed anchor, since triangle boundaries generate the cycle space. +There are exactly two spin labelings for each such wall. Every allowed wall +edge has homogeneous $b$ endpoints. Split these edges according to their +common sign. A homogeneous triangle has only one sign class. A mixed +triangle has just one homogeneous edge, which its even rule forces to be +absent. Thus none of the triangle equations couples the two sign classes. +Each sign restriction of an allowed wall is itself a wall, and arbitrary +walls supported in the two allowed sign sets can be combined. This proves +factorization without an additional global compatibility condition. + +For an unobserved cell let +$r_y(b)=1$ if $b$ is homogeneous there and $r_y(b)=q_y$ otherwise. +Define $a_h^+(b)$ as follows: it equals $x$ on edges of unobserved +homogeneous-plus cells, equals $1$ on observed open-plus cells, and is zero +on all other edges. Set it to zero also on $E_0$. Define $a_h^-(b)$ with +minus in place of plus. Summing the unobserved statuses and then the second +spins gives the first-spin weight +\begin{equation}\label{discrete:wall-factor} + w_h(b)=\frac{c_h}{2}\, + \prod_{y\text{ unobserved}}r_y(b)\, + Z(a_h^+(b))Z(a_h^-(b))\, + \ind\{b\text{ satisfies its fixed sites}\}. +\end{equation} +Here $c_h>0$ is the product of the observed-cell factors; these are +constants because their first spins are fixed. The factor $1/2$ is exact: +each $Z$ counts two global signs whereas the actual second-spin sum counts +only two, not four. In particular $E_0$ deletes wall coordinates and does +not impose a relation between the two global signs. Formula +\eqref{discrete:wall-factor} would in general fail on a graph with a hole +if the missing cycle constraints were omitted, explaining our ambient +triangulation convention. + +Let $h_-\le h_+$ be ordered histories. For any $b$ in the lower support and +$c$ in the upper support, $b\wedge c$ belongs to the lower support and +$b\vee c$ to the upper support, also when pins occur in just one law. +On an unobserved cell, homogeneous-plus eligibility at the meet is the +intersection of the input eligibilities; at the join it contains their +union. Therefore, coordinatewise, +\begin{align*} + a_{h_-}^+(b\wedge c)&\ge a_{h_-}^+(b)\wedge a_{h_+}^+(c),& + a_{h_+}^+(b\vee c)&\ge a_{h_-}^+(b)\vee a_{h_+}^+(c),\\ + a_{h_-}^-(b\wedge c)&\ge a_{h_-}^-(b)\vee a_{h_+}^-(c),& + a_{h_+}^-(b\vee c)&\ge a_{h_-}^-(b)\wedge a_{h_+}^-(c). +\end{align*} +On observed cells the plus vectors are already ordered and the minus +vectors reverse-ordered; hence the same inequalities hold there. Deleting +the common coordinates $E_0$ preserves all four inequalities. +Furthermore +\[ + r_y(b\wedge c)r_y(b\vee c)\ge r_y(b)r_y(c). +\] +To check this last assertion, comparable restrictions are unchanged by +sorting. For incomparable restrictions both inputs are mixed, whereas +each output has weight at least $q_y$. A homogeneous input is extremal +and cannot be lost. Applying monotonicity and +\eqref{discrete:Z-lattice} to each sign in +\eqref{discrete:wall-factor} now proves +\begin{equation}\label{discrete:two-law} + w_{h_-}(b\wedge c)w_{h_+}(b\vee c) + \ge w_{h_-}(b)w_{h_+}(c). +\end{equation} +Observed-cell constants cancel. This also proves the lattice condition +within either first-spin law. + +For clarity, zero weights and unequal supports cause no invocation of an +unstated strictly positive version of Holley's criterion +\cite{Holley1974}. Extend the weights by zero to the whole first-spin cube +and put $\widetilde w(b,0)=w_{h_-}(b)$, +$\widetilde w(b,1)=w_{h_+}(b)$. The two within-layer inequalities and +\eqref{discrete:two-law} say that $\widetilde w$ satisfies the lattice +condition on the cube times $\{0,1\}$. The nonnegative-weight FKG theorem +\cite{FKG1971} applies. For increasing $f$, its positive covariance with +the last coordinate says exactly +$\E_{h_-}f(B)\le\E_{h_+}f(B)$. The same theorem gives association of +each first-spin law. This proves the needed extension to sorted supports. + +It remains to restore statuses. Given $b$, each unobserved homogeneous +cell is eligible to open with its sign; mixed cells are necessarily closed. +Let $S_+$ and $S_-$ be the two open subsets of eligible cells. Wall +factorization now gives independent weights for these subsets. Apart from +constants their respective weights are +\begin{equation}\label{discrete:subset-weight} + \prod_{y\in S_s}q_y + \prod_{y\in I_s\setminus S_s}(1-q_y)\, + Z\bigl(\ind\{e\text{ lies in an open cell of sign }s\} + \ind\{e\notin E_0\}\bigr), +\end{equation} +where $I_s$ is the eligible set and observed open cells of sign $s$ are +included as fixed allowed cells in the last factor. Different cells have +disjoint edge sets. The Bernoulli factor is modular; the $Z$ factor is +log-supermodular in the cell set by \eqref{discrete:Z-lattice}. Thus each +subset law is associated. The same two-law calculation shows stochastic +increase under enlarging $I_s$ or the fixed allowed cells: on a common +subset cube the sorted allowed-edge sets contain the coordinatewise +intersection and union, and the Bernoulli factors cancel. Ineligible cells +are held closed. The preceding nonnegative-weight argument again handles +these deterministic restrictions. + +Increasing $b$ enlarges plus eligibility and shrinks minus eligibility. +Hence $S_+$ increases and $S_-$ decreases in inclusion order, exactly the +status order $-<0<+$. Association of the minus block is also association +in reverse inclusion order, since the covariance of decreasing functions +equals that of their negatives. The two blocks are independent. If $F,G$ +are increasing functions of $(B,\tau)$, conditional association gives +$\E(FG\mid B)\ge\E(F\mid B)\E(G\mid B)$; the two conditional +expectations are increasing in $B$. Association of $B$ completes the +joint association claim. An ordered coupling of the first spins followed +by ordered conditional status kernels gives the two-law assertion. + +If $q_y=1$, a homogeneous unobserved cell is open deterministically, and +an observed homogeneous closed cell is infeasible. All displayed +inequalities remain valid on feasible supports, either directly or by +continuity as $q_y\uparrow1$; no division by $1-q_y$ is used. Finally an +extra open-plus cell in the upper law has the maximum possible status and +first-spin values. Querying that same block in the lower law always gives +ordered values and retains its correct distribution. This is observation +in the other law, not imposition of the upper event on it. The open-minus +case is symmetric. +\end{proof} + +\begin{remark}\label{discrete:not-raw-FKG} +Proposition~\ref{prop:history-order} asserts association of the joint law, +not the lattice condition for its unsummed density. Nor does it allow +observation of a closed status without its first spins. For example, on a +single triangle conditioned only to be closed, the first-spin weight is +$1-q$ on the two homogeneous configurations and $q$ on the six mixed +ones. Its pair covariance is $(1-2q)/(1+2q)<0$ when $q>1/2$. +\end{remark} + +\subsection{Online exploration and buffered circuits} + +We next specify the probabilistic meaning of coupled exploration. This +will matter again when the remaining interior is compared with a plane +sample independent of exterior observables. + +\begin{lemma}[Conditional kernels at a joint record]\label{discrete:online} +Consider two finite-volume laws ordered as in +Proposition~\ref{prop:history-order}. There is an online exploration +coupling with the following invariant: conditional on every full joint +query record, the eventual completion in either coordinate has that +coordinate's original Gibbs conditional law given its own observed values +and deterministic constraints. The next cell, together with all its first +spins, may be chosen as any deterministic function of the joint record. +If the retained conditional problems become identical, their completions +can be sampled identically. +\end{lemma} +\begin{proof} +At a joint record $R$ let $\mu_i^R$ be the two specified own-history +conditional laws. Select a common query block $Q=Q(R)$ and couple its +marginals by an ordered kernel $\kappa_R$, available from +Proposition~\ref{prop:history-order}. For each possible pair of answers +$(a_1,a_2)$ recursively complete with the respective conditional laws +$\mu_i^R(\cdot\mid Q=a_i)$. This is a finite recursion: every nonterminal +query adds a new cell or site. At a terminal node with the same remaining +specification, use one draw from that common law. At any other terminal +node use any coupling of its two remaining laws. + +Backward induction proves the marginal invariant. For a completed +observable $f$ in coordinate $1$, the expectation from the node $R$ is +\[ + \sum_{a_1,a_2}\kappa_R(a_1,a_2) + \mu_1^R(f\mid Q=a_1) + =\sum_{a_1}\mu_1^R(Q=a_1)\mu_1^R(f\mid Q=a_1) + =\mu_1^R(f). +\] +The second coordinate is identical. Applying the same induction starting +at any reached node gives the assertion conditional on the whole joint +record, not merely on an individual history. Independent randomness used +to select a query can be put in the record and conditioned on first. +No conditioning of a previously sampled full-field coupling is involved. +\end{proof} + +The following geometric exploration implements the lemma. In a prescribed +annular search area authorize the honeycomb edges incident to favorable +open $Y$ cells; edges outside the area may be declared unavailable. Start +from the exterior face set for an inward search, or from a connected inner +face layer for an outward search. Invade across unauthorized honeycomb +edges, querying the responsible cell and its full first-spin block in both +laws when needed. On reaching a prescribed authorized circuit with +clearance the invasion cannot cross it. The boundary of the invaded union +of honeycomb faces consists of authorized contours. Select the component +separating the start from the protected target, deleting inessential +excursions to obtain a simple circuit. In an inward search this is the +boundary around the component containing the connected target; in an +outward search it is the outer boundary of the invaded set. + +There is no hidden revelation on the retained side. A queried cell touches +the invaded face set. A honeycomb vertex strictly on one side of an edge +contour touches only faces on that side. A queried cell meeting both sides +therefore lies on the contour and is favorable open, so its retained +first-spin sites have the prescribed contour sign. If a queried cell is +not favorable, invasion crosses all its incident unauthorized edges; it +cannot leave an unprescribed first-spin neighbor behind that cell. Thus +the only retained sites queried are prescribed cut-layer first spins. +Second-spin labels remain unqueried. In the absence of crossing $E_0$ +edges, Lemma~\ref{lem:cell-cut} identifies the stopped retained law. +Together with Lemma~\ref{discrete:online}, this proves the exact stopped-cut +and common-sampling assertions for either direction of exploration. + +\begin{lemma}[Buffered circuits and paths]\label{lem:buffer-circuits} +Fix a finite collection of annuli and tubes in a bounded planar region, +each with a positive-width buffer and with prescribed geometric clearance. +At mesh $\delta$, suppose the buffers contain no equality edge $E_0$ and +no first-spin pin adverse to a requested sign. Then each request for good +circuits, or connected good paths formed from a finite annular chain, has +probability bounded below by a positive constant independent of $\delta$ +for all sufficiently small $\delta$. The bound is uniform over feasible +histories supported away from the buffers and over lattice translations +preserving the clearances. Requests with the same sign may be combined by +association; requests of different signs in disjoint buffers may be made +successively. In an annular stack of fixed-ratio, separated slots between +lattice scales $r$ and $L$, the probability of finding no requested good +circuit is at most +\begin{equation}\label{discrete:stack} + C(r/L)^\alpha, +\end{equation} +for constants $C,\alpha>0$. + +Moreover, conditioning a free ambient law on any deterministic collection +of open-plus cells and their first-spin values increases every increasing +event in $(B,\tau)$. This applies to a favorable path event in the ambient +plane even when its path leaves the interior of a prescribed good contour. +\end{lemma} +\begin{proof} +The primitive comparison takes place in a small \emph{filled} regular +disk whose entire larger comparison cut and interior fit inside the +buffer. In that disk consider a smaller regular annulus. Delete +favorable pins in the filled disk, which +can only decrease the probability of the favorable increasing event. +Prescribing the outer cut open with the adverse sign decreases it again +by Proposition~\ref{prop:history-order}. There are no other constraints +inside this small outer cut. Lemma~\ref{lem:cell-cut} and +Theorem~\ref{thm:circuit-input} give a positive lower bound in the +resulting deterministic regular problem. The same comparison applies +after any allowed outside history. For a minus request reverse all first +spins and the status order. + +For gluing, use regular annuli of inner radius $\rho$ and outer radius +$2\rho$, with a small fixed geometric slack. Consecutive centers are +separated by a distance strictly between $\rho$ and $2\rho$ in the +triangular graph norm. Their inner balls intersect, and each inner ball +has a point outside the other's outer ball. Any two corresponding +surrounding circuits must therefore intersect: disjoint Jordan curves +with overlapping interiors would be nested, contradicting the latter +property. Intersecting good honeycomb paths of the same sign join. +Finitely many such annuli give a connected path following a prescribed +tube. A closed chain following a polygonal Jordan curve gives a closed +walk with the same winding number about its protected target, and hence +a surrounding simple circuit. Choose the annuli small enough that their +larger filled comparison disks stay in the buffer. Thus the target +annulus may enclose arbitrary pins in its hole: none lies in these small +comparison disks. Association multiplies their +fixed positive probabilities. A general fixed collar is covered by a +finite such chain. Rounding moves paths by only $O(\delta)$. + +For requests in disjoint buffers expose the previous successful +constructions only in those buffers and condition on their full allowed +histories. The next buffer still has the same uniform bound, regardless +of the previous sign. For a stack choose $k\ge c_1\log(L/r)-c_2$ +separated slots. Conditional on all previously inspected slots, failure +in the next slot has probability at most $1-c_3$. Thus the total failure +probability is at most $(1-c_3)^k$, which is +\eqref{discrete:stack}. Slots of bounded lattice size are absorbed into +$C$; no estimate at a sublattice scale is asserted. + +Finally a prescription of open-plus cells is an extreme upper constraint. +Proposition~\ref{prop:history-order} shows that it increases every +increasing ambient event. This conclusion does not require the event to +lie inside the prescribed contour. If an ambient favorable path runs +from that contour to an interior target, the segment after its last +intersection with the contour lies inside and connects its prescribed +first-spin layer to the target. This observation requires no regularity +or interior corridor for the contour itself. +\end{proof} + +\begin{proposition}[Local matching and the free plane law]\label{prop:local-mixing} +There are $C,\alpha>0$ with the following property. Suppose a finite +ambient graph contains a ball of radius $L$ together with its interaction +cells, and its law has first-spin pins and second-spin equalities, none +in that ball. Then its +pair marginal in the concentric radius-$r$ ball is within +$C(r/L)^\alpha$ in total variation of a common free plane law, for +$L\ge Cr\ge C$. The same is true with the statuses of either fixed +choice of first color. The plane law is the local limit of free ambient +laws along every exhaustion, and its unaugmented pair and increment +laws preserve translations, lattice symmetries, and height symmetries. + +Adding extreme first-spin pins in a bounded inner region can be coupled +to the original law so that the configurations agree beyond a common +circuit of the added sign. If there are $k$ separated favorable annular +slots outside all the changes and no adverse pins or equality edges in +their buffers, the failure probability is at most $Ce^{-ck}$. +All matches preserve the individual conditional marginals at every joint +record as in Lemma~\ref{discrete:online}. +\end{proposition} +\begin{proof} +Inside the pin-free radius-$L$ ball choose a deterministic regular +open-minus cut of radius comparable to $L$. Let $\mu^-$ be the original +law with this extra prescription. It is below the original law $\mu$. +Query the cut cells also in $\mu$, and use the ordered online kernels +thereafter. Search inward in separated annular slots for a good plus +circuit in the lower law. By Lemma~\ref{lem:buffer-circuits}, the failure +probability is $C(r/L)^\alpha$. A plus cell in the lower law is plus also +in the upper law, so the selected circuit is common. The exploration +geometry just proved leaves identical inner conditional problems, with +no equality edges or pins. Sample them once, including their free +second-spin component labels. The inside law of the deterministic minus +cut is independent of all the original exterior constraints. Thus every +eligible $\mu$ is within $C(r/L)^\alpha$ of this common comparison law +on the small ball. + +For two free ambient volumes containing a radius-$L$ ball this gives a +total-variation distance at most $2C(r/L)^\alpha$ on the radius-$r$ ball. +The finite-state local marginals are Cauchy along any exhaustion. Their +consistent limits define a plane law. Comparing any given finite ambient +law first with a much larger free volume and then taking its limit gives +the claimed bound, with a changed constant. Apply the same argument to +translated, reflected, rotated, or spin-rotated exhaustions to obtain the +stated invariances. The augmentation itself singles out one partite +class, so only its corresponding lattice symmetries are asserted; the +unaugmented interaction \eqref{discrete:pair-weight} has all lattice +symmetries. + +For additional plus pins search outward for a good plus circuit in the +lower law; every such circuit is common. On its exterior the deterministic +constraints agree and the stopped specifications are identical. The +upper law can therefore use the same exterior sample. For additional +minus pins reverse the order and the signs. The slot bound gives +$Ce^{-ck}$. The correctness of all marginal conditionings follows from +the finite recursion of Lemma~\ref{discrete:online}, followed only then by +volume limits. +\end{proof} + +Two consequences of this formulation will be useful. First, every feasible +finite event consisting of first-spin pins and finitely many connected +second-spin plus constraints has positive plane probability. Find an +exterior-searched good circuit around its entire support, an event of +positive probability. In the finite inside law, make the second spin +constant plus and prescribe the desired first spins; every such first-spin +configuration has positive total weight. The finite conditional +probability is positive. Second, all finite conditional identities pass +to the plane by exhaustion, since the event being conditioned on has +positive probability. In particular height interiors with fixed traces +have the Gibbs property in the plane construction. + +The next conditional form will let us match a local increment field with +a plane copy independent of distant absolute-height observations. Its +hypothesis concerns the retained law after an exact cut; arbitrary exterior +spin labels without such a cut are not a conditioning class in +Proposition~\ref{prop:local-mixing}. + +\begin{corollary}[Plane matching after a stopped cut] +\label{cor:conditional-plane-matching} +Let $\mathcal R$ be an exterior record, and let $G$ be its +successful-search event, determined by that record. Suppose that on every successful record a good +circuit surrounds $B(z,L)$ together with its interaction cells, and that +conditional on this record the retained law is the open-cut law of +Lemma~\ref{lem:cell-cut}, with no additional inside pins or equality edges. +For $L\ge Cr\ge C$, the pair variables in $B(z,r)$ can be coupled with +variables $P_r$ of the fixed free-plane marginal $\nu_r$ so that +\[ + \Prob(P_r\in A\mid\mathcal R)=\nu_r(A) + \quad\text{for every event }A, + \qquad + \Prob(\text{mismatch}\mid\mathcal R)\le C(r/L)^\alpha + \quad\text{on }G. +\] +The same plane marginal is assigned on failure. Consequently $P_r$ is +independent of the entire record and the total mismatch probability is at +most $\Prob(G^c)+C(r/L)^\alpha$. Agreement of pair variables also matches +increments along paths contained in $B(z,r)$. +\end{corollary} +\begin{proof} +The local comparison proof applies uniformly to the retained open-cut law. +To see this directly, put a deterministic regular open-minus circuit inside +$B(z,L)$ at a radius comparable to $L$. Adding this prescription lowers +the first-color/status law by Proposition~\ref{prop:history-order}. +The old boundary prescriptions are outside this regular circuit. Search +inward for a common open-plus circuit and use the same annular stack and +exact inside sampling as in Proposition~\ref{prop:local-mixing}. The error +is $C(r/L)^\alpha$, independently of the old circuit and its exterior +record. The law inside the deterministic minus circuit is independent of +that record. Comparing it with the free-plane law gives the stated +conditional total-variation bound, with a changed constant. + +For each record choose a maximal coupling of its retained marginal with +the same second marginal $\nu_r$. On failed records use that second +marginal and any coupling. On these finite local state spaces the usual +maximal-coupling formula gives a measurable kernel. The conditional +second-marginal identity in the statement proves independence from +$\mathcal R$, and averaging the mismatch bound proves the final estimate. + +For a stopped exploration from Lemma~\ref{discrete:online}, assume there +are no additional pins or equality edges inside the cut and no equality +edge crosses it. The geometric invasion above records only the prescribed first-color cut layer on the +retained side. Exterior second-spin labels, including those needed to +read absolute heights along exterior paths, reveal no retained component +label: open crossing cells have constant factors and no equality edge +crosses the cut. Lemma~\ref{lem:cell-cut} therefore verifies the retained-law +hypothesis for precisely these records. Retained second-spin labels must +remain unobserved. +\end{proof} + +If a connected fixed skeleton has constant $W$ by equality edges, giving +its component the actual label plus has conditional probability exactly +$1/2$, independent of $(B,\tau)$. Thus it does not bias any first-spin +search. More generally, at most $m$ connected all-plus constraints have +conditional probability between $2^{-m}$ and $1$; any failed-search +probability increases by at most $2^m$ after imposing them. Once a stopped +open cut separates all these constraints from a retained region containing +no other pins or equality edges, revealing their labels fixes no retained +component. Its conditional law +is the unlabelled open-cut law. Applying Corollary~\ref{cor:conditional-plane-matching} +inside a cut at an intermediate scale gives local plane +matching also in this situation, with constants depending on $m$ and, +if necessary, a smaller positive exponent. For example a cut between +$\sqrt{rL}$ and a fixed fraction of $L$ has failure +$C_m(r/L)^{\alpha/2}$ and leaves an inside comparison error of the same +order. Absolute exterior heights may be included in the record by +revealing paths from their sites to an exterior anchor; the inner +complementary labels remain unqueried. Zero-total interior tests do not depend on the unspecified lift offset. + +\subsection{Multiplicative comparison for rare pins} + +Additive mixing does not control an event whose probability tends to zero +with the mesh. We next prove the comparison that will be used for such +events. All geometric neighborhoods in this proposition are fixed before +letting $\delta$ tend to zero. + +\begin{proposition}[Separated rare pins]\label{prop:rare-pins} +Fix $k$ bounded filled simply connected neighborhoods $U_1,\ldots,U_k$ +with disjoint closures. In each $U_i$ let $P_i$ prescribe arbitrary first +spins on a finite site set and prescribe second-spin plus on at most +$m_i$ connected lattice subgraphs, singletons allowed. Assume the +supports stay a fixed positive distance from $\partial U_i$, so that +isolating circuit collars fit inside $U_i$, and let $m=\sum_i m_i$ be +fixed. In the free plane law, +\begin{equation}\label{discrete:rare-pins} + c\prod_{i=1}^k\Prob(P_i) + \le \Prob\Bigl(\bigcap_{i=1}^kP_i\Bigr) + \le C\prod_{i=1}^k\Prob(P_i). +\end{equation} +The constants depend on $x$, $k$, $m$, and the fixed buffers, but not on +the numbers of pinned sites, the lengths of the connected subgraphs, or +lattice translations preserving the buffers. The comparison also holds +in finite free ambient volumes containing all the required comparison +collars. Previous pins inside the currently considered obstacle are +retained in both comparison laws. +\end{proposition} +\begin{proof} +We first establish a single-sign comparison under arbitrary existing +first-spin pins and second-spin equalities. Consider an obstacle $K$ +with an empty collar, and an event $A$ adding only first-spin pins of +sign $s$ on $K$. There can be previous pins of either sign inside $K$, +as well as equality edges there. Choose a deterministic outer good cut +$\gamma_s$ of sign $s$ in the collar. Let $p_*$ be the probability of +$A$ in the law with this additional cut. By the exact-cut lemma, $p_*$ +depends on the previous \emph{inside} constraints and on the chosen +outer cut, but not on any remote constraints. Order gives +\begin{equation}\label{discrete:pstar} + \Prob(A)\le p_*. +\end{equation} +For minus pins this is the same assertion in reversed order. + +An exterior search finds a closer good cut $C_s$ of sign $s$ in a +strictly inner collar with probability at least $c_0>0$, uniformly over +all existing constraints. Conditional on any stopped successful record, +the remaining conditional probability of $A$ is exactly its probability +inside $C_s$, with all previous internal constraints retained. In the +deterministic outer-cut law, conditioning on this particular closer +favorable cut increases the event $A$. Its inside law is the same by +Lemma~\ref{lem:cell-cut}; hence the conditional probability is at least +$p_*$. Averaging over successful records proves +\begin{equation}\label{discrete:single-sign} + c_0p_*\le\Prob(A)\le p_*. +\end{equation} +In particular probabilities under two different remote constraint sets +are comparable whenever their previous internal constraints coincide. +This argument retains opposite pins inside the obstacle; it does not +erase them when the next sign block is considered. + +Write $E_i$ for the event that each of the specified second-spin +subgraphs in obstacle $i$ is constant, and $L_i$ for the event that their +labels are all plus. Initially impose no first-spin pins. Apply +\eqref{discrete:single-sign} with $W$ as first color to the events $L_i$, +obstacle by obstacle. Each conditional factor, given earlier obstacles, +is comparable with its unconditional factor, because those constraints +are remote and the same reference cut can be used. Therefore +\[ + \Prob\Bigl(\bigcap_i L_i\Bigr)\asymp\prod_i\Prob(L_i). +\] +The component-label estimate gives, both jointly and separately, +\[ + 2^{-m}\Prob\Bigl(\bigcap_i E_i\Bigr) + \le\Prob\Bigl(\bigcap_i L_i\Bigr) + \le\Prob\Bigl(\bigcap_i E_i\Bigr),\qquad + 2^{-m_i}\Prob(E_i)\le\Prob(L_i)\le\Prob(E_i). +\] +Consequently $\Prob(\bigcap_iE_i)\asymp\prod_i\Prob(E_i)$. + +Now regard all $E_i$ as the common equality set $E_0$ for the original +first color. Let $A_i$ be its prescribed first-spin event. Add the plus +pins in obstacle $1$, then its minus pins, then the two blocks in obstacle +$2$, and so on. At each step \eqref{discrete:single-sign} compares the +conditional probability with the same factor in the individual law +conditioned on $E_i$ and on earlier sign blocks \emph{in this obstacle}. +Remote $E_j$ and earlier remote first-spin pins disappear behind the +reference cut. Previous internal plus pins remain when the minus block +is added. There are at most $2k$ factors, so multiplication gives +\[ + \Prob\Bigl(\bigcap_i A_i\,\Bigm|\,\bigcap_i E_i\Bigr) + \asymp\prod_i\Prob(A_i\mid E_i). +\] +Combining with the equality comparison gives +$\Prob(\bigcap_i(A_i\cap E_i))\asymp +\prod_i\Prob(A_i\cap E_i)$. Finally restoring all the actual plus +labels costs a factor between $2^{-m}$ and $1$, even after the arbitrary +first-spin pins and statuses have been specified. The same holds +individually with $m_i$. Since $P_i=A_i\cap L_i$, this proves +\eqref{discrete:rare-pins}. Every comparison was finite-volume and +uniform. Positive probability of the finite pin events permits passage +to the plane limit. No division by a mesh-dependent lower bound for a +pin probability occurred. +\end{proof} + +\subsection{Protected switches and height order} + +A spin configuration records height only modulo four. The next switch +changes an integer lift by four in a protected region while preserving +both of its spins. It will supply nonzero height fluctuations and allow +the moment argument to compare different integer-offset parity classes. + +\begin{lemma}[Protected component switch]\label{lem:collar-switch} +Suppose two nested good circuits have opposite first-spin signs. Between +and on the two circuits assume there are no second-spin equality +constraints or prescribed second-spin labels. Conditional on the +first spins and cell statuses, there is a deterministically selectable +second-spin component in that collar whose fair label flip changes the +integer lift throughout the protected inner region by $+4$ or $-4$ +relative to the protected exterior, while preserving both spins in both +protected regions. The selection uses only the first spins, statuses, +equality edges, and the two circuits. It therefore preserves any stopped +selection of the circuits based on these data. + +For disjoint collars the switches commute and give equally weighted +orbits containing every parity vector of the corresponding inner lift +offsets in $4\Z$. Spin constraints and comparisons of lifts along paths +inside the protected regions are preserved. With the height anchor fixed +in the protected exterior, a test supported there is unchanged; a +zero-total test supported entirely in the protected inner region is also +unchanged. Opposite good cuts can be required in any +fixed nested pin-free collars with uniformly positive probability. +The assertion holds with the two colors interchanged. +\end{lemma} +\begin{proof} +For an oriented edge, direct use of \eqref{discrete:increment} gives +\begin{equation}\label{discrete:switch-differential} + d(H+BW/2)=W\,dB. +\end{equation} +Whenever $B$ changes, $W$ is constant on that edge and its endpoints +belong to the same closed-cell component. For such a component $C$ define +an edge form $\omega_C$ equal to $dB$ on its changing edges and zero on +the other edges. On any triangle the two changing edges, if present, +share a vertex and consequently belong to the same component. Their +contributions cancel. Thus $\omega_C$ has zero circulation and, by simple +connectedness, has a potential $\psi_C$. + +On $C$ one has $\psi_C=B+\text{constant}$, since this is true along each +closed-cell or equality edge of a component path. Every site outside $C$ +can be joined to a first site of $C$ by a path whose preceding edges have +zero $\omega_C$. A changing last edge would put both endpoints in $C$, +so it too has zero form. Hence every value of $\psi_C$ is a value attained +on $C$, and its range has diameter at most two. In particular its +nonzero differences are $\pm2$. + +Open cuts prevent these components from crossing either circuit. Choose +a path in the collar from the exterior-side layer of the inner circuit +to the interior-side layer of the outer circuit. The difference of its +first-spin endpoints is $\pm2$. Since +$\sum_Cd\psi_C=dB$, at least one component meeting this path contributes +a difference $\pm2$. Such a component is confined to the collar; its +potential is constant on each connected protected inner and outer +region. Choose the first such component in a fixed deterministic order. +No label of this component is prescribed. Let its label be $w\in\{-,+\}$. +Flipping it changes the right side of +\eqref{discrete:switch-differential} by $-2w\,d\psi_C$. Neither endpoint +spin changes in the protected regions, so their relative height shift is +$-2w(\pm2)=\pm4$. Anchor the lift in the protected exterior to fix its +absolute value there. The flip is an involution preserving its +conditional probability because the label is fair. + +The chosen component and circuits are unchanged by this operation, +since they depend only on $(B,\tau,E_0)$. A switch changes an inner +offset $4t$ to $4(t\pm1)$ and therefore reverses its parity. Switches in +disjoint collars act on disjoint components and commute. Every orbit +has $2^j$ equally weighted elements for $j$ collars and visits each +parity vector exactly once. This conclusion remains true after imposing +any checks invariant under the switches; it asserts an orbit identity, +not independence after arbitrary checks. The statements about tests +follow from their supports and total weights. If a central event involves +absolute offsets and is not invariant, one must enlarge its bounded +range to contain the orbit before applying this identity. Finally apply +Lemma~\ref{lem:buffer-circuits} successively in two disjoint nested +collars to require opposite signs, with the given constraints away from +both buffers. Swapping the colors is a symmetry of the Gray representation. +\end{proof} + +\begin{lemma}[Height comparison and flat loops]\label{lem:height-order} +Let the free sites be in bounded faces of a connected triangular-lattice +skeleton of fixed integer trace. Include all neighbors of free sites up +to that trace. The weighted height law is positively associated, and +ordered feasible traces give stochastically ordered laws. The assertion +also applies after restricting to components separated by further fixed +curves. With constant trace, the changing dual edges are disjoint closed +honeycomb loops. Given their unoriented geometry their jumps are +independent fair signs. Exposing such loops from the outside leaves in +each unexposed interior the empty-exterior loop law with the appropriate +constant inner boundary layer. +\end{lemma} +\begin{proof} +Write the edge potential as +\[ + V(t)=\begin{cases}-(\log x)|t|,&t\in\{-1,0,1\},\\ + +\infty,&\text{otherwise}. + \end{cases} +\] +This is a convex extended-real potential on the integers. For two +admissible arrays $h,g$, sorting their endpoint values gives on each edge +\[ + V((h\wedge g)_v-(h\wedge g)_u) + +V((h\vee g)_v-(h\vee g)_u) + \le V(h_v-h_u)+V(g_v-g_u). +\] +For completeness, if the endpoint orders agree this is equality. If +they disagree, write the four ordered endpoint values; sorting replaces +two crossing intervals by two nested pairings and cannot increase the +sum of their lengths. The new edge differences lie between the two old +ones, so their absolute values remain at most one. Since $-\log x\ge0$, +the displayed inequality follows, including $x=1$. Ordered traces put +the meet in the lower support and the join in the upper support. +Multiplying the edge inequalities proves the within-law lattice +condition and the two-law inequality. Heights are bounded in this finite +problem by the trace bounds plus graph distance to the trace. FKG and +the product-with-$\{0,1\}$ argument used in +Proposition~\ref{prop:history-order} therefore give association and +ordered comparison on a finite lattice, with inadmissible arrays assigned +zero weight. + +On each triangle integer Lipschitz heights take at most two consecutive +values. Its dual honeycomb vertex consequently has either zero or two +changing edges. Constant trace prevents such edges from ending on the +bounding skeleton. They thus form mutually vertex-disjoint loops. A +loop lying in a bounded face of the connected skeleton cannot enclose +any piece of that skeleton: a connection from that piece to the bounding +skeleton would cross the loop. Every choice of one of two jump signs +for each loop therefore yields exactly one admissible height field with +the specified constant trace. Its weight is $x$ to the total loop length, +independent of all the signs. Conditional jumps are independent and fair, +and the marginal geometric weight is $2$ per loop times $x$ per occupied +edge. + +For a fixed exposed loop, the loops strictly inside cannot touch its +vertices. The edge and loop factors split between inside and outside; +the inside boundary face layer has a constant height. Selecting the next +enclosing loop by an exploration depending only on already exposed +outside geometry does not inspect a strict inside edge. Summing the +product weights over completions, or equivalently conditioning the +constant inner height layer, proves the same factorization at each +stopping step. This is the asserted empty-exterior law and applies +without regularity of the exposed loop. Finally the ambient realization +in Lemma~\ref{lem:spin-lift}, with constant pair pins on the connected +skeleton, gives the same flat height problems used above. +\end{proof} + +Every use of a positive-width buffer in later sections has the following +order of quantifiers: first fix the finite geometry, its clearances, and +its number of requests; next let $\delta\downarrow0$; only afterwards +shrink a gap or exceptional window. The constants of this section may +depend on that fixed geometry and on the fixed parameter $x$. No +uniformity as $x$ varies or as a buffer degenerates is asserted. diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/03-moments.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/03-moments.tex new file mode 100644 index 0000000000000000000000000000000000000000..a4c97567cb79b705edc60f36391ce883ef37e75e --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/03-moments.tex @@ -0,0 +1,602 @@ +\section{Shell counts and smearing moments}\label{sec:moments} + +All distances in this section are in lattice units. A \emph{smearing of +radius $a\geq1$ and weight bound $A$} is a linear statistic +\begin{equation}\label{moments:weights} + Y(H)=\sum_u w_uH(u),\qquad + \supp w\subset B(z_0,a),\qquad + \sum_u|w_u|\leq A,\qquad \sup_u|w_u|\leq Aa^{-2}. +\end{equation} +The weights are real and may have either sign. If $\sum_uw_u=0$, we +call the smearing \emph{zero-total}; its value is independent of the +additive constant in the height lift. Constants throughout may depend +on the fixed parameter $x$. + +The bounded height problems below use the convention of +Lemma~\ref{lem:height-order}: a connected fixed-trace lattice skeleton +bounds the free sites, and every incident interaction up to that trace +is retained. This includes the interior of a stopped contour after its +inner face layer has been fixed. The skeleton need not be convex or +have a lower bound on the widths of its fjords. + +We will prove two bounds for these smearings, for every finite $p\geq1$. +Suppose the radius $a$ is at most a fixed small fraction of the distance +$n$ from the smearing center to the trace. If that trace has magnitude +at most $K$, the $L^p$ norm is controlled by +$1+K+\sqrt{\log(n/a)}$. For zero-total smearings in the free plane +law, the norms are bounded independently of $a$. The common starting point is a bound on the +number of enclosing loops in each shell. It gives a logarithmic +covariance estimate and hence positive mass in a central interval; +rounded midpoints then turn that central mass into all finite moments. + +\subsection{A shell estimate without an upper crossing input} + +\begin{lemma}[Geometric tails for shell counts]\label{lem:shell-moments} +In a finite constant-boundary height problem, let $N_d(z)$ be the number +of level loops surrounding a site $z$ whose Euclidean closest approach +to $z$ belongs to $[d,2d)$, where $d\geq1$. There are $c,C>0$ such that +\begin{equation}\label{moments:shell-tail} + \Prob\{N_d(z)\geq t\}\leq Ce^{-ct}\qquad(t\geq0). +\end{equation} +In particular, for each finite $p\geq1$, $\E N_d(z)^p\leq C_p$. +These constants are independent of the shape, $z$, and $d$, and the +same assertions hold in any bounded face of a connected flat skeleton. +\end{lemma} + +\begin{proof} +A constant shift reduces to boundary height zero. Conditional on their +unoriented geometry, the level loops have independent fair height +increments. Expose enclosing loops from outside inward, using the +stopping rule in Lemma~\ref{lem:height-order}. If the first loop counted +by $N_d(z)$ exists, its unexplored interior has the empty-exterior loop +law with a constant inner trace. Its distance from $z$ is at most +$2d+O(1)$. Every further counted loop surrounds $B(z,d/2)$, for all +sufficiently large $d$. The factor $1/2$ provides clearance from all +rounding and incident-face conventions. + +We first prove a uniform obstruction in any such remaining domain. +Suppose an exterior search finds a good open-plus $B$ contour $C$ strictly +inside its boundary, surrounding $B(z,d/2)$. Choose the outermost such +contour by the authorized-edge invasion following +Lemma~\ref{discrete:online}. The search exposes only exterior +history and the prescribed open-plus cut data. In particular it reveals +no strict interior cell and leaves the exact cut law of +Lemma~\ref{lem:cell-cut} inside $C$. Moreover +\begin{equation}\label{moments:cut-radius} + d/2\leq\dist(z,C)\leq2d+O(1). +\end{equation} +There is a number $\kappa>0$, independent of $C$, such that under this +interior law a $B$-plus path joins its prescribed inner layer to +$B(z,d/2)$ with probability at least $\kappa$. + +Here are geometric and conditional details of this last assertion. +Fix a sufficiently small constant $\epsilon>0$, and choose a closest +point $p$ of $C$ to $z$. Realize the same interior law in a new free +ambient triangulation containing $B(z,10d)$, conditioned only on the +same open-plus cells and first-spin sites of $C$. Exact cutting +justifies this replacement even for an arbitrarily nonconvex $C$. +In this ambient graph request a good plus circuit in an annulus about +$p$ with radii $\epsilon d$ and $2\epsilon d$. Since $C$ visits the +inner ball and surrounds $B(z,d/2)$, it must exit the outer ball and +intersect this circuit. Next request a chain of annular plus circuits +of these same radii, from $p$ to an annulus wholly inside $B(z,d/2)$. +The centers may follow a straight segment in the ambient plane. Choose +successive spacings strictly between $\epsilon d$ and $2\epsilon d$, +with fixed slack. The inner balls of consecutive annuli overlap and +each protrudes outside the other's outer ball. Consequently their +surrounding circuits intersect: disjoint circuits would have either +disjoint interiors, contradicting the overlap, or nested interiors, +contradicting that protrusion. Equation~\eqref{moments:cut-radius} +bounds the number of requests by a constant depending only on +$\epsilon$. Bounded lattice displacements are absorbed by the slack. + +Lemma~\ref{lem:buffer-circuits} and positive association give a fixed +positive probability for their intersection in the free ambient law. +All the data imposed on $C$ are favorable for this increasing event, +so Proposition~\ref{prop:history-order} gives the same lower bound after +conditioning on $C$. The connected circuit chain contains a path +from $C$ to the terminal circuit inside the disk. Take its last +intersection with $C$ before that endpoint. The remaining path stays +inside $C$, since otherwise planar separation would force another +intersection. Its adjacent plus face chain therefore joins the +prescribed inner layer to the disk. This proves the asserted lower +bound $\kappa$. In particular this connection precludes a deeper +$B$ wall surrounding the disk. The ambient chain was allowed to leave +$C$; no interior corridor of prescribed width was assumed. + +To turn this obstruction into a bound on the number of loops, let $N$ +be the number of further qualifying enclosing loops in the remaining +flat problem. Closest approach is nonincreasing under nesting, so the +qualifying loops are consecutive in the enclosing nesting order until +their closest approach falls below $d$. Conditional on all unoriented +geometry, write the height residues along them as a nearest-neighbor +walk on $\Z/4\Z$, with independent fair signs. From every starting +residue there is a prescribed block of four signs that contains a +$W$ wall with unchanged $B=+$, followed inward by a $B$ wall. For +example, starting from residues $0,1,2,3$, respectively, the initial +strings $++$, $--$, $---$, $+++$ have that property; complete each to +four signs arbitrarily. Every chosen four-sign block has probability +$1/16$. Hence, on $\{N\geq k\}$, the conditional probability of +seeing this ordered pair of walls among the first $k$ loops is at least +\[ + 1-\varepsilon_k, + \qquad \varepsilon_k=(15/16)^{\lfloor k/4\rfloor}. +\] +The statement follows by conditioning successively on the starting +residue of each block; independence between block-success events is +not required. + +Call this ordered-wall event $\mathcal A$. A $W$ wall with $B=+$ is +a good open-plus contour, because every cell at which $W$ is +nonconstant is necessarily open. Thus $\mathcal A$ implies existence +of the exterior-searched outermost plus cut above and of a $B$ wall +strictly inside it surrounding the disk. The preceding obstruction, +conditioned on every possible stopped cut, yields +\[ + (1-\varepsilon_k)\Prob(N\geq k) + \leq\Prob(\mathcal A)\leq1-\kappa. +\] +Choose a fixed integer $k$ with $\varepsilon_k\leq\kappa/2$ and put +$\rho=(1-\kappa)/(1-\kappa/2)<1$. The probability of continuing for +$k$ further qualifying loops is at most $\rho$. + +After exposing these $k$ loops, the last one's interior is again an +empty-exterior flat problem of exactly the same type, with closest +boundary distance at most $2d+O(1)$. Restarting conditionally gives +\[ + \Prob\{N_d(z)\geq1+mk\}\leq\rho^m\qquad(m\geq0). +\] +This is a stopping recursion; it asserts no independence of successive +geometric shells. It proves~\eqref{moments:shell-tail} for sufficiently +large $d$. For bounded $d$, each counted loop visits a fixed-size ball +and the loops have disjoint honeycomb vertices, giving a deterministic +bound on their number. Finally, integration of the exponential tail +gives every stated moment. +\end{proof} + +\begin{lemma}[Common loops and the logarithmic covariance bound] +\label{moments:covariance} +Let the flat trace be zero, let $n$ be the distance from $z_0$ to its +bounding skeleton, and let $z,w\in B(z_0,a)$, where +$1\leq a\leq c_0n$ for a sufficiently small absolute $c_0$. With +$b=\max(1,|z-w|)$, +\begin{equation}\label{moments:covariance-bound} + 0\leq\E[H(z)H(w)] + \leq C\left(1+\log\frac{n}{b}\right). +\end{equation} +Every smearing~\eqref{moments:weights} in this ball therefore satisfies +\begin{equation}\label{moments:second-moment} + \E Y^2\leq C A^2\left(1+\log\frac{n}{a}\right). +\end{equation} +\end{lemma} + +\begin{proof} +The independent centered loop orientations give the exact identity +\begin{equation}\label{moments:common-loops} + \E[H(z)H(w)] + =\E\#\{\text{level loops surrounding both $z$ and $w$}\}. +\end{equation} +Fix a dyadic closest-approach shell $[d,2d)$ about $z$ with +$d\leq b/100$. A loop surrounding both sites and entering $B(z,2d)$ +must also leave a ball about $z$ of radius comparable to $b$; otherwise +it could not enclose $w$. It supplies a wall arm across the intervening +annuli. Along the whole loop exactly one of $B,W$ changes. A good +circuit of that color cannot be crossed by its wall, since the circuit's +open cells have constant first spin. + +Use the wall color as the first spin. The zero-height skeleton fixes +that first spin and imposes constancy of the second spin along a +connected skeleton. Represent the latter constancy by $E_0$ edges. +Its actual constant label costs exactly $1/2$, independent of the +first spins and statuses, and hence does not change their marginal. +All arm annuli lie away from the skeleton, since $b\leq2a+1$ and +$c_0$ is small. The logarithmic circuit stack from +Lemma~\ref{lem:buffer-circuits}, applied for each of the two possible +wall colors, consequently gives +\begin{equation}\label{moments:arm} + \Prob\{\text{such a common loop exists in the shell}\} + \leq C(d/b)^\alpha. +\end{equation} +If $M_d$ counts common loops in this shell, then +$M_d\leq N_d(z)$ and $M_d=0$ outside the event in~\eqref{moments:arm}. +Cauchy--Schwarz and Lemma~\ref{lem:shell-moments} imply +\[ + \E M_d\leq (\E N_d(z)^2)^{1/2} + \Prob(M_d>0)^{1/2} + \leq C(d/b)^{\alpha/2}. +\] +Loops at distance below one give a deterministic bounded contribution +by disjointness. The sum over the small dyadic scales is bounded. +Each of the +$O(1+\log(n/b))$ remaining shells contributes at most a constant. +There are no shells beyond scale $O(n)$: a nearest skeleton site is +outside every enclosing loop, so the segment from $z$ to that site +meets the loop within distance $n+a+O(1)$. These facts and +\eqref{moments:common-loops} prove~\eqref{moments:covariance-bound}. + +For completeness the average of the singularity is uniformly bounded, +including its diagonal. Triangular-lattice balls have at most +$C(1+r)^2$ sites. For fixed $z$, the layer-cake formula gives, when +$a>1$, +\begin{align*} + &\sum_w |w_w|\log^+\frac{a}{\max(1,|z-w|)}\\ + &\qquad=\int_0^{\log a} + \sum_{\max(1,|z-w|)0$; the +pointwise hypothesis therefore makes both corresponding output weights +positive. All logarithms below are thus evaluated on finite positive +supports. Integrating the logarithm of the pointwise hypothesis and +then using the entropy inequality gives +\begin{align*} + \log A+\log B + &\le\sum_z\nu_-(z)\log u(z)+\sum_z\nu_+(z)\log v(z) + -\mathcal H(\nu_0)-\mathcal H(\nu_1)\\ + &\le\left(\sum_z\nu_-(z)\log u(z)-\mathcal H(\nu_-)\right) + +\left(\sum_z\nu_+(z)\log v(z)-\mathcal H(\nu_+)\right)\\ + &\le\log\sum_z u(z)+\log\sum_z v(z). +\end{align*} +The last inequality is Jensen's inequality applied to +$\sum\nu\log(a/\nu)$ on the positive support of each probability +measure; adding any unused nonnegative weights only enlarges the sum. +Exponentiating proves the scalar statement without modifying zero +values or assuming that a positive approximation preserves its premise. + +For the induction step write $s=(s',a)$ and $t=(t',b)$. Fix $s',t'$ +and apply the one-dimensional theorem in $a,b$. For the partial sums +$F(s')=\sum_a f(s',a)$, and likewise $G,U,V$, its conclusion is +\[ + F(s')G(t')\leq + U(m_-(s',t'))V(m_+(s',t')). +\] +The induction hypothesis in the other $m-1$ coordinates proves the +claim. No factorization of the functions is used. A finite array is +extended by zero to $\Z^m$; the premise must still be checked on every +pair of its nonzero input supports. +\end{proof} + +\begin{lemma}[Admissibility and energy at rounded midpoints] +\label{moments:weighted-midpoints} +Let $\mathcal S$ be the integer $1$-Lipschitz arrays on a finite +connected graph, with fixed integer heights on a nonempty set of +vertices. Set +\[ + \mathcal W(h)=\ind_{\{h\in\mathcal S\}} + x^{\sum_{\{i,j\}}|h_i-h_j|}. +\] +Then $\mathcal S$ is finite, both rounded midpoints of $s,t\in\mathcal S$ +belong to $\mathcal S$, and +\begin{equation}\label{moments:weight-midpoint} + \mathcal W(m_-(s,t))\mathcal W(m_+(s,t))\geq \mathcal W(s)\mathcal W(t). +\end{equation} +Moreover a linear statistic with $\sum|w_i|\leq A$ obeys +\begin{equation}\label{moments:rounding} + \left|Y(m_\pm(s,t))-\frac{Y(s)+Y(t)}2\right|\leq A/2. +\end{equation} +The same energy inequality holds with additional support constraints +whenever both outputs satisfy those constraints. +\end{lemma} + +\begin{proof} +One fixed height bounds every coordinate by its graph distance from +that vertex, so the array is finite. For an edge $ij$ put +$a=s_i-s_j$ and $b=t_i-t_j$. If $c,d$ are its differences in the two +rounded arrays, and $\varepsilon_i$ is the parity of $s_i+t_i$, then +\[ + c=\frac{a+b-\varepsilon_i+\varepsilon_j}{2},\qquad + d=\frac{a+b+\varepsilon_i-\varepsilon_j}{2}. +\] +Thus $c+d=a+b$, $|c-d|\leq1$, and $c,d$ are its two nearest integer +halves. In particular $c,d\in\{-1,0,1\}$ and +\[ + |c|+|d|=|a+b|\leq|a|+|b|. +\] +Each fixed integer coordinate is preserved exactly. Summing over edges +and using $x\leq1$ proves~\eqref{moments:weight-midpoint}, including +$x=1$. Each rounded coordinate differs from its average by at most +$1/2$, which proves~\eqref{moments:rounding} even for signed weights. +\end{proof} + +\begin{lemma}[Central mass in finitely many classes] +\label{lem:midpoint-amplification} +Let $\mu(h)=\mathcal W(h)/Z$ be a finite probability measure on integer arrays. +Partition its support into at most $J$ classes. Suppose that two arrays +from the same class have both rounded midpoints in the full support, +with the weight inequality~\eqref{moments:weight-midpoint}. Let $Y$ be +a linear statistic satisfying~\eqref{moments:rounding}. If $M>0$, +$M\geq A/2$, and, for every class $\mathcal S_i$, +\begin{equation}\label{moments:class-central} + \mu\bigl(\mathcal S_i\cap\{|Y|\leq M\}\bigr)\geq c>0, +\end{equation} +then there are $a_*>0$ and $C_p<\infty$, depending only on $J,c,p$, such +that +\begin{equation}\label{moments:amplification} + \mu\{|Y|>tM\}\leq4e^{-a_*t}\quad(t\geq0), + \qquad \|Y\|_{L^p(\mu)}\leq C_pM\quad(1\leq p<\infty). +\end{equation} +Outputs may belong to any class. In particular no stability of an +individual class under midpoint rounding is required. +\end{lemma} + +\begin{proof} +For integers $j\geq3$ define +\[ + I_j=[(2^j-4)M,(2^{j+1}+4)M],\qquad p_j=\mu(Y\in I_j). +\] +For $j\geq4$ choose a class carrying at least $p_j/J$ of the mass of +$I_j$, and pair its tail arrays with its central arrays from +\eqref{moments:class-central}. Every output has its statistic in +\[ + [(2^{j-1}-7/2)M,(2^j+7/2)M]\subset I_{j-1}; +\] +indeed the central average contributes at most $M/2$ and rounding at +most $A/2\leq M$. Apply Theorem~\ref{thm:midpoint} to $\mathcal W$ restricted +to the chosen tail and central sets, and to two copies of $\mathcal W$ restricted +to $\{Y\in I_{j-1}\}$. Dividing by $Z^2$ gives +\begin{equation}\label{moments:recursion} + p_j\leq (J/c)p_{j-1}^2. +\end{equation} + +Put $K_*=J/c\geq1$, $N=\lceil4K_*\rceil$, and $L=3+N$. +For $j\geq4$ these intervals have overlap at most two: the upper +endpoint of $I_j$ is strictly below the lower endpoint of $I_{j+2}$. +Thus $\sum_{j\geq4}p_j\leq2$, and among $j=4,\ldots,L$ there is +$j_0$ with $K_*p_{j_0}\leq1/2$. Iteration of +\eqref{moments:recursion} yields +\[ + K_*p_{j_0+r}\leq2^{-2^r}\quad(r\geq0), + \qquad + p_j\leq K_*^{-1} + \exp\{- (\log2)2^{j-L}\}\quad(j\geq L). +\] +Repeat the argument for $-Y$, with the same $L$. If $t\geq2^L$ and +$k=\lfloor\log_2t\rfloor$, the cores +$[2^jM,2^{j+1}M]\subset I_j$ for $j\geq k$ cover the positive tail, +and their negative counterparts cover the negative tail. Writing +$q_0=\exp\{-(\log2)2^{k-L}\}\leq1/2$, we obtain +\[ + \mu(|Y|>tM) + \leq\frac2{K_*}\sum_{r\geq0}q_0^{2^r} + \leq4q_0 + \leq4\exp\{- (\log2)2^{-L-1}t\}. +\] +For $0\leq t<2^L$ the last bound exceeds one. This proves the tail +claim with $a_*=(\log2)2^{-L-1}$. Finally +$\E|Y|^p=\int_0^\infty pt^{p-1}\mu(|Y|>t)\,\dd t$ proves the moment +claim. This proof explicitly uses the unconditional central mass in +each class; a central bound for their union would not suffice. +\end{proof} + +\subsection{Bounded traces and plane increments} + +\begin{proposition}[Smearing with bounded boundary values] +\label{prop:smearing} +In a bounded height problem as specified above, suppose its fixed trace +has absolute value at most $K$. Let $n$ be the distance from the +smearing center to the bounding sites. For +$1\leq a\leq c_0n$ and every finite $p\geq1$, +\begin{equation}\label{moments:smearing-bound} + \left\|\sum_uw_uH(u)\right\|_p + \leq C_{p,A}\left(1+K+\sqrt{\log(n/a)}\right). +\end{equation} +The bound is uniform over the shape of the trace and applies in +particular to the interior of a good cut after its complete inner +height layer has been specified. +\end{proposition} + +\begin{proof} +For zero trace, Lemma~\ref{moments:covariance} and Chebyshev's inequality +supply central probability at least $1/2$ with +$M=C_A(1+\sqrt{\log(n/a)})$, increased if necessary to exceed $A/2$. +Lemma~\ref{moments:weighted-midpoints} verifies all midpoint hypotheses +for the actual weighted height measure. Apply +Lemma~\ref{lem:midpoint-amplification} with one class to prove +\eqref{moments:smearing-bound} for zero trace. + +For general trace, put $K_0=\lceil K\rceil$. Height order from +Lemma~\ref{lem:height-order} traps the law between the flat laws with +traces $-K_0$ and $K_0$. For nonnegative weights, the corresponding +smearing laws are the zero-trace smearing shifted by +$\pm K_0\sum_uw_u$. Both tails are therefore bounded by the +zero-trace tails with an additive displacement at most $AK_0$. +This gives~\eqref{moments:smearing-bound}. Split arbitrary signed +weights into their positive and negative parts; each satisfies +\eqref{moments:weights}, and the triangle inequality in $L^p$ finishes +the proof. On a cut, fix the entire actual inner trace first, so its +interior is an ordinary weighted height problem by +Lemma~\ref{lem:cell-cut}. The same argument applies conditionally. +\end{proof} + +\begin{proposition}[Uniform plane moments for zero-total smearings] +\label{prop:plane-moments} +For the infinite-volume increment law furnished by +Proposition~\ref{prop:local-mixing}, every zero-total +smearing~\eqref{moments:weights} satisfies +\begin{equation}\label{moments:plane-bound} + \left\|\sum_uw_uH(u)\right\|_p\leq C_{p,A} + \qquad(1\leq p<\infty). +\end{equation} +The constants are uniform in $a\geq1$ and the center. The same estimate +holds for the increment law in a finite free simply connected +triangulation containing $B(z_0,C_0a)$, for a sufficiently large fixed +$C_0$. +\end{proposition} + +\begin{proof} +Work first with the free spin pair in the finite ambient graph. +Choose a fixed large constant $L_0$ with $1/L_00$. Its trace is contained +in two consecutive integers. Conditional also on the complete inner +trace, subtract the lower of these integers. The interior is now an +ordinary height problem with trace in $\{0,1\}$, and its distance from +$z_0$ is between fixed multiples of $L_0a$. Proposition~\ref{prop:smearing} +therefore gives a uniform conditional second-moment bound $C_A$. +The random subtraction changes no zero-total smearing. Chebyshev's +inequality and then averaging over the search show, for some fixed +$M\geq A/2$, +\begin{equation}\label{moments:plane-central} + \Prob(|Y|\leq M)\geq c_1/2. +\end{equation} +If the finitely many smallest lattice scales require enlarging the +annulus to accommodate rounding, use a fixed minimal annulus radius; +its ratio to $a\geq1$ remains bounded and the same constants suffice. + +To amplify this central bound, use the correct finite height measure. +For any chosen anchor $o$, the four cyclic rotations of the Gray states +preserve every increment and every interaction weight, and act +transitively on the pair state at $o$. Consequently the unconditioned +free pair has exactly the same increment law as its version with state +$(+,+)$ at $o$. By Lemma~\ref{lem:spin-lift}, the latter is the measure +on integer $1$-Lipschitz arrays with $H(o)=0$ and density proportional +to $x^{\sum_{ij}|H(i)-H(j)|}$. Thus $Y$ in this anchored measure has +the central bound~\eqref{moments:plane-central}. This argument obtains +the cut central bound before fixing the anchor, and hence introduces +no extra anchor constraint into the stopped interior law. + +The anchored arrays form one midpoint-admissible class by +Lemma~\ref{moments:weighted-midpoints}. Applying +Lemma~\ref{lem:midpoint-amplification} proves~\eqref{moments:plane-bound} +in finite volume. At fixed lattice weights, enlarge that volume. +The increment convergence from Proposition~\ref{prop:local-mixing} +and the uniform bounds pass the estimate to the plane; higher moments +also give convergence of every fixed finite moment. All constants +above are independent of the location and radius of the smearing. +\end{proof} + +\begin{lemma}[Nondegeneracy between two disks]\label{lem:nondegeneracy} +Let $U_1,U_2$ be two fixed disjoint round disks with disjoint closures, +and let $f_i\geq0$ be smooth functions supported compactly in $U_i$, +with $\int f_i=1$. Form their exact face-area averages on the dilated +lattice geometry of scale $R$. If $Y_R$ is the first average minus +the second, there is $c>0$ such that +\begin{equation}\label{moments:nondegeneracy} + \E Y_R^2\geq c +\end{equation} +for all sufficiently large $R$, in the plane and in sufficiently large +finite free volumes. The bound is uniform under translations of the +fixed arrangement. +\end{lemma} + +\begin{proof} +Choose two disjoint nested annular collars around $\supp f_1$ inside +$U_1$, avoiding $\supp f_2$. Prescribe an outer good $B$-plus cut and +an inner good $B$-minus cut. Successive applications of +Lemma~\ref{lem:buffer-circuits} in these separated buffers give their +joint probability at least $c_2>0$, uniformly in $R$ large enough for +rounding. Make the choices by the stopped searches following +Lemma~\ref{discrete:online}; the event and the selected cuts +depend on first spins and cell statuses, and do not prescribe any +second-spin labels. + +By Lemma~\ref{lem:collar-switch}, conditional on those variables there +is a second-spin component in the intervening collar whose fair label +flip changes every height in the inner protected region by $4$ in +absolute value relative to the exterior of the outer cut. Choose the +component measurably using a fixed ordering, and condition on all its +other labels. The cuts, their event, and all weights of $Y_R$ are +unchanged by this flip. Exact unit mass in the first disk and zero +weight in the collar mean that the two values of $Y_R$ differ by $4$. +A fair pair of real numbers at distance $4$ has variance $4$ and +second moment at least $4$. Averaging over the cut event yields +$\E Y_R^2\geq4c_2$ in finite volume. The fourth-moment bound in +Proposition~\ref{prop:plane-moments} allows passage of these second +moments to the plane. This proves the claim. +\end{proof} + +\subsection{Exact area interpolation} + +Let $Q_{\delta,u}$ be the hexagonal face centered at $u\in\delta\T$. +For a bounded compactly supported test $f$, use precisely +\begin{equation}\label{moments:area-weights} + w_{\delta,f}(u)=\int_{Q_{\delta,u}}f(z)\,\dd z, + \qquad + \langle h_\delta,f\rangle + =\sum_u w_{\delta,f}(u)h_\delta(u). +\end{equation} +This identity follows from the piecewise constant extension in the +problem, including its zero extension outside the discrete domain. +For tests supported inside that domain the tessellation gives the +exact, rather than asymptotic, identities +\[ + \sum_u w_{\delta,f}(u)=\int f, + \qquad \sum_u|w_{\delta,f}(u)|\leq\|f\|_{L^1}, + \qquad |w_{\delta,f}(u)|\leq\frac{\sqrt3}{2}\delta^2\|f\|_\infty. +\] +In the plane these hold for every compactly supported test. A test +supported in a disk of physical radius $r$, with +$\|f\|_1\leq A$ and $\|f\|_\infty\leq Ar^{-2}$, therefore has +smearing weights at radius $a=r/\delta+O(1)$ with a constant multiple +of the same weight bound. For any fixed physical geometry the +condition $a\geq1$ holds once the mesh is small. Reflection in a +lattice symmetry takes each face to its reflected face, so this +interpolation is exactly equivariant under every site reflection used +below. A zero-integral test gives a zero-total smearing at every mesh. + +In particular, on a fixed compact subset of a bounded domain, +Proposition~\ref{prop:smearing} bounds a normalized radius-$r$ average +by $C_p(1+\sqrt{\log(1/r)})$, with fixed geometry and the mesh sent +to zero first. Finite sums of such localized smearings obey the same +bounds by the triangle inequality. If the radius is a fixed small +fraction of the distance to a bounded trace, the right side of +\eqref{moments:smearing-bound} is uniformly bounded, even as both +physical scales subsequently tend to zero. Finally, +Proposition~\ref{prop:plane-moments} gives a uniform bound for each +fixed bounded family of zero-total smooth tests and their dilations. +These assertions use ordinary Euclidean area weights throughout. + +The class hypothesis~\eqref{moments:class-central} has deliberately +not been asserted for any spin-pinned ensemble. The parity-class +admissibility and central mass required in that setting will be proved +in Proposition~\ref{prop:pin-moments} before +Lemma~\ref{lem:midpoint-amplification} is applied there. diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/04-plane.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/04-plane.tex new file mode 100644 index 0000000000000000000000000000000000000000..615936ab4d157481101f864aaea731b5abad9fc3 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/04-plane.tex @@ -0,0 +1,765 @@ +\section{Reflection and the plane normalization} +\label{sec:plane} + +Throughout this section the law is the free plane pair obtained in +Proposition~\ref{prop:local-mixing}, with the fixed weight +$x\in[1/\sqrt2,1]$. Only its original nearest-neighbor interaction is used +for reflection; no reflection symmetry of the auxiliary cell variables is +needed. Write $\xi_u=H(u)-H(0)$ for its height increments. If +$f\in C_c^\infty(\R^2)$ has integral zero, set +\[ + H_\delta(f)=\sum_{u\in\T}w_{\delta,f}(u)H(u),\qquad + w_{\delta,f}(u)=\int_{\delta(u+V)}f(z)\dd z, +\] +where $V$ is the closed unit-mesh hexagonal face centered at zero, with +boundaries ignored in integrals. The faces $u+V$ tile the plane. In +particular, $\sum_u w_{\delta,f}(u)=\int f=0$, so the statistic is +independent of the additive lift. All these finite sums are centered by +height reflection. We will show that their covariances converge to a +positive multiple of the plane Green form, with the same constant along +every mesh sequence. We then use this covariance to show that a Laplace +test supported strictly on one side of a reflection line has covariance +with its reflected test tending to zero. Reflection positivity will +interpret this as a vanishing reflection seminorm, which +Section~\ref{sec:pins} will use to transfer the Laplace identity through +separated pinning conditions. + +Use Euclidean coordinates, and put +\[ + e_1=(1,0),\qquad e_2=(1/2,\sqrt3/2),\qquad + P=\frac{2\pi}{\sqrt3},\qquad + \T^*=\{(2\pi m,P(2n-m)):m,n\in\Z\}. +\] +The reciprocal torus is $\widehat\T=\R^2/\T^*$, with characters +$u\mapsto e^{ip\cdot u}$. Small neighborhoods of its origin always use +their Euclidean representatives. We use +$\widehat f(p)=\int e^{-ip\cdot z}f(z)\dd z$ for the continuum Fourier +transform. + +The covariance statement below is the output of the spectral argument. +Its coefficient will be fixed by a full scalar cutoff limit, after the +possible subsequential spectra have been identified. The proof is completed +in the final subsection; the reflection-null insertion then follows from it. + +\begin{proposition}[Plane covariance and normalization] +\label{prop:plane-covariance} +There is a constant $v=v(x)\in(0,\infty)$, depending only on the fixed +weight $x$, such that for every pair of real zero-integral tests +$f,g\in C_c^\infty(\R^2)$, +\begin{align} + \lim_{\delta\downarrow0}\E[H_\delta(f)H_\delta(g)] + &=\frac{v}{(2\pi)^2} + \int_{\R^2}\frac{\widehat f(p)\overline{\widehat g(p)}}{|p|^2} + \dd p \label{plane:eq:covariance}\\ + &=\frac{v}{2\pi}\iint_{\R^2\times\R^2} + f(z)\log\frac1{|z-w|}\,g(w)\dd z\dd w. \notag +\end{align} +The conclusion also holds for zero-integral tests converging in +$C_c^\infty$ with a common compact support. +\end{proposition} + +\subsection{Reflection positivity and normal translation} + +The row-conditioning proof below is the site-reflection construction +of \cite[Section~3, example~5]{FILS1978} specialized to the present edge law. +We include the normal-translation argument because positivity of that +translation, not only reflection positivity of the field, is needed +for the nonnegative Cauchy mixture. + +\begin{proposition}[Positive normal transfer] +\label{prop:reflection-transfer} +Let $\ell$ be any row of lattice sites parallel to one of the three +unoriented nearest-neighbor directions, and choose one of its closed +half-planes. The plane pair is reflection positive across $\ell$. +The assertion remains valid after adjoining any finite collection of fields +\begin{equation} + \label{plane:eq:phases} + Z_s(u)=U_s\exp\{is(H(u)-H(o))\}, +\end{equation} +where the $U_s$ are independent unit-circle Haar variables, independent of +the pair, and $o$ is any anchor. + +More precisely, let $\theta_\ell$ act on observables by spatial reflection, +and take local functions supported in the chosen half-plane, whose +height differences are evaluated along paths in that half-plane. Then +\[ + \langle F,G\rangle_\ell + =\E\big[\overline{\theta_\ell F}\,G\big] +\] +is a positive semidefinite Hermitian form. In its quotient completion, +translation farther into the half-plane by the pure normal vector of +length $\sqrt3$ is a positive self-adjoint contraction $S$. Unit +translation along the row is a commuting unitary $U$. At mesh $\delta$ +the normal step is $\sqrt3\delta$. +\end{proposition} + +\begin{proof} +Take first a reflection-symmetric finite free volume, chosen so that its +intersection with the row is connected and contains the observables under +consideration. No edge of the triangular lattice jumps across a row of +sites. Conditional on the row spins, the two strict sides therefore have +independent, reflected-identical laws: every original edge weight belongs +to a single side together with its row boundary. Row spins determine +relative row heights. If phases are present, condition also on their +values at one row anchor. On each side the other phases are determined +from those anchor phases and the increments on that side. Their +conditional Haar law at the row anchor is independent of the spins, even +if the original anchor $o$ was elsewhere. Consequently +\[ + \E\big[\overline{\theta_\ell F}\,F\big] + =\E\left[\left|\E[F\mid\text{row spins and row phases}]\right|^2\right] + \ge0. +\] +The plane limit gives the same inequality for local functions. Ordinary +$L^2$ approximation is also allowed, since +$|\langle F,G\rangle_\ell|\le\|F\|_2\|G\|_2$. +Changing the anchor or translating the configuration multiplies each +$U_s$ by a unit complex number determined by the increments. Conditional +Haar measure is unchanged. This proves stationarity and all the lattice +reflection symmetries also for the augmented law. + +For the operator statement take $\ell=\{y=0\}$ and the upper half-plane. +A site has coordinates $(m+n/2,n\sqrt3/2)$. Reflections in $y=0$ and +$y=\sqrt3/2$ send its integer coordinates respectively to +$(m+n,-n)$ and $(m+n-1,2-n)$. Thus both are site-row reflections, and their +composition gives the pure normal translation $a=(0,\sqrt3)$. +Let $T$ denote translation of observables by $a$. Stationarity and +$\theta_\ell T=T^{-1}\theta_\ell$ imply +\[ + \langle TF,G\rangle_\ell=\langle F,TG\rangle_\ell. +\] +Furthermore $TF$ is supported above the halfway row $y=\sqrt3/2$, and +reflection of $TF$ in that row is $\theta_\ell F$. Reflection positivity +at that row gives $\langle F,TF\rangle_\ell\ge0$. + +Boundedness must be proved before taking the quotient. Put +$a_n=\langle T^nF,T^nF\rangle_\ell^{1/2}$. Symmetry and reflection +Cauchy--Schwarz yield +\[ + a_n^2=\langle T^{n-1}F,T^{n+1}F\rangle_\ell + \le a_{n-1}a_{n+1}\quad(n\ge1), + \qquad a_n\le\|F\|_2. +\] +If $a_0=0$, the first inequality gives $a_1=0$. Otherwise an increase +$a_1>a_0$ would, by log-convexity, force geometric growth, contradicting +the second inequality. Hence $\|TF\|_\ell\le\|F\|_\ell$. +The operator descends to the quotient and extends to a bounded symmetric +positive operator on its completion, hence to a positive self-adjoint +contraction $S$. Tangential translation preserves the form and has an +inverse with the same property. It therefore gives a unitary $U$; +$U,U^{-1}$ commute with $S$. Rotation by $\pi/3$ and $2\pi/3$, and +translation of the base row, give exactly the same construction in all +three directions. +\end{proof} + +\subsection{The increment spectrum and its Cauchy representation} + +\begin{lemma}[Punctured spectral measure] +\label{plane:lem:spectrum} +There is a positive, locally finite measure $C$ on +$\widehat\T\setminus\{0\}$, invariant under the lattice rotations and +reflections, such that every finitely supported real array $(b_u)$ with +$\sum b_u=0$ satisfies +\begin{equation} + \label{plane:eq:spectrum} + \E\left|\sum_u b_uH(u)\right|^2 + =\int\left|\sum_u b_ue^{ip\cdot u}\right|^2 C(\dd p). +\end{equation} +There is no invariant random linear tilt term. Moreover, for some +$r_0>0$ and $K<\infty$, +\begin{equation} + \label{plane:eq:annuli} + C\{r\le|p|\le2r\}\le K\quad(00). +\end{equation} +\end{lemma} + +\begin{proof} +Let $V_u$ be ordinary unitary translation on the plane probability space. +Lemma~\ref{spectra:unitary}, applied to the two basis translations, +constructs their scalar covariance measures $\mu_{a,b}(\dd p)$ on +$\widehat\T$. Write $P_0$ for the common invariant projection. +All increments belong to $L^2$, since +$|\xi_u|$ is bounded by the graph distance from zero to $u$. The cocycle +identity gives +\[ + \xi_{u+v}=\xi_v+V_v\xi_u, + \qquad (V_v-I)\xi_u=(V_u-I)\xi_v. +\] +Put $d_u(p)=e^{ip\cdot u}-1$. The polynomial covariance identity in +Lemma~\ref{spectra:unitary} transfers the cocycle relation to the scalar +measures. On a patch where $d_v\ne0$, it gives +$\mu_{\xi_u,\xi_w}=\overline{d_u}d_w +\mu_{\xi_v,\xi_v}/|d_v|^2$. Division is made first on compact +subpatches where the denominator is bounded below. Thus define there +\[ + C(\dd p)= + \frac{\mu_{\xi_v,\xi_v}(\dd p)} + {|e^{ip\cdot v}-1|^2}. +\] +The definitions agree on overlaps. The two choices $v=e_1,e_2$ cover +the punctured torus; on every compact subset their denominators are +bounded below on a finite cover. This proves local finiteness and +\eqref{plane:eq:spectrum} for the part orthogonal to $P_0$. + +The remaining projected cocycle is additive: +$P_0\xi_u=A\cdot u$ for some random vector $A\in L^2$. +For a smooth compactly supported $f$ of integral zero, use the exact +face weights for $R^{-2}f(z/R)$ at unit mesh. Their first lattice moment is +\[ + \sum_u u\int_{u+V}R^{-2}f(z/R)\dd z + =R\int zf(z)\dd z+O(1), +\] +where the deterministic error is bounded because $|u-z|$ is bounded +on $u+V$. Orthogonal projection and Proposition~\ref{prop:plane-moments} +bound the $L^2$ norm of the dot product of $A$ with this vector uniformly +in $R$. Divide by $R$ and let $R\to\infty$. Choosing two such $f$ with +independent first moments proves $A=0$. Orthogonality rules out any +cancellation between this tilt and other spectral components. +Uniqueness of the local construction of $C$ gives its stated symmetries. + +For the annular estimate choose a real smooth bump $b$ with integral one +and support so small that $\widehat b$ has no zero on $|p|\le2$. +The tests $f_1=\partial_1b$ and $f_2=\partial_2b$ have integral zero, and +$|\widehat f_1|^2+|\widehat f_2|^2$ is bounded below on +$1\le|p|\le2$. Let $b^{(r,j)}_u$ be the unit-face weights for +$r^2f_j(rz)$. Their absolute sums are bounded and their largest +absolute values are $O(r^2)$; their supports have radius $O(r^{-1})$. +For $1\le|p|\le2$, +\[ + \sum_u b^{(r,j)}_ue^{irp\cdot u}\longrightarrow\widehat f_j(-p) + \quad\text{uniformly as }r\downarrow0. +\] +Indeed replacing the face center by a point in its face changes the +exponential by $O(r)$ uniformly here. Apply +Proposition~\ref{prop:plane-moments} and \eqref{plane:eq:spectrum} to +the two weights. Their squared transforms bound below a positive +constant on $r\le|p|\le2r$, proving the first assertion in +\eqref{plane:eq:annuli} for small $r$. Local finiteness handles any +remaining compact range of radii. Summation over dyadic annuli gives +the second assertion. +\end{proof} + +Restrict translations to the rectangular sublattice generated by $e_1$ +and $(0,\sqrt3)$. Its reciprocal torus has centered rectangle +\[ + \mathcal R=[-\pi,\pi)\times[-P/2,P/2). +\] +The projection $\pi:\widehat\T\to\mathcal R$ is a two-sheeted covering. +The preimages of zero are zero and the nonzero alias $a_*=(0,P)$ on +$\widehat\T$. Let $C'=\pi_*C$, with the value of $C$ at the omitted +origin set to zero when interpreting this pushforward. +For $00$, +\begin{equation} + \label{plane:eq:weighted-nu} + \int_{0<|k|<\kappa}|k|\,\nu(\dd k,\dd s)<\infty. +\end{equation} +The physical punctured line $k=0$ near zero has zero $C$ mass, and +$C\{a_*\}=0$. These conclusions hold before any rescaling limit is taken. +The analogous assertions hold in each of the three rotated charts. +\end{lemma} + +\begin{proof} +Take $F=\xi_{e_1}$, an observable on the horizontal reflection row. +Apply the scalar construction of Lemma~\ref{spectra:transfer} to the +commuting $U,S$ from Proposition~\ref{prop:reflection-transfer}. +It gives a finite positive measure $\gamma(\dd k,\dd\lambda)$ on the +unit circle times $[0,1]$ such that, for every $m\in\Z$ and $j\ge0$, +\[ + \E[F\,V_{me_1+j(0,\sqrt3)}F] + =\langle F,U^mS^jF\rangle_\ell + =\int e^{imk}\lambda^j\,\gamma(\dd k,\dd\lambda). +\] +Reflection in the base row gives the same expression with $|j|$ for +negative $j$. Put $\lambda=e^{-\sqrt3s}$, interpreting $\lambda=0$ as +$s=\infty$. The $j$th Fourier coefficient of $Q_s$ is +$e^{-\sqrt3s|j|}$, including both endpoints. Uniqueness of Fourier +coefficients of finite measures on the rectangular torus identifies +the ordinary spectral measure of $F$ with this mixture. +By \eqref{plane:eq:spectrum} that measure is +$|e^{ik}-1|^2 C'(\dd k,\dd l)$. Dividing by this strictly positive +factor on $k\ne0$ gives \eqref{plane:eq:mixture} and local finiteness +of $\nu$ there. +Since $Q_s$ has total mass one, the left side of +\eqref{plane:eq:weighted-nu} equals +$\int_{0<|k|<\kappa}|k|\,C'(\dd k,\dd l)$. +Near the physical origin this is finite by \eqref{plane:eq:annuli} and +$|k|\le|p|$; its remaining preimage has finite mass by local finiteness +on the physical torus away from zero. This includes a neighborhood of +$a_*$ and does not require any estimate on horizontal bands near zero. + +For the physical line take a compact segment of $k=0$ in a small +punctured disk and rotate it through $\pi/3$. Its coordinates become +$(k',l')=(-\sqrt3l/2,l/2)$: both are nonzero, and the image is a +nonvertical graph away from $l'=0$. For each fixed $k'$ its normal +section is a singleton outside zero. Every $Q_s$ assigns zero mass +to this singleton: $Q_s$ is nonatomic for $s>0$, including $s=\infty$, +while $Q_0$ is supported at zero. Applying \eqref{plane:eq:mixture} +and then positivity of the pushforward gives zero mass to the rotated +segment, hence to the original segment. Countably many segments cover +the punctured line. +For the alias, rotation sends $(0,P)$ to $(-\pi,P/2)$. +On the rectangular torus this point has nonzero tangential and nonzero +normal coordinates. The same mixture argument gives zero mass to that +point. Projection can only add mass, so invariance under rotation yields +$C\{a_*\}=0$. In particular this argument does not identify the two +boundary representatives of the rectangle on the physical torus. +Rotating the entire construction proves the assertions for the other +row directions. +\end{proof} + +\subsection{A summable dispersion defect} + +The unperiodized Cauchy kernel with $s=|k|$ has density +$|k|/\{\pi(k^2+l^2)\}$. We next show that only mixing mass near this +relation survives at small frequencies. The three mirror directions +will then determine the tangential measure as well. The key estimate +comes from averaging a fourth angular harmonic, whose rotational average +vanishes but whose Cauchy average measures the deviation from $s=|k|$. + +For centered coordinates write +\[ + \chi(k,l)=\cos(4\arg(k+il)) + =1-\frac{8k^2l^2}{(k^2+l^2)^2},\qquad (k,l)\ne0, +\] +and put +\[ + D(k,s)=\left(\frac{|k|-s}{|k|+s}\right)^2\quad(s<\infty), + \qquad D(k,\infty)=1. +\] + +\begin{lemma}[Angular identity and summable defect] +\label{plane:lem:defect} +Uniformly for $s\in[0,\infty]$ and sufficiently small $k\ne0$, +\begin{equation} + \label{plane:eq:poisson} + \int\chi(k,l)Q_s(\dd l)=D(k,s)+O(|k|). +\end{equation} +For some fixed $\kappa>0$, +\begin{equation} + \label{plane:eq:defect} + \int_{0<|k|<\kappa}D(k,s)\,\nu(\dd k,\dd s)<\infty. +\end{equation} +There is also $K_1<\infty$ such that, for all sufficiently small $r>0$, +\begin{equation} + \label{plane:eq:bands} + \nu\{r\le|k|\le2r\}\le K_1. +\end{equation} +\end{lemma} + +\begin{proof} +Put $a=|k|$. The analytic function +$((a+iz)/(a-iz))^2$ is bounded in the upper half-plane, has boundary +real part $\chi(a,l)$, and has real value $((a-s)/(a+s))^2$ at $z=is$. +The Poisson formula therefore gives the exact line identity +\begin{equation} + \label{plane:eq:line-poisson} + \int_\R\chi(a,l)\frac{s\dd l}{\pi(s^2+l^2)} + =\left(\frac{a-s}{a+s}\right)^2\quad(00,\ |l|\le P/2}\sum_{n\ne0}p_s(l+nP)<\infty. +\] +Indeed for $s\le P$ use $|l+nP|\ge P(|n|-1/2)$ and sum the +square tail; for $s>P$ the $O(s/P)$ terms with $|n|\le2s/P+1$ +are each at most $1/(\pi s)$ and the remaining terms have a summable +$s/(nP)^2$ bound. The difference between the periodized and line +integrals of $f_a$ is at most +\[ + 4\pi M_Pa+ + \int_{|l|>P/2}f_a(l)p_s(l)\dd l + \le4\pi M_Pa+32a^2/P^2. +\] +This proves \eqref{plane:eq:poisson} uniformly for finite positive $s$. +For $s=0$ it is exact; for $s=\infty$ use the uniform density and +$\int f_a\le4\pi a$. + +Integrate \eqref{plane:eq:poisson} over +$\epsilon<|k|<\kappa$. Its error is bounded independently of +$\epsilon$ by \eqref{plane:eq:weighted-nu}. +Replacing the projected integral by the physical integral inside +$|p|<\kappa$ changes it by a bounded amount: the remaining physical +region, including the other sheet, has finite mass away from zero. +Thus it suffices to bound above +\[ + \int_{\epsilon<|p|<\kappa,\ |k|>\epsilon} + \chi(k,l)\,C(\dd p). +\] +The integral over the full radial annulus is exactly zero, since +$\sum_{j=0}^5\cos(4(\arg p+j\pi/3))=0$ and $C$ is rotation invariant. +In the deleted cap $|k|\le\epsilon$, the negative part of $\chi$ is +confined to $|l|<(1+\sqrt2)|k|$, hence to +$\epsilon<|p|0 +\] +when $r$ is small. Equation~\eqref{plane:eq:mixture} therefore bounds +the remaining $\nu$ mass by a constant times +$C'\{r\le|k|\le2r,\ |l|\le2r\}$. The physical-origin preimage +lies in a fixed number of annuli of scale $r$, and the alias preimage +has bounded finite mass. This proves \eqref{plane:eq:bands}. +\end{proof} + +\begin{lemma}[Endcaps] +\label{lem:endcaps} +After decreasing $r_0$ if necessary, there is $K_3<\infty$ such that +\begin{equation} + \label{plane:eq:endcaps} + C\{b<|p|\le2b,\ |k|\le h\}\le K_3\frac hb + \qquad(00$, by +$1/(2\pi|l'|)\le K/b$; its folded tails are bounded by $M_P$. +The uniform endpoint obeys the same bound, and the $s=0$ atom misses +the interval. The relevant horizontal band has bounded $\nu$ mass +by \eqref{plane:eq:bands}, enlarging by finitely many dyadic bands +if necessary. Apply \eqref{plane:eq:mixture} and note that projection +adds nonnegative mass to the rotated physical cap. This proves +\eqref{plane:eq:endcaps}. Applying the bound with $b=\delta b_0$ +and $h=\delta h_0$, then sending $h_0\downarrow0$, proves the last +assertion for every vague limit; continuous cutoff majorants justify +passage to such limits. +\end{proof} + +\subsection{The full spectral scaling limit} + +For $\delta>0$ rescale a fixed small physical neighborhood of zero by +$p\mapsto p/\delta$, and denote its image measure by $C_\delta$. +On every fixed compact subset of $\R^2\setminus\{0\}$ this is +well defined for small $\delta$. Equation~\eqref{plane:eq:annuli} +gives local boundedness and hence subsequential vague compactness. + +\begin{lemma}[Form of every subsequential spectrum] +\label{plane:lem:subsequences} +Every vague subsequential limit is +\begin{equation} + \label{plane:eq:subsequence} + M(\dd p)=c\frac{\dd p}{|p|^2} +\end{equation} +for some finite $c\ge0$, at this point possibly depending on the +subsequence. This identity holds on the entire punctured plane, +including the tangential zero lines. +\end{lemma} + +\begin{proof} +Fix $00$ put +\begin{equation} + \label{plane:eq:cutoff} + J(h)=\int Q(p)\chi(k,l) + [q_0(|p|/h)-q_0(k/h)]\,C(\dd p). +\end{equation} +Each integrand vanishes near zero and has compact support in the +physical chart, so this is a finite integral. +We first show that $J(h)$ has a full limit as $h\downarrow0$. +Split its bracket as +\[ + [q_0(|p|/h)-1]+[1-q_0(k/h)]. +\] +The first term has integral zero by sixfold rotation, since its other +factors except $\chi$ are radial and it vanishes near zero. +For the second term replace the physical cutoff $Q$ by the rectangular +strip $0<|k|<\kappa$ in \eqref{plane:eq:mixture}. The resulting error +has a limit by dominated convergence: in a sufficiently small physical +neighborhood of zero the cutoffs and centered coordinates agree; +all remaining contributions come from a finite measure away from +that origin, including the alias neighborhood. Their multipliers +are bounded and converge pointwise as $h\downarrow0$. On $k=0$ +the factor $1-q_0(k/h)$ is identically zero. + +For the strip contribution set +$A(k,s)=\int\chi(k,l)Q_s(\dd l)$. Equations +\eqref{plane:eq:poisson}, \eqref{plane:eq:defect}, and +\eqref{plane:eq:weighted-nu} give +\[ + |A(k,s)|\le D(k,s)+K|k|, + \qquad + \int_{0<|k|<\kappa}|A(k,s)|\,\nu(\dd k,\dd s)<\infty. +\] +Dominated convergence applied to +$\int(1-q_0(k/h))A(k,s)\nu(\dd k,\dd s)$ proves that the strip +contribution has a limit. Thus +\begin{equation} + \label{plane:eq:cutoff-full-limit} + L:=\lim_{h\downarrow0}J(h) +\end{equation} +exists, using only the summable defect and finite cutoff errors, +without any assumption about a spectral scaling limit. + +Now take any sequence along which $C_h\to c\dd p/|p|^2$. +In the rescaled variable the bracket in \eqref{plane:eq:cutoff} is +$q_0(|p|)-q_0(k)$, which vanishes on $|p|\le1/2$. +On a dyadic annulus $R<|p|\le2R$ with $R>10$, it is supported on +$|k|\le1$. Equation~\eqref{plane:eq:endcaps}, used at physical +scales $b=hR$ and horizontal width $h$, bounds that mass by $K/R$. +Summing dyadic annuli gives a uniform $O(1/R)$ tail, up to the edge +of the fixed support of $Q$. Vague convergence on the remaining +compact annulus therefore gives +\begin{align} + L&=c\int_{\R^2}\frac{\chi(k,l)}{|p|^2} + [q_0(|p|)-q_0(k)]\dd p \notag\\ + &=c\int_0^{2\pi}\cos(4u) + \int_0^\infty[q_0(r)-q_0(r|\cos u|)]\frac{\dd r}{r}\dd u + =-\frac\pi2c. \label{plane:eq:cutoff-value} +\end{align} +For completeness, for $t>0$ the inner radial integral with $t=|\cos u|$ +equals $\log t$: integrate first from $\varepsilon$ to $M$, change +variables in the second term, then use that $q_0=1$ near zero and +vanishes for large argument. Its absolute integral is bounded by +$K(1+|\log t|)$, which is integrable in $u$, justifying Fubini. +The angular value can be checked without a Fourier-series limit: +\[ + \int_0^{2\pi}\cos(4u)\log|\cos u|\dd u + =4\int_0^{\pi/2}\cos(4u)\log(\cos u)\dd u + =4\int_0^{\pi/2}\sin^2u\cos(2u)\dd u + =-\frac\pi2. +\] +The middle equality follows by integration by parts; the boundary +term $\sin(4u)\log(\cos u)$ vanishes at both ends. +Since $L$ was defined by a full limit, \eqref{plane:eq:cutoff-value} +fixes the same $c$ for every subsequence. Subsequence compactness +then gives full vague convergence. +\end{proof} + +\subsection{Euclidean area covariance and reflection-null insertions} + +\begin{proof}[Proof of Proposition~\ref{prop:plane-covariance}] +For the exact area weights define +$A_{\delta,f}(p)=\sum_uw_{\delta,f}(u)e^{ip\cdot u}$. +On every fixed compact set of $\zeta$, +\begin{equation} + \label{plane:eq:transform-limit} + A_{\delta,f}(\delta\zeta)\longrightarrow\widehat f(-\zeta) + \quad\text{uniformly}. +\end{equation} +Indeed the defining sum is the integral of $f(z)$ times the +exponential at its face center. Replacing that center by $z$ +changes the exponential by $O(\delta|\zeta|)$ on each face. +The total integral is exact, so no lattice-cell area factor remains. + +We record bounds that also control frequencies outside a fixed +rescaled annulus. For every integer $N\ge1$, in a fixed small +physical neighborhood of zero, +\begin{equation} + \label{plane:eq:transform-bounds} + |A_{\delta,f}(p)|\le K_N + \min\left\{\frac{|p|}{\delta}, + (1+|p|/\delta)^{-N}\right\}, +\end{equation} +and on the complement of that neighborhood it is $O_N(\delta^N)$. +The first bound follows from exact zero total and +$\sum_u|w_{\delta,f}(u)|\,|u|=O(\delta^{-1})$. +For the other bounds, let $\Delta_e$ denote a unit lattice difference +in a basis direction. Translation of faces gives +\[ + \sum_u|\Delta_e^Nw_{\delta,f}(u)| + \le\int_{\R^2}|\Delta_{\delta e}^N f(z)|\dd z + \le\delta^N\|\partial_e^N f\|_{L^1}. +\] +Discrete summation by parts therefore bounds +$|1-e^{ip\cdot e}|^N|A_{\delta,f}(p)|$ by this last quantity. +Near zero at least one of the two basis multipliers is at least +$a|p|$; away from zero on the reciprocal torus at least one is bounded +below on a finite compact cover. Together with +$|A_{\delta,f}|\le\|f\|_1$, these estimates prove +\eqref{plane:eq:transform-bounds}. Their constants are uniform for +a bounded smooth family with a common compact support. + +Equations~\eqref{plane:eq:spectrum} and +\eqref{plane:eq:annuli} now allow passage to the full Fourier integral. +For example the contribution of $|p|<\epsilon\delta$ to a variance +is $O(\epsilon^2)$ by the first bound in +\eqref{plane:eq:transform-bounds} and dyadic summation. +The contribution of $R\delta<|p|0$. +The covariance limit therefore rules out $c=0$. +All constructions have used only the fixed plane law at weight $x$; +there is no domain or approximation parameter in $v$. +\end{proof} + +\begin{proposition}[Reflection-null Laplace insertion] +\label{prop:reflection-null} +Fix one of the three row directions. Let $\ell_\delta$ be site rows +of $\delta\T$ converging to a line $\ell$ in that direction, and +choose the same side of each row. Suppose that real +$\varphi_\delta\to\varphi$ in $C_c^\infty(\R^2)$, with common +compact support lying on that side at a positive distance from +$\ell_\delta$ for all sufficiently small $\delta$. Put +$X_\delta=H_\delta(\Delta\varphi_\delta)$, using exact area weights. +Then +\begin{equation} + \label{plane:eq:reflection-null} + \|X_\delta\|_{\ell_\delta}^2 + =\E[(\theta_{\ell_\delta}X_\delta)X_\delta] + \longrightarrow0, + \qquad \sup_{\delta\text{ small}}\|X_\delta\|_{L^2}<\infty. +\end{equation} +This holds also in every finitely phase-augmented reflection space of +Proposition~\ref{prop:reflection-transfer}. In particular, if +$Y_\delta$ is supported on the same side and has bounded reflection +norm, then +$\E[(\theta_{\ell_\delta}Y_\delta)X_\delta]\to0$. +\end{proposition} + +\begin{proof} +All Laplace tests have integral zero. Reflection in a site row +permutes the hexagonal faces exactly, so +\[ + \theta_{\ell_\delta}X_\delta + =H_\delta\bigl(\Delta(\varphi_\delta\circ\theta_{\ell_\delta})\bigr) +\] +as zero-total increment observables. Their supports, including the +finitely many faces meeting the test supports, lie strictly on +opposite sides once $\delta$ is small. The tests and their reflections +converge smoothly on fixed compact sets. By +Proposition~\ref{prop:plane-covariance}, the limit of their covariance is +\[ + \frac{v}{(2\pi)^2}\int |p|^2\widehat\varphi(p) + \overline{\widehat{\varphi\circ\theta_\ell}(p)}\dd p + =v\int\nabla\varphi(z)\cdot + \nabla(\varphi\circ\theta_\ell)(z)\dd z=0, +\] +because the two supports are disjoint. Reflection positivity makes +the finite-mesh quantity a squared seminorm. The ordinary second +moments are bounded by Proposition~\ref{prop:plane-moments}, or by +Proposition~\ref{prop:plane-covariance}. Adjoining independent Haar +variables does not change the reflection norm of the phase-independent +$X_\delta$. Finally apply reflection Cauchy--Schwarz. Only the +reflection seminorm vanishes; an ordinary variance need not do so. +\end{proof} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/05-pins.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/05-pins.tex new file mode 100644 index 0000000000000000000000000000000000000000..73ba944afa691d3cd9028f626da354b2a640411a --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/05-pins.tex @@ -0,0 +1,936 @@ +\section{Separated pins and transfer to boundary brackets}\label{sec:pins} + +The reflection norm of a Laplace insertion tends to zero by +Proposition~\ref{prop:reflection-null}. We will transfer this identity to +upper and lower height laws whose boundary traces bracket zero. We do +this by cutting the pinned boundary into separated pieces and moving +those pieces to one side of the insertion. The same prescribed spins +can represent different integer heights on different pieces. We first +require the pinned sites within each piece to lie in one consecutive +pair of heights, then require these pairs to have the same integer +offset. Moment bounds and multiplicative comparisons of pin +probabilities control the motion. Local phase factors allow the +common-offset condition to be imposed after the pieces have been moved +back. + +All geometric lengths in this section are physical lengths. A window, +a gap, or an arrangement of separated sets is fixed before the mesh +tends to zero. + +An increment function supported in a disk means a function of the height +differences on edges in that disk, allowing a fixed arbitrarily small +enlargement for connecting paths. If $f$ is smooth, supported in the disk, +and $\int f=0$, the exact area pairing $H_\delta(f)$ is such a function: +its coefficients sum to zero, so paths in the enlarged disk express it +in terms of increments. Throughout the section put +\begin{equation}\label{pins:insertion-data} + X_\delta=H_\delta(\Delta\varphi),\qquad + F_\delta=\prod_{j=1}^q F_{j,\delta},\qquad + \varphi\in C_c^\infty(K_0),\qquad + \prod_{j=1}^q\|F_{j,\delta}\|_\infty\le C_F, +\end{equation} +where $\varphi$ is real, $K_0\Subset D$ is a disk, and $F_{j,\delta}$ is +an increment function in a disk $K_j\Subset D$. The spectator disks may +overlap each other, but have positive distance from a fixed neighborhood +of $K_0$. The empty product is allowed. + +\subsection{The boundary walk and the two brackets} + +Let $\gamma:\R/L\Z\longrightarrow\partial D$ be the positively oriented +arclength parametrization. In a fixed tubular neighborhood of +$\partial D$, let $\pi$ be normal projection followed by the coordinate +$\gamma^{-1}$, with values in $\R/L\Z$. This map exists because the +boundary is a $C^2$ embedded compact curve. Write $d_L$ for circular +distance in $\R/L\Z$. + +\begin{lemma}[Inner boundary walk]\label{lem:boundary-walk} +There is a closed walk $S_{0,\delta}$ of adjacent triangular-lattice face +centers, with repeated vertices and edges allowed, whose vertex set is +exactly the boundary face layer $\partial F_\delta$. Its parametrized +trace is within $O(\delta)$ of the boundary cycle in traversal order. +Every free interior site lies in a bounded face of this walk, with +winding number one, and every interaction path from a free interior site +to an exterior site meets its vertex set. + +For small $\delta$, $\pi$ is defined on the walk, its degree is one, +and the following fixed-scale assertions hold. For each $b>0$, the +number of subwalks with disjoint traversal-time interiors and projected +diameter at least $b$ is bounded independently of sufficiently small +$\delta$. Every proper projected boundary arc is traversed from end +to end by a subwalk, up to $o(1)$ errors at its endpoints. These +assertions do not require a bound on the length of $S_{0,\delta}$ or +on its number of crossings of a line. +\end{lemma} + +\begin{proof} +Associate to each successive edge of the honeycomb boundary cycle its +incident interior face. At a trivalent boundary vertex, the two such +faces are either the same, or meet across the third edge. Joining their +centers therefore gives the required walk after constant steps are +removed. This also proves the $O(\delta)$ position bound. Every face +adjacent to the boundary appears. An edge path leaving the enclosed +face set first passes through such a face, proving separation. + +One can deform each boundary edge to the corresponding center path in +the union of its incident faces and the stars of its endpoints. This +deformation never meets a nonboundary interior face center. Consequently +the original cycle and the center walk have the same winding number +around every free interior center. In particular those centers lie in +bounded complementary components of the walk. + +Use the uniformly convergent parametrizations in +Definition~\ref{def:approximation}, and parametrize the center walk in +the corresponding traversal order. The position error still tends to +zero uniformly. Normal projection is uniformly continuous on a smaller +closed tubular collar, so the projected walks converge uniformly to the +corresponding degree-one parametrization of the boundary circle. They +have degree one for fine mesh by homotopy in that circle. For any fixed +$b$, uniform continuity of the limiting parametrization gives +$\omega(b)>0$ such that a projected excursion of diameter $b$ needs at +least $\omega(b)$ units of parameter time, once the uniform error is +smaller than $b/4$. Disjoint excursion intervals therefore number at +most $1/\omega(b)$, after normalizing the parameter circle to length one. +Finally lift the projected walk to the real line. Its net change in +one traversal is $L$. Before a first visit to the right endpoint of +a lifted proper arc, take its last visit to the left endpoint. The +intervening subwalk stays in that interval and crosses it. Discrete +endpoints introduce only $o(1)$ errors. This proves the final assertion. +\end{proof} + +In the following, the graph of a walk means its image with all traversed +edges. Removing a set of its vertices removes the incident edges too. +Additional lattice adjacencies could only merge the components used +below, so the specified graph convention is harmless but convenient. + +Fix a finite collection $\mathcal L$ of horizontal levels that meet +$D$ and are regular values of the vertical coordinate on $\partial D$. +We use nonempty collections, so their boundary intersection set is +nonempty. Their +intersections with $\partial D$ are finite: each is isolated by +transversality, and their set is compact. Let $\mathcal C\subset\R/L\Z$ +be the finite set of projected intersection coordinates. Choose +$\epsilon>0$ so small that the arcs +$\{d_L(s,c)<2\epsilon\}$, $c\in\mathcal C$, are disjoint and every +complementary arc has nonempty interior. These arcs specify fixed +exceptional windows. The pins will be exact off the smaller windows +$d_L(\pi(\cdot),\mathcal C)<\epsilon$. + +Remove the vertices of $S_{0,\delta}$ with +$d_L(\pi(v),\mathcal C)<\epsilon/2$. Among the remaining graph +components retain those that contain a vertex with +$d_L(\pi(v),\mathcal C)\ge\epsilon$; denote their union by +$A_{\delta,\epsilon}$. Thus every skeleton vertex outside the +$\epsilon$ windows belongs to $A_{\delta,\epsilon}$, while this set +avoids the $\epsilon/2$ windows. + +\begin{lemma}[Bounded label count]\label{pins:label-count} +At fixed $\mathcal L$ and $\epsilon$, the number of connected +components used to form $A_{\delta,\epsilon}$ is bounded by a constant +$M(\mathcal L,\epsilon)$ independent of sufficiently small $\delta$. +\end{lemma} + +\begin{proof} +A retained component contains a traversal segment beginning next to a +removed interval and reaching distance at least $\epsilon$ from +$\mathcal C$, without visiting a removed vertex. Indeed use a maximal +portion of the original traversal outside the removed set that visits +a deep vertex. Its projection travels a distance at least +$\epsilon/2-o(1)$. For distinct graph components these portions have +disjoint time interiors, because a shared traversal vertex would join +the components. Lemma~\ref{lem:boundary-walk} bounds their number. +The same proof, using any fixed smaller constants in the two thresholds, +covers rounding at endpoints. It puts no bound on the number of short +excursions confined to the windows. +\end{proof} + +\begin{definition}[Filled brackets]\label{def:brackets} +In the plane spin law impose $B=+$ on all of $S_{0,\delta}$ and $W=+$ +on $A_{\delta,\epsilon}$. Anchor the height to zero at one doubly pinned +vertex, and restrict it to the original interior. Its law is the +\emph{upper filled bracket}, denoted $H_\delta^{+,\epsilon}$. For the +\emph{lower filled bracket} $H_\delta^{-,\epsilon}$ interchange the +colors: impose $W=+$ on the whole skeleton and $B=+$ on +$A_{\delta,\epsilon}$, with the same zero anchor. +\end{definition} + +These finite pin events have positive probability. In a finite free +ambient graph the constant zero height is an admissible extension; +Proposition~\ref{prop:rare-pins}, or its deterministic enclosing-cut +comparison, keeps the finite event positive in the plane limit. All +plane conditionings below can equivalently be obtained by first taking +the ambient-volume limit at a fixed mesh. Local comparison gives this +limit, and division is only by a fixed positive finite-event probability +at that stage. + +\begin{lemma}[Integer traces and order]\label{pins:bracket-order} +The bracket traces are actual integer heights satisfying +\begin{equation}\label{pins:trace-intervals} + H_\delta^{+,\epsilon}\in\{0,1\},\qquad + H_\delta^{-,\epsilon}\in\{-1,0\} + \quad\hbox{on }S_{0,\delta},\qquad + H_\delta^{\pm,\epsilon}=0\quad\hbox{on }A_{\delta,\epsilon}. +\end{equation} +Conditional on either trace, the free interior has the original weighted +height Gibbs law. There is an ordered coupling +\begin{equation}\label{pins:height-sandwich} + H_\delta^{-,\epsilon}\le h_\delta\le H_\delta^{+,\epsilon} +\end{equation} +on every interior face. The bounded-trace smearing estimates of +Proposition~\ref{prop:smearing} apply to both brackets with constants +independent of the window sizes. +\end{lemma} + +\begin{proof} +The integer inverse image of $B=+$ is the union of the pairs +$4t+\{0,1\}$, whereas that of $W=+$ is the union of +$4t+\{-1,0\}$. A nearest-neighbor chain of constant first color cannot +leave its lifted pair, since different pairs have distance at least +three. Connectedness of $S_{0,\delta}$ and its zero anchor therefore +give precisely \eqref{pins:trace-intervals}; second-color plus pins +select the zero endpoint of the pair. This argument establishes the +integer branch, rather than merely its residue modulo four. + +Lemma~\ref{lem:boundary-walk} separates every free site from exterior +interactions. After conditioning on the skeleton heights, the +nearest-neighbor weights factor over the interior components and the +exterior; factors between fixed sites affect only the trace probability. +Lemma~\ref{lem:spin-lift} identifies each interior factor with the +weighted height law. Applying Lemma~\ref{lem:height-order} to each +fixed trace, and then averaging the resulting kernels, proves +\eqref{pins:height-sandwich}. All these traces have absolute value at +most one, so Proposition~\ref{prop:smearing} gives the last assertion. +In particular the upper mean is between zero and one, and the lower +mean between minus one and zero, by comparison with the flat laws. +\end{proof} + +Our target is the identity +\begin{equation}\label{eq:bracket-insertion} + \lim_{\delta\downarrow0} + \E\left[H_\delta^{\pm,\epsilon}(\Delta\varphi) + F_\delta\right]=0 +\end{equation} +for the local factors in \eqref{pins:insertion-data}, with the grid and +windows fixed. We will prove it under the separating geometric +hypotheses stated in Proposition~\ref{prop:bracket-insertion}: two grid +levels must bracket the insertion disk and miss the spectators, and the +remaining pieces in the intervening strip must separate to its two +sides in an oblique projection. This condition will let us move all the +other factors to one side of a reflection line while keeping the moved +pin sets separated. The next constructions provide the +integer and moment control needed to carry out those moves. + +\subsection{Opening gaps and checking the local lift} + +Choose two levels $\ell_-<\ell_+$ from $\mathcal L$ strictly below and +above $K_0$, respectively, and missing every spectator disk with a +positive margin. Let $\mathcal C_0\subset\mathcal C$ be their boundary +intersection coordinates. Fix $00$, and then take $\delta$ small enough that $r_\delta0$ under $P$. Expose the test +cut from the exterior and choose the collar cuts by their corresponding +stopped explorations. Lemma~\ref{pins:marker-checks} implies that +intersecting this event with $P_{\mathrm{loc}}$ still has probability +at least $c_0/2$ under $P$ for fine mesh. + +The pin checks can be read within the $U_i$, outside the entire test +search region. Conditional on the exterior record and on the actual +height layer of the test cut, its inside is the unconstrained weighted +height problem with a consecutive-pair trace. Subtract its possibly +random common offset. Since $\int f=0$, this does not change +$Y_\delta$. Proposition~\ref{prop:smearing}, using a finite partition +into smaller smearing balls if necessary, gives a fixed $M_0$ and a +conditional probability at least $1/2$ of $|Y_\delta|\le M_0$. +Consequently a central event $\mathcal A$, including all selected cuts +and checks and the condition $|Y_\delta|\le M_0$, has +\begin{equation}\label{pins:central-unpartitioned} + \Prob(\mathcal A\mid P_{\mathrm{loc}})\ge c_1>0, + \qquad \mathcal A\subset\{|Y_\delta|\le M_0\}. +\end{equation} + +Lemma~\ref{lem:collar-switch} supplies in each nonanchor collar a +weight-preserving involution shifting all its inner heights by $+4$ +or $-4$, relative to the exterior. The relevant component is chosen +from the first-color, status, and cut record, without using its fair +second-color label. Its flip preserves that record. All spins on +the protected inner and outer regions, all pin labels, and all local +checks remain unchanged. It also preserves $Y_\delta$ and its test-cut +record: the entire test search neighborhood lies outside $U_i$, in the +protected exterior of the switch. The disjoint collars give commuting involutions; +the $i$th one flips precisely the parity of $t_i$. These involutions +act on the augmented spin and status measure. The event $\mathcal A$ +records only the selected cuts, the checks, and the displayed bound on +$Y_\delta$; it does not fix the extra exterior heights used to estimate +its probability. It is therefore invariant under the involutions. +Each orbit has one equally weighted +member for every parity vector, so +\begin{equation}\label{pins:every-class-mass} + \Prob\bigl(|Y_\delta|\le M_0,\ \kappa=k + \mid P_{\mathrm{loc}}\bigr) + \ge 2^{-(m-1)}c_1\quad\text{for every }k. +\end{equation} +Marginalizing the statuses preserves this identity for the height +parity classes. The orbit calculation does not assert independence +after conditioning on the checks. When $m=1$ no collar switch is needed. + +The face-area weights of $f$ have bounded total absolute mass, and +coordinatewise rounding changes the associated linear statistic by +at most half that mass. Increase $M_0$ to absorb this bound. Apply +Lemma~\ref{lem:midpoint-amplification} with +\eqref{pins:every-class-mass} and the parity partition. It gives +\eqref{eq:pin-moments}, uniformly in the ambient volume. Exhaustion +at each fixed mesh gives the plane assertion; Fatou's lemma transfers +the moment bounds. With no obstacles use +Proposition~\ref{prop:plane-moments}. The construction uses only fixed +positive margins and finitely many requests, proving the stated +uniformity and the finite-collection version by H\"older's inequality. +\end{proof} + +\subsection{Normalized reflection bounds and analytic translation} + +A height difference between representatives of two obstacles is not +local to either obstacle. Its exponential can be split into two local +phase factors, one at each representative. We use the stationary +Haar-lift phases from Proposition~\ref{prop:reflection-transfer}: for any +fixed real frequency $\theta$, put +\begin{equation}\label{pins:haar-phase} + Z_\theta(v)=U_\theta\exp\{i\theta(H(v)-H(o))\}, +\end{equation} +with an independent uniform unit complex variable for every phase field +needed. Two factors from the same field share this auxiliary variable, +so +$Z_\theta(v)\overline{Z_\theta(w)} +=\exp\{i\theta(H(v)-H(w))\}$. +Changing the anchor is absorbed by Haar invariance. The joint spin, +increment, and phase law is reflection positive, and a phase value at a +site on one side of a row belongs to that side's algebra. Thus each +factor can move with its own obstacle, including when its balancing +factor lies on the other side of the row. + +For a site-row reflection $\vartheta$, use +$\langle A,B\rangle_\vartheta=\E[\overline{\vartheta A}B]$ on its +positive side, quotienting by null vectors. Pure normal translation +by $b_\delta=\sqrt3\,\delta$ is the positive self-adjoint contraction +$S_\delta$ of Proposition~\ref{prop:reflection-transfer}. + +\begin{lemma}[Normalized side norm]\label{pins:side-norm} +Suppose a family of checked obstacles and factors lies strictly on one +side of a site row. Their filled neighborhoods and all needed check +paths lie on that side; unbounded factors have free test neighborhoods +disjoint from the obstacle neighborhoods. If $A$ is a bounded product, +possibly including arbitrary Haar phases, times at most one smooth +zero-total insertion, then +\begin{equation}\label{pins:normalized-side-bound} + \left\|A\prod_i\frac{\ind_{P_i\cap C_i}}{p_{i,\delta}} + \right\|_\vartheta\le C. +\end{equation} +The bound is uniform on compact families with the stated margins. +\end{lemma} + +\begin{proof} +Let $J$ denote the product of the probabilities on this side. Squaring +the norm gives +\[ + J^{-2}\E\left[\overline{\vartheta A}A\, + \ind_{P_{\mathrm{loc}}\cap\vartheta P_{\mathrm{loc}}}\right]. +\] +The reflected arrangement consists of two copies of every obstacle, +all with disjoint filled neighborhoods. The strict row margin +separates the two copies. Their individual probabilities are the +same $p_{i,\delta}$, so \eqref{pins:multiplicative} bounds the +probability of the ordinary doubled pin event by $CJ^2$. +The checked event has no larger probability. If $A$ contains an +insertion $Y$, Proposition~\ref{prop:pin-moments} in this doubled +arrangement and Cauchy--Schwarz bound +$\E[|Y\,\vartheta Y|\mid P_{\mathrm{loc}}\cap +\vartheta P_{\mathrm{loc}}]$ by a constant. Bounded factors and +unit-modulus phases contribute only their uniform bounds. The +factor $J^2$ cancels exactly, proving the assertion. +\end{proof} + +For a related separating-line continuation, see +\cite[Section~7.1, Lemma~7.4]{DCKLM2026}. +Here we must also normalize by rare pin probabilities: +Lemma~\ref{pins:side-norm} supplies the bounded matrix elements before +the continuation is applied. The following argument proves the exact +version needed for these checked obstacles. + +\begin{lemma}[Analytic translation]\label{lem:analytic-translation} +Partition a finite arrangement of the preceding checked obstacles and +local factors into two families separated strictly in projection on a +lattice reflection normal $n$. At most one factor is an unbounded +zero-total insertion. Translate the high family by $sn$, and let +$M_\delta(s)$ be its plane expectation normalized by the product +$J_\delta$ of all individual ordinary pin probabilities, at lattice +normal-step translations. If +\[ + M_\delta(s_\delta)\longrightarrow0 +\] +for every $s$ in a nonempty open interval $I\subset(0,\infty)$ and +every lattice rounding $s_\delta\to s$, then $M_\delta(0)\to0$. +The same is true for a low family translated by $-sn$, and along any +converging sequence of other placements preserving the required margins. +\end{lemma} + +\begin{proof} +Choose $\eta>0$ smaller than the actual projection gap between the +enlarged supports. Back the high family up by +$\eta_\delta=N_\delta b_\delta\to\eta$, where $N_\delta$ is a +positive integer. There is still a fixed gap; choose a site row in +it, converging to a line in the limiting gap. Let $B_\delta$ be the +normalized high-side factor in this backed arrangement and let +$A_\delta$ be the reflected conjugate of the normalized low-side +factor. Lemma~\ref{pins:side-norm} gives +$\|A_\delta\|_\vartheta,\|B_\delta\|_\vartheta\le C$. +Individual $p_{i,\delta}$ are invariant under lattice translation +and reflection, so their product is the same throughout the motion. + +For $\Re z>-\eta_\delta$ set +\begin{equation}\label{pins:analytic-family} + f_\delta(z)=\int_{[0,1]} + \lambda^{(z+\eta_\delta)/b_\delta}\, + \gamma_{A_\delta,B_\delta}(\dd\lambda), +\end{equation} +where the finite cross measure is constructed in +Lemma~\ref{spectra:transfer}, with its circle variable integrated out. +For $\Re w>0$ use $\lambda^w=e^{w\log\lambda}$ on $\lambda>0$ +and give it value zero at $\lambda=0$. +Corollary~\ref{spectra:analytic} proves that this is holomorphic and +bounded by $\|A_\delta\|_\vartheta\|B_\delta\|_\vartheta$. +Thus $|f_\delta|\le C^2$, and all fine +meshes have the common domain $\Re z>-\eta/2$, which contains zero +as an interior point. + +At $s_\delta=m b_\delta\ge0$, the exponent in +\eqref{pins:analytic-family} is the positive integer $m+N_\delta$. +The transfer interpretation therefore gives the exact equality +$f_\delta(s_\delta)=M_\delta(s_\delta)$. This never evaluates a +zeroth spectral power at the kernel. Cauchy's estimates give a +uniform derivative bound on compact subsets of the common half-plane, +so converging lattice roundings sample the same limiting function. +Every sequence has a subsequence on which $f_\delta$ converges locally +uniformly to a bounded holomorphic function. It vanishes on $I$ by +hypothesis, hence throughout the half-plane by the identity theorem, +and in particular at zero. Subsequence extraction proves the claim +for the original sequence. + +Rigid translation preserves distances inside each family, and moving +the families apart increases their projection gap. The preliminary +backoff was smaller than that gap. Thin filled neighborhoods and +check paths can therefore be kept on their own sides at every step; +their reflected copies have the same separation. These observations +verify the side-norm hypotheses, including for convergent variations of +the other placements. Reversing $n$ proves the low-family version. +\end{proof} + +\subsection{The three-direction geometry and phase projection} + +Here is the precise geometry needed for the insertion identity. Put +\begin{equation}\label{pins:three-normals} + e=(0,1),\qquad u=(\sqrt3/2,1/2),\qquad + u'=(-\sqrt3/2,1/2). +\end{equation} +The levels $\ell_\pm$ chosen above strictly bracket $K_0$ and avoid +every spectator disk. After the boundary intersection gaps are opened, +each boundary group and each spectator support lies wholly above, +below, or between these levels. Call the outer families $T$ and $B$. +Require the middle family to split into $L$ and $R$ with, for some +$\kappa>0$, +\begin{equation}\label{pins:middle-geometry} + \sup_{z\in L}z\cdot u<\inf_{z\in K_0}z\cdot u-\kappa, + \qquad + \inf_{z\in R}z\cdot u>\sup_{z\in K_0}z\cdot u+\kappa. +\end{equation} +Suprema over a family mean over all its enlarged supports. Its +obstacle neighborhoods, check paths, and representative phases are +included in those supports. Empty families are omitted. Choose the +neighborhoods sufficiently thin to preserve these inequalities. +Overlapping spectator disks must belong to the same family and move +together. This geometry is used later only with $K_0$ and the strip +very small compared with their distance to all remaining supports. + +\begin{lemma}[A local choice of the grid]\label{pins:local-geometry} +Fix $z_0\in D$, $\overline{B(z_0,\rho)}\subset D$, and an integer +$q\ge0$. One can choose a finite grid of regular horizontal levels, +depending only on $z_0,\rho,q$, with the following property. If +$K_0\subset B(z_0,\rho/1000)$ and at most $q$ spectator disks of +radii less than $\rho/(1000(q+1))$ lie outside $B(z_0,\rho)$, two +grid levels give all the strict geometry in +\eqref{pins:middle-geometry}. The same grid works for any finite +number of such collections of spectator disks. +\end{lemma} + +\begin{proof} +Translate $z_0$ to zero for this geometric calculation. In each +interval $(\rho/40,\rho/20)$ and $(-\rho/20,-\rho/40)$ choose +$q+1$ regular levels with mutual distances exceeding +$\rho/(80(q+1))$. They exist because regular values are dense +and each candidate interval has length $\rho/40$. Their union is +the grid. A spectator's closed vertical projection has length less +than $2\rho/(1000(q+1))$, so it meets at most one level in either +candidate family. At least one level in each family therefore +avoids all $q$ disks, with a positive margin. These two levels +strictly bracket $K_0$. + +Every boundary point and middle-strip spectator point is outside +$B(0,\rho)$ and has $|y|<\rho/20$. Thus +$|x|>\sqrt{399/400}\,\rho$, and +$|(\sqrt3/2)x+y/2|>\rho/2$, with the sign of $x$. +A connected middle boundary arc or spectator disk cannot change this +sign. It consequently belongs wholly to $L$ or $R$, whereas the +$u$-projections of $K_0$ have absolute value at most $\rho/1000$. +Opening small intersection gaps and choosing sufficiently thin filled +neighborhoods preserves these strict inequalities. The construction +of the grid preceded the choice of the disks, proving the last assertion. +\end{proof} + +\begin{lemma}[Separated insertion]\label{pins:three-moves} +At fixed positive gaps satisfying \eqref{pins:middle-geometry}, and for +any product $\Psi_\delta$ of local Haar-phase factors at the +representatives with fixed frequencies, +\begin{equation}\label{pins:separated-identity} + J_\delta^{-1}\E\left[ + X_\delta F_\delta\Psi_\delta\ind_{P_{\mathrm{loc}}}\right] + \longrightarrow0. +\end{equation} +This holds for every converging lattice-rounded sequence of placements +with the stated strict separations. +\end{lemma} + +\begin{proof} +Figure~\ref{fig:pins-five-moves} records the successive separating +projections. Keep $X_\delta$ fixed and move all other factors, including +each check and each phase with its obstacle. First translate $T$ by $a_+e$ and +$B$ by $-a_-e$. Each is an entire extreme side across an existing +horizontal gap. Choose these two distances sufficiently large that +$T$ is strictly above $K_0$ and $B$ strictly below it in +$u$-projection. With \eqref{pins:middle-geometry}, the families +$Q_+=T\cup R$ and $Q_-=B\cup L$ are then strictly above and below +$K_0$, respectively, in that projection. + +Translate $Q_+$ by $bu$, with $b$ sufficiently large that it is +vertically above $K_0$ and below $K_0$ in $u'$-projection. Both +requirements are possible because +$u\cdot e=1/2$ and $u\cdot u'=-1/2$. Translate $Q_-$ by $-cu$, +with $c$ so large that it is above $K_0\cup Q_+$ in +$u'$-projection. Each of these moves increases an existing $u$ gap. +Finally translate $Q_-$ by $du'$. It is an entire extreme side +across a strict $u'$ gap, and $u'\cdot e=1/2$, so large $d$ puts +it vertically above $K_0$ as well. At every move, within-family +distances stay fixed and between-family projection gaps increase. +Thus no filled obstacle neighborhood meets another obstacle or the +insertion neighborhood. The required thin local paths remain available. + +All distances can be chosen in open ranges, in the order +$a_+,a_-,b,c,d$. The translations can be made exactly on the lattice. +If $a_1=(1,0)$ and $a_2=(1/2,\sqrt3/2)$ generate $\T$, then +\[ + \sqrt3 e=-a_1+2a_2,\qquad + \sqrt3 u=a_1+a_2,\qquad + \sqrt3 u'=-2a_1+a_2. +\] +Round each physical distance to a multiple of $b_\delta$. The five +rounding errors are $O(\delta)$; all the finitely many strict margins +therefore survive. Site reflection rows in these directions have +spacing $b_\delta/2$, so a row can also be chosen in every fixed gap. + +At the final placement there is a horizontal site row separating +$X_\delta$ from every other factor. Reflection Cauchy--Schwarz, +Lemma~\ref{pins:side-norm}, and +Proposition~\ref{prop:reflection-null} bound the absolute value of +the normalized expectation by $C\|X_\delta\|_\vartheta\to0$. +Adding phases does not change this norm of the phase-free insertion. + +For every fixed admissible $a_+,a_-,b,c$, the last assertion holds +for $d$ in a nonempty open interval of sufficiently large values and +for every lattice rounding. Lemma~\ref{lem:analytic-translation} +therefore removes the $du'$ move. The resulting assertion holds for +every sufficiently large $c$ with earlier distances fixed, so the same +lemma removes the $-cu$ move. Continue in the order $bu$, $-a_-e$, +$a_+e$. At each stage later distances may depend on the already fixed +earlier ones; the open-interval assertion is exactly what the analytic +lemma needs. This proves \eqref{pins:separated-identity} at the original +placement. Empty families simply omit their moves. +\end{proof} + +\begin{figure}[!hbp] +\centering +\input{figures/pins-five-moves.tex} +\caption{The five moves in Lemma~\ref{pins:three-moves}. +The normal projection is $\pi_n(z)=z\cdot n$, and $A<_nB$ means +$\sup_{z\in A}z\cdot n<\inf_{z\in B}z\cdot n$ for the enlarged +supports. The interval bars record this order; panels do not share a +common scale. Each family carries its obstacle neighborhoods, checks, +local factors, and representative phases together. Choose +$a_+,a_-,b,c,d$ successively in nonempty open ranges, each depending on +the earlier choices. After the final reflection bound, analytic +translation removes the moves in reverse order $d,c,b,a_-,a_+$ by +successive continuation of the normalized expectation. Empty families +omit their moves.} +\label{fig:pins-five-moves} +\end{figure} + +On $P_{\mathrm{loc}}$ the double-pin representatives satisfy +$H(v_i)=4t_i$ in the anchor convention of +\eqref{pins:offset-constraints}. In particular +\[ + D_i=\frac{H(v_i)-H(v_1)}4=t_i-t_1\in\Z. +\] +For $s=(s_2,\ldots,s_m)\in[0,2\pi]^{m-1}$, independent Haar +fields give the exact balanced character identity +\begin{equation}\label{pins:balanced-characters} + \exp\left(i\sum_{i=2}^m s_i D_i\right) + =\prod_{i=2}^m + Z^{(i)}_{s_i/4}(v_i)\overline{Z^{(i)}_{s_i/4}(v_1)}. +\end{equation} +The auxiliary Haar variables cancel. This identity is valid for +unbounded integer lifts; no reduction of the differences modulo four +has been made. Let +\begin{equation}\label{pins:common-offset-event} + P_= =P_{\mathrm{loc}}\cap\{D_i=0\text{ for all }i\ge2\}. +\end{equation} +Fourier orthogonality on the integer variables gives +\begin{equation}\label{pins:fourier-projection} + \ind_{P_=}= + \frac{\ind_{P_{\mathrm{loc}}}}{(2\pi)^{m-1}} + \int_{[0,2\pi]^{m-1}} + \exp\left(i\sum_{i=2}^m s_iD_i\right)\,\dd s. +\end{equation} +For each fixed $s$, Lemma~\ref{pins:three-moves} applies to the +right-hand character. At this fixed geometry its normalized integrand +is bounded uniformly in $s$ and $\delta$, since +\[ + J_\delta^{-1}\E[|X_\delta F_\delta|\ind_{P_{\mathrm{loc}}}] + \le \frac{\Prob(P)}{J_\delta}\,C_F + \E[|X_\delta|\mid P_{\mathrm{loc}}]\le C. +\] +Equations~\eqref{pins:multiplicative} and \eqref{eq:pin-moments} +justify this bound. Dominated convergence in +\eqref{pins:fourier-projection} yields +\begin{equation}\label{pins:common-offset-numerator} + J_\delta^{-1}\E[X_\delta F_\delta\ind_{P_=}] + \longrightarrow0. +\end{equation} + +\subsection{Synchronizing offsets and filling the gaps} + +Keep the grid and windows fixed. Choose a radius $r_0>0$ so small +that the balls about $\gamma(\mathcal C_0)$ of radius $2r_0$ are +disjoint, avoid every test disk, and lie within the single-color portions +of the windows. In particular they meet no second-color equality +edge or pin. The first-color deletions are contained in balls of +radius $Ca$ about these points, for a fixed $C$. Write +$\mu_{\delta,a}$ for the law conditioned on $P$, +$\mu_{\delta,a}^{=}$ for the law conditioned on $P_=$, and +$\mu_{\delta,0}$ for the corresponding filled bracket. These denote +one chosen bracket sign at a time. + +\begin{lemma}[Gap closing]\label{pins:gap-closing} +There is a function $\omega(a)\to0$ as $a\downarrow0$ such that +\begin{align} + \limsup_{\delta\downarrow0} + \Prob(P_=^c\mid P)&\le\omega(a), + \label{pins:offset-synchronization}\\ + \limsup_{\delta\downarrow0} + \left\|\mu_{\delta,a}^{=}|_{\mathcal I_\delta} + -\mu_{\delta,0}|_{\mathcal I_\delta}\right\|_{\TV} + &\le\omega(a),\label{pins:increment-tv}\\ + \limsup_{\delta\downarrow0} + \E_{\mu_{\delta,a}^{=}}|X_\delta|^p + &\le C_p\qquad(1\le p<\infty), + \label{pins:uniform-common-moments} +\end{align} +where $\mathcal I_\delta$ is the joint increment information in the +fixed test disks. The constants in the last line are independent of +all sufficiently small $a$. +\end{lemma} + +\begin{proof} +For each whole gap use a logarithmic stack between radii $Ca$ and +$r_0$, retaining the second-color prescriptions first as equality +edges $E_0$. All first-color pins in this stack are favorable and +there is no equality edge crossing it. A surrounding good plus circuit +joins the traversing first-color arms on its two sides. The arms +exist by the degree-one traversal in Lemma~\ref{lem:boundary-walk}; +they run from the inner gap neighborhood to beyond the chosen outer +collar. Together with the local checks, such a circuit identifies +the lifted pairs of the neighboring groups. The stack failure +probability is at most $C(a/r_0)^\alpha$. Restoring the boundedly +many second-color plus labels costs at most a fixed factor $2^M$. +There are finitely many gaps, and their successive connections join +all groups cyclically. Lemma~\ref{pins:marker-checks} thus proves +\eqref{pins:offset-synchronization}, with a bound of this power form +plus terms whose mesh limsup is zero. + +For comparison with the filled bracket, keep exactly the same +second-color equalities $E_0$ in both laws. Add the missing favorable +first-color pins in one gap and use the ordered stopped coupling of +Proposition~\ref{prop:history-order}. Search outward from the changed +region for a common good plus circuit in the same stack. Except +with probability $C(a/r_0)^\alpha$, such a cut is found before the +search meets any equality edge or label prescription. The only +changes are on its near side, so the correct stopped kernels agree +on its far side by Lemma~\ref{lem:cell-cut}. Sample those remaining +variables identically. This matches the spins and increments in all +test disks, and also the second-color data needed to read every +prescribed plus label. The exterior of the small gap ball contains +paths within each test disk, so the matching of pair variables there +indeed matches its full local increment information. + +Repeat for the finitely many gaps, including all discarded shallow +components inside the changed balls. The conditional laws at every +stage use the common $E_0$ and their own correct query marginals. +After this coupling restore the label event. Under each equality law +its probability is at least $2^{-M}$. If the joint records match the +label data outside an exceptional event of probability $r$, then for +any event of the test data its two label-conditioned probabilities +differ by at most $C2^M r$. This follows by comparing the two joint +numerators and the two label-event denominators separately. Thus the +bounded label cost preserves the vanishing total-variation error. +Finally conditioning the gapped law further on $P_=$ changes its +total variation by at most $\Prob(P_=^c\mid P)$, which proves +\eqref{pins:increment-tv}. No estimate here divides an additive +error by the probability of the rare first-color pin event: all +couplings already have those conditional laws as their marginals. + +It remains to prove \eqref{pins:uniform-common-moments}; the separated +estimate \eqref{eq:pin-moments} alone does not provide a uniform +constant as the obstacle gaps close. Fix one cut-search annulus +around the test support, independent of $a$, away from the boundary +collar. Under $P$ it has a favorable good cut with conditional +probability at least $c>0$, uniformly in $a$: use the buffer bound +with all remote equalities retained and then the same bounded label +cost. By \eqref{pins:offset-synchronization}, for all sufficiently +small $a$ its intersection with $P_=$ has conditional probability +at least $c/2$ in mesh limsup. More precisely choose $a$ so that +$\omega(a)0$. +Divide \eqref{pins:common-offset-numerator} by this quantity to obtain +$\E_{\mu_{\delta,a}^{=}}[X_\delta F_\delta]\to0$. +Let $T_M(t)=\max(-M,\min(t,M))$. The second moments in +\eqref{pins:uniform-common-moments} and in the filled bracket imply +\[ + \E[|X_\delta-T_M(X_\delta)|]\le C/M +\] +in both laws, uniformly in small $a$ after the mesh limit. Total +variation in \eqref{pins:increment-tv} therefore yields +\[ + \limsup_{\delta\downarrow0} + |\E_{\mu_{\delta,0}}[X_\delta F_\delta]| + \le 2C_F M\omega(a)+2C_F C/M. +\] +First take the mesh limit at fixed $a$ as displayed, then let +$a\downarrow0$, and finally let $M\to\infty$. This proves +\eqref{eq:bracket-insertion}. Weak convergence of the local test +statistics, continuity of their bounded factors, and the same moment +bound pass the identity to subsequential bracket limits. + +The window size $\epsilon$ has stayed fixed throughout. The boundary +estimates in Section~\ref{sec:boundary} will control the effect of +shrinking these windows, and Section~\ref{sec:limit} will then transfer +the identity to the true field. +In particular no separated-obstacle constant was used uniformly when +the gaps collided; the independent common-offset estimate was the +ingredient that permitted their closure. +\end{proof} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/06-boundary.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/06-boundary.tex new file mode 100644 index 0000000000000000000000000000000000000000..8870b21c65ea1f8d9cb06ec4dcb1c73b6c61d3da --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/06-boundary.tex @@ -0,0 +1,852 @@ +\section{Boundary attachments and vanishing boundary effects} +\label{sec:boundary} + +The construction below joins two nearby boundary points by a nonnegative +path and completes it through a suitable part of the genuine exterior +to surround a small boundary neighborhood. We call the resulting +separator a boundary arch. Its failure probability will decay +exponentially in the number of available scales. Searches from the +small-neighborhood side will then remove the exceptional windows in the +pinning brackets. Searches from the opposite side will control an +absolute height average near the boundary while leaving distant height +observations measurable outside the arch. + +The first task is to attach a nonnegative path to a prescribed boundary +arc. A bulk circuit alone does not give that attachment. We construct +a lower comparison law whose mean near the arc is close to $-1/2$; +a level-path exploration then forces a boundary-attached zero path with +positive probability. Every real separating site retains its actual +height throughout these comparisons. + +\subsection{The boundary convention and a synthetic lower trace} + +Write $V_\delta$ for the set of face centers on which the finite height +problem is defined, including its prescribed boundary sites, and write +$S_{0,\delta}$ for the connected boundary walk of +Lemma~\ref{lem:boundary-walk}. We use its image as a graph; occurrences +of one vertex in the traversal are not different height variables. +If a further site circuit is exposed, the \emph{usable trace} of a +retained component consists of its real fixed neighboring sites. The +values at those sites remain part of the conditioning. + +For a height $H$ and a level $t$, put +\begin{equation} + \widehat{\mathcal O}_t(H) + = (\delta\T\setminus V_\delta) + \,\cup\,\{v\in V_\delta:H(v)\ge t\}. + \label{boundary:artificial-exterior} +\end{equation} +Thus only sites outside the \emph{original} height problem are declared +open artificially. A real vertex which is removed during a search is +still a real vertex, with its observed height. For the reversed +convention replace $H\ge t$ by $H\le t$. + +Here and below every geometric length is positive and fixed before the +mesh limit. In tangent and inward normal coordinates at +$p\in\partial D$, let $Q_a(p)=p+[-a,a]^2$. There is a radius, uniform in +$p$, on which the limiting boundary is a graph with any prescribed +small slope tolerance. Parametric convergence has two further uses. +First, all portions of $S_{0,\delta}$ in a fixed local box lie in a +vanishing neighborhood of the corresponding limiting arc. Second, +two visits belonging to a smaller boundary patch can be joined along +the walk in a slightly larger patch. Both assertions have fixed +positive slack; they do not assert that the discrete boundary is a +graph. To connect such a patch to the genuine exterior, take a lattice +path from a point on its exterior side towards an interior point and +stop at its first boundary site. Join that site to the desired +boundary endpoint along the walk in the larger patch. To justify this +local connection, choose a slightly larger limiting arc containing the +smaller patch. The inverse of the limiting Jordan +parametrization is uniformly continuous. Hence, for fine mesh, all +visits to the smaller patch occur in the corresponding traversal +interval, up to its fixed endpoint slack. The intervening walk stays +in the larger patch by uniform parametric convergence. This applies +to repeated visits as well as distinct vertices. + +For the lower comparison, use $W$ as the first color. Its plus sign +can represent the pair $\{-1,0\}$ and its minus sign the pair +$\{-3,-2\}$. We place the first pair near a clean boundary arc and +the second pair elsewhere. An open-plus cut near the clean arc will +then permit reflection of the inner height about $-1/2$. The following +construction fixes these actual integer pairs with only finitely many +component labels, even when the discrete boundary walk has many repeated +visits. This bounded label count is what keeps the later circuit +estimates uniform. + +\begin{lemma}[Synthetic trace]\label{boundary:synthetic-trace} +Fix finitely many high and low boundary arcs, separated by transition +neighborhoods of positive length, with both types present. The high +cores and all their transition neighborhoods lie where the usable actual +trace is at least zero; the remaining usable trace is at least $-2$. +One may also add real separator pieces, each connected piece meeting +its low part and staying a positive distance from the high cores and +their transition neighborhoods. There may be arbitrarily many such +pieces, for example when two site circuits enter and leave the domain +many times. For all sufficiently small meshes there is a synthetic +height $K$, obtained from a free +ambient spin law by first-color pins and at most $M$ second-color +labels, such that its connected prescribed skeleton $S$ has trace +\begin{equation} + K|_{S^+}\in\{-1,0\},\qquad + K|_{S^-}\in\{-3,-2\}. + \label{boundary:synthetic-pairs} +\end{equation} +Here $S=S^+\cup S^-$, the high part contains the high cores and stays +inside their prescribed larger arcs, and $M$ depends only on the +number of these arcs. It does not depend on the separator pieces, the +length of the discrete walk or the number of its repeated vertices. +Given its full trace, $K$ has the usual height Gibbs laws in the +bounded faces of $S$, and these laws are below the actual laws in +height order. Before imposing the second-color labels, an event +measurable in the first color and its statuses whose failure +probability is $\varepsilon$ has failure probability at most +$2^M\varepsilon$ after they are imposed. +\end{lemma} + +\begin{proof} +Choose shortened cores of the prescribed arcs, leaving disjoint +transition neighborhoods between consecutive cores. The image of an +appropriate consecutive portion of the boundary traversal gives a +connected graph for each core. Compact limiting cores of opposite +types are separated, so their images neither intersect nor have an +edge between them at sufficiently small mesh. Any portion not yet +assigned is in one of the transition neighborhoods. Repeated visits +inside a core belong to that same connected core image. Any repeated +visit that could affect assignment outside the cores is localized to +a transition neighborhood: otherwise two traversal parameters a fixed +positive distance apart would converge to the same point of the Jordan +curve. Uniform continuity of its inverse parametrization excludes +this possibility. + +Grow the connected core sets in the finite walk graph. For example, +give each unassigned vertex to a nearest core in graph distance, +breaking ties in a fixed order, and use a shortest path to that core +as its parent. Each resulting part is connected. Each component of +the still unassigned graph had a neighboring core, since the entire +walk graph is connected; hence the procedure assigns every vertex. +The growth stays in the transition neighborhoods until it meets an +already assigned core. In particular it never changes a prescribed +core or its type. Merge neighboring parts of the same type. Added +separator pieces are assigned low and joined to the low parts they +meet. Their clearance from the high patch makes this consistent. +Every added piece attaches to an existing low part, so it creates no +new part; it may merge existing low parts. In particular no cost is +charged for the number of real components of an added circuit. + +Pin $W=+$ or $W=-$ on the resulting parts. Their adjacency graph is +connected. On each edge of a spanning tree joining opposite-sign +parts, choose one corresponding skeleton edge and prescribe $B=-$ +there. Its two endpoints already have opposite $W$ signs, so +coherence forces their $B$ signs to agree. There are at most $M$ +such labels. Anchor the lift by $K(o)=-1$ at a plus endpoint of one +of these edges. Along a connected constant-$W$ part the lifted pair +is unchanged; a labeled transition changes $-1$ to $-2$. Propagation +along the spanning tree therefore gives +\eqref{boundary:synthetic-pairs}. Extra contacts between parts create +no further choice of lift: the ambient lift is single valued. The +configuration $B\equiv-$ shows that all the imposed conditions are +simultaneously feasible. The separate flat comparison below fixes +both spins and does not use this construction. + +Conditional on $W$ and its statuses, the $B$ components have fair +independent labels. Requiring at most $M$ of them to have label minus +has conditional probability at least $2^{-M}$, even if several +requests refer to the same component. This proves the last +assertion. The height Gibbs property follows on conditioning on the +whole trace and integrating out the statuses. On each high part +the synthetic trace is at most zero, and on each low part it is at +most $-2$. Lemma~\ref{lem:height-order} gives the claimed comparison +on every retained component. +\end{proof} + +For later stopping arguments it is useful to state the elementary +site-circuit fact explicitly. + +\begin{lemma}[Extremal site circuits]\label{boundary:extremal} +In a specified finite annular strip, consider the simple open site +circuits surrounding a fixed connected inner box. If one exists, +there is an innermost and an outermost such circuit, ordered by their +geometric Jordan interiors. Selection of the innermost circuit +requires only its trace and observations on its inner side in the +strip; selection of the outermost requires only its trace and +observations on its outer side. Artificial openness as in +\eqref{boundary:artificial-exterior} does not change these assertions. + +Consequently, inner circuits selected from the inside and outer +circuits selected from the outside in disjoint strips leave the +pairwise disjoint unexamined middle components with their height Gibbs laws, independent +given the revealed data and their real traces. +\end{lemma} + +\begin{proof} +Two eligible cycles have inner and outer envelopes made of edges in +their union. To see this, if they share at least two vertices, their +union is two-vertex-connected. Indeed, after deleting any vertex, +each cycle is connected and at least one common vertex remains. +The face of this union containing the inner box and its unbounded +face have simple cycle boundaries. They give the required +envelopes. The inner box is connected and disjoint from the cycles, +so it lies in a single face. If the cycles have no common vertex or +only one, the requirement that both surround the box makes them +nested. In every case the envelopes stay in the original strip +and surround its inner box. Finitely many repeated envelopes give +the least and greatest Jordan interiors. Geometric interiors, not +just sets of enclosed lattice vertices, determine this order. + +For a proposed innermost circuit $\gamma$, the assertion that it is +selected is equivalent to its being open and to the nonexistence of +an eligible open circuit with strictly smaller interior contained +in its interior. A nonnested competitor would give such a circuit +by the inner-envelope operation. The equivalent assertion reads +only the sites on or inside $\gamma$ in the strip. The outer case +is identical with the order reversed. Deterministic tie conventions +for a traversal of the selected cycle do not reveal additional +sites. An unsuccessful strip can be read in its entirety. + +All these selection events are consequently measurable in the +discarded regions and the separating traces. The nearest-neighbor +height density factors over the remaining components, proving the +Gibbs and independence claims. Only the goodness test of a genuinely +exterior site is deterministic. Every selected real site retains +its actual observed height in this factorization. +\end{proof} + +\subsection{A local attachment} + +We isolate the probabilistic and topological step which joins a bulk +path to the actual boundary. Its constants are uniform over the +separator traces allowed in the statement. + +\begin{lemma}[Attachment to a clean arc]\label{lem:boundary-attachment} +There are constants $\lambda>0$ and $a_0>0$, depending only on $x$, +with the following property. Fix $b>0$ and put $s=\lambda b$. +Suppose a retained height problem has a connected bounding skeleton +consisting of $S_{0,\delta}$ and separator pieces, all with usable +trace at least $-2$. A clean local patch of the base skeleton has +trace at least zero. Use tangential and inward-normal coordinates +$(t,y)$ at this patch, and call $y$ its depth. Assume that all its +base-skeleton sites in the box $|t|\le 2b$, $|y|\le b$ lie in +$|y|0$. The event and the choice of cut are measurable +in $W$ and its statuses. + +Given these variables and the prescribed transition labels, every +$B$ component inside the good cut is free and no such component +crosses it. Flip all their labels. On the connected pinned high +part one has +\[ + K(v)-\tfrac12B(v)=-\tfrac12. +\] +Consequently this flip sends $K(v)$ to $-1-K(v)$. All increments +inside the cut also change sign, since $W$ is unchanged and $B$ is +reversed. It follows throughout its protected interior that +\begin{equation} + K\longmapsto-1-K. + \label{boundary:minus-half-reflection} +\end{equation} +This is a weight-preserving involution of the still fair component +labels. In particular the conditional mean at $z$, on $G$, is +exactly $-1/2$. + +\paragraph{Why failure has bounded conditional mean.} +Let $\mathcal A$ contain the full first color and its statuses and +the prescribed second-color labels. Increments satisfy +\begin{equation} + \dd(K-BW/2)=-B\,\dd W. + \label{boundary:component-identity} +\end{equation} +For each $B$ component $C$, the portion of $\dd W$ carried by that +component has zero curl. Every $W$-changing edge belongs to a closed +cell. The two changing edges of any triangle share a vertex, so +their endpoints belong to the same $B$ component and their +contributions cancel. Its potential $\phi_C$ has oscillation at most two: +on $C$ it equals $W$ up to a constant, and outside $C$ it is +constant until a path first hits $C$. This is also the +component-potential calculation in Lemma~\ref{lem:collar-switch}. +Integrating \eqref{boundary:component-identity} from the labeled +anchor $o$, where $K(o)=-1$, gives an endpoint correction of absolute +value at most one and one term +$-B_C(\phi_C(z)-\phi_C(o))$ for each component. Every unlabeled +component has conditional mean zero. At most $M$ components are +labeled. Therefore +\begin{equation} + \big|\E[K(z)\mid\mathcal A]\big|\le 2+2M. + \label{boundary:failure-mean} +\end{equation} +Since $G$ is $\mathcal A$-measurable, its failure contributes at most +$(2+2M)\Prob(G^c)$ to the \emph{mean}. No pointwise height bound or +bound on $\E[|K(z)|\mid G^c]$ is being used. Combining +\eqref{boundary:minus-half-reflection}--\eqref{boundary:failure-mean} +shows that +\begin{equation} + \left|\E K(z)+\tfrac12\right|\le C_M\eta(s/b). + \label{boundary:synthetic-mean} +\end{equation} + +\paragraph{Boundary-entering level paths and a Gibbs ceiling.} +Condition on the synthetic height trace on $S$ and consider the +bounded face containing $z$. Starting at every trace edge with +values $-1,0$, follow its dual level path at level $-1/2$, stopping +when it returns to the skeleton. Reveal only the path and its two +adjacent site lips. Continuation is unique: in a triangle containing +an edge with values $-1,0$, the third height is either $-1$ or $0$, +so exactly two of its edges cross this level. Such a path cannot +branch or turn into an independent closed contour. Stop a path also +at an earlier revealed segment if necessary, and exhaust all the +boundary-entering paths. Each high lip is a connected chain of +zeros attached to a zero on the prescribed skeleton; each low lip +has height $-1$. + +This is a stopped height exploration: the next query is determined +by the already revealed heights, so the unrevealed regions retain +their height Gibbs laws. Give a remaining region the high or low +designation inherited from the side of the exposed paths and the +original trace. This designation ignores every unexposed closed +contour. It is consistent because a closed contour in a bounded +face cannot enclose part of the connected bounding skeleton, or +part of a path attached to that skeleton. After all the entering +paths have been traced, a low region has usable boundary at most +$-1$, while a high region has usable boundary at most zero. This +can alternatively define the designation by cutting the face along +the exposed paths and using their oriented lips. If $z$ is itself +revealed, its lip gives the same bounds directly. + +Height comparison with the constant ceilings $-1$ and $0$, whose +mean fields are respectively $-1$ and $0$, now gives +\begin{equation} + \E K(z)\le -1+\Prob(z\hbox{ has the high designation}). + \label{boundary:ceiling} +\end{equation} +An unseen closed contour can create a high island inside a +low-designated region. Its entire Gibbs contribution is included +in this ceiling comparison; the high designation is not the event +$K(z)\ge0$. Equations~\eqref{boundary:synthetic-mean} and +\eqref{boundary:ceiling} yield a high-designation probability at +least $1/2-C_M\eta(s/b)$. + +\paragraph{The barriers force a real attachment.} +Figure~\ref{fig:boundary-attachment} depicts the following separation +argument. +At the two boundary projections $t=\pm2b/3$, request good $W$-minus +circuits in annuli with inner size $2s$ and outer size less than +$b/8$. Choose the inner boxes to contain the whole cross-section +$-s/10\le y\le s$ at the corresponding projection. Each annulus +meets only low skeleton pins; its circuit meets the low part and +therefore uses the anchored pair $\{-3,-2\}$. Its adjacent site +path contains a surrounding site circuit of heights at most $-2$. +The same stack estimate and label cost bound the probability of +failure of either barrier by $2\eta_1(s/b)$, where +$\eta_1(u)\to0$. These barrier events are intersected with the +high-designation event after deriving \eqref{boundary:ceiling}; they +were not extra observations in that Gibbs comparison. + +Every exposed zero lip starts on the designated high patch: the +rest of $S$, including the added separators, has heights $-3,-2$. +Suppose no such lip reaches depth $s$ while $|t|100$, $c,C>0$ and a positive slope tolerance +such that the following holds. Fix $p\in\partial D$ and a local +radius $R$ satisfying that tolerance. Suppose the actual prescribed +trace on $S_{0,\delta}$ is at least $-1$ everywhere and at least zero +in $Q_R(p)\setminus Q_r(p)$. Choose any $N$ positive scales +\[ + 16r\le\ell_1,\qquad + L\ell_j\le\ell_{j+1},\qquad + \ell_N\le R/10. +\] +At all sufficiently small meshes, +\begin{equation} + \Prob\!\left( + \begin{array}{c} + \text{a site circuit in }\widehat{\mathcal O}_0(H) + \text{ surrounds }Q_r(p)\\[-2pt] + \text{and is contained in }Q_R(p)\setminus Q_r(p) + \end{array}\right) + \ge 1-Ce^{-cN}. + \label{boundary:arch-estimate} +\end{equation} +The constants are independent of $N,p$ and the prescribed trace; +the required mesh threshold may depend on the chosen positive +scales and the boundary approximation. The same assertion holds +with all inequalities reversed when the original trace is at most +$1$ everywhere and at most zero in the clean annulus. All usable +sites of the resulting arch have their real height at least zero, +or at most zero in the reversed assertion. +\end{proposition} +\end{samepage} + +\begin{proof} +We give the increasing construction. All choices of relative widths +below are fixed once and for all, depending at most on $x$. + +\paragraph{Preliminary blocks at level $-1$.} +In block $j$ seek site circuits of level at least $-1$ in the two +strips +\[ + Q_{\ell_j}\setminus Q_{\ell_j/2}, + \qquad Q_{7\ell_j}\setminus Q_{5\ell_j}, +\] +with artificial exterior allowed, each surrounding its inner box. +Use Lemma~\ref{boundary:synthetic-trace} with high intervals on the +two clean boundary subarcs running through \emph{all} these strips. +Place their transitions before the innermost buffers and beyond +the outermost ones, in the available clean annulus. Low intervals +are used on the remaining skeleton. There are only two high arcs, +so the number $M$ of transition labels is independent of $N$. + +Before imposing those labels, the slightly narrower buffers in +each strip see only favorable first-color pins. By +Lemma~\ref{lem:buffer-circuits} there is $a_1>0$ such that, given +the earlier complete first-color/status slot records, both good +plus circuits in the next block occur with conditional probability +at least $a_1$. All such buffers are disjoint by the choice of $L$. +A good circuit meets a high boundary arc, since that arc traverses +the strip. Its adjacent site path is consequently in the anchored +pair $\{-1,0\}$. That path has winding number one around the inner +box; erasing unnecessary pieces gives a simple surrounding site +circuit at level at least $-1$. + +If $I_j$ records the two-circuit success, the conditional estimate +implies, for $t>0$, +\[ + \E\exp\!\left(-t\sum_{j=1}^N I_j\right) + \le(1-a_1+a_1e^{-t})^N. +\] +Choosing $t$ and then a sufficiently small $a_2>0$ gives +$\Prob(\sum I_j0$. + +Join the boundary ends through the clean real boundary sites to +the genuine exterior, as in the attachment lemma. In that exterior +connect them by a path below the arc, around the lower side of +$Q_\ell$, staying in $Q_{5\ell}\setminus Q_\ell$. The upper bulk +route and lower exterior route lie in disjoint opposite corridors, +so their union contains a closed site walk with winding number one +around $Q_\ell$. It contains a simple surrounding open circuit. +Only sites outside the original $V_\delta$ have been used +artificially; no real preliminary separator was given artificial +height. This produces the desired level-zero arch in the block. + +Conditional on $\mathcal R$, distinct retained middle problems are +independent. If at least $a_2N$ preliminary blocks succeeded, the +probability that none upgrades is at most $(1-a_3)^{a_2N}$. +Adding the preliminary count failure proves +\eqref{boundary:arch-estimate}. Reflection $H\mapsto-H$ proves the +reversed assertion. When a resulting arch is later used as a +conditioning boundary, it is searched for afresh by the height +extremal selection of Lemma~\ref{boundary:extremal}; none of the +synthetic constructions or auxiliary successes is then conditioned +on. +\end{proof} + +\subsection{Vanishing brackets and boundary correlations} + +The next estimate removes the mean contribution of the exceptional +windows. After establishing compactness in Section~\ref{sec:limit}, +we will combine it with the ordered bracket coupling to identify the +limiting brackets with the true field. + +\begin{proposition}[Vanishing bracket means] +\label{prop:bracket-collapse} +Fix a finite regular grid as in Definition~\ref{def:brackets}. +For every $f\in C_c^\infty(D)$, the upper and lower bracket fields +satisfy +\begin{equation} + \lim_{\epsilon\downarrow0}\ \limsup_{\delta\downarrow0} + \left|\E H_\delta^{\pm,\epsilon}(f)\right|=0. + \label{boundary:bracket-means} +\end{equation} +\end{proposition} + +\begin{proof} +The bracket trace belongs to $[-1,1]$ and equals zero away from the +finitely many exceptional windows. Choose pairwise disjoint fixed +outer neighborhoods of their centers, missing $\supp f$. Given +$N$, choose $N$ separated positive scales in each neighborhood and +then take $\epsilon$ sufficiently small that its exceptional +window lies inside the innermost box. Finally take the mesh small +with this geometry fixed. + +Condition on the bracket trace. Proposition~\ref{prop:boundary-arch} +gives increasing level-zero arches around all windows except with +probability at most $JC e^{-cN}$, where $J$ is their fixed number. +Select innermost arches by testing from the exceptional side. On +simultaneous success every retained component meeting $\supp f$ +has nonnegative usable trace: each new real separator site has +height at least zero and the old visible base trace is zero. By +height comparison the conditional mean on each such component is +nonnegative, and hence so is their sum against a nonnegative $f$. +Thus, using the unconditional bracket moment bound +of Proposition~\ref{prop:smearing}, +\[ + \E H_\delta^{\pm,\epsilon}(f) + \ge -\|H_\delta^{\pm,\epsilon}(f)\|_2 + (JC e^{-cN})^{1/2} + \ge -C_f e^{-cN/2}. +\] +The same argument with decreasing arches gives the upper bound. +In particular no bound conditioned on arch failure is needed. +The moment constant is uniform over the original traces in +$[-1,1]$. Since $N$ is arbitrary, this proves +\eqref{boundary:bracket-means} for nonnegative tests. Splitting a +smooth signed test into a difference of nonnegative smooth compactly +supported tests proves the general case. + +\end{proof} + +\begin{proposition}[Boundary moments with exterior spectators] +\label{prop:boundary-moments} +Fix a nonnegative smooth radial bump $\rho$, supported in the unit +disk, with integral one, and fix a sufficiently small $\theta>0$. +For $z\in D$ write $d(z)=\dist(z,\partial D)$ and +\[ + \rho_z(u)=(\theta d(z))^{-2} + \rho\!\left(\frac{u-z}{\theta d(z)}\right),\qquad + Y_z=H(\rho_z), +\] +where $H$ is any subsequential distributional and moment limit of +the true fields. For every $1\le p<\infty$, +\begin{equation} + \sup_{z\in D}\|Y_z\|_p\le C_{p,\theta,D,\rho}. + \label{boundary:uniform-depth-moments} +\end{equation} +In particular this bound is uniform when $z$ approaches any point +of a fixed compact boundary arc. + +Let $p_0\in\partial D$ and let $F$ be a product of a fixed number +of smooth averages supported a positive distance from $p_0$. +The averages may be fixed in the interior, or may be of the same +comparable-depth form with centers approaching fixed boundary +points distinct from $p_0$. Then, jointly in those allowed +approaches, +\begin{equation} + \E[Y_zF]\longrightarrow0\qquad(z\longrightarrow p_0). + \label{boundary:spectator-vanishing} +\end{equation} +The same statement holds for finite linear combinations of these +products. + +If $p_1,\ldots,p_m$ are distinct fixed boundary points and +$z_i\to p_i$, then the reference average +$Z_m=m^{-1}\sum_{i=1}^mY_{z_i}$ satisfies +\begin{equation} + \limsup_{z_i\to p_i}\|Z_m\|_2\le C m^{-1/2}, + \qquad \sup_m\sup_{z_1,\ldots,z_m}\|Z_m\|_p\le C_p. + \label{boundary:reference-average} +\end{equation} +In the first assertion $m$ and its distinct boundary points are +fixed before taking the depth limits. Subsequently $m\to\infty$ +makes these references tend to zero in every finite $L^p$. +\end{proposition} + +\begin{proof} +At mesh $\delta$ put $Y_{z,\delta}=h_\delta(\rho_z)$, and denote the +corresponding lattice spectator product by $F_\delta$. +At a fixed $z$, the distance from its lattice representative to the +prescribed skeleton tends to $d(z)$. The exact face-area weights +of $\rho_z$ have total mass one, are supported in a ball of radius +$\theta d(z)+O(\delta)$, and are bounded by a constant times +$(\delta/d(z))^2$. The ratio between boundary distance and smearing +radius is thus bounded above and below independently of $z$ once +the mesh is taken sufficiently small for that fixed placement. +Proposition~\ref{prop:smearing}, with original trace zero, gives +\eqref{boundary:uniform-depth-moments}. The passage to the limit +uses the higher moments from the same proposition. Compactness +of the smooth boundary makes its constants uniform over boundary +points; no estimate uniform in the approximation error divided by +a moving depth is asserted before taking the mesh limit. + +Choose a small fixed outer neighborhood of $p_0$ missing all the +spectator supports; for approaching spectators this is possible +uniformly once their limiting distinct points have been fixed. +Given $N$, choose $N$ fixed separated scales inside this neighborhood. +For all sufficiently close $z$ the support of $\rho_z$ is in the +inner box of this stack. Apply +Proposition~\ref{prop:boundary-arch} to the true zero boundary. +Select an outermost increasing arch by testing from outside and +reveal its exterior and real trace. The spectator product $F_\delta$, +including its absolute height values, is measurable in that exterior +record. On success, the retained region containing the testing +ball has nonnegative usable trace, and hence nonnegative conditional +mean for its unit nonnegative average. For any nonnegative +exterior-measurable factor $U$ it follows that +\[ + \E[Y_{z,\delta}U] + \ge -\E\big[|Y_{z,\delta}|U\ind_{\{\text{increasing search fails}\}}\big]. +\] +The separate decreasing search gives the corresponding upper bound. +These searches reveal only their tested sides; they do not +condition on the intermediate constructions in the arch proof. + +Apply the two bounds to $U=(F_\delta)_+$ and $U=(F_\delta)_-$, the positive and +negative parts of the whole spectator product. If $F$ has $k$ +factors, H\"older's inequality and the unconditional +$2(k+1)$-moment bounds give +\[ + \E\big[|Y_{z,\delta}F_\delta|\ind_{\{\text{a search fails}\}}\big] + \le \|Y_{z,\delta}F_\delta\|_2\, + \Prob(\text{a search fails})^{1/2} + \le C_F e^{-cN/2}. +\] +The constants remain bounded for comparable-depth spectators at +the other fixed boundary points, by +\eqref{boundary:uniform-depth-moments}. In particular the estimate +uses moments in the original zero-boundary law, not moments under +a failure event or a random high trace. First take the mesh limit +at fixed positions and scales. Then take the indicated approaches +to the distinct boundary points. The resulting limsup is at most +$C_F e^{-cN/2}$. Since $N$ was arbitrary, this proves +\eqref{boundary:spectator-vanishing}. + +Finally, \eqref{boundary:uniform-depth-moments} bounds the diagonal +terms in $\E Z_m^2$ by $C/m$. Each of the finitely many off-diagonal +terms vanishes as the depths tend to zero, by +\eqref{boundary:spectator-vanishing} with one spectator. This proves +the first assertion of \eqref{boundary:reference-average}. +Minkowski's inequality gives its uniform $L^p$ bounds independently +of $m$. Interpolation between $L^2$ and any larger finite moment +then proves the final claim; for $p\le2$ use monotonicity of +$L^p$ norms. These are absolute-height references, with no lift +constant left unspecified. +\end{proof} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/07-limit.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/07-limit.tex new file mode 100644 index 0000000000000000000000000000000000000000..889c515ebe459d198b91d047e3d4a214749037b4 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/07-limit.tex @@ -0,0 +1,801 @@ +\section{Identification of the limiting field} +\label{sec:limit} + +Fix \(x\) throughout, and let \(v\in(0,\infty)\) be the +domain-independent constant in Proposition~\ref{prop:plane-covariance}. +We identify every subsequential limit of the actual zero-boundary +fields. The steps below also establish tightness and justify passage +of all moments; no assertion of Gaussianity is used before the last +step. + +\subsection{Compactness, moments, and the insertion identity} + +We write \(h_\delta(f)=\int_D h_\delta(z)f(z)\dd z\). +This is the exact face-area pairing from the introduction, including +for signed tests. In particular \(\int f=0\) means that its discrete +weights sum to exactly zero, so adding a constant to a height lift has +no effect. + +\begin{proposition}[Tightness and moment convergence] +\label{prop:tightness} +For every \(t>1\), the true fields are tight in +\(H^{-t}_{\mathrm{loc}}(D)\). The same holds for the upper and lower +brackets, uniformly in their exceptional windows. Every fixed finite +collection of test pairings has uniformly bounded moments of every +order. Along a distributional law limit, all its mixed moments +converge. These assertions hold also for finite joint couplings of +the indicated fields. +\end{proposition} + +\begin{proof} +A consequence of Proposition~\ref{prop:smearing}, using a finite +cover of a compact set by interior disks, is +\begin{equation} + \sup_\delta\|h_\delta(f)\|_{L^p} + \le C_{K,p}\|f\|_\infty,\qquad + \supp f\subset K\Subset D,\quad 1\le p<\infty. + \label{eq:limit-fixed-moments} +\end{equation} +Indeed, split the face weights by a smooth partition of unity +subordinate to that cover. Each resulting weight family has bounded +total variation and the required maximum weight on its fixed disk; +apply the smearing estimate and the triangle inequality. The argument +applies to the brackets after conditioning on their traces, whose +values lie between \(-1\) and \(1\). Its constants thus do not depend +on the windows. Complex tests are handled by their real and imaginary +parts. + +Here is the compactness argument in detail. Place \(D\) in a square +torus and fix \(\chi\in C_c^\infty(D)\). For its Fourier basis +\(e_k\), \(k\in\Z^2\), let +\(a_{\delta,k}=h_\delta(\chi\overline{e_k})\). Since the moduli of the +basis functions are constant, \eqref{eq:limit-fixed-moments} bounds +\(\|a_{\delta,k}\|_{L^p}\) independently of \(k\). For \(s>1\) and +\(p\ge2\), Minkowski's inequality gives +\begin{align} + \bigl\|\|\chi h_\delta\|_{H^{-s}}^2\bigr\|_{L^{p/2}} + &\le + \sum_{k\in\Z^2}(1+|k|^2)^{-s} + \|a_{\delta,k}\|_{L^p}^2 + \le C_{\chi,p,s}. + \label{eq:limit-sobolev-moments} +\end{align} +The bounds for smaller \(p\) follow by monotonicity of \(L^p\) norms. +Choose \(10\), put the centers a distance \(a\) along their inward +normals and use bumps \(\psi_{\ell,a}\) of radius \(\theta a\), where +\(0<\theta<1/4\) is fixed. The tubular neighborhood theorem for a +\(C^2\) Jordan curve gives distance exactly \(a\) to the boundary for +these centers when \(a\) is sufficiently small. Define +\[ + Y_{\ell,a}=H(\psi_{\ell,a}),\qquad + R_{m,a}=\frac1m\sum_{\ell=1}^m Y_{\ell,a}. +\] +The comparable-depth moment bound in +Proposition~\ref{prop:boundary-moments} is uniform along this fixed +arc. Minkowski's inequality therefore gives +\(\sup_{m,a}\|R_{m,a}\|_{L^q}\le C_q\) for each finite \(q\), after +restricting to the corresponding sufficiently small depths. +For fixed \(m\), the same proposition gives +\(\E[Y_{\ell,a}Y_{k,a}]\to0\) when \(\ell\ne k\). +Consequently +\begin{equation} + \limsup_{a\downarrow0}\|R_{m,a}\|_{L^2}^2 + \le \frac{C_2^2}{m}. + \label{eq:limit-reference-second} +\end{equation} +For each \(m\), choose a positive depth \(a_m\) small enough that this +squared norm is at most \((C_2^2+1)/m\) and all disk diameters meet +the prescribed bound. Then \(R_m=R_{m,a_m}\) tends to zero in +\(L^2\). For \(p>2\), interpolate this convergence with the uniform +\(L^q\) bound for any \(q>p\); for \(p\le2\), use monotonicity. +This proves the assertion. The order in +\eqref{eq:limit-reference-second} is depth first at fixed \(m\), +then \(m\to\infty\). +\end{proof} + +For \(j\ge1\), define the moment distribution \(T_j=\E H^{\otimes j}\) +on \(D^j\), and set \(T_0=1\). This definition is legitimate for +general smooth tests on the product, not just tensor tests. +For example, after localizing in a square torus, expand a product-space +test in its Fourier series. Its coefficients decay faster than any +power, while H\"older's inequality and +\eqref{eq:limit-fixed-moments} bound the expected absolute product of +any \(j\) Fourier coefficients uniformly. The resulting series is +absolutely convergent and defines a continuous distribution. +For tensor tests it gives precisely +\[ + T_j(f_1\otimes\cdots\otimes f_j) + =\E\prod_{i=1}^j H(f_i). +\] +This construction agrees with taking the expectation of the tensor +power of the random distribution by +\eqref{eq:limit-sobolev-moments}. + +For \(j\ge2\), we will determine \(T_j\) from \(T_{j-2}\) by its behavior +in one variable. The next steps establish harmonicity away from coincident +points, rule out additional distributions supported at coincidences, +and identify each logarithmic collision coefficient. Together with +the zero boundary value, these properties will give the Gaussian +moment recursion by subtraction of Dirichlet Green functions. + +\begin{proposition}[Harmonic moments] +\label{prop:harmonic-moments} +Let +\[ + \mathcal C_j=\{(z_1,\ldots,z_j)\in D^j: + z_i\ne z_k\text{ for }i\ne k\}. +\] +On \(\mathcal C_j\), \(T_j\) is a smooth function and is harmonic in +each variable separately. +\end{proposition} + +\begin{proof} +We prove the first-variable distributional Laplace identity in a +small product neighborhood of any distinct tuple; symmetry then gives +all the identities. Translate the first center to the origin. +Choose \(R>0\) so that \(B(0,4R)\Subset D\) and all the other centers +lie outside \(\overline{B(0,4R)}\). Choose \(02h\), +the product of bump supports is off the diagonals. The radial mean +value property, successively in each harmonic variable, gives +\(T_{j,h}(\mathbf z)=T_j(\mathbf z)\). +Taking \(h\) to be the smaller of \(d(\mathbf z)/4\) and a fixed +interior radius proves \eqref{eq:limit-log-bound}. + +For completeness, a collision tube +\[ + A_h=\{\mathbf z:d(\mathbf z)\le2h\} +\] +in a fixed compact set has volume at most \(C_jh^2\): use the +union bound over pairs, fix all but one point in a selected pair, +and integrate that point over a disk of radius \(2h\). +The same bound at every radius \(s\), followed by integration of +the distribution function, gives for \(q\ge0\) +\[ + \int_{A_h}\bigl(1+\log_+(1/d(\mathbf z))\bigr)^q\dd\mathbf z + \le C_qh^2(1+\log(1/h))^q. +\] +Indeed for \(q>0\), integrate +\(q(1+\log(1/s))^{q-1}\dd s/s\) against the bound \(Cs^2\); +the endpoint term is \(Ch^2(1+\log(1/h))^q\). +This proves local integrability. It also shows that the +off-diagonal function has vanishing \(L^1\) mass on \(A_h\). +Equation~\eqref{eq:limit-mollifier-bound} gives the same assertion +for \(T_{j,h}\), since \(h^2(1+\log(1/h))^{j/2}\to0\). +Off \(A_h\) the two functions agree exactly. Thus \(T_{j,h}\) +converges locally in \(L^1\) to the off-diagonal function. +But convolution also converges to \(T_j\) in distributions. +These limits are equal. In particular neither a delta distribution +nor any of its derivatives on a collision diagonal can be present. +The case \(j=1\) has no collision set and follows directly from +harmonicity. + +To prove \eqref{eq:limit-zero-boundary}, choose disjoint small fixed +radial averaging disks around \(z_2,\ldots,z_j\). +For \(z_1\) near \(p\), choose its averaging radius to be +\(\theta\dist(z_1,\partial D)\). +The supports are pairwise separated. The harmonic mean value +property in every variable identifies the displayed pointwise +value with +\[ + \E\left[H(\rho_{z_1,\theta\dist(z_1,\partial D)}) + \prod_{i=2}^jH(\rho_{z_i,s_i})\right]. +\] +Proposition~\ref{prop:boundary-moments} makes this tend to zero. +For \(j=1\) the same conclusion also follows from the zero mean. +\end{proof} + +\subsection{The logarithmic collision coefficient} + +\begin{lemma}[Punctured harmonic expansion] +\label{limit:puncture} +Let \(j\ge2\). Fix a collision point \(y\in D\) and distinct spectators +\(\mathbf z=(z_3,\ldots,z_j)\), all separated from \(y\). +For \(x\) in a sufficiently small punctured disk about \(y\), +\begin{equation} + T_j(x,y,\mathbf z) + =L(y,\mathbf z)\log(1/|x-y|) + +R(x;y,\mathbf z), + \label{eq:limit-puncture} +\end{equation} +where \(R\) extends harmonically across \(x=y\). +The coefficient \(L\) is smooth in the separated parameters +\((y,\mathbf z)\), and the first-variable derivatives of \(R\) +are bounded uniformly on smaller disks and compact sets of these +parameters. The coefficient \(L\) is separately harmonic in each +spectator variable. +\end{lemma} + +\begin{proof} +For fixed parameters, the angular Fourier coefficients of a harmonic +function in a punctured disk have the forms +\(a_0+b_0\log r\) and \(a_nr^n+b_nr^{-n}\), \(n\ge1\), for the +sine and cosine modes. Equation~\eqref{eq:limit-log-bound} bounds +the function by a power of \(1+\log(1/r)\). Multiplying its +\(n\)-th Fourier coefficient by \(r^n\) and sending \(r\downarrow0\) +therefore shows \(b_n=0\) for every \(n\ge1\). +After subtracting the logarithmic term, the remaining nonnegative +modes are the harmonic extension of their values on any fixed +smaller circle, and hence extend across the center. + +On a circle of radius \(s>0\) enclosing no other spectator, +the coefficient is the flux +\begin{equation} + L(y,\mathbf z) + =-\frac1{2\pi} + \int_{|x-y|=s}\partial_{n_x}T_j(x,y,\mathbf z)\dd\ell(x). + \label{eq:limit-flux} +\end{equation} +One can keep \(s\) fixed on a neighborhood of any separated +parameter tuple. Parameterizing \(x=y+se^{i\theta}\), the integrand +is smooth by Proposition~\ref{prop:harmonic-moments}; thus \(L\) +is smooth. Applying a spectator Laplacian under this integral +also proves its separate harmonicity. +Subtract \(L\log(1/|x-y|)\) on that circle. Its values are +smooth and uniformly bounded on compact parameter sets. +The Poisson formula for their harmonic extension, differentiated +in \(x\) on a smaller disk, yields the claimed uniform derivative +bounds for \(R\). +\end{proof} + +\begin{proposition}[Collision coefficient] +\label{prop:collision} +In \eqref{eq:limit-puncture}, +\begin{equation} + L(y,\mathbf z)=\frac{v}{2\pi}T_{j-2}(\mathbf z). + \label{eq:limit-collision} +\end{equation} +The convention \(T_0=1\) applies when \(j=2\). +\end{proposition} + +\begin{proof} +Choose two real smooth signed tests \(\alpha,\beta\) with zero +integral, supported in disjoint disks, such that +\[ + I=\iint\alpha(u)\log(1/|u-w|)\beta(w)\dd u\dd w\ne0. +\] +Such tests can be obtained by taking horizontal derivatives of +unit mollifiers concentrated about two distinct points on a +horizontal line. As their radii tend to zero, integration by parts +makes the displayed integral tend to the mixed horizontal derivative +of the logarithmic kernel at these two points, which is nonzero. +Fix one such pair. For a fixed point \(y_0\), define +\[ + \alpha_r(x)=r^{-2}\alpha((x-y_0)/r),\qquad + \beta_r(x)=r^{-2}\beta((x-y_0)/r). +\] +Let \(F=\prod_{i=3}^jH(\rho_{z_i,s_i})\), where the spectator disks +are fixed, small, pairwise disjoint and separated from a fixed +closed disk \(\overline{B(y_0,R_0)}\Subset D\). +An empty product is one. We first prove +\begin{equation} + \lim_{r\downarrow0} + \E[H(\alpha_r)H(\beta_r)F] + =\frac{v}{2\pi}I\,T_{j-2}(\mathbf z). + \label{eq:limit-plane-factorization} +\end{equation} +We will evaluate this limit in two ways. A plane copy independent of +the spectators gives the right side of +\eqref{eq:limit-plane-factorization}; the punctured harmonic expansion +will give \(I L(y_0,\mathbf z)\). Their equality determines \(L\). +For the first evaluation, the plane copy must be independent of the +exterior record that determines the absolute spectator heights. + +Fix \(r>0\) small enough that both inner supports lie in +\(B(y_0,Cr)\) and \(\sqrt r0\). The exploration always queries a cell status +together with all its first-color sites, using the stopped kernels +of Proposition~\ref{prop:local-mixing}. Let +\(\mathcal G_\delta\) contain the stopped query record (including its +success or failure outcome), the selected cut and its first-color data +when it exists, and the genuinely exterior pair data needed below. +Do not reveal complementary-spin values at strictly +inside boundary-layer sites merely because their first-color values +were queried. + +We verify both the measurability and the conditional law at this +stage. Each spectator disk can be joined to the zero-height anchor +by paths outside \(B(y_0,R_0)\). One may choose paths in the ambient +triangulation, outside the search disk, to the anchored skeleton. +Their sums of the local increments from Lemma~\ref{lem:spin-lift} +give the absolute spectator heights, with the correct common lift +fixed at the anchor. Alternatively, portions of paths in +\(D\setminus\overline{B(y_0,R_0)}\) can detour around the interior +disk and then reach the boundary layer; their fixed compact +portions occur in every sufficiently fine approximation. +The ambient construction requires no microscopic regularity of that +last approach to the skeleton. Include all these exterior paths +and the pair data on the spectator disks in \(\mathcal G_\delta\). +Thus the entire discrete spectator product \(F_\delta\) is +\(\mathcal G_\delta\)-measurable, as an absolute-height observation, +not merely a spin observation. + +Every crossing cell of the selected contour is open with prescribed +first color. Its factor is constant and leaves the complementary +spin unrestricted. No imposed equality edge crosses the contour. +By Lemma~\ref{lem:cell-cut}, closed-cell complementary components +on its two sides are disconnected. Hence revealing exterior labels +reveals no strictly interior component label. +The stopped query convention likewise fixes no further strictly +interior first-color variables. Conditional on +\(\mathcal G_\delta\), the unexamined interior is exactly the +open-cut law with no inner pins or equalities. +Its height lift may have an exterior-dependent additive constant; +both local tests have exactly zero total and discard that constant. + +The cut surrounds a ball of radius comparable to \(\sqrt r\). +The retained-law and exterior-measurability verifications above allow +us to apply Corollary~\ref{cor:conditional-plane-matching}. It couples +the increments +in \(B(y_0,Cr)\), with its connecting paths, to the fixed plane +increment marginal \(\nu_\delta\) with error +\(C(r/\sqrt r)^{\kappa_2}\), uniformly in each successful exterior +record. For every such record choose a coupling kernel whose +second marginal is this same \(\nu_\delta\). On failed searches +choose an independent variable with marginal \(\nu_\delta\). +These are ordinary conditional couplings on finite discrete +spaces; the finite ambient volume may subsequently be exhausted +using the same local comparison. In particular the resulting +plane variable \(P_\delta\) satisfies +\[ + \Prob(P_\delta\in A\mid\mathcal G_\delta)=\nu_\delta(A) +\] +for every measurable event \(A\), also on failure. This identity +proves genuine independence of \(P_\delta\) from +\(\mathcal G_\delta\), and therefore from \(F_\delta\). +It is stronger than specifying just its unconditional marginal. + +Write \(U_\delta=h_\delta(\alpha_r)\), +\(V_\delta=h_\delta(\beta_r)\), and let \(U'_\delta,V'_\delta\) +be the corresponding statistics of this plane copy. +Matching increments in a connected disk implies equality of both +statistics because their area weights have exact total zero. +If \(E_\delta\) is the union of search failure and coupling mismatch, +then for some \(\kappa>0\) +\[ + \limsup_{\delta\downarrow0}\Prob(E_\delta)\le Cr^\kappa. +\] +Cauchy--Schwarz and equality off \(E_\delta\) give +\begin{align} + &\left|\E[(U_\delta V_\delta-U'_\delta V'_\delta)F_\delta]\right| + \nonumber\\ + &\quad\le + \Prob(E_\delta)^{1/2} + \left(\|U_\delta V_\delta F_\delta\|_{L^2} + +\|U'_\delta V'_\delta F_\delta\|_{L^2}\right). + \label{eq:limit-coupling-error} +\end{align} +Applying H\"older inside each norm at an order at least \(2j\), +\eqref{eq:limit-small-moments} bounds the first norm by +\(C(1+\log(1/r))\). All fixed spectator norms are bounded. +The plane zero-total moment bound in +Proposition~\ref{prop:plane-moments} bounds the second norm uniformly. +Thus the mesh limsup of \eqref{eq:limit-coupling-error} is at most +\[ + Cr^{\kappa/2}(1+\log(1/r)), +\] +which tends to zero. + +For each fixed \(r\), first let the mesh tend to zero. +Moment convergence treats the true field and the spectators, +whereas independence factors the plane term as +\(\E[U'_\delta V'_\delta]\E[F_\delta]\). +Proposition~\ref{prop:plane-covariance} evaluates its first factor: +\[ + \lim_{\delta\downarrow0}\E[U'_\delta V'_\delta] + =\frac{v}{2\pi} + \iint\alpha_r(x)\log(1/|x-y|)\beta_r(y)\dd x\dd y + =\frac{v}{2\pi}I. +\] +The last equality uses exact zero totals to cancel the dilation +constant. Separate harmonicity and radial mean value give +\(\E F=T_{j-2}(\mathbf z)\). Only now let \(r\downarrow0\); +the preceding error bound proves \eqref{eq:limit-plane-factorization}. + +We read the same limit from \eqref{eq:limit-puncture}. +First average its spectator variables on their radial disks. +Their harmonic mean value property, including that for \(L\) +from Lemma~\ref{limit:puncture}, evaluates them at \(\mathbf z\). +After substituting \(x=y_0+ru\), \(y=y_0+rw\), the singular term is +\[ + \iint\alpha(u)\beta(w)L(y_0+rw,\mathbf z) + \{\log(1/r)+\log(1/|u-w|)\}\dd u\dd w . +\] +For every fixed \(w\), the term containing \(\log(1/r)\) is zero +because \(\int\alpha=0\). This cancellation is exact even though +\(L\) varies with the second colliding variable. +The remaining kernel is bounded on the two disjoint supports; +smoothness of \(L\) makes the remaining integral tend to +\(I L(y_0,\mathbf z)\). +For the regular term, subtract +\(R(y_0;y_0+rw,\mathbf z)\) before integrating against \(\alpha(u)\). +The uniform first-variable derivative bound from +Lemma~\ref{limit:puncture} bounds its contribution by \(Cr\). +The left side of \eqref{eq:limit-plane-factorization} therefore +tends to \(I L(y_0,\mathbf z)\). +Since \(I\ne0\), comparison proves \eqref{eq:limit-collision}. +\end{proof} + +\subsection{Wick recursion and convergence of the full law} + +The remaining identification uses harmonicity, prescribed collision +singularities, and the boundary condition. Related collision arguments +identify dimer-height moments in \cite[Section~3]{Kenyon2001} and +six-vertex moments in \cite[Section~7.2]{DCKLM2026}. +Here Proposition~\ref{prop:collision} gives the logarithmic coefficient +from a plane copy independent of the absolute-height spectators, and +Lemma~\ref{lem:no-diagonal} supplies the boundary value and excludes +additional distributions on collisions. + +\begin{theorem}[Moment identification and the full field law] +\label{thm:wick} +For every \(j\ge2\) and distinct \(x,y_2,\ldots,y_j\in D\), +\begin{equation} + T_j(x,y_2,\ldots,y_j) + =v\sum_{i=2}^j G_D(x,y_i)\, + T_{j-2}(y_2,\ldots,\widehat{y_i},\ldots,y_j). + \label{eq:limit-wick} +\end{equation} +Together with \(T_0=1\) and \(T_1=0\), this identifies every moment +distribution with that of \(\sqrt v\,\Phi_D\). +Every subsequential field limit has that law. Consequently +\(h_\delta/\sqrt v\) converges to \(\Phi_D\) as a random +distribution, with joint convergence of every finite collection of +smooth compactly supported pairings. +\end{theorem} + +\begin{proof} +Fix the distinct \(y_i\)'s and subtract the right side of +\eqref{eq:limit-wick} from its left side as a function of \(x\). +It is harmonic outside these finitely many points. +The Dirichlet Green function for the negative Euclidean Laplacian +has local singularity +\[ + \frac1{2\pi}\log(1/|x-y_i|). +\] +Proposition~\ref{prop:collision} shows that its coefficient agrees +with the logarithmic singularity of \(T_j\) at each point. +Lemma~\ref{limit:puncture} therefore makes the difference removable +there. It is harmonic on all of \(D\). +Equation~\eqref{eq:limit-zero-boundary} gives zero limit at every +boundary point, as does the Dirichlet Green function on a \(C^2\) +Jordan domain. Thus the difference extends continuously by zero +to the boundary. The maximum principle, applied to it and to its +negative, makes it identically zero. This proves +\eqref{eq:limit-wick}. The base \(T_1=0\) follows from the exact +height-reflection symmetry and uniform integrability. + +Induction gives zero for odd moments and, for even \(j\), the sum +over pairings of the products of \(vG_D\). +Lemma~\ref{lem:no-diagonal} says that these are identities of the +entire moment distributions, including tests crossing diagonals. +The Green products are locally integrable; in each pairing their +variables occur in disjoint pairs, and the logarithmic singularity +is integrable in two dimensions. +It follows that for every real \(f\in C_c^\infty(D)\), \(H(f)\) +has exactly the centered Gaussian moments with variance +\[ + v\iint_{D\times D}f(z)G_D(z,w)f(w)\dd z\dd w. +\] +These moments determine its law. One direct justification avoids +assuming an exponential moment in advance: the nonnegative series +for \(\cosh(tH(f))\), monotone convergence, and the known even +moments give +\(\E\cosh(tH(f))=\exp(t^2\Var(H(f))/2)\) for every real \(t\). +Since \(e^{|tH(f)|}\le2\cosh(tH(f))\), the exponential moment is +finite. The absolutely integrable power series for its +characteristic function then yields the Gaussian characteristic +function. This also covers zero variance. + +Apply this conclusion to +\(f=\sum_{\ell=1}^k a_\ell f_\ell\), for every real vector +\((a_1,\ldots,a_k)\). All these real linear combinations are +Gaussian with the stated covariance form. Their characteristic +functions identify the joint vector +\((H(f_1),\ldots,H(f_k))\) with that of +\(\sqrt v\,\Phi_D\). + +Finally choose a countable dense family of smooth tests on an +interior exhaustion of \(D\). Evaluation on these tests determines +a distribution and generates the Borel sigma-field of the local +Sobolev spaces used in Proposition~\ref{prop:tightness}; this follows, +for example, from their realization by countably many localized +Fourier coordinates. Hence equality of the finite-dimensional +laws on this family determines the random-distribution law. +We chose the original subsequence arbitrarily, so every limit +allowed by tightness has the same law. Tightness and uniqueness +give convergence of the full sequence, for each \(t>1\) in +\(H^{-t}_{\mathrm{loc}}(D)\), and therefore as distributions. +Continuity of test evaluation gives the claimed simultaneous +test limits, and Proposition~\ref{prop:tightness} also gives their +mixed-moment convergence. + +The normalization is \(\sigma(x)=\sqrt v\). +Its strict positivity, finiteness, and independence of \(D\) and +the approximation were proved in +Proposition~\ref{prop:plane-covariance}. All estimates here are +for fixed \(x\) in the stated closed interval, so the endpoint is +included with no additional limiting argument in the parameter. +This completes the proof of Theorem~\ref{thm:main}. +\end{proof} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/08-scalar-spectra.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/08-scalar-spectra.tex new file mode 100644 index 0000000000000000000000000000000000000000..c82addb1994cfda8c51d69265cf3a58a90ce50ce --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/08-scalar-spectra.tex @@ -0,0 +1,153 @@ +\section{Scalar spectral measures}\label{sec:scalar-spectra} + +The spectral arguments in Sections~\ref{sec:plane} and \ref{sec:pins} +use scalar covariance measures and bounded analytic matrix elements. +We construct these objects directly. Inner products in this appendix +are conjugate linear in the first variable. Haar measure on a torus +is normalized to have mass one. + +\begin{lemma}[Commuting translations]\label{spectra:unitary} +Let $V_1,\ldots,V_d$ be commuting unitaries on a complex Hilbert space. +For vectors $a,b$ there is a unique finite complex measure $\mu_{a,b}$ +on the $d$-torus such that +\[ + \int e^{i\mathbf n\cdot\theta}\,\mu_{a,b}(\dd\theta) + =\langle a,V_1^{n_1}\cdots V_d^{n_d}b\rangle + \qquad(\mathbf n\in\Z^d). +\] +The measure $\mu_{a,a}$ is positive, has mass $\|a\|^2$, and +$\|\mu_{a,b}\|_{\TV}\le\|a\|\|b\|$. For Laurent polynomials $P,Q$, +\[ + \mu_{P(V)a,Q(V)b} + =\overline{P(e^{i\theta})}Q(e^{i\theta})\mu_{a,b}. +\] +If $P_0$ is the orthogonal projection onto the common invariant +subspace, then $\mu_{a,b}(\{0\})=\langle P_0a,P_0b\rangle$. +\end{lemma} + +\begin{proof} +For a vector $a$ and an integer $N\ge1$, consider the nonnegative density +\[ + K_{N,a}(\theta)=N^{-d} + \left\|\sum_{0\le n_1,\ldots,n_d0$ such that +\[ + F_{a,b}(j)=\langle a,S^jb\rangle\quad(j=1,2,\ldots), + \qquad |F_{a,b}(w)|\le\|a\|\|b\|. +\] +It is obtained by integrating $\lambda^w$ against the $[0,1]$ +marginal of $\gamma_{a,b}$, with value zero at $\lambda=0$. +\end{corollary} + +\begin{proof} +Take $U=I$ in Lemma~\ref{spectra:transfer} if no tangential operator +is present. For $\lambda>0$ put +$\lambda^w=\exp(w\log\lambda)$ and set it equal to zero at zero. +When $\Re w>0$ its absolute value is at most one, giving the bound +and the positive-integer identities. On each closed smaller +half-plane $\Re w\ge\eta>0$, every +$\lambda^\eta|\log\lambda|^r$ is bounded for integer $r\ge0$. +Dominated differentiation against the finite cross measure proves +holomorphy. No value or continuity at exponent zero is asserted. +\end{proof} diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/09-annulus.tex b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/09-annulus.tex new file mode 100644 index 0000000000000000000000000000000000000000..e999726220ce2d0e3d3283bac14082b0038037c7 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/build/sections/09-annulus.tex @@ -0,0 +1,941 @@ +\section{The weighted annulus estimate}\label{sec:annulus} + +Theorem~\ref{thm:circuit-input} follows from a mixed-cylinder crossing +estimate and the renormalization argument of \cite[Appendix~A]{GL2025}. +We prove the required seed estimate using both signs of the first-spin +crossing and both orientations of the cell lattice. A winding +construction converts a seed of either orientation to the one required +by the cylinder convention. + +\subsection{Cuts and comparisons on a cylinder} + +Write $Y$ and $Z$ for the two classes of elementary triangle centers, +with $Y$ the class used in Section~\ref{sec:discrete}, and put $q=x^2$. +An occupation of class $T\in\{Y,Z\}$ uses the cell table +\eqref{discrete:cell-table} on triangles of that class. +For a periodic rows-cylinder of height $H$, let $P_T$ denote its mixed +law: $B=+$ on its top face layer, $B=-$ on its bottom face layer, +$W$ free, with factors $q$ on changing interior $T$ cells and no factors +on boundary $T$ cells. Thus the class specifies the boundary convention +as well as the augmentation. All contours and test regions below have +positive clearance; lattice rounding changes their positions by $O(1)$. + +\begin{lemma}[Ambient extension]\label{annulus:ambient} +Take a finite triangulation of the sphere containing a periodic triangular +lattice cylinder. Choose any edge-disjoint family of elementary triangles +in that cylinder, make each a cell of parameter $q=x^2$, and make each +remaining edge a cell of parameter $x$, or of parameter $1$ on a specified +set of edges. Use coherent spin pairs and the cell table +\eqref{discrete:cell-table}. Proposition~\ref{prop:history-order} holds +for this law, including deterministic $W$-equality edges and its stated +first-spin histories. The selected triangles may have either orientation. + +A simple authorized winding contour in the cylindrical portion, with no +$W$-equality edge crossing it, has the cut property of +Lemma~\ref{lem:cell-cut}. In particular, prescribing a +lower open-minus and an upper open-plus contour of class $T$ realizes +$P_T$ between those contours, when they bound the rows-cylinder. +\end{lemma} +\begin{proof} +Cap a longer periodic cylinder at each end by a triangulated disk; +triangular fans suffice. Every mod-two cycle on this sphere is generated +by triangular face boundaries. Consequently, for fixed $B=b$, a possible +$W$ disagreement set satisfies the same triangle equations as in the proof +of Proposition~\ref{prop:history-order}. On a mixed-$b$ triangle its +single homogeneous edge cannot belong to that set. Restricting to +homogeneous-plus edges or to homogeneous-minus edges therefore separately +preserves every triangle equation. Each restriction integrates to a spin +configuration, and the wall factorization \eqref{discrete:wall-factor} +holds, with its same factor $1/2$. + +For an unobserved triangle cell, $r_y(b)$ is $1$ or $x^2$ according as +$b$ is constant or mixed; for an edge cell it is $1$ or that edge's +parameter. On an unobserved homogeneous cell the corresponding allowed +wall-edge parameter is $x$, or the specified single-edge parameter; +on an observed open cell it is $1$. Equality edges have parameter zero +in the wall partition sums. The cell inequality for $r_y$ and the +intersection/union inequalities for the two allowed-edge vectors are +unchanged. The Ising partition-sum inequality +\eqref{discrete:Z-lattice} thus proves the same two-law inequality. +Restoring statuses uses only disjointness of the cells' edge sets. +This proves association and conditional order, including parameters $1$. + +For the cut assertion, include among the selected triangles all cells +responsible for authorizing the contour. Each crossing cell has its first +spins prescribed and contributes a constant, exactly as in +Lemma~\ref{lem:cell-cut}; the remaining factors separate. This proof is +local and applies to a winding contour, which separates the capped sphere. +The equality constraints do not cross the contour by hypothesis. +Two such cuts isolate the law between them. The excluded boundary-cell +factors are precisely the constants removed by the cuts. No extra winding +constraint is imposed: an annular configuration satisfying the cut-layer +pins extends coherently to either cap by taking the prescribed first spin +constant there, and the exterior partition factors are independent of the +interior second spins. +\end{proof} + +In applications of Lemma~\ref{annulus:ambient}, triangles of opposite +orientations are selected only in separated regions. Unused augmentations +are marginalized, and all remaining edges are single-edge cells. We do not +assert joint association for overlapping $Y$ and $Z$ augmentations. + +\begin{lemma}[One complementary-color cut]\label{annulus:one-white} +The comparison of Lemma~\ref{annulus:ambient} for $B$ and signed +$B$ statuses remains valid with one prescribed open $W$ winding contour +of fixed sign, provided that its cells are disjoint from the selected +$B$ cells. Histories still observe no other $W$ labels. +\end{lemma} +\begin{proof} +An open $W$ triangle with prescribed sign contributes the constant $q$ +for every assignment of its $B$ spins. Represent its prescription by +single-edge parameters $1$ on its three edges and by $W$ equality along +those edges, then specify the common $W$ label. The incident-site union +of the contour cells is connected: consecutive cells along the contour +share a site. Before that label is specified, global $W$ flip pairs the +two possible labels with equal weight, for every $B$ and every permitted +$B$-status history. Specifying its sign therefore multiplies each such +marginal weight by $1/2$. It does not change the order comparison. +Apply Lemma~\ref{annulus:ambient} with these deterministic equality edges. +\end{proof} + +\begin{lemma}[Boundary slides]\label{annulus:slide} +Let $\mu_{a,b}$ be the law between a lower open-minus $B$ contour $a$ +and an upper open-plus $B$ contour $b$. If the contours are ordered +from bottom to top as +\[ + a_10. +\] +Consequently conditioning on $A$ changes the probability of any event +measurable off the patch by bounded factors depending only on $x,M$. +\end{lemma} +\begin{proof} +At most $M$ exterior complementary-spin components meet the patch. +Restrict their free labels to agree, losing a factor at most +$2^{(M-1)_+}$, and set all patch complementary spins to this common +label. Choose the compatible first-spin extension. On every +unprescribed cell select its open status if homogeneous, and its closed +status if mixed. All its local weights are positive. If $a(x)>0$ is +the least positive member of $x,x^2,1-x,1-x^2$, omitting zero entries, +the resulting local weight is at least $a(x)^M$. There are at most +$2^M3^M2^M$ local spin/status assignments, each of weight at most one. +These bounds give a uniform lower bound for the ratio of the restricted +and unrestricted conditional partition sums. In particular the +argument includes $x=1$: a prescribed closed cell must then be mixed. +For an exterior marginal $\mu$, conditioning multiplies its density by +$f/\mu(f)$, where $c\leq f=\Prob(A\mid\hbox{exterior})\leq1$. +This proves the last assertion. +\end{proof} + +We will use this lemma only with a fixed-width collar between the +changed sites and any incompatible exterior pin. Common occupied +paths prescribe their own first-spin sites and are retained throughout. +In each application below the other fixed sites are on a disjoint +minus wall. Extend these compatible first-spin values across the +collar arbitrarily and set the complementary spin constant. This +verifies the extension hypothesis; it does not require a finite-energy +assertion for a site already fixed by an opposite open cell. + +\begin{lemma}[Equalities on a fixed plus layer] +\label{annulus:plus-equalities} +In the law of Lemma~\ref{annulus:ambient}, fix a permitted history +and an equality set $E_0$. Let $F$ be a set of edges both of whose +endpoints are pinned $B=+$. Adding the equalities $W_u=W_v$ for +$uv\in F$ stochastically decreases the joint law of $B$ and signed +$B$ statuses. There is no restriction on the number of edges in $F$. +\end{lemma} +\begin{proof} +Use $E_-=E_0\cup F$ for the lower law and $E_+=E_0$ for the upper +law in \eqref{discrete:wall-factor}. For first-spin configurations +$b,c$, put $m=b\wedge c$ and $j=b\vee c$. On $F$ the plus-wall +vectors satisfy +\[ + a_-^+(m)=0=a_-^+(b)\wedge a_+^+(c),\qquad + a_+^+(j)\geq a_+^+(c)=a_-^+(b)\vee a_+^+(c). +\] +All minus-wall coordinates on $F$ vanish, since its endpoints are +common plus pins. Off $F$ the four inequalities in the proof of +Proposition~\ref{prop:history-order} are unchanged. The cell factors +$r_y$ do not depend on the equality set. Thus monotonicity and +log-supermodularity of $Z$ prove the same two-law inequality for the +first-spin marginals. + +To restore statuses, first couple these marginals in order. In the +conditional plus-cell weights \eqref{discrete:subset-weight}, write +$A_-(S)$ and $A_+(T)$ for the allowed wall-edge vectors of lower and +upper open-cell sets. Their sorted vectors obey +\[ + A_-(S\cap T)\geq A_-(S)\wedge A_+(T),\qquad + A_+(S\cup T)\geq A_-(S)\vee A_+(T). +\] +On $F$ the first comparison is $0\geq0$ and the second is the +inclusion of the upper open set in its union; elsewhere these are the +usual cell-set comparisons. The Bernoulli factors cancel in the +resulting two-law inequality. No cell containing an edge of $F$ can +be eligible for minus occupation, so the minus-status comparison is +unchanged. The ordered status kernels complete the joint coupling. +The nonnegative-weight argument applies also at $x=1$. +\end{proof} + +\begin{lemma}[A straight short-direction crossing] +\label{annulus:straight-short} +Fix a cell class $T$ and $0<\eta<1/2$. In triangular coordinates let +$P=[0,3r]\times[0,r]$. Give its long sides open-plus $B$ cuts and +its short sides open-minus $B$ cuts, exclude their boundary-cell +factors, and leave complementary-spin labels unobserved. Use feasible +bounded transition patches at the four corners. There is +$c=c(x,\eta)>0$, independent of $r$, such that, for all sufficiently large $r$, an occupied-plus +$T$-site path in $P$ crosses from height $\eta r$ to height +$(1-\eta)r$ with probability at least $c$. +\end{lemma} +\begin{proof} +All crossings below use the induced triangular site graph. Lattice +rows and boundary contours are chosen with the fixed collars of +Lemma~\ref{annulus:patch}; that lemma absorbs the bounded corner +changes. The crossing between the two displayed interior heights is +measurable away from these patches for sufficiently large $r$. + +Divide $P$ into three rhombi $R_1,R_2,R_3$ of width $r$. An ordinary +$B$-plus vertical crossing in each outer rhombus has probability bounded +below. Indeed, impose an adverse open-minus cut on its inner side. +Conditional order and the finite corner/port comparison reduce the +bound to an alternating open-arc rhombus. Reflection in its ascending +diagonal, followed by reversal of $B$, preserves that law and exchanges +an ordinary plus vertical crossing with a minus horizontal crossing. +Ordinary triangular-site duality gives a positive lower bound for +these two symmetric alternatives. Both outer crossing events are +increasing; association gives their intersection probability at least +$c_0(x)>0$. The auxiliary adverse cuts were used only to compare the +two individual probabilities and are not retained. + +Run the following searches in the original law, without conditioning +on the two ordinary-crossing events. Explore the $B$-minus component +attached to the left short side, and similarly the component attached +to the right short side. Reveal first spins only, and declare failure +if either component reaches the middle rhombus. Retain the full Peierls interface +separating each explored component from the middle rhombus, including +all its excursions. The intersection of the two ordinary-crossing events guarantees that +each interface is confined to its outer rhombus, since its ordinary +plus crossing blocks the attached minus component. Thus the successful +records have probability at least $c_0(x)$. On each such record, fill +holes on the explored side and retain the region $D_0$ +between the two interfaces. Its interior is unobserved, and +\[ + R_2\subseteq D_0\subseteq P. +\] +Along either lateral interface the outer first spin is minus and the +inner first spin is plus. Each selected mixed triangle contributes the +constant $q=x^2$ and forces its three complementary spins to agree. +Successive selected triangles share a face. Thus each full lateral +interface supplies one connected $W$-equality chain, regardless of its +length or excursions. The constants cancel after conditioning on the +exploration record. Away from the bounded corner patches, the top and +bottom remain open-plus cuts and impose no $W$ equality. + +Reflect in the ascending diagonal of $R_2$. In these coordinates +\[ + \rho(u,v)=(r+v,u-r),\qquad D=D_0\cup\rho(D_0). +\] +This reflection preserves the chosen cell class. For example, with +$\omega=e^{i\pi/3}$, $\Lambda=\Z+\omega\Z$ and +$Y=\Lambda-i/\sqrt3$, its linear part is $z\mapsto\omega\bar z$, +and $\omega\overline{(-i/\sqrt3)}+i/\sqrt3=\omega-1\in\Lambda$. +The same holds for $Z$. The inclusions above give +\[ + \rho(D_0)\cap P=R_2,\qquad D\cap P=D_0. +\] +The union is a simply connected symmetric domain: its lower and upper +reflected arms attach to $D_0$ along the bottom and top sides of $R_2$. +The construction is made on the actual lattice contours with matching +endpoint collars. + +Put $A=(r,0)$, $C=(2r,r)$, $B_0=(2r,0)$ and $D_1=(r,r)$. +Reflection fixes $A,C$ and exchanges $B_0,D_1$. The boundary arc +$AB_0$ surrounds the lower reflected arm, and $CD_1$ surrounds the +upper one. Any occupied site connection between these two arcs has a +bottom-to-top subcrossing of $P$ entirely in $D_0$: take its segment +after the last bottom-side visit before the first subsequent top-side +visit. It therefore contains the crossing between the two interior +heights in the statement. No confinement of this subcrossing to $R_2$ +is required. + +On $D$ take the excluded-boundary-cell law with $B=+$ on its inner +boundary layer and with $W$ constant, of unspecified sign, on that +layer. Denote it by $\nu_D$. This is the equal mixture of the two laws +with boundary spin pairs $(+,+)$ and $(+,-)$; global $W$ reversal +preserves all $B$-occupation events. For the $(+,+)$ law, occupied-site +super-duality, reflection and interchange of colors give +\begin{equation}\label{annulus:symmetric-short} + \nu_D(AB_0\mathrel{\longleftrightarrow}_{\xi^{B,+}}CD_1) + \geq\tfrac12. +\end{equation} +This is precisely the site-arc convention of +\cite[Lemma~3.17]{GL2025}: the two alternative color crossings have +union of probability one, and symmetry equates their probabilities. +Their disjointness is not required. The sign of a crossing incident to +the corresponding boundary layer is plus. + +Where the old top and bottom cuts lie in the interior of $D$, prescribe +them open-plus. These are increasing first-spin/status prescriptions, +so association preserves the lower bound +\eqref{annulus:symmetric-short}. Their open factors are constants and +remove all $W$ interaction across them. On old top/bottom pieces that +lie on $\partial D$, the boundary factors are already excluded; no +additional exterior minus pins are imposed on the sites of those +open cells. This convention avoids a conflict between an open-plus +cell and an exterior minus spin in the same cell. + +We compare the resulting law in $D_0$ with the law left by the actual +exploration. The old top/bottom pieces outside the middle rhombus lie +on $\partial D$ and hence have constant $W$ under $\nu_D$. In the +actual law add exactly these equalities, along edges whose endpoints +are already pinned $B=+$ by the open cut. By +Lemma~\ref{annulus:plus-equalities}, this decreases all increasing +$B$-occupation events, with no loss depending on the number of edges. +No equality is added on the old top/bottom pieces that run through the +interior of $D$, namely the middle-rhombus pieces. + +After this lowering, the two laws have identical retained cell +factors, first-spin pins, and long boundary equality chains. The two +lateral chains, extended along their adjacent old top/bottom boundary +pieces, contain every remaining complementary-spin connection to the +exterior, except for the bounded transition patches. Their sites all +have fixed boundary first-spin data. The remaining exterior can only +identify these two chains or leave their labels separate. For fixed +retained $(B,\tau)$, such an identification changes the complementary +spin sum by a factor in $\{1,1/2\}$; after normalization the two +marginal densities differ by at most a factor two. Mixtures over +unobserved exterior statuses preserve this bound. Applying +Lemmas~\ref{annulus:ports} and \ref{annulus:patch} to the finitely many +additional corner components gives a uniform factor $c_1(x)>0$. + +Consequently, for every successful ordinary-interface exploration +record, the original probability of the occupied crossing between the +interior heights is at least $c_1(x)/2$. Averaging over those records +and using their probability at least $c_0(x)$ proves the assertion. +All modifications at the corners are compatible bounded patches and +all other comparisons are monotone or involve the two connected +boundary chains. Thus no bound depends on a boundary length. The +argument and the patch lemma include $x=1$. +\end{proof} + +\begin{figure}[tbp] + \centering + \input{figures/annulus-stepped-domain.tex} + \caption{The stepped reference region for the separated-path comparison. + The full upper and lower paths stay outside the central crossing band. + Orange patches contain the four actual endpoint records. The dashed + sides bound the central $3:1$ comparison parallelogram; both those + sides and the event $E$ are separated from the endpoint patches. + The vertical coordinate is expanded, and fixed-width outward shifts + and corner rounding are omitted.} + \label{annulus:fig-stepped} +\end{figure} + +\begin{lemma}[A separated-path crossing] +\label{annulus:gluing} +Use triangular coordinates $(u,v)$, with $u$ horizontal, and a fixed +cell class $T$. Let +\[ + P_L=[0,6\ell]\times[0,\ell],\qquad + P_R=[\ell,7\ell]\times[0,\ell] +\] +be embedded parallelograms in a matching mixed cylinder. Let $\Gamma_L$ +be the uppermost occupied-plus horizontal crossing of $P_L$ and +$\Gamma_R$ the lowermost one of $P_R$. Suppose that $\Gamma_L$ lies +above $3\ell/4$ and $\Gamma_R$ below $\ell/4$. +For all sufficiently large $\ell$ there is $c=c(x)>0$, uniform in +the feasible extremal pair and in $\ell$, such that, conditional on +this pair, with probability at least +$c$ there is an occupied-plus vertical crossing between heights +$3\ell/10$ and $7\ell/10$ in the horizontal window +$[5\ell/4,23\ell/4]$. +The cylinder and lattice rounding are required to leave a fixed-width +collar around the displayed parallelograms. +\end{lemma} +\begin{proof} +We prove the estimate uniformly after refining the two extremal paths +to their exterior exploration records. The upper exploration reveals +only the part of $P_L$ above its full crossing, and the lower one only +the part of $P_R$ below its full crossing, together with the prescribed +first-spin layers on the crossings. All observed statuses include +all their first-spin sites. No complementary-spin label is revealed. +The path version of the invasion argument in +Lemma~\ref{annulus:search} gives these records. Use the actual +authorized honeycomb boundary of the explored face set to realize each +extremal crossing. Every queried cell meeting both sides is then an +open boundary cell; its retained first spins are its prescribed plus +layer. This avoids revealing an additional strip along an arbitrary +interpolation of a site path. We retain the full crossings, including +all their excursions near a side. + +Construct a stepped reference region $S$. Its upper portion has +horizontal range $[0,6\ell]$ and vertical range +$[\ell/2,5\ell/4]$; its lower portion has horizontal range +$[\ell,7\ell]$ and vertical range $[-\ell/4,\ell/2]$. +Move each of its two stepped sidewalls outward by a fixed number of +lattice spacings, say twenty, and round to honeycomb paths. The top +and bottom sides are likewise chosen as actual lattice contours. +The steps lie at height near $\ell/2$, at positive macroscopic distance +from both extremal paths. + +Join the actual four endpoints of the full crossings to the respective +outer sidewalls through four bounded patches. The region $D$ between +the two full paths and these sidewalls is unobserved outside those +patches. Indeed its upper part is below the full $\Gamma_L$ in $P_L$, +and its lower part is above the full $\Gamma_R$ in $P_R$. In their +overlap the two statements hold simultaneously, since the height bands +are separated. The narrow strips introduced outside a side of a +parallelogram were not queried by its exploration; the other exploration +is separated from them in height. Thus the only extra recorded sites +or cells introduced by an endpoint join lie in its bounded patch. +This uses the full paths: no discarded prefix is placed in $D$. + +Prescribe the two adverse sidewalls open-minus, stopping them before +the endpoint patches. They lie in the unobserved region and are +disjoint from the occupied-plus crossings. By conditional order this +can only decrease the probability of the desired central vertical +crossing; the rarity of the prescribed walls incurs no probability +factor. We next make bounded, compatible completions in the endpoint +patches. Let $h$ be the complete original record in those patches: +retain every recorded first spin and status, including all first-spin +sites of each recorded cell. Retain also the plus pins forced by the +crossings. The new minus walls are separated from these sites by the +fixed outward displacement. Choose a compatible completion $A$ only +in a bounded core, keeping an outer collar unprescribed except for the +common crossing and wall pins. The fixed first-spin values are +compatible; extend them across this free collar and set the +complementary spin constant. On unprescribed core cells choose open +status when homogeneous and closed status when mixed. Include every +cell incident to a mutable core site in the patch. Thus +Lemma~\ref{annulus:patch} gives a uniform positive lower bound for $A$. +At $x=1$, recorded closed cells keep their already recorded mixed first +spins. Write $h^*=(h,A)$, and keep this complete bounded history in all +reference laws below. No arbitrary part of the original record is +removed by a finite-energy assertion. + +Let $\nu_{S,h^*}$ be a reference law with open-plus top and bottom arcs, +open-minus stepped sidewalls, and this same history $h^*$ in the four +endpoint cores. Realize the law in a filled ambient triangulation by +these cell and first-spin prescriptions, with a fixed feasible +completion of its outer corner cells and no complementary-spin labels. +Its top and bottom are at distance at least $\ell/4$ from the original +parallelograms, so their prescribed plus layers do not meet $h^*$. +The law is positively associated by Lemma~\ref{annulus:ambient}. + +Condition this reference law on the two full paths being occupied-plus. +The law in $D$ has the same retained cell factors and first-spin pins +as the original record completed by $A$. Every other boundary cell is +open and removes the complementary-spin interaction across its arc. +Choose each completed core to contain its entire short endpoint join, +including every non-open cell crossing the chosen boundary of $D$ and +all its first-spin sites. The boundary enters and leaves the free outer +collar only along the common open crossing or wall arcs. Thus every +cross-boundary cell outside the completed cores is already open. All +other cross-boundary first spins and statuses are fixed in $h^*$; only +the uniformly bounded number of complementary-spin sites in those +cores can communicate with the exterior. Lemma~\ref{annulus:ports} compares the +two retained laws with a uniform factor, independently of the exterior +complementary-spin wiring. The original endpoint history $h^*$ is +kept on both sides of this comparison. + +Write $E$ for the vertical crossing of the central height interval in +the statement. Its support, including the incident first-spin sites of its cells, +lies in $D$ for sufficiently large $\ell$; the full comparison rectangle +need not lie in $D$. The bounded displacement between the occupied site +path and its authorized exploration boundary is absorbed by the strict +height gaps. Its horizontal window is at macroscopic distance from +all actual endpoint patches, whose horizontal coordinates are near +$0,6\ell,\ell,7\ell$. The fixed corners of $S$ are also outside this +window. The lower bound for $A$, followed by the port comparison, +gives +\begin{equation}\label{annulus:record-comparison} + \Prob(E\mid\hbox{original record}) + \geq c_1(x)\, + \nu_{S,h^*}(E\mid\Gamma_L,\Gamma_R\hbox{ occupied-plus}) + \geq c_1(x)\,\nu_{S,h^*}(E). +\end{equation} +The last inequality is association: the full-path prescriptions are +increasing, with every first-spin site of each path cell included. +All constants are uniform in the retained bounded history $h^*$. + +It remains to bound $\nu_{S,h^*}(E)$. In the reference law alone, prescribe +two additional open-minus walls at horizontal positions $5\ell/4$ +and $23\ell/4$, ending a bounded distance before the top and bottom +plus arcs. This decreases $E$. Complete the four new transition +patches as above. These walls and patches are at macroscopic distance +from every actual endpoint patch. The central region is a straight +parallelogram of width $9\ell/2$ and height $3\ell/2$, hence aspect +ratio three. Exact cut factorization off its corners and +Lemmas~\ref{annulus:ports}--\ref{annulus:patch} compare its law with +the alternating open-arc law of +Lemma~\ref{annulus:straight-short}. Lemma~\ref{annulus:straight-short}, with $r=3\ell/2$ and +$\eta=11/30$, bounds below the probability of the crossing $E$ itself: +its two heights are +$-\ell/4+(11/30)(3\ell/2)=3\ell/10$ and +$-\ell/4+(19/30)(3\ell/2)=7\ell/10$. +It follows that +$\nu_{S,h^*}(E)\geq c_2(x)>0$. + +The additional interior minus walls were imposed only in $\nu_{S,h^*}$, +after removing the conditioning on the actual crossings in +\eqref{annulus:record-comparison}. They are therefore not required to +be compatible with paths that might cross them. Combining the two +bounds and averaging over the exterior exploration records proves the +lemma. All exceptional corner adjustments involve a bounded number +of cells, with free outer collars and compatible common pins as above. +\end{proof} + +\subsection{A seed with either cell orientation} + +We give the scale and extraction conventions once. Fix $C\geq3$ and +work in the mixed cylinder in (58) of \cite{GL2025}, with circumference +$L\sim2Cn$ and height $H\sim5n$. These relations only allow the usual +bounded changes needed to select actual lattice rows. Choose +$m=\lfloor\varepsilon H\rfloor$, where $\varepsilon>0$ is a fixed small +constant, for instance $10^{-5}$. Every construction below fits with +this choice; making $\varepsilon$ smaller by a fixed factor would only +change constants. We first take $n$ large enough for all clearances to +exceed a fixed number of lattice spacings. + +A band of height $m+O(1)$ supplies a finite family of tests as follows. +Lift paths to the flat cover of the cylinder, and put horizontal centers +on a net of spacing at most $m/4$. If a vertical crossing has horizontal +extent at most $5m$, a window of width $5.5m$ contains it. Trim its +vertical ends to obtain a vertical test of width six times its height, +with height between $.96m$ and $.99m$, after the allowed lattice +rounding. If its extent is greater than $5m$, take a subpath between +vertical lines separated by $4.4m$ and trim it to a horizontal test +of width four times its height, with height between $1.01m$ and +$1.05m$. The latter window encloses the original band vertically. +An occupied winding also supplies horizontal tests of this type. The +slack permits the specified centers, lattice rows, and crossing-side +conventions to be adjusted before trimming. There are finitely many +tests, with their number bounded in terms of $C$ and $\varepsilon$, not +$n$. We call a lower bound for one of these tests a \emph{seed}. + +\begin{lemma}[Seed with a matching class]\label{annulus:first-seed} +There is $c=c(x,C)>0$ such that, for each sufficiently large $n$, one of +$T=Y,Z$ has a seed of occupied $B$-plus cells, under the matching mixed +law $P_T$, in a band of height comparable to $m$ centered near $.71H$. +The seed is a horizontal crossing of aspect ratio four or a vertical +crossing of aspect ratio six. The choice of class and test may depend +on $n$; the lower bound $c$ does not. +\end{lemma} +\begin{proof} +Start under $P_Y$ with a thin band $S$ centered near $H/3$. +Lemma~\ref{annulus:duality} gives a vertical occupied $B$ crossing of +one sign, or a winding occupied $W$ circuit of one sign. The sum of +the probabilities of these four events is at least one. + +A $B$-plus vertical crossing gives a $Y$ seed by the finite-family +extraction above. The slide comparison of Lemma~\ref{annulus:slide} +moves its test upward. A $B$-minus vertical crossing is reflected +across the horizontal middle line of the cylinder, followed by a flip +of $B$. The resulting law is $P_Z$, including its boundary-cell +convention: horizontal reflection interchanges the two cell classes. +It gives a $Z$ plus seed near $2H/3$, which can again be moved upward. +Neither step asserts a color-preserving symmetry of a fixed $P_Y$ law. + +It remains to treat a $W$ winding. Global $W$ flip lets us take its +sign to be plus, at a loss of at most a factor two. Search from below +in a slightly enlarged band, as in Lemma~\ref{annulus:search}. On a +successful record the retained upper region lies above one open +$W$-plus winding $\gamma$ of class $Y$ and below the original upper +$B$-plus cut. All tests used next lie in its unobserved part. + +Choose a horizontal lattice reflection axis near $.69H$. The reflection +of $\gamma$ lies strictly above the old top, since +$2(.69)-1/3>1$ and the search band is thin. Move the top $B$-plus cut +up to that reflected contour, now of class $Z$. By +Lemma~\ref{annulus:one-white} and the cut comparison, this move +\emph{decreases} every increasing $B$-plus test. The law between +$\gamma$ and its reflection is invariant under reflection followed by +exchange of the two spin colors. This follows from the coherent edge +weight and the exact cut factors; the transformation also transports +$Y$ tests to $Z$ tests. + +Apply band duality near the reflection axis, using fresh $Y$ +augmentation. The finite extraction gives a family of $B$ seeds of +either sign and $W$ horizontal seeds of either sign whose probabilities +have sum bounded below. Reflection and color exchange turn the $W$ +seeds into $Z$-oriented $B$ seeds. For either orientation a minus seed +has probability at most that of the corresponding plus seed: flipping +$B$ changes the top prescribed cut from plus to minus while retaining +the one $W$-plus cut, and Lemma~\ref{annulus:one-white} orders these +two laws. Consequently a fixed finite family of $B$-plus tests, in the +two orientations, has total probability bounded below in the symmetric +law, uniformly over the successful search record. + +The same lower bound holds in the original law above $\gamma$, by +the comparison that moved the top upward. Its index family can be +chosen independently of $\gamma$: the search band, reflection axis, +and enlarged test windows are deterministic and separated. Averaging +over successful records therefore gives a positive lower bound for +one of those tests under $P_Y$. If that test uses class $Z$, its +augmentation is fresh and unobserved. Apply the slide comparison, +changing the boundary class to that of the test, to move it upward and +obtain an ordinary matching $P_Z$ experiment. The same comparison +moves a $Y$ test upward within $P_Y$. + +All three branches can thus be placed near $.71H$, with clearance +between every old and new cut when their classes differ. Taking the +minimum of the finitely many bounds proves the lemma. The sum bound is +obtained before choosing its successful member, so no random test is +selected inside a conditional probability. +\end{proof} + +\subsection{A winding and recovery of the requested orientation} + +Apply \eqref{annulus:RSW} if the seed in +Lemma~\ref{annulus:first-seed} is vertical. We have a positive lower +bound for an occupied horizontal plus crossing in the matching law +$P_T$. If $T=Y$, horizontal lengthening gives the horizontal crossing +required in (58), inside its target band $[3n,4n]$: the seed is near +$.71H\sim3.55n$ and its height is much smaller than $n$. It remains +to treat $T=Z$. We do not identify opposite-orientation augmentations +at the same location. + +\begin{lemma}[Winding from the matching seed]\label{annulus:winding} +Under $P_Z$, the horizontal seed above implies a positive lower bound +for an occupied $B$-plus winding of class $Z$ in a thin neighborhood of +height $.71H$, entirely below $.73H$. The bound is uniform in $n$. +\end{lemma} +\begin{proof} +We first obtain a short vertical crossing in a controlled horizontal +window. Use the two overlapping width-$6\ell$ parallelograms of +Lemma~\ref{annulus:gluing}, choosing their vertical height to be about +$50m$. Their total horizontal span is less than $500m$. Place their bottom at, or just +above, the seed band. In a thin band above relative height $40m$, +request a horizontal crossing through the left parallelogram; in one +below relative height $10m$, request a horizontal crossing through the +right parallelogram. These estimates follow from the original +horizontal seed, upward translation by Lemma~\ref{annulus:slide}, and +horizontal lengthening with fixed aspect ratios. Cross rectangles +extending beyond the parallelogram's sloping sides and then trim the +paths to those sides. Association makes the intersection of the two +requests have probability bounded below. + +Let $\Gamma_L$ be the uppermost crossing of the full left +parallelogram and $\Gamma_R$ the lowermost crossing of the full right +one. A crossing in the upper thin band separates the top side from the +region below that band; hence the uppermost crossing stays above +relative height $39m$, allowing lattice rounding. Similarly the +lowermost right crossing stays below height $11m$. Thus the two +thin-band requests imply that the pair $(\Gamma_L,\Gamma_R)$ lies in +a set $\mathcal G$ of separated realizations in gluing order. + +For each realization in $\mathcal G$, +Lemma~\ref{annulus:gluing} gives a vertical crossing of the central gap +with conditional probability at least $c_0>0$. The bounds $39m$ and +$11m$ put the extremals above three quarters and below one quarter of +their height-$50m$ parallelograms. We condition only on the two +extremal crossings, not additionally on the thin-band requests. +Averaging gives a lower bound $c_0\Prob(\mathcal G)$, and +$\Prob(\mathcal G)$ is at least the probability of the requests. +The resulting crossing runs between relative heights $15m$ and $35m$ +in a horizontal window of width at most $500m$. This supplies the +required local vertical-crossing estimate. + +Place a thin horizontal band about relative height $25m$, strictly +between these two vertical levels. Translate the vertical-crossing +window to two seam neighborhoods separated by about $L/2$. Their +widths are much smaller than $L$. Request also two horizontal +crossings in the thin band: one follows each of the two arcs between +the seams, and each extends beyond the whole vertical window at both +ends. These horizontal rectangles have length, for example, about +$3L/4$, so each is embedded in the cylinder. Their crossing estimates +are ordinary horizontal lengthenings. All four events are increasing +in the same signed $B$-status field. Association bounds the probability +of their intersection below by a positive constant. + +On that intersection both horizontal paths meet the vertical path in +each seam neighborhood, by planar site crossing. In the flat cover, +the first horizontal path connects seam 1 to seam 2 on its right, and +the second connects seam 2 to the next periodic copy of seam 1. The +connections therefore join a site path to its translate by one full +period. Its projection contains a noncontractible occupied circuit. +The interpolation to authorized honeycomb edges changes its position +by only a bounded number of lattice spacings and yields a simple +winding cut in a slightly larger band. All these bands remain below +$.73H$ because $m/H$ is fixed and sufficiently small. +\end{proof} + +\begin{proposition}[The mixed-cylinder seed estimate] +\label{annulus:seed} +For every fixed $C\geq3$ there is $\delta=\delta(x,C)>0$ such that, +for all sufficiently large $n$, +\begin{equation}\label{annulus:seed-bound} + P_Y\bigl(\mathsf H_Y^+([-2n,2n]\times[3n,4n])\bigr)\geq\delta +\end{equation} +on the mixed cylinder $\mathrm{Cyl}_{Cn,5n}$ of +\cite[Appendix~A]{GL2025}, with the same lattice rounding convention. +\end{proposition} +\begin{proof} +Only the $T=Z$ branch remains after Lemma~\ref{annulus:first-seed} +and \eqref{annulus:RSW}. By Lemma~\ref{annulus:winding}, with +probability bounded below an exterior search finds a $Z$-oriented +$B$-plus winding below $.73H$. Above a successful record the retained +law is between that plus cut and the original upper plus cut. It is +therefore above the free capped-sphere law for increasing $B$-plus +tests: prescribing either plus cut is an increase by +Lemma~\ref{annulus:ambient}. Tests of class $Y$ well above the +explored band use disjoint, fresh cells, so this comparison applies to +them too. + +Test a thin band near $.75H$ using class $Y$. The free sphere law is +invariant under the two spin flips and exchange of the spin colors. +Band duality and finite extraction therefore imply a positive lower +bound for the sum of a fixed finite family of $Y$-oriented $B$-plus +seed probabilities. These spin symmetries do not require spatial +translation or reflection symmetry of the caps. The lower bound holds +in every retained law between the two plus cuts. Average over +successful records, and then choose one member of the deterministic +family. This gives a $Y$ seed under $P_Z$. + +Finally slide the boundary cuts and change their class to $Y$, moving +the test to height near $.77H$. Lemma~\ref{annulus:slide} preserves +the lower bound and gives the matching mixed law $P_Y$. The clearance +between old and new cuts guarantees that the cell families used in +this comparison are edge-disjoint. Apply \eqref{annulus:RSW} if the +seed is vertical, then horizontally lengthen to width $4n$. Since +$.77H\sim3.85n$ and all vertical bands used here are much thinner than +$n$, the resulting path stays in $[3n,4n]$. It is the crossing in +\eqref{annulus:seed-bound}. +\end{proof} + +\subsection{The annulus estimate and the field theorem} + +\begin{proof}[Proof of Theorem~\ref{thm:circuit-input}] +Proposition~\ref{annulus:seed} proves the horizontal alternative in +(58) of \cite{GL2025}. We now use the implications of that source's +Appendix~A. The RSW estimate (56) and horizontal lengthening convert +(58) into the pushing estimate (57); the comparison between rectangle +and cylinder has exactly the boundary-cell convention realized by our +cuts. Pushing gives the renormalization inequality (23), and its +non-exponential-decay branch, selected by the exclusion argument on +pp.~44--45 of \cite{GL2025}, gives equation (55). Those implications +use association, domain Markov comparison, the weighted site-crossing +inputs already specified, and qualitative delocalization. Their output is precisely +an occupied plus circuit under an excluded-boundary-cell law with the +first color minus on its boundary layer and the second color free. +Lemma~\ref{lem:cell-cut} identifies this with the law used in the +statement of Theorem~\ref{thm:circuit-input}. + +Our seed proof was for sufficiently large lattice scales. The finitely +many remaining admissible $n$ can be absorbed by decreasing the +constant. The condition $n\geq3/(a-1)$ implies +$\lfloor an\rfloor-n\geq3$, so a plus ring can be placed around layer +$n+1$, with plus first spins through layer $n+2$, minus first spins on +the outer prescribed boundary layer, and constant second spin. Force +the finitely many ring cells open. This is a feasible positive-weight +configuration for every $x\in[1/\sqrt2,1]$. Thus each of those finite +probabilities is positive. Spin flips and color exchange give the +other versions of the theorem. +\end{proof} + +The dependence of the proof is +\[ + \text{cut and order lemmas, (56), local site gluing} + \ \Longrightarrow\ \eqref{annulus:seed-bound} + \ \Longrightarrow\ (57),(23),(55). +\] +The seed uses only the local cut, order, and crossing inputs displayed +above. Theorem~\ref{thm:circuit-input} supplies the annulus estimate +in Lemma~\ref{lem:buffer-circuits}. +Proposition~\ref{prop:plane-covariance} gives $v\in(0,\infty)$ with +the Euclidean-area convention. Section~\ref{sec:limit} then proves +tightness, the Wick recursion, and all mixed-moment convergence with +$\sigma(x)=\sqrt v$ for the inside approximations of +Theorem~\ref{thm:main}. diff --git a/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/paper.pdf b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..690200f46eec83919e4f649102867ed974332892 --- /dev/null +++ b/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3dae0156982e5d205484a60ebb25c02591cf8a67cb7ce0ea0abf5486bdaaa61b +size 930006 diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/README.md b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2294f5f304f18568dff66f7178686b82c4077b9e --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/README.md @@ -0,0 +1,21 @@ +# [Goldfeld's analytic density conjecture and the 2-converse for elliptic curves](paper.pdf) + +**Author:** OpenAI + +**Date:** October 7, 2026 + +## Citation + +```bibtex +@misc{OAI:Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026, + author = {{OpenAI}}, + title = {{Goldfeld's analytic density conjecture and the $2$-converse for elliptic curves}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf}{OAI:Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026}}, + year = {2026} +} +``` + +## Version note + +This version updates citations to revised manuscripts in this collection; see the [previous version](../Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-September-23-2026/paper.pdf). diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/main.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..68c2237e6017f253afa56114ba05658671a84c72 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/main.tex @@ -0,0 +1,108 @@ +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage[a4paper,margin=30mm]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{microtype} +\usepackage{enumitem,booktabs,tabularx,array,longtable,mathrsfs,graphicx,flafter} +\usepackage{pict2e} +\usepackage[numbers,sort&compress]{natbib} +\usepackage{xcolor} +\usepackage{xurl} +\usepackage[hypertexnames=false,colorlinks=true,linkcolor=blue!45!black,citecolor=blue!45!black,urlcolor=blue!45!black]{hyperref} +\usepackage[capitalise,noabbrev,nameinlink]{cleveref} +\ifdefined\pdfinfoomitdate\pdfinfoomitdate=1\fi +\ifdefined\pdftrailerid\pdftrailerid{}\fi +\ifdefined\pdfsuppressptexinfo\pdfsuppressptexinfo=15\fi +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\newtheorem{claim}[theorem]{Claim} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{convention}[theorem]{Convention} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newcommand{\Q}{\mathbb Q} +\newcommand{\Z}{\mathbb Z} +\newcommand{\R}{\mathbb R} +\newcommand{\C}{\mathbb C} +\newcommand{\N}{\mathbb N} +\newcommand{\F}{\mathbb F} +\newcommand{\Qtwo}{\mathbb Q_2} +\newcommand{\Ztwo}{\mathbb Z_2} +\DeclareMathOperator{\Gal}{Gal} +\DeclareMathOperator{\Sel}{Sel} +\DeclareMathOperator{\Sha}{Sha} +\DeclareMathOperator{\corank}{corank} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\length}{length} +\DeclareMathOperator{\Fr}{Fr} +\DeclareMathOperator{\Frob}{Frob} +\DeclareMathOperator{\Cl}{Cl} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\Ext}{Ext} +\DeclareMathOperator{\Aut}{Aut} +\DeclareMathOperator{\End}{End} +\DeclareMathOperator{\Spec}{Spec} +\DeclareMathOperator{\coker}{coker} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\res}{res} +\DeclareMathOperator{\cor}{cor} +\DeclareMathOperator{\GL}{GL} +\DeclareMathOperator{\SL}{SL} +\DeclareMathOperator{\tr}{tr} +\DeclareMathOperator{\diag}{diag} +\DeclareMathOperator{\supp}{supp} +\DeclareMathOperator{\Nrd}{Nrd} +\setlist{topsep=4pt,itemsep=2pt,parsep=0pt} +\setlist[itemize]{label=$\bullet$} +\setcounter{tocdepth}{1} +\emergencystretch=2em +\DeclareMathOperator{\Tr}{Tr} +\DeclareMathOperator{\Nm}{Nm} +\DeclareMathOperator{\adj}{adj} +\DeclareMathOperator{\id}{id} +\theoremstyle{definition} +\newtheorem{hypothesis}[theorem]{Hypothesis} +\newtheorem{assumption}[theorem]{Assumption} +\newtheorem{conjecture}[theorem]{Conjecture} +\newtheorem{example}[theorem]{Example} +\numberwithin{equation}{section} +\title{Goldfeld's analytic density conjecture\\and the $2$-converse for elliptic curves} +\author{OpenAI} +\date{October 7, 2026} +\hypersetup{pdftitle={Goldfeld's analytic density conjecture and the 2-converse for elliptic curves},pdfauthor={OpenAI},pdfsubject={Quadratic twists and the low-corank 2-converse}} +\begin{document} +\maketitle +\begin{abstract} +We prove Goldfeld's analytic density conjecture: for every elliptic curve +$E$ over $\Q$, the quadratic twists of $E$ with analytic rank zero and one +each have density $1/2$ among signed squarefree twist parameters ordered by +absolute value. We also prove the low-corank $2$-converse: if the +$2^\infty$-Selmer corank of $E$ is zero or one, then it equals the analytic +and Mordell--Weil ranks, and the Tate--Shafarevich group is finite. +\end{abstract} +\tableofcontents +\clearpage +\input{sections/00-introduction} +\input{sections/01-preliminaries} +\input{sections/01-arithmetic-transfer} +\input{sections/05-coefficients} +\input{sections/06-traces} +\input{sections/07-prime-graphs} +\input{sections/08-rational-converse} +\input{sections/09-local-matrices} +\input{sections/10-irreducible-converse} +\input{sections/01-nonvanishing} +\input{sections/02-binary-algebra} +\input{sections/04-cyclotomic} +\input{sections/03-heegner} +\input{sections/11-conclusions} +\bibliographystyle{plainnat} +\bibliography{references} +\end{document} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/references.bib b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..e731256ac5b548c58e9707aa24ce8a762b4b273f --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/references.bib @@ -0,0 +1,1093 @@ +@incollection{Goldfeld1979, + author = {Goldfeld, Dorian}, + title = {Conjectures on elliptic curves over quadratic fields}, + booktitle = {Number Theory, Carbondale 1979}, + editor = {Nathanson, Melvyn B.}, + series = {Lecture Notes in Mathematics}, + volume = {751}, + pages = {108--118}, + publisher = {Springer}, + address = {Berlin}, + year = {1979}, + doi = {10.1007/BFb0062705}, + url = {https://www.math.columbia.edu/~goldfeld/ConjecturesonEllipticCurves.pdf} +} + +@misc{Smith2025, + author = {Smith, Alexander}, + title = {The {Birch} and {Swinnerton-Dyer} conjecture implies {Goldfeld}'s conjecture}, + year = {2025}, + note = {arXiv:2503.17619, version 1}, + eprint = {2503.17619}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + doi = {10.48550/arXiv.2503.17619}, + url = {https://arxiv.org/abs/2503.17619v1} +} + +@article{CaiShuTian2014, + author = {Cai, Li and Shu, Jie and Tian, Ye}, + title = {Explicit {Gross--Zagier} and {Waldspurger} formulae}, + journal = {Algebra \& Number Theory}, + volume = {8}, + number = {10}, + pages = {2523--2572}, + year = {2014}, + doi = {10.2140/ant.2014.8.2523}, + url = {https://msp.org/ant/2014/8-10/ant-v8-n10-p05-p.pdf} +} + +@incollection{Kato2004, + author = {Kato, Kazuya}, + title = {{$p$}-adic {Hodge} theory and values of zeta functions of modular forms}, + booktitle = {Cohomologie {$p$}-adiques et applications arithm\'etiques ({III})}, + editor = {Berthelot, Pierre and Fontaine, Jean-Marc and Illusie, Luc and Kato, Kazuya and Rapoport, Michael}, + series = {Ast\'erisque}, + number = {295}, + pages = {117--290}, + publisher = {Soci\'et\'e Math\'ematique de France}, + year = {2004}, + url = {https://www.numdam.org/item/AST_2004__295__117_0/} +} + +@article{BurungaleTian2026, + author = {Burungale, Ashay A. and Tian, Ye}, + title = {A rank zero {$p$}-converse to a theorem of {Gross--Zagier}, {Kolyvagin} and {Rubin}}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {203}, + number = {1}, + pages = {1--13}, + year = {2026}, + doi = {10.4007/annals.2026.203.1.1}, + note = {Theorem numbering follows arXiv:2506.03465v2 (\url{https://arxiv.org/abs/2506.03465v2})}, + url = {https://annals.math.princeton.edu/2026/203-1/p01} +} + +@article{Cassels1965, + author = {Cassels, J. W. S.}, + title = {Arithmetic on curves of genus 1. {VIII}. {On} conjectures of {Birch} and {Swinnerton-Dyer}}, + journal = {Journal f\"ur die reine und angewandte Mathematik}, + volume = {217}, + pages = {180--199}, + year = {1965}, + doi = {10.1515/crll.1965.217.180}, + url = {https://doi.org/10.1515/crll.1965.217.180} +} + +@book{Neukirch1999, + author = {Neukirch, J\"urgen}, + title = {Algebraic Number Theory}, + series = {Grundlehren der mathematischen Wissenschaften}, + volume = {322}, + publisher = {Springer}, + address = {Berlin}, + year = {1999}, + note = {Translated from the German by Norbert Schappacher}, + doi = {10.1007/978-3-662-03983-0}, + url = {https://link.springer.com/book/10.1007/978-3-662-03983-0} +} + +@article{RadziwillSoundararajan2015, + author = {Radziwi{\l}{\l}, Maksym and Soundararajan, K.}, + title = {Moments and distribution of central {$L$}-values of quadratic twists of elliptic curves}, + journal = {Inventiones Mathematicae}, + volume = {202}, + number = {3}, + pages = {1029--1068}, + year = {2015}, + doi = {10.1007/s00222-015-0582-z}, + url = {https://www.math.mcgill.ca/radziwill/QuadraticTwists.pdf} +} + +@article{Iwaniec1990, + author = {Iwaniec, Henryk}, + title = {On the order of vanishing of modular {$L$}-functions at the critical point}, + journal = {Journal de th\'eorie des nombres de Bordeaux}, + volume = {2}, + number = {2}, + pages = {365--376}, + year = {1990}, + doi = {10.5802/jtnb.33}, + url = {https://www.numdam.org/item/JTNB_1990__2_2_365_0/} +} + +@article{HeathBrown1995, + author = {Heath-Brown, D. R.}, + title = {A mean value estimate for real character sums}, + journal = {Acta Arithmetica}, + volume = {72}, + number = {3}, + pages = {235--275}, + year = {1995}, + doi = {10.4064/aa-72-3-235-275}, + url = {https://doi.org/10.4064/aa-72-3-235-275} +} + +@article{ErdosKac1940, + author = {Erd{\H{o}}s, Paul and Kac, Mark}, + title = {The {Gaussian} law of errors in the theory of additive number theoretic functions}, + journal = {American Journal of Mathematics}, + volume = {62}, + pages = {738--742}, + year = {1940}, + doi = {10.2307/2371483}, + url = {https://www.renyi.hu/~p_erdos/1940-12.pdf} +} + +@article{GrossZagier1986, + author = {Gross, Benedict H. and Zagier, Don B.}, + title = {{Heegner} points and derivatives of {$L$}-series}, + journal = {Inventiones Mathematicae}, + volume = {84}, + number = {2}, + pages = {225--320}, + year = {1986}, + doi = {10.1007/BF01388809}, + url = {https://wiki.epfl.ch/waldspurger/documents/gross-zagier.pdf} +} + +@incollection{Kolyvagin1990, + author = {Kolyvagin, V. A.}, + title = {Euler systems}, + booktitle = {The {Grothendieck} Festschrift, Volume {II}}, + editor = {Cartier, Pierre and Illusie, Luc and Katz, Nicholas M. and Laumon, G{\'e}rard and Manin, Yuri I. and Ribet, Kenneth A.}, + series = {Progress in Mathematics}, + volume = {87}, + pages = {435--483}, + publisher = {Birkh\"auser}, + address = {Boston}, + year = {1990}, + mrnumber = {1106906}, + note = {Linked chapter is the 2007 reprint}, + url = {https://link.springer.com/chapter/10.1007/978-0-8176-4575-5_11} +} + +@article{Waldspurger1980, + author = {Waldspurger, Jean-Loup}, + title = {Correspondance de {Shimura}}, + journal = {Journal de Math\'ematiques Pures et Appliqu\'ees}, + series = {9}, + volume = {59}, + number = {1}, + pages = {1--132}, + year = {1980} +} + +@article{Waldspurger1981, + author = {Waldspurger, Jean-Loup}, + title = {Sur les coefficients de {Fourier} des formes modulaires de poids demi-entier}, + journal = {Journal de Math\'ematiques Pures et Appliqu\'ees}, + series = {9}, + volume = {60}, + number = {4}, + pages = {375--484}, + year = {1981}, + url = {https://mate.dm.uba.ar/~nsirolli/files/waldspurger.pdf} +} + +@inproceedings{Waldspurger1983, + author = {Waldspurger, Jean-Loup}, + title = {Correspondances de {Shimura}}, + booktitle = {Proceedings of the International Congress of Mathematicians, Warszawa, 1983}, + editor = {Ciesielski, Zbigniew and Olech, Czes{\l}aw}, + volume = {1}, + pages = {525--531}, + publisher = {PWN--Polish Scientific Publishers and Elsevier Science Publishers}, + address = {Warszawa and Amsterdam}, + year = {1984}, + url = {https://www.imj-prg.fr/wp-content/uploads/2020/prix/waldspurger1983.pdf} +} + +@article{Weil1964, + author = {Weil, Andr\'e}, + title = {Sur certains groupes d'op\'erateurs unitaires}, + journal = {Acta Mathematica}, + volume = {111}, + pages = {143--211}, + year = {1964}, + doi = {10.1007/BF02391012}, + url = {https://doi.org/10.1007/BF02391012} +} + +@incollection{Deligne1969, + author = {Deligne, Pierre}, + title = {Formes modulaires et repr\'esentations {$\ell$}-adiques}, + booktitle = {S\'eminaire {Bourbaki}, 1968/69}, + series = {Lecture Notes in Mathematics}, + volume = {179}, + pages = {139--172}, + publisher = {Springer}, + address = {Berlin}, + year = {1971}, + note = {Expos\'e 355, February 1969}, + url = {https://www.numdam.org/item/SB_1968-1969__11__139_0/} +} + +@article{Carayol1986, + author = {Carayol, Henri}, + title = {Sur les repr\'esentations {$\ell$}-adiques associ\'ees aux formes modulaires de {Hilbert}}, + journal = {Annales scientifiques de l'\'Ecole Normale Sup\'erieure}, + series = {4}, + volume = {19}, + number = {3}, + pages = {409--468}, + year = {1986}, + doi = {10.24033/asens.1512}, + url = {https://www.numdam.org/item/10.24033/asens.1512/} +} + +@article{JetchevKane2011, + author = {Jetchev, Dimitar and Kane, Ben}, + title = {Equidistribution of {Heegner} points and ternary quadratic forms}, + journal = {Mathematische Annalen}, + volume = {350}, + number = {3}, + pages = {501--532}, + year = {2011}, + doi = {10.1007/s00208-010-0568-5}, + eprint = {0908.3905}, + archivePrefix = {arXiv}, + note = {Section numbering follows arXiv:0908.3905v1}, + url = {https://arxiv.org/abs/0908.3905v1} +} + +@article{FerreroWashington1979, + author = {Ferrero, Bruce and Washington, Lawrence C.}, + title = {The {Iwasawa} invariant {$\mu_p$} vanishes for abelian number fields}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {109}, + number = {2}, + pages = {377--395}, + year = {1979}, + doi = {10.2307/1971116}, + url = {https://doi.org/10.2307/1971116} +} + +@article{Rohrlich1984, + author = {Rohrlich, David E.}, + title = {On {$L$}-functions of elliptic curves and cyclotomic towers}, + journal = {Inventiones Mathematicae}, + volume = {75}, + number = {3}, + pages = {409--423}, + year = {1984}, + doi = {10.1007/BF01388636}, + url = {https://doi.org/10.1007/BF01388636} +} + +@article{Rohrlich1988, + author = {Rohrlich, David E.}, + title = {{$L$}-functions and division towers}, + journal = {Mathematische Annalen}, + volume = {281}, + number = {4}, + pages = {611--632}, + year = {1988}, + doi = {10.1007/BF01456842}, + url = {https://doi.org/10.1007/BF01456842} +} + +@article{Rohrlich1989, + author = {Rohrlich, David E.}, + title = {Nonvanishing of {$L$}-functions for {$\mathrm{GL}(2)$}}, + journal = {Inventiones Mathematicae}, + volume = {97}, + number = {2}, + pages = {381--403}, + year = {1989}, + doi = {10.1007/BF01389047}, + url = {https://doi.org/10.1007/BF01389047} +} + +@article{Tate1966, + author = {Tate, John}, + title = {On the conjectures of {Birch} and {Swinnerton-Dyer} and a geometric analog}, + journal = {S\'eminaire Bourbaki}, + volume = {9}, + pages = {415--440}, + year = {1966}, + note = {Expos\'e 306}, + url = {https://www.numdam.org/item/SB_1964-1966__9__415_0/} +} + +@article{Cassels1962, + author = {Cassels, J. W. S.}, + title = {Arithmetic on curves of genus 1. {IV}. {Proof} of the {Hauptvermutung}}, + journal = {Journal f\"ur die reine und angewandte Mathematik}, + volume = {211}, + pages = {95--112}, + year = {1962}, + doi = {10.1515/crll.1962.211.95}, + url = {https://doi.org/10.1515/crll.1962.211.95} +} + +@article{Kramer1981, + author = {Kramer, Kenneth}, + title = {Arithmetic of elliptic curves upon quadratic extension}, + journal = {Transactions of the American Mathematical Society}, + volume = {264}, + number = {1}, + pages = {121--135}, + year = {1981}, + doi = {10.1090/S0002-9947-1981-0597871-8}, + url = {https://doi.org/10.1090/S0002-9947-1981-0597871-8} +} + +@article{DokchitserDokchitser2011, + author = {Dokchitser, Tim and Dokchitser, Vladimir}, + title = {Root numbers and parity of ranks of elliptic curves}, + journal = {Journal f\"ur die reine und angewandte Mathematik}, + volume = {658}, + pages = {39--64}, + year = {2011}, + doi = {10.1515/CRELLE.2011.060}, + eprint = {0906.1815}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/0906.1815} +} + +@article{DokchitserDokchitser2010, + author = {Dokchitser, Tim and Dokchitser, Vladimir}, + title = {On the {Birch--Swinnerton-Dyer} quotients modulo squares}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {172}, + number = {1}, + pages = {567--596}, + year = {2010}, + doi = {10.4007/annals.2010.172.567}, + url = {https://annals.math.princeton.edu/wp-content/uploads/annals-v172-n1-p11-p.pdf} +} + +@article{CesnaviciusImai2016, + author = {{\v C}esnavi{\v c}ius, K{\k e}stutis and Imai, Naoki}, + title = {The remaining cases of the {Kramer--Tunnell} conjecture}, + journal = {Compositio Mathematica}, + volume = {152}, + number = {11}, + pages = {2255--2268}, + year = {2016}, + doi = {10.1112/S0010437X16007624}, + url = {https://www.imo.universite-paris-saclay.fr/~kestutis.cesnavicius/kramer-tunnell.pdf} +} + +@book{IwaniecKowalski2004, + author = {Iwaniec, Henryk and Kowalski, Emmanuel}, + title = {Analytic Number Theory}, + series = {American Mathematical Society Colloquium Publications}, + volume = {53}, + publisher = {American Mathematical Society}, + address = {Providence, RI}, + year = {2004}, + doi = {10.1090/coll/053}, + url = {https://doi.org/10.1090/coll/053} +} + +@book{FriedlanderIwaniec2010, + author = {Friedlander, John and Iwaniec, Henryk}, + title = {Opera de cribro}, + series = {American Mathematical Society Colloquium Publications}, + volume = {57}, + publisher = {American Mathematical Society}, + address = {Providence, RI}, + year = {2010}, + doi = {10.1090/coll/057}, + url = {https://doi.org/10.1090/coll/057} +} + +@book{Serre1968, + author = {Serre, Jean-Pierre}, + title = {Abelian {$\ell$}-adic representations and elliptic curves}, + publisher = {W. A. Benjamin}, + address = {New York}, + year = {1968}, + note = {McGill University lecture notes, written with the collaboration of Willem Kuyk and John Labute}, + url = {https://www.math.mcgill.ca/darmon/courses/18-19/gs/serre-mcgill.pdf} +} + +@article{Serre1972, + author = {Serre, Jean-Pierre}, + title = {Propri\'et\'es galoisiennes des points d'ordre fini des courbes elliptiques}, + journal = {Inventiones Mathematicae}, + volume = {15}, + number = {4}, + pages = {259--331}, + year = {1972}, + doi = {10.1007/BF01405086}, + url = {https://wstein.org/sage_summer/bsd_comp/Serre-properties_galoisiennes_des_points_dordre_fini_des_courbes_elliptiques.pdf} +} + +@book{Nekovar2006, + author = {Nekov{\'a}{\v r}, Jan}, + title = {Selmer complexes}, + series = {Ast\'erisque}, + volume = {310}, + publisher = {Soci\'et\'e Math\'ematique de France}, + year = {2006}, + isbn = {978-2-85629-227-3}, + doi = {10.24033/ast.717}, + url = {https://www.numdam.org/item/AST_2006__310__R1_0/} +} + +@article{BreuilConradDiamondTaylor2001, + author = {Breuil, Christophe and Conrad, Brian and Diamond, Fred and Taylor, Richard}, + title = {On the modularity of elliptic curves over {$\mathbf Q$}: wild {$3$}-adic exercises}, + journal = {Journal of the American Mathematical Society}, + volume = {14}, + number = {4}, + pages = {843--939}, + year = {2001}, + doi = {10.1090/S0894-0347-01-00370-8}, + url = {https://www.ams.org/jams/2001-14-04/S0894-0347-01-00370-8/S0894-0347-01-00370-8.pdf} +} + +@article{AtkinLi1978, + author = {Atkin, A. O. L. and Li, Wen Ch'ing}, + title = {Twists of newforms and pseudo-eigenvalues of {$W$}-operators}, + journal = {Inventiones Mathematicae}, + volume = {48}, + number = {3}, + pages = {221--243}, + year = {1978}, + doi = {10.1007/BF01390245}, + url = {https://doi.org/10.1007/BF01390245} +} + +@article{Deuring1941, + author = {Deuring, Max}, + title = {Die {Typen} der {Multiplikatorenringe} elliptischer {Funktionenk\"orper}}, + journal = {Abhandlungen aus dem Mathematischen Seminar der Hansischen Universit\"at}, + volume = {14}, + pages = {197--272}, + year = {1941}, + doi = {10.1007/BF02940746}, + url = {https://doi.org/10.1007/BF02940746} +} + +@article{BirchSwinnertonDyer1965, + author={Birch, Bryan J. and Swinnerton-Dyer, H. P. F.}, + title={Notes on elliptic curves. {II}}, + journal={Journal f{\"u}r die reine und angewandte Mathematik},volume={218},pages={79--108},year={1965}, + note={\href{https://doi.org/10.1515/crll.1965.218.79}{doi:10.1515/crll.1965.218.79}} +} + +@article{Skinner2020, + author={Skinner, Christopher}, + title={A converse to a theorem of {Gross}, {Zagier}, and {Kolyvagin}}, + journal={Annals of Mathematics},volume={191},number={2},pages={329--354},year={2020}, + doi={10.4007/annals.2020.191.2.1}, + note={\href{https://annals.math.princeton.edu/wp-content/uploads/annals-v191-n2-p01-s.pdf}{primary text}} +} + +@misc{KellerYin2024, + author={Keller, Timo and Yin, Mulun}, + title={{$p$}-converse theorems for elliptic curves of potentially good ordinary reduction at {Eisenstein} primes}, + year={2024},note={\href{https://arxiv.org/abs/2410.23241v1}{arXiv:2410.23241v1}} +} + +@article{Howard2012, + author={Howard, Benjamin},title={The {Heegner} point {Kolyvagin} system}, + journal={Compositio Mathematica},volume={140},number={6},pages={1439--1472},year={2004}, + note={\href{https://doi.org/10.1112/S0010437X04000569}{doi:10.1112/S0010437X04000569}; + text at \href{https://arxiv.org/abs/1202.6340v1}{arXiv:1202.6340v1}} +} + +@book{MilneADT2006, + author={Milne, J. S.},title={Arithmetic Duality Theorems}, + edition={Second},publisher={BookSurge},year={2006}, + note={\href{https://www.jmilne.org/math/Books/ADTnot.pdf}{author's electronic edition}} +} + +@article{GelbartJacquet1978, + author={Gelbart, Stephen and Jacquet, Herv{\'e}}, + title={A relation between automorphic representations of {$\mathrm{GL}(2)$} and {$\mathrm{GL}(3)$}}, + journal={Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series={4},volume={11},number={4},pages={471--542},year={1978}, + note={\href{https://doi.org/10.24033/asens.1355}{doi:10.24033/asens.1355}} +} + +@article{Faltings1983, + author={Faltings, Gerd}, + title={Endlichkeitss{\"a}tze f{\"u}r abelsche {Variet{\"a}ten} {\"u}ber {Zahlk{\"o}rpern}}, + journal={Inventiones Mathematicae},volume={73},number={3},pages={349--366},year={1983}, + note={\href{https://doi.org/10.1007/BF01388432}{doi:10.1007/BF01388432}} +} + +@article{Bogomolov1980, + author={Bogomolov, Fedor}, + title={Sur l'alg{\'e}bricit{\'e} des repr{\'e}sentations {$l$}-adiques}, + journal={Comptes Rendus de l'Acad{\'e}mie des Sciences de Paris, S{\'e}rie A--B}, + volume={290},number={15},pages={A701--A703},year={1980} +} + +@article{Monsky1996, + author = {Monsky, Paul}, + title = {Generalizing the {Birch--Stephens} theorem. {I}. {Modular} curves}, + journal = {Mathematische Zeitschrift}, + volume = {221}, + pages = {415--420}, + year = {1996}, + doi = {10.1007/PL00004518}, + url = {https://link.springer.com/article/10.1007/PL00004518} +} + +@article{HoffsteinLuo1997, + author = {Hoffstein, Jeffrey and Luo, Wenzhi}, + title = {Nonvanishing of {$L$}-series and the combinatorial sieve}, + journal = {Mathematical Research Letters}, + volume = {4}, + number = {2--3}, + pages = {435--444}, + year = {1997}, + note = {With an appendix by David E. Rohrlich}, + doi = {10.4310/MRL.1997.v4.n3.a12}, + url = {https://www.intlpress.com/site/pub/files/_fulltext/journals/mrl/1997/0004/0003/MRL-1997-0004-0003-a012.pdf} +} + +@article{Bogomolov1981, + author = {Bogomolov, Fedor A.}, + title = {Points of finite order on an {Abelian} variety}, + journal = {Mathematics of the USSR-Izvestiya}, + volume = {17}, + number = {1}, + pages = {55--72}, + year = {1981}, + doi = {10.1070/IM1981v017n01ABEH001329}, + url = {https://www.mathnet.ru/eng/im1843}, + note = {Russian original published in 1980} +} + +@article{BFH1990, + author = {Bump, Daniel and Friedberg, Solomon and Hoffstein, Jeffrey}, + title = {Nonvanishing theorems for {$L$}-functions of modular forms and their derivatives}, + journal = {Inventiones Mathematicae}, + volume = {102}, + number = {3}, + pages = {543--618}, + year = {1990}, + doi = {10.1007/BF01233440}, + url = {https://wstein.org/papers/bib/bump-friedberg-hoffstein-nonvanishing.pdf} +} + +@book{BoschLutkebohmertRaynaud1990, + author = {Bosch, Siegfried and L\"utkebohmert, Werner and Raynaud, Michel}, + title = {N\'eron Models}, + series = {Ergebnisse der Mathematik und ihrer Grenzgebiete, 3. Folge}, + volume = {21}, + publisher = {Springer}, + address = {Berlin--Heidelberg}, + year = {1990}, + doi = {10.1007/978-3-642-51438-8}, + url = {https://link.springer.com/book/10.1007/978-3-642-51438-8} +} + +@book{MilneEC2021, + author = {Milne, J. S.}, + title = {Elliptic Curves}, + edition = {Second}, + publisher = {World Scientific}, + year = {2021}, + url = {https://www.jmilne.org/math/Books/EC2.pdf}, + note = {Author's electronic version} +} + +@article{Drinfeld1973, + author = {Drinfeld, V. G.}, + title = {Two theorems on modular curves}, + journal = {Functional Analysis and Its Applications}, + volume = {7}, + number = {2}, + pages = {155--156}, + year = {1973}, + doi = {10.1007/BF01078890}, + url = {https://www.mathnet.ru/rus/faa2422}, + note = {Russian original: Funktsional. Anal. i Prilozhen. 7(2), 83--84} +} + +@misc{MilneCFT2020, + author = {Milne, J. S.}, + title = {Class Field Theory}, + year = {2020}, + note = {Version 4.03, August 6, 2020}, + url = {https://www.jmilne.org/math/CourseNotes/CFT.pdf} +} + +@misc{MilneANT2020, + author = {Milne, J. S.}, + title = {Algebraic Number Theory}, + year = {2020}, + note = {Version 3.08, July 19, 2020}, + url = {https://www.jmilne.org/math/CourseNotes/ANT.pdf} +} + +@incollection{BlochKato1990, + author = {Bloch, Spencer and Kato, Kazuya}, + title = {{L}-functions and {Tamagawa} numbers of motives}, + booktitle = {The {Grothendieck} Festschrift, Vol. {I}}, + series = {Progress in Mathematics}, + volume = {86}, + publisher = {Birkh{\"a}user Boston}, + address = {Boston, MA}, + year = {1990}, + pages = {333--400}, + doi = {10.1007/978-0-8176-4574-8_9}, + url = {https://math.stanford.edu/~conrad/BSDseminar/refs/BKTamagawa.pdf} +} + +@article{Berger2003, + author = {Berger, Laurent}, + title = {{Bloch} and {Kato}'s exponential map: three explicit formulas}, + journal = {Documenta Mathematica}, + volume = {Extra Volume Kato}, + year = {2003}, + pages = {99--129}, + doi = {10.4171/DMS/3/3}, + url = {https://ems.press/books/dms/250/4889} +} + +@misc{SharifiIwasawa, + author = {Sharifi, Romyar}, + title = {{Iwasawa} Theory}, + year = {n.d.}, + howpublished = {Author's lecture notes}, + note = {Undated; version accessed 23 September 2026}, + url = {https://www.math.ucla.edu/~sharifi/iwasawa.pdf} +} + +@article{Shimura1981CriticalValues, + author = {Shimura, Goro}, + title = {The critical values of certain zeta functions associated with modular forms of half-integral weight}, + journal = {Journal of the Mathematical Society of Japan}, + volume = {33}, + number = {4}, + pages = {649--672}, + year = {1981}, + doi = {10.2969/jmsj/03340649}, + url = {https://www.jstage.jst.go.jp/article/jmath1948/33/4/33_4_649/_pdf} +} + +@article{PalDeVeraPiquero2019, + author = {Pal, Aprameyo and de Vera-Piquero, Carlos}, + title = {Pullbacks of {Saito--Kurokawa} lifts and a central value formula for degree 6 {$L$}-series}, + journal = {Documenta Mathematica}, + volume = {24}, + pages = {1935--2036}, + year = {2019}, + doi = {10.4171/DM/719}, + url = {https://ems.press/journals/dm/articles/8965649} +} + +@article{CornutJetchev2013, + author = {Cornut, Christophe and Jetchev, Dimitar}, + title = {Liftings of reduction maps for quaternion algebras}, + journal = {Bulletin of the London Mathematical Society}, + volume = {45}, + number = {2}, + pages = {370--386}, + year = {2013}, + doi = {10.1112/blms/bds098}, + url = {https://arxiv.org/abs/1012.0725v1}, + note = {Preprint locators refer to arXiv:1012.0725v1}, + eprint = {1012.0725}, + archivePrefix = {arXiv}, + primaryClass = {math.NT} +} + +@misc{Purkait2012, + author = {Purkait, Soma}, + title = {On {Shimura}'s decomposition}, + howpublished = {arXiv:1205.7086v2 [math.NT]}, + year = {2013}, + note = {Version 2, 4 April 2013; first posted in 2012}, + eprint = {1205.7086v2}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/1205.7086v2} +} + +@article{BarriosEtAl2025, + author = {Barrios, Alexander J. and Roy, Manami and Sahajpal, Nandita and Tallana, Darwin and Tobin, Bella and Wiersema, Hanneke}, + title = {Local data of elliptic curves under quadratic twist}, + journal = {Research in Number Theory}, + volume = {11}, + year = {2025}, + note = {Article 75, 39 pp.}, + doi = {10.1007/s40993-025-00650-w}, + url = {https://link.springer.com/article/10.1007/s40993-025-00650-w} +} + +@misc{Smith2017, + author = {Smith, Alexander}, + title = {{$2^\infty$}-{Selmer} groups, {$2^\infty$}-class groups, and {Goldfeld}'s conjecture}, + year = {2017}, + eprint = {1702.02325}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Version 2}, + url = {https://arxiv.org/abs/1702.02325v2} +} + +@article{SmithDistributionI, + author = {Smith, Alexander}, + title = {The distribution of {$\ell^\infty$}-{Selmer} groups in degree {$\ell$} twist families {I}}, + journal = {Journal of the American Mathematical Society}, + volume = {39}, + number = {1}, + pages = {1--72}, + year = {2026}, + doi = {10.1090/jams/1062}, + note = {Preprint locators refer to arXiv:2207.05674v2}, + eprint = {2207.05674}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/2207.05674v2} +} + +@article{SmithDistributionII, + author = {Smith, Alexander}, + title = {The distribution of {$\ell^\infty$}-{Selmer} groups in degree {$\ell$} twist families {II}}, + journal = {Journal of the American Mathematical Society}, + volume = {39}, + number = {2}, + year = {2026}, + eprint = {2207.05143}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Preprint locators refer to arXiv:2207.05143v2}, + url = {https://arxiv.org/abs/2207.05143v2} +} + +@article{SkinnerUrban2014, + author = {Skinner, Christopher and Urban, Eric}, + title = {The {Iwasawa} main conjectures for {$\mathrm{GL}_2$}}, + journal = {Inventiones Mathematicae}, + volume = {195}, + number = {1}, + pages = {1--277}, + year = {2014}, + doi = {10.1007/s00222-013-0448-1} +} + +@article{Zhang2014, + author = {Zhang, Wei}, + title = {Selmer groups and the indivisibility of {Heegner} points}, + journal = {Cambridge Journal of Mathematics}, + volume = {2}, + number = {2}, + pages = {191--253}, + year = {2014}, + doi = {10.4310/CJM.2014.v2.n2.a2} +} + +@article{CastellaWan2024, + author = {Castella, Francesc and Wan, Xin}, + title = {{Perrin-Riou}'s main conjecture for elliptic curves at supersingular primes}, + journal = {Mathematische Annalen}, + volume = {389}, + pages = {2595--2636}, + year = {2024}, + doi = {10.1007/s00208-023-02711-w} +} + +@article{BurungaleTian2020, + author = {Burungale, Ashay A. and Tian, Ye}, + title = {{$p$}-converse to a theorem of {Gross--Zagier}, {Kolyvagin} and {Rubin}}, + journal = {Inventiones Mathematicae}, + volume = {220}, + number = {1}, + pages = {211--253}, + year = {2020}, + doi = {10.1007/s00222-019-00929-7} +} + +@article{BurungaleCastellaSkinnerTian2022, + author = {Burungale, Ashay and Castella, Francesc and Skinner, Christopher and Tian, Ye}, + title = {{$p^\infty$}-{Selmer} groups and rational points on {CM} elliptic curves}, + journal = {Annales math{\'e}matiques du Qu{\'e}bec}, + volume = {46}, + pages = {325--346}, + year = {2022}, + doi = {10.1007/s40316-022-00203-y} +} + +@article{Tian2014, + author = {Tian, Ye}, + title = {Congruent numbers and {Heegner} points}, + journal = {Cambridge Journal of Mathematics}, + volume = {2}, + number = {1}, + pages = {117--161}, + year = {2014}, + doi = {10.4310/CJM.2014.v2.n1.a4} +} + +@misc{Kriz2022, + author = {Kriz, Daniel}, + title = {Supersingular main conjectures, {Sylvester}'s conjecture and {Goldfeld}'s conjecture}, + year = {2022}, + eprint = {2002.04767}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Version 5; first posted in 2020}, + url = {https://arxiv.org/abs/2002.04767v5} +} + +@misc{BurungaleSkinner2024, + author = {Burungale, Ashay and Skinner, Christopher}, + title = {A {$p$}-converse theorem for {CM} elliptic curves}, + year = {2024}, + eprint = {2210.10730}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Appendix A, pp. 51--54, to L. Alp{\"o}ge, M. Bhargava and A. Shnidman, Integers expressible as the sum of two rational cubes, version 3}, + url = {https://arxiv.org/abs/2210.10730v3} +} + +@article{Chevalley1935, + author = {Chevalley, Claude}, + title = {D{\'e}monstration d'une hypoth{\`e}se de {M. Artin}}, + journal = {Abhandlungen aus dem Mathematischen Seminar der Universit{\"a}t Hamburg}, + volume = {11}, + year = {1935}, + pages = {73--75}, + doi = {10.1007/BF02940714}, + url = {https://doi.org/10.1007/BF02940714} +} + +@misc{Yu2021, + author = {Yu, Qiyao}, + title = {{$p$}-Converse to a Theorem of {Gross--Zagier}, {Kolyvagin}, and {Rubin} for Small Primes}, + howpublished = {Senior thesis, California Institute of Technology}, + year = {2021}, + doi = {10.7907/ccbk-ht28}, + url = {https://thesis.caltech.edu/14225/}, + note = {Theorem 1, p.~2; acknowledgements, p.~iii} +} + +@article{Lang1956, + author = {Lang, Serge}, + title = {Algebraic Groups Over Finite Fields}, + journal = {American Journal of Mathematics}, + volume = {78}, + number = {3}, + pages = {555--563}, + year = {1956}, + doi = {10.2307/2372673} +} + +@article{Warning1935, + author = {Warning, Ewald}, + title = {Bemerkung zur vorstehenden Arbeit}, + journal = {Abhandlungen aus dem Mathematischen Seminar der Universit{\"a}t Hamburg}, + volume = {11}, + year = {1935}, + pages = {76--83}, + doi = {10.1007/BF02940715}, + url = {https://doi.org/10.1007/BF02940715} +} + +@misc{OpenAITwoPrimaryBSD2026, + author = {{OpenAI}}, + title = {{The two-primary Birch--Swinnerton-Dyer formula in Selmer corank at most one}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-two-primary-Birch-Swinnerton-Dyer-formula-in-Selmer-corank-at-most-one-October-6-2026/paper.pdf}{OAI:The-two-primary-Birch-Swinnerton-Dyer-formula-in-Selmer-corank-at-most-one-October-6-2026}}, + year = {2026} +} + +@misc{OpenAIAllPrimeSelmer2026, + author = {{OpenAI}}, + title = {{The Selmer converse for elliptic curves at every prime}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-Selmer-converse-for-elliptic-curves-at-every-prime-October-7-2026/main.pdf}{OAI:The-Selmer-converse-for-elliptic-curves-at-every-prime-October-7-2026}}, + year = {2026} +} + +@article{MurtyMurty1991, + author = {Murty, M. Ram and Murty, V. Kumar}, + title = {Mean values of derivatives of modular {$L$}-series}, + journal = {Annals of Mathematics}, + volume = {133}, + number = {3}, + pages = {447--475}, + year = {1991}, + doi = {10.2307/2944316}, + url = {https://mast.queensu.ca/~murty/murty-murty-annals.pdf} +} + +@article{PerelliPomykala1997, + author = {Perelli, Alberto and Pomyka{\l}a, Jacek}, + title = {Averages of twisted elliptic {$L$}-functions}, + journal = {Acta Arithmetica}, + volume = {80}, + number = {2}, + pages = {149--163}, + year = {1997}, + doi = {10.4064/aa-80-2-149-163}, + url = {https://matwbn.icm.edu.pl/ksiazki/aa/aa80/aa8024.pdf} +} + +@article{OnoSkinner1998, + author = {Ono, Ken and Skinner, Christopher}, + title = {Non-vanishing of quadratic twists of modular {$L$}-functions}, + journal = {Inventiones Mathematicae}, + volume = {134}, + number = {3}, + pages = {651--660}, + year = {1998}, + doi = {10.1007/s002220050275}, + url = {https://uva.theopenscholar.com/files/ken-ono/files/037_8.pdf} +} + +@article{James1998, + author = {James, Kevin}, + title = {{$L$}-series with nonzero central critical value}, + journal = {Journal of the American Mathematical Society}, + volume = {11}, + number = {3}, + pages = {635--641}, + year = {1998}, + doi = {10.1090/S0894-0347-98-00263-X}, + url = {https://www.math.clemson.edu/~kevja/PAPERS/JAMS.pdf} +} + +@article{Vatsal1998, + author = {Vatsal, Vinayak}, + title = {Rank-one twists of a certain elliptic curve}, + journal = {Mathematische Annalen}, + volume = {311}, + number = {4}, + pages = {791--794}, + year = {1998}, + doi = {10.1007/s002080050209}, + url = {https://www.math.ubc.ca/~vatsal/research/der.PDF} +} + +@article{KrizLi2019, + author = {Kriz, Daniel and Li, Chao}, + title = {{Goldfeld}'s conjecture and congruences between {Heegner} points}, + journal = {Forum of Mathematics, Sigma}, + volume = {7}, + pages = {e15}, + year = {2019}, + note = {80 pp.}, + doi = {10.1017/fms.2019.9} +} + +@article{KumarEtAl2024, + author = {Kumar, Sumit and Mallesham, Kummari and Sharma, Prahlad and Singh, Saurabh Kumar}, + title = {Moments of derivatives of modular {$L$}-functions}, + journal = {The Quarterly Journal of Mathematics}, + volume = {75}, + number = {2}, + pages = {715--734}, + year = {2024}, + doi = {10.1093/qmath/haae028}, + eprint = {2303.16864}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Preprint locators refer to arXiv:2303.16864v2}, + url = {https://arxiv.org/abs/2303.16864v2} +} + +@misc{KrizNordentoft2025, + author = {Kriz, Daniel and Nordentoft, Asbj{\o}rn Christian}, + title = {Horizontal {$p$}-adic {$L$}-functions}, + year = {2025}, + eprint = {2310.20678}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Version 3; first posted in 2023}, + url = {https://arxiv.org/abs/2310.20678v3} +} + +@article{TianYuanZhang2017, + author = {Tian, Ye and Yuan, Xinyi and Zhang, Shou-Wu}, + title = {Genus periods, genus points and congruent number problem}, + journal = {Asian Journal of Mathematics}, + volume = {21}, + number = {4}, + pages = {721--774}, + year = {2017}, + doi = {10.4310/AJM.2017.v21.n4.a5}, + url = {https://archive.intlpress.com/site/pub/files/_fulltext/journals/ajm/2017/0021/0004/AJM-2017-0021-0004-a005.pdf} +} + +@misc{SmithCongruent2016, + author = {Smith, Alexander}, + title = {The congruent numbers have positive natural density}, + year = {2016}, + eprint = {1603.08479}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {Version 2, 29 March 2016}, + url = {https://arxiv.org/abs/1603.08479v2} +} + +@article{BurungaleCastellaSkinner2025, + author = {Burungale, Ashay A. and Castella, Francesc and Skinner, Christopher}, + title = {Base change and {Iwasawa} main conjectures for {$\mathrm{GL}_2$}}, + journal = {International Mathematics Research Notices}, + volume = {2025}, + number = {8}, + pages = {rnaf082}, + year = {2025}, + doi = {10.1093/imrn/rnaf082}, + url = {https://web.math.ucsb.edu/~castella/BCS-print.pdf} +} + +@article{CastellaGrossiLeeSkinner2022, + author = {Castella, Francesc and Grossi, Giada and Lee, Jaehoon and Skinner, Christopher}, + title = {On the anticyclotomic {Iwasawa} theory of rational elliptic curves at {Eisenstein} primes}, + journal = {Inventiones Mathematicae}, + volume = {227}, + number = {2}, + pages = {517--580}, + year = {2022}, + doi = {10.1007/s00222-021-01072-y}, + eprint = {2008.02571}, + archivePrefix = {arXiv}, + primaryClass = {math.NT} +} + +@misc{OpenAIMeanAnalyticRank2026, + author = {{OpenAI}}, + title = {{The mean analytic rank of quadratic twists of elliptic curves}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/paper.pdf}{OAI:The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026}}, + year = {2026} +} + +@misc{Crainic2004, + author = {Crainic, Marius}, + title = {On the perturbation lemma, and deformations}, + year = {2004}, + eprint = {math/0403266}, + archivePrefix = {arXiv}, + primaryClass = {math.AT}, + note = {Version 1, 16 March 2004}, + url = {https://arxiv.org/abs/math/0403266v1} +} + +@article{Chaiken1982, + author = {Chaiken, Seth}, + title = {A combinatorial proof of the all minors matrix tree theorem}, + journal = {SIAM Journal on Algebraic and Discrete Methods}, + volume = {3}, + number = {3}, + pages = {319--329}, + year = {1982}, + doi = {10.1137/0603033} +} + +@article{FengXiong2004, + author = {Feng, Keqin and Xiong, Maosheng}, + title = {On elliptic curves {$y^2=x^3-n^2x$} with rank zero}, + journal = {Journal of Number Theory}, + volume = {109}, + number = {1}, + pages = {1--26}, + year = {2004}, + doi = {10.1016/j.jnt.2003.12.015} +} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/00-introduction.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/00-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..ebd10789c0abc95cca808cb6196dbdb10d05e94c --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/00-introduction.tex @@ -0,0 +1,336 @@ +\section{Introduction}\label{sec:introduction} + +Let $E$ be an elliptic curve over $\Q$. Write +\[ + a(E)=\ord_{s=1}L(E,s),\qquad r(E)=\rank_{\Z}E(\Q),\qquad + c_2(E)=\corank_{\Ztwo}\Sel_{2^\infty}(E/\Q). +\] +The Selmer group uses the local Kummer conditions at every place. +Its corank includes both the Mordell--Weil rank and any divisible +$2$-primary contribution from the Tate--Shafarevich group. +Modularity supplies the analytic continuation and functional equation +of $L(E,s)$ \citep{BreuilConradDiamondTaylor2001}. + +\begin{theorem}[The $2$-converse]\label{thm:main-converse} +For every elliptic curve $E/\Q$ with $c_2(E)\in\{0,1\}$, +\[ + a(E)=r(E)=c_2(E),\qquad \Sha(E/\Q)\text{ is finite}. +\] +\end{theorem} + +There is no restriction on reduction type, complex multiplication, +rational torsion, or rational isogenies. The hypothesis concerns the full +$2$-power Selmer corank; a Mordell--Weil rank bound alone does not give it. + +For a nonzero squarefree integer $d$, let $E^{(d)}$ denote the quadratic +twist of $E$, and set +\[ + \mathcal D(X)=\{d\in\Z:0<|d|\le X,\ d\text{ squarefree}\}. +\] +Thus positive and negative parameters are counted together and ordered +by absolute value. A residue class can fix the sign of the functional +equation; the half-density statement below concerns the full set +$\mathcal D(X)$. + +\begin{theorem}[Goldfeld's analytic density conjecture]\label{thm:main-density} +For every elliptic curve $E/\Q$ and each $j\in\{0,1\}$, +\[ + \lim_{X\to\infty} + \frac{\#\{d\in\mathcal D(X):a(E^{(d)})=j\}}{\#\mathcal D(X)} + =\frac12. +\] +Consequently the twists of analytic rank at least two have density zero. +For a density-one set of signed squarefree parameters $d$, the analytic +and Mordell--Weil ranks of $E^{(d)}$ agree and its whole +Tate--Shafarevich group is finite. +\end{theorem} + +The theorem follows by combining the pointwise $2$-converse with +Smith's distribution of full $2$-power Selmer coranks +\citep[Theorem~1.1]{Smith2025}. Section~\ref{sec:conclusions} gives +the deduction, including the passage from integer to squarefree +parameters. The main work of this paper is the pointwise converse. + +\subsection{Consequences and companion results} + +The converse has a finite-descent consequence. Put +\[ + d_2(E)=\dim_{\F_2}\Sel_2(E/\Q)-\dim_{\F_2}E(\Q)[2]. +\] + +\begin{corollary}[A finite Selmer criterion]\label{cor:finite-descent} +If $d_2(E)\in\{0,1\}$, then +\[ + a(E)=r(E)=c_2(E)=d_2(E),\qquad + \Sha(E/\Q)\text{ is finite},\qquad \Sha(E/\Q)[2^\infty]=0. +\] +\end{corollary} + +Thus a finite $2$-descent can certify the analytic rank and the vanishing +of the entire $2$-primary Tate--Shafarevich group in these two cases. +The proof uses the alternating Cassels--Tate pairing to pass from +$d_2(E)$ to the full Selmer corank, and is given in +Section~\ref{sec:conclusions}. + +The density theorem resolves the frequency assertion for analytic ranks +zero and one. The mean analytic-rank assertion requires additional +control: a set of density zero can still contribute to the rank-weighted +average. The separate companion +\citet[Theorems~1.1 and~1.2]{OpenAIMeanAnalyticRank2026} proves the +required analytic tail estimate and, together with +Theorem~\ref{thm:main-density}, obtains mean analytic rank $1/2$ +in the same signed squarefree ordering. + +A subsequent companion \citep[Theorem~1.1]{OpenAIAllPrimeSelmer2026} +extends the pointwise converse to every prime $p$: full $p$-power Selmer +corank $r\in\{0,1\}$ forces analytic and Mordell--Weil ranks $r$ +and finiteness of the whole Tate--Shafarevich group. Its proof uses the +$2$-converse and analytic twist densities established here. + +The rank and finiteness assertions are distinct from the +Birch--Swinnerton-Dyer leading-coefficient formula. +The pointwise two-primary formula of +\citet[Theorem~1.1]{OpenAITwoPrimaryBSD2026}, combined with the +Selmer-corank densities in the proof of Theorem~\ref{thm:main-density}, +gives the exact two-primary formula on a density-one set of signed +squarefree twists. Their common analytic and Mordell--Weil ranks are +zero and one with density $1/2$ each. This consequence is +\citet[Corollary~16.1]{OpenAITwoPrimaryBSD2026}; its leading-coefficient +assertion concerns the valuation at $2$. + +\subsection{Goldfeld's conjecture and analytic nonvanishing} + +Birch and Swinnerton-Dyer's comparisons of rational points with central +$L$-values led to the conjectural equality of algebraic and analytic rank +\citep{BirchSwinnertonDyer1965}. The conjecture also predicts finiteness +of $\Sha(E/\Q)$ and a formula for the leading coefficient +\citep[\S1, pp.~415--421]{Tate1966}. +Goldfeld's original 1979 formulation asks for the mean analytic order +in a family parametrized by quadratic-field discriminants +\citep[p.~113, Conjecture~(B)]{Goldfeld1979}. +The density formulation predicts that analytic ranks zero and one each +occur half the time. Our counting convention throughout is the signed +squarefree set $\mathcal D(X)$. + +The analytic study of quadratic twists produced both nonzero central +values and simple central zeros. Bump--Friedberg--Hoffstein and +Murty--Murty supplied auxiliary twists with the nonvanishing needed in +Heegner-point arguments; Iwaniec and Perelli--Pomyka\l a developed +quantitative estimates for central derivatives +\citep{BFH1990,MurtyMurty1991,Iwaniec1990,PerelliPomykala1997}. +Ono--Skinner obtained a lower bound of order $X/\log X$ for the +number of nonvanishing central values among twists by fundamental +discriminants $D$ with $0<|D|\le X$ +\citep[Corollary~3]{OnoSkinner1998}. +More recently, Kumar--Mallesham--Sharma--Singh sharpened derivative +nonvanishing estimates through second moments, and +Kriz--Nordentoft improved central-value lower bounds for curves with +no rational two-torsion +\citep[Theorem~1]{KumarEtAl2024} +\citep[Theorem~1.1 and Remark~1.2]{KrizNordentoft2025}. +These quantitative results yield many twists without by themselves +giving a positive proportion for every fixed curve. + +Positive proportions were obtained in special families. James proved +analytic-rank-zero proportions for particular curves, and Vatsal proved +positive proportions of both analytic ranks zero and one for $X_0(19)$ +\citep[Theorem~1]{James1998} \citep[Theorem~II]{Vatsal1998}. +Kriz--Li proved both positive proportions for every rational elliptic +curve admitting a rational $3$-isogeny +\citep[Theorem~1.5]{KrizLi2019}. +In the congruent-number family, Tian's Heegner-point work gives rank +one and odd-order Tate--Shafarevich group in specified subfamilies +\citep{Tian2014}. Genus-period and genus-point congruences, followed by +Selmer statistics, give further analytic density results +\citep{TianYuanZhang2017,SmithCongruent2016}. +These arguments connect coefficient congruences and arithmetic +statistics with analytic nonvanishing, a connection also central to +the present proof. + +The statistical input used here has its own progression. +Smith first established higher $2$-power Selmer distributions for curves +with full rational two-torsion and no rational cyclic subgroup of order +four \citep{Smith2017}. His subsequent work treated the irreducible +residual case and further rational two-isogeny cases +\citep{SmithDistributionI,SmithDistributionII}. +The unrestricted theorem gives full Selmer coranks zero and one with +density $1/2$ each for every rational elliptic curve +\citep[Theorem~1.1]{Smith2025}. Its analytic corollary assumes +Birch--Swinnerton-Dyer \citep[Corollary~1.2]{Smith2025}. +We use the Selmer theorem itself and supply the pointwise analytic +implication through Theorem~\ref{thm:main-converse}. + +\subsection{The Selmer converse problem} + +Gross--Zagier and Kolyvagin established the forward implication: +analytic rank at most one gives equality with the Mordell--Weil rank +and finiteness of the whole Tate--Shafarevich group +\citep{GrossZagier1986,Kolyvagin1990}; see also the combined formulation +in \citet[\S1]{Skinner2020}. +The Gross--Zagier formula relates a central derivative to the height +of a Heegner point, and Kolyvagin's derived classes control the Selmer +group. A converse must produce analytic nonvanishing from Selmer +information. + +Cyclotomic Iwasawa theory gave rank-zero converses at good ordinary +odd primes in the work of Skinner--Urban, under residual +irreducibility and ramification hypotheses +\citep{SkinnerUrban2014}. +Skinner and Wei Zhang proved rank-one converse criteria through +Heegner points and derived classes, under their respective reduction, +residual-image and local hypotheses \citep{Skinner2020,Zhang2014}. +Burungale--Castella--Skinner subsequently removed the auxiliary +ramification conditions in the good ordinary, residually irreducible +case for $p>3$ \citep[Theorem~1.2.2 and the discussion following +Remark~1.2.3]{BurungaleCastellaSkinner2025}. +At good supersingular primes $p>3$, Castella--Wan obtained the rank-one +Selmer-corank implication for semistable curves +\citep[Theorem~A]{CastellaWan2024}. + +Reducible residual representations call for a different Iwasawa-theoretic +comparison. Castella--Grossi--Lee--Skinner proved the corank-zero and +corank-one converses at good ordinary Eisenstein primes $p>2$, with +local isogeny character neither trivial nor cyclotomic +\citep[Theorem~E]{CastellaGrossiLeeSkinner2022}. +Keller--Yin treated potentially good ordinary reduction at odd +Eisenstein primes without that character exclusion +\citep[Theorem~B]{KellerYin2024}. +These results enlarge the allowed residual representations while +retaining conditions on the prime and its reduction type. + +The CM theory includes substantial results at the prime two. +Burungale--Tian proved the rank-one converse at good ordinary primes +$p>3$ \citep{BurungaleTian2020}; +Burungale--Castella--Skinner--Tian included the small ordinary primes +under an additional conductor hypothesis +\citep[Theorem~A]{BurungaleCastellaSkinnerTian2022}. +Ressler and Yu obtained the small-prime good-ordinary result without +that conductor condition; see Yu's Theorem~1 and the attribution in +Burungale--Castella--Skinner--Tian, Remark~C +\citep{Yu2021,BurungaleCastellaSkinnerTian2022}. +Burungale--Skinner's combined ordinary formulation includes $p=2$, +and their good supersingular CM theorem also permits $p=2$ under an +additional surjectivity condition on Selmer localization at $p$ +\citep[Theorems~A.3 and~A.1]{BurungaleSkinner2024}. + +In corank zero, Burungale--Tian's theorem covers every rational CM +elliptic curve at every prime, without a reduction restriction +\citep[Theorem~1.1]{BurungaleTian2026}. +Combined with Smith's unrestricted distribution, it therefore already +gives the analytic-rank-zero half for every CM twist family. +Their Theorem~1.2 gives rank zero for almost all positive squarefree +$n\equiv1,2,3\pmod8$ in the congruent-number family +$ny^2=x^3-x$. +Kriz's preprint states a converse for curves with CM by the full ring +of integers at the unique ramified prime of the CM field, and derives +analytic densities for restricted CM families, including congruent-number +curves \citep[Theorems~1.1 and~10.17]{Kriz2022}. +Its dyadic pointwise statement concerns the CM fields $\Q(i)$ and +$\Q(\sqrt{-2})$. +Together with Smith's distribution theorem, the stated dyadic converse +would yield both half-density conclusions for quadratic twists of every +curve with CM by either of these maximal orders. +Theorem~\ref{thm:main-converse} treats the full $2$-power Selmer corank +for every rational elliptic curve, in both ranks zero and one. + +\subsection{Proof strategy} + +Fix the curve under consideration. We construct finite binary families +of twists +\[ + h_x=\prod_{q\in\mathcal Q}(q^*)^{\lambda_q(x)},\qquad + q^*=(-1/q)q,\qquad x\in\F_2^b, +\] +where $\mathcal Q$ is a finite set of distinct good odd primes and the +$\lambda_q$ are linear forms. The parameter at $x=0$ is $1$. +The families have the same local twisting classes at every fixed bad +place. Their nonzero vertices have analytic order zero or one, according +to the corank of the fixed curve. A scalar determinant coordinate +attached to the relevant class and Selmer complex has a nonzero central +specialization there, with uniformly bounded $2$-adic valuation. +Bounded integral interpolation then recovers nonvanishing at the missing +vertex $0$. + +At corank zero, the interpolated class is a Beilinson--Kato class and +its central specialization detects $L(E,1)$ \citep{Kato2004}. +At corank one, it is a Heegner class over an imaginary quadratic field +$K=\Q(\sqrt{k})$, +whose height detects +\[ + \left[L(E,s)L(E^{(k)},s)\right]'_{s=1}. +\] +An analytically nonvanishing companion $E^{(k)}$ makes the Selmer +corank over $K$ equal to one. The argument retains integral Kummer +conditions at $2$ and every bad prime. The rational Iwasawa input is +used in its stated scope; the uniform integral estimates at $2$ are +proved in Sections~\ref{sec:heegner-interpolation} and +\ref{sec:cy:interpolation}. The Heegner construction is related to +Howard's Kolyvagin-system framework \citep{Howard2012}; the integral +bounds required here are established with the local conditions and +uniformity stated in this paper. + +The finite families are built from modular coefficients. Waldspurger's +formula supplies the even-sign coefficients \citep{Waldspurger1981}. +In odd sign, reductions +of genus Heegner sums give weighted ternary theta coefficients at +increasing finite precisions. A uniform lower bound allows a least +normalized valuation to be selected. In the even case this is a minimum +among the coefficients of one form. In the odd case it is a minimum +over bounded-weight sequences as the precision increases; each finite +collection of tests is then realized at a sufficiently high actual +precision. A test attaining the minimum detects the required analytic +order and gives a uniform upper bound. Weight-two Hecke traces turn these coefficient +tests into contraction and deletion rules for finite configurations +of primes. + +There are two exhaustive residual cases. If $E[2]$ is reducible, its +invariant line is a rational point of order two. Graphs encode prescribed +quadratic residue symbols between auxiliary primes. The resulting finite +construction makes two separate coefficient tests nonzero together at +every nonzero binary vertex. The odd argument fixes one companion field +before the dimension grows. In this branch, the even construction first +supplies the lower bound needed to normalize the odd coefficient test. +If $E[2]$ is irreducible, local Selmer equations give matrices over +$\F_2$. Subtracting a correction determined by finitely many local types +makes these matrices symmetric; their nullities still give a lower +bound on the Selmer dimension up to a fixed cost. Removing one selected prime or pair of primes, or retaining +it with either of two allowed local choices, gives three configurations. +Their coefficient tests satisfy the same sum-zero relation as the +corresponding matrix determinants. This relation does not identify the +coefficient test with the determinant. +We group the configurations into blocks and arrange that the matrix +entries between distinct blocks vanish. +A nonzero coefficient test bounds the matrix kernel, and hence the number +of singular blocks in the finite configuration. Fixing a configuration +with a maximal number of such blocks lets us arrange nonzero tests at +every nonzero binary vertex. An additional alternating-matrix construction +supplies a companion with uniformly bounded prime count and Selmer length. + +Two parts of the argument have uses beyond this assembly. The +interpolation algebra clears denominators through a bounded complex, +so the required congruence precision is independent of the number of +new primes. The graph construction treats the coefficient tests as polynomials in +prescribed residue symbols and makes separately nonzero tests nonzero +together. Its proof retains squared variables until after multiplying +their highest-degree parts. +Neither construction presupposes the desired nonvanishing at the base. + +\paragraph{Organization.} +Section~\ref{sec:preliminaries} records the rank implications and local +conventions. Section~\ref{sec:transfer-criteria} states the two arithmetic +transfer criteria, the lower bounds needed to normalize coefficients, +and auxiliary nonvanishing with prescribed local conditions. +Sections~\ref{cs:coefficient-systems} and~\ref{sec:trace-calculus} +turn analytic nonvanishing into coefficient tests and prime-substitution +identities. Section~\ref{gr:section} develops the graph construction +used in the rational-torsion converse of Section~\ref{pw:section}. +Section~\ref{sec:lm:local-matrices} supplies the Selmer matrices for +the irreducible converse in Section~\ref{sec:sa:saturation}. +The remaining main-text sections prove the arithmetic inputs: +Section~\ref{sec:auxiliary-nonvanishing} establishes auxiliary +nonvanishing, Section~\ref{sec:binary-algebra} develops the common +finite-complex and binary transfer arguments, and +Sections~\ref{sec:cy:interpolation} and~\ref{sec:heegner-interpolation} +construct the cyclotomic and Heegner determinant coordinates and prove +their integral bounds. Finally, Section~\ref{sec:conclusions} assembles the unrestricted +result and its density and finite-descent consequences. diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-arithmetic-transfer.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-arithmetic-transfer.tex new file mode 100644 index 0000000000000000000000000000000000000000..f372dbe734508501dc12702154accf328d0c74f0 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-arithmetic-transfer.tex @@ -0,0 +1,359 @@ +\section{Arithmetic estimates for finite twist families} +\label{sec:transfer-criteria} + +The pointwise converse will follow by placing the given curve at the +zero vertex of a large finite family of twists. We arrange analytic +nonvanishing at every other vertex, together with an upper bound on a +normalized valuation. The estimates in this section explain which +normalization is needed and what must be uniform as the family grows. +Their proofs occupy Sections~\ref{sec:binary-algebra}, +\ref{sec:cy:interpolation} and~\ref{sec:heegner-interpolation}. + +Fix $E/\Q$ of conductor $N$ and retain the local weights $w(h)$, +finite Sha lengths $s(h)$, and period-normalized values $\mathcal L(h)$ +of Section~\ref{sec:preliminaries}. In particular $s(h)$ is defined at +a corank-zero base and at every twist already known to have analytic +rank zero or one. All valuations satisfy $v(2)=1$. + +A binary family has the form +\[ + h_x=h_0\prod_{q\in\mathcal Q}(q^*)^{\lambda_q(x)}, + \qquad x\in\F_2^b,\qquad q^*=(-1/q)q, +\] +where the new primes are distinct and prime to $2Nh_0$, and each +$\lambda_q$ is linear. The old factors of $h_0$ remain at every vertex; +no new factor is present at zero. We will hold the required local +squareclasses fixed while $b$ grows. Both the set of primes and their +sizes may depend on $b$. + +Here is the common transfer mechanism. For families satisfying the +hypotheses of the transfer theorems below, the arithmetic proofs attach +power series +\[ + u_x(t)\in\Ztwo[[t]][1/2] +\] +to the vertices, using a common family of cochain models and compatible +trivializations of the determinant lines. The differences of these +coordinates therefore have a fixed meaning. Their constant terms detect +the central value in rank zero or a Heegner point in rank one. If the analytic nonvanishing sought +at the base fails, then $u_0(0)=0$. The nonzero vertices instead satisfy +$v(u_x(0))\le B_1$ with $B_1$ independent of $b$. +The denominator analysis proves that, for every fixed integer $m$ and +sufficiently large $b$, some $x\ne0$ satisfies +\[ + v\bigl(u_x(0)-u_0(0)\bigr)\ge m. +\] +Taking $m>B_1$ contradicts these two assertions. The work is to obtain +this congruence with a dimension threshold independent of the number +of new primes. Section~\ref{sec:binary-algebra} does so after the new +local blocks have been eliminated from the Selmer complex: a clearing +factor for the remaining bounded complex makes finitely many coefficient +congruences sufficient. Only that clearing factor needs a uniform pole +bound; the numerator may involve the whole prime set. + +\subsection{Transfer of a central value} + +For a twist with nonzero central value, put +\begin{equation}\label{eq:transfer-normalized-value} + D(h)=v(\mathcal L(h))-2w(h)-s(h). +\end{equation} +The subtraction records the local contributions of the ramified primes +and the finite Selmer contribution. In the cyclotomic proof, Kato's class +and the invariant line at the real place form the determinant coordinate +$u_x$. Its central valuation differs from $D(h_x)$ by a fixed bounded +amount. Thus an upper bound on $D$ is exactly the arithmetic input to +the preceding contradiction. + +\begin{theorem}[Cyclotomic missing vertex] +\label{thm:cyclotomic-interpolation} +There is a constant $C_E$, depending only on $E$, with the following +property. Fix an odd fundamental discriminant $h_0$, prime to $2N$, with +$c_2(E^{(h_0)})=0$. Suppose that for arbitrarily +large $b$ there is a family +\begin{equation}\label{eq:cy:cube} + h_x=h_0\prod_{q\in\mathcal Q}(q^*)^{\lambda_q(x)}, + \qquad x\in\F_2^b,\qquad \lambda_q\in(\F_2^b)^*, +\end{equation} +where $\mathcal Q$ consists of distinct primes outside $2Nh_0$, +$q^*=(-1/q)q$, and every $h_x$ has the same sign and the same local +squareclasses at $2N$. Assume that a constant $B$, independent of $b$, +satisfies +\begin{equation}\label{eq:cy:punctured-bound} + L(E^{(h_x)},1)\ne0,\qquad D(h_x)\le B\qquad(x\ne0). +\end{equation} +If $E[2]$ is irreducible, assume also that some $L$, independent of $b$, +satisfies +\begin{equation}\label{eq:cy:prime-bound} + v_2(q^2-1)\le L\qquad(q\in\mathcal Q). +\end{equation} +Then $L(E^{(h_0)},1)\ne0$ and +\begin{equation}\label{eq:cy:transferred-bound} + D(h_0)\le B+C_E. +\end{equation} +The necessary dimension may depend on $h_0$, its finite Selmer group, +and the bound in Equation~\eqref{eq:cy:prime-bound}; $C_E$ does not. +\end{theorem} + +The final constant $C_E$ bounds the specialization error. The finite +Selmer group of the base and, in the irreducible case, the bound on +$v_2(q^2-1)$ affect how large a cube is needed, but not this transferred +error. We shall construct the nonzero vertices so that +$v(\mathcal L(h_x))\le2w(h_x)+C$; since $s(h_x)\ge0$, this supplies +the hypothesis on $D(h_x)$. + +\subsection{Transfer of a Heegner point} +\label{sec:h:statements} + +In corank one the coordinate comes from a Heegner point. The family +must also carry a companion twist whose central value is nonzero. +We first specify the two Heegner constructions whose indices enter +the estimates. + +Let $K=\Q(\sqrt{k})$, where $k<0$ is an odd fundamental discriminant and +every prime dividing $2N$ splits in $K$. We omit the two fields with extra +units and, if $E$ has complex multiplication, its CM field. Fix a nonzero modular parametrization $X_0(N)\to E$, translated so +that the cusp $\infty$ maps to the origin, and compatible orientations +of the Heegner points $y_c\in E(H_c)$, where $H_c$ is the ring class +field of conductor $c$. The Manin--Drinfeld theorem makes the images of +cusp differences torsion \citep[Section~1]{Drinfeld1973}. Since the +modular curve and parametrization are fixed, one integer kills all +these images and removes cuspidal ambiguities. + +If $\chi_e|_{G_K}$ is a primitive ring class character of conductor $c$, +write $P_c(e)$ for the character \emph{sum} of $y_c$. Equivalently, twist +over $H_c$ and trace to $E^{(e)}(K)$. If this latter group has rank one, +$j(P_c(e))$ is the valuation of its index on the free rank-one lattice. +Passing between this lattice and the rank-one lattice of the contributing +curve among $E^{(e)}(\Q)$ and $E^{(ek)}(\Q)$ changes the index by a bounded +amount: restriction and addition or subtraction of conjugates have +composites multiplication by $2$. + +We use two choices of data: +\begin{align*} + \text{genus data:}\quad& k=h h_*,\quad (h,h_*)=1, + \quad e=h_*,\quad c=1, + \quad h_*\text{ fixed};\\ + \text{ring data:}\quad& (k,h)=1,\quad e=h,\quad c=|h|. +\end{align*} +The character in genus data is unramified. In ring data, restriction at +each $q\mid h$ has conductor exponent one: this follows by pulling the +quadratic character back under the local norm. Thus these are the asserted +primitive ring class conductors. + +\begin{proposition}[Comparison of the two Heegner constructions] +\label{prop:heegner-comparison} +For either set of data, +\begin{equation}\label{eq:h:height} + \widehat h(P_c(e)) + =C_E\,c\sqrt{|k|}\, + \left[L(E^{(e)},s)L(E^{(ek)},s)\right]'_{s=1}, +\end{equation} +with a fixed nonzero constant determined by the parametrization and height +conventions. In particular, a simple zero of the product gives total +Mordell--Weil rank one and finite Shafarevich--Tate groups. + +Suppose $h$ has analytic rank one, and use genus data with a fixed partner +$h_*$ of analytic rank zero and ring data with a possibly varying $k$, +where $L(E^{(hk)},1)\ne0$. Then +\begin{equation}\label{eq:h:index-comparison} + 2j(P_{|h|}(h))-2j(P_1(h_*)) + =v(\mathcal L(hk))+O_{E,h_*}(1). +\end{equation} +Here the two points are formed in their respective quadratic fields. +If instead $h_*$ has analytic rank one and $L(E^{(h)},1)\ne0$, genus +data give +\begin{equation}\label{eq:h:reverse-comparison} + 2j(P_1(h_*))=v(\mathcal L(h))+O_{E,h_*}(1). +\end{equation} +\end{proposition} + + +The genus construction varies the quadratic field $\Q(\sqrt{hh_*})$ +while holding $h_*$ fixed. It is the construction detected by the odd +coefficients below. Interpolation instead uses the ring construction: +within one binary family the field $K$ is common to every vertex. +Equation~\eqref{eq:h:index-comparison} converts a genus-index estimate +and an even central-value estimate into the ring-index estimate needed +for transfer. The field $K$ may change when a new family is chosen. + +\begin{theorem}[Heegner interpolation]\label{thm:heegner-interpolation} +Fix $E$ and an initial discriminant $h_0$. Consider families +$h_x$, $x\in\F_2^b$, obtained from $h_0$ by adjoining new prime factors +with linear activation functions on $\F_2^b$. No old factor is removed; +the signed factor belonging to an odd prime $q$ is +$q^*=(-1/q)q$. Suppose the local twisting classes at $2N$ are constant. +For each family let $k$ define an imaginary field satisfying the standing +Heegner conditions, with $(k,h_x)=1$ for every $x$. Each new prime must +either split in $K$ or satisfy $t_q=0$. + +Assume that the following bounds are fixed independently of $b$: +\begin{enumerate}[label=\textup{(\roman*)}] + \item a bound for $\omega(k)$; + \item a bound for the length of the finite quotient of + $\Sel_{2^\infty}(E^{(h_0)}/K)$ by its divisible subgroup; + \item a constant $B$. +\end{enumerate} +Assume this base Selmer group has corank one. Suppose, for every $x\ne0$, +the product $L(E^{(h_x)},s)L(E^{(h_xk)},s)$ has a simple zero and +\begin{equation}\label{eq:h:interpolation-hypothesis} + 2j(P_{|h_x|}(h_x))-4w(h_x)-s(h_x)-s(h_xk)\le B. +\end{equation} +Then, for sufficiently large $b$, the base product has a simple zero. +The dimension threshold depends only on the fixed base and the displayed +bounds, not on the number or sizes of the new primes. The field $K$ may +vary with the family. +\end{theorem} + +In these ring data, the relevant normalized quantity is +\[ + 2j(P_{|h|}(h))-4w(h)-s(h)-s(hk). +\] +We use the theorem to prove nonvanishing at the base. In our applications, +the genus-index and even central-value estimates will give +$2j(P_{|h_x|}(h_x))\le4w(h_x)+C$ at every nonzero vertex. Subtracting +the nonnegative Sha lengths supplies the required upper bound. + +The finite-quotient condition allows two uses of the theorem. The +rational-two-torsion argument fixes $K$ before increasing $b$. The +irreducible argument lets $K$ vary and verifies the following criterion. + +\begin{lemma}\label{lem:h:base-selmer-bound} +The finite-quotient bound in Theorem~\ref{thm:heegner-interpolation} holds +if $K$ belongs to a fixed finite collection. It also holds if +$E^{(h_0)}$ is fixed with Selmer corank one, the curves +$E^{(h_0k)}$ have analytic rank zero with bounded $s(h_0k)$, and +$\omega(k)$ is bounded. +\end{lemma} + +\subsection{Lower bounds and the coefficient constructions} + +The transfer criteria ask for upper bounds at a well-chosen set of +twists. To find those twists, we first need lower bounds on all the +normalized coefficients under consideration. In even sign a least +normalized valuation can then be selected, and a coefficient attaining +it gives both analytic nonvanishing and an upper bound with a constant +independent of the prime support. In odd sign the coefficients come at +increasing finite precision: the minimum is defined through bounded-weight +sequences, and each use is realized on a finite collection of indices. + +For the even coefficient construction, +Section~\ref{cs:coefficient-systems} relates twice a coefficient valuation +to $v(\mathcal L(h))$ up to a fixed constant. For the odd construction it +relates the coefficient valuation to the genus index. The following +three lower estimates supply the normalizations, with different roles +in the two residual cases. + +When $E[2]$ is reducible, the cyclotomic argument supplies the even +lower estimate directly. By Lemma~\ref{pr:residual-cases}, the +representation is then an extension of two trivial modules. + +\begin{theorem}[Cyclotomic lower bound]\label{thm:cyclotomic-bound} +Suppose that $E[2]$ is an extension of two trivial $\F_2$-modules. +There is a constant $C_E$ such that every odd fundamental discriminant +$h$ prime to $2N$ with +$L(E^{(h)},1)\ne0$ satisfies +\begin{equation}\label{eq:cy:lower-bound} + v(\mathcal L(h))\ge 2w(h)+s(h)-C_E. +\end{equation} +The constant is independent of the number and sizes of the primes +that divide $h$. +\end{theorem} + +When $E[2]$ is irreducible, the genus construction supplies the lower +estimate for either sign. With an analytic-rank-zero fixed partner, +it bounds the odd genus index. With an analytic-rank-one fixed +partner, Equation~\eqref{eq:h:reverse-comparison} turns it into the +even central-value bound. + +\begin{theorem}[Genus bound]\label{thm:heegner-genus-bound} +In genus data, suppose the product in +Equation~\eqref{eq:h:height} has a simple zero and $E[2]$ is irreducible. +Then, uniformly in $h$, +\begin{equation}\label{eq:h:genus-bound} + 2j(P_1(h_*))\ge 2w(h)+s(h)-O_{E,h_*}(1). +\end{equation} +In proving the uniform estimate, one may omit the finitely many $h$ for +which $K$ meets $\Q(E[2])$ nontrivially. +\end{theorem} + +The remaining case is the odd coefficient construction with rational +two-torsion. Here the genus estimate just stated is unavailable. We use +instead the following ring estimate, whose residual representation is +unrestricted. + +\begin{theorem}[Ring bound]\label{thm:heegner-ring-bound} +In ring data, suppose the product in +Equation~\eqref{eq:h:height} has a simple zero, every $q\mid h$ splits in +$K$, and $\omega(k)\le a$, where $\omega$ counts distinct prime factors. +Then +\begin{equation}\label{eq:h:ring-bound} + 2j(P_{|h|}(h))\ge + 4w(h)+s(h)+s(hk)-O_{E,a}(1). +\end{equation} +There is no irreducibility assumption on $E[2]$. +\end{theorem} + +The passage from this ring estimate to an odd genus estimate is part +of Proposition~\ref{prop:rational-odd-bound}. The even coefficient construction +first provides, for each already rank-one twist $h$ in the positive +filter, a companion parameter $k'$ satisfying the ring-bound hypotheses: +it is negative, odd fundamental, coprime to $2Nh$, a local square at +every prime of $2Nh$, and defines a nonexceptional imaginary field. +Its prime count is bounded, and the companion obeys +$L(E^{(hk')},1)\ne0$ and +\[ + v(\mathcal L(hk'))\le2w(hk')+s(hk')+C. +\] +Substitute this upper bound into +Equation~\eqref{eq:h:index-comparison} and the ring lower bound. +Since $w(hk')=w(h)+w(k')$ and $w(k')$ is bounded, the result is +\[ + 2j(P_1(h_*))\ge2w(h)+s(h)-C'. +\] +Only then is the odd coefficient system normalized in the reducible +branch. Thus the lower-bound dependencies are +\[ + \begin{array}{c@{\quad\longrightarrow\quad}l} + \text{irreducible genus bound}&\text{even and odd coefficient bounds},\\[2pt] + \text{reducible cyclotomic bound}&\text{even coefficients, then bounded companions},\\[2pt] + \text{ring bound and those companions}&\text{reducible odd coefficient bound}. + \end{array} +\] +The reducible odd normalization is therefore available after the even +companion construction. The all-split hypothesis belongs to the ring +lower bound used here. The Heegner transfer criterion retains its stated +alternative for new primes with $t_q=0$. + +\subsection{Auxiliary twists in prescribed local classes} + +The coefficient constructions also require an auxiliary twist with +specified local classes. For even sign the number of its prime factors +must remain bounded as the local conditions vary. The following +nonvanishing result supplies both kinds of partner; its proof is given +in Section~\ref{sec:auxiliary-nonvanishing}. + +\begin{proposition}[Auxiliary nonvanishing] +\label{prop:rough-nonvanishing}\label{nv:rough}\label{nv:local-witness} +Let $E/\Q$ have conductor $N$, and let $S$ be a finite set of primes +containing the prime divisors of $2N$. Prescribe a real sign +$\sigma\in\{1,-1\}$ and a unit squareclass +$c_p\in\Z_p^\times/\Z_p^{\times2}$ for each $p\in S$. +Suppose that these data are realized by an odd fundamental discriminant, +and that twists in this filter have root number $\varepsilon$. +For every finite set $B$ of primes there are odd fundamental +discriminants $D$ of arbitrarily large absolute value such that +\[ + \operatorname{sign}(D)=\sigma,\qquad [D]_p=c_p\quad(p\in S),\qquad + p\nmid D\quad(p\in B), +\] +Moreover: +\begin{enumerate}[label=\textup{(\roman*)}] +\item If $\varepsilon=1$, they can be chosen with +$L(E^{(D)},1)\ne0$ and $\omega(|D|)\le5$. +\item If $\varepsilon=-1$, they can be chosen with +$L'(E^{(D)},1)\ne0$, so the central zero is simple. +\end{enumerate} +The bound five in \textup{(i)} is independent of $E,S,B$ and the +prescribed classes. In either case, every prime factor of $D$ can be +required to exceed any previously fixed bound. +\end{proposition} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-nonvanishing.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-nonvanishing.tex new file mode 100644 index 0000000000000000000000000000000000000000..6f756182c9d5e2175ce52b2be5f7404f32c78b09 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-nonvanishing.tex @@ -0,0 +1,443 @@ +\section{Proof of auxiliary nonvanishing} +\label{sec:auxiliary-nonvanishing} + +We prove Proposition~\ref{prop:rough-nonvanishing}. The even-sign +assertion follows from Hoffstein--Luo after one preliminary twist. +For the odd-sign assertion we retain the prescribed local conditions +throughout a derivative first-moment calculation. + +\begin{proof}[Proof of Proposition~\ref{prop:rough-nonvanishing}\textup{(i)}] +An odd fundamental discriminant is squarefree and congruent to $1$ +modulo $4$, so $c_2$ is represented by $u_2\in\{1,5\}$ modulo $8$. +For odd $p\in S$, choose a nonzero residue $u_p$ representing $c_p$. +The Chinese remainder theorem and Dirichlet's theorem give a prime +$q\notin S\cup B$ satisfying +\[ + q\equiv\sigma u_2\pmod8,\qquad + \sigma q\equiv u_p\pmod p\quad(p\in S,\ p\ne2). +\] +Then $D_0=\sigma q$ is an odd fundamental discriminant in the prescribed +filter. Put $A=E^{(D_0)}$ and let $N_A$ be its conductor. Thus +$\varepsilon(A)=1$. + +The theorem of Hoffstein--Luo +\citep[pp.~435--436]{HoffsteinLuo1997} gives infinitely many odd +fundamental discriminants $h$ such that +\[ + L(A^{(h)},1)\ne0,\qquad \omega(|h|)\le4, +\] +and $\chi_h(p)=1$ at every prime in the fixed finite set consisting of +$S\cup B\cup\{q\}$ and the prime divisors of $N_A$. +The twisting formula for the root number gives +\[ + 1=\varepsilon(A^{(h)})=\varepsilon(A)\chi_h(-N_A) + =\operatorname{sign}(h), +\] +so $h>0$. For odd $p$ the condition $\chi_h(p)=1$ says that $h$ is a +unit square in $\Q_p$. At $2$, odd fundamentality and $\chi_h(2)=1$ +give $h\equiv1\pmod8$, which has the same meaning. +Since $q\nmid h$, the product $D=D_0h$ is squarefree and congruent to +$1$ modulo $4$. It retains the prescribed sign and squareclasses and +avoids $B$. Finally, +\[ + E^{(D)}\simeq A^{(h)},\qquad \omega(|D|)=1+\omega(h)\le5. +\] +Distinct choices of $h$ give distinct $D$. +\end{proof} + +\subsection{An odd-sign witness in a fixed progression} +\label{odd:fixed-progression} + +We retain the modulus of the local conditions throughout the first-moment +calculation. Iwaniec's derivative moment +\citep[Theorem on p.~367 and Sections~6--10]{Iwaniec1990} treats the +negative-discriminant split family. The following argument allows any +fixed admissible progression. It makes no uniformity assertion as that +progression varies. + +\begin{lemma}[Odd first moment]\label{nv:odd-first-moment} +Let $f$ be the weight-two newform of an elliptic curve of conductor $N$, +with its $L$-function normalized to have center $1/2$. +Fix $H$ divisible by $8$ and $N$, a reduced class $a\pmod H$, and +$\sigma\in\{1,-1\}$ with $\sigma a\equiv1\pmod4$. +Suppose the twists with $n>0$ squarefree and $n\equiv a\pmod H$ +have root number $-1$. +For every nonnegative, nonzero $\Phi\in C_c^\infty((1,2))$, there are +$c>0$, $c_1\in\mathbb R$, and an absolute $\eta>0$ such that +\begin{equation}\label{odd:moment} + \sum_{\substack{n>0\ \mathrm{squarefree}\\n\equiv a\ (H)}} + L'(1/2,f\otimes\chi_{\sigma n})\Phi(n/X) + =cX\log X+c_1X+O_{f,H,a,\sigma,\Phi}(X^{1-\eta}). +\end{equation} +Consequently this progression contains arbitrarily large $n$ whose +twists have a simple central zero. +\end{lemma} + +\begin{proof} +Write $L(s,f)=\sum_{m\ge1}\lambda(m)m^{-s}$, so +$|\lambda(m)|\le\tau(m)$, where $\tau$ is the divisor function, and put $Q=\sqrt N/(2\pi)$. +In estimates below, constants may depend on the fixed data in the Lemma; +all unspecified power exponents are absolute. +The proof separates two issues: preserving the fixed progression while +removing the squarefree condition, and controlling the frequencies after +Poisson summation. The zero frequency will give a positive main term of +order $X\log X$; the other frequencies and the discarded square divisors +must together have a power-saving bound. We keep the modulus $H$ fixed +throughout these steps. +Set +\[ + V(y)=\frac1{2\pi i}\int_{(2)} + e^{z^2}\Gamma(1+z)y^{-z}\frac{dz}{z^2}. +\] +The conductor of the twist is $Nn^2$. Its odd functional equation gives +\begin{equation}\label{odd:afe} + L'(1/2,f\otimes\chi_{\sigma n}) + =2\sum_{m\ge1}\frac{\lambda(m)\chi_{\sigma n}(m)}{\sqrt m} + V\left(\frac m{Qn}\right). +\end{equation} +Indeed, shift the defining completed integral across its double pole +and use the functional equation. The central value is zero, so the +derivative of the completion contributes no additional term. +Use the right side of Equation~\eqref{odd:afe} to define $\mathcal A(n)$ +also for nonsquarefree $n\equiv a\pmod H$. + +\paragraph{Large square divisors.} +We first record the precise large-sieve input. For every $\rho>0$ and +fixed $0<\delta<1/4$, +\begin{equation}\label{odd:second-moment} + \sum_{\substack{0Y$, with at most $\tau(v)$ choices +of $d$. Also $\sigma t$ is fundamental, $(tv,2N)=1$, and +\[ + \chi_{\sigma n}(m) + =\chi_{\sigma t}(m)\mathbf1_{(m,v)=1}. +\] +On a Mellin line $\Re z=\delta>0$, the series defining $\mathcal A(tv^2)$ +therefore uses +\[ + L(1/2+z,f\otimes\chi_{\sigma t}) + \prod_{p\mid v} + \left(1-\frac{\lambda(p)\chi_{\sigma t}(p)}{p^{1/2+z}} + +\frac{\chi_{\sigma t}(p)^2}{p^{1+2z}}\right). +\] +The product is $O_\epsilon(v^\epsilon)$. By Cauchy's inequality and +Equation~\eqref{odd:second-moment}, the sum of the absolute $L$-values +over $t\le2X/v^2$ is +$O((X/v^2)^{1+\epsilon}(1+|\Im z|)^C)$. +The remaining Mellin factors are bounded by $O(X^\delta)$ times a +rapidly decreasing function of $\Im z$. Choose $\delta$ and $\epsilon$ +sufficiently small in terms of $\rho$. Absorbing the divisor count and +these small powers gives +$X^{1+\rho}\sum_{v>Y}v^{-2}\ll X^{1+\rho}/Y$, as claimed. +The double pole in the kernel is harmless on this fixed positive line. + +\paragraph{Poisson summation.} +For $(d,H)=1$ put $J=d^2$ and $c_J\equiv aJ^{-1}\pmod H$. +Let $T(J)$ be the sum of $\mathcal A(n)\Phi(n/X)$ over +$n\equiv a\pmod H$ with $J\mid n$, without a squarefree restriction. +Writing $m=m_1q$ with $m_1\mid H^\infty$ and $(q,H)=1$, put +$\kappa(m_1)=\chi_{\sigma a}(m_1)$ and +\[ + G_\nu(q)=\sum_{y\bmod q}\left(\frac yq\right)e(\nu y/q),\qquad + W(z,R)=\int_0^\infty\Phi(x)V\left(\frac z{Qx}\right)e(-Rx)\,dx, +\] +where $e(x)=e^{2\pi ix}$. Poisson summation gives +\begin{equation}\label{odd:poisson} + \begin{split} + T(J)={}&\frac{2X}{HJ} + \sum_{m_1\mid H^\infty}\frac{\lambda(m_1)\kappa(m_1)}{\sqrt{m_1}} + \sum_{(q,H)=1}\frac{\lambda(q)}{q^{3/2}} + \left(\frac{\sigma JH}{q}\right)\\ + &\hspace{9mm}\cdot\sum_{\nu\in\mathbb Z} + G_\nu(q)e(\nu c_J\bar q/H) + W\left(\frac{m_1q}{X},\frac{\nu X}{HJq}\right), + \end{split} +\end{equation} +where $q\bar q\equiv1\pmod H$ and $G_\nu(1)=1$. +For clarity, the Chinese remainder theorem evaluates the finite sum as +\[ + \sum_{\substack{x\bmod Hq\\x\equiv c_J\ (H)}} + \left(\frac xq\right)e(\nu x/(Hq)) + =e(\nu c_J\bar q/H)\left(\frac Hq\right)G_\nu(q). +\] +Multiplication by $(\sigma J/q)$ yields Equation~\eqref{odd:poisson}; +this factor vanishes when $(q,J)>1$. + +\paragraph{The zero frequency.} +The Gauss sum $G_0(q)$ is zero unless $q$ is a square, when it is +$\varphi(q)$. Define +\[ + H_p(z)=1+(1-p^{-1})\sum_{r\ge1} + \lambda(p^{2r})p^{-r(1+2z)},\qquad + F_J(z)=\prod_{p\nmid HJ}H_p(z), +\] +\[ + L_H(z)=\sum_{m_1\mid H^\infty} + \lambda(m_1)\kappa(m_1)m_1^{-1/2-z},\qquad + \widehat\Phi_0(z)=\int_0^\infty\Phi(x)x^z\,dx. +\] +Mellin inversion expresses the zero-frequency contribution as +\begin{equation}\label{odd:zero-integral} + T_0(J)=\frac{2X}{HJ}\frac1{2\pi i}\int_{(2)} + e^{z^2}\Gamma(1+z)(QX)^z\widehat\Phi_0(z)L_H(z)F_J(z) + \frac{dz}{z^2}. +\end{equation} +At a good prime, let $\alpha_p\beta_p=1$ and +$|\alpha_p|=|\beta_p|=1$. The identity +\[ + \sum_{r\ge0}\lambda(p^{2r})x^r + =\frac{1+x}{(1-\alpha_p^2x)(1-\beta_p^2x)} +\] +shows that $H_p(z)$ is the symmetric-square Euler factor at $1+2z$ +times a polynomial +$1+O(p^{-2-4\Re z}+p^{-2-2\Re z})$. +The correction product converges absolutely near $\Re z\ge-1/16$. +To omit a prime dividing $J$, omit its correction factor and insert an +inverse symmetric-square Euler polynomial; this introduces no poles at +zeros of $H_p$. These omitted factors cost at most $J^B$ on that strip. +The finite Euler product $L_H$ is holomorphic there. +Symmetric-square continuation, its functional equation, and polynomial +strip bounds now allow the shift to $\Re z=-1/16$, with error +\begin{equation}\label{odd:zero-error} + T_0(J)=R_J(X)+O(J^B X^{1-1/16}), +\end{equation} +where $R_J(X)$ is the residue of the integrand in +Equation~\eqref{odd:zero-integral}, including its factor $2X/(HJ)$. +For this analytic input see +\citep[Theorem~9.3 and Remark~9.9]{GelbartJacquet1978}; in the CM case +the untwisted symmetric square is a product of nontrivial Dirichlet and +Hecke-character $L$-functions, so the same continuation holds near $1$. + +The sum of the residues, with $d$ extended to infinity, has coefficient +function +\[ + M(z)=e^{z^2}\Gamma(1+z)Q^z\widehat\Phi_0(z)L_H(z) + \prod_{p\nmid H}\bigl(H_p(z)-p^{-2}\bigr). +\] +The product is interpreted by its symmetric-square factorization and +an absolutely convergent correction. It is holomorphic near zero. +Moreover $M(0)>0$. Indeed +\[ + F_p^{\rm ev}:=\frac{1+p^{-1}} + {(1-\alpha_p^2/p)(1-\beta_p^2/p)}>0,\qquad + H_p(0)=p^{-1}+(1-p^{-1})F_p^{\rm ev}>p^{-1}. +\] +All the fixed local factors in $L_H(0)$ are positive, and +$L(1,\operatorname{sym}^2 f)>0$ by the Rankin--Selberg residue formula. +The remaining correction factors are positive and form a convergent +product. The full residue is therefore +\begin{equation}\label{odd:residue} + \frac{2X}{H}\bigl(M(0)\log X+M'(0)\bigr), + \qquad c=\frac{2M(0)}H>0. +\end{equation} +Extending the residue sum costs $O_\rho(X^{1+\rho}/Y)$: +its terms contain $d^{-2}\prod_{p\mid d}H_p(0)^{-1}$, and this +product, as well as its differentiated version, is +$O_\epsilon(d^\epsilon(1+\log d))$. +The resulting $d^{-2+\epsilon}$ tail also justifies differentiating +the residue sum. + +\paragraph{The nonzero frequencies.} +The zero frequency has now supplied the positive main term. We next +bound the remaining frequencies uniformly in the square divisor $J$ +by a fixed power of $J$, so that summation over the retained square +divisors will preserve a power saving in $X$. +We prove the bound +\begin{equation}\label{odd:offdiagonal} + T_{\ne0}(J)\ll J^B X^{7/8}. +\end{equation} +For odd $q$, set $\epsilon_q=1$ or $i$ according as $q\equiv1$ or +$3\pmod4$, and $\widetilde G_\nu(q)=\epsilon_q^{-1}G_\nu(q)$. +Quadratic reciprocity makes $\widetilde G_\nu$ multiplicative in $q$. +As $4\mid H$, the phase $\epsilon_q e(\nu c_J\bar q/H)$ is a +function on $(\mathbb Z/H\mathbb Z)^\times$. Expand it in Dirichlet +characters $\psi\pmod H$; every expansion coefficient has absolute +value at most one. For $\nu\ne0$, consider +\[ + D_{\psi,J,\nu}(s)=\sum_{(q,H)=1} + \frac{\lambda(q)}{q^s}\frac{\widetilde G_\nu(q)}{\sqrt q} + \left(\frac{\sigma JH}{q}\right)\psi(q). +\] +At $p\nmid2HJ\nu$, its local factor is +$1+\lambda(p)\xi(p)p^{-s}$, where +$\xi(q)=\psi(q)(\sigma JH\nu/q)$ is a Dirichlet character. +Multiplication by the inverse $\mathrm{GL}_2$ Euler factor leaves +\[ + 1+(1-\lambda(p)^2)\xi(p)^2p^{-2s} + +\lambda(p)\xi(p)^3p^{-3s}. +\] +These factors converge absolutely for $\Re s>1/2$. + +The exceptional primes cause only a fixed power loss. For an odd prime +$p$, put $v=v_p(\nu)$. Direct summation over residue lifts gives +\[ + G_\nu(p^r)= + \begin{cases} + \varphi(p^r),&r\text{ even},\ r\le v,\\ + -p^{r-1},&r\text{ even},\ r=v+1,\\ + \epsilon_p p^{r-1/2} + \left(\dfrac{\nu/p^{r-1}}p\right), + &r\text{ odd},\ r=v+1,\\ + 0,&\text{otherwise}. + \end{cases} +\] +For even $r$ this is the Ramanujan sum. For odd $r$, the sum of the +lifts vanishes unless $p^{r-1}\mid\nu$, and the primitive quadratic +Gauss sum then gives the formula. Thus the local sum is a polynomial; +on $\Re s\ge3/4$ its absolute value is at most +$\sum_{r\ge0}(r+1)p^{-r/4}\le C_0$. +The inverse Euler polynomial is also bounded absolutely. Primes dividing +$J$ remove the local sum altogether. Passing to the primitive character +underlying $\xi$ introduces only such inverse Euler polynomials. Hence +\[ + D_{\psi,J,\nu}(s)=L(s,f\otimes\xi^{\rm prim})C_{\psi,J,\nu}(s), +\] +where $C_{\psi,J,\nu}$ is holomorphic for $\Re s>1/2$ and bounded +on $\Re s\ge3/4$ by $(2J|\nu|)^C$. Indeed the exceptional-prime +cost is at most $C_1^{\omega(J\nu)}$, and the other corrections have +summable $O(p^{-3/2})$ errors there. +The conductor of $\xi^{\rm prim}$ is at most $4HJ|\nu|$. +The twisted cusp-form $L$-function is entire; its functional equation +and polynomial strip bounds therefore give +\begin{equation}\label{odd:gauss-strip} + |D_{\psi,J,\nu}(3/4+i t)| + \ll_{f,H}(J|\nu|)^C(1+|t|)^C. +\end{equation} +The exponents are absolute because the degree and weight are fixed. + +It remains to sum these bounds without losing the power saving. +The kernel and integration by parts in $x$ give, for fixed $r,s$ and +every $K>0$, +\begin{equation}\label{odd:weight-decay} + |(z\partial_z)^r(R\partial_R)^s W(z,R)| + \ll_{r,s,K}(1+z)^{-K}(1+|R|)^{-K}(1+|\log z|). +\end{equation} +The logarithm accounts for the double pole when $z$ tends to zero. +On the actual sums $z\ge X^{-1}$. +For a fixed small $\rho>0$, insert smooth cutoffs +$z\ll X^\rho$ and $|R|\ll X^\rho$. +The discarded part is negligible: use $|G_\nu(q)|\le q$ and +\[ + \sum_{\nu\in\mathbb Z} + (1+|\nu|X/(HJq))^{-K}\ll_H1+Jq/X +\] +to obtain a polynomial absolute majorant in $X,J$ for +Equation~\eqref{odd:poisson}. More explicitly, its absolute value is +$O_\epsilon(X^{3/2+\epsilon}\log X)$, uniformly for $J\ge1$: +the $q$-sums contribute +$(X/m_1)^{1/2+\epsilon}+(J/X)(X/m_1)^{3/2+\epsilon}$, +and the remaining $m_1\mid H^\infty$ sums converge. +For $z>1$, absorb the positive logarithm into an arbitrarily small +power of $z$ in this calculation. On either discarded tail, increasing +$K$ in Equation~\eqref{odd:weight-decay} supplies an arbitrarily large +factor $X^{-\rho K}$. +The retained nonzero-frequency range satisfies +\begin{equation}\label{odd:ranges} + m_1q\ll X^{1+\rho},\qquad + 0<|\nu|\ll_H JX^{2\rho},\qquad + q\gg_H X^{1-\rho}/J. +\end{equation} + +Partition the $q$-sum into smooth segments $q\asymp T$. +By Equation~\eqref{odd:weight-decay}, the finitely many derivative +norms needed for Mellin inversion of the segment's weight are +$O(X^{C'\rho})$, uniformly in $m_1,J,\nu,T$. +Mellin inversion uses $D_{\psi,J,\nu}(1+s)T^s$. +Shift its contour to $\Re s=-1/4$; the factorization above shows that +no pole is crossed. Equation~\eqref{odd:gauss-strip} and the vertical +decay of the weight's Mellin transform give +\begin{equation}\label{odd:dyadic} + \sum_q\frac{\lambda(q)}q\frac{\widetilde G_\nu(q)}{\sqrt q} + \left(\frac{\sigma JH}{q}\right)\psi(q)W_*(q/T) + \ll (J|\nu|)^C X^{C'\rho}T^{-1/4}. +\end{equation} +Here $W_*$ includes the dyadic and cutoff factors and both arguments +of the original weight; their logarithmic derivatives are controlled +by Equation~\eqref{odd:weight-decay}. +The sum over $m_1$ is bounded since +\[ + \sum_{m_1\mid H^\infty}\frac{|\lambda(m_1)|}{\sqrt{m_1}} + \le\prod_{p\mid H}(1-p^{-1/2})^{-2}<\infty. +\] +Equation~\eqref{odd:ranges} bounds the dyadic sum of $T^{-1/4}$ by +$O_H(J^{1/4}X^{-1/4+\rho/4})$, even if its formal lower endpoint +is below one. Also +\[ + \sum_{0<|\nu|\ll_H JX^{2\rho}}(J|\nu|)^C + \ll_H J^{2C+1}X^{2(C+1)\rho}. +\] +Multiplying these estimates by $X/J$ from Equation~\eqref{odd:poisson} +proves $T_{\ne0}(J)\ll J^B X^{3/4+C''\rho}$. +Choose $\rho$ absolutely small enough that $C''\rho\le1/8$. +This proves Equation~\eqref{odd:offdiagonal}. + +\paragraph{Conclusion.} +Sum the zero- and nonzero-frequency errors over $d\le Y$, with $J=d^2$. +Together with the large-square and residue tails, the total error is +\[ + O\left(Y^{2B+1}X^{1-\kappa}+X^{1+\rho}/Y\right), + \qquad \kappa=1/16, +\] +after enlarging $B$. Choose an absolute $\delta_0>0$ with +$(2B+1)\delta_0<\kappa/2$, put $Y=X^{\delta_0}$, and choose the +tail exponent $0<\rho<\delta_0/4$. +Both errors are $O(X^{1-\eta})$ for an absolute $\eta>0$. +Equation~\eqref{odd:residue} proves Equation~\eqref{odd:moment}. +Its leading coefficient is positive, so some derivative is nonzero in +every sufficiently large dyadic interval. The odd functional equation +already forces the central value to vanish, proving the final assertion. +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{prop:rough-nonvanishing}\textup{(ii)}] +Choose $H$ divisible by $8N$ and by all primes in $S\cup B$. +The prescribed squareclasses and sign determine a reduced class +$a\pmod H$ with $\sigma a\equiv1\pmod4$, by the Chinese remainder +theorem. At a prime in $B\setminus S$, choose any nonzero residue. +Then every positive squarefree $n\equiv a\pmod H$ gives an odd +fundamental discriminant $D=\sigma n$ in the prescribed filter and +prime to every member of $B$. Lemma~\ref{nv:odd-first-moment} supplies +arbitrarily large such $n$ with $L'(E^{(D)},1)\ne0$. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-preliminaries.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-preliminaries.tex new file mode 100644 index 0000000000000000000000000000000000000000..6aa221a9d00659ed705c295f349090b5b9c1fed0 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/01-preliminaries.tex @@ -0,0 +1,198 @@ +\section{Selmer ranks and local conventions}\label{sec:preliminaries} + +We first record the arithmetic implications used to pass between curves +and to interpret the final analytic nonvanishing. They apply to every +elliptic curve over $\Q$. + +Throughout, we use Mordell--Weil finite generation and the positive +definiteness of the canonical height modulo torsion over number fields +\citep[Chapter~IV, finite-basis theorem, Theorem~4.7, +Remark~4.12, and Theorem~6.1]{MilneEC2021}. + +\begin{lemma}[Ranks and the forward implication]\label{pr:ranks} +For an elliptic curve $A/\Q$ there is an exact sequence +\[ + 0\longrightarrow A(\Q)\otimes\Qtwo/\Ztwo + \longrightarrow\Sel_{2^\infty}(A/\Q) + \longrightarrow\Sha(A/\Q)[2^\infty]\longrightarrow0. +\] +In particular +\[ + c_2(A)=r(A)+\corank_{\Ztwo}\Sha(A/\Q)[2^\infty]. +\] +If $a(A)\le1$, then $r(A)=a(A)$, the whole group $\Sha(A/\Q)$ is +finite, and $c_2(A)=a(A)$. +\end{lemma} + +\begin{proof} +The finite Kummer exact sequences are +\[ + 0\longrightarrow A(\Q)/2^nA(\Q) + \longrightarrow\Sel_{2^n}(A/\Q) + \longrightarrow\Sha(A/\Q)[2^n]\longrightarrow0. +\] +Their direct limit gives the displayed sequence; taking coranks gives +the identity. The last assertion is the Gross--Zagier--Kolyvagin +forward theorem \citep{GrossZagier1986,Kolyvagin1990}; see also its +unrestricted formulation in \citet[\S1]{Skinner2020}. +\end{proof} + +\begin{lemma}[Parity and change of curve]\label{pr:invariance} +\label{prop:selmer-parity} +For every elliptic curve $A/\Q$ with root number $\varepsilon(A)$, +\[ + (-1)^{c_2(A)}=\varepsilon(A). +\] +A rational isogeny preserves $a(A)$, $r(A)$ and $c_2(A)$. +For a quadratic field $K=\Q(\sqrt{k})$, +\[ + \corank_{\Ztwo}\Sel_{2^\infty}(A/K) + =c_2(A)+c_2(A^{(k)}). +\] +\end{lemma} + +\begin{proof} +The parity statement is the $p=2$ case of +\citet[Theorem~1.4, equivalently Theorem~4.19]{DokchitserDokchitser2010}. +At $p=2$ this is Monsky's theorem \citep{Monsky1996}. +Isogenies and their duals induce maps respecting every local Kummer +condition; their composites are multiplication by their fixed degree. +After rationalization these maps preserve ranks and coranks. Their +$L$-functions agree by isogeny invariance. + +Restriction to $K$ and the two conjugation projections $1+c$ and $1-c$ +give maps between $\Sel_{2^\infty}(A/K)$ and the sum of the Selmer +groups of $A$ and $A^{(k)}$ over $\Q$, with composites multiplication +by $2$. They respect local Kummer images, so rationalization gives the +corank identity. An integral direct sum is not needed. +\end{proof} + +\begin{lemma}[The residual alternatives]\label{pr:residual-cases} +The representation $E[2]$ is reducible over $\F_2$ if and only if +$E(\Q)[2]\ne0$. In that case it is an extension of two trivial +$\F_2$-representations. Otherwise its image is $C_3$ or $S_3$ in +$\GL_2(\F_2)$. Quadratic twisting leaves this representation unchanged. +\end{lemma} + +\begin{proof} +An invariant line over $\F_2$ has a unique nonzero vector, which must +be fixed. Conversely a rational point of order two spans an invariant +line. Both that line and the one-dimensional quotient are trivial, +since $\F_2^\times=\{1\}$. The irreducible subgroups of +$\GL_2(\F_2)\simeq S_3$ are $C_3$ and $S_3$. Finally a quadratic +character reduces to $1$ modulo $2$. +\end{proof} + +The distinction here is irreducibility over $\F_2$, rather than +absolute irreducibility: the cyclic cubic case is included. +In the rational-torsion case we may first replace the curve by a +rationally isogenous one with full rational two-torsion, if such a +curve exists. Otherwise, for any chosen rational two-isogeny +$E\to E'$, both $\Q(E[2])$ and $\Q(E'[2])$ are quadratic. +Lemma~\ref{pr:invariance} justifies this choice before any constructions. + +\subsection{Finite lengths and twisting data} + +All valuations above $2$ are normalized by $v(2)=1$, with $v(0)=+\infty$. +For a finite $\Ztwo$-module $M$, its length is $\log_2\#M$. +The corank of a cofinitely generated discrete $\Ztwo$-module is the +rank of its Pontryagin dual. Its quotient by the maximal divisible +subgroup is finite. This finite quotient must be distinguished from +finiteness of the original group. + +A fixed support $S$ is a finite set of primes containing $2$ and +all primes of bad reduction; it is enlarged explicitly when necessary. +Write $N$ for the conductor of $E$. +A local filter specifies a real sign and unit squareclasses at $S$ +for a variable odd fundamental discriminant prime to $S$. +The empty discriminant $h=1$ denotes the untwisted curve. +We also write $E^{(h)}$ for twisting by a rational squareclass. +For an odd prime $p$, the signed prime discriminant is +$p^*=(-1/p)p$. Products of distinct $p^*$ are odd fundamental +discriminants, with the empty product interpreted as $1$. + +For an odd fundamental discriminant $h$ prime to $2N$, the +coprime-twist root-number formula is +\[ + \varepsilon(E^{(h)})=\varepsilon(E)\chi_h(-N) +\] +\citep[Section~1]{RadziwillSoundararajan2015}. +Thus matching unit squareclasses at the primes dividing $2N$ and +opposite real signs give opposite functional signs: the values of +$\chi_h(N)$ agree, whereas $\chi_h(-1)=\operatorname{sgn}(h)$. +This verifies the sign condition when choosing the auxiliary partners +below. + +Put $T=T_2(E)$ and $V=E[2]$. Frobenius is arithmetic, and +$a_p(E)=p+1-\#E(\F_p)$ at a good prime. For $h$ prime to $S$, set +\begin{equation}\label{eq:h:weights} + t_p=\dim_{\F_2}V^{\Fr_p},\qquad + w(h)=\frac12\sum_{p\mid |h|}t_p. +\end{equation} +The residual identity, a transposition and a rotation of order three +have $t_p=2,1,0$, respectively. We call these split, simple and root +primes; their weights are $1,1/2,0$. Only types present in the +residual image are used. Quadratic residue symbols written additively +take the values $0,1\in\F_2$, corresponding to $+1,-1$. + +Whenever its group is finite, write +\[ + s(h)=\length_{\Ztwo}\Sha(E^{(h)}/\Q)[2^\infty]. +\] +This includes every twist already proved to have analytic rank zero +or one. It also includes a base of Selmer corank zero, since its full +$2$-primary Selmer group is then finite. We make no whole-Sha +finiteness assertion at such a base until analytic nonvanishing has +been established. + +Let $\Omega_E^+$ be a positive real period and let $\Omega_E^-$ be +the positive magnitude of a nonzero anti-invariant period. Put +\begin{equation}\label{eq:h:algebraic-value} + \mathcal L(h)= + \frac{\sqrt{|h|}\,L(E^{(h)},1)}{\Omega_E^{\operatorname{sgn}(h)}}. +\end{equation} +Valuations refer to this algebraic period-normalized value at a chosen +place above $2$. Changes of the fixed period, modular parametrization +or isogeny affect valuations by bounded constants. All parametrizations +send the cusp $\infty$ to the origin. +Replacing Equation~\eqref{eq:h:algebraic-value} by the central value +divided by a N\'eron real period of $E^{(h)}$ changes a finite valuation +by $O_E(1)$: the differential changes by the usual twisting factor, +and there are only finitely many twisting classes at $2$. + +Every uniform bound below specifies its fixed data. Constants may +depend on the curve, a chosen fixed twist and finite local preparation; +they may not depend on the subsequent cube dimension or the number of +new primes. At finite precision, the sizes of primes realizing a +specified configuration may depend on that entire configuration. +A limiting construction will only be used through its finite +realizations. + +\begin{lemma}[Finite descent and corank]\label{pr:finite-descent} +Let $F$ be the quotient of $\Sha(E/\Q)[2^\infty]$ by its maximal +divisible subgroup. Then +\[ + d_2(E)=c_2(E)+\dim_{\F_2}F[2], + \qquad \dim_{\F_2}F[2]\text{ is even}. +\] +Thus $d_2(E)\in\{0,1\}$ implies $c_2(E)=d_2(E)$ and $F=0$. +\end{lemma} + +\begin{proof} +The finite Kummer sequence at $n=1$ gives +$d_2(E)=r(E)+\dim_{\F_2}\Sha(E/\Q)[2]$. +The divisible subgroup is a direct sum of copies of +$\Qtwo/\Ztwo$ and splits as an abstract abelian subgroup. +Its $2$-torsion dimension is its corank. Lemma~\ref{pr:ranks} +therefore gives the displayed identity. +The Cassels--Tate pairing on $F$ is perfect. For an elliptic curve, +the rational divisor $[O]$ defining its principal polarization makes +the pairing alternating +\citep[Chapter~I, Remark~6.10(b) and Theorem~6.13(a)]{MilneADT2006}. +A finite abelian $2$-group with such a pairing is an orthogonal sum +of pairs of cyclic groups of equal order: choose an element of +maximal order, pair it with an element detecting that order, split +off their nondegenerate plane, and continue. Hence its $2$-rank +is even. A finite $2$-group with zero $2$-rank is zero, proving +the last assertion. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/02-binary-algebra.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/02-binary-algebra.tex new file mode 100644 index 0000000000000000000000000000000000000000..d0fd3a40393a5b80a154b2f7bf00835179e9b43c --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/02-binary-algebra.tex @@ -0,0 +1,328 @@ +\section{Transfer on a binary cube}\label{sec:binary-algebra} +\label{sec:h:binary-algebra} + +Both analytic arguments will produce one determinant coordinate at each +vertex of a binary cube. The following algebra transfers a bounded +valuation at every nonzero vertex to the zero vertex. Its essential +feature is that the required dimension depends on a bounded number of +coefficients, even when the family involves arbitrarily many primes. + +Put $\Lambda=\Ztwo[[t]]$ and +$O=\widehat{\Lambda_{(2)}}$. Let $G\simeq(\Z/2\Z)^b$ and +$R=\Lambda[G]$. Index the sign homomorphisms $G\to\{\pm1\}$ +by $x\in\F_2^b$, with $x=0$ the augmentation. For an element or +matrix over $O[G]$, a subscript $x$ denotes evaluation at this character. +The proofs first control Laurent coefficients, then clear determinant +denominators, and finally use the parity of the number of solutions of +low-degree equations on the cube. + +\begin{lemma}[Laurent expansions]\label{lem:h:laurent-expansions} +For $M\ge1$, +\[ + O/2^MO\simeq(\Z/2^M\Z)((t)). +\] +Thus an element of $O$ has a unique expansion +$\sum_{n\in\Z}a_nt^n$ with $a_n\in\Ztwo$ and +$v(a_n)\to\infty$ as $n\to-\infty$. Its $O$-valuation is +$\min_n v(a_n)$. +\end{lemma} + +\begin{proof} +If $s\in\Lambda\setminus(2)$, write +$s=t^h v_1+2w_1$, with $v_1\in\Lambda^\times$ and +$w_1\in\Lambda$. Modulo $2^M$ its inverse is a geometric expansion +of length $M$ in $2w_1/(t^h v_1)$. It is a Laurent series with finite +negative support. Conversely every Laurent series with finite negative +support lies in the localization of $\Lambda$ modulo $2^M$, since +$t$ is invertible there. Taking inverse limits proves the expansion +statement. Reduction modulo successive powers of $2$ proves the +valuation formula. +\end{proof} + +\begin{lemma}[A uniform pole bound for Schur elimination] +\label{lem:h:bounded-poles} +Let $A_1,\ldots,A_m$ be square matrices over $\Lambda$ with nonzero +residual determinants and +$\ord_t(\overline{\det A_j})\le h$. Put +$A=\diag(A_1,\ldots,A_m)$. If $B=A+2E_1$ with $E_1$ a matrix over +$\Lambda$, then $B$ is invertible over $O$. Modulo $2^M$, every entry +of $B^{-1}$ has no powers below $-Mh$, independently of $m$ and of +the matrix sizes. The same bound holds for a Schur complement +$D=P-QB^{-1}S$ when $P,Q,S$ have entries in $\Lambda$. + +In particular, suppose a block over $R$ augments to $A$. It is +invertible over $O[G]$, and the assertion applies uniformly at all sign +evaluations. If the lower off-diagonal block $S$ augments to zero, the +Schur complement augments to the old block $P$. +\end{lemma} + +\begin{proof} +Write +$\det A_j=t^{h_j}v_j+2w_j$, where $h_j\le h$, +$v_j\in\Lambda^\times$, and $w_j\in\Lambda$. Put +\[ + C_j=\frac{\operatorname{adj}(A_j)}{t^{h_j}v_j}, + \qquad C=\diag(C_1,\ldots,C_m). +\] +Every entry of $C$ has pole at most $h$. We have $BC=1+2F_1$, with +every entry of $F_1$ having pole at most $h$. Consequently +\[ + B^{-1}\equiv C\sum_{j=0}^{M-1}(-2F_1)^j\pmod{2^M}. +\] +The $j$th summand has pole at most $(j+1)h\le Mh$. The number of +summands in a matrix product does not increase a valuation or pole +bound. Multiplication by power-series matrices likewise introduces no +negative powers. This proves the first assertion. + +The ring $O[G]$ is local with maximal ideal generated by $2$ and the +augmentation ideal of $G$. The residual determinant of the proposed +block is that of $A$, a unit over $\F_2((t))$, so the block is +invertible. Each sign evaluation differs from augmentation by a +matrix divisible by $2$ with entries in $\Lambda$. Apply the first +assertion to it. The final assertion is the Schur formula with +$S_0=0$. +\end{proof} + +\begin{lemma}[A bounded clearing factor]\label{lem:h:pivot-clearing} +Let $D$ be a based bounded complex of finite free $O[G]$-modules, of +total graded rank at most $r$, whose augmentation $D_0$ is a complex +over $\Lambda$. Suppose that the rational specialization of $D_0$ at +$t=0$ has one of the following cohomology patterns: +\begin{enumerate}[label=\textup{(\roman*)}] + \item dimension one in degrees one and two, and zero elsewhere; + \item dimension two in degree one, and zero elsewhere. +\end{enumerate} +Suppose that the total torsion length in the integral specialized +cohomology is at most $h_1$. + +In case \textup{(i)}, take an integral degree-one cycle $z$ and a closed +functional $\lambda\in2^{-a_0}(D^2)^*$, and suppose each character +constituent over the fraction field of $O$ is either acyclic or has +pattern \textup{(i)}. Let $u_x$ be the determinant tensor of their +cohomology classes, with value zero in the acyclic case. In case +\textup{(ii)}, take two cycles whose denominator exponents sum to at +most $a_0$, suppose each constituent has pattern \textup{(ii)}, and +let $u_x$ be their wedge determinant coordinate. One may multiply these +coordinates by any one element $\eta\in O[G]$. + +Then there are $f,d\in O[G]$ with $d_x=f_xu_x$ at every character, +such that $f$ is $2^{a_0}$ times a polynomial of bounded degree in +the differential entries of $D$, the degree depending only on $r$. +Moreover +\[ + f_0\in\Lambda,\qquad f_0(0)\ne0,\qquad + v(f_0(0))\le C(r,h_1,a_0). +\] +If, at every fixed precision, the entries of $D_x$ have a uniform bound +on negative Laurent support, then so do the $f_x$. No such assertion is +required for $d_x$, for the cycles, or for $\eta$. +\end{lemma} + +\begin{proof} +Over $\Ztwo$, put the specialized complex into a sum of free +cohomology terms and one-dimensional two-term complexes with +differentials $2^{a_j}$, by elementary-divisor decomposition. The sum +of the positive $a_j$ is at most $h_1$. Lift the constant integral +basis changes to $D$. Cancel the same pivot positions formally, retaining +their pivot numerators as denominators. The number of operations is bounded +by $r$. Each pivot and basis change is rational in the differential +entries. Let $P_1$ be a product of sufficiently high powers of the +successive pivot numerators so that every denominator in these changes +and in the determinant comparison divides $P_1$. Its degree is bounded +in terms of $r$; its specialization $P_{1,0}(0)$ is nonzero with +valuation bounded in terms of $r,h_1$. Increase the powers once more +if needed to give all final expressions the same denominator. + +Over $O[G][1/P_1]$, case \textup{(i)} leaves a complex +$[O[G]\xrightarrow{\delta}O[G]]$ in degrees one and two. Let +$\alpha,\beta$ be the projected cycle and closed functional. Their +determinant tensor, including the cancelled-pivot determinant factor, +is a rational expression in $D,z,2^{a_0}\lambda$. If a field +constituent has $\delta\ne0$, the cycle identity +$\delta\alpha=0$ gives $\alpha=0$, so the same expression yields +the stipulated zero coordinate. In case \textup{(ii)} the remaining +complex is $O[G]^2[-1]$ and its coordinate is the determinant of the +two projected cycles times the pivot determinant factor. In either +case, after denominator clearing, for every constituent on which +$P_{1,x}\ne0$ we have +\[ + u_x=2^{-a_0}\eta_x Q_{1,x}/P_{1,x},\qquad Q_1\in O[G]. +\] +Set $f=2^{a_0}P_1^2$ and $d=\eta P_1Q_1$. This gives $d_x=f_xu_x$ +on those constituents. Where a pivot numerator first vanishes, +$P_{1,x}=0$, and both sides of the cleared identity are zero. Thus the +identity holds on every character. Since $f$ involves only the +bounded number of differential entries in the pivot calculation, +its degree, augmentation valuation and pole bounds are as asserted. +The factor $\eta$ has been placed in $d$, never in $f$. +\end{proof} + +The preceding lemmas isolate the denominator problem: after eliminating +new blocks, the clearing factor uses a complex of bounded size. +The remaining task is to match finitely many coefficients at zero and +at some nonzero vertex. The next lemma gives that match once the cube +has sufficiently many coordinates. + +\begin{lemma}[Finite coefficient congruences] +\label{lem:h:boolean-coefficients} +Let $A_1(x),\ldots,A_q(x)\in\Ztwo$ each be one specified Laurent +coefficient of the evaluation of an element of $O[G]$. If +\[ + b>q(2^{M-1}-1), +\] +there is $x\ne0$ such that +$A_i(x)\equiv A_i(0)\pmod{2^M}$ for every $i$. +\end{lemma} + +\begin{proof} +For one coefficient write +\[ + A(x)=\sum_{g\in G}a_g(-1)^{g\cdot x} + =\sum_{S\subseteq\{1,\ldots,b\}}c_Sx_S, + \qquad x_S=\prod_{i\in S}x_i, + \qquad 2^{|S|}\mid c_S. +\] +The last divisibility follows by expanding each sign as a product of +$1-2x_i$. The $j$th binary digit of $z\in\Ztwo$ is +$\delta_j(z)=\binom z{2^j}\bmod2$; this holds on nonnegative integers +by binary expansion and then on $\Ztwo$ by continuity. In the ring +of functions on the binary cube with coefficients in $\F_2[[Z]]$, +\[ + (1+Z)^{A(x)}=(1+Z)^{c_\varnothing} + \prod_{S\ne\varnothing} + \left(1+x_S\big((1+Z)^{c_S}-1\big)\right). +\] +The nonconstant factor indexed by $S$ starts at degree at least +$2^{|S|}$ in $Z$. A term contributing to $Z^{2^j}$, for $j\ge1$, +therefore has Boolean degree at most +\[ + \sum_S|S|\le\sum_S2^{|S|-1}\le2^{j-1}. +\] +The zeroth digit is constant. The congruences in the statement are +thus equations over $\F_2$ of total degree at most +$q\sum_{j=1}^{M-1}2^{j-1}=q(2^{M-1}-1)$, all vanishing at zero. +For completeness, the number of their common zeros is even: modulo +two it is the sum over the cube of the product of $1+Q$ over all +defining equations $Q$. Every monomial has degree below $b$, hence +omits a variable and sums to zero. This is the +Chevalley--Warning argument \citep{Chevalley1935,Warning1935}. The zero solution therefore has a +nonzero companion. +\end{proof} + +We now apply these coefficient congruences to the cleared identity +$d_x=f_xu_x$. Only the bounded negative support of $f_x$ is prescribed; +for $d_x$ we will match its constant coefficient alone. This distinction +keeps the required number of congruences independent of the numerator's +other coefficients. + +\begin{lemma}[Transfer through a bounded clearing factor] +\label{lem:h:boolean-transfer} +Let $f,d\in O[G]$ and let $u_x\in\Lambda[1/2]$ satisfy +$d_x=f_xu_x$ at each character. Suppose +$f_0\in\Lambda$ and $c_0=v(f_0(0))<\infty$. Fix $M>c_0$, and +suppose every $f_x\bmod2^M$ has no powers below $-L(M)$. If +\begin{equation}\label{eq:h:cube-threshold} + b>(L(M)+2)(2^{M-1}-1), +\end{equation} +some $x\ne0$ satisfies +\begin{equation}\label{eq:h:central-transfer} + v\bigl(u_x(0)-u_0(0)\bigr)\ge M-2c_0. +\end{equation} +Consequently, when $c_0$ and each $L(M)$ have bounds independent of +the family, a uniform upper bound $v(u_x(0))\le B_1$ at all nonzero +vertices forces $v(u_0(0))\le B_1$ for all sufficiently large $b$. +The base value itself is allowed to vary with the family. +\end{lemma} + +\begin{proof} +Apply Lemma~\ref{lem:h:boolean-coefficients} to the coefficients of +$f_x$ in degrees $-L(M),\ldots,0$ and to the constant coefficient +of $d_x$. At the supplied nonzero solution, every negative coefficient +of $f_x$ is divisible by $2^M$, and its constant coefficient is +congruent to $f_0(0)$. Therefore its constant coefficient has valuation +$c_0$, and $v_O(f_x)\le c_0$. Since $d_x\in O$, the identity +$d_x=f_xu_x$ gives $v_O(u_x)\ge-c_0$; the same bound holds for +$u_0$. By Lemma~\ref{lem:h:laurent-expansions}, all their coefficients +are in $2^{-c_0}\Ztwo$. Both have zero negative coefficients because +they lie in $\Lambda[1/2]$. + +The convergent constant-term convolution gives +\[ + [t^0]d_x\equiv([t^0]f_x)u_x(0)\pmod{2^{M-c_0}}, + \qquad [t^0]d_0=f_0(0)u_0(0). +\] +Combine these identities with the imposed coefficient congruences and +divide by $f_0(0)$. This proves +Equation~\eqref{eq:h:central-transfer}. For the consequence, choose +one integer $M>\max\{c_*,B_1+2c_*\}$, where $c_*$ bounds $c_0$, +and then take $b$ above Equation~\eqref{eq:h:cube-threshold}. If the +base valuation exceeded $B_1$, the transferred nonzero valuation would +also exceed $B_1$, a contradiction. The pivot valuation affects the +required precision and dimension, but not the transferred upper bound. +\end{proof} + +\subsection{Finite cochain models} +\label{sec:common-finite-models} + +The arithmetic applications also need finite free complexes that retain +maps to the original cochains. The following algebraic construction +provides these models and transports their comparison diagrams. +It applies before any determinant coordinate is chosen. + +\begin{lemma}[Finite Artin models]\label{rl:finite-model} +\label{lem:h:finite-models} +Let $(A,\mathfrak m,k)$ be an Artin local ring, and let $D$ be a complex of +flat $A$-modules. Suppose $H^*(D\otimes_A k)$ is finite dimensional and +supported in $[a,b]$. There is a bounded finite free complex $C$, with +\[ + \operatorname{rank}_A C^j=\dim_k H^j(D\otimes_A k), +\] +and a strong deformation retraction +\[ + i:C\longrightarrow D,\qquad p:D\longrightarrow C,\qquad + pi=1,\qquad 1-ip=dh+hd. +\] +Thus maps to the original complex, as well as maps between finite models, +are available. Any fixed finite collection of chain maps, homotopies, +triangles, and perfect pairings can be transported to these models. +\end{lemma} + +\begin{proof} +Flat modules over an Artin local ring are free, including modules of infinite +rank. Here is a useful version of the argument. Lift a basis of $M/\mathfrak +mM$ to a flat module $M$, and map the corresponding free module to $M$. +Its cokernel is zero because $\mathfrak m$ is nilpotent. Flatness shows that +the kernel has zero reduction, and nilpotence again makes the kernel zero. + +Split the residual complex as its cohomology, with zero differential, plus +contractible two-term disks. Lift all the graded bases. These lifts are +graded isomorphisms: an inverse modulo $\mathfrak m$ lifts to an inverse by +a finite geometric series. Let $d_0$ be the lifted disk differential and +write $d=d_0+\epsilon$. All coefficients of $\epsilon$ belong to +$\mathfrak m$. For the disk contraction $(i_0,p_0,h_0)$, arrange +$h_0^2=h_0i_0=p_0h_0=0$ and +$1-i_0p_0=d_0h_0+h_0d_0$. The operators +$1+h_0\epsilon$ and $1+\epsilon h_0$ have finite geometric inverses. +The homological perturbation lemma gives explicit contraction maps; +we record the formulas to retain their compatibility with the +arithmetic diagrams \citep[Sections~2.2--2.4 and~3.2]{Crainic2004}. +The perturbation identities give the differential +\[ + d_C=p_0\epsilon(1+h_0\epsilon)^{-1}i_0 +\] +on the lifted residual cohomology, and give +\[ + i=(1+h_0\epsilon)^{-1}i_0,\quad + p=p_0(1+\epsilon h_0)^{-1},\quad + h=h_0(1+\epsilon h_0)^{-1}. +\] +Substitution, using $(d_0+\epsilon)^2=0$, proves the asserted contraction +identities. These calculations are valid for infinite disk sums: each +operator is a module homomorphism and every geometric series terminates +at the nilpotence exponent of $\mathfrak m$. + +Transport a map $f$ as $p'fi$, retaining the contraction homotopies +for compositions. A quasi-isomorphism between bounded free complexes +has a contractible cone and a homotopy inverse. This transports finite +diagrams, including triangles and perfect dualities. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/03-heegner.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/03-heegner.tex new file mode 100644 index 0000000000000000000000000000000000000000..46647ee4c42dfd17f5531bedf70a5c1a102f7df4 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/03-heegner.tex @@ -0,0 +1,2117 @@ +\section{Heegner points and transfer} +\label{sec:heegner-interpolation} + +We prove the Heegner comparison, the genus and ring bounds, and the +interpolation criterion stated in Section~\ref{sec:transfer-criteria}. +The point and its paired functional define one determinant coordinate. +Its central value measures the point index after the Selmer and local +contributions have been subtracted. Local switches then control its +divisors. An outer limit supplies the uniform ring bound when residual +irreducibility is unavailable; a universal binary family supplies +interpolation. + +\subsection{Height and base Selmer comparisons} + +Retain the genus and ring data, character sums $P_c(e)$, and lattice +indices of Section~\ref{sec:transfer-criteria}. We first justify the two +comparisons used there. + +\begin{proof}[Proof of Proposition~\ref{prop:heegner-comparison}] +The explicit Gross--Zagier formula for ring classes +\citep[Theorem~1.1, pp.~2524--2525]{CaiShuTian2014} applies. Automorphic induction of the +quadratic character gives the product in Equation~\eqref{eq:h:height}. Discriminant and conductor are prime to $N$, and the +classical split Heegner hypothesis holds; consequently the shared-prime +corrections in the general formula are absent. The unit-index convention +is constant in the fields retained here. With a character sum, solving +the formula for the height gives exactly $c\sqrt{|k|}$, as in +Equation~\eqref{eq:h:height}. The forward Gross--Zagier--Kolyvagin theorem +gives the rank and finiteness assertion +\citep{GrossZagier1986,Kolyvagin1990}. + +For Equation~\eqref{eq:h:index-comparison}, both free points are compared +with the free line on $E^{(h)}(\Q)$. Its regulator cancels from the ratio +of their heights, since absolute canonical height is unchanged by twist +identification. This height invariance follows from the canonical-height +limit and the degree formula for heights under morphisms +\citep[Chapter~IV, Lemmas~4.1 and~4.5--4.6, and Remark~4.12]{MilneEC2021}. +The remaining variable factor is +$\sqrt{|hk|}L(E^{(hk)},1)$; its infinity sign is that of $h_*$. Period +and lattice changes have bounded $2$-valuation. If the rank-one line is +instead that of the fixed curve $E^{(h_*)}$, its regulator is fixed and +the same calculation gives Equation~\eqref{eq:h:reverse-comparison}. +\end{proof} + +\begin{proof}[Proof of Lemma~\ref{lem:h:base-selmer-bound}] +Restriction, twisting, and addition or subtraction of conjugates give +maps in both directions between the Selmer group over $K$ and +\[ + \Sel_{2^\infty}(E^{(h_0)}/\Q) + \oplus\Sel_{2^\infty}(E^{(h_0k)}/\Q) +\] +whose composites are multiplication by $2$. They induce isogenies on +divisible subgroups. On the finite quotients the kernel of either induced +map is killed by $2$: subtract an element of the divisible subgroup to +lift a divisible image, and then use the composite. The generator +dimensions are uniformly bounded. Indeed the mod-$2$ Selmer group over +$K$ is bounded by Kummer cohomology over $K(E[2])$; this is a quadratic +extension of a fixed field with a bounded number of ramified primes. +Kummer theory bounds the generator number of the corresponding pro-$2$ +group over the fixed field, and the index-two subgroup bound preserves +a uniform bound. The fixed local support includes that of $h_0$. +The finite quotient on the displayed product is bounded by hypothesis; +therefore its counterpart over $K$ has bounded length as well. For a +finite collection of fields, finiteness of each quotient is enough. +\end{proof} + +\subsection{Integral models and ring-class deformation} +\label{rl:section}\label{sec:h:finite-models} + +The determinant argument uses characters of increasing conductor. +We construct their cochain limits together with maps to the original +cochains. These maps will let us detect limiting Selmer classes by +Galois evaluation and choose local switches. Later we retain the same +maps through the outer limit needed for the ring bound. + +Write $T=T_2E$ and $\Lambda=\mathbf Z_2[[t]]$. For a quadratic +squareclass $h$, put $T^h=T\otimes\chi_h$. The imaginary quadratic field +$K$ satisfies the split Heegner hypothesis at $2N$. We omit the two fields +with extra units and, when $E$ has complex multiplication, its CM field. +A quadratic character $\chi$ comes from a quadratic twist over $\mathbf Q$. +We use +\[ + A_i=(\mathbf Z/2^i\mathbf Z)[t]/(t^i). +\] +The same constructions work over $A_i[G]$ and $\Lambda[G]$, where $G$ is a +fixed finite elementary abelian $2$-group and the additional character has +values in $G$. Statements uniform in the number of generators of $G$ will +be identified separately; finite-diagram compactness by itself is a statement +for fixed $G$. + +\subsubsection{Finite models with their cochain maps} + +The general finite-model construction is Lemma~\ref{rl:finite-model}. +We apply it to the following arithmetic cochains and retain its actual +contractions throughout. + +For a profinite group and a finite free coefficient module over an Artin local ring $A$, +continuous inhomogeneous cochains are flat: locally constant functions are +the filtered union of the modules of functions on finite clopen partitions, +and these modules are finite free. Their reduction is the cochain complex +with reduced coefficients. The same observations apply to restrictions, +mapping cones, and local conditions given by finite free complexes. In the +applications below the groups are Galois groups of totally imaginary number +fields or nonarchimedean local fields. Their $2$-cohomological dimension and +the usual finiteness theorems give the bounded residual cohomology required +in Lemma~\ref{rl:finite-model}. + +For an inner limit, the quadratic field $K$, the active conductor support, +the finite group $G$, and the number of derivative primes are fixed. +The residual representation is $E[2]$: all the scalar characters and +group-like coefficients become trivial in the residue field. Put +$F=K(E[2])$. The number of places of $F$ in the permitted set $S_i$ is +bounded even when its auxiliary primes move. Kummer theory bounds +$H^1(G_{F,S_i},\mathbf F_2)$ by the $S_i$-units modulo squares and +$\operatorname{Cl}(F)[2]$; their dimensions are bounded by the unit +rank, $\#S_i$, and the fixed class-group dimension. Hochschild--Serre +for the fixed group $\operatorname{Gal}(F/K)$ then bounds the residual +global $H^1$ for $E[2]$. The global Euler characteristic bounds $H^2$, +and $H^0$ is already bounded. Local cohomology and the specified local +conditions have bounded residual dimensions, since the local degrees +of $K$ are at most two and the number of places is bounded. Thus the +target Selmer cones over $K$ have uniformly bounded finite-model ranks +in this inner limit. This bound may depend on the fixed active support; +the stronger outer bound is proved in Lemma~\ref{rl:residual-bound}. +No rank bound is asserted for cochains over the growing ring-class +fields, or for the induced modules in their Shapiro descriptions. + +\begin{lemma}[Limits of finite diagrams]\label{rl:finite-limits} +Suppose diagrams of bounded finite free complexes over $A_i$, or +over $A_i[G]$, have a common bounded cohomological degree interval +and bounded ranks in every degree. Include the chain homotopies +and inverses for every asserted identity or equivalence. Along a +cofinal subsequence, or a nonprincipal ultrafilter, their matrices +converge to the same diagram of perfect complexes over $\Lambda$ +or $\Lambda[G]$. + +Moreover, the contractions into the original cochains may be retained for +the evaluation construction in Lemma~\ref{rl:evaluation}. Adding finitely +many new objects or maps does not require changing already chosen models +for the old objects. Finite-stage arithmetic operations with unbounded +source complexes are permitted when only finitely many of their outputs, +and the witnesses to their identities, are retained in the bounded +target complexes. +\end{lemma} + +\begin{proof} +There are finitely many possible graded ranks. Fix them on an +ultrafilter-large set. At a fixed precision $j$, all matrix entries belong +to the finite ring $A_j$ (or $A_j[G]$), so have unique ultrafilter limits. +These limits are compatible as $j$ varies. Matrix identities, including +the homotopy-inverse identities, are finite polynomial identities and pass +to the limit. New models and maps may be mapped to old models by their +already fixed contractions. Passing to any slower cofinal precision has +the same old limits. For the all-sequence evaluation statements below, +fix this ultrafilter once and for all, and keep the original contraction +at every stage. Later arithmetic diagrams must extend these same +stages. Restriction to an ultrafilter-large set and passage to slower +cofinal coefficient precision preserve every old evaluation on every +old group sequence. Thus later operations use the same stage diagrams +and ultrafilter, preserving the arithmetic maps already constructed. + +Here is the last assertion in cochain terms. Let $D_i$ be an original +target cochain complex, with contraction +$(\iota_i,\pi_i,h_i)$ onto its bounded finite model $C_i$. +Perform transfer and scalar weighting at stage $i$ before applying +this contraction. A resulting cycle $z_i'\in D_i^1$ gives +$z_i=\pi_i z_i'\in C_i^1$, and +\[ + z_i'-\iota_i z_i=d(h_i z_i'). +\] +Thus its relation to the original arithmetic cocycle is retained by +the original contraction. If an identity in the target is +$u_i'-v_i'=d w_i'$, retain the vectors +$\pi_i u_i',\pi_i v_i',\pi_i w_i'$; the corresponding identity is +still exact. For identities involving maps between target complexes, +use the transported maps $\pi_i'f_i\iota_i$ and their contraction +homotopies, so that the same assertion includes the required boundary +corrections. Local lifts, closed degree-two functionals, and witnesses +to specialization, duality and switch identities are treated in the +same way. They are finitely many vectors or matrices of bounded size. +Their entries, as well as the differentials, therefore have simultaneous +limits. Neither a free model of the arithmetic source nor the entire +transfer map from that source is included in the limiting diagram. +Any precision lost in a finite-stage calculation is accounted for +before retaining these vectors; passing to the same slower cofinal +precision for the whole diagram preserves all its identities. +\end{proof} + +The finite models now retain both the original cochains and their +comparison maps. We next specify the local conditions on those cochains. +The point is to retain the actual Kummer images at every place dividing $2N$; +the determinant comparisons will use their integral orthogonality, not +just the rational Selmer ranks. + +\subsubsection{Integral local conditions and duality} + +\begin{lemma}[Integral Kummer local condition]\label{rl:kummer} +\label{lem:h:duality} +Let $F$ be a finite extension of a nonarchimedean local field of +characteristic zero, and let $B/F$ be any elliptic curve. Put +$M_F=B(F)^\wedge_2=\varprojlim_n B(F)/2^nB(F)$. There is a perfect local +condition +\[ + U_F=M_F[-1]\longrightarrow R\Gamma(F,T_2B). +\] +For every $n\geq1$, derived reduction has +\[ + H^0(U_F\otimes^{\mathbf L}\mathbf Z/2^n)=B(F)[2^n],\qquad + H^1(U_F\otimes^{\mathbf L}\mathbf Z/2^n)=B(F)/2^nB(F). +\] +Its map in degree zero is the isomorphism onto +$H^0(F,B[2^n])$, and its map in degree one is the finite Kummer injection. +The condition is its own exact orthogonal complement under local Tate +duality, for every reduction type and with no hypothesis on $B[2]$. +\end{lemma} + +\begin{proof} +The local analytic description of $B(F)$ shows that $M_F$ is a finitely +generated $\mathbf Z_2$-module. Its torsion is the finite group +$B(F)[2^\infty]$. Consequently $M_F$ has a free resolution of length at +most one. Also $H^0(F,T_2B)=0$, since $B(F)[2^\infty]$ has bounded +exponent. The integral Kummer injection into $H^1(F,T_2B)$ therefore +defines the displayed morphism using the truncation in degrees at most +one of $R\Gamma(F,T_2B)$. + +Tensor the free resolution of $M_F$ with $\mathbf Z/2^n$. Its two +cohomology groups are $M_F[2^n]$ and $M_F/2^nM_F$. The inverse limits +of the ordinary Kummer sequences identify their maps as asserted. + +For orthogonality, compose cup product and the Weil pairing with the local +invariant map. A morphism +\[ + M_F[-1]\otimes^{\mathbf L}M_F[-1] + \longrightarrow\mathbf Z_2[-2] +\] +is determined by its homomorphism $M_F\otimes M_F\to\mathbf Z_2$: +the possible $\operatorname{Tor}_1$ is in degree one and gives no extra +degree-zero morphism to this target. The indicated homomorphism vanishes, +because the finite Kummer image annihilates itself at every level by local +Tate duality. Choose a nullhomotopy in free models. The induced morphism +\[ + R\Gamma(F,T_2B)/U_F + \longrightarrow R\operatorname{Hom}_{\mathbf Z_2} + (U_F,\mathbf Z_2)[-2] +\] +is a quasi-isomorphism. This can be checked after reduction modulo $2$: +degree one is the perfect pairing of the finite Kummer quotient with the +Kummer image, and degree two is dual to $B(F)[2]$. Its perfect cone is +therefore zero by derived Nakayama. This proves exact orthogonality and +also its compatibility with derived reduction. This is precisely the +finite-module duality input of \cite[Proposition~5.2.4]{Nekovar2006}. +\end{proof} + +Where the scalar deformation is trivial, extend this local condition by +derived scalar extension to $A_i$ or $A_i[G]$. At an unramified good prime +use the inflated residue-field complex +\[ + U_v=[\,M\xrightarrow{\operatorname{Fr}_v-1}M\,] + \quad\text{in degrees }0,1. +\] +Its quotient in full local cochains is the singular local complex. +The full local condition is the identity on local cochains, and its +orthogonal strict condition is zero. At a derivative prime the +conditions used later are the following specified truncations instead. +In its split local model write +\[ + L_v=D^0\oplus(F_v\oplus S_v)[-1]\oplus D^2[-2], +\] +where the differential is zero, $D^0$ is dual to $D^2$, and the finite +and transverse planes $F_v,S_v$ are each isotropic. Put +\[ + U_{\rm str}=D^0,\qquad + U_{\rm rel}=D^0\oplus(F_v\oplus S_v)[-1],\qquad + U_F=D^0\oplus F_v[-1],\qquad U_S=D^0\oplus S_v[-1]. +\] +Then $U_{\rm str}^{\perp}=U_{\rm rel}$ and each plane condition is +its own orthogonal complement. Every displayed condition maps +isomorphically onto local $H^0$ and injectively into local $H^1$. +Thus they satisfy precisely the detection hypotheses used below. +Their finite arithmetic realization and the isotropic-plane +nullhomotopies are part of the derivative construction; these +truncated conditions are not identified with the full local condition. + +For a finite permitted set $S$ the Selmer complex is, by definition, +\begin{equation}\label{rl:selmer-definition} + C_S=\operatorname{Cone}\left( + R\Gamma(G_{K,S},M)\oplus\bigoplus_{v\in S}U_v + \longrightarrow\bigoplus_{v\in S}R\Gamma(K_v,M) + \right)[-1]. +\end{equation} +At $2N$ take the Kummer conditions just constructed. Restriction and +localization triangles are the triangles of this cone. The finite rings +$A_i$ and $A_i[G]$ are Frobenius coefficient rings; alternatively the +duality maps may be checked after reduction to their residue field. +Exact local orthogonality and global duality therefore give +\begin{equation}\label{rl:global-duality} + C_S\simeq R\operatorname{Hom}(C_S^{\perp},A_i)[-3], +\end{equation} +with the appropriate dual representation. This application uses the +orthogonality hypotheses of +\cite[Theorem~6.3.4]{Nekovar2006}; the theorem is not being used to assert +the existence of a varying-prime limit. Complex places contribute zero +Tate complexes. If the character is inverted by the nontrivial +automorphism of $K/\mathbf Q$, conjugate transport followed by the Weil +pairing identifies the two representations over the same scalar ring. +All maps and nullhomotopies in this paragraph are finite diagrams to +which Lemma~\ref{rl:finite-limits} applies. + +\subsection{The moving conductor character} +\label{sec:h:conductor-direction} + +The conductor character must preserve the local conditions at $2N$ +while making the new local terms invertible after reduction modulo $2$ +and inversion of $t$. The following proposition supplies those local +values. Its separate bounds on Tate Frobenius control the contribution +of the moving prime when we later specialize to $t=0$. + +\begin{proposition}[Ring-class characters with prescribed local values] +\label{rl:characters}\label{lem:h:conductor-primes} +Fix finitely many split primes of $K$ above odd rational primes, outside +$2N$, and orient one prime in each conjugate pair. There are distinct +split rational primes $r_i$ avoiding all the fixed data and characters +\[ + \xi_i:\operatorname{Gal}(H_{r_i}/K)\longrightarrow + \mathbf Z/2^{n_i}\mathbf Z, + \qquad n_i\longrightarrow\infty, +\] +such that $\xi_i$ is surjective on the inertia quotient at $r_i$, is zero +at the primes above $2N$, and has odd value at each prescribed oriented +prime. We can require $r_i\to1$ in $\mathbf Z_2$ and +\begin{equation}\label{eq:h:r-avoidance} + v_2(2+a_{r_i}(E)),\quad v_2(2-a_{r_i}(E)),\quad + v_2\det(1\pm\operatorname{Fr}_{r_i}\mid T)\ \leq c_E. +\end{equation} +The constant $c_E$ is independent of the list and of $K$. +\end{proposition} + +\begin{proof} +We give the compatibility argument before imposing the Tate condition. +Choose prime ideals $\mathfrak p_1,\ldots,\mathfrak p_s$ with pairwise +disjoint conjugate pairs, including the oriented prescribed primes and +the primes above $2N$, and enough additional split prime ideals to +generate $\operatorname{Cl}(K)$. Such additional ideals may avoid any +fixed finite set. Put weight $w_j=1$ at a prescribed odd prime and +$w_j=0$ at every additional prime and every prime above $2N$. +The conjugate weight is $-w_j$. Let +\[ + R=\ker\bigl(\mathbf Z^s\longrightarrow\operatorname{Cl}(K)\bigr), +\] +choose a basis $m^{(a)}$ of $R$, and choose $\beta_a\in K^\times$ with +$(\beta_a)=\prod_j\mathfrak p_j^{m_j^{(a)}}$. + +Work first over $F_\infty=K(\mu_{2^\infty})$ and adjoin $2^n$-th roots +of the finitely many $\beta_a/\overline\beta_a$. Prescribe on these +roots the multipliers +\begin{equation}\label{rl:kummer-prescription} + \zeta_{2^n}^{\,-\sum_j m_j^{(a)}w_j}. +\end{equation} +The minus sign fixes the choice of connecting map in the ring-class +sequence and could be reversed throughout. These prescriptions respect +every Kummer relation. Indeed, if +\[ + \prod_a(\beta_a/\overline\beta_a)^{b_a} + \in(F_\infty^\times)^{2^n}, +\] +take its valuation at a prime above each $\mathfrak p_j$ of nonzero +weight. These odd primes are unramified in $F_\infty/K$. Thus +$2^n$ divides $\sum_a b_am_j^{(a)}$ for each such $j$, proving the +required compatibility of~\eqref{rl:kummer-prescription}. Primes over +$2$ have weight zero and impose no division by a ramification index. +Units impose no additional weighted relation. Kummer duality supplies +the prescribed automorphism of the radical extension over $F_\infty$. + +At a rational prime $r$ split in a sufficiently large finite cyclotomic +subfield, the power-residue character of $\mathbf F_r^\times$ is +surjective onto $\mu_{2^n}$. The split ring-class exact sequence is +\[ + 1\longrightarrow + (\mathcal O_K/r\mathcal O_K)^\times/(\mathbf Z/r\mathbf Z)^\times + \longrightarrow\operatorname{Pic}(\mathbf Z+r\mathcal O_K) + \longrightarrow\operatorname{Cl}(K)\longrightarrow1. +\] +The excluded extra-unit fields are the only source of a unit +correction. The first group is $\mathbf F_r^\times$, with a principal +relation measured by $\beta/\overline\beta$ at the oriented prime over +$r$. Consequently~\eqref{rl:kummer-prescription} says exactly that its +primitive power-residue character extends to the class group with the +specified values $w_j$. More explicitly, the inertia group and the +chosen ideal classes present the ring-class group, and the basis of $R$ +lists its additional relations. We have imposed those relations on the +inertia character itself; we have not divided by a class-group order +to extend a previously fixed character. Thus this construction introduces +no denominator, even when the class number has a large $2$-part. The +class group and the number of prescribed primes change the finite +Chebotarev extension, but not the integrality of the character. +Since the ring-class extension is unramified at $2N$, value zero on +Frobenius means that the resulting local character is trivial there. +Conjugation acts by inversion. + +We now show that imposing these finitely many radical conditions cannot +force either forbidden Tate trace. In the non-CM case the image of +$G_{K(\mu_{2^\infty})}$ is an open subgroup of +$\operatorname{SL}_2(\mathbf Z_2)$, by the fixed-prime open-image theorem +and the cyclotomic determinant identity +\cite[Chapter~IV, \S2.2, theorem, p.~IV-11, and Chapter~I, \S1.2, +Example~2, p.~I-4]{Serre1968}: the image is the intersection of the +open image of $G_K$ with the determinant-one subgroup. +Its index in the corresponding fixed-$E$ image changes +by at most two when $K$ changes. Its commutator subgroup contains a +fixed open subgroup $U_E$ of $\operatorname{SL}_2(\mathbf Z_2)$. +One may see uniformity by starting with a principal congruence subgroup +in the fixed image: every index-two subgroup contains its squares, and +the commutators of the resulting fixed congruence subgroup are open. +Because the radical extension over $F_\infty$ is abelian, these +commutators act trivially on it. Hence every permitted Tate coset +contains a translate of $U_E$. + +For completeness, in the CM case let $M$ be the CM field. The image over +$KM(\mu_{2^\infty})$ contains a fixed open subgroup of the norm-one +Cartan; the index changes by a bounded factor, as $[KM:\mathbf Q]\leq4$. +Choose $\gamma\in G_{KM}$ with +$\chi_{\rm cyc}(\gamma)=5^4=625$. This is possible uniformly: the +cyclotomic image of $G_{KM}$ has index at most four in +$\mathbf Z_2^\times$, so contains fourth powers. On the radical Galois +group, conjugation by $\gamma$ is raising to $625$, because all the +radicands lie in $K$. On the Tate image over $KM$, conjugation is +trivial. Therefore +\[ + \gamma u\gamma^{-1}u^{-625},\qquad + u\in G_{KM(\mu_{2^\infty})}, +\] +fixes every prescribed radical and acts on $T$ as $\rho_T(u)^{-624}$. +Raising to the fixed nonzero power $624$ carries an open subgroup of the +one-dimensional norm-one Cartan onto an open subgroup. This proves the +required uniform kernel statement also in the CM case. The open Cartan +image used here is the CM part of the usual $\ell$-adic image theorem +\cite[Chapter~IV, \S2.2, Remark, p.~IV-13]{Serre1968}. + +On a coset of an open subgroup of $\operatorname{SL}_2$, trace is not +identically $2$ or $-2$. The same holds on a coset of an open norm-one +Cartan subgroup; on the other Cartan-normalizer component trace is zero. +The relevant determinant-one sets are compact and have finitely many +cosets modulo the fixed open subgroup. Choose in each coset an element +whose trace is neither forbidden value. The largest of the finitely +many resulting valuations is a constant depending only on $E$. + +Finally restrict the prescribed radical automorphism and such a Tate +lift to a finite Galois extension, including as many roots of unity as +required. Chebotarev gives infinitely many rational primes with this +Frobenius class; choose the place over the prime to realize the chosen +representative. They split in $K$ and have arbitrarily high prescribed +congruence to $1$. Since +$\det(1\pm\operatorname{Fr}_r)=1\pm a_r+r$, a congruence precision +larger than the fixed trace bound gives all of~\eqref{eq:h:r-avoidance}. +All these conditions concern a finite extension at each stage. +\end{proof} + +Choose $n_i$ large enough that $1+t$ has order dividing $2^{n_i}$ in +$A_i^\times$, and put $\Psi_i=(1+t)^{\xi_i}$. For example $n_i\geq2i$ +is sufficient. Orient the inertia generator to act by $1+t$; +the prescribed split Frobenius exponents remain odd in the limit. +Use global cochains unramified outside $2N$, $r_i$, the active conductor +primes and the derivative primes already retained. At $2N$ use the +Kummer conditions above and elsewhere outside the conductors use the +unramified condition. Reduction modulo $t$, with the unramified +condition restored at $r_i$, gives the ordinary fixed-field complex; +retain its comparison map at every finite stage. + +\begin{lemma}[Acyclic relaxed local complexes]\label{rl:local-acyclic} +\label{lem:h:relaxed-local} +For a primitive character constituent, let $C$ denote the limiting +Selmer complex with full conditions at $r$ and at its active good +conductor primes, and the prescribed Kummer, unramified or derivative +conditions elsewhere. The limiting full +local complexes are acyclic over every height-one residue field of +$\Lambda$ of characteristic zero. At $(2)$, with residue field +$\Omega=\mathbf F_2((t))$, the $r$-complex is acyclic, as are the +complexes at active split primes with odd prescribed Frobenius exponent +of the deformation character and +at active primes $q$ with $t_q=0$. At each of these acyclic relaxed +places, the full and orthogonal strict conditions agree on the +indicated test. If every relaxed place is acyclic at that test and +the remaining local conditions are self-dual, global duality makes +the Selmer complex self-dual. The Selmer complex +has no global invariants on these tests. +\end{lemma} + +\begin{proof} +Use tame inertia and unramified Frobenius, or the Hochschild--Serre +complex for these two procyclic directions. At $r$, inertia minus one +is multiplication by $t$ times a unit. It is invertible on all the +indicated fields except the characteristic-zero fiber $t=0$. There, +$r\to1$, and the two remaining Frobenius differentials have nonzero +determinant by~\eqref{eq:h:r-avoidance}, including either sign of the +quadratic twist. The bound also ensures that the integral local +torsion at this central fiber has bounded length. + +At an active odd conductor prime, inertia of the quadratic character +acts by $-1$. Its differential is thus $-2$ and is invertible in +characteristic zero. In characteristic two the quadratic character +disappears. At a split prime the Frobenius action is $zB$, where +$B\in\operatorname{GL}_2(\mathbf F_2)$ and +$z=(1+t)^a$ has odd $a\in\mathbf Z_2$. Its coefficient of $t$ is one, +so $z$ is nonconstant. No nonzero polynomial over the finite constant +field vanishes at $z$. Thus both Frobenius complexes, with operators +$zB-1$ and $q^{-1}zB-1$, are invertible over $\Omega$; here $q=1$ in +the residue field. No irreducibility assumption is used. + +If $t_q=0$, the rational residual Frobenius $B$ has order three. +At a split place the operator is again $zB-1$, invertible whether +$z$ is nonconstant or $z=1$. At an inert place the ring-class +Frobenius is trivial, since the ideal $(q)$ is principal, and +the Tate Frobenius is $B^2$, which also has no eigenvalue one. +These observations give the additional $t_q=0$ assertion. + +The orthogonal full and strict conditions agree at each place where +full local cochains are acyclic. When this holds at every relaxed +place and the remaining local conditions are self-dual, +Equation~\eqref{rl:global-duality} gives global self-duality. +Global invariants in characteristic two are excluded by the nontrivial +$r$-inertia scalar. In characteristic zero the same argument works +unless the scalar is trivial; in that case $T\otimes\mathbf Q_2$ over +$G_K$ is absolutely irreducible. For non-CM curves this follows from +the open image, and for CM curves from the open Cartan and its +nontrivial normalizer component, since $K$ is not the CM field. +Lemma~\ref{rl:evaluation} below realizes these actions on the limiting +complex as well. On the self-dual tests, duality pairs degrees +one and two. +\end{proof} + +\subsection{The Heegner determinant and its central value}\label{sec:h:specialization} + +The point index is not itself the quantity transferred across a growing +family. Each new conductor prime changes the local Selmer terms as well +as the point. We combine these changes in a determinant coordinate. +Its central valuation will be twice the point index, less the finite +Selmer length and the conductor contribution. This formula reduces the +index estimates to lower bounds for the determinant coordinate. + +Retain a primitive genus or ring instance from Section~\ref{sec:transfer-criteria}, +with point $P_c(e)$ over $K$. Use the conductor characters just +constructed, taking $n_i\ge2i$, and the representations $T\chi_e\Psi_i$. +Retain the same auxiliary primes and the same fixed inner ultrafilter, +now denoted $\mathcal U_{\mathrm{in}}$. + +The Selmer complex $C$ is a coefficientwise limit of the corresponding +finite free cochain models along $\mathcal U_{\mathrm{in}}$. It has the integral Kummer condition at +$2N$, the full condition at $r_i$ and the active good conductor primes, +and the unramified condition at all other permitted finite places. +Here the full condition means that no restriction is imposed on local +cochains. Section~\ref{sec:h:finite-models} and Lemma~\ref{rl:local-acyclic} +constructed the local models, their duality maps, and the comparison +at $t=0$. We use these concrete complexes and maps; +cohomologically equivalent complexes without the comparison maps would +not suffice for the later prime choices. Over +$\operatorname{Frac}(\Lambda)$, the modified full local complexes +are acyclic, so the full conditions agree with their orthogonal strict +conditions. Global duality, followed by conjugate transport and the +Weil pairing, therefore gives a perfect pairing +\[ + H^1(C\otimes_\Lambda\operatorname{Frac}(\Lambda))\times H^2(C\otimes_\Lambda\operatorname{Frac}(\Lambda)) + \longrightarrow\operatorname{Frac}(\Lambda). +\] +Here conjugation in $K/\Q$ inverts the ring-class character. These are +the pairing and identification supplied by +Equation~\eqref{rl:global-duality} and Lemma~\ref{rl:local-acyclic}. + +Fix the single integer multiplier $L$ of +Lemma~\ref{lem:h:derivative-classes}. It depends on the curve, +parametrization and fixed local types, and clears descent and local +Kummer ambiguities for the complete conductor. In particular its +valuation does not grow with the number of primes. The following +construction and formulas include that multiplier throughout. + +At each finite stage transfer the Kummer class of $y_{cr_i}$ from +$H_{cr_i}$ to $K$ with the specified scalar coefficients, using +$Ly_{cr_i}$. Complete the finite coset sum before contracting its +target cocycle and local Kummer lifts into the models over $K$. +The resulting cycles $P_i$, with their contraction witnesses, give +$P\in H^1(C)$ by Lemma~\ref{rl:finite-limits}. +Local Kummer conditions at $2N$ are preserved because $\Psi_i$ is +trivial there. At the center of the $i$th finite model, the norm relation +has the factor +\begin{equation}\label{eq:h:trace-center} + \begin{aligned} + b_i&=a_{r_i}-\chi_e(\Fr_{\mathfrak r_i}) + -\chi_e(\Fr_{\bar{\mathfrak r}_i}), + \qquad r_i=\mathfrak r_i\bar{\mathfrak r}_i,\\ + P_i\big|_{t=0}&=\varepsilon_i b_i\kappa(LP_c(e)). + \end{aligned} +\end{equation} +where $\kappa$ denotes the Kummer class in the central comparison +and $\varepsilon_i$ is a unit; the equality is taken modulo the finite +coefficient precision. Since $\chi_e$ is defined over $\Q$, its values +at the conjugate Frobenius elements agree; explicitly, +$b_i=a_{r_i}-2\chi_e(r_i)$. +To retain the central identity at the cochain level, let $B_i$ be the +reduction of a fixed finite model of the ordinary Kummer complex over +$K$, and let $\beta_i:B_i\to C_i/(t)$ be its comparison map to the +relaxed central complex. Choose a cycle $q_i$ representing +$\kappa(LP_c(e))$. The finite norm relation gives a boundary witness +$v_i$ in the target model such that +\[ + P_i\bmod t-\varepsilon_i b_i\beta_i(q_i)=d v_i. +\] +Retain $\beta_i,q_i,v_i$, and the target contraction homotopies on +the same stages and at the same coefficient precision as $P_i$. +Retain these units in the same ultrafilter +$\mathcal U_{\mathrm{in}}$ as all the comparison maps. Then +$b=\lim_{\mathcal U_{\mathrm{in}}}b_i$ has bounded valuation by +Equation~\eqref{eq:h:r-avoidance}, and +$\varepsilon=\lim_{\mathcal U_{\mathrm{in}}}\varepsilon_i$ is a unit. Thus +$P|_{t=0}=\varepsilon b\kappa(LP_c(e))$, with $b\ne0$. +The special complex differs from the ordinary Kummer complex only by +the active-prime relaxed quotients and the limit of the singular +quotient at the single moving prime $r_i$, the latter of bounded length. +Inflation from the complexes omitting $r_i$ gives this comparison. All modified +local complexes are rationally acyclic at the center, so pairings agree +there as well. + +If the product has a simple zero, its rational special fiber has +one-dimensional cohomology in degrees one and two, and $P$ specializes +nontrivially by Gross--Zagier. The generic dimensions are at most these +special dimensions. Moreover, the long exact sequence for multiplication +by $t$ shows that $H^1(C[1/2])[t]=0$, since the special $H^0$ vanishes. +A torsion class that disappeared over the generic field would be killed +by a power of $t$ after localization at $(t)$; hence the nonzero special +class cannot disappear. Thus the generic ranks are one in degrees one +and two, $P$ spans $H^1$, and the rational rank is constant at $t=0$. +If only base Selmer corank one is known, the same dimension bound gives +generic ranks at most one; a zero generic point is allowed. + +\begin{definition}\label{def:h:determinant-coordinate} +Choose an integral basis of $\det^{-1}_{\Lambda}C$. In generic rank one, +the element formed by $P$ in $H^1$ and the functional +$\langle P,\cdot\rangle$ on $H^2$ determines a scalar +$u(C,P)\in\operatorname{Frac}(\Lambda)$ in that basis. Put $u=0$ if +$P=0$ or the generic rank is zero. Integral changes of determinant basis +multiply $u$ by a unit. +\end{definition} + +In the simple-zero case, constancy of the rational cohomology rank at +$t=0$ makes $u$ regular in the local ring $\Lambda_{(t)}$. Its value +$u(0)\in\Qtwo$ is therefore already defined. This specialization takes +place at $(t)$; the stronger assertion $u\in\Lambda[1/2]$ will follow +from the divisor estimates below. + +The determinant has a simple integral interpretation. On a rank-one +free Selmer line, the point and its paired functional each contribute +the point's index. Torsion in degree two subtracts its length from the +coordinate in the inverse determinant lattice. For example, the complex +$[\Ztwo\xrightarrow{2^a}\Ztwo]$ in degrees one and two has inverse +determinant lattice mapping to $2^a\Ztwo$ in +the rational determinant. The coordinate of a fixed rational tensor +therefore loses $a$ in valuation. The next lemma carries out this +calculation with the actual local Kummer conditions. It also compares +the Selmer length over $K$ with those of the two rational twists. + +\begin{lemma}[Central determinant valuation] +\label{lem:h:central-valuation} +For a simple-zero instance, +\begin{equation}\label{eq:h:central-determinant} + \begin{aligned} + v(u(0))&=2j(P_c(e)) + -\length\Sha(E^{(e)}/K)[2^\infty] + -\sum_{q\mid c}\sum_{v\mid q}t_v+O_E(1),\\ + t_v&=\dim_{\F_2}E[2]^{\Fr_v}. + \end{aligned} +\end{equation} +Furthermore, +\begin{equation}\label{eq:h:weil-restriction-length} + \length\Sha(E^{(e)}/K)[2^\infty] + +\sum_{q\mid c}\sum_{v\mid q}t_v + =s(e)+s(ek)+\sum_{q\mid k}t_q + +2\sum_{q\mid c}t_q+O_E(1). +\end{equation} +The constants include the one fixed class multiplier and the bounded +local contribution at the moving prime $r_i$. +\end{lemma} + +\begin{proof} +The ordinary integral Kummer complex over $K$ is self-dual. Its $H^1$ is +the compact Selmer module, and the torsion in $H^2$ has the length of the +finite quotient of the discrete Selmer group by its divisible subgroup. +This follows by derived base change to $\Qtwo/\Ztwo$: the local +complexes give exactly the discrete Kummer conditions. In the present +simple-zero case that finite quotient is +$\Sha(E^{(e)}/K)[2^\infty]$. Duality pairs the free parts in degrees +one and two perfectly. Torsion in degrees one and three costs a bounded +amount, by global torsion and duality. The uniform torsion bound here comes +from a fixed nonidentity Tate scalar acting trivially on every ring-class +field in the construction: its scalar minus one annihilates that torsion. +Lemma~\ref{rl:kernel} constructs this scalar, and the descent argument +of Lemma~\ref{lem:h:derivative-classes} uses the same bound. + +At an active odd conductor place inertia acts by minus identity. +All integral $H^1$ is Kummer, and the relaxed quotient contributes only +$H^2(K_v,T^e)$ in degree two. Its length is $t_v$, by local duality +and the fixed $2$-torsion. At the moving prime $r_i$ the contribution +is bounded by +Equation~\eqref{eq:h:r-avoidance}. The generic pairings specialize to +the ordinary Kummer pairing because the modified local complexes are +rationally acyclic at the center. Thus the free determinant tensor has +valuation twice the point index, whereas torsion in degree two +contributes negative length to the inverse determinant. Together with +Equation~\eqref{eq:h:trace-center}, this proves +Equation~\eqref{eq:h:central-determinant}. The specialization is at +constant rational cohomology rank, so no specialization torsion is +being substituted for the point. + +For Equation~\eqref{eq:h:weil-restriction-length}, apply the isogeny +invariance of the BSD quotient to quadratic Weil restriction and +$E^{(e)}\times E^{(ek)}$ +\citep[Theorem~2.1 and the preceding discussion]{Tate1966}. +All the groups in this +comparison are finite apart from the known rank-one lattices; no BSD +equality is assumed. The forward and reverse isogenies have composites +multiplication by $2$. Consequently the rank-one lattice indices, +height ratios, torsion ratios and period ratios contribute bounded +$2$-powers. For periods, the pullback indices of N\'eron differentials +at $2$ are bounded by those composites; real kernels and component +ratios are bounded as well. + +The remaining terms are the Tamagawa numbers. A ramified quadratic +twist of good reduction at an odd prime $q$ has type $I_0^*$ and +component number one plus the number of roots of its reduced auxiliary +cubic \citep[Theorem~4.1, Table~4 and proof, Case~3]{BarriosEtAl2025}. +To identify this number, write a good integral model as $y^2=f(x)$, +retaining the quadratic term, and the twisting parameter as $d=\pi u$. +The auxiliary cubic is $\bar u^3\bar f(T/\bar u)$; it is separable +and its roots correspond to the nonzero rational two-torsion points. +Thus the component number is $\#E[2]^{\mathrm{Fr}_q}$ and its +$2$-valuation is $t_q$. This argument also applies in residue +characteristic $3$. Its connected reduction is unipotent. Some inertia element acts +by $-1$ on the twisted $2$-adic representation, so its local +$2$-primary torsion is precisely its Frobenius-fixed $2$-torsion. +Over an unramified extension the same formula holds with the +Frobenius of the enlarged residue field. At unramified +or split places, Weil-restriction component numbers are the products +over $v\mid q$. At a prime $q\mid k$ outside $2N$, the curve over +$K$ has good reduction and its Weil restriction has connected special +fiber. Indeed, Weil restriction of its N\'eron model is the N\'eron +model of the restriction of the curve +\citep[Section~7.6, Proposition~6]{BoschLutkebohmertRaynaud1990}. +Its special fiber has the original connected elliptic fiber as quotient, +with connected vector-group layers from ramification. Exactly one rational twist +has the ramified component factor. At a conductor prime $q\mid c$, +the two rational twists give a combined valuation $2t_q$, and the +corresponding contribution over $K$ is $\sum_{v\mid q}t_v$. All +places above $2N$ have bounded local contributions. These are precisely +the terms of Equation~\eqref{eq:h:weil-restriction-length}. +\end{proof} + + +In a simple-zero genus instance, the fixed partner absorbs the terms involving $h_*$, +while $c=1$ and $k=hh_*$. The displayed formulas therefore identify +\[ + v(u(0))=2j(P_1(h_*))-2w(h)-s(h)+O_{E,h_*}(1). +\] +In a simple-zero ring instance with $\omega(k)\le a$, the discriminant term +is bounded and the conductor term is $4w(h)$, giving +\[ + v(u(0))=2j(P_{|h|}(h))-4w(h)-s(h)-s(hk)+O_{E,a}(1). +\] +The ring identity also applies to the interpolation families in which +an added nonsplit prime has $t_q=0$; such a prime contributes no weight. +The all-split hypothesis is needed for the uniform ring lower bound. +These formulas explain both the lower-bound statements and the +normalization in Heegner interpolation. To prove the lower bounds, +we must show that $u$ has no negative divisor away from $(2)$ and +has a uniformly bounded negative divisor at $(2)$ in the stated +cases. We will construct integral local switches that preserve its determinant +valuation, and use inner detection to choose switches lowering excess +Selmer rank. +The uniform ring estimate will require an additional characteristic-zero +limit; the universal binary family will instead require a bounded +clearing factor after the new local blocks have been removed. + +The main intermediate estimate is +\begin{equation}\label{eq:h:divisor-bounds} + \begin{aligned} + v_{\mathfrak p}(u)&\ge0 + &&\bigl(\operatorname{ht}\mathfrak p=1, + \ \mathfrak p\ne(2)\bigr),\\ + v_{(2)}(u)&\ge-O_{E,h_*}(1) + &&\text{in genus data with irreducible }E[2],\\ + v_{(2)}(u)&\ge-O_{E,a}(1) + &&\text{in ring data with }\omega(k)\le a + \text{ and all active primes split.} + \end{aligned} +\end{equation} +To construct the switches used in these estimates, we first retain +enough Galois evaluation data to select their derivative primes. + +\subsection{Evaluation and the exact kernel} + +The determinant estimates require switches that detect the excess +Selmer dimension at a height-one test. To choose +switching primes, we must still detect a nonzero limiting Selmer class +by Galois evaluation. The next two lemmas first retain that detection +under coefficient specialization, then restrict it to sequences acting +trivially on the full Tate module, all ring-class fields, and the +quadratic characters in use. + +\begin{lemma}[Evaluation on arbitrary Galois sequences]\label{rl:evaluation} +\label{lem:h:evaluation} +Fix $K$ and a sequence of the finite cochain constructions above. Keep +the contraction maps into the original global cochains. Let +$\Gamma_K=\prod_i G_K$ and +$\Gamma=\Gamma_K\rtimes\langle\tau\rangle\subset\prod_iG_{\mathbf Q}$, +with simultaneous complex conjugation $\tau$. Thus $\Gamma_K$ has +index two in $\Gamma$; the larger unrestricted product of rational +Galois groups is not used for induction. The matrix limit defines a +coefficient action of $\Gamma_K$ on $\Lambda^2$. For every field $L$ +receiving a map from $\Lambda$, there is a natural injection +\[ + H^1(C\otimes_\Lambda L)\longrightarrow + H^1_{\rm abs}(\Gamma_K,L^2), +\] +where the right side denotes abstract crossed-homomorphism classes. +Here $C$ may be the global complex or a Selmer complex whose local +conditions contain all local degree-zero invariants and inject into +local $H^1$. The same statement holds for the induced representation +of $\Gamma$. + +The evaluation maps and their degree-two cochain identities exist +for every group sequence and commute with coefficient extension. +\end{lemma} + +\begin{proof} +Let $C_i$ be a finite model and let $\iota_i$ be its chosen map to the +original global cochains, using the projection from the Selmer cone +when appropriate. For every $g=(g_i)$ and $h=(h_i)$ define matrices +\[ + e^0_i:C_i^0\to A_i^2,\quad + e^1_{g,i}:C_i^1\to A_i^2,\quad + e^2_{g,h,i}:C_i^2\to A_i^2 +\] +by evaluating $\iota_i$ in degrees zero, one, and two. Their source +ranks are fixed and their entries belong to $A_i$. Thus each has a +coefficientwise ultrafilter limit, for every choice of $g,h$. +The same fixed ultrafilter defines these limits for all $g,h$. Likewise +$\rho(g)=\lim_i\rho_i(g_i)$ is a representation. The original +cochain identities imply +\begin{align} + e^1_g d&=(\rho(g)-1)e^0,\label{rl:eval-boundary}\\ + e^2_{g,h}d&=\rho(g)e^1_h-e^1_{gh}+e^1_g. + \label{rl:eval-cocycle} +\end{align} +All identities pass to the limit because their matrix expressions +have finitely many terms. A cycle $x\in C^1\otimes L$ consequently +gives the crossed homomorphism $g\mapsto e^1_g(x)$, and a boundary +gives a coboundary. + +We prove injectivity in a way that also controls base change. At each +finite stage let $k=\mathbf F_2$ be the residual field. Choose a +space of representatives for residual $H^1$. Evaluate pairs $(c,m)$, +where $c$ is in this space and $m\in k^2$, by +$b_c(g)-(\rho(g)-1)m$. The intersection of the kernels of all +these evaluations consists precisely of pairs $(0,m)$ with $m$ an +invariant. Since the vector space is finite dimensional, a list of +at most $\dim H^1+2$ elements already has this intersection. For +these elements evaluation is a chain map +\[ + C_i\longrightarrow D_i= + [\,A_i^2\xrightarrow{((\rho_i(g_j)-1))_j}(A_i^2)^d\,] +\] +in degrees zero and one, inducing an isomorphism on residual $H^0$ +and an injection on residual $H^1$. For Selmer complexes this uses +the exact sequence of~\eqref{rl:selmer-definition}: the indicated +local degree-zero isomorphisms give $H^0(C_i)=H^0_{\rm glob}$ and +$H^1(C_i)\hookrightarrow H^1_{\rm glob}$ residually. + +Retain these matrices and their chosen group-element sequences. +The residual global and local complexes, and the local conditions, +have no negative cohomology. The cone definition therefore gives +$H^n(C\otimes k)=0$ for $n<0$. Put $Q=\operatorname{Cone}(C\to D)$. +The long exact sequence gives $H^n(Q\otimes k)=0$ for $n<-1$; +its groups in degrees $-1$ and $0$ vanish because the detecting map is +an isomorphism on $H^0$ and injective on $H^1$. Any $H^3(C\otimes k)$ +contributes in degree two of this cone, so causes no negative-degree +obstruction. Successively cancel the unit differential blocks of +$Q$. This gives a homotopy-equivalent bounded free complex starting +in degree one. For any $\Lambda$-algebra $L$, its ordinary tensor +product computes $Q\otimes^{\mathbf L}_\Lambda L$ and still starts +in degree one; no flatness is needed. Thus the long exact sequence +makes $H^1(C\otimes L)\to H^1(D\otimes L)$ injective. A crossed cocycle that is a coboundary +on all of $\Gamma_K$ is in particular a coboundary on the detecting +list, proving the desired injection. For induction the same proof +has coefficient rank four and the detecting bound is $\dim H^1+4$. +\end{proof} + +\begin{lemma}[The exact common kernel]\label{rl:kernel} +In the notation of Lemma~\ref{rl:evaluation}, let $H$ be the group of +sequences each of whose entries acts trivially on the full Tate module, +on all ring-class fields of $K$, and on the quadratic characters in +use. Restriction from the crossed classes in that Lemma to $H$ is +injective at every characteristic-zero test. It is also injective +at the residual $(2)$ test. The characteristic-zero annihilator +needed for this assertion can be chosen with a fixed finite +$2$-valuation depending only on $E$, also as $K$ varies. +\end{lemma} + +\begin{proof} +The Tate image contains an open subgroup of scalar homotheties, both +in the CM and non-CM cases. Choose once and for all +$g\in G_{\mathbf Q}$ with Tate action $u\,1$, where +$u\in1+4\mathbf Z_2$ and $u\ne1$. Its square belongs to every +quadratic subgroup. Put +\[ + z=g^2\tau g^2\tau^{-1}. +\] +The generalized dihedral property of every ring-class extension +implies that $z$ is ring-class trivial. It is also trivial on every +quadratic character, and its Tate action is the fixed scalar $u^4$. +For every sequence in $\Gamma_K$, its commutator with the constant +sequence $z$ is in the exact group $H$, since its Tate commutator and +all its abelian character images are trivial. Thus $z$ is central in +$\Gamma_K/H$ and acts on the coefficients by $u^4$. + +Here the elementary central-scalar argument suffices. If a crossed +cocycle $b$ is defined on a group with such a central element, comparison +of $b(zg)$ and $b(gz)$ gives +\[ + (u^4-1)b(g)=(g-1)b(z). +\] +In characteristic zero this makes $b$ a coboundary. Inflation--restriction +then gives injectivity on $H$. The valuation of $u^4-1$ is fixed. + +In characteristic two choose, at each stage, inertia at $r_i$ mapping +onto the chosen generator of $\xi_i$. Its Tate action is trivial and +its ring-class images commute, so the resulting sequence is central +in $\Gamma_K/H$ and acts on $M$ by $1+t$. Its scalar minus one is +invertible in $\mathbf F_2((t))$. + +For the induced representation $W$, first restrict to $\Gamma_K$. +There $W=M\oplus M^\tau$, and this inertia sequence acts on the +summands by $1+t$ and $(1+t)^{-1}$. Hence $W^{\Gamma_K}=0$. +Inflation--restriction for the index-two inclusion gives an injection +$H^1(\Gamma,W)\to H^1(\Gamma_K,W)$, even in characteristic two. +Apply the central-scalar calculation separately to the two summands +to obtain injection on restriction to $H$. The same argument works +in characteristic zero with the fixed scalar $u^4$. +Throughout, $H$ is defined by exact actions at every stage. +\end{proof} + +\begin{lemma}[Irreducibility on the characteristic-zero tests] +\label{rl:irreducibility} +On an inner characteristic-zero test where $\Psi^2\ne1$, +the four-dimensional representation induced from $T\chi\Psi$ is +absolutely irreducible. If $\Psi^2=1$ on an inner test, it splits +as two inequivalent absolutely irreducible quadratic twists. +\end{lemma} + +\begin{proof} +The two induced summands are distinguished by $r$-inertia, whose +scalars are $\Psi$ and $\Psi^{-1}$. On either summand, multiplying +the Tate matrices by scalars does not alter invariant subspaces. +The Tate representation restricted to $G_K$ is absolutely +irreducible under the exclusions already specified. These facts +give absolute irreducibility of the induction when the two inertia +characters differ. + +If $\Psi^2=1$, extension across conjugation gives the two quadratic +twists. They are inequivalent, since a quadratic self-twist of the +Tate representation here would make its restriction to $G_K$ +reducible over an algebraic closure. In the CM case this would +force $K$ to be the CM field, which was excluded. +\end{proof} + +\begin{lemma}[Simultaneous finite Chebotarev realization] +\label{rl:chebotarev-evaluation} +For any element $u$ of an exact kernel in Lemma~\ref{rl:kernel}, +derivative primes can be chosen, at increasing finite precision, +whose rational Frobenius is $\tau u$ on all retained data. Their +finite localization is evaluation on $(\tau u)^2$. The assertion +is compatible with any fixed finite list of previous derivative +operations. +\end{lemma} + +\begin{proof} +At one Artin stage, a coordinate of a cochain in the image of a +finite model is a locally constant function. The finitely many +coordinates being used factor through one finite quotient of the +absolute Galois group. Enlarge it to contain the Tate action at +the required precision, the finitely many ring-class fields and +quadratic characters currently in use, and all old finite data. +Chebotarev realizes the conjugacy class of $\tau u$ on this finite +quotient, with a chosen place realizing the desired representative +\citep[Chapter~V, Theorem~3.23]{MilneCFT2020}. +It gives a rational prime inert in $K$, outside the old finite set. +Because $u$ is exactly Tate-trivial, its Frobenius tends to +$\rho_T(\tau)$; in particular $a_\ell\to0$ and $\ell\to-1$. +Because $u$ is exactly ring-class trivial, the square Frobenius on +the $K$-prime is the identity on every retained ring-class field. +The unramified local coordinate is therefore the stated +Frobenius-square evaluation. + +Repeat at each finite stage with increasing precision. All +conditions remain finite, and no density bound or prime-size +bound is required. +Previously imposed finite diagrams are unchanged. +\end{proof} + +In induced-module notation, restriction to the exact kernel is additive. +For a crossed cocycle $b$ and an exact-kernel element $u$, +\[ + b((\tau u)^2)=(1+\tau)b(u). +\] +Indeed $\tau^2=1$, $u$ acts trivially on the coefficients, and the +cocycle identity cancels the two occurrences of $b(\tau)$. Projection +to either induced summand identifies $\operatorname{im}(1+\tau)$ +with a two-dimensional coefficient module, also in characteristic two. + +\subsection{The local switch and its integral determinant} +\label{rd:local-subsection} + +Fix a complex conjugation $\tau$ and write $C_\tau$ for its action on $T$. +The next two Lemmas construct the integral local switches and the classes +that pass through them. Their finite-level formulas are needed before +applying the limit constructions above. + +\begin{lemma}[The split local model]\label{rd:local-model}\label{lem:h:switching-pairing} +Let a sequence of inert good primes \(\ell\) have rational Frobenius +lifts tending on \(T\) to a fixed complex conjugation \(C_\tau\). +At the unique prime of \(K\) above \(\ell\), the limiting local complex +has +\begin{equation} + H^0=M,\qquad H^1=F\oplus S=M\oplus M,\qquad H^2=M, + \label{rd:local-cohomology} +\end{equation} +with zero differentials in a free split model. Here \(M=T\otimes\Lambda\) +with the relevant scalar coefficient structure. The two degree-one +coordinates of a cocycle are +\begin{equation} + f(c)=c(\gamma^2),\qquad s(c)=c(\sigma), + \label{eq:h:local-coordinates} +\end{equation} +where \(\sigma\) is an oriented pro-\(2\) tame generator. The plane +conditions \(F=\{s=0\}\) and \(S=\{f=0\}\) include \(H^0\) and exclude +\(H^2\). Each is its own orthogonal complement for conjugate-Weil +duality. The strict condition \(H^0\) and the relaxed condition +\(H^0\oplus H^1[-1]\) are mutually dual. All four inclusions can be +equipped with compatible integral duality triangles. +\end{lemma} + +\begin{proof} +The prime-to-\(\ell\) local cochains are computed by the tame inertia and +residue-field directions. In these two directions the differentials +are formed from inertia minus one and Frobenius minus one, with the +usual Frobenius action on tame inertia. On \(M\), inertia is trivial at +the derivative prime. The square of a rational Frobenius is trivial +on every ring-class character. In the limit it is also the identity on +\(T\), while \(\ell^2\) tends to one. Thus both differentials become zero, +giving \eqref{rd:local-cohomology}. + +Here is a finite-precision check of the pairing, needed at \(2\). +At a retained quotient killed by \(2^a\), impose also +\(q=\ell^2\equiv1\pmod{2^{a+1}}\), as well as trivial +Frobenius-square action on the coefficient module at this quotient. +The tame two-generator complex then has zero differentials, +with the coordinates in \eqref{eq:h:local-coordinates}. Its degree-one +scalar generators are the unramified and tame characters. +More explicitly, use the presentation +\(\phi\sigma\phi^{-1}\sigma^{-q}=1\). +After augmentation with trivial coefficient action its Fox +resolution has terms of ranks \(1,2,1\), with +\(d^0=0\) and \(d^1=(0,1-q)\), in the ordered finite and +tame coordinates. The diagonal from the same resolution +has zero pure-finite term, unit mixed terms, and pure-tame +coefficient \(\pm\binom q2\). The latter coefficient is +the augmented second derivative of \(\sigma^{-q}\) +together with its adjacent \(\sigma\) in the relation. +Both \(1-q\) and \(\binom q2\) vanish modulo \(2^a\) +under the imposed congruence. Thus this is an actual +split complex and an actual pure-plane zero pairing +at the retained precision. +The field contains the \(2^{a+1}\)-st roots of unity, so +\(-1\) is a \(2^a\)-th power. The norm-residue identity +\((x,x)=(x,-1)\) for the \(2^a\)-Hilbert symbol therefore +makes the square of each scalar generator zero. +The two generators form a basis; local Tate duality makes +their cross pairing a unit. The same calculation applies +coefficientwise to the free Artin coefficient module, including +its nilpotent \(t\) and quadratic variables. Thus the pure +plane restrictions are already zero at every retained quotient. +All these congruences can be imposed simultaneously with the +derivative Frobenius conditions by increasing their precision. +Taking the compatible limit proves integral vanishing of the +pure squares. It is not deduced from skew symmetry in +characteristic two. + +Equivalently, in the limiting tame presentation +\(\phi\sigma\phi^{-1}=\sigma^q\) with \(q\to1\), the +rank-\((1,2,1)\) resolution specializes to the exterior +resolution for two procyclic directions. The finite +Hilbert-symbol calculation specifies the cup product on +its split cohomology and rules out a hidden square term. +Conjugation transports the finite Tate coordinate by \(C_\tau\) and the +singular coordinate by \(-C_\tau\), with possible scalar units coming from +the orientations. Consequently the cross pairing is +\begin{equation} + \beta(x,y)=\epsilon\,\langle x,C_\tau y\rangle,\qquad + \epsilon\in\Lambda^\times,\quad x\in F,\ y\in S, + \label{eq:h:cross-pairing} +\end{equation} +where \(\langle\, ,\,\rangle\) is the perfect alternating Weil form. +This proves the assertions about orthogonal complements. Since the +restrictions of this explicit pairing to either pure plane are zero as +maps of the split complexes, their isotropy homotopies may be chosen to +be zero. Only a product of two degree-one terms could map to the +degree-two local invariant target; the degree-zero terms introduce +no additional restriction. These zero homotopies agree on the +strict subcomplex. These are the actual +orthogonality data required in the Selmer duality construction +\cite[Theorem~6.3.4]{Nekovar2006}; the compatibility assertion is therefore +an assertion about these displayed complexes and maps. Lemma~\ref{rl:finite-limits} is used to retain this finite diagram together +with the unchanged local data. +\end{proof} + +For a finite set $I$ of derivative primes, let $C_I$ be obtained +from $C$ by replacing the finite plane condition $F$ by $S$ at each +prime of $I$, retaining all other local conditions. The classes below +use the same multiplier $L$ already included in $P$; in particular, +$P_{\varnothing}=P$. + +\begin{lemma}[Descent and the switch at \(2\)]\label{rd:derivative}\label{lem:h:derivative-classes} +Suppose that the finite ring-class transfers are performed before +retaining their target cycles and witnesses as in +Lemma~\ref{rl:finite-limits}. There is one +integer \(L\ne0\), depending on the fixed curve, parametrization and +fixed local types, such that the classes obtained from the Heegner +derivatives of \(L\) times the point satisfy, for every finite switched +set \(I\), +\begin{equation} + P_I\in H^1(C_I),\qquad + f(P_{I\cup\{\ell\}})=0,\qquad + s(P_{I\cup\{\ell\}})=C_\tau f(P_I). + \label{eq:h:finite-singular} +\end{equation} +The same \(L\) works for every number of active and derivative primes. +The previously imposed singular conditions are retained. +\end{lemma} + +\begin{proof} +We first descend the derivative classes using one multiplier for the +complete conductor, and verify their Kummer conditions at $2N$. We then +compute both local coordinates in Equation~\eqref{eq:h:finite-singular}. +The last step retains these classes and identities in the same bounded +target cochain diagrams used for evaluation. + +Choose the orientations coherently. The relative ring-class group at +an inert prime \(\ell\) is cyclic of order \(\ell+1\). For distinct new +primes these groups form a product: the ring-class exact sequence has +kernel the product of the local residue-unit quotients, and the only +global units here are \(1,-1\), whose images in these quotients are +trivial. Set +\[ + D_\ell=\sum_{i=1}^{\ell} i\sigma_\ell^i,\qquad + D_I=\prod_{\ell\in I}D_\ell. +\] +Direct multiplication gives +\begin{equation} + (\sigma_\ell-1)D_\ell=(\ell+1)- + \sum_{i=0}^{\ell}\sigma_\ell^i. + \label{rd:derivative-identity} +\end{equation} +The Hecke correspondence and reduction of its CM isogenies give, for +every class-group translate, +\begin{equation} + \operatorname{Tr}(y_{c r n})=a_\ell y_{c r n/\ell}, + \qquad + \widetilde y_{c r n}=\operatorname{Fr}_\ell + \widetilde y_{c r n/\ell}. + \label{eq:h:heegner-norm-reduction} +\end{equation} +These are the point relations, not an application of a residual +irreducibility theorem. A fixed multiple of the parametrization removes +cuspidal terms. + +There is a uniform bound on the \(2\)-primary torsion over the union of +the ring-class fields in use. To see this, choose a fixed nonidentity +scalar homothety of infinite order in the \(2\)-adic Tate image. +Square a lift so that it +belongs to every quadratic subgroup under consideration. Multiply it +by its conjugate under complex conjugation. Its action on each +ring-class field is trivial, because conjugation inverts the abelian +ring-class action, while its action on \(T\) is still a fixed +nonidentity scalar. If \(2^e\) annihilates its scalar minus one up to +a unit, then \(2^e\) kills the torsion in question. The existence of +this fixed scalar, including the CM case, is the Tate-image input +used in Lemma~\ref{rl:kernel}. + +Work first with coefficients modulo \(2^a\). Require \(a_\ell\) and +\(\ell+1\) to vanish to a precision substantially larger than \(a\). +Equations \eqref{rd:derivative-identity} and +\eqref{eq:h:heegner-norm-reduction} then make the derivative Kummer class +invariant under the relative ring-class group. In the +inflation--restriction sequence, both the obstruction to descent and +the ambiguity of descent are killed by \(2^e\), since their +coefficient module is killed by \(2^e\). Multiplication by \(2^{2e}\) +therefore gives a descent independent of this ambiguity: descend +\(2^e\) times the class and multiply its lift by \(2^e\). +There is no repetition of this factor for individual primes; descent +is performed once from the field with the complete conductor. + +The global descent has cost only the fixed factor $2^{2e}$, regardless +of the number of derivative primes. It remains to ensure that the +descended class satisfies the Kummer condition at every fixed bad place; +this is a separate local descent issue. + +At a place over \(2N\) these descent extensions are unramified. +Here is the local descent argument, valid also for even extension degree +and for toric or additive reduction. Let $F'/F$ be a finite unramified +extension with group $G$, and write $k'/k$ for its residue extension. +The successive formal-group quotients $E_j(F')/E_{j+1}(F')$ are additive +copies of $k'$. The normal basis theorem makes each a cohomologically +trivial $G$-module, without a restriction on $|G|$. Every finite +quotient $E_1(F')/E_j(F')$ is therefore cohomologically trivial. +The inverse systems of these finite groups and their invariant groups +satisfy the Mittag--Leffler condition. Taking inverse limits in finite +$G$-cochains consequently gives $H^1(G,E_1(F'))=0$. +Let $\mathcal E/\mathcal O_F$ be the N\'eron model and put +$\widetilde E^0=\mathcal E_k^0$, a smooth geometrically connected +commutative algebraic group over the finite field $k$. +Lang's finite-extension cocycle theorem +\citep[Proposition~3, p.~559]{Lang1956} gives +$H^1(G,\widetilde E^0(k'))=0$. +The smooth reduction sequence then gives $H^1(G,E^0(F'))=0$. +Let $\Phi=\mathcal E_k/\widetilde E^0$ be the finite \'etale +component-group scheme. Each fiber over a point of $\Phi(k')$ +is a torsor under $\widetilde E^0_{k'}$, and hence has a $k'$-point +by \citet[Theorem~2, pp.~557--558]{Lang1956}. +Smooth lifting therefore makes $E(F')\to\Phi(k')$ surjective. Hence +\[ + H^1(G,E(F'))\lhook\joinrel\longrightarrow + H^1(G,\Phi(k')). +\] +Existence of the smooth finite-type model and smooth lifting follow from +\citet[Section~1.3, Corollary~2, and Section~2.3, Proposition~5]{BoschLutkebohmertRaynaud1990}. +The right side is killed by the exponent of $\Phi(\overline k)$. +By inflation--restriction, the left side is exactly the kernel of +$H^1(F,E)\to H^1(F',E)$. Thus the same fixed exponent makes a +class in $H^1(F,E[2^a])$ Kummer whenever its restriction is Kummer. +N\'eron models commute with unramified base extension +\citep[Section~7.2, Theorem~1 and Corollary~2]{BoschLutkebohmertRaynaud1990}, +so their geometric component groups are unchanged. Only the finitely many fixed local twisting +types at $2N$ occur, so the product of these component exponents is +bounded independently of the conductor and of the extension degree. +Include this product, the single descent factor $2^{2e}$, and the +parametrization factor in \(L\). Thus the descended class has the +integral Kummer condition at \(2N\). +No good-ordinary or semistability condition was used. Transfer with +the scalar character preserves this condition because \(\Psi=1\) +there. + +The single multiplier $L$ now gives descent with the required Kummer +conditions. We next prove the finite-to-singular identity itself. Both +coordinates matter: the singular coordinate must become $C_\tau f$, +while the new finite coordinate must vanish at the retained precision. + +Here is the local calculation, including the division by two. Apply +the derivatives at all primes other than \(\ell\), and write \(X,Y\) +for the resulting lower and upper points. Put \(F_\ell=\operatorname{Fr}_\ell\). +The lower field splits at the \(K\)-prime \((\ell)\), since that ideal +is principal. Reduction therefore gives \(F_\ell^2X=X\). +The following Frobenius-polynomial identities are taken on the reduction; +good odd-prime reduction is injective on the $2$-primary torsion +coordinates being compared. +If \(Q\) is a \(2^a\)-division point of \(LX\), the finite coordinate +of its Kummer class is +\begin{equation} + f=(F_\ell^2-1)Q= + \bigl(a_\ell F_\ell-(\ell+1)\bigr)Q. + \label{rd:finite-formula} +\end{equation} +We give the descent-cocycle calculation of the other coordinate. +Choose \(Z\) with \(2^aZ=LD_\ell Y\), and choose the descended +cocycle \(b\) so that on the upper-field Galois group it is +\(b(g)=(g-1)Z\). A change by the already bounded descent ambiguity +has no effect on the eventual limit. The crossed identity gives +\[ + U=(\sigma_\ell-1)Z-b(\sigma_\ell) + \in E(H_{crn}). + \] +For \(g\) in the upper-field Galois group, compare the two +expansions of \(b(g\sigma_\ell)\); they give \(gU=U\). +Moreover, +\[ + 2^aU=L\bigl((\ell+1)Y-a_\ell X\bigr). + \] +Both integers \(\ell+1,a_\ell\) are divisible by \(2^a\). +Consequently +\[ + U_0=L\frac{\ell+1}{2^a}Y- + L\frac{a_\ell}{2^a}X + \] +is an actual upper-field point with the same \(2^a\)-multiple +as \(U\). Thus \(U-U_0\) is upper-field torsion of bounded +exponent. This comparison with an actual integer quotient +is what bounds the ambiguity; arbitrary division points +would not give this bound. Reduction makes +\(\sigma_\ell\) act trivially and +\(\widetilde Y=F_\ell\widetilde X\). Therefore +reduction of \(b(\sigma_\ell)=-U\) gives its singular coordinate +\begin{equation} + s=\bigl(a_\ell-(\ell+1)F_\ell\bigr)Q + \label{rd:singular-formula} +\end{equation} +up to the uniformly bounded descent torsion already described. +The Frobenius polynomial yields the exact operator identity +\begin{equation} + (F_\ell-a_\ell) + \bigl(a_\ell F_\ell-(\ell+1)\bigr) + =a_\ell-(\ell+1)F_\ell. + \label{rd:exact-frobenius} +\end{equation} +Thus \(s=(F_\ell-a_\ell)f\); when \(a_\ell\) vanishes at the +retained torsion precision, this is \(s=F_\ell f\). Taking the +Frobenius limit gives \(s=C_\tau f\). + +If $\gamma$ is the chosen rational Frobenius lift, its image in the +generalized-dihedral ring-class Galois group lies outside the abelian +subgroup, so $\gamma^2$ acts trivially on the full upper ring-class field. +The same lift therefore computes the descended finite Kummer coordinate +from the reduced point over the common residue field $\mathbf F_{\ell^2}$. +For the new finite coordinate, reduction of the derivative point is +\begin{equation} + \sum_{i=1}^{\ell}iF_\ell X + =\frac{\ell(\ell+1)}2F_\ell X. + \label{rd:half-factor} +\end{equation} +The finite Kummer coordinate consequently vanishes modulo \(2^a\) +if \(v_2(\ell+1)\ge a+1\). The additional \(1\) is essential at +\(2\). It is imposed in the choice of the next precision, and does +not multiply the class by a new denominator. Bounded torsion +ambiguities disappear on passing from \(E[2^a]\) to \(E[2^m]\) with +\(a-m\ge e\). Choose \(a\) and the Frobenius precision successively +faster than \(m\). + +The calculation is compatible with every translate in the transfer: +transport the place and its Frobenius before applying that translate. +The scalar weight on the lower and upper class is identical. Applying +the same calculation at each \(\ell\in I\) proves the earlier +singular conditions as well. + +The local formulas now give the switch. To use it in the rank-reduction +argument, we must retain more than its cohomology class: the transferred +target cycles, local lifts and degree-two cochain identities must extend +the original finite diagrams. We record this compatibility next. + +Here the transfer itself is integral at the cochain level. +For a finite Artin coefficient ring \(A\), let +\(\Delta=\operatorname{Gal}(H_{cr}/K)\), through which the +finite scalar and quadratic characters factor. Shapiro's +cochain map and the coefficient homomorphism +\[ + A[\Delta]\longrightarrow A,\qquad + [\sigma]\longmapsto\chi_e(\sigma)\Psi(\sigma) + \] +send the descended class to the desired twisted class. +For a universal quadratic family, replace the quadratic +value by its group element in \(A[G]\), also including the +fixed base character. Choose inverse actions on both +sides when using that Shapiro convention. Explicitly, +these are the finite coset sums with the indicated scalar +weights; there is no division by \(\#\Delta\). +These maps and their degree-zero and degree-two compatibility formulas +are used at this finite stage, before passage to a bounded target model. +Naturality of restriction and Kummer corestriction +supplies the local lifts. At \(2N\) the scalar character +is trivial, so these are precisely the Kummer conditions +of the indicated quadratic twist. + +More explicitly, in the universal case let +$\nu:\Delta\to G$ be the additional quadratic character. +Perform the coefficient map +\[ + A_i[\Delta]\longrightarrow A_i[G],\qquad + [\sigma]\longmapsto + \chi_{h_0}(\sigma)\Psi_i(\sigma)[\nu(\sigma)] +\] +and the finite coset sum before any character evaluation. This gives +one cycle over $A_i[G]$, with its local lifts. Every sign evaluation +$A_i[G]\to A_i$ sends this cycle and these lifts to the corresponding +weighted construction, because it commutes with finite sums and +differentials. After contraction, compare an evaluated target model +with its already chosen scalar model using their maps to the same +original target cochains. Retain these comparison matrices and their +contraction homotopies for all the finitely many characters of this +fixed $G$. No character idempotent or division by a class-group +order is used. At $t=0$ the split-prime norm multiplier on this universal +cycle is +\[ + a_{r_i}-2\chi_{h_0}(r_i)[\nu(\Fr_{\mathfrak r_i})]. +\] +The two conjugate Frobenius values of $\nu$ agree because each +quadratic character comes from $\Q$. Evaluation at the character +corresponding to $h$ therefore gives exactly +$a_{r_i}-2\chi_h(r_i)$, with the central boundary witness described +above. + +Finally contract only the resulting target cycles, local lifts and +boundary witnesses into the models over $K$. Retain the target +comparison maps, the split local Fox complexes, their zero isotropy +homotopies, and their duality and switch identities in degrees zero, +one and two. The proof of Lemma~\ref{rl:finite-limits} shows explicitly +how to transport these identities and their witnesses. In particular +the unbounded cochains over $H_{cr}$ and the full Shapiro maps are not +objects or maps of this limiting diagram. +When a further derivative prime is selected, extend the +same original finite-stage diagram and its contraction +maps, using the same inner ultrafilter. Do not construct +an unrelated cohomologically equivalent old complex. +The earlier evaluations, including all degree-two +cocycle identities, are consequently retained by the +same contraction maps after each new switch. For a fixed finite set of +switches and fixed $G$, the target rank bounds above apply. +Lemma~\ref{rl:finite-limits} therefore applies to these extended +target diagrams at their common retained precision. +Their limiting classes give +\eqref{eq:h:finite-singular}. The displayed local formulas agree with the +calculation underlying \cite[Proposition~1.7.4]{Howard2012}; Howard's +odd-prime global hypotheses are not being asserted at \(2\). +\end{proof} + +\begin{lemma}[Preservation of the determinant coordinate] +\label{lem:h:determinant-switch} +Let $\mathcal O$ be a height-one discrete valuation ring at which the +complexes and switching conditions are self-dual. Suppose the generic +Selmer group for a set $I$ has rank one and is spanned by $P_I$, and +$v_0=f(P_I)$ is nonzero at the next derivative prime. Then the switched +generic group has rank one and is spanned by $P_{I\cup\{l\}}$, and +\begin{equation}\label{eq:h:switch-equality} + v_{\mathcal O}(u_I)=v_{\mathcal O}(u_{I\cup\{l\}}). +\end{equation} +This assertion does not require a primitive localization in either +integral plane. +\end{lemma} + +\begin{proof} +Compare the strict condition and the relaxed condition of +Lemma~\ref{lem:h:switching-pairing}. Their complexes are dual. Over the +fraction field, the image of relaxed $H^1$ in $F\oplus S$ is +self-annihilating by Poitou--Tate, hence two-dimensional. Strict $H^1$ is +zero because the original rank-one group localizes nontrivially. The +relaxed image meets $F$ in the line spanned by $v_0$ and, by +Equation~\eqref{eq:h:finite-singular}, meets $S$ in the nonzero line +spanned by $C_\tau v_0$. Its intersection with either plane is therefore +exactly a line. This proves the rank and spanning assertions. + +For the integral determinant comparison let $A=P_I$ and +$B=P_{I\cup\{l\}}$ be a field basis of relaxed $H^1$. The dual basis +$A^\vee,B^\vee$ belongs to strict $H^2$. In the triangle adding $F[-1]$ +to the strict complex, the map $F\to H^2_{\mathrm{str}}$ pairs a vector +$x$ against the relaxed localization. By +Equations~\eqref{eq:h:cross-pairing} and +\eqref{eq:h:finite-singular}, it is a unit times +$\langle x,v_0\rangle B^\vee$. The remaining $H^2$ quotient maps to +$A^\vee$. Choose $x$ mapping to $B^\vee$. Although $v_0$ and $x$ need +not be integral separately, the volume of the ordered basis $(v_0,x)$ +of $F$ is a unit of $\mathcal O$, precisely because its symplectic +pairing is a unit. For $S$ use $C_\tau v_0$ and a preimage of +$A^\vee$; its volume is again a unit. The two determinant tensors thus +map, up to units, to the same tensor in the strict determinant, using +$A^\vee\wedge B^\vee$. All triangles and plane lattices in this +comparison are integral. Their determinant isomorphisms consequently +give Equation~\eqref{eq:h:switch-equality}, including any torsion or +localization-index contribution. +\end{proof} + +\subsection{Rank reduction and nonnegative divisors}\label{sec:h:rank-reduction} + +The derivative-prime reduction follows the Kolyvagin-system argument of +\citet[Lemmas~1.5.3 and~1.6.4]{Howard2012}. We carry its switches +through integral Selmer complexes and preserve their determinant +coordinate. The local calculation and descent above supply the +characteristic-two pairing and one fixed multiplier; the argument +below supplies the uniformity as the conductor varies. + +We now prove the first two bounds in Equation~\eqref{eq:h:divisor-bounds}. +A height-one specialization can have larger Selmer dimension than the +generic rank-one line. Local switches will remove that excess dimension +while preserving the determinant valuation. At test dimension one, +integrality is immediate. At the coefficient prime $(2)$ this argument +uses residual irreducibility and therefore applies here to genus data. + +Use the sequence groups $\Gamma_K\subset\Gamma$ of +Lemma~\ref{rl:evaluation}, and write $\mathcal H$ for the exact +kernel of Lemma~\ref{rl:kernel}. Over the relevant test field, put +$W=\operatorname{Ind}_{\Gamma_K}^{\Gamma}(T\chi_e\Psi)$. +Lemma~\ref{rl:chebotarev-evaluation} realizes finite localization as +the projection of $(1+\tau)b(u')$, for $u'\in\mathcal H$, to one +induced summand. Restriction to $\mathcal H$ is injective by +Lemma~\ref{rl:kernel}, and evaluation there is additive and +Galois-equivariant. The image of $1+\tau$ is a copy of the +two-dimensional summand, also in characteristic two. + +\begin{lemma}[Rank reduction at a height-one prime] +\label{lem:h:height-one-reduction} +Suppose a primitive instance has generic cohomology of rank at most one +in degrees one and two, zero elsewhere, and $P$ spans $H^1$ when it is +nonzero. Then the first line of Equation~\eqref{eq:h:divisor-bounds} +holds. These hypotheses hold in every simple-zero instance and also at +the base of Theorem~\ref{thm:heegner-interpolation}. The second line holds in +genus data with irreducible $E[2]$, with a bound independent of the +number of active or derivative primes. +\end{lemma} + +\begin{proof} +There is nothing to prove if $u=0$. Otherwise the generic rank is one +and $P$ is nonzero. Localize, and if convenient complete, at a +height-one prime. Test its +residue field; at $(2)$ do this argument only in genus data with +irreducible residual representation. Suppose first that $\Psi^2\ne1$ +on the field. Then $W$ is irreducible. Inertia at $r$ distinguishes its +two induced summands. On one summand, irreducibility of $T$ over $K$ +comes from open image or the CM normalizer in characteristic zero, and +from the assumed residual irreducibility at $(2)$. In the latter case +we have omitted the fields meeting $\Q(E[2])$ nontrivially. The cyclic +cubic residual case remains irreducible over $\F_2((t))$, with a +possibly quadratic commuting field. Constant Tate matrix images are +realized on the sequence group; scalar character twists do not change +this irreducibility. + +Let the test Selmer $H^1$ have dimension $s\ge2$. Include the reduction of +a primitive generator of the generic free $H^1$ lattice among two +independent classes. We can arrange that their localization has rank +two. To see this, if the classes are independent over the commuting +field of $W$, simplicity and the injective restriction in +Lemma~\ref{rl:kernel} imply that the field span of their joint +evaluations on $\mathcal H$ is the whole of $W\oplus W$. Otherwise +a nontrivial equivariant linear relation would vanish on restriction, +and hence on the original classes. Projection by $1+\tau$ therefore +spans all pairs in the two-dimensional localization space. Some actual +evaluation pair has nonzero determinant: a homogeneous quadratic +vanishing on an additive group vanishes on its field span, since its +polar form vanishes on every pair from the group. This argument is +valid in characteristic two as well. If the classes are dependent over +the commuting field but independent over the ground field, projection +commutes with that field action on the graph of $\tau$. At the residual +prime~$(2)$, in the cyclic cubic case, this commuting field is +$\F_4((t))$: rational complex +conjugation has trivial residual image, so the commuting-field action +is the same on the two induced summands. If the second class is $\alpha$ times the first, with +$\alpha$ outside $\F_2((t))$, a nonzero projected evaluation $v$ gives +the ground-field-independent pair $v,\alpha v$. Thus this case also +gives rank-two localization. + +Choose the derivative prime realizing that evaluation. Its localization +is nonzero on the primitive generic generator. The relaxed image on the +test fiber is self-annihilating of dimension two, and contains all of +$F$ because the finite localization has rank two. It is therefore $F$. +Switching to $S$ lowers test $H^1$ dimension by two. Generically, +Lemmas~\ref{lem:h:derivative-classes} and +\ref{lem:h:determinant-switch} keep rank one, a nonzero class, and the +same determinant valuation. + +It remains to treat $\Psi^2=1$, which occurs here only in +characteristic zero. Extend $\Psi$ across $\tau$ and split into the +two conjugation signs. Conjugation on the cochains includes +$1+t\mapsto(1+t)^{-1}$, which is trivial on this fiber. The fixed +Kummer conditions and relaxed conditions are preserved. At previously +switched places the split local model has diagonal conjugation action +on $f,s$, so its plane conditions are preserved too. The induced +representation now splits into two nonisomorphic absolutely irreducible +twists. Finite and singular localization each have one line per sign. +Within a sign the pairing is a symmetric hyperbolic pairing of those +two isotropic lines; the signs are orthogonal. + +If both Selmer signs occur, the restriction argument just used gives +rank-two localization by choosing one class of each sign, with a +nonzero component of the primitive generator among them. If only one +sign occurs and $s>1$, choose rank-one localization nonzero on that +generator. The relaxed image has a self-annihilating line in each +sign. In the sign hit this is the finite line; in the other it must +be the singular line, since a symmetric hyperbolic plane in +characteristic zero has exactly these two isotropic lines. The switch +preserves the total dimension but introduces the other sign: the old +strict kernel has dimension $s-1\ge1$ and the new singular line +contributes the second sign. A subsequent rank-two switch reduces +dimension. Iteration reaches test rank one; it cannot pass below one, +because the generic rank-one class has been retained throughout. + +At test rank one the minimal self-dual complex over the DVR has one +free term in each of degrees one and two and zero differential; there +are no invariants. An integral class and its integral dual functional +therefore give an integral determinant coordinate. Reversing the +switches gives the first assertion. At $(2)$ the initial fixed descent +and local multiples cost a bounded valuation, independent of every +subsequent switch. This proves the second assertion with the stated +uniformity. +\end{proof} + +\subsection{Uniformity without residual irreducibility} +\label{sec:h:uniform-ring-bound} + +Only the ring-data bound at $(2)$ remains. Residual irreducibility is +not assumed, so the preceding argument on that residue field does not +cover every instance. We first bound the model sizes and retain evaluation through a second +limit. These constructions turn a hypothetical +sequence of unbounded negative determinant valuations into a +characteristic-zero outer limit. There the retained evaluation maps +permit rank reduction and force a bounded denominator, giving a +contradiction. + +\begin{lemma}[Uniform residual sizes]\label{rl:residual-bound} +Suppose $\omega(\operatorname{disc}K)\leq A$, the local twisting classes +at $2N$ belong to a fixed finite list, and all active conductor primes +are split with odd Frobenius exponent of the deformation character. After localization and completion at +$(2)$, the minimal free ranks of the Selmer complexes are bounded in +terms of $E,A$, and the number of retained derivative primes. They do +not depend on the number of active conductor primes. +\end{lemma} + +\begin{proof} +Reduce first over $\mathbf F_2[[t]]$. The quadratic character is now +trivial. Removing the active conductor primes from the permitted +ramification set changes the global complex by their singular local +complexes. These, and their unramified local complexes, are acyclic +after inverting $t$, by Lemma~\ref{rl:local-acyclic}. The resulting +smaller-support complex, including its comparison maps, can be +constructed at the original Artin stages before taking the limit. +Its support consists of $2N,r$, and the retained derivative primes. +Its $\mathbf F_2((t))$ cohomology dimensions are bounded by those at +$t=0$: choose a minimal finite free model over $\mathbf F_2[[t]]$. + +Here is a uniform bound for the latter residual cohomology. Put +$F=\mathbf Q(E[2])$, a fixed field. Then $FK/F$ is at most quadratic. +Enlarge the allowed set of primes of $F$ by those ramified in $K$. +Its cardinality is bounded by a constant depending on $E,A$ and the +number of derivative primes. Kummer theory bounds the number of +generators of the maximal pro-$2$ Galois group over $F$ unramified +outside this set, using the fixed unit group, the fixed $2$-class group, +and the allowed valuations. The subgroup defining $FK$ has index at +most two; the elementary Schreier bound bounds its generator number. +Every finite Galois $2$-extension of $FK$ with this ramification has +Galois closure of $2$-power degree over $F$, so this subgroup indeed +controls the required pro-$2$ extensions of $FK$. + +Over $FK$ the residual Tate module is trivial. Restriction and +inflation--restriction therefore bound the residual $H^1$ over $K$. +The $H^0$ bound is immediate, and the global Euler characteristic or +global duality bounds $H^2$. The local terms at the remaining bounded +set have bounded dimensions, with degrees of the local fields at most +two over the fixed rational local fields. At $2N$ there are only +finitely many local quadratic twisting classes. The same bounds +apply to the Selmer cone. Lemma~\ref{rl:finite-model} now bounds the +minimal ranks. Determinant valuations will require a separate argument. +\end{proof} + +\subsubsection{Evaluation through the outer limit} + +The preceding evaluation argument concerns one inner construction over a +fixed $K$. The ring bound must also be uniform when $K$ and the conductor +vary. When all active primes split and $\omega(k)$ is bounded, +Lemma~\ref{rl:residual-bound} bounds the model sizes after any fixed +number of derivative operations. The next proposition shows that passing to a second +limit of such models preserves detection, including classes represented +only by approximate cycles before that limit. + +\begin{proposition}[Integral evaluation through the outer limit] +\label{rl:outer-evaluation} +Let $C_j$ be any family of the preceding limiting complexes, completed +over $\mathcal O_j=\widehat{\Lambda_{(2)}}$, possibly for different +quadratic fields $K_j$. Suppose their minimal ranks are bounded. +Assume a common bounded cohomological degree interval. Keep the +actual evaluation matrices and transport them to the minimal models +through integral contractions. For a nonprincipal +ultrafilter $\mathcal U$, put +\[ + \mathcal O_\infty= + \left(\prod_{\mathcal U}\mathcal O_j\right)/\mathfrak a, + \qquad + \mathfrak a=\{(x_j): + \{j:v_2(x_j)\geq n\}\in\mathcal U\text{ for every }n\}. +\] +Then $\mathcal O_\infty$ is a DVR with uniformizer $2$ and a +characteristic-zero fraction field $L_\infty$. The outer $H^1$ over +$L_\infty$ injects into crossed classes on the inner quadratic sequence +group product, or its extension by one simultaneous complex conjugation +for the induced representation. Its restriction to the product +of their exact common kernels is injective. All arbitrary-sequence +degree-two evaluation identities survive. These conclusions also +hold after retaining any fixed finite collection of additional +integral diagrams. +\end{proposition} + +\begin{proof} +A nonzero element of the quotient has a representative whose +valuations are bounded on an ultrafilter-large set. A finite +partition then makes its valuation equal to a single integer $n$ +on such a set. It is $2^n$ times a unit. Products add these finite +valuations, so the quotient is a domain, and every nonzero ideal has +an element of smallest valuation. It is consequently a DVR. The +integer $2^n$ is nonzero for every $n$, so its fraction field has +characteristic zero. + +For each $j$, all-sequence evaluation maps originally have entries +in $\Lambda$. Extension to $\mathcal O_j$ and composition with an +integral contraction still give integral matrices. Thus evaluation +on any sequence of inner group elements has an entrywise image in +$\mathcal O_\infty$. Equations~\eqref{rl:eval-boundary} and +\eqref{rl:eval-cocycle} survive for all such sequences. In particular, +if an outer cycle is represented by vectors $x_j$ for which +$d_jx_j$ has valuation tending to infinity, the evaluation of +$d_jx_j$ does too: the degree-two evaluation matrix is integral. +Thus an outer cycle gives an exact crossed cocycle even when its +representatives are only approximate inner cycles. + +Over the inner residue field $\Omega_j$, choose a detecting list as +in Lemma~\ref{rl:evaluation}; its length is at most +$\dim_{\Omega_j}H^1(C_j\otimes\Omega_j)+\operatorname{rank}M$. +These lengths are bounded. Include in the integral diagrams the +evaluation map to its two-term complex and a contraction of its cone +to a complex starting in degree one. Such a contraction uses only +unit pivots over $\mathcal O_j$ and has bounded graded sizes. +All its matrices, including inverses and homotopies, are integral +and pass to the quotient. Its cone still starts in degree one +after extension to $L_\infty$. This proves injectivity just as in +Lemma~\ref{rl:evaluation}. + +Let $H_j$ be the inner exact kernel. In the product of the quadratic +sequence groups, the central elements of Lemma~\ref{rl:kernel} give +a central element modulo $\prod_jH_j$ with scalar $u^4$. Since +$u^4-1$ remains nonzero in $\mathcal O_\infty$, the same calculation +gives restriction injectivity. For the induced representation first +restrict to the quadratic subgroup, as in Lemma~\ref{rl:kernel}. +Additional finite diagrams pass through the same entrywise operations. +\end{proof} + +\begin{lemma}[Irreducibility in the outer limit] +\label{rl:outer-irreducibility} +On the outer characteristic-zero test, $\Psi$ has infinite order and +the four-dimensional representation induced from $T\chi\Psi$ is +absolutely irreducible. +\end{lemma} + +\begin{proof} +The inner irreducibility argument requires a uniform finite +witness to survive this limit. The images of the quadratic subgroups have index at most +two in the fixed compact $2$-adic Tate image. A compact $2$-adic +analytic group is topologically finitely generated and hence has +only finitely many closed subgroups of index at most two. Choose +one on an ultrafilter-large set. Its absolutely irreducible +representation has finitely many matrices spanning +$M_2(\mathbf Q_2)$; the determinant expressing this spanning +property is a fixed nonzero $2$-adic number. Every one of these +Tate matrices is realized by choices of Galois elements in each +component. Their accompanying character scalars are units and +do not change the spanning assertion. Its determinant remains +nonzero in $L_\infty$. This proves absolute irreducibility in +that field. Also $1+t$ has infinite order already in every +$\Omega_j$: for a nonzero integer $n$, the first nonzero term of +$(1+t)^n-1$ occurs in finite degree. It remains a unit modulo +$2$ in every component, so no such power becomes one in the +outer field. + +The two induced summands therefore have different inertia scalars, +$\Psi$ and $\Psi^{-1}$, and the induction is absolutely irreducible +as in Lemma~\ref{rl:irreducibility}. +\end{proof} + +\begin{lemma}[Prime realization through the outer limit] +\label{rl:outer-chebotarev} +The finite Chebotarev realization of Lemma~\ref{rl:chebotarev-evaluation} +is compatible with Proposition~\ref{rl:outer-evaluation} and with any +fixed finite list of previous derivative operations. +\end{lemma} + +\begin{proof} +Apply Lemma~\ref{rl:chebotarev-evaluation} at each finite stage. +For an outer sequence do this separately +for each inner sequence, retaining the relevant finite evaluation +matrices and degree-two identities before taking the outer +quotient. Approximate inner cycles cause no problem, by the +integrality calculation in Proposition~\ref{rl:outer-evaluation}. +Previously imposed finite diagrams are unchanged. +\end{proof} + +\begin{theorem}[Compatibility of the limit constructions] +\label{rl:limit-evaluation-package} +The finite free models, ring-class characters, local conditions and +pairings constructed above can be retained simultaneously. Their +inner limits have the stated height-one acyclicity and all-sequence +cohomology detection. For all-split ring data with bounded +$\omega(\operatorname{disc}K)$, the residual model sizes are bounded +independently of the active conductor support. Their outer limits +retain arbitrary evaluations, exact-kernel injectivity and finite +Chebotarev realization after any fixed number of additional +integral arithmetic operations. +\end{theorem} + +\begin{proof} +Use Lemma~\ref{rl:finite-model} at each finite stage and keep the +same contractions and ultrafilter as in Lemma~\ref{rl:finite-limits}. +Perform the finite ring-class transfer and weighting first, retaining +only the resulting bounded target cycles and witnesses as in that +lemma; no limit of the growing Shapiro source is taken. +The local assertions and uniform residual sizes are +Lemmas~\ref{rl:kummer}, \ref{rl:local-acyclic} and +\ref{rl:residual-bound}; the required characters come from +Proposition~\ref{rl:characters}. Lemmas~\ref{rl:evaluation} and +\ref{rl:kernel} give inner detection. Proposition~\ref{rl:outer-evaluation} +and Lemma~\ref{rl:outer-chebotarev} preserve it through the +outer limit and later finite operations. Every retained identity is +an identity of actual integral matrices. The finite derivative classes and local identities of +Lemma~\ref{lem:h:derivative-classes} are among the integral arithmetic +target diagrams retained in these operations, including the central +norm relation before and after sign evaluation. +\end{proof} + +\begin{lemma}[Uniform determinant bound in ring data] +\label{lem:h:uniform-ring-determinant} +For simple-zero ring data with every active conductor prime split in +$K$ and $\omega(k)\le a$, the coordinate of +Definition~\ref{def:h:determinant-coordinate} satisfies +\[ + v_{(2)}(u)\ge -C_{E,a}, +\] +where $C_{E,a}$ is independent of $h$ and $K$. +There is no residual irreducibility assumption. This is the last +line of Equation~\eqref{eq:h:divisor-bounds}. +\end{lemma} + +\begin{proof} +Put $O=\widehat{\Lambda_{(2)}}$. By +Lemma~\ref{rl:residual-bound}, after any fixed number of derivative +switches the minimal $O$-models have bounded size in terms of $E$, $a$ +and that number, independently of $h$. The full local complexes at +$r$ and the active split primes are contractible over $O$, and the +switched planes are integrally self-dual. Thus the class and its paired +closed functional have a common bounded clearing exponent, supplied by +the fixed descent multiplier and the retained global duality map. + +Suppose the asserted lower bound fails. Choose instances with +$v_O(u)\to-\infty$. Cancel disks over $O$ and take an outer limit of +their bounded free models. Transport the class, closed functional, +evaluations and the retained comparison and switch maps through these +integral contractions, applying the same contractions to their boundary +witnesses. Only the resulting bounded target vectors and matrices enter +the outer diagram; the eliminated list of active-place complexes does +not. Concretely, take the ultraproduct of their +valuation rings and quotient by the ideal of sequences whose valuation +tends to infinity. The resulting ring $\mathcal O_\infty$ is a DVR +with uniformizer $2$: a nonzero sequence has a finite valuation on an +ultrafilter-large set and is that power of $2$ times a unit. Its +fraction field has characteristic zero. All integral matrix identities, +duality diagrams, and the local switch diagrams pass to this limit. + +Proposition~\ref{rl:outer-evaluation} gives injective evaluation +on the outer sequence group and on its exact common kernel. This +includes outer cycles represented by approximate inner cycles, since +their coboundaries are evaluated by integral degree-two matrices. +The fixed central scalar remains different from one in the outer +field. Lemma~\ref{rl:outer-irreducibility} gives absolute irreducibility +of the induced representation there: the scalar $1+t$ has infinite +order and distinguishes the two summands. + +Each individual minimal $O$-complex is a square complex in degrees +one and two, by self-duality and the absence of residual invariants. +Choose a primitive vector in its generic kernel. Such vectors survive +the outer limit, so outer $H^1$ has rank at least one. If its rank exceeds +one, choose rank-two localization by the absolutely irreducible +evaluation argument in Lemma~\ref{lem:h:height-one-reduction}, making +it nonzero on one of these primitive vectors. The inner Chebotarev construction realizes the corresponding +sequences of derivative primes. At each original Artin stage retain +the old contractions and evaluations, adjoin the new local and +derivative diagrams, and pass through the same inner and outer +ultrafilters. Slower cofinal coefficient precision is permitted; +independent reconstruction of the old diagrams is not. For an ultrafilter-large set of instances the localization is +generically nonzero. Lemma~\ref{lem:h:determinant-switch} preserves +the valuations tending to minus infinity, while the outer rank falls +by two. The new complexes and integral classes obey the same bounds, +with only the now fixed finite number of added derivative primes. + +The process must reach outer rank one: ranks are finite and cannot +fall below one while the primitive kernel vector is retained. At this +stage some maximal boundary minor is nonzero over the outer fraction +field. Its valuation is consequently bounded in the individual DVRs +on an ultrafilter-large set. Split that minor over their fraction +fields. The entries of the class and duality maps are integral and +their common initial multipliers are bounded. The formula for their +determinant coordinate, or the elementary-divisor decomposition, then +has a lower valuation bound depending on this minor and the bounded +complex size. The Heegner classes themselves need not survive the outer +limit: a numerator tending to zero only increases its valuation. It is +the primitive kernel vector that preserves rank, and the boundary minor +that bounds the denominators. This contradicts $v_O(u)\to-\infty$, and +proves the uniform estimate. +\end{proof} + +\begin{proof}[Proof of Theorems~\ref{thm:heegner-genus-bound} and +\ref{thm:heegner-ring-bound}] +By Lemmas~\ref{lem:h:height-one-reduction} and +\ref{lem:h:uniform-ring-determinant}, the element $u$ has nonnegative +valuation away from $(2)$ and a uniformly bounded negative valuation +at $(2)$. Normality of $\Lambda$ implies that a fixed power of $2$ +times $u$ belongs to $\Lambda$. Its central value therefore has the +same lower valuation bound. + +In genus data, $s(h_*)$ and the weight of $h_*$ are fixed, $c=1$, +and $k=hh_*$. Equations~\eqref{eq:h:central-determinant} and +\eqref{eq:h:weil-restriction-length} give +Equation~\eqref{eq:h:genus-bound}. The excluded intersection fields +are finite in number, since an irreducible two-division field has +at most one quadratic subfield. In ring data, the sum over $q\mid k$ +is bounded by $2\omega(k)$, whereas +$2\sum_{q\mid h}t_q=4w(h)$. The same equations give +Equation~\eqref{eq:h:ring-bound}. +\end{proof} + +\subsection{The universal Heegner class} +\label{sec:h:universal-class} + +For interpolation we combine the non-$(2)$ divisor estimate and the +central valuation formula with a universal binary family. The +characterwise coordinates must have a uniformly controlled clearing +factor. We first remove the +norm and local determinant factors belonging to primes unused at a +character, then eliminate the new-prime blocks before choosing that +clearing factor. + +Recall the binary coefficient rings: +\[ + G\simeq(\Z/2\Z)^b,\qquad R=\Lambda[G],\qquad + O=\widehat{\Lambda_{(2)}}. +\] +We work with the universal quadratic character over $R$ for the +family in Theorem~\ref{thm:heegner-interpolation}. At a new prime $q$ +let $g_q\in G$ be its inertia bit: at a character $x$, it evaluates +to $-1$ when $q$ is active and to $1$ when it is unused. Choose the +conductor character of Proposition~\ref{rl:characters} with odd +exponents at all the new split primes. In the universal complex relax +at every new prime and at the old active primes, and take the trace +class $p$ from the conductor containing all new primes, together with +$r$ and the old conductor. As in the proof of +Lemma~\ref{lem:h:derivative-classes}, form its $A_i[G]$-weighted +target cycle at each finite stage, together with its local lifts and +boundary witnesses, before evaluating any sign character. Apply the +limit construction for this fixed $G$ to those target data; the source +ring-class cochains do not enter the limiting diagram. Choose an integral determinant basis and +write $u_{\mathrm{rel}}$ for the characterwise determinant coordinate. + +\begin{lemma}[Removing the unused-prime factors] +\label{lem:h:unused-prime-correction} +There is $\eta\in O[G]$ such that +$u=\eta u_{\mathrm{rel}}$ agrees at each character with the primitive +determinant coordinate up to a $\Lambda$-unit. In particular, +$u_x\in\Lambda[1/2]$. If the base product derivative is zero, then +$u_0(0)=0$. At the nonzero vertices, +\begin{equation}\label{eq:h:normalized-vertex-bound} + v(u_x(0))\le B+O_{E,h_0,a}(1), +\end{equation} +where $a$ bounds $\omega(k)$. +\end{lemma} + +\begin{proof} +At an unused prime, the norm relation multiplies the primitive point +class by +\[ + e_q=\begin{cases} + a_q,&q\text{ inert in }K,\\ + a_q-z-z^{-1},&q\text{ split in }K, + \end{cases} +\] +where $z=\chi_{h_0}\Psi$ times the universal quadratic scalar at an +oriented Frobenius. The relaxed singular quotient contributes +\[ + l_q=\prod_{v\mid q} + \det\left(1-q_v^{-1}\eta_v(\Fr_v)\Fr_v\mid T\right), +\] +where $q_v$ is the residue cardinality and $\eta_v$ denotes the full +scalar character. Thus $u_{\mathrm{rel}}$ differs from the primitive +coordinate by $e_q^2/l_q$, up to a $\Lambda$-unit. This follows from +the localization triangle with its integral determinant isomorphism; +the pairing comparison is made over the fraction field. Choose +conjugate-compatible Frobenius lifts in these formulas, taking the +square of rational Frobenius at an inert place, and extend the +expressions universally over $O[G]$. + +Both $e_q$ and $l_q$ are units in $O[G]$. At a split prime, the odd +Frobenius exponent gives a nonconstant scalar in $\F_2((t))$; at an +inert new prime, the hypothesis $t_q=0$ gives an odd trace. Moreover, +already in the group ring, +$l_q\equiv e_q^2\pmod2$. In the split case the residual identity is +\[ + (1+a_qz+z^2)(1+a_qz^{-1}+z^{-2}) + =a_q^2+z^2+z^{-2}=(a_q+z+z^{-1})^2. +\] +In the inert case the Frobenius-square polynomial gives $a_q^2$. +Here the group-like quadratic scalars have square one, so the identities +hold before sign evaluation. Consequently +\begin{equation}\label{eq:h:group-ring-correction} + \eta=\prod_{q\ \mathrm{new}} + \left(1+\frac{l_q/e_q^2-1}{2}(1+g_q)\right) + \quad\text{belongs to }O[G]. +\end{equation} +Its factor is $l_q/e_q^2$ at unused characters and $1$ at active +characters. It makes the required correction without an idempotent +denominator for each prime. + +For all the primitive constituents, generic cohomology has rank at +most one. At nonzero vertices this follows from the simple-zero +assumption. At the base it follows from Selmer corank one; a nonzero +generic class then spans the possible rank-one group. Hence +Lemma~\ref{lem:h:height-one-reduction} applies to every nonzero +primitive determinant coordinate. Its nonnegative valuations away +from $(2)$ imply membership in $\Lambda[1/2]$, by normality. The +same assertion is automatic for a zero coordinate. + +If the base derivative vanishes, Equation~\eqref{eq:h:height} makes +the specialized point torsion. Either its generic determinant +coordinate is zero or the specialization is at constant rational +rank one and its degree-one class is zero there. In either case +$u_0(0)=0$. At a nonzero vertex use +Equations~\eqref{eq:h:central-determinant} and +\eqref{eq:h:weil-restriction-length}. Subtracting the two Sha lengths +and $4w(h_x)$ leaves precisely the expression bounded in +Equation~\eqref{eq:h:interpolation-hypothesis}, together with bounded +terms at $k$, the old support and $r$. This gives +Equation~\eqref{eq:h:normalized-vertex-bound}. +\end{proof} + +The corrected coordinates have the required upper bounds at nonzero +vertices and vanish at the center if the base derivative vanishes. +To apply binary transfer, we still need $f,d\in O[G]$ with $d_x=f_xu_x$ at every character. +The required controls are a bound on $v(f_0(0))$ and, at each fixed +precision, a bound on the negative Laurent support of every $f_x$. The next lemma obtains those bounds from the +old complex, whose size is bounded, rather than from the full growing +conductor. + +\begin{lemma}[A uniform clearing factor for the Heegner family] +\label{lem:h:family-clearing} +For the element $u$ of Lemma~\ref{lem:h:unused-prime-correction}, +there are $f,d\in O[G]$ with $d_x=f_xu_x$ at every character, +$f_0\in\Lambda$, and $v(f_0(0))$ uniformly bounded. For each fixed +$M$, the negative Laurent support of every $f_x\bmod2^M$ has a +bound independent of $b$ and of the number of new primes. +\end{lemma} + +\begin{proof} +First make the pairing functional integral up to a bounded multiplier. +The class $p$ is integral. Lift $2^{a_0}p$ to the complex strict at +the relaxed places and use integral duality against the relaxed +complex. At $r$ and every new prime the full local complex over +$O[G]$ is contractible: its reduction at the maximal ideal is acyclic, +by the local calculation in Lemma~\ref{lem:h:relaxed-local} and the +root-type alternative. At the old active primes its cohomology is +killed by a bounded power of $2$, because inertia is minus identity. +The old support is fixed. Thus $a_0$ is bounded independently of the +new primes. After inverting $2$, lifting is canonical. We obtain a +closed representative of the paired functional over +$2^{-a_0}O[G]$. + +At augmentation, present the complex as the old complex, with no new +primes, extended by the direct sum of their singular complexes. +Each singular complex is a bounded-size block in degrees one and two, +with differential $A_q$ and determinant $l_{q,0}$. The differential is +upper triangular with the old complex as a subcomplex. This graded +free model lifts to $R$: stabilize the finite free models, identify their +augmentations, and lift the corresponding graded changes of basis. +The lifts are invertible because the augmentation ideal lies in the +Jacobson radical. Cancel the additional lifted unit disks before +retaining the old-plus-singular grading. Their augmented cross terms +are zero, so cancellation leaves precisely the displayed augmented +model; the added disks do not enlarge its old part. +The old model has bounded size, since $h_0$ is fixed and +$\omega(k)$ is bounded. +Indeed, the fixed-field Kummer and Schreier argument in +Lemma~\ref{rl:residual-bound}, now retaining the fixed primes of $h_0$, +bounds the residual global and local dimensions uniformly for +$\omega(k)$ bounded. This size bound is separate from the central +torsion-length bound used below. + +Over $O[G]$ the entire new-prime block is invertible. Schur elimination +leaves a complex $D$ of the bounded old size, with augmentation exactly +the old complex. For each $A_q$, the order of its residual determinant +at $t=0$ is bounded uniformly. At a split prime this follows from the +odd Frobenius exponent and the degree-two Frobenius polynomial; at a +root-type prime the constant term is already nonzero. Every sign +evaluation of the lifted block is its augmentation plus a matrix +divisible by $2$ with power-series entries. Therefore +Lemma~\ref{lem:h:bounded-poles} bounds the negative Laurent support of +the entries of every $D_x$ modulo each fixed $2^M$, independently of +the number of blocks. + +The integral central specialization of the old complex is controlled +by the ordinary base Kummer complex, the fixed old conductor primes, +and the bounded singular contributions at $r$. Its rational $H^1$ and +$H^2$ both have dimension one. Its torsion lengths are bounded by the +finite Selmer quotient assumed in +Theorem~\ref{thm:heegner-interpolation}, together with bounded global +torsion and these local contributions. Choose its elementary-divisor +bases at the center and lift. Apply case \textup{(i)} of +Lemma~\ref{lem:h:pivot-clearing} to $D$, the projected cycle and +paired functional. The eliminated large block contributes an +$O[G]$-unit to the determinant, and the multiplier in +Equation~\eqref{eq:h:group-ring-correction} belongs to $O[G]$. +Include both in the allowed factor $\eta$ of that lemma, so neither +enters the clearing factor $f$. The lemma gives $d=fu$, a bounded +central valuation for $f_0$, and the asserted pole bounds for $f_x$. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:heegner-interpolation}] +The primitive ring-class product has odd functional-equation sign +under the standing Heegner conditions. Suppose the base product does +not have a simple zero. Its first derivative then vanishes. By +Lemma~\ref{lem:h:unused-prime-correction}, $u_0(0)=0$, whereas every +nonzero vertex has central determinant valuation bounded by one +constant $B_1$ independent of the family. By +Lemma~\ref{lem:h:family-clearing}, the hypotheses of +Lemma~\ref{lem:h:boolean-transfer} hold with uniform central and pole +bounds. Choose its fixed precision larger than $B_1$ plus twice the +central bound, and then take the cube dimension sufficiently large. +It supplies a nonzero vertex whose central valuation exceeds $B_1$, +a contradiction. Thus the base product has a simple zero. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/04-cyclotomic.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/04-cyclotomic.tex new file mode 100644 index 0000000000000000000000000000000000000000..6a85b54410cf816ac39c2d069755c9634839b129 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/04-cyclotomic.tex @@ -0,0 +1,814 @@ +\section{Cyclotomic interpolation at analytic rank zero} +\label{sec:cy:interpolation} + +The cyclotomic argument transfers a nonzero central value across a binary +family. Its input is a uniform upper bound for the normalized valuations +at every nonzero vertex. Its output is nonvanishing at a corank-zero +base. The class used here is Kato's zeta class, and the additional variable +is the real cyclotomic $\Ztwo$-extension of $\Q$. + +Retain $T=T_2(E)$ and put $V_2=T\otimes_{\Ztwo}\Qtwo$. +The local weights, finite Sha lengths and period normalization are those +of Section~\ref{sec:preliminaries}, and $D(h)$ is defined in +Equation~\eqref{eq:transfer-normalized-value}. We prove +Theorems~\ref{thm:cyclotomic-bound} and~\ref{thm:cyclotomic-interpolation} +with their stated distinction between the uniform specialization error +and the dimension threshold for a fixed base. + +For a two-dimensional representation over $\F_2$, reducibility is +equivalent to being an extension of trivial modules. These are therefore +the two exhaustive residual cases. The proof has three stages: construct +a class in a fixed integral lattice, identify its central determinant, +and apply the binary congruences. Residual reducibility makes the +cyclotomic complex free after localization at $(2)$; the irreducible +case instead uses the bounded clearing factor of +Lemma~\ref{lem:h:pivot-clearing}. + +\subsection{The positive cyclotomic complex} + +At the coefficient prime $2$, the real place must be included in the +cochain construction. The positive complex defined below removes the +real cochains and retains their connecting invariant line. We will +combine this fixed line with the zeta class to form the determinant +whose central value detects nonvanishing at a corank-zero base. + +Put +\[ + \Gamma=\Gal(\Q_\infty/\Q),\qquad + \Lambda=\Ztwo[[\Gamma]]=\Ztwo[[t]],\qquad + \mathcal O=\widehat{\Lambda_{(2)}},\qquad + \Omega=\mathcal O/2\mathcal O=\F_2((t)), +\] +where a generator of $\Gamma$ corresponds to $1+t$. +The completion is $2$-adic. An element of $\mathcal O$ has a finite +negative Laurent part modulo every $2^M$, but need not have a value at +$t=0$. Every central evaluation below is made on a rational Iwasawa +class or on an element of $\Lambda[1/2]$ before extending coefficients +to $\mathcal O$. + +For a family in Equation~\eqref{eq:cy:cube}, let +$G=(\Z/2\Z)^b$ have characters indexed by $x\in\F_2^b$, and let +$\psi:G_{\mathbb Q}\to G$ be its universal +quadratic character: evaluation at $x$ is $\chi_{h_x/h_0}$. Put +\[ + R=\Lambda[G],\qquad + \mathbb T=T\otimes_{\mathbb Z _2}R, +\] +with the fixed twist $\chi_{h_0}$, the universal twist $\psi$, and the +inverse cyclotomic action. One may replace $G$ by the actual image of +$\psi$ and subsequently extend scalars. In a family in +Theorem~\ref{thm:cyclotomic-interpolation}, a nonzero character trivial on that image +already gives the conclusion directly. + +Let $S$ be the set of primes dividing $2N h_0\prod_{q\in\mathcal Q}q$. +For $q\in\mathcal Q$, write $g_q\in G$ for its inertia element, so +$x(g_q)=(-1)^{\lambda_q(x)}$. Use continuous cochains with their completed +coefficient topology, and set +\begin{equation}\label{eq:cy:positive-complex} + C_S^+(\mathbb T)= + \operatorname{Cone}\bigl(R\Gamma(G_{\mathbb Q,S},\mathbb T) + \longrightarrow R\Gamma(\mathbb R,\mathbb T)\bigr)[-1]. +\end{equation} +The real complex here uses ordinary cochains in nonnegative degrees. +There are no imposed local conditions at the finite places. We write +$C_S(\mathbb T)=R\Gamma(G_{\Q,S},\mathbb T)$ for the unmodified complex. +Throughout this section, \emph{ordinary global cohomology} means this +unmodified cohomology; it imposes no ordinary-reduction hypothesis at~$2$. + +\begin{lemma}\label{lem:cy:positive-model} +The complex in Equation~\eqref{eq:cy:positive-complex} is perfect over $R$ and computes derived +coefficient specializations. There is a class $a\in H^1(C_S^+(\mathbb T))$ +whose rational span is the real-place summand. Its integral index in +that summand depends only on $E$ and the fixed real sign. +\end{lemma} +\begin{proof} +Here are the finiteness and coefficient issues in the use of global +cochains. For a finite coefficient quotient of $R$, continuous cochains +are filtered unions of finite products of free coefficient modules. +Refinement of finite partitions makes these modules flat; over an Artin +local coefficient ring they are free. For finite residual coefficients, +global cohomology is finite in each degree, and restriction to the real +places is an isomorphism in degrees greater than two, by the real-place +clause of global duality \cite[\S5.7.1.7]{Nekovar2006}. +Thus the residual fiber has bounded +amplitude and finite-dimensional cohomology. The same amplitude bound +holds for every finite coefficient module, by a composition series and +the cohomology long exact sequence. + +This gives a bounded finite free model as follows. Over the residue +field split off the acyclic disks, leaving its finitely many cohomology +spaces. Lift each invertible disk differential over an Artin coefficient +quotient and cancel it. Invertibility of a lifted inverse follows from +nilpotence of the maximal ideal. Equivalently one can perform this on a +free resolution; a minimal free model cannot have an additional term +whose reduction has zero cohomology, because its residual differential +is zero. Hence the remaining ranks are the finite residual ranks and +are bounded independently of the coefficient quotient. Minimal models +identified by a homotopy equivalence over an Artin local ring are +isomorphic. Lifting their changes of basis therefore makes these models +compatible along $R/\mathfrak m^n$. Taking the inverse limit gives a +bounded finite free model over~$R$. The cochain construction with finite +free coefficients and the same cancellation also proves derived base +change. This is a fixed-$S$ argument; it does not assert uniform bounds +on the number of generators as $S$ varies. + +All the characters of the family have the same real sign, so the action +at the real place is the fixed action on $T\chi_{h_0}$ extended to $R$. +Choose a nonzero vector in its integral invariant line. Its connecting +image in the fiber is $a$. There are no global invariant vectors in the +rational elliptic representation, and consequently this connecting map +is injective rationally. The choice and its index are fixed. Notice also +that $H^1(\mathbb R,\mathbb T)$ is killed by~$2$; thus twice any ordinary +cohomology class lifts to the positive complex. The real-place global duality input is its corrected form at~$2$ +\cite[\S\S5.7.1--5.7.5]{Nekovar2006}; the invariant line and the lifting +assertion follow from the long exact sequence of this ordinary-real cone. +Complete real Tate cochains, used in the duality formulation, become +acyclic after inverting~$2$ and would not retain this invariant line. +\end{proof} + +\subsection{Fixed-form zeta classes and the integral coefficient map} + +To control denominators as the tame support grows, we construct every +class in the cohomological lattice of one fixed modular form. Let $f$ be the fixed weight-two form of $E$, and choose +its fixed integral cohomological lattice, with the Tate twist making its +rational representation~$V_2$. Kato's classes (8.1.2)--(8.1.3), for a fixed +symbol $\xi\in\mathrm{SL}_2(\mathbb Z)$, exist for arbitrary $m$ and any +$S$ containing the prime factors of $mN$. The trace in Section~8.9 is +a homomorphism into the lattice +\[ + \mathbb Z _2[\operatorname{Gal}(\mathbb Q(\mu_m)/\mathbb Q)] + \otimes V_{2,\mathbb Z _2}(Y_1(N))(1). +\] +Section~8.11 then projects to the lattice of the fixed form. +Proposition~8.12 supplies its norm relations. These assertions hold at +the coefficient prime~$2$ \cite[Sections~5.1, 8.1, 8.9--8.12]{Kato2004}. +In particular, the auxiliary modular-curve level used to define a trace +does not become the level of the projected newform. + +Choose an isomorphism of the resulting fixed rational representation with +$V_2$. A single power $2^{c_E}$ sends its integral lattice into~$T$. +Choose fixed symbols with nonzero projections on the required period +lines; their existence and the construction with both signs are made +explicit in \cite[Sections~13.6 and 13.9]{Kato2004}. Taking a fixed linear +combination, if needed, costs another fixed denominator. + +The following integral coefficient map encodes the binary family. Choose +$m=|h_0|\prod_{q\in\mathcal Q}q$, which is odd and divisible by the +conductors of all the tame characters in the family, including +$\chi_{h_0}$. At a sufficiently large +cyclotomic level write $A_{m,n}=\Gal(\Q(\mu_{m2^n})/\Q)$ +and let $\Gamma_n$ be its quotient in the real cyclotomic tower. Shapiro identifies the cohomology of the cyclotomic field +with global cohomology with induced group-ring coefficients. Push the +class along the ring homomorphism +\begin{equation}\label{eq:cy:coefficient-map} + \mathbb Z _2[A_{m,n}]\longrightarrow + \mathbb Z _2[\Gamma_n\times G],\qquad + [\sigma]\longmapsto + \chi_{h_0}(\sigma)[\sigma|_{\Gamma_n}][\psi(\sigma)]. +\end{equation} +Use inverse actions on both sides if this is required by the chosen +Shapiro convention. This is a homomorphism of integral coefficient +modules and acts on actual cohomology classes. It requires neither +division by $|G|$ nor surjectivity of a cohomological specialization map. +The prime $2$ belongs to the fixed omitted support, so Proposition~8.12 +gives exact norm compatibility as $n$ increases. The pushed classes +therefore give an integral smoothed Iwasawa class with coefficients in +$\mathbb T$, up to the single fixed power~$2^{c_E}$. + +We have placed all character constituents in the lattice of the same +modular form. The next normalization issue is smoothing: its +removal must be harmless both after localization at $(2)$ and at the +central value $t=0$. These are distinct requirements, checked next. + +We next remove smoothing. In weight two and with $r=r'=1$, its factors +are +\begin{equation}\label{eq:cy:smoothing} + (c^2-c\sigma_c)(d^2-d\sigma_d). +\end{equation} +This is the specialization of +\cite[Theorem~6.6 and (4.2.4)]{Kato2004}. Choose a fixed +$e\geq\max(2,v_2(N))$, increasing it to accommodate the finitely many +fixed symbol levels. The Chinese remainder theorem permits $c,d>1$, +prime to $6Nm$, such that +\[ + c,d\equiv1\pmod{3N_{\mathrm{odd}}m},\qquad + c,d\equiv1+2^e\pmod{2^{e+1}}. +\] +Their tame actions in \eqref{eq:cy:coefficient-map} are trivial. If +$\sigma_c$ acts in $\Gamma$ as $(1+t)^{\kappa(c)}$, then +$v_2(\kappa(c))=e-2$. Modulo the maximal ideal of $\mathcal O[G]$ its +smoothing factor is +\[ + 1-(1+t)^{\kappa(c)}\ne0\quad\hbox{in }\mathbb F _2((t)). +\] +It is therefore a unit in $\mathcal O[G]$. Its central value is +$c(c-1)$, of valuation exactly~$e$. The same statements hold for $d$ +and for inverse-translate conventions. Thus unsmoothing introduces +neither a $2$-adic denominator at $(2)$ nor a growing central denominator. +The integers $c,d$ vary with $m$; the congruences fix the needed valuations, +not their exact cyclotomic group elements. + +Denote the resulting rational ordinary class by $z_S$. \citet[Theorem~9.7]{Kato2004} applies to $k=2,r=r'=1$. In the character constituent +$x$, its central reciprocity formula reads +\begin{equation}\label{eq:cy:reciprocity-center} + v_2\bigl(\exp_2^*z_{S,x}(0)\bigr) + =v_2(\mathcal L(h_x))+ + \sum_{\substack{q\in\mathcal Q\,,\ q\nmid h_x}} + v_2\bigl(\#E^{(h_x)}(\mathbb F _q)\bigr)+O_E(1) +\end{equation} +when the value is nonzero, and a zero central value gives a zero dual +exponential. The omitted primes dividing $2N$ are included in the error. +To check the normalization, the character sum in +\eqref{eq:cy:coefficient-map} is the unnormalized sum, as in Kato's trace. +Its tame quadratic Gauss sum supplies $\sqrt{|h_x|}$ up to a root of +unity. Tame conductors and their Gauss sums are $2$-adic units. The +period vector is the fixed symbol vector of $f$. More explicitly, +in the required sign line write the period represented by +$\delta(f,1,\xi)^{\pm}$ as $c_\xi^{\pm}\Omega_E^{\pm}$. +The nonzero scalar $c_\xi^{\pm}$ is fixed: the character-sum formula +of \cite[Theorem~6.6]{Kato2004} uses this same $\delta(f,1,\xi)^{\pm}$ +for every tame character. The tame character enters through its +$L$-value and Gauss sum, not through a newly chosen period vector. +The comparison with the minimal differential of $E^{(h_x)}$ at $2$ has bounded valuation, +because there are only finitely many local twisting classes there. +At a good unused prime the omitted factor is +\[ + 1-\frac{a_q(E)\chi_{h_x}(\operatorname{Fr}_q)}q+\frac1q + =\frac{\#E^{(h_x)}(\mathbb F _q)}q; +\] +at a good ramified prime the local $L$-factor is~$1$. These account for +every varying factor in \eqref{eq:cy:reciprocity-center}. + +\subsection{Rational divisibility and the local Euler corrections} + +We now exclude poles of the zeta determinant away from $(2)$ and +account for every omitted Euler factor. Write $A=\Lambda[1/2]$. Theorem~12.5(3) of +\cite{Kato2004} is a height-one divisibility over~$A$; its possible local +$H^2$ correction comes from the arithmetic place~$2$. It need not be +supported at the Iwasawa ideal~$(2)$. The global groups +there use $j_*$ outside that prime. The stronger integral assertion of +Theorem~12.5(4) is not used. For a non-CM elliptic curve the characteristic-zero +image condition is supplied by the open image theorem, independently of +the residual image. For CM the required rational statement at every +prime, including~$2$, is supplied by +\cite[Theorem~2.6 and Remark~2.7]{BurungaleTian2026}. Neither statement +asserts uniform integrality in a quadratic group ring. The rational +cohomology statements, including \citet[Theorem~12.4]{Kato2004}, give rank one in degree one and torsion in degree +two, with no other positive cohomological rank. The real-place +modification adds its invariant line. Hence every generic character +constituent of the positive complex has rank two in degree one and no +other positive rank. + +Fix a character constituent $h$ and write $V_h=V_2\chi_h$. Let $C_{j_*}$ +be the rational Iwasawa complex in Kato's formulation and $C_S$ the +rational full global complex. At an odd prime put +\[ + W_q=H^1(I_q,V_h). +\] +The localization triangle has local cone +\begin{equation}\label{eq:cy:local-block} + Q_q=R\Gamma\bigl(G_{\mathbb F _q}, + W_q\otimes A(\Gamma^\iota)\bigr)[-1] + =\left[W_q\otimes A + \xrightarrow{\ 1-\gamma_q\operatorname{Fr}_{W_q}\ } + W_q\otimes A\right] +\end{equation} +in degrees one and two. Here $\gamma_q$ denotes the scalar cyclotomic +Frobenius in the chosen convention. Its exponent is nonzero. Consequently +$D_q=\det(1-\gamma_q\operatorname{Fr}_{W_q})$ is a nonzero element of~$A$, +and the map in \eqref{eq:cy:local-block} is injective. This remains true +after localization at a height-one prime dividing $D_q$: localization +does not mean reduction modulo that prime. Thus +\[ + H^1(Q_q)=0,\qquad + \operatorname{length}_{A_{\mathfrak p}}H^2(Q_q)_{\mathfrak p} + =v_{\mathfrak p}(D_q). +\] +The long exact sequence gives +\begin{equation}\label{eq:cy:local-sequence} + \begin{gathered} + H^1(C_{j_*})\simeq H^1(C_S),\\ + 0\longrightarrow H^2(C_{j_*})\longrightarrow H^2(C_S) + \longrightarrow\bigoplus_{q\in S\setminus\{2\}}H^2(Q_q) + \longrightarrow H^3(C_{j_*}). + \end{gathered} +\end{equation} +In particular, the length of $H^2(C_S)$ is at most the length of +$H^2(C_{j_*})$ plus the sum of the local lengths. No assertion that +$H^3(C_{j_*})$ vanishes is required here. + +At a good unused prime, $W_q=V_h(-1)$, so, on including the quadratic +Frobenius sign in $Z$, +\begin{equation}\label{eq:cy:local-euler} + D_q=P_q(Z),\qquad P_q(Z)=1-\frac{a_q(E)}q Z+\frac1q Z^2. +\end{equation} +At a good active prime, inertia acts by $-1$ on $V_h$. Its rational +inertia cohomology is zero, so $W_q=0$ and $D_q=1$. + +At fixed bad primes the general expression is $H^1(I_q,V_h)$ in +\eqref{eq:cy:local-block}. Replacing it indiscriminately by $V_h^{I_q}(-1)$ +would be incorrect. For example, at split multiplicative reduction, +\[ + V_h^{I_q}=\mathbb Q _2(1),\qquad + H^1(I_q,V_h)=\mathbb Q _2(-1), +\] +and the correct determinant is $1-\gamma_q/q$, with nonzero central +value. The incorrect replacement would give $1-\gamma_q$. +In general $D_q(0)\ne0$ follows from local duality and the Weil pairing: +$H^2(\mathbb Q _q,V_h)=H^0(\mathbb Q _q,V_h)^*=0$, since elliptic torsion +over a local field is finite. The fixed bad-prime corrections therefore +have nonzero central values for every reduction type. + +Let $z_{\mathrm{BK},h}$ denote a generator of the rational Kato zeta +line in its real cyclotomic component. The rational comparison with +the fixed-form class constructed above is made only after taking the +character constituent. Both global Iwasawa $H^1$ modules have rank one. +Their reciprocity laws at cyclotomic finite-order characters agree up to +the omitted Euler factors, a nonzero constant, and a group-like unit. +This follows by coprime Gauss-sum factorization and the fixed period +comparison; restricting conductor exponents to either fixed parity +removes any factor $\chi_h(2)^n$. Infinitely many of these tests have +nonzero central value by cyclotomic nonvanishing, as used in +\cite[Theorem~13.5(2)]{Kato2004}. After clearing the finitely many +denominators of the scalar ratio, the difference is a power series +vanishing at infinitely many finite-order characters. Weierstrass +preparation forces that difference to be zero. This proves the generic +comparison without identifying the integral lattices of varying +twisted newforms. Its nonzero scalar in $\mathbb Q _2$ may depend on +$h$ and need not have a uniformly bounded $2$-valuation: every such +scalar is a unit of $A$ and does not affect height-one divisibility +over~$A$. The uniform integral and central bounds instead concern +the actual fixed-form class and the fixed period vector in +\eqref{eq:cy:reciprocity-center}. + +Equations~\eqref{eq:cy:local-sequence}--\eqref{eq:cy:local-euler} now show exactly +how the imprimitive factors enter divisibility. At any height-one +$\mathfrak p$ of $A$, enlarging the global complex increases its +degree-two length by at most $\sum_qv_{\mathfrak p}(D_q)$, whereas +multiplying the rank-one zeta generator by $\prod_qD_q$ adds exactly +that quantity to its index. To cover Kato's coefficient-prime correction, multiply the +class also by a fixed element $F_2\in\Lambda$ divisible over $A$ by the +characteristic ideal of the relevant local $H^2_{\mathrm{Iw}}$. +It may be chosen with $F_2(0)\ne0$. Indeed derived local control gives +\[ + H^2_{\mathrm{Iw}}(\mathbb Q _2,T\chi_h)_\Gamma\otimes\mathbb Q _2 + =H^2(\mathbb Q _2,V_h)=0, +\] +so the characteristic ideal has no factor $t$. Local twisting classes +at $2$ are fixed, and one element covers their finite set. + +Likewise any additional fixed Euler factors in the rational comparison +can be cleared by a fixed product with nonzero central value, using the +actual blocks \eqref{eq:cy:local-block}. Denote the total fixed multiplier +by~$F_E$. Multiplying by it only changes the fixed constants in +\eqref{eq:cy:reciprocity-center} and the integrality bound. For the corrected +class, still written $z_S$, we have at every height-one $\mathfrak p$ of~$A$ +\begin{equation}\label{eq:cy:divisibility} + \operatorname{length}_{A_{\mathfrak p}}H^2(C_S)_{\mathfrak p} + \leq + \operatorname{length}_{A_{\mathfrak p}} + \bigl(H^1(C_S)/Az_{S,h}\bigr)_{\mathfrak p}. +\end{equation} + +There is an integral convention check for the varying unused primes. +In $\mathcal O[G]$, both $P_q(Z)$ and $Z^2P_q(Z^{-1})$ are units: their +reductions are nonzero polynomials evaluated at the nonconstant +cyclotomic Frobenius. The identity +\[ + P_q(Z)-Z^2P_q(Z^{-1})=\frac{q-1}{q}(1-Z^2) +\] +shows that their ratio $r_q$ is $1$ modulo~$2$. If $g_q$ is the universal +inertia element, then +\begin{equation}\label{eq:cy:reciprocal-correction} + U_q=1+\frac{r_q-1}{2}(1+g_q)\in\mathcal O[G]^\times +\end{equation} +is integral. At an active character it is $1$; at an unused character +it is $r_q$. Its unused central value is $1$, since $Z=\pm1$ there. +Thus inverse Frobenius conventions can be reconciled before character +evaluation, without a denominator for each prime. Products of these +units have the same property. The resulting rational character +coordinates have the Euler convention in \eqref{eq:cy:divisibility}. + +\begin{lemma}[Fixed-lattice zeta class]\label{lem:cy:kato-class} +For every binary family and its ramification set $S$, the corrected +class $z_S$ satisfies the central reciprocity formula \eqref{eq:cy:reciprocity-center} and the rational divisibility +\eqref{eq:cy:divisibility}. For some $c_E\ge0$ depending only on $E$, +\[ + 2^{c_E}z_S\in + H^1\!\left(C_S(\mathbb T)\otimes_R^{\mathbf L}\mathcal O[G]\right). +\] +The same exponent works for all $S$, binary families, and fixed factors +$h_0$ with the specified local classes. Here the displayed cohomology +is derived scalar extension of the Iwasawa complex. +\end{lemma} +\begin{proof} +The integral coefficient map uses the fixed-form lattice and no +character averages. Unsmoothing and every varying-prime convention +correction are units over $\mathcal O[G]$. The multiplier $F_E$ is fixed. +The preceding construction therefore gives the displayed assertion +with a fixed exponent, as well as the two stated comparison formulas. +\end{proof} + +\subsection{The determinant and its central specialization} + +The zeta class now has two controls: rational divisibility will exclude +poles of its determinant coordinate away from $(2)$, and the fixed +lattice bounds the class's integral denominator at $(2)$. We next +identify its determinant coordinate at +$t=0$. This is the step that converts those cohomological controls +into a statement about $D(h)$. + +Choose a basis of the invertible $R$-module +$\det_R^{-1}C_S^+(\mathbb T)$; $R$ is local, so such a basis exists. +Lift $2z_S$ to rational positive cohomology and take its wedge with $a$. +The factor $2$ is fixed, and two lifts differ by a real-place class, +which does not change this wedge. Let $u$ be its generic determinant +coordinate, including the fixed multiplier $F_E$ above. The real-place +summand introduces no height-one torsion over~$A$. Thus +\eqref{eq:cy:divisibility} says that $u_x$ has no pole at any height-one +prime of $\Lambda$ except possibly $(2)$. Since $\Lambda$ is normal, +\begin{equation}\label{eq:cy:rational-integrality} + u_x\in\Lambda[1/2]\qquad\hbox{for every }x. +\end{equation} +The two cycles have a common denominator bounded by a fixed power +$2^{C_{\mathrm{int}}}$ after extension to $\mathcal O[G]$. This follows +from Lemma~\ref{lem:cy:kato-class} and the factor $2$ needed for the lift. + +\begin{proposition}[Central determinant formula]\label{prop:cy:specialization} +There is a constant $C_{\mathrm{loc}}$, depending only on the fixed curve +and local classes, with the following property. Suppose +$c_2(E^{(h_x)})=0$. If $L(E^{(h_x)},1)=0$, then $u_x(0)=0$; if +$L(E^{(h_x)},1)\ne0$, then +\begin{equation}\label{eq:cy:determinant-center} + \bigl|v_2(u_x(0))-D(h_x)\bigr|\leq C_{\mathrm{loc}}. +\end{equation} +The rational positive complex at $t=0$ has cohomology only in degree one, +of dimension two, so these are specializations of the same determinant. +\end{proposition} +\begin{proof} +Abbreviate $T_h=T_2E^{(h_x)}$ and $A_h=E^{(h_x)}[2^\infty]$. +Use the integral Kummer subgroup +\[ + K_v=\operatorname{im}\bigl(E^{(h_x)}(\mathbb Q _v)^{\wedge}_2 + \longrightarrow H^1(\mathbb Q _v,T_h)\bigr) +\] +at every finite place. For $v\ne2$ it is all of $H^1(\mathbb Q _v,T_h)$. +One way to see this integrally is the inverse-limit Kummer exact sequence: +its quotient is $T_2H^1(\mathbb Q _v,E^{(h_x)})$, which is zero because +local Tate duality identifies the $2$-primary local Weil--Ch\^atelet group +with the dual of the finite $2$-completion of the local point group. +At $2$ the quotient +\[ + L_2=H^1(\mathbb Q _2,T_h)/K_2 +\] +is a free rank-one $\mathbb Z _2$-module. The same Kummer sequence and +local Tate duality identify it with the $\mathbb Z _2$-dual of the free +part of $E^{(h_x)}(\mathbb Q _2)^{\wedge}_2$. + +The dual exponential identifies $L_2\otimes\mathbb Q _2$ with the +one-dimensional de Rham target. To specify its integral comparison, put +\[ + B_2=E^{(h_x)}(\mathbb Q _2)^{\wedge}_2/\mathrm{tors} +\] +and choose a minimal differential $\omega_h$. +The Bloch--Kato exponential agrees with the Kummer image of the classical +elliptic exponential, which is the inverse of the formal logarithm on a +sufficiently small open subgroup. This comparison holds for every +reduction type \cite[Definition~3.10 and Example~3.11]{BlochKato1990}. +The dual exponential is the adjoint of that exponential under local +Tate duality \cite[\S II and Proposition~II.5]{Berger2003}. +Extend the formal logarithm to the rationalized local point group and write +$\log_{\omega_h}(B_2)=\lambda_h\mathbb Z _2$. +The integral identification +$L_2=\operatorname{Hom}_{\mathbb Z _2}(B_2,\mathbb Z _2)$ then gives +\[ + \exp_2^*(L_2)=\lambda_h^{-1}\mathbb Z _2\omega_h, +\] +using the Weil-pairing identification of the de Rham target with +$\mathbb Q _2\omega_h$. Thus the relative lattice valuation is fixed +by the local curve and differential. Since only finitely many local +twist classes occur, these valuations are uniformly bounded. + +The assumption on the Selmer corank implies that the compact finite +Selmer group is torsion and that the discrete finite Selmer group has +length $s(h_x)$. Rational Poitou--Tate consequently identifies ordinary +global $H^1$ with the singular line at $2$, and gives ordinary global +$H^2=0$ rationally. Adding the real invariant line gives the claimed +dimension two in degree one. This equals the generic rank, so derived +base change of the perfect complex specializes its determinant without +a change of rational cohomological rank. + +Here is the integral length calculation. Let $J$ be the image of the +free part of global $H^1(G_{\mathbb Q,S},T_h)$ in $L_2$, and put +$i=\operatorname{length}(L_2/J)$. The compact/discrete Poitou--Tate +sequence for the mutually orthogonal Kummer conditions contains +\[ +\begin{aligned} + 0\longrightarrow L_2/J + &\longrightarrow \operatorname{Sel}_{2^\infty}(E^{(h_x)}/\mathbb Q)^\vee + \longrightarrow H^2(G_{\mathbb Q,S},T_h)\\ + &\longrightarrow \bigoplus_{q\in S}H^2(\mathbb Q _q,T_h) + \longrightarrow H^0(\mathbb Q,A_h)^\vee\longrightarrow0, +\end{aligned} +\] +with the usual real Tate-cohomology terms inserted. Those terms are +killed by $2$ and have dimensions bounded by the fixed dimension of~$T$. +Taking lengths and using local duality gives +\begin{equation}\label{eq:cy:pt-length} + \operatorname{length}H^2(G_{\mathbb Q,S},T_h) + =s(h_x)-i+\sum_{q\in S}\operatorname{length}H^0(\mathbb Q _q,A_h) + +O_E(1). +\end{equation} +This sequence follows from integral Poitou--Tate duality with the finite +Kummer conditions and the real Tate-cohomology correction +\cite[\S\S5.7.1.6, 5.7.4--5.7.5 and 6.9.1]{Nekovar2006}. +The free real invariant line is already accounted for by $a$; only the +bounded real torsion terms enter the error above. +No unramified condition replaces +the Kummer condition at a bad prime. Global torsion is bounded by its +injection into $E^{(h_x)}(\mathbb Q _2)[2^\infty]$, whose order is bounded +by the fixed local twisting classes. The finite terms at $2$ and at +fixed bad primes are bounded for the same reason. Passing between +ordinary and positive cohomology changes only these bounded real and +global torsion terms. + +Suppose first that the central value is nonzero. The coordinate of +$z_{S,x}(0)$ in the free global line has valuation +\[ + v_2(\exp_2^*z_{S,x}(0))-i+O_E(1). +\] +For the inverse determinant, torsion in degree two subtracts its length +and torsion in degree one adds its length. This sign can be checked on +the complex $[\mathbb Z _2\xrightarrow{2^a}\mathbb Z _2]$ in degrees one +and two: its inverse determinant lattice maps to $2^a\mathbb Z _2$ in +the rational determinant. A vector's coordinate thus loses~$a$. +Using \eqref{eq:cy:pt-length}, the two appearances of $i$ cancel, leaving +\[ + v_2(u_x(0))= + v_2(\exp_2^*z_{S,x}(0))-s(h_x) + -\sum_{q\in S}\operatorname{length}H^0(\mathbb Q _q,A_h)+O_E(1). +\] + +At an active good prime, quadratic inertia acts by $-1$ on the Tate +module. Its invariants on $A_h$ are therefore exactly $E[2]$, and taking +Frobenius invariants gives length~$t_q$. At an unused good prime, reduction +identifies the local $2$-primary torsion with +$E^{(h_x)}(\mathbb F _q)[2^\infty]$, of length +$v_2(\#E^{(h_x)}(\mathbb F _q))$. These unused terms cancel exactly +those in \eqref{eq:cy:reciprocity-center}. The active terms, including the primes +of $h_0$, sum to $2w(h_x)$. All other terms have already been bounded +independently of the growing support. This proves +\eqref{eq:cy:determinant-center}. + +If the central value is zero, reciprocity makes the dual exponential +zero. The rational ordinary specialization then satisfies the finite +condition at $2$, and it satisfies the finite conditions elsewhere +automatically. It lies in the rational finite Selmer group, which is +zero. Its wedge with the real-place class is therefore zero. The +constant-rank determinant specialization proves $u_x(0)=0$. +\end{proof} + +\subsection{Residual freeness and the lower bound} + +The central formula expresses $D(h)$ through the determinant valuation. +When the residual representation is an extension of trivial modules, +we can bound that valuation directly: the positive complex becomes a +free rank-two module in degree one after extension to $\mathcal O[G]$. +The fixed-lattice class then supplies the lower bound without any loss +from a growing ramification support. + +\begin{lemma}[Residual concentration]\label{lem:cy:residual-free} +If $E[2]$ is an extension of two trivial $\F_2$-modules, then there is an +isomorphism in the derived category +\[ + C_S^+(\mathbb T)\otimes_R\mathcal O[G] + \simeq \mathcal O[G]^2[-1]. +\] +\end{lemma} +\begin{proof} +The ring $\mathcal O[G]$ is local, with residue field $\Omega$ obtained +by setting $2=0$ and every $g=1$. Thus the quadratic characters disappear. +Since $E[2]$ has a filtration with trivial factors, it is enough first to +compute the positive residual complex for the trivial representation. + +Let $K_n$ be the real cyclotomic layer of degree $d_n=2^n$. The number +of finite primes of $K_n$ above a fixed $S$ is bounded with $n$: at $2$ +there is total ramification, and the Frobenius of each fixed odd prime +has nonzero image in $\Gamma$. The $2$-ranks of the class groups of +$K_n$ are also bounded. Let $X$ be the inverse limit, under norm maps, of +their $2$-primary class groups. The unique prime above~$2$ is totally +ramified in this tower, so class-field-theoretic control gives +\[ + X_{\Gamma^{2^n}}\simeq\Cl(K_n)[2^\infty] +\] +\cite[Proposition~3.2.11 and Remark~3.2.12]{SharifiIwasawa}. +Ferrero--Washington gives $\mu(X)=0$ for this abelian tower +\cite{FerreroWashington1979}. The Iwasawa structure theorem then makes +$X$ finitely generated over $\mathbb Z _2$, so all its coinvariants have +uniformly bounded $2$-rank. Passing to the quotient $S$-class groups +preserves this upper bound. + +The signature map of units in $K_n$ is surjective. For $n\geq1$, let +$\zeta$ be a primitive $2^{n+2}$th root and put +$\epsilon=1+\zeta+\zeta^{-1}$. If $f_1(X)=X^2-2$ and +$f_{n+1}(X)=f_n(X^2-2)$, then $f_n$ is the minimal polynomial of +$\zeta+\zeta^{-1}$ and $f_n(-1)=-1$. Hence +$N_{K_n/\mathbb Q}(\epsilon)=-1$. Its signature vector has odd +augmentation. The embeddings form a regular set for the cyclic +$2$-group $\operatorname{Gal}(K_n/\mathbb Q)$, whose group algebra over +$\mathbb F _2$ is local. A vector with odd augmentation is a unit in +this group algebra, so its translates span every signature. For $n=0$ +the assertion follows from the unit~$-1$. + +The signature calculation supplies the real-place surjectivity needed +for the positive complex. The class-group and support terms are bounded +along the tower. We can therefore identify the one cohomological degree +whose dimension grows with the layer degree, and then recover the rank +after inverting $t$. + +Kummer theory now determines the cohomological growth. +Writing $s_n$ for the number of finite support places and $c_n$ for the +$2$-rank of the $S$-class group, one has +\[ + \dim H^1(G_{K_n,S},\mu_2)=d_n+s_n+c_n. +\] +The real degree-one restriction is surjective by the signature result. +In degree two, the Kummer sequence has class-group term of dimension +$c_n$ and Brauer term. The Brauer invariants at the real and finite +support places have their single sum relation. Since a finite support +place above $2$ is present, restriction of the Brauer term to the real +places is surjective and has kernel of dimension $s_n-1$. Thus the +degree-two kernel of restriction to infinity is bounded. Restriction +is an isomorphism in higher degrees by global duality. The degree-zero +restriction is injective. The cohomology of the positive fiber is +therefore bounded in every degree except one; its degree-one dimension +is $d_n+O_S(1)$. + +Apply Lemma~\ref{lem:cy:positive-model} modulo $2$. Derived specialization to the +$n$th layer is specialization modulo $t^{2^n}$. For a perfect complex +over $\mathbb F _2[[t]]$, the universal-coefficient exact sequence shows +that a rank-$r$ cohomology module contributes $r2^n+O(1)$ to these +dimensions; the torsion terms contribute only $O(1)$. It follows that +after inverting $t$ the trivial-constituent fiber has dimension one in +degree one and vanishes in every other degree. Extensions preserve +this concentration, so the fiber for $E[2]$ has dimension two in degree +one. A minimal finite free complex over the local ring $\mathcal O[G]$ +has zero residual differentials. The concentration just proved forces +all its terms except the rank-two term in degree one to vanish. +No denominator is introduced by this exact freeness statement. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:cyclotomic-bound}] +Apply Lemma~\ref{lem:cy:residual-free} to the single discriminant $h$. +The fixed-lattice construction and the free complex give +$2^{C_{\mathrm{int}}}u_h\in\mathcal O$ with $C_{\mathrm{int}}$ depending +only on $E$. Equation~\eqref{eq:cy:rational-integrality} also gives +$u_h\in\Lambda[1/2]$. Since +$\mathcal O\cap\Lambda[1/2]=\Lambda$, it follows that +$v(u_h(0))\ge-C_{\mathrm{int}}$. Analytic rank zero supplies Selmer +corank zero by the forward theorem of Gross--Zagier--Kolyvagin. +Proposition~\ref{prop:cy:specialization} now gives +$D(h)\ge-C_{\mathrm{int}}-C_{\mathrm{loc}}$. +All constants come from the fixed form, the fixed real period line, +or the finitely many local twisting classes at $2N$. +\end{proof} + +\subsection{Transfer to the base} + +It remains to prove the missing-vertex theorem. Residual freeness gives +a single integral family in the reducible case. In the irreducible +case we instead need a bounded clearing factor after eliminating the +new local blocks. The bound on $v_2(q^2-1)$ enters precisely here: the +next lemma controls the negative Laurent powers in those inverse +blocks at each fixed precision. + +\begin{lemma}\label{lem:cy:cyclotomic-poles} +Suppose that $q$ is an added prime and $v_2(q^2-1)\le L$. At +augmentation $G\to1$, the inverse singular Frobenius block contributed +by $q$ has, modulo each fixed $2^M$, negative Laurent support bounded +in terms of $L$ and $M$. This bound is independent of $q$. +\end{lemma} + +\begin{proof} +Identify $\Gamma$ with $1+4\Ztwo$ using a fixed generator. If +$\gamma_q=(1+t)^{\alpha_q}$ is the image of arithmetic Frobenius at +$q$, then +\[ + v_2(\alpha_q)=v_2(q^2-1)-3 +\] +when the generator is $5$; changing the generator multiplies +$\alpha_q$ by a unit. In particular $\alpha_q\ne0$. The singular +quotient is represented by a block of bounded size whose determinant +is the Euler polynomial in Equation~\eqref{eq:cy:local-euler}. +Modulo $2$, with $z=(1+t)^{\alpha_q}$, it is +\[ + 1+\overline{a_q}z+z^2. +\] +If $\overline{a_q}=1$, its constant coefficient is $1$. If +$\overline{a_q}=0$, it is $(1+z)^2$, whose $t$-order is +$2^{v_2(\alpha_q)+1}\le2^{L-2}$. Thus the inverse determinant has +uniformly bounded pole order modulo $2$. Lift its inverse modulo +$2^M$ by a geometric expansion of length at most $M$. Each term +contains only a bounded number of inverse residual factors, and all +numerators have nonnegative powers of $t$. The adjugate formula gives +the same bound for every entry of the inverse block. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:cyclotomic-interpolation}] +At every nonzero vertex, analytic rank zero gives +$c_2(E^{(h_x)})=0$ by the forward rank-zero theorem. Thus +Proposition~\ref{prop:cy:specialization} applies at every vertex. + +First assume $E[2]$ is an extension of trivial modules. +Lemma~\ref{lem:cy:residual-free} and the fixed-lattice construction give +$2^{C_{\mathrm{int}}}u\in\mathcal O[G]$. Moreover, the character coordinates of $u$ +are in $\Lambda[1/2]$. Fourier inversion, performed rationally, shows +$u\in\Lambda[1/2][G]$; intersecting coefficientwise with +$\mathcal O[G]$ gives +\begin{equation}\label{eq:cy:universal-integrality} + 2^{C_{\mathrm{int}}}u\in\Lambda[G]. +\end{equation} +The coefficients at $t=0$ therefore obey the bounded-degree Boolean +congruences of Lemma~\ref{lem:h:boolean-coefficients}. For any fixed +precision and sufficiently large $b$, there is a nonzero $x$ for which +$u_x(0)$ agrees with $u_0(0)$ to that precision. The fixed multiplier +in Equation~\eqref{eq:cy:universal-integrality} affects the required +precision but has no dependence on $b$. + +Now suppose $E[2]$ is irreducible. At augmentation, represent the +positive complex as the old complex, with ramification set excluding +$\mathcal Q$, extended by the direct sum of singular blocks at the +new primes. The differential is upper triangular with the old +complex as subcomplex. The finite-model argument of +Lemma~\ref{lem:h:finite-models} lifts this model over $R$: stabilize the +finite free models and lift their graded changes of basis. These lifts +are invertible because the augmentation ideal lies in the Jacobson +radical. Cancel all additional lifted unit disks before retaining the +old-plus-singular grading; their augmented cross terms are zero, so the +remaining augmentation is exactly the prescribed block model. Thus no +stabilization disk enlarges the old complex. +Lemma~\ref{lem:h:bounded-poles} then applies to this block model. All the new +blocks are invertible over $\mathcal O[G]$: modulo its maximal ideal +their Frobenius determinants are nonzero in $\Omega$. +Schur elimination leaves a complex of bounded size. Its augmentation +is the fixed old complex, and its entries have bounded negative +Laurent support modulo each fixed $2^M$. Under the determinant-line +identification, write +\[ + u=\eta u_{\mathrm{bd}},\qquad \eta\in\mathcal O[G]^\times, +\] +where $u_{\mathrm{bd}}$ is the coordinate on this bounded complex and +$\eta$ is the determinant factor of the eliminated blocks. No uniform +Laurent bound on $\eta$ is needed. + +The pole bound remains uniform as primes are added. At augmentation the inverse new block is a direct +sum of the inverses in Lemma~\ref{lem:cy:cyclotomic-poles}. At any +character its perturbation has entries divisible by $2$ and no +negative powers of $t$. Modulo $2^M$, the inverse uses a geometric +series of length at most $M$, independently of the number of blocks. +Each product therefore uses a bounded number of inverse entries. +Sums of an arbitrary number of such terms cannot decrease the +nonarchimedean valuation or the common lower Laurent bound. This is +the required bound for Schur elimination. + +At $t=0$ the old positive complex has rational cohomology only in +degree one, of dimension two, by +Proposition~\ref{prop:cy:specialization} at $h_0$. Its finite torsion +and all old local data are fixed. Choose boundary pivots there, +leaving those two free coordinates. Their sizes and valuations may +depend on $h_0$ but not on $b$. Apply the determinant clearing argument +of Lemma~\ref{lem:h:pivot-clearing} to the wedge of the two +bounded-integral cycles $a,2z_S$ on the remaining complex. Its allowance +for an arbitrary factor $\eta$ puts the eliminated-block factor into +the numerator alone. It yields +\begin{equation}\label{eq:cy:cleared-determinant} + d=fu\in\mathcal O[G],\qquad f\in\mathcal O[G],\qquad + f_0\in\Lambda,\quad f_0(0)\ne0. +\end{equation} +For each fixed $M$, the negative Laurent support of $f_x\bmod2^M$ +is bounded independently of $b$ and $x$. The clearing factor is a +polynomial of bounded degree in the remaining bounded-size matrix, +with the pivot denominators cleared by adjugates. Neither the +eliminated-block unit, the zeta class nor $d$ is required to have a uniform bound on +its negative Laurent support. + +Equation~\eqref{eq:cy:rational-integrality} ensures that every $u_x$ +has no negative $t$-powers. Thus all hypotheses of +Lemma~\ref{lem:h:boolean-transfer} hold for +Equation~\eqref{eq:cy:cleared-determinant}. In particular, for each +fixed precision and sufficiently large $b$, some nonzero $x$ satisfies +the corresponding central congruence between $u_x(0)$ and $u_0(0)$. +The dependence on $h_0$ enters the required precision and dimension, +through $v(f_0(0))$, and not the eventual valuation comparison. + +In either residual case let $C$ bound the absolute error in +Equation~\eqref{eq:cy:determinant-center}. The nonzero vertices have +$v(u_x(0))\le B+C$. If $L(E^{(h_0)},1)=0$, the central coordinate at +zero is zero, and a congruence of precision larger than $B+C$ is +impossible. Hence the central value is nonzero. If +$D(h_0)>B+2C$, then +$v(u_0(0))>B+C$, giving the same contradiction. This proves +Equation~\eqref{eq:cy:transferred-bound} with $C_E=2C$. +Only the specialization error determines this final loss; all pivot +and pole bounds determine how large a cube is needed. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/05-coefficients.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/05-coefficients.tex new file mode 100644 index 0000000000000000000000000000000000000000..9ffd8937ddbcbbcc98f5fbea1386778442988eb0 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/05-coefficients.tex @@ -0,0 +1,774 @@ +\section{Coefficients that detect analytic rank} +\label{cs:coefficient-systems} + +The interpolation theorems require nonvanishing with a uniform valuation +bound at the nonzero vertices of a cube. We encode both requirements in +one binary coefficient: it is one when a modular coefficient has the +least normalized valuation. Waldspurger's formula supplies the even-sign +coefficients; reduction of genus Heegner sums supplies the odd-sign +coefficients at finite precision. We prove their modular and arithmetic +properties separately before choosing this normalization. + +\subsection{Filters and prime weights} + +Fix $E/\Q$ and a finite set $S$ containing the primes of $2N$ and the +ramification set of $F=\Q(E[2])$. Additional fixed primes may be included. +A \emph{filter} consists of a sign $\sigma\in\{1,-1\}$ and unit +squareclasses at the primes in $S$, imposed on positive squarefree integers +$D$ prime to $S$, so that +\[ + h=\sigma D +\] +is an odd fundamental discriminant and the functional sign of $E^{(h)}$ +is constant. Multiplication by squares of units preserves the local +conditions. We impose these conditions on all Fourier indices, not only +on squarefree ones. Projections onto the required unit squareclasses are +finite combinations of quadratic coefficient twists and coprimality +projections; they enlarge the level only at $S$. + +For $p\notin S$, the action on $V=E[2]$ has the following three types: +\[ +\begin{array}{c|c|c} +\text{type}&\Fr_p|_V&\text{weight}\\ \hline +\text{split}&1&1\\ +\text{simple}&\text{an element of order }2&1/2\\ +\text{root}&\text{an element of order }3&0. +\end{array} +\] +Thus $w(D)=\frac12\sum_{p\mid D}\dim_{\mathbf F_2}V^{\Fr_p}=w(h)$. +The fractional part of $w(D)$ is constant on a filter: it is determined +by the quadratic discriminant character of the residual representation. +For an arbitrary squarefree set of primes we use the same additive +weight. Signs are encoded by $p^*=(-1/p)p$, so that $h=\prod_{p\mid D}p^*$. + +We use the ordinary theta multiplier cubed in weight $3/2$. A finite +idele unit character and its Dirichlet character are related by the +reciprocal convention: if a finite Schwartz function obeys +$f(ux)=\alpha(u)f(x)$, its scalar classical character on the lower-right +entry is associated to $\alpha^{-1}$. All valuations satisfy $v(2)=1$. + +\subsection{The even coefficient system} + +\begin{proposition}[Even coefficients] +\label{prop:even-coefficients}\label{co:even} +Fix a nonempty filter with even functional sign. There are a holomorphic +weight-$3/2$ cusp form +\[ + g=\sum_{n\geq1}a(n)q^n +\] +of level supported on $S$, after enlarging exponents at those primes, +and finite-order characters $\psi,\eta$ of $2$-power order, with +$\psi/\eta$ quadratic, having the following properties. +\begin{enumerate}[label=\textup{(\roman*)}] +\item The coefficients vanish off the filter and, for $p\notin S$, +\begin{equation} + a(p^2n)=\bigl(\eta(p)a_p(E)-\psi(p)(-n/p)\bigr)a(n) + -p\eta(p)^2a(n/p^2). +\label{cs:hecke-recurrence} +\end{equation} +As usual a coefficient with a nonintegral index is zero. +\item After normalizing at one nonzero squarefree index, every squarefree +coefficient in the filter is a rational number times a root of unity of +$2$-power order. For a fixed nonzero squarefree index $D_0$, +\begin{equation} + 2v\left(\frac{a(D)}{a(D_0)}\right) + =v\left(\frac{\mathcal L(\sigma D)}{\mathcal L(\sigma D_0)}\right) + \quad\text{whenever }a(D)\ne0. +\label{cs:even-ratio} +\end{equation} +Equivalently, there is a constant $c_g$, independent of $D$, such that +\begin{equation} + 2v(a(D))=v\bigl({\cal L}(h)\bigr)+c_g. +\label{cs:even-value} +\end{equation} +In particular $a(D)\ne0$ if and only if $L(E^{(h)},1)\ne0$. +\item After the fixed auxiliary exclusions described below, there is a +constant $C_g$ such that, at every nonzero squarefree coefficient, +\begin{equation} + v(a(D))\geq w(D)+\tfrac12s(h)-C_g. +\label{cs:even-lower-bound} +\end{equation} +The constants depend on the fixed curve, filter and auxiliary choices, +and not on $D$ or its number of prime factors. +\end{enumerate} +\end{proposition} + +\begin{proof} +We first choose the packet member and its local characters. We then +establish the rationality up to phase needed for valuation comparisons, +apply the coefficient-square formula, and deduce the uniform lower bound +from the interpolation estimates. + +Use the Shimura packet attached to the integral-weight newform of +$E^{(-\sigma)}$. In the classical convention its positive Fourier index +$D$ tests the twist by $\chi_{-D}$, hence the curve $E^{(\sigma D)}$. +The packet and Fourier coefficient results of +\citet{Waldspurger1980,Waldspurger1981} apply to the cuspidal packet +orthogonal to unary theta series. Their local uniqueness and global +multiplicity assertions are summarized in +\citep[Sections~3.1 and~5.1]{Waldspurger1983}. +A nonzero central value in the filter exists by +Proposition~\ref{prop:rough-nonvanishing}. It selects a globally occurring +packet member with nonzero Fourier functional at that index. At good +odd primes choose spherical vectors; at infinity choose the holomorphic +vector of weight $3/2$. + +We explain the choices at a prime of $S$. Let $\lambda_D$ be a nonzero +local Fourier functional and start with a vector on which it is nonzero. +Average upper-unipotent translates against the inverse additive character +of frequency $D$. If the averaging compact subgroup is sufficiently +large, its translate by a unit scale $u$ can contribute only when $u^2$ +is sufficiently close to $1$. The surviving scales are consequently +small neighborhoods of $1$ and $-1$. Local constancy then permits +projection onto a unit character which matches the forced action of +$-1$, without killing the Fourier value: the contributions of the two +neighborhoods add. Such a character may be chosen to have $2$-power +order. Indeed only its parity is prescribed, and the $2$-primary +quotient of the unit group realizes either possible parity. Upper +averaging at integral frequency gives period one, and lower-unipotent +invariance holds at sufficiently large depth. These vectors therefore +give a classical form at a level supported on $S$. The parity conditions +combine correctly by automorphy. The subsequent squareclass projections +preserve its character. Write that character as $\psi$. + +In the theta-multiplier convention the good eigenvalues of the packet +are $\psi(p)$ times those of $E^{(-\sigma)}$. Set +$\eta=\psi\chi_{-\sigma}$. Then $\psi/\eta$ is quadratic and the +weight-$3/2$ Hecke formula gives Equation~\eqref{cs:hecke-recurrence}. + +We need more than algebraicity of the coefficients. After normalization +at one squarefree index, their nonzero squarefree valuations must be +integers, so that a strict valuation inequality gains a full factor of +$2$, even when the character field is ramified. We prove this by showing +that every such coefficient is rational up to a phase of $2$-power order. +At the fixed level, +the weight-$3/2$ cusp space with character $\psi$ has a basis over the +field of character values, and coefficient conjugation changes $\psi$ +to its conjugate +\citep[Section~2, Lemma~4(3)--(4), pp.~658--659]{Shimura1981CriticalValues}. +The good Hecke equations and the vanishing of coefficients off the +filter are linear equations over $\Q(\psi,\eta)$. In a finite-dimensional +space, finitely many of these equations cut out their full common +kernel. The constructed complex vector has a nonzero coefficient at +a squarefree index $D_0$ of the filter, so this coefficient functional +is nonzero on some algebraic vector in that kernel. Choose such a +vector. It remains orthogonal to unary theta series: at good primes +their eigenvalues have absolute value $p+1$, whereas the prescribed +eigenvalues have absolute value at most $2\sqrt p$ by Hasse's bound +\citep[Section~2, Lemma~2.1, and Corollary~5.2]{Purkait2012}. + +We use \citet[Corollary~2, pp.~483--484]{Waldspurger1981} to compare +Fourier coefficients. Its hypothesis (H1) holds for every nonzero +classical eigenspace used here, by Proposition~2 of that paper. +The final paragraph of the corollary's proof removes (H2) when the +indices lie in the same local squareclass at every level prime. +Our filters retain this condition at~$2$ as well as at the odd primes. + +Let $u$ be an automorphism of $\overline\Q$ acting by an odd power $e$ +on the $2$-power characters, and put $\nu=\eta^{(e-1)/2}$. The +coefficient conjugate $g^u$ and coefficient twist $g\otimes\nu$ have +exactly the same character and good Hecke system, since +\[ + \psi\nu^2=\psi\eta^{e-1}=\psi^e, + \qquad \eta\nu^2=\eta^e. +\] +They may be compared at a common level supported on $S$, in the same +good Hecke eigenspace $W$, and both have a nonzero $D_0$-coefficient. +Let $\ell_n:W\to\C$ denote the $n$th Fourier-coefficient functional. +Waldspurger's corollary applies to every $f\in W$ and gives +\[ + \ell_D(f)^2=C_D\ell_{D_0}(f)^2, +\] +where $C_D$ is independent of $f$. If $C_D=0$, then $\ell_D=0$. +Otherwise choose $c_D\in\C$ with $c_D^2=C_D$ and factor the identity +as +\[ + (\ell_D-c_D\ell_{D_0})(\ell_D+c_D\ell_{D_0})=0. +\] +The polynomial ring on $W$ is an integral domain, so one factor +vanishes identically. Thus the two coefficient functionals are +proportional on the whole space, including oldvectors and linear +combinations. In particular the two forms have the same ratio of +their $D$- and $D_0$-coefficients. + +It follows, for $\xi=a(D)/a(D_0)$, that +\[ + u(\xi)=\nu(D/D_0)\xi. +\] +The local squareclass conditions imply +$\eta(D/D_0)=z^2$ for a value $z$ in the group of values of $\eta$. +Consequently $u(\xi/z)=\xi/z$ for every $u$, so $\xi/z\in\Q$. +This proves the phase assertion. + +With our characters and period normalization, its identity of +\emph{coefficient squares} is +\begin{equation} + \left(\frac{a(D)}{a(D_0)}\right)^2 + =\psi(D/D_0)\, + \frac{\mathcal L(\sigma D)}{\mathcal L(\sigma D_0)}. + \label{cs:even-square-ratio} +\end{equation} +Here $\psi(D/D_0)=\psi(D)\psi(D_0)^{-1}$ has valuation zero; +the factor $\sqrt{D/D_0}$ in the classical central-value comparison +is incorporated in $\mathcal L$. The local unit +squareclasses at $S$ agree; at a good prime the spherical squarefree +factor is one at both valuations zero and one +\citep[Section~I.3, pp.~377--378]{Waldspurger1981}. +There is consequently no extra product over the prime factors of $D$. +Taking valuations gives Equation~\eqref{cs:even-ratio}, hence +Equation~\eqref{cs:even-value}. The same identity, compared with the +nonzero coefficient at $D_0$, gives the asserted equivalence of +vanishing. The corresponding rational-square statement for central values +is Vign\'eras's rationality theorem, recalled in +\citet[Section~6.3, Theorem~6]{Waldspurger1983}. + +If $E[2]$ is an extension of trivial modules, combine +Equation~\eqref{cs:even-value} with +Theorem~\ref{thm:cyclotomic-bound}. +If $E[2]$ is irreducible, choose a fixed odd fundamental discriminant +$h_*$ of opposite infinite sign, of analytic rank one, whose local +characters agree with those of $h$ at $2N$. Proposition~\ref{prop:rough-nonvanishing} +supplies such a choice. Exclude its prime factors from the filter and +choose its support to avoid the finitely many exceptional genus fields. +The reverse genus comparison in Proposition~\ref{prop:heegner-comparison} +and Theorem~\ref{thm:heegner-genus-bound} give the same lower bound. +These are fixed exclusions and constants, proving +Equation~\eqref{cs:even-lower-bound} in both cases. +\end{proof} + +\subsection{Odd coefficients from reduction of Heegner traces} + +The odd construction combines reduction of Heegner points with the ternary +quadratic forms attached to definite quaternion orders. We use Deuring's +reduction correspondence in the oriented form of Cornut--Jetchev, +together with the Eichler-order and ternary-form description of +Jetchev--Kane \citep{Deuring1941,CornutJetchev2013,JetchevKane2011}. +The weights below retain the genus character and the local orientations, +so that the resulting Fourier coefficients recover the reduced genus sum +at finite precision. + +Fix now a nonempty filter of odd functional sign. Choose an odd fundamental +$h_*$ of opposite infinite sign, with $L(E^{(h_*)},1)\ne0$, whose local +characters agree with those of $h$ at $2N$. Exclude its primes. We may +choose $|h_*|>3$ and include in its support a prime outside the +exceptional imaginary quadratic discriminants. Thus all genus fields +below have only the units $\{1,-1\}$ and avoid the CM field of $E$. +Write +\[ + k=hh_*<0,\qquad K_D=\Q(\sqrt{k}),\qquad + P_D=P_1(h_*). +\] +The point $P_D$ is the character \emph{sum} of the conductor-one Heegner +point for $K_D$. We fix the modular parametrization $\varphi$ with +$\varphi(\infty)=0$, so the constants in its Hecke and Atkin--Lehner +relations are torsion. At a simple zero of $E^{(h)}$, its free line is that of +$E^{(h)}$, up to the fixed-degree identifications in +Proposition~\ref{prop:heegner-comparison}. +Below, the product derivative means the derivative at $s=1$ of +$L(E^{(h)},s)L(E^{(h_*)},s)$. + +\begin{proposition}[Odd coefficients under a genus-index bound] +\label{prop:odd-coefficients}\label{co:odd} +Assume that a constant $C_*$ satisfies +\begin{equation} + j(P_D)\geq w(D)+\tfrac12s(h)-C_* +\label{cs:odd-bound-hypothesis} +\end{equation} +for every $h$ in the filter with a simple zero. There are arbitrarily +large precisions $M$, good odd primes $\ell$ outside the fixed support, +and holomorphic weight-$3/2$ forms $g_M=\sum a_M(n)q^n$, of level +supported on $S\cup\{\ell\}$, with the following properties. +\begin{enumerate}[label=\textup{(\roman*)}] +\item The additional filter at $\ell$ is +\begin{equation} + (h_*/\ell)=-\sigma,\qquad (h/\ell)=\sigma, + \qquad \rho_T(\Fr_\ell)\equiv C\pmod{2^M}, +\label{cs:detecting-prime} +\end{equation} +where $C$ is the action of a complex conjugation. In particular +$\ell\equiv-1\pmod{2^M}$. +\item After a fixed harmless decrease in the working precision, the +forms satisfy Equation~\eqref{cs:hecke-recurrence} modulo that precision, +with characters $\eta_M,\psi_M$ of $2$-power order and quadratic ratio. +Their squarefree coefficients have the form of a $2$-power phase times +an integer modulo $2^M$. +\item If a coefficient is visible, meaning $v(a_M(D))W. +\] +These choices are uniform over prime realizations with the prescribed +weight bounds. + +The coefficient $B_U[n]$ is zero unless $D$ belongs to the filter. +Within the range just specified, it satisfies +\begin{equation} + v(B_U[n])\geq + w(r)+\frac{\#\{p\in J:p\text{ simple}\}}2-e_U. + \label{tc:coefficient-bound} +\end{equation} +At a split prime $p\in J$, the factor contributed by the difference +operator, after removing its character phase and one factor of $2$, is +\begin{equation} + c_p(D)= + \frac{a_p(E)-(\psi/\eta)(p)(-D/p)-1}{2}\pmod 2. + \label{tc:shell-factor} +\end{equation} +This is independent of the exponent of $p$ in $m$. At a simple prime +$p\in J$, Equation~\eqref{tc:shell-factor} holds for the first shell, +that is, when $p\nmid m$. +\end{lemma} + +\begin{proof} +The good-prime recurrence of Section~\ref{cs:coefficient-systems} expresses +every relevant coefficient in terms of the squarefree coefficient $a(D)$. +After removing the factor $\eta(p)^s$, the multipliers for powers $p^{2s}$ +are determined by +\[ + b_0=1,\qquad + b_1=a_p(E)-(\psi/\eta)(p)(-D/p),\qquad + b_{s+1}=a_p(E)b_s-pb_{s-1}. +\] +If $p\mid D$, the Legendre symbol in $b_1$ is zero. The recurrences at +different primes commute and their multipliers multiply. + +For $p\in U/J$ the difference operator contributes +$b_s-b_{s-1}$, with $b_{-1}=0$. Here $p\mid D$, so $b_1=a_p(E)$ is +even. Modulo $2$ the sequence alternates between $1$ and $0$, and every +such difference is odd. For $p\in J$ we have $p\nmid D$; now $b_0$ +and $b_1$ are odd and every $b_s$ is odd. The difference +$b_{s+1}-b_s$ is therefore even. + +For the more precise assertion at a split prime put +$a=a_p(E)$ and $\kappa=(\psi/\eta)(p)(-D/p)\in\{1,-1\}$. +Since $E[2]$ is rational over $\mathbf F_p$, +$a\equiv p+1\pmod4$. If $\Delta_s=b_{s+1}-b_s$, the recurrence gives +\[ + \Delta_{s+1}=a\Delta_s-p\Delta_{s-1}\quad(s\geq1). +\] +Every $\Delta_s$ is even, whence +$\Delta_{s+1}\equiv\Delta_{s-1}\pmod4$. Directly, +\[ + \Delta_1-\Delta_0 + =a^2-a\kappa-2a+2\kappa+1-p\equiv0\pmod4. +\] +Thus $\Delta_s/2\equiv(a-\kappa-1)/2\pmod2$ for every $s$. +For a simple prime this last formula is still the defining calculation +at $s=0$, which is all that will be required. + +Put $d_U=\lceil\delta+w(U)\rceil$. Whenever the sharp squarefree +bound $v(a(D))\ge\delta+w(D)$ is available, the factors just computed +give at least one further factor of $2$ for each $p\in J$. Hence +\[ + v(B_U[n])\ge \delta+w(D)+\#J-d_U + =w(r)+\frac{\#\{p\in J:p\text{ simple}\}}2-e_U. +\] +For an allowed squarefree class this expression is integral, since +$\delta+w(D)$ is integral. Its only possible negative value before +this parity condition is imposed is $-1/2$, so it is nonnegative. +For the even source the sharp bound holds at every squarefree index, +which proves all-index integrality and the displayed estimate. + +For the odd source, let $u_0$ bound $w(U)$. Every prime in $U$ is a +nonroot, so $\#U\le2u_0$ and the normalizing exponents $d_U$ are +bounded. Proposition~\ref{prop:odd-coefficients} gives a constant +$C$ such that at every admissible squarefree index +\[ + v(a_M(D))\ge\min\{M,w(D)-C\}. +\] +This includes the case of zero product derivative, when the coefficient +vanishes modulo $2^M$. Choose $W$ above the prescribed tested weights +and so large that $W-C-d_U>K$ for all permitted $U$. By +Lemma~\ref{cs:fixed-weight-uniformity}, on an ultrafilter-large set +of stages the sharp squarefree bound holds simultaneously for every +$D$ with $w(D)\le W$. Take an arbitrarily high stage in this set, +with precision exceeding all the fixed normalizations, the first-shell +tests, and $\delta+W+2u_0$, and such that $M-d_U\ge K$ +for every permitted $U$. + +The recurrences and operator identities for this source hold modulo +the working precision. Their multipliers are integral, so iteration +through any square exponent leaves errors in the same precision ideal. +After dividing by $2^{d_U}$, the possible error has valuation at least +$M-d_U$. Thus the sharp calculation above is valid throughout the +bounded range. Outside that range the same calculation with the coarse +squarefree bound gives +\[ + v(B_U[n])\ge + \min\{M-d_U,\,w(D)-C+\#J-d_U\}\ge K. +\] +This proves integrality at every index of the actual form, while +asserting the sharp estimate only on the specified bounded range. +There is no restriction on the number of weight-zero root factors. +Coefficients excluded by the filter are zero. Every removed phase +is a value of $\eta$, hence a unit reducing to $1$ at the chosen +prime above $2$. +\end{proof} + +At equality, the normalized leading coefficient is $A(D)$ times the +displayed shell factors. In particular it is zero when $A(D)=0$. +For the odd source this assertion is used for the finite stabilized +symbol evaluations realized at the chosen stage. All omitted-prime +comparisons use the same source $g$ and minimum $\delta$. + +In later coefficientwise divisions, choose $K$ to cover the largest +additional division and the desired final divisibility. If a least-weight +argument also requires all lower-weight symbols to vanish, that condition +holds simultaneously on an ultrafilter-large set: a failure would select +a bounded-weight sequence contradicting the stabilized minimum. Intersect +that set with the one in the lemma. The bounded range then supplies the +sharp calculation and any required zero symbols; the coefficients beyond +the cutoff already have all the necessary factors of $2$. Consequently +all coefficientwise divisions and vanishings used below hold on actual +integral forms at one chosen stage for each finite collection of tests. +No stage is required to work for every unbounded configuration. + +\subsection{Removing unary coefficients} + +The coefficient bound identifies the terms that can survive at the +lowest valuation. For matching $U$ in the rational-torsion case, these +lie on finitely many square classes. Subtracting the corresponding unary +theta series will permit one further integral division by $2$. + +Suppose first that $E(\Q)[2]\ne0$. There are then no root primes. +For matching $U$, define +\begin{equation} + \begin{split} + \Theta_J&= + \sum_{\substack{m>0\\(m,\prod_{s\in S}s)=1}} + \eta(m)\chi_{-4}(m)^i m\,q^{Jm^2},\\ + H_U&=\frac12\left(B_U- + \sum_{\substack{J\subseteq U\\J\text{ split only}}} + B_U[J]\Theta_J\right), + \end{split} + \label{tc:unary-subtraction} +\end{equation} +where $i\in\{0,1\}$ is chosen so that $\eta\chi_{-4}^i$ is odd. +For opposite $U$, set $H_U=B_U$. Except where a further division is +explicitly made in Lemma~\ref{tc:minimum-transfer}, in the irreducible +case we also set $H_U=B_U$. + +\begin{lemma} +\label{tc:unary-integrality} +The form in Equation~\eqref{tc:unary-subtraction} is integral. Each +$\Theta_J$ is a weight-$3/2$ unary theta form with character +\[ + \eta\chi_{-4}^i(-J/\cdot), +\] +whose new level primes are the primes of $J$, each to exponent one. +Its character differs from $\psi_U$ by a quadratic character. +\end{lemma} + +\begin{proof} +In matching parity the right side of +Equation~\eqref{tc:coefficient-bound} can be zero only if $r=1$ and +$J$ consists of split primes. At these indices +Equation~\eqref{tc:shell-factor}, together with the odd squared-index +multipliers at primes outside $U$, gives +\[ + B_U[Jm^2]\equiv B_U[J]\eta(m)\pmod2. +\] +The coefficient of $\Theta_J$ at $Jm^2$ has precisely this residue: +the common phase $\eta(m)$ is retained on both sides, while +$\chi_{-4}(m)^i m$ is an odd integer. Thus this is divisibility by +$2$, not merely by $\mathfrak m$ in a ramified coefficient ring. +Different squarefree $J$ have disjoint such supports. The numerator in +Equation~\eqref{tc:unary-subtraction} is consequently divisible by $2$ +coefficientwise. + +Put $\beta=\eta\chi_{-4}^i$, and let $\beta_0$ be its primitive +inducing character, of conductor $r$ supported on $S$. The unary +theta transformation \citep[Section~2, p.~2]{Purkait2012} gives +\[ + \Theta_J^0=\sum_{m>0}\beta_0(m)m q^{Jm^2} + \in S_{3/2}\bigl(4r^2J,\beta_0(-4J/\cdot)\bigr). +\] +Removing the terms with $s\mid m$ applies +$1-s\beta_0(s)\mathsf V_{s^2}$, where +$\mathsf V_{s^2}=\mathsf V_s^2$. Thus +\[ + \Theta_J=\prod_{s\in S} + \bigl(1-s\beta_0(s)\mathsf V_{s^2}\bigr)\Theta_J^0. +\] +Writing $P_S=\prod_{s\in S}s$, every term in this product has theta +parameter $Jd^2$ for some $d\mid P_S$. The same transformation formula +places all terms at level $4r^2JP_S^2$, with character +$\beta_0(-4J/\cdot)$ on the units of that level. This is the displayed +character $\eta\chi_{-4}^i(-J/\cdot)$. Since $J$ is prime to $S$, +each fresh prime in $J$ still occurs in the level to exponent one. +Finally $\psi_U/\eta$ is quadratic, as is +$\chi_{-4}^i(-J/\cdot)$, proving the last assertion. +\end{proof} + +\subsection{Weight-two traces} + +We next express coefficient tests as traces of Galois representations. +The trace identities will give relations among the tests; the +level-prime identity will compare a test with the one obtained by +omitting a prime. + +Multiply the integral half-integral-weight form under consideration by +\[ + \theta=1+2\sum_{m\geq1}q^{m^2}. +\] +This produces a weight-two modular form with the same reduced expansion. +Choose a finite extension of $\Qtwo$ containing all coefficient fields +and character values needed at the fixed level, and denote its ring of +integers and maximal ideal by $\mathcal O$ and $\mathfrak m$. + +The characteristic-zero decomposition by the Hecke operators away from +the level supplies commuting operators +\[ + t(u),\ d(u),\qquad u\in G_{\Q}, +\] +by taking the traces and determinants of the corresponding +two-dimensional Galois representations. For cuspidal systems these +are the weight-two representations of Deligne; for Eisenstein systems +they are the sums of the two defining characters. At a good arithmetic +Frobenius, $t(\Fr_q)$ is the ordinary weight-two $T_q$, and the +determinant is the cyclotomic character times the diamond character. +We use the existence and good-prime compatibility of these representations +in their characteristic-zero form +\citep[\S3, (3.9)--(3.12), and Theorem~4.9]{Deligne1969}, and +local-global compatibility +\citep[Theorem~(A), \S0.7]{Carayol1986}. +We take the contragredients of the cohomological representations in these +references, so arithmetic Frobenius has trace $a_q$ and determinant $q$ +times the diamond eigenvalue. + +Here is a precise integral framework for the reductions that follow. +Take the finite-dimensional sum of these characteristic-zero systems, +retaining their multiplicity spaces, that contains the vector under +consideration and its diamond transforms. Its integral Fourier lattice +is finite over $\mathcal O$: finitely many coefficients already give an +injective map of this space, and the lattice embeds in the corresponding +finite free $\mathcal O$-module. Good Hecke operators preserve integral +expansions. Diamonds do so as well. For the subtracted vector this last +claim follows from the formula +\[ + \langle u\rangle H_U + =\psi_U(u)H_U+ + \frac12\sum_J B_U[J] + \bigl(\psi_U(u)-\eta(u)\chi_{-4}(u)^i(-J/u)\bigr)\Theta_J: +\] +each parenthesis is zero or twice a unit. The same observation applies +after multiplying by $\theta$. + +Traces at arbitrary Galois elements are limits of good Frobenius traces +on this finite lattice. Indeed, continuity gives a common finite +quotient at any prescribed accuracy, and Chebotarev gives a good prime +in each required conjugacy class. Its size is unrestricted, and it may +avoid any specified finite list of indices and primes. This proves +integrality of all the traces and determinants used below, not only of +the good Hecke operators with which the construction began. + +Let $\mathcal T$ be the resulting commutative operator algebra on the +reduced orbit of the vector. Equality means equality of every Fourier +coefficient after any further indicated operator products. We retain +this algebra, including its possible nilpotents. + +\begin{lemma}[Trace identities and fresh-prime tests] +\label{tc:trace-algebra}\label{co:traces} +In this reduced operator algebra, +\begin{equation} + d(u)t(v)=t(v),\qquad + t(u)t(v)=t(uv)+t(uv^{-1}),\qquad t(1)=0. + \label{tc:trace-identities} +\end{equation} +A coefficient of a product of traces can be tested by replacing its +arguments with Frobenius elements at distinct fresh primes avoiding +the coefficient index. If the index is $n$ and those primes are +$q_1,\ldots,q_a$, the test is the reduced coefficient at +$nq_1\cdots q_a$. Determinants may be applied first. +\end{lemma} + +\begin{proof} +For a weight-two form $f$, the good-prime formula is +\[ + (T_qf)[n]=f[qn]+q(\langle q\rangle f)[n/q]. +\] +When $q\nmid n$ the second term is absent. Choosing the successive +test primes distinct and avoiding $n$ proves the coefficient assertion. +Chebotarev and continuity, on the finite lattice just described, allow +these choices for arbitrary trace arguments at any required accuracy. + +All the diamond characters are of $2$-power order. On a form with one +character its determinant therefore reduces to the identity. For a +subtracted vector the displayed diamond formula leaves, in addition, +only unary contributions $\Theta_J\theta$. A fresh trace kills each +such contribution modulo $\mathfrak m$: its coefficient test has +index $nq$ with $q\nmid nJ$, and cannot have the squarefree part $J$. +The same argument applies after any further tests. This proves +$d(u)t(v)=t(v)$. + +For two invertible $2$-by-$2$ matrices the characteristic-zero identity +is +\[ + \tr(A)\tr(B)=\tr(AB)+\det(B)\tr(AB^{-1}). +\] +Apply it to every characteristic-zero system and use the determinant +identity just proved. Finally, $t(1)=2$ before reduction. +\end{proof} + +The bounds of Lemma~\ref{tc:shell-bound} are particularly well suited to +these tests: an added prime contributes its nonnegative weight, and +additional root primes contribute no weight. A zero established by +one of these bounds consequently remains zero after all the further +tests used here. In the moving-precision case all the preceding +constructions are made at the actual fixed level of the chosen stage. +The required divisibility is uniform at the specified weight cutoff; +continuity is used only in a finite-dimensional space at that stage. + +The only level-prime identity we need is the following. We distinguish +the weight-two operator $\mathsf U_p^{(2)}$ from the earlier +half-integral-weight notation, although both extract $p$-multiples in +their respective Fourier expansions. + +\begin{lemma}[Inertia and a level operator] +\label{tc:inertia-identity}\label{co:inertia} +For $p\in U$, choose a place over $p$, an inertia element $\tau_p$ +on which the ramified quadratic character is $-1$, and a corresponding +arithmetic Frobenius lift $\phi_p$. On the characteristic-zero space +under consideration, before reduction, one has +\begin{equation} + \mathsf U_p^{(2)} + \bigl(t(g\tau_p\phi_p)-t(g\phi_p)\bigr) + =d(\phi_p)\bigl(t(g\tau_p)-t(g)\bigr). + \label{tc:exact-level-identity} +\end{equation} +The identity commutes with further good traces. After reduction it +therefore evaluates a difference at coefficient $1$ by the corresponding +difference at coefficient $p$. +\end{lemma} + +\begin{proof} +At $p$ the summands in question are either old from a level omitting +$p$, or have conductor exponent one and primitive ramified quadratic +diamond character. For the former the representation is unramified, +so both trace differences are zero, irrespective of the action of +$\mathsf U_p^{(2)}$ on the old multiplicity space. + +For the latter, local-global compatibility identifies the local +representation with a principal series with one unramified and one +ramified character; its monodromy is zero. In a basis of these two +lines write +\[ + \rho(\tau_p)=\begin{pmatrix}1&0\\0&-1\end{pmatrix}, + \qquad + \rho(\phi_p)=\begin{pmatrix}\lambda&0\\0&\mu\end{pmatrix}. +\] +The level eigenvalue is $\lambda$, the Frobenius eigenvalue on the +unramified line, and $d(\phi_p)=\lambda\mu$. If the lower-right entry +of $\rho(g)$ is $z$, the two trace differences are $-2z\mu$ and +$-2z$, respectively. Both sides of +Equation~\eqref{tc:exact-level-identity} are $-2z\lambda\mu$. +The Eisenstein calculation is the identical calculation on its pair +of characters. Copies old at other primes do not change it. + +These are all the possibilities: the new level has exponent one at +$p$, with ramified quadratic determinant, so the Steinberg case with +unramified determinant does not enter. A unary summand with $p\notin J$ +is old from a level omitting $p$; with $p\in J$ it has the same ramified +quadratic local character. Thus the preceding classification also +covers Equation~\eqref{tc:unary-subtraction}. + +Finally apply Equation~\eqref{tc:trace-identities} to remove the +determinant from the right side after reduction. Taking coefficient +$1$ on the left is taking coefficient $p$ before $\mathsf U_p^{(2)}$. +\end{proof} + +\subsection{Rules when there is rational two-torsion} + +We now apply the common trace identities to the rational-torsion case. +The coefficient bounds first restrict the Galois data on which a symbol +can depend. The level-prime identity then determines how the symbol +changes when one of those data is varied. + +An elementary extension of a number field means a compositum of +quadratic extensions. Whenever a ramification support is specified, +only extensions unramified outside that support are included. For +finite support the resulting elementary extension is finite. Labels +below are Frobenius specifications in these extensions, with a chosen +place when an orientation over $F$ is needed. They always include the +fixed rational local conditions that specify the filter. + +\begin{proposition}[Rational trace and contraction rules] +\label{tc:rational-rules} +Suppose $E(\Q)[2]\ne0$. +\begin{enumerate}[label=\textup{(\roman*)}] +\item For matching $U$, on the subtracted vector $H_U$, +\[ + t(g)t(u)=0\quad(u\text{ split}). +\] +The trace on split elements factors through the elementary extension +of $F$ supported on $S\cup U$. For opposite $U$, on $B_U$, every +product of two traces is zero, and traces factor through the rational +elementary extension supported there. +\item If $U\cup\{q\}$ has the parity of the filter, its symbol is +read at coefficient $1$ by $t(\Fr_q)$ on $H_U$ for split $q$, and on +$B_U$ for simple $q$. +\item Fix $p\in U$ and put $g=\Fr_q$. Replacing $g$ by $g\tau_p$ +changes the symbol, additively in $\mathbf F_2$, by +\begin{equation} + A\bigl((U/p)\cup\{q'\}\bigr), + \qquad \Fr_{q'}\sim g\phi_p, + \label{tc:rational-contraction} +\end{equation} +if $p$ and $q$ are not both simple. The label of $q'$ is required +only away from the omitted primes and carries their product labels. +The replacement uses the original source with level support +$S\cup(U/p)$: the \emph{whole rational prime} $p$ is omitted, +including both places over it if $p$ splits in $F$. If both endpoints +are simple, the change is zero. +\item A split vertex with trivial label relative to the level with +that vertex omitted has symbol zero. +\end{enumerate} +\end{proposition} + +\begin{proof} +For matching $U$, two fresh tests, one of them split, add weight at +least $3/2$ to Equation~\eqref{tc:coefficient-bound}. The allowed +valuation is integral, so the numerator has valuation at least $2$. +After the division in Equation~\eqref{tc:unary-subtraction} it still +vanishes modulo $\mathfrak m$; fresh tests kill its unary terms. +For opposite $U$, two nonroot tests add weight at least $1$, leaving +at least $1/2$ after subtracting $e_U$, and hence at least $1$ at an +allowed coefficient. This proves the two product vanishings on the +entire reduced orbit. + +The trace identities show why these vanishings give the stated +elementary quotients. If $u$ is split, apply the identity to +$t(gu)t(u)$ to obtain $t(gu^2)=t(g)$. The subgroup generated by +squares in $G_F$ has elementary quotient, since a group of exponent +two is abelian. In the opposite case the same calculation applies +to every $u\in G_\Q$. Ramification outside the level is absent from +the characteristic-zero representations and remains absent in the +quotient. + +For a split $q$, its added weight is $1$: at coefficient $q$ the +division by $2$ in $H_U$ places the coefficient exactly at the +normalized detection depth. There is no unary term at that index. +For simple $q$, $e_U=1/2$ already gives that depth on $B_U$. +The character phases reduce to $1$, proving (ii). + +For (iii), apply Lemma~\ref{tc:inertia-identity} at coefficient $1$, +so that its left side is a coefficient-$p$ test. Replace its trace +arguments by fresh primes with Frobenius $g\tau_p\phi_p$ and +$g\phi_p$. Put $V=U/p$. For $X=U,V$, set +$n_X=\lceil\delta+w(X)\rceil$ and let $m_X$ be one in matching +parity and zero otherwise. After a fresh +trace kills the unary terms, the shell multiplier relative to the +omitted-source test is +\[ + 2^{1+n_V-n_U-m_U+m_V}c_p(D'), + \qquad D'=Vq',\quad \Fr_{q'}\sim g\phi_p. +\] +The exponent is zero for split $p$, and also for simple $p$ with +matching $U$. It is one for simple $p$ with opposite $U$, precisely +the simple--simple case. This checks all integer divisions in the +contraction rule. For simple $p$ only the first shell is used. +The change $\psi_U/\psi_V=(p/\cdot)$ is already included in that +shell calculation; all remaining phases reduce to one. + +In the first three cases the shell is therefore $c_p(D')A(D')$. +Both fresh Frobenius elements have the same image in the omitted +source: that source is built from the original modular form, the same +$\eta,\psi,\delta$, and the operators at $V$, so it is unramified at the entire rational prime +$p$. Inertia at either place over $p$ acts trivially on its symbol. +The ramified quadratic coordinate of $\tau_p$ reverses the Legendre +sign in $c_p$, whose additive change is one. The difference of the +two shell values is consequently $A(D')$, proving +Equation~\eqref{tc:rational-contraction}. + +If both primes are simple, their residual images are the same +transposition, so $g\phi_p$ is split. The shell now has positive +valuation after normalization and contributes zero. Finally (iv) +is (ii) with $t(\Fr_q)=t(1)=0$ in the relevant elementary quotient. +\end{proof} + +The contraction rules control changes in existing vertices. The next +calculation gives a way to add two simple vertices while preserving the +symbol. + +\begin{proposition}[Insertion of a pair of simple primes] +\label{tc:simple-twins} +Suppose $E(\Q)[2]\ne0$ and $U$ has matching parity. Let a rational +elementary label, relative to $S$ and all existing split vertices, +be realized by a simple prime $q$ with +\[ + \#E(\mathbf F_q)\equiv2\pmod4. +\] +Inserting two fresh simple primes with this same label leaves $A(U)$ +unchanged. Their mutual simple-edge label, and their labels against +other simple vertices, do not affect this assertion. +\end{proposition} + +\begin{proof} +First test $t(\Fr_q)^2$ on matching $H_U$. The weight-two Hecke +formula at coefficient $1$ gives, after reduction, +\[ + H_U[q^2]+q(\langle q\rangle H_U)[1]. +\] +Only the $J=1$ unary term can contribute at $1$ or $q^2$. +Write $b=B_U[1]$, $\epsilon=\chi_{-4}(q)$, and +$\kappa=(\psi_U/\eta)(q)$. Substituting +Equation~\eqref{tc:transformed-recurrence} and the two characters in +Equation~\eqref{tc:unary-subtraction}, the preceding expression is +the reduction of +\begin{equation} + b\,\frac{\eta(q)}2 + \left(a_q(E)+\kappa(q-\epsilon) + -q\epsilon^i(1+\epsilon)\right). + \label{tc:twin-calculation} +\end{equation} +For $q\equiv3\pmod4$ the parenthesis divided by $2$ is +$a_q(E)/2$ modulo $2$. For $q\equiv1\pmod4$ it is +$a_q(E)/2+1$. In either case it equals +$(q+1-a_q(E))/2=\#E(\mathbf F_q)/2$ modulo $2$. +Since $b$ reduces to $A(U)$, this proves that the squared trace +has coefficient $(\#E(\mathbf F_q)/2)A(U)$. + +By Lemma~\ref{tc:trace-algebra}, replace the two copies of this +trace by distinct fresh primes realizing the same operator tests. +Their product coefficient reads the symbol with the two primes +inserted. To pass to any other pair with the labels in the +statement, vary one prime at a time. After omitting that simple +prime the opposite-parity test of +Proposition~\ref{tc:rational-rules} depends only on rational +elementary labels. Its changes against other simple primes are +zero by the simple--simple case of the same proposition. Thus +only the fixed support and existing split labels need be matched. +Fresh intermediate primes can match both old and new finite +specifications, so that no collision of vertices is required. +The assumed odd value of $\#E(\mathbf F_q)/2$ completes the proof. +\end{proof} + +\subsection{An elementary character on root elements} + +Assume now that $E[2]$ is irreducible. Its image is either cyclic +of order three or $S_3$. The reduced trace algebra need not be a +field: the order-two units below can have nontrivial nilpotent +parts. We therefore retain the algebra, rather than replacing it +by its residue field. + +\begin{lemma}[Root character] +\label{tc:root-character} +On matching $B_U$ one has $t(u)=0$ for every nonroot $u$. +On opposite $B_U$ one has $t(u)=0$ for split $u$ and +$t(g)t(u)=0$ for two simple elements. In either parity, +\[ + t(u)^2=1\quad(u\text{ a root}). +\] +The traces factor through an extension of $\Gal(F/\Q)$ by an +elementary kernel over $F$. Moreover, there is a multiplicative +character $\alpha:G_\Q\longrightarrow\mathcal T^\times$ into the +reduced trace algebra, unramified outside $S\cup U$, such that +\[ + \alpha(u)^2=1\quad\text{for all }u, + \qquad t(u)=\alpha(u)\quad(u\text{ a root}). +\] +In particular $\alpha$ factors through a rational elementary +extension with that ramification support. +\end{lemma} + +\begin{proof} +The trace vanishings follow from +Equation~\eqref{tc:coefficient-bound}. In matching parity, one +nonroot test adds at least $1/2$ and hence gives an integral +valuation at least $1$. In opposite parity, either a split test +or two simple tests add at least $1$, again leaving positive +integral valuation after the loss $e_U=1/2$. + +For a root test, use the same fresh prime $q$ twice, avoiding the +coefficient index, rather than two distinct primes. The weight-two +Hecke formula and Equation~\eqref{tc:transformed-recurrence} give +the identity operator modulo $\mathfrak m$: $a_q(E)$ is odd, and +the middle quadratic-character term cancels the diamond term +modulo $2$. This proves $t(u)^2=1$ by continuity for every root +$u$. For completeness, it suffices to check indices prime to the +chosen $q$; each particular index permits such a choice of $q$ +with the prescribed finite trace data. + +Since split traces vanish in both parities, +$t(gu^2)=t(g)$ for $u\in G_F$. Thus the traces factor through +the quotient by the squares of $G_F$. At any fixed accuracy the +trace action is on a finite lattice modulo $\mathfrak m$, so we +may work in a finite quotient +\[ + 1\longrightarrow H\longrightarrow\Gamma + \longrightarrow\Gal(F/\Q)\longrightarrow1 +\] +with $H$ elementary abelian. Choose an order-three lift $R$ of a +rotation. Such a lift exists because the inverse image of the +order-three subgroup is an extension by a finite $2$-group. +The trace identity with the identity element gives +$t(R)=t(R^{-1})=t(R^2)$. Applying it to $R,R^2$ gives +$t(R)t(R^2)=t(1)+t(R^{-1})=t(R)$; the left side is $1$. +Hence +\[ + t(R)=t(R^2)=1. +\] + +For $a\in H$ set +\[ + \alpha(a)=t(aR)=t(aR^2). +\] +The equality follows from $t(a)=0$ and the trace identity with +$R$. Conjugacy invariance by an element $b\in H$ implies that +$\alpha$ is unchanged on multiplying its argument by +$bR(b)^{-1}$. It therefore factors through the coinvariants +$H/[H,R]$. Also it is invariant under conjugation by $R$. +The trace product now gives +\[ + \alpha(a)\alpha(b) + =t(aR)t(bR) + =t\bigl(aR(b)R^2\bigr)+t(ab^{-1}) + =\alpha\bigl(aR(b)\bigr) + =\alpha(ab). +\] +The last equality uses the coinvariant invariance just proved; +the split term is zero. Since $aR$ is a root, +$\alpha(a)^2=1$. + +For cyclic residual image, this already extends to $\Gamma$ by +setting $\alpha(R)=1$. For $S_3$, choose a transposition lift +$s$ normalizing $\langle R\rangle$. It can be obtained from any +transposition lift by conjugating its order-three complement by +an element of $H$. Thus $sRs^{-1}=R^{-1}$ and $s^2\in H$. +Conjugacy of traces shows that $\alpha$ on $H$ is invariant +under $s$. In both parities we have $t(s)t(sR)=0$, either because +each factor is zero or by the two-simple product rule. Its trace +identity reads +\[ + 0=\alpha(s^2)+t(R)=\alpha(s^2)+1. +\] +Therefore the extension defined by $\alpha(s)=1$ respects the +relation for $s^2$, as well as conjugation and the relations in +$\langle R\rangle$. It is the required multiplicative +order-two character, and agrees with the trace on both root +cosets. At the fixed stage, choose one common finite quotient +through which the traces and residual representation factor, and +pull back the character constructed there. No canonical choice +across quotients is needed. Unramifiedness outside the level is preserved. +\end{proof} + +\subsection{Irreducible deletion rules and minimal labels} + +The root character replaces products of root traces by a single +multiplicative value. We now combine that fact with the level-prime +identity to compute changes at nonroot vertices. The last lemma applies +these rules at the least weight where a symbol is nonzero. + +The \emph{total root label} is the product of the rational elementary +labels of all root primes being used. It includes the fixed-support +conditions and the rational quadratic labels against the active +nonroot vertices. Its discriminant coordinate is trivial in the +quadratic quotient of $S_3$; for cyclic residual image there is no +such coordinate. + +\begin{proposition}[Irreducible substitution rules] +\label{tc:irreducible-rules} +Suppose $E[2]$ is irreducible. +\begin{enumerate}[label=\textup{(\roman*)}] +\item On matching $B_U$, coefficient $1$ of a product of root +traces reads $A$ on the union of $U$ and those roots. It depends +on the roots only through their total rational elementary label +relative to $S\cup U$. Any finite collection of roots, including +the empty collection, may be replaced in this test by one virtual +root with that label. +\item Changing the Legendre bit of that root against a split +vertex $p$ has additive derivative equal to deletion of $p$, +with its rational labels away from $p$ transferred to the total +root label. Changing the root bit against a simple vertex has +derivative zero. +\item To vary a simple vertex $q$, omit it and use opposite +$B_V$, retaining the other root probes. At another simple +vertex $p$, choose Frobenius lifts $g$ and $\phi_p$ for $q$ and +$p$. If their transposition images are different, the derivative +under $g\mapsto g\tau_p$ deletes both $p$ and $q$ and transfers +their rational labels to the root total. If their transposition +images are equal, the derivative is zero. +\item In the test in (iii), variation at a split $p$ is given by +the first-shell factors $c_p$ times symbols of merged +configurations whose weight is one less. It consequently +vanishes whenever all symbols of that lower weight vanish. +\end{enumerate} +All these assertions preserve every specified label at the other +vertices, and use the chosen place for inertia and Frobenius. +\end{proposition} + +\begin{proof} +Root primes have weight zero. Thus the fresh-prime tests at +coefficient $1$ of matching $B_U$ are precisely the normalized +coefficients defining $A$. Lemma~\ref{tc:root-character} makes +the product of root traces equal to the value of $\alpha$ on +their total elementary label. A rotation survives every +compatible elementary specification: an elementary quotient +cannot eliminate the order-three subgroup, and in the $S_3$ +case the only compatibility condition is its trivial image in +the quadratic quotient. Chebotarev therefore supplies the +claimed single virtual root, even for the empty total label. + +For (ii), apply Lemma~\ref{tc:inertia-identity} with $g$ a root. +If $p$ is split then $g\phi_p$ is a root. The coefficient with +$J=\{p\}$ has zero cost in +Equation~\eqref{tc:coefficient-bound}; its first shell is +$c_p$ times the symbol with $p$ deleted. The latter is +unramified at $p$ and is the same in the two tests, while $c_p$ +changes by $1$. Multiplication of Frobenius labels by $\phi_p$ +is exactly the transfer of the deleted vertex's rational labels +to the root. If $p$ is simple, $g\phi_p$ is simple, and its +weight $1/2$ plus the $1/2$ contributed by $J$ puts the shell +above the testing depth. The derivative is then zero. + +For (iii), $e_V=1/2$. When the two transpositions differ, +$g\phi_p$ is a rotation, and the $1/2$ contribution from the +simple prime in $J=\{p\}$ exactly cancels $e_V$. The shell +again equals $c_p$ times the omitted-$p$ symbol, now with both +simple vertices removed and their product represented by a +root. The Legendre flip proves the asserted derivative. +For equal transpositions their product is split; its additional +weight $1$ forces the shell to vanish. + +Finally, if $p$ is split and $g$ simple, then $g\phi_p$ is +simple. The $p$-shell is at the first-shell depth and is +expressed by Equation~\eqref{tc:shell-factor} with +$D'=(V/p)q'$ and the retained root probes. Its nonroot weight +is +\[ + w(V)-1+\frac12 + =\left(w(V)+\frac12\right)-1. +\] +This is one less than the original weight. In particular both +shell terms vanish when symbols of that weight vanish. The +comparison omitting $p$ is unramified there. Root probes can +be matched on the rational elementary support throughout, +which proves the final label assertion as well. +\end{proof} + +At the least nonzero weight, every lower-weight term in the preceding +rules vanishes. This removes the dependence on internal edge labels; +the remaining assertion keeps both the fixed-support labels and the +total root label. + +\begin{lemma}[Transfer at the least nonzero weight] +\label{tc:minimum-transfer} +Suppose $E[2]$ is irreducible, and let $m$ be the least weight +of an index on the filter with nonzero symbol. At weight $m$, +the dependence on each nonroot vertex is only through its +oriented rational Frobenius lift in the Galois group over $\Q$ +of the maximal elementary extension of $F$ unramified outside $S$, together with the +requirement on the total root label. In particular, replacing +the nonroot vertices by fresh vertices with those same +fixed-support labels preserves the symbol, irrespective of +their internal edge labels, provided the root total is matched. +The assertion allows simultaneous changes using disjoint +intermediate configurations. +\end{lemma} + +\begin{proof} +Every symbol of weight less than $m$ is zero. For a simple +vertex, Proposition~\ref{tc:irreducible-rules} therefore makes +its inertia derivatives at every other active nonroot vertex +zero: different transpositions give a lower-weight deletion, +equal transpositions give zero directly, and a split vertex +gives a lower-weight merged configuration. Its labels against +root vertices are immaterial by the simple case of the root +derivative rule. These statements hold for conjugates of +inertia too, because the Frobenius and inertia calculation is +made at a chosen place and may be conjugated. Starting with +the elementary extension over $F$ supported on $S\cup V$, +killing the inertia at the active vertices leaves exactly +fixed-support elementary labels. This proves the assertion +for a simple vertex. + +For a split vertex $q$, let $V$ be the other nonroot vertices, +so $w(V)=m-1$ and $V$ still has matching parity. We first claim +that $B_V$ is divisible by $2$ integrally. In +Equation~\eqref{tc:coefficient-bound}, an entry of cost zero +has $r$ consisting only of roots and $J$ consisting only of +split primes. Its underlying squarefree class has weight +\[ + w(V)-\#J1$, the sum of $(N\mathfrak q)^{-s}$ over prime ideals of +residue degree greater than one is at most $2\sum_p p^{-2s}$, which +stays bounded as $s\downarrow1$. The corresponding sum over the ray +class diverges. Hence that class contains infinitely many degree-one +primes. Outside the fixed ramification support these give split rational +primes, and finite exclusions remove finitely many choices. + +At an old inert prime, prescribe instead the norm of the residue in +$\mathbf F_{p^2}^\times$. Its norm onto $\mathbf F_p^\times$ is +surjective. For a new simple vertex all conditions are rational +congruences, including the inert class in $F$; the Chinese remainder +theorem and Dirichlet's theorem apply. Successive selection realizes the +whole graph. Reciprocity determines reverse bits, since the support +Hilbert symbols are fixed and only the two endpoint residues remain. +Taking norms gives \eqref{gr:norm}, with no extra independent condition. + +The same construction applies to a product template. It preserves its +support data and its residues at every remaining vertex; no internal +residue is imposed on the replacement. For a simple cluster use rational +congruences for the norm labels. To check the rational filter in a split +cluster, write $\pi=\prod_i\pi_i$ and $\pi'=ab\pi$ for its replacement. +The multiplier $ab$ is a square unit at $S_F$ and positive at real places. +Consequently +\[ + N\pi=(\prod_i p_i)u,\qquad N\pi'=q u +\] +have the same signed rational $S$-unit $u$: its valuations and sign agree. +Thus $q/\prod_i p_i=N(ab)$ is locally square at the rational support. +The condition at $2$ also identifies $q^*$ with $\prod_i p_i^*$ in the +fixed tests. This verifies preservation of the norm correction. + +Finally, compare two disjoint realizations of the same graph. Insert +fresh bridge vertices with matching bits to both realizations and replace +vertices one at a time. The omitted-vertex Frobenius tests agree by the +radical description above, so the symbol values agree. A preliminary +bridge removes any overlap. This proves both graph dependence and +invariance under the product replacements. +\end{proof} + +Consequently, fixing the vertex types gives a well-defined function +$A_{\mathcal G}$ of the independent forward edge bits: choose any prime +realization of the graph $\mathcal G$ and evaluate its coefficient +symbol. Lemma~\ref{gr:realization} makes the result independent of that +choice. We will write its unique multilinear polynomial as $P$. +Equation~\eqref{gr:first-contraction} says that a derivative of $P$ +evaluates the contracted graph. + +A split vertex is \emph{primary} if its generator is a square unit at +every finite place of $S_F$ and positive at every real place. The principal +ray class realizes such types. Reciprocity makes their fixed radical +labels trivial, and their signed rational contributions are squares in the +fixed tests. Including stationary vertex primes in those tests makes +primary incidences to them neutral. Including the support of a quadratic +discriminant $k$ ensures that every primary prime splits in +$\mathbf Q(\sqrt{k})$. + +Two symbols may use different fixed-support tests or read only rational +norm labels from this same graph. We call these \emph{compatible +projections} when they forget fixed-label coordinates or take norm data, +preserve primary vertices, and commute with the +omitted-vertex product substitution. In the norm projection either +oriented-bit toggle changes the rational bit once. Thus one physical +edge difference induces the specified difference for each symbol; it +need not give the same polynomial for both symbols. + +\begin{definition}[Witnesses and permitted partitions]\label{gr:partitionable} +A \emph{witness} is a finite graph with symbol $1$. A graph is +\emph{partitionable} if it admits a partition into nonempty clusters, each +containing at most one simple vertex, and oriented contraction trees whose +contracted graph is a witness. The contraction trees are part of the data; +this definition makes no assertion about a Selmer group. +\end{definition} + +For a two-isogenous curve with quadratic field $F'=\mathbf Q(E'[2])$, +a simple vertex is \emph{good} if it is inert in both $F$ and $F'$. +A \emph{donor} is split in $F$ and inert in $F'$. Attaching a donor +turns a simple vertex split in $F'$ into a good one. These are conditions +on finite labels; their supply will be established in the arithmetic +application. + +\subsection{Forests as finite-difference operators} + +For an edge bit $z$, put $\Delta_z f=f|_{z=0}+f|_{z=1}$. +Every function on a finite binary cube has a unique multilinear polynomial +over $\mathbf F_2$; $\Delta_z$ is its formal derivative. Differences +therefore commute and satisfy $\Delta_z^2=0$. + +\begin{lemma}[Oriented forests]\label{gr:forest} +Assume the contraction, isolation, and omitted-prime assertions of +Theorem~\ref{thm:symbol-rules}. Differentiation along a tree contracts +it, adding product labels and external incidences; the result is zero if +the tree contains two simple vertices. A collection of edge variables +containing a cycle has zero derivative, including when its orientations +are incompatible. The two oriented variables on one pair form a cycle +of length two. +\end{lemma} + +\begin{proof} +The one-edge rule is the symbol contraction identity, with product +replacement supplied by Lemma~\ref{gr:realization}. Induction contracts +a tree: split--split mergers remain split, split--simple mergers remain +simple, and merging two simple components gives zero. A root orientation +determines all relative orientations along the tree. Its product template +uses support types and external bits, not the differentiated internal bits. + +For the two variables on a split pair $p,q$, differentiate first in one +inertia bit over $p$. The resulting symbol omits the \emph{entire rational +prime} $p$, so its elementary extension is unramified at both places over +$p$. The derivative in the other oriented bit is zero. Repeated use of +the same variable gives zero by $\Delta_z^2=0$. + +For a longer cycle, contract a spanning path. The closing edge becomes +internal to one cluster and changes neither its support label nor an +incidence to a remaining vertex. The omitted-endpoint argument just given +therefore kills its derivative. Conjugating the product only changes its +orientation; it does not restore the omitted endpoint or create a +self-residue. + +For example, after contracting aligned edge $12$, the two bits from its +product to vertex $3$ are +$t_0=z_{13}^0+z_{23}^0$ and $t_1=z_{13}^1+z_{23}^1$, up to fixed type +corrections. An aligned edge $23$ differentiates $t_0$. The closing +edge $31$ differentiates either $t_0$ again, giving zero, or $t_1$, giving +the omitted-endpoint zero. Every longer cycle reduces to these cases. +Further differences commute with this zero derivative. +\end{proof} + +Call the original vertices \emph{terminals}; any stationary external +vertices retain their types and incidences. Fix their vertex types and a +realizable baseline graph. Write $z=(z_e)$ for the independent toggles of +the terminal--terminal bits, and let $P(z)$ be the terminal symbol. +A \emph{network} adjoins primary vertices and specified incidences +involving them. It adds no terminal--terminal edge: the original bits +$z$ remain parameters. All unspecified primary incidences are neutral. +Within each network fix a consistent orientation at each terminal. +Different networks may use different alignments. + +Write $y=(y_e)$ for the bits on the added incidences, and let $f(z,y)$ +be the symbol of the enlarged graph. We shall express $f(z,\mathbf1)$ +as a finite-difference operator applied to $P(z)$. The differences in +$y$ first contract the added graph; the forest rule then expresses each +surviving term as differences in the original variables $z$. + +For example, join one primary vertex $r$ to two permitted terminals +$a,b$, in a fixed alignment. Expanding in its two added incidences gives +four terms. The term with no difference is zero because $r$ is isolated. +Each one-edge difference contracts $r$ onto one terminal and leaves the +original symbol $P$, so these two terms cancel in $\F_2$. The two-edge +tree contracts the terminal pair and gives $\Delta_{z_{ab}}P$. +Thus this path acts exactly as the terminal difference +$\Delta_{z_{ab}}$. The path has two added edges, but its operator has +contraction degree one. In general, a component meeting $t$ terminals +has terminal contraction degree $t-1$. + +The lowest two operator degrees can be read from a matrix. Index the +internal primary vertices by $I$, let $e_{ij}$ be their internal edge +bits, and let $c_a$ be the incidence column from them to terminal $a$. +The grounded Laplacian is the symmetric matrix over $\F_2$ with +\[ + Q_{ij}=e_{ij}\quad(i\ne j),\qquad + Q_{ii}=\sum_{j\ne i}e_{ij}+\sum_a(c_a)_i. +\] +Equivalently, +\begin{equation}\label{gr:grounding-dictionary} + Q\mathbf1=\sum_a c_a. +\end{equation} +Thus prescribed off-diagonal entries and terminal columns realize a +given symmetric $Q$ precisely when this row-sum identity holds. For the +one-primary-vertex path above, $Q=(0)$ and $c_a=c_b=(1)$. + +The coefficients below are instances over $\F_2$ of the all-minors +matrix-tree theorem \citep[\S1, Equation~(2)]{Chaiken1982}; we include +the incidence-matrix proof needed here. + +\begin{lemma}[Network expansion]\label{gr:network} +A network satisfies $f(z,\mathbf1)=\mathcal N P(z)$, where +$\mathcal N$ is a sum of terminal finite-difference operators indexed by +forests. In each surviving forest term, every component containing an +internal primary vertex meets a terminal. A component meeting $t$ +terminals has contraction degree $t-1$; +a component containing two simple terminals acts as zero. Networks with +disjoint internal vertices and no edges between them multiply as operators +on the same $P$. In particular, degree greater than $\deg P$ annihilates it. + +For the grounded Laplacian $Q$ and terminal columns $c_a$ defined above, +the constant +and the pair-contraction coefficients are +\begin{equation}\label{gr:forest-coefficients} + \det Q,\qquad c_a^{\mathsf t}\operatorname{adj}(Q)c_b\quad(a\ne b). +\end{equation} +The latter multiplies the terminal difference in the selected alignment; +a prohibited pair multiplies the zero operator. +\end{lemma} + +\begin{proof} +For the set $E_0$ of added incidences, keep the terminal variables $z$ +fixed and expand in the variables $y$: +\[ + f(z,\mathbf1)=\sum_{T\subseteq E_0}(\Delta_T^y f)(z,\mathbf0). +\] +Lemma~\ref{gr:forest} removes cycles. A component meeting no terminal +contracts to an isolated primary vertex, so isolation removes it, including +an untouched primary vertex. In a surviving component the primary labels +and external primary bits are trivial. Its contracted label and external +incidences are thus exactly those obtained by contracting its terminals +in the original graph. A terminal tree with the same relative orientations +gives that operator, of degree $t-1$. + +Expanding two disjoint networks gives composition: product labels agree +in either order, and any resulting cycle vanishes. Polynomial +differentiation then proves the degree bound. This reasoning also verifies +compatibility with projections at every degree. Norms commute with +oriented products, primary norm corrections are neutral, and either +oriented toggle induces its rational toggle on the original terminal +polynomial. Repeated projected differences or prohibited simple mergers +give zero. Forgetting fixed-label coordinates commutes with the same +products. + +For the coefficients, write the Laplacian of the added network as +$L=DD^{\mathsf t}$, +where each incidence column has ones at its edge endpoints. Let $I$ and +$A$ be the internal and terminal sets. Cauchy--Binet for $Q=L_{I,I}$ +counts edge sets whose incidence matrix becomes invertible after deleting +the terminal rows. They are exactly forests with one terminal in each +component: cycles give dependent columns, a component with no deleted row +gives dependent rows, and a tree with one row deleted is invertible by +leaf removal. These are the degree-zero terms. + +Apply Cauchy--Binet instead to row set $I\cup\{a\}$ and column set +$I\cup\{b\}$. Each component must contain one root from each of +$A\setminus\{a\}$ and $A\setminus\{b\}$. Thus $a,b$ lie together +and every other terminal lies in its own component. The corresponding +minor is +\[ + \det\begin{pmatrix}Q&c_b\\c_a^{\mathsf t}&0\end{pmatrix} + =c_a^{\mathsf t}\operatorname{adj}(Q)c_b. +\] +The corner is zero because there is no added terminal--terminal edge. Signs +disappear in characteristic two, and the adjugate identity remains valid +when $Q$ is singular. +\end{proof} + +\subsection{Selecting one address} + +An \emph{address} is $x\in\mathbf F_2^b$, where $b\ge1$. +A vertex with activation $\lambda\in(\mathbf F_2^b)^*$ is present +when $\lambda(x)=1$. Fix a nonzero target $x_*$ and an edge bit $z$ +joining terminals $a_0,a_1$ active there. Either all terminals are always +present, or all have nonzero linear activations with at least one terminal +for each nonzero linear form. For one symbol we need a derivative as the leading term at $x_*$ and +a constant term $1$ elsewhere. For two symbols we must also account for +a derivative allocated to just one factor; the second network includes +a binary parameter for this purpose. We construct these two networks by +prescribing their constant and degree-one terms; the final degree count +will remove every higher term. + +Choose a dual basis $\lambda_1,\ldots,\lambda_b$ with +$\lambda_i(x_*)=1$ for every $i$. Indeed, start with +$\lambda_1(x_*)=1$ and add it to a basis of the annihilator of $x_*$. +Make $b$ groups of three primary vertices, with all three vertices in +group $i$ activated by $\lambda_i$. The physical coordinate vectors index +these actual vertices. In each three-dimensional coordinate space choose +a computational basis $(e_i,u_i,v_i)$ with $e_i=(1,1,1)$. Prescribe a +symmetric form $Q$ by making the $e_i$ orthonormal and orthogonal to all +$u_j,v_j$, and using on the remaining coordinates +\begin{equation}\label{gr:H} + H(T,B)=\begin{pmatrix}0&T\\T^{\mathsf t}&B\end{pmatrix}. +\end{equation} +Convert this form to its matrix in the physical vertex coordinates, +which we also denote by $Q$. Write $Q_J$ for the restriction to the +physical coordinates in groups $J$. + +The column $h_i=Qe_i$ represents the covector dual to $e_i$. Since the +coordinate changes do not mix groups, $h_i$ is supported on group $i$; +it is independent of $T,B$. Attach this incidence column to a terminal +of activation $\lambda_i$, or to any fixed terminal in the stationary +case. When the active groups are $J$, the sum of these anchor columns is +\[ + \sum_{i\in J}h_i|_J=Q_J\mathbf1_J, +\] +since $\mathbf1_J=\sum_{i\in J}e_i$. Use the off-diagonal physical +entries of $Q$ as the internal edge bits. Equation~\eqref{gr:grounding-dictionary} +then gives the prescribed diagonal as well: the anchors make the actual +grounded Laplacian equal to $Q_J$ at every address, even after groups +have disappeared. + +Also attach the same column $c$ to $a_0,a_1$. If their moving activations +$\alpha,\beta$ differ, attach it to a terminal of activation +$\alpha+\beta$ as well. The additional column sum is always zero: +\[ + \bigl(\alpha(x)+\beta(x)+(\alpha+\beta)(x)\bigr)c=0. +\] +The third terminal is absent at $x_*$. Equal activations, or two stationary +terminals, require only the first two columns. Coincident terminal roles +mean addition of columns. Hence these attachments preserve the grounding +at every restriction. + +Write $O_{\ge d}$ for a sum of contraction operators of degrees at least +$d$. This denotes a filtration, not a numerical estimate. +Figure~\ref{gr:selector-figure} depicts the group-level cycle and path +used in the two programs when $b=4$. + +\begin{figure}[tbp] +\centering +\setlength{\unitlength}{1mm} +\begin{picture}(115,36) +\put(15,28){\circle{6}}\put(15,28){\makebox(0,0){$1$}} +\put(40,28){\circle{6}}\put(40,28){\makebox(0,0){$2$}} +\put(40,8){\circle{6}}\put(40,8){\makebox(0,0){$3$}} +\put(15,8){\circle{6}}\put(15,8){\makebox(0,0){$4$}} +\put(18,28){\vector(1,0){19}}\put(40,25){\vector(0,-1){14}} +\put(37,8){\vector(-1,0){19}}\put(15,11){\vector(0,1){14}} +\put(27.5,0){\makebox(0,0){Cycle}} +\put(75,28){\circle{6}}\put(75,28){\makebox(0,0){$1$}} +\put(100,28){\circle{6}}\put(100,28){\makebox(0,0){$2$}} +\put(100,8){\circle{6}}\put(100,8){\makebox(0,0){$3$}} +\put(75,8){\circle{6}}\put(75,8){\makebox(0,0){$4$}} +\put(78,28){\vector(1,0){19}}\put(100,25){\vector(0,-1){14}} +\put(97,8){\vector(-1,0){19}} +\put(87.5,0){\makebox(0,0){Path}} +\end{picture} +\caption{The off-diagonal patterns of $T-I$ for the two programs when +$b=4$. The vertices represent groups, not the individual primary +vertices of the network. A proper group restriction breaks the cycle; +the path from $1$ to $4$ survives only when every group is present.} +\label{gr:selector-figure} +\end{figure} + +\begin{lemma}[Two address programs]\label{gr:programs} +With these activations and grounding, there are the following networks: +\begin{enumerate} +\item A singular program $\mathcal S$ such that +\[ + \mathcal S_{x_*}=\Delta_z+O_{\ge2},\qquad + \mathcal S_x=1+O_{\ge1}\quad(x\ne x_*). +\] +\item Two nonsingular programs on the same sites, indexed by +$\varepsilon\in\mathbf F_2$, such that +\[ + \mathcal N_x^{(\varepsilon)}=1+O_{\ge1},\qquad + \mathcal N_x^{(1)}+\mathcal N_x^{(0)} + =\begin{cases}\Delta_z+O_{\ge2},&x=x_*,\\ + O_{\ge2},&x\ne x_*. + \end{cases} +\] +\end{enumerate} +All new sites have nonzero activation and are absent at $0$. +Unspecified incidences, including those to stationary external vertices, +may remain neutral. +\end{lemma} + +\begin{proof} +For the first program, take $T=I+P$, with $P$ the cyclic permutation +matrix, and let $B$ be diagonal with exactly one nonzero entry. Every +proper principal restriction of $P$ is a union of directed paths, hence +nilpotent. Thus $T_J$ and $H(T_J,B_J)$ are invertible for proper $J$, +including the empty restriction, whose determinant is $1$. + +On all groups, $\ker T$ and $\ker T^{\mathsf t}$ are spanned by +$\mathbf1$. A radical vector of $H$ has $v=t\mathbf1$; summing +$T^{\mathsf t}u+Bv=0$ gives $t=0$, since +$\mathbf1^{\mathsf t}B\mathbf1=1$. Hence $Q$ has radical generated +by $r=\sum_i u_i$. Its adjugate is $rr^{\mathsf t}$: it is nonzero +of rank one, symmetry identifies its factors with the kernel, and the +only nonzero scalar in $\mathbf F_2$ is $1$. + +Take $c$ dual to $u_1$, so $c^{\mathsf t}r=1$. All anchors annihilate +$r$. At $x_*$ the only terminal columns pairing nontrivially with $r$ +are therefore those of $a_0,a_1$. Formula~\eqref{gr:forest-coefficients} +gives constant zero and precisely $\Delta_z$ in degree one. Every other +address has a proper group subset and constant $1$, since the activation +forms form a basis. For $b=1$, $T=0$ and $B=(1)$ give the same radical. + +For the second program take $T=I+L$, where $L$ is the consecutive lower +shift, and $B_\varepsilon=\varepsilon E_{bb}$. Every group restriction +of $T$ is invertible, and +\begin{equation}\label{gr:inverse} + H(T,B)^{-1}= + \begin{pmatrix}T^{-\mathsf t}BT^{-1}&T^{-\mathsf t}\\ + T^{-1}&0\end{pmatrix}. +\end{equation} +Again take $c$ dual to $u_1$. On groups $J$, the change in +$c^{\mathsf t}Q_J^{-1}c$ is $((T_J^{-1})_{b1})^2$, interpreted as +zero if an endpoint is absent. The expansion +$(I+L_J)^{-1}=I+L_J+L_J^2+\cdots$ shows that this is $1$ exactly +when the entire path $1,\ldots,b$ survives, namely at $x_*$. +Pairings with anchors do not change, since $Q_J^{-1}h_i=e_i$ and +$e_i,h_i,c$ are independent of $\varepsilon$. At the target the +balancing terminal is absent, leaving only the changed pair $a_0,a_1$. +All determinants are $1$. Lemma~\ref{gr:network} proves the assertion, +also for the single-vertex path $b=1$. +\end{proof} + +\subsection{Simultaneous units on a punctured cube} + +The preceding programs control only two degrees of their operators. +To make this sufficient, at each address we spend exactly the degree +of a chosen top monomial. Any additional contraction then vanishes. +For two symbols, the same accounting uses the ordinary product of their +top homogeneous parts. The multiplication is performed before imposing +the Boolean relation $z^2=z$, so one occurrence of $z$ in each factor +remains two contraction requirements. + +\begin{theorem}[Address lemma]\label{gr:address} +Assume the contraction, isolation, and whole-prime omission rules of +Proposition~\ref{tc:rational-rules}, or the same rules for another +symbol, together with the realization freedoms of +Lemma~\ref{gr:realization}. Let $b\ge1$ and +consider either of the following terminal arrangements: +\begin{enumerate} +\item One symbol on a nonempty set of always active terminals, whose +polynomial in the independent pair bits is nonzero. +\item One or two symbols on terminals with nonzero linear activations, +including a terminal for every nonzero linear form. At each $x\ne0$, +each symbol separately is a nonzero polynomial in the active bits. +The symbols may have stationary external data and may read compatible +projections of a common graph. +\end{enumerate} +At every $x\ne0$, assume that the active terminal data and the stationary +external data obey each required filter. Then finitely many primary +auxiliaries with nonzero linear activations, and one realizable assignment +of graph bits, make all the symbols $1$ at every $x\ne0$. No auxiliary +is present at $0$. All may satisfy fixed splitting and neutral-incidence +conditions included in their primary type. + +A nonzero evaluation or a nonzero iterated edge difference suffices for +the polynomial hypothesis. In particular, a partition as in +Definition~\ref{gr:partitionable} suffices in the stationary case. +\end{theorem} + +\begin{proof} +Fix a common realizable baseline for the terminal bits and regard their +toggles as variables; omit variables invisible to a symbol. A nonzero +iterated difference implies a nonzero polynomial, while every nonzero +polynomial has a top monomial with coefficient $1$. By +Lemma~\ref{gr:forest}, this also proves the assertion about partitions. + +For one symbol, let $P_x$ have degree $d_x$ at $x\ne0$ and choose a +monomial of degree $d_x$ with coefficient $1$. For each of its variables +adjoin a separate singular program targeted at $x$, all with disjoint +internal vertices. At address $x$, its own $d_x$ programs have zero +constant, so they consume at least $d_x$ contraction degrees. Any extra +degree from any program kills $P_x$. Only the selected degree-one terms +of these programs and the constants of the others survive, giving the +chosen coefficient $1$. A nonzero constant polynomial needs no program. +Stationary anchors give the same argument for always active terminals. + +For two symbols, write their polynomials at $x$ as $P_x,R_x$, of degrees +$d_x,e_x$. Multiply their top homogeneous parts in the ordinary ring +$\mathbf F_2[z_1,\ldots,z_m]$, before imposing Boolean relations. +This ring is a domain, so choose a coefficient $1$ at a monomial +\begin{equation}\label{gr:chosen-monomial} + M_x=\prod_z z^{\nu_{xz}},\qquad + \nu_{xz}\in\{0,1,2\},\qquad + \sum_z\nu_{xz}=d_x+e_x. +\end{equation} +For each exponent two add one singular program targeted at $x$; for +each exponent one add one nonsingular program, with its own parameter +$\varepsilon_{xz}\in\mathbf F_2$. Keep all internal sets disjoint. +Let +\[ + \Phi(\varepsilon)=\prod_{x\ne0} + (\text{final value of }P_x)(\text{final value of }R_x). +\] +We show that $\sum_\varepsilon\Phi(\varepsilon)=1$, which implies +that one choice makes every factor $1$. + +Expand the operators by contraction degree. At its target a singular +program has zero constant in both factors, so it consumes at least one +degree in each. A nonsingular program has constant $1$ independent of +its parameter. Summing that parameter cancels a term using only its +constants everywhere; a surviving term must consume at least one degree +somewhere for that program. The total of these minimum costs is +\begin{equation}\label{gr:budget} + D=\sum_{x\ne0}(d_x+e_x). +\end{equation} +A nonzero term cannot consume more, since some factor would then be +differentiated beyond its degree. Every surviving term therefore uses +each minimum cost exactly. + +Thus a singular program contributes precisely $\Delta_z$ in each factor +at its target and constants elsewhere. A nonsingular program contributes +degree one in exactly one factor. Summing its parameter kills that +contribution away from its target and gives $\Delta_z$ at the target; +every other occurrence contributes the common constant $1$. In +particular, no higher forest coefficient remains. + +At one address put $Z_i=\{z:\nu_{xz}=i\}$ for $i=1,2$, and write +$z_J=\prod_{z\in J}z$. The surviving allocation sum is +\[ + \sum_{J\subseteq Z_1} + [z_{Z_2}z_J]P_x^{\rm top}\, + [z_{Z_2}z_{Z_1\setminus J}]R_x^{\rm top} + =[M_x](P_x^{\rm top}R_x^{\rm top})=1. +\] +Wrong-degree coefficients are zero. Since the total degree is $D$ +and no factor exceeds its degree, each factor receives its full degree; +its derivative is exactly the displayed coefficient, independent of the +baseline. Allocations at distinct addresses are independent, so their +product is $1$. This covers constant factors too. For instance, if +both top forms are $z$, their ordinary product is $z^2$: a singular +program differentiates each once. Boolean reduction would lose that +allocation. + +Choose parameters with $\Phi=1$ and realize the resulting finite graph +by Lemma~\ref{gr:realization}. Primary types preserve the filters and +the stipulated neutral incidences and splitting conditions. Nonzero +linear activations ensure that no new vertex appears at $0$. +\end{proof} + +For a stabilized symbol this is a finite construction at each dimension. +First choose $b$, the terminal data, and all networks; their weights and +coefficient tests then have a finite bound. Select an actual stage where the numerical bounds and the finitely many stabilized symbol +evaluations hold for that range. The required precision may +grow with $b$. The unit-valuation constant, however, is the constant of +the coefficient construction and must be independent of $b$; the forest +argument supplies no additional uniformity assertion. diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/08-rational-converse.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/08-rational-converse.tex new file mode 100644 index 0000000000000000000000000000000000000000..15a333ca073b129123173b545fdb0c29a25cba3a --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/08-rational-converse.tex @@ -0,0 +1,936 @@ +\section{The converse with rational two-torsion}\label{pw:section} + +We prove the pointwise converse for curves with $E(\Q)[2]\ne0$. +The finite graph construction supplies binary families with a unit coefficient +at every nonzero address. Cyclotomic interpolation settles the even case. +For the odd case we first establish the missing lower bound for the moving +coefficient system, then keep one nonvanishing quadratic companion fixed +throughout the interpolation. + +Fix such a curve $E/\Q$. We use the prime weights $w(h)$, normalized values +$\mathcal L(h)$, and finite $2$-primary Shafarevich--Tate lengths $s(h)$ +from the preceding sections. The corank $c_2(E^{(h)})$ is a different +quantity: a corank-zero base has finite $s(h)$ before analytic +nonvanishing is known. All new primes are odd primes of good reduction. +A filter fixes the real sign and the local unit squareclasses at a finite +support containing $2N$, and may exclude any further fixed finite set. + +For a signed parameter $h$, write $A(h)$ for the symbol at the positive +index $|h|$ on its chosen filter. We will use two bounds attached to a +unit coefficient: +\begin{align} + A(h)=1\text{ in the even system}\quad&\Longrightarrow\quad + L(E^{(h)},1)\ne0,\qquad v(\mathcal L(h))\le 2w(h)+C, + \label{pw:even-unit-interface}\\ + A(h)=1\text{ in the odd system}\quad&\Longrightarrow\quad + a(E^{(h)})=1,\qquad j(P_h)\le w(h)+C. + \label{pw:odd-unit-interface} +\end{align} +Here $P_h$ is the genus Heegner sum with a fixed analytic-rank-zero +partner $h_*$, and $j(P_h)$ is its free-line index valuation. +The first bound is available from the even coefficient construction and +Theorem~\ref{thm:cyclotomic-bound}. We use the second only after +Proposition~\ref{prop:rational-odd-bound} has supplied the arithmetic lower +bound required to normalize the odd system. +The contraction and isolation identities are those of +Theorem~\ref{thm:symbol-rules}; their finite graph consequences were proved +in Section~\ref{gr:section}. + +Write $j_h(k)=j(P_{|h|}(h))$ for the ring-class index over $K=\Q(\sqrt{k})$. +Theorem~\ref{thm:heegner-ring-bound} states that, if +$k<0$ is an odd fundamental discriminant with $(k,2Nh)=1$, has at most +$A$ prime factors, is square at $2Nh$, and defines a nonexceptional +imaginary field, and the twists $h,hk$ have analytic +orders one and zero, then +\begin{equation}\label{pw:ring-lower-interface} + 2j_h(k)\ge4w(h)+s(h)+s(hk)-C_{E,A}. +\end{equation} +All coefficient and interpolation constants depend on the fixed curve, +its parametrization, and fixed local data. A bound on $\omega(k)$ may +enter $C_{E,A}$; the sizes of its primes do not. The finite networks, +required coefficient precision, and prime sizes may depend on the binary +dimension. The unit bounds in Equations~\eqref{pw:even-unit-interface} +and~\eqref{pw:odd-unit-interface} may not. + +By Lemma~\ref{pr:invariance}, an isogeny preserves analytic rank and +Selmer corank. If the isogeny class contains a curve with full rational +two-torsion, we use that curve. Otherwise choose a rational two-isogeny $E\to E'$ and write +$F=\mathbb Q(E[2])$, $F'=\mathbb Q(E'[2])$; both fields are quadratic. +A prime split in $F$ is called split, and one inert in $F$ is called simple. +Their weights are respectively $1$ and $1/2$. A simple prime is good if it +is also inert in $F'$. At such a prime +\begin{equation}\label{pw:good-simple} + \#E(\mathbb F_p)\equiv2\pmod4. +\end{equation} +Indeed there is exactly one nonzero rational two-torsion point in the +reduction. If the group order were divisible by four, its two-primary +subgroup would contain a rational point of order four. Its image under the +two-isogeny would supply on $E'$ a rational two-torsion point different from +the dual kernel, contradicting inertness in $F'$. Thus the good-twin rule +applies. When $F=F'$, every simple prime is good. + +\subsection{Seeds and finite supplies}\label{pw:seeds-section} + +The word ``label'' below means an individually realizable fixed-support +elementary Frobenius label, with orientations when required. It does not +include a self-residue of a prime generator. All contractions and +comparisons are those of Theorem~\ref{thm:symbol-rules} and +Lemma~\ref{gr:forest}. + +\begin{lemma}[Minimum seeds]\label{pw:minimum-seeds} +\begin{enumerate} +\item In an all-split alphabet, suppose a unit symbol has a nonempty +witness. At the least positive vertex count $r$ of such a witness, all +mutual edge bits are immaterial. The symbol is determined by the individual +fixed-support labels. This remains true if the empty configuration is a +unit, provided no contraction to the empty configuration is used. +\item In the quadratic case, suppose the symbol has a nonzero witness, +the alphabet is closed under the allowed contractions, and it contains +the good twin operations. There are +$r\ge0$ and $s_1\ge1$ such that for every $s\ge s_1$ of the permitted simple +parity, the minimum split count of a unit with $s$ simple vertices is $r$. +At these counts all edge bits are immaterial. A chosen minimum seed may be +padded by arbitrarily many good twin pairs. +\end{enumerate} +The assertions also hold for a stabilized moving odd symbol, with every +particular finite list of uses made at a sufficiently advanced stage. +\end{lemma} + +\begin{proof} +For the first assertion, a derivative in an edge of an $r$-vertex graph is a +symbol on $r-1$ vertices. If $r\ge2$, this graph remains nonempty and has +value zero by minimality. If $r=1$, there is no edge. The omitted-vertex +description then leaves exactly the fixed-support labels. + +For the second assertion let $r(s)$ be the minimum split count at simple +count $s$, with value $+\infty$ when no witness exists. Once a finite value +occurs, good-twin insertion gives $r(s+2)\le r(s)$. A nonincreasing sequence +of nonnegative integers stabilizes. Choose $s_1\ge1$ in that range. A +derivative of an edge with a split endpoint reduces the split count and +preserves the simple count; it is therefore zero at the minimum. A +simple--simple derivative is zero by the symbol rule. Twin insertion gives +the last assertion. + +For the moving system, take the minimum and the nonincreasing sequence in +the stabilized profile. Each comparison just used involves bounded vertex +counts. A failure on an ultrafilter-large set of stages at any one such bound +would produce a bounded-weight sequence contradicting that minimum. Thus +any fixed finite collection holds on an ultrafilter-large intersection of +stages, from which an arbitrarily high stage may be chosen. No assertion +about every sufficiently high stage, or about all unbounded counts at one +stage, is needed. +\end{proof} + +Recall that a list is partitionable when a permitted contraction forest +has a unit symbol as its output. Its terminal polynomial is then nonzero, +since the indicated iterated finite difference is nonzero. + +\begin{lemma}[Finite label reserves]\label{pw:reserves} +Fix a minimum seed and a finite label alphabet. +\begin{enumerate} +\item In the all-split rational alphabet, a list with the same total label +as the seed and sufficiently many copies of its labels is partitionable. +\item In the quadratic alphabet, retain $r$ split anchors with the seed +labels. Suppose there are sufficiently many simple vertices of the required +parity and sufficiently many split reserves of each realizable rational +shift. If $F\ne F'$, also suppose +\begin{equation}\label{pw:donor-balance} + \begin{aligned} + \Delta={}&\#\{p:\ p\text{ split in }F\text{ and inert in }F'\}\\ + &-\#\{p:\ p\text{ inert in }F\text{ and split in }F'\}>C_0. + \end{aligned} +\end{equation} +Here $C_0$ depends only on the anchors and the reserves. Then all other +split vertices can be attached to simple vertices so that the result is +the minimum seed and good twin pairs. The twins may match a prescribed +finite enrichment of the rational labels. The base simple labels may be +specified on any projection on which the required total agrees. +\end{enumerate} +All reserve requirements depend only on the finite alphabets, seed, and +projection. They do not depend on the original list length. +\end{lemma} + +\begin{proof} +In the first case retain the first $r-1$ seed labels and merge all other +vertices to the last cluster. Sufficient copies ensure that this cluster +is nonempty. Its label is forced by the total, hence is the last seed +label. Lemma~\ref{pw:minimum-seeds} makes its unknown edges immaterial. + +For the second case, the rational labels of split attachments form the +subgroup with trivial $F$-coordinate. They act transitively on the simple +coset, so every prescribed change of a simple label has a realizable split +shift. Reserve sufficiently many representatives of every such shift. +Remove these reserves and the anchors from the donor pool. If $F\ne F'$, +\eqref{pw:donor-balance}, with $C_0$ exceeding the number removed, leaves a +distinct donor for each bad simple vertex. Attach these donors; every +simple vertex is now good. If $F=F'$, this operation was unnecessary. + +Pair equal enriched good labels. By withholding a bounded number of pairs, +leave between $s_1$ and $s_1+C_1$ unpaired vertices, with the correct parity; +$C_1$ depends only on the number of enriched labels. Use reserved shifts +to turn the excess unpaired vertices into good pairs and to set the first +$s_1-1$ base positions to the desired seed labels. The seed labels +themselves need not all be good. Attach every remaining nonanchor split +vertex to the last base position. Its projected label is forced by the +total, the anchors, the other base positions, and the twin pairs. It is +the required last seed label. Each cluster contains one simple vertex, +so every contraction is permitted. Only a bounded number of reserve +shifts was used. + +When incidences to a retained split anchor are needed only to remove twins, +they can be prescribed after the contracted labels are fixed, by the +independent terminal-edge realization. Fixed stationary vertices instead +enter the finite label enrichment from the outset. These two uses do not +increase the number of label types with the original list length. +\end{proof} + +\begin{lemma}[Neutral packets]\label{pw:packets} +For any of the finite reserve problems above with prescribed rational total +zero, one can choose a finite packet of terminal labels with rational total +zero such that every nonempty union of copies of the packet has the required +supplies. In the quadratic case with $F\ne F'$, its donor surplus may +be made arbitrarily large. Compatible fixed splitting conditions may be +included whenever +the needed individual labels and shifts remain realizable. +\end{lemma} + +\begin{proof} +Choose ample copies of every required label, including anchors and shifts. +When the quadratic fields $F,F'$ are distinct, add enough donors to +exceed all the losses from the other labels and the prescribed reserve +margin. When $F=F'$, every simple vertex is already good. Duplicate every +full label in the resulting list. Duplication gives total zero in every +rational elementary coordinate and preserves any strict donor surplus. +Choose the margins so that after reserving the finitely many anchors in +any one packet, the union of any positive number of packets still meets +the reserve requirements. All labels are realized by distinct fresh +primes; duplication never means repeating an actual prime factor. +\end{proof} + +\subsection{The even converse and its uniform estimate} +\label{pw:lower-section} + +\begin{proposition}[Even original base]\label{pw:even-base} +If $c_2(E)=0$, then $a(E)=0$. +\end{proposition} + +\begin{proof} +Parity gives even functional sign. Fix an even symbol on the filter of $1$, +including all auxiliary class-group tests. If its value at $1$ is a +unit, analytic nonvanishing is already detected. Otherwise use a +nonempty minimum seed in the full-torsion case, or a stabilized quadratic +seed in the other case. + +For each $b$, assign a neutral packet from Lemma~\ref{pw:packets} to +every nonzero linear form on $\mathbb F_2^b$, and activate its primes +by that form. At every nonzero address at least one packet is active; +their union satisfies the reserve problem and has a nonzero terminal +polynomial. At zero no terminal is active. The single-symbol case of +Theorem~\ref{gr:address} adds primary auxiliaries and makes the symbol a +unit at every nonzero address. All local classes remain those of $1$. +Equation~\eqref{pw:even-unit-interface} gives the uniform bound at all +nonzero vertices. Theorem~\ref{thm:cyclotomic-interpolation}, applied +at the original corank-zero base, now gives $a(E)=0$. +\end{proof} + +\begin{proposition}[Partitionable even estimate]\label{pw:partitionable-even} +Fix an even unit symbol on a prescribed filter. For every +partitionable parameter $h$ on its filter with $c_2(E^{(h)})=0$, +\begin{equation}\label{pw:partitionable-bound} + \mathcal L(h)\ne0,\qquad v(\mathcal L(h))-2w(h)-s(h)\le C. +\end{equation} +The constant depends only on the symbol and fixed local data. +\end{proposition} + +\begin{proof} +If the parameter has no prime factors, the only contraction is the identity, +so partitionability means that the empty symbol itself is a unit. +Equation~\eqref{pw:even-unit-interface} +then proves the assertion directly. Otherwise the stationary terminal +set is nonempty. +Keep the prime factors of $h$ stationary. The iterated edge difference +along the defining contraction forest is $1$, so their terminal polynomial +is nonzero. The stationary one-symbol case +of Theorem~\ref{gr:address} gives arbitrarily large binary cubes based at +$h$, with only primary new primes, whose other addresses have unit symbol. +Equation~\eqref{pw:even-unit-interface} and $s(h_x)\ge0$ give the uniform +upper bound required by the cyclotomic transfer. The base corank is zero, +so Theorem~\ref{thm:cyclotomic-interpolation} gives \eqref{pw:partitionable-bound}. A base-dependent +dimension threshold does not affect the asserted constant. +\end{proof} + +\subsection{The lower bound needed for odd coefficients} + +The even estimate also supplies the arithmetic hypothesis of +Proposition~\ref{prop:odd-coefficients}. For an already analytic-rank-one +parameter $h$, we choose a companion $k'=k'(h)$ with boundedly many prime +factors and estimate the central value at $hk'$. Comparing the ring and +genus Heegner sums then bounds $j(P_h)$ from below. The companion in this +argument may vary with $h$; the odd coefficient system has not yet been +normalized. + +To compare the two fixed isogenous curves $E,E'$, add subscripts to +$s,w,\mathcal L$. At a parameter $h$ already known to have analytic rank +zero, both twists have finite Tate--Shafarevich groups by the forward +theorem. Cassels's isogeny formula for the arithmetic BSD quotient +\citep{Cassels1965}, as explained in +\citet[Theorem~2.1 and the following discussion]{Tate1966}, gives +\begin{equation}\label{pw:isogeny-weight-comparison} + s_E(h)+2w_E(h)=s_{E'}(h)+2w_{E'}(h)+O_{E,E'}(1). +\end{equation} +Indeed, at an active odd good prime the component-group valuation is +$t_p$ for the corresponding curve, so the active Tamagawa valuations +sum to twice its weight. At the fixed support only finitely many local +twisting classes occur. Differential, period, and torsion ratios are +bounded by the fixed isogeny and its reverse, and the rank-zero regulator +is $1$. These account for the bounded error in +\eqref{pw:isogeny-weight-comparison}. The isogeny identity applies to the +known finite groups and does not assume the BSD value formula. + +The two twists have the same $L$-function. Their fixed normalizing periods +therefore give +$v(\mathcal L_E(h))-v(\mathcal L_{E'}(h))=O_{E,E'}(1)$, uniformly in $h$. +Combining this with \eqref{pw:isogeny-weight-comparison} shows that +$v(\mathcal L(h))-2w(h)-s(h)$ changes by a uniformly bounded amount. +Consequently \eqref{pw:partitionable-bound} transfers in either direction +with one constant, even when the choice between the two fixed isogeny +orientations depends on $h$. + +\begin{lemma}[A bounded companion for a varying odd parameter] +\label{pw:rough-companion} +Fix a positive odd-sign filter and a negative genus partner $h_*$ with +$L(E^{(h_*)},1)\ne0$, chosen using Proposition~\ref{prop:rough-nonvanishing} and then +excluded from the variable parameters. There are constants $A,C$ such that every $h$ on this filter of analytic +order one admits a negative odd fundamental discriminant $k'$ for which +\begin{enumerate} +\item $(k',2Nh)=1$, $k'$ is a square at every place of $2Nh$, and +$\mathbb Q(\sqrt{k'})$ is nonexceptional; +\item $\omega(k')\le A$; +\item $L(E^{(hk')},1)\ne0$ and +\begin{equation}\label{pw:rough-bound} + v(\mathcal L(hk'))\le 2w(hk')+s(hk')+C. +\end{equation} +\end{enumerate} +\end{lemma} + +\begin{proof} +Choose the class-group support and all other fixed label tests before +varying $h$. Prepare an even negative-index symbol for each possible +total type at this support, and for both isogeny orientations if needed. +There are finitely many such preparations. The positive index $|hk'|$ +has nonzero total rational type: its negative-discriminant parity is +already nontrivial among the tests at $2$. Thus in the full-torsion case +a unit seed has positive count. In the quadratic case use the stabilized +seed of Lemma~\ref{pw:minimum-seeds}. + +When $F\ne F'$, interchanging the isogeny orientation interchanges the two +counts in \eqref{pw:donor-balance}. Select the orientation with initial +balance at least zero. The existing donors can then pay for arbitrarily +many existing bad simples. They do not have to be supplied by new primes. + +Let $R$ be the absolute prime-count bound in Proposition~\ref{prop:rough-nonvanishing}. Insert +in $k'$ a finite dummy supply that meets the anchors, minimum simple count, +and reserve requirements for every one of the finitely many prepared +symbols. When the quadratic fields $F,F'$ are distinct, add donor slack +paying for every reserved loss, the new dummy bad simples, and a further +possible loss of $R$ from the later rough factor. Add a fresh ramified +prime if needed to exclude the exceptional +imaginary fields. The number of dummy primes is bounded independently +of $h$. Their labels and initial incidences may be chosen by +Lemma~\ref{gr:realization}. + +Absorb $h$ and the dummy product into the curve. Apply +Proposition~\ref{prop:rough-nonvanishing} to complete $k'$ by a squarefree factor coprime to all +primes already used. Prescribe its sign and its local unit classes so +that the final $k'$ is an odd negative fundamental discriminant, is a +square at $2Nh$, and has the required original local classes at $2N$. +These conditions are reduced congruences at the level of the absorbed +curve. Additional fixed primes may be excluded. The lemma makes the +central value at $hk'$ nonzero with at most $R$ new factors. Its size +threshold may depend on $h$ and all these congruences; $R$ does not. + +No particular resulting unit class at the auxiliary class-group support +was assumed in advance: dummy supplies were prepared for every possible +total there. For the actual total, Lemma~\ref{pw:reserves} makes $hk'$ +partitionable. Analytic nonvanishing gives Selmer corank zero by the +forward theorem. Proposition~\ref{pw:partitionable-even} therefore gives +\eqref{pw:rough-bound}, with the isogeny comparison above if the other +orientation was used. The finite preparation and the bound on dummy and +rough factors give $A,C$ independent of $h$. +\end{proof} + +Proposition~\ref{prop:heegner-comparison} compares the genus sum $P_h$ +with the ring-class sum over $K=\Q(\sqrt{k})$: +\begin{equation}\label{pw:height-ratio} + 2j_h(k)-2j(P_h)=v(\mathcal L(hk))+O(1) +\end{equation} +whenever the two twists have analytic orders one and zero. +The error is uniform in $h$ for fixed $k$, and uniform in $h,k$ when +$\omega(k)$ is bounded and the prescribed local classes are retained. +Thus the same comparison applies to the bounded companions just constructed. + +\begin{proposition}[Uniform lower bound for the odd detector] +\label{pw:odd-lower}\label{prop:rational-odd-bound} +Every analytically rank-one $h$ in the fixed positive filter satisfies +\begin{equation}\label{pw:odd-lower-bound} + 2j(P_h)\ge 2w(h)+s(h)-C. +\end{equation} +In particular $j(P_h)\ge w(h)-C$ uniformly in $h$ and its prime count. +\end{proposition} + +\begin{proof} +Choose $k'$ by Lemma~\ref{pw:rough-companion}. Combine +\eqref{pw:ring-lower-interface}, \eqref{pw:height-ratio}, and +\eqref{pw:rough-bound}. Since the factors are coprime, +$w(hk')=w(h)+w(k')$, and $w(k')\le\omega(k')\le A$. Hence +\begin{align*} + 2j(P_h) + &\ge 4w(h)+s(h)+s(hk')-v(\mathcal L(hk'))-C\\ + &\ge 2w(h)+s(h)-2w(k')-C\\ + &\ge 2w(h)+s(h)-C'. +\end{align*} +Only even symbols and independently nonvanishing companions were used. +Thus this proof precedes, and does not assume, the odd minimum-depth +normalization. +\end{proof} + +\subsection{A fixed companion for the odd converse} +\label{pw:fixed-companion-section} + +Suppose the functional sign is odd. By +Proposition~\ref{pw:odd-lower}, the odd coefficient system can now be +normalized on the positive filter of $1$. Fix its old support and genus +partner $h_*$. Its moving detecting prime $\ell$ has not become an +extra fixed support requirement. + +Choose a separate even symbol for negative discriminants square at $2N$, +excluding the fixed odd support, the relevant torsion ramification, and +the exceptional imaginary fields. Choose a unit $k$ of that symbol. +Then $L(E^{(k)},1)\ne0$. Fix this $k$ and +$K=\mathbb Q(\sqrt{k})$ for the rest of the construction, before choosing any +cube dimension. Its fresh ramification makes it independent of the old +fixed label extensions. At sufficiently advanced stages $\ell$ avoids +$k$. The intrinsic odd label tests continue to omit the primes of $k$. +When the odd symbol already detects the base, the converse follows directly. +We henceforth consider the remaining case, in which the odd symbol has the +nonempty seed described above. + +For the moving odd source, fix its stabilized minimum depth and seed +profiles before constructing packets. A bounded-weight seed has boundedly +many vertices here, since every prime has weight at least $1/2$. For each +fixed field used in the labels, permitting ramification above the one +moving prime $\ell$ adds only boundedly many dimensions to its elementary +squareclass space. Identify these spaces compatibly with their fixed +projections and stabilize the finitely many seed and label profiles. +The reserve bounds of Lemma~\ref{pw:reserves} are uniform over these +profiles, so the packet constructions below have a fixed size. They are +finite tables of labels; their prime representatives will be chosen at +an actual coefficient stage after the networks and their weight bounds +have been specified. + +Our remaining task is to construct, for every binary dimension, a family +in which the odd test at $h$ and an even test at $hk$ are simultaneously +units away from the zero address. Every new prime will split in this +single field $K$. For quadratic $F$, the good-twin rule makes the unit +at $k$ a nonzero even test on additional prime configurations. With full +rational two-torsion, the restriction to $K$-split primes can instead +leave only the empty configuration at the original minimum depth. The +next construction supplies a nonempty witness in exactly that case; +its extra division changes the valuation estimate by a fixed constant. + +\subsection{A nonempty witness with full rational two-torsion} +\label{pw:split-section} + +\begin{lemma}[Recurrence congruences]\label{pw:recurrence} +Let $p$ be odd, $a\equiv p+1\pmod4$, and let +\[ + b_0=1,\quad b_1=a-\kappa,\quad + b_{s+1}=ab_s-pb_{s-1}. +\] +If $\kappa=\pm1$, then $b_{s+1}-b_s$ is even and +\[ + \frac{b_{s+1}-b_s}{2}\equiv\frac{a-\kappa-1}{2}\pmod2 + \quad(s\ge0). +\] +If $\kappa=0$, put $b_{-1}=0$; then $b_s-b_{s-1}$ is odd for every +$s\ge0$. Finally, for $\kappa=1$, if $a\equiv p+1\pmod{2^m}$ then +$b_s\equiv p^s\pmod{2^m}$ for every $s\ge0$. +\end{lemma} + +\begin{proof} +Modulo $2$ the recurrence is $b_{s+1}=b_{s-1}$. Its initial values prove +the parity assertions. For $d_s=b_{s+1}-b_s$, the recurrence for $d_s$ +is the same. Directly, +$d_1-d_0\equiv(p-1)(p-\kappa)\equiv0\pmod4$ when $\kappa=\pm1$. +Thus $d_s/2$ is constant modulo $2$. The last assertion follows by +substituting the sequence $p^s$ in the recurrence and checking its first +two terms. +\end{proof} + +\begin{lemma}[Nonempty $K$-split witness]\label{pw:split-witness} +Suppose $E[2]$ is rational. Choose a negative unit $k$ of a fixed even +symbol for $E$, prime to all previous fixed support and to the ramification +support of $E[8]$. Put $K=\mathbb Q(\sqrt{k})$, chosen nonexceptional. +Let $S_0$ contain $2N$, the primes of $k$, and primes generating the class +group of $K$. On the positive filter of $1$ square at $S_0$, there is an +even unit test on nonempty products of primes split in $K$ with these +properties: +\begin{enumerate} +\item it has a nonempty witness; +\item it satisfies the oriented split contraction and primary-isolation +rules over $K$, for contractions with nonempty output; +\item a unit at $D$ implies +\begin{equation}\label{pw:split-unit-bound} + L(E^{(kD)},1)\ne0,\qquad v(\mathcal L(kD))\le 2\omega(D)+C_k. +\end{equation} +\end{enumerate} +The proof uses Lemmas~\ref{tc:trace-algebra} and~\ref{tc:inertia-identity} +to construct a further divided coefficient test. +\end{lemma} + +\begin{proof} +Let $a_0(n)$ be the coefficients of the original negative-index form for +$E$. Since $k$ attains its least normalized depth, +$v(a_0(|k|D)/a_0(|k|))\ge\omega(D)$ whenever $kD$ lies on its filter. +Use the ordinary even coefficient form for $E^{(k)}$, normalized by +$a(1)=1$, on the positive filter of $1$ square at $S_0$. +The two exact comparisons in Equation~\eqref{cs:even-ratio} give +\[ + 2v(a(D)) + =v\!\left(\frac{\sqrt D\,L(E^{(kD)},1)}{L(E^{(k)},1)}\right) + =2v\!\left(\frac{a_0(|k|D)}{a_0(|k|)}\right). +\] +Indeed, the period and the factor $\sqrt{|k|}$ cancel in the old ratio, +and the new period cancels in the new ratio. Enlarging $S_0$ only +restricts the allowed $D$, so the original minimum still gives +\begin{equation}\label{pw:split-basic-depth} + v(a(D))\ge\omega(D) +\end{equation} +at every allowed squarefree $D$. + +If equality holds at a nonempty product of $K$-split primes, use the usual +even bit, projected from oriented $K$-labels to rational labels. It has +all the required properties by Theorem~\ref{thm:symbol-rules}. We +therefore assume for the rest of the proof that equality never occurs +there. By the rational-phase assertion in Proposition~\ref{prop:even-coefficients}, +normalization by $a(1)=1$ makes each nonzero squarefree coefficient a +rational number times a root of unity. Its valuation is an integer, +not just an element of the possibly ramified coefficient field's +discrete value group. Thus strict inequality implies +\begin{equation}\label{pw:split-extra-depth} + v(a(D))\ge\omega(D)+1 + \quad\text{for every nonempty allowed all-$K$-split }D. +\end{equation} + +Write $g=\sum a(n)q^n$ for the form. Its characters satisfy +$\psi/\eta=\chi_{-4}$; since the scalar character $\psi$ is even, +$\eta$ is odd. For a set $U$ of $K$-split +primes put +\[ + B_U=2^{-|U|}\prod_{p\in U}(U_p-\eta(p)V_p)g, + \qquad + \Theta_J=\sum_{m>0,\ (m,S_0)=1}\eta(m)m q^{Jm^2}. +\] +All expansions retain the prescribed support sieves. The ordinary divided +form is +\[ + H_U=\frac12\left(B_U-\sum_{J\subseteq U}B_U[J]\Theta_J\right). +\] +Here $B_U[J]$ denotes its coefficient at the squarefree index $J$. + +\smallskip\noindent\emph{The mod-$8$ consequence.} +We first prove +\begin{equation}\label{pw:split-mod8} + a_p(E^{(k)})\equiv p+1\pmod8 + \quad\text{for every allowed good }p\text{ split in }K. +\end{equation} +Put $f=H_{\{p\}}\theta$ and apply its trace at a Frobenius lift $\phi_p$, +testing coefficient $p^2$. The terms $B_{\{p\}}\theta$ and +$\Theta_{\{p\}}\theta$ have the same character, whose $p$-part is +primitive quadratic. Thus they have no $p$-old constituent. On their +conductor-one ramified principal-series constituents the identity is +\[ + U_p^2t(\phi_p)=U_p^3+d(\phi_p)U_p. +\] +The remaining term $\Theta_\varnothing\theta$ is unraised, and obeys the +ordinary good-prime coefficient identity. Consequently +\[ + (t(\phi_p)f)[p^2]=f[p^3]+(d(\phi_p)f)[p]. +\] +Replace the trace by a fresh split prime $p'$ with the same finite data, +including every support-unit test. At each rational quadratic character +unramified outside $S_0$, a Frobenius lift at $p$ has the character value +of $p$. Hence the matched $p'$ has the same value, and $pp'$ has value +$1$. Equivalently, $p'$ has the same unit squareclasses as $p$ at all +places of $S_0$, so their product is square at all of them, including $2$. +Since $\phi_p\in G_K$, the new prime is also split in $K$. +Its coefficient on the left tests $pp'$; by +\eqref{pw:split-extra-depth} it is zero modulo the maximal ideal after +the two divisions. To check the determinant term, let $d_1,d_0$ be the +determinant scalars on the raised and unraised character spaces. Then +\[ + d(\phi_p)f + =d_1f+\frac{B_{\{p\}}[1]}2(d_1-d_0) + \Theta_\varnothing\theta. +\] +The character difference $(d_1-d_0)/2$ is integral. Also +$f[p]\equiv H_{\{p\}}[p]=0$ modulo the maximal ideal, since +$\Theta_{\{p\}}[p]=1$, whereas +$(\Theta_\varnothing\theta)[p]\equiv\Theta_\varnothing[p]=0$ +because $\theta\equiv1$ and $p$ is nonsquare. Thus +$(d(\phi_p)f)[p]=0$ after reduction. This cancellation uses the two +character spaces together. + +On the right, the indices $p$ and $p^3$ in $B_{\{p\}}$ have underlying +squarefree index $1$; they involve only $a(1),a(p^2),a(p^4)$. The +$J=\varnothing$ unary term has no coefficient at either nonsquare +index. Thus no other squarefree coefficient contributes there. +For $a=a_p(E^{(k)})$, the phase-free square coefficients are +$1,a-1,a(a-1)-p$. Hence the remaining coefficient is, up to a unit, +\[ + H_{\{p\}}[p^3] + =\frac{a^2-2a-p+1-p(a-2)}4 + =\frac{(a-1)(a-p-1)}4. +\] +This quotient is rational. Its vanishing in the residue field therefore +gives a positive integral $2$-adic valuation, so it is divisible by $2$. +Full rational two-torsion makes $a$ even, so +$a-1$ is odd; this proves \eqref{pw:split-mod8}. No individual total +filter condition on $p$ was needed: its matched prime $p'$ makes $pp'$ +lie on the filter, and the square-index terms on the right come from $1$. + +\smallskip\noindent\emph{One further division by $2$.} +Define +\begin{equation}\label{pw:four-divided-form} + \widetilde H_U=\frac14 + \left(B_U-\sum_{J\subseteq U}B_U[J]\Theta_J\right). +\end{equation} +We verify integrality at every coefficient. Write a test index uniquely +as $Jrm^2$, where $J\subseteq U$ and $r$ is squarefree and disjoint from +$U$. The underlying squarefree coefficient is at +$D=(U/J)r$. Removing the unit phases, a prime of $U/J$ contributes an odd +factor $b_s-b_{s-1}$ with $\kappa=0$, and a prime of $J$ contributes +$b_{s+1}-b_s$ with $\kappa=(D/p)$. Thus +\begin{equation}\label{pw:shell-valuation} + v(B_U[Jrm^2])\ge\omega(r) +\end{equation} +by \eqref{pw:split-basic-depth}, with one additional unit of valuation +when $D$ is nonempty and all its primes split in $K$. + +If $r\ne1$ and all primes of $D$ split in $K$, the last inequality is +at least $\omega(r)+1\ge2$. If $D$ contains an inert prime, then $r$ +contains at least two: the total rational $K$-character is trivial on +the filter, and all primes of $U$ split. Then +\eqref{pw:shell-valuation} is again at least $2$. No unary term has +this squarefree part. This proves divisibility by $4$ for $r\ne1$. + +Suppose $r=1$ and $J\ne U$. Then $D=U/J$ is nonempty and all split, +so $B_U[J]$ is even. This cancellation can be checked without dividing +by a leading multiplier, which may be zero. Factor from both shell +coefficients the common phase and the scalar +$2^{-|U|+|J|}a(U/J)$, whose valuation is at least $1$ by +\eqref{pw:split-extra-depth}. The remaining factors are the odd +differences at $U/J$, the integral divided differences at $J$, and +the ordinary square-index factors outside $U$. By +Lemma~\ref{pw:recurrence}, their product is congruent modulo $2$ to +the product of their leading values, even when one of those values +is zero modulo $2$. Since $m$ is odd, multiplication by $m$ preserves +this congruence. The common scalar supplies the second factor $2$. +Retaining the phase $\eta(m)$ therefore gives +\[ + B_U[Jm^2]\equiv B_U[J]\eta(m)m\pmod4. +\] +This is exactly the cancellation with $B_U[J]\Theta_J$. + +Finally let $J=U$, so $D=1$. At a prime outside $U$ the recurrence gives +$b_s\equiv p^s\pmod4$. At a prime of $U$, +\eqref{pw:split-mod8} gives $b_s\equiv p^s\pmod8$, and hence +\[ + \frac{b_{s+1}-b_s}{2} + \equiv \frac{a_p-2}{2}\,p^s\pmod4. +\] +Multiplying these congruences, again retaining the phases, gives +$B_U[Um^2]\equiv B_U[U]\eta(m)m\pmod4$. This proves integrality in +the last case and establishes \eqref{pw:four-divided-form}. +Diamonds preserve this lattice: when $J\ne U$, $B_U[J]$ is even and +the quadratic character difference supplies another factor $2$; when +$J=U$, the characters agree exactly. + +\smallskip\noindent\emph{The new symbol and its witness.} +Multiply \eqref{pw:four-divided-form} by ordinary theta and use the +integral trace operators. Two fresh traces in $G_K$ give zero after +reduction at every coefficient. To see this, start with an arbitrary +test index $Jrm^2$ and choose the two fresh primes outside that index +and the level. The filter imposes $\chi_K(D)=1$; since $U$ is all split, +the number of inert factors in $r$ is either zero or at least two. +The fresh traces replace $r$ by $rq_1q_2$, with both $q_i$ split. +In the first case the valuation after division by $4$ is at least +$\omega(r)+2+1-2=\omega(r)+1\ge1$. In the second case it is at least +$\omega(r)+2-2=\omega(r)\ge2$. The unary terms disappear under these +fresh tests. Additional fresh $G_K$ traces only improve these estimates, +so vanishing holds on the entire reduced trace orbit. The trace identity +therefore gives +\[ + t(gu^2)=t(g)\qquad(g,u\in G_K) +\] +on this reduced trace orbit. Thus the tests factor through the elementary +extension of $K$ unramified off the level. + +A single fresh $K$-split trace at coefficient $1$ reads the bit +\begin{equation}\label{pw:deeper-bit} + \widetilde A(D)= + \left(2^{-\omega(D)-1}a(D)\text{ with its phase removed}\right)\bmod2 +\end{equation} +for a nonempty all-split configuration. The contraction rule follows +from the same integral local identity as in Lemma~\ref{tc:inertia-identity}. +For completeness its first shell, with $p\in U$ and a fresh trace $q$, +has underlying configuration $D'=(U/p)q$, which is still nonempty, and +its reduction is +\[ + c_p(D')\widetilde A(D'),\qquad + c_p(D')=\frac{a_p-(D'/p)-1}{2}\bmod2. +\] +Changing the oriented inertia bit changes $c_p$ once. The omitted-prime +identity gives the product label and removes the entire rational prime +$p$ from the new ramification support. Consequently its repeated +contraction has precisely the forest interpretation of +Lemma~\ref{gr:forest}. An omitted-vertex label equal to the identity has +trace zero, which is primary isolation. No contraction to the empty +configuration has occurred. + +It remains to prove that this deeper test has a witness. Fresh +ramification gives $K\not\subseteq\mathbb Q(E[8])$. By Chebotarev there +is a good prime $p$ inert in $K$ and trivial on the original $E[8]$. +Then +\[ + p\equiv1\pmod8,\qquad a_p(E^{(k)})\equiv-2\pmod8. +\] +On $\widetilde H_\varnothing$, whose coefficient at $1$ is zero, test +$t(u)^2$ at coefficient $1$, where $u=\operatorname{Fr}_p$. The square +coefficient and matching unary character give, up to a unit, +\[ + \frac{a_p(E^{(k)})-1-p}{4}\bmod2=1. +\] +The determinant term at coefficient $1$ cancels. In characteristic two, +$t(u^2)=t(u)^2$, so a single trace in $G_K$ is nonzero. A fresh prime +realizing this finite trace test is split in $K$. Moreover $u^2$ is +trivial on every rational quadratic character, so the prime lies on the +required total rational filter. It is a nonempty witness for +\eqref{pw:deeper-bit}. Finally the exact coefficient ratio gives +\eqref{pw:split-unit-bound}, with the additional depth at most one. +\end{proof} + +\begin{lemma}[Orientation correction]\label{pw:coinvariants} +Let $K$ be imaginary quadratic, let $S_0$ contain $2$ and its ramification +support, and let $V_0$ be the elementary label space over $K$ unramified +off $S_0$. Complex conjugation acts on $V_0$ by $c$. If the rational +total of an oriented prime configuration is zero on every rational +quadratic character unramified off $S_0$, then its oriented total belongs +to $(1+c)V_0$. A reserved supply containing every label allows its +orientations to be flipped to realize any prescribed change in +$(1+c)V_0$. +\end{lemma} + +\begin{proof} +Complex conjugation has order two outside $G_K$, so +$G_{\mathbb Q}=G_K\rtimes\langle c\rangle$. A $c$-invariant quadratic +character of $G_K$ extends by giving $c$ value zero. At a rational prime +outside $S_0$, inertia lies in $G_K$ and the character is trivial there; +thus its extension remains unramified outside $S_0$. The assumed total +therefore annihilates $(V_0^*)^c$. + +For a finite vector space with involution, the annihilator of +$\ker(1+c^*)=(V_0^*)^c$ is $\operatorname{im}(1+c)$. This proves the +first assertion. Flipping a vertex of label $v$ changes its oriented +label from $v$ to $cv$, and hence changes the total by $(1+c)v$. +Reserve one representative for every preimage needed to express the +desired element of the image. Their independent flips give the second +assertion. These flips preserve every rational norm label. +\end{proof} + +\subsection{Common packets and rank-one interpolation} +\label{pw:assembly-section} + +\begin{proposition}[Families with a fixed companion] +\label{pw:fixed-companion-families} +With the fixed odd coefficient system and companion $k$ chosen in +Section~\ref{pw:fixed-companion-section}, suppose the odd symbol at $1$ +is zero. There is a constant $C$ with the following property. For every $b\ge1$ there are distinct primes outside +$2Nk$ and the fixed supports of both coefficient tests, with nonzero +linear activations, such that their signed products $h_x$, +$x\in\F_2^b$, satisfy $h_0=1$. Every $h_x$ is positive and has the fixed +local classes of $1$, and every new prime splits in $K=\Q(\sqrt{k})$. +The primes also avoid the detecting prime of the actual odd coefficient +stage. In particular $(h_x,k)=1$ for every $x$. For every $x\ne0$, +\[ + a(E^{(h_x)})=1,\qquad L(E^{(h_xk)},1)\ne0, +\] +and +\[ + j(P_{h_x})\le w(h_x)+C,\qquad + v(\mathcal L(h_xk))\le 2w(h_x)+C. +\] +The constant $C$ and the discriminant $k$ are independent of $b$. +\end{proposition} + +\begin{proof} +We construct common terminal packets, individually split in $K$, such +that the odd terminal polynomial and an even terminal polynomial testing +$hk$ are separately nonzero at each nonzero address. + +First suppose $F,F'$ are quadratic. Keep the original even symbol +evaluated on $hk$, treating the vertices of $k$ as stationary external +data. Enrich the rational labels of the $h$-vertices by the primes of +$k$. Their total there and at the even support is required to be zero. +Let $V$ be the resulting rational elementary label space, including the +$F,F'$ and $K$ coordinates and all relations among these characters. +The allowed simple labels form the affine set +$\{v\in V:\chi_F(v)=1,\ \chi_K(v)=0\}$, in additive notation. +The difference of any two of its elements belongs to +$\ker\chi_F\cap\ker\chi_K$, precisely the realizable rational labels +of the permitted split attachments. Translation by this subgroup is +therefore transitive. The fields $F,F'$ are unramified outside the old +support, whereas $K$ has a fresh ramified prime; thus $K$ is independent +of their compositum. When $F\ne F'$, this realizes both the good-simple +pattern $(1,1,0)$ and the donor pattern $(0,1,0)$ in their three +coordinates. When $F=F'$, all simple labels are good. + +For the old odd projection, take a normal closure of its finite label +extension, including the moving prime $\ell$ at any stage realizing the +stabilized profile. It is unramified outside the old support and $\ell$. Once $\ell$ avoids +$k$, a prime ramified in $K$ remains outside that set. Hence $K$ +has trivial intersection with this normal closure, and every old odd +label can be realized together with splitting in $K$. This applies +also to oriented split anchors over $F$. The added stationary $k$ +coordinates may have relations, but they are already included in $V$; +they do not impose extra requirements on the omitted odd projection. + +Use packets with the required simple supply and reserves in this kernel, +and with sufficiently large donor slack when $F\ne F'$. For the even +test, take no split anchors. +Correct all bad simples to good ones, pair equal enriched labels, and +retain a nonempty good base pair. Use reserves to match the pair and +the remaining good pairs, and attach every leftover split vertex to the +last base position. Its label is forced by total zero. The output is +a collection of good twin pairs, each matching also at every split +vertex of $k$. Twin insertion into the unit at $k$ proves that this +output has even symbol one. Thus the even terminal polynomial is +nonzero. + +For the odd test, project away the newly added tests at $k$. The same +packets contain enough split anchors, simple vertices and reserve shifts +to contract to the stabilized odd seed and good pairs, by +Lemma~\ref{pw:reserves}. Its total on that projection is the prescribed +zero total. Incidences between the retained anchors and the good pairs +can be set after contraction, by independent edge choices. The odd +polynomial is therefore nonzero as well. This odd test does not include +the stationary vertices of $k$. + +Now suppose the curve has full rational two-torsion. Use the even test +of Lemma~\ref{pw:split-witness}, with $K$-oriented labels on its support +$S_0$, and let $v_1,\ldots,v_r$ be a minimum nonempty witness. Its +oriented total $v_1+\cdots+v_r$ lies in $(1+c)V_0$, by +Lemma~\ref{pw:coinvariants}. Choose packets containing ample copies of +every needed even label, all odd seed labels on their rational +projection, and orientation-shifting reserves. In the common compositum, +restriction to the even label extension is surjective, so each even label +has a lift. Each intrinsic odd label also has a lift fixing $K$: fresh +ramification gives $K\cap L_{\rm odd}=\mathbb Q$, and the moving odd prime +avoids $k$. Extending these elements to the common compositum gives the +required lifts. Take sufficiently many lifts for each projection +separately, without prescribing their other projection. Duplicate each +full label, so the packet has rational total zero. + +For the even contraction, retain anchors with labels +$v_1,\ldots,v_{r-1}$. After reserving these anchors, use orientation +flips to make the total equal to $\sum v_i$; this is possible by +Lemma~\ref{pw:coinvariants}. Merge all remaining vertices into the +last cluster. Its label is $v_r$. The cluster is nonempty, and the +minimum nonempty count makes the output a unit independently of its +mutual edges. For the odd contraction, use its rational projection. +Every odd seed label lifts to a $K$-split prime because $K$ was freshly +ramified outside its intrinsic support. Retain all but the last odd +seed label and merge the remainder. Total zero gives the last label, +so this is also a unit. Orientation correction is conjugation over +$\mathbb Q$, which preserves every rational quadratic label, including +those at the moving odd prime. Adding $k$ to the common support has not +added it to the intrinsic odd projection. + +In both cases put a sufficient common packet at every nonzero linear +form on $\mathbb F_2^b$. Each nonzero address has two separately +nonzero terminal polynomials. Theorem~\ref{gr:address} supplies primary +auxiliaries split in $K$ (and $F$ in the quadratic case), neutral at the +stationary primes of $k$, and makes both symbols one at every nonzero +address. The auxiliary generators are primary at every support +coordinate used by either projection. Thus the odd and even graph +identities remain identities on the same common terminal polynomial +data. All active products $h$ are positive and square at the fixed +tests, and all their primes split in $K$. + +For each fixed $b$, the terminal tables and networks now give a finite +list of coefficient tests and a maximum weight. Choose the working +precision after these bounds are fixed. Finer ray neighborhoods affect +prime realization but do not enlarge the elementary label alphabet. +Lemma~\ref{cs:fixed-weight-uniformity} and +Theorem~\ref{thm:symbol-rules} realize the required divisibilities and +symbol identities on an ultrafilter-large intersection of stages. +At an arbitrarily high actual stage in that intersection, realize the +finite graphs by distinct primes. The unit-depth constants and the +companion $k$ were fixed before $b$ was chosen, and therefore remain +uniform in these realizations. + +At each nonzero address the odd unit detects analytic rank one and gives +$j(P_h)\le w(h)+C$. The even unit detects $L(E^{(hk)},1)\ne0$ and gives +$v(\mathcal L(hk))\le2w(hk)+C$, or the bound +\eqref{pw:split-unit-bound} in the full-torsion case. The fixed quantity +$2w(k)$ is absorbed into $C$. These are the asserted estimates. +\end{proof} + +\begin{proposition}[Odd original base]\label{pw:odd-base} +If $c_2(E)=1$, then $a(E)=1$. +\end{proposition} + +\begin{proof} +Parity gives odd functional sign. Proposition~\ref{pw:odd-lower} +therefore permits the odd normalization used above. If its symbol at $1$ +is a unit, it already gives $a(E)=1$. Otherwise apply +Proposition~\ref{pw:fixed-companion-families} for arbitrarily large $b$. +At every nonzero address its estimates and +Proposition~\ref{prop:heegner-comparison}, with the fixed $k$, give +\[ + 2j_h(k)\le4w(h)+C. +\] +The finite Sha lengths there are nonnegative. Hence +$2j_h(k)-4w(h)-s(h)-s(hk)\le C$, as required for Heegner interpolation. + +At address zero, $L(E^{(k)},1)\ne0$ gives $c_2(E^{(k)})=0$ by +Lemma~\ref{pr:ranks}. Lemma~\ref{pr:invariance} gives +\[ + \corank_{\Ztwo}\Sel_{2^\infty}(E/K) + =c_2(E)+c_2(E^{(k)})=1. +\] +Since $K$ is fixed, the finite quotient of this base Selmer group has a +fixed length. Theorem~\ref{thm:heegner-interpolation} makes +$L(E,s)L(E^{(k)},s)$ have a simple zero. Its second factor is nonzero at +$1$, so $a(E)=1$. +\end{proof} + +\begin{theorem}[The rational-two-torsion converse]\label{thm:rational-converse} +Let $E/\Q$ satisfy $E(\Q)[2]\ne0$ and +$c_2(E)=\operatorname{corank}_{\Z_2}\Sel_{2^\infty}(E/\Q)\in\{0,1\}$, +with the local Kummer conditions at every place. Then +\[ + \operatorname{ord}_{s=1}L(E,s)=c_2(E). +\] +There is no restriction on the rational isogeny configuration, complex +multiplication, or reduction at $2$ or at the bad primes. +\end{theorem} + +\begin{proof} +The initial isogeny choice preserves both quantities and covers both +rational two-torsion configurations. Proposition~\ref{pw:even-base} +proves the corank-zero case. In the corank-one case, +Proposition~\ref{prop:rational-odd-bound} supplies the coefficient +normalization, and Proposition~\ref{pw:odd-base} proves analytic rank one +using a companion fixed before the binary dimension grows. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/09-local-matrices.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/09-local-matrices.tex new file mode 100644 index 0000000000000000000000000000000000000000..ab6e8fb7d582a00299b76210e575306d61b9a0f7 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/09-local-matrices.tex @@ -0,0 +1,499 @@ +\section{Selmer matrices and three-state relations} +\label{sec:lm:local-matrices} + +Assume that $V=E[2]$ is irreducible, and write +$F=\Q(V)$ and $G=\Gal(F/\Q)\in\{C_3,S_3\}$. +The symbol rules will be useful because a unit symbol bounds the +$2$-Selmer dimension. We now express local Selmer conditions by a +binary matrix and make that bound constrain the number of singular +blocks. The second half of the section develops the elementary matrix +operations needed to apply this constraint. + +Write the Weil pairing additively, and choose a basis of $V$ in which +its matrix is +\[ + J=\begin{pmatrix}0&1\\1&0\end{pmatrix}. +\] +Fix a finite set $S$ containing $2$, $3$, the bad primes, all auxiliary +exclusions, and rational primes whose prime ideals generate the class +groups of every subfield of $F$. Local specifications at $S$ will also +include the archimedean places. The detecting prime $\ell$ for an odd +coefficient system is kept separate: all generators below have valuation +zero there. This separation keeps the set of support types finite as +$\ell$ varies. We shall apply the construction to a fixed curve, after +absorbing any initial quadratic twist into $E$. + +\subsection{Global classes and local equations} + +At a split prime $p$, choose a place of $F$ and put $H_p=1$. +At a simple prime, choose a place with Frobenius a specified +transposition $c$ and put $H_p=\langle c\rangle$. +Set +\[ + F'_p=F^{H_p},\qquad V_p=V^{H_p}. +\] +Thus $V_p$ has dimension two or one, respectively. The chosen place +lies above a degree-one prime $P_p$ of $F'_p$. By the choice of $S$, +there is $\pi_p\in(F'_p)^\times$ whose divisor away from $S$ is $P_p$. +For $x\in V_p$ define +\begin{equation}\label{eq:lm:generator-class} + C_p(x)=\cor_{F'_p/\Q}(\chi_{\pi_p}x)\in H^1(\Q,V). +\end{equation} +Here $\chi_{\pi_p}$ is the quadratic Kummer character; its product with +$x$ is a cocycle because $H_p$ fixes $x$. + +The inertia coordinate of $C_p(x)$ at $p$ is $x$, and all its other +inertia coordinates outside $S$ vanish. Indeed, local +restriction--corestriction has exactly one ramified summand, at the +degree-one place where $\pi_p$ has valuation one. These coordinates +therefore make the classes for distinct $p$ independent. A root prime +has $V^{\Fr_p}=0$ and contributes no coordinates. + +Let $h$ be a twist containing the active nonroot primes in its +discriminant. At a good odd prime $p$ ramified in $h$, inertia identifies +the local Kummer condition with $V_p$. To see surjectivity, halve a +Frobenius-fixed two-torsion point over the maximal unramified extension. +The ramified twisting involution negates its half, so the resulting +Kummer inertia is that two-torsion point. The Kummer condition has +dimension $\dim V_p$ by local duality, giving the asserted isomorphism. + +Fix arithmetic Frobenius lifts $\phi_p$. A second local coordinate is +unramified evaluation at $\phi_p$, modulo Frobenius coboundaries. +Let $K_p(x)(\phi_p)$ be this coordinate for the Kummer lift of inertia +$x$. It is determined by $E[4]$ and the local twisting squareclass. +Define the block matrix $B$ by +\begin{equation}\label{eq:lm:raw-matrix} + B_{qp}(y,x)=\langle C_p(x)(\phi_q),y\rangle + -\mathbf1_{p=q}\langle K_p(x)(\phi_p),y\rangle, + \qquad x\in V_p,\quad y\in V_q. +\end{equation} +Thus $Bx=0$ is exactly the collection of active-prime Selmer equations +for $\sum_p C_p(x_p)$. Changing the unramified unit part of the twist +adds $J$ to a split diagonal block. On a simple line it changes nothing, +since the Weil pairing restricts to zero on a one-dimensional space. + +Record in the \emph{type} $\mathfrak h_p$ the subgroup $H_p$ and the +squareclasses of $\pi_p$ at the places over $S$, including signatures. +Only finitely many types occur. Finer generator neighborhoods will be +used to reproduce self entries, but they are not part of this type +alphabet and do not enter its codimension cost. Global reciprocity gives +\begin{equation}\label{eq:lm:symmetry-defect} + B_{qp}+B_{pq}^{t}=b(\mathfrak h_q,\mathfrak h_p), +\end{equation} +where $b$ is the sum of the local cup pairings at $S$. +Indeed, at an active prime decompose each class into its Kummer lift +and its unramified difference. Both planes are isotropic, and the +cross pairing is unramified evaluation paired with inertia. The terms +at $p$ and $q$ give the left side; the sum over all places is zero. +Elsewhere outside $S$ the classes are unramified, so the local pairing +vanishes. This includes $\ell$, where the generators have unit valuation. +The same calculation shows that $b(\mathfrak h,\mathfrak h)$ is alternating. + +\subsection{Prescribing the matrix entries} + +We next prove that the off-diagonal entries and the rational Legendre +bits can be varied independently. The latter bits will control split +diagonals without disturbing the other blocks. The class-field inputs +are ray-class reciprocity, the Hilbert product formula, and Chebotarev +\citep[Chapter~VI, Sections~7--8, and Chapter~VII, Section~13]{Neukirch1999}; +see also \citet[Chapter~V, Theorems~3.23, 5.3 and~5.5, +and Example~5.4]{MilneCFT2020}. + +\begin{lemma}[Realization of finite matrix prescriptions] +\label{lem:lm:arithmetic-realization} +Fix finitely many individually admissible oriented prime templates, +including generator neighborhoods at $S$, any additional finite places, +and oriented Frobenius on $E[4]$ and fixed quadratic-radical extensions +unramified outside that support. At arbitrarily fresh primes these +templates admit the following simultaneous prescriptions. +\begin{enumerate}[label=\textup{(\roman*)}] +\item Between distinct vertices, one direction of the double-coset +residue bits is free and reciprocity determines the reverse direction. +The available matrix blocks are all binary matrices for two split +vertices in the $S_3$ case, and $J\F_4$ in the $C_3$ case, with the +rotation algebra identified with $\F_4$. For split--simple vertices +the full vector space is available, and for simple--simple vertices +the scalar entry is available. +\item The rational Legendre bit between the absolute primes is +independent of the matrix block, subject to rational reciprocity in +the reverse direction. +\item Repeating a template fixes its simple self entry and its split +self block modulo a scalar multiple of $J$. A sufficiently primary +split template with trivial $E[4]$-Frobenius has self block in $\F_2J$. +\end{enumerate} +Here \emph{primary} means sufficiently close to $1$ at the finite +places of $S$ and totally positive at the real places. New cross-bit +prescriptions are made outside the support. All assertions concern +finite configurations; an additional moving prime $\ell$ may be +included among the prescribed places. +\end{lemma} + +\begin{proof} +\emph{Off-diagonal entries.} +Restriction--corestriction in Equation~\eqref{eq:lm:generator-class} +gives, for distinct vertices, +\begin{equation}\label{eq:lm:double-coset} + B_{qp}(y,x)= + \sum_{g\in H_q\backslash G/H_p} + e_{pq}(g)\langle gx,y\rangle. +\end{equation} +The bit $e_{pq}(g)$ is the quadratic residue of $g\pi_p$ at the +oriented $q$-place in $F^{H_q\cap gH_pg^{-1}}$. Indeed, pair local +transfer with the $H_q$-invariant vector $y$; the orbit length +$[H_q:H_q\cap gH_pg^{-1}]$ is precisely the residue degree in the +norm calculation. In this intermediate field, each of $\pi_q$ and +$g\pi_p$ has its off-support divisor at a single prime: its oriented +Frobenius generates the subgroup fixing the generator. Hilbert +reciprocity therefore relates $e_{pq}(g)$ to $e_{qp}(g^{-1})$, with +correction only at $S$. + +For a new vertex the independent forward bits are residue conditions +at distinct primes of its own field $F'_p$. Move an initial template +away from the old primes and choose a degree-one prime in the ray class +whose quotient generator has the prescribed neighborhoods at $S$, +real signs, and nonzero residues at those old primes. Multiplying the +template generator by this quotient gives the required new generator. +These conditions also preserve the admissible fixed Frobenius data: +changes by local units at old primes are trivial on the intersection +with extensions unramified outside the fixed support. Chebotarev thus +imposes the ray and fixed-label conditions simultaneously. Prime ideals +of degree greater than one over $\Q$ have density zero among prime +ideals of $F'_p$, so requiring degree one loses no admissible class. +The same argument permits additional finite support, including $\ell$. +Reverse bits are then determined by reciprocity. Rational norm bits at +already chosen root primes may be imposed as additional residue +conditions in the ray modulus: finite-field norm maps are surjective, +and these primes contribute no matrix coordinates. + +\emph{Matrix span and the norm bit.} +The norm to $\Q$ writes the rational absolute-prime Legendre bit as +the sum of the double-coset bits, plus a fixed support-unit correction. +For two split vertices the matrices in +Equation~\eqref{eq:lm:double-coset} are $Jg$. They span +$\operatorname{Mat}_2(\F_2)$ for $S_3$ and $J\F_4$ for $C_3$. +A nontrivial rotation satisfies $1+R+R^2=0$: changing these three +bits fixes the matrix and changes their sum. For split--simple +vertices, the three nonzero vectors or dual vectors likewise span +the full space and have the same odd relation. For two simple vertices, +the matching double coset has zero pairing and the other has nonzero +pairing. The first bit changes the norm bit alone. This proves +\textup{(i)} and \textup{(ii)}. + +\emph{Self entries.} +The nonidentity double cosets in self-transfer are unramified at the +oriented prime. The identity term is a scalar times the pairing and +is therefore zero on a simple line. At a split vertex the two rotation +terms have fixed sum by reciprocity; changing both alters the block +only by a scalar multiple of $J$. Every other term has an involution +representative $\tau$ exchanging the oriented place with another one. +For a simple vertex this includes a transposition other than $c$ +representing the nonmatching self double coset. + +Work in $F^\tau$ and put +\[ + \alpha=\pi_p\tau\pi_p,\qquad + \beta=\pi_p+\tau\pi_p,\qquad + F=F^\tau(\sqrt{D_\tau}). +\] +The distinct divisors of $\pi_p$ and $\tau\pi_p$ ensure $\beta\ne0$. +If $v_0$ is the place below the oriented prime, the residue symbol of +$\tau\pi_p$ there is $(\alpha,\beta)_{v_0}$: $\alpha$ has valuation +one and $\beta$ is a unit with the required residue. Outside +$S\cup\{v_0\}$, $\alpha$ is a unit. When $\beta$ is a unit, both +$(\alpha,\beta)_v$ and $(-D_\tau,\beta)_v$ vanish. When $\beta$ has +positive valuation, put +$\gamma=(\pi_p-\tau\pi_p)/\sqrt{D_\tau}\in F^\tau$. The identity +\[ + \beta^2-4\alpha=D_\tau\gamma^2 +\] +shows that $\alpha$ has residue squareclass $-D_\tau$; the two +symbols are again equal. At $v_0$, $(-D_\tau,\beta)_{v_0}=0$. +Reciprocity applied to both symbols gives, in additive notation, +\begin{equation}\label{eq:lm:self-spin} + (\alpha,\beta)_{v_0} + =\sum_{v\in S}\bigl((\alpha,\beta)_v+(-D_\tau,\beta)_v\bigr). +\end{equation} + +At finite support places the right side is locally constant in a +sufficiently small neighborhood of the template. At a real place +where $F/F^\tau$ is complex, $\alpha$ and $-D_\tau$ are positive. +At a split real place, opposite signs of $\pi_p$ and $\tau\pi_p$ +make the two terms cancel; equal signs determine their sum. Thus +signatures suffice, without archimedean size restrictions. +For a primary template, $\alpha$ is a square at the finite support +places and $\beta$ has the squareclass of $2$. The support sum becomes +$\sum_{v\in S}(-D_\tau,2)_v=0$, since the terms outside $S$ vanish. +The involution terms are therefore zero. Together with the local +Kummer lift determined by $E[4]$, this proves \textup{(iii)}. +\end{proof} + +\subsection{Symmetrization and the Selmer bound} + +The realization lemma supplies the allowable matrix blocks. We now remove +their fixed-support reciprocity defect and compare the resulting kernels +with actual Selmer classes. The fixed support types, stationary +environment and additional local conditions will account for the loss +in dimension. + +Choose a matrix rule $L(\mathfrak h,\mathfrak h')$ in the available +block spans such that +\begin{equation}\label{eq:lm:type-correction} + L(\mathfrak h,\mathfrak h')+ + L(\mathfrak h',\mathfrak h)^t=b(\mathfrak h,\mathfrak h'). +\end{equation} +For distinct types, choose either direction using +Equation~\eqref{eq:lm:symmetry-defect}. For equal types, the right +side is alternating. It is a matrix plus its transpose in the full +span; in the rotation span use $R+R^{-1}=1$ after multiplication by +$J$. On a simple line it is zero. Choose $L=0$ when one type is +primary and trivial at $S$, since then its support pairings vanish. +Define, on every pair including the diagonal, +\[ + M_{qp}=B_{qp}-L(\mathfrak h_q,\mathfrak h_p). +\] +The matrix $M$ is symmetric. Lemma~\ref{lem:lm:arithmetic-realization} +allows zero cross-$M$ entries between prescribed blocks independently +of their internal entries. + +A \emph{stationary environment} consists of the fixed coordinates +outside the variable blocks; its dimension is the number of those +coordinates. + +\begin{proposition}[Nullity forces Selmer dimension] +\label{prop:selmer-matrix-bound} +Fix the curve, support types, a bound for the number of additional +constrained places, and a bound for the dimension of a stationary +environment. Partition a finite configuration into blocks with zero +cross-$M$ entries, and denote their matrices by $M_i$. There is a +constant depending only on these fixed data such that +\begin{equation}\label{eq:lm:selmer-nullity} + \dim_{\F_2}\Sel_2(E^{(h)}/\Q) + \geq\sum_i\dim_{\F_2}\ker M_i-C. +\end{equation} +At a unit coefficient symbol the sum of nullities, and hence the +number of singular blocks, is therefore uniformly bounded. The bound +works for both coefficient sources and is independent of the moving +prime $\ell$. +\end{proposition} + +\begin{proof} +On $\bigoplus_i\ker M_i$, impose +\begin{equation}\label{eq:lm:type-sums} + \sum_{p:\,\mathfrak h_p=\mathfrak h}x_p=0 + \quad\text{for each type }\mathfrak h, +\end{equation} +using the fixed orientation and basis to identify coordinates of the +same type. These equations have codimension at most +$\sum_{\mathfrak h}\dim V_{\mathfrak h}$. They kill the correction +in every row, since that correction is +\[ + \sum_{\mathfrak h}L(\mathfrak h_q,\mathfrak h) + \sum_{p:\,\mathfrak h_p=\mathfrak h}x_p. +\] +Thus $Bx=0$ at all block positions. Set the environment coordinates +to zero and impose its row conditions, losing at most its dimension. +The Selmer conditions at $S$ and the additional constrained places +have bounded total codimension in local $H^1$. At every remaining +good place the classes satisfy the unramified Kummer condition; at a +root prime local cohomology is zero. Their sums are therefore Selmer +classes, and independent inertia coordinates make the map injective. +This proves Equation~\eqref{eq:lm:selmer-nullity}. + +At a unit symbol, Proposition~\ref{prop:unit-symbol-detection} bounds +the Selmer dimension, giving the remaining assertions. The type +constraints use only the fixed $S$; a condition at the single moving +prime contributes a uniformly bounded local dimension. +\end{proof} + +\subsection{Three states on two coordinates} + +We have obtained two kinds of information from an arithmetic prime +configuration: its coefficient symbol and a matrix whose nullity +bounds its Selmer dimension from below. To compare configurations, +we now vary exactly two coordinates at a time. Both the symbol and +the determinant obey one common three-state relation. They remain +different functions; the relation gives linearity, not their equality. +The bounded number of singular blocks at a unit symbol will be the +additional input used in the next section. + +A \emph{site} consists of either one split vertex or an ordered pair +of simple vertices, and always supplies two matrix coordinates. +At a split site use the three states +\[ + \text{absent},\qquad + \text{present with diagonal }Q,\qquad + \text{present with diagonal }Q+J. +\] +The rational Legendre bit of the aggregate root selects the two +present diagonals. At a simple-pair site use absence of both vertices +and two present variants differing in their nonmatching cross bit. +Replace the second prime by a prime with the same template, self data, +norm data, and outside cross bits. Its matching bit with the first +prime must also change to keep the rational norm bit fixed; that bit +has zero matrix contribution. Thus the two present matrices again +differ by the symmetric toggle on their coordinate pair. Require all +alternatives to agree against alternatives at other sites. These are +finite simultaneous prescriptions allowed by +Lemma~\ref{lem:lm:arithmetic-realization}. + +In comparing states, keep fixed the total parameter label at the fixed +support: the product of the labels of the active sites and the aggregate +roots. The aggregate-root label itself changes when a site is deleted, +absorbing the deleted labels. + +\begin{lemma}[The site relations]\label{lem:lm:site-relations} +Fix the total parameter label at the fixed support and the diagonal +choices at the other present sites. In each state choose aggregate +roots restoring this label, compatibly with an order-three residual +Frobenius, and preserving those diagonals. For either coefficient +symbol, its three values at one site sum to zero. The same holds for +$\det M$, with empty determinant one. +Consequently both functions extend linearly to the tensor product of +one copy of $\F_2^2$ per site, whose three nonzero vectors represent +the three states. These factors encode evaluations, not vectors of $V$. +\end{lemma} + +\begin{proof} +For a split site this is the root-deletion rule of +Theorem~\ref{thm:symbol-rules}. Deletion transfers the removed +vertex's rational labels to the aggregate root. Signed prime +discriminants preserve the unit twist, and hence the diagonal, +at every remaining prime. + +For a simple-pair site, omit the varied second prime from its +opposite-parity trace test. In an extension of $G$ by an elementary +kernel, two lifts of its transposition $c$ are conjugate by the kernel +exactly when their difference lies in the image of $1+c$. Dually, +this means agreement on the $c$-fixed radical squareclasses. +Besides fixed-support radicals, these are generated by products of +the orbit generators $g\pi_p$ over $c$-orbits: their off-support +divisors are independent and conjugation permutes them. Singleton +orbits test matching bits. A two-element orbit has product in $F^c$; +its symbol at the varying degree-one prime is, by the residue norm, +the symbol of one factor in $F$, namely the nonmatching bit. + +The variants agree on support radicals and the orbit tests for every +other vertex. At the first prime they change both matching and +nonmatching bits. Modulo the image of $1+c$, their difference is +therefore the product of inertia in the matching transposition +orientation and inertia in the other orientation. Apply these +substitutions successively. The matching-orientation derivative is zero; +the different-transposition derivative deletes the pair by +Theorem~\ref{thm:symbol-rules}. Multiplication +by inertia leaves the residual transposition unchanged. The intermediate +Frobenius test is realized by Chebotarev; it need not be a site variant. +The resulting root has rotation image and transfers the pair's rational +labels to the aggregate. Labels elsewhere are unchanged. At simple +vertices root probes are immaterial; at split vertices the common +rational labels preserve the diagonals. Matched actual probes, or their +aggregate, are available because their discriminant character is trivial. +This proves the symbol relation. + +For the determinant, reverse every permutation cycle of length at +least three. The resulting terms cancel in characteristic two, leaving +only involutions. Toggling the symmetric entries $(i,j),(j,i)$ changes +exactly the terms containing $(ij)$, whose sum is the determinant with +coordinates $i,j$ deleted. This includes the split $J$-shift. Finally, +the three-state relation in each factor is precisely linearity on its +three nonzero binary vectors. +\end{proof} + +\begin{lemma}[Binary tensor span]\label{lem:binary-tensor-span} +Let $W=\bigotimes_{i=1}^rW_i$, where each $W_i$ has dimension two +over $\F_2$, and let $0\ne f\in W^*$. The nonzero pure tensors +annihilated by $f$ span $\ker f$. Thus if pure tensors $e,t$ satisfy +$f(e)=f(t)=1$, then $t$ is $e$ plus a sum of pure zeros of $f$. +\end{lemma} + +\begin{proof} +It suffices to show that a functional $g$ vanishing on the pure zeros +of $f$ is either $0$ or $f$. Induct on $r$, the case $r=0$ being +immediate. Slice at the three nonzero vectors of the last factor, +numbering so that $f_3=f_1+f_2$ and $g_3=g_1+g_2$. +If $f_i=0$, then $g_i=0$ because the smaller pure tensors span. +Otherwise induction gives $g_i=\epsilon_i f_i$ for a binary scalar +$\epsilon_i$. If all three $f_i$ are nonzero, $f_1,f_2$ are independent, +so the sum identities force all $\epsilon_i$ to agree. If one $f_i$ +vanishes, the other two, and their $g_i$, agree. All three cannot vanish. +Hence $g=0$ or $g=f$. +\end{proof} + +Take $f=\det M$ and let $e$ be the all-absent state. Every invertible +state is the empty state plus a sum of singular pure states. +Moreover, on any selected set of active sites, some choice of pair +toggles makes $M$ invertible: the iterated determinant difference over +all selected pairs is the empty determinant, one. These facts turn the +Selmer nullity bound into a constraint on symbol evaluations. + +\subsection{Making one address singular} + +The final construction singles out one nonzero vector of a binary +cube. Every position is activated by a linear form, as required for +interpolation; auxiliary split sites repair the matrix at all other +nonzero vectors. + +\begin{lemma}[A block address program]\label{lem:lm:address-program} +Let $M_*$ be the singular matrix of a finite site state, and let $D$ +be a sum of its pair toggles such that $N_*=M_*+D$ is invertible. +For $b\geq2$ and $0\ne x_*\in\F_2^b$, one can add finitely many +primary split sites, each activated by a linear form, so that: +\begin{itemize} +\item all sites present in the original state have activation $l_0$, +with $l_0(x_*)=1$; +\item no site is active at zero, and at $x_*$ precisely the original +state $M_*$ remains; +\item the matrix is invertible at every other nonzero address; +\item the active auxiliary matrix is always invertible, and its Schur +complement contributes $D$ exactly when the original sites are active +and $x\ne x_*$. +\end{itemize} +All entries use the freedoms of +Lemma~\ref{lem:lm:arithmetic-realization}. +\end{lemma} + +\begin{proof} +Choose a basis $y=(y_1,\ldots,y_{b-1})$ for the forms annihilating +$x_*$ and complete it by $l_0$. Then $y=0$ exactly at $0,x_*$. +For each required toggle and each nonzero $\eta\in\F_2^{b-1}$, +choose a basis of forms all equal to one at $\eta$. Such a basis is +obtained from a form $u$ with $u(\eta)=1$ by adding $u$ to a basis +of the annihilator of $\eta$. Its unique simultaneous all-one +solution is $\eta$. + +Construct a path with $r=b-1$ steps, using two new split positions at +each step, both activated by the corresponding basis form. In scalar +block notation, where a scalar denotes that scalar times $J$, put +\begin{equation}\label{eq:lm:path-matrix} + P=\begin{pmatrix}0&T\\T^t&B_e\end{pmatrix}, + \qquad T=I+\text{lower consecutive shift}. +\end{equation} +The near and far endpoints are steps $1$ and $r$. The matrix $B_e$ +has one nonzero diagonal entry at the far endpoint. Restrict both sides +to active steps, retaining only the original consecutive edges. The +restricted $T$ is triangular +with diagonal one, so $P$ is invertible, with scalar inverse +\[ + P^{-1}=\begin{pmatrix} + T^{-t}B_eT^{-1}&T^{-t}\\T^{-1}&0 + \end{pmatrix}. +\] +Couple the addressed coordinate pair by $J$ to the first side at the +near endpoint. Such a pairing is available also for two simple lines. +Solving $Tv=e_{\rm near}$ propagates one to the far endpoint exactly +when every step is active; a missing step interrupts the consecutive +shift. The Schur contribution is consequently $J$ on a complete path +and zero otherwise, including when the near endpoint is absent. + +For each nonzero $y$, exactly one path, the one indexed by $\eta=y$, +is complete. Their direct sum supplies the toggle when $y\ne0$ and +supplies zero when $y=0$. Repeat for each toggle in $D$, with zero +mutual cross-$M$ entries. The actual matrices are the scalar matrices +tensored with $J$, so the same inverse calculation gives the asserted +binary Schur complements. All blocks lie in the permitted spans, and +primary diagonals are $0$ or $J$. + +At $x_*$ the auxiliary sites are absent and $l_0=1$, leaving $M_*$. +At any other nonzero address with $l_0=1$, eliminating the auxiliary +sites leaves $M_*+D=N_*$. If $l_0=0$, only the invertible auxiliary +matrix remains. Every activation is linear and vanishes at zero. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/10-irreducible-converse.tex b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/10-irreducible-converse.tex new file mode 100644 index 0000000000000000000000000000000000000000..8d5e563d12199de56303df6bbee4dafc9d0691f4 --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/build/sections/10-irreducible-converse.tex @@ -0,0 +1,765 @@ +\section{The converse when \texorpdfstring{$E[2]$}{E[2]} is irreducible} +\label{sec:sa:saturation} + +The local matrices now supply the families needed for interpolation. +We shall arrange that a coefficient symbol is a unit at every nonzero +vertex of a binary cube, with all added primes absent at zero. +The key observation is that a unit evaluation has only boundedly many +singular matrix blocks. A maximal list of such blocks will therefore +force all the required unit evaluations. In the odd case, a second +construction supplies simultaneous nonvanishing for an auxiliary even +symbol. + +\begin{theorem}[The irreducible converse] +\label{thm:irreducible-converse} +Let $E/\Q$ be an elliptic curve for which $E[2]$ is irreducible as a +$G_{\Q}$-module. If +\[ + c_2(E)=\corank_{\Ztwo}\Sel_{2^\infty}(E/\Q)\in\{0,1\}, +\] +then $\ord_{s=1}L(E,s)=c_2(E)$. +\end{theorem} + +The curve is fixed throughout. Every constant may depend on it and on +the finite choices specified below, all made before the cube dimension +grows. The result applies pointwise to any quadratic twist by taking +that twist as the initial curve. + +\subsection{Finite evaluation tables and ordered profiles} + +A block is a finite set of the three-state sites of +Section~\ref{sec:lm:local-matrices}, together with their prescribed +matrix entries. A state chooses one of the three alternatives at each +site. Its evaluated matrix $M_s$ deletes the coordinates of absent sites +and applies the toggles of the chosen active alternatives. The empty state has determinant $1$. +We call a state singular when $\det M_s=0$. + +The matrix and the coefficient symbol give different information about +such a state. The raw matrix $B$ records the active-prime Selmer equations; +$M$ is the symmetric matrix obtained after the fixed-support correction. +The symbol still depends on the arithmetic realization, even when those +matrix entries have been prescribed. What links them is +Proposition~\ref{prop:selmer-matrix-bound}: a symbol value $1$ permits +only boundedly many singular blocks. We shall first stabilize the +remaining arithmetic dependence and then use this bound. + +Fix a normalized coefficient symbol $A$ on the filter of the parameter +$1$. For the odd source retain its condition at the moving detecting +prime $\ell$. Consider an actual finite array of blocks, numbered in +increasing order, with $M=0$ between different blocks. For chosen +indices $i_1<\cdots0$ +and $d$ signed squarefree. Thus +\[ + A(X)=\sum_{m\le\sqrt X}S(X/m^2),\qquad + S(X)=\sum_{m\le\sqrt X}\mu(m)A(X/m^2). +\] +The second equality follows by substituting the first and using +$\sum_{m\mid r}\mu(m)=\mathbf1_{r=1}$. +For a fixed integer $M$, the terms with $m\le M$, divided by $X$, +tend to $2\delta\sum_{m\le M}\mu(m)/m^2$. The remaining absolute +contribution is at most +\[ + 2X\sum_{m>M}m^{-2}, +\] +because $A(Y)\le2\lfloor Y\rfloor\le2Y$. +First let $X$ and then $M$ tend to infinity. The absolutely convergent +series $\sum\mu(m)/m^2=1/\zeta(2)$ proves the formula. +Applying it to the property always true gives +$\#\mathcal D(X)\sim2X/\zeta(2)$, proving the density assertion. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:main-density}] +Smith's theorem states that, for every fixed elliptic curve $E/\Q$ +and $j=0,1$ \citep[Theorem~1.1]{Smith2025}, +\[ + \#\{n\in\Z:0<|n|\le X,\ c_2(E^{(n)})=j\}=X+o(X) + . +\] +Quadratic twisting depends only on the squareclass, so +Lemma~\ref{lem:squarefree-density} gives density $1/2$ for each +corank among the signed squarefree parameters. + +For $j=0,1$, Theorem~\ref{thm:main-converse} gives +$c_2(E^{(d)})=j\Rightarrow a(E^{(d)})=j$, while +Lemma~\ref{pr:ranks} gives the converse implication. +The analytic-rank counts therefore equal the corresponding corank +counts exactly. The two densities sum to one. Their complement, +the twists of analytic rank at least two, has density zero, and +Lemma~\ref{pr:ranks} gives the final rank and finiteness assertions +on the density-one union. +\end{proof} diff --git a/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4b221fedcc3f87fc92e56b7a7ad73461f77844ed --- /dev/null +++ b/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c417858c9fe566daacb7738741dc66e211eea148b3da587eb5ee68eaad208d64 +size 1087540 diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/README.md b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6bb5af71454cd66bf7536c58a3ca75b7794abe1e --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [Hilbert's tenth problem over the rational numbers](main.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026, + author = {{OpenAI}}, + title = {{Hilbert's tenth problem over the rational numbers}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/main.pdf}{OAI:Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version updates citations to revised manuscripts in this collection; see the [previous version](../Hilberts-tenth-problem-over-the-rational-numbers-September-24-2026/main.pdf). diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/figures/reduction-overview.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/figures/reduction-overview.tex new file mode 100644 index 0000000000000000000000000000000000000000..a59f2983d83532992f399235bdc399f02e0e2d77 --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/figures/reduction-overview.tex @@ -0,0 +1,60 @@ +\suppressfloats[t] +\begin{figure}[!ht] +\centering +\begin{tikzpicture}[ + box/.style={draw=blue!45!black,fill=blue!2,rounded corners=1.5pt, + align=center,font=\small,inner sep=5.5pt,text width=6.55cm}, + result/.style={box,text width=14.15cm,fill=blue!5}, + line/.style={-{Stealth[length=2mm]},semithick,draw=blue!45!black}] +\node[box,minimum height=1.72cm] (slopes) + {\textbf{Vary $A\in R$}\\[3pt] + Choose a representation at precision $K$:\\[2pt] + $\widetilde A=\sum_{i=1}^3\widetilde u_i/\widetilde v$, + \quad $\widetilde s_i=(\widetilde u_i:\widetilde v)$.}; +\node[box,minimum height=1.72cm,right=0.65cm of slopes] (root) + {\textbf{Keep the root tuple $\mathbf a$ fixed}\\[3pt] + $f(\widetilde{\mathbf a})=0$, \quad + $\delta=f(\eta(\mathbf a))\ne0$,\\[2pt] + $|\delta|\le C_f B^D$, \quad $K\ge cD$.}; + +\node[box,below=0.5cm of slopes] (local) + {For each ambient prime $q\mid M_K(\widetilde s_i)$:\\[3pt] + one tested branch gives actual formal points + and valuation bounds above $q$, using + pole parity and coarsening.}; + +\node[box,minimum height=1.72cm,below=0.5cm of local] (comparison) + {\textbf{Paired elliptic tests}\\[3pt] + $\widetilde a$ is $q$-integral and + $v_q(\widetilde a-\eta(a))\ge K$\\[2pt] + for every $a\in R$.}; +\node[box,minimum height=1.72cm,right=0.65cm of comparison] (error) + {Apply the comparison to $a_1,\ldots,a_n$:\\[2pt] + $v_q(\delta)\ge K$ for every such $q$.\\[3pt] + Hence $M_K(\widetilde s_i)^K\mid\delta$ + for $i=1,2,3$.}; + +\node[result,minimum height=1.62cm,below=0.5cm of comparison, + xshift=3.8cm] (height) + {\textbf{Apply the five-point height estimate to each chosen slope}\\[3pt] + $\displaystyle + \hgt(\widetilde A) + \le\sum_{i=1}^3\hgt(\widetilde s_i)+\log3 + \le 3H_K|\delta|^{c/K}+\log3 + \ll_f B\qquad(A\in R).$}; + +\draw[line] (slopes)--(local); +\draw[line] (local)--(comparison); +\draw[line] (comparison)--(error); +\draw[line] (root)-- node[midway,fill=white,inner sep=2pt, + font=\small,align=center] {polynomial\\evaluation} (error); +\draw[line] (error.south)--(height.north -| error.south); +\end{tikzpicture} +\caption{The use of one nonzero $\delta$ for every $A\in R$. +All slopes shown come from the representation chosen at the fixed ordinary +precision $K$, and $M_K$ uses the fixed exceptional set for $K$. +The comparison holds for every $a\in R$, so it applies to the fixed root tuple. +The implied constant in the final bound is ordinary and independent of $A$ +and $\mathbf a$.} +\label{fig:finite-test-proof} +\end{figure} diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/main.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..911cd422d592d7e08326f329790a837c89a337ca --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/main.tex @@ -0,0 +1,81 @@ +\documentclass[11pt]{article} +\pdfinfoomitdate=1 +\pdftrailerid{} +\pdfsuppressptexinfo=15 +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage[a4paper,margin=29mm]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{microtype} +\usepackage{enumitem,booktabs,array} +\usepackage{xcolor} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning} +\usepackage{xurl} +\usepackage[nottoc,notlof,notlot]{tocbibind} +\usepackage{hyperref} +\hypersetup{colorlinks=true,linkcolor=blue!45!black,citecolor=blue!45!black,urlcolor=blue!45!black, + pdftitle={Hilbert's tenth problem over the rational numbers},pdfauthor={OpenAI},pdflang={en}} +\urlstyle{same} +\newcommand{\bibdoi}[1]{\href{https://doi.org/#1}{doi:\nolinkurl{#1}}} +\setlength{\emergencystretch}{2em} +\numberwithin{equation}{section} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{remark}[theorem]{Remark} +\newtheorem{notation}[theorem]{Notation} +\newcommand{\Q}{\mathbb Q} +\newcommand{\Z}{\mathbb Z} +\newcommand{\N}{\mathbb N} +\newcommand{\F}{\mathbb F} +\newcommand{\R}{\mathbb R} +\newcommand{\C}{\mathbb C} +\newcommand{\hgt}{h} +\newcommand{\Sha}{\mathop{\mathrm{Sha}}} +\DeclareMathOperator{\Sel}{Sel} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\corank}{corank} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\rad}{rad} +\DeclareMathOperator{\Gal}{Gal} +\DeclareMathOperator{\End}{End} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\Frac}{Frac} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\coker}{coker} +\DeclareMathOperator{\Br}{Br} +\DeclareMathOperator{\GL}{GL} +\DeclareMathOperator{\GSp}{GSp} +\DeclareMathOperator{\Trd}{Trd} +\DeclareMathOperator{\Nrd}{Nrd} +\newcommand{\st}{^{*}} +\title{Hilbert's tenth problem over the rational numbers} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\maketitle +\begin{abstract} +We give a negative answer to Hilbert's tenth problem over the rational numbers: +no algorithm decides whether a polynomial with integer coefficients has a rational +zero. The number of variables is part of the input. +\end{abstract} +\clearpage +{\small\setlength{\parskip}{0pt}\tableofcontents} +\clearpage +\input{sections/01-introduction} +\input{sections/02-reduction} +\input{sections/03-parity} +\input{sections/04-height} +\input{sections/05-elliptic} +\input{sections/06-primes} +\input{sections/07-consequences} + +\bibliographystyle{plain} +\bibliography{references/references} +\end{document} diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/references/references.bib b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/references/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..1e916a1fd82fdad388ac49ff8a2abbe42850dc2a --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/references/references.bib @@ -0,0 +1,1078 @@ + +@article{SilverbergZarhin1995, + author = {Silverberg, Alice and Zarhin, Yuri G.}, + title = {Semistable reduction and torsion subgroups of abelian varieties}, + journal = {Annales de l'Institut Fourier}, + volume = {45}, + number = {2}, + year = {1995}, + pages = {403--420}, + doi = {10.5802/aif.1459}, + url = {https://aif.centre-mersenne.org/articles/10.5802/aif.1459/}, + note = {\bibdoi{10.5802/aif.1459}} +} + + +@misc{PointwiseTwoConverse, + author = {{OpenAI}}, + title = {{A pointwise $2$-converse for elliptic curves with rational two-torsion}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026/paper.pdf}{OAI:A-pointwise-2-converse-for-elliptic-curves-with-rational-two-torsion-October-7-2026}}, + year = {2026}, + note = {Theorem~1.1} +} +@misc{UnrestrictedTwoConverse, + author = {{OpenAI}}, + title = {{Goldfeld's analytic density conjecture and the $2$-converse for elliptic curves}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026/paper.pdf}{OAI:Goldfelds-analytic-density-conjecture-and-the-2-converse-for-elliptic-curves-October-7-2026}}, + year = {2026}, + note = {Theorem~1.1} +} +@misc{OddRegularFontaineMazurAtTwo, + author = {{OpenAI}}, + title = {{Fontaine--Mazur modularity at the prime 2}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026/paper.pdf}{OAI:Fontaine-Mazur-modularity-at-the-prime-2-October-6-2026}}, + year = {2026}, + note = {Theorem~1.1 and Section~2.1} +} + +@book{Silverman2009, + author = {Silverman, Joseph H.}, + title = {The Arithmetic of Elliptic Curves}, + edition = {Second}, + series = {Graduate Texts in Mathematics}, + volume = {106}, + publisher = {Springer}, + address = {New York}, + year = {2009}, + doi = {10.1007/978-0-387-09494-6}, + url = {https://doi.org/10.1007/978-0-387-09494-6}, + note = {\bibdoi{10.1007/978-0-387-09494-6}} +} +@article{Cassels1962, + author = {Cassels, J. W. S.}, + title = {Arithmetic on curves of genus 1. {IV}. {Proof} of the {Hauptvermutung}}, + journal = {Journal f{\"u}r die reine und angewandte Mathematik}, + volume = {211}, + year = {1962}, + pages = {95--112}, + doi = {10.1515/crll.1962.211.95}, + url = {https://doi.org/10.1515/crll.1962.211.95}, + note = {\bibdoi{10.1515/crll.1962.211.95}} +} +@article{PoonenStoll1999, + author = {Poonen, Bjorn and Stoll, Michael}, + title = {The {Cassels--Tate} pairing on polarized abelian varieties}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {150}, + number = {3}, + year = {1999}, + pages = {1109--1149}, + doi = {10.2307/121064}, + url = {https://math.mit.edu/~poonen/papers/sha.pdf}, + note = {\bibdoi{10.2307/121064}} +} +@book{BoschLutkebohmertRaynaud1990, + author = {Bosch, Siegfried and L{\"u}tkebohmert, Werner and Raynaud, Michel}, + title = {N{\'e}ron Models}, + series = {Ergebnisse der Mathematik und ihrer Grenzgebiete}, + volume = {21}, + publisher = {Springer}, + address = {Berlin}, + year = {1990}, + doi = {10.1007/978-3-642-51438-8}, + url = {https://doi.org/10.1007/978-3-642-51438-8}, + note = {\bibdoi{10.1007/978-3-642-51438-8}} +} +@book{Davenport2000, + author = {Davenport, Harold}, + title = {Multiplicative Number Theory}, + edition = {Third}, + series = {Graduate Texts in Mathematics}, + volume = {74}, + publisher = {Springer-Verlag}, + address = {New York}, + year = {2000}, + note = {Revised and with a preface by Hugh L. Montgomery. \href{https://link.springer.com/book/9780387950976}{Source}}, + isbn = {978-0-387-95097-6}, + url = {https://link.springer.com/book/9780387950976} +} +@book{Neukirch1999, + author = {Neukirch, J{\"u}rgen}, + title = {Algebraic Number Theory}, + series = {Grundlehren der mathematischen Wissenschaften}, + volume = {322}, + publisher = {Springer}, + address = {Berlin}, + year = {1999}, + note = {Translated from the German by Norbert Schappacher. \bibdoi{10.1007/978-3-662-03983-0}}, + doi = {10.1007/978-3-662-03983-0}, + url = {https://doi.org/10.1007/978-3-662-03983-0} +} +@article{GreenTao2010, + author = {Green, Benjamin and Tao, Terence}, + title = {Linear equations in primes}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {171}, + number = {3}, + year = {2010}, + pages = {1753--1850}, + doi = {10.4007/annals.2010.171.1753}, + url = {https://annals.math.princeton.edu/2010/171-3/p08}, + note = {\bibdoi{10.4007/annals.2010.171.1753}} +} +@article{GreenTao2012, + author = {Green, Ben and Tao, Terence}, + title = {The {M{\"o}bius} function is strongly orthogonal to nilsequences}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {175}, + number = {2}, + year = {2012}, + pages = {541--566}, + doi = {10.4007/annals.2012.175.2.3}, + url = {https://annals.math.princeton.edu/2012/175-2/p03}, + note = {\bibdoi{10.4007/annals.2012.175.2.3}} +} +@article{GreenTaoZiegler2012, + author = {Green, Ben and Tao, Terence and Ziegler, Tamar}, + title = {An inverse theorem for the {Gowers} {$U^{s+1}[N]$}-norm}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {176}, + number = {2}, + year = {2012}, + pages = {1231--1372}, + doi = {10.4007/annals.2012.176.2.11}, + url = {https://annals.math.princeton.edu/2012/176-2/p11}, + note = {\bibdoi{10.4007/annals.2012.176.2.11}} +} +@misc{GreenTaoZiegler2024Erratum, + author = {Green, Ben and Tao, Terence and Ziegler, Tamar}, + title = {Erratum for {An inverse theorem for the Gowers {$U^{s+1}[N]$}-norm}}, + year = {2024}, + month = apr, + note = {Six-page author erratum. \href{https://terrytao.wordpress.com/wp-content/uploads/2024/04/erratum-4.pdf}{Source}}, + url = {https://terrytao.wordpress.com/wp-content/uploads/2024/04/erratum-4.pdf} +} +@book{Voight2021, + author = {Voight, John}, + title = {Quaternion Algebras}, + series = {Graduate Texts in Mathematics}, + volume = {288}, + publisher = {Springer}, + address = {Cham}, + year = {2021}, + doi = {10.1007/978-3-030-56694-4}, + url = {https://doi.org/10.1007/978-3-030-56694-4}, + note = {\bibdoi{10.1007/978-3-030-56694-4}} +} +@article{Pazuki2012, + author = {Pazuki, Fabien}, + title = {Theta height and {Faltings} height}, + journal = {Bulletin de la Soci{\'e}t{\'e} Math{\'e}matique de France}, + volume = {140}, + number = {1}, + year = {2012}, + pages = {19--49}, + doi = {10.24033/bsmf.2623}, + url = {https://www.numdam.org/item/BSMF_2012__140_1_19_0/}, + note = {\bibdoi{10.24033/bsmf.2623}} +} +@article{Javanpeykar2014, + author = {Javanpeykar, Ariyan}, + title = {Polynomial bounds for {Arakelov} invariants of {Belyi} curves}, + journal = {Algebra \& Number Theory}, + volume = {8}, + number = {1}, + year = {2014}, + pages = {89--140}, + note = {With an appendix by Peter Bruin. \bibdoi{10.2140/ant.2014.8.89}}, + doi = {10.2140/ant.2014.8.89}, + url = {https://msp.org/ant/2014/8-1/p04.xhtml} +} +@article{GaudronRemond2014, + author = {Gaudron, {\'E}ric and R{\'e}mond, Ga{\"e}l}, + title = {Polarisations et isog{\'e}nies}, + journal = {Duke Mathematical Journal}, + volume = {163}, + number = {11}, + year = {2014}, + pages = {2057--2108}, + doi = {10.1215/00127094-2782528}, + url = {https://lmbp.uca.fr/~gaudron/art13.pdf}, + note = {\bibdoi{10.1215/00127094-2782528}} +} +@article{Faltings1983, + author = {Faltings, Gerd}, + title = {Endlichkeitss{\"a}tze f{\"u}r abelsche {Variet{\"a}ten} {\"u}ber {Zahlk{\"o}rpern}}, + journal = {Inventiones Mathematicae}, + volume = {73}, + number = {3}, + year = {1983}, + pages = {349--366}, + doi = {10.1007/BF01388432}, + url = {https://doi.org/10.1007/BF01388432}, + note = {\bibdoi{10.1007/BF01388432}. Erratum: ibid. 75 (1984), 381, \bibdoi{10.1007/BF01388572}} +} +@article{SerreTate1968, + author = {Serre, Jean-Pierre and Tate, John}, + title = {Good reduction of abelian varieties}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {88}, + number = {3}, + year = {1968}, + pages = {492--517}, + doi = {10.2307/1970722}, + url = {https://annals.math.princeton.edu/1968/88-3/p05}, + note = {\bibdoi{10.2307/1970722}} +} +@book{Serre1979, + author = {Serre, Jean-Pierre}, + title = {Local Fields}, + series = {Graduate Texts in Mathematics}, + volume = {67}, + publisher = {Springer-Verlag}, + address = {New York}, + year = {1979}, + note = {Translated from the French by Marvin Jay Greenberg. \bibdoi{10.1007/978-1-4757-5673-9}}, + doi = {10.1007/978-1-4757-5673-9}, + url = {https://doi.org/10.1007/978-1-4757-5673-9} +} +@book{Serre1997, + author = {Serre, Jean-Pierre}, + title = {Galois Cohomology}, + series = {Springer Monographs in Mathematics}, + publisher = {Springer-Verlag}, + address = {Berlin}, + year = {1997}, + note = {Translated from the French by Patrick Ion. \bibdoi{10.1007/978-3-642-59141-9}}, + doi = {10.1007/978-3-642-59141-9}, + url = {https://doi.org/10.1007/978-3-642-59141-9} +} +@book{MilneADT2006, + author = {Milne, James S.}, + title = {Arithmetic Duality Theorems}, + edition = {Second}, + publisher = {BookSurge}, + address = {Charleston, SC}, + year = {2006}, + url = {https://www.jmilne.org/math/Books/adt.html}, + note = {\href{https://www.jmilne.org/math/Books/adt.html}{Source}} +} +@misc{MilneAV2008, + author = {Milne, James S.}, + title = {{Abelian Varieties}}, + year = {2008}, + note = {Course notes, version 2.0, March 16. \href{https://www.jmilne.org/math/CourseNotes/AV.pdf}{Source}}, + url = {https://www.jmilne.org/math/CourseNotes/AV.pdf} +} +@misc{MilneCFT2020, + author = {Milne, James S.}, + title = {{Class Field Theory}}, + year = {2020}, + note = {Course notes, version 4.03, August 6. \href{https://www.jmilne.org/math/CourseNotes/CFT.pdf}{Source}}, + url = {https://www.jmilne.org/math/CourseNotes/CFT.pdf} +} +@misc{MilneEtale2013, + author = {Milne, James S.}, + title = {{Lectures on {\'E}tale Cohomology}}, + year = {2013}, + note = {Course notes, version 2.21, March 22. \href{https://www.jmilne.org/math/CourseNotes/LEC.pdf}{Source}}, + url = {https://www.jmilne.org/math/CourseNotes/LEC.pdf} +} +@book{Mumford1970, + author = {Mumford, David}, + title = {Abelian Varieties}, + series = {Tata Institute of Fundamental Research Studies in Mathematics}, + volume = {5}, + publisher = {Oxford University Press}, + address = {London}, + year = {1970} +} +@book{Marker2002, + author = {Marker, David}, + title = {Model Theory: An Introduction}, + series = {Graduate Texts in Mathematics}, + volume = {217}, + publisher = {Springer}, + address = {New York}, + year = {2002}, + doi = {10.1007/b98860}, + url = {https://doi.org/10.1007/b98860}, + note = {\bibdoi{10.1007/b98860}} +} + + +@article{Hilbert1900, + author = {Hilbert, David}, + title = {{Mathematische Probleme. Vortrag, gehalten auf dem internationalen Mathematiker-Kongre{\ss} zu Paris 1900}}, + journal = {Nachrichten von der K{\"o}niglichen Gesellschaft der Wissenschaften zu G{\"o}ttingen, Mathematisch-Physikalische Klasse}, + volume = {1900}, + number = {3}, + year = {1900}, + pages = {253--297}, + url = {https://gdz.sub.uni-goettingen.de/id/PPN252457811_1900}, + language = {German}, + note = {\href{https://gdz.sub.uni-goettingen.de/id/PPN252457811_1900}{Source}} +} + +@article{DavisPutnamRobinson1961, + author = {Davis, Martin and Putnam, Hilary and Robinson, Julia}, + title = {The decision problem for exponential {Diophantine} equations}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {74}, + number = {3}, + year = {1961}, + pages = {425--436}, + doi = {10.2307/1970289}, + url = {https://doi.org/10.2307/1970289}, + note = {\bibdoi{10.2307/1970289}} +} + +@article{Davis1973, + author = {Davis, Martin}, + title = {{Hilbert}'s tenth problem is unsolvable}, + journal = {The American Mathematical Monthly}, + volume = {80}, + number = {3}, + year = {1973}, + pages = {233--269}, + url = {https://math.umd.edu/~mcl/Pubs/713/Diophantine.pdf}, + note = {\href{https://math.umd.edu/~mcl/Pubs/713/Diophantine.pdf}{Source}} +} + +@article{Matiyasevich1970, + author = {Matiyasevich, Yu. V.}, + title = {Diofantovost' perechislimykh mnozhestv}, + journal = {Doklady Akademii Nauk SSSR}, + volume = {191}, + number = {2}, + year = {1970}, + pages = {279--282}, + url = {https://www.mathnet.ru/eng/dan35274}, + language = {Russian}, + note = {English title: The Diophantineness of enumerable sets. \href{https://www.mathnet.ru/eng/dan35274}{Source}} +} + +@article{Robinson1949, + author = {Robinson, Julia}, + title = {Definability and decision problems in arithmetic}, + journal = {The Journal of Symbolic Logic}, + volume = {14}, + number = {2}, + year = {1949}, + pages = {98--114}, + doi = {10.2307/2266510}, + url = {https://doi.org/10.2307/2266510}, + note = {\bibdoi{10.2307/2266510}} +} + +@article{Poonen2009, + author = {Poonen, Bjorn}, + title = {Characterizing integers among rational numbers with a universal-existential formula}, + journal = {American Journal of Mathematics}, + volume = {131}, + number = {3}, + year = {2009}, + pages = {675--682}, + doi = {10.1353/ajm.0.0057}, + url = {https://doi.org/10.1353/ajm.0.0057}, + eprint = {math/0703907}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {\bibdoi{10.1353/ajm.0.0057}} +} + +@article{Koenigsmann2016, + author = {Koenigsmann, Jochen}, + title = {Defining {$\mathbb{Z}$} in {$\mathbb{Q}$}}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {183}, + number = {1}, + year = {2016}, + pages = {73--93}, + doi = {10.4007/annals.2016.183.1.2}, + url = {https://doi.org/10.4007/annals.2016.183.1.2}, + eprint = {1011.3424}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {\bibdoi{10.4007/annals.2016.183.1.2}} +} + +@article{PoonenSubrings, + author = {Poonen, Bjorn}, + title = {{Hilbert}'s tenth problem and {Mazur}'s conjecture for large subrings of {$\mathbb{Q}$}}, + journal = {Journal of the American Mathematical Society}, + volume = {16}, + number = {4}, + year = {2003}, + pages = {981--990}, + doi = {10.1090/S0894-0347-03-00433-8}, + url = {https://doi.org/10.1090/S0894-0347-03-00433-8}, + eprint = {math/0306277}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {\bibdoi{10.1090/S0894-0347-03-00433-8}} +} + +@article{PoonenSurvey, + author = {Poonen, Bjorn}, + title = {Undecidability in number theory}, + journal = {Notices of the American Mathematical Society}, + volume = {55}, + number = {3}, + year = {2008}, + pages = {344--350}, + url = {https://math.mit.edu/~poonen/papers/h10_notices.pdf}, + note = {\href{https://math.mit.edu/~poonen/papers/h10_notices.pdf}{Source}} +} + +@incollection{Deligne1971, + author = {Deligne, Pierre}, + title = {Travaux de {Shimura}}, + booktitle = {S{\'e}minaire Bourbaki, Vol. 1970/71, + Expos{\'e}s 382--399}, + series = {Lecture Notes in Mathematics}, + volume = {244}, + publisher = {Springer-Verlag}, + year = {1971}, + pages = {123--165}, + note = {Expos{\'e} 389. \href{https://www.numdam.org/item/SB_1970-1971__13__123_0/}{Source}}, + url = {https://www.numdam.org/item/SB_1970-1971__13__123_0/} +} + +@incollection{Deligne1979, + author = {Deligne, Pierre}, + title = {Vari{\'e}t{\'e}s de {Shimura}: + interpr{\'e}tation modulaire, et techniques de + construction de mod{\`e}les canoniques}, + booktitle = {Automorphic Forms, Representations and {$L$}-Functions, + Part 2}, + series = {Proceedings of Symposia in Pure Mathematics}, + volume = {33}, + publisher = {American Mathematical Society}, + year = {1979}, + pages = {247--289}, + url = {https://publications.ias.edu/deligne/paper/380}, + note = {\href{https://publications.ias.edu/deligne/paper/380}{Source}} +} + +@incollection{Deligne1971Modular, + author = {Deligne, Pierre}, + title = {Formes modulaires et repr{\'e}sentations {$\ell$}-adiques}, + booktitle = {S{\'e}minaire Bourbaki, Vol. 1968/69, + Expos{\'e}s 347--363}, + series = {Lecture Notes in Mathematics}, + volume = {179}, + publisher = {Springer-Verlag}, + year = {1971}, + pages = {139--172}, + note = {Expos{\'e} 355. \href{https://www.numdam.org/item/SB_1968-1969__11__139_0/}{Source}}, + url = {https://www.numdam.org/item/SB_1968-1969__11__139_0/} +} + +@incollection{Fontaine1994, + author = {Fontaine, Jean-Marc}, + title = {Repr{\'e}sentations {$p$}-adiques semi-stables}, + booktitle = {P{\'e}riodes {$p$}-adiques: + S{\'e}minaire de Bures, 1988}, + editor = {Fontaine, Jean-Marc}, + series = {Ast{\'e}risque}, + number = {223}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + year = {1994}, + pages = {113--184}, + note = {Expos{\'e} III. \href{https://www.numdam.org/item/AST_1994__223__113_0/}{Source}}, + url = {https://www.numdam.org/item/AST_1994__223__113_0/} +} +@incollection{Faltings1989, + author = {Faltings, Gerd}, + title = {Crystalline cohomology and {$p$}-adic + {Galois} representations}, + booktitle = {Algebraic Analysis, Geometry, and Number Theory}, + editor = {Igusa, Jun-Ichi}, + publisher = {Johns Hopkins University Press}, + address = {Baltimore, MD}, + year = {1989}, + pages = {25--80} +} + +@article{Faltings1988, + author = {Faltings, Gerd}, + title = {{$p$}-adic {Hodge} theory}, + journal = {Journal of the American Mathematical Society}, + volume = {1}, + number = {1}, + year = {1988}, + pages = {255--299}, + doi = {10.1090/S0894-0347-1988-0924705-1}, + note = {\bibdoi{10.1090/S0894-0347-1988-0924705-1}} +} + +@article{Carayol1986, + author = {Carayol, Henri}, + title = {Sur les repr{\'e}sentations {$l$}-adiques associ{\'e}es + aux formes modulaires de {Hilbert}}, + journal = {Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series = {4}, + volume = {19}, + number = {3}, + year = {1986}, + pages = {409--468}, + doi = {10.24033/asens.1512}, + url = {https://numdam.org/articles/10.24033/asens.1512/}, + note = {\bibdoi{10.24033/asens.1512}} +} + +@book{Cox2013, + author = {Cox, David A.}, + title = {Primes of the Form {$x^2+ny^2$}: + Fermat, Class Field Theory, and Complex Multiplication}, + edition = {Second}, + publisher = {John Wiley \& Sons}, + year = {2013}, + isbn = {978-1-118-39018-4}, + doi = {10.1002/9781118400722}, + note = {\bibdoi{10.1002/9781118400722}} +} +@article{Siegel1935, + author = {Siegel, Carl Ludwig}, + title = {{{\"U}ber die Classenzahl quadratischer Zahlk{\"o}rper}}, + journal = {Acta Arithmetica}, + volume = {1}, + number = {1}, + year = {1935}, + pages = {83--86}, + doi = {10.4064/aa-1-1-83-86}, + note = {\bibdoi{10.4064/aa-1-1-83-86}} +} + +@article{Zarhin1974, + author = {Zarhin, Yu. G.}, + title = {A remark on endomorphisms of abelian varieties over + function fields of finite characteristic}, + journal = {Mathematics of the USSR-Izvestiya}, + volume = {8}, + number = {3}, + year = {1974}, + pages = {477--480}, + doi = {10.1070/IM1974v008n03ABEH002115}, + url = {https://www.mathnet.ru/eng/im1933}, + note = {\bibdoi{10.1070/IM1974v008n03ABEH002115}} +} + +@article{Bost1996, + author = {Bost, Jean-Beno{\^\i}t}, + title = {Intrinsic heights of stable varieties and abelian varieties}, + journal = {Duke Mathematical Journal}, + volume = {82}, + number = {1}, + year = {1996}, + pages = {21--70}, + doi = {10.1215/S0012-7094-96-08202-2}, + note = {\bibdoi{10.1215/S0012-7094-96-08202-2}} +} +@incollection{Bost1996Bourbaki, + author = {Bost, Jean-Beno{\^\i}t}, + title = {{P{\'e}riodes et isog{\'e}nies des vari{\'e}t{\'e}s + ab{\'e}liennes sur les corps de nombres + (d'apr{\`e}s D. Masser et G. W{\"u}stholz)}}, + booktitle = {S{\'e}minaire Bourbaki, Vol. 1994/95, + Expos{\'e}s 790--804}, + series = {Ast{\'e}risque}, + number = {237}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + year = {1996}, + pages = {115--161}, + note = {Expos{\'e} 795. \href{https://archive.numdam.org/item/SB_1994-1995__37__115_0/}{Source}}, + url = {https://archive.numdam.org/item/SB_1994-1995__37__115_0/} +} + +@book{BombieriGubler2006, + author = {Bombieri, Enrico and Gubler, Walter}, + title = {Heights in Diophantine Geometry}, + series = {New Mathematical Monographs}, + volume = {4}, + publisher = {Cambridge University Press}, + year = {2006}, + isbn = {978-0-521-84615-8}, + doi = {10.1017/CBO9780511542879}, + note = {\bibdoi{10.1017/CBO9780511542879}} +} + +@article{GaudronRemondPeriods2014, + author = {Gaudron, {\'E}ric and R{\'e}mond, Ga{\"e}l}, + title = {Th{\'e}or{\`e}me des p{\'e}riodes et degr{\'e}s minimaux d'isog{\'e}nies}, + journal = {Commentarii Mathematici Helvetici}, + volume = {89}, + number = {2}, + year = {2014}, + pages = {343--403}, + doi = {10.4171/CMH/322}, + url = {https://lmbp.uca.fr/~gaudron/art11.pdf}, + note = {\bibdoi{10.4171/CMH/322}} +} + +@article{vonKaenel2021, + author = {von K{\"a}nel, Rafael}, + title = {The effective {Shafarevich} conjecture for abelian varieties of {$\mathrm{GL}_2$}-type}, + journal = {Forum of Mathematics, Sigma}, + volume = {9}, + year = {2021}, + pages = {e39, 1--29}, + doi = {10.1017/fms.2021.29}, + url = {https://doi.org/10.1017/fms.2021.29}, + note = {\bibdoi{10.1017/fms.2021.29}} +} + +@misc{Alpoge2021, + author = {Alp{\"o}ge, Levent}, + title = {Modularity and effective {Mordell} {I}}, + year = {2021}, + eprint = {2109.07917}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/2109.07917}, + note = {arXiv:2109.07917v2, November 24, 2021. \href{https://arxiv.org/abs/2109.07917}{Source}} +} + +@article{GarciaFritzPastenVidaux2025, + author = {Garcia-Fritz, Natalia and Pasten, Hector and Vidaux, Xavier}, + title = {Effectivity for existence of rational points is undecidable}, + journal = {Journal of Number Theory}, + volume = {276}, + year = {2025}, + pages = {81--97}, + doi = {10.1016/j.jnt.2025.01.023}, + url = {https://doi.org/10.1016/j.jnt.2025.01.023}, + eprint = {2311.01958}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + note = {\bibdoi{10.1016/j.jnt.2025.01.023}} +} + + +@incollection{PoonenRankOne2002, + author = {Poonen, Bjorn}, + title = {Using elliptic curves of rank one towards the undecidability of + {Hilbert}'s tenth problem over rings of algebraic integers}, + booktitle = {Algorithmic Number Theory: 5th International Symposium, + {ANTS-V}, Sydney, Australia, July 2002, Proceedings}, + editor = {Fieker, Claus and Kohel, David R.}, + series = {Lecture Notes in Computer Science}, + volume = {2369}, + pages = {33--42}, + publisher = {Springer-Verlag}, + address = {Berlin}, + year = {2002}, + url = {https://math.mit.edu/~poonen/papers/ants5.pdf}, + note = {\href{https://math.mit.edu/~poonen/papers/ants5.pdf}{Source}} +} + +@article{CornelissenZahidi2007, + author = {Cornelissen, Gunther and Zahidi, Karim}, + title = {Elliptic divisibility sequences and undecidable problems + about rational points}, + journal = {Journal f{\"u}r die reine und angewandte Mathematik}, + volume = {613}, + year = {2007}, + pages = {1--33}, + eprint = {math/0412473}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/math/0412473v3}, + note = {Author manuscript, version 3, June 23, 2006. \href{https://arxiv.org/abs/math/0412473v3}{Source}} +} + +@article{Scholze2013DeRham, + author = {Scholze, Peter}, + title = {{$p$}-adic {Hodge} theory for rigid-analytic varieties}, + journal = {Forum of Mathematics, Pi}, + volume = {1}, + year = {2013}, + eid = {e1}, + pages = {e1, 1--77}, + doi = {10.1017/fmp.2013.1}, + url = {https://www.math.uni-bonn.de/people/scholze/pAdicHodgeTheory.pdf}, + note = {Corollary 1.8; see also the 2016 corrigendum. \bibdoi{10.1017/fmp.2013.1}} +} +@article{Scholze2016DeRhamCorrigendum, + author = {Scholze, Peter}, + title = {{$p$}-adic {Hodge} theory for rigid-analytic varieties---corrigendum}, + journal = {Forum of Mathematics, Pi}, + volume = {4}, + year = {2016}, + eid = {e6}, + pages = {e6}, + doi = {10.1017/fmp.2016.4}, + url = {https://people.math.uni-bonn.de/scholze/pAdicHodgeErratum.pdf}, + note = {\bibdoi{10.1017/fmp.2016.4}} +} + +@article{GuitartMolina2009, + author = {Guitart, Xavier and Molina, Santiago}, + title = {Parametrization of {Abelian} {$K$}-surfaces with quaternionic multiplication}, + journal = {Comptes Rendus. Math\'ematique}, + volume = {347}, + number = {23--24}, + pages = {1325--1330}, + year = {2009}, + doi = {10.1016/j.crma.2009.09.025}, + url = {https://www.numdam.org/item/10.1016/j.crma.2009.09.025.pdf}, + note = {\bibdoi{10.1016/j.crma.2009.09.025}} +} + +@incollection{Ribet1992, + author = {Ribet, Kenneth A.}, + title = {Abelian varieties over {$\mathbf{Q}$} and modular forms}, + booktitle = {Algebra and Topology 1992}, + publisher = {Korea Advanced Institute of Science and Technology}, + address = {Taejon}, + pages = {53--79}, + year = {1992}, + note = {Preprint arXiv:alg-geom/9208002. \href{https://arxiv.org/abs/alg-geom/9208002}{Source}}, + url = {https://arxiv.org/abs/alg-geom/9208002} +} + +@phdthesis{Pyle1995, + author = {Pyle, Elisabeth Eve}, + title = {Abelian Varieties over {$\mathbf{Q}$} with Large Endomorphism Algebras and Their Simple Components over {$\overline{\mathbf{Q}}$}}, + school = {University of California, Berkeley}, + year = {1995}, + url = {https://math.berkeley.edu/~ribet/pyle_thesis.pdf} +} + +@article{Quer2000, + author = {Quer, Jordi}, + title = {{$\mathbf{Q}$}-curves and abelian varieties of {$\mathrm{GL}_2$}-type}, + journal = {Proceedings of the London Mathematical Society}, + series = {3}, + volume = {81}, + number = {2}, + pages = {285--317}, + year = {2000}, + doi = {10.1112/S0024611500012570} +} + +@article{Quer2001Fields, + author = {Quer, Jordi}, + title = {Fields of definition of {$\mathbf{Q}$}-curves}, + journal = {Journal de Th\'eorie des Nombres de Bordeaux}, + volume = {13}, + number = {1}, + year = {2001}, + pages = {275--285}, + doi = {10.5802/jtnb.321}, + url = {https://www.numdam.org/article/JTNB_2001__13_1_275_0.pdf}, + note = {\bibdoi{10.5802/jtnb.321}} +} + +@article{Williams1974, + author = {Williams, Kenneth S.}, + title = {Mertens' theorem for arithmetic progressions}, + journal = {Journal of Number Theory}, + volume = {6}, + year = {1974}, + pages = {353--359}, + doi = {10.1016/0022-314X(74)90032-8}, + url = {https://people.math.carleton.ca/~williams/papers/pdf/057.pdf}, + note = {\bibdoi{10.1016/0022-314X(74)90032-8}} +} +@book{MontgomeryVaughan2007, + author = {Montgomery, Hugh L. and Vaughan, Robert C.}, + title = {Multiplicative Number Theory I: Classical Theory}, + series = {Cambridge Studies in Advanced Mathematics}, + volume = {97}, + publisher = {Cambridge University Press}, + year = {2007}, + doi = {10.1017/CBO9780511618314}, + note = {\bibdoi{10.1017/CBO9780511618314}} +} +@article{Selberg1947, + author = {Selberg, Atle}, + title = {On an elementary method in the theory of primes}, + journal = {Norske Videnskabers Selskab, Forhandlinger}, + volume = {19}, + number = {18}, + year = {1947}, + pages = {64--67} +} + +@incollection{Ribet1977Nebentypus, + author = {Ribet, Kenneth A.}, + title = {Galois representations attached to eigenforms with nebentypus}, + booktitle = {Modular Functions of One Variable V}, + editor = {Serre, Jean-Pierre and Zagier, Don Bernard}, + series = {Lecture Notes in Mathematics}, + volume = {601}, + pages = {18--52}, + publisher = {Springer}, + address = {Berlin, Heidelberg}, + year = {1977}, + doi = {10.1007/BFb0063943}, + url = {https://doi.org/10.1007/BFb0063943}, + note = {\bibdoi{10.1007/BFb0063943}} +} + +@incollection{Zarhin2023Quaternion, + author = {Zarhin, Yuri G.}, + title = {Abelian varieties, quaternion trick and endomorphisms}, + booktitle = {Birational Geometry, K{\"a}hler--Einstein Metrics and Degenerations}, + editor = {Cheltsov, Ivan and Chen, Xiuxiong and Katzarkov, Ludmil and Park, Jihun}, + series = {Springer Proceedings in Mathematics and Statistics}, + volume = {409}, + publisher = {Springer}, + address = {Cham}, + pages = {857--864}, + year = {2023}, + doi = {10.1007/978-3-031-17859-7_42}, + url = {https://doi.org/10.1007/978-3-031-17859-7_42}, + eprint = {2010.07995}, + archivePrefix = {arXiv}, + note = {Author version arXiv:2010.07995v5. \bibdoi{10.1007/978-3-031-17859-7_42}} +} + + +@article{Mazur1995, + author = {Mazur, Barry}, + title = {Speculations about the topology of rational points: an up-date}, + journal = {Ast{\'e}risque}, + number = {228}, + year = {1995}, + pages = {165--181}, + url = {https://www.numdam.org/item/AST_1995__228__165_0/}, + note = {\href{https://www.numdam.org/item/AST_1995__228__165_0/}{Source}} +} + +@incollection{CornelissenZahidi2000, + author = {Cornelissen, Gunther and Zahidi, Karim}, + title = {Topology of {Diophantine} sets: remarks on {Mazur}'s conjectures}, + booktitle = {Hilbert's Tenth Problem: Relations with Arithmetic and Algebraic Geometry}, + editor = {Denef, Jan and Lipshitz, Leonard and Pheidas, Thanases and Van Geel, Jan}, + series = {Contemporary Mathematics}, + volume = {270}, + publisher = {American Mathematical Society}, + address = {Providence, RI}, + year = {2000}, + pages = {253--260}, + doi = {10.1090/conm/270/04377}, + eprint = {math/0006140}, + archivePrefix = {arXiv}, + primaryClass = {math.LO}, + url = {https://arxiv.org/abs/math/0006140}, + note = {Author preprint dated June 20, 2000. \bibdoi{10.1090/conm/270/04377}} +} + +@article{EisentragerMillerParkShlapentokh2017, + author = {Eisentr{\"a}ger, Kirsten and Miller, Russell and Park, Jennifer and Shlapentokh, Alexandra}, + title = {As easy as {$\mathbb{Q}$}: {Hilbert}'s tenth problem for subrings of the rationals and number fields}, + journal = {Transactions of the American Mathematical Society}, + volume = {369}, + number = {11}, + year = {2017}, + pages = {8291--8315}, + doi = {10.1090/tran/7075}, + eprint = {1601.07158}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/1601.07158}, + note = {\bibdoi{10.1090/tran/7075}} +} + +@article{MazurRubin2010, + author = {Mazur, Barry and Rubin, Karl}, + title = {Ranks of twists of elliptic curves and {Hilbert}'s tenth problem}, + journal = {Inventiones Mathematicae}, + volume = {181}, + number = {3}, + year = {2010}, + pages = {541--575}, + doi = {10.1007/s00222-010-0252-0}, + url = {https://escholarship.org/content/qt3nx8s5vn/qt3nx8s5vn.pdf}, + note = {\bibdoi{10.1007/s00222-010-0252-0}} +} + +@article{KoymansPagano2026, + author = {Koymans, Peter and Pagano, Carlo}, + title = {{Hilbert}'s tenth problem via additive combinatorics}, + journal = {Journal of the American Mathematical Society}, + year = {2026}, + doi = {10.1090/jams/1081}, + eprint = {2412.01768}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://doi.org/10.1090/jams/1081}, + note = {Published electronically August 10, 2026; arXiv:2412.01768v3 submitted November 24, 2025. \bibdoi{10.1090/jams/1081}} +} + +@article{AlpogeBhargavaHoShnidman2026, + author = {Alp{\"o}ge, Levent and Bhargava, Manjul and Ho, Wei and Shnidman, Ari}, + title = {Rank stability in quadratic extensions and {Hilbert}'s tenth problem for the ring of integers of a number field}, + journal = {Inventiones Mathematicae}, + volume = {243}, + year = {2026}, + pages = {1129--1139}, + doi = {10.1007/s00222-025-01392-3}, + url = {https://doi.org/10.1007/s00222-025-01392-3}, + note = {Version of record published online December 1, 2025. \bibdoi{10.1007/s00222-025-01392-3}} +} + +@article{DemeyerVanGeel2006, + author = {Demeyer, Jeroen and Van Geel, Jan}, + title = {An existential divisibility lemma for global fields}, + journal = {Monatshefte f{\"u}r Mathematik}, + volume = {147}, + number = {4}, + year = {2006}, + pages = {293--308}, + doi = {10.1007/s00605-005-0342-z}, + url = {https://backoffice.biblio.ugent.be/download/328999/454769}, + note = {Author manuscript dated July 11, 2005. \bibdoi{10.1007/s00605-005-0342-z}} +} + +@article{Mokrani2020, + author = {Mokrani, Youcef}, + title = {Adaptation of {Monsky} matrices for {$\theta$}-congruent numbers}, + journal = {International Journal of Number Theory}, + volume = {16}, + number = {2}, + year = {2020}, + pages = {377--396}, + doi = {10.1142/S1793042120500207}, + url = {https://doi.org/10.1142/S1793042120500207}, + note = {Published online September 5, 2019. \bibdoi{10.1142/S1793042120500207}} +} + +@misc{WeiGuo2022, + author = {Wei, Tao and Guo, Xuejun}, + title = {The rank of {$2$}-{Selmer} group associate to {$\theta$}-congruent numbers}, + year = {2022}, + eprint = {2210.01678}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/2210.01678}, + note = {arXiv:2210.01678v1, October 4, 2022. \href{https://arxiv.org/abs/2210.01678}{Source}} +} + +@article{LongMaclachlanReid2006, + author = {Long, D. D. and Maclachlan, C. and Reid, A. W.}, + title = {Arithmetic {Fuchsian} groups of genus zero}, + journal = {Pure and Applied Mathematics Quarterly}, + volume = {2}, + number = {2}, + year = {2006}, + pages = {569--599}, + doi = {10.4310/PAMQ.2006.v2.n2.a9}, + url = {https://web.ma.utexas.edu/users/areid/genus0_final.pdf}, + note = {\bibdoi{10.4310/PAMQ.2006.v2.n2.a9}} +} + +@phdthesis{Nualart2015, + author = {Nualart Riera, Joan}, + title = {On the Hyperbolic Uniformization of {Shimura} Curves with an {Atkin--Lehner} Quotient of Genus 0}, + school = {Universitat de Barcelona}, + year = {2015}, + month = oct, + url = {https://diposit.ub.edu/items/ece138ce-1523-4d59-90ae-b08826c454e8}, + note = {Title-page date October 2015; repository release February 3, 2016. \href{https://diposit.ub.edu/items/ece138ce-1523-4d59-90ae-b08826c454e8}{Source}} +} + +@article{DarmonGranville1995, + author = {Darmon, Henri and Granville, Andrew}, + title = {On the equations {$z^m=F(x,y)$} and {$Ax^p+By^q=Cz^r$}}, + journal = {Bulletin of the London Mathematical Society}, + volume = {27}, + number = {6}, + year = {1995}, + pages = {513--543}, + doi = {10.1112/blms/27.6.513}, + url = {https://www.math.mcgill.ca/darmon/pub/Articles/Research/12.Granville/pub12.pdf}, + note = {\bibdoi{10.1112/blms/27.6.513}} +} + +@article{MurtyPasten2013, + author = {Murty, M. Ram and Pasten, Hector}, + title = {Modular forms and effective {Diophantine} approximation}, + journal = {Journal of Number Theory}, + volume = {133}, + number = {11}, + year = {2013}, + pages = {3739--3754}, + doi = {10.1016/j.jnt.2013.05.006}, + url = {https://mast.queensu.ca/~murty/Murty-Pasten-1.pdf}, + note = {\bibdoi{10.1016/j.jnt.2013.05.006}} +} + +@misc{vonKaenel2013Preprint, + author = {von K{\"a}nel, Rafael}, + title = {Modularity and integral points on moduli schemes}, + year = {2013}, + eprint = {1310.7263}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/1310.7263v1}, + note = {arXiv:1310.7263v1, October 27, 2013; revised version 2, March 23, 2014. \href{https://arxiv.org/abs/1310.7263v1}{Source}} +} + +@misc{vonKaenelKret2023, + author = {von K{\"a}nel, Rafael and Kret, Arno}, + title = {Integral points on coarse {Hilbert} moduli schemes}, + year = {2023}, + eprint = {2307.06944}, + archivePrefix = {arXiv}, + primaryClass = {math.NT}, + url = {https://arxiv.org/abs/2307.06944}, + note = {arXiv:2307.06944v1, July 13, 2023. \href{https://arxiv.org/abs/2307.06944}{Source}} +} + +@article{Wu2020, + author = {Wu, Chenyan}, + title = {Virtual {Abelian} varieties of {$\mathrm{GL}_2$}-type}, + journal = {Mathematical Research Letters}, + volume = {27}, + number = {3}, + year = {2020}, + pages = {903--944}, + doi = {10.4310/MRL.2020.v27.n3.a14}, + eprint = {1507.03069}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + url = {https://arxiv.org/abs/1507.03069}, + note = {Author version arXiv:1507.03069v3, January 25, 2022. \bibdoi{10.4310/MRL.2020.v27.n3.a14}} +} + +@article{CornelissenShlapentokh2009, + author = {Cornelissen, Gunther and Shlapentokh, Alexandra}, + title = {Defining the integers in large rings of a number field using one universal quantifier}, + journal = {Journal of Mathematical Sciences (New York)}, + volume = {158}, + number = {5}, + year = {2009}, + pages = {713--726}, + doi = {10.1007/s10958-009-9404-4}, + eprint = {0708.3075}, + archivePrefix = {arXiv}, + primaryClass = {math.LO}, + url = {https://arxiv.org/abs/0708.3075v2}, + note = {Originally published in Zapiski Nauchnykh Seminarov POMI 358 (2008), 199--223; author version arXiv:0708.3075v2, February 14, 2008. \href{https://arxiv.org/abs/0708.3075v2}{Author version}. \bibdoi{10.1007/s10958-009-9404-4}} +} + +@article{HeathBrown1994, + author = {Heath-Brown, D. R.}, + title = {The size of {Selmer} groups for the congruent number problem, {II}}, + journal = {Inventiones Mathematicae}, + volume = {118}, + pages = {331--370}, + year = {1994}, + doi = {10.1007/BF01231536}, + url = {https://doi.org/10.1007/BF01231536}, + note = {With an appendix by Paul Monsky, pp.~365--370. \bibdoi{10.1007/BF01231536}} +} diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/01-introduction.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..6317bee97d3fd40707bf137fab04f7f1b3578780 --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/01-introduction.tex @@ -0,0 +1,250 @@ +\section{Introduction}\label{sec:introduction} + +Hilbert's tenth problem over the rational numbers asks for a decision +procedure for rational zeros of polynomials with integer coefficients. +The number of variables is part of the input. + +\begin{theorem}\label{thm:main} +There is no algorithm which, given a polynomial +$f\in\Z[X_1,\ldots,X_n]$, with $n$ part of the input, decides whether +$f$ has a zero in $\Q^n$. +\end{theorem} + +\subsection{Historical setting} + +Hilbert's tenth problem, as stated in his 1900 list of mathematical +problems, asks for a finite procedure deciding whether a polynomial +equation with integer coefficients has a solution in the ordinary +integers \cite[Problem~10]{Hilbert1900}. Its negative resolution grew +out of a much stronger description of polynomial equations. A relation +on the positive integers is \emph{recursively enumerable} if an +algorithm can list exactly its satisfying tuples. It is +\emph{Diophantine} if membership can be expressed by the existence of +additional positive integers satisfying a polynomial equation with +integer coefficients. Thus a Diophantine description expresses a +condition entirely through polynomial solvability. + +Davis, Putnam, and Robinson proved in 1961 that every recursively +enumerable relation has such a representation if exponentiation is +also allowed. They reduced the ordinary polynomial representation +theorem to a growth criterion for a Diophantine relation +\cite[Theorem and Corollary~3]{DavisPutnamRobinson1961}. +Matiyasevich supplied the required growth in 1970 through a +Diophantine description of a Fibonacci relation, completing the +theorem that every recursively enumerable relation on the positive +integers is Diophantine \cite{Matiyasevich1970}. The equivalent +all-integer decision problem is therefore undecidable. This +representation theorem explains the strength of the result: integer +polynomial equations can encode arbitrary recursively enumerable +conditions. + +Letting the unknowns range over \(\mathbb Q\) changes the decision +problem. Enumerating rational tuples will eventually find any rational +zero, but gives no answer for an equation without one. A possible +transfer of the integer theorem would be an existential definition of +membership in \(\mathbb Z\) using only the ring operations of +\(\mathbb Q\). One could then replace each integer unknown by a +rational unknown subject to that membership condition, obtaining an +equivalent rational existential question. More generally, a +\emph{Diophantine model} of integer arithmetic represents the integers +by a Diophantine subset of some \(\mathbb Q^k\), with Diophantine +relations for addition and multiplication. Such a model also +translates integer equations into rational existential questions +\cite[Definition~3.1 and Observation~3.3]{CornelissenZahidi2000}. +Here the defining polynomial equations and all their witnesses are +interpreted over \(\mathbb Q\). +These constructions are sufficient routes to undecidability; the +decision problem does not require its solution to produce either one. + +Julia Robinson showed in 1949 that the integers are first-order +definable in the rationals using addition and multiplication. Her +formula uses both universal and existential quantifiers, and her work +also proves undecidability of the full first-order theory of rational +arithmetic \cite[Theorems~3.1 and~4.2]{Robinson1949}. Later work +reduced the quantifier complexity. Poonen defined \(\mathbb Z\) in +\(\mathbb Q\) by a positive formula with two universal quantifiers +followed by seven existential quantifiers +\cite[Theorem~4.1]{Poonen2009}. Koenigsmann then gave a universal +definition of \(\mathbb Z\); equivalently, its complement in +\(\mathbb Q\) is Diophantine. His result also implies undecidability +of the \(\forall\exists\) theory +\cite[Theorem~1 and Corollaries~2--3]{Koenigsmann2016}. These results +give substantial control of definitions inside \(\mathbb Q\), but +do not supply the existential membership condition for the direct +transfer above. + +The distinction between a Diophantine model and undecidability also +has a geometric setting. Mazur conjectured that, for a variety over +\(\mathbb Q\), the closure of its rational points in its real points +has only finitely many connected components +\cite[Conjecture~3]{Mazur1995}. He observed that this conjecture +would rule out a Diophantine definition of \(\mathbb Z\) in +\(\mathbb Q\). Cornelissen and Zahidi showed that it would also rule +out a Diophantine model of integer arithmetic in a finite Cartesian +power of \(\mathbb Q\) +\cite[Theorem~3.6]{CornelissenZahidi2000}. These obstructions to +definitions and models do not by themselves rule out a negative +answer to the rational decision problem. + +One approach studies the subrings +\(\mathbb Z[S^{-1}]\subseteq\mathbb Q\), whose denominators use only +primes in \(S\). Poonen constructed disjoint recursive sets of primes +\(T_1,T_2\), each of natural density zero, such that positive-integer +arithmetic has a Diophantine model in \(\mathbb Z[S^{-1}]\) whenever +\(S\supseteq T_1\) and \(S\cap T_2=\varnothing\). Hilbert's tenth +problem is undecidable for every such ring. Taking \(S\) to be the +complement of \(T_2\) gives a recursive set of density one and a +proper subring of \(\mathbb Q\) +\cite[Theorem~1.3]{PoonenSubrings}. The construction uses selected +multiples of a point on a rank-one elliptic curve whose real +coordinates approximate integers. + +Eisenträger, Miller, Park, and Shlapentokh later constructed +computably presentable subrings \(\mathbb Z[S^{-1}]\), including +examples in which \(S\) has density one, whose Hilbert's tenth problem +is Turing equivalent to that over \(\mathbb Q\) +\cite[Theorem~3.17]{EisentragerMillerParkShlapentokh2017}. For these +examples, a Turing reduction from integer solvability would already +give a Turing reduction from integer solvability to the rational +field problem. The density of the +inverted primes alone therefore does not settle the relation to the +field problem. + +Elliptic curves also give a transfer between rings of integers of +number fields. Poonen proved that, for \(F\subseteq K\), an elliptic +curve \(E/F\) with +\[ + \operatorname{rank}E(F)=\operatorname{rank}E(K)=1 +\] +makes \(\mathcal O_F\) Diophantine in \(\mathcal O_K\) +\cite[Theorem~1]{PoonenRankOne2002}. If \(\mathbb Z\) is already +Diophantine in \(\mathcal O_F\), undecidability transfers to +\(\mathcal O_K\). Mazur and Rubin pursued this route through +quadratic twists and Selmer groups, conditional on the conjectured +evenness of \(\dim_{\mathbb F_2}\operatorname{Sha}(E/L)[2]\). +Assuming this for every elliptic curve over every number field, they obtained undecidability for +every infinite finitely generated \(\mathbb Z\)-algebra +\cite[Theorem~1.13, Corollary~1.14, and Theorem~8.1]{MazurRubin2010}. + +This number-field program has recently been completed +unconditionally. Koymans and Pagano combined two-descent with +additive combinatorics to prove that \(\mathbb Z\) is Diophantine in +the ring of integers of every number field, and that Hilbert's tenth +problem is undecidable for every infinite finitely generated +\(\mathbb Z\)-algebra \cite{KoymansPagano2026}. +Alpöge, Bhargava, Ho, and Shnidman +gave another route: for every quadratic extension \(K/F\) of number fields, they +construct an abelian variety over \(F\) with positive rank unchanged +over \(K\), and deduce that \(\mathbb Z\) is Diophantine in every +number-field ring of integers +\cite[Theorem~1.1 and Corollary~1.2]{AlpogeBhargavaHoShnidman2026}. +The field \(\mathbb Q\) is not a finitely generated +\(\mathbb Z\)-algebra, so these results concern a different class of +rings from the field in Theorem~\ref{thm:main}. + +The elliptic approach also illuminates nearby rational decision +problems. In a rank-one group, a multiple \(nP\) of a nontorsion +point can represent the integer \(n\), and local coordinates or heights can reveal arithmetic +information about that index. Cornelissen and Zahidi used elliptic +divisibility sequences and existential valuation predicates in this +direction. Under a conjectural odd primitive-divisor property for one +such sequence, they obtained a Diophantine model of +\((\mathbb Z,+,\mid)\) and proved undecidability of a positive +\(\Pi_2\) fragment with one universal quantifier +\cite[Conjecture~3.16 and Theorems~3.17 and~5.3]{CornelissenZahidi2007}. +The assertion with one universal quantifier uses the correction by +Cornelissen and Shlapentokh +\cite[Remark~2.3 in the author version]{CornelissenShlapentokh2009}. + + +Garcia-Fritz, Pasten, and Vidaux instead adjoined predicates comparing +the logarithmic heights of rational tuples to the rational ring +language. In this expanded language they gave a +positive existential interpretation of \(\mathbb N\), and hence +proved undecidability; comparisons between tuples of length at most +three suffice \cite[Theorems~1.1--1.2]{GarciaFritzPastenVidaux2025}. +Their construction uses elliptic canonical heights to encode +consecutive squares. The present paper concerns ordinary rational +polynomial solvability, and its height estimates enter the proof of +that ordinary statement. + +\subsection{Proof strategy} + +Constant polynomials can be decided directly. For each nonconstant integral +polynomial \(f\), we construct an effectively generated sequence of finite tests. +Each test can be answered by finitely many rational-solvability queries, and the sequence satisfies +\begin{equation}\label{intro:finite-test-interface} + f\text{ has an integer zero} + \quad\Longleftrightarrow\quad + \text{every test succeeds}. +\end{equation} +An integer zero supplies witnesses for all the tests. If a rational-solvability algorithm existed, we could run two searches in parallel: enumeration of integer zeros, and enumeration of tests until one fails. The arithmetic work is to prove that a failed test exists whenever \(f\) has no integer zero. + +Suppose all the finite tests succeed. Compactness then gives a ring \(R\) containing a zero \(\mathbf a=(a_1,\ldots,a_n)\) of \(f\), embedded in an elementary extension of the rational field; we use a tilde for embedded values and points. The ambient extension also carries the integer and valuation data, height functions, elliptic multiple maps, and functions for finite products used in the proof. The tests attach an elliptic point \(T_a\) to each \(a\in R\), compatibly with addition, and require \(T_a\) to be nonidentity when \(a\ne0\). The embedded points lie in the transferred copy of a fixed infinite cyclic subgroup \(\Z P\) of finite index in a rank-one elliptic group, with \(T_1=P\). This defines unique indices +\[ + \widetilde T_a=\eta(a)P, + \qquad \eta(a)\in{}^*\Z. +\] +Here \({}^*\Z\) is the ambient integer structure, whose elements may be nonordinary. The point axioms make \(\eta:R\to{}^*\Z\) injective and additive, with \(\eta(1)=1\), but \(\eta\) need not respect multiplication. Thus the modeled equation does not yet give an equation satisfied by the indices. + +Two local comparisons address this obstruction. The primary test compares an embedded ring value with a quotient of truncated elliptic logarithms. The formal logarithm can recover the corresponding quotient of point indices once that quotient is integral at the prime. A second comparison, on the conjugate elliptic curve, supplies this control using only additivity of \(\eta\). Where the comparisons apply, they show that every \(\widetilde a\) is integral at the prime and agrees with \(\eta(a)\) to the prescribed precision. Each pair uses auxiliary choices that work for every ring element, which is essential for the later uniform bound. + +The proof arranges these comparisons at primes detected by a height estimate. Fix the five rational points of \(\mathbf P^1\) supplied by that estimate and primitive integral linear forms vanishing at them; call these the contact forms. For a rational point \(s=(u:v)\) outside this set, written in coprime integer coordinates, let \(M(s)\) be the product, without repetition, of the nonexceptional primes at which one of these forms has odd valuation. We call the primes counted by \(M(s)\) its contact primes. The estimate bounds the absolute logarithmic Weil height by +\[ + h(s)\le H M(s)^c +\] +for fixed constants \(H,c\). This definition and estimate transfer to the ambient extension. At each prescribed precision, the theory represents every ring element as a +sum of three fractions of ring elements, called slopes, and equips factors of +their contact forms with the local conditions. A prime-pattern theorem supplies +the required primes for these representations in the ordinary integer model. +A separate existential condition controls the parity of possible denominator +valuations outside a fixed finite set. In a model satisfying the tests, consider +the three slopes supplied for any ring element at that precision. After the +further fixed exclusions, the parity condition lets the proof apply the local +comparisons at every contact prime of those slopes. Enlarging the exceptional +set changes the height constant but preserves the exponent \(c\). + +Set +\[ + \delta=f\bigl(\eta(a_1),\ldots,\eta(a_n)\bigr), + \qquad + B=\max\bigl(1,|\eta(a_1)|,\ldots,|\eta(a_n)|\bigr). +\] +If \(\delta=0\), elementarity gives an ordinary integer zero of \(f\). Otherwise \(\delta\) is a nonzero ambient integer whose size is bounded by a fixed polynomial in \(B\). Choose one ordinary precision \(K\) large enough in terms of the degree of \(f\) and the exponent \(c\). For any \(A\in R\), choose a tested representation at precision \(K\). Every contact prime of its slopes divides this same \(\delta\) to order at least \(K\), because all modeled root coordinates agree locally with their indices. The height estimate then bounds each slope height by a constant times \(B\). The logarithmic height inequality for their sum gives +\[ + h(\widetilde A)\ll_f B + \qquad\text{for every }A\in R, +\] +with one ordinary constant. + +For each nonzero root coordinate \(a_j\), consider its attached point +\(T_{a_j}\). Applying the uniform bound to the ring elements representing +\(x(T_{a_j})\) gives \(h(x(\eta(a_j)P))\ll_f B\). +The transferred canonical-height comparison for \(P\) makes this height grow +quadratically in \(|\eta(a_j)|\). If \(B>1\), choose \(j\) with +\(|\eta(a_j)|=B\); the two bounds give \(B^2\ll_f B\). If \(B=1\), the +required bound is immediate. Thus all root indices lie in an ordinary finite +interval. Additivity and injectivity identify the modeled root coordinates +with those ordinary integers, contradicting \(\delta\ne0\). This proves the +finite-test equivalence and hence the undecidability theorem. + +The detailed reduction in Section~\ref{sec:reduction} makes these steps +precise. Section~\ref{par:section} proves the pole-parity condition; its +passage from two-descent data to rational points uses the pointwise +$2$-converse \cite[Theorem~1.1]{PointwiseTwoConverse} and the +Cassels--Tate pairing \cite{Cassels1962}. +Section~\ref{hei:section} proves the five-point height estimate. Its +modularity step uses the odd regular Fontaine--Mazur theorem at $2$ +\cite[Theorem~1.1]{OddRegularFontaineMazurAtTwo}, whose statement has no +hypothesis on the residual image. Section~\ref{ell:section} proves the +rank-one and local elliptic results, and Section~\ref{pri:section} +supplies the prime patterns and simultaneous local witnesses for the +ordinary integer model. Section~\ref{red:degree-normal-form} gives +Turing degree $0'$ and the quartic normal form. + +At rational primes, valuations are normalized by \(v_q(q)=1\), with +\(v_q(0)=+\infty\). The support of a nonzero rational number is the set of +primes dividing its numerator or denominator in lowest terms. The notation +\(X\ll Y\) means \(X\le CY\) for a positive constant depending only on the +fixed data in the statement; additional dependencies are indicated when +they occur. diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/02-reduction.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/02-reduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..ca661b707e348eeee70788988b96d93f8c5cb0ae --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/02-reduction.tex @@ -0,0 +1,888 @@ +\section{Finite rational tests for integer solvability} +\label{sec:reduction} + +We construct the finite rational tests announced in the introduction and +prove that success of every test forces an ordinary integer zero. The +construction has an ordinary integer model. Conversely, compactness will +embed a model of all the tests in an elementary extension of \(\Q\), +where arithmetic restrictions on its ring values will force an integer +solution. The later sections prove the arithmetic inputs used here. + +The elliptic point data first give an additive assignment of integer +indices. A local comparison will recover those indices from ring values +and determine the two local test conditions. + +\subsection{Elliptic indices and the local comparison} +\label{red:local-comparison-section} + +Fix the number field, involution, and elliptic curve +\begin{equation}\label{ell:data} + F=\Q(\sqrt2),\qquad d=75-53\sqrt2,\qquad + E:\ y^2=x^3-d^2x, +\end{equation} +where \(\sigma\) is the nontrivial automorphism of \(F/\Q\). +The following result, proved in Section~\ref{ell:section}, supplies the +integer indices. + +\begin{proposition}\label{ell:rank} +The group $E(F)$ has rank one. Consequently there exist a positive integer +$m$ and a nontorsion point $P\in E(F)$ such that +\[ + mE(F)=\Z P. +\] +We fix such $m$ and $P$ once and for all. +\end{proposition} + +We now describe the point data that the recursive theory will impose. +Let \(R\) be an integral domain +of characteristic zero for which \(\sqrt2\notin\Frac(R)\), and write +\[ + R_F=R[\sqrt2],\qquad F_R=\Frac(R)(\sqrt2). +\] +For each \(a\in R\), consider a point \(T_a\in E(F_R)\) subject to +\begin{equation}\label{red:elliptic-axioms} +\begin{gathered} + T_0=O,\qquad T_1=P,\qquad + T_{a+a'}=T_a+T_{a'}\quad(a,a'\in R),\\ + T_a\in mE(F_R)\quad(a\in R),\\ + a\ne0\Longrightarrow T_a\text{ is finite and }x(T_a)y(T_a)\ne0. +\end{gathered} +\end{equation} +The theory will supply six unary ring-valued functions +\(x_0,x_1,x_2,y_0,y_1,y_2\). For \(a\ne0\), they are required to +satisfy \(x_2(a)y_2(a)\ne0\) and +\begin{equation}\label{red:coordinate-functions} + x(T_a)=\frac{x_0(a)+x_1(a)\sqrt2}{x_2(a)},\qquad + y(T_a)=\frac{y_0(a)+y_1(a)\sqrt2}{y_2(a)}. +\end{equation} +Their values at \(a=0\) are unrestricted, since \(T_0=O\). +In the integer model we will take \(T_a=aP\). Representing the +coordinates by ring elements will also let a uniform height bound on +\(R\) control their heights. + +For the arithmetic analysis, consider an elementary extension of the +ordinary many-sorted structure containing \(\Q,\Z,\R,F\), the prime and +valuation relations, the height functions, the elliptic multiple maps, +and the finite-product functions. We call elements of the original +structure \emph{ordinary}; starred sorts satisfy the same first-order +statements with ordinary parameters. For the moment, suppose that \(R\) +embeds in the rational sort \({}^*\Q\) of such an extension. Its +fraction-field interpretation embeds \(F_R\) in \({}^*F\). A tilde +denotes the image of a ring element, field element, or point. Later +compactness will supply an extension and an embedded ring with these +properties. + +The identity \(mE(F)=\Z P\) transfers to this extension: every point +of \(mE({}^*F)\) has a unique expression \(nP\), with +\(n\in{}^*\Z\). Define +\begin{equation}\label{red:eta} + \widetilde T_a=\eta(a)P. +\end{equation} +The group-law axioms give +\begin{equation}\label{red:additivity} + \eta(a+a')=\eta(a)+\eta(a'),\qquad \eta(1)=1. +\end{equation} +If \(\eta(a)=0\), then \(T_a=O\), and the finite-point axiom forces +\(a=0\). Thus \(\eta:R\to{}^*\Z\) is injective and additive. +Conjugating \eqref{red:eta} gives +\(\widetilde T_a^\sigma=\eta(a)P^\sigma\). +We make no assumption about \(\eta(aa')\). + +For nonzero \(h\in R\), the index ratio of \(T_{ha}\) and \(T_h\) is +\(\eta(ha)/\eta(h)\), which need not equal \(\eta(a)\). We will +recover this ratio locally from point parameters, and use a second +comparison to identify it with \(\eta(a)\) to the required precision. + +For a finite point with \(y\ne0\), put \(z=-x/y\), and set \(z(O)=0\). +Every nonzero multiple of \(P\) avoids the two-torsion points, so +\(z(nP)\) is defined for every integer \(n\). Write +\[ + \ell(Z)=Z+\sum_{t\ge2}c_tZ^t\in F[[Z]],\qquad + \ell_K(Z)=Z+\sum_{2\le t\le K}c_tZ^t +\] +for the formal logarithm in this parameter and its truncation through +degree \(K\). The truncations are effectively computable from the +fixed equation. Section~\ref{ell:section} proves the following uniform +statements about integer multiples of the fixed \(F\)-rational points +\(P,P^\sigma\). + +\begin{proposition}\label{ell:formal} +There is a fixed finite set of rational primes $S_E$ with the following +properties. Let $p\notin S_E$, let $v$ be any place of $F$ above $p$, +normalized by $v(p)=1$, and let $n,n'\in\Z$, with $n'\ne0$. Assume +$nP,n'P$ reduce to $O$ at $v$. Then +\begin{equation}\label{ell:ratio} + v\!\left(\frac{z(nP)}{z(n'P)}\right)=v_p(n/n'). +\end{equation} +For every integer $K\ge1$, if in addition $p>K+1$ and $v_p(n/n')\ge0$, +then $\ell_K(z(n'P))\ne0$ and +\begin{equation}\label{ell:truncation} + v\!\left(\frac{\ell_K(z(nP))}{\ell_K(z(n'P))}-\frac n{n'}\right) + \ge K. +\end{equation} +Both assertions also hold at the same place $v$ after replacing +$E,P,\ell_K$ by $E^\sigma,P^\sigma,\ell_K^\sigma$ and imposing the +corresponding reduction-to-$O$ hypotheses on the conjugate points. +Here and below the valuation of zero is $+\infty$, so $n=0$ is included. +\end{proposition} + +The two estimates provide different kinds of local information. Equation +\eqref{ell:ratio} determines the valuation of an index ratio from the +point parameters without assuming that the ratio is integral. Once an +index ratio is known to be integral, \eqref{ell:truncation} approximates +it by a ratio of finite polynomial evaluations. The next lemma combines both forms of control. + +Reduction to \(O\) has its usual valuation meaning, transferred to the +elementary extension. +Only the stated assertions about integer multiples of the fixed +\(F\)-rational points \(P,P^\sigma\) and evaluations of the finite +polynomials \(\ell_K,\ell_K^\sigma\) are transferred; no infinite +formal series is evaluated in the extension. + +\begin{samepage} +\begin{lemma}[Local comparison]\label{red:local-comparison} +Let \(K\ge1\) be an ordinary integer. Let \(q\) be a prime of the +ambient integer sort \({}^*\Z\), possibly nonordinary, with +\(q\notin S_E\) and \(q>K+1\), and let \(v_*\) be a place of +\({}^*F\) above \(q\), normalized by \(v_*(q)=1\). +Suppose there are nonzero \(h,j_0\in R\), chosen independently of +\(a\), such that for every \(a\in R\): +\begin{enumerate}[label=(\roman*),leftmargin=*] +\item The points \(\widetilde T_h,\widetilde T_{ha}\) reduce to \(O\) +at \(v_*\), the value \(\ell_K(z(\widetilde T_h))\) is nonzero, and +\[ + v_*\!\left( + \frac{\ell_K(z(\widetilde T_{ha}))}{\ell_K(z(\widetilde T_h))} + -\widetilde a\right)\ge K. +\] +\item The points \(\widetilde T_{j_0}^{\sigma}\) and +\(\widetilde T_{(h-4)a}^{\sigma}\) reduce to \(O\) on the conjugate +curve at the same place \(v_*\), and +\[ + v_*\!\left( + \frac{z(\widetilde T_{(h-4)a}^{\sigma})} + {z(\widetilde T_{j_0}^{\sigma})}\right)\ge K. +\] +\end{enumerate} +Then every \(\widetilde a\) is integral at \(q\), and +\[ + v_q(\widetilde a-\eta(a))\ge K + \qquad(a\in R). +\] +Here \(z(O)=0\). The denominator in (ii) is nonzero because +\(j_0\ne0\) and the nonzero points in \eqref{red:elliptic-axioms} +have nonzero \(x\)- and \(y\)-coordinates. +\end{lemma} +\end{samepage} + +\begin{proof} +Transfer the formal-parameter valuation equality of +Proposition~\ref{ell:formal} to the conjugate points at \(v_*\). +The comparison in (ii) gives +\[ + v_q\!\left(\frac{\eta((h-4)a)}{\eta(j_0)}\right)\ge K. +\] +The denominator is a nonzero ambient integer, so its \(q\)-valuation +is nonnegative. Consequently +\begin{equation}\label{red:alternate-index} + v_q(\eta((h-4)a))\ge K. +\end{equation} +Put \(V_a=\eta(ha)\). Additivity applied to +\((h-4)a=ha-4a\), including the case \(a=1\), gives +\[ + V_a\equiv4\eta(a)\pmod{q^K},\qquad + V_1\equiv4\pmod{q^K}. +\] +Since \(q\ne2\), \(V_1\) is a \(q\)-unit. The ambient integers +\(V_a,\eta(a)\) are \(q\)-integral, and hence +\begin{equation}\label{red:actual-slope} + V_a/V_1\text{ is \(q\)-integral},\qquad + V_a/V_1\equiv\eta(a)\pmod{q^K}. +\end{equation} +The primary points have indices \(V_1\) and \(V_a\). They reduce to +\(O\), the denominator index is nonzero, and their ratio is now known +to be integral. The truncated-logarithm assertion of +Proposition~\ref{ell:formal} therefore gives +\[ + v_*\!\left( + \frac{\ell_K(z(\widetilde T_{ha}))}{\ell_K(z(\widetilde T_h))} + -\frac{V_a}{V_1}\right)\ge K. +\] +The comparison in (i) relates this same logarithm ratio to +\(\widetilde a\). Combining it with the last display and +\eqref{red:actual-slope} proves the required congruence, since +\(v_*\) restricts to \(v_q\) on \({}^*\Q\). It also proves +\(q\)-integrality of \(\widetilde a\). Zero numerator indices are +covered by the convention \(v_q(0)=+\infty\). + +\end{proof} + +The same \(h\) must serve every \(a\), because the calculation uses +both \(a\) and \(1\). We will impose ring-language versions of these +comparisons and obtain their valuation hypotheses at primes detected by a +height estimate. + +\subsection{Contact primes and ordinary integer witnesses} +\label{red:arithmetic-inputs} + +Throughout the paper, \(\hgt\) denotes the absolute logarithmic Weil +height. The next input identifies primes whose product controls the height +of a rational point. It is proved in Section~\ref{hei:section}. + +\begin{theorem}[Five-point height estimate]\label{hei:height} +There exist five distinct points $\mathcal C\subset\mathbf P^1(\Q)$, +including $\infty$, a finite set $S$ of rational primes, and constants +$H,c>0$ with the following property. For each $b\in\mathcal C$, choose +a primitive integral linear form $L_b(U,V)$ vanishing at $b$, with +$L_\infty(U,V)=V$. For +$s=(u:v)\in\mathbf P^1(\Q)\setminus\mathcal C$, let $M_S(s)$ be the +product, taken without repetition, of primes $q\notin S$ for which +at least one of the integers +\begin{equation}\label{hei:radical} + v_q(L_b(u,v))-\min\{v_q(u),v_q(v)\},\qquad b\in\mathcal C, +\end{equation} +is odd. Here $v_q(q)=1$ and $v_q(0)=+\infty$. Then +\begin{equation}\label{hei:height-bound} + \hgt(s)\le H M_S(s)^c. +\end{equation} +\end{theorem} + +Multiplying $(u,v)$ by a nonzero rational scalar adds the same valuation +to both terms in~\eqref{hei:radical}, so each contact order is independent +of the chosen homogeneous coordinates. It is nonnegative after scaling +the coordinates to be integral and primitive at $q$. With fixed primitive +integral coordinates, the nonzero integers $L_b(u,v)$ have only finitely +many prime divisors, so the product defining $M_S(s)$ is finite. + + + +For a positive integer \(K\) and a nonzero integer \(e\) satisfying +\(M_S(s)^K\mid e\), the estimate gives +\[ + \hgt(s)\le H|e|^{c/K}. +\] +In the reduction, the same polynomial error will play the role of \(e\) +for representations of every ring element. This is why the exponent +\(c\) must be fixed, although its precise value is not needed. +The following immediate consequence permits the further fixed exclusions +needed by the local tests. + +\begin{corollary}\label{hei:enlarge-exceptions} +If $S'\supset S$ is any fixed finite set of primes, then +\[ + \hgt(s)\le H\left(\prod_{q\in S'\setminus S}q\right)^c + M_{S'}(s)^c + \qquad(s\in\mathbf P^1(\Q)\setminus\mathcal C). +\] +In particular enlarging the exceptional set changes the constant +but leaves the exponent unchanged. +\end{corollary} + +\begin{proof} +Every prime counted by $M_S(s)$ is either counted by $M_{S'}(s)$ or +belongs to $S'\setminus S$. Thus +$M_S(s)\le(\prod_{q\in S'\setminus S}q)M_{S'}(s)$, and +Theorem~\ref{hei:height} applies. +\end{proof} + +To apply this estimate uniformly, the theory will write each ring element +as a sum of three fractions and impose local conditions on factors of their +contact forms. The following ordinary integer result supplies witnesses +for those axioms. It is a direct consequence of the prime-pattern lemma +and the Chinese remainder calculation proved in Section~\ref{pri:section}. + +\begin{corollary}[Ordinary contact representations]\label{pri:integer-coverage} +Let \(\mathcal K\subset\Z_{>0}\) be the finite multiplier set supplied +by Lemma~\ref{pri:pattern} in Section~\ref{pri:section}. It has the +following property. For every integer \(K\ge1\), every \(A\in\Z\), and every +real lower bound \(Y_0>0\), there exist integers \(u_1,u_2,v\), with \(v\ne0\), +such that, on setting \(u_3=Av-u_1-u_2\), the following hold. +\begin{enumerate}[label=(\arabic*),leftmargin=*] +\item \textup{Representation and primes.} Each of the thirteen numbers +\begin{equation}\label{pri:coverage-list} + v,\qquad L_b(u_i,v) + \quad(1\le i\le3,\ b\in\mathcal C\setminus\{\infty\}) +\end{equation} +equals \(\varepsilon k r\), where \(\varepsilon\in\{1,-1\}\), +\(k\in\mathcal K\), and \(r>Y_0\) is a positive rational prime. Every +such \(r\) splits in \(F\), is a prime of good reduction for both +\(E\) and \(E^\sigma\), lies outside \(S_E\), and satisfies \(r>K+1\). + +\item \textup{Witnesses at each place.} For each occurrence of a prime +\(r\) in this list and each of the two places \(v_r\) of \(F\) above it, +there are nonzero integers \(h,j_0\), chosen independently of \(a\in\Z\), +such that every \(a\in\Z\) satisfies conditions (i) and (ii) of +Lemma~\ref{red:local-comparison} in the ordinary setting: take \(R=\Z\), +its identity embedding in the ordinary structure, \(T_a=aP\), \(q=r\), +and \(v_*=v_r\), normalized by \(v_r(r)=1\). In this specialization +the tildes disappear. The choices of \(h,j_0\) may differ at different +occurrences and at the two places. +\end{enumerate} +The set \(\mathcal K\) is independent of \(K,A,Y_0\). +\end{corollary} + +The two places in part (2) are the two residue branches above a split +prime. At either one, conditions (i) and (ii) use the two conjugate curves +at that same place. If \(\mathfrak p\) is the prime ideal of +\(\Z[\sqrt2]\) corresponding to \(v_r\), its valuation ring is +\((\Z[\sqrt2])_{\mathfrak p}\), with uniformizer \(r\). Thus the two +valuation inequalities in part (2) are exactly membership in +\(r^K(\Z[\sqrt2])_{\mathfrak p}\); for a finite indicated point, +reduction to \(O\) is equivalent to +\(1/x\in r(\Z[\sqrt2])_{\mathfrak p}\). We now encode these ordinary +witnesses by formulas that also make sense for a general ring. + +\subsection{A recursive theory with an ordinary integer model} +\label{red:theory} + +Let \(\mathcal T\) be a theory in a countable recursive expansion of +the language of rings. Its ring \(R\) is required to be an integral +domain of characteristic zero with \(\sqrt2\notin\Frac(R)\). +Add the six unary ring-valued functions above. Interpret \(T_0\) as +\(O\) and, for \(a\ne0\), require the two fractions in +\eqref{red:coordinate-functions} to define the coordinates of +\(T_a\in E(F_R)\), with both denominators nonzero. Impose the point +conditions \eqref{red:elliptic-axioms}. + +Use the five points \(\mathcal C\), primitive contact forms \(L_b\), and +finite multiplier set \(\mathcal K\) of the preceding inputs. For each +ordinary integer \(K\ge1\), add the following representation axiom. +For every \(A\in R\) there exist \(u_1,u_2,v\in R\), with \(v\ne0\), +such that, on setting +\[ + u_3=Av-u_1-u_2, +\] +each member of +\begin{equation}\label{red:contact-list} + v,\qquad L_b(u_i,v)\quad + (1\le i\le3,\ b\in\mathcal C\setminus\{\infty\}) +\end{equation} +equals \(\varepsilon k r\), where +\(\varepsilon\in\{1,-1\}\), \(k\in\mathcal K\), and \(r\in R\) +has the following properties. The choices of \(r\) and its auxiliary +data are made separately for the different members of the list. + +First require \(r\ne0\), \(rR\) proper, and \(R/rR\) a field. +Require \(B_r\in R\) satisfying +\[ + B_r^2\equiv2\pmod{rR},\qquad + 2B_r\text{ invertible in }R/rR. +\] +These conditions define two maximal ideals of \(R_F\): +\begin{equation}\label{red:branch-ideals} + \mathfrak p_\pm + =\ker\bigl(R_F\longrightarrow R/rR,\ \sqrt2\longmapsto\pm B_r\bigr). +\end{equation} +They are the two residue branches to be tested. In the integer model +they correspond to the two places of \(F\) above a supplied split +prime \(r\). In a general model they are defined by the quotient field, +independently of an ambient valuation. + +For each \(\mathfrak p\in\{\mathfrak p_+,\mathfrak p_-\}\), require +nonzero \(h,j_0\in R\), chosen at that branch and independently of +\(a\), such that the following hold for every \(a\in R\). A point is +called \emph{formal for this localization} if it is \(O\), or if +\(1/x\in r(R_F)_{\mathfrak p}\). +\begin{enumerate}[label=(\roman*),leftmargin=*] +\item The points \(T_h,T_{ha}\) are formal for this localization, +\(\ell_K(z(T_h))\ne0\), and +\begin{equation}\label{red:primary-test} + \frac{\ell_K(z(T_{ha}))}{\ell_K(z(T_h))}-a + \in r^K(R_F)_{\mathfrak p}. +\end{equation} +\item The points \(T_{j_0}^{\sigma},T_{(h-4)a}^{\sigma}\) are formal +for the conjugate curve at the same localization, and +\begin{equation}\label{red:alternate-test} + \frac{z(T_{(h-4)a}^{\sigma})}{z(T_{j_0}^{\sigma})} + \in r^K(R_F)_{\mathfrak p}. +\end{equation} +\end{enumerate} +Here \(z(O)=0\), and the denominator in +\eqref{red:alternate-test} is nonzero by \(j_0\ne0\) and +\eqref{red:elliptic-axioms}. The pairs \(h,j_0\) may differ between +the two branches. The scheme contains every ordinary \(K\); the +termination proof will later select a single precision after \(f\) +is fixed. + +All these conditions have recursive first-order expressions in \(R\). +The absence of \(\sqrt2\) from \(\Frac(R)\) is expressed by +\[ + \forall a,b\in R\quad b\ne0\Longrightarrow a^2\ne2b^2. +\] +Elements of \(R_F\) are pairs of ring elements, and elements of +\(F_R\) are fractions \((A+B\sqrt2)/D\), with \(A,B,D\in R\) +and \(D\ne0\). Equations with fixed coefficients in \(F\) can +therefore be separated into two coordinates and cleared of denominators. +The elliptic group law, including the identity and exceptional addition +cases, is given by finitely many field equations and inequations. +Membership in \(mE(F_R)\) is expressed by existential coordinates for +a point whose \(m\)-multiple is the prescribed point. These conditions +are ring formulas under the same interpretation. + +Saying that \(R/rR\) is a field means that \(1\notin rR\) and every +element outside \(rR\) has an inverse modulo \(rR\). For \(D'\in F_R\), +the assertion +\begin{equation}\label{red:localization-definition} + D'\in r^i(R_F)_{\mathfrak p_\pm} +\end{equation} +means that \(D'=r^iX/Y\) for some \(X,Y\in R_F\) such that the +evaluation of \(Y\) under \(\sqrt2\mapsto\pm B_r\) is nonzero modulo +\(rR\), hence a unit in that field. These representations and inverse conditions +are expressed by ring quantifiers. The exponent \(i\) is fixed in +each axiom; neither variable exponentiation nor a valuation function +is part of \(\mathcal T\). + +\begin{lemma}\label{red:standard-model} +The theory \(\mathcal T\) is recursive and has a model whose ring is +\(\Z\). In this model \(T_a=aP\) for every integer \(a\). +\end{lemma} + +\begin{proof} +The ring and elliptic axioms hold for \(\Z\) with \(T_a=aP\). +For nonzero \(a\), the coordinates lie in \(F\) and admit integer +numerator and denominator representatives; choose arbitrary integer +values for the six coordinate functions at \(a=0\). +Nonzero multiples of the nontorsion point \(P\) +avoid \(O\) and the two-torsion points, so their \(x\)- and +\(y\)-coordinates are nonzero. + +Fix \(K\ge1\) and \(A\in\Z\). Corollary~\ref{pri:integer-coverage} +supplies \eqref{red:contact-list} with the required fixed multipliers and +positive split primes. For each such \(r\), the quotient \(\Z/r\Z\) +is a field. Splitness supplies a root \(B_r\) of \(2\) modulo \(r\), +and \(2B_r\) is invertible because \(r\) is odd. The ideals +\eqref{red:branch-ideals} correspond to the two places above \(r\). +At each one, the corollary supplies nonzero \(h,j_0\), fixed for all +integers \(a\), with the required formal points and both valuation +comparisons. Its localization interpretation gives exactly +\eqref{red:primary-test} and \eqref{red:alternate-test}. Thus every +representation axiom holds. + +The coefficients of \(\ell_K\) are computable from the fixed equation, +and the interpretations and axiom schemes above are effective. The +finite sets, fixed integers, rational coefficients, and coordinates +of \(P\) are finitely many exact constants that can be hardcoded in +the theory. Their existence suffices for the existence of the decision +procedure constructed below; no effective search for those fixed +choices is required. No list of all true arithmetic sentences is used. +\end{proof} + +\subsection{Finite rational tests and compactness} +\label{red:finite-tests} + +The finite tests will also impose a positive existential condition on +every ring value. This input holds on all integers and controls the parity +of possible poles; Section~\ref{par:section} constructs it. + +\begin{proposition}\label{par:pole-parity} +There are a positive existential formula $\Phi(b)$ in the language of +rings, with fixed rational coefficients, and a finite set $S_1$ of +rational primes such that: +\begin{enumerate} +\item $\Q\models\Phi(b)$ for every $b\in\Z$; +\item if $b\in\Q^\times$ and $\Q\models\Phi(b)$, then, for every +$q\notin S_1$, the inequality $v_q(b)<0$ implies $v_q(b)\in2\Z$. +\end{enumerate} +\end{proposition} + +The second property does not rule out even pole orders. Its later use rests on a +simple product observation. If $q\notin S_1$ and nonzero $a,c\in\Q$ +satisfy $\Phi(a)$ and $\Phi(ac)$, with both $v_q(a)$ and $v_q(ac)$ +negative, then +\[ + v_q(c)=v_q(ac)-v_q(a)\in2\Z. +\] +Section~\ref{red:valuation} applies this observation when $\Phi$ holds +on every element of the ring supplied by the finite tests. + +An integer zero can therefore supply rational witnesses for all the +conditions imposed below. In the converse direction, pole parity will +connect a contact prime in the ambient integer structure to one of the +tested localizations of the embedded ring. + +Assume that an algorithm decides rational solvability of integral +polynomials. Given $f\in\Z[X_1,\ldots,X_n]$, the constant case can be +settled immediately, so assume $f$ is nonconstant. Add constants +$\mathbf a=(a_1,\ldots,a_n)$ and the equation $f(\mathbf a)=0$ to +$\mathcal T$, and Skolemize the resulting theory. This is effective for +a recursive first-order theory: after prenex conversion, each existential +quantifier is replaced by a function of the preceding universal variables. +All resulting function symbols are ring-valued. The Skolemized axioms +are universal sentences with quantifier-free matrices. + +A ground term is a term with no variables, built from the named constants +using the ring operations and added functions in this language. A compatible +assignment of values to all ground terms will interpret the added functions +on the ring of term values. Enumerate these terms, associate a rational +variable to each, and enumerate the following constraints: +\begin{enumerate}[label=(\alph*),leftmargin=*] +\item the constants $0,1$ and the ring operations have their usual values; +\item equal input tuples have equal outputs for each function symbol; +\item every ground instance of every universal axiom holds; +\item the value of every ground term satisfies the positive existential +formula $\Phi$ from Proposition~\ref{par:pole-parity}. +\end{enumerate} +The witnesses for $\Phi$ in (d) are auxiliary rational variables. +They are not values of additional functions of the ring and do not create +new ground terms subject to (d). The same distinction applies to the +inverse variables introduced only when translating a finite test to +polynomial equations; they are not added to the term-generated ring. + +Every finite initial part of this list is decidable by the assumed +rational-solvability algorithm. Indeed, after introducing the witnesses +for $\Phi$, the finite collection is an existential Boolean combination +of polynomial equalities and inequations. An inequation $g\ne0$ becomes +$gy=1$ with a new variable; a finite Boolean formula can be put into +disjunctive normal form; and a conjunction $g_1=\cdots=g_s=0$ is +equivalent over $\Q$ to $\sum_i g_i^2=0$. Clearing fixed rational +denominators gives finitely many integral polynomial queries. + +If any test fails, report that $f$ has no integer zero. This answer is +sound: an integer zero extends the model of Lemma~\ref{red:standard-model} +and admits Skolem functions; all its ground-term values are integers +and hence satisfy $\Phi$. + +\begin{lemma}\label{red:compactness} +If every finite rational test succeeds, there exist an ambient +elementary extension of the many-sorted structure specified in +\S\ref{red:local-comparison-section}, a +model \(R\) of \(\mathcal T\), a tuple \(\mathbf a\in R^n\) with +\(f(\mathbf a)=0\), and an embedding \(R\hookrightarrow{}^*\Q\) +into its rational sort such that every element of the image satisfies +\(\Phi\). +\end{lemma} + +\begin{proof} +Take the ordinary many-sorted structure specified in +\S\ref{red:local-comparison-section}, with all the indicated functions +and relations. Expand this ambient structure by constants naming all +ordinary elements in their respective sorts. Its elementary diagram +consists of all first-order sentences in its language that are true in +the expanded structure. Use this diagram and add constants +assigning a value to every ground term of the Skolemized ring language, +the ring and functionality constraints, all ground universal instances, +and $\Phi$ for each term value. Every finite subset has a +model: its finitely many constraints are among a successful rational +test, and they can be interpreted in the ordinary structure. Finitely +many sentences of its elementary diagram are already true there. +The compactness theorem therefore supplies a simultaneous assignment +in an elementary extension; see \cite{Marker2002}. + +Let $R$ be the set of values of the ground terms. Constraint (a) makes +it a subring of ${}^*\Q$. Interpret each added function by applying its +symbol to representative ground terms. Constraint (b) makes the result +independent of representatives. Every element of $R$ is represented by +a ground term, so (c) implies every universal Skolemized axiom in $R$. +Its reduct is the required model of $\mathcal T$, and (d) gives the +pole-parity condition on every element. The interpretation of fraction +fields extends the embedding to +$F_R\hookrightarrow{}^*F$. + +The ambient diagram is used only in this existence argument. It is not +required to be recursive and is never queried by the finite rational +tests. +\end{proof} + +We now analyze any model and embedding supplied by +Lemma~\ref{red:compactness}. All starred objects refer to its one +ambient extension. The point conditions give the additive injection +\(\eta\) of +\eqref{red:eta}--\eqref{red:additivity}. + +\subsection{Odd valuations select a tested branch} +\label{red:valuation} + +The height radical supplies primes of the ambient integer sort, +whereas the tests are imposed at ideals above an element \(r\in R\). +We now connect these two kinds of data. Fix an ordinary precision +\(K\ge1\). Enlarge the finite exceptional set \(S\) in the height +estimate to a finite set \(S_K\) containing: +the exceptional set for $\Phi$, the supports of all multipliers in +$\mathcal K$, the primes needed to keep the contact forms distinct +with their required unit determinants, the bad or ramified primes of +the elliptic data and $F$, and the finitely many primes excluded by +Proposition~\ref{ell:formal} at precision $K$. + +Write \(M_K(s)=M_{S_K}(s)\) for the radical with these larger +exceptions. Corollary~\ref{hei:enlarge-exceptions} keeps the exponent +unchanged: if \(M(s)=M_S(s)\) is the original radical, then +\[ + M(s)\le\left(\prod_{q\in S_K\setminus S}q\right)M_K(s), + \qquad \hgt(s)\le H_K M_K(s)^c +\] +with an ordinary constant $H_K$. Enlarge $c$ to a positive integer +once and for all if necessary. + +Choose the representation axiom at precision $K$ for any $A\in R$, +and put $\widetilde s_i=(\widetilde u_i:\widetilde v)$. +All its contact forms are nonzero, so +$\widetilde s_i\notin\mathcal C$. Consider any ambient prime $q$ +counted in some $M_K(\widetilde s_i)$. Here and below a radical, prime, +or valuation on starred sorts is the transfer of its ordinary definition. + +Let $t=\min\{v_q(\widetilde u_i),v_q(\widetilde v)\}$. +At $q\notin S_K$, the minimum of the valuations of the five contact +forms equals $t$: all their coefficients are integral and a pair has +unit determinant. Since some contact depth is odd, these five +valuations cannot all have the same parity. In particular one of them +is odd. For its expression $\varepsilon k r$ in +\eqref{red:contact-list}, $k$ is a $q$-unit, and hence +\begin{equation}\label{red:odd-r} + v_q(\widetilde r)\text{ is odd}. +\end{equation} + +The odd valuation links this ring element \(r\) to the ambient +prime \(q\), but it does not make the tested localization a subring of +the ambient valuation ring: \(R\) may have denominators at \(q\). +We will quotient the value group by the convex subgroup generated by +the negative valuations of nonzero ring elements. Pole parity ensures +that the odd value of \(r\) survives positively in this quotient. The +center of the resulting valuation will then select one of the two +tested branches. + +\begin{lemma}\label{red:coarsening} +For the prime $q$ and element $r$ in \eqref{red:odd-r}, there is a +branch $\mathfrak p\in\{\mathfrak p_+,\mathfrak p_-\}$ of that +representation axiom and an ambient place $v_*$ of ${}^*F$ over $q$ +such that, for every ordinary integer $l\ge1$ and every $D'\in F_R$, +\begin{equation}\label{red:valuation-transfer} + D'\in r^l(R_F)_{\mathfrak p} + \quad\Longrightarrow\quad v_*(\widetilde D')\ge l. +\end{equation} +Every point formal for this tested localization actually reduces to +$O$ for $v_*$. +\end{lemma} + +\begin{proof} +Let $J$ be the convex subgroup of ${}^*\Z$ generated by the negative +values of $v_q$ on $\widetilde R\setminus\{0\}$. Thus $\gamma\in J$ +if $|\gamma|$ is bounded by a finite sum of absolute values of such +negative values. This definition is external; we will use it only to +construct a valuation on the embedded ring, not as part of an algorithm +or a transferred formula. + +Every valuation of a nonzero ring element that lies in $J$ is even. +If $J=0$, this is immediate. +Otherwise, given $a\ne0$ with $v_q(\widetilde a)\in J$, finite products +of ring elements having negative value give $b\in R\setminus\{0\}$ +with +$v_q(\widetilde b)<-|v_q(\widetilde a)|$. Both $\widetilde b$ and +$\widetilde a\widetilde b$ have negative valuation. The soundness of +$\Phi$, transferred from Proposition~\ref{par:pole-parity}, says that +these two valuations are even. Their difference +$v_q(\widetilde a)$ is therefore even as well. + +By \eqref{red:odd-r}, $v_q(\widetilde r)$ is outside $J$; it is +positive, because every negative ring value lies in $J$. +Extend $v_q$ to an ambient place $v_*$ on ${}^*F$. Outside the fixed +ramified primes, its value group is still ${}^*\Z$ with the same +normalization, by transfer of the corresponding ordinary place facts. +Coarsen it to the ordered quotient ${}^*\Z/J$, obtaining $w_*$. +This coarsened valuation is nonnegative on $\widetilde R$: +all its negative original values become zero. It is also nonnegative +on $\widetilde R_F$, since $\sqrt2$ is integral. + +The pullback of the center on the embedded \(R_F\) is +\[ + \mathfrak p=\{x\in R_F:w_*(\widetilde x)>0\}. +\] +It is a proper prime ideal, and it contains $r$ because +$w_*(\widetilde r)>0$. On the other hand, +\[ + R_F/rR_F\simeq(R/rR)[X]/(X^2-2) + \simeq(R/rR)\times(R/rR), +\] +where the last isomorphism uses $B_r^2=2$ and the invertibility of +$2B_r$. A prime of this product is one of its two maximal ideals. +Consequently $\mathfrak p$ is exactly one of the tested branch ideals +$\mathfrak p_\pm$. + +If $D'=r^l X/Y$ as in \eqref{red:localization-definition}, then +$Y\notin\mathfrak p$, so its image has $w_*$-value zero. Thus +\[ + w_*(\widetilde D')\ge l w_*(\widetilde r). +\] +For $D'=0$, \eqref{red:valuation-transfer} is automatic. Otherwise, +if $J=0$, the displayed inequality gives +$v_*(\widetilde D')\ge l v_q(\widetilde r)\ge l$. +If $J\ne0$, its convexity implies that it contains every ordinary +integer. A positive value in the ordered quotient is represented by +an ambient integer larger than every element of $J$; the same inequality +again gives $v_*(\widetilde D')\ge l$. + +Finally, a tested finite formal point has +$1/x\in r(R_F)_{\mathfrak p}$, so its actual $x$-valuation is +negative. At the good integral model this is exactly the condition +for reduction to $O$. The identity point has that reduction as well. +\end{proof} + +\subsection{Index congruences at every contact prime} +\label{red:indices} + +\begin{proposition}\label{red:index-congruence} +Fix an ordinary \(K\ge1\) and use the exceptional set \(S_K\) above. +Choose a representation supplied at precision \(K\) for an arbitrary +\(A\in R\), and put +\(\widetilde s_i=(\widetilde u_i:\widetilde v)\). +For every prime \(q\) of \({}^*\Z\) counted by any +\(M_K(\widetilde s_i)\), and every \(a\in R\), the element +\(\widetilde a\) is integral at \(q\) and +\begin{equation}\label{red:index-congruence-equation} + v_q(\widetilde a-\eta(a))\ge K. +\end{equation} +\end{proposition} + +\begin{proof} +The odd-contact argument selects a factor \(r\) with odd +\(q\)-valuation. Lemma~\ref{red:coarsening} supplies one of its tested +branches and a place \(v_*\) above \(q\). At this branch the theory +supplies nonzero \(h,j_0\), fixed for all \(a\in R\). +Every tested formal point is an actual formal point at \(v_*\), for +its own curve. The same lemma sends the memberships +\eqref{red:primary-test} and \eqref{red:alternate-test} to the two +valuation comparisons of Lemma~\ref{red:local-comparison}, each at +precision \(K\) and at this same place. The primary logarithm denominator +is nonzero by its axiom and the embedding; the conjugate parameter +denominator is nonzero by \(j_0\ne0\) and the point conditions. +Finally \(q\notin S_K\) ensures \(q\notin S_E\) and \(q>K+1\). +All hypotheses of Lemma~\ref{red:local-comparison} therefore hold, +and it gives the assertion. +\end{proof} + +\subsection{The height contradiction} +\label{red:height-contradiction} + +\begin{proposition}\label{red:finite-test-success} +Let $f\in\Z[X_1,\ldots,X_n]$ be nonconstant. If every finite system +of rational constraints constructed in \S\ref{red:finite-tests} for +$f$ is solvable, then $f$ has a zero in $\Z^n$. +\end{proposition} + +\begin{proof} +Choose the model supplied by Lemma~\ref{red:compactness}, with its +root tuple $\mathbf a$ and the additive map $\eta$ of +\eqref{red:eta}--\eqref{red:additivity}. Set +\[ + \delta=f(\eta(a_1),\ldots,\eta(a_n))\in{}^*\Z. +\] +If $\delta=0$, the ambient integer sort satisfies +$\exists\mathbf x\in\Z^n\ f(\mathbf x)=0$; by elementarity the +ordinary integers satisfy that sentence. It remains to consider +$\delta\ne0$. + +Write +\begin{equation}\label{red:B-D} + B=\max(1,|\eta(a_1)|,\ldots,|\eta(a_n)|),\qquad + D=\max(1,\deg f). +\end{equation} +For an ordinary constant $C_f>0$, transfer of the elementary polynomial +bound gives +\begin{equation}\label{red:error-bound} + |\delta|\le C_f B^D. +\end{equation} +Choose an ordinary integer $K\ge cD$, where $c$ is the fixed positive +integer exponent of the height estimate. All exceptions and constants +below refer to this fixed $K$. + +Figure~\ref{fig:finite-test-proof} summarizes how the chosen representations +for all \(A\in R\) use the same \(\delta\). + +\input{figures/reduction-overview} + +For any $A\in R$, take its representation at precision $K$ and +any prime $q$ counted in any $M_K(\widetilde s_i)$. +Proposition~\ref{red:index-congruence} applies to each $a_j$. +Both the embedded coordinates and their integer indices are +\(q\)-integral. Since \(f(\widetilde{\mathbf a})=0\) in the ambient +field and the coefficients of \(f\) are integers, their coordinatewise +congruences give +\begin{equation}\label{red:error-divisibility} + v_q(\delta)\ge K. +\end{equation} +For each fixed slope, \eqref{red:error-divisibility} now holds for +every ambient prime counted by its radical. This is the internal +universal premise in the transfer of the ordinary divisibility fact: +if every prime in a squarefree product divides an integer to order at +least \(K\), then the \(K\)th power of that product divides the integer. +Using the transferred finite-product function gives +\begin{equation}\label{red:radical-divides} + M_K(\widetilde s_i)^K\mid\delta. +\end{equation} +The coarsenings may have been chosen externally one prime at a time; +only the universal assertion just established enters this transferred +implication. Although \(A\) and its representation were arbitrary, +the integer \(\delta\) is the same for all of them. + +As $\delta\ne0$, \eqref{red:radical-divides} and +\eqref{red:error-bound} give +\[ + M_K(\widetilde s_i)^c + \le |\delta|^{c/K} + \le C_f^{c/K}B^{cD/K}\ll_f B. +\] +The height estimate therefore implies +\begin{equation}\label{red:slope-height} + \hgt(\widetilde s_i)\ll_f B. +\end{equation} +Since $v\ne0$ and $u_1+u_2+u_3=Av$, the ordinary logarithmic height +inequality for a sum of three numbers, transferred to the ambient +structure, gives +\begin{equation}\label{red:all-ring-height} + \hgt(\widetilde A) + =\hgt\!\left(\frac{\widetilde u_1}{\widetilde v} + +\frac{\widetilde u_2}{\widetilde v} + +\frac{\widetilde u_3}{\widetilde v}\right) + \le\sum_{i=1}^3\hgt(\widetilde s_i)+\log3 + \ll_f B \qquad(A\in R). +\end{equation} +The implicit constant is ordinary and independent of $A$ and of the +root tuple. The dependence on $f$ comes only from its degree and +coefficients and the resulting fixed choice of $K$. + +For each nonzero \(a_j\), formula +\eqref{red:coordinate-functions} expresses \(x(T_{a_j})\) using +the three ring elements \(x_0(a_j),x_1(a_j),x_2(a_j)\), with +\(x_2(a_j)\ne0\). Applying \eqref{red:all-ring-height} to these +three elements and using the logarithmic height inequalities over the +fixed number field \(F\) gives +\begin{equation}\label{red:elliptic-upper} + \hgt(x(\eta(a_j)P))\ll_f B. +\end{equation} +Canonical height on the fixed elliptic curve gives, for ordinary +integer $n\ne0$, and hence for ambient integer indices by transfer, +\begin{equation}\label{red:elliptic-lower} + \hgt(x(nP))=2\widehat h(P)n^2+O(1), + \qquad\widehat h(P)>0; +\end{equation} +see \cite{Silverman2009}. The error term is uniformly bounded for +the fixed curve and point. If $B>1$, choose a maximizing nonzero +index in \eqref{red:B-D}. Equations +\eqref{red:elliptic-upper}--\eqref{red:elliptic-lower} give +\[ + 2\widehat h(P)B^2\le C B+C' +\] +for ordinary constants, so $B$ is bounded by an ordinary constant. +This is also true if $B=1$. + +Every element of ${}^*\Z$ in an ordinary finite interval is an +ordinary integer, by transfer of the finite description of that +interval. Thus $\eta(a_j)=n_j\in\Z$ for each $j$. +By additivity and $\eta(1)=1$, $\eta(n_j)=n_j$; injectivity then +gives $a_j=n_j$ in $R$. The relation $f(\mathbf a)=0$ is consequently +an ordinary integer solution. In the case currently under consideration +this also contradicts $\delta\ne0$. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:main}] +Constant polynomials can be decided directly. For nonconstant $f$, +if every finite rational test succeeds, +Proposition~\ref{red:finite-test-success} gives an integer zero. Therefore, +when $f$ has no integer zero, some finite test must fail. Run the +finite-test search and enumeration of integer tuples in parallel, +allocating successive finite steps to each. The enumeration terminates +when a zero exists; the test search terminates when none exists. +Their answers are sound. Rational decidability would therefore give +integer decidability, contradicting the Davis--Putnam--Robinson--Matiyasevich +theorem \cite{DavisPutnamRobinson1961,Matiyasevich1970}. +\end{proof} + diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/03-parity.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/03-parity.tex new file mode 100644 index 0000000000000000000000000000000000000000..e828bef1d31272113744777b270789e8a5a1f670 --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/03-parity.tex @@ -0,0 +1,718 @@ +\section{An existential condition excluding odd poles}\label{par:section} + +We prove Proposition~\ref{par:pole-parity}, used in the finite rational +tests of Section~\ref{sec:reduction}. It requires a positive existential +condition that holds on all integers and restricts the denominators of any +rational number satisfying it. Square classes below mean classes in the +multiplicative group modulo squares. + +Earlier existential formulas make related valuation information +accessible on restricted sets of primes. For a fixed global field +\(K\) of characteristic different from \(2\) and a fixed quadratic +extension \(L/K\), Demeyer and Van Geel give an existential formula +which, for nonzero \(x,y\in K\), is equivalent to +\[ + v_{\mathfrak p}(x)\ \text{odd} + \quad\Longrightarrow\quad + v_{\mathfrak p}(x/y^2)>0 + \qquad + \text{for every nonarchimedean prime \(\mathfrak p\) inert in \(L/K\)}. +\] +They also permit a fixed finite union of such inert-prime sets +\cite[Theorem~14 and Corollary~15 in the author version]{DemeyerVanGeel2006}. +Cornelissen and Zahidi use related odd-valuation predicates in their +elliptic-divisibility approach +\cite[Sections~3.3 and~3.11]{CornelissenZahidi2007}. +The existential definitions of Demeyer and Van Geel control the +chosen inert primes. +Proposition~\ref{par:pole-parity} instead supplies the stated +one-sided restriction outside a fixed finite exceptional set. + +We first define a formula from finite multiplier lists and prove the +pole restriction. We then choose the lists once and for all and prove +integer completeness by realizing the same square class on two elliptic +curves. + +\subsection{The formula and the pole restriction} + +For now, let $\mathcal M\subset\Q^\times$ be a finite nonempty list, +and for each $m\in\mathcal M$ let $\mathcal D_m\subset\Q^\times$ +be a finite nonempty list. The construction below associates a formula +$\Phi$ to these lists. Let $S_1$ be a finite set containing $2$, $3$, +and the supports of every member of all the lists. We will make one +fixed choice of the lists in the next subsection. + +For $l\in\Q^\times$, write +\begin{equation}\label{par:curve} + E_l:\quad y^2=x(x-l)(x+3l). +\end{equation} +The three roots are distinct, so this is an elliptic curve with its +point at infinity $O$ as origin. Define $\Phi(b)$ to hold if $b=0$, +or if $b\ne0$ and, for some $m\in\mathcal M$, $m_d\in\mathcal D_m$, +and $t,e\in\Q$, the following conditions hold: +\begin{equation}\label{par:auxiliary-functions} + d=m_db,\qquad b'=mb,\qquad + U=b\frac{1-dt^2}{1+dt^2},\qquad H'=b'(b'-U^2), +\end{equation} +\[ + 1+dt^2\ne0,\qquad eH'\ne0, +\] +and each of $E_e$ and $E_{eH'}$ has a rational point whose +$x$-coordinate belongs to $b'\Q^{\times2}$. + +For each fixed choice of the lists, this is a positive existential +formula. The choices of multipliers are finite disjunctions. A nonzero +condition $a\ne0$ is the existential equation $az=1$; the condition on +$x$ is expressed by $x=b'z^2$ with $z\ne0$. Introduce $U$ as a variable +and multiply its defining equality by $1+dt^2$. All remaining conditions +are polynomial equalities with fixed rational coefficients, which can be +cleared to integer coefficients. + +\begin{lemma}\label{par:soundness} +For any finite lists as above, if $b\in\Q^\times$ satisfies $\Phi(b)$ +and $q\notin S_1$, then $v_q(b)<0$ implies $v_q(b)\in2\Z$. +\end{lemma} + +\begin{proof} +Suppose that $q\notin S_1$, that witnesses for $\Phi(b)$ have been +chosen, and that $k=v_q(b)<0$ is odd. The multipliers are $q$-adic +units, so $v_q(d)=v_q(b')=k$. If $t=0$, then $U=b$. If $t\ne0$, +the valuation $v_q(dt^2)=k+2v_q(t)$ is odd and hence nonzero. +When this valuation is positive, both $1-dt^2$ and $1+dt^2$ are +units. When it is negative, both have valuation $v_q(dt^2)$. +In either case $v_q(U)=k$. Since $2k0$, the +other two factors are units because $q\ne3$, so its valuation is +$v_q(X)$. In both cases this valuation must be even. The case +$v_q(X)=0$ already has the desired parity. This contradicts +$x\in b'\Q_q^{\times2}$, since $v_q(b')=k$ is odd. +\end{proof} + + +\subsection{Preparing integer witnesses} + +We now choose the multiplier lists so that the formula also holds on +every integer. These lists will be fixed independently of the input +$b$. Choose a finite list $\mathcal M\subset\Q^\times$ with the +following property: for every $b\in\Q^\times$, some $m\in\mathcal M$ +makes +\begin{equation}\label{par:b-prime-choices} + b'=mb>0,\qquad b'\in\Q_2^{\times2},\qquad + b'\in\text{the unit nonsquare class of }\Q_3^\times. +\end{equation} +Here the last condition means that $b'$ has even $3$-adic valuation +and nonsquare unit part. Such a list exists because +$\R^\times/\R^{\times2}$, $\Q_2^\times/\Q_2^{\times2}$, and +$\Q_3^\times/\Q_3^{\times2}$ are finite, their classes are open, +and weak approximation supplies a rational representative for each +specified finite tuple of classes. For each $m\in\mathcal M$, set +\[ + S(m)=\{2,3\}\cup\operatorname{Supp}(m). +\] +The same argument gives a finite list +$\mathcal D_m\subset\Q^\times$ such that, for any $b\ne0$, some +$m_d\in\mathcal D_m$ makes +\begin{equation}\label{par:d-choices} + d=m_db>0,\qquad d\in\Q_q^{\times2}\quad(q\in S(m)). +\end{equation} +Use these fixed lists in $\Phi$, and fix $S_1$ containing $2$, $3$, +and all their supports as above. The normalizations +\eqref{par:b-prime-choices}--\eqref{par:d-choices} are used only to +select entries $m,m_d$ for an integer input; they are not additional +conjuncts of $\Phi$. Lemma~\ref{par:soundness} already proves the pole +restriction for this choice. + +Fix $b\in\Z\setminus\{0\}$ and choose $m,m_d$ so that +\eqref{par:b-prime-choices} and \eqref{par:d-choices} hold. +We choose $t$ to serve two purposes. The value $U$ should be small at +the places where $d$ was made a local square, while at primes outside +$S(m)$ where $v_q(b')$ is odd it should retain the valuation of $b$. +These properties will make $H'$ a local square at every prime where +$v_q(b')$ is odd, and $b'$ a local square at every prime where +$v_q(H')$ is odd. + +At the real place and at every $q\in S(m)$, choose a local solution +of $dt^2=1$. As $t$ tends to this solution, the rational function +$U$ tends to zero: its denominator tends to the nonzero number $2$. +Thus, in sufficiently small neighborhoods, $H'>0$ at the real place, +and +\[ + H'=b'^2\left(1-\frac{U^2}{b'}\right)\in\Q_q^{\times2} + \quad(q\in S(m)), +\] +by openness of the local square subgroup. At every +$q\in\operatorname{Supp}(m_d)\setminus S(m)$, require $t$ to be +so small that $v_q(dt^2)>0$. Weak approximation satisfies all these +conditions simultaneously with a rational $t$. In particular +$1+dt^2\ne0$ and $H'>0$. + +Let $\beta,\theta$ be the unique positive squarefree integers +representing the square classes of $b',H'$, and let +\[ + B=\operatorname{Supp}(\beta),\qquad + J=\operatorname{Supp}(\theta). +\] + +\begin{lemma}\label{par:cross-squares} +The sets $B,J$ are disjoint and avoid $2,3$. Moreover, +\begin{equation}\label{par:mutual-squares} + \theta\in\Q_q^{\times2}\quad(q\in B),\qquad + \beta\in\Q_q^{\times2}\quad(q\in J). +\end{equation} +Both $\beta$ and $\theta$ are squares in $\Q_2^\times$; at $3$, +$\theta$ is a square and $\beta$ is a unit nonsquare. In particular +$B\ne\varnothing$. +\end{lemma} + +\begin{proof} +The assertions at $2,3$ follow from the choices already made and +are unchanged on replacing numbers by square-class representatives. +At a prime $q\in B\cap S(m)$, $H'$ is a local square by construction. +Now suppose $q\in B\setminus S(m)$. Since $m$ is a unit at $q$ and +$b$ is an integer, $v_q(b)=v_q(b')$ is a positive odd integer. +If $q\notin\operatorname{Supp}(m_d)$ and $t\ne0$, then +$v_q(dt^2)=v_q(b)+2v_q(t)$ is odd and nonzero, and the quotient +$(1-dt^2)/(1+dt^2)$ is a unit, just as in +Lemma~\ref{par:soundness}. For $t=0$ this quotient is $1$. +If instead $q\in\operatorname{Supp}(m_d)$, our additional smallness +condition on $t$ also makes it a unit. Hence $v_q(U)=v_q(b)$, and +\[ + v_q(U^2/b')=v_q(b)>0. +\] +As $q$ is odd, $1-U^2/b'$ is a local square. The displayed formula +for $H'$ proves the first assertion of \eqref{par:mutual-squares}, +and also proves $B\cap J=\varnothing$. + +For the converse assertion, let $q\in J$. Such a prime is outside +$S(m)$, since $H'$ is square there, and $v_q(b')$ is even because +$q\notin B$. If $U=0$, then $H'=b'^2$ and there is no such prime, +so suppose $U\ne0$. Put +\[ + \alpha=v_q(b'),\qquad \gamma=2v_q(U). +\] +Both are even. If $\alpha\ne\gamma$, then +$v_q(b'-U^2)=\min(\alpha,\gamma)$ is even, contrary to +the oddness of $v_q(H')$. Therefore $\alpha=\gamma$. +Since $v_q(H')=\alpha+v_q(b'-U^2)$ is odd, cancellation is +strict: $v_q(b'-U^2)>\alpha$. Thus +$b'/U^2\in1+q\Z_q$, a square in $\Q_q^\times$, proving that +$\beta$ is square there. This argument also covers possible +denominators in $t$ or $U$. Finally $\beta$ cannot be $1$, since +its class at $3$ is nonsquare. +\end{proof} + + +Write $H'=\theta c^2$ with $c\in\Q^\times$. For every $n\in\Q^\times$ +the isomorphism +\begin{equation}\label{par:twist-scaling} + E_{n\theta}\longrightarrow E_{nH'},\qquad + (x,y)\longmapsto(c^2x,c^3y) +\end{equation} +preserves $x$-coordinate square classes. Thus, taking $e=n$ in the +formula, it remains to find one $n$ for which both $E_n$ and +$E_{n\theta}$ have a rational point with nonzero $x$-coordinate of class +$\beta$, the class of $b'$. We first give a criterion for one parameter +$l$, and then construct a single $n$ for which it applies to both twists. + +\subsection{A criterion for one twist} + +We recall the exact part of full two-descent that we use; see +\cite[Chapter~X, Proposition~1.4, p.~315]{Silverman2009}. For a split +separable cubic $y^2=\prod_{i=1}^3(x-e_i)$ over a field $k$ of +characteristic zero, choosing two roots identifies +$H^1(k,E[2])$ with $(k^\times/k^{\times2})^2$. In the coordinate +corresponding to $e_i$, the Kummer map takes a point to the class +of $x-e_i$; at $(e_i,0)$ the value is replaced by +$\prod_{j\ne i}(e_i-e_j)$, and at $O$ it is $1$. +The Kummer map is an injection of $E(k)/2E(k)$ into this group. +The group $\Sel_2(E/\Q)$ is the subgroup of rational pairs lying +in the Kummer image at every completion. The standard Selmer exact +sequence \cite[Chapter~X, Theorem~4.2, p.~333]{Silverman2009} is +\begin{equation}\label{par:selmer-exact-sequence} + 0\longrightarrow E(\Q)/2E(\Q) + \longrightarrow\Sel_2(E/\Q) + \longrightarrow\Sha(E/\Q)[2]\longrightarrow0. +\end{equation} + + +We use the coordinates $(x+3l,x-l)$ for $E_l$. For a finite rational +point $T$ with $x(T)\notin\{0,l,-3l\}$, the curve equation gives +\[ + [x(T)]=[x(T)+3l]\,[x(T)-l]. +\] +Consequently, if the class $(\beta,1)$ is represented by a rational +point and is distinct from the classes of all four rational two-torsion +points, that point has the required nonzero $x$-coordinate class $\beta$. +The next calculation identifies conditions that make $(\beta,1)$ the +one additional Selmer direction beyond rational two-torsion. + +For the Selmer graph-matrix viewpoint underlying this calculation, see +Monsky's appendix to Heath-Brown \cite[Appendix, pp.~365--370]{HeathBrown1994}. +The matrix and simultaneous rank calculations below adapt that viewpoint +to the present curve family. + +At the primes dividing $l$, the local square conditions will be recorded +by binary residue symbols. For an odd prime $q$ and a $q$-adic unit $a$, +write $[a/q]\in\F_2$ for the nonsquare bit: it is $0$ for a square +residue and $1$ for a nonsquare residue. For a finite set $Q$ of distinct +primes different from $2,3$, indexed by $i$, and a vector $w\in\F_2^Q$, +write $D_w$ for the diagonal matrix with diagonal $w$. Put +\begin{equation}\label{par:matrices} + s_i=[-1/q_i],\qquad \lambda_i=[3/q_i],\qquad + (Ku)_i=\sum_{j\ne i}[q_j/q_i](u_j+u_i),\qquad N=K+D_s. +\end{equation} +All matrices and vectors in this calculation are over $\F_2$. Write +$\mathbf1$ for the all-ones vector and $\mathbf1_B$ for the indicator +of $B$ in $Q$. Quadratic reciprocity gives +\begin{equation}\label{par:reciprocity-matrix} + K+K^{\mathsf t}=ss^{\mathsf t}+D_s. +\end{equation} +In particular, if $s^{\mathsf t}\mathbf1=1$, then +\begin{equation}\label{par:matrix-null-vectors} + K\mathbf1=K^{\mathsf t}\mathbf1=0, + \qquad N=K^{\mathsf t}+ss^{\mathsf t}. +\end{equation} + +The family \(y^2=x(x-n)(x+3n)\) also occurs in the study of +\(\pi/3\)- and \(2\pi/3\)-congruent numbers. Mokrani adapted +Monsky matrices to these families \cite{Mokrani2020}. For this +family, Wei and Guo give a two-Selmer matrix formulation and write +the same quadratic-reciprocity identity for the associated R\'edei +matrix as \eqref{par:reciprocity-matrix} +\cite[Section~4 and Theorem~6.2]{WeiGuo2022}. The simultaneous +kernel conditions for the two twists required here are constructed +below. + +\begin{lemma}\label{par:descent} +Let $l>0$ be squarefree, prime to $6$, with +$l\equiv3\pmod4$ and $l\equiv2\pmod3$. Suppose that its support +$Q$ contains the nonempty set $B$ of Lemma~\ref{par:cross-squares} +and a prime outside $B$, and suppose that +\begin{equation}\label{par:matrix-target} + \ker K=\langle\mathbf1,\mathbf1_B\rangle, + \qquad \lambda\notin\operatorname{im}K. +\end{equation} +Then +\[ + \dim_{\F_2}\Sel_2(E_l/\Q)=3, +\] +and $(\beta,1)$ is a Selmer class outside the subgroup of rational +two-torsion classes, in Kummer coordinates $(x+3l,x-l)$. +\end{lemma} + +\begin{proof} +In the stated coordinates, the points $(l,0)$ and $(-3l,0)$ have +classes +\begin{equation}\label{par:torsion-classes} + \tau_1=(l,1),\qquad \tau_2=(3,-l), +\end{equation} +respectively. For example, the replacement coordinate at $(l,0)$ +is $(l+3l)l=4l^2$, and the replacement at $(-3l,0)$ is +$(-3l)(-4l)=12l^2$. These two classes are independent globally: +$l$ is nonsquare, and the second coordinate of $\tau_2$ is negative. + +We first bound the Selmer group using necessary local conditions. +Afterward we verify that $(\beta,1)$ lies in the actual local Kummer +image everywhere. For any odd prime $q$, the group +$E_l(\Q_q)/2E_l(\Q_q)$ has order four. To see this, choose an +open formal subgroup $H$ on which multiplication by $2$ is an +isomorphism. The quotient $G=E_l(\Q_q)/H$ is finite, and +$E_l(\Q_q)/2E_l(\Q_q)\simeq G/2G$. Moreover +$E_l(\Q_q)[2]\simeq G[2]$: injectivity follows from $H[2]=0$, +and a lift of any element of $G[2]$ can be corrected by an element +of $H$, using the surjectivity of multiplication by $2$ on $H$. +Finally $|G/2G|=|G[2]|=4$. + +At an odd prime $q\nmid3l$, the roots are integral and pairwise +distinct modulo $q$. If $v_q(x)<0$, all three factors have that +valuation, which must be even. If $x$ is integral, at most one +factor has positive valuation, and that valuation must be even. +The replacement classes at the roots are units as well. Hence +the local Kummer image is contained in the subgroup of pairs +having even coordinate valuations. This unramified subgroup has +order four, so the containment is equality. + +At a support prime $q_i\mid l$, the valuation pairs of $\tau_1$ +and $\tau_2$ are $(1,0)$ and $(0,1)$ modulo $2$; therefore they +generate the entire local image, again by its order four. At $3$, +$l$ is a unit nonsquare and $-l$ is a square. Thus $\tau_1$ +and $\tau_2$ have independent first-coordinate classes and square +second coordinates. The local image at $3$ is consequently +\begin{equation}\label{par:local-three} + (\Q_3^\times/\Q_3^{\times2})\times\{1\}. +\end{equation} + +At $2$ we need the necessary condition that both Kummer coordinates +have even valuation. For a point away from the roots with +$v_2(x)<0$, all three factors have valuation $v_2(x)$, so that +valuation is even. If $x$ is integral and even, $x+3l$ and $x-l$ +are units. Suppose $x$ is odd. If $x-l=2u$ with $u$ odd, then +\[ + (y/2)^2=(l+2u)u(u+2l)\equiv l\pmod8. +\] +The right side is an odd unit congruent to $3$ or $7$ modulo $8$, +which is impossible for a square. In every remaining nonroot +case, $v_2(x-l)\ge2$ and $v_2(x+3l)\ge2$. Their difference is +$4l$, so their minimum valuation is $2$. Since $x$ is a unit, +their valuation sum is even, and hence both valuations are even. +The root and identity classes also have even valuations, as follows +from \eqref{par:torsion-classes}. This establishes the claimed +necessary condition at $2$; no sufficiency is being asserted. + +At the real place the first coordinate is always positive. Indeed, +for a nonroot real point the allowable $x$ intervals are +$(-3l,0)$ and $(l,\infty)$, and the replacement first coordinates +at the roots are positive as well. The sign of the second coordinate +therefore gives a homomorphism from the Selmer group to +$\{\pm1\}$, and it is surjective because of $\tau_2$. Its kernel, +the classes with both coordinates positive, has index two. +Every class in this kernel has a unique representative of the form +\begin{equation}\label{par:normalized-pair} + \left(3^\delta\prod_iq_i^{u_i},\ \prod_iq_i^{v_i}\right), + \qquad \delta\in\F_2,\quad u,v\in\F_2^Q. +\end{equation} +Here the good-prime restrictions and the even valuations at $2$ +exclude every other prime, and \eqref{par:local-three} excludes +$3$ from the second coordinate. + +At $q_i$, compare \eqref{par:normalized-pair} with the local +torsion class +\[ + \tau_1^{u_i}\tau_2^{v_i} + =(l^{u_i}3^{v_i},(-l)^{v_i}). +\] +The coordinate valuations already agree modulo $2$. Requiring +the resulting unit quotients to be squares gives exactly +\begin{equation}\label{par:selmer-matrix-equations} + Ku+D_\lambda v=\delta\lambda,\qquad Nv=0. +\end{equation} +For example the first unit quotient has nonsquare bit +$\sum_{j\ne i}[q_j/q_i](u_j+u_i)+(\delta+v_i)\lambda_i$; +the second has bit $(Kv)_i+s_iv_i$. The requirement that the +second coordinate be square at $3$ adds +\begin{equation}\label{par:selmer-three-equation} + (\lambda+s)^{\mathsf t}v=0, +\end{equation} +using $[q_i/3]=\lambda_i+s_i$. + +The residue assumptions imply +$s^{\mathsf t}\mathbf1=1$ and $\lambda^{\mathsf t}\mathbf1=0$. +Equations \eqref{par:matrix-null-vectors} give +\begin{equation}\label{par:kernel-N} + \ker N=\ker K^{\mathsf t}\cap s^\perp. +\end{equation} +Indeed, left multiplying $Nv=0$ by $\mathbf1^{\mathsf t}$ +gives $s^{\mathsf t}v=0$, and the identity +$N=K^{\mathsf t}+ss^{\mathsf t}$ then gives the claim in both +directions. By \eqref{par:matrix-target}, $\ker K^{\mathsf t}$ +has dimension two. It contains $\mathbf1$, on which +$s^{\mathsf t}$ is nonzero, so \eqref{par:kernel-N} is a line. +The functional $\lambda^{\mathsf t}$ is nonzero on +$\ker K^{\mathsf t}$ because +$\lambda\notin\operatorname{im}K=(\ker K^{\mathsf t})^\perp$. +Since it vanishes on $\mathbf1$, it is nonzero on the complementary +line \eqref{par:kernel-N}. Equations +\eqref{par:selmer-three-equation} and \eqref{par:kernel-N} +therefore force $v=0$. The first equation in +\eqref{par:selmer-matrix-equations} now gives +$Ku=\delta\lambda$, so $\delta=0$ and +$u\in\ker K=\langle\mathbf1,\mathbf1_B\rangle$. +There are at most four sign-normalized classes, and hence at +most eight Selmer classes. + +For equality, we verify that +\[ + \gamma=(\beta,1) +\] +is an actual local Kummer class everywhere. At $2$ and at the real +place it is the identity class, since $\beta$ is a positive local +square. At $3$ it is $\tau_1$, since $\beta$ and $l$ are both +unit nonsquares. At $q_i\mid l$, take $u=\mathbf1_B$ and $v=0$: +the comparison with $\tau_1^{u_i}$ has square coordinate quotients +precisely because $K\mathbf1_B=0$. At every other finite odd +prime it is unramified, so lies in the local image already +described. This proves $\gamma\in\Sel_2(E_l/\Q)$. +It is neither the identity nor $\tau_1$: $B$ is nonempty, and +$l$ has a prime factor outside $B$. It cannot equal $\tau_2$ or +$\tau_1\tau_2$, whose second coordinates are negative. Thus +$\tau_1,\tau_2,\gamma$ are three independent Selmer classes, +and the upper bound is attained. +\end{proof} + + +It remains to realize this particular Selmer class by a rational point. +The consequence we use from Theorem~1.1 of \cite{PointwiseTwoConverse} +is the following: an elliptic curve $C/\Q$ with $C(\Q)[2]\ne0$ and +$\corank_{\Z_2}\Sel_{2^\infty}(C/\Q)\in\{0,1\}$ has finite +$\Sha(C/\Q)$. The next proof verifies the full Selmer-corank hypothesis +before applying it. + +\begin{lemma}\label{par:global-point} +Under the hypotheses of Lemma~\ref{par:descent}, the curve $E_l$ +has a rational point with nonzero $x$-coordinate in +$\beta\Q^{\times2}$. +\end{lemma} + +\begin{proof} +Put $r=\rank E_l(\Q)$. Since $E_l$ has full rational two-torsion, +the Kummer sequence \eqref{par:selmer-exact-sequence} and +Lemma~\ref{par:descent} imply +\begin{equation}\label{par:rank-sha} + r+\dim_{\F_2}\Sha(E_l/\Q)[2]=1. +\end{equation} +This also controls the full $2$-primary Selmer group before any +finiteness conclusion. The usual exact sequence is +\[ + 0\longrightarrow E_l(\Q)\otimes\Q_2/\Z_2 + \longrightarrow\Sel_{2^\infty}(E_l/\Q) + \longrightarrow\Sha(E_l/\Q)[2^\infty]\longrightarrow0. +\] +These are cofinitely generated $\Z_2$-modules. If the last group +has corank $t$, its structure is +$(\Q_2/\Z_2)^t\oplus F$ with $F$ finite, so +$t\le\dim_{\F_2}\Sha(E_l/\Q)[2]$. It follows from +\eqref{par:rank-sha} that +\[ + 0\le\corank_{\Z_2}\Sel_{2^\infty}(E_l/\Q)=r+t\le1. +\] +The curve has nonzero rational two-torsion, so +\cite[Theorem~1.1]{PointwiseTwoConverse} now applies and proves +that $\Sha(E_l/\Q)$ is finite. + +The Cassels--Tate pairing on this finite group is perfect and +alternating. Alternation here uses the principal polarization +represented by the rational divisor $(O)$; see +\cite{Cassels1962}; see also +\cite[Section~1 and Corollary~9]{PoonenStoll1999}. For completeness, +an alternating perfect pairing on a finite abelian $2$-group +forces an even number of cyclic factors. Choose an element $x$ +of maximal order $2^a$. Perfection supplies $y$ whose pairing +with $x$ has exact order $2^a$. The subgroup generated by $x,y$ +is a nondegenerate copy of $(\Z/2^a\Z)^2$, and the whole group +is its direct sum with its orthogonal complement. Induction gives +a decomposition into such paired cyclic factors. Hence +\[ + \dim_{\F_2}\Sha(E_l/\Q)[2]\quad\text{is even}. +\] +This conclusion uses the perfect pairing on the full finite +$2$-primary group; its restriction to the subgroup killed by $2$ +need not be perfect. Equation~\eqref{par:rank-sha} therefore gives +$\Sha(E_l/\Q)[2]=0$ and $r=1$. + +The Kummer sequence now shows that $\gamma=(\beta,1)$ is the +class of a rational point $T$. By Lemma~\ref{par:descent} its class +differs from all four two-torsion point classes. Thus $T$ is finite +and none of $x(T)$, $x(T)-l$, $x(T)+3l$ is zero. The curve equation +gives, modulo squares, +\[ + [x(T)]=[x(T)+3l]\,[x(T)-l]=\beta, +\] +as required. +\end{proof} + + +\begin{remark} +The unrestricted $2$-converse \cite[Theorem~1.1]{UnrestrictedTwoConverse} +can replace the pointwise theorem in the preceding proof. It gives +finiteness of the whole $\Sha(E_l/\Q)$ from the same full Selmer-corank +bound, without any rational-two-torsion hypothesis. +\end{remark} + +\subsection{One parameter for both twists} + +The criterion is now a condition on the prime support of one twist. +We construct a single positive squarefree $n$ for which it holds both +on the support of $n$ and on that of $n\theta$. The mutual local-square +relations from Lemma~\ref{par:cross-squares} are what allow the second +support to be added without disturbing the first construction. + +\begin{lemma}\label{par:simultaneous-matrices} +For $\beta,\theta,B,J$ as in Lemma~\ref{par:cross-squares}, there is +a positive squarefree integer $n$, prime to $6\theta$, whose support +$P$ contains $B$ and at least one auxiliary prime outside $B$, such +that the following statements hold for both $l=n$ and $l=n\theta$. +The number $l$ satisfies $l\equiv3\pmod4$ and $l\equiv2\pmod3$. +On its prime support $Q=P$ or $Q=P\cup J$, the matrices +\eqref{par:matrices} satisfy \eqref{par:matrix-target}. +\end{lemma} + +\begin{proof} +Since $\beta,\theta$ are odd squares at $2$, their products of +$(-1)$-symbols are $1$. At $3$, reciprocity gives +$[q/3]=[3/q]+[-1/q]=\lambda_q+s_q$. Consequently +\begin{equation}\label{par:fixed-symbol-sums} + \sum_{i\in B}s_i=\sum_{j\in J}s_j=0,\qquad + \sum_{i\in B}\lambda_i=1,\qquad + \sum_{j\in J}\lambda_j=0. +\end{equation} +The fixed $B$--$J$ symbols need not vanish individually. Their +row sums, however, satisfy +\begin{equation}\label{par:cross-symbol-sums} + \sum_{j\in J}[q_j/q_i]=0\quad(i\in B),\qquad + \sum_{i\in B}[q_i/q_j]=0\quad(j\in J), +\end{equation} +by \eqref{par:mutual-squares}. + +Introduce one auxiliary prime $q_0$ of type +$(s_0,\lambda_0)=(1,1)$, and a set $I$ of $|B|-1$ auxiliary +primes of type $(0,0)$. These types can be imposed by the residue +classes $7$ and $1$ modulo $12$, respectively. We first prescribe +all required Legendre symbols abstractly, and realize them by actual +primes at the end. Until then, each unchosen symbol is a bit whose reverse +is constrained by quadratic reciprocity; the matrix reciprocity identity +therefore holds for every completion of these choices. On each of the sets +\[ + Q_0=B\cup I\cup\{q_0\},\qquad Q_1=Q_0\cup J, +\] +the total $s$-sum is $1$ and the total $\lambda$-sum is $0$. +The former gives $l\equiv3\pmod4$, while the sum of $s+\lambda$ +gives $l\equiv2\pmod3$ for the corresponding prime product. + +We first show that, subject to $K\mathbf1_B=0$, both matrix targets follow +from one nonsingularity condition. Fix $b_*\in B$ and let $a$ have entries +$1$ at $q_0,b_*$ and $0$ elsewhere. Thus +\[ + a^{\mathsf t}\mathbf1=0,\qquad + a^{\mathsf t}\mathbf1_B=1. +\] +We shall impose $K\mathbf1_B=0$ on both supports. Assuming this condition +for the moment, set $K^\#=K+\lambda a^{\mathsf t}$. The total symbol +sums and \eqref{par:matrix-null-vectors} show that $K^\#$ kills +$\mathbf1$ on both sides, and +\begin{equation}\label{par:sharp-B} + K^\#\mathbf1_B=\lambda. +\end{equation} +Put +\[ + T=\operatorname{Id}-\mathbf1_Ba^{\mathsf t}. +\] +This is a projection onto $a^\perp$, with kernel +$\langle\mathbf1_B\rangle$, and it fixes $\mathbf1$. By +\eqref{par:sharp-B}, +\begin{equation}\label{par:projection-factorization} + K=K^\#T. +\end{equation} +Suppose that $\ker K^\#=\langle\mathbf1\rangle$. If $Kx=0$, then +$Tx=c\mathbf1$, so +$x=c\mathbf1+(a^{\mathsf t}x)\mathbf1_B$; the converse follows from +$K\mathbf1=K\mathbf1_B=0$. This gives the required kernel of $K$. +If $Kx=\lambda$, put $y=Tx$. Then $a^{\mathsf t}y=0$ and +$K^\#(y-\mathbf1_B)=0$, so +$y-\mathbf1_B\in\langle\mathbf1\rangle$. Applying $a^{\mathsf t}$ +would give $-1=0$, a contradiction. Thus $\lambda\notin\operatorname{im}K$. + +For either support, let $M$ be the matrix obtained from $K^\#$ by +deleting the $q_0$ row and column. It is enough to make $M$ nonsingular. +Indeed, if $K^\#x=0$, subtract $x_{q_0}\mathbf1$ from $x$. The resulting +vector still lies in the kernel, has zero $q_0$ coordinate, and its +remaining coordinates are killed by $M$. Nonsingularity makes that +vector zero, proving $\ker K^\#=\langle\mathbf1\rangle$. We therefore +have two tasks for the symbol choices: impose $K\mathbf1_B=0$ and make +these deleted matrices nonsingular on both supports. + +For the smaller support, let $C$ be a $B$-by-$I$ matrix whose columns +are a basis of the even-sum hyperplane +\[ + \{x\in\F_2^B:\mathbf1_B^{\mathsf t}x=0\}. +\] +These columns will form the off-diagonal block of the deleted matrix. +When $|B|=1$, $C$ is the empty matrix. Prescribe +$[q_i/q_b]=[q_b/q_i]=C_{bi}$ for $b\in B,i\in I$. +Every other off-diagonal symbol incident with $I$ is set to zero. +Prescribe +\[ + [q_0/q_b]=\sum_{i\in I}C_{bi}\qquad(b\in B), +\] +and obtain reverse symbols by reciprocity. In particular +$[q_b/q_0]=[q_0/q_b]+s_b$. The $q_0$--$J$ symbols remain free. + +These prescriptions ensure $K\mathbf1_B=0$ on both supports. +At a $B$ row, the terms from $I$ and $q_0$ cancel, and the sum +from $J$, when present, is zero by \eqref{par:cross-symbol-sums}. +At an $I$ row the sum is a column sum of $C$, hence zero. At the +$q_0$ row it is the sum of all entries of $C$ plus $\sum_B s_b$, +again zero. At a $J$ row it is zero by the second equality in +\eqref{par:cross-symbol-sums}. It therefore remains to make the deleted +matrices nonsingular. + +On $Q_0$, the deleted matrix has the form +\begin{equation}\label{par:block} + M_0=\begin{pmatrix}A&C\\ C^{\mathsf t}&0\end{pmatrix}, + \qquad \mathbf1_B^{\mathsf t}A\mathbf1_B=1. +\end{equation} +The equality follows from \eqref{par:sharp-B} and +$\sum_B\lambda_b=1$. The lower right block is zero since the +only potentially nonzero symbols incident with $I$ are in $C$, +whose column sums vanish. The added matrix $\lambda a^{\mathsf t}$ +changes neither off-diagonal block, because $a$ and $\lambda$ +both vanish on $I$. No symmetry of $A$ is required. + +To prove $M_0$ nonsingular, let $M_0(x,y)^{\mathsf t}=0$. +The second block equation says $C^{\mathsf t}x=0$. Since the +columns of $C$ span the even-sum hyperplane, its annihilator is +$\langle\mathbf1_B\rangle$; hence $x=c\mathbf1_B$. +Left multiplying the first block equation +$cA\mathbf1_B+Cy=0$ by $\mathbf1_B^{\mathsf t}$ gives $c=0$ +by \eqref{par:block}. The injectivity of $C$ then gives $y=0$. +This proof applies also when $|B|$ is even; when $|B|=1$ it says +simply that $M_0=(1)$. + +On adding $J$, the $B,I$ block of the deleted matrix stays equal to +$M_0$. Indeed, the only possible changes to its diagonal are the +$B$--$J$ row sums, which vanish by \eqref{par:cross-symbol-sums}; all +$I$--$J$ symbols were set to zero. Now varying the bit $[q_0/q_j]$ for +one $j\in J$ also varies its reverse by the same bit, as their +reciprocity discrepancy is fixed. After deleting the $q_0$ row and +column, the only surviving change is a toggle of the $j$-th diagonal +entry. Thus these choices independently toggle the $J$-diagonal entries +of the enlarged matrix. Its determinant is a multilinear polynomial +in these bits whose coefficient of their full product is $\det M_0=1$. +A nonzero multilinear polynomial over $\F_2$ cannot vanish at every +point of the Boolean cube: this follows by induction on the number of +variables, writing it as $f_0+Xf_1$. Hence some choice makes the enlarged +matrix nonsingular. If $J$ is empty, the smaller-support calculation +already suffices. The chosen bits do not affect the smaller matrix. + +The deleted matrices are now nonsingular on both supports, so the +preceding reduction proves \eqref{par:matrix-target} on both. +Finally realize the prescribed symbols. Choose the auxiliary primes +successively. At each step, specify the type modulo $12$ and the +Legendre symbols modulo every already fixed prime in $B\cup J$ +or among the earlier auxiliary primes. Each symbol can be imposed +by a nonzero residue modulo that prime; reverse symbols are +consistent by the prescribed reciprocity rule. The Chinese +remainder theorem gives a reduced residue class, and Dirichlet's +theorem supplies infinitely many primes in it. Excluding the +finitely many previously used primes causes no difficulty. +The resulting product +$n=\prod_{q\in B\cup I\cup\{q_0\}}q$ has all the asserted +properties. +\end{proof} + +\begin{proof}[Completion of the proof of Proposition~\ref{par:pole-parity}] +The value $b=0$ satisfies $\Phi$ by definition. For a nonzero integer +$b$, make the local choices preceding Lemma~\ref{par:cross-squares} and choose +$n$ by Lemma~\ref{par:simultaneous-matrices}. Both $l=n$ and +$l=n\theta$ satisfy the hypotheses of Lemma~\ref{par:global-point}, so +each curve has a point with nonzero $x$-coordinate of class $\beta$, +which is also the class of $b'$. The isomorphism +\eqref{par:twist-scaling} sends the point on $E_{n\theta}$ to one on +$E_{nH'}$ with the same $x$-coordinate square class. Taking $e=n$ +gives the two points required in the definition of $\Phi$, on $E_e$ +and $E_{eH'}$. This proves integer completeness, while +Lemma~\ref{par:soundness} proves the asserted pole restriction. +\end{proof} diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/04-height.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/04-height.tex new file mode 100644 index 0000000000000000000000000000000000000000..8e3cadfc5f3cc8d9c2273f833cb37dbea6360be5 --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/04-height.tex @@ -0,0 +1,1326 @@ +\section{A height bound from odd contact with five points}\label{hei:section} + +We prove Theorem~\ref{hei:height}, whose contact radical supplies the +primes used in Section~\ref{sec:reduction}. For +\(s\in\mathbf P^1(\Q)\setminus\mathcal C\), the target is +\[ + \hgt(s)\le H M_S(s)^c, +\] +where \(M_S(s)\) is the squarefree product of the nonexceptional primes +of odd contact with the five fixed points, as defined in that theorem. + +Throughout this section, $\hgt$ is the absolute logarithmic Weil height, +and $h_{\mathrm F}$ is the original stable Faltings height. Unless +another dependence is stated, constants depend only on the geometric +objects and auxiliary levels fixed in the proof. + +The geometric part of the proof constructs a finite cover +$\pi:Y\to\mathbf P^1$ with ramification index two exactly above +$\mathcal C$, carrying a family of principally polarized abelian surfaces. +Outside fixed exceptional primes, the local equation becomes $t=z^2$ +after a finite unramified extension. Thus only odd contact can ramify +the splitting field of a rational fiber, as Lemma~\ref{hei:fiber-field} +makes precise. +The polarized isomorphism class of the surfaces varies on each component, +which also allows their Faltings height to control the base height +(Lemma~\ref{hei:base-height}). + +The surfaces carry quaternionic multiplication, and fibers above a common +base point are isogenous. For a rational base point, this gives isogenies +between a surface and its Galois conjugates. Fibers with extra +endomorphisms have uniformly bounded height by complex multiplication. +For the other fibers, a controlled splitting of the isogeny obstruction +produces a two-dimensional Galois representation. Modularity and a +conductor estimate give a weight-two newform whose level is bounded by a +fixed power of $M_S(s)$. The surface is then an isogeny factor of the +corresponding modular Jacobian over a field of degree $O(M_S(s))$. +Height bounds for that Jacobian and the quantitative isogeny theorem +complete the estimate. + + +\subsection{The five-point quaternionic quotient} + +We first construct the cover whose ramification will detect the odd +contact orders in Theorem~\ref{hei:height}. Let $B/\Q$ be the +indefinite quaternion algebra of discriminant +$210=2\cdot3\cdot5\cdot7$, let $\mathcal O$ be a maximal order, and put +$G=B^\times$. Fix $B\otimes_\Q\mathbf R\simeq M_2(\mathbf R)$. +The quaternionic Shimura datum is $(G,\mathfrak H^\pm)$, where the +two half planes parametrize the conjugates of the elliptic-curve +Hodge homomorphism. Its reflex field is $\Q$: over $\mathbf C$ its +cocharacter has the usual $\mathrm{GL}_2$ conjugacy class, and this +class is invariant under the Galois action for the inner form $G$. + +We use canonical models and functoriality for Shimura varieties +\cite{Deligne1971,Deligne1979}. In the form needed here, they give +the model over the reflex field with complex points +\[ + G(\Q)\backslash + \bigl(\mathfrak H^\pm\times G(\mathbf A_f)/K\bigr) +\] +for a compact open subgroup $K$, and define level maps and +finite-adelic right actions over that field. We use the full Shimura +varieties over $\Q$, including all their geometric components. + +At maximal level, put +\[ + X=\operatorname{Sh}_{\widehat{\mathcal O}^{\,\times}} + (G,\mathfrak H^\pm). +\] +This curve is proper because $B$ is a division algebra. Strong +approximation for $B^1$, the reduced-norm theorem, and +$\operatorname{Nrd}(\mathcal O_p^\times)=\Z_p^\times$ give +\[ + G(\mathbf A_f)=G(\Q)^+\widehat{\mathcal O}^{\,\times}. +\] +Indeed, match the finite-adelic norm modulo $\widehat\Z^\times$ by +a positive rational reduced norm and then apply strong approximation +to the norm-one part. There are also rational elements of negative +norm, since no real place is ramified. Consequently $X_{\mathbf C}$ +is the connected compact curve +\[ + (\mathcal O^1/\{\pm1\})\backslash\mathfrak H. +\] + +The uniformizing group has no nontrivial elliptic stabilizers. A +noncentral norm-one unit fixing a point has integral trace of absolute +value less than two, hence trace $0$ or $\pm1$. It would generate +$\Q(i)$ or $\Q(\sqrt{-3})$. These fields cannot embed in $B$, since +they split at the ramified primes $5$ and $7$, respectively. The +Eichler area formula, in the normalization of +\cite[Theorem 39.1.2]{Voight2021}, therefore gives +\[ + \frac{\operatorname{area}(X(\mathbf C))}{2\pi} + =\frac16\prod_{p\mid210}(p-1)=8. +\] +There are no cusps or elliptic corrections, so $2g(X)-2=8$ and +$g(X)=5$. + +The finite-adelic normalizer of $\widehat{\mathcal O}$ induces the +Atkin--Lehner group +\[ + \mathcal W\simeq(\Z/2\Z)^4 +\] +over $\Q$. At a split prime, the normalizer is scalars times order +units. At a division prime, its quotient by scalars and order units +has order two, detected by parity of reduced-norm valuation. Finite +adelic scalars act trivially, since +$\mathbf A_f^\times=\Q^\times\widehat\Z^\times$. The resulting +action is faithful: a generic domain point has rational stabilizer +equal to the center, which accounts precisely for the scalars already +removed. Let $X^*=X/\mathcal W$. + +The geometry of this discriminant-\(210\) quotient has been tabulated +before. Long, Maclachlan, and Reid list the signature +\((0;2^5;0)\), recording a genus-zero quotient with five elliptic +cycles of order two and no cusps +\cite[Table~3]{LongMaclachlanReid2006}. Nualart Riera gives genus +\(5\) for the original curve and the five involution labels +\(30,42,70,105,210\), and identifies the full quotient over +\(\mathbb Q\) with \(\mathbf P^1\) +\cite[Propositions~4.1--4.2]{Nualart2015}. The calculation here +recovers this fixed configuration and establishes the rational branch +values used in the reduction. + +A finite stabilizer of a point on a smooth characteristic-zero curve +acts faithfully on its tangent line and is cyclic. Since every +nonidentity element of $\mathcal W$ has order two, each nontrivial +stabilizer has order two. If $r$ is the number of geometric branch +values of $X\to X^*$, Riemann--Hurwitz gives +\begin{equation}\label{hei:hurwitz} + 2g(X^*)-2+\frac r2=\frac{2g(X)-2}{16}=\frac12. +\end{equation} +Thus $r=5-4g(X^*)\le5$. + +We exhibit five different stabilizer labels. Take +\[ + m=30,42,70,105,210. +\] +The field $\Q(\sqrt{-m})$ is nonsplit at every prime dividing $210$. +For the first three values, the only prime of $210$ not dividing $m$ +is respectively $7,5,3$, and the residues of $-m$ there are the +nonsquares $5,3,2$. For $m=105$, the quadratic discriminant is +$-420$, so $2$ is ramified too. For $m=210$, all four primes are +ramified. The quaternion embedding criterion from +Albert--Brauer--Hasse--Noether, as in \cite{Voight2021}, gives an +embedding of each field in $B$. + +An embedded $\sqrt{-m}$ lies in some maximal order: at split local +places an integral element stabilizes a lattice, and at division +places it lies in the unique maximal order. Intersecting these local +orders gives a global maximal order containing the embedded element. +Strong approximation implies that all maximal orders in this +indefinite rational quaternion algebra are conjugate by $B^\times$ +\cite[Theorems 28.2.10 and 28.2.11(b)]{Voight2021}, so a conjugate +of the embedded element lies in our fixed $\mathcal O$. +It normalizes $\mathcal O$ because it is a unit at every prime outside +$210$, and at a division prime every element normalizes the unique +maximal order. Its norm is $m$ and it fixes a point of $\mathfrak H$, +so it gives a fixed point of the involution $w_m$ with the corresponding +norm-parity label. + +The five labels are different. A fiber of the quotient is one +$\mathcal W$-orbit, and the stabilizers along this orbit agree because +$\mathcal W$ is abelian. Distinct labels thus yield distinct branch +values, proving $r\ge5$. Equation~\eqref{hei:hurwitz} now forces +$r=5$ and $g(X^*)=0$. There is exactly one branch value for each of +the five labels. Every $w_m$ is defined over $\Q$, so Galois preserves +its uniquely labelled branch value. Each branch value is therefore +individually rational. In particular $X^*$ is a genus-zero curve +with a rational point, hence is isomorphic over $\Q$ to +$\mathbf P^1$. Fix an isomorphism sending one branch value to +$\infty$, and denote the five branch values by $\mathcal C$. + +\newpage +\subsection{The abelian surface family} + +We next pass to a fine level so that the cover carries abelian +surfaces. The construction will provide a finite level map $Y\to X$, +unramified over $X$, and a principally polarized abelian surface +scheme $\mathcal A\to Y$. Write $\pi$ for the composite +\[ + Y\longrightarrow X\longrightarrow X^*\simeq\mathbf P^1, + \qquad \pi:Y\longrightarrow\mathbf P^1. +\] +Every fiber $\mathcal A_y$ with $y\in Y(\overline\Q)$ will have an embedding +$B\hookrightarrow\operatorname{End}^0_{\overline\Q}(\mathcal A_y)$ +given by left multiplication. +Fibers with the same image under $\pi$ will be geometrically isogenous, +and the polarized moduli map will be nonconstant on every geometric +component. We now construct the family and prove these properties. + +Canonical-model functoriality associates algebraic maps to morphisms +of Shimura data at compatible levels +\cite{Deligne1971,Deligne1979}. A Siegel variety at principal level +at least three carries the universal principally polarized abelian +scheme. The required morphism to a Siegel datum comes from the +following symplectic representation. + +On the four-dimensional rational space $V=B$, put +\[ + \rho(g)(x)=x\bar g,\qquad + \psi(x,y)=\operatorname{Trd}(\Delta x\bar y), +\] +where the bar is the standard quaternion involution and $\Delta$ is a +pure quaternion with $\Delta^2<0$. Such a rational $\Delta$ exists +by real approximation in the trace-zero subspace. The identities +$\bar\Delta=-\Delta$ and cyclicity of reduced trace show that $\psi$ +is alternating. It is nondegenerate because the reduced-trace +pairing is nondegenerate and $\Delta$ is invertible. Moreover +\[ + \psi(x\bar g,y\bar g)=\operatorname{Nrd}(g)\psi(x,y). +\] +Quaternion conjugation reverses products, as does composition of +right multiplications; together these identities give +$\rho(gh)=\rho(g)\rho(h)$. +Thus $\rho$ is a faithful symplectic-similitude representation. + +The Hodge homomorphism makes $V_{\mathbf R}$ a complex vector space by +right multiplication. At a base point represented by +$J=\left(\begin{smallmatrix}0&-1\\1&0\end{smallmatrix}\right)$, +the associated real quadratic form is +\[ + \psi(x,x\bar J)=\operatorname{tr}(J\Delta xx^{\mathrm t}). +\] +Since $\Delta$ has trace zero, $J\Delta$ is symmetric, and its +determinant is positive; it is therefore definite. Choose its sign +on one half plane. Conjugation by $G(\mathbf R)$ gives all the other +complex structures, and the displayed similitude identity gives the +corresponding definite sign on the other half plane as well. This is +the two-component Siegel datum. A real scalar acts on $V$ with the +homological weight of an elliptic curve, which is the required weight. + +Choose a rational symplectic basis for $V$. The standard lattice in +that basis is self-dual for $\psi$. Intersect a sufficiently small +compact open subgroup of $\widehat{\mathcal O}^{\,\times}$ with the +inverse image of a principal Siegel level, and call the resulting +subgroup $K_Y$. Put +\[ + Y=\operatorname{Sh}_{K_Y}(G,\mathfrak H^\pm). +\] +The induced morphism from $Y$ to the fine Siegel moduli scheme pulls +back its universal family to the principally polarized abelian +surface scheme $\mathcal A\to Y$. +The self-dual lattice need not be preserved by the whole maximal +order: the intersection of levels provides the integral moduli +problem, while the rational Hodge structure retains the $B$-action. +Fix this level and family once and for all. + +There may be finitely many geometric components of the smooth +projective curve $Y$. The level map $Y\to X$ is unramified by the +uniformization and the absence of elliptic stabilizers on $X$. +Consequently its composite $\pi$ has ramification index two at +every point above $\mathcal C$ and index one elsewhere. + +Every geometric fiber $A=\mathcal A_y$ has left $B$-multiplication in +$\operatorname{End}^0_{\overline\Q}(A)$. Left multiplication commutes +with the right complex structures on $V$; the equivalence between +abelian varieties up to isogeny and their polarizable rational Hodge +structures supplies the endomorphisms. Homomorphisms of abelian +varieties defined over $\overline\Q$ do not acquire new elements after +extension to $\mathbf C$ \cite{Mumford1970}. + +For non-CM points, the moduli construction of Guitart and Molina gives +a related description by compatible isogenies +\cite[Lemma~1, Corollary~2, and Section~3]{GuitartMolina2009}. +For this fine-level family, the following Hodge argument gives the +underlying geometric isogenies for all fibers needed here; compatible +choices are made in the descent argument. Changing level or applying the normalizer changes +the finite-adelic coordinate, while domain coordinates of fibers +above a common point of $X^*$ can be identified up to $G(\Q)$. +Their rational Hodge structures are therefore isomorphic, so the +fibers are geometrically isogenous. In particular, if +$\pi(y)=s\in\mathbf P^1(\Q)$, then $\pi({}^g y)=g(s)=s$ and +$\mathcal A_y$ is isogenous to each of its Galois conjugates. + +Finally, the polarized moduli map of the family is nonconstant on +every geometric component. Its complex structures vary in a half +plane, whereas a fixed rational Hodge structure has only countably +many presentations on the fixed rational space $V$. Thus a component +cannot have a single geometric isomorphism class of fibers. + +\subsection{Rational fibers and odd-contact ramification} + +The ramification index two now explains the parity in the theorem. +We make precise how even contact with a branch value gives unramified +local lifts, and record the good reduction of the resulting surfaces. + +Enlarge a fixed finite set $S$ of rational primes whenever necessary +in the following construction. All these enlargements depend only +on the fixed curves, maps, and family, and occur before choosing $s$. +Include $2$, primes at which the branch sections meet, and primes at +which the chosen coordinates or the geometric models degenerate. +Spread $Y$, $\mathbf P^1$, $\pi$, and $\mathcal A$ over +$\Z[S^{-1}]$ so that the curves are smooth and proper, $\pi$ is finite +and étale away from the branch sections, and +\[ + \pi^*b=2D_b +\] +as relative Cartier divisors, with $D_b$ the reduced inverse image, +finite étale over the ground ring. The abelian scheme also spreads +over this proper model of $Y$. + +\begin{lemma}\label{hei:fiber-field} +For $s\in\mathbf P^1(\Q)\setminus\mathcal C$, put $M=M_S(s)$. +There is a Galois extension $K_0/\Q$ of uniformly bounded degree +splitting the fiber $\pi^{-1}(s)$, unramified outside +$S\cup\{q:q\mid M\}$. Every fiber $A=\mathcal A_y$ above $s$ is +defined over $K_0$ and has good reduction at every place of $K_0$ +outside $S$. +\end{lemma} + +\begin{proof} +The fiber has at most $\deg\pi$ geometric points, so its splitting +field is Galois of degree at most $(\deg\pi)!$. Fix $q\notin S$. +If the reduction of $s$ avoids the branch sections, finite étaleness +implies that the fiber is unramified at $q$. Otherwise it meets +exactly one branch section $b$, and its contact order is +\[ + v_q(L_b(u,v))-\min\{v_q(u),v_q(v)\}. +\] +After a finite unramified local extension, all points of $D_b$ over +this reduction are defined, since $D_b$ is finite étale. At each +such point choose a formal coordinate $z$ cutting out $D_b$. +If $t$ cuts out $b$ on the base, the divisor equality gives +$\pi^*t=z^2e(z)$ with $e(z)$ a unit. After a further unramified +extension its residue has a square root, and Hensel's lemma, since +$q\ne2$, gives a square root of $e(z)$ in the formal power-series +ring. Replacing $z$ by $z\sqrt{e(z)}$ changes the local equation to +$t=z^2$. Make this calculation at every point of $D_b$ over the +branch reduction, using a common further finite unramified extension. + +If the contact order is even, a square root of $t(s)$ is obtained +over an unramified extension by extracting the square root of its +unit part. Both local lifts at every such point are consequently +unramified. By properness, every geometric point of the fiber specializes +to one of the points of $D_b$ just treated, so the whole fiber is +unramified. This proves +that ramification can occur only at the primes in the assertion. + +Every $K_0$-point $y$ extends over the local valuation rings outside +$S$ by properness of $Y$. Pulling back the spread abelian scheme +along these sections gives good reduction of $\mathcal A_y$. +This also applies at places where $K_0/\Q$ is ramified. Thus field +ramification may occur at primes dividing $M$, while good reduction +over $K_0$ holds outside the fixed set $S$. +\end{proof} + +This use of contact multiplicities has a classical specialization +precedent. Darmon and Granville work with a fixed Galois cover of +the projective line branched at \(0,1,\infty\). In that setting, +their Proposition~3.2, credited there to Beckmann, relates +divisibility of contact orders by branch indices to the absence of +new ramification outside fixed bad primes in specialized fiber fields +\cite{DarmonGranville1995}. For the cover used here, the local +equation \(t=z^2\) makes the parity of the contact order relevant. + +\subsection{Comparison of base height and Faltings height} + +The fiber-field lemma identifies the primes that may ramify when a rational +base point is lifted to the family. We also need to recover the height +of that base point from the fiber. The next lemma depends only on the +fixed family, and applies to every algebraic point of $Y$. + +\begin{lemma}\label{hei:base-height} +For every $y\in Y(\overline\Q)$ one has +\begin{equation}\label{hei:comparison} + \hgt(\pi(y))\le C\bigl(1+\max\{0,h_{\mathrm F}(\mathcal A_y)\}\bigr), +\end{equation} +with a constant independent of $y$ and its field of definition. +\end{lemma} + +\begin{proof} +We will use a theta-null map with two properties: its projective height +agrees up to a fixed additive constant with Pazuki's theta height +$h_\Theta$ of the fiber, and the map is nonconstant on each component +of a fixed cover of $Y$. Here $h_\Theta$ is the projective height of +the theta-null point for the corresponding polarization and level +\cite[Section 2.3]{Pazuki2012}. The second property makes the pulled-back +$\mathcal O(1)$ ample on the covering curve. Comparing that ample +height with the pullback of the base height gives +\[ + \hgt(\pi(y))\ll 1+h_\Theta(\mathcal A_y). +\] +Pazuki's comparison of theta and Faltings height will then prove the +lemma. We first construct a map with the two stated properties. + +For every fixed even integer $r\ge2$, the required algebraic theta +data can be chosen after a finite cover of each geometric component +of $Y$. Over a finite extension of its function field, choose a +symmetric ample line bundle $\mathcal M$ representing the principal +polarization, together with the theta data of +\cite[Section 2.3]{Pazuki2012}. These choices require only a finite +extension: a representative of a geometric principal polarization +can be made symmetric by translation, and the torsion points and +finite theta data are defined after a finite extension. They spread +over a dense open subset of the smooth projective covering curve, +where the theta-null map is algebraic. The value of this map at a +fiber is the zero-section point $\Theta(0)$ constructed from Pazuki's +good choices of theta data; after complex uniformization of that fiber, +\cite[Sections~2.3.2--2.3.4]{Pazuki2012} identifies this point, up to the finite +coordinate ambiguity among good choices, with the characteristic +Nullwerte displayed below. These covers and data may +depend on $r$; we will fix the final level after proving nonconstancy. + +We next compare the projective height of this map with Pazuki's theta +height, uniformly in the fiber at any fixed $r$. For a fiber +$A=\mathcal A_y$ and a period matrix $\tau$ for its principal +polarization, the characteristic coordinates can be taken to be +\begin{equation}\label{hei:theta-series} + \theta[a,b](\tau,0)= + \sum_{n\in\Z^2} + \exp\bigl(\pi i(n+a)^{\mathrm t}\tau(n+a) + +2\pi i(n+a)^{\mathrm t}b\bigr), + \quad a,b\in(r^{-1}\Z^2)/\Z^2. +\end{equation} +Start with a nonzero section of $\mathcal M$, whose space of sections +has dimension one, pull it back by $[r]$, and use +$[r]^*\mathcal M\simeq\mathcal M^{r^2}$. Translating by the theta +group over representatives of $A[r^2]/A[r]$ gives these coordinates. +Changing the generating section multiplies all coordinates by one +common scalar. Two symmetric representatives differ by a +two-torsion element of $\operatorname{Pic}^0$, which shifts the +half-characteristic; these shifts are included because $r$ is even. + +Put $k=r^2$. At the generic fiber of the chosen cover, let $g_x$ +denote the good theta-group lift of a $k$-torsion point $x$. These +lifts satisfy the good-choice relation $g_xg_y=\zeta_{x,y}g_{x+y}$ with +$\zeta_{x,y}\in\mu_k$. It gives $g_0\in\mu_k$ and, by iteration at +$kx=0$, $g_x^k\in\mu_k$; hence $g_x^{k^2}=1$. Choose $u_x=c_xg_x$ +with $u_x^{2k}=1$ by taking a $2k$-th root of the central scalar +$(g_x^{2k})^{-1}$. Since $2k\mid k^2$, we have +$c_x^{k^2}=u_x^{k^2}g_x^{-k^2}=1$. These finitely many roots can be +chosen once after a finite constant extension of the function field +and spread with the good data. We use these normalizations only to +compare coordinates of the fixed good-choice theta-null map. + +In analytic theta coordinates, a lift of translation by +$(m+\tau l)/k$ is given by shifting the argument and multiplying by +\[ + \exp(\pi i l^{\mathrm t}\tau l/k+2\pi i l^{\mathrm t}z). +\] +Theta automorphy shows that its order divides $2k$ and that it permutes +$\theta[a,b](\tau,rz)$, up to bounded-order roots of unity, by +$(a,b)\mapsto(a+l/r,b+m/r)$. Two lifts of the same translation whose +$2k$-th powers are one differ by a scalar in $\mu_{2k}$. Thus +comparison with the algebraic $u_x$ introduces a $\mu_{2k}$ factor +after the preceding $\mu_{k^2}$ change from the good lift. All these +coordinate roots of unity preserve projective height, as do +permutations and a common scalar. + +The customary Fourier change of theta basis is a fixed invertible +matrix at this level, so it changes height by $O_r(1)$. Grouping +$r(n+a)$ modulo $k$ in~\eqref{hei:theta-series} relates these +coordinates blockwise by finite Fourier matrices to +$\theta[e/k,0](k\tau,0)$, $e\bmod k$. There are $r^4$ independent +sections, as required by $h^0(\mathcal M^{r^2})=r^4$, and their +values are not all zero since $\mathcal M^{r^2}$ is basepoint-free. +Pazuki's exact theta height uses the $\ell^2$ projective height +\cite[Definition 2.6]{Pazuki2012}; its difference from the usual +projective height is also bounded at this fixed level. These +comparisons give one additive constant depending on $r$, not on the +fiber or its field of definition. + +It remains to choose a level at which the theta-null map is +nonconstant. The following argument avoids an assumption about +generic injectivity of a particular theta map. Take a connected +analytic disk with a fixed homology marking on which the period matrix +varies. Suppose the projective vectors +in~\eqref{hei:theta-series} were constant at every sufficiently +divisible even level. At a chosen period $\tau_0$, select rational +$b_0$ with $\theta[0,b_0](\tau_0,0)\ne0$; such a $b_0$ exists since +the function of real $b$ has constant Fourier coefficient one. +Shrink the disk so its denominator stays nonzero. At a common level +containing $b$ and $b_0$, projective constancy implies that +\[ + \frac{\theta[0,b](\tau,0)}{\theta[0,b_0](\tau,0)} +\] +is constant as $\tau$ varies, for every rational $b$. Density of +rational $b$, continuity, and absolute convergence of the theta +series show that the functions of real $b$ for $\tau$ and $\tau_0$ +are proportional. Their constant Fourier coefficients are one, so +they are equal. Consequently every +$\exp(\pi i n^{\mathrm t}\tau n)$ is constant. Taking $n=e_i$ and +$n=e_i+e_j$ and using continuity forces $\tau$ itself to be constant, +a contradiction. A level with a nonconstant vector therefore exists. +Nonconstancy persists at multiples of that level because the old +characteristic coordinates occur among the new ones. A common even +multiple works for the finitely many components. + +Fix this common level, and make the preceding choices of covers and +theta data at that level. The finitely many covering curves, maps, +and open subsets are now fixed, and can all be defined over a fixed +number field. On each base component, choose a smaller marked disk +avoiding the branch values of the covers and the images of their +omitted points, and take a connected lift to each covering curve above +it. The selected holomorphic characteristic vector remains +nonconstant on the smaller disk. If the theta-null map were constant +on a covering curve, the preceding pointwise identification would +confine that vector on the connected lift to a fixed finite set. +Continuity and connectedness would then make it constant. Thus the +theta-null map is nonconstant on each covering curve and extends +across the omitted points. Its pullback of $\mathcal O(1)$ +has positive degree and is ample. A sufficiently large multiple +of this line bundle minus the pullback by $\pi$ of +$\mathcal O_{\mathbf P^1}(1)$ also has positive degree. The height +machine and the lower bound for an ample height on a projective curve +therefore give +\begin{equation}\label{hei:theta-base} + \hgt(\pi(y))\le C(1+h_\Theta(\mathcal A_y)) +\end{equation} +on the open where the theta data are defined +\cite{BombieriGubler2006}. + +Here $h_\Theta$ is Pazuki's exact theta height; the bounded coordinate +and projective-height comparisons have already been absorbed +in~\eqref{hei:theta-base}. Pazuki uses the Deligne normalization +\[ + h_{\mathrm F}^{\mathrm D}(A) + =h_{\mathrm F}(A)+\frac{\dim A}{2}\log\pi; +\] +compare \cite[Section 2.2]{Pazuki2012} and +\cite[Section 2.3]{GaudronRemondPeriods2014}. Here $h_{\mathrm F}$ +is the original stable Faltings height. For the present surfaces +the difference is the fixed constant $\log\pi$. + +For $H_\Theta=\max\{h_\Theta,1\}$ and +$H_{\mathrm D}=\max\{h_{\mathrm F}^{\mathrm D},1\}$, +\cite[Corollary 1.3(2)]{Pazuki2012} gives +\[ + |H_\Theta-\tfrac12H_{\mathrm D}| + \le C_2\log(\min\{H_\Theta,H_{\mathrm D}\}+2), +\] +where $C_2$ depends only on dimension and level. Since +$\log(H_{\mathrm D}+2)\le2H_{\mathrm D}$ and +$H_{\mathrm D}\le\max\{h_{\mathrm F},1\}+\log\pi$ for these surfaces, +we obtain +\[ + h_\Theta\le C(1+\max\{0,h_{\mathrm F}\}). +\] +Combining this with~\eqref{hei:theta-base} proves the assertion on the +chosen open sets. + +The omitted points on the fixed covering curves form a finite +geometric set. Their base heights are bounded, and enlarging $C$ +handles them. Absolute heights and stable Faltings heights are +unchanged by field extension, so passing to points of the fixed +covers introduces no dependence on their residue-field degrees. +Taking the maximum over the finitely many components proves the lemma. +\end{proof} + +\begin{remark}[An alternative deduction on the compact moduli image] +The same numerical comparison can alternatively be deduced by bounding +the period term in Pazuki's Theorem 1.1 for this family. That theorem compares +$h_\Theta-\tfrac12h_{\mathrm F}^{\mathrm D}$ with the average of +logarithms of determinants of imaginary parts of Siegel-reduced +periods, with bounded error at fixed dimension and level +\cite{Pazuki2012}. The determinant terms are bounded here. +The moduli image is compact because $Y$ is projective, and the +minimum nonzero period length in the polarization metric has a +positive lower bound on it. On the subgroup $\Z^2$ of the period +lattice the metric has matrix $(\operatorname{Im}\tau)^{-1}$. +Minkowski's theorem bounds $\det\operatorname{Im}\tau$ above in terms +of that minimum length, and Siegel reduction bounds it below by a +positive constant. These bounds hold at every embedding, because +every conjugate belongs to the fixed compact moduli image. Theorem 1.1 +and the same normalization conversion therefore also give +$h_\Theta\le C(1+\max\{0,h_{\mathrm F}\})$. +\end{remark} + +\subsection{A field of definition for homomorphisms} + +We now choose the fiber used in the arithmetic proof. Fix +$s\in\mathbf P^1(\Q)\setminus\mathcal C$, put $M=M_S(s)$ and +$T=S\cup\{q:q\mid M\}$, and choose $y$ above $s$. Let +$A=\mathcal A_y$ and choose the splitting field $K_0$ from +Lemma~\ref{hei:fiber-field}. Since $\pi$ is defined over $\Q$ and $s$ +is rational, $\pi({}^g y)=g(s)=s$ for every $g\in G_\Q$. +The common-base property of the family therefore makes the conjugates +of $A$ geometrically isogenous. +The descent argument needs all their homomorphisms over one Galois +field. We can define them without losing the bounded degree or +introducing ramification at further primes. + +\begin{lemma}\label{hei:hom-field} +There is a Galois extension $L/\Q$ containing $K_0$, of uniformly +bounded degree, over which all geometric homomorphisms between all +Galois conjugates of $A$ are defined. It is unramified outside $T$. +\end{lemma} + +\begin{proof} +There are boundedly many conjugates because they are defined over +$K_0$. Let $\mathcal H$ be the direct sum of the geometric Hom groups +indexed by all ordered pairs of these conjugates. This is a free +abelian group of bounded rank. Galois transport gives a natural +action of $G_\Q$ on $\mathcal H$, permuting the summands according to +its action on the ordered pairs. The action of $G_{K_0}$ on $\mathcal H$ has +finite image: a finite set of generators of the Hom groups is defined +over a finite extension. Finite subgroups of $\mathrm{GL}_r(\Z)$ +have bounded order for bounded $r$. Let $L$ be the fixed field of +the kernel of this action inside $G_{K_0}$. The transport action of +$G_\Q$, together with normality of $G_{K_0}$, makes that kernel normal +in $G_\Q$. +Thus $L/\Q$ is Galois and its degree is uniformly bounded. + +At a place outside $T$, the extension $K_0/\Q$ is unramified and all +the conjugates have good reduction. For a coefficient prime different +from the residue characteristic, inertia acts trivially on their Tate +modules and therefore on the Hom groups embedded faithfully between +those modules. Thus $L/K_0$ introduces no ramification there. +\end{proof} + +All homomorphisms between conjugates, including the prescribed +$B$-action, are now defined over $L$. Its degree is uniformly bounded, +and it is unramified outside $T$. Extending $K_0$ to $L$ preserves +good reduction of $A$ outside the fixed set $S$. We now bound +$h_{\mathrm F}(A)$ in terms of $M$, beginning with its endomorphism +algebra. + +\subsection{The endomorphism dichotomy and descent up to isogeny} +\label{hei:endomorphisms} + +The endomorphism algebra determines which comparison will give a +height bound for $A$. Put +$D=\operatorname{End}^0_{\overline\Q}(A)$, and let $C_B$ be the +centralizer of the prescribed left $B$-action in $D$. On rational +homology the centralizer of left $B$ is right $B$. A Hodge +endomorphism in that centralizer must commute, over $\mathbf R$, with +the complex structure, whose centralizer in $M_2(\mathbf R)$ is +$\mathbf C$. Thus $C_B$ is either $\Q$ or an imaginary quadratic +field $k$ contained in $B$. More explicitly, a nonscalar rational +element commuting with the complex structure generates such a +quadratic field, and its real centralizer has dimension two, leaving +no further possibilities. + +Both cases use the following quantitative isogeny theorem to transfer +a known height bound. If $C_1,C_2$ are $g$-dimensional abelian +varieties over a number field $k_0$ of degree $d$, and are isogenous +over an extension $K/k_0$, then there are $K$-isogenies in both +directions with degree at most +\begin{equation}\label{hei:gr} + \kappa(C_1)= + \left((14g)^{64g^2}d + \max\{h_{\mathrm F}(C_1),\log d,1\}^{2}\right)^{1024g^3}. +\end{equation} +This is \cite[Theorem 1.4, with the definition on p.~2058]{GaudronRemond2014}. +It uses the original stable Faltings height and requires neither +semistability over $k_0$ nor a principal polarization. In our +applications we take $K=k_0$. The stable height is additive on +products and satisfies +\begin{equation}\label{hei:isogeny-height} + h_{\mathrm F}(C_2)\le h_{\mathrm F}(C_1) + +\tfrac12\log\deg\phi + \quad\text{for an isogeny }\phi:C_1\longrightarrow C_2 +\end{equation} +\cite{Faltings1983}. We will always apply \eqref{hei:gr} to a source +whose height has already been bounded. + +If $C_B=k$, the central-simple-algebra double-centralizer calculation +gives +\[ + D=B\otimes_\Q k\simeq M_2(k). +\] +The last isomorphism holds because an embedded quadratic field is a +maximal subfield of $B$ and splits it. Matrix idempotents, all defined +over $L$ by Lemma~\ref{hei:hom-field}, give +$A\sim_L E^2$ for a CM elliptic curve $E/L$: take the image of an +integer multiple of a rank-one idempotent, and use the matrix units +to identify the two elliptic factors up to isogeny. The degree of +$j(E)$ is at most $[L:\Q]$, hence is bounded. Complex multiplication +theory identifies the degree of a singular modulus with the class +number of its imaginary quadratic order. Class-number growth for +imaginary quadratic fields and the formula for class numbers of +orders imply that only finitely many such $j$-invariants have bounded +degree \cite{Cox2013,Siegel1935}. Their stable elliptic heights, and +therefore $h_{\mathrm F}(E^2)$, are bounded. Apply \eqref{hei:gr} to +the source $E^2$, with dimension two, bounded height, and bounded +$[L:\Q]$, and then apply \eqref{hei:isogeny-height}. This bounds +$h_{\mathrm F}(A)$ uniformly. Lemma~\ref{hei:base-height} already +proves Theorem~\ref{hei:height} for these fibers, since $M\ge1$. +The finiteness invoked here need not be effective. + +We henceforth treat the other case, $C_B=\Q$. The same +double-centralizer calculation gives $D=B$. One can check this +calculation after an extension splitting $B$: an algebra containing +the full $2\times2$ matrix units is a matrix algebra over their +centralizer. Because $B$ is division, $A$ is absolutely simple; a +proper isogeny factor would give a nontrivial idempotent in $D$. + +Our goal in this case is to find a primitive weight-two newform $f$ +of level $N$, a Galois extension $L'/\Q$ containing $L$, and an +abelian variety $D_0/L'$ such that, for fixed constants $C,a>0$, +\[ + [L':\Q]\le CM,\qquad N\le CM^a,\qquad + J_1(N)\sim_{L'}A\times D_0. +\] +Once the height of this modular Jacobian has been bounded in terms +of $N$, the factorization will let us transfer the bound to $A$ over +a field of controlled degree. We first use the conjugacy isogenies +to construct a two-dimensional representation. Their discrepancy +under composition will be reduced to a sign and then split with +control on both the field degree and inertia. + +Compatible-isogeny cocycles and their scalar splittings are part of +the theory of $\Q$-curves and building blocks +\cite[Section~6]{Ribet1992}\cite[Chapters~4--5]{Pyle1995}; +compare \cite[Section~4]{Quer2001Fields}. +The scalar cochain constructed below takes values among roots of unity +of order $O(M)$, and its inertia restrictions will control the modular level. + +Put $\Gamma=\operatorname{Gal}(L/\Q)$. For each $g\in\Gamma$, choose +a quasi-isogeny $\mu_g:{}^gA\to A$, with $\mu_1=1$, satisfying +\begin{equation}\label{hei:blinear} + \mu_g\,{}^g\alpha=\alpha\mu_g\qquad(\alpha\in B). +\end{equation} +To obtain it, start with an isogeny between the fibers above the +common rational point. Transporting the $B$-action along this +isogeny gives an automorphism of $B=D$, which is inner by +Skolem--Noether. Composing with the corresponding element of +$B^\times$ gives \eqref{hei:blinear}. All these maps are defined +over $L$ by Lemma~\ref{hei:hom-field}. + +The maps $\mu_g\,{}^g\mu_h$ and $\mu_{gh}$ have the same source and +target and both intertwine the $B$-actions. Their quotient therefore +lies in the centralizer $\Q^\times$: +\[ + \mu_g\,{}^g\mu_h=c(g,h)\mu_{gh}, + \qquad c(g,h)\in\Q^\times. +\] +For a quasi-isogeny, use the degree obtained by extending the +geometric degree multiplicatively from isogenies. A rational scalar +$c$ on a surface has degree $c^4$, so the last identity gives +\[ + |c(g,h)|= + \left(\frac{\deg\mu_g\,\deg\mu_h}{\deg\mu_{gh}}\right)^{1/4}. +\] +Let $a_g=(\deg\mu_g)^{-1/4}$ be the positive real algebraic fourth +root. We extend the coefficient scalars in the isogeny category and +put +\[ + \widetilde\mu_g=a_g\mu_g + \in\operatorname{Hom}_L^0({}^gA,A)\otimes_\Q\overline\Q. +\] +Here Galois transports the Hom factor and acts trivially on the +coefficient factor $\overline\Q$. The preceding degree identity +now gives +\begin{equation}\label{hei:sign-cocycle} + \widetilde\mu_g\,{}^g\widetilde\mu_h + =\epsilon(g,h)\widetilde\mu_{gh}, + \qquad + \epsilon(g,h)=\frac{c(g,h)}{|c(g,h)|}\in\{\pm1\}. +\end{equation} +Associativity makes $\epsilon$ a normalized cocycle on $\Gamma$; +we inflate it to $G_\Q$. This is the obstruction in the isogeny +version of Weil descent. The normalized discrepancy depends only on +the sign of $c(g,h)$, so we will not need bounds for the individual +degrees $\deg\mu_g$. + +A scalar cochain with coboundary $\epsilon$ will cancel this sign. +On $G_L$ the inflated cocycle is trivial, so the restriction of such +a cochain will be a character. We seek one whose restricted character +is conjugacy invariant and has controlled order: its kernel will then +define a Galois field over which the corrected action agrees with the +Tate action of $A$. Control on inertia will also be needed to bound +the modular level. The following splitting supplies both properties. + +\begin{lemma}[Controlled splitting of the sign obstruction] +\label{hei:sign-splitting} +There is a finite Dirichlet character $\chi$ of order $m\le C M$, +unramified outside $T$, and a continuous cochain +$\beta:G_\Q\to\mu_{2m}$ such that +\begin{equation}\label{hei:beta} + \beta^2=\chi,\qquad + \frac{\beta(g)\beta(h)}{\beta(gh)}=\epsilon(g,h). +\end{equation} +The cochain can be chosen trivial on inertia at every prime outside +$T$. Its restriction to $G_L$ is a conjugacy-invariant character. +The local conductor of $\chi$ at any fixed prime is bounded +independently of $s$, and $\chi$ is tame at odd primes. +\end{lemma} + +\begin{proof} +Identify +$H^2(G_\Q,\{\pm1\})=\operatorname{Br}(\Q)[2]$. At a prime +outside $T$, the cocycle factors through the unramified quotient +$\widehat\Z$, which has cohomological dimension one on torsion +coefficients. Its local class is therefore zero. We use local +reciprocity and the Brauer local-global theorem in the form described +in \cite{Serre1979,MilneCFT2020,MilneEtale2013}. + +For a finite character $\chi_v$ with values in +$\overline\Q^{\,\times}$ with trivial coefficient action, its +square-root obstruction $\partial\chi_v$ in +$H^2(G_{\Q_v},\{\pm1\})$ vanishes if and only if $\chi_v$ has a +continuous character square root. By reciprocity this is equivalent +to its being trivial on the order-two subgroup of $\Q_v^\times$, +that is, on $-1$. To verify the equivalence, use +$\Z_p^\times\simeq\mu_{p-1}\times\Z_p$ for odd $p$, and +$\Z_2^\times\simeq\{\pm1\}\times\Z_2$ at $2$. A character of the +infinite cyclic valuation factor has a square root by choosing a +square root of its value on a uniformizer; the procyclic free factors +also admit character square roots. The only obstruction in the +finite cyclic torsion factors is the value on their element of order +two. At the real place the same assertion follows directly from +$G_{\mathbf R}=\Z/2\Z$. + +At each odd finite prime with nonzero local class of $\epsilon$, +choose an odd character modulo that prime, so its value at $-1$ is +$-1$. At $2$, if necessary, use the nontrivial character modulo +$4$. Their product is a global Dirichlet character $\chi$. Its +local square-root obstruction matches that of $\epsilon$ at every +finite place. The real invariant matches too, because the sum of +local invariants of a Brauer class is zero. Injectivity in the +Brauer local-global theorem gives $\partial\chi=[\epsilon]$. + +Each odd-prime factor has order at most $q-1$, and the factor at $2$ +has order two. Thus the order $m$ of their product satisfies +\[ + m\le 2\prod_{q\in T,\ q\ne2}(q-1)\le C M. +\] +The conductor at an odd prime divides that prime, and the conductor +at $2$ divides $4$. Factors at other primes are unramified locally; +this proves the stated local conductor assertions. + +Choose a continuous set-theoretic square root of $\chi$, valued in +$\mu_{2m}$. Equality of the obstruction classes allows its +coboundary to be corrected to exactly $\epsilon$ by a sign-valued +continuous cochain. The resulting $\beta$ satisfies +\eqref{hei:beta}. On $G_L$ the inflated cocycle is identically one, +so $\beta$ restricts to a character. Its conjugacy invariance follows +from the cochain identity: if $u\in G_L$ and $g\in G_\Q$, then +$\epsilon(g,u)=\epsilon(gug^{-1},g)=1$, and comparison of +$\beta(gu)$ computed in these two ways gives +$\beta(gug^{-1})=\beta(u)$. + +At an odd prime outside $T$, inertia fixes $L$, and $\chi$ is +unramified, so the restriction of $\beta$ to inertia is a sign +character. Only finitely many such restrictions are nontrivial, +because a continuous function to the finite set $\mu_{2m}$ factors +through a finite quotient of $G_\Q$. At an odd prime there is a +unique nontrivial quadratic character of inertia: wild inertia is +pro-odd and the tame quotient has a unique quotient of order two. +Let $d_\beta$ be a squarefree integer whose odd prime factors are +precisely these offending primes. Multiplication of $\beta$ by the +quadratic character of $\Q(\sqrt{d_\beta})$ cancels all the unwanted +inertia characters. This quadratic character is unramified away +from those primes and possibly $2\in S$. Its square is one and its +coboundary is one, so \eqref{hei:beta} and the restriction properties +are preserved. Since $\{\pm1\}\subset\mu_{2m}$, the corrected cochain +still takes values in $\mu_{2m}$, whose elements have orders dividing +$2m\le CM$. +\end{proof} + +\subsection{Two-dimensional representations and modularity} +\label{hei:modularity} + +We construct representations at coefficient primes $2$ and $3$. +The $2$-adic one will yield a modular form. The $3$-adic one will +measure the conductor at $2$, where the conductor comparison requires +a coefficient prime different from the residue prime. This requires +identifying both representations with the same newform. + +Fix coefficient embeddings $\overline\Q\hookrightarrow +\overline\Q_\ell$ for $\ell=2,3$. On the covariant rational Tate +module of $A$ with these extended coefficients put +\begin{equation}\label{hei:representation} + R_\ell(g)=\beta(g)\widetilde\mu_{\bar g}\circ g, + \qquad g\in G_\Q,\quad \bar g=g|_L. +\end{equation} +Here $g$ first transports torsion points to \({}^gA\), and the +quasi-isogeny returns them to $A$. In a composition the discrepancy +of the maps is $\epsilon(g,h)$, and the discrepancy of the scalar +cochain is the same sign. Their product is one. Thus $R_\ell$ is +a genuine continuous representation. All algebraic coefficients +and the splitting of $B$ can be taken in one finite extension of +$\Q_\ell$ for each $\ell$. + +Equation \eqref{hei:blinear} shows that $R_\ell$ commutes with $B$. +After coefficient extension, $B\otimes\overline\Q_\ell\simeq +M_2(\overline\Q_\ell)$; the matrix units then give +\begin{equation}\label{hei:double-copy} + R_\ell\simeq r_\ell\oplus r_\ell +\end{equation} +for a two-dimensional representation $r_\ell$. On $G_L$ the +quasi-isogeny in \eqref{hei:representation} is +$\widetilde\mu_1=1$, so only the character $\beta|_{G_L}$ separates +$R_\ell$ from the Tate action of $A$. Define +\[ + G_{L'}=\ker(\beta|_{G_L}). +\] +Conjugacy invariance of this character makes $L'/\Q$ Galois, and its +image has order at most $2m$. Consequently +\begin{equation}\label{hei:lprime-degree} + [L':\Q]\le 2m[L:\Q]\le C M. +\end{equation} +On $G_{L'}$, the representation $R_\ell$ is exactly the Tate-module +representation of $A$, with coefficients extended. This field will +allow us to recover an abelian factor over $L'$. Its degree may grow +with $M$; the local conductor argument will use $L$, whose degree is +uniformly bounded. + +\begin{samepage} +The modularity input is \cite[Theorem 1.1]{OddRegularFontaineMazurAtTwo} +in its exact form: every continuous irreducible odd two-dimensional +$2$-adic representation of $G_\Q$, unramified outside finitely many +primes and de Rham at $2$ with distinct Hodge--Tate weights, is a Tate +twist of the representation associated with a classical cuspidal +eigenform. There is no residual-image hypothesis in that statement. +We now verify its hypotheses for $r_2$. The same arguments also give +the properties of $r_3$ used below. The commutant and +Hodge-decomposition arguments have antecedents in +\cite[Section~3]{Ribet1992}; we apply them to the corrected action +\eqref{hei:representation}. +\end{samepage} + +By Faltings' semisimplicity and endomorphism theorems, +\[ + \operatorname{End}_{G_{L'}}(V_\ell(A)) + =\operatorname{End}_{L'}(A)\otimes\Q_\ell + =B\otimes\Q_\ell +\] +\cite{Faltings1983}. Therefore $r_\ell|_{G_{L'}}$ is semisimple +with scalar commutant after algebraic coefficient extension, and is +absolutely irreducible. So is $r_\ell$. + +The de Rham comparison theorem for smooth proper varieties, together +with its Hodge--Tate decomposition, applies to $A$ over every +completion of $L'$ at its coefficient prime +\cite[Corollary~1.8]{Scholze2013DeRham}; see also the corrected +definitions in \cite{Scholze2016DeRhamCorrigendum}. +Since the covariant Tate module is dual to first \'etale cohomology, +$V_\ell(A)$ is de Rham with cyclotomic exponents $0,1$, each twice. +The de Rham property descends through finite local extensions +\cite[Section~3.9(ii)]{Fontaine1994}. +Thus $R_\ell$ is de Rham over $\Q_\ell$, and its decomposition +\eqref{hei:double-copy} gives exponents $0,1$, each once, for $r_\ell$. +Here the cyclotomic character has exponent $1$ and Hodge--Tate +weight $-1$. + +For complex conjugation $j$, the involution $r_\ell(j)$ cannot be +scalar. If it were, \eqref{hei:double-copy} would make $R_\ell(j)$ +scalar too. Under comparison with Betti homology, +$\mu_{\bar j}\circ j$ is conjugation followed by a holomorphic +quasi-isogeny. It exchanges the two nonzero Hodge subspaces, whereas +a scalar preserves both. Multiplying by the nonzero algebraic +coefficient in \eqref{hei:representation} does not change this +fact. Hence the two eigenvalues of $r_\ell(j)$ are $1$ and $-1$, +and $r_\ell$ is odd. + +At a prime outside $T\cup\{\ell\}$, inertia fixes $L$, $A$ has +good reduction, and the corrected $\beta$ is trivial. Thus $r_\ell$ +is unramified there. In particular it is ramified at only finitely +many primes. All hypotheses of the stated modularity theorem now +hold for $r_2$. Applying it realizes $r_2$ as a Tate twist of the +representation associated with a classical cuspidal eigenform. + +We use the arithmetic-Frobenius normalization in which a weight-$k$ +form $f$ has good traces $a_q(f)$ and determinant +$\psi_f\chi_{\mathrm{cyc}}^{k-1}$. Its cyclotomic exponents are +$0,k-1$; the companion fixes this convention in +\cite[Section~2.1]{OddRegularFontaineMazurAtTwo}. The two exponents +$0,1$ of $r_2$ therefore force weight two and Tate shift zero. Thus +$r_2$ is realized by the arithmetic $2$-adic representation of a +normalized primitive weight-two newform. + +For comparison with a dual presentation, if an intermediate realization is written as +$V_{f,2}^{\vee}\otimes\chi_{\mathrm{cyc}}^n$, then +\[ + V_{f,2}^{\vee}\otimes\chi_{\mathrm{cyc}}^n + \simeq V_{g,2}\otimes\chi_{\mathrm{cyc}}^{n+1-k}, + \qquad g=(f\otimes\psi_f^{-1})_{\mathrm{new}}. +\] +Here $g$ is the primitive newform of the indicated finite-character +twist. The target exponents $0,1$ give $k=2$, $n=1$ in this +presentation, and hence arithmetic Tate exponent zero. Changing +from arithmetic to geometric Frobenius inverts the evaluated +eigenvalues; it does not dualize the representation. After this +conversion when necessary, let $f$ denote the normalized primitive +newform whose arithmetic $2$-adic representation realizes $r_2$, +and let $N$ be its level. + +To use $r_3$ for the dyadic conductor of this level, we must identify +it with the same algebraic conjugate of $f$. A single algebraic +trace, obtained from the good special fiber, will compare the two +coefficient primes. + +\begin{lemma}\label{hei:compatibility} +The representation $r_3$ is the $3$-adic representation of the same +algebraic conjugate of $f$ that realizes $r_2$. +\end{lemma} + +\begin{proof} +Fix a rational prime $q\notin T\cup\{2,3\}$ with $q\nmid N$, +a place of $\overline\Q$ above $q$, and an arithmetic Frobenius +$g$ in that decomposition group. These primes form a cofinite set, +as needed for the Chebotarev argument below. The automorphism induced +by $g$ on the residue field $\overline{\mathbf F}_q$ is $x\mapsto x^q$. +Therefore the reduction of +\({}^gA\) is the Frobenius twist $\widetilde A^{(q)}$ of the same +geometric special fiber $\widetilde A$. Specialization of +prime-to-$q$ torsion identifies the action of $g$ with the relative +Frobenius map $\widetilde A\to\widetilde A^{(q)}$. A multiple of +$\mu_{\bar g}$ extends over good reduction, and its reduction, after +dividing by that integer, maps $\widetilde A^{(q)}$ back to +$\widetilde A$. The composite is thus an element +\[ + u_q=\operatorname{red}(\mu_{\bar g})\circ + \operatorname{Frob}^{\mathrm{rel}}_q + \in\operatorname{End}^0(\widetilde A). +\] +Here $\operatorname{red}(\mu_{\bar g})$ is reduction of the +unnormalized quasi-isogeny; the scalar $a_{\bar g}$ from degree +normalization is inserted below. + +The characteristic polynomial of an endomorphism of an abelian +variety on rational Tate modules has rational coefficients and is +independent of the coefficient prime. This applies to a rational +endomorphism after clearing denominators +\cite[I, Theorem 10.9 and Proposition 10.20]{MilneAV2008}. +Consequently +\[ + \alpha_q=\frac12\beta(g)a_{\bar g}\operatorname{Tr}(u_q) + \in\overline\Q +\] +is a single algebraic number whose images at $2$ and $3$ are the +traces of $r_2(g)$ and $r_3(g)$, respectively. The factor $1/2$ +comes from \eqref{hei:double-copy}. This construction is independent +of any comparison of coefficient-field degrees. + +The identification of $r_2$ with the representation of $f$ selects +an embedding of its Hecke field in $\overline\Q$. Injectivity of +the fixed embedding $\overline\Q\hookrightarrow\overline\Q_2$ +then gives $\alpha_q=a_q(f)$ as algebraic numbers at every good +prime. Under the chosen embedding at $3$, the same equalities +hold. Chebotarev density and the character criterion for semisimple +representations \cite[IV, Theorem~3.3 and Lemma~3.9]{MilneAV2008} +identify $r_3$ with that member of the compatible system of $f$ +\cite{Deligne1971Modular}. Semisimplicity on our side follows already +from irreducibility. +\end{proof} + +\subsection{A uniform bound for the modular level} + +\begin{lemma}\label{hei:level-bound} +There are fixed constants $C,a>0$ such that +\begin{equation}\label{hei:level} + N\le C M^a. +\end{equation} +\end{lemma} + +\begin{proof} +For a primitive weight-two form, the local newform conductor is +the exponent of $q$ in its primitive level. Local--global +compatibility, with conductor preservation under the local +correspondence, identifies this with the Artin-conductor exponent +of its $\ell$-adic representation whenever $q\ne\ell$ +\cite[Theorem~A in Section~0.7, with the normalization in Section~0.5]{Carayol1986}. +The conductor includes the Weil--Deligne monodromy contribution. +We use $r_2$ at all primes other than $2$, and $r_3$ at $2$, +justified by Lemma~\ref{hei:compatibility}. The exponent is zero at +$q\notin T$ by the unramified assertion above. + +First let $q\in T$ be larger than a fixed constant that includes all +primes in $S$, the primes $2,3$, and the uniform upper bound for +$[L:\Q]$. Wild inertia, a pro-$q$ group, acts trivially on $L$. +The surface has good reduction over $L$ at this prime, so wild +inertia also acts trivially on its prime-to-$q$ Tate modules. On +this subgroup $\beta$ is a character, and its square is the tame +character $\chi$. Hence its wild restriction is sign-valued and +must be trivial, as $q$ is odd. Formula \eqref{hei:representation} +makes $R_\ell$ tame at $q$, and hence $r_\ell$ is tame there as well. +Its dimension is two, so its +conductor exponent is at most two. + +It remains to bound the exponents at the fixed finite set of smaller +primes. Fix one of them, say $q$, a place $v$ of $L$ above it, and +put $F=L_v$. Let $\ell\ne q$ be the coefficient prime chosen above. +Only finitely many embedded extensions $F/\Q_q$ can occur, because +their degrees are bounded. We seek a bound $u_q$, independent of +$s$, such that for every $u>u_q$ the upper ramification group +$G_{\Q_q}^u$ lies in $G_F$, is killed by the character +$\beta|_{G_F}$, and acts trivially on $V_\ell(A)$. On such a group +$g|_L=1$, so the quasi-isogeny in $R_\ell(g)$ is also the identity. +We obtain this bound by controlling the character and the Tate action +over the finitely many possible fields $F$. + +First consider the character. By local reciprocity, the square of +$\beta|_{G_F}$ corresponds to +$\chi\circ\operatorname{Norm}_{F/\Q_q}$. Although the global order +of $\chi$ may grow with $M$, its conductor on $\Q_q$-units is +uniformly bounded: of the constructed Dirichlet factors only the +factor at $q$ ramifies there. Choose an integer $b$ large enough, +uniformly over the finitely many possibilities for $F$, that this +square character is trivial on $U_F^b=1+\mathfrak m_F^b$ and that +the local logarithm identifies $U_F^b$ with $\mathfrak m_F^b$. +Then $\beta(U_F^b)\subset\{\pm1\}$. For odd $q$, squaring maps +$U_F^b$ onto itself, and therefore $\beta$ kills $U_F^b$. For +$q=2$, writing $e_F=v_F(2)$ gives +\[ + (U_F^b)^2=U_F^{b+e_F} +\] +in these logarithmic coordinates. Thus $\beta$ kills a uniformly +deeper unit group also at $2$. Reciprocity gives a uniform upper +ramification cut for this character. The quadratic correction in +Lemma~\ref{hei:sign-splitting} does not affect the argument, because +it leaves $\beta^2=\chi$ unchanged. An arbitrarily large unramified +character order has no effect on a unit-filtration bound. + +Next consider the Tate action. Choose a fixed prime $p_0\ge3$, +different from $q$, and put +\[ + F_1=F(A[p_0]). +\] +Its degree satisfies $[F_1:F]\le|\mathrm{GL}_4(\F_{p_0})|$. +The semistable reduction criterion says that inertia is unipotent +over $F_1$ \cite[Theorem 3.5]{SilverbergZarhin1995}. Its wild +pro-$q$ subgroup has trivial action on $V_\ell(A)$, since a compact +unipotent subgroup of $\mathrm{GL}_4(\Q_\ell)$ has no nontrivial +pro-$q$ subgroup when $\ell\ne q$. Since both $[F:\Q_q]$ and +$[F_1:F]$ are bounded, the fields $F_1$ and their normal closures +over $\Q_q$ also range over finite sets. + +Choose an upper ramification cut over $\Q_q$ exceeding the breaks +of all these finite field extensions and whose images under the +finitely many relevant Herbrand inverse functions exceed the cuts +for $\beta|_{G_F}$. The subgroup and quotient rules for upper +ramification groups then place every sufficiently high +$G_{\Q_q}^u$ inside $G_F$, in the kernel of $\beta|_{G_F}$, and in +the wild Tate-module kernel over $F_1$ \cite{Serre1979}. On this +group $\widetilde\mu_{\bar g}=\widetilde\mu_1=1$, so +\eqref{hei:representation} makes $R_\ell$ trivial there. Its +decomposition \eqref{hei:double-copy} then makes $r_\ell$ trivial +there as well. We have therefore obtained the required uniform +upper cut $u_q$ for $r_\ell$, independent of $s$. Its Swan conductor +is at most $2u_q$. The remaining contribution from inertia +invariants, including Weil--Deligne monodromy, is at most two because +$r_\ell$ has dimension two. This bounds its full conductor exponent +at the fixed prime. + +The finitely many fixed primes contribute a constant to $N$. Every +remaining ramified prime divides $M$ and has exponent at most two, +so their product contributes at most $M^2$. This proves +\eqref{hei:level}, and the proof allows $a=2$ after altering the fixed +constant. The uniform local bounds use the bounded degree of $L$; +\eqref{hei:lprime-degree} supplies the degree of the field $L'$ for +the global isogeny estimate. +\end{proof} + +\subsection{The modular factor and the final height bound} +\label{hei:final-height} + +For elliptic curves over \(\mathbb Q\), Murty and Pasten earlier +obtained an effective \(O(N\log N)\) bound for Faltings height in +terms of the conductor, with applications to \(S\)-unit equations +\cite[Theorems~1.1 and~7.1]{MurtyPasten2013}. The abelian-variety +comparison used in this final step follows the modular height +strategy of von K\"anel \cite[Sections~1.2 and~5]{vonKaenel2021}; +see also \cite{Alpoge2021}. +The preceding descent and ramification arguments provide the +point-dependent fields and the level bound needed to apply that strategy +here. + +Let $J=J_1(N)$. The weight-two Eichler--Shimura realization places +$r_2$ in $V_2(J)\otimes\overline\Q_2$ +\cite[Theorem~2.1 and the following weight-two realization]{Ribet1977Nebentypus}. +We will turn this shared constituent into a nonzero homomorphism +$A\to J$ over $L'$. The next argument descends a Hom from the +extended coefficient field to $\Q_2$, giving the abelian factor over +$L'$ itself. + +\begin{lemma}\label{hei:modular-factor} +There is an abelian variety $D_0/L'$ such that +\[ + J\sim_{L'}A\times D_0. +\] +\end{lemma} + +\begin{proof} +Put $V=V_2(A)$, $W=V_2(J)$, and $H=G_{L'}$. After extending +coefficients, $V$ is two copies of $r_2|_H$, while $W$ contains at +least one copy. Hence +$\operatorname{Hom}_H(V\otimes\overline\Q_2, +W\otimes\overline\Q_2)\ne0$. Invariants commute with coefficient +extension in this situation. Indeed, in the finite-dimensional +space $\operatorname{Hom}_{\Q_2}(V,W)$ they are the intersection of +the kernels of the linear equations expressing commutation with +each $h\in H$. Finitely many of these equations cut out that same +intersection, by stabilization of dimensions. Kernels of this +finite system commute with scalar extension. Thus +\[ + \operatorname{Hom}_H(V,W)\otimes\overline\Q_2 + =\operatorname{Hom}_H(V\otimes\overline\Q_2, + W\otimes\overline\Q_2)\ne0. +\] +Faltings' homomorphism theorem identifies +$\operatorname{Hom}_H(V,W)$ with +$\operatorname{Hom}_{L'}(A,J)\otimes\Q_2$, so an actual nonzero +$L'$-homomorphism $A\to J$ exists. Absolute simplicity makes its +kernel finite. Poincare complete reducibility over $L'$ then gives +the claimed factor \cite{Faltings1983,Mumford1970}. A single shared +constituent was sufficient to produce the Hom; the resulting rational +Tate-module injection automatically supplies its full required +multiplicity. In particular $\dim J\ge2$. +\end{proof} + +The controlled field, level, and factorization sought in the non-CM +case are now established. We turn to the height of the modular +Jacobian. Write $g_0=\dim J$. The modular group index bounds the +degree of the map $j:X_1(N)\to\mathbf P^1$ by $C N^2$. It is +branched only over $0,1728,\infty$, so after rescaling the target it +is a Belyi map. Riemann--Hurwitz, or the usual genus formula, also +gives $g_0\le C N^2$. Javanpeykar's theorem +\cite[Theorem 1.1.1 and Section 2.3]{Javanpeykar2014} for a smooth +projective connected curve $X$ of genus $g\ge1$ bounds its Jacobian's +stable height in his convention by +\[ + 13\cdot10^6 g\,\deg_B(X)^5. +\] +Javanpeykar's height here equals the original stable Faltings +height of the Jacobian used in \eqref{hei:gr}. The addition of +$(g/2)\log\pi$ in \cite[Lemma 2.4.4]{Javanpeykar2014} converts +instead to the Deligne normalization $h_{\mathrm F}^{\mathrm D}$ +of \cite[Section 2.3]{GaudronRemondPeriods2014}. +Thus no normalization correction is needed here; in either +convention the difference is only $O(g)$. +Since Lemma~\ref{hei:modular-factor} ensures $g_0\ge2$, +the genus hypothesis applies. We obtain +\begin{equation}\label{hei:jacobian-height} + g_0\le C N^2, + \qquad \max\{0,h_{\mathrm F}(J)\}\le C N^{12}. +\end{equation} + +For the final comparison we choose a principally polarized complement. +An abelian variety over a number field has a polarization defined over +that field and is consequently isogenous there to its dual. When +$D_0\ne0$, choose such a polarization over $L'$. Applying Zarhin's +trick to it gives a principal polarization over $L'$ on +\[ + D_Z=(D_0\times D_0^\vee)^4 +\] +\cite[Theorem~1.1(ii) and Remark~1.4]{Zarhin2023Quaternion}; see also +\cite[proof of Corollary~3.2]{Bost1996Bourbaki}. If $D_0=0$, omit +this factor and take all its height and dimension contributions below +to be zero. In either case this choice of complement gives +\[ + C_1=J^8\sim_{L'} C_2=A^8\times D_Z. +\] +Both sides have dimension $g=8g_0$. Their common field has degree +$d=[L':\Q]\le C M$, and the source has known stable height +$h_{\mathrm F}(C_1)=8h_{\mathrm F}(J)$. From +\eqref{hei:level} and \eqref{hei:jacobian-height}, +\[ + g\le C M^{2a},\qquad + \max\{0,h_{\mathrm F}(C_1)\}\le C M^{12a}. +\] +Applying \eqref{hei:gr} to this source gives an isogeny +$\phi:C_1\to C_2$ whose logarithmic degree is at most +\begin{align} + \log\deg\phi + &\le1024g^3\bigl(64g^2\log(14g)+\log d + +2\log\max\{h_{\mathrm F}(C_1),\log d,1\}\bigr) + \label{hei:log-isogeny}\\ + &\le C M^C.\nonumber +\end{align} +The last inequality follows by substituting the preceding bounds: +every power of $g$ is a fixed power of $M$, while the remaining +logarithms are bounded by $C(1+\log M)\le C'M$ for $M\ge1$. +This is the point at which the explicit dependence on dimension in +the isogeny theorem is needed. The theorem is applied with source +$J^8$, whose height is already bounded. + +By additivity and \eqref{hei:isogeny-height}, +\[ + 8h_{\mathrm F}(A)+h_{\mathrm F}(D_Z) + \le h_{\mathrm F}(C_1)+\tfrac12\log\deg\phi + \le C M^C. +\] +Bost's lower bound applies to every abelian variety over a number field. +For the complement $D_Z$ chosen above, the form in +\cite[Corollary~8.4]{GaudronRemondPeriods2014} gives +\[ + h_{\mathrm F}^{\mathrm D}(D_Z)\ge + -\tfrac12(\dim D_Z)\log(2\pi). +\] +The normalization identity +$h_{\mathrm F}^{\mathrm D}=h_{\mathrm F} ++\tfrac12(\dim D_Z)\log\pi$ +therefore yields +\[ + h_{\mathrm F}(D_Z)\ge + -\tfrac12(\dim D_Z)\log(2\pi^2). +\] +Since $\dim D_Z\le g\le C M^{2a}$, it follows that +\begin{equation}\label{hei:faltings-final} + h_{\mathrm F}(A)\le C M^C. +\end{equation} +Neither a degree bound for the original $\mu_g$ nor a bound for the +degree of a field of coefficients has entered this estimate. + +\begin{proof}[Completion of the proof of Theorem~\ref{hei:height}] +For the arbitrary point $s$ fixed above, let $A=\mathcal A_y$ be the +chosen fiber. The CM case gave a uniform +upper bound for $h_{\mathrm F}(A)$; the other case gave +\eqref{hei:faltings-final}. Applying Lemma~\ref{hei:base-height} +gives $\hgt(s)\le H M_S(s)^c$ after enlarging fixed constants $H,c$. +All curves, levels, theta data, exceptional primes, and comparison +constants were fixed independently of $s$. This proves the +theorem. Since $M_S(s)\ge1$, the exponent $c$ may, if desired, +be increased to a positive integer. +\end{proof} + +\begin{remark}[Related height bounds] +Let \(U\) be a nonempty open subscheme of +\(\operatorname{Spec}\mathcal O_K\) for a number field \(K\). +For fixed relative dimension and \([K:\Q]\), related work bounds +stable Faltings height polynomially in the radical of the product +of the absolute discriminant of \(K\) and the norms of the prime +ideals outside \(U\). +Von K\"anel proves such a bound for abelian schemes over \(U\) whose geometric +generic fiber is simple, non-CM, and \(\Q\)-virtual of +\(\mathrm{GL}_2\)-type, with conjugate isogenies compatible with all +geometric endomorphisms +\cite[Proposition~9.9]{vonKaenel2013Preprint}. +Von K\"anel and Kret treat the product-\(\mathrm{GL}_2\)-type class +with \(G_\Q\)-isogenies and also abelian schemes with geometric CM +\cite[Theorem~7.1]{vonKaenelKret2023}. +\end{remark} diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/05-elliptic.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/05-elliptic.tex new file mode 100644 index 0000000000000000000000000000000000000000..b0ce354f369a1c7572b163788b6611d65a3727a7 --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/05-elliptic.tex @@ -0,0 +1,189 @@ +\section{The rank-one elliptic group and its local parameters} +\label{ell:section} + +We prove Propositions~\ref{ell:rank} and~\ref{ell:formal}, the two elliptic +inputs used in Section~\ref{red:local-comparison-section}. Recall the fixed +data of \eqref{ell:data}: +\[ + F=\Q(\sqrt2),\qquad d=75-53\sqrt2,\qquad + E:\ y^2=x^3-d^2x, +\] +with \(\sigma\) the nontrivial automorphism of \(F/\Q\). The algebraic integer \(d\) +is positive at both real embeddings and has norm \(7\). In particular, +\(\mathfrak d=(d)\) is a prime ideal with residue field \(\F_7\). + +In Section~\ref{pri:section}, we will choose split primes of good reduction +for $E$ and its conjugate $E^\sigma$ at which $7$ is a nonsquare. The identity +$dd^\sigma=7$ then makes their reductions quadratic twists with opposite +Frobenius traces. + +\begin{proof}[Proof of Proposition~\ref{ell:rank}] +The ring of integers is $\mathcal O_F=\Z[\sqrt2]$. Minkowski's bound is +$\sqrt8/2=\sqrt2<2$, so every ideal class contains an ideal of norm one. +Thus $\mathcal O_F$ is a principal ideal domain. The unit theorem gives +$|\mathcal O_F^*/\mathcal O_F^{*2}|=4$. The units $-1$ and $1+\sqrt2$ +realize all four sign patterns at the real embeddings, so a totally +positive unit is a square. + +Consider the two-isogenous curve +\[ + E':\ y^2=x^3+4d^2x. +\] +We use the usual two-isogeny descent, with isogenies +$\varphi:E\to E'$ and $\widehat\varphi:E'\to E$ whose composite is $[2]$; +see \cite[Chapter~X, Proposition~4.7 and Example~4.9, pp.~336--337]{Silverman2009}. Its homomorphisms +\[ + \alpha:E(F)\longrightarrow F^*/F^{*2},\qquad + \alpha':E'(F)\longrightarrow F^*/F^{*2} +\] +send a point with nonzero $x$ to the class of $x$, send the origin to $1$, +and send $(0,0)$ to the class of the linear coefficient in the equation. +Their kernels are $\widehat\varphi E'(F)$ and $\varphi E(F)$, respectively. +In the present case +\begin{equation}\label{ell:isogeny-index} + |\operatorname{im}\alpha|\, + |\operatorname{im}\alpha'|=4\,2^{\rank E(F)}. +\end{equation} +For completeness, $E$ has full rational two-torsion, and either point +$(\pm d,0)$ maps under $\varphi$ to the nonidentity point of +$\ker\widehat\varphi$. Hence the kernel of +$E'(F)/\varphi E(F)\to \widehat\varphi E'(F)/2E(F)$ is trivial. Taking +indices in $2E(F)\subset\widehat\varphi E'(F)\subset E(F)$ gives the left +side of \eqref{ell:isogeny-index} as $|E(F)/2E(F)|$, which is +$2^{\rank E(F)+2}$ by the Mordell--Weil Theorem. + +If the linear coefficient of an equation $y^2=x^3+cx$ is a unit at a +finite place, then a nonzero $x$ has even valuation there. Indeed, when +$v(x)<0$ the term $x^3$ has strictly smaller valuation than $cx$, while +when $v(x)>0$ the term $cx$ has strictly smaller valuation; an odd +$v(x)$ would give an odd valuation of $y^2$ in either case. Applied to +$E$, this shows that every class in $\operatorname{im}\alpha$ is supported, +apart from its unit class, only at $\mathfrak d$. The class number +calculation therefore bounds the image by $4\cdot2=8$. The torsion +points already give the four distinct classes +\[ + 1,-1,d,-d. +\] +Let $w=-5+4\sqrt2=d(1+\sqrt2)^3$. Direct calculation gives +$w^3-w=-8d$, and consequently +\[ + Q=(-dw,\,2\sqrt2\,d^2)\in E(F). +\] +The element $-dw$ has opposite signs at the two real embeddings, whereas +the four torsion classes have equal signs at both embeddings. Thus +$\alpha(Q)$ is outside those four classes, proving +$|\operatorname{im}\alpha|=8$. + +We next prove $\operatorname{im}\alpha'=\{1\}$. At both real embeddings, +$x^3+4d^2x$ has the sign of $x$, so every nonzero $x$ on $E'$ is totally +positive. The unit-coefficient argument excludes odd valuations away +from the prime above $2$ and $\mathfrak d$. Normalize the valuation at +the prime above $2$ to have value group $\Z$. Then $v(4d^2)=4$. If +$v(x)$ were odd, the valuations $3v(x)$ and $4+v(x)$ would be unequal and +their minimum would be odd, again impossible for $y^2$. +At $\mathfrak d$ the coefficient has valuation $2$. An odd $v(x)$ is +impossible unless $v(x)=1$, by the same comparison. In that remaining +case write $x=du$ with $u$ a local unit. The equation becomes +\[ + y^2=d^3u(u^2+4). +\] +An even valuation would require $u^2+4\equiv0\pmod{\mathfrak d}$. +But $-4=3$ is not a square in $\F_7$. Thus all finite valuations of $x$ +are even. Since $\mathcal O_F$ is principal, $x$ is a square times a +unit; total positivity makes that unit a square. The exceptional point +$(0,0)$ also gives the trivial class $4d^2$, and the origin does likewise. +This proves the assertion about $\alpha'$. Equation +\eqref{ell:isogeny-index} now gives $\rank E(F)=1$. + +Finally, choose $m$ divisible by the exponent of the finite torsion +subgroup of $E(F)$. The finitely generated group $mE(F)$ is torsion-free +of rank one and therefore has a generator $P$ as claimed. +\end{proof} + +Recall the parameter \(z=-x/y\), with \(z(O)=0\), and the formal +logarithm and its degree-\(K\) truncation +\[ + \ell(Z)=Z+\sum_{t\ge2}c_tZ^t,\qquad + \ell_K(Z)=Z+\sum_{2\le t\le K}c_tZ^t. +\] + +Reading multiplication indices from elliptic coordinates has a +precedent in Poonen's rank-one Diophantine construction. His +Lemma~9 reads divisibility of indices from denominators of elliptic +multiples, and Lemma~11 uses the formal group to approximate an +integer square by a quotient of coordinates +\cite{PoonenRankOne2002}. Proposition~\ref{ell:formal} uses a +truncated formal logarithm to approximate a quotient of indices. +The paired local tests in the reduction use this comparison together with the +conjugate curve. + +The effective computation of the truncations in Section~\ref{red:local-comparison-section} can be made explicit. With $w=-1/y$ one has +\[ + x=z/w,\qquad w=z^3-d^2zw^2. +\] +Successively solving this identity determines $w$ as a formal power +series in $z$; substitution in $dx/(2y)$ and termwise integration +determines $\ell$. The formal group and its invariant differential have +integral coefficients at every place of good integral reduction +\cite[Chapter IV]{Silverman2009}. + +\begin{proof}[Proof of Proposition~\ref{ell:formal}] +Include $2$, the primes of bad reduction of either equation, and the +ramified primes of $F/\Q$ in $S_E$. Let $p\notin S_E$, let $v$ be a +place above $p$ normalized by $v(p)=1$, and let $n,n'\in\Z$, with +$n'\ne0$ and both $nP,n'P$ reducing to $O$, as in the proposition. +At this allowed place $F_v/\Q_p$ is +unramified, so its normalized value group is $\Z$. The kernel of +reduction is the formal group on the maximal ideal. For a finite point +on this integral good model, membership in that kernel is equivalent to +$v(x)<0$; its parameter then has $v(z)>0$. + +Write the invariant differential as +$(1+\sum_{j\ge1}a_jZ^j)dZ$, with $a_j$ integral at $v$. Thus +$v(c_t)\ge-v_p(t)$. If $v(Z)\ge1$, the term of degree $t\ge2$ in the +logarithm has valuation at least $t\,v(Z)-v_p(t)>v(Z)$ for $p>2$, and +these valuations tend to infinity. The logarithm consequently converges +on the entire formal kernel, is a homomorphism there, and satisfies +\[ + v(\ell(Z))=v(Z). +\] +These are also the standard formal-logarithm assertions of +\cite[Chapter IV, \S6]{Silverman2009}; the displayed coefficient bound +specifies the uniformity we require. + +Set $U=nP$ and $V=n'P$. The identity $[n']U=[n]V$, entirely within +the formal kernel, gives $n'\ell(z(U))=n\ell(z(V))$. +The point $V$ is nonzero, hence $\ell(z(V))\ne0$. Valuation preservation +proves \eqref{ell:ratio}, including $U=O$. + +Now fix $K\ge1$ and suppose $p>K+1$ and $v_p(n/n')\ge0$. For every $t>K$, +\begin{equation}\label{ell:tail-exponent} + t-1-v_p(t)\ge K. +\end{equation} +For $t0$ then +$t-1-j\ge p^j-1-j\ge p-2\ge K$; if $j=0$ it is again immediate. +Therefore, for $v(Z)\ge1$, +\begin{equation}\label{ell:tail} + v(\ell(Z)-\ell_K(Z))\ge v(Z)+K. +\end{equation} +The inequality also holds at $Z=0$ with the stated convention. Put +$q=n/n'$. The hypothesis $v_p(q)\ge0$ and \eqref{ell:ratio} give +$v(z(U))\ge v(z(V))$. The identity $\ell(z(U))=q\ell(z(V))$ and +\eqref{ell:tail} imply +\[ + v\bigl(\ell_K(z(U))-q\ell_K(z(V))\bigr) + \ge v(z(V))+K. +\] +The same tail estimate gives +$v(\ell_K(z(V)))=v(z(V))$, in particular a nonzero denominator. +Division proves \eqref{ell:truncation}. The proof applies verbatim to +the conjugate equation and the polynomial $\ell_K^\sigma$. +\end{proof} + +The quantifiers in Proposition~\ref{ell:formal} are those used in +Lemma~\ref{red:local-comparison}: for each fixed \(K\), a single finite +set of excluded rational primes works for all integer indices and all +unramified places above the remaining primes. The transfer there concerns +integer multiples of the fixed \(F\)-rational points \(P,P^\sigma\) +and finite polynomial evaluations. +No infinite series is evaluated in the elementary extension. diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/06-primes.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/06-primes.tex new file mode 100644 index 0000000000000000000000000000000000000000..0006953a9ebb34f53dcfed9efbc2ee291d190def --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/06-primes.tex @@ -0,0 +1,705 @@ +\section{Prime patterns for the two conjugate local tests} +\label{pri:section} + +This section proves Corollary~\ref{pri:integer-coverage}, the ordinary +coverage input used in the recursive theory. The raw prime-pattern result +below supplies the reduction orders; its first consequence constructs the +paired integer witnesses by the Chinese Remainder Theorem. + +Retain the five points $\mathcal C$ and the primitive integral forms +$L_b$ of Theorem~\ref{hei:height}, choosing $L_\infty(U,V)=V$. +For integers $A,u_1,u_2,v$ with $v\ne0$, setting $u_3=Av-u_1-u_2$ gives +\[ + A=\frac{u_1}{v}+\frac{u_2}{v}+\frac{u_3}{v}. +\] +Evaluating the five contact forms on $(u_i,v)$ gives the common value $v$ +and four further values for each slope. We seek to express each of these +thirteen entries as the product of a sign, a multiplier from one fixed +finite set, and a positive prime at which the reduction orders of $E$ and +$E^\sigma$ permit simultaneous local tests. + +\begin{lemma}[Prime patterns]\label{pri:pattern} +There is a finite set $\mathcal K\subset\Z_{>0}$ such that, for every +$A\in\Z$ and every real $B>0$, there exist integers $u_1,u_2,v$, with +$v\ne0$, for which, on setting $u_3=Av-u_1-u_2$, each of the thirteen +numbers +\begin{equation}\label{pri:forms-list} + v,\qquad L_b(u_j,v) + \quad(1\le j\le3,\ b\in\mathcal C\setminus\{\infty\}) +\end{equation} +has the form $\epsilon kr$, where $\epsilon\in\{1,-1\}$, +$k\in\mathcal K$, and $r>B$ is a positive rational prime. Every such +prime splits in $F$ and is a prime of good reduction for both $E$ and +$E^\sigma$. At either place of $F$ above $r$, if $d_1,d_2$ are the +cardinalities of the reduction groups of $E,E^\sigma$ over $\F_r$, then +\begin{equation}\label{pri:order-conditions} + \gcd(d_1,d_2)\mid4, + \qquad r\nmid d_1d_2. +\end{equation} +The set $\mathcal K$ is independent of $A$ and $B$. +\end{lemma} + +The listed values are nonzero, so the slopes $(u_i:v)$ lie outside +$\mathcal C$. A prime counted by one of their contact radicals divides a +listed contact value, because the corresponding normalized contact depth +is positive and the coordinates are integral; unless it divides a member +of $\mathcal K$, it is therefore one of the selected primes $r$. + +Before proving the lemma, we record the consequence that explains its +splitting and reduction-order conditions. Together with +Proposition~\ref{ell:formal}, they give two local tests at each place, +with one pair of auxiliary integers at that place serving every integer $a$. + +\begin{corollary}[Simultaneous integer tests]\label{pri:integer-tests} +Fix an integer $K\ge1$ and a prime $r$ supplied by Lemma~\ref{pri:pattern}, large +enough for Proposition~\ref{ell:formal} at precision $K$. At each of +the two places $v$ above $r$ there are nonzero integers $h,j_0$, chosen +independently of $a\in\Z$, such that, for every $a\in\Z$: +\begin{enumerate} +\item $hP$ and $haP$ reduce to $O$ at $v$, + $\ell_K(z(hP))\ne0$, and +\[ + v\!\left(\frac{\ell_K(z(haP))}{\ell_K(z(hP))}-a\right) + \ge K; +\] +\item $j_0P^\sigma$ and $(h-4)aP^\sigma$ reduce to $O$ at the + same place $v$, and +\[ + v\!\left(\frac{z((h-4)aP^\sigma)}{z(j_0P^\sigma)}\right) + \ge K. +\] +\end{enumerate} +The choices of $h,j_0$ may differ at the two places. +\end{corollary} + +\begin{proof} +Let $d_1,d_2$ be the two reduction orders at the chosen place. Choose +$j_0=d_2$. Since $r\nmid d_1$ and $\gcd(d_1,d_2)\mid4$, the pair of +integer congruences +\[ + h\equiv0\pmod{d_1},\qquad + h\equiv4\pmod{d_2r^K} +\] +is consistent. Choose a positive solution $h$. Reduction orders +show that all four indicated points are in the respective formal +kernels, uniformly for $a\in\Z$. The logarithm congruence follows from +Proposition~\ref{ell:formal} with indices $ha,h$, whose ratio is $a$. +For the conjugate ratio use \eqref{ell:ratio} on the conjugate curve: +\[ + v\!\left(\frac{z((h-4)aP^\sigma)}{z(j_0P^\sigma)}\right) + =v_r\!\left(\frac{(h-4)a}{d_2}\right)\ge K. +\] +The nonzero denominator follows because $j_0P^\sigma$ is nontorsion. +Zero numerator indices are covered by the infinite-valuation +convention. Finally, at these split unramified primes the valuation +ring on $F$ is the localization of $\mathcal O_F=\Z[\sqrt2]$ at the +chosen prime ideal, and $r$ is a uniformizer. Thus every displayed +inequality is exactly membership in $r^K(\mathcal O_F)_{\mathfrak p}$. +For a finite formal point, the condition $v(x)<0$ equivalently places +$1/x$ in $r(\mathcal O_F)_{\mathfrak p}$, as used in the ring-language tests of +Section~\ref{red:theory}. +\end{proof} + +\begin{proof}[Proof of Corollary~\ref{pri:integer-coverage}] +Fix \(K\ge1\), \(A\in\Z\), and \(Y_0>0\). Choose a real threshold +larger than \(Y_0\), \(K+1\), and every prime in the fixed finite set +\(S_E\). Lemma~\ref{pri:pattern} gives the thirteen contact values +with primes above this threshold, using its one finite set +\(\mathcal K\). These primes split in \(F\) and are good for both +curves. At each of the two places above each occurrence, +Corollary~\ref{pri:integer-tests} gives nonzero \(h,j_0\), fixed for +every integer \(a\), with its two formal-kernel conditions and valuation +comparisons. In the identity embedding with \(T_a=aP\), these are exactly +conditions (i) and (ii) of Lemma~\ref{red:local-comparison}. The final +localization calculation in the proof of Corollary~\ref{pri:integer-tests} +gives the stated membership and finite-point interpretations. The choices +are made separately at the different occurrences and places, as allowed. +The fixed set \(\mathcal K\) is independent of \(K,A,Y_0\) because the +prime-pattern lemma makes it independent of \(A\) and of the threshold. +\end{proof} + +We now prove Lemma~\ref{pri:pattern}. Constants with a subscript $A$ may +depend on $A$, a subsequently fixed real box, and the fixed contact +forms, but not on the small-prime cutoff $L$. The order of choices is: +the finite multiplier set; then $A$, a box and one initial congruence +class; then $L$; and finally a large dilation parameter $X$. + +\subsection{Reduction orders and their possible common factors} + +Restrict attention to primes +\begin{equation}\label{pri:prime-residues} + r\equiv1\pmod8, + \qquad r\equiv3\pmod7. +\end{equation} +Quadratic reciprocity gives $(2/r)=1$, so $r$ splits in $F$, and +$(7/r)=(r/7)=-1$. At either chosen place above $r$, the two nonzero +reductions of $d$ and $d^\sigma$ have product $7$. They therefore +represent opposite square classes in $\F_r^*$. The curves $E$ and +$E^\sigma$ are the quadratic twists by these classes of +$E_0:y^2=x^3-x$, so their traces of Frobenius are opposite. + +Here is the specific description of that trace which we need. Since +$r\equiv1\pmod4$, the automorphism +$(x,y)\mapsto(-x,iy)$ of $E_0$ is defined over $\F_r$ and has square +$[-1]$. Its centralizer in the rational geometric endomorphism algebra +is $\Q(i)$. Indeed, the faithful action of endomorphisms on an auxiliary +two-dimensional rational Tate module bounds this centralizer by +dimension two, while it already contains $\Q(i)$. More explicitly one +may use the $3$-adic Tate module for $r>3$, on which the minimal +polynomial $T^2+1$ is irreducible and its matrix centralizer has dimension +two. The faithful action remains injective after extending coefficients +\cite[Theorem III.7.4]{Silverman2009}. + +Frobenius commutes with this automorphism. Its characteristic polynomial +is integral, and its determinant is $r$; these are the usual degree and +trace identities for elliptic endomorphisms +\cite[Proposition III.8.6 and Chapter V, \S2]{Silverman2009}. +It is thus an algebraic integer in $\Q(i)$, hence equals $a+bi$ for +$a,b\in\Z$, with +\begin{equation}\label{pri:gaussian} + a^2+b^2=r,\qquad a\ne0. +\end{equation} +The last condition follows because a rational prime is not a square. +Consequently, in either order, +\begin{equation}\label{pri:orders} + d_1,d_2=r+1\pm2a. +\end{equation} +Both orders are divisible by four, since both curves have full rational +two-torsion over $\F_r$. Their sum is $2(r+1)$, whose $2$-adic valuation +is exactly two by \eqref{pri:prime-residues}. Thus the $2$-part of their +greatest common divisor is exactly four. For sufficiently large $r$, +the Hasse bound gives $02t$ and the later local-density +estimates hold for every $p\notin S_0$. Choose a fixed integer $H_0$ with +$t2^{-H_0}<1$. For any $A$ and any $p\in S_0$, each primitive $F_\nu$ +maps $(\Z/p^{H_0}\Z)^3$ onto $\Z/p^{H_0}\Z$. The proportion of vectors for +which $p^{H_0}\mid F_\nu(T)$ is therefore $p^{-H_0}$. Since $tp^{-H_0}<1$, +there is a vector class modulo $p^{H_0}$ on which none of the $F_\nu$ is +divisible by $p^{H_0}$. Every lift of this class modulo $p^{H_0+3}$ has +\[ + v_p(F_\nu(T))0$ independent +of $L$. + +We use the following precise form of the Green--Tao--Ziegler theorem. +For a fixed finite collection of integer affine-linear forms +$\psi_1,\ldots,\psi_t$ on $\Z^d$ whose nonzero linear parts are pairwise +nonproportional, and a fixed dilating box where all values are positive, +the von Mangoldt weighted count is +\begin{equation}\label{pri:gtz} + \sum_{n\in\mathcal D_X\cap\Z^d}\prod_{\nu=1}^t\Lambda(\psi_\nu(n)) + =\operatorname{vol}(\mathcal D_X)\prod_p\beta_p+o(X^d), +\end{equation} +where +\[ + \beta_p=(1-1/p)^{-t}p^{-d} + \#\{n\in\F_p^d:\psi_\nu(n)\ne0\text{ for every }\nu\}. +\] +Here all coefficients and the box are fixed before $X\to\infty$. +This is the finite-complexity case of the Main Theorem of +\cite{GreenTao2010}, combined with the M\"obius--nilsequence theorem +\cite[Theorem 1.1]{GreenTao2012} and the inverse theorem +\cite[Theorem 1.3]{GreenTaoZiegler2012}, with its correction +\cite{GreenTaoZiegler2024Erratum}. Pairwise nonproportional linear parts +give finite complexity: for any chosen form, the other forms can be +partitioned into singletons, none spanning it. The 2024 erratum +corrects intermediate factorization and filtration statements and leaves +the stated inverse theorem, and hence \eqref{pri:gtz}, unchanged. + +For each $T_0\in\mathcal R_W$, use its representative in $[0,W)^3$ and +write $T=T_0+Wn$. The forms +\[ + \psi_{\nu,T_0}(n) + =\epsilon_\nu F_\nu(T_0+Wn)/k_\nu +\] +have integer coefficients and pairwise nonproportional linear parts. +Use $n\in(X/W)\mathcal B'$. For all sufficiently large $X$, depending +on $A,L$, this entails $T\in X\mathcal B$, uniformly over the finite +set of representatives $T_0$. The volume in \eqref{pri:gtz} is then +$\operatorname{vol}(\mathcal B')X^3/W^3$. + +At $p\mid W$, the coefficients of the variable parts of every divided +form vanish modulo $p$, whereas their constant values are nonzero. +Consequently $\beta_p=(1-1/p)^{-t}\ge1$. At $p\nmid W$, multiplication +by $W$ and by $k_\nu^{-1}$ is invertible. The zero sets of the forms +are distinct affine hyperplanes, and each pair has an intersection of +codimension two. Inclusion--exclusion, using only the first two terms +for a uniform error, gives +\[ + p^{-3}\#\{n:\psi_{\nu,T_0}(n)\ne0\ (\forall\nu)\} + =1-t/p+O_t(p^{-2}). +\] +Thus $\beta_p=1+O_t(p^{-2})$. Taking the original fixed threshold +large enough, the product over any subset of these primes is bounded +below by one fixed positive convergent product. This lower bound is +independent of $L$ and $T_0$. + +Prime powers in \eqref{pri:gtz} are negligible. On a box of scale $X$, +there are $O(X^{1/2}\log X)$ proper prime powers in the range of each +nonconstant form, and at most $O_{A,L}(X^2)$ lattice points for each +prescribed value of that form, by solving for one coordinate. Their +total weighted contribution is therefore +$O_{A,L}(X^{5/2}(\log X)^{t+1})=o_{A,L}(X^3)$. +For genuine prime values the weight is at most $C_A(\log X)^t$, by +\eqref{pri:value-range}. + +Sum \eqref{pri:gtz} over the finitely many allowed progressions. For +each fixed $L$ their errors still sum to $o_{A,L}(X^3)$, while the +$W^{-3}$ volume factor cancels the $W^3$ in the number of progressions +in \eqref{pri:crt-density}. The lower bound for the local-factor product, +the removal of prime powers, and the bound on the prime weights therefore +give \eqref{pri:lower}, with a positive coefficient independent of $L$. +We require no uniformity in the little-oh error as $A$ or $L$ varies. + +We must now remove the patterns for which some pair of reduction orders +has an odd common factor $l>L$. For one form, we will bound the number of +possible bad prime values by $O_A(X/(L\log X))$ plus terms of smaller +order as $X\to\infty$ for fixed $L$. For each fixed bad value, a second +count will bound the points on +its affine fiber for which the other $t-1$ forms remain prime by +$O_A(X^2/(\log X)^{t-1})$. The contribution from the term +$X/(L\log X)$ is therefore $O_A(X^3/(L(\log X)^t))$. This retains the +factor $(\log X)^{-t}$ in \eqref{pri:lower} and introduces the saving $1/L$. +The first count sieves the pairs $(a,b)$ in \eqref{pri:gaussian}; the +second sieves the two free coordinates on a fiber. Both use the following +two-dimensional estimate. + +\subsection{An elementary upper sieve with uniform errors} + +Let $\mathcal P_Z$ be a set of primes at most $Z$, with forbidden subsets +$\Omega_p\subset\F_p^2$ having densities +$g(p)=|\Omega_p|/p^2$ in $(0,1/2)$. Extend $g$ multiplicatively to +squarefree integers supported on $\mathcal P_Z$. Let $\mathbf x$ range +over a square in $\Z^2$ with $n$ integer choices in each coordinate. +The simultaneous forbidden conditions at the primes dividing a +squarefree integer $e$ hold at +\begin{equation}\label{pri:residue-error} + n^2g(e)+O(ne+e^2) +\end{equation} +points, uniformly in the location of the square. Indeed the Chinese +Remainder Theorem gives $e^2g(e)$ residue classes, and the count in +each differs from $n^2/e^2$ by $O(n/e+1)$. + +The following estimate uses Selberg's $\lambda^2$ method +\cite{Selberg1947}; compare \cite[Section~3.2]{MontgomeryVaughan2007}. +We give the weights and error term needed for these two-dimensional boxes. + +\begin{lemma}\label{pri:upper-sieve} +The number of points in this square avoiding every $\Omega_p$ is at most +\begin{equation}\label{pri:sieve-bound} + \frac{n^2}{G(Z)}+O(nZ^6+Z^8),\qquad + G(Z)=\sum_{\substack{e\le Z\text{ squarefree}\\p\mid e\Rightarrow p\in\mathcal P_Z}} + \prod_{p\mid e}\frac{g(p)}{1-g(p)}. +\end{equation} +The error constant is absolute. +\end{lemma} + +\begin{proof} +All integers in the sums that follow are squarefree and supported on +$\mathcal P_Z$. Put $g_*(p)=(1-g(p))/g(p)$ and extend it +multiplicatively, with $g(1)=g_*(1)=1$. For real weights $\lambda_e$ +supported on $e\le Z$ with $\lambda_1=1$, the square +\[ + \left(\sum_{\substack{e\le Z\\ + \mathbf x\bmod p\in\Omega_p\ (p\mid e)}}\lambda_e\right)^2 +\] +majorizes the indicator of avoiding all forbidden sets: at such a point +only $e=1$ contributes. Upon summing and applying +\eqref{pri:residue-error}, its main term divided by $n^2$ is +$\sum_{e,f}\lambda_e\lambda_fg([e,f])$. +The identity $1/g(d)=\sum_{h\mid d}g_*(h)$ gives the diagonalization +\begin{equation}\label{pri:diagonalization} + \sum_{e,f}\lambda_e\lambda_fg([e,f]) + =\sum_hg_*(h) + \left(\sum_{\substack{e\le Z\\h\mid e}}\lambda_eg(e)\right)^2. +\end{equation} +Prescribe the inner sums to equal +$\mu(h)/(G(Z)g_*(h))$. Finite M\"obius inversion gives +\begin{equation}\label{pri:weights} + \lambda_e=\frac{\mu(e)}{G(Z)g(e)g_*(e)} + \sum_{\substack{k\le Z/e\\(k,e)=1}} + \frac{\mu(k)^2}{g_*(k)}. +\end{equation} +In particular $\lambda_1=1$ and +\[ + |\lambda_e|\le\frac1{g(e)g_*(e)} + =\prod_{p\mid e}(1-g(p))^{-1} + \le2^{\omega(e)}\le e. +\] +Substitution in \eqref{pri:diagonalization} gives $1/G(Z)$. +For the error at $[e,f]$, use $[e,f]\le ef$ and +$|\lambda_e\lambda_f|\le ef$. Its sum is bounded by +\[ + O\!\left(n\sum_{e,f\le Z}e^2f^2+ + \sum_{e,f\le Z}e^3f^3\right) + =O(nZ^6+Z^8), +\] +as required. +\end{proof} + +We shall always set $Z=X^{1/100}$. Two consequences for $G(Z)$ will +be useful. If $\mathcal P_Z$ contains all primes above a fixed +threshold up to $Z$, and +$g(p)=s/p+O_s(p^{-2})$ for a fixed positive integer $s$, then +\begin{equation}\label{pri:sieve-dimension} + G(Z)\gg(\log X)^s. +\end{equation} +If instead it contains the primes $p\equiv1\pmod4$ above a fixed +threshold up to $Z$, with at most one additional prime omitted, and +$g(p)=2/p+O(p^{-2})$, then +\begin{equation}\label{pri:split-sieve-dimension} + G(Z)\gg\log X, +\end{equation} +uniformly in that omitted prime. In these two estimates the implicit +constants may depend on the fixed threshold and the fixed density +estimates, as well as on $s$, but not on $X$ or the omitted prime. + +Here are details of the truncation behind both claims. For +$y=Z^\theta$, where $\theta>0$ will be fixed sufficiently small, the +Euler product +\[ + D(y)=\prod_{\substack{p\le y\\p\in\mathcal P_Z}} + (1+g_*(p)^{-1}) +\] +is respectively $\gg(\log y)^s$ or $\gg\log y$, by the ordinary and +progression Mertens estimates +\cite[equation~(1.1) and Theorem~1]{Williams1974}. In the latter case removing one prime +loses at most a factor two because $g(p)<1/2$. +In the expansion of $D(y)$ give a squarefree $e$ weight $1/g_*(e)$. +The weighted mean of $\log e$ equals +\[ + \sum_{\substack{p\le y\\p\in\mathcal P_Z}} + g(p)\log p\ll\log y. +\] +This uses $\sum_{p\le y}(\log p)/p\ll\log y$, and the bound is uniform +when a prime is omitted. For a small enough fixed $\theta$, Markov's +inequality shows that at least half the weight has $e\le Z$. +Those terms occur in $G(Z)$, proving both assertions. + +\subsection{Counting bad prime values} + +Fix one index $\nu$. All its possible prime values lie in the interval +\eqref{pri:value-range}. Let $B_{A,L}(X)$ be the number of primes in +that interval satisfying \eqref{pri:prime-residues} for which the two +orders have a common odd factor $l>L$. We claim +\begin{equation}\label{pri:bad-primes} + B_{A,L}(X)\ll_A + \frac{X}{L\log X}+X^{7/8}+\sqrt X\log X. +\end{equation} +It suffices to count pairs $(a,b)\in\Z^2$ with +$|a|,|b|\le C_A\sqrt X$, $a\ne0$, for which $a^2+b^2$ is a prime +in the interval and \eqref{pri:bad-classes} holds for some prime +$l>L$. Every bad prime supplies such a pair. Overcounting pairs, and +counting a pair several times if necessary, gives an upper bound. + +First consider $LZ$, it avoids all these forbidden sets. +Lemma~\ref{pri:upper-sieve} and +\eqref{pri:split-sieve-dimension} give +$O(n^2/\log X+nZ^6+Z^8)$ pairs. At the shortest possible squares, +\[ + \frac{nZ^6+Z^8}{n^2/\log X} + \ll_A(\log X) + \bigl(X^{6/100-3/8}+X^{8/100-3/4}\bigr)=o_A(1). +\] +The error is therefore absorbed uniformly before summing over $l$. +Each $l$ contributes $O_A(X/(l^2\log X))$, and summing over even all +integers $l>L$ gives $O_A(X/(L\log X))$. + +For $l>X^{1/8}$ use a lattice count without a sieve. Since $a\ne0$ +and $l\mid a$, necessarily $l\le C_A\sqrt X$, and the number of +possible $a$ is $O_A(\sqrt X/l)$, with no additive constant. +There are at most two classes for $b$, giving +$O_A(\sqrt X/l+1)$ possibilities. The count for one $l$ is thus +\[ + O_A(X/l^2+\sqrt X/l). +\] +To sum it explicitly, split $X^{1/8}L$ in one of +their pairs of reduction orders. More explicitly, the ratios of the +two other terms to $X^3/(\log X)^t$ are +$O_A(X^{-1/8}\log X)$ and $O_A(X^{-1/2}(\log X)^2)$; both tend to +zero. None of the constants in this upper estimate depends on $L$. + +Choose $L$, after all data depending on $A$ have been fixed, large +enough that +\[ + C_A/L<\tfrac12 c_A(\log L)^{-C_0}. +\] +This is possible because $(\log L)^{C_0}/L\to0$. Then choose $X$ +sufficiently large for \eqref{pri:lower}, for all the upper estimates, +and for the residual little-oh in \eqref{pri:total-loss} to be smaller +than the remaining lower-bound coefficient. At least one prime +pattern survives. Small common odd factors were already excluded by +the CRT conditions, and all larger ones have just been removed. The +$2$-part and the prime-to-$r$ assertions proved from +\eqref{pri:orders} now give \eqref{pri:order-conditions}. The primes +have size at least $c_AX$, so increasing $X$ makes all of them exceed +any prescribed $B$. This proves Lemma~\ref{pri:pattern}. + +Together with Corollary~\ref{pri:integer-tests}, the prime-pattern lemma +proves Corollary~\ref{pri:integer-coverage}, completing the ordinary integer +witnesses used in Section~\ref{sec:reduction}. The analysis there combines +the tested representations with the parity, height, and elliptic inputs to +turn success of all finite tests into an ordinary integer zero. diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/07-consequences.tex b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/07-consequences.tex new file mode 100644 index 0000000000000000000000000000000000000000..beb1dd9eee30a9865b59dda9fdd53f417a3e96d9 --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/build/sections/07-consequences.tex @@ -0,0 +1,108 @@ +\section{Turing degree and a quartic normal form} +\label{red:degree-normal-form} + +The finite-test reduction determines the Turing degree of rational +solvability. A separate arithmetic-circuit conversion gives the same +degree for two restricted forms of the input. + +\begin{corollary}\label{thm:degree-normal-form} +With the usual effective coding, let \(\mathrm{H10}(\Q)\) be the set of +integral polynomials having a rational zero, with the number of variables +part of the input. Then \(\mathrm{H10}(\Q)\) has Turing degree \(0'\), +the degree of the halting problem. The same is true for each of the +following restricted input problems: +\begin{enumerate}[label=(\roman*),leftmargin=*] +\item rational solvability for integral polynomials of total degree at +most four; +\item given a nonempty finite list +\(q_1,\ldots,q_s\in\Z[X_1,\ldots,X_N]\), each of total degree at most +two, whether \(\sum_{i=1}^s q_i^2\) has a zero in \(\Q^N\). +\end{enumerate} +No bound is imposed on the number of variables, the number of summands +in (ii), or the coefficient heights. +\end{corollary} + +\begin{proof} +Let \(\mathrm{H10}(\Z)\) denote the analogous set of integral polynomials +having an integer zero. The parallel search in the proof of Theorem~\ref{thm:main} +in Section~\ref{sec:reduction} can be run with +an \(\mathrm{H10}(\Q)\) oracle in place of the hypothetical rational +decision procedure. The finite tests of \S\ref{red:finite-tests} are +uniformly computable from \(f\) and their indices once the fixed +arithmetic data have been chosen, and each test uses finitely many oracle +queries. The search therefore halts on every input, proving +\[ + \mathrm{H10}(\Z)\le_{\mathrm T}\mathrm{H10}(\Q), +\] +where \(\le_{\mathrm T}\) denotes Turing reducibility. The fixed choices +used to define \(\mathcal T\) are independent of \(f\), so this +construction gives a single oracle machine. + +The Davis--Putnam--Robinson--Matiyasevich theorem, in the form +\cite[Theorem~8.1]{Davis1973}, applies to a positive-integer coding of +the halting set. Its positive-integer witnesses can be replaced by +\(1+u_1^2+u_2^2+u_3^2+u_4^2\), using the four-square theorem as in +\cite[p.~234]{Davis1973}. Specializing the parameter in the resulting +fixed polynomial gives a computable many-one reduction of the halting +set to \(\mathrm{H10}(\Z)\). Integer solvability is itself computably +enumerable by enumeration of integer tuples, so it has Turing degree +\(0'\). Rational solvability is also computably enumerable: enumerate +rational tuples and evaluate the input polynomial exactly. Every +computably enumerable set is Turing reducible to the halting set. +Together with the displayed oracle reduction, this proves that +\(\mathrm{H10}(\Q)\) has degree \(0'\). + +For the degree restriction, we apply over \(\Q\) the algebraic +normalization used in \cite[Theorem~7.5]{Davis1973}. Given +\(f\in\Z[X_1,\ldots,X_n]\), effectively construct an arithmetic circuit +evaluating \(f\), with input nodes, integral constant nodes, and addition +and multiplication gates. Give every node \(v\) a new variable \(Y_v\). +For an input node \(X_j\) and a constant node \(c\), impose respectively +\[ + Y_v-X_j=0,\qquad Y_v-c=0. +\] +For a sum or product node \(v\) with incoming nodes \(u,w\), impose +respectively +\[ + Y_v-Y_u-Y_w=0,\qquad Y_v-Y_uY_w=0. +\] +Finally impose \(Y_{\mathrm{out}}=0\) at the output node. This gives a +nonempty finite list \(q_1,\ldots,q_s\) of integral polynomials of total +degree at most two in \(N=n+m\) common variables +\(\mathbf Z=(\mathbf X,\mathbf Y)\), where \(m\) is the number of circuit +nodes. It also handles constant inputs. Induction through the circuit shows +that each rational input tuple has a unique extension satisfying the +gate equations, with output value \(f(\mathbf X)\). Since squares of +rationals are nonnegative, it follows that +\[ +\begin{gathered} + (\exists\mathbf x\in\Q^n)\ f(\mathbf x)=0 + \\ + \Longleftrightarrow\quad + (\exists\mathbf z\in\Q^N)\ \bigwedge_{i=1}^s \bigl(q_i(\mathbf z)=0\bigr)\\ + \Longleftrightarrow\quad + (\exists\mathbf z\in\Q^N)\ \sum_{i=1}^s q_i(\mathbf z)^2=0. +\end{gathered} +\] +Let \(S_2\) denote the presented list problem in (ii), and let +\(H_{\le4}\) denote the problem in (i). Sending \(f\) to the list +\((q_1,\ldots,q_s)\), and then expanding its squared sum, gives computable +many-one reductions +\[ + \mathrm{H10}(\Q)\le_{\mathrm m}S_2 + \le_{\mathrm m}H_{\le4}. +\] +The expanded polynomial has integral coefficients and total degree at +most four. Both target sets are computably enumerable by rational-tuple +enumeration, so the reductions and the first part of the proof give +Turing degree \(0'\) for both. + +The many-one reduction to the restricted problems starts from +\(\mathrm{H10}(\Q)\); the reduction from \(\mathrm{H10}(\Z)\) remains a +Turing reduction. This argument does not establish many-one completeness +of \(\mathrm{H10}(\Q)\). The list in (ii) is supplied as part +of the input, so no recognition of sum-of-squares presentations is +needed. The construction supplies no bound on the number of variables +or coefficient heights, and it gives no single existential definition +of \(\Z\) in \(\Q\). +\end{proof} diff --git a/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/main.pdf b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/main.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f6d81a65f5896d816816d1aabde5540259f5e7fd --- /dev/null +++ b/preprints/Hilberts-tenth-problem-over-the-rational-numbers-October-6-2026/main.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f79236c22b981fe66aaf3ba494a466bf26db212117db47d95a31bf0315af2b30 +size 701017 diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/README.md b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a36e30f80ff9eb1ca16a3398a29bf05c37e4be38 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/README.md @@ -0,0 +1,20 @@ +# [Incompressible Box Transport and Finite Computation](manuscript.pdf) + +**Author:** OpenAI +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Incompressible-Box-Transport-and-Finite-Computation-October-6-2026, + author = {{OpenAI}}, + title = {{Incompressible Box Transport and Finite Computation}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/manuscript.pdf}{OAI:Incompressible-Box-Transport-and-Finite-Computation-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version supplies effective torus-projection and common-clock decay estimates, including the projected-force and pressure bounds; see the [previous version](../Incompressible-Box-Transport-and-Finite-Computation-September-27-2026/manuscript.pdf). diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/analysis.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/analysis.tex new file mode 100644 index 0000000000000000000000000000000000000000..5f06ea1ea72f1449b748cfaa86da6221df515d99 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/analysis.tex @@ -0,0 +1,282 @@ +\section{Analytic classes and changes of physical coordinates}\label{sec:model} +The geometric constructions prescribe a smooth velocity first. This section +records exactly which other solutions are excluded by the energy argument. +Pressure assumptions are kept separate: continuity in a pressure norm, a +norm at each individual time, and an integrable pressure gradient are +different conditions. + +Write $\mathcal F_\nu[U]=U_t+(U\cdot\nabla)U-\nu\Delta U$. +All noncompact results below use $\mathbb R^3$; their velocities and forces +have one fixed compact spatial support unless the individual statement +says otherwise. This property concerns the constructed solution, not a +competing solution. On $[0,T]$, write $CH^k=C([0,T];H^k(\mathbb R^3))$ +and $C^1L^2=C^1([0,T];L^2(\mathbb R^3))$. Spatial constants in pressure +may depend on time. + +\begin{lemma}[The pressure term without a pressure norm]\label{lem:b-gradient} +If $w,g\in L^2(\mathbb R^3;\mathbb R^3)$ satisfy +$\operatorname{div}w=0$ and $\operatorname{curl}g=0$ in distributions, then +$\langle w,g\rangle_{L^2}=0$. In particular, any distributional gradient +$g=\nabla p\in L^2$ has zero pairing with $w$, without an assumption that +$p\in L^2$. +\end{lemma} +\begin{proof} +An $L^2$ field is a tempered distribution. The differential identities, +initially tested on compactly supported smooth functions, extend to +Schwartz tests by multiplying by cutoffs tending to one and using $L^2$ +convergence of the tests and their first derivatives. Fourier transformation +gives $\xi\cdot\widehat w=0$ and +$\xi_j\widehat g_k-\xi_k\widehat g_j=0$. These are identities of locally +integrable functions, so they hold almost everywhere. Away from $\xi=0$, +$\widehat g$ is parallel to $\xi$ and $\widehat w$ is perpendicular to it. +Their Hermitian product is zero. The exceptional point has measure zero; +Plancherel proves the assertion. +\end{proof} + +\begin{lemma}[Residual realization and separate comparison classes] +\label{lem:b-comparison}\label{lem:p2-realization} +Let $\nu>0$ and let $U$ be a prescribed smooth divergence-free velocity +on $[0,\infty)\times\mathbb R^3$, with $U(0)=0$. On each finite interval, +assume $U\in CH^2\cap C^1L^2$ and $U,\nabla U$ are bounded. Put +$f=\mathcal F_\nu[U]$. Then $(U,0)$ is a solution. Its velocity is unique +in each of the following separately stated comparison classes, with the +same force and initial data: +\begin{enumerate}[label=(\roman*),itemsep=2pt] +\item Smooth classical $v\in CH^2\cap C^1L^2$, with bounded $v$, and a +pressure representative $p\in CH^1$. +\item Smooth classical $v\in CH^2\cap C^1L^2$, with bounded $v,\nabla v$, +and an $H^1$ pressure representative at each time, with no required time +continuity in that pressure norm. +\item Strong solutions with $v\in CH^4\cap C^1H^2$ and distributional +$\nabla p\in CL^2$. +\item Smooth classical $v\in CH^2\cap C^1L^2$, with bounded $v,\nabla v$, +and a pressure representative $p\in CL^2$. +\item Smooth classical $v\in CH^2\cap C^1L^2$, with bounded $v,\nabla v$, +without an additional integrability or normalization condition on pressure. +\end{enumerate} +The pressure gradient is unique. An $L^2$ pressure representative, when +specified, is zero; otherwise pressure is determined up to a function of +time. The reference material flow is a smooth diffeomorphism at every +finite time and exists for every finite forward time. + +On a flat torus $\T_L^3$, the same conclusion holds in the classical class +where $v,v_t$, spatial derivatives through order two, and $p,\nabla p$ are +continuous on finite closed cylinders, with periodic mean-zero pressure. +No Sobolev conditions at infinity are involved in that assertion. +\end{lemma} +\begin{proof} +Substitution proves existence of the prescribed solution. Set $w=v-U$. +The difference equation is +\[ + w_t+(v\cdot\nabla)w+(w\cdot\nabla)U + =\nu\Delta w-\nabla p,\qquad \operatorname{div}w=0. +\] +The stated velocity regularity implies $w\in C^1L^2\cap CH^2$, so +$\frac d{dt}\|w\|_2^2=2\langle w,w_t\rangle$ at each time. In case +(iii), the stronger assumptions imply these inclusions. They also imply +bounded velocity and spatial derivatives through order two: for $j\le2$, +Cauchy--Schwarz in Fourier space uses the finite integral +$\int_{\mathbb R^3}|\xi|^{2j}(1+|\xi|^2)^{-4}\,d\xi$. + +For the transport term, insert a cutoff $\chi_R$ that equals one on the +ball of radius $R$, is supported in the ball of radius $2R$, and satisfies +$|\nabla\chi_R|\le C/R$. Its boundary error is at most +$CR^{-1}\|v\|_\infty\|w\|_2^2$, which tends to zero. Diffusion is +integrated by parts in $H^2$; alternatively its cutoff error is bounded by +$CR^{-1}\|w\|_2\|\nabla w\|_2$. The deformation term is bounded by +$\|\nabla U\|_{\infty,\mathrm{op}}\|w\|_2^2$. + +We justify the pressure pairing according to the stated alternatives. +For (i) and (ii), at each fixed time approximate the chosen $H^1$ pressure +by compactly supported smooth functions; distributional incompressibility +and $w\in L^2$ give $\langle\nabla p,w\rangle=0$. Thus no continuity +of $p$ in time is used in (ii). For (iv), integration by parts on the +cutoff gives a pressure boundary term bounded by +$CR^{-1}\|p\|_2\|w\|_2$, also tending to zero. For (iii), apply +Lemma~\ref{lem:b-gradient} directly. Finally, in (v) the equation itself +gives at each time +\[ + \nabla p=f-v_t-(v\cdot\nabla)v+\nu\Delta v\in L^2, + \qquad \|(v\cdot\nabla)v\|_2\le\|v\|_\infty\|\nabla v\|_2. +\] +Here $f\in L^2$ follows from the identical estimate for $U$ and its stated +time and space regularity. The smooth pressure gradient is curl free, so +Lemma~\ref{lem:b-gradient} again cancels the term. This does not choose an +$L^2$ representative of the pressure. + +In every case the resulting pointwise energy inequality is +\[ + \frac12\frac d{dt}\|w\|_2^2+\nu\|\nabla w\|_2^2 + \le \|\nabla U\|_{\infty,\mathrm{op}}\|w\|_2^2. +\] +The coefficient is bounded on each finite interval and $w(0)=0$, so an +integrating factor gives $w=0$. The pressure has already disappeared before +time integration; the proof imposes no unlisted temporal pressure norm. +Substitution then gives $\nabla p=0$. A spatially constant $L^2$ function +on $\mathbb R^3$ is zero, which proves the normalization assertion. + +On the torus every integration by parts is periodic and has no boundary +term. The specified classical regularity justifies norm differentiation, +diffusion, and pressure cancellation. The same energy inequality gives +uniqueness and the mean-zero normalization fixes pressure. In either domain, +the smooth reference velocity and its bounded spatial derivative give +unique material trajectories; bounded speed prevents finite-time escape. +Solving backwards on a finite interval gives the inverse flow, and smooth +ODE dependence gives its smoothness. +\end{proof} + +Cases (i)--(v) identify the precise hypotheses used by the applications; +their presence in a common lemma does not replace a theorem's declared +comparison class by a different one. In particular, a pressure norm is not +silently imposed in a gradient-only application. The proof is the classical +energy comparison for prescribed smooth solutions \cite[Section~18]{Leray1934}, +with its noncompact pressure pairings made explicit. + +For the flow $\Phi_t$, differentiation of its trajectory equation gives +\[ + U(t)=(\partial_t\Phi_t)\circ\Phi_t^{-1},\qquad + \partial_{tt}\Phi_t(a)= + (f-\nabla p+\nu\Delta U)(t,\Phi_t(a)). +\] +These identities describe the material form of the same constructed solution; +they do not add an independent existence claim. + +\begin{lemma}[Physical scaling]\label{lem:p2-chart} +For $a,b>0$, $x=x_0+ay$, and $s=bt$, let +$U(t,x)=abV(bt,(x-x_0)/a)$. Then trajectories are transformed by this change +of variables, incompressibility is preserved, and at the prescribed physical +viscosity $\nu$, +\[ + \mathcal F_\nu[U](t,x)=ab^2\left[ + V_s+(V\cdot\nabla_y)V-\frac{\nu}{a^2b}\Delta_yV + \right](bt,(x-x_0)/a). +\] +\end{lemma} +\begin{proof} +The trajectory equation gives $\dot x=abV$; differentiating in space gives +$\operatorname{div}_xU=b\operatorname{div}_yV$. The three residual terms +scale by $ab^2,ab^2$, and $b/a$, respectively, proving the formula. +\end{proof} +Thus a side-$10$ torus is kept as a physical side-$10$ torus. If a chart +is rescaled, the residual is recomputed with the fixed $\nu$; the equation +is not identified with a differently normalized viscosity. + +\begin{proposition}[Projection on a flat torus]\label{prop:projection-l2} +Let $g$ be a smooth force on $[0,\infty)\times\T_L^3$ with zero +spatial mean at each time. There is a unique smooth mean-zero potential +$\phi$ satisfying $\Delta\phi=\operatorname{div}g$. Put +$Qg=\nabla\phi$ and $Pg=g-Qg$. Then $Pg$ is solenoidal and mean zero, +and replacing $(g,p)$ by $(Pg,p-\phi)$ preserves the velocity and the +pressure normalization. + +Use normalized spatial measure, frequencies $\xi_k=2\pi k/L$, and norms +\[ + \|G\|_{H^s}^2=\sum_{k\in\Z^3}(1+|\xi_k|^2)^s|\widehat G(k)|^2, + \qquad + \|G\|_{C^r}=\max_{|\beta|\le r}\|\partial_x^\beta G\|_\infty. +\] +For all integers $h,r\ge0$, at each time, +\begin{equation}\label{eq:projection-estimate} + \begin{aligned} + \max\{\|\partial_t^h Pg\|_{C^r},\|\partial_t^h Qg\|_{C^r}\} + &\le S_L\|\partial_t^h g\|_{H^{r+2}},\\ + \|\partial_t^h\phi\|_{C^{r+1}} + &\le S_Ld_L\|\partial_t^h g\|_{H^{r+2}}, + \end{aligned} +\end{equation} +where $S_L=(1+52(L/(2\pi))^4)^{1/2}$ and +$d_L=(1+(L/(2\pi))^2)^{1/2}$. + +Uniform bounds, temporal $L^2$ bounds on spatial suprema, and qualitative +uniform decay of all mixed derivatives pass from $g$ to $Pg,Qg,\phi$. +A quantitative envelope for time order $h$ and output spatial order $r$ +passes to $Pg,Qg$ through order $r$ and to $\phi$ through order $r+1$ +when the input derivatives through spatial order $r+2$ satisfy that +envelope. The constants may depend on the derivative order. +Periodicity and stationarity, including either property on a time tail, +are preserved on their respective intervals. + +For computable $L>0$, effective mixed-derivative evaluation and effective +derivative bounds for $g$ on finite time slabs give effective evaluation +and such bounds for $Pg,Qg,\phi$. Corresponding supplied global input +bounds give effective global bounds in each assertion above. +\end{proposition} +\begin{proof} +For $k\ne0$ define +\[ + \widehat\phi(t,k)=-\frac{i\xi_k\cdot\widehat g(t,k)}{|\xi_k|^2}, + \qquad \widehat\phi(t,0)=0. +\] +The nonzero-frequency symbols of $Q$ and $P$ are complementary orthogonal +projections. Their $H^s$ operator norms are at most one, while the +multiplier for $\phi$ has norm at most $d_L$ from $H^s$ to $H^{s+1}$. +For $|\beta|\le r$, Cauchy--Schwarz bounds the absolute sum of the +Fourier series for $\partial_x^\beta G$ by +\[ + \left(\sum_{k\in\Z^3}(1+|\xi_k|^2)^{-2}\right)^{1/2} + \|G\|_{H^{r+2}}. +\] +The shell $|k|_\infty=n\ge1$ contains $24n^2+2\le26n^2$ points. +Since $\sum_{n\ge1}n^{-2}\le2$, the factor is at most $S_L$. +For the tail $|k|_\infty>N\ge1$, it is at most +\begin{equation}\label{eq:projection-tail} + \left(26(L/(2\pi))^4/N\right)^{1/2}. +\end{equation} +Applying these estimates to the multipliers proves +\eqref{eq:projection-estimate}, including the estimate for $\phi$ with +one additional spatial derivative. On compact time slabs these tails +converge uniformly for every mixed derivative. Thus the series define +smooth fields and may be differentiated term by term. The Fourier +identities give the Poisson equation, uniqueness of its mean-zero +solution, and $\operatorname{div}Pg=0$. Also +$-\nabla(p-\phi)+Pg=-\nabla p+g$. + +For every integer $n\ge0$, the multinomial expansion and Parseval give +\begin{equation}\label{eq:projection-derivative-bounds} + \|G\|_{H^n}^2 + \le\sum_{|\beta|\le n} + \frac{n!}{(n-|\beta|)!\,\beta!} + \|\partial_x^\beta G\|_\infty^2. +\end{equation} +Use $n=r+2$ and $G=\partial_t^h g$. This finite sum proves the uniform +bounds and qualitative decay assertions. If its input suprema are +bounded by $C_{h,\beta}a_h(t)$, it gives the same envelope $a_h$ for +the output, with the constants specified by +\eqref{eq:projection-estimate}--\eqref{eq:projection-derivative-bounds}. +Integrating the squared estimates proves the temporal $L^2$ assertion +from the corresponding input norms. The operators act at each time, +so they preserve the stated temporal symmetries. + +For effective evaluation, the supplied derivative bounds and +\eqref{eq:projection-tail} give a computable Fourier truncation on each +finite time slab. The finitely many coefficient integrals are computed +by Riemann sums. After scaling the torus to $[0,1]^3$, the integrand +for $\widehat G(k)$ has Lipschitz bound +\[ + L\sqrt3\max_j\|\partial_{x_j}G\|_\infty + +2\pi|k|\|G\|_\infty. +\] +This gives an effective quadrature error and hence evaluation of every +mixed derivative of all three fields. The displayed finite sums also +compute output bounds from the supplied input bounds. +\end{proof} +The estimates apply to the pressure shift $\phi$; in the constructions +with original pressure zero, the projected pressure is $-\phi$. +Projection generally changes pressure. It supplies no compact-support +conclusion on Euclidean space and is distinct from the direct zero-pressure +solenoidal shear construction. + +\paragraph{Effective flat profiles.} +For later cutoff formulas put +\begin{equation}\label{eq:p2-step} + \rho(s)=\begin{cases}e^{-1/s},&s>0,\\0,&s\le0,\end{cases} + \qquad \sigma(s)=\frac{\rho(s)}{\rho(s)+\rho(1-s)}. +\end{equation} +Positive-side derivatives of $\rho$ are polynomials in $1/s$ times +$e^{-1/s}$ and extend flatly at zero. The estimate +$v^me^{-v}\le(m+k)!v^{-k}$ gives effective error bounds near the seam, +and $\rho(s)+\rho(1-s)\ge e^{-2}$. Products, translations, rescalings, +and derivatives therefore yield effective cutoffs with all requested +derivative bounds. Periodization uses zero collars; at approximate real +arguments a finite superset of possible translates is evaluated. No real +equality test at a seam or execution of the encoded computation is used. diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/balanced.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/balanced.tex new file mode 100644 index 0000000000000000000000000000000000000000..b31ddf5c0d690a53b3b2f778a0f03c78c7e3d7b2 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/balanced.tex @@ -0,0 +1,166 @@ +\section{A complete balanced three-stack realization}\label{sec:bb-balanced-three-stack} + +In a positional code with base $B$, replacing a prefix of length $r$ +by one of length $s$ gives an affine map with slope $B^{r-s}$. +Thus a three-stack instruction has determinant one when it preserves +the sum of the three prefix lengths. A third stack supplies reversible +history under this constraint: we first move a fresh blank from beyond +a work-tape boundary onto the history stack, then replace that blank +by the record. + +\begin{theorem}[Balanced three-stack realization] +\label{thm:bb-balanced-three-stack} +For every machine and finite input, there are effective coefficients +$f_0,f_1$ such that $f=f_0+\nu f_1$ on $\R^3$ has an explicit +zero-data solution $(U,0)$. Force and velocity have one compact +spatial support and bounded mixed derivatives of every order, and +are one-periodic after $t=1$. At the fixed label $x_*=(4,0,0)$, +\[ + \exists t\ge0:\quad X(t;x_*)\in(-1,2)^3 + \quad\Longleftrightarrow\quad\text{the machine halts}. +\] +For a fixed machine its repeated field is independent of the input. +The comparison class is $u\in C H^2\cap C^1L^2$, bounded $u,\nabla u$ +on finite intervals, and pressure modulo constants in $C H^1$. +The formula is valid for every fixed real $\nu>0$, with effective +evaluation when $\nu$ is computable and relative evaluation otherwise. +\end{theorem} +\begin{proof} +Normalize the finite machine to one halting state $h$, directing missing +nonhalting instructions to it by unchanged-letter stay moves. This preserves +initial halting as well. Let $\Gamma$ be the work alphabet and +$b\in\Gamma$ its blank. Use three infinite top-first stacks $L,R,J$. A rule replaces three +finite prefixes, leaving their tails untouched. Introduce boundary +$\star$, marked work letters $\bar a$, and controls $A_q,S_q,T_q,D_q$; +only $A_h$ is terminal. For each $q\ne h$, the preparatory rules are +\begin{align} + (A_q;\varepsilon,a,\varepsilon)&\to(S_q;\bar a,\varepsilon,\varepsilon), + \label{eq:bb-balanced-entry}\\ + (S_q;\varepsilon,c,\varepsilon)&\to(S_q;c,\varepsilon,\varepsilon), + \label{eq:bb-balanced-out-sweep}\\ + (S_q;\varepsilon,\star b,\varepsilon)&\to(T_q;\varepsilon,\star,b), + \label{eq:bb-balanced-blank}\\ + (T_q;c,\varepsilon,\varepsilon)&\to(T_q;\varepsilon,c,\varepsilon), + \label{eq:bb-balanced-return-sweep}\\ + (T_q;\bar a,\varepsilon,\varepsilon)&\to(D_q;\varepsilon,a,\varepsilon). + \label{eq:bb-balanced-restore} +\end{align} +Here $a,c\in\Gamma$. For $\delta(q,a)=(q',d,\sigma)$ add +\begin{equation}\label{eq:bb-balanced-step-table} +\begin{array}{c|c|c} +\sigma&\text{source}&\text{target}\\\hline +0&(D_q;\varepsilon,a,b)&(A_{q'};\varepsilon,d,\kappa)\\ +-1&(D_q;c,a,b)&(A_{q'};\varepsilon,cd,\kappa)\quad(c\in\Gamma)\\ +1&(D_q;\varepsilon,ac,b)&(A_{q'};d,c,\kappa)\quad(c\in\Gamma)\\ +1&(D_q;\varepsilon,a\star b,b)&(A_{q'};d,b\star,\kappa). +\end{array} +\end{equation} +Every individual row occurrence, including its choice of $c$, receives +a distinct record symbol $\kappa$. + +\emph{Full-domain separation and initialized behavior.} +\label{lem:bb-balanced-processor}\label{proof:bb-balanced-processor} +Every rule preserves total prefix length: it is one in the transfer +rows, two in the blank-supply row, and respectively two, three, three, +four in the final rows. Source branches at $A_q$ test the right top; +at $S_q$ the right top separates work letters from the boundary; +at $T_q$ the left top separates work and marked letters. At $D_q$ +the right top fixes the work instruction, with the next right symbol +or left top separating its remaining branches. Target branches at +$S_q$ have distinct marked or ordinary left tops; at $T_q$ distinct +boundary or ordinary right tops; at $D_q$ distinct restored $a$; +and at an $A$ control distinct history tops $\kappa$. +This proves separation for arbitrary independent tails. + +Initialize +\[ + (A_{q_0};b^\infty,v\star b^\infty,b^\infty),\qquad + v=\begin{cases}\omega,&\omega\ne\varepsilon,\\b,&\omega=\varepsilon. + \end{cases} +\] +At a checkpoint, $L$ lists cells strictly left of the head and +$R=a_1\cdots a_m\star b^\infty$, $m\ge1$, lists the current cell +and a finite right block; beyond it the tape is blank. $J$ contains +completed records, newest first. The first rule marks $a_1$ while +moving it left; $m-1$ forward transfers expose $\star$. The blank +row removes one filler blank beyond that boundary and pushes it on +$J$, without changing the infinite blank filler. The reverse transfers +and restoration of $a_1$ restore exactly the original two work stacks. +The final rule replaces the fresh history blank by its record and +performs the work instruction. A left move pops the next cell from +$L$; a right move with $m\ge2$ pops the current cell from $R$; +when $m=1$ the last row exposes a blank and retains a nonempty right +block. Thus the invariant holds and one work step costs +$1+(m-1)+1+(m-1)+1+1=2m+2$ rules. An initially halted input needs +none. The records recover the head displacements as well. + +\emph{From balanced words to solid boxes.} +Give the enlarged alphabet $\Sigma$ the odd digits +$1,3,\ldots,2|\Sigma|-1$ in base $B=2|\Sigma|+1$. +For a finite word $v$ put $e(v)=\sum_{j=1}^{|v|}d(v_j)B^{-j}$; +for an infinite stack $\xi$ put +$e(\xi)=\sum_{j\ge1}d(\xi_j)B^{-j}$. +The prefix interval is $I(v)=e(v)+[0,B^{-|v|}]$, with +$I(\varepsilon)=[0,1]$. Every infinite tail satisfies +\[ + \frac1{B-1}\le e(\xi)\le\frac{2|\Sigma|-1}{B-1}<1, +\] +so its code lies strictly inside each applicable prefix interval. +Distinct incompatible prefixes have positive gaps, since digits differ +by at least two while the remaining interval has width at most one unit +in the differing place. Place control $s$ at +$o_s=(4i_s,0,0)$, with $i_{A_h}=0$ and distinct positive integers +for the others. The code of $(s;L,R,J)$ is +$o_s+(e(L),e(R),e(J))$. +A rule with input prefixes $\alpha_1,\alpha_2,\alpha_3$ +and output prefixes $\alpha'_1,\alpha'_2,\alpha'_3$ gives boxes +\[ + Q_i=o_s+\prod_jI(\alpha_j),\qquad + Q_i'=o_{s'}+\prod_jI(\alpha'_j). +\] +Both families are separately disjoint by the preceding full-prefix +separation. In control-relative coordinates their exact maps are +\begin{equation}\label{eq:bb-balanced-affine-rule} + y_j=e(\alpha'_j)+B^{|\alpha_j|-|\alpha'_j|} + (x_j-e(\alpha_j)). +\end{equation} +The identity $e(\alpha\xi)=e(\alpha)+B^{-|\alpha|}e(\xi)$ +proves their action on every code. Initialized stacks are eventually +blank, with rational codes +$e(vb^\infty)=e(v)+B^{-|v|}d(b)/(B-1)$. +The affine determinant equals +$B^{\sum|\alpha_j|-\sum|\alpha'_j|}=1$, exactly by balance. +Apply Theorem~\ref{lem:bb-balanced-box-routing} to these full boxes. + +\emph{Every intermediate time.} +All half-widths are at most $1/2$, so that lemma uses $R=1$. +Sources have first coordinate at least four, since no rule leaves +$A_h$. Targets with nonhalt control have the same property. +For such a branch the initial expansion and final contraction preserve +first coordinate at least four. During deformation its center has +first coordinate at least $4\Lambda$. Every scaled halt target +center has first coordinate at most $\Lambda$, whereas the endpoints +of each nonhalt parking path have first coordinate at least +$4\Lambda$. Since $\Lambda+4<4\Lambda$, the original segment +cannot meet an obstacle cube around a halt target. Any encountered +obstacle has first coordinate at least $4\Lambda$, so its boundary +detour remains at least $4\Lambda-4$. Subtracting a half-width at +most one still leaves first coordinate greater than two. Hence +\begin{equation}\label{eq:bb-balanced-no-premature-event} + \Phi_\tau(Q_i)\subset\{x_1>2\}\quad(0\le\tau\le1) + \quad\text{for every branch with nonhalt target}. +\end{equation} +This includes delivery after halt targets have already been filled. + +Finally load $x_*=(4,0,0)$ along the straight segment to the rational +initial code using the translation part of Lemma~\ref{lem:bb-curl}. +It avoids $(-1,2)^3$ for a nonhalt initial control. Repeat the box +field from time one. Induction at integer times applies the exact +full-box maps; the finite compiler cycles reach a code in $(0,1)^3$ +precisely upon halting. Equation~\eqref{eq:bb-balanced-no-premature-event} +excludes every intermediate false visit. The residual proposition +gives the force and uniqueness; compact support gives all finite-slab +Sobolev conditions and uniformly bounded kinetic energy. Every choice +was finite and effective, including the obstacle detours. The input +enters only the first loading path, completing the proof. +\end{proof} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/clocks.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/clocks.tex new file mode 100644 index 0000000000000000000000000000000000000000..3e97258eabfa6007f448d8a895984258457bfcdd --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/clocks.tex @@ -0,0 +1,140 @@ +\section{Clock profiles for selected processors}\label{sec:clocks} + +Lemma~\ref{ba:log-clock} gives the common logarithmic change of time. +We now apply it to two Euclidean processors with different pressure +classes, and then use a companion's autonomous spatial clock to obtain +stationary or decaying forcing on the torus. In every case the clock +traverses every finite computational time; periodic, stationary and +decaying profiles remain separate choices. + +\subsection{Preserving the declared comparison classes} +\label{sec:bb-late-logclock} + +The two templates below use different whole-space pressure assumptions. +Slowing their trajectories preserves those declared comparison classes +because the new reference velocity retains the required regularity on +every finite physical-time interval. + +\begin{proposition}\label{prop:bb-late-logclock} +The template of Theorem~\ref{thm:bb-direction-shuttle} admits a force +in $L^2([0,\infty)\times\R^3)$ with the same material label and +event. The template of Theorem~\ref{thm:bb-guarded-history} admits +a force in $L^2([0,\infty);H^j(\R^3))$ for every integer $j\ge0$. +Both retain uniform compact support, zero initial velocity, bounded +mixed derivatives, their stated pressure and velocity comparison +classes, and finite effective prescriptions. +\end{proposition} +\begin{proof}\label{proof:bb-late-logclock} +Apply Lemma~\ref{ba:log-clock} to each template, including its loading +interval if present. Both are initially zero, have one compact support, +and have uniformly bounded mixed derivatives. The lemma gives the exact +residual and all mixed bounds; fixed support also gives +$\|f(t)\|_{H^j}\le C_j(1+t)^{-1}$ for every fixed $j$. + +On each finite interval the slowed reference field retains every Sobolev +regularity and bounded derivative required by its original comparison +class. Case (i) of Lemma~\ref{lem:b-comparison} therefore applies to the +direction shuttle's continuous $H^1$ pressure representative, and case +(iii) applies to the guarded-history processor's continuous $L^2$ +pressure gradient. Both constructed pressures are zero. + +The new path is $X(\log(1+t);a_0)$. The clock lemma preserves the event +and the effective prescription. In particular, loaded samples $1+k$ +occur at physical times $e^{1+k}-1$, whereas the aligned construction's +samples $k$ occur at $e^k-1$. These times have no finite accumulation. +The new forces have the stated temporal integrability; no periodicity +in physical time is asserted for them. +\end{proof} + +\subsection{The input-offset alternative}\label{bc:input-offset-section} +A fixed material label can also be retained by shifting the state charts +by the initial tape code. The complete planar routing and spatial-clock +construction for this choice belongs to +\cite[Theorem~4.1 and Section~5]{OpenAI379StationaryA2}. +The following application fixes its match with the present conventions. + +\begin{corollary}[Two profiles of the input-offset processor] +\label{bc:input-offset-event} +On $\T^3$, the fixed label $P=(1/4,1/4,0)$ and strip +$O=\{1/32h_n$. Mark the old head, scan right to $g$, +write the record and install the new frontier at $g+1$, then return to +the mark. All intervening history is nonfrontier, the new frontier +cell is empty, and there is only one mark. Hence the same rows apply +when $r_0=2$. There are $g-h_n-1$ continuing right moves, +$g-h_n$ continuing left moves, and four other instructions, giving +$2(g-h_n)+3$. The last row clears the mark and makes the work +movement; the invariant is restored with frontier $g+1$. This proves +finite completion, indefinite legality for a nonhalting run, and the +stated halt equivalence, including initial halting. +\end{proof} + +\subsection{From symbolic cylinders to closed rectangles} + +Radix encodings turn a push or pop of a tape letter into an affine map; +this is the generalized-shift viewpoint of +Moore~\cite{Moore1990,Moore1991}. The following calculation adds the +separation of full closed rectangles needed for smooth localization. + +\begin{lemma}[Separated rectangle codes]\label{ba:rectangles} +Let a deterministic partial tape table on an alphabet $\Gamma$ of size +$m$ have the two incoming properties of Lemma~\ref{lem:bb-onecell}. +Assign distinct odd digits $e(a)\in\{1,3,\ldots,2m-1\}$ and choose +an integer $B\ge2m+1$. Its local rules admit effective positive diagonal +affine maps of determinant one between finite families of closed planar +rectangles. Sources are pairwise separated, as are targets. Both the +minimal subdivision and the subdivision by both adjacent letters given +below realize every tape in their full symbolic cylinders. +\end{lemma} +\begin{proof}\label{ba:rectangles-proof} +Use Lemma~\ref{lem:bb-onecell} with digits $d(a)=e(a)$. Its digit +hypotheses hold for every $B\ge2m+1$. In the notation +\[ + C(a_1a_2\cdots)=\sum_{j\ge1}e(a_j)B^{-j},\quad + h_a(v)=\frac{e(a)+v}{B},\quad + I_{a_1\cdots a_l}=h_{a_1}\cdots h_{a_l}([0,1]), +\] +the left stream starts immediately left of the head and the right stream +starts at the head. Place state $s$ in $k_s+a[0,1]^2$ with a common +rational $a>0$. The minimal branch maps are exactly +\eqref{eq:bb-one-cell-branches}; scaling both charts by $a$ leaves +$\operatorname{diag}(B^{-d},B^d)$ unchanged. + +For the additional full subdivision, restrict the right- and stay-move +sources to $x\in I_\gamma$, for every full letter $\gamma$. +Their targets become $I_{\beta\gamma}\times[0,1]$ and +$I_\gamma\times I_\beta$, respectively, for written letter $\beta$. +The already split left-move targets remain +$[0,1]\times I_{\gamma\beta}$. At a fixed target state the +incoming direction is fixed, and the pair $(\beta,\gamma)$ +distinguishes the branches in every case. Thus the added subdivision +preserves separate target separation, while source separation follows +by restriction of the shared source rectangles. All these statements +concern the filled closed rectangles and arbitrary symbolic tails. + +For completeness the quantitative gaps remain valid for the entire +range $B\ge2m+1$: distinct first-digit intervals have gap at least +$B^{-1}$ and distinct second-digit intervals at least $B^{-2}$. +The source and target families therefore have within-state gaps at +least $aB^{-2}$; different state squares have their own chosen gaps. +Tail values lie between $1/(B-1)$ and $(2m-1)/(B-1)<1$. +An initial constant tail after $l$ digits contributes +$B^{-l}e(a_{\rm tail})/(B-1)$, so initialized codes are rational. +At checkpoints the history records, or the known absolute origin of +the record block, also recover the absolute work-head position. +\end{proof} + + +\subsection{Conventions for the remaining geometric realizations}\label{bc:section} +\label{bc:frontier-section} +Unless a different table is specified, subsequent routes use the move-first recorder of +Lemma~\ref{lem:bb-movefirst}, with initial frontier two. The controls +$(C_q,J_r,S_r,P_q,T_q)$ there are written $(W_q,P_r,B_r,C_q,D_q)$ +here, and its empty/frontier/record symbols $(e,F,r)$ are written +$(E,F,R_r)$. Permuting work, history and mark coordinates in every row +preserves every guard. This identifies the full partial table, its inverse +and the exact checkpoint count $2(2+n-h')+4$, including arbitrary allowed +tapes. A nonterminal branch means one with both endpoint controls +nonterminal; a final branch into a halt can enter the observer. + +The full branches are those of Lemma~\ref{lem:bb-onecell}. For an alphabet +of size $m$ we use one of the following explicitly indicated conventions: +\begin{equation}\label{bc:digits} +(B,\{d_a\})=(2m+2,\{1,3,\ldots,2m-1\}),\quad +(2m+1,\{1,3,\ldots,2m-1\}),\quad +(2m,\{0,2,\ldots,2m-2\}). +\end{equation} +All satisfy its digit bound and separation hypotheses. In the last +convention the full blank has digit zero; boundary codes remain in the +closed-rectangle and neighborhood conclusions. Write +$C(a_1a_2\cdots)=\sum_{j\ge1}d_{a_j}B^{-j}$ and +$I_v=\sum_{j=1}^{|v|}d_{v_j}B^{-j}+[0,B^{-|v|}]$. +A constant tail after $k$ positions contributes +$d_{\rm tail}B^{-k}/(B-1)$, so the initial codes are rational. +Guarded three-cell rules use Lemma~\ref{lem:bb-window-rectangles} with +$(a,b)=(1,2)$ after their own full-domain inverse has been proved. + +\subsection{Analytic conventions for the geometric variants}\label{bc:analytic-section} +The whole-space baseline in these variants means smooth +$u\in CH^2\cap C^1L^2$, bounded $u,\nabla u$ on finite intervals, +and a pressure representative in $CH^1$. When the competitor-gradient +condition is omitted explicitly, the other conditions remain unchanged. +Both cases fall under Lemma~\ref{lem:b-comparison}(i); separately stated +pressure classes are retained. The torus baseline is its classical torus +clause. Unless a projection is specified, the force is +\begin{equation}\label{bc:residual} +f_U=U_t+(U\cdot\nabla)U-\nu\Delta U,\qquad (u,p)=(U,0). +\end{equation} +Torus projection is the separate choice in +Proposition~\ref{prop:projection-l2}, with changed pressure. +Localized affine motion is supplied by Lemma~\ref{lem:bb-curl} on a +compact time interval, using effective derivative bounds, positive lower +scale bounds and the positive cutoff margins specified in each route. +The potential is \eqref{eq:bb-potential}; the resulting flow fixes every +region disjoint from its support. In particular exponential diagonal +scales and linear reciprocal scales have respectively generators +$\theta'\log D$ and $\diag(l'/l,-l'/l,0)$. + +\begin{lemma}[Finite forcing mechanisms]\label{bc:analytic} +A finite family of the preceding pulses, joined with flat time collars, +can be used once for initialization and repeated with period one thereafter. +It gives a smooth effective velocity and residual force with all mixed +derivatives uniformly bounded. In $\R^3$ both have one fixed compact +spatial support, and the velocity has uniformly bounded kinetic energy. +In a torus chart, +periodized curl or planar Hamiltonian pulses have zero spatial mean, as +does their residual force. Initial velocity and pressure are zero. +Uniqueness holds in the comparison classes of Section~\ref{sec:model}; +in the whole-space class the competitor's gradient bound can be omitted +if the remaining conditions are retained. +\end{lemma} +\begin{proof}\label{bc:analytic-proof} +Each pulse is a finite expression in rational data, effective smooth +switches, their derivatives, positive diagonal scales and logarithms. +Finite positive separation margins bound every cutoff derivative. A finite +maximum bounds a period and the loading interval, and repetitions preserve +that bound. To evaluate near a join, a coarse enclosure of time gives a +finite superset of possibly active pulses. Summing them avoids an exact +comparison of a computable time with an integer. The flat collars give +smoothness. Compact support gives every required spatial Sobolev bound. +Lemma~\ref{lem:p2-realization} gives the asserted solution and comparison; +on a torus the integral of each curl or Hamiltonian derivative vanishes, +and the convection term is a divergence. Its flow satisfies +$\det D\Phi_t=1$, because differentiating this determinant gives +$(\divg U)(t,\Phi_t)\det D\Phi_t=0$ and its initial value is one. +The velocity and acceleration identities in that lemma consequently apply +to these volume-preserving diffeomorphisms. +\end{proof} + +For later use, spatial chart changes are always made at the velocity level. +If $x=o+a y$, set $\widetilde U(t,x)=aU(t,(x-o)/a)$ and then compute +\eqref{bc:residual} at the prescribed physical $\nu$. The time and convection +terms scale by $a$, while the Laplacian term scales by $a^{-1}$. +Thus chart rescaling does not silently change the fixed physical viscosity. diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/compact-processors.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/compact-processors.tex new file mode 100644 index 0000000000000000000000000000000000000000..0e63498b8d27d83fcaa2b836a66b89f769c3b726 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/compact-processors.tex @@ -0,0 +1,189 @@ +\section{Compact support and onto slow clocks}\label{ba:euclidean} + +A whole-space processor can use arbitrarily separated finite lanes. +We shall construct a periodic cycle with fixed compact support and also +give a separate decaying force with the same material event. We first +establish the time change used for the latter choice. Its clock must tend +to infinity: traversing only a finite amount of machine time would not +preserve the halting event. + +\subsection{The logarithmic clock at every derivative order} + +\begin{lemma}[Logarithmic clock with full derivative bounds] +\label{ba:log-clock} +Let $W(s,x)$ be a smooth solenoidal field for $s\ge0$, initially zero, +with every mixed derivative bounded and support in one compact set $K$. +For fixed computable $\nu>0$, set +\[ + s(t)=\log(1+t),\quad \rho(t)=(1+t)^{-1},\quad + U(t,x)=\rho(t)W(s(t),x),\quad + F=U_t+(U\cdot\nabla)U-\nu\Delta U. +\] +Every derivative $\partial_t^k\partial_x^\alpha U$ and +$\partial_t^k\partial_x^\alpha F$ is uniformly +$O((1+t)^{-1-k})$ and belongs to space-time $L^2$. +Both supports lie in $K$. If $\Xi$ is the material flow of $W$, that +of $U$ is $\Xi(s(t),a)$, so every fixed spatial reachability event is +unchanged. Effective finite formulas for $W$ give effective formulas +for $U,F$ and all derivatives. +\end{lemma} +\begin{proof}\label{ba:log-clock-proof} +Since $s'=\rho$ and $\rho'=-\rho^2$, +\begin{equation}\label{ba:clock-rule} + \partial_t\{\rho^jY(s(t),x)\} + =\rho^{j+1}(\partial_s-j)Y(s(t),x). +\end{equation} +For $P_{k,j}(D)=\prod_{r=0}^{k-1}(D-j-r)$, with $P_{0,j}=1$, +induction yields +\begin{equation}\label{ba:clock-induction} + \partial_t^k\{\rho^jY(s(t),x)\} + =\rho^{j+k}P_{k,j}(\partial_s)Y(s(t),x). +\end{equation} +Spatial differentiation commutes with this identity. Taking $j=1$ +proves the velocity bound at every order. The residual is exactly +\begin{equation}\label{ba:clock-residual} + F=\rho^2\{W_s-W+(W\cdot\nabla)W\}(s(t),x) + -\nu\rho\Delta W(s(t),x). +\end{equation} +Every mixed derivative of the braces is bounded by the finite product +rule and the hypotheses. Apply \eqref{ba:clock-induction} with $j=2$ +and $j=1$ to obtain orders $\rho^{2+k}$ and $\rho^{1+k}$, +respectively. This gives the force bound, including every spatial +multi-index. In particular no temporal derivative of the convection +term has been omitted. + +Supports do not increase under differentiation or multiplication. +For either field $Z$, the squared integral of an indicated derivative +is at most +\[ + |K|C_{k,\alpha}^2\int_0^\infty(1+t)^{-2-2k}\,dt + =\frac{|K|C_{k,\alpha}^2}{1+2k}. +\] +The zero datum remains zero, so residual realization applies. +The chain rule shows that $\Xi(s(t),a)$ solves the $U$ trajectory +equation with initial label $a$; uniqueness identifies it with the +actual trajectory. The clock is increasing onto $[0,\infty)$ with +inverse $e^s-1$, so it loses no finite computational time. Finally +logarithm on positive arguments, the rational powers of $1+t$, and +the finite-index evaluation of the template and its derivatives are +effective. This proves all assertions. +\end{proof} + + +\subsection{Loaded Euclidean processors} + +\begin{theorem}[Two full-box processors on Euclidean space] +\label{ba:euclidean-boxes} +For every finite machine and input, and every fixed computable $\nu>0$, +either the move-first recorder of Lemma~\ref{lem:bb-movefirst} or the +six-rule recorder of Lemma~\ref{ba:six-compiler} yields effective smooth forcing on $\mathbb R^3$ with one +compact spatial support, all mixed derivatives bounded, and period one +for $t\ge1$, such that +\[ + \exists t\ge0:\ (\Phi_t(0))_1<-1 + \quad\Longleftrightarrow\quad\text{halting}. +\] +The zero-data solution is unique in Lemma~\ref{ba:realization}'s class, +has pressure zero and uniformly bounded energy. Separately, the six-rule +processor admits a force square-integrable on all space-time with the +same support and event. +\end{theorem} +\begin{proof}\label{ba:euclidean-boxes-proof} +Write $\Gamma$ for the full alphabet of the recorder being used. +For the six-rule table use initial frontier 2 and base $B=2|\Gamma|+2$. +Give nonhalting controls lanes $3i+[0,1]$ and halting controls lanes +$-3i+[0,1]$, enumerating each group from 1; the second coordinate is +$[0,1]$. The minimal subdivision has gap $B^{-2}$. Use full thickness +$[-1,1]$, heights $10i$, and the transported-cutoff construction in +Section~\ref{sec:ba-transported-localization}, with initial padding $1/(10B^3)$. +Target horizontal padding is at most $1/(10B^2)$, below half the gap; +vertical middle intervals are also separated. + +For the move-first table use a single halt lane $-3+[0,1]$, other lanes +$2+2j+[0,1]$, base $B=2|\Gamma|+1$, the minimal subdivision, thickness +$[-1,1]$, and heights $4i$. Use current-box padding $1/(10B^2)$. +The middle-phase separation is +$2(1+1/(10B^2))<4$; the planar gaps handle the other phases. +This localization has a fixed current padding, as distinct from the +transported initial padding in the six-rule version. + +The rational initial code $P_*$ is reached from zero along +$\theta(t)P_*$ by a localized translation during $[0,1]$. +Repeating the chosen cycle produces a template $W$ with one compact +support and bounded mixed derivatives. The code identity at times +$1+n$ follows by induction through the local rules; the respective +recorder invariant supplies every next checkpoint in finite positive +time. A halt lies below $-1$ in the first coordinate. In a nonhalting +run all branch endpoints have positive first coordinate, and +\eqref{eq:bb-convex-coordinate} keeps it positive throughout every cycle. +Loading is nonnegative. Lemma~\ref{ba:realization} completes the PDE +argument. Uniform support and boundedness give a uniform energy bound. +The separate square-integrable choice follows from +Lemma~\ref{ba:log-clock}, without claiming periodicity in physical +time for that choice. +\end{proof} + + +\subsection{Two realizations of a left frontier} + +\begin{proposition}[Separate columns or solid-box parking] +\label{prop:bb-mid-stream}\label{prop:bb-mid-parking} +Both left-frontier tables have compact whole-space realizations, +periodic after $t=1$, with fixed label zero and event $X_1(t;0)<-1/2$. +The stopping version can use distinct-height stream functions and +has uniqueness with pointwise-in-time $H^1$ comparison pressure. +The continuing version transports full solid boxes by evacuation, +reshaping and delivery, and represents every local step, including +post-halt idle computation. It has in particular uniqueness with +comparison pressure in $C([0,T];H^1)$. +\end{proposition} +\begin{proof}\label{proof:bb-mid-stream}\label{proof:bb-mid-parking} +Let $\Sigma$ be the full work--history--mark alphabet of the chosen +left-frontier table, including its record symbols and any halting idle +records in the continuing version. Use odd digits in base $B=2|\Sigma|+2$, offset $-2$ for $C_h$ and +$2,4,6,\ldots$ for other controls. The two head-relative fractions +and height zero give a rational initial code $Z_*$. The rightmost +nonempty history cell is the original cell $-2$, an absolute landmark. + +For the stopping table, apply the stream-function construction +\eqref{eq:bb-mid-stream-path} at heights $z_i=3i$. +Choose source and target column paddings no greater than $1/2$ and +one third of their respective family gaps. A middle layer padding +$1/2$ keeps distinct layers disjoint. The explicit thickening bound +following that construction proves the neighborhood action. +Write $Z_*=(x_*,y_*,0)$. With a flat switch $\theta$ from zero to one, +load the origin along $\theta(t)Z_*$ using the velocity +$\nabla\times(0,0,H)$, where +$H(t,x,y,z)=\theta'(t)\chi(x,y,z)(x_*y-y_*x)$. +Choose $\chi$ compactly supported in $\R^3$ and equal to one near the +entire segment. The gate $\theta'$ vanishes on the time collars. +All nonhalt source and target lower-left first coordinates are at +least two. Inequality~\eqref{eq:bb-mid-stream-safe} therefore +excludes the observer during each period; loading has nonnegative +first coordinate. Halt codes lie in $(-2,-1)$. + +For the continuing table retain its unrestricted first-row history +symbol and its idle work rules. Thicken every rectangle by $[-1,1]$. +Choose $L$ ten larger than the maximum of zero and every source or +target right endpoint. Reserve parking projections +$(L+4i,0)+[-1,1]^2$ and let $\delta$ be the minimum of one and the +gaps in each union of one rectangle family with these reservations. +Use padding $\delta/10$, travel height five, and $7N$ slots: evacuate +all sources by three translations each, reshape all parked boxes by +$\operatorname{diag}(1+\theta(\lambda_i-1),[1+\theta(\lambda_i-1)]^{-1},1)$, +and deliver by three translations each. Horizontal widths stay at +most one, vertical half-width is one, and the reservations miss both +original families. Lemma~\ref{lem:bb-lift-parking} proves exact action +on the whole boxes and their neighborhoods even with source--target +overlap. A first localized translation loads $Z_*$ from the origin. +The sampling identity is now valid for every $k\ge0$, not just until +halting: $\Phi_{1+k}(0)=Z(C_k)$ for the continued table. + +For a nonhalting run all used endpoint centers have first coordinate +at least two, parking centers are farther right, and half-widths are +at most $1/2$. Translation, parking strain, and waiting therefore +keep first coordinate positive. A halt checkpoint lies in $(-2,-1)$. +Proposition~\ref{prop:bb-realization} proves the analytic assertions +for both constructions. Their compact support also gives uniformly +bounded kinetic energy. +\end{proof} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/compilers.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/compilers.tex new file mode 100644 index 0000000000000000000000000000000000000000..b486b111883b0caafb7fb923f3c81ac2ebebf3ab --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/compilers.tex @@ -0,0 +1,307 @@ +\section{History records and complete symbolic domains} +\label{sec:bb-frontiers} + +The balanced-stack theorem is complete. The remaining realizations +use alternative recorders with tape data in two coordinates. +A motion of boxes is invertible. To use it for an ordinary machine, +we must retain whatever information an instruction erases. We use +finite history records in the sense of reversible computation, but +prove the local inverses below: reversibility of the initialized +execution would not by itself separate the full boxes. + +A work instruction is $r=(q,a)\mapsto(p_r,b_r,d_r)$, with +$d_r\in\{-1,0,1\}$. The work tape is indexed by $\Z$, starts with +head zero, and has only finitely many prescribed nonblank cells. +Halting states have no outgoing work instruction. Missing instructions +can be replaced by write-preserving stationary steps to a fresh halt +state. Unless a construction explicitly adds a dummy initial step, +an initially halting state is already a halt checkpoint. When a construction +uses a single halting state $h$, merge the original halting states and +redirect their incoming transitions; this preserves initial halting. In +the recorder tables $Q$ is the work-state set and $\Gamma$ the work +alphabet. Radix bases are chosen from the full cell alphabet, including +all history and mark tracks. + +\subsection{A one-cell code and its exact inverse test} + +A partial one-cell table sends a control and a scanned letter to a +new control, a written letter, and a displacement. Its two incoming +conditions are: the new control determines the displacement, and the +new control together with the written letter determines the entire +old control and read letter. + +\begin{lemma}[From one-cell tables to closed rectangles] +\label{lem:bb-onecell}\label{lem:bb-mid-prefix} +Give an alphabet of size $m$ digits separated by at least two, between +$0$ and $B-2$. Put +\[ +E(A)=\sum_{j\ge1}d(A_j)B^{-j},\qquad +I(v)=\sum_{j=1}^{|v|}d(v_j)B^{-j}+[0,B^{-|v|}]. +\] +For a head-relative tape $(a_j)_{j\in\Z}$ use the coordinates +\[ + (x,y)=\big(E(a_{-1}a_{-2}\cdots),E(a_0a_1\cdots)\big). +\] +After writing at cell zero, a displacement $e$ makes the old cell $e$ +the new cell zero. +A deterministic partial one-cell table satisfying the incoming +conditions acts, after separate state translations, by a finite list +of reciprocal affine maps on full closed rectangles. Each source +family and each target family is separately disjoint. For a rule +reading $a$, writing $b$, and moving by $e$, the branches are +\begin{equation}\label{eq:bb-one-cell-branches} +\begin{array}{c|c|c|c} +e&\text{source}&\text{target}&(x',y')\\\hline +1 &[0,1]\times I(a)&I(b)\times[0,1] + &((d(b)+x)/B,By-d(a))\\ +0 &[0,1]\times I(a)&[0,1]\times I(b) + &(x,y+(d(b)-d(a))/B)\\ +-1&I(c)\times I(a)&[0,1]\times(d(c)+I(b))/B + &(Bx-d(c),[d(c)+(d(b)+By-d(a))/B]/B). +\end{array} +\end{equation} +The last row is split over every letter $c$. Each linear part is +$\operatorname{diag}(B^{-e},B^e)$. With odd digits +$1,3,\ldots,2m-1$ and $B\in\{2m+1,2m+2\}$, every code lies in +the interior of its applicable rectangle, and unscaled within-family +gaps are at least $B^{-2}$. +\end{lemma} +\begin{proof} +The identity $E(aA)=(d(a)+E(A))/B$ gives all three formulas and their +action on the independent tails. At the first differing digit, +incompatible prefix intervals have a positive gap: the digit difference +is at least two while the child interval has length one in that scale. +Thus the source state, read letter, and any left split separate sources. +At one target state the displacement is fixed. For a right or stationary +move the written letter separates the relevant target coordinate; +for a left move the pair $(c,b)$ separates the two-letter prefix. +The incoming inverse condition rules out duplicates. These arguments +concern the complete intervals, including their endpoints. +For odd digits the infinite tail lies between $1/(B-1)$ and +$(2m-1)/(B-1)<1$, proving interiority. The longest target prefix has +length two, giving the asserted gap. Uniformly scaling state squares +by $s$ scales gaps by $s$ and leaves the linear parts unchanged. +\end{proof} + +\subsection{Moving the work head before recording} + +We first place a frontier to the right of every possible work head. +A temporary mark lets the history excursion return to the correct +cell even though its length grows with the computation. + +\begin{lemma}[Move-first recorder] +\label{lem:bb-movefirst}\label{lem:bb-mid-right-compiler} +There is an effective one-cell table satisfying the incoming conditions +whose checkpoint configurations simulate the work machine. After +$n$ work steps its frontier is at $n+2$, its records occupy +$2,\ldots,n+1$, and its temporary marks are all zero. Each nonhalting +checkpoint has a finite positive continuation to the next one, with +no intervening checkpoint. +\end{lemma} +\begin{proof} +Use letters $(c,\ell,j)$ with work letter $c$, history +$\ell\in\{e,F\}\sqcup\{r\}$ and mark $j\in\{0,1\}$. +The controls are $C_q,J_r,S_r,P_p,T_p$. The complete partial table is +\[ +\begin{array}{lll} + C_q:(a,\ell,0)&\mapsto J_r:(b_r,\ell,0),d_r&\ell\ne F,\\ + J_r:(c,\ell,0)&\mapsto S_r:(c,\ell,1),1&\ell\ne F,\\ + S_r:(c,\ell,0)&\mapsto S_r:(c,\ell,0),1&\ell\ne F,\\ + S_r:(c,F,0)&\mapsto P_{p_r}:(c,r,0),1,&\\ + P_p:(c,e,0)&\mapsto T_p:(c,F,0),-1,&\\ + T_p:(c,\ell,0)&\mapsto T_p:(c,\ell,0),-1&\ell\ne F,\\ + T_p:(c,\ell,1)&\mapsto C_p:(c,\ell,0),0&\ell\ne F. +\end{array} +\] +Initialize the frontier at two, all other history empty, and all marks +zero. At checkpoint $n$ the head satisfies $|h_n|\le n$. +The first row updates the work tape and moves to $h'\le n+1$, strictly +left of the frontier $f=n+2$. The second row marks $h'$. The forward +scan writes $r$ at $f$, puts a new frontier at $f+1$, and the backward +scan stops exactly at the mark, which it clears. Its length is +$2(f-h')+4$, so it is finite and positive. This proves the invariant +inductively, including the exact work update and halt equivalence. + +For the full-domain inverse, $r$ recovers the old work pair into $J_r$; +mark one distinguishes entry into $S_r$ from its mark-zero loop; +a written record determines entry into $P_p$; a written $F$ +distinguishes entry into $T_p$ from its loop; and entry into $C_p$ +uniquely restores mark one. Every destination has the single incoming +displacement displayed in the table. No invariant on remote cells +was used. +\end{proof} + +\subsection{Recording before the work-head displacement} + +The next table leaves its mark at the old work head. Its final step +performs the work displacement; storing that displacement in the +checkpoint control keeps incoming moves unambiguous. + +\begin{lemma}[Direction-recording scan] +\label{lem:bb-direction}\label{lem:bb-mid-mark-compiler} +Let $D=\{-1,0,1\}$ and let $O$ be either a singleton or $\{0,1\}$. +An effective one-cell table on +$\Gamma\times(\{\bot,F\}\sqcup\mathcal R)\times\{0,1\}\times O$, +where $\mathcal R=\{(q,e,a):q\text{ nonhalting},e\in D,a\in\Gamma\}$, +satisfies the incoming conditions. It preserves the $O$ track in +its physical cells. Starting with frontier at one, its checkpoint +at work step $n$ has frontier $n+1$, records at $1,\ldots,n$, zero +marks, and the correct work configuration. A step from head $i$ +takes $5+2(n-i)$ local rules. +\end{lemma} +\begin{proof}\label{proof:bb-mid-mark-compiler} +Use main controls $M(q,e)$, forward controls $G(r)$, and $A(p,d),B(p,d)$ +for every work state $p$ and $d\in D$, including pairs not produced by +a work instruction. Copy the $O$ component in each row. In the first +three rows use every $r=(q,e,a)\in\mathcal R$ with +$\delta(q,a)=(p,c,d)$. The final three rows apply independently to +every $(p,d)\in Q\times D$, including pairs that are not outputs of +any work instruction. The variables $v\in\Gamma$ and +$h\in\{\bot,F\}\sqcup\mathcal R$ range over all letters subject to +the displayed restrictions. The whole table is +\[ +\begin{array}{lll} + M(q,e):(a,h,0)&\mapsto G(r):(c,h,1),1&h\ne F,\\ + G(r):(v,h,0)&\mapsto G(r):(v,h,0),1&h\ne F,\\ + G(r):(v,F,0)&\mapsto A(p,d):(v,r,0),1,&\\ + A(p,d):(v,\bot,0)&\mapsto B(p,d):(v,F,0),-1,&\\ + B(p,d):(v,h,0)&\mapsto B(p,d):(v,h,0),-1&h\ne F,\\ + B(p,d):(v,h,1)&\mapsto M(p,d):(v,h,0),d&h\ne F. +\end{array} +\] +Starting at $M(q_0,0)$, the first row writes and marks the old head. +The scan reaches frontier $j=n+1$, stores its record, creates the +next frontier, returns to the unique mark and makes the work move. +The count is $2(j-i)+3=5+2(n-i)$. Since $i\le nh_n$, +the forward scan reaches the frontier, moves it one cell right, and +the return scan reaches the mark. Its neighboring-cell guard holds +because the new frontier is $p_n+1$. The last rule clears the mark +and performs the work displacement. Counting the two traversals and +endpoint actions gives $2(p_n-h_n)+1$; induction gives $|h_n|\le n$. + +For injectivity on all relative tapes, into Go the old cursor is +output offset $-1$: a mark there distinguishes entry from the loop, +and $r$ restores the overwritten work letter and old Ready control. +Into Back the old cursor is offset $+1$. An output pointer at $+2$ +identifies a log insertion, with record at $+1$ recovering $r$ and +old pair $(P,E)$. A nonpointer at $+2$ identifies the guarded loop. +Into Ready the corresponding Back control uniquely restores the +cleared mark. These are all possibilities, proving the full inverse. +\end{proof} + +\begin{lemma}[Closed rectangles for a finite guarded window] +\label{lem:bb-window-rectangles} +Suppose a finite partial injective local tape map reads and writes only +indices $[-a,b-1]$, then shifts the cursor by $e$, where +$-a\le e\le b$. Split its domain by every complete word in that +window. With gapped radix coding the input prefix lengths are +$(a,b)$ and output lengths $(a+e,b-e)$; the affine branch has linear +part $\operatorname{diag}(B^{-e},B^e)$. Both full rectangle families +are separately disjoint. +\end{lemma} +\begin{proof} +After the writes the new left prefix consists of old indices +$e-1,e-2,\ldots,-a$, and the right prefix of $e,e+1,\ldots,b-1$. +The two remaining tails are free and unchanged, so the image is the +whole output cylinder. Distinct source cylinders have disjoint +images by injectivity. If both pairs of output prefixes were +compatible, a common extension would belong to both images; hence +at least one coordinate has incompatible prefixes. The gapped +interval argument then separates the complete closed rectangles. +The prefix lengths give the two reciprocal scales directly. +\end{proof} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/geometry.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/geometry.tex new file mode 100644 index 0000000000000000000000000000000000000000..15679a19e3b23d1eecc4a9870493408bd295f241 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/geometry.tex @@ -0,0 +1,324 @@ +\section{Transporting complete boxes} +\label{sec:bb-boxes} + +We allow an instruction to change all three side lengths while +preserving their product. The geometric question is concrete: +given finitely many disjoint closed boxes and prescribed determinant-one +affine maps onto another disjoint family, can one carry out every map by +a smooth incompressible motion? The two families may overlap each +other. Consequently a destination cannot be occupied until every source +that obstructs it has been removed. + +We first extend an explicitly separated motion to a velocity field. +We then give two ways to produce that motion. Separate horizontal +projections permit a simple lift and transfer. For general solid boxes +we use parking and detours around the other occupied boxes. +Figure~\ref{fig:bb-routing} contrasts the height separation with the +evacuation order that makes overlapping source and target families harmless. + +\subsection{An affine motion and its curl extension} + +Throughout, a smooth switch is obtained by translating and rescaling +$\sigma$ in \eqref{eq:p2-step}, with its transition strictly inside +its allotted interval. Thus successive motions are stationary on +neighborhoods of their joining times. + +\begin{lemma}[A velocity on a neighborhood of each moving box] +\label{lem:bb-curl} +Let $K_i(t)=c_i(t)+D_i(t)K_i^0$, $1\le i\le N$, where $K_i^0$ is +an axis-parallel box, possibly with zero side lengths, and $D_i(t)$ is +positive diagonal with determinant one. Suppose the centers and scales +are smooth and constant near the ends of a compact time interval. +For the effective conclusion, assume computable endpoints for the +initial boxes $K_i^0$, effective evaluation of the centers' and scales' +derivatives, bounds for those derivatives, and positive lower bounds +for every scale on that interval. +If the coordinatewise $2\eta$ enlargements of the moving boxes are +pairwise disjoint and bounded, for a known $\eta>0$, a +compactly supported smooth divergence-free field realizes these motions +on open neighborhoods of the initial boxes. It vanishes near the time +endpoints. When all enlarged boxes lie in an interior torus chart, +the field extends to a mean-zero field on that torus. +The field is effective under the effective-data assumptions above; +smooth existence itself does not require computable data. +\end{lemma} +\begin{proof} +Choose a smooth cutoff $\chi_i$ which is one on the $\eta$ +enlargement of $K_i(t)$ and supported in its $2\eta$ enlargement, +using products of the effective switches. Put $y=x-c_i$ and +$L_i=\dot D_iD_i^{-1}$; then $\operatorname{tr}L_i=0$. +Take the curl of +\begin{equation}\label{eq:bb-potential} + \chi_i\{\tfrac12\dot c_i\times y+\tfrac13(L_i y)\times y\}. +\end{equation} +The identity +$\nabla\times(G\times y)=2G-y\operatorname{div}G+(y\cdot\nabla)G$ +shows that this curl equals $\dot c_i+L_i y$ on the plateau. +Disjoint supports permit summation over $i$. The path +$c_i(t)+D_i(t)D_i(t_0)^{-1}(x_0-c_i(t_0))$ has exactly that +derivative and remains in its prescribed box. ODE uniqueness proves +the formula. On the compact time interval the normalized matrix norm +has a finite bound $M$, computable under the effective-data assumptions; +an initial perturbation less than +$\eta/(2M)$ remains on the plateau. This proves the neighborhood +claim, also for zero-width initial boxes. +The potential is zero near time endpoints because the centers and +scales are constant there. Its support is bounded. Within a torus +chart extend the potentials by zero; periodic curls have zero integral. +\end{proof} + +\begin{proposition}[Fluid realization and a pressure refinement] +\label{prop:bb-realization} +Fix $\nu>0$. A finite collection of the preceding motions, repeated +with period one, or preceded by one finite loading interval, yields a +smooth prescribed velocity $U$ with $U(0)=0$. Suppose its spatial +support is contained in one compact set in $\R^3$, or its potentials +are contained in interior torus charts. Then +\begin{equation}\label{eq:bb-residual} + f=U_t+(U\cdot\nabla)U-\nu\Delta U +\end{equation} +has the same support and time periodicity and bounded mixed derivatives +of every order. The solution is $(U,0)$, with the uniqueness and +material-flow conclusions of Lemma~\ref{lem:p2-realization}. +In $\R^3$ its uniqueness statement also holds when the competing +pressure has an $H^1$ representative at each time, without requiring +continuity into $H^1$, while the other velocity hypotheses of +Section~\ref{sec:model} are retained. On the torus $U$ and $f$ have +zero mean. Under the effective-data assumptions of Lemma~\ref{lem:bb-curl}, +the formula is $f_0+\nu f_1$ with effective coefficients; +evaluation is effective for computable $\nu$, and relative to $\nu$ +otherwise. +\end{proposition} +\begin{proof} +The residual identity and Lemma~\ref{lem:b-comparison} give existence, +uniqueness and the material flow. In the whole-space pressure refinement +use case (ii): the reference field has compact support and smooth bounded +mixed derivatives, hence belongs to $CH^2\cap C^1L^2$ with bounded +velocity and gradient; the competing velocity and pointwise $H^1$ +pressure are exactly that case's hypotheses. No pressure continuity +in time is added. Integrating the residual on a torus uses +$\int U=0$, $\int\Delta U=0$ and +$\int(U\cdot\nabla)U=\int\operatorname{div}(U\otimes U)=0$. + +Each derivative of $e^{-1/s}$ for $s>0$ is a polynomial in $1/s$ +times $e^{-1/s}$. The estimate +$v^m e^{-v}\le(m+k)!v^{-k}$ supplies effective endpoint error bounds, +and the denominator defining $\sigma$ is at least $e^{-2}$. +Under those effective-data assumptions all positive scales have effective +positive lower bounds. Finite +compositions, differentiation, and the logarithms of positive computable +scales are therefore effective. At an approximate time, a coarse bound +gives a finite superset of possible translates of the zero-extended +unit template. This evaluates the periodic field without deciding +whether time is an integer. None of these operations iterates the +machine execution: the program contains the entire finite instruction +list. +\end{proof} + +\subsection{Three geometric schedules} + +For later use we describe the exact hypotheses of the schedules. +First suppose $P_i,Q_i\subset\R^2$ are finite families of closed +rectangles, possibly with zero side lengths, separately +pairwise disjoint, with affine maps +\[ + F_i(x)=q_i+\operatorname{diag}(\lambda_i,\lambda_i^{-1})(x-p_i), + \qquad \lambda_i>0, +\] +where $p_i,q_i$ are their centers, and require $F_i(P_i)=Q_i$. +Their side lengths have a common finite bound. Source and target rectangles +belonging to different families need not be disjoint. The smooth existence +statements allow arbitrary real rectangle coordinates and scales. For the +effective conclusions, assume rational rectangle endpoints and rational +scales, together with computable chosen heights and vertical half-widths; +then a rational side-length bound and positive gap margins can be computed. + +\begin{lemma}[Separated projections and parking] +\label{lem:bb-lift-parking} +These reciprocal maps have the following smooth compactly supported +unit-time realizations, stationary on time collars. They are effective +under the rational-data assumptions just stated. +\begin{enumerate} +\item For the products $P_i\times[z_0-h,z_0+h]$, with common $h\ge0$ +and $z_0\in\R$, lift all boxes with their source projections fixed, +transfer them at sufficiently separated private heights, and lower +them with their target projections fixed. The middle motion may use +$g_i(s)=\lambda_i^s$ or $g_i(s)=1+s(\lambda_i-1)$ and matrix +$\operatorname{diag}(g_i,g_i^{-1},1)$, with the center interpolated +linearly in $s$. Each horizontal width stays between its endpoint +widths. In the linear case every point satisfies +\begin{equation}\label{eq:bb-convex-coordinate} + X_1(s)=(1-s)X_1(0)+sX_1(1). +\end{equation} +\item Alternatively, choose disjoint parking rectangles away from both +families. Move every source to its parking site before delivering any +target, using an upward, horizontal, and downward translation. Reshape +at the parking sites, then deliver by the same three translations. +This uses $7N$ motions. The same schedule applies to assigned onto positive +diagonal determinant-one maps between rational solid boxes whose centers +lie in a common horizontal plane and whose source and target horizontal +projections are separately disjoint. Require both horizontal widths during +reshaping to stay inside their reserved parking rectangles and the travel +height above the common plane to exceed twice the largest vertical +half-width. +\end{enumerate} +Both constructions act on neighborhoods of the whole source boxes. +\end{lemma} +\begin{proof} +In the first construction choose padding smaller than a quarter of +the within-family horizontal gaps and choose height differences larger +than twice the padded vertical half-width. During lift and descent, +horizontal separation suffices. During transfer, vertical separation +suffices. The two choices of $g_i$ are positive and monotone between +$1$ and $\lambda_i$; their reciprocals are monotone as well. Thus the +width claim holds. The affine path is +$c_i(s)+\operatorname{diag}(g_i,g_i^{-1},1)(X_0-c_i(0))$. +Its first coordinate gives \eqref{eq:bb-convex-coordinate} exactly for +the linear choice. Lemma~\ref{lem:bb-curl} now applies. + +For the second construction choose padding smaller than the gaps in +each union of source projections with reserved parking rectangles, and +of target projections with those rectangles. In the evacuation pass, +vertical motion is separated from uncollected sources and parked boxes. +During delivery it is separated from already filled targets and boxes +still parked. At travel height, the moving box is above every resting +box. A shape change stays within its own reserved projection. +These are the occupied sets at each actual time; source--target +intersection causes no interference because all sources have left +before delivery starts. Lemma~\ref{lem:bb-curl} applies to each motion +with every other box fixed. Finite concatenation gives the required +neighborhood map. +\end{proof} + +\begin{figure}[ht] +\centering +\begin{tikzpicture}[x=.75cm,y=.65cm,>=stealth,font=\small] + \draw[gray] (0,0)--(5,0); + \draw[thick,blue!65!black,->] (.5,0)--(.5,2.4)--(4.2,2.4)--(4.2,.1); + \draw[thick,orange!80!black,->] (1.6,0)--(1.6,1.3)--(3.1,1.3)--(3.1,.1); + \node[below] at (1,0) {sources}; + \node[below] at (3.7,0) {targets}; + \node[above] at (2.5,2.6) {Separate height layers}; + \begin{scope}[xshift=5.1cm] + \node[draw,rounded corners,minimum width=2.6cm] (s) at (1.8,2.8) {all source boxes}; + \node[draw,rounded corners,minimum width=2.6cm] (p) at (1.8,1.1) {all boxes parked}; + \node[draw,rounded corners,minimum width=2.6cm] (t) at (1.8,-.6) {all target boxes}; + \draw[->,thick] (s)--(p) node[midway,right] {evacuate}; + \draw[->,thick] (p)--(t) node[midway,right] {deliver}; + \end{scope} +\end{tikzpicture} +\caption{The two separation mechanisms in +Lemma~\ref{lem:bb-lift-parking}. Left: horizontal projections separate +the lift and descent, and distinct heights separate the transfer; +the second horizontal coordinate is suppressed. Right: a temporal +schedule, not a spatial drawing. Every source is removed before any +target is occupied, so overlap between the two families is harmless.} +\label{fig:bb-routing} +\end{figure} + +There is also a useful stream-function implementation of the first +schedule. Suppose $a_i,a_i'$ are the lower left corners of $P_i,Q_i$. +At height $z_i$, put $d_i=a_i'-a_i$, $b_i=\log\lambda_i$ and +$g_i(s)=a_i+sd_i$. On a neighborhood of the swept rectangle use +\begin{equation}\label{eq:bb-mid-stream-path} + \xi_i(s)=g_i(s)+\operatorname{diag}(\lambda_i^s,\lambda_i^{-s})(\xi-a_i). +\end{equation} +The Hamiltonian +\[ + H_i=d_{i1}y-d_{i2}x+b_i(x-g_{i1})(y-g_{i2}) +\] +generates this motion. Put $\widehat H_i=\chi_iH_i$, where $\chi_i$ +is one near the whole sweep and supported in its reserved layer. Use +\[ + \dot s(\partial_y\widehat H_i,-\partial_x\widehat H_i,0). +\] +Disjoint height layers separate these cutoffs. Vertical phases use +$\nabla\times(0,x\chi_i,0)$, equal to $(0,0,1)$ on their column +plateaus. If $M=\max_i(1,\lambda_i,\lambda_i^{-1})$ and the column +plateau margins are $\delta,\delta'$, an initial thickening smaller than +$\min(\delta/(4M),\delta'/(4M),1/(8M))$ stays on every plateau. +Thus the affine formula also holds on open neighborhoods. For points of +the original rectangle it has the additional bound +\begin{equation}\label{eq:bb-mid-stream-safe} + X_1(s)\ge\min(a_{i1},a'_{i1}). +\end{equation} +The bound follows because the first relative coordinate in +\eqref{eq:bb-mid-stream-path} is nonnegative. + +\subsection{Solid boxes with overlapping projections} + +The preceding lift requires separate horizontal projections. We now +remove that restriction; this is needed when all three coordinates +encode independent stacks. + +\begin{theorem}[Expansion, obstacle detours, and delivery] +\label{lem:bb-balanced-box-routing} +Let $Q_i=a_i+\prod_{j=1}^3[-h_{ij},h_{ij}]$ and +$Q_i'=b_i+\prod_{j=1}^3[-k_{ij},k_{ij}]$ be rational solid boxes, +with positive half-widths, each family pairwise disjoint. Suppose +$s_{ij}=k_{ij}/h_{ij}$ and $\prod_js_{ij}=1$. An effective compactly +supported smooth solenoidal field, zero outside the time interval +$[1/4,3/4]$, has time-one map +\[ + a_i+y\longmapsto b_i+\operatorname{diag}(s_{i1},s_{i2},s_{i3})y +\] +on a neighborhood of each $Q_i$. +\end{theorem} +\begin{proof}\label{proof:bb-balanced-box-routing} +For an empty family take the zero field. Otherwise let +$R=\max(1,h_{ij},k_{ij})$. Choose a rational $\Lambda>10$ so that +centers in each of the lists $(\Lambda a_i)$ and $(\Lambda b_i)$ +are separated by more than $20R$ in maximum norm. This is possible +because distinct disjoint boxes have distinct centers. Let +\[ + K=\max(4\Lambda,|\Lambda a_{i1}|,|\Lambda b_{i1}|), + \qquad d_i=(K+30Ri,0,0). +\] +The $d_i$ are parking centers, separated from each other and both scaled +families by at least $30R$ in their first coordinate. + +First multiply all source centers by a common factor increasing from +$1$ to $\Lambda$, while keeping shapes fixed. Next change all shapes +at those separated centers by factors $s_{ij}^{\theta}$, +$0\le\theta\le1$. Each half-width is the geometric interpolation +$h_{ij}^{1-\theta}k_{ij}^{\theta}\le R$. +Move the boxes one at a time from $\Lambda a_i$ to $d_i$, then, +after all have been parked, from $d_i$ to $\Lambda b_i$. +Finally shrink all target centers by a common factor from $\Lambda$ +to $1$, with target shapes fixed. + +Here is a finite construction of every single-box path. Around each +stationary center place the closed cube of maximum-norm radius $4R$. +These cubes are disjoint since stationary centers are separated by +more than $20R$, and neither endpoint is in a cube. Start with the +straight segment between the endpoints. Its intersections with the +cubes are rational intervals, found by linear inequalities. Replace +each portion inside a cube by a polygonal path on its boundary: join +the entry point to a vertex of a containing face, use cube edges to a +face containing the exit point, and join to that exit point. The cube +is convex face by face, so these segments remain on its boundary; +no other cube meets them. A tangency needs no replacement. The +resulting rational polygonal path has distance at least $4R$ from +every stationary center. Traverse its segments with flat switches, +stopping to all orders at vertices. Its geometric image is unchanged, +so smoothing the time parameter does not reduce clearance. + +For a uniform localization margin, let $g_a$ be the minimum over +$i1$, and terminal codes lie strictly in $(-2,-1)\times(0,1)$. +The infinite tails are in $[\delta,1-\delta]$, +$\delta=1/(D-1)$, so finite-prefix decoding of length $b$ is possible +from error less than $(\delta/2)D^{-b}$ without a boundary ambiguity. + +Split full triples $[-1,1]$. By +Lemma~\ref{lem:bb-window-rectangles}, source prefix lengths $(1,2)$ +become $(1+d,2-d)$, target cylinders are complete, and both rectangle +families have gaps at least $D^{-3}$. Thicken by $[-1/4,1/4]$, +lift to height $4i$, use linear middle scale +$\mu_i=1+(D^{-d_i}-1)\theta$, and descend. Padding smaller than +$D^{-3}/4$ separates all phases. Repeating the pulse, zero on +$[0,1/12]$ and $[11/12,1]$, gives periodicity from zero without +loading. At a nonhalting branch's lift and descent the first +coordinate is greater than one; during the middle transfer the +particle's third coordinate is exactly $4i$, outside $(-1,1)$. +Thus even a horizontal route passing over the observation box cannot +cause a false visit. The integer samples and the compiler invariant +prove halting equivalence. The record count and pointer site $n+3$ +recover absolute indexing at checkpoints. + +For uniqueness apply Lemma~\ref{lem:b-comparison}(iii). +The explicit compactly supported smooth field lies in $CH^4\cap C^1H^2$ +on every finite interval and has pressure zero. The competing class +in the theorem is precisely case (iii), including its distributional +$CL^2$ gradient. Lemma~\ref{lem:b-gradient} cancels that gradient +against the solenoidal velocity difference without introducing a pressure +$L^2$ norm. Thus the velocity and pressure gradient are unique, while +pressure itself remains free up to a time-dependent spatial constant. +Proposition~\ref{prop:bb-late-logclock} gives the stated +decaying alternative. +\end{proof} + +\subsection{A flagged head and two-pass parking} +\label{sec:bb-two-pass-parking} + +\begin{theorem}\label{thm:bb-two-pass-parking} +For any machine and finitely specified initial tape, an effective +smooth force on $\R^3$, periodic from time zero, with one compact +spatial support and bounded mixed derivatives, realizes the event +\[ + \exists t\ge0:\quad X(t;0)\in(-6,-4)\times(-1,1)\times(-1,1) + \quad\Longleftrightarrow\quad\text{halting}. +\] +The zero-data velocity is unique among classical smooth solutions +with bounded $u,\nabla u$, $u\in C H^2\cap C^1L^2$ and $p\in C L^2$ +on every finite interval. The prescribed solution has uniformly +bounded kinetic energy. +\end{theorem} +\begin{proof}\label{proof:bb-two-pass-parking} +Merge terminal states into $q_\dagger$, send missing instructions +there by a stay step, and add a fresh initial state $q_*$, with no +incoming instruction, which writes back and stays while entering +the old initial state. For each normalized nonterminal rule +$r=(q,a)\mapsto(p_r,b_r,d_r)$ use cell letters +\[ + (w,h,j)\in\Gamma:=\mathcal A\times + (\{\circ,\star\}\sqcup\{[r]:r\in\mathcal R\})\times\{0,1\}, +\] +where $\mathcal A$ is the work alphabet and $\mathcal R$ is the +finite set of normalized instruction labels. Thus $\Gamma$ includes +all three tracks. +The complete table, with $h\ne\star$ wherever $h$ occurs, is +\[ +\begin{array}{lll} + M_q:(a,h,1)&\mapsto A_r:(b_r,h,0),d_r,\\ + A_r:(w,h,0)&\mapsto R_r:(w,h,1),1,\\ + R_r:(w,h,0)&\mapsto R_r:(w,h,0),1,\\ + R_r:(w,\star,0)&\mapsto B_{p_r}:(w,[r],0),1,\\ + B_q:(w,\circ,0)&\mapsto L_q:(w,\star,0),-1,\\ + L_q:(w,h,0)&\mapsto L_q:(w,h,0),-1,\\ + L_q:(w,h,1)&\mapsto M_q:(w,h,1),0. +\end{array} +\] +The destination fixes the incoming displacement. The record index +recovers the first row's old work pair; a flag distinguishes the +entries into $R_r$; a record distinguishes the entries into $B_q$; +a written frontier distinguishes entry and loop into $L_q$; +and entry into $M_q$ is the unique cell-preserving last row. +This proves the full one-cell inverse conditions. + +Initialize the sole flag at zero and the sole frontier at three, +with empty history elsewhere. At ready step $k$, only the work +head $i$ is flagged, records occupy $3,\ldots,k+2$, and the frontier +is $e_k=k+3$. The work rule clears the flag and moves to +$j=i+d_r\le e_k-2$, which is unflagged even for $d_r=0$. +It is flagged anew; the scan logs at $e_k$, advances the pointer, +returns, and preserves the ready flag. The two loop lengths are +$e_k-j-1$ and $e_k-j$, with five other rules, for a total +$2(e_k-j)+4$. Thus all scans terminate and ready halting is exact. + +Use odd digits in base $K=2|\Gamma|+2$, initial fractions $x_*,y_*$, +and state offsets $a_{M_{q_*}}=0$, $a_{M_{q_\dagger}}=-5$, and +$4,8,12,\ldots$ for the others. The code +$(a_s-x_*+x,y-y_*,0)$ starts at zero. Lemma~\ref{lem:bb-onecell} +gives $N$ full rectangle maps with scales $\lambda_i\in\{K^{-1},1,K\}$; +thicken by $[-1/4,1/4]$. The entire terminal block is inside the +observation box because $0-1$. Eventually constant tails are rational even for an +arbitrary finitely specified initial tape, and the pointer and record +count recover its absolute head position at ready checkpoints. + +For the required two-pass geometry, let $g$ be the minimum of one +and all positive separating coordinate gaps in either planar family, +and set $\epsilon=g/20$. Choose +\[ + C=20+\max(\{0\}\cup\{\text{right endpoints of source and target boxes}\}), + \qquad S_i=(C+4i,0,0). +\] +In a first pass give each source four consecutive slots: lift by ten, +translate above $S_i$, descend, and reshape there by the linear +reciprocal scale. In a second pass give each parked box three slots: +lift by ten, translate above its target, and descend. The total is +$7N$ slots, and every source is gone before a target is filled. +Widths remain at most one. Source gaps protect the first lift, +parking spacing protects strain and parking moves, target gaps protect +delivery, and travel height separates every horizontal transfer from +resting boxes. These inequalities remain strict under $2\epsilon$ +padding. Applying Lemma~\ref{lem:bb-curl} in chronological order +fixes every stationary box and gives the exact full-box map to the +moving one. Thus overlapping source and target families cause no +interference. + +Repeat the flat-ended template from zero and take its residual. +The integer sampling induction gives the table execution. In a +nonhalting run every endpoint box lies in $x_1>-1$; translations +interpolate corresponding endpoint points, strain occurs far to the +right, and waiting leaves the point fixed. The entire two-pass path +therefore remains in $x_1>-1$. A terminal sample lies inside the +observer. This proves the event for all times. + +For the exact pressure class use Lemma~\ref{lem:b-comparison}(iv). +The prescribed compactly supported smooth velocity satisfies the +reference $CH^2\cap C^1L^2$ and bounded-gradient conditions. The +competing velocity has precisely these bounds and a $CL^2$ pressure +representative, as that case requires. Its cutoff argument uses the +pressure itself, with error $CR^{-1}\|p\|_2\|u-U\|_2$, and assumes +no extra integrability of its derivative. The lemma gives velocity +uniqueness; the $L^2$ pressure representative is then zero. +Compact support and +bounded derivatives of the prescribed velocity give its uniform +energy bound and its global material flow. +\end{proof} + + +\subsection{A two-cell append and its guarded inverse}\label{bc:two-cell-section} +Use Lemma~\ref{lem:bb-window-compiler} with initial frontier $r_0=1$, +renaming Ready, Go and Back as $M,R,L$ and $(E,P)$ as +$(\perp,\star)$. The track order is work, mark, history. +The Ready history coordinate and the marked Back row remain unrestricted; +the unmarked Back row tests precisely the right-neighbor history. +Thus the full table, not only its initialized execution, is identical. +At checkpoint $n$, its frontier is $p_n=1+n>h_n$, where $h_n$ is +the work-head position, and the exact cycle length is $2(1+n-h_n)+1$. +Lemma~\ref{lem:bb-window-rectangles} applies with +$(a,b)=(1,2)$: the complete allowed triple fixes both history writes, +and its full image has prefix lengths $(1+e,2-e)$. + +\begin{theorem}[Guarded cylinders in a torus chart]\label{bc:guarded-torus} +On the unit torus, the fixed label $(1/8,0,0)$ and the strip +$\{x:x_1\pmod1\in(-1/4,0)\}$ realize halting by a general mean-zero +force with zero initial velocity and pressure. It is periodic after time +one and all its mixed derivatives are bounded. The torus comparison +class gives uniqueness. +\end{theorem} +\begin{proof}\label{bc:guarded-torus-proof} +Let $a$ be the augmented alphabet size and $k$ the control count in +Lemma~\ref{lem:bb-window-compiler}. Use zero-blank base $B=2a$, and enumerate +nonterminal and terminal states with positive integer indices $j\ge1$ +and first-coordinate offsets respectively +$L_0+3j$ and $-L_0-3j$, where $L_0=4k+ka^3+10$. +Refinement by triples gives at most $N=ka^3$ branches. Their source +prefix lengths are $(1,2)$ and image lengths $(1+e,2-e)$, so the +smallest possible grid gap is $B^{-3}$. If $P_i,Q_i$ are lower corners, +the branch map is +$Q_i+\diag(B^{-e_i},B^{e_i})(y-P_i)$. + +Choose three flat ramps $\alpha,\beta,\gamma$, active respectively in +$(1/8,1/4)$, $(3/8,5/8)$ and $(3/4,7/8)$. Set +\[ + c_i(t)=((1-\beta)P_i+\beta Q_i,\ i(\alpha-\gamma)), + \quad l_i=1-\beta+\beta B^{-e_i}. +\] +The moving rectangle has side lengths $l_i B^{-1}$ and +$l_i^{-1}B^{-2}$. Use a physical padding +$\varepsilon=B^{-3}/4$ around each moving rectangle in three dimensions. +During ascent and descent the planar endpoint gaps separate these +neighborhoods; during the affine phase the unit height gaps separate them. +Use Lemma~\ref{lem:bb-curl} for the paths +$c_i+\diag(l_i,l_i^{-1},1)(y-(P_i,0))$ and sum the disjoint fields. +The first coordinate is an endpoint convex combination even though the +paths are based at lower corners rather than centers. All supports lie +in $[-2L_0,2L_0]^3$, by the definitions of $L_0$ and $N$. + +Scale by $\rho=1/(32L_0)$, so the repeated mechanism is supported in +$[-1/16,1/16]^3$. Load the fixed label $(1/8,0,0)$ to the scaled +rational input code by a moving translation with cutoff radius $1/32$; +its support stays in $(-1/4,1/4)^3$. For a nonterminal initial code, +the entire first coordinate during loading is positive, and subsequent +nonterminal branches have first coordinate greater than $1/32$. +Terminal codes have first coordinate less than $-1/32$. Hence the stated +strip detects exactly terminal entry, including initial halting, without +any wraparound artifact. Periodize the compact curl fields and recompute +the force at physical $\nu$. Mean zero, bounded derivatives and comparison +follow from Lemma~\ref{bc:analytic}. +\end{proof} + +\subsection{A filled half-line and mean-corrected vertical motion} +\label{bc:halfline-section} +The next recorder starts with an infinite constant history tail rather +than a single frontier symbol. Its guard and its mean-zero vertical +realization both have independent roles. + +\begin{lemma}[History at a filled half-line]\label{bc:halfline-table} +A finite guarded table has a full-domain inverse and simulates the original +machine from a tape with a separately constant tail in each direction. +At checkpoint $n$ its nonempty history cells are exactly the absolute +indices below $2+n$. +\end{lemma} +\begin{proof}\label{bc:halfline-table-proof} +Normalize to one halt state $h$. For $i=(q,a)\in I=(Q\setminus\{h\})\times A$, +write $\delta(q,a)=(q_i,b_i,e_i)$. History letters are +$\mathcal H=\{\perp,\#\}\sqcup I$, with +$\mathcal H_+=\{\#\}\sqcup I$. The tracks are work, mark and history; +controls are $\mathsf R_q,\mathsf B_q,\mathsf T_i,\mathsf S_i$. +Write $\ell_j$ for the history at relative cell $j$. +Here is the complete table, with unmentioned cells unchanged: +\begin{equation}\label{bc:halfline-rules} +\begin{array}{c|c|c|l} +\text{input}&\text{output}&\text{move}&\text{condition}\\\hline +\mathsf R_q(a,0,k)&\mathsf T_i(b_i,0,k)&e_i&i=(q,a),\ q\ne h\\ +\mathsf T_i(c,0,k)&\mathsf S_i(c,1,k)&1&k\in\mathcal H_+\\ +\mathsf S_i(c,0,k)&\mathsf S_i(c,0,k)&1&k\in\mathcal H_+\\ +\mathsf S_i(c,0,\perp)&\mathsf B_{q_i}(c,0,i)&0&\ell_{+1}=\perp\\ +\mathsf B_q(c,0,k)&\mathsf B_q(c,0,k)&-1&k\in\mathcal H_+\\ +\mathsf B_q(c,1,k)&\mathsf R_q(c,0,k)&0&k\in\mathcal H_+. +\end{array} +\end{equation} +Initialize $\mathsf R_{q_0}$ at head zero with marks zero, history $\#$ +at every index below two and $\perp$ elsewhere. At checkpoint $n$, the +work head $p_n$ has $|p_n|\le n$ and the boundary is $r_n=2+n$. +After the work move, $p'=p_n+e_i\le n+1-1$, and halt codes $<-5$. Thicken the rectangles of +Lemma~\ref{lem:bb-onecell} by $[-1,1]$, give branch $i$ height $10i$, +and use the linear scale $g_i=1+\theta(\lambda_i-1)$ in the lift +schedule. A padding smaller than one tenth of the minimum of one +and all within-family planar gaps suffices. The middle strain has +potential $(0,0,(\dot g_i/g_i)(x_1-c_{i1})(x_2-c_{i2}))$. +Equation~\eqref{eq:bb-convex-coordinate} excludes every nonhalting +visit to $x_1<-5$. The table and routing are fixed for the machine; +only $x_*,y_*$ change with the input. The passive origin bit remains +at physical cell zero, so no absolute tape information is discarded. + +For the second case first merge all halting work states into a single +state $q_h$, redirecting incoming transitions and retaining initial halting. +Delete the passive track from the direction recorder, and now let +$\mathcal A$ denote that full alphabet. Use odd digits with +$B=2|\mathcal A|+2$ and +$\lambda=1/[16(J+1)]$, where $J$ counts the controls. Number them +from zero and set +\[ + S_s(x,y)=(A_s+\lambda x,1/4+\lambda y),\qquad + A_s=2\lambda\operatorname{index}(s)+ + \begin{cases}5/8,&s=M(q_h,e),\\1/4,&\text{otherwise}. + \end{cases} +\] +The nonhalt squares lie in $[1/4,3/8]\times[1/4,1/4+\lambda]$; +halt squares lie in $[5/8,3/4]\times[1/4,1/4+\lambda]$. +Write $m$ for the number of branches. Use coding height $1/4$, +branch heights $1/2+i/[4(m+1)]$, and +the same linear first scale. One hundredth of the minimum of +$1/16$, $1/[4(m+1)]$, and the source and target planar gaps is +valid padding; absent pair gaps are omitted. All supports lie inside +the cube, and all horizontal widths are at most $\lambda$. +A localized translation with padding $1/1000$ loads the rational +initial point from the fixed label in one unit interval. + +In a nonhalting period the center has first coordinate at most $3/8$ +and half-width at most $\lambda/2$, hence is below $1/2$; loading +has the same bound. Halting codes lie in the observer. The exact +sampling induction gives one table step per period, with checkpoint +cycle $2(k+1-h_k)+3$. The record block beginning at cell one +recovers absolute indexing at checkpoints. An initial halt is +observed at time one. +\end{proof} + + +\subsection{A one-time torus loader} + +The next placement uses a separate first interval to load the code. Only +the instruction cycle is then repeated, so periodicity begins at time one. + +\begin{theorem}[A separate one-unit loader on the torus] +\label{ba:loaded-torus} +For every machine and finite input and every fixed computable $\nu>0$, +there is an effective smooth +mean-zero force, one-periodic for $t\ge1$ with bounded mixed derivatives, +whose unique smooth zero-data solution with zero normalized pressure +satisfies +\[ + \exists t\ge0:\ \Phi_t(1/2,1/2,1/4) + \in(1/16,1/4)\times\mathbb T^2 + \quad\Longleftrightarrow\quad\text{halting}. +\] +Uniqueness holds in the classical class of Section~\ref{sec:model}. +\end{theorem} +\begin{proof}\label{ba:loaded-torus-proof} +Use the single-halt move-first recorder of +Lemma~\ref{lem:bb-movefirst}, without an entry state. Let +$\Gamma$ be its full alphabet and $N$ its number of controls. Put +$B=2|\Gamma|+1$, $a=1/(16N)$, the halt square at +$(1/8,1/4)+a[0,1]^2$, and the other squares at +$(1/2+2ja,1/4)+a[0,1]^2$, $0\le j\le N-2$. +Use the minimal subdivision, so right and stay moves are not split by +the left letter. Its gaps are at least $a/B^2$. +For $M$ branches choose +\[ + h=\frac1{64(M+1)},\quad Z_i=\frac12+\frac{i}{4(M+1)},\quad + \varepsilon=\min\{1/128,h/4,a/(4B^2)\}. +\] +Apply linear-first-scale full-box routing from height $z_0=1/4$. +Middle heights differ by $16h$; source and target gaps handle the +vertical phases. Centers lie in +$[1/8,5/8]\times[1/4,5/16]$, widths are at most $a$, and all padded +boxes lie in $(1/16,15/16)^3$. This is a construction on the specified +unit torus, with no change of physical viscosity. + +In the first unit interval translate a box of side $1/64$ from the +fixed label to the rational initial code, using Lemma~\ref{lem:bb-curl}. +The segment and a small padding lie inside the same chart. Repeat +only the instruction cycle afterward. Code induction proves the +checkpoint identities. A halting code has first coordinate in +$[1/8,3/16]$, including an initial halt reached by loading. For a +nonhalting run both centers of every used branch have first coordinate +at least $1/2$, with half-width at most $a/2$; loading has the same +lower center bound. Hence the particle always stays to the right of +$1/4$. Residual realization proves every analytic assertion. The +separate loading field accounts for the qualification $t\ge1$ in the +periodicity statement. +\end{proof} + + +\subsection{Repeated torus loading branches}\label{ba:torus} + +A loader can instead be one branch of every period. To keep its target +separate from all computational targets, place the initial code in a state +square with no incoming instruction. This condition concerns the entire +target family, not only the distinguished execution. We implement the +same startup principle first with full boxes, then with fixed columns. + +\begin{theorem}[A loader repeated as part of the processor] +\label{ba:periodic-torus} +For every finite machine and input, and every fixed computable $\nu>0$, +there is an effective smooth mean-zero force on the unit flat torus, +one-periodic from time zero, with all mixed derivatives bounded. Its +zero-data solution has pressure zero, is unique in the classical class +of Section~\ref{sec:model}, and satisfies +\[ + \exists t\ge0:\ \Phi_t(1/8,1/8,1/4) + \in\{5/81/(2B)$ from the endpoints +of $[0,1]$, so the new target lies strictly inside the entry square. +There is no other target in that square. Both enlarged branch lists +therefore remain separately separated, with gaps at least $a/B^2$. +The extra source is separated from all state squares. + +Number the branches, including loading, by $1\le i\le M$. Set +\[ + z_0=\tfrac14,\qquad h=\frac1{16(M+1)},\qquad + Z_i=\tfrac12+\frac{i}{4(M+1)},\qquad + \varepsilon=\frac1{10}\min(h,a/B^2). +\] +Thicken each planar source by $[z_0-h,z_0+h]$. Lift the resulting +full box to center height $Z_i$, move it horizontally, and lower it +to $z_0$. For an instruction with displacement $d_i$, use +$D_i=\operatorname{diag}(B^{-d_iw_2},B^{d_iw_2},1)$; +loading has $d_i=0$. Its center is the planar endpoint interpolation +plus $(Z_i-z_0)(w_1-w_3)e_3$. Adjacent middle heights are $4h$ apart, +while the padded half-thickness is $h+\varepsilon<2h$. +Source and target gaps handle the other phases. Horizontal half-widths +never exceed $a/2$, horizontal centers lie between $1/8$ and $3/4+a$, +and vertical centers lie between $1/4$ and $3/4$. The padded motions +are thus strictly inside the unit cube. Lemma~\ref{lem:bb-curl} gives a +chart field, extended periodically in space and time. Its zero time +collars give zero initial velocity. + +The first cycle loads the fixed particle. Each subsequent cycle maps +its exact code to the next local code until the first halt, or forever +in a nonhalting run. Lemma~\ref{lem:bb-movefirst} identifies the finite +checkpoint times with machine steps. The added entry state handles an +original initial halt. A halt code is in the target slab. For a +nonhalting execution every used source and target center, including the +loader, has first coordinate at most $3/8$. Exponential interpolation +keeps the center below that bound and the half-width below $a/2$; +the particle cannot reach $5/8$ at any intermediate time. The final +transition into a halt is not subject to this nonhalting-endpoint bound. +Lemma~\ref{ba:realization} gives the force, its mean, its effective +derivatives, and uniqueness. Repeating the loading field is harmless +to the initialized trajectory and makes the force periodic from zero. +\end{proof} + +\paragraph{A fixed-column implementation.}\label{bc:unit-periodic-section} +The same untargeted-entry condition also permits a repeated initializer +using fixed source and target columns. The next construction retains its +explicit column potentials and its fixed label; its middle motion uses +linear interpolation of the first planar scale. + +\begin{theorem}[A periodic initializer on the unit torus] +\label{bc:unit-periodic-event} +There is an effective halting realization on $\T^3$ with fixed label +$a_*=(3/8,1/4,1/2)$ and fixed strip $5/8R+2$. +Lemma~\ref{lem:bb-lift-parking} gives the full $7N$-motion schedule. + +Repeat this unit pulse from zero. Nonhalting endpoint boxes and all +parking boxes have nonnegative first coordinate. Translations preserve +that bound, and strain takes place in positive parking envelopes. +Therefore a nonhalting path never enters the negative observation box. +A halting code lies in $[-3,-2]\times[0,1]\times\{0\}$ inside it. +The residual proposition finishes the proof. Loading was a repeated +instruction, so no exceptional first-time force is required. +\end{proof} + + +\begin{remark}[A different observation regime] +For comparison, the distinct velocity-field detector of +\cite[Theorem~1.1(2) and Section~5]{OpenAI379EulerianC} uses +$\R^2\times\T$ and the event +$\int_{\{X_2>0\}\times\T}u_3>1/2$. Its force has globally bounded +mixed derivatives and horizontal support compact on each finite time +interval. The nonnegative scalar velocity has diffusion tails; after +loading its total mass is one. Its cutoff estimate gives loss +$\delta<1/24$, nonhalting mass at most $\delta$ in the observed half-space, +and halting mass above $3/4$. Those conclusions follow from the cited +advection--diffusion proof and have no uniform spatial support assertion. +They are a separate force and observation regime from the material test +proved here. +\end{remark} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/introduction.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..2f6645999c682c489b51f51d4b9075ba18a6c12f --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/introduction.tex @@ -0,0 +1,173 @@ +\section{Introduction}\label{sec:introduction} +A finite instruction can prescribe a volume-preserving affine map on a +box. A fluid realization must do more: it must move every point of that +box, preserve incompressibility outside it, and leave the other instructions +available. Source boxes and destination boxes can overlap. Moreover, a +particle used to report the answer must avoid the observation region +throughout every nonhalting transition. We study these requirements together. + +Our geometric result is Theorem~\ref{lem:bb-balanced-box-routing}. +It extends any finite collection of positive diagonal determinant-one maps +between separately disjoint rational solid boxes to the time-one map of +an effective smooth compactly supported incompressible velocity. The maps +hold on neighborhoods of the entire closed boxes. The proof separates +centers, changes shapes, evacuates the sources to storage, and delivers +boxes along paths avoiding everything still occupied. Positive margins make +the construction effective and permit additional observation guards. + +The first computational application, Theorem~\ref{thm:bb-balanced-three-stack}, +uses all three coordinates for symbolic data. Three stacks retain a tape +and its execution history. Every local instruction preserves the total +length of the prefixes it replaces, so its affine map has determinant one. +A fixed particle, initially in a fluid at rest, enters the fixed cube +$(-1,2)^3$ exactly when the encoded machine halts. The force is smooth, +compactly supported in space and periodic after a one-unit loading interval. +Its prescription uses the finite rule table, not the executed computation. +This application completes the main construction before we vary +initialization, history guards and observers. + +The passage from a symbolic instruction to a fluid observation begins +with retained history, which makes the instruction injective on its +entire domain of tapes, not just along the chosen computation. A rule +specifies finite prefixes and leaves their infinite tails free; gapped +radix expansions place the codes in separately disjoint closed source +and target boxes. Prefix replacement extends to an affine map of each +whole box, which smooth incompressible transport then realizes. +An additional geometric bound must exclude unintended visits to +the observer between successive rule times. Finally, the prescribed +velocity determines a body force, and an energy comparison identifies +the resulting solution in the declared class. Each later variant changes +one or more of these steps while retaining this separation of tasks. + +The remaining constructions answer more specific questions. Two tape +coordinates can be thickened into solid boxes, or their planar scale changes +can be compensated in the normal direction. A temporary mark, a persistent +mark, an explicit frontier and a boundary between occupied and unused +history give different partial instruction maps. We prove their inverses +on their full domains because this is what separates the target boxes. +A bounded observation box permits horizontal motion above it; a slab needs +a coordinate bound throughout that motion. Storage and obstacle detours +supply further alternatives. Loading once gives eventual periodicity, +whereas placing the initial code at the fixed label or repeating a loading +branch gives periodicity from time zero. Onto slow clocks give separate +decaying forces with derivative norms square-integrable in time. + +\subsection{Prior work and the role of forcing} +The computational starting point is Turing's finite machine model +\cite{Turing1936}. Landauer's discussion of retained intermediate information +\cite[Section~3]{Landauer1961} and Bennett's explicit history recording +\cite[Eqs.~(9)--(11)]{Bennett1973} explain how an irreversible computation +can be embedded in an invertible mechanism. We use that principle, but +prove the finite guarded tables and their complete inverses here. No +complexity bound or history-erasure procedure from those works is asserted +for these tables. + +Moore's generalized shifts turn symbolic updates into affine operations +on positional expansions \cite{Moore1990,Moore1991}. Our gapped expansions +serve the same purpose. Moore also realizes invertible generalized shifts +by smooth planar diffeomorphisms and three-dimensional flows +\cite[Section~6, Theorem~12 and its corollary]{Moore1991}. +Cardona, Miranda, Peralta-Salas and Presas extend the affine maps on +neighborhoods of separated planar blocks to an area-preserving disk +diffeomorphism, using contraction, transport, expansion and Moser's area +correction \cite[Proposition~5.1]{CardonaMirandaPeraltaSalasPresas2021}. +This is a geometric predecessor of the routing problem here. Our local +curl formulas implement positive diagonal determinant-one motions in +three dimensions directly; the proof supplies effective support and +neighborhood bounds and controls observation at intermediate times. + +Computational universality has been established for stationary Euler +flows with adapted geometry \cite{CardonaMirandaPeraltaSalasPresas2021}. +Cardona, Miranda and Peralta-Salas also construct universal Euclidean +Beltrami flows, with infinite energy, and robust simulations of +tape-bounded machines by unforced Navier--Stokes flows on a flat torus +\cite[arXiv version~3, Theorem~1 and Remark~29]{CardonaMirandaPeraltaSalas2023Beltrami}. +Dyhr, Gonz\'alez-Prieto, Miranda and Peralta-Salas obtain stationary +unforced Navier--Stokes universality using an adapted metric and the +Hodge Laplacian +\cite[Theorem~A]{DyhrGonzalezPrietoMirandaPeraltaSalas2026}. + +Here the ambient metric is fixed and flat, the viscosity is +prescribed, and the initial velocity is zero. The machine is placed in an +external body force. Given an explicit solenoidal velocity $U$, the identity +$f=U_t+(U\cdot\nabla)U-\nu\Delta U$ supplies that force. The mathematical +work is the effective construction of $U$ and its all-time observation, +followed by uniqueness in the stated comparison class. We do not assert a +regularity theorem for arbitrary fluid data. + +The companion \cite{OpenAI379Shear} gives an entry construction using +solenoidal shears, and \cite{OpenAI379Sheets} treats prefix instructions +and other planar or normal-compensated realizations. They explain adjacent +geometric choices; the proofs of the present full-box mechanisms are given +here. The final input-offset application explicitly imports the planar +processor and spatial clock of \cite{OpenAI379StationaryA2}, with the exact +parameters and conclusions stated in Section~\ref{bc:input-offset-section}. +The companion \cite{OpenAI379EulerianC} detects computation from an +integral of the velocity field on $\R^2\times\T$ via an +advection--diffusion estimate. The end of +Section~\ref{sec:bb-initialization} compares that event with the path of +one material particle studied here. + +\subsection{Equation, effectiveness and reading path} +Throughout $\nu>0$ is fixed, $\T=\R/\Z$, and the fluid equation on +$\R^3$ or the flat unit torus is +\begin{equation}\label{eq:box-NS} + u_t+(u\cdot\nabla)u=-\nabla p+\nu\Delta u+f, + \qquad \divg u=0,\qquad u(0)=0. +\end{equation} +A material label $a$ has path $\dot\Phi_t(a)=u(t,\Phi_t(a))$, +$\Phi_0(a)=a$. We also write $X(t;a)=\Phi_t(a)$. The smooth constructed +velocities have global material flows. On the torus pressure is normalized +to have mean zero. Whole-space pressure assumptions are specified in +Section~\ref{sec:model} and in the individual statements. Unless explicitly +projected, the force is a general body force and the constructed pressure +is zero. + +An effective field is a finite program that evaluates every requested +mixed derivative at computably supplied arguments to any prescribed +rational error and computes the bounds used in the proof. The finite +machine and its finite input determine the coefficients, cutoffs and +routing schedule. Evaluating the field cannot first compute the selected +machine run. All algorithmic statements concern computable $\nu$; +the same formulas are valid for arbitrary positive $\nu$, with evaluation +relative to that parameter. The encoded trajectories are exact real +trajectories. No uniform precision tolerance for an unbounded computation +is asserted. + +Section~\ref{sec:model} states the analytic comparison tools. +Section~\ref{sec:bb-boxes} proves the box motions, and +Section~\ref{sec:bb-balanced-three-stack} gives the balanced-stack application. +Sections~\ref{sec:bb-frontiers} and~\ref{ba:codes} establish reusable +recorders and full closed-rectangle coding; Section~\ref{ba:geometry} +supplies the common interpolation formulas. The subsequent constructions +can be read according to the requirement being changed: +\begin{center} +\begin{tabular}{@{}p{.24\textwidth}p{.71\textwidth}@{}} +\toprule +Choice & Where it is developed \\ +\midrule +Initialization and time periodicity & +Section~\ref{sec:bb-initialization} compares a separate loader, direct +placement of the initial code, and a loading branch repeated in every +period. An untargeted start square permits the last choice. \\[4pt] +History domains & +Sections~\ref{ba:marked-routes} and~\ref{sec:bb-guarded} distinguish +persistent marks, fresh history and neighboring-cell guards. Their +inverses on arbitrary allowed tapes determine the separated image boxes. +\\[4pt] +Observer geometry & +Section~\ref{ba:ordered-routes} treats bounded boxes, slabs and +half-spaces. Sections~\ref{sec:solid-routing} and~\ref{sec:torus-routing} +develop storage, detours and fixed torus charts with the corresponding +intermediate-time bounds. \\[4pt] +Decay and stationarity & +The logarithmic clock in Section~\ref{ba:euclidean} produces separate +decaying forces. Section~\ref{sec:clocks} treats further profile choices, +including the imported input-offset processor. \\ +\bottomrule +\end{tabular} +\end{center} +The five whole-space comparison classes are stated in +Lemma~\ref{lem:b-comparison}. Each alternative fixes its own label, +observer, support, pressure class and time dependence; these are separate +constructions rather than simultaneous guarantees for one force. diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/main.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..4e7906a98eb229d082ea574d5c2367b5645b34fc --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/main.tex @@ -0,0 +1,56 @@ +\documentclass[11pt]{article} +\ifdefined\pdftrailerid\pdftrailerid{}\fi +\ifdefined\pdfinfoomitdate\pdfinfoomitdate=1\fi +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern,amsmath,amssymb,amsthm,mathtools,booktabs,enumitem,microtype,longtable,array,tikz} +\usepackage[margin=1in]{geometry} +\usetikzlibrary{arrows.meta,positioning} +\usepackage[colorlinks=true,linkcolor=blue!50!black,citecolor=blue!50!black,urlcolor=blue!50!black]{hyperref} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition}\newtheorem{definition}[theorem]{Definition} +\theoremstyle{remark}\newtheorem{remark}[theorem]{Remark} +\newcommand{\R}{\mathbb R}\newcommand{\T}{\mathbb T}\newcommand{\Z}{\mathbb Z}\newcommand{\N}{\mathbb N}\newcommand{\Q}{\mathbb Q} +\DeclareMathOperator{\supp}{supp}\DeclareMathOperator{\divg}{div}\DeclareMathOperator{\diag}{diag}\DeclareMathOperator{\id}{id} +\hypersetup{pdftitle={Incompressible Box Transport and Finite Computation},pdfauthor={OpenAI}} +\title{Incompressible Box Transport and Finite Computation} +\author{OpenAI} +\date{October 6, 2026} +\begin{document}\maketitle +\begin{abstract} +We realize finite positive diagonal affine maps of determinant one by +effective smooth incompressible flows on neighborhoods of entire closed +rational solid boxes. The source and target families are each disjoint, but may +overlap each other. The construction uses localized curls, evacuation to +storage and obstacle detours. A balanced three-stack recorder then assigns +every machine and finite input a smooth Navier--Stokes force with one +compact spatial support, periodic after a loading interval, at any fixed +positive computable viscosity. The fluid starts at rest, and one fixed +particle enters one fixed open cube exactly when the machine halts. +Further constructions give fixed torus charts, periodicity from time zero, +alternative history guards and bounded or slab observers. Onto slow clocks +yield separate decaying forces. Each construction includes an all-time +observation proof, effective derivative bounds and a stated pressure +comparison class. +\end{abstract} +\input{introduction} +\input{analysis} +\input{geometry} +\input{balanced} +\input{compilers} +\input{coding-conventions} +\input{routing-conventions} +\input{initialization} +\input{compact-processors} +\input{persistent-history} +\input{guarded-history} +\input{observer-routing} +\input{solid-routing} +\input{torus-routing} +\input{clocks} +\bibliographystyle{plain} +\bibliography{references} +\end{document} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/observer-routing.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/observer-routing.tex new file mode 100644 index 0000000000000000000000000000000000000000..a5f6ba7fd12db7f57d5dce758dfda8556bac7df0 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/observer-routing.tex @@ -0,0 +1,982 @@ +\section{Routing choices dictated by the observer} +\label{ba:ordered-routes} + +The preceding processors move every branch by a prescribed affine map. +We now ask which parts of that motion must be controlled between the +integer times. A bounded observation box allows horizontal work above +the observer. A slab observer requires a bound on the horizontal +coordinate throughout the motion. Finally, a half-space observer can be +protected by moving all sources to storage before delivering any target. +These three requirements lead to the constructions below. + +\subsection{Four motions above a bounded observer} +\label{ba:four-stage-section} + +We first separate ascent, scaling, translation and descent. The two +planar motions occur at a fixed height, so their exclusion from the +bounded observer follows without a horizontal coordinate estimate. + +Let $D_i,E_i\subset\mathbb R^2$, $1\le i\le N$, be closed rational +axis-aligned rectangles with positive side lengths. Assume the $D_i$ +are pairwise disjoint and the $E_i$ are pairwise disjoint, and let +\[ + A_i(b)=c_i'+\operatorname{diag}(\lambda_i,\lambda_i^{-1})(b-c_i), + \qquad \lambda_i\in\mathbb Q_{>0},\qquad A_i(D_i)=E_i, +\] +where $c_i,c_i'$ are their centers. No separation between a source and +a target is assumed. All distances used to choose coordinate padding +below are distances for the maximum norm. + +Let $\vartheta=\sigma$ be the effective flat switch in +\eqref{eq:p2-step}. For a closed interval, possibly reduced to one +point, define +\[ + \chi_{[a,b],\epsilon}(v)= + \vartheta\!\left(\frac{2(v-a+\epsilon)}\epsilon\right) + \vartheta\!\left(\frac{2(b+\epsilon-v)}\epsilon\right). +\] +For a box $K$, let $\chi_{K,\epsilon}$ be the product over its three +coordinates. It is one on the $\epsilon/2$ enlargement of $K$ and +zero outside its $\epsilon$ enlargement. The effective profile estimates +following \eqref{eq:p2-step} apply to these products and rescalings. + +\begin{lemma}[Four-stage realization]\label{ba:four-stage} +The rectangle data determine effectively a smooth divergence-free field +$W(s,x)$ supported in a compact subset of $(0,1)\times\mathbb R^3$. +Its time-one map is $(b,z)\mapsto(A_i(b),z)$ on a neighborhood of +each $D_i\times\{0\}$. For a point of that plate, every planar +motion occurs at height $4i$, while ascent and descent preserve its +source and target planar coordinates, respectively. The scaling can +use either linear interpolation of its positive first factor or linear +interpolation of the logarithm of that factor. +\end{lemma} + +\begin{proof}\label{ba:four-stage-proof} +The empty family is realized by zero. Otherwise put $h_i=4i$, +$w_i=c_i'-c_i$, and +\[ + \Theta_k(s)=\vartheta(10s-(2k-1)),\qquad 1\le k\le4. +\] +Only the $k$th motion is active on the interval +$[(2k-1)/10,2k/10]$; the four intervals are disjoint. If +$a_{ij},a'_{ij}$ are the source and target half-widths, respectively, +take the four swept boxes +\[ + \begin{aligned} + K_{i1}&=D_i\times[0,h_i],\\ + K_{i2}&=\{c_i+(u_1,u_2):|u_j|\le\max(a_{ij},a'_{ij})\} + \times\{h_i\},\\ + K_{i3}&=\operatorname{box}(E_i-w_i,E_i)\times\{h_i\},\\ + K_{i4}&=E_i\times[0,h_i]. + \end{aligned} +\] +Here $\operatorname{box}$ denotes the smallest axis-aligned rectangle +containing the two displayed rectangles. Within each of the four +families these boxes are disjoint: source separation handles the first, +target separation the fourth, and distinct heights the other two. +Choose a positive rational $\epsilon<1$ smaller than one quarter of +every pairwise distance within these families. A family with fewer than +two members contributes no restriction. Its $\epsilon$ enlargements +are then still disjoint. + +Choose either +\[ + \mu_i=1+(\lambda_i-1)\Theta_2 + \quad\hbox{or}\quad \mu_i=\lambda_i^{\Theta_2}, + \qquad \gamma_i=\dot\mu_i/\mu_i. +\] +The factors $\mu_i$ and $\mu_i^{-1}$ stay between their respective +endpoint values. Use the coordinate potentials +\[ + \begin{aligned} + B_{i1}&=(0,h_i x_1,0),& + B_{i2}&=(0,0,(x_1-c_{i1})(x_2-c_{i2})),\\ + B_{i3}&=(0,0,w_{i1}x_2-w_{i2}x_1),& + B_{i4}&=(0,-h_i x_1,0). + \end{aligned} +\] +For the logarithmic-scale construction we also retain the alternative +translation potentials, with $e_3=(0,0,1)$, +\[ + B_{i1}=\tfrac12(h_ie_3)\times x,\qquad + B_{i3}=\tfrac12(w_{i1},w_{i2},0)\times x,\qquad + B_{i4}=\tfrac12(-h_ie_3)\times x. +\] +Their curls equal the same constant translation vectors. Their localized +fields need not agree away from the plates. Either choice gives +\[ + W=\sum_i\left[ + \dot\Theta_1\nabla\times(\chi_{K_{i1},\epsilon}B_{i1}) + +\gamma_i\nabla\times(\chi_{K_{i2},\epsilon}B_{i2}) + +\dot\Theta_3\nabla\times(\chi_{K_{i3},\epsilon}B_{i3}) + +\dot\Theta_4\nabla\times(\chi_{K_{i4},\epsilon}B_{i4})\right]. +\] +This is a finite sum of spatial curls. Its spatial support is compact, +its time support is contained in $[1/10,8/10]$, and the lower bound +$\mu_i\ge\min(1,\lambda_i)>0$ proves smoothness and effectivity. + +For $b\in D_i$, the successive paths are +\[ + \begin{array}{c|c} + \text{motion}&\text{position}\\\hline + \text{ascent}&(b,h_i\Theta_1)\\ + \text{scaling}&(c_i+\operatorname{diag}(\mu_i,\mu_i^{-1})(b-c_i),h_i)\\ + \text{translation}&(A_i(b)-w_i+\Theta_3w_i,h_i)\\ + \text{descent}&(A_i(b),h_i(1-\Theta_4)). + \end{array} +\] +Each path stays in its swept box. On a neighborhood of that box the +uncut curls are, in order, +\[ + h_ie_3,\qquad (x_1-c_{i1},-(x_2-c_{i2}),0),\qquad + (w_{i1},w_{i2},0),\qquad -h_ie_3. +\] +After multiplication by the time coefficients, these are the prescribed +affine velocities. The motion matrices are positive diagonal of determinant +one, the plateau margin is $\epsilon/2$, and the support padding is +$\epsilon$. The disjoint swept boxes therefore permit the plateau +argument of Lemma~\ref{lem:bb-curl}, with $\eta=\epsilon/2$. +It identifies these particular localized fields with the displayed +paths on the plateaux. The normalized diagonal factors are bounded by +$L_i=\max(1,\lambda_i,\lambda_i^{-1})$, so that lemma gives the +full initial neighborhood of radius $\epsilon/(4L_i)$. +\end{proof} + +We use the following precise Euclidean comparison class in the applications: +on each $[0,T]$, +\begin{equation}\label{ba:euclidean-comparison-class} + \begin{gathered} + u\in C([0,T];H^2(\mathbb R^3))\cap C^1([0,T];L^2(\mathbb R^3)),\\ + u,\nabla u\in L^\infty([0,T]\times\mathbb R^3),\qquad + p\in C([0,T];H^1(\mathbb R^3)). + \end{gathered} +\end{equation} +The pressure representative is part of this condition; it is zero for +our constructed solution. These comparison velocities and pressures +satisfy case (i) of Lemma~\ref{lem:b-comparison}. We retain the stated +bounded-gradient requirement here, although that case does not need it. + +That lemma also gives a smooth material diffeomorphism on every finite +interval. Differentiating its trajectory equation gives +$\dot J=(D_xu)(t,\Phi_t(a))J$, $J(0)=I$, for $J=D_a\Phi_t$. +Consequently +\begin{equation}\label{ba:material-volume} + \frac d{dt}\det J=(\nabla\cdot u)(t,\Phi_t(a))\det J=0, + \qquad \det J=1. +\end{equation} +The same proof applies to periodic lifts on the torus. The residual +formulas below are affine in viscosity, so they also define the asserted +solutions for any real $\nu>0$, with effectivity relative to $\nu$. + +\begin{theorem}[Two bounded-box material tests]\label{ba:bounded-box-tests} +Fix a positive computable viscosity $\nu$. A deterministic one-tape +machine and finite input effectively determine each of the following +general body forces on $[0,\infty)\times\mathbb R^3$. Both have zero +initial velocity, a unique global smooth velocity in +\eqref{ba:euclidean-comparison-class}, and constructed pressure zero. +\begin{enumerate} +\item The force and velocity have one fixed compact spatial support, all +mixed derivatives bounded, and period one for $t\ge1$. The particle +from $0$ enters $(-5,-2)\times(-1,2)\times(-1,1)$ exactly when the +machine halts. +\item The force and velocity have one fixed compact spatial support and, +for all $k\ge0$ and spatial multi-indices $\alpha$, satisfy +\begin{equation}\label{ba:eighteen-decay} + \|\partial_t^k\partial_x^\alpha u(t)\|_\infty+ + \|\partial_t^k\partial_x^\alpha f(t)\|_\infty + \le C_{k,\alpha}(1+t)^{-1-k}. +\end{equation} +The particle from $(2,0,0)$ enters +$(-1/2,3/2)\times(-1/2,3/2)\times(-1/2,1/2)$ exactly when the +machine halts. In particular $f\in L^2([0,\infty);H^m(\mathbb R^3))$ +for every integer $m\ge0$. +\end{enumerate} +The supports and constants may depend on the machine and input. The +labels and observers do not. All force derivatives admit evaluation to +any prescribed rational error by a finite program. +\end{theorem} + +\begin{proof}\label{ba:bounded-box-tests-proof} +Normalize to a single halt state $q_H$ and a complete nonhalting table, +as in Section~\ref{ba:codes}. Apply the move-first recorder of +Lemma~\ref{lem:bb-movefirst}. Its history frontier starts at cell $2$; +all other history cells are empty and all mark bits are zero. At +checkpoint $n$, the frontier is $g_n=n+2$, the work head satisfies +$|h_n|\le n$, and the next work instruction ending at $h'$ is completed +in exactly $4+2(g_n-h')$ local steps. Thus every required checkpoint +is reached after finitely many steps. The incoming-direction and +written-symbol inverse properties hold on the whole partial table. +The records recover the successive work instructions and hence the +absolute head position, even though the geometric code is head-relative. + +Let $m$ be the full alphabet size. Use odd digits $\beta(a)$ in +$\{1,3,\ldots,2m-1\}$, with base $B=2m+1$ in the first construction +and $B=2m+2$ in the second. Set +\[ + C(a_0a_1\cdots)=\sum_{r\ge0}\beta(a_r)B^{-r-1},\quad + P_a(v)=\frac{\beta(a)+v}{B},\quad D_a(v)=Bv-\beta(a),\quad + I_a=P_a([0,1]). +\] +Let $\xi$ encode the left string, nearest cell first, and $\eta$ +the string starting at the head. The complete right, stay and left +branch maps are \eqref{eq:bb-one-cell-branches}, with its digit +$d(a)$ equal to $\beta(a)$ and its move $e$ equal to $d$ here. +The left move is split over every full symbol $c$. The shared lemma +proves the full-rectangle endpoint formulas, arbitrary-tail action and +linear part $\operatorname{diag}(B^{-d},B^d)$. + +Translate each state square horizontally. In the first construction +give the halt state offset $-4$ and the other states offsets $2+2r$, +$r\ge0$; in the second use halt offset $0$ and other offsets $3r$, +$r\ge1$. Thus the code is $(o_s+\xi,\eta,0)$. +Lemma~\ref{lem:bb-onecell} applies with exactly these odd digits and +either displayed base: its incoming conditions are those supplied by +the move-first recorder, and \eqref{eq:bb-one-cell-branches} is its minimal +left-split branch list. Thus both complete closed rectangle families +are separately disjoint, with within-state gaps at least $B^{-2}$. +This proves the hypotheses of Lemma~\ref{ba:four-stage}; no separation +between the source and target families is required. + +Use its linear scale and coordinate potentials for the first construction; +use its logarithmic scale and symmetric translation potentials for the +second. In the latter case the scaling coefficient is exactly +$(\log\lambda_i)\dot\Theta_2$ and the scale matrix is +$\operatorname{diag}(\lambda_i^{\Theta_2},\lambda_i^{-\Theta_2})$. +Denote the resulting step field by $W_{\rm step}$. + +The initial code $P_{\rm in}$ is rational. A constant full-symbol +tail of digit $\beta_0$ after $M$ positions contributes +$B^{-M}\beta_0/(B-1)$; all other contributions are finite. For the +appropriate fixed label $a_*$, put $v_0=P_{\rm in}-a_*$ and let +$J_0$ be the smallest box containing $[a_*,P_{\rm in}]$. The loader +\[ + W_{\rm in}(s,x)=\frac d{ds}\vartheta(2s-1/2)\, + \nabla\times\left(\chi_{J_0,1}(x)\frac{v_0\times x}{2}\right) +\] +has the exact marked path $a_*+\vartheta(2s-1/2)v_0$, since the +uncut curl is $v_0$ and the entire segment lies in the plateau. Form +\[ + W(s,x)=W_{\rm in}(s,x)+\sum_{n\ge1}W_{\rm step}(s-n,x). +\] +The zero time collars make this smooth, initially zero, and periodic for +$s\ge1$, with common compact spatial support and bounded mixed derivatives. + +At time $s=1+k$ the marked particle is exactly the code after $k$ local +instructions, through the first halt or indefinitely in a nonhalting run. +This follows by induction from the full-rectangle maps. Each halt code +lies in its stated observation box, including one reached by loading an +initially halted machine. In a nonhalting run, the first loader has +$x_1\ge0$ and later nonhalt codes have $x_1\ge2$; for the second these +bounds are $x_1\ge2$ and $x_1\ge3$. Ascent and descent leave those +planar coordinates unchanged. Every planar motion has height $4i\ge4$, +outside both observers. The intervening stationary intervals add no new +positions. This proves exclusion at every real time. + +For the first case take $u=W$ and its residual force. For the second set +\[ + s(t)=\log(1+t),\quad \theta(t)=(1+t)^{-1},\quad + u(t,x)=\theta(t)W(s(t),x), +\] +whose force is +\[ + f=\theta^2\{-W+\partial_sW+(W\cdot\nabla)W\}(s(t),x) + -\nu\theta\Delta W(s(t),x). +\] +Lemma~\ref{ba:log-clock} applies to this fixed-support, bounded-derivative +template. Its identity +$\partial_t(\theta^jY(s(t)))=\theta^{j+1}(\partial_s-j)Y(s(t))$ +proves \eqref{ba:eighteen-decay} for every $k,\alpha$. Fixed support +then gives the stated $L^2_tH^m_x$ conclusion. Its clock is onto, with +inverse $t=e^s-1$, so the material path is the old path composed with +$s(t)$ and the event is unchanged. + +In both cases smoothness, fixed support and bounded derivatives on +finite time intervals put the reference velocity in $CH^2\cap C^1L^2$ +with bounded velocity and gradient. It is solenoidal and initially zero. +Lemma~\ref{lem:b-comparison}(i) therefore gives the exact solution +$(u,0)$ and uniqueness in \eqref{ba:euclidean-comparison-class}. +The effective profiles following \eqref{eq:p2-step}, applied to the +finite table, rational initial code, finitely many boxes and repeated +template, give all derivative evaluations. A coarse time approximation +encloses finitely many possible active translates, avoiding equality +tests at seams. The prescription never computes the machine's run. +\end{proof} + +\subsection{Small plates and a slab observer on the unit torus} +\label{ba:torus-plates-section} + +A slab observer has no height restriction, so elevation alone cannot +protect it. We now keep each nonhalting branch inside a narrow range of +first coordinates throughout its motion. The delayed-head recorder also +allows arbitrary finitely supported work data on both sides of the head. + +\begin{theorem}[Torus plates and square-integrable forcing] +\label{ba:torus-plates} +Fix a positive computable $\nu$. Every deterministic one-tape machine +with finitely specified tape, blank outside a finite set, effectively +determines a smooth mean-zero general force on +$\mathbb T^3=\mathbb R^3/\mathbb Z^3$, with bounded mixed derivatives +and period one for $t\ge1$. Its zero-data Navier--Stokes solution is +globally smooth and unique among smooth solutions, with pressure normalized +to mean zero and constructed pressure zero. For +$P_*=(1/4,1/2,1/4)$ and $X(t)=\Phi_t(P_*)$, the event +\begin{equation}\label{ba:torus-plate-event} + \exists t\ge0:\quad X_1(t)\pmod1\in(1/2,7/8) +\end{equation} +is equivalent to halting. + +A separate effective force has the same zero data, event, uniqueness and +mean-zero property, is supported in one compact sub-box of $(0,1)^3$, +has all mixed derivatives bounded, and satisfies +\begin{equation}\label{ba:cube-rate} + \|\widehat f(t,\cdot)\|_\infty=O((1+t)^{-2/3}). +\end{equation} +In particular $\widehat f\in L^2([0,\infty)\times\mathbb T^3)$. +\end{theorem} + +\begin{proof}\label{ba:torus-plates-proof} +Use Lemma~\ref{ba:six-compiler} with the frontier initially at cell $1$. +Its main control $M_{q,e}$ records the last work displacement $e$, initially +zero. In one work step it writes and marks the old head, records +$(q,e,a)$ at the frontier, returns to the mark, and only then makes the +work displacement. All other initial history cells are blank and every +mark is zero. At checkpoint $n$ the frontier is $n+1$, $|h_n|\le n$, +and the next checkpoint takes exactly $2(n+1-h_n)+3$ local steps. +These scans test history and marks, so the proof is unaffected by work +symbols on either side of the head. Main controls with halting $q$ have +no outgoing rules. The full-domain incoming properties are those of +the cited lemma. + +Let $S$ be the local state set, $N=|S|$, let $S_h$ be its halting main +states, and enumerate $S$ by $n(s)=0,\ldots,N-1$. Put +\[ + \ell=\frac1{16(N+1)},\quad z_0=\frac14,\quad + x_s=\frac18+2\ell n(s)+\frac12\mathbf1_{s\in S_h},\quad + T_s(\xi,\eta)=(x_s+\ell\xi,1/4+\ell\eta). +\] +Nonhalting squares lie in $1/8\le x_1<1/4$ and halting squares in +$5/8\le x_1<3/4$; distinct squares have gap at least $\ell$. +Give the full alphabet, of size $m$, odd digits in base $\beta=2m+1$. +Conjugating \eqref{eq:bb-one-cell-branches} by the source and target charts +gives separately disjoint rectangle families $R_j^0,R_j^1$ with positive +diagonal factors $\alpha_j,\alpha_j^{-1}$, +$\alpha_j\in\{\beta^{-1},1,\beta\}$. Every chart has the same +scale, so this remains the physical linear part. +Lemma~\ref{lem:bb-onecell}, with this uniform chart scaling, gives +within-family coordinate gaps at least $\ell/\beta^2$, including the +two-letter target intervals for left moves. + +For $1\le j\le L$, write the centers as $p_j^0,p_j^1$, the source +half-widths as $a_j,b_j$, and the target half-widths as +$\alpha_ja_j,\alpha_j^{-1}b_j$. All endpoint half-widths are at +most $\ell/2$. Choose +\[ + h_j=\frac12+\frac{j}{4(L+1)},\qquad + \epsilon=\frac1{100}\min\left(1,\frac\ell{\beta^2}, + \frac1{4(L+1)}\right). +\] +With $\theta(s)=\vartheta(2s-1/2)$ and +$\Theta_k(\tau)=\theta(3\tau-k+1)$ for $k=1,2,3$, define +\[ + \begin{aligned} + C_j(\tau)&=\big((1-\Theta_2)p_j^0+\Theta_2p_j^1, + z_0+(\Theta_1-\Theta_3)(h_j-z_0)\big),\\ + \sigma_j&=1+(\alpha_j-1)\Theta_2,\qquad + \lambda_j=\dot\sigma_j/\sigma_j,\\ + (w_{j1},w_{j2},w_{j3})&=(a_j\sigma_j,b_j/\sigma_j,0). + \end{aligned} +\] +These centers and half-widths describe moving plates. Their +$\epsilon$ enlargements are disjoint: the first third uses source +projections, the middle third distinct heights, and the last third +target projections. The padding is at most one hundredth of every +relevant gap. All plates and padding lie in a compact sub-box of +$(0,1)^3$, since their centers interpolate between the stated chart +centers, widths are at most $\ell$, heights lie between $1/4$ and +$3/4$, and $\ell\le1/32$, $\epsilon\le1/100$. + +For $w\ge0$ put +\[ + \kappa_\epsilon(w,v)= + \vartheta\!\left(\frac{2(w+\epsilon-v)}\epsilon\right) + \vartheta\!\left(\frac{2(w+\epsilon+v)}\epsilon\right),\qquad + \chi_j=\prod_{a=1}^3\kappa_\epsilon(w_{ja},x_a-C_{ja}). +\] +Writing $y=x-C_j$, use +\[ + A_j=\tfrac12\dot C_j\times y+(0,0,\lambda_jy_1y_2), + \qquad V(\tau,x)=\sum_j\nabla\times(\chi_jA_j). +\] +Extend the potentials by zero outside the chart. The support remains +away from its faces, so this gives a smooth torus field, zero near the +time endpoints. On the whole plateau of plate $j$ its velocity is +$\dot C_j+(\lambda_jy_1,-\lambda_jy_2,0)$; other summands vanish +there. Hence the path from $(p_j^0+(r,s),z_0)$ is exactly +\begin{equation}\label{ba:plate-path} + C_j(\tau)+(\sigma_j(\tau)r,\sigma_j(\tau)^{-1}s,0), + \qquad |r|\le a_j,\quad |s|\le b_j. +\end{equation} +It ends at the prescribed affine image. The plateau argument of +Lemma~\ref{lem:bb-curl} applies with +$D_j=\operatorname{diag}(\sigma_j,\sigma_j^{-1},1)$, +$\eta=\epsilon/2$, and diagonal bound +$\max(1,\alpha_j,\alpha_j^{-1})$: the required enlarged-box separation +was just proved. It gives the same motion on an initial neighborhood +of radius $\epsilon/[4\max(1,\alpha_j,\alpha_j^{-1})]$, with constant +normal displacement, and therefore includes boundary codes. + +The initial code $P_{\rm in}$ is rational, since relative to constant +blank tails only finitely many work and frontier digits differ. Load it +from $P_*$ along $C_*=(1-\theta)P_*+\theta P_{\rm in}$ using +\[ + V_0(t,x)=\nabla\times\left[ + \prod_{a=1}^3\kappa_{1/64}(0,x_a-C_{*,a}(t)) + \frac{\dot C_*(t)\times(x-C_*(t))}{2}\right]. +\] +The segment and its collar stay within the chart: its first coordinate +stays between $1/8$ and $3/4$, its second between $1/4$ and +$1/2+\ell$, and its third is $1/4$. Its plateau curl is $\dot C_*$. +Take $U=V_0$ on $[0,1]$ and $U(t)=V(t-n)$ on $[n,n+1]$ for $n\ge1$. +Time collars make this smooth and initially zero. It has fixed compact +chart support, bounded mixed derivatives, and period one after loading. +Define $f=U_t+(U\cdot\nabla)U-\nu\Delta U$ using the stated physical +viscosity. Both $U$ and $f$ have mean zero: $U$ is a curl, the +Laplacian integrates to zero, and +$(U\cdot\nabla)U=\operatorname{div}(U\otimes U)$. +The torus clause of Lemma~\ref{lem:b-comparison} applies to this +smooth, initially zero, solenoidal reference field and gives the unique +smooth solution $(U,0)$ with mean-zero pressure. + +Equations~\eqref{eq:bb-one-cell-branches} and \eqref{ba:plate-path} identify +the particle at time $1+k$ with the $k$th local configuration. The +recorder invariant ensures that a nonhalting computation continues +indefinitely. A halt, including an initial halt reached by loading, +puts the particle in $5/8\le X_1<3/4$, proving the event. For a +nonhalting computation the loader has $X_1\le1/4$ and every later +branch has both endpoint centers below $1/4$. Its center is their +convex interpolation and its first half-width is at most $\ell/2$. +Thus $00$; the cutoff +estimates and zero collars allow derivative evaluation at approximate real +arguments without tests for exact boundary equality. Only positive +arguments enter the cube root. The program repeats the entire local +table and never uses a computed execution. +\end{proof} + +\subsection{Storage and periodic forcing without a loader} +\label{ba:parking-section} + +The next construction absorbs initialization into the positions of the +state rectangles. A zero digit for the full blank symbol places the +initial left stack at zero; an input-dependent second-coordinate translation then +places the entire initial code at one fixed particle. To protect a +half-space observer during every period, we first evacuate all sources +to separate storage rectangles and only afterwards fill the targets. + +\begin{lemma}[Zero-blank coding]\label{ba:zero-blank-code} +Let an alphabet of size $m>1$ have digits $0,\ldots,m-1$, with full +blank digit zero. Set $B=m+1$, $\kappa=(m-1)/m$, and +\[ + \operatorname{val}(a_0a_1\cdots)=\sum_{r\ge0}a_rB^{-r-1},\qquad + I_a=\frac{a+[0,\kappa]}B,\qquad I_{a,b}=\frac{a+I_b}B. +\] +The code is injective, takes values in $[0,\kappa]$, and its distinct +one-letter and two-letter cylinders have positive rational gaps. For a +deterministic partial table with target-state-determined incoming direction +and incoming rule determined by target state and written symbol, separated +state translates of $[0,\kappa]^2$ yield separately disjoint full source +and target rectangles by the following maps in state-relative coordinates: +\begin{equation}\label{ba:zero-digit-maps} + \begin{array}{c|c|c|c} + d&\text{source}&(\xi',\eta')&\text{target}\\\hline + 1&[0,\kappa]\times I_a&((b+\xi)/B,B\eta-a)&I_b\times[0,\kappa]\\ + 0&[0,\kappa]\times I_a&(\xi,\eta+(b-a)/B)&[0,\kappa]\times I_b\\ + -1&I_c\times I_a&(B\xi-c,c/B+(b+B\eta-a)/B^2)& + [0,\kappa]\times I_{c,b}. + \end{array} +\end{equation} +The last row is split over all $c$. Each map has positive diagonal +linear part of determinant one and acts exactly on the full rectangle. +\end{lemma} + +\begin{proof}\label{ba:zero-blank-code-proof} +The maximum tail is $(m-1)/(B-1)=\kappa$, and +$(m-1+\kappa)/B=\kappa$. Consecutive first-digit intervals have +gap $(1-\kappa)/B>0$. Within one first-digit interval the second-digit +gaps are this quantity divided by $B$; different first digits already +give a gap. The interval containing a code recovers its first digit, +and $v\mapsto Bv-a$ then exposes the tail. Repetition proves +injectivity, including endpoint codes. + +Writing $a$ to $b$ changes the first right digit. A right move pushes +$b$ onto the left string and removes $a$ from the right; a left move +removes $c$ from the left and prepends $c,b$ to the old right tail. +These identities give \eqref{ba:zero-digit-maps}, including its images +and reciprocal slopes. Determinism and digit gaps separate sources by +state, read digit, and $c$ when needed. At one target state the common +incoming direction determines where the written digit is visible: in +$I_b$ on the left or right, or in $I_{c,b}$. The incoming-rule +hypothesis and digit gaps then separate the closed target rectangles. +\end{proof} + +\begin{lemma}[Evacuation, storage and delivery]\label{ba:parking} +Suppose $A_i:D_i\to E_i$, $1\le i\le N$, are the rational reciprocal +rectangle maps of Lemma~\ref{ba:four-stage}, with $N\ge1$ and every +$D_i\subset\{x_1<0\}$. There is an effective smooth divergence-free +field on $\mathbb R\times\mathbb R^3$, one-periodic in time, zero near +each integer time, and uniformly compactly supported in space, whose +one-period map is $(b,z)\mapsto(A_i(b),z)$ on a neighborhood of every +$D_i\times\{0\}$. If $E_i\subset\{x_1<0\}$, the entire +one-period path of each point in $D_i\times\{0\}$ remains in that +half-space. +\end{lemma} + +\begin{proof}\label{ba:parking-proof} +Let $d_i,b_i$ be the source and target centers, and let $a_{ij},a'_{ij}$ +be their half-widths. Put $a^*_{ij}=\max(a_{ij},a'_{ij})$. +Choose $\epsilon$ to be one quarter of the minimum of $1$ and all +pairwise maximum-norm distances within the source and target families; +omit pair entries when $N=1$. Define +\[ + \begin{gathered} + x_{\min}=\min\{x_1:(x_1,x_2)\in D_i\cup E_i\text{ for some }i\},\\ + R=\max(1,\max_i a^*_{i1}),\qquad J=4(R+1),\qquad + s_i=(x_{\min}-iJ,0). + \end{gathered} +\] +The storage rectangle at $s_i$ with half-widths $a^*_{ij}$ lies in +$x_1<0$. Its first-coordinate projection is separated by more than one +from every source and target and from the other storage projections: +the relevant gaps are at least $J-R>1$ and $J-2R>1$. + +We need only a localized translation and a localized reciprocal scaling. +On a time segment $[t_0,t_0+\delta]$, use +$g(t)=\vartheta(3(t-t_0)/\delta-1)$, whose derivative is supported +in the middle third. Using the cutoff $\kappa_\epsilon$ defined in +the proof of Theorem~\ref{ba:torus-plates}, for half-widths $a,b$ write +\[ + \chi_{a,b}(y)=\kappa_\epsilon(a,y_1) + \kappa_\epsilon(b,y_2)\kappa_\epsilon(0,y_3). +\] +A plate translation from center $P$ to $Q$ is produced by +\[ + C(t)=(1-g)P+gQ,\qquad + \nabla\times\left[ + \tfrac12\chi_{a,b}(x-C(t))\dot C(t)\times(x-C(t))\right]. +\] +On its plateau the velocity is $\dot C$ and the exact path is +$C(t)+(r,s,0)$. At storage center $P=(s_i,0)$, take +$q(t)=1+(\lambda_i-1)g(t)$ and the field +\[ + \nabla\times\left(0,0, + \frac{\dot q}{q}(x_1-P_1)(x_2-P_2) + \chi_{a^*_{i1},a^*_{i2}}(x-P)\right). +\] +It has the exact path $P+(qr,q^{-1}s,0)$. The denominator has the +positive lower bound $\min(1,\lambda_i)$, and the whole path lies in +the storage rectangle, because each half-width stays between its source +and target values. + +Partition a period into $7N$ equal segments and take $Z=2$. For each +$i$ in order, use four segments for +\[ + (d_i,0)\longrightarrow(d_i,Z)\longrightarrow(s_i,Z) + \longrightarrow(s_i,0),\qquad\text{then scale at }s_i. +\] +Only after all these evacuations, use three segments for each $i$ to +deliver its target shape along +\[ + (s_i,0)\longrightarrow(s_i,Z)\longrightarrow(b_i,Z) + \longrightarrow(b_i,0). +\] +Sum these segment fields and extend periodically. The middle-third +time switches give zero neighborhoods of every segment endpoint and +every integer time. The result is a smooth finite sum of curls with +one compact spatial support. + +This is the $7N$ schedule of Lemma~\ref{lem:bb-lift-parking}(ii). +Its separation hypotheses have explicit margins here. Unpadded +source-source and target-target gaps are at least $4\epsilon$, so their +$\epsilon$ enlargements leave gap at least $2\epsilon$. Storage +gaps exceed one, leaving more than $1-2\epsilon>0$ after padding. +At horizontal travel height the enlarged moving plate and every +enlarged stationary plate have vertical gap $2-2\epsilon>0$. +Every scaling stays in its reserved storage rectangle. The lemma +therefore gives simultaneous noninterference for evacuation and delivery, +including when a source meets a target. + +The localized potentials above have exactly these affine generators on +their plateaux, so the plateau argument of Lemma~\ref{lem:bb-curl} +gives endpoint +$(d_i+(r,s),0)\mapsto(b_i+(\lambda_i r,\lambda_i^{-1}s),0)$, +with normal displacement unchanged. Put +$M=\max_i(1,\lambda_i,\lambda_i^{-1})$ and +$d_*=\min(2\epsilon,1-2\epsilon,2-2\epsilon)>0$. +A neighborhood radius smaller than both $\epsilon/(8M)$ and +$d_*/(4M)$ retains the plateaux and all exclusion margins throughout +the concatenation. This applies the shared proofs to the displayed +potentials and does not identify their fields away from the plateaux. + +If $E_i$ is negative, each translation of an individual point joins two +negative first coordinates, and its linear interpolation remains negative. +Scaling occurs inside the negative storage rectangle. The point is +stationary during all other segments. This proves the asserted +whole-period exclusion. +\end{proof} + +\begin{theorem}[A periodic force with no loading interval] +\label{ba:periodic-parking} +Fix a positive computable $\nu$. A deterministic one-tape machine and +finite input word in cells $0,\ldots,L-1$, with other cells blank and +initial head zero, effectively determine a general body force on +$\mathbb R^3$ extending smoothly and one-periodically to all real times. +It has uniformly compact spatial support and bounded mixed derivatives. +Its zero-data solution has a unique global smooth velocity in +\eqref{ba:euclidean-comparison-class}, with constructed pressure zero, and +\[ + \exists t\ge0:\quad (\Phi_t((-2,0,0)))_1>0 + \quad\Longleftrightarrow\quad\text{the machine halts}. +\] +The fixed label is already the initial code; periodicity begins at zero. +\end{theorem} + +\begin{proof}\label{ba:periodic-parking-proof} +Insert a fresh nonhalting start state that preserves the read letter, +stays put and enters the original start state. Replace missing +nonhalting instructions by letter-preserving stay instructions to a halt +state. This finite normalization preserves the halting question, +including an initially halted machine, and guarantees a nonhalting +initial control and at least one rule. + +Apply the six-row delayed-head recorder of Lemma~\ref{ba:six-compiler} +with initial frontier $1$. Initially every other history cell is blank +and every mark is zero. The main control records $(q,e)$, where $e$ +is the preceding displacement, and the history record is $(q,e,a)$. +The old head is marked before the right scan and cleared on return, +immediately before displacement into the next main state. At checkpoint +$k$ the frontier is $k+1$ and the head $i$ satisfies $|i|\le k$; +the next checkpoint uses $2(k+1-i)+3\le4k+5$ local steps. The +incoming-direction and written-symbol properties hold on the full +domain, as required by Lemma~\ref{ba:zero-blank-code}. + +Give the full blank symbol digit zero and the other full symbols digits +$1,\ldots,m-1$. Order nonhalting local states with the initial state +first and assign offsets $-2h$, $h=1,2,\ldots$; assign halting main +states offsets $2h$, $h=1,2,\ldots$. Let $\eta_{\rm in}$ be the +initial right-stack value and put $y_*=-\eta_{\rm in}$. Only finitely +many full symbols are initially nonblank, so this is a finite rational +sum. Every cell left of the initial head is fully blank. The code +\[ + (x_\sigma+\xi,y_*+\eta,0) +\] +therefore places the initial configuration exactly at $(-2,0,0)$. +The input changes the common second-coordinate translation, while the +observed label and zero initial velocity remain fixed. + +Every finitely reached tape still has finite full-symbol support, so its +code is rational and can be decoded by rational digit extraction until +both tails are zero. At a checkpoint the leftmost nonempty history site +has absolute index $1$; its relative position also recovers the head's +absolute index. Thus this coding retains the initialized computation. + +Translate the rectangles of \eqref{ba:zero-digit-maps} by the indicated +state offsets and $y_*$. Lemma~\ref{ba:zero-blank-code} gives their +full affine action and separate source and target gaps. Since +$\kappa<1$, every nonhalting state block is strictly negative in the +first coordinate and every halting block strictly positive. Halting +states have no outgoing rules, so all sources are negative. Apply +Lemma~\ref{ba:parking} to obtain its periodic field $v$. Zero tails +can place a code on a rectangle boundary, which is included in that +lemma's full-neighborhood conclusion. + +Set +\[ + f=f_0+\nu f_1,\qquad + f_0=\partial_tv+(v\cdot\nabla)v,\qquad f_1=-\Delta v. +\] +The field and force are smooth, periodic, uniformly compactly supported, +and have all mixed derivatives bounded. Since $v$ vanishes near integer +times, its initial value is zero. Fixed support and bounded derivatives +give $v\in CH^2\cap C^1L^2$ and bounded $v,\nabla v$ on every finite +interval. Lemma~\ref{lem:b-comparison}(i) therefore supplies the exact +solution $(v,0)$, uniqueness in +\eqref{ba:euclidean-comparison-class}, and its global material flow. + +At time zero the marked particle is the initial code. If it is a +nonhalting code at integer $n$, its digits select a source rectangle and +the next period applies exactly that local instruction. Induction +identifies the integer-time codes through the first halt or forever. +Finite completion of every recorder scan identifies the original +machine at the checkpoint integers. A halt therefore reaches a positive +code. If the machine never halts, each used branch has a negative target +rectangle. Lemma~\ref{ba:parking} keeps its marked path negative for +that whole period, ruling out an intermediate false visit. + +Finally the force program uses finite normalization, the finite table, +the rational input shift, a finite rectangle list, rational storage and +separation data, $7N$ time segments and explicit cutoffs. All scaling +denominators have known positive lower bounds. The zero-collar and flat +profile estimates following \eqref{eq:p2-step} permit evaluation of the +repeated formula and every derivative from approximate real arguments +without exact seam tests. +Every period executes all branch maps, independently of the marked +particle's current state; the program never computes the input run. +\end{proof} + +\subsection{Direction-split marking and a bounded observer} +\label{ba:bounded-box-native} + +A stay instruction need not clear and reinstall a persistent mark. +We separate that case in the next table. Its geometric realization +uses a bounded observation box: during horizontal transfers the routing +height itself prevents a false visit. + +\begin{lemma}[Direction-split persistent marking] +\label{ba:split-mark-compiler} +In the notation of Lemma~\ref{ba:persistent-compiler}, there is an +effective partial finite table with a persistent checkpoint mark, +pointer at $p_n=n+2$, and both full-domain incoming properties of +Lemma~\ref{ba:rectangles}. A work step ending at $w'$ takes +$2(p_n-w')+4+\mathbf1_{\{d_\tau\ne0\}}$ local steps. +\end{lemma} + +\begin{proof}\label{ba:split-mark-compiler-proof} +Use full symbols $[g,e,l]$, with work letter $g$, mark $e\in\{0,1\}$, +and $l\in\{E,P\}\sqcup\{J_\tau\}$. Controls are $A_q$, +$B_\tau$ for moving instructions, $C_\tau,S_\tau$, and $D_q,R_q$. +For $\tau=(q,a)$ writing $b_\tau$, the complete table is +\[ +\begin{array}{c|c|c|c|r} +\text{control}&\text{read and guard}&\text{target}&\text{write}&d\\\hline +A_q&[a,1,l],\ d_\tau=0&C_\tau&[b_\tau,1,l]&0\\ +A_q&[a,1,l],\ d_\tau\ne0&B_\tau&[b_\tau,0,l]&d_\tau\\ +B_\tau&[g,0,l]&C_\tau&[g,1,l]&0\\ +C_\tau&[g,1,l],\ l\ne P&S_\tau&[g,1,l]&1\\ +S_\tau&[g,0,l],\ l\ne P&S_\tau&[g,0,l]&1\\ +S_\tau&[g,0,P]&D_{q^+_\tau}&[g,0,J_\tau]&1\\ +D_q&[g,0,E]&R_q&[g,0,P]&-1\\ +R_q&[g,0,l],\ l\ne P&R_q&[g,0,l]&-1\\ +R_q&[g,1,l],\ l\ne P&A_q&[g,1,l]&0. +\end{array} +\] +The first two rows use nonhalting $q$. In those rows and the +$B_\tau$ row, $l$ is unrestricted, including $P$; no additional +history guard is imposed. Initialize in $A_{q_0}$ at zero, with the +input work tape, a unique mark at zero, pointer at two, and empty +history elsewhere. + +At checkpoint $n$, the work move ends at +$w'=w_n+d_\tau\le n+11$. These three exclusions cover every real +time and prove the event equivalence independently of horizontal +excursions in the middle stage. The repeated processor installs every +local branch from the finite table; it does not depend on the executed +run or its outcome. +\end{proof} + + +\subsection{Separating vertical and planar potentials} + +\begin{theorem}[A decaying processor with phasewise planar potentials] +\label{ba:phasewise-flow} +At fixed computable $\nu>0$ there is an effective force on $\mathbb R^3$ +with one compact spatial support and all mixed derivatives of time order +$k$ bounded by $C_{k,\alpha}(1+t)^{-1-k}$, whose unique smooth +zero-data solution satisfies +\[ + \exists t\ge0:\ (\Phi_t(0))_1<-1/2 + \quad\Longleftrightarrow\quad\text{halting}. +\] +It uses the six-rule recorder with initial frontier 1, full subdivision +of the rectangles, and separate vertical-translation and planar +Hamiltonian potentials. The constructed pressure is zero and uniqueness +is in Lemma~\ref{ba:realization}'s whole-space class. +\end{theorem} +\begin{proof}\label{ba:phasewise-flow-proof} +Let $\Gamma$ be the full alphabet of the six-rule table with $r_0=1$. +Use odd digits in base $B=2|\Gamma|+1$ and its fully subdivided maps. Put halt lanes at $-2,-4,\ldots$ +and the other lanes at $2,4,\ldots$, each of width one. The second +coordinate lies in $[0,1]$. For the resulting rectangles $P_i,Q_i$, +centers $p_i,q_i$, and first scale $\lambda_i$, choose rational +$0<\varepsilon\le1/4$ smaller than one quarter of all within-source +and within-target maximum-norm distances. Empty pair lists impose no +condition. Thicken by $[-1,1]$ and put $H_i=4i$. + +On each third of the cycle use a flat progress function $\vartheta$ +from zero to one. Lifting uses $z_i=H_i\vartheta$ and potential +$A_i=(0,z_i'X_1,0)$, whose curl is $(0,0,z_i')$. +At height $H_i$, set $c_i=(1-\vartheta)p_i+\vartheta q_i$ and +$\mu_i=1-\vartheta+\vartheta\lambda_i$. Use the potential +$A_i=(0,0,\psi_i)$, where +\[ + \psi_i=c_{i1}'(X_2-c_{i2})-c_{i2}'(X_1-c_{i1}) + +\frac{\mu_i'}{\mu_i}(X_1-c_{i1})(X_2-c_{i2}). +\] +Its curl is +$(c_{i1}'+(\mu_i'/\mu_i)(X_1-c_{i1}), + c_{i2}'-(\mu_i'/\mu_i)(X_2-c_{i2}),0)$. +Thus it realizes reciprocal scaling about the interpolated center. +Descending uses the first potential with $z_i=H_i(1-\vartheta)$. +Multiply each potential by its current-box $\varepsilon$ cutoff +before taking the curl. Source gaps, distinct middle heights, and +target gaps separate the three stages. On the whole boxes and a +neighborhood the uncut formulas are exact. The first coordinate is +constant during vertical motion and is the convex interpolation of its +endpoints during the planar stage. + +For loading put $\theta_0(s)=\sigma(2s-1/2)$, which is zero near zero +and one near one. Let $P_*$ be the rational initial code. Load it in the +first unit interval by the planar path +$m(s)=\theta_0(s)((P_*)_1,(P_*)_2)$, localized around +$(m(s),0)+[-1,1]^3$, using potential +$(0,0,m_1'(X_2-m_2)-m_2'(X_1-m_1))$. +Repeat the three-phase instruction field afterward to obtain $W$. +Code induction and the delayed-head invariant prove the correspondence +at times $1+n$. Nonhalting codes have first coordinate at least 2, +so loading and the convex-path bound exclude $X_1<-1/2$ for every real +time. A halt code has first coordinate at most $-1$, including one +reached by loading an initially halted machine. Apply +Lemma~\ref{ba:log-clock}; physical code times are $e^{1+n}-1$. +Its support, derivative, event, and uniqueness conclusions give precisely +the claimed separate force choice. +\end{proof} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/persistent-history.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/persistent-history.tex new file mode 100644 index 0000000000000000000000000000000000000000..aabafc523af314f1b57807feeab325e694c5fff8 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/persistent-history.tex @@ -0,0 +1,512 @@ +\section{Persistent marks and guarded history routes} +\label{ba:marked-routes} + +The preceding recorders clear the work-head mark at each checkpoint. +We now retain that mark, or replace the moving history pointer by a +guarded boundary between occupied and unused cells. These changes give +different partial maps on arbitrary tapes, even though their initialized +executions simulate the same machine. We prove each inverse on its +declared domain before using it to separate the geometric branch images. +The use of retained history follows the reversible-computation idea of +Bennett~\cite{Bennett1973}; the local guards and geometric interfaces +are established here. + +In this section an input word occupies cells $0,1,\ldots$, the other +work cells are blank, and the initial head is at zero. All constructions +include initial halting. When one halt state $h$ is used, identify the +original halting states with $h$ and redirect incoming instructions; +there are no outgoing halting instructions to preserve. If necessary +adjoin an unreachable halt state. +We write $X(t;a)=\Phi_t(a)$ for the trajectory from $a$. + +\subsection{A persistent mark and input-dependent placement} +\label{ba:persistent-periodic} + +A force can be periodic from time zero if no separate loading interval +is needed. We achieve this by translating the initial control's coding +square so that the prescribed particle already represents the input. +The translation depends effectively on the finite input. First we give +the recorder that this periodic processor implements. + +\begin{lemma}[A recorder with a persistent work-head mark] +\label{ba:persistent-compiler} +Let a machine have work alphabet $\Gamma$, halt state $h$, and +instructions +$\gamma=(q,a)\mapsto(q^+_\gamma,a^+_\gamma,d_\gamma)$, +where $q\ne h$ and $d_\gamma\in\{-1,0,1\}$. +There is an effective finite partial one-head table with these properties. +At the checkpoint after $n$ work steps, it has the correct work tape, +state and head, a unique mark at that head, and a history pointer at +$p_n=n+2$. Each target control determines the incoming displacement; +the target control and written full cell symbol determine the source +control and read full symbol on the entire partial domain. If the next +work-head position is $w'=w_n+d_\gamma$, the next checkpoint is reached +after exactly $2(p_n-w')+4$ local steps. +\end{lemma} + +\begin{proof}\label{ba:persistent-compiler-proof} +A full symbol is $(a,e,s)\in\Gamma\times\{0,1\}\times\mathcal H$, +where $\mathcal H=\{E,P\}\sqcup\{r_\gamma\}$ records empty history, +a pointer, or an instruction. All displayed control families are +disjoint. The following is the complete table; free cell indices range +over their finite alphabets: +\[ +\begin{array}{c|c|c|c|r} +\text{control}&\text{read and guard}&\text{target}&\text{write}&d\\\hline +A_q&(a,1,s),\ s\ne P&B_\gamma&(a^+_\gamma,0,s)&d_\gamma\\ +B_\gamma&(c,0,s),\ s\ne P&R_\gamma&(c,1,s)&1\\ +R_\gamma&(c,0,s),\ s\ne P&R_\gamma&(c,0,s)&1\\ +R_\gamma&(c,0,P)&C_{q^+_\gamma}&(c,0,r_\gamma)&1\\ +C_q&(c,0,E)&L_q&(c,0,P)&-1\\ +L_q&(c,0,s),\ s\ne P&L_q&(c,0,s)&-1\\ +L_q&(c,1,s),\ s\ne P&A_q&(c,1,s)&0 +\end{array} +\] +The first row has $q\ne h$ and $\gamma=(q,a)$; there is no rule from +$A_h$. Initially the actual head and the unique mark are at zero, +the work tape is the input, and history is $E$ except for $P$ at cell 2. + +At checkpoint $n$, $|w_n|\le n$, so after the first row the head is at +$w'\le n+10}, +\] +maps $S_i$ onto $T_i$, with $c_i^S,c_i^T$ their centers. There is a +smooth nondecreasing switch $\eta:[0,1]\to[0,1]$, zero near 0 and one +near 1, for which either scale +path $r_i=\lambda_i^\eta$ or $r_i=1-\eta+\eta\lambda_i$ yields an +effective smooth compactly supported solenoidal unit-time field, zero +on time collars, realizing $(y,z)\mapsto(F_i(y),z)$ on the whole box +$S_i\times[-1,1]$ and a neighborhood of it. The paths are affine; +each horizontal half-width remains between its endpoint values, and the +horizontal sweep of each original box lies in the coordinate bounding +rectangle of $S_i$ and $T_i$. With the linear choice, a particle's first +coordinate is the convex +interpolation of its endpoint first coordinates. +\end{lemma} + +\begin{proof}\label{ba:two-interpolations-proof} +For $N=0$ take the zero field. For $N\ge1$ apply +Lemma~\ref{lem:bb-lift-parking}(i) with vertical half-width one. +Use the shared phase switches with $\eta=w_2$ and set +\[ + C_i(s)=\big((1-\eta)c_i^S+\eta c_i^T,\,6i(w_1-w_3)\big), + \qquad D_i(s)=\operatorname{diag}(r_i,r_i^{-1},1). +\] +The affine path is +$G_i(s,y)=C_i(s)+D_i(s)(y-(c_i^S,0))$. +Choose $\epsilon$ to be one quarter of the minimum of 1 and all +pairwise max-norm distances in the two planar lists, omitting empty +pair lists. The $\epsilon$-padded moving boxes are disjoint: source +and target gaps are at least $4\epsilon$ during the vertical phases, +and the middle-phase height spacing is $6>2(1+\epsilon)$. + +For later loading formulas, record the centered cutoff explicitly: +\[ + \chi(C,L,\epsilon;x)= + \prod_{j=1}^3\sigma\!\left(\frac{L_j+\epsilon+x_j-C_j}{\epsilon/2}\right) + \sigma\!\left(\frac{L_j+\epsilon-x_j+C_j}{\epsilon/2}\right). +\] +Here $L$ is the vector of half-widths; the plateau has padding +$\epsilon/2$ and the support has padding $\epsilon$. +If $L_i(s)$ are the moving half-widths, $Y=x-C_i(s)$ and +$A_i=D_i'D_i^{-1}$, the field supplied by +\eqref{eq:bb-potential} is +\begin{equation}\label{ba:affine-box-field} + V(s,x)=\sum_i\nabla\times\left\{ + \chi(C_i,L_i,\epsilon;x) + \left[\tfrac12 C_i'\times Y+\tfrac13(A_iY)\times Y\right] + \right\}. +\end{equation} +Indeed $\det D_i=1$, and the preceding separation verifies +Lemma~\ref{lem:bb-curl} with localization parameter $\epsilon/2$. +Its neighborhood conclusion applies with +$L_* =\max_i\max(1,\lambda_i,\lambda_i^{-1})$ because +$\|D_i(s)\|_\infty\le L_*$ and $D_i(0)=I$. +It therefore gives the stated affine motion on the full boxes and +on their initial max-norm neighborhoods of radius $\epsilon/(4L_*)$. +The paths are stationary for $s\le1/12$ and $s\ge11/12$. +Their finite center ranges and endpoint width bounds give common +compact support. The effective positive lower bound +$r_i\ge\min(1,\lambda_i)$ verifies the scale requirement. +For the linear scale, the first-coordinate identity is +\[ + (G_i(s,y))_1=(1-\eta)y_1+\eta(F_i(y_1,y_2))_1. +\] +The second coordinate need not interpolate its own endpoint values. +Instead, if $b_{i2}$ is the source's second half-width, convexity of the +reciprocal function gives +\begin{equation}\label{eq:ba-reciprocal-envelope} + \frac{b_{i2}}{(1-\eta)+\eta\lambda_i} + \le (1-\eta)b_{i2}+\eta\frac{b_{i2}}{\lambda_i}. +\end{equation} +The first half-width is exactly its endpoint interpolation. For the +exponential scale, convexity of the exponential gives the corresponding +upper bounds in both coordinates, since +$\lambda_i^{\pm\eta}\le(1-\eta)+\eta\lambda_i^{\pm1}$. +In either case the center is interpolated linearly and each half-width +is at most the interpolation of its endpoint half-widths. Therefore each +lower edge is at least the interpolation of the endpoint lower edges, +and each upper edge is at most the corresponding interpolation of upper +edges. This proves the claimed bounding rectangle for the entire sweep. +The individual endpoint-width bounds also follow directly from monotonicity +of the positive scales and their reciprocals. +\end{proof} + +The same construction applies to $P_i\times[-h,h]$ for any common +$h\ge0$, including plates and rectangles with zero side lengths, under +the hypotheses of Lemma~\ref{lem:bb-lift-parking}(i). Replace $6i$ by +heights $H_i$ whose pairwise gaps exceed $2h+2\varepsilon$, and choose +$\varepsilon$ below one third of every within-family planar gap. The +formula for $C_i$ uses the source and target centers in place of +$c_i^S,c_i^T$; its support padding is $\varepsilon$ and plateau padding +is $\varepsilon/2$. Source projections, distinct heights and target +projections separate the three phases in that order. Empty pair lists +impose no gap restriction, and the empty family gives the zero field. +Arbitrary real data give smooth existence; the effective-data assumptions +of the shared lemma give computable scales, derivative bounds and margins. +The same perturbation argument gives an open neighborhood even when a +side length is zero. + +\subsection{Transporting an initial cutoff} +\label{sec:ba-transported-localization} + +The transported-initial-cutoff convention is also useful. Write the +affine path as $G_i(t)x=J_i(t)x+g_i(t)$ and localize by +$\psi_i(G_i(t)^{-1}x)$, where $\psi_i$ has support padding +$\varepsilon_0$ around the initial box and equals one on a smaller +positive padding. +If $\lambda_i\in[B^{-1},B]$, its initial padding +$\varepsilon_0$ expands horizontally by at most $B$. Choose +$2B\varepsilon_0$ below every target gap, +$2\varepsilon_0$ below every source gap, and +$\varepsilon_0\le\varepsilon$. These transported supports stay +separated in the same three phases. The affine generator is +$v_i+A_ix$, with $A_i=\dot J_iJ_i^{-1}$ and +$v_i=\dot g_i-A_ig_i$. Its potential is +\[ + \tfrac12v_i\times x+\tfrac13(A_ix)\times x. +\] +The identity proved in Lemma~\ref{lem:bb-curl} gives the exact +generator on the transported plateau. Its neighborhood argument then +proves the same full-box endpoint map. The factor $B$ in the margin +choice is essential: transported padding does not stay fixed under +stretching. + +\subsection{Independent planar interpolation} + +For an observer that needs both planar coordinates to follow their own +endpoint interpolations, the reciprocal path is insufficient. The next +construction interpolates the two factors independently and compensates +the temporary planar area change in the third direction. Here the named +targets may be disjoint containers of the actual affine images; only the +image centers enter the motion. + +\begin{lemma}[Independent planar scales and normal compensation] +\label{ba:plate-routing} +Let $P_i,Q_i\subset\R^2$ be finite families of closed rectangles, +separately pairwise disjoint, and let assigned positive diagonal affine +maps $F_i$ satisfy $F_i(P_i)\subseteq Q_i$. Write their diagonal factors as +$\lambda_{i1}^*,\lambda_{i2}^*>0$ with product one. +There is a smooth compactly supported solenoidal unit-time field, zero on +time collars, whose endpoint map is $(y,z)\mapsto(F_i(y),z)$ on a +neighborhood of each entire plate $P_i\times\{0\}$. During the horizontal +phase both planar factors interpolate linearly, while the normal factor +compensates their product. Each planar coordinate of a point on the plate +is its convex endpoint interpolation. +\end{lemma} +\begin{proof}\label{ba:plate-routing-proof} +Use the height phases in Section~\ref{sec:ba-localization}. For source +center $p_i$, end its center path at its actual image $F_i(p_i)$; in the +onto case this is the named target center. Choose separated heights $H_i$ +as above and set +\[ + c_i=\bigl((1-w_2)p_i+w_2F_i(p_i),\,H_i(w_1-w_3)\bigr), +\] +\[ + \lambda_{ij}=1-w_2+w_2\lambda_{ij}^*,\qquad + D_i=\operatorname{diag}\bigl( + \lambda_{i1},\lambda_{i2},(\lambda_{i1}\lambda_{i2})^{-1}\bigr). +\] +The volume-preserving path has logarithmic derivative +\[ + T_i=\dot D_iD_i^{-1}=\operatorname{diag}\left( + \frac{\dot\lambda_{i1}}{\lambda_{i1}}, + \frac{\dot\lambda_{i2}}{\lambda_{i2}}, + -\frac{\dot\lambda_{i1}}{\lambda_{i1}} + -\frac{\dot\lambda_{i2}}{\lambda_{i2}}\right). +\] +This matrix has trace zero, so \eqref{eq:bb-potential} localized +around the moving plate gives the desired field. Its planar motion is +$c_i+(\lambda_{i1}(y_1-p_{i1}),\lambda_{i2}(y_2-p_{i2}),0)$. +Normal displacement changes by the factor +$(\lambda_{i1}\lambda_{i2})^{-1}$. The factors have positive +lower bounds; choose the initial thickness less than their product's +minimum times the normal plateau width. A small enlargement of the +planar rectangle is allowed by the positive collars as well. Thus a +whole thin neighborhood follows the volume-preserving affine motion. +The normal factor returns to one at the endpoint. The final plate image +is contained in $Q_i\times\{0\}$. Source and target-container +gaps protect the vertical phases and distinct heights protect the +middle phase. Linear interpolation of each planar factor gives both +convex-coordinate identities on the plate. +This proves smooth existence for arbitrary real data. Under the effective +input assumptions of Lemma~\ref{lem:bb-curl}, the positive scale bounds and +finite gap margins can be computed and the construction is effective. +\end{proof} + +\subsection{Forcing and effective evaluation} + +\begin{lemma}[Residual forcing for the finite processors]\label{ba:realization} +Fix computable $\nu>0$. Let $W$ be smooth, solenoidal, initially zero, +with support in one compact subset of $\mathbb R^3$ and every mixed +derivative bounded. Then +\begin{equation}\label{ba:residual} + F_W=W_t+(W\cdot\nabla)W-\nu\Delta W +\end{equation} +has the same support and derivative properties. The zero-data solution +$(W,0)$ is unique among smooth solutions with +$u\in C_tH^2\cap C_t^1L^2$, bounded $u$ on finite intervals, and +$p\in C_tH^1$. The corresponding torus assertion holds in the +classical comparison class of Section~\ref{sec:model}. A sum of curls +in a torus chart gives both $W$ and $F_W$ mean zero. Finite formulas +from the effective-data instances of the preceding constructions, finite +loading, and repetition of one cycle give effective evaluation of every +force derivative. +\end{lemma} +\begin{proof}\label{ba:realization-proof} +Fixed compact support and bounded mixed derivatives imply all reference +velocity hypotheses of Lemma~\ref{lem:b-comparison}. Case (i) gives +exactly the stated whole-space comparison class, without a competing +gradient bound; its torus clause gives the stated classical comparison +class. The same lemma provides the pressure normalization and global +material flow. The product rule applied to \eqref{ba:residual} +proves the force's support and derivative bounds. A chart curl has +zero mean, and integration of the residual uses +$\int\Delta W=0$ and +$\int(W\cdot\nabla)W=\int\operatorname{div}(W\otimes W)=0$. +For these effective-data instances, gate derivatives and seam evaluation are +those of \eqref{eq:p2-step} and Proposition~\ref{prop:bb-realization}. +The explicit affine scales and every reciprocal denominator have positive +computable bounds. Thus differentiating the finite formulas, using a +finite superset of possible period indices, evaluates every derivative +without a machine execution or a real equality test at a seam. +\end{proof} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/solid-routing.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/solid-routing.tex new file mode 100644 index 0000000000000000000000000000000000000000..a59ad0bc94d783a0b841ca7471473b1ef390f571 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/solid-routing.tex @@ -0,0 +1,668 @@ +\section{Evacuation, columns and obstacle detours}\label{sec:solid-routing} +The following refinements choose the occupied regions and the storage order +explicitly. Ordered low extraction controls a height observer; simultaneous +lifting controls a first-coordinate observer; expanded centers permit +three-dimensional detours. Fixed columns and recorded pointers give further +ways to keep a whole transition outside a detector. Each proof specifies +which parts of the geometry act on solid neighborhoods and which bounds +are needed only for the coded central plane. + +Unless an individual theorem specifies another class, whole-space +comparison means smooth $u\in CH^2\cap C^1L^2$, bounded $u,\nabla u$ +on finite intervals, and a pressure representative in $CH^1$, as in +Section~\ref{bc:analytic-section}. The torus comparison class is the +classical class of Lemma~\ref{lem:b-comparison}. The distinct pressure +conditions stated below remain part of their respective results. + +\subsection{Ordered extraction below the computation}\label{bc:ordered-section} +\begin{proposition}[Ordered full-box transport]\label{bc:ordered} +Let $D_i,S_i$ be finite families of closed rational axis-aligned boxes in $\R^3$ +with positive side lengths, pairwise disjoint within each family. +Suppose the assigned center-to-center affine map $F_i$ satisfies +$F_i(D_i)=S_i$ and has positive diagonal linear part $A_i$ of +determinant one. There is an effective compactly supported solenoidal +unit-time field, zero near the time endpoints, whose time-one map has +this action on every full $D_i$. If both centers of a pair have negative +third coordinate, every point of $D_i$ whose third coordinate equals that +of its center follows a path with negative third coordinate. +\end{proposition} +\begin{proof}\label{bc:ordered-proof} +Choose an integer $L>1$ larger than the absolute values of all endpoint +coordinates. The storage columns have first coordinates $U_i=4(i+1)L$ +and common height $Z=-4L$. Write $[\ell_i,r_i]$ for the first-coordinate +interval of $D_i$. Extract sources in decreasing order of $r_i$. +Translate each horizontally right to its column and then vertically to +$Z$, retaining its second coordinate. If an unextracted box meets the +active box in both the second and third projections, disjointness forces +their first intervals to be separated. That box cannot lie to the right: +its right endpoint would then exceed $r_i$, contrary to the extraction +order. It lies strictly to the left of $\ell_i$ and misses the entire +rightward sweep. Stored boxes lie below the original boxes; vertical +moves occur in distinct columns outside them. + +At storage height, adjust the second center coordinate to its target +value and apply $A_i^{\theta}$. Each intermediate half-width lies between +its two endpoint values, hence is less than $L$. The columns remain +disjoint throughout these operations. Deliver boxes in increasing order +of the right endpoint of their target first interval: raise a box to its +target height and translate it left into its target. The raising column +is empty. As above, a previously delivered box whose last two intervals +meet the active ones must be separated in the first coordinate. Its +smaller right endpoint puts it wholly to the left of the active target +interval, so the leftward sweep stops before reaching it. +Undelivered boxes remain at storage height. These observations give +positive rational clearances for all swept bounding boxes. Choose cutoff +padding below each clearance and use Lemma~\ref{lem:bb-curl} in successive +flat slots. Induction over the slots proves the full-box assertion. +A point initially in the central third-coordinate plane retains zero +third-coordinate offset during each diagonal deformation. Its height is +interpolated only between the two endpoint heights and $Z$. If those +endpoint heights are negative, every intermediate height is negative. +\end{proof} + +The onto hypothesis in the preceding proposition is a useful exact-box +specialization. Its target-container version, including the effective +input conditions, is given in Section~\ref{bc:contained-targets}. + +\begin{theorem}[A positive-height observation]\label{bc:positive-height} +On $\R^3$, the fixed label $0$ and observation $\{x_3>0\}$ realize +halting effectively by a compactly supported general force with zero +initial velocity and pressure, bounded mixed derivatives, and period one +after time one. The force has a separate alternative in +$L^2(0,\infty;H^j)$ for every $j$, tending to zero in every spatial +supremum norm at rate $O((1+t)^{-1})$. +\end{theorem} +\begin{proof}\label{bc:positive-height-proof} +Use Lemma~\ref{lem:bb-movefirst} and odd digits in base $2m+2$. Give every +simulator state a distinct positive integer index $i_s$ and put its +third-coordinate center at $z_s=i_s$ for ready halting states and +$z_s=-i_s$ otherwise. Thicken the full rectangles of +Lemma~\ref{lem:bb-onecell} by $[z_s-1/4,z_s+1/4]$. The assigned third +scale is one, so the maps satisfy Proposition~\ref{bc:ordered}. +The rational initial code $Y_0$ is loaded from the origin along the +straight segment, by a localized translation during $[0,1]$. Repeat the +unit-time mechanism after time one. At time $1+k$ the particle is exactly +the code after $k$ defined simulator transitions. If the initial machine +halts, the loading endpoint already has positive height. If it never +halts, loading has nonpositive height and all later transitions have +negative endpoint centers; the proposition excludes a positive height +at every intervening time. Conversely, a halting checkpoint has positive +height. Lemma~\ref{bc:analytic} gives the force and uniqueness, and +Lemma~\ref{ba:log-clock} gives the separate temporal alternative. +\end{proof} + +\subsection{Simultaneous lifting with a convex-coordinate guard} +\label{bc:simultaneous-section} +\begin{proposition}[Simultaneous full-box transport]\label{bc:simultaneous} +Suppose finite planar source and target rectangle families $S_i,T_i$ +have positive side lengths and endpoints on the grid $B^{-2}\Z^2$, +with integer $B\ge2$, and are separately +disjoint. Require their assigned center-to-center maps to satisfy +$F_i(S_i)=T_i$ and to have linear part $\diag(\lambda_i,\lambda_i^{-1})$ with +$\lambda_i\in\{B^{-1},1,B\}$. There is an effective solenoidal motion +of the full boxes obtained by taking the product with $[-1,1]$. +For every transported point its first coordinate is a convex combination +of its initial and final first coordinates at every time. +\end{proposition} +\begin{proof}\label{bc:simultaneous-proof} +Let $p_i^-,p_i^+$ be the centers in the plane $z=0$, set $h_i=5i$, and +choose a smooth $\Theta$ equal to zero on $(-\infty,1/4]$ and one on +$[3/4,\infty)$. For $0\le t\le1$, put +\[ + \theta=\Theta(3t-1),\quad l_i=1-\theta+\theta\lambda_i, + \quad c_i=(1-\theta)p_i^-+\theta p_i^+ + +h_i\{\Theta(3t)-\Theta(3t-2)\}e_3. +\] +The desired path is $g_i(t,y)=c_i(t)+\diag(l_i,l_i^{-1},1)(y-p_i^-)$. +Use a source padding $\varepsilon=1/(10B^3)$, transported by this same +affine map, for the cutoff neighborhood. During lifting the planar +source gap is at least $B^{-2}$. During lowering the enlarged target +padding is at most $B\varepsilon20R$ so large that the +expanded source centers $A_i^*=Ha_i$ and target centers $B_i^*=Hb_i$ +are separately more than $20R$ apart in the sup norm. Set +\[ + Z_0=1+100R+\max_i\{\|A_i^*\|_\infty,\|B_i^*\|_\infty\}, + \qquad P_i=(0,0,-Z_0-100Ri). +\] +Each of the unions $\{A_i^*\}\cup\{P_i\}$ and +$\{B_i^*\}\cup\{P_i\}$ has separation greater than $20R$. +The construction has five phases: expand source centers by a factor +from one to $H$ while keeping shapes fixed; move them successively to +$P_i$; change each parked shape by the prescribed positive diagonal +power; move them successively to $B_i^*$; contract target centers to +$b_i$ while keeping the final shapes fixed. + +The simultaneous expansion is collision free. For each pair of source +boxes some coordinate has positive gap +$|a_{i,j}-a_{k,j}|-r_{i,j}-r_{k,j}$; multiplication of the center +difference by a factor at least one preserves that gap. The same +argument applies to contraction toward the disjoint targets. Choose +padding less than one quarter of the minimum such gap, and less than +one. During a parked deformation the $j$th half-width is +$r_{i,j}^{1-\theta}w_{i,j}^{\theta}\le\max(r_{i,j},w_{i,j})0$. +Every boundary used around a negative-height obstacle lies below +$-H+4R<0$. Storage heights are negative as well. Expansion, contraction, +and positive diagonal deformation preserve the central-plane condition. +Thus all these paths are negative. Finitely many rational vertices, +endpoint widths, and cutoff paddings give a rational support bound. +\end{proof} + +\begin{theorem}[A height test inside one torus chart]\label{bc:expanded-height-event} +On the unit torus, the fixed label $o=(1/2,1/2,1/2)$ and event +\begin{equation}\label{bc:expanded-height-fixed-event} + \{x:x_3\pmod1\in(1/2,1)\} +\end{equation} +realize halting by a smooth general mean-zero force, periodic after time +one, with zero initial velocity and pressure and bounded mixed derivatives. +The repeated mechanism depends on the machine alone; only initialization +depends on its finite input. The solution is unique in the torus class. +\end{theorem} +\begin{proof}\label{bc:expanded-height-event-proof} +Use the frontier recorder, odd base $B=2m+1$, distinct negative integer +heights for nonterminal states and height one for the terminal ready state. +Thicken every branch by a third half-width $1/4$. The reciprocal tape +map is onto its target rectangle; adjoining the unchanged third interval +gives an onto box map with linear part $\diag(B^{-e},B^e,1)$ and +determinant one. All source centers are +negative because terminal controls have no outgoing rules. Apply the +preceding proposition. The logical initial code $Y_0$ is rational and has +a uniform machine-dependent bound as the input varies: its two stack +coordinates lie in $[0,1]$ and its height is fixed by the initial control. +A moving translation loads the logical origin to $Y_0$, with a fixed +source half-width one and padding one. This gives a machine-dependent +rational bound $K$ for the supports of all such loaders and the repeated +mechanism; for example take $K=1+2R+M$ with $M$ an upper bound for all +routing vertices and loading coordinates and $R$ enlarged to cover their +half-widths. Choose $\lambda=1/(4K)$ and use the chart $x=o+\lambda Y$. +Everything remains strictly inside $(1/4,3/4)^3$. + +Periodize the resulting compactly supported curl fields, loading during +the first unit interval and repeating thereafter. Compute the residual +at physical viscosity $\nu$, after the chart change. The fields and force +have zero mean and all the bounds in Lemma~\ref{bc:analytic}. +For a nonhalting run, loading has nonpositive logical height and each +later segment remains negative by the proposition. A terminal code has +physical height $1/2+\lambda$, which lies in the event. There is no +chart-boundary crossing that could create a spurious observation. +An initially terminal input is detected at the loading endpoint. +The initialized correspondence is exact; at checkpoints the number of +history records gives $n$, and the frontier's relative position together +with its absolute index $2+n$ also recovers the absolute work-head position. +\end{proof} + +\subsection{Fixed columns and separate layers}\label{bc:columns-section} +\begin{proposition}[Column and layer transport]\label{bc:columns} +Let $S_i,T_i$ be finite rational planar rectangle families of positive side +lengths, each separately disjoint, with endpoints on the $B^{-2}$ grid, +where $B\ge2$ is an integer. +Let their assigned center-to-center positive reciprocal diagonal affine +maps satisfy $F_i(S_i)=T_i$. A finite effective +solenoidal field in $\R^3$ realizes all these maps on the rectangles in +$z=0$. Along each tracked path the first coordinate stays between its +initial and final values. The field has compact support and flat time +collars. +\end{proposition} +\begin{proof}\label{bc:columns-proof} +Give rectangle $i$ height $h_i=4i$. A planar cutoff equal to one near +its source and supported within padding $1/(4B^2)$ has support disjoint +from the other source cutoffs. Multiply it by a third-coordinate cutoff +which is one near the entire interval $[0,h_i]$. The curl of the potential +$(0,h_i x,0)$ times these cutoffs equals $(0,0,h_i)$ along that source +column. A common flat schedule lifts all rectangles. The corresponding +target cutoffs give a later descent by $-h_i$. + +In the middle phase, let $p_i,q_i$ be the centers and $a_i>0$ the +first-coordinate scale. With phase parameter $\mu\in[0,1]$, set +$c_i=p_i+\mu(q_i-p_i)$, $l_i=1+\mu(a_i-1)$ and +\[ + H_i(\mu,x,y)=d_{i,1}y-d_{i,2}x+ + \frac{a_i-1}{l_i}(x-c_{i,1})(y-c_{i,2}), + \qquad d_i=q_i-p_i. +\] +On a neighborhood of the desired path, the planar Hamiltonian field +$(\partial_yH_i,-\partial_xH_i)$ generates +$c_i+\diag(l_i,l_i^{-1})(\zeta-p_i)$. +The first coordinate is the convex interpolation of its endpoint values. +The second half-width obeys +\[ + \frac{r_{i,2}}{(1-\mu)+\mu a_i} + \le (1-\mu)r_{i,2}+\mu r_{i,2}/a_i, +\] +by convexity of the reciprocal function. Consequently the swept rectangle +lies in the coordinate bounding rectangle of the two endpoints. Localize +$H_i$ around that rectangle in the layer $z=h_i$, with third padding less +than one, and take the curl of $(0,0,H_i)$ times that cutoff. For a +flat middle ramp $\mu=\eta_2(t)$, multiply the resulting phase field by +$\eta_2'(t)$. Layers are disjoint, so the sum has the required action. Lift and descent preserve +planar coordinates. The exact paths and ODE uniqueness establish the +full-rectangle and intermediate-coordinate assertions. +\end{proof} + +\subsection{Target containers and prescribed affine images} +\label{bc:contained-targets} +The named targets in Propositions~\ref{bc:ordered}, \ref{bc:simultaneous} +and~\ref{bc:columns} can also be rational \emph{containers} for the actual +images. More precisely, replace the onto condition by +\[ + F_i(D_i)\subseteq S_i\quad\text{in Proposition~\ref{bc:ordered}}, + \qquad + F_i(S_i)\subseteq T_i\quad\text{in the other two propositions}. +\] +Keep the other geometric hypotheses. For ordered transport retain the +center-to-center condition. For simultaneous and column transport the +actual endpoint center is $F_i(p_i)$, where $p_i$ is the source center; +it need not be the center of the container. The maps have the same positive +diagonal determinant-one linear parts as before, including the specified +three scale choices in Proposition~\ref{bc:simultaneous}. +All transport and path conclusions remain valid. For arbitrary real map +coefficients this is a smooth existence statement. The construction is +effective when those coefficients are computable, and otherwise its +evaluation is relative to them. An empty list again uses the zero field. + +Here are the necessary modifications of the proofs. In ordered transport, +write $r_{i,j}$ for a source half-width, $w_{i,j}$ for the corresponding +container half-width, and $a_{i,j}>0$ for the diagonal factor. Containment +gives $a_{i,j}r_{i,j}\le w_{i,j}$, hence +\[ + r_{i,j}a_{i,j}^{\theta} + \le\max(r_{i,j},a_{i,j}r_{i,j}) + \le\max(r_{i,j},w_{i,j})0$ be the minimum sup-norm separation within the +two center families. Put $K=1+32R/m_0$. Expand all source centers by +factors from one to $K$, leaving their shapes unchanged. Let +$M=\max_i\{|(Kc_i)_1|,|(Kq_i)_1|\}$ and choose parking centers +$P_i=(M+32Ri,0)$. Each union of expanded endpoint centers and parking +centers has separation at least $32R$. + +Move expanded sources successively to their parking centers, deform them +there using the linear reciprocal scale, move them successively to the +expanded target centers, then contract those centers to their targets. +For each successive transfer put a square of sup-radius $4R$ around +every stationary center. Replace each nontrivial segment intersection +with an obstacle square by a counterclockwise path along its boundary. +The intersection points and corners are rational; the squares are disjoint, +so the resulting finite polygon stays at distance at least $4R$ from +all stationary centers. Flat schedules on its segments give smooth center +motion. The simultaneous expansion and contraction preserve a positive +coordinate gap for every pair, exactly as in the solid-box argument. +If $g_0,g_1$ are their minimum positive gaps, choose padding +$\varepsilon=\min(g_0,g_1,2R)/4$ for these phases. During individual +transfers use padding below $R$; the stationary half-widths are below $R$. +Thus all required cutoff supports avoid stationary rectangles. + +For a moving center $c$ and horizontal scale $l$, the potential +\[ + H=\chi\left[\dot c_x(y-c_y)-\dot c_y(x-c_x) + +\frac{\dot l}{l}(x-c_x)(y-c_y)\right] +\] +gives the required motion on the cutoff plateau. The other current +rectangles are fixed. This proves every full planar branch, including +its boundary, by induction through the operations. A one-square loading +translation with half-width $1/4$ takes $(-4,0)$ to the initial rational +code. All these supports lie in a square $[-L,L]^2$, where one can choose +$L=10+S_0+4m_Q$ with $S_0$ a finite bound for routing vertices and cutoff +widths. The same $L$ covers every input of a fixed machine, since initial +codes are uniformly bounded. + +The planar detours need not avoid the horizontal observation box. +We instead make them at height three. Choose a switch $\eta$ with +collars and set +$h(s)=3\{\eta(3s)-\eta(3s-2)\}$ on a unit interval. It lifts in the +first third, stays at three in the middle, and lowers in the last third. +Choose $\Gamma$ equal to one near $[-L,L]^2\times[-1,4]$, with compact +support, and $\beta(z)$ compactly supported and equal to one near three. +For any one of the planar fields $w$, zero outside its phase interval, +put +\[ + Z(s,x)=h'(s)\nabla\times(0,x_1\Gamma(x),0),\qquad + V_w(s,x)=Z(s,x)+3\beta(x_3)(w(3s-1,x_1,x_2),0). +\] +Along each tracked path the first term is exact vertical translation. +The second term acts only in the middle third, at height three, and runs +the full planar phase. It is divergence free because $w$ is planar +solenoidal and $\beta$ is independent of the planar coordinates. +Thus the trajectory lifts at its exact source, performs every detour +outside the vertical detector interval, and lowers at its exact target. +Use this construction for the loader and for each repeated phase. While +its height can lie in $(-1,1)$, a nonterminal computational particle has +first coordinate at least four; the initial loading source has first +coordinate $-4$. A terminal code lies in $(0,1)^2\times\{0\}$. +These facts prove the all-real-time observation equivalence, including +an initially terminal input. + +For the comparison assertion, the constructed field has compact support +and bounded mixed derivatives, so it satisfies the reference hypotheses +of Lemma~\ref{lem:b-comparison}. The displayed competitor class is exactly +case (v) of that lemma. Its proof obtains $\nabla p\in L^2$ from the +equation and cancels the pressure term by Lemma~\ref{lem:b-gradient}; it +does not require an integrable pressure representative. Hence the velocity +is unique, and pressure is determined up to a function of time. + +Finally let $U(s)$ denote the eventually periodic field just constructed +and set $\rho(t)=(1+t)^{1/3}-1$, $\widehat U=\rho' U(\rho(t))$. +The new residual is +\[ + \widehat f=\rho''U+(\rho')^2\{U_s+(U\cdot\nabla)U\} + -\nu\rho'\Delta U, + \quad \rho'=\tfrac13(1+t)^{-2/3},\quad + \rho''=-\tfrac29(1+t)^{-5/3}. +\] +Uniform derivative bounds and the fixed compact support give the stated +decay and space-time $L^2$ estimate. Chain differentiation also gives all +mixed bounds. The clock is effective on $[0,\infty)$, starts at zero, +is finite at finite time and is onto; hence it preserves precisely the +same material event. The initial zero collar is preserved as well. +This slower force is an alternative to, not a periodic version of, the +first force. +\end{proof} diff --git a/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/torus-routing.tex b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/torus-routing.tex new file mode 100644 index 0000000000000000000000000000000000000000..c18dc50cf82ad5f425a868824b40d419afffd9c1 --- /dev/null +++ b/preprints/Incompressible-Box-Transport-and-Finite-Computation-October-6-2026/build/torus-routing.tex @@ -0,0 +1,365 @@ +\section{Torus charts and phasewise localization}\label{sec:torus-routing} + +The next constructions keep the whole motion inside a specified torus +chart. A scaled linear interpolation preserves a convex first coordinate; +an exponential interpolation in a fixed chart instead uses endpoint-width +bounds. A phasewise construction then exhibits the vertical and planar +potentials separately, and the final variant retains a permanent origin +track. These choices give different path estimates for their observers. +In every case the force is recomputed at the prescribed physical viscosity +after any spatial rescaling. + +\subsection{Physical chart scaling and thickened torus boxes} + +\begin{proposition}[Linear scaling into the torus] +\label{prop:bb-mid-scaled-torus} +The direction recorder without its passive track has a unit-torus +realization periodic after $t=1$, with fixed label $(1/8,0,0)$ and +halting event $x_1\in(-1/4,0)\pmod1$. Each period acts on full +solid boxes; the pressure is zero and the force has zero mean. +\end{proposition} +\begin{proof}\label{proof:bb-mid-scaled-torus} +Use the controls of Lemma~\ref{lem:bb-direction}. Let +$\Sigma=\Gamma\times(\{\bot,F\}\sqcup\mathcal R)\times\{0,1\}$ +be its full cell alphabet after deleting the singleton passive track. +Let $S$ be the finite set of recorder controls and choose a bijection +$j:S\to\{1,\ldots,|S|\}$. +Use odd digits with $B=2|\Sigma|+1$, and offsets $o_s=-2j(s)$ for halting main +controls and $o_s=2j(s)$ for the others. Number the resulting reciprocal branches +$i=1,\ldots,N$, and write $k_i$ for branch $i$'s first-coordinate scale. +Thicken each reciprocal branch by +$[-1,1]$. Its horizontal family gaps are at least $B^{-2}$. +Lift branch $i$ to $4i$, use the linear first scale +$\kappa_i=1+\theta(k_i-1)$, and descend. Padding smaller than +$(4B^2)^{-1}$ separates all phases: in the middle the half-height +is one and height gaps are four; in the other phases horizontal +gaps suffice. The two horizontal half-widths are at most $1/2$. +Use the true-plateau cutoff of Lemma~\ref{lem:bb-curl}; it supplies +at least the full-box guarantee, together with a neighborhood extension. +The exact first coordinate obeys +\begin{equation}\label{eq:bb-mid-scaled-convex} + X_1(\tau)=(1-\theta)X_1(0)+\theta X_1(1). +\end{equation} + +Let $V$ be the period-one extension of the unit-time field just constructed. +All codes, paths and padded supports lie in $(-L,L)^3$ for +$L=10+2|S|+4N$. Put $a=1/(16L)$ and define in the torus patch +$(-1/2,1/2)^3$ the repeated field $U(t,x)=aV(t,x/a)$. +Its support lies in $(-1/16,1/16)^3$ and its curl potential is the +scaled potential $a^2A(t,x/a)$. In particular its mean is zero. +The residual must be recomputed at the physical viscosity: +\begin{equation}\label{eq:bb-mid-viscosity-scale} + \mathcal F_\nu[U](t,x)=a\{V_t+(V\cdot\nabla)V-(\nu/a^2)\Delta V\}(t,x/a). +\end{equation} +This keeps the specified viscosity rather than silently rescaling it. +During the first unit interval load from $(1/8,0,0)$ to the scaled +initial code using a curl translation with a box of half-width $1/32$ +and padding $1/32$. Its support lies inside $(-1/4,1/4)^3$. + +For a nonhalting run both loading endpoints have positive first +coordinate, and every subsequent pair of coded endpoints is positive. +Equation~\eqref{eq:bb-mid-scaled-convex} preserves that sign throughout. +A halting checkpoint has negative first coordinate in $(-1/16,0)$. +All paths stay in the stated patch, so passage modulo one introduces +no extra visit. Checkpoint times are +$1+\sum_{l0,\\0,&r\le0,\end{cases} + \qquad \Theta(r)=\frac{E(r)}{E(r)+E(1-r)}. +\] +Use the single-halt normalization and the seven-row recorder in +Lemma~\ref{lem:bb-movefirst}, with frontier initially at two and all marks +initially zero. In the present notation its controls are +$S_q,U_r,W_r,C_q,D_q$ (ready, work-move completed, right scan, +frontier extension, left scan), and its full symbols are $(a,g,m)$ +with history $g\in\{E,F\}\sqcup\{\widehat r\}$. +The first row writes and moves, the second marks and starts the scan, +and the last clears the mark and stays. These are exactly the seven +rows already proved, after renaming. Thus the new work head $j'$ is +less than $n+2$, a work step takes $2(n+2-j')+4$ local steps, and +both full-domain incoming properties hold. + +Let $M$ count the partial controls, let $H=S_h$, and put +\[ + \ell=\frac1{100(M+1)},\qquad o_H=(3/4,1/2),\qquad + o_{s_i}=(1/4+2i\ell,1/2)\quad(0\le i0$. Curls have zero mean, and incompressibility +gives zero mean for the residual. Lemma~\ref{ba:realization} supplies +the unique zero-data PDE solution and its global trajectories. + +At times $1+k$, induction through the full branch maps gives the exact +local code through the first halt, or for all $k$ in the nonhalting +case. A halt code has first coordinate in +$[3/4,3/4+\ell]\subset(2/3,5/6)$, including a code reached solely by +loading an initially halted machine. For a nonhalting input the loader +stays below $1/2$ in first coordinate. Lift and descent retain the +nonhalting planar endpoint codes. In the middle phase the centers are +convex combinations of nonhalting centers and the first half-width is +at most $\ell/2$, so +\[ + X_1\le1/4+2M\ell+\ell/2<1/2. +\] +This excludes the height-independent observer at every intermediate +time. Only the loader depends on the input; the repeated field depends +on the finite machine table. +\end{proof} + + +\subsection{A permanent origin marker and moving cutoff neighborhoods} +\label{bc:height-separated-section} +\begin{theorem}[A height-separated mechanism with an origin track] +\label{bc:height-separated-event} +On the unit torus, the fixed label $(1/8,3/8,1/4)$ and strip +$2/30\) for which \(rL\) is a line +bundle. For every \(\varepsilon>0\), that line has a smooth Hermitian metric +\(h_\varepsilon\) satisfying +\[ + \frac{\sqrt{-1}}{2\pi r}\Theta_{h_\varepsilon} + \geq-\varepsilon\omega. +\] +Smooth metrics and forms on a singular space are understood through local +embeddings. We call \(L\) semiample if an actual positive integral multiple +is a holomorphic line bundle generated by its global sections. + +\begin{assumption}[Logarithmic Iitaka subadditivity] +\label{asm:log-iitaka} +Let \(f:X\to Y\) be a surjective morphism with connected fibers between +smooth connected projective complex varieties. Let \(D_X\) and \(D_Y\) be +reduced effective simple normal crossing divisors, allowing zero divisors, +such that +\[ + \Supp(f^*D_Y)\subseteq\Supp(D_X). +\] +For a very general smooth fiber \(F\), put \(D_F=D_X|_F\). Then +\[ + \kappa(X,K_X+D_X)\geq + \kappa(F,K_F+D_F)+\kappa(Y,K_Y+D_Y). +\] +Here \(D_F\) is reduced SNC and +\(K_F+D_F\sim (K_X+D_X)|_F\). The Iitaka dimension is \(-\infty\) when +all positive integral systems are empty, with +\((-\infty)+b=-\infty\) also for \(b=-\infty\); the zero divisor on a +point has Iitaka dimension zero. +\end{assumption} + +\begin{theorem}[Log abundance for compact Kähler spaces]\label{thm:main} +Assume Assumption~\ref{asm:log-iitaka}. Let \(X\) be a normal irreducible +compact Kähler complex analytic space, and let \(\Delta\geq0\) be a rational +divisor such that \((X,\Delta)\) is log canonical and \(K_X+\Delta\) is +rational Cartier. If \(K_X+\Delta\) is analytically nef, then it is +semiample. Explicitly, there is an integer \(m>0\) such that +\(m(K_X+\Delta)\) is Cartier and +\[ + H^0\bigl(X,\OO_X(m(K_X+\Delta))\bigr)\otimes_{\C}\OO_X + \longrightarrow \OO_X(m(K_X+\Delta)) +\] +is surjective at every point of \(X\). +\end{theorem} + +The theorem includes every finite dimension and the zero-boundary case. +Assumption~\ref{asm:log-iitaka} is used through the projective good-model +theorem stated in Proposition~\ref{proj:good-models}. The cited proof of +that projective theorem uses only its zero-boundary case, on a resolved +projective Albanese fibration. + +\subsection{Context and relation to earlier work} + +In the minimal model program, abundance complements the construction of +minimal models: the nef adjoint on a minimal model should determine a +canonical fibration. For minimal projective threefolds, Miyaoka proved the +case of numerical dimension one and Kawamata completed canonical abundance +\cite{Miyaoka1988,Kawamata1992}. Keel, Matsuki, and McKernan established +log abundance for threefolds +\cite{KMM1994,KMM2004}. In arbitrary dimension, Birkar, Cascini, Hacon, and +McKernan established log terminal models for projective klt pairs with big +boundary and pseudo-effective adjoint, and finite generation for big +adjoints \cite{BCHM2010}. + +The compact Kähler history already points to the importance of simple +spaces. Peternell's threefold theorem isolated the possible case of a simple +space not bimeromorphic to a finite quotient of a torus +\cite{Peternell2001}; Demailly and Peternell subsequently proved canonical +nonvanishing for nef terminal Kähler threefolds, including that case +\cite{DemaillyPeternell2003}. Höring and Peternell constructed minimal models +for normal \(\Q\)-factorial terminal compact Kähler threefolds with pseudo-effective canonical class +\cite{HoeringPeternell2016}. Campana, Höring, and Peternell treated canonical abundance +\cite{CHP2016,CHP2023}, and Das and Ou +established log abundance for compact Kähler log canonical threefolds +\cite[Corollary~1.3]{DasOu2026}. + +With \(D_X=D_Y=0\), Assumption~\ref{asm:log-iitaka} is Iitaka's classical +\(C_{n,m}\) inequality +\(\kappa(X)\geq\kappa(F)+\kappa(Y)\) for algebraic fiber spaces +\cite[Equation~(1.0.1)]{CaoPaun2017}. Cao and Păun proved the analogous +logarithmic inequality over an abelian base when the pair on the total space +has an effective rational boundary and is klt +\cite[Theorem~1.1]{CaoPaun2017}. Fujino derives +logarithmic subadditivity from the conjectured equality +\(\kappa_\sigma(X,K_X+D)=\kappa(X,K_X+D)\) for smooth projective +\(X\) with reduced SNC \(D\) +\cite{Fujino2017Subadditivity,Fujino2020Corrigendum}. Hashizume proves the +reduced-SNC subadditivity statement when the log canonical divisor of the +very general fiber is abundant \cite[Theorem~1.2]{Hashizume2020}. Here the +implication is used in the other direction: the projective companion +\cite{LI} derives good models for pseudo-effective projective lc adjoints +from Assumption~\ref{asm:log-iitaka}, and those good models anchor the +Kähler induction. + +Hacon and Xie's cone theorem, adjunction, relative positivity, and +modified-big preparation \cite{HX} provide analytic inputs for our +program constructions. Section~\ref{sec:programs} constructs effective +generalized base data on a higher carrier, with an exact adjoint +pullback identity and a multiplier-ideal inclusion. Fibrewise +$L^2$ positivity and regularization give this presentation; its +Stein-factor consequence supplies the non-klt induction. +The section then proves the restricted semiampleness, proper relative +good-model, and finite-model statements needed here, following the +dimension-induction strategy of \cite{HX}. +The nef data remain globally nef on a fixed carrier, and the total +generalized boundary is globally modified big. Actual rational lines +make the selected ray contractions projective; ordinary projective +analytic results \cite{FujinoAnalyticBCHM} then construct their flips +and the relative models. This produces a Kähler pullback description of +the relevant Bott--Chern class. Generation of the prescribed holomorphic +line requires the additional divisorial decomposition and boundary +arguments. The fibration comparison and period positivity come from +\cite{CI}; the boundary and lifting constructions adapt inputs in +\cite{CB,BL}. The precise imported results are stated at their points +of use. + +\subsection{The proof and its main constructions} + +For a pseudo-effective \((1,1)\)-class \(\alpha\), \(N(\alpha)\) records +the least generic vanishing forced along prime divisors. Given a smooth +compact Kähler manifold \(X\) and a rational SNC boundary \(B\) with +\(J=K_X+B\) pseudo-effective, the induction constructs a modification +\(\mu:Y\to X\) with \(Y\) smooth and +\[ + \mu^*J\sim_{\Q}P+R,\qquad P\text{ semiample},\qquad + R=N(c_1(\mu^*J)), +\] +as an identity of rational holomorphic line bundles, with \(R\) an effective +rational divisor. Section~\ref{sec:inductive-reduction} uses transfer rules, +algebraic reduction, and generically finite covers to reduce the induction +to projective manifolds, nontrivial fibrations, and simple spaces of +algebraic dimension zero. Here simple means that no positive-dimensional +proper compact subvariety passes through a very general point. + +Section~\ref{sec:programs} supplies two program results. For the fibration +case it contracts a known negative part while preserving the prescribed nef +line. For the simple case it proves special termination for a chosen scaling +and reaches a nef model when the pseudo-effective adjoint is rationally +equivalent to a divisor supported on the reduced boundary, allowing negative +coefficients. The termination argument uses lower-dimensional induction to +construct one model on which an interval of perturbed adjoints is nef. On a +common resolution their negative multiplicities are affine, whereas every +nontrivial wall of the restricted program changes a slope. Hence only +finitely many such walls occur. + +Section~\ref{sec:boundary} turns generation on separate strata into generation +on the entire reduced dlt boundary, adapting Fujino's method of admissible +sections \cite[Section~4]{Fujino2000}. When a comparison is needed, a Mori +contraction realizes Kollár's residue comparison at the two coefficient-one +points of a general \(\PP^1\) fiber +\cite[Definition~13 and Proposition~14]{Kollar2013Sources}. On a common +resolution, the pulled-back restrictions of the ambient Kähler class differ +by a real linear combination of Chern classes of line bundles. On a stratum +whose boundary dominates the image of the map +defined by its semiample adjoint, restriction determines sections. For the +remaining strata, we prove finite image for self-comparisons on sufficiently +divisible pluricanonical systems using an invariant integral, period and +lattice arguments, and a uniform cohomological bound for cyclic covers. +Products over these finite images give compatible generating sections, used +in both closing arguments. + +Section~\ref{sec:rank-one} first reduces to fibrations whose very general +fiber has log Kodaira dimension zero. On a prepared fibration \(g:X\to W\), +a relative generating form gives +\[ + K_X+B\sim_{\Q}g^*H+A_*,\qquad H=K_W+T+M, +\] +where \(T\) is a rational SNC boundary and \(M\) is pulled back from a nef +rational line on a projective quotient of \(W\). Fiber induction allows us +to subtract the part of \(A_*\) dominating \(W\) from a positive current for +\(K_X+B\). The resulting metric descends along connected smooth fibers; a +zero among the nonnegative coefficients at primes dominating each base prime +allows extension, proving \(H\) pseudo-effective. If \(a(W)=0\), the +projective quotient is a point, so \(M\sim_{\Q}0\) and lower-dimensional +induction makes \(H\) rationally equivalent to its negative divisor. For +projective \(W\), a reduction via a chosen generalized program derived from +Assumption~\ref{asm:log-iitaka} either lowers the positive base dimension, +handled by secondary induction, or reaches a nef line that is big or torsion. +At a stopping case, an intersection argument identifies the full negative +divisor upstairs. A torsion positive part completes the decomposition +directly. In the big nef case, Section~\ref{sec:programs} contracts that +divisor while preserving the nef line; boundary generation, extension, and +a new log canonical place at a hypothetical base locus prove semiampleness. + +Section~\ref{sec:nonvanishing} proves, independently of +Assumption~\ref{asm:log-iitaka}, that a positive canonical power has a nonzero +meromorphic section on every smooth connected simple compact Kähler manifold +of algebraic dimension zero. Ou's uniruledness and foliation results supply +the cotangent slope control \cite{Ou2025}. A point-threshold bound for big +classes of volume one is contradicted using an auxiliary projective bundle +over \(X\times X\). The diagonal in its square produces a subsheaf occupying +a fixed positive fraction of a symmetric cotangent power of that bundle. +A second construction over the diagonal of \(X\times X\) forces determinant +vanishing which, after restriction to a blowup of \(X\), violates the point +bound. + +Finally, Section~\ref{sec:signed} uses the meromorphic section to obtain, +after resolving and enlarging to a reduced SNC boundary, a pseudo-effective +adjoint with a signed representative supported there. +Section~\ref{sec:programs} gives a nef dlt model, and +Section~\ref{sec:boundary} gives generation on its reduced boundary. +Pseudo-effectivity of the canonical pullback and an intersection argument +isolate positive-dimensional boundary fibers away from components whose +signed coefficients are nonpositive. A local root construction adapted from +\cite[Proposition~3.3]{LI} separates the positive and negative divisor +supports. An SNC Hodge-module calculation extends the lifting method of +\cite[Sections~10--12]{BL} to residual poles and kills every finite-order +obstruction to lifting such a fiber. Douady space and Artin approximation +give compact deformations leaving the boundary; compactness of the cycle-space +components and relative compactness of bounded-volume cycles allow a Baire +argument to produce a covering family. Simplicity +forces the actual nef line to be torsion. The program comparison and +Lemma~\ref{bir:unique-current} then permit subtraction of the added boundary, +yielding the inductive decomposition. diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/02-inductive-reduction.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/02-inductive-reduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..dcedcb1d8326acfc5b8d5a76aa18a287ae928f74 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/02-inductive-reduction.tex @@ -0,0 +1,586 @@ +\section{Birational decompositions and the geometric reduction} +\label{sec:inductive-reduction} + +The proof will produce a semiample line bundle on a smooth model, together +with its entire fixed divisorial part. This section makes that statement +precise and reduces the induction to two cases: spaces admitting a +nontrivial fibration, and simple spaces of algebraic dimension zero. + +\subsection{The inductive decomposition and its negative part} + +We use additive notation for rational holomorphic line bundles. Thus +\(L\sim_{\Q}L'\) means that \(mL\) and \(mL'\) are holomorphically +isomorphic for some positive integer \(m\). If a rational divisor occurs in such +an identity, it denotes its associated rational line bundle. In contrast, +\(c_1(L)\) and \(\{D\}=c_1(\OO_X(D))\) denote real Bott--Chern classes. +Canonical comparisons are made with the usual local meromorphic canonical +identifications. In particular, an identity of lines below contains more +information than equality of their Chern classes. + +Let \(X\) be a smooth compact Kähler manifold and let \(\alpha\) be a +pseudo-effective real \((1,1)\)-class. Fix a Kähler form \(\omega\). For a +prime divisor \(D\), its minimal multiplicity is +\[ + \nu_D(\alpha)=\lim_{\varepsilon\downarrow0} + \inf\bigl\{\nu_D(T):T\in\alpha,\ T\geq-\varepsilon\omega\bigr\}. +\] +Here \(T\) ranges over closed currents, and \(\nu_D(T)\) is its generic +Lelong number; one may equivalently use currents with analytic singularities. +The limit is independent of \(\omega\). Boucksom's divisorial decomposition +is +\[ + N(\alpha)=\sum_D\nu_D(\alpha)D, + \qquad Z(\alpha)=\alpha-\{N(\alpha)\}. +\] +The sum is a finite effective real divisor, and \(Z(\alpha)\) is modified +nef: its minimal multiplicity at every prime is zero. We write \(N(L)\) and +\(\nu_D(L)\) for \(N(c_1(L))\) and \(\nu_D(c_1(L))\). These are the +analytic notions, with small Kähler +perturbations, throughout the paper. We use the foundational results in +\cite[Sections~2--3 and~5]{Boucksom2004}. + +The induction asks for a decomposition that retains both the actual line +bundle and this analytic negative divisor. + +\begin{definition}\label{def:good-decomposition} +For \(n\geq0\), let \(\Ggood_n\) be the following assertion. If \(X\) +is a connected smooth compact Kähler manifold of dimension \(n\), \(B\) +is a rational simple normal crossing boundary with coefficients in +\([0,1]\), and \(J=K_X+B\) is pseudo-effective, then there is a smooth +compact Kähler modification \(\mu:Y\to X\) and an actual rational line +identity +\begin{equation}\label{bir:good-decomposition} + \mu^*J\sim_{\Q}P+R, + \qquad P\text{ semiample},\qquad R=N(\mu^*J)\geq0, +\end{equation} +where \(R\) is a rational divisor. +\end{definition} + +The next lemmas make this decomposition stable under further resolutions +and allow exceptional resolution errors to be removed. They also provide +the fixed-section statement needed to descend the case in which the +positive part is torsion. + +\begin{lemma}[Negative-part calculus]\label{bir:calculus} +Let \(\alpha\) be pseudo-effective on a smooth compact Kähler manifold. +\begin{enumerate} +\item Every positive current in \(\alpha\) contains the divisorial current +\([N(\alpha)]\). If \(0\leq F\leq N(\alpha)\), then +\[ + \alpha-\{F\}\text{ is pseudo-effective},\qquad + N(\alpha-\{F\})=N(\alpha)-F. +\] +\item Minimal multiplicities are homogeneous and subadditive. In +particular, if \(\beta\) is nef, then +\(N(\alpha+\beta)\leq N(\alpha)\). +\item If \(\mu:Y\to X\) is a smooth modification and \(D'\) is the strict +transform of a prime \(D\), then +\[ + \nu_{D'}(\mu^*\alpha)=\nu_D(\alpha). +\] +\item If \(\gamma\) is modified nef and \(j:\widetilde D\to X\) is a +resolution of a prime divisor, then \(j^*\gamma\) is pseudo-effective. +\end{enumerate} +\end{lemma} + +\begin{proof} +The first assertion about currents follows from the definition of minimal +multiplicity and Siu decomposition. Homogeneity and subadditivity follow by +scaling and adding testing currents. The subtraction identity is the +corresponding property in the big cone, followed by a small Kähler +perturbation. More explicitly, for \(\alpha_\varepsilon=\alpha+ +\varepsilon\{\omega\}\), subtract +\(F_\varepsilon=\min\{F,N(\alpha_\varepsilon)\}\) coefficientwise. +In the big cone all positive currents contain this divisor, so subtracting +it translates each minimal multiplicity by its coefficient. As +\(\varepsilon\downarrow0\), \(F_\varepsilon\to F\). The class of +\(F-F_\varepsilon\) can be absorbed in a Kähler perturbation tending to +zero (there are only finitely many components). This gives the upper bound +for the asserted identity; subadditivity applied after adding \(F\) gives +the reverse bound. Weak compactness of positive currents gives +pseudo-effectivity of the limit. This is also the subtraction property of +the divisorial decomposition in \cite[Section~3]{Boucksom2004}. + +For the strict-transform formula, pull almost-positive testing currents +to \(Y\). Near the generic point of \(D'\), the map is an isomorphism, +so the generic order is unchanged. This proves one inequality. Conversely, +push a testing current on \(Y\) to \(X\). To control its negative error, +write the error as a small multiple of the fixed positive current +\(\mu_*\omega_Y\), and add a fixed smooth Kähler representative of +\(C\omega_X-\{\mu_*\omega_Y\}\) for \(C\) sufficiently large. The +result is a positive test in a Kähler perturbation tending to zero. The +pushforward of \(\omega_Y\) has no divisorial order at the generic point +of \(D\), where \(\mu\) is an isomorphism. Thus this test has the same +generic order as the original one at \(D'\). Regularization, if needed, +returns to tests with analytic singularities. This proves the other +inequality and the formula. It is the analytic form of the strict-transform +comparison in \cite[Lemma~5.8]{Boucksom2004}. + +Finally, choose analytic-singularity tests for a modified-nef class whose +generic order at the chosen prime tends to zero. Subtract that generic +divisorial order before restricting to a resolution of the prime. The +remaining singular set does not contain its generic point, so restriction +gives an almost-positive current there. The subtracted multiple and the +Kähler error tend to zero. Taking the limit proves the last assertion; see +also \cite[Propositions~2.4 and~3.8]{Boucksom2004}. +\end{proof} + +For a rational line \(J\) on a normal compact Kähler space \(X\) whose pullback +to a smooth resolution is pseudo-effective, we also use minimal +multiplicities for divisorial places. If \(Q\) appears on a smooth +resolution \(p:Y\to X\), set +\[ + \nu_Q(J):=\nu_Q(p^*J). +\] +The strict-transform formula on a common smooth refinement makes this +independent of the chosen resolution. When a real class is already on a +fixed smooth model, \(\nu_Q\) continues to denote its coefficient in the +negative part on that model. + +\begin{lemma}[Exceptional translation]\label{bir:exceptional} +Let \(p:Y\to X\) be a proper bimeromorphic morphism from a smooth compact +Kähler manifold to a normal compact Kähler space. Let \(M\) be a real +\((1,1)\)-class on \(X\) represented by smooth local potentials, and let +\(E\geq0\) be a real \(p\)-exceptional divisor. If +\(\alpha=p^*M+\{E\}\) is pseudo-effective, then \(p^*M\) is +pseudo-effective and +\[ + N(\alpha)=N(p^*M)+E. +\] +\end{lemma} + +\begin{proof} +It suffices by Lemma~\ref{bir:calculus} to prove \(E\leq N(\alpha)\). +Write +\[ + E-N(\alpha)=U-V, + \qquad U,V\geq0, +\] +with no common component, and suppose \(U\neq0\). Its components are +\(p\)-exceptional. Put \(n=\dim Y\) and +\(\ell=\max\{\dim p(U_i):U_i\text{ a component of }U\}\). Normality +gives \(\ell\leq n-2\). Let \(\eta\) be the pullback of a Kähler form +on \(X\), let \(\omega\) be Kähler on \(Y\), and set +\[ + q(\gamma,\delta)= + \int_Y\gamma\,\delta\,\eta^{\ell}\omega^{n-\ell-2}. +\] +The restriction property in Lemma~\ref{bir:calculus} gives +\(q(Z(\alpha),U)\geq0\). The term \(q(p^*M,U)\) is zero: on each +component of \(U\), it contains \(\ell+1\) factors pulled back from an +image of dimension at most \(\ell\). Distinct effective divisors have +nonnegative intersection against the semipositive and Kähler factors in +\(q\). Hence +\[ + 0\leq q(Z(\alpha),U)=q(U,U)-q(V,U)\leq q(U,U). +\] +On the other hand, \(q(U,\eta)=0\) by the same dimension count, whereas +\(q(\eta,\eta)>0\). The mixed Hodge index theorem, applied first with +Kähler factors and then by a semipositive limit, says that \(q\) is +negative semidefinite on \(\eta^\perp\). It follows that \(q(U,U)=0\) +and that \(U\) is in the radical of \(q\): the radical assertion follows +from negative semidefiniteness on \(\eta^\perp\), and then from +\(q(U,\eta)=0\). But +\[ + q(U,\omega)=\sum_i u_i\int_{U_i} + \eta^{\ell}\omega^{n-\ell-1}>0. +\] +Indeed, a component with image dimension \(\ell\) has strictly positive +integrand on a dense open. This is a contradiction. The mixed Hodge index +statement used here is the mixed Hodge--Riemann relation +\cite[Theorems~A and~C]{DinhNguyen}; the limit preserves the assertion that +there is at most one positive direction. +\end{proof} + +\begin{lemma}[Pulling up a known decomposition]\label{bir:pullup} +Let \(\alpha\) be a pseudo-effective real \((1,1)\)-class on a smooth compact +Kähler manifold, and suppose +\[ + \alpha=\beta+\{R\},\qquad \beta\text{ nef},\qquad R=N(\alpha)\geq0. +\] +For every smooth modification \(\mu:Y\to X\), +\[ + N(\mu^*\alpha)=\mu^*R. +\] +In particular, this applies to the Chern classes of an actual rational line +decomposition with a nef rational positive part. +\end{lemma} + +\begin{proof} +Subadditivity and nefness give \(N(\mu^*\alpha)\leq\mu^*R\). By the +strict-transform formula, the difference +\(U=\mu^*R-N(\mu^*\alpha)\) is effective and exceptional. Moreover +\(Z(\mu^*\alpha)=\mu^*\beta+\{U\}\) is modified nef. Apply +Lemma~\ref{bir:exceptional} to this class. It gives +\(U\leq N(Z(\mu^*\alpha))=0\), proving the assertion. +\end{proof} + +\begin{lemma}[Fixed sections]\label{bir:sections} +Let \(L\) be a pseudo-effective rational line on a smooth compact Kähler +manifold. Every section \(s\) of an integral multiple \(mL\) satisfies +\[ + \ord_D(s)\geq m\nu_D(L) +\] +at every prime \(D\). If \(L\sim_{\Q}P+R\), with \(P\) semiample and +\(R=N(L)\) rational, then in every sufficiently divisible degree +multiplication by the canonical section of \(mR\) identifies +\(H^0(X,mP)\) with \(H^0(X,mL)\). +\end{lemma} + +\begin{proof} +The divisor current \([\operatorname{div}(s)]/m\) is a positive current +in \(c_1(L)\), so Lemma~\ref{bir:calculus} gives the order bound. In the +stated decomposition, every section therefore divides holomorphically by +the canonical section of \(mR\). Conversely, multiplication gives a +section of \(mL\). The actual rational line identity makes these operations +inverse after clearing denominators. +\end{proof} + +\begin{lemma}[Uniqueness when the positive part is torsion] +\label{bir:unique-current} +Suppose \(L\sim_{\Q}R\), where \(R=N(L)\) is an effective rational +divisor on a smooth compact Kähler manifold. Then the only positive current +in \(c_1(L)\) is \([R]\). If \(F\geq0\) is a rational divisor and +\(L-F\) is pseudo-effective, then +\[ + F\leq R,\qquad L-F\sim_{\Q}R-F=N(L-F). +\] +The same conclusions hold if \(L\sim_{\Q}P+R\) with \(P\) torsion. +\end{lemma} + +\begin{proof} +Write \(X\) for the manifold. The assertion is immediate if \(\dim X=0\), +so assume \(\dim X>0\). +Every positive current \(T\) in \(c_1(L)\) contains \([R]\). The +residual \(T-[R]\) is positive with zero cohomology class, so its mass +against a Kähler form to the power \(\dim X-1\) is zero. Thus it vanishes. +For the second assertion, add \([F]\) to any positive current in +\(c_1(L-F)\). Uniqueness gives \(F\leq R\), and subtraction in +Lemma~\ref{bir:calculus} gives the asserted negative part. A torsion line +has zero Chern class and becomes trivial after taking a positive multiple, +so the last statement is the same argument. +\end{proof} + +\subsection{Birational transfer of the decomposition} + +All modifications resolving spaces, maps, or ideals can be chosen +projective. A projective modification of a compact Kähler space is Kähler; +graphs between compact Kähler models can likewise be resolved by smooth +compact Kähler manifolds. We use these standard analytic resolution and +flattening results without further mention. + +For log discrepancies our convention is +\[ + a(E;X,\Delta)=1+\ord_E\bigl(K_Y-p^*(K_X+\Delta)\bigr) +\] +on a smooth model \(p:Y\to X\). In particular, on a log resolution of an +lc pair, giving each new exceptional divisor coefficient one produces an +effective exceptional error. The next proposition explains why this +convention is harmless. + +\begin{proposition}[Resolution and descent]\label{bir:resolution-transfer} +Let \((X,\Delta)\) be a normal compact Kähler lc pair with rational +boundary and rational Cartier adjoint \(J\). Let \(p:Y\to X\) be a log +resolution, and put +\[ + B_Y=p_*^{-1}\Delta+\sum_{E\text{ exceptional}}E. +\] +If \(p^*J\) is pseudo-effective and the conclusion of +Definition~\ref{def:good-decomposition} holds for \((Y,B_Y)\), then there +is a smooth compact Kähler modification \(r:V\to X\) with an actual +rational line identity +\[ + r^*J\sim_{\Q}P+R,\qquad P\text{ semiample},\qquad + R=N(r^*J)\geq0, +\] +where \(R\) is a rational divisor. +If \(J\) is analytically nef, it is semiample on \(X\). +\end{proposition} + +\begin{proof} +With compatible canonical choices there is an actual rational divisor +identity +\[ + K_Y+B_Y=p^*J+E_p,\qquad + E_p=\sum_{E\text{ exceptional}}a(E;X,\Delta)E\geq0. +\] +Suppose \(q:V\to Y\) realizes the decomposition for the left side. +Lemma~\ref{bir:exceptional}, applied over \(X\), gives +\[ + N\bigl(q^*(K_Y+B_Y)\bigr) + =N(q^*p^*J)+q^*E_p. +\] +Cancelling \(q^*E_p\) in the actual rational line identities proves the +first assertion. This argument also shows that further resolutions using +the reduced-exceptional convention do not change the assertion +\(\Ggood_n\). + +If \(J\) is nef, its pullback is nef, so its negative part is zero. The +semiample line in the decomposition is therefore \(q^*p^*J\) itself, up +to rational line isomorphism. Choose an actual Cartier multiple generated +on \(V\). Normality gives \((p q)_*\OO_V=\OO_X\), and projection formula +identifies its sections with the sections downstairs. A base point +downstairs would make every pullback section vanish on its nonempty fiber. +There is no such point, so that multiple of \(J\) is globally generated. +\end{proof} + +The second transfer concerns a torsion positive part. Its proof uses the +following local construction for finite maps, which will also be used for +meromorphic sections and for covers of spaces of algebraic dimension zero. + +\begin{lemma}[Finite analytic norms and characteristic polynomials] +\label{bir:finite-norm} +Let \(\nu:Z\to X\) be a finite surjective morphism of normal irreducible +complex spaces, of degree \(d>0\), and let \(L\) be a holomorphic line +bundle on \(X\). A nonzero meromorphic section \(s\) of \(\nu^*L\) +has a nonzero meromorphic norm \(\operatorname{Nm}_\nu(s)\) in +\(L^{\otimes d}\), with +\[ + \operatorname{div}(\operatorname{Nm}_\nu(s)) + =\nu_*\operatorname{div}(s). +\] +If \(s\) is holomorphic, its norm is holomorphic. If, in addition, +\(s\) is nonzero at every point of \(\nu^{-1}(x)\), then its norm is +nonzero at \(x\). + +For a global meromorphic function \(f\) on \(Z\), there is a monic +polynomial \(\chi_f(T)\) of degree \(d\) with global meromorphic +coefficient functions on \(X\) such that \(\chi_f(f)=0\) after pulling +the coefficients to \(Z\). +\end{lemma} + +\begin{proof} +At \(x\in X\), choose a holomorphic frame of \(L\) and put +\[ + R=\OO_{X,x},\qquad K=\operatorname{Frac}(R),\qquad + A=(\nu_*\OO_Z)_x. +\] +The generic algebra \(A\otimes_RK\) is a product of finite field +extensions of \(K\), of total dimension \(d\). The local meromorphic +coefficient \(a\) of \(s\) belongs to this algebra. Since \(Z\) is +irreducible and \(s\) is not identically zero, its restriction is nonzero +on every generic local component. Thus \(a\) is nonzero in every field +factor, and the determinant of multiplication by \(a\) is nonzero. +Under a change of frame by a unit \(g\), this determinant changes by +\(g^{-d}\). The determinants therefore glue to the asserted +meromorphic section. The valuation formula for a norm over a discrete +valuation ring gives the displayed divisor identity at every prime of +the normal space \(X\). + +If \(s\) is holomorphic, then \(a\in A\) is integral over \(R\). +Its norm is integral over \(R\) and belongs to \(K\), hence belongs to +\(R\) by normality. This does not require \(A\) to be locally free. +If \(s\) is nonzero at every point over \(x\), then \(a\) is a unit +in the finite semilocal algebra \(A\); applying the same argument to +\(a^{-1}\) shows that its norm is a unit in \(R\). + +For a meromorphic function \(f\), use instead the determinant of +\(T\) minus multiplication by its local coefficient. These monic +polynomials agree on overlaps, and Cayley--Hamilton shows that they +annihilate \(f\). All these constructions use fractions of local analytic +germs, so they remain available when the global meromorphic functions on +\(X\) are constant. +\end{proof} + +We now descend a decomposition whose positive part is torsion, the form +needed for a covering family on a space of algebraic dimension zero. + +\begin{proposition}[Descent of a purely negative decomposition] +\label{bir:finite-descent} +Let \(e:Y\to X\) be a proper generically finite surjective morphism +between connected smooth compact Kähler manifolds. Let \(L\) be a +pseudo-effective rational line on \(X\), and let \(F\geq0\) be a +rational divisor on \(Y\). Suppose that on a smooth model over \(Y\), +the line \(e^*L+F\) is rationally linearly equivalent to its rational +negative part. Then there is an effective rational divisor \(D\) on +\(X\) such that +\[ + L\sim_{\Q}D=N(L). +\] +\end{proposition} + +\begin{proof} +Replace \(Y\) by the smooth model in the hypothesis and pull \(F\) back. +Write \(e^*L+F\sim_{\Q}R=N(e^*L+F)\). Pull back a positive current in +\(c_1(L)\) and add \([F]\). Lemma~\ref{bir:unique-current} gives +\(F\leq R\). Put \(D_Y=R-F\). Subtraction in +Lemma~\ref{bir:calculus} gives +\[ + e^*L\sim_{\Q}D_Y=N(e^*L)\geq0. +\] +In particular \([D_Y]\) is the unique positive current in \(c_1(e^*L)\). + +Choose \(m\) so that \(mL\) and \(mD_Y\) are integral and the latter is +the divisor of a holomorphic section \(s\) of \(e^*(mL)\). Factor \(e\) +through its normal Stein space: +\[ + Y\xrightarrow{h}Z\xrightarrow{\nu}X, + \qquad \nu\text{ finite of degree }d=\deg e. +\] +The connected birational map \(h\) descends \(s\) to a holomorphic +section \(s_Z\) of \(\nu^*(mL)\), by normality and projection formula. +Lemma~\ref{bir:finite-norm} gives a holomorphic section of \(mdL\) whose +divisor is +\[ + \operatorname{div}(\operatorname{Nm}_\nu(s_Z)) + =\nu_*\operatorname{div}(s_Z)=m e_*D_Y. +\] +Thus \(D=d^{-1}e_*D_Y\) is effective and satisfies \(L\sim_{\Q}D\). + +Both \(e^*D\) and \(D_Y\) are positive divisor currents in +\(c_1(e^*L)\), so uniqueness gives \(e^*D=D_Y\). We already know +\(N(L)\leq D\). If this inequality were strict at a prime \(A\subset X\), +choose analytic-singularity tests for \(L\) whose generic orders at \(A\) +tend to \(\nu_A(L)\), and pull them to \(Y\). For any prime \(A'\) +dominating \(A\), the generic orders are multiplied by +\(\operatorname{mult}_{A'}e^*A\). The pulled-back Kähler errors can be +enlarged to Kähler errors upstairs tending to zero. Consequently +\[ + \nu_{A'}(e^*L) + \leq \operatorname{mult}_{A'}(e^*A)\,\nu_A(L) + <\operatorname{mult}_{A'}(e^*A)\,\operatorname{coeff}_A(D), +\] +contrary to \(N(e^*L)=D_Y=e^*D\). This proves \(D=N(L)\). +\end{proof} + +We will also use Proposition~\ref{bir:finite-descent} when \(e\) is a +modification and \(F=0\). Once the positive part of a decomposition is +known to be torsion, it gives \(L\sim_{\Q}N(L)\) on the original smooth +space; Lemma~\ref{bir:pullup} then identifies the negative divisor upstairs +with the pullback of \(N(L)\). + +\subsection{The projective anchor and the two geometric cases} + +\begin{proposition}[Projective good models]\label{proj:good-models} +Under Assumption~\ref{asm:log-iitaka}, every projective lc pair over +\(\C\) with rational boundary and pseudo-effective rational Cartier +adjoint has a good log minimal model. In particular, \(\Ggood_n\) holds +for projective manifolds in every dimension, and every nef rational lc +adjoint on a projective variety is semiample as an actual rational line. +\end{proposition} + +\begin{proof} +The good-model assertion is the rational-boundary consequence of the full +argument in \cite[Proposition~2.5, Theorem~9.6, and Section~10]{LI}. That +argument establishes the additional inductive and nonvanishing premises of +its Proposition~2.5 before applying it, and proves a stronger real-boundary +induction. Its only use of Assumption~\ref{asm:log-iitaka} is in its +Lemma~6.1, on a resolved projective Albanese fibration with both boundaries +zero. Thus its premise is precisely available here. + +For clarity, its good-model conclusion gives on a common smooth projective +resolution +\[ + u^*(K_X+B)=v^*(K_{X_m}+B_m)+F, + \qquad F\geq0\text{ and }v\text{-exceptional}, +\] +as an actual rational divisor identity; the line on \(X_m\) is semiample. +This is the comparison in \cite[Lemma~2.2]{LI}. Algebraic nefness of a +rational line on a projective variety implies analytic nefness, by adding +arbitrarily small ample rational classes. Lemma~\ref{bir:exceptional} +therefore identifies \(F\) with the analytic negative part of the left +side. On a smooth projective variety, analytic pseudo-effectivity of a +divisor class agrees with algebraic pseudo-effectivity +\cite[Proposition~1.2]{BDPP}; hence the good-model assertion applies to +every projective instance of \(\Ggood_n\). This proves the stated form of +\(\Ggood_n\). If the original adjoint +is nef, the same comparison and normal descent give its semiampleness. +\end{proof} + +The remainder of the paper proves the following two propositions. They +are stated here so that the global induction can be completed before its +technical components are developed. A compact space is \emph{simple} if +no positive-dimensional proper compact analytic subvariety passes through +a very general point. We write \(a(X)\) for its algebraic dimension. + +\begin{proposition}[The fibration case]\label{rank:fibration-case} +Assume Assumption~\ref{asm:log-iitaka}. Fix \(n>0\) and assume +\(\Ggood_j\) for \(j0\) and assume \(\Ggood_j\) for \(j0\). + +If \(a(X)=n\), the Kähler Moishezon theorem makes \(X\) projective, and +Proposition~\ref{proj:good-models} applies. If \(00\) and the evaluation ideal +\[ + \operatorname{im}\bigl(f^*f_*\OO_T(rJ)\longrightarrow\OO_T(rJ)\bigr) + =\mathcal I\otimes\OO_T(rJ). +\] +Outside the exceptional locus of \(f\), evaluation is an isomorphism. +On a positive-dimensional projective fiber, every section vanishes: +\(rJ\) has negative degree on every fiber curve, and curves cover +every positive-dimensional fiber component. Connectedness gives the +same vanishing on the whole nontrivial fiber. Hence the zero set of +\(\mathcal I\) is exactly the exceptional locus. On a common +resolution principalizing \(\mathcal I\), relative generation on +the positive side identifies \(rF\) in +Equation~\eqref{prog:comparison} with the divisor of +\(\mathcal I\OO_W\). Thus \(\Supp F\) is the full inverse image +of that locus. On a common resolution of a longer negative program, +discrepancy monotonicity makes the cumulative comparison dominate +this first-step divisor. These are support statements for the actual +comparison, stronger than effectiveness and exceptionality alone. + +We next state the restricted model inputs used in this section. A nef +b-class is a Bott--Chern class that is globally nef on one fixed smooth +compact Kähler carrier, with its linear traces on the other models. The +generalized adjoint on \(T\) is +\(\alpha=\{K_T+B\}+\beta_T\). Generalized klt, abbreviated gklt, +means that all generalized log discrepancies, computed on that carrier, +are positive. The modified-bigness hypothesis below concerns the whole +boundary-plus-nef trace \(\{B\}+\beta_T\). We use the convention of +\cite[Definition~2.8]{HX}: a modified-big trace is the pushforward of +a big Bott--Chern class on a modification. The trace itself may be +a current; the generalized adjoint is required to define a +Bott--Chern class. +For a proper map $f:T\to S$, let $q_f$ be the quotient map to +$H^{1,1}_{\BC}(T,\R)/f^*H^{1,1}_{\BC}(S,\R)$. Relative +pseudo-effectivity means +$q_f(\alpha)\in\overline{q_f(\operatorname{Psef}(T))}$, where +$\operatorname{Psef}(T)$ is the absolute pseudo-effective cone. +Equivalently, for Kähler classes $\omega_T,\omega_S$, the class +$\alpha$ is pseudo-effective over $S$ if for every $\epsilon>0$ +some $c_\epsilon\geq0$ makes +$\alpha+\epsilon\omega_T+c_\epsilon f^*\omega_S$ big. +This imposes no projectivity hypothesis on $f$. For the actual +relative line classes of an already projective map, this is the +usual relative pseudo-effective cone. + +\begin{proposition}[Restricted Kähler model inputs]\label{prog:mori} +Let \((T,B+\boldsymbol\beta)\) be an effective compact Kähler gklt +pair of dimension \(d\), with \(T\) globally strongly +\(\Q\)-factorial. Suppose that its nef b-data are globally nef on a +fixed smooth carrier and that \(\{B\}+\beta_T\) is globally +modified big. Write \(\alpha=\{K_T+B\}+\beta_T\). +\begin{enumerate} +\item If \(\alpha\) is nef, there is a proper morphism with connected +fibers \(g:T\to Z\) to a normal compact Kähler space and a Kähler +class \(\omega_Z\) such that \(\alpha=g^*\omega_Z\). +\item For a proper morphism \(\pi:T\to V\) to a normal compact +Kähler space, if \(\alpha\) is pseudo-effective over \(V\), there +is a chosen good log terminal model over \(V\). It is nonextracting, +compact Kähler and globally strongly \(\Q\)-factorial. Its adjoint +is nef over \(V\), and on a common projective resolution its comparison +with \(\alpha\) is effective and exceptional over the new model, +with strictly positive coefficient at every prime contracted from \(T\). +The construction retains compatible forward Bott--Chern traces of the +specified data on a common smooth carrier. +\item A compact polytope of these data on one fixed carrier has +finitely many marked relative canonical models and relative weak log +canonical models with normal compact Kähler targets. +\end{enumerate} +The relative assertion applies to proper morphisms, without assuming +that \(\pi\) is projective. It is an assertion about a chosen model, +not termination of every generalized flip sequence. +\end{proposition} + +\begin{proof} +These are the semiampleness, proper relative model and finite-model +assertions of Theorem~\ref{prog:restricted-package}, proved below +by dimension induction independently of \(\Ggood\). +Finite marked weak-model geography is recorded in +Lemma~\ref{prog:finite-geography}. Projective analytic model +constructions used in that induction are supplied by +Proposition~\ref{prog:projective-good-model}. None of these statements +promotes an undetected generalized-ray contraction to a projective map. +\end{proof} + +We use separately the analytic cone theorem +\cite[Theorem~1.3]{HX}: an \(\alpha\)-negative analytic extremal ray +of an effective gklt adjoint has a rational curve generator \(C\) with +\(0<-\alpha\cdot C\leq2d\). Existence of the supporting contraction +in the applications below follows from the nef assertion above. +When an ordinary rational adjoint is negative on that ray, +Lemma~\ref{prog:detected-projectivity} and +Proposition~\ref{prog:detected-flip} give its projective contraction and ordinary +flip. We call these \emph{detected ordinary steps}. + +The Bott--Chern transform through such a birational step has a concrete +description which does not require the source to be smooth. Write the +step as \(T\xrightarrow{f}Z\xleftarrow{f^+}T^+\), with +\(f^+=\id\) for a divisorial contraction, and let \(J\) be its +negative rational adjoint. For \(\gamma\in H^{1,1}_{\BC}(T,\R)\), +choose the unique real number \(c\) for which +\(\gamma-c\{J\}\) annihilates the contracted analytic ray. +Every contracted curve is on that ray. Lemma~\ref{prog:bc-descent} +therefore gives a unique class \(\delta\) on \(Z\) with +\(\gamma-c\{J\}=f^*\delta\), and we put +\[ + \gamma^+=(f^+)^*\delta+c\{J^+\}. +\] +The rational-singularity and vanishing hypotheses of that lemma hold: +slightly lowering the rational Cartier floor gives a klt adjoint still +antiample over \(Z\), and relative vanishing gives rational +singularities on the base. On a common resolution, the pullback +difference is \(c\) times the adjoint comparison in +Equation~\eqref{prog:comparison}; it is exceptional over the new +model, and over both models in a flip. This defines a linear transform. +For the Chern class of a rational line it agrees with its reflexive trace, +by the coherent line comparison \cite[Lemma~7.2]{CB} and exceptional +negativity. The already-projective relative program below only needs a +ray for degrees of global rational lines; this Bott--Chern construction +is used for its subsequent detected analytic-ray programs. + +When such a class difference lies in an exceptional divisor span, we write +it as \(\{F\}\) for the representing real exceptional divisor \(F\). +This divisor is unique: an exceptional divisor with zero class has zero +degree on every contracted curve, and exceptional negativity applied to +both signs makes it zero. + +We also use local projective analytic results. For a projective +analytic morphism over a Stein neighborhood of a compactum with +Fujino's property (P), relative klt base point freeness says that, if +\(L\) is a relatively nef Cartier line and +\(aL-(K+\Gamma)\) is relatively ample for some positive integer +\(a\), then all sufficiently high powers of \(L\) are relatively +generated after shrinking +\cite[Theorems~6.2 and 6.5]{FujinoAnalyticBCHM}. +We use the finite negative-ray truncation in the relative cone theorem +in the same setting. Finally, the multigraded adjoint finite-generation +theorem applies to a projective morphism from a smooth space, for simultaneous +effective SNC klt boundaries with a common relatively ample rational +summand \cite[Theorem~3.1]{DHP}. Finitely many smaller Stein +neighborhoods suffice over a compact base. + +\begin{lemma}[Descent without changing a Cartier exponent] +\label{prog:integral-descent} +Let \(f:T\to Z\) be a projective bimeromorphic contraction with normal +target. Suppose an ordinary rational klt adjoint is \(f\)-antiample. +If a Cartier line \(L\) has degree zero on every contracted curve, +then \(f_*L\) is an invertible sheaf and evaluation is an isomorphism +\[ + f^*(f_*L)\simeq L. +\] +The same conclusion holds for an ordinary dlt adjoint whose floor is +rational Cartier and which is \(f\)-antiample. In a flip, a line with +zero contracted degree therefore has the same Cartier exponent on +both sides, and the two lines are pullbacks of a line on the common +base. +\end{lemma} + +\begin{proof} +For dlt input, decrease the floor by a sufficiently small positive +rational multiple. The resulting pair is klt and remains +\(f\)-antiample. For this klt pair the base point free hypothesis +holds for \(L\), because \(L\) has zero fiber degrees and the negative +adjoint is relatively ample. Over a smaller base neighborhood every +sufficiently high power of \(L\) is therefore generated. The +associated morphism is constant on each connected fiber: its +tautological line has degree zero on every fiber curve, and every +positive-dimensional projective image contains a curve. Its graph +then factors through \(Z\); the graph projection is finite +bimeromorphic and \(Z\) is normal. Descend two consecutive generated +powers \(L^k,L^{k+1}\) to lines \(M_k,M_{k+1}\). The line +\(M_{k+1}\otimes M_k^{-1}\) pulls back to \(L\). Projection formula +identifies this quotient with +\(f_*L\), so these local descents and their evaluation maps agree on +overlaps. Pull the descended line to the positive side of a flip. +This is the argument of \cite[Lemma~7.4]{CB}. +\end{proof} + +\subsection{Relative klt programs and small models} + +The local finite-generation theorem also supplies an ordinary klt program +over a compact base. We use it to obtain globally strongly +\(\Q\)-factorial small models of strata. The construction keeps track of +degrees of global rational lines, which are the degrees needed for exact +Cartier descent. + +\begin{proposition}[Relative klt programs over a compact base] +\label{prog:relative-klt} +Let \(\pi:T\to V\) be projective bimeromorphic, where \(V\) is a +normal compact Kähler space and \(T\) is normal, compact Kähler, and +globally strongly \(\Q\)-factorial. Let \((T,B)\) be an effective +rational klt pair with rational-line adjoint \(J=K_T+B\). +There is a finite sequence of ordinary \(J\)-negative steps over +\(V\), all projective over \(V\), whose last adjoint is curve-nef +over \(V\), meaning that it has nonnegative degree on every curve +contracted over \(V\). Every working space is compact Kähler and globally +strongly \(\Q\)-factorial. On a common resolution the comparison +from the first adjoint to the last is effective and exceptional over +the last space. +\end{proposition} + +\begin{proof} +We give the reduction to the local finite-generation input, including why +it yields a single finite program over the compact base. Let +\(\mathcal N_{\R}\) be the finite-dimensional space of degrees of global +rational lines on curves over \(V\), and put \(r=\dim\mathcal N_{\R}\). +If \(r=0\), then \(J\) is already curve-nef. Assume \(r>0\). Choose +rational lines \(H_1,\ldots,H_r\) whose degree classes form a basis and +such that both \(H_i\) and \(J+H_i\) are relatively ample. Such a basis +exists because the relatively ample classes whose sum with \(J\) is also +relatively ample form a nonempty open set containing sufficiently positive +classes. Define the rational simplex of adjoints +\[ + \Pi=\operatorname{conv}\{J,J+H_1,\ldots,J+H_r\}. +\] +We will choose a general direction \(H=\sum_i\theta_iH_i\) with +\(\theta_i>0\) and \(\sum_i\theta_i=1\). Its entire scaling segment lies +in this simplex: +\[ + J+tH=(1-t)J+\sum_i t\theta_i(J+H_i)\in\Pi + \qquad(0\leq t\leq1), +\] +and it lies in the relative interior for \(0t\) for which \(J+sH\) is +relatively ample. On the zero face of the normalized compact curve slice, +\[ + J=-\frac{t}{s-t}(J+sH) +\] +in degrees. Thus \(J\) is uniformly negative on that face. Choose the +positive ample truncation so that its compact remainder \(K\) misses the +face. The finite rational polyhedral test and the general choice of \(H\) +make the face a single ray \(R\). The wall class has a positive minimum on +\(K\) and is positive on every other truncated curve generator. Hence a +sufficiently small open neighborhood of \(w\) inside the annihilator +\(R^\perp\) consists of nef classes with zero face exactly \(R\). + +Suppose first that \(R^\perp\) has positive dimension. It is a rational +hyperplane because \(R\) is represented by an integral curve. Choose a +rational simplex of support classes in that neighborhood containing the +degree class of \(w\) in its relative interior, and represent each vertex +by a rational line \(N\). For each such \(N\), compactness gives an +integer \(a>0\) for which \(aN-J\) is relatively ample. Relative base +point freeness contracts exactly \(R\) and descends \(N\) to a relatively +ample rational line on the contraction base. These bases agree because +the contracted curves agree. The difference between \(w\) and the +corresponding convex combination of these rational lines has zero +relative degree. In the finite rational span of the lines involved, the +degree map has rational kernel, since rational lines have rational degrees +on integral curves. The difference is therefore a real combination of +rational lines of zero relative degree. Lemma~\ref{prog:integral-descent} +descends these lines, and lifting curves from the base shows that their +descents still have zero degree over \(V\). They do not affect relative +ampleness. Convexity now shows that \(w\) descends to a relatively ample +real line class over \(V\). If \(R^\perp=0\), the same zero-degree descent +applies to \(w\); the contraction base has no curves over \(V\), hence is +finite over \(V\), and relative ampleness is automatic. + +After a flip, let \(w^+\) be the pullback of this wall class to the positive +side. For sufficiently small \(\delta>0\), +\[ + J^++(t-\delta)H^+ + =\left(1-\frac{\delta}{t}\right)w^+ + +\frac{\delta}{t}J^+ +\] +is relatively ample over \(V\): the wall is pulled back from a relatively +ample class on the contraction base, and \(J^+\) is relatively ample over +that base. After a divisorial contraction, openness of the ample cone on +the base gives the same nonempty interval of relative ampleness. + +Each working model is consequently one of the marked ample models +already counted. Indeed, for a fixed finite prefix and an interior +parameter \(00\) for which +\((S,\Delta-\epsilon D)\) is effective and klt. On a projective log +resolution \(r:W\to S\), use the strict lowered boundary and give +every exceptional prime a coefficient strictly between its crepant +coefficient and \(1\), and at least zero. The resulting klt adjoint +has the actual form +\[ + K_W+\Gamma\sim_{\Q}r^*(K_S+\Delta-\epsilon D)+F, + \qquad F\geq0, +\] +where every \(r\)-exceptional prime has positive coefficient in +\(F\). Apply Proposition~\ref{prog:relative-klt} over \(S\). +On its endpoint the trace \(F_Y\) is effective, exceptional over +\(S\), and relatively nef. Negativity makes \(F_Y=0\). +Since all initially exceptional primes had positive coefficient, +\(Y\to S\) is small and the lowered adjoint is crepant. +Restoring \(\epsilon D\) gives the full crepant identity. + +A projective small morphism to a smooth germ is an isomorphism: +transport a relatively ample line to the smooth germ, where it is +Cartier; smallness makes the original line its pullback, contradicting +relative ampleness on a nontrivial fiber. Thus \(h\) is an isomorphism +over an SNC open meeting all lc centers of the dlt pair. The full +crepant comparison then proves dlt on \(Y\). +\end{proof} + +\subsection{Scaling toward zero and keeping a nef rational line} + +The next construction runs every positive truncation of an ordinary +dlt scaling. It also explains why a sufficiently large multiple of +a prescribed nef rational line forces every step to be trivial for +that line. The integer that clears the line will be the same at +every step. + +For the detected ordinary scalings constructed below, let +\(\alpha_0(\lambda)=\{H\}+\lambda\omega\) on the first space +\(T_0\), with initial parameter \(1\), and let \(\alpha_i(\lambda)\) +be its linear transform on a working model \(T_i\). Put +\(\lambda_{-1}=1\). If the next step occurs at threshold +\(\lambda_i\), its ray is annihilated by \(\alpha_i(\lambda_i)\) +and is negative for \(\alpha_i(0)\). The trace \(\alpha_i(\lambda)\) +is nef on \([\lambda_i,\lambda_{i-1}]\), which we call its +\emph{working interval}. If \(\alpha_i(0)\) is nef, we set +\(\lambda_i=0\) and stop. Working intervals are allowed to be +degenerate; strict decrease of positive thresholds will be arranged only +in the proof of special termination. + +\begin{lemma}[Positive truncations and a fixed nef line] +\label{prog:nef-trivial} +Let \((T,B)\) be an effective rational dlt pair on a globally strongly +\(\Q\)-factorial compact Kähler \(d\)-fold, and put \(J=K_T+B\). +\begin{enumerate} +\item For a sufficiently large Kähler class \(\omega\), there is an +ordinary \(J\)-program with scaling of \(\omega\), starting with +\(\{J\}+\omega\) Kähler. Every positive truncation is finite. +If \(J\) is pseudo-effective, the program either reaches a nef adjoint +or has positive thresholds tending to zero. If \(J\) is not +pseudo-effective, the program is finite and ends with a Mori fiber +contraction. +\item Let \(P\) be a nef rational line with \(mP\) Cartier, and choose +\(b\in\Q\) with \(b>4dm\). The same alternatives hold for +\(H=J+bP\), according to pseudo-effectivity of \(H\), with +\(\omega\) enlarged if necessary. Every birational step is an ordinary +\(J\)-negative step on which \(P\) is trivial, and the final Mori +ray, if present, is also \(P\)-trivial. The same line \(mP\) descends +through every birational contraction and pulls back to its positive +side. Its traces remain analytically nef; if \(P\) is semiample, its +same generated multiple and associated morphism are preserved, also +through the final Mori contraction. +\end{enumerate} +\end{lemma} + +\begin{proof} +Write \(H=J\) in the first case and \(H=J+bP\) in the second. +Fix \(\omega\) with \(\{H\}+\omega\) Kähler. For each +\(0<\eta<1\), choose a positive rational \(\epsilon\) so small that, +with \(F=\lfloor B\rfloor\), +\[ + (T,B-\epsilon F)\ \text{is klt},\qquad + \eta\omega+\epsilon\{F\}\ \text{is Kähler}. +\] +For \(\lambda\in[\eta,1]\) use the presentations +\[ + \{H\}+\lambda\omega + =\{K_T+B-\epsilon F\} + +\bigl(b\{P\}+\lambda\omega+\epsilon\{F\}\bigr), +\] +omitting \(b\{P\}\) in the first case. Their b-data are globally +nef on the fixed initial carrier, and their boundary-plus-nef traces +are globally modified big. These are effective gklt data. + +We first construct a step whenever the unscaled working trace is not +nef. Choose a positive shift strictly below the current wall and use the +gklt presentation of its current trace \(A\). The ray at the wall is +\(A\)-negative. On a compact slice of the analytic curve cone, the +cone theorem makes the \(A\)-negative part locally polyhedral after +a sufficiently small positive Kähler truncation. Separating the +chosen extremal ray from the other finitely many rays in that +truncation gives a Kähler class \(\omega_R\) such that +\(A+\omega_R\) is nef and its zero face is precisely this ray; +see the supporting construction in Proposition~\ref{prog:ordinary-step}. +Add the pullback of this new Kähler class to the fixed nef carrier. +The resulting adjoint still has globally nef data and modified-big +boundary-plus-nef trace, so the nef assertion of +Proposition~\ref{prog:mori} supplies its supporting contraction. +This uses a new supporting direction on the current space; it does +not require the trace of the original scaling direction to be Kähler. +We verify a rational ordinary detector before asserting projectivity +or constructing a flip. +In the second case nefness of \(P\) makes \(J\) negative on the ray; +the first case has this property directly. Lower the floor by a small +rational amount, retaining negativity of \(J_\epsilon\), so that +\(-J\cdot R\leq2(-J_\epsilon\cdot R)\). The ordinary klt cone +length bound gives a rational curve generator \(C\) with +\[ + 0<-J\cdot C\leq4d. +\] +In the second case, if \(P\cdot C>0\), integrality of \(mP\) gives +\(P\cdot C\geq1/m\), contradicting +\[ + H\cdot C\geq-4d+b/m>0. +\] +Thus in that case the ray is \(P\)-trivial. The lowered ordinary adjoint is a +global rational detector. The detected projectivity and flip +constructions in Lemma~\ref{prog:detected-projectivity} +and Proposition~\ref{prog:detected-flip} supply the projective ordinary step. +The difference of \(J\) and a positive rational multiple of the +lowered adjoint has zero contracted degree; exact descent in +Lemma~\ref{prog:integral-descent} shows that restoring the floor +preserves the positive-side sign. This is the ordinary replacement +of Proposition~\ref{prog:ordinary-replacement}, and the full pair +remains dlt by Equation~\eqref{prog:comparison}. + +In the second case, Lemma~\ref{prog:integral-descent} descends the actual Cartier line +\(mP\) without changing \(m\). Analytic nefness descends and pulls +back under these projective contractions \cite[Lemma~2.44]{HX}. +A generated multiple descends as a generated line by projection +formula and pulls back as one. Thus the same length estimate and the +same \(b\) apply at the next step. The corresponding assertion on +a final Mori ray follows from exactly the same estimate. For a +semiample \(P\), the map of its fixed generated multiple is constant +on each connected projective contracted fiber: otherwise its image +contains a curve of positive degree. The map therefore factors through +the normal contraction base, including in the fiber-type case. + +The traces used in this construction are linear by the degree-zero +descent description preceding Lemma~\ref{prog:integral-descent}. +At a wall the scaled class is pulled back from its base. The comparison +for an earlier parameter is a nonnegative multiple of the ordinary +adjoint comparison. Consequently the gklt presentations on any fixed +positive segment remain gklt along its program, and every working +model is a weak model for a member of that segment. The finite marked +weak-model assertion in Proposition~\ref{prog:mori} applies. +A marked model cannot recur: its boundary trace would be the same, +whereas a nontrivial intervening ordinary step strictly increases a +discrepancy. There are therefore only finitely many steps with +threshold at least \(\eta\). + +For decreasing cutoffs, any already-constructed finite prefix remains +valid. The floor perturbations cancel in the displayed classes and +continue to cancel under their linear transforms; their nonpositive +comparisons preserve the new gklt data. Starting at its last nef wall +therefore extends the prefix to the smaller cutoff. This gives one +compatible scaling program. A positive limiting threshold would lie +in a finite positive truncation, so an infinite program has limit zero. +Pseudo-effectivity excludes a negative Mori endpoint. If \(H\) is +not pseudo-effective, its pseudo-effective threshold in the initial +Kähler direction is positive. Every nef working trace, together with +its effective exceptional comparison, makes the initial scaled class +pseudo-effective, so the scaling thresholds are bounded below by +that positive number. The program is therefore finite. Its endpoint +cannot be nef, since that comparison would make \(H\) +pseudo-effective; it is the stated Mori fiber contraction. +\end{proof} + +We call these programs \emph{detected ordinary scalings}. Their steps +are ordinary negative steps of one analytic extremal ray, with the +linear Bott--Chern transform described above. +The next lemma connects their nef working traces +to the analytic negative part, including its limit at parameter zero. + +\begin{lemma}[Negative parts along a detected ordinary scaling] +\label{prog:negative-along-scaling} +In a scaling from Lemma~\ref{prog:nef-trivial}, write \(H=J\) in its first +case and \(H=J+bP\) in its second, and use the notation +\(\alpha_0(\lambda)=\{H\}+\lambda\omega\) above. For a parameter +\(\lambda\) in the working interval of \(T_i\), a common smooth +resolution \(p:W\to T_0\), \(q:W\to T_i\) gives +\begin{equation} + p^*\alpha_0(\lambda)=q^*\alpha_i(\lambda)+\{E_i(\lambda)\}, + \qquad E_i(\lambda)\geq0,\qquad q_*E_i(\lambda)=0. + \label{prog:working-negative} +\end{equation} +Here \(E_i(\lambda)\) is an actual real exceptional divisor, and +\[ + N(p^*\alpha_0(\lambda))=E_i(\lambda). +\] +For the limit statement, let \(H\) be any rational line on a normal compact +Kähler space \(T\) whose pullback to a smooth resolution is +pseudo-effective, and let \(A\) be a Kähler class on \(T\). On any fixed +smooth resolution \(r:U\to T\) and for every prime \(Q\subset U\), +\[ + \lim_{\lambda\downarrow0}\nu_Q(r^*(\{H\}+\lambda A)) + =\nu_Q(r^*\{H\}). +\] +Thus the same convergence holds for every divisorial place, after choosing +a resolution on which it appears. +\end{lemma} + +\begin{proof} +For \(\lambda\) in the working interval of \(T_i\), every earlier +threshold is at least \(\lambda\). Each earlier step is therefore negative +or trivial for this parameter. Composing its comparisons gives +Equation~\eqref{prog:working-negative}. Since \(\alpha_i(\lambda)\) is +nef, Lemma~\ref{bir:exceptional} identifies the exceptional divisor with +the negative part. + +On the fixed resolution \(U\), choose a Kähler class \(\Omega\) and +\(c>0\) such that \(c\Omega-r^*A\) is Kähler. Monotonicity of each +minimal multiplicity under addition of a nef class gives +\[ + \nu_Q(r^*\{H\}+\lambda c\Omega) + \leq \nu_Q(r^*(\{H\}+\lambda A)) + \leq \nu_Q(r^*\{H\}). +\] +The left side tends to the right side by the definition using small Kähler +perturbations. This proves the convergence on \(U\), and the same argument +applies on a resolution representing any chosen divisorial place. +\end{proof} + +\begin{proposition}[Contracting a known negative part] +\label{prog:contract-negative} +Let \((T,B)\) be an effective rational dlt pair on a globally +strongly \(\Q\)-factorial compact Kähler space, and put \(J=K_T+B\). +Suppose there is an actual rational-line identity +\[ + J\sim_{\Q}P+E, +\] +where \(P\) is analytically nef, \(E\) is an effective rational +Cartier divisor, and, on one smooth compact Kähler resolution +\(\pi:W\to T\) projective over \(T\), +\[ + N(\pi^*\{J\})=\pi^*E. +\] +There is a finite ordinary \(J\)-negative program to a nef model +\(T'\) which contracts precisely the prime components of \(E\) +among the primes of \(T\). Every step is \(P\)-trivial, with a +fixed Cartier exponent as in Lemma~\ref{prog:nef-trivial}, and +\[ + J_{T'}\sim_{\Q}P_{T'}. +\] +If \(P\) is semiample, then so is this actual last adjoint. +\end{proposition} + +\begin{proof} +Lemma~\ref{bir:pullup} makes the stated equality valid on any +higher resolution. Choose \(b\) as in +Lemma~\ref{prog:nef-trivial}. Adding \(bP\) leaves the same +negative part. Indeed, on a smooth resolution write +\(\alpha=\pi^*\{J\}\), \(p=\pi^*\{P\}\), and \(e=\pi^*E=N(\alpha)\). +Subadditivity and homogeneity of negative multiplicities give +\begin{align*} + N(\alpha+bp)&\leq e,\\ + (1+b)e=N((1+b)\alpha) + &\leq N(\alpha+bp)+bN(\{e\}) + \leq N(\alpha+bp)+be. +\end{align*} +Thus \(N(\alpha+bp)=e\). + +Run the scaling for \(H=J+bP\). +Let \(Q\) be the strict transform on a fixed resolution of a prime +component of \(E\). Its multiplicity in \(N(\pi^*\{H\})\) is +positive. The limit in Lemma~\ref{prog:negative-along-scaling} makes its multiplicity +positive for every sufficiently small positive parameter. If +that prime still survived on the corresponding working model, +Equation~\eqref{prog:working-negative} would make its multiplicity zero, +because the comparison there is exceptional over that model. +It must therefore be contracted after finitely many steps. The +same conclusion holds if a nef endpoint is reached before taking +the limit. There are only finitely many components of \(E\), so +after a finite prefix all have disappeared. + +Throughout the program \(P\) descends and remains nef. The +actual identity \(J_i\sim_{\Q}P_i+E_i\), with \(E_i\) the +codimension-one pushforward of \(E\), follows from the reflexive +trace convention. Once \(E_i=0\), we have \(J_i\sim_{\Q}P_i\); since +\(P_i\) is nef, the program stops. Conversely, a divisorial negative step can +contract only a prime of \(E_i\): its ray is \(P_i\)-trivial, +so the effective divisor \(E_i\) has negative degree on every +contracted curve, and those curves are contained in its support. +This proves the exact assertion about contracted primes. +\end{proof} + +The next lemma records the cohomology carried by a detected ordinary scaling +that begins on a smooth space. Its surjectivity will let us choose one +generic initial scaling direction for all later models. Its exceptional +splitting will also carry the span of line classes to the terminal models +used in Section~\ref{sec:boundary}. + +\begin{lemma}[Cohomology through ordinary steps] +\label{prog:cohomology-transport} +Let a finite prefix of one of the detected ordinary scalings constructed +in Lemma~\ref{prog:nef-trivial} start on a smooth compact Kähler +space, and let \(V\) be any working space. +For every smooth compact Kähler resolution \(p:U\to V\) +projective over \(V\), +\begin{align} + H^2(U,\R) + &=p^*H^2(V,\R)\ \oplus\ + \bigoplus_{Q\ {\rm exceptional\ for}\ p}\R\{Q\}, \label{prog:H2}\\ + H^{1,1}(U,\R) + &=p^*H^{1,1}_{\BC}(V,\R)\ \oplus\ + \bigoplus_{Q\ {\rm exceptional\ for}\ p}\R\{Q\}. + \label{prog:H11} +\end{align} +The linear transform from the first space is surjective onto +\(H^2(V,\R)\) and \(H^{1,1}_{\BC}(V,\R)\), respectively. For a small correspondence between +working spaces, the difference of the pulled-back classes and +their transforms on a common resolution lies in the span of the +primes exceptional over both spaces. +Under the displayed decompositions, the Chern class of a global +holomorphic line on \(U\) is the sum of the pullback of a rational +holomorphic line class on \(V\) and an exceptional rational divisor +class. In particular, passage to the exceptional quotient preserves +the real span of line Chern classes. +\end{lemma} + +\begin{proof} +For a modification of a smooth compact Kähler manifold, the +degree-two modification theorem gives these decompositions, and +the exceptional classes have type \((1,1)\). Suppose they hold +at one step. Its contraction base and both working spaces have +rational singularities: slight lowering of the rational Cartier +floor makes the ordinary pair klt, and the detected contraction has +a base with rational singularities. These contractions are +bimeromorphic, so a common resolution and Leray give +\(R^if_*\OO=0\) for \(i>0\); this verifies the additional +hypothesis in Lemma~\ref{prog:bc-descent}. + +The ray of this detected contraction is one ray for Bott--Chern degrees. +This also suffices for degree-two classes. Indeed, pull a class +\(\gamma\in H^2(V,\R)\) to a smooth resolution \(p:U\to V\) +and take its Hodge decomposition. By the decomposition already proved for +this working model in Equation~\eqref{prog:H11}, its \((1,1)\)-part is \(p^*\beta+\{E\}\) for a +Bott--Chern class \(\beta\) and an exceptional real divisor +\(E\). The other Hodge components have zero degree on curves. +On every \(p\)-contracted curve the degree of \(E\) is therefore +zero, so both signs of negativity make \(E=0\). Lifting any +curve of \(V\) through the projective resolution now shows that +\(\gamma\) and \(\beta\) have the same curve degrees. Thus +subtracting a multiple of \(\{J\}\) from either a degree-two or +a Bott--Chern class can annihilate every curve of the contracted +fiber. By +Lemma~\ref{prog:bc-descent}, a degree-two class, or a Bott--Chern class, +with these zero degrees is pulled back from the base. +Subtract a multiple of \(\{J\}\) to make any given class +annihilate that ray, descend the remainder, and use the trace +\(\{J^+\}\) to define its transform. On a common resolution the +difference is a multiple of the exceptional adjoint comparison in +Equation~\eqref{prog:comparison}. For a flip the two exceptional prime +sets on that resolution are the same. For a divisorial +contraction the target resolution has just the one additional +exceptional prime of the step. The old decomposition therefore +spans the new one and proves surjectivity of the transform. + +The sums are direct. If the pullback of a class from \(V\) is +an exceptional divisor class, that divisor has zero degree on +all curves over \(V\). Applying exceptional negativity to both +signs makes the divisor zero; injectivity of pullback gives that +the class is zero. The pullback injectivity in degree two and in +Bott--Chern cohomology is also +Lemma~\ref{prog:bc-descent}, applied to the resolution. Passing to +higher smooth resolutions proves the assertion for every \(p\). + +For the line assertion, let \(\mathscr H\) be a holomorphic line on +\(U\), and put \(\mathscr Q=(p_*\mathscr H)^{**}\). Global strong +\(\Q\)-factoriality gives an invertible sheaf +\(\mathscr M=\mathscr Q^{[m]}\) for some \(m>0\). The coherent +evaluation comparison of \cite[Lemma~7.2]{CB} gives +\[ + \mathscr H^{\otimes m}\simeq p^*\mathscr M\otimes\OO_U(E), + \qquad E\ \text{an integral \(p\)-exceptional divisor}. +\] +Indeed \((p_*\mathscr H^{\otimes m})^{**}=\mathscr M\), since the +two sheaves agree at the general points of all divisors of \(V\). +Local generators of \(p_*\mathscr H^{\otimes m}\) in a frame +of \(\mathscr M\) compare their evaluations with the pulled-back +coefficients by meromorphic quotients. Those quotients agree on the +isomorphism locus and hence glue; their zeros and poles are exceptional. +Taking Chern classes proves the assertion without choosing a meromorphic +section of \(\mathscr H\). +\end{proof} + +Before returning to special termination, we record the consequence used in +the boundary argument: a lower-dimensional manifold of Kodaira dimension +zero has a terminal torsion model carrying the preceding exceptional +splitting. + +\begin{corollary}[Terminal models in Kodaira dimension zero] +\label{prog:terminal-kappa-zero} +Let \(X\) be a smooth compact Kähler \(d\)-fold with \(d0\), and transformed classes +\(\{J_V\},A_V\) such that +\begin{equation} + \{J_V\}+tA_V\ \text{is nef for every }0\leq t\leq\delta. + \label{prog:whole-nef-interval} +\end{equation} +On a common smooth resolution of \(S\) and \(V\), the +differences of pullbacks of \(J,A\) and these transforms lie +in the common exceptional span. +\end{lemma} + +\begin{proof} +Let \(P_M=J_M\) denote the semiample rational line from +Lemma~\ref{prog:stratum-model}, and use its transform \(A_M\). +On a common resolution \(p:W\to S,\ q:W\to M\), let \(F_A\) be the +real divisor in the common exceptional span defined by +\[ + q^*A_M-p^*A=\{F_A\}. +\] +It is effective: \(-F_A\) is \(q\)-nef, because \(p^*A\) is +nef and the other term is pulled back from \(M\); apply +exceptional negativity. Its support is disjoint from \(p^{-1}(U)\). +In particular \(A_M\) is pseudo-effective, and its negative +multiplicity at every prime of \(M\) is zero. Indeed, +\(q^*A_M=p^*A+\{F_A\}\), and +Lemma~\ref{bir:exceptional} applied over \(S\) gives +\(N(q^*A_M)=F_A\). + +Let \(D_M\) be the rational Cartier trace of \(D\). +Choose \(\tau>0\) so small that \(A+\tau\{D\}\) is Kähler. +For a fixed sufficiently small \(t>0\), consider on \(M\) the +boundary \(\Delta_M-t\tau D_M\) and the nef b-class represented on +\(W\) by \(t p^*(A+\tau\{D\})\). Its trace on \(M\) is +\(t(A_M+\tau\{D_M\})\), so its generalized adjoint is +\begin{equation} + \{P_M\}+tA_M. + \label{prog:interval-gadjoint} +\end{equation} +These are effective gklt data. Over \(U\) the b-class +descends to \(M\), so its generalized discrepancy +contribution is zero there, and subtracting \(t\tau D_M\) +raises every zero log discrepancy of the dlt pair. +Away from the floor the ordinary pair is klt; on one fixed +log resolution its finitely many subunit coefficients stay +subunit for small \(t\). This proves gklt. The generalized +boundary is big. On a common resolution the pullback of the +trace of \(A+\tau\{D\}\) minus \(p^*(A+\tau\{D\})\) is effective exceptional +by the same negativity argument as for \(F_A\). The latter +pullback is nef and big, so the trace is big; the remaining +boundary is effective. + +Choose an integer \(m>0\) such that \(mP_M\) is generated, and +let \(g:M\to Z\) be the Stein factor of its morphism. Then \(Z\) +is normal projective and \(mP_M=g^*H\) for an ample generated Cartier line +\(H\) on \(Z\). Set \(L=\{P_M\}+tA_M\). The preceding +preparation makes \(L\) an effective gklt adjoint with globally nef +b-data and globally modified-big boundary-plus-nef trace. It is +pseudo-effective because \(P_M\) is nef and \(A_M\) is modified +nef. Apply the proper relative assertion of +Proposition~\ref{prog:mori} over \(Z\). This produces a chosen +nonextracting good log terminal model \(\phi:M\dashrightarrow V\) +and a morphism \(g_V:V\to Z\), with \(L_V\) nef over \(Z\). +The hypothesis here is properness: the semiample morphism \(M\to Z\) +need not be projective. Put +\[ + mP_V=g_V^*H,\qquad A_V=(L_V-\{P_V\})/t. +\] +The relative construction preserves the actual line pulled back from +\(Z\), and its forward Bott--Chern transport preserves the displayed +linear relation; these are the transforms of \(P_M,A_M\). + +The map \(\phi\) is small. On a common projective resolution +\(a:W'\to M\), \(c:W'\to V\), its comparison is +\[ + a^*L=c^*L_V+\{E\},\qquad E\geq0, +\] +where \(E\) is exceptional over \(V\) and has positive coefficient +at the strict transform of each prime contracted from \(M\). +The forward trace \(L_V\) is pseudo-effective, so exceptional +translation gives +\[ + N(a^*L)=N(c^*L_V)+E\geq E. +\] +But \(L\) is modified nef on \(M\); the coefficient of +\(N(a^*L)\) at a strict prime of \(M\) is zero. Thus no prime of +\(M\) is contracted. Nonextraction then proves smallness. + +Fix \(b>2dm\). We claim that \(L_V+b\{P_V\}\) is absolutely +nef. Otherwise the cone theorem for the effective gklt adjoint +\(L_V\) gives an \(L_V\)-negative rational extremal generator +\(C\) such that +\[ + (L_V+b\{P_V\})\cdot C<0,\qquad 0<-L_V\cdot C\leq2d. +\] +Indeed the cone summand on which \(L_V\) is nonnegative also has +nonnegative \(P_V\)-degree, so a negative ray summand must account +for any failure of nefness. If \(P_V\cdot C=0\), ampleness of +\(H\) makes \(C\) vertical over \(Z\), contradicting relative +nefness of \(L_V\). Otherwise Cartier integrality gives +\(P_V\cdot C\geq1/m\), contradicting +\[ + (L_V+b\{P_V\})\cdot C\geq-2d+b/m>0. +\] +This proves the claim. Both \(\{P_V\}\) and +\((1+b)\{P_V\}+tA_V\) are nef. By convexity, +\[ + \{P_V\}+sA_V\ \text{is nef for }0\leq s\leq\frac{t}{1+b}. +\] +Thus \(\delta=t/(1+b)\) works. The actual line \(P_V\) has the +same generated multiple as \(P_M\), since both are pulled back from +\(H/m\). Its class is the transform of \(J\). +The relative comparison and linear transport give exceptional-divisor +comparisons for \(P_M,A_M\). Since \(S,M,V\) agree in codimension +one, their final comparison divisors are exceptional over both \(S\) +and \(V\), as required. +\end{proof} + +\subsection{Special termination} + +\begin{theorem}[Special termination for a chosen dlt scaling] +\label{prog:special-termination} +Assume \(\Ggood_d\) for every \(d0\) on this working space, above the remaining +walls, and set +\[ + A=\{J\}+\lambda_0H. +\] +It is Kähler, as the restriction of the interior ambient +Kähler class. The exact change of parameter is +\begin{equation} + \{J\}+tA=(1+t)(\{J\}+\lambda H),\qquad + \lambda=\frac{\lambda_0t}{1+t},\qquad + t=\frac{\lambda}{\lambda_0-\lambda}. + \label{prog:reparameterization} +\end{equation} +It applies for \(0\leq\lambda<\lambda_0\). The new walls +\(t_i\) strictly decrease toward zero, and the traces +\(\{J_i\}+tA_i\) are nef on their successive restricted +working intervals. + +On a common resolution of a nontrivial small stratum step, let \(D_i\) +be the real exceptional divisor defined by +\[ + p_i^*\{J_i\}-q_i^*\{J_{i+1}\}=\{D_i\}. +\] +The strict adjoint comparison makes \(D_i\) an effective +nonzero divisor exceptional over both strata. Equality of +the scaled pullbacks at its wall gives the exact +Bott--Chern equality +\begin{equation} + p_i^*(\{J_i\}+tA_i)-q_i^*(\{J_{i+1}\}+tA_{i+1}) + =\left(1-\frac{t}{t_i}\right)\{D_i\}. + \label{prog:restricted-comparison} +\end{equation} +For \(t\) in a later working interval all preceding factors +on the right are nonnegative. Telescoping on a common +resolution expresses the pullback of \(\{J\}+tA\) as the +pullback of its nef working trace plus an effective divisor +exceptional over that working stratum. +Lemma~\ref{bir:exceptional} identifies the latter divisor +with the negative part. + +Push the resulting positive currents to one fixed smooth +resolution of \(S\) and let \(t\downarrow0\). Closedness of +the pseudo-effective cone proves that \(J\) is +pseudo-effective. The negative multiplicities converge +valuation by valuation by the limit statement in +Lemma~\ref{prog:negative-along-scaling}. The comparison divisors +have no strict prime of \(S\), since the maps are small. +Their coefficients also vanish at every place whose center +meets the floor: each finite composition is unchanged on a +neighborhood of the floor by the induction on smaller +centers. Passing to the limit proves +Equation~\eqref{prog:away-floor}. + +The stratum has dimension less than \(n\), and the divisor \(D_S\) +constructed above is rational Cartier with support equal to its floor. +Lemmas~\ref{prog:stratum-model} and +\ref{prog:nef-interval} give one small model \(V\) on +which all transformed classes of \(\{J\}+tA\) are nef +for \(0\leq t\leq\delta\). On a common smooth +resolution \(p:W\to S,\ q:W\to V\), define the real divisor \(F(t)\) +in the common exceptional span by +\begin{equation} + p^*(\{J\}+tA)-q^*(\{J_V\}+tA_V)=\{F(t)\}. + \label{prog:affine-comparison} +\end{equation} +Uniqueness of the representing exceptional divisor makes \(F(t)\) +coefficientwise affine in \(t\). It is effective on +\([0,\delta]\): \(-F(t)\) is \(p\)-nef because the +class pulled back from \(V\) is nef, so exceptional +negativity applies. It is exceptional over \(V\) as +well. Lemma~\ref{bir:exceptional} gives +\[ + N\bigl(p^*(\{J\}+tA)\bigr)=F(t) + \qquad(0\leq t\leq\delta). +\] +Every divisorial negative multiplicity is thus affine on +this whole interval. This remains true on higher +resolutions by Lemma~\ref{bir:pullup}. + +Choose a nontrivial stratum wall \(t_i\in(0,\delta)\). +On a common resolution of \(S,V\) and the adjacent +strata, their nef working models compute the same +negative part on their respective open intervals. Their +two affine expressions agree at \(t_i\). But +Equation~\eqref{prog:restricted-comparison} says that, at a prime +with coefficient \(d_i>0\) in \(D_i\), their difference +is +\[ + \left(1-\frac{t}{t_i}\right)d_i. +\] +Their slopes differ by \(-d_i/t_i\). A single affine +function on \([0,\delta]\) cannot agree with both on +two open intervals. This contradiction excludes every +such wall. Infinitely many walls would tend to zero, so +the nontrivial diagrams on this stratum are finite. + +There are finitely many surviving strata. Induction on +their dimensions makes all sufficiently late ambient +flipping and flipped loci disjoint from the floor. This +proves the theorem. +\end{proof} + +\begin{corollary}[A signed adjoint supported on the floor] +\label{prog:signed-nef} +Assume \(\Ggood_d\) for every \(d0\) +\cite[Theorem~5.2]{FujinoAnalyticBCHM}. Composing a resolution of \(T\) +with \(f\), the Leray spectral sequence proves that \(Z\) has rational +singularities. The same reasoning works when the klt boundary is +chosen separately on finitely many Stein base neighborhoods. For +fiber-type contractions in case~(ii), rationality of the base follows +from \cite[Lemma~8.8(i)]{DHP}; thus that application also precedes +the construction of generalized data on the base. + +\begin{lemma}[Projectivity from a rational line detecting the ray] +\label{prog:detected-projectivity} +Let $f:T\to Z$ be a proper contraction between normal compact +K\"ahler spaces, with $T$ having rational singularities. Suppose +$\gamma$ is K\"ahler on $Z$ and +\[ + \alpha=f^*\gamma,\qquad + \overline{\mathrm{NA}}(T)\cap\alpha^\perp=R +\] +is a nonzero ray. If a global rational line bundle $D$ has +$D\cdot R<0$, then $-D$ is relatively ample and $f$ is projective. +\end{lemma} +\begin{proof} +Fix a K\"ahler class $\omega$ on $T$ and normalize $\overline{\mathrm{NA}}(T)$ by +$\omega\cdot z=1$. The resulting slice $S$ is compact. Its unique +point on $R$ has negative $D$-degree, so $d=c_1(D)$ is negative on +a neighborhood of that point in $S$. On the complementary compact +set, $\alpha$ has a strictly positive minimum, while $d$ is bounded. +For all sufficiently small $s>0$, the class $\alpha-sd$ is therefore +strictly positive on $S$ and is K\"ahler by cone duality. + +Choose an integer $m>0$ making $mD$ integral. Then +\[ + c_1(-mD)+f^*((m/s)\gamma)=(m/s)(\alpha-sd) +\] +is K\"ahler. On a neighborhood in the base with a potential for +$\gamma$, absorb that potential in a smooth metric on the same global +line bundle $-mD$. Its curvature is positive on the fibres. The analytic +positive-line-bundle criterion and the fibrewise relative-ampleness +criterion make $-mD$ relatively ample. The line bundle was global +throughout, so no gluing of unrelated local polarizations is required. +\end{proof} + + +An analytic contraction supplied by a supporting class therefore becomes +projective as soon as one rational line has negative degree on its ray. +For a small contraction, that same line will define the flip globally. +The local ordinary adjoints used to prove finite generation need not +glue; their section algebras will be Veronese subalgebras of one algebra. + +\begin{lemma}[Divisor representatives over a Stein base] +\label{prog:stein-representatives} +Let $\pi:Y\to U$ be a projective surjective morphism with connected fibres +between normal irreducible complex spaces, where $U$ is Stein, and let +$\mathcal L$ be a holomorphic line bundle on $Y$. +If $\pi$ is bimeromorphic, $\mathcal L$ has a holomorphic section +which is not identically zero, and hence an effective Cartier divisor +representative. More generally, after shrinking $U$ around any specified +point, $\mathcal L$ has a nonzero meromorphic section. +\end{lemma} + +\begin{proof} +Suppose first that $\pi$ is bimeromorphic. Grauert's proper direct-image +theorem makes $\mathcal F=\pi_*\mathcal L$ coherent. On the nonempty +open subset $U^\circ$ where $\pi$ is an isomorphism, it is a line bundle. +Choose $u_*\in U^\circ$. Cartan's theorem~A says that global sections +generate $\mathcal F_{u_*}$, so one global section has nonzero image in +$\mathcal F_{u_*}/\mathfrak m_{u_*}\mathcal F_{u_*}$. +Under +\[ + H^0(U,\pi_*\mathcal L)=H^0(Y,\mathcal L) +\] +it gives a section $s$ nonzero at the unique point above $u_*$. +Its zero divisor is effective Cartier and represents $\mathcal L$. +The section may vanish elsewhere; only its meromorphic inverse is +being used to obtain a meromorphic trivialization. + +For the general case, fix $u\in U$ and $y\in\pi^{-1}(u)$, and choose +a $\pi$-ample line bundle $\mathcal H$. Relative Serre generation, +after shrinking to a Stein neighbourhood of $u$, gives an integer +$n$ for which both $\mathcal L\otimes\mathcal H^n$ and +$\mathcal H^n$ are relatively generated. Their proper direct images +are coherent. Cartan's theorem~A and the evaluation maps supply +sections $s$ and $t$ of these two bundles which are both nonzero at +$y$. The quotient $s/t$ is the required nonzero meromorphic section +of $\mathcal L$. At no point is $Y$ assumed Stein. +\end{proof} + +\begin{proposition}[A global algebra for a detected flip] +\label{prog:detected-flip} +Let $(T,B+\mathbf M)$ be a gklt pair on a normal compact K\"ahler +space which is globally strongly $\Q$-factorial, and let $A\in H^{1,1}_{\BC}(T,\R)$ +be its adjoint class. Let $f:T\to Z$ be a projective small contraction +onto a normal compact K\"ahler space. Suppose that the classes of all +$f$-vertical curves lie on one ray $R\subset\overline{\mathrm{NA}}(T)$, that $A\cdot R<0$, +and that a global line bundle $L$ satisfies $L\cdot R<0$. + +Then $\bigoplus_{m\geq0}f_*L^m$ is locally finitely generated. The +relative Proj of a sufficiently divisible Veronese is a projective +small contraction $f^+:T^+\to Z$, where $T^+$ is compact K\"ahler and +globally strongly $\Q$-factorial. The reflexive transform $L^+$ is a +rational line bundle, with a positive power equal to the relatively +ample tautological bundle. The transformed boundary and the same +b-nef datum define a gklt pair on $T^+$, with relatively K\"ahler +adjoint $A^+$. This is the generalized flip, with the usual +strict discrepancy increase at centres in either exceptional locus. + +Moreover, if $t=(A\cdot C)/(L\cdot C)>0$ for an $f$-vertical curve $C$, +then there is a unique $\eta\in H^{1,1}_{\BC}(Z,\R)$ such that +\[ + A=t\,c_1(L)+f^*\eta,\qquad + A^+=t\,c_1(L^+)+(f^+)^*\eta. +\] +Every class on $T$ has the corresponding forward transport with an +actual exceptional-divisor correction. No assertion of surjectivity +on Bott--Chern groups is required. +\end{proposition} + +\begin{proof} +Since $f$ has a global relatively ample bundle and all its vertical +curves lie on $R$, numerical invariance of ampleness on the projective +fibres shows that $-L$ is $f$-ample. + +\smallskip\noindent +\emph{A local rational ordinary adjoint.} +Fix $z\in Z$ and a relatively compact Stein neighbourhood $U$. +Take a projective log resolution $p:V\to T_U$ carrying $\mathbf M$, +and put $\rho=f p$. Write its actual structure boundary as $B_V$, so +\[ + [K_V+B_V]+[\mathbf M_V]=p^*A. +\] +Every coefficient of $B_V$ is less than one. Apply +Lemma~\ref{prog:stein-representatives} to obtain a Cartier +representative $D_L$ of $L$ on $T_U$. The same birational direct-image +argument applies to the coherent rank-one reflexive canonical sheaf: +it supplies a canonical form nonzero at a chosen point of the common +smooth isomorphism locus. Use this meromorphic form on $T_U$ and its +pullback to $V$ to choose compatible canonical representatives, and set +\[ + N=t p^*D_L-K_V-B_V. +\] +For every $\rho$-vertical curve, its degree equals that of $\mathbf M_V$. +Thus $N$ is $\rho$-nef. + +The relative bigness of $N$ uses the additional fact that +$\rho=f\circ p$ is \emph{bimeromorphic}: both the small contraction +$f$ and the resolution $p$ are bimeromorphic. It does not follow from +relative nefness alone. In fact every real Cartier divisor is relatively +big for this projective bimeromorphic map over the Stein neighbourhood. +Here is the required ample-plus-effective decomposition explicitly. +Write $N=\sum_j r_jN_j$, where $r_j>0$, $\sum_jr_j=1$, and the $N_j$ +are rational Cartier divisors in its finite Cartier span. Choose a +$\rho$-ample line bundle and a Cartier representative +$P$ for it using Lemma~\ref{prog:stein-representatives}. +If $q_jN_j$ is integral, apply the birational case of that lemma to +$\mathcal O_V(q_jN_j-P)$. Its nonzero holomorphic section has an +effective Cartier zero divisor $E_j$, giving the actual relation +$q_jN_j\sim P+E_j$. This use depends on $\rho$ being bimeromorphic; +the section is allowed to vanish along exceptional fibres. Therefore +\[ + N\sim_{\R} + \underbrace{\left(\sum_j\frac{r_j}{q_j}\right)P}_{H} + +\underbrace{\sum_j\frac{r_j}{q_j}E_j}_{E}. +\] +Here $H$ is $\rho$-ample and $E\geq0$, proving $\rho$-bigness. +For a map with positive-dimensional general fibres the direct image +used above can be zero; no such bigness claim is made for that setting. +Make the finitely many section choices on a slightly larger Stein +neighbourhood, and now shrink $U$ so its closure is compact in that +neighbourhood. Properness makes the inverse image of this closure +compact. A log resolution of the finitely many resulting divisors +therefore gives a uniform positive bound for the following choice. +Choose $\epsilon>0$ small enough that $(V,B_V+\epsilon E)$ is sub-klt. +The divisor $(1-\epsilon)N+\epsilon H$ is relatively ample. Express it +as a positive combination of rational ample divisors and take general +members of sufficiently high multiples. Relative Bertini +\cite[Theorem~2.20]{DHP}, applied on a log resolution of $B_V+E$, +gives an effective $\Theta\sim_{\R}N$ such that $(V,B_V+\Theta)$ is +sub-klt. The high multiples make the added coefficients arbitrarily +small. All choices are made near the compact fibre; shrink $U$ once +to retain them. + +Put $\Delta=p_*(B_V+\Theta)\geq0$. Write the actual linear equivalence +as $\Theta=N+\sum_j a_j\operatorname{div}_V(g_j)$. +The bimeromorphic map $p$ identifies meromorphic function fields, so +$g_j=p^*h_j$. Pushing down gives +$K_{T_U}+\Delta=tD_L+\sum_j a_j\operatorname{div}_{T_U}(h_j)$; +in particular this divisor is real Cartier. Pulling back this same +identity gives +\[ + K_{T_U}+\Delta\sim_{\R}tD_L, + \qquad p^*(K_{T_U}+\Delta)=K_V+B_V+\Theta. +\] +Thus $(T_U,\Delta)$ is klt. Any finitely many base line bundles in a +relative linear equivalence can first be trivialized by shrinking $U$. +Record the resulting equality as +\begin{equation}\label{prog:detector-rationalization} + K_{T_U}+\sum_i d_iD_i=tD_L+\sum_j b_j\operatorname{div}(g_j), + \qquad d_i>0, +\end{equation} +using the positive support of $\Delta$. After a further relatively +compact shrinking, the displayed divisors have finitely many prime +components: their locally finite supports meet a compact inverse image. +Equality of coefficients in \eqref{prog:detector-rationalization} is a +finite rational affine system in $(d_i,t,b_j)$. The klt condition is +open within this system, as seen on one log resolution; the pullbacks +of its adjoints vary linearly by the displayed identity. A nearby +rational solution therefore gives a rational effective klt boundary +$\Delta_q$ and $t_q\in\Q_{>0}$ with +\begin{equation}\label{prog:detector-local-adjoint} + K_{T_U}+\Delta_q\sim_{\Q}t_qD_L. +\end{equation} +The individual local primes $D_i$ need not be $\Q$-Cartier: the identity +ensures that the total adjoint is $\Q$-Cartier. + +\smallskip\noindent +\emph{One global flip algebra.} +The adjoint in \eqref{prog:detector-local-adjoint} is $f_U$-antiample. +Its ordinary flip and local finite generation follow from +\cite[Theorems~1.14 and~1.18]{FujinoAnalyticBCHM}. Clearing the displayed +linear equivalence identifies a Veronese of its canonical algebra +with a Veronese of $\mathcal R:=\bigoplus_{m\geq0}f_*L^m$ over $U$. +Hence $\mathcal R$ is locally finitely generated by +\cite[Lemma~2.26]{FujinoAnalyticBCHM}. The graded pieces are coherent. Over a connected normal base open +the inverse image is irreducible; products of nonzero sections of line +bundles are nonzero there. Thus its graded section algebra is an +integral domain, without choosing any global meromorphic frame of $L$. +Compactness supplies one sufficiently divisible Veronese +$\mathcal R^{(r)}$ generated in degree one. Its relative Proj $T^+$ +restricts to the ordinary flip over every such $U$. It is therefore +normal, locally klt, and small over $Z$, and has the global relatively +ample bundle +$\mathcal O_{T^+}(1)$. On the common big open this bundle is $L^r$. +Reflexivity gives +\[ + (L^+)^{[r]}\simeq\mathcal O_{T^+}(1). +\] +This proves that $L^+$ is a rational line bundle before any assertion +of factoriality. Relative positivity over the compact K\"ahler base +makes $T^+$ compact K\"ahler. + +For any global rank-one reflexive sheaf $\mathcal F^+$ on $T^+$, +take its coherent reflexive transform $\mathcal F$ on $T$ using a +common resolution. Some $M=\mathcal F^{[m]}$ is a line bundle. +Choose $c\in\Q$ so that $(M+cL)\cdot C=0$, and clear its denominator +to obtain an integral bundle $J=n(M+cL)$ numerically trivial over $f$. +The local rational klt pairs \eqref{prog:detector-local-adjoint} have +antiample adjoint, so Lemma~\ref{prog:integral-descent} yields +one global line bundle $J_Z$ with $J=f^*J_Z$. +On $T^+$, pull back $J_Z$, undo the rational twist $ncL^+$, and compare +on the common big open. After clearing the already established index +of $L^+$, reflexivity gives an invertible positive reflexive power of +$\mathcal F^+$. This proves global strong factoriality. + +\smallskip\noindent +\emph{The original generalized pair.} +The local log-Fano pairs above give $R^if_*\mathcal O_T=0$ for $i>0$ +by \cite[Theorem~5.2]{FujinoAnalyticBCHM}. They make $T$ locally klt, hence rational. +Leray for a projective resolution then shows that $Z$ is rational. +Lemma~\ref{prog:bc-descent}(i) therefore gives +$f^*H^{1,1}_{\BC}(Z,\R)=R^\perp$, with injective pullback. Thus $A=t c_1(L)+f^*\eta$ for a unique $\eta$. +Define $A^+=t c_1(L^+)+(f^+)^*\eta$; it is relatively K\"ahler. + +To construct its actual discrepancy divisor, let $\mathcal I$ be the +ideal defined by +\[ + \operatorname{im}(f^*f_*L^r\longrightarrow L^r) + =\mathcal I\otimes L^r. +\] +Principalize $\mathcal I$ on a common resolution $p:W\to T$, +$q:W\to T^+$ carrying $\mathbf M$. If +$\mathcal I\mathcal O_W=\mathcal O_W(-F_L)$, the tautological quotient +gives the actual bundle identity +\[ + q^*\mathcal O_{T^+}(1)=p^*L^r\otimes\mathcal O_W(-F_L). +\] +Hence $E_L=F_L/r$ is effective and exceptional over both sides, and +$[E_L]=p^*c_1(L)-q^*c_1(L^+)$. If $B_W$ is the original structure +boundary, put $B_W^+=B_W-tE_L$. Then +\[ + [K_W+B_W^+]+[\mathbf M_W]=q^*A^+. +\] +Its pushforward is $B^+$, and its discrepancies do not decrease. +The local ordinary comparison in \eqref{prog:detector-local-adjoint} +has discrepancy divisor $t_qE_L$, so its strictness proves the stated +strictness for $tE_L$ as well. Thus the original pair remains gklt. + +Finally, write any $\theta\in H^{1,1}_{\BC}(T,\R)$ uniquely as +$\theta=f^*\eta_\theta+s c_1(L)$ and set +$\theta^+=(f^+)^*\eta_\theta+s c_1(L^+)$. Its correction is the actual +divisor $sE_L$. For a rational line $M$, the number $s$ is rational. Applying +Lemma~\ref{prog:integral-descent} to a Cartier multiple of $M-sL$ +gives $M=sL+f^*M_Z$ as actual rational lines. Reflexive extension +on the common big open gives $M^+=sL^++(f^+)^*M_Z$. +Consequently the cohomological transport agrees with the reflexive +transform on Chern classes. +\end{proof} + + +\subsubsection{Real boundaries and their linear transport} + +The rational ordinary step constructed below also determines the step +for every sufficiently close real boundary. The relevant comparison is +an identity of actual rational lines over the contraction base. + +\begin{proposition}[Ordinary real boundaries] +\label{prog:ordinary-replacement} +Let $T$ be normal compact K\"ahler and globally Weil $\Q$-factorial, +with canonical sheaf a rational line bundle. Let $B\geq0$ be a real +boundary with $(T,B)$ klt. Assume the rational ordinary-step result +of Proposition~\ref{prog:ordinary-step} for $T$ and its subsequent models. Then every +$(K_T+B)$-negative extremal analytic ray has an ordinary step with +projective contractions, compact K\"ahler models, and the expected +opposite relative ample signs. Global Weil $\Q$-factoriality is preserved; +global strong $\Q$-factoriality is preserved when imposed initially. +\end{proposition} +\begin{proof} +Put $D=K_T+B$ and fix a $D$-negative extremal ray $R$. On the finite +positive support of $B$, effectiveness, the klt condition and negativity +on $R$ persist under small coefficient changes. Klt openness is checked +on one log resolution of this support. Choose nearby effective rational +klt boundaries $B_0,\ldots,B_m$ and positive real numbers $u_j$ with +\[ + B=\sum_j u_jB_j,\qquad \sum_j u_j=1, + \qquad D_j\cdot R<0,\quad D_j=K_T+B_j. +\] +For $B=0$ take just $B_0=0$. Every $D_j$ is a global rational line +bundle. The rational-step theorem for $(T,B_0)$ provides a projective +contraction $f:T\to Z$ onto a compact K\"ahler base, contracting +exactly $R$, with $-D_0$ relatively ample. The base is rational by +\cite[Lemma~8.8]{DHP}, so Lemma~\ref{prog:bc-descent} gives +$f^*H^{1,1}_{\BC}(Z,\R)=R^\perp$; use case~(ii) when $f$ is of +fiber type. +Let $C$ be a rational curve spanning $R$, and set +$a_j=(D_j\cdot C)/(D_0\cdot C)\in\Q_{>0}$. On every projective +fibre, $-D_j$ is numerically equivalent to the positive multiple +$-a_jD_0$. Numerical invariance of ampleness on that fibre, followed +by the relative-ampleness criterion, makes $-D_j$ relatively ample. +The positive combination $-D$ is relatively ample as a real line +bundle. This also handles a fibre-type contraction. + +Suppose henceforth that $f$ is birational. A Cartier multiple +$M_j=n_j(D_j-a_jD_0)$ is numerically trivial over $Z$ and +$M_j-D_0$ is relatively ample. Lemma~\ref{prog:integral-descent}, +applied to the rational klt pair $(T,B_0)$ gives a rational line bundle +$A_j$ on $Z$ with the actual identity +\begin{equation}\label{prog:real-line-descent} + D_j=a_jD_0+f^*A_j. +\end{equation} +Here and below an identity of rational line bundles means an isomorphism +after a common integral multiple. The descent lemma is used only for +birational $f$. + +For a small $f$, let $f^+:T^+\to Z$ be its rational $D_0$-flip. +The rational theorem supplies a global relatively ample adjoint +$D_0^+$ and preserves the stated factoriality and canonical-sheaf +conditions. The other transformed adjoints $D_j^+$ are therefore +rational line bundles. Transform \eqref{prog:real-line-descent} on the common +big open and extend by reflexivity to obtain +\[ + D_j^+=a_jD_0^++(f^+)^*A_j. +\] +All $D_j^+$ are relatively ample, as is +$D^+=\sum_j u_jD_j^+$. Thus this same small map is the required +ordinary real-boundary flip. The real ordinary discrepancy comparison +proves that $(T^+,B^+)$ is klt and gives the strict increases at +exceptional centres. + +For a divisorial contraction, write +$D_0=f^*D_0'+e_0E$ with $e_0>0$. Transforming +\eqref{prog:real-line-descent} on the target and summing yields +\[ + D-f^*D'=\left(\sum_j u_ja_j\right)e_0E. +\] +This coefficient is positive. The same discrepancy comparison proves +the required assertions. The ambient category was already preserved +by the rational step in both cases. +\end{proof} + + +For later use, let \(D=K_T+B\) drive one of the birational steps just +constructed, and write \(f':T'\to Z\) for its positive morphism +(or the identity for a divisorial contraction). Lemma~\ref{prog:bc-descent} +gives the unique decomposition and forward transform +\begin{equation} + \theta=f^*\eta+s\{D\},\qquad + \theta'=(f')^*\eta+s\{D'\}. + \label{prog:ordinary-forward-transport} +\end{equation} +On a common resolution \(p:W\to T\), \(q:W\to T'\), the ordinary +comparison \(p^*D-q^*D'=F\) is an actual effective real divisor, +exceptional over \(T'\) and over both sides for a flip. Hence +\(p^*\theta-q^*\theta'=s\{F\}\). On Chern classes this is the +reflexive transform, by the line identities in the proof above and +Lemma~\ref{prog:integral-descent}. This construction gives forward +transport without assuming surjectivity onto the next Bott--Chern group. + +\subsubsection{Actual real lines and relative numerical spaces} + +A second polarization argument will be used for maps whose fibers are +Moishezon. It applies to a real combination of global line bundles, +provided that its degrees on the fibers agree with a relatively Kähler +class. + +\begin{lemma}[Polarization by an actual real line bundle] +\label{prog:actual-line-polarization} +Let $f:T\to Z$ be a proper Moishezon map, where $T$ is a compact +K\"ahler space. Suppose that $L\in\operatorname{Pic}(T)\otimes\R$ +and a relatively K\"ahler class $\omega$ satisfy +\[ + L\cdot C=\omega\cdot C + \quad\text{for every compact curve $C$ contracted by $f$.} +\] +Then $L$ is relatively ample and $f$ is projective. +\end{lemma} + +\begin{proof} +Let $V$ be an irreducible positive-dimensional subspace of a reduced +fibre. It is Moishezon. Normalize $V$ and take a smooth projective +modification $\pi:\widetilde V\to V^{\mathrm n}$, chosen so that +an effective exceptional divisor $E$ has $-E$ relatively ample. +The pullback of the K\"ahler class from $V$ to its normalization is +K\"ahler. Consequently +$\pi^*\omega-\delta[E]$ is K\"ahler for sufficiently small +$\delta>0$. On the projective manifold $\widetilde V$ the actual +real line bundle $\pi^*L-\delta E$ has the same curve degrees as +that K\"ahler class, and is therefore ample. For example, subtract +a sufficiently small positive multiple of a fixed ample class from +the K\"ahler class; the corresponding real line bundle is nef by +the projective numerical criterion. Also $\pi^*L$ is nef, and the +decomposition +\[ + \pi^*L=(\pi^*L-\delta E)+\delta E +\] +shows that it is big. Thus +\[ + L^{\dim V}\cdot V=(\pi^*L)^{\dim V}>0. +\] +The real Nakai--Moishezon criterion for proper algebraic spaces +\cite[Theorem~1.6]{FujinoMiyamoto2020}, applied to the algebraizations +of the Moishezon fibres, proves that $L$ is ample on every reduced +fibre. The criterion is insensitive to nilpotents and reducible +components. In the coefficient space of the finitely many global +line bundles occurring in $L$, choose, for each fibre, a rational +simplex containing $L$ in its interior whose vertices restrict to +ample rational lines on that fibre. Openness of fibrewise ampleness +for each of these finitely many rational lines gives a base +neighbourhood on which the entire simplex is relatively ample. +Choose finitely many such neighborhoods covering the base and +intersect their coefficient neighborhoods of $L$. Every rational +point of the resulting neighborhood is relatively ample globally. +A rational simplex in this intersection also expresses $L$ as a +positive combination of relatively ample rational lines. Clearing +the denominator of one rational point proves projectivity. +\end{proof} + +\begin{remark} +The proof uses only positivity of the top self-intersections of +$L$. Equality of curve degrees with $\omega$ does not assert +equality of their higher intersection numbers or of their +Bott--Chern classes. +\end{remark} + + + + +The projective morphism needed for the relative program can be chosen +on a smooth model of the rational quotient. Here the Hodge-theoretic +polarization has an elementary construction, independent of any +birational projectivity-descent assertion. + +\begin{lemma}[Smooth Hodge-theoretic polarization] +\label{prog:smooth-polarization} +Let \(g:W\to S\) be a surjective morphism with connected fibers +between smooth compact Kähler manifolds. If +\(g^*:H^0(S,\Omega_S^2)\to H^0(W,\Omega_W^2)\) is an isomorphism, +then \(g\) is projective. This applies when its general fiber is +rationally connected. +\end{lemma} + +\begin{proof} +We use the smooth argument of \cite[Theorem~3.1, Step~1]{CH}. +Let \(d=\dim W-\dim S\). Choose a rational class \(u\in H^2(W,\Q)\) +close to a Kähler class. Write its Hodge decomposition as +\(u=b+g^*v\), where \(b\) is Kähler and \(v\) has types \((2,0)\) +and \((0,2)\). Hodge type and the projection formula give +\[ + c=g_*(u^d)=g_*(b^d)>0,\qquad + g_*(u^{d+1})=g_*(b^{d+1})+(d+1)c\,v. +\] +Since pushforward is rational, the class +\[ + \ell=u-g^*\frac{g_*(u^{d+1})}{(d+1)c} + =b-g^*\frac{g_*(b^{d+1})}{(d+1)c} +\] +is rational and of type \((1,1)\). Lefschetz's theorem makes it the +Chern class of a rational line. The displayed equality supplies a +metric with positive curvature locally over \(S\), by adding a +potential for the base class. Thus this line is relatively ample. +For rationally connected general fibers, holomorphic two-forms are +pulled back from the smooth base, so the hypothesis holds. +\end{proof} + +\begin{lemma}[A rational Hodge correction over a smooth base] +\label{prog:relative-hodge} +Let $f:T\to S$ be an already projective surjective morphism of normal +compact K\"ahler spaces. Assume that $S$ is smooth, $T$ has globally +strongly $\Q$-factorial klt singularities, and, for a projective resolution +$r:W\to T$, the morphism $g=f\circ r$ satisfies +\[ + g^*:H^0(S,\Omega_S^2)\xrightarrow{\ \simeq\ } + H^0(W,\Omega_W^2). +\] +Then every $\alpha\in H^{1,1}_{\BC}(T,\R)$ can be written +\[ + \alpha=c_1(L)+f^*\gamma, +\] +where $L\in\operatorname{Pic}(T)\otimes_{\mathbb Z}\mathbb R$ is a +finite real combination of global line bundles and +$\gamma\in H^{1,1}(S,\mathbb R)$. +\end{lemma} + +\begin{proof} +The composition $g$ is projective, since all the spaces are compact. +Choose a $g$-ample line bundle on $W$, with integral Chern class $H$. +Set $d=\dim W-\dim S$ and +\[ + c=g_*(H^d)>0. +\] +Thus $c$ is the positive degree of $H^d$ on a general fibre. The +cohomological pushforward here is the usual pushforward between the +smooth compact manifolds $W$ and $S$, defined over $\mathbb Q$ and of +Hodge bidegree $(-d,-d)$. + +Define a rational linear operator on degree-two cohomology by +\[ + \Pi(\eta)=\eta-g^*\!\left(\frac{g_*(\eta\smile H^d)}{c}\right). +\] +Every class of type $(2,0)$ on $W$ is pulled back from $S$, and the +same holds for type $(0,2)$. The projection formula therefore shows +that $\Pi$ kills both types. It preserves type $(1,1)$. Consequently +\[ + \Pi(H^2(W,\mathbb Q))\subset + H^2(W,\mathbb Q)\cap H^{1,1}(W). +\] +By the Lefschetz $(1,1)$ theorem the image consists of rational Chern +classes of global line bundles. Applying $\Pi$ to $r^*\alpha$ gives +\[ + r^*\alpha=c_1(L_W)+g^*\gamma, + \qquad L_W\in\operatorname{Pic}(W)\otimes\mathbb R, + \qquad + \gamma=\frac{g_*(r^*\alpha\smile H^d)}{c}\in H^{1,1}(S,\mathbb R). +\] +For example, express $r^*\alpha$ in a rational basis of $H^2(W,\mathbb Q)$ +and apply $\Pi$ to each basis vector. This gives the required finite +real combination $L_W$. + +Write $L_W=\sum_j a_jL_j$ with actual line bundles $L_j$ on $W$. +For each $j$, let +\[ + \mathcal F_j=(r_*L_j)^{**}. +\] +It is a rank-one reflexive coherent sheaf. Strong +$\mathbb Q$-factoriality gives an integer $m_j>0$ for which +$M_j=\mathcal F_j^{[m_j]}$ is a line bundle on $T$. +The canonical identification over the isomorphism locus of $r$ gives +\[ + L_j^{\otimes m_j}\simeq r^*M_j\otimes\mathcal O_W(E_j) +\] +for an integral $r$-exceptional divisor $E_j$. +One may obtain this comparison directly from the evaluation map for +$r_*L_j$: the two coherent rank-one sheaves agree away from the +exceptional locus, so their invertible transforms differ by an +exceptional divisor. No global meromorphic frame of $L_j$ or of the +canonical sheaf is required. + +Set $L=\sum_j(a_j/m_j)M_j$ and +$E=\sum_j(a_j/m_j)E_j$. The preceding identities yield +\[ + r^*(\alpha-c_1(L)-f^*\gamma)=[E]. +\] +The divisor $E$ is $r$-exceptional and is numerically trivial on every +$r$-contracted curve. The exceptional negativity lemma applied in both +signs gives $E=0$. Injectivity of pullback by a resolution, or pushforward +of the equality of currents, now gives +$\alpha=c_1(L)+f^*\gamma$. +\end{proof} + + +The hypothesis of Lemma~\ref{prog:relative-hodge} persists on each +projective globally strongly \(\Q\)-factorial klt model over this fixed +smooth base: on a common smooth resolution, holomorphic two-forms are +invariant under modifications. Thus the lemma applies separately on +every working model. It supplies real combinations of global lines; +Lemma~\ref{prog:stein-representatives} supplies their Cartier-divisor +representatives on sufficiently small Stein base neighborhoods. + +\begin{lemma}[The projective relative cone in Bott--Chern cohomology] +\label{prog:projective-cone} +Let \(f:T\to S\) be projective between normal compact Kähler spaces +with rational singularities, and assume +\[ + H^{1,1}_{\BC}(T,\R) + =c_1\bigl(\Pic(T)\otimes\R\bigr) + +f^*H^{1,1}_{\BC}(S,\R). +\] +Let \(N_1^{\mathrm{line}}(T/S)\) denote the space of real combinations +of \(f\)-contracted curves modulo degrees of global line bundles, +and let \(\overline{\mathrm{NE}}^{\mathrm{line}}(T/S)\) be their +closed effective cone. Their analytic classes give an isomorphism +onto the span of the face +\[ + \mathcal F_f= + \overline{\mathrm{NA}}(T)\cap(f^*\omega_S)^\perp, +\] +where \(\omega_S\) is any Kähler class on \(S\); this isomorphism +identifies \(\overline{\mathrm{NE}}^{\mathrm{line}}(T/S)\) with +\(\mathcal F_f\). In particular, relative extremal rays in the line +space are extremal rays of the full analytic cone. +\end{lemma} + +\begin{proof} +The assumed decomposition makes analytic equivalence and line-degree +equivalence identical on combinations of vertical curves. Their map +into the analytic numerical space is therefore well-defined and +injective. We must show that its closed effective cone is the entire +face, including its classes represented by positive currents. + +Fix \(z\in\mathcal F_f\). For every \(\gamma\in +H^{1,1}_{\BC}(S,\R)\), both \(a\omega_S+\gamma\) and +\(a\omega_S-\gamma\) are Kähler for large \(a\). Positivity then +shows that \(z\) annihilates \(f^*\gamma\). Fix a global relatively +ample line \(H\). If a real line \(D\) has nonnegative degree on +every vertical curve, the projective relative numerical criterion +makes \(D+\epsilon H\) relatively ample for every \(\epsilon>0\). +Its Chern class becomes Kähler after adding a sufficiently large +multiple of \(f^*\omega_S\). Therefore +\[ + (c_1(D)+\epsilon c_1(H))\cdot z\geq0, + \qquad c_1(D)\cdot z\geq0. +\] +Applying this to both signs of a relatively numerically trivial line +shows that pairing with \(z\) factors through the finite-dimensional +space of relative line degrees. It is nonnegative on its nef cone. +By duality for this projective relative space, it is represented by +an element of \(\overline{\mathrm{NE}}^{\mathrm{line}}(T/S)\). +The decomposition in the statement makes its analytic image equal +to \(z\). Conversely every vertical effective curve lies in +\(\mathcal F_f\), and finite-dimensional injectivity preserves +closedness. This proves the cone equality and the extremality claim. +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03b-projective-good-model.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03b-projective-good-model.tex new file mode 100644 index 0000000000000000000000000000000000000000..d4d4e7ed8d2b2f91b1bfc0208240f3e2da755934 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03b-projective-good-model.tex @@ -0,0 +1,439 @@ +\subsection{Good models for already projective relative adjoints} + +\begin{proposition}[Projective relative completion] +\label{prog:projective-good-model} +Let \(f:X\to S\) be an already projective surjective morphism of +normal compact Kähler spaces, with \(X\) smooth. Let +\((X,B+\mathbf M)\) be an effective generalized klt pair with adjoint +\(A\), carried by a projective resolution \(p:W\to X\) with smooth +\(W\), so that +\[ + p^*A=c_1(K_W)+[B_W]+\mathbf M_W. +\] +Suppose that there are an actual real line bundle +\(J\in\Pic(X)\otimes\R\) and +\(\beta\in H^{1,1}_{\BC}(S)\) such that +\[ + A=c_1(J)+f^*\beta, + \qquad + N:=p^*J-K_W-B_W + \text{ is nef and big over }fp. +\] +Assume that \(J\) is pseudoeffective over \(S\). +Then there is a finite chosen \(A\)-negative projective program over +\(S\), with globally strongly \(\Q\)-factorial compact Kähler +working spaces, and a nonextracting endpoint \(X_m\) such that +\[ + J_m\sim_{\R}g^*H, + \qquad + A_m=g^*\bigl(c_1(H)+\rho^*\beta\bigr). +\] +Here \(J_m\) is the actual real-line transform of \(J\), +\(g:X_m\to Z\) is a projective connected-fibre morphism, +\(\rho:Z\to S\) is projective, and \(H\) is an actual real line +bundle ample over \(S\). Thus the class on \(Z\) in this formula is +relatively Kähler over \(S\). The generalized pair on \(X_m\) is +gklt. On a common resolution the comparison with \(A\) is effective +and exceptional over \(X_m\), with strictly positive coefficient +at the strict transform of every prime contracted from \(X\). +\end{proposition} + +\begin{proof} +We reduce to fixed ordinary pairs, and construct one global program. +Choose finitely many Stein open sets \(U_\ell\subset S\) and +semianalytic Stein compact subsets \(W_\ell\Subset U_\ell\) whose +interiors cover \(S\). Such compacts are obtained by intersections +with closed polydiscs in local embeddings of \(S\). In particular +they satisfy condition~(P) of \cite{FujinoAnalyticBCHM}: the source +is normal, the base is Stein, the compact is Stein, and its +intersection with any analytic subset defined near it has finitely +many connected components. This remains true on every normal +projective model. Shrinking \(U_\ell\) around \(W_\ell\) preserves +the finite cover. + +\smallskip\noindent +\emph{Actual ordinary replacements.} +On each chart represent the finitely many line bundles in the data +by Cartier divisors. For a projective map to a Stein space this can +be done by twisting a line bundle and its prospective meromorphic +frame by sufficiently positive relative lines and using nonzero +sections. The generic-rank-one direct-image argument is an +alternative only when the map is bimeromorphic. +Relative bigness gives +\(N\sim_{\R}P+E\), with \(P\) relatively ample and \(E\geq0\). +For sufficiently small \(\epsilon>0\), +\((W,B_W+\epsilon E)\) is sub-klt near the compact inverse image. +The line \((1-\epsilon)N+\epsilon P\) is relatively ample. +General divided relative sections give an effective representative +\(T\) such that +\[ + \Theta:=\epsilon E+T\sim_{\R}N, + \qquad (W,B_W+\Theta)\text{ is sub-klt}. +\] +All supports and coefficient margins are fixed near that compact. +With compatible canonical representatives, push the finite +principal-divisor expression for \(\Theta-N\) down and pull it +back again. For \(\Delta_\ell=p_*(B_W+\Theta)\) this gives +\[ + \Delta_\ell\geq0, + \qquad K_X+\Delta_\ell\sim_{\R}J|_{X_{U_\ell}}, + \qquad + p^*(K_X+\Delta_\ell)=K_W+B_W+\Theta. +\] +In the last equality the chosen principal correction is included +in the representative of \(K_X+\Delta_\ell\). +Thus \((X_{U_\ell},\Delta_\ell)\) is ordinary klt and its boundary +is relatively big. Lemma~11.15 of \cite{FujinoAnalyticBCHM}, with +its big part equal to \(\Delta_\ell\) and its remaining part zero, +replaces it, in its actual real linear equivalence class, by a klt +boundary with an effective general relatively ample rational +summand. Its condition on non-klt centres is vacuous. +Choose the reserved ample summand to be \(\Q\)-linearly equivalent +to a small rational multiple of a fixed global \(f\)-ample line. +Its later strict transform is consequently \(\Q\)-Cartier by the +transport of that global line, without a local factoriality claim. + +We make these choices for a finite rational polytope of actual +global line data. Start with a finite rational span containing +\(J\), and add relatively ample rational lines spanning the global +relative degree space. The above construction is valid in a +neighbourhood of \(J\): retain a small part of the ample summand +and use openness of ampleness and the strict klt inequalities. +It is also valid along a segment from \(J\) to a sufficiently +positive adjoint, by adding divided general ample divisors. +Use finitely many such representatives and one log resolution on +each chart. More explicitly, represent a finite simplex inside the +open ample neighbourhood used above; varying its positive +coefficients represents all nearby global line parameters on the +same finite support. Form the joint finite affine system consisting +of the divisor identities on all charts, with common global line +coordinates and separate boundary and principal-divisor +coordinates. This system is rational. Allow all boundary +coefficients to vary, including those originally contributed by +the real boundary \(B\); fix only the reserved rational ample part +and the zero-support constraints. Its projection to the global +line coordinates contains the just constructed neighbourhood, so +it has a rational affine section. Choose that section sufficiently +close to the constructed real affine lift, by rational approximation +in its affine space of sections, so that the strict klt and +effectiveness margins are retained along the compact segment. +In the joint solution space the +strict klt and effectiveness margins permit a rational polytope +containing the scaling segment. This supplies on every chart +a rational polytope of ordinary klt boundaries with a fixed +effective relatively ample rational summand, representing the +restrictions of the same global line parameters. These boundaries, +including the scaling representatives, are fixed before the +program starts. Their divisors need not agree on different charts. + +\smallskip\noindent +\emph{One global scaling construction.} +Apply the global degree-space construction in the proof of +Proposition~\ref{prog:relative-klt} to \(J\) and a general ample +scaling direction in the chosen span. Here are the modifications +that allow real line data and a nonbirational map to \(S\). +The global relatively ample line still gives a compact normalized +slice of the curve cone. The fixed ordinary chart pairs give finite +negative-ray truncations. A general direction avoids equal wall +parameters for independent ray-degree functionals, exactly as in +that proof. A positive wall therefore selects a single ray in the +global degree space. A rational nef support is represented by a +global rational line; a large multiple minus the chartwise ordinary +adjoint is relatively ample. Ordinary relative base point freeness +contracts the ray using the evaluation of this one global line. + +If the contraction is small, choose a global rational line having +negative ray degree and construct its flip by its one global +graded algebra. The local ordinary proof of +Proposition~\ref{prog:detected-flip} applies to this algebra: +all curves of the contraction have proportional degrees for global +lines, so the detector and the driving line are positively +proportional over the contraction; ordinary rational replacement +gives local finite generation. This part of that proof needs only +the already projective contraction and these line degrees. +It does not require a prior assertion about the full Bott--Chern +cone. The relative Proj is the next global model. In a divisorial +step the exceptional prime and +Lemma~\ref{prog:integral-descent} give the same continuation as in +Proposition~\ref{prog:relative-klt}. Killing the degree of any global +line by a rational multiple of the detector, then applying that +lemma, preserves global strong \(\Q\)-factoriality in both cases. +The global lines continue to span the relative degree spaces. +The rational support-simplex argument in that proposition makes +the wall a descended relatively ample real line on its contraction +base and gives a nonempty interval of ampleness immediately after +each step. This argument uses relative line data and projectivity, +not birationality of the map to \(S\). + +We check explicitly the persistence of the ordinary pairs. Expand +the line parameters in finitely many global rational lines. Their +reflexive transforms are actual rational lines by the preceding +strong property. Pushing forward the fixed principal-divisor +identities gives +\[ + K_{X_i}+\Delta_{\ell,i}\sim_{\R}J_i|_{(X_i)_{U_\ell}}. +\] +Hence these ordinary adjoints are \(\R\)-Cartier; no local +factoriality of individual prime divisors is being assumed. +On a common resolution their comparison minus the appropriate +positive multiple of the detector comparison is exceptional and +relatively numerically trivial. Negativity in both signs makes +this difference zero. Every chosen step is consequently negative +for the fixed ordinary pairs. They remain effective and klt, and +their boundaries remain relatively big. The same equality of +comparison divisors, after adding the fixed base pullback, +preserves the generalized pair and its discrepancy inequalities. + +For termination, every already constructed working model is a weak +log canonical model on each chart of a boundary in the fixed +polytope: choose a parameter in its nonempty ample scaling interval. +Indeed, actual descent at a preceding wall \(\lambda_j\) makes +the comparison for \(J+tH\) equal to +\((1-t/\lambda_j)\) times its \(J\)-comparison. For a parameter +in the current interval all preceding \(\lambda_j\) are at least +\(t\), so these comparisons are effective. +Theorem~E of \cite{FujinoAnalyticBCHM} gives finitely many marked +models on each chart. That theorem does not require locally +\(\Q\)-factorial targets. There are therefore finitely many possible +global marked working models. Indeed, isomorphisms between the +restrictions of two existing marked models agree on their common +dense open, and hence on overlaps. A repeated marked working model +would have the same boundary transform and discrepancies, contrary +to strict discrepancy increase at an intervening nontrivial step. +The global program is finite. Relative pseudoeffectivity excludes +a Mori fibre endpoint, so \(J_m\) is nef over \(S\). +This is a finite-cover argument for a single constructed program; +it does not glue independent minimal models. + +\smallskip\noindent +\emph{Semiampleness and the global polarization.} +On the endpoint the fixed ordinary pair is klt, its effective +boundary is relatively big, and its adjoint is nef over +\(W_\ell\). Lemma~11.16 of \cite{FujinoAnalyticBCHM} applies to +this already existing weak model. More explicitly, Lemma~11.15 +replaces the endpoint boundary by \(A_\ell+B_\ell\), where +\(A_\ell\geq0\) is relatively ample, \(B_\ell\geq0\), and the +pair is klt. Theorem~8.3 then gives semiampleness near \(W_\ell\): +its log canonical, klt-existence, real Cartier, ample-summand and +nef-over-compact hypotheses have all been checked. + +The actual equivalences identify these local semiample adjoints +with restrictions of \(J_m\). Their ample models agree on overlaps +by \cite[Lemma~11.3]{FujinoAnalyticBCHM}. To retain a global +polarization, shrink the initial parameter polytope around \(J\) +after the finite program: all its finitely many strict step signs +persist, so the transformed ordinary boundaries remain klt and big. +On each chart the pushforward of its initial common ample rational +summand is effective and relatively big. Apply +\cite[Lemma~11.13]{FujinoAnalyticBCHM} to this common big rational +part and the small endpoint boundary polytope. All pairs are klt, +so the condition on non-klt centres is vacuous. The lemma gives a +common general relatively ample rational summand by one +\(\Q\)-linearly trivial translation. In particular the rational +parametrization is preserved; separate applications of +Lemma~11.15 to individual parameters would not suffice here. +In this finite rational span Theorem~11.17 of \cite{FujinoAnalyticBCHM} +makes the endpoint nef region a rational polytope. Intersect the +finitely many inverse images of these regions and express \(J_m\) +as a positive combination of rational points in its minimal face. +The corresponding global rational lines are semiample on every +chart by the same ordinary base point free argument. After clearing +denominators and taking common sufficiently divisible powers over +the finite cover, each is relatively generated globally: generation on +the charts is generation of its global coherent relative +evaluation map. The product of these finitely many relative +morphisms, followed by Stein factorization, gives a projective +\(g:X_m\to Z\), a projective \(\rho:Z\to S\), and descended +global lines whose positive combination \(H\) is relatively ample. +It realizes the glued ample model and gives +\(J_m\sim_{\R}g^*H\). Adding back \(f_m^*\beta\) proves the +asserted Bott--Chern identity. Composing the effective step +comparisons proves the final discrepancy statement. +\end{proof} + +\begin{corollary}[Semiampleness on an existing projective model] +\label{prog:projective-semiample} +Let \(f:T\to S\) be a projective morphism of normal compact Kähler +spaces with \(T\) globally strongly \(\Q\)-factorial, and let +\(J\in\Pic(T)\otimes\R\) be nef over \(S\). Suppose that on a +finite Stein-compact cover satisfying condition~(P), there are +effective ordinary klt boundaries \(\Delta_\ell\), big over the +base, such that +\(K_T+\Delta_\ell\sim_{\R}J|_{T_{U_\ell}}\). +Then \(J\) has the projective relative semiample contraction and +actual descended ample real line of +Proposition~\ref{prog:projective-good-model}. +In particular this applies to any already existing weak model of +the fixed ordinary chart pairs in that proof; one need not run a +new program for the adjoint in question. +\end{corollary} + +\begin{proof} +Lemma~11.15 and Theorem~8.3 of \cite{FujinoAnalyticBCHM} give +local semiampleness. For an existing weak model this is also +Lemma~11.16. To globalize the polarization, take a finite rational +span of the global lines defining \(J\). On each chart the ample +part of the normalized boundary allows small perturbations in +this span. The joint rational affine construction in the preceding +proof gives a rational family with a common rational ample part; +all boundary coefficients are allowed to vary. Theorem~11.17 then +gives a rational nef region on each chart. The finite-intersection, +rational-vertex and global-evaluation argument in that proof gives +one projective contraction and its actual descended ample real +line. Only its local ample models are identified by uniqueness. +\end{proof} + +\begin{remark}[The two uses of projective completion] +\label{prog:projective-good-model-uses} +For a selective extraction over an already constructed weak model, +the carrier map is projective bimeromorphic. The inherited +exceptional splitting expresses the nef datum, modulo this base, +by actual real lines. Relative nefness follows from the carrier +datum, while relative bigness follows from birationality, using the +ample-plus-effective construction in the ordinary replacement. +The prepared adjoint is a base pullback plus an effective +exceptional divisor supported on exactly the unwanted primes. +Proposition~\ref{prog:projective-good-model} applies. On its endpoint +the remaining error is effective, exceptional over the fixed base, +and relatively nef; negativity makes it zero. Strict discrepancy +improvement prevents contraction of a requested zero-error prime. +The chosen extraction boundary must be effective and klt; in +particular its prescribed primes have the usual admissible +discrepancy range. + +For the graph construction, suppose the already projective graph +resolution \(h:V\to Y_m\) has smooth source and +\[ + A_V=h^*A_{Y_m}+[G],\qquad G\geq0. +\] +Then the global relative real line is \(J=\OO_V(G)\), the base +class is \(A_{Y_m}\), and its carrier line is +\(N=G-K_V-B_V\). Its relative degrees equal those of the prepared +nef datum. That datum is nef and big on the prepared carrier, for +example a pullback of its prepared Kähler class; thus \(N\) is nef +and big over \(Y_m\). This bigness is a separate hypothesis check, +since \(h\) can have positive-dimensional general fibres. +Effectivity of \(G\) gives relative pseudoeffectivity. Apply the +proposition over \(Y_m\). The subsequent negativity argument must +still remove \(G_m\); only then is the endpoint adjoint the pullback +of \(A_{Y_m}\) and good over the original base. + +For transport of all classes, verify separately that all +Bott--Chern classes on the graph carrier are real-line classes +modulo \(Y_m\), using the smooth rationally connected fibration +and the inherited exceptional splitting on the lower-dimensional +base model. Lemma~\ref{prog:projective-cone} then identifies +the relative degree rays with full Bott--Chern rays, so the +detected-step transport applies. The driving identity involving +\(G\) alone does not give this additional property. +\end{remark} + +\begin{corollary}[Ordinary projective Mori output] +\label{prog:projective-mori} +Let \(f:X\to S\) be an already projective surjective morphism of +compact Kähler spaces, with \(X\) smooth. Let \((X,B)\) be an +effective ordinary real klt pair, and let \(D=K_X+B\). If \(D\) +is not pseudoeffective over \(S\), then its projective program over +\(S\), with scaling of a relatively ample actual real line \(N\), +terminates with a Mori fibre contraction. The initial scaling +parameter is chosen so that \(D+TN\) is nef over \(S\). +The working spaces are globally strongly \(\Q\)-factorial and +compact Kähler, and the actual line comparisons and integral +descent of Proposition~\ref{prog:projective-good-model} apply. +\end{corollary} + +\begin{proof} +The line \(N\) is fixed; it need not be a general scaling direction. +In particular several extremal rays may have the same wall +parameter. Choose \(\epsilon>0\) such that \(D+2\epsilon N\) is +still not pseudoeffective over \(S\). On the finite Stein-compact +cover choose divided general effective representatives of \(N\) +so that all the resulting ordinary pairs representing \(D+tN\), +\(0\leq t\leq T\), are klt. For +\(\epsilon\leq t\leq T\) reserve a common effective relatively +ample rational summand. The joint rational-family construction in +Proposition~\ref{prog:projective-good-model} puts these fixed pairs +in the polytopes required by Theorem~E of +\cite{FujinoAnalyticBCHM}. + +Suppose a finite prefix has reached \(X_i\), and put +\(\mu_i=\lambda_{i-1}\), with \(\mu_0=T\). Its transformed +\(D_i+\mu_iN_i\) is nef. Define +\[ + \lambda_i=\min\{t\in[0,\mu_i]:D_i+tN_i + \text{ is nef over }S\}. +\] +The feasible set is a nonempty closed interval. Inductively +\(\lambda_i>2\epsilon\): all previous steps have nonpositive +comparison for \(D+2\epsilon N\), so its transform is still not +pseudoeffective. A first threshold at most \(2\epsilon\) would +make this transform nef by convexity between the current and +preceding thresholds, a contradiction. + +There is a \(D_i\)-negative extremal ray \(R_i\) with +\((D_i+\lambda_iN_i)\cdot R_i=0\). To see attainment without a +generality assumption, let \(t<\lambda_i\) tend to \(\lambda_i\). +A ray negative for \(D_i+tN_i\) has positive \(N_i\)-degree, +because \(D_i+\mu_iN_i\) is nef. When \(t>\lambda_i/2\), it is +also negative for \(D_i+(\lambda_i/2)N_i\). The latter has fixed +ordinary klt big-boundary representatives on the charts, since +\(\lambda_i/2>\epsilon\). Normalize each of these boundaries by +\cite[Lemma~11.15]{FujinoAnalyticBCHM} as \(A_\ell+B'_\ell\), +with \(A_\ell\geq0\) relatively ample and the new pair klt. +The \(A_\ell\)-truncation of the cone theorem for +\(K+B'_\ell\) gives finitely many rays negative for the entire +adjoint in question. The finite cover therefore gives finitely +many global negative rays. One of these rays attains the wall, +as required. + +Choose one such ray, even if the wall vanishes on other rays. +The rational-support argument for an individual negative ray in +Proposition~\ref{prog:relative-klt} gives a global rational nef +support annihilating exactly \(R_i\), and ordinary relative base +point freeness contracts it. For the real ordinary boundary one +may first choose a nearby rational klt boundary that is still +negative on \(R_i\). The contraction therefore has a rational +ordinary antiample adjoint. Its flip, when small, is constructed +from one global detector algebra as above. + +If the contraction is of fibre type, stop. Otherwise the wall +\(w_i=D_i+\lambda_iN_i\) has degree zero on \(R_i\). +In the finite rational span of its actual line factors, this +zero-degree subspace is rational: its defining functional has +rational values on rational lines. Thus \(w_i\) is a real +combination of rational lines of zero ray degree. +Lemma~\ref{prog:integral-descent} descends those lines to the +contraction base. Their combination is nef over \(S\), by lifting +curves through the projective contraction. Pulling it to the +positive side shows that the transformed wall stays nef. The next +threshold therefore satisfies \(\lambda_{i+1}\leq\lambda_i\); +equality is permitted. No interval of ampleness between successive +thresholds is required. + +If \(E_i\geq0\) is the ordinary \(D_i\)-comparison on a common +resolution, this actual wall descent gives, for every real \(t\), +\[ + p_i^*(D_i+tN_i) + \sim_{\R}q_i^*(D_{i+1}+tN_{i+1}) + +(1-t/\lambda_i)E_i. +\] +For \(t\leq\lambda_i\) the error is effective. This proves all +the nonpositivity and fixed-pair persistence assertions used in +the induction, including the lower bound on thresholds. + +At every working model use the \emph{wall parameter} \(t=\lambda_i\), +rather than an interior ample parameter. Since +\(\lambda_i\leq\lambda_j\) for every earlier step, the displayed +comparisons show that \(X_i\) is a weak log canonical model of +the initial fixed chart pairs representing \(D+\lambda_iN\). +Its trace is nef by definition. Theorem~E counts all these marked +weak log canonical models, including the ones at repeated wall +parameters. The finite chart cover gives a finite global marked +list. Repetition would contradict the strict ordinary +\(D\)-discrepancy increase at an intervening step. Thus this +program with the specified \(N\) is finite. Non-pseudoeffectivity +excludes a nef endpoint for \(D\), so the last contraction is a +Mori fibre contraction. The comparison at \(t=1=\lambda_i\) is +crepant: such a step supplies no strict discrepancy improvement +for \(D+N\), while it is still strictly negative for \(D\). +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03c-base-presentations.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03c-base-presentations.tex new file mode 100644 index 0000000000000000000000000000000000000000..fc2dfb15386121b736483e7c6e3c3deee2bc21a2 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03c-base-presentations.tex @@ -0,0 +1,644 @@ +\subsubsection{Base presentations and multiplier ideals} + +The following constructions take place in the category of generalized +data specified above. In particular, the whole adjoint is a +Bott--Chern class, whereas the boundary and nef traces on a singular +space are interpreted as currents. On a smooth carrier the structure +boundary is a real divisor; its negative components may be exceptional +over the space of the pair. The nef part is specified on that carrier +and pulled back to higher models. + +\begin{lemma}[Adjoint-preserving preparation] +\label{prog:base-presentation-preparation} +Let $(X,B+\mathbf M)$ be a generalized pair on a normal compact +K\"ahler space, with globally modified-big total boundary +$B+\mathbf M_X$. Write +\[ + A=[K_X+B+\mathbf M_X],\qquad + \mathcal J_o=\mathcal J(X,B+\mathbf M). +\] +There are generalized data on $X$ with the same adjoint class, a +projective carrier $p:U\to X$ with $U$ smooth and compact K\"ahler, an SNC real +divisor $C$ whose negative components are $p$-exceptional, and a +K\"ahler class $\beta$ such that +\begin{equation}\label{prog:base-presentation-prepared} + p^*A=[K_U+C]+\beta,\qquad + \mathcal J_1=p_*\mathcal O_U(-\lfloor C\rfloor) + \supseteq\mathcal J_o. +\end{equation} +The carrier may be required to dominate any prescribed projective +modification of $X$, with the structure and exceptional divisors +having simultaneous SNC support. The prepared total boundary is +globally modified big. In particular, the preparation preserves the +gklt condition. +\end{lemma} + +\begin{proof} +Choose a common projective log resolution $p_0:U_0\to X$ of the +original nef carrier and the prescribed modification, and write +\[ + p_0^*A=[K_{U_0}+C^0]+\mathbf M_{U_0}. +\] +The class $\mathbf M_{U_0}$ is nef, and the negative part $(C^0)^-$ +is exceptional over $X$. The modified-big preparation +\cite[Lemmas~2.10 and~2.23]{HX} can be made with the prescribed +resolution. We give its divisor and ideal details. Choose an effective divisor $E_0$ with sufficiently large coefficients +and full $p_0$-exceptional support so that the class +\[ + [(C^0)^+]+\mathbf M_{U_0}+[E_0] +\] +is big. Resolve a Kodaira decomposition of this class. On a further +projective modification $a:U\to U_0$ with $U$ smooth one obtains +\[ + a^*\bigl([(C^0)^+]+\mathbf M_{U_0}+[E_0]\bigr) + =\kappa+[D],\qquad D\geq0, +\] +where $\kappa$ is K\"ahler. The support can be made SNC together +with all the other divisors. On any additional blowup, subtract a +sufficiently small effective exceptional class from the pulled-back +K\"ahler class and add it to the divisor; an exceptional divisor +whose negative is relatively ample makes the resulting class +K\"ahler again. + +Put $p=p_0a$ and +\[ + C^{\mathrm{alt}}=D-a^*(C^0)^--a^*E_0-K_{U/U_0}. +\] +Then +\[ + p^*A=[K_U+C^{\mathrm{alt}}]+\kappa, +\] +and every negative component of $C^{\mathrm{alt}}$ is +$p$-exceptional. Let $C^{\mathrm{old}}$ be the crepant structure +boundary of the original data on this same model. For $00),\qquad + f_*\mathcal O_{N_1}=\mathcal O_Z/(f_*\mathcal J_1), + \qquad N_1=V(\mathcal J_1). +\end{equation} +If $N_1$ dominates $Z$, then $f_*\mathcal J_1=0$. +Otherwise there are generalized data $(Z,B_Z+\mathbf N)$, a +projective carrier $\tau:T\to Z$ with $T$ smooth and compact K\"ahler, a real +SNC structure divisor $C_T$, and a K\"ahler class $\beta_T$ such that +\begin{equation}\label{prog:base-presentation-identities} + \begin{gathered} + [K_Z+B_Z+\mathbf N_Z]=\gamma,\qquad + \tau^*\gamma=[K_T+C_T]+\beta_T,\qquad + \mathbf N_T=\beta_T,\\ + B_Z=\tau_*C_T\geq0,\qquad + B_Z+\mathbf N_Z\ \text{is globally modified big}. + \end{gathered} +\end{equation} +The negative components of $C_T$ are $\tau$-exceptional, and +\begin{equation}\label{prog:base-presentation-ideal} + \mathcal J_Z:=\mathcal J(Z,B_Z+\mathbf N) + =\tau_*\mathcal O_T(-\lfloor C_T\rfloor) + \supseteq f_*\mathcal J_1. +\end{equation} +In particular the base data are gklt wherever $f_*\mathcal J_1$ is +the unit ideal. If the source data are gklt, the base data are gklt. +All adjoint identities are preserved by pullback to higher models. +\end{proposition} + +\begin{proof} +Choose a projective resolution $\mu:W\to Z$, with $W$ smooth +compact K\"ahler and reduced exceptional divisor $F$ having SNC +support. Apply Lemma~\ref{prog:base-presentation-preparation} on a +carrier dominating the main component of the base change. We obtain +projective maps $p:U\to X$ and $q:U\to W$ with $fp=\mu q$ and +\begin{equation}\label{prog:base-presentation-source} + [K_U+C]+\beta=p^*A=q^*\mu^*\gamma, + \qquad \mathcal J_1=p_*\mathcal O_U(-\lfloor C\rfloor). +\end{equation} +Here $U$ is smooth compact K\"ahler, $\beta$ is K\"ahler, and all +negative components of $C$ are $p$-exceptional. The maps are +projective by composition and factorization over the separated base +$W$. The map $q$ has connected fibres: this holds over the open set +where $\mu$ is an isomorphism, and its Stein factorization is finite +and bimeromorphic over the normal space $W$. + +The integral divisor $-\lfloor C\rfloor$ has class +\[ + [-\lfloor C\rfloor] + =[K_U+\{C\}]+\beta-(fp)^*\gamma. +\] +The pair $(U,\{C\})$ is klt with SNC boundary. Relative +Kawamata--Viehweg vanishing, first for $p$ and then for $fp$, applies +because the positive class modulo pullbacks is K\"ahler +\cite[Theorem~2.2]{HX}. Equivalently, the real line bundle +$-K_U-C$ is relatively ample, +so the vanishing follows from \cite[Theorem~1.2]{FujinoVanishing2025} +with the identity as its first morphism. Leray gives $R^if_*\mathcal J_1=0$ for +$i>0$. Applying $f_*$ to the sequence defining $N_1$, and using +$f_*\mathcal O_X=\mathcal O_Z$, proves +\eqref{prog:base-presentation-Stein}. If $N_1$ dominates $Z$, the +ideal $f_*\mathcal J_1\subseteq\mathcal O_Z$ vanishes generically +and therefore vanishes. This proves that alternative. + +Suppose from now on that $N_1$ does not dominate $Z$. Every +$q$-horizontal coefficient of $C$ is then less than one. Indeed, +a component with coefficient at least one forces the multiplier +ideal to be proper along its image in $X$, and its image would make +$N_1$ dominate $Z$. If $Z$ is a point, the asserted base presentation +is the dimension-zero presentation. We therefore assume +$b=\dim Z>0$. + +\paragraph{The fibre metric.} +Choose a smooth representative $\rho$ of +$\mu^*\gamma-c_1(K_W)$, a K\"ahler form $\omega_W$, and a +K\"ahler form representing $\beta$, still denoted by $\beta$. +For some $a>0$, +\[ + \beta\geq a q^*\omega_W. +\] +Consider the holomorphic line bundle +\[ + L=\mathcal O_U(-K_{U/W}-\lfloor C\rfloor). +\] +Equation~\eqref{prog:base-presentation-source} gives a singular +Hermitian metric $h$ on $L$ whose curvature current is +\begin{equation}\label{prog:base-presentation-curvature} + \Theta_h(L)=\beta+[\{C\}]-q^*\rho. +\end{equation} +Its weights are smooth functions plus the divisorial logarithms +with coefficients in $\{C\}$. We normalize $dd^c$ so that +$dd^c\log|z|^2=[z=0]$ and write squared-norm weights as $e^{-\varphi}$. +Let $e$ be the canonical meromorphic section of +\[ + K_{U/W}\otimes L=\mathcal O_U(-\lfloor C\rfloor), +\] +so that $\operatorname{div}(e)=-\lfloor C\rfloor$. + +Choose an analytic Zariski open set $W^\circ\subseteq W$ on which +$q$ is a submersion, the horizontal boundary is relatively SNC, +there are no vertical boundary components, $\mu$ is an isomorphism +onto an open subset of $Z$, and coherent base change holds in degree +zero. On $q^{-1}(W^\circ)$, the divisor $-\lfloor C\rfloor$ is +effective and exceptional over $X$. Normality and the contraction +property therefore identify +\[ + q_*(K_{U/W}\otimes L)|_{W^\circ} + =\mathcal O_{W^\circ}e. +\] +Here $K_{U/W}$ is viewed as the relative canonical line bundle. The +fibre norm +\[ + I(w)=\int_{U_w}|e_w|_h^2 +\] +is positive and finite. The fractional SNC weights are integrable; +any zeros of $e_w$ only improve integrability. Relative SNC +coordinates and a partition of unity show that $I$ is smooth: +parameter derivatives act on smooth factors multiplying fixed +integrable monomial weights. + +Set $\psi=-\log I$ on $W^\circ$. Then +\begin{equation}\label{prog:base-presentation-open-positivity} + \rho+dd^c\psi\geq a\omega_W. +\end{equation} +Here are the details for the singular weights. Locally choose +$\ell$ with $dd^c\ell=\rho-a\omega_W$, and put +$h'=he^{-q^*\ell}$. Its weights are psh, and its fibre norm satisfies +$I'=e^{-\ell}I$. Restrict the family to a small coordinate line disk +$\Delta_R$, with centre $0$. The sharp $L^2$ extension theorem gives +a twisted top form extending $e_0$ and satisfying +\begin{equation}\label{prog:base-presentation-sharp-extension} + \int_{q^{-1}(\Delta_R)}|E|_{h'}^2 + \leq\pi R^2 I'(0). +\end{equation} +Top-form norms here are normalized to use Euclidean area in the +base coordinate. We use the Stein hypersurface form of the optimal +extension theorem \cite[Theorem~2.2 and \S3.5, (3.1)]{GuanZhouOptimal2015}, +with defining function the disk coordinate divided by $R$. + +To check applicability, embed the restricted projective family into +projective space over the disk and remove a relative hyperplane +section that does not contain the central fibre. The complement is +Stein. A holomorphic section of $L$ on this Stein space can be chosen +nonzero at a point of the central fibre; deleting its zero divisor +trivializes $L$ and leaves a Stein space. The central fibre is smooth +and connected, hence irreducible, so both deletions leave a dense +open subset of it. For a zero-dimensional fibre choose the deletions +to avoid its point. In the resulting trivialization the weight is +psh, and the sharp extension theorem applies to canonical forms. +The extension extends across the deleted hypersurfaces in reverse +order by local $L^2$ removability: in every original frame the metric +is bounded below by a smooth positive metric. The extension retains +its norm bound and its prescribed restriction to the central fibre. + +After dividing $E$ by the base differential, the rank-one direct +image identifies it with $b(t)e$, where $b$ is holomorphic and +$b(0)=1$. Thus the disk average of $|b(t)|^2I'(t)$ is at most $I'(0)$. +Jensen's inequality and the submean inequality for $\log|b|^2$ give +\[ + \log I'(0) + \geq\operatorname{avg}_{\Delta_R} + \bigl(\log|b(t)|^2+\log I'(t)\bigr) + \geq\operatorname{avg}_{\Delta_R}\log I'(t). +\] +The same argument applies to every sufficiently small disk at every +centre and in every complex line direction. Hence $-\log I'=\psi+\ell$ is psh, which proves +\eqref{prog:base-presentation-open-positivity}. + +\paragraph{Extension over the base.} +Let $D$ be a prime divisor in $W\setminus W^\circ$. Choose a component +$Q$ of $q^*D$ dominating $D$. When $D$ is not $\mu$-exceptional, choose +$Q$ not $p$-exceptional: take a component over the corresponding prime +on $Z$ already on $X$ and then its strict transform. Put +\[ + u=\operatorname{ord}_Q(q^*D),\qquad c=\operatorname{coeff}_Q(C). +\] +At a general point of $Q$, avoiding all other relevant divisors, +there are local coordinates with +\[ + t_1=z_1^u,\qquad t_j=z_j\quad(2\leq j\leq b). +\] +Indeed the map $Q\to D$ is submersive at a general smooth point, +and a local unit in the first equation is absorbed by a holomorphic +$u$th root. Such points can be chosen above every point of a dense +analytic open subset of $D$ by generic smoothness and properness. +Integration over a fixed small polydisk in the remaining fibre +coordinates gives +\begin{equation}\label{prog:base-presentation-divisor-bound} + I(t)\geq c_*|t_1|^{-2(c+u-1)/u} +\end{equation} +for some $c_*>0$ near each such base point. The section and metric +contribute the exponent $c$, while division by the base differential +in the relative canonical form contributes $u-1$. + +For a nonexceptional $D$ the chosen $Q$ has $c\geq0$, so +\eqref{prog:base-presentation-divisor-bound} bounds $\psi$ from above +near its general points. For the finitely many exceptional divisors, +the same estimate supplies a nonnegative integer $m$ such that, if +$k$ is a smooth metric on $\mathcal O_W(F)$ and $s_F$ its divisor +section, +\[ + \varphi=\psi+m\log|s_F|_k^2 +\] +is locally bounded above near general points of every divisor. +Adding local potentials of $\rho+m c_1(k)-a\omega_W$ to +$\varphi$ gives psh weights by +\eqref{prog:base-presentation-open-positivity}. These weights +extend across the divisors and then across the remaining analytic +set of codimension at least two, giving +\begin{equation}\label{prog:base-presentation-positive-current} + S=\rho+m c_1(k)+dd^c\varphi\geq a\omega_W +\end{equation} +on all of $W$. + +\paragraph{A K\"ahler carrier.} +Regularize the current in +\eqref{prog:base-presentation-positive-current} in its class, retaining +a lower bound for the potentials. More precisely, choose an +approximation with analytic singularities such that +\begin{equation}\label{prog:base-presentation-regularization} + S'=\rho+m c_1(k)+dd^c\varphi',\qquad + S'\geq\frac a2\omega_W,\qquad + \varphi'\geq\varphi-O(1). +\end{equation} +These simultaneous properties are the Bergman regularization +properties of \cite{DemaillyRegularization1992}; see also +\cite[pp.~59--60]{PopoviciRegularization2004}. +Resolve the analytic singularities and the support of $F$ by a +sequence of blowups with smooth centres $r:T\to W$, with simultaneous +SNC support, and write +\[ + r^*S'=[H]+\zeta,\qquad H\geq0. +\] +The residual current $\zeta$ has locally bounded potentials. Removing +the divisorial part from the positive current +$r^*S'-(a/2)r^*\omega_W$ shows that +\[ + \zeta\geq\frac a2r^*\omega_W. +\] +The difference has vanishing Lelong numbers, so its class is nef by +regularization. Choose an effective $r$-exceptional divisor $G$ with +$-G$ relatively ample. For $0<\eta\ll1$, the class +$(a/2)r^*\omega_W-\eta[G]$ is K\"ahler. Therefore +\begin{equation}\label{prog:base-presentation-carrier-data} + \begin{split} + \tau&=\mu r,\qquad + \beta_T=[\zeta]-\eta[G],\\ + C_T&=H+\eta G-mr^*F-K_{T/W} + \end{split} +\end{equation} +has K\"ahler $\beta_T$. If $r$ is an isomorphism, omit $G$ and its +correction. The choice of $\eta$ will be decreased once more below. + +The exact class calculation is +\[ + \begin{split} + [K_T+C_T]+\beta_T + &=r^*c_1(K_W)+[H]+[\zeta]-m[r^*F]\\ + &=r^*(c_1(K_W)+[\rho])=\tau^*\gamma. + \end{split} +\] +All possibly negative terms in $C_T$ are $\tau$-exceptional. +Consequently $B_Z=\tau_*C_T$ is effective. Specify the nef b-data by +$\mathbf N_T=\beta_T$; the displayed identity defines generalized +data on $Z$ with adjoint class $\gamma$. At the level of currents, +pushing the identity gives the required trace identity on $Z$: +exceptional divisor currents push to zero, and a $dd^c$ difference +pushes to a $dd^c$ difference. Canonical traces can be computed using +local meromorphic canonical frames; a change of frame changes the +corresponding Chern potentials by the usual logarithmic transition +term. Thus only the whole adjoint, rather +than its individual traces, needs to be a Bott--Chern class. The +class $\beta_T$ plus the strict transform of $B_Z$ is big on $T$, +so its pushforward $B_Z+\mathbf N_Z$ is globally modified big. +These are~\eqref{prog:base-presentation-identities}. + +\paragraph{The multiplier ideal.} +Take a local holomorphic function $v\in f_*\mathcal J_1$. By the +pushforward description of $\mathcal J_1$, +\begin{equation}\label{prog:base-presentation-source-orders} + \operatorname{div}(q^*\mu^*v)\geq\lfloor C\rfloor. +\end{equation} +Thus $q^*\mu^*v\,e$, tensored with a local base canonical frame, +is a holomorphic $L$-valued top form on $U$. Its squared norm is +locally integrable by the fractional SNC weights in +\eqref{prog:base-presentation-curvature}. Over the submersion locus, +fibre integration followed by base integration is precisely this +top-form integral. Properness and a finite coordinate covering +therefore give +\begin{equation}\label{prog:base-presentation-base-integral} + \int |\mu^*v|^2e^{-\psi}<\infty +\end{equation} +locally on $W$; the integral is taken where the original fibre +metric is defined. + +The lower bound on $\varphi'$ in +\eqref{prog:base-presentation-regularization} preserves this +integrability after replacing $\psi$ by +$\varphi'-m\log|s_F|_k^2$. Change variables through $r$. Along a +prime divisor of $T$, let $h,j,k_D,d$ be respectively the coefficients +of $H$, $\operatorname{div}(\tau^*v)$, $K_{T/W}$, and $r^*F$. +The local integrand has exponent +$2(j-h+md+k_D)$, up to a bounded positive factor. Its integrability +implies $j-h+md+k_D>-1$, or, since $j$ is integral, +\[ + j\geq\lfloor h-md-k_D\rfloor. +\] +Therefore +\[ + \operatorname{div}(\tau^*v) + \geq\lfloor H-mr^*F-K_{T/W}\rfloor. +\] +Choose $\eta>0$ sufficiently small that adding $\eta G$ does not +change any of these finitely many round-downs. The resulting +inequality is exactly +$\operatorname{div}(\tau^*v)\geq\lfloor C_T\rfloor$, proving +\eqref{prog:base-presentation-ideal} as an inclusion of ideal sheaves. +In particular, if $f_*\mathcal J_1$ is the unit ideal on an open set, +then so is $\mathcal J_Z$, and the base data are gklt there. + +Finally, the nef data descend to $T$, and the structure boundaries +on higher models are defined by crepant pullback of +\eqref{prog:base-presentation-identities}. On every common refinement +of the source and base carriers, both adjoints are the pullback of +$\gamma$. Thus the identities remain exact on higher models. +\end{proof} + +\begin{lemma}[Contractions of closed subspaces] +\label{prog:base-emc} +Let $D$ be a compact complex space, possibly nonreduced, and let +$\delta\in H^2(D,\R)$ have nonnegative degree on compact curves. +Use the definitions of a Moishezon morphism and of a contraction +defined by a class in \cite[Definitions~2.32 and~2.34]{HX}. +Then the following hold. +\begin{enumerate} +\item If $\delta$ is endowed with a Moishezon contraction, so is +its restriction to every closed analytic subspace of $D$. +\item Let $g:D\to V$ be a projective contraction of compact +complex spaces, so $g_*\OO_D=\OO_V$, and suppose +$\delta=g^*\epsilon$ for a class $\epsilon\in H^2(V,\R)$ +having nonnegative degree on compact curves. Then $\delta$ is +endowed with a Moishezon contraction if and only if $\epsilon$ +is endowed with one. +\end{enumerate} +\end{lemma} + +\begin{proof} +Write $h:D\to S$ for a Moishezon contraction defined by +$\delta$. For a closed subspace $D_0\subset D$, take the Stein +factorization +\[ + D_0\longrightarrow S_0\longrightarrow S +\] +of its restriction. The first map is a contraction, and the second +is finite. Thus a curve in $D_0$ is contracted by the first map +exactly when its $\delta$-degree is zero. Choose a projective +surjection $P\to D$ witnessing that $h$ is Moishezon, with +$P\to S$ projective. The closed subspace +$P_0=P\times_D D_0$ is projective over $S$ and projective +and surjective over $D_0$. It is also projective over $S_0$: +a relatively ample line for $P_0\to S$ remains ample on the +fibres of $P_0\to S_0$. This proves the first assertion, +including its scheme structure. + +For the descent direction of the second assertion, every curve +in a fibre of $g$ has $\delta$-degree zero. A connected +projective complex space is connected by chains of compact curves +after passing to its reduction. Therefore $h$ is constant on +the underlying set of each fibre of $g$. It factors as +$h=k\circ g$ for a holomorphic map $k:V\to S$. +To see that this factorization holds also for nonreduced spaces, +choose a coordinate neighbourhood in $S$ of the image of a fibre. +Properness permits restriction to a neighbourhood of its point +in $V$ whose inverse image maps into that coordinate +neighbourhood. The coordinate functions of $h$ then descend +uniquely through $g_*\OO_D=\OO_V$; their analytic relations +descend through the same equality. These local factorizations +glue. Furthermore, +\[ + k_*\OO_V=h_*\OO_D=\OO_S. +\] +Every irreducible compact curve $C\subset V$ is dominated by +a compact curve $C'\subset D$. Indeed, after base change to +the normalization of $C$, take a component dominating that curve +and a projective multisection. The projection formula gives +\[ + \delta\cdot C' + =\deg(C'\to C)\,\epsilon\cdot C. +\] +Consequently $k$ contracts exactly the curves of +$\epsilon$-degree zero. The composite $P\to D\to V$ +is a projective surjection, and $P\to S$ is projective, so +it witnesses that $k$ is Moishezon. + +Conversely, suppose $k:V\to S$ is a Moishezon contraction +defined by $\epsilon$. Then $k\circ g$ is a contraction, +and the projection formula verifies its curve criterion, treating +separately curves contracted by $g$. If $Q\to V$ is a +projective surjection witnessing that $k$ is Moishezon, then +$D\times_V Q\to D$ is projective and surjective, while +$D\times_V Q\to Q\to S$ is projective. This supplies the +required witness. +\end{proof} + +\begin{lemma}[Crepant transport of the multiplier closed subspace] +\label{prog:multiplier-transport} +Let $g:X\to Y$ be a projective bimeromorphic morphism of +normal compact K\"ahler spaces. Suppose effective generalized +pair data on $X$ and $Y$ have the same globally nef b-part +and are crepant over $Y$. In particular their adjoint classes +$A_X$ and $A_Y$ satisfy $A_X=g^*A_Y$ in Bott--Chern +cohomology. Write $J_X,J_Y$ for their multiplier ideals and +$N_X=V(J_X)$, $N_Y=V(J_Y)$ for their non-klt closed +subspaces. Then +\[ + g_*J_X=J_Y,\qquad R^ig_*J_X=0\quad(i>0), + \qquad g_*\OO_{N_X}=\OO_{N_Y}. +\] +The restriction $N_X\to N_Y$ is a projective contraction. +Hence, whenever $A_Y$ is nef, the restriction of $A_X$ to +$N_X$ is endowed with a Moishezon contraction if and only if +the restriction of $A_Y$ to $N_Y$ is endowed with one. +\end{lemma} + +\begin{proof} +Take a projective common log resolution $r:U\to X$ carrying +the nef datum, and put $s=g\circ r$. By crepancy there is +one real SNC divisor $C$ such that +\[ + K_U+[C]+\beta=s^*A_Y=r^*A_X, +\] +where $\beta$ is globally nef. The multiplier ideals are +\[ + J_X=r_*\OO_U(-\lfloor C\rfloor),\qquad + J_Y=s_*\OO_U(-\lfloor C\rfloor). +\] +Their direct-image equality follows at once. For vanishing, set +$L=\OO_U(-\lfloor C\rfloor)$ and +$\Delta=C-\lfloor C\rfloor$. The pair $(U,\Delta)$ +is klt, and the actual real line +\[ + L-(K_U+\Delta)=-K_U-C +\] +has class $\beta-s^*A_Y$. It is relatively nef over $Y$ +and relatively big because $s$ is bimeromorphic. The same +statements hold over $X$. Relative Kawamata--Viehweg vanishing, +in the form of \cite[Theorem~1.2]{FujinoVanishing2025} with +the first morphism the identity and the real line +$\mathcal H=-K_U-C$, therefore gives +\[ + R^is_*L=R^ir_*L=0\qquad(i>0). +\] +The real-line identity in that theorem is the displayed definition +of $\mathcal H$; its relative positivity is checked by the class +identity above. The klt condition means that there are no proper log +canonical strata to test for relative log bigness. Leray gives +$R^ig_*J_X=0$ for $i>0$. Pushing forward +$0\to J_X\to\OO_X\to\OO_{N_X}\to0$ and using +$g_*\OO_X=\OO_Y$ now proves the asserted structure-sheaf +equality. It also identifies the scheme-theoretic image with +$N_Y$, giving the projective contraction between these closed +subspaces. Apply Lemma~\ref{prog:base-emc} to conclude. +\end{proof} + +\begin{remark} +The preceding lemma also transports the contraction hypothesis +through a crepant projective flip: apply it to the two contractions +to their common base, equipped with the descended adjoint and +the common nef b-data. On that base the boundary is the effective +pushforward of the source boundary, and the nef data remain on +the same carrier; the descended Bott--Chern adjoint and its +identity on a common resolution define the crepant base data +in the whole-adjoint and current-trace category used here. +All assertions concern the fixed adjoint +and its multiplier ideal. No conclusion about the multiplier +ideal of a different driving adjoint is used. +\end{remark} + +\begin{corollary}[The contraction step over a lower-dimensional base] +\label{prog:base-emc-induction} +Use the hypotheses and notation of +Proposition~\ref{prog:base-presentation}. Suppose that +$A=f^*\gamma$ is nef and that its restriction to the original +non-klt closed subspace $N_o=V(J_o)$ is endowed with a +Moishezon contraction. Put +\[ + I=f_*J_1,\qquad N_*=V(I)\subset Z. +\] +Then $\gamma|_{N_*}$ is endowed with a Moishezon contraction. +If the prepared non-klt closed subspace $N_1=V(J_1)$ dominates +$Z$, then $\gamma$ and $A$ are endowed with Moishezon +contractions. Otherwise the generalized pair supplied on $Z$ +has a non-klt closed subspace endowed with the contraction +defined by the restricted class of $\gamma$. In this latter +case, if $\gamma$ is nef and NQC and the assertion +$\mathsf C_{\dim Z}$ is available, then $\gamma$ and $A$ +are endowed with Moishezon contractions. +\end{corollary} + +\begin{proof} +The inclusion $J_o\subset J_1$ gives $N_1\subset N_o$ +as closed analytic subspaces. By +Lemma~\ref{prog:base-emc}, the given contraction restricts to +$N_1$. Proposition~\ref{prog:base-presentation} identifies +\[ + f_*\OO_{N_1}=\OO_Z/I=\OO_{N_*}. +\] +Thus the restriction $N_1\to N_*$ is a projective +contraction. The restricted adjoint is the pullback of +$\gamma|_{N_*}$, so Lemma~\ref{prog:base-emc} descends +the contraction to $N_*$. Nonnegative degrees on curves of +$N_*$ follow from projective multisections and nefness of +$A$. + +If $N_1$ dominates the normal irreducible space $Z$, then +$I=0$: a local function in $I$ pulls back to zero on the +dominating closed subspace and hence vanishes generically on +$Z$. Normality, and in particular reducedness, gives its +vanishing. Therefore $N_*=Z$, which proves the assertion in +this case. + +If $N_1$ does not dominate $Z$, the constructed base ideal +satisfies $I\subset J_Z$. Hence +\[ + V(J_Z)\subset V(I)=N_* +\] +as closed analytic subspaces. Restriction by +Lemma~\ref{prog:base-emc} provides the required contraction +on $V(J_Z)$, with its complete scheme structure. The +generalized pair on $Z$ has globally nef carrier data and +globally modified-big total boundary by +Proposition~\ref{prog:base-presentation}. When the stated +nef and NQC conditions hold, these facts are precisely the +hypotheses of $\mathsf C_{\dim Z}$, which gives the +contraction on $Z$. Finally Lemma~\ref{prog:base-emc} +pulls it back through the projective contraction $f$ to $X$. +The case of an empty non-klt closed subspace has the same +interpretation, with its contraction condition vacuous. +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03c-restricted-induction.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03c-restricted-induction.tex new file mode 100644 index 0000000000000000000000000000000000000000..222494796066246c4a079d2c82db5b5c7b58e419 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/03c-restricted-induction.tex @@ -0,0 +1,1925 @@ +\subsection{A restricted dimension induction} +\label{prog:dimension-induction} + +All generalized nef data in this subsection are globally nef on a fixed +compact K\"ahler carrier. For the degree arguments we use weak NQC: +a positive combination of rational degree-two classes having +nonnegative degree on compact curves. Strong NQC implies this +condition, and the contraction assertion admits this weak form +\cite[Definition~2.43]{HX}. The nef adjoint itself remains nef in +Bott--Chern cohomology throughout. A modified-big boundary means the total trace +$B+\mathbf M_X$ is globally modified big. Relative assertions retain +these absolute hypotheses. A marked model records its bimeromorphic map +from the specified source; two markings agree only under an isomorphism +commuting with those maps. Weak models below may be arbitrary normal compact K\"ahler weak log +canonical models. Their generalized nef traces are understood as +closed currents pushed forward from the fixed nef carrier; only the +whole adjoint is required to be a Bott--Chern class. In particular no +factoriality, and no separate Bott--Chern class for either $K_Y+B_Y$ +or the nef trace, is required of an auxiliary weak target. This +category contains both the working models and the adjunction strata +used in special termination. Chosen program outputs remain globally +strongly $\mathbb Q$-factorial. + +For dimension at most $d$, write $\mathsf B_d$ for semiampleness of a +nef gklt adjoint with modified-big boundary, including a Moishezon +connected contraction onto a normal compact K\"ahler target. It makes +no assertion that every such contraction is projective. +Write $\mathsf C_d$ for the NQC non-klt contraction assertion of +\cite[Theorem~1.6]{HX}, and $\mathsf C_{d,\mathrm{big}}$ for its +big-adjoint case. The relative assertions are: +\begin{itemize} +\item $\mathsf M_d$: a relatively pseudo-effective gklt adjoint over +any proper map to a normal compact K\"ahler base $S$, with the globally +nef and modified-big data just specified, has a chosen nonextracting +good log terminal model over $S$. Its working space is globally +strongly $\mathbb Q$-factorial and compact K\"ahler; its connected +relative canonical morphism has normal compact K\"ahler target and +is Moishezon. From a smooth common carrier, +all Bott--Chern classes have forward traces, and the chosen model has +the rational degree-two and Bott--Chern exceptional splittings proved +below. +\item $\mathsf F_d$: a compact polytope of these data on one fixed +carrier has a polyhedral relative effective locus, finitely many +relative canonical chambers with chosen good terminal models, and +finitely many marked weak models, accounting for every weak model +in the category specified above. +\end{itemize} +Passing to the proper image and then to its normal Stein factor allows +all base maps to be taken surjective with connected fibres. These +operations preserve the compact K\"ahler base category. + +The independent inputs are the analytic cone theorem, the projective +results of Proposition~\ref{prog:projective-good-model}, relative +vanishing, adjunction, relative-canonical positivity, and the +nef-and-big K\"ahler criterion. The base presentations and +multiplier-ideal descent used in the induction are proved below. +The projective constructions use the actual-line lemmas of the preceding +subsection. No assertion of termination of an arbitrary sequence of +flips is used. + +\input{sections/03c-base-presentations} + +\subsubsection{A fixed integral grid and cohomology transport} + +\begin{lemma}[Integral degree-two descent for a locally log-Fano map] +\label{prog:integral-h2} +Let $f:X\to Z$ be a projective surjective morphism with connected fibres +between normal complex analytic spaces. Assume that $f_*\mathcal O_X= +\mathcal O_Z$, that $R^if_*\mathcal O_X=0$ for $i>0$, and that every point +of $Z$ has a neighbourhood $U$ on which there is a klt pair +$(X_U,\Delta_U)$ with $-(K_{X_U}+\Delta_U)$ ample over $U$. +Then $f^*:H^2(Z,\mathbb Z)\to H^2(X,\mathbb Z)$ is injective, and its +image consists exactly of the integral classes having degree zero on +every compact curve contracted by $f$. +\end{lemma} + +\begin{proof} +Properness, normality and connected fibres identify both +$f_*\mathcal O_X=\mathcal O_Z$ and +$f_*\mathcal O_X^*=\mathcal O_Z^*$. Apply $Rf_*$ to the analytic +exponential sequence. The local surjectivity of +$\mathcal O_Z\to\mathcal O_Z^*$ and the stated coherent vanishing give +\[ + R^1f_*\mathbb Z_X=0, + \qquad + R^1f_*\mathcal O_X^*\simeq R^2f_*\mathbb Z_X. +\] +Let $\xi\in H^2(X,\mathbb Z)$ have zero degrees on contracted curves. +A germ of its edge image in $R^2f_*\mathbb Z_X$ is, under this +isomorphism, represented after shrinking $U$ by an actual line bundle +$L$ on $X_U$. Equality of these germs means that, after further +shrinking, $c_1(L)$ and $\xi|_{X_U}$ have the same class. In particular +$L$ has degree zero on every curve in every fibre above this smaller +neighbourhood. + +On a sufficiently small Stein base neighbourhood, twisting by a +relatively ample line and taking a quotient of two nonzero relative +sections gives a meromorphic Cartier representative for $L$. Thus +the Cartier-divisor form of base point freeness applies. +The line bundle $L$ is relatively nef, and +$aL-(K_{X_U}+\Delta_U)$ is relatively ample for every real $a$. +The projective analytic base-point-free theorem applies to the Cartier +line $L$. Its conclusion is generation for \emph{every} sufficiently +large integer power, not only for a divisible subsequence +\cite[Theorems~6.2 and~6.5]{FujinoAnalyticBCHM}. Thus, over a further relatively compact +neighbourhood, both $L^m$ and $L^{m+1}$ are relatively generated. +A generated line of degree zero on every curve of a projective connected +fibre defines a constant projective map on that fibre: the restriction +of the generated line is the pullback of $\mathcal O(1)$, and a +positive-dimensional projective image contains a curve of positive +degree. The corresponding relative image is therefore finite and +bimeromorphic over the normal base, and is the base itself. Consequently +\[ + L^m\simeq f^*M_m,\qquad L^{m+1}\simeq f^*M_{m+1} +\] +for line bundles on the neighbourhood in $Z$. Taking their quotient +proves $L\simeq f^*(M_{m+1}\otimes M_m^{-1})$. Its germ in +$R^1f_*\mathcal O_X^*$ is zero, so the edge image of $\xi$ is zero. + +The integral Leray spectral sequence, using +$R^1f_*\mathbb Z_X=0$, gives +\[ + 0\longrightarrow H^2(Z,\mathbb Z) + \xrightarrow{f^*}H^2(X,\mathbb Z) + \longrightarrow H^0(Z,R^2f_*\mathbb Z_X). +\] +Exactness at the middle term proves the assertion. The argument is +integral throughout and does not discard torsion. The converse follows +by restriction of a pulled-back class to a fibre. +\end{proof} + +\begin{lemma}[A fixed integral grid along existing crepant steps] +\label{prog:fixed-integral-grid} +Let $X_0$ be a compact K\"ahler space, and suppose that +\[ + \alpha_0=\sum_{j=1}^r a_j\gamma_{0j},\qquad a_j>0, + \qquad \gamma_{0j}\in H^2(X_0,\mathbb Q), +\] +where each $\gamma_{0j}$ has nonnegative degree on compact curves. +Fix integers $m_j>0$ such that $m_j\gamma_{0j}$ is the image of an +integral cohomology class. Consider an existing sequence of projective +birational steps +\[ + X_i\xrightarrow{f_i}Z_i\xleftarrow{f_i^+}X_{i+1}, +\] +where $f_i^+$ is the identity for a divisorial step, $f_i$ satisfies +Lemma~\ref{prog:integral-h2}, and $\alpha_i$ is trivial on its +contracted ray. Assume every $f_i$-contracted curve has degree +proportional to that ray for the classes in the display. Then the +classes $\gamma_{ij}$ descend through $f_i$ and pull back through +$f_i^+$, the same integers $m_j$ remain integral multiples at every +stage, and the transported classes remain nonnegative on curves. +In particular, for every integral compact curve $C\subset X_i$, +\[ + \alpha_i\cdot C>0\quad\Longrightarrow\quad + \alpha_i\cdot C\geq\delta, + \qquad \delta:=\min_j\frac{a_j}{m_j}>0. +\] +\end{lemma} + +\begin{proof} +Positivity of the coefficients and nonnegativity of the summands imply +that every $\gamma_{ij}$ annihilates the contracted ray. Apply the +integral descent lemma to the chosen integral lift of +$m_j\gamma_{ij}$ and pull its descended class back to $X_{i+1}$. +This keeps $m_j$ fixed. + +To verify nonnegativity, take a curve on $X_{i+1}$. If it is contracted +by $f_i^+$, every descended summand has degree zero. Otherwise its +image is a curve $\Gamma\subset Z_i$. The projective map $f_i$ has a +compact curve mapping onto $\Gamma$ with positive degree: take a +component of its inverse image dominating $\Gamma$ and intersect with +sufficiently many relatively ample hyperplanes. Nonnegativity of the +old summand on this curve implies nonnegativity on $\Gamma$, hence on +the curve on $X_{i+1}$. This argument uses a positive-degree lift, not +a degree-one section. Finally $m_j\gamma_{ij}\cdot C$ is a +nonnegative integer, giving the stated lower bound. +\end{proof} + +\begin{corollary}[Uniform crepancy parameter; no termination assertion] +\label{prog:uniform-canonical-parameter} +Suppose additionally that the working spaces are $d$-dimensional klt +spaces, that $\alpha_i$ are nef, and that the ordinary canonical +negative-ray length bound $0<-K_{X_i}\cdot C\leq2d$ is available. +For a fixed real number $t>2d/\delta$, every negative extremal ray +chosen in an existing $(K_{X_i}+t\alpha_i)$-program is +$\alpha_i$-trivial. If the steps are projective ordinary canonical +steps, Lemma~\ref{prog:fixed-integral-grid} therefore applies +inductively with this same value of $t$. + +If $\alpha_0$ is not big and $\alpha_0-c_1(K_{X_0})$ is big, then +$K_{X_i}+t\alpha_i$ remains non-pseudo-effective along these crepant +steps. Consequently a terminating such program ends with a Mori +fibre contraction. This corollary does not assert that the requisite +contractions exist or that the program terminates. +\end{corollary} + +\begin{proof} +A negative ray is $K_{X_i}$-negative because $\alpha_i$ is nef. Choose +its rational curve generator with the ordinary length bound. If its +$\alpha_i$-degree were positive, then +\[ + (K_{X_i}+t\alpha_i)\cdot C\geq-2d+t\delta>0, +\] +a contradiction. The step is thus an ordinary canonical step with +$\alpha_i$ pulled back from its base, and the preceding lemma applies. +On a common resolution the pullback of +$\alpha_{i+1}-c_1(K_{X_{i+1}})$ is the pullback of +$\alpha_i-c_1(K_{X_i})$ plus the effective canonical comparison. +Thus it stays big. Equality of the crepant pullbacks of $\alpha_i$ +preserves its nonbigness. The +identity +\[ + (t+1)\alpha_i=(c_1(K_{X_i})+t\alpha_i) + +(\alpha_i-c_1(K_{X_i})) +\] +excludes pseudo-effectivity of its first summand. A nef endpoint is +therefore impossible. +\end{proof} + + +\begin{lemma}[Cohomology splitting along detected steps] +\label{prog:detected-cohomology} +Let $X_0$ be a smooth compact K\"ahler manifold. Consider a finite +sequence of divisorial contractions and small flips +\[ + X_0\dashrightarrow X_1\dashrightarrow\cdots + \dashrightarrow X_r +\] +between normal globally strongly $\mathbb Q$-factorial compact +K\"ahler spaces with rational singularities. +Assume that every negative contraction $f_i:X_i\to Z_i$ is a +projective contraction of one ray of the analytic cone, that $Z_i$ +has rational singularities, and that each small flip is the detected +flip of a global rational line $L_i$ with $L_i\cdot R_i<0$. +For a divisorial contraction assume the usual single exceptional +prime. Then, for every projective smooth resolution $p:U\to X_i$, +\begin{align*} + H^2(U,\mathbb R) + &=p^*H^2(X_i,\mathbb R) + \oplus\bigoplus_{E\text{ exceptional for }p}\mathbb R[E],\\ + H^{1,1}(U,\mathbb R) + &=p^*H^{1,1}_{\rm BC}(X_i,\mathbb R) + \oplus\bigoplus_{E\text{ exceptional for }p}\mathbb R[E]. +\end{align*} +The first equality also holds over $\mathbb Q$. There are compatible +forward linear transforms on $H^2(-,\mathbb R)$ and on Bott--Chern +cohomology. They are surjective, are isomorphisms for a small flip, +and preserve rational degree-two classes. On a common resolution the +pullback difference is an actual exceptional divisor class; for a +flip it is exceptional over both spaces. + +The exceptional quotient also takes the Chern class of a holomorphic +line bundle on $U$ to a rational holomorphic line class on $X_i$. +\end{lemma} + +\begin{proof} +For a modification of a smooth compact K\"ahler manifold the two +splittings are the degree-two modification formula. Suppose that they +hold for $X=X_i$. We use only the following birational descent fact: +for a proper bimeromorphic map between normal compact spaces in +Fujiki's class with rational singularities, pullback is injective on +$H^2(-,\mathbb R)$ and on Bott--Chern cohomology, and its image in +either group consists of the classes having degree zero on every +contracted curve. This is the bimeromorphic case of +\cite[Lemma~2.6(1)]{DH2024}. + +First note that a degree-two class $\xi\in H^2(X,\mathbb R)$ has +the same degrees on curves as a Bott--Chern class. Indeed, pull it to +a smooth projective resolution $a:W\to X$ and take the $(1,1)$-part +of its Hodge decomposition. The induction hypothesis writes that +part as $a^*\beta+[F]$, with $F$ exceptional over $X$. On every +$a$-contracted curve, $a^*\xi$ and its $(2,0)$ and $(0,2)$ parts +have degree zero. Hence $F$ has degree zero on every such curve. +Exceptional negativity applied to both signs gives $F=0$. +Projective multisections lifting a curve of $X$ then show that +$\xi$ and $\beta$ have the same degrees on every curve of $X$. + +Suppose first that $X\dashrightarrow X^+$ is a small detected flip. +Write $f:X\to Z$ and $f^+:X^+\to Z$, and fix an integral curve +$C$ on its negative ray. For $\xi\in H^2(X,\mathbb R)$ set +\[ + s=\frac{\xi\cdot C}{c_1(L)\cdot C}. +\] +By the preceding paragraph, $\xi-s c_1(L)$ vanishes on every +$f$-contracted curve. Thus it is $f^*\eta$ for a unique +$\eta\in H^2(Z,\mathbb R)$. Define +\[ + T\xi=(f^+)^*\eta+s c_1(L^+). +\] +For a Bott--Chern class, the same descent takes place in +Bott--Chern cohomology, so the two transforms agree. The detected +flip construction gives an effective rational divisor $E_L$ on a +common projective resolution $a:W\to X$, $b:W\to X^+$ such that +\[ + a^*c_1(L)-b^*c_1(L^+)=[E_L]. +\] +Consequently +\[ + a^*\xi=b^*T\xi+s[E_L]. +\] +If $\xi$ is rational, then $s$ is rational. Since the image of +$f^*$ on real degree-two cohomology is the realification of a +rational subspace, its unique preimage $\eta$ is rational as well. +This proves rationality of $T\xi$. + +The sets of prime divisors exceptional for $a$ and $b$ are identical: +the two working spaces are small bimeromorphic. The old splitting +and the displayed pullback identity therefore span +\[ + H^2(W,\mathbb R) + =b^*H^2(X^+,\mathbb R) + +\operatorname{span}_{\mathbb R}\{[E]:E\text{ is }b + \text{-exceptional}\}, +\] +and similarly in bidegree $(1,1)$. The sum is direct. If a pullback +from $X^+$ equals an exceptional divisor class, that divisor has +degree zero on all $b$-contracted curves, so both signs of negativity +make it zero; pullback injectivity then makes the original class +zero. In particular the dimensions on the two sides agree, $T$ is +injective by the old direct sum, and $T$ is surjective. The rational +version follows either from the same argument or from realification. + +For a divisorial contraction $f:X\to X^+$, let $D$ be its +exceptional prime. Its degree on the contracted ray is negative: +otherwise $D$ would be $f$-nef, contrary to exceptional negativity. +For any $\xi$, subtract +\[ + \frac{\xi\cdot C}{D\cdot C}[D] +\] +and descend the result by the same birational cohomology lemma. +This defines $T\xi$. On a common resolution its pullback difference +is a multiple of the total transform of $D$. The target's exceptional +prime set is the old one together with the strict transform of $D$. +The same spanning and directness argument gives the target splitting +and surjectivity; its kernel is $\mathbb R[D]$. Rationality is again +immediate from the quotient of rational intersection numbers. + +These arguments initially prove the splitting on a chosen common +resolution. To obtain it on any projective smooth resolution +$U\to X^+$, dominate that resolution and the chosen one by a smooth +common projective resolution. Apply the smooth degree-two +modification formula upstairs and push down to $U$. An exceptional +divisor pushes either to zero or to a divisor exceptional over $X^+$. +This proves spanning on $U$; negativity gives directness there. + +Finally let $\mathcal H$ be a holomorphic line on $U$ and put +$\mathcal Q=(p_*\mathcal H)^{**}$. Global strong +$\mathbb Q$-factoriality gives an $m>0$ for which +$\mathcal M=\mathcal Q^{[m]}$ is invertible. The coherent evaluation +comparison gives +\[ + \mathcal H^{\otimes m} + \simeq p^*\mathcal M\otimes\mathcal O_U(F) +\] +for an integral $p$-exceptional divisor $F$. This comparison is +obtained from the coherent direct image and evaluation map; it does +not assume that $\mathcal H$ has a global meromorphic section. +Dividing first Chern classes by $m$ proves the line assertion. +\end{proof} + + +\begin{corollary}[Stability under projective extraction] +\label{prog:extraction-cohomology} +Let $r:Y\to X$ be a projective bimeromorphic morphism of normal compact +K\"ahler spaces with rational singularities. Suppose that $Y$ is globally +strongly $\mathbb Q$-factorial and that $X$ has the splitting property in +the preceding lemma. Then $Y$ has that property as well. More precisely, +if $E_1,\ldots,E_s$ are the prime divisors exceptional for $r$, then +\[ + H^2(Y,\mathbb R) + =r^*H^2(X,\mathbb R)\oplus + \bigoplus_{j=1}^{s}\mathbb R[E_j], +\] +and the analogous statements hold over $\mathbb Q$ and in +Bott--Chern cohomology. +\end{corollary} + +\begin{proof} +Choose any projective smooth resolution $q:W\to Y$. The composite +$p=rq$ is a projective resolution of $X$. Its exceptional primes are +exactly the $q$-exceptional primes together with the strict transforms +$\widetilde E_j$ of the $E_j$. Since every $E_j$ is $\mathbb Q$-Cartier, +\[ + [\widetilde E_j]=q^*[E_j]+[F_j] +\] +for a rational $q$-exceptional divisor $F_j$. Substitute these identities +in the splitting for $p$. The result spans $H^2(W,\mathbb R)$ by +$q^*H^2(Y,\mathbb R)$ and the $q$-exceptional divisor classes. Their sum +is direct: an exceptional divisor whose class is a pullback has degree +zero on every $q$-contracted curve, and applying exceptional negativity +to both signs makes the divisor zero. Pullback injectivity then applies. +The same argument in bidegree $(1,1)$ and over $\mathbb Q$ proves the +splitting property for $Y$. + +Now expand $q^*\xi$, for $\xi\in H^2(Y,\mathbb R)$, using the original +$p$-splitting and replace the $[\widetilde E_j]$ as above. The difference +between $q^*\xi$ and a class in +$q^*(r^*H^2(X,\mathbb R)+\sum_j\mathbb R[E_j])$ is $q$-exceptional, +and is therefore zero by the direct sum just proved. Thus the displayed +formula for $H^2(Y,\mathbb R)$ spans. Its directness follows from +exceptional negativity for $r$ and pullback injectivity. The rational +and Bott--Chern statements follow by the identical argument. The line +bundle assertion of the preceding lemma uses only global strong +$\mathbb Q$-factoriality and hence applies to $Y$ as well. +\end{proof} + + + +\paragraph{Support in the special-termination comparison.} +\label{prog:special-support} +The following support comparison applies to the detected steps in +the dimension induction. Let $\psi:X\dashrightarrow X^+$ be a detected +small negative step with maps $f:X\to Z$ and $f^+:X^+\to Z$, +and let $L$ be its negative detector. For a sufficiently +divisible $r>0$, put +\[ + \operatorname{im}(f^*f_*L^r\longrightarrow L^r) + =\mathcal I\otimes L^r. +\] +The zero set of $\mathcal I$ is exactly the exceptional locus of $f$. +Outside that locus $f$ is an isomorphism, so the evaluation map is +surjective. On a positive-dimensional projective fibre, every section +of $L^r$ vanishes: its restriction to each integral curve has negative +degree, and those curves cover every positive-dimensional fibre +component. Connectedness supplies the whole nontrivial fibre. + +On a resolution principalizing $\mathcal I$, the detector comparison +is a positive multiple of the effective divisor defined by +$\mathcal I\mathcal O_W$. Consequently its support is the full +inverse image of the exceptional locus. The driving adjoint differs +from a positive real multiple of $c_1(L)$ by a class pulled back from +the contraction base. Its comparison divisor is therefore the same +positive multiple of the detector comparison: their class difference +is exceptional and zero, so both-sign negativity makes it zero as a +divisor. The comparison for a longer +negative program is at least this first-step divisor, by discrepancy +monotonicity on a common resolution. + +Suppose the beginning and end restrictions to a surviving normalized +lc stratum $S$ are isomorphic and their strict adjunction data agree. +The general point of this stratum avoids every intervening surgery: +a zero-discrepancy place remains such a place, whereas strict +comparison would increase its discrepancy if its center were contained +in the exceptional locus. Thus its strict transform $S_W$ on a common +resolution is not contained in the comparison support. Iterated strict +adjunction identifies the restriction of the effective comparison with +the difference of the identified adjoints, so its class is zero. +A nonzero effective divisor on a positive-dimensional compact K\"ahler +stratum has positive K\"ahler mass. The restricted divisor is therefore +zero. If the first step meeting the stratum were nontrivial there, +the full inverse-image support and surjectivity $S_W\to S$ would make +this restriction nonzero, a contradiction. For a zero-dimensional +stratum, generic-point avoidance already excludes an intersection. +The whole program is consequently an isomorphism near the stratum. +This is the same strict-adjunction support argument used in the proof +of Theorem~\ref{prog:special-termination}; it does not use its +lower-dimensional abundance assumption. + +\begin{proposition}[A uniform relative NQC bound] +\label{prog:relative-nqc-grid} +Let $f_0:U\to Z$ be an already projective surjective morphism with +connected fibres between smooth compact +K\"ahler manifolds, and suppose that +\[ + f_0^*:H^0(Z,\Omega_Z^2)\longrightarrow H^0(U,\Omega_U^2) +\] +is an isomorphism. Let $\alpha_0$ be a nef class with an expression +\[ + \alpha_0=\sum_{j=1}^k r_j\eta_{j,0},\qquad + r_j>0,\quad \eta_{j,0}\in H^2(U,\mathbb Q), +\] +where $\eta_{j,0}$ has nonnegative degree on every curve vertical +over $Z$. Let $D_0=K_U+\Delta_U+\mathbf M_U$ be a generalized klt +adjoint. Consider its projective relative program for +$D_0+a\alpha_0$, under the projective local ordinary reduction described in the +proof of Lemma~\ref{prog:base-point-free-induction}. + +If $\alpha_0=0$, triviality is immediate. Otherwise there are +positive integers $m_j$, chosen once on $U$, and a number +\[ + \delta=\min_j\frac{r_j}{m_j}>0 +\] +such that, for $a\delta>2\dim U$, the entire relative program is +$\alpha_0$-trivial. The same number $a$ works at every step. +\end{proposition} + +\begin{proof} +\emph{Rational classes modulo the fixed base.} +Choose an $f_0$-ample line bundle with integral Chern class $H$, and +put $e=\dim U-\dim Z$ and $c=f_{0*}(H^e)>0$. The rational operator +\[ + \Pi(\eta)=\eta- + f_0^*\!\left(\frac{f_{0*}(\eta\smile H^e)}{c}\right) +\] +preserves type $(1,1)$ and kills types $(2,0)$ and $(0,2)$. +Indeed these latter classes are pulled back from $Z$, and the +projection formula applies. Thus +$\Pi(H^2(U,\mathbb Q))\subset H^{1,1}(U)\cap H^2(U,\mathbb Q)$. +By the Lefschetz $(1,1)$ theorem, choose an actual line bundle +$L_{j,0}$ and an integer $m_j>0$ with +\[ + \eta_{j,0}=\frac1{m_j}c_1(L_{j,0})+f_0^*\gamma_j, + \qquad \gamma_j\in H^2(Z,\mathbb Q). +\] +The original summands $\eta_{j,0}$ need not have type $(1,1)$. +Their base components account for this. Their weighted sum gives +\begin{equation}\label{prog:eq:relative-nqc} + \alpha_0=\sum_j\frac{r_j}{m_j}c_1(L_{j,0})+f_0^*\Gamma, + \qquad \Gamma=\sum_jr_j\gamma_j\in H^{1,1}(Z,\mathbb R). +\end{equation} +The final assertion follows because $f_0^*$ is an injective Hodge +map and the other terms have type $(1,1)$. The identity is therefore +also one of Bott--Chern classes. +Each $L_{j,0}$ has nonnegative integral degree on every +$Z$-vertical curve. + +\smallskip\noindent +\emph{Induction across an actual contraction.} +Suppose at a finite stage $f_i:U_i\to Z$ we have actual line bundles +$L_{j,i}$, nef over $Z$, and +\[ + \alpha_i=\sum_j\frac{r_j}{m_j}c_1(L_{j,i})+f_i^*\Gamma. +\] +Assume also that $\alpha_i$ is nef and that the transformed +$D_i$ is generalized klt. These assertions hold initially. +Let $R$ be a $(D_i+a\alpha_i)$-negative extremal ray over $Z$. +It is $D_i$-negative because $\alpha_i$ is nef. Lemma~\ref{prog:relative-hodge} and Lemma~\ref{prog:projective-cone} +identify the relative curve cone with the corresponding face of the +full analytic cone, at the initial model and after every step. The +analytic cone theorem therefore supplies a rational generator $C$ with +\[ + 0<-D_i\cdot C\leq2\dim U. +\] +All $L_{j,i}\cdot C$ are nonnegative integers. If +$\alpha_i\cdot C>0$, one of them is at least one, and hence +$\alpha_i\cdot C\geq\delta$. Therefore +\[ + (D_i+a\alpha_i)\cdot C + \geq-2\dim U+a\delta>0, +\] +a contradiction. We have $\alpha_i\cdot C=0$ and +$L_{j,i}\cdot C=0$ for every $j$. Every curve contracted by the +projective extremal contraction $h_i:U_i\to Y_i$ has class on +$R$ when tested by global line bundles, so the same vanishing +holds for all of them. + +On each fixed Stein chart of $Z$, choose the effective real +ordinary representative of the initial relatively ample nef +datum once, before running the program. Its actual real linear +equivalence to the fixed real line-bundle representative persists +under pushforward. The Bott--Chern comparison with the generalized +adjoint modulo the fixed base class persists separately by +exceptional negativity, as detailed below. +Thus every $h_i$ is, locally on $Y_i$, a contraction with an +ordinary real klt log-Fano boundary. On a relatively compact base +chart, rational approximation in the finite affine system of Cartier +adjoint identities gives a rational effective klt boundary with the +same antiample sign, as in Proposition~\ref{prog:detected-flip}. +Lemma~\ref{prog:integral-descent} therefore applies. +Consequently +\[ + M_{j,i}:=(h_i)_*L_{j,i}\ \text{is a line bundle},\qquad + h_i^*M_{j,i}=L_{j,i}. +\] +For a divisorial contraction set $L_{j,i+1}=M_{j,i}$. +For a flip $h_i^+:U_{i+1}\to Y_i$, set +$L_{j,i+1}=(h_i^+)^*M_{j,i}$. +These are actual line bundles with the \emph{same} integers $m_j$. +The descended Bott--Chern class +\[ + \alpha_{Y_i} + =\sum_j\frac{r_j}{m_j}c_1(M_{j,i})+f_{Y_i}^*\Gamma +\] +satisfies $h_i^*\alpha_{Y_i}=\alpha_i$. +It is nef by descent of nefness through the projective surjection +$h_i$; its pullback to the next model is $\alpha_{i+1}$. +This proves that the step is crepant for $\alpha_i$. Hence it is +also a $D_i$-negative step, and the original generalized pair +remains gklt. + +Finally each $M_{j,i}$ is nef over $Z$. For a $Z$-vertical curve +$B\subset Y_i$, projectivity supplies a curve $B'\subset U_i$ +mapping onto it with some positive degree $d_B$. Then +\[ + d_B(M_{j,i}\cdot B)=L_{j,i}\cdot B'\geq0. +\] +No assertion $d_B=1$ is required. Pullback preserves this relative +nefness, so the induction applies on $U_{i+1}$. Its curve degrees +are again integers because the transported objects are line +bundles, not because any curves were lifted with degree one. +This proves the fixed bound through the whole program. +\end{proof} + +\begin{remark}[Scope of the degree grid] +The transported rational classes +\[ + \eta_{j,i}=\frac1{m_j}c_1(L_{j,i})+f_i^*\gamma_j +\] +have degrees in $m_j^{-1}\mathbb Z_{\geq0}$ on curves vertical over +the fixed smooth base $Z$. This relative assertion is exactly what +the initial projective program requires. It does not assert +nonnegativity of these individual classes on all curves of every +birational model, and uses neither rational connectedness of +resolution fibres nor Graber--Harris--Starr. +\end{remark} + +\subsubsection{The negative-part comparison for a nef adjoint} +We write $N_\sigma(\xi)$ for the divisorial negative part of a +pseudo-effective class. We use its homogeneity, subadditivity, +continuity after adding a vanishing K\"ahler perturbation, and the +identities +\[ + N_\sigma(r^*\xi+[E])=N_\sigma(r^*\xi)+E, + \qquad r_*N_\sigma(r^*\xi)=N_\sigma(\xi) +\] +for an effective $r$-exceptional divisor $E$. A nef class has zero +negative part. These are the divisorial Zariski-decomposition +properties of \cite[Section~3]{Boucksom2004} and +\cite[Appendix~A]{DHY}. No identity +$N_\sigma(r^*\xi)=r^*N_\sigma(\xi)$ for arbitrary $\xi$ is assumed. + +\begin{lemma}[The absolute negative part after a relative program] +\label{prog:negative-part-program} +Let $\mu:U\to X$ be a projective resolution, let $\alpha$ be nef on $X$, +let $c>0$, and let $F_U\geq0$ be $\mu$-exceptional. Put +\[ + D_U=c\mu^*\alpha+[F_U]. +\] +Suppose that $\phi:U\dasharrow V$ is a finite $D_U$-negative program, +possibly relative to another base, and denote its transformed class and +divisor by $D_V$ and $F_V=\phi_*F_U$. Then +\[ + N_\sigma(D_V)=F_V. +\] +\end{lemma} + +\begin{proof} +Take a common projective resolution $p:W\to U$, $q:W\to V$. +The negativity comparison for the finite program is +\[ + p^*D_U=q^*D_V+[E], + \qquad E\geq0,\quad E\text{ is }q\text{-exceptional}. +\] +This comparison is valid for a relative negative program: its proof +uses the negativity of the contracted rays and the positive adjoint on +each flipped side, not absolute nefness of the final adjoint. +Since $p^*F_U$ is effective and exceptional over $X$, the exceptional +identity and nefness of $(\mu p)^*\alpha$ give +\[ + N_\sigma(p^*D_U)=p^*F_U + =N_\sigma(q^*D_V)+E. +\] +Pushing forward by $q$ proves the assertion. In particular, the +negative part in this statement is absolute, even when the program +that produced $V$ was relative. +\end{proof} + +\subsubsection{Descent of the effective vertical divisor} + +\begin{lemma}[Vertical numerical triviality] +\label{prog:vertical-divisor} +Let $g:V\to S$ be a projective surjective morphism with connected fibres. +Assume that $S$ is globally Weil $\mathbb{Q}$-factorial. Let $F\geq0$ be +an effective real Cartier divisor on $V$, vertical over $S$, such that +\[ + F\cdot C=0 + \quad\text{for every curve }C\text{ contracted by }g. +\] +Then there is an effective real Cartier divisor $F_S$ on $S$ such that, +as actual divisors, +\[ + F=g^*F_S. +\] +\end{lemma} + +\begin{proof} +For a prime divisor $P\subset S$, write $m_Q$ for the multiplicity of +$Q$ in $g^*P$, where $Q$ ranges over the prime divisors dominating $P$. +These multiplicities may be computed over the smooth generic locus of +$P$, where $P$ is Cartier. Put +\[ + b_P=\min_{g(Q)=P}\frac{\operatorname{coeff}_Q F}{m_Q}, + \qquad F_S=\sum_P b_PP. +\] +Only finitely many $b_P$ are nonzero, since any such $P$ is the image of +a component of $F$. Thus $F_S$ is a genuine effective Weil real divisor. +Global Weil $\mathbb{Q}$-factoriality makes this finite divisor real +Cartier. + +We first check equality over codimension one in $S$. Work near a +general point of $P$ and restrict to a transverse disk. Resolving the +source, and cutting by general relative ample hypersurfaces if the +relative dimension exceeds one, reduces to a projective surface over +that disk with connected fibres. These operations can be performed +over a relatively compact Stein neighbourhood; they do not require +global sections on $S$. The intersection matrix of the components of +the special fibre is negative semidefinite, with kernel generated by +the full fibre with its multiplicities. The restriction of $F$ has +zero intersection with every fibre component. Its coefficients are +therefore proportional to those multiplicities. Equivalently, all the +ratios in the definition of $b_P$ are equal. When $g$ is birational this +assertion over the generic point of $P$ is immediate. + +Consequently +\[ + G=F-g^*F_S +\] +is a signed real Cartier divisor supported over a subset of codimension +at least two in $S$. Moreover, $G$ is numerically trivial over $S$. +We check that such a signed exceptional divisor is zero. The assertion +is local on $S$. Over a relatively compact Stein neighbourhood, take +$d=\dim V-\dim S$ general relative ample hypersurfaces and resolve their +intersection. They give a projective generically finite morphism +$H\to S$. The cuts may be chosen to meet any prescribed component of +$G$ in a nonzero divisorial trace. After normalization and Stein +factorization, $H\to S$ factors as a projective birational morphism +$H\to S'$ followed by a finite morphism $S'\to S$. The restricted +divisor $G|_H$ is exceptional for $H\to S'$ and numerically trivial +over $S'$. Applying the ordinary exceptional negativity lemma to both +$G|_H$ and $-G|_H$ gives $G|_H=0$. The choice of the cuts therefore +excludes every nonzero component of $G$. Hence $G=0$. + +The surface argument above is also the usual proof of the +degenerate-divisor negativity statement: after subtracting the minimum +multiple of the full fibre, an effective residual fibre divisor omits +a component and cannot be numerically trivial. Notice that projectivity +of $g$ was a hypothesis; it was not deduced from factoriality. +\end{proof} + +\subsubsection{The negative part on the lower-dimensional base} + +\begin{lemma}[Detecting the negative part by pullback currents] +\label{prog:negative-part-base} +Let $g:V\to S$ be a surjective morphism. Suppose that $\alpha_S$ is nef, +$F_S\geq0$ is real Cartier, $c>0$, and +\[ + D_S=c\alpha_S+[F_S],\qquad D_V=g^*D_S,\qquad + N_\sigma(D_V)=g^*F_S. +\] +Then $N_\sigma(D_S)=F_S$. +\end{lemma} + +\begin{proof} +Nefness gives $N_\sigma(D_S)\leq F_S$. Fix a prime divisor $P\subset S$ +and a prime divisor $Q\subset V$ dominating it. Write +$m=\operatorname{mult}_Q(g^*P)>0$ and $b=\operatorname{coeff}_P F_S$. +At their generic smooth points, pullback of positive currents satisfies +\[ + \nu(g^*T,Q)=m\nu(T,P). +\] +Indeed, the divisorial term $\nu(T,P)[P]$ pulls back with multiplicity +$m$, and the residual current has zero generic Lelong number there. + +Choose K\"ahler forms $\omega_S,\omega_V$ and a constant $C>0$ for which +$C\omega_V-g^*\omega_S$ is K\"ahler. For $\varepsilon>0$, let $T_\varepsilon$ +be any positive current in the big class $D_S+\varepsilon[\omega_S]$. +Minimality of the multiplicity and monotonicity under adding a nef +class give +\begin{align*} + m\nu(T_\varepsilon,P) + &=\nu(g^*T_\varepsilon,Q)\\ + &\geq\nu(D_V+\varepsilon g^*[\omega_S],Q)\\ + &\geq\nu(D_V+C\varepsilon[\omega_V],Q). +\end{align*} +Taking the infimum over $T_\varepsilon$, and then letting +$\varepsilon\downarrow0$, gives +\[ + m\nu(D_S,P)\geq\nu(D_V,Q) + =\operatorname{coeff}_Q(g^*F_S)=mb. +\] +This proves the reverse inequality for every $P$. +All multiplicities are unchanged by resolving away from the generic +points in question, so the same argument applies to the normal spaces +under consideration. + +The $\varepsilon$ perturbation is necessary: at a pseudoeffective +boundary class, the infimum over its exact positive currents need not +equal its minimal multiplicity. The argument uses that equality only +for the big perturbed classes. +\end{proof} + +\begin{lemma}[Pullback when the positive part is nef] +\label{prog:negative-part-pullback} +Suppose +\[ + \xi=P+[F],\qquad P\text{ nef},\quad F\geq0\text{ real Cartier}, + \qquad N_\sigma(\xi)=F. +\] +For every projective resolution $p:W\to S$, +\[ + N_\sigma(p^*\xi)=p^*F. +\] +\end{lemma} + +\begin{proof} +Write $N'=N_\sigma(p^*\xi)$. Since $p^*P$ is nef, $N'\leq p^*F$. +Birational invariance gives $p_*N'=F$, so +$E=p^*F-N'\geq0$ is $p$-exceptional. The positive part of $p^*\xi$ is +\[ + p^*P+[E], +\] +and is modified nef. If $E\neq0$, exceptional negativity in its +covering-curve form provides a component of $E$ covered by curves $C_t$ +contracted by $p$, with $E\cdot C_t<0$ +\cite[Appendix~A, Lemma~A.3]{DHY}. A modified nef class has nonnegative +intersection with a general member of a family of curves covering a +prime divisor: use currents with arbitrarily small negative part and +zero generic divisorial Lelong number, restrict to a general member, +and let the negative bound tend to zero. But here +\[ + (p^*P+E)\cdot C_t=E\cdot C_t<0, +\] +a contradiction. Thus $E=0$. +\end{proof} + +\begin{proposition}[Any lower-dimensional good model suffices] +\label{prog:nef-good-comparison} +Suppose the initial relative program has the data in +Lemma~\ref{prog:negative-part-program}. Assume in addition that +its class $\alpha_V$ is nef and agrees with $\mu^*\alpha$ on a common +resolution, and that there is an already projective connected-fibre +morphism $g:V\to S$ with +\[ +\alpha_V=g^*\alpha_S,\qquad D_V=g^*D_S. +\] +Suppose there is a projective small modification +$s:S^{\mathrm q}\to S$ such that $S^{\mathrm q}$ is globally Weil +$\mathbb Q$-factorial; the identity is allowed. Assume that the +lower-dimensional adjoint $s^*D_S$ has a good model: +there are a normal compact K\"ahler space $S_m$, a common projective +resolution $p:W\to S^{\mathrm q}$, $q:W\to S_m$, and a nef semiample +class $D_m$ such that +\[ + p^*s^*D_S=q^*D_m+[E], + \qquad E\geq0,\quad E\text{ is }q\text{-exceptional}. +\] +Then $\alpha$ is semiample on $X$. If the contraction defining +semiampleness of $D_m$ is Moishezon, the resulting contraction of +$\alpha$ is Moishezon as well. In particular, it is unnecessary to +lift a program on $S$ to $V$, or to require that a chosen program +producing $S_m$ preserve $\alpha_S$ at every intermediate step. +\end{proposition} + +\begin{proof} +Nefness descends under the surjective morphism $g$, so $\alpha_S$ is nef. +The class of $F_V$ is pulled back from $S$, so $F_V$ is numerically +trivial over $S$. It is therefore vertical: an effective horizontal +component would restrict to a nonzero effective divisor on a general +projective fibre, with positive intersection against a suitable power +of an ample class, contradicting numerical triviality. For a +birational $g$, verticality is automatic by dimension. +First take a projective resolution $\pi:\widetilde V\to V$ of the main +component of $V\times_S S^{\mathrm q}$. The induced map +$\widetilde g:\widetilde V\to S^{\mathrm q}$ is projective and has +connected fibres. Pull back $\alpha_V,D_V,F_V$ along $\pi$, and pull +back $\alpha_S,D_S$ along $s$. All displayed class identities are +preserved, and $\pi^*F_V$ remains an effective vertical divisor. +Lemma~\ref{prog:negative-part-program} gives +$N_\sigma(D_V)=F_V$ before this modification. Because +$D_V=c\alpha_V+[F_V]$ with $\alpha_V$ nef, +Lemma~\ref{prog:negative-part-pullback} then gives +\[ + N_\sigma(\pi^*D_V)=\pi^*F_V. +\] +We may therefore replace $(V,S,g)$ by +$(\widetilde V,S^{\mathrm q},\widetilde g)$ and suppress the new +superscripts in the rest of the proof. The good-model comparison now +reads $p^*D_S=q^*D_m+[E]$. No assertion that the crepant subboundary on +$\widetilde V$ is effective is needed: this space is used only for +classes, currents and the effective divisor $\pi^*F_V$. The +lower-dimensional generalized pair is the crepant pullback to the +small model $S^{\mathrm q}$. + +The class identity $[F_V]=g^*(D_S-c\alpha_S)$ shows that $F_V$ is +numerically trivial over $S$. Lemma~\ref{prog:vertical-divisor} +gives an actual effective real Cartier divisor $F_S$ with +$F_V=g^*F_S$. Injectivity of pullback yields +\[ + D_S=c\alpha_S+[F_S]. +\] +The established identity $N_\sigma(D_V)=F_V$ and +Lemma~\ref{prog:negative-part-base} therefore give +$N_\sigma(D_S)=F_S$, and +Lemma~\ref{prog:negative-part-pullback} gives +\[ + N_\sigma(p^*D_S)=p^*F_S. +\] +On the other hand $q^*D_m$ is nef, so the exceptional-divisor identity +applied to the good-model comparison gives +\[ + N_\sigma(p^*D_S)=E. +\] +Thus $E=p^*F_S$ as actual divisors. Subtracting them from the comparison +proves the exact class equality +\[ + q^*D_m=c\,p^*\alpha_S. +\] +This proves the needed preservation of $\alpha_S$ from the final good +model, without an assumption about its intermediate models. + +Choose a contraction $h:S_m\to T$ to a normal compact K\"ahler space +and a K\"ahler class $\kappa$ on $T$ with $D_m=h^*\kappa$. Taking a +resolution of the main component of $V\times_S W$, and then a common +projective resolution with $U$, produces a projective modification +$r:R\to X$ and a holomorphic map $\ell:R\to T$ satisfying +\[ + r^*\alpha=\frac1c\ell^*\kappa. +\] +For every curve $C$ in a fibre of $r$ this equality implies +$\ell(C)$ is a point, since a K\"ahler class has positive degree on +every nonconstant image curve. The fibres of the projective modification +$r$ are connected projective complex spaces, hence are connected by +chains of curves. Therefore $\ell$ is +constant on each fibre of $r$. The factorization theorem for a proper +map onto a normal space gives a holomorphic map $f:X\to T$ with +$\ell=f\circ r$. Pushing forward the class equality by $r$ gives +\[ + \alpha=f^*(\kappa/c). +\] +The maps from the main fibre-product component to $S_m$ have connected +general fibres; their Stein factorizations are finite birational over +the normal space $S_m$, hence have connected fibres everywhere. +Together with the connected fibres of $h$, this shows that $\ell$, +and therefore $f$, has connected fibres. This is the required +semiampleness of $\alpha$. + +Finally, $R\to S_m$ is projective: it is obtained from the projective +map $g$ by base change, followed by projective resolutions and the +projective map $q$. If $h$ is Moishezon, choose a projective surjection +$H\to S_m$ such that $H\to T$ is projective. A component of +$R\times_{S_m}H$ dominating $R$ is projective and surjective over $X$, +and its map to $T$ is projective. This is a Moishezon witness for $f$. +\end{proof} + + +\begin{lemma}[The contraction step in the dimension induction] +\label{prog:base-point-free-induction} +Assume $\mathsf C_{d-1}$, $\mathsf B_{d-1}$ and $\mathsf M_{d-1}$. +Then $\mathsf C_{d,\mathrm{big}}$ and $\mathsf B_d$ hold. +\end{lemma} +\begin{proof} +\smallskip\noindent +\emph{The big non-klt contraction.} +Apply the construction of \cite[Section~3]{HX}. On its smooth +modification $\nu:U\to X$ it writes +\[ + \nu^*\alpha=[D_U]+\eta_U, + \qquad D_U\geq0,\quad \eta_U\text{ K\"ahler}. +\] +The induction over the jumping coefficients of the multiplier +ideal reduces the new reduced stratum to dimension at most $d-1$. +The given contraction on the old non-klt subspace and +$\mathsf C_{d-1}$ provide the Moishezon maps of those strata. +Every map that is promoted to a projective map in that construction +contracts exactly the curves on which $\nu^*\alpha$ vanishes. +On each such curve the actual real line bundle $-D_U$ has degree +$\eta_U\cdot C$. On a further projective common resolution +$q:U''\to U$, choose an effective exceptional divisor $E$ with +$-E$ relatively ample and choose $\varepsilon>0$ sufficiently small. +Use the decomposition +\[ + q^*\nu^*\alpha=[D'']+\eta'',\qquad + D''=q^*D_U+\varepsilon E,\qquad + \eta''=q^*\eta_U-\varepsilon[E]. +\] +Here $\eta''$ is K\"ahler, and the actual real line bundle $-D''$ +has degree $\eta''\cdot C$ on every contracted curve. Restrict this +decomposition to the smooth reduced components in the gluing +construction. Lemma~\ref{prog:actual-line-polarization} then supplies +precisely the relative ampleness needed in place of +\cite[Lemma~2.42]{HX}, including the common-resolution step in its +Claim~3.5. The exceptional term $-\varepsilon[E]$ makes the +positive part $\eta''$ K\"ahler on the common resolution. + +The exact sequences of multiplier ideals, relative vanishing, +finite pushouts, and extension from sufficiently thickened +$\operatorname{Supp}D_U$ in that proof then apply unchanged. +They give the birational Moishezon contraction in +$\mathsf C_{d,\mathrm{big}}$. In particular the gluing step uses +neither generalized termination nor a projectivity criterion for +an undetected ray. + +\smallskip\noindent +\emph{Preparation for both cases of $\mathsf B_d$.} +The modified-big perturbation +\cite[Lemma~2.23]{HX} supplies a nef datum that dominates a +K\"ahler class on its carrier. Subtracting a sufficiently small +multiple of the pullback of a K\"ahler class $\omega_X$ still leaves +a nef datum on that carrier. Thus +$\alpha$ is a gklt adjoint plus $\varepsilon\omega_X$, and the cone +argument of \cite[Lemma~2.45]{HX} makes $\alpha$ NQC. +This preparation applies whether or not $\alpha$ is big. + +\smallskip\noindent +\emph{The nef-and-big case of $\mathsf B_d$.} +For a gklt pair the multiplier ideal is the unit ideal, so the +preceding big non-klt assertion now applies and gives a birational +contraction $h:X\to Y$. +On a projective resolution $p:W\to X$ chosen projective over $Y$, +relative Kawamata--Viehweg vanishing for the effective exceptional +divisor $-\lfloor B_W\rfloor$ gives +$R^ih_*\mathcal O_X=0$ for $i>0$. Thus $Y$ has rational +singularities. Proper birational Bott--Chern descent +\cite[Lemma~8.7]{DHP} gives $\alpha=h^*\gamma$. +The descended adjoint is gklt, nef and big, and has no trivial +curve. The criterion \cite[Theorem~4.3]{HLX} makes $\gamma$ +K\"ahler. + +For completeness, the projectivity input in that criterion is +restricted to a map $S\to Z'$ between smooth compact K\"ahler +manifolds with rationally connected general fibre: $S$ is the +chosen smooth divisor on a resolution and $Z'$ is the resolution +of the null-locus component. The smooth-source, smooth-base +argument in \cite[Theorem~3.1, Step~1]{CH} applies. Its subsequent +relative program starts with this projective map. Thus this application of the criterion uses only the +smooth-source, smooth-base projectivity argument and an +already-projective relative program. + +\smallskip\noindent +\emph{The non-big case of $\mathsf B_d$.} +Use a projective small factorialization and the modified-big +perturbation of the pair. The non-pseudo-effectivity of $K_X$ +gives an MRC fibration by \cite{Ou2025}. Choose a smooth K\"ahler +MRC base $Z$ and a smooth modification $\mu:U\to X$ such that +$U\to Z$ is projective. Only the smooth case of +\cite[Theorem~3.1, Step~1]{CH} is needed: pullback identifies +the holomorphic two-forms since the general fibre is rationally +connected. Lemma~\ref{prog:relative-hodge} identifies any $(1,1)$-class on $U$, +modulo a class pulled back from $Z$, with an actual real line bundle. +Lemma~\ref{prog:projective-cone} identifies its relative rays +with rays of the analytic cone; both statements persist along the +projective relative construction. + +Write, as in \cite[Theorem~4.1, Claim~4.1]{HX}, +\[ + D_U(a)=K_U+\Delta_U+\mathbf M_U+a\alpha_U + =(a+1)\alpha_U+F_U, + \quad \alpha_U=\mu^*\alpha,\quad + \Delta_U,F_U\geq0, +\] +where $\Delta_U$ is klt and $F_U$ is $\mu$-exceptional. +The modified-big replacement is chosen, as in the cited Claim~4.1, +so that the nef datum $\mathbf M_U$ on this smooth carrier is +K\"ahler. If a further projective resolution is needed, subtract a +sufficiently small effective exceptional divisor from its nef part +and add that divisor to the subboundary; this preserves the +adjoint and the klt inequalities. +Choose $a_0$ using the uniform bound of +Proposition~\ref{prog:relative-nqc-grid}. It makes the relative +$D_U(a_0)$-program $\alpha_U$-trivial and preserves that choice +through every step. This is a +\emph{projective} relative program from its first step: the nef +data are represented by real line bundles modulo $Z$. +Lemma~\ref{prog:relative-hodge} applies on every +intermediate model over this fixed smooth base. +More precisely, put $r:U\to Z$ and choose one actual global real +line bundle $L$ with +\[ + \mathbf M_U+a_0\alpha_U=c_1(L)+r^*\gamma. +\] +The bundle $L$ is relatively ample, because $\mathbf M_U$ is +K\"ahler and $\alpha_U$ is nef. On each of a fixed finite collection +of relatively compact Stein charts of $Z$, choose an effective +real divisor $\Theta$ representing $L$, with $(U,\Delta_U+\Theta)$ +klt. The representatives can retain a positive relatively ample +part in their boundaries. Here the equality +$K_U+\Delta_U+\Theta\sim_{\R}K_U+\Delta_U+L$ is an actual +real linear equivalence of line bundles; the equality with +$D_U(a_0)$ modulo $r^*\gamma$ is separately an equality of +Bott--Chern classes. + +Fix these ordinary pairs on the initial charts. Their actual +linear equivalences and their Bott--Chern comparisons with $D_U(a_0)$ +modulo the fixed base class persist separately throughout a global +relative program. Proposition~\ref{prog:projective-good-model} applies: +the source is smooth, its adjoint is represented by an actual global +real line modulo $Z$, its carrier nef part is relatively ample, and +$D_U(a_0)=(a_0+1)\mu^*\alpha+[F_U]$ is pseudo-effective. +It gives a finite program $U\dasharrow V$ and a good relative endpoint. +This is one global program controlled by fixed ordinary chart pairs. +Its construction uses global line algebras, not a choice of unrelated +local minimal models. Proposition~\ref{prog:relative-nqc-grid} makes +every step $\alpha_U$-trivial with the same value $a_0$. + +Here is an explicit ample-model comparison that gives the required +descent of $\alpha_V$. Both $D_V(a_0)$ and $\alpha_V$ are nef over +$Z$. Put $a_1=a_0+1$ and $a_2=a_0+2$. Before the program starts, +choose fixed ordinary representatives on the finite chart cover for +all three relatively ample nef parts $\mathbf M_U+a_j\alpha_U$, +$j=0,1,2$, on one simultaneous log resolution. The +$\alpha_U$-crepancy of the constructed program makes its endpoint +$V$ a weak model for each of these three fixed ordinary adjoints. +Their traces $D_V(a_j)=D_V(a_0)+(a_j-a_0)\alpha_V$ are nef. +Corollary~\ref{prog:projective-semiample} therefore makes +\[ + D_V(a_j)=D_V(a_0)+(a_j-a_0)\alpha_V +\] +semiample over $Z$. Their zero curves are exactly the common zero +curves of $D_V(a_0)$ and $\alpha_V$. Their projective ample-model +contractions therefore have the same fibres: these fibres are +connected by curves, and each contraction is constant on the +fibres of the other. Identify the two normal targets, writing the +common contraction as $g:V\to S$. If +$D_V(a_j)=g^*\lambda_j$, with $\lambda_j$ relatively K\"ahler over +$Z$, subtraction gives +\[ + \alpha_V=g^*(\lambda_2-\lambda_1)=g^*\alpha_S. +\] +This is an equality of Bott--Chern classes, not merely of curve +degrees. Since the initial program is $\alpha_U$-trivial, it is +also $D_U(a_1)$-negative. From now on put $a=a_1$ and suppress +the argument in $D_U(a)$ and $D_V(a)$. + +The maps $V\to Z$ and $S\to Z$ are projective. Moreover $g$ is +projective: a relatively ample bundle for $V\to Z$ restricts to +an ample bundle on every fibre of $g$, and hence is $g$-ample. +Each $D_U(a_j)$ is not big globally: pushing a big such class to +$X$ would make $(a_j+1)\alpha$ big. If it were big over the smooth +MRC base $Z$, relative-canonical positivity +\cite[Theorem~2.48]{HX}, together with the pseudo-effectivity of +$K_Z$, would make it big globally. It is therefore not big over +$Z$. This property persists to its relative semiample model, so +its relative canonical morphism has $\dim S0$, +with the map to $S$ retained throughout. +\end{lemma} + +\begin{proof} +After the smooth preparation in \cite[Proposition~5.12]{HX}, write the +adjoint as +\[ + A=D+\omega,\qquad D\geq0,\quad \omega\text{ K\"ahler}, + \qquad \operatorname{Supp}D=N_+(A). +\] +Here $N_+(A)$ denotes the reduced divisor with support +$\bigcap_{0<\epsilon\ll1}\operatorname{Supp}N_\sigma(A-\epsilon\omega)$; +this support is constant for sufficiently small positive $\epsilon$ +and is independent of the chosen Kähler class $\omega$ +\cite[Lemma~5.3]{HX}. At a nonterminal scaling step, +\[ + A_i\cdot R_i<0,\qquad + (A_i+t_i\omega_i)\cdot R_i=0,\qquad t_i>0. +\] +Consequently $\omega_i\cdot R_i>0$ and $D_i\cdot R_i<0$. +A component of the actual effective divisor $D_i$ supplies a global +rational Cartier detector. The supporting contraction follows from +$\mathsf B_d$, and its projectivity and flip follow from +Proposition~\ref{prog:detected-flip}. This argument does not require +$\omega_i$ to remain nef. + +To apply $\mathsf B_d$ to a gdlt presentation, lower its finitely many +floor coefficients on the initial smooth carrier and add the same small +class to the K\"ahler nef datum. The adjoint does not change, and the +resulting gklt presentation persists through the same negative steps. +The original gdlt presentation is retained for adjunction to the floor. +Thus the special-termination proof of \cite[Lemma~5.8]{HX} applies with +$\mathsf F_{d-1}$ on its smooth lower-dimensional carrier. Its other +inputs are adjunction, discrepancy monotonicity, and the local +Cartier-index calculation. The last neighbourhood-isomorphism step +uses the evaluation-ideal support argument in +the \hyperref[prog:special-support]{support comparison above}: the comparison of +the first detected flip has support equal to the full inverse image +of its exceptional locus, and later comparisons dominate it. +One does not infer disjointness of images merely from a vanishing +restriction of an arbitrary exceptional divisor. The theta induction of +\cite[Proposition~5.11]{HX} now gives a weak model. Applying +$\mathsf B_d$ to its nef adjoint makes it good, and +Lemma~\ref{prog:weak-to-terminal} gives the log terminal model. +All its steps are detected or belong to the already-projective +relative extraction in that lemma. + +For completeness, the negative-part identity needed in this argument +is only +\[ + N(p^*\xi+E)=N(p^*\xi)+E\quad(E\geq0\text{ $p$-exceptional}), +\] +not the stronger formula $N(p^*\xi)=p^*N(\xi)$ for an arbitrary +pseudo-effective class. The comparison with a nef endpoint identifies +its exceptional error with the negative part. The formula for +$N_+$ follows by writing a K\"ahler form upstairs as +$p^*\omega-F$, with $F$ positive on every exceptional prime, and applying +the displayed identity to +$p^*(\xi-\epsilon\omega)+E+\epsilon F$. Pushforward identifies the +nonexceptional coefficients; $\epsilon F$ supplies all exceptional +primes. These are exactly the uses in the theta argument. + +Now put $P=f^*\omega_S$ and suppose $A+cP$ is big for some $c$. +Fix $\delta>0$ smaller than the $\omega_S$-degree of every compact +integral curve on $S$ and enlarge $c$ so $c>4d/\delta$. +Use the following direct preparation, which keeps the original +unshifted globally nef datum. On a smooth projective carrier +$\nu:W\to X$ write +\[ + \nu^*(A+cP)=[G]+\omega,\qquad G\geq0,\quad\omega\text{ K\"ahler}, + \qquad [K_W+B_W]+M_W=\nu^*A, +\] +with the non-K\"ahler support property used in the big-class +preparation. Here $\operatorname{Ex}(\nu)$ below denotes the reduced +divisor formed by all $\nu$-exceptional primes. Write +$B_W=B_W^+-B_W^-$. For small $\epsilon>0$ put +\[ + \begin{split} + B'&=B_W^++\epsilon B_W^-+ + \epsilon(G+\operatorname{Ex}(\nu)),\\ + M'_W&=M_W+c\nu^*P+\epsilon\omega,\\ + b&=B_W^++\frac{\epsilon}{1+\epsilon}\operatorname{Ex}(\nu). + \end{split} +\] +The new boundary is klt and $M'_W$ is K\"ahler. Direct addition gives +\[ + A'=[K_W+B']+M'_W + =(1+\epsilon)\bigl([K_W+b]+M_W+c\nu^*P\bigr). +\] +Moreover $B'\geq b$. In every theta branch the cumulative added +boundary satisfies $0\leq C\leq1-B'$, so +\[ + b+\frac{C}{1+\epsilon} + \leq b+\frac{1-b}{1+\epsilon}<1. +\] +Thus the unshifted presentation +$[K_W+b+C/(1+\epsilon)]+M_W$ is genuinely gklt with the +\emph{original} globally nef datum. This is the presentation used +for the horizontal length bound. No base form is subtracted from +an arbitrary newly prepared nef datum. + +A horizontal negative ray would have $P$-degree at least $\delta$; +the bound $0<-A_{\rm unshifted}\cdot C\leq4d$ would contradict +$c\delta>4d$. Every constructed step is therefore over $S$. +Its projective connected fibres are contracted by $f$, so $f$ factors +through its base and through the flip. The final finite extraction is +also over $S$. + +The shifted nef endpoint is semiample by $\mathsf B_d$. Its zero face +contains no horizontal curve: decompose such a curve by the unshifted +adjoint's cone theorem; nefness of the shifted class forces all +summands into the zero face, and a summand of positive $P$-degree again +contradicts the length bound. The shifted class is big, so the +connected semiampleness map is bimeromorphic. Its connected fibres are Moishezon and are connected +by chains of compact curves. The preceding zero-face argument makes +the map to $S$ constant on each such curve, hence on every fibre. +The analytic factorization lemma therefore factors the map to $S$ +through the semiampleness map. Subtracting $c\omega_S$ from the +normalized class on its target gives the required relative K\"ahler class for the unshifted adjoint. The effective +resolution error from the preparation is removed by the usual +negativity comparison, giving a model of the original data. + +The forward traces and exceptional splittings persist by +Lemma~\ref{prog:detected-cohomology}. In the last extraction, +the newly extracted prime classes move from the old exceptional span +into the pullback span; they are actual rational Cartier classes. +Both-sign negativity proves directness as before. +\end{proof} + +\begin{lemma}[Changing the base of a relatively trivial adjoint] +\label{prog:graph-good-model} +Suppose $g:X\to Y$ is projective, its general fibre is rationally +connected, and a gklt adjoint satisfies $A_X=g^*A_Y$. Assume the +prepared nef datum is K\"ahler on a smooth carrier. Let +$Y\dashrightarrow Y_m$ be the chosen nonextracting good model +supplied by $\mathsf M_{d-1}$ over $S$, with its exceptional +cohomology splitting, and let $\dim Y2d/\delta$, where every +integral curve on $S$ has $\omega_S$-degree greater than +$\delta>0$. Set +\[ + A_c=A_0+cP=D+N,\qquad D=K_U+B_U,\quad N=M_U+cP. +\] +Since $A_c$ is not big globally, relative-canonical positivity +\cite[Theorem~2.48(2)]{HX}, together with pseudo-effectivity of $K_Z$, +shows that $A_c$ is not big over $Z$, whether or not it is globally +pseudo-effective. The class $N$ is big over $Z$. Consequently $D$ +cannot be pseudo-effective over $Z$: otherwise $D+N=A_c$ would be +big over $Z$. The smooth projective RC Hodge projection represents +every class modulo $Z$ by an actual real line. The ordinary global klt adjoint $D$ is therefore relatively +non-pseudo-effective. The projective ordinary Mori construction of +Corollary~\ref{prog:projective-mori}, with scaling of the actual +relatively ample real line represented by $N$, terminates in a Mori +fibre space. Lemma~\ref{prog:relative-hodge} and +Lemma~\ref{prog:projective-cone} identify every relative ray +with a full analytic ray. Its nef b-data retain the fixed globally +nef carrier $U$. + +First suppose $A_c$ is not pseudo-effective globally. The retained +relative-canonical positivity theorem on $h$, together with +pseudo-effectivity of $K_Z$, then says that $A_c$ is not +pseudo-effective over $Z$. The terminating relative program ends +in a Mori contraction at a threshold $\tau>1$. At every step its +scaled zero ray has $A_c$-degree negative. Inductively the map to +$S$ is retained: if such a ray were horizontal, its $P$-degree +would exceed $\delta$, while the gklt cone theorem for $A_0$ gives +a rational generator of $-A_0$-degree at most $2d$, contradicting +$A_c\cdot R\leq0$. Once $P\cdot R=0$, the step is negative or +crepant for $A_0$, so its gklt presentation persists. The same +argument applies to the final Mori ray. This would be an +$A_c$-negative Mori contraction over $S$, contradicting the +preserved pseudo-effectivity over $S$. Hence $A_c$ is +pseudo-effective globally. + +It is not big globally. Relative-canonical positivity now implies +that it is not big over $Z$. Its pseudo-effective threshold for +$D+tN$ over $Z$ is exactly one: for $t>1$ the class is big, while +pseudo-effectivity for $t<1$ would make $A_c$ big because $N$ is +big over $Z$. The same finite relative program therefore ends in +a Mori contraction $g:U'\to Y$ at threshold one. +All birational steps, including any steps at threshold one, and +the final zero ray are over $S$ by the preceding length argument +with $A_c\cdot R\leq0$. For a zero ray with positive $P$-degree, +$A_0$ would again have degree less than $-c\delta$. +Thus $Y$ carries a map to $S$ and $\dim Y0$ below the +$\omega_c$-degree of every compact integral curve in $X_c$. Fix $\bar\lambda<\delta/(\delta+2d)$ and for +$0<\lambda\leq\bar\lambda$ put +\[ + A_{\lambda,i}=(1-\lambda)H_i+\lambda A_{u,i}. +\] +The same cone estimate shows more than nefness: for a sufficiently +small $\epsilon>0$, uniform on the finite list and the chosen radial +interval, $A_{\lambda,i}-\epsilon H_i$ is nef. Indeed on a +horizontal $A_{u,i}$-negative rational ray its degree is greater than +$(1-\lambda-\epsilon)\delta-2d\lambda>0$; on the nonnegative +part of the cone and on the vertical cone it is nonnegative. +It follows for every class $\xi\in\overline{\mathrm{NA}}(Y_i)$ that +\[ + A_{\lambda,i}\cdot\xi=0 + \quad\Longleftrightarrow\quad + H_i\cdot\xi=A_{u,i}\cdot\xi=0. +\] +In particular its null curves are exactly those contracted by +$\psi_i$. The central data are crepant through these maps over $X_c$; +thus the convex data defining $A_{\lambda,i}$ remain gklt with +globally modified-big boundary. Apply $\mathsf B_d$ to $A_{\lambda,i}$. Its connected +semiampleness map and $\psi_i$ both have Moishezon fibres, and each +connected such fibre is connected by chains of compact curves. +Equality of their contracted curves makes each map constant on the +fibres of the other. The analytic factorization lemma identifies +the two maps. Thus the selected relative canonical model is also +the canonical model over $S$ on this radial interval. +This proves local polyhedrality and the finite local list; compactness +gives the global finite list of canonical models and chosen terminal +models. + +\paragraph{Uniform preparation preserving every weak model.} +\label{prog:uniform-preparation} +Write $A_u=[K_X+B_u+\mathbf M_{u,X}]$ for the adjoints in the +parameter polytope. We first record why a weak model of these gklt data +extracts no divisor. On a common resolution $p:U\to X$, $q:U\to Y$ +put $D=p^*A_u-q^*A_{u,Y}$, using the actual structure-boundary +comparison. The weak-model discrepancy inequalities give $p_*D\geq0$, +and $-D$ is $p$-nef because $A_{u,Y}$ is nef over the fixed base. +Negativity therefore gives $D\geq0$. An extracted prime on $Y$ has +coefficient one in the weak-model boundary, whereas its coefficient in +the structure boundary of the gklt source is less than one; it would +give a negative coefficient of $D$. Hence there is no such prime. +Consequently $D$ is $q$-exceptional and the target is itself gklt. + +Fix a parameter $u_0$. The boundary plus nef part is globally +modified big by hypothesis. The modified-big preparation +\cite[Lemma~2.23]{HX} gives, on a fixed projective smooth carrier +$a:W\to X$, an effective klt boundary $\Gamma$, a K\"ahler class +$\gamma_0$, and an effective $a$-exceptional real divisor $F$ such that +\begin{equation}\label{prog:eq:uniform-preparation} + [K_W+\Gamma]+\gamma_0=a^*A_{u_0}+[F]. +\end{equation} +Here is the effectivity detail in this use of the preparation. Its new +nef datum dominates a K\"ahler form on a carrier. After resolving the +new structure boundary, choose an effective exceptional divisor whose +negative is relatively ample and subtract a sufficiently small multiple +from the pulled-back datum to make it K\"ahler. Add the same multiple +to the structure boundary, +then replace its negative coefficients by zero and, if needed, add +small positive coefficients on the remaining exceptional primes. +All coefficients stay below one. Only exceptional coefficients have +been increased; their increase is the divisor $F\geq0$ in +\eqref{prog:eq:uniform-preparation}. + +On a sufficiently small closed polyhedral neighbourhood of $u_0$ put +\[ + \gamma_u=\gamma_0+a^*(A_u-A_{u_0}). +\] +These classes remain K\"ahler by openness, and the same $\Gamma$ and +the same $F$ satisfy +\[ + [K_W+\Gamma]+\gamma_u=a^*A_u+[F]. +\] +Thus this is one affine family of gklt pairs on one smooth carrier, +with a fixed effective boundary and K\"ahler nef data. + +Let $\psi:X\dashrightarrow Y$ be \emph{any} weak model at a parameter +$u$ in this neighbourhood, and resolve the induced map $W\dashrightarrow +Y$ by $r:T\to W$, $q:T\to Y$. Its original comparison is +\[ + (ar)^*A_u=q^*A_{u,Y}+E_u, + \qquad E_u\geq0\text{ is }q\text{-exceptional}. +\] +Since $\psi$ is nonextracting, every $a$-exceptional prime is exceptional +over $Y$. Hence $r^*F$ is also $q$-exceptional, and +\begin{equation}\label{prog:eq:prepared-weak} + r^*\bigl([K_W+\Gamma]+\gamma_u\bigr) + =q^*A_{u,Y}+E_u+r^*F. +\end{equation} +This proves that $W\dashrightarrow Y$ is a weak model of the prepared +pair. In detail, subtract the effective exceptional error on the right +from its structure boundary on $T$ and push down to $Y$. The resulting +boundary is precisely the transform of $\Gamma$, it is effective, the +adjoint is the already existing Bott--Chern class $A_{u,Y}$, and all +discrepancies are at least those of the prepared gklt pair. This uses generalized data at the level of currents. On $T$ keep +the nef datum $r^*\gamma_u$, and subtract the displayed effective +$q$-exceptional error from the prepared structure boundary. Pushing +forward by $q$ gives the boundary $\Gamma_Y$ and the trace of this +fixed nef b-class. Their sum with the canonical current represents +the already existing locally exact adjoint $A_{u,Y}$; the resolution +identity defines its structure boundary. The generalized discrepancies +have not decreased. This argument neither requires $K_Y+\Gamma_Y$ to +be real Cartier nor asserts that the nef trace is separately a +Bott--Chern class. It therefore applies to every K\"ahler weak target, +including the adjunction strata used in special termination. + +\paragraph{Every weak model occurs in the finite canonical list.} +Choose a small box in $H^{1,1}(W,\mathbb R)$ which spans that vector +space and whose addition to the compact family $\{\gamma_u\}$ stays +inside the K\"ahler cone. For any $Y$ above choose a K\"ahler class +$\eta_Y$ and define $\eta_W=r_*q^*\eta_Y$. Smooth-source cohomology +puts $\eta_W$ in $H^{1,1}(W,\mathbb R)$ and gives an actual +$r$-exceptional real divisor $D_\eta$ with +\[ + r^*\eta_W-q^*\eta_Y=[D_\eta]. +\] +Its negative is $r$-nef, so $D_\eta\geq0$ by exceptional negativity. +As $W\dashrightarrow Y$ extracts no divisors, $D_\eta$ is also +$q$-exceptional. Scale $\eta_Y$ by a sufficiently small positive number +so that $\eta_W$ lies in the fixed box. Adding this identity to +\eqref{prog:eq:prepared-weak} yields an effective +$q$-exceptional comparison with target class $A_{u,Y}+\eta_Y$, which +is K\"ahler over the original base. Thus $W\dashrightarrow Y$ is the +canonical model of a member of this one enlarged prepared polytope. +Its canonical-model list is finite by the first part of the geography +proof. The induced list of maps from $X$ is therefore finite as well. +A finite cover of the original compact parameter polytope completes +the proof for all weak models. + +\end{proof} + + +\begin{theorem}[The restricted package in every dimension] +\label{prog:restricted-package} +The assertions $\mathsf B_d$, $\mathsf C_d$, $\mathsf M_d$ and +$\mathsf F_d$ hold in every finite dimension, for the globally nef +carrier data and globally modified-big boundary traces specified above. +All birational steps used to prove them are detected steps or belong +to an already-projective relative construction with the stated +relative-line algebraicity. A general semiample morphism is asserted +to be Moishezon; projectivity is asserted only when the construction +provides an actual relatively ample line. +\end{theorem} +\begin{proof} +The assertions in dimensions zero and one follow from degrees and +factorization of maps of compact curves. Suppose the package holds +in dimensions less than $d$. Lemma~\ref{prog:base-point-free-induction} +first proves $\mathsf C_{d,\mathrm{big}}$ and then $\mathsf B_d$. +The former uses $\mathsf C_{d-1}$; the nonbig part of the latter +uses only a chosen $\mathsf M_{d-1}$ model and the explicit +negative-part comparison. In particular, no lower program is lifted. + +With $\mathsf B_d$ available, Proposition~\ref{prog:ordinary-step} +constructs detected negative steps in dimension $d$. +Lemma~\ref{prog:big-good-model}, using the already known +$\mathsf F_{d-1}$, gives the big-shift case of $\mathsf M_d$. +Lemma~\ref{prog:relative-model} gives its remaining case, using +$\mathsf M_{d-1}$ and the projective graph construction. This proves +$\mathsf M_d$ over every proper compact K\"ahler base, with its +chosen-model invariant. Lemma~\ref{prog:finite-geography}, whose +hypotheses are \emph{both} $\mathsf B_d$ and $\mathsf M_d$, now +proves $\mathsf F_d$. + +It remains to prove $\mathsf C_d$ when its nef NQC adjoint $\alpha$ +is not big. First use +Lemma~\ref{prog:base-presentation-preparation}, preserving the +adjoint $\alpha$ and making the nef datum K\"ahler on a smooth +carrier. Its multiplier-ideal inclusion allows the given contraction +to restrict to the prepared non-klt closed subspace by +Lemma~\ref{prog:base-emc}. Next take the projective dlt preparation +in \cite[Section~6]{HX}, keeping its crepant structure data. The +working space is klt and globally strongly $\mathbb Q$-factorial. +The retained crepant structure boundary need not be lc; it is +effective, including the extracted primes of coefficient at least one. On a common carrier the nef datum is +nef and big. Consequently the total boundary trace is modified big, +and $\alpha-c_1(K_X)$ is a big Bott--Chern class. The contraction on +the non-klt closed subspace transports through this preparation by +Lemma~\ref{prog:multiplier-transport}. Choose an NQC expression with +positive coefficients and integral multiples of its rational +degree-two summands. Corollary~\ref{prog:uniform-canonical-parameter} +provides a single number $t$ such that each negative ray of +$K_X+t\alpha$ is $\alpha$-trivial. Choose a K\"ahler scaling class +$\omega$ with $K_X+t\alpha+\omega$ nef. Every selected negative +ray is ordinary $K_X$-negative; the actual rational canonical line +is its detector. Proposition~\ref{prog:ordinary-step} supplies its +projective contraction or flip, and the fixed integral grid persists. +The descended $\alpha$ remains nef by projective descent of nefness. + +The driving class is non-pseudo-effective throughout, by the +corollary. Its initial pseudo-effective scaling threshold is positive; +choose a cutoff $\varepsilon>0$ below that threshold. On the fixed +initial carrier the compact segment of globally nef data +\[ + t\alpha+[\varepsilon,1]\omega +\] +has modified-big total boundary. At its scaling parameter each working +model is a marked weak model of a member of this segment. Each selected +step is negative for the fixed driving adjoint, so its discrepancies +do not decrease and increase at a valuation affected by that step. +An infinite sequence would repeat a marked model by $\mathsf F_d$; +the cumulative nonzero effective comparison for the fixed adjoint +would then contradict equality of that marking. Hence this program +terminates. Non-pseudo-effectivity excludes a nef endpoint, leaving +an $\alpha$-trivial ordinary Mori contraction $f:X'\to Z$. + +The structure data of the prepared contraction problem remain +crepant throughout this $\alpha$-trivial program. Their effective +traces and globally nef and big carrier datum therefore persist. +Lemma~\ref{prog:multiplier-transport} transports the contraction on +the non-klt closed subspace through each birational step. +Lemma~\ref{prog:bc-descent} gives +\[ + \alpha_{X'}=f^*\gamma +\] +in Bott--Chern cohomology. The class $\gamma$ is nef by projective +descent; Lemma~\ref{prog:integral-h2} descends the fixed rational +NQC summands, and projective multisections preserve their +nonnegative degrees. + +Apply Corollary~\ref{prog:base-emc-induction} to this projective +Mori contraction. In its notation the prepared non-klt subspace +$N_1$ has Stein space $V(f_*J_1)$ over $Z$. If $N_1$ dominates +$Z$, this Stein space is $Z$ itself and its inherited contraction +already supplies the contraction of $\gamma$. Otherwise the base +presentation has multiplier ideal $J_Z\supset f_*J_1$, so the +contraction restricts to $V(J_Z)$ as a closed subspace of +$V(f_*J_1)$. Since $\dim Z0$, is finite. If the driving adjoint is not +pseudo-effective, the scaling terminates with a Mori fibre space. +\end{corollary} +\begin{proof} +Proposition~\ref{prog:ordinary-step} constructs each step and +Lemma~\ref{prog:detected-cohomology} supplies the forward traces from +the fixed carrier. Each reached model at a scaling parameter is a +marked weak model of that parameter's adjoint. The compact parameter +segment satisfies $\mathsf F_d$, so there are finitely many such +markings. Strict increase for the fixed driving adjoint rules out +repetition. If that adjoint is not pseudo-effective, the positive +pseudo-effective scaling threshold gives a fixed positive cutoff +containing every parameter of a continuing program. The finite +program cannot end nef, hence ends with the claimed Mori map. +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/04-boundary.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/04-boundary.tex new file mode 100644 index 0000000000000000000000000000000000000000..0a3a68955c7ea25b5dc62fe3db2001bf48505dcb --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/04-boundary.tex @@ -0,0 +1,1424 @@ +\section{Generation along the dlt boundary}\label{sec:boundary} + +We prove that the restrictions of a nef adjoint to the separate log +canonical strata fit together to generate its restriction to the whole +reduced boundary. Semiampleness on the normal components does not by itself +supply compatible sections on their union. The proof has three +parts. A Mori contraction reduces the obstruction to restriction from a +stratum to one comparison of residues. Crepant transport respects all +lower residues. Finally a finiteness argument permits us to impose every +comparison simultaneously by taking products of sections. + +Throughout this section, \(n\geq1\) and \(\Ggood_j\) is assumed for every +\(j0\), contrary to the preceding inequalities. +The strict transform is finite birational over the smooth marked curve, +and hence isomorphic to it. Adjunction to that smooth strict transform +thus has nonnegative coefficient. This is the original coefficient by the +surface-slice residue calculation. + +The full-weight pair is dlt and has the asserted floor. On an SNC model, +at the general point of the center of a divisorial valuation \(v\), take +normal parameters \(x_1,\ldots,x_a\), giving an unmarked parameter boundary +weight zero. The SNC discrepancy inequality is +\[ + a(v;\widehat Z,\widehat B_{\widehat Z}) + \geq \sum_{i=1}^a(1-b_i)v(x_i). +\] +Every \(v(x_i)>0\). Thus a zero-discrepancy center is an intersection +of unit components. Those intersections meet the isomorphism locus, +while every exceptional component has coefficient below one. To produce +a dlt resolution for the restricted map, principalize its nonisomorphism +locus and resolve together with the ordered SNC boundary. That locus +contains no entire log canonical center, so the displayed discrepancy +inequality makes every new exceptional coefficient strictly below one. +This is the dlt resolution criterion. It also identifies the unit primes +downstairs with the next incident strata. + +Finally let \(R_{\rm all}\) be the whole unit union on \(\widehat Z\). Sections +on its smooth components which agree on all their SNC intersections glue +by the elementary equalizer for the coordinate ideals of an SNC union. +Even iterated residues make the equalities independent of the chosen chain. +Apply the floor-connectedness lemma to the full-weight pair and this full +unit union. It gives +\((p_Z)_*\mathcal O_{R_{\rm all}}=\mathcal O_{C_Z}\). +Projection formula therefore descends the glued section uniquely to the +restricted invertible line on the reduced \(C_Z\). The proof with \(Z=V\) +gives the assertion for \(S\). +\end{proof} + +Each boundary stratum has dimension less than \(n\). The class of +\(J_Z:=K_Z+B_Z\) is nef, since it is the restriction of the nef adjoint +class. Proposition~\ref{bir:resolution-transfer}, applied using +\(\Ggood_{\dim Z}\) on a log resolution, makes the actual rational line +\(J_Z\) semiample. Increase \(q\) once +for all so that +\(L_Z:=\mathcal O_Z(qJ_Z)=\mathcal O_V(qJ)|_Z\) is generated for every +boundary stratum. Its map and Stein factorization give +\begin{equation}\label{floor:semiample-map} + f_Z:Z\longrightarrow Y_Z,\qquad L_Z=f_Z^*N_Z, +\end{equation} +where \(Y_Z\) is normal projective, \(f_Z\) has connected fibers, and +\(N_Z\) is ample. These are actual line identities. We call \(C_Z\) +\emph{vertical} if \(f_Z(C_Z)\ne Y_Z\); the empty floor is vertical. +If \(C_Z\) dominates \(Y_Z\), then for every \(k\geq1\) the restriction +\[ + H^0(Z,L_Z^k)\longrightarrow H^0(C_Z,L_Z^k|_{C_Z}) +\] +is injective. Indeed, every section comes from \(Y_Z\); if its pullback +vanishes on \(C_Z\), surjectivity makes it vanish at every point of \(Y_Z\). + +Fix a K\"ahler class \(c\) on \(V\), and let \(c_Z\) be its restriction +to each stratum. For boundary strata \(Z,Z'\) of the same dimension, an +\emph{arrow} is a proper bimeromorphic comparison with a projective +resolution whose source is smooth and compact K\"ahler, +\[ + \begin{tikzcd}[column sep=large] + & T\arrow[dl,"p"']\arrow[dr,"p'"]&\\ + Z&&Z' + \end{tikzcd} +\] +such that the two pulled-back adjoint lines are equal as invertible +subsheaves of meromorphic \(q\)-pluricanonical forms on \(T\), and +\begin{equation}\label{floor:class-comparison} + p^*c_Z-(p')^*c_{Z'}\in\NS(T)_{\R}. +\end{equation} +Here \(\NS(T)_{\R}\) is the real span of first Chern classes of +holomorphic lines, with torsion removed. The degree-two formula for a +smooth modification says that its new classes are exceptional divisor +classes. It follows that Equation~\eqref{floor:class-comparison} is independent +of further resolution and is preserved by composition. These arrows +therefore form a groupoid on the finite set of strata of each dimension. +An arrow \(\gamma:Z\dashrightarrow Z'\) transports sections by +\[ + (p')^*(\gamma_*s)=p^*s. +\] +Normality gives existence and uniqueness. Transport commutes with +multiplication and identifies the complete systems and their Stein targets +in Equation~\eqref{floor:semiample-map}. +The equality of meromorphic lines defines this transport of adjoint sections; the class +congruence will control self-arrows when the floor is vertical. + +\subsection{One residue comparison suffices for restriction} + +The only obstruction to extending a section from \(C_Z\) is its possible +variation among the connected components of a general floor fiber. We show +that all these components meet one general Mori fiber, whose floor is +connected or consists of two points. Thus at most one residue comparison +is needed. + +\begin{lemma}[Restriction and a Mori link]\label{floor:restriction} +For each positive-dimensional boundary stratum \(Z\), there is either no +comparison or one arrow between two components of \(C_Z\), allowing a +component to be compared with itself, with the following property. In all +sufficiently large divisible degrees \(k\), a section of \(L_Z^k|_{C_Z}\) +extends to \(Z\) if its two residues agree under that arrow. With no +arrow, every such section extends. The degree bound is uniform over +sections. When present, the arrow compares the two coefficient-one points +on general \(\PP^1\) fibers of a projective Mori contraction on a +bimeromorphic compact K\"ahler model of \(Z\). +\end{lemma} + +\begin{proof} +We use the dimension-free torsion-free restriction lemma +\cite[Lemma~7.1]{BL}. In its notation, for an effective compact K\"ahler +lc pair \((T,G)\), klt away from its reduced floor \(C\), and a connected +map \(f:T\to P\) to a normal compact base from which an actual positive +adjoint multiple is pulled back, it asserts that +\(R^1f_*\mathcal O_T(-C)\) is torsion-free. The ideal sequence gives +\begin{equation}\label{floor:restriction-obstruction} + \mathscr Q:=\coker(\mathcal O_P\longrightarrow f_*\mathcal O_C) + \lhook\joinrel\longrightarrow R^1f_*\mathcal O_T(-C). +\end{equation} +For \(T=Z\) and \(P=Y_Z\), if \(C_Z\) is vertical, \(\mathscr Q\) has +proper support and is zero. Serre vanishing for the kernel of +\(\mathcal O_P\to f_*\mathcal O_C\), tensored with \(N_Z^k\), extends +every restriction in a uniform large-degree tail. If \(C_Z\) dominates, +the same display says that a section extends as soon as its values are +constant on the reduced floor fiber over a dense open of \(Y_Z\): its +class in the torsion-free \(\mathscr Q\otimes N_Z^k\) then vanishes, and +the local lifts glue. They are unique because \(C_Z\) dominates \(Y_Z\), +so \(\mathcal O_{Y_Z}\to(f_Z)_*\mathcal O_{C_Z}\) is injective. +This uses neither reduced special scheme +fibers nor base change at their points. + +Suppose now that \(C_Z\) dominates \(Y_Z\). There is an effective rational +Cartier divisor \(D\) with \(\Supp D=\Supp C_Z\): restrict to \(Z\) the +globally \(\Q\)-Cartier floor primes of \(V\) not containing \(Z\). +For small rational +\(\epsilon>0\), \((Z,B_Z-\epsilon D)\) is effective klt. Apply +Corollary~\ref{prog:small-model} to obtain a projective small strong +\(\Q\)-factorialization \(\rho:Z_0\to Z\), crepant also for the full pair. +Write \(\Delta_0\) for its full boundary and \(D_0=\rho^*D\). +The full adjoint +\[ + P=K_{Z_0}+\Delta_0 +\] +is the actual semiample rational line pulled back from \(Y_Z\), and the +lowered klt adjoint is \(J_{\rm low}=P-\epsilon D_0\). Put +\(d=\dim Z\), choose \(m>0\) with \(mP\) Cartier and generated, and take +\(b>4md\). Consider +\[ + H=J_{\rm low}+bP=(1+b)P-\epsilon D_0. +\] +On a general fiber of the map to \(Y_Z\), its class is +\(-\epsilon\{D_0\}\). This is the negative of a nonzero effective +divisor because the floor dominates \(Y_Z\), so its pairing with a +K\"ahler power is negative. If \(H\) were pseudo-effective, a positive +current representing it would restrict to a positive current on almost +every resolved smooth fiber, contradicting this pairing. Thus \(H\) +is not pseudo-effective. + +Apply Lemma~\ref{prog:nef-trivial} to the lowered klt pair and the nef +rational line \(P\). Its \(H\)-program with K\"ahler scaling has ordinary +\(J_{\rm low}\)-negative steps, is finite, and ends in a projective Mori +contraction. Every step, including the final Mori ray, is \(P\)-trivial. +The same actual Cartier line \(mP\) descends at each birational step. +Consequently its semiample map to the fixed base \(Y_Z\) persists on +every working model. That map is constant on each connected final Mori +fiber and hence factors through the Mori contraction. We obtain +\[ + T\xrightarrow{u}W\xrightarrow{g}Y_Z. +\] +Both maps have connected fibers. The full adjoint on each model is the +trace of \(P\). On a common resolution of a birational step, its natural +meromorphic canonical comparison is an exceptional divisor with zero +class, since the two actual lines descend from the same line on the +contraction base. Exceptional negativity applied to both signs makes +that divisor zero. Thus the full pair remains crepant, including its +meromorphic adjoint identifications. The full transformed pair +\((T,G)\) is effective lc and is klt away from its full floor \(C^+\): +there it agrees with the transformed lowered klt pair. The program is +nonextracting, so the transformed divisor \(D^+\) has +\(\Supp D^+=\Supp C^+\). Since the full adjoint is pulled back from +\(Y_Z\), the lowered adjoint on a \(u\)-fiber is +\(-\epsilon D^+\). Hence \(D^+\) is relatively ample over \(W\). + +Compare the connected components of a general floor fiber on the original +small model and on \(T\). On a common projective log resolution the +full crepant subboundary is the same. Its unit union maps to both floors +with connected fibers by \cite[Lemma~2.1]{BL}. Proper closed surjections +with connected fibers preserve connected components, also after restricting +over a point of \(Y_Z\). Thus the connected components of the two +underlying floor fibers correspond. + +Every connected component of the floor fiber on \(T\) meets one common +general Mori fiber. Indeed \(C^+\to W\) is surjective because \(C^+\) +is the support of the relatively ample \(D^+\). Apply +Equation~\eqref{floor:restriction-obstruction} to \(u\). Surjectivity of +the floor makes \(\mathcal O_W\to u_*\mathcal O_{C^+}\) injective; the +displayed torsion-free cokernel then makes \(u_*\mathcal O_{C^+}\) +torsion-free. Let +\[ + C^+\longrightarrow\overline C\longrightarrow W +\] +be the Stein factorization. The finite space \(\overline C\) is reduced, +and every irreducible component of +\(\overline C\) dominates \(W\). To see the +last implication algebraically, a vertical minimal prime of a finite +reduced algebra over a domain would give, by prime avoidance, a nonzero +element killed by a nonzero element of the domain. After shrinking \(Y_Z\) +to a dense open, the fiber-dimension theorem gives every component of +\(\overline C_y\) dimension \(\dim W-\dim Y_Z\). The fiber \(W_y\) is irreducible of that +dimension: a resolution of \(W\) still has connected fibers over \(Y_Z\), +and a general one is smooth and connected and surjects onto \(W_y\). +Finiteness now makes each component of \(\overline C_y\) dominate \(W_y\). +Consequently each connected component of \(C^+_y\) meets \(u^{-1}(w)\) +for the same general \(w\in W_y\). + +The reduced general fiber \(F\) of \(u\) is irreducible by the same +resolution argument. If \(\dim F\geq2\), the support of the effective +ample Cartier multiple of \(D^+|_F\), whose support is \(C^+\cap F\), +is connected. One elementary +proof, valid even if \(F_{\rm red}\) is not normal, cuts by general +hyperplanes to an integral projective surface. If the ample divisor +split into disjoint nonzero Cartier parts \(D_1,D_2\), their pullbacks +to a resolution would be orthogonal, while the projection formula gives +\(v^*(D_1+D_2)\cdot v^*D_i>0\) for both \(i\). Thus both +\((v^*D_i)^2>0\), contradicting the surface Hodge index theorem. +If \(\dim F=1\), choose the fiber also off the singular, boundary +intersection, and ramification loci. It is a smooth connected curve and +\[ + 0=\deg(K_F+G|_F)=2g(F)-2+\deg(G|_F). +\] +There is a unit point, so \(F\simeq\PP^1\). Its floor has one or two +points; if there are two they exhaust the horizontal boundary. In every +connected case the preceding common-fiber observation makes the general +floor fiber connected, so no comparison is needed. In the remaining case +the two unit points represent all its connected components. + +Normalize the horizontal floor primes and take their Stein factorizations +over \(W\). If there are two primes, each finite Stein map has degree one +and is an isomorphism over normal \(W\); their main fiber product gives +a proper bimeromorphic comparison. If there is one prime, its normal Stein +space is a double cover of \(W\). The exchange on its general fiber +extends over the branch locus: the reduced horizontal non-diagonal +component of the double fiber product has finite birational projections +to the normal cover and hence both projections are isomorphisms. Its graph +lifts to the normalized prime. Composing with the program graphs transports +the comparison to two original normal floor primes, possibly the same one. +All graph projections are projective, and the primes survive birationally +because the program extracts no divisors. + +This comparison is crepant as a meromorphic residue identity. On a smooth +ruled open, order the markings after an \'etale local cover, choose a base +volume \(\xi\), and put the markings at \(z=0,\infty\). A pulled-back +\(q\)-pluriadjoint frame has the form +\[ + a(w)(dz/z)^{\otimes q}\otimes\xi^{\otimes q}. +\] +Its two residues are \(a(w)\xi^{\otimes q}\) and +\((-1)^q a(w)\xi^{\otimes q}\), which agree. This is the two-marking +Poincar\'e-residue comparison of +\cite[Section~3, Definition~13 and Proposition~14]{Kollar2013Sources}. +On a resolved graph both restricted actual lines are pulled back from +\(Y_Z\); their meromorphic embeddings agree on this dense open and hence +everywhere, including along exceptional primes. Equal residues therefore +give a constant value on the entire general floor fiber. The horizontal +consequence of Equation~\eqref{floor:restriction-obstruction} extends the section. +Normality descends it from the small model. Its restriction is the +prescribed section on the original reduced floor, since every original +floor prime is covered birationally and the two restrictions agree after +that pullback. + +It remains to check Equation~\eqref{floor:class-comparison}. Let \(\widehat T\) +be a common smooth resolution of the parent and Mori models and let +\(a,b:H\to\widehat T\) be the two maps from a resolved branch graph. +The resolution of the Mori model is an isomorphism near a general entire +\(\PP^1\) fiber: its centers have codimension at least two, hence cannot +dominate the ruling base. Every holomorphic two-form on \(\widehat T\) +comes from the base on that ruled open. In fact its vertical one-form +terms vanish on \(\PP^1\), and its remaining coefficients are constant +on that compact fiber. Thus \(a^*-b^*\) kills \(H^{2,0}\), and also +\(H^{0,2}\) by conjugation. This rational Hodge map on degree two has +image of type \((1,1)\). The Lefschetz \((1,1)\) theorem puts its real +image in \(\NS(H)_{\R}\). Apply this to the pulled-back parent class +\(c_Z\). The link is therefore an arrow as defined above. +\end{proof} + +\subsection{Transport respects every lower residue} + +An arrow can contract a divisor to a higher-codimension stratum. The next +local observation explains how to compare residues even in that case. +All valuations in its proof are local monomial valuations in an SNC chart. + +\begin{lemma}[Unit strata above an SNC stratum]\label{floor:unit-strata} +Let \(p:T\to Z\) be a projective log resolution of a dlt pair, with +crepant SNC subboundary on the smooth \(T\). Let \(R\subseteq T\) be a +unit stratum and let \(D=p(R)\) be its center. Then +\(D\) is a dlt stratum. There is a unit stratum \(R'\subseteq R\) such +that \(p(R')=D\) and \(R'\to D\) is birational. In the iterated residue +comparison along \(R'\), the normal logarithmic Jacobian is \(\pm1\). +\end{lemma} + +\begin{proof} +The center is a dlt stratum by the SNC discrepancy calculation in the +proof of Lemma~\ref{floor:adjunction}. Work over the generic SNC part of \(D\), +of codimension \(a\), with normal coordinates \(x_1,\ldots,x_a\) for +the unit divisors. The zero-discrepancy divisorial valuations centered +there are exactly the primitive rational monomial rays in +\(\R_{>0}^a\). Here is a local verification that also fixes their +normalization. The discrepancy inequality in the proof of +Lemma~\ref{floor:adjunction} says on every log-smooth model that the center +of a zero-discrepancy valuation is exactly a unit stratum: an additional +unmarked normal parameter, or a parameter with coefficient below one, would +give positive discrepancy. Blow up that stratum. If the positive normal +orders of the valuation are \(w_1,\ldots,w_b\), the chart indexed by a +smallest order \(w_k\) replaces these by \(w_k\) and the positive members +of \(w_i-w_k\). The exceptional divisor is again unit, and the center +is exactly the new unit stratum. While there is more than one positive +order their sum decreases. Eventually the center is the generic point of +one unit divisor, where a normalized divisorial valuation has order one. +Reversing these ordinary toric blowups proves monomiality and primitive +normalization. Conversely this subtraction algorithm for any primitive +positive integer vector terminates at order one, and reversing it extracts +that monomial valuation. Comparison on a common graph gives uniqueness +of the valuation with those weights and of its center on any model. + +For a unit component \(E\) meeting the inverse image of the generic SNC +part of \(D\), put +\[ + v_E=(\ord_E x_1,\ldots,\ord_E x_a)\in\Z_{\geq0}^a. +\] +If the unit components through a unit stratum \(Q\) meeting that inverse image are +\(E_1,\ldots,E_b\), define +\[ + \phi_Q:\R_{\geq0}^b\longrightarrow\R_{\geq0}^a,\qquad + (t_1,\ldots,t_b)\longmapsto\sum_{j=1}^b t_jv_{E_j}, + \qquad \sigma_Q=\phi_Q(\R_{\geq0}^b). +\] +The source carries its standard lattice \(\Z^b\). For the fixed +resolution \(T\), these cones subdivide the orthant over its interior. +On rational rays, \(\phi_Q\) sends a +monomial valuation on \(T\) to the same normalized valuation on \(Z\), +so it is injective on each cone. Interiors of different cones are +disjoint, because the center and the weights of a monomial valuation on +\(T\) are unique. Every rational ray in the orthant occurs: view its +valuation on \(T\) and use the same SNC description there. There are +only finitely many cones over the generic part of \(D\); density of +rational rays therefore gives coverage. Taking subsets of unit components +gives the faces, and uniqueness of valuations also on faces identifies +intersections as common faces. Consequently \(\sigma_R\) is a face +of an \(a\)-dimensional cone \(\sigma_{R'}\) with the same downstairs +center, for a unit stratum \(R'\subseteq R\). + +Let \(E_1,\ldots,E_a\) be the unit components through \(R'\). +The integer matrix \(A=(\ord_{E_j}x_i)\) of this full cone is unimodular. +Indeed every positive +primitive integral vector in the source cone is the normalized vector of +a divisorial valuation, so its image is primitive. If a prime divided +\(\det A\), a nonzero kernel vector modulo that prime, lifted to a +positive primitive integral vector, would have nonprimitive image. Hence +\(\det A=\pm1\). The strata \(R'\) and \(D\) have the same dimension. +We next prove that their generically finite map has degree one. In local coordinates at a +general point of \(R'\), +\[ + x_i=u_i(y,z)\prod_{j=1}^a y_j^{A_{ij}}, +\] +where the \(u_i\) are units, the \(y_j\) are normal coordinates, and +\(z\) are coordinates along the stratum. The tangential map is +generically \'etale in characteristic zero. Since \(A^{-1}\) is integral, +replace \(y_j\) by +\(\widetilde y_j=y_j\prod_i u_i^{(A^{-1})_{ji}}\). Then +\(x_i=\prod_j\widetilde y_j^{A_{ij}}\), and the map consisting of +\(\widetilde y\) and the downstairs tangential coordinates is locally +biholomorphic at a general \'etale point of \(R'\to D\). Two distinct +points over a general point of \(D\) would therefore give two lifts of +nearby target points whose normals approach with any fixed positive rate +vector in the interior of this cone. Varying the nonzero leading +coefficients fills an open set of nearby torus points, so such a target can +be chosen in the locus where \(p\) is an isomorphism. This contradiction +proves that \(R'\to D\) is birational. Finally, after taking residue +along \(R'\), the normal coefficient of +\(\bigwedge_i dx_i/x_i\) is \(\det A\) times that of +\(\bigwedge_jdy_j/y_j\); terms differentiating the units vanish in that +residue. Since \(\det A=\pm1\), the even pluriresidue removes the sign. +\end{proof} + +\begin{lemma}[Preservation of lower restrictions]\label{floor:transport} +Fix \(0\leq d0\), choose a common log resolution +\(p:T\to Z\), \(p':T\to Z'\) of the arrow. For a target floor prime +\(D'\), start with its strict transform \(R\). It is a unit stratum and +maps birationally to \(D'\). Its source center \(p(R)\) is a stratum by +Lemma~\ref{floor:unit-strata}. If \(R\to p(R)\) is not birational, that +lemma replaces \(R\) by a unit stratum inside it which maps birationally +onto the same source center. The target center may then shrink. If the +map to that center is not birational, apply the lemma on the target side, +and continue alternately. Each necessary replacement strictly decreases +dimension. The process therefore ends with one unit stratum mapping +birationally to lower strata \(D_0,D_0'\) on the two sides. + +The image in the common system base remains unchanged throughout. Indeed +the two maps from the resolved graph to the Stein targets are identified +by the arrow, and a replacement keeps its entire image on the side then +being treated. Initially the image was \(f_{Z'}(D')\). The terminal +comparison of \(D_0\) and \(D_0'\) is an arrow: restricting the actual +meromorphic identification to iterated residues gives crepancy, with the +logarithmic determinant sign removed by Lemma~\ref{floor:unit-strata}; +restricting the line Chern classes in Equation~\eqref{floor:class-comparison} +gives the same condition modulo \(\NS_{\R}\). Lower invariance thus +identifies the transported and assigned residues on \(D_0'\). + +This equality determines the entire section on \(D'\). The Stein map +of \(L_{D'}=L_{Z'}|_{D'}\) is the Stein factor of +\(f_{Z'}|_{D'}\), because the line induced on that Stein space is ample; +its target is finite over \(f_{Z'}(D')\). The image of \(D_0'\) in this +target is a closed irreducible subset of full dimension, since it still +maps onto \(f_{Z'}(D')\), and therefore is the whole target. Both +sections on \(D'\) come from it. Equality after restriction to +\(D_0'\) proves equality on \(D'\). + +The same construction shows that the image of every target floor prime +in the system base is the image of a lower source stratum, and the reverse +statement follows from the inverse arrow. A floor dominates the system +base on one side exactly when it does on the other. This proves the last +assertion. +\end{proof} + +\subsection{Finite actions on vertical strata} + +Once lower-dimensional sections are compatible and invariant, +Lemma~\ref{floor:transport} preserves their restrictions under every arrow. +If \(C_Z\) dominates \(Y_Z\), injectivity of restriction forces any such +transported extension to equal the assigned extension. Thus only vertical +strata require the following argument for finite image. + +\begin{proposition}[Finite image of self-arrows]\label{floor:finite-action} +Let \(Z\) be a boundary stratum with \(C_Z\) vertical. For all sufficiently +large divisible \(k\), the self-arrows of \(Z\) have finite image on +\(H^0(Z,L_Z^k)\). +\end{proposition} + +For \(m=qk\), a pluricanonical eigenform \(s\in H^0(Z,L_Z^k)\) with +\(\int_Z|s|^{2/m}<\infty\) becomes the \(m\)-th power of a holomorphic top +form on a smooth resolution of a cyclic root cover, so the auxiliary proposition below makes its +eigenvalue a root of unity. A uniform bound on the middle Betti numbers of +selected resolutions of these covers in the fixed degree will then bound +the possible orders; boundedness of the representation will give finite +image. The auxiliary proposition uses the polarization congruence in +Equation~\eqref{floor:class-comparison}. + +\subsubsection{Top-form scalars} + +\begin{proposition}[A polarized top-form scalar]\label{floor:top-form-scalar} +Let \(U\) be a smooth connected compact K\"ahler manifold of dimension +\(d0\) sufficiently divisible that the connected semiample map +and its Stein target satisfy +\[ + f:U'\longrightarrow Y,\qquad + \mathcal O_{U'}(\ell P)=f^*N, +\] +where \(Y\) is normal projective and \(N\) is ample, and that +Lemma~\ref{bir:sections} identifies every graded piece in +\[ + R_\ell(U):=\bigoplus_{j\geq0}H^0(U,j\ell K_U) + \simeq \bigoplus_{j\geq0}H^0(Y,N^j). +\] +This is the full section ring of the ample line \(N\), so +\(Y\simeq\Proj R_\ell(U)\). Passing to a further divisible Veronese gives +the same Proj. We call \(Y\) the \emph{canonical Iitaka base}. A +bimeromorphic self-map of \(U\) acts on this graded ring and therefore +induces an automorphism of \(Y\). + +\begin{lemma}[Finite action on the canonical Iitaka base]\label{floor:finite-base} +Let \(U\) be a smooth connected compact K\"ahler manifold of dimension +\(d0\) in the interior, since \(\chi_R\) diverges at the boundary +and \(\chi\) is bounded on the closed disk. At that point, +\[ + 0\ge\partial_z\partial_{\bar z}\log(\chi/\chi_R) + \ge\frac{\kappa}{2}(\chi-\chi_R)>0, +\] +a contradiction. Thus the Ahlfors--Schwarz comparison gives +\(\chi(0)\le4/(\kappa R^2)\) \cite{Ahlfors1938}. +Letting \(R\to\infty\) forces the metric to vanish +on \(\C\). The argument is local and allows zeros of the +induced metric, so the local representations just constructed suffice. +Consequently their period maps are locally constant along each such orbit. +In any holomorphic volume frame the logarithm of the coefficient in +Equation~\eqref{floor:hodge-density} is harmonic along each orbit: the top Hodge line is +flat there, and \(\sigma\) is a nonzero holomorphic multiple of a flat +generator. + +This is incompatible with finite mass. Diagonalize the one-parameter +action in projective coordinates, and choose two coordinates nonzero at a +general point with different weights, of difference \(a\ne0\). A small +smooth transverse slice \(Q\) on which their ratio is one gives a +holomorphic local biholomorphism onto its image +\[ + \Phi:\C^*\times Q\longrightarrow Y^* +\] +with fibers of size at most \(|a|\): the ratio at \(\Phi(z,t)\) is +\(z^a\). The entire \(\C^*\) factor is allowed because \(Y^*\) is +invariant. In the product frame \((dz/z)\wedge dt_1\wedge\cdots\wedge +dt_{\dim Q}\), write \(\Phi^*\nu\) with coefficient \(\rho(z,t)>0\). +For fixed \(t\), \(\log\rho(z,t)\) is harmonic on \(\C^*\). Its +circular mean at \(|z|=e^u\) is \(A(t)u+B(t)\). Jensen's inequality +therefore gives, with an irrelevant positive normalization, +\[ + \int_{\C^*}\rho(z,t)\frac{i\,dz\wedge d\overline z}{|z|^2} + \ \geq\ c\int_{\R}e^{A(t)u+B(t)}\,du=\infty. +\] +Tonelli's theorem contradicts the finite mass of \(\Phi^*\nu\), which +is at most \(|a|\nu(Y)\) by the bounded covering degree. This proves +that \(h\) has finite order. +\end{proof} + +After a power, the scalar problem can thus be restricted to a fiber with +Kodaira dimension zero. The polarization congruence then passes to that +fiber; the next two lattice arguments control its nonprojective factors. +In the next lemma, the hypothesis +on the origin of the model is what provides the degree-two exceptional +splitting; rational singularities alone are not used for that splitting. + +\begin{lemma}[The scalar on a symplectic factor]\label{floor:symplectic-scalar} +Let \(Y\) be a terminal compact K\"ahler primitive symplectic space of +dimension \(2e0\). Since \(\beta\) +is nef over \(Y\), exceptional negativity applied to the divisor \(E\), +with \(\{E\}=p^*c-[\beta]\), gives \(E=\sum_i e_iE_i\geq0\). Pair with the positive +normalization \(W_R=(p^*\eta\,p^*\overline\eta)^{e-1}\). Exceptional +classes pair to zero with \(p^*c\) by projection formula, and hence for +some constant \(b_e>0\) +\begin{equation}\label{floor:positive-bb} + q_Y(c)=b_e\left(\int_R\beta^2 W_R+\sum_i e_i\int_{E_i}\beta W_R\right)>0. +\end{equation} +Every term is nonnegative. The first is strictly positive on the common +open where \(\beta\) is positive and the symplectic form is nondegenerate. + +Set \(H_\Q=H^2(Y,\Q)\) and +\(D_\Q=H_\Q\cap H^{1,1}(Y,\C)\). Lefschetz \((1,1)\) on \(R\), together +with the line-trace assertion of Lemma~\ref{prog:cohomology-transport}, +identifies \(D_\Q\) with the rational span of line Chern classes. +It is \(G\)-invariant because \(G\) is a rational Hodge automorphism. +The same line-trace assertion applied to the graph congruence gives +\(Gc-c\in D_\R\). The line \(\C\eta\) survives in \(H_\C/D_\C\); +our immediate aim is to prove that all eigenvalues on this quotient have +absolute value one. Write \(\Sigma=(H^{2,0}\oplus H^{0,2})_\R\), the +positive real two-plane. There are three possibilities for the restriction +of the Lorentz form to \(D_\R\). + +If \(D_\R\) is negative definite, its orthogonal projection \(c_0\) of +\(c\) to \(D_\R^\perp\) is fixed by \(G\) and has positive square by +Equation~\eqref{floor:positive-bb}. On \(D_\R^\perp\), the invariant space +\(\Sigma\oplus\R c_0\) is positive definite and its complement is +negative definite. All eigenvalues there have absolute value one. If +\(D_\R\) contains a positive vector, it is nondegenerate with one +positive direction. Its orthogonal complement is the positive plane +\(\Sigma\) plus a negative-definite space, giving the same conclusion. +In either case \(H_\R/D_\R\simeq D_\R^\perp\). + +In the remaining case \(D_\R\) is negative semidefinite with radical a +rational isotropic line \(\ell\). The lattice action on \(\ell\) is +\(\pm1\). On \(\ell^\perp/\ell\) the form is the positive plane +\(\Sigma\) plus a negative-definite \((1,1)\) space, and the quotient +\(H_\R/\ell^\perp\) is dual to \(\ell\). The invariant flag +\(0\subset\ell\subset\ell^\perp\subset H_\R\) therefore shows that +all eigenvalues on \(H_\R\) have absolute value one; this argument also +allows unipotent parts. In all cases the eigenvalues on +\(H_\C/D_\C\) have absolute value one. The rational quotient +\(H_\Q/D_\Q\) carries the preserved lattice +\[ + \overline\Lambda_Y=\Lambda_Y/(\Lambda_Y\cap D_\Q), +\] +where the intersection is saturated. Thus +\(\lambda\) is an algebraic integer and all its algebraic conjugates have +absolute value one. Kronecker's theorem makes it a root of unity. +\end{proof} + +\begin{lemma}[The scalar on a torus]\label{floor:torus-scalar} +Let \(A\) be the integral Hodge automorphism of \(H^1(T,\Z)\) induced +by an automorphism of a compact complex torus \(T\). Suppose a positive +Hermitian class \(c\in H^{1,1}(T,\R)\) satisfies +\((\bigwedge^2 A)c-c\in\NS(T)_\R\). Then +\(\det(A|H^{1,0}(T))\) is a root of unity. +\end{lemma} + +\begin{proof} +Put \(V=H^1(T,\Q)\) and \(D_\Q=\NS(T)_\Q\). For each eigenvalue +\(\theta\) of \(A_\C\), let \(V_\theta\) be its generalized eigenspace and set +\(d_\theta=\dim V_\theta\), \(p_\theta=\dim(V_\theta\cap H^{1,0}(T))\). +Complex conjugation gives +\(p_\theta+p_{\overline\theta}=d_\theta=d_{\overline\theta}\). + +For \(|\theta|\ne1\), project \(c\) to the block +\(V_\theta\wedge V_{\overline\theta}\), with \(\bigwedge^2V_\theta\) understood for +real \(\theta\). This projection preserves \(D_{\overline\Q}\). Indeed +the Chinese-remainder projectors onto the generalized spaces are +polynomials in \(A\) with algebraic coefficients. Apply them to the +two tensor slots separately and then alternate. The resulting maps are +algebraic linear combinations of rational Hodge maps on \(\bigwedge^2V\); +these preserve rational \((1,1)\) classes, hence \(D_\Q\) by Lefschetz +\((1,1)\). Separate slot projections avoid any collision of products of +eigenvalues in degree two. + +On this block \(A_2=\bigwedge^2 A\) has the single generalized +eigenvalue \(\theta\overline\theta=|\theta|^2\ne1\). The inverse of \(A_2-1\) +there is a finite polynomial in its nilpotent part. Project the congruence +for \(c\) to the block and apply this inverse. It follows that its block +\(c_{\theta,\overline\theta}\) belongs to \(D_\C\). Positivity says that this +block is a perfect tensor between \(V_\theta\) and \(V_{\overline\theta}\), +pairing their opposite Hodge types: in a basis of \(H^{1,0}\) the relevant +matrices are positive-definite principal Hermitian blocks. For real +\(\theta\) the corresponding alternating tensor is nondegenerate. + +The intersection of this block with \(D_\C\) is defined over +\(\overline\Q\). Nondegeneracy is the nonvanishing of a determinant, +so it contains a nondegenerate tensor with algebraic coefficients. For +any Galois automorphism \(\gamma\), the conjugate tensor remains in +\(D_{\overline\Q}\), hence is still of type \((1,1)\) for the given +Hodge decomposition, and is perfect between \(V_{\gamma(\theta)}\) and +\(V_{\gamma(\overline\theta)}\). Opposite-type perfection yields +\begin{equation}\label{floor:torus-hodge-count} + p_{\gamma(\theta)}+p_{\gamma(\overline\theta)} + =d_\theta\qquad(|\theta|\ne1). +\end{equation} +This does not replace \(\gamma(\overline\theta)\) by +\(\overline{\gamma(\theta)}\), and assumes no Galois invariance of the Hodge +decomposition. + +The top-form scalar is the algebraic integer +\(z=\prod_\theta \theta^{p_\theta}=\det(A|H^{1,0})\), also when generalized eigenspaces +are nontrivial. For any Galois automorphism \(\delta\), reindex by the +image roots and pair complex conjugates: +\[ + \begin{aligned} + \log|\delta z| + &=\frac12\sum_\theta + \bigl(p_{\delta^{-1}(\theta)} + +p_{\delta^{-1}(\overline\theta)}\bigr)\log|\theta|\\ + &=\frac12\sum_\theta d_\theta\log|\theta| + =\tfrac12\log|\det A|=0. + \end{aligned} +\] +For \(|\theta|\ne1\) the second equality uses +Equation~\eqref{floor:torus-hodge-count} with \(\gamma=\delta^{-1}\); the other +terms vanish. The last equality is unimodularity of the integral action. +Kronecker's theorem now proves the assertion. +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{floor:top-form-scalar}] +Apply Lemma~\ref{floor:finite-base}. After a power, \(g\) acts trivially +on the canonical Iitaka base. Use the modification \(\pi:U'\to U\) and +the map \(f:U'\to Y\) in its construction, and restrict over a general +point where the graph and the fibration are smooth and the fiber meets the +isomorphism locus of \(\pi\). Dividing \(\alpha\) by a local base volume +gives a nonzero top form on the smooth compact fiber \(F\), which has +\(\kappa(F)=0\); its returning map scales the form by the corresponding +power of \(\mu\). A point fiber gives scalar one. For a positive-dimensional +fiber, let \(\omega_U\) be a K\"ahler form representing the class in the +proposition and put \(\beta_F=(\pi|_F)^*\omega_U\). This is a smooth +semipositive form, strictly positive on the dense open where \(\pi\) is +an isomorphism. Pulling the original graph congruence to \(U'\) and +restricting to the fiber shows that the two pullbacks of \([\beta_F]\) on +a common resolved graph of the returning map of \(F\) differ by real line classes. +This weaker positivity suffices below. + +Since \(\dim F\leq d0\) and a compatible invariant generating system +of tuples through dimension \(n-1\). +\end{proposition} + +\begin{proof} +At the point strata use the same scalar in the canonical zero-form +generator \(1\). The even residue convention identifies these generators +along every path and under every point arrow. This gives the required +system in dimension zero; if there are no points the empty system is +understood. + +Suppose the system has been constructed through dimension \(d-1\). +Replace it by powers and their span in a common degree \(k\) chosen so that +Lemma~\ref{floor:restriction} applies on +every \(d\)-stratum, Proposition~\ref{floor:finite-action} applies on every +vertical \(d\)-stratum, and +\(\mathcal I_{f_Z(C_Z)}\otimes N_Z^k\) is generated for every +\(d\)-stratum \(Z\). These conditions hold in a common divisible tail: +there are finitely many strata, and the last condition is Serre's theorem. +For a \(d\)-stratum \(Z\), Lemma~\ref{floor:adjunction} glues +the lower tuple to a section on its whole \(C_Z\). Its residues satisfy +the one link in Lemma~\ref{floor:restriction}, if that link is present, +because the lower tuple is invariant. That lemma extends the section to +\(Z\). + +Let \(\mathcal P_d(k)\) be the vector space of all tuples through +dimension \(d\) whose lower part is in \(\mathcal V_{d-1}(k)\) and whose +new components restrict to that lower part. Call its elements +\emph{pre-tuples}. Its projection to +\(\mathcal V_{d-1}(k)\) is surjective, since the finitely many extensions +can be chosen independently. This system already generates. To check a +point \(z\in Z\), put \(y=f_Z(z)\). If \(y\in f_Z(C_Z)\), choose a +floor point over \(y\) and a lower tuple nonzero there. Every extension is +the pullback of a section of \(N_Z^k\), so it is nonzero at every point +over \(y\), including \(z\). If \(y\notin f_Z(C_Z)\), the chosen generation +of \(\mathcal I_{f_Z(C_Z)}\otimes N_Z^k\) supplies a base section nonzero +at \(y\). It pulls back to a section +vanishing on \(C_Z\); combine it with the zero lower tuple and zero +components on the other new strata. This also treats an empty floor. +Surjectivity to the lower system preserves generation at lower points. + +We impose invariance in dimension \(d\). For a dominating floor, +injectivity of restriction and Lemma~\ref{floor:transport} already make +every pre-tuple invariant on that stratum. +Verticality is invariant under arrows, so the remaining orbits consist +entirely of vertical strata. + +For each such orbit choose a representative \(Z\), and let \(G_Z\) be +the finite isotropy image on \(H^0(Z,L_Z^k)\) given by +Proposition~\ref{floor:finite-action}. For a pre-tuple with component +\(s_Z\), form the norm +\[ + P_Z(s_Z)=\prod_{g\in G_Z}g(s_Z) + \in H^0(Z,L_Z^{k|G_Z|}). +\] +Choose a common positive integer \(a\) divisible by all \(|G_Z|\), use +\(P_Z(s_Z)^{a/|G_Z|}\), and transport it to each member of that orbit. +This is independent of the chosen arrow: changing that arrow by an +isotropy arrow merely permutes the factors in degree \(k\). No finiteness +assertion in degree \(ak\) is needed. On strata with dominating floor +use \(s_Z^a\), and on all lower strata use the componentwise \(a\)-th +power of the assigned tuple. + +The resulting tuple is compatible. By Lemma~\ref{floor:transport}, +every transported factor in a norm has exactly the prescribed lower +restriction. The norm and its indicated power therefore restrict to +the \(a\)-th power of that restriction, the same value used on all lower +strata and in all other orbits. It is invariant in dimension \(d\) by +construction, and remains invariant below it. + +These tuples still generate. Fix a point \(z\) in an orbit member. +For each of the finitely many transported factors, choose a point over +\(z\) on a resolution of its comparison graph. Equality of the +pulled-back invertible adjoint lines identifies the fiber values. The +factor is nonzero at \(z\) exactly when the representative component +\(s_Z\) is nonzero at the corresponding point of \(Z\). Evaluation at each +such point is a nonzero linear functional on the generating space +\(\mathcal P_d(k)\). +A finite union of their proper kernels cannot cover a complex vector +space. One pre-tuple makes all factors nonzero and gives a norm nonzero +at \(z\). At a lower point a nonzero assigned value stays nonzero after +its \(a\)-th power. Taking the linear span of all the constructed tuples +therefore gives a compatible invariant generating system in degree \(ak\). +This completes the induction on \(d\). +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{floor:generation}] +Take the system in Proposition~\ref{floor:tuples}. Its components on the +prime components of \(S\) agree on every common lower stratum, so +Lemma~\ref{floor:adjunction} descends each tuple uniquely to a section of +the actual line \(\mathcal O_V(qkJ)|_S\). At any \(x\in S\), choose a +prime component through \(x\) and a tuple nonzero there. It is the pullback +of the descended value in the same invertible line fiber at \(x\), so +that value is nonzero. The finite-dimensional span of these descended +sections generates at every point of the reduced \(S\). This is the +claimed global generation of an actual Cartier multiple. +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/05-projective-program-input.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/05-projective-program-input.tex new file mode 100644 index 0000000000000000000000000000000000000000..791dded29fbf0357f50ca72abf2e8608ba7d3440 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/05-projective-program-input.tex @@ -0,0 +1,206 @@ +\subsection{Projective programs under the assumption} +\label{rank:projective-program-input} + +The argument for a projective base uses a terminating program to reach a nef +adjoint and, after decreasing the nef data, a program ending in a Mori fiber +space. The conditional input is termination in the pseudo-effective case. +We first state the exact program result and then derive that case from the +projective good models in Proposition~\ref{proj:good-models}. + +\begin{proposition}[A conditional generalized program] +\label{proj:generalized-mmp} +Assume Assumption~\ref{asm:log-iitaka}. Let +\((V,B+\boldsymbol M)\) be a projective generalized dlt rational pair, +where \(V\) is \(\Q\)-factorial, \(B\geq0\), and the nef b-divisor +\(\boldsymbol M\) is determined by a nef rational Cartier divisor on a +projective birational model. Put \(D=K_V+B+M_V\). + +There is a choice of \(D\)-MMP with ample scaling which terminates. If +\(D\) is pseudo-effective, its endpoint \(V_m\) has nef adjoint \(D_m\). +If \(D\) is not pseudo-effective, its endpoint has a Mori fiber contraction +to a projective variety of smaller dimension. The birational steps and their +endpoints stay \(\Q\)-factorial generalized dlt, and the forward birational +map extracts no divisors. +In the pseudo-effective case, on a common resolution one has an actual +rational divisor identity +\[ + u^*D=v^*D_m+F,\qquad F\geq0\text{ and }v\text{-exceptional}. +\] +\end{proposition} + +For the pseudo-effective alternative, we first derive the relative weak +Zariski decompositions used by the minimal-model existence theorem. + +For a projective morphism, first replace its image by its normal Stein +factor. We use the relative convention of \cite[Section~2]{TsakanikasXie}: +a divisor is pseudo-effective over the base when its restriction to a very +general fiber of this surjective morphism is pseudo-effective. An NQC weak Zariski decomposition of \(D\) over the +base is a birational equality \(h^*D\equiv_Z P+N\), where \(P\) is a +nonnegative real combination of relatively nef rational Cartier divisors +and \(N\geq0\). The decomposition below has rational Cartier parts. + +\begin{lemma}[Relative canonical decomposition]\label{proj:relative-wzd} +Assume Assumption~\ref{asm:log-iitaka}. Let \(V\) be a smooth +quasi-projective complex variety and let \(f:V\to Z\) be projective, with +\(Z\) normal and quasi-projective. If \(K_V\) is pseudo-effective over +\(Z\), then on a normal variety \(Y\) with a projective birational morphism \(h:Y\to V\) there +are rational Cartier divisors \(P,N\) such that +\[ + h^*K_V\equiv_Z P+N,\qquad P\text{ nef over }Z,\qquad N\geq0. +\] +\end{lemma} + +\begin{proof} +We use the construction in the proof of +\cite[Proposition~3.3]{External037}. Its absolute input is a nef-plus- +effective rational decomposition for the canonical divisor of a smooth +projective variety with pseudo-effective canonical class. This is supplied +here by Proposition~\ref{proj:good-models} and its common-resolution +comparison. + +Replace the image of \(f\) by its normal Stein factor. This does not change +relative numerical classes or contracted curves, and now \(f\) is +surjective with connected fibers. Its very general fiber is smooth +projective with pseudo-effective canonical divisor, hence is non-uniruled +by \cite[Theorem~0.2 and Corollary~0.3]{BDPP}. Compactify the projective +morphism and resolve away from \(V\). We obtain +\(\bar f:\bar V\to\bar Z\), with \(\bar V\) smooth projective and +\(\bar Z\) normal projective, unchanged over \(Z\). If \(\dim Z=0\), +\(V\) is already projective and the absolute input proves the lemma. + +Suppose \(\dim Z>0\), and let \(r:\widetilde Z\to\bar Z\) be a smooth +projective resolution. Choose a sufficiently positive very ample divisor +\(A_Z\) on \(\bar Z\) and a general \(B\in|2A_Z|\). The pulled-back systems +on both \(\widetilde Z\) and \(\bar V\) are base point free. Bertini makes +\(r^*B\) and \(\bar f^*B\) smooth nonempty reduced divisors. Their double +covers +\[ + \pi_Z:Z^\sharp\to\widetilde Z, + \qquad \pi:V^\sharp\to\bar V +\] +are smooth integral projective varieties. The canonical formulas are +\[ + K_{Z^\sharp}\sim_{\Q}\pi_Z^*(K_{\widetilde Z}+r^*A_Z), + \qquad + K_{V^\sharp}\sim_{\Q}\pi^*(K_{\bar V}+\bar f^*A_Z). +\] +The first line is big when \(A_Z\) is sufficiently positive. The rational +map \(V^\sharp\dashrightarrow Z^\sharp\) has the same very general fibers +as \(f\). A covering family of rational curves on \(V^\sharp\) would +either dominate a covering family of rational curves on \(Z^\sharp\), or +cover its very general fibers by vertical rational curves. Both are +impossible. Thus \(V^\sharp\) is non-uniruled and \(K_{V^\sharp}\) is +pseudo-effective by BDPP. + +Apply the absolute decomposition to \(V^\sharp\). Moving the rational +principal difference in the canonical formula into the nef part gives an +actual rational divisor decomposition for a pullback of +\(\pi^*(K_{\bar V}+\bar f^*A_Z)\). Take a common equivariant resolution of +that model and its conjugate under the covering involution. On this smooth +projective resolution \(g:T\to V^\sharp\), average the two decompositions. +We obtain +\[ + g^*\pi^*(K_{\bar V}+\bar f^*A_Z)=\bar P+\bar N, + \qquad \bar P\text{ nef},\quad \bar N\geq0, +\] +where \(\bar P\) and \(\bar N\) are invariant rational Cartier divisors. + +Let \(q:T\to\bar Y\) be the finite quotient by the involution. The invariant +composite \(\pi g\) induces a projective birational morphism +\(\bar h:\bar Y\to\bar V\), with \(\bar Y\) normal and projective. An invariant +rational divisor descends by dividing its coefficient at an upstairs prime +by the ramification index. The descended divisor is rational Cartier when +the original divisor is: after clearing denominators, choose one Cartier +equation on a semilocal neighborhood of the finite orbit above a point +(a Cartier divisor is principal on a semilocal ring), and multiply all its +translates. The product is invariant and has divisor +equal to the group order times the original divisor. It descends to a local +equation for a multiple of the downstairs divisor. This argument includes +stabilizers and ramification primes. + +Accordingly \(\bar P=q^*P\) and \(\bar N=q^*N\) for rational Cartier +divisors on \(\bar Y\). Lifting curves through the finite map shows that +\(P\) is nef, and coefficientwise descent shows that \(N\) is effective. +Finite pullback is injective on rational divisors, so the displayed identity +descends. Restrict it to \(Y=\bar h^{-1}(V)\). The term pulled +back from \(A_Z\) is numerically trivial over \(Z\), giving +\(h^*K_V\equiv_ZP+N\), as required. +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{proj:generalized-mmp}] +Lemma~\ref{proj:relative-wzd} and +\cite[Theorem~5.2]{TsakanikasXie}, applied to the generalized pair +\((U/Z,0+0)\) with \(U\) smooth, prove relative minimal-model existence for smooth varieties +by dimension induction. The hypothesis of that theorem is relative smooth +minimal-model existence one dimension lower; the lemma supplies its other +hypothesis, an NQC weak Zariski decomposition. The induction begins in +dimension zero. Then \cite[Theorem~5.4]{TsakanikasXie} supplies minimal +models for every pseudo-effective NQC generalized lc pair in the relevant +dimension. Their Theorem~2.7 gives existence in the Birkar--Shokurov sense. + +The nef data in the statement are NQC, because a nef rational Cartier +divisor is a positive multiple of a nef Cartier divisor. In the +pseudo-effective case the preceding paragraph therefore gives the +Birkar--Shokurov model required by +\cite[Theorem~4.2]{TsakanikasXie}. In the other case, the non-pseudo-effective +alternative of that theorem applies directly. To meet its scaling +hypothesis, take an effective sufficiently positive ample rational divisor +\(A\) whose general components have sufficiently small coefficients. On +a fixed log resolution carrying \(\boldsymbol M\), these components are +transverse to the boundary and preserve generalized log canonicity, while +their ample class can be chosen large enough that \(D+A\) is nef. The +theorem supplies a terminating MMP starting on \(V\). + +We verify the step types inductively. Suppose \(V_i\) is +\(\Q\)-factorial generalized dlt. By +\cite[Remark~2.15]{TsakanikasXie}, each birational step has the form +\[ + V_i\xrightarrow{g_i}Z_i\xleftarrow{h_i}V_{i+1}, +\] +where \(g_i\) contracts a negative extremal ray and \(h_i\) is small and projective. +Suppose \(g_i\) is divisorial, and write \(R\) for its ray. An exceptional +prime \(E\) has \(E\cdot R<0\): otherwise it would be effective, +exceptional, and \(g_i\)-nef, contrary to negativity. There is only one +exceptional prime. Indeed, a combination of two distinct exceptional +primes can be chosen to have degree zero on \(R\); negativity applied to +both signs of that combination would make it zero. + +We show directly that \(Z_i\) is \(\Q\)-factorial. For a prime divisor +\(T\) on \(Z_i\), let \(\widetilde T\) be its strict transform, choose a +curve \(C\) spanning \(R\), and put +\[ + a=-\frac{\widetilde T\cdot C}{E\cdot C}\in\Q. +\] +Choose a positive integer \(m\) for which \(m(\widetilde T+aE)\) is +Cartier. Its line has degree zero on \(R\), so +\cite[Theorem~1.5]{Xie2022} gives an actual Cartier line \(\mathcal L_T\) +on \(Z_i\) and an isomorphism +\[ + \OO_{V_i}\bigl(m(\widetilde T+aE)\bigr)\simeq g_i^*\mathcal L_T. +\] +On an open set trivializing \(\mathcal L_T\), the Cartier divisor +\(m(\widetilde T+aE)\) is principal upstairs. Pushing this principal +divisor identity down through the birational \(g_i\) gives a principal +divisor \(mT\) on that open set. +Thus \(T\) is rational Cartier. It follows that \(h_i\) is an isomorphism: +the pushforward of an \(h_i\)-ample Cartier divisor is rational Cartier +on \(Z_i\), and its pullback is the original divisor because \(h_i\) +is small. It has degree zero on every contracted curve, so relative +ampleness rules out positive-dimensional fibers; a finite birational +map to the normal \(Z_i\) is an isomorphism. If \(g_i\) is small, +the relatively ample canonical model \(h_i\) is the flip of +\cite[Definition~3.2]{HanLi}. Thus the chosen birational steps are +divisorial contractions and flips. The underlying variety of a +generalized dlt pair is klt, and these steps preserve the +\(\Q\)-factorial generalized dlt category +\cite[Remark~2.3 and Lemma~3.7]{HanLi}. They introduce no prime +divisors on the new models. For completeness, on a common resolution +of one step \(V_i\dashrightarrow V_{i+1}\) carrying \(\boldsymbol M\), +taking the difference of the two generalized discrepancy formulas cancels +their common nef divisor. The resulting difference of the adjoint pullbacks is exceptional over the new +model and anti-nef over it. The negativity lemma makes this difference +effective. Composing these actual rational divisor comparisons gives +\(u^*D=v^*D_m+F\) with \(F\) effective and exceptional over the endpoint. +The endpoints in the two cases are the nef and Mori fiber endpoints supplied +by the terminating program theorem. +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/05-rank-one.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/05-rank-one.tex new file mode 100644 index 0000000000000000000000000000000000000000..f030d9a901a13c7d6d86b986c78b5eba9df5f207 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/05-rank-one.tex @@ -0,0 +1,1173 @@ +\section{Descent along a fibration} +\label{sec:rank-one} + +Throughout this section we assume Assumption~\ref{asm:log-iitaka}. + +We prove Proposition~\ref{rank:fibration-case}. Its geometric reduction +leads to a fibration whose very general fiber has logarithmic Kodaira +dimension zero. In sufficiently divisible degrees the log pluricanonical +systems on that fiber are one-dimensional, and a relative generating form +determines an adjoint line on the base. We prove the resulting rank-one +proposition by a secondary induction on the positive base dimension: after proving +pseudo-effectivity on the base, we either lower its dimension or lift a nef +line and its entire fixed divisor. The last step proves generation of the +remaining nef line. + +\subsection{Reduction to the rank-one case} + +\begin{proposition}[The rank-one case] +\label{rank:rank-one} +Assume Assumption~\ref{asm:log-iitaka}. Fix \(n>0\) and assume +\(\Ggood_d\) for every \(d0\). If \(a(X)=n\), then \(X\) is Moishezon and +Kähler, hence projective, and Proposition~\ref{proj:good-models} applies. +Otherwise resolve the algebraic reduction as a fibration +\(g:X'\to W\) to a smooth projective variety of dimension \(a(X)\). +Put \(J'=K_{X'}+B'\) for the modified log adjoint. Its restriction to +a very general smooth fiber is pseudo-effective. Indeed, one may choose +a sequence of positive currents in +\(c_1(J')+\varepsilon_j[\omega]\), with analytic singularities and +\(\varepsilon_j\downarrow0\), and restrict all of them outside a +countable union of proper analytic subsets of the base. By +\(\Ggood_{\dim F}\), the restricted adjoint has nonnegative Kodaira +dimension. + +That dimension must be zero. If it were positive, generic coherent +base change would give a divisible \(q\) for which +\(\mathcal E=g_*\OO_{X'}(qJ')\) has a fiber system with a +positive-dimensional image on very general fibers. A sufficiently +large ample twist of the coherent sheaf \(\mathcal E\) is generated at +the generic point of the projective \(W\). Evaluation would therefore +give two sections of +\(\OO_{X'}(qJ')\otimes g^*\OO_W(A)\), for one ample \(A\), whose ratio +is nonconstant on a general \(g\)-fiber. This ratio is a meromorphic +function on \(X'\). Every meromorphic function on \(X'\) factors +through its algebraic reduction, a contradiction. +Proposition~\ref{rank:rank-one} now applies. + +Suppose next that \(a(X)=0\), and resolve the fibration in the +hypothesis as \(f:(X',B')\to Y\). The base may be replaced by a smooth +compact Kähler model, and \(a(Y)=0\), since its meromorphic functions +pull back to \(X'\). Write \(d=\dim X'-\dim Y>0\). +The same restriction argument and \(\Ggood_d\) show that +\[ + \kappa(F,K_F+B'_F)\geq0 +\] +on very general smooth fibers. If this integer is \(j0\), then \(K_S+a_0P_S\) is big for some rational +\(a_0>0\); if \(S\) is a point, \(M\sim_{\Q}0\). +There is a rational divisor \(A_*\) on \(X\) giving an actual rational +line identity +\begin{equation} + J\sim_{\Q}g^*H+A_*. +\label{rank:line-comparison} +\end{equation} +These data satisfy the following properties. + +\begin{enumerate} +\item The horizontal part \(A_{*,\mathrm{hor}}\) is effective. +On a very general smooth fiber it is the zero divisor of a relative +generating section of a divisible multiple of \(K_F+B_F\), divided +by that multiple. + +\item For each prime \(D\subset W\), let \(E\) run over the primes of +\(X\) dominating \(D\), and put \(a_E=\ord_E(g^*D)\). +Then +\begin{equation} + (A_*)_E\geq0,\qquad + \min_{E\to D}\frac{(A_*)_E}{a_E}=0. +\label{rank:zero-minimum} +\end{equation} +There is no assertion here about the sign at a prime whose image has +codimension at least two. + +\item For all degrees \(q\) divisible by one positive integer, +multiplication by the relative generating form identifies +\[ + H^0(W,qH)\simeq H^0(X,qJ) +\] +and preserves ratios of sections. In the same degrees, for every +proper holomorphic \(h:W\to V\), there is a natural injection +\begin{equation} + (hg)_*\OO_X(qJ)\ \lhook\joinrel\longrightarrow\ + h_*\OO_W(qH). +\label{rank:relative-injection} +\end{equation} + +\item Let \(\tau:W'\to W\) be a further smooth modification included +in another diagram with the preceding properties over the same reference +\(X_0\), using the same source-boundary convention. Let \(H'\) be the +base line produced by that diagram. Then, as actual rational lines, +\begin{equation} + H'\sim_{\Q}\tau^*H+E_H, + \qquad E_H\geq0\ \text{\(\tau\)-exceptional}. +\label{rank:higher-base} +\end{equation} +\end{enumerate} +\end{lemma} + +\begin{proof} +The flattening construction of \cite[Lemma~2.4]{CI} gives the stated +reference property, and preserves it after any finite sequence of +further base modifications. Its source boundary is the one in +\cite[Lemma~2.1]{CI}. We may resolve the discriminant and the +horizontal divisor of the relative generator so that all relevant +strata are smooth over the dense smooth log locus. Proposition~2.7 +of \cite{CI} then gives \(T\) and a rational parabolic Hodge line +\(M\). A positive multiple of that line is the highest rank-one +Hodge step of a complex summand of a pure real-polarizable variation +with an integral lattice. Theorem~3.1 of \cite{CI} gives the +factorization \(M=p^*P_S\) and the stated positivity, after a further +modification and a positive rational rescaling. These are identities +in \(\Pic\otimes\Q\), not merely identities of classes. + +Here is the order computation that gives +Equations~\eqref{rank:line-comparison}--\eqref{rank:relative-injection}. +Choose a degree \(m\) for which +\(g_*\OO_X(m(K_{X/W}+B))\) has generic rank one and all boundary +denominators are cleared. Its reflexive hull is a line on the smooth +\(W\). Let \(s\) be a meromorphic relative generating form in a +local frame of this line. At the generic point of a prime \(D\), +choose a nonvanishing ordinary base volume \(\omega_W\), and set +\[ + l_E=\frac1m\ord_E(s\wedge g^*\omega_W^m),\qquad + \delta_E=B_E,\qquad + \alpha_D=\min_{E\to D}\frac{l_E+\delta_E}{a_E}. +\] +The relative-times-base identification in this formula is taken in +the \(m\)-th canonical tensor power. The source is resolved over +the generic point of \(D\), so all the primes needed for the +divisorial test occur in this minimum. In the notation of the +proof of \cite[Proposition~2.7]{CI}, the parabolic order is +\[ + \beta_D=\min_{E\to D}\frac{l_E+1-a_E}{a_E}, + \qquad T_D=\alpha_D-\beta_D. +\] +Thus the corresponding local frame of \(T+M\) has order +\(\alpha_D\). Comparing its pullback with the log adjoint form +defines \(A_*\), with +\begin{equation} + (A_*)_E=l_E+\delta_E-a_E\alpha_D . +\label{rank:vertical-order} +\end{equation} +Changing the generating form multiplies it by a meromorphic base +function. This changes both \(\alpha_D\) and \(\beta_D\) by its +normalized base order and leaves the comparison invariant. The local +comparisons therefore give the rational divisor and the line identity +globally. Equation~\eqref{rank:vertical-order} proves +Equation~\eqref{rank:zero-minimum}. Horizontally the comparison is +precisely the zero divisor of the fiberwise log section, so it is +effective and has the asserted restriction. + +The same order computation proves the relative injection. +In a divisible degree \(q\), a meromorphic base coefficient +\(\varphi\) gives a regular base section at \(D\) exactly when +\[ + \ord_D(\varphi)+q\alpha_D\geq0. +\] +Its corresponding upstairs orders at the primes \(E\to D\) are +\[ + a_E\ord_D(\varphi)+q(l_E+\delta_E). +\] +Their simultaneous nonnegativity is equivalent to the preceding +inequality. Conversely, an upstairs section restricts to a multiple +of the generator on general connected fibers, so its ratio with the +generator descends meromorphically to \(W\). The order inequalities +make it regular outside codimension two on \(W\), and normality +extends it. Consequently +\[ + g_*\OO_X(qJ)\ \lhook\joinrel\longrightarrow\ + \OO_W(qH). +\] +Applying the left exact functor \(h_*\) proves +Equation~\eqref{rank:relative-injection}. The reverse global +comparison follows from the reference property: its only initially +untested poles are on \(g\)-contracted primes, all exceptional over +\(X_0\); pushing to \(X_0\), extending in codimension two, and pulling +back with the reduced-exceptional boundary removes them. This is +the global comparison in \cite[Proposition~2.7]{CI}. + +Finally consider \(\tau:W'\to W\). The parabolic rational line pulls +back under SNC modifications, as in the construction preceding +\cite[Theorem~3.1]{CI}. The coefficient \(T_D\) at an old strict +transform is unchanged. Indeed the sheaf of regular relative +adjoint forms inside the common meromorphic generator line is +unchanged over the generic point of \(D\) by the log modification +formula. Equivalently, the old inequalities above already test all +vertical primes there; in SNC coordinates logarithmic pullback +preserves those inequalities, so new source exceptional primes +impose no stronger one. This keeps \(\alpha_D\) unchanged in +compatible frames, while parabolic pullback keeps \(\beta_D\) +unchanged. Over a new \(\tau\)-exceptional prime every source prime +is exceptional over \(X_0\): a pre-existing one had image of +codimension at least two on \(W\), and a new one is exceptional +by construction. All therefore have boundary coefficient one. +The formula for \(T_D=\alpha_D-\beta_D\) then gives coefficient one +on that new base prime. Thus +\[ + T'=\tau_*^{-1}T+\operatorname{Exc}(\tau)_{\mathrm{red}}. +\] +The usual log discrepancy formula for the SNC pair \((W,T)\) +now gives \(K_{W'}+T'=\tau^*(K_W+T)+E_H\), with \(E_H\) +effective and exceptional. Adding the pulled-back parabolic line +proves Equation~\eqref{rank:higher-base}. +\end{proof} + +\begin{lemma}[Pseudo-effectivity of the base line] +\label{rank:base-psef} +In the setting of Lemma~\ref{rank:comparison}, suppose +\(\dim X=n\), \(0<\dim W0\), Equation~\eqref{rank:first-nef-endpoint} preserves +the divisible section spaces. For \(\kappa(H)=k\) the nef +\(H_{\mathrm{nef}}\) is big, and the second alternative holds with +\(W_m=W_{\mathrm{nef}}\) and \(H_m=H_{\mathrm{nef}}\). If +\(0<\kappa(H)0\). For a rational \(c\in(0,1)\), put +\(H_c=K_W+T+cM\). We claim +\begin{equation} + H_c\ \text{is not pseudo-effective} + \quad(00\) for which \(H-\delta p^*U\) has an +effective representative, forcing \(\kappa(H)\geq\dim S>0\). +Choose a rational \(a>\max\{1,a_0\}\) and a small +rational \(\lambda>0\) such that \(K_S+aP_S-\lambda U\) is big. +This is possible because \(P_S\) is nef and +\(K_S+a_0P_S\) is big. Choose +\[ + 0<\eta<\lambda\frac{1-c}{a-1} + \quad\text{rational}. +\] +The rational line \(cP_S+\eta U\) is ample. A sufficiently high +general member divided by its degree pulls back to a rational +boundary transverse to \(T\) with subunit coefficient. Applying +the nonvanishing part of Proposition~\ref{proj:good-models} to +this ordinary projective log pair gives +\[ + E_c\sim_{\Q}H_c+\eta p^*U,\qquad E_c\geq0. +\] +A nonzero section defining \(E_c\) restricts nontrivially to very +general \(p\)-fibers in a fixed divisible degree. The hypotheses +of the weak-effectivity statement \cite[Lemma~3.3]{CI} are now +satisfied: the source is smooth in class \(\mathcal C\), \(T\) +is rational SNC, the base \(S\) is smooth projective, and a +relative log system is nonzero. Applied to the big line +\(K_S+aP_S-\lambda U\), it gives +\[ + E_a\sim_{\Q}K_W+T+aM-\lambda p^*U,\qquad E_a\geq0. +\] +For +\[ + \theta=\frac{1-c}{a-c},\qquad + \delta=\theta\lambda-(1-\theta)\eta>0, +\] +the rational interpolation is +\[ + (1-\theta)E_c+\theta E_a + \sim_{\Q}H-\delta p^*U. +\] +Multiplying pullbacks of sections of \(U\) by a section of the +effective left-hand side yields +\(\kappa(H)\geq\kappa(p^*U)=\dim S>0\). +This contradicts Equation~\eqref{rank:nontrivial-nef-data} and +proves Equation~\eqref{rank:lowered-nonpsef}. + +We next run a program to fiber type while descending the actual nef line +\(H_{\mathrm{nef}}\) through every contraction. Choose the common +resolution in Equation~\eqref{rank:first-nef-endpoint} to determine the nef +data. The negativity lemma gives +\[ + F_M:=\sigma^*M_{\mathrm{nef}}-\mu^*M\geq0 + \quad\text{\(\sigma\)-exceptional}. +\] +Indeed its negative is \(\sigma\)-nef and exceptional. For every +rational \(00\) with +\(rH_{\mathrm{nef}}\) Cartier, and choose an integer \(d_0>2kr\). +This coefficient will force every ray of the second program to have zero +degree for the descended nef line. Decreasing the nef data to +\((1-\varepsilon)\boldsymbol M\) preserves generalized dlt +singularities: on the displayed resolution the crepant boundary +changes by \(-\varepsilon F_M\), so discrepancies do not decrease. +Add \(d_0H_{\mathrm{nef}}\), determined as nef data on +\(W_{\mathrm{nef}}\). It changes no discrepancies, and the resulting +adjoint is +\[ + (1+d_0)H_{\mathrm{nef}}-\varepsilon M_{\mathrm{nef}} + =(1+d_0)\left( + H_{\mathrm{nef}}-\frac{\varepsilon}{1+d_0}M_{\mathrm{nef}}\right). +\] +It is not pseudo-effective by the preceding paragraph. The +non-pseudo-effective case of Proposition~\ref{proj:generalized-mmp} +therefore gives a chosen terminating program to a Mori fiber +contraction in the \(\Q\)-factorial generalized dlt category. + +At any stage of this second program, let \(H_i\) be the descended rational +line, assuming inductively that it is nef and \(rH_i\) is Cartier, and write +\[ + G_i=K_{W_i}+T_i+(1-\varepsilon)M_i. +\] +An extremal ray negative for \(G_i+d_0H_i\) is negative for \(G_i\). +The pair with adjoint \(G_i\) is still generalized dlt: the added +nef b-divisor \(d_0H_i\) descends to the current model, so removing +it changes no discrepancy. The generalized length bound +\cite[Proposition~3.13]{HanLi} gives a curve \(C\) +on that ray with \(0<-G_i\cdot C\leq2k\). If \(H_i\cdot C>0\), +Cartier integrality would give +\[ + \frac{d_0}{r}\leq d_0H_i\cdot C + <-G_i\cdot C\leq2k, +\] +a contradiction. Thus \(H_i\cdot C=0\). +The exact contraction statement \cite[Theorem~1.5]{Xie2022} +descends the Cartier line \(rH_i\) along this contraction as an +actual Cartier line. In a flip we pull that same line to the +flipped side. The descended line is nef: every curve on the +contraction base has a curve above it mapping with positive degree, +so its degree is nonnegative; pullback preserves nefness. +Consequently \(r\) and nefness persist, and the argument applies +inductively to all steps and to the final contraction. Each step +is crepant for \(H_i\). + +Let \(W_m\) be the last birational model of this second program and let +\(H_m\) be the descended line on it. Crepancy for the \(H_i\), together +with the absence of extraction, turns +Equation~\eqref{rank:first-nef-endpoint} into +Equation~\eqref{rank:base-endpoint} on a common resolution, with an +effective divisor exceptional over \(W_m\). +The final contraction \(h:W_m\to V\) has connected fibers and, +by the same exact descent, +\[ + H_m\sim_{\Q}h^*H_V +\] +for a rational line \(H_V\) on the normal projective \(V\). +If \(V\) is a point, the second alternative holds with +\(H_m\sim_{\Q}0\). + +Assume \(\dim V>0\). To obtain the first alternative, it remains to show +that the log adjoint on the new very general fibers has Kodaira dimension +zero. Resolve the base program by +\(\mu:W''\to W\) and \(\nu:W''\to W_m\), and prepare the source +over \(W''\), calling it \(g'':(X'',B'')\to W''\). The diagram +we use is +\[ +\begin{tikzcd} + X'' \arrow[r,"g''"] & W'' \arrow[r,"\nu"] \arrow[d,"\mu"'] & + W_m \arrow[r,"h"] & V\\ + & W +\end{tikzcd} +\] +with composite \(f= h\nu g''\). +Equation~\eqref{rank:higher-base} and +Equation~\eqref{rank:base-endpoint} give +\[ + H''\sim_{\Q}\nu^*H_m+E'', + \qquad E''\geq0\ \text{\(\nu\)-exceptional}. +\] +To see the exceptionality, the error in +Equation~\eqref{rank:base-endpoint} is already exceptional over +\(W_m\), and every \(\mu\)-exceptional prime is exceptional +over \(W_m\) as well: otherwise \(W_m\) would extract a divisor +over \(W\). +For every degree divisible by one fixed integer, +Equation~\eqref{rank:relative-injection}, exceptional descent, +and projection formula now yield +\begin{align*} + f_*\OO_{X''}(q(K_{X''}+B'')) + &\lhook\joinrel\longrightarrow + (h\nu)_*\OO_{W''}(qH'')\\ + &=h_*\OO_{W_m}(qH_m)=\OO_V(qH_V). +\end{align*} +Here \(\nu_*\OO_{W''}(qE'')=\OO_{W_m}\) by normality and +\(h_*\OO_{W_m}=\OO_V\). Generic coherent base change, +simultaneously for the countably many divisible degrees, bounds +the dimension of every such system on a very general \(f\)-fiber +by one. The log adjoint on that fiber is pseudo-effective by +restriction of a countable sequence of perturbed currents with +analytic singularities. Its dimension is less than \(n\), so +the lower-dimensional \(\Ggood\) supplies a nonzero section in +some divisible degree. Taking a common multiple shows that the +fiber log Kodaira dimension is zero. All maps in the composite +have connected fibers; resolving \(V\) and the source keeps this +property and gives a smooth projective base of dimension +\(0<\dim V0\), since at least one component of +\(Q\) has image dimension \(l\). Thus \(Q\) is not in the radical, +and its square is strictly negative, contrary to +Equation~\eqref{rank:nonnegative-square}. + +It remains to treat \(l=k-1\). Terms from primes whose image has +smaller dimension vanish in this form, as do cross terms from +different divisorial images. Fix a prime divisor \(D\subset Y\) +and take all the primes \(E_1,\ldots,E_s\subset X\) dominating it. +Write \(a_i=\ord_{E_i}(b^*D)>0\) and +\(C_{ij}=\langle E_i,E_j\rangle_{k-1}\). +The divisor \(D\) is rational Cartier, also when \(Y=W_m\). +Consequently +\[ + C_{ij}\geq0\ (i\ne j),\qquad + \sum_j C_{ij}a_j=0. +\] +The first assertion is positivity of the proper intersection of +distinct effective primes. The second pairs \(E_i\) with the +pulled-back divisor \(D\); the additional base factor makes the +intersection vanish by dimension. Components of \(b^*D\) +mapping into a proper subset of \(D\) make no contribution. +The graph with edges \(C_{ij}>0\) is connected. Indeed over a +very general point of \(D\) the fiber is connected, all its points +lie in the components \(E_i\), and an intersection contributes a +positive entry precisely when it dominates \(D\). + +For any real vector \(x=(x_i)\), the two displayed properties give +the exact identity +\[ + x^{\mathsf T}Cx + =-\sum_{i1\) for which +\(uL|_{D_Z}\) is generated, and consider the integral line +\begin{equation} + \mathscr N + :=\OO_U(u\ell+E-C) + =\OO_U\bigl(K_U+\Delta_F+(u-1)\ell\bigr). +\label{rank:vanishing-line} +\end{equation} +Although the expression on the right uses rational divisors, its +sum is the integral line on the left. The restriction sequence is +\[ + 0\longrightarrow\mathscr N + \longrightarrow\OO_U(u\ell+E) + \longrightarrow\OO_C(u\ell+E)\longrightarrow0. +\] +The direct image of the last sheaf is supported on the proper analytic +subset \(f(C)\), so it is torsion. Consequently, the two assertions +\begin{equation} + R^1f_*\mathscr N\ \text{torsion-free}, + \qquad H^1(Y,f_*\mathscr N)=0 +\label{rank:vanishing} +\end{equation} +will give surjectivity on global sections: torsion-freeness makes the +connecting map to \(R^1f_*\mathscr N\) zero, and the \(H^1\)-vanishing +then removes the obstruction to lifting a global section. + +We prove Equation~\eqref{rank:vanishing} using analytic injectivity. +Equation~\eqref{rank:big-pullback} identifies +\(\mathscr N\otimes K_U^{-1}\) with +\(\Delta_F+(u-1)f^*H_Y\) in \(\Pic(U)\otimes\Q\); this comparison +need not be an isomorphism of the corresponding integral lines. Fix a +very ample line \(A_Y\) on \(Y\) and its Fubini--Study metric. +A Kodaira decomposition of the big nef \(H_Y\), given arbitrarily +small weight as in the proof of Lemma~\ref{rank:lift}, writes +\((u-1)H_Y\) as a positive rational multiple of \(A_Y\) plus +an effective rational divisor whose fixed singular contribution +is arbitrarily small and whose remaining contribution is a +general divided ample member. Choose the small weight below +the log canonical threshold of its pullback relative to the +klt SNC boundary \(\Delta_F\), and choose the ample member generally. +Then the resulting boundary on \(U\) is klt. Choose a positive +integer \(q_0\) clearing all its denominators and realizing both the +chosen Kodaira decomposition and the preceding rational-line comparison +as line isomorphisms, in particular +\[ + (\mathscr N\otimes K_U^{-1})^{\otimes q_0} + \simeq \OO_U(q_0\Delta_F)\otimes + f^*\OO_Y\bigl(q_0(u-1)H_Y\bigr). +\] +The divisor metrics and the Fubini--Study metric +define a singular Hermitian metric on +\((\mathscr N\otimes K_U^{-1})^{\otimes q_0}\). Its \(q_0\)-th +root is a metric on the actual line \(\mathscr N\otimes K_U^{-1}\), +with multiplier ideal \(\OO_U\) and curvature dominating a positive +multiple of the pullback Fubini--Study form. The same statements hold after every +nonnegative twist by \(f^*A_Y\). + +The injectivity theorem \cite[Theorem~A]{FujinoMatsumura} applies +on the compact Kähler \(U\): multiplication by the pullback of +any nonzero section of a positive power of \(A_Y\) is injective +on +\[ + H^1(U,\mathscr N\otimes f^*A_Y^j) + \quad(j\geq0) +\] +into the correspondingly higher twist. Its assumptions are +exactly the semipositive smooth metric on the multiplying line, +the preceding positive lower curvature bound, and the trivial +multiplier ideal. +This injectivity implies Equation~\eqref{rank:vanishing}. +For the second assertion, the Leray edge map injects +\(H^1(Y,f_*\mathscr N)\) into \(H^1(U,\mathscr N)\). +Multiplication by a section of a sufficiently high \(A_Y\)-power +sends this subspace to zero, since Serre vanishing kills +\(H^1(Y,f_*\mathscr N\otimes A_Y^j)\) for large \(j\). +Injectivity upstairs forces the original subspace to be zero. +For the first assertion, suppose \(R^1f_*\mathscr N\) has a +nonzero torsion subsheaf. A section of a sufficiently high +power of \(A_Y\) annihilates a nonzero such subsheaf. +After a further sufficiently large twist it has a nonzero +global section, and Serre vanishing and Leray identify that +section with a nonzero class in +\(H^1(U,\mathscr N\otimes f^*A_Y^j)\). +Multiplication annihilates this class, again contradicting +injectivity. This proves both assertions. + +The resulting surjectivity extends the floor sections as follows. +Pull any section of \(uL|_{D_Z}\) +to \(C\), multiply by the canonical section of \(E|_C\), and +extend by this surjectivity. The extended section descends to +\(Z\), since \(r_*\OO_U(E)=\OO_Z\) by exceptionality and +normality. On the strict transforms of the components of +\(D_Z\), division by the canonical section of \(E\) recovers +the prescribed section. The descended restriction therefore +equals it on the whole reduced \(D_Z\), since equality holds +generically on every component. Since \(uL|_{D_Z}\) is generated, +this proves Equation~\eqref{rank:floor-avoidance}. + +We finish by showing that this stable base locus is empty. The +base loci of factorial Cartier multiples form a descending +sequence of compact analytic subsets and hence stabilize. +Sections exist because \(H_Y\) is big and +Equation~\eqref{rank:big-pullback} descends their pullbacks. +Choose a divisible degree \(v\) whose base locus is +\(\mathbf B(L)\), and let \(\mathfrak b\) be its base ideal. +If \(\mathbf B(L)\ne\varnothing\), the ideal is a unit near +\(D_Z\), while \((Z,\Delta_Z)\) is klt outside \(D_Z\). +Its log canonical threshold +\[ + t=\operatorname{lct}_{(Z,\Delta_Z)}(\mathfrak b) +\] +is therefore a positive rational number, attained by a divisor +whose center is contained in \(\mathbf B(L)\). +This follows directly on a simultaneous log resolution of the +pair and the ideal: the threshold is the minimum of the positive +rational discrepancies divided by the positive integral ideal +orders. + +Choose an integer \(s>t\) and general divisors +\(D_1,\ldots,D_s\in|vL|\). On the same resolution their fixed +part is the divisor of \(\mathfrak b\); their free transforms +are jointly transverse to the SNC data. Hence +\[ + \left(Z,\ \Delta_Z+\frac{t}{s}\sum_{i=1}^s D_i\right) +\] +is log canonical: the fixed part is at its log canonical +threshold and the free components have coefficients \(t/s<1\). +There is a new lc place centered in \(\mathbf B(L)\), and the +new adjoint satisfies the actual identity +\[ + L_{\mathrm{new}}\sim_{\Q}(1+tv)L. +\] +Apply \cite[Theorem~3.3]{HLX} to this compact Kähler lc rational +pair. It gives a projective strongly \(\Q\)-factorial dlt +modification \(d:Z'\to Z\). Since the pair is lc, all extracted +divisors have log discrepancy zero in our convention, so the +modification is crepant. The source is again compact Kähler. +Choose its defining dlt log resolution, with exceptional crepant +coefficients strictly below one and an isomorphism at the general +point of every lc stratum; resolving the remaining data away from +those points gives the resolution required by +Definition~\ref{def:lc-strata-resolution}. The floor on \(Z'\) has a point over the center +of this lc place, hence over \(\mathbf B(L)\). +The new nef adjoint is \(d^*L_{\mathrm{new}}\). On a common +resolution with \(U\), it satisfies +Equation~\eqref{rank:big-pullback} with the big nef line +\((1+tv)H_Y\). The previously proved assertion +\eqref{rank:floor-avoidance} therefore makes its stable base locus +disjoint from its floor. On the +other hand, normality and projection formula identify all +divisible sections under \(d\), and give +\[ + \mathbf B(d^*L_{\mathrm{new}}) + =d^{-1}\mathbf B(L). +\] +This locus contains the stated floor point, a contradiction. +Thus \(\mathbf B(L)=\varnothing\); factorial stabilization +provides an actual globally generated multiple of \(L\). +\end{proof} + +\subsection{Completion of the rank-one case} + +\begin{proof}[Proof of Proposition~\ref{rank:rank-one}] +By Proposition~\ref{bir:resolution-transfer} we can begin on the +resolved source in the statement. We use a secondary induction on +the positive base dimension \(k\). Apply +Lemma~\ref{rank:comparison} and then Lemma~\ref{rank:base-psef} +to obtain the prepared data and the pseudo-effective line \(H\). + +If \(a(W)=0\), Lemma~\ref{rank:zero-base} and the first case of +Lemma~\ref{rank:lift} give +\(J\sim_{\Q}N(J)\), which is already the required decomposition +with trivial positive part. If \(W\) is projective, apply +Lemma~\ref{rank:base-reduction}. Its first alternative has a +strictly smaller positive base dimension, so the secondary induction +and birational transfer finish the proof. In its second alternative, +take a common smooth base resolution in +Equation~\eqref{rank:base-endpoint} and prepare the source over it. +Equation~\eqref{rank:higher-base} adds an effective divisor +exceptional over the old base. It is also exceptional over \(W_m\), +because the base program extracted no divisors. Thus the second +case of Lemma~\ref{rank:lift} applies. + +We have obtained +\[ + J\sim_{\Q}P_0+A,\qquad A=N(J)\geq0, +\] +with \(P_0\) nef. A rationally trivial \(P_0\) finishes the proof. +In the remaining case \(P_0=b^*H_m\), where \(b:X\to W_m\) +is proper and \(H_m\) is big and nef on the projective \(W_m\). +Apply Proposition~\ref{prog:contract-negative} to this +nef-plus-negative presentation. It gives a globally strongly +\(\Q\)-factorial dlt compact Kähler model \((Z,\Delta_Z)\) with nef +adjoint \(L_Z\). The ordinary dlt endpoint has the resolution property +of Definition~\ref{def:lc-strata-resolution}. On a common smooth resolution +\(\mu:U\to X\), \(r:U\to Z\) its exact positive-line comparison is +\[ + r^*L_Z\sim_{\Q}\mu^*P_0 + =(b\mu)^*H_m . +\] +Proposition~\ref{rank:big-nef-generation} makes \(L_Z\) semiample. +Hence \(\mu^*P_0\) is semiample. Lemma~\ref{bir:pullup} identifies +\(\mu^*A=N(\mu^*J)\), so this is precisely \(\Ggood_n\) on \(U\). +Finally Proposition~\ref{bir:resolution-transfer} transfers the +decomposition back through all the prepared source modifications. +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/06-simple-nonvanishing.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/06-simple-nonvanishing.tex new file mode 100644 index 0000000000000000000000000000000000000000..663be46ff6a9b1f6a2a388066a158669f6447932 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/06-simple-nonvanishing.tex @@ -0,0 +1,1427 @@ +\section{Meromorphic nonvanishing on simple spaces}\label{sec:nonvanishing} + +The simple case of the induction needs a divisor representing a multiple of +the canonical bundle; its coefficients need not be nonnegative. The +following result supplies precisely this starting point. + +\begin{theorem}\label{nv:meromorphic} +Let \(X\) be a smooth connected compact Kähler manifold. Suppose that +\(a(X)=0\) and that no positive-dimensional proper compact analytic +subvariety passes through a very general point of \(X\). Then +\(K_X^{\otimes m}\) has a nonzero meromorphic section for some integer +\(m>0\). +\end{theorem} + +The proof compares two ways of measuring poles. After normalizing a big +class on \(X\) to have volume one, its pole order at a very general point is +bounded. We construct a projective bundle over \(X^2\) whose volume grows +linearly with a parameter \(q\). Restriction to the exceptional divisor of +the diagonal in the square of this bundle then produces a high-rank +subsheaf of a symmetric cotangent power. A second diagonal forces +substantial vanishing of its determinant; descending that determinant +produces a point pole of order comparable to +\(q^{1/(2\dim X+1)}\), contradicting the point bound. +The argument uses only meromorphic sections of line bundles; it does not +require nonconstant meromorphic functions on \(X\). + +For the proof, suppose that the conclusion fails. Write +\[ + n=\dim X,\qquad \mathscr L=K_X,\qquad L=c_1(\mathscr L) + \in H^{1,1}_{\BC}(X,\R). +\] +We may assume \(n\ge2\): a compact complex curve is projective, and the +assertion for a point is immediate. Throughout this Section, an inequality +between real \((1,1)\)-classes is in pseudo-effective order: +\(\alpha\le\beta\) means that \(\beta-\alpha\) is pseudo-effective. For a +divisor \(D\), \(\{D\}\) denotes \(c_1(\OO(D))\). Pullbacks of classes will +occasionally be suppressed when the map is evident. + +\subsection{Line subsheaves and point poles} + +We first record the consequence of simplicity that controls all the +determinant lines used below. + +\begin{lemma}\label{nv:slope} +Under the contrary hypothesis above, \(H^1(X,\OO_X)=0\), the group +\(\Pic(X)\) is countable, and \(L\ge0\). If \(\mathscr H\) is a holomorphic +line bundle and +\(\mathscr H\longrightarrow\Omega_X^{\otimes k}\) is nonzero, where +\(k\ge0\), then +\begin{equation}\label{nv:slope-X} + c_1(\mathscr H)\le kL . +\end{equation} +There is a complement of a countable union of proper analytic subsets of +\(X\) with the following further property. For every point \(x\) in this +complement, let +\[ + a:Y=\Bl_xX\longrightarrow X,\qquad F=a^{-1}(x). +\] +Every nonzero line map +\(\mathscr H_Y\longrightarrow (a^*\Omega_X)^{\otimes k}\) satisfies +\begin{equation}\label{nv:slope-blowup} + c_1(\mathscr H_Y)\le k a^*L . +\end{equation} +\end{lemma} + +\begin{proof} +If the Albanese map of \(X\) is nonconstant, simplicity makes its image +\(n\)-dimensional: a positive-dimensional general fiber of smaller +dimension would be a forbidden subvariety. At a point where the Albanese +map has rank \(n\), some \(n\) invariant one-forms have nonzero wedge after +pullback. This gives a nonzero holomorphic section of \(K_X\), contrary to +our assumption. Thus \(H^1(X,\OO_X)=0\). The exponential sequence embeds +\(\Pic(X)\) into the countable group \(H^2(X,\Z)\). + +The manifold \(X\) is not uniruled, by simplicity. Ou's +non-pseudo-effectivity criterion for the canonical class therefore gives +\(L\ge0\) \cite[Theorem~1.1]{Ou2025}. We recall how the slope and foliation +results in the same paper give the more precise inequality in +Equation~\eqref{nv:slope-X}. Let \(\gamma\) be any class in the full dual of the +pseudo-effective cone, and use the slope +\[ + \mu_\gamma(\mathscr E) + =\frac{c_1(\mathscr E)\cdot\gamma}{\rk\mathscr E} +\] +for torsion-free sheaves. If +\(\mu_{\gamma,\min}(\Omega_X)<0\), the first Harder--Narasimhan piece +\(\mathscr T\subset T_X\) has strictly positive slope. It is saturated and +semistable. The tensor slope inequality shows that the bracket +\(\bigwedge^2\mathscr T\to T_X/\mathscr T\) is zero: the minimum slope of +its source is at least \(2\mu_\gamma(\mathscr T)\), whereas the maximum +slope of its target is smaller than \(\mu_\gamma(\mathscr T)\). +Consequently \(\mathscr T\) is a foliation. Its dual has strictly negative +maximum slope and is not pseudo-effective by +\cite[Proposition~4.5]{Ou2025}. Ou's foliation theorem +\cite[Theorem~1.4]{Ou2025} makes this foliation the tangent foliation of a +meromorphic fibration with compact general leaf closures. Its rank is strictly +between zero and \(n\): rank \(n\) would give +\(\mu_\gamma(T_X)=-L\cdot\gamma/n\le0\). The general leaf closure is +therefore a positive-dimensional proper subvariety through a general +point, again contradicting simplicity. + +We have proved \(\mu_{\gamma,\min}(\Omega_X)\ge0\). In its +Harder--Narasimhan filtration all quotient slopes are now nonnegative, so +\(\mu_{\gamma,\max}(\Omega_X)\le L\cdot\gamma\). The tensor slope +inequality \cite[Lemma~4.4]{Ou2025} gives +\[ + c_1(\mathscr H)\cdot\gamma + \le \mu_{\gamma,\max}(\Omega_X^{\otimes k}) + \le kL\cdot\gamma . +\] +Separation by the dual cone proves Equation~\eqref{nv:slope-X}. For \(k=0\) this is +also immediate from the effective zero divisor of a nonzero map +\(\mathscr H\to\OO_X\). + +It remains to choose \(x\) uniformly. For any vector bundle +\(\mathscr V\), independent global sections are generically pointwise +independent. Indeed, choose a maximal pointwise independent subfamily on +a dense open set. Expressing any other section in that family by minors +gives meromorphic function coefficients. They are constant because +\(a(X)=0\), so maximality among a linearly independent family forces all +its members to be pointwise independent. Thus evaluation on +\(H^0(X,\mathscr V)\) is injective away from a proper analytic subset +(unless that vector space is zero, in which case there is no restriction). +Apply this to +\(\mathscr V=\mathscr H^{-1}\otimes\Omega_X^{\otimes k}\) for every +\(\mathscr H\in\Pic(X)\) and \(k\ge0\). There are countably many such +bundles. + +For \(x\) outside the resulting exceptional set, write any line bundle on +\(Y=\Bl_xX\) uniquely as +\(a^*\mathscr H\otimes\OO_Y(mF)\), \(m\in\Z\). A line map from this bundle +to \((a^*\Omega_X)^{\otimes k}\), restricted away from \(F\), extends over +\(x\) to a section of +\(\mathscr H^{-1}\otimes\Omega_X^{\otimes k}\) by Hartogs' theorem. If +\(m>0\), this section vanishes at \(x\), since +\(a_*\OO_Y(-mF)=\mathcal I_x^m\). The choice of \(x\) rules this out. +Thus \(m\le0\), and Equation~\eqref{nv:slope-X} yields +\[ + c_1(a^*\mathscr H\otimes\OO_Y(mF)) + \le k a^*L+m\{F\}\le k a^*L. +\] +If a target has a finite filtration whose graded pieces are direct sums +of the indicated cotangent tensors, take the first nonzero associated +graded component of the line map and then a nonzero direct-sum component. +The preceding argument applies with the tensor order of that component. +\end{proof} + +We will use several standard facts about volumes of real \((1,1)\)-classes. +Our normalization is \(\vol(\alpha)=\int\alpha^e\) for a nef class on an +\(e\)-fold. Volume is continuous, homogeneous, monotone in +pseudo-effective order, invariant under modification, and its \(e\)-th +root is concave on the big cone. Analytic Fujita approximation computes +it by Kähler parts on smooth projective modifications. Here a +\emph{smooth projective modification} means a projective modification +whose source is smooth; the sources used here are compact Kähler +manifolds obtained by resolving coherent analytic ideals. For a smooth +irreducible divisor \(D\) and a big class \(\alpha\), write +\(\operatorname{vol}_{\,|D}(\alpha)\) for the numerical restricted volume. +It is zero when \(D\) is contained in the non-Kähler locus +\cite[Theorem~1.1]{Vu2023}; otherwise it is +the supremum of the masses on \(D\) of restrictions of Kähler currents +with analytic singularities that are not generically singular on \(D\) +\cite[Lemma~2.7]{CollinsTosatti2018}. The divisorial derivative and its +continuity on the big cone are +\begin{equation}\label{nv:volume-derivative} + \frac{\dd}{\dd u}\vol(\alpha-u\{D\}) + =-e\,\operatorname{vol}_{\,|D}(\alpha-u\{D\}); +\end{equation} +see \cite[Theorem~1.1]{Vu2023}. We apply this formula only on smooth +manifolds while the varying class is big. + +Here is a useful precise form of the approximation in the restricted +volume formula. Resolve the log-ideal singularities of a current +restricted to \(D\). Its pullback is an effective real divisor plus a +positive residual current with locally bounded potentials. The latter +dominates a positive multiple of the pulled-back Kähler form. A current +with locally bounded potentials has zero Lelong numbers, so Demailly +regularization makes its class, after subtracting that multiple, nef +\cite[Theorem~1.1]{DemaillyRegularization1992}. +On a projective modification there is an effective exceptional divisor +whose negative is relatively ample. Subtracting a sufficiently small +multiple of this divisor from the residual class therefore makes that +class Kähler; add the same multiple to the divisor part. Round all +divisor coefficients slightly upwards to rational numbers. Openness of +the Kähler cone preserves the Kähler property. These changes can be +arbitrarily small in top intersections, which compute the original mass +by the bounded-potential product formula. Thus we may approximate a +restricted mass by +\begin{equation}\label{nv:rational-fujita} + h^*(\alpha|_D)=\beta+\{D'\},\qquad + \beta\ \text{Kähler},\quad D'\ge0\ \text{a rational divisor}. +\end{equation} +Moreover, \(D'\) has at least the log-ideal orders of the original +restriction on every further resolution. We will use this last +property to turn poles into vanishing conditions. Only \(D'\) is made +rational; the class \(\beta\) and the horizontal part of \(\alpha\) remain +real. + +\begin{lemma}[A point pole bound]\label{nv:pole-threshold} +Let \(W\) be a smooth compact Kähler manifold of dimension \(e\ge2\), +\(\alpha\) a big real \((1,1)\)-class, and \(z\in W\). Suppose a smooth +projective modification \(\mu:W'\to W\), which is an isomorphism near +\(z\), admits a decomposition +\[ + \mu^*\alpha=K+\{D\},\qquad K\ \text{Kähler},\quad D\ge0, +\] +where \(D\) misses the point \(z'\) over \(z\). If the ordinary analytic +Seshadri constant \(\epsilon(K,z')\) is at least \(\eta>0\), then, on the +blowup \(b:\widehat W=\Bl_zW\to W\) with exceptional divisor \(G\), +\begin{equation}\label{nv:pole-formula} + \sup\{u\ge0:b^*\alpha-u\{G\}\ge0\} + \le \frac{\eta}{2} + +2^{e-1}\vol(\alpha)\eta^{-(e-1)} . +\end{equation} +\end{lemma} + +\begin{proof} +Set \(u_0=\eta/2\). Blowing up \(z'\), the class +\(K-u_0\{G'\}\) is Kähler. The Fujita decomposition is unchanged near +\(G'\), so it supplies a Kähler current for +\(\alpha_{u_0}=b^*\alpha-u_0\{G\}\) that is smooth near \(G\). +Its restriction there has class \(u_0c_1(\OO_{\PP^{e-1}}(1))\). +The restricted volume is consequently \(u_0^{e-1}\): the current gives +this lower bound, and the volume of the restricted class gives the +opposite bound. + +Let \(\tau\) denote the left side of Equation~\eqref{nv:pole-formula}. The classes +\(\alpha_u=b^*\alpha-u\{G\}\) are big for \(0\le u<\tau\), since +\(\alpha_0\) is big and the pseudo-effective cone is convex. The +concave function \(f(u)=\vol(\alpha_u)^{1/e}\) satisfies, by +Equation~\eqref{nv:volume-derivative}, +\[ + f'(u_0)=-\frac{u_0^{e-1}}{f(u_0)^{e-1}}. +\] +Its tangent line at \(u_0\) must remain positive up to \(\tau\). +Therefore +\[ + \tau\le u_0+\frac{f(u_0)^e}{u_0^{e-1}} + \le u_0+\frac{\vol(\alpha)}{u_0^{e-1}}, +\] +which is Equation~\eqref{nv:pole-formula}. +\end{proof} + +Fix a Kähler class \(\omega\) on \(X\). The class \(L\) is not big: +a big holomorphic line bundle would make \(X\) Moishezon, contrary to +\(a(X)=0\). For \(t>0\) define +\begin{equation}\label{nv:normalization} + P=r(L+t\omega),\qquad + r=\vol(L+t\omega)^{-1/n}. +\end{equation} +Then \(P\) is a big real class, \(\vol(P)=1\), \(L\le P/r\), and +\(r\to\infty\) as \(t\downarrow0\). Choose a smooth Fujita model +\(\mu:Y_P\to X\) with Kähler part \(P'\) satisfying +\begin{equation}\label{nv:P-prime} + \mu^*P=P'+\{D_P\},\qquad v:=\int_{Y_P}(P')^n>\frac12. +\end{equation} +At a very general point \(y\) of this model there is no +positive-dimensional proper subvariety: its image would be one through a +very general point of \(X\), and \(y\) avoids the exceptional locus. +The ordinary Seshadri formula for a Kähler class, +\[ + \epsilon(K,y) + =\inf_{\substack{W\ni y\\ \dim W>0}} + \left(\frac{\int_W K^{\dim W}} + {\operatorname{mult}_y W}\right)^{1/\dim W}, +\] +therefore gives \(\epsilon(P',y)=v^{1/n}\ge2^{-1/n}\). +This is the ordinary nef/Kähler formula +\cite[Theorem~2.8]{Tosatti2016}; see also +\cite[Equation~(1.5)]{CollinsTosatti2018} and the +Kähler cone criterion of \cite{DemaillyPaun2004}. We use this ordinary +formula in both applications below. Lemma~\ref{nv:pole-threshold}, with +\(\vol(P)=1\), now yields a constant \(C_n\) depending only on \(n\) +such that, for a very general \(x\), +\begin{equation}\label{nv:point-bound} + \tau(P,x):=\sup\{u\ge0:a^*P-u\{F\}\ge0\}\le C_n, + \qquad a:\Bl_xX\to X. +\end{equation} +Here and below positive constants denoted \(c_n,C_n\) may be decreased or +increased from one occurrence to the next. They are independent of all +parameters and choices of currents and modifications. + +\subsection{A projective bundle with controlled volume} + +We now produce a class whose volume grows, while its point pole threshold +grows much more slowly. On \(X^2\), let \(\mathscr L_i\) and \(L_i\) +denote the pullbacks of \(\mathscr L\) and \(L\) from the \(i\)-th factor. +Use the quotient convention and put +\[ + \pi:Z=\PP_{X^2}(\mathscr L_1\oplus\mathscr L_2)\longrightarrow X^2, + \qquad \xi=c_1(\OO_Z(1)),\qquad d=\dim Z=2n+1 . +\] +Thus \(\pi_*\OO_Z(m)=\Sym^m(\mathscr L_1\oplus\mathscr L_2)\) for +\(m\ge0\). The zero divisor \(A_i\) of +\(\pi^*\mathscr L_i\to\OO_Z(1)\) has class \(\xi-L_i\); it is the +section on which \(\xi\) restricts to \(L_{3-i}\). In particular +\(\xi=\{A_i\}+L_i\ge0\). + +\begin{lemma}\label{nv:subvarieties} +For \(X\) and \(Z\) above, assume that \(K_X^{\otimes m}\) has no nonzero +meromorphic section for every integer \(m>0\). +Through a very general point of \(X^2\), the only positive-dimensional +proper compact irreducible analytic subvarieties are the two factor +slices. Through a very general point of \(Z\), the only +positive-dimensional compact irreducible analytic subvarieties are a +fiber of \(\pi\), the full inverse images of the two factor slices, and +\(Z\) itself. +\end{lemma} + +\begin{proof} +Let \(C\subset X^2\) be irreducible through a pair whose coordinates are +very general in \(X\). Each projection image is a point or all of \(X\), +by properness and simplicity. If exactly one is a point, \(C\) is the +corresponding full slice. If both projections are surjective, test their +fibers at a general point of \(C\) whose coordinates are still very +general. A positive-dimensional fiber must be the full other factor. +Thus either \(C=X^2\), or \(\dim C=n\) and both projections are +generically finite. + +We show that subvarieties of the latter kind cannot sweep \(X^2\). +The space of compact \(n\)-cycles on a compact Kähler manifold has +countably many irreducible components, each compact +\cite[Theorem~1.1]{LiebermanCycles}. On a component containing integral cycles +generically finite over both factors, integrality holds on a dense open +set and the two projection degrees remain positive, as can also be +tested by intersection with pulled-back Kähler forms. Suppose the +incidence over one such component dominates \(X^2\). Resolve the +parameter space and the dominating incidence component, obtaining maps +\[ + h:\mathcal Y\longrightarrow\mathcal S,\qquad + F_i:\mathcal Y\longrightarrow X +\] +between smooth spaces. For general \(t\in\mathcal S\), the fiber +\(Y_t=h^{-1}(t)\) is smooth, compact, and bimeromorphic to the integral +cycle, hence irreducible. Its maps \(f_i=F_i|_{Y_t}:Y_t\to X\) are +generically finite. Choose \(t\) also so that \(Y_t\) meets the dense +open set where \(d(F_1,h)\) is invertible and \(d(F_1,F_2)\) has rank +\(2n\). The first assertion follows from generic finiteness of \(f_1\), +and the second from the assumed dominance in \(X^2\). + +Our immediate aim is to turn this dominance into a meromorphic frame of +\(f_2^*T_X\). Its determinant would meromorphically trivialize +\(f_2^*K_X^{-1}\), and hence also \(f_2^*K_X\). +On \(Y_t\), the equal-rank bundle map +\[ + d(F_1,h)|_{Y_t}:T_{\mathcal Y}|_{Y_t} + \longrightarrow f_1^*T_X\oplus + (\OO_{Y_t}\otimes T_t\mathcal S) +\] +has a meromorphic inverse, given by its adjugate and determinant. +For fixed \(v\in T_t\mathcal S\), apply this inverse to \((0,v)\) +and then apply \(dF_2\). The result is a meromorphic section of +\(f_2^*T_X\). At a general point where \(d(F_1,F_2)\) has rank +\(2n\), the resulting map \(T_t\mathcal S\to f_2^*T_X\) is +surjective: in local coordinates \((F_1,h)\), it is the derivative +of \(F_2\) in the parameter directions with \(F_1\) fixed. Choose +\(n\) fixed vectors \(v_i\) whose values there are independent. +Their wedge is a nonzero meromorphic section of \(f_2^*K_X^{-1}\) +on the irreducible \(Y_t\); its inverse trivializes \(f_2^*K_X\) +meromorphically. + +Factor the proper generically finite map \(f_2\) as +\[ + Y_t\longrightarrow \overline Y_t + \xrightarrow{\nu}X +\] +by Stein factorization. Here \(\overline Y_t\) is normal and irreducible, the first +map is a modification, and \(\nu\) is finite of degree \(N>0\). +Meromorphic sections descend across a modification of a normal +space, so the section descends to a nonzero meromorphic section of +\(\nu^*K_X\). Lemma~\ref{bir:finite-norm} gives a nonzero meromorphic +section of \(K_X^{\otimes N}\). This norm is defined in local finite +analytic fraction algebras, so it remains available even though the +global meromorphic function field of \(X\) is just \(\C\). It +contradicts our assumption. + +Consequently the incidence image of each such cycle component is a +proper compact analytic subset of \(X^2\). There are only countably +many components, so their union misses a very general pair. This +proves the assertion for \(X^2\). + +Now let \(W\subset Z\) be irreducible through a very general point. +Its image is a point, a full factor slice, or \(X^2\). If its generic +relative dimension is one, it is the full inverse image of that +image. Otherwise it is a multisection of the restricted +\(\PP^1\)-bundle. Over a slice or over \(X^2\), a multisection is a +divisor with line bundle +\(\OO(k)\otimes\pi^*\mathscr H\), \(k>0\). Its homogeneous equation +has coefficients in +\[ + H^0\bigl(S,\mathscr H\otimes + \mathscr L_1^{\otimes i} + \otimes\mathscr L_2^{\otimes(k-i)}\bigr), + \qquad 0\le i\le k, +\] +where \(S\) is the relevant slice or \(X^2\), and a fixed-factor line is +understood as constant. A single nonzero monomial cuts out only the +axis sections and vertical divisors. A multisection not on an axis +therefore has two nonzero coefficients. Their quotient is a +meromorphic section of a nonzero power of +\(\mathscr L_1\otimes\mathscr L_2^{-1}\). Over a slice this is, up to +inversion and a constant line, a positive power of \(K_X\). Over +\(X^2\), restriction to a general factor slice gives the same +conclusion. This is impossible. The axes themselves miss a very +general point of \(Z\), proving the claim. +\end{proof} + +Let \(q\) tend to infinity through positive integers. For each sufficiently +large \(q\), choose \(t=t(q)\) in Equation~\eqref{nv:normalization} so that +\(r=r(q)\ge q^2\), and use the resulting normalized class \(P=P(q)\). +Define the real class and the scale +\begin{equation}\label{nv:M-definition} + M=P_1+P_2+q\xi,\qquad A_q=q^{1/d}. +\end{equation} + +\begin{lemma}\label{nv:two-slot-volume} +For these choices, \(M\) is big and +\begin{equation}\label{nv:M-bounds} + c_nq\le\vol(M)\le C_nq,\qquad + \tau(M,z):=\sup\{u\ge0:b_z^*M-u\{F_z\}\ge0\}\le C_nA_q +\end{equation} +at a very general point \(z\in Z\), where +\(b_z:\Bl_zZ\to Z\) has exceptional divisor \(F_z\). +\end{lemma} + +\begin{proof} +Pull \(Z\) to the Fujita model \(Y_P^2\) from +Equation~\eqref{nv:P-prime}, and put \(H=P'_1+P'_2\) on this pulled-back bundle. +There is a further smooth projective modification +\(\nu:\widehat Z\to\PP_{Y_P^2}(\mu^*\mathscr L_1\oplus +\mu^*\mathscr L_2)\) and a Fujita decomposition of the pullback of \(M\) +whose Kähler part is exactly +\begin{equation}\label{nv:exact-K} + K=\frac12\nu^*H+\Theta , +\end{equation} +where \(\Theta\) is Kähler and has degree \(q\) on a general vertical +line. The modification and the divisor part miss that line. + +Here is the construction. It suffices to decompose \(H/2+q\xi\) as +\(\Theta\) plus an effective divisor, clean on a whole general vertical +line. Since \(\OO(1)\) is relatively ample, a small positive class of +the form \(\delta(\xi+cH)\) is Kähler for some \(c>0\). Choose +\(\delta>0\) so small that \(\delta0 +\] +on a general fiber. For sufficiently large divisible integers \(j\), +let \(\mathcal F_j=f_*\OO_U(j\Lambda)\) and \(R_j=\rk\mathcal F_j\). +Here \(j\Lambda\) is an actual line bundle and +\(c_1(\mathcal F_j)\) means \(c_1(\det\mathcal F_j)\). Then +\begin{align} + R_j&=\frac{w}{e!}j^e+O(j^{e-1}),\label{nv:GRR-rank}\\ + B_0:=G+\lim_j\frac{c_1(\mathcal F_j)}{jR_j} + &=\frac{f_*\beta^{e+1}}{(e+1)w}\ge0,\label{nv:GRR-base}\\ + \int_U\beta^{b_0+e} + &\le (e+1)^{b_0}w\,\vol(B_0).\label{nv:mixed-bound} +\end{align} +The limit in Equation~\eqref{nv:GRR-base} is a limit of real Bott--Chern classes. +\end{lemma} + +\begin{proof} +The restriction of \(c_1(\Lambda)\) to each fiber is represented by the +restriction of the Kähler form \(\beta\). The fiberwise criterion for +relative ampleness makes \(\Lambda\) relatively ample after clearing +denominators. Relative Serre vanishing then kills the higher direct +images for all sufficiently large divisible \(j\). Analytic +Grothendieck--Riemann--Roch \cite{LevyGRR}, in degrees zero and two, gives +\[ + R_j=\frac{f_*c_1(\Lambda)^e}{e!}j^e+O(j^{e-1}),\qquad + c_1(\mathcal F_j) + =\frac{f_*c_1(\Lambda)^{e+1}}{(e+1)!}j^{e+1}+O(j^e). +\] +The degree-zero pushforward is \(w\). Expanding +\(\beta=f^*G+c_1(\Lambda)\) shows that +\[ + f_*\beta^{e+1} + =f_*c_1(\Lambda)^{e+1}+(e+1)wG, +\] +because terms with at least two horizontal factors have negative +fiber degree after pushforward. This proves the equality in +Equation~\eqref{nv:GRR-base}; the cohomological GRR equality is an equality in +Bott--Chern cohomology by the \(\partial\bar\partial\)-lemma on compact +Kähler manifolds. Pushforward of the positive form +\(\beta^{e+1}\) is a positive closed \((1,1)\)-current, so \(B_0\) is +pseudo-effective. + +To prove Equation~\eqref{nv:mixed-bound}, we need a nef class on the base. +The class \(B_0\) is presently only known to be pseudo-effective. We +flatten \(f\) to obtain a nef class above the base and compare it +with the pullback of \(B_0\). Take a smooth projective flattening +modification \(p:Z'_0\to Z_0\), the equidimensional main transform +\(\overline U\) of \(U\times_{Z_0}Z'_0\), and a resolution +\(U'\to\overline U\). Write \(f':U'\to Z'_0\) and \(q:U'\to U\) for +the maps and \(\beta'=q^*\beta\). The class +\[ + B'_0=\frac{f'_*(\beta')^{e+1}}{(e+1)w} +\] +is nef. It is enough to show that the positive pushforward current +representing this class has zero Lelong numbers. This current can +be computed by integration on the cycle \(\overline U\) of the smooth +form pulled back from \(U\). At a base point, cover the compact fiber +by finitely many coordinate neighborhoods, each embedded in a product +of base coordinates and ambient coordinates. In the mass over a base +ball of radius \(\delta\), after wedging with a base Euclidean form to +power \(b_0-1\), the integrand is bounded by a finite sum of projection +volume forms using \(b_0-1\) base coordinates and \(e+1\) generic +linear combinations of all coordinates of the ambient product, including +the remaining base direction. These projections can be chosen finite on the +neighborhoods: fixing the \(b_0-1\) base coordinates leaves local +dimension at most \(e+1\), by equidimensionality, and generic ambient +coordinates finish a finite projection. After shrinking to compact +subneighborhoods their degrees are bounded. Change of variables +therefore bounds each integral by +\(O(\delta^{2(b_0-1)})\) times the measure of the remaining coordinate +range. On each compact subneighborhood these ranges, taken over closed +base balls, are nested compact sets whose intersection is the image of +the central fiber. That image has measure zero in the \(e+1\) coordinates, +because the fiber has dimension \(e\). Continuity of finite measure from +above shows that the range measures tend to zero. Thus the +mass is +\[ + o\bigl(\delta^{2(b_0-1)}\bigr). +\] +This also covers \(b_0=1\), when it asserts absence of an atom. The +pushforward current has zero Lelong numbers at every point, and +Demailly regularization \cite[Theorem~1.1]{DemaillyRegularization1992} +proves that its class \(B'_0\) is nef. + +Pushforward under \(p\) gives \(p_*B'_0=B_0\). For a modification between +smooth compact Kähler manifolds, +the kernel of pushforward on real Bott--Chern \((1,1)\)-classes is generated +by the classes of its exceptional prime divisors. Since +\(p_*p^*B_0=B_0\), it follows that \(B'_0-p^*B_0\) is an exceptional real +divisor class. It is +\(p\)-nef because \(B'_0\) is nef. Apply relative negativity to this +exceptional real divisor. Locally over the base, the usual proof for a +projective modification cuts by general hyperplanes to a surface and +uses the negative definite intersection matrix of exceptional curves; +it forces every coefficient of a relatively nef exceptional divisor to +be nonpositive. Thus +\[ + B'_0=p^*B_0-\{D_0\},\qquad D_0\ge0\ \text{\(p\)-exceptional}. +\] +In particular +\begin{equation}\label{nv:flattened-volume} + \int_{Z'_0}(B'_0)^{b_0} + =\vol(B'_0)\le\vol(p^*B_0)=\vol(B_0). +\end{equation} +Choose a Kähler class \(\omega'\) on \(Z'_0\) and put +\(C=B'_0+\varepsilon\omega'\). For \(0\le k\le b_0\), set +\[ + I_k=\int_{U'}(\beta')^{e+k}(f'^*C)^{b_0-k}. +\] +These are mixed intersections of nef classes. The first two satisfy +\[ + I_0=w\int_{Z'_0}C^{b_0},\qquad + I_1=(e+1)w\int_{Z'_0}B'_0C^{b_0-1} + \le(e+1)w\int_{Z'_0}C^{b_0}. +\] +The mixed nef inequalities make the sequence \(I_k\) log-concave. +Every \(I_k\) is positive: on the dense open where \(q\) is a local +biholomorphism and \(f'\) is a submersion, \(\beta'\) is positive +definite and \(f'^*C\) has rank \(b_0\), so the defining top form +is strictly positive. The successive ratios are therefore at most +\(I_1/I_0\le e+1\). Thus +\[ + \int_U\beta^{b_0+e}=I_{b_0} + \le(e+1)^{b_0}w\int_{Z'_0}C^{b_0}. +\] +Letting \(\varepsilon\downarrow0\) and using +Equation~\eqref{nv:flattened-volume} proves Equation~\eqref{nv:mixed-bound}. +\end{proof} + +We will also use the determinant formula without its volume bound. + +\begin{corollary}\label{nv:slope-descent} +Let \(Y\) be a smooth compact Kähler manifold and \(\mathscr E\) a +holomorphic vector bundle of rank at least two. Write +\(\pi_{\mathscr E}:\PP_Y(\mathscr E)\to Y\) and +\(\zeta_{\mathscr E}=c_1(\OO_{\PP(\mathscr E)}(1))\). +Suppose that a real class \(D\) on \(Y\) satisfies +\[ + c_1(\mathscr H)\le kD + \quad\text{whenever}\quad + 0\ne\bigl(\mathscr H\longrightarrow\mathscr E^{\otimes k}\bigr) +\] +for a line bundle \(\mathscr H\) and integer \(k\ge0\). +For a real class \(A\) on \(Y\) and a real number \(b\ge0\), +\begin{equation}\label{nv:slope-descent-equation} + \pi_{\mathscr E}^*A+b\zeta_{\mathscr E}\ge0 + \quad\Longrightarrow\quad A+bD\ge0 . +\end{equation} +\end{corollary} + +\begin{proof} +Choose a real class \(H_0\) on \(Y\) so that +\(\zeta_{\mathscr E}+\pi_{\mathscr E}^*H_0\) is Kähler; relative +ampleness of \(\OO(1)\) permits such a choice. Take numbers +\(\delta\downarrow0\) with \(b+\delta>0\) rational. Adding +\(\delta(\zeta_{\mathscr E}+\pi_{\mathscr E}^*H_0)\) to the +pseudo-effective class in Equation~\eqref{nv:slope-descent-equation} makes it +big. A Fujita decomposition on a smooth projective modification +\(h:U\to\PP_Y(\mathscr E)\), with the divisor coefficients rounded +upwards as in Equation~\eqref{nv:rational-fujita}, has the form +\[ + \beta=f^*(A+\delta H_0)+c_1(\Lambda),\qquad + \Lambda=(b+\delta)h^*\OO(1)-\OO_U(D') + \ \text{in }\Pic(U)\otimes\Q, +\] +where \(f=\pi_{\mathscr E}h\), \(\beta\) is Kähler, and \(D'\ge0\) +is rational. For divisible \(j\), +\[ + f_*\OO_U(j\Lambda)\ \subseteq\ + \Sym^{j(b+\delta)}\mathscr E . +\] +Its determinant of rank \(R_j\) consequently maps into +\(\mathscr E^{\otimes j(b+\delta)R_j}\). The assumed line inequality +gives +\[ + \frac{c_1(\mathcal F_j)}{jR_j}\le(b+\delta)D. +\] +Lemma~\ref{nv:direct-image} makes +\(A+\delta H_0+\lim c_1(\mathcal F_j)/(jR_j)\) pseudo-effective. +Adding the preceding pseudo-effective difference shows that +\(A+\delta H_0+(b+\delta)D\) is pseudo-effective. Let +\(\delta\downarrow0\). This proves the corollary. In this argument +only \(b+\delta\) and the coefficients of \(D'\) are rational; \(A\), +\(H_0\), and \(D\) remain real classes. +\end{proof} + +\subsection{Restriction to the diagonal} + +We now use the volume of \(M\) to obtain a high-rank subsheaf of a +symmetric cotangent power on \(Z\). Distinguish the two copies of \(Z\) +by bracketed indices and +blow up their diagonal: +\[ + b:B=\Bl_{\Delta_Z}(Z\times Z)\longrightarrow Z\times Z,\qquad + E=b^{-1}(\Delta_Z). +\] +Thus \(E=\PP_Z(\Omega_Z)\); its points are normal lines in \(T_Z\). +The dimensions are \(\dim B=2d\) and \(\dim E=2d-1\), and +\(E\to Z\) has relative dimension \(d-1\). +Put \(\zeta=c_1(\OO_E(1))\), so that \(\{E\}|_E=-\zeta\). +For \(s\ge0\) define +\[ + C_s=b^*(M_{[1]}+M_{[2]})-s\{E\},\qquad + s_{\max}=\sup\{s\ge0:C_s\ge0\}. +\] +The class \(C_0\) is big, so \(s_{\max}>0\) and \(C_s\) is big for +\(0\le s0\) such that, for every sufficiently +large \(q\), one can choose a rational number +\[ + c_nA_q\le s\le C_nA_q +\] +and a Kähler current \(T\) in \(C_s\) with analytic singularities, +not generically singular on \(E\), with the following property. On a +smooth projective modification \(h:U\to E\), its restricted mass has +a rational-divisor approximation +\begin{equation}\label{nv:selected-decomposition} + h^*(2M+s\zeta)=\beta+\{D'\}, + \qquad \beta\ \text{Kähler},\quad D'\ge0\ \text{rational}, +\end{equation} +which retains all log-ideal orders of \(T|_E\). If +\(f:U\to Z\) is the natural map and +\[ + w=\int_{U_z}\beta^{d-1} +\] +on a general fiber, then +\begin{equation}\label{nv:selected-w} + w\ge c_ns^{d-1}. +\end{equation} +\end{lemma} + +\begin{proof} +First let \(s\) be any rational number in \((0,s_{\max})\) with +\(v_E(s)>0\), and use the approximation in +Equation~\eqref{nv:rational-fujita} for any current used +to compute this restricted volume. In +Lemma~\ref{nv:direct-image}, the data for Equation~\eqref{nv:restriction-class} +are +\[ + b_0=d,\quad e=d-1,\quad G=2M,\quad + \Lambda=s h^*\OO_E(1)-\OO_U(D') + \ \text{in }\Pic(U)\otimes\Q. +\] +For large divisible \(j\), the associated sheaves satisfy +\begin{equation}\label{nv:symmetric-inclusion} + \mathcal F_j=f_*\OO_U(j\Lambda) + \subseteq\Sym^{js}\Omega_Z,\qquad + R_j=\rk\mathcal F_j,\qquad 00\). The contribution of +\(0(1-\delta)m\). Summing instead over their internal +degree gives +\[ + H_m(\delta) + \le \binom{m+n}{n}\binom{\lceil\delta m\rceil+n}{n},\qquad + \limsup_{m\to\infty}\frac{H_m(\delta)}{N_m} + \le\binom{2n}{n}\delta^n. +\] +On the other hand, \(w^+\ge w/2\) and +Equation~\eqref{nv:plus-rank} show that the approximation on \(E^+\) +retains at least half the rank fraction in +Equation~\eqref{nv:selected-rank-fraction}: +\[ + \lim_{j\to\infty}\frac{R_j^+}{N_{js}} + =\frac{w^+}{s^{d-1}} + \ge\frac{w}{2s^{d-1}}\ge c_n>0. +\] +Fix \(\delta>0\), depending only on \(n\), so small that, for each fixed +\(q\) and its selected data, fewer than \(R_j^+/2\) monomials have transverse +degree greater than \((1-\delta)js\) for all sufficiently large divisible +\(j\). For each +remaining monomial, Equation~\eqref{nv:coefficient-order} and +Lemma~\ref{nv:incidence-pole} give +\[ + \ord_u(c_{\alpha,\gamma}) + \ge j(s-C_n)-(1-\delta)js + =j(\delta s-C_n)\ge\frac{\delta js}{2}. +\] +The last inequality holds once \(q\) is large, since +\(s\ge c_nA_q\to\infty\). + +Over the same discrete valuation ring \(R\), the torsion-free sheaf +\(\mathcal F_j^+\) becomes a free module of rank \(R_j^+\). Write its +inclusion into the symmetric power as a matrix with the monomials +as rows. Every maximal minor uses at least \(R_j^+/2\) of the rows +whose coefficients have order at least \(\delta js/2\). All maximal +minors therefore have order at least +\(\delta jR_j^+s/4\). By the definition of \(h_j\), this proves +Equation~\eqref{nv:determinant-order-equation}. Dividing the determinant +map by \(\sigma_{J_+}^{h_j}\) gives a holomorphic map at every point of +codimension one: the coefficients have the required order along \(J_+\), +and its local equation is a unit away from \(J_+\). Hartogs' theorem +extends the divided map across the remaining set of codimension at least +two, giving the stated factorization through +\(\det\mathcal F_j^+(h_jJ_+)\). +\end{proof} + +\begin{proof}[Completion of the proof of Theorem~\ref{nv:meromorphic}] +Fix \(q\) sufficiently large for the preceding lemmas, with its chosen +\(P,s,T\) and modifications. Choose a very general point \(x\) in the first +factor of \(X^2\). The slice of \(Z^+\) above \(x\) is +\[ + S=\PP_Y(\OO_Y\oplus a^*\mathscr L),\qquad + a:Y=\Bl_xX\longrightarrow X, +\] +and \(J_+|_S\) is the pullback of \(F\). We choose \(x\) so that +Equation~\eqref{nv:slope-blowup}, Equation~\eqref{nv:point-bound}, the restrictions of +the currents below, and all determinant maps for divisible \(j\) +can be tested on this slice. These exclude at most countably many +proper analytic sets and the measure-zero exceptional sets for +current restrictions. + +Write the restricted determinant line as +\[ + (\det\mathcal F_j^+)|_S + =\pi_S^*\mathscr Q_j^+\otimes\OO_S(\ell_j^+),\qquad + Q_j^+=c_1(\mathscr Q_j^+). +\] +Factoring the common zero of order \(h_j\) from the determinant +map gives a nonzero map whose source on \(S\) is +\[ + \pi_S^*(\mathscr Q_j^+\otimes\OO_Y(h_jF)) + \otimes\OO_S(\ell_j^+). +\] +The plus sign of \(h_jF\) follows because division of the map by +the local equation of \(J_+^{h_j}\) enlarges its source from +\(\det\mathcal F_j^+\) to +\(\det\mathcal F_j^+\otimes\OO(h_jJ_+)\). +Its target embeds into the \(jsR_j^+\)-fold tensor of the +restriction of \(p_+^*\Omega_Z\). In particular we use the +cotangent bundle of the original \(Z\), with its restricted +filtration +\[ + 0\longrightarrow + \pi_S^*(\OO_Y^{\oplus n}\oplus a^*\Omega_X) + \longrightarrow (p_+^*\Omega_Z)|_S + \longrightarrow + \OO_S(-2)\otimes\pi_S^*a^*\mathscr L + \longrightarrow0. +\] +The same homogeneous-monomial calculation as in +Equation~\eqref{nv:determinant-bound-Z}, now applying +Equation~\eqref{nv:slope-blowup} to the second factor of \(X^2\), gives +\begin{equation}\label{nv:determinant-bound-slice} + \ell_j^+\le0,\qquad + Q_j^++h_j\{F\} + \le(jsR_j^+-\ell_j^+)a^*L. +\end{equation} +More explicitly, if the chosen graded term has \(i\) relative +factors, the pushed polynomial has degree +\(-2i-\ell_j^+\ge0\). Its exponent in \(a^*\mathscr L\), together +with the \(i\) relative factors and the cotangent order from the second +factor of \(X^2\), is at most \(jsR_j^+-\ell_j^+\). The cotangent +factors from the first factor of \(X^2\) are constant. This proves the +displayed inequality using +the tensors of \(a^*\Omega_X\), without introducing \(\Omega_Y\) +or \(\Omega_{Z^+}\). + +Apply Lemma~\ref{nv:direct-image} to the decomposition in +Equation~\eqref{nv:plus-decomposition}. Equation~\eqref{nv:GRR-base} +shows that the limits of the restricted determinant components divided by +\(jR_j^+\) exist; denote them by \(Q^+\) and \(\ell^+\). Divide +Equation~\eqref{nv:determinant-bound-slice} by \(jR_j^+\), use +Equation~\eqref{nv:determinant-order-equation}, and pass to the closed +pseudo-effective cone. We obtain +\begin{equation}\label{nv:slice-upper} + \ell^+\le0,\qquad + Q^++c_ns\{F\}\le(s-\ell^+)a^*L. +\end{equation} +The pseudo-effective class in Equation~\eqref{nv:GRR-base}, restricted to the +very general slice \(S\), is +\begin{equation}\label{nv:slice-psef} + \pi_S^*(Q^++2a^*P)+(\ell^++2q)\xi\ge0. +\end{equation} +Testing on a general vertical line gives \(\ell^++2q\ge0\). +Let \(A\subset S\) be the axis of +\(\PP_Y(\OO_Y\oplus a^*\mathscr L)\) with divisor class \(\{A\}=\xi\). +On \(A\simeq Y\), its normal class is \(\{A\}|_A=\xi|_A=a^*L\ge0\). +Add an arbitrarily small Kähler class to the class in +Equation~\eqref{nv:slice-psef}, and choose a Kähler current with analytic +singularities in the resulting big class. Remove its generic divisorial +pole along \(A\) and restrict +the residual current to \(A\). Adding back the removed nonnegative multiple +of \(a^*L\) preserves pseudo-effectivity. Passing to the limit gives +\begin{equation}\label{nv:slice-lower} + Q^++2a^*P+(\ell^++2q)a^*L\ge0. +\end{equation} + +The slope bound in Equation~\eqref{nv:slice-upper} supplies the +pseudo-effective class \((s-\ell^+)a^*L-Q^+-c_ns\{F\}\). Adding it to +Equation~\eqref{nv:slice-lower} cancels the entire normalized determinant +class restricted to the axis, \(Q^++\ell^+a^*L\), leaving +\[ + 2a^*P+(s+2q)a^*L-c_ns\{F\}\ge0. +\] +Since \(L\le P/r\), the point bound in Equation~\eqref{nv:point-bound} implies +\begin{equation}\label{nv:contradiction} + \frac{c_ns}{\,2+(s+2q)/r\,}\le C_n. +\end{equation} +The denominator is bounded independently of \(q\), because +\(s\le C_nq^{1/d}\) and \(r\ge q^2\). The numerator tends to +infinity, because \(s\ge c_nq^{1/d}\). Equation~\eqref{nv:contradiction} +is impossible for arbitrarily large \(q\). + +For each \(q\), the choice of \(t(q)\), the rational \(s\), the current +\(T\), and the modifications precedes the limit in \(j\). The monomial +cutoff \(\delta\) depends only on \(n\), while the required lower bound for +divisible \(j\) may depend on the fixed data. We choose the very general +points after those data are fixed. +Thus every simultaneous general-point test above involves at most +countably many conditions, and no bound depends on the point. +The contradiction disproves the contrary hypothesis and proves +Theorem~\ref{nv:meromorphic}. +\end{proof} diff --git a/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/07-signed-rigidity.tex b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/07-signed-rigidity.tex new file mode 100644 index 0000000000000000000000000000000000000000..f3f5665f4946de8f895287f9a38c9700aa9be2d2 --- /dev/null +++ b/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/build/sections/07-signed-rigidity.tex @@ -0,0 +1,1644 @@ +\section{Signed rigidity on simple spaces} +\label{sec:signed} + +The meromorphic section furnished by Theorem~\ref{nv:meromorphic} need +not have an effective divisor. We therefore need a boundary argument +that retains both its zeroes and its poles. The result below supplies +that argument. + +\begin{theorem}[Signed rigidity]\label{signed:torsion} +Let \((X,D)\) be a dlt pair on a normal irreducible compact Kähler +space, and suppose that the pair has the resolution property of +Definition~\ref{def:lc-strata-resolution}. Suppose also that \(X\) is +globally \(\Q\)-factorial, that \(a(X)=0\), that \(X\) is simple, +and that \(D=\sum_{i=1}^sD_i\) is reduced. Put \(L=K_X+D\), and +assume the following. +\begin{enumerate} +\item The rational line \(L\) is analytically nef and has an actual +rational linear equivalence +\[ + L\sim_{\Q}G=\sum_{i=1}^s a_iD_i,\qquad a_i\in\Q. +\] +\item For some real \(c>0\), the pullback of the class +\(\{L-cD\}\) to a projective resolution with smooth compact +Kähler source is pseudo-effective. +\item The rational holomorphic line \(L|_D\) is semiample on the +whole reduced analytic space \(D\): some Cartier multiple is +generated at every point of \(D\). +\end{enumerate} +Then \(L\) is torsion. More precisely, for some positive integer +\(q\), the holomorphic line \(\OO_X(qL)\) is isomorphic to +\(\OO_X\). +\end{theorem} + +To apply this theorem in the proof of Proposition~\ref{simple:case}, +Theorem~\ref{nv:meromorphic} supplies a signed representative of the +canonical bundle. After resolving, we enlarge the support of the +transformed boundary and this signed canonical divisor to a reduced SNC +divisor; the resulting adjoint remains pseudo-effective. +Corollary~\ref{prog:signed-nef} gives an ordinary dlt nef model +\((X_{\mathrm{nef}},D_{\mathrm{nef}})\) whose adjoint +\(L_{\mathrm{nef}}=K_{X_{\mathrm{nef}}}+D_{\mathrm{nef}}\) has a +signed representative supported on \(D_{\mathrm{nef}}\), supplying +the first hypothesis. Theorem~\ref{floor:generation} supplies +semiampleness on the whole reduced \(D_{\mathrm{nef}}\). On a common +smooth resolution, simplicity excludes uniruledness, so Ou's criterion +\cite[Theorem~1.1]{Ou2025} and exceptional translation for the canonical +comparison give pseudo-effectivity of the pullback of +\(K_{X_{\mathrm{nef}}}=L_{\mathrm{nef}}-D_{\mathrm{nef}}\). Thus the +second hypothesis holds with \(c=1\). Once signed rigidity makes the +actual line \(L_{\mathrm{nef}}\) torsion, the program comparison and +Lemma~\ref{bir:unique-current} let us subtract the added boundary and give +the required decomposition for the original adjoint. The final subsection +verifies these steps. + +The signed construction in \cite[Proposition~3.3]{LI} is the source +of the root and separation operations used below. The lifting +method is that of \cite[Sections~10--12]{BL}. +We will establish the analytic form of the signed construction and +the change to the lifting argument caused by its residual poles. +The numerical argument first singles out positive-dimensional fibers in +the positive boundary. We then lift those fibers through every finite +boundary neighborhood and deform them to compact subspaces outside the +boundary. An argument using the cycle space and Baire's theorem turns these +deformations into a covering family, which simplicity excludes. + +\subsection{The boundary detected by the nef class} + +If \(D=0\), the signed equivalence already gives +\(L\sim_{\Q}0\). We may therefore assume in the constructions +below that \(D\ne0\); in particular \(\dim X>0\). + +Fix the data of Theorem~\ref{signed:torsion}, and write +\[ + G=G_+-G_-,\qquad D_0=\sum_{a_i=0}D_i, +\] +where \(G_+\) and \(G_-\) are effective with disjoint prime supports. +Choose a positive integer \(m\) so that \(mG_+\), \(mG_-\), +\(mD_0\), and \(mL\) are Cartier, the given rational equivalence +induces a fixed isomorphism +\[ + N_0:=\OO_X(mG)\simeq\OO_X(mL), +\] +and \(N_0|_D\) is generated. Its sections give a morphism and an +actual line isomorphism +\begin{equation}\label{signed:boundary-map} + \phi:D\longrightarrow P=\PP^b,\qquad + N_0|_D\simeq\phi^*\OO_P(1). +\end{equation} +Let \(n=\dim X\). Choose a projective resolution +\(\mu:\widetilde X\to X\) as in the second hypothesis of the theorem, +and a Kähler class \(\omega\) on \(\widetilde X\). The numerical +dimension of the nef pullback is +\[ + v=\nu(L):=\max\bigl\{k\in\{0,\ldots,n\}: + (\mu^*\{L\})^k\omega^{n-k}>0\bigr\}. +\] + +The next argument is the Kähler form of +\cite[Lemma~3.2]{LI}. + +\begin{lemma}\label{signed:boundary-geometry} +If \(v=0\), then \(D=0\) and \(L\sim_{\Q}0\). If \(v=n>0\), +then \(a(X)=n\). If \(00}\dim\phi(D_i)=r, +\] +and +\begin{equation}\label{signed:small-intersections} + \dim\phi\bigl(\Supp G_+\cap(\Supp G_-\cup D_0)\bigr)0\) such that +\(C\omega-h\) is nef and \(h-\epsilon\omega\) is +pseudo-effective. Pairing these two inequalities successively with +products of the nef classes \(\mu^*\{L\}\), \(h\), and +\(\omega\) shows that +\[ + (\mu^*\{L\})^k h^{n-k}>0 + \quad\Longleftrightarrow\quad + (\mu^*\{L\})^k\omega^{n-k}>0. +\] +We may therefore use \(\theta\) in all the tests defining \(v\). + +Suppose first that \(v0\) attains dimension \(r\). + +It remains to separate its intersections from a general fiber. +On \(H^{1,1}_{\BC}(\widetilde X,\R)\) consider the form +\[ + q(\alpha,\beta)= + \alpha\beta(\mu^*\{L\})^r h^{n-r-2},\qquad + Q_{ij}=q(\mu^*\{D_i\},\mu^*\{D_j\}). +\] +The mixed Kähler Hodge index theorem, followed by approximation of +the nef factors by Kähler classes, says that \(q\) has at most one +positive direction; see \cite[Theorems~A and C]{DinhNguyen}. Put +\(l=\mu^*\{L\}\). The definition of \(v\) and +Equation~\eqref{signed:boundary-zero} give +\[ + q(l,l)=0,\qquad q(l,\mu^*\{D_i\})=0, + \qquad q(l,h)=\{L\}^{v}\theta^{n-v}>0. +\] +Linear algebra now makes \(q\) negative semidefinite on +\(l^\perp\): a positive vector in \(l^\perp\), together with a +suitable vector in the span of \(l,h\), would give two positive +directions. In particular \(Q\) is negative semidefinite. + +For \(i\ne j\), one has \(Q_{ij}\geq0\). This assertion uses +the effective intersection cycle of the distinct \(\Q\)-Cartier +divisors \(D_i,D_j\) on \(X\), and projection formula. It does +not require their total transforms to intersect effectively. The +two Cartier equations have a proper intersection: the dlt ambient +space is klt, hence Cohen--Macaulay, after dropping the reduced +boundary, and the distinct divisor equations form a regular +sequence. The intersection cycle is consequently pure of +codimension two, and each of its mixed nef degrees is nonnegative. + +Write the coefficient vector as +\(\mathbf a=\mathbf a^+-\mathbf a^-\), with nonnegative vectors +of disjoint supports. The signed equivalence and orthogonality to +\(l\) give \(Q\mathbf a=0\). Thus +\[ + Q(\mathbf a^+,\mathbf a^+) + =Q(\mathbf a^+,\mathbf a^-)\geq0. +\] +Negative semidefiniteness forces equality and +\(Q\mathbf a^+=0\). For every \(j\) with \(a_j\leq0\), its +row is a sum of nonnegative off-diagonal terms: +\[ + 0=\sum_{a_i>0}a_iQ_{ji}. +\] +Each term is zero. Applying the generated-line degree test to the +effective intersection cycles proves +Equation~\eqref{signed:small-intersections}. If \(r=0\), any +nonempty intersection would have positive \(\theta^{n-2}\)-degree, +so these intersections are empty. + +Finally, if \(v=n>0\), the nef volume criterion makes the rational +line on \(\widetilde X\) big +\cite[Theorem~0.5]{DemaillyPaun2004}. A big holomorphic line on a +compact Kähler manifold has maximal Iitaka dimension. Hence +\(a(\widetilde X)=n\), and birational invariance gives \(a(X)=n\). +\end{proof} + +Thus, when \(00\). +Equation~\eqref{signed:small-intersections} makes those fibers disjoint +from \(\Supp G_-\cup D_0\). The next construction prepares their normal +directions and adjunction for infinitesimal lifting. + +\subsection{Local roots and residue with residual poles} + +We work for the rest of the signed argument in the range +\(01\) divisible by \(m\) +and by every nonzero integer \(|ma_i|\), and put +\(a=\ell/m\), a positive integer. + +\begin{lemma}[Analytic signed charts]\label{signed:root-charts} +For each \(t\in P\), after shrinking an open neighborhood +\(U\subset P\), choose a line \(R_U\) together with an isomorphism +\(R_U^\ell\simeq\OO_P(1)|_U\). A comparison of two such roots on an +overlap is power-compatible if its \(\ell\)-th power commutes with these +isomorphisms. If +\(t\notin\phi(\Supp G_+)\), one may take \(U\) disjoint from this +closed image and set \(Z_U=S=T=\varnothing\); the assertions below are +then vacuous for the unique maps from the empty spaces. If +\(t\in\phi(\Supp G_+)\), there are a Hausdorff normal +analytic space \(Z_U\) of pure dimension \(n\), considered near a +reduced Cartier divisor \(S\) of pure dimension \(n-1\), a +reduced Weil divisor \(T\) with no component in common +with \(S\), and maps +\[ + \pi:Z_U\longrightarrow X,\qquad g:S\longrightarrow U +\] +with the following properties. +\begin{enumerate} +\item The map \(g\) is proper, and \(\pi|_S\) is finite over +\(D_U=\phi^{-1}(U)\), with \(g=\phi\pi|_S\). Its image covers +the positive components over \(U\), and +\[ + \OO_S(S)\simeq g^*R_U. +\] +The image of \(S\cap T\) lies in +\(\phi(\Supp G_+\cap(\Supp G_-\cup D_0))\). +Near \(S\), the underlying sets satisfy +\[ + \pi^{-1}(|D|)=|S|\cup|T|. +\] +\item The pair \((Z_U,S+T)\) is log canonical, and there is a fixed +actual isomorphism of divisorial sheaves +\begin{equation}\label{signed:adjoint-chart} + \tau:\OO_{Z_U}(aS)\xrightarrow{\ \simeq\ }\omega_{Z_U}(S+T). +\end{equation} +The spaces \(Z_U\) and \(S\) are Cohen--Macaulay. The support +of \(T\) is locally set-theoretically principal. +Off \(T\), the space \(Z_U\) is klt and its canonical sheaf is +invertible. The map \(\pi\) is quasi-finite near \(S\setminus T\). +\item Projective log resolutions of the total divisor data can be +chosen with Kähler forms on neighborhoods of the compact sets over +each compact fiber of \(g\). Power-compatible changes of the +boundary root extend to isomorphisms of ambient germs that preserve +the full ideal \(\OO_{Z_U}(-S)\), the reduced divisor \(T\), and +Equation~\eqref{signed:adjoint-chart}. Resolutions may be chosen +functorially for these germ isomorphisms. +\end{enumerate} +Here the nonempty space \(Z_U\) is a neighborhood of the whole compact +fiber under consideration; no extension of \(g\) to \(Z_U\) is asserted. +\end{lemma} + +\begin{proof} +The empty branch follows by shrinking away from the closed image +\(\phi(\Supp G_+)\). We construct the nonempty charts in four stages: +take roots and trivialize the remaining adjoint torsion, separate the +positive and negative root divisors, retain the root line that controls the +normal direction, and pass to an ordinary neighborhood of the compact fiber. + +First consider an analytic open set on which the Cartier lines of +\(mG_+\), \(mG_-\), and \(mD_0\) are trivial, and let +\(f_+,f_-,f_0\) be the functions representing their sections. Normalize +the entire finite space +\[ + \{y_+^\ell=f_+,\qquad y_-^\ell=f_-,\qquad y_0^\ell=f_0\}, +\] +retaining all its components and the lifted action of \(\mu_\ell^3\) +that multiplies the three root coordinates. On an overlap, the functions +\(f_+,f_-,f_0\) change by holomorphic units. Local \(\ell\)-th roots of +those units give comparisons of the finite spaces that lift uniquely to +their normalizations; different choices differ by \(\mu_\ell^3\). +The quotient stacks of these normalized charts by \(\mu_\ell^3\) glue to +the simultaneous normalized root stack over \(X\), which we denote by +\(\mathcal X_{\mathrm{rt}}\). The zero divisors +of the three root sections are denoted by \(S_+,S_-,S_0\). At a +generic prime of multiplicity \(b\), a normalized chart of +\(y^\ell=x^b\) has ramification index \(\ell/b\) and +\(\ord(y)=1\). Here \(b=|ma_i|\) or \(b=m\), so it divides +\(\ell\). Thus each root divisor is generically reduced and +Cartier. A Cartier divisor on a normal space satisfies Serre's +condition \(S_1\), so it is reduced. Log ramification with the +full reduced boundary gives a log canonical pair and the rational +equivalence +\[ + K_{\mathcal X_{\mathrm{rt}}}+S_++S_-+S_0 + \sim_{\Q}a(S_+-S_-). +\] +The ambient charts of \(\mathcal X_{\mathrm{rt}}\) are klt. Off the +boundary this follows from +the klt complement downstairs and the unramified charts. For a +place centered in the Cartier boundary, dropping that boundary +increases its log discrepancy by its strictly positive order; +this also makes every zero-discrepancy place positive. + +To turn the rational adjoint equivalence into an actual isomorphism, +consider the integral reflexive sheaf on \(\mathcal X_{\mathrm{rt}}\) +\[ + \mathcal F= + \bigl(\omega_{\mathcal X_{\mathrm{rt}}}(S_++S_-+S_0)\otimes + \OO_{\mathcal X_{\mathrm{rt}}}(-a(S_+-S_-))\bigr)^{**}. +\] +It is torsion. Choose a periodicity +\(\mathcal F^{[q]}\simeq\OO\), take the relative spectrum of its +reflexive-power algebra, and normalize; write \(\rho_{\mathrm{ind}}\) +for this finite map, and retain \(S_+,S_-,S_0\) for the pulled-back +root divisors on the cover. At codimension one this +is a cover \(w^q=u\) for a unit \(u\), hence is unramified. +Log canonicity, the klt ambient property, and reduced Cartier +root divisors persist. The tautological evaluation of this +algebra trivializes the reflexive pullback +\((\rho_{\mathrm{ind}}^*\mathcal F)^{**}\): it does so in +codimension one, and the identity then extends reflexively. +The evaluation is a sheaf morphism on the cover stack itself, +so the resulting actual divisorial isomorphism +\[ + \omega(S_++S_-+S_0)\simeq\OO\bigl(a(S_+-S_-)\bigr) +\] +on the cover is equivariant on every atlas. + +Next separate the positive and negative root divisors. Let +\(\mathcal X_{\mathrm{sep}}\) be the normalization of the blowup of the +ideal generated by their equations on the cover, and write \(p_1\) for its +map. This blowup embeds in a relative +\(\PP^1\); its normalization still has fibers of dimension at +most one. Each exceptional prime therefore lies over a +codimension-two positive--negative intersection. At its generic +point the original dlt pair is a two-branch SNC pair. After +extracting roots of units the normalized Kummer chart there has +smooth coordinates +\(x=u^{\ell/b_+}\), \(z=w^{\ell/b_-}\), where \(b_+\) and +\(b_-\) are the two corresponding multiplicities. On this chart +\(\mathcal F\) is a line and its periodicity cover is unramified. +The two-coordinate blowup calculation consequently applies at +every exceptional generic point. If \(E\) denotes its +exceptional divisor, it gives reduced Cartier divisors +\[ + E,\qquad S'_+=p_1^*S_+-E,\qquad S'_-=p_1^*S_--E, +\] +with \(S'_+\cap S'_-=\varnothing\). No such two-branch stratum +is contained in \(S_0\), so \(p_1^*S_0\) is reduced and has no +exceptional component. The full boundary +\(S'_++S'_-+E+p_1^*S_0\) is crepant and reduced. Its +codimension-one equality with the pullback adjoint gives the +discrepancy equality for every further valuation, hence log +canonicity. The ambient charts after this blowup are still +klt. Off the full boundary the blowup is an isomorphism to +the old klt complement. A place of zero pair discrepancy +centered in that boundary gains its strictly positive order +when the effective Cartier boundary is dropped, while a +place of positive pair discrepancy remains positive. The +strict divisor \(S'_+\) is finite over \(S_+\): +before normalization it lies in one section of the projective +ratio coordinate, so its proper map has finite fibers, and +normalization is finite. + +On \(\mathcal X_{\mathrm{sep}}\), put \(S=S'_+\) and, temporarily, +\(T=S'_-+E+p_1^*S_0\). Write +\(\pi_{\mathrm{sep}}:\mathcal X_{\mathrm{sep}}\to X\) for the composite +map, and define the retained root line +\[ + \mathcal R:=\OO_{\mathcal X_{\mathrm{sep}}}(S'_+-S'_-), + \qquad \mathcal R^\ell\simeq\pi_{\mathrm{sep}}^*N_0. +\] +Near \(S\), the negative strict root section is a unit. The fixed adjoint +isomorphism becomes +\(\omega_{\mathcal X_{\mathrm{sep}}}(S+T) + \simeq\OO_{\mathcal X_{\mathrm{sep}}}(aS)\), and the positive root +section divided by that negative unit section is a section of +\(\mathcal R\) with zero divisor \(S\). This line and section determine +the Cartier divisor \(S\) and its normal line; they must survive passage +to an ordinary chart. + +The pair consisting of \(\mathcal R\) and its displayed power isomorphism +defines a map to the gerbe \(\sqrt[\ell]{N_0}\), which parametrizes +\(\ell\)-th roots of \(N_0\). Take the relative coarse space over this +gerbe. On an atlas this quotients by the finite relative inertia kernel, +the subgroup of each stabilizer acting trivially on \(\mathcal R\). +Thus the quotient retains the root character of \(\mathcal R\). The +deck transformations of the representable periodicity cover +are not this inertia kernel and are not removed. + +Both \(\mathcal R\) and its section descend through the kernel, so the +reduced image \(S\) remains Cartier and its full ideal descends. We retain +\(S,T\) for the reduced images. A finite-group norm of +a local equation of the upstairs \(T\) has precisely its image +as zero set. Thus the reduced image \(T\) is locally +set-theoretically principal; it need not be Cartier. All +divisorial ramification lies on the full boundary. Log +ramification identifies the invariant log dualizing sheaf in +codimension one with the downstairs one. Taking reflexive +hulls and invariants of the equivariant adjoint isomorphism +gives an actual descended isomorphism \(\OO(aS)\simeq\omega(S+T)\). +Its ordinary pullback below is Equation~\eqref{signed:adjoint-chart}. +Outside \(S+T\), the local +finite quotient is quasi-étale, so its klt upstairs complement gives +a klt downstairs complement by finite discrepancy comparison. Away from +\(T\), dropping the Cartier divisor \(S\) from the lc pair +increases the log discrepancy of every place centered in \(S\) by +its strictly positive order. Thus the quotient charts are klt away from +\(T\), and the same isomorphism makes their canonical sheaves invertible +there. Off \(T\) the separating blowup is an +isomorphism, while the other operations are finite; hence +the composite map to \(X\) is quasi-finite near \(S\setminus T\). + +The same quotient preserves Cohen--Macaulayness of both the +ambient space and \(S\). Before the quotient the ambient +space is klt and hence Cohen--Macaulay, and \(S\) is Cartier +there. Locally its finite quotient ring, and the quotient +ring of \(S\), are invariant direct summands of those finite +Cohen--Macaulay rings. A system of parameters downstairs is +one upstairs; the vanishing of lower local cohomology upstairs +and the invariant projection give its vanishing for the +downstairs direct summand. This proves the stated depth. + +Removal of the relative inertia kernel also makes the strict +positive divisor finite and representable over +\[ + D\times_P\sqrt[\ell]{\OO_P(1)}. +\] +Its root line is \(\OO_S(S)\), and its image covers +\(\Supp G_+\). The intersection \(S\cap T\) maps to the +positive--negative or positive--zero intersections: the only +new component is the separating exceptional divisor. Before the quotient, +the inverse image of \(|D|\) is the support of +\(S'_++S'_-+E+p_1^*S_0\). The finite quotient sends this full support +to \(|S|\cup|T|\), and the equality of underlying sets persists under the +ordinary base change below. The image of \(S\cap T\) in \(P\) consequently +has dimension \(0\). This +proves Equation~\eqref{signed:full-residual-comparison}. + +Projection formula gives the same comparison after adding +\(D_S=p^*S\). The quotient sequence therefore identifies +\[ +\begin{aligned} + R(p_D)_*\left( + \frac{\omega_{\widehat Z}(D_S+C)}{\omega_{\widehat Z}(C)} + \right) + &\simeq \omega_Z(S+T)|_S[0]\\ + &\simeq \OO_S(aS)[0], +\end{aligned} +\] +where \(p_D:D_S\to S\) and the quotient is a sheaf on the +possibly nonreduced divisor \(D_S\). To justify the displayed +derived statement, first push it by the exact closed immersion +\(S\hookrightarrow Z\). There it is the quotient of the two +acyclic comparisons. Closed pushforward detects cohomology +sheaves, and canonical truncation yields the statement on \(S\). + +There is a quotient morphism +\begin{equation}\label{signed:quotient-map} +\begin{aligned} + \omega_H(A)&= + \frac{\omega_{\widehat Z}(H+A)}{\omega_{\widehat Z}(A)} + \\ + &\longrightarrow + \frac{\omega_{\widehat Z}(D_S+C)}{\omega_{\widehat Z}(C)}. +\end{aligned} +\end{equation} +Indeed \(H+A\leq D_S+C\) and \(A\leq C\). This morphism +need not be injective when \(C\) and \(H\) share a component. +Compose its derived pushforward with the preceding isomorphism. +The result retracts Equation~\eqref{signed:derived-insertion}: +at each generic point of \(S\), its composite is the identity +under the fixed residue convention. The composite is an +endomorphism of the invertible sheaf \(\OO_S(aS)\) in degree +zero; since \(S\) is reduced, agreement at every generic point +implies agreement everywhere. Applying \(Rg_*\) proves +Equation~\eqref{signed:residue-injection}. All maps use the +fixed adjoint isomorphism, divisor ideals, and residue, so they +commute with the germ comparisons. Relative canonical forms +under products, followed by wedging with the canonical frame +of the new factor, give the last assertion. +\end{proof} + +\subsection{The localized Hodge argument} + +The target in Equation~\eqref{signed:residue-injection} contains +the additional poles \(A\). The following version of the filtered +SNC calculation incorporates them. In its application, we embed \(H\) +by the graph of \(h\) in \(\widehat Z\times U\) and use the projection to +\(U\) as the ambient map. This projection is submersive, while its +restriction to the graph is the proper map \(h\); it requires no extension +of \(h\) to \(\widehat Z\). We will use the same graph construction after +a change of parameter. The parameter is projective only in the last +assertion below; the closed-stratum maps are proper Kähler maps. + +\begin{proposition}\label{signed:localized-hodge} +Let \(q:\mathscr V\to Y\) be a holomorphic map of complex +manifolds, submersive near a reduced closed analytic subspace +\(i:H\hookrightarrow\mathscr V\) of pure dimension \(d\) and +codimension \(c_0>0\). Suppose \(h=q|_H\) is proper. Assume +that locally \(H\) is an SNC divisor in a smooth submanifold of +codimension \(c_0-1\), and that a reduced divisor \(A\) is +simultaneously SNC and transverse to those support equations. +Assume that the components \(H_i\) and \(A_j\) near \(H\) have +finite global smooth indexing, and that every closed stratum +\(H_I\cap A_J\), with \(I\ne\varnothing\), is smooth and proper +over \(Y\) and carries a global relative Kähler form. Empty or +disconnected strata are allowed. +Here \(H_I=\bigcap_{i\in I}H_i\) and +\(A_J=\bigcap_{j\in J}A_j\), with \(A_\varnothing=\mathscr V\). + +Use right \(\mathscr D\)-modules and finite-pole local cohomology, +and put +\[ + \mathcal K_A=\mathcal H^{c_0}_{[H]}(\omega_{\mathscr V})(*A). +\] +Its order filtration is generated from +\(F_0\mathcal K_A=i_*\omega_H(A)\), with \(F_p=0\) for \(p<0\). +For \(M^j=\mathcal H^j q_+\mathcal K_A\), the filtered direct +image is strict at every level, and \(M^j\) has a finite +filtration by submodules, strict for \(F\), whose quotients are +polarizable real pure Hodge modules. In particular, +\begin{equation}\label{signed:lowest-step} + F_0M^j=R^jh_*\omega_H(A)\lhook\joinrel\longrightarrow M^j, + \qquad F_pM^j=0\quad(p<0). +\end{equation} +Define the symbol morphism +\[ + \sigma:F_0M^j\otimes T_Y\longrightarrow\gr^F_1M^j, + \qquad \sigma(m\otimes\xi)=[m\xi]. +\] +If \(Y\) is smooth projective, then for every ample line \(N\) on \(Y\), +\begin{equation}\label{signed:symbol-vanishing} + \Hom_{\OO_Y}(N,\Ker\sigma)=0. +\end{equation} +This includes any coherent torsion in the kernel. +\end{proposition} + +\begin{proof} +We verify the residual localization in the proof of +\cite[Proposition~11.1]{BL}. We first identify the lowest order step and +a filtration by the number of branch poles. Its graded pieces will be +dual constant modules on smooth strata, to which proper Kähler direct +image applies. The resulting strictness gives the injection at the lowest +filtration step, +and the graded de Rham complex on a projective base gives the symbol +vanishing. + +At a point of \(H\), choose +simultaneous coordinates +\[ + (z_1,\ldots,z_{c_0-1},x_1,\ldots,x_t,y_1,\ldots,y_s,\xi), + \quad + \mathscr I_H=(z_1,\ldots,z_{c_0-1},x_1\cdots x_t), + \quad A=(y_1\cdots y_s=0). +\] +Let \(\eta\) be the coordinate volume form. The localization +Čech complex for the displayed regular support equations has +cohomology only in degree \(c_0\). Localizing this cohomology +also in the \(y\)'s gives \(\mathcal K_A\). Successive finite +Taylor divisions give its unique additive polar normal forms: +finite sums of +\begin{equation}\label{signed:polar-form} + f(x_{I^c},y_{J^c},\xi) + \prod_{\nu=1}^{c_0-1}z_\nu^{-u_\nu} + \prod_{i\in I}x_i^{-v_i} + \prod_{j\in J}y_j^{-w_j}\eta, + \quad I\ne\varnothing, +\end{equation} +where every displayed order is positive and \(J\) is arbitrary, +including empty. The coefficient is independent of exactly +the variables occurring negatively. The normal form is an +additive statement, not an \(\OO_{\mathscr V}\)-linear +decomposition. + +The simple fractions, with each displayed order equal to one, +are exactly the image of \(\omega_H(A)\). More explicitly, +their unreduced representatives are +\[ + \frac{f\eta} + {z_1\cdots z_{c_0-1}(x_1\cdots x_t)(y_1\cdots y_s)}. +\] +The regular-equation residue identifies their numerators modulo +\(\mathscr I_H\) with the absolute dualizing sheaf of \(H\), +twisted by \(A\). This map is injective. If the fraction has +no remaining \(x\)-pole, Taylor division says that its +numerator modulo the \(z\)'s is divisible by \(x_1\cdots x_t\). +Localization in the \(y\)'s does not enlarge this kernel, +because each \(y_j\) is a nonzerodivisor modulo +\(\mathscr I_H\). This also proves the identification under +changes of coordinates, including the determinant of the +normal conormal frame. + +Give a term of Equation~\eqref{signed:polar-form} the excess +\[ + e=\sum_\nu(u_\nu-1)+\sum_{i\in I}(v_i-1) + +\sum_{j\in J}(w_j-1). +\] +The right canonical action of a coordinate derivative is minus +differentiation of the coefficient of \(\eta\). A derivative +in a denominator variable increases its order by one with a +nonzero scalar. Because the coefficient in the normal form +is independent of those variables, every term of excess +\(e\) is obtained from a simple term by \(e\) such derivatives. +Conversely, order \(p\) differentiations produce excess at +most \(p\). Thus \(F_p\mathcal K_A\) consists exactly of the +finite sums of excess at most \(p\). This is the good order +filtration generated from \(i_*\omega_H(A)\). + +There is also an increasing filtration \(W\) by the total +number of branch poles. Intrinsically, its step of index +\(-d+k-1\) is the sum of the images of support modules for +subunions of the \(H_i\), localized along sublists of the +\(A_j\), for which the total number of selected branches is +at most \(k\). In the normal form it imposes +\(|I|+|J|\leq k\). The induced double filtration therefore +has +\begin{equation}\label{signed:localized-graded} + \gr^W_{-d+k-1}(\mathcal K_A,F) + \simeq + \bigoplus_{\substack{|I|+|J|=k\\ I\ne\varnothing}} + (i_{I,J})_+(\omega_{H_I\cap A_J},F^{(0)}). +\end{equation} +Here \(F^{(0)}_p\omega_{H_I\cap A_J}=0\) for \(p<0\) and is +\(\omega_{H_I\cap A_J}\) for \(p\geq0\). +Here \(A_\varnothing=\mathscr V\), and empty intersections +contribute zero. To check this formula, retain the polar type +using exactly \(I,J\). Its normal denominators are the +\(c_0-1\) equations \(z_\nu\), the \(|I|\) selected \(x\)'s, +and the \(|J|\) selected \(y\)'s. They are the regular +equations of the smooth stratum \(H_I\cap A_J\), whose +dimension is \(d-k+1\). Right closed transfer has no +codimension shift in \(F\), and the excess counts exactly its +normal derivative orders. Mayer--Vietoris boundary maps for +the \(x\)-subunions and the localization boundary for each +selected \(y\) identify these quotients intrinsically with +the support module of that intersection. For the latter +assertion, localization modulo the nonlocalized module in one +transverse \(y\) direction is its first local cohomology in +that direction. A fixed order of the component labels fixes +the residue signs, so the identifications glue. The smooth- +support graded modules are regular holonomic, and their finite +extension \(\mathcal K_A\) is regular holonomic as well. + +The filtration \(W\) has a real realization. Tensor the +finite-pole de Rham comparisons for the regular support +coordinates with the open localization comparison for the +\(y\) coordinates, whose one-coordinate factor is the +cohomology of a punctured disk. These comparisons are +natural for all sublists. The resulting real support and +localization complexes complexify to the de Rham complexes +just computed. The latter are perverse by regular +holonomicity; exact and faithful complexification gives the +same assertion for the real complexes. Their real perverse +images then give \(W\). +On a graded stratum of dimension \(d-k+1\), the real object +is its dual constant object +\(\R^H[d-k+1](d-k+1)\). Its first right filtration step is +zero and its weight is \(-d+k-1\), in agreement with +Equation~\eqref{signed:localized-graded}. Residue signs and +constant normalizations preserve its real polarization. This +is the real comparison in \cite[Section~11.2]{BL}, with the +punctured-disk factors supplying the additional localization +boundaries. + +The proper-support check also survives localization. If a +holomorphic germ \(f\) vanishes on reduced \(H\), then +\begin{equation}\label{signed:support-condition} + fF_p\mathcal K_A\subset F_{p-1}\mathcal K_A. +\end{equation} +For a generator \(z_\nu\) of \(\mathscr I_H\), multiplication +reduces its pole order or kills the class. Multiplication by +\(x_1\cdots x_t\) also lowers the excess or kills the class, +because the polar type always has \(I\ne\varnothing\). +The \(y\)-poles do not affect this argument. In particular +every graded stratum stays in the proper support \(H\), and +properness is needed only there. + +We have now identified the order filtration, its real pure stratum pieces, +and the proper support of each level. We next pass these data to the base. +Apply Saito's constant-source Kähler direct-image theorem +\cite[Theorem~1 and Remark~1.2]{SaitoKahler} to each smooth +closed stratum in Equation~\eqref{signed:localized-graded}, +using its stipulated relative Kähler form. The resulting +degree-\(j\) direct image of the step indexed by \(\lambda\) +is strict and polarizable real pure of weight \(\lambda+j\). +In the submersion neighborhood, the level-\(F_p\) relative +right de Rham complex has term +\[ + F_{p-e}\mathcal K_A\otimes\bigwedge^e T_{\mathscr V/Y} + \quad\text{in degree }-e. +\] +The simultaneous excess and branch bounds show that passing +to a \(W\)-quotient commutes with taking each such level. + +To prove strictness, use the finite \(W\) spectral sequence +\[ + E_1^{-\lambda,j+\lambda} + =\mathcal H^j q_+\gr^W_\lambda\mathcal K_A + \quad\Longrightarrow\quad \mathcal H^j q_+\mathcal K_A. +\] +Its first-page terms and their level filtrations are strict +pure objects by the preceding application. The differentials +are real and filtration preserving, because the support and +localization comparisons are real and natural. The first +differential preserves weight, hence is a strict morphism of +pure Hodge modules; its kernels and cokernels remain pure. +A higher differential sends \((\lambda,j)\) to +\((\lambda-k,j+1)\) for \(k\geq2\) and strictly lowers +weight. Such a real filtered map is zero. On distinct strict +supports this follows from strict support; on the same dense +smooth support a real map preserves both Hodge filtrations, +and a source vector of type \((p,q)\) would have image in +\(F^p\cap\overline F^q\) of a pure object of smaller weight, +which is zero. Both the unfiltered and each level spectral +sequence therefore degenerate at the second page. Their +comparison is injective there. A least-\(W\)-step argument +on the finite abutment proves injection at every \(F\) level +and strictness of its induced \(W\) filtration. This is the +strict-direct-image argument of \cite[Proposition~11.1]{BL}, +now justified for every graded term with \(A\)-poles. + +For \(p<0\), the relative complex is zero. For \(p=0\), its +only term is \(F_0\mathcal K_A=i_*\omega_H(A)\) in degree +zero. The level injection gives +Equation~\eqref{signed:lowest-step}. + +Suppose finally that \(Y\) is smooth projective. Each strict- +support pure quotient just obtained is of exactly the type in +\cite[Lemma~11.2]{BL}: a polarizable real pure direct-image +piece arising from a dual constant on a smooth Kähler source. +That lemma compares its actual right filtration with the +Sabbah--Schnell pure component extending the same generic +polarized real variation. Its proof uses uniqueness of the +intermediate extension and the reconstruction of \(F\) from +the canonical \(V\)-filtration, so it depends only on this +pure piece, not on the divisor presentation of its source. +It gives the negative-ample vanishing +\[ + \mathbb H^u\bigl(Y,N^{-1}\otimes\gr^F_p\mathrm{DR}_Y Q\bigr)=0 + \quad(u<0) +\] +for each pure quotient \(Q\), by +\cite[Theorem~16.3.10]{SabbahSchnell}. The finite strict +filtration extends this vanishing to \(M^j\). Since its +negative \(F\) levels vanish, its degree-one graded right +de Rham complex is exactly +\[ + \gr^F_1\mathrm{DR}_Y M^j= + \left[F_0M^j\otimes T_Y\xrightarrow{\sigma}\gr^F_1M^j\right] + \quad\text{in degrees }-1,0. +\] +Its negative hypercohomology after tensoring by \(N^{-1}\) +is \(H^0(Y,N^{-1}\otimes\Ker\sigma)\). It vanishes, which +is Equation~\eqref{signed:symbol-vanishing}. This calculation +does not assume that the kernel is locally free. +\end{proof} + +\subsection{Lifting every finite boundary neighborhood} + +Return to the charts and resolution of +Lemma~\ref{signed:root-charts} and +Equation~\eqref{signed:resolved-divisors}. On an empty chart the sheaves +below are zero. On a nonempty chart put \(I=\OO_Z(-S)\), an invertible +ideal. For every integer \(j\) +and positive integer \(k\), put +\[ + \mathcal A_j=I^j/I^{j+1}=\OO_S(-jS),\qquad + \mathcal T_{j,k}=I^j/I^{j+k}. +\] +These are sheaves on the underlying topological space of \(S\). +Pushforward by \(g\) has that meaning for \(\mathcal T_{j,k}\); +it does not require a morphism from a thickening to \(U\). +A local frame of \(R_U^{-1}\) gives a Laurent graded frame +\(u^j\) of \(\mathcal A_j\) for every \(j\). It is a frame +on the associated graded, not an extension of a frame to \(Z\). + +\begin{proposition}[All finite lifting orders]\label{signed:all-orders} +For every root chart, every \(j\in\Z\), and every \(k\geq1\), +the map of sheaves of complex vector spaces on \(U\) +\begin{equation}\label{signed:all-order-surjection} + g_*\mathcal T_{j,k+1}\longrightarrow g_*\mathcal T_{j,k} +\end{equation} +is surjective. The assertion holds on every parameter germ, +including germs supported at special parameters. +\end{proposition} + +\begin{proof} +The assertion is immediate for an empty chart. We induct on \(k\), +simultaneously for all integer \(j\) and all nonempty charts. The layer +algebra and its connecting maps are the +ones in \cite[Lemma~12.1]{BL}; we recall their construction to +specify exactly which obstruction is to be killed. + +Assume all smaller orders. The connecting map for +\[ + 0\longrightarrow\mathcal A_{j+k} + \longrightarrow\mathcal T_{j,k+1} + \longrightarrow\mathcal T_{j,k}\longrightarrow0 +\] +factors uniquely through a map +\begin{equation}\label{signed:obstruction} + \delta_k:g_*\mathcal A_j\longrightarrow R^1g_*\mathcal A_{j+k}. +\end{equation} +Indeed the smaller orders make +\(g_*\mathcal T_{j,k}\to g_*\mathcal A_j\) surjective. For +\(k>1\), the kernel comes from \(g_*\mathcal T_{j+1,k-1}\), +by the leading-layer sequence. The order \(k-1\) in degree +\(j+1\) lifts this kernel into \(g_*\mathcal T_{j,k+1}\), so +the current connecting map kills it. For \(k=1\) the leading +map is the identity. Vanishing of all maps in +Equation~\eqref{signed:obstruction} is equivalent to the +surjectivity at the current order. + +The maps \(\delta_k\) form a degree-\(k\) derivation on the +Laurent graded algebra \(\bigoplus_jg_*\mathcal A_j\), with +values in its first-cohomology module. On a parameter germ, choose a lift +of a leading section \(x\) to \(g_*\mathcal T_{j,k}\), and represent that +lift locally by \(x_\alpha\in I^j\). Then +\(x_\beta-x_\alpha\in I^{j+k}\). +Their differences modulo \(I^{j+k+1}\) represent +\(\delta_k(x)\). For another degree-\(l\) section \(z\), +the product difference is +\[ + x_\beta z_\beta-x_\alpha z_\alpha + =x_\alpha(z_\beta-z_\alpha)+z_\alpha(x_\beta-x_\alpha) + +(x_\beta-x_\alpha)(z_\beta-z_\alpha). +\] +The last term lies in \(I^{j+l+2k}\subset I^{j+l+k+1}\). +This proves the derivation rule. If \(t_1,\ldots,t_b\) are +coordinates on \(U\), choose simultaneous representatives +\(G_{i,\alpha}\) of their lifts to \(g_*\mathcal T_{0,k}\); their +differences lie in \(I^k\). Taylor's +formula modulo their squared differences gives, for any +holomorphic \(F\), +\begin{equation}\label{signed:chain-rule} + \delta_k(F(t))=\sum_i F_{t_i}(t)\delta_k(t_i). +\end{equation} +Both formulas hold on germs, without removing torsion in the +target, and commute with the prescribed germ comparisons. + +Put \(m_k=a+k>0\). An order-\(k\) obstruction raises degree by \(k\), +whereas the residue injection accepts degree \(-a\). We therefore test +leading sections \(x\) of degree \(-m_k=-(a+k)\). Apply the split residue +injection to define +\[ + c(x)=\operatorname{res}_*\delta_k(x),\qquad + e_i(x)=\operatorname{res}_*\bigl(x\delta_k(t_i)\bigr) + \quad\text{in }R^1h_*\omega_H(A). +\] +Both arguments have degree \(-a\), the degree of +\(\OO_S(aS)\) in Equation~\eqref{signed:residue-injection}. +The next construction places these classes in a filtered direct-image +module. For the identity graph, the calculation will give the undivided +relation \(c(x)+\sum_i e_i(x)\partial_{t_i}=0\). Taking its degree-one +symbol gives \(\sigma(\sum_i e_i(x)\otimes\partial_{t_i})=0\). +We will globalize that +symbol on a projective coordinate-power cover, where the boundary root is +an ample line. The adjugate formula expresses the symbol across the +ramification of this cover without dividing by its Jacobian determinant. +The symbol vanishing will then kill the obstructions of the parameter coordinates +on every stalk; the undivided relation will kill \(\delta_k(x)\), and the +derivation rule will recover the other degrees. + +Let \(\psi:U'\to U\) be a holomorphic map between coordinate +opens of dimension \(b\), with coordinates \(w\) on \(U'\), +transverse to every smooth closed stratum \(H_I\cap A_J\). +The identity map is allowed. In \(\widehat Z\times U'\), +the graph support \(H^\flat=H\times_U U'\) is an SNC divisor +in a smooth complete intersection of codimension \(b\). +The residual divisor remains transverse. After shrinking about a +compact fiber, the finite-component Lemma~10.3 of \cite{BL} +gives finite smooth indexing of the graph strata, and their +relative Kähler forms restrict from the product neighborhood. +Complete-intersection adjunction gives the canonical factor +\[ + \omega_{U'}\otimes\psi^*\omega_U^{-1}, +\] +whose coordinate frame we denote by \(dw/dt\). This is a +ratio of canonical frames, with no inverse Jacobian. Pull +the Čech representatives of \(c(x),e_i(x)\) to this graph +and tensor by that frame. Proposition~\ref{signed:localized-hodge} +places the resulting classes \(\widetilde c,\widetilde e_i\) +in \(F_0M^\flat\), where \(M^\flat\) is the degree-one +direct-image module of the localized graph support. + +Write \(J=(\partial\psi_i/\partial w_j)\) and +\(J^\#=\operatorname{adj}(J)\). Because the adjugate is polynomial in +\(J\), the following identity remains meaningful where \(J\) is singular: +\begin{equation}\label{signed:adjugate} + \widetilde c\det J+ + \sum_{i,j}(\widetilde e_i\partial_{w_j})J^\#_{ji}=0 + \quad\text{in }M^\flat. +\end{equation} +We verify the change from \cite[Lemma~12.2]{BL} explicitly. +Choose simultaneous representatives of the lifts to length \(k\) +\[ + x_\alpha\in I^{-a-k},\quad x_\beta-x_\alpha\in I^{-a}, + \qquad G_{i,\beta}-G_{i,\alpha}\in I^k. +\] +After pulling to \(\widehat Z\), put +\(\eta_\alpha=x_\alpha\tau\), using the meromorphic form +defined by Equation~\eqref{signed:adjoint-chart}, and put +\(Q_{i,\alpha}=\psi_i(w)-G_{i,\alpha}\), +\(P_\alpha=\prod_iQ_{i,\alpha}\). On an overlap write +\(\Delta_i=G_{i,\beta}-G_{i,\alpha}\). The insertion and +\(D_S\geq H\) give the precise pole bounds +\begin{align} + \eta_\alpha&\in\omega_{\widehat Z}(H+A+kD_S),\nonumber\\ + \eta_\beta-\eta_\alpha,\quad \eta_\alpha\Delta_i + &\in\omega_{\widehat Z}(H+A),\label{signed:pole-bounds}\\ + \eta_\alpha\Delta_i\Delta_l,\quad + (\eta_\beta-\eta_\alpha)\Delta_i + &\in\omega_{\widehat Z}(H+A-kD_S) + \subset\omega_{\widehat Z}(A).\nonumber +\end{align} +Thus every quadratic or cross difference has no \(H\)-pole, +although it may retain a pole on \(A\). Such a term is zero +in the support module localized along \(A\). + +In that localized graph support module consider the finite +generalized fractions +\[ + S_\alpha=\left[\frac{\eta_\alpha\wedge dw}{P_\alpha}\right]. +\] +The \(H\)-pole is already in the numerator. Each polar class +is killed by a power of a reduced equation of \(H\), and each +\(\Delta_i\) is a multiple of that equation. +Changing \(Q_{i,\alpha}\) to \(Q_{i,\beta}\) therefore has a +finite geometric expansion on each class. The last line of +Equation~\eqref{signed:pole-bounds} kills all terms beyond the +linear terms, and gives the exact equality +\[ + S_\beta-S_\alpha= + \left[\frac{(\eta_\beta-\eta_\alpha)\wedge dw}{P_\alpha}\right] + +\sum_i\left[ + \frac{\eta_\alpha\Delta_i\wedge dw} + {Q_{i,\alpha}P_\alpha}\right]. +\] +Let \(C_\bullet\) be the first cochain. Let \(E_{i,\bullet}\) +be the cochain with the numerator of the \(i\)-th summand and +only denominator \(P_\alpha\), and let \(E_{i,\bullet}^{(l)}\) +have its additional denominator \(Q_{l,\alpha}\). The simple +cochains \(C_\bullet,E_{i,\bullet}\) are cocycles representing +\(\widetilde c,\widetilde e_i\); their possible triple-overlap +errors are precisely the cross terms killed above. The normal +residue frame in this identification is \(dw/dt\). + +The numerator of \(E_{i,\bullet}\), including its \(A\)-poles, +is independent of \(w\). Right differentiation therefore gives +\[ + E_{i,\bullet}\partial_{w_j}=\sum_lJ_{lj}E_{i,\bullet}^{(l)}. +\] +The preceding fraction equality is +\(\check dS_\bullet=C_\bullet+\sum_iE_{i,\bullet}^{(i)}\). +Multiplying by \(\det J\) and using \(JJ^\#=(\det J)\id\) +gives at the cochain level +\[ + \check d(S_\bullet\det J)=C_\bullet\det J+ + \sum_{i,j}(E_{i,\bullet}\partial_{w_j})J^\#_{ji}. +\] +These cochains are in the end term of the relative right de +Rham complex, so a Čech coboundary there is a total +coboundary. Passing to the direct image proves +Equation~\eqref{signed:adjugate}, with \(J^\#_{ji}\) placed +after the right derivative as displayed. Passing to +\(\gr^F_1\) yields +\begin{equation}\label{signed:local-symbol} + \sigma\left(\sum_{j,i}J^\#_{ji}\widetilde e_i + \otimes\partial_{w_j}\right)=0. +\end{equation} +For \(\psi=\id\) the undivided identity is +\begin{equation}\label{signed:undivided} + c(x)+\sum_i e_i(x)\partial_{t_i}=0. +\end{equation} +For \(b=0\) there are no graph equations, and the same +undivided cochain computation gives \(c(x)=0\). + +We now prove that the obstructions of the parameter coordinates vanish on every +stalk, including an obstruction supported only at a special parameter. +Suppose \(b>0\), and fix \(t_*\in P\). We will use one compact graph over +a projective parameter space, obtained by a parameter change unbranched +above \(t_*\). The vanishing of +\(\Hom\) in Equation~\eqref{signed:symbol-vanishing} applies to the entire +coherent symbol kernel, and the local isomorphism +above \(t_*\) will detect vanishing on the full germ there. The +construction of \cite[Proposition~10.5]{BL} gives a coordinate- +power map, here of exponent \(\ell\), +\[ +\begin{gathered} + \psi:P'=\PP^b\longrightarrow P,\qquad + [w_0:\cdots:w_b]\longmapsto[w_0^\ell:\cdots:w_b^\ell],\\ + R=\OO_{P'}(1),\qquad R^\ell\simeq\psi^*\OO_P(1), +\end{gathered} +\] +in suitably chosen coordinates, unbranched over \(t_*\). +We spell out why its geometry also accommodates \(A\). +Choose finitely many relatively compact parameter opens +covering \(\phi(D)\), with the chart resolutions defined on +slightly larger opens. Empty charts contribute no strata. Properness of +the nonempty supports leaves +only finitely many closed smooth strata \(H_I\cap A_J\) meeting +the corresponding compact sets. A general tuple of coordinate +hyperplanes is transverse to the maps of every such stratum, +for every subtuple, and avoids \(t_*\). This follows by Sard's +theorem applied to the incidence with variable hyperplanes; +varying each hyperplane supplies its normal direction. In +these coordinates \(d\psi\) has image the tangent space to +the intersection of its vanishing coordinate hyperplanes. +The transversality condition is consequently +\[ + dh(T_z(H_I\cap A_J))+d\psi(T_wP')=T_{h(z)}P + \quad\text{whenever }h(z)=\psi(w). +\] +It gives the required simultaneous regular graph equations +and SNC transverse residual divisors. + +To obtain a single compact graph support, first form the compact +graph \(\Xi=D\times_P P'\subset X\times P'\). On it the +pullback of \(N_0\) has the specified root \(R\). Lemma~10.1 +of \cite{BL} extends that root to a neighborhood of \(\Xi\). +Perform the full construction of Lemma~\ref{signed:root-charts} +on this neighborhood, including the relative quotient and its ordinary +pullback, and use the canonical sheaf relative to \(P'\) in the periodicity +algebra; the absolute canonical factor is added only when +taking graph residues. Resolve the same ordered total divisor data before imposing +the graph equations. Near a compact graph slice, the root +comparison lemma identifies this construction with the ordinary +product of a local chart with a parameter open, as an ambient +germ preserving the ideal and the adjoint form. Uniqueness +of the comparison as a germ and properness of the graph allow +a base shrink on which the identification holds on the entire +slice. Normalization thus occurs before ramified graph base +change. Smooth-functorial resolution preserves the product +identification. + +The graph cut \(H'\) in this resolved ambient space is compact, +has pure dimension \(n-1\), and is locally an SNC divisor in +a smooth complete intersection of codimension \(b\). Its +ambient projection to \(P'\) is submersive near \(H'\). +Let \(A'\) be the reduced ambient resolved residual divisor, restricted +to a neighborhood of \(H'\). Under each product-germ identification +it is \(A\times U'\); its restriction to the graph complete intersection +is the transverse residual cut. The chosen transversality makes \(A'\) +simultaneously SNC with the graph support equations. +All closed strata \(H'_I\cap A'_J\) are compact and smooth; +splitting their connected components leaves finitely many +indices. The relative metric construction in +Lemma~\ref{signed:root-charts} gives one Kähler form near +\(H'\), and hence the required forms on every stratum. Thus +Proposition~\ref{signed:localized-hodge} applies to this single +global graph. Write \(M'\) for its degree-one module. + +Take \(x=u^{-m_k}\). On a graph chart choose a frame +\(\vartheta\) of \(R\) compatible with the downstairs frame +of \(\OO_P(1)\). The local rule +\begin{equation}\label{signed:global-symbol} + \vartheta^{m_k}\longmapsto + \sum_{j,i}J^\#_{ji}\widetilde e_i(u^{-m_k}) + \otimes\partial_{w_j} +\end{equation} +defines a global morphism +\(R^{m_k}\to F_0M'\otimes T_{P'}\). Here is the transition +check, including the ramification locus. For changes of +coordinates let \(A_t=\partial t'/\partial t\) and +\(B_w=\partial w'/\partial w\), and let the root frame change +by \(\vartheta'=\lambda\vartheta\). Locally \(\lambda\) +descends from a holomorphic unit downstairs: its \(\ell\)-th +power does, and after choosing a local \(\ell\)-th root of +that unit the remaining ratio is a locally constant element +of \(\mu_\ell\). Root germ compatibility and +Equation~\eqref{signed:chain-rule} transform the downstairs +column of \(e_i\)'s by \(\lambda^{m_k}A_t\). No derivative +of \(\lambda\) appears, since \(x\) multiplies outside +\(\delta_k(t_i)\). The absolute canonical factor changes +by \(\det B_w/\det A_t\). Hence +\[ +\begin{aligned} + \widetilde e'&=\frac{\det B_w}{\det A_t}\lambda^{m_k}A_t\widetilde e, + &J'&=A_tJB_w^{-1},\\ + (J')^\#\widetilde e'&=\lambda^{m_k}B_wJ^\#\widetilde e. +\end{aligned} +\] +The adjugate equality is polynomial in \(J\), so holds also +when \(J\) is singular. The last formula, together with the +inverse change of the vector basis, is exactly the transition +of Equation~\eqref{signed:global-symbol}. The graph classes +here are natural Čech pullbacks through ambient germs; no +ramified base-change isomorphism for \(R^1h_*\) is used. + +Equation~\eqref{signed:local-symbol} puts the image of this +morphism in the first-symbol kernel. Since +\(R^{m_k}=\OO_{\PP^b}(a+k)\) is ample, +Equation~\eqref{signed:symbol-vanishing} makes the morphism +zero. At a point above \(t_*\), the map \(\psi\) is locally +biholomorphic and \(J^\#\) is invertible. The ambient germ +comparison identifies the graph classes with the downstairs +classes there. Thus \(e_i(u^{-m_k})=0\) as germs at +\(t_*\), including any class supported there. The point was +arbitrary, so these classes vanish on every chart. + +The split injection in Lemma~\ref{signed:residue} and the +invertible Laurent frame now give \(\delta_k(t_i)=0\). +For every leading section \(x\) of degree \(-m_k\), the +classes \(e_i(x)\) vanish. Equation~\eqref{signed:undivided}, +the injection in Equation~\eqref{signed:lowest-step}, and +then the split residue injection give \(\delta_k(x)=0\). +When \(b=0\), the direct identity \(c(x)=0\) and the same +two injections give this conclusion without a graph test. +In particular, the derivation rule and characteristic zero give +\[ + 0=\delta_k(u^{-m_k})=-m_k u^{-m_k-1}\delta_k(u), + \qquad \delta_k(u)=0. +\] +For any local \(F\in g_*\OO_S\), the degree-\(-m_k\) section +\(Fu^{-m_k}\) then gives +\(0=\delta_k(Fu^{-m_k})=u^{-m_k}\delta_k(F)\). +Every graded section is \(Fu^j\), so \(\delta_k\) vanishes +in every degree. This proves the current order and completes +the induction. +\end{proof} + +\subsection{Compact deformations and the signed theorem} + +We now turn the infinitesimal lifting into actual compact +subspaces. The role of all the integer layers in +Proposition~\ref{signed:all-orders} is that both the equations +of a boundary fiber and a generator of its normal direction +can be lifted compatibly. This is the analytic counterpart of +the compact-family step in \cite[Proposition~5.1]{LI}. + +\begin{lemma}\label{signed:escaping-fibers} +Assume \(00\). +On the selected component the locus where it is singular or +where \(g\) has rank less than \(r\) is proper. Removing its +image, along with the preceding proper bad subsets, under the +finite map leaves a nonempty open \(D_i^\circ\subset D_i\). +Its points have preimages at smooth points of these fiber +components. + +Fix \(x\in D_i^\circ\) and a point above it in the compact +fiber \(F=g^{-1}(t)\), for \(t\in Y\). Work on the single +ordinary chart neighborhood of that fiber from +Lemma~\ref{signed:root-charts}. Take regular coordinates +\(t_1,\ldots,t_r\) on \(Y\) centered at \(t\), extended to +local coordinates of its smooth embedding in \(P\). Their +pullbacks form a regular sequence on \(S\) along \(F\), +by flatness. In addition, \(S\) is Cohen--Macaulay, so +\(F\) is Cohen--Macaulay of pure dimension \(d\). + +Choose once and for all a Hausdorff open neighborhood +\(W\subset Z\) of \(F\), disjoint from \(T\), on which +\(\pi\) is quasi-finite. Set \(I=\OO_Z(-S)\). +Proposition~\ref{signed:all-orders} lets us lift the finitely +many \(t_i\)'s to compatible germs of sections of \(\OO_Z/I^q\), +\(q\geq1\), along \(F\). It also lifts the conormal frame +\(u\in I/I^2\) to compatible germs +\(\widetilde y_q\in I/I^{q+1}\) along \(F\); write \(\widetilde y\) +for this system. At each order choose simultaneous +representatives on a neighborhood of \(F\) contained in +\(W\). These neighborhoods may shrink with the order. +The leading coefficient of \(\widetilde y\) is a unit +frame, so it generates \(I\) on each finite thickening. + +For \(R_q=\C[s]/(s^q)\), cut the lifted \(r\) equations in +the Cartier thickening \(qS\), and map \(s\) to +\(\widetilde y\). Denote the resulting subspace by +\(F_q\). It is flat over the Artin analytic point +\(\Spec R_q\), with closed fiber \(F\). Before cutting, +multiplication by the Cartier generator identifies each +successive \(s\)-layer with \(\OO_S\); this is the +flatness criterion over \(R_q\). Quotienting by lifts of +the closed-fiber regular sequence preserves flatness, by +the local flatness criterion. Compatibility of the lifted +equations gives compatible reductions of all \(F_q\). + +Each of these is an embedded compact deformation in the +same fixed neighborhood \(W\). To see why the shrinking +representative neighborhoods cause no difficulty, the +support of \(F_q\) is the fixed compact set \(F\). Its +ideal on its representative neighborhood glues with the +unit ideal on \(W\setminus F\), since the deformation is +empty on their overlap away from \(F\). This realizes it +as a closed subspace of \(W\times\Spec R_q\). The ideal +is coherent locally on both opens, and the family is proper +over the Artin point because its support is compact. + +The Douady space of compact subspaces of \(W\) represents +proper flat embedded families \cite[Section~9]{Douady1966}. +The compatible \(F_q\)'s thus define a formal arc in its +analytic germ at \([F]\). Embed that germ in a finite +dimensional analytic coordinate space. The arc is a formal +solution of its convergent defining equations. Analytic +Artin approximation \cite[Theorem~1.2]{Artin1968} gives a +convergent arc agreeing modulo \(s^2\). Pull back the +universal family and shrink its disk to obtain +\(\mathscr F\subset W\times\Delta\), proper and flat over +\(\Delta\), with closed fiber \(F\) and the prescribed +first normal displacement. + +The family may be taken to have pure \(d\)-dimensional +fibers throughout the disk. Here is a local justification. +The central fiber is Cohen--Macaulay of dimension \(d\). +Flatness over the regular one-dimensional base makes its +parameter a nonzerodivisor and gives the depth and dimension +of the total local ring as \(d+1\) along that fiber. +Cohen--Macaulayness is open for analytic local rings, and +properness allows a disk shrink for which it holds on the +whole family. Every total component then meets the central +fiber after shrinking, and flatness makes it dominate the +disk; the dimension formula gives it dimension \(d+1\). +Quotient by the nonzerodivisor at each +parameter gives Cohen--Macaulay fibers of dimension \(d\). +The analytic dimension formula and unmixedness of these +local rings give the asserted purity. + +Let \(f\) be a local equation of \(S\). On \(\mathscr F\) +it vanishes on the central fiber, so flatness writes it as +\(f=s h\). Agreement modulo \(s^2\) with the formal +deformation says that \(h|_F\) is a unit: this is precisely +the lifted conormal generator. Finitely many such +neighborhoods cover the compact \(F\). Properness of +\(\mathscr F\to\Delta\) lets us shrink the disk so that +they cover the entire family and all their \(h\)'s are +units; remove the closed image of the complement. Thus a +nonzero fiber misses \(S\). The neighborhood \(W\) already +misses \(T\), and the set equality in Lemma~\ref{signed:root-charts} gives +\(\pi^{-1}(|D|)\cap W=|S|\cap W\). Hence the +nonzero fiber images miss \(D\). + +The induced map \(\Pi:\mathscr F\to X\times\Delta\) is proper: +the source is proper over \(\Delta\) and the target is +Hausdorff over it, so the graph is closed and the projection +is proper. It is quasi-finite by the choice of \(W\), +hence finite. It therefore preserves the dimension of +every fiber component. Every total component through a central +point dominates the disk by flatness, and its punctured part is dense. +Thus every central point, including the point chosen above \(x\), +is a limit of points of nonzero fibers of dimension \(d\). + +Let \(\mathscr Z\subset X\times\Delta\) be the schematic +image of this finite map. Its algebra is the coherent image +of \(\OO_{X\times\Delta}\to\Pi_*\OO_{\mathscr F}\). +Multiplication by a nonzero +germ from the disk is injective on \(\OO_{\mathscr F}\), +by flatness, and remains injective after the exact finite +pushforward. It is therefore injective on the image algebra. +That algebra is torsion-free, hence flat, over each local +discrete valuation ring of the disk. Thus \(\mathscr Z\) +is a proper flat family of subspaces of \(X\). The finite +map to its schematic image is surjective, also on each +fiber as a map of supports. Each \(\mathscr Z_s\) consequently +has pure dimension \(d\). The Douady-to-cycle morphism, in the +form recorded in \cite[Section~3.3]{Fujiki1978}, makes their +fundamental cycles an analytic family in the cycle space +of \(X\). The restriction to a smaller closed disk is +compact. The volumes of these cycles against a Kähler +form are bounded by continuity, proving the last assertion. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{signed:torsion}] +The assertion is immediate in dimension zero, and the case +\(D=0\) follows directly from the signed equivalence. By +Lemma~\ref{signed:boundary-geometry}, the case \(v=0\) +already gives \(L\sim_{\Q}0\), and \(v=n>0\) contradicts +\(a(X)=0\). Suppose, therefore, that \(0=Latex, font=\small, + variety/.style={draw=MidnightBlue!60,rounded corners=2pt, + fill=MidnightBlue!3,align=center,minimum width=43mm, + minimum height=11mm}, + every edge/.style={draw,->,thick}, + note/.style={font=\footnotesize,align=center}] +\node[font=\bfseries] at (3,1.0) {CM transport}; +\node[variety] (A) at (0,0) {$A^n/\Qbar$}; +\node[variety] (C) at (6,0) {$C/\Qbar$\quad(CM)}; +\node[variety] (A0) at (0,-1.7) {$A_0^n$}; +\node[variety] (C0) at (6,-1.7) {$C_0$}; +\path (A) edge node[left,note] {reduction} (A0); +\path (C) edge node[right,note] {reduction} (C0); +\path (A0) edge node[above] {$a_{\mathrm{CM}}$} (C0); +\node[note] at (3,-2.65) {$\gamma_0=(a_{\mathrm{CM}}j)^*\kappa_0$}; +\node[font=\bfseries] at (3,-3.3) {Prescribed-filtration transport}; +\node[variety] (Z) at (0,-4.4) {$Z^m/\Qbar$\quad(balanced Weil)}; +\node[variety] (B) at (6,-4.4) {$B/K$, $K/K_0$ finite}; +\node[variety] (Z0) at (0,-6.1) {$Z_0^m$}; +\node[variety] (B0) at (6,-6.1) {$B_0$}; +\path (Z) edge node[left,note] {reduction} (Z0); +\path (B) edge node[right,note] {reduction} (B0); +\path (Z0) edge node[above] {$a_{\mathrm{fl}}$} (B0); +\node[note] at (3,-7.05) + {$a_{\mathrm{fl}}^*\Fil^1H^1_{\mathrm{dR}}(B) + =(\mathcal F_Z^1)^{\oplus m}$}; +\end{tikzpicture} diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/main.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..3b75da36136b6a67ae6353e640a6d85a81634301 --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/main.tex @@ -0,0 +1,73 @@ +\documentclass[11pt]{article} +\usepackage[a4paper,margin=28mm]{geometry} +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{microtype} +\usepackage{enumitem} +\usepackage{booktabs} +\usepackage[dvipsnames]{xcolor} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning} +\usepackage[colorlinks=true,linkcolor=MidnightBlue,citecolor=MidnightBlue,urlcolor=MidnightBlue,breaklinks=true]{hyperref} +\hypersetup{pdftitle={Milne's rationality conjecture for abelian varieties}, + pdfsubject={Rational pairings of specialized Hodge classes with Lefschetz classes}, + pdfauthor={OpenAI}} +\setlength{\emergencystretch}{2em} +\setlist[enumerate]{itemsep=3pt,topsep=5pt} +\setlist[itemize]{itemsep=3pt,topsep=5pt} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\numberwithin{equation}{section} +\newcommand{\Q}{\mathbb Q} +\newcommand{\Z}{\mathbb Z} +\newcommand{\R}{\mathbb R} +\newcommand{\C}{\mathbb C} +\newcommand{\F}{\mathbb F} +\newcommand{\Qbar}{\overline{\mathbb Q}} +\newcommand{\Kzero}{K_0} +\newcommand{\Cw}{C_w} +\DeclareMathOperator{\End}{End} +\DeclareMathOperator{\Hom}{Hom} +\DeclareMathOperator{\Tr}{Tr} +\DeclareMathOperator{\Fil}{Fil} +\DeclareMathOperator{\Res}{Res} +\DeclareMathOperator{\GSp}{GSp} +\DeclareMathOperator{\GL}{GL} +\DeclareMathOperator{\SL}{SL} +\DeclareMathOperator{\SU}{SU} +\DeclareMathOperator{\MT}{MT} +\DeclareMathOperator{\Lef}{Lef} +\DeclareMathOperator{\NS}{NS} +\DeclareMathOperator{\Gal}{Gal} +\DeclareMathOperator{\id}{id} +\DeclareMathOperator{\Spec}{Spec} +\title{Milne's rationality conjecture\protect\\ for abelian varieties} +\author{OpenAI} +\date{October 7, 2026} +\begin{document} +\maketitle +\vspace{-1em} +\begin{abstract} +We prove Milne's rationality conjecture for abelian varieties, including +residue characteristic \(2\). After good reduction, the pairing of a +rational Hodge class with any complementary product of divisor classes +on the reduction is the same rational number in every prime-to-\(p\) +realization and in crystalline cohomology. Using the Hodge theorem for CM +abelian varieties, we also show that every such specialized Hodge class +is represented by a single rational algebraic cycle in all these realizations. +\end{abstract} +\input{sections/00_intro} +\input{sections/01_preliminaries} +\input{sections/02_transport} +\input{sections/03_filtration} +\input{sections/04_weil} +\input{sections/05_reduction} +\input{references} +\end{document} diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/references.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/references.tex new file mode 100644 index 0000000000000000000000000000000000000000..418e678f30e6d8aa4c0d8c3b513d9ca01a9fce80 --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/references.tex @@ -0,0 +1,274 @@ +\begin{thebibliography}{Stacks} + +\bibitem[And92]{Andre1992} +Y.~Andr\'e, +\emph{Une remarque \`a propos des cycles de Hodge de type CM}, +in S.~David (ed.), \emph{S\'eminaire de Th\'eorie des Nombres, +Paris, 1989--90}, Progress in Math. \textbf{102}, +Birkh\"auser Boston, Boston, MA, 1992, 1--7. + +\bibitem[And96]{Andre1996} +Y.~Andr\'e, +\emph{Pour une th\'eorie inconditionnelle des motifs}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{83} (1996), 5--49. +\href{https://doi.org/10.1007/BF02698643}{doi:10.1007/BF02698643}. +\href{https://www.numdam.org/item/10.1007/BF02698643.pdf}{Original article}. + +\bibitem[Bla94]{Blasius1994} +D.~Blasius, +\emph{A $p$-adic property of Hodge classes on abelian varieties}, +in \emph{Motives} (Seattle, WA, 1991), Part~2, +U.~Jannsen, S.~Kleiman, and J.-P.~Serre (eds.), +Proc. Sympos. Pure Math. \textbf{55}, Part~2, +American Mathematical Society, Providence, RI, 1994, 293--308. +\href{https://doi.org/10.1090/pspum/055.2/1265557}{doi:10.1090/pspum/055.2/1265557}. +\href{https://archive.mpim-bonn.mpg.de/id/eprint/3859/1/preprint_1992_59.pdf}{Author's preprint}. + +\bibitem[CF00]{ColmezFontaine2000} +P.~Colmez and J.-M.~Fontaine, +\emph{Construction des repr\'esentations $p$-adiques semi-stables}, +Invent. Math. \textbf{140} (2000), no.~1, 1--43. +\href{https://doi.org/10.1007/s002220000042}{doi:10.1007/s002220000042}. +\href{https://www.imo.universite-paris-saclay.fr/~fontaine/CF.pdf}{Author's version}. + +\bibitem[Con03]{Conrad2003} +B.~Conrad, +\emph{Minimal models for elliptic curves}, notes, 20 October 2003. +\href{https://math.stanford.edu/~conrad/vigregroup/vigre03/minimalmodel.pdf}{Author's notes}. + +\bibitem[Del82]{Deligne1982} +P.~Deligne, +\emph{Hodge cycles on abelian varieties} (notes by J.~S.~Milne), +in P.~Deligne, J.~S.~Milne, A.~Ogus, and K.-y.~Shih, +\emph{Hodge Cycles, Motives, and Shimura Varieties}, +Lecture Notes in Math. \textbf{900}, Springer-Verlag, +Berlin--New York, 1982, 9--100. +\href{https://www.jmilne.org/math/Documents/Deligne82.pdf}{Corrected online version}. + +\bibitem[FR05]{FontaineRapoport2005} +J.-M.~Fontaine and M.~Rapoport, +\emph{Existence de filtrations admissibles sur des isocristaux}, +Bull. Soc. Math. France \textbf{133} (2005), no.~1, 73--86. +\href{https://doi.org/10.24033/bsmf.2479}{doi:10.24033/bsmf.2479}. +\href{https://www.numdam.org/article/BSMF_2005__133_1_73_0.pdf}{Published version}. + +\bibitem[GLX26]{GleasonLimXu2026} +I.~Gleason, D.~G.~Lim, and Y.~Xu, +\emph{The connected components of affine Deligne--Lusztig varieties}, +Invent. Math. \textbf{243} (2026), 805--861. +\href{https://doi.org/10.1007/s00222-025-01386-1}{doi:10.1007/s00222-025-01386-1}. +\href{https://arxiv.org/abs/2208.07195v3}{arXiv:2208.07195v3} +(10 November 2025); preprint locators refer to +\href{https://arxiv.org/pdf/2208.07195v3}{this version}. + +\bibitem[Gro71]{Grothendieck1970} +A.~Grothendieck, +\emph{Groupes de Barsotti-Tate et cristaux}, +in \emph{Actes du Congr\`es International des Math\'ematiciens} +(Nice, 1970), Tome~1, Gauthier-Villars, Paris, 1971, 431--436. +\href{https://webusers.imj-prg.fr/~leila.schneps/grothendieckcircle/GroupesB-T.pdf}{Original article}. + +\bibitem[Har08]{Hartl2008} +U.~Hartl, +\emph{On period spaces for $p$-divisible groups}, +C. R. Math. Acad. Sci. Paris \textbf{346} (2008), nos.~21--22, 1123--1128. +\href{https://doi.org/10.1016/j.crma.2008.07.003}{doi:10.1016/j.crma.2008.07.003}. +\href{https://comptes-rendus.academie-sciences.fr/mathematique/item/10.1016/j.crma.2008.07.003.pdf}{Published version}. + +\bibitem[Ill15]{IllusiePisa} +L.~Illusie, +\emph{Grothendieck at Pisa: crystals and Barsotti--Tate groups}, +in U.~Zannier (ed.), \emph{Colloquium De Giorgi 2013 and 2014}, +Publications of the Scuola Normale Superiore \textbf{5}, +Edizioni della Normale, Pisa, 2015, 79--107. +\href{https://doi.org/10.1007/978-88-7642-515-8_5}{doi:10.1007/978-88-7642-515-8\_5}. +\href{https://www.imo.universite-paris-saclay.fr/~luc.illusie/Illusie-Pisa5.pdf}{Author's version}. + +\bibitem[Kim12]{Kim2012} +W.~Kim, +\emph{The classification of $p$-divisible groups over $2$-adic discrete +valuation rings}, +Math. Res. Lett. \textbf{19} (2012), no.~1, 121--141. +\href{https://doi.org/10.4310/MRL.2012.v19.n1.a10}{doi:10.4310/MRL.2012.v19.n1.a10}. +\href{https://arxiv.org/abs/1007.1904v3}{arXiv:1007.1904v3} +(30 December 2011); preprint locators refer to +\href{https://arxiv.org/pdf/1007.1904v3}{this version}. + +\bibitem[Kis06]{Kisin2006} +M.~Kisin, +\emph{Crystalline representations and $F$-crystals}, +in V.~Ginzburg (ed.), \emph{Algebraic Geometry and Number Theory: +In Honor of Vladimir Drinfeld's 50th Birthday}, +Progress in Math. \textbf{253}, Birkh\"auser Boston, Boston, MA, +2006, 459--496. +\href{https://doi.org/10.1007/978-0-8176-4532-8_7}{doi:10.1007/978-0-8176-4532-8\_7}. + +\bibitem[Kis17]{Kisin2017} +M.~Kisin, +\emph{Mod $p$ points on Shimura varieties of abelian type}, +J. Amer. Math. Soc. \textbf{30} (2017), no.~3, 819--914. +\href{https://people.math.harvard.edu/~kisin/dvifiles/lr.pdf}{Author's version used for all locators}. + +\bibitem[KZ25a]{KisinZhouEarlier} +M.~Kisin and R.~Zhou, +\emph{Independence of $\ell$ for Frobenius conjugacy classes attached to +abelian varieties}, +Ann. of Math. (2) \textbf{202} (2025), no.~3, 1077--1156. +\href{https://doi.org/10.4007/annals.2025.202.3.3}{doi:10.4007/annals.2025.202.3.3}. +\href{https://arxiv.org/abs/2103.09945v2}{arXiv:2103.09945v2} (7 October 2024). +All locators refer to +\href{https://arxiv.org/pdf/2103.09945v2}{arXiv:2103.09945v2}. + +\bibitem[KZ25b]{KisinZhou2025} +M.~Kisin and R.~Zhou, +\emph{Strongly compatible systems associated to semistable abelian varieties}, +preprint, 2025, +\href{https://arxiv.org/abs/2505.02165v1}{arXiv:2505.02165v1} +(deposited 4 May 2025). +\href{https://arxiv.org/pdf/2505.02165v1}{PDF version used for all locators}, +dated 10 June 2025. + +\bibitem[Mar26]{Markman2026} +E.~Markman, +\emph{Secant sheaves and Weil classes on abelian varieties}, +preprint, contribution to the ICM 2026, +\href{https://arxiv.org/abs/2509.23403v2}{arXiv:2509.23403v2} +(11 February 2026). +\href{https://arxiv.org/pdf/2509.23403v2}{Version used for all locators}, +dated 13 February 2026. + +\bibitem[Mil86]{MilneAV} +J.~S.~Milne, +\emph{Abelian varieties}, +in G.~Cornell and J.~H.~Silverman (eds.), \emph{Arithmetic Geometry} +(Storrs, CT, 1984), Springer-Verlag, New York, 1986, 103--150. +\href{https://doi.org/10.1007/978-1-4613-8655-1_5}{doi:10.1007/978-1-4613-8655-1\_5}. +\href{https://www.jmilne.org/math/xnotes/AVs.pdf}{Corrected author's version}, +2 January 2022; original theorem numbering retained. + +\bibitem[Mil99]{Milne1999} +J.~S.~Milne, +\emph{Lefschetz classes on abelian varieties}, +Duke Math. J. \textbf{96} (1999), no.~3, 639--675. +\href{https://www.jmilne.org/math/articles/1999aP.pdf}{Author's version}; +\href{https://www.jmilne.org/math/articles/1999a.html}{author's correction to +the proof of Theorem~5.9}. + +\bibitem[Mil00]{Milne2000} +J.~S.~Milne, +\emph{Towards a proof of the conjecture of Langlands and Rapoport}, +notes for a talk at the Institut Henri Poincar\'e, 28 April 2000, +version dated 30 April 2000. +\href{https://www.jmilne.org/math/articles/2000.pdf}{Author's notes}. + +\bibitem[Mil05]{MilneShimura} +J.~S.~Milne, +\emph{Introduction to Shimura varieties}, +in \emph{Harmonic Analysis, the Trace Formula, and Shimura Varieties}, +Clay Math. Proc. \textbf{4}, American Mathematical Society, +Providence, RI, 2005, 265--378. +\href{https://www.jmilne.org/math/xnotes/svi.pdf}{Author's revision}, +16 September 2017; locators refer to this revision. + +\bibitem[Mil08a]{MilneAIM2007} +J.~S.~Milne, +\emph{The Tate conjecture over finite fields (AIM talk)}, +notes for the American Institute of Mathematics workshop, July 2007, +version~2.2, 7 May 2008. +\href{https://www.jmilne.org/math/articles/2007e.pdf}{Version used for all locators}. + +\bibitem[Mil08b]{MilneAVNotes} +J.~S.~Milne, +\emph{Abelian Varieties}, course notes, version~2.00, 2008, vi+166~pp. +\href{https://www.jmilne.org/math/CourseNotes/AVc.pdf}{Author's course notes}. + +\bibitem[Mil09]{Milne2009} +J.~S.~Milne, +\emph{Rational Tate classes}, +Mosc. Math. J. \textbf{9} (2009), no.~1, 111--141. +\href{https://www.jmilne.org/math/articles/2009b.pdf}{Author's version}; +page numbers refer to this version. + +\bibitem[Mil13]{MilneLEC} +J.~S.~Milne, +\emph{Lectures on \'{E}tale Cohomology}, +course notes, version~2.21, 22 March 2013. +\href{https://www.jmilne.org/math/CourseNotes/LEC.pdf}{Author's notes}. + +\bibitem[MilANT]{MilneANT} +J.~S.~Milne, +\emph{Algebraic Number Theory}, course notes, version~3.08, 19 July 2020. +\href{https://www.jmilne.org/math/CourseNotes/ANTc.pdf}{Author's course notes}. +Locators refer to this version. + +\bibitem[Mil20]{Milne2020} +J.~S.~Milne, +\emph{Hodge classes on abelian varieties}, +preprint, 2020, +\href{https://arxiv.org/abs/2010.08857v2}{arXiv:2010.08857v2} +(11 November 2020). +\href{https://arxiv.org/pdf/2010.08857v2}{Version used for all locators}. + +\bibitem[Mil22]{MilneAG2022} +J.~S.~Milne, +\emph{Algebraic Groups: The Theory of Group Schemes of Finite Type over a Field}, +Cambridge Studies in Advanced Mathematics \textbf{170}, +Cambridge University Press, Cambridge, 2017; corrected reprint, 2022. +\href{https://doi.org/10.1017/9781316711736}{doi:10.1017/9781316711736}. +\href{https://www.jmilne.org/math/Books/iAG2022.pdf}{Corrected 2022 version used for all locators}. + +\bibitem[Mil25]{Milne2025} +J.~S.~Milne, +\emph{Abelian motives and Shimura varieties in nonzero characteristic}, +preprint, version~2.2, 2 November 2025. +\href{https://www.jmilne.org/math/articles/SVp.pdf}{Author's version used for all locators}. + +\bibitem[Moo98]{Moonen1998} +B.~Moonen, +\emph{Models of Shimura varieties in mixed characteristics}, +in A.~J.~Scholl and R.~L.~Taylor (eds.), +\emph{Galois Representations in Arithmetic Algebraic Geometry} +(Durham, 1996), London Math. Soc. Lecture Note Ser. \textbf{254}, +Cambridge University Press, Cambridge, 1998, 267--350. +\href{https://doi.org/10.1017/CBO9780511662010.008}{doi:10.1017/CBO9780511662010.008}. +\href{https://www.math.ru.nl/personal/bmoonen/Papers/SMCfinal.pdf}{Author's version}. + +\bibitem[OAI26]{OpenAICMHodge2026} +OpenAI, +\emph{The rational Hodge conjecture for CM abelian varieties},\newline +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/The-rational-Hodge-conjecture-for-CM-abelian-varieties-October-6-2026/paper.pdf}{OAI:The-rational-Hodge-conjecture-for-CM-abelian-varieties-October-6-2026}, +2026. + +\bibitem[PR24]{PappasRapoport2024} +G.~Pappas and M.~Rapoport, +\emph{$p$-adic shtukas and the theory of global and local Shimura varieties}, +Camb. J. Math. \textbf{12} (2024), no.~1, 1--164. +\href{https://doi.org/10.4310/CJM.2024.v12.n1.a1}{doi:10.4310/CJM.2024.v12.n1.a1}. +\href{https://arxiv.org/abs/2106.08270v6}{arXiv:2106.08270v6} +(26 October 2023); preprint page numbers refer to +\href{https://arxiv.org/pdf/2106.08270v6}{this version}. + +\bibitem[Stacks]{StacksProject} +The Stacks Project Authors, +\emph{The Stacks Project}, +\href{https://stacks.math.columbia.edu/tag/0A42}{Lemma~30.28.3, Tag~0A42}, +accessed 23 September 2026. + +\bibitem[Tat67]{Tate1967} +J.~T.~Tate, +\emph{$p$-Divisible Groups}, +in T.~A.~Springer (ed.), \emph{Proceedings of a Conference on Local Fields} +(Driebergen, 1966), Springer-Verlag, Berlin--Heidelberg, 1967, 158--183. +\href{https://doi.org/10.1007/978-3-642-87942-5_12}{doi:10.1007/978-3-642-87942-5\_12}. +\href{https://www.math.purdue.edu/~tongliu/teaching/598/p-divisible.pdf}{Original article}. + +\bibitem[Win97]{Wintenberger1997} +J.-P.~Wintenberger, +\emph{Propri\'et\'es du groupe tannakien des structures de Hodge $p$-adiques +et torseur entre cohomologies cristalline et \'etale}, +Ann. Inst. Fourier (Grenoble) \textbf{47} (1997), no.~5, 1289--1334. +\href{https://doi.org/10.5802/aif.1600}{doi:10.5802/aif.1600}. +\href{https://www.numdam.org/item/10.5802/aif.1600.pdf}{Original article}. + +\end{thebibliography} diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/00_intro.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/00_intro.tex new file mode 100644 index 0000000000000000000000000000000000000000..4c134f556c9465fd5ba4249eb2a0a44ba93407c0 --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/00_intro.tex @@ -0,0 +1,280 @@ +\section{Introduction} + +Suppose an abelian variety has good reduction at a prime. A rational +algebraic cycle on the variety specializes to a cycle on the reduction. +Its intersection with any complementary product of divisors has a rational +degree, and every cycle-class realization computes that same number. +Milne's rationality conjecture asks for this conclusion when the original +class is only known to be a rational Hodge class. We prove it for every +residue characteristic. + +The distinction matters because good reduction can acquire divisors that +do not lift to the original variety. Deligne's absolute-Hodge theorem gives +compatible realizations of the Hodge class, but does not by itself identify +its pairing with these new divisors as the degree of a rational cycle. +The conjecture isolates this rationality question from the stronger problem +of representing the Hodge class by an algebraic cycle. + +Fix \(\Qbar\subset\C\), a prime \(p\), and a \(p\)-adic place \(w\) +of \(\Qbar\). Write +\[ + \F=\overline{\mathbb F}_p,\qquad + \Kzero=\operatorname{Frac}W(\F),\qquad + \Cw=\widehat{\Qbar}_w. +\] +We regard \(\Kzero\) and an algebraic closure of it as subfields of +\(\Cw\). Good reduction means good reduction after descent to a number +field and finite extension at the chosen place. + +\begin{theorem}\label{thm:main} +Let \(A/\Qbar\) be an abelian variety of dimension \(d\) with good +reduction \(A_0/\F\) at \(w\). Let \(0\leq r\leq d\), and let +\[ + \gamma\in H^{2r}(A(\C),\Q(r)) +\] +be a rational Hodge class. For every list of Cartier divisors +\(D_1,\ldots,D_{d-r}\) on \(A_0\), there is a number \(q\in\Q\) +such that +\begin{align*} + \Tr_\ell\bigl(\gamma_{0,\ell} + c_{1,\ell}(D_1)\cdots c_{1,\ell}(D_{d-r})\bigr)&=q + &&\text{in }\Q_\ell\quad(\ell\ne p),\\ + \Tr_p\bigl(\gamma_{0,p} + c_{1,\mathrm{cris}}(D_1)\cdots + c_{1,\mathrm{cris}}(D_{d-r})\bigr)&=q + &&\text{in }\Cw. +\end{align*} +Here \(\gamma_{0,\ell}\) is the smooth proper specialization of the +\(\ell\)-adic realization, and \(\gamma_{0,p}\) is the +de Rham--crystalline specialization in +\[ + H^{2r}_{\mathrm{cris}}(A_0/W(\F))[1/p](r) + \otimes_{\Kzero}\Cw. +\] +The traces use the top Tate twist and send the class of a zero-cycle to +its degree. If \(r=d\), the divisor product is \(1\). +\end{theorem} + +By linearity the same conclusion holds for every rational Lefschetz class +of complementary codimension, that is, every rational linear combination +of products of divisors. The number \(q\) is common to all realizations +for the fixed data; no comparison between different reduction places is +required. + +\subsection{Origins and consequences} + +Milne introduced a weak-rationality formulation while studying the +reduction of Shimura varieties and the Langlands--Rapoport conjecture +\cite[Conjecture~6.1(A)]{Milne2000}. It asks that a specialized CM +Hodge class whose components lie in the local spans of divisor products +in every realization arise from one rational Lefschetz class. +The pairing formulation appears in his +AIM notes and his study of rational Tate classes +\cite[Section~10]{MilneAIM2007}, \cite[Conjecture~4.1]{Milne2009}. +A previous positive case is a CM abelian variety with simple ordinary +reduction, together with all its powers: in that case every divisor +class on the reduction lifts \cite[Example~4.2]{Milne2009}. + +The broader purpose is to obtain rational cohomological correspondences +for abelian motives in characteristic~\(p\), compatible with reduction +from characteristic zero \cite[Sections~5--6]{Milne2000}; see also +\cite[Introduction and Section~2]{Milne2025}. For \(\ell\ne p\), +Tate classes are twisted \(\ell\)-adic classes fixed by a power of +Frobenius; there is a corresponding \(\Q_p\)-algebra of crystalline +Tate classes. A \emph{good theory of rational Tate classes} chooses +one graded \(\Q\)-algebra on each variety whose scalar extensions +give these Tate algebras. The theory is stable under pullback and +pushforward, contains divisor classes, and contains specializations of +CM Hodge classes \cite[Definitions~2.1 and~3.1]{Milne2009}. +These are cohomological correspondences; their definition does not +assert that they are algebraic. + +Milne proved that the rationality assertion for all CM abelian varieties +is equivalent to the existence of such a good theory on varieties over +\(\F\) whose connected components are products of abelian varieties +and projective spaces \cite[Theorem~4.5]{Milne2009}. +Our proof also expresses each specialized Hodge class as the pullback, +along a rational homomorphism of special fibers, of a specialized Hodge +class from a CM abelian variety. This extends the theory's +specialization property beyond the CM case. +In Corollary~\ref{cor:all-hodge-specialization}, every rational +Hodge class on a good-reduction abelian variety specializes to a unique +class in one fixed good theory. Its crystalline component gives the +stated specialization after extension to \(\Cw\). + +A distinct additional input gives algebraicity on the special fiber. +Combining the same transport with the Hodge theorem for CM abelian +varieties \cite[Theorem~1.1]{OpenAICMHodge2026}, +Corollary~\ref{cor:algebraic-specialization} represents each specialized +Hodge class by one rational algebraic cycle in all the stated +realizations. Its pairing with any complementary algebraic cycle is +therefore a rational intersection number. This consequence uses the CM +Hodge theorem; the proof of Theorem~\ref{thm:main} is independent of it. + +\subsection{The method and its antecedents} + +Three foundational results make this question accessible. Deligne proved +that every Hodge class on an abelian variety is absolute Hodge +\cite[Main Theorem~2.11]{Deligne1982}. Blasius established its compatibility +with \(p\)-adic comparison \cite[Theorems~0.3 and~5.3]{Blasius1994}; +Moonen presents the Blasius--Wintenberger comparison theorem, with +Ogus's simplification, in the perfect-residue-field form needed for +the local auxiliary lifts below \cite[Theorem~5.6.3]{Moonen1998}. Milne's theory of +Lefschetz classes supplies a common rational divisor algebra with perfect +complementary pairing, independent of the Weil cohomology +\cite[Section~5]{Milne1999}. + +The determinant classes used in the proof belong to the theory of Weil +classes developed by Weil, Deligne and Andr\'e; see +\cite[Section~4 and Endnotes~M.10--M.12]{Deligne1982}. +Andr\'e's refinement of the CM reduction expresses Hodge classes by +pullbacks from varieties of split Weil type \cite{Andre1992}; a detailed +account is \cite[Theorem~1]{Milne2020}. We prove directly the balanced +form of that reduction needed here in Lemma~\ref{lem:cm-reduction}. +Balanced signatures assert equal Hodge multiplicities at conjugate +embeddings; split Weil type also requires the associated Hermitian +form to have a half-dimensional isotropic subspace. +Andr\'e's later theory of motivated cycles establishes a broader +unconditional motivic setting for abelian Hodge classes +\cite[Theorem~0.6.2]{Andre1996}, without identifying them with algebraic +cycles. + +For an imaginary quadratic field, Markman has proved algebraicity of +Weil classes on abelian fourfolds of Weil type and on abelian sixfolds +of split Weil type \cite[Theorem~1.2]{Markman2026}. These are +characteristic-zero algebraicity results. The pairing argument here +applies in arbitrary dimension and begins only with the Hodge class +and its good reduction. + +There is also a direct antecedent for the lifting strategy. Milne asked +whether a specialized CM Hodge class and a divisor could be lifted +together, up to isogeny, to a CM variety, and explained the resulting +rationality implication \cite[Question~10.6 and Proposition~10.7]{MilneAIM2007}. +His current account gives a conditional criterion through weak lifting +of Lefschetz classes on CM Weil triples and describes the reduction +from general Hodge classes through CM varieties to Weil classes +\cite[Introduction, Question~2.17, and Theorem~2.18]{Milne2025}. +Our proof follows this general route, using two auxiliary varieties +with different purposes. The +first is CM; the second realizes a prescribed admissible filtration +over a local field and need not be CM. The necessary realization +machinery comes from Grothendieck--Serre--Tate deformation theory, +Tate's extension theorem, and the integral-model and local-Shimura +results of Kisin--Zhou and Pappas--Rapoport +\cite{Grothendieck1970,Tate1967,KisinZhou2025,PappasRapoport2024}. +For the prescribed filtration, we choose a framed local Shimura +point over its admissible period and use integral uniformization; +the required uniformization condition is supplied by +\cite[Corollary~6.3]{GleasonLimXu2026}. We state the precise inputs +where they enter and prove the connecting arguments for the +prescribed flag. + +The contribution along this route is to construct a filtration that +preserves the extra divisor and then obtain a rational divisor identity +on its lift. A separate normalization by rational intersection numbers +makes the tensor transports simultaneous in all realizations. +Kisin--Zhou's compatibility theorem concerns Weil--Deligne +representations across coefficient fields +\cite[Theorem~1.2]{KisinZhou2025}; the additional issue here is the +rational value of a Hodge--divisor intersection. + +The key step is a dichotomy for balanced Weil classes: either all the +complementary Lefschetz pairings vanish, or the specialized class is +itself a rational polynomial in divisors, simultaneously in every +realization. + +\subsection{Proof overview} + +The proof has four stages. The order below describes the deduction; +Sections~\ref{sec:transport}--\ref{sec:weil} establish its reusable +constructions before Section~\ref{sec:reduction} assembles them. + +\paragraph{1. Transport to a CM variety.} +Corollary~\ref{cor:cm-transport} constructs a CM +abelian variety \(C/\Qbar\), a quasi-isogeny +\(a_{\mathrm{CM}}:A_0^n\to C_0\), and a rational Hodge class +\(\kappa\) such that +\[ + \gamma_0=(a_{\mathrm{CM}}j)^*\kappa_0, +\] +where \(j\) includes the first factor. This is one rational algebraic homomorphism on the +special fibers and one equality in every realization. Kisin--Zhou's +special-point theorem supplies the CM lift +\cite[Theorem~2.2.7]{KisinZhou2025}. The local tensors initially determine +similitude scalars; a ratio of rational divisor intersections shows +that all those scalars are the same rational number. This normalization +is what transports the original rational class, rather than a separate +local multiple in each cohomology theory. + +\paragraph{2. Reduce CM classes to balanced Weil classes.} +Lemma~\ref{lem:cm-reduction} constructs rational-idempotent factors of +actual powers of \(C\). Their homology has rank \(2s\) over a CM field +\(E\), with signatures \((s,s)\) at every embedding, and their +polarizations induce conjugation on \(E\). Their Weil classes are the +rational forms whose components, after splitting \(E\), are top +alternating forms on individual \(E\)-eigenspaces. Pullbacks of these +Hodge classes span the given CM Hodge class over \(\Q\). Good reduction +is retained. Having one rational value for each complementary +Lefschetz pairing is preserved by rational pullback +(Lemma~\ref{lem:pairing-functorial}). It therefore remains to prove +that assertion for balanced Weil classes. + +\paragraph{3. Find a divisor and a compatible filtration.} +For a balanced Weil variety \(Z\), let \(\dagger\) denote Rosati on its +reduction and consider +\[ + \mathcal U=\{u\in\End^0(Z_0):u^\dagger=u,\quad + ue=\bar e u\text{ for all }e\in E\}. +\] +Proposition~\ref{prop:weil} proves a dichotomy. If \(\mathcal U\) has no +invertible element, every complementary Lefschetz pairing of a +specialized Weil class is zero. If it has an invertible element, the +specialized Weil class is itself a simultaneous rational Lefschetz +class: one rational polynomial in divisors gives its class in every +realization. For the second branch, such a \(u\) supplies a divisor +\(D^u\) whose alternating form is nondegenerate on each \(E\)-eigenspace. +Theorem~\ref{thm:filtration} constructs a weakly admissible balanced +filtration on the fixed crystalline module that preserves \(E\), \(u\), +and the polarization. Generic transversality has a classical role in +admissible-filtration constructions +\cite[Theorem~1 and Lemmas~1.1--1.2]{FontaineRapoport2005}. +Here bounded-degree avoidance makes all the constrained choices over +one finite extension, and a maximality argument reduces the +weak-admissibility test to subobjects stable under the endomorphisms. + +\paragraph{4. Lift the divisor and extract a rational identity.} +The second case of Proposition~\ref{prop:transport} realizes this flag +on a local auxiliary abelian variety \(B\), with a marked quasi-isogeny +\(a_{\mathrm{fl}}:Z_0^m\to B_0\). The prescribed flag makes the +first-summand projector, its algebraic \(E\)-action, and the transported +divisor filtered. These specified algebraic maps lift to \(B\). +After choosing an abstract complex realization of \(B\), polynomial +coefficient extraction expresses the relevant rational Betti Weil class +as a rational linear combination of divisor products +(Lemma~\ref{lem:weil-divisor-span}). The same rational identity specializes +in every realization. Pullback returns it to \(Z_0\), completing the +case of an invertible element in the dichotomy and, through the first two stages, the +main theorem. + +Figure~\ref{fig:two-transports} separates the two lifts and their +special-fiber markings. Section~\ref{sec:preliminaries} fixes comparisons, +traces, and rational pullback. Section~\ref{sec:transport} proves both +transport alternatives; Section~\ref{sec:filtration} constructs the +prescribed flag; Section~\ref{sec:weil} proves the balanced-Weil dichotomy; +and Section~\ref{sec:reduction} proves the CM reduction and finishes the +argument. + +\begin{figure}[tbp] +\centering +\input{figures/two-transports} +\caption{The two uses of transport. Each lower horizontal arrow is one +actual quasi-isogeny preserving the specified tensors in all +realizations; the vertical arrows denote good reduction. There is no +claimed map between the generic fibers. The upper construction starts +from the original variety. The lower construction is applied separately +to a balanced Weil variety \(Z\) arising in the CM reduction; its lift +\(B\) realizes the chosen filtration \(\mathcal F_Z^{\oplus m}\) under +\(a_{\mathrm{fl}}^*\). The CM and prescribed-filtration auxiliaries need +not coincide.} +\label{fig:two-transports} +\end{figure} diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/01_preliminaries.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/01_preliminaries.tex new file mode 100644 index 0000000000000000000000000000000000000000..d3af8d2d840930265d2a1075fbf183832209248b --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/01_preliminaries.tex @@ -0,0 +1,227 @@ +\section{Comparisons and rational Lefschetz classes} +\label{sec:preliminaries} + +We first put the realizations in Theorem~\ref{thm:main} in a common +notation and formulate its conclusion as a property of cohomology classes. +The essential functorial fact is that this property is preserved by rational +pullback. We also record the criterion that will lift an additional divisor +once a suitable Hodge filtration has been realized. + +We work in the category of abelian varieties up to isogeny. Thus +\(\Hom^0(X,Y)=\Hom(X,Y)\otimes_\Z\Q\), and divisors may have rational +coefficients. Pullback by a rational homomorphism is defined on \(H^1\) +and extended to its exterior algebra. If \(Nf\) is an actual homomorphism, +then on \(H^{2r}\) +\begin{equation}\label{eq:rational-pullback} + f^*=N^{-2r}(Nf)^*. +\end{equation} +This convention is the same in all realizations. + +For an abelian variety \(X/\F\), set +\[ + k_\ell=\Q_\ell\quad(\ell\ne p),\qquad k_p=\Cw, +\] +and write \(H_v^{2r}(X)(r)\) for its \(\ell\)-adic cohomology if +\(v=\ell\ne p\), and for crystalline cohomology extended to \(\Cw\) +if \(v=p\). Cup products will usually be written without a cup symbol. +All trace maps and divisor classes have their cycle-class normalizations. +The Betti Tate line \(\Q(r)\) supplies the twists in the other +realizations through comparison. Thus \(\Tr_v\) is the trace on top +cohomology with its top Tate twist and sends the class of a zero-cycle to +its degree. For a good-reduction lift, \(\gamma_{0,\ell}\) denotes +smooth proper specialization of its absolute-Hodge realization, and +\(\gamma_{0,p}\) denotes de Rham--crystalline specialization extended +from \(\Kzero\) to \(\Cw\). We keep first crystalline cohomology +over \(\Kzero\) when constructing filtrations, and specify each +extension of the filtration field separately. + +We use the exterior-algebra description of abelian cohomology and +faithfulness of rational homomorphisms on \(H^1\); see +\cite[Theorems~12.5 and~15.1]{MilneAV} for the prime-to-characteristic +realizations. The uniform Weil-cohomology formalism, including +crystalline cohomology, exterior powers, cycle-normalized traces and +the projection formula, is set out in +\cite[Section~1 and Appendix, Proposition~(A.2)]{Milne1999}. Smooth +proper specialization away from \(p\) is +\cite[Theorem~20.4]{MilneLEC}. + +\subsection{Comparison of Hodge tensors} + +\begin{lemma}\label{lem:comparison} +For an abelian variety with good reduction, the realizations of an +absolute Hodge class are compatible with the de Rham and crystalline +comparison isomorphisms. In particular, the \(p\)-adic crystalline tensor +obtained from its \(p\)-adic \'etale realization agrees, after extension of +scalars, with the de Rham--crystalline realization in +Theorem~\ref{thm:main}. These compatibilities respect tensor operations, +duals, Tate twists, divisor classes, and rational homomorphisms. + +The same assertion applies to auxiliary abelian varieties with good +reduction over a finite extension of \(\Kzero\), using a complex +embedding of an algebraic closure of their field of definition. +\end{lemma} + +\begin{proof} +For abelian varieties over \(\Qbar\), Deligne's absolute-Hodge theorem +\cite[Main Theorem~2.11]{Deligne1982} and Blasius's comparison theorem +\cite[Theorems~0.3 and~5.3]{Blasius1994} give the assertion. The +compatibility of the crystalline comparison with the de Rham comparison +is part of \cite[\S5.1]{Blasius1994}. The formulation for a complete +mixed-characteristic discrete valuation ring with perfect residue field +is given in \cite[Theorem~5.6.3]{Moonen1998}; the paragraph following +that theorem explains removal of the number-field hypothesis. A finite +extension of \(\Kzero\) is within that scope. The stated functorialities +are those of the comparison isomorphisms. +\end{proof} + +An abstract complex embedding used here need not be continuous. To see +that it can be chosen compatibly with \(\Qbar\subset\C\), take a +transcendence basis of \(\overline{\Kzero}/\Qbar\), embed it in a +transcendence basis of \(\C/\Qbar\), and extend algebraically. The +cardinalities permit this construction. No descent of a general +auxiliary lift to \(\Qbar\) is inferred. + +\subsection{The common rational Lefschetz space} + +Let \(\Lef^r(X)\) be the space of rational polynomial expressions in +divisors of codimension \(r\), modulo numerical equivalence. We use the +following established properties: +\begin{enumerate}[label=(\roman*)] + \item its cycle map is injective, and + \(\Lef^r(X)\otimes_\Q k_v\) is the divisor-generated subspace of + \(H_v^{2r}(X)(r)\); + \item intersection and degree give a perfect pairing + \[ + \Lef^r(X)\times\Lef^{\dim X-r}(X)\longrightarrow\Q; + \] + \item pushforward by a homomorphism of abelian varieties preserves the + divisor-generated subspaces in each realization; + \item hard Lefschetz and its inverse restrict to these subspaces. +\end{enumerate} +These are \cite[Proposition~5.2, Corollaries~5.3 and~5.5, +Theorem~5.9]{Milne1999}, with the author's correction to the proof of +Theorem~5.9. Crystalline cohomology is included. Extension of its +coefficient field to \(\Cw\) preserves these statements. We call the +tuple of realizations of a fixed element of \(\Lef^r(X)\) a +\emph{simultaneous rational Lefschetz class}. + +\begin{definition} +A tuple \(\alpha=(\alpha_v)_v\), with +\(\alpha_v\in H_v^{2r}(X)(r)\), has the \emph{Lefschetz pairing +property} if, for every \(\delta\in\Lef^{\dim X-r}(X)\), the numbers +\(\Tr_v(\alpha_v\delta_v)\) are the images of one number in \(\Q\). +\end{definition} + +Simultaneous rational algebraic classes have this property, by the +intersection formula. The property is closed under rational linear +combinations. We shall need the following additional closure property. + +\begin{lemma}\label{lem:pairing-functorial} +If \(\alpha\) has the Lefschetz pairing property on \(Y\) and +\(f\in\Hom^0(X,Y)\), then \(f^*\alpha\) has that property on \(X\). +\end{lemma} + +\begin{proof} +If \(r>\dim Y\), the input class is zero; if \(r>\dim X\), +its pullback is zero. We may therefore suppose that \(f\) is an actual +homomorphism and \(r\leq\min(\dim X,\dim Y)\). +For \(\delta\in\Lef^{\dim X-r}(X)\), the class \(f_*\delta_v\) +lies in the Lefschetz subspace of codimension \(\dim Y-r\) in every +realization. Choose rational bases \(a_i\) of +\(\Lef^{\dim Y-r}(Y)\) and \(b_j\) of \(\Lef^r(Y)\). The matrix +\(M_{ij}=\deg(a_i b_j)\) is an invertible rational matrix. If +\(f_*\delta_v=\sum_i c_{i,v}(a_i)_v\), the projection formula gives +\[ + \sum_i c_{i,v}M_{ij}=\deg(\delta f^*b_j). +\] +The right side is a rational number independent of \(v\). Solving this +one rational system shows that \(c_{i,v}=c_i\in\Q\) for every \(v\). +Thus \(f_*\delta\) is simultaneous rational Lefschetz. Applying the +projection formula once more proves the assertion. For rational \(f\), +use \eqref{eq:rational-pullback}. +\end{proof} + +\subsection{Lifting a prescribed rational homomorphism} + +The second transport construction will produce an abelian lift with a +chosen Hodge filtration. The following criterion then lifts the algebraic +projector, field action, and divisor already specified on its special fiber. +Its input is a rational algebraic homomorphism, rather than an arbitrary +map between cohomology spaces. + +In the next lemma \(R\) is a complete mixed-characteristic discrete +valuation ring finite over \(W(\F)\), with fraction field \(K\). +For an abelian scheme \(\mathcal X/R\), the Hodge filtration is regarded +as a filtration of +\(H^1_{\mathrm{cris}}(X_0/W(\F))[1/p]\otimes_{\Kzero}K\). + +\begin{lemma}\label{lem:lift-hom} +Let \(\mathcal X,\mathcal Y\) be abelian schemes over \(R\), with +special fibers \(X_0,Y_0\), and let +\(f_0\in\Hom^0(X_0,Y_0)\). If its contravariant crystalline map +preserves the Hodge filtrations, then \(f_0\) lifts uniquely to a +rational homomorphism \(\mathcal X\to\mathcal Y\). + +In particular, a symmetric rational homomorphism \(X_0\to X_0^\vee\) +with this property lifts to a rational divisor class on the generic +fiber. Algebraic identities among finitely many such lifted maps remain +valid. +\end{lemma} + +\begin{proof} +The crystalline map already commutes with Frobenius. Full faithfulness +for rational filtered Dieudonn\'e modules gives a rational morphism of +the associated \(p\)-divisible groups; see +\cite{Grothendieck1970} and the perfect-residue-field formulation in +\cite[\S4.2(v)]{IllusiePisa}. Equivalently, crystalline comparison first +gives the rational map on Tate modules. Multiply by an integer \(N\) +that clears both its Tate-lattice denominator and the denominator of +\(f_0\). Tate's extension theorem +\cite[Theorem~4]{Tate1967} extends the resulting integral generic-fiber +map of \(p\)-divisible groups over \(R\). Faithfulness of the +special-fiber Dieudonn\'e functor identifies its reduction with the +map induced by \(Nf_0\). Here equality after inverting \(p\) is +already equality of integral maps, because the integral Dieudonn\'e +modules are torsion free. The integer \(N\) is fixed for the remainder +of the construction. + +The specified-map form of Serre--Tate deformation theory now gives a +lift over each \(R/\mathfrak m_R^n\) +\cite[p.~432]{Grothendieck1970}. One can also deduce it from the +fixed-object formulation \cite[Theorem~2.3.3]{IllusiePisa} as follows. +On \(X_0\times Y_0\) form the shear +\(s_0(x,y)=(x,y+Nf_0(x))\). The lifted \(p\)-divisible-group map gives +the same shear on the product \(p\)-divisible group. View the existing +product deformation with two special-fiber markings differing by +\(s_0\). Full faithfulness lifts the shear to an algebraic isomorphism +between these marked deformations; its second component restricted to +\(X\) lifts \(Nf_0\). Uniqueness makes these maps compatible at every +finite order. + +Formal existence algebraizes the resulting formal map +\cite[Tag~0A42]{StacksProject}: its source is proper over the complete +noetherian ring \(R\), and its target is separated and of finite type. +Dividing by the fixed \(N\) gives the desired rational lift. Rigidity +gives uniqueness and injectivity of specialization on rational +homomorphisms \cite[Proposition~20.1 and Corollary~20.2]{MilneAV}. + +If \(f_0\) is symmetric, injectivity shows that its lift is symmetric. +The usual identification +\[ + \NS(X_K)\otimes\Q + \simeq\Hom(X_K,X_K^\vee)^{\mathrm{sym}}\otimes\Q +\] +gives the rational divisor class, after a finite extension if +necessary \cite[Proposition~17.2]{MilneAV}. Finally an identity between the maps specializes to the +given identity, so injectivity proves it upstairs as well. +\end{proof} + +Only prescribed rational algebraic maps on the special fiber are being +lifted in Lemma~\ref{lem:lift-hom}. An arbitrary \(\Q_p\)-linear map of +\(p\)-divisible groups is not asserted to be a rational algebraic map. +We also use the extension of generic-fiber homomorphisms between abelian +schemes over a discrete valuation ring: their N\'eron mapping property +extends such a homomorphism uniquely over the base +\cite[Definition~5.1 and Example~5.3]{Conrad2003}. Clearing one +rational denominator therefore makes specialization of these maps +well defined. diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/02_transport.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/02_transport.tex new file mode 100644 index 0000000000000000000000000000000000000000..1cb7f952cd111b077becc209aa24b3cd551cca42 --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/02_transport.tex @@ -0,0 +1,814 @@ +\section{Transport through Hodge-type integral models} +\label{sec:transport} + +After taking a power of the original abelian variety, we transport a +rational Hodge class to an auxiliary variety by one quasi-isogeny on +special fibers, with the same equality in every +realization. The auxiliary variety can be chosen either of CM type or +with a prescribed admissible Hodge filtration. These choices serve +different parts of the proof, but share the tensor construction and the +rational normalization in Proposition~\ref{prop:transport} below. + +Throughout this section, a polarization on a rational homology space is +written as a rational alternating form, using the fixed Betti +trivialization of the Tate line. If its similitude character is $c$, +an alternating form $\xi:V^{2r}\to\Q$ of multiplier $c^r$ means that +\begin{equation} + \xi(gv_1,\ldots,gv_{2r})=c(g)^r\xi(v_1,\ldots,v_{2r}). + \label{eq:transport-multiplier} +\end{equation} +Such a form is regarded as a tensor with its codimension-$r$ Tate +twist. All homomorphisms and polarizations may be rational: an +isomorphism in the isogeny category induces the usual isomorphisms on +cohomology, including its tensor constructions. + +We say that filtered isocrystal data have \emph{finite local-field +descent} if they are obtained by scalar extension from an isocrystal +with its tensors over the maximal unramified subfield \(H_0\) of a +finite extension \(H/\Q_p\), together with a filtration over \(H\). +The scalar extension is to \(\Kzero H\). This condition will let us +apply weak admissibility over a finite local field. +For a group in a faithful representation, a tensor-preserving +identification means one respecting a finite family of rational tensors +whose stabilizer is that group, together with their comparison realizations. + +\begin{proposition}[Transport] +\label{prop:transport} +Let $A/\Qbar$ be an abelian variety of positive dimension with good +reduction at $w$, and put $V=H_1(A(\C),\Q)$. Suppose +\[ + G\subset\GSp(V,\psi) +\] +is connected reductive, its Hodge homomorphism $h$ gives the +Hodge structure of $A$, and its conjugacy class $X$ makes this +inclusion a Hodge embedding. Let $\gamma$ be a rational Hodge +class of codimension $r$, represented on $V$ by an alternating +form satisfying \eqref{eq:transport-multiplier}. + +Then there exist a positive integer $n$, an auxiliary +good-reduction abelian variety $B$, a quasi-isogeny +$a:A_0^n\to B_0$, and a rational Hodge class $\kappa$ of +codimension $r$ on $B$ such that, for the first-factor inclusion +$j:A_0\to A_0^n$, +\begin{equation} + (aj)^*\kappa_0=\gamma_0. + \label{eq:transport-class} +\end{equation} +The equality holds simultaneously in every $\ell$-adic +realization with $\ell\ne p$ and in the crystalline realization +after extension to $\Cw$. Either of the following two further +specifications can be imposed. +\begin{enumerate} +\item The variety $B$ is of CM type and is defined over $\Qbar$, +with its indicated good reduction at $w$. +\item Put $D_A=H^1_{\mathrm{cris}}(A_0/W(\F))[1/p]$. Suppose +$\mathcal F_A$ is a filtration in degrees $0,1$ on $D_A$, over a +finite extension of $\Kzero$, which is weakly admissible and has +finite local-field descent together with the specialized tensors +specifying the $G$-structure. Suppose +also that, after a geometric tensor-preserving identification, it +lies in the $G$-orbit of the original Hodge filtration. Then $B$ +can be defined over a finite extension $K/\Kzero$ inside $\Cw$, +and $a$ can be chosen so that +\begin{equation} + a^*\Fil^1H^1_{\mathrm{dR}}(B/K) + =(\mathcal F_A^1)^{\oplus n}. + \label{eq:transport-prescribed-filtration} +\end{equation} +Here the equality is made after a common finite extension and +crystalline--de Rham identification. To discuss Hodge classes on +this $B$, choose a complex embedding of an algebraic closure of +$K$ extending the fixed embedding of $\Qbar$. +\end{enumerate} +In the second case the realizations of $\kappa$ are supplied by +the canonical tensor sections of the Hodge-type model and the +polarization. In the first case these agree with the usual +realizations and specialization of its absolute Hodge class. +\end{proposition} + +We prepare two ingredients for the proof. First, we enlarge the given +Hodge datum so that integral-model theorems apply at every prime while +its rational representation remains a sum of copies of \(V\). +Second, we realize a prescribed admissible filtration by choosing a +framed local Shimura point above its crystalline period and applying +integral uniformization. The resulting abelian lift retains that +point's integral tensors and special-fiber marking. After these +preparations, the proof constructs the transported tensor and normalizes +it using rational divisor intersections. + +\subsection{An auxiliary strongly admissible datum} + +We recall the hypotheses on integral models that we will use. +For a reductive group \(H_p/\Q_p\), a full Bruhat--Tits stabilizer +is the smooth group scheme fixing a point of its extended building. +Its identity component is the associated parahoric group scheme. +Now let \((H,X_H)\) be a Shimura datum over \(\Q\). In the terminology +of \cite[Definition~2.1.6]{KisinZhou2025}, the triple +\((H,X_H,\mathcal H)\) is \emph{strongly admissible} if \((H,X_H)\) +is of Hodge type, \(\mathcal H\) is a full stabilizer of \(H_{\Q_p}\) +with connected special fiber, the centralizer of a maximal +\(\Kzero\)-split torus of \(H_{\Kzero}\) is \(R\)-smooth, and the +relative root system over \(\Kzero\) is reduced when \(p=2\). Here $R$-smoothness is the condition on tori used in +\cite[\S2.4]{KisinZhouEarlier}. We will use it only for products and +extensions of restrictions of scalars of split tori, for which it +holds by \cite[Proposition~2.4.6]{KisinZhouEarlier}. + +\begin{lemma}[Auxiliary Hodge datum] +\label{lem:auxiliary-datum} +Let +\[ + (G,X)\lhook\joinrel\longrightarrow + (\GSp(V,\psi),X_{\mathrm{Siegel}}) +\] +be a Hodge embedding, with $G$ connected and similitude character $c$. +For every prime $p$ there exist a totally real field $P$, a connected +reductive group $J$, and a Hodge embedding +\[ + (J,X_J)\lhook\joinrel\longrightarrow + (\GSp(W,\psi_W),X'_{\mathrm{Siegel}}) +\] +with the following properties. +\begin{enumerate} +\item There are inclusions of Shimura data induced by +\[ + G\longrightarrow J\longrightarrow\Res_{P/\Q}G_P, +\] +where the first map is diagonal and $J$ is the subgroup on which the +similitude multipliers in the restriction of scalars agree. +\item The group $J_{\Q_p}$ is quasi-split and has a full connected +stabilizer $\mathcal J$ making $(J,X_J,\mathcal J)$ strongly admissible. +\item As a rational $J$-representation, +\begin{equation} + W\simeq (V\otimes_{\Q}P)^{\oplus m} + \label{eq:transport-copies} +\end{equation} +for some positive integer $m$. The form $\psi_W$ has multiplier the +common character $c$, and $\mathcal J\to\GL(W_{\Q_p})$ extends to a +closed immersion into $\GL(\Lambda_p)$ for a self-dual $\Z_p$-lattice +$\Lambda_p$. +\end{enumerate} +\end{lemma} + +\begin{proof} +Choose a finite extension of $\Q_p$ splitting $G_{\Q_p}$. Polynomial +approximation, together with Krasner's lemma +\cite[Propositions~7.60--7.61 and Corollary~7.62]{MilneANT}, gives a +totally real number field $P$ whose completions at $p$ split $G_{\Q_p}$. For +example, approximate the minimal polynomial of a primitive element +of a splitting extension at $p$, and a polynomial with distinct real +roots at the real place. The resulting number field can have just +one place above $p$; this additional condition is not needed. + +Define the multiplier fiber product +\begin{equation} + J=(\Res_{P/\Q}G_P) + \mathbin{\times}_{\Res_{P/\Q}\mathbf G_m}\mathbf G_m, + \label{eq:equal-multiplier-group} +\end{equation} +where the last map is diagonal. The Hodge cocharacter, or its +inverse according to convention, pairs to $1$ with $c$. Since $c$ +factors through $G^{\mathrm{ab}}$, its character on this torus is +primitive. Thus $\ker(G^{\mathrm{ab}}\to\mathbf G_m)$ is a torus, +and $\ker(c:G\to\mathbf G_m)$ is connected reductive. The exact +sequence +\[ + 1\longrightarrow\Res_{P/\Q}(\ker c)_P + \longrightarrow J\xrightarrow{c}\mathbf G_m\longrightarrow1 +\] +proves connectedness and reductivity of $J$. Moreover, +\begin{equation} + J^{\mathrm{der}}=\Res_{P/\Q}G_P^{\mathrm{der}}. + \label{eq:auxiliary-derived} +\end{equation} + +The action on $U=V\otimes_\Q P$, with alternating form +$\Tr_{P/\Q}\psi_P$, gives a symplectic embedding of $J$ with +similitude character $c$. The diagonal Hodge homomorphism gives +$X_J$. The adjoint Hodge-type and Cartan-involution axioms follow +componentwise from those for $X$. We also check that extending the +totally real field introduces no rational adjoint factor on which +the Hodge homomorphism is trivial. Write a rational simple adjoint +factor as $\Res_{L/\Q}H$, with $L$ totally real. Every field factor +$L'$ of $P\otimes_\Q L$ is totally real, and every real embedding of +$L$ extends to a real embedding of $L'$. Hence the existence of a +nontrivial Hodge component for $H$ persists in each resulting +rational factor. Finally the diagonal weight is rational and the +trace form is a polarization. This proves that $(J,X_J)$ is a +Shimura datum of Hodge type. + +Here are the local conditions explicitly. Put $P\otimes\Q_p= +\prod_{v\mid p}P_v$ and choose a split maximal torus $T_v$ of +$G_{P_v}$. The character $c$ on $T_v$ has a cocharacter section: +a conjugate of the Hodge cocharacter pairs to $1$ with it, and all +cocharacters of a split torus are defined over $P_v$. The same +argument applies to $G_{P_v}^{\mathrm{ab}}$. Consequently the +maximal torus of $J_{\Q_p}$ obtained from the $T_v$, and the +abelianization of $J_{\Q_p}$, have the forms +\begin{align} + T_J&\simeq\mathbf G_m\times + \prod_{v\mid p}\Res_{P_v/\Q_p}\mathbf G_m^{\operatorname{rk}G-1}, + \label{eq:auxiliary-torus}\\ + J_{\Q_p}^{\mathrm{ab}}&\simeq\mathbf G_m\times + \prod_{v\mid p}\Res_{P_v/\Q_p} + \mathbf G_m^{\dim G^{\mathrm{ab}}-1}. + \label{eq:auxiliary-abelianization} +\end{align} +The split Borels over the $P_v$ give a Borel of $J_{\Q_p}$, so this +group is quasi-split. Its derived group is a product of restrictions +of split groups by \eqref{eq:auxiliary-derived}. The vertices from +the hyperspecial vertices in those split groups give a very special +parahoric of $J_{\Q_p}$. The inertia coinvariants of the cocharacter +module in \eqref{eq:auxiliary-abelianization} are torsion-free, since +that module is a direct sum of permutation modules. The full +stabilizer is therefore connected by +\cite[Lemma~4.2.4]{KisinZhouEarlier}. + +The centralizer of a maximal $\Kzero$-split torus is obtained from +\eqref{eq:auxiliary-torus} by unramified base extension; its torus +factors are still induced split tori and $\mathbf G_m$. +It is $R$-smooth by +\cite[Proposition~2.4.6]{KisinZhouEarlier}. Finally restrictions of +split root systems give reduced relative root systems, also at +$p=2$. These are precisely the strong-admissibility checks in the +construction of \cite[Proposition~5.3.8]{KisinZhou2025}. They use +the stipulated Hodge embedding, not the assertion that $G$ is the +full Mumford--Tate group of a particular point. + +Apply \cite[Proposition~2.1.9]{KisinZhou2025}, starting with the +representation $U$ just constructed. Its proof first tensors $U$ +with an auxiliary totally real $\Q$-vector space, then takes direct +sums, and finally applies the symplectic self-duality construction. +The group acts trivially on that extra vector-space factor. In the +last construction the dual representation twisted by $c$ is +identified with $U$ by its symplectic form. Thus every resulting +rational summand is a copy of $U$, with the same multiplier. This +gives \eqref{eq:transport-copies}, together with $\psi_W$ and +$\Lambda_p$. The assertion of the cited proposition includes +$p=2$; its proof uses the reduced-relative-root condition through +\cite[Lemma~2.1.8]{KisinZhou2025}. +\end{proof} + +Choose a sufficiently small neat prime-to-$p$ level $K^p$ and put +$K_p=\mathcal J(\Z_p)$. The adapted embedding gives the integral +model $\mathcal S_K$ and its universal abelian scheme. A rational +$\Z_{(p)}$-lattice can be chosen with completion $\Lambda_p$. +We use a finite family of tensors defining its stabilizer +$\mathcal J$, as in \cite[\S2.1.4]{KisinZhou2025}. +Any additional rational $J$-invariant tensors may be included in +this family after clearing denominators. Indeed their integral +stabilizer condition already holds on the generic fiber; flatness +of $\mathcal J$ makes it hold on $\mathcal J$ itself. Adding them +therefore changes neither the group scheme nor its tensor +trivializations. + +The added tensors have compatible sections in every realization, as +follows. Use the homological degree-one realizations in this paragraph, +that is, the duals of the corresponding $H^1$, so that their reference +representation is $W$. For such a realization $H_\nu$ over its +coefficient field $k_\nu$, let +\[ + \mathcal P_\nu=\operatorname{Isom}_{\{s_\alpha\}} + (W\otimes k_\nu,H_\nu) +\] +be its torsor of frames preserving the original defining tensors. +For a rational $J$-invariant tensor $u$ and a frame $e$, set +$u_\nu=e(u)$. Two frames differ by an element of $J$, so this +definition is independent of the frame and descends from a +trivialization of the torsor. It also works integrally after clearing +the fixed denominator of $u$. + +The Betti and \'etale frame torsors are supplied by the canonical +tensor sections of \cite[\S2.1.4]{KisinZhou2025}. The construction +of the universal Breuil--Kisin--Fargues module and its structure +tensors gives the crystalline torsor and its compatibility with +those sections +\cite[\S\S2.1.13--2.1.14]{KisinZhou2025}. +Indeed, a comparison map carrying every $s_\alpha$ to its specified +realization carries a frame $e$ to the comparison of $e$; it therefore +carries $e(u)$ to the same tensor evaluated in the new frame. +Thus it preserves $u_\nu$ for every added invariant $u$, without +requiring $u$ to be an expression in the chosen defining tensors. +At a lift over $\Qbar$, these are the realizations of its rational +Hodge tensor, by Lemma~\ref{lem:comparison}. Their crystalline +specializations are independent of the lift because they are +evaluations in the fixed crystalline frame torsor. + +The same observation applies to isogenies. One quasi-isogeny +preserving the defining tensors identifies their frame torsors in +every realization in which those tensors are preserved. It +therefore preserves all the added invariant tensors as well. +This proves the tensor comparison and simultaneous preservation +that will be used below; flatness alone is used only to keep the +integral stabilizer unchanged. + +Specification~\textup{(1)} of Proposition~\ref{prop:transport} +uses the special-point theorem +\cite[Theorem~2.2.7]{KisinZhou2025} directly. The next lemma is +needed only for specification~\textup{(2)}, where the filtration +has been prescribed in advance. + +\subsection{Realizing a prescribed admissible filtration} + +For a point $x\in\mathcal S_K(\F)$ let $C_x$ be the corresponding +abelian variety and put +\[ + \mathbb D_x=H^1_{\mathrm{cris}}(C_x/W(\F)),\qquad + D_x=\mathbb D_x[1/p]. +\] +The crystalline structure tensors are denoted $s_{\alpha,0,x}$; +the tensors away from $p$ are denoted $s_{\alpha,\ell,x}$. +They are the specializations of the canonical tensor sections and +are independent of the chosen lift of $x$. + +The \emph{tensor isogeny class} $\mathcal I_x$ consists of the points +$y\in\mathcal S_K(\F)$ for which a single quasi-isogeny +$C_x\to C_y$ preserves $s_{\alpha,0}$ and every +$s_{\alpha,\ell}$ for $\ell\ne p$. We emphasize that this +definition concerns actual quasi-isogenies of abelian varieties. +It is the class defined in \cite[\S2.2.4]{KisinZhou2025}. + +\begin{lemma}[Realization of an admissible filtration] +\label{lem:admissible-realization} +Let $(J,X_J,\mathcal J)$ be strongly admissible, with $J_{\Q_p}$ +quasi-split, and choose the adapted embedding and neat level above. +Let $x\in\mathcal S_K(\F)$ have a lift to characteristic zero. +Suppose a filtration $\mathcal F$ on $D_x$, after a finite extension +of $\Kzero$, has the following properties: +\begin{enumerate} +\item the resulting filtered isocrystal is admissible; +\item geometrically its filtration is induced by a $J$-valued +cocharacter in the conjugacy class prescribed by $X_J$. +\end{enumerate} +Then, after extending that field finitely, there are $y\in\mathcal I_x$, +a tensor-preserving quasi-isogeny $b:C_x\to C_y$, and a lift +$\widetilde y$ over the extended valuation ring such that +\[ + b^*\Fil^1 H^1_{\mathrm{dR}}(C_{\widetilde y})=\mathcal F^1 +\] +under the crystalline--de Rham identification. + +In particular, condition \textup{(1)} follows if the filtered +isocrystal and its tensor data have finite local-field descent and +$\mathcal F$ is weakly admissible. +\end{lemma} + +\begin{proof} +Write $k=\F$ and let $\breve E$ be the completed local reflex field. +We work over a common finite extension $K$ of $\Kzero$ containing +$\breve E$ and a field of definition of $\mathcal F$. Every further +field extension below is finite. Put $K_p=\mathcal J(\Z_p)$. + +We first fix the relation between the group and cohomological +conventions. Let $\rho:J_{\Q_p}\to\GL(W_{\Q_p})$ be the adapted +homological representation and let $\rho^\vee$ be its dual. Choose +the tensor-preserving identification +$\mathbb D_x\simeq\Lambda_p^\vee\otimes_{\Z_p}W(k)$ of +\cite[\S2.1.14]{KisinZhou2025}. The local shtuka parameter is +$b_x\in J(\Kzero)$, whereas crystalline Frobenius on this +cohomological Dieudonn\'e module is +\[ + F_x=\rho^\vee(\sigma(b_x))\circ\sigma. +\] +The additional $\sigma$ on $b_x$ comes from the comparison with +the vector shtuka: its special-fiber module is +$(\sigma^{-1})^*(\mathbb D_x^\vee)$ +\cite[Example~2.3.4 and Remark~2.3.10]{PappasRapoport2024}. +Write $\{\mu\}$ for the class prescribed by $X_J$; then +$[b_x]\in B(J,\mu^{-1})$. + +For precision, identify the general linear crystalline period +flag with the appropriate filtration variety on $D_x$ by its +marked Rapoport--Zink interpretation. If a deformation +$\mathcal H$ has special-fiber marking +$q:\mathcal H_k\dashrightarrow C_x[p^\infty]$, this identification +sends its period to +$(q^*)^{-1}\Fil^1H^1_{\mathrm{dR}}(\mathcal H)$. +Pushout through the faithful Hodge representation gives the +commutative period square +\[ +\begin{array}{ccc} +M_{\mathcal J,b_x,\mu,K_p}&\longrightarrow&M_{\GL,\rho(b_x),\rho(\mu)}\\ +\pi_{\mathrm{GM}}\downarrow&&\downarrow\pi_{\mathrm{GM}}\\ +\mathcal F_{J,\mu}&\longrightarrow&\operatorname{Flag}(D_x). +\end{array} +\] +The lower map is a closed immersion: the parabolic stabilizing +the faithful filtration intersects $J$ in the parabolic for +$\mu$. Define $f_{\mathcal F}$ to be the unique $J$-flag with +image $\mathcal F$. It exists by condition~\textup{(2)}. The +square uses crystalline periods and the dual Frobenius descent +above, so no extension of $\sigma$ to the ramified filtration +field is chosen. When $q=b^{-1}$ its lower right period is +exactly $b^*\Fil^1$. + +\medskip\noindent +\emph{A framed point over the prescribed period.} +Admissibility of the faithful filtered isocrystal implies that +the image of $f_{\mathcal F}$ in the general linear period flag +variety is in its admissible locus. To see this in the +cohomological coordinates of the square, let $U$ be a crystalline +representation realizing $(D_x,\mathcal F)$. Its crystalline +comparison identifies the associated vector bundle away from +the untilt with $U\otimes\mathcal O$. The filtered de Rham +comparison identifies the modification at the untilt with the +standard lattice $U\otimes B_{\mathrm{dR}}^+$. They glue to the +trivial bundle $U\otimes\mathcal O$ on the Fargues--Fontaine +curve, which is the general linear admissibility condition. +Since $\rho$ is faithful, +$\rho^{-1}(Z_{\GL(W)})\subset Z_J$: an element acting as a scalar +commutes with the faithful image of $J$. The admissible-locus +identity in \cite[Proposition~3.1.1(i), (3.1.9)]{PappasRapoport2024} +therefore puts $f_{\mathcal F}$ in +$\mathcal F_{J,\mu}^{\mathrm{adm}}$. + +This locus is the image of the crystalline period map +\[ + \pi_{\mathrm{GM}}: + M_{\mathcal J,b_x,\mu,K_p} + \longrightarrow\mathcal F_{J,\mu}^{\mathrm{adm}}. +\] +The map is \'{e}tale +\cite[\S3.1.1, (3.1.4)]{PappasRapoport2024}. +Its fiber at the classical point $f_{\mathcal F}$ is nonempty; +an \'{e}tale rigid space over $K$ has a point over a finite +extension of $K$. After making that extension, choose +\begin{equation} + z\in M_{\mathcal J,b_x,\mu,K_p}(K), + \qquad \pi_{\mathrm{GM}}(z)=f_{\mathcal F}. + \label{eq:transport-framed-point} +\end{equation} +In particular $z$ supplies the integral level as well as the +rational isocrystal marking. If $C$ is the completed algebraic +closure of $K$, its moduli description gives an actual +$\mathcal J$-torsor $\mathcal P_z$, a Frobenius isomorphism +bounded by $\mu$, and, for sufficiently large $a$, an isomorphism +\[ + i_a:\mathcal J_{Y_{[a,\infty)}(C^\flat)} + \xrightarrow{\ \sim\ } + \mathcal P_z|_{Y_{[a,\infty)}(C^\flat)}, + \qquad + \varphi_{\mathcal P_z}\circ\varphi^*i_a + =i_a\circ\varphi_{b_x}. +\] +These are precisely the torsor and annular framing in +\cite[\S3.1.1]{PappasRapoport2024}. Its associated +pro-\'{e}tale $\mathcal J(\Z_p)$-torsor gives integral tensor +frames. Thus the integral structure and Frobenius-compatible +framing are part of the chosen point, with all their tensor +compatibilities. + +\medskip\noindent +\emph{Integral realization and its special fiber.} +Our adapted datum is of global Hodge type: the group scheme is +a full connected Bruhat--Tits stabilizer, and the chosen Hodge +embedding is integral on $\Lambda_p$. +The center also satisfies the split-rank hypothesis of +\cite[\S4.1]{PappasRapoport2024}. Indeed its real subgroup of +multiplier one preserves the positive definite form +$\psi_W(v,h(i)w)$ and is compact. Its real split rank is +therefore at most one, while the rational weight torus supplies +one split central direction over $\Q$; both split ranks are one. +The model here is the one in +\cite[\S2.1.11 and Theorem~2.1.12]{KisinZhou2025}, obtained +from this adapted Hodge embedding and satisfying the +Pappas--Rapoport characterization. Condition $(U_x)$ holds +by \cite[Corollary~6.3]{GleasonLimXu2026}; see also +\cite[Remark~4.10.4]{PappasRapoport2024}. Consequently +\cite[Theorem~4.10.6]{PappasRapoport2024} represents the integral +local Shimura variety by a normal formal scheme +$\mathfrak M_{\mathcal J,b_x,\mu}$ and gives the morphism +\[ + \Theta_x:\mathfrak M_{\mathcal J,b_x,\mu} + \longrightarrow\widehat{\mathcal S_K}. +\] +More precisely, \cite[\S4.10.2, (4.10.2)--(4.10.6)]{PappasRapoport2024} +identifies this formal scheme with the tensor-compatible open and +closed part of the pullback of the Siegel Rapoport--Zink space. +This construction identifies the pullback of the universal +$\mathcal J$-shtuka with its tautological framed shtuka and the +faithful vector realization with the universal $p$-divisible group. + +Its rigid generic fiber is the local Shimura variety +\cite[Proposition~3.5.1(i)]{PappasRapoport2024}. +The classical point $z$ of this rigid generic fiber gives +$\operatorname{Spf}\mathcal O_K\to\mathfrak M_{\mathcal J,b_x,\mu}$. +Indeed it lies in the generic fiber of a formal affine chart; +for a special formal chart one may take an affinoid member of +its standard generic-fiber covering containing $z$. +Evaluation of the formal chart's ring is integral, and its +ideal of definition maps to topologically nilpotent elements of +$\mathcal O_K$. Let $z_0$ be the special point and put +$y=\Theta_x(z_0)$ and $\widetilde y=\Theta_x(z)$. +The formal map $\widetilde y$ gives a point of the integral model +over $\mathcal O_K$ by restricting to an affine neighborhood of +$y$. Pullback of the universal abelian scheme gives +$C_{\widetilde y}$ and its $p$-divisible group $\mathcal H_z$. + +We record explicitly the integral comparison at this point. +For a uniformizer $\pi$ of $K$, put +$\mathfrak S=W(k)[[u]]$, with $u\mapsto\pi$, and let +$E_\pi(u)$ generate its kernel. The crystalline representation +and integral level of $z$ give the $\mathcal J$-Breuil--Kisin +torsor of \cite[\S3.5]{PappasRapoport2024}, with +\[ + \Phi:\varphi^*\mathcal P_{\mathrm{BK}}[1/E_\pi] + \xrightarrow{\ \sim\ } + \mathcal P_{\mathrm{BK}}[1/E_\pi]. +\] +Its pushout to $\GL(\Lambda_p)$ is the Breuil--Kisin module of +$\mathcal H_z$. Reduction at $u=0$, followed by the dual +Frobenius descent fixed above, therefore gives the actual +Dieudonn\'e lattice of $\mathcal H_{z,k}$. +Proposition~3.5.1 of \cite{PappasRapoport2024} compares the two +specializations of this already constructed framed point. In +the coordinates of \cite[Theorem~2.2.5]{KisinZhou2025} it gives +\[ + g\in X_{\mathcal J}(\mu^{-1},b_x),\qquad + \mathbb D(\mathcal H_{z,k}) + =\rho^\vee(\sigma(g))\mathbb D_x\subset D_x. +\] +Indeed the Frobenius matrix on this lattice, written in its +induced basis, is +\[ + \rho^\vee\!\left( + \sigma(g^{-1}b_x\sigma(g))\right)\circ\sigma, +\] +which explains the same Frobenius descent in the +Deligne--Lusztig condition and in the lattice formula. + +\medskip\noindent +\emph{The abelian marking and the filtration.} +Keep the identity prime-to-$p$ coordinate in the uniformization. +The description of its special fiber in +\cite[\S4.10.3]{PappasRapoport2024}, or equivalently the +isogeny-class map of \cite[Theorem~2.2.5]{KisinZhou2025}, gives +$y=i_x(g)$ and a single abelian quasi-isogeny +$b:C_x\to C_y$ preserving the crystalline tensors and every +prime-to-$p$ tensor. Its crystalline marking is the one just +used for $\mathcal H_z$, because the uniformization is induced +by the marked Siegel Rapoport--Zink space. + +The crystalline period map of that space is the Hodge filtration +of its universal deformation pulled back by its marking. +Compatibility of $\Theta_x$ with the tautological shtuka and +\eqref{eq:transport-framed-point} consequently give +\[ + b^*\Fil^1H^1_{\mathrm{dR}}(C_{\widetilde y}/K) + =\mathcal F^1. +\] +The deformation criterion +\cite[Proposition~2.2.3]{KisinZhou2025} is satisfied concretely: +the filtration is of type $\mu$, and the crystalline structure +tensors compare with the integral \'{e}tale tensors in the +$\mathcal J(\Z_p)$-frames of $z$. The bounded integral shtuka +and its annular framing were obtained before using this +criterion or comparing specializations. All cited global +Hodge-type and strongly admissible results apply at $p=2$ as +well. + +Finally, under finite local-field descent, the weak-admissibility +inequalities restrict to the descended Frobenius subobjects. +Colmez--Fontaine's theorem +\cite[Theorem~A]{ColmezFontaine2000} makes those descended data +admissible, and scalar extension supplies condition~\textup{(1)}. +\end{proof} + +\subsection{Proof of the transport proposition} + +\begin{proof}[Proof of Proposition~\ref{prop:transport}] +\medskip\noindent +\emph{The original point and its reduction.} +Apply Lemma~\ref{lem:auxiliary-datum}. Choose a rational +$J$-equivariant identification +$W=(V\otimes_\Q P)^{\oplus m}$ and set $n=m[P:\Q]$. +Choose a basis of $P$ whose first vector is $1$. The resulting +identification of the Hodge structure at the diagonal point $h$ +with $V^{\oplus n}$ makes the first-factor map equal to +\begin{equation} + v\longmapsto(v\otimes1,0,\ldots,0). + \label{eq:transport-first-factor} +\end{equation} +The rational homology/isogeny correspondence +\cite[Corollary~6.9]{MilneShimura} therefore makes the abelian variety +\(C\) at that point isogenous to \(A^n\). Fix a rational isogeny +\(f:A^n\to C\) realizing this identification. + +We explain the field and reduction assertions for this starting +point. The Hodge embedding maps it to the Siegel point of the +polarized variety $C$ with finite level. The abelian variety $C$ +is defined over $\Qbar$: clearing a denominator in $f$ realizes +it as a quotient of $A^n$ by a finite subgroup of its torsion, and +every such subgroup is defined over $\Qbar$. Its rational +polarization and its finite level also descend to $\Qbar$, since +homomorphisms between abelian varieties over $\Qbar$ do not +enlarge after extending algebraically closed fields +\cite[Corollary~20.4]{MilneAV}. The Hodge +embedding induces a finite morphism onto its +image at sufficiently small finite level +\cite[Theorem~5.16]{MilneShimura}. Its fiber over a +$\Qbar$-point therefore consists of $\Qbar$-points. This places +the diagonal point on the canonical model over $\Qbar$. + +After a finite number-field extension the variety $C$ has good +reduction, since it is isogenous to $A^n$ +\cite[Chapter~IV, Theorem~3.5]{MilneAVNotes}. Its polarization and +prime-to-$p$ level extend after a further finite extension. +The integral Hodge-type model is the normalization of the closure +of the generic fiber in the adapted Siegel model. The valuative +criterion for this finite normalization therefore extends our +point to its integral model. Denote the reduction by $x$. +The rational isogeny $f$ specializes to a quasi-isogeny +$f_0:A_0^n\to C_x$. + +\medskip\noindent +\emph{The trace tensor and its descent.} +Next extend the alternating form defining $\gamma$ +$P$-multilinearly and take its trace. Composing with projection +onto the first copy in \eqref{eq:transport-copies} gives +\begin{equation} + \eta=\Tr_{P/\Q}(\gamma_P)\circ + (\operatorname{pr}_1)^{\otimes 2r} + \in\bigwedge^{2r}W^*. + \label{eq:transport-trace-tensor} +\end{equation} +For $r=0$ this is interpreted as the scalar trace. +The equal-multiplier condition implies that $\eta$ has multiplier +$c^r$ under $J$. On \eqref{eq:transport-first-factor}, its +restriction is +\begin{equation} + j^*f^*\eta_C=[P:\Q]\gamma. + \label{eq:transport-trace-restriction} +\end{equation} +The class $\eta_C$ is understood with its Tate twist. + +We turn this semi-invariant into the untwisted tensors to which +the integral-model theorems directly apply. Write +$\psi_W^{-1}\in\bigwedge^2W$ for the inverse symplectic +bivector, and include +\begin{equation} + u_\psi=\psi_W\otimes\psi_W^{-1},\qquad + u_\eta=\eta\otimes(\psi_W^{-1})^{\otimes r} + \label{eq:transport-untwisted-tensors} +\end{equation} +among the structure tensors. Both are $J$-invariant tensors in +ordinary tensor constructions of $W$ and $W^*$; no separately +trivialized Tate object is needed. They can be made integral and +added to the defining family as explained above. Their +crystalline and prime-to-$p$ realizations at $x$ are the +specializations from the original point, with the comparison +conventions fixed above. + +\phantomsection +\label{par:transport-tensor-descent} +The entire finite family of structure tensors, including +$u_\psi$ and $u_\eta$, has finite local-field descent. To see +this, choose a finite extension $L/\Q_p$ over whose valuation +ring the original number-field point is defined, and let $L_0$ +be its maximal unramified subfield. The canonical \'etale +tensor sections of \cite[\S2.1.4]{KisinZhou2025}, pulled back +to that point, are $\Gal(\overline L/L)$-invariant. Applying +the tensor functor $D_{\mathrm{cris},L}$ to these morphisms +from the unit object places them in the crystalline tensor +spaces over $L_0$. Their extension to $\Kzero$ is exactly +the family $s_{\alpha,0,x}$, by good-reduction comparison. +The map $f_0$ also descends after a finite residue-field +extension, so this descent is retained under its marking. +Taking a compositum with the finite field of definition of a +prescribed filtration therefore gives one finite local field +for all the data. No tensor-preserving trivialization over +$L_0$ is being asserted or needed. + +\medskip\noindent +\emph{The two choices of lift.} +For specification~(1), apply +\cite[Theorem~2.2.7]{KisinZhou2025} to $x$. It gives a point +$y\in\mathcal I_x$ with a special-point lift and a +tensor-preserving quasi-isogeny $b:C_x\to C_y$. +The special-point lift supplies a CM abelian variety $B$. Special +points on the canonical Shimura variety are algebraic over its +reflex field by the canonical-model theory +\cite[Definition~12.8 and Proposition~14.14]{MilneShimura}, so $B$ +and its level data can be taken over $\Qbar$. The given local lift specifies their embedding at $w$ +and their good reduction $B_0=C_y$. + +For specification~(2), identify $D_x$ with $D_A^{\oplus n}$ using +$f_0^*$ and prescribe the direct-sum filtration +$\mathcal F_A^{\oplus n}$. It is weakly admissible, with the +required finite local-field descent. It is also in the required +$J$-cocharacter orbit. Indeed a geometric element of the +transported $G$ taking the original filtration on $D_A$ to +$\mathcal F_A$ acts diagonally on all the copies of $V$ in $W$; +its image in $J$ takes the original filtration on $D_x$ to the +prescribed one. The tensor-preserving identifications used here +come from the initial point and comparison, so they include the +$J$-structure tensors as well. Geometric conjugacy can be +realized over a finite extension, since the corresponding +isomorphism scheme is of finite type. +Lemma~\ref{lem:admissible-realization} now gives $y$, its lift +$B$, and a tensor-preserving quasi-isogeny $b:C_x\to B_0$ with +the prescribed marked filtration. This proves +\eqref{eq:transport-prescribed-filtration} for +$a=bf_0$. + +\medskip\noindent +\emph{A common rational normalization.} +It remains, in both specifications, to recover the twisted class +and normalize it by a single rational scalar. Choose a complex +description of the lifted Shimura point. Its rational marking by +$W$ supplies a rational Hodge class $\eta_B$ corresponding to +$\eta$, and a rational divisor class $\theta_B$ +corresponding to $\psi_W$. Write $\theta_C$ for the analogous +class on $C$ and put +\[ + \theta_*=f_0^*\theta_{C,0}\in\NS(A_0^n)\otimes_\Z\Q. +\] +The class $\theta_*$ is rational ample. Tensor preservation of +$u_\psi$ says that, in each realization, +\begin{equation} + a^*\theta_{B,0}=\lambda_v\theta_*, + \label{eq:transport-local-similitudes} +\end{equation} +with a nonzero local scalar $\lambda_v$. Let $D=n\dim A$. +Pairing with $\theta_*^{D-1}$ gives +\begin{equation} + \lambda_v= + \frac{\deg\bigl(a^*\theta_{B,0}\cdot\theta_*^{D-1}\bigr)} + {\deg(\theta_*^D)}=:\lambda\in\Q^\times. + \label{eq:transport-rational-similitude} +\end{equation} +Both intersection numbers refer to rational divisor classes on +the same abelian variety; their cycle-class traces are identical +in every realization. The denominator is positive because +$\theta_*$ is ample, and the numerator is nonzero by +\eqref{eq:transport-local-similitudes}. Thus all the scalars in +\eqref{eq:transport-local-similitudes}, including the crystalline +one, are the single rational number $\lambda$. + +Preservation of $u_\eta$, together with +\eqref{eq:transport-rational-similitude}, then yields +\begin{equation} + a^*\eta_{B,0}=\lambda^r f_0^*\eta_{C,0} + \label{eq:transport-eta-scaling} +\end{equation} +simultaneously. In fact the inverse bivector scales by +$\lambda^{-1}$, so that the equality for the untwisted tensor +in \eqref{eq:transport-untwisted-tensors} gives exactly +\eqref{eq:transport-eta-scaling}. Set +\[ + \kappa=\frac{\lambda^{-r}}{[P:\Q]}\eta_B. +\] +Specializing \eqref{eq:transport-trace-restriction} and using +\eqref{eq:transport-eta-scaling} proves +\eqref{eq:transport-class}. + +For the arbitrary local lift, the crystalline realization just +used is unambiguous: the canonical model supplies the untwisted +tensor $u_\eta$, and the algebraic polarization supplies its Tate +line and inverse bivector. The comparison isomorphism and these +operations define $\eta_B$ in the crystalline realization and +agree with its canonical \'{e}tale tensors. Consequently any +identity expressing this class by algebraic divisor operations +specializes with the same rational coefficients in all +realizations. For the $\Qbar$-valued CM lift, these are also the +usual absolute-Hodge and de Rham realizations. This completes +the two constructions. +\end{proof} + +\begin{corollary}[CM transport of a Hodge class] +\label{cor:cm-transport} +Let \(A/\Qbar\) be an abelian variety of positive dimension with +good reduction at \(w\), and let +\(\gamma\in H^{2r}(A(\C),\Q(r))\) be a rational Hodge class, +where \(0\leq r\leq\dim A\). There are a positive integer \(n\), +a CM abelian variety \(B/\Qbar\) with good reduction at \(w\), +a rational Hodge class \(\kappa\) of codimension \(r\) on \(B\), +and a quasi-isogeny \(a:A_0^n\to B_0\) such that +\[ + \gamma_0=(aj)^*\kappa_0, +\] +where \(j:A_0\to A_0^n\) is the first-factor inclusion. This is an +equality of the usual absolute-Hodge specializations in every +prime-to-\(p\) realization and in crystalline cohomology extended +to \(\Cw\). +\end{corollary} + +\begin{proof} +Choose a polarization \(\psi\) on \(V=H_1(A(\C),\Q)\), and let +\(G=\MT(V)\). The Mumford--Tate group is connected reductive and +is characterized by its Hodge tensors +\cite[Section~3, Propositions~3.4 and~3.6]{Deligne1982}. +The Hodge homomorphism and its \(G(\R)\)-conjugacy class define +the Mumford--Tate Shimura datum of Hodge type, with faithful +symplectic representation +\[ + G\hookrightarrow\GSp(V,\psi). +\] +The polarization supplies the rational weight and the Cartan +involution condition. The definition of the Mumford--Tate group +excludes an adjoint factor on which the Hodge homomorphism is +trivial. The class \(\gamma\), with its Tate twist, is fixed by +\(G\). Equivalently, its alternating form on \(V\) has multiplier +\(c^r\), where \(c\) is the similitude character. Thus the first +alternative of Proposition~\ref{prop:transport} applies and gives +the asserted data and simultaneous equality. +\end{proof} diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/03_filtration.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/03_filtration.tex new file mode 100644 index 0000000000000000000000000000000000000000..c14d2e86b1d777b7944ce9e765adaa60aa3b7cdf --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/03_filtration.tex @@ -0,0 +1,482 @@ +\section{An endomorphism-stable weakly admissible filtration} +\label{sec:filtration} + +We construct a filtration on first crystalline cohomology that preserves an +additional divisor. The construction takes place entirely on the given +isocrystal. Its realization by an abelian lift will be a separate step. +Generic transversality is a basic ingredient of the admissible-filtration +existence theorems of Fontaine--Rapoport +\cite[Theorem~1 and Lemmas~1.1--1.2]{FontaineRapoport2005}. +We impose the additional endomorphism and polarization constraints +explicitly. The bounded-degree argument below chooses the required +coordinates over a finite algebraic extension, while testing every +subisocrystal over the fixed coefficient field. + +Throughout this section, $\Kzero=\operatorname{Frac}W(\overline{\F}_p)$, +and valuations are normalized by $v(p)=1$. If $D$ is an isocrystal over +$\Kzero$ and $K/\Kzero$ is finite, a subspace $L\subset D_K$ defines the +one-step filtration +\[ + \Fil^iD_K= + \begin{cases} + D_K,&i\leq 0,\\ + L,&i=1,\\ + 0,&i\geq 2. + \end{cases} +\] +For an isocrystal subobject $P\subset D$, its Hodge number for this +filtration is $t_H(P)=\dim_K(P_K\cap L)$. Its Newton number $t_N(P)$ is +the sum of its slopes with multiplicities. Weak admissibility means that +$t_H(D)=t_N(D)$ and $t_H(P)\leq t_N(P)$ for every isocrystal subobject +$P$ over $\Kzero$. + +Finite local-field descent is understood as in Section~\ref{sec:transport}: +the isocrystal and its indicated tensors descend to the maximal unramified +subfield of a finite extension of \(\Q_p\), and the filtration descends +to that finite extension. + +\begin{theorem}[The filtration construction] +\label{thm:filtration} +Let $A_0/\overline{\F}_p$ be an abelian variety equipped with a rational +action of a CM field $E$ and a polarization whose Rosati involution +restricts to conjugation on $E$. Suppose that +\[ + D=H^1_{\mathrm{cris}}(A_0/W(\overline{\F}_p))[1/p] +\] +has rank $2s$ over $E\otimes_\Q\Kzero$, where $s\geq 1$. Suppose also +that there is an invertible $u\in\End^0(A_0)$ such that +\[ + u^\dagger=u,\qquad ue=\bar e u\quad(e\in E). +\] +Let $\beta$ be the dual polarization pairing on $D$, with values in +the isocrystal line of slope $1$. + +Then there are a finite extension $K/\Kzero$ and a subspace $L\subset +D_K$ with the following properties: +\begin{enumerate} +\item The one-step filtration with $\Fil^1D_K=L$ is weakly admissible. +\item $L$ is stable under the cohomological actions of $E$ and $u$, +and is Lagrangian for $\beta$. +\item After extending to an algebraically closed field $\Omega/K$, +one has $\dim_\Omega L_\tau=s$ for every embedding +$\tau:E\hookrightarrow\Omega$. +\item The isocrystal, its indicated tensors, and this filtration have +finite local field descent. +\end{enumerate} +Moreover, geometrically $L$ belongs to the balanced polarized +cocharacter orbit. More explicitly, define +\[ + G_D=\left\{g\in\GSp(D,\beta)\cap + \GL_{E\otimes_\Q\Kzero}(D): + \det_{E\otimes_\Q\Kzero}(g)=c(g)^s\right\}, +\] +where the scalar on the right is viewed in +$(E\otimes_\Q\Kzero)^\times$. The balanced $E$-stable +$\beta$-Lagrangians form a single $G_D(\Omega)$-orbit. Each is the +weight-$1$ space of a cocharacter of $G_{D,\Omega}$ with weights $0,1$. +In particular $L$ belongs to the orbit of any original filtration of +this type under a tensor-preserving comparison. +\end{theorem} + +The proof will construct \(L\) from Lagrangians in finitely many +symplectic spaces. The two lemmas below supply the required simultaneous +choice: minimum intersection with a subspace is ensured by a nonzero +minor of bounded degree, and all such minors over a fixed coefficient +field can be made nonzero over one finite extension. + +\begin{lemma}[Bounded-degree avoidance over a finite extension] +\label{lem:avoidance} +Let $K_1/\Kzero$ be a finite extension, and let $r,b\geq 1$ be integers. +There exist an element $\theta$ algebraic over $\Q_p$ and a point +\[ + (x_0,\ldots,x_{r-1})\in K_1(\theta)^r +\] +at which every nonzero polynomial in $K_1[X_0,\ldots,X_{r-1}]$ of total +degree at most $b$ is nonzero. The coordinates $x_i$ can all be chosen +in $\Q_p(\theta)$. +\end{lemma} + +\begin{proof} +Choose an integer $N>b$ and put +\[ + B=b\sum_{i=0}^{r-1}N^i. +\] +Let $e$ be the ramification index of $K_1/\Kzero$, so that +$v(K_1^\times)=\frac1e\Z$. Choose a prime $q>\max(B,e)$, and choose +$\theta$ with $\theta^q=p$ in an algebraic closure of $K_1$. The value +$v(\theta)=1/q$ has order $q$ modulo $\frac1e\Z$. Consequently the +ramification index, and hence the degree, of $K_1(\theta)/K_1$ is at +least $q$. The polynomial $X^q-p$ gives the reverse inequality, so +\[ + [K_1(\theta):K_1]=q>B. +\] + +Set $x_i=\theta^{N^i}$. Under the substitution $X_i=T^{N^i}$, +distinct monomials of total degree at most $b$ have distinct exponents: +each exponent of an individual variable is smaller than $N$, and +uniqueness follows from base-$N$ expansion. Thus a nonzero polynomial +of total degree at most $b$ becomes a nonzero polynomial in $T$ of +degree at most $B$. It cannot vanish at $\theta$, whose degree over +$K_1$ exceeds $B$. +\end{proof} + +\begin{remark} +The coefficient field in Lemma~\ref{lem:avoidance} is the fixed field +$K_1$. The conclusion concerns all bounded-degree polynomials over that +field, with no restriction on their cardinality. It would be false with +$K_1(\theta)$ in place of $K_1$ as the coefficient field. +\end{remark} + +\begin{lemma}[Intersections with Lagrangians] +\label{lem:lagrangian-intersection} +Let $M$ be a symplectic space of dimension $2m$ over a field $k$ of +characteristic zero, and let $W\subset M$ have dimension $a$. A nonempty +open subset of the Lagrangian Grassmannian consists of subspaces $L$ +such that +\[ + \dim(L\cap W)=\max(0,a-m). +\] +On any fixed symplectic affine big cell, at least one nonzero polynomial +of degree at most $m$ has nonvanishing locus contained in this open +subset. This degree bound is independent of $W$. +\end{lemma} + +\begin{proof} +We first work over an algebraic closure. The Lagrangian Grassmannian +is geometrically integral of dimension $m(m+1)/2$; its affine big cells +are parametrized by symmetric $m\times m$ matrices. If $1\leq a\leq m$, +consider the projective incidence variety of pairs $(\ell,L)$ with +$\ell\subset W$ a line and $\ell\subset L$ a Lagrangian. The fiber over +$\ell$ is the Lagrangian Grassmannian of the symplectic space +$\ell^\perp/\ell$, and therefore the incidence variety has dimension +\[ + a-1+\frac{m(m-1)}2<\frac{m(m+1)}2. +\] +Its image is a proper closed subset. Its complement consists precisely +of the Lagrangians missing $W$. The case $a=0$ is immediate. For +$a>m$, use +\[ + \dim(L\cap W)=a-m+\dim(L\cap W^\perp) +\] +and apply the preceding argument to $W^\perp$. + +For the assertion on equations, choose coordinates on the fixed big +cell in which $L$ is the column space of +\[ + \begin{pmatrix}I_m\\ T\end{pmatrix},\qquad T=T^{\mathsf t}. +\] +The minimum-intersection condition says that the composite of this +matrix with the quotient map $M\longrightarrow M/W$ has rank +$\min(m,2m-a)$. Its entries are affine linear polynomials in the +independent entries of $T$. The nonempty open subset already proved +meets this big cell, so some minor of the required size is a nonzero +polynomial over $k$. Its degree is at most $m$, and its nonvanishing +implies the required rank. If the required rank is zero, use the +constant polynomial $1$. +\end{proof} + + +The two lemmas reduce simultaneous transversality to a uniform bound on +the degrees of the relevant minors. We now identify the symplectic +spaces on which to apply them and the inequalities they must enforce. + +\begin{proof}[Proof of Theorem~\ref{thm:filtration}] +We write $e$ and $u$ also for their cohomological actions on $D$. +These actions commute with Frobenius and satisfy +\begin{equation} +\label{eq:filtration-adjoints} + \beta(ux,y)=\beta(x,uy),\qquad + \beta(ex,y)=\beta(x,\bar e y),\qquad ue=\bar e u. +\end{equation} +There is no change to the last relation from contravariance. Indeed, +pulling back $ue=\bar e u$ gives $e^*u^*=u^*\bar e^*$; replacing $e$ +by $\bar e$ gives $u^*e^*=\bar e^*u^*$. Likewise, if $J$ is the +homological polarization matrix, $U^{\mathsf t}J=JU$ implies +$UJ^{-1}=J^{-1}U^{\mathsf t}$, which is the self-adjointness of the +cohomological action $U^{\mathsf t}$ for the dual pairing. The +Rosati-conjugate adjoint identity for $E$ follows in the same way. + +The pullback $U^{\mathsf t}$ of an individual endomorphism is +distinct from the contragredient group action $g\mapsto g^{-\mathsf t}$. +If a homological similitude $g$ has multiplier $c_V$ and satisfies +$\det_E(g)=c_V^s$, its dual action has multiplier $c_D=c_V^{-1}$ +and satisfies $\det_E(g^{-\mathsf t})=c_D^s$. +Thus $G_D$ is the dual form of the homological group defined by this +determinant condition, with its cohomological multiplier. + +\medskip\noindent +\emph{Reduction to the stable subobjects.} +First consider any $E,u$-stable candidate $L\subset D_K$, where +$K/\Kzero$ is finite. We show that the weak-admissibility inequalities +need only be tested on $E,u$-stable subobjects. This resembles the use of canonical +destabilizing objects in \cite[Section~2]{FontaineRapoport2005}, +but we use total defect, not defect divided by dimension, and give +the required elementary argument. +For any isocrystal subobject $P\subset D$ over $\Kzero$, set +\[ + f(P)=t_H(P)-t_N(P). +\] +These values form a finite set: the Hodge number is a bounded integer, +and the Newton number is determined by bounded integer multiplicities +among the finitely many slopes of $D$. Let $a$ be their maximum. +Newton numbers are additive in short exact sequences, while +\[ + (P_K\cap L)+(Q_K\cap L)\subset (P+Q)_K\cap L. +\] +Consequently +\begin{equation} +\label{eq:filtration-supermodularity} + f(P)+f(Q)\leq f(P\cap Q)+f(P+Q). +\end{equation} +If $P$ and $Q$ both attain $a$, the right-hand terms are each at +most $a$, so both attain $a$. Thus maximizers are closed under +intersection and sum. Choose a maximizer $P_{\max}$ of largest +dimension. Adding any other maximizer to it shows that the other +one is contained in it. Hence $P_{\max}$ is the unique largest +maximizer. + +The operators $u$ and $e\in E^\times$ are filtration-preserving +isocrystal automorphisms. They preserve $f$ and hence fix +$P_{\max}$, by its uniqueness. Thus $P_{\max}$ is $E,u$-stable. +Consequently, if $t_H(D')\leq t_N(D')$ for every $E,u$-stable +subobject $D'$, then $a=f(P_{\max})\leq0$. All the +weak-admissibility inequalities follow. We must therefore construct +an $E,u$-stable Lagrangian with these restricted inequalities and +$t_H(D)=t_N(D)$. + +\medskip\noindent +\emph{Semisimplicity and symplectic blocks.} +The Rosati trace form +\[ + \langle a,b\rangle=\Tr(ab^\dagger) + \quad\text{on }\End^0(A_0)\otimes_\Q\R +\] +is positive definite \cite[Theorem~17.3]{MilneAV}. Left multiplication +by $u$ is self-adjoint for this form, since trace cyclicity gives +\[ + \langle ua,b\rangle=\Tr(uab^\dagger) + =\Tr(ab^\dagger u)=\langle a,ub\rangle. +\] +It is therefore diagonalizable. Its minimal polynomial equals the +minimal polynomial of $u$ in the endomorphism algebra, as is seen by +applying a polynomial in the multiplication operator to the identity. +Thus $u$, and hence $u^2$, acts semisimply on $D$. The relation in +\eqref{eq:filtration-adjoints} also shows that $u^2$ commutes with $E$. + +Put +\[ + B(x,y)=\beta(x,uy). +\] +This is a nondegenerate alternating pairing. Indeed, invertibility is +immediate, and +$B(y,x)=-\beta(ux,y)=-B(x,y)$. In addition, +\[ + B(ex,y)=\beta(x,\bar euy)=\beta(x,uey)=B(x,ey), + \qquad B(u^2x,y)=B(x,u^2y). +\] +After a finite splitting extension $K_1/\Kzero$, write +\[ + D_{K_1}=\bigoplus_{\tau,z}M_{\tau,z}, + \qquad + M_{\tau,z}=\{x:ex=\tau(e)x\ (e\in E),\ u^2x=zx\}. +\] +We omit zero summands. The self-adjoint identities for $B$ show that +distinct summands are orthogonal. Its restriction to each summand is +therefore nondegenerate. Write $\dim M_{\tau,z}=2m_{\tau,z}$. + +For $\bar\tau=\tau\circ\overline{(\cdot)}$, the operator $u$ maps +$M_{\tau,z}$ isomorphically to $M_{\bar\tau,z}$. On these spaces, +\begin{equation} +\label{eq:filtration-u-similitude} + B(ux,uy)=zB(x,y). +\end{equation} +Here $z\neq 0$, and $\tau\neq\bar\tau$. Choose a $B$-Lagrangian +$L_{\tau,z}$ in one member of each opposite pair, and prescribe +\begin{equation} +\label{eq:filtration-opposite-choice} + L_{\bar\tau,z}=uL_{\tau,z}. +\end{equation} +Equation~\eqref{eq:filtration-u-similitude} shows that the latter is +Lagrangian as well. Their direct sum $L$ is $E$-stable and $u$-stable; +on applying $u$ twice, one obtains $zL_{\tau,z}=L_{\tau,z}$. Since +\[ + \beta(x,y)=B(x,u^{-1}y), +\] +$L$ is also $\beta$-Lagrangian. Its dimension at each $E$-embedding +is $s$. It remains to make the independent choices appropriately. + +\medskip\noindent +\emph{The inherited Newton grading.} +Use the canonical slope decomposition +\[ + D=\bigoplus_\lambda D_\lambda. +\] +The isocrystal category over $\overline{\F}_p$ is semisimple, and +this decomposition is functorial +\cite[\S3.2, Proposition~3.3]{ColmezFontaine2000}. The slopes of $D$ +belong to $[0,1]$: its integral Dieudonn\'e operators \(F,V\) +satisfy \(FV=p\), so both the slopes of \(F\) and those of \(V\) +are nonnegative. All the endomorphisms above preserve every +$D_\lambda$, and the projectors onto the simultaneous eigenspaces +preserve its scalar extension. Thus each block has a grading +\[ + M_{\tau,z}=\bigoplus_\lambda M_{\tau,z,\lambda},\qquad + M_{\tau,z,\lambda}=M_{\tau,z}\cap(D_\lambda)_{K_1}. +\] +We use this grading even if Frobenius permutes the labels $(\tau,z)$. +No extension of Frobenius to $K_1$, and no isocrystal structure on an +individual block, is required. + +Before scalar extension, $B$ is a pairing of isocrystals into the +slope-$1$ line. Hence $B(D_\lambda,D_\mu)=0$ unless +$\lambda+\mu=1$. Nondegeneracy on an individual block $M$ then gives +perfect pairings between $M_\lambda$ and $M_{1-\lambda}$. In +particular, if $\dim M=2m$, +\begin{equation} +\label{eq:filtration-block-newton} + \sum_\lambda\lambda\dim M_\lambda=m. +\end{equation} + +Let $D'\subset D$ be an isocrystal subobject over $\Kzero$ stable +under $E$ and $u$. Its intersections $M'=D'_{K_1}\cap M$ decompose +$D'_{K_1}$ and inherit the same slope grading. Put $a=\dim M'$. +The slope sum of the graded quotient $M/M'$ is at most $2m-a$, +because all its slopes belong to $[0,1]$. By +\eqref{eq:filtration-block-newton}, +\begin{equation} +\label{eq:filtration-block-bound} + \sum_\lambda\lambda\dim M'_\lambda + \geq \max(0,a-m). +\end{equation} +The additional bound by zero follows from the nonnegative slopes. +The right side is also the smallest possible dimension of the +intersection of a Lagrangian in $M$ with $M'$. +Thus attaining this minimum in every block will give the +weak-admissibility inequalities for all the stable subobjects. + +\medskip\noindent +\emph{Simultaneous choices and finite local field descent.} +We may arrange the splitting field and coordinates used above as +follows. Choose a finite field $k_0\subset\overline{\F}_p$ over +which $A_0$, its polarization, $u$, and a rational basis of $E$ are +defined. The underlying isocrystal and the indicated tensors then +descend to $\operatorname{Frac}W(k_0)$. Choose a finite local field +$H/\Q_p$ containing this field and splitting the actions of $E$ and +$u^2$. The eigenspaces and their symplectic bases can be constructed +over $H$ by linear algebra. We take $K_1=\Kzero H$. In particular, +the independent Lagrangian Grassmannians, fixed symplectic big cells +in them, and the maps induced by $u$ all have coordinates over $H$. + +Take the product of these big cells, one for each independent choice +in \eqref{eq:filtration-opposite-choice}, and let $r$ be its number +of affine coordinates. For every $E,u$-stable isocrystal subobject +$D'$ over $\Kzero$ and each independent block $M$, the space +$M'=D'_{K_1}\cap M$ is defined over the \emph{fixed} field $K_1$. +Lemma~\ref{lem:lagrangian-intersection} supplies a nonzero polynomial +over $K_1$, of degree at most $m$, whose nonvanishing ensures +\begin{equation} +\label{eq:filtration-minimal-intersection} + \dim(L_{\tau,z}\cap M')=\max(0,\dim M'-m). +\end{equation} +We regard this as a polynomial on the whole product by ignoring the +other coordinates. A single bound $b=\max m_{\tau,z}$ works for all +these polynomials, independently of $D'$. On the opposite block, +the same intersection equality follows from $u$-stability of $D'$ +and \eqref{eq:filtration-opposite-choice}. + +Apply Lemma~\ref{lem:avoidance} to $K_1,r,b$. Its one point satisfies +\eqref{eq:filtration-minimal-intersection} for every one of the +subobjects just specified, simultaneously. This use of the lemma +does not assume that the collection of subobjects is countable or +that its members descend to $H$. Their definition over $K_1$ and +the uniform polynomial degree bound are the only requirements. +There are nonzero blocks with $m\geq1$, so $r,b\geq1$ as required. + +Put $K=K_1(\theta)=\Kzero H(\theta)$. The resulting Lagrangian is +defined over $H(\theta)$ in the chosen coordinates, and $H(\theta)$ +is finite over $\Q_p$. Extending the original isocrystal to the +maximal unramified subfield of $H(\theta)$ therefore gives finite +local field descent of the complete filtered data. In particular, +the construction has not obtained its generic point by introducing +transcendental parameters. + +Summing \eqref{eq:filtration-minimal-intersection} and +\eqref{eq:filtration-block-bound} over all blocks gives +\begin{equation} +\label{eq:filtration-stable-test} + t_H(D')\leq t_N(D') + \quad\text{for every $E,u$-stable isocrystal subobject $D'\subset D$.} +\end{equation} +For $D$ itself, both numbers equal $\frac12\dim D$ by +\eqref{eq:filtration-block-newton}. The reduction to stable subobjects +proved at the start now gives all the weak-admissibility inequalities +for subobjects of $D$ over $\Kzero$. Each subobject over the smaller unramified +field of descent extends to one of these subobjects. Hence the +descended filtered isocrystal is weakly admissible as well. + +\medskip\noindent +\emph{The geometric cocharacter orbit.} +Over $\Omega$, the polarization pairs $D_\tau$ only with +$D_{\bar\tau}$. A balanced $E$-stable Lagrangian is determined by an +$s$-dimensional subspace of $D_\tau$ for one member of each pair; +the subspace in the opposite member is its annihilator. The +subgroup of $G_D$ with multiplier $1$ contains the product of +$\SL(D_\tau)$ acting on opposite spaces by the inverse dual +representations. These special linear groups are transitive on +the $s$-dimensional subspaces. Thus all the indicated Lagrangians +form one $G_D(\Omega)$-orbit. + +Finally choose an $E$-stable $\beta$-Lagrangian complement to one +such $L$. Such a complement is obtained separately on each pair +of opposite embedding spaces. Acting by $t$ on $L$ and by $1$ +on the complement gives a cocharacter with multiplier $t$ and +$E$-determinant $t^s$ at each embedding. It lies in $G_D$ and has +the stated filtration. This proves the final assertions. +\end{proof} + +\begin{corollary} +\label{cor:filtration-admissible} +The filtration of Theorem~\ref{thm:filtration}, with its finite local +field descent, is admissible: the descended filtered isocrystal is +the filtered crystalline module of a crystalline representation. +\end{corollary} + +\begin{proof} +Apply the weakly-admissible-implies-admissible theorem of +Colmez--Fontaine with monodromy operator zero +\cite[Theorem~A]{ColmezFontaine2000}. +\end{proof} + +\begin{corollary}[The divisor filtration condition] +\label{cor:filtration-divisor} +Let \(D,L\) be as in Theorem~\ref{thm:filtration}, and let \(\psi\) +and \(U\) denote the homological polarization and the homological +action of \(u\) on \(D_K^\vee\). The untwisted divisor form +\(\psi(\cdot,U\cdot)\) belongs to +\[ + \Fil^1\bigl(\bigwedge^2D_K\bigr)=L\wedge D_K, +\] +and hence to filtration degree zero after its codimension-one Tate +twist. If a marked power is realized by an abelian lift, the +corresponding pulled-back divisor satisfies the filtration condition +for its symmetric homomorphism in Lemma~\ref{lem:lift-hom}. +\end{corollary} + +\begin{proof} +Let \(H\subset D_K^\vee\) be the annihilator of \(L\). It is +Lagrangian for \(\psi\) and stable under \(U\): for \(a\in L\) +and \(h\in H\), +\[ + a(Uh)=(u^*a)(h)=0. +\] +Therefore \(\psi(h,Uh')=0\) for \(h,h'\in H\). The divisor form +thus lies in +\[ + \ker\bigl(\bigwedge^2D_K\longrightarrow\bigwedge^2H^\vee\bigr) + =L\wedge D_K. +\] +This proves the assertion on the fixed filtered vector space. After +realization of a marked power, pullback respects this filtration +condition, which is precisely the condition on the associated +symmetric homomorphism in Lemma~\ref{lem:lift-hom}. +\end{proof} diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/04_weil.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/04_weil.tex new file mode 100644 index 0000000000000000000000000000000000000000..e3fd56b907ba992b5537800caf08805364902de0 --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/04_weil.tex @@ -0,0 +1,439 @@ +\section{Balanced Weil classes}\label{sec:weil} + +Let $A/\Qbar$ have good reduction at the fixed place $w$, and let a CM +field $E$ act on $A$ up to isogeny. We write $e\mapsto\bar e$ for its +complex conjugation. Suppose that a polarization $\lambda$ induces this +involution on $E$. Put +\[ + V=H_1(A(\C),\Q),\qquad \dim_E V=2s,\qquad + g=\dim A=s[E:\Q], +\] +where $s\geq 1$. We assume that the Hodge multiplicities at every +embedding of $E$ are $(s,s)$. The polarization is an alternating form +$\psi:V\times V\longrightarrow\Q(1)$ satisfying +\[ + \psi(ex,y)=\psi(x,\bar e y). +\] + +\begin{definition}\label{def:weil-space} +The rational space of \emph{Weil classes} associated with $E$ is the +subspace +\[ + W_E^s(A)\subset + \bigwedge\nolimits_{\Q}^{2s} V^\vee\otimes\Q(s) + =H^{2s}(A(\C),\Q(s)) +\] +whose scalar extension to a splitting field $\Omega$ of $E$ is +\begin{equation}\label{eq:weil-pure-space} + W_E^s(A)\otimes_\Q\Omega + =\bigoplus_{\tau:E\hookrightarrow\Omega} + \bigwedge\nolimits_\Omega^{2s}V_\tau^\vee + \otimes\Q(s)_\Omega. +\end{equation} +Here each summand is extended by zero on the other eigenspaces. The +right side is Galois stable, so it defines the indicated rational +subspace. +\end{definition} + +The balanced multiplicities imply that every element of $W_E^s(A)$ is +a Hodge class: each determinant in \eqref{eq:weil-pure-space} has +untwisted type $(s,s)$. We use its compatible realizations as an +absolute Hodge class; see \cite{Deligne1982}. The same eigenspace +description of its support holds after specialization, since the +$E$-action specializes compatibly. + +Our goal is the Lefschetz pairing property for these specialized +classes. In fact, the reduction satisfies a dichotomy determined by +its rational endomorphisms. Let $\dagger$ be Rosati for the reduced +polarization and put +\begin{equation}\label{eq:weil-U} + \mathcal U= + \{u\in\End^0(A_0):u^\dagger=u,\quad + ue=\bar e u\ \text{for every }e\in E\}. +\end{equation} + +\begin{proposition}\label{prop:weil} +Every $\gamma\in W_E^s(A)$ satisfies the Lefschetz pairing property +at $w$. More precisely, if $\mathcal U$ in \eqref{eq:weil-U} has no +invertible element, all complementary pairings are zero. If it has +an invertible element, $\gamma_0$ is a simultaneous rational +Lefschetz class. +\end{proposition} + +We first prove the vanishing alternative. For the other alternative, +an invertible $u$ supplies a divisor whose form is nondegenerate on +each $E$-eigenspace separately. We will lift this divisor and use it +to obtain a rational identity for the determinant classes. + +\subsection{The orthogonality alternative} + +\begin{lemma}\label{lem:weil-orthogonality} +If $\mathcal U$ contains no invertible element, every specialization of +a class in $W_E^s(A)$ is orthogonal to all complementary Lefschetz +classes, in each cohomological realization. +\end{lemma} + +\begin{proof} +We prove the contrapositive. A nonzero pairing will produce a divisor +form nondegenerate on one $E$-eigenspace. We will then show that a +rational endomorphism in $\mathcal U$ with this property is invertible. + +Fix one realization and extend its coefficient field to an +algebraically closed field $\Omega$. At the crystalline component we +also include the coefficient extension used for the specialized +class. In this proof, $V_\tau$ also denotes the corresponding +eigenspace in the dual of first cohomology of $A_0$, identified by +specialization and comparison. Write $L^j_\Omega(A_0)$ for the $\Omega$-span of products of +$j$ divisor classes. Since $[E:\Q]\geq2$, we have $g-2s\geq0$. +Hard Lefschetz on the Lefschetz algebra gives +\begin{equation}\label{eq:weil-hard-lefschetz} + L^{g-s}_\Omega(A_0) + =\psi_0^{g-2s}L^s_\Omega(A_0). +\end{equation} +The restriction of hard Lefschetz to this algebra, including for +crystalline cohomology, follows from the Lefschetz correspondences +of \cite[Theorem~5.9]{Milne1999}. + +Suppose a Weil class pairs nontrivially with +$D_1\cdots D_s\psi_0^{g-2s}$, and choose a pure term, supported on +$V_\tau$, whose contribution is nonzero. This term already has +degree $2s$ on $V_\tau$, so no further factor in a nonzero top-degree +product can use that space. A factor from $\psi_0$ which uses +$V_{\bar\tau}$ also uses $V_\tau$; hence the polarization factors +contribute to neither space in this pair. All $2s$ degrees on +$V_{\bar\tau}$ must therefore come from the $s$ divisor factors. +Each has degree two, so each must contribute its restriction to +$V_{\bar\tau}$, and those restrictions have nonzero product. +The coefficient of $t_1\cdots t_s$ in +\[ + (t_1D_1+\cdots+t_sD_s)^s\big|_{V_{\bar\tau}} +\] +is $s!$ times that product. Some $\Omega$-linear combination of the +divisors therefore restricts to a nondegenerate alternating form on +$V_{\bar\tau}$. + +We identify which endomorphisms can give these restrictions. Let +$p_\xi\in E\otimes_\Q\Omega$ be the eigenspace projectors. Rosati +satisfies $p_\xi^\dagger=p_{\bar\xi}$. A divisor corresponds under +$\psi_0$ to a Rosati-symmetric endomorphism $t$. Define +\begin{equation}\label{eq:weil-block-projection} + \Pi(t)=\sum_\xi p_{\bar\xi}t p_\xi. +\end{equation} +This operation takes place inside +$\End^0(A_0)\otimes_\Q\Omega$. Moreover, +\[ + (p_{\bar\xi}t p_\xi)^\dagger + =p_{\bar\xi}t^\dagger p_\xi, + \qquad + \Pi(t)e=\bar e\Pi(t). +\] +Thus $\Pi(t)\in\mathcal U\otimes_\Q\Omega$. Conversely, these are +exactly the blocks allowed by the second equation in +\eqref{eq:weil-U}. For $x,y\in V_\xi$, the form +$\psi_0(x,ty)$ depends only on $p_{\bar\xi}t p_\xi$. +It follows that projecting by \eqref{eq:weil-block-projection} +preserves all the same-embedding restrictions in question. + +Nondegeneracy on $V_{\bar\tau}$ is a polynomial open condition on +$\mathcal U\otimes_\Q\Omega$, and we have shown this open is +nonempty. The rational points of the rational vector space +$\mathcal U$ are Zariski dense after extension to $\Omega$. Hence +there is a rational $u\in\mathcal U$ for which +$\psi_0(\cdot,u\cdot)$ is nondegenerate on $V_{\bar\tau}$. + +To prove invertibility, we use the fact that a nonzero $E$-stable +abelian subvariety has a nonzero homology space at every embedding +of $E$. Suppose that $u$ is not invertible, and choose an integer +$N>0$ such that $Nu$ is an endomorphism. The reduced identity +component $C=((\ker(Nu))^0)_{\mathrm{red}}$ is a +positive-dimensional abelian subvariety. The relation $ue=\bar e u$ makes $C$ stable under +the rational action of $E$. This action is unital and therefore +faithful. Choose a primitive element $e$ of $E$ and an integer +$M>0$ such that $Me$ acts by an integral endomorphism of $C$. +The exterior algebra description of cohomology and normalized +top-degree pullback give, in every realization +\cite[Appendix, Proposition~(A.2)(a),(b)]{Milne1999}, +\[ + \det\bigl(n-e\mid H^1(C)\bigr) + =M^{-2\dim C}\deg\bigl([Mn]-Me\bigr) +\] +for every integer $n$ for which the map on the right is an +isogeny. All but finitely many integers have this property. +The right side is rational and independent of the realization. +Polynomial interpolation therefore gives one characteristic +polynomial in $\Q[T]$, identical also in crystalline cohomology. +Its roots lie among +the conjugates of $e$, and rationality forces their multiplicities to +be equal. Since $C\ne0$, every embedding of $E$ occurs with positive +multiplicity. The same statement holds on first homology, in the +chosen realization. Rational Poincar\'e reducibility +\cite[Proposition~12.1]{MilneAV} makes the inclusion +\(C\hookrightarrow A_0\) injective on first homology in every +realization. This inclusion is \(E\)-equivariant, and its +image is killed by \(u\). Thus the nonzero \(\bar\tau\)-eigenspace +of \(H_1(C)\) shows that the kernel of \(u\) meets +\(V_{\bar\tau}\) nontrivially. Such a vector lies in the radical of +$\psi_0(\cdot,u\cdot)|_{V_{\bar\tau}}$, a contradiction. + +A nonzero pairing would therefore give an invertible element of +$\mathcal U$. Taking the contrapositive proves the lemma. The +argument applies separately to every realization, so all the +pairings in this case have the common rational value zero. +\end{proof} + +\subsection{A divisor identity on a rational summand} + +For the rest of the section, suppose that $u\in\mathcal U$ is +invertible. It gives a rational divisor $D^u$ on $A_0$ with +alternating form +\begin{equation}\label{eq:weil-extra-divisor} + D^u(x,y)=\psi_0(x,uy). +\end{equation} +This form is nondegenerate and pairs each embedding of $E$ only with +itself: $u$ exchanges opposite eigenspaces, whereas $\psi_0$ pairs +opposite eigenspaces. + +Prescribed-filtration transport will replace $A_0$ by a power and +then by an isogenous special fiber $B_0$. We will retain the first +factor through a rational projector on $B_0$, and lift that projector, +the $E$-action on its image, and the transported divisor to $B$. +The next lemma explains the resulting divisor identity: a divisor +nondegenerate separately on those eigenspaces generates their +determinant classes. A rational projector here means an idempotent +in the rational endomorphism algebra. + +\begin{lemma}\label{lem:weil-divisor-span} +Let $B$ be a complex abelian variety, let $R\in\End^0(B)$ be a +rational projector, and suppose that there is an algebra action +$E\longrightarrow R\End^0(B)R$ whose unit maps to $R$. +Let $T=\operatorname{im}(R)$ in rational first homology, with +$\dim_E T=2s$; the indicated endomorphisms act by zero on +$\ker(R)$. Suppose there is a rational divisor class $D$ on +$B$ such that $R^*D=D$ and, after splitting $E$, its alternating form +is +\[ + D=\sum_\tau D_\tau, + \qquad D_\tau\in\bigwedge\nolimits^2 T_\tau^\vee\otimes\Q(1), +\] +with each $D_\tau$ nondegenerate. Then the rational subspace whose +scalar extension is +\[ + \bigoplus_\tau\bigwedge\nolimits^{2s}T_\tau^\vee\otimes\Q(s), +\] +extended by zero on the complementary summand, consists of rational +Lefschetz classes on $B$. +\end{lemma} + +\begin{proof} +For $b\in E$, let $\widetilde b\in\End^0(B)$ act by $b$ on $T$ and +by zero on the complement. Its pullback of a rational divisor is a +rational divisor: clear a denominator in $\widetilde b$, and use +that multiplication by $N$ acts as $N^2$ on $H^2$. Over a splitting +field $\Omega$, choosing Tate-line bases, we have +\[ + (\widetilde b^*D)^s + =\left(\sum_\tau\tau(b)^2D_\tau\right)^s. +\] +The coordinates $x_\tau=\tau(b)$ are independent coordinates on the +scalar extension of the rational vector group underlying $E$. +In the corresponding vector-valued polynomial +\begin{equation}\label{eq:weil-coefficient-polynomial} + P((x_\tau)_\tau)=\left(\sum_\tau x_\tau^2D_\tau\right)^s, +\end{equation} +the coefficient of $x_\tau^{2s}$ is $D_\tau^s$. Nondegeneracy makes +this coefficient nonzero, so it spans +$\bigwedge^{2s}T_\tau^\vee\otimes\Q(s)_\Omega$. + +Let $M$ be the rational span of the Lefschetz classes +$(\widetilde b^*D)^s$ for $b\in E$. The set $E$ of rational points +is Zariski dense in its vector group, also after extension to +$\Omega$. Any linear functional annihilating $M\otimes_\Q\Omega$ +annihilates all evaluations of \eqref{eq:weil-coefficient-polynomial} +on those points. It therefore annihilates the polynomial, and hence +each coefficient. Every $D_\tau^s$ belongs to +$M\otimes_\Q\Omega$. + +This proves the required inclusion after scalar extension. Both +subspaces are rational; applying faithful scalar extension to their +quotient proves the inclusion over $\Q$. In particular it gives +rational coefficients for every rational class in the asserted +subspace, without requiring an individual embedding line to be +defined over $\Q$. +\end{proof} + +\subsection{A lift preserving the divisor} + +We now construct the auxiliary variety to which +Lemma~\ref{lem:weil-divisor-span} applies. To transport the Weil class, +we use the $E$-linear polarization similitudes whose determinant has +the same transformation law as a codimension-$s$ Tate twist. +Choose a rational basis +for the Betti Tate line, let $c$ be the multiplier of +$\GSp(V,\psi)$, and set +\begin{equation}\label{eq:weil-group} + G=\{a\in\GSp(V,\psi)\cap\GL_E(V): + \det_E(a)=c(a)^s\}. +\end{equation} +On points over a $\Q$-algebra $R$, the determinant equality is in +$(E\otimes_\Q R)^\times$, with the right side embedded diagonally. + +\begin{lemma}\label{lem:weil-group} +The Hodge homomorphism of $A$ factors through $G$, and its conjugacy +class defines a Shimura datum of Hodge type through the displayed +embedding. Over an algebraically closed coefficient field, the orbit +of the corresponding filtration on $H^1$ consists exactly of the +$E$-stable Lagrangians for the dual polarization pairing whose +dimension at each embedding of $E$ is $s$. Using a basis of its Tate +line, every alternating form in \eqref{eq:weil-pure-space} transforms +by $c^s$. +\end{lemma} + +\begin{proof} +The polarization pairs $V_\tau$ with $V_{\bar\tau}$, and no other pair +of eigenspaces. Over an algebraically closed field, choose one +embedding in each conjugate pair. An element of $G$ is specified by +$c$ and matrices $a_\tau\in\GL_{2s}$ with +$\det(a_\tau)=c^s$; the matrices on the opposite spaces are then +determined by the polarization. In particular, +\[ + \ker(c:G\longrightarrow\mathbb G_m) + \simeq\prod_{\{\tau,\bar\tau\}}\SL_{2s}. +\] +The multiplier is surjective geometrically. Thus $G$ is connected +reductive, with the same adjoint group as the group of $E$-linear +polarization similitudes. + +The two Hodge characters occur $s$ times at every embedding. Their +product is the polarization multiplier, so the Hodge homomorphism +satisfies the determinant condition in \eqref{eq:weil-group}. Its +weight is rational and central. On the adjoint Lie algebra the Hodge +types are among $(-1,1),(0,0),(1,-1)$, as follows from the weight-one +representation. Conjugation by the image of $i$ is a Cartan +involution, by the polarization. At every real embedding of the +maximal totally real subfield of $E$, the adjoint group has unitary +signature $(s,s)$. Its Hodge homomorphism is nontrivial there, so no +rational simple adjoint factor has trivial Hodge homomorphism. +These are the Shimura-datum conditions for the given Hodge embedding. + +On $H^1$ the polarization still pairs opposite eigenspaces. An +$E$-stable Lagrangian is specified by an $s$-dimensional subspace at +one embedding of each pair; the subspace at the opposite embedding +is its annihilator. The factor $\SL_{2s}$ acts transitively on these +subspaces, as in the cohomological orbit calculation of +Theorem~\ref{thm:filtration}. Finally, an alternating determinant form +evaluated on $a_\tau v_1,\ldots,a_\tau v_{2s}$ is multiplied by +$\det(a_\tau)=c^s$. This proves the asserted transformation law. +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{prop:weil}] +The vanishing alternative is Lemma~\ref{lem:weil-orthogonality}. +Suppose that $u$ is invertible, and use the divisor $D^u$ from +\eqref{eq:weil-extra-divisor}. + +\medskip\noindent +\emph{A filtration preserving the divisor.} + +Let $\mathcal D=H^1_{\mathrm{cris}}(A_0/W(\F))[1/p]$, with its +contravariant convention, and let $\beta$ be the dual polarization +pairing, taking values in the isocrystal line of slope one. The +actions on $\mathcal D$ satisfy +\[ + \beta(ux,y)=\beta(x,uy),\qquad + \beta(ex,y)=\beta(x,\bar e y),\qquad ue=\bar e u. +\] +All these endomorphisms and the polarization have finite field +descent. Theorem~\ref{thm:filtration} supplies, over a finite +extension with finite local field descent, a weakly admissible +filtration $\Fil^1\mathcal D=L$ which is $E$- and $u$-stable, +is Lagrangian for $\beta$, and has dimension $s$ at every embedding +of $E$. By Lemma~\ref{lem:weil-group} it lies geometrically in the +required $G$-orbit. The +\hyperref[par:transport-tensor-descent]{finite-descent argument} in +Proposition~\ref{prop:transport} shows that its full finite family of +Hodge-type structure tensors descends from the original number-field +point by crystalline comparison. Taking a compositum with the local +field of definition of $L$ gives the common finite local-field descent +required by its prescribed-filtration clause. + +\medskip\noindent +\emph{Transport and the first rational summand.} +Apply Proposition~\ref{prop:transport} to $G$ and $\gamma$ with this +filtration. It gives a lift $B$, a +quasi-isogeny $a:A_0^n\longrightarrow B_0$, and a rational Hodge +class $\kappa$ on $B$, with +\[ + f_0=aj:A_0\longrightarrow B_0,\qquad + f_0^*\kappa_0=\gamma_0, +\] +simultaneously in the realizations under consideration. The +filtration on $B$, marked by $a$, is the direct sum of $n$ copies of +the chosen filtration. Here $j$ includes the first factor. The map +$f_0$ identifies $A_0$ with a rational direct summand of $B_0$. +Its retraction $q_0$ and the corresponding projector $R_0$ are +\begin{equation}\label{eq:weil-projector-identity} + q_0=\operatorname{pr}_1a^{-1},\qquad R_0=f_0q_0. +\end{equation} +Thus $q_0f_0=\id$ and $R_0^2=R_0$. Pulling back +$f_0^*\kappa_0=\gamma_0$ by $q_0$ gives +\[ + R_0^*\kappa_0=q_0^*\gamma_0. +\] +Act by $E$ on $\operatorname{im}(R_0)$ using $e\mapsto f_0e q_0$, +and by zero on the complement. Also put $D_0=q_0^*D^u$. + +\medskip\noindent +\emph{Lifting the projector, action, and divisor.} +The projector and this $E$-action preserve the repeated filtration. +By Corollary~\ref{cor:filtration-divisor}, $D^u$ satisfies the divisor +lifting condition for the chosen filtration on the first summand. +The crystalline map induced by $q_0=\operatorname{pr}_1a^{-1}$ +respects that filtration and the marked repeated filtration on $B_0$. +Hence $D_0=q_0^*D^u$ satisfies the same condition on $B$. +Apply Lemma~\ref{lem:lift-hom} to \(R_0\), to a finite +\(\Q\)-basis of the action of \(E\) on \(\operatorname{im}(R_0)\), and to the +symmetric homomorphism \(h_{D_0}:B_0\to B_0^\vee\) defined by \(D_0\). +Denote their lifts by \(R\), the corresponding basis of maps, and +\(h_D\). Injectivity of specialization preserves \(R^2=R\), the +rational multiplication table of that basis, and its unit \(R\). +It therefore gives an algebra action \(E\to R\End^0(B)R\). +The symmetric map \(h_D\) defines a rational divisor class \(D\). +Moreover, \(q_0R_0=q_0\), so +\[ + R_0^\vee h_{D_0}R_0=h_{D_0}. +\] +Injectivity lifts this identity to \(R^\vee h_DR=h_D\), which is +exactly \(R^*D=D\). Thus the required projector, action, and divisor +all exist on the one auxiliary variety $B$. + +\medskip\noindent +\emph{The rational identity and its specialization.} +Consider now rational Betti cohomology at a complex realization of +$B$. The summand $T=\operatorname{im}(R)$ has dimension $2s$ at +each embedding of $E$. The form of $D$ is supported on this summand +and pairs each embedding with itself nondegenerately. Also +$R^*\kappa$ is supported on the pure determinant spaces of this +summand. These assertions can be checked after extension to any +one prime-to-$p$ realization: for the divisor they follow from its +specified specialization, and for the Hodge class they follow from +the equality $R_0^*\kappa_0=q_0^*\gamma_0$ and the +pure support of $\gamma_0$. Compatibility of the transported +realizations then gives these support and nondegeneracy assertions +in Betti cohomology. + +Lemma~\ref{lem:weil-divisor-span} now expresses the rational Betti +class $R^*\kappa$ as a finite rational linear combination of products +of rational divisor classes on $B$. The realization and +specialization compatibilities in +Proposition~\ref{prop:transport}, together with those for divisors +and homomorphisms, specialize this identity with the same rational +coefficients in every component. Hence $R_0^*\kappa_0$ is a +simultaneous rational Lefschetz class. Finally, +\[ + \gamma_0=f_0^*R_0^*\kappa_0, +\] +because $R_0f_0=f_0$. Pullback by a rational homomorphism preserves +simultaneous rational Lefschetz classes, so the same is true of +$\gamma_0$. Its complementary traces are therefore one common +rational intersection number, proving the second alternative and +the proposition. +\end{proof} diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/05_reduction.tex b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/05_reduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..4249a3e196a9976f09db766ebce44b458bd663c0 --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/build/sections/05_reduction.tex @@ -0,0 +1,448 @@ +\section{CM reduction and consequences} +\label{sec:reduction} + +The remaining step in the main proof is to express CM Hodge classes +as pullbacks of balanced Weil classes. Together with CM transport +and Proposition~\ref{prop:weil}, this will prove +Theorem~\ref{thm:main}. We then derive two specialization consequences. + +\subsection{CM classes as pullbacks of Weil classes} + +We give the CM reduction in the form needed here. The stronger +reduction to classes on abelian varieties of split Weil type is due to +Deligne and Andr\'e \cite{Andre1992}; see the reconstruction in +\cite[Theorem~1 and Section~4]{Milne2020}. Only balanced signatures +and a compatible polarization are needed for our application, and +we prove this form directly using rational idempotents on powers. + +\begin{lemma}[CM reduction] +\label{lem:cm-reduction} +Let $A/\Qbar$ be an abelian variety of CM type with good reduction at $w$, +and let $r>0$. For every rational Hodge class +$\gamma\in H^{2r}(A(\C),\Q(r))$, there are finitely many abelian varieties +$B_i/\Qbar$ with good reduction at $w$, rational homomorphisms +$f_i\colon A\to B_i$, and rational Weil classes +$\eta_i\in H^{2r}(B_i(\C),\Q(r))$ such that +\begin{equation} +\label{eq:cm-pullback-decomposition} + \gamma=\sum_i f_i^*\eta_i. +\end{equation} +Each $B_i$ has an action of a CM field $K$ for which $H_1(B_i(\C),\Q)$ +has rank $2r$ over $K$, the Hodge signatures are $(r,r)$ at every +embedding of $K$, and a polarization induces complex conjugation on $K$. +The equality specializes simultaneously in all the realizations used in +Theorem~\ref{thm:main}. +\end{lemma} + +\begin{proof} +We first identify the eigenspace components that can support a rational +Hodge class. For each such component we construct a balanced abelian +factor of a power of $A$, whose Weil classes pull back onto that +component. Taking the sum of these rational pullback spaces will then +give the decomposition over $\Q$. + +\medskip\noindent +\emph{Balanced eigenspace components.} +Set $V=H_1(A(\C),\Q)$. We work throughout up to isogeny. There is a +CM algebra $E'$, a product of CM fields, acting on $A$ such that $V$ is +free of rank one over $E'$. To obtain it, decompose $A$ up to isogeny +into simple CM factors and take the product of their CM fields, with a +separate label for each repeated factor. Transporting this action back +along an isogeny gives the asserted action on $A$ itself. + +Choose a finite Galois CM field $K\subset\Qbar$ containing the images of +all the factors of $E'$, and put $S=\Hom_{\Q\text{-alg}}(E',K)$. Then +\[ + V_K:=V\otimes_{\Q}K=\bigoplus_{\rho\in S}V_\rho, + \qquad \dim_K V_\rho=1. +\] +The Hodge decomposition is diagonal for this decomposition after +extension to $\C$. We suppress the common Tate twist in the following +linear-algebra calculations. Alternating forms of degree $2r$ decompose +as +\[ + \bigwedge^{2r}V_K^* + =\bigoplus_{\substack{\Delta\subset S\\ |\Delta|=2r}}L_\Delta, + \qquad + L_\Delta= + \bigwedge^{2r}\left(\bigoplus_{\rho\in\Delta}V_\rho\right)^*, +\] +where each form on the right is extended by zero on the other summands. +Every $L_\Delta$ is one-dimensional and has a definite Hodge type. + +Suppose the component of $\gamma$ in $L_\Delta$ is nonzero. Since +$\gamma$ is rational, its component in $L_{\sigma\Delta}$ is the +semilinear conjugate of that component and is nonzero for every +$\sigma\in\Gal(K/\Q)$. The Hodge condition therefore implies that +every $\sigma\Delta$ contains $r$ lines of each of the two Hodge types. +We call such a subset balanced under all conjugates. + +\medskip\noindent +\emph{An abelian factor with balanced signatures.} +Fix one of these subsets $\Delta$. Form the abelian variety +$A\otimes_{\Q}K$ in the category up to isogeny: it is a power of $A$ +whose index space is the underlying rational vector space of $K$. +The regular action of $K$ on this index space is an action by rational +endomorphisms of the power. Its rational homology is +\[ + T=V\otimes_{\Q}K,\qquad + \dim_\Q T=[K:\Q]\dim_\Q V. +\] +In contrast with the coefficient space $V_K$, we regard $T$ here as a +$\Q$-vector space, with $K$ acting on its second factor. The abelian +variety remains over $\Qbar$. The actions on the two factors give +an action of the rational algebra +\[ + E'\otimes_{\Q}K\simeq\prod_{\rho\in S}K, + \qquad e\otimes k\longmapsto\bigl(\rho(e)k\bigr)_{\rho\in S}. +\] +Let $e_\Delta$ be the idempotent with coordinates $1$ on $\Delta$ and +$0$ elsewhere. It is a rational endomorphism of $A\otimes_{\Q}K$, +so its image is an abelian variety $B_\Delta$ up to isogeny. In +particular no Galois invariance of $\Delta$ is required for this +construction. Write +\[ + U=H_1(B_\Delta(\C),\Q)=e_\Delta T. +\] +The index-field action of $K$ preserves $U$. + +Now extend the coefficients of $U$ to $K$, and use the fixed inclusion +$K\subset\C$ to identify the embeddings of $K$ with $\Gal(K/\Q)$. +Evaluation of the index factor at $\tau$ identifies its eigenspace in +$T\otimes_\Q K$ with $V_K$. In that eigenspace the idempotent retains +exactly the summands indexed by $\tau\Delta$. Thus +\begin{equation} +\label{eq:cm-embedding-summand} + U_\tau=\bigoplus_{\rho\in\Delta}V_{\tau\rho}, +\end{equation} +and the same description holds after extension to $\C$. Explicitly, +evaluation of the idempotent at the pair of embeddings $(\xi,\tau)$ is $1$ exactly +when $\xi=\tau\rho$ for some $\rho\in\Delta$. Thus +$\dim_K U_\tau=2r$ for every $\tau$. Since $K$ is Galois and +$\Delta$ is balanced under all conjugates, each $U_\tau$ has $r$ lines +of each Hodge type. Consequently $U$ has rank $2r$ over $K$, +$\dim B_\Delta=r[K:\Q]$, and the required Hodge signatures are +$(r,r)$. + +\medskip\noindent +\emph{A compatible polarization.} +Let $\psi$ be a +rational polarization form on $V$, and equip the index space $K$ with +the positive definite rational symmetric form +\[ + t(k,l)=\Tr_{K/\Q}(k\bar l). +\] +The form $\Psi=\psi\otimes t$ is a rational polarization form on the +power $A\otimes_{\Q}K$: its alternating and Hodge properties follow +from those of $\psi$, and its positivity follows by tensoring the +positive symmetric form associated to $\psi$ with $t$. A positive +integral multiple gives an actual polarization. For $a\in K$, +\[ + t(ak,l)=t(k,\bar a l), +\] +so the Rosati involution of $\Psi$ induces conjugation on the +index-field action. Restrict $\Psi$ to $B_\Delta$. This is again a +polarization, and because $U$ is $K$-stable its adjoint identity still +induces conjugation on $K$. This restriction does not require +$e_\Delta$ to be self-adjoint. + +\medskip\noindent +\emph{Pullback and descent of the rational span.} +The factor $B_\Delta$ now has the field action, balanced signatures, +and polarization needed to define its Weil classes. The rational +homomorphism $f_\Delta\colon A\to B_\Delta$ defined on +homology by +\[ + v\longmapsto e_\Delta(v\otimes 1) +\] +has the needed effect on Weil classes. After splitting coefficients, +its component at the identity embedding of $K$ is the projection +\[ + \bigoplus_{\rho\in S}V_\rho + \longrightarrow + \bigoplus_{\rho\in\Delta}V_\rho. +\] +Thus pullback maps $\bigwedge^{2r}U_{\id}^*$ isomorphically onto +$L_\Delta$. More generally the component indexed by $\tau$ pulls back +onto $L_{\tau\Delta}$. The rational Weil-class space $W_K^r(B_\Delta)$ +is characterized, with the twist restored, by +\[ + W_K^r(B_\Delta)\otimes_{\Q}K + =\bigoplus_{\tau:K\hookrightarrow K} + \bigwedge^{2r}U_\tau^*(r). +\] +In particular $f_\Delta^*W_K^r(B_\Delta)$ is a rational subspace whose +extension to $K$ contains $L_\Delta(r)$. + +Take the sum of these rational pullback spaces over the finitely many +subsets supporting $\gamma$. Its scalar extension contains every +component of $\gamma$, and therefore contains $\gamma$ itself. Since +extension of scalars is injective on the quotient by a rational +subspace, the sum already contains $\gamma$ over $\Q$. This proves +\eqref{eq:cm-pullback-decomposition} with rational Weil classes. Notice +that an individual embedding component need not descend to $\Q$; +only the entire Weil-class space and its pullback are used in this +descent argument. + +\medskip\noindent +\emph{Good reduction and specialization.} +All the constructions use finitely many rational endomorphisms of +powers of $A$ and their images. They therefore exist over $\Qbar$ and +descend, together with the maps, to a common number field after a finite +extension. Choose that extension so that $A$ has good reduction at the +place specified by $w$. For any $\ell\ne p$, the rational Tate module +of $B_\Delta$ is a Galois-stable direct summand of the rational Tate +module of the power of $A$. It is unramified at this place. The +N\'eron--Ogg--Shafarevich criterion gives good reduction of +$B_\Delta$ there; it also shows that the isogenies used in the +construction do not affect this conclusion +\cite[Chapter~IV, Theorem~3.5]{MilneAVNotes}. Rational homomorphisms between +the resulting good-reduction varieties specialize after clearing +denominators. The equality of rational Hodge classes +\eqref{eq:cm-pullback-decomposition} is respected by their compatible +realizations and by specialization, with the same rational coefficients +in every component. This proves the last assertion. +\end{proof} + +\begin{corollary} +\label{cor:cm-pairing} +The Lefschetz pairing property holds for the specialization of every +rational Hodge class on a CM abelian variety over $\Qbar$ with good +reduction at $w$. +\end{corollary} + +\begin{proof} +In codimension zero the class is a rational multiple of the unit, so +the assertion follows from the compatibility of divisor intersection +numbers with the normalized traces. In positive codimension use +Lemma~\ref{lem:cm-reduction}. Proposition~\ref{prop:weil} gives the +Lefschetz pairing property for the specialization of each $\eta_i$. +Lemma~\ref{lem:pairing-functorial} preserves this property under +rational pullback and rational linear combinations. Applying it to +\eqref{eq:cm-pullback-decomposition} proves the assertion. +\end{proof} + +\subsection{Proof of the main theorem} + +\begin{proof}[Proof of Theorem~\ref{thm:main}] +The case \(r=0\) follows from divisor intersection numbers as in the +preceding corollary. This includes \(\dim A=0\), where the abelian +variety is a point. If \(r=\dim A\), a rational top class is a +rational multiple of the point class; its normalized trace is +preserved by specialization, and the complementary product is \(1\). +We may therefore assume \(00$, take $q$ times the +point class, where $q\in\Q$ is the normalized trace of $\gamma$. +The point class belongs to $\mathcal R^d(A_0)$ +\cite[\S2.3]{Milne2009}, and its normalized trace is one. Compatibility +of traces with specialization gives the required components in these +cases. + +Suppose now that $00\) such that \(h=Nb\) is an actual +homomorphism \(A_0\to B_0\). Pullback by \(h\) preserves the theory +by axiom \textup{(R1)} of \cite[Definition~2.1]{Milne2009}. Since +\(\mathcal R^r(A_0)\) is a \(\Q\)-vector space, we may set +\[ + \rho_\gamma=N^{-2r}h^*\rho_\kappa\in\mathcal R^r(A_0). +\] +Functoriality of the component maps and +\eqref{eq:rational-pullback} give +\begin{align*} + (\rho_\gamma)_\ell + &=N^{-2r}h^*\kappa_{0,\ell} + =b^*\kappa_{0,\ell}=\gamma_{0,\ell} + &&(\ell\ne p),\\ + (\rho_\gamma)_p\otimes1 + &=N^{-2r}h^*\kappa_{0,p} + =b^*\kappa_{0,p}=\gamma_{0,p}. +\end{align*} +The second line is taken after extension from $\Kzero$ to $\Cw$. +Pullback in \textup{(R1)} applies to any homomorphism $h$, and rational +scalar multiplication allows any denominator $N$. Thus the argument +requires neither an isogeny nor separability, and remains valid when +$p\mid N$, including at $p=2$. + +Finally, two classes with the required components have the same +\(\ell\)-adic component for any one \(\ell\ne p\). Injectivity of +that component map by \textup{(R4)} makes them equal. Thus the class +is unique in the fixed theory, independently of the auxiliary choices. +\end{proof} + +This cohomological membership statement alone gives no algebraic cycle +and proves neither the Hodge nor the Tate conjecture. The construction +takes place at the fixed +reduction place: its CM auxiliary may have dimension $n\dim A$, and +the map $b$ is between special fibers. It supplies no same-dimensional +CM lift or map between the generic fibers. + +\subsection{Algebraicity after good reduction} + +The CM Hodge theorem \cite[Theorem~1.1]{OpenAICMHodge2026}, combined +with our CM transport, strengthens the preceding specialization +statement. It is an additional input to the following consequence, +not to the proof of Theorem~\ref{thm:main}. + +\begin{corollary}[Algebraic specialization of rational Hodge classes] +\label{cor:algebraic-specialization} +Fix the prime and place as in Theorem~\ref{thm:main}. Let +\(A/\Qbar\) be an abelian variety of dimension \(d\) with good +reduction \(A_0/\F\) at \(w\), and let +\(\gamma\in H^{2r}(A(\C),\Q(r))\) be a rational Hodge class, +where \(0\leq r\leq d\). There is one rational algebraic cycle +\(z_\gamma\in\operatorname{CH}^r(A_0)_{\Q}\) such that +\[ + \operatorname{cl}_\ell(z_\gamma)=\gamma_{0,\ell} + \quad(\ell\ne p),\qquad + \operatorname{cl}_{\mathrm{cris}}(z_\gamma)\otimes1=\gamma_{0,p}. +\] +The crystalline equality is in +\[ + H^{2r}_{\mathrm{cris}}(A_0/W(\F))[1/p](r) + \otimes_{\Kzero}\Cw. +\] +This holds for every prime \(p\), including \(p=2\). +Consequently, for every +\(y\in\operatorname{CH}^{d-r}(A_0)_{\Q}\), the traces of +\(\gamma_{0,\ell}\operatorname{cl}_\ell(y)\) for \(\ell\ne p\) +and of \(\gamma_{0,p}\operatorname{cl}_{\mathrm{cris}}(y)\) +are all the same rational number \(\deg(z_\gamma\cdot y)\). +\end{corollary} + +\begin{proof} +In codimension zero or top codimension, use the corresponding rational +multiple of the unit or the point class, as in the preceding proof. +This includes dimension zero. For $00\) with \(h=Nb\) an actual homomorphism +\(A_0\to B_0\), and put +\[ + z_\gamma=N^{-2r}h^*Z_0\in\operatorname{CH}^r(A_0)_{\Q}. +\] +Here \(h^*\) is the Chow pullback between smooth varieties, defined +by the graph and refined intersection; it requires neither flatness +nor separability of \(h\). Functoriality of cycle classes and +\eqref{eq:rational-pullback} give the required equalities. Rational +coefficients permit this denominator even if \(p\mid N\); the +crystalline realization has already inverted \(p\). Finally, +compatibility of cycle classes with products and normalized traces +gives the asserted intersection number for every \(y\). +\end{proof} + +This conclusion concerns only the special fiber at the fixed place. +It neither asserts the Hodge conjecture for arbitrary abelian varieties +in characteristic zero nor lifts \(z_\gamma\) to the original +generic fiber. The representing cycle is not asserted to be unique +modulo rational equivalence, and no comparison between different +reduction places is made. diff --git a/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/paper.pdf b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..c35db431b2fdf9cf4b6c062caafed996e27acc6a --- /dev/null +++ b/preprints/Milnes-rationality-conjecture-for-abelian-varieties-October-7-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:640701a0ea8d8026d2f019e571e052f2d106cad3f5216cf6f7fca0d643873234 +size 595267 diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/README.md b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5d0e2e1835ed39cf6d237491809779d68ceb1a8e --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [Numerical semiampleness of nef adjoint classes on compact Kähler manifolds](numerical-generalized-abundance.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026, + author = {{OpenAI}}, + title = {{Numerical semiampleness of nef adjoint classes on compact K{\"a}hler manifolds}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/numerical-generalized-abundance.pdf}{OAI:Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version states the Iitaka, model, and contraction inputs used in the divisorial-decomposition argument explicitly; see the [previous version](../Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-4-2026/numerical-generalized-abundance.pdf). diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/companions.bib b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/companions.bib new file mode 100644 index 0000000000000000000000000000000000000000..f38c42fe951d69d96d6bed9b4309298d3ae03286 --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/companions.bib @@ -0,0 +1,41 @@ +@misc{K, + author = {{OpenAI}}, + title = {{Log abundance for compact K{\"a}hler spaces under logarithmic Iitaka subadditivity}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026/main.pdf}{OAI:Log-abundance-for-compact-Kahler-spaces-under-logarithmic-Iitaka-subadditivity-October-6-2026}}, + year = {2026}, + note = {Theorem 2.13, Lemma 3.6, Proposition 3.8, Proposition 3.30, and Theorem 3.55} +} + +@misc{LI, + author = {{OpenAI}}, + title = {{Orbifold and logarithmic Iitaka subadditivity}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Orbifold-and-logarithmic-Iitaka-subadditivity-September-26-2026/paper.pdf}{OAI:Orbifold-and-logarithmic-Iitaka-subadditivity-September-26-2026}}, + year = {2026}, + note = {Corollary 6.2; Lemmas 4.1 and 4.3 and Proposition 4.5} +} + +@misc{P, + author = {{OpenAI}}, + title = {{Numerical Semiampleness of Nef Adjoint Divisors}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Numerical-Semiampleness-of-Nef-Adjoint-Divisors-October-3-2026/paper.pdf}{OAI:Numerical-Semiampleness-of-Nef-Adjoint-Divisors-October-3-2026}}, + year = {2026} +} + +@misc{MM, + author = {{OpenAI}}, + title = {{Minimal models and Mori fibre spaces for generalized log canonical $\mathbb{Q}$-pairs}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Minimal-models-and-Mori-fibre-spaces-for-generalized-log-canonical-Q-pairs-September-24-2026/paper.pdf}{OAI:Minimal-models-and-Mori-fibre-spaces-for-generalized-log-canonical-Q-pairs-September-24-2026}}, + year = {2026} +} + +@misc{LA, + author = {{OpenAI}}, + title = {{Log abundance in characteristic zero}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Log-abundance-in-characteristic-zero-September-24-2026/paper.pdf}{OAI:Log-abundance-in-characteristic-zero-September-24-2026}}, + year = {2026} +} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/figures/zero-two-diagonals.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/figures/zero-two-diagonals.tex new file mode 100644 index 0000000000000000000000000000000000000000..92f8230f6cca83baff1b0e43af240aac8e9de4c7 --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/figures/zero-two-diagonals.tex @@ -0,0 +1,42 @@ +\begin{minipage}[c]{0.47\linewidth} +\centering +\small +\begin{tikzpicture}[>=stealth, baseline=(current bounding box.center)] +\node (v) at (0,1.5) {$V$}; +\node (b) at (2.7,1.5) {$B$}; +\node (v0) at (0,0) {$\mathcal V_0$}; +\node (zz) at (2.7,0) {$Z\times Z$}; +\draw[->] (v)--node[above] {$\subset$} (b); +\draw[->] (v0)--node[above] {$\subset$} (zz); +\draw[->] (v)--node[left] {$b|_V$} (v0); +\draw[->] (b)--node[right] {$b$} (zz); +\end{tikzpicture} +\[ + \begin{gathered} + V_z=\operatorname{Bl}_xX,\\ + (V\cap E)_z=\mathbb P(T_z^*D_\lambda) + \subset E_z=\mathbb P(T_z^*Z). + \end{gathered} +\] +\end{minipage} +\hfill +\begin{minipage}[c]{0.50\linewidth} +\centering +\small +\begin{tikzpicture}[>=stealth, baseline=(current bounding box.center)] +\node (ep) at (0,1.5) {$E^+$}; +\node (e) at (3,1.5) {$E=\mathbb P_Z(\Omega_Z)$}; +\node (zp) at (0,0) {$Z^+$}; +\node (z) at (3,0) {$Z$}; +\draw[->] (ep)--(e); +\draw[->] (ep)--(zp); +\draw[->] (e)--(z); +\draw[->] (zp)--node[below] {$p_+=\operatorname{Bl}_{U_0}$} (z); +\end{tikzpicture} +\[ + \begin{gathered} + J_+=p_+^{-1}(U_0),\qquad U_0=X\times\mathbb P^1,\\ + \mathcal J=(\mathcal I_V\cdot\cO_E)\cdot\cO_{E^+}. + \end{gathered} +\] +\end{minipage} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/literature.bib b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/literature.bib new file mode 100644 index 0000000000000000000000000000000000000000..d86e044fc6b3a77fd40ae5bfe0ffc510f588860a --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/literature.bib @@ -0,0 +1,536 @@ + +@article{Boucksom2004, + author = {Boucksom, S{\'e}bastien}, + title = {Divisorial {Zariski} decompositions on compact complex manifolds}, + journal = {Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series = {4}, + volume = {37}, + number = {1}, + year = {2004}, + pages = {45--76}, + doi = {10.1016/j.ansens.2003.04.002}, + url = {https://numdam.org/articles/10.1016/j.ansens.2003.04.002/} +} + +@article{DemaillyPaun2004, + author = {Demailly, Jean-Pierre and P{\u a}un, Mihai}, + title = {Numerical characterization of the {K{\"a}hler} cone of a compact {K{\"a}hler} manifold}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {159}, + number = {3}, + year = {2004}, + pages = {1247--1274}, + doi = {10.4007/annals.2004.159.1247}, + url = {https://annals.math.princeton.edu/2004/159-3/p05} +} + +@misc{Ou, + author = {Ou, Wenhao}, + title = {A characterization of uniruled compact {K{\"a}hler} manifolds}, + year = {2025}, + eprint = {2501.18088}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {arXiv:2501.18088v1}, + url = {https://arxiv.org/abs/2501.18088v1} +} + +@misc{Vu2023, + author = {Vu, Duc-Viet}, + title = {Derivative of volumes of big cohomology classes}, + year = {2023}, + eprint = {2307.15909}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {arXiv:2307.15909v1}, + url = {https://arxiv.org/abs/2307.15909v1} +} + +@article{CollinsTosatti2018, + author = {Collins, Tristan C. and Tosatti, Valentino}, + title = {Restricted volumes on {K{\"a}hler} manifolds}, + journal = {Annales de la Facult{\'e} des sciences de Toulouse: Math{\'e}matiques}, + series = {6}, + volume = {31}, + number = {3}, + year = {2022}, + pages = {907--947}, + doi = {10.5802/afst.1708}, + eprint = {1608.07089}, + archivePrefix = {arXiv}, + url = {https://www.numdam.org/articles/10.5802/afst.1708/} +} + +@article{LevyGRR, + author = {Levy, Roni N.}, + title = {The {Riemann--Roch} theorem for complex spaces}, + journal = {Acta Mathematica}, + volume = {158}, + year = {1987}, + pages = {149--188}, + doi = {10.1007/BF02392258}, + url = {https://link.springer.com/article/10.1007/BF02392258} +} + +@article{BDPP, + author = {Boucksom, S{\'e}bastien and Demailly, Jean-Pierre and P{\u a}un, Mihai and Peternell, Thomas}, + title = {The pseudo-effective cone of a compact {K{\"a}hler} manifold and varieties of negative {Kodaira} dimension}, + journal = {Journal of Algebraic Geometry}, + volume = {22}, + number = {2}, + year = {2013}, + pages = {201--248}, + doi = {10.1090/S1056-3911-2012-00574-8}, + eprint = {math/0405285}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0405285} +} + +@article{Fujiki1978, + author = {Fujiki, Akira}, + title = {Closedness of the {Douady} spaces of compact {K{\"a}hler} spaces}, + journal = {Publications of the Research Institute for Mathematical Sciences}, + volume = {14}, + number = {1}, + year = {1978}, + pages = {1--52}, + doi = {10.2977/prims/1195189279}, + url = {https://ems.press/journals/prims/articles/2878} +} + +@article{Fujiki, + author = {Fujiki, Akira}, + title = {On the {Douady} space of a compact complex space in the category {$\mathcal C$}}, + journal = {Nagoya Mathematical Journal}, + volume = {85}, + year = {1982}, + pages = {189--211}, + doi = {10.1017/S002776300001970X}, + url = {https://www.cambridge.org/core/journals/nagoya-mathematical-journal/article/B337182621A918C3F24BD75D1DA52773} +} + +@misc{HX, + author = {Hacon, Christopher and Xie, Lingyao}, + title = {On the {K{\"a}hler} {MMP} and the transcendental base-point-free theorem}, + year = {2026}, + eprint = {2607.24986}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {arXiv:2607.24986v1}, + doi = {10.48550/arXiv.2607.24986}, + url = {https://arxiv.org/abs/2607.24986v1} +} + +@article{DinhNguyen, + author = {Dinh, Tien-Cuong and Nguyen, Viet-Anh}, + title = {The mixed {Hodge--Riemann} bilinear relations for compact {K{\"a}hler} manifolds}, + journal = {Geometric and Functional Analysis}, + volume = {16}, + number = {4}, + year = {2006}, + pages = {838--849}, + doi = {10.1007/s00039-006-0572-9}, + eprint = {math/0501449}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0501449v2} +} + +@article{Tosatti2016, + author = {Tosatti, Valentino}, + title = {The {Calabi--Yau} theorem and {K{\"a}hler} currents}, + journal = {Advances in Theoretical and Mathematical Physics}, + volume = {20}, + number = {2}, + year = {2016}, + pages = {381--404}, + doi = {10.4310/ATMP.2016.v20.n2.a4}, + eprint = {1505.02124}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/1505.02124v2} +} + +@article{BEGZ2010, + author = {Boucksom, S{\'e}bastien and Eyssidieux, Philippe and Guedj, Vincent and Zeriahi, Ahmed}, + title = {{Monge--Amp{\`e}re} equations in big cohomology classes}, + journal = {Acta Mathematica}, + volume = {205}, + year = {2010}, + pages = {199--262}, + doi = {10.1007/s11511-010-0054-7}, + eprint = {0812.3674}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/0812.3674v2} +} + +@article{DemaillyRegularization1992, + author = {Demailly, Jean-Pierre}, + title = {Regularization of closed positive currents and intersection theory}, + journal = {Journal of Algebraic Geometry}, + volume = {1}, + year = {1992}, + pages = {361--409}, + url = {https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/regularization.pdf} +} + +@incollection{LiebermanCycles, + author = {Lieberman, David I.}, + title = {Compactness of the {Chow} scheme: applications to automorphisms and deformations of {K{\"a}hler} manifolds}, + booktitle = {Fonctions de plusieurs variables complexes {III}}, + editor = {Norguet, Fran{\c c}ois}, + series = {Lecture Notes in Mathematics}, + volume = {670}, + publisher = {Springer}, + year = {1978}, + pages = {140--186}, + doi = {10.1007/BFb0064399}, + url = {https://link.springer.com/chapter/10.1007/BFb0064399} +} + +@article{KebekusSchnell2021, + author = {Kebekus, Stefan and Schnell, Christian}, + title = {Extending holomorphic forms from the regular locus of a complex space to a resolution of singularities}, + journal = {Journal of the American Mathematical Society}, + volume = {34}, + number = {2}, + year = {2021}, + pages = {315--368}, + doi = {10.1090/jams/962}, + eprint = {1811.03644}, + archivePrefix = {arXiv}, + note = {Numbered citations refer to arXiv:1811.03644v4}, + url = {https://arxiv.org/abs/1811.03644v4} +} + +@article{Miyaoka1988, + author = {Miyaoka, Yoichi}, + title = {Abundance conjecture for $3$-folds: case $\nu=1$}, + journal = {Compositio Mathematica}, + volume = {68}, + number = {2}, + year = {1988}, + pages = {203--220}, + url = {https://www.numdam.org/item/CM_1988__68_2_203_0/} +} + +@article{Kawamata1992, + author = {Kawamata, Yujiro}, + title = {Abundance theorem for minimal threefolds}, + journal = {Inventiones mathematicae}, + volume = {108}, + number = {2}, + year = {1992}, + pages = {229--246}, + doi = {10.1007/BF02100604}, + url = {https://link.springer.com/article/10.1007/BF02100604} +} + +@article{KMM1994, + author = {Keel, Sean and Matsuki, Kenji and McKernan, James}, + title = {Log abundance theorem for threefolds}, + journal = {Duke Mathematical Journal}, + volume = {75}, + number = {1}, + year = {1994}, + pages = {99--119}, + url = {https://www.math.purdue.edu/people/profile/matsuki.html} +} + +@article{KMM2004, + author = {Keel, Sean and Matsuki, Kenji and McKernan, James}, + title = {Corrections to: \textquotedblleft Log abundance theorem for threefolds\textquotedblright}, + journal = {Duke Mathematical Journal}, + volume = {122}, + number = {3}, + year = {2004}, + pages = {625--630}, + url = {https://www.math.purdue.edu/people/profile/matsuki.html} +} + +@article{HoeringPeternell2016, + author = {H{\"o}ring, Andreas and Peternell, Thomas}, + title = {Minimal models for {K{\"a}hler} threefolds}, + journal = {Inventiones mathematicae}, + volume = {203}, + number = {1}, + year = {2016}, + pages = {217--264}, + doi = {10.1007/s00222-015-0592-x}, + eprint = {1304.4013}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/1304.4013v3} +} + +@article{CHP2016, + author = {Campana, Fr{\'e}d{\'e}ric and H{\"o}ring, Andreas and Peternell, Thomas}, + title = {Abundance for {K{\"a}hler} threefolds}, + journal = {Annales scientifiques de l'{\'E}cole Normale Sup{\'e}rieure}, + series = {4}, + volume = {49}, + number = {4}, + year = {2016}, + pages = {971--1025}, + doi = {10.24033/asens.2301}, + url = {https://numdam.org/articles/10.24033/asens.2301/} +} + +@misc{CHP2023, + author = {Campana, Fr{\'e}d{\'e}ric and H{\"o}ring, Andreas and Peternell, Thomas}, + title = {Erratum and addendum to the paper: {Abundance for K{\"a}hler threefolds}}, + year = {2023}, + eprint = {2304.10161}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {arXiv:2304.10161v1}, + url = {https://arxiv.org/abs/2304.10161v1} +} + +@article{DasOu2026, + author = {Das, Omprokash and Ou, Wenhao}, + title = {On the log abundance for compact {K{\"a}hler} threefolds {II}}, + journal = {Proceedings of the London Mathematical Society}, + volume = {132}, + number = {3}, + year = {2026}, + pages = {e70141}, + doi = {10.1112/plms.70141}, + eprint = {2306.00671}, + archivePrefix = {arXiv}, + note = {Numbered citations refer to arXiv:2306.00671v4}, + url = {https://arxiv.org/abs/2306.00671v4} +} + +@article{LP1, + author = {Lazi{\'c}, Vladimir and Peternell, Thomas}, + title = {On Generalised Abundance, {I}}, + journal = {Publications of the Research Institute for Mathematical Sciences}, + volume = {56}, number = {2}, year = {2020}, pages = {353--389}, + doi = {10.4171/PRIMS/56-2-3}, + eprint = {1808.00438}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/1808.00438v2} +} + +@article{LP2, + author = {Lazi{\'c}, Vladimir and Peternell, Thomas}, + title = {On Generalised Abundance, {II}}, + journal = {Peking Mathematical Journal}, + volume = {3}, number = {1}, year = {2020}, pages = {1--46}, + doi = {10.1007/s42543-019-00022-1}, + eprint = {1809.02500}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/1809.02500v4} +} + +@article{DasOu2024, + author = {Das, Omprokash and Ou, Wenhao}, + title = {On the log abundance for compact {K{\"a}hler} threefolds}, + journal = {Manuscripta Mathematica}, + volume = {173}, number = {1--2}, year = {2024}, pages = {341--404}, + doi = {10.1007/s00229-023-01467-6}, + eprint = {2201.01202}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/2201.01202v3} +} + +@misc{DHY, + author = {Das, Omprokash and Hacon, Christopher and Y{\'a}{\~n}ez, Jos{\'e} Ignacio}, + title = {{MMP} for Generalized Pairs on {K{\"a}hler} $3$-folds}, + year = {2026}, + note = {arXiv:2305.00524v3; to appear in Annali della Scuola Normale Superiore di Pisa, Classe di Scienze}, + doi = {10.2422/2036-2145.202506_004}, + eprint = {2305.00524}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/2305.00524v3} +} + +@article{Ambro, + author = {Ambro, Florin}, + title = {The moduli $b$-divisor of an lc-trivial fibration}, + journal = {Compositio Mathematica}, + volume = {141}, number = {2}, year = {2005}, pages = {385--403}, + doi = {10.1112/S0010437X04001071}, + eprint = {math/0308143}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0308143} +} + +@article{Schmid, + author = {Schmid, Wilfried}, + title = {Variation of {Hodge} structure: the singularities of the period mapping}, + journal = {Inventiones Mathematicae}, + volume = {22}, year = {1973}, pages = {211--319}, + doi = {10.1007/BF01389674} +} + +@article{CKS, + author = {Cattani, Eduardo and Kaplan, Aroldo and Schmid, Wilfried}, + title = {Degeneration of {Hodge} structures}, + journal = {Annals of Mathematics}, series = {2}, + volume = {123}, number = {3}, year = {1986}, pages = {457--535}, + doi = {10.2307/1971333}, + url = {https://annals.math.princeton.edu/1986/123-3/p02} +} + +@article{Hironaka, + author = {Hironaka, Heisuke}, + title = {Bimeromorphic smoothing of a complex-analytic space}, + journal = {Acta Mathematica Vietnamica}, + volume = {2}, year = {1977}, pages = {103--168} +} + +@article{BierstoneMilman, + author = {Bierstone, Edward and Milman, Pierre D.}, + title = {Canonical desingularization in characteristic zero by blowing up the maximum strata of a local invariant}, + journal = {Inventiones Mathematicae}, + volume = {128}, number = {2}, year = {1997}, pages = {207--302}, + doi = {10.1007/s002220050141}, + eprint = {alg-geom/9508005}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/alg-geom/9508005} +} + +@misc{BBYv2, + author = {Matsumura, Shin-ichi and Wang, Juanyong and Wu, Xiaojun and Zhang, Qimin}, + title = {{Beauville--Bogomolov--Yau} decomposition for {K{\"a}hler} generalized pairs}, + year = {2026}, + note = {arXiv:2506.23218v2, September 9, 2026}, + eprint = {2506.23218}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/2506.23218v2} +} + +@article{COP, + author = {Campana, Fr{\'e}d{\'e}ric and Oguiso, Keiji and Peternell, Thomas}, + title = {Non-algebraic hyperk{\"a}hler manifolds}, + journal = {Journal of Differential Geometry}, + volume = {85}, number = {3}, year = {2010}, pages = {397--424}, + doi = {10.4310/jdg/1292940689}, + eprint = {0804.1682}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/0804.1682} +} + +@book{SGA1, + author = {Grothendieck, Alexander and others}, + title = {Rev{\^e}tements {\'e}tales et groupe fondamental ({SGA} 1)}, + series = {Documents Math{\'e}matiques}, volume = {3}, + publisher = {Soci{\'e}t{\'e} Math{\'e}matique de France}, + address = {Paris}, year = {2003}, + note = {Updated edition of Lecture Notes in Mathematics 224 (1971); arXiv:math/0206203v2}, + eprint = {math/0206203}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0206203v2} +} + +@book{Ueno, + author = {Ueno, Kenji}, + title = {Classification Theory of Algebraic Varieties and Compact Complex Spaces}, + series = {Lecture Notes in Mathematics}, volume = {439}, + publisher = {Springer}, address = {Berlin}, year = {1975}, + doi = {10.1007/BFb0070570} +} + +@misc{DemaillyCADG, + author = {Demailly, Jean-Pierre}, + title = {Complex Analytic and Differential Geometry}, + year = {2012}, note = {Version of June 21, 2012}, + url = {https://www-fourier.univ-grenoble-alpes.fr/~demailly/manuscripts/agbook.pdf} +} + +@article{PPS, + author = {Pareschi, Giuseppe and Popa, Mihnea and Schnell, Christian}, + title = {{Hodge} modules on complex tori and generic vanishing for compact {K{\"a}hler} manifolds}, + journal = {Geometry {\&} Topology}, + volume = {21}, number = {4}, year = {2017}, pages = {2419--2460}, + doi = {10.2140/gt.2017.21.2419}, + url = {https://msp.org/gt/2017/21-4/p12.xhtml} +} + + +@incollection{Barlet, + author={Barlet, Daniel}, + title={Espace analytique r\'eduit des cycles analytiques complexes compacts d'un espace analytique complexe de dimension finie}, + booktitle={Fonctions de plusieurs variables complexes, II}, + editor={Norguet, Fran\c{c}ois}, + series={Lecture Notes in Mathematics}, volume={482}, + publisher={Springer}, address={Berlin}, year={1975}, pages={1--158}, + doi={10.1007/BFb0080243} +} + +@incollection{BarletSurvey, + author={Barlet, Daniel}, + title={How to use the cycle space in complex geometry}, + booktitle={Several Complex Variables}, + series={Mathematical Sciences Research Institute Publications}, volume={37}, + publisher={Cambridge University Press}, address={Cambridge}, + year={1999}, pages={25--42}, + url={https://library.slmath.org/books/Book37/files/barlet.pdf} +} + +@article{Grauert, + author={Grauert, Hans}, + title={Ein {Theorem} der analytischen {Garbentheorie} und die {Modulr\"aume} komplexer {Strukturen}}, + journal={Publ. Math. Inst. Hautes \'Etudes Sci.}, + volume={5}, year={1960}, pages={5--64}, + doi={10.1007/BF02684746}, + note={Correction: ibid. 16 (1963), 35--36, doi:10.1007/BF02684291} +} + +@article{HironakaFlattening, + author = {Hironaka, Heisuke}, + title = {Flattening Theorem in Complex-Analytic Geometry}, + journal = {American Journal of Mathematics}, + volume = {97}, + number = {2}, + pages = {503--547}, + year = {1975}, + doi = {10.2307/2373721} +} + +@article{BierstoneMilman2008, + author = {Bierstone, Edward and Milman, Pierre D.}, + title = {Functoriality in Resolution of Singularities}, + journal = {Publications of the Research Institute for Mathematical Sciences}, + volume = {44}, + number = {2}, + pages = {609--639}, + year = {2008}, + doi = {10.2977/PRIMS/1210167338}, + eprint = {math/0702375}, + archivePrefix = {arXiv} +} + +@misc{FujinoAnalyticBCHM, + author = {Fujino, Osamu}, + title = {Minimal model program for projective morphisms between complex analytic spaces}, + year = {2022}, + eprint = {2201.11315}, + archivePrefix = {arXiv}, + primaryClass = {math.AG}, + note = {arXiv:2201.11315v1}, + doi = {10.48550/arXiv.2201.11315}, + url = {https://arxiv.org/abs/2201.11315v1} +} + +@article{BCHM2010, + author = {Birkar, Caucher and Cascini, Paolo and Hacon, Christopher D. and McKernan, James}, + title = {Existence of minimal models for varieties of log general type}, + journal = {Journal of the American Mathematical Society}, + volume = {23}, + number = {2}, + year = {2010}, + pages = {405--468}, + doi = {10.1090/S0894-0347-09-00649-3}, + eprint = {math/0610203}, + archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/math/0610203} +} + +@article{GrauertCorrection, + author = {Grauert, Hans}, + title = {Berichtigung: {Ein Theorem der analytischen Garbentheorie und die Modulr{\"a}ume komplexer Strukturen}}, + journal = {Publications Math{\'e}matiques de l'IH{\'E}S}, + volume = {16}, year = {1963}, pages = {35--36}, + doi = {10.1007/BF02684291}, + url = {https://www.numdam.org/item/PMIHES_1963__16__35_0/} +} + +@article{Campana1981, + author = {Campana, Fr{\'e}d{\'e}ric}, + title = {Cor{\'e}duction alg{\'e}brique d'un espace analytique faiblement {K{\"a}hl{\'e}rien} compact}, + journal = {Inventiones Mathematicae}, + volume = {63}, number = {2}, year = {1981}, pages = {187--223}, + doi = {10.1007/BF01393876} +} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/main.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..a230ddda2765721e1f2265d3b53df6e4e722389d --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/main.tex @@ -0,0 +1,30 @@ +\documentclass[11pt]{article} +\input{preamble} +\title{Numerical semiampleness of nef adjoint classes\\on compact K\"ahler manifolds} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\maketitle +\begin{abstract} +Let \(X\) be a smooth connected compact K\"ahler manifold, let \(B\) be an +effective rational simple normal crossing divisor with coefficients less +than one, and let \(M\) be a nef rational holomorphic line bundle on \(X\). +If \(K_X+B\) is pseudo-effective and \(K_X+B+M\) is nef, we prove that its +first Chern class in real Bott--Chern cohomology is represented by a semiample +rational line bundle. This numerical statement allows a flat change of line +bundle; it does not assert semiampleness of the original adjoint. +\end{abstract} +\tableofcontents +\input{sections/01-introduction} +\input{sections/02-preliminaries} +\input{sections/03-descent} +\input{sections/04-adjoint} +\input{sections/05-zero} +\input{sections/06-cycles} +\input{sections/07-completion} +\begingroup +\raggedright +\bibliographystyle{plain} +\bibliography{literature,companions} +\endgroup +\end{document} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/preamble.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/preamble.tex new file mode 100644 index 0000000000000000000000000000000000000000..5bcb38d7532962e7d5613d9c781855a5dfa132f9 --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/preamble.tex @@ -0,0 +1,46 @@ +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{mathrsfs} +\usepackage{microtype} +\usepackage[margin=1.05in]{geometry} +\usepackage{enumitem} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning,calc} +\usepackage{xcolor} +\usepackage{hyperref} +\hypersetup{colorlinks=true,linkcolor=blue!45!black,citecolor=blue!45!black, + urlcolor=blue!45!black,pdftitle={Numerical semiampleness of nef adjoint classes on compact Kahler manifolds}, + pdfauthor={OpenAI}} +\newcommand{\Q}{\mathbb Q} +\newcommand{\R}{\mathbb R} +\newcommand{\C}{\mathbb C} +\newcommand{\Z}{\mathbb Z} +\newcommand{\N}{\mathbb N} +\newcommand{\PP}{\mathbb P} +\newcommand{\cO}{\mathcal O} +\newcommand{\num}{\equiv} +\newcommand{\qsim}{\sim_{\Q}} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\codim}{codim} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\vol}{vol} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\tr}{tr} +\DeclareMathOperator{\Alb}{Alb} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\newtheorem{claim}[theorem]{Claim} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{convention}[theorem]{Convention} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\numberwithin{equation}{section} +\setlist[enumerate]{leftmargin=*,itemsep=3pt} +\setlist[itemize]{leftmargin=*,itemsep=3pt} +\emergencystretch=1.2em diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/01-introduction.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..25ebe108740bef203223d1f80067759dee06bf46 --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/01-introduction.tex @@ -0,0 +1,160 @@ +\section{Introduction}\label{sec:introduction} + +A central aim of abundance theory is to recover a holomorphic map from +the positivity of an adjoint class. For an ordinary log canonical line, +the expected conclusion is semiampleness of that line itself. +Adding an arbitrary nef line introduces a different phenomenon: its +flat part need not be torsion. The natural conclusion is then numerical +semiampleness, namely the existence of a semiample line with the same +real Chern class. + +We prove this statement for smooth compact K\"ahler manifolds with a +klt boundary. A \emph{rational line bundle} is an element of +\(\Pic(X)\otimes_{\Z}\Q\). It is nef when its first Chern class belongs +to the closure of the K\"ahler cone, and pseudo-effective when that +class contains a closed positive \((1,1)\)-current. It is semiample +when a positive integral multiple is a holomorphic line bundle +generated everywhere by global sections. + +\begin{theorem}\label{thm:main} +Let \(X\) be a smooth connected compact K\"ahler manifold, let +\(B\geq0\) be a rational simple normal crossing divisor whose +coefficients are strictly less than one, and let +\(M\in\Pic(X)\otimes_{\Z}\Q\). +Assume that \(K_X+B\) is pseudo-effective, \(M\) is nef, and +\(D=K_X+B+M\) is nef. Then there is a semiample rational line bundle +\(L\) on \(X\) such that +\[ + c_1(L)=c_1(D)\quad\text{in }H^{1,1}_{\mathrm{BC}}(X,\R). +\] +\end{theorem} + +The numerical formulation is essential even on an elliptic curve: +a nontorsion degree-zero line \(M\) is nef but has no section in any +positive power, whereas its Chern class is represented by the trivial +line. Theorem~\ref{thm:main} allows exactly this change of flat part. +It keeps the nef line \(M\) on the original manifold; it is not a +statement about an arbitrary nef b-divisor on a higher model. + +\subsection{Context and the inputs to the proof} + +Lazi\'c and Peternell formulated generalized abundance for projective +klt pairs as precisely this numerical semiampleness problem +\cite[Generalised Abundance Conjecture]{LP1}. Their work relates it to ordinary abundance +and to positivity on varieties with numerically trivial canonical +class, using nef reduction and the positive part of the divisorial +Zariski decomposition \cite{LP1,LP2}. They proved the surface case and +the threefold case in which the ordinary adjoint has positive numerical +dimension \cite[Corollaries~C and~D]{LP1}. +The present proof uses the projective positive-part theorem of +\cite[Proposition~8.1]{P} as an input. Our task is to pass from that +projective statement to the analytic setting, where the nef summand +need not be represented by a divisor and a manifold may have no +nonconstant meromorphic functions. + +The compact K\"ahler minimal model program has developed alongside +these abundance questions. H\"oring and Peternell constructed minimal +models for compact K\"ahler threefolds \cite{HoeringPeternell2016}. +The threefold abundance theorems +\cite{CHP2016,CHP2023} and the log abundance theorem of Das and Ou +\cite{DasOu2024,DasOu2026} establish important cases of the ordinary problem. +Hacon and Xie's analytic cone theorem \cite{HX} supplies the rational +curve length bound. The restricted K\"ahler model constructions and +ordinary scaling in \cite[Section~3]{K} supply the detected projective +steps used here. For ordinary adjoints in arbitrary dimension, we use +that paper's divisorial decomposition theorem, with its precise +logarithmic Iitaka hypothesis supplied by \cite[Corollary~6.2]{LI}. + +These are substantial inputs. Section~\ref{sec:preliminaries} states +their precise forms, retaining the distinction between actual +rational line identities and equalities of real classes. +The proof below supplies the further arguments needed for the nef +summand. It uses Boucksom's analytic divisorial decomposition +\cite{Boucksom2004}, the compactness theory of cycle spaces +\cite{Barlet,LiebermanCycles,Fujiki}, and the geometry of compact K\"ahler +spaces of algebraic dimension zero +\cite{COP,BBYv2,Ou}. The adjoint construction on a projective base +follows the discriminant and moduli-line strategy of Ambro +\cite[Theorem~0.2]{Ambro}, using the period results of \cite{LI} +to accommodate a real polarization. + +\subsection{The stronger statement and the proof} + +For a pseudo-effective real \((1,1)\)-class \(\alpha\), denote by +\(N(\alpha)\) its divisorial negative part: the effective real divisor +whose coefficient along each prime is the least generic multiplicity +forced in positive representatives, with arbitrarily small K\"ahler +perturbations. A nef class has zero negative part. +We prove a stronger statement in which the adjoint sum need not be nef. + +The algebraic dimension \(a(T)\) is the transcendence degree of the +field of meromorphic functions on \(T\). Its algebraic reduction, +after modification, is a morphism \(h:T\to W\) to a smooth projective +variety of dimension \(a(T)\) whose meromorphic functions account for +all those on \(T\). + +\begin{theorem}\label{thm:decomposition} +Let \(T\) be a smooth connected compact K\"ahler manifold, \(B\geq0\) +a rational simple normal crossing divisor with coefficients less than +one, and \(M\) a nef rational line bundle. Suppose +\(J=K_T+B\) is pseudo-effective. There are a smooth compact K\"ahler +modification \(\mu:U\to T\), a semiample rational line \(P\) on \(U\), +and an effective rational divisor \(R\) on \(U\), such that +\[ + \mu^*(J+M)\num P+R,\qquad + R=N\bigl(c_1(\mu^*(J+M))\bigr). +\] +Here \(\num\) denotes equality of real Chern classes. +Moreover, if \(a(T)=0\), then \(c_1(M)=0\). +\end{theorem} + +We prove both assertions of Theorem~\ref{thm:decomposition} +simultaneously by induction on dimension. Projective manifolds are +covered by \cite{P}. For \(a(T)=0\), the ordinary decomposition and +the decomposition theorem for K\"ahler klt pairs of Calabi--Yau type +\cite[Corollary~1.4]{BBYv2} reduce the problem to tori and simple +spaces carrying a generically symplectic form. The simple case requires +a meromorphic nonvanishing statement for \(K_T+M\). +Section~\ref{sec:zero} develops the required extension of the +two-diagonal argument in \cite[Section~6]{K}. The new geometric input +excludes a family of correspondences sweeping \(T\times T\): such a +family would produce a nonzero holomorphic one-form on a fixed finite +cover. + +When \(00$ and $d=\dim X-\dim Y>0$. + +Flatten $f$ after a smooth modification $q:Y'\to Y$ +\cite{HironakaFlattening}. +Let $Z$ be the normalization of the main component of $X\times_Y Y'$, +and resolve it by a projective modification $r:X'\to Z$. +Write $g_0:Z\to Y'$ and $g=g_0r$. The map $g_0$ is equidimensional; +it and $g$ have connected fibers by Stein factorization and normality +of $Y'$. All these spaces admit the asserted K\"ahler models. +Write $p_0:Z\to X$ for the map to the original source, so that +$p=p_0r$ is a modification. If $Y$ is projective, the base +modifications may be chosen projective. Figure~\ref{desc:diagram} +separates the equidimensional map from the resolution above it. + +\begin{figure}[ht] +\centering +\begin{tikzpicture}[>=Stealth, every node/.style={inner sep=3pt}] +\node (Xp) at (0,1.35) {$X'$}; +\node (Z) at (2.6,1.35) {$Z$}; +\node (X) at (5.2,1.35) {$X$}; +\node (Yp) at (2.6,0) {$Y'$}; +\node (Y) at (5.2,0) {$Y$}; +\draw[->] (Xp) -- node[above] {$r$} (Z); +\draw[->] (Z) -- node[above] {$p_0$} (X); +\draw[->] (Xp) -- node[below left] {$g$} (Yp); +\draw[->] (Z) -- node[right] {$g_0$} (Yp); +\draw[->] (X) -- node[right] {$f$} (Y); +\draw[->] (Yp) -- node[below] {$q$} (Y); +\end{tikzpicture} +\caption{The flattened main component $Z$ is equidimensional over +$Y'$. A prime divisor on the resolution $X'$ whose image in $Y'$ +has codimension at least two must therefore be exceptional for $r$.} +\label{desc:diagram} +\end{figure} + +Put $\alpha=c_1(p^*M)$, choose a K\"ahler form $\omega$ on $X'$, and +choose a closed positive current $T$ representing $\alpha$. +The volume +\[ + c=\int_{X'_y}\omega^d +\] +is positive and constant on the smooth-fibration locus. Define the +closed positive $(1,1)$-current +\begin{equation}\label{desc:base-current} + S=c^{-1}g_*(T\wedge\omega^d) +\end{equation} +on $Y'$. We claim that $T=g^*S$ over that locus. +Indeed $g_*(T\wedge\omega^{d-1})$ is a closed positive current of +degree zero, hence a nonnegative constant. Its cohomology class is +the fiber intersection of $\alpha$ with $\omega^{d-1}$, which vanishes. +Thus this current is zero. In local product coordinates this says +that the vertical block of the positive matrix of measures defining +$T$ vanishes. Positivity also forces its mixed block to vanish. +Closedness then makes the horizontal coefficients independent of the +fiber coordinates. Connectedness of the fibers makes these local +currents descend, and Equation~\eqref{desc:base-current} identifies +their common descent as $S$. + +The current $S$ has local plurisubharmonic potentials, so its pullback +by the dominant map $g$ is defined on all of $X'$. +The closed order-zero current $T-g^*S$ is supported on the inverse +image of the complement of the smooth-fibration locus in $Y'$. +The support theorem for currents +\cite[Chapter~III, Corollaries~2.11 and~2.14]{DemaillyCADG} therefore gives +\begin{equation}\label{desc:vertical-difference} + T-g^*S=[D],\qquad D=\sum_E x_E E, +\end{equation} +where $D$ is a signed real divisor supported on vertical primes. +We next show that its components dominating base divisors come in +whole pullbacks. + +Fix a prime divisor $Q\subset Y'$ occurring among their images, and +let $E_1,\ldots,E_s$ be the primes of $X'$ dominating $Q$. +Let $a_i>0$ be their multiplicities in $g^*Q$, and let $x_i$ be their +coefficients in $D$. For a K\"ahler form $\eta$ on $Y'$, set +\begin{equation}\label{desc:intersection-matrix} + C_{ij}=\int_{X'}\{E_i\}\{E_j\}\,(g^*\eta)^{k-1}\omega^{d-1}. +\end{equation} +For $i\ne j$, these numbers are nonnegative. +The inverse image $g^{-1}(Q)$ is an effective Cartier divisor, hence +has pure codimension one. After a generic choice of the point in +$Q$, its fiber components all have pure dimension $d$. Distinct +primes $E_i,E_j$ have pure codimension-two intersection; if they +meet over a general point of $Q$, that intersection dominates $Q$ +and has fibers of dimension $d-1$. It therefore contributes +positively to $C_{ij}$. These dimension statements follow by +generic flatness over $Q$, excluding the smaller base images. +The graph having an edge when $C_{ij}>0$ is consequently connected. Indeed, over a general point +of $Q$ the irreducible components of the connected fiber have a +connected intersection graph. Grouping those components according +to the global prime $E_i$ containing them gives the graph above as +a quotient, which is still connected. Moreover $Ca=0$, where +$a=(a_i)$. +To see this, pair $E_i$ with $g^*Q$ and $(g^*\eta)^{k-1}\omega^{d-1}$. +Its image lies in $Q$, so the $k$ classes from the base give zero. +Components of $g^*Q$ whose images have codimension at least two give +zero separately in this pairing. + +Let $\beta$ be the Bott--Chern class of $S$. Equation~\eqref{desc:vertical-difference} gives +$\{D\}=\alpha-g^*\beta$. Pairing this identity with each +$E_i(g^*\eta)^{k-1}\omega^{d-1}$ shows that +\[ + Cx\geq0. +\] +Here the $\alpha$ term is nonnegative by nefness, and the base term +vanishes by dimension. Components of $D$ above other base divisors, +or above sets of codimension at least two, also contribute zero. +Since $a$ has strictly positive entries and $a^{\mathsf t}Cx=0$, +we obtain $Cx=0$. The kernel is precisely $\R a$: indeed +\[ + x^{\mathsf t}Cx + =-\sum_{i0$ is the multiplicity of that prime in $f^*Q$. +The disk lies in $X$, so the character of $F$ is trivial on its +boundary. Hence $\chi$ has finite order dividing $a_Q$ on the base +meridian. There are finitely many such $Q$. A common power of +$\chi$ kills all their meridians and therefore factors through +$\pi_1(Y)$; subsets of complex codimension at least two add no +obstruction. The resulting unitary flat line on $Y$ has zero real +Chern class, and another power removes any torsion in its integral +Chern class. It then belongs to $\Pic^0(Y)$. + +The resulting characters agree after pullback on $X^\circ$. +Since $\pi_1(X^\circ)\to\pi_1(X)$ is surjective, they agree on $X$ +as well. Dividing by the powers taken in the argument proves the +asserted identity in $\Pic(X)\otimes\Q$. +\end{proof} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/04-adjoint.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/04-adjoint.tex new file mode 100644 index 0000000000000000000000000000000000000000..2132e8e0960e552fd39c6b16bb4410decdc0a5d4 --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/04-adjoint.tex @@ -0,0 +1,459 @@ +\section{An ordinary adjoint on the projective base} +\label{sec:adjoint} + +The induction will produce a morphism to a projective variety for which an +ordinary adjoint is pulled back from the base. To apply the projective +numerical-semiampleness theorem, we must realize the line downstairs as an +ordinary klt adjoint. The following proposition provides this realization. +The total space need not be projective. + +\begin{proposition}[An adjoint on the base] +\label{adj:base} +Let $(Y,D)$ be an effective klt pair with rational boundary on a normal +compact K\"ahler space. Let $f:Y\to Z$ be a surjective morphism with connected +fibers to a normal projective variety, and suppose that +$\dim Y>\dim Z$. If $H$ is a rational Cartier line bundle on $Z$ and +\begin{equation} +\label{adj:initial} + K_Y+D\qsim f^*H, +\end{equation} +then there is an effective rational divisor $D_Z$ such that $(Z,D_Z)$ is klt +and +\[ + H\qsim K_Z+D_Z. +\] +\end{proposition} + +Ambro proves the corresponding statement for projective total spaces +\cite[Theorem~0.2]{Ambro}. We follow the same separation into a discriminant +and a Hodge-theoretic moduli line. The two points requiring attention here +are the real, possibly irrational polarization of a K\"ahler family and the +construction of its cyclic cover without a meromorphic frame of $K_Y$. +The period results recalled next address the first point; we give the cover +and the required infinitesimal calculation explicitly. + +\subsection{The period input and the discriminant} + +For a pure variation of Hodge structures on a smooth open set, the +\emph{line period map} of a rank-one highest Hodge piece is the map to the +projective space of the flat vector space that records this line in a local +flat trivialization. Its generic differential rank is independent of the +trivialization. The full period map records the entire Hodge filtration. +For quasi-unipotent boundary monodromy, the \emph{parabolic extension} of the +line is the rational line bundle obtained by making the monodromy unipotent +on local finite covers, extending the highest Hodge piece, and descending +with its rational boundary weights. + +We use the following precise consequence of the period results in +\cite[Lemmas~4.1 and~4.3 and Proposition~4.5]{LI}. + +\begin{lemma}[Period quotient input] +\label{adj:period-input} +Let $S$ be a smooth projective variety and let $S^\circ\subset S$ have simple +normal crossing complement. Let $\mathbb V$ be a real-polarizable pure +variation on $S^\circ$ with an integral lattice and quasi-unipotent local +monodromy. Suppose that a complex direct summand of $\mathbb V_{\C}$, as a +variation of Hodge structures, has a rank-one highest Hodge piece, with parabolic extension $L$. Then $L$ is nef, +and its numerical dimension is the generic rank of its line period map. + +After modification $\tau:S'\to S$, there are a smooth projective variety +$Q$, a surjective morphism $p:S'\to Q$ with connected fibers, and a nef +rational line bundle $P$ on $Q$ such that +\begin{equation} +\label{adj:period-descent} + \tau^*L\qsim p^*P. +\end{equation} +Moreover, $\dim Q$ is at most the generic rank of the full period map of +$\mathbb V$. If $Q$ is a point, $\tau^*L$ is rationally trivial. +\end{lemma} + +Here the identity is in $\Pic(S')\otimes\Q$, including the boundary. +For clarity, the dimension assertion follows because the descended, +generically immersive period map on $Q$ belongs to an adjoint variation +obtained by tensor constructions from $\mathbb V$. +The rational adjoint reduction in \cite[Lemma~4.3]{LI} retains entire +rational simple factors, so its monodromy is discrete even when the +original real polarization is irrational. It also kills only finite +scalar monodromy after taking a power. Thus +\eqref{adj:period-descent} does not discard an arbitrary flat twist. +We shall need exactly this actual line identity. + +Choose a projective resolution $b:S\to Z$, and normalize the main +component of $Y\times_Z S$. Choose its log resolution functorially +with respect to local isomorphisms preserving the marked boundary; +over the open where $b$ is an isomorphism this is a functorial log +resolution of $(Y,D)$. Denote the resulting smooth compact K\"ahler +space by $X$, with maps $\pi:X\to Y$ and $g:X\to S$. +Such a resolution is available in the complex analytic category; +see \cite[Theorem~1.1 and the preceding analytic remark]{BierstoneMilman2008}. +The functorial choice will matter when we lift local flows. +Additional resolutions used to compute thresholds and fiber integrals +are auxiliary and do not replace the family whose cohomology we use. +Define the crepant rational divisor $D_X$ by +\[ + K_X+D_X=\pi^*(K_Y+D). +\] +Its exceptional coefficients may be negative; all its coefficients are +strictly less than one. For a prime divisor $Q_0$ on $S$, let +\[ + t_{Q_0}=\sup\{c\in\R:(X,D_X+c g^*Q_0) + \text{ is log canonical over the general point of }Q_0\}. +\] +The definition is unchanged on a higher crepant resolution. It gives a +positive rational number, computed by a log resolution as +\begin{equation} +\label{adj:threshold} + t_{Q_0}=\min_i\frac{1-u_i}{a_i}, +\end{equation} +where $g^*Q_0=\sum_i a_i E_i$ over its general point and $u_i$ is the +coefficient of $E_i$ in the crepant boundary there. Define +\begin{equation} +\label{adj:discriminant} + \Delta_S=\sum_{Q_0}(1-t_{Q_0})Q_0, + \qquad L_S=b^*H-K_S-\Delta_S. +\end{equation} +Only finitely many terms of $\Delta_S$ are nonzero: off a suitable proper +analytic subset the resolved pair is relatively simple normal crossing, +the map is smooth, and the threshold of a base prime is one. We may choose +$S$ with a simple normal crossing divisor containing this exceptional set +and the support of $\Delta_S$. + +The coefficients of $\Delta_S$ are strictly less than one. To prove +Proposition~\ref{adj:base}, we will show that $L_S$ has an effective rational +representative whose addition to $\Delta_S$ is sub-klt. The relevant +positivity comes from the following root construction. + +\subsection{The root cover and its highest Hodge line} + +\begin{lemma}[The root eigenline] +\label{adj:root} +In the setting of Proposition~\ref{adj:base}, there is a dense Zariski open +$S^\circ\subset S$ and a smooth proper family $h:V^\circ\to S^\circ$ obtained +from a cyclic cover and resolution, such that $R^l h_*\R$, where +$l=\dim Y-\dim Z$, is real-polarizable and has an integral lattice. +One character summand of its complexification has a rank-one highest +Hodge piece. On $S^\circ$, this line agrees, as a rational line bundle, +with $b^*H-K_S$. +\end{lemma} + +\begin{proof} +Choose an integer $m>0$ clearing all divisors and rational line identities. +A meromorphic section of the line $m b^*H$ exists because $S$ is projective. +Its pullback, under the identity +\[ + m(K_X+D_X)\simeq g^*(m b^*H), +\] +and division by the canonical meromorphic section of $mD_X$ give a +meromorphic section $\sigma$ of $K_X^{\otimes m}$. +On the open where $\sigma$ has neither zeros nor poles, take its $m$th +roots in the fibers of $K_X$. In local canonical frames this is the +equation $z^m=\sigma$; on overlaps the roots transform by the transition +functions of $K_X$. The local covers therefore glue without a +meromorphic trivialization of $K_X$, and without choosing a root of $H$. + +The Grauert--Remmert extension theorem for finite analytic covers +\cite[Exposé~XII, Proposition~5.3 and Theorem~5.4]{SGA1} extends it +normally across the divisor of $\sigma$, giving a finite cyclic cover +of $X$, possibly disconnected. It is compact K\"ahler. +Take a resolution functorial for the cyclic action and for local +isomorphisms of the pair, as in \cite[Section~1.1 and Lemma~1.1]{Ambro}. +Thus both resolutions are functorial. A local flow preserving the +original pair lifts through them once its lift to the root cover has +been chosen; we will construct that lift explicitly below. +The resulting compact manifold $V$ is K\"ahler. After deleting from $S$ the zeros and +poles of the chosen base section and the degeneration locus, the map +$h:V^\circ\to S^\circ$ is smooth and proper. We take $S^\circ$ +inside the isomorphism locus of $b$. Shrinking it further, the original +fibers of $Y\to Z$ are normal effective klt pairs and the chosen +resolutions restrict to resolutions of those pairs. + +Average a global K\"ahler class on $V$ under the cyclic group. Its +restriction is a flat real section of $R^2h_*\R$ and polarizes the +primitive pieces. Their Lefschetz decomposition supplies a flat real +polarization of the full degree-$l$ cohomology. We retain the full +cohomology local system, with lattice $R^lh_*\Z$ modulo torsion; an +irrational primitive summand is not required to carry its own lattice. +The finite group action preserves this variation and its polarization. + +Locally over the base, the tautological root, divided by a local base +volume form, gives a relative meromorphic top form $\tau$ on the cover. +It belongs to a fixed character of the cyclic group. The klt condition +makes its squared volume locally integrable, including after resolution, +so it extends holomorphically: a meromorphic top form with a divisorial +pole cannot be locally square integrable. +To see the orders directly, consider a boundary prime on the original +normal fiber with coefficient $u=p/e\in(0,1)$ in lowest terms. At a +general point the cover has local coordinate $x=y^e$, and the pulled-back +root form has order +\begin{equation} +\label{adj:root-order} + e-1-eu=e-1-p\in\{0,\ldots,e-2\}. +\end{equation} +Away from the boundary its order at a nonexceptional prime is zero. +The corresponding calculation on a crepant resolution uses coefficients +less than one and proves integrability at exceptional divisors as well. + +Suppose that $\tau'$ is another holomorphic top form of the same +character on a fiber. The ratio $\tau'/\tau$ is an invariant meromorphic +function and descends to the original normal connected fiber. +A pole along a boundary prime downstairs would pull back with order at +least $e$, whereas \eqref{adj:root-order} permits only $e-2$ zeros of +$\tau$. No such pole is possible. Away from the boundary, $\tau$ has +no divisorial zeros downstairs. Normality extends the ratio across +codimension two, and compactness makes it constant. This also handles +a disconnected cover, since the full root group acts transitively on +its components over a connected fiber. The highest Hodge piece of the +chosen character is therefore one-dimensional. + +Finally, changing a local frame of $m b^*H$ changes the root by an +$m$th root of the corresponding base factor; changing the base volume +form contributes the inverse canonical transition. Taking the $m$th tensor power removes +the finite root ambiguities. These are precisely the transitions of +$m(b^*H-K_S)$, proving the asserted identity on $S^\circ$. +\end{proof} + +\begin{lemma}[Extension across the discriminant] +\label{adj:extension} +The parabolic extension of the eigenline in Lemma~\ref{adj:root} is $L_S$ +of \eqref{adj:discriminant}. This identification persists on higher +smooth base models with simple normal crossing complement. +\end{lemma} + +\begin{proof} +Fix a general point of a prime $Q_0=(t=0)$ on $S$. We normalize the +root form by a nonvanishing local frame of $b^*H-K_S$. More explicitly, +if the meromorphic section of $m b^*H$ chosen in Lemma~\ref{adj:root} +is $a$ times a nonvanishing local frame, divide its root by $a^{1/m}$ +and by the local base volume form. This is an ordinary frame after a +finite power substitution; the finite ambiguity is precisely part of +the parabolic convention. Thus zeros or poles of the chosen meromorphic +base section do not enter the following exponent. +Tangential base coordinates may be treated as parameters. On a log resolution, +\[ + t=\prod_{i=1}^k x_i^{a_i} +\] +up to a nowhere-zero factor, and the squared absolute root form has +vertical density factors $|x_i|^{-2u_i}$. Horizontal boundary factors +are integrable because their coefficients are less than one. +The squared Hodge norm of the relative form is its fiber integral. +Writing $s_i=-\log|x_i|$, the integral is computed on slices +\[ + \sum_i a_i s_i=-\log|t| +\] +with exponential weight $\exp(-2\sum_i(1-u_i)s_i)$. +Conversion to the ordinary base area element contributes $|t|^{-2}$. +The minimum in \eqref{adj:threshold} thus gives constants $C,N>0$ such +that, on a sufficiently small punctured disk, +\begin{equation} +\label{adj:norm-power} + C^{-1}|t|^{2(t_{Q_0}-1)}(-\log|t|)^{-N} + \leq \|\tau\|^2 + \leq C|t|^{2(t_{Q_0}-1)}(-\log|t|)^N. +\end{equation} +Indeed, the slice has at most polynomial volume in $-\log|t|$, which +proves the upper estimate after factoring out the least exponential +decay. For the lower estimate take a chart along a component attaining +the minimum, away from all other vertical components, and integrate +over a fixed compact set in the remaining directions. Compactness +allows finitely many charts; the integrable horizontal factors do not +alter the power of $|t|$. + +After a local power substitution making monodromy unipotent, extending +Hodge frames and their duals have norms bounded by powers of +$-\log|t|$. These are the nilpotent-orbit estimates of +Schmid and Cattani--Kaplan--Schmid \cite{Schmid,CKS}, in the form used in +\cite[Section~4.1]{LI}. Consequently the comparison between a +frame of $b^*H-K_S$ and an extending Hodge frame has rational order +$t_{Q_0}-1$. Multiplication by $t^{1-t_{Q_0}}$, on a cover where this +power is integral, removes exactly that order. Both the corrected +comparison and its inverse have at most logarithmic growth. A +holomorphic function on a punctured disk with such growth has no pole; +applying this to the inverse excludes a zero. The same argument with +tangential parameters extends the identification across each divisor, +and normal extension treats codimension two. Thus the extending line is +\[ + b^*H-K_S+\sum_{Q_0}(t_{Q_0}-1)Q_0=L_S. +\] +For the last assertion, first make the boundary monodromies +unipotent. In canonical extending frames a local monomial pullback +$t_i=\text{unit}\cdot\prod_j s_j^{a_{ij}}$ replaces the commuting +nilpotent residues $N_i$ by $\sum_i a_{ij}N_i$, which are again +nilpotent. Both the canonical flat extension and its extending Hodge +filtration therefore pull back without an additional divisor. +Descending with rational weights incorporates the finite-monodromy +parts and gives the same conclusion for the parabolic line, including +exceptional base divisors; see \cite[Section~4]{LI}. +\end{proof} + +We have now identified the moduli line with an extreme Hodge line, so +Lemma~\ref{adj:period-input} makes it nef and gives an actual line +descent. To obtain a big line on the quotient, we must compare the +variation seen by this one line with that seen by the whole family. +Effectivity of the original boundary is decisive in this comparison. + +\subsection{The line detects the full period rank} + +\begin{lemma}[Equality of period ranks] +\label{adj:rank} +For the family of Lemma~\ref{adj:root}, the line period map of its root +eigenline and the full period map of $R^lh_*\R$ have the same generic +differential rank. +\end{lemma} + +\begin{proof} +Work in an open patch on which the ranks are constant, and let $\xi$ +be a holomorphic base vector field in the kernel of the line period +map. Choose a local frame $\tau$ of the eigenline, viewed as a +relative top form on $V^\circ$. The infinitesimal period formula says +that contraction with $\tau$ sends the Kodaira--Spencer class of $\xi$ +to zero in the fiber cohomology $H^1(\Omega^{l-1})$. + +Here is the corresponding lifting construction. Pull back the tangent +sequence to the line generated by $\xi$ and push it out along +\[ + T_{V^\circ/S^\circ}\longrightarrow + T_{V^\circ/S^\circ}\otimes K_{V^\circ/S^\circ} + \simeq\Omega^{l-1}_{V^\circ/S^\circ}, + \qquad v\longmapsto\iota_v\tau. +\] +Write $U$ for a sufficiently small Stein base patch and put +$\mathcal F=\Omega^{l-1}_{V_U/U}$. The pushed-out extension is +\[ + 0\longrightarrow\mathcal F + \longrightarrow\mathcal E + \longrightarrow\cO_{V_U}\longrightarrow0, +\] +with class in $H^1(V_U,\mathcal F)$. Shrink within the generic locus +so that $R^1h_*\mathcal F$ is locally free and coherent base change +holds. The contraction formula makes the image of this class in +$H^0(U,R^1h_*\mathcal F)$ zero. The Leray exact sequence and the +vanishing $H^1(U,h_*\mathcal F)=0$ show that +$H^1(V_U,\mathcal F)\to H^0(U,R^1h_*\mathcal F)$ is injective. +The extension class is therefore zero, and a holomorphic splitting +exists on the entire $V_U$. +Where $\tau$ is nonzero, divide the vertical part of the splitting by +$\tau$. This gives a meromorphic vector field $\widetilde\xi$ on the +resolved cover projecting to $\xi$, with poles bounded by the zero +divisor of $\tau$. Average it under the root group. Its projection +remains $\xi$, and the averaged field is invariant. + +We check this field at codimension-one points of the original normal +total space. At a boundary prime use the ramification coordinate +$x=y^e$ from \eqref{adj:root-order}. A tangential coefficient of an +invariant vector field has Laurent exponents congruent to zero modulo +$e$. Its permitted pole order is at most $e-2$, so every exponent is +nonnegative. The coefficient of $\partial/\partial y$ has exponents +congruent to one modulo $e$. Its first possible negative exponent is +$1-e$, which is again excluded. The normal coefficient is therefore +divisible by $y$. Thus the descended vector field is holomorphic and +tangent to the boundary. At a prime outside the boundary the root +form has no zero, and the conclusion is immediate. + +The resolution is an isomorphism at the codimension-one points just +used. Remaining exceptional divisors map into codimension at least +two in the original normal space. Holomorphic derivations extend +across that subset, so the descended field is holomorphic everywhere +on the family over our base patch and still projects to $\xi$. +Its local flow preserves the boundary components, their coefficients, +and the singular locus. By the functorial choice made above, the flow +first lifts to $X$ and preserves its crepant boundary $D_X$. + +This flow then lifts holomorphically to the root cover. Indeed, on the good +base patch the defining pluriform has divisor exactly the negative +multiple of the boundary. Pullback by a pair-preserving flow gives a +pluriform with the same divisor. Their ratio is a holomorphic unit on +the normal space; its $m$th root can be chosen starting at one in the +flow parameter. The root normalized at flow time zero is unique as a germ. Thus the +local cover lifts agree on overlaps of the unbranched open and glue +by normality. Functorial +resolution then lifts the flow to $V^\circ$. +Consequently the Kodaira--Spencer class of the resolved family vanishes +on $\xi$, and so does its full period differential. +The reverse kernel inclusion holds because the line is part of the +full Hodge filtration. The two kernels, and therefore the generic +ranks, are equal. +\end{proof} + +The argument is the analytic counterpart of Ambro's infinitesimal +comparison \cite[Proposition~2.1]{Ambro}. Notice exactly where it uses +$D\geq0$: the strict pole bound in \eqref{adj:root-order} is imposed at +primes of the original pair. Negative crepant exceptional coefficients +are allowed because their images have codimension at least two. + +\subsection{Replacing the moduli line by a klt boundary} + +\begin{proof}[Proof of Proposition~\ref{adj:base}] +Apply Lemma~\ref{adj:period-input} to the variation of +Lemma~\ref{adj:root}. Its monodromy is quasi-unipotent by the monodromy +theorem for this proper K\"ahler family \cite{Schmid}. Lemma~\ref{adj:extension} +identifies its parabolic line with $L_S$. Passing to the indicated +higher smooth projective model, and keeping the notation $S$, we have +\[ + L_S\qsim p^*P +\] +for a nef rational line $P$ on a smooth projective quotient $Q$. +Let $r$ be the generic rank of the line period map. Numerical dimension +of a nef line is unchanged by a surjective pullback, so +\[ + r=\nu(L_S)=\nu(P)\leq\dim Q + \leq\operatorname{rank}(d\Phi)=r, +\] +where $\Phi$ is the full period map and the last equality is +Lemma~\ref{adj:rank}. Thus $P$ is big if $\dim Q>0$. If $Q$ is a point, +$L_S$ is rationally trivial. + +Suppose first that $\dim Q>0$. By Kodaira's lemma write +$P\qsim A+E$, with $A$ ample rational and $E\geq0$ rational. For every +small positive rational $\varepsilon$, +\begin{equation} +\label{adj:small-fixed-part} + P\qsim A_\varepsilon+\varepsilon E, + \qquad A_\varepsilon=(1-\varepsilon)P+\varepsilon A + \quad\text{ample}. +\end{equation} +The pair $(S,\Delta_S)$ is sub-klt. On a fixed log resolution of +$\Delta_S+p^*E$, choose $\varepsilon$ sufficiently small that +$(S,\Delta_S+\varepsilon p^*E)$ remains sub-klt. Choose a sufficiently +large divisible integer $N$ and a general member +$G\in|N A_\varepsilon|$. The system $|Np^*A_\varepsilon|$ is +basepoint-free; on that resolution its general member meets the fixed +boundary transversely. Taking $N$ large makes its coefficient $1/N$ +less than one. Bertini therefore gives an effective rational divisor +\[ + E_S=\varepsilon p^*E+\frac1N p^*G + \qsim L_S +\] +with $(S,\Delta_S+E_S)$ sub-klt. In the point case take $E_S=0$. +In either case, +\begin{equation} +\label{adj:upstairs-presentation} + K_S+\Delta_S+E_S\qsim b^*H. +\end{equation} + +Set $D_Z=b_*(\Delta_S+E_S)$. This divisor is effective. Indeed, for +each prime of the original normal base, some component of its pullback +on $Y$ dominates it. That component has multiplicity $a\geq1$ and +boundary coefficient $u\geq0$, so its threshold is at most +$(1-u)/a\leq1$. Thus the coefficient of the discriminant at every +nonexceptional base prime is nonnegative, and $E_S$ is effective. + +Choose compatible canonical divisors and a rational Cartier divisor +representing $H$. The line identity +\eqref{adj:upstairs-presentation} gives an integer $m>0$ and a rational +function $\varphi$ in the common function field of $S$ and $Z$ such that +\[ + K_S+\Delta_S+E_S-b^*H=\frac1m\operatorname{div}_S(\varphi). +\] +Pushing down gives +\[ + K_Z+D_Z-H=\frac1m\operatorname{div}_Z(\varphi). +\] +In particular, $K_Z+D_Z$ is rational Cartier and rationally linearly +equivalent to $H$. Pulling the latter divisor equality back and +comparing with the former proves the crepant identity +\[ + K_S+\Delta_S+E_S=b^*(K_Z+D_Z). +\] +Since the pair upstairs is sub-klt, the effective pair $(Z,D_Z)$ is klt. +This proves the proposition. +\end{proof} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/05-zero.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/05-zero.tex new file mode 100644 index 0000000000000000000000000000000000000000..4e408e205d58aa47a04f3cfbfa0bcd95ac0404cb --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/05-zero.tex @@ -0,0 +1,1745 @@ +\section{Nef classes in algebraic dimension zero}\label{sec:zero} + +A semiample line bundle on a space of algebraic dimension zero is +rationally trivial. The induction therefore requires a stronger +conclusion in this case: the additional nef class must itself vanish. +The ordinary adjoint decomposition reduces this assertion to a question +about nef line bundles on simple manifolds. We first carry out that +geometric reduction. The remaining argument adapts the meromorphic +nonvanishing construction of \cite[Section~6]{K} to a line bundle that +need not be canonical. + +\begin{proposition}\label{zero:vanishing} +Let \(n\ge1\). Assume that the algebraic-dimension-zero assertion of +Theorem~\ref{thm:decomposition} holds in every dimension less than \(n\). +Let \(T\) be a smooth connected compact Kähler \(n\)-fold with +\(a(T)=0\), and let \(B\) be an effective rational simple normal crossing +boundary with coefficients less than one. If \(K_T+B\) is +pseudo-effective, then every nef rational holomorphic line bundle \(M\) +on \(T\) satisfies \(c_1(M)=0\). +\end{proposition} + +For intersections in this Section, a line bundle and its first Chern +class are distinguished when necessary by braces: \(\{H\}=c_1(H)\). +An inequality between real \((1,1)\)-classes is in pseudo-effective +order. A compact manifold is \emph{simple} if no positive-dimensional +proper compact analytic subvariety passes through a very general point. +Here, as usual, ``very general'' permits deletion of a countable union +of proper analytic subsets. + +\subsection{Reduction to a simple symplectic manifold} + +The following elementary intersection test lets us use finite covers +without requiring the nef line bundle to descend through them. + +\begin{lemma}\label{zero:mass-test} +Let \(V\) be a smooth compact Kähler \(n\)-fold, where \(n\ge1\), +and let \(\gamma\) be a nef +class, and let \(C\) be a nef and big class. If +\(\gamma\cdot C^{n-1}=0\), then \(\gamma=0\). +In particular, if \(V\) admits a generically finite surjective morphism +to a complex torus of algebraic dimension zero, every nef rational line +class on \(V\) is zero. +\end{lemma} + +\begin{proof} +Choose a Kähler class \(\omega\) and \(\varepsilon>0\) such that +\(C-\varepsilon\omega\) is pseudo-effective. When \(n\ge2\), the +identity +\[ + C^{n-1}-(\varepsilon\omega)^{n-1} + =(C-\varepsilon\omega) + \sum_{j=0}^{n-2}C^{n-2-j}(\varepsilon\omega)^j +\] +and nonnegativity of intersections of a pseudo-effective class with +nef classes give +\[ + 0=\gamma\cdot C^{n-1} + \ge \varepsilon^{n-1}\gamma\cdot\omega^{n-1}\ge0. +\] +The same conclusion is immediate when \(n=1\). A positive current in +\(\gamma\) thus has zero mass, so it vanishes. + +For the last assertion, write \(f:V\to A\) for the morphism. The +pushforward of the nef rational line class is a rational +pseudo-effective \((1,1)\)-class on \(A\). Averaging a positive current +under translations represents it by a constant semipositive form. The +kernel of a rational such form is the tangent space of a subtorus; the +induced positive integral form, after clearing denominators, polarizes +the quotient. Since \(a(A)=0\), this quotient is a point, and hence +\(f_*\gamma=0\). For a Kähler class \(\eta\) on \(A\), the class +\(C=f^*\eta\) is nef and big and +\[ + \gamma\cdot C^{n-1}=(f_*\gamma)\cdot\eta^{n-1}=0. +\] +Apply the first assertion. +\end{proof} + +\begin{lemma}\label{zero:geometric-reduction} +Under the induction hypothesis of Proposition~\ref{zero:vanishing}, +it suffices to prove the following assertion: every nef rational line +class on a smooth simple compact Kähler manifold of algebraic dimension +zero carrying a generically nondegenerate holomorphic two-form is zero. +\end{lemma} + +\begin{proof} +Apply the ordinary good divisorial decomposition to \(K_T+B\). On a +smooth modification its semiample part is rationally trivial, because +\(a(T)=0\). After the klt modification convention of +Section~\ref{sec:preliminaries}, the resulting ordinary adjoint still +equals its rational negative divisor as an actual rational line bundle. +The contraction of a known negative part +\cite[Theorem~2.13 and Proposition~3.8]{K}, with nef part zero, produces +an ordinary compact Kähler klt pair \((T_0,B_0)\) such that +\(K_{T_0}+B_0\qsim0\). + +The decomposition theorem of Matsumura--Wang--Wu--Zhang +\cite[Corollary~1.4]{BBYv2} applies to this pair: its nef b-part is zero. +A finite quasi-étale cover of \(T_0\) is a product of a rationally +connected factor, strict Calabi--Yau factors, irreducible holomorphic +symplectic factors, and a torus. Algebraic dimension is unchanged by +proper generically finite maps and by modifications. No +positive-dimensional rationally connected factor can occur, since a +Kähler resolution of such a factor is projective by algebraic +connectedness \cite{Campana1981}. A strict Calabi--Yau factor of +dimension at least three has no holomorphic two-forms. Extension of +forms for klt spaces \cite{KebekusSchnell2021} gives the same vanishing on a resolution, which is +projective by Kodaira's criterion. Such factors are also excluded. +Dimension-two factors of Calabi--Yau type are counted among the +symplectic factors. A resolution of an irreducible symplectic factor +has \(h^{2,0}=1\), generated by a generically nondegenerate form. + +Resolve the cover and the maps to \(T\) and to smooth models of all its +factors. We obtain a smooth compact Kähler manifold \(V\), with the +pulled-back nef line class \(\gamma\), mapping generically finitely to +\(T\) and to a product \(X_1\times\cdots\times X_r\). If \(r\ge2\), +let \(C\) be the pullback of a sum of Kähler classes from the factors. +For the projection omitting \(X_i\), every component of a smooth general +fiber maps generically finitely to \(X_i\). This fiber has algebraic +dimension zero and a nonzero top form, obtained by pulling back either +a torus volume form or a power of a symplectic form. Its canonical class +is therefore pseudo-effective. Its dimension is less than \(n\), so +the induction hypothesis, with zero boundary, makes the restriction of +\(\gamma\) zero. + +Expand \(C^{n-1}\). A nonzero term has top powers from all factors +except one, where precisely one power is missing. Integration over the +fibers just considered shows that its pairing with \(\gamma\) is zero. +Thus \(\gamma\cdot C^{n-1}=0\), and Lemma~\ref{zero:mass-test} gives +\(\gamma=0\). Vanishing descends to \(T\) by push--pull for a +generically finite map. A single torus factor is covered by the last +assertion of that lemma. + +It remains to consider one symplectic factor. On a smooth model \(X\) +we have \(a(X)=0\) and \(H^0(X,\Omega_X^2)=\C\sigma\), with +\(\sigma\) generically nondegenerate. There is no dominant meromorphic +fibration from \(X\) to an intermediate-dimensional compact base. +Indeed, on smooth Kähler models such a base has algebraic dimension +zero, hence is nonprojective and has a nonzero holomorphic two-form by +Kodaira's criterion. Its pullback would be a nonzero degenerate +holomorphic two-form on \(X\), which is impossible. + +The minimal-fibration theorem of Campana, in the form +\cite[Theorem~2.3(3) and Corollary~2.5(2)]{COP}, now says that \(X\) +is isotypically semi-simple. This means that \(X\) and a power +\(S^r\) of a simple manifold have a common generically finite cover; +we may take smooth Kähler models. If \(r\ge2\), repeat the preceding +product intersection argument. The smaller-dimensional fibers are +simple: simplicity is preserved by generically finite maps between +spaces of algebraic dimension zero. Indeed, a covering family of +proper subvarieties upstairs or downstairs gives such a family on the +other space by images or inverse images at points where the map is +finite; the countability of compact cycle components gives the very +general formulation. They are not uniruled, and hence +their canonical bundles are pseudo-effective by \cite[Theorem~1.1]{Ou}. +The induction hypothesis again applies. If \(r=1\), the common smooth +cover is simple and carries the pullback of \(\sigma\), a generically +nondegenerate holomorphic two-form. This is precisely the assertion +stated in the lemma. +\end{proof} + +\subsection{Finite correspondences and cotangent slopes} + +We next isolate the two geometric properties needed for the +nonvanishing argument. The first controls subvarieties of a product; +the second controls line subsheaves of cotangent tensors. + +\begin{lemma}\label{zero:no-correspondences} +Let \(X\) be a smooth simple compact Kähler manifold of algebraic +dimension zero, carrying a generically nondegenerate holomorphic +two-form. Suppose that every smooth connected compact Kähler manifold +mapping generically finitely onto \(X\) has irregularity zero. +Through a very general point of \(X^2\), the only positive-dimensional +proper irreducible compact analytic subvarieties are the two factor +slices. +\end{lemma} + +\begin{proof} +Fix a generically nondegenerate holomorphic two-form \(\sigma\) on +\(X\). A moving correspondence would produce a holomorphic one-form +on a fixed finite cover of \(X\). To see this, we identify its first projection +with a fixed finite cover over a parameter ball, and then contract the +pulled-back two-form in a direction varying the second projection. + +For a subvariety through a pair whose coordinates are very general, +simplicity makes each projection image either a point or all of \(X\). +If both projections dominate, their fibers through general points are +either zero-dimensional or the full other factor. A proper such +subvariety must therefore be a generically finite correspondence. + +Suppose these correspondences sweep \(X^2\). The compact cycle spaces +of a compact Kähler manifold have countably many compact irreducible +components \cite{LiebermanCycles}. One component must have incidence +image equal to \(X^2\). Resolve that component and the relevant +incidence component, obtaining a compact Kähler parameter space \(S\), +a smooth incidence space \(Y\), and maps +\[ + h:Y\longrightarrow S,\qquad F_1,F_2:Y\longrightarrow X. +\] +For a general parameter, the fiber is smooth and irreducible, and each +\(F_i\) restricts to a generically finite map. The map +\((F_1,h):Y\to X\times S\) is generically finite. Its normal finite +Stein factor is a finite cover of the smooth product. + +By purity, the branch locus of this cover is divisorial. Every branch +component dominating \(S\) has a proper image in \(X\): otherwise its +divisorial fibers over \(S\) would sweep \(X\), contradicting +simplicity. Compactness of \(S\) makes these images closed analytic +subsets. Remove the images in \(S\) of the remaining branch components +and take a small ball \(B\) about a general parameter. There is a fixed +proper analytic subset \(A\subset X\) such that the cover is étale +over \((X\setminus A)\times B\). Since \(B\) is simply connected, +this étale cover is pulled back from a fixed cover of \(X\setminus A\). +Normalize \(X\) in that cover. Uniqueness of normal finite extension +then identifies the cover over \(X\times B\) with the product of this +fixed normal cover and \(B\); see +\cite[Exposé~XII, Proposition~5.3 and Theorem~5.4]{SGA1}. + +Let \(\widetilde X\) be a smooth Kähler resolution of the fixed cover. +The second projection gives a meromorphic map +\(G:\widetilde X\times B\dashrightarrow X\). The pullback \(G^*\sigma\) +is a holomorphic two-form: resolve the meromorphic map and descend +holomorphic forms across a modification of a smooth space. Dominance +of \((F_1,F_2)\) implies that, at suitable general points, the +derivatives of \(G\) in the parameter directions span \(T_X\), while +the derivative along \(\widetilde X\) is an isomorphism. Choose a +constant tangent vector on \(B\) for which this parameter derivative +is nonzero at such a point. Contracting \(G^*\sigma\) with that vector +and restricting to \(\widetilde X\times\{t\}\) yields a nonzero global +holomorphic one-form on \(\widetilde X\). This contradicts the +hypothesis on irregularity. + +Each component parametrizing generically finite correspondences thus +has proper incidence image. Their countable union misses a very +general pair, proving the assertion. +\end{proof} + +\begin{lemma}\label{zero:cotangent-slope} +Let \(X\) be a smooth simple compact Kähler manifold of dimension +\(n\ge2\), algebraic dimension zero and irregularity zero, and suppose \(K_X\) is +pseudo-effective. Let \(\mathscr L\) be a holomorphic line bundle such +that \(L=c_1(\mathscr L)\ge c_1(K_X)\) in pseudo-effective order. +For every nonzero map \(\mathscr H\to\Omega_X^{\otimes k}\), where +\(\mathscr H\) is a line bundle and \(k\ge0\), +\begin{equation}\label{zero:slope-X} + c_1(\mathscr H)\le kL. +\end{equation} +For every very general \(x\in X\), write +\(a:Y=\operatorname{Bl}_xX\to X\). Every nonzero line map +\(\mathscr H_Y\to(a^*\Omega_X)^{\otimes k}\) satisfies +\begin{equation}\label{zero:slope-blowup} + c_1(\mathscr H_Y)\le ka^*L. +\end{equation} +The exceptional set of points can be chosen simultaneously for all +\(\mathscr H_Y\) and \(k\). +\end{lemma} + +\begin{proof} +We give the slope argument from \cite[Lemma~6.2]{K}, indicating why it +does not require any hypothesis about canonical sections. Let +\(\gamma\) belong to the full dual of the pseudo-effective cone. +Ou's convention calls precisely these classes movable, and +Harder--Narasimhan filtrations exist for them +\cite[Definition~4.2 and Lemma~4.3]{Ou}. If the minimum +\(\gamma\)-slope of \(\Omega_X\) were negative, the first +Harder--Narasimhan subsheaf \(\mathscr T\subset T_X\) would have +positive slope and be semistable. Tensor slope inequalities make its +bracket into \(T_X/\mathscr T\) zero, so it is a foliation. Its dual +has negative maximum slope and is non-pseudo-effective. By +\cite[Theorem~1.4, Lemmas~4.3--4.4 and Proposition~4.5]{Ou}, its leaves have +compact closures given by a meromorphic fibration. The rank of +\(\mathscr T\) is strictly less than \(\dim X\), since +\(c_1(T_X)\cdot\gamma\le0\). A general leaf closure contradicts +simplicity. + +All Harder--Narasimhan quotient slopes of \(\Omega_X\) are consequently +nonnegative, and its maximum slope is at most +\(c_1(K_X)\cdot\gamma\). Tensor slopes give +\[ + c_1(\mathscr H)\cdot\gamma + \le k c_1(K_X)\cdot\gamma\le kL\cdot\gamma. +\] +Separation by the dual cone proves \eqref{zero:slope-X}. + +Irregularity zero embeds \(\Pic(X)\) in the countable group +\(H^2(X,\Z)\). For any vector bundle on \(X\), linearly independent +global sections are generically pointwise independent: the coefficients +expressing one section in a maximal pointwise independent subfamily +are meromorphic functions, hence constants because \(a(X)=0\). +Evaluation is therefore injective outside a proper analytic subset. +Apply this simultaneously to +\(\mathscr H^{-1}\otimes\Omega_X^{\otimes k}\) for all lines +\(\mathscr H\) and all \(k\). + +For a point outside the resulting countable exceptional union, write +\(\mathscr H_Y=a^*\mathscr H\otimes\cO_Y(mF)\), where \(F\) is the +exceptional divisor. A nonzero map as in the statement extends away +from \(F\) to a section on \(X\) by Hartogs. If \(m>0\), that section +vanishes at \(x\), because \(a_*\cO_Y(-mF)=\mathcal I_x^m\), +contrary to injectivity of evaluation. Thus \(m\le0\), and +\eqref{zero:slope-X} proves \eqref{zero:slope-blowup}. +\end{proof} + +\subsection{Meromorphic nonvanishing from cotangent slope bounds} + +The next proposition extracts the line-bundle content of the +construction in \cite[Section~6]{K}. Its hypotheses deliberately separate +cotangent slopes from the identity of the chosen line bundle. This is +what permits the application to the sum of the canonical bundle and a +nef line bundle. + +\begin{proposition}\label{zero:line-nonvanishing} +Let \(X\) be a smooth simple compact Kähler manifold of dimension +\(n\ge2\), with \(a(X)=0\) and irregularity zero. Assume that the only +positive-dimensional proper compact irreducible analytic subvarieties +through a very general point of \(X^2\) are its factor slices. +Let \(\mathscr L\) be a holomorphic line bundle with pseudo-effective +class \(L\). Assume the following line-subsheaf bounds: +\begin{enumerate} +\item For every line bundle \(\mathscr H\), every integer \(k\ge0\), +and every nonzero map \(\mathscr H\to\Omega_X^{\otimes k}\), one has +\(c_1(\mathscr H)\le kL\). +\item Outside a countable union of proper analytic subsets of \(X\), +every point \(x\) has this property: if +\(a:Y=\operatorname{Bl}_xX\to X\), then for every line bundle +\(\mathscr H_Y\), every \(k\ge0\), and every nonzero map +\(\mathscr H_Y\to(a^*\Omega_X)^{\otimes k}\), one has +\(c_1(\mathscr H_Y)\le ka^*L\). +\end{enumerate} +Then some positive power of \(\mathscr L\) has a nonzero meromorphic +section. +\end{proposition} + +We prove the proposition by comparing point poles with vanishing along +a diagonal. Assume, throughout the proof, that no positive power of +\(\mathscr L\) has a nonzero meromorphic section. A normalized big class +on \(X\) has bounded pole order at a very general point. On the rank-two projective bundle over \(X^2\) formed from the two +pullbacks of \(\mathscr L\), a class of growing volume produces a +large family of symmetric cotangent tensors. +The diagonal in \(X^2\) forces a large common vanishing order in +their determinant. The slope inequalities then turn that vanishing into an +impossible point pole on \(X\). + +The proof below follows the volume and two-diagonal construction of +\cite[results~6.3--6.10]{K}. We retain its analytic estimates and give +their proofs along with the determinant calculations, so that the +chosen line bundle enters only through the hypotheses stated above. + +\subsubsection{Point pole thresholds} + +We will use several standard facts about volumes of real \((1,1)\)-classes. +Our normalization is \(\operatorname{vol}(\alpha)=\int\alpha^e\) for a nef class on an +\(e\)-fold. Volume is continuous, homogeneous, monotone in +pseudo-effective order, invariant under modification, and its \(e\)-th +root is concave on the big cone. Analytic Fujita approximation computes +it by Kähler parts on smooth projective modifications. Here a +\emph{smooth projective modification} means a projective modification +whose source is smooth; the sources used here are compact Kähler +manifolds obtained by resolving coherent analytic ideals. For a smooth +irreducible divisor \(D\) and a big class \(\alpha\), write +\(\operatorname{vol}_{\,|D}(\alpha)\) for the numerical restricted volume. +It is zero when \(D\) is contained in the non-Kähler locus +\cite[Theorem~1.1]{Vu2023}; otherwise it is +the supremum of the masses on \(D\) of restrictions of Kähler currents +with analytic singularities that are not generically singular on \(D\) +\cite[Lemma~2.7]{CollinsTosatti2018}. The divisorial derivative and its +continuity on the big cone are +\begin{equation}\label{zero:volume-derivative} + \frac{\mathrm{d}}{\mathrm{d} u}\operatorname{vol}(\alpha-u\{D\}) + =-e\,\operatorname{vol}_{\,|D}(\alpha-u\{D\}); +\end{equation} +see \cite[Theorem~1.1]{Vu2023}. We apply this formula only on smooth +manifolds while the varying class is big. + +Here is a useful precise form of the approximation in the restricted +volume formula. Resolve the log-ideal singularities of a current +restricted to \(D\). Its pullback is an effective real divisor plus a +positive residual current with locally bounded potentials. The latter +dominates a positive multiple of the pulled-back Kähler form. A current +with locally bounded potentials has zero Lelong numbers, so Demailly +regularization makes its class, after subtracting that multiple, nef +\cite[Theorem~1.1]{DemaillyRegularization1992}. +On a projective modification there is an effective exceptional divisor +whose negative is relatively ample. Subtracting a sufficiently small +multiple of this divisor from the residual class therefore makes that +class Kähler; add the same multiple to the divisor part. Round all +divisor coefficients slightly upwards to rational numbers. Openness of +the Kähler cone preserves the Kähler property. These changes can be +arbitrarily small in top intersections, which compute the original mass +by the bounded-potential product formula. Thus we may approximate a +restricted mass by +\begin{equation}\label{zero:rational-fujita} + h^*(\alpha|_D)=\beta+\{D'\},\qquad + \beta\ \text{Kähler},\quad D'\ge0\ \text{a rational divisor}. +\end{equation} +Moreover, \(D'\) has at least the log-ideal orders of the original +restriction on every further resolution. We will use this last +property to turn poles into vanishing conditions. Only \(D'\) is made +rational; the class \(\beta\) and the horizontal part of \(\alpha\) remain +real. + +\begin{lemma}[A point pole bound]\label{zero:pole-threshold} +Let \(W\) be a smooth compact Kähler manifold of dimension \(e\ge2\), +\(\alpha\) a big real \((1,1)\)-class, and \(z\in W\). Suppose a smooth +projective modification \(\mu:W'\to W\), which is an isomorphism near +\(z\), admits a decomposition +\[ + \mu^*\alpha=K+\{D\},\qquad K\ \text{Kähler},\quad D\ge0, +\] +where \(D\) misses the point \(z'\) over \(z\). If the ordinary analytic +Seshadri constant \(\epsilon(K,z')\) is at least \(\eta>0\), then, on the +blowup \(b:\widehat W=\operatorname{Bl}_zW\to W\) with exceptional divisor \(G\), +\begin{equation}\label{zero:pole-formula} + \sup\{u\ge0:b^*\alpha-u\{G\}\ge0\} + \le \frac{\eta}{2} + +2^{e-1}\operatorname{vol}(\alpha)\eta^{-(e-1)} . +\end{equation} +\end{lemma} + +\begin{proof} +Set \(u_0=\eta/2\). Blowing up \(z'\), the class +\(K-u_0\{G'\}\) is Kähler. The Fujita decomposition is unchanged near +\(G'\), so it supplies a Kähler current for +\(\alpha_{u_0}=b^*\alpha-u_0\{G\}\) that is smooth near \(G\). +Its restriction there has class \(u_0c_1(\cO_{\mathbb{P}^{e-1}}(1))\). +The restricted volume is consequently \(u_0^{e-1}\): the current gives +this lower bound, and the volume of the restricted class gives the +opposite bound. + +Let \(\tau\) denote the left side of Equation~\eqref{zero:pole-formula}. The classes +\(\alpha_u=b^*\alpha-u\{G\}\) are big for \(0\le u<\tau\), since +\(\alpha_0\) is big and the pseudo-effective cone is convex. The +concave function \(f(u)=\operatorname{vol}(\alpha_u)^{1/e}\) satisfies, by +Equation~\eqref{zero:volume-derivative}, +\[ + f'(u_0)=-\frac{u_0^{e-1}}{f(u_0)^{e-1}}. +\] +Its tangent line at \(u_0\) must remain positive up to \(\tau\). +Therefore +\[ + \tau\le u_0+\frac{f(u_0)^e}{u_0^{e-1}} + \le u_0+\frac{\operatorname{vol}(\alpha)}{u_0^{e-1}}, +\] +which is Equation~\eqref{zero:pole-formula}. +\end{proof} + +Fix a Kähler class \(\omega\) on \(X\). The class \(L\) is not big: +a big holomorphic line bundle would make \(X\) Moishezon, contrary to +\(a(X)=0\). For \(t>0\) define +\begin{equation}\label{zero:normalization} + P=r(L+t\omega),\qquad + r=\operatorname{vol}(L+t\omega)^{-1/n}. +\end{equation} +Then \(P\) is a big real class, \(\operatorname{vol}(P)=1\), \(L\le P/r\), and +\(r\to\infty\) as \(t\downarrow0\). Choose a smooth Fujita model +\(\mu:Y_P\to X\) with Kähler part \(P'\) satisfying +\begin{equation}\label{zero:P-prime} + \mu^*P=P'+\{D_P\},\qquad v:=\int_{Y_P}(P')^n>\frac12. +\end{equation} +At a very general point \(y\) of this model there is no +positive-dimensional proper subvariety: its image would be one through a +very general point of \(X\), and \(y\) avoids the exceptional locus. +The ordinary Seshadri formula for a Kähler class, +\[ + \epsilon(K,y) + =\inf_{\substack{W\ni y\\ \dim W>0}} + \left(\frac{\int_W K^{\dim W}} + {\operatorname{mult}_y W}\right)^{1/\dim W}, +\] +therefore gives \(\epsilon(P',y)=v^{1/n}\ge2^{-1/n}\). +This is the ordinary nef/Kähler formula +\cite[Theorem~2.8]{Tosatti2016}; see also +\cite[Equation~(1.5)]{CollinsTosatti2018} and the +Kähler cone criterion of \cite{DemaillyPaun2004}. We use this ordinary +formula in both applications below. Lemma~\ref{zero:pole-threshold}, with +\(\operatorname{vol}(P)=1\), now yields a constant \(C_n\) depending only on \(n\) +such that, for a very general \(x\), +\begin{equation}\label{zero:point-bound} + \tau(P,x):=\sup\{u\ge0:a^*P-u\{F\}\ge0\}\le C_n, + \qquad a:\operatorname{Bl}_xX\to X. +\end{equation} +Here and below positive constants denoted \(c_n,C_n\) may be decreased or +increased from one occurrence to the next. They are independent of all +parameters and choices of currents and modifications. + +\subsubsection{A projective bundle with controlled volume} + +We now produce a class whose volume grows, while its point pole threshold +grows much more slowly. On \(X^2\), let \(\mathscr L_i\) and \(L_i\) +denote the pullbacks of \(\mathscr L\) and \(L\) from the \(i\)-th factor. +Use the quotient convention and put +\[ + \pi:Z=\mathbb{P}_{X^2}(\mathscr L_1\oplus\mathscr L_2)\longrightarrow X^2, + \qquad \xi=c_1(\cO_Z(1)),\qquad d=\dim Z=2n+1 . +\] +Thus \(\pi_*\cO_Z(m)=\operatorname{Sym}^m(\mathscr L_1\oplus\mathscr L_2)\) for +\(m\ge0\). The zero divisor \(A_i\) of +\(\pi^*\mathscr L_i\to\cO_Z(1)\) has class \(\xi-L_i\); it is the +section on which \(\xi\) restricts to \(L_{3-i}\). In particular +\(\xi=\{A_i\}+L_i\ge0\). + +\begin{lemma}\label{zero:subvarieties} +For the projective bundle \(Z\) just defined, the only +positive-dimensional compact irreducible analytic subvarieties through +a very general point are a fiber of \(\pi\), the full inverse images of +the two factor slices, and \(Z\) itself. +\end{lemma} + +\begin{proof} +The image of such a subvariety in \(X^2\) is a point, a factor slice, +or all of \(X^2\), by the hypothesis of +Proposition~\ref{zero:line-nonvanishing}. Generic relative dimension +one gives the full inverse image. Otherwise, except for a point, the +subvariety is a multisection of the restricted projective line bundle. +On the slice or product \(S\), its divisor line is +\(\cO(k)\otimes\pi^*\mathscr H\), with \(k>0\). Its homogeneous +equation has coefficients in +\[ + H^0\bigl(S,\mathscr H\otimes + \mathscr L_1^{\otimes i}\otimes + \mathscr L_2^{\otimes(k-i)}\bigr),\qquad 0\le i\le k. +\] +A single nonzero monomial cuts out only axes and vertical divisors. +A non-axis multisection therefore has two nonzero coefficients. Their +quotient is a meromorphic section of a nonzero power of +\(\mathscr L_1\otimes\mathscr L_2^{-1}\). Restricting to a general +factor slice gives a meromorphic section of a nonzero power of +\(\mathscr L\); inversion makes the power positive if necessary. +This contradicts the standing contrary hypothesis. The axes +avoid a very general point of \(Z\), proving the lemma. +\end{proof} + +Let \(q\) tend to infinity through positive integers. For each sufficiently +large \(q\), choose \(t=t(q)\) in Equation~\eqref{zero:normalization} so that +\(r=r(q)\ge q^2\), and use the resulting normalized class \(P=P(q)\). +Define the real class and the scale +\begin{equation}\label{zero:M-definition} + M=P_1+P_2+q\xi,\qquad A_q=q^{1/d}. +\end{equation} + +The quantitative goal can now be stated. On the blowup +\(a:\operatorname{Bl}_xX\to X\) of a very general point, with exceptional +divisor \(F\), we will produce a positive rational scale \(s\) satisfying +\(c_nA_q\le s\le C_nA_q\) and +\[ + 2a^*P+(s+2q)a^*L-c_ns\{F\}\ge0. +\] +Since \(L\le P/r\), this would imply +\[ + \frac{c_ns}{2+(s+2q)/r}\le\tau(P,x)\le C_n. +\] +The denominator stays bounded because \(r\ge q^2\), while the numerator +tends to infinity. To obtain the class inequality, the first diagonal +will produce a subsheaf occupying a fixed positive fraction of a +symmetric cotangent power. An incidence construction will then force +its determinant to vanish to order proportional to \(s\). We begin +with the volume that supplies this rank fraction. + +\begin{lemma}\label{zero:two-slot-volume} +For these choices, \(M\) is big and +\begin{equation}\label{zero:M-bounds} + c_nq\le\operatorname{vol}(M)\le C_nq,\qquad + \tau(M,z):=\sup\{u\ge0:b_z^*M-u\{F_z\}\ge0\}\le C_nA_q +\end{equation} +at a very general point \(z\in Z\), where +\(b_z:\operatorname{Bl}_zZ\to Z\) has exceptional divisor \(F_z\). +\end{lemma} + +\begin{proof} +Pull \(Z\) to the Fujita model \(Y_P^2\) from +Equation~\eqref{zero:P-prime}, and put \(H=P'_1+P'_2\) on this pulled-back bundle. +There is a further smooth projective modification +\(\nu:\widehat Z\to\mathbb{P}_{Y_P^2}(\mu^*\mathscr L_1\oplus +\mu^*\mathscr L_2)\) and a Fujita decomposition of the pullback of \(M\) +whose Kähler part is exactly +\begin{equation}\label{zero:exact-K} + K=\frac12\nu^*H+\Theta , +\end{equation} +where \(\Theta\) is Kähler and has degree \(q\) on a general vertical +line. The modification and the divisor part miss that line. + +Here is the construction. It suffices to decompose \(H/2+q\xi\) as +\(\Theta\) plus an effective divisor, clean on a whole general vertical +line. Since \(\cO(1)\) is relatively ample, a small positive class of +the form \(\delta(\xi+cH)\) is Kähler for some \(c>0\). Choose +\(\delta>0\) so small that \(\delta0\) and \(C_s\) is big for +\(0\le s0 +\] +on a general fiber. For sufficiently large divisible integers \(j\), +let \(\mathcal F_j=f_*\cO_U(j\Lambda)\) and \(R_j=\operatorname{rk}\mathcal F_j\). +Here \(j\Lambda\) is an actual line bundle and +\(c_1(\mathcal F_j)\) means \(c_1(\det\mathcal F_j)\). Then +\begin{align} + R_j&=\frac{w}{e!}j^e+O(j^{e-1}),\label{zero:GRR-rank}\\ + B_0:=G+\lim_j\frac{c_1(\mathcal F_j)}{jR_j} + &=\frac{f_*\beta^{e+1}}{(e+1)w}\ge0,\label{zero:GRR-base}\\ + \int_U\beta^{b_0+e} + &\le (e+1)^{b_0}w\,\operatorname{vol}(B_0).\label{zero:mixed-bound} +\end{align} +The limit in Equation~\eqref{zero:GRR-base} is a limit of real Bott--Chern classes. +\end{lemma} + +\begin{proof} +The restriction of \(c_1(\Lambda)\) to each fiber is represented by the +restriction of the Kähler form \(\beta\). The fiberwise criterion for +relative ampleness makes \(\Lambda\) relatively ample after clearing +denominators. Relative Serre vanishing then kills the higher direct +images for all sufficiently large divisible \(j\). Analytic +Grothendieck--Riemann--Roch \cite{LevyGRR}, in degrees zero and two, gives +\[ + R_j=\frac{f_*c_1(\Lambda)^e}{e!}j^e+O(j^{e-1}),\qquad + c_1(\mathcal F_j) + =\frac{f_*c_1(\Lambda)^{e+1}}{(e+1)!}j^{e+1}+O(j^e). +\] +The degree-zero pushforward is \(w\). Expanding +\(\beta=f^*G+c_1(\Lambda)\) shows that +\[ + f_*\beta^{e+1} + =f_*c_1(\Lambda)^{e+1}+(e+1)wG, +\] +because terms with at least two horizontal factors have negative +fiber degree after pushforward. This proves the equality in +Equation~\eqref{zero:GRR-base}; the cohomological GRR equality is an equality in +Bott--Chern cohomology by the \(\partial\bar\partial\)-lemma on compact +Kähler manifolds. Pushforward of the positive form +\(\beta^{e+1}\) is a positive closed \((1,1)\)-current, so \(B_0\) is +pseudo-effective. + +Apply Lemma~\ref{zero:nef-pushforward} to choose \(p:Z'_0\to Z_0\), +\(q:U'\to U\), and \(f':U'\to Z'_0\), and put \(\beta'=q^*\beta\). +The resulting class \(B'_0\) is nef and satisfies +Equation~\eqref{zero:flattened-volume}. +Choose a Kähler class \(\omega'\) on \(Z'_0\) and put +\(C=B'_0+\varepsilon\omega'\). For \(0\le k\le b_0\), set +\[ + I_k=\int_{U'}(\beta')^{e+k}(f'^*C)^{b_0-k}. +\] +These are mixed intersections of nef classes. The first two satisfy +\[ + I_0=w\int_{Z'_0}C^{b_0},\qquad + I_1=(e+1)w\int_{Z'_0}B'_0C^{b_0-1} + \le(e+1)w\int_{Z'_0}C^{b_0}. +\] +The mixed nef inequalities make the sequence \(I_k\) log-concave. +Every \(I_k\) is positive: on the dense open where \(q\) is a local +biholomorphism and \(f'\) is a submersion, \(\beta'\) is positive +definite and \(f'^*C\) has rank \(b_0\), so the defining top form +is strictly positive. The successive ratios are therefore at most +\(I_1/I_0\le e+1\). Thus +\[ + \int_U\beta^{b_0+e}=I_{b_0} + \le(e+1)^{b_0}w\int_{Z'_0}C^{b_0}. +\] +Letting \(\varepsilon\downarrow0\) and using +Equation~\eqref{zero:flattened-volume} proves Equation~\eqref{zero:mixed-bound}. +\end{proof} + +We will also use the determinant formula without its volume bound. + +\begin{corollary}\label{zero:slope-descent} +Let \(Y\) be a smooth compact Kähler manifold and \(\mathscr E\) a +holomorphic vector bundle of rank at least two. Write +\(\pi_{\mathscr E}:\mathbb{P}_Y(\mathscr E)\to Y\) and +\(\zeta_{\mathscr E}=c_1(\cO_{\mathbb{P}(\mathscr E)}(1))\). +Suppose that a real class \(D\) on \(Y\) satisfies +\[ + c_1(\mathscr H)\le kD + \quad\text{whenever}\quad + 0\ne\bigl(\mathscr H\longrightarrow\mathscr E^{\otimes k}\bigr) +\] +for a line bundle \(\mathscr H\) and integer \(k\ge0\). +For a real class \(A\) on \(Y\) and a real number \(b\ge0\), +\begin{equation}\label{zero:slope-descent-equation} + \pi_{\mathscr E}^*A+b\zeta_{\mathscr E}\ge0 + \quad\Longrightarrow\quad A+bD\ge0 . +\end{equation} +\end{corollary} + +\begin{proof} +If \(Y\) is a point, both \(A\) and \(D\) vanish and the assertion is +immediate. Suppose \(\dim Y\ge1\). Choose a real class \(H_0\) on \(Y\) so that +\(\zeta_{\mathscr E}+\pi_{\mathscr E}^*H_0\) is Kähler; relative +ampleness of \(\cO(1)\) permits such a choice. Take numbers +\(\delta\downarrow0\) with \(b+\delta>0\) rational. Adding +\(\delta(\zeta_{\mathscr E}+\pi_{\mathscr E}^*H_0)\) to the +pseudo-effective class in Equation~\eqref{zero:slope-descent-equation} makes it +big. A Fujita decomposition on a smooth projective modification +\(h:U\to\mathbb{P}_Y(\mathscr E)\), with the divisor coefficients rounded +upwards as in Equation~\eqref{zero:rational-fujita}, has the form +\[ + \beta=f^*(A+\delta H_0)+c_1(\Lambda),\qquad + \Lambda=(b+\delta)h^*\cO(1)-\cO_U(D') + \ \text{in }\Pic(U)\otimes\Q, +\] +where \(f=\pi_{\mathscr E}h\), \(\beta\) is Kähler, and \(D'\ge0\) +is rational. For divisible \(j\), +\[ + f_*\cO_U(j\Lambda)\ \subseteq\ + \operatorname{Sym}^{j(b+\delta)}\mathscr E . +\] +Its determinant of rank \(R_j\) consequently maps into +\(\mathscr E^{\otimes j(b+\delta)R_j}\). The assumed line inequality +gives +\[ + \frac{c_1(\mathcal F_j)}{jR_j}\le(b+\delta)D. +\] +Lemma~\ref{zero:direct-image} makes +\(A+\delta H_0+\lim c_1(\mathcal F_j)/(jR_j)\) pseudo-effective. +Adding the preceding pseudo-effective difference shows that +\(A+\delta H_0+(b+\delta)D\) is pseudo-effective. Let +\(\delta\downarrow0\). This proves the corollary. In this argument +only \(b+\delta\) and the coefficients of \(D'\) are rational; \(A\), +\(H_0\), and \(D\) remain real classes. +\end{proof} + +For the forthcoming application over the \(d\)-fold \(Z\), with fibers +of dimension \(d-1\), Lemma~\ref{zero:direct-image} has a useful concrete +consequence. Once we prove \(B_0\le C_nM\), the bound +\(\operatorname{vol}(M)\le C_nq\) gives +\[ + \int_U\beta^{2d-1}\le C_nwq. +\] +Thus an upper bound for the normalized determinant class will convert +a lower bound for total mass into a lower bound for the fiber volume +\(w\). The next calculation supplies the required determinant control. + +\subsubsection{Cotangent lines on the projective bundle} + +We return to \(Z=\mathbb P_{X^2}(\mathscr L_1\oplus\mathscr L_2)\). +The following calculation is where the chosen line bundle enters the +first determinant estimate. A line mapping into a cotangent tensor +has nonpositive degree on a general projective-line fiber; the +calculation also controls its horizontal class. + +\begin{lemma}\label{zero:cotangent-Z} +Let \(\mathscr H\) be a holomorphic line bundle on \(Z\), and suppose +there is a nonzero map \(\mathscr H\to\Omega_Z^{\otimes k}\), with +\(k\ge0\). Then +\[ + \mathscr H=\pi^*(\mathscr Q_1\boxtimes\mathscr Q_2) + \otimes\cO_Z(\ell) +\] +for lines \(\mathscr Q_i\) on \(X\) and an integer \(\ell\), and +\[ + \ell\le0,\qquad + c_1(\mathscr Q_1)_1+c_1(\mathscr Q_2)_2 + \le(k-\ell)(L_1+L_2). +\] +\end{lemma} + +\begin{proof} +Irregularity zero and Künneth give +\(\Pic(X^2)=\operatorname{pr}_1^*\Pic(X)\oplus +\operatorname{pr}_2^*\Pic(X)\), and the projective-bundle formula for +\(\Pic(Z)\) gives the asserted expression. Filter the target using +\[ + 0\longrightarrow\pi^*\Omega_{X^2}\longrightarrow\Omega_Z + \longrightarrow\cO_Z(-2)\otimes + \pi^*(\mathscr L_1\otimes\mathscr L_2)\longrightarrow0. +\] +Choose a nonzero associated graded component. Suppose it has \(i\) +relative factors and \(k_1,k_2\) cotangent factors from the two copies +of \(X\), so \(k_1+k_2=k-i\). Its relative degree is \(-2i\). +Pushing to \(X^2\) forces \(m=-2i-\ell\ge0\); hence +\(\ell\le-2i\le0\). A nonzero monomial in +\(\operatorname{Sym}^m(\mathscr L_1\oplus\mathscr L_2)\), with first +exponent \(m_1\), gives on the two general slices +\[ + c_1(\mathscr Q_1)\le(i+m_1+k_1)L,\qquad + c_1(\mathscr Q_2)\le(i+m-m_1+k_2)L. +\] +These are exactly the assumed cotangent-line bounds on \(X\), applied +after moving the indicated powers of \(\mathscr L\) to the source. +Each coefficient on the right is at most \(k-\ell\). Since \(L\ge0\), +pullback and addition prove the claimed bound. +\end{proof} + +\subsubsection{Extracting a positive rank fraction} + +\begin{lemma}\label{zero:diagonal-mass} +There are constants \(c_n,C_n>0\) such that, for every sufficiently +large \(q\), one can choose a rational number +\[ + c_nA_q\le s\le C_nA_q +\] +and a Kähler current \(T\) in \(C_s\) with analytic singularities, +not generically singular on \(E\), with the following property. On a +smooth projective modification \(h:U\to E\), its restricted mass has +a rational-divisor approximation +\begin{equation}\label{zero:selected-decomposition} + h^*(2M+s\zeta)=\beta+\{D'\}, + \qquad \beta\ \text{Kähler},\quad D'\ge0\ \text{rational}, +\end{equation} +which retains all log-ideal orders of \(T|_E\). If +\(f:U\to Z\) is the natural map and +\[ + w=\int_{U_z}\beta^{d-1} +\] +on a general fiber, then +\begin{equation}\label{zero:selected-w} + w\ge c_ns^{d-1}. +\end{equation} +\end{lemma} + +\begin{proof} +First let \(s\) be any rational number in \((0,s_{\max})\) with +\(v_E(s)>0\), and use the approximation in +Equation~\eqref{zero:rational-fujita} for any current used +to compute this restricted volume. In +Lemma~\ref{zero:direct-image}, the data for Equation~\eqref{zero:restriction-class} +are +\[ + b_0=d,\quad e=d-1,\quad G=2M,\quad + \Lambda=s h^*\cO_E(1)-\cO_U(D') + \ \text{in }\Pic(U)\otimes\Q. +\] +For large divisible \(j\), the associated sheaves satisfy +\begin{equation}\label{zero:symmetric-inclusion} + \mathcal F_j=f_*\cO_U(j\Lambda) + \subseteq\operatorname{Sym}^{js}\Omega_Z,\qquad + R_j=\operatorname{rk}\mathcal F_j,\qquad 00\). The contribution of +\(0(1-\delta)m\). Summing instead over their internal +degree gives +\[ + H_m(\delta) + \le \binom{m+n}{n}\binom{\lceil\delta m\rceil+n}{n},\qquad + \limsup_{m\to\infty}\frac{H_m(\delta)}{N_m} + \le\binom{2n}{n}\delta^n. +\] +On the other hand, \(w^+\ge w/2\) and +Equation~\eqref{zero:plus-rank} show that the approximation on \(E^+\) +retains at least half the rank fraction in +Equation~\eqref{zero:selected-rank-fraction}: +\[ + \lim_{j\to\infty}\frac{R_j^+}{N_{js}} + =\frac{w^+}{s^{d-1}} + \ge\frac{w}{2s^{d-1}}\ge c_n>0. +\] +Fix \(\delta>0\), depending only on \(n\), so small that, for each fixed +\(q\) and its selected data, fewer than \(R_j^+/2\) monomials have transverse +degree greater than \((1-\delta)js\) for all sufficiently large divisible +\(j\). For each +remaining monomial, Equation~\eqref{zero:coefficient-order} and +Lemma~\ref{zero:incidence-pole} give +\[ + \operatorname{ord}_u(c_{\alpha,\gamma}) + \ge j(s-C_n)-(1-\delta)js + =j(\delta s-C_n)\ge\frac{\delta js}{2}. +\] +The last inequality holds once \(q\) is large, since +\(s\ge c_nA_q\to\infty\). + +Over the same discrete valuation ring \(R\), the torsion-free sheaf +\(\mathcal F_j^+\) becomes a free module of rank \(R_j^+\). Write its +inclusion into the symmetric power as a matrix with the monomials +as rows. Every maximal minor uses at least \(R_j^+/2\) of the rows +whose coefficients have order at least \(\delta js/2\). All maximal +minors therefore have order at least +\(\delta jR_j^+s/4\). By the definition of \(h_j\), this proves +Equation~\eqref{zero:determinant-order-equation}. Dividing the determinant +map by \(\sigma_{J_+}^{h_j}\) gives a holomorphic map at every point of +codimension one: the coefficients have the required order along \(J_+\), +and its local equation is a unit away from \(J_+\). Hartogs' theorem +extends the divided map across the remaining set of codimension at least +two, giving the stated factorization through +\(\det\mathcal F_j^+(h_jJ_+)\). +\end{proof} + +\subsubsection{Cancellation on the point blowup} + +\begin{proof}[Completion of the proof of Proposition~\ref{zero:line-nonvanishing}] +Fix \(q\) sufficiently large for the preceding lemmas, with its chosen +\(P,s,T\) and modifications. Choose a very general point \(x\) in the first +factor of \(X^2\). The slice of \(Z^+\) above \(x\) is +\[ + S=\mathbb{P}_Y(\cO_Y\oplus a^*\mathscr L),\qquad + a:Y=\operatorname{Bl}_xX\longrightarrow X, +\] +and \(J_+|_S\) is the pullback of \(F\). We choose \(x\) so that +Equation~\eqref{zero:slope-blowup}, Equation~\eqref{zero:point-bound}, the restrictions of +the currents below, and all determinant maps for divisible \(j\) +can be tested on this slice. These exclude at most countably many +proper analytic sets and the measure-zero exceptional sets for +current restrictions. + +Write the restricted determinant line as +\[ + (\det\mathcal F_j^+)|_S + =\pi_S^*\mathscr Q_j^+\otimes\cO_S(\ell_j^+),\qquad + Q_j^+=c_1(\mathscr Q_j^+). +\] +Factoring the common zero of order \(h_j\) from the determinant +map gives a nonzero map whose source on \(S\) is +\[ + \pi_S^*(\mathscr Q_j^+\otimes\cO_Y(h_jF)) + \otimes\cO_S(\ell_j^+). +\] +The plus sign of \(h_jF\) follows because division of the map by +the local equation of \(J_+^{h_j}\) enlarges its source from +\(\det\mathcal F_j^+\) to +\(\det\mathcal F_j^+\otimes\cO(h_jJ_+)\). +Its target embeds into the \(jsR_j^+\)-fold tensor of the +restriction of \(p_+^*\Omega_Z\). In particular we use the +cotangent bundle of the original \(Z\), with its restricted +filtration +\[ + 0\longrightarrow + \pi_S^*(\cO_Y^{\oplus n}\oplus a^*\Omega_X) + \longrightarrow (p_+^*\Omega_Z)|_S + \longrightarrow + \cO_S(-2)\otimes\pi_S^*a^*\mathscr L + \longrightarrow0. +\] +The same homogeneous-monomial calculation as in +Equation~\eqref{zero:determinant-bound-Z}, now applying +Equation~\eqref{zero:slope-blowup} to the second factor of \(X^2\), gives +\begin{equation}\label{zero:determinant-bound-slice} + \ell_j^+\le0,\qquad + Q_j^++h_j\{F\} + \le(jsR_j^+-\ell_j^+)a^*L. +\end{equation} +More explicitly, if the chosen graded term has \(i\) relative +factors, the pushed polynomial has degree +\(-2i-\ell_j^+\ge0\). Its exponent in \(a^*\mathscr L\), together +with the \(i\) relative factors and the cotangent order from the second +factor of \(X^2\), is at most \(jsR_j^+-\ell_j^+\). The cotangent +factors from the first factor of \(X^2\) are constant. This proves the +displayed inequality using +the tensors of \(a^*\Omega_X\), without introducing \(\Omega_Y\) +or \(\Omega_{Z^+}\). + +Apply Lemma~\ref{zero:direct-image} to the decomposition in +Equation~\eqref{zero:plus-decomposition}. Equation~\eqref{zero:GRR-base} +shows that the limits of the restricted determinant components divided by +\(jR_j^+\) exist; denote them by \(Q^+\) and \(\ell^+\). Divide +Equation~\eqref{zero:determinant-bound-slice} by \(jR_j^+\), use +Equation~\eqref{zero:determinant-order-equation}, and pass to the closed +pseudo-effective cone. We obtain +\begin{equation}\label{zero:slice-upper} + \ell^+\le0,\qquad + Q^++c_ns\{F\}\le(s-\ell^+)a^*L. +\end{equation} +The pseudo-effective class in Equation~\eqref{zero:GRR-base}, restricted to the +very general slice \(S\), is +\begin{equation}\label{zero:slice-psef} + \pi_S^*(Q^++2a^*P)+(\ell^++2q)\xi\ge0. +\end{equation} +Testing on a general vertical line gives \(\ell^++2q\ge0\). +Let \(A\subset S\) be the axis of +\(\mathbb{P}_Y(\cO_Y\oplus a^*\mathscr L)\) with divisor class \(\{A\}=\xi\). +On \(A\simeq Y\), its normal class is \(\{A\}|_A=\xi|_A=a^*L\ge0\). +Add an arbitrarily small Kähler class to the class in +Equation~\eqref{zero:slice-psef}, and choose a Kähler current with analytic +singularities in the resulting big class. Remove its generic divisorial +pole along \(A\) and restrict +the residual current to \(A\). Adding back the removed nonnegative multiple +of \(a^*L\) preserves pseudo-effectivity. Passing to the limit gives +\begin{equation}\label{zero:slice-lower} + Q^++2a^*P+(\ell^++2q)a^*L\ge0. +\end{equation} + +The slope bound in Equation~\eqref{zero:slice-upper} supplies the +pseudo-effective class \((s-\ell^+)a^*L-Q^+-c_ns\{F\}\). Adding it to +Equation~\eqref{zero:slice-lower} cancels the entire normalized determinant +class restricted to the axis, \(Q^++\ell^+a^*L\), leaving +\[ + 2a^*P+(s+2q)a^*L-c_ns\{F\}\ge0. +\] +Since \(L\le P/r\), the point bound in Equation~\eqref{zero:point-bound} implies +\begin{equation}\label{zero:contradiction} + \frac{c_ns}{\,2+(s+2q)/r\,}\le C_n. +\end{equation} +The denominator is bounded independently of \(q\), because +\(s\le C_nq^{1/d}\) and \(r\ge q^2\). The numerator tends to +infinity, because \(s\ge c_nq^{1/d}\). Equation~\eqref{zero:contradiction} +is impossible for arbitrarily large \(q\). + +For each \(q\), the choice of \(t(q)\), the rational \(s\), the current +\(T\), and the modifications precedes the limit in \(j\). The monomial +cutoff \(\delta\) depends only on \(n\), while the required lower bound for +divisible \(j\) may depend on the fixed data. We choose the very general +points after those data are fixed. +Thus every simultaneous general-point test above involves at most +countably many conditions, and no bound depends on the point. +The contradiction disproves the contrary hypothesis and proves +Proposition~\ref{zero:line-nonvanishing}. +\end{proof} + +\subsection{Vanishing on the simple model} + +We now apply Proposition~\ref{zero:line-nonvanishing} to the sum of +the canonical bundle and the nef line bundle whose class we wish to +eliminate. The remaining use of the ordinary adjoint +decomposition is particularly short: it turns meromorphic +nonvanishing into both signs of pseudo-effectivity. + +\begin{proposition}\label{zero:simple-vanishing} +Let \(X\) be a smooth simple compact Kähler manifold of algebraic +dimension zero carrying a generically nondegenerate holomorphic +two-form. Every nef rational holomorphic line bundle on \(X\) has zero +first Chern class. +\end{proposition} + +\begin{proof} +The assertion is immediate for a point. A positive-dimensional space +of algebraic dimension zero cannot be a curve, so assume \(\dim X\ge2\). +If \(q(X)>0\), its Albanese map is generically finite onto its image, +by simplicity. Ueno's structure theorem for subvarieties of complex +tori makes this image a translate of a torus: its quotient by the +connected stabilizer is of general type, and positive dimension of that +quotient would contradict algebraic dimension zero \cite{Ueno}. +Lemma~\ref{zero:mass-test} proves the conclusion. + +The same argument applies after any smooth generically finite Kähler +cover of \(X\) having positive irregularity. Such a cover is still +simple and has algebraic dimension zero; vanishing upstairs descends +by push--pull. We may therefore suppose that every such cover has +irregularity zero. Lemma~\ref{zero:no-correspondences} then describes +the subvarieties through a very general point of \(X^2\). + +Clear denominators and let \(N_0\) be the resulting nef holomorphic line +bundle. A top wedge of the generically nondegenerate two-form is a +nonzero holomorphic section of \(K_X\). In particular \(K_X\) is +effective. Set +\[ + \mathscr L=K_X+N_0,\qquad L=c_1(\mathscr L). +\] +The class \(L\) is pseudo-effective and dominates \(c_1(K_X)\). +Lemma~\ref{zero:cotangent-slope} supplies both slope inequalities. +Every hypothesis of Proposition~\ref{zero:line-nonvanishing} is now +satisfied. Some positive power of \(K_X+N_0\) therefore has a nonzero +meromorphic section. Dividing by the corresponding power of a +canonical section shows that \(N_0\), as a rational line bundle, is +represented by a signed divisor. + +Resolve its positive and negative parts. On the resulting smooth +Kähler model write +\[ + N_0\qsim E-G,\qquad E,G\ge0, +\] +with rational coefficients and simple normal crossing union of their +supports; we suppress the pullback notation for \(N_0\). The canonical +bundle \(K'\) of this model remains effective. Choose a small rational +\(u>0\) so that both \(uE\) and \(uG\) are klt boundaries. +The ordinary decomposition, Theorem~\ref{pre:ordinary}, applies to +\(K'+uE\) and \(K'+uG\). On a common higher model, denote their pulled +back classes by \(\alpha_E\) and \(\alpha_G\). Algebraic dimension zero +makes each semiample part rationally trivial, so that the pulled back +rational lines equal their negative divisors. Since +\(\alpha_E-\alpha_G=u\{N_0\}\) is nef, +Lemma~\ref{pre:negative}\,(2) gives +\[ + N(\alpha_E)\le N(\alpha_G),\qquad + u\{N_0\}=\{N(\alpha_E)-N(\alpha_G)\}. +\] +Thus \(-\{N_0\}\) is pseudo-effective, whereas \(\{N_0\}\) is nef. +Pairing both classes with a Kähler power gives zero mass, and hence +\(\{N_0\}=0\). Pullback injectivity yields the same conclusion on +\(X\). +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{zero:vanishing}] +Lemma~\ref{zero:geometric-reduction} reduces the assertion to +Proposition~\ref{zero:simple-vanishing}, which proves it. +In particular, once the induction has reached dimension \(n\), the +ordinary decomposition of \(K_T+B\) also proves the decomposition +assertion of Theorem~\ref{thm:decomposition} in algebraic dimension +zero: adding the nef line changes no Chern class. Its semiample positive +part is rationally trivial, and its negative part is unchanged. +\end{proof} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/06-cycles.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/06-cycles.tex new file mode 100644 index 0000000000000000000000000000000000000000..fe16f444e38eb064602c3b23c6d1f27a26a5373f --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/06-cycles.tex @@ -0,0 +1,488 @@ +\section{The nef summand on the algebraic-reduction fibers} +\label{sec:cycles} + +Let $T$ be a smooth compact K\"ahler manifold of dimension $n$, and suppose +that $00$, some divisible $m$ has two sections whose +ratio is nonconstant on the connected fiber $X_w$. Lifting these +sections as above gives a meromorphic function on $X$ whose restriction +to $X_w$ is that ratio. Every meromorphic function on $X$ factors +through its algebraic reduction. Such a function, when defined on a +nonempty open subset of the smooth fiber $X_w$, is constant there: +a local holomorphic section of $h$ through a point where the quotient +is holomorphic shows that the base function extends holomorphically +at $w$. This contradicts the chosen nonconstant ratio. + +The countable simultaneous choice is legitimate by Baire's theorem. +If a generic assertion is initially established on a dense open set, +a proper analytic exceptional subset of that open is still nowhere +dense in $W$. Thus such generic assertions can also be included in the +choice. +\end{proof} + +\subsection{Divisor incidence and a countable collection of fibrations} + +We use the cycle-space results of Barlet, Lieberman, and Fujiki +\cite{Barlet,LiebermanCycles,Fujiki1978,Fujiki}. In the form needed here, +the spaces of +effective cycles of a compact K\"ahler manifold have countably many +irreducible components; each component is compact and belongs to +Fujiki's class $\mathcal C$; see \cite[p.~189]{Fujiki}. The locus of +cycles contained in a fiber of a proper map is an analytic relative +cycle space \cite[Proposition~3.2]{Fujiki1978}. We also use the +meromorphic fiber map obtained by analytic flattening: after modifying +the base, the flat strict transform has an analytic family of fiber +cycles and hence a holomorphic map to the cycle space +\cite[Chapter~V]{Barlet}. All parameter spaces and images in class $\mathcal C$ +will be replaced by smooth compact K\"ahler models when needed. + +The following observation explains why the numerical class of a divisor +can detect a semiample fibration without fixing its flat twist. + +\begin{lemma}\label{cycle:divisors} +Let $F$ be a smooth connected compact K\"ahler manifold, let $A$ be a +rational line bundle on $F$, and suppose that a modification +$\rho:\widehat F\to F$ from a smooth compact K\"ahler manifold satisfies +\begin{equation}\label{cycle:fiber-decomposition} + \rho^*A\num P+R, + \qquad P\text{ semiample}, + \qquad R=N(c_1(\rho^*A))\text{ a rational divisor}. +\end{equation} +Let $g:\widehat F\to Q$ be the fibration defined by $P$, so that $Q$ is +normal projective and $P\qsim g^*H_Q$ for an ample rational line bundle +$H_Q$. There is a dense open subset $U\subset F$, independent of the +divisors below, with the following properties for every sufficiently +divisible positive integer $m$. +\begin{enumerate} +\item There exists an analytic family of effective +divisors on $F$ with class $m c_1(A)$ that distinguishes the general fibers +of the meromorphic fibration $g\circ\rho^{-1}$. +\item For every effective divisor $D$ with class +$m c_1(A)$, membership +in $\operatorname{Supp}D$ is constant along the intersection of $U$ +with a general smooth fiber of that meromorphic fibration. +\end{enumerate} +\end{lemma} + +\begin{proof} +The difference between the two sides of +\eqref{cycle:fiber-decomposition} is flat as a rational line bundle. +By Lemma~\ref{pre:picard}, there is a flat rational line +bundle $\eta$ on $F$ such that +\[ + \rho^*(A+\eta)\qsim P+R. +\] +Choose $m$ clearing the denominators and such that $mH_Q$ is very ample. +The divisors +\[ + g^*D_Q+mR, + \qquad D_Q\in|mH_Q|, +\] +descend to an analytic family of divisors on $F$ with class $m c_1(A)$. +Indeed $\rho_*\cO_{\widehat F}=\cO_F$, so the projection formula +identifies sections of $m(A+\eta)$ with sections of its pullback. +On the isomorphism locus of $\rho$, away from $\operatorname{Supp}R$, +they distinguish general $g$-fibers, since hyperplanes distinguish +points of $Q$. + +For an arbitrary effective divisor $D$ of this class, +Lemma~\ref{pre:negative}(1) gives +\[ + \rho^*D\geq mR. +\] +The residual divisor $D'=\rho^*D-mR$ is effective and has class +$m c_1(P)$. Let $G$ be a smooth compact connected fiber of $g$. If +$D'$ does not contain $G$, its restriction is an effective divisor of +class zero on $G$, hence is empty: in positive dimension this follows +by integrating against a K\"ahler form to the appropriate power. +Consequently $\operatorname{Supp}D'$ either contains $G$ or misses it. +For a point fiber the same alternative is immediate. Taking the image +of the isomorphism locus of $\rho$, and deleting +$\operatorname{Supp}R$ and the nonsmooth locus of $g$, gives the stated +open set $U$. This choice uses only $\rho$, $R$, and $g$, and works for +all the divisors simultaneously. +\end{proof} + +\begin{lemma}\label{cycle:detection} +Let $h:X\to W$ be a fibration of smooth connected compact K\"ahler +manifolds with $\dim W<\dim X$, and let $A$ be a rational line bundle +on $X$. There is a countable collection of diagrams +\begin{equation}\label{cycle:diagrams} + \begin{tikzpicture}[baseline=(current bounding box.center),>=Stealth] + \node (Xi) at (0,1.15) {$X_i$}; + \node (Zi) at (2.7,1.15) {$Z_i$}; + \node (X) at (0,0) {$X$}; + \node (W) at (2.7,0) {$W$}; + \draw[->] (Xi) -- node[above] {$f_i$} (Zi); + \draw[->] (Xi) -- node[left] {$p_i$} (X); + \draw[->] (Zi) -- node[right] {$k_i$} (W); + \draw[->] (X) -- node[below] {$h$} (W); + \end{tikzpicture} +\end{equation} +where $p_i$ is a modification, $f_i$ is a fibration, and $X_i,Z_i$ are +smooth compact K\"ahler manifolds, with the following property. + +For a very general smooth fiber $F=X_w$, suppose that a smooth compact +K\"ahler modification $\rho:\widehat F\to F$ has a decomposition +\eqref{cycle:fiber-decomposition} for $A|_F$, and that the fibration +$g:\widehat F\to Q$ defined by $P$ has positive-dimensional base. +For some $i$, the restriction of $f_i$ over $w$ is bimeromorphically +equivalent to $g$. In particular, on a common resolution, their +general fibers coincide. The collection and the exceptional subsets +of $W$ can be fixed before $F$, $\rho$, $P$, and $R$ are chosen. +\end{lemma} + +\begin{proof} +We associate a map to each component of the relative divisor space by +recording all its divisors through a point. On a fiber with the stated +decomposition, Lemma~\ref{cycle:divisors} makes these incidence supports +constant along the semiample fibration. Integral multiplicities will +then give constancy of the cycle maps themselves, while the +distinguishing linear system will give the converse. + +Put $d=\dim X-\dim W$, and let $W^\circ$ be the smooth-fibration locus +of $h$. Consider the relative cycle spaces whose points are pairs +$(w,D)$, where $D$ is an effective $(d-1)$-cycle in $X_w$. They are +closed subspaces of the product of $W$ with the corresponding compact +cycle components of $X$. Thus they have countably many compact +irreducible components in class $\mathcal C$. + +For each positive integer $m$ clearing the denominator of $A$, retain +the components meeting $W^\circ$ on which the divisor class is +$m c_1(A|_{X_w})$. This is a condition on an entire component over +$W^\circ$: in a smooth family the cohomology class of an analytic +family of cycles is locally constant, and $c_1(A)$ supplies a global +section of the same cohomology local system. After resolving a +component, its open part over $W^\circ$ is connected, so equality at +one point implies equality throughout that part. Components not +dominating $W$ have proper analytic images; exclude all these images +from the eventual choice of $w$. + +Fix a retained dominating component and a smooth compact K\"ahler +resolution $S$ of it. Denote its divisor at $s\in S$ by $D_s$ and form +the incidence +\[ + \mathcal I_S + =\{(x,s)\in X\times S:x\in\operatorname{Supp}D_s\}. +\] +We take the incidence of the analytic cycle family, including its +limits from the open part over $W^\circ$. Over that open part it is a +family of pure $(d-1)$-dimensional cycles. Hence every irreducible +component there dominates $S$ and has dimension $\dim S+d-1$. +Let $I_1,\ldots,I_t$ be the incidence components that dominate $X$. +The other components have proper analytic images in $X$; outside +those images they contribute nothing to incidence. + +For each $I_j\to X$, analytic flattening gives a meromorphic map +recording its generic fiber as an effective cycle in $S$. All these +cycles have dimension +\[ + e=\dim S+d-1-\dim X. +\] +Taking the tuple of these maps, together with $h$, gives a meromorphic +map $\Phi_S$ from $X$ into $W$ times a finite product of compact cycle +components of $S$. On a dense open subset of $X$, the union of the +supports of the recorded cycles is precisely +\begin{equation}\label{cycle:incidence-support} + \{s\in S:x\in\operatorname{Supp}D_s\}. +\end{equation} +In obtaining this open set we discard the images of the nondominating +incidence components and the exceptional sets of the fiber maps. +The target components and the image of $\Phi_S$ belong to class +$\mathcal C$. Resolving the graph, taking Stein factorization, and +replacing the base by a smooth compact K\"ahler model therefore gives +a diagram \eqref{cycle:diagrams}. The coordinate $h$ ensures that its +base maps to $W$. If there is no dominating incidence component, we +retain only the coordinate $h$; such a component will not be needed +to detect a positive-dimensional $Q$. + +This construction gives countably many diagrams. Fix their models, +their incidence-recording open sets, and their Stein factorizations. +We may simultaneously require that their fibers over the eventual +$w$ be smooth, that $p_i$ restrict to a modification over $w$, and that +each of the dense open sets used meet the corresponding fiber densely. +For any one diagram these are generic conditions, by properness, +generic smoothness, and the fiber-dimension theorem. In particular, +let $U_i\subset Z_i$ be the locus over which $f_i$ is smooth. We +require that $k_i^{-1}(w)$ meet $U_i$ densely. To justify this +condition, a component of $Z_i\setminus U_i$ that does not dominate +$W$ has proper image, whereas a component dominating $W$ has general +fiber of dimension strictly less than $\dim Z_i-\dim W$. +Since the general $k_i$-fiber is smooth of that pure dimension, it +cannot have a component contained in $Z_i\setminus U_i$. The same +conditions may be imposed after any preselected countable collection +of further modifications of these diagrams. + +We now choose such a very general $w$ and a decomposition on $F=X_w$ +as in the statement. By Lemma~\ref{cycle:divisors}, a projective +linear system of divisors of class $m c_1(A|_F)$ distinguishes the +general $g$-fibers for some $m$. Its image in the relative cycle +space is irreducible and lies in one irreducible component. That +component dominates $W$, since all images of nondominating components +were excluded. It is therefore one of the components used above. +Passing to its parameter resolution $S$ preserves the distinguishing +property: every divisor still has a preimage in $S$. + +The map $\Phi_S|_F$ distinguishes general $g$-fibers. Indeed two +different general points of $Q$ are separated by a divisor in the +chosen linear system, so their incidence supports +\eqref{cycle:incidence-support} differ. Conversely, fix a general +smooth connected $g$-fiber $G$. On the common open set of +Lemma~\ref{cycle:divisors} and the incidence recording, membership in +every divisor $D_s$ is constant along $G$. Thus the support in +\eqref{cycle:incidence-support} is fixed as the point moves in that +open part of $G$. + +This support assertion also gives constancy of the recorded +\emph{cycles}. Their fixed union of supports is pure $e$-dimensional +and has finitely many irreducible components. Since all recorded +cycles have dimension $e$, there are only countably many possible tuples of +effective cycles supported there: their multiplicities are +nonnegative integers. A holomorphic map from a connected complex +manifold with countable image is constant. Removing a proper +analytic subset from the smooth connected $G$ leaves a connected +open set, so $\Phi_S$ is constant on a general $g$-fiber. Point +fibers require no separate argument. + +Constancy on the general connected fibers gives a meromorphic +factorization through $Q$. One can see this by taking the image of +the graph in $Q$ times the target: its projection to $Q$ has one-point +general fibers and is bimeromorphic. The distinguishing property +makes the induced map from $Q$ generically one-to-one onto its image. +Hence $\Phi_S|_F$ defines the same meromorphic fibration as $g$. + +Finally, the restriction of $f_i$ over $w$ still has connected fibers: +its fibers are exactly the corresponding fibers of $f_i$. Its base +over $w$ is connected, being the image of the connected source fiber. +The finite map in Stein factorization cannot split a connected +general $g$-fiber: a map from that fiber into a finite set is constant. +The preselected resolutions restrict to modifications over $w$. +Thus the same comparison holds for $f_i$, proving the assertion. +\end{proof} + +\subsection{Vanishing of the nef class on the fibers} + +We can now choose the flat twists on the total space. The order of +choice is essential: the following proof fixes a countable collection +of global representatives before it chooses the smooth fiber. + +\begin{proposition}\label{cycle:nef-summand} +Assume Theorem~\ref{thm:decomposition} in dimensions less than $n$. +Let $T$ be a smooth connected compact K\"ahler $n$-fold with +$00$. + +On a general smooth $g$-fiber $G$, the class of $P_F$ is zero. +Restricting the last equality in +\eqref{cycle:residual-effective} and using the same positivity +argument shows that +\begin{equation}\label{cycle:restriction-zero} + c_1(\rho^*(M|_F)|_G)=0, + \qquad + G\cap\operatorname{Supp}(\rho^*E_F-R_F)=\varnothing. +\end{equation} +If $G$ is a point, the first assertion is automatic and the second +holds for a general point. In positive dimension, choose a general +fiber not contained in the effective divisor, restrict it, and +integrate the effective and nef classes against a K\"ahler power. +Both nonnegative masses must vanish. + +Lemma~\ref{cycle:detection} gives an index $i$ such that the restriction +of $f_i$ over $w$ and $g$ have the same general fibers up to modifications. By +\eqref{cycle:restriction-zero} and injectivity of pullback on +cohomology, $p_i^*M$ has class zero on a smooth $f_i$-fiber above +$w$. Such a fiber can be chosen in the smooth-fibration locus of +$f_i$, by the generic conditions already imposed. Over the +connected smooth locus in $Z_i$, the restrictions of this Chern +class form a locally constant section of $R^2(f_i)_*\R$. Vanishing +at one fiber therefore implies vanishing at every fiber in this +locus. Thus $i\in I_0$; its representative $M_i^*$ was already +chosen before $w$. + +We claim that +\begin{equation}\label{cycle:positive-kappa} + \kappa(F,J_F+M_i^*|_F)>0. +\end{equation} +On a common resolution of the maps on $F$, the line $M_i^*|_F$ +is rationally trivial on a general $g$-fiber because it is a +pullback from the intermediate base of $f_i$. This triviality +descends between smooth models of the fiber: for a modification, +pullback on line bundles is injective by normality and the +projection formula. The difference +\[ + \Lambda=\rho^*(J_F+M_i^*|_F)-P_F-R_F +\] +is a flat rational line bundle by +\eqref{cycle:inductive-decomposition}. Its restriction to a +general $G$ is rationally trivial. Indeed $P_F|_G$ is trivial, +$M_i^*|_G$ is trivial, and +\eqref{cycle:restriction-zero} makes +$\cO_{\widehat F}(\rho^*E_F-R_F)|_G$ trivial, while +$J_F\qsim E_F$. + +Resolve $Q$ and the induced map, and continue to denote the +resulting fibration between smooth models by $g$. By Lemma~\ref{desc:flat}, +$\Lambda\qsim g^*\lambda$ for a flat rational line bundle +$\lambda$ on the smooth projective base. The line $P_F$ is the +pullback of the ample rational line on the original $Q$; on its +resolution the corresponding base line $H_Q'$ is nef and big. +Twisting by $\lambda$ preserves bigness. On these models we have +an actual rational identity +\[ + \rho^*(J_F+M_i^*|_F) + \qsim g^*(H_Q'+\lambda)+R_F. +\] +Multiplication by the canonical section of a divisible multiple +of $R_F$ embeds the section spaces of the big base line into the +section spaces on $\widehat F$. Since $\dim Q>0$, this proves +\eqref{cycle:positive-kappa}. + +This contradicts the instance of Lemma~\ref{cycle:sections} imposed +on $J+M_i^*$ when $w$ was chosen. Hence $M|_F\num0$ for the +chosen fiber. Finally, restrictions of $c_1(M)$ form a +locally constant section of $R^2h_*\R$ on the connected smooth +locus of $h$. Their vanishing therefore holds on every fiber in +that locus, and in particular on a general smooth fiber. +\end{proof} + +\begin{corollary}\label{cycle:base-descent} +Under the assumptions of Proposition~\ref{cycle:nef-summand}, +there are modifications $p:T'\to T$ and $b:W'\to W$, with +$T'$ smooth compact K\"ahler and $W'$ smooth projective, a +fibration $h':T'\to W'$ lifting $h$, and a nef rational line +bundle $N$ on $W'$ such that +\[ + p^*M\num(h')^*N. +\] +\end{corollary} + +\begin{proof} +Proposition~\ref{cycle:nef-summand} supplies the fiberwise +vanishing required in Proposition~\ref{desc:nef}. Apply that +proposition to $h$ and $M$. The modified base remains projective, +so the descended rational class is nef. +\end{proof} diff --git a/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/07-completion.tex b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/07-completion.tex new file mode 100644 index 0000000000000000000000000000000000000000..8956d27da5d058b6fb3a4b4acb64ebcec60e0703 --- /dev/null +++ b/preprints/Numerical-semiampleness-of-nef-adjoint-classes-on-compact-Kahler-manifolds-October-6-2026/build/sections/07-completion.tex @@ -0,0 +1,305 @@ +\section{Completion of the induction}\label{sec:completion} + +We now combine the preceding constructions. The main geometric step is +to make the ordinary adjoint semiample after adding a sufficiently +positive line from the algebraic base, while preserving the map to that +base. The adjoint formula of Proposition~\ref{adj:base} then puts the +problem on a projective variety. We first isolate the negative-part +calculation needed to pull the projective answer back. + +\subsection{Divisors above subsets of codimension at least two} + +\begin{lemma}\label{finish:exceptional} +Let \(r:V\to S\) be a surjective morphism from a smooth compact K\"ahler +manifold to a normal projective variety. Let \(H\) be a nef rational +Cartier divisor on \(S\). If \(E\geq0\) is a real divisor on \(V\) whose +every component has image of codimension at least two in \(S\), then +\[ + N(r^*H+E)=E. +\] +\end{lemma} +\begin{proof} +Put \(n=\dim V\), \(\beta=c_1(r^*H)\), and +\(\alpha=\beta+\{E\}\). Nefness gives \(N(\alpha)\leq E\). +Suppose +\[ + U=E-N(\alpha)>0. +\] +Then \(\beta+\{U\}=Z(\alpha)\) is modified nef. Write +\(U=\sum_i u_iU_i\), with \(u_i>0\), and choose +\[ + s=\max_i\dim r(U_i)\leq\dim S-2. +\] +In particular \(0\leq s\leq n-2\). Let \(\eta\) be the pullback of an +ample class on \(S\), and let \(\omega\) be a K\"ahler class on \(V\). +Consider the symmetric bilinear form +\[ + Q(\gamma,\delta)=\int_V\gamma\,\delta\,\eta^s\omega^{n-s-2} + \quad\text{on }H^{1,1}(V,\R). +\] +Since the image of each \(U_i\) has dimension at most \(s\), any pairing +on \(U_i\) with \(s+1\) classes from \(S\) vanishes. Therefore +\begin{equation}\label{finish:orthogonal} + Q(\{U\},\eta)=0,\qquad Q(\{U\},\beta)=0. +\end{equation} +By Lemma~\ref{pre:negative}(3), \(Z(\alpha)\) restricts +pseudo-effectively to a resolution of \(U_i\). Pairing there with the +nef classes \(\eta^s\omega^{n-s-2}\) and summing over \(i\) gives +\[ + 0\leq Q(\{U\},Z(\alpha))=Q(\{U\},\{U\}). +\] +On the other hand, +\[ + Q(\eta,\eta)=\int_V\eta^{s+2}\omega^{n-s-2}>0, +\] +because \(s+2\leq\dim S\). The mixed Hodge--Riemann relations +\cite[Theorem~A]{DinhNguyen}, applied with +\(\eta+\varepsilon\omega\) and then passed to the limit, show that \(Q\) +has at most one positive eigenvalue. Thus its restriction to +\(\eta^\perp\) is negative semidefinite. Equations +\eqref{finish:orthogonal} force \(Q(\{U\},\{U\})=0\). +A zero-square vector for a negative semidefinite form belongs to its +radical; decomposing every class into a multiple of \(\eta\) and an +element of \(\eta^\perp\) shows that \(\{U\}\) belongs to the radical of +the whole form \(Q\). + +This contradicts +\[ + Q(\{U\},\omega)= + \sum_i u_i\int_{U_i}\eta^s\omega^{n-s-1}>0. +\] +Indeed every term is nonnegative, and a component with image dimension +\(s\) gives a strictly positive integral on its smooth generic locus. +Consequently \(U=0\). +\end{proof} + +This proof is the codimension-two part of the lifting argument in +\cite[Section~5]{K}. Its formulation above also applies to maps with +positive-dimensional fibers; birational exceptional translation alone +would not suffice at that point of our proof. + +\subsection{Keeping the ordinary program over the algebraic base} + +\begin{proposition}\label{finish:over-base} +Let \(T\) be a smooth compact K\"ahler manifold of dimension \(n\), let +\((T,B)\) be a rational simple normal crossing klt pair with +\(J=K_T+B\) pseudo-effective, and let +\(h:T\to W\) be a surjective morphism to a smooth projective variety. +There are a smooth compact K\"ahler modification \(T_1\to T\), an +effective klt adjoint \(J_1\) on \(T_1\) as in +\eqref{pre:resolution-error}, and a finite ordinary \(J_1\)-negative +program over \(W\), ending at a normal compact K\"ahler klt pair +\((Y,\Delta)\), such that for some positive integer \(b\) and an ample +Cartier divisor \(A_W\) on \(W\), +\[ + K_Y+\Delta+b h_Y^*A_W +\] +is semiample. Here \(h_Y:Y\to W\) is the descended morphism. +\end{proposition} +\begin{proof} +Choose \(A_W\) very ample and an integer \(b>2n\), and set +\(C=h^*A_W\). A general member of a sufficiently high multiple of +the free system \(|C|\), divided by that multiple and multiplied by +\(b\), gives an effective rational representative of \(bC\). +Bertini's theorem, with the multiple chosen large enough, makes its +sum with \(B\) an effective simple normal crossing klt boundary. +Theorem~\ref{pre:ordinary} therefore gives a decomposition of \(J+bC\). + +Pass to a higher smooth model \(T_1\) and apply the convention +\eqref{pre:resolution-error} to the original pair \((T,B)\). Write +\(J_1=K_{T_1}+B_1\) and \(C_1=h_1^*A_W\). The exceptional error and +Lemma~\ref{pre:negative} retain an actual identity +\begin{equation}\label{finish:augmented-decomposition} + J_1+bC_1\qsim P_1+R_1,\qquad + P_1\text{ semiample},\qquad R_1=N(J_1+bC_1)\geq0, +\end{equation} +with rational terms. On this fixed model choose a fresh general +fractional representative of \(bC_1\), so that its sum with \(B_1\) +is again simple normal crossing and klt. +Apply Proposition~\ref{pre:contract} to this augmented ordinary +adjoint and its known negative part in +\eqref{finish:augmented-decomposition}. Its finite ordinary scaling +contracts or flips detected analytic extremal rays negative for the +augmented adjoint. It preserves the actual semiample positive line +\(P_1\), with a fixed generated Cartier multiple, and contracts the +negative part \(R_1\). + +The positive line \(P_1\) and the fixed algebraic-base line +\(C_1=h_1^*A_W\) have distinct roles; they need not be equal or +proportional. Preservation of \(C_1\) and of the specific morphism +to \(W\) follows from a separate ray estimate. We check inductively +that each step is over \(W\). Suppose the current +model \(T_i\) still has a morphism \(h_i:T_i\to W\) and the unaugmented +pair is klt. Put +\[ + J_i=K_{T_i}+B_i,\qquad C_i=h_i^*A_W. +\] +An extremal ray negative for \(J_i+bC_i\) is \(J_i\)-negative because +\(C_i\) is nef. The K\"ahler klt cone theorem +\cite[Theorem~1.3]{HX}, with zero nef b-part, supplies a rational curve +\(\Gamma\) generating this ray and satisfying +\[ + 0<-J_i\cdot\Gamma\leq2n. +\] +If \(C_i\cdot\Gamma>0\), Cartier integrality gives +\[ + (J_i+bC_i)\cdot\Gamma\geq-2n+b>0, +\] +a contradiction. Hence \(C_i\) is numerically trivial on the contracted +ray. + +The contracted fibers are projective, and all their curves have class +in the contracted ray. If their image under \(h_i\) had positive +dimension, a curve on a fiber would have positive degree against +\(h_i^*A_W\); thus \(h_i\) is constant on each contracted fiber. +Connected-fiber descent to the normal contraction base factors \(h_i\) +through it. For a flip, composing the morphism from the flipped space +with this base map gives the next \(h_i\). The added line is consequently +the same Cartier pullback \(C_{i+1}=h_{i+1}^*A_W\) on the next model. +Each step is also \(J_i\)-negative, and the unaugmented ordinary klt +pair persists. This proves the induction through the finite program. +On a common resolution the two pullbacks of the line from \(W\) +agree. Subtracting \(b\) times this pullback from the augmented +comparison therefore gives an effective exceptional comparison for +the unaugmented adjoints as well. +Writing \(P_Y\) for the descended positive line, the final actual +rational-line identity is +\[ + K_Y+\Delta+b h_Y^*A_W\qsim P_Y. +\] +The line \(P_Y\) is semiample by Proposition~\ref{pre:contract}, which +proves the required semiampleness of the augmented adjoint. +\end{proof} + +The degree argument is the familiar way of preserving a nef Cartier +line in an adjoint program; compare \cite[Lemma~3.6]{K} and +\cite[Section~8.2]{P}. Here preservation of the line also preserves the +specific morphism to \(W\). + +\subsection{The strengthened decomposition} + +\begin{proof}[Proof of Theorem~\ref{thm:decomposition}] +We induct simultaneously on \(n=\dim T\) for both assertions of the +theorem. Dimension zero is immediate. Suppose both assertions hold in +every dimension less than \(n\). The projective case of the decomposition +is Proposition~\ref{pre:projective}. If \(a(T)=0\), +Proposition~\ref{zero:vanishing} gives \(M\num0\); ordinary decomposition +then proves the required statement for \(J+M\). It remains to treat +\[ + 00\) for every nonzero tangent +vector \(v\). It is \emph{compatible} with \(J\) if, in addition, +\(\omega(Ju,Jv)=\omega(u,v)\). A taming form is automatically +nondegenerate; thus a closed taming form is symplectic. + +Donaldson asked whether the existence of a taming symplectic form +on a closed four-manifold implies the existence of a compatible +one \cite[Section~5.2, Question~2]{Donaldson2006}. +This existence question is distinct from his a priori estimate +conjecture for a prescribed-volume equation. +The elementary projection +\(\omega\mapsto \frac12(\omega+\omega(J\,\cdot,J\,\cdot))\) +shows the obstacle: it preserves positivity on complex lines +but generally loses closedness. Our main result answers the +existence question affirmatively. + +\begin{theorem}\label{thm:main} +Suppose that a smooth almost complex structure \(J\) on a closed +connected smooth real four-manifold \(X\) is tamed by a symplectic +form. Then there is a smooth symplectic form compatible with \(J\). +\end{theorem} + +The almost complex structure in Theorem~\ref{thm:main} is the given +one. The conclusion imposes no condition on the cohomology class of +the compatible form. In particular, it does not assert that an +arbitrary taming class contains a compatible representative. + +There is also an intrinsic description of the compatible cone in terms +of the taming cone and the intersection pairing. + +\begin{theorem}[Taming and compatible cones]\label{thm:taming-cones} +Let \(X,J\) satisfy the hypotheses of Theorem~\ref{thm:main}, and give +\(X\) the orientation induced by \(J\). Let +\(\mathcal K_J^t,\mathcal K_J^c\subset H^2(X;\R)\) be the classes +represented by taming and compatible symplectic forms, respectively. +Let \(H_J^-\) be the subspace represented by smooth closed real +anti-invariant two-forms. Set +\[ + \mathcal V=(H_J^-)^\perp,\qquad + \mathcal C=\mathcal K_J^t\cap\mathcal V, +\] +where orthogonality is for the intersection pairing. Then +\begin{align} + \mathcal K_J^t&=\mathcal C+H_J^-,\label{eq:tame-decomposition}\\ + \mathcal K_J^c&= + \{a\in\mathcal C:\ a\cdot y>0 + \text{ for every }0\ne y\in\overline{\mathcal C}\}. + \label{eq:compatible-duality} +\end{align} +The closure is taken in \(\mathcal V\), and the sum in +\eqref{eq:tame-decomposition} is a Minkowski sum. +\end{theorem} + +\begin{corollary}\label{cor:taming-cones} +Under the same hypotheses, write \(h_J^-=\dim H_J^-\) and let +\(b_2^+(X)\) be the positive index of the intersection form. +If \(h_J^-=b_2^+(X)-1\), then +\[ + \mathcal K_J^t=\mathcal K_J^c+H_J^-. +\] +In particular, if \(b_2^+(X)=1\), then +\(\mathcal K_J^t=\mathcal K_J^c\): every taming class has a smooth +compatible symplectic representative. +\end{corollary} + +The proofs are given in Section~\ref{sec:cones}. They use separation +in a prescribed cohomology class and the current estimates below. +The inclusion +\(\mathcal K_J^c+H_J^-\subseteq\mathcal K_J^t\) +can be strict when \(h_J^-0\}. +\] +Existence of the limit is part of the argument. The principal +step, Theorem~\ref{thm:splitting}, proves that the restriction +\(P_E=\ind_E P\) is closed. It applies to any closed current +\(P+Q\) with an anti-invariant \(L^2\) correction and the stated +mass and angular bounds; annihilation of all closed forms is +not needed for this step. + +The reason the angular estimate suffices is a balance between +two errors. Planar tangent measures show that, over the same +nearby pairs, the squared normal component of the displacement +between base points, relative to the first complex line and divided +by \(r^2\), has integral \(o(r^2)\). +Closedness of \(P+Q\) trades tangential derivatives of a smooth +density cutoff for a product of angular and transverse errors. +The derivative and normalization of the cutoff contribute +\(r^{-3}\). Cauchy--Schwarz therefore bounds the decisive +boundary term by +\[ +r^{-3}\,O(r^2)\,o(r)=o(1), +\] +where the two factors are the square roots of the angular and +transverse moments. The \(L^2\) bound controls the correction's +cutoff error separately. Together these estimates prove closedness +of the density restriction without requiring a quantitative rate +for tangent measure convergence. + +Once \(P_E\) is closed, the residual +\(T-P_E=\ind_{X\setminus E}P+Q\) is closed as well. Its positive +summand is concentrated on zero-density centers, where the +negative error in the pairing does tend to zero. Pairing this residual +with \(T\), and using the vanishing of the mixed terms, forces +\(Q=0\). The resulting nonzero positive current \(P=T\) +cannot annihilate a closed taming form. + +The relative projection estimate in Lemma~\ref{lem:mixing}, for +fixed smooth orthogonal bundle projections, and the closedness +statement in Theorem~\ref{thm:splitting} may be useful separately. +The regularized pairing estimates use the four-dimensional fact +that anti-invariant two-forms are self-dual. +Sections~\ref{sec:currents} and \ref{sec:mass} construct the +separating current and prove its mass bound. +Section~\ref{sec:energy} establishes the regularization and +angular estimates. Section~\ref{sec:density} proves density +existence and the planar tangent description; +Section~\ref{sec:splitting} uses them to control cutoff boundaries +and prove closedness of \(P_E\). +Section~\ref{sec:conclusion} completes the existence argument. +Section~\ref{sec:cones} develops the prescribed-class separation +and proves the cone description. + +A triple of closed two-forms on an oriented four-manifold is +\emph{hypersymplectic} if every nonzero real linear combination is +symplectic and induces the given orientation. The companion +\cite[Theorem~1.1]{OpenAIHypersymplectic2026} combines the current +estimates above with additional prescribed-class and deformation +arguments to deform hypersymplectic triples normalized by +\(\int_X\omega_i\wedge\omega_j=\delta_{ij}\) on closed connected oriented +smooth four-manifolds to hyperk\"ahler triples, while fixing each class +\([\omega_i]\in H^2(X;\R)\). diff --git a/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/02-currents.tex b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/02-currents.tex new file mode 100644 index 0000000000000000000000000000000000000000..21ec821f63bd19bf62b93d1a06474dafb8affc7e --- /dev/null +++ b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/02-currents.tex @@ -0,0 +1,164 @@ +\section{A current obtained by separation}\label{sec:currents} + +We first construct the current that would obstruct compatibility: +a positive current and an anti-invariant correction whose sum +annihilates every closed two-form. + +Give \(X\) its complex orientation. Fix a smooth \(J\)-Hermitian +metric \(g\), and write +\[ +F(u,v)=g(Ju,v),\qquad +(R\alpha)(u,v)=\tfrac12\bigl(\alpha(u,v)-\alpha(Ju,Jv)\bigr). +\] +Thus \(R\) is the orthogonal projection onto the anti-invariant +two-forms, and \(1-R\) projects onto the invariant two-forms. +All forms and currents are real. + +We identify bivectors with two-forms using \(g\). Let +\(\mathscr C\to X\) be the bundle of unit complex line bivectors +\[ +\mathscr C_x=\{v\wedge Jv:\ |v|_g=1\}. +\] +For \(\ell\in\mathscr C_x\), let \(L_\ell\subset T_xX\) be its +oriented plane. The following pointwise identities will be used: +\begin{equation}\label{eq:algebra} +\im R\subset\Lambda_g^+,\qquad +*F=F,\qquad |F|^2=2,\qquad +|\ell|=1,\qquad \ell^+=F/2,\qquad F(\ell)=1. +\end{equation} +They follow by taking a unitary frame +\((v,Jv,w,Jw)\). In that frame \(F\) corresponds to +\(v\wedge Jv+w\wedge Jw\), and the anti-invariant subspace is spanned +by +\[ +v\wedge w-Jv\wedge Jw,\qquad +Jv\wedge w+v\wedge Jw. +\] + +A two-current acts on smooth two-forms. It is \emph{closed} if it +annihilates exact two-forms. Under the \(L^2\) identification with +distributional two-forms, this means \(d^*T=0\), or equivalently +\(d(*T)=0\). Multiplication and orthogonal projections on +distributional forms act on currents by duality. + +\begin{lemma}[A closed lift]\label{lem:lift} +There is a real order-zero pseudodifferential operator +\[ +B:C^\infty(\im R)\longrightarrow\Omega^2(X) +\] +such that \(dB=0\) and \(RB=\Id\). +\end{lemma} + +\begin{proof} +Consider \(\cL=Rdd^*\) on sections of \(\im R\). If \(\xi\ne0\), +the projection of +\(\xi\wedge\iota_{\xi^\sharp}\) from self-dual two-forms back to +self-dual two-forms is \(|\xi|^2/2\) times the identity. +By \eqref{eq:algebra}, the principal symbol of \(\cL\) on +\(\im R\) is therefore the same scalar. In particular \(\cL\) +is elliptic. For anti-invariant smooth forms \(a,b\), +\[ +\ip{\cL a}{b}_{L^2}=\ip{d^*a}{d^*b}_{L^2}. +\] +It is nonnegative and self-adjoint. Every element of its kernel +is smooth and coclosed; being self-dual, it is also closed. + +Let \(H\) be the orthogonal projection onto this kernel and let +\(G\) be the inverse of \(\cL\) on its orthogonal complement, +extended by zero on the kernel. The elliptic generalized-inverse +theorem gives \(G\) of order \(-2\) and \(H\) a smoothing +finite-rank operator; see +\cite[Proposition~6.4 and Theorem~6.3]{MelroseIML}. +Set +\[ +B=dd^*G+H. +\] +Then \(dB=0\), while \(RB=\cL G+H=\Id\). +\end{proof} + +The projected elliptic operator used here also appears in Lejmi's +proof of local compatibility in dimension four +\cite[proof of Theorem~1]{Lejmi2006}. +Dr\u{a}ghici and Zhang's exact-form result gives the corresponding +global linear correction phenomenon +\cite[Proposition~3.1]{DraghiciZhang2012}. +The present formula specifies the closed lift and its mapping properties; +positivity remains a separate problem. + +\begin{proposition}\label{prop:separation} +If \(J\) admits no compatible symplectic form, there are currents +\(P,Q,T\) and a finite positive measure \(\lambda\) on +\(\mathscr C\) such that +\begin{align} +P(\alpha)&=\int_{\mathscr C}\alpha_x(\ell)\dd\lambda(x,\ell), +&\lambda(\mathscr C)&=1,\label{eq:positive-representation}\\ +T&=P+Q, +&RP&=0,\quad RQ=Q,\quad *Q=Q,\label{eq:decomposition}\\ +T(\alpha)&=0&&\text{for every smooth closed two-form }\alpha. +\label{eq:annihilation} +\end{align} +The current \(P\) annihilates every closed invariant two-form. +The projection \(\mu\) of \(\lambda\) to \(X\) is the +\emph{trace measure} of \(P\): for every smooth function \(b\), +\(P(bF)=\int_Xb\dd\mu\). Each of \(P,Q,T\) belongs to \(H^{-3}\). +\end{proposition} + +\begin{proof} +In the Fr\'echet space of smooth invariant two-forms, the cone of +positive definite forms is open and convex. It is disjoint from +the linear subspace of closed invariant forms by hypothesis. +Hahn--Banach separation gives a nonzero continuous functional +nonnegative on the cone and zero on that subspace. Extend it to +all two-forms by composing with \(1-R\), and call it \(P\). +This is the positive-current separation framework of +Sullivan and Harvey--Lawson \cite{Sullivan1976,HarveyLawson1983}; +for its almost-complex formulation, see +\cite[Section~3]{LiZhang2009}. + +Positivity extends to semidefinite invariant forms by adding +\(\eps F\) and taking \(\eps\downarrow0\). +Since \(C\|\alpha\|_\infty F\pm(1-R)\alpha\) are semidefinite +for a fixed norm-comparison constant, +\[ +|P(\alpha)|\le C\|\alpha\|_\infty P(F). +\] +Thus \(P\) has order zero, and \(P(F)>0\) because \(P\ne0\). +Scale \(P\) so that \(P(F)=1\). + +For completeness, the measure representation can be obtained +in local unitary frames. Invariant two-forms identify with +Hermitian symmetric forms by +\(\alpha\mapsto\alpha(\,\cdot,J\,\cdot)\). +The positive functional has a positive Hermitian matrix of +coefficient measures. Its trace is a positive measure \(\mu\); +the coefficient measures are absolutely continuous with +respect to \(\mu\). Their Radon--Nikodym density is a positive +semidefinite Hermitian matrix of trace one, or equivalently +a convex combination of bivectors in \(\mathscr C_x\). +Measurable spectral decomposition in measurable unitary frames +gives \(\lambda\) in \eqref{eq:positive-representation}. +The identity \(F(\ell)=1\) shows that its projection is \(\mu\) +and that its total mass is one. + +Define +\[ +T(\alpha)=P(\alpha-BR\alpha),\qquad +Q(\alpha)=-P(BR\alpha). +\] +For closed \(\alpha\), the form \(\alpha-BR\alpha\) is closed +and invariant, proving \eqref{eq:annihilation}. Moreover \(RP=0\) +and \(RQ=Q\), so \(*Q=Q\) by \eqref{eq:algebra}. +In particular \(T\) is a closed current. + +A finite measure on a compact four-manifold defines an element +of \(H^{-3}\), by the Sobolev embedding \(H^3\subset C^0\). +The order-zero operator \(RB^*\) is bounded on this Sobolev +space by the pseudodifferential Sobolev mapping theorem +\cite[Proposition~0.5.E]{Taylor1991}, so the same conclusion +holds for \(Q=-RB^*P\) and \(T\). +\end{proof} + +Hereafter \(C\), with or without a subscript, denotes a finite +constant independent of the small scale parameters. It may +change from one occurrence to the next. Constants are uniform +over centers in \(X\). diff --git a/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/03-mass.tex b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/03-mass.tex new file mode 100644 index 0000000000000000000000000000000000000000..1ef5a4accfddb87dda6d5bccc7e03b94f581fe8f --- /dev/null +++ b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/03-mass.tex @@ -0,0 +1,150 @@ +\section{Quadratic mass growth}\label{sec:mass} + +Let \(P,\mu\) be as in Proposition~\ref{prop:separation}. +We use the annihilation of closed invariant forms to bound the +mass of \(P\) in every small ball. +Write \(B_s(x)\) for a geodesic ball. +\begin{proposition}\label{prop:growth} +There is a constant \(C\) such that +\begin{equation}\label{eq:growth} +\mu(B_s(x))\le Cs^2 +\end{equation} +for all \(x\in X\) and \(s>0\). +\end{proposition} + +The proof uses closed invariant test forms +\[ +Du=(1-BR)dd_J^cu,\qquad d_J^cu=-du\circ J. +\] +The Hessian terms of \(dd_J^cu\), with \(J\) frozen at a point, +form an invariant two-form. Consequently \(Rdd_J^c\) is a +first-order differential operator on functions. + +We first spell out the local estimate needed for the +order-zero correction. In dimension four, an order-zero +pseudodifferential operator has an off-diagonal kernel bounded +by \(C|y-z|^{-4}\) in local coordinates +\cite[Section~0.2, Proposition~0.2.B]{Taylor1991}. +Work in a fixed smooth local bundle trivialization. +If \(f\) is supported in a coordinate ball of radius \(a\le1\) +and its coefficient derivatives satisfy +\begin{equation}\label{eq:scaled-input} +|\partial^jf|\le C_jMa^{-j}, +\end{equation} +then its local contribution to the operator is bounded by +\(CM\). Indeed, write \(f(z)=M\widetilde f((z-z_0)/a)\). +Six bounded derivatives of \(\widetilde f\) give +\(|\widehat{\widetilde f}(\xi)|\le C(1+|\xi|^2)^{-3}\) +by integration by parts. This bound is integrable in four +dimensions, so \(\|\widehat{\widetilde f}\|_1\le C\), and hence +\(\|\widehat f\|_1\le CM\). The bounded-symbol Fourier formula +gives the assertion; smoothing remainders are controlled by +\(\|f\|_1\). This estimate uses the derivative bounds +\eqref{eq:scaled-input}, not general \(L^\infty\) boundedness. + +\begin{lemma}\label{lem:radial-correction} +Choose normal coordinates centered at \(x\), on a uniformly +small fixed ball, and put \(t=d_g(x,y)\). Let a smooth radial +cutoff be one on a smaller ball and vanish outside the +coordinate ball. For \(s>0\) small, let \(u_s,h_s\) be this +cutoff times +\[ +\log\sqrt{s^2+t^2},\qquad \sqrt{s^2+t^2}, +\] +respectively, extended by zero. Near the center, +\begin{equation}\label{eq:correction-bounds} +|BRdd_J^cu_s|\le \frac{C}{s+t}, +\qquad +|BRdd_J^ch_s|\le C(1+|\log(s+t)|). +\end{equation} +Both expressions are uniformly bounded at any fixed positive +distance from \(x\). +\end{lemma} + +\begin{proof} +The first-order property of \(Rdd_J^c\) gives +\[ +|\partial^j(Rdd_J^cu_s)|\le C_j(s+t)^{-1-j},\qquad +|\partial^j(Rdd_J^ch_s)|\le C_j(s+t)^{-j} +\] +near \(x\). Away from \(x\), all fixed-order derivatives are +uniformly bounded, including terms from the cutoff. + +At \(y\), put \(a=s+t\), assuming \(a\) small. Localize the +input to a ball about \(y\) of radius a small fixed multiple +of \(a\). On this ball \(s+d_g(x,\cdot)\) is comparable to +\(a\), so \eqref{eq:scaled-input} gives contributions \(C/a\) +and \(C\). For the rest of the input within distance \(O(a)\) +of \(x\), the kernel is bounded by \(Ca^{-4}\). The respective +input \(L^1\) bounds on this region are \(Ca^3\) and \(Ca^4\), +again giving \(C/a\) and \(C\). + +On the more distant shells about \(x\), with radius +\(\rho\ge Ca\), the kernel is \(O(\rho^{-4})\), the input +bounds are \(C/\rho\) and \(C\), and the shell volume is +\(O(\rho^4)\). Summation over dyadic shells gives \(C/a\) +and \(C(1+|\log a|)\). The logarithmic input has uniformly +bounded total \(L^1\) norm, since its local integral is at most +\(C\int_0^{\rho_0}\rho^3/(s+\rho)\dd\rho\le C\rho_0^3\). +The square-root input has bounded \(L^1\) norm as well. +Thus the remaining smooth kernel terms are bounded uniformly. +The same decomposition gives uniform bounds +when \(y\) stays a fixed distance from the center. +Compactness makes all chart and operator constants uniform +in \(x\). +\end{proof} + +\begin{proof}[Proof of Proposition~\ref{prop:growth}] +In the normal coordinates of Lemma~\ref{lem:radial-correction}, +let \(J_0=J(x)\) be the constant complex structure, orthogonal +for the Euclidean metric at the center. On the inner ball, +the Hessians of the two radial functions are +\[ +\frac{I}{s^2+t^2}-\frac{2zz^\top}{(s^2+t^2)^2}, +\qquad +\frac{I}{\sqrt{s^2+t^2}}-\frac{zz^\top}{(s^2+t^2)^{3/2}}. +\] +Since +\((z\cdot v)^2+(z\cdot J_0v)^2\le t^2|v|^2\), their +complex-line traces satisfy +\begin{align} +dd^c_{J_0}u_s(v,J_0v) +&\ge\frac{2s^2|v|^2}{(s^2+t^2)^2},\label{eq:log-trace}\\ +dd^c_{J_0}h_s(v,J_0v) +&\ge\frac{|v|^2}{\sqrt{s^2+t^2}}.\label{eq:sqrt-trace} +\end{align} +The first lower bound is nonnegative everywhere and at least +\(c/s^2\) for \(t0\). In the second estimate the logarithmic +correction is absorbed by the positive inverse-distance +term on a sufficiently small fixed neighborhood. +Choose a fixed \(A>0\) large enough to absorb the negative +term in the first estimate. Outside that neighborhood all +terms are uniformly bounded. We obtain globally +\[ +D(u_s+Ah_s)(v,Jv)\ge +\frac{c}{s^2}\ind_{B_s(x)}-C' +\] +for all unit \(v\) and small \(s\). + +The form on the left is closed and invariant. Applying \(P\), +which annihilates it, and using \(\mu(X)=1\), gives +\(0\ge cs^{-2}\mu(B_s(x))-C'\). +This proves \eqref{eq:growth} for small \(s\). Increasing +the constant handles all larger radii. +\end{proof} diff --git a/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/04-energy.tex b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/04-energy.tex new file mode 100644 index 0000000000000000000000000000000000000000..61b7bebe67aab8f589b9b960065d46007671ff83 --- /dev/null +++ b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/04-energy.tex @@ -0,0 +1,270 @@ +\section{Regularization and angular control}\label{sec:energy} + +We now combine quadratic mass growth with regularized current +pairings to prove that \(Q\in L^2\) and to control the variation +of nearby complex-line directions. These are the remaining +quantitative inputs to the density-splitting theorem. + +Let \(\Delta=dd^*+d^*d\) be the Hodge Laplacian, and set +\[ +S_r=(1+r^2\Delta)^{-3},\qquad 00\). After subtracting the displayed term, +the short-time remainder has the bound +\begin{equation}\label{eq:heat-remainder} +Ct^{-1}e^{-c_0d_g(x,y)^2/t}+C_Mt^M,\qquad 00\}\), the +current \(P_E=\ind_EP\) is closed. +\end{theorem} + +For positive currents that are already closed, Elkhadhra proves +that restriction to a \(J\)-analytic subset remains closed +\cite[Section~3.2, Lemma~1, author version]{Elkhadhra2014}. +Here only \(P+Q\) is initially closed, and the positive-density +set is not assumed to be \(J\)-analytic; the mass and angular +estimates provide the cutoff control needed for the restriction. + +Throughout this section and Section~\ref{sec:splitting}, assume +the hypotheses of Theorem~\ref{thm:splitting}, and write \(T=P+Q\). +We continue to write \(\ang_r\) for the left side of +\eqref{eq:abstract-angular}. We first establish the density +limit and show that, at \(\mu\)-almost every positive-density point, +the current has planar tangent measures. This makes the average +transverse displacement small without supplying a rate. +Section~\ref{sec:splitting} combines that smallness with the +angular bound to prove closedness. + +\begin{lemma}\label{lem:density} +The two-density \(\theta(p)\) exists and is finite at every +\(p\in X\). +\end{lemma} + +The radial comparison is in the tradition of Lelong--Jensen +formulas for almost complex currents; see +\cite[Proposition~1 and Corollary~2]{ElkhadhraMimouni2007}. +We apply closure to \(P+Q\) and estimate the \(L^2\) correction +directly. + +\begin{proof} +The current \(T\) has measure coefficients with variation +bounded by a constant times +\(\sigma=\mu+|Q|\,dV_g\). Cauchy--Schwarz and +\eqref{eq:abstract-growth} give +\[ +\sigma(B_s(p))\le Cs^2, +\] +uniformly in \(p\). + +In normal coordinates \(z\) at \(p\), let \(J_0=J(p)\) and +\(F_0=F_p\) be constant, and put \(t=|z|=d_g(p,y)\). +Our sign convention gives +\(dd^c_{J_0}(t^2/2)=2F_0\). Call a radius \emph{good} if its sphere is +\(\sigma\)-null. For good radii define +\[ +b(r)=r^{-2}T(\ind_{B_r(p)}F_0). +\] +These pairings are well-defined using the coefficient +measures. We claim that +\begin{equation}\label{eq:density-identity} +b(s)-b(r)=\tfrac12 +T\bigl(\ind_{\{r0\). +The locally rescaled measures +\[ +\nu_r=r^{-2}(z_p/r)_*\mu +\] +have uniformly bounded mass on each compact subset of +\(T_pX\), so every sequence of scales has a vaguely +convergent subsequence. Every limit \(\nu\) satisfies +\begin{equation}\label{eq:tangent-ball} +\nu(B_D(0))=\theta(p)D^2\qquad(D>0). +\end{equation} +Initially the identity follows at continuity radii of +\(\nu\). Increasing continuity radii recover the mass of +each open ball, while decreasing continuity radii recover +the corresponding closed ball. Both masses are +\(\theta(p)D^2\), so the identity holds for every \(D>0\) +and every centered sphere is \(\nu\)-null. + +The current and measure rescalings have the same normalization. +Indeed, put \(D_r(y)=z_p(y)/r\). For a compactly supported +test two-form \(\beta=\sum_{iD_1\), the difference of these integrands is +nonnegative and strictly positive at every +\(0<|w|0. +\] +The quadratic growth bound supplies domination for this +limit. In particular \(\theta\) is Borel measurable. +Differentiation of the finite measure \(\mu\) with respect +to four-dimensional volume also shows that +\begin{equation}\label{eq:theta-volume} +\theta(x)=0\quad\text{for volume-almost every }x. +\end{equation} +Indeed, apply the differentiation theorem for Radon measures +\cite[Theorem~4.19]{Kinnunen2026} in a fixed coordinate chart, +with smooth volume as the denominator measure. At +volume-almost every center the measure-to-volume ratios +of sufficiently small coordinate balls are bounded. +Enclosing a geodesic ball of radius \(r\) in a coordinate +ball of comparable radius therefore gives +\(\mu(B_r(x))=O_x(r^4)\), and hence +\(r^{-2}\mu(B_r(x))\to0\). + +\subsection*{The error from the \(L^2\) correction} + +Put \(M_r(x)=\mu(B_r(x))\). Cauchy--Schwarz gives +\begin{align} +r^{-3}\int_X|Q|M_r\vol +&\le +\left(\int_X|Q|^2r^{-2}M_r\vol\right)^{1/2} +\left(\int_Xr^{-4}M_r\vol\right)^{1/2} +\longrightarrow0. +\label{eq:q-cutoff} +\end{align} +For the second factor, Fubini and the four-dimensional +volume bound give +\[ +\int_Xr^{-4}M_r(x)\,dV_g(x) +=r^{-4}\int_X\operatorname{vol}_g(B_r(y))\dd\mu(y) +\le C\mu(X). +\] +For the first, \(r^{-2}M_r\) is bounded and tends to zero +volume-almost everywhere by \eqref{eq:theta-volume}. +Dominated convergence applies to \(|Q|^2\). + +First variation gives \(|df_r(x)|\le Cr^{-3}M_r(x)\). +Thus \eqref{eq:q-cutoff} also proves +\begin{equation}\label{eq:q-full-derivative} +\int_X|Q|\,|df_r|\vol\longrightarrow0. +\end{equation} + +\subsection*{Tangential derivatives of the density cutoff} + +We prove the complementary estimate +\begin{equation}\label{eq:tangential-cutoff} +\int_{\mathscr C}|df_r(x)|_{L_\ell}\dd\lambda(x,\ell) +\longrightarrow0, +\end{equation} +where the subscript means restriction of the covector to +the two-plane \(L_\ell\). + +For \((x,\ell)\in\mathscr C\), \(y\in B_r(x)\), and +\(m\in\mathscr C_y\), put +\[ +z=z_x(y),\qquad z^\perp=\pr_{L_\ell^\perp}z, +\qquad \delta=|\ell-\tau_{yx}m|. +\] +These quantities measure different errors +(Figure~\ref{fig:cutoff-geometry}). Closedness will replace a +derivative along \(L_\ell\) by normal derivatives. Differentiating +the radial kernel normally contributes \(|z^\perp|/r\), while +the resulting mixed two-forms contribute \(\delta\). +Keeping these factors together is what makes their integrated +product overcome the cutoff's \(r^{-3}\) normalization. + +\begin{figure}[tb] +\centering +\begin{tikzpicture}[>=stealth, line cap=round, line join=round, + font=\small, scale=0.95] + \begin{scope} + \node at (0.2,2.25) {Displacement in \(T_xX\)}; + \filldraw[fill=blue!7, draw=blue!35] + (-1.6,-0.6) -- (1.5,-0.6) -- (2.15,0.2) -- (-0.95,0.2) -- cycle; + \node[blue!60!black] at (-1.0,-0.37) {\(L_\ell\)}; + \coordinate (O) at (0,0); + \coordinate (Zt) at (1.05,-0.12); + \coordinate (Z) at (1.05,1.45); + \draw[->,thick,blue!65!black] (O) -- (Zt); + \draw[->,thick,black!80] (O) -- (Z) + node[midway,left] {\(z/r\)}; + \draw[->,thick,red!65!black] (Zt) -- (Z) + node[midway,right] {\(z^\perp/r\)}; + \fill (O) circle (1.4pt); + \node[below left] at (O) {\(0\)}; + \fill (Zt) circle (1.2pt); + \fill (Z) circle (1.2pt); + \node at (0.2,-1.05) {\(L_\ell+\R z^\perp\subset T_xX\)}; + \end{scope} + \begin{scope}[xshift=6.5cm] + \node at (0.45,2.25) {Chord in \(\Lambda^2T_xX\)}; + \coordinate (O) at (0,0); + \coordinate (A) at (1.6,0); + \coordinate (B) at (65:1.6); + \draw[densely dashed,black!30] (1.6,0) arc (0:78:1.6); + \draw[->,thick,blue!65!black] (O) -- (A); + \draw[->,thick,blue!65!black] (O) -- (B); + \draw[thick,red!65!black] (A) -- (B) + node[midway,right] {\(\delta\)}; + \node[below] at (A) {\(\ell\)}; + \node[above left] at (B) {\(\tau_{yx}m\)}; + \fill (O) circle (1.4pt); + \node[below left] at (O) {\(0\)}; + \node at (0.45,-0.62) {\(|\ell|=|\tau_{yx}m|=1\)}; + \node at (0.45,-1.05) {\(1-\ip{\ell}{\tau_{yx}m}=\delta^2/2\)}; + \end{scope} +\end{tikzpicture} +\caption{The two factors in the tangential cutoff estimate. +The left panel lies in the subspace spanned by \(L_\ell\) and +the normal displacement. The right panel lies in the span of +two unit bivectors, in a different ambient vector space. +Closedness produces the product \(\delta|z^\perp|/r\). +The squared integrals of its factors are \(\ang_r=O(r^4)\) +and \(\trans_r=o(r^2)\), respectively.} +\label{fig:cutoff-geometry} +\end{figure} + +Fix \((x,\ell)\). Choose orthonormal normal coordinates +\(z=z_x(y)\) with \(\ell=e_1\wedge e_2\), and put +\(h_r(z)=h(|z|^2/r^2)\). +At the fixed center \(x\), first variation of squared +distance gives +\(d_x[d_g(x,y)^2](e_i)=-2z_i\). Hence, for \(i=1,2\), +\begin{equation}\label{eq:center-derivative} +df_r(x)e_i=-r^{-2}\int_X\partial_{z_i}h_r\dd\mu(y). +\end{equation} +This differentiates the scalar distance kernel. We now +freeze \(x,\ell\), and these coordinates, and use closedness +of \(T\) in the \(y\) variable. + +Coordinate covectors in normal coordinates differ from +radially parallel covectors by \(O(|z|^2)\). Indeed, the +Jacobi equation along \(t\mapsto\exp_x(tz)\), in a parallel +frame, has curvature coefficient \(O(|z|^2)\). The field +with initial data \((0,v)\) is therefore +\(tv+O(|z|^2|v|)\) for \(0\le t\le1\), giving +\(\tau_{yx}\circ d(\exp_x)_z=\Id+O(|z|^2)\). +Inverting gives the same estimate for coordinate covectors. +Since both line bivectors have norm one, +\begin{equation}\label{eq:quadratic-coordinate} +(dz_1\wedge dz_2)(m) +=\ip{\ell}{\tau_{yx}m}+O(r^2) +=1-\tfrac12\delta^2+O(r^2)\qquad(|z|0\}}P\) +is closed. Set +\[ +P'=\ind_{X\setminus E}P,\qquad +T'=P'+Q=T-P_E. +\] +Then \(T'\) is closed. The current \(P'\) is represented +by the restriction \(\lambda'\le\lambda\) to base points +outside \(E\), with projection +\(\mu'=\ind_{X\setminus E}\mu\). +We pair \(T\) with this residual current rather than with itself: +placing the second positive factor on zero-density centers makes +the previously bounded negative error in the pairing tend to zero. + +We first show that the negative term in +\eqref{eq:positive-pairing} tends to zero for this +choice of \(P'\). For each \(y\notin E\), +\begin{equation}\label{eq:zero-density-tail} +r^{-2}\int_X(1+d_g(x,y)/r)^{-6}\dd\mu(x) +\longrightarrow0. +\end{equation} +On the inner ball and on every fixed dyadic shell this +follows from \(s^{-2}\mu(B_s(y))\to0\). +The quadratic mass bound dominates the shell contributions +by \(C2^{-4j}\), a summable sequence, giving the full +limit. The uniform bound \eqref{eq:shell} then permits +dominated convergence against \(\mu'\). +Discarding the nonnegative angular term in +\eqref{eq:positive-pairing} yields +\begin{equation}\label{eq:liminf} +\liminf_{r\downarrow0}\ip{S_rP}{*S_rP'}_{L^2}\ge0. +\end{equation} + +Apply Lemma~\ref{lem:zero-pairing} to \(T'\). +Its regularizations are in \(L^2\), since \(P'\) has +measure coefficients and \(Q\in L^2\). +Expanding gives +\[ +0=\ip{S_rP}{*S_rP'} ++\ip{S_rP}{*S_rQ} ++\ip{S_rQ}{*S_rP'} ++\|S_rQ\|_2^2. +\] +Both mixed terms tend to zero by +\eqref{eq:cross-vanish}, applied once to \(P\) and once +to \(P'\). Since \(S_rQ\to Q\) strongly in \(L^2\), +\eqref{eq:liminf} implies \(0\ge\|Q\|_2^2\). +Therefore \(Q=0\). + +It follows that \(P=T\) annihilates all smooth closed +forms. In particular \(P(\omega)=0\). On the other +hand, \(\omega_x(\ell)>0\) on the compact bundle +\(\mathscr C\); it has a positive minimum there. +Equation~\eqref{eq:positive-representation} and +\(\lambda(\mathscr C)=1\) give \(P(\omega)>0\), +a contradiction. + +The positive cone and the subspace of closed invariant +smooth forms therefore intersect. Any form in their +intersection is the required smooth compatible +symplectic form for \(J\). +\end{proof} diff --git a/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/08-cones.tex b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/08-cones.tex new file mode 100644 index 0000000000000000000000000000000000000000..14255b791ced4ab3992f44118865b2ab5204da98 --- /dev/null +++ b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/build/sections/08-cones.tex @@ -0,0 +1,418 @@ +\section{The compatible cone}\label{sec:cones} + +The distinction between existence and realization of a specified class +appears in the separating functional. For existence, it annihilates all +closed invariant forms. For a specified class, it need only annihilate +exact invariant forms. We first establish the estimates in this setting, +then identify the classes of the resulting currents. + +\subsection{Invariant representatives and separation} + +We retain the Hermitian metric, the projection \(R\), and the closed +lift \(B=dd^*G+H\) of Lemma~\ref{lem:lift}. +For a closed current \(D\), let +\(\mathfrak c(D)\in H^2(X;\R)\) denote its intersection-dual class: +\[ + D(\alpha)=\mathfrak c(D)\cdot[\alpha] + \quad\text{for every smooth closed two-form }\alpha. +\] +Equivalently, \(\mathfrak c(D)\) is represented by the Hodge star of +the harmonic part of the distributional two-form associated with \(D\). + +\begin{lemma}\label{lem:invariant-cohomology} +The classes represented by closed invariant forms are exactly +\(\mathcal V=(H_J^-)^\perp\). The intersection form is positive +definite on \(H_J^-\), and +\[ + H^2(X;\R)=\mathcal V\oplus H_J^-. +\] +The operator \(1-BR\) takes exact forms to exact invariant forms. +\end{lemma} + +\begin{proof} +Closed anti-invariant forms are self-dual, hence harmonic. Their +intersection pairing is their \(L^2\) inner product, so it is positive +definite on their classes. Invariant and anti-invariant forms wedge to +zero pointwise. + +For any closed two-form \(\alpha\), the form +\((1-BR)\alpha\) is closed and invariant, and +\[ + [\alpha]=[(1-BR)\alpha]+[HR\alpha], +\] +because \(BR\alpha=dd^*GR\alpha+HR\alpha\). The second summand +is represented by a closed anti-invariant form. The two subspaces are +orthogonal, and positive definiteness on the second makes their +intersection zero. This proves the decomposition and the assertion +about \(\mathcal V\). + +If \(\alpha\) is exact, it is \(L^2\)-orthogonal to every harmonic +form. For a harmonic anti-invariant form \(\beta\), +\(\ip{R\alpha}{\beta}_{L^2}=\ip{\alpha}{\beta}_{L^2}=0\). +Thus \(HR\alpha=0\), and both \(BR\alpha\) and +\((1-BR)\alpha\) are exact. +\end{proof} + +A current is called \emph{positive} here if it annihilates +anti-invariant forms and is nonnegative on pointwise semipositive +invariant forms. As in Proposition~\ref{prop:separation}, it has a +representation by a finite positive measure on \(\mathscr C\). +Its trace measure is the projection to \(X\). + +\begin{lemma}[Prescribed-class separation]\label{lem:class-separation} +Let \(a\in\mathcal V\) have no compatible representative. There +are currents \(P,Q,T\in H^{-3}\), with \(P\) nonzero and positive, +such that +\begin{gather} + P(F)=1,\qquad P\text{ annihilates exact invariant forms}, + \label{eq:class-exact-tests}\\ + T=P+Q\text{ is closed},\qquad RQ=Q=*Q, + \label{eq:class-current}\\ + \mathfrak c(T)\in\mathcal V,\qquad + \mathfrak c(T)\cdot a\le0. + \label{eq:class-separator-sign} +\end{gather} +Moreover, a class \(b\in H^2(X;\R)\) is taming if and only if +\[ + b\cdot\mathfrak c(N)>0 + \quad\text{for every nonzero closed positive current }N. +\] +\end{lemma} + +\begin{proof} +By Lemma~\ref{lem:invariant-cohomology}, the closed invariant +representatives of \(a\) form a nonempty affine space. Separate +this affine space from the open cone of positive invariant forms +in the Fr\'echet space of smooth invariant forms. Hahn--Banach +separation gives a nonzero continuous functional, nonnegative on +the positive cone and nonpositive on the affine space. It vanishes +on the direction space, which consists of exact invariant forms. +Indeed, translating by any real multiple of a direction preserves +the affine space, while positive scalings preserve the cone. +Extend the functional by \(1-R\) and normalize it as in +Proposition~\ref{prop:separation} to obtain \(P(F)=1\). +The same positivity argument gives its measure representation. + +Define \(T(\alpha)=P((1-BR)\alpha)\) and +\(Q(\alpha)=-P(BR\alpha)\). Lemma~\ref{lem:invariant-cohomology} +shows that \(T\) annihilates every exact form, so it is closed. +The projection identities give \(RQ=Q=*Q\). A closed +anti-invariant form \(\beta\) lies in the kernel of the operator +used to construct \(G\); hence \(B\beta=\beta\) and +\(T(\beta)=0\). Thus \(\mathfrak c(T)\in\mathcal V\). +On a closed invariant representative of \(a\), the currents +\(T\) and \(P\) agree, proving \eqref{eq:class-separator-sign}. +The Sobolev assertion follows from the measure representation and +the order-zero lift, as in Proposition~\ref{prop:separation}. + +For the last statement, a taming representative evaluates strictly +positively on every nonzero positive current. Conversely, if \(b\) +has no taming representative, separate its affine space of closed +representatives from the open cone of forms positive on complex +lines. The separator annihilates all exact forms. Since arbitrary +anti-invariant forms can be added to that cone, it also annihilates +all anti-invariant forms. It is therefore a nonzero closed positive +current \(N\), and \(b\cdot\mathfrak c(N)\le0\). +\end{proof} + +\subsection{Pairings for currents of arbitrary class} + +\begin{lemma}\label{lem:cohomological-pairing} +For closed currents \(D_1,D_2\in H^{-3}\), +\begin{equation}\label{eq:cohomological-pairing} + \ip{S_rD_1}{*S_rD_2}_{L^2} + =\mathfrak c(D_1)\cdot\mathfrak c(D_2). +\end{equation} +\end{lemma} + +\begin{proof} +The forms \(*S_rD_i\) lie in \(H^3\), are distributionally closed, +and have the harmonic components representing \(\mathfrak c(D_i)\). +Here we use commutation with \(d^*,*\), and the fact that \(S_r\) +is the identity on harmonic forms. Their heat regularizations are +smooth closed representatives of these classes. The intersection +identity for smooth forms passes to the limit in \(L^2\). +In degree two on a four-manifold, +\(\alpha\wedge\beta=(*\alpha)\wedge(*\beta)\), giving +\eqref{eq:cohomological-pairing}. +\end{proof} + +We record the estimates that apply to the separator in +Lemma~\ref{lem:class-separation}. In the next proposition, positive +currents are not required to have any prescribed cohomology class. + +\begin{proposition}\label{prop:class-estimates} +Suppose that \(P\ne0\) is positive, annihilates exact invariant +forms, and \(T=P+Q\) is closed, where \(Q\in H^{-3}\) is +anti-invariant. Write \(\lambda\) for a positive measure representing +\(P\), and \(\mu\) for its trace. Then +\begin{gather} + \mu(B_s(x))\le Cs^2,\qquad Q\in L^2, + \label{eq:class-growth}\\ + \iint_{d_g(x,y)0\}\). + +If \(A\) is any positive current whose trace has quadratic growth, +then +\begin{equation}\label{eq:class-mixed-limit} + \lim_{r\downarrow0}\ip{S_rA}{*S_rQ}_{L^2}=0. +\end{equation} +Every closed positive current has quadratic trace growth. +\end{proposition} + +\begin{proof} +Each radial test \(Du=(1-BR)dd_J^cu\) in +Section~\ref{sec:mass} is exact by +Lemma~\ref{lem:invariant-cohomology}. Its pointwise estimates +therefore give the quadratic growth bound under the present +annihilation hypothesis. The normalization \(P(F)=1\) is inessential: +for arbitrary finite mass it only changes the constant. In particular, +this argument applies to every closed positive current. + +We will use the kernel estimates for any pair \(A_1,A_2\) of positive +currents with quadratic-growth trace measures \(\mu_1,\mu_2\). +Write \(\lambda_1,\lambda_2\) for their representing measures. +The proof of Lemma~\ref{lem:positive-pairing}, using +Lemma~\ref{lem:kernel} and \eqref{eq:angular-identity}, gives +\begin{align} + \|S_rA_i\|_2&\le C_i r^{-1},\label{eq:general-smoothed-mass}\\ + \ip{S_rA_1}{*S_rA_2}_{L^2} + &\ge cr^{-4}\iint_{d0\) for every +\(\eps>0\). The last part of Lemma~\ref{lem:class-separation} +shows that \(y+\eps a\) is taming. It also lies in \(\mathcal V\), +so \(y+\eps a\in\mathcal C\), proving the claim. + +It follows that \(a\cdot y\ge0\), with strict inequality if +\(y\ne0\). If \(P'\ne0\), then \(y\ne0\). To see this, +suppose \(y=0\) and pair \(T'\) with itself using +\eqref{eq:cohomological-pairing}. We obtain +\[ + 0=\ip{S_rP'}{*S_rP'}+2\ip{S_rP'}{*S_rQ}+\|S_rQ\|_2^2. +\] +The residual lemma, the mixed-term limit, and strong \(L^2\) +convergence of \(S_rQ\) force \(Q=0\). Then the nonzero positive +current \(P'=T'\) evaluates strictly positively on a closed tamer, +contrary to \(\mathfrak c(T')=0\). + +Finally, a taming representative of \(a\) gives +\(a\cdot\mathfrak c(P_E)\ge0\), strictly if \(P_E\ne0\). +At least one of \(P_E,P'\) is nonzero. Therefore +\[ + a\cdot\mathfrak c(T) + =a\cdot\mathfrak c(P_E)+a\cdot y>0, +\] +contradicting \eqref{eq:class-separator-sign}. This proves +\eqref{eq:compatible-duality}. +\end{proof} + +\begin{proof}[Proof of Corollary~\ref{cor:taming-cones}] +The subspace \(H_J^-\) is positive definite, while its orthogonal +complement \(\mathcal V\) contains the nonempty positive-square +cone \(\mathcal C\). Hence \(h_J^-\le b_2^+-1\). If equality +holds, the intersection form on \(\mathcal V\) has signature +\((1,b_2^-)\). Convexity puts \(\mathcal C\) in one component +of its positive-square cone. Every element of that component pairs +strictly positively with every nonzero element of its closure, +by Cauchy--Schwarz in coordinates of signature +\((+,-,\ldots,-)\). Thus all \(a\in\mathcal C\) satisfy +\eqref{eq:compatible-duality}, and +\(\mathcal C=\mathcal K_J^c\). Equation +\eqref{eq:tame-decomposition} gives the asserted identity. +If \(b_2^+=1\), the inequality forces \(h_J^-=0\), proving the +last assertion. +\end{proof} + +\begin{example}[Strict inclusion on the four-torus]\label{ex:strict-cones} +On \(X=\R^4/\mathbb Z^4\), use the Euclidean metric and standard +orientation, and put \(e^{ij}=dx_i\wedge dx_j\). Set +\[ + U=e^{12}+e^{34},\qquad V_0=e^{13}-e^{24},\qquad + W=e^{14}+e^{23}, +\] +\[ + f=\tfrac14\sin(2\pi x_1),\qquad + k=\tfrac14\sin(2\pi x_2),\qquad + r=(1+f^2+k^2)^{1/2}. +\] +The form \(F=(U+fV_0+kW)/r\) is self-dual and has squared norm +two, so it is the fundamental form of a smooth orthogonal almost +complex structure \(J\) of this orientation. The form +\[ + \eta=U+2f e^{13}+2k e^{23} +\] +is closed. Its self-dual part is \(rF\), so it is invariant, and +its anti-self-dual part is +\[ + f(e^{13}+e^{24})+k(e^{23}-e^{14}). +\] +Its Hermitian eigenvalues are \(r\pm\sqrt{f^2+k^2}>0\). +Thus \(\eta\) is compatible. The sine terms are exact, giving +\([\eta]=[U]\). + +A closed anti-invariant form is self-dual and harmonic for the flat +metric, hence is a constant combination \(aU+bV_0+cW\). +Orthogonality to \(F\) gives \(a+bf+ck=0\) everywhere. Varying +\(x_1,x_2\) yields \(a=b=c=0\); thus \(H_J^-=0\). +The closed forms \(U\pm V_0\) have invariant projections +\((1\pm f)F/r\), so both tame \(J\). Their classes pair to zero, +since \(U^2=V_0^2\). Neither class can have a compatible +representative, which would wedge strictly positively with a tamer +in the other class. Hence +\[ + \mathcal K_J^c+H_J^-=\mathcal K_J^c + \subsetneq\mathcal K_J^t. +\] +In Theorem~\ref{thm:taming-cones}, the class \([U+V_0]\) fails +the strict positivity test against \([U-V_0]\in\mathcal C\), +and conversely. +\end{example} diff --git a/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/paper.pdf b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..de152659c5ff6897d6a070975187a93dbdd396b3 --- /dev/null +++ b/preprints/Taming-implies-compatibility-on-four-manifolds-October-6-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbddc627efab3dd49a69a32b270b52b6ea4528846bd3b313038a696ed3281265 +size 249763 diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/README.md b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8bc1d1ce25ff549724af954d82a8cd65771bfb35 --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [Termination of generalized-canonical flips on compact Kähler fourfolds](termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026, + author = {{OpenAI}}, + title = {{Termination of generalized-canonical flips on compact K{\"a}hler fourfolds}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf}{OAI:Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version clarifies that only independent negativity, codimension-two smoothness, and cycle-comparison results are used from the companion fourfold paper; see the [previous version](../Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-5-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf). diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/paper.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/paper.tex new file mode 100644 index 0000000000000000000000000000000000000000..95801b3760a7e2c31f709751bbaaa740ad55670f --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/paper.tex @@ -0,0 +1,51 @@ +\newcommand{\DoNotLoadEpstopdf}{} +\documentclass[11pt]{article} +\ifdefined\pdfinfoomitdate\pdfinfoomitdate=1\fi +\ifdefined\pdftrailerid\pdftrailerid{}\fi +\ifdefined\pdfsuppressptexinfo\pdfsuppressptexinfo=15\fi +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{microtype,xcolor} +\usepackage{xurl} +\usepackage[colorlinks=true,linkcolor=blue!50!black,citecolor=blue!50!black,urlcolor=blue!50!black]{hyperref} +\hypersetup{pdftitle={Termination of generalized-canonical flips on compact Kahler fourfolds},pdfauthor={OpenAI}} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newtheorem{example}[theorem]{Example} +\newcommand{\R}{\mathbb R} +\newcommand{\Q}{\mathbb Q} +\newcommand{\Z}{\mathbb Z} +\newcommand{\N}{\mathbb N} +\newcommand{\C}{\mathbb C} +\newcommand{\bM}{\mathbf M} +\newcommand{\dd}{\mathrm d} +\DeclareMathOperator{\Exc}{Exc} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\codim}{codim} +\DeclareMathOperator{\id}{id} +\DeclareMathOperator{\mult}{mult} +\DeclareMathOperator{\rank}{rank} +\DeclareMathOperator{\ord}{ord} +\setlength{\emergencystretch}{1em} +\title{Termination of generalized-canonical flips\\on compact K\"ahler fourfolds} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\maketitle +\input{sections/01-introduction} +\input{sections/02-foundations} +\input{sections/03-comparison} +\input{sections/04-low-places} +\input{sections/05-witnesses} +\input{sections/06-cycles} +\input{sections/07-termination} +\input{references} +\end{document} diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/references.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/references.tex new file mode 100644 index 0000000000000000000000000000000000000000..1cef90cc1ce0f5bf5f365f46ecc7744e34be95b0 --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/references.tex @@ -0,0 +1,134 @@ +\begin{thebibliography}{99} +\raggedright + +\bibitem{BierstoneMilman1997} +Edward Bierstone and Pierre D.~Milman, +\emph{Canonical desingularization in characteristic zero by blowing up the +maximum strata of a local invariant}, +Inventiones Mathematicae \textbf{128} (1997), no.~2, 207--302. +\href{https://doi.org/10.1007/s002220050141}{doi:10.1007/s002220050141}. + +\bibitem{BirkarZhang2016} +Caucher Birkar and De-Qi Zhang, +\emph{Effectivity of Iitaka fibrations and pluricanonical systems of polarized pairs}, +Publications Math\'ematiques de l'IH\'ES \textbf{123} (2016), 283--331. +\href{https://doi.org/10.1007/s10240-016-0080-x}{doi:10.1007/s10240-016-0080-x}. + +\bibitem{BorelHaefliger1961} +Armand Borel and Andr\'e Haefliger, +\emph{La classe d'homologie fondamentale d'un espace analytique}, +Bulletin de la Soci\'et\'e Math\'ematique de France \textbf{89} (1961), 461--513. +\href{https://doi.org/10.24033/bsmf.1571}{doi:10.24033/bsmf.1571}. + +\bibitem{ChenTsakanikas2023} +Guodu Chen and Nikolaos Tsakanikas, +\emph{On the termination of flips for log canonical generalized pairs}, +Acta Mathematica Sinica, English Series \textbf{39} (2023), no.~6, 967--994. +\href{https://doi.org/10.1007/s10114-023-0116-3}{doi:10.1007/s10114-023-0116-3}. +Theorem numbering follows \href{https://arxiv.org/abs/2011.02236v2}{arXiv:2011.02236v2}. + +\bibitem{DHP2024} +Omprokash Das, Christopher Hacon, and Mihai P\u{a}un, +\emph{On the $4$-dimensional minimal model program for K\"ahler varieties}, +Advances in Mathematics \textbf{443} (2024), article~109615. +\href{https://doi.org/10.1016/j.aim.2024.109615}{doi:10.1016/j.aim.2024.109615}. +Theorem numbering follows \href{https://arxiv.org/abs/2205.12205v3}{arXiv:2205.12205v3}. + +\bibitem{Fujino2004} +Osamu Fujino, +\emph{Termination of 4-fold canonical flips}, +Publications of the Research Institute for Mathematical Sciences +\textbf{40} (2004), no.~1, 231--237. +\href{https://doi.org/10.2977/PRIMS/1145475971}{doi:10.2977/PRIMS/1145475971}. + +\bibitem{Fujino2005Addendum} +Osamu Fujino, +\emph{Addendum to ``Termination of 4-fold canonical flips''}, +Publications of the Research Institute for Mathematical Sciences +\textbf{41} (2005), no.~1, 251--257. +\href{https://doi.org/10.2977/PRIMS/1145475410}{doi:10.2977/PRIMS/1145475410}. + +\bibitem{FujinoAnalytic2022} +Osamu Fujino, +\emph{Minimal model program for projective morphisms between complex +analytic spaces}, +preprint, 2022. +\href{https://arxiv.org/abs/2201.11315v1}{arXiv:2201.11315v1}. + +\bibitem{Goresky1978} +R.~Mark Goresky, +\emph{Triangulation of stratified objects}, +Proceedings of the American Mathematical Society +\textbf{72} (1978), no.~1, 193--200. + +\bibitem{Grauert1962} +Hans Grauert, +\emph{\"Uber Modifikationen und exzeptionelle analytische Mengen}, +Mathematische Annalen \textbf{146} (1962), 331--368. +\href{https://doi.org/10.1007/BF01441136}{doi:10.1007/BF01441136}. + +\bibitem{Greb2011} +Daniel Greb, +\emph{Rational singularities and quotients by holomorphic group actions}, +Annali della Scuola Normale Superiore di Pisa, Classe di Scienze (5) +\textbf{10} (2011), no.~2, 413--426. +\href{https://www.numdam.org/item/ASNSP_2011_5_10_2_413_0/}{Numdam:ASNSP\_2011\_5\_10\_2\_413\_0}. + +\bibitem{HX2026} +Christopher Hacon and Lingyao Xie, +\emph{On the K\"ahler MMP and the transcendental base-point-free theorem}, +preprint, 2026. +\href{https://arxiv.org/abs/2607.24986v1}{arXiv:2607.24986v1}. + +\bibitem{KMM1987} +Yujiro Kawamata, Katsumi Matsuda, and Kenji Matsuki, +\emph{Introduction to the minimal model problem}, +in \emph{Algebraic Geometry, Sendai, 1985}, +Advanced Studies in Pure Mathematics, vol.~10, +Kinokuniya and North-Holland, 1987, pp.~283--360. +\href{https://doi.org/10.2969/aspm/01010283}{doi:10.2969/aspm/01010283}. + +\bibitem{Mather1970} +John Mather, +\emph{Notes on topological stability}, +Harvard University lecture notes, July 1970. +Published in Bulletin of the American Mathematical Society (N.S.) +\textbf{49} (2012), no.~4, 475--506. +\href{https://doi.org/10.1090/S0273-0979-2012-01383-6}{doi:10.1090/S0273-0979-2012-01383-6}. + +\bibitem{Moraga2025} +Joaqu\'in Moraga, +\emph{Termination of pseudo-effective 4-fold flips}, +Mathematische Zeitschrift \textbf{310} (2025), article~73. +\href{https://doi.org/10.1007/s00209-025-03766-y}{doi:10.1007/s00209-025-03766-y}. + +\bibitem{OrdinaryKahler} +OpenAI, +\emph{Finite ordinary minimal model programs on compact K\"ahler fourfolds}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-September-24-2026/paper.pdf}{OAI:Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-September-24-2026}, +2026. + +\bibitem{RSW2017} +Jean Ruppenthal, H{\aa}kan Samuelsson Kalm, and Elizabeth Wulcan, +\emph{Explicit Serre duality on complex spaces}, +Advances in Mathematics \textbf{305} (2017), 1320--1355. +\href{https://doi.org/10.1016/j.aim.2016.10.013}{doi:10.1016/j.aim.2016.10.013}. +Page references follow \href{https://arxiv.org/abs/1401.8093v2}{arXiv:1401.8093v2}. + +\bibitem{Teissier1982} +Bernard Teissier, +\emph{Vari\'et\'es polaires.~II. Multiplicit\'es polaires, sections planes, +et conditions de Whitney}, +in \emph{Algebraic Geometry (La R\'abida, 1981)}, +Lecture Notes in Mathematics, vol.~961, +Springer, 1982, pp.~314--491. + +\bibitem{Wang2021} +Juanyong Wang, +\emph{On the Iitaka conjecture $C_{n,m}$ for K\"ahler fibre spaces}, +Annales de la Facult\'e des Sciences de Toulouse, Math\'ematiques (6) +\textbf{30} (2021), no.~4, 813--897. +\href{https://doi.org/10.5802/afst.1690}{doi:10.5802/afst.1690}. + +\end{thebibliography} diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/01-introduction.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..725634de5082cdd90439ea49cff5055fb7a9defe --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/01-introduction.tex @@ -0,0 +1,273 @@ +\begin{abstract} +Every sequence of generalized-canonical flips on compact K\"ahler +fourfolds with rational boundary and fixed rational analytically nef +b-divisor terminates when the small morphisms are projective. We prove +this for normal globally Weil $\Q$-factorial models with boundary +coefficients less than one, allowing exceptional log discrepancies equal +to one. No scaling rule or pseudo-effectivity assumption is required. +The theorem applies to existing projective small diagrams with the +specified opposite ample signs. +\end{abstract} + +\section{Introduction and the main theorem}\label{sec:introduction} + +A flip replaces a small contraction on which an adjoint divisor is +negative by a small contraction on which its transform is positive. +Termination asks whether this local improvement can continue +indefinitely. Generalized pairs enlarge the adjoint from $K_X+B$ to +$K_X+B+M_X$, where $M_X$ is the trace of nef data on a higher +birational model. The nef contribution can change discrepancies even +where the ordinary boundary is absent. On a compact K\"ahler space, +one must also distinguish analytic nefness from nonnegative degrees +on curves. + +We prove termination in the generalized-canonical case in dimension +four, for rational nef data fixed throughout the sequence. The proof +does not choose the contractions. It applies to every sequence of +projective small diagrams with the required opposite ample signs. +Exceptional log discrepancies may equal one. The resulting canonical +singularities need not be smooth in codimension two, so the argument +must establish smoothness precisely along the flipped surfaces that +it counts. We first specify the global analytic category of the theorem. + +\subsection{The data and the statement} + +All spaces are complex, and a fourfold is irreducible and +four-dimensional. A K\"ahler form on a normal space is +given by smooth strictly plurisubharmonic local potentials in analytic +embeddings. A class in the real Bott--Chern space +$H^{1,1}_{\mathrm{BC}}(X,\R)$ is \emph{analytically nef} if it lies +in the closure of the K\"ahler cone. For a rational line bundle or +a $\Q$-Cartier divisor, this means that its first Chern class is nef +in this sense. + +We call a normal compact space \emph{globally Weil $\Q$-factorial} if +every prime Weil divisor defined on the whole space is $\Q$-Cartier +and some positive reflexive power of its canonical sheaf is a line +bundle. This condition does not assert factoriality of the local +analytic rings, or $\Q$-Cartierness of every rank-one reflexive sheaf. +Compatible actual canonical divisor representatives on the birational +models are part of the supplied data. We do not infer their existence +from the canonical rational line-bundle condition alone. + +Fix a projective birational morphism +\[ + \pi:X'\longrightarrow X +\] +of normal compact K\"ahler spaces and an analytically nef +$\Q$-Cartier divisor $M'$ on $X'$. These data define a rational +b-divisor $\bM$: on a model dominating $X'$ its trace is the pullback +of $M'$, and on another model its trace is the pushforward from a +common higher model. We write $M_T$ for the trace on a model $T$. +The divisor $M'$ need not be effective. Replacing $X'$ by a higher +model and $M'$ by its pullback leaves $\bM$ unchanged. + +Let $B\geq0$ be a rational divisor of finite support with coefficients +less than one, and assume $D=K_X+B+M_X$ is $\Q$-Cartier. On a smooth +model $p:W\to X$ dominating $X'$, define the actual rational divisor +$\Delta_W$ by +\begin{equation}\label{eq:structure} + K_W+\Delta_W+M_W=p^*(K_X+B+M_X). +\end{equation} +For a prime divisor $E$ on $W$, its \emph{generalized log discrepancy} +is +\[ + a(E;X,B+\bM)=1-\operatorname{coeff}_E\Delta_W. +\] +Here a \emph{prime over $X$}, or a \emph{divisorial place}, is a prime +divisor on a proper bimeromorphic model, identified with its strict +transforms on common higher models. Its centre is its reduced +irreducible image, and it is \emph{exceptional} if this image has +codimension at least two. Equation~\eqref{eq:structure} on higher +models defines its discrepancy independently of the carrying model. +The pair is \emph{generalized klt} if all these discrepancies are +positive, and \emph{generalized canonical} if the discrepancies of +exceptional primes are at least one. Replacing the latter inequality +by strict inequality gives \emph{generalized terminal}. Throughout +the theorem we impose positivity for every prime as well as the +canonical bound for exceptional primes. Accordingly, exceptional +coefficients of $\Delta_W$ may be zero or negative. + +We use \emph{projective} for a proper morphism admitting a relatively ample +holomorphic line bundle. A $\Q$-Cartier divisor is relatively ample +if a positive Cartier multiple is so. A proper bimeromorphic +morphism is \emph{small} if its exceptional locus contains no prime +divisor. A small birational map identifies the prime divisors on its +two models, and hence defines strict transforms of boundaries and +canonical divisors. + +\begin{theorem}\label{thm:termination} +Let $X_0$ be a normal irreducible globally Weil $\Q$-factorial compact +K\"ahler fourfold, and let $B_0\geq0$ be a rational divisor with +coefficients in $[0,1)$. Fix compatible actual canonical divisors on +the birational models. Let $\bM$ be the rational b-divisor represented +by an analytically nef $\Q$-Cartier divisor $M'$ on a projective +birational morphism $X'\to X_0$ of normal compact K\"ahler spaces. +Assume +\[ + \begin{aligned} + a(E;X_0,B_0+\bM)&>0&&\text{for every prime over $X_0$},\\ + a(E;X_0,B_0+\bM)&\geq1&&\text{for every exceptional prime}. + \end{aligned} +\] +Consider a sequence of normal globally Weil $\Q$-factorial compact +K\"ahler fourfolds +\[ + X_0\dashrightarrow X_1\dashrightarrow X_2\dashrightarrow\cdots . +\] +On $X_i$, let $B_i$ be the strict transform of $B_0$, let $M_i$ be +the trace of this same $\bM$, and suppose +$D_i=K_{X_i}+B_i+M_i$ is $\Q$-Cartier. Suppose that every step is +given by a diagram +\begin{equation}\label{eq:step-diagram} + X_i\xrightarrow{\ f_i\ }Z_i + \xleftarrow{\ f_i^+\ }X_{i+1} +\end{equation} +of projective small bimeromorphic morphisms with connected fibres, +where $Z_i$ is normal compact K\"ahler, both morphisms are +nonisomorphisms, $-D_i$ is $f_i$-ample, and $D_{i+1}$ is +$f_i^+$-ample. Then the sequence is finite. +\end{theorem} + +The canonical discrepancy bound and positivity are assumed only on +the initial pair; both persist by the comparison proved below. +The theorem imposes no pseudo-effectivity or scaling condition and +no relative Picard-number restriction. It concerns finiteness of +given diagrams; existence of a desired next step is a separate question. + +\subsection{Preceding results and the present argument} + +In the relative projective algebraic setting, Kawamata, Matsuda, +and Matsuki proved termination for ordinary terminal +$\Q$-factorial fourfolds with empty boundary. Their fourfold argument +combines Shokurov's discrepancy difficulty with a descent of surface +classes \cite[Theorem~5-1-15 and its proof]{KMM1987}. +Fujino extended the discrepancy and surface-count method to ordinary +canonical projective fourfold pairs with effective rational boundary +\cite{Fujino2004}. The corrected statement with +$\lfloor B\rfloor=0$ is \cite[Theorem~5.1]{Fujino2005Addendum}; its +flipping contractions need not have relative Picard number one. +Two parts of this work directly underlie our proof. First, the target +of a canonical flip is terminal near general points of its +codimension-two flipped locus, which permits the blowup discrepancy +calculation \cite[Lemma~2.2]{Fujino2004}. Second, the corrected +low-discrepancy count makes its exclusions by centre, so that they +apply to repeated blowups above a boundary surface and not only to +its first blowup +\cite[Proposition~3.1 and Lemma~3.2]{Fujino2005Addendum}. + +Generalized pairs retain nef information on a higher birational +model; see the generalized polarized pairs of +Birkar and Zhang \cite[Definition~1.4 and Section~4]{BirkarZhang2016}. +Chen and Tsakanikas proved termination of every sequence of flips for +pseudo-effective four-dimensional NQC log canonical generalized pairs +in the relative projective algebraic setting +\cite[Theorem~1.1]{ChenTsakanikas2023}; see also +\cite[Theorem~4.4]{Moraga2025}. +Here NQC means that the nef data are finite nonnegative real +combinations of nef $\Q$-Cartier data. +The rational nef datum used here is NQC in the algebraic setting. +Their result allows log canonical singularities and real NQC data. +Theorem~\ref{thm:termination} instead concerns canonical singularities +and fixed rational data, permits nonprojective compact K\"ahler spaces, +and applies without pseudo-effectivity. The smooth-centre discrepancy +formula for generalized pairs also appears in +\cite[Lemma~2.9]{ChenTsakanikas2023}. + +In the K\"ahler setting, Das, Hacon, and P\u{a}un prove termination +for ordinary dlt compact K\"ahler fourfold pairs whose adjoint is rationally linearly +equivalent to an effective divisor, assuming the successive models +remain K\"ahler \cite[Theorem~6.6]{DHP2024}. +Hacon and Xie prove termination of a minimal model program with +scaling for strongly $\Q$-factorial compact K\"ahler generalized klt +pairs whose boundary plus nef part is big, in arbitrary dimension +\cite[Theorem~1.5]{HX2026}. The present theorem treats every given +sequence in its canonical rational setting, without either of these +positivity or scaling conditions. + +The ordinary terminal K\"ahler fourfold argument in +\cite[Section~4]{OrdinaryKahler} uses spans of analytic cycle classes +in place of algebraic cycle classes. We retain this organization and +establish the generalized-canonical version. Its essential points are +local ordinary terminality along flipped surfaces, a finite count of +places below log discrepancy two allowing zero exceptional boundary +coefficients, and a fixed denominator for witness discrepancies at +smooth general points. The cycle comparison is proved for compact +reduced analytic spaces, so it applies directly to boundary components +even when they are nonnormal. The proof reproduces these arguments +in full and invokes no termination theorem. Its analytic negativity +input is Wang's lemma \cite[Lemma~1.3 and Appendices~A--B]{Wang2021}. +The references to \cite{OrdinaryKahler} concern only this negativity +statement, terminal smoothness in codimension two, and the cycle +comparison. No canonical bundle formula or absolute supporting-contraction +theorem from that paper is used: the small projective diagrams are part +of the hypotheses of Theorem~\ref{thm:termination}. + +\subsection{Proof strategy} + +Dimension four links the two parts of the proof. Smallness bounds both +exceptional loci by dimension two, and the opposite ample signs force +their dimensions to sum to at least three. Once the target locus +contains no surface, the source locus must therefore contain one. +A surface also has codimension two: its blowup at a smooth general +point has ordinary log discrepancy two. This connects the discrepancy +threshold to the surface classes that will be counted. + +Surfaces contained in the source and target exceptional loci are +called \emph{flipping} and \emph{flipped surfaces}, respectively. +First we prove strict discrepancy increase for every place centred +in either exceptional locus. Thus a place exceptional over the target +and centred in a flipped surface has log discrepancy strictly greater +than one, even when its source discrepancy equals one. Effectivity of +the boundary and of the difference between the pulled-back nef trace +and the nef datum then give ordinary terminality near a general point +of that surface. Terminal smoothness in codimension two makes the +target smooth there. This is the precise smoothness needed in the proof. + +Blowing up a flipped surface at such points supplies a global prime +divisor, called its \emph{witness}. Choose one integer $m>0$ such that +$mM'$ is Cartier and $mB_0$ has integral coefficients. The integral +Weil divisor $mM_T$ is Cartier near the smooth general point of every +flipped surface on a target $T$. The witness calculation consequently +puts its target log discrepancy in +\[ + (1,2]\cap m^{-1}\Z. +\] +Its discrepancy strictly increases at each use, so each fixed place +can serve as a witness at most $m$ times. This count uses no uniform +bound on the Cartier indices of the nef traces elsewhere on the models. + +We combine this finite set of values with a finite set of possible +places, treating the positive boundary coefficients in decreasing +order. If a flipped surface lies in a component of coefficient $b$, +its witness has source discrepancy strictly below $2-b$. +On the first model of a fixed tail, monotonicity keeps its discrepancy +below $2-b$. The low-place lemma puts these divisors in a finite set, +except possibly those centred on surfaces in a positive boundary +component of coefficient $d$, with discrepancy at least $2-d$. Thus $d>b$. +The induction has already +excluded flipping surfaces in those higher-coefficient components, +so these centres persist through the common isomorphic opens and +cannot become flipped surfaces. At each coefficient stage the +possible divisorial witnesses thus belong to a fixed finite set. + +Once these witnesses are exhausted, the target exceptional locus +contains no surface in the boundary components of the current +coefficient. On each such component, +Borel--Moore localization compares +its analytic surface classes with those of the source component. +Every removed source surface gives a nonzero kernel class by +K\"ahler positivity. The rank consequently drops at each remaining +step affecting such a surface. After the boundary components have +been treated, the witness argument with threshold two excludes every +remaining flipped surface. The same cycle comparison on the fourfolds +then gives strict rank loss at every step. + +Section~\ref{sec:foundations} fixes the analytic foundations and +common models. Section~\ref{sec:comparison} proves the strict +one-step comparison. Section~\ref{sec:low-places} establishes the +low-place count. Section~\ref{sec:witnesses} proves generic +terminality along flipped surfaces and constructs witnesses with +finitely many possible discrepancy values. Section~\ref{sec:cycles} proves the +cycle-rank comparison, and Section~\ref{sec:termination} combines +these ingredients. diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/02-foundations.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/02-foundations.tex new file mode 100644 index 0000000000000000000000000000000000000000..e9f86ab67ba877dda8e8935cf94993c905cb288c --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/02-foundations.tex @@ -0,0 +1,203 @@ +\section{Analytic foundations and common models}\label{sec:foundations} + +We will compare actual divisors on common models and later prove +smoothness at general points of flipped surfaces. This section +records the analytic facts needed for these two purposes. All +discrepancy comparisons use the fixed b-divisor $\bM$ from +Theorem~\ref{thm:termination}. + +\subsection{Places and projective resolutions}\label{subsec:places} + +A \emph{place} is a global prime divisor on a normal proper +bimeromorphic model, identified with its strict transforms on common +higher models. Its centre is its reduced irreducible image. A place +is exceptional over a model when its centre has codimension at least +two. This description does not identify places solely through fields +of global meromorphic functions. Properness makes the centres compact +analytic subspaces. When checking a local singularity condition, we +also use divisors on proper modifications of analytic neighbourhoods; +we refer to these explicitly as \emph{local places}. + +Every divisor in a pullback comparison is an actual divisor, with +the compatible canonical representatives prescribed in +Theorem~\ref{thm:termination}. Ordinary relative canonical +coefficients can be computed from local pluricanonical equations +after clearing a Cartier multiple; over a smooth space they are +the orders of the Jacobian. These computations localize. Indeed, +a ratio of representatives that is a unit off a codimension-two +subset of a normal base extends as a unit across that subset. +Thus agreement on the isomorphic opens gives the same local +discrepancy coefficients. + +For a proper bimeromorphic morphism $r:V\to T$ of normal spaces, +the set of points with positive-dimensional fibres is closed +analytic. Off this subset the morphism is finite and +bimeromorphic, hence an isomorphism by normality. The subset has +codimension at least two: its inverse image is a proper analytic +subset of $V$, and the fibre-dimension theorem excludes a +codimension-one image with positive-dimensional fibres. Fibres +are connected by Stein factorization. A point where the morphism +is a local isomorphism is isolated in its fibre, so it cannot +belong to a connected positive-dimensional fibre. The exceptional +locus is therefore exactly the inverse image of this subset. + +We use normalization, proper mapping, fibre dimension, Stein +factorization, and resolution and principalization in the complex +analytic category. The last two permit simultaneous resolution +of finitely many divisors and coherent ideals by projective +modifications; see +\cite[Theorems~1.6, 1.10, and~13.2(1)]{BierstoneMilman1997}. +Projective morphisms are preserved under base change and +restriction to closed analytic subspaces; finite morphisms are +projective. The projective morphisms used here can also be +composed: a sufficiently large twist of one relative ample +line bundle by the pullback of the next is relatively ample +for the composite, with compactness giving a uniform choice. + +\begin{proposition}[Common models]\label{prop:common-models} +Any finite portion of the sequence in +Theorem~\ref{thm:termination} has a smooth common model dominating +its members and $X'$, projective over each member. It may also +dominate any prescribed projective modification of one of those +members. For a chosen member $T$, it can be arranged that the +exceptional locus over $T$ is divisorial and that its union with +the strict transform of $\Supp B_T$ has simple normal crossings. +The model carries $\bM$ as the pullback of $M'$. +\end{proposition} + +\begin{proof} +Enlarge the finite portion to an initial segment starting at $X_0$. +For one step, take the reduced component of +$X_i\times_{Z_i}X_{i+1}$ containing the graph over the common +isomorphic open. It is projective over both models, and its +normalization remains so. Combine these graphs and $X'\to X_0$ +by successive dominating components of fibre products, then +normalize and resolve. To include a prescribed projective +modification of a member, take one further fibre product over +that member before resolving. Base change, restriction, finite +normalization, and composition show that all resulting morphisms +to the members of the segment are projective. + +Fix $T$. Choose a closed analytic subset of codimension at +least two outside which the map is an isomorphism, $T$ is +smooth, and the boundary components are smooth and disjoint; +include their singular loci and pairwise intersections in this +subset. Principalize the pullback of its ideal and resolve +the total divisor without changing this open set. The inverse +image of the chosen subset is now a divisor whose components +are exceptional over $T$; it contains the entire exceptional +locus. Resolving together with the strict boundary gives the +claimed normal-crossing condition. Pulling back $M'$ preserves +the fixed data. +\end{proof} + +A further common resolution with a model carrying any prescribed +place allows comparison of its discrepancy. That carrying model +need not itself be projective, and the further resolution is only +required to be proper. Projectivity of the models in +Proposition~\ref{prop:common-models} will be used when applying +negativity and when constructing divisorial witnesses. + +\subsection{Negativity for actual divisors} + +For a projective morphism, relative nefness of a rational divisor +in the following lemma is the degree condition on all contracted +curves. This is distinct from absolute analytic nefness. + +\begin{lemma}[Analytic negativity]\label{lem:negativity} +Let $r:V\to T$ be a projective bimeromorphic morphism of normal +complex spaces and let $F$ be a $\Q$-Cartier divisor on $V$. +If $-F$ has nonnegative degree on every contracted curve and +$r_*F$ is effective, then $F$ is effective. +\end{lemma} + +This is \cite[Lemma~1.3 and Appendix~A]{Wang2021}, after +clearing a Cartier multiple. The relative degree criterion in +the projective case is explicit in \cite[Appendix~B]{Wang2021}. +Effectivity is that of the actual divisor, not merely its class. +The corresponding statement is +\cite[Lemma~2.3(i)]{OrdinaryKahler}. We apply it only when $r_*F=0$. + +An effective $\Q$-Cartier divisor on a normal space pulls back +effectively: after multiplying, its local meromorphic equation +has no divisorial poles, hence is holomorphic by normality. +It also has nonnegative degree on every compact curve not +contained in its support, by restriction to the normalization +of that curve. We will use both facts. + +\subsection{Ordinary terminal singularities in codimension two} + +The following local statement will be applied on an open set +meeting a flipped surface. We include its surface proof, as in +\cite[Lemma~4.4]{OrdinaryKahler}. Ordinary terminality here means +that every local exceptional place has ordinary log discrepancy +strictly greater than one. + +\begin{lemma}\label{lem:terminal-smooth} +A normal complex fourfold with a canonical rational line bundle +and ordinary terminal singularities is smooth in codimension two. +\end{lemma} + +\begin{proof} +Suppose the singular locus has a codimension-two component. +Near its general smooth point, choose a holomorphic projection +to $\C^2$ submersive on that component. Take a log resolution +which is an isomorphism over the regular locus. Choose a general +fibre $S$ of the projection: its inverse image $\widetilde S$ +is smooth, misses exceptional strata whose images have dimension +less than two, and meets all remaining strata transversely. These +choices follow by generic smoothness on the resolution and its +finitely many strata. +Write $\rho:\widetilde S\to S$ for the induced resolution. Terminal +singularities are klt, so the ambient space has rational singularities +by \cite[Theorem~3.12]{FujinoAnalytic2022}, and is Cohen--Macaulay +\cite[Remark~2.1]{Greb2011}. The fibre has the expected codimension +two. Its two defining parameters therefore form a regular sequence, +so $S$ is Cohen--Macaulay. It is regular away from isolated points +by the general choice of fibre. Serre's criterion makes $S$ normal. + +For the regular sequence, the Koszul calculation of the dualizing +sheaf gives $\omega_S\simeq\omega_T\otimes\mathcal O_S$, where +$T$ denotes the ambient neighbourhood; the two slice equations +trivialize the normal determinant. This uses the local analytic +Ext description of the dualizing sheaf +\cite[pp.~3--4]{RSW2017}. Away from the isolated intersections with +the ambient singular locus, a local Cartier pluricanonical power +restricts accordingly, and the identification extends reflexively +over the normal surface. Applying adjunction also on the smooth +resolution therefore restricts its relative canonical equation to +\[ + A:=K_{\widetilde S}-\rho^*K_S=\sum_j a_jE_j, + \qquad a_j>0. +\] +Here each exceptional curve is a transverse restriction of an +exceptional divisor on the resolution; terminality gives its +positive coefficient. +A normal surface germ with this property is smooth. Indeed, if +exceptional curves remain, negative definiteness +\cite[Section~4.8(e)]{Grauert1962} gives $A^2<0$, +so $A\cdot E_j<0$ for some $j$. The pulled-back canonical divisor +has degree zero on $E_j$, and therefore +$K_{\widetilde S}\cdot E_j<0$. Since $E_j^2<0$, adjunction gives +\[ + 0\leq p_a(E_j) + =1+\tfrac12(K_{\widetilde S}\cdot E_j+E_j^2)\leq0. +\] +Both negative intersection numbers are integers, so each equals +$-1$. Thus $E_j$ is a smooth rational $(-1)$-curve. Contract it +to a smooth point by \cite[Section~4.8(a)]{Grauert1962}. The map to +the normal surface germ factors +through this contraction, and pushforward of the relative +canonical equation leaves positive coefficients on all remaining +exceptional curves. Repetition ends with a finite bimeromorphic +map to the normal surface germ, which is an isomorphism. + +But the transverse slice at the chosen singular fourfold +point has embedding dimension at least that of the fourfold +germ minus two, hence greater than two. It is singular, a +contradiction. +\end{proof} + +In Proposition~\ref{prop:ordinary-terminal} we will verify ordinary +terminality on an open set meeting each flipped surface before +applying the lemma there. diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/03-comparison.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/03-comparison.tex new file mode 100644 index 0000000000000000000000000000000000000000..e5249d893e98e7a6384f8f341e16c6ab0a984f66 --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/03-comparison.tex @@ -0,0 +1,234 @@ +\section{Discrepancies across one flip}\label{sec:comparison} + +We first establish the properties of an individual step that will be +used throughout the termination argument. The two relative ample +signs produce an effective divisor on the normalized graph. Its +support contains the entire inverse image of the exceptional loci; +this is what gives strict increase for every place centred in either +locus. + +\begin{proposition}[Comparison across a flip]\label{prop:comparison} +Let +\[ + T\overset{f}{\longrightarrow}Z + \overset{g}{\longleftarrow}T^+ +\] +be a step satisfying the hypotheses of Theorem~\ref{thm:termination} between normal compact K\"ahler fourfolds. Write +\[ + D_T=K_T+B_T+M_T,\qquad + D_{T^+}=K_{T^+}+B_{T^+}+M_{T^+}, +\] +where the nef traces come from the same fixed b-divisor $\bM$. +Then the following assertions hold. +\begin{enumerate} +\item The exceptional images coincide: +\[ + A:=f(\Exc f)=g(\Exc g). +\] +With reduced structures, put +\[ + L=f^{-1}(A)=\Exc f,\qquad + L^+=g^{-1}(A)=\Exc g. +\] +These are closed analytic subsets, and +\[ + T\setminus L\simeq T^+\setminus L^+, + \qquad \dim L,\dim L^+\leq2,\qquad \dim A\leq1. +\] +\item For every divisorial place $E$ over the two models, +\begin{equation}\label{eq:discrepancy-monotonicity} + a(E;T^+,B_{T^+}+\bM) + \geq a(E;T,B_T+\bM). +\end{equation} +The inequality is strict if the centre of $E$ on $T$ is contained in +$L$, or if its centre on $T^+$ is contained in $L^+$. +A place is exceptional over $T$ if and only if it is exceptional over +$T^+$. In particular, the generalized canonical condition of +Theorem~\ref{thm:termination} is preserved. If it holds on $T$, then +every exceptional place with centre contained in $L^+$ satisfies +\begin{equation}\label{eq:target-strict-discrepancy} + a(E;T^+,B_{T^+}+\bM)>1. +\end{equation} +\item The exceptional loci satisfy +\begin{equation}\label{eq:exceptional-dimensions} + \dim L+\dim L^+\geq3. +\end{equation} +Consequently, if $L^+$ contains no surface, then $L$ contains a surface. +\end{enumerate} +\end{proposition} + +\begin{proof} +\emph{The common exceptional image.} +For each of the two morphisms, the exceptional locus is precisely the +inverse image of the locus of positive-dimensional fibres, by the +discussion in Section~\ref{subsec:places}. Off the union of these +two images, the morphisms initially give isomorphic opens whose +complements upstairs have codimension at least two. Thus prime +divisors already correspond, before equality of the images is known. + +Let $U\subset Z$ be the open set where $f$ is an isomorphism. Transport +$D_T|_{f^{-1}(U)}$ to an actual $\Q$-Cartier divisor $D_U$ on $U$. +The two adjoints agree under the identification of prime divisors +induced by the small map: this holds for the canonical and boundary +terms by their prescribed transforms, and for the nef traces by the +pushforward rule for the fixed b-divisor. Hence on $g^{-1}(U)$ the +divisors $D_{T^+}$ and $g^*D_U$ agree away from the exceptional locus +of $g$. That locus contains no divisor, so the two Weil divisors +agree everywhere on $g^{-1}(U)$. Clearing Cartier multiples and using +normality gives equality as $\Q$-Cartier divisors as well. + +If $g$ had a positive-dimensional fibre over a point of $U$, its +projectivity would provide a curve $C$ in that fibre. The equality +just proved would give $D_{T^+}\cdot C=0$, contrary to $g$-ampleness. +Thus $g$ is also an isomorphism over $U$. Interchanging $f$ and $g$ +and using $f$-ampleness of $-D_T$ proves the reverse inclusion of their +isomorphism loci. This establishes the asserted common image $A$ +and the identification of the complements of $L$ and $L^+$. +Smallness gives $\dim L,\dim L^+\leq2$. Every fibre over $A$ is +positive dimensional, so the fibre-dimension theorem gives +$\dim A\leq1$. + +\emph{An effective divisor on the graph.} +Let $G$ be the normalization of the component of $T\times_ZT^+$ +dominating $Z$. Its projections fit into the commutative diagram +\begin{equation}\label{eq:normalized-graph} + \begin{array}{ccc} + G&\xrightarrow{\ q\ }&T^+\\[3pt] + {\scriptstyle p}\big\downarrow&& + \big\downarrow{\scriptstyle g}\\[3pt] + T&\xrightarrow{\ f\ }&Z. + \end{array} + \qquad h:=f\circ p=g\circ q. +\end{equation} +The morphisms $p,q,h$ are projective and bimeromorphic, as in +Proposition~\ref{prop:common-models}. Define the actual $\Q$-Cartier +divisor +\begin{equation}\label{eq:graph-divisor} + F:=p^*D_T-q^*D_{T^+}. +\end{equation} +It vanishes off $h^{-1}(A)$. Since both $L$ and $L^+$ have codimension +at least two, $F$ is exceptional over both models; in particular, +$p_*F=0$. + +If $C$ is a curve contracted by $p$, then $q_*C$ is either zero or a +curve contracted by $g$. The projection formula therefore gives +\[ + (-F)\cdot C=D_{T^+}\cdot q_*C\geq0. +\] +Thus $-F$ is $p$-nef in the relative curve-degree sense. Applying +Lemma~\ref{lem:negativity} to a positive Cartier multiple of $F$ +proves that $F\geq0$. + +There is a strict inequality on every curve contracted by $h$. +Indeed, for such an irreducible curve $C$, the relative ample signs +give +\[ + D_T\cdot p_*C\leq0,\qquad + D_{T^+}\cdot q_*C\geq0, +\] +with strict inequality whenever the corresponding image is a curve. +The two images cannot both be points: the map +$G\to T\times_ZT^+$ is finite onto the graph component, so it cannot +contract $C$. Hence +\begin{equation}\label{eq:graph-curve-negativity} + F\cdot C=D_T\cdot p_*C-D_{T^+}\cdot q_*C<0 + \qquad\text{for every $h$-contracted irreducible curve $C$.} +\end{equation} + +We next show that this strict inequality determines the whole support: +\begin{equation}\label{eq:graph-support} + \Supp F=h^{-1}(A). +\end{equation} +Fix $z\in A$. The fibre $h^{-1}(z)$ is projective and connected; +connectedness also follows directly from the proper bimeromorphic +morphism $h$ and normality of $Z$. It is positive dimensional because +it surjects onto $f^{-1}(z)$. Its reduction has finitely many +irreducible components. A zero-dimensional irreducible component +would be a point disjoint from every other component, contradicting +connectedness. Therefore every point belongs to a positive-dimensional +projective component. Intersecting such a component with hyperplanes +through the point produces an irreducible curve through that point. + +An effective $\Q$-Cartier divisor has nonnegative degree on every +compact irreducible curve not contained in its support: a positive +multiple is an effective Cartier divisor, whose canonical section +restricts to a nonzero holomorphic section on the normalization of +that curve. By \eqref{eq:graph-curve-negativity}, every curve in +$h^{-1}(z)$ is therefore contained in $\Supp F$. The preceding +paragraph puts every point of the fibre in $\Supp F$. This proves +$h^{-1}(A)\subset\Supp F$; the reverse inclusion was already noted. + +\emph{Discrepancies of all places.} +Choose a sufficiently high smooth common model carrying the fixed +nef data and dominating $G$, as supplied by +Proposition~\ref{prop:common-models}. To compare a specified place +$E$, further dominate a model representing it, so that $E$ is a prime +divisor on a smooth model $W$ with morphism $r:W\to G$. The same +canonical divisor $K_W$ and the same nef trace $M_W$ occur in both +discrepancy equations: +\[ + \begin{aligned} + K_W+\Delta_T+M_W&=(p\circ r)^*D_T,\\ + K_W+\Delta_{T^+}+M_W&=(q\circ r)^*D_{T^+}. + \end{aligned} +\] +Their difference is the equality of actual divisors +\[ + r^*F=\Delta_T-\Delta_{T^+}. +\] +Taking the coefficient at $E$ yields +\begin{equation}\label{eq:graph-discrepancy-identity} + a(E;T^+,B_{T^+}+\bM)-a(E;T,B_T+\bM) + =\operatorname{coeff}_E(r^*F). +\end{equation} +Pullback of the effective $\Q$-Cartier divisor $F$ is effective, proving +\eqref{eq:discrepancy-monotonicity}. + +If the centre of $E$ on $T$ lies in $L$, its centre on $G$ lies in +$p^{-1}(L)=h^{-1}(A)$; the same conclusion holds if its centre on +$T^+$ lies in $L^+$. By \eqref{eq:graph-support}, this centre is +contained in $\Supp F$. A local equation of a positive effective +Cartier multiple of $F$ vanishes on that centre. Its pullback has +positive order along $E$: it is a nonzero holomorphic function on +the inverse image of the coordinate neighbourhood and vanishes on +the part of $E$ lying there. Consequently the +right-hand side of \eqref{eq:graph-discrepancy-identity} is strictly +positive. This proves strictness for an arbitrary place with either +specified centre condition. + +A place whose centre is a prime divisor on a normal model is +represented by that divisor, since a proper bimeromorphic morphism +to a normal space is an isomorphism at general points of each prime +divisor on the target. Every prime divisor +on $T$ meets $T\setminus L$, and its corresponding prime divisor on +$T^+$ meets $T^+\setminus L^+$. The common isomorphism identifies +their orders. Thus a place is nonexceptional on one side exactly +when it is nonexceptional on the other. Together with +\eqref{eq:discrepancy-monotonicity}, this preserves positivity for +all places and the lower bound $1$ for exceptional places. For a +place centred in $L^+$, strictness improves that lower bound to +\eqref{eq:target-strict-discrepancy}. + +\emph{The dimension inequality.} +The step is nontrivial, so $A\neq\varnothing$. Equation +\eqref{eq:graph-support} implies $F\neq0$. Every irreducible component +$P$ of $\Supp F$ is a divisor on the four-dimensional normal space +$G$, hence has dimension three. Its finite image under +$G\to T\times_ZT^+$ is contained in $L\times_ZL^+$. Therefore +\[ + 3=\dim P\leq\dim(L\times_ZL^+)\leq\dim L+\dim L^+, +\] +which proves \eqref{eq:exceptional-dimensions}. If $L^+$ contains no +surface, then $\dim L^+\leq1$, while smallness gives $\dim L\leq2$. +The inequality forces $\dim L=2$, so a two-dimensional irreducible +component of $L$ is the required surface. +\end{proof} + +We will call an irreducible compact analytic surface contained in $L$ +a \emph{flipping surface}, and one contained in $L^+$ a +\emph{flipped surface}. Applying Proposition~\ref{prop:comparison} +successively shows that every pair in a sequence as in +Theorem~\ref{thm:termination} remains generalized canonical. The +strict bound \eqref{eq:target-strict-discrepancy} concerns places +centred in the flipped locus and will supply the local terminal +condition used to study its surfaces. diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/04-low-places.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/04-low-places.tex new file mode 100644 index 0000000000000000000000000000000000000000..81cd99791f54b3e89605e430dd3859cafaa9c122 --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/04-low-places.tex @@ -0,0 +1,279 @@ +\section{Places of small discrepancy} +\label{sec:low-places} + +Fix a model $T$ in the sequence of Theorem~\ref{thm:termination}. +Proposition~\ref{prop:comparison} gives log discrepancy at least one +for every exceptional place over $T$. We will show that, apart from a +finite set of places, an exceptional place of discrepancy below two is +centred on a surface in a positive boundary component. Its discrepancy +is then bounded below by two minus that component's coefficient. +This description will restrict the possible divisors used to count +flipped surfaces. + +\subsection{The nef trace and local estimates} + +Write $B_T$ and $M_T$ for the boundary and the trace of $\bM$ on $T$. +They are $\Q$-Cartier: each is a finite rational combination of globally +defined prime Weil divisors, to which global Weil $\Q$-factoriality applies. +Choose a smooth model +\[ + r\colon W\longrightarrow T +\] +that is projective over $T$ and carries the fixed nef data, as supplied by +Proposition~\ref{prop:common-models}. Define the actual divisors +\begin{equation} + \Delta_W=r^*(K_T+B_T+M_T)-K_W-M_W, + \qquad J_W=r^*M_T-M_W. + \label{eq:boundary-and-defect} +\end{equation} +Thus the coefficient of a prime $E$ in $\Delta_W$ is +$1-a(E;T,B_T+\bM)$. + +\begin{lemma}[Effectivity of the nef-trace defect] +\label{lem:nef-defect} +For every smooth model $r\colon W\to T$ that is projective over $T$ and +carries the fixed nef data, the divisor $J_W$ in +\eqref{eq:boundary-and-defect} is an effective +$r$-exceptional $\Q$-Cartier divisor. +\end{lemma} + +\begin{proof} +The pushforward of both $r^*M_T$ and $M_W$ is $M_T$, so $J_W$ is +$r$-exceptional. For every curve $C$ contracted by $r$, +\[ + (-J_W)\cdot C=M_W\cdot C\geq 0. +\] +To see the last inequality, let $s\colon W\to X'$ be the morphism to the +fixed carrier. Since $M_W=s^*M'$, its degree on $C$ is zero if $s(C)$ is a +point, and otherwise is the degree of $M'$ on $s(C)$ multiplied by the +degree of the induced map of normalized curves. Analytic nefness of $M'$ +implies that these curve degrees are nonnegative: restrict a sequence of +K\"ahler classes converging to $c_1(M')$ to the normalized curve and pass to +the limit. We use this consequence of analytic nefness only for the +relative degree calculation above. Lemma~\ref{lem:negativity}, applied to +$J_W$ and $r_*J_W=0$, now gives $J_W\geq0$. +\end{proof} + +We will use the following local estimate both to check ordinary terminality +and to locate places of small generalized discrepancy. It applies to local +analytic places as well as to places represented by divisors on compact +models. + +\begin{lemma}[A local differential estimate] +\label{lem:jacobian} +Let $W$ be a smooth complex space of dimension $n$, and let $E$ be a prime +divisor on a smooth proper birational model of an open subset of $W$. +Suppose its centre $C$ has codimension $c$. At a general smooth point of +$C$, choose coordinates $x_1,\ldots,x_n$ with +$C=(x_1=\cdots=x_c=0)$. Writing $v=\operatorname{ord}_E$, one has +\begin{equation} + a(E;W,0)\geq\sum_{j=1}^{c}v(x_j)\geq c. + \label{eq:jacobian-bound} +\end{equation} +If $C$ is contained in exactly one positive component $H$ of a rational +divisor $\Delta$, and $H$ is smooth at the general point of $C$ with +coefficient $d\in(0,1)$, choose the coordinates so that $H=(x_1=0)$. +Then +\begin{equation} + a(E;W,\Delta) + \geq (1-d)v(x_1)+\sum_{j=2}^{c}v(x_j) + \geq c-d. + \label{eq:one-positive-bound} +\end{equation} +If $C$ is contained in no positive component of $\Delta$, then +$a(E;W,\Delta)\geq c$. +\end{lemma} + +\begin{proof} +Compute at a general smooth point of $E$ above the chosen coordinate +neighbourhood. If $t$ is a local equation of $E$, write +$x_j=t^{v(x_j)}u_j$ for $1\leq j\leq c$, where $u_j$ is a unit at the +general point of $E$. Each $v(x_j)$ is a positive integer. In expanding +the pullback of $dx_1\wedge\cdots\wedge dx_n$, at most one factor in a +nonzero term can contribute a differential $dt$. Thus its order along +$E$ is at least $\sum_{j=1}^c v(x_j)-1$. The remaining coordinate +differentials are holomorphic and do not lower this order. Adding one to +the coefficient of the relative canonical divisor proves +\eqref{eq:jacobian-bound}. + +For the boundary statement, each component with nonpositive coefficient +contributes a nonnegative amount to the log discrepancy. Components not +containing $C$ have order zero along $E$. Subtracting just +$d\,v(x_1)$ from \eqref{eq:jacobian-bound} therefore gives +\eqref{eq:one-positive-bound}. If there is no positive component through +$C$, nothing has to be subtracted. +\end{proof} + +\subsection{A finite exceptional set of places} + +We next describe the places with generalized log discrepancy below two. +The finite exceptional set is attached to one fixed model; its size need +not be uniform along the sequence. The distinction according to the +centre of a place follows the corrected discrepancy argument of +Fujino~\cite[Proposition~3.1 and Lemma~3.2]{Fujino2005Addendum}. We give +the full argument, including the repeated blowups that are needed when a +boundary coefficient exceeds $1/2$. + +\begin{lemma}[Places of log discrepancy below two] +\label{lem:low-places} +Let $(T,B_T+\bM)$ be any model of a sequence as in Theorem~\ref{thm:termination}. There is a +finite set $\mathcal F_T$ of exceptional places over $T$ with the following +property. If $E$ is exceptional over $T$, +\[ + a(E;T,B_T+\bM)<2, + \qquad E\notin\mathcal F_T, +\] +then its centre $S$ on $T$ is a surface contained in a unique positive +component $H$ of $B_T$. The space $T$ and the reduced boundary support are +smooth at the general point of $S$. If the coefficient of $H$ is $d$, +then +\begin{equation} + a(E;T,B_T+\bM)\geq2-d. + \label{eq:low-place-threshold} +\end{equation} +If $B_T=0$, there are only finitely many exceptional places with log +discrepancy below two. +\end{lemma} + +\begin{proof} +Choose a smooth modification $r\colon W\to T$, projective over $T$ and +carrying the nef data, such that its exceptional locus is divisorial and, together with +the strict transform of $\Supp B_T$, has simple normal crossings. +Starting with this simple normal crossing divisor, blow up the +intersections of pairs of positive strict transforms until they are +mutually disjoint. Each intersection is a finite disjoint union of smooth +codimension-two subspaces. Blowing it up separates the chosen pair, +preserves simple normal crossings, and cannot make a previously separated +pair meet. Thus finitely many such blowups suffice. + +Keep the notation $W$ for the resulting model and $\Delta_W$ for its +boundary in \eqref{eq:boundary-and-defect}. Its positive components are +exactly the strict transforms of the positive components of $B_T$, with +the same coefficients. They are smooth and pairwise disjoint. Every +component exceptional over $T$ has nonpositive coefficient by +generalized canonicity; zero coefficients are allowed. On a higher +smooth model $u\colon V\to W$, +the nef terms cancel because $M_V=u^*M_W$, giving +\[ + K_V+\Delta_V=u^*(K_W+\Delta_W). +\] +Hence generalized discrepancies over $T$ can be computed as ordinary +discrepancies for $(W,\Delta_W)$, including its negative coefficients. + +Put all $r$-exceptional prime divisors on $W$ into $\mathcal F_T$. +There are finitely many, since $W$ is compact. A further exceptional +place $E$ has centre $C$ on $W$ of codimension at least two: a place with +divisorial centre on a normal model is represented by that divisor. +Lemma~\ref{lem:jacobian} shows that +$a(E;W,\Delta_W)<2$ forces $C$ to have codimension two and to lie in +one of the positive components, say $H$ with coefficient $d$. The same +lemma gives +\begin{equation} + a(E;W,\Delta_W)\geq2-d. + \label{eq:resolution-low-bound} +\end{equation} +If $C$ is not contained in $\Exc(r)$, then $r$ is an isomorphism at its +general point. Its image is the surface $S$ required in the statement; +smoothness and uniqueness of the positive component descend from $W$. + +It remains to treat the centres contained in $\Exc(r)$. Such a centre +$C$, being codimension two and contained in $H$, must be an irreducible +component of $H\cap F$ for some exceptional divisor $F$ on $W$. +There are only finitely many such components, and each is smooth by +simple normal crossings. We show that a fixed one contributes only +finitely many places of log discrepancy below two. + +Near $C$, the only positive component of $\Delta_W$ is $H$. +Deleting the nonpositive components can only lower discrepancies, so +\[ + a(E;W,dH)\leq a(E;W,\Delta_W)<2 +\] +for every place under consideration with centre $C$. We can therefore +work with the smooth pair $(W,dH)$ and the fixed smooth codimension-two +centre $C\subset H$. + +Set $W_0=W$ and $H_0=H$. Blow up $C$ to obtain $W_1$, with exceptional +divisor $F_1$ and strict transform $H_1$. If $E$ is not $F_1$, its +centre on $W_1$ is contained in $F_1$ and has codimension at least two. +The crepant boundary on $W_1$ has sole positive component $dH_1$; the +coefficient of $F_1$ is $-(1-d)$. Lemma~\ref{lem:jacobian} therefore +forces the centre of $E$ to have codimension two and to lie in $H_1$. +It is consequently the entire intersection +\[ + C_1=H_1\cap F_1. +\] +This intersection is a smooth irreducible section of the exceptional +$\mathbb P^1$-bundle over $C$, hence isomorphic to $C$. + +Repeat this construction: after $W_j$ has been obtained, blow up +$C_j=H_j\cap F_j$ to obtain $W_{j+1}$, with new exceptional divisor +$F_{j+1}$. Writing $C_0=C$, the maps and +their centres are +\begin{equation}\label{eq:forced-centres} + W_j=\operatorname{Bl}_{C_{j-1}}W_{j-1},\qquad + C_j=H_j\cap F_j\simeq C_{j-1}\qquad(j\geq1). +\end{equation} +The new strict transform +$H_{j+1}$ meets $F_{j+1}$ in a smooth section and is disjoint from the +strict transform of $F_j$. Inductively, it misses every older exceptional +divisor. The codimension-two blowup formula gives the coefficient +\begin{equation} + \operatorname{coeff}_{F_j}(\Delta_j)=-j(1-d), + \qquad a(F_j;W,dH)=1+j(1-d), + \label{eq:forced-chain-coefficients} +\end{equation} +where $K_{W_j}+\Delta_j$ is the pullback of $K_W+dH$. +Indeed the new coefficient is the sum of the coefficients of $H_j$ and +$F_j$, minus one. This is $-(j+1)(1-d)$. + +Thus the only way a place of discrepancy below two can remain +unextracted is for its centre to follow these successive intersections. +At every stage, if $E$ has not yet appeared, the argument just given +forces its centre to be $C_j$. Choose local transverse coordinates +$x,y$ with $H_j=(x=0)$ and $F_j=(y=0)$, and put +$v=\operatorname{ord}_E$. Retaining the negative coefficient of $F_j$ +in the differential estimate gives +\begin{equation} + \begin{split} + a(E;W,dH)&\geq (1-d)v(x)+\bigl(1+j(1-d)\bigr)v(y)\\ + &\geq (1-d)+\bigl(1+j(1-d)\bigr) + =2-d+j(1-d). + \end{split} + \label{eq:forced-chain-cutoff} +\end{equation} +For +\[ + J=\left\lceil\frac{d}{1-d}\right\rceil, +\] +the right side is at least two. Every place with discrepancy below two +and centre $C$ must therefore be one of $F_1,\ldots,F_J$. Equivalently, +the possible indices in \eqref{eq:forced-chain-coefficients} satisfy +$j<1/(1-d)$; the strict endpoint is included in the cutoff calculation. + +All these blowups have global smooth compact analytic centres. Thus the +divisors just enumerated are global places. Conversely, an arbitrary +place can be followed on common proper resolutions even when its +original carrying model was not projective; its centres map onto the +preceding centres. The argument forcing $C_j$ therefore covers every +place over $C$, not only those chosen in advance from this blowup chain. + +Add the finitely many divisors obtained for all the finitely many +intersections $H\cap F$ to $\mathcal F_T$. Every place outside this set +has the centre described earlier, and +\eqref{eq:resolution-low-bound} gives +\eqref{eq:low-place-threshold}. If the boundary has no positive +component, Lemma~\ref{lem:jacobian} already excludes every further place +of discrepancy below two, proving the last assertion. +The proof used only nonpositivity of the exceptional coefficients on +$W$, so exceptional places of log discrepancy exactly one cause no +additional case. +\end{proof} + +\begin{remark} +The second and subsequent blowups in the preceding proof are essential. +For example, when $d=2/3$, the first two divisors have log discrepancies +$4/3$ and $5/3$, and the third has discrepancy two. This is the phenomenon +in Fujino's correction \cite[Example~2.1]{Fujino2005Addendum}. The finite +exceptional set in Lemma~\ref{lem:low-places} is defined by centres and +contains the whole finite chain over each exceptional intersection. +\end{remark} diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/05-witnesses.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/05-witnesses.tex new file mode 100644 index 0000000000000000000000000000000000000000..ea2b139be5d67c4541619676eb97910bebb58248 --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/05-witnesses.tex @@ -0,0 +1,224 @@ +\section{Divisorial witnesses for flipped surfaces} +\label{sec:witnesses} + +A surface in the flipped locus supplies a divisor whose discrepancy has +just increased. The fixed rational nef data constrain the new discrepancy +to a finite set. The construction requires smoothness at the general +point of the flipped surface. Generalized canonicity alone does not +supply that smoothness; strict increase on the target exceptional locus +does. We first establish this local consequence and then construct a +global divisor by blowing up the surface. +For ordinary canonical pairs, this use of terminality near a flipped +surface appears in Fujino \cite[Lemma~2.2]{Fujino2004}. +The proof here includes the nef-trace defect and checks the local +singularity condition from the hypotheses on global places. + +\begin{proposition}[Terminality near a flipped surface] +\label{prop:ordinary-terminal} +Let $T\dashrightarrow T^+$ be a step in the sequence of +Theorem~\ref{thm:termination}, and let $S\subset L^+$ be an irreducible +flipped surface. There is an analytic open subset $U\subset T^+$ +meeting $S$ on which the underlying space has ordinary terminal +singularities. Consequently $T^+$ is smooth at a general point of $S$. +\end{proposition} + +\begin{proof} +Choose a smooth model $r\colon W\to T^+$, projective over $T^+$ and +carrying the fixed nef data, with divisorial exceptional locus as in +Proposition~\ref{prop:common-models}. Using the divisors of +\eqref{eq:boundary-and-defect}, write the ordinary relative canonical +equation as +\begin{equation} + \Theta_W:=r^*K_{T^+}-K_W + =\Delta_W-r^*B_{T^+}-J_W. + \label{eq:ordinary-boundary} +\end{equation} +The pullback $r^*B_{T^+}$ is effective: after clearing a Cartier +multiple, a local equation for the effective boundary is holomorphic +by normality, and remains holomorphic after pullback. +Lemma~\ref{lem:nef-defect} gives $J_W\geq0$. Generalized canonicity +therefore makes every exceptional coefficient of $\Theta_W$ +nonpositive. Its nonexceptional coefficients are zero, since it is +an ordinary relative canonical divisor. + +An exceptional prime $P$ on $W$ whose image contains $S$ has image +exactly $S$: its irreducible image has dimension at most two. +Proposition~\ref{prop:comparison} gives +\[ + a(P;T^+,B_{T^+}+\bM)>a(P;T,B_T+\bM)\geq1, +\] +because its target centre lies in $L^+$. Thus its coefficient in +$\Delta_W$, and hence in $\Theta_W$, is strictly negative. + +There are only finitely many exceptional prime divisors on $W$. +Delete from $T^+$ the images of those with coefficient zero in +$\Theta_W$, and call the resulting open set $U$. Proper mapping +makes the deleted set closed analytic. None of these images contains +$S$, so their finite union cannot contain the irreducible surface $S$; +in particular, $U\cap S$ is a dense open subset of $S$. + +We check ordinary terminality on $U$ using local analytic places. +Restrict the resolution and \eqref{eq:ordinary-boundary} over $U$. +Every local component of its exceptional divisor now has strictly +negative coefficient in $\Theta_W$. If a local exceptional place +$E$ over $U$ has divisorial centre on this resolution, it is the place +of that divisor. The divisor must be exceptional over $U$, since +otherwise $E$ would not be exceptional. Its negative coefficient +therefore gives ordinary log discrepancy greater than one. + +For any remaining local exceptional place, take a common local +resolution. Its centre on the smooth space $r^{-1}(U)$ has +codimension at least two. Since $\Theta_W\leq0$, +Lemma~\ref{lem:jacobian} gives +\[ + a(E;U,0)=a(E;r^{-1}(U),\Theta_W|_{r^{-1}(U)}) + \geq a(E;r^{-1}(U),0)\geq2. +\] +This checks all local exceptional places and proves ordinary +terminality. The canonical rational line bundle restricts to $U$, +so Lemma~\ref{lem:terminal-smooth} applies there. Its singular locus +has codimension at least three and cannot contain the surface +$S\cap U$. Thus $T^+$ is smooth at a general point of $S$. +\end{proof} + +\subsection{The blowup divisor and its discrepancy} + +Fix an integer $m>0$ such that $mM'$ is a Cartier divisor and $mb$ is an +integer for every positive coefficient $b$ of $B_0$. The same integer +clears all boundary coefficients on every model, since the boundaries are +strict transforms. Moreover +\begin{equation} + mM_T\text{ is an integral Weil divisor on every model }T. + \label{eq:integral-nef-traces} +\end{equation} +Indeed, on a common model carrying the data, $mM_W$ is the pullback of the +integral Cartier divisor $mM'$, and pushforward preserves integral Weil +coefficients. Although \eqref{eq:integral-nef-traces} does not assert +global Cartierness of $mM_T$, it implies Cartierness on the smooth locus +of $T$. + +\begin{proposition}[A witness for every flipped surface] +\label{prop:witnesses} +Consider the $i$-th step of a sequence as in Theorem~\ref{thm:termination}, with target +$T^+=X_{i+1}$. Let $S$ be an irreducible surface contained in its flipped +locus. There is a global prime place $E_S$, with centre $S$ on $T^+$, +obtained by blowing up $S$ at its general smooth point. It is exceptional +over every model of the sequence. Write +\[ + B_{i+1}=\sum_{\ell} b_{\ell}H_{\ell}, + \qquad b_{\ell}>0, +\] +and let $r\colon W\to T^+$ be a smooth model that is projective over +$T^+$ and carries both $E_S$ and the fixed nef data. With +$J_W=r^*M_{i+1}-M_W$, one has +\begin{equation} + a(E_S;X_{i+1},B_{i+1}+\bM) + =2-\sum_{\ell}b_{\ell}\operatorname{mult}_S(H_{\ell}) + -\operatorname{coeff}_{E_S}(J_W). + \label{eq:witness-discrepancy} +\end{equation} +In particular, +\begin{equation} + a(E_S;X_{i+1},B_{i+1}+\bM) + \in\Lambda_m:=(1,2]\cap\tfrac1m\Z + =\left\{1+\tfrac1m,1+\tfrac2m,\ldots,2\right\}. + \label{eq:witness-grid} +\end{equation} +Its discrepancy on the source is strictly below two. If $S$ is contained +in a component of $B_{i+1}$ of coefficient $b>0$, then more precisely +\begin{equation} + a(E_S;X_i,B_i+\bM) + < a(E_S;X_{i+1},B_{i+1}+\bM)\leq2-b. + \label{eq:witness-threshold} +\end{equation} +\end{proposition} + +\begin{proof} +By Proposition~\ref{prop:ordinary-terminal}, a general point of the +surface $S$ is a smooth point of both $T^+$ and $S$. +Blow up the global coherent +ideal of the reduced analytic subspace $S$. Over the open subset where +$T^+$ and $S$ are smooth, this is the blowup of a smooth codimension-two +centre, with one exceptional prime dominating that open subset of $S$. +After normalization the preimage of $S$ is a compact analytic subset +with finitely many irreducible components. One of these contains this +exceptional divisor and dominates $S$, by proper mapping; the smooth +calculation gives uniqueness. It is a global prime divisor, and we +denote its place by $E_S$. Resolve further and use +Proposition~\ref{prop:common-models} to obtain a smooth model $W$, +projective over $T^+$, carrying it and the nef data. The centre on $T^+$ is $S$, so it is +exceptional there. Smallness of every step preserves exceptionalness, +as in Proposition~\ref{prop:comparison}, and therefore it is exceptional +over every $X_j$. + +The ordinary log discrepancy of the blowup at a smooth codimension-two +centre is two. Pulling back a boundary component $H_{\ell}$ subtracts +$b_{\ell}\operatorname{mult}_S(H_{\ell})$, where the generic +multiplicity is a nonnegative integer and is zero unless $S\subset +H_{\ell}$. The identity +\[ + \Delta_W=r^*(K_{T^+}+B_{i+1})-K_W+J_W +\] +then proves \eqref{eq:witness-discrepancy}. This computation only uses +the smooth general point of the centre. The boundary components may be +singular or intersect one another along $S$. + +Lemma~\ref{lem:nef-defect} gives +$\operatorname{coeff}_{E_S}(J_W)\geq0$. It also lies in +$\tfrac1m\Z$. To verify this denominator claim, restrict to a smooth +open subset of $T^+$ meeting a general point of $S$. +By \eqref{eq:integral-nef-traces}, $mM_{i+1}$ is an integral Cartier +divisor there, so its pullback has integral order along $E_S$. +The divisor $mM_W$ is integral Cartier as the pullback of $mM'$. +Consequently the coefficient of +\[ + mJ_W=r^*(mM_{i+1})-mM_W +\] +along $E_S$ is an integer. This is a local calculation near the general +point of $S$, and does not require $mM_{i+1}$ to be Cartier elsewhere. + +Every term subtracted from two in \eqref{eq:witness-discrepancy} is +nonnegative and belongs to $\tfrac1m\Z$. Since the target centre is +contained in $L_i^+$, strict increase in +Proposition~\ref{prop:comparison} and generalized canonicity on the +source give +\[ + a(E_S;X_{i+1},B_{i+1}+\bM) + >a(E_S;X_i,B_i+\bM)\geq1. +\] +These facts prove \eqref{eq:witness-grid}. If $S$ is contained in a component +of coefficient $b$, its generic multiplicity is at least one, so +\eqref{eq:witness-discrepancy} bounds the target discrepancy by $2-b$. +This proves \eqref{eq:witness-threshold}; without that containment the +same argument gives the strict source bound below two. +\end{proof} + +Call a place chosen by Proposition~\ref{prop:witnesses} a \emph{witness} +for the corresponding flipped surface. The possible target discrepancies +of witnesses form the fixed finite set $\Lambda_m$. A place that is used +again must reach a strictly larger member of this set. + +\begin{lemma}[Finite use of each witness] +\label{lem:finite-use} +Let $I$ be any set of step indices in a sequence as in Theorem~\ref{thm:termination}. For every +$i\in I$, choose a flipped surface of the $i$-th step and a witness $E_i$ +as in Proposition~\ref{prop:witnesses}. Then each fixed place $E$ +occurs among the $E_i$ at most $m$ times. Consequently, if all the +$E_i$ belong to a fixed finite collection $\mathcal F$, then +$\#I\leq m\,\#\mathcal F$. +\end{lemma} + +\begin{proof} +Suppose $i0$ recovers its +chart coordinate as $w/t$. Locally all blocks extend smoothly to an +ambient chart, and this left inverse shows that the embedding is locally +an ambient smooth embedding. It therefore preserves the Whitney +conditions. Mather's control data +\cite[Section~7, Proposition~7.1, and Section~8]{Mather1970} and +Goresky's triangulation theorem \cite[Section~5]{Goresky1978} give a +triangulation compatible with the strata and smooth on them. Compactness +makes it finite; smoothness on the strata gives the stated dimension +bound. In particular, $H_4(V,\R)$ is finite-dimensional and $c_2(V)$ +is a finite nonnegative integer. + +We will also use Borel--Moore homology $H_*^{\mathrm{BM}}$, defined by +locally finite chains. It agrees with ordinary homology on compact +spaces, and it allows a fundamental class to be restricted to an open +subset even when that subset is noncompact. For a closed analytic +subset $A\subset V$ of a compact analytic space, compatible +triangulations give the localization exact sequence +\begin{equation}\label{eq:bm-localization} + \cdots\longrightarrow H_j(A,\R)\longrightarrow H_j(V,\R) + \xrightarrow{\ j^*\ } H_j^{\mathrm{BM}}(V\setminus A,\R) + \longrightarrow H_{j-1}(A,\R)\longrightarrow\cdots. +\end{equation} +This is the homological sequence for the closed subset and its open +complement. In a compatible triangulation, the Borel--Moore group of +the complement is the homology of the relative chain complex for +$(V,A)$, so the sequence follows from the long exact sequence of that +pair; see +\cite[Sections~1.2 and~1.6]{BorelHaefliger1961}. +If $S$ is an irreducible surface, its singular +locus has real dimension at most two. Applying this sequence to that +locus extends the oriented fundamental class of $S_{\mathrm{reg}}$ +uniquely to a class in $H_4(S,\R)$. This is the analytic fundamental +class used in \eqref{eq:cycle-rank}. Its restriction to any open subset +is the corresponding Borel--Moore fundamental class; see also +\cite[Section~3.1 and Theorem~3.2]{BorelHaefliger1961}. + +K\"ahler positivity supplies the nonvanishing needed for strict rank +loss. If $V$ is a closed reduced analytic subspace of a compact +K\"ahler space $Y$, and $S\subset V$ is an irreducible surface, then +the local potentials of a K\"ahler form $\omega$ on $Y$ define a class +$[\omega]\in H^2(Y,\R)$. Here is the construction on the possibly +singular space. Let $\mathcal{PH}_Y$ be the sheaf of functions locally +equal to the real part of a holomorphic function. The differences of +the potentials form a cocycle in this sheaf. The connecting +homomorphism for the exact sequence +\[ + 0\longrightarrow\R_Y\xrightarrow{\,\sqrt{-1}\,}\mathcal O_Y + \xrightarrow{\,\operatorname{Re}\,}\mathcal{PH}_Y + \longrightarrow0 +\] +gives $[\omega]$, with the normalization agreeing with the de~Rham +class on smooth spaces. Constant-sheaf cohomology agrees with +singular cohomology because analytic spaces are locally contractible, +as also follows from the compatible triangulations above. The +construction commutes with holomorphic pullback; hence its pullback +to a resolution is the de~Rham class of the pulled-back form. We obtain +\begin{equation}\label{eq:positive-surface-class} + \bigl\langle[\omega]^2,[S]\bigr\rangle + =\int_{S_{\mathrm{reg}}}\omega^2>0. +\end{equation} +The pairing here is taken in $Y$. To compute it, choose a resolution +$r:\widetilde S\to S$ that is an isomorphism over $S_{\mathrm{reg}}$. +Since $r_*[\widetilde S]=[S]$, the pairing equals +$\int_{\widetilde S}(r^*\omega)^2$. The pulled-back form is +semipositive everywhere and positive on the open set mapping to +$S_{\mathrm{reg}}$, which proves the strict inequality. Consequently +the class of $S$ is nonzero in $H_4(Y,\R)$ and hence also in +$H_4(V,\R)$. + +\begin{lemma}[Cycle loss]\label{lem:cycle-loss} +Let $P$ and $Q$ be compact reduced complex analytic spaces, and let +$L_P\subset P$ and $L_Q\subset Q$ be closed analytic subsets with +dense complements. Suppose an isomorphism +\[ + U=P\setminus L_P\simeq Q\setminus L_Q +\] +is represented by a proper bimeromorphic graph: there is a compact +reduced analytic space $G$ with proper projections $p:G\to P$ and +$q:G\to Q$ such that the common open +\begin{equation}\label{eq:cycle-graph-open} + p^{-1}(P\setminus L_P)=q^{-1}(Q\setminus L_Q) +\end{equation} +is dense in $G$ and maps isomorphically to both displayed complements. +If $\dim L_Q\leq1$, there is a surjection +\[ + \mathcal C_2(P)\longrightarrow\mathcal C_2(Q), + \qquad\text{and thus}\qquad c_2(P)\geq c_2(Q). +\] +If $L_P$ contains an irreducible surface whose class in $H_4(P,\R)$ is nonzero, +then $c_2(P)>c_2(Q)$. In particular, strict inequality holds whenever +$L_P$ contains a surface and $P$ is a closed analytic subspace of a +compact K\"ahler space. +\end{lemma} + +\begin{proof} +The restriction from $Q$ will identify its fourth homology with the +fourth Borel--Moore homology of the common open. We then compare the +surface classes by their restrictions there. + +Since $L_Q$ has real dimension at most two, +$H_4(L_Q,\R)=H_3(L_Q,\R)=0$. The degree-four part of +\eqref{eq:bm-localization} is therefore +\[ + 0\longrightarrow H_4(Q,\R) + \xrightarrow{\ j_Q^*\ }H_4^{\mathrm{BM}}(U,\R) + \longrightarrow0. +\] +Define the linear map +\begin{equation}\label{eq:cycle-comparison-map} + \Phi=(j_Q^*)^{-1}\circ j_P^*: + H_4(P,\R)\longrightarrow H_4(Q,\R). +\end{equation} + +To determine $\Phi$ on surface classes, we first check that strict +transforms are analytic, without a normality hypothesis. Let +$S\subset P$ be an irreducible surface not contained in $L_P$. +Removing a proper analytic subset from an irreducible analytic space +leaves an irreducible space: its regular locus remains connected after +removing an analytic subset of positive complex codimension +\cite[Section~3.3]{BorelHaefliger1961}. Thus +$S\cap U$ is irreducible. The analytic inverse image $p^{-1}(S)$ has +a unique irreducible component $\widetilde S$ meeting the open where +$p$ and $q$ are isomorphisms; there it agrees with $S\cap U$. +This component is a compact irreducible surface. Remmert's proper +mapping theorem shows that +\[ + S^+:=q(\widetilde S)\subset Q +\] +is an irreducible analytic surface, agreeing with $S\cap U$ on $U$. +It is the strict transform of $S$. The same construction with $p$ and +$q$ interchanged gives strict transforms in the other direction. + +The restrictions of $[S]$ and $[S^+]$ to $U$ are the same oriented +fundamental class, so \eqref{eq:cycle-comparison-map} gives +$\Phi([S])=[S^+]$. If instead $S\subset L_P$, its restriction +vanishes and $\Phi([S])=0$. It follows that $\Phi$ maps +$\mathcal C_2(P)$ into $\mathcal C_2(Q)$. Every irreducible surface +in $Q$ meets $U$, since $\dim L_Q\leq1$; its strict transform in $P$ +therefore maps back to its class. The induced map of cycle spans is +surjective. Finally, a nonzero surface class supported in $L_P$ lies +in its kernel. Finite-dimensionality gives the strict rank inequality, +and \eqref{eq:positive-surface-class} gives the stated K\"ahler case. +\end{proof} + +Here are the two applications to a flip +$T\to Z\leftarrow T^+$ with exceptional loci $L,L^+$. +Let $A\subset Z$ be the common exceptional image furnished by +Proposition~\ref{prop:comparison}. On the normalized graph of the +flip, with projections $p,q$ and common composite $h$ to $Z$, one has +\[ + p^{-1}(T\setminus L)=h^{-1}(Z\setminus A) + =q^{-1}(T^+\setminus L^+). +\] +Both projections are isomorphisms there. Thus this graph gives exactly +the diagram required by Lemma~\ref{lem:cycle-loss} for $P=T$, $Q=T^+$. +For a boundary component $H\subset T$ and its transform +$H^+\subset T^+$, give both spaces their reduced structures and put +\[ + L_H=H\cap L,\qquad L_{H^+}=H^+\cap L^+. +\] +Smallness ensures that the complementary opens are dense and +identified. In the compact analytic fibre product $H\times_Z H^+$, +take the reduced irreducible component $G_H$ containing their common +open graph, with projections $p_H,q_H$ and common composite $h_H$ to +$Z$. This component exists because the fibre product over +$Z\setminus A$ is precisely that graph. Its projections are proper, +and the common open is dense in it. Moreover +\[ + p_H^{-1}(H\setminus L_H)=h_H^{-1}(Z\setminus A) + =q_H^{-1}(H^+\setminus L_{H^+}), +\] +with both projections isomorphisms on this open. This verifies +\eqref{eq:cycle-graph-open}, including equality of the inverse images; +normality of $H$ and $H^+$ is unnecessary. +In particular, when $H^+$ contains no flipped surface, +$\dim L_{H^+}\leq1$, so $c_2(H)\geq c_2(H^+)$. The inequality is +strict if $H$ contains a flipping surface, because $H$ is a closed +analytic subspace of the K\"ahler fourfold $T$. The surjectivity used +throughout is the surjectivity on the spans of surface classes proved +above; no surjectivity of \eqref{eq:cycle-comparison-map} on all homology +is needed. diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/07-termination.tex b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/07-termination.tex new file mode 100644 index 0000000000000000000000000000000000000000..2c2a0d75312b0a2426557dc9965d54e6d08658e4 --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/build/build/sections/07-termination.tex @@ -0,0 +1,144 @@ +\section{Termination by descending boundary coefficients} +\label{sec:termination} + +We now combine the two counts. At each positive boundary coefficient, +the witness count first excludes flipped surfaces, and the cycle count +then excludes flipping surfaces. The same witness count at threshold +two removes all remaining flipped surfaces, after which the ranks of +surface classes on the fourfolds decrease at every step. + +Write $L_i$ and $L_i^+$ for the exceptional loci of step $i$, so that +flipping surfaces lie in $L_i$ and flipped surfaces lie in $L_i^+$. +Proposition~\ref{prop:comparison} gives +\begin{equation}\label{eq:final-dimension} + \dim L_i\leq2,\qquad \dim L_i^+\leq2,\qquad + \dim L_i+\dim L_i^+\geq3. +\end{equation} +Smallness identifies the finitely many positive boundary +components and preserves their coefficients. + +\begin{lemma}[Persistence of a surface centre]\label{lem:persistence} +Let $T\dashrightarrow T^+$ be a step of a sequence as in +Theorem~\ref{thm:termination}, and let $E$ be an exceptional place +whose centre on $T$ is a surface $S$. If $S$ is not contained in the +source exceptional locus, its target centre is the strict transform +of $S$, a surface meeting the common isomorphic open. If $S$ +lies in a boundary component, its transform lies in the +corresponding component. +\end{lemma} + +\begin{proof} +Represent the place on a common higher model. Its image onto $S$ is +surjective by the definition of the centre and properness. The inverse +image of the dense open portion of $S$ on which the step is an +isomorphism is nonempty and dense in $E$. There the two centre maps agree. +The closure of this portion's target image is both the strict +transform of $S$ and the whole target centre. The assertions +follow. +\end{proof} + +The following count isolates the argument used at each coefficient, +including the final value $b=0$. Write +$a_i(E)=a(E;X_i,B_i+\bM)$ and fix the integer $m$ of +Proposition~\ref{prop:witnesses}. + +\begin{lemma}[Counting flipped surfaces] +\label{lem:coefficient-witness-count} +Consider a tail beginning with $X_N$ of a sequence as in +Theorem~\ref{thm:termination}. Let $b$ be either zero or a positive +boundary coefficient. Suppose no flipping surface at any step of the +tail lies in a boundary component of coefficient greater than $b$. +If $b>0$, only finitely many steps of the tail have a flipped surface +contained in a coefficient-$b$ boundary component. If $b=0$, only +finitely many steps of the tail have any flipped surface. +\end{lemma} + +\begin{proof} +At every step $i$ under consideration, choose one such flipped surface +and its witness $E_i$ from Proposition~\ref{prop:witnesses}. The place +is exceptional over $X_N$, and discrepancy monotonicity gives +\begin{equation}\label{eq:tail-witness-bound} + a_N(E_i)\leq a_i(E_i)b$. By the hypothesis on flipping surfaces, this surface +centre is not contained in $L_N$. Lemma~\ref{lem:persistence} carries +it to a surface in the corresponding coefficient-$d$ component on +$X_{N+1}$. At each successive step up to and including step $i$, the +same hypothesis and lemma apply. Consequently the centre on $X_{i+1}$ +meets $X_{i+1}\setminus L_i^+$. This contradicts its definition as +the chosen flipped surface, which is contained in $L_i^+$. + +Every chosen witness therefore belongs to the fixed finite set +$\mathcal F_{X_N}$. Lemma~\ref{lem:finite-use} permits each place to +be used at most $m$ times, since its discrepancies on witness targets +are strictly increasing members of $(1,2]\cap m^{-1}\Z$. There are +at most $m\,\#\mathcal F_{X_N}$ steps under consideration. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:termination}] +Suppose the sequence is infinite. Proposition~\ref{prop:comparison} +preserves generalized canonicality: every exceptional place has +log discrepancy at least one on every model. The strict bound greater +than one used in the witness count holds on the target of its witness +step by strict discrepancy increase. No terminality of the whole +model is used. + +Order the distinct positive boundary coefficients as +$b_1>\cdots>b_s>0$. Inductively pass to tails on which no flipping +or flipped surface lies in a component of any coefficient already +treated. Start with the full sequence. For the next coefficient +$b=b_j$, the induction hypothesis satisfies the assumption of +Lemma~\ref{lem:coefficient-witness-count}. Passing beyond the finitely +many steps it counts leaves a tail with no flipped surface in any +coefficient-$b$ component. + +Index those components on the initial model by a finite set $I_b$, +and write $H_{i,\alpha}$ for their strict transforms on $X_i$, +$\alpha\in I_b$. Smallness preserves this indexing. Each target +component now satisfies +\[ + \dim(H_{i+1,\alpha}\cap L_i^+)\leq1. +\] +Otherwise this intersection would contain a flipped surface. +The boundary-component application of Lemma~\ref{lem:cycle-loss} +therefore gives +\[ + c_2(H_{i,\alpha})\geq c_2(H_{i+1,\alpha}), +\] +with strict inequality whenever $H_{i,\alpha}$ contains a flipping +surface. The hypotheses were checked in Section~\ref{sec:cycles} +for the reduced components, without normalizing them. In particular, +K\"ahler positivity in $X_i$ makes every removed surface class nonzero +in $H_4(H_{i,\alpha},\R)$. + +It follows that the finite nonnegative integer +\[ + r_b(i):=\sum_{\alpha\in I_b}c_2(H_{i,\alpha}) +\] +does not increase and decreases strictly at each step with a flipping +surface in a coefficient-$b$ component. Only finitely many such +steps occur. Pass beyond them to finish this stage. + +After all positive coefficients have been treated, the hypothesis of +Lemma~\ref{lem:coefficient-witness-count} holds with $b=0$. If +$B_0=0$, the positive-coefficient induction is empty and this hypothesis +already holds on the original sequence. Pass beyond the finitely many +steps having a flipped surface. On the resulting tail, +$\dim L_i^+\leq1$, whereas \eqref{eq:final-dimension} forces $L_i$ to +contain a surface. Lemma~\ref{lem:cycle-loss}, applied to the +fourfolds themselves, gives +\[ + c_2(X_i)>c_2(X_{i+1}) +\] +at every remaining step. These are finite nonnegative integers, so +they cannot decrease strictly along an infinite tail. This proves +termination. +\end{proof} diff --git a/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf new file mode 100644 index 0000000000000000000000000000000000000000..87d46ab86982abb86dbd3e81e25bc44317b4930a --- /dev/null +++ b/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6f647b4844ccefe7352ae5883e8a727c13bbd545b5df68a385852b669d55dadd +size 396720 diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/README.md b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..538b43c49a4d7e74803f35e322237afaddee304d --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/README.md @@ -0,0 +1,21 @@ +# [Termination of generalized log canonical flips on compact Kähler fourfolds](termination-generalized-lc-kahler-fourfolds.pdf) + +**Author:** OpenAI + +**Date:** October 7, 2026 + +## Citation + +```bibtex +@misc{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026, + author = {{OpenAI}}, + title = {{Termination of generalized log canonical flips on compact K{\"a}hler fourfolds}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/termination-generalized-lc-kahler-fourfolds.pdf}{OAI:Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026}}, + year = {2026} +} +``` + +## Version note + +This version clarifies the independent relative MMP and birational-comparison inputs used by the proof and updates citations to revised companion papers; see the [previous version](../Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-5-2026/termination-generalized-lc-kahler-fourfolds.pdf). diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/main.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..d30f4cfb6a8a967bb2d6f8aed31ad29dcccee88e --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/main.tex @@ -0,0 +1,68 @@ +\documentclass[11pt]{amsart} +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage{microtype} +\usepackage[margin=1.05in]{geometry} +\usepackage{mathtools,amssymb} +\usepackage{tikz-cd} +\usepackage{graphicx} +\usepackage{hyperref} +\hypersetup{hidelinks,pdftitle={Termination of generalized log canonical flips on compact Kahler fourfolds},pdfauthor={OpenAI}} + +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{notation}[theorem]{Notation} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newtheorem*{claim}{Claim} +\numberwithin{equation}{section} + +\newcommand{\Q}{\mathbb{Q}} +\newcommand{\R}{\mathbb{R}} +\newcommand{\Z}{\mathbb{Z}} +\newcommand{\C}{\mathbb{C}} +\newcommand{\M}{\mathbf{M}} +\DeclareMathOperator{\Exc}{Exc} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\Sing}{Sing} +\DeclareMathOperator{\cent}{cent} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\codim}{codim} +\DeclareMathOperator{\rk}{rk} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\coker}{coker} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\Proj}{Proj} +\DeclareMathOperator{\IC}{IC} +\DeclareMathOperator{\Gr}{Gr} +\newcommand{\BM}{\mathrm{BM}} +\allowdisplaybreaks[2] +\setcounter{tocdepth}{1} +\emergencystretch=2em + +\title[Generalized log canonical flips on K\"ahler fourfolds]{Termination of generalized log canonical flips\newline on compact K\"ahler fourfolds} +\author{OpenAI} +\date{October 7, 2026} + +\begin{document} +\begin{abstract} +\input{sections/00-abstract} +\end{abstract} +\maketitle +\tableofcontents + +\input{sections/01-introduction} +\input{sections/02-preliminaries} +\input{sections/03-comparisons} +\input{sections/04-terminal-junctions} +\input{sections/05-branch-topology} +\input{sections/06-curve-places} +\input{sections/07-difficulty} +\input{sections/08-completion} +\input{references} +\end{document} diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/references.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/references.tex new file mode 100644 index 0000000000000000000000000000000000000000..702426b85c60bc8d1c67ba986a386a8e6243cc1b --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/references.tex @@ -0,0 +1,167 @@ +\begin{thebibliography}{99} +\raggedright + +\bibitem{AlexeevHaconKawamata2007} +Valery Alexeev, Christopher Hacon, and Yujiro Kawamata, +\emph{Termination of (many) 4-dimensional log flips}, +Invent. Math. \textbf{168} (2007), no.~2, 433--448. +\url{https://doi.org/10.1007/s00222-007-0038-1}. + +\bibitem{BierstoneMilman1997} +Edward Bierstone and Pierre D. Milman, +\emph{Canonical desingularization in characteristic zero by blowing up the +maximum strata of a local invariant}, +Invent. Math. \textbf{128} (1997), no.~2, 207--302. +\url{https://doi.org/10.1007/s002220050141}. + +\bibitem{BirkarZhang2016} +Caucher Birkar and De-Qi Zhang, +\emph{Effectivity of Iitaka fibrations and pluricanonical systems of polarized pairs}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{123} (2016), 283--331. +\url{https://doi.org/10.1007/s10240-016-0080-x}. + +\bibitem{ChenTsakanikas2023} +Guodu Chen and Nikolaos Tsakanikas, +\emph{On the termination of flips for log canonical generalized pairs}, +Acta Math. Sin. (Engl. Ser.) \textbf{39} (2023), no.~6, 967--994. +\url{https://doi.org/10.1007/s10114-023-0116-3}. + +\bibitem{DeligneLefschetz} +Pierre Deligne, +\emph{Th\'eor\`eme de Lefschetz et crit\`eres de d\'eg\'en\'erescence de suites spectrales}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{35} (1968), 107--126. +\url{https://doi.org/10.1007/BF02698925}. + +\bibitem{DeligneHodgeII} +Pierre Deligne, +\emph{Th\'eorie de Hodge : II}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{40} (1971), 5--57. +\url{https://doi.org/10.1007/BF02684692}. + +\bibitem{DeligneHodgeIII} +Pierre Deligne, +\emph{Th\'eorie de Hodge : III}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{44} (1974), 5--77. +\url{https://doi.org/10.1007/BF02685881}. + +\bibitem{ForstnericStein} +Franc Forstneri\v{c}, +\emph{Extending holomorphic mappings from subvarieties in Stein manifolds}, +Ann. Inst. Fourier (Grenoble) \textbf{55} (2005), no.~3, 733--751. +\url{https://doi.org/10.5802/aif.2112}. + +\bibitem{Fujino2005Addendum} +Osamu Fujino, +\emph{Addendum to \textquotedblleft Termination of 4-fold canonical flips\textquotedblright}, +Publ. Res. Inst. Math. Sci. \textbf{41} (2005), no.~1, 251--257. +\url{https://doi.org/10.2977/PRIMS/1145475410}. + +\bibitem{FujinoAnalyticMMP} +Osamu Fujino, +\emph{Minimal model program for projective morphisms between complex analytic spaces}, +arXiv:2201.11315v1 (2022). +\url{https://arxiv.org/abs/2201.11315v1}. + +\bibitem{GoreskyMacPhersonIHII} +Mark Goresky and Robert MacPherson, +\emph{Intersection homology II}, +Invent. Math. \textbf{72} (1983), no.~1, 77--129. +\url{https://doi.org/10.1007/BF01389130}. + +\bibitem{Grauert1962} +Hans Grauert, +\emph{\"Uber Modifikationen und exzeptionelle analytische Mengen}, +Math. Ann. \textbf{146} (1962), 331--368. +\url{https://doi.org/10.1007/BF01441136}. + +\bibitem{GrothendieckHilbert1961} +Alexander Grothendieck, +\emph{Techniques de construction et th\'eor\`emes d'existence en g\'eom\'etrie +alg\'ebrique IV : les sch\'emas de Hilbert}, +in \emph{S\'eminaire Bourbaki : ann\'ees 1960/61, expos\'es 205--222}, +S\'eminaire Bourbaki \textbf{6}, Soci\'et\'e Math\'ematique de France, +1961, Expos\'e 221, 249--276; erratum, vol.~7 (1962), p.~302. +\url{https://www.numdam.org/item/SB_1960-1961__6__249_0/}. + +\bibitem{HaconMoraga2020} +Christopher Hacon and Joaqu\'in Moraga, +\emph{On weak Zariski decompositions and termination of flips}, +Math. Res. Lett. \textbf{27} (2020), no.~5, 1393--1421. +\url{https://doi.org/10.4310/MRL.2020.v27.n5.a6}. + +\bibitem{HaconXie2026} +Christopher Hacon and Lingyao Xie, +\emph{On the K\"ahler MMP and the transcendental base-point-free theorem}, +arXiv:2607.24986v1 (2026), submitted July 27, 2026. +\url{https://arxiv.org/abs/2607.24986v1}. + +\bibitem{HanLiuZhuang2025} +Jingjun Han, Jihao Liu, and Ziquan Zhuang, +\emph{Effective termination of general type MMPs in dimension at most five}, +arXiv:2509.01501v1 (2025). +\url{https://arxiv.org/abs/2509.01501v1}. + +\bibitem{KawamataMatsudaMatsuki1987} +Yujiro Kawamata, Katsumi Matsuda, and Kenji Matsuki, +\emph{Introduction to the minimal model problem}, +in \emph{Algebraic Geometry, Sendai, 1985}, Tadao Oda (ed.), +Advanced Studies in Pure Mathematics \textbf{10}, +North-Holland, Amsterdam, 1987, 283--360. +\url{https://doi.org/10.2969/aspm/01010283}. + +\bibitem{Moraga2025} +Joaqu\'in Moraga, +\emph{Termination of pseudo-effective 4-fold flips}, +Math. Z. \textbf{310} (2025), no.~4, Article 73, 32 pp. +\url{https://doi.org/10.1007/s00209-025-03766-y}. + +\bibitem{KahlerAuxiliary} +OpenAI, +\emph{Finite ordinary minimal model programs on compact K\"ahler fourfolds}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf}{OAI:Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026}, +2026. + +\bibitem{ProjectiveLCFourfolds} +OpenAI, +\emph{Termination for projective log canonical fourfolds with rational boundary}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Termination-for-projective-log-canonical-fourfolds-with-rational-boundary-September-24-2026/paper.pdf}{OAI:Termination-for-projective-log-canonical-fourfolds-with-rational-boundary-September-24-2026}, +2026. + +\bibitem{CanonicalKahler} +OpenAI, +\emph{Termination of generalized-canonical flips on compact K\"ahler fourfolds}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf}{OAI:Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026}, +2026. + +\bibitem{RaynaudSGA1XII} +Mich\`ele Raynaud, +\emph{G\'eom\'etrie alg\'ebrique et g\'eom\'etrie analytique}, +in \emph{Rev\^etements \'etales et groupe fondamental (SGA 1)}, +Alexander Grothendieck (ed.), Lecture Notes in Mathematics \textbf{224}, +Springer-Verlag, Berlin--Heidelberg, 1971, Expos\'e XII, 311--343. +\url{https://doi.org/10.1007/BFb0058667}. + +\bibitem{SaitoMHP} +Morihiko Saito, +\emph{Modules de Hodge polarisables}, +Publ. Res. Inst. Math. Sci. \textbf{24} (1988), no.~6, 849--995. +\url{https://doi.org/10.2977/PRIMS/1195173930}. + +\bibitem{SerreGAGA} +Jean-Pierre Serre, +\emph{G\'eom\'etrie alg\'ebrique et g\'eom\'etrie analytique}, +Ann. Inst. Fourier (Grenoble) \textbf{6} (1956), 1--42. +\url{https://doi.org/10.5802/aif.59}. + +\bibitem{ShokurovNonvanishing} +V. V. Shokurov, +\emph{The nonvanishing theorem}, +Math. USSR-Izv. \textbf{26} (1986), no.~3, 591--604. +Russian original: Izv. Akad. Nauk SSSR Ser. Mat. \textbf{49} (1985), +no.~3, 635--651. +\url{https://doi.org/10.1070/IM1986v026n03ABEH001160}. + +\end{thebibliography} diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/00-abstract.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/00-abstract.tex new file mode 100644 index 0000000000000000000000000000000000000000..3cde29ccba7587620fda31b995e9e468f6234861 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/00-abstract.tex @@ -0,0 +1 @@ +Every sequence of generalized log canonical flips on a normal irreducible globally Weil \(\Q\)-factorial compact K\"ahler fourfold terminates, provided the flips are projective small diagrams with the stated opposite ample signs. The boundary is rational, and the nef b-divisor is fixed and represented by an analytically nef \(\Q\)-Cartier divisor on a projective modification. No scaling rule or pseudo-effectivity assumption is required. The theorem concerns existing flip sequences; it does not assert the existence of all contractions or flips. diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/01-introduction.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..f8d4614e72276e22c4c72372166daede96e7e695 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/01-introduction.tex @@ -0,0 +1,62 @@ +\section{Introduction}\label{sec:introduction} + +Termination of flips rules out an endless sequence of small birational improvements in the minimal model program. Since flips contract no divisors, their number cannot be bounded by counting divisors that disappear. In dimension four, exceptional surfaces bring places centered on surfaces and curves into the argument. On compact K\"ahler spaces, the contractions may be projective even when the ambient fourfold has no ample line bundle. + +Shokurov's difficulty counts exceptional divisors with small discrepancy to measure the improvement of singularities \cite[Definition~2.15 and Corollaries~2.16--2.17]{ShokurovNonvanishing}. Kawamata, Matsuda, and Matsuki combined it with the rank of surface cycle classes to prove termination of terminal fourfold flips in the algebraic setting \cite[Theorem~5-1-15]{KawamataMatsudaMatsuki1987}. For boundaries, Fujino's corrected argument for canonical fourfold pairs exhibits the recurring contributions from successive blowups over a codimension-two center \cite[Example~2.1 and Theorems~5.1--5.2]{Fujino2005Addendum}. Alexeev, Hacon, and Kawamata developed a weighted difficulty that subtracts these contributions and tracks cycles on normalized boundary components \cite[Section~2]{AlexeevHaconKawamata2007}. Discrepancy improvement and the behavior of boundary cycles also guide the proof here. + +Generalized pairs place part of the adjoint data on a higher birational model: a nef divisor there contributes its trace on the space carrying the boundary \cite[Definitions~1.4 and 4.1]{BirkarZhang2016}. For algebraic generalized pairs, Hacon and Moraga gave a termination reduction using weak Zariski decompositions \cite[Theorem~1]{HaconMoraga2020}. Termination for pseudo-effective generalized log canonical fourfolds with NQC nef data was proved by Chen and Tsakanikas \cite[Theorem~1.1]{ChenTsakanikas2023} and by Moraga \cite[Theorem~4.4]{Moraga2025}. Here NQC means a nonnegative real combination of nef \(\Q\)-Cartier divisors on the higher model. Han, Liu, and Zhuang proved termination of ordinary klt fourfold minimal model programs when the boundary is big over the fixed algebraic base \cite[Corollary~3.2(3)]{HanLiuZhuang2025}. + +Hacon and Xie formulate a termination conjecture for generalized klt pairs with higher \((1,1)\)-class data on compact K\"ahler spaces \cite[Conjecture~1.15]{HaconXie2026}. The generalized klt case of the theorem below treats a four-dimensional rational-divisor form of that question under the stated projectivity and global Weil \(\Q\)-factoriality assumptions; the theorem also permits generalized log canonical singularities. Its ambient spaces may be nonprojective, and the prescribed small diagrams may vary their bases and choices under the hypotheses below. + +A normal compact complex space \(X\) is \emph{globally Weil \(\Q\)-factorial} if every prime Weil divisor defined on all of \(X\) is \(\Q\)-Cartier and some positive reflexive power of its canonical sheaf is invertible. Projective morphisms of complex spaces are understood in the analytic sense: they admit a relatively ample holomorphic line bundle. A \(\Q\)-Cartier divisor is relatively ample if a positive Cartier multiple is relatively ample. + +For a normal compact K\"ahler space \(X\), a rational nef b-divisor \(\M\) in this paper is represented by a \(\Q\)-Cartier divisor \(M'\) on a normal compact K\"ahler space \(X'\) with a projective bimeromorphic map \(\pi:X'\to X\). We require \(c_1(M')\) to lie in the closure of the K\"ahler cone in real Bott--Chern cohomology. On a model dominating \(X'\), the trace \(M_W\) is the pullback of \(M'\); on another model it is the pushforward from a common higher model. The divisor \(M'\) need not be effective. + +We use compatible actual canonical divisor representatives on the birational models under consideration. Given an effective rational Weil divisor \(B\) of finite support for which \(D_X=K_X+B+M_X\) is \(\Q\)-Cartier, choose a smooth proper bimeromorphic model \(p:W\to X\) dominating \(X'\) and write +\begin{equation}\label{eq:discrepancy-definition} + K_W+\Delta_W+M_W=p^*(K_X+B+M_X). +\end{equation} +A \emph{global divisorial place} is a prime divisor on a normal proper bimeromorphic model, with primes identified by strict transform on common higher models. Its log discrepancy is +\[ + a(E;X,B+\M)=1-\operatorname{coeff}_E(\Delta_W) +\] +on a model carrying \(E\). The pair is \emph{generalized log canonical} if this number is nonnegative for every global divisorial place, including the primes on \(X\). These places are defined on birational models; the definition does not depend on a field of global meromorphic functions. + +\begin{theorem}\label{thm:main} +Let \(X_0\) be a normal irreducible globally Weil \(\Q\)-factorial compact K\"ahler fourfold. Let \(B_0\) be an effective rational Weil divisor of finite support with coefficients in \([0,1]\). Let \(\M\) be represented by an analytically nef \(\Q\)-Cartier divisor on a projective bimeromorphic normal compact K\"ahler model of \(X_0\). Fix compatible actual canonical divisor representatives on all birational models under consideration. Suppose that \(D_0=K_{X_0}+B_0+M_{X_0}\) is \(\Q\)-Cartier and that \((X_0,B_0+\M)\) is generalized log canonical. + +Consider a sequence of normal irreducible globally Weil \(\Q\)-factorial compact K\"ahler fourfolds +\[ + X_0\dashrightarrow X_1\dashrightarrow X_2\dashrightarrow\cdots. +\] +On \(X_i\), let \(B_i\) be the strict transform of \(B_0\), let \(M_i=M_{X_i}\) be the trace of the same b-divisor, and assume that \(D_i=K_{X_i}+B_i+M_i\) is \(\Q\)-Cartier. Transport the canonical representatives under the induced identifications of prime divisors. Suppose that every step is given by a diagram +\begin{equation}\label{eq:flip-diagram} +\begin{tikzcd}[column sep=large] + X_i \arrow[r,"f_i"] & Z_i & X_{i+1}\arrow[l,"f_i^+"'] +\end{tikzcd} +\end{equation} +where \(Z_i\) is normal compact K\"ahler, both maps are projective small bimeromorphic morphisms with connected fibers, neither is an isomorphism, and +\[ + -D_i\text{ is }f_i\text{-ample},\qquad + D_{i+1}\text{ is }f_i^+\text{-ample}. +\] +Here \emph{small} means that the exceptional locus contains no prime divisor. Then the sequence is finite. +\end{theorem} + +We call a diagram satisfying the hypotheses of Theorem~\ref{thm:main} a \emph{flip} for the indicated adjoint. The theorem applies to arbitrary choices of such diagrams. Taking \(\M=0\) gives the ordinary log canonical case. + +The proof uses the relative constructions and special termination for generalized pairs in \cite{KahlerAuxiliary}, whose precise forms we recall in Section~\ref{sec:preliminaries}. + +\subsection*{Proof strategy} + +We first prove termination for generalized klt pairs on models satisfying the stronger factoriality condition specified in Section~\ref{sec:preliminaries}. Discrepancy monotonicity and finiteness for the initial pair make the set of exceptional places of discrepancy at most one constant on a tail. Extracting it gives crepant models \(h_i:Y_i\to X_i\) whose remaining exceptional discrepancies are greater than one; we call them \emph{terminal junctions}. Each downstairs flip connects two junctions by a decrease of the extracted boundary coefficients followed by a finite, possibly empty, program of small steps. This construction adapts the projective argument of \cite[Section~3, Proposition~3.4]{ProjectiveLCFourfolds}. + +The extracted coefficients may still vary. When an extracted divisor maps onto a surface, a transverse smooth surface cuts its general fiber into exceptional curves. Adjunction and negative definiteness bound the entries of the grouped intersection matrix. The fixed rational boundary and nef data then confine the discrepancies of extracted places with surface centers to a finite set. A downstairs flip strictly raises the discrepancy of a place whose center lies in its exceptional locus. It follows that, on every junction of a tail, each coefficient that still varies belongs to a divisor mapping onto a curve or a point of \(X_i\). + +The branch bound of Theorem~\ref{thm:branch} applies to a reduced union \(Q\) of divisors on a terminal fourfold \(Y\) when a projective bimeromorphic morphism \(Y\to X\) of normal irreducible compact K\"ahler fourfolds sends \(Q\) to a set of dimension at most one. A surface in \(Q\) may have several prime divisors above it in the disjoint normalization of its components. The theorem bounds the total excess of branches by the ranks of surface cycle classes on those normalizations and the number of global ordinary discrepancy-two places centered on singular curves in \(Q\). It is formulated independently of any boundary or crepant equation. + +The word \emph{global} is essential. Projective topology over the curve image relates the branch excess to local systems along the singular curves. Saito's projective analytic decomposition theorem and a Hodge-filtration argument on a compact K\"ahler resolution give the needed purity. A Quot parameter argument gives finite monodromy. On a Stein neighborhood of a compact core carrying all loops of the curve, we apply Fujino's local small \(\Q\)-factorialization theorem; fiber degrees and blowups then produce local ordinary discrepancy-two places. A canonical discrepancy comparison shows that they occur as divisors on one global resolution, and the retained loops keep those global divisors distinct. The normalization and parameter methods follow \cite[Sections~5--6]{ProjectiveLCFourfolds}; the analytic purity argument and the passage to distinct global divisors are given here. + +Section~\ref{sec:difficulty} constructs the difficulty by counting exceptional places of discrepancy below two with ceiling weights, subtracting generic blowup contributions locally before summation, and adding cycle-rank corrections on normalized boundary components. The branch bound makes it nonnegative at junctions. Across a small step, the cycle-rank change cancels the change in the local subtractions, leaving a sum of nonnegative weight losses. This adapts the locally corrected difficulty in \cite[Section~4]{ProjectiveLCFourfolds}. + +A surface in the positive exceptional locus of a downstairs flip forces a drop of at least one in the difficulty between its terminal junctions. Only finitely many flips can do this. Every remaining flip has an exceptional surface only on the negative side, so the rank of analytic surface classes on the ambient \(X_i\) decreases. This proves termination for generalized klt pairs on these auxiliary models. Special termination and deletion of the whole boundary floor reduce elementary generalized dlt programs to that case. We then use relative continuation and this gdlt termination to lift each diagram of Theorem~\ref{thm:main} to a finite program whose endpoint maps crepantly to the next downstairs model. A negative curve downstairs has a negative multisection upstairs, so each lift is nonempty. Their concatenation proves Theorem~\ref{thm:main}. diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/02-preliminaries.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/02-preliminaries.tex new file mode 100644 index 0000000000000000000000000000000000000000..abe6db7dc1757bb511a589163673485e55e1ea23 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/02-preliminaries.tex @@ -0,0 +1,261 @@ +\section{Generalized pairs and auxiliary programs}\label{sec:preliminaries} + +The relative constructions used in the proof take place on models with a +stronger global factoriality property than the one in +Theorem~\ref{thm:main}. We first specify that property and the generalized +pair conventions for those constructions. We then record the precise +forms of the auxiliary results that will be used. + +The auxiliary definitions and statements in this section use reduced, +irreducible, second-countable complex analytic spaces as their ambient +spaces. + +\begin{definition}[Global strong factoriality]\label{def:strong-factoriality} +A normal compact complex space \(T\) is \emph{globally strongly +\(\Q\)-factorial} if, for every coherent rank-one reflexive sheaf +\(\mathcal F\) on all of \(T\), some positive reflexive power +\[ + \mathcal F^{[m]}=(\mathcal F^{\otimes m})^{**},\qquad m>0, +\] +is an invertible sheaf. +\end{definition} + +This condition implies global Weil \(\Q\)-factoriality: apply it to the +divisorial sheaf of each global prime divisor and to the reflexive canonical +sheaf. It is a condition on sheaves on the whole space; it makes no assertion +that arbitrary analytic open subsets, or the analytic local rings, are +\(\Q\)-factorial. We use \emph{strong model} to mean a globally strongly +\(\Q\)-factorial model. + +A \emph{rational line bundle} on \(T\) is an element of +\(\Pic(T)\otimes_{\Z}\Q\). An equality of rational line bundles means an +isomorphism of holomorphic line bundles after taking a positive common +integral multiple. A rank-one reflexive sheaf is \emph{rationally +invertible} if a positive reflexive power is invertible. On a projective +morphism \(T\to V\), a rational line bundle is \emph{relatively nef} if +its degree is nonnegative on every compact irreducible curve in a fiber, +and is \emph{relatively ample} if a positive integral multiple is relatively +ample. For the absolute nef data in this paper, nefness means that the +first Chern class lies in the closure of the K\"ahler cone, as in the +introduction; it implies relative nefness for every morphism under +consideration. + +The auxiliary constructions are stated for rational generalized +\emph{b-line data}. On a normal compact space \(T\), these consist of an +effective rational Weil divisor \(B\) of finite support, a projective +modification \(p:W\to T\), and a rational line bundle \(M_W\) on \(W\) +that is nef absolutely, or nef over the specified base of a relative +argument. It is pulled back on every higher model; we continue to denote +the resulting b-object by \(\M\). After clearing a denominator, proper +direct image followed by double dual defines its reflexive trace \(M_T\). +The adjoint \(D_T=K_T+B+M_T\) is required to be rationally invertible. +Here \(K_T\) in the b-line formulation is the reflexive canonical sheaf. +On a smooth log resolution projective over \(T\) and carrying the data, the natural +meromorphic comparison over the isomorphism locus defines the crepant +boundary by +\[ + K_W+B_W+M_W=p^*D_T. +\] +The log discrepancy of a global place \(E\) is +\(a(E;T,B+\M)=1-\operatorname{coeff}_E(B_W)\) on a model carrying it. +All statements about places below concern the global places defined in the +introduction. A global place is exceptional over \(T\) if its center on +\(T\) has codimension at least two. + +We abbreviate \emph{generalized klt}, \emph{generalized lc}, and +\emph{generalized dlt} to gklt, glc, and gdlt. A pair is gklt if all of +its global log discrepancies are positive, and glc if they are all +nonnegative. It is \emph{generalized terminal} if it is gklt and +\(a(E;T,B+\M)>1\) for every place exceptional over \(T\). A +\emph{generalized log canonical center} is the center of a global place of +log discrepancy zero. A glc pair is gdlt if there is a Zariski-open set +\(T^\circ\subset T\) on which \((T^\circ,B|_{T^\circ})\) is simple normal +crossing and the b-data descend, and which contains the general point of +every generalized log canonical center. The carrier and subsequent log +resolutions may be chosen isomorphic on this open. The zero-discrepancy +centers there are strata of the coefficient-one boundary. These are the +conventions of \cite[Convention~9.1 and Definition~9.2]{KahlerAuxiliary}. + +We explain the relation between this formulation and the actual divisors in +Theorem~\ref{thm:main}. A \(\Q\)-Cartier divisor determines a rational +line bundle. If \(mM_W\) is integral Cartier, then on the normal target +the reflexive sheaf +\[ + \bigl(p_*\mathcal O_W(mM_W)\bigr)^{**} +\] +agrees with the divisorial sheaf \(\mathcal O_T(mp_*M_W)\): the two agree +at every codimension-one point, where the modification is an isomorphism, +and normality gives uniqueness of the reflexive extension. The same +comparison on a common higher model is compatible with pullback and with +transport across a small map. The canonical trace is the canonical +sheaf of the target. These facts are +\cite[Lemma~9.3(i)--(ii)]{KahlerAuxiliary}. The natural meromorphic +comparisons therefore agree with the comparisons using the compatible +actual canonical representatives in \eqref{eq:discrepancy-definition}. +In every application below the b-line discrepancies are exactly the +discrepancies of that equation, and a crepant b-line identity is the +corresponding equality of actual rational divisors. A common projective +carrier for any finite part of our birational constructions carries the +pullback of the original analytically nef divisor, which is relatively nef +over each base used in that part. A single carrier dominating an infinite +sequence is not required. + +Here is the elementary step used in the auxiliary programs. Suppose that +the source \(T\) and the output \(T_1\) are strong normal compact K\"ahler +spaces, and write \(D_T\) and \(D_{T_1}\) for their rationally invertible +adjoints. An \emph{elementary negative step} is either a projective +bimeromorphic divisorial contraction \(f:T\to T_1\) for which \(-D_T\) +is \(f\)-ample, or a diagram +\[ + T\xrightarrow{\ f\ }Z\xleftarrow{\ f^+\ }T_1 +\] +of projective small bimeromorphic morphisms to a normal compact K\"ahler +space with \(-D_T\) \(f\)-ample and \(D_{T_1}\) \(f^+\)-ample. The +degree functionals of the curves contracted on the negative side span one +nonzero ray when paired with global rational line bundles on \(T\). +In the small case the positive side is the relative Proj of the actual +adjoint algebra: after choosing a positive multiple of \(D_T\) represented +by a holomorphic line bundle \(\mathcal L\), it is +\[ + T_1=\Proj_Z\bigoplus_{m\geq0} f_*\mathcal L^{\otimes m}. +\] +The boundary is pushed forward in the divisorial case and strictly +transformed in the small case, and the same b-data are used on common higher +models. With the compatible actual canonical representatives, a divisorial +step satisfies \(D_{T_1}=f_*D_T\). If the step is \emph{over \(V\)}, all its maps commute with the +given maps to \(V\). In the constructions used below the contraction maps +have connected fibers, and a small step has nonisomorphic morphisms on both +sides; the latter properties are also verified in +Section~\ref{sec:comparisons}. This is the form of +\cite[Definition~9.6]{KahlerAuxiliary}. Its one-ray condition concerns +degrees of global line bundles and imposes no condition on the relative +Bott--Chern dimension. A diagram in Theorem~\ref{thm:main} need not be +elementary. + +\begin{proposition}[Low places and projective realization]\label{prop:low-places} +Let \((T,B+\M)\) be gklt rational generalized data on a normal compact +K\"ahler space, with effective boundary of finite support and an absolutely +nef rational datum carried by a projective modification. Fix a projective +log resolution carrying the datum. There is \(\varepsilon>0\) such that +every global place satisfies +\[ + a(E;T,B+\M)\geq\varepsilon, +\] +and only finitely many places exceptional over \(T\) satisfy +\[ + a(E;T,B+\M)<1+\varepsilon. +\] +This finite set can be represented simultaneously by prime divisors on a +smooth model projective over \(T\). In particular the exceptional places +of discrepancy at most one form a finite set with such a realization. +\end{proposition} + +This is the rational nef specialization of +\cite[Lemma~4.2(i)]{KahlerAuxiliary}. The positive number +\(\varepsilon\) belongs to this one pair; uniformity along a sequence will +follow from discrepancy monotonicity. + +\begin{proposition}[Exact extraction]\label{prop:extraction} +Let \((T,B+\M)\) be rational gklt data on a strong normal compact +K\"ahler space, with an absolutely nef rational line bundle on a projective +carrier and rationally invertible adjoint. For any specified finite set +\(\mathcal E\) of places exceptional over \(T\) with +\(a(E;T,B+\M)\leq1\), there is a projective bimeromorphic morphism +\(h:U\to T\) such that \(U\) is a strong normal compact K\"ahler space, +the \(h\)-exceptional prime divisors are exactly the members of +\(\mathcal E\), and the crepant generalized pair on \(U\) is gklt with +effective boundary. Thus, writing this boundary as \(B_U\), +\[ + K_U+B_U+M_U=h^*(K_T+B+M_T). +\] +\end{proposition} + +This is \cite[Proposition~9.11]{KahlerAuxiliary}. Terminality is not part +of the extraction assertion. It will follow when \(\mathcal E\) is chosen +to contain every exceptional place of discrepancy at most one. + +\begin{proposition}[Relative programs]\label{prop:relative-program} +Let \(\pi:T\to V\) be a projective bimeromorphic morphism of normal compact +K\"ahler spaces. Suppose that \(T\) is strong and that \((T,B+\M)\) is +rational gdlt, with effective boundary, a projective carrier on which the +rational line datum is nef over \(V\), and a rationally invertible adjoint +\(D_T\). +\begin{enumerate} +\item If \(D_T\) is not relatively nef over \(V\), there is an elementary +negative step over \(V\). Its output is projective over \(V\), normal +compact K\"ahler and strong, and is gdlt with the transported boundary and +b-data. The same construction is available after every finite prefix whose +last adjoint is not relatively nef over \(V\). +\item If the initial pair is gklt, there exists a finite, possibly empty, +sequence of elementary negative steps over this one fixed base \(V\) whose +last adjoint is relatively nef over \(V\). Its models and transported data +have the properties in the first assertion. +\end{enumerate} +\end{proposition} + +The two assertions are respectively +\cite[Propositions~9.7 and 9.9]{KahlerAuxiliary}. The first is a +continuation assertion for gdlt data. The second asserts the existence of +one finite run for gklt data; it does not assert termination of every choice +of a relative program. + +\begin{proposition}[Crepant gdlt modification]\label{prop:gdlt-modification} +Let \((T,B+\M)\) be rational glc data of dimension at most four on a normal +compact K\"ahler space. Assume that the higher absolutely nef rational +line datum is carried by a projective modification and that +\(K_T+B+M_T\) is rationally invertible. There is a projective bimeromorphic +morphism \(h:Y\to T\) such that \(Y\) is a strong normal compact K\"ahler +space, \((Y,B_Y+\M)\) is gdlt with \(B_Y\geq0\), and +\[ + K_Y+B_Y+M_Y=h^*(K_T+B+M_T). +\] +Every \(h\)-exceptional prime has coefficient one in \(B_Y\), equivalently +has generalized log discrepancy zero over \((T,B+\M)\). +\end{proposition} + +This is \cite[Proposition~11.4]{KahlerAuxiliary}. The base \(T\) need not +be strong, and the assertion does not require that every zero-discrepancy +place be extracted. + +\begin{theorem}[Special termination]\label{thm:special-termination} +Let \(d\leq4\), and let +\[ + (T_0,B_0+\M)\dashrightarrow(T_1,B_1+\M) + \dashrightarrow(T_2,B_2+\M)\dashrightarrow\cdots +\] +be a sequence of elementary steps for rational gdlt data on strong normal +compact K\"ahler spaces of dimension \(d\). The boundaries are transported +as in an elementary program, and the higher absolutely nef b-line datum is fixed and is +carried by projective modifications. There is an index \(i_0\) such that, +for every \(i\geq i_0\), the exceptional loci on both sides of the step are +disjoint from every generalized log canonical center on their respective +sides. The contraction bases in this sequence may vary. +\end{theorem} + +This is \cite[Theorem~11.3]{KahlerAuxiliary}. We use it for the elementary +sequences on strong models. Full termination for four-dimensional gdlt +data will be deduced in Section~\ref{sec:completion}. + +\paragraph{Scope of the auxiliary inputs.} +The results recalled above use the projective relative arguments in +\cite[Sections~9--11]{KahlerAuxiliary}, together with its low-place +calculation. Relative continuation is Proposition~9.7 there; the finite +run over a fixed bimeromorphic base in Proposition~9.9 uses the local +finite-generation argument of Lemma~9.8, and exact extraction in +Proposition~9.11 uses that finite run. The special-termination and gdlt +modification arguments in Section~11 form an induction on dimension, +using the threefold termination theorem of Section~10. These proofs do +not invoke the canonical bundle formula or the absolute +supporting-contraction induction of Section~6. Indeed, Section~6 uses +the threefold termination theorem as an input to its good-model +construction; the dependency is in that direction. Thus the use of +\cite{KahlerAuxiliary} here does not require its absolute contraction or +minimal-model theorems. + +The imports from \cite{CanonicalKahler} are likewise restricted to its +common-model construction (Proposition~2.1), analytic negativity +(Lemma~2.2), and terminal smoothness in codimension two (Lemma~2.3). +Its fourfold termination theorem is not an input. All relative +constructions above retain their stated strong-factoriality hypotheses; +these are not additional hypotheses on the given sequence in +Theorem~\ref{thm:main}. diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/03-comparisons.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/03-comparisons.tex new file mode 100644 index 0000000000000000000000000000000000000000..38594f19df43200ec0975c04f07ca5d2233d5044 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/03-comparisons.tex @@ -0,0 +1,529 @@ +\section{Birational comparisons} +\label{sec:comparisons} + +We compare the adjoints on the two sides of a small diagram and at the +ends of a finite relative program. The comparisons locate exactly which +global places acquire larger discrepancies. They also give a projective +morphism from a nef end to a prescribed ample model, with the nef adjoint +equal to the pullback of the ample adjoint. We then record the homological +ranks that count contracted divisors and surfaces. +All divisor equalities in this section are equalities of actual rational +divisors, with the compatible canonical representatives and the fixed +b-divisor $\M$ of Section~\ref{sec:preliminaries}. + +For a projective morphism, a rational Cartier divisor is called +\emph{relatively nef} here if it has nonnegative degree on every compact +irreducible curve contracted by the morphism. We use the analytic +negativity lemma in the following precise form +\cite[Lemma~2.2]{CanonicalKahler}: if $r:V\to T$ is a projective +bimeromorphic morphism of normal complex spaces, $H$ is a +$\Q$-Cartier divisor on $V$, $-H$ is relatively nef, and $r_*H\geq0$, +then $H\geq0$. Neither compactness nor a singularity hypothesis is +part of this input. A divisor is \emph{exceptional over $T$} if every +prime in its support has image of codimension at least two in $T$. + +We will also use two consequences of normality. An effective +$\Q$-Cartier divisor pulls back effectively under a dominant morphism: +after clearing its index, a local meromorphic equation with no +divisorial poles is holomorphic on a normal space. Such a divisor has +nonnegative degree on a compact curve not contained in its support, +by restricting its effective section to the normalization of the curve. + +\subsection{Common models and the nef part} + +The projectivity in the hypotheses permits all comparisons in a finite +part of the argument to be made on one compact K\"ahler resolution. +We give the construction for the diagrams used here; compare the +common-model construction of \cite[Proposition~2.1]{CanonicalKahler}. + +\begin{lemma}[Common models with projective maps]\label{lem:common-projective-models} +Let a finite collection of normal irreducible compact K\"ahler spaces +be joined, with compatible bimeromorphic identifications, by finitely +many projective bimeromorphic morphisms and their inverses. Suppose +that a fixed nef b-divisor is carried by a projective bimeromorphic +morphism $X'\to X$ to one of these spaces, with analytically nef +$\Q$-Cartier trace $M'$ on $X'$. Then there is a +smooth compact K\"ahler space $W$ with compatible projective +bimeromorphic morphisms to every space in the collection and to $X'$. +The resolution may simultaneously principalize finitely many specified +generically nonzero coherent ideals and resolve finitely many specified divisors. Its trace +$M_W$ is the pullback of $M'$ and is analytically nef. +\end{lemma} + +\begin{proof} +For a diagram $T\to Z\leftarrow T^+$, take the reduced component of +$T\times_ZT^+$ containing the graph over the common isomorphism open. +Its projections are projective, and finite normalization preserves +projectivity. Adjoin the remaining spaces and the carrier one at a +time by the same construction. Resolving the resulting dominating +component gives a common smooth model. Analytic resolution and +principalization allow the stated simultaneous choices by projective +modifications; see \cite[Theorems~1.6, 1.10 and 13.2(1)]{BierstoneMilman1997}. +Base change, restriction to a closed analytic subspace, finite +normalization, and composition preserve projectivity. For composition +in the present compact setting, one can choose a uniform sufficiently +large twist of a relative ample bundle by the pullback of the next one. +This also proves compatibility with any finite chain of the small +diagrams and divisorial contractions considered below. + +A smooth space projective over a compact K\"ahler space is compact +K\"ahler: a relative ample bundle supplies positivity in the fiber +directions, and adding a sufficiently large multiple of a pulled-back +K\"ahler form supplies positivity in all directions. Finally, choose +K\"ahler classes on $X'$ converging to $c_1(M')$. Their pullbacks to +$W$ have semipositive representatives. Adding positive multiples +tending to zero of a fixed K\"ahler class on $W$ gives K\"ahler classes +converging to $c_1(M_W)$. Thus $M_W$ is analytically nef. +\end{proof} + +In particular, $M_W$ has nonnegative degree on every compact curve. +For an arbitrary global place, a further common proper model with a +model carrying that place suffices to compare coefficients. This last +model need not be projective: projectivity is used to establish an +effective divisor on a common model, after which its pullbacks remain +effective on every higher proper model. + +\begin{lemma}[Effective nef defect]\label{lem:nef-defect} +Let $T$ be a normal compact K\"ahler model, and let $r:W\to T$ be a +projective bimeromorphic morphism from a normal compact K\"ahler space +$W$ dominating the fixed projective carrier of $\M$. Assume that +$M_T$ is $\Q$-Cartier. Then +\begin{equation}\label{eq:nef-defect} + J_{W/T}:=r^*M_T-M_W\geq0 +\end{equation} +is an exceptional $\Q$-Cartier divisor over $T$. If $s:W'\to W$ is +a higher normal model, then $J_{W'/T}=s^*J_{W/T}$. +\end{lemma} + +\begin{proof} +The trace definition gives $r_*J_{W/T}=0$. On an $r$-contracted curve, +$-J_{W/T}=M_W-r^*M_T$ has the same degree as $M_W$, hence has +nonnegative degree by projection formula from the nef carrier. +Analytic negativity gives $J_{W/T}\geq0$. +The final identity follows from functoriality of pullback and the fact +that the b-divisor descends on $W$. +\end{proof} + +The next lemma explains why hypotheses stated for global generalized +places give the local ordinary singularity conditions needed later. +It is here that effectivity of the boundary and of the nef defect +enters the singularity comparison. The global Weil and strong +$\Q$-factoriality conventions ensure the Cartier hypotheses below for +the respective models in the proof, since the divisor traces have +finite support. + +\begin{lemma}[From global generalized discrepancies to local singularities] +\label{lem:ordinary-singularities} +Let $T$ be a normal compact K\"ahler space, let $B$ be an effective +rational divisor of finite support, and let $\M$ have analytically nef +rational data on a projective carrier. Assume that $K_T$, $B$, and +$M_T$ are $\Q$-Cartier. +If every global generalized log discrepancy of $(T,B+\M)$ is +nonnegative, respectively positive, then the same condition holds for +local analytic places. In the positive case, $T$ has ordinary klt +singularities locally. If the global generalized discrepancies are +positive and every global place exceptional over $T$ has generalized +log discrepancy strictly greater than one, +then $T$ has ordinary terminal singularities locally. In dimension +four the latter conclusion implies $\dim\Sing T\leq1$. +\end{lemma} + +\begin{proof} +Choose a smooth log resolution $r:W\to T$, projective over $T$ and carrying $\M$, +with divisorial exceptional locus and simple normal crossing support +for all divisors in the crepant equation +\[ + K_W+\Delta_W+M_W=r^*(K_T+B+M_T). +\] +Such a simultaneous resolution is available by +Lemma~\ref{lem:common-projective-models}. The assumed inequalities +give coefficients at most one, respectively strictly below one, for +every global prime of $\Delta_W$. The same bounds hold on their local +branches. On any further local model the nef part is pulled back from +$W$, so its generalized discrepancies are the ordinary discrepancies +of the simple normal crossing subpair $(W,\Delta_W)$. The simple +normal crossing discrepancy criterion proves the asserted local +generalized inequalities, including when some coefficients of +$\Delta_W$ are negative. + +Put $J=J_{W/T}$. The ordinary crepant boundary for $(T,0)$ is +\begin{equation}\label{eq:ordinary-crepant-boundary} + \Delta_W^{(0)}=\Delta_W-r^*B-J, + \qquad K_W+\Delta_W^{(0)}=r^*K_T. +\end{equation} +Both $r^*B$ and $J$ are effective. After resolving their joint support +as above, every coefficient of $\Delta_W^{(0)}$ is therefore strictly +below one in the positive case. The same local simple normal crossing +criterion gives ordinary klt singularities. + +For the terminal assertion, the relative canonical divisor is +exceptional, and at an exceptional prime $R$ of $W$ its coefficient is +\[ + \operatorname{coeff}_R(K_W-r^*K_T) + =a(R;T,B+\M)-1+\operatorname{coeff}_R(r^*B+J)>0. +\] +These positive coefficients persist on every local branch. A local +place exceptional over the smooth space $W$ has ordinary log +discrepancy at least two over $W$: the Jacobian determinant of a smooth +model carrying it has positive integral order along an exceptional +divisor. Its discrepancy over $T$ adds the nonnegative order of +$K_W-r^*K_T$, and hence remains greater than one. Local exceptional +places already represented by divisors on $W$ satisfy the displayed +strict inequality. Thus $T$ is locally ordinary terminal. +For a normal complex fourfold with a rational canonical line bundle, +local ordinary terminality implies smoothness in codimension two by +\cite[Lemma~2.3]{CanonicalKahler}, giving the last assertion. +\end{proof} + +For later calculations, the same equations give, for every global place +$E$ followed on a common higher model, +\begin{equation}\label{eq:generalized-ordinary-discrepancy} + a(E;T,B+\M) + =a(E;T,0)-\ord_E(r^*B)-\ord_E(J_{W/T}). +\end{equation} +The orders on the right mean coefficients after pullback to that model. +They are nonnegative under the hypotheses of +Lemma~\ref{lem:ordinary-singularities}. + +\subsection{Small diagrams and finite programs} + +We now locate the entire region in which a small step changes +discrepancies. All exceptional loci and their images in this +subsection are given their reduced structures. We use the graph method +of \cite[Lemma~2.1]{ProjectiveLCFourfolds} and prove the needed analytic +comparison, with the fixed b-divisor, below. + +\begin{lemma}[Comparison for an arbitrary small diagram] +\label{lem:small-comparison} +Let +\[ + T\xrightarrow{\ f\ }Z\xleftarrow{\ f^+\ }T^+ +\] +be a diagram of normal irreducible compact K\"ahler fourfolds in which +$f$ and $f^+$ are projective small bimeromorphic morphisms with +connected fibers, and both are nonisomorphisms. Let $(T,B_T+\M)$ and +$(T^+,B_{T^+}+\M)$ have effective rational boundaries related by +strict transform and the same fixed rational b-divisor. Transport the +canonical representatives by the identification of prime divisors, +and assume that the actual adjoints $D_T$ and $D_{T^+}$ are +$\Q$-Cartier, with $-D_T$ $f$-ample and $D_{T^+}$ $f^+$-ample. + +The exceptional images of $f$ and $f^+$ are equal. If their common +image is $A$, then +\begin{equation}\label{eq:small-loci} + L:=\Exc(f)=f^{-1}(A),\qquad + L^+:=\Exc(f^+)=(f^+)^{-1}(A), +\end{equation} +the complements are isomorphic, and +\begin{equation}\label{eq:small-dimensions} + \dim L,\dim L^+\leq2,\qquad \dim A\leq1, + \qquad \dim L+\dim L^+\geq3. +\end{equation} + +Let $G$ be the normalization of the main graph, with projections +$p:G\to T$, $q:G\to T^+$ and $h=f\circ p=f^+\circ q$. Then the +actual $\Q$-Cartier divisor +\begin{equation}\label{eq:small-divisor} + F:=p^*D_T-q^*D_{T^+} +\end{equation} +is effective and exceptional over both $T$ and $T^+$, and +\begin{equation}\label{eq:small-support} + \Supp F=h^{-1}(A). +\end{equation} +Moreover, $F\cdot C<0$ for every irreducible curve $C$ contracted by $h$. + +For every global place $E$ over these spaces, let $\ord_E(F)$ denote +the coefficient of the pullback of $F$ on any higher proper model +dominating $G$ and carrying $E$. Then +\begin{equation}\label{eq:small-discrepancies} + a(E;T^+,B_{T^+}+\M)-a(E;T,B_T+\M)=\ord_E(F)\geq0. +\end{equation} +The inequality is strict exactly when $\cent_T(E)\subset L$, and this +condition is equivalent to $\cent_{T^+}(E)\subset L^+$. A place is +exceptional over $T$ if and only if it is exceptional over $T^+$. +\end{lemma} + +\begin{proof} +We first recall the fiber description for a proper bimeromorphic +morphism $v:V\to S$ of normal spaces. Its positive-dimensional-fiber +locus is closed analytic. Over its complement the map is finite +locally on $S$, hence an isomorphism by normality. Stein factorization +shows that every fiber is connected, because its finite bimeromorphic +factor over the normal space $S$ is an isomorphism. A reduced compact +connected positive-dimensional fiber has no zero-dimensional +irreducible component: such a component would be a singleton disjoint +from the finitely many other closed components. Hence no point in +such a fiber is a local isomorphism point. The exceptional locus of +$v$ is exactly the full inverse image of its positive-dimensional-fiber +locus. + +Let $U\subset Z$ be the open set over which $f$ is an isomorphism. +On $U$, $D_T$ defines a $\Q$-Cartier divisor $D_U$. The actual Weil +coefficients of the two adjoints agree under the identification of +prime divisors. Since $f^+$ is small, it follows that +$D_{T^+}|_{(f^+)^{-1}U}=(f^+)^*D_U$. A positive-dimensional projective +fiber over $U$ would contain a curve on which this divisor has degree +zero, contrary to $f^+$-ampleness. Thus $f^+$ is an isomorphism over +$U$. Interchanging the two sides and using $f$-ampleness of $-D_T$ +gives the reverse inclusion of the isomorphism opens. This proves +the equality of exceptional images and \eqref{eq:small-loci}. +Smallness gives $\dim L,\dim L^+\leq2$. Over a general point of each +component of $A$ the fiber has dimension at least one, so the +fiber-dimension theorem gives $\dim A\leq1$. + +The graph projections are projective and surjective, and the map from +$G$ to its component in $T\times_ZT^+$ is finite. A prime divisor of +either side maps to a prime divisor of $Z$ by smallness. On the graph +it therefore corresponds to the same prime place on the other side, +with the same adjoint coefficient. Consequently $p_*F=q_*F=0$. +On a $p$-contracted curve, $-F$ has the degree of $q^*D_{T^+}$, which +is nonnegative. Analytic negativity gives $F\geq0$. + +For a curve $C$ contracted by $h$, the projection formula and the two +ample signs give +\[ + -F\cdot C=(-D_T)\cdot p_*C+D_{T^+}\cdot q_*C>0. +\] +Here an image that is a point contributes zero. At least one image is +a curve, because the finite map to the fiber product cannot contract +$C$ to a point. Thus at least one summand is strictly positive. + +The support of $F$ is contained in $h^{-1}(A)$, since both projections +identify the common isomorphism open and the adjoints agree there. +Conversely, take $x\in h^{-1}(A)$ and write $z=h(x)$. The map +$h:G\to Z$ is proper bimeromorphic, so its fiber over $z$ is connected. +It is projective and positive-dimensional: its projection to the +positive-dimensional fiber $f^{-1}(z)$ is surjective. The fiber +description above places $x$ on a positive-dimensional irreducible +component. Successive projective hyperplane cuts through $x$ give an +irreducible curve $C$ in that fiber through $x$. If $x$ were outside +$\Supp F$, then $C$ would not be contained in the effective +$\Q$-Cartier divisor $F$, so $F\cdot C\geq0$. The preceding strict +inequality excludes this. Hence \eqref{eq:small-support} holds. + +Follow a global place $E$ on a common proper model dominating $G$ and +the nef carrier. Subtracting its two crepant equations cancels the +same trace of $\M$ and gives \eqref{eq:small-discrepancies}. The order +of an effective $\Q$-Cartier divisor is positive precisely when the +center of the place is contained in its support. Proper images of +centers give +\[ + \cent_Z(E)=f(\cent_T(E))=f^+(\cent_{T^+}(E))=h(\cent_G(E)). +\] +Together with \eqref{eq:small-loci} and \eqref{eq:small-support}, this +proves both center equivalence and the stated exact strictness +criterion. If the centers are not contained in these loci, their +general points correspond on the common open and the order is zero. +Finally, a place centered at a divisor on a normal model is that +divisorial place. Smallness identifies these prime divisors on the +two sides, proving equivalence of exceptionality. + +Since both morphisms are nonisomorphisms, $A$ is nonempty, so $F$ has +a prime divisor $R$ in its support. The graph is a fourfold, hence +$\dim R=3$. Its finite map to the graph component has image in +$L\times_ZL^+$, whence +\[ + 3\leq\dim(L\times_ZL^+)\leq\dim L+\dim L^+. +\] +This is the remaining inequality in \eqref{eq:small-dimensions}. +\end{proof} + +The discrepancy statement preserves generalized lc and generalized +klt inequalities along a small step. It also preserves generalized +terminality, because the same places are exceptional on both sides. +The isomorphism-open argument did not use nontriviality. In the normal +irreducible compact K\"ahler fourfold setting of +Lemma~\ref{lem:small-comparison}, if an elementary small step is initially specified by a nonisomorphic +negative contraction, a small positive morphism, and the stated Cartier +and ample hypotheses, that argument forces the positive morphism to be +nonisomorphic as well. Its fibers are connected by normality and Stein +factorization, so Lemma~\ref{lem:small-comparison} applies. +For a finite program we need, in addition, to retain the location of +the accumulated correction at its end. + +\begin{lemma}[Comparison along a finite negative program] +\label{lem:program-comparison} +Let $Y_0\dashrightarrow\cdots\dashrightarrow Y_m$, with $m\geq0$, be +a finite sequence of normal irreducible compact K\"ahler fourfolds with +$\Q$-Cartier adjoints $D_j=K_{Y_j}+B_j+M_{Y_j}$. Suppose the effective +rational boundaries are transported by pushforward, the canonical +representatives are compatible, and the same b-divisor with a projective +carrier is used throughout. Assume +each step is either a small diagram satisfying +Lemma~\ref{lem:small-comparison}, or a projective bimeromorphic +divisorial contraction $v_j:Y_j\to Y_{j+1}$ such that +$D_{j+1}=(v_j)_*D_j$ and $-D_j$ is $v_j$-ample. These steps extract +no prime divisors. On a smooth common model $W$ with projective maps +to every $Y_j$ and to the carrier, write $r_j:W\to Y_j$. Then +\begin{equation}\label{eq:program-comparison} + r_0^*D_0-r_m^*D_m=E,\qquad E\geq0,\qquad (r_m)_*E=0. +\end{equation} +Every global discrepancy is nondecreasing along the run. If a prime +divisor is contracted in a divisorial step, its discrepancy increases +strictly at that step, and its discrepancy at the end is strictly +larger than before that step. +\end{lemma} + +\begin{proof} +For a divisorial step put +$E_j=D_j-v_j^*D_{j+1}$. It is exceptional over $Y_{j+1}$ and has +strictly negative degree on every $v_j$-contracted curve. Negativity +gives $E_j\geq0$. Every point of an exceptional fiber lies on a curve +in that fiber, by the connected projective fiber argument in the proof +of Lemma~\ref{lem:small-comparison}. The negative degree therefore +forces that point into $\Supp E_j$. In particular the coefficient of +$E_j$ at each contracted prime is positive. Subtracting crepant +equations gives nondecreasing discrepancies and this strict increase. +For a small step the same assertions, with an effective correction +exceptional over its output, follow from +Lemma~\ref{lem:small-comparison}. + +Pull the corrections of all steps to $W$ and add them. This gives the +effective divisor in \eqref{eq:program-comparison}. Each prime in a +summand is exceptional over that step's output, and remains exceptional +over every later output. Indeed, if that place became a prime divisor +on a later normal model, that prime would have a strict-transform prime +on each earlier model, since none of the intervening steps extracts divisors. +This contradicts its earlier exceptionality. Thus the sum is +exceptional over $Y_m$. Its nonnegative coefficients also show that +a strict increase from a contracted prime cannot be canceled later. +For $m=0$ the correction is zero and the assertions are immediate. +\end{proof} + +\subsection{A nef end and a prescribed ample model} + +An effective correction exceptional over the end is the form needed to +compare a finite program with a prescribed positive side of a diagram. +The next argument uses the effective-pushforward form of negativity, +since the two corrections need not have the same exceptional primes; +compare \cite[Lemma~2.5]{ProjectiveLCFourfolds} in the projective setting. + +\begin{lemma}[Nef and ample models]\label{lem:nef-ample} +Let $Y_0$, $Y$, and $T_+$ be normal irreducible compact K\"ahler spaces +with projective bimeromorphic morphisms to a normal compact K\"ahler +space $S$. On a smooth common model $W$ over $S$, projective over these +spaces, let $P_0$, $P$, and $P_+$ be the pullbacks of respective +$\Q$-Cartier divisors $D_0$, $D_Y$, and $D_+$. Suppose that +\[ + P_0=P+E_Y=P_++E_+, +\] +where $E_Y\geq0$ is exceptional over $Y$ and $E_+\geq0$ is exceptional +over $T_+$. If $D_Y$ is nef over $S$ and $D_+$ is ample over $S$, +then $P=P_+$ as actual divisors. The induced bimeromorphic map is a +projective morphism $\varphi:Y\to T_+$ over $S$, and +$D_Y=\varphi^*D_+$. +\end{lemma} + +\begin{proof} +Write $r:W\to Y$ and $t:W\to T_+$, and put +$H=P-P_+=E_+-E_Y$. Then $r_*H=r_*E_+\geq0$. On an $r$-contracted +curve, $-H$ has the degree of $P_+$, which is nonnegative because +the curve lies over a point of $S$. Negativity gives $H\geq0$. +Likewise $t_*(-H)=t_*E_Y\geq0$, while $H$ is $t$-nef because $P$ comes +from an $S$-nef divisor. Negativity applied to $-H$ gives $H\leq0$. +Thus $P=P_+$. + +For a curve $C$ in an $r$-fiber, equality gives +$t^*D_+\cdot C=P\cdot C=0$. The image $t(C)$ lies in an $S$-fiber, +where $D_+$ is ample, so $t(C)$ is a point. Every $r$-fiber is +projective and connected. If an irreducible component of one such +fiber had positive-dimensional image under $t$, a curve in that +projective image and projective hyperplane cuts of its inverse image +would supply a curve on which $t$ is nonconstant. Thus each component +maps to a point, and connectedness makes those points equal. The map +$t$ is constant on every $r$-fiber. + +The reduced image of $(r,t):W\to Y\times_ST_+$ is a proper analytic +graph with one-point fibers over $Y$. Its projection to $Y$ is +therefore finite and bimeromorphic, hence an isomorphism by normality +of $Y$. This gives the morphism $\varphi$. Its graph is a closed +subspace of $Y\times_ST_+$, whose projection to $T_+$ is projective +by base change from $Y\to S$; hence $\varphi$ is projective. Finally, +pushing the equality $P=P_+$ to $Y$ gives +$D_Y=\varphi^*D_+$ as actual divisors. +\end{proof} + +\subsection{Ranks of analytic cycle classes} + +The small-diagram comparison forces a surface on at least one side of +every step. The following ranks count the steps after the positive +side has no exceptional surface. They also count divisorial steps in +the auxiliary programs. Their role is the analytic counterpart of the +surface-cycle rank in the terminal fourfold argument of +\cite[Theorem~5-1-15 and Lemma~5-1-17]{KawamataMatsudaMatsuki1987}. + +For a compact complex analytic space $V$ and an integer $k\geq0$, put +\[ + \begin{split} + \mathcal C_k(V)&=\operatorname{span}_{\Q} + \{[Q]\in H_{2k}(V,\Q): + Q\subset V\text{ irreducible compact analytic},\ \dim Q=k\},\\ + c_k(V)&=\dim_{\Q}\mathcal C_k(V). + \end{split} +\] +Fundamental classes use the complex orientation of the regular loci. +Finite compatible triangulations of compact analytic spaces make these +ranks finite. If $V$ is compact K\"ahler, the class of every such $Q$ +is nonzero, including when $V$ or $Q$ is singular: for a K\"ahler form +$\omega$, +\[ + \langle[\omega]^k,[Q]\rangle=\int_{Q_{\mathrm{reg}}}\omega^k>0. +\] +The same observation applies to a closed analytic subspace of a +compact K\"ahler space. We use ordinary homology on compact spaces +and Borel--Moore homology on open complements. + +\begin{lemma}[Loss of analytic cycle classes]\label{lem:cycle-loss} +Let $k\geq0$ be an integer, and let $X\dashrightarrow Y$ be a +bimeromorphic transformation of compact K\"ahler spaces represented by +a proper bimeromorphic diagram. +Suppose it identifies +\[ + U=X\setminus A\simeq Y\setminus B, +\] +where $A$ and $B$ are closed analytic subspaces and $\dim B0$ and a finite set $\mathcal I$ of global +places such that, at every remaining index $i$, +\begin{equation}\label{eq:stable-low-places} + \begin{gathered} + a_i(E)\geq\varepsilon\quad\text{for every global place }E, + \\ + \mathcal I= + \{E:E\text{ is exceptional over }X_i,\ a_i(E)\leq 1\}. + \end{gathered} +\end{equation} +There are projective bimeromorphic crepant morphisms +\begin{equation}\label{eq:terminal-junction} + \begin{gathered} + h_i:(Y_i,\Theta_i+\M)\longrightarrow (X_i,B_i+\M), + \\ + K_{Y_i}+\Theta_i+M_{Y_i}=h_i^*D_i, + \end{gathered} +\end{equation} +with the following properties. +\begin{enumerate} +\item Each $Y_i$ is a strong normal irreducible compact K\"ahler fourfold, +$\Theta_i$ is effective, and +$(Y_i,\Theta_i+\M)$ is generalized terminal. The exceptional prime +divisors of $h_i$ represent exactly the places in $\mathcal I$. +\item For $E\in\mathcal I$, let $S_{i,E}$ be its prime on $Y_i$. Define +\begin{equation}\label{eq:junction-coefficient-change} + \Theta_i'= + \Theta_i-\sum_{E\in\mathcal I} + \bigl(a_{i+1}(E)-a_i(E)\bigr)S_{i,E}. +\end{equation} +Starting with $(Y_i,\Theta_i'+\M)$, a finite, possibly empty, sequence +of small elementary steps over $Z_i$ ends at +$(Y_{i+1},\Theta_{i+1}+\M)$. All its models are strong normal irreducible +compact K\"ahler fourfolds, all its pairs are generalized +terminal, and its boundary and nef data are transported as in an elementary +program. In particular, every global place is exceptional over one model +of this connecting sequence if and only if it is exceptional over all of +them. +\item There is one finite label set $\mathcal H$ for the primes supplied by +$\mathcal I$ and by the components of $B_0$. Write $S_h$ for the current +strict transform of a label and $b_h$ for its current coefficient. Labels +are retained when their coefficient is zero. On the entire chain of +coefficient changes and small steps, +\[ + \Theta=\sum_{h\in\mathcal H}b_hS_h, + \qquad 0\leq b_h<1, +\] +and every $b_h$ is nonincreasing. Call a label \emph{varying} if its +coefficient sequence is not eventually constant, and \emph{fixed} +otherwise. After a further tail is chosen, all fixed coefficients are +constant. Every varying label comes from $\mathcal I$ and has positive +coefficient at every remaining stage. +\end{enumerate} +\end{proposition} + +Figure~\ref{fig:terminal-bridge} records the two kinds of change between +crepant junctions. The difficulty in Section~\ref{sec:difficulty} will +be compared across both upper moves. +\begin{figure}[ht] +\centering +\begin{tikzcd}[column sep=3.2cm,row sep=large] + (Y_i,\Theta_i) \arrow[r,Rightarrow,"\Theta_i'\leq\Theta_i"] + \arrow[d,"h_i"'] & + (Y_i,\Theta_i') \arrow[r,dashed,"\text{finite small program}"] & + (Y_{i+1},\Theta_{i+1}) \arrow[d,"h_{i+1}"] \\ + X_i \arrow[r,"f_i"'] & Z_i & X_{i+1}\arrow[l,"f_i^+"] +\end{tikzcd} +\caption{The bridge for one downstairs flip. The first upper arrow changes +the boundary on the same space; it is not a morphism. The second denotes a +finite, possibly empty, sequence of small elementary steps over $Z_i$. +The two vertical maps are crepant for the displayed endpoint boundaries, +and the b-divisor $\M$ is fixed throughout.} +\label{fig:terminal-bridge} +\end{figure} + +\begin{proof} +By Lemma~\ref{lem:small-comparison}, discrepancies do not decrease, and a +place is exceptional over $X_i$ exactly when it is exceptional over +$X_{i+1}$. Consequently the sets +\[ + \mathcal I_i=\{E:E\text{ is exceptional over }X_i,\ a_i(E)\leq1\} +\] +form a decreasing sequence. Proposition~\ref{prop:low-places} makes the +first of them finite and gives a positive lower bound for all initial +discrepancies. Monotonicity preserves that bound. A decreasing sequence +of subsets of a finite set stabilizes, which gives +\eqref{eq:stable-low-places}. We reindex this tail. + +If $\mathcal I$ is empty, take the identity as the first junction. +Otherwise apply Proposition~\ref{prop:extraction} at the first index to +extract exactly $\mathcal I$. Its hypotheses hold: the model is strong, +the pair is generalized klt with rational effective boundary, and the +fixed nef data are carried on a higher model projective over $X_i$. +The resulting morphism is projective bimeromorphic and has a strong normal +irreducible compact K\"ahler source. Crepancy gives the coefficient +$1-a_i(E)\in[0,1-\varepsilon]$ on an extracted prime; all other boundary +components are strict transforms of $B_i$. Thus the crepant boundary is +effective. Notice that a place with $a_i(E)=1$ is extracted with coefficient +zero. + +Any place exceptional over this source is exceptional over $X_i$: a prime +on $X_i$ has a strict transform on every proper birational model. Such a +place is not one of the extracted primes, so its discrepancy is strictly +greater than $1$ by \eqref{eq:stable-low-places}. Crepancy and the positive +lower bound prove generalized terminality. This constructs the first +junction. + +Suppose the junction over $X_i$ has been constructed. The coefficient of +$S_{i,E}$ changes in \eqref{eq:junction-coefficient-change} from +$1-a_i(E)$ to $1-a_{i+1}(E)$. Both are nonnegative because $E$ belongs to +the stabilized set at both indices, and the latter is no larger than the +former. The divisor subtracted from $\Theta_i$ is effective and +$\Q$-Cartier on the strong model $Y_i$. Its pullback to a higher model is +effective; hence subtracting it only increases discrepancies. In +particular, $\Theta_i'$ remains effective and +$(Y_i,\Theta_i'+\M)$ remains generalized terminal. Set +\[ + D_i'=K_{Y_i}+\Theta_i'+M_{Y_i}. +\] + +We first compare this adjoint with the positive model downstairs. By +Lemma~\ref{lem:common-projective-models}, choose a smooth common +model $W$, carrying $\M$, with projective maps +$q:W\to Y_i$ and $r:W\to X_{i+1}$, all over $Z_i$, and put +\begin{equation}\label{eq:junction-positive-comparison} + F=q^*D_i'-r^*D_{i+1}. +\end{equation} +The coefficient change makes $q_*F=0$. Indeed, at a prime $S_{i,E}$ with +$E\in\mathcal I$, the coefficient of the crepant boundary computed from +$X_{i+1}$ is $1-a_{i+1}(E)$, the new coefficient in $\Theta_i'$. +Every other prime on $Y_i$ corresponds, by smallness downstairs, to a +prime on $X_{i+1}$ and has its transported boundary coefficient. The +canonical representatives and the trace of the same b-divisor agree in +this calculation. On a curve contracted by $q$, the divisor $-F$ has +nonnegative degree: $q^*D_i'$ has degree zero and $r^*D_{i+1}$ is pulled +back from the $f_i^+$-ample divisor $D_{i+1}$. The negativity +lemma therefore gives $F\geq0$. Moreover every prime on $X_{i+1}$ is +represented on $Y_i$, where the coefficient of $F$ is zero. Thus $F$ is +exceptional over $X_{i+1}$. + +Use the finite generalized klt part of +Proposition~\ref{prop:relative-program} for $D_i'$ over $Z_i$. The map +$Y_i\to Z_i$ is projective bimeromorphic to a normal compact K\"ahler +base, the source is strong and generalized klt, and a common higher model +projective over $Y_i$ carries the fixed data with the +required relative nefness. The proposition supplies a finite elementary +program ending at a model $\overline Y$ whose adjoint $\overline D$ is nef +over $Z_i$. On a further common model, write again $q$ for the map to +$Y_i$ and $\bar q$ for the map to $\overline Y$. +Lemma~\ref{lem:program-comparison} gives +\[ + q^*D_i'=\bar q^*\overline D+G, + \qquad G\geq0\text{ exceptional over }\overline Y. +\] +Together with \eqref{eq:junction-positive-comparison}, these are the two +effective comparisons required by Lemma~\ref{lem:nef-ample}. That lemma +gives a projective morphism $h_{i+1}:\overline Y\to X_{i+1}$ and the +actual crepant identity $\overline D=h_{i+1}^*D_{i+1}$. + +This program cannot have lost a marked prime $S_{i,E}$. Its discrepancy +immediately after the coefficient change is $a_{i+1}(E)$; by the crepant +identity its discrepancy at the end is again $a_{i+1}(E)$. If a divisorial +step had contracted it, the strict comparison for that step would have +increased this discrepancy, and subsequent comparisons could not decrease +it. Nor can the program have lost any other prime on $Y_i$. Such a prime +corresponds to a prime on $X_{i+1}$, and that prime must have a strict +transform on $\overline Y$. An elementary program extracts no prime, so a +prime once contracted cannot reappear. We have excluded every divisorial +step. All connecting steps are therefore small, and their discrepancy +comparisons preserve generalized terminality. They also preserve the +exceptionality status of every place. Smallness downstairs keeps each +marked place exceptional over $X_{i+1}$, whereas every other surviving +prime corresponds to a prime on $X_{i+1}$. Thus the surviving marked +primes are exactly the exceptional primes of $h_{i+1}$, and the end is the +required junction $Y_{i+1}$. This proves the construction by induction. The +relative program is allowed to have length zero. + +There are finitely many marked primes and finitely many components of +$B_0$. Smallness transports all of them through every connector. The +downstairs coefficients are constant, and the marked coefficients are +$1-a_i(E)$ at junctions and are changed only by +\eqref{eq:junction-coefficient-change}. They are therefore nonincreasing +and lie in $[0,1)$. For the finitely many coefficient sequences that are +eventually constant, discard a prefix after all have become constant. +Every other sequence stays positive: a nonnegative nonincreasing sequence +that reaches zero is thereafter zero. Only marked coefficients can be of +this latter type. This proves the last assertion. +\end{proof} + +All the terminal models just constructed are also ordinarily terminal by +Lemma~\ref{lem:ordinary-singularities}. In particular they are smooth in +codimension two. To control marked coefficients above a surface, we need +no bound on the number of exceptional curves in a transverse slice. +Grouping the curves by their global marked labels will give a linear +system with at most $|\mathcal I|$ unknowns and an integer matrix whose +columns are linearly independent. We will bound its entries and clear one denominator for +its right-hand side; a nonsingular minor then gives a uniform lattice for +the marked coefficients. + +\begin{proposition}[Finiteness above marked surfaces]\label{prop:surface-finiteness} +In the setting of Proposition~\ref{prop:terminal-junctions}, there is a +finite set +\[ + \mathcal A_{\mathrm{surf}} + \subset [\varepsilon,1]\cap\Q +\] +such that $a_i(E)\in\mathcal A_{\mathrm{surf}}$ whenever +$E\in\mathcal I$ and $\cent_{X_i}(E)$ is a surface. After passing to a +further tail, the following conclusions hold. +\begin{enumerate} +\item No $E\in\mathcal I$ has a surface center contained in $L_i$ on +$X_i$, or a surface center contained in $L_i^+$ on $X_{i+1}$. +\item Every varying label $S_h\subset Y_i$ satisfies +$\dim h_i(S_h)\leq1$ at every junction. +\item For an irreducible compact analytic surface contained in either $L_i$ +or $L_i^+$, the corresponding +junction morphism is an isomorphism near its general point, and the +downstairs model is smooth there. Blowing up the coherent ideal of that +surface defines a unique global generic blowup place. It is exceptional +over the corresponding downstairs model and has discrepancy strictly +greater than $1$; in particular it does not belong to $\mathcal I$. +\end{enumerate} +\end{proposition} + +\begin{proof} +We first prove the assertion about $\mathcal A_{\mathrm{surf}}$. If +$\mathcal I$ is empty, choose $\mathcal A_{\mathrm{surf}}=\varnothing$. +For the remaining case, fix a junction $\rho:Y\to X$ and a surface +$V\subset X$ which is the center of at least one marked prime. We work +near general points of $V$. + +\medskip\noindent\emph{A transverse surface and its curves.} +The exceptional image of a proper birational morphism to normal $X$ has +codimension at least two. We may avoid every other component of that +image and every center properly contained in $V$. The full inverse image +of $V$ is a proper analytic subset of the irreducible fourfold $Y$, hence +has dimension at most three. A component supplying a curve over a general +point of $V$ must therefore have dimension three and be a divisor +dominating $V$. All such divisors are marked. Components of dimension +at most two cannot supply a curve in a general fiber. These observations +also show that the general fibers over $V$ have dimension at most one. + +The singular locus of terminal $Y$ has dimension at most one, so it misses +the fiber over a general point of $V$. The singular loci of the marked +divisors, their pairwise intersections, and their intersections with +strict transforms of components of $B_0$ have dimension at most two. +Choose also a projective carrier $\sigma:W\to Y$ for the fixed nef data, +with $W$ smooth. Its nonisomorphism image has dimension at most two. None of +these subsets can contain an entire curve over a general point of $V$: +a component that dominates the surface has zero-dimensional general +fiber, and components with smaller image can be avoided. + +Here is a precise choice of the slice used below. Near a general smooth +point of $V$, lift two local coordinates on $V$ to holomorphic functions +on $X$. Take a general common level set of their pullbacks on $Y$. +Finite analytic stratifications near the proper fiber can be chosen to +respect the divisors and the subsets in the preceding paragraph. On +every stratum dominating $V$, generic smoothness makes the two pulled-back +functions submersive over general values; the images of all other strata +can be avoided. It follows, after shrinking about the fiber, that the +level set is a smooth surface $R$. The restriction of $K_Y$ to $R$ is +$K_R$, because the two slice equations trivialize its normal bundle. + +Let $C_1,\ldots,C_q$ be the reduced irreducible curves of the fiber in +$R$. Each is supplied by exactly one marked divisor, with multiplicity +one in that divisor's slice: at a general point of the curve the divisor +is smooth, the slice is transverse on it, and none of the other listed +subsets contains that curve. Write $\lambda(j)$ for its label. The same +label may supply several curves, but each marked divisor with center $V$ +supplies at least one. No $C_j$ is contained in a strict downstairs +boundary component or in the nonisomorphism image of $\sigma$. + +The restricted map on the slice is proper near this fiber, contracts the +$C_j$ to a point, and is an isomorphism off that point locally. No +surface component is mapped to the point, by the fiber dimension bound. +Pass, if necessary, to the normal Stein factor of the local target, or +equivalently to the normalization of the relevant local image. We then +have a proper modification from the smooth surface whose reduced +exceptional set is the union of these curves. Grauert's +negative-definiteness criterion +\cite[Section~4, no.~8(e), pp.~366--367]{Grauert1962} therefore applies: +the matrix +\[ + A=(C_j\cdot C_k)_{1\leq j,k\leq q} +\] +is negative definite. Put $u_j=-C_j^2\in\Z_{>0}$ and +$m_{jk}=C_j\cdot C_k\in\Z_{\geq0}$ for $j\ne k$. + +\medskip\noindent\emph{Uniform bounds for the intersection equations.} +Let $B_Y^{\mathrm{str}}$ denote the strict boundary part coming from +$B_i$. It has nonnegative intersection with every $C_j$, since it is +effective and contains no such curve. The same nonnegativity holds for +$M_Y$. Indeed, the strict transform $C_j'$ on $W$ meets the isomorphism +locus of $\sigma$. For the effective nef defect of +Lemma~\ref{lem:nef-defect}, +\[ + J=\sigma^*M_Y-M_W\geq0, +\] +the curve $C_j'$ is not contained in $\Supp J$. The projection formula, +nefness on the carrier, and effectivity then give +\[ + M_Y\cdot C_j=M_W\cdot C_j'+J\cdot C_j'\geq0. +\] +Intersect the crepant equation +$K_Y+\Theta+M_Y=\rho^*D_X$ with $C_j$. On $R$ the marked part near the +fiber is $\sum_k b_{\lambda(k)}C_k$. Adjunction for the reduced +irreducible compact curve $C_j$ gives +$K_R\cdot C_j=2p_a(C_j)-2+u_j$. We obtain +\begin{align*} + 0={}&2p_a(C_j)-2+(1-b_{\lambda(j)})u_j + +\sum_{k\ne j}b_{\lambda(k)}m_{jk} + +(B_Y^{\mathrm{str}}+M_Y)\cdot C_j\\ + \geq{}&2p_a(C_j)-2+(1-b_{\lambda(j)})u_j. +\end{align*} +Since $p_a(C_j)\geq0$ and +$1-b_{\lambda(j)}\geq\varepsilon$, it follows that +\begin{equation}\label{eq:surface-self-intersection-bound} + (1-b_{\lambda(j)})u_j\leq2-2p_a(C_j)\leq2, + \qquad u_j\leq U:=\left\lceil\frac2\varepsilon\right\rceil. +\end{equation} + +Negative definiteness now bounds each whole row of $A$, even when $q$ is +large. Fix $j$ and test its quadratic form on the vector whose $j$th +entry is $1$ and whose $k$th entry is $m_{jk}/u_k$ for $k\ne j$. Its +value is +\[ + -u_j+\sum_{k\ne j}\frac{m_{jk}^2}{u_k} + +2\sum_{\substack{k<\ell\\k,\ell\ne j}} + \frac{m_{k\ell}m_{jk}m_{j\ell}}{u_ku_\ell}<0. +\] +The last sum is nonnegative. Therefore +\begin{equation}\label{eq:surface-row-bound} + \sum_{k\ne j}\frac{m_{jk}^2}{u_k}0$ such that every +$m_{\mathrm{data}}v_j$ is integral, for every junction and surface in +this calculation. Choose it to clear the initial boundary coefficients +of this strong generalized klt sequence and to make its chosen higher nef +divisor integral Cartier. Canonical +degrees on the smooth $R$ are integral. Each strict boundary prime is +Cartier in the smooth neighborhood of the fiber, so its degree has the +chosen boundary denominator. Finally, the trace of the integral Cartier +divisor $m_{\mathrm{data}}\M$ on any model is an integral Weil divisor: +compute it by pulling back to a common higher model and pushing forward. +On the smooth neighborhood of the present fiber that trace is Cartier, +so its degree is integral as well. No assertion about its Cartier index +elsewhere is needed. + +Choose $t$ rows of $AP$ giving a nonsingular square matrix. Its +determinant is a nonzero integer with an absolute value bounded in terms +of $t$ and $C_{\mathrm{row}}$, for example by +$t^{t/2}C_{\mathrm{row}}^t$ by Hadamard's inequality. Since +$1\leq t\leq|\mathcal I|$, choose one integer $H_{\mathrm{det}}$ bounding +all these absolute values. Cramer's rule applied to +\eqref{eq:grouped-surface-equations} then gives +\[ + \begin{gathered} + q_{\mathrm{surf}}= + m_{\mathrm{data}}\operatorname{lcm}(1,2,\ldots,H_{\mathrm{det}}), + \\ + b_h\in q_{\mathrm{surf}}^{-1}\Z\qquad(h\in\mathcal H_V). + \end{gathered} +\] +The denominator is independent of the junction, the surface, and the +number of geometric curves in the slice. In particular the marked +discrepancies above surfaces belong to the finite set +\begin{equation}\label{eq:marked-surface-discrepancies} + \mathcal A_{\mathrm{surf}} + =[\varepsilon,1]\cap q_{\mathrm{surf}}^{-1}\Z. +\end{equation} +This finite set is used only to exclude recurring marked surface centers +contained in the exceptional loci. The weight denominator in +Section~\ref{sec:difficulty} will be chosen later from the actual fixed +coefficients and the initial rational data; it need not clear every element +of $\mathcal A_{\mathrm{surf}}$. + +\medskip\noindent\emph{Removing marked surface centers from the exceptional loci.} +Fix $E\in\mathcal I$. Suppose its center is a surface in $L_i$ at +infinitely many indices $i_1a_{i_k}(E). +\] +Both $a_{i_k}(E)$ and $a_{i_{k+1}}(E)$ belong to +$\mathcal A_{\mathrm{surf}}$, a contradiction. If instead its center is +a surface in $L_i^+$ at +infinitely many indices, the corresponding positive-side discrepancies +satisfy +\[ + a_{i_{k+1}+1}(E)>a_{i_{k+1}}(E)\geq a_{i_k+1}(E), +\] +again contradicting membership of $a_{i_k+1}(E)$ and +$a_{i_{k+1}+1}(E)$ in the same finite set. There are finitely many +$E\in\mathcal I$, so one tail excludes all +such occurrences on both sides. This proves assertion (1). + +On that tail, suppose a marked prime has a surface center $V$ at a +junction over $X_i$. Assertion (1) says $V$ is not contained in $L_i$. +Its general point is therefore in the common isomorphism open of the +next diagram. The next center is its strict transform, still a surface, +and Lemma~\ref{lem:small-comparison} gives equality of its two +discrepancies. Repeating the argument at every subsequent index shows +that its coefficient is constant from this index onward. A varying label +cannot have such a surface center. Its center cannot be a divisor +downstairs because it represents an exceptional place. This proves +assertion (2). + +Finally let $V$ be an irreducible compact analytic surface in one of the exceptional loci of a +remaining diagram, and use the junction on that side. If the junction +were not an isomorphism at the general point of $V$, its general fiber +there would be positive dimensional: a proper birational morphism to a +normal space is an isomorphism wherever it is finite. A component +supplying those curves over $V$ would be a divisor with center $V$, by +the dimension argument at the start of the proof. This is excluded by +assertion (1). Thus the junction is an isomorphism near a general point +of $V$. The source is ordinarily terminal and smooth in codimension two, +so the downstairs model is smooth at a general point of this surface. + +The coherent ideal of the global analytic surface $V$ has a projective +blowup. Over the dense open where the ambient model and $V$ are smooth, +this is the ordinary codimension-two blowup and has a unique prime +divisor dominating $V$. Its closure on the normalized blowup defines +a global place with center $V$, hence an exceptional place on the +downstairs model. If its discrepancy were at most $1$, it would belong +to the stabilized set $\mathcal I$, contradicting assertion (1). +This proves assertion (3). +\end{proof} + +At each remaining junction, the reduced union of the varying labels is +contracted by $h_i$ to a set of dimension at most one. This is the input +for Theorem~\ref{thm:branch}. Assertion~(3) has a separate later use: +over a surface in the positive exceptional locus of a downstairs diagram, +it supplies the global generic blowup place and the smooth downstairs +neighborhood used by the detector in Section~\ref{sec:completion}. diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/05-branch-topology.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/05-branch-topology.tex new file mode 100644 index 0000000000000000000000000000000000000000..edaad16572cb44108d20329138e1d412d3bbbbff --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/05-branch-topology.tex @@ -0,0 +1,781 @@ +\section{The branch inequality} +\label{sec:branch} + +The terminal junctions constructed in Section~\ref{sec:junctions} have +only finitely many boundary labels, but one label can have several +normalization branches along a surface. We need to control the total +number of these branches for the labels whose images downstairs are +curves or points. The estimate in this section applies to an arbitrary +union of exceptional divisors with that image-dimension bound; it does +not use a boundary or a crepant equation. + +Let $p\colon Y\to X$ be a projective bimeromorphic morphism of normal +irreducible compact K\"ahler fourfolds, with $Y$ ordinary terminal. Let +\[ + Q=\bigcup_{j=1}^{m}Q_j\subset Y +\] +be a reduced union of distinct irreducible divisors, with $m\geq0$, and assume that +$\dim p(Q)\leq1$. Write $\nu_j\colon Q_j^\nu\to Q_j$ for normalization +and $\nu\colon\coprod_jQ_j^\nu\to Q$ for their disjoint union. For an +irreducible compact analytic surface $V\subset Q$, define +\begin{equation}\label{eq:branch-count-definition} + \begin{aligned} + r_V(Q)&=\#\{F:\ F\text{ is a prime divisor of }\coprod_jQ_j^\nu, + \ \nu(F)=V\},\\ + \beta(Q)&=\sum_{\substack{V\subset Q\\ \dim V=2}}(r_V(Q)-1). + \end{aligned} +\end{equation} +The surface $V$ is counted once in the sum, regardless of which $Q_j$ +contain it. A normalization divisor mapping to $V$ with degree greater +than one counts once in $r_V(Q)$; that degree will instead enter a +pushforward map in the proof. The sum in +\eqref{eq:branch-count-definition} will be shown to have only finitely +many nonzero terms. + +Recall that a global place over $Y$ is a prime divisor on a normal proper +bimeromorphic model, with primes identified by strict transform on a +common higher model. Put +\begin{equation}\label{eq:branch-place-count} + \tau_Y(Q)=\#\left\{ + \begin{array}{@{}l@{}} + E\text{ a global place over }Y:\\[-2pt] + \cent_Y(E)\text{ is an irreducible curve contained in }\Sing Y\cap Q, + \quad a(E;Y,0)=2 + \end{array}\right\}. +\end{equation} +Here $a(E;Y,0)$ is the ordinary log discrepancy, defined intrinsically +by the natural meromorphic comparisons of rational canonical bundles +on birational models. Thus +$\tau_Y(Q)$ counts global divisors, rather than divisors visible only +over a neighborhood of a point of a singular curve. + +\begin{theorem}[Branch inequality]\label{thm:branch} +Let $p\colon Y\to X$ be a projective bimeromorphic morphism of normal +irreducible compact K\"ahler fourfolds, where $Y$ has ordinary terminal +singularities. Let $Q=\bigcup_{j=1}^{m}Q_j$ be a reduced union of +distinct irreducible divisors satisfying $\dim p(Q)\leq1$. Then the +sum defining $\beta(Q)$ and the count defining $\tau_Y(Q)$ are finite, +and +\begin{equation}\label{eq:branch-inequality} + \beta(Q)\leq\sum_{j=1}^{m}c_2(Q_j^\nu)+\tau_Y(Q). +\end{equation} +The rank $c_2(Q_j^\nu)$ is the rational rank spanned in +$H_4(Q_j^\nu,\Q)$ by the fundamental classes of compact irreducible +analytic surfaces. +\end{theorem} + +At a terminal junction, Section~\ref{sec:difficulty} will take $Q$ to +be the union of varying labels and prove that rounding can leave an +integer deficit of at most $r_V(Q)-1$ at each surface $V\subset Q$. +Thus $\beta(Q)$ bounds the total possible deficit. The same section +shows that the terms from normalization ranks and exceptional weights +together contribute at least the right-hand side of +\eqref{eq:branch-inequality}. + +The proof first relates the normalization branches to the weight-four +part of a degree-five cohomology map. A smooth resolution then confines +that part to degree-two cohomology of punctured neighborhoods along the +singular curves of $Y$. The remaining argument converts those local classes into the +global places counted by \eqref{eq:branch-place-count}. The +normalization method follows the projective branch argument of +\cite[Section~5, especially Lemma~5.2]{ProjectiveLCFourfolds}. Here the +ambient fourfolds may be nonprojective, so we supply the analytic and +Hodge-theoretic steps needed in that setting. + +Unless other coefficients are displayed, homology and cohomology in +the rest of this section have rational coefficients and refer to the +complex analytic topology. We omit $\Q$ from their notation when this +causes no ambiguity. If $Q$ is empty, +all terms in \eqref{eq:branch-inequality} vanish. We henceforth assume +$Q\ne\varnothing$. + +\subsection{Projectivity over the center and normalization relations} + +To compare normalization relations on $Q$ with cohomology that a +resolution can control, enlarge $Q$ to the full inverse image of its +center. Set +\begin{equation}\label{eq:branch-projective-loci} + C=p(Q)_{\mathrm{red}},\qquad + P=(p^{-1}C)_{\mathrm{red}}. +\end{equation} +Properness makes $C$ a compact analytic subset of $X$. Its components +are compact curves and possibly isolated points. The comparison will +use $H^5(P)\to H^5(Q)$. We first show that these spaces over $C$ are +projective even when $X$ and $Y$ are not. + +Choose on each curve component of $C$ a smooth point that lies on no +other component. Their sum is a Cartier divisor on $C$, and its line +bundle has positive degree on every curve component. The ampleness +criterion for reduced compact analytic curves says that this positivity +is exactly ampleness; isolated point components impose no condition. +One can see why singularities introduce no additional obstruction by +normalizing $C$. Write $\nu_C\colon C^\nu\to C$ for this map. Its +source is a disjoint union of compact Riemann surfaces and points, and +\[ + 0\longrightarrow\mathcal O_C\longrightarrow + \nu_{C*}\mathcal O_{C^\nu}\longrightarrow\mathcal F\longrightarrow0 +\] +has a quotient $\mathcal F$ supported at finitely many points. On the +Riemann surfaces, a sufficiently high power of the chosen line bundle +separates points and any fixed finite set of jets by Riemann--Roch. +The conditions for these sections to descend to $C$ are the finitely +many gluing conditions measured by $\mathcal F$. Applying the same +jet separation to them gives the compact-curve criterion and a +projective embedding of $C$. + +We will also use the following form of the relative-embedding +criterion. Suppose that $q\colon R\to C$ is projective and has a +global relatively ample holomorphic line bundle $H$. Compactness of +$C$ permits one common power $H^n$ for the relative embeddings on a +finite cover of $C$. Its relative sections give a closed immersion +\[ + R\hookrightarrow\mathbb P_C(q_*H^n). +\] +Here the direct image is coherent by properness, and the relative +projective space is allowed to come from a coherent sheaf. If $A$ is +an ample line bundle on $C$, then $q_*H^n\otimes A^k$ is globally +generated for $k$ sufficiently large: algebraize the coherent sheaf +on the projective $C$ by GAGA +\cite[Section~12, Theorems~1--3]{SerreGAGA} and apply the usual global-generation +criterion. A surjection from a finite free sheaf onto it embeds its +projective space, and hence $R$, in $C\times\mathbb P^N$ for some +$N$. An embedding of $C$ and the Segre embedding now make $R$ +projective. This reasoning applies to reducible spaces and to +nonreduced closed subspaces as well. GAGA algebraizes their coherent +ideals, and also algebraizes holomorphic morphisms between the resulting +projective spaces. + +Apply this argument to the base change $P\to C$. It shows that $P$ +is projective. The closed analytic subspaces $Q$ and $Q_j$ are then +projective by GAGA, and the finite normalization $Q_j^\nu\to Q_j$ +is projective (as every finite morphism is), so each $Q_j^\nu$ is +projective as well. In particular, +all these spaces and all the maps between them may now be treated as +algebraic for purposes of mixed Hodge theory. + +The normalization comparison requires a pure threefold containing $Q$. +Let $P_1$ be the reduced union of the three-dimensional components of +$P$. The preimage of the proper analytic subset $C\subset X$ is a +proper analytic subset of the irreducible fourfold $Y$, so its +components have dimension at most three. Each $Q_j$ has dimension +three and is one of those components. Thus +\[ + Q\subset P_1\subset P,\qquad \dim(P\setminus P_1)\leq2. +\] +These observations also apply when $C$ consists only of points. + +For a projective variety $R$, the mixed Hodge structure on $H_k(R)$ +is dual to that on $H^k(R)$. We write $W_\bullet$ for the weight +filtration on either group. For a map of such groups, +$\rk\Gr^W_a[\,\cdot\,]$ will mean the rank of its induced map on the +weight-$a$ graded pieces. If $R$ has dimension at most two, then +$H_4(R)$ has the fundamental classes of its irreducible surface +components as a basis. It is pure of weight $-4$: these classes are +the pushforwards of the top classes of smooth projective resolutions +of the components, which have that weight; see also +\cite[Theorem~8.2.4(ii)--(iii)]{DeligneHodgeIII}. + +\begin{lemma}[Normalization relations]\label{lem:branch-normalization} +For the spaces in \eqref{eq:branch-projective-loci}, the sum defining +$\beta(Q)$ is finite and +\begin{equation}\label{eq:branch-normalization-bound} + \beta(Q)-\sum_jc_2(Q_j^\nu) + \leq \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr]. +\end{equation} +\end{lemma} + +\begin{proof} +For a reduced pure projective threefold $R$, write +$\nu_R\colon N_R\to R$ for normalization. Choose a closed reduced +subset $A_R\subset R$ of dimension at most two containing the locus +where $\nu_R$ is not an isomorphism, and put +$F_R=(\nu_R^{-1}A_R)_{\mathrm{red}}$. The square +\[ +\begin{tikzcd} + F_R \arrow[r,hook] \arrow[d] & N_R \arrow[d,"\nu_R"]\\ + A_R \arrow[r,hook] & R +\end{tikzcd} +\] +is a proper excision square. Indeed $\nu_R$ is finite and proper and +identifies the open complements. Collapsing the two closed subsets +gives a continuous bijection $N_R/F_R\to R/A_R$ of compact Hausdorff +quotients, hence a homeomorphism. Comparing the two relative homology +sequences gives the exact sequence +\begin{equation}\label{eq:branch-normalization-excision} + H_5(R)\xrightarrow{\partial_R}H_4(F_R) + \longrightarrow H_4(A_R)\oplus H_4(N_R). +\end{equation} +All its maps are compatible with mixed Hodge structures. This follows +from algebraic functoriality and the exact sequence of relative +cohomology as a sequence of mixed Hodge structures +\cite[Propositions~8.2.2 and 8.3.9]{DeligneHodgeIII}, followed by +duality on these compact spaces. + +Take this square first for $P_1$. For $Q$, take +$A_Q=Q\cap A_{P_1}$. The normalization +$N_Q=\coprod_jQ_j^\nu$ is a union of entire, disjoint normalization +components of $N_{P_1}$. Thus these choices give a morphism of the +two squares, with $F_Q$ equal to the part of $F_{P_1}$ in those +selected components. + +For a surface component $V$ of $A_Q$, let +$F_{V,1},\ldots,F_{V,r_V(Q)}$ be the surface components of $F_Q$ +mapping onto it, and let $d_{V,\alpha}>0$ be their finite degrees over +$V$. On top homology the corresponding part of the map to $A_Q$ is +\[ + \bigoplus_{\alpha=1}^{r_V(Q)}\Q[F_{V,\alpha}] + \longrightarrow\Q[V],\qquad + \sum_\alpha t_\alpha[F_{V,\alpha}] + \longmapsto\left(\sum_\alpha d_{V,\alpha}t_\alpha\right)[V]. +\] +Its kernel has dimension $r_V(Q)-1$. A surface not contained in +$A_Q$ has exactly one normalization divisor over it, since the +normalization is an isomorphism at its general point. Conversely, +finiteness and surjectivity of normalization give at least one divisor +over every surface in $Q$. It follows that +\[ + B_Q:=\ker\bigl[H_4(F_Q)\longrightarrow H_4(A_Q)\bigr], + \qquad \dim B_Q=\beta(Q). +\] +This also proves finiteness of the sum: the only possible nonzero +terms come from the finitely many surface components of $A_Q$. + +The image of $B_Q$ in $H_4(N_Q)$ is spanned by classes of compact +surfaces in its normalization components. Its rank is therefore at +most $\sum_jc_2(Q_j^\nu)$. Hence +\[ + U_Q:=\ker\bigl[B_Q\longrightarrow H_4(N_Q)\bigr] + \quad\text{satisfies}\quad + \dim U_Q\geq\beta(Q)-\sum_jc_2(Q_j^\nu). +\] +By \eqref{eq:branch-normalization-excision}, $U_Q$ is the image of +$\partial_Q$. + +The map $H_4(F_Q)\to H_4(F_{P_1})$ is injective. Both groups have +surface components as their bases, and the surfaces in $F_Q$ remain +distinct surfaces on the selected normalization components of +$P_1$. Naturality of the boundary maps therefore sends $U_Q$ +injectively into the image of $\partial_{P_1}$ on the image of +$H_5(Q)\to H_5(P_1)$. The groups $H_4(F_Q)$ and $H_4(F_{P_1})$ +are pure of weight $-4$. Strictness for the weight filtration +\cite[Theorem~2.3.5(iii)--(iv)]{DeligneHodgeII} says that +$\partial_R$ maps $\Gr^W_{-4}H_5(R)$ onto its image in the pure group +$H_4(F_R)$. Applying this to the naturality square, we obtain +\[ + \dim U_Q\leq + \rk\Gr^W_{-4}\bigl[H_5(Q)\longrightarrow H_5(P_1)\bigr]. +\] +Finally, Borel--Moore localization contains +\[ + H^{\BM}_6(P\setminus P_1)\longrightarrow H_5(P_1) + \longrightarrow H_5(P). +\] +The first group vanishes because $P\setminus P_1$ has complex +dimension at most two. The second arrow is therefore injective, +and remains injective on weight-graded pieces by strictness. Duality +between rational homology and cohomology reverses the sign of the +weight and turns the last two inequalities into +\eqref{eq:branch-normalization-bound}. +\end{proof} + +\subsection{A smooth resolution and purity over the center} + +Lemma~\ref{lem:branch-normalization} proves the normalization bound +and finiteness of $\beta(Q)$. To finish Theorem~\ref{thm:branch}, we +must prove finiteness of $\tau_Y(Q)$ and the remaining estimate +\[ + \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr]\leq\tau_Y(Q). +\] +We first show that $W_4H^5(P)$ vanishes after pullback to the resolved +inverse image. The key purity there comes from compact K\"ahler Hodge +theory on the smooth ambient resolution. + +Fix, for the rest of Section~\ref{sec:branch}, one projective +resolution with smooth source +\[ + g\colon\widetilde Y\longrightarrow Y +\] +which is an isomorphism over $Y_{\mathrm{reg}}$, whose exceptional +locus is a divisor with simple normal crossings, and which principalizes +the ideal of $\Sing Y$. Thus +\[ + \mathcal I_{\Sing Y}\mathcal O_{\widetilde Y} + =\mathcal O_{\widetilde Y}(-E_{\mathrm{sing}}), + \qquad + \Supp E_{\mathrm{sing}}=g^{-1}(\Sing Y). +\] +Smoothness is used for purity here; the conditions on the exceptional +divisor and singular ideal will be used in the curve construction. +If $Y$ is smooth, we take $g$ to be the identity and the displayed +divisor to be zero. Projective resolution and principalization, chosen +to preserve the already resolved open $Y_{\mathrm{reg}}$, give such a +choice in the analytic category +\cite[Theorems~1.10, 12.2, and 13.2(1)]{BierstoneMilman1997}. The resolution is compact +K\"ahler, and both $g$ and $pg$ have global relatively ample line +bundles. For the composite one uses a sufficiently positive twist +of a $g$-ample bundle by the pullback of a $p$-ample bundle; compactness +allows a uniform choice. Set +\[ + \widetilde P=((pg)^{-1}C)_{\mathrm{red}}. +\] +The projectivity argument over $C$ given above shows that +$\widetilde P$ is projective. + +We use intersection complexes in their perverse normalization. For +an irreducible complex analytic space $Z$ of dimension $z$ and a local +system $\mathcal E$ on a smooth dense open, $\IC_Z(\mathcal E)$ +restricts there to $\mathcal E[z]$. It is the middle extension of +that shifted local system: it has no nonzero perverse subobject or +quotient supported in a proper analytic subset of $Z$. The stalk +support condition says that on a smooth boundary stratum of dimension +$s$, +\begin{equation}\label{eq:branch-ic-stalk-bound} + \mathcal H^q(\IC_Z(\mathcal E))|_S=0\qquad(q>-s-1). +\end{equation} +Here $\mathcal H^q$ denotes ordinary cohomology sheaves, not perverse +cohomology. These conventions and the support condition are the +middle-extension axioms in +\cite[Section~2.3 and Section~3.3, Axiom {\rm[AX1]}(c)]{GoreskyMacPhersonIHII}. +They are local statements on stratified spaces, so they apply to the +analytic stratifications used here. If a new stratum of dimension $s$ +cuts the local-system open, the only stalk degree is $-z$, which is +at most $-s-1$ whenever $s2(3-z)-4. +\] +The generic nonzero stalk of $\mathcal K_{Z,i}[-i]$ is in degree +$i-z$, because a perverse middle extension on $Z$ has its generic +local system in degree $-z$. It is a direct summand of this stalk, +so +\begin{equation}\label{eq:branch-support-shift} + i-z\leq2(3-z)-4,\qquad\text{or equivalently}\qquad i+z\leq2. +\end{equation} + +We now restrict the decomposition to $C$. Suppose first that +$Z\not\subset C$, and stratify $Z\cap C$ compatibly with +$\mathcal K_{Z,i}$. A stratum $S$ has dimension $s\leq z-1$ and +$s\leq1$. Its stalk degrees for $\mathcal K_{Z,i}$ are at most +$-s-1$ by \eqref{eq:branch-ic-stalk-bound}. This remains valid under +the refinement by $C$: a stratum cut out of an old boundary stratum +inherits the stronger bound from that stratum, while a stratum cut +out of the local-system open has only degree $-z\leq-s-1$. +Compactly supported cohomology on the smooth complex $s$-fold $S$ +vanishes above degree $2s$. Thus its contribution to the +hypercohomology of $\mathcal K_{Z,i}[-i]|_C$ vanishes in degrees +greater than +\[ + i-s-1+2s=i+s-1\leq i+z-2\leq0. +\] +Filtering $C$ by its finitely many strata proves that this summand +has no degree-one hypercohomology on $C$. The full-support summand +$\IC_X$ has the same property: for each stratum of $C$, the upper +bound is $-s-1+2s=s-1\leq0$; on the smooth open its only stalk degree +is $-4$, which is smaller still. + +Only summands with $Z\subset C$ can therefore contribute in degree +one. Such a complex is supported on the closed subset $C$, so its +restriction induces an isomorphism on hypercohomology from $X$ to +$C$. The chosen global splitting and proper base change now show that +\[ + \mathbb H^1(X,K_f)=H^5(\widetilde Y) + \longrightarrow + \mathbb H^1(C,K_f|_C)=H^5(\widetilde P) +\] +is surjective. + +It remains to justify what this surjection says about weights. +Compact K\"ahler Hodge theory gives $H^5(\widetilde Y,\Q)$ its pure +Hodge structure of weight $5$. On the projective $\widetilde P$, +Deligne's mixed Hodge structure has weights at most $5$ +\cite[Theorem~8.2.4(iii)]{DeligneHodgeIII}. We verify directly that +the restriction map preserves its Hodge filtration, because the +ambient $\widetilde Y$ may be nonprojective. + +Choose a proper smooth projective hyperresolution +$\epsilon_\bullet\colon Z_\bullet\to\widetilde P$. Deligne's +construction computes the Hodge filtration on $H^5(\widetilde P)$ +from the total simplicial de Rham complex of the $Z_n$, filtered by +holomorphic form degree +\cite[Section~8.1, (8.2.1), and Proposition~8.2.2]{DeligneHodgeIII}. +The terms can be chosen projective because $\widetilde P$ is projective +and the construction can use projective resolutions and modifications. +We may use smooth forms in this complex, with the same filtration: +the Dolbeault resolutions give filtered quasi-isomorphisms from the +holomorphic de Rham complexes on the smooth $Z_n$. +A class in $F^aH^5(\widetilde Y,\C)$ has a closed smooth representative +$\eta$ whose components have holomorphic degree at least $a$, by the +K\"ahler Hodge decomposition. Pullback along the holomorphic map +$Z_0\to\widetilde P\hookrightarrow\widetilde Y$ preserves these +bidegrees. Put that pullback in simplicial degree zero of the total +complex. Its de Rham differential vanishes, and its simplicial +differential is zero because the two face pullbacks to $Z_1$ have the +same composite with the augmentation. It is therefore a cocycle in +the filtered total de Rham complex. It represents the ordinary +topological restriction by de Rham +naturality and cohomological descent. Thus restriction preserves +$F^a$ for every $a$. + +The restriction is rational on underlying cohomology. It also +preserves $W$: the source is pure of weight $5$, and $W_5$ is all of +the target. It is consequently a morphism of mixed Hodge structures. +Strictness for $W$ \cite[Theorem~2.3.5(iii)]{DeligneHodgeII}, applied +to the surjection just proved, yields +\[ + W_4H^5(\widetilde P) + =\im\bigl[W_4H^5(\widetilde Y)\to H^5(\widetilde P)\bigr]=0. +\] +Together with the upper weight bound, this proves purity of weight +$5$. Strictness here concerns mixed Hodge structures themselves and +does not require a rational polarization on the compact K\"ahler +source. +\end{proof} + +\subsection{The contribution of singular curves} + +Let $j\colon Y_{\mathrm{reg}}\hookrightarrow Y$ be the inclusion. +Ordinary terminal singularities are smooth in codimension two, so +$\Sing Y$ is a finite union of irreducible curves and points. Analytic +constructibility and a compatible Whitney stratification let us +remove a finite set of points from each singular curve $T$ so that +the remaining connected smooth curve $T^\circ$ carries the local +systems +\begin{equation}\label{eq:branch-local-systems} + \mathcal V_T=(R^2j_*\Q_{Y_{\mathrm{reg}}})|_{T^\circ},\qquad + \mathcal W_T=(R^2g_*\Q_{\widetilde Y})|_{T^\circ},\qquad + b_T=\dim H_c^2(T^\circ,\mathcal V_T). +\end{equation} +Here $\mathcal V_T$ records degree-two cohomology of punctured +neighborhoods, while $\mathcal W_T$ records that of the fixed +resolution fibers and will provide geometric representatives. +We use one finite puncture set on each $T$ for all the following +requirements. All cohomology sheaves of $Rj_*\Q$ and $Rg_*\Q$ are +locally constant on $T^\circ$, and the fibers of $g$ there have +dimension at most two. For the latter assertion, +$g^{-1}(T)$ has dimension at most three, so the general fiber has +dimension at most two; remove its exceptional dimension-jump points. +We also remove intersections of singular curves and the finitely +many points of $T\cap Q$ when $T$ is not contained in $Q$. + +For later use we impose one further condition on this same finite +puncture set. Let $E$ be a prime component of $\Exc(g)$ dominating +$T$. It is smooth because the exceptional divisor has simple normal +crossings. Its proper map to $T$ has a Stein factorization +\[ + E\longrightarrow\widehat T_E\longrightarrow T, +\] +where the first map has connected fibers and the second is finite. +The intermediate curve is normal and irreducible because $E$ is +normal and irreducible. Remove from $T$ the branch values of the +finite map and the critical values of the first map, together with +the already excluded singular points. Properness and generic +smoothness make these sets finite. Over $T^\circ$ the second map +is then a finite unramified cover; it stays connected because deleting +finitely many points from the irreducible normal curve +$\widehat T_E$ leaves it connected. The first map is a smooth proper +family with connected fibers. There are only finitely many +such $E$, so these conditions can be imposed simultaneously. They +will let us recognize global divisors after restricting to a smaller +curve domain. + +The number $b_T$ is unaffected by any further finite puncturing. +Indeed, for $t\in T^\circ$, Poincar\'e duality on the oriented real +surface $T^\circ$ gives +\[ + H_c^2(T^\circ,\mathcal V_T) + \simeq H^0(T^\circ,\mathcal V_T^\vee)^\vee + \simeq \bigl((\mathcal V_T)_t\bigr)_{\pi_1(T^\circ,t)}, +\] +where the last term is the coinvariant space for monodromy. A loop +can be perturbed away from finitely many additional points, so the +fundamental group of the further punctured curve surjects onto +$\pi_1(T^\circ,t)$. The restricted local system has the same +monodromy image, and hence the same coinvariant dimension. + +\begin{lemma}[The weight-four contribution]\label{lem:branch-cone} +With the choices in \eqref{eq:branch-local-systems}, +\begin{equation}\label{eq:branch-cone-bound} + \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr] + \leq + \sum_{\substack{T\text{ irreducible curve}\\T\subset\Sing Y\cap Q}} b_T. +\end{equation} +\end{lemma} + +\begin{proof} +Use the full-support projection in the chosen decomposition for $g$ +to form the morphism +\[ + \alpha\colon\Q_Y[4]\longrightarrow Rg_*\Q_{\widetilde Y}[4] + \longrightarrow\IC_Y. +\] +The first arrow is the natural pullback map. Both arrows restrict +to the identity on $Y_{\mathrm{reg}}$. Let $\mathcal L$ be the cone +of $\alpha$, so that +\begin{equation}\label{eq:branch-comparison-triangle} + \Q_Y[4]\xrightarrow{\alpha}\IC_Y\longrightarrow\mathcal L + \longrightarrow\Q_Y[5]. +\end{equation} +It is supported on $\Sing Y$. +Enlarge the finite puncture sets, if necessary, so that the cohomology +sheaves of $\mathcal L$ are local systems on each $T^\circ$. Analytic +constructibility permits this enlargement, and the preceding +coinvariant description shows that it does not change $b_T$. + +By proper base change, the map induced by $\alpha$ on $P$ factors as +\[ + H^5(P)\longrightarrow H^5(\widetilde P) + \longrightarrow\mathbb H^1(P,\IC_Y|_P). +\] +The first arrow comes from a holomorphic morphism between the +projective spaces $\widetilde P$ and $P$, and is algebraic by GAGA. +It therefore preserves weights. Lemma~\ref{lem:branch-resolved-purity} +shows that it kills $W_4H^5(P)$. Hence the displayed composite kills +that subspace as well; we need no weight statement about the chosen +perverse projection. The long exact sequence of +\eqref{eq:branch-comparison-triangle} on $P$ gives +\[ + W_4H^5(P)\subset + \im\bigl[\mathbb H^0(P,\mathcal L|_P)\longrightarrow H^5(P)\bigr]. +\] +Restricting the triangle from $P$ to $Q$ shows that the image of this +subspace in $H^5(Q)$ is contained in the image of +$\mathbb H^0(Q,\mathcal L|_Q)$. Passing to a weight-graded quotient +can only lower rank, and therefore +\begin{equation}\label{eq:branch-cone-rank} + \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr] + \leq\dim\mathbb H^0(Q,\mathcal L|_Q). +\end{equation} + +We estimate the last group by its strata. On a stratum of $\Sing Y$ +of dimension $s\in\{0,1\}$, the bound +\eqref{eq:branch-ic-stalk-bound} and the triangle give +\begin{equation}\label{eq:branch-cone-stalk-bound} + \mathcal H^q(\mathcal L)|_S=0\qquad(q>-s-1). +\end{equation} +The constant complex in the triangle has its only stalk cohomology +in degree $-4$; its shifted contribution to the cone is in degree +$-5$, so it cannot alter this upper bound. On a curve $T^\circ$, +the same triangle identifies $\mathcal H^{-2}(\mathcal L)$ with +$\mathcal H^{-2}(\IC_Y)$. The curve stratum has complex codimension +three in $Y$. In the middle-extension construction, attaching a +codimension-$c$ stratum retains the unshifted cohomology of $Rj_*\Q$ +through degree $c-1$. For $c=3$ this gives +\begin{equation}\label{eq:branch-cone-link} + \mathcal H^{-2}(\mathcal L)|_{T^\circ} + =\mathcal H^{-2}(\IC_Y)|_{T^\circ} + =(R^2j_*\Q)|_{T^\circ}=\mathcal V_T. +\end{equation} +This is the attaching truncation of +\cite[Section~3.1 and Section~3.3, Axiom {\rm[AX1]}(d)]{GoreskyMacPhersonIHII}, +with the shift by four from our perverse normalization. + +The restriction $\mathcal L|_Q$ is supported on the closed set +$\Sing Y\cap Q$, so its hypercohomology may be computed on that set. +The complement there of the disjoint opens $T^\circ$ +for the curves contained in $Q$ is finite. A point stratum contributes +nothing to degree-zero hypercohomology by +\eqref{eq:branch-cone-stalk-bound}. The open--closed cohomology +sequence therefore gives a surjection +\[ + \bigoplus_{T\subset\Sing Y\cap Q} + \mathbb H_c^0(T^\circ,\mathcal L|_{T^\circ}) + \longrightarrow\mathbb H^0(Q,\mathcal L|_Q). +\] +On a curve, compactly supported cohomology of a local system vanishes +above degree two. In the spectral sequence +\[ + H_c^a(T^\circ,\mathcal H^b(\mathcal L)|_{T^\circ}) + \ \Longrightarrow\ + \mathbb H_c^{a+b}(T^\circ,\mathcal L|_{T^\circ}), +\] +the stalk bound gives $b\leq-2$. The only term in total degree zero +is consequently $a=2$, $b=-2$, whose dimension is $b_T$ by +\eqref{eq:branch-cone-link}. The dimension of each degree-zero +abutment is at most $b_T$. This bound and +\eqref{eq:branch-cone-rank} prove \eqref{eq:branch-cone-bound}. +\end{proof} + +Combining Lemmas~\ref{lem:branch-normalization} and +\ref{lem:branch-cone} gives the topological reduction of the theorem: +\begin{equation}\label{eq:branch-topological-bound} + \begin{aligned} + \beta(Q)-\sum_jc_2(Q_j^\nu) + &\leq \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr]\\ + &\leq + \sum_{\substack{T\text{ irreducible curve}\\T\subset\Sing Y\cap Q}} b_T. + \end{aligned} +\end{equation} +There are finitely many curves in this sum, and the local systems have +finite rank on curves of finite topological type, so its terms are +finite. It remains to prove that this sum is at most $\tau_Y(Q)$ and +that $\tau_Y(Q)$ is finite. + +We finish the topological part by relating the punctured cohomology +in $\mathcal V_T$ to the cohomology of the fixed resolution. This +identifies the classes that the subsequent geometric construction +will realize. + +\begin{lemma}[Resolution cohomology and punctured cohomology] +\label{lem:link-quotient} +For every singular curve $T$ with the choices in +\eqref{eq:branch-local-systems}, restriction from the resolution to +the regular locus induces a surjection of local systems +\begin{equation}\label{eq:branch-link-quotient} + \mathcal W_T\twoheadrightarrow\mathcal V_T. +\end{equation} +For every $t\in T^\circ$, its map on fibers is equivariant for the +action of $\pi_1(T^\circ,t)$ and is the map induced by restriction +\begin{equation}\label{eq:branch-link-stalk-map} + \begin{aligned} + (\mathcal W_T)_t + &\simeq H^2(g^{-1}(t)) + \simeq\varinjlim_{U\ni t}H^2(g^{-1}U)\\ + &\longrightarrow\varinjlim_{U\ni t}H^2(U\cap Y_{\mathrm{reg}}) + \simeq(\mathcal V_T)_t, + \end{aligned} +\end{equation} +where $U$ runs through sufficiently small open neighborhoods of $t$ +in $Y$ and $g^{-1}(U\cap Y_{\mathrm{reg}})$ is identified with +$U\cap Y_{\mathrm{reg}}$. +\end{lemma} + +\begin{proof} +The isomorphism of $g$ over the regular locus and adjunction give a +natural morphism +\[ + \rho\colon Rg_*\Q_{\widetilde Y}[4] + \longrightarrow Rj_*\Q_{Y_{\mathrm{reg}}}[4]. +\] +By the definition of a higher direct-image stalk and proper base +change for $g$, its degree-$-2$ map at $t$ is precisely +\eqref{eq:branch-link-stalk-map}. These are the usual sheaf +cohomology groups of constant sheaves, equal to singular cohomology +on the locally contractible analytic spaces in question. + +Let $\kappa\colon\IC_Y\to Rg_*\Q_{\widetilde Y}[4]$ be the +full-support inclusion in the chosen decomposition. Its restriction +to $Y_{\mathrm{reg}}$ is the identity. The composite +$\rho\kappa\colon\IC_Y\to Rj_*\Q[4]$ is therefore the canonical +comparison morphism: by adjunction a morphism to $Rj_*\Q[4]$ is +determined by its restriction to $Y_{\mathrm{reg}}$. The +codimension-three attaching construction used in +\eqref{eq:branch-cone-link} says that this comparison is an +isomorphism on ordinary stalk cohomology in degree $-2$ along +$T^\circ$. Its degree-$-2$ map factors through +\[ + \mathcal H^{-2}(Rg_*\Q[4])|_{T^\circ}=\mathcal W_T. +\] +Thus the degree-$-2$ map induced by $\rho$, namely +\eqref{eq:branch-link-quotient}, is surjective. It is a morphism of +the local systems in \eqref{eq:branch-local-systems}, which gives +the asserted monodromy equivariance. +\end{proof} diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/06-curve-places.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/06-curve-places.tex new file mode 100644 index 0000000000000000000000000000000000000000..5ddbaf5124444d0d51b3f7b9d4040f44b6f5c1a5 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/06-curve-places.tex @@ -0,0 +1,496 @@ +\subsection{Curve contributions and global places} +\label{subsec:curve-places} + +It remains to bound the contribution \(b_T\) of each singular curve by +global divisors. We realize the relevant cohomology classes by line +bundles near a compact subset carrying all loops of \(T^\circ\). Degrees +on the fibers of a small \(\Q\)-factorialization then produce exceptional +surfaces. Retaining those loops will ensure that their blowup places +remain distinct on the fixed global resolution. + +\begin{proposition}[Global places over a singular curve]\label{prop:curve-places} +For every irreducible curve component \(T\) of \(\Sing Y\), with \(b_T\) +as in \eqref{eq:branch-local-systems} and the fixed resolution +\(g:\widetilde Y\to Y\), +\[ + b_T\ \le\ + \#\left\{ + \begin{array}{c} + E\text{ a prime component of }\Exc(g):\\ + g(E)=T,\quad a(E;Y,0)=2 + \end{array} + \right\}. +\] +In particular, the divisors counted here represent distinct global +divisorial places. +\end{proposition} + +\begin{proof} +Fix \(T\), and write +\[ + q_T:\mathcal W_T\longrightarrow\mathcal V_T +\] +for the natural quotient of Lemma~\ref{lem:link-quotient}. If \(b_T=0\) +there is nothing to prove, so assume \(b_T>0\). We may remove finitely +many further points of \(T^\circ\) whenever needed. The local systems +already defined restrict to the smaller curve, and the induced map on +fundamental groups is surjective. Thus their monodromy images and the +coinvariant dimension \(b_T\) do not change. + +We first construct sections +\[ + \sigma_1,\ldots,\sigma_{b_T}\in H^0(T^\circ,\mathcal W_T) +\] +whose images under \(q_T\) are linearly independent in every fiber of +\(\mathcal V_T\), after the permitted further finite puncturing. + +\emph{Step 1. Invariant lifts from finite monodromy.} +First we show that \(\mathcal W_T\), and therefore its quotient +\(\mathcal V_T\), has finite monodromy. Let +\(\mathcal F=\widetilde Y\times_Y T\), with its full complex-space +structure. It is projective over the compact projective curve \(T\). +A relative embedding and GAGA identify this morphism with an algebraic +projective family, including its possibly nonreduced scheme fibers. +After deleting finitely many points we may assume that +\(\mathcal F\to T^\circ\) is flat and that all +\((R^kg_*\Q)|_{T^\circ}\) are local systems. + +For \(t\in T^\circ\), put \(F_t=\mathcal F_t\). Every integral class in +\(H^2(F_t,\Z)\) lifts, by proper base change, to +\(H^2(g^{-1}U_t,\Z)\) for a sufficiently small Stein neighborhood +\(U_t\) of \(t\) in \(Y\). Terminal singularities are rational +\cite[Remark~3.8 and Theorem~3.12]{FujinoAnalyticMMP}. Hence +\(g_*\mathcal O_{\widetilde Y}=\mathcal O_Y\) and +\(R^kg_*\mathcal O_{\widetilde Y}=0\) for \(k>0\); Leray and Cartan's +Theorem~B give +\[ + H^2(g^{-1}U_t,\mathcal O_{\widetilde Y})=0. +\] +The exponential sequence therefore realizes the lifted integral class +as the first Chern class of a holomorphic line bundle on \(g^{-1}U_t\). +Its restriction to the projective scheme \(F_t\) is algebraic by the +scheme form of GAGA +\cite[Corollary~4.3 and Theorem~4.4]{RaynaudSGA1XII}. In particular, +\begin{equation}\label{eq:curve-fiber-chern} + \Pic(F_t)\otimes_{\Z}\Q + \xrightarrow{\ c_1\ } H^2(F_t,\Q)=(\mathcal W_T)_t + \quad\text{is surjective}. +\end{equation} +Here and below the cohomology of a scheme fiber means that of its +analytic topological space; nilpotents do not change it. + +We use the parameter argument of +\cite[Section~6.1, proof of Lemma~6.4]{ProjectiveLCFourfolds} to show +that a spanning set of fiber classes has finite monodromy orbits. Fix a +relatively very ample \(\mathcal O_{\mathcal F}(1)\). Every line bundle on a +fiber is a quotient of some +\(\mathcal O_{F_t}(-n)^{\oplus r}\). Letting \(n,r\), and the Hilbert +polynomial vary gives countably many relative Quot schemes of finite +type over \(T^\circ\) +\cite[Theorems~3.1--3.2]{GrothendieckHilbert1961}. In each take the +open set on which the universal quotient is invertible on the whole +pulled-back family. These open sets still contain a point representing +every fiber line bundle. Indeed the family and universal quotient are +flat over the Quot scheme, so the local criterion for flatness makes a +fiberwise locally free quotient of rank one locally free near that +fiber; properness removes the image of the complementary closed locus. + +There are countably many irreducible components of these parameter +spaces. Choose \(t\) outside the closures of the images of all +components which do not dominate \(T^\circ\). Such a point exists, +since each of those closures is a finite set and a complex curve is +uncountable. Put \(\Gamma=\pi_1(T^\circ,t)\). By +\eqref{eq:curve-fiber-chern}, choose finitely many +line bundles on \(F_t\) whose Chern classes span +\((\mathcal W_T)_t\). Each is represented on a dominating +reduced irreducible parameter component \(H\). The Chern class of the +universal bundle gives a section of the pullback of \(\mathcal W_T\) +to \(H^{\mathrm{an}}\): restrict its class on the total family to +fibers and use proper base change. + +Choose a closed point of the generic fiber of \(H\to T^\circ\). +Its residue field is a finite extension of the function field of +\(T\). Spreading this point, normalizing its closure, and deleting +finitely many base points gives a connected finite \'etale cover of a +dense open of \(T^\circ\), together with a morphism from that cover +to \(H\). The analytification of an +irreducible complex algebraic variety is path connected. A path in +\(H^{\mathrm{an}}\) from the original parameter point to a point of +this cover identifies the transported Chern class with the class +there. The subgroup fixing that sheet has finite index and fixes +this class. The inclusion of the further punctured curve, with the +projected path for change of basepoint, still surjects on \(\Gamma\). +The image of the finite-index sheet stabilizer is therefore finite +index in \(\Gamma\) and fixes the original class. Thus each of our +spanning classes has a finite orbit under \(\Gamma\). The intersection +of their stabilizers has finite index and acts trivially on +\((\mathcal W_T)_t\). The monodromy group \(G\) of \(\mathcal W_T\) +is therefore finite, as is that of \(\mathcal V_T\). + +Poincar\'e duality with local coefficients on the oriented curve gives +\[ + b_T=\dim(\mathcal V_T)_t{}_{\Gamma}. +\] +For a representation of the finite group \(G\) over \(\Q\), averaging +identifies coinvariants with invariants and makes invariants an exact +functor. The quotient \(q_T\) therefore supplies the asserted sections +\(\sigma_i\) with independent images. + +\emph{Step 2. Line bundles near a compact curve core.} +Take \(T^\circ\) noncompact, removing one more point if needed. +Recall the fixed choice made after \eqref{eq:branch-local-systems}: +for every prime component \(E\) of \(\Exc(g)\) dominating \(T\), +its Stein factor restricts to +\begin{equation}\label{eq:global-divisor-family} + E|_{T^\circ}\longrightarrow \widehat T_E^\circ\longrightarrow T^\circ, +\end{equation} +where the first map is a smooth proper family with connected fibers +and the second is a connected finite \'etale cover. Further finite +puncturing preserves these properties. Choose an ambient open +\(Y^\circ\subset Y\) in which \(T^\circ\) is closed: remove the +discarded points of \(T\), the other singular components, and their +intersection points. These choices will be used when we identify the +local divisors globally. + +Let \(h:g^{-1}T^\circ\to T^\circ\) be the restricted resolution. +The curve \(T^\circ\) has the homotopy type of a finite graph, so +cohomology of its local systems vanishes in degrees at least two. +The Leray spectral sequence for \(h\) consequently makes the edge map +\[ + H^2(g^{-1}T^\circ,\Q) + \longrightarrow H^0(T^\circ,\mathcal W_T) +\] +surjective. Choose lifts of the \(\sigma_i\). The algebraic space +\(g^{-1}T^\circ\) has finite triangulation type; after multiplying +each lift by a positive integer, it comes from a class +\(\alpha_i\in H^2(g^{-1}T^\circ,\Z)\). Replace \(\sigma_i\) by the +same multiple. Their images are still independent. + +To extend the \(\alpha_i\) simultaneously while retaining every loop +of \(T^\circ\), choose a compact curve core as follows. In the smooth +compactification of \(T^\circ\), remove small open +coordinate discs about its punctures, with disjoint closures, and denote the complement by +\(K_*\). This is a connected compact semianalytic subset of +\(T^\circ\). The inclusion of its interior into \(T^\circ\) induces +a surjection on fundamental groups. The core \(K_*\) is also Runge: every component of +\(T^\circ\setminus K_*\) runs to a missing puncture and is therefore +not relatively compact. The compact set \(g^{-1}K_*\) is +semianalytic. Continuity of cohomology on neighborhoods of this +compact set extends the restrictions of the finitely many +\(\alpha_i\) to integral classes on one open neighborhood +\(\widetilde U_0\) of \(g^{-1}K_*\) in \(\widetilde Y\). +One may use \v{C}ech cohomology for this continuity statement; +semianalytic triangulation and local contractibility identify it with +singular cohomology here. Properness of \(g\) makes +\[ + U_0=Y\setminus g(\widetilde Y\setminus\widetilde U_0) +\] +an open neighborhood of \(K_*\) with \(g^{-1}U_0\subset\widetilde U_0\). + +The closed curve \(T^\circ\subset Y^\circ\) is Stein. Siu's +Stein-neighborhood theorem, in the form +\cite[Theorem~2.1]{ForstnericStein} with empty compact set, gives a +Stein neighborhood \(\Omega\) of this curve in \(Y^\circ\). +The Runge property makes \(K_*\) holomorphically convex in +\(T^\circ\), hence also in \(\Omega\) by the paragraph preceding +that theorem. The usual holomorphic-polyhedron construction for a +convex compact in a Stein space gives a Stein neighborhood +\[ + K_*\subset U\Subset\Omega\cap U_0. +\] +Take its connected component containing \(K_*\). It is normal, +being open in \(Y\), and therefore irreducible. For the local +\(\Q\)-factorialization, Fujino's compact construction +\cite[Section~1.11]{FujinoAnalyticMMP} supplies an ambient semianalytic +Stein compact \(K'\Subset U\), with +\(K_*\subset\operatorname{int}_U(K')\), such that +\[ + K'\cap Z\ \text{has finitely many connected components} +\] +for every analytic subset \(Z\) defined on a neighborhood of +\(K'\). This is the compact condition (P4) in Fujino's condition +(P); normality of the source and Steinness of the base supply its +other ambient conditions. + +The classes just extended to \(g^{-1}U\) are Chern classes of line +bundles \(L_1,\ldots,L_{b_T}\) there, by the same rational-singularity, +Cartan, and exponential-sequence argument used above. For every +\(t\) in the interior of \(K_*\), their fiber classes are the +\(\sigma_i(t)\); hence their images under \(q_T\) remain independent. +We also need divisor representatives before making any further +modification. The sheaf \(g_*L_i\) is coherent and has rank one on +the regular open of \(U\). Cartan's Theorem~A supplies a global +section nonzero at a point of that open. Its pullback is a nonzero +section of \(L_i\), whose zero divisor is a Cartier divisor \(A_i\) +on \(g^{-1}U\) representing \(L_i\). + +\emph{Step 3. Fiber degrees and surface families.} +We will obtain at least \(b_T\) surface families by proving that the +\(b_T\) line bundles constructed below have linearly independent vectors +of fiber degrees. +Apply Fujino's small \(\Q\)-factorialization theorem +\cite[Theorem~1.24]{FujinoAnalyticMMP} to the ordinary pair +\((U,0)\), the identity \(U\to U\), and the full compact \(K'\). +The identity is projective, \(U\) is terminal and therefore klt, +and \(K_U\) is \(\Q\)-Cartier. The preceding construction supplies +condition (P). After restricting the base to a neighborhood of +\(K'\), the theorem gives a projective small bimeromorphic morphism +\[ + \ell:Y'\longrightarrow U +\] +with \(Y'\) normal and \(\Q\)-factorial over \(K'\). We retain the +notation \(U\) after this restriction and restrict \(g,L_i,A_i\) +accordingly. Compactness and local terminality of \(Y\) give a common +\(m_{\mathrm{can}}>0\) for which \(\omega_Y^{[m_{\mathrm{can}}]}\) is +invertible; its restriction to \(U\) is +\(\omega_U^{[m_{\mathrm{can}}]}\). Since \(\ell\) is +small, the natural identification on the common codimension-one open +extends by reflexivity to +\[ + \omega_{Y'}^{[m_{\mathrm{can}}]} + \simeq\ell^*\omega_U^{[m_{\mathrm{can}}]}. +\] +In particular, the left side is invertible and the natural relative +canonical divisor \(K_{Y'/U}\) is zero. This is canonical crepancy, +expressed using compatible local canonical generators as +\(K_{Y'}=\ell^*K_U\). A place exceptional over \(Y'\) is exceptional +over \(U\), because \(\ell\) is small. Crepancy therefore preserves +the terminal discrepancy inequalities, so \(Y'\) is terminal. Moreover \(\ell\) +is an isomorphism over \(U_{\mathrm{reg}}\). Indeed, for a relatively +ample line bundle \(\mathcal A\) on \(Y'\), the rank-one reflexive +sheaf \((\ell_*\mathcal A)^{**}\) is locally invertible on the smooth +base. Its pullback agrees with \(\mathcal A\) off codimension two +and hence everywhere there, by reflexivity on the normal source. +A positive-dimensional fiber over a smooth point would then have +degree zero against \(\mathcal A\), contradicting relative ampleness. + +Push \(A_i\) forward to a Weil divisor on \(U\), and let \(D_i'\) be +its strict transform on \(Y'\). These are actual locally finite +analytic divisors defined on all of the current \(Y'\). We apply +\(\Q\)-factoriality precisely in the sense of +\cite[Definition~2.38]{FujinoAnalyticMMP}: every prime divisor +defined on a neighborhood of the whole set \(\ell^{-1}(K')\) +is \(\Q\)-Cartier at each point of that set. Properness makes +\(\ell^{-1}(K')\) compact, and local finiteness leaves only finitely +many prime components of the \(D_i'\) near it. A finite cover of +this full compact and a common multiple therefore give an integer +\(m_{\mathrm{div}}>0\) and an open neighborhood of \(\ell^{-1}(K')\) +on which every \(m_{\mathrm{div}}D_i'\) is Cartier. By properness, +choose an open set \(U_1\) with \(K'\subset U_1\subset U\) whose full +inverse image is contained in that neighborhood, and put +\[ + \mathcal N_i=\mathcal O_{Y'}(m_{\mathrm{div}}D_i')|_{\ell^{-1}U_1}. +\] +This completes the use of \(\Q\)-factoriality on the specified full +compact; all later restrictions use these fixed line bundles. +In particular, the change-of-compact issue in +\cite[Remark~2.39]{FujinoAnalyticMMP} does not arise. On the +regular open, where both \(g\) and \(\ell\) are isomorphisms, +\begin{equation}\label{eq:curve-regular-bundles} + \mathcal N_i|_{U_{1,\mathrm{reg}}} + \simeq L_i^{\otimes m_{\mathrm{div}}}|_{U_{1,\mathrm{reg}}}. +\end{equation} + +Choose connected curve domains +\[ + B_0\Subset B_1\Subset\operatorname{int}_{T^\circ}(K_*) +\] +such that \(\pi_1(B_0)\to\pi_1(T^\circ)\) is surjective; nested +smaller cores obtained by enlarging the omitted discs have this +property. The larger domain lets us control finitely many components +near \(\overline B_0\) and make their discrete exceptional sets finite +on that compact. Work in the ambient open of \(U_1\) obtained by removing +\(T^\circ\setminus B_1\), so that \(B_1\) is closed there. +The inverse image of \(B_1\) is proper over \(B_1\). +Local finiteness of its analytic components, compactness of +\(\ell^{-1}(\overline B_0)\), and properness allow us first to +replace \(B_1\) by a neighborhood of \(\overline B_0\) on whose +inverse image only finitely many components occur. + +We claim that deleting finitely many points from \(B_0\) gives a +connected curve domain \(B\) with +\(\pi_1(B)\to\pi_1(T^\circ)\) surjective and the following fiber +description. All fibers of \(\ell\) over \(B\) have dimension at +most one. The finitely many irreducible surface components +\(S_1,\ldots,S_s\) of the reduced inverse image of \(B\), counted +after this restriction, all dominate \(B\). Their normalizations +factor as +\[ + \widehat S_\alpha\xrightarrow{\,h_\alpha\,}C_\alpha + \longrightarrow B \qquad (1\le\alpha\le s), +\] +where \(C_\alpha\to B\) is a connected finite \'etale cover and +\(h_\alpha\) is a smooth proper family of connected curves. A cover +that splits on restriction contributes separate components to this +list. For each fixed \(t\in B\), the pairs \((\alpha,c)\) with +\(c\in C_\alpha\) over \(t\) supply distinct irreducible curves and +exhaust the irreducible curves of \(\ell^{-1}(t)\). Each smooth +connected normalization fiber maps birationally to the curve it +supplies. + +We verify this description by spelling out the finite exclusions. +Smallness gives \(\dim\Exc(\ell)\le2\), so a general fiber above +\(B_1\) has dimension at most one. The locus of larger fibers is a +proper analytic subset of \(B_1\), by the fiber-dimension theorem +for proper maps. For each surface component of the reduced inverse +image that dominates \(B_1\), take its normalization and then its Stein factor over the +curve. The normalization is proper and is a normal surface. +Its singularities are isolated. Away from the branch values of the +finite Stein factor and the critical values of the map from the +normalization, it is a smooth proper family of connected curves +over a finite unramified cover. The values at which an intersection +of two components, or the nonisomorphism locus of a normalization, +contains a whole fiber curve also form a discrete analytic subset: +these loci have dimension at most one, and their general fibers +over the base are zero-dimensional. Finally remove the images of +components lying over a point. Each of these excluded sets is +discrete on the larger curve domain \(B_1\); there are only finitely +many components, so their union meets \(\overline B_0\) in a finite +set. + +Delete those finitely many points from \(B_0\) and call the result +\(B\). It is connected, and +\(\pi_1(B)\to\pi_1(T^\circ)\) is still surjective: loops in \(B_0\) +may be perturbed away from a finite set. The exclusions give the +asserted fiber description and families. + +For each \(\alpha,i\), let +\[ + d_{\alpha i} + =\deg\bigl(\mathcal N_i|_{h_\alpha^{-1}(c)}\bigr), + \qquad c\in C_\alpha, +\] +where pullback to \(\widehat S_\alpha\) is understood. This integer +is independent of \(c\), by constancy of degree in a smooth proper +family over the connected curve \(C_\alpha\). Because its fiber +maps birationally to the curve it supplies, this is also the degree +of \(\mathcal N_i\) on that fiber curve of \(\ell\). +We claim that the map +\begin{equation}\label{eq:curve-degree-map} + \Q^{b_T}\longrightarrow\Q^s,\qquad + (c_i)_i\longmapsto + \left(\sum_i c_i d_{\alpha i}\right)_\alpha +\end{equation} +is injective. + +Suppose its value is zero, and fix \(t\in B\). Every irreducible +curve in \(F'_t=\ell^{-1}(t)\) then has degree zero against +\(\sum_i c_i c_1(\mathcal N_i)\). The fiber has dimension at most +one. Its rational \(H_2\) is spanned by the fundamental classes of +its irreducible curves, also when the fiber is nonreduced, and +\(H^2(F'_t,\Q)\) is the rational dual of \(H_2(F'_t,\Q)\). +The restricted Chern class is therefore zero. Proper base change +identifies it with the germ in \((R^2\ell_*\Q)_t\). +Restriction through the isomorphism over the regular open gives +the natural map +\[ + (R^2\ell_*\Q)_t\longrightarrow (R^2j_*\Q)_t + =(\mathcal V_T)_t, +\] +so the corresponding punctured class is zero as well. By +\eqref{eq:curve-regular-bundles}, the restrictions of +\(\sum_i c_i c_1(\mathcal N_i)\) and +\(m_{\mathrm{div}}\sum_i c_i c_1(L_i)\) agree on their common regular +open. Taking their germ in \((R^2j_*\Q)_t\) and applying +\eqref{eq:branch-link-stalk-map} to the latter identifies that zero +class with +\[ + m_{\mathrm{div}}\sum_i c_i\,q_T(\sigma_i(t)). +\] +These vectors are independent; hence every \(c_i=0\). This proves +\eqref{eq:curve-degree-map}, and in particular +\begin{equation}\label{eq:curve-surface-count} + s\ge b_T. +\end{equation} + +\emph{Step 4. Distinct global discrepancy-two divisors.} +Take an ambient open \(U_B\subset U_1\) whose intersection with +\(T^\circ\) is the closed subspace \(B\), obtained as above by +removing \(T^\circ\setminus B\). Each \(S_\alpha\) is a closed +analytic surface in \(\ell^{-1}U_B\). Since \(Y'\) is terminal, +it is smooth in codimension two by +\cite[Lemma~2.3]{CanonicalKahler}. Thus at a general point of +\(S_\alpha\) both the ambient space and the surface are smooth. +Blow up its coherent ideal and normalize. The unique divisor +dominating that dense smooth part defines a local place \(v_\alpha\) +of ordinary log discrepancy \(2\) over \(Y'\), the value for a +smooth codimension-two blowup. Canonical crepancy of \(\ell\) +gives +\[ + a(v_\alpha;U_B,0)=2,\qquad + \cent_{U_B}(v_\alpha)=B. +\] +The \(v_\alpha\) are distinct because their centers on \(Y'\) are +the distinct \(S_\alpha\). + +It remains to represent each \(v_\alpha\) by a prime divisor on +\(g^{-1}U_B\) and show that these local divisors arise from distinct +global components of \(\Exc(g)\). + +On the fixed global resolution, the relative canonical divisor is +intrinsic even if the canonical bundle has no global divisor +representative. Using the fixed \(m_{\mathrm{can}}\), divide by +\(m_{\mathrm{can}}\) the divisor of the +natural meromorphic comparison +\(g^*\omega_Y^{[m_{\mathrm{can}}]}\dashrightarrow +\omega_{\widetilde Y}^{\otimes m_{\mathrm{can}}}\), and denote the +result by \(K_{\widetilde Y/Y}\). It is exceptional; write +\[ + K_{\widetilde Y/Y}=\sum_E\kappa_EE. +\] +The natural canonical comparisons commute with restriction and +composition, so this divisor supplies the relative discrepancy term +on \(U_B\) as well. +Every \(\kappa_E\) is strictly positive by terminality. The +principalization of the ideal of \(\Sing Y\) says that +\(g^{-1}(\Sing Y)\) is supported on these exceptional divisors. +Put \(\widetilde U_B=g^{-1}U_B\), and consider \(v_\alpha\) on a +common proper model with \(\widetilde U_B\). If it were exceptional +over this smooth resolution, then \(a(v_\alpha;\widetilde U_B,0)\ge2\). +Its center on the +resolution maps into \(B\subset\Sing Y\), so it is contained in at +least one of the \(E\), with \(\ord_{v_\alpha}(E)>0\). +The discrepancy formula would give +\[ + a(v_\alpha;U_B,0) + =a(v_\alpha;\widetilde U_B,0) + +\sum_E\kappa_E\ord_{v_\alpha}(E)>2, +\] +a contradiction. Thus \(v_\alpha\) is represented by a prime +divisor on \(g^{-1}U_B\). Since \(U_B\cap T=B\), this local divisor +is an irreducible component of \(E|_B\) for a global exceptional +divisor \(E\) with \(g(E)=T\). + +Such a global divisor cannot split into two components over \(B\). +Indeed the connected finite cover \(\widehat T_E^\circ\to T^\circ\) in +\eqref{eq:global-divisor-family} remains connected over \(B\): +the action of \(\pi_1(T^\circ)\) on a fiber is transitive, and +\(\pi_1(B)\) has the same image. Over this connected cover the +restriction of \(E\) is a smooth proper family with connected +fibers, so its total space is connected and smooth, hence +irreducible. Therefore the distinct local divisors representing +the \(v_\alpha\) come from distinct global components \(E\) of +\(\Exc(g)\). Their global centers are \(T\), and their ordinary +log discrepancies are \(2\), since this equality holds on the +open over \(B\). Together with \eqref{eq:curve-surface-count}, +this proves the proposition. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:branch}] +Every global place of ordinary log discrepancy \(2\) whose center +is a singular curve is represented by a component of \(\Exc(g)\). +Indeed the same discrepancy computation in the last part of +Proposition~\ref{prop:curve-places} would otherwise make its +discrepancy strictly greater than \(2\). There are only finitely +many such components on the compact resolution, so +\(\tau_Y(Q)\) is finite. Proposition~\ref{prop:curve-places}, +summed over the singular curves contained in \(Q\), gives +\[ + \sum_{T\subset\Sing Y\cap Q} b_T\le\tau_Y(Q). +\] +Combining this with \eqref{eq:branch-topological-bound} yields +\[ + \beta(Q)\le \sum_j c_2(Q_j^\nu)+\tau_Y(Q), +\] +as required. +\end{proof} diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/07-difficulty.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/07-difficulty.tex new file mode 100644 index 0000000000000000000000000000000000000000..dcbfd81e4b8c4ce8570d6ca8054cc9f3dac60427 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/07-difficulty.tex @@ -0,0 +1,559 @@ +\section{The difficulty on the terminal chain}\label{sec:difficulty} + +We now construct an integer that is nonnegative at the crepant terminal +junctions and nonincreasing along the moves between them. The local +subtraction of surface contributions and the correction by cycle ranks on +boundary normalizations adapt the projective construction in +\cite[Definition~4.2, Lemma~4.3, and Section~7]{ProjectiveLCFourfolds}. +We give the required finiteness and comparison arguments in the analytic +setting. + +Use the terminal chain of Proposition~\ref{prop:terminal-junctions}, after +the truncation in Proposition~\ref{prop:surface-finiteness}. Its finite set +of prime labels is denoted by \(\mathcal H\). On a current model its +boundary is +\[ + \Theta=\sum_{h\in\mathcal H}b_hS_h,\qquad 0\leq b_h<1. +\] +The labels persist by strict transform, including those of coefficient +zero, and the coefficients are nonincreasing. The fixed coefficients have +already become constant. Every varying coefficient is positive; at a +junction \(h_i:Y_i\to X_i\), its label is exceptional for \(h_i\) and has +image of dimension at most one. Each model of the chain is strong and +compact K\"ahler, the generalized pair is terminal, and the underlying +fourfold is ordinarily terminal. + +Choose a positive integer \(N\) that clears the fixed label coefficients, +the coefficients of the initial boundary of the particular strong +generalized klt sequence under study, and its fixed nef datum: on the chosen +higher carrier, \(N\M\) is represented by an integral Cartier divisor. +These are finite rational data. We impose no denominator condition on a +varying coefficient. For \(u\in\R\), put +\begin{equation}\label{eq:difficulty-weights} + \omega(u)=\left\lceil N\max\{u,0\}\right\rceil, + \qquad + w(E)=\omega\bigl(2-a(E;Y,\Theta+\M)\bigr), +\end{equation} +where \(E\) is a global divisorial place and the current pair is understood +in \(w(E)\). Thus \(w(E)>0\) exactly when the discrepancy is less than +two; discrepancy equal to two has weight zero. + +For a fixed label, \(\omega(b_h)=Nb_h\), so its contribution incurs no +rounding loss in the local estimate below. The conditions on the initial +boundary and nef carrier will give the lattice at the positive endpoint in +Lemma~\ref{lem:positive-surface}. The earlier surface lattice has already +served to choose the tail; \(N\) need not clear every element of +\(\mathcal A_{\mathrm{surf}}\). + +\subsection{Echoes and finite local corrections} + +The recurring places over a generic codimension-two boundary center are +the echoes of \cite[Example~1.4, Lemma~1.5, and Definition~2.3]{AlexeevHaconKawamata2007}. +The full chain matters: \cite[Example~2.1]{Fujino2005Addendum} shows why +removing only the first blowup does not make a boundary difficulty finite. + +First consider an irreducible compact analytic surface \(V\subset S_h\) +whose general point lies in a smooth open of \(Y\) where \(S_h\) is smooth, +no other label occurs, and \(\M\) descends. The following sequence of +global places records the predictable contribution above such a surface. +Blow up the coherent ideal of \(V\) globally and normalize. The global +exceptional divisor has a unique irreducible component dominating the dense +smooth open of \(V\); call its place \(E_{V,h,1}\). On this normalized +blowup, its analytic intersection with the strict transform of \(S_h\) +has a unique irreducible component dominating that same open of \(V\). +Blow up the coherent ideal of this global component, normalize, and take +the unique new exceptional prime over that open. Repeat this operation on +these normalized blowups, denoting the successive places by +\(E_{V,h,j}\), \(j\geq1\). The models are smooth at the general points +of the indicated intersections, so each next component exists and is +unique there. When another higher model is needed for comparison, a common +proper model identifies these same global places by strict transform. We +call them the \emph{echoes} of \(S_h\) above \(V\). + +The first exceptional prime has crepant boundary coefficient +\(-(1-b_h)\). At stage \(j\) this coefficient is \(-j(1-b_h)\): blowing +up its intersection with the strict label adds one more \(-(1-b_h)\). +Consequently +\begin{equation}\label{eq:echo-discrepancy} + a(E_{V,h,j};Y,\Theta+\M)=1+j(1-b_h). +\end{equation} +The contributing echoes are precisely those with \(j(1-b_h)<1\). In +particular there are only finitely many contributing indices for each +\(b_h<1\). Define the \emph{default contribution} of label \(h\) by the finite sum +\begin{equation}\label{eq:echo-default} + d_h=\sum_{j\geq1}\omega\bigl(1-j(1-b_h)\bigr). +\end{equation} +Here terms outside the finite set just described are zero. If \(b_h=0\), +then \(d_h=0\). If \(b_h>0\), its first term gives +\(d_h\geq\omega(b_h)\geq1\). Each summand is nonincreasing as \(b_h\) +decreases, and no new positive index can appear. Hence every \(d_h\) is a +nonincreasing nonnegative integer along the chain. After discarding +finitely many further junctions, all \(d_h\) are constant, including +throughout each intervening finite string of moves. Indeed each of the +finitely many integers can drop only finitely often, while coefficients +stay unchanged during the small steps. We henceforth use this truncated +chain and these constant values \(d_h\). + +On a fixed model, the generic echo contribution is the only contribution +that can recur over infinitely many surface centers. We now justify this +claim. All places in the following proposition are +global divisorial places. + +\begin{proposition}[Finiteness below discrepancy two] +\label{prop:difficulty-finite} +Let \((Y,\Theta+\M)\) be a model of the truncated terminal chain. +Among the places exceptional over \(Y\) with discrepancy less than two, +there are only finitely many whose centers have codimension at least three. +For each fixed irreducible compact analytic surface \(V\subset Y\), there +are only finitely many whose center is \(V\). + +There is a finite set \(\mathcal V_Y\) of irreducible compact analytic +surfaces with the following additional property. If +\(V\notin\mathcal V_Y\), its general point lies in a smooth open where +\(\M\) descends and either no label occurs or exactly one smooth label +\(S_h\) occurs. There are no positive-weight places centered on \(V\) +in the first case or when \(b_h=0\). When \(b_h>0\), they are exactly the +echoes \(E_{V,h,j}\) with \(j(1-b_h)<1\). +\end{proposition} + +\begin{proof} +Take a projective resolution \(\pi:W\to Y\) with \(W\) smooth and carrying \(\M\), +with divisorial exceptional locus, and resolving all labels. Further +blowups of intersections in the simple normal crossing divisor make the +strict transforms of the labels smooth and pairwise disjoint, while keeping +the full divisor simple normal crossing. Write +\[ + K_W+\Theta_W+M_W=\pi^*(K_Y+\Theta+M_Y). +\] +Every \(\pi\)-exceptional component of \(\Theta_W\) has coefficient +\(1-a(E;Y,\Theta+\M)<0\), by generalized terminality. The only possible +positive components of \(\Theta_W\) are therefore the strict transforms +of the positive labels. On higher models the nef datum pulls back from \(W\), so the +discrepancy calculation is the ordinary one for the signed boundary +\(\Theta_W\). + +Consider a place \(E\) that is also exceptional over \(W\), and let its +center on \(W\) have codimension \(c\geq2\). At a general smooth point +of this center choose normal parameters \(x_1,\ldots,x_c\). The Jacobian +formula on a smooth model carrying \(E\) gives +\[ + a(E;W,0)\geq\sum_{i=1}^c\ord_E(x_i), + \qquad \ord_E(x_i)\geq1. +\] +Indeed, in the pullback of a local volume form at most one differential +factor can lose one order along \(E\); adding one to the Jacobian order +gives the displayed bound. If the center lies in no positive component of +\(\Theta_W\), the signed boundary can only raise this discrepancy, which +is at least two. Otherwise it lies in a unique positive smooth label of +coefficient \(b<1\). Taking \(x_1\) as its local equation and discarding +the negative boundary terms gives +\begin{equation}\label{eq:local-discrepancy-estimate} + a(E;Y,\Theta+\M) + \geq (1-b)\ord_E(x_1)+\sum_{i=2}^c\ord_E(x_i). +\end{equation} +A discrepancy less than two thus forces \(c=2\) and containment in a +positive label. A label of coefficient zero cannot give such a place. + +If this codimension-two center is contained in \(\Exc(\pi)\), it is a +component of the intersection of its label with one of the finitely many +exceptional divisors. There are only finitely many such centers. If it +meets the isomorphism open, its general point maps isomorphically to a +surface downstairs, and the center is the strict transform of that surface. +Thus a center mapping to codimension at least three belongs to the first +finite list, and for any fixed surface downstairs there are only finitely +many possible centers on \(W\). + +There are only finitely many places of discrepancy less than two whose +center on \(W\) equals a fixed one of these codimension-two centers. To see this, discard the negative +components of \(\Theta_W\); this lowers discrepancies, so it suffices to +work with the single smooth label of coefficient \(b\). Blow up the center +generically. The new exceptional coefficient is \(-(1-b)\). A further +place with discrepancy less than two has its center in that exceptional +divisor; the estimate \eqref{eq:local-discrepancy-estimate} also forces a +codimension-two center in the strict label. It must therefore follow their +intersection above the general point of the original center. At stage +\(j\) the most recent exceptional coefficient is \(-j(1-b)\), and the +older exceptional divisors do not meet this generic intersection. A place +above it that is still exceptional has discrepancy at least +\[ + (1-b)+1+j(1-b)=1+(j+1)(1-b). +\] +This reaches two after finitely many stages. The same argument shows that, +where no other boundary or nef data enter, the places below two are exactly +the echoes in \eqref{eq:echo-discrepancy}. + +This generic computation identifies global places. At each global blowup +there is a unique irreducible component of its exceptional divisor that +dominates the dense smooth part of the center. The global analytic +intersection of that prime with the strict label then has a unique +irreducible component dominating the same part. These global components +have coherent ideals, which define the next global blowups. Conversely, +one can follow any given global place on common higher models through these +blowups; when its center becomes a divisor on a normal model, that divisor +represents the place. Thus the computation does not count different local +pieces of one place separately. + +Finally include the finitely many divisors on \(W\) that are exceptional +over \(Y\). The complement of the isomorphism open, and the loci where a +label fails to be smooth and alone or the nef datum fails to descend, are +contained in a proper analytic subset of \(Y\) of codimension at least +two. Such a subset has only finitely many surface components on the compact +fourfold. Take these components for \(\mathcal V_Y\), enlarging the set +by the finitely many surface images already encountered if necessary. +Outside them the preceding one-label calculation applies, or there is no +positive label and no place of positive weight. This proves all assertions. +\end{proof} + +For an irreducible compact analytic surface \(V\subset Y\), let +\begin{equation}\label{eq:difficulty-branches} + r_{V,h}=\#\{D:\ D\text{ is a prime divisor of }S_h^\nu + \text{ mapping onto }V\}. +\end{equation} +This number is finite, because normalization is finite and the inverse +image of \(V\) has finitely many components on the compact normalization. +It is zero if \(V\not\subset S_h\). It counts prime divisors on the +normalization, without counting their possible multiple sheets over \(V\) +as separate divisors. + +Every place with center a surface, curve, or point on the normal fourfold +is exceptional over it: a place with a divisor as center is represented by +that divisor. Hence the two raw sums below involve only exceptional +places. Proposition~\ref{prop:difficulty-finite} makes the local sum +\(\sum_{\cent_Y(E)=V}w(E)\) finite after zero terms are omitted. Although +this raw sum is finite at each fixed surface, the same nonzero contribution +\(d_h\) can recur at infinitely many surfaces in a label. We therefore +subtract the branch contributions at each surface before summing over +surfaces. Define the integer +\begin{equation}\label{eq:difficulty-bracket} + q_Y(V)=\sum_{\cent_Y(E)=V}w(E)-\sum_{h\in\mathcal H}r_{V,h}d_h. +\end{equation} +Only finitely many \(q_Y(V)\) are nonzero. Indeed, outside the finite set +in Proposition~\ref{prop:difficulty-finite}, a surface on a positive label +has raw sum \(d_h\), with \(r_{V,h}=1\) and all other branch counts zero. +A surface generically on a sole zero-coefficient label has both raw sum and +default zero, as does a surface away from all labels. These cases exhaust +the surfaces outside that finite set. + +We may therefore define the difficulty by +\begin{equation}\label{eq:difficulty} + \begin{aligned} + \mathfrak D(Y,\Theta+\M) + ={}&\sum_{\codim_Y\cent_Y(E)\geq3}w(E) + +\sum_{\substack{V\subset Y\\\dim V=2}}q_Y(V)\\ + &+\sum_{h\in\mathcal H}d_hc_2(S_h^\nu), + \end{aligned} +\end{equation} +where the surface sum is over irreducible compact analytic surfaces. +The first sum has finitely many nonzero terms by +Proposition~\ref{prop:difficulty-finite}; the second has just been shown +to have finite support; and the last is finite because \(\mathcal H\) is +finite and every analytic cycle rank is finite. Thus \(\mathfrak D\) is +an integer. The subtraction in \eqref{eq:difficulty-bracket} is performed +at each surface before the second sum is taken. Both a local bracket and +the difficulty on an intermediate model are at this point allowed to be +negative. + +\subsection{The lower bound at the junctions} + +The possible negative part of a surface bracket comes only from rounding +the contributions of varying labels. For a surface \(V\), put +\[ + r_V^{\mathrm{var}}=\sum_{h\text{ varying}}r_{V,h}. +\] +We first prove, on every current terminal model, that +\begin{equation}\label{eq:difficulty-local-bound} + q_Y(V)\geq-\max\{r_V^{\mathrm{var}}-1,0\}. +\end{equation} + +The underlying fourfold is ordinarily terminal by +Lemma~\ref{lem:ordinary-singularities}, hence smooth at general points of +\(V\). Blow up \(V\) generically to obtain a global exceptional +place \(E_V\). For each label let \(m_h\) be its multiplicity transverse +to \(V\) at a general point, taking \(m_h=0\) if it does not contain +\(V\). The ordinary log discrepancy of \(E_V\) is two. On a common +carrier \(\pi:W\to Y\) carrying this place, the nef defect +\(J=\pi^*M_Y-M_W\) is effective by Lemma~\ref{lem:nef-defect}. If \(j_V\) is its coefficient at +\(E_V\), the discrepancy formula and generalized terminality give +\begin{equation}\label{eq:difficulty-first-blowup} + a(E_V;Y,\Theta+\M)=2-\sum_hm_hb_h-j_V>1, + \qquad j_V\geq0. +\end{equation} +In particular \(\sum_hm_hb_h<1\). + +We also have \(r_{V,h}\leq m_h\). To see this analytically, work at a +general smooth point of \(V\). Each prime divisor of \(S_h^\nu\) counted +by \(r_{V,h}\) gives at least one point of the finite normalization over +that point of \(V\); the points supplied by distinct prime divisors can be +taken distinct after avoiding their special loci. They correspond to +distinct local analytic branches of \(S_h\), each containing the germ of +\(V\). Each branch contributes at least one to the transverse multiplicity +\(m_h\). A normalization divisor with several sheets may supply more +than one local branch, which preserves the stated inequality. + +Let \(t=r_V^{\mathrm{var}}\), and list the numbers \(Nb_h\) for varying +labels, repeating each one \(r_{V,h}\) times, as +\(x_1,\ldots,x_t\). The fixed contribution +\(k=N\sum_{h\text{ fixed}}r_{V,h}b_h\) is a nonnegative integer. For +\(t\geq1\), the ceiling inequality gives +\[ + \left\lceil k+\sum_{\ell=1}^t x_\ell\right\rceil + \geq k+\sum_{\ell=1}^t\lceil x_\ell\rceil-(t-1). +\] +For \(t=0\) the left side is \(k\). Using effectivity, +\(m_h\geq r_{V,h}\), and \eqref{eq:difficulty-first-blowup}, we obtain in +both cases +\begin{equation}\label{eq:difficulty-first-weight} + w(E_V)\geq\sum_h r_{V,h}\omega(b_h) + -\max\{r_V^{\mathrm{var}}-1,0\}. +\end{equation} +No rounding loss is needed for a fixed label because \(Nb_h\) is integral. + +It remains to supply the terms of \(d_h\) with \(j\geq2\). Such a term +is positive only if \(b_h>1/2\); when \(b_h=1/2\), the second echo has +discrepancy exactly two and weight zero. The strict inequality +\(\sum_hm_hb_h<1\) implies that at most one label through \(V\) has +coefficient greater than \(1/2\), and its multiplicity is one. This label +is smooth at general points of \(V\) and has \(r_{V,h}=1\). Use its +successive generic blowups above \(V\). For each \(j\geq2\) with a +positive default, the resulting global place is distinct from \(E_V\) and +from all the others. With this label alone its discrepancy is +\(1+j(1-b_h)\). The other effective boundary components and the effective +nef defect only lower the discrepancy. Its actual weight is therefore at +least \(\omega(1-j(1-b_h))\). These places supply every remaining +default. Adding their weights to \eqref{eq:difficulty-first-weight} +proves \eqref{eq:difficulty-local-bound}, including the cases with no +varying label or with zero coefficients. + +\begin{proposition}[Lower bound at crepant junctions] +\label{prop:difficulty-lower} +At every crepant junction \(h_i:(Y_i,\Theta_i+\M)\to(X_i,B_i+\M)\) of +the truncated chain, +\[ + \mathfrak D(Y_i,\Theta_i+\M)\geq0. +\] +\end{proposition} + +\begin{proof} +Write \(Y=Y_i\) and let +\(Q=\bigcup_{h\text{ varying}}S_h\) with its reduced structure. If +\(Q\) is empty, \eqref{eq:difficulty-local-bound} makes every surface +bracket nonnegative, and the other terms of \eqref{eq:difficulty} are +nonnegative. Suppose \(Q\ne\varnothing\). At this junction the map +\(h_i\) is projective bimeromorphic from an ordinarily terminal compact +K\"ahler fourfold, and \(\dim h_i(Q)\leq1\) by +Proposition~\ref{prop:surface-finiteness}. Thus Theorem~\ref{thm:branch} +applies. For a surface \(V\subset Q\), its branch count in that theorem +is \(r_V(Q)=r_V^{\mathrm{var}}\geq1\); the last inequality follows from +the finite surjective normalizations. Surfaces outside \(Q\) have +\(r_V^{\mathrm{var}}=0\). The total possible deficit in +\eqref{eq:difficulty-local-bound} is consequently \(\beta(Q)\). + +Every varying label has \(d_h\geq1\). The places counted by +\(\tau_Y(Q)\) in Theorem~\ref{thm:branch} also each supply a weight of at +least one in the first sum of \eqref{eq:difficulty}. In fact such a place +\(E\) has ordinary log discrepancy two and center a singular curve in +\(Q\). It is exceptional over \(Y\). Its center is contained in a +varying label of positive coefficient, and that effective label is +\(\Q\)-Cartier on the strong model. Its order at \(E\) is therefore +strictly positive. On a common carrier the discrepancy formula reads +\[ + a(E;Y,\Theta+\M) + =2-\ord_E(\Theta)-\operatorname{coeff}_E(J)<2, + \qquad J\geq0. +\] +The count \(\tau_Y(Q)\) uses distinct global places. They occur as +distinct terms of the codimension-at-least-three sum, and none is a place +in a surface bracket. Theorem~\ref{thm:branch} now gives +\[ + \beta(Q) + \leq\sum_{h\text{ varying}}c_2(S_h^\nu)+\tau_Y(Q) + \leq\sum_{h\in\mathcal H}d_hc_2(S_h^\nu) + +\sum_{\codim_Y\cent_Y(E)\geq3}w(E). +\] +Summing \eqref{eq:difficulty-local-bound} and substituting this inequality +in \eqref{eq:difficulty} proves the assertion. The branch inequality and +this lower bound have been used only at the junctions. +\end{proof} + +\subsection{Exact change along the chain} + +For a small step, the change in the normalization cycle ranks will cancel +the change in the surface defaults. We establish this equality before +comparing the difficulties. + +\begin{lemma}[Normalization cycle ranks]\label{lem:difficulty-ranks} +Consider a small step of the terminal chain, with exceptional loci +\(L,L^+\), +\[ + Y\xrightarrow{f}Z\xleftarrow{f^+}Y^+. +\] +For each label \(h\), let \(e_h\) and \(e_h^+\) be the numbers of prime +divisors in \(S_h^\nu\) and \((S_h^+)^\nu\) lying over \(L\) and +\(L^+\), respectively. Then these numbers are finite and +\begin{equation}\label{eq:difficulty-rank-change} + \begin{gathered} + e_h=\sum_{\substack{V\subset L\\\dim V=2}}r_{V,h},\qquad + e_h^+=\sum_{\substack{V^+\subset L^+\\\dim V^+=2}}r_{V^+,h}^+,\\ + c_2(S_h^\nu)-c_2((S_h^+)^\nu)=e_h-e_h^+. + \end{gathered} +\end{equation} +The surface sums run over irreducible compact analytic surfaces. +\end{lemma} + +\begin{proof} +Let \(T_h\) be the normalization of the common image of the two labels in +\(Z\). Restricting the projective maps, composing with finite +normalization, and factoring through \(T_h\) gives projective +bimeromorphic maps of normal compact threefolds +\[ + S_h^\nu\longrightarrow T_h\longleftarrow (S_h^+)^\nu. +\] +They identify over the common isomorphism open. By +Lemma~\ref{lem:small-comparison}, the common exceptional image +\(A=f(L)=f^+(L^+)\) has dimension at most one. A normalization divisor +lying over \(L\) has a surface as its image in \(S_h\), because +normalization is finite, and its image in \(T_h\) lies over \(A\). +It is therefore contracted by the displayed map. Conversely, the map is +an isomorphism off the preimage of \(A\), so every contracted prime divisor +lies over \(L\). These are exactly the primes counted in the first sum +in \eqref{eq:difficulty-rank-change}. The same reasoning holds on the +positive side. The exceptional loci have finitely many surface components, +which also proves finiteness. + +We use the following independence fact. For a projective bimeromorphic +map \(g:S\to T\) of normal compact threefolds, the classes in +\(H_4(S,\Q)\) of the prime divisors contracted by \(g\) are linearly +independent. Take a resolution \(r:\widetilde S\to S\) that is projective, +has smooth source, and is an isomorphism over \(U=S_{\mathrm{reg}}\). Put +\(R=r^{-1}(S\setminus U)\). Normality gives \(\dim(S\setminus U)\leq1\), +and \(\dim R\leq2\). If a rational combination of the contracted divisor +classes vanished on \(S\), the corresponding combination of strict +transforms would restrict to zero in \(H_4^{\BM}(U,\Q)\). The localization +sequence +\[ + H_4(R,\Q)\longrightarrow H_4(\widetilde S,\Q) + \longrightarrow H_4^{\BM}(U,\Q) +\] +then shows that its class is a rational combination of the classes of the +surface components of \(R\); those classes span \(H_4(R,\Q)\). Subtract +that combination. We obtain a homologically trivial rational Cartier +divisor on \(\widetilde S\), all of whose components are exceptional over +\(T\). For the components of \(R\), this follows since their images in +\(S\), hence in \(T\), have dimension at most one. On the smooth compact +resolution, homological triviality makes this divisor numerically trivial +on every curve by the ordinary class pairing. Analytic negativity in both +signs, in the form of \cite[Lemma~2.2]{CanonicalKahler}, makes the +divisor zero. The strict transforms of the original divisors are distinct +from the resolution-exceptional ones, so all original coefficients vanish. +This proves independence without any factoriality assumption on \(S\). + +For either label normalization, restrict its span of compact analytic +surface classes to the common open over \(T_h\setminus\nu^{-1}(A)\), +where \(\nu:T_h\to f(S_h)\) is normalization. The complement of this +open in either normalization has dimension at most two. Localization shows that the kernel of this +restriction is spanned by its surface components, precisely the contracted +prime divisors just counted. Their independence makes the kernel dimension +\(e_h\) on one side and \(e_h^+\) on the other. The two images agree: +any compact analytic prime surface not removed has a strict transform on +the other normalization through their proper graph over \(T_h\), and the +two classes restrict to the same class on the common open. The same holds +in the reverse direction. Subtracting the dimensions of these two cycle +spans proves the last equality in \eqref{eq:difficulty-rank-change}. +\end{proof} + +\begin{proposition}[Change of the difficulty]\label{prop:difficulty-change} +The difficulty is nonincreasing under every coefficient change and every +small step of the truncated terminal chain. More precisely: +\begin{enumerate} +\item Suppose \(\Theta'\leq\Theta\) is a coefficient change on the same +model \(Y\), and write \(w(E)\) and \(w'(E)\) for its old and new weights. +The set +\[ + \mathcal C=\{E:\ E\text{ exceptional over }Y,\ w(E)\ne w'(E)\} +\] +is finite, and +\begin{equation}\label{eq:difficulty-coefficient-change} + \mathfrak D(Y,\Theta+\M)-\mathfrak D(Y,\Theta'+\M) + =\sum_{E\in\mathcal C}\bigl(w(E)-w'(E)\bigr)\geq0. +\end{equation} +\item For a small step \(Y\to Z\leftarrow Y^+\) with exceptional loci +\(L,L^+\), write \(w(E),w^+(E)\) for the two weights. The set +\[ + \mathcal P=\{E:\ E\text{ exceptional over }Y,\ + \cent_Y(E)\subset L,\ w(E)+w^+(E)>0\} +\] +is finite. Its center condition is equivalently +\(\cent_{Y^+}(E)\subset L^+\), and +\begin{equation}\label{eq:difficulty-small-change} + \mathfrak D(Y,\Theta+\M)-\mathfrak D(Y^+,\Theta^++\M) + =\sum_{E\in\mathcal P}\bigl(w(E)-w^+(E)\bigr)\geq0. +\end{equation} +\end{enumerate} +In either move, a strict decrease in the weight of any exceptional place +forces a strict decrease in the difficulty. +\end{proposition} + +\begin{proof} +For a coefficient change, the removed boundary \(\Theta-\Theta'\) is +effective and \(\Q\)-Cartier on the strong model. For every place, +\[ + a(E;Y,\Theta'+\M)-a(E;Y,\Theta+\M) + =\ord_E(\Theta-\Theta')\geq0. +\] +Thus \(w(E)\geq w'(E)\). The model, centers, branch counts, and +normalization ranks are unchanged, and the defaults \(d_h\) are constant +by the choice of the tail. At a fixed surface the two raw sums are finite, +and therefore +\[ + q_Y(V)-q'_Y(V)=\sum_{\cent_Y(E)=V}\bigl(w(E)-w'(E)\bigr). +\] +Let \(\Sigma\) be the finite union of the supports of the two functions +\(q_Y\) and \(q'_Y\) on surfaces. Outside \(\Sigma\) the displayed +sum is zero. Every summand is nonnegative, so no exceptional place with +such a surface center can lose weight. At each surface of \(\Sigma\) +only finitely many places have positive old or new weight, and there are +only finitely many positive weights at centers of codimension at least +three. This proves that \(\mathcal C\) is finite. Summing the displayed +identity over \(\Sigma\), adding the finite comparison in codimension at +least three, and canceling the unchanged rank term gives +\eqref{eq:difficulty-coefficient-change}. + +For a small step, Lemma~\ref{lem:small-comparison} says that exceptionality +of a global place is the same on the two sides, that the two center +containment conditions in the statement are equivalent, and that +\(w(E)\geq w^+(E)\). If a center is not contained in the exceptional +locus, its general point corresponds on the common isomorphism open and its +discrepancy is unchanged. The set \(\mathcal P\) is finite: each +exceptional locus has dimension at most two and has finitely many surface +components; a surface center contained in it is one of these components. +Proposition~\ref{prop:difficulty-finite} gives finiteness above each such +surface and finiteness of all positive-weight places with lower-dimensional +centers, on both sides. + +Surface centers not contained in \(L\) correspond by proper strict +transform to those not contained in \(L^+\). At their general points the +places, discrepancies, and normalization primes over the surfaces +correspond, so the two local brackets agree. The analogous correspondence +holds for the raw terms at lower-dimensional centers outside the exceptional +loci. In the exceptional loci, every contributing place is counted exactly +once in the raw part on each side of \eqref{eq:difficulty}. This remains +true if its center changes from a surface to a curve or point, or conversely. +The finite comparison of those raw parts is therefore +\(\sum_{E\in\mathcal P}(w(E)-w^+(E))\). The subtracted defaults on the +exceptional surfaces have difference \(-\sum_h d_h(e_h-e_h^+)\). Hence +\begin{align*} + &\mathfrak D(Y,\Theta+\M)-\mathfrak D(Y^+,\Theta^++\M)\\ + &\quad=\sum_{E\in\mathcal P}\bigl(w(E)-w^+(E)\bigr) + -\sum_h d_h(e_h-e_h^+) + +\sum_h d_h\bigl(c_2(S_h^\nu)-c_2((S_h^+)^\nu)\bigr)\\ + &\quad=\sum_{E\in\mathcal P}\bigl(w(E)-w^+(E)\bigr), +\end{align*} +where the last equality is Lemma~\ref{lem:difficulty-ranks}. This is +\eqref{eq:difficulty-small-change}. Every summand is nonnegative. A +strictly decreasing exceptional weight must have its center in the +exceptional loci, since weights agree off them, and is in \(\mathcal P\). +A positive weight that becomes zero is included by the definition of +\(\mathcal P\). The same positivity is immediate in +\eqref{eq:difficulty-coefficient-change}; this proves strictness in both +cases. +\end{proof} diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/08-completion.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/08-completion.tex new file mode 100644 index 0000000000000000000000000000000000000000..46a5b102e434531262c5e38ebcbb5c811fee021c --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/sections/08-completion.tex @@ -0,0 +1,352 @@ +\section{Termination and the log canonical reduction}\label{sec:completion} + +We first show that a surface in the positive exceptional locus of a +downstairs diagram is detected by the integer difficulty. The calculation +uses the weight denominator \(N\) chosen for the particular strong gklt +sequence under consideration. We then prove +termination for strong gklt models, pass to elementary gdlt programs, and +lift the arbitrary diagrams of Theorem~\ref{thm:main} to those programs. + +\begin{lemma}[A positive exceptional surface]\label{lem:positive-surface} +Use the truncated terminal chain of +Propositions~\ref{prop:terminal-junctions} and +\ref{prop:surface-finiteness}, with the integer \(N\), weights, and constant +defaults chosen in Section~\ref{sec:difficulty}. If an irreducible compact +analytic surface \(V\) is contained in \(L_i^+\subset X_{i+1}\), there is +a global place \(E\), exceptional over both junctions and every model of +their connector, such that +\[ + a_{i+1}(E)\in(1,2]\cap N^{-1}\Z, + \qquad w_i(E)\geq w_{i+1}(E)+1. +\] +Here \(w_i\) and \(w_{i+1}\) are the weights at the two crepant junctions. +Consequently +\[ + \mathfrak D(Y_i,\Theta_i+\M) + >\mathfrak D(Y_{i+1},\Theta_{i+1}+\M). +\] +\end{lemma} + +\begin{proof} +By Proposition~\ref{prop:surface-finiteness}, the model \(X_{i+1}\) is +smooth near the general point of \(V\), the junction morphism is an +isomorphism there, and the generic blowup of \(V\) gives a unique global +place \(E\) with +\[ + a^+:=a_{i+1}(E)>1. +\] +This place is exceptional over \(X_{i+1}\) and does not belong to the +stabilized extracted set \(\mathcal I\). The blowup of the coherent ideal +of \(V\) is projective, so Lemma~\ref{lem:common-projective-models} gives a +smooth common model \(W\) carrying both \(E\) and the fixed nef datum, +with a projective morphism \(r:W\to X_{i+1}\). By Lemma~\ref{lem:nef-defect}, +\[ + J=r^*M_{i+1}-M_W\geq0. +\] +At the generic smooth codimension-two center, the ordinary log discrepancy +of the blowup is two. The discrepancy formula is therefore +\begin{equation}\label{eq:positive-detector-discrepancy} + a^+=2-\ord_E(B_{i+1})-\operatorname{coeff}_E(J). +\end{equation} +Both subtracted terms are nonnegative. Thus \(a^+\leq2\). + +We verify the denominator in this calculation. By the choice in +Section~\ref{sec:difficulty}, \(N\) clears the coefficients of the initial +boundary and the Cartier denominator of the higher nef divisor of this +strong gklt sequence. Since the downstairs boundaries are strict +transforms, \(NB_{i+1}\) is an integral Weil divisor. Also \(NM_{i+1}\) +is an integral Weil divisor: it is the pushforward of the integral Cartier +divisor \(NM_W\) from a common carrier. On the smooth open neighborhood of +the general point of \(V\), these two integral Weil divisors are Cartier. +Their orders at \(E\) are consequently integral after multiplication by +\(N\). In particular, +\[ + N\ord_E(B_{i+1})\in\Z, + \qquad + N\operatorname{coeff}_E(J) + =\ord_E(Nr^*M_{i+1})-\operatorname{coeff}_E(NM_W)\in\Z. +\] +Only Cartierness on this smooth open has been used. Equation +\eqref{eq:positive-detector-discrepancy} gives +\(a^+\in(1,2]\cap N^{-1}\Z\). + +Put \(a^-=a_i(E)\). The strict part of +Lemma~\ref{lem:small-comparison} applies because +\(\cent_{X_{i+1}}(E)=V\subset L_i^+\), and gives \(a^-c_2(X_{i+1}) +\] +at every step of this tail. These are nonnegative integers, a +contradiction. +\end{proof} + +\begin{theorem}[Termination of elementary gdlt programs]\label{thm:gdlt} +Let +\[ + (T_0,B_0+\M)\dashrightarrow(T_1,B_1+\M) + \dashrightarrow(T_2,B_2+\M)\dashrightarrow\cdots +\] +be a sequence of elementary steps for rational gdlt pairs on strong normal irreducible +compact K\"ahler fourfolds. Assume that the boundaries are effective +rational divisors of finite support transported by the steps, that the +fixed b-divisor is represented by an analytically nef \(\Q\)-Cartier divisor +on a projective bimeromorphic normal compact K\"ahler model of \(T_0\), and +that the actual adjoints are \(\Q\)-Cartier with compatible canonical +representatives. Then the sequence is finite. The contraction bases and +the choices of elementary steps may vary. +\end{theorem} + +\begin{proof} +An elementary program extracts no prime divisors. Lemma~\ref{lem:cycle-loss} with \(k=3\) +therefore permits only finitely many divisorial steps. If the sequence were +infinite, we could discard a finite prefix containing them and work on a +tail of small steps. +The rational b-line realization described in +Section~\ref{sec:preliminaries} has the same discrepancies and fixed higher +nef data; common projective carriers for finite portions carry their +analytically nef pullbacks. Thus Theorem~\ref{thm:special-termination} +applies. After a further tail, both exceptional loci of every step avoid +every generalized log canonical center on their respective sides. + +Set \(H_i=\lfloor B_i\rfloor\). Since the pair is glc and \(B_i\) is +effective, its coefficients belong to \([0,1]\), so \(H_i\) is the reduced +sum of its coefficient-one components. Each such component is itself a +generalized log canonical center. Hence \(\Supp H_i\) is disjoint from +the exceptional loci adjacent to \(T_i\) on this tail. The divisors +\(H_i\) are effective and \(\Q\)-Cartier on the strong models, and they +are strict transforms of each other across the small steps. + +Remove the whole floor and write +\[ + \widehat B_i=B_i-H_i, + \qquad \widehat D_i=K_{T_i}+\widehat B_i+M_{T_i}=D_i-H_i. +\] +The new boundary is effective. For every global place \(E\), comparison +of the two crepant equations gives +\begin{equation}\label{eq:full-floor-deletion} + a(E;T_i,\widehat B_i+\M) + =a(E;T_i,B_i+\M)+\ord_E(H_i). +\end{equation} +The added order is nonnegative. If the old discrepancy is zero, the gdlt +definition says that the general point of its center is a stratum of the +coefficient-one boundary. Taking its closure places the entire center in +\(\Supp H_i\). The order of an effective \(\Q\)-Cartier divisor at a +place whose center lies in its support is strictly positive. Thus every +former zero discrepancy becomes positive, and every former positive +discrepancy stays positive. The pairs \((T_i,\widehat B_i+\M)\) are gklt. + +We check the two ample signs after this full deletion. For a step write +\[ + T_i\xrightarrow{f}Z\xleftarrow{f^+}T_{i+1}, + \qquad L=\Exc(f),\quad L^+=\Exc(f^+). +\] +Lemma~\ref{lem:small-comparison} gives a common exceptional image \(A\) +with \(L=f^{-1}(A)\), \(L^+=(f^+)^{-1}(A)\), and both maps isomorphisms +off \(A\). Properness makes \(f(\Supp H_i)\) closed. It is disjoint from +\(A\), because \(\Supp H_i\cap L=\varnothing\). On the base open +\(Z\setminus f(\Supp H_i)\), which contains \(A\), the divisor \(H_i\) +vanishes, so \(-\widehat D_i=-D_i+H_i\) has the original relative ample +sign. On \(Z\setminus A\) the map \(f\) is an isomorphism, and every line +bundle is relatively ample for an isomorphism. These two opens cover +\(Z\). After clearing a common Cartier multiple, relative ampleness is +local on the base, so \(-\widehat D_i\) is \(f\)-ample. The identical +argument with \(f^+\) and \(H_{i+1}\) proves that +\(\widehat D_{i+1}=D_{i+1}-H_{i+1}\) is \(f^+\)-ample. + +Reindex this floor-deleted tail at its first model and regard it as a +sequence of the arbitrary small diagrams in Theorem~\ref{thm:strong-gklt}. +The model and diagram hypotheses are inherited; the new boundaries are +effective and related by strict transform, the actual adjoints are +\(\Q\)-Cartier, and the two ample signs have just been checked. A common +carrier for the finite preceding portion, projective over the new first +model, supplies the fixed analytically nef divisor. In this application +the detector integer is chosen afresh for the new initial boundary and +nef carrier. The theorem makes the tail finite, contradicting its +construction. +\end{proof} + +To lift a prescribed downstairs diagram, we run gdlt continuation over +its base. Theorem~\ref{thm:gdlt} forces the chosen run to reach a nef +adjoint, and Lemma~\ref{lem:nef-ample} gives a projective crepant morphism +from that endpoint to the prescribed positive model. A negative +multisection ensures that the run contains a step. + +\begin{lemma}[A nonempty gdlt lift]\label{lem:nonempty-lift} +Let +\[ + X\xrightarrow{\ f\ }Z\xleftarrow{\ f^+\ }X^+ +\] +be any one of the small diagrams allowed in Theorem~\ref{thm:main}, with +normal globally Weil \(\Q\)-factorial compact K\"ahler fourfolds on the two +sides, effective rational boundaries \(B,B^+\) related by strict transform, +the same rational nef b-divisor, and the compatible actual adjoints +\(D_X,D_{X^+}\). Assume \((X,B+\M)\) is glc, and represent the b-divisor +by an analytically nef \(\Q\)-Cartier divisor on a projective carrier over +\(X\). Suppose +\[ + h:(Y,\Theta+\M)\longrightarrow(X,B+\M) +\] +is a projective crepant gdlt modification as in +Proposition~\ref{prop:gdlt-modification}; in particular \(Y\) is strong, +\(\Theta\geq0\), and every \(h\)-exceptional prime has coefficient one. +Then there is a finite sequence of elementary negative gdlt steps over +\(Z\), of length \(m\geq1\), +\[ + (Y,\Theta+\M)=(Y_0,\Theta_0+\M) + \dashrightarrow\cdots\dashrightarrow(Y_m,\Theta_m+\M), +\] +and a projective bimeromorphic morphism \(h^+:Y_m\to X^+\) such that +\[ + K_{Y_m}+\Theta_m+M_{Y_m}=(h^+)^*D_{X^+}. +\] +The end is a strong normal compact K\"ahler gdlt model with effective +boundary, and every \(h^+\)-exceptional prime has coefficient one in +\(\Theta_m\). Thus it is again a crepant gdlt modification of the same +type. +\end{lemma} + +\begin{proof} +The composite \(Y\to Z\) is projective bimeromorphic to a normal compact +K\"ahler base. On a projective common carrier, the fixed analytically nef +divisor is nef over \(Z\). Thus the continuation assertion of +Proposition~\ref{prop:relative-program} applies to this gdlt pair and to +every non-nef finite prefix produced from it. + +The initial adjoint \(D_Y=h^*D_X\) is not nef over \(Z\). Indeed, the +nonisomorphic projective contraction \(f\) has a positive-dimensional +fiber, and projective hyperplane cuts give a compact irreducible curve +\(C\) in that fiber. The negative ample sign gives \(D_X\cdot C<0\). +There is a compact irreducible curve \(C'\subset Y\) mapping onto \(C\). +For completeness, normalize \(C\), take an irreducible component of its +base change under \(h\) which dominates that normalization, and write +\(r\) for its generic fiber dimension. The normalization of \(C\) is a +projective compact curve, so this component, being projective over it, is +projective. A sufficiently high very ample system on the component has +\(r\) general members whose intersection with a generic fiber is a +nonempty zero-dimensional cycle. Their intersection therefore has a +compact curve component dominating the base. Its image in \(Y\) is such +a \(C'\). The induced map of normalized curves has a positive finite +degree. The projection formula now gives +\[ + D_Y\cdot C'=\deg(C'/C)\,D_X\cdot C<0. +\] +In particular, any run reaching nefness must contain at least one step. + +Choose an elementary negative step whenever the current adjoint is not +nef over \(Z\). The relative continuation assertion keeps all outputs +projective over \(Z\), strong normal compact K\"ahler, and gdlt with the +transported data. All models in the run are irreducible: \(Y\) is +bimeromorphic to the irreducible \(X\), and every elementary step is +bimeromorphic. If this process never reached a nef adjoint, it would +give an infinite elementary gdlt sequence with the fixed analytically nef +b-divisor. This contradicts Theorem~\ref{thm:gdlt}. We obtain a finite +run of length \(m\geq1\) with end adjoint \(D_{Y_m}\) nef over \(Z\). + +Take a smooth common model \(W\) with projective maps to the models in the +run, to \(X^+\), and to the nef carrier, all over \(Z\). Write \(P_0,P,P_+\) for the pullbacks +of \(D_Y,D_{Y_m},D_{X^+}\), respectively. By +Lemma~\ref{lem:program-comparison}, the finite run gives +\[ + P_0=P+G,\qquad G\geq0\text{ exceptional over }Y_m. +\] +Initial crepancy identifies \(P_0\) with the pullback of \(D_X\). +Lemma~\ref{lem:small-comparison}, pulled to \(W\), gives the second +comparison +\[ + P_0=P_++F,\qquad F\geq0\text{ exceptional over }X^+. +\] +The first end is nef over \(Z\), and \(D_{X^+}\) is ample over \(Z\). +Lemma~\ref{lem:nef-ample} therefore gives an actual equality \(P=P_+\) +and a projective morphism \(h^+:Y_m\to X^+\) over \(Z\) with +\(D_{Y_m}=(h^+)^*D_{X^+}\). + +The end is strong, gdlt, and has effective boundary by the relative +program. It remains to check its exceptional primes. Every prime on +\(Y_m\) has a strict-transform prime on \(Y\), because an elementary +program extracts no prime divisors. Let \(R\) be exceptional for +\(h^+\), and let \(R_0\) be its prime on \(Y\). If \(R_0\) were not +exceptional for \(h\), it would represent a prime on \(X\). Smallness +downstairs identifies that prime with a prime on \(X^+\). The place of +\(R\) would then have a divisorial center on \(X^+\), contradicting its +exceptionality. Hence \(R_0\) is \(h\)-exceptional and has coefficient +one in \(\Theta\). Boundary coefficients of surviving primes are +unchanged by an elementary program, so \(R\) has coefficient one in +\(\Theta_m\). The displayed crepant equality also identifies its +discrepancy over \(X^+\) as zero. This proves the lemma. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:main}] +Assume that the sequence in the theorem is infinite. By +Lemma~\ref{lem:small-comparison}, every global discrepancy is nondecreasing +along it. Hence every \((X_i,B_i+\M)\) is glc. The rational b-line +realization of the initial data satisfies +Proposition~\ref{prop:gdlt-modification}: \(X_0\) is a normal compact +K\"ahler fourfold, the boundary is effective and rational, the nef datum +has a projective carrier, and the adjoint is rationally invertible. The +proposition gives a projective crepant gdlt modification +\[ + h_0:(Y_0,\Theta_0+\M)\longrightarrow(X_0,B_0+\M) +\] +with a strong normal compact K\"ahler source and only coefficient-one +exceptional primes. It requires no strong factoriality of \(X_0\). + +Apply Lemma~\ref{lem:nonempty-lift} to the first downstairs diagram and +\(h_0\). Its endpoint is a crepant gdlt modification of the same type over +\(X_1\), so it is the input for the next application. At every finite +stage a common projective carrier supplies the fixed analytically nef +data over the current downstairs model. Induction therefore lifts every +downstairs diagram. Each lifted string is finite and contains at least one +elementary step, and its endpoint is used as the literal starting model of +the next string. Their concatenation is an infinite sequence of elementary +gdlt steps on strong normal irreducible compact K\"ahler fourfolds, with the same +b-divisor throughout. Theorem~\ref{thm:gdlt} allows the bases to vary and +rules out this sequence. The contradiction proves +Theorem~\ref{thm:main}. +\end{proof} diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/termination-generalized-lc-kahler-fourfolds.tex b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/termination-generalized-lc-kahler-fourfolds.tex new file mode 100644 index 0000000000000000000000000000000000000000..51d90c3f729425e197d7ebc66204386631a8c1b5 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/build/termination-generalized-lc-kahler-fourfolds.tex @@ -0,0 +1,3769 @@ +\documentclass[11pt]{amsart} +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage{microtype} +\usepackage[margin=1.05in]{geometry} +\usepackage{mathtools,amssymb} +\usepackage{tikz-cd} +\usepackage{graphicx} +\usepackage{hyperref} +\hypersetup{hidelinks,pdftitle={Termination of generalized log canonical flips on compact Kahler fourfolds},pdfauthor={OpenAI}} + +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{notation}[theorem]{Notation} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newtheorem*{claim}{Claim} +\numberwithin{equation}{section} + +\newcommand{\Q}{\mathbb{Q}} +\newcommand{\R}{\mathbb{R}} +\newcommand{\Z}{\mathbb{Z}} +\newcommand{\C}{\mathbb{C}} +\newcommand{\M}{\mathbf{M}} +\DeclareMathOperator{\Exc}{Exc} +\DeclareMathOperator{\Supp}{Supp} +\DeclareMathOperator{\Sing}{Sing} +\DeclareMathOperator{\cent}{cent} +\DeclareMathOperator{\ord}{ord} +\DeclareMathOperator{\codim}{codim} +\DeclareMathOperator{\rk}{rk} +\DeclareMathOperator{\im}{im} +\DeclareMathOperator{\coker}{coker} +\DeclareMathOperator{\Pic}{Pic} +\DeclareMathOperator{\Proj}{Proj} +\DeclareMathOperator{\IC}{IC} +\DeclareMathOperator{\Gr}{Gr} +\newcommand{\BM}{\mathrm{BM}} +\allowdisplaybreaks[2] +\setcounter{tocdepth}{1} +\emergencystretch=2em + +\title[Generalized log canonical flips on K\"ahler fourfolds]{Termination of generalized log canonical flips\newline on compact K\"ahler fourfolds} +\author{OpenAI} +\date{October 7, 2026} + +\begin{document} +\begin{abstract} +Every sequence of generalized log canonical flips on a normal irreducible globally Weil \(\Q\)-factorial compact K\"ahler fourfold terminates, provided the flips are projective small diagrams with the stated opposite ample signs. The boundary is rational, and the nef b-divisor is fixed and represented by an analytically nef \(\Q\)-Cartier divisor on a projective modification. No scaling rule or pseudo-effectivity assumption is required. The theorem concerns existing flip sequences; it does not assert the existence of all contractions or flips. + +\end{abstract} +\maketitle +\tableofcontents + +\section{Introduction}\label{sec:introduction} + +Termination of flips rules out an endless sequence of small birational improvements in the minimal model program. Since flips contract no divisors, their number cannot be bounded by counting divisors that disappear. In dimension four, exceptional surfaces bring places centered on surfaces and curves into the argument. On compact K\"ahler spaces, the contractions may be projective even when the ambient fourfold has no ample line bundle. + +Shokurov's difficulty counts exceptional divisors with small discrepancy to measure the improvement of singularities \cite[Definition~2.15 and Corollaries~2.16--2.17]{ShokurovNonvanishing}. Kawamata, Matsuda, and Matsuki combined it with the rank of surface cycle classes to prove termination of terminal fourfold flips in the algebraic setting \cite[Theorem~5-1-15]{KawamataMatsudaMatsuki1987}. For boundaries, Fujino's corrected argument for canonical fourfold pairs exhibits the recurring contributions from successive blowups over a codimension-two center \cite[Example~2.1 and Theorems~5.1--5.2]{Fujino2005Addendum}. Alexeev, Hacon, and Kawamata developed a weighted difficulty that subtracts these contributions and tracks cycles on normalized boundary components \cite[Section~2]{AlexeevHaconKawamata2007}. Discrepancy improvement and the behavior of boundary cycles also guide the proof here. + +Generalized pairs place part of the adjoint data on a higher birational model: a nef divisor there contributes its trace on the space carrying the boundary \cite[Definitions~1.4 and 4.1]{BirkarZhang2016}. For algebraic generalized pairs, Hacon and Moraga gave a termination reduction using weak Zariski decompositions \cite[Theorem~1]{HaconMoraga2020}. Termination for pseudo-effective generalized log canonical fourfolds with NQC nef data was proved by Chen and Tsakanikas \cite[Theorem~1.1]{ChenTsakanikas2023} and by Moraga \cite[Theorem~4.4]{Moraga2025}. Here NQC means a nonnegative real combination of nef \(\Q\)-Cartier divisors on the higher model. Han, Liu, and Zhuang proved termination of ordinary klt fourfold minimal model programs when the boundary is big over the fixed algebraic base \cite[Corollary~3.2(3)]{HanLiuZhuang2025}. + +Hacon and Xie formulate a termination conjecture for generalized klt pairs with higher \((1,1)\)-class data on compact K\"ahler spaces \cite[Conjecture~1.15]{HaconXie2026}. The generalized klt case of the theorem below treats a four-dimensional rational-divisor form of that question under the stated projectivity and global Weil \(\Q\)-factoriality assumptions; the theorem also permits generalized log canonical singularities. Its ambient spaces may be nonprojective, and the prescribed small diagrams may vary their bases and choices under the hypotheses below. + +A normal compact complex space \(X\) is \emph{globally Weil \(\Q\)-factorial} if every prime Weil divisor defined on all of \(X\) is \(\Q\)-Cartier and some positive reflexive power of its canonical sheaf is invertible. Projective morphisms of complex spaces are understood in the analytic sense: they admit a relatively ample holomorphic line bundle. A \(\Q\)-Cartier divisor is relatively ample if a positive Cartier multiple is relatively ample. + +For a normal compact K\"ahler space \(X\), a rational nef b-divisor \(\M\) in this paper is represented by a \(\Q\)-Cartier divisor \(M'\) on a normal compact K\"ahler space \(X'\) with a projective bimeromorphic map \(\pi:X'\to X\). We require \(c_1(M')\) to lie in the closure of the K\"ahler cone in real Bott--Chern cohomology. On a model dominating \(X'\), the trace \(M_W\) is the pullback of \(M'\); on another model it is the pushforward from a common higher model. The divisor \(M'\) need not be effective. + +We use compatible actual canonical divisor representatives on the birational models under consideration. Given an effective rational Weil divisor \(B\) of finite support for which \(D_X=K_X+B+M_X\) is \(\Q\)-Cartier, choose a smooth proper bimeromorphic model \(p:W\to X\) dominating \(X'\) and write +\begin{equation}\label{eq:discrepancy-definition} + K_W+\Delta_W+M_W=p^*(K_X+B+M_X). +\end{equation} +A \emph{global divisorial place} is a prime divisor on a normal proper bimeromorphic model, with primes identified by strict transform on common higher models. Its log discrepancy is +\[ + a(E;X,B+\M)=1-\operatorname{coeff}_E(\Delta_W) +\] +on a model carrying \(E\). The pair is \emph{generalized log canonical} if this number is nonnegative for every global divisorial place, including the primes on \(X\). These places are defined on birational models; the definition does not depend on a field of global meromorphic functions. + +\begin{theorem}\label{thm:main} +Let \(X_0\) be a normal irreducible globally Weil \(\Q\)-factorial compact K\"ahler fourfold. Let \(B_0\) be an effective rational Weil divisor of finite support with coefficients in \([0,1]\). Let \(\M\) be represented by an analytically nef \(\Q\)-Cartier divisor on a projective bimeromorphic normal compact K\"ahler model of \(X_0\). Fix compatible actual canonical divisor representatives on all birational models under consideration. Suppose that \(D_0=K_{X_0}+B_0+M_{X_0}\) is \(\Q\)-Cartier and that \((X_0,B_0+\M)\) is generalized log canonical. + +Consider a sequence of normal irreducible globally Weil \(\Q\)-factorial compact K\"ahler fourfolds +\[ + X_0\dashrightarrow X_1\dashrightarrow X_2\dashrightarrow\cdots. +\] +On \(X_i\), let \(B_i\) be the strict transform of \(B_0\), let \(M_i=M_{X_i}\) be the trace of the same b-divisor, and assume that \(D_i=K_{X_i}+B_i+M_i\) is \(\Q\)-Cartier. Transport the canonical representatives under the induced identifications of prime divisors. Suppose that every step is given by a diagram +\begin{equation}\label{eq:flip-diagram} +\begin{tikzcd}[column sep=large] + X_i \arrow[r,"f_i"] & Z_i & X_{i+1}\arrow[l,"f_i^+"'] +\end{tikzcd} +\end{equation} +where \(Z_i\) is normal compact K\"ahler, both maps are projective small bimeromorphic morphisms with connected fibers, neither is an isomorphism, and +\[ + -D_i\text{ is }f_i\text{-ample},\qquad + D_{i+1}\text{ is }f_i^+\text{-ample}. +\] +Here \emph{small} means that the exceptional locus contains no prime divisor. Then the sequence is finite. +\end{theorem} + +We call a diagram satisfying the hypotheses of Theorem~\ref{thm:main} a \emph{flip} for the indicated adjoint. The theorem applies to arbitrary choices of such diagrams. Taking \(\M=0\) gives the ordinary log canonical case. + +The proof uses the relative constructions and special termination for generalized pairs in \cite{KahlerAuxiliary}, whose precise forms we recall in Section~\ref{sec:preliminaries}. + +\subsection*{Proof strategy} + +We first prove termination for generalized klt pairs on models satisfying the stronger factoriality condition specified in Section~\ref{sec:preliminaries}. Discrepancy monotonicity and finiteness for the initial pair make the set of exceptional places of discrepancy at most one constant on a tail. Extracting it gives crepant models \(h_i:Y_i\to X_i\) whose remaining exceptional discrepancies are greater than one; we call them \emph{terminal junctions}. Each downstairs flip connects two junctions by a decrease of the extracted boundary coefficients followed by a finite, possibly empty, program of small steps. This construction adapts the projective argument of \cite[Section~3, Proposition~3.4]{ProjectiveLCFourfolds}. + +The extracted coefficients may still vary. When an extracted divisor maps onto a surface, a transverse smooth surface cuts its general fiber into exceptional curves. Adjunction and negative definiteness bound the entries of the grouped intersection matrix. The fixed rational boundary and nef data then confine the discrepancies of extracted places with surface centers to a finite set. A downstairs flip strictly raises the discrepancy of a place whose center lies in its exceptional locus. It follows that, on every junction of a tail, each coefficient that still varies belongs to a divisor mapping onto a curve or a point of \(X_i\). + +The branch bound of Theorem~\ref{thm:branch} applies to a reduced union \(Q\) of divisors on a terminal fourfold \(Y\) when a projective bimeromorphic morphism \(Y\to X\) of normal irreducible compact K\"ahler fourfolds sends \(Q\) to a set of dimension at most one. A surface in \(Q\) may have several prime divisors above it in the disjoint normalization of its components. The theorem bounds the total excess of branches by the ranks of surface cycle classes on those normalizations and the number of global ordinary discrepancy-two places centered on singular curves in \(Q\). It is formulated independently of any boundary or crepant equation. + +The word \emph{global} is essential. Projective topology over the curve image relates the branch excess to local systems along the singular curves. Saito's projective analytic decomposition theorem and a Hodge-filtration argument on a compact K\"ahler resolution give the needed purity. A Quot parameter argument gives finite monodromy. On a Stein neighborhood of a compact core carrying all loops of the curve, we apply Fujino's local small \(\Q\)-factorialization theorem; fiber degrees and blowups then produce local ordinary discrepancy-two places. A canonical discrepancy comparison shows that they occur as divisors on one global resolution, and the retained loops keep those global divisors distinct. The normalization and parameter methods follow \cite[Sections~5--6]{ProjectiveLCFourfolds}; the analytic purity argument and the passage to distinct global divisors are given here. + +Section~\ref{sec:difficulty} constructs the difficulty by counting exceptional places of discrepancy below two with ceiling weights, subtracting generic blowup contributions locally before summation, and adding cycle-rank corrections on normalized boundary components. The branch bound makes it nonnegative at junctions. Across a small step, the cycle-rank change cancels the change in the local subtractions, leaving a sum of nonnegative weight losses. This adapts the locally corrected difficulty in \cite[Section~4]{ProjectiveLCFourfolds}. + +A surface in the positive exceptional locus of a downstairs flip forces a drop of at least one in the difficulty between its terminal junctions. Only finitely many flips can do this. Every remaining flip has an exceptional surface only on the negative side, so the rank of analytic surface classes on the ambient \(X_i\) decreases. This proves termination for generalized klt pairs on these auxiliary models. Special termination and deletion of the whole boundary floor reduce elementary generalized dlt programs to that case. We then use relative continuation and this gdlt termination to lift each diagram of Theorem~\ref{thm:main} to a finite program whose endpoint maps crepantly to the next downstairs model. A negative curve downstairs has a negative multisection upstairs, so each lift is nonempty. Their concatenation proves Theorem~\ref{thm:main}. + +\section{Generalized pairs and auxiliary programs}\label{sec:preliminaries} + +The relative constructions used in the proof take place on models with a +stronger global factoriality property than the one in +Theorem~\ref{thm:main}. We first specify that property and the generalized +pair conventions for those constructions. We then record the precise +forms of the auxiliary results that will be used. + +The auxiliary definitions and statements in this section use reduced, +irreducible, second-countable complex analytic spaces as their ambient +spaces. + +\begin{definition}[Global strong factoriality]\label{def:strong-factoriality} +A normal compact complex space \(T\) is \emph{globally strongly +\(\Q\)-factorial} if, for every coherent rank-one reflexive sheaf +\(\mathcal F\) on all of \(T\), some positive reflexive power +\[ + \mathcal F^{[m]}=(\mathcal F^{\otimes m})^{**},\qquad m>0, +\] +is an invertible sheaf. +\end{definition} + +This condition implies global Weil \(\Q\)-factoriality: apply it to the +divisorial sheaf of each global prime divisor and to the reflexive canonical +sheaf. It is a condition on sheaves on the whole space; it makes no assertion +that arbitrary analytic open subsets, or the analytic local rings, are +\(\Q\)-factorial. We use \emph{strong model} to mean a globally strongly +\(\Q\)-factorial model. + +A \emph{rational line bundle} on \(T\) is an element of +\(\Pic(T)\otimes_{\Z}\Q\). An equality of rational line bundles means an +isomorphism of holomorphic line bundles after taking a positive common +integral multiple. A rank-one reflexive sheaf is \emph{rationally +invertible} if a positive reflexive power is invertible. On a projective +morphism \(T\to V\), a rational line bundle is \emph{relatively nef} if +its degree is nonnegative on every compact irreducible curve in a fiber, +and is \emph{relatively ample} if a positive integral multiple is relatively +ample. For the absolute nef data in this paper, nefness means that the +first Chern class lies in the closure of the K\"ahler cone, as in the +introduction; it implies relative nefness for every morphism under +consideration. + +The auxiliary constructions are stated for rational generalized +\emph{b-line data}. On a normal compact space \(T\), these consist of an +effective rational Weil divisor \(B\) of finite support, a projective +modification \(p:W\to T\), and a rational line bundle \(M_W\) on \(W\) +that is nef absolutely, or nef over the specified base of a relative +argument. It is pulled back on every higher model; we continue to denote +the resulting b-object by \(\M\). After clearing a denominator, proper +direct image followed by double dual defines its reflexive trace \(M_T\). +The adjoint \(D_T=K_T+B+M_T\) is required to be rationally invertible. +Here \(K_T\) in the b-line formulation is the reflexive canonical sheaf. +On a smooth log resolution projective over \(T\) and carrying the data, the natural +meromorphic comparison over the isomorphism locus defines the crepant +boundary by +\[ + K_W+B_W+M_W=p^*D_T. +\] +The log discrepancy of a global place \(E\) is +\(a(E;T,B+\M)=1-\operatorname{coeff}_E(B_W)\) on a model carrying it. +All statements about places below concern the global places defined in the +introduction. A global place is exceptional over \(T\) if its center on +\(T\) has codimension at least two. + +We abbreviate \emph{generalized klt}, \emph{generalized lc}, and +\emph{generalized dlt} to gklt, glc, and gdlt. A pair is gklt if all of +its global log discrepancies are positive, and glc if they are all +nonnegative. It is \emph{generalized terminal} if it is gklt and +\(a(E;T,B+\M)>1\) for every place exceptional over \(T\). A +\emph{generalized log canonical center} is the center of a global place of +log discrepancy zero. A glc pair is gdlt if there is a Zariski-open set +\(T^\circ\subset T\) on which \((T^\circ,B|_{T^\circ})\) is simple normal +crossing and the b-data descend, and which contains the general point of +every generalized log canonical center. The carrier and subsequent log +resolutions may be chosen isomorphic on this open. The zero-discrepancy +centers there are strata of the coefficient-one boundary. These are the +conventions of \cite[Convention~9.1 and Definition~9.2]{KahlerAuxiliary}. + +We explain the relation between this formulation and the actual divisors in +Theorem~\ref{thm:main}. A \(\Q\)-Cartier divisor determines a rational +line bundle. If \(mM_W\) is integral Cartier, then on the normal target +the reflexive sheaf +\[ + \bigl(p_*\mathcal O_W(mM_W)\bigr)^{**} +\] +agrees with the divisorial sheaf \(\mathcal O_T(mp_*M_W)\): the two agree +at every codimension-one point, where the modification is an isomorphism, +and normality gives uniqueness of the reflexive extension. The same +comparison on a common higher model is compatible with pullback and with +transport across a small map. The canonical trace is the canonical +sheaf of the target. These facts are +\cite[Lemma~9.3(i)--(ii)]{KahlerAuxiliary}. The natural meromorphic +comparisons therefore agree with the comparisons using the compatible +actual canonical representatives in \eqref{eq:discrepancy-definition}. +In every application below the b-line discrepancies are exactly the +discrepancies of that equation, and a crepant b-line identity is the +corresponding equality of actual rational divisors. A common projective +carrier for any finite part of our birational constructions carries the +pullback of the original analytically nef divisor, which is relatively nef +over each base used in that part. A single carrier dominating an infinite +sequence is not required. + +Here is the elementary step used in the auxiliary programs. Suppose that +the source \(T\) and the output \(T_1\) are strong normal compact K\"ahler +spaces, and write \(D_T\) and \(D_{T_1}\) for their rationally invertible +adjoints. An \emph{elementary negative step} is either a projective +bimeromorphic divisorial contraction \(f:T\to T_1\) for which \(-D_T\) +is \(f\)-ample, or a diagram +\[ + T\xrightarrow{\ f\ }Z\xleftarrow{\ f^+\ }T_1 +\] +of projective small bimeromorphic morphisms to a normal compact K\"ahler +space with \(-D_T\) \(f\)-ample and \(D_{T_1}\) \(f^+\)-ample. The +degree functionals of the curves contracted on the negative side span one +nonzero ray when paired with global rational line bundles on \(T\). +In the small case the positive side is the relative Proj of the actual +adjoint algebra: after choosing a positive multiple of \(D_T\) represented +by a holomorphic line bundle \(\mathcal L\), it is +\[ + T_1=\Proj_Z\bigoplus_{m\geq0} f_*\mathcal L^{\otimes m}. +\] +The boundary is pushed forward in the divisorial case and strictly +transformed in the small case, and the same b-data are used on common higher +models. With the compatible actual canonical representatives, a divisorial +step satisfies \(D_{T_1}=f_*D_T\). If the step is \emph{over \(V\)}, all its maps commute with the +given maps to \(V\). In the constructions used below the contraction maps +have connected fibers, and a small step has nonisomorphic morphisms on both +sides; the latter properties are also verified in +Section~\ref{sec:comparisons}. This is the form of +\cite[Definition~9.6]{KahlerAuxiliary}. Its one-ray condition concerns +degrees of global line bundles and imposes no condition on the relative +Bott--Chern dimension. A diagram in Theorem~\ref{thm:main} need not be +elementary. + +\begin{proposition}[Low places and projective realization]\label{prop:low-places} +Let \((T,B+\M)\) be gklt rational generalized data on a normal compact +K\"ahler space, with effective boundary of finite support and an absolutely +nef rational datum carried by a projective modification. Fix a projective +log resolution carrying the datum. There is \(\varepsilon>0\) such that +every global place satisfies +\[ + a(E;T,B+\M)\geq\varepsilon, +\] +and only finitely many places exceptional over \(T\) satisfy +\[ + a(E;T,B+\M)<1+\varepsilon. +\] +This finite set can be represented simultaneously by prime divisors on a +smooth model projective over \(T\). In particular the exceptional places +of discrepancy at most one form a finite set with such a realization. +\end{proposition} + +This is the rational nef specialization of +\cite[Lemma~4.2(i)]{KahlerAuxiliary}. The positive number +\(\varepsilon\) belongs to this one pair; uniformity along a sequence will +follow from discrepancy monotonicity. + +\begin{proposition}[Exact extraction]\label{prop:extraction} +Let \((T,B+\M)\) be rational gklt data on a strong normal compact +K\"ahler space, with an absolutely nef rational line bundle on a projective +carrier and rationally invertible adjoint. For any specified finite set +\(\mathcal E\) of places exceptional over \(T\) with +\(a(E;T,B+\M)\leq1\), there is a projective bimeromorphic morphism +\(h:U\to T\) such that \(U\) is a strong normal compact K\"ahler space, +the \(h\)-exceptional prime divisors are exactly the members of +\(\mathcal E\), and the crepant generalized pair on \(U\) is gklt with +effective boundary. Thus, writing this boundary as \(B_U\), +\[ + K_U+B_U+M_U=h^*(K_T+B+M_T). +\] +\end{proposition} + +This is \cite[Proposition~9.11]{KahlerAuxiliary}. Terminality is not part +of the extraction assertion. It will follow when \(\mathcal E\) is chosen +to contain every exceptional place of discrepancy at most one. + +\begin{proposition}[Relative programs]\label{prop:relative-program} +Let \(\pi:T\to V\) be a projective bimeromorphic morphism of normal compact +K\"ahler spaces. Suppose that \(T\) is strong and that \((T,B+\M)\) is +rational gdlt, with effective boundary, a projective carrier on which the +rational line datum is nef over \(V\), and a rationally invertible adjoint +\(D_T\). +\begin{enumerate} +\item If \(D_T\) is not relatively nef over \(V\), there is an elementary +negative step over \(V\). Its output is projective over \(V\), normal +compact K\"ahler and strong, and is gdlt with the transported boundary and +b-data. The same construction is available after every finite prefix whose +last adjoint is not relatively nef over \(V\). +\item If the initial pair is gklt, there exists a finite, possibly empty, +sequence of elementary negative steps over this one fixed base \(V\) whose +last adjoint is relatively nef over \(V\). Its models and transported data +have the properties in the first assertion. +\end{enumerate} +\end{proposition} + +The two assertions are respectively +\cite[Propositions~9.7 and 9.9]{KahlerAuxiliary}. The first is a +continuation assertion for gdlt data. The second asserts the existence of +one finite run for gklt data; it does not assert termination of every choice +of a relative program. + +\begin{proposition}[Crepant gdlt modification]\label{prop:gdlt-modification} +Let \((T,B+\M)\) be rational glc data of dimension at most four on a normal +compact K\"ahler space. Assume that the higher absolutely nef rational +line datum is carried by a projective modification and that +\(K_T+B+M_T\) is rationally invertible. There is a projective bimeromorphic +morphism \(h:Y\to T\) such that \(Y\) is a strong normal compact K\"ahler +space, \((Y,B_Y+\M)\) is gdlt with \(B_Y\geq0\), and +\[ + K_Y+B_Y+M_Y=h^*(K_T+B+M_T). +\] +Every \(h\)-exceptional prime has coefficient one in \(B_Y\), equivalently +has generalized log discrepancy zero over \((T,B+\M)\). +\end{proposition} + +This is \cite[Proposition~11.4]{KahlerAuxiliary}. The base \(T\) need not +be strong, and the assertion does not require that every zero-discrepancy +place be extracted. + +\begin{theorem}[Special termination]\label{thm:special-termination} +Let \(d\leq4\), and let +\[ + (T_0,B_0+\M)\dashrightarrow(T_1,B_1+\M) + \dashrightarrow(T_2,B_2+\M)\dashrightarrow\cdots +\] +be a sequence of elementary steps for rational gdlt data on strong normal +compact K\"ahler spaces of dimension \(d\). The boundaries are transported +as in an elementary program, and the higher absolutely nef b-line datum is fixed and is +carried by projective modifications. There is an index \(i_0\) such that, +for every \(i\geq i_0\), the exceptional loci on both sides of the step are +disjoint from every generalized log canonical center on their respective +sides. The contraction bases in this sequence may vary. +\end{theorem} + +This is \cite[Theorem~11.3]{KahlerAuxiliary}. We use it for the elementary +sequences on strong models. Full termination for four-dimensional gdlt +data will be deduced in Section~\ref{sec:completion}. + +\paragraph{Scope of the auxiliary inputs.} +The results recalled above use the projective relative arguments in +\cite[Sections~9--11]{KahlerAuxiliary}, together with its low-place +calculation. Relative continuation is Proposition~9.7 there; the finite +run over a fixed bimeromorphic base in Proposition~9.9 uses the local +finite-generation argument of Lemma~9.8, and exact extraction in +Proposition~9.11 uses that finite run. The special-termination and gdlt +modification arguments in Section~11 form an induction on dimension, +using the threefold termination theorem of Section~10. These proofs do +not invoke the canonical bundle formula or the absolute +supporting-contraction induction of Section~6. Indeed, Section~6 uses +the threefold termination theorem as an input to its good-model +construction; the dependency is in that direction. Thus the use of +\cite{KahlerAuxiliary} here does not require its absolute contraction or +minimal-model theorems. + +The imports from \cite{CanonicalKahler} are likewise restricted to its +common-model construction (Proposition~2.1), analytic negativity +(Lemma~2.2), and terminal smoothness in codimension two (Lemma~2.3). +Its fourfold termination theorem is not an input. All relative +constructions above retain their stated strong-factoriality hypotheses; +these are not additional hypotheses on the given sequence in +Theorem~\ref{thm:main}. + +\section{Birational comparisons} +\label{sec:comparisons} + +We compare the adjoints on the two sides of a small diagram and at the +ends of a finite relative program. The comparisons locate exactly which +global places acquire larger discrepancies. They also give a projective +morphism from a nef end to a prescribed ample model, with the nef adjoint +equal to the pullback of the ample adjoint. We then record the homological +ranks that count contracted divisors and surfaces. +All divisor equalities in this section are equalities of actual rational +divisors, with the compatible canonical representatives and the fixed +b-divisor $\M$ of Section~\ref{sec:preliminaries}. + +For a projective morphism, a rational Cartier divisor is called +\emph{relatively nef} here if it has nonnegative degree on every compact +irreducible curve contracted by the morphism. We use the analytic +negativity lemma in the following precise form +\cite[Lemma~2.2]{CanonicalKahler}: if $r:V\to T$ is a projective +bimeromorphic morphism of normal complex spaces, $H$ is a +$\Q$-Cartier divisor on $V$, $-H$ is relatively nef, and $r_*H\geq0$, +then $H\geq0$. Neither compactness nor a singularity hypothesis is +part of this input. A divisor is \emph{exceptional over $T$} if every +prime in its support has image of codimension at least two in $T$. + +We will also use two consequences of normality. An effective +$\Q$-Cartier divisor pulls back effectively under a dominant morphism: +after clearing its index, a local meromorphic equation with no +divisorial poles is holomorphic on a normal space. Such a divisor has +nonnegative degree on a compact curve not contained in its support, +by restricting its effective section to the normalization of the curve. + +\subsection{Common models and the nef part} + +The projectivity in the hypotheses permits all comparisons in a finite +part of the argument to be made on one compact K\"ahler resolution. +We give the construction for the diagrams used here; compare the +common-model construction of \cite[Proposition~2.1]{CanonicalKahler}. + +\begin{lemma}[Common models with projective maps]\label{lem:common-projective-models} +Let a finite collection of normal irreducible compact K\"ahler spaces +be joined, with compatible bimeromorphic identifications, by finitely +many projective bimeromorphic morphisms and their inverses. Suppose +that a fixed nef b-divisor is carried by a projective bimeromorphic +morphism $X'\to X$ to one of these spaces, with analytically nef +$\Q$-Cartier trace $M'$ on $X'$. Then there is a +smooth compact K\"ahler space $W$ with compatible projective +bimeromorphic morphisms to every space in the collection and to $X'$. +The resolution may simultaneously principalize finitely many specified +generically nonzero coherent ideals and resolve finitely many specified divisors. Its trace +$M_W$ is the pullback of $M'$ and is analytically nef. +\end{lemma} + +\begin{proof} +For a diagram $T\to Z\leftarrow T^+$, take the reduced component of +$T\times_ZT^+$ containing the graph over the common isomorphism open. +Its projections are projective, and finite normalization preserves +projectivity. Adjoin the remaining spaces and the carrier one at a +time by the same construction. Resolving the resulting dominating +component gives a common smooth model. Analytic resolution and +principalization allow the stated simultaneous choices by projective +modifications; see \cite[Theorems~1.6, 1.10 and 13.2(1)]{BierstoneMilman1997}. +Base change, restriction to a closed analytic subspace, finite +normalization, and composition preserve projectivity. For composition +in the present compact setting, one can choose a uniform sufficiently +large twist of a relative ample bundle by the pullback of the next one. +This also proves compatibility with any finite chain of the small +diagrams and divisorial contractions considered below. + +A smooth space projective over a compact K\"ahler space is compact +K\"ahler: a relative ample bundle supplies positivity in the fiber +directions, and adding a sufficiently large multiple of a pulled-back +K\"ahler form supplies positivity in all directions. Finally, choose +K\"ahler classes on $X'$ converging to $c_1(M')$. Their pullbacks to +$W$ have semipositive representatives. Adding positive multiples +tending to zero of a fixed K\"ahler class on $W$ gives K\"ahler classes +converging to $c_1(M_W)$. Thus $M_W$ is analytically nef. +\end{proof} + +In particular, $M_W$ has nonnegative degree on every compact curve. +For an arbitrary global place, a further common proper model with a +model carrying that place suffices to compare coefficients. This last +model need not be projective: projectivity is used to establish an +effective divisor on a common model, after which its pullbacks remain +effective on every higher proper model. + +\begin{lemma}[Effective nef defect]\label{lem:nef-defect} +Let $T$ be a normal compact K\"ahler model, and let $r:W\to T$ be a +projective bimeromorphic morphism from a normal compact K\"ahler space +$W$ dominating the fixed projective carrier of $\M$. Assume that +$M_T$ is $\Q$-Cartier. Then +\begin{equation}\label{eq:nef-defect} + J_{W/T}:=r^*M_T-M_W\geq0 +\end{equation} +is an exceptional $\Q$-Cartier divisor over $T$. If $s:W'\to W$ is +a higher normal model, then $J_{W'/T}=s^*J_{W/T}$. +\end{lemma} + +\begin{proof} +The trace definition gives $r_*J_{W/T}=0$. On an $r$-contracted curve, +$-J_{W/T}=M_W-r^*M_T$ has the same degree as $M_W$, hence has +nonnegative degree by projection formula from the nef carrier. +Analytic negativity gives $J_{W/T}\geq0$. +The final identity follows from functoriality of pullback and the fact +that the b-divisor descends on $W$. +\end{proof} + +The next lemma explains why hypotheses stated for global generalized +places give the local ordinary singularity conditions needed later. +It is here that effectivity of the boundary and of the nef defect +enters the singularity comparison. The global Weil and strong +$\Q$-factoriality conventions ensure the Cartier hypotheses below for +the respective models in the proof, since the divisor traces have +finite support. + +\begin{lemma}[From global generalized discrepancies to local singularities] +\label{lem:ordinary-singularities} +Let $T$ be a normal compact K\"ahler space, let $B$ be an effective +rational divisor of finite support, and let $\M$ have analytically nef +rational data on a projective carrier. Assume that $K_T$, $B$, and +$M_T$ are $\Q$-Cartier. +If every global generalized log discrepancy of $(T,B+\M)$ is +nonnegative, respectively positive, then the same condition holds for +local analytic places. In the positive case, $T$ has ordinary klt +singularities locally. If the global generalized discrepancies are +positive and every global place exceptional over $T$ has generalized +log discrepancy strictly greater than one, +then $T$ has ordinary terminal singularities locally. In dimension +four the latter conclusion implies $\dim\Sing T\leq1$. +\end{lemma} + +\begin{proof} +Choose a smooth log resolution $r:W\to T$, projective over $T$ and carrying $\M$, +with divisorial exceptional locus and simple normal crossing support +for all divisors in the crepant equation +\[ + K_W+\Delta_W+M_W=r^*(K_T+B+M_T). +\] +Such a simultaneous resolution is available by +Lemma~\ref{lem:common-projective-models}. The assumed inequalities +give coefficients at most one, respectively strictly below one, for +every global prime of $\Delta_W$. The same bounds hold on their local +branches. On any further local model the nef part is pulled back from +$W$, so its generalized discrepancies are the ordinary discrepancies +of the simple normal crossing subpair $(W,\Delta_W)$. The simple +normal crossing discrepancy criterion proves the asserted local +generalized inequalities, including when some coefficients of +$\Delta_W$ are negative. + +Put $J=J_{W/T}$. The ordinary crepant boundary for $(T,0)$ is +\begin{equation}\label{eq:ordinary-crepant-boundary} + \Delta_W^{(0)}=\Delta_W-r^*B-J, + \qquad K_W+\Delta_W^{(0)}=r^*K_T. +\end{equation} +Both $r^*B$ and $J$ are effective. After resolving their joint support +as above, every coefficient of $\Delta_W^{(0)}$ is therefore strictly +below one in the positive case. The same local simple normal crossing +criterion gives ordinary klt singularities. + +For the terminal assertion, the relative canonical divisor is +exceptional, and at an exceptional prime $R$ of $W$ its coefficient is +\[ + \operatorname{coeff}_R(K_W-r^*K_T) + =a(R;T,B+\M)-1+\operatorname{coeff}_R(r^*B+J)>0. +\] +These positive coefficients persist on every local branch. A local +place exceptional over the smooth space $W$ has ordinary log +discrepancy at least two over $W$: the Jacobian determinant of a smooth +model carrying it has positive integral order along an exceptional +divisor. Its discrepancy over $T$ adds the nonnegative order of +$K_W-r^*K_T$, and hence remains greater than one. Local exceptional +places already represented by divisors on $W$ satisfy the displayed +strict inequality. Thus $T$ is locally ordinary terminal. +For a normal complex fourfold with a rational canonical line bundle, +local ordinary terminality implies smoothness in codimension two by +\cite[Lemma~2.3]{CanonicalKahler}, giving the last assertion. +\end{proof} + +For later calculations, the same equations give, for every global place +$E$ followed on a common higher model, +\begin{equation}\label{eq:generalized-ordinary-discrepancy} + a(E;T,B+\M) + =a(E;T,0)-\ord_E(r^*B)-\ord_E(J_{W/T}). +\end{equation} +The orders on the right mean coefficients after pullback to that model. +They are nonnegative under the hypotheses of +Lemma~\ref{lem:ordinary-singularities}. + +\subsection{Small diagrams and finite programs} + +We now locate the entire region in which a small step changes +discrepancies. All exceptional loci and their images in this +subsection are given their reduced structures. We use the graph method +of \cite[Lemma~2.1]{ProjectiveLCFourfolds} and prove the needed analytic +comparison, with the fixed b-divisor, below. + +\begin{lemma}[Comparison for an arbitrary small diagram] +\label{lem:small-comparison} +Let +\[ + T\xrightarrow{\ f\ }Z\xleftarrow{\ f^+\ }T^+ +\] +be a diagram of normal irreducible compact K\"ahler fourfolds in which +$f$ and $f^+$ are projective small bimeromorphic morphisms with +connected fibers, and both are nonisomorphisms. Let $(T,B_T+\M)$ and +$(T^+,B_{T^+}+\M)$ have effective rational boundaries related by +strict transform and the same fixed rational b-divisor. Transport the +canonical representatives by the identification of prime divisors, +and assume that the actual adjoints $D_T$ and $D_{T^+}$ are +$\Q$-Cartier, with $-D_T$ $f$-ample and $D_{T^+}$ $f^+$-ample. + +The exceptional images of $f$ and $f^+$ are equal. If their common +image is $A$, then +\begin{equation}\label{eq:small-loci} + L:=\Exc(f)=f^{-1}(A),\qquad + L^+:=\Exc(f^+)=(f^+)^{-1}(A), +\end{equation} +the complements are isomorphic, and +\begin{equation}\label{eq:small-dimensions} + \dim L,\dim L^+\leq2,\qquad \dim A\leq1, + \qquad \dim L+\dim L^+\geq3. +\end{equation} + +Let $G$ be the normalization of the main graph, with projections +$p:G\to T$, $q:G\to T^+$ and $h=f\circ p=f^+\circ q$. Then the +actual $\Q$-Cartier divisor +\begin{equation}\label{eq:small-divisor} + F:=p^*D_T-q^*D_{T^+} +\end{equation} +is effective and exceptional over both $T$ and $T^+$, and +\begin{equation}\label{eq:small-support} + \Supp F=h^{-1}(A). +\end{equation} +Moreover, $F\cdot C<0$ for every irreducible curve $C$ contracted by $h$. + +For every global place $E$ over these spaces, let $\ord_E(F)$ denote +the coefficient of the pullback of $F$ on any higher proper model +dominating $G$ and carrying $E$. Then +\begin{equation}\label{eq:small-discrepancies} + a(E;T^+,B_{T^+}+\M)-a(E;T,B_T+\M)=\ord_E(F)\geq0. +\end{equation} +The inequality is strict exactly when $\cent_T(E)\subset L$, and this +condition is equivalent to $\cent_{T^+}(E)\subset L^+$. A place is +exceptional over $T$ if and only if it is exceptional over $T^+$. +\end{lemma} + +\begin{proof} +We first recall the fiber description for a proper bimeromorphic +morphism $v:V\to S$ of normal spaces. Its positive-dimensional-fiber +locus is closed analytic. Over its complement the map is finite +locally on $S$, hence an isomorphism by normality. Stein factorization +shows that every fiber is connected, because its finite bimeromorphic +factor over the normal space $S$ is an isomorphism. A reduced compact +connected positive-dimensional fiber has no zero-dimensional +irreducible component: such a component would be a singleton disjoint +from the finitely many other closed components. Hence no point in +such a fiber is a local isomorphism point. The exceptional locus of +$v$ is exactly the full inverse image of its positive-dimensional-fiber +locus. + +Let $U\subset Z$ be the open set over which $f$ is an isomorphism. +On $U$, $D_T$ defines a $\Q$-Cartier divisor $D_U$. The actual Weil +coefficients of the two adjoints agree under the identification of +prime divisors. Since $f^+$ is small, it follows that +$D_{T^+}|_{(f^+)^{-1}U}=(f^+)^*D_U$. A positive-dimensional projective +fiber over $U$ would contain a curve on which this divisor has degree +zero, contrary to $f^+$-ampleness. Thus $f^+$ is an isomorphism over +$U$. Interchanging the two sides and using $f$-ampleness of $-D_T$ +gives the reverse inclusion of the isomorphism opens. This proves +the equality of exceptional images and \eqref{eq:small-loci}. +Smallness gives $\dim L,\dim L^+\leq2$. Over a general point of each +component of $A$ the fiber has dimension at least one, so the +fiber-dimension theorem gives $\dim A\leq1$. + +The graph projections are projective and surjective, and the map from +$G$ to its component in $T\times_ZT^+$ is finite. A prime divisor of +either side maps to a prime divisor of $Z$ by smallness. On the graph +it therefore corresponds to the same prime place on the other side, +with the same adjoint coefficient. Consequently $p_*F=q_*F=0$. +On a $p$-contracted curve, $-F$ has the degree of $q^*D_{T^+}$, which +is nonnegative. Analytic negativity gives $F\geq0$. + +For a curve $C$ contracted by $h$, the projection formula and the two +ample signs give +\[ + -F\cdot C=(-D_T)\cdot p_*C+D_{T^+}\cdot q_*C>0. +\] +Here an image that is a point contributes zero. At least one image is +a curve, because the finite map to the fiber product cannot contract +$C$ to a point. Thus at least one summand is strictly positive. + +The support of $F$ is contained in $h^{-1}(A)$, since both projections +identify the common isomorphism open and the adjoints agree there. +Conversely, take $x\in h^{-1}(A)$ and write $z=h(x)$. The map +$h:G\to Z$ is proper bimeromorphic, so its fiber over $z$ is connected. +It is projective and positive-dimensional: its projection to the +positive-dimensional fiber $f^{-1}(z)$ is surjective. The fiber +description above places $x$ on a positive-dimensional irreducible +component. Successive projective hyperplane cuts through $x$ give an +irreducible curve $C$ in that fiber through $x$. If $x$ were outside +$\Supp F$, then $C$ would not be contained in the effective +$\Q$-Cartier divisor $F$, so $F\cdot C\geq0$. The preceding strict +inequality excludes this. Hence \eqref{eq:small-support} holds. + +Follow a global place $E$ on a common proper model dominating $G$ and +the nef carrier. Subtracting its two crepant equations cancels the +same trace of $\M$ and gives \eqref{eq:small-discrepancies}. The order +of an effective $\Q$-Cartier divisor is positive precisely when the +center of the place is contained in its support. Proper images of +centers give +\[ + \cent_Z(E)=f(\cent_T(E))=f^+(\cent_{T^+}(E))=h(\cent_G(E)). +\] +Together with \eqref{eq:small-loci} and \eqref{eq:small-support}, this +proves both center equivalence and the stated exact strictness +criterion. If the centers are not contained in these loci, their +general points correspond on the common open and the order is zero. +Finally, a place centered at a divisor on a normal model is that +divisorial place. Smallness identifies these prime divisors on the +two sides, proving equivalence of exceptionality. + +Since both morphisms are nonisomorphisms, $A$ is nonempty, so $F$ has +a prime divisor $R$ in its support. The graph is a fourfold, hence +$\dim R=3$. Its finite map to the graph component has image in +$L\times_ZL^+$, whence +\[ + 3\leq\dim(L\times_ZL^+)\leq\dim L+\dim L^+. +\] +This is the remaining inequality in \eqref{eq:small-dimensions}. +\end{proof} + +The discrepancy statement preserves generalized lc and generalized +klt inequalities along a small step. It also preserves generalized +terminality, because the same places are exceptional on both sides. +The isomorphism-open argument did not use nontriviality. In the normal +irreducible compact K\"ahler fourfold setting of +Lemma~\ref{lem:small-comparison}, if an elementary small step is initially specified by a nonisomorphic +negative contraction, a small positive morphism, and the stated Cartier +and ample hypotheses, that argument forces the positive morphism to be +nonisomorphic as well. Its fibers are connected by normality and Stein +factorization, so Lemma~\ref{lem:small-comparison} applies. +For a finite program we need, in addition, to retain the location of +the accumulated correction at its end. + +\begin{lemma}[Comparison along a finite negative program] +\label{lem:program-comparison} +Let $Y_0\dashrightarrow\cdots\dashrightarrow Y_m$, with $m\geq0$, be +a finite sequence of normal irreducible compact K\"ahler fourfolds with +$\Q$-Cartier adjoints $D_j=K_{Y_j}+B_j+M_{Y_j}$. Suppose the effective +rational boundaries are transported by pushforward, the canonical +representatives are compatible, and the same b-divisor with a projective +carrier is used throughout. Assume +each step is either a small diagram satisfying +Lemma~\ref{lem:small-comparison}, or a projective bimeromorphic +divisorial contraction $v_j:Y_j\to Y_{j+1}$ such that +$D_{j+1}=(v_j)_*D_j$ and $-D_j$ is $v_j$-ample. These steps extract +no prime divisors. On a smooth common model $W$ with projective maps +to every $Y_j$ and to the carrier, write $r_j:W\to Y_j$. Then +\begin{equation}\label{eq:program-comparison} + r_0^*D_0-r_m^*D_m=E,\qquad E\geq0,\qquad (r_m)_*E=0. +\end{equation} +Every global discrepancy is nondecreasing along the run. If a prime +divisor is contracted in a divisorial step, its discrepancy increases +strictly at that step, and its discrepancy at the end is strictly +larger than before that step. +\end{lemma} + +\begin{proof} +For a divisorial step put +$E_j=D_j-v_j^*D_{j+1}$. It is exceptional over $Y_{j+1}$ and has +strictly negative degree on every $v_j$-contracted curve. Negativity +gives $E_j\geq0$. Every point of an exceptional fiber lies on a curve +in that fiber, by the connected projective fiber argument in the proof +of Lemma~\ref{lem:small-comparison}. The negative degree therefore +forces that point into $\Supp E_j$. In particular the coefficient of +$E_j$ at each contracted prime is positive. Subtracting crepant +equations gives nondecreasing discrepancies and this strict increase. +For a small step the same assertions, with an effective correction +exceptional over its output, follow from +Lemma~\ref{lem:small-comparison}. + +Pull the corrections of all steps to $W$ and add them. This gives the +effective divisor in \eqref{eq:program-comparison}. Each prime in a +summand is exceptional over that step's output, and remains exceptional +over every later output. Indeed, if that place became a prime divisor +on a later normal model, that prime would have a strict-transform prime +on each earlier model, since none of the intervening steps extracts divisors. +This contradicts its earlier exceptionality. Thus the sum is +exceptional over $Y_m$. Its nonnegative coefficients also show that +a strict increase from a contracted prime cannot be canceled later. +For $m=0$ the correction is zero and the assertions are immediate. +\end{proof} + +\subsection{A nef end and a prescribed ample model} + +An effective correction exceptional over the end is the form needed to +compare a finite program with a prescribed positive side of a diagram. +The next argument uses the effective-pushforward form of negativity, +since the two corrections need not have the same exceptional primes; +compare \cite[Lemma~2.5]{ProjectiveLCFourfolds} in the projective setting. + +\begin{lemma}[Nef and ample models]\label{lem:nef-ample} +Let $Y_0$, $Y$, and $T_+$ be normal irreducible compact K\"ahler spaces +with projective bimeromorphic morphisms to a normal compact K\"ahler +space $S$. On a smooth common model $W$ over $S$, projective over these +spaces, let $P_0$, $P$, and $P_+$ be the pullbacks of respective +$\Q$-Cartier divisors $D_0$, $D_Y$, and $D_+$. Suppose that +\[ + P_0=P+E_Y=P_++E_+, +\] +where $E_Y\geq0$ is exceptional over $Y$ and $E_+\geq0$ is exceptional +over $T_+$. If $D_Y$ is nef over $S$ and $D_+$ is ample over $S$, +then $P=P_+$ as actual divisors. The induced bimeromorphic map is a +projective morphism $\varphi:Y\to T_+$ over $S$, and +$D_Y=\varphi^*D_+$. +\end{lemma} + +\begin{proof} +Write $r:W\to Y$ and $t:W\to T_+$, and put +$H=P-P_+=E_+-E_Y$. Then $r_*H=r_*E_+\geq0$. On an $r$-contracted +curve, $-H$ has the degree of $P_+$, which is nonnegative because +the curve lies over a point of $S$. Negativity gives $H\geq0$. +Likewise $t_*(-H)=t_*E_Y\geq0$, while $H$ is $t$-nef because $P$ comes +from an $S$-nef divisor. Negativity applied to $-H$ gives $H\leq0$. +Thus $P=P_+$. + +For a curve $C$ in an $r$-fiber, equality gives +$t^*D_+\cdot C=P\cdot C=0$. The image $t(C)$ lies in an $S$-fiber, +where $D_+$ is ample, so $t(C)$ is a point. Every $r$-fiber is +projective and connected. If an irreducible component of one such +fiber had positive-dimensional image under $t$, a curve in that +projective image and projective hyperplane cuts of its inverse image +would supply a curve on which $t$ is nonconstant. Thus each component +maps to a point, and connectedness makes those points equal. The map +$t$ is constant on every $r$-fiber. + +The reduced image of $(r,t):W\to Y\times_ST_+$ is a proper analytic +graph with one-point fibers over $Y$. Its projection to $Y$ is +therefore finite and bimeromorphic, hence an isomorphism by normality +of $Y$. This gives the morphism $\varphi$. Its graph is a closed +subspace of $Y\times_ST_+$, whose projection to $T_+$ is projective +by base change from $Y\to S$; hence $\varphi$ is projective. Finally, +pushing the equality $P=P_+$ to $Y$ gives +$D_Y=\varphi^*D_+$ as actual divisors. +\end{proof} + +\subsection{Ranks of analytic cycle classes} + +The small-diagram comparison forces a surface on at least one side of +every step. The following ranks count the steps after the positive +side has no exceptional surface. They also count divisorial steps in +the auxiliary programs. Their role is the analytic counterpart of the +surface-cycle rank in the terminal fourfold argument of +\cite[Theorem~5-1-15 and Lemma~5-1-17]{KawamataMatsudaMatsuki1987}. + +For a compact complex analytic space $V$ and an integer $k\geq0$, put +\[ + \begin{split} + \mathcal C_k(V)&=\operatorname{span}_{\Q} + \{[Q]\in H_{2k}(V,\Q): + Q\subset V\text{ irreducible compact analytic},\ \dim Q=k\},\\ + c_k(V)&=\dim_{\Q}\mathcal C_k(V). + \end{split} +\] +Fundamental classes use the complex orientation of the regular loci. +Finite compatible triangulations of compact analytic spaces make these +ranks finite. If $V$ is compact K\"ahler, the class of every such $Q$ +is nonzero, including when $V$ or $Q$ is singular: for a K\"ahler form +$\omega$, +\[ + \langle[\omega]^k,[Q]\rangle=\int_{Q_{\mathrm{reg}}}\omega^k>0. +\] +The same observation applies to a closed analytic subspace of a +compact K\"ahler space. We use ordinary homology on compact spaces +and Borel--Moore homology on open complements. + +\begin{lemma}[Loss of analytic cycle classes]\label{lem:cycle-loss} +Let $k\geq0$ be an integer, and let $X\dashrightarrow Y$ be a +bimeromorphic transformation of compact K\"ahler spaces represented by +a proper bimeromorphic diagram. +Suppose it identifies +\[ + U=X\setminus A\simeq Y\setminus B, +\] +where $A$ and $B$ are closed analytic subspaces and $\dim B0$ and a finite set $\mathcal I$ of global +places such that, at every remaining index $i$, +\begin{equation}\label{eq:stable-low-places} + \begin{gathered} + a_i(E)\geq\varepsilon\quad\text{for every global place }E, + \\ + \mathcal I= + \{E:E\text{ is exceptional over }X_i,\ a_i(E)\leq 1\}. + \end{gathered} +\end{equation} +There are projective bimeromorphic crepant morphisms +\begin{equation}\label{eq:terminal-junction} + \begin{gathered} + h_i:(Y_i,\Theta_i+\M)\longrightarrow (X_i,B_i+\M), + \\ + K_{Y_i}+\Theta_i+M_{Y_i}=h_i^*D_i, + \end{gathered} +\end{equation} +with the following properties. +\begin{enumerate} +\item Each $Y_i$ is a strong normal irreducible compact K\"ahler fourfold, +$\Theta_i$ is effective, and +$(Y_i,\Theta_i+\M)$ is generalized terminal. The exceptional prime +divisors of $h_i$ represent exactly the places in $\mathcal I$. +\item For $E\in\mathcal I$, let $S_{i,E}$ be its prime on $Y_i$. Define +\begin{equation}\label{eq:junction-coefficient-change} + \Theta_i'= + \Theta_i-\sum_{E\in\mathcal I} + \bigl(a_{i+1}(E)-a_i(E)\bigr)S_{i,E}. +\end{equation} +Starting with $(Y_i,\Theta_i'+\M)$, a finite, possibly empty, sequence +of small elementary steps over $Z_i$ ends at +$(Y_{i+1},\Theta_{i+1}+\M)$. All its models are strong normal irreducible +compact K\"ahler fourfolds, all its pairs are generalized +terminal, and its boundary and nef data are transported as in an elementary +program. In particular, every global place is exceptional over one model +of this connecting sequence if and only if it is exceptional over all of +them. +\item There is one finite label set $\mathcal H$ for the primes supplied by +$\mathcal I$ and by the components of $B_0$. Write $S_h$ for the current +strict transform of a label and $b_h$ for its current coefficient. Labels +are retained when their coefficient is zero. On the entire chain of +coefficient changes and small steps, +\[ + \Theta=\sum_{h\in\mathcal H}b_hS_h, + \qquad 0\leq b_h<1, +\] +and every $b_h$ is nonincreasing. Call a label \emph{varying} if its +coefficient sequence is not eventually constant, and \emph{fixed} +otherwise. After a further tail is chosen, all fixed coefficients are +constant. Every varying label comes from $\mathcal I$ and has positive +coefficient at every remaining stage. +\end{enumerate} +\end{proposition} + +Figure~\ref{fig:terminal-bridge} records the two kinds of change between +crepant junctions. The difficulty in Section~\ref{sec:difficulty} will +be compared across both upper moves. +\begin{figure}[ht] +\centering +\begin{tikzcd}[column sep=3.2cm,row sep=large] + (Y_i,\Theta_i) \arrow[r,Rightarrow,"\Theta_i'\leq\Theta_i"] + \arrow[d,"h_i"'] & + (Y_i,\Theta_i') \arrow[r,dashed,"\text{finite small program}"] & + (Y_{i+1},\Theta_{i+1}) \arrow[d,"h_{i+1}"] \\ + X_i \arrow[r,"f_i"'] & Z_i & X_{i+1}\arrow[l,"f_i^+"] +\end{tikzcd} +\caption{The bridge for one downstairs flip. The first upper arrow changes +the boundary on the same space; it is not a morphism. The second denotes a +finite, possibly empty, sequence of small elementary steps over $Z_i$. +The two vertical maps are crepant for the displayed endpoint boundaries, +and the b-divisor $\M$ is fixed throughout.} +\label{fig:terminal-bridge} +\end{figure} + +\begin{proof} +By Lemma~\ref{lem:small-comparison}, discrepancies do not decrease, and a +place is exceptional over $X_i$ exactly when it is exceptional over +$X_{i+1}$. Consequently the sets +\[ + \mathcal I_i=\{E:E\text{ is exceptional over }X_i,\ a_i(E)\leq1\} +\] +form a decreasing sequence. Proposition~\ref{prop:low-places} makes the +first of them finite and gives a positive lower bound for all initial +discrepancies. Monotonicity preserves that bound. A decreasing sequence +of subsets of a finite set stabilizes, which gives +\eqref{eq:stable-low-places}. We reindex this tail. + +If $\mathcal I$ is empty, take the identity as the first junction. +Otherwise apply Proposition~\ref{prop:extraction} at the first index to +extract exactly $\mathcal I$. Its hypotheses hold: the model is strong, +the pair is generalized klt with rational effective boundary, and the +fixed nef data are carried on a higher model projective over $X_i$. +The resulting morphism is projective bimeromorphic and has a strong normal +irreducible compact K\"ahler source. Crepancy gives the coefficient +$1-a_i(E)\in[0,1-\varepsilon]$ on an extracted prime; all other boundary +components are strict transforms of $B_i$. Thus the crepant boundary is +effective. Notice that a place with $a_i(E)=1$ is extracted with coefficient +zero. + +Any place exceptional over this source is exceptional over $X_i$: a prime +on $X_i$ has a strict transform on every proper birational model. Such a +place is not one of the extracted primes, so its discrepancy is strictly +greater than $1$ by \eqref{eq:stable-low-places}. Crepancy and the positive +lower bound prove generalized terminality. This constructs the first +junction. + +Suppose the junction over $X_i$ has been constructed. The coefficient of +$S_{i,E}$ changes in \eqref{eq:junction-coefficient-change} from +$1-a_i(E)$ to $1-a_{i+1}(E)$. Both are nonnegative because $E$ belongs to +the stabilized set at both indices, and the latter is no larger than the +former. The divisor subtracted from $\Theta_i$ is effective and +$\Q$-Cartier on the strong model $Y_i$. Its pullback to a higher model is +effective; hence subtracting it only increases discrepancies. In +particular, $\Theta_i'$ remains effective and +$(Y_i,\Theta_i'+\M)$ remains generalized terminal. Set +\[ + D_i'=K_{Y_i}+\Theta_i'+M_{Y_i}. +\] + +We first compare this adjoint with the positive model downstairs. By +Lemma~\ref{lem:common-projective-models}, choose a smooth common +model $W$, carrying $\M$, with projective maps +$q:W\to Y_i$ and $r:W\to X_{i+1}$, all over $Z_i$, and put +\begin{equation}\label{eq:junction-positive-comparison} + F=q^*D_i'-r^*D_{i+1}. +\end{equation} +The coefficient change makes $q_*F=0$. Indeed, at a prime $S_{i,E}$ with +$E\in\mathcal I$, the coefficient of the crepant boundary computed from +$X_{i+1}$ is $1-a_{i+1}(E)$, the new coefficient in $\Theta_i'$. +Every other prime on $Y_i$ corresponds, by smallness downstairs, to a +prime on $X_{i+1}$ and has its transported boundary coefficient. The +canonical representatives and the trace of the same b-divisor agree in +this calculation. On a curve contracted by $q$, the divisor $-F$ has +nonnegative degree: $q^*D_i'$ has degree zero and $r^*D_{i+1}$ is pulled +back from the $f_i^+$-ample divisor $D_{i+1}$. The negativity +lemma therefore gives $F\geq0$. Moreover every prime on $X_{i+1}$ is +represented on $Y_i$, where the coefficient of $F$ is zero. Thus $F$ is +exceptional over $X_{i+1}$. + +Use the finite generalized klt part of +Proposition~\ref{prop:relative-program} for $D_i'$ over $Z_i$. The map +$Y_i\to Z_i$ is projective bimeromorphic to a normal compact K\"ahler +base, the source is strong and generalized klt, and a common higher model +projective over $Y_i$ carries the fixed data with the +required relative nefness. The proposition supplies a finite elementary +program ending at a model $\overline Y$ whose adjoint $\overline D$ is nef +over $Z_i$. On a further common model, write again $q$ for the map to +$Y_i$ and $\bar q$ for the map to $\overline Y$. +Lemma~\ref{lem:program-comparison} gives +\[ + q^*D_i'=\bar q^*\overline D+G, + \qquad G\geq0\text{ exceptional over }\overline Y. +\] +Together with \eqref{eq:junction-positive-comparison}, these are the two +effective comparisons required by Lemma~\ref{lem:nef-ample}. That lemma +gives a projective morphism $h_{i+1}:\overline Y\to X_{i+1}$ and the +actual crepant identity $\overline D=h_{i+1}^*D_{i+1}$. + +This program cannot have lost a marked prime $S_{i,E}$. Its discrepancy +immediately after the coefficient change is $a_{i+1}(E)$; by the crepant +identity its discrepancy at the end is again $a_{i+1}(E)$. If a divisorial +step had contracted it, the strict comparison for that step would have +increased this discrepancy, and subsequent comparisons could not decrease +it. Nor can the program have lost any other prime on $Y_i$. Such a prime +corresponds to a prime on $X_{i+1}$, and that prime must have a strict +transform on $\overline Y$. An elementary program extracts no prime, so a +prime once contracted cannot reappear. We have excluded every divisorial +step. All connecting steps are therefore small, and their discrepancy +comparisons preserve generalized terminality. They also preserve the +exceptionality status of every place. Smallness downstairs keeps each +marked place exceptional over $X_{i+1}$, whereas every other surviving +prime corresponds to a prime on $X_{i+1}$. Thus the surviving marked +primes are exactly the exceptional primes of $h_{i+1}$, and the end is the +required junction $Y_{i+1}$. This proves the construction by induction. The +relative program is allowed to have length zero. + +There are finitely many marked primes and finitely many components of +$B_0$. Smallness transports all of them through every connector. The +downstairs coefficients are constant, and the marked coefficients are +$1-a_i(E)$ at junctions and are changed only by +\eqref{eq:junction-coefficient-change}. They are therefore nonincreasing +and lie in $[0,1)$. For the finitely many coefficient sequences that are +eventually constant, discard a prefix after all have become constant. +Every other sequence stays positive: a nonnegative nonincreasing sequence +that reaches zero is thereafter zero. Only marked coefficients can be of +this latter type. This proves the last assertion. +\end{proof} + +All the terminal models just constructed are also ordinarily terminal by +Lemma~\ref{lem:ordinary-singularities}. In particular they are smooth in +codimension two. To control marked coefficients above a surface, we need +no bound on the number of exceptional curves in a transverse slice. +Grouping the curves by their global marked labels will give a linear +system with at most $|\mathcal I|$ unknowns and an integer matrix whose +columns are linearly independent. We will bound its entries and clear one denominator for +its right-hand side; a nonsingular minor then gives a uniform lattice for +the marked coefficients. + +\begin{proposition}[Finiteness above marked surfaces]\label{prop:surface-finiteness} +In the setting of Proposition~\ref{prop:terminal-junctions}, there is a +finite set +\[ + \mathcal A_{\mathrm{surf}} + \subset [\varepsilon,1]\cap\Q +\] +such that $a_i(E)\in\mathcal A_{\mathrm{surf}}$ whenever +$E\in\mathcal I$ and $\cent_{X_i}(E)$ is a surface. After passing to a +further tail, the following conclusions hold. +\begin{enumerate} +\item No $E\in\mathcal I$ has a surface center contained in $L_i$ on +$X_i$, or a surface center contained in $L_i^+$ on $X_{i+1}$. +\item Every varying label $S_h\subset Y_i$ satisfies +$\dim h_i(S_h)\leq1$ at every junction. +\item For an irreducible compact analytic surface contained in either $L_i$ +or $L_i^+$, the corresponding +junction morphism is an isomorphism near its general point, and the +downstairs model is smooth there. Blowing up the coherent ideal of that +surface defines a unique global generic blowup place. It is exceptional +over the corresponding downstairs model and has discrepancy strictly +greater than $1$; in particular it does not belong to $\mathcal I$. +\end{enumerate} +\end{proposition} + +\begin{proof} +We first prove the assertion about $\mathcal A_{\mathrm{surf}}$. If +$\mathcal I$ is empty, choose $\mathcal A_{\mathrm{surf}}=\varnothing$. +For the remaining case, fix a junction $\rho:Y\to X$ and a surface +$V\subset X$ which is the center of at least one marked prime. We work +near general points of $V$. + +\medskip\noindent\emph{A transverse surface and its curves.} +The exceptional image of a proper birational morphism to normal $X$ has +codimension at least two. We may avoid every other component of that +image and every center properly contained in $V$. The full inverse image +of $V$ is a proper analytic subset of the irreducible fourfold $Y$, hence +has dimension at most three. A component supplying a curve over a general +point of $V$ must therefore have dimension three and be a divisor +dominating $V$. All such divisors are marked. Components of dimension +at most two cannot supply a curve in a general fiber. These observations +also show that the general fibers over $V$ have dimension at most one. + +The singular locus of terminal $Y$ has dimension at most one, so it misses +the fiber over a general point of $V$. The singular loci of the marked +divisors, their pairwise intersections, and their intersections with +strict transforms of components of $B_0$ have dimension at most two. +Choose also a projective carrier $\sigma:W\to Y$ for the fixed nef data, +with $W$ smooth. Its nonisomorphism image has dimension at most two. None of +these subsets can contain an entire curve over a general point of $V$: +a component that dominates the surface has zero-dimensional general +fiber, and components with smaller image can be avoided. + +Here is a precise choice of the slice used below. Near a general smooth +point of $V$, lift two local coordinates on $V$ to holomorphic functions +on $X$. Take a general common level set of their pullbacks on $Y$. +Finite analytic stratifications near the proper fiber can be chosen to +respect the divisors and the subsets in the preceding paragraph. On +every stratum dominating $V$, generic smoothness makes the two pulled-back +functions submersive over general values; the images of all other strata +can be avoided. It follows, after shrinking about the fiber, that the +level set is a smooth surface $R$. The restriction of $K_Y$ to $R$ is +$K_R$, because the two slice equations trivialize its normal bundle. + +Let $C_1,\ldots,C_q$ be the reduced irreducible curves of the fiber in +$R$. Each is supplied by exactly one marked divisor, with multiplicity +one in that divisor's slice: at a general point of the curve the divisor +is smooth, the slice is transverse on it, and none of the other listed +subsets contains that curve. Write $\lambda(j)$ for its label. The same +label may supply several curves, but each marked divisor with center $V$ +supplies at least one. No $C_j$ is contained in a strict downstairs +boundary component or in the nonisomorphism image of $\sigma$. + +The restricted map on the slice is proper near this fiber, contracts the +$C_j$ to a point, and is an isomorphism off that point locally. No +surface component is mapped to the point, by the fiber dimension bound. +Pass, if necessary, to the normal Stein factor of the local target, or +equivalently to the normalization of the relevant local image. We then +have a proper modification from the smooth surface whose reduced +exceptional set is the union of these curves. Grauert's +negative-definiteness criterion +\cite[Section~4, no.~8(e), pp.~366--367]{Grauert1962} therefore applies: +the matrix +\[ + A=(C_j\cdot C_k)_{1\leq j,k\leq q} +\] +is negative definite. Put $u_j=-C_j^2\in\Z_{>0}$ and +$m_{jk}=C_j\cdot C_k\in\Z_{\geq0}$ for $j\ne k$. + +\medskip\noindent\emph{Uniform bounds for the intersection equations.} +Let $B_Y^{\mathrm{str}}$ denote the strict boundary part coming from +$B_i$. It has nonnegative intersection with every $C_j$, since it is +effective and contains no such curve. The same nonnegativity holds for +$M_Y$. Indeed, the strict transform $C_j'$ on $W$ meets the isomorphism +locus of $\sigma$. For the effective nef defect of +Lemma~\ref{lem:nef-defect}, +\[ + J=\sigma^*M_Y-M_W\geq0, +\] +the curve $C_j'$ is not contained in $\Supp J$. The projection formula, +nefness on the carrier, and effectivity then give +\[ + M_Y\cdot C_j=M_W\cdot C_j'+J\cdot C_j'\geq0. +\] +Intersect the crepant equation +$K_Y+\Theta+M_Y=\rho^*D_X$ with $C_j$. On $R$ the marked part near the +fiber is $\sum_k b_{\lambda(k)}C_k$. Adjunction for the reduced +irreducible compact curve $C_j$ gives +$K_R\cdot C_j=2p_a(C_j)-2+u_j$. We obtain +\begin{align*} + 0={}&2p_a(C_j)-2+(1-b_{\lambda(j)})u_j + +\sum_{k\ne j}b_{\lambda(k)}m_{jk} + +(B_Y^{\mathrm{str}}+M_Y)\cdot C_j\\ + \geq{}&2p_a(C_j)-2+(1-b_{\lambda(j)})u_j. +\end{align*} +Since $p_a(C_j)\geq0$ and +$1-b_{\lambda(j)}\geq\varepsilon$, it follows that +\begin{equation}\label{eq:surface-self-intersection-bound} + (1-b_{\lambda(j)})u_j\leq2-2p_a(C_j)\leq2, + \qquad u_j\leq U:=\left\lceil\frac2\varepsilon\right\rceil. +\end{equation} + +Negative definiteness now bounds each whole row of $A$, even when $q$ is +large. Fix $j$ and test its quadratic form on the vector whose $j$th +entry is $1$ and whose $k$th entry is $m_{jk}/u_k$ for $k\ne j$. Its +value is +\[ + -u_j+\sum_{k\ne j}\frac{m_{jk}^2}{u_k} + +2\sum_{\substack{k<\ell\\k,\ell\ne j}} + \frac{m_{k\ell}m_{jk}m_{j\ell}}{u_ku_\ell}<0. +\] +The last sum is nonnegative. Therefore +\begin{equation}\label{eq:surface-row-bound} + \sum_{k\ne j}\frac{m_{jk}^2}{u_k}0$ such that every +$m_{\mathrm{data}}v_j$ is integral, for every junction and surface in +this calculation. Choose it to clear the initial boundary coefficients +of this strong generalized klt sequence and to make its chosen higher nef +divisor integral Cartier. Canonical +degrees on the smooth $R$ are integral. Each strict boundary prime is +Cartier in the smooth neighborhood of the fiber, so its degree has the +chosen boundary denominator. Finally, the trace of the integral Cartier +divisor $m_{\mathrm{data}}\M$ on any model is an integral Weil divisor: +compute it by pulling back to a common higher model and pushing forward. +On the smooth neighborhood of the present fiber that trace is Cartier, +so its degree is integral as well. No assertion about its Cartier index +elsewhere is needed. + +Choose $t$ rows of $AP$ giving a nonsingular square matrix. Its +determinant is a nonzero integer with an absolute value bounded in terms +of $t$ and $C_{\mathrm{row}}$, for example by +$t^{t/2}C_{\mathrm{row}}^t$ by Hadamard's inequality. Since +$1\leq t\leq|\mathcal I|$, choose one integer $H_{\mathrm{det}}$ bounding +all these absolute values. Cramer's rule applied to +\eqref{eq:grouped-surface-equations} then gives +\[ + \begin{gathered} + q_{\mathrm{surf}}= + m_{\mathrm{data}}\operatorname{lcm}(1,2,\ldots,H_{\mathrm{det}}), + \\ + b_h\in q_{\mathrm{surf}}^{-1}\Z\qquad(h\in\mathcal H_V). + \end{gathered} +\] +The denominator is independent of the junction, the surface, and the +number of geometric curves in the slice. In particular the marked +discrepancies above surfaces belong to the finite set +\begin{equation}\label{eq:marked-surface-discrepancies} + \mathcal A_{\mathrm{surf}} + =[\varepsilon,1]\cap q_{\mathrm{surf}}^{-1}\Z. +\end{equation} +This finite set is used only to exclude recurring marked surface centers +contained in the exceptional loci. The weight denominator in +Section~\ref{sec:difficulty} will be chosen later from the actual fixed +coefficients and the initial rational data; it need not clear every element +of $\mathcal A_{\mathrm{surf}}$. + +\medskip\noindent\emph{Removing marked surface centers from the exceptional loci.} +Fix $E\in\mathcal I$. Suppose its center is a surface in $L_i$ at +infinitely many indices $i_1a_{i_k}(E). +\] +Both $a_{i_k}(E)$ and $a_{i_{k+1}}(E)$ belong to +$\mathcal A_{\mathrm{surf}}$, a contradiction. If instead its center is +a surface in $L_i^+$ at +infinitely many indices, the corresponding positive-side discrepancies +satisfy +\[ + a_{i_{k+1}+1}(E)>a_{i_{k+1}}(E)\geq a_{i_k+1}(E), +\] +again contradicting membership of $a_{i_k+1}(E)$ and +$a_{i_{k+1}+1}(E)$ in the same finite set. There are finitely many +$E\in\mathcal I$, so one tail excludes all +such occurrences on both sides. This proves assertion (1). + +On that tail, suppose a marked prime has a surface center $V$ at a +junction over $X_i$. Assertion (1) says $V$ is not contained in $L_i$. +Its general point is therefore in the common isomorphism open of the +next diagram. The next center is its strict transform, still a surface, +and Lemma~\ref{lem:small-comparison} gives equality of its two +discrepancies. Repeating the argument at every subsequent index shows +that its coefficient is constant from this index onward. A varying label +cannot have such a surface center. Its center cannot be a divisor +downstairs because it represents an exceptional place. This proves +assertion (2). + +Finally let $V$ be an irreducible compact analytic surface in one of the exceptional loci of a +remaining diagram, and use the junction on that side. If the junction +were not an isomorphism at the general point of $V$, its general fiber +there would be positive dimensional: a proper birational morphism to a +normal space is an isomorphism wherever it is finite. A component +supplying those curves over $V$ would be a divisor with center $V$, by +the dimension argument at the start of the proof. This is excluded by +assertion (1). Thus the junction is an isomorphism near a general point +of $V$. The source is ordinarily terminal and smooth in codimension two, +so the downstairs model is smooth at a general point of this surface. + +The coherent ideal of the global analytic surface $V$ has a projective +blowup. Over the dense open where the ambient model and $V$ are smooth, +this is the ordinary codimension-two blowup and has a unique prime +divisor dominating $V$. Its closure on the normalized blowup defines +a global place with center $V$, hence an exceptional place on the +downstairs model. If its discrepancy were at most $1$, it would belong +to the stabilized set $\mathcal I$, contradicting assertion (1). +This proves assertion (3). +\end{proof} + +At each remaining junction, the reduced union of the varying labels is +contracted by $h_i$ to a set of dimension at most one. This is the input +for Theorem~\ref{thm:branch}. Assertion~(3) has a separate later use: +over a surface in the positive exceptional locus of a downstairs diagram, +it supplies the global generic blowup place and the smooth downstairs +neighborhood used by the detector in Section~\ref{sec:completion}. + +\section{The branch inequality} +\label{sec:branch} + +The terminal junctions constructed in Section~\ref{sec:junctions} have +only finitely many boundary labels, but one label can have several +normalization branches along a surface. We need to control the total +number of these branches for the labels whose images downstairs are +curves or points. The estimate in this section applies to an arbitrary +union of exceptional divisors with that image-dimension bound; it does +not use a boundary or a crepant equation. + +Let $p\colon Y\to X$ be a projective bimeromorphic morphism of normal +irreducible compact K\"ahler fourfolds, with $Y$ ordinary terminal. Let +\[ + Q=\bigcup_{j=1}^{m}Q_j\subset Y +\] +be a reduced union of distinct irreducible divisors, with $m\geq0$, and assume that +$\dim p(Q)\leq1$. Write $\nu_j\colon Q_j^\nu\to Q_j$ for normalization +and $\nu\colon\coprod_jQ_j^\nu\to Q$ for their disjoint union. For an +irreducible compact analytic surface $V\subset Q$, define +\begin{equation}\label{eq:branch-count-definition} + \begin{aligned} + r_V(Q)&=\#\{F:\ F\text{ is a prime divisor of }\coprod_jQ_j^\nu, + \ \nu(F)=V\},\\ + \beta(Q)&=\sum_{\substack{V\subset Q\\ \dim V=2}}(r_V(Q)-1). + \end{aligned} +\end{equation} +The surface $V$ is counted once in the sum, regardless of which $Q_j$ +contain it. A normalization divisor mapping to $V$ with degree greater +than one counts once in $r_V(Q)$; that degree will instead enter a +pushforward map in the proof. The sum in +\eqref{eq:branch-count-definition} will be shown to have only finitely +many nonzero terms. + +Recall that a global place over $Y$ is a prime divisor on a normal proper +bimeromorphic model, with primes identified by strict transform on a +common higher model. Put +\begin{equation}\label{eq:branch-place-count} + \tau_Y(Q)=\#\left\{ + \begin{array}{@{}l@{}} + E\text{ a global place over }Y:\\[-2pt] + \cent_Y(E)\text{ is an irreducible curve contained in }\Sing Y\cap Q, + \quad a(E;Y,0)=2 + \end{array}\right\}. +\end{equation} +Here $a(E;Y,0)$ is the ordinary log discrepancy, defined intrinsically +by the natural meromorphic comparisons of rational canonical bundles +on birational models. Thus +$\tau_Y(Q)$ counts global divisors, rather than divisors visible only +over a neighborhood of a point of a singular curve. + +\begin{theorem}[Branch inequality]\label{thm:branch} +Let $p\colon Y\to X$ be a projective bimeromorphic morphism of normal +irreducible compact K\"ahler fourfolds, where $Y$ has ordinary terminal +singularities. Let $Q=\bigcup_{j=1}^{m}Q_j$ be a reduced union of +distinct irreducible divisors satisfying $\dim p(Q)\leq1$. Then the +sum defining $\beta(Q)$ and the count defining $\tau_Y(Q)$ are finite, +and +\begin{equation}\label{eq:branch-inequality} + \beta(Q)\leq\sum_{j=1}^{m}c_2(Q_j^\nu)+\tau_Y(Q). +\end{equation} +The rank $c_2(Q_j^\nu)$ is the rational rank spanned in +$H_4(Q_j^\nu,\Q)$ by the fundamental classes of compact irreducible +analytic surfaces. +\end{theorem} + +At a terminal junction, Section~\ref{sec:difficulty} will take $Q$ to +be the union of varying labels and prove that rounding can leave an +integer deficit of at most $r_V(Q)-1$ at each surface $V\subset Q$. +Thus $\beta(Q)$ bounds the total possible deficit. The same section +shows that the terms from normalization ranks and exceptional weights +together contribute at least the right-hand side of +\eqref{eq:branch-inequality}. + +The proof first relates the normalization branches to the weight-four +part of a degree-five cohomology map. A smooth resolution then confines +that part to degree-two cohomology of punctured neighborhoods along the +singular curves of $Y$. The remaining argument converts those local classes into the +global places counted by \eqref{eq:branch-place-count}. The +normalization method follows the projective branch argument of +\cite[Section~5, especially Lemma~5.2]{ProjectiveLCFourfolds}. Here the +ambient fourfolds may be nonprojective, so we supply the analytic and +Hodge-theoretic steps needed in that setting. + +Unless other coefficients are displayed, homology and cohomology in +the rest of this section have rational coefficients and refer to the +complex analytic topology. We omit $\Q$ from their notation when this +causes no ambiguity. If $Q$ is empty, +all terms in \eqref{eq:branch-inequality} vanish. We henceforth assume +$Q\ne\varnothing$. + +\subsection{Projectivity over the center and normalization relations} + +To compare normalization relations on $Q$ with cohomology that a +resolution can control, enlarge $Q$ to the full inverse image of its +center. Set +\begin{equation}\label{eq:branch-projective-loci} + C=p(Q)_{\mathrm{red}},\qquad + P=(p^{-1}C)_{\mathrm{red}}. +\end{equation} +Properness makes $C$ a compact analytic subset of $X$. Its components +are compact curves and possibly isolated points. The comparison will +use $H^5(P)\to H^5(Q)$. We first show that these spaces over $C$ are +projective even when $X$ and $Y$ are not. + +Choose on each curve component of $C$ a smooth point that lies on no +other component. Their sum is a Cartier divisor on $C$, and its line +bundle has positive degree on every curve component. The ampleness +criterion for reduced compact analytic curves says that this positivity +is exactly ampleness; isolated point components impose no condition. +One can see why singularities introduce no additional obstruction by +normalizing $C$. Write $\nu_C\colon C^\nu\to C$ for this map. Its +source is a disjoint union of compact Riemann surfaces and points, and +\[ + 0\longrightarrow\mathcal O_C\longrightarrow + \nu_{C*}\mathcal O_{C^\nu}\longrightarrow\mathcal F\longrightarrow0 +\] +has a quotient $\mathcal F$ supported at finitely many points. On the +Riemann surfaces, a sufficiently high power of the chosen line bundle +separates points and any fixed finite set of jets by Riemann--Roch. +The conditions for these sections to descend to $C$ are the finitely +many gluing conditions measured by $\mathcal F$. Applying the same +jet separation to them gives the compact-curve criterion and a +projective embedding of $C$. + +We will also use the following form of the relative-embedding +criterion. Suppose that $q\colon R\to C$ is projective and has a +global relatively ample holomorphic line bundle $H$. Compactness of +$C$ permits one common power $H^n$ for the relative embeddings on a +finite cover of $C$. Its relative sections give a closed immersion +\[ + R\hookrightarrow\mathbb P_C(q_*H^n). +\] +Here the direct image is coherent by properness, and the relative +projective space is allowed to come from a coherent sheaf. If $A$ is +an ample line bundle on $C$, then $q_*H^n\otimes A^k$ is globally +generated for $k$ sufficiently large: algebraize the coherent sheaf +on the projective $C$ by GAGA +\cite[Section~12, Theorems~1--3]{SerreGAGA} and apply the usual global-generation +criterion. A surjection from a finite free sheaf onto it embeds its +projective space, and hence $R$, in $C\times\mathbb P^N$ for some +$N$. An embedding of $C$ and the Segre embedding now make $R$ +projective. This reasoning applies to reducible spaces and to +nonreduced closed subspaces as well. GAGA algebraizes their coherent +ideals, and also algebraizes holomorphic morphisms between the resulting +projective spaces. + +Apply this argument to the base change $P\to C$. It shows that $P$ +is projective. The closed analytic subspaces $Q$ and $Q_j$ are then +projective by GAGA, and the finite normalization $Q_j^\nu\to Q_j$ +is projective (as every finite morphism is), so each $Q_j^\nu$ is +projective as well. In particular, +all these spaces and all the maps between them may now be treated as +algebraic for purposes of mixed Hodge theory. + +The normalization comparison requires a pure threefold containing $Q$. +Let $P_1$ be the reduced union of the three-dimensional components of +$P$. The preimage of the proper analytic subset $C\subset X$ is a +proper analytic subset of the irreducible fourfold $Y$, so its +components have dimension at most three. Each $Q_j$ has dimension +three and is one of those components. Thus +\[ + Q\subset P_1\subset P,\qquad \dim(P\setminus P_1)\leq2. +\] +These observations also apply when $C$ consists only of points. + +For a projective variety $R$, the mixed Hodge structure on $H_k(R)$ +is dual to that on $H^k(R)$. We write $W_\bullet$ for the weight +filtration on either group. For a map of such groups, +$\rk\Gr^W_a[\,\cdot\,]$ will mean the rank of its induced map on the +weight-$a$ graded pieces. If $R$ has dimension at most two, then +$H_4(R)$ has the fundamental classes of its irreducible surface +components as a basis. It is pure of weight $-4$: these classes are +the pushforwards of the top classes of smooth projective resolutions +of the components, which have that weight; see also +\cite[Theorem~8.2.4(ii)--(iii)]{DeligneHodgeIII}. + +\begin{lemma}[Normalization relations]\label{lem:branch-normalization} +For the spaces in \eqref{eq:branch-projective-loci}, the sum defining +$\beta(Q)$ is finite and +\begin{equation}\label{eq:branch-normalization-bound} + \beta(Q)-\sum_jc_2(Q_j^\nu) + \leq \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr]. +\end{equation} +\end{lemma} + +\begin{proof} +For a reduced pure projective threefold $R$, write +$\nu_R\colon N_R\to R$ for normalization. Choose a closed reduced +subset $A_R\subset R$ of dimension at most two containing the locus +where $\nu_R$ is not an isomorphism, and put +$F_R=(\nu_R^{-1}A_R)_{\mathrm{red}}$. The square +\[ +\begin{tikzcd} + F_R \arrow[r,hook] \arrow[d] & N_R \arrow[d,"\nu_R"]\\ + A_R \arrow[r,hook] & R +\end{tikzcd} +\] +is a proper excision square. Indeed $\nu_R$ is finite and proper and +identifies the open complements. Collapsing the two closed subsets +gives a continuous bijection $N_R/F_R\to R/A_R$ of compact Hausdorff +quotients, hence a homeomorphism. Comparing the two relative homology +sequences gives the exact sequence +\begin{equation}\label{eq:branch-normalization-excision} + H_5(R)\xrightarrow{\partial_R}H_4(F_R) + \longrightarrow H_4(A_R)\oplus H_4(N_R). +\end{equation} +All its maps are compatible with mixed Hodge structures. This follows +from algebraic functoriality and the exact sequence of relative +cohomology as a sequence of mixed Hodge structures +\cite[Propositions~8.2.2 and 8.3.9]{DeligneHodgeIII}, followed by +duality on these compact spaces. + +Take this square first for $P_1$. For $Q$, take +$A_Q=Q\cap A_{P_1}$. The normalization +$N_Q=\coprod_jQ_j^\nu$ is a union of entire, disjoint normalization +components of $N_{P_1}$. Thus these choices give a morphism of the +two squares, with $F_Q$ equal to the part of $F_{P_1}$ in those +selected components. + +For a surface component $V$ of $A_Q$, let +$F_{V,1},\ldots,F_{V,r_V(Q)}$ be the surface components of $F_Q$ +mapping onto it, and let $d_{V,\alpha}>0$ be their finite degrees over +$V$. On top homology the corresponding part of the map to $A_Q$ is +\[ + \bigoplus_{\alpha=1}^{r_V(Q)}\Q[F_{V,\alpha}] + \longrightarrow\Q[V],\qquad + \sum_\alpha t_\alpha[F_{V,\alpha}] + \longmapsto\left(\sum_\alpha d_{V,\alpha}t_\alpha\right)[V]. +\] +Its kernel has dimension $r_V(Q)-1$. A surface not contained in +$A_Q$ has exactly one normalization divisor over it, since the +normalization is an isomorphism at its general point. Conversely, +finiteness and surjectivity of normalization give at least one divisor +over every surface in $Q$. It follows that +\[ + B_Q:=\ker\bigl[H_4(F_Q)\longrightarrow H_4(A_Q)\bigr], + \qquad \dim B_Q=\beta(Q). +\] +This also proves finiteness of the sum: the only possible nonzero +terms come from the finitely many surface components of $A_Q$. + +The image of $B_Q$ in $H_4(N_Q)$ is spanned by classes of compact +surfaces in its normalization components. Its rank is therefore at +most $\sum_jc_2(Q_j^\nu)$. Hence +\[ + U_Q:=\ker\bigl[B_Q\longrightarrow H_4(N_Q)\bigr] + \quad\text{satisfies}\quad + \dim U_Q\geq\beta(Q)-\sum_jc_2(Q_j^\nu). +\] +By \eqref{eq:branch-normalization-excision}, $U_Q$ is the image of +$\partial_Q$. + +The map $H_4(F_Q)\to H_4(F_{P_1})$ is injective. Both groups have +surface components as their bases, and the surfaces in $F_Q$ remain +distinct surfaces on the selected normalization components of +$P_1$. Naturality of the boundary maps therefore sends $U_Q$ +injectively into the image of $\partial_{P_1}$ on the image of +$H_5(Q)\to H_5(P_1)$. The groups $H_4(F_Q)$ and $H_4(F_{P_1})$ +are pure of weight $-4$. Strictness for the weight filtration +\cite[Theorem~2.3.5(iii)--(iv)]{DeligneHodgeII} says that +$\partial_R$ maps $\Gr^W_{-4}H_5(R)$ onto its image in the pure group +$H_4(F_R)$. Applying this to the naturality square, we obtain +\[ + \dim U_Q\leq + \rk\Gr^W_{-4}\bigl[H_5(Q)\longrightarrow H_5(P_1)\bigr]. +\] +Finally, Borel--Moore localization contains +\[ + H^{\BM}_6(P\setminus P_1)\longrightarrow H_5(P_1) + \longrightarrow H_5(P). +\] +The first group vanishes because $P\setminus P_1$ has complex +dimension at most two. The second arrow is therefore injective, +and remains injective on weight-graded pieces by strictness. Duality +between rational homology and cohomology reverses the sign of the +weight and turns the last two inequalities into +\eqref{eq:branch-normalization-bound}. +\end{proof} + +\subsection{A smooth resolution and purity over the center} + +Lemma~\ref{lem:branch-normalization} proves the normalization bound +and finiteness of $\beta(Q)$. To finish Theorem~\ref{thm:branch}, we +must prove finiteness of $\tau_Y(Q)$ and the remaining estimate +\[ + \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr]\leq\tau_Y(Q). +\] +We first show that $W_4H^5(P)$ vanishes after pullback to the resolved +inverse image. The key purity there comes from compact K\"ahler Hodge +theory on the smooth ambient resolution. + +Fix, for the rest of Section~\ref{sec:branch}, one projective +resolution with smooth source +\[ + g\colon\widetilde Y\longrightarrow Y +\] +which is an isomorphism over $Y_{\mathrm{reg}}$, whose exceptional +locus is a divisor with simple normal crossings, and which principalizes +the ideal of $\Sing Y$. Thus +\[ + \mathcal I_{\Sing Y}\mathcal O_{\widetilde Y} + =\mathcal O_{\widetilde Y}(-E_{\mathrm{sing}}), + \qquad + \Supp E_{\mathrm{sing}}=g^{-1}(\Sing Y). +\] +Smoothness is used for purity here; the conditions on the exceptional +divisor and singular ideal will be used in the curve construction. +If $Y$ is smooth, we take $g$ to be the identity and the displayed +divisor to be zero. Projective resolution and principalization, chosen +to preserve the already resolved open $Y_{\mathrm{reg}}$, give such a +choice in the analytic category +\cite[Theorems~1.10, 12.2, and 13.2(1)]{BierstoneMilman1997}. The resolution is compact +K\"ahler, and both $g$ and $pg$ have global relatively ample line +bundles. For the composite one uses a sufficiently positive twist +of a $g$-ample bundle by the pullback of a $p$-ample bundle; compactness +allows a uniform choice. Set +\[ + \widetilde P=((pg)^{-1}C)_{\mathrm{red}}. +\] +The projectivity argument over $C$ given above shows that +$\widetilde P$ is projective. + +We use intersection complexes in their perverse normalization. For +an irreducible complex analytic space $Z$ of dimension $z$ and a local +system $\mathcal E$ on a smooth dense open, $\IC_Z(\mathcal E)$ +restricts there to $\mathcal E[z]$. It is the middle extension of +that shifted local system: it has no nonzero perverse subobject or +quotient supported in a proper analytic subset of $Z$. The stalk +support condition says that on a smooth boundary stratum of dimension +$s$, +\begin{equation}\label{eq:branch-ic-stalk-bound} + \mathcal H^q(\IC_Z(\mathcal E))|_S=0\qquad(q>-s-1). +\end{equation} +Here $\mathcal H^q$ denotes ordinary cohomology sheaves, not perverse +cohomology. These conventions and the support condition are the +middle-extension axioms in +\cite[Section~2.3 and Section~3.3, Axiom {\rm[AX1]}(c)]{GoreskyMacPhersonIHII}. +They are local statements on stratified spaces, so they apply to the +analytic stratifications used here. If a new stratum of dimension $s$ +cuts the local-system open, the only stalk degree is $-z$, which is +at most $-s-1$ whenever $s2(3-z)-4. +\] +The generic nonzero stalk of $\mathcal K_{Z,i}[-i]$ is in degree +$i-z$, because a perverse middle extension on $Z$ has its generic +local system in degree $-z$. It is a direct summand of this stalk, +so +\begin{equation}\label{eq:branch-support-shift} + i-z\leq2(3-z)-4,\qquad\text{or equivalently}\qquad i+z\leq2. +\end{equation} + +We now restrict the decomposition to $C$. Suppose first that +$Z\not\subset C$, and stratify $Z\cap C$ compatibly with +$\mathcal K_{Z,i}$. A stratum $S$ has dimension $s\leq z-1$ and +$s\leq1$. Its stalk degrees for $\mathcal K_{Z,i}$ are at most +$-s-1$ by \eqref{eq:branch-ic-stalk-bound}. This remains valid under +the refinement by $C$: a stratum cut out of an old boundary stratum +inherits the stronger bound from that stratum, while a stratum cut +out of the local-system open has only degree $-z\leq-s-1$. +Compactly supported cohomology on the smooth complex $s$-fold $S$ +vanishes above degree $2s$. Thus its contribution to the +hypercohomology of $\mathcal K_{Z,i}[-i]|_C$ vanishes in degrees +greater than +\[ + i-s-1+2s=i+s-1\leq i+z-2\leq0. +\] +Filtering $C$ by its finitely many strata proves that this summand +has no degree-one hypercohomology on $C$. The full-support summand +$\IC_X$ has the same property: for each stratum of $C$, the upper +bound is $-s-1+2s=s-1\leq0$; on the smooth open its only stalk degree +is $-4$, which is smaller still. + +Only summands with $Z\subset C$ can therefore contribute in degree +one. Such a complex is supported on the closed subset $C$, so its +restriction induces an isomorphism on hypercohomology from $X$ to +$C$. The chosen global splitting and proper base change now show that +\[ + \mathbb H^1(X,K_f)=H^5(\widetilde Y) + \longrightarrow + \mathbb H^1(C,K_f|_C)=H^5(\widetilde P) +\] +is surjective. + +It remains to justify what this surjection says about weights. +Compact K\"ahler Hodge theory gives $H^5(\widetilde Y,\Q)$ its pure +Hodge structure of weight $5$. On the projective $\widetilde P$, +Deligne's mixed Hodge structure has weights at most $5$ +\cite[Theorem~8.2.4(iii)]{DeligneHodgeIII}. We verify directly that +the restriction map preserves its Hodge filtration, because the +ambient $\widetilde Y$ may be nonprojective. + +Choose a proper smooth projective hyperresolution +$\epsilon_\bullet\colon Z_\bullet\to\widetilde P$. Deligne's +construction computes the Hodge filtration on $H^5(\widetilde P)$ +from the total simplicial de Rham complex of the $Z_n$, filtered by +holomorphic form degree +\cite[Section~8.1, (8.2.1), and Proposition~8.2.2]{DeligneHodgeIII}. +The terms can be chosen projective because $\widetilde P$ is projective +and the construction can use projective resolutions and modifications. +We may use smooth forms in this complex, with the same filtration: +the Dolbeault resolutions give filtered quasi-isomorphisms from the +holomorphic de Rham complexes on the smooth $Z_n$. +A class in $F^aH^5(\widetilde Y,\C)$ has a closed smooth representative +$\eta$ whose components have holomorphic degree at least $a$, by the +K\"ahler Hodge decomposition. Pullback along the holomorphic map +$Z_0\to\widetilde P\hookrightarrow\widetilde Y$ preserves these +bidegrees. Put that pullback in simplicial degree zero of the total +complex. Its de Rham differential vanishes, and its simplicial +differential is zero because the two face pullbacks to $Z_1$ have the +same composite with the augmentation. It is therefore a cocycle in +the filtered total de Rham complex. It represents the ordinary +topological restriction by de Rham +naturality and cohomological descent. Thus restriction preserves +$F^a$ for every $a$. + +The restriction is rational on underlying cohomology. It also +preserves $W$: the source is pure of weight $5$, and $W_5$ is all of +the target. It is consequently a morphism of mixed Hodge structures. +Strictness for $W$ \cite[Theorem~2.3.5(iii)]{DeligneHodgeII}, applied +to the surjection just proved, yields +\[ + W_4H^5(\widetilde P) + =\im\bigl[W_4H^5(\widetilde Y)\to H^5(\widetilde P)\bigr]=0. +\] +Together with the upper weight bound, this proves purity of weight +$5$. Strictness here concerns mixed Hodge structures themselves and +does not require a rational polarization on the compact K\"ahler +source. +\end{proof} + +\subsection{The contribution of singular curves} + +Let $j\colon Y_{\mathrm{reg}}\hookrightarrow Y$ be the inclusion. +Ordinary terminal singularities are smooth in codimension two, so +$\Sing Y$ is a finite union of irreducible curves and points. Analytic +constructibility and a compatible Whitney stratification let us +remove a finite set of points from each singular curve $T$ so that +the remaining connected smooth curve $T^\circ$ carries the local +systems +\begin{equation}\label{eq:branch-local-systems} + \mathcal V_T=(R^2j_*\Q_{Y_{\mathrm{reg}}})|_{T^\circ},\qquad + \mathcal W_T=(R^2g_*\Q_{\widetilde Y})|_{T^\circ},\qquad + b_T=\dim H_c^2(T^\circ,\mathcal V_T). +\end{equation} +Here $\mathcal V_T$ records degree-two cohomology of punctured +neighborhoods, while $\mathcal W_T$ records that of the fixed +resolution fibers and will provide geometric representatives. +We use one finite puncture set on each $T$ for all the following +requirements. All cohomology sheaves of $Rj_*\Q$ and $Rg_*\Q$ are +locally constant on $T^\circ$, and the fibers of $g$ there have +dimension at most two. For the latter assertion, +$g^{-1}(T)$ has dimension at most three, so the general fiber has +dimension at most two; remove its exceptional dimension-jump points. +We also remove intersections of singular curves and the finitely +many points of $T\cap Q$ when $T$ is not contained in $Q$. + +For later use we impose one further condition on this same finite +puncture set. Let $E$ be a prime component of $\Exc(g)$ dominating +$T$. It is smooth because the exceptional divisor has simple normal +crossings. Its proper map to $T$ has a Stein factorization +\[ + E\longrightarrow\widehat T_E\longrightarrow T, +\] +where the first map has connected fibers and the second is finite. +The intermediate curve is normal and irreducible because $E$ is +normal and irreducible. Remove from $T$ the branch values of the +finite map and the critical values of the first map, together with +the already excluded singular points. Properness and generic +smoothness make these sets finite. Over $T^\circ$ the second map +is then a finite unramified cover; it stays connected because deleting +finitely many points from the irreducible normal curve +$\widehat T_E$ leaves it connected. The first map is a smooth proper +family with connected fibers. There are only finitely many +such $E$, so these conditions can be imposed simultaneously. They +will let us recognize global divisors after restricting to a smaller +curve domain. + +The number $b_T$ is unaffected by any further finite puncturing. +Indeed, for $t\in T^\circ$, Poincar\'e duality on the oriented real +surface $T^\circ$ gives +\[ + H_c^2(T^\circ,\mathcal V_T) + \simeq H^0(T^\circ,\mathcal V_T^\vee)^\vee + \simeq \bigl((\mathcal V_T)_t\bigr)_{\pi_1(T^\circ,t)}, +\] +where the last term is the coinvariant space for monodromy. A loop +can be perturbed away from finitely many additional points, so the +fundamental group of the further punctured curve surjects onto +$\pi_1(T^\circ,t)$. The restricted local system has the same +monodromy image, and hence the same coinvariant dimension. + +\begin{lemma}[The weight-four contribution]\label{lem:branch-cone} +With the choices in \eqref{eq:branch-local-systems}, +\begin{equation}\label{eq:branch-cone-bound} + \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr] + \leq + \sum_{\substack{T\text{ irreducible curve}\\T\subset\Sing Y\cap Q}} b_T. +\end{equation} +\end{lemma} + +\begin{proof} +Use the full-support projection in the chosen decomposition for $g$ +to form the morphism +\[ + \alpha\colon\Q_Y[4]\longrightarrow Rg_*\Q_{\widetilde Y}[4] + \longrightarrow\IC_Y. +\] +The first arrow is the natural pullback map. Both arrows restrict +to the identity on $Y_{\mathrm{reg}}$. Let $\mathcal L$ be the cone +of $\alpha$, so that +\begin{equation}\label{eq:branch-comparison-triangle} + \Q_Y[4]\xrightarrow{\alpha}\IC_Y\longrightarrow\mathcal L + \longrightarrow\Q_Y[5]. +\end{equation} +It is supported on $\Sing Y$. +Enlarge the finite puncture sets, if necessary, so that the cohomology +sheaves of $\mathcal L$ are local systems on each $T^\circ$. Analytic +constructibility permits this enlargement, and the preceding +coinvariant description shows that it does not change $b_T$. + +By proper base change, the map induced by $\alpha$ on $P$ factors as +\[ + H^5(P)\longrightarrow H^5(\widetilde P) + \longrightarrow\mathbb H^1(P,\IC_Y|_P). +\] +The first arrow comes from a holomorphic morphism between the +projective spaces $\widetilde P$ and $P$, and is algebraic by GAGA. +It therefore preserves weights. Lemma~\ref{lem:branch-resolved-purity} +shows that it kills $W_4H^5(P)$. Hence the displayed composite kills +that subspace as well; we need no weight statement about the chosen +perverse projection. The long exact sequence of +\eqref{eq:branch-comparison-triangle} on $P$ gives +\[ + W_4H^5(P)\subset + \im\bigl[\mathbb H^0(P,\mathcal L|_P)\longrightarrow H^5(P)\bigr]. +\] +Restricting the triangle from $P$ to $Q$ shows that the image of this +subspace in $H^5(Q)$ is contained in the image of +$\mathbb H^0(Q,\mathcal L|_Q)$. Passing to a weight-graded quotient +can only lower rank, and therefore +\begin{equation}\label{eq:branch-cone-rank} + \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr] + \leq\dim\mathbb H^0(Q,\mathcal L|_Q). +\end{equation} + +We estimate the last group by its strata. On a stratum of $\Sing Y$ +of dimension $s\in\{0,1\}$, the bound +\eqref{eq:branch-ic-stalk-bound} and the triangle give +\begin{equation}\label{eq:branch-cone-stalk-bound} + \mathcal H^q(\mathcal L)|_S=0\qquad(q>-s-1). +\end{equation} +The constant complex in the triangle has its only stalk cohomology +in degree $-4$; its shifted contribution to the cone is in degree +$-5$, so it cannot alter this upper bound. On a curve $T^\circ$, +the same triangle identifies $\mathcal H^{-2}(\mathcal L)$ with +$\mathcal H^{-2}(\IC_Y)$. The curve stratum has complex codimension +three in $Y$. In the middle-extension construction, attaching a +codimension-$c$ stratum retains the unshifted cohomology of $Rj_*\Q$ +through degree $c-1$. For $c=3$ this gives +\begin{equation}\label{eq:branch-cone-link} + \mathcal H^{-2}(\mathcal L)|_{T^\circ} + =\mathcal H^{-2}(\IC_Y)|_{T^\circ} + =(R^2j_*\Q)|_{T^\circ}=\mathcal V_T. +\end{equation} +This is the attaching truncation of +\cite[Section~3.1 and Section~3.3, Axiom {\rm[AX1]}(d)]{GoreskyMacPhersonIHII}, +with the shift by four from our perverse normalization. + +The restriction $\mathcal L|_Q$ is supported on the closed set +$\Sing Y\cap Q$, so its hypercohomology may be computed on that set. +The complement there of the disjoint opens $T^\circ$ +for the curves contained in $Q$ is finite. A point stratum contributes +nothing to degree-zero hypercohomology by +\eqref{eq:branch-cone-stalk-bound}. The open--closed cohomology +sequence therefore gives a surjection +\[ + \bigoplus_{T\subset\Sing Y\cap Q} + \mathbb H_c^0(T^\circ,\mathcal L|_{T^\circ}) + \longrightarrow\mathbb H^0(Q,\mathcal L|_Q). +\] +On a curve, compactly supported cohomology of a local system vanishes +above degree two. In the spectral sequence +\[ + H_c^a(T^\circ,\mathcal H^b(\mathcal L)|_{T^\circ}) + \ \Longrightarrow\ + \mathbb H_c^{a+b}(T^\circ,\mathcal L|_{T^\circ}), +\] +the stalk bound gives $b\leq-2$. The only term in total degree zero +is consequently $a=2$, $b=-2$, whose dimension is $b_T$ by +\eqref{eq:branch-cone-link}. The dimension of each degree-zero +abutment is at most $b_T$. This bound and +\eqref{eq:branch-cone-rank} prove \eqref{eq:branch-cone-bound}. +\end{proof} + +Combining Lemmas~\ref{lem:branch-normalization} and +\ref{lem:branch-cone} gives the topological reduction of the theorem: +\begin{equation}\label{eq:branch-topological-bound} + \begin{aligned} + \beta(Q)-\sum_jc_2(Q_j^\nu) + &\leq \rk\Gr^W_4\bigl[H^5(P)\longrightarrow H^5(Q)\bigr]\\ + &\leq + \sum_{\substack{T\text{ irreducible curve}\\T\subset\Sing Y\cap Q}} b_T. + \end{aligned} +\end{equation} +There are finitely many curves in this sum, and the local systems have +finite rank on curves of finite topological type, so its terms are +finite. It remains to prove that this sum is at most $\tau_Y(Q)$ and +that $\tau_Y(Q)$ is finite. + +We finish the topological part by relating the punctured cohomology +in $\mathcal V_T$ to the cohomology of the fixed resolution. This +identifies the classes that the subsequent geometric construction +will realize. + +\begin{lemma}[Resolution cohomology and punctured cohomology] +\label{lem:link-quotient} +For every singular curve $T$ with the choices in +\eqref{eq:branch-local-systems}, restriction from the resolution to +the regular locus induces a surjection of local systems +\begin{equation}\label{eq:branch-link-quotient} + \mathcal W_T\twoheadrightarrow\mathcal V_T. +\end{equation} +For every $t\in T^\circ$, its map on fibers is equivariant for the +action of $\pi_1(T^\circ,t)$ and is the map induced by restriction +\begin{equation}\label{eq:branch-link-stalk-map} + \begin{aligned} + (\mathcal W_T)_t + &\simeq H^2(g^{-1}(t)) + \simeq\varinjlim_{U\ni t}H^2(g^{-1}U)\\ + &\longrightarrow\varinjlim_{U\ni t}H^2(U\cap Y_{\mathrm{reg}}) + \simeq(\mathcal V_T)_t, + \end{aligned} +\end{equation} +where $U$ runs through sufficiently small open neighborhoods of $t$ +in $Y$ and $g^{-1}(U\cap Y_{\mathrm{reg}})$ is identified with +$U\cap Y_{\mathrm{reg}}$. +\end{lemma} + +\begin{proof} +The isomorphism of $g$ over the regular locus and adjunction give a +natural morphism +\[ + \rho\colon Rg_*\Q_{\widetilde Y}[4] + \longrightarrow Rj_*\Q_{Y_{\mathrm{reg}}}[4]. +\] +By the definition of a higher direct-image stalk and proper base +change for $g$, its degree-$-2$ map at $t$ is precisely +\eqref{eq:branch-link-stalk-map}. These are the usual sheaf +cohomology groups of constant sheaves, equal to singular cohomology +on the locally contractible analytic spaces in question. + +Let $\kappa\colon\IC_Y\to Rg_*\Q_{\widetilde Y}[4]$ be the +full-support inclusion in the chosen decomposition. Its restriction +to $Y_{\mathrm{reg}}$ is the identity. The composite +$\rho\kappa\colon\IC_Y\to Rj_*\Q[4]$ is therefore the canonical +comparison morphism: by adjunction a morphism to $Rj_*\Q[4]$ is +determined by its restriction to $Y_{\mathrm{reg}}$. The +codimension-three attaching construction used in +\eqref{eq:branch-cone-link} says that this comparison is an +isomorphism on ordinary stalk cohomology in degree $-2$ along +$T^\circ$. Its degree-$-2$ map factors through +\[ + \mathcal H^{-2}(Rg_*\Q[4])|_{T^\circ}=\mathcal W_T. +\] +Thus the degree-$-2$ map induced by $\rho$, namely +\eqref{eq:branch-link-quotient}, is surjective. It is a morphism of +the local systems in \eqref{eq:branch-local-systems}, which gives +the asserted monodromy equivariance. +\end{proof} + +\subsection{Curve contributions and global places} +\label{subsec:curve-places} + +It remains to bound the contribution \(b_T\) of each singular curve by +global divisors. We realize the relevant cohomology classes by line +bundles near a compact subset carrying all loops of \(T^\circ\). Degrees +on the fibers of a small \(\Q\)-factorialization then produce exceptional +surfaces. Retaining those loops will ensure that their blowup places +remain distinct on the fixed global resolution. + +\begin{proposition}[Global places over a singular curve]\label{prop:curve-places} +For every irreducible curve component \(T\) of \(\Sing Y\), with \(b_T\) +as in \eqref{eq:branch-local-systems} and the fixed resolution +\(g:\widetilde Y\to Y\), +\[ + b_T\ \le\ + \#\left\{ + \begin{array}{c} + E\text{ a prime component of }\Exc(g):\\ + g(E)=T,\quad a(E;Y,0)=2 + \end{array} + \right\}. +\] +In particular, the divisors counted here represent distinct global +divisorial places. +\end{proposition} + +\begin{proof} +Fix \(T\), and write +\[ + q_T:\mathcal W_T\longrightarrow\mathcal V_T +\] +for the natural quotient of Lemma~\ref{lem:link-quotient}. If \(b_T=0\) +there is nothing to prove, so assume \(b_T>0\). We may remove finitely +many further points of \(T^\circ\) whenever needed. The local systems +already defined restrict to the smaller curve, and the induced map on +fundamental groups is surjective. Thus their monodromy images and the +coinvariant dimension \(b_T\) do not change. + +We first construct sections +\[ + \sigma_1,\ldots,\sigma_{b_T}\in H^0(T^\circ,\mathcal W_T) +\] +whose images under \(q_T\) are linearly independent in every fiber of +\(\mathcal V_T\), after the permitted further finite puncturing. + +\emph{Step 1. Invariant lifts from finite monodromy.} +First we show that \(\mathcal W_T\), and therefore its quotient +\(\mathcal V_T\), has finite monodromy. Let +\(\mathcal F=\widetilde Y\times_Y T\), with its full complex-space +structure. It is projective over the compact projective curve \(T\). +A relative embedding and GAGA identify this morphism with an algebraic +projective family, including its possibly nonreduced scheme fibers. +After deleting finitely many points we may assume that +\(\mathcal F\to T^\circ\) is flat and that all +\((R^kg_*\Q)|_{T^\circ}\) are local systems. + +For \(t\in T^\circ\), put \(F_t=\mathcal F_t\). Every integral class in +\(H^2(F_t,\Z)\) lifts, by proper base change, to +\(H^2(g^{-1}U_t,\Z)\) for a sufficiently small Stein neighborhood +\(U_t\) of \(t\) in \(Y\). Terminal singularities are rational +\cite[Remark~3.8 and Theorem~3.12]{FujinoAnalyticMMP}. Hence +\(g_*\mathcal O_{\widetilde Y}=\mathcal O_Y\) and +\(R^kg_*\mathcal O_{\widetilde Y}=0\) for \(k>0\); Leray and Cartan's +Theorem~B give +\[ + H^2(g^{-1}U_t,\mathcal O_{\widetilde Y})=0. +\] +The exponential sequence therefore realizes the lifted integral class +as the first Chern class of a holomorphic line bundle on \(g^{-1}U_t\). +Its restriction to the projective scheme \(F_t\) is algebraic by the +scheme form of GAGA +\cite[Corollary~4.3 and Theorem~4.4]{RaynaudSGA1XII}. In particular, +\begin{equation}\label{eq:curve-fiber-chern} + \Pic(F_t)\otimes_{\Z}\Q + \xrightarrow{\ c_1\ } H^2(F_t,\Q)=(\mathcal W_T)_t + \quad\text{is surjective}. +\end{equation} +Here and below the cohomology of a scheme fiber means that of its +analytic topological space; nilpotents do not change it. + +We use the parameter argument of +\cite[Section~6.1, proof of Lemma~6.4]{ProjectiveLCFourfolds} to show +that a spanning set of fiber classes has finite monodromy orbits. Fix a +relatively very ample \(\mathcal O_{\mathcal F}(1)\). Every line bundle on a +fiber is a quotient of some +\(\mathcal O_{F_t}(-n)^{\oplus r}\). Letting \(n,r\), and the Hilbert +polynomial vary gives countably many relative Quot schemes of finite +type over \(T^\circ\) +\cite[Theorems~3.1--3.2]{GrothendieckHilbert1961}. In each take the +open set on which the universal quotient is invertible on the whole +pulled-back family. These open sets still contain a point representing +every fiber line bundle. Indeed the family and universal quotient are +flat over the Quot scheme, so the local criterion for flatness makes a +fiberwise locally free quotient of rank one locally free near that +fiber; properness removes the image of the complementary closed locus. + +There are countably many irreducible components of these parameter +spaces. Choose \(t\) outside the closures of the images of all +components which do not dominate \(T^\circ\). Such a point exists, +since each of those closures is a finite set and a complex curve is +uncountable. Put \(\Gamma=\pi_1(T^\circ,t)\). By +\eqref{eq:curve-fiber-chern}, choose finitely many +line bundles on \(F_t\) whose Chern classes span +\((\mathcal W_T)_t\). Each is represented on a dominating +reduced irreducible parameter component \(H\). The Chern class of the +universal bundle gives a section of the pullback of \(\mathcal W_T\) +to \(H^{\mathrm{an}}\): restrict its class on the total family to +fibers and use proper base change. + +Choose a closed point of the generic fiber of \(H\to T^\circ\). +Its residue field is a finite extension of the function field of +\(T\). Spreading this point, normalizing its closure, and deleting +finitely many base points gives a connected finite \'etale cover of a +dense open of \(T^\circ\), together with a morphism from that cover +to \(H\). The analytification of an +irreducible complex algebraic variety is path connected. A path in +\(H^{\mathrm{an}}\) from the original parameter point to a point of +this cover identifies the transported Chern class with the class +there. The subgroup fixing that sheet has finite index and fixes +this class. The inclusion of the further punctured curve, with the +projected path for change of basepoint, still surjects on \(\Gamma\). +The image of the finite-index sheet stabilizer is therefore finite +index in \(\Gamma\) and fixes the original class. Thus each of our +spanning classes has a finite orbit under \(\Gamma\). The intersection +of their stabilizers has finite index and acts trivially on +\((\mathcal W_T)_t\). The monodromy group \(G\) of \(\mathcal W_T\) +is therefore finite, as is that of \(\mathcal V_T\). + +Poincar\'e duality with local coefficients on the oriented curve gives +\[ + b_T=\dim(\mathcal V_T)_t{}_{\Gamma}. +\] +For a representation of the finite group \(G\) over \(\Q\), averaging +identifies coinvariants with invariants and makes invariants an exact +functor. The quotient \(q_T\) therefore supplies the asserted sections +\(\sigma_i\) with independent images. + +\emph{Step 2. Line bundles near a compact curve core.} +Take \(T^\circ\) noncompact, removing one more point if needed. +Recall the fixed choice made after \eqref{eq:branch-local-systems}: +for every prime component \(E\) of \(\Exc(g)\) dominating \(T\), +its Stein factor restricts to +\begin{equation}\label{eq:global-divisor-family} + E|_{T^\circ}\longrightarrow \widehat T_E^\circ\longrightarrow T^\circ, +\end{equation} +where the first map is a smooth proper family with connected fibers +and the second is a connected finite \'etale cover. Further finite +puncturing preserves these properties. Choose an ambient open +\(Y^\circ\subset Y\) in which \(T^\circ\) is closed: remove the +discarded points of \(T\), the other singular components, and their +intersection points. These choices will be used when we identify the +local divisors globally. + +Let \(h:g^{-1}T^\circ\to T^\circ\) be the restricted resolution. +The curve \(T^\circ\) has the homotopy type of a finite graph, so +cohomology of its local systems vanishes in degrees at least two. +The Leray spectral sequence for \(h\) consequently makes the edge map +\[ + H^2(g^{-1}T^\circ,\Q) + \longrightarrow H^0(T^\circ,\mathcal W_T) +\] +surjective. Choose lifts of the \(\sigma_i\). The algebraic space +\(g^{-1}T^\circ\) has finite triangulation type; after multiplying +each lift by a positive integer, it comes from a class +\(\alpha_i\in H^2(g^{-1}T^\circ,\Z)\). Replace \(\sigma_i\) by the +same multiple. Their images are still independent. + +To extend the \(\alpha_i\) simultaneously while retaining every loop +of \(T^\circ\), choose a compact curve core as follows. In the smooth +compactification of \(T^\circ\), remove small open +coordinate discs about its punctures, with disjoint closures, and denote the complement by +\(K_*\). This is a connected compact semianalytic subset of +\(T^\circ\). The inclusion of its interior into \(T^\circ\) induces +a surjection on fundamental groups. The core \(K_*\) is also Runge: every component of +\(T^\circ\setminus K_*\) runs to a missing puncture and is therefore +not relatively compact. The compact set \(g^{-1}K_*\) is +semianalytic. Continuity of cohomology on neighborhoods of this +compact set extends the restrictions of the finitely many +\(\alpha_i\) to integral classes on one open neighborhood +\(\widetilde U_0\) of \(g^{-1}K_*\) in \(\widetilde Y\). +One may use \v{C}ech cohomology for this continuity statement; +semianalytic triangulation and local contractibility identify it with +singular cohomology here. Properness of \(g\) makes +\[ + U_0=Y\setminus g(\widetilde Y\setminus\widetilde U_0) +\] +an open neighborhood of \(K_*\) with \(g^{-1}U_0\subset\widetilde U_0\). + +The closed curve \(T^\circ\subset Y^\circ\) is Stein. Siu's +Stein-neighborhood theorem, in the form +\cite[Theorem~2.1]{ForstnericStein} with empty compact set, gives a +Stein neighborhood \(\Omega\) of this curve in \(Y^\circ\). +The Runge property makes \(K_*\) holomorphically convex in +\(T^\circ\), hence also in \(\Omega\) by the paragraph preceding +that theorem. The usual holomorphic-polyhedron construction for a +convex compact in a Stein space gives a Stein neighborhood +\[ + K_*\subset U\Subset\Omega\cap U_0. +\] +Take its connected component containing \(K_*\). It is normal, +being open in \(Y\), and therefore irreducible. For the local +\(\Q\)-factorialization, Fujino's compact construction +\cite[Section~1.11]{FujinoAnalyticMMP} supplies an ambient semianalytic +Stein compact \(K'\Subset U\), with +\(K_*\subset\operatorname{int}_U(K')\), such that +\[ + K'\cap Z\ \text{has finitely many connected components} +\] +for every analytic subset \(Z\) defined on a neighborhood of +\(K'\). This is the compact condition (P4) in Fujino's condition +(P); normality of the source and Steinness of the base supply its +other ambient conditions. + +The classes just extended to \(g^{-1}U\) are Chern classes of line +bundles \(L_1,\ldots,L_{b_T}\) there, by the same rational-singularity, +Cartan, and exponential-sequence argument used above. For every +\(t\) in the interior of \(K_*\), their fiber classes are the +\(\sigma_i(t)\); hence their images under \(q_T\) remain independent. +We also need divisor representatives before making any further +modification. The sheaf \(g_*L_i\) is coherent and has rank one on +the regular open of \(U\). Cartan's Theorem~A supplies a global +section nonzero at a point of that open. Its pullback is a nonzero +section of \(L_i\), whose zero divisor is a Cartier divisor \(A_i\) +on \(g^{-1}U\) representing \(L_i\). + +\emph{Step 3. Fiber degrees and surface families.} +We will obtain at least \(b_T\) surface families by proving that the +\(b_T\) line bundles constructed below have linearly independent vectors +of fiber degrees. +Apply Fujino's small \(\Q\)-factorialization theorem +\cite[Theorem~1.24]{FujinoAnalyticMMP} to the ordinary pair +\((U,0)\), the identity \(U\to U\), and the full compact \(K'\). +The identity is projective, \(U\) is terminal and therefore klt, +and \(K_U\) is \(\Q\)-Cartier. The preceding construction supplies +condition (P). After restricting the base to a neighborhood of +\(K'\), the theorem gives a projective small bimeromorphic morphism +\[ + \ell:Y'\longrightarrow U +\] +with \(Y'\) normal and \(\Q\)-factorial over \(K'\). We retain the +notation \(U\) after this restriction and restrict \(g,L_i,A_i\) +accordingly. Compactness and local terminality of \(Y\) give a common +\(m_{\mathrm{can}}>0\) for which \(\omega_Y^{[m_{\mathrm{can}}]}\) is +invertible; its restriction to \(U\) is +\(\omega_U^{[m_{\mathrm{can}}]}\). Since \(\ell\) is +small, the natural identification on the common codimension-one open +extends by reflexivity to +\[ + \omega_{Y'}^{[m_{\mathrm{can}}]} + \simeq\ell^*\omega_U^{[m_{\mathrm{can}}]}. +\] +In particular, the left side is invertible and the natural relative +canonical divisor \(K_{Y'/U}\) is zero. This is canonical crepancy, +expressed using compatible local canonical generators as +\(K_{Y'}=\ell^*K_U\). A place exceptional over \(Y'\) is exceptional +over \(U\), because \(\ell\) is small. Crepancy therefore preserves +the terminal discrepancy inequalities, so \(Y'\) is terminal. Moreover \(\ell\) +is an isomorphism over \(U_{\mathrm{reg}}\). Indeed, for a relatively +ample line bundle \(\mathcal A\) on \(Y'\), the rank-one reflexive +sheaf \((\ell_*\mathcal A)^{**}\) is locally invertible on the smooth +base. Its pullback agrees with \(\mathcal A\) off codimension two +and hence everywhere there, by reflexivity on the normal source. +A positive-dimensional fiber over a smooth point would then have +degree zero against \(\mathcal A\), contradicting relative ampleness. + +Push \(A_i\) forward to a Weil divisor on \(U\), and let \(D_i'\) be +its strict transform on \(Y'\). These are actual locally finite +analytic divisors defined on all of the current \(Y'\). We apply +\(\Q\)-factoriality precisely in the sense of +\cite[Definition~2.38]{FujinoAnalyticMMP}: every prime divisor +defined on a neighborhood of the whole set \(\ell^{-1}(K')\) +is \(\Q\)-Cartier at each point of that set. Properness makes +\(\ell^{-1}(K')\) compact, and local finiteness leaves only finitely +many prime components of the \(D_i'\) near it. A finite cover of +this full compact and a common multiple therefore give an integer +\(m_{\mathrm{div}}>0\) and an open neighborhood of \(\ell^{-1}(K')\) +on which every \(m_{\mathrm{div}}D_i'\) is Cartier. By properness, +choose an open set \(U_1\) with \(K'\subset U_1\subset U\) whose full +inverse image is contained in that neighborhood, and put +\[ + \mathcal N_i=\mathcal O_{Y'}(m_{\mathrm{div}}D_i')|_{\ell^{-1}U_1}. +\] +This completes the use of \(\Q\)-factoriality on the specified full +compact; all later restrictions use these fixed line bundles. +In particular, the change-of-compact issue in +\cite[Remark~2.39]{FujinoAnalyticMMP} does not arise. On the +regular open, where both \(g\) and \(\ell\) are isomorphisms, +\begin{equation}\label{eq:curve-regular-bundles} + \mathcal N_i|_{U_{1,\mathrm{reg}}} + \simeq L_i^{\otimes m_{\mathrm{div}}}|_{U_{1,\mathrm{reg}}}. +\end{equation} + +Choose connected curve domains +\[ + B_0\Subset B_1\Subset\operatorname{int}_{T^\circ}(K_*) +\] +such that \(\pi_1(B_0)\to\pi_1(T^\circ)\) is surjective; nested +smaller cores obtained by enlarging the omitted discs have this +property. The larger domain lets us control finitely many components +near \(\overline B_0\) and make their discrete exceptional sets finite +on that compact. Work in the ambient open of \(U_1\) obtained by removing +\(T^\circ\setminus B_1\), so that \(B_1\) is closed there. +The inverse image of \(B_1\) is proper over \(B_1\). +Local finiteness of its analytic components, compactness of +\(\ell^{-1}(\overline B_0)\), and properness allow us first to +replace \(B_1\) by a neighborhood of \(\overline B_0\) on whose +inverse image only finitely many components occur. + +We claim that deleting finitely many points from \(B_0\) gives a +connected curve domain \(B\) with +\(\pi_1(B)\to\pi_1(T^\circ)\) surjective and the following fiber +description. All fibers of \(\ell\) over \(B\) have dimension at +most one. The finitely many irreducible surface components +\(S_1,\ldots,S_s\) of the reduced inverse image of \(B\), counted +after this restriction, all dominate \(B\). Their normalizations +factor as +\[ + \widehat S_\alpha\xrightarrow{\,h_\alpha\,}C_\alpha + \longrightarrow B \qquad (1\le\alpha\le s), +\] +where \(C_\alpha\to B\) is a connected finite \'etale cover and +\(h_\alpha\) is a smooth proper family of connected curves. A cover +that splits on restriction contributes separate components to this +list. For each fixed \(t\in B\), the pairs \((\alpha,c)\) with +\(c\in C_\alpha\) over \(t\) supply distinct irreducible curves and +exhaust the irreducible curves of \(\ell^{-1}(t)\). Each smooth +connected normalization fiber maps birationally to the curve it +supplies. + +We verify this description by spelling out the finite exclusions. +Smallness gives \(\dim\Exc(\ell)\le2\), so a general fiber above +\(B_1\) has dimension at most one. The locus of larger fibers is a +proper analytic subset of \(B_1\), by the fiber-dimension theorem +for proper maps. For each surface component of the reduced inverse +image that dominates \(B_1\), take its normalization and then its Stein factor over the +curve. The normalization is proper and is a normal surface. +Its singularities are isolated. Away from the branch values of the +finite Stein factor and the critical values of the map from the +normalization, it is a smooth proper family of connected curves +over a finite unramified cover. The values at which an intersection +of two components, or the nonisomorphism locus of a normalization, +contains a whole fiber curve also form a discrete analytic subset: +these loci have dimension at most one, and their general fibers +over the base are zero-dimensional. Finally remove the images of +components lying over a point. Each of these excluded sets is +discrete on the larger curve domain \(B_1\); there are only finitely +many components, so their union meets \(\overline B_0\) in a finite +set. + +Delete those finitely many points from \(B_0\) and call the result +\(B\). It is connected, and +\(\pi_1(B)\to\pi_1(T^\circ)\) is still surjective: loops in \(B_0\) +may be perturbed away from a finite set. The exclusions give the +asserted fiber description and families. + +For each \(\alpha,i\), let +\[ + d_{\alpha i} + =\deg\bigl(\mathcal N_i|_{h_\alpha^{-1}(c)}\bigr), + \qquad c\in C_\alpha, +\] +where pullback to \(\widehat S_\alpha\) is understood. This integer +is independent of \(c\), by constancy of degree in a smooth proper +family over the connected curve \(C_\alpha\). Because its fiber +maps birationally to the curve it supplies, this is also the degree +of \(\mathcal N_i\) on that fiber curve of \(\ell\). +We claim that the map +\begin{equation}\label{eq:curve-degree-map} + \Q^{b_T}\longrightarrow\Q^s,\qquad + (c_i)_i\longmapsto + \left(\sum_i c_i d_{\alpha i}\right)_\alpha +\end{equation} +is injective. + +Suppose its value is zero, and fix \(t\in B\). Every irreducible +curve in \(F'_t=\ell^{-1}(t)\) then has degree zero against +\(\sum_i c_i c_1(\mathcal N_i)\). The fiber has dimension at most +one. Its rational \(H_2\) is spanned by the fundamental classes of +its irreducible curves, also when the fiber is nonreduced, and +\(H^2(F'_t,\Q)\) is the rational dual of \(H_2(F'_t,\Q)\). +The restricted Chern class is therefore zero. Proper base change +identifies it with the germ in \((R^2\ell_*\Q)_t\). +Restriction through the isomorphism over the regular open gives +the natural map +\[ + (R^2\ell_*\Q)_t\longrightarrow (R^2j_*\Q)_t + =(\mathcal V_T)_t, +\] +so the corresponding punctured class is zero as well. By +\eqref{eq:curve-regular-bundles}, the restrictions of +\(\sum_i c_i c_1(\mathcal N_i)\) and +\(m_{\mathrm{div}}\sum_i c_i c_1(L_i)\) agree on their common regular +open. Taking their germ in \((R^2j_*\Q)_t\) and applying +\eqref{eq:branch-link-stalk-map} to the latter identifies that zero +class with +\[ + m_{\mathrm{div}}\sum_i c_i\,q_T(\sigma_i(t)). +\] +These vectors are independent; hence every \(c_i=0\). This proves +\eqref{eq:curve-degree-map}, and in particular +\begin{equation}\label{eq:curve-surface-count} + s\ge b_T. +\end{equation} + +\emph{Step 4. Distinct global discrepancy-two divisors.} +Take an ambient open \(U_B\subset U_1\) whose intersection with +\(T^\circ\) is the closed subspace \(B\), obtained as above by +removing \(T^\circ\setminus B\). Each \(S_\alpha\) is a closed +analytic surface in \(\ell^{-1}U_B\). Since \(Y'\) is terminal, +it is smooth in codimension two by +\cite[Lemma~2.3]{CanonicalKahler}. Thus at a general point of +\(S_\alpha\) both the ambient space and the surface are smooth. +Blow up its coherent ideal and normalize. The unique divisor +dominating that dense smooth part defines a local place \(v_\alpha\) +of ordinary log discrepancy \(2\) over \(Y'\), the value for a +smooth codimension-two blowup. Canonical crepancy of \(\ell\) +gives +\[ + a(v_\alpha;U_B,0)=2,\qquad + \cent_{U_B}(v_\alpha)=B. +\] +The \(v_\alpha\) are distinct because their centers on \(Y'\) are +the distinct \(S_\alpha\). + +It remains to represent each \(v_\alpha\) by a prime divisor on +\(g^{-1}U_B\) and show that these local divisors arise from distinct +global components of \(\Exc(g)\). + +On the fixed global resolution, the relative canonical divisor is +intrinsic even if the canonical bundle has no global divisor +representative. Using the fixed \(m_{\mathrm{can}}\), divide by +\(m_{\mathrm{can}}\) the divisor of the +natural meromorphic comparison +\(g^*\omega_Y^{[m_{\mathrm{can}}]}\dashrightarrow +\omega_{\widetilde Y}^{\otimes m_{\mathrm{can}}}\), and denote the +result by \(K_{\widetilde Y/Y}\). It is exceptional; write +\[ + K_{\widetilde Y/Y}=\sum_E\kappa_EE. +\] +The natural canonical comparisons commute with restriction and +composition, so this divisor supplies the relative discrepancy term +on \(U_B\) as well. +Every \(\kappa_E\) is strictly positive by terminality. The +principalization of the ideal of \(\Sing Y\) says that +\(g^{-1}(\Sing Y)\) is supported on these exceptional divisors. +Put \(\widetilde U_B=g^{-1}U_B\), and consider \(v_\alpha\) on a +common proper model with \(\widetilde U_B\). If it were exceptional +over this smooth resolution, then \(a(v_\alpha;\widetilde U_B,0)\ge2\). +Its center on the +resolution maps into \(B\subset\Sing Y\), so it is contained in at +least one of the \(E\), with \(\ord_{v_\alpha}(E)>0\). +The discrepancy formula would give +\[ + a(v_\alpha;U_B,0) + =a(v_\alpha;\widetilde U_B,0) + +\sum_E\kappa_E\ord_{v_\alpha}(E)>2, +\] +a contradiction. Thus \(v_\alpha\) is represented by a prime +divisor on \(g^{-1}U_B\). Since \(U_B\cap T=B\), this local divisor +is an irreducible component of \(E|_B\) for a global exceptional +divisor \(E\) with \(g(E)=T\). + +Such a global divisor cannot split into two components over \(B\). +Indeed the connected finite cover \(\widehat T_E^\circ\to T^\circ\) in +\eqref{eq:global-divisor-family} remains connected over \(B\): +the action of \(\pi_1(T^\circ)\) on a fiber is transitive, and +\(\pi_1(B)\) has the same image. Over this connected cover the +restriction of \(E\) is a smooth proper family with connected +fibers, so its total space is connected and smooth, hence +irreducible. Therefore the distinct local divisors representing +the \(v_\alpha\) come from distinct global components \(E\) of +\(\Exc(g)\). Their global centers are \(T\), and their ordinary +log discrepancies are \(2\), since this equality holds on the +open over \(B\). Together with \eqref{eq:curve-surface-count}, +this proves the proposition. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:branch}] +Every global place of ordinary log discrepancy \(2\) whose center +is a singular curve is represented by a component of \(\Exc(g)\). +Indeed the same discrepancy computation in the last part of +Proposition~\ref{prop:curve-places} would otherwise make its +discrepancy strictly greater than \(2\). There are only finitely +many such components on the compact resolution, so +\(\tau_Y(Q)\) is finite. Proposition~\ref{prop:curve-places}, +summed over the singular curves contained in \(Q\), gives +\[ + \sum_{T\subset\Sing Y\cap Q} b_T\le\tau_Y(Q). +\] +Combining this with \eqref{eq:branch-topological-bound} yields +\[ + \beta(Q)\le \sum_j c_2(Q_j^\nu)+\tau_Y(Q), +\] +as required. +\end{proof} + +\section{The difficulty on the terminal chain}\label{sec:difficulty} + +We now construct an integer that is nonnegative at the crepant terminal +junctions and nonincreasing along the moves between them. The local +subtraction of surface contributions and the correction by cycle ranks on +boundary normalizations adapt the projective construction in +\cite[Definition~4.2, Lemma~4.3, and Section~7]{ProjectiveLCFourfolds}. +We give the required finiteness and comparison arguments in the analytic +setting. + +Use the terminal chain of Proposition~\ref{prop:terminal-junctions}, after +the truncation in Proposition~\ref{prop:surface-finiteness}. Its finite set +of prime labels is denoted by \(\mathcal H\). On a current model its +boundary is +\[ + \Theta=\sum_{h\in\mathcal H}b_hS_h,\qquad 0\leq b_h<1. +\] +The labels persist by strict transform, including those of coefficient +zero, and the coefficients are nonincreasing. The fixed coefficients have +already become constant. Every varying coefficient is positive; at a +junction \(h_i:Y_i\to X_i\), its label is exceptional for \(h_i\) and has +image of dimension at most one. Each model of the chain is strong and +compact K\"ahler, the generalized pair is terminal, and the underlying +fourfold is ordinarily terminal. + +Choose a positive integer \(N\) that clears the fixed label coefficients, +the coefficients of the initial boundary of the particular strong +generalized klt sequence under study, and its fixed nef datum: on the chosen +higher carrier, \(N\M\) is represented by an integral Cartier divisor. +These are finite rational data. We impose no denominator condition on a +varying coefficient. For \(u\in\R\), put +\begin{equation}\label{eq:difficulty-weights} + \omega(u)=\left\lceil N\max\{u,0\}\right\rceil, + \qquad + w(E)=\omega\bigl(2-a(E;Y,\Theta+\M)\bigr), +\end{equation} +where \(E\) is a global divisorial place and the current pair is understood +in \(w(E)\). Thus \(w(E)>0\) exactly when the discrepancy is less than +two; discrepancy equal to two has weight zero. + +For a fixed label, \(\omega(b_h)=Nb_h\), so its contribution incurs no +rounding loss in the local estimate below. The conditions on the initial +boundary and nef carrier will give the lattice at the positive endpoint in +Lemma~\ref{lem:positive-surface}. The earlier surface lattice has already +served to choose the tail; \(N\) need not clear every element of +\(\mathcal A_{\mathrm{surf}}\). + +\subsection{Echoes and finite local corrections} + +The recurring places over a generic codimension-two boundary center are +the echoes of \cite[Example~1.4, Lemma~1.5, and Definition~2.3]{AlexeevHaconKawamata2007}. +The full chain matters: \cite[Example~2.1]{Fujino2005Addendum} shows why +removing only the first blowup does not make a boundary difficulty finite. + +First consider an irreducible compact analytic surface \(V\subset S_h\) +whose general point lies in a smooth open of \(Y\) where \(S_h\) is smooth, +no other label occurs, and \(\M\) descends. The following sequence of +global places records the predictable contribution above such a surface. +Blow up the coherent ideal of \(V\) globally and normalize. The global +exceptional divisor has a unique irreducible component dominating the dense +smooth open of \(V\); call its place \(E_{V,h,1}\). On this normalized +blowup, its analytic intersection with the strict transform of \(S_h\) +has a unique irreducible component dominating that same open of \(V\). +Blow up the coherent ideal of this global component, normalize, and take +the unique new exceptional prime over that open. Repeat this operation on +these normalized blowups, denoting the successive places by +\(E_{V,h,j}\), \(j\geq1\). The models are smooth at the general points +of the indicated intersections, so each next component exists and is +unique there. When another higher model is needed for comparison, a common +proper model identifies these same global places by strict transform. We +call them the \emph{echoes} of \(S_h\) above \(V\). + +The first exceptional prime has crepant boundary coefficient +\(-(1-b_h)\). At stage \(j\) this coefficient is \(-j(1-b_h)\): blowing +up its intersection with the strict label adds one more \(-(1-b_h)\). +Consequently +\begin{equation}\label{eq:echo-discrepancy} + a(E_{V,h,j};Y,\Theta+\M)=1+j(1-b_h). +\end{equation} +The contributing echoes are precisely those with \(j(1-b_h)<1\). In +particular there are only finitely many contributing indices for each +\(b_h<1\). Define the \emph{default contribution} of label \(h\) by the finite sum +\begin{equation}\label{eq:echo-default} + d_h=\sum_{j\geq1}\omega\bigl(1-j(1-b_h)\bigr). +\end{equation} +Here terms outside the finite set just described are zero. If \(b_h=0\), +then \(d_h=0\). If \(b_h>0\), its first term gives +\(d_h\geq\omega(b_h)\geq1\). Each summand is nonincreasing as \(b_h\) +decreases, and no new positive index can appear. Hence every \(d_h\) is a +nonincreasing nonnegative integer along the chain. After discarding +finitely many further junctions, all \(d_h\) are constant, including +throughout each intervening finite string of moves. Indeed each of the +finitely many integers can drop only finitely often, while coefficients +stay unchanged during the small steps. We henceforth use this truncated +chain and these constant values \(d_h\). + +On a fixed model, the generic echo contribution is the only contribution +that can recur over infinitely many surface centers. We now justify this +claim. All places in the following proposition are +global divisorial places. + +\begin{proposition}[Finiteness below discrepancy two] +\label{prop:difficulty-finite} +Let \((Y,\Theta+\M)\) be a model of the truncated terminal chain. +Among the places exceptional over \(Y\) with discrepancy less than two, +there are only finitely many whose centers have codimension at least three. +For each fixed irreducible compact analytic surface \(V\subset Y\), there +are only finitely many whose center is \(V\). + +There is a finite set \(\mathcal V_Y\) of irreducible compact analytic +surfaces with the following additional property. If +\(V\notin\mathcal V_Y\), its general point lies in a smooth open where +\(\M\) descends and either no label occurs or exactly one smooth label +\(S_h\) occurs. There are no positive-weight places centered on \(V\) +in the first case or when \(b_h=0\). When \(b_h>0\), they are exactly the +echoes \(E_{V,h,j}\) with \(j(1-b_h)<1\). +\end{proposition} + +\begin{proof} +Take a projective resolution \(\pi:W\to Y\) with \(W\) smooth and carrying \(\M\), +with divisorial exceptional locus, and resolving all labels. Further +blowups of intersections in the simple normal crossing divisor make the +strict transforms of the labels smooth and pairwise disjoint, while keeping +the full divisor simple normal crossing. Write +\[ + K_W+\Theta_W+M_W=\pi^*(K_Y+\Theta+M_Y). +\] +Every \(\pi\)-exceptional component of \(\Theta_W\) has coefficient +\(1-a(E;Y,\Theta+\M)<0\), by generalized terminality. The only possible +positive components of \(\Theta_W\) are therefore the strict transforms +of the positive labels. On higher models the nef datum pulls back from \(W\), so the +discrepancy calculation is the ordinary one for the signed boundary +\(\Theta_W\). + +Consider a place \(E\) that is also exceptional over \(W\), and let its +center on \(W\) have codimension \(c\geq2\). At a general smooth point +of this center choose normal parameters \(x_1,\ldots,x_c\). The Jacobian +formula on a smooth model carrying \(E\) gives +\[ + a(E;W,0)\geq\sum_{i=1}^c\ord_E(x_i), + \qquad \ord_E(x_i)\geq1. +\] +Indeed, in the pullback of a local volume form at most one differential +factor can lose one order along \(E\); adding one to the Jacobian order +gives the displayed bound. If the center lies in no positive component of +\(\Theta_W\), the signed boundary can only raise this discrepancy, which +is at least two. Otherwise it lies in a unique positive smooth label of +coefficient \(b<1\). Taking \(x_1\) as its local equation and discarding +the negative boundary terms gives +\begin{equation}\label{eq:local-discrepancy-estimate} + a(E;Y,\Theta+\M) + \geq (1-b)\ord_E(x_1)+\sum_{i=2}^c\ord_E(x_i). +\end{equation} +A discrepancy less than two thus forces \(c=2\) and containment in a +positive label. A label of coefficient zero cannot give such a place. + +If this codimension-two center is contained in \(\Exc(\pi)\), it is a +component of the intersection of its label with one of the finitely many +exceptional divisors. There are only finitely many such centers. If it +meets the isomorphism open, its general point maps isomorphically to a +surface downstairs, and the center is the strict transform of that surface. +Thus a center mapping to codimension at least three belongs to the first +finite list, and for any fixed surface downstairs there are only finitely +many possible centers on \(W\). + +There are only finitely many places of discrepancy less than two whose +center on \(W\) equals a fixed one of these codimension-two centers. To see this, discard the negative +components of \(\Theta_W\); this lowers discrepancies, so it suffices to +work with the single smooth label of coefficient \(b\). Blow up the center +generically. The new exceptional coefficient is \(-(1-b)\). A further +place with discrepancy less than two has its center in that exceptional +divisor; the estimate \eqref{eq:local-discrepancy-estimate} also forces a +codimension-two center in the strict label. It must therefore follow their +intersection above the general point of the original center. At stage +\(j\) the most recent exceptional coefficient is \(-j(1-b)\), and the +older exceptional divisors do not meet this generic intersection. A place +above it that is still exceptional has discrepancy at least +\[ + (1-b)+1+j(1-b)=1+(j+1)(1-b). +\] +This reaches two after finitely many stages. The same argument shows that, +where no other boundary or nef data enter, the places below two are exactly +the echoes in \eqref{eq:echo-discrepancy}. + +This generic computation identifies global places. At each global blowup +there is a unique irreducible component of its exceptional divisor that +dominates the dense smooth part of the center. The global analytic +intersection of that prime with the strict label then has a unique +irreducible component dominating the same part. These global components +have coherent ideals, which define the next global blowups. Conversely, +one can follow any given global place on common higher models through these +blowups; when its center becomes a divisor on a normal model, that divisor +represents the place. Thus the computation does not count different local +pieces of one place separately. + +Finally include the finitely many divisors on \(W\) that are exceptional +over \(Y\). The complement of the isomorphism open, and the loci where a +label fails to be smooth and alone or the nef datum fails to descend, are +contained in a proper analytic subset of \(Y\) of codimension at least +two. Such a subset has only finitely many surface components on the compact +fourfold. Take these components for \(\mathcal V_Y\), enlarging the set +by the finitely many surface images already encountered if necessary. +Outside them the preceding one-label calculation applies, or there is no +positive label and no place of positive weight. This proves all assertions. +\end{proof} + +For an irreducible compact analytic surface \(V\subset Y\), let +\begin{equation}\label{eq:difficulty-branches} + r_{V,h}=\#\{D:\ D\text{ is a prime divisor of }S_h^\nu + \text{ mapping onto }V\}. +\end{equation} +This number is finite, because normalization is finite and the inverse +image of \(V\) has finitely many components on the compact normalization. +It is zero if \(V\not\subset S_h\). It counts prime divisors on the +normalization, without counting their possible multiple sheets over \(V\) +as separate divisors. + +Every place with center a surface, curve, or point on the normal fourfold +is exceptional over it: a place with a divisor as center is represented by +that divisor. Hence the two raw sums below involve only exceptional +places. Proposition~\ref{prop:difficulty-finite} makes the local sum +\(\sum_{\cent_Y(E)=V}w(E)\) finite after zero terms are omitted. Although +this raw sum is finite at each fixed surface, the same nonzero contribution +\(d_h\) can recur at infinitely many surfaces in a label. We therefore +subtract the branch contributions at each surface before summing over +surfaces. Define the integer +\begin{equation}\label{eq:difficulty-bracket} + q_Y(V)=\sum_{\cent_Y(E)=V}w(E)-\sum_{h\in\mathcal H}r_{V,h}d_h. +\end{equation} +Only finitely many \(q_Y(V)\) are nonzero. Indeed, outside the finite set +in Proposition~\ref{prop:difficulty-finite}, a surface on a positive label +has raw sum \(d_h\), with \(r_{V,h}=1\) and all other branch counts zero. +A surface generically on a sole zero-coefficient label has both raw sum and +default zero, as does a surface away from all labels. These cases exhaust +the surfaces outside that finite set. + +We may therefore define the difficulty by +\begin{equation}\label{eq:difficulty} + \begin{aligned} + \mathfrak D(Y,\Theta+\M) + ={}&\sum_{\codim_Y\cent_Y(E)\geq3}w(E) + +\sum_{\substack{V\subset Y\\\dim V=2}}q_Y(V)\\ + &+\sum_{h\in\mathcal H}d_hc_2(S_h^\nu), + \end{aligned} +\end{equation} +where the surface sum is over irreducible compact analytic surfaces. +The first sum has finitely many nonzero terms by +Proposition~\ref{prop:difficulty-finite}; the second has just been shown +to have finite support; and the last is finite because \(\mathcal H\) is +finite and every analytic cycle rank is finite. Thus \(\mathfrak D\) is +an integer. The subtraction in \eqref{eq:difficulty-bracket} is performed +at each surface before the second sum is taken. Both a local bracket and +the difficulty on an intermediate model are at this point allowed to be +negative. + +\subsection{The lower bound at the junctions} + +The possible negative part of a surface bracket comes only from rounding +the contributions of varying labels. For a surface \(V\), put +\[ + r_V^{\mathrm{var}}=\sum_{h\text{ varying}}r_{V,h}. +\] +We first prove, on every current terminal model, that +\begin{equation}\label{eq:difficulty-local-bound} + q_Y(V)\geq-\max\{r_V^{\mathrm{var}}-1,0\}. +\end{equation} + +The underlying fourfold is ordinarily terminal by +Lemma~\ref{lem:ordinary-singularities}, hence smooth at general points of +\(V\). Blow up \(V\) generically to obtain a global exceptional +place \(E_V\). For each label let \(m_h\) be its multiplicity transverse +to \(V\) at a general point, taking \(m_h=0\) if it does not contain +\(V\). The ordinary log discrepancy of \(E_V\) is two. On a common +carrier \(\pi:W\to Y\) carrying this place, the nef defect +\(J=\pi^*M_Y-M_W\) is effective by Lemma~\ref{lem:nef-defect}. If \(j_V\) is its coefficient at +\(E_V\), the discrepancy formula and generalized terminality give +\begin{equation}\label{eq:difficulty-first-blowup} + a(E_V;Y,\Theta+\M)=2-\sum_hm_hb_h-j_V>1, + \qquad j_V\geq0. +\end{equation} +In particular \(\sum_hm_hb_h<1\). + +We also have \(r_{V,h}\leq m_h\). To see this analytically, work at a +general smooth point of \(V\). Each prime divisor of \(S_h^\nu\) counted +by \(r_{V,h}\) gives at least one point of the finite normalization over +that point of \(V\); the points supplied by distinct prime divisors can be +taken distinct after avoiding their special loci. They correspond to +distinct local analytic branches of \(S_h\), each containing the germ of +\(V\). Each branch contributes at least one to the transverse multiplicity +\(m_h\). A normalization divisor with several sheets may supply more +than one local branch, which preserves the stated inequality. + +Let \(t=r_V^{\mathrm{var}}\), and list the numbers \(Nb_h\) for varying +labels, repeating each one \(r_{V,h}\) times, as +\(x_1,\ldots,x_t\). The fixed contribution +\(k=N\sum_{h\text{ fixed}}r_{V,h}b_h\) is a nonnegative integer. For +\(t\geq1\), the ceiling inequality gives +\[ + \left\lceil k+\sum_{\ell=1}^t x_\ell\right\rceil + \geq k+\sum_{\ell=1}^t\lceil x_\ell\rceil-(t-1). +\] +For \(t=0\) the left side is \(k\). Using effectivity, +\(m_h\geq r_{V,h}\), and \eqref{eq:difficulty-first-blowup}, we obtain in +both cases +\begin{equation}\label{eq:difficulty-first-weight} + w(E_V)\geq\sum_h r_{V,h}\omega(b_h) + -\max\{r_V^{\mathrm{var}}-1,0\}. +\end{equation} +No rounding loss is needed for a fixed label because \(Nb_h\) is integral. + +It remains to supply the terms of \(d_h\) with \(j\geq2\). Such a term +is positive only if \(b_h>1/2\); when \(b_h=1/2\), the second echo has +discrepancy exactly two and weight zero. The strict inequality +\(\sum_hm_hb_h<1\) implies that at most one label through \(V\) has +coefficient greater than \(1/2\), and its multiplicity is one. This label +is smooth at general points of \(V\) and has \(r_{V,h}=1\). Use its +successive generic blowups above \(V\). For each \(j\geq2\) with a +positive default, the resulting global place is distinct from \(E_V\) and +from all the others. With this label alone its discrepancy is +\(1+j(1-b_h)\). The other effective boundary components and the effective +nef defect only lower the discrepancy. Its actual weight is therefore at +least \(\omega(1-j(1-b_h))\). These places supply every remaining +default. Adding their weights to \eqref{eq:difficulty-first-weight} +proves \eqref{eq:difficulty-local-bound}, including the cases with no +varying label or with zero coefficients. + +\begin{proposition}[Lower bound at crepant junctions] +\label{prop:difficulty-lower} +At every crepant junction \(h_i:(Y_i,\Theta_i+\M)\to(X_i,B_i+\M)\) of +the truncated chain, +\[ + \mathfrak D(Y_i,\Theta_i+\M)\geq0. +\] +\end{proposition} + +\begin{proof} +Write \(Y=Y_i\) and let +\(Q=\bigcup_{h\text{ varying}}S_h\) with its reduced structure. If +\(Q\) is empty, \eqref{eq:difficulty-local-bound} makes every surface +bracket nonnegative, and the other terms of \eqref{eq:difficulty} are +nonnegative. Suppose \(Q\ne\varnothing\). At this junction the map +\(h_i\) is projective bimeromorphic from an ordinarily terminal compact +K\"ahler fourfold, and \(\dim h_i(Q)\leq1\) by +Proposition~\ref{prop:surface-finiteness}. Thus Theorem~\ref{thm:branch} +applies. For a surface \(V\subset Q\), its branch count in that theorem +is \(r_V(Q)=r_V^{\mathrm{var}}\geq1\); the last inequality follows from +the finite surjective normalizations. Surfaces outside \(Q\) have +\(r_V^{\mathrm{var}}=0\). The total possible deficit in +\eqref{eq:difficulty-local-bound} is consequently \(\beta(Q)\). + +Every varying label has \(d_h\geq1\). The places counted by +\(\tau_Y(Q)\) in Theorem~\ref{thm:branch} also each supply a weight of at +least one in the first sum of \eqref{eq:difficulty}. In fact such a place +\(E\) has ordinary log discrepancy two and center a singular curve in +\(Q\). It is exceptional over \(Y\). Its center is contained in a +varying label of positive coefficient, and that effective label is +\(\Q\)-Cartier on the strong model. Its order at \(E\) is therefore +strictly positive. On a common carrier the discrepancy formula reads +\[ + a(E;Y,\Theta+\M) + =2-\ord_E(\Theta)-\operatorname{coeff}_E(J)<2, + \qquad J\geq0. +\] +The count \(\tau_Y(Q)\) uses distinct global places. They occur as +distinct terms of the codimension-at-least-three sum, and none is a place +in a surface bracket. Theorem~\ref{thm:branch} now gives +\[ + \beta(Q) + \leq\sum_{h\text{ varying}}c_2(S_h^\nu)+\tau_Y(Q) + \leq\sum_{h\in\mathcal H}d_hc_2(S_h^\nu) + +\sum_{\codim_Y\cent_Y(E)\geq3}w(E). +\] +Summing \eqref{eq:difficulty-local-bound} and substituting this inequality +in \eqref{eq:difficulty} proves the assertion. The branch inequality and +this lower bound have been used only at the junctions. +\end{proof} + +\subsection{Exact change along the chain} + +For a small step, the change in the normalization cycle ranks will cancel +the change in the surface defaults. We establish this equality before +comparing the difficulties. + +\begin{lemma}[Normalization cycle ranks]\label{lem:difficulty-ranks} +Consider a small step of the terminal chain, with exceptional loci +\(L,L^+\), +\[ + Y\xrightarrow{f}Z\xleftarrow{f^+}Y^+. +\] +For each label \(h\), let \(e_h\) and \(e_h^+\) be the numbers of prime +divisors in \(S_h^\nu\) and \((S_h^+)^\nu\) lying over \(L\) and +\(L^+\), respectively. Then these numbers are finite and +\begin{equation}\label{eq:difficulty-rank-change} + \begin{gathered} + e_h=\sum_{\substack{V\subset L\\\dim V=2}}r_{V,h},\qquad + e_h^+=\sum_{\substack{V^+\subset L^+\\\dim V^+=2}}r_{V^+,h}^+,\\ + c_2(S_h^\nu)-c_2((S_h^+)^\nu)=e_h-e_h^+. + \end{gathered} +\end{equation} +The surface sums run over irreducible compact analytic surfaces. +\end{lemma} + +\begin{proof} +Let \(T_h\) be the normalization of the common image of the two labels in +\(Z\). Restricting the projective maps, composing with finite +normalization, and factoring through \(T_h\) gives projective +bimeromorphic maps of normal compact threefolds +\[ + S_h^\nu\longrightarrow T_h\longleftarrow (S_h^+)^\nu. +\] +They identify over the common isomorphism open. By +Lemma~\ref{lem:small-comparison}, the common exceptional image +\(A=f(L)=f^+(L^+)\) has dimension at most one. A normalization divisor +lying over \(L\) has a surface as its image in \(S_h\), because +normalization is finite, and its image in \(T_h\) lies over \(A\). +It is therefore contracted by the displayed map. Conversely, the map is +an isomorphism off the preimage of \(A\), so every contracted prime divisor +lies over \(L\). These are exactly the primes counted in the first sum +in \eqref{eq:difficulty-rank-change}. The same reasoning holds on the +positive side. The exceptional loci have finitely many surface components, +which also proves finiteness. + +We use the following independence fact. For a projective bimeromorphic +map \(g:S\to T\) of normal compact threefolds, the classes in +\(H_4(S,\Q)\) of the prime divisors contracted by \(g\) are linearly +independent. Take a resolution \(r:\widetilde S\to S\) that is projective, +has smooth source, and is an isomorphism over \(U=S_{\mathrm{reg}}\). Put +\(R=r^{-1}(S\setminus U)\). Normality gives \(\dim(S\setminus U)\leq1\), +and \(\dim R\leq2\). If a rational combination of the contracted divisor +classes vanished on \(S\), the corresponding combination of strict +transforms would restrict to zero in \(H_4^{\BM}(U,\Q)\). The localization +sequence +\[ + H_4(R,\Q)\longrightarrow H_4(\widetilde S,\Q) + \longrightarrow H_4^{\BM}(U,\Q) +\] +then shows that its class is a rational combination of the classes of the +surface components of \(R\); those classes span \(H_4(R,\Q)\). Subtract +that combination. We obtain a homologically trivial rational Cartier +divisor on \(\widetilde S\), all of whose components are exceptional over +\(T\). For the components of \(R\), this follows since their images in +\(S\), hence in \(T\), have dimension at most one. On the smooth compact +resolution, homological triviality makes this divisor numerically trivial +on every curve by the ordinary class pairing. Analytic negativity in both +signs, in the form of \cite[Lemma~2.2]{CanonicalKahler}, makes the +divisor zero. The strict transforms of the original divisors are distinct +from the resolution-exceptional ones, so all original coefficients vanish. +This proves independence without any factoriality assumption on \(S\). + +For either label normalization, restrict its span of compact analytic +surface classes to the common open over \(T_h\setminus\nu^{-1}(A)\), +where \(\nu:T_h\to f(S_h)\) is normalization. The complement of this +open in either normalization has dimension at most two. Localization shows that the kernel of this +restriction is spanned by its surface components, precisely the contracted +prime divisors just counted. Their independence makes the kernel dimension +\(e_h\) on one side and \(e_h^+\) on the other. The two images agree: +any compact analytic prime surface not removed has a strict transform on +the other normalization through their proper graph over \(T_h\), and the +two classes restrict to the same class on the common open. The same holds +in the reverse direction. Subtracting the dimensions of these two cycle +spans proves the last equality in \eqref{eq:difficulty-rank-change}. +\end{proof} + +\begin{proposition}[Change of the difficulty]\label{prop:difficulty-change} +The difficulty is nonincreasing under every coefficient change and every +small step of the truncated terminal chain. More precisely: +\begin{enumerate} +\item Suppose \(\Theta'\leq\Theta\) is a coefficient change on the same +model \(Y\), and write \(w(E)\) and \(w'(E)\) for its old and new weights. +The set +\[ + \mathcal C=\{E:\ E\text{ exceptional over }Y,\ w(E)\ne w'(E)\} +\] +is finite, and +\begin{equation}\label{eq:difficulty-coefficient-change} + \mathfrak D(Y,\Theta+\M)-\mathfrak D(Y,\Theta'+\M) + =\sum_{E\in\mathcal C}\bigl(w(E)-w'(E)\bigr)\geq0. +\end{equation} +\item For a small step \(Y\to Z\leftarrow Y^+\) with exceptional loci +\(L,L^+\), write \(w(E),w^+(E)\) for the two weights. The set +\[ + \mathcal P=\{E:\ E\text{ exceptional over }Y,\ + \cent_Y(E)\subset L,\ w(E)+w^+(E)>0\} +\] +is finite. Its center condition is equivalently +\(\cent_{Y^+}(E)\subset L^+\), and +\begin{equation}\label{eq:difficulty-small-change} + \mathfrak D(Y,\Theta+\M)-\mathfrak D(Y^+,\Theta^++\M) + =\sum_{E\in\mathcal P}\bigl(w(E)-w^+(E)\bigr)\geq0. +\end{equation} +\end{enumerate} +In either move, a strict decrease in the weight of any exceptional place +forces a strict decrease in the difficulty. +\end{proposition} + +\begin{proof} +For a coefficient change, the removed boundary \(\Theta-\Theta'\) is +effective and \(\Q\)-Cartier on the strong model. For every place, +\[ + a(E;Y,\Theta'+\M)-a(E;Y,\Theta+\M) + =\ord_E(\Theta-\Theta')\geq0. +\] +Thus \(w(E)\geq w'(E)\). The model, centers, branch counts, and +normalization ranks are unchanged, and the defaults \(d_h\) are constant +by the choice of the tail. At a fixed surface the two raw sums are finite, +and therefore +\[ + q_Y(V)-q'_Y(V)=\sum_{\cent_Y(E)=V}\bigl(w(E)-w'(E)\bigr). +\] +Let \(\Sigma\) be the finite union of the supports of the two functions +\(q_Y\) and \(q'_Y\) on surfaces. Outside \(\Sigma\) the displayed +sum is zero. Every summand is nonnegative, so no exceptional place with +such a surface center can lose weight. At each surface of \(\Sigma\) +only finitely many places have positive old or new weight, and there are +only finitely many positive weights at centers of codimension at least +three. This proves that \(\mathcal C\) is finite. Summing the displayed +identity over \(\Sigma\), adding the finite comparison in codimension at +least three, and canceling the unchanged rank term gives +\eqref{eq:difficulty-coefficient-change}. + +For a small step, Lemma~\ref{lem:small-comparison} says that exceptionality +of a global place is the same on the two sides, that the two center +containment conditions in the statement are equivalent, and that +\(w(E)\geq w^+(E)\). If a center is not contained in the exceptional +locus, its general point corresponds on the common isomorphism open and its +discrepancy is unchanged. The set \(\mathcal P\) is finite: each +exceptional locus has dimension at most two and has finitely many surface +components; a surface center contained in it is one of these components. +Proposition~\ref{prop:difficulty-finite} gives finiteness above each such +surface and finiteness of all positive-weight places with lower-dimensional +centers, on both sides. + +Surface centers not contained in \(L\) correspond by proper strict +transform to those not contained in \(L^+\). At their general points the +places, discrepancies, and normalization primes over the surfaces +correspond, so the two local brackets agree. The analogous correspondence +holds for the raw terms at lower-dimensional centers outside the exceptional +loci. In the exceptional loci, every contributing place is counted exactly +once in the raw part on each side of \eqref{eq:difficulty}. This remains +true if its center changes from a surface to a curve or point, or conversely. +The finite comparison of those raw parts is therefore +\(\sum_{E\in\mathcal P}(w(E)-w^+(E))\). The subtracted defaults on the +exceptional surfaces have difference \(-\sum_h d_h(e_h-e_h^+)\). Hence +\begin{align*} + &\mathfrak D(Y,\Theta+\M)-\mathfrak D(Y^+,\Theta^++\M)\\ + &\quad=\sum_{E\in\mathcal P}\bigl(w(E)-w^+(E)\bigr) + -\sum_h d_h(e_h-e_h^+) + +\sum_h d_h\bigl(c_2(S_h^\nu)-c_2((S_h^+)^\nu)\bigr)\\ + &\quad=\sum_{E\in\mathcal P}\bigl(w(E)-w^+(E)\bigr), +\end{align*} +where the last equality is Lemma~\ref{lem:difficulty-ranks}. This is +\eqref{eq:difficulty-small-change}. Every summand is nonnegative. A +strictly decreasing exceptional weight must have its center in the +exceptional loci, since weights agree off them, and is in \(\mathcal P\). +A positive weight that becomes zero is included by the definition of +\(\mathcal P\). The same positivity is immediate in +\eqref{eq:difficulty-coefficient-change}; this proves strictness in both +cases. +\end{proof} + +\section{Termination and the log canonical reduction}\label{sec:completion} + +We first show that a surface in the positive exceptional locus of a +downstairs diagram is detected by the integer difficulty. The calculation +uses the weight denominator \(N\) chosen for the particular strong gklt +sequence under consideration. We then prove +termination for strong gklt models, pass to elementary gdlt programs, and +lift the arbitrary diagrams of Theorem~\ref{thm:main} to those programs. + +\begin{lemma}[A positive exceptional surface]\label{lem:positive-surface} +Use the truncated terminal chain of +Propositions~\ref{prop:terminal-junctions} and +\ref{prop:surface-finiteness}, with the integer \(N\), weights, and constant +defaults chosen in Section~\ref{sec:difficulty}. If an irreducible compact +analytic surface \(V\) is contained in \(L_i^+\subset X_{i+1}\), there is +a global place \(E\), exceptional over both junctions and every model of +their connector, such that +\[ + a_{i+1}(E)\in(1,2]\cap N^{-1}\Z, + \qquad w_i(E)\geq w_{i+1}(E)+1. +\] +Here \(w_i\) and \(w_{i+1}\) are the weights at the two crepant junctions. +Consequently +\[ + \mathfrak D(Y_i,\Theta_i+\M) + >\mathfrak D(Y_{i+1},\Theta_{i+1}+\M). +\] +\end{lemma} + +\begin{proof} +By Proposition~\ref{prop:surface-finiteness}, the model \(X_{i+1}\) is +smooth near the general point of \(V\), the junction morphism is an +isomorphism there, and the generic blowup of \(V\) gives a unique global +place \(E\) with +\[ + a^+:=a_{i+1}(E)>1. +\] +This place is exceptional over \(X_{i+1}\) and does not belong to the +stabilized extracted set \(\mathcal I\). The blowup of the coherent ideal +of \(V\) is projective, so Lemma~\ref{lem:common-projective-models} gives a +smooth common model \(W\) carrying both \(E\) and the fixed nef datum, +with a projective morphism \(r:W\to X_{i+1}\). By Lemma~\ref{lem:nef-defect}, +\[ + J=r^*M_{i+1}-M_W\geq0. +\] +At the generic smooth codimension-two center, the ordinary log discrepancy +of the blowup is two. The discrepancy formula is therefore +\begin{equation}\label{eq:positive-detector-discrepancy} + a^+=2-\ord_E(B_{i+1})-\operatorname{coeff}_E(J). +\end{equation} +Both subtracted terms are nonnegative. Thus \(a^+\leq2\). + +We verify the denominator in this calculation. By the choice in +Section~\ref{sec:difficulty}, \(N\) clears the coefficients of the initial +boundary and the Cartier denominator of the higher nef divisor of this +strong gklt sequence. Since the downstairs boundaries are strict +transforms, \(NB_{i+1}\) is an integral Weil divisor. Also \(NM_{i+1}\) +is an integral Weil divisor: it is the pushforward of the integral Cartier +divisor \(NM_W\) from a common carrier. On the smooth open neighborhood of +the general point of \(V\), these two integral Weil divisors are Cartier. +Their orders at \(E\) are consequently integral after multiplication by +\(N\). In particular, +\[ + N\ord_E(B_{i+1})\in\Z, + \qquad + N\operatorname{coeff}_E(J) + =\ord_E(Nr^*M_{i+1})-\operatorname{coeff}_E(NM_W)\in\Z. +\] +Only Cartierness on this smooth open has been used. Equation +\eqref{eq:positive-detector-discrepancy} gives +\(a^+\in(1,2]\cap N^{-1}\Z\). + +Put \(a^-=a_i(E)\). The strict part of +Lemma~\ref{lem:small-comparison} applies because +\(\cent_{X_{i+1}}(E)=V\subset L_i^+\), and gives \(a^-c_2(X_{i+1}) +\] +at every step of this tail. These are nonnegative integers, a +contradiction. +\end{proof} + +\begin{theorem}[Termination of elementary gdlt programs]\label{thm:gdlt} +Let +\[ + (T_0,B_0+\M)\dashrightarrow(T_1,B_1+\M) + \dashrightarrow(T_2,B_2+\M)\dashrightarrow\cdots +\] +be a sequence of elementary steps for rational gdlt pairs on strong normal irreducible +compact K\"ahler fourfolds. Assume that the boundaries are effective +rational divisors of finite support transported by the steps, that the +fixed b-divisor is represented by an analytically nef \(\Q\)-Cartier divisor +on a projective bimeromorphic normal compact K\"ahler model of \(T_0\), and +that the actual adjoints are \(\Q\)-Cartier with compatible canonical +representatives. Then the sequence is finite. The contraction bases and +the choices of elementary steps may vary. +\end{theorem} + +\begin{proof} +An elementary program extracts no prime divisors. Lemma~\ref{lem:cycle-loss} with \(k=3\) +therefore permits only finitely many divisorial steps. If the sequence were +infinite, we could discard a finite prefix containing them and work on a +tail of small steps. +The rational b-line realization described in +Section~\ref{sec:preliminaries} has the same discrepancies and fixed higher +nef data; common projective carriers for finite portions carry their +analytically nef pullbacks. Thus Theorem~\ref{thm:special-termination} +applies. After a further tail, both exceptional loci of every step avoid +every generalized log canonical center on their respective sides. + +Set \(H_i=\lfloor B_i\rfloor\). Since the pair is glc and \(B_i\) is +effective, its coefficients belong to \([0,1]\), so \(H_i\) is the reduced +sum of its coefficient-one components. Each such component is itself a +generalized log canonical center. Hence \(\Supp H_i\) is disjoint from +the exceptional loci adjacent to \(T_i\) on this tail. The divisors +\(H_i\) are effective and \(\Q\)-Cartier on the strong models, and they +are strict transforms of each other across the small steps. + +Remove the whole floor and write +\[ + \widehat B_i=B_i-H_i, + \qquad \widehat D_i=K_{T_i}+\widehat B_i+M_{T_i}=D_i-H_i. +\] +The new boundary is effective. For every global place \(E\), comparison +of the two crepant equations gives +\begin{equation}\label{eq:full-floor-deletion} + a(E;T_i,\widehat B_i+\M) + =a(E;T_i,B_i+\M)+\ord_E(H_i). +\end{equation} +The added order is nonnegative. If the old discrepancy is zero, the gdlt +definition says that the general point of its center is a stratum of the +coefficient-one boundary. Taking its closure places the entire center in +\(\Supp H_i\). The order of an effective \(\Q\)-Cartier divisor at a +place whose center lies in its support is strictly positive. Thus every +former zero discrepancy becomes positive, and every former positive +discrepancy stays positive. The pairs \((T_i,\widehat B_i+\M)\) are gklt. + +We check the two ample signs after this full deletion. For a step write +\[ + T_i\xrightarrow{f}Z\xleftarrow{f^+}T_{i+1}, + \qquad L=\Exc(f),\quad L^+=\Exc(f^+). +\] +Lemma~\ref{lem:small-comparison} gives a common exceptional image \(A\) +with \(L=f^{-1}(A)\), \(L^+=(f^+)^{-1}(A)\), and both maps isomorphisms +off \(A\). Properness makes \(f(\Supp H_i)\) closed. It is disjoint from +\(A\), because \(\Supp H_i\cap L=\varnothing\). On the base open +\(Z\setminus f(\Supp H_i)\), which contains \(A\), the divisor \(H_i\) +vanishes, so \(-\widehat D_i=-D_i+H_i\) has the original relative ample +sign. On \(Z\setminus A\) the map \(f\) is an isomorphism, and every line +bundle is relatively ample for an isomorphism. These two opens cover +\(Z\). After clearing a common Cartier multiple, relative ampleness is +local on the base, so \(-\widehat D_i\) is \(f\)-ample. The identical +argument with \(f^+\) and \(H_{i+1}\) proves that +\(\widehat D_{i+1}=D_{i+1}-H_{i+1}\) is \(f^+\)-ample. + +Reindex this floor-deleted tail at its first model and regard it as a +sequence of the arbitrary small diagrams in Theorem~\ref{thm:strong-gklt}. +The model and diagram hypotheses are inherited; the new boundaries are +effective and related by strict transform, the actual adjoints are +\(\Q\)-Cartier, and the two ample signs have just been checked. A common +carrier for the finite preceding portion, projective over the new first +model, supplies the fixed analytically nef divisor. In this application +the detector integer is chosen afresh for the new initial boundary and +nef carrier. The theorem makes the tail finite, contradicting its +construction. +\end{proof} + +To lift a prescribed downstairs diagram, we run gdlt continuation over +its base. Theorem~\ref{thm:gdlt} forces the chosen run to reach a nef +adjoint, and Lemma~\ref{lem:nef-ample} gives a projective crepant morphism +from that endpoint to the prescribed positive model. A negative +multisection ensures that the run contains a step. + +\begin{lemma}[A nonempty gdlt lift]\label{lem:nonempty-lift} +Let +\[ + X\xrightarrow{\ f\ }Z\xleftarrow{\ f^+\ }X^+ +\] +be any one of the small diagrams allowed in Theorem~\ref{thm:main}, with +normal globally Weil \(\Q\)-factorial compact K\"ahler fourfolds on the two +sides, effective rational boundaries \(B,B^+\) related by strict transform, +the same rational nef b-divisor, and the compatible actual adjoints +\(D_X,D_{X^+}\). Assume \((X,B+\M)\) is glc, and represent the b-divisor +by an analytically nef \(\Q\)-Cartier divisor on a projective carrier over +\(X\). Suppose +\[ + h:(Y,\Theta+\M)\longrightarrow(X,B+\M) +\] +is a projective crepant gdlt modification as in +Proposition~\ref{prop:gdlt-modification}; in particular \(Y\) is strong, +\(\Theta\geq0\), and every \(h\)-exceptional prime has coefficient one. +Then there is a finite sequence of elementary negative gdlt steps over +\(Z\), of length \(m\geq1\), +\[ + (Y,\Theta+\M)=(Y_0,\Theta_0+\M) + \dashrightarrow\cdots\dashrightarrow(Y_m,\Theta_m+\M), +\] +and a projective bimeromorphic morphism \(h^+:Y_m\to X^+\) such that +\[ + K_{Y_m}+\Theta_m+M_{Y_m}=(h^+)^*D_{X^+}. +\] +The end is a strong normal compact K\"ahler gdlt model with effective +boundary, and every \(h^+\)-exceptional prime has coefficient one in +\(\Theta_m\). Thus it is again a crepant gdlt modification of the same +type. +\end{lemma} + +\begin{proof} +The composite \(Y\to Z\) is projective bimeromorphic to a normal compact +K\"ahler base. On a projective common carrier, the fixed analytically nef +divisor is nef over \(Z\). Thus the continuation assertion of +Proposition~\ref{prop:relative-program} applies to this gdlt pair and to +every non-nef finite prefix produced from it. + +The initial adjoint \(D_Y=h^*D_X\) is not nef over \(Z\). Indeed, the +nonisomorphic projective contraction \(f\) has a positive-dimensional +fiber, and projective hyperplane cuts give a compact irreducible curve +\(C\) in that fiber. The negative ample sign gives \(D_X\cdot C<0\). +There is a compact irreducible curve \(C'\subset Y\) mapping onto \(C\). +For completeness, normalize \(C\), take an irreducible component of its +base change under \(h\) which dominates that normalization, and write +\(r\) for its generic fiber dimension. The normalization of \(C\) is a +projective compact curve, so this component, being projective over it, is +projective. A sufficiently high very ample system on the component has +\(r\) general members whose intersection with a generic fiber is a +nonempty zero-dimensional cycle. Their intersection therefore has a +compact curve component dominating the base. Its image in \(Y\) is such +a \(C'\). The induced map of normalized curves has a positive finite +degree. The projection formula now gives +\[ + D_Y\cdot C'=\deg(C'/C)\,D_X\cdot C<0. +\] +In particular, any run reaching nefness must contain at least one step. + +Choose an elementary negative step whenever the current adjoint is not +nef over \(Z\). The relative continuation assertion keeps all outputs +projective over \(Z\), strong normal compact K\"ahler, and gdlt with the +transported data. All models in the run are irreducible: \(Y\) is +bimeromorphic to the irreducible \(X\), and every elementary step is +bimeromorphic. If this process never reached a nef adjoint, it would +give an infinite elementary gdlt sequence with the fixed analytically nef +b-divisor. This contradicts Theorem~\ref{thm:gdlt}. We obtain a finite +run of length \(m\geq1\) with end adjoint \(D_{Y_m}\) nef over \(Z\). + +Take a smooth common model \(W\) with projective maps to the models in the +run, to \(X^+\), and to the nef carrier, all over \(Z\). Write \(P_0,P,P_+\) for the pullbacks +of \(D_Y,D_{Y_m},D_{X^+}\), respectively. By +Lemma~\ref{lem:program-comparison}, the finite run gives +\[ + P_0=P+G,\qquad G\geq0\text{ exceptional over }Y_m. +\] +Initial crepancy identifies \(P_0\) with the pullback of \(D_X\). +Lemma~\ref{lem:small-comparison}, pulled to \(W\), gives the second +comparison +\[ + P_0=P_++F,\qquad F\geq0\text{ exceptional over }X^+. +\] +The first end is nef over \(Z\), and \(D_{X^+}\) is ample over \(Z\). +Lemma~\ref{lem:nef-ample} therefore gives an actual equality \(P=P_+\) +and a projective morphism \(h^+:Y_m\to X^+\) over \(Z\) with +\(D_{Y_m}=(h^+)^*D_{X^+}\). + +The end is strong, gdlt, and has effective boundary by the relative +program. It remains to check its exceptional primes. Every prime on +\(Y_m\) has a strict-transform prime on \(Y\), because an elementary +program extracts no prime divisors. Let \(R\) be exceptional for +\(h^+\), and let \(R_0\) be its prime on \(Y\). If \(R_0\) were not +exceptional for \(h\), it would represent a prime on \(X\). Smallness +downstairs identifies that prime with a prime on \(X^+\). The place of +\(R\) would then have a divisorial center on \(X^+\), contradicting its +exceptionality. Hence \(R_0\) is \(h\)-exceptional and has coefficient +one in \(\Theta\). Boundary coefficients of surviving primes are +unchanged by an elementary program, so \(R\) has coefficient one in +\(\Theta_m\). The displayed crepant equality also identifies its +discrepancy over \(X^+\) as zero. This proves the lemma. +\end{proof} + +\begin{proof}[Proof of Theorem~\ref{thm:main}] +Assume that the sequence in the theorem is infinite. By +Lemma~\ref{lem:small-comparison}, every global discrepancy is nondecreasing +along it. Hence every \((X_i,B_i+\M)\) is glc. The rational b-line +realization of the initial data satisfies +Proposition~\ref{prop:gdlt-modification}: \(X_0\) is a normal compact +K\"ahler fourfold, the boundary is effective and rational, the nef datum +has a projective carrier, and the adjoint is rationally invertible. The +proposition gives a projective crepant gdlt modification +\[ + h_0:(Y_0,\Theta_0+\M)\longrightarrow(X_0,B_0+\M) +\] +with a strong normal compact K\"ahler source and only coefficient-one +exceptional primes. It requires no strong factoriality of \(X_0\). + +Apply Lemma~\ref{lem:nonempty-lift} to the first downstairs diagram and +\(h_0\). Its endpoint is a crepant gdlt modification of the same type over +\(X_1\), so it is the input for the next application. At every finite +stage a common projective carrier supplies the fixed analytically nef +data over the current downstairs model. Induction therefore lifts every +downstairs diagram. Each lifted string is finite and contains at least one +elementary step, and its endpoint is used as the literal starting model of +the next string. Their concatenation is an infinite sequence of elementary +gdlt steps on strong normal irreducible compact K\"ahler fourfolds, with the same +b-divisor throughout. Theorem~\ref{thm:gdlt} allows the bases to vary and +rules out this sequence. The contradiction proves +Theorem~\ref{thm:main}. +\end{proof} + +\begin{thebibliography}{99} +\raggedright + +\bibitem{AlexeevHaconKawamata2007} +Valery Alexeev, Christopher Hacon, and Yujiro Kawamata, +\emph{Termination of (many) 4-dimensional log flips}, +Invent. Math. \textbf{168} (2007), no.~2, 433--448. +\url{https://doi.org/10.1007/s00222-007-0038-1}. + +\bibitem{BierstoneMilman1997} +Edward Bierstone and Pierre D. Milman, +\emph{Canonical desingularization in characteristic zero by blowing up the +maximum strata of a local invariant}, +Invent. Math. \textbf{128} (1997), no.~2, 207--302. +\url{https://doi.org/10.1007/s002220050141}. + +\bibitem{BirkarZhang2016} +Caucher Birkar and De-Qi Zhang, +\emph{Effectivity of Iitaka fibrations and pluricanonical systems of polarized pairs}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{123} (2016), 283--331. +\url{https://doi.org/10.1007/s10240-016-0080-x}. + +\bibitem{ChenTsakanikas2023} +Guodu Chen and Nikolaos Tsakanikas, +\emph{On the termination of flips for log canonical generalized pairs}, +Acta Math. Sin. (Engl. Ser.) \textbf{39} (2023), no.~6, 967--994. +\url{https://doi.org/10.1007/s10114-023-0116-3}. + +\bibitem{DeligneLefschetz} +Pierre Deligne, +\emph{Th\'eor\`eme de Lefschetz et crit\`eres de d\'eg\'en\'erescence de suites spectrales}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{35} (1968), 107--126. +\url{https://doi.org/10.1007/BF02698925}. + +\bibitem{DeligneHodgeII} +Pierre Deligne, +\emph{Th\'eorie de Hodge : II}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{40} (1971), 5--57. +\url{https://doi.org/10.1007/BF02684692}. + +\bibitem{DeligneHodgeIII} +Pierre Deligne, +\emph{Th\'eorie de Hodge : III}, +Publ. Math. Inst. Hautes \'{E}tudes Sci. \textbf{44} (1974), 5--77. +\url{https://doi.org/10.1007/BF02685881}. + +\bibitem{ForstnericStein} +Franc Forstneri\v{c}, +\emph{Extending holomorphic mappings from subvarieties in Stein manifolds}, +Ann. Inst. Fourier (Grenoble) \textbf{55} (2005), no.~3, 733--751. +\url{https://doi.org/10.5802/aif.2112}. + +\bibitem{Fujino2005Addendum} +Osamu Fujino, +\emph{Addendum to \textquotedblleft Termination of 4-fold canonical flips\textquotedblright}, +Publ. Res. Inst. Math. Sci. \textbf{41} (2005), no.~1, 251--257. +\url{https://doi.org/10.2977/PRIMS/1145475410}. + +\bibitem{FujinoAnalyticMMP} +Osamu Fujino, +\emph{Minimal model program for projective morphisms between complex analytic spaces}, +arXiv:2201.11315v1 (2022). +\url{https://arxiv.org/abs/2201.11315v1}. + +\bibitem{GoreskyMacPhersonIHII} +Mark Goresky and Robert MacPherson, +\emph{Intersection homology II}, +Invent. Math. \textbf{72} (1983), no.~1, 77--129. +\url{https://doi.org/10.1007/BF01389130}. + +\bibitem{Grauert1962} +Hans Grauert, +\emph{\"Uber Modifikationen und exzeptionelle analytische Mengen}, +Math. Ann. \textbf{146} (1962), 331--368. +\url{https://doi.org/10.1007/BF01441136}. + +\bibitem{GrothendieckHilbert1961} +Alexander Grothendieck, +\emph{Techniques de construction et th\'eor\`emes d'existence en g\'eom\'etrie +alg\'ebrique IV : les sch\'emas de Hilbert}, +in \emph{S\'eminaire Bourbaki : ann\'ees 1960/61, expos\'es 205--222}, +S\'eminaire Bourbaki \textbf{6}, Soci\'et\'e Math\'ematique de France, +1961, Expos\'e 221, 249--276; erratum, vol.~7 (1962), p.~302. +\url{https://www.numdam.org/item/SB_1960-1961__6__249_0/}. + +\bibitem{HaconMoraga2020} +Christopher Hacon and Joaqu\'in Moraga, +\emph{On weak Zariski decompositions and termination of flips}, +Math. Res. Lett. \textbf{27} (2020), no.~5, 1393--1421. +\url{https://doi.org/10.4310/MRL.2020.v27.n5.a6}. + +\bibitem{HaconXie2026} +Christopher Hacon and Lingyao Xie, +\emph{On the K\"ahler MMP and the transcendental base-point-free theorem}, +arXiv:2607.24986v1 (2026), submitted July 27, 2026. +\url{https://arxiv.org/abs/2607.24986v1}. + +\bibitem{HanLiuZhuang2025} +Jingjun Han, Jihao Liu, and Ziquan Zhuang, +\emph{Effective termination of general type MMPs in dimension at most five}, +arXiv:2509.01501v1 (2025). +\url{https://arxiv.org/abs/2509.01501v1}. + +\bibitem{KawamataMatsudaMatsuki1987} +Yujiro Kawamata, Katsumi Matsuda, and Kenji Matsuki, +\emph{Introduction to the minimal model problem}, +in \emph{Algebraic Geometry, Sendai, 1985}, Tadao Oda (ed.), +Advanced Studies in Pure Mathematics \textbf{10}, +North-Holland, Amsterdam, 1987, 283--360. +\url{https://doi.org/10.2969/aspm/01010283}. + +\bibitem{Moraga2025} +Joaqu\'in Moraga, +\emph{Termination of pseudo-effective 4-fold flips}, +Math. Z. \textbf{310} (2025), no.~4, Article 73, 32 pp. +\url{https://doi.org/10.1007/s00209-025-03766-y}. + +\bibitem{KahlerAuxiliary} +OpenAI, +\emph{Finite ordinary minimal model programs on compact K\"ahler fourfolds}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026/paper.pdf}{OAI:Finite-ordinary-minimal-model-programs-on-compact-Kahler-fourfolds-October-6-2026}, +2026. + +\bibitem{ProjectiveLCFourfolds} +OpenAI, +\emph{Termination for projective log canonical fourfolds with rational boundary}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Termination-for-projective-log-canonical-fourfolds-with-rational-boundary-September-24-2026/paper.pdf}{OAI:Termination-for-projective-log-canonical-fourfolds-with-rational-boundary-September-24-2026}, +2026. + +\bibitem{CanonicalKahler} +OpenAI, +\emph{Termination of generalized-canonical flips on compact K\"ahler fourfolds}, +OpenAI Math Release preprint +\href{https://github.com/openai/math/blob/main/preprints/Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026/termination-generalized-terminal-flips-compact-kahler-fourfolds.pdf}{OAI:Termination-of-generalized-canonical-flips-on-compact-Kahler-fourfolds-October-6-2026}, +2026. + +\bibitem{RaynaudSGA1XII} +Mich\`ele Raynaud, +\emph{G\'eom\'etrie alg\'ebrique et g\'eom\'etrie analytique}, +in \emph{Rev\^etements \'etales et groupe fondamental (SGA 1)}, +Alexander Grothendieck (ed.), Lecture Notes in Mathematics \textbf{224}, +Springer-Verlag, Berlin--Heidelberg, 1971, Expos\'e XII, 311--343. +\url{https://doi.org/10.1007/BFb0058667}. + +\bibitem{SaitoMHP} +Morihiko Saito, +\emph{Modules de Hodge polarisables}, +Publ. Res. Inst. Math. Sci. \textbf{24} (1988), no.~6, 849--995. +\url{https://doi.org/10.2977/PRIMS/1195173930}. + +\bibitem{SerreGAGA} +Jean-Pierre Serre, +\emph{G\'eom\'etrie alg\'ebrique et g\'eom\'etrie analytique}, +Ann. Inst. Fourier (Grenoble) \textbf{6} (1956), 1--42. +\url{https://doi.org/10.5802/aif.59}. + +\bibitem{ShokurovNonvanishing} +V. V. Shokurov, +\emph{The nonvanishing theorem}, +Math. USSR-Izv. \textbf{26} (1986), no.~3, 591--604. +Russian original: Izv. Akad. Nauk SSSR Ser. Mat. \textbf{49} (1985), +no.~3, 635--651. +\url{https://doi.org/10.1070/IM1986v026n03ABEH001160}. + +\end{thebibliography} + +\end{document} diff --git a/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/termination-generalized-lc-kahler-fourfolds.pdf b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/termination-generalized-lc-kahler-fourfolds.pdf new file mode 100644 index 0000000000000000000000000000000000000000..0377fb54027a8dcb3963101e5152938823dc3a24 --- /dev/null +++ b/preprints/Termination-of-generalized-log-canonical-flips-on-compact-Kahler-fourfolds-October-7-2026/termination-generalized-lc-kahler-fourfolds.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0e35c0328f2caef0bdbfcdc30347da8c78e209515ff5bd112114ceed51a9e97 +size 646791 diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/README.md b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9b066f270c2255476f8d12b2b32018c7da9a103a --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [The Gaussian free field limit of integer Lipschitz heights with two-arc boundary data](paper.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026, + author = {{OpenAI}}, + title = {{The Gaussian free field limit of integer Lipschitz heights with two-arc boundary data}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/paper.pdf}{OAI:The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version derives the conditional cut and loop estimates from the companion weighted annulus circuit theorem at $x=1$; see the [previous version](../The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-September-25-2026/paper.pdf). diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/figures/boundary-arches.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/figures/boundary-arches.tex new file mode 100644 index 0000000000000000000000000000000000000000..4f7670c1446b6ac8494a758b5d6b29f10c7bad6c --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/figures/boundary-arches.tex @@ -0,0 +1,60 @@ +\begin{tikzpicture}[x=0.42cm,y=0.42cm,>=Stealth,font=\small] + \fill[gray!12,even odd rule] (-7,-7) rectangle (7,7) + (-5,-5) rectangle (5,5); + \fill[gray!24,even odd rule] (-1,-1) rectangle (1,1) + (-.5,-.5) rectangle (.5,.5); + \fill[blue!3] (-5,0) rectangle (5,5); + \fill[gray!24,even odd rule] (-1,-1) rectangle (1,1) + (-.5,-.5) rectangle (.5,.5); + \draw[gray!60] (-7,-7) rectangle (7,7); + \draw[gray!60] (-5,-5) rectangle (5,5); + \draw[gray!65] (-1,-1) rectangle (1,1); + \draw[gray!65] (-.5,-.5) rectangle (.5,.5); + \node[anchor=east,font=\scriptsize] at (-7.35,7) {$Q_{7\ell}$}; + \draw[gray!65,thin] (-7.25,7)--(-7,7); + \node[anchor=east,font=\scriptsize] at (-7.35,5) {$Q_{5\ell}$}; + \draw[gray!65,thin] (-7.25,5)--(-5,5); + \node[anchor=center,font=\scriptsize,fill=white,inner sep=.5pt] at (0,1.5) {$Q_\ell$}; + \draw[gray!65,thin] (0,1.1)--(0,1); + \node[anchor=center,font=\scriptsize] at (0,-1.45) {$Q_{\ell/2}$}; + \draw[gray!65,thin] (0,-1.12)--(0,-.5); + \draw[black!65,thick] (-7.35,0)--(7.35,0); + \node[anchor=south east,font=\scriptsize] at (7.25,.15) {clean boundary}; + \node[blue!65!black] at (0,4) {free middle}; + \node[gray!70!black] at (0,-4) {artificial exterior}; + \node[font=\scriptsize] at (0,6.05) {outer strip}; + \node[anchor=east,font=\scriptsize,fill=white,inner sep=1pt] at (-2.7,-1.1) {inner strip}; + \draw[gray!65,thin] (-2.65,-1.1)--(-1,-.8); + \draw[blue!70!black,line width=1.3pt] (-2,.08)--(-2,2)--(2,2)--(2,.08); + \draw[blue!70!black,line width=1.3pt] (-2.35,.35)--(-1.65,.35); + \draw[blue!70!black,line width=1.3pt] (1.65,.35)--(2.35,.35); + \draw[blue!70!black,dashed,line width=1.1pt] + (-2,.02)--(-2,-2)--(2,-2)--(2,.02); + \draw[orange!80!black,line width=1.2pt] (-2.1,.02)--(-1.95,.65); + \draw[orange!80!black,line width=1.2pt] (1.9,.02)--(2.05,.65); + \draw[black!65,densely dotted] (-2.5,-.25) rectangle (-1.5,.85); + \draw[black!65,densely dotted] (1.5,-.25) rectangle (2.5,.85); + \fill (0,0) circle (.065); + \node[anchor=north west,font=\scriptsize] at (.08,-.02) {$p$}; + \node[anchor=north,font=\scriptsize,fill=white,inner sep=1pt] at (-2,-.3) {$q_L$}; + \node[anchor=north,font=\scriptsize,fill=white,inner sep=1pt] at (2,-.3) {$q_R$}; + \node[anchor=south,font=\scriptsize] at (0,2.12) {bulk joining tube}; + \begin{scope}[shift={(12,-.15)},x=1.4cm,y=0.65cm] + \fill[blue!3] (-1.1,0) rectangle (1.1,3.65); + \draw[black!60] (-1.15,0)--(1.15,0); + \draw[orange!80!black,line width=2pt] (-.3,0)--(.3,0); + \node[anchor=north,font=\scriptsize] at (0,-.13) {anchored high patch}; + \draw[red!70!black,line width=1.1pt] (-.70,0)--(-.73,1.1)--(-.64,2.1)--(-.68,3.45); + \draw[red!70!black,line width=1.1pt] (.70,0)--(.65,1.2)--(.74,2.2)--(.68,3.45); + \node[rotate=90,font=\scriptsize,red!65!black] at (-.83,1.85) {low barrier}; + \node[rotate=90,font=\scriptsize,red!65!black] at (.88,1.85) {low barrier}; + \draw[orange!80!black,line width=1.3pt] (-.1,0).. controls (.2,.3) and (-.18,.8)..(.12,1.15); + \draw[gray!70,densely dashed] (-1.05,1)--(1.05,1); + \node[anchor=west,font=\scriptsize] at (1.09,1) {$d$}; + \fill (0,3) circle (.035); + \node[anchor=north,align=center,font=\scriptsize] at (0,2.8) {$x$ at depth\\$3d$}; + \draw[gray!60,densely dotted] (-1.04,-.05) rectangle (1.04,3.6); + \node[align=center,font=\scriptsize] at (0,4.3) {Synthetic attachment\\vertical scale magnified}; + \end{scope} +\end{tikzpicture} + diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/figures/pin-moving.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/figures/pin-moving.tex new file mode 100644 index 0000000000000000000000000000000000000000..2b6610557fd332579a2f76e3030d254343bc9ba9 --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/figures/pin-moving.tex @@ -0,0 +1,42 @@ +\begin{tikzpicture}[x=1cm,y=1cm,>=Stealth, + group/.style={draw=blue!55!black,fill=blue!8,rounded corners=3pt, + minimum width=8mm,minimum height=6mm,font=\small}, + ins/.style={circle,draw=black,fill=white,inner sep=2pt,font=\small}, + move/.style={->,very thick,draw=blue!65!black}, + guide/.style={dashed,gray!55}] +\begin{scope}[shift={(0,0)}] + \draw[guide] (-1.25,.55)--(1.25,.55); + \draw[guide] (-1.25,-.55)--(1.25,-.55); + \node[ins] at (0,0) {$X$}; + \node[group] at (-1,0) {$L$}; + \node[group] at (1,0) {$R$}; + \node[group] at (0,.95) {$T$}; + \node[group] at (0,-.95) {$B$}; + \draw[move] (0,1.32)--(0,1.88); + \draw[move] (0,-1.32)--(0,-1.88); + \node[font=\small,align=center] at (0,-2.4) + {1. Vertical separation\\$+e$ and $-e$}; +\end{scope} +\begin{scope}[shift={(4.5,0)}] + \draw[guide] (-.7,1.22)--(.7,-1.22); + \node[ins] at (0,0) {$X$}; + \node[group] at (.92,.56) {$T,R$}; + \node[group] at (-.92,-.56) {$B,L$}; + \draw[move] (1.35,.82)--(1.95,1.17) + node[right,font=\small] {$u$}; + \draw[move] (-1.35,-.82)--(-1.95,-1.17); + \node[font=\small,align=center] at (0,-2.4) + {2. Oblique separation\\$+u$ and $-u$}; +\end{scope} +\begin{scope}[shift={(10,0)}] + \node[ins] at (0,0) {$X$}; + \node[group] at (1.04,1.1) {$T,R$}; + \node[group] at (-.65,-.7) {$B,L$}; + \draw[move] (-1.06,-.35)--(-2.792,.65) + node[above,font=\small] {$u'$}; + \draw[guide] (-2.15,.48)--(1.55,.48); + \node[font=\small,align=center] at (0,-2.4) + {3. Raise the remaining group\\along $+u'$}; +\end{scope} +\end{tikzpicture} + diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/paper.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/paper.tex new file mode 100644 index 0000000000000000000000000000000000000000..505d4badd481e786cd20c0d9986989800efbea7f --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/paper.tex @@ -0,0 +1,120 @@ +\PassOptionsToPackage{hyphens}{url} +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\input{glyphtounicode} +\pdfglyphtounicode{angbracketleftBigg}{27E8} +\pdfglyphtounicode{angbracketleftbig}{27E8} +\pdfglyphtounicode{angbracketrightBigg}{27E9} +\pdfglyphtounicode{angbracketrightbig}{27E9} +\pdfglyphtounicode{arrowhookleft}{02D3} +\pdfglyphtounicode{braceex}{23AA} +\pdfglyphtounicode{braceleftbigg}{007B} +\pdfglyphtounicode{braceleftbt}{23A9} +\pdfglyphtounicode{braceleftmid}{23A8} +\pdfglyphtounicode{bracelefttp}{23A7} +\pdfglyphtounicode{bracerightbigg}{007D} +\pdfglyphtounicode{bracketleftbig}{005B} +\pdfglyphtounicode{bracketleftbigg}{005B} +\pdfglyphtounicode{bracketleftbt}{23A3} +\pdfglyphtounicode{bracketlefttp}{23A1} +\pdfglyphtounicode{bracketrightbig}{005D} +\pdfglyphtounicode{bracketrightbigg}{005D} +\pdfglyphtounicode{bracketrightbt}{23A6} +\pdfglyphtounicode{bracketrighttp}{23A4} +\pdfglyphtounicode{hatwide}{0302} +\pdfglyphtounicode{integraldisplay}{222B} +\pdfglyphtounicode{integraltext}{222B} +\pdfglyphtounicode{intersectiondisplay}{22C2} +\pdfglyphtounicode{intersectiontext}{22C2} +\pdfglyphtounicode{mapsto}{007C} +\pdfglyphtounicode{parenleftBig}{0028} +\pdfglyphtounicode{parenleftBigg}{0028} +\pdfglyphtounicode{parenleftbig}{0028} +\pdfglyphtounicode{parenleftbigg}{0028} +\pdfglyphtounicode{parenleftbt}{239D} +\pdfglyphtounicode{parenlefttp}{239B} +\pdfglyphtounicode{parenrightBig}{0029} +\pdfglyphtounicode{parenrightBigg}{0029} +\pdfglyphtounicode{parenrightbig}{0029} +\pdfglyphtounicode{parenrightbigg}{0029} +\pdfglyphtounicode{parenrightbt}{23A0} +\pdfglyphtounicode{parenrighttp}{239E} +\pdfglyphtounicode{productdisplay}{220F} +\pdfglyphtounicode{producttext}{220F} +\pdfglyphtounicode{radicalbig}{221A} +\pdfglyphtounicode{summationdisplay}{2211} +\pdfglyphtounicode{summationtext}{2211} +\pdfglyphtounicode{uniontext}{22C3} +\pdfglyphtounicode{vextenddouble}{2225} +\pdfglyphtounicode{vextendsingle}{007C} +\pdfgentounicode=1 +\usepackage[margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools,mathrsfs} +\usepackage[expansion=false]{microtype} +\usepackage{enumitem,booktabs,array} +\usepackage{needspace} +\usepackage{graphicx,tikz} +\usetikzlibrary{arrows.meta,calc,patterns,positioning} +\usepackage[unicode,colorlinks=true,linkcolor=blue!45!black,citecolor=blue!45!black,urlcolor=blue!45!black]{hyperref} +\usepackage[capitalise,noabbrev,nameinlink]{cleveref} +\hypersetup{pdftitle={The Gaussian free field limit of integer Lipschitz heights with two-arc boundary data},pdfauthor={OpenAI}} +\numberwithin{equation}{section} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{remark}[theorem]{Remark} +\newcommand{\preserveresulttype}[1]{% + \AtBeginEnvironment{#1}{\crefalias{theorem}{#1}}} +\forcsvlist{\preserveresulttype}{theorem,proposition,lemma,corollary,definition,remark} +\makeatletter +\newcommand{\reserveresultspace}[1]{% + \BeforeBeginEnvironment{#1}{% + \if@nobreak\else\Needspace{4\baselineskip}\fi}} +\makeatother +\forcsvlist{\reserveresultspace}{theorem,proposition,lemma,corollary,definition,remark} +\newcommand{\PP}{\mathbb P} +\newcommand{\EE}{\mathbb E} +\newcommand{\R}{\mathbb R} +\newcommand{\Z}{\mathbb Z} +\newcommand{\N}{\mathbb N} +\newcommand{\C}{\mathbb C} +\newcommand{\Tri}{\mathbb T} +\newcommand{\eps}{\varepsilon} +\newcommand{\one}{\mathbf 1} +\DeclareMathOperator{\Var}{Var} +\DeclareMathOperator{\Cov}{Cov} +\DeclareMathOperator{\dist}{dist} +\DeclareMathOperator{\supp}{supp} +\DeclareMathOperator{\Rea}{Re} +\DeclareMathOperator{\Ima}{Im} +\DeclarePairedDelimiter{\abs}{\lvert}{\rvert} +\DeclarePairedDelimiter{\norm}{\lVert}{\rVert} +\setlist[itemize]{topsep=4pt,itemsep=2pt} +\setlist[enumerate]{topsep=4pt,itemsep=2pt} +\title{The Gaussian free field limit of integer Lipschitz heights with two-arc boundary data} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\maketitle +\begin{abstract} +We prove that the centered uniform odd integer height function on triangular-lattice approximations of a smooth simply connected domain, with neighboring differences zero or two and boundary values $+1$ and $-1$ on two arcs, converges to a universal multiple of the Dirichlet Gaussian free field. This resolves the field part of Schramm's Problem~2.2. We give an absolutely convergent finite-volume formula for the normalization. The proof combines reflection positivity, a spectral sum rule, and boundary comparison with Gaussian moment identities. +\end{abstract} +\tableofcontents +\input{sections/01-introduction} +\input{sections/02-spin} +\input{sections/03-cuts} +\input{sections/04-moments} +\input{sections/05-spectral} +\input{sections/06-normalization} +\input{sections/07-pins} +\input{sections/08-boundary} +\input{sections/09-limits} +\input{sections/10-gaussian} +\bibliographystyle{plain} +\bibliography{references} +\end{document} diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/references.bib b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..74b62e9fdadf4693289e0fb54c02762bc2f20347 --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/references.bib @@ -0,0 +1,137 @@ +@incollection{Schramm2007, + author = {Schramm, Oded}, + title = {Conformally invariant scaling limits: an overview and a collection of problems}, + booktitle = {Proceedings of the International Congress of Mathematicians, Madrid, 2006}, + volume = {I}, + editor = {Sanz-Sol{\'e}, Marta and Soria, Javier and Varona, Juan L. and Verdera, Joan}, + publisher = {European Mathematical Society}, + address = {Z{\"u}rich}, + year = {2007}, + pages = {513--543}, + doi = {10.4171/022-1/20}, + note = {\href{https://arxiv.org/abs/math/0602151v2}{arXiv:math/0602151v2}} +} + +@article{GM2021, + author = {Glazman, Alexander and Manolescu, Ioan}, + title = {Uniform {Lipschitz} functions on the triangular lattice have logarithmic variations}, + journal = {Communications in Mathematical Physics}, + volume = {381}, + number = {3}, + year = {2021}, + pages = {1153--1221}, + doi = {10.1007/s00220-020-03920-z}, + note = {Revised version: \href{https://arxiv.org/abs/1810.05592v3}{arXiv:1810.05592v3} (2023)} +} + +@article{GRST2019, + author = {Gozlan, Nathael and Roberto, Cyril and Samson, Paul-Marie and Tetali, Prasad}, + title = {Transport proofs of some discrete variants of the {Pr\'ekopa--Leindler} inequality}, + journal = {Annali della Scuola Normale Superiore di Pisa, Classe di Scienze}, + series = {5}, + volume = {22}, + number = {3}, + year = {2021}, + pages = {1207--1232}, + doi = {10.2422/2036-2145.201906_002}, + note = {Numbered citations refer to \href{https://arxiv.org/abs/1905.04038v1}{arXiv:1905.04038v1}} +} + +@article{GL2025, + author = {Glazman, Alexander and Lammers, Piet}, + title = {Delocalisation and continuity in {2D}: loop {O(2)}, six-vertex, and random-cluster models}, + journal = {Communications in Mathematical Physics}, + volume = {406}, + year = {2025}, + eid = {108}, + pages = {Article 108}, + doi = {10.1007/s00220-025-05259-9}, + note = {59 pp.; \href{https://doi.org/10.1007/s00220-025-05259-9}{doi:10.1007/s00220-025-05259-9}} +} + +@article{FILS1978, + author = {Fr{\"o}hlich, J{\"u}rg and Israel, Robert and Lieb, Elliott H. and Simon, Barry}, + title = {Phase Transitions and Reflection Positivity. {I}. General Theory and Long Range Lattice Models}, + journal = {Communications in Mathematical Physics}, + volume = {62}, + year = {1978}, + pages = {1--34}, + doi = {10.1007/BF01940327} +} + +@article{Kenyon2001, + author = {Kenyon, Richard}, + title = {Dominos and the {Gaussian} Free Field}, + journal = {The Annals of Probability}, + volume = {29}, + number = {3}, + year = {2001}, + pages = {1128--1137}, + doi = {10.1214/aop/1015345599}, + note = {Numbered citations refer to \href{https://arxiv.org/abs/math-ph/0002027v1}{arXiv:math-ph/0002027v1}} +} + +@misc{OpenAIBalancedSixVertex2026, + author = {{OpenAI}}, + title = {{The Gaussian free field limit of the balanced six-vertex model with variance multiplier $1/\arcsin(c/2)$}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026/The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026.pdf}{OAI:The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026}}, + year = {2026}, + note = {Theorem~1.1} +} + +@misc{OpenAIWeighted2026, + author = {{OpenAI}}, + title = {{Gaussian free-field limits of weighted integer Lipschitz heights}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026/paper.pdf}{OAI:Gaussian-free-field-limits-of-weighted-integer-Lipschitz-heights-October-6-2026}}, + year = {2026}, + note = {Theorem~2.3 and Appendix~B} +} + +@misc{Usui2012, + author = {Usui, Kouta}, + title = {A Note on Reflection Positivity and the {Umezawa--Kamefuchi--K\"all\'en--Lehmann} Representation of Two Point Correlation Functions}, + year = {2012}, + note = {\href{https://arxiv.org/abs/1201.3415v3}{arXiv:1201.3415v3}, March 2, 2012} +} + +@article{KlartagLehec2019, + author = {Klartag, Bo'az and Lehec, Joseph}, + title = {Poisson processes and a log-concave {Bernstein} theorem}, + journal = {Studia Mathematica}, + volume = {247}, + number = {1}, + year = {2019}, + pages = {85--107}, + doi = {10.4064/sm180212-30-7}, + note = {\href{https://arxiv.org/abs/1802.04176v2}{arXiv:1802.04176v2}} +} + +@misc{DCKLM2026, + author = {Duminil-Copin, Hugo and Kozlowski, Karol Kajetan and Lammers, Piet and Manolescu, Ioan}, + title = {Gaussian free field convergence of the six-vertex model with {$-1\le\Delta\le-1/2$}}, + year = {2026}, + note = {\href{https://arxiv.org/abs/2603.06268v1}{arXiv:2603.06268v1}, March 6, 2026} +} + +@article{FKG1971, + author = {Fortuin, C. M. and Kasteleyn, P. W. and Ginibre, J.}, + title = {Correlation inequalities on some partially ordered sets}, + journal = {Communications in Mathematical Physics}, + volume = {22}, + year = {1971}, + pages = {89--103}, + doi = {10.1007/BF01651330} +} + +@article{Miller2011, + author = {Miller, Jason}, + title = {Fluctuations for the {Ginzburg--Landau} {$\nabla\phi$} Interface Model on a Bounded Domain}, + journal = {Communications in Mathematical Physics}, + volume = {308}, + year = {2011}, + pages = {591--639}, + doi = {10.1007/s00220-011-1315-9}, + note = {Numbered citations refer to \href{https://arxiv.org/abs/1002.0381v2}{arXiv:1002.0381v2}} +} diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/01-introduction.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..03a069071e6310af99f6d6031ff007439e919c83 --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/01-introduction.tex @@ -0,0 +1,258 @@ +\section{Introduction}\label{sec:introduction} + +Uniform Lipschitz heights are among the simplest random surface models with a +hard local constraint. Their planar fluctuations are expected to be governed +by the Gaussian free field. We prove this for integer heights on the +triangular lattice with the two-arc boundary condition proposed by Schramm. +The conclusion concerns the field, including all joint test-function limits +and distributional tightness. + +\subsection{The model and the limit} + +Write +\[ + \Tri=\Z(1,0)+\Z(1/2,\sqrt3/2) +\] +for the unit triangular lattice. Let $D\subset\R^2$ be bounded, smooth, and +simply connected, and let $a,b$ be distinct points of $\partial D$. They +divide the boundary into open arcs $A_+$ and $A_-$. For $\delta\downarrow0$, +let $D_\delta$ be simply connected polygonal domains made of triangles of +$\delta\Tri$, whose marked boundary parametrizations converge uniformly to +that of $(D,a,b)$. Put the discrete marks at the midpoints of distinct +boundary edges. The boundary vertices then split into disjoint sets +$A_{+,\delta}$ and $A_{-,\delta}$; no vertex receives two prescriptions. + +Choose $h_\delta$ uniformly among the odd integer functions on the vertices +of $D_\delta$ satisfying +\begin{equation}\label{eq:odd-model} + h_\delta=1\text{ on }A_{+,\delta},\qquad + h_\delta=-1\text{ on }A_{-,\delta},\qquad + |h_\delta(x)-h_\delta(y)|\in\{0,2\}\quad(x\sim y). +\end{equation} +Extend the function affinely on every triangle. For a test function +$f\in C_c^\infty(D)$, write $h_\delta(f)=\int h_\delta(x)f(x)\,dx$ once its +support lies in $D_\delta$. This convention is used for every smeared height +below. + +Our Dirichlet Gaussian free field $\Phi_D$ has covariance +\begin{equation}\label{eq:gff-convention} + \EE[\Phi_D(f)\Phi_D(g)] + =\iint_{D\times D}f(x)G_D(x,y)g(y)\,dx\,dy, + \qquad G_D=(-\Delta_D)^{-1}. +\end{equation} +In particular, the logarithmic singularity of $G_D(x,y)$ is +$(2\pi)^{-1}\log(1/|x-y|)$. Let $\bar g$ be the bounded harmonic extension +of the boundary data $+1$ on $A_+$ and $-1$ on $A_-$. + +\begin{theorem}\label{thm:main} +Let $D$ be a bounded smooth simply connected planar domain with two +distinct marked boundary points. Let $D_\delta$ be simply connected +triangular-lattice polygonal approximations with uniformly converging +marked boundary parametrizations and edge-midpoint marks, and let +$h_\delta$ have the uniform odd-height law \eqref{eq:odd-model}. +There is a constant $\sigma>0$, depending only on the unit triangular-lattice +model, such that +\[ + h_\delta\ \Longrightarrow\ \bar g+\sigma\Phi_D + \qquad\text{in }\mathcal D'(D). +\] +For every $f\in C_c^\infty(D)$, $\EE h_\delta(f)\to\int_D\bar g f$. +Consequently +\begin{equation}\label{eq:main-centered} + \frac{h_\delta-\EE h_\delta}{\sigma} + \ \Longrightarrow\ \Phi_D + \qquad\text{in }\mathcal D'(D). +\end{equation} +All finite vectors of test-function integrals converge jointly to the +corresponding Gaussian vectors, and all their mixed moments converge. +The constant is specified by the absolutely convergent finite-volume series +in \cref{prop:normalization-series}; in the spectral convention below, +$\sigma=4\pi\sqrt{c_*}$. +\end{theorem} + +It is convenient to prove the theorem for +\begin{equation}\label{eq:integer-height} + H_\delta=(h_\delta-1)/2, + \qquad g=0\text{ on }A_+,\quad g=-1\text{ on }A_-. +\end{equation} +Thus $H_\delta$ is integer valued and $|H_\delta(x)-H_\delta(y)|\le1$ on +edges. Write $m$ for the bounded harmonic extension of $g$, so +$\bar g=1+2m$. We will show that $H_\delta$ converges to +$m+\sqrt v\,\Phi_D$, where +\begin{equation}\label{eq:normalization-relations} + v=(2\pi)^2c_*,\qquad \sigma^2=4v. +\end{equation} +There is no logarithmic rescaling of the distribution-valued field. The +logarithmic divergence of point fluctuations is consistent with a finite +limit after smooth spatial averaging. + +\subsection{History and significance} + +Schramm's 2006 problem collection asks about the scaling limits of this +height function and its zero interface +\cite[Problem~2.2, p.~527]{Schramm2007}. +\Cref{thm:main} resolves the field part of that problem for smooth simply +connected domains, with the covariance convention made explicit in +\eqref{eq:gff-convention}. The +interface assertion is a separate question. The real-valued Lipschitz +model in Schramm's Problem~2.3, p.~528, is also distinct from the integer model +studied here. + +Glazman and Manolescu developed a two-spin representation with positive +association for the uniform integer Lipschitz model and studied its +logarithmic fluctuations \cite{GM2021}. Glazman and Lammers subsequently +studied delocalisation across a larger parameter range. Their 2025 article +discusses the Gaussian free field limit as a conjecture +\cite[Section~1.2.4]{GL2025}. The scale estimates used here are proved in +\cref{sec:cuts} from the annulus circuit estimate specified below. +Logarithmic fluctuations alone do not determine a Gaussian scaling limit. +The additional work here is to obtain comparisons under rare pinning, +identify the covariance, control the imposed boundary values, and determine +all joint moments. + +For real-valued gradient fields with smooth uniformly convex interactions, +Miller proved a bounded-domain GFF limit with continuous perturbations of +affine boundary data \cite[Theorem~1.1]{Miller2011}. The integer-valued law +studied here, with its hard constraint on every edge increment, lies outside +those hypotheses. + +Besides the loop estimates, we use the discrete midpoint +Pr\'ekopa--Leindler inequality of Klartag--Lehec +\cite[Theorem~1.4]{KlartagLehec2019}, in the nonnegative-function form of +Gozlan--Roberto--Samson--Tetali \cite[Theorem~3]{GRST2019}. Its role is to +turn central probability estimates into uniform higher moments. The +rounding and parity conditions needed for this application are verified +in \cref{sec:moments}. + +Reflection positivity is a classical method for converting spatial +symmetry and positivity into spectral information +\cite{FILS1978}. The reflection quotient and positive transfer used here +are closely related to the constructions in +\cite[Sections~3.1--3.3 and 4.1]{Usui2012}. We establish their exact +site-row and auxiliary-phase versions directly. The final moment +argument has a related predecessor in Kenyon's identification of dimer +height moments by matching collision poles in a determinant pairing identity +\cite[Lemma~3.1 and Proposition~3.2]{Kenyon2001}; here the collision +coefficients come from local cut mixing rather than a determinant formula. + +Duminil-Copin--Kozlowski--Lammers--Manolescu prove a full-plane GFF limit +for the zero-slope square-lattice six-vertex state with +$a=b=1$ and $c\in[\sqrt3,2]$ +\cite[Theorems~2.2 and 2.8]{DCKLM2026}. Their transfer representations, +analytic translation arguments, harmonic correlations and collision +analysis are substantial methodological precedents +\cite[Theorems~4.12 and 4.15; Sections~7--9]{DCKLM2026}. +The argument below uses triangular site reflections and a finite-rotation +angular sum to determine the plane covariance. Separated rare pins and +boundary attachments then connect this information to the actual +two-arc bounded-domain law. The normalization is specified by finite +counts and Fourier coefficients in \cref{sec:normalization}. + +For comparison, the prescribed iterated balanced-torus limit of the +square-lattice six-vertex model with $a=b=1$ gives a balanced zero-slope +plane state with a GFF scaling limit for each fixed $00$, uniformly for all sufficiently large $r$. Boundary-cell +factors are excluded in that theorem. At edge weight one their removal +leaves exactly the uniform coherent-pair law with the indicated +one-spin boundary condition. Only this annulus theorem is used from +\cite{OpenAIWeighted2026}. + +Fix $0<\eps<1/50$ for the local circuit constructions below. + +\begin{lemma}[Local double circuits]\label{lem:local-circuit} +There are $R>3$, $p>0$, and $r_0<\infty$ with the following property. In a constrained coherent-pair law, suppose +that the radius-$Rr$ face-ball patch about $z$, including the two layers +of its bounding contour, contains no prescribed spins or $E_0$ edges. +For $r\ge r_0$, conditional on arbitrary $B$ values outside that patch, +there is probability at least $p$ of a simple double-$B$ circuit of either +specified sign whose curve surrounds $z$ and lies at norm radii +\begin{equation}\label{eq:local-circuit-annulus} + (1-\eps)r\le |\,\cdot-z|_g\le(2+\eps)r. +\end{equation} +The circuit encloses the real norm ball of radius $(1-\eps)r$. +For a sign-$t$ circuit, additional $B=t$ pins in the patch are allowed. +\end{lemma} +\begin{proof} +Consider sign plus first. Fix $B=-1$ on both face layers of the +radius-$2r$ regular contour. By \cref{lem:spin-fkg} this lowers every +increasing event. The exact cut law identifies its interior with the +one-spin minus-boundary law in the cited annulus theorem. Bounded +changes in the chosen contour and integer radius are absorbed by the +fixed slack in \eqref{eq:local-circuit-annulus}. + +Each edge of the occupied $Y$ circuit lifts to two honeycomb edges. +Both are double-$B$ plus: the two occupied endpoints prescribe all +incident face spins. The resulting closed walk stays a bounded distance +from the site circuit and has the same winding about the inner ball. +Split the walk at repeated vertices and discard zero-winding pieces; +one obtains a simple double circuit with that winding. The $Y$ lattice +and the face-center lattice are translates with the same graph norm, so +all the displacement errors just used are bounded independently of $r$. +For sufficiently large $r$ the resulting circuit satisfies +\eqref{eq:local-circuit-annulus} and has the asserted enclosure. + +Choose, for example, $R=4$, increasing the lower threshold on $r$ to +accommodate all face stars and contour layers. The comparison takes +place inside the prescribed empty patch, so arbitrary exterior $B$ +conditioning leaves it valid. Global sign reversal proves the minus +case. Adding pins of the requested sign can only increase the circuit +probability by \cref{lem:spin-fkg}. +\end{proof} + +\begin{lemma}[A circuit under the opposite cut condition]\label{lem:worst-cut} +There are fixed $K<\infty$ and $c>0$ with the following property. +Inside a regular dual cut of radius $Kn$, fix $B=-t$ on the inner boundary +layer and leave $W$ free. With probability at least $c$, there is a +double-$B$ circuit of sign $t$ between radii $n$ and $2n$. The constants +are independent of $n$, for all sufficiently large $n$. +\end{lemma} +\begin{proof} +Take a polygonal curve at norm radius $3n/2$. Choose $r$ to be a +sufficiently small fixed multiple of $n$, and cover this curve cyclically +by annuli as in \eqref{eq:local-circuit-annulus}. Put their centers on +the curve, including its corners, with successive distances between +$1.4r$ and $1.6r$. Integer rounding preserves these inequalities with +slack for large $n$. Choose $r/n$ small enough that the annuli and their +radius-$Rr$ comparison patches lie strictly between radii $n$ and $2n$. + +The circuits in neighboring annuli must intersect. Their enclosed +inner balls overlap, and each inner ball protrudes outside the other's +outer ball, since $\eps<1/50$. Disjoint Jordan curves have disjoint or +nested interiors, and these two geometric properties exclude both +possibilities. At a common honeycomb vertex, two double paths of the +same sign join with all three incident face spins of that sign. +Choose intersection points for consecutive pairs and join them along +the intervening circuits. The resulting closed walk stays $O(r)$ from +the center polygon and is homotopic to it in the complement of the +radius-$n$ ball. Extracting a simple circuit with nonzero winding gives +the required circuit between radii $n$ and $2n$. + +There are only a fixed number of small annuli. Their events are all +increasing in the order toward $t$, so \cref{lem:spin-fkg,lem:local-circuit} +give a positive lower bound for their intersection. A fixed sufficiently +large $K$ keeps every comparison patch away from the opposite boundary +condition. The constants do not depend on $n$. +\end{proof} + +For clarity, a \emph{buffer} below means an open neighborhood in which +the local annuli, together with their larger worst-condition cuts, fit +with positive clearance. Thus an obstacle can lie in the hole of a +collar without lying in the buffers used to construct the collar circuit. +We distinguish these local buffers from the entire disk bounded by the +eventual circuit. + +\begin{lemma}[Circuits in buffers]\label{lem:buffer-circuits} +Consider a fixed positive-width polygonal collar, or a fixed positive-width +tube following a polygonal arc. Suppose it has a buffer disjoint from +$E_0$ and from all prescribed $B$ spins. At sufficiently fine mesh, +conditional on arbitrary $B$ values away from the buffer, there is a +probability at least $c>0$ of a double-$B$ circuit around the collar's hole, +or a connected double-$B$ path following the tube, of either specified sign. +For a sign-$t$ event, arbitrary additional $B=t$ pins in the buffer are +allowed. The constant depends on the fixed geometry, not on the mesh, +the number of pins elsewhere, or their values. + +Finitely many separated such requirements have a uniformly positive joint +probability, even if different buffers request different signs. For a +logarithmic stack of separated similar annular buffers between radii $r$ +and $L$, the probability that no circuit of a prescribed sign occurs is +at most +\begin{equation}\label{eq:stack-failure} + C(r/L)^\alpha +\end{equation} +for some $\alpha>0$. In lattice units this holds uniformly for $L\gg r\geq1$, +after adjustment of $C$. +\end{lemma} + +\begin{proof} +First consider a small regular annulus whose larger cut lies in the +buffer. Delete any favorable pins in that cut. This can only lower the +probability of the desired event in the order toward $t$. Fix the +opposite sign on both sides of the larger deterministic cut. FKG lowers +the desired probability again, and the exact cut law identifies the +remaining problem with \cref{lem:worst-cut}. This gives a uniform local +lower bound under every allowed exterior conditioning. + +We explain the geometric gluing, with all comparison patches inside the buffer. Cover the center curve of the tube +or collar by finitely many small regular annuli. Choose their common +inner radius much smaller than the tube width. Consecutive centers may +be separated by, for example, $3/2$ times that radius in the graph-distance +norm. Their inner balls intersect, and each inner ball protrudes beyond +the other's outer ball. Two surrounding circuits in these annuli must +therefore intersect: disjoint Jordan curves would have disjoint interiors +or nested interiors, and the two geometric conditions exclude these +possibilities. Their union is connected and follows the prescribed +tube. Around a closed center curve, its outer boundary contains a simple +circuit enclosing the hole; the annuli are small enough that their union +does not fill that hole. At a common dual vertex, double paths of the +same sign have all three adjacent spin sites of that sign, so the gluing +does not lose the double-path property. Bounded lattice rounding is +absorbed by the positive geometric clearances. + +All the small annulus events for one sign are increasing in the same +order. FKG multiplies their local lower bounds, giving a positive +constant depending only on the finite cover. For separated buffers, +condition successively on the configurations outside the next buffer; +the preceding lower bound applies under each such conditioning. This +also permits different signs in different buffers. + +Finally choose a fixed scale ratio large enough that the enlarged buffers +of successive annular slots are disjoint. There are at least +$c_2\log(L/r)-C_2$ slots. At each trial, conditional on the previously +examined slots, success has probability at least $c_3>0$. Failure in all +slots has probability at most $(1-c_3)^{c_2\log(L/r)-C_2}$, which is +\eqref{eq:stack-failure}. The finitely many bounded lattice scales can be +absorbed in its prefactor. +\end{proof} + +\subsection{Loop estimates inside simple contours} + +For a simple honeycomb contour $L$, let $\PP_L$ be the loop $O(2)$ law +strictly inside $L$, with edge weight one and empty exterior: loops use +neither edges nor vertices of $L$, and have weight $2^{\#\mathrm{loops}}$. +It is represented by coherent pairs on the interior faces with both +spins plus on the inner boundary layer. Indeed no wall can meet a +contour vertex, since all interior faces incident to that vertex are +boundary faces. Conversely a loop strictly inside $L$ encloses no +boundary face. Given the loops, assigning independently to each loop +the color $B$ or $W$ that changes across it reconstructs a unique coherent +pair with these boundary signs. Thus the colors are independent fair +choices conditional on the loop geometry. + +The first-spin marginal under this flat condition still admits the +comparisons above. Embed $L$ in a larger regular spin domain, fix $B=+$ +on the exterior faces and the inner boundary layer, and join all those +sites by $W$-equality edges. The exterior and boundary face chain are +connected, so one connected equality set suffices. Requiring its single +$W$ label to be plus has probability exactly $1/2$ conditional on every +$B$, by \cref{lem:spin-fkg}; it does not change the $B$ marginal. The +resulting inside pair law is precisely the flat law just described. + +\begin{proposition}[Loop estimates]\label{prop:loop-estimates} +There are constants $c_0>0$ and $0<\rho<1$ such that, for all sufficiently +large integer $n$, the following statements hold. +\begin{enumerate}[label=(\roman*)] +\item If the interior of a simple contour $L$ contains $\Lambda_{2n}(z)$, +then $\PP_L$ gives probability at least $c_0$ to a loop contained in +$\Lambda_{2n}(z)$ and surrounding $\Lambda_n(z)$. +\item If $L$ has graph inradius $n$ about $z$, then +\begin{equation}\label{eq:upper-loop-estimate} + \PP_L\bigl(\text{at least two loops surround }\Lambda_{\rho n}(z)\bigr) + \le 1-c_0. +\end{equation} +\end{enumerate} +There is no aspect-ratio or boundary-regularity assumption on $L$. +\end{proposition} +\begin{proof} +For (i), use two separated polygonal collars at norm radii, for example, +$1.3n$ and $1.7n$. Their comparison buffers fit strictly between radii +$n$ and $2n$ and avoid the fixed boundary layers and equality edges. +\Cref{lem:buffer-circuits} gives a uniformly positive probability of a +double-$B$ plus circuit in the inner collar and a double-$B$ minus circuit +in the outer collar. Different signs cause no association issue: reveal +the outer collar and apply the local conditional bound in the disjoint +inner buffer. A $B$ wall separates these opposite-sign circuits. No +wall can cross either double circuit, since all three face spins at each +of its vertices agree. At least one wall loop therefore surrounds the +inner circuit and lies inside the outer one, proving (i). + +For (ii), put $z=0$. If a honeycomb circuit surrounds $\Lambda_s$, its +inner incident faces contain a triangular face-center circuit surrounding +the real norm ball of radius $s-b$, for a universal $b$. To see this, +follow the inner incident faces along the contour. Successive centers +are equal or adjacent, and the resulting closed walk tracks the contour +within bounded distance. Its edges lie on the inner side. Splitting at +repeated vertices gives a simple circuit with the same nonzero winding +about the smaller ball. The same observation applies to a double +circuit whose face spins have one fixed sign. + +Let $E$ be the event in \eqref{eq:upper-loop-estimate}, and let $E'$ also +require that its outermost surrounding loop changes $W$ and its second +outermost changes $B$. The independent coloring gives +\begin{equation}\label{eq:two-loop-coloring} + \PP_L(E')=\tfrac14\PP_L(E). +\end{equation} +On $E'$, the outer loop is double-$B$ plus: no surrounding $B$ wall lies +outside it. The faces immediately inside the next loop have $B=-1$. +Consequently there is a simple minus face-center circuit enclosing the +real norm ball of radius $\rho n-b$. Other loops cannot alter these +incident signs without intersecting one of the two selected loops. + +We select an enclosing plus cut using only $B$. Extend the flat spins +as plus outside $L$, and start with all exterior faces reached. Traverse +face adjacency unless the crossed honeycomb edge, including its endpoints, +is strictly inside $L$ and is double-$B$ plus. A deterministic queue +queries the $B$ values needed to decide each attempted traversal, and +retains the full query record. Complete this reachable closure. If the +center is unreached, let $U$ be its component in the ordinary face-adjacency +graph of all unreached faces. Each face adjacent to $U$ but outside it +is reached, and each edge separating the two sets is an eligible +strictly interior double-plus edge. The reached set is connected to the +exterior, so $U$ has no holes. At a honeycomb vertex only three faces +meet; the boundary of $U$ therefore has degree two at every vertex and +is a single simple circuit $C$. + +Every original boundary face is reached across an ineligible contour +edge. Moreover, every queried face in $U$ was tested from a reached +neighbor across a blocked edge, and hence is a plus inner-layer face of +$C$. There are no other queried sites or original boundary constraints +in $U$. Each completion consistent with the record reproduces the same +search and the same cut. Across $C$ both $B$ values are plus, so coherence +places no restriction on $W$ there. Thus \cref{lem:double-cut} gives +exactly the plus-$B$, free-$W$ cut law in $U$, even after all unobserved +exterior variables are summed out. On $E'$ the outer selected loop +blocks the search, and $C$ lies on or outside that loop and encloses the +minus face circuit. +The search does not condition on $E'$ or on any loop color. + +For a fixed realized $C$, let $A_C$ be the event of a simple minus +face-center circuit inside $C$ enclosing the real norm ball of radius +$\rho n-b$. This is a decreasing event. In a sufficiently large +regular free spin domain, prescribing plus on both layers of this fixed +$C$ gives its cut law and decreases $A_C$, by +\cref{lem:spin-fkg,lem:double-cut}. Its probability in the stopped +interior is therefore at most its probability in that free domain. +We now bound the latter probability uniformly in $C$. + +Choose an exterior face incident to $L$ with center $u$ satisfying +$|u|_g=n+O(1)$. Fix $M>10(R+2)$, with $R$ from +\cref{lem:local-circuit}, and choose an integer $m$ such that +$(1-p)^m\le1/8$. About $u$ test the annuli of that lemma at scales +\[ + d_i=\left\lfloor\frac{n}{20M^i}\right\rfloor, + \qquad i=0,\ldots,m-1. +\] +Test from large to small, revealing the $B$ spins in each tested annulus +and its incident face stars. The radius-$Rd_{i+1}$ comparison patch +lies strictly inside the hole of every previously tested annulus for +large $n$. Hence each trial has conditional success probability at +least $p$, and the probability of no success is at most $1/8$. +Take the free comparison domain large enough to contain $L$ and all +these patches with their bounding layers. + +On success, the incident-face construction gives a simple plus +face-center circuit around $u$, enclosing the real norm ball of radius +$(1-2\eps)d_i$ and contained in the ball of radius $(2+2\eps)d_i$. +Set +\[ + \rho=1-\frac{1}{200M^{m-1}}. +\] +For all sufficiently large $n$, the enclosed ball about $u$ overlaps +the radius-$(\rho n-b)$ ball about zero with linear slack. Indeed the +smallest tested radius is $n/(20M^{m-1})+O(1)$, whereas +$(1-\rho)n=n/(200M^{m-1})$. The plus circuit does not surround zero, +since its containing ball has radius at most $(2+2\eps)n/20$ and is +centered at distance $n+O(1)$ from zero. A minus circuit counted by $A_C$ lies inside $C$, and hence inside $L$; +it cannot surround the exterior face center $u$. +The two circuits consequently have overlapping interiors with neither +containing the other. They must intersect. In the planar triangular +face graph, such an intersection contains a common spin site, impossible +for a plus and a minus circuit. + +It follows that $\PP_{\rm free}(A_C)\le1/8$ for every realized $C$. +On $E'$ the search succeeds and $A_C$ occurs. Averaging over its full +records therefore gives $\PP_L(E')\le1/8$. Equation +\eqref{eq:two-loop-coloring} yields $\PP_L(E)\le1/2$. +Taking $c_0$ to be the smaller of $1/2$ and the constant in (i) proves +the proposition. All lower thresholds on $n$ are imposed after the +fixed constants $R,p,M,m,\rho$ have been chosen. +\end{proof} + +In a general flat height domain or a bounded skeleton face we use +\cref{prop:loop-estimates}\textup{(ii)} only after exposing an enclosing +level loop. Its strict interior has the empty-exterior law: another +loop cannot use its vertices, and the unexplored inside retains the +weight $2^{\#\mathrm{loops}}$. The contraction $\rho<1$ above is in +graph radii, as required for the distance-shell argument. + +\subsection{Plane comparison} + +We record the coupling mechanism behind our use of these circuits. Take +two pair laws whose domains contain a large ball, with no constraints +there. On a slightly smaller deterministic dual cut, compare each $B$ +marginal with the law having minus fixed on both boundary layers. +Exact cutting makes this lower interior law common to both comparisons. + +Run the exterior exploration of \cref{lem:double-cut} in the lower law, +querying the same sites in the other two laws. At every stage retain, +for each marginal, its conditional law given its own queried values. +If these values are ordered, conditional FKG orders the next site's plus +probabilities: fixing the outer minus layer and then lowering the queried +values can only decrease that probability. A fresh uniform random +variable therefore samples all three next spins in their required order. +The next query depends only on the revealed record, so this recursive +conditional sampling preserves each marginal. + +Stop when the lower configuration has a plus double circuit. Its cut +sites are plus in all three configurations. The exploration has queried +only their exterior and these cut sites, so their remaining conditional +interior laws coincide. Fill that interior identically. Sample $W$ only +after this $B$ exploration; its components are free across the cut and can +also be matched. The construction allows arbitrary constraints outside +the large ball, including $E_0$ equalities there. + +The same construction compares a law with one obtained by adding extreme +$B$ pins in a small region. Explore outward from that region in the more +adverse configuration. A double circuit of the added sign matches the +configurations on the far side. This version will be used when filling +small gaps in a pin curve. + +\begin{proposition}[Plane law and quantitative local comparison] +\label{prop:plane-mixing} +Free coherent pairs in expanding regular hexagons converge on cylinder +events to a law $\mu_\infty$. This law is invariant under lattice +translations, lattice symmetries, global sign changes, and interchange +of the colors. If the domain of a finite pair law $\mu^{E_0,\eta}$ +contains a ball of radius $L$ and has no constraints in that ball, then +its restriction to a concentric +ball of radius $r$ differs from that of $\mu_\infty$ in total variation +by at most $C(r/L)^\alpha$, for $L\gg r\geq1$. + +The associated plane height increments exist and have the same spatial +symmetries. Every finite feasible prescription of $B$ pins together with +$W=+1$ on finitely many connected paths has positive plane probability. +\end{proposition} + +\begin{proof} +Apply the preceding common-lower-law coupling and search for a plus circuit +in a stack between the inner ball and the deterministic outer cut. Its +failure probability is bounded by \eqref{eq:stack-failure}. On success +the full pair configurations agree in the inner ball. This bounds the +total variation distance between any two sufficiently large free-volume +laws, and proves the Cauchy property on each cylinder. It gives the same +bound with one constrained law and one expanding free volume; then let +the latter volume tend to the plane. Constants do not depend on the +constraints outside the empty ball. + +Translated or reflected exhausting volumes give the same limit by this +comparison, proving the spatial symmetries. The finite laws have the +stated spin symmetries. Formula \eqref{eq:height-increment} determines +increments on every fixed path, and its vanishing curl persists in the +limit. It therefore defines the plane height modulo one additive +integer. + +To check positivity of a finite pin event, enclose all its sites and paths +by a double-$B$ cut. Such a cut has positive probability by +\cref{lem:buffer-circuits}. In its finite interior, take $W$ everywhere +plus and choose $B$ with the prescribed values and the cut value. This +is a coherent extension and has positive conditional counting probability. +The exact cut law proves the assertion. Uniform finite-volume estimates +pass to this positive-probability plane conditioning. +\end{proof} + +When height increments rather than the two spin labels are considered, +one may equivalently anchor a free height at zero. The global Gray +rotation $(B,W)\mapsto(W,-B)$ preserves \eqref{eq:height-increment} and +cycles the four residues at the anchor. Each anchored height consequently +has the same four representatives in the free pair law. This observation +will let us apply counting inequalities directly to anchored height arrays. + +\subsection{A comparison for separated rare pin events} + +A family of \emph{separated obstacles} consists of finitely many supports, +each contained in a bounded simply connected polygonal neighborhood $U_i$, +with the closures $\overline U_i$ pairwise disjoint. Each support has a +surrounding polygonal collar inside $U_i$, with positive clearance for all +its local buffers and larger comparison cuts. Their filled interiors +also lie in $U_i$. Thus an isolating cut encloses only its own obstacle; +disjoint annular collars alone would not impose this condition. +After rescaling, these neighborhoods, collars, and clearances are fixed. +For example, finitely many lattice paths converging uniformly to disjoint +compact simple arcs admit such neighborhoods: choose sufficiently thin +regular neighborhoods of the arcs, with endcaps, and approximate their +boundaries polygonally. Their closures remain disjoint at fine mesh. On obstacle $i$, an event $P_i$ prescribes arbitrary +$B$ values and requires $W=+1$ on at most $m_i$ connected subpaths. There +is a fixed bound on $\sum_i m_i$, but no bound on the number of pinned +sites along a subpath. We use the same notation $P_i$ for the event and +write $p_i=\mu_\infty(P_i)$ for its probability. + +The following comparison treats one obstacle while retaining any pins +already imposed on it. This retention allows its plus and minus pins to +be prescribed in successive batches. + +\begin{lemma}[Relative comparison for one obstacle] +\label{lem:relative-pin-comparison} +Let $\mu$ and $\nu$ be finite pair laws with second-color equality +constraints and first-color pins. Their domains contain the same filled +isolating neighborhood $U$, and their constraints inside $U$ agree: +these consist of retained $B$ pins $R$ and equality edges $E_0$ on one +obstacle. Its surrounding collar and buffers in $U$ contain no +constraints. Outside $U$ the two laws may have different constraints. +If $A$ prescribes one sign $t$ on further sites of that obstacle, +consistently with $R$, then +\[ + c\nu(A)\leq\mu(A)\leq c^{-1}\nu(A). +\] +Here $c>0$ depends only on the collar and its buffers, not on the +retained pins, equality edges, remote constraints, or the probability +of $A$. The same assertion holds with the colors interchanged. +\end{lemma} + +\begin{proof} +Fix sign $t$ on a deterministic double layer $\Gamma$ in the collar. +Let $q$ be the probability of $A$ in its interior law, retaining $R$ +and the internal $E_0$ constraints. Exact cutting makes $q$ the same +for $\mu$ and $\nu$. FKG in the order toward $t$ gives, for either +law $\lambda\in\{\mu,\nu\}$, +\begin{equation}\label{eq:rare-pin-upper} + \lambda(A)\leq\lambda(A\mid B=t\text{ on }\Gamma)=q. +\end{equation} +In a thinner collar strictly inside $\Gamma$, an exterior stopping search finds +a double circuit of sign $t$ with probability at least $c_1>0$, by +\cref{lem:buffer-circuits}. Its constant is uniform over $R$ and all +remote constraints: the search buffers contain none of these pins or +$E_0$ edges. Conditional on the search, the inner law is the corresponding +closer-cut law. In the deterministic-$\Gamma$ law, conditioning on this closer +sign-$t$ cut can only increase $A$, while preserving $R$. Its probability +of $A$ is therefore at least $q$. Consequently +\begin{equation}\label{eq:rare-pin-sandwich} + c_1q\leq\lambda(A)\leq q, + \qquad \lambda\in\{\mu,\nu\}. +\end{equation} +Comparison through this common $q$ proves the lemma. The retained pins +may be extremely rare; their probability never enters the inequalities. +The stopping exploration has not inspected the strict interior, which +is essential for the lower bound. +\end{proof} + +\begin{proposition}[Products of separated pin probabilities] +\label{prop:pin-product} +For a separated family as above, there are constants $00$. Partition $\mathcal S$ into at +most $m_*$ classes. Suppose that whenever $x,y$ belong to the same class, +both coordinatewise rounded midpoints belong to $\mathcal S$, and that +their $Y$ values differ from $(Y(x)+Y(y))/2$ by at most $M$. Suppose also +that, for every class in use, +\begin{equation}\label{eq:class-central-mass} + \PP\{\abs Y\leq M,\ x\hbox{ belongs to that class}\}\geq c>0. +\end{equation} +Then, for constants depending only on $c$ and $m_*$, +\[ + \PP(\abs Y>tM)\leq C e^{-c't}\quad(t\geq1),\qquad + \norm{Y}_{L^p}\leq C_pM\quad(p<\infty). +\] +The rounded outputs need not belong to the input class. +\end{lemma} + +\begin{proof} +Consider the enlarged positive dyadic intervals +$I_k=[2^kM-4M,2^{k+1}M+4M]$, and put $p_k=\PP(Y\in I_k)$. +Choose a class carrying at least $p_k/m_*$ of this mass. Pair its +indicator on $I_k$ with its indicator on $[-M,M]$. Both rounded output +statistics belong to $I_{k-1}$: the half-width error is at most +$2M+M/2+M<4M$. Apply the product midpoint inequality with both output +arrays equal to the indicator of $\mathcal S\cap\{Y\in I_{k-1}\}$. +After division by $\abs{\mathcal S}^2$, it gives +\begin{equation}\label{eq:dyadic-tail-recursion} + p_{k-1}^2\geq c p_k/m_*. +\end{equation} +The admissibility assumption is needed only where the two input +indicators are nonzero; no output class restriction occurs. + +For $k\geq4$ these enlarged intervals have bounded overlap. Hence, in +an initial range of bounded length depending only on $c,m_*$, some $p_{k_0}$ +is at most $c/(2m_*)$. Write $b=m_*/c$. Iterating +\eqref{eq:dyadic-tail-recursion} gives +$b p_{k_0+j}\leq2^{-2^j}$. The bounded size of the initial range absorbs +the earlier terms, so $p_k\leq C\exp(-c'2^k)$ for all $k$. Repeat with +negative intervals and sum the resulting tail bounds. Integrating the +tail proves the moment assertion. +\end{proof} + +Integer Lipschitz arrays are stable under these two midpoint operations: +an integral edge bound on the averaged coordinates is preserved by taking +floors at both endpoints or ceilings at both endpoints. A fixed integral +boundary or anchor is preserved as well. For a statistic with weights +$w_x$, the rounding error is at most $\frac12\sum_x\abs{w_x}$. These +observations verify the lemma's admissibility hypotheses in the unpinned +applications. + +\subsection{Bounded-boundary height problems} + +\begin{lemma}[Loop counts in a distance shell]\label{lem:loop-shells} +In a finite flat-boundary height problem, fix an interior site $x$. +The number of level loops surrounding $x$ whose graph inradii lie between +$d$ and $2d$ has moments bounded at every order, uniformly in the domain +and in $d\geq1$. The same holds when the shell is defined by Euclidean +closest approach to $x$. Both assertions also hold in a bounded face of +a connected constant-height skeleton. +\end{lemma} + +\begin{proof} +Let $\rho<1$ and $c_0>0$ be the constants in +\cref{prop:loop-estimates}(ii). Choose $\eta>0$ small enough that +$\rho(1+\eta)<1$, with slack for bounded lattice rounding at large +distances. Divide $[d,2d]$ into a bounded +number of intervals with ratio at most $1+\eta$. Expose surrounding loops +from the exterior, and consider the first one whose graph inradius +lies in one such interval $[d', (1+\eta)d']$. If it exists, its interior +has the empty-exterior loop law. If its graph inradius is $n$, then +$n\le(1+\eta)d'$. Every further loop with graph inradius at least $d'$ +surrounds $\Lambda_{\lfloor d'\rfloor}(x)$. For sufficiently large $d'$, +\[ + \lceil\rho n\rceil<\lfloor d'\rfloor, +\] +because $\rho(1+\eta)<1$. Thus two such loops imply the exact event +in \cref{prop:loop-estimates}(ii), in the same graph convention. Their +conditional probability is at most $1-c_0$. +Reapply this argument after each successive pair of exposed loops. +The count in the interval is dominated by one plus twice a geometric +random variable with a fixed success parameter. A bounded number of +such bounds handles $[d,2d]$. + +At bounded distances, disjoint loops approaching that close must use +distinct vertices in a fixed finite ball, so their number is bounded +deterministically. This handles the rounding exceptions. Every application +of the upper bound follows exposure of a surrounding loop, so the flat +loop description in \cref{lem:gray} suffices for the stated domains. + +Finally, triangular graph distance and Euclidean distance are comparable +by fixed constants, and a contour is within bounded distance of its +incident face centers. A Euclidean closest-approach shell $[d,2d]$ is +therefore covered by a fixed finite number of graph-inradius shells, +with bounded small-radius exceptions. Summing the graph-shell moment +bounds proves the Euclidean assertion. This metric comparison is made +only after the strict graph-radius contraction has been proved. +\end{proof} + +\begin{proposition}[Interior smearing moments]\label{prop:smearing-moments} +Consider a uniform height problem with boundary values bounded in absolute +value by $K$. Let the center of a radius-$a$ smearing have distance $n$ +from the boundary, with $1\leq a\leq c_0n$ for a sufficiently small fixed +$c_0>0$. Then, for every finite $p$, +\begin{equation}\label{eq:smearing-moments} + \norm{\textstyle\sum_xw_xH(x)}_{L^p} + \leq C_p\bigl(1+\sqrt{\log(n/a)}\bigr). +\end{equation} +Here $C_p$ depends on $p,A,K$, but not on boundary regularity. The same +statement holds for bounded data on the inner face chain of a dual cut, +and in the bounded skeleton faces considered above. +\end{proposition} + +\begin{proof} +First put zero on the boundary. Conditional on all loop geometry, +independent centered jump signs give +\begin{equation}\label{eq:common-loop-covariance} + \EE[H(x)H(y)] + =\EE\bigl[\#\{\hbox{loops surrounding both }x\hbox{ and }y\}\bigr]. +\end{equation} +Let $s=\max(1,\dist(x,y))$, for $x,y$ in the smearing ball. Their boundary +distances are comparable to $n$. A loop surrounding both points and +approaching $x$ within distance $2d\ll s$ supplies a wall arm from scale +$O(d)$ to scale of order $s$. The contour changes only one spin color +along its entire length. A surrounding double circuit of that color +blocks the arm: at a vertex of the double circuit all three adjacent +spins have that color's fixed value, so its wall cannot cross there. + +Flat height boundary conditions fix both colors on a connected boundary +chain. For either color used as the first spin, constancy of the other +color on this chain is an $E_0$ requirement; its single label does not +change the first marginal. The buffers between scales $d$ and $s$ lie +away from the boundary. Thus \cref{lem:buffer-circuits}, for either +possible wall color, bounds the arm probability by $C(d/s)^\alpha$. +Together with the second moment in \cref{lem:loop-shells}, Cauchy--Schwarz +bounds the expected common-loop count in this shell by +$C(d/s)^{\alpha/2}$. Summing the small shells is finite. Each shell from +scale $s$ up to scale $O(n)$ contributes at most a constant. There are no +larger enclosing shells, since an enclosing loop cannot surround a fixed +boundary site. Consequently +\begin{equation}\label{eq:point-covariance-upper} + 0\leq\EE[H(x)H(y)]\leq C\bigl(1+\log(n/s)\bigr). +\end{equation} + +Summing \eqref{eq:point-covariance-upper} against $\abs{w_xw_y}$ yields +\begin{equation}\label{eq:smearing-variance} + \EE\Bigl(\sum_xw_xH(x)\Bigr)^2 + \leq C\bigl(1+\log(n/a)\bigr). +\end{equation} +Indeed the part $\log(n/a)$ is controlled by the total weight. For the +remaining singularity, graph balls contain $O(r^2)$ sites, so the bounds +in \eqref{eq:normalized-weights} give a uniform average of +$\log(a/\max(1,\dist(x,y)))$. The one-site contribution is bounded by +$Ca^{-2}\log a$. This calculation also covers signed weights. + +Chebyshev's inequality gives a fixed central probability on the scale +$M=C(1+\sqrt{\log(n/a)})$, chosen also to dominate the rounding error. +The height arrays with zero boundary have admissible rounded midpoints, +so \cref{lem:midpoint-tails} with one class proves +\eqref{eq:smearing-moments} in the flat case. + +For bounded boundary data, compare with the zero-boundary height shifted +by $-\lceil K\rceil$ and $+\lceil K\rceil$. A nonnegative smearing is +stochastically trapped between the corresponding shifted smearings. +Its two tails are therefore bounded by those of the zero-boundary problem, +with an additional deterministic error at most $A\lceil K\rceil$. +Split signed weights into positive and negative parts and use the triangle +inequality in $L^p$. This proves the stated bound. The proof uses only +the flat loop representation and the incident-star convention, and hence +also applies to the asserted dual-cut and skeleton boundaries. +\end{proof} + +In particular, a normalized average on a ball whose radius is a fixed +small fraction of its distance to the boundary has moments bounded +uniformly as that distance tends to zero, with mesh sent to zero first. +This observation will be used at both ordinary boundary points and the +two marks. + +\begin{proposition}[Plane zero-total moments]\label{prop:plane-moments} +For every zero-total smearing satisfying \eqref{eq:normalized-weights}, +\begin{equation}\label{eq:plane-zero-total-moments} + \norm{\textstyle\sum_x w_xH(x)}_{L^p(\mu_\infty)}\leq C_p, + \qquad p<\infty, +\end{equation} +uniformly in its radius, location, and lattice rotation. The same bound +holds in sufficiently larger finite free volumes, for a height anchored +outside the construction. +\end{proposition} + +\begin{proof} +Search from the exterior for a double-$B$ circuit in an annulus between +$Ka$ and $2Ka$ about the support, where $K$ is a fixed sufficiently large +constant. \Cref{lem:buffer-circuits} gives probability at least $c>0$, +uniformly in $a$ and in a still larger free volume. The search does not +inspect the interior. Its inner height trace lies in one pair of +consecutive integers by \cref{lem:double-cut}. Subtract the lower integer +of that pair. Conditional on the trace, the interior is a bounded-boundary +height problem. Its boundary distance from the support is comparable to +$a$, and $K$ may be chosen to meet the small-fraction requirement in +\cref{prop:smearing-moments}. That proposition bounds the second moment +of the shifted smearing by a constant. The shift does not alter the +original smearing, since its total is zero. We have therefore obtained +an unconditional central probability $\PP(\abs Y\leq M)\geq c'>0$ for a +constant $M$. + +The free pair increment law is the uniform anchored-height law, as noted +after \cref{prop:plane-mixing}. Its arrays have admissible rounded +midpoints and bounded rounding error. Apply \cref{lem:midpoint-tails} +in this finite volume, with the anchor outside the searched circuit. +This gives the bound for every $p$, uniformly in that volume and in $a$. +For each fixed lattice smearing, let the volume expand and use +\cref{prop:plane-mixing}; the bounds pass to the limit. The constants are +uniform in $a$ and the listed symmetries, proving the assertion. +\end{proof} + +\subsection{An isolated component switch} + +The following finite identity has two uses: it supplies the parity classes +needed for conditional moments, and it prevents the limiting covariance +coefficient from vanishing. + +\begin{lemma}[A fair switch between opposite cuts]\label{lem:component-switch} +Suppose that two nested double-$B$ circuits have opposite signs, and that +their intervening collar contains no $E_0$ edge or pinned $W$ site. There +is a component of $B$-changing edges confined to this collar whose fair +$W$ sign can be flipped so as to change every height inside the inner +cut by $4$ in absolute value relative to every height outside the outer +cut. The flip changes no spin pin outside the collar. It preserves any inner +height prescription invariant under a common additive shift in $4\Z$, +while leaving exterior heights fixed. + +Conditional on $B$ and the other $W$ component labels, the two choices +are equally likely. If a zero-total statistic has total weight $\lambda$ +inside the inner cut, no weight in the collar, and all its other weight +outside the outer cut, its two values differ by $4\abs\lambda$ and its +conditional variance is at least $4\lambda^2$. +\end{lemma} + +\begin{proof} +On every oriented edge the Gray increment gives the identity +\begin{equation}\label{eq:component-potential-identity} + d(H+BW/2)=W\,dB. +\end{equation} +Let $J$ be one connected component of $B$-changing edges, and put +$\omega_J=\one_JdB$, extended by zero to other edges. A triangle has +either no $B$-changing edge or two incident ones in the same component. +Thus $\omega_J$ has zero curl and has a potential $\psi_J$ on the simply +connected ambient graph. On the vertices of $J$ this potential agrees +with $B$ up to an additive constant. Every other vertex can be connected +to $J$ by a path with no edge of $J$ before its endpoint, and so its +potential continues one of the two values on $J$. The potential has +exactly two values, differing by two. + +No component of $B$-changing edges can cross a double-$B$ cut. Between +the two cuts, the sum of the potential changes of all such components, +from the outer cut to the inner one, is the total change of $B$, namely +$2$ or $-2$. At least one component $J$ in the collar therefore has a +nonzero change. Its potential is constant on the inner region and on +the outer region, with a difference of two. Normalize it to zero outside +the outer cut. + +The collar is free of $E_0$ and pinned $W$ sites. Consequently the +$W$-equality component containing $J$ consists precisely of its vertices, +and its common value $w$ is an independent fair sign by +\cref{lem:spin-fkg}. Flip this sign and leave all other $W$ components +unchanged. Formula \eqref{eq:component-potential-identity} gives, at every +vertex not in $J$, +\[ + H'-H=-2w\psi_J, +\] +when the height is anchored outside the outer cut. The correction from +$BW/2$ vanishes at these vertices. Thus the height change is zero +outside and is $+4$ or $-4$ throughout the inner region. The spin pins +outside the collar are untouched. The two statistic values differ by +$4\abs\lambda$, so a fair choice between them has variance +$(4\lambda)^2/4=4\lambda^2$. +\end{proof} + +For two fixed disjoint test disks, \cref{lem:buffer-circuits} can require +these opposite cuts around one disk while avoiding the other, with a +uniform positive probability. Applied to the difference of their +unit-mass averages, \cref{lem:component-switch} therefore gives a strictly +positive, scale-uniform second-moment lower bound. This assertion is +also uniform in a large finite-volume approximation to the plane. + +\subsection{Moments conditional on pin obstacles} + +For the following moment statement, impose one extra condition on the +separated obstacles of \cref{prop:pin-product}. We call a pin pattern +\emph{interval-compatible} if, along a connected chain on obstacle $i$, +its exact height description is +\begin{equation}\label{eq:interval-pin-description} + H(v)\in I_{i,v}+4t_i\quad(v\hbox{ on the chain}),\qquad t_i\in\Z, +\end{equation} +where the $I_{i,v}$ are prescribed integer intervals and at least one is +a singleton. The spin event must be exactly this requirement for some +$t_i$, with no additional height restriction. The patterns used later +have intervals of one or two consecutive integers. They are represented +by $B$ pins and by $W=+1$ on a bounded number of connected subpaths, +as in \cref{prop:pin-product}. A singleton makes each $t_i$ unique after +a common lift has been chosen. Reflections and translations preserve +this definition. + +\begin{proposition}[Conditional obstacle moments]\label{prop:obstacle-moments} +Fix finitely many separated interval-compatible obstacles with filled +isolating neighborhoods $U_i$ as in \cref{prop:pin-product}. Let a test +disk lie in a pin-free simply connected neighborhood $U_0$, with room +for a surrounding buffered cut whose filled interior lies in $U_0$. +Require $\overline U_0$ to be disjoint from every $\overline U_i$. +Let $Y$ be a zero-total smearing in the test disk, satisfying +\eqref{eq:normalized-weights} at its scale. Conditional on all the pins, +\begin{equation}\label{eq:obstacle-moment-bound} + \norm Y_{L^p}\leq C_p\qquad(p<\infty). +\end{equation} +The constants depend on the macroscopic arrangement, the weight bound, +the number of obstacles, and the bound on W-subpath counts, but not on +the mesh or the microscopic pin probabilities. No uniformity as obstacle +separations vanish is asserted here. +\end{proposition} + +\begin{proof} +If the obstacle family is empty, use \cref{prop:plane-moments} directly. +For a nonempty family, begin in a finite free volume and anchor the +height at a singleton on obstacle 1 with its prescribed unshifted +value, so $t_1=0$. The conditional +pair law becomes uniform counting of admissible anchored height arrays +satisfying \eqref{eq:interval-pin-description}. Partition them by the +parities of $t_2,\ldots,t_m$. In a pair of arrays in the same class, +$(t_i+t_i')/2$ is an integer. Both rounded midpoint arrays therefore +satisfy the same interval requirements with this new offset: the interval +endpoints are integral. The edge bounds and the anchor are preserved. +The rounding error of $Y$ is bounded by $A/2$. We verify the remaining +central-mass hypothesis of \cref{lem:midpoint-tails}. + +First retain W-constancy as $E_0$ and temporarily drop its plus labels. +Around the test find a double-$B$ cut by an exterior stopping search. +Around each non-anchor obstacle find two nested double-$B$ cuts of +opposite signs in its pin-free collar. Choose all these search buffers +disjoint. \Cref{lem:buffer-circuits} gives their joint event $\mathcal A$ +probability bounded below, conditional on the $B$ pins and $E_0$. +Restoring the bounded number of W-plus labels loses at most the fixed +factor explained after \cref{lem:double-cut}. Thus +\begin{equation}\label{eq:obstacle-cut-probability} + \PP(\mathcal A\mid\hbox{all pins})\geq c_1>0. +\end{equation} + +The test search has not revealed its strict interior. Conditional on +its trace, its height boundary lies in one consecutive pair, and there +are no interior pin constraints. Subtract that pair's lower value. +The zero total removes the shift, and \cref{prop:smearing-moments} supplies +a uniform conditional second moment. If necessary cover the test support +by a fixed number of smaller balls to meet that proposition's small-radius +condition. For a sufficiently large fixed $M$, Chebyshev gives +\begin{equation}\label{eq:obstacle-central-event} + \PP(\mathcal A,\abs Y\leq M\mid\hbox{all pins})\geq c_2>0. +\end{equation} +Here we conditioned on the searches and their exterior traces, not on +all the $B$ values inside the test disk. + +Now expose all $B$ values and use \cref{lem:component-switch} separately +in each non-anchor obstacle collar. Choose a contributing component +measurably from $B$. Its $W$ label is an independent fair bit, unaffected +by the required plus labels because the collar has no pinned W sites or +$E_0$ edges. Flipping it changes $t_i$ by an odd integer and changes no +other offset. The anchor, every other obstacle, and the whole test neighborhood lie +outside $U_i$, hence outside this collar's outer cut. The flip consequently +preserves $Y$, all other offsets, all pins, and $\mathcal A$. +Distinct collars give distinct independent bits. + +Conditional on $B$ and all remaining W-component labels, these switches +act transitively on the $2^{m-1}$ parity vectors, preserve probability, +and preserve the event in \eqref{eq:obstacle-central-event}. Each parity +class thus receives at least $2^{-(m-1)}c_2$ of that central probability. +This is \eqref{eq:class-central-mass}, with a number of classes independent +of the mesh. \Cref{lem:midpoint-tails} proves every moment bound. + +Finally let the free volume expand at each fixed mesh. The finite pin +event has positive plane probability by \cref{prop:plane-mixing}; cylinder +convergence therefore passes to its conditional law. The uniform moment +bounds pass as well, proving \eqref{eq:obstacle-moment-bound} in the plane. +\end{proof} + +\begin{corollary}[Equal-offset moments with varying separations] +\label{cor:equal-offset-moments} +For a nonempty obstacle family in the preceding setup, impose the additional event +$\mathcal E=\{t_i=t_1\hbox{ for every }i\}$. The obstacles may now vary +or approach one another, while staying away from a fixed test disk. +Fix an annular buffer around that disk, with positive clearance from +the disk and with fixed inner and outer radii. Suppose the buffer and +its filled interior contain no pins. +Suppose that, under conditioning on the pins and $\mathcal E$, an exterior +search finds a surrounding double-$B$ cut in this buffer, with probability +at least $c>0$ uniformly in the varying arrangements. Suppose that +$\mathcal E$ can be checked in the exterior of the selected cut, so its +strict interior remains free given the trace. Then the zero-total test +in that disk has moments bounded uniformly in those arrangements. + +A sufficient condition is that the cut probability conditional on the +pins alone is at least $c_0>0$, that +$\PP(\mathcal E\mid\hbox{pins})\to1$ uniformly along the varying family, +and that the same exterior measurability holds. +\end{corollary} + +\begin{proof} +Anchor at obstacle 1. Equal offsets make all the offsets zero, so the +admissible height arrays now satisfy fixed integer interval constraints. +Their rounded midpoints are admissible without a parity partition. +On the asserted cut event, the trace lies in a consecutive pair and the +conditional interior is free of further constraints. The fixed buffer +bounds its distance from the test above and below, uniformly in the +arrangement. Covering the support by a fixed number of smaller balls +if necessary, \cref{prop:smearing-moments} therefore gives the uniform +central probability in \eqref{eq:obstacle-central-event}. Apply +\cref{lem:midpoint-tails} with one class. This proof uses +neither the separate obstacle collars nor bounds on moments outside the +equal-offset event. + +For the sufficient condition, if +$\eps=\PP(\mathcal E^c\mid\hbox{pins})$, then the conditional cut probability +after adding $\mathcal E$ is at least $(c_0-\eps)/(1-\eps)$. +This is bounded below for all sufficiently small $\eps$. Exterior +measurability ensures that the conditioning has not changed the free +interior once the trace is fixed. Finite-volume approximation justifies +the counting argument exactly as in \cref{prop:obstacle-moments}. +\end{proof} diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/05-spectral.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/05-spectral.tex new file mode 100644 index 0000000000000000000000000000000000000000..8b7c1d0dba3f971084d90a6d4864ea8143ab2143 --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/05-spectral.tex @@ -0,0 +1,693 @@ +\section{Reflection positivity and the plane covariance} +\label{sec:spectral} + +All expectations in this section are for the free plane pair constructed in +\cref{prop:plane-mixing}. Its height increments are denoted by +\(\xi_u=H(u)-H(0)\), for \(u\in\Tri\). For a compactly supported test of integral +zero, \(H_\delta(f)\) means the integral of the affine interpolation on +\(\delta\Tri\) against \(f\); its value is independent of the chosen additive +constant. No Gaussian assumption is made in this section. + +We identify the scaling covariance of these averages in two stages. First, +reflection positivity and an angular inequality force every subsequential +spectral limit to have an inverse-Laplacian density. A signed angular sum +then shows that all these limits have the same coefficient. The covariance +also implies that \(H_\delta(\Delta\phi)\), for a compactly supported smooth +\(\phi\) supported strictly on one side of a lattice reflection line, has +vanishing reflection norm. +This is the input for the pin-motion argument in \cref{sec:pins}. + +We use Euclidean coordinates in both spaces. Set +\[ + e_1=(1,0),\qquad e_2=(1/2,\sqrt3/2),\qquad + \Tri^\perp=\{p\in\R^2:p\cdot u\in2\pi\Z\text{ for all }u\in\Tri\}, + \qquad \widehat\Tri=\R^2/\Tri^\perp. +\] +The characters are \(u\mapsto e^{ip\cdot u}\). A neighborhood of zero in +\(\widehat\Tri\) will always be identified with its Euclidean representative. +In particular, the disk of radius \(1/2\) is unambiguous. Our continuum Fourier +convention is +\[ + \widehat f(\zeta)=\int_{\R^2}e^{-i\zeta\cdot x}f(x)\,dx. +\] + +\subsection{A positive normal translation} + +The square-integral proof of reflection positivity below is a site-plane +version of the classical mechanism developed by +Fr\"ohlich--Israel--Lieb--Simon \cite{FILS1978}. We give the finite-volume +factorization and the exact row geometry because the later argument needs +a positive normal transfer, including in the presence of auxiliary +height phases. +The distinction between site reflection and reflection between site rows +matters: the positive-transfer construction in +\cite[Sections~3.3 and 4.1]{Usui2012} makes the role of site reflection +explicit. Our halfway line is itself a row of triangular-lattice sites. + +\begin{proposition}[Reflection positivity with auxiliary phases] +\label{prop:reflection-positivity} +Let \(\ell\) be a line of lattice sites parallel to a nearest-neighbor direction. +The plane law is reflection positive across \(\ell\). This remains true after +adjoining any finite collection of phase fields +\begin{equation} + \label{eq:auxiliary-phases} + Z_\theta(u)=U_\theta\exp\{i\theta(H(u)-H(o))\},\qquad \theta\in\R, +\end{equation} +where the \(U_\theta\)'s are independent uniform points of the unit circle, +independent of the pair, and \(o\) is any anchor. + +More precisely, let \(\Theta_\ell\) denote spatial reflection, and let +\(\mathcal A_\ell\) consist of cylinder functions supported in one closed +half-plane, with increments evaluated along paths in that half-plane. Then +\[ + \langle F,G\rangle_\ell + =\EE\big[\overline{\Theta_\ell F}\,G\big] +\] +is positive semidefinite. In its quotient completion, normal translation farther +into the half-plane by \(\sqrt3\) is a positive self-adjoint contraction \(S\). +Tangential translation by one lattice unit is a commuting unitary operator. +On mesh \(\delta\), the normal step is \(\sqrt3\delta\). +\end{proposition} + +\begin{proof} +The phase law does not depend on its anchor: replacing \(o\) by another site +multiplies each \(U_\theta\) by a unit complex number determined by the +increments, which preserves its conditional Haar law. The same observation +under translations and reflections gives the phase law the spatial +symmetries of the pair law. We may therefore put the phase anchor on +\(\ell\). + +First take a finite reflection-symmetric free volume. Conditional on the spin +values on its intersection with \(\ell\), the configurations on the two sides +are independent and reflected-identical. Indeed, no nearest-neighbor edge +jumps across a row of sites. A lift on the row is fixed by its spin values and +one anchor value on the row. If phases are present, additionally condition on +their values at that anchor. The phases on each side are then determined by +the increments on that side and these row values, so conditional independence +persists. Thus +\[ + \EE\big[\overline{\Theta_\ell F}F\big] + =\EE\big[\lvert\EE[F\mid\text{row data}]\rvert^2\big]\ge0. +\] +The plane limit gives the assertion for cylinder functions. Functions in +ordinary \(L^2\) obtained by approximation are included because +\(\lvert\langle F,G\rangle_\ell\rvert\le +\|F\|_{L^2}\|G\|_{L^2}\). + +For clarity, take \(\ell=\{y=0\}\), with the upper half-plane chosen. Write a +site as \((m+n/2,n\sqrt3/2)\). Reflection about \(y=0\) sends its integer +coordinates to \((m+n,-n)\), and reflection about \(y=\sqrt3/2\) sends them to +\((m+n-1,2-n)\). Both preserve \(\Tri\). Their composition is the pure normal +translation \(a=(0,\sqrt3)\); no tangential correction is required. +Let \(T\) be translation by \(a\) on cylinder functions. Stationarity gives +\(\langle TF,G\rangle_\ell=\langle F,TG\rangle_\ell\). Moreover, +\(\langle F,TF\rangle_\ell\) is the reflection form of \(TF\) at the halfway +row, since reflecting \(TF\) in that row gives \(\Theta_\ell F\). It is +therefore nonnegative. + +To prove boundedness before taking the quotient, put +\(a_n=\|T^nF\|_\ell\). Reflection Cauchy--Schwarz and the preceding symmetry +imply \(a_n^2\le a_{n-1}a_{n+1}\) for \(n\ge1\). Ordinary Cauchy--Schwarz +and stationarity give \(a_n\le\|F\|_{L^2}\) for every \(n\). A bounded +nonnegative log-convex sequence cannot have \(a_1>a_0\); if \(a_0=0\), the +same inequality gives \(a_1=0\). Consequently \(\|TF\|_\ell\le\|F\|_\ell\). +It follows that \(T\) descends to the quotient and extends to the stated +positive self-adjoint contraction \(S\). Tangential translation commutes with +reflection, preserves the form, and has an inverse with the same properties. +It is therefore unitary and commutes with \(S\). Rotation gives the other +lattice directions, and rescaling gives the mesh statement. +\end{proof} + +\subsection{The increment spectral measure} + +We first specify the elementary spectral construction for ordinary lattice +translations. If $V$ is a unitary translation and $F$ a Hilbert-space +vector, the positive Fourier polynomials +\[ + \frac1{N+1}\left\|\sum_{j=0}^N e^{-ijk}V^jF\right\|^2 + \frac{dk}{2\pi} +\] +have mass $\|F\|^2$ and Fourier coefficients converging to +$\langle F,V^nF\rangle$. Compactness of finite measures on the circle +gives the scalar spectral measure, uniquely specified by these +coefficients. Rectangular Fourier sums give the same construction for +commuting lattice translations. Polarization gives their cross +measures and the bound on total variation by the product of the vector +norms. A multiplier is defined first for trigonometric polynomials and +then by completion; this is the meaning of $E(dp)$ below. The mass at +zero is the projection onto invariant vectors, also obtained as the +limit of rectangular Ces\`aro averages of translations. + +\begin{lemma} +\label{lem:increment-spectral} +There is a nonnegative measure \(C\), locally finite on +\(\widehat\Tri\setminus\{0\}\), such that +\begin{equation} + \label{eq:increment-spectral} + \EE\left(\sum_u a_uH(u)\right)^2 + =\int_{\widehat\Tri\setminus\{0\}} + \left|\sum_u a_ue^{ip\cdot u}\right|^2 C(dp) +\end{equation} +for every finitely supported real array with \(\sum_u a_u=0\). +The measure is invariant under the lattice reflections and rotations. +There is no additional random linear tilt term in this identity. +\end{lemma} + +\begin{proof} +Let \(V_u\) be the ordinary unitary translation operators on the plane +probability space, and let \(E(dp)\) be their joint spectral resolution. The +increment cocycle satisfies +\[ + \xi_{u+v}=\xi_v+V_v\xi_u, + \qquad (V_v-I)\xi_u=(V_u-I)\xi_v. +\] +On a spectral neighborhood where \(e^{ip\cdot v}-1\ne0\), this identity +expresses every \(E(dp)\xi_u\) as \(e^{ip\cdot u}-1\) times the same spectral +vector. Equivalently, on that neighborhood define +\[ + C(dp)=\frac{\langle\xi_v,E(dp)\xi_v\rangle_{L^2}} + {|e^{ip\cdot v}-1|^2}. +\] +The cocycle identity makes these definitions agree on overlaps. The two basis +directions cover the punctured torus, so they define a locally finite measure +there and give \cref{eq:increment-spectral} for the nonzero spectral part. + +Let \(P_0=E(\{0\})\). The invariant part of the cocycle is additive, hence +\(P_0\xi_u=A\cdot u\) for a random vector \(A\in L^2\). Take a smooth +zero-integral function \(f\) with nonzero first moment \(m=\int x f(x)\,dx\), +and smear the unit-mesh affine height against \(L^{-2}f(x/L)\). Affine +interpolation reproduces linear functions exactly, so the invariant part of +this statistic is \(L A\cdot m\). Its \(L^2\) norm is bounded uniformly in +\(L\) by \cref{prop:plane-moments}, since orthogonal projection cannot +increase that norm. Two choices of \(f\) with independent first moments imply +\(A=0\). This also rules out cancellation of a tilt by other spectral +components: those components are orthogonal to the invariant subspace. + +The representation determines \(C\) locally by any nonvanishing lattice +difference. The symmetries of the increment law therefore give the asserted +symmetries of \(C\). +\end{proof} + +\begin{lemma}[Uniform annular mass] +\label{lem:annulus-mass} +For some finite constant \(K\), +\begin{equation} + \label{eq:annulus-mass} + C\{r\le |p|\le2r\}\le K,\qquad 00\), +\(\int_{0<|p|<1/4}|p|^\eta C(dp)<\infty\). +\end{lemma} + +\begin{proof} +Choose two real smooth zero-integral functions \(f_1,f_2\) whose Fourier +transforms have no common zero on \(1\le|\zeta|\le2\). For example, take the +two first derivatives of a smooth bump whose transform does not vanish on that +annulus. Let \(a^{(r,i)}_u\) be the affine interpolation weights for +\(r^2f_i(rx)\). Uniformly on the fixed annulus, +\[ + \sum_u a^{(r,i)}_ue^{ir\zeta\cdot u} + \longrightarrow \widehat f_i(-\zeta). +\] +This follows directly by interpolating the smooth plane wave; its error on a +unit triangle is \(O(r^2)\), uniformly for \(\zeta\) in a compact set. +Consequently the sum of the squared absolute values of these two transforms +is bounded below on \(r\le|p|\le2r\), for all sufficiently small \(r\). +Apply \cref{eq:increment-spectral} and the uniform \(L^2\) bound of +\cref{prop:plane-moments}. The remaining range of \(r\) is covered by local +finiteness of \(C\). Summing over dyadic annuli proves the last assertion. +\end{proof} + +\subsection{Cauchy kernels from positive transfer} + +Transfer spectral representations for lattice two-point functions are +developed in \cite{Usui2012} and, for the six-vertex model, in +\cite[Theorems~4.12 and 4.15]{DCKLM2026}. We derive the particular +periodized Cauchy mixture needed here, including its reciprocal-lattice +aliases, from the normal step already established. + +For the normal transfer we need the joint spectrum of a commuting unitary +$U$ and positive contraction $S$. The preceding Fourier construction +extends to a measure on the circle times $[0,1]$. For each $N$, the commuting +Bernstein operators +\[ + B_{N,j}=\binom Nj S^j(I-S)^{N-j},\qquad 0\le j\le N, +\] +are positive and sum to the identity. For a Hilbert-space vector $F$, place +at $j/N$ the positive Fourier measure whose $n$th coefficient is +\[ + \langle F,U^nB_{N,j}F\rangle. +\] +The resulting measures have mass $\|F\|^2$. Their mixed moments converge +to $\langle F,U^nS^mF\rangle$, because +$\sum_j(j/N)^m B_{N,j}=S^m+O_m(N^{-1})$ in operator norm. +Compact limits are unique: polynomials in the second coordinate and +trigonometric polynomials in the first uniformly approximate continuous +functions. Polarization again supplies cross measures. For $\Rea z>0$, +integrating $\lambda^z$, with value zero at $\lambda=0$, against them gives +the bounded complex transfer powers used in \cref{sec:pins}. These finite positive-measure +constructions suffice; no reconstruction of a continuum field is used. + +Put \(P=2\pi/\sqrt3\). Restrict translations to the rectangular sublattice +generated by \((1,0)\) and \((0,\sqrt3)\), and let \(C'\) be the projection +of \(C\) onto its reciprocal rectangle +\[ + \mathcal R=[-\pi,\pi)\times[-P/2,P/2). +\] +The projection is a two-sheeted covering of reciprocal tori. Its second +preimage of the rectangular origin is a nonzero point of \(\widehat\Tri\). +It will be called an alias of the origin. In every comparison below the +measure near this nonzero point is finite; atoms there are allowed. + +For \(00\). +\end{proposition} + +\begin{proof} +Let \(F=H(e_1)-H(0)\), supported on the reflection row. In the reflection +Hilbert space, let \(U\) be horizontal unit translation and \(S\) the positive +normal transfer from \cref{prop:reflection-positivity}. For \(j\ge0\), +\[ + \EE\big[F\,V_{ne_1+j(0,\sqrt3)}F\big] + =\langle F,U^nS^jF\rangle_\ell. +\] +The joint spectral resolution of the commuting operators \(U,S\) represents +this as \(\int e^{ink}\lambda^j\,\gamma(dk,d\lambda)\), with +\(0\le\lambda\le1\). Reflection in the row gives the same formula with +\(|j|\) for negative \(j\). Write +\(\lambda=e^{-\sqrt3s}\), including \(s=\infty\) at \(\lambda=0\). +The vertical Fourier coefficients of \(Q_s\) are +\(e^{-\sqrt3s|j|}\). Uniqueness of Fourier coefficients of finite measures +therefore identifies the ordinary increment spectral measure as the mixture +of \(Q_s\)'s with mixing measure \(\gamma\). By +\cref{lem:increment-spectral}, that increment measure is +\(|e^{ik}-1|^2 C'(dk,dl)\). Division on \(k\ne0\) proves +\cref{eq:cauchy-mixture} and the local finiteness assertion. + +Since \(Q_s\) has total mass one, the left side of +\cref{eq:weighted-nu} equals \(\int_{0<|k|<\kappa}|k|\,C'(dk,dl)\). +Near the physical origin this is finite by \cref{lem:annulus-mass}, because +\(|k|\le|p|\). The rest consists of finite mass away from the physical +origin, including the alias contribution. This proves the assertion without +any horizontal-band estimate on \(\nu\). +\end{proof} + +\subsection{An angular identity with a nonnegative defect} + +We seek an angular function whose sixfold rotational average is zero, +but whose unperiodized vertical Poisson average is nonnegative and vanishes precisely +when the normal scale equals the tangential frequency magnitude. The +fourth harmonic has both properties. The estimates below control +periodization, aliases, and the passage from horizontal bands to physical +annuli; the dispersion relation is forced only in the scaling limit. + +For \(p=(k,l)\ne0\), write +\[ + \chi(k,l)=\cos(4\arg(k+il)) + =1-\frac{8k^2l^2}{(k^2+l^2)^2}. +\] +On \(\mathcal R\), this means the displayed function of the centered +representatives; we only integrate it over small horizontal bands. + +\begin{lemma}[Angular Poisson identity] +\label{lem:angular-poisson} +Uniformly for \(s\in[0,\infty]\) and \(0<|k|<\kappa\), +\begin{equation} + \label{eq:angular-poisson} + \int\chi(k,l)Q_s(dl) + =D(k,s)+O(|k|),\qquad + D(k,s)=\left(\frac{|k|-s}{|k|+s}\right)^2, +\end{equation} +where \(D(k,\infty)=1\). +\end{lemma} + +\begin{proof} +Put \(a=|k|\). The bounded analytic function +\[ + z\longmapsto\left(\frac{a+iz}{a-iz}\right)^2 +\] +on the upper half-plane has boundary real part \(\chi(a,l)\). +The Poisson formula at \(z=is\) gives, for the unperiodized Cauchy density +\(p_s(l)=s/\{\pi(s^2+l^2)\}\), +\[ + \int_\R\chi(a,l)p_s(l)\,dl + =\left(\frac{a-s}{a+s}\right)^2. +\] +To bound periodization uniformly, put +\(f_a(l)=1-\chi(a,l)=8a^2l^2/(a^2+l^2)^2\). Then +\(\int_\R f_a(l)\,dl=4\pi a\), and +\(f_a(l)\le 8a^2/l^2\) away from zero. Also +\[ + \sup_{s>0}\sup_{|l|\le P/2}\sum_{n\ne0}p_s(l+nP)<\infty. +\] +For this last bound, split the sum at \(|n|\) comparable to \(s/P\): the +near terms are bounded by \(1/(\pi s)\), and the remaining square tail is +summable. Comparing the integrals of \(f_a\) over the period and over the +line now gives an \(O(a)\) error; the unfolded tail contributes only +\(O(a^2)\). The cases \(s=0\) and \(s=\infty\) follow directly from their +definitions. +\end{proof} + +\begin{proposition}[Summable dispersion defect] +\label{prop:dispersion-defect} +For some fixed \(\kappa>0\), +\begin{equation} + \label{eq:dispersion-defect} + \int_{0<|k|<\kappa}D(k,s)\,\nu(dk,ds)<\infty. +\end{equation} +There is a finite constant \(K_1\) such that +\begin{equation} + \label{eq:horizontal-band-mass} + \nu\{r\le|k|\le2r\}\le K_1 +\end{equation} +for all sufficiently small \(r>0\). +\end{proposition} + +\begin{proof} +Integrate \cref{eq:angular-poisson} over \(\eps<|k|<\kappa\). +The total error is bounded independently of \(\eps\) by +\cref{eq:weighted-nu}. Replacing the projected measure by the physical +measure in the disk \(|p|<\kappa\) incurs another bounded error: the omitted +physical region and the aliases have finite mass. Thus it suffices to bound +above +\[ + \int_{\eps<|p|<\kappa,\ |k|>\eps}\chi(k,l)\,C(dp). +\] +The integral over the full radial annulus vanishes. Indeed, the sum of the +fourth angular harmonic over rotations by multiples of \(\pi/3\) is zero, +and \(C\) is invariant under those rotations. Write +\(E_\eps=\{|k|\le\eps,\ \eps<|p|<\kappa\}\) for the removed endcap. +Then +\[ + \int_{\eps<|p|<\kappa,\ |k|>\eps}\chi\,dC + =-\int_{E_\eps}\chi\,dC + \le\int_{E_\eps\cap\{\chi<0\}}|\chi|\,dC. +\] +Negativity requires \(|l/k|<1+\sqrt2\), so the last integral is confined +to \(\eps<|p|\le K_2\eps\). A fixed number of the annuli in +\cref{eq:annulus-mass} bounds it uniformly. This gives the required upper +bound even if the positive part of the endcap integral is large. Since +\(D\) is nonnegative, monotone convergence gives +\cref{eq:dispersion-defect}. + +For \cref{eq:horizontal-band-mass}, on \(r\le|k|\le2r\) the part with +\(s\notin[r/2,4r]\) has \(D\ge1/9\), and hence bounded mass. For +\(s\in[r/2,4r]\), a fixed positive fraction of \(Q_s\) lies in +\(|l|\le2r\). \Cref{eq:cauchy-mixture} bounds that part of \(\nu\) +by a constant times +\(C'\{r\le|k|\le2r,\ |l|\le2r\}\). This is bounded by +\cref{lem:annulus-mass} and the finite alias mass. +\end{proof} + +\begin{lemma}[Endcap estimate] +\label{lem:endcap} +For a finite constant \(K_3\), +\begin{equation} + \label{eq:endcap} + C\{r<|p|<2r,\ |k|\le\eps\}\le K_3\frac{\eps}{r}, + \qquad 0<\eps0\), rescale the physical neighborhood of zero by +\(p\mapsto p/\delta\); denote the resulting measure by \(C_\delta\). +Its restriction to any fixed compact subset of \(\R^2\setminus\{0\}\) is +well defined once \(\delta\) is small. By \cref{lem:annulus-mass}, every +sequence \(\delta\downarrow0\) has a subsequence with a vague limit there. + +\begin{lemma} +\label{lem:spectral-subsequences} +Every such vague limit has the form +\begin{equation} + \label{eq:spectral-subsequence} + M(dp)=c\,\frac{dp}{|p|^2} +\end{equation} +for a finite \(c\ge0\), initially allowed to depend on the subsequence. +\end{lemma} + +\begin{proof} +Fix a compact horizontal band \(a\le|k|/\delta\le b\), where \(010\), it is supported on \(|k|<1\), +whose rescaled mass is at most \(K/R\) by \cref{lem:endcap}. Summing gives +an \(O(1/R)\) tail bound. Vague convergence may therefore be used in the +whole integral. Polar coordinates yield +\begin{align*} + \sum_{j\ge0}I_j + &=c\int_0^{2\pi}\cos(4u) + \int_0^\infty\bigl[q(r)-q(r|\cos u|)\bigr]\frac{dr}{r}\,du\\ + &=c\int_0^{2\pi}\cos(4u)\log|\cos u|\,du + =-\frac\pi2c. +\end{align*} +For the middle equality, change variables in the second radial integral, +first with finite cutoffs. The absolute radial integral is bounded by a +constant times \(1+|\log|\cos u||\), which is integrable in \(u\). +For the last equality, use the fourth Fourier coefficient of +\(\log|1+e^{2iu}|\), obtained by expanding from inside the unit circle; the +constant \(-\log2\) in \(\log|\cos u|\) has zero pairing with \(\cos4u\). +The left side is independent of the subsequence, so all coefficients agree. +The final integral also proves independence of \(q\). +\end{proof} + +\subsection{Covariance convergence and a reflection null vector} + +\begin{theorem}[Universal plane covariance] +\label{thm:plane-covariance} +The rescaled spectral measures converge vaguely on the punctured plane to +\(c_*\,dp/|p|^2\), with \(00\). +Its finiteness follows already from the annular mass bound. +\end{proof} + +\begin{corollary}[Reflection null vector] +\label{cor:reflection-null} +Let \(\phi\in C_c^\infty(\R^2)\) be supported strictly on one side of a line +parallel to a lattice reflection direction. Choose site rows \(\ell_\delta\) +converging to that line, still separated from the support by a positive +margin. For +\begin{equation} + \label{eq:laplace-insertion} + X_\delta=H_\delta(\Delta\phi), +\end{equation} +its reflection norm at \(\ell_\delta\) tends to zero. This holds in every +finite phase augmentation of \cref{prop:reflection-positivity}, and also for +lattice translations and reflected placements converging to the stated +configuration. +\end{corollary} + +\begin{proof} +The squared norm is +\(\EE[(\Theta_{\ell_\delta}X_\delta)X_\delta]\). By +\cref{thm:plane-covariance}, it converges to the inverse-Laplacian pairing of +\(\Delta\phi\) and its reflected copy, multiplied by \(v\). That pairing is +\(\int\nabla\phi\cdot\nabla(\phi\circ\theta)\), and is zero because the +supports are disjoint. Reflection positivity makes these squared norms +nonnegative. Auxiliary phases do not change the expectation of a statistic +which does not use them. Converging placements are covered by the varying-test +assertion of \cref{thm:plane-covariance}. The conclusion concerns the reflection +norm; the ordinary variance of \(X_\delta\) need not vanish. +\end{proof} diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/06-normalization.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/06-normalization.tex new file mode 100644 index 0000000000000000000000000000000000000000..2dc893d86116a1cc096fdf8e905637c3402752b4 --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/06-normalization.tex @@ -0,0 +1,199 @@ +\section{An absolutely convergent formula for the normalization} +\label{sec:normalization} + +The spectral constant can be specified entirely by finite counting problems. +This section fixes every ingredient of the formula and proves convergence of +its indicated terms. The construction is independent of a domain and its +marked boundary points. + +Choose the even smooth cutoff +\begin{equation} + \label{eq:explicit-cutoff} + q(s)= + \begin{cases} + 1,& |s|\le1/2,\\[2pt] + \displaystyle + \frac{e^{-1/(1-|s|)}} + {e^{-1/(1-|s|)}+e^{-1/(|s|-1/2)}},&1/2<|s|<1,\\[8pt] + 0,&|s|\ge1. + \end{cases} +\end{equation} +For \(j=0,1,2,\ldots\), define a smooth function on the reciprocal torus by +\begin{equation} + \label{eq:normalization-multiplier} + F_j(p)=q(4|p|)\cos(4\arg p) + \bigl[q(2^jk)-q(2^{j+1}k)\bigr],\qquad p=(k,l), +\end{equation} +using its expression in the disk \(|p|<1/4\), and zero outside that disk. +Set \(F_j(0)=0\). Smoothness at the apparent angular singularity follows +because the bracket vanishes whenever \(|k|\le2^{-j-2}\). +Let \(d_{ju}\), \(u\in\Tri\), be its Fourier coefficients, with the convention +\begin{equation} + \label{eq:normalization-fourier} + F_j(p)=\sum_{u\in\Tri}d_{ju}e^{ip\cdot u},\qquad + d_{ju}=\frac{A_{\Tri}}{(2\pi)^2} + \int_{\widehat\Tri}F_j(p)e^{-ip\cdot u}\,dp, + \qquad A_{\Tri}=\frac{\sqrt3}{2}. +\end{equation} +Here the integral uses Euclidean measure on any fundamental representative +of the torus, whose area is \((2\pi)^2/A_{\Tri}\). The coefficients are real +and satisfy \(d_{j,-u}=d_{ju}\), because \(F_j\) is real and even. + +For \(j,s\ge0\), put +\begin{equation} + \label{eq:normalization-radii} + R_{js}=2^{(j+s+4)^2},\qquad + \mathcal H_R=\{u\in\Tri:\dist_{\Tri}(0,u)\le R\}. +\end{equation} +Let \(\langle\cdot\rangle_R\) be uniform averaging over all pairs +\(B,W\in\{-1,+1\}^{\mathcal H_R}\) for which both colors do not change on the +same nearest-neighbor edge. There are no boundary pins. For +\(|u|\le\sqrt R\), choose any lattice path \(\gamma_{0u}\) in +\(\mathcal H_R\), oriented from \(0\) to \(u\), and set +\begin{equation} + \label{eq:finite-band-coefficient} + b_{js}=\sum_{\substack{u\in\Tri\\ |u|\le\sqrt{R_{js}}}}d_{ju} + \left\langle + \left(\sum_{xy\in\gamma_{0u}} + \frac{W_xB_y-B_xW_y}{2}\right)^2 + \right\rangle_{R_{js}}. +\end{equation} +The curl identity for the spin encoding makes this independent of the paths. +The expression is a finite sum of prescribed Fourier coefficients and ratios +of finite integer counts. + +\begin{proposition}[Finite-volume normalization series] +\label{prop:normalization-series} +The series of the indicated terms is absolutely convergent: +\begin{equation} + \label{eq:normalization-absolute} + \sum_{j\ge0}|b_{j0}|+ + \sum_{j,s\ge0}|b_{j,s+1}-b_{js}|<\infty. +\end{equation} +Its value satisfies +\begin{equation} + \label{eq:finite-normalization} + c_*=\frac1\pi\sum_{j\ge0} + \left[b_{j0}+\sum_{s\ge0}(b_{j,s+1}-b_{js})\right]>0, + \qquad + \sigma=4\pi\sqrt{c_*}. +\end{equation} +Thus the displayed formula specifies a strictly positive universal +normalization using only \cref{eq:explicit-cutoff,eq:normalization-multiplier,eq:normalization-fourier,eq:normalization-radii,eq:finite-band-coefficient}. +\end{proposition} + +\begin{proof} +Write +\[ + V(u)=\EE\bigl(H(u)-H(0)\bigr)^2,\qquad + b_j=\sum_{u\in\Tri}d_{ju}V(u). +\] +The height rule gives \(V(u)\le K|u|^2\) for \(u\ne0\). For each fixed \(j\), +Fourier smoothness makes the series defining \(b_j\) absolutely convergent. +By \cref{eq:increment-spectral}, +\[ + V(u)=2\int(1-\cos(p\cdot u))\,C(dp). +\] +Interchanging the sum and integral is legitimate even though \(C\) has +infinite mass near zero: the absolute integral is bounded by +\(\sum_u|d_{ju}|V(u)<\infty\). Since +\(\sum_u d_{ju}=F_j(0)=0\) and +\(\sum_u d_{ju}\cos(p\cdot u)=F_j(p)\), we obtain +\begin{equation} + \label{eq:band-inversion} + b_j=-2\int F_j(p)\,C(dp)=-2I_j. +\end{equation} +It follows from \cref{prop:angular-sum} that +\begin{equation} + \label{eq:infinite-band-sum} + \sum_{j\ge0}|b_j|<\infty, + \qquad \sum_{j\ge0}b_j=\pi c_*. +\end{equation} + +We next bound the finite-volume error uniformly in both indices. Differentiating +\cref{eq:normalization-multiplier} a fixed number of times gives +\begin{equation} + \label{eq:band-fourier-decay} + |d_{ju}|\le K\,2^{Aj}(1+|u|)^{-8} +\end{equation} +for fixed finite constants \(K,A\). Indeed, on the support of the horizontal +bracket we have \(|p|\ge|k|\ge2^{-j-2}\); derivatives of the angular factor +and of the rescaled cutoff therefore cost only a fixed power of \(2^j\). +Integration by parts in a basis of torus coordinates gives the displayed +decay. + +Let \(V_R(u)\) denote the finite-hexagon expectation in +\cref{eq:finite-band-coefficient}. Reduce the exponent in +\cref{prop:plane-mixing}, if necessary, to \(0<\alpha\le1\). For +\(0<|u|\le\sqrt R\), evaluate the increment along a shortest path contained +in a ball of radius \(K|u|\). This is permitted by path independence. Both +its finite and infinite versions have square at most \(K|u|^2\). Coupling +inside this ball gives +\begin{equation} + \label{eq:finite-variance-error} + |V_R(u)-V(u)|\le K|u|^2\left(\frac{|u|}{R}\right)^\alpha. +\end{equation} +The distance to the free outer boundary is comparable to \(R\), uniformly in +the stated range. Combining +\cref{eq:band-fourier-decay,eq:finite-variance-error}, the error in the retained +part of the coefficient is at most +\[ + K2^{Aj}R^{-\alpha} + \sum_{u\in\Tri}(1+|u|)^{-8}|u|^{2+\alpha} + \le K'2^{Aj}R^{-\alpha}. +\] +The omitted tail is at most +\[ + K2^{Aj}\sum_{|u|>\sqrt R}(1+|u|)^{-8}|u|^2 + \le K'2^{Aj}R^{-2}. +\] +Consequently, for some fixed \(\beta>0\), +\begin{equation} + \label{eq:finite-band-error} + |b_{js}-b_j|\le K2^{Aj}R_{js}^{-\beta}. +\end{equation} +All constants here are independent of \(j,s\). + +Put \(e_{js}=b_{js}-b_j\). The particular radii in +\cref{eq:normalization-radii} make +\(\sum_{j,s}|e_{js}|<\infty\), since a negative quadratic exponent dominates +\(Aj\). Moreover, +\[ + |b_{j,s+1}-b_{js}|\le|e_{j,s+1}|+|e_{js}|, + \qquad |b_{j0}|\le|b_j|+|e_{j0}|. +\] +Together with \cref{eq:infinite-band-sum}, this proves +\cref{eq:normalization-absolute}. For every \(j\), telescoping gives +\(b_{j0}+\sum_s(b_{j,s+1}-b_{js})=b_j\), and then +\cref{eq:infinite-band-sum} gives the first identity in +\cref{eq:finite-normalization}. Its positivity was proved in +\cref{thm:plane-covariance}. Finally, the covariance coefficient for \(H\) is +\(v=(2\pi)^2c_*\). The centered odd height is twice the centered integer +height, so its covariance coefficient is \(4v\), whose positive square root +is \(4\pi\sqrt{c_*}\). +\end{proof} + +\begin{remark}[The fundamental-cell convention] +\label{rem:cell-area} +There is no further triangular-cell factor in +\cref{eq:finite-normalization}. If \(\lambda_u\) is the unit-mesh nodal hat, +then \(\int\lambda_u=A_{\Tri}\). Thus the physical interpolation weight is +\[ + a_{\delta,u}(f) + =\delta^2\int_{\R^2}\lambda_0(y)f(\delta u+\delta y)\,dy. +\] +The hat mass \(A_{\Tri}\delta^2\) cancels the site density +\((A_{\Tri}\delta^2)^{-1}\) in the limit of the transform at +\(p=\delta\zeta\). Its limit is \(\widehat f(-\zeta)\), with no prefactor. +The reciprocal-cell factor in \cref{eq:normalization-fourier} is already part +of the Fourier coefficients used in \cref{eq:band-inversion}. The only +remaining comparison is between +\(c_*\int|\widehat f(\zeta)|^2|\zeta|^{-2}\,d\zeta\) and the conventional +inverse-Laplacian covariance +\((2\pi)^{-2}\int|\widehat f(\zeta)|^2|\zeta|^{-2}\,d\zeta\). +This accounts for \(v=(2\pi)^2c_*\). +\end{remark} + +With the normalization fixed, we return to the reflection-null identity of +\cref{cor:reflection-null}. In \cref{sec:pins} we transfer that identity to +laws conditioned on the boundary pins. diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/07-pins.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/07-pins.tex new file mode 100644 index 0000000000000000000000000000000000000000..585d40554a52b9eb4b1e7ee4fca4b7466f8515af --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/07-pins.tex @@ -0,0 +1,741 @@ +\section{Opening and moving boundary pins}\label{sec:pins} + +We transfer the plane reflection identity to two laws that bracket the +boundary problem. Three separate operations are involved: opening small +gaps makes the pin sets into separated arcs; analytic translation moves +these arcs to one side of the insertion; and a local coupling closes the +gaps. Throughout this section all geometric lengths are in physical +coordinates. Every fixed arrangement is discretized before any of its +gaps or windows are shrunk. + +Write $g_\delta=0$ on $A^+_\delta$ and $g_\delta=-1$ on +$A^-_\delta$. A \emph{local increment function in a disk $K$} is a +measurable function of the increments on lattice edges in $K$, with a +fixed arbitrarily small enlargement of $K$ allowed for interpolation. +In particular, if $f\in C_c^\infty(K)$ and $\int f=0$, then +$H_\delta(f)$ is such a function: its interpolation coefficients have +sum zero, and paths joining their vertices can be chosen in the enlarged +disk. We use +\begin{equation}\label{eq:pins-insertion} + X_\delta=H_\delta(\Delta\phi),\qquad + F_\delta=\prod_{j=1}^q F_{j,\delta},\qquad + \supp\phi\Subset K_0, +\end{equation} +where $\phi\in C_c^\infty(K_0)$ is real and each $F_{j,\delta}$ is a local +increment function in a disk $K_j$. We assume a uniform bound on +$\prod_j\|F_{j,\delta}\|_\infty$. The disks $K_1,\ldots,K_q$ +may overlap each other. They are disjoint, with positive clearance, +from $K_0$. The case $q=0$ means $F_\delta=1$. + +\subsection{Windows and actual height brackets} + +Fix a finite set $\mathcal L$ of horizontal levels. Require that every +level meeting $\partial D$ is a regular value of the height coordinate +on $\partial D$, and that no level contains a marked point. Its +intersections with $\partial D$ are finite: transversality makes them +isolated, and compactness then makes their number finite. Around every +intersection choose a small open boundary arc, called a \emph{window}. +The closures of the windows are disjoint and avoid the marks. Choose +them small enough that the portions of boundary between successive +windows contain nonempty exact-value arcs. We denote this finite +window system by $\mathcal W$. + +The discrete windows are intervals in the boundary parametrization of +$D_\delta$. Uniform convergence of that parametrization specifies +them for all sufficiently small $\delta$; their endpoints are rounded +to partitions between consecutive boundary vertices. Thus a vertex +is assigned to exactly one portion of the boundary. Uniform +convergence, rather than the number of discrete crossings of a line, +is what determines these windows. + +In the plane spin law impose the exact Gray-code pins of $g_\delta$ +off $\mathcal W$. In an upper bracket impose only $B=+$ on every +window, and in a lower bracket impose only $B=-$. These finite pin +events have positive probability. For example, a double cut around +the whole boundary reduces positivity to an admissible finite spin +extension; the corresponding bounded height extension supplies one. +Anchor the height at an exact-value vertex $v_*$ by +$H(v_*)=g_\delta(v_*)$. Let $\mu^{+,\mathcal W}_\delta$ and +$\mu^{-,\mathcal W}_\delta$ be the resulting laws inside $D_\delta$. + +\begin{lemma}[Boundary brackets]\label{lem:boundary-brackets} +The boundary traces in these laws satisfy the following actual integer +height constraints: +\begin{equation}\label{eq:bracket-intervals} +\begin{array}{c|cc} + & \text{off the windows}&\text{on a window}\\ \hline + \mu^{+,\mathcal W}_\delta & H=g_\delta&H\in\{0,1\}\\ + \mu^{-,\mathcal W}_\delta & H=g_\delta&H\in\{-2,-1\}. +\end{array} +\end{equation} +Conditional on the trace, the interior has the uniform height Gibbs +law with that trace. Consequently there is a coupling with the true +height law $\mu^g_\delta$ such that +\begin{equation}\label{eq:bracket-order} + H^-_\delta\le H^g_\delta\le H^+_\delta + \quad\text{at every vertex, and hence after affine interpolation}. +\end{equation} +The bracket means lie between $-2$ and $1$. The bounded-boundary +smearing estimates of \cref{prop:smearing-moments} apply to both +brackets, uniformly in the sizes and number of windows. +\end{lemma} + +\begin{proof} +The inverse images of $B=+$ in $\Z$ are the disjoint adjacent pairs +$\{4t,4t+1\}$; those of $B=-$ are $\{4t-2,4t-1\}$. Along a +connected chain with constant $B$, the height cannot move from one +such pair to another, since the distance between successive pairs is +three. The nearest-neighbor height constraint therefore propagates +one pair along the entire chain. + +For an upper window adjoining exact height $0$, this pair is +$\{0,1\}$. If it adjoins exact height $-1$, its first vertex must +have height $0$, again selecting $\{0,1\}$. For a lower window, +height $-1$ directly selects $\{-2,-1\}$, and an adjoining exact +height $0$ forces the first window vertex to be $-1$. At a marked +transition the exact residues $0$ and $-1$ select the unique adjacent +branches. Starting from $v_*$ and following the connected boundary +therefore gives \eqref{eq:bracket-intervals} everywhere, including +every later exact-value arc. This proves an integer statement, +independent of any choice of representatives modulo four. + +The spin-height bijection and the Gibbs property in +\cref{lem:gray} identify the conditional interior law. No edge from +an interior vertex reaches past the pinned vertex boundary. The +upper trace dominates $g_\delta$, and the lower trace is dominated +by it. Height comparison, applied to each trace and then averaged, +gives the two stochastic orders and an ordered coupling. Comparison +with constant boundary heights $-2$ and $1$, whose centered laws are +sign-symmetric, bounds the means. The same comparison and +\cref{prop:smearing-moments} give the asserted moment bounds. +\end{proof} + +\subsection{Reflection estimates with rare pins} + +Analytic translation across a separating line is also used to propagate +correlation identities in the six-vertex argument of +\cite[Section~7.1, especially Lemma~7.4]{DCKLM2026}. Our factors include +conditioning on rare obstacle events. The first task is therefore to +bound the reflected norms after division by their probabilities; this +bound is what permits the same analytic-continuation principle here. + +We first record precisely the normalization used when moving pins. +An obstacle event $P_i$ below consists of pins on a connected arc, +with the following description in a height lift: +\begin{equation}\label{eq:obstacle-intervals} + H(v)\in I_i(v)+4t_i\quad(v\text{ on the arc}),\qquad t_i\in\Z. +\end{equation} +Here the $I_i(v)$ are fixed integer intervals, at least one of them +is a singleton, and the spin description consists of $B$ pins and +$W=+$ on a bounded number of connected subpaths. These are the +obstacles of \cref{prop:pin-product,prop:obstacle-moments}. +The filled obstacle neighborhoods are pairwise disjoint, as specified +in \cref{prop:pin-product}. Every unbounded insertion has a pin-free +filled test neighborhood, including its cut-search buffer, disjoint +from all of them, as in \cref{prop:obstacle-moments}. These are fixed +positive-clearance conditions. Bounded spectator disks may overlap one +another. Constants may depend on this fixed geometry. + +The disconnected pin arcs carry separate offsets $4t_i$. We impose +their equality before closing gaps: \cref{prop:obstacle-moments} does +not give uniform constants as gaps shrink, whereas common offsets give +fixed integer interval constraints after anchoring. Balanced endpoint +phases will Fourier-project the event that these offsets agree; +see \eqref{eq:fourier-offset-equality}. To carry those phases through +reflections and translations, we use the auxiliary fields of +\cref{prop:reflection-positivity}. For a real frequency $\theta$, set +\begin{equation}\label{eq:haar-phase} + Z_\theta(v)=U_\theta + \exp\{i\theta(H(v)-H(o))\}, +\end{equation} +where $U_\theta$ is uniform on the unit circle, independent of the +spins; use an independent $U$ for each field being added. The choice +of $o$ is immaterial because of Haar invariance, and the original spin +and increment law is unchanged. \Cref{prop:reflection-positivity} gives +stationarity, reflection positivity, and the positive normal transfer +for the joint law. Phase values in a half-plane are recovered from +its row phases and paths staying in that half-plane, so endpoint phases +have the required local support. Frequencies may be arbitrary real +numbers; no periodicity of a lifted height is assumed. + +Let $\vartheta$ be reflection across a lattice row. On functions +supported in its closed positive half-plane, write +\begin{equation}\label{eq:pins-reflection-product} + \langle A,B\rangle_{\vartheta} + =\EE[\overline{\vartheta A}\,B],\qquad + \|A\|_{\vartheta}^2=\langle A,A\rangle_{\vartheta}. +\end{equation} +We use the quotient and completion for this positive semidefinite +form. Pure normal translation through +$\tau_\delta=\sqrt3\,\delta$ acts there as a positive self-adjoint +contraction $S_\delta$ by \cref{prop:reflection-positivity}. + +\begin{lemma}[Normalized reflection bound]\label{lem:normalized-reflection} +Suppose the obstacle events $P_1,\ldots,P_m$ and the support of $A$ +are strictly on one side of a reflection row. The obstacles have +pairwise disjoint filled isolating neighborhoods, and every unbounded +insertion in $A$ has a pin-free filled test neighborhood disjoint from +them. Choose these neighborhoods inside the same open half-plane. Let +$p_i=\PP(P_i)$ and +\[ + V=A\prod_{i=1}^m\frac{\one_{P_i}}{p_i}. +\] +Assume $A$ is either uniformly bounded or a uniformly bounded +function times one smooth zero-total height insertion in such a +disk. Bounded factors may include the phase fields +\eqref{eq:haar-phase}. Then $\|V\|_{\vartheta}\le C$, uniformly +as $\delta\downarrow0$. The assertion is uniform when the +macroscopic arrangements range over a compact family preserving +all the stated positive separations. +\end{lemma} + +\begin{proof} +Let $P=\bigcap_iP_i$ and $J=\prod_i p_i$. Directly from the +definition, +\begin{equation}\label{eq:squared-pin-normalization} + \|V\|_{\vartheta}^{2} + =\frac{\EE[\one_{P\cap\vartheta P} + \overline{\vartheta A}\,A]}{J^2}. +\end{equation} +There are $2m$ obstacles in this expression. The strict separation +from the row separates the original obstacles from their reflected +copies; their individual probabilities are +$p_1,\ldots,p_m,p_1,\ldots,p_m$. Consequently +\cref{prop:pin-product} gives +\begin{equation}\label{eq:reflected-pin-product} + \PP(P\cap\vartheta P)\le C\prod_{i=1}^m p_i^2=CJ^2. +\end{equation} +For bounded $A$ this proves the claim. Otherwise write $A=BY$, +with $B$ bounded and $Y$ the zero-total insertion. +\Cref{prop:obstacle-moments}, applied separately to $Y$ and +$\vartheta Y$ in the full reflected obstacle arrangement, gives +\[ + \EE[|Y\,\vartheta Y|\mid P\cap\vartheta P] + \le\EE[|Y|^2\mid P\cap\vartheta P]^{1/2} + \EE[|\vartheta Y|^2\mid P\cap\vartheta P]^{1/2}\le C. +\] +Combining this with \eqref{eq:reflected-pin-product} cancels the +\emph{squared} denominator in \eqref{eq:squared-pin-normalization}. +The estimates invoked have uniform constants on the indicated +compact families. Unit-modulus phases do not alter them. +\end{proof} + +\begin{lemma}[Analytic translation]\label{lem:analytic-translation} +Partition a finite arrangement of pin obstacles and local factors +into two groups strictly separated by projection on a lattice +reflection normal $n$. The factors have the form allowed in +\cref{lem:normalized-reflection}, with at most one unbounded +zero-total insertion in the entire arrangement. Move the high +group rigidly by $tn$, keeping the low group fixed, and normalize +the plane expectation by the product of the individual obstacle +probabilities. Denote this quantity, at lattice normal step +translations, by $M_\delta(t)$. + +If $M_\delta(t_\delta)\to0$ for every $t$ in a nonempty open +interval $I\subset(0,\infty)$ and lattice-rounded $t_\delta\to t$, +then $M_\delta(0)\to0$. The same implication holds with the low +group moved in direction $-n$. It also holds along sequences of +other fixed placements converging with all the required positive +clearances. +\end{lemma} + +\begin{proof} +We prove the high-group version. Choose $\eta>0$ so small that +moving this group by $-\eta n$ still leaves a fixed positive +projection gap. Put $\eta_\delta=N_\delta \tau_\delta\to\eta$ with +$N_\delta\in\N$, and use the translated arrangement at +$-\eta_\delta$ as the initial arrangement. Choose a lattice +reflection row in its gap, tending to a row strictly in the +limiting gap. Reflect and conjugate the normalized low-group +factor to obtain a positive-side Hilbert vector $A_\delta$; +denote the normalized high-group factor at $-\eta_\delta$ by +$B_\delta$. Individual obstacle probabilities are invariant under +these lattice translations and reflections. By +\cref{lem:normalized-reflection}, +\begin{equation}\label{eq:analytic-side-bound} + \|A_\delta\|_{\vartheta},\ \|B_\delta\|_{\vartheta}\le C. +\end{equation} + +For $\Rea z>-\eta_\delta$ define +\begin{equation}\label{eq:analytic-matrix-element} + f_\delta(z)= + \big\langle A_\delta, + S_\delta^{(z+\eta_\delta)/\tau_\delta}B_\delta\big\rangle_{\vartheta}. +\end{equation} +If $S_\delta=\int_{[0,1]}\lambda\,dE_\delta(\lambda)$, the power +in this formula means +\[ + S_\delta^w=\int_{(0,1]}e^{w\log\lambda}\,dE_\delta(\lambda), + \qquad \Rea w>0. +\] +Its value on the zero spectral subspace is zero. It is holomorphic +in this open half-plane and has operator norm at most one. +Holomorphy follows, for example, by dominated differentiation on +compact subsets, using boundedness of +$\lambda^a|\log\lambda|^k$ for $a>0$. Thus +\eqref{eq:analytic-side-bound} makes $f_\delta$ uniformly bounded. +For small $\delta$ all these functions are defined on the common +half-plane $\Rea z>-\eta/2$. This open half-plane contains zero +in its interior. + +At every lattice parameter $t=m\tau_\delta\ge0$ the exponent in +\eqref{eq:analytic-matrix-element} is the positive integer +$m+N_\delta$, so the transfer interpretation gives exactly +$f_\delta(t)=M_\delta(t)$. There is no assertion here about the +spectral power at the initial boundary point $-\eta_\delta$. +Cauchy's estimate on compact subsets gives a uniform derivative +bound, so replacing a real parameter by its nearest lattice +parameter changes $f_\delta$ by $o(1)$. + +Along any subsequence, the normal-family theorem supplies a further +subsequence converging locally uniformly to a holomorphic function +$f$. The hypothesis makes $f$ zero on $I$. The identity theorem +then makes it zero throughout the common half-plane, in particular +at zero. Every subsequence has this property, proving the claim. +Choose the filled neighborhoods strictly inside the two separated +projection regions. Rigid motion preserves their within-group +separations, while moving the groups apart preserves their projection +gap. The initial negative backoff is smaller than that gap. Reflected +copies likewise have disjoint filled neighborhoods by their positive +row margin. These observations verify the geometric hypotheses of +the side norm bounds throughout the motion. Convergent variations of +the other placements preserve those bounds and the common half-plane. Replacing $n$ by $-n$ +proves the low-group version. +\end{proof} + +\subsection{Gaps and three directions of motion} + +Choose two levels $\ell_-<\ell_+$ from $\mathcal L$ such that +$K_0$ lies strictly between them and neither line meets any +$K_j$, $j\ge1$. All these separations have positive margins. +Inside each window based at an intersection with these two levels, +remove a still smaller boundary subarc from the pin set. These are +the \emph{gaps}. For now their sizes are fixed and positive. They +are chosen to contain the boundary portions in a sufficiently thin +strip about their level, so that all remaining pins stay a positive +distance from the two lines. Transversality and uniform boundary +convergence ensure this at small mesh, even if the approximating +boundary has many crossings inside a window. + +The remaining connected pin arcs are the obstacle events +$P_1,\ldots,P_m$. At these fixed positive gap sizes they approach +finitely many disjoint compact simple arcs. Thin regular neighborhoods +with endcaps give pairwise disjoint filled isolating neighborhoods, as +in \cref{prop:pin-product}; they can avoid the fixed interior test disks. +Each arc has its buffered collar inside its own neighborhood. Positive +separation from the chosen levels also lets the neighborhoods stay on +the same sides of those levels. Each arc contains an exact-value subarc. The branch argument in +\cref{lem:boundary-brackets}, now applied along an individual arc, +shows that it has exactly the interval description +\eqref{eq:obstacle-intervals}, with +\[ + I_i(v)=\{g_\delta(v)\}\ \text{off windows},\qquad + I_i(v)=\{0,1\}\ \text{or}\ \{-2,-1\}\ \text{on windows}. +\] +Only the integer offset $t_i$ can differ between distinct arcs. +Take an exact-value representative $v_i$ on each arc and put +$g_i=g_\delta(v_i)$. + +The geometric separation used below is the following. Set +\begin{equation}\label{eq:three-normals} + e=(0,1),\qquad u=(\sqrt3/2,1/2),\qquad + u'=(-\sqrt3/2,1/2). +\end{equation} +These are normals to the three lattice reflection directions. +The obstacles and spectator disks lying in the middle band must +split into two families $L,R$, with a number $\kappa>0$ such that +\begin{equation}\label{eq:middle-projections} + \sup_{x\in L}x\cdot u + <\inf_{x\in K_0}x\cdot u-\kappa, + \qquad + \inf_{x\in R}x\cdot u + >\sup_{x\in K_0}x\cdot u+\kappa. +\end{equation} +Here and below a supremum over a family means over the union of +its supports. Empty families are omitted. All the remaining +obstacles and spectator disks lie wholly above $\ell_+$ (family +$T$) or below $\ell_-$ (family $B$). Overlapping spectator disks +belong to the same family; their factors will always move together. + +\begin{proposition}[Identity with separated gaps]\label{prop:gapped-identity} +Fix windows, gaps and tests satisfying the preceding conditions. +Let $P=\bigcap_{i=1}^mP_i$ and +$J_\delta=\prod_{i=1}^m\PP(P_i)$. For any product $\Psi_\delta$ +of unit-modulus phase factors at the representatives $v_i$, +\begin{equation}\label{eq:gapped-phase-identity} + \frac{\EE[X_\delta F_\delta\Psi_\delta\one_P]}{J_\delta} + \longrightarrow0. +\end{equation} +The phases may have arbitrary fixed real frequencies and the +independent Haar lifts of \eqref{eq:haar-phase}. The assertion is +valid for every convergent sequence of lattice-rounded placements +with these strict separations. + +If $E$ is the event that all offsets in +\eqref{eq:obstacle-intervals} agree, then also +\begin{equation}\label{eq:gapped-equal-offset-identity} + \frac{\EE[X_\delta F_\delta\one_{P\cap E}]}{J_\delta} + \longrightarrow0. +\end{equation} +\end{proposition} + +\begin{proof} +We first prove \eqref{eq:gapped-phase-identity}. Include each +representative phase factor with its obstacle. Move all supports +apart by the following sequence of one-sided translations. Each +translation is across a strict projection gap and moves the entire +selected side rigidly. + +First move $T$ by $a_+e$ and $B$ by $-a_-e$, successively. +These are legitimate moves across the original horizontal gaps. +Choose the positive distances sufficiently large that $T$ is above +$K_0$ in $u$-projection and $B$ is below it in that projection. +Together with \eqref{eq:middle-projections}, the two combined +families +\[ + Q_+=T\cup R,\qquad Q_-=B\cup L +\] +are now strictly above and below $K_0$ in $u$-projection. + +Next move $Q_+$ by $bu$ and $Q_-$ by $-cu$, successively. +Choose $b$ large enough that all of $Q_+$ is strictly above $K_0$ +in vertical coordinate, and strictly below $K_0$ in $u'$-projection. +This is possible because $u\cdot e=1/2$ and +$u\cdot u'=-1/2$. Then choose $c$ large enough that all of +$Q_-$ lies strictly above $K_0\cup Q_+$ in $u'$-projection. +Each of these moves increases its separating $u$-gap. No +separation within either combined family changes. + +Finally move $Q_-$ by $du'$. Its $u'$-projection is already +separated from every other support, so this is another legitimate +one-sided move. Because $u'\cdot e=1/2$, a sufficiently large +$d$ puts all of $Q_-$ strictly above $K_0$ vertically. Thus every +factor other than $X_\delta$ is now strictly above $K_0$. +All choices can be made in open ranges with positive margins; +every finite choice leaves a fixed finite arrangement. The +successive strict projection gaps also keep different moving +families disjoint, while distances inside each moving family are +preserved. In particular, all individual arc collars remain +available. \Cref{fig:pin-moving} illustrates the three directions. + +At the final placement put a horizontal reflection row between +$K_0$ and all the other supports. Reflection Cauchy--Schwarz and +\cref{lem:normalized-reflection} bound the normalized expectation +by +\[ + C\|X_\delta\|_{\vartheta}. +\] +The norm tends to zero by \cref{cor:reflection-null}. That +corollary remains valid in the phase-augmented Hilbert space, +since $X_\delta$ itself does not involve phases and its reflection +inner product is unchanged by their addition. + +For every fixed admissible $a_+,a_-,b,c$, this proves vanishing +for $d$ in a sufficiently large open interval. Apply +\cref{lem:analytic-translation} to remove the last move. The same +argument then applies for every sufficiently large $c$ with +$a_+,a_-,b$ fixed, so it removes the $-cu$ move. Remove $bu$, +$-a_-e$ and $a_+e$ in that order, each time using an open interval +of allowed large values. This is successive one-variable +analytic continuation; no simultaneous motion through surrounding +pins is involved. It proves \eqref{eq:gapped-phase-identity} at +the original placement. + +To impose $E$, note that on $P$ +\[ + D_i=\frac{H(v_i)-g_i-H(v_1)+g_1}{4}=t_i-t_1\in\Z + \quad(2\le i\le m). +\] +For $s=(s_2,\ldots,s_m)\in[0,2\pi]^{m-1}$, +\begin{equation}\label{eq:balanced-offset-phases} + e^{i\sum_{i=2}^m s_iD_i} + =\prod_{i=2}^m + e^{-is_i(g_i-g_1)/4} + Z_{s_i/4}^{(i)}(v_i) + \overline{Z_{s_i/4}^{(i)}(v_1)}. +\end{equation} +Use an independent phase field for each $i$ on the right. Every +Haar factor cancels with its conjugate. Hence this is an identity +of functions of the original increments, including for unbounded +relative lifts. Fourier orthogonality gives exactly +\begin{equation}\label{eq:fourier-offset-equality} + \one_E=(2\pi)^{-(m-1)} + \int_{[0,2\pi]^{m-1}}e^{i\sum_{i=2}^m s_iD_i}\,ds + \quad\text{on }P. +\end{equation} +For each fixed $s$, the normalized expectation tends to zero by +\eqref{eq:gapped-phase-identity}. Its absolute value is bounded +uniformly in $s$ and $\delta$: indeed +\[ + \frac{\EE[|X_\delta F_\delta|\one_P]}{J_\delta} + \le \frac{\PP(P)}{J_\delta}\, + \|F_\delta\|_\infty\, + \EE[|X_\delta|\mid P]\le C +\] +by \cref{prop:pin-product,prop:obstacle-moments} at this fixed +gap geometry. Dominated convergence in +\eqref{eq:fourier-offset-equality} proves +\eqref{eq:gapped-equal-offset-identity}. +\end{proof} + +\begin{figure}[t] + \centering + \input{figures/pin-moving} + \caption{The three normal directions used to move the obstacles. + Each shaded group denotes all of its arc obstacles and local test + factors. The insertion $X$ stays fixed. Vertical moves first + separate $T$ and $B$; the $u$ moves separate $T\cup R$ and + $B\cup L$; for a sufficiently large final displacement, the + $u'$ move places the latter above $X$. + The relation $u\cdot u'=-1/2$ supplies the projection gap for + the last move. Distances are chosen successively; the drawing is + schematic.}\label{fig:pin-moving} +\end{figure} + +\subsection{Equal offsets and filling the gaps} + +Keep $\mathcal W$ fixed. Around each selected intersection choose +a small physical neighborhood contained in its single-color +window, disjoint from all test disks and from all other such +neighborhoods. In particular there are no $W$ pins in these +neighborhoods. Let $r>0$ be a sufficiently small fixed size for +them. Shrink the gaps so that each lies within a ball of radius +$a\ll r$ about its intersection. This is possible by +transversality. Constants in what follows can depend on +$\mathcal W$ and $r$, but not on $a$ or on sufficiently small +$\delta$. We write $o_\delta(1)$ with $a$ fixed. + +Let $\mu_{\delta,a}$ be the plane law conditioned on the gapped +pins. Let $\mu^{=}_{\delta,a}=\mu_{\delta,a}(\,\cdot\mid E)$, +whenever $E$ has positive probability. Finally let +$\mu_{\delta,0}$ denote the filled bracket. All these notations +refer to one chosen sign of the bracket. + +\begin{lemma}[Gap filling]\label{lem:gap-filling} +There are $\beta>0$ and a function $\epsilon(a)\to0$ as +$a\downarrow0$ such that +\begin{equation}\label{eq:offset-high-probability} + \limsup_{\delta\downarrow0}\mu_{\delta,a}(E^c) + \le\epsilon(a). +\end{equation} +If $\mathscr I_\delta$ is the joint increment information in the +fixed test disks, then +\begin{equation}\label{eq:gap-tv} + \limsup_{\delta\downarrow0} + \big\|\mu^{=}_{\delta,a}|_{\mathscr I_\delta} + -\mu_{\delta,0}|_{\mathscr I_\delta}\big\|_{\rm TV} + \le\epsilon(a). +\end{equation} +For every finite $p$, and for all sufficiently small $a$, the +variables $X_\delta$ have uniformly bounded $p$th moments under +$\mu^{=}_{\delta,a}$ and under $\mu_{\delta,0}$, in the sense +of a bound on $\limsup_{\delta\downarrow0}$ independent of $a$. +No such uniform assertion is needed for the law conditioned on +$E^c$. +\end{lemma} + +\begin{proof} +First replace each requirement $W=+$ by the requirement that $W$ +be constant on that subpath, and call the resulting edge equalities +$E_0$. If there are $M$ prescribed subpaths, then, conditional on +$B$ and $E_0$, requiring all their component labels to be plus +has probability between $2^{-M}$ and one. The number $M$ is +fixed by the original windows and does not grow as gaps shrink. + +Consider one gap. In the annulus from scale $Ca$ to scale $r$, +the only pins are $B$ pins of the desired window sign. There are +no $E_0$ edges there. The favorable-pin version of +\cref{lem:buffer-circuits}, used in a logarithmic collection of +separated annular slots, therefore gives a double circuit of +that sign surrounding the gap except with probability +\[ + C(a/r)^\beta+o_\delta(1). +\] +This estimate holds before any offset equality has been imposed. +The two adjoining pinned boundary arms leave the neighborhood, +so a surrounding dual circuit crosses each of them. At a crossing +both incident primal sites have the window sign. Consecutive +edges of a double circuit also share a connected chain of sites +of that sign. Thus the circuit joins the two pinned arms through +a connected constant-$B$ chain. The adjacent-pair argument of +\cref{lem:boundary-brackets} forces the same lifted pair on both +arms. Their offsets are therefore equal. + +The gap adjacency graph of the remaining boundary arcs is a +cycle, hence connected. Circuits around all the gaps force every +$t_i$ to agree. A union bound over the fixed number of gaps, +followed by restoration of the $W=+$ labels at cost at most +$2^M$, proves \eqref{eq:offset-high-probability}, with for +example a constant multiple of $(a/r)^\beta$ as the error. +In particular $\mu_{\delta,a}(E)$ is bounded away from zero for +small $a$ and then small $\delta$. + +For the coupling assertion first work with $E_0$ and fill only +one gap. All the new $B$ pins have the same sign. The $B$ +marginals before and after adding them are ordered, by +\cref{lem:spin-fkg}. Use the stopping coupling of \cref{sec:cuts}, based on +\cref{lem:double-cut}, exploring outwards from the gap and +coupling the queried values in this order. In the more adverse +law a double circuit of the added sign occurs before the search +leaves the window neighborhood with failure probability at most +$C(a/r)^\beta+o_\delta(1)$, by the same favorable-pin estimate. +On success it is a common double circuit in the two laws. All +changed constraints are on its gap side; no $E_0$ edge crosses it. +The conditional law on its other side is therefore identical. +Sample that side identically, including its $W$ components. + +Do this successively at the finitely many gaps. Searches stay in +disjoint window neighborhoods. The resulting coupling matches +the joint increments in every test disk and all the $W$ labels +that must subsequently be checked, except with probability +tending to zero with $a$. This last point uses that the label +sites are outside the single-color window neighborhoods. If two +laws can be coupled with error $\varepsilon$ on variables +including an event $L$, and both give $L$ probability at least +$c>0$, their restrictions conditioned on $L$ differ in total +variation by at most $2\varepsilon/c$. Indeed, for any event +$A$ the numerators $\PP(A\cap L)$ differ by at most +$\varepsilon$, as do the two denominators, and division gives +the stated bound. Applying this with $c=2^{-M}$ restores all +the required plus labels. It proves the claimed approximation +between the unconditioned-offset gapped law and the filled law. +Conditioning the former additionally on $E$ changes any marginal +by at most $\mu_{\delta,a}(E^c)$. This proves +\eqref{eq:gap-tv}, after enlarging $\epsilon(a)$. + +It remains to check the uniform moments under equal offsets. +Fix an annular buffer around $K_0$, with fixed inner and outer +radii and positive clearance from $K_0$. Choose its filled +interior compactly contained in $D$ and disjoint from all gap +neighborhoods, so the buffer and its interior contain no pins. +Conditional just on the pins, a +double $B$ cut in this buffer has probability at least a fixed +$c_0>0$. This follows from the local cut estimate and the +bounded cost of the plus labels. By +\eqref{eq:offset-high-probability}, its probability under +additional conditioning on $E$ is at least $c_0/2$ for all +sufficiently small $a$ and then small mesh. Moreover $E$ is +measurable outside this cut: relative heights between the +representatives can be evaluated on paths in the connected +exterior of a disk containing the buffer. Such paths avoid the +unrevealed interior of the cut. The usual outside-in cut +exploration therefore leaves a Gibbs interior with its +bounded-range trace, even after $E$ is imposed. + +All offsets are now common. Anchoring one representative makes +the interval restrictions fixed integer intervals, so rounded +midpoints require no parity classes. Together with the fixed +buffer, these observations verify the hypotheses of +\cref{cor:equal-offset-moments}; it +gives the asserted bounds uniformly as the gaps close. The +filled law has bounded boundary data by +\cref{lem:boundary-brackets}, and +\cref{prop:smearing-moments} gives its bounds. This argument +does not estimate the exceptional unequal-offset law. +\end{proof} + +\begin{proposition}[Bracket identity]\label{prop:bracket-identity} +Fix a window system $\mathcal W$ for a finite grid +$\mathcal L$, and either bracket from +\cref{lem:boundary-brackets}. Let $K_0,\ldots,K_q\Subset D$ +be disks, with $K_0$ at positive distance from every $K_j$, +$j\ge1$, and let $X_\delta,F_\delta$ be as in +\eqref{eq:pins-insertion}. Suppose there are two levels +$\ell_-<\ell_+$ in $\mathcal L$ such that: +\begin{enumerate}[label=\textnormal{(\roman*)}] +\item $K_0$ is strictly between the two levels, and both levels + avoid every spectator disk $K_j$ with positive margin; +\item after opening sufficiently small gaps inside their + corresponding windows, every pin arc and spectator disk + in the middle band belongs to one of the two strictly + separated $u$-projection families in + \eqref{eq:middle-projections}. +\end{enumerate} +Then +\begin{equation}\label{eq:bracket-identity} + \lim_{\delta\downarrow0} + \EE_{\mu^{\pm,\mathcal W}_\delta} + [H_\delta(\Delta\phi)F_\delta]=0. +\end{equation} +In particular it applies to products of bounded continuous +functions of finitely many smooth zero-total tests in each +$K_j$. There is no disjointness requirement between spectator +disks. For this latter class the identity passes to any +subsequential distributional limit of the bracket laws. + +For any fixed bound $q$ on the number of spectator disks these +geometric hypotheses can be arranged locally as follows. Fix +$x\in D$ and $\rho>0$ with $\overline{B(x,\rho)}\subset D$. +Take $K_0$ sufficiently small about $x$, and take at most $q$ +spectator disks of sufficiently small radii, all outside +$B(x,\rho)$. From a sufficiently dense grid of regular levels +one can choose the two levels within a fixed small fraction of +$\rho$ above and below $x$. The choices and smallness bounds +depend on $q$ and $\rho$, not on the number of terms in a later +linear combination of such products. +\end{proposition} + +\begin{proof} +At fixed gaps, \cref{prop:pin-product} gives +$\PP(P)/J_\delta\ge c_a>0$. By +\cref{lem:gap-filling}, for all sufficiently small fixed $a$, +$\PP(E\mid P)\ge1/2$ at small mesh. Division of +\eqref{eq:gapped-equal-offset-identity} by +$\PP(P\cap E)/J_\delta$ therefore gives +\begin{equation}\label{eq:conditional-gapped-identity} + \lim_{\delta\downarrow0} + \EE_{\mu^{=}_{\delta,a}}[X_\delta F_\delta]=0. +\end{equation} +The positive number $c_a$ may tend to zero as $a\downarrow0$; +it is used only with $a$ fixed. + +Let $X^{(T)}=\max(-T,\min(X,T))$ and put +$M=\sup_\delta\|F_\delta\|_\infty$. The total variation bound +in \cref{lem:gap-filling} applies to $X^{(T)}F_\delta$, which +is a bounded function of the joint test increments. The same +lemma, at any $p>1$, bounds the truncation errors under the +equal-offset and filled laws by $C_pM T^{1-p}$. Consequently +\[ + \limsup_{\delta\downarrow0} + \left|\EE_{\mu_{\delta,0}}[X_\delta F_\delta]\right| + \le 2MT\epsilon(a)+C_pM T^{1-p}. +\] +First send $a\downarrow0$ and then $T\to\infty$. This proves +\eqref{eq:bracket-identity}. For bounded continuous functions +of smooth tests, distributional convergence and the same +uniform integrability pass the expectation to a subsequential +limit. + +For completeness, here is a quantitative choice of the local +geometry in the last assertion. Translate $x$ to the origin. +Take $K_0\subset B(0,\rho/1000)$ and seek levels in +$(\rho/40,\rho/20)$ and $(-\rho/20,-\rho/40)$. +Choose spectator radii so small that the total length of their +vertical projections is less than half the length of either +candidate interval; a bound $\rho/(1000(q+1))$ on each radius +suffices. There is then a nonempty open subinterval of each +candidate interval avoiding all spectator disks. Regular values +are dense, so a sufficiently dense regular grid supplies both +levels, with positive margins. + +Every boundary point in the resulting middle band is outside +$B(0,\rho)$. The same is true of every middle spectator disk +by assumption. Since $|y|<\rho/20$ there, each such point has +$|x|>\sqrt{1-1/400}\,\rho$. Its $u$-projection +$(\sqrt3/2)x+y/2$ consequently has magnitude greater than +$\rho/2$, with the sign of $x$. A connected middle arc or +disk cannot change that sign. Thus +\eqref{eq:middle-projections} holds with ample margin, whereas +all projections of $K_0$ have magnitude at most $\rho/1000$. +Small gaps and lattice approximation errors preserve the +strict inequalities. This proves the geometric assertion. +\end{proof} + +The order of limits is now explicit. The identity for a fixed +filled window system is proved by first sending the mesh to +zero at fixed positive gaps and then shrinking those gaps. +In the boundary comparison below, one subsequently shrinks +the windows for each fixed finite grid, and only then refines +the grid. The bracket order alone does not identify its law +with the true boundary law; the next section supplies the +boundary information needed for that step. diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/08-boundary.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/08-boundary.tex new file mode 100644 index 0000000000000000000000000000000000000000..f93f17ffd30214a80b5d5237fb8edf523eac2dbf --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/08-boundary.tex @@ -0,0 +1,647 @@ +\section{A height arch at a constant boundary arc}\label{sec:boundary} + +We now recover the boundary information lost in the single-color windows. +Near an arc with prescribed height $k$, we construct a path of height at +least $k$ that joins the boundary on both sides of a small exceptional +piece. Closing this path through the exterior separates that piece from +the rest of the domain. The estimate uses the actual conditional Gibbs +law and will also apply to the new boundary traces exposed during this +separation. In \cref{sec:limits}, lower and upper versions identify both +the boundary mean and its mixed moments with distant observations. + +\paragraph{Regions, fixed sites, and artificial exterior.} +All graphs in this section are embedded in the triangular lattice of mesh +$\delta$. A \emph{skeleton} is a finite connected union of lattice edges. +The free sites of a region lie in bounded faces of its skeleton. Every +neighbor of a free site is either free or a fixed skeleton site; the latter +sites are its \emph{usable boundary}. Conditional on the values $\eta$ at +the usable boundary, the height is uniform among the admissible integer +Lipschitz extensions. We always assume that this set is nonempty. +Only usable boundary values enter this specification. + +Initially the skeleton $S_0$ is a polygon boundary. We also allow it to be +the union of that boundary and finitely many simple lattice circuits meeting +it. The additional circuits cut off small boundary patches; the chosen +remaining free regions are on the other side. Vertices in the removed +patches, and vertices exterior to the original polygon, will be declared +open artificially. Usable boundary sites are never declared open +artificially. Thus, at threshold $a$, the open sites are +\begin{equation}\label{eq:boundary-open-sites} + \{v\text{ free or usable}:H(v)\ge a\} + \ \cup\ \{v\text{ outside the region and its usable boundary}\}. +\end{equation} +When an additional separator is exposed, its usable sites carry their +actual exposed heights. In particular, this convention does not discard a +new boundary condition. + +Write $Q_r=p+[-r,r]^2$ in tangent and inward-normal coordinates at a smooth +boundary point $p$. The interior is on the positive normal side. +An open site circuit surrounding $Q_r$ is called an \emph{arch separator}: +its part in the domain joins the clean boundary on the two sides, and its +remaining part can run through the artificial exterior. It separates the +free sites near $p$ from remote boundary data. + +\begin{theorem}[Constant-arc arch estimate]\label{thm:boundary-arches} +There are constants $M>1$, $c,C>0$, and a positive geometric tolerance with +the following property. Fix a positive integer $N$ and scales +\begin{equation}\label{eq:arch-scales} + 16r<\ell_1<\cdots<\ell_N0$ such that, conditional +on all first-color spins outside a block buffer, a pair of such double +circuits in slightly narrower versions of \eqref{eq:preliminary-strips} +has probability at least $a$. Choose $M$ so that the block buffers are +disjoint. Successive revelation of these buffers gives the same lower +bound conditional on the preceding outcomes. Indeed, for $\lambda>0$ and +the success indicators $I_i$, +\[ + \EE\exp\!\left(-\lambda\sum_{i=1}^N I_i\right) + \le (1-a+ae^{-\lambda})^N. +\] +It follows that $\sum I_i\ge aN/2$ except with probability $C e^{-cN}$. +Requiring at most four complementary labels multiplies this failure bound +by at most $2^4$. + +Each double circuit meets the high part of the skeleton: the original +boundary has a segment from the inner box to the exterior of the outer +box. The adjacent faces along the double circuit all have the same first +color and, by continuation from that intersection, their lifts lie in the +anchored pair $[k-1,k]$. The corresponding closed primal walk stays within +a bounded number of lattice spacings of the dual circuit and has winding +number one about the inner box. It contains a simple surrounding site +circuit. This produces the preliminary circuits in the synthetic height. +The event that at least a given number of pairs exist is increasing in the +height, so \eqref{eq:synthetic-height-domination} transfers its probability +to the actual law. +\end{proof} + +We now select the preliminary pairs by exploring the actual height law. +The synthetic configuration used to bound their abundance plays no part +in this selection. + +\begin{lemma}[Extremal-circuit stopping]\label{lem:extremal-stopping} +In a deterministic annular strip, good surrounding simple site circuits +have inner and outer envelopes. The innermost such circuit can be selected +by revealing the strip from its inner side; the outermost can be selected +from its outer side. In each case the selection and the revealed values +are measurable with respect to the sites on the circuit and on the tested +side. No height on the untested side is conditioned by the selection. + +In particular, in each successful block of +\cref{lem:preliminary-circuits}, select an innermost circuit $C_i^-$ in the +inner strip and an outermost circuit $C_i^+$ in the outer strip. Conditional +on these selections and the full configuration outside the intervening free +regions, those regions have independent Gibbs interiors with their +revealed boundary values. +\end{lemma} + +\begin{proof} +If two surrounding simple cycles have at least two common vertices, their +union is two-vertex-connected. After deleting any one vertex, the +remaining part of each cycle is connected and the two parts still share a +vertex. Its complementary face containing the inner box and its unbounded +face therefore have simple cycle boundaries. These boundaries are the +inner and outer envelopes. They use only good vertices of the original +cycles and stay in the same strip. If there is only one common vertex, +the two cycles cannot cross just once. Since both enclose the inner box, +their interiors are nested. Disjoint surrounding cycles are nested as +well. Iterating the envelope operation in the finite strip gives the +extremal circuit, regarded without an orientation. + +For a specified good circuit $C$, whether it is the inner extremal circuit +can be decided from its closed inner side in the strip. A competing +circuit that improved it while partly leaving that side would have an +inner envelope with $C$ that is itself a better good circuit entirely on +that side. Thus the absence of a better circuit has no dependence on +unseen heights outside $C$. The outer statement is identical with the +directions reversed. Equivalently, these statements specify stopping +sigma-fields: on the event that the selected circuit is $C$, the recorded +heights and the selection event are measurable using the deterministic set +consisting of $C$ and its tested side. One may reveal that entire set, +including bounded pockets. Failure to find a circuit requires only the +strip itself. + +For the selected pairs, let $V_i$ be the actual free sites between $C_i^-$ +and $C_i^+$. Reveal the unsuccessful strips, the tested sides of successful +strips, the selected circuits, and then every site outside $\bigcup_i V_i$. +Call the resulting sigma-field $\mathcal G$. On every realization of the +selected sets, the preceding measurability statement says that the event +specifying these sets places no condition on the heights in $\bigcup_i V_i$ +beyond their recorded boundary values. The finite Gibbs specification +therefore applies. Distinct $V_i$ have no interacting edge after their +separators are fixed, giving conditional independence. Touches with the +original boundary may divide $V_i$ into several bounded faces; the same +argument applies to their union. +\end{proof} + +The selected circuits have height at least $k-1$ on their usable sites. +Every usable boundary value of a retained middle problem is consequently at +least $k-2$. The full strip +\begin{equation}\label{eq:untouched-middle} + Q_{5\ell_i}\setminus Q_{\ell_i} +\end{equation} +between them was not searched. Its original usable boundary, including any +tiny replacements, still has the clean lower bound $k$. Moreover, each +selected circuit meets the base polygon boundary, so +$S=S_0\cup C_i^-\cup C_i^+$ is connected. These facts hold on every +realization of $\mathcal G$ and will be the only boundary information used +to upgrade the block. + +\subsection{An attachment from the prescribed boundary} + +\begin{lemma}[Boundary attachment]\label{lem:boundary-attachment} +Consider a retained middle problem at scale $\ell$. Near either of the +locations $(-2\ell,0)$ and $(2\ell,0)$, there are fixed constants +$00$ a path of sites at height at least $k$ enters from the clean +boundary band and reaches depth $d$ inside the box of half-width $W_0$. +Its boundary end is connected through good fixed or artificial sites to +the exterior below, within a slight enlargement of the box. The bound is +uniform in the exposed boundary values of the middle problem. +\end{lemma} + +\begin{proof} +Translate the attachment location to the origin. Take $W_0$ to be a small +fixed fraction of $\ell$, and later take $d$ to be a smaller fixed fraction +of $W_0$. The two preliminary circuits are outside this box. The +unobstructed part above the boundary tolerance belongs to one bounded face +of $S$; in particular, a site $x$ close to $(0,3d)$ is free in that face. + +\emph{Synthetic boundary and its mean.} +On $S$, prescribe the high interval $[k-1,k]$ on a base subarc near the +origin, of half-width approximately $W_0/4$, and the low interval +$[k-3,k-2]$ elsewhere. Choose its endpoints so that the high part covers +horizontal width $W_0/8$, lies within horizontal half-width $W_0/3$, and +avoids all tiny replacement attachments. A replacement attached within +the high portion receives the high prescription throughout. There are +only two transition labels. This construction is feasible for all +sufficiently small replacement diameters and gives the synthetic lower +comparison $K$ in \eqref{eq:synthetic-height-domination}. + +Let $A$ be the event that a primal path of heights at least $k$ joins this +high patch to depth $d$ inside the attachment box. This is an increasing +height event, so it is enough to give it positive probability in the +synthetic law. We shall first use the mean at $x$ to detect which side of +the boundary-entering contours contains $x$, and then show that the high +side forces $A$. + +Between radii of order $d$ and a small fixed fraction of $W_0$, annular +buffers centered on the projected boundary contain only favorable $t=s$ +pins. The annular stack estimate gives, except with probability +\begin{equation}\label{eq:attachment-cut-error} + e(d/W_0)\longrightarrow0, +\end{equation} +a double $t=s$ circuit surrounding $x$ and meeting the high patch. The +same bound, multiplied by a fixed factor, holds after the two complementary +labels are required. Choose such a cut using only the first color. Its +inner face chain belongs to the anchored pair $[k-1,k]$, and both transition +labels lie outside it. No component of $t$-changing edges crosses the +double cut. Thus the complementary labels in its interior, including its +inner cut layer, are all free. Flipping these labels preserves their +conditional law. It reverses every interior height increment and swaps +the two values of the anchored cut pair, hence sends +$K$ to $2k-1-K$ there. The conditional mean at $x$ is therefore $k-1/2$. + +We also need a bound on the mean on failure, uniform in the lattice size. +The component potentials in the proof of \cref{lem:component-switch} +give this bound. On each component of $t$-changing edges, $dt$ extended +by zero has a potential with two values differing by two. If $t=B$, the +identity +\[ + d(K+BW/2)=W\,dB +\] +expresses the height difference from the transition anchor to $x$ as an +endpoint term of absolute value at most one, plus the component labels +times their potential differences. Each potential difference has absolute +value at most two. If $t=W$, use $d(K-BW/2)=-B\,dW$ instead. +The unprescribed labels have conditional mean zero, and at most two +components have prescribed labels. Since the anchor has value $k-2$ or +$k-1$, this proves +\begin{equation}\label{eq:attachment-failure-mean} + \bigl|\EE[K(x)\mid t,\text{transition labels}]-k\bigr|\le C_1 +\end{equation} +for every first-color configuration, with an absolute constant $C_1$. +Combining the symmetry on success with this bound gives +\begin{equation}\label{eq:attachment-synthetic-mean} + \EE K(x)=k-\tfrac12+O(e(d/W_0)). +\end{equation} +All these arguments take place in a finite free volume around the +construction, so no infinite-volume height or absolute anchor is required. + +\emph{Low lateral barriers.} +Around the boundary locations with horizontal offsets $\pm2W_0/3$, use +annuli with inner radius several times $d$ and outer radius less than +$W_0/8$. All local first-color pins are now favorable to $t=-s$. With +failure probability again tending to zero with $d/W_0$, each side contains +a double $t=-s$ circuit meeting the low skeleton. Its face paths have the +anchored low values and include a path from the low skeleton to above +depth $3d$, inside the horizontal band of width $W_0/4$ about that side +location. Write $L$ for the event that both such lateral barriers exist. +They have height at most $k-2$ in the synthetic problem. +The estimates survive the same two complementary labels. We may increase +the lower end of the annular range by a fixed factor when a little more +vertical clearance is needed. + +For the planar separation below, continue each barrier along its local low +skeleton arc and then through the exterior to a line below the boundary +band. Uniform parametric approximation keeps this continuation in a +slightly enlarged lateral strip; a tiny replacement attaches to the same +local base arc. The skeleton portion is outside the high patch and is +low throughout. The exterior portion is only a geometric continuation, +which a contour lying in the face cannot cross. Thus the two barriers +separate the high patch laterally all the way through the boundary band. + +\emph{The mean detects a side of the open contours.} +Condition on the synthetic trace on the whole skeleton $S$. In its +bounded face containing $x$, follow every dual level path at threshold +$k-1/2$ that enters through a skeleton edge. At each crossed edge, the +adjacent heights are exactly $k-1,k$. On entering a triangle, those two +values force its third value to be one of $k-1,k$, and hence determine the +next crossed edge. The exploration only reveals the adjacent values of +the paths being followed. Exhaust all boundary crossings in this way, +including crossings on either side of a skeleton edge bordering a slit +in the face. + +Conditional on these open paths and their lips, their occurrence imposes +only the indicated fixed vertex values. Any admissible completion with +those values has the same open paths, by the degree-two rule and exhaustion +of the boundary crossings. Unseen closed contours remain unrestricted. +The remaining free components therefore have their Gibbs laws. + +Cut the face along the exposed open paths. Their lips have known sides: +the $k$ lip is high and the $k-1$ lip is low. Together with the threshold +signs of the skeleton trace, these sides label every resulting geometric +cell high or low. Here is why these labels are consistent even when the +skeleton boundary has slits. A closed threshold contour in this face +cannot enclose a skeleton site, since the connected skeleton continues +outside the contour and cannot cross it. It cannot enclose part of an +exposed open path either: that path continues to the skeleton and contours +do not intersect. In the full threshold-sign picture, one may therefore +erase the closed contours, filling each outermost enclosed region with +its exterior sign, without changing any recorded skeleton or lip sign. +The remaining sign is constant in each cell cut out by the open paths. +This proves consistency; it is a deterministic explanation, not an +additional revelation or conditioning of the closed contours. + +The free primal Gibbs components left by the exploration lie in these +geometric cells; removing the revealed lip vertices may divide a cell +further. In a low cell every adjacent fixed value is at most $k-1$. +In a high cell every adjacent fixed value is at most $k$: the high +skeleton values and the high lips are exactly $k$, and all other fixed +values satisfy the same ceiling. Let $U$ be the event that $x$ belongs +to a high cell, including the case that it lies on a revealed high lip. +A revealed low lip belongs to the low case. + +Comparison with a constant ceiling, including the deterministic case when +$x$ lies on a revealed lip, yields +\begin{equation}\label{eq:attachment-cell-mean} + \EE K(x)\le k-1+\PP(U). +\end{equation} +Together with \eqref{eq:attachment-synthetic-mean}, this gives +$\PP(U)\ge1/2-O(e(d/W_0))$. A closed high island around $x$ does not +suffice for $U$. Such islands remain inside their unrestricted Gibbs +cells, and comparison controls the cell's mean rather than each of its +height values. + +\emph{The correct boundary lip reaches the box.} +The high lip of every exposed open path is a connected primal chain at +height $k$. Its endpoints are skeleton sites at height $k$, so they lie +on the designated high patch, including any tiny replacements carrying +that patch's prescription. No endpoint lies on a preliminary circuit or +on another low part of the skeleton. + +We claim that $U\cap L\subseteq A$. Suppose instead that $L$ occurs but +$A$ does not. Follow a high lip from either of its endpoints on the high +patch. It cannot cross a low lateral barrier: these are primal paths of +height at most $k-2$, whereas the lip has height $k$. It cannot leave +through the exterior side of the face. To pass above a barrier it would +first have to reach depth $d$, already giving $A$. Consequently every +exposed open path stays between the two barriers and below depth $d$. +This statement concerns all the open paths, since every one of their high +lips starts on the designated high patch. + +The site $x$ is at depth $3d$. Staying above depth $2d$, it can be +joined to one lateral barrier without crossing any exposed open contour. +Following that barrier down to its low skeleton endpoint also crosses +none: all its sites have height at most $k-2$. The resulting route puts +$x$ in the cell with the low label inherited from that endpoint. This +contradicts $U$. The boundary and the tiny replacements stay in a much +shallower band and do not obstruct the deep portion of this route; the +barrier itself supplies the continuation through that band. Fixed margins +between depths $d$ and $3d$ absorb lattice rounding. + +Since $\PP(L^c)=O(e(d/W_0))$, the inclusion proves +\[ + \PP(A)\ge\PP(U)-\PP(L^c)\ge\tfrac12-O(e(d/W_0)). +\] +The mean calculation was not conditioned on the lateral barriers. +Choose $d/W_0$ once so that this bound is at least, say, $1/4$. +The event $A$ asks only for a superlevel path, even though the synthetic +construction produced an exact-height-$k$ lip. It is therefore increasing, +and \eqref{eq:synthetic-height-domination} gives the same positive lower +bound for the actual height. + +Finally, in the actual comparison every usable skeleton site in the local +box is at least $k$; the other skeleton sites there are artificial. A tiny +replacement is attached to the local base arc, and that arc, with its +parametric slack at the box margins, is connected through open sites to +the exterior below. For example a path from below stopped at its first +encounter with the base boundary reaches such an open site. Thus the +attachment has the exterior continuation claimed in the lemma. +\end{proof} + +\subsection{Joining the attachments and amplifying across scales} + +\begin{lemma}[Upgrade in a retained middle region]\label{lem:arch-upgrade} +For every successful preliminary block, conditional on $\mathcal G$ from +\cref{lem:extremal-stopping}, the probability of an arch separator at +threshold $k$ in its untouched middle is at least an absolute constant +$a_1>0$. +\end{lemma} + +\begin{proof} +Fix the realized middle problem. Its actual boundary has the lower bounds +recorded after \eqref{eq:untouched-middle}. The two attachments of +\cref{lem:boundary-attachment} have uniform positive probabilities, and +their events are increasing in the actual height. + +We first record a bulk path estimate under this same conditional law. +For a box with a fixed relative annular buffer inside the free middle, +compare from below with constant height $k-2$ on its bounding skeleton. +The latter comparison may be realized by fixing both spins of that height +on $S$. Connectedness of $S$ fixes a common flat lift on every relevant +bounded face. Its height contours are closed loops: a contour cannot +cross the flat skeleton or enclose just part of a connected skeleton. +Given the unoriented loops, all their jump signs are independent fair signs. +For use of the first-spin circuit estimates, first enforce constancy of +the second spin along $S$. This is an $E_0$ constraint outside the bulk +buffers. Since $S$ is connected, specifying its second-spin value costs +one fair component label and does not change the first-spin marginal. + +Apply \cref{lem:buffer-circuits} in a fixed number of thinner concentric +buffers, requesting alternating first-spin signs on five double circuits. +All these buffers are inside the free region. Successive conditional +estimates give a positive probability, uniform in mesh and exposed actual +heights, for this event in the flat comparison. Between each successive +pair there is a first-spin wall loop surrounding the inner box. Hence +there are at least four nested height loops in the allocated annulus. + +Retain only the event that there are at least four enclosing unoriented +loops in the allocated annulus, forgetting the first-spin event used to +lower-bound its probability. This event and the choice of four consecutive +enclosing loops depend only on the full unoriented geometry. Conditional +on that geometry, the height just outside the first chosen loop is $k-2$ +plus a sum of other fair loop signs. It is therefore symmetric about +$k-2$ and independent of the four chosen signs. With probability at least +$2^{-5}$ it is at least $k-2$ and all four signs are positive. The inner +face path of the fourth loop is then at least $k$. Its closed primal walk +has winding number one and contains a surrounding circuit, with only +bounded mesh displacement. Thus a fixed bulk annulus has a uniformly +positive probability of a circuit at height at least $k$. Height order +transfers this to the actual middle law. + +These bulk circuits give paths along any fixed polygonal tube with positive +width and clearance. To see the deterministic gluing, place small annuli +along the tube so that consecutive inner disks overlap and each protrudes +beyond the other annulus's outer disk. Two surrounding circuits cannot +then be disjoint or nested, so they intersect. A finite string supplies +the desired connected crossing. Positive association for heights bounds +the probability of the simultaneous increasing circuit events below by the +product of their positive lower bounds. + +Use such a tube to cross each attachment box horizontally near depth +$d/2$, extending a little beyond its sides. Any rising attachment from +the boundary band to depth $d$ intersects this crossbar. Join the left +and right crossbars by tubes going upward near horizontal locations +$\pm2\ell$, across at depth $2\ell$, and downward on the right. Tube +widths are much smaller than $d$, and all their bulk boxes have clearance +from the skeleton. The whole construction lies between $Q_\ell$ and +$\partial Q_{5\ell}$; see \cref{fig:boundary-arches}. + +Apply height positive association in the actual conditional Gibbs problem +to the two attachment events and the finite collection of bulk circuit +events. This gives a fixed lower bound $a_1>0$ for their intersection. +The exterior continuations of the attachments can be joined below the +boundary, around the bottom of $Q_\ell$, through artificial sites and +good local boundary sites. The resulting closed open walk follows a +rectangle around $Q_\ell$ and has winding number one, so it contains an +open surrounding simple cycle. The tubes avoid the preliminary circuits; +in particular, the construction has not declared any of their possibly +sub-$k$ usable values artificial. Every artificial site used here was +already outside the original region or in a removed boundary patch, +which proves the upgrade. +\end{proof} + +\begin{figure}[tb] + \centering + \input{figures/boundary-arches} + \caption{A retained block in tangent coordinates. The four labeled squares + determine the two searched strips; the attachment boxes and path widths are + enlarged for legibility. The two shaded strips contain the preliminary separators. + Their facing sides leave the middle Gibbs region unsearched. The blue + route uses two boundary attachments, horizontal crossbars, and bulk + paths at positive clearance in the actual height law. The right detail + shows the synthetic low-barrier argument used to prove an attachment; + its barriers are not imposed in the actual law. The dashed lower route + uses the artificial exterior. All displayed paths are schematic corridors, + not a prescribed realization of the random separator.} + \label{fig:boundary-arches} +\end{figure} + +\begin{proof}[Proof of \cref{thm:boundary-arches}] +Let $Z$ be the number of successful preliminary blocks. +\Cref{lem:preliminary-circuits} gives +$\PP(Z1$. For $K\Subset D$, $p<\infty$, +and tests supported in $K$, +\begin{equation} + \sup_\delta\norm{H_\delta(f)}_{L^p} + \le C_{K,p}\norm{f}_{\infty}. + \label{eq:local-test-moments} +\end{equation} +The constants are uniform over these bracket laws. Along convergence in +law, every finite joint test moment converges. These assertions hold +also for any fixed finite collection of fields in a coupling. +\end{proposition} + +\begin{proof} +Cover $K$ by finitely many balls whose radii are a sufficiently small +fixed fraction of their distance from $\partial D$, and use a partition +of unity. The smearing estimate of \cref{prop:smearing-moments}, applied +to the positive and negative parts on each ball, gives +\eqref{eq:local-test-moments}. For brackets, condition first on the +boundary trace. Its uniform bound gives the same constants before and +after averaging over that trace. + +For completeness, place a cutoff $\chi\in C_c^\infty(D)$ in a fixed +square, regarded as a flat torus, and let $e_n$, $n\in\Z^2$, be its +normalized Fourier basis. Since $\norm{\chi e_n}_\infty$ is bounded +independently of $n$, for $s>1$ we have +\begin{equation} + \sup_\delta\EE\norm{\chi H_\delta}_{H^{-s}}^2 + =\sup_\delta\sum_{n\in\Z^2}(1+|n|^2)^{-s} + \EE|H_\delta(\chi\overline{e_n})|^2<\infty. + \label{eq:sobolev-bound} +\end{equation} +For any $p\ge2$, Minkowski's inequality applied to the sum defining +the squared norm gives its $L^{p/2}$ bound as well, using +\eqref{eq:local-test-moments} at order $p$. If $10$. +It is uniformly integrable. Convergence in law of the test vector +therefore implies convergence of its product expectation. The same +argument applies to mixed products from a finite coupling. The +moment inequalities themselves pass to every limit by truncation. +\end{proof} + +Fix once and for all a nonnegative radial function +$\rho\in C_c^\infty(B(0,1))$ with integral one, and set +\[ + \rho_{x,r}(z)=r^{-2}\rho((z-x)/r),\qquad + d(x)=\dist(x,\partial D). +\] +Choose a sufficiently small fixed $\kappa>0$. The smearing estimate, +first with mesh tending to zero at fixed $x$, also implies +\begin{equation} + \sup_{x\in D}\norm{H(\rho_{x,\kappa d(x)})}_{L^p}\le C_p + \label{eq:depth-moment-bound} +\end{equation} +for any subsequential true or bracket limit. Here and below a harmless +change of the constant covers centers in a fixed compact part of $D$. +In particular this bound is valid when the center approaches a marked +point; it requires only bounded boundary data, not a constant arc. + +\subsection{The ordered limits have the correct boundary mean} + +We specify the limits of brackets before using their identities. +Choose increasing finite grids $\mathcal G_n$ whose union is dense +among the transverse regular horizontal levels of $\partial D$ and +which miss the two marks. Each such level has finitely many boundary +intersections. For fixed $n$, choose disjoint windows at these +intersections, avoiding the marks, and denote their maximum size by +$\eta$. At each mesh, height comparison gives a coupling +\begin{equation} + H_{\delta,n,\eta}^- + \le H_\delta\le H_{\delta,n,\eta}^+. + \label{eq:ordered-brackets} +\end{equation} +For example, couple each ordered pair and disintegrate over the true +field to join the couplings. Affine interpolation preserves the order. + +Start with an arbitrary convergent subsequence of the true laws, with +limit denoted by $H$. For each fixed $n,\eta$ take further joint +subsequences in \eqref{eq:ordered-brackets}; then let $\eta$ decrease +to zero at fixed $n$; finally let $n$ increase. Tightness permits all +these extractions. At every stage the true marginal is the originally +chosen law of $H$. The order persists when tested against nonnegative +smooth functions, because that is a closed condition under +distributional convergence. The use of a countable determining family +of nonnegative tests makes the order simultaneous almost surely. +Write the final triple as $(H^-,H,H^+)$. + +Identities from \cref{prop:bracket-identity} pass through these limits. +For bounded continuous functions of local increment tests this follows +from convergence in law and the moment bound for the Laplace +insertion. Every admissible finite selection of grid levels belongs +to all sufficiently late grids. Taking the other insertion to be one +shows that the distributional means $m^-$ and $m^+$ of the final +brackets are harmonic locally throughout $D$. Indeed any interior +point admits two regular levels on opposite sides of a sufficiently +small testing disk. Distributional harmonic functions are smooth, +so these means are ordinary harmonic functions. Comparison with +constant-boundary laws, whose means equal the boundary constant by +height reflection, gives +\begin{equation} + -2\le m^-\le m^+\le1. + \label{eq:bounded-bracket-means} +\end{equation} + +\begin{proposition}[Boundary trace and mixed boundary moments] +\label{prop:boundary-trace} +Both limiting bracket means are the harmonic extension $m$ of $g$. +Consequently $H^-=H=H^+$ almost surely in the ordered coupling, and +$\EE H=m$. + +Let $p$ be on an open boundary arc on which $g=k$, where $k$ is +$0$ or $-1$, and let $x\to p$ from within $D$. For the true limiting +field put $Y_x=H(\rho_{x,\kappa d(x)})$. If $F$ is a product of a fixed +finite number of height averages supported away from a neighborhood +of $p$, then +\begin{equation} + \EE[(Y_x-k)F]\longrightarrow0. + \label{eq:mixed-boundary-trace} +\end{equation} +The same assertion holds when those averages approach finitely many +other, distinct, nonmarked boundary points, with their radii a fixed +small fraction of their depths. In that assertion the points and their +finite number are fixed before the depths tend to zero. +\end{proposition} + +\begin{proof} +We first identify the bracket means. Fix a point $p$ on an open arc +of value $k$, a center $x$ near $p$, and its testing ball of radius +$\kappa d(x)$. Choose finitely many final arch scales surrounding +this ball in a small clean neighborhood of the nearest boundary +projection of $x$. Work initially at finite mesh with a fixed grid +and windows sufficiently small for the construction below, and write +$Y_{\delta,x}$ for the chosen bracket's unit average in the ball. +Two searches will isolate the ball from the exceptional window values +and then from the remote boundary data. + +For each window choose a clean censor neighborhood on its constant +arc, of value $k_i$. Choose these neighborhoods disjoint, away from +the marks, small relative to the final arch scales, and small enough +to miss the testing ball. Conditional +on the original bracket trace, all its values are at least $k_i-2$, +and those in this censor neighborhood outside its window are at least +$k_i$. Enclose the entire discrete window and its adjacent sites in +the inner comparison box, with a positive margin before sending the +mesh to zero. Theorem~\ref{thm:boundary-arches} supplies an arch at +level $k_i$ surrounding this box. For a fixed grid there are only +finitely many windows; shrinking them relative to their censor +neighborhoods makes the total failure probability as small as desired. + +On success choose the innermost arch by exploring from the window +side, as in \cref{lem:extremal-stopping}. Discard the patch between +the window and this arch, and retain the side away from the window. +This retained side contains the testing ball and has not been +examined by the search. Conditional on the revealed patches and +separator traces, its free heights have their Gibbs law. No original +exceptional vertex is adjacent to a retained free site. The new usable +separator sites carry their actual heights, which are at least $k_i$; +the global lower bounds are also preserved. Thus the first searches +replace the windows by small boundary pieces with the required +one-sided data. They do not condition on the preliminary revelations +used only to prove the arch probability estimate. + +Apply \cref{cor:boundary-robustness} at the chosen final scales in +the retained domain. The censor patches are small enough for its +replacement hypothesis. In the chosen clean neighborhood every usable +original or replacement boundary site has height at least $k$. +With high probability there is an arch at level $k$ separating the +testing ball from the remote boundary. Choose the outermost such +arch by searching from the remote side. This time the unexamined +region is the side containing the testing ball, between the final +arch and the clean boundary arc. Its usable boundary consists of +sites on the arch and any original or censor pieces it contains, +all at height at least $k$. Height comparison with constant data +therefore gives conditional mean at least $k$ for $Y_{\delta,x}$. + +Let $E_\delta$ denote success of both stages, and expose only the +discarded patches, the remote side of the final arch, and their +usable traces. On $E_\delta$ this information determines the event +and leaves the testing region Gibbs. For any $q>1$ the preceding +conditional comparison gives +\begin{equation} + \EE(Y_{\delta,x}-k)\ge + -\norm{Y_{\delta,x}-k}_{L^q} + \PP(E_\delta^c)^{1-1/q}. + \label{eq:boundary-mean-error} +\end{equation} +The norm is bounded by the unconditional comparable-depth smearing +estimate, whose limit form is \eqref{eq:depth-moment-bound}. No +moment estimate after conditioning on censor success is needed. + +For the upper bound start afresh from the original bracket trace. +Its global values are at most $k_i+2$, and its clean values in the +$i$th censor neighborhood are at most $k_i$. Use decreasing censor +arches and then a decreasing final arch in the same two stopping +directions. The testing region now has usable boundary at most $k$, +giving the matching upper estimate, with the same H\"older bound on +the failure contribution. This separate +construction is necessary because the lower censor arches carry no +upper bound on their revealed heights. + +We make explicit the uniformity that permits the grid limit. Given an +error tolerance, first choose finitely many final arch blocks in a +sufficiently straight part of the limiting smooth arc. They are +available for every sufficiently shallow testing center. For each +fixed grid, choose the outer censor sizes so small that the robust +comparison applies in these blocks; the synthetic interval endpoints +in that comparison avoid all the tiny replacements. By +\cref{cor:boundary-robustness}, the final block estimates do not incur +a factor for the number of replacements. Next decrease the window +sizes so that all censor searches succeed with the desired total +error, and before that take the mesh and boundary approximation +errors to zero. The resulting bound on the mean depends on the final +blocks and the error tolerance, and not on the grid. It thus survives +window limits followed by grid refinement. This is exactly the order +of limits used to define $(H^-,H,H^+)$. Nearest projections and the +uniform smooth-arc estimates allow tangential as well as normal +approaches to $p$. + +Since each bracket mean is harmonic, radial averaging recovers its +value at $x$. The two bounds just proved show that its boundary trace +is $k$ on the open arc. Together with +\eqref{eq:bounded-bracket-means}, bounded harmonic uniqueness gives +$m^-=m^+=m$. The two marked points do not change this uniqueness: +for a bounded harmonic function with zero trace elsewhere, compare +its absolute value with its supremum times the harmonic measure of +arbitrarily small boundary neighborhoods of the marks. At any fixed +interior point these harmonic measures tend to zero, since a smooth +domain has a Poisson kernel and single points have zero arclength. + +The order now identifies the fields, rather than merely their means. +For every nonnegative test $f$, +$H^+(f)-H^-(f)\ge0$ and its expectation is zero. Thus it vanishes +almost surely. Apply this to a countable dense family of nonnegative +tests and use continuity of distributions. The ordered fields agree +as distributions almost surely, proving the first assertion and +transferring the bracket identities to $H$. + +For the mixed assertion no censoring is needed in the true law. +Choose deterministic outer arch neighborhoods that do not meet the +supports of the other observations. First suppose $F\ge0$ is +measurable outside those neighborhoods. On the lower good event +$E_-$, choose the outermost lower arch from the exterior. The event, +the selected trace, and $F$ are measurable in the revealed exterior; +the Gibbs property gives +\[ + \EE[(Y_x-k)F;E_-]\ge0. +\] +The upper search separately gives an event $E_+$ on which the reverse +inequality holds. These two searches need not share a sigma-field. +For $q>1$, their failure contributions satisfy +\begin{equation} + -\norm{(Y_x-k)F}_{L^q}\PP(E_-^c)^{1-1/q} + \le \EE[(Y_x-k)F] + \le \norm{(Y_x-k)F}_{L^q}\PP(E_+^c)^{1-1/q}. + \label{eq:weighted-arch-bounds} +\end{equation} +All norms here are bounded by H\"older and the smearing estimates. +For signed $F$, apply the bounds to its positive and negative parts; +they are exterior measurable and have the same moment control. +One uses the actual exterior stopping search at this step, without +retaining any of the preliminary revelations used to prove the arch +probability estimate. The result follows first at finite mesh, then +for limit moments by \cref{prop:tightness} and truncation. + +When other observations approach different boundary points, fix that +finite set first and take the outer neighborhoods smaller than their +mutual distances. The observations remain exterior measurable as +their depths decrease. Estimate \eqref{eq:depth-moment-bound} bounds +their moments uniformly, so the same proof gives +\eqref{eq:mixed-boundary-trace} in this joint limiting regime. +\end{proof} + +\begin{lemma}[Deterministic boundary reference averages] +\label{lem:boundary-references} +Fix a compact subarc of one open constant boundary arc, with value +$k$. There exist finite averages of comparable-depth unit smearings +near that subarc which converge to $k$ in every finite $L^p$ of the +true limiting field. More precisely, choose $N$ distinct points +$p_1,\ldots,p_N$ in the subarc, let $x_i(t)$ approach $p_i$ normally +at depth $t$, and put +\[ + A_{N,t}=\frac1N\sum_{i=1}^N + H(\rho_{x_i(t),\kappa d(x_i(t))}). +\] +For all sufficiently small $t$ the balls are disjoint, and +\begin{equation} + \limsup_{t\downarrow0}\EE|A_{N,t}-k|^2\le\frac C N, + \qquad + \sup_{N,t}\norm{A_{N,t}-k}_{L^q}\le C_q. + \label{eq:boundary-average-variance} +\end{equation} +The second supremum is over admissible small depths. Consequently +$\lim_{N\to\infty}\limsup_{t\downarrow0} +\norm{A_{N,t}-k}_{L^p}=0$ for every finite $p$. +\end{lemma} + +\begin{proof} +Write $Y_i(t)$ for the $i$th summand. Uniform comparable-depth +moments give $\EE|Y_i(t)-k|^2\le C$. For $i\ne l$, apply +\eqref{eq:mixed-boundary-trace} with exterior factor $Y_l(t)-k$: +\[ + \EE[(Y_i(t)-k)(Y_l(t)-k)]\longrightarrow0. +\] +Expanding the square, taking the depth limit at fixed $N$, and then +using the diagonal bound proves the first estimate in +\eqref{eq:boundary-average-variance}. Minkowski's inequality gives +the second from \eqref{eq:depth-moment-bound}, uniformly in $N$. +For $p\le2$ use the $L^2$ bound; for $p>2$ interpolate $L^2$ with +an $L^q$ bound for any $q>p$. A diagonal choice of finite depths as +$N$ increases gives the claimed reference sequence. In particular, +we have not asserted that one comparable-depth average, or a fixed +finite collection of them, becomes deterministic. +\end{proof} + +\subsection{Absolute moments and the absence of diagonal terms} + +Define the distributional moment $T_j$ by +\begin{equation} + \langle T_j,f_1\otimes\cdots\otimes f_j\rangle + =\EE\prod_{i=1}^j H(f_i),\qquad T_0=1. + \label{eq:moment-distributions} +\end{equation} +These are well-defined distributions on $D^j$. For example, the +local Sobolev moment bounds in the proof of \cref{prop:tightness} +permit taking the expectation of the tensor power as a distribution; +equivalently, the continuous multilinear form in +\eqref{eq:moment-distributions} has a distributional kernel. Let +\[ + \mathcal C_j=\{(x_1,\ldots,x_j)\in D^j:x_i\ne x_l\text{ for }i\ne l\} +\] +be the configuration space without collisions. + +\begin{proposition}[Harmonicity of absolute-height moments] +\label{prop:moment-harmonicity} +On $\mathcal C_j$, $T_j$ is a smooth function and is harmonic in each +variable separately. +\end{proposition} + +\begin{proof} +The identity already transferred to the true law says +\begin{equation} + \EE[H(\Delta\phi)F]=0 + \label{eq:true-local-increment-identity} +\end{equation} +for bounded products of localized increment functions satisfying the +separation conditions of \cref{prop:bracket-identity}. In particular, +each factor may be a bounded continuous function of $H(q)$, where +$q$ has integral zero and is supported in a small disk. Moment bounds +and truncation extend the identity to products of finitely many such +$H(q)$'s whenever the same geometric conditions hold. The disks may +overlap one another. + +Fix distinct points $x_0,x_2,\ldots,x_j$. Take a small closed disk +about $x_0$ with a larger concentric neighborhood compactly contained +in $D$ and disjoint from the spectator points. Choose spectator +neighborhoods and tests $f_i$ therein, and write $c_i=\int f_i$. +All these neighborhoods can be made as small as needed below. We +will approximate each absolute observation $H(f_i)$ by constants +and local zero-total observations supported a fixed positive distance +from the Laplace insertion. + +Choose a unit smooth average $\rho_i$ near $x_i$, and a clean boundary +subarc accessible without entering a fixed larger disk about $x_0$. +Such access is always possible. A path in $D$ that meets the excluded +small disk can be detoured through a concentric annulus compactly +contained in $D$; thus removing this disk does not block a route to +the boundary subarc. For finitely many reference endpoints in +\cref{lem:boundary-references}, join $\rho_i$ to each endpoint by a +finite chain of unit smooth averages +\[ + \rho_{i,n,0}=\rho_i,\ \rho_{i,n,1},\ldots, + \rho_{i,n,L_{i,n}}=\rho_{x_n(t),\kappa d(x_n(t))}. +\] +Consecutive supports lie in one disk of arbitrarily small prescribed +maximum diameter. Construct this by a sufficiently fine subdivision +of a path in its open tube, reducing the radii as necessary near the +boundary. All chain disks avoid the fixed neighborhood of $x_0$; +different chains need not avoid one another. There is the exact +identity +\begin{align} + H(f_i)={}&c_i k+H(f_i-c_i\rho_i) + +\frac{c_i}{N}\sum_{n=1}^N\sum_{l=0}^{L_{i,n}-1} + H(\rho_{i,n,l}-\rho_{i,n,l+1}) + +c_i(A_{N,t}-k). + \label{eq:transport-identity} +\end{align} +Every nonconstant term before the last has total integral zero and +is supported in one small disk. The final term tends to zero in +every required $L^p$, with depth first and then $N$ increasing. + +We check the separation geometry uniformly in the number of chain +links. Translate coordinates so that $x_0=0$, and suppose all chain +disks are outside $B(0,R)$. Choose $\ell\ll R$, and support $\phi$ +in $B(0,\ell/10)$. Available lower and upper levels lie in +$(-2\ell,-\ell)$ and $(\ell,2\ell)$, respectively. Cap the diameter +of every chain disk, and of each initial spectator neighborhood, +by $\ell/(100j)$. Expand a product of the approximations on the +right side of \eqref{eq:transport-identity}, omitting the last error +term. Each expanded term contains at most $j-1$ disks: it selects +at most one local observation from each original spectator factor. +Thus the total length of the forbidden vertical projections is +less than $\ell/100$ in either available level interval, regardless +of the number or length of the routes. Choose regular levels from +the dense union of grids outside these projections and with positive +clearance. + +Any selected disk in the resulting middle band is outside $B(0,R)$ +and has vertical coordinate of size at most $2\ell$. It consequently +lies well to the left or right of the insertion, also in projection +along $u=(\sqrt3/2,1/2)$, because $\ell\ll R$. The boundary pieces +in the middle band have the same property by the interior clearance +of $x_0$. These are exactly the geometric conditions of +\cref{prop:bracket-identity}. Each finite expanded term therefore +satisfies \eqref{eq:true-local-increment-identity}; the levels can +depend on that term. There is no requirement that a single pair +avoid every disk in all the routes at once. + +For each finite approximation the expanded sum is finite, so its +expectation against $H(\Delta\phi)$ is zero. The approximated +spectator variable differs from $H(f_i)$ by $c_i(A_{N,t}-k)$; in +particular its higher moments stay bounded independently of the +number of links. H\"older's inequality now passes to the $L^p$ +reference limit in the unexpanded product. We obtain +\[ + \EE\bigl[H(\Delta\phi)\prod_{i=2}^jH(f_i)\bigr]=0. +\] +This proves distributional harmonicity in the distinguished variable +on a neighborhood of every collision-free configuration. Product +tests suffice by density in the smooth tests on a product +neighborhood. Repeating with each distinguished variable gives +$\Delta_{x_i}T_j=0$ on $\mathcal C_j$. Their sum is the ordinary +elliptic Laplacian on $\R^{2j}$, so distributional harmonic +regularity gives a smooth representative there. The separate +identities then hold classically. +\end{proof} + +\begin{lemma}[No distributions supported on collision diagonals] +\label{lem:no-contact} +The smooth function $T_j$ on $\mathcal C_j$ is locally integrable on +$D^j$ and represents its full moment distribution. For $j\ge2$, +$K\Subset D$, and distinct $x_1,\ldots,x_j\in K$, with +$d_* =\min_{i2r$, the averaging balls +are disjoint and separate harmonicity gives +$T_j^{(r)}=T_j$ exactly by successive applications of the mean-value +property. Taking $r$ to be a fixed small fraction of $d_*$, with a +fixed upper cutoff depending on $K$, proves +\eqref{eq:offdiagonal-log-bound}. Its right side is integrable on +$K^j$: it is bounded by a constant times one plus the sum over +pairs of powers of $|\log|x_i-x_l||$, and such powers are +integrable in two dimensions. + +The collision neighborhood $\{d_*\le2r\}\cap K^j$ has volume +$O_{K,j}(r^2)$. By \eqref{eq:common-mollifier-bound}, the integral +of $|T_j^{(r)}|$ over that neighborhood tends to zero. The integral +there of the off-diagonal function tends to zero by its local +integrability. Off that neighborhood the two functions agree. +Thus $T_j^{(r)}$ converges in $L^1$ on compact sets to the extended +off-diagonal function. It also converges distributionally to the +original $T_j$, by the approximate-identity property. The two are +therefore the same distribution; no additional term supported on +a diagonal remains. + +For the boundary claims, choose fixed, disjoint, small radial unit +averages $\rho_i$ at the spectator points. For $x$ sufficiently +near the boundary, its comparable-depth averaging ball is disjoint +from all of them. Separate mean value gives +\[ + T_j(x,y_2,\ldots,y_j) + =\EE\left[H(\rho_{x,\kappa d(x)}) + \prod_{i=2}^jH(\rho_i)\right]. +\] +H\"older and \eqref{eq:depth-moment-bound} bound this uniformly in +$x$, including approaches to the marks. At a clean point, +\eqref{eq:mixed-boundary-trace} gives its limit as +$k\EE\prod_{i=2}^jH(\rho_i)$, which equals the right side of +\eqref{eq:moment-boundary-trace} by mean value once more. +\end{proof} diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/10-gaussian.tex b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/10-gaussian.tex new file mode 100644 index 0000000000000000000000000000000000000000..4ddca5c5cf0636bb4218f5b5808f359f64e40d5e --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/build/sections/10-gaussian.tex @@ -0,0 +1,360 @@ +\section{Collision coefficients and Gaussian identification} +\label{sec:gaussian} + +The preceding section applies to every subsequential true-field law. +Fix one such limit $H$ and its uncentered moment functions $T_j$. +The plane covariance coefficient is +$v=(2\pi)^2c_*>0$, as in \cref{thm:plane-covariance}. We now show +that it determines all moments in $D$. + +A related way to identify Gaussian pairings, by cancelling collision +singularities, appears in Kenyon's dimer-height proof +\cite[Lemma~3.1 and Proposition~3.2]{Kenyon2001}. The singularities there +are computed from explicit determinant formulas. Duminil-Copin, +Kozlowski, Lammers, and Manolescu use harmonicity and collision asymptotics +to identify higher full-plane increment correlations from the GFF +two-point function +\cite[Section~7.2]{DCKLM2026}. Here separate harmonicity determines the +form of each singularity, while a stopped local coupling to the plane law +determines its coefficient. The boundary traces proved in +\cref{sec:limits} then supply harmonic uniqueness in the bounded domain. + +\begin{lemma}[The only isolated singularity is logarithmic] +\label{lem:log-singularity} +Fix a collision-free list $(y,\mathbf z)$ of interior points. In a +neighborhood of $x=y$ containing none of the points of $\mathbf z$, +\begin{equation} + T_j(x,y,\mathbf z) + =L(y,\mathbf z)\log\frac1{|x-y|}+R(x;y,\mathbf z), + \label{eq:log-expansion} +\end{equation} +where $R$ extends harmonically across $x=y$ in the first variable. +The function $L$ is smooth on the parameter configuration space. +On compact subsets of that space one can choose a uniform radius +on which $R$, and each fixed order of its first-variable derivatives +on a smaller disk, are uniformly bounded. +\end{lemma} + +\begin{proof} +By \cref{prop:moment-harmonicity,lem:no-contact}, the function of $x$ +is harmonic on a punctured disk and has at most polylogarithmic +growth at its puncture. The polar Fourier expansion of a harmonic +function there has constant angular part $a+b\log r$ and, in angular +mode $n\ge1$, radial factors $r^n$ and $r^{-n}$. A coefficient of +$r^{-n}$ would grow faster than every power of $\log(1/r)$, so it +vanishes. The remaining positive modes extend harmonically to the +center. This proves \eqref{eq:log-expansion}. This argument can +also be obtained by taking Fourier coefficients on each concentric +circle and solving their radial differential equations; the growth +bound kills the negative coefficients one at a time. + +There is a useful parameter formula that supplies the needed +uniformity. Choose a fixed radius $a>0$, small enough for all +$(y,\mathbf z)$ in a parameter neighborhood. Outward differentiation +in the first variable gives +\begin{equation} + L(y,\mathbf z) + =-\frac1{2\pi}\int_{|w-y|=a} + \partial_{n_w}T_j(w,y,\mathbf z)\,ds_w. + \label{eq:circle-log-coefficient} +\end{equation} +The integral of the derivative of the removable remainder is zero, +and that of $\log(1/|w-y|)$ is $-2\pi$. Parametrize the circle by +$w=y+a e^{i\theta}$. The integrand is smooth in all parameters on +this fixed collision-free compact set, so $L$ is smooth. Subtract +the logarithmic term from the boundary values on this circle and +use the Poisson formula on its disk. It gives the extension $R$ +and bounds all its first-variable derivatives on every fixed +smaller concentric disk, uniformly over compact parameter sets. +This proves in particular the continuity of $L$ needed below, +without inferring it from a nonuniform singular limit. +\end{proof} + +\begin{proposition}[Identification of the collision coefficient] +\label{prop:collision-coefficient} +For $j\ge2$ and distinct $(y,\mathbf z)$, +\begin{equation} + L(y,\mathbf z)=\frac{v}{2\pi}T_{j-2}(\mathbf z). + \label{eq:collision-coefficient} +\end{equation} +The convention is $T_0=1$; no centering is made in this identity. +\end{proposition} + +\begin{proof} +\emph{A stopped comparison with the plane.} +We first establish precisely the mixing statement used to examine +the collision. Fix an interior center $y_0$, and fixed small +spectator balls away from it. For two smooth zero-integral tests +$\alpha,\beta$ in disjoint bounded disks, put +\[ + \alpha_r(x)=r^{-2}\alpha((x-y_0)/r),\qquad + \beta_r(x)=r^{-2}\beta((x-y_0)/r). +\] +Their supports lie in $B(y_0,Cr)$. If $F_\delta$ is a product of +height averages on the spectator balls, then, with a plane copy +denoted by $H_\delta^{\mathrm{pl}}$, +\begin{align} + &\limsup_{\delta\downarrow0} + \left|\EE[H_\delta(\alpha_r)H_\delta(\beta_r)F_\delta] + -\EE[H_\delta^{\mathrm{pl}}(\alpha_r) + H_\delta^{\mathrm{pl}}(\beta_r)]\,\EE F_\delta\right| + \longrightarrow0\qquad(r\downarrow0). + \label{eq:local-product-mixing} +\end{align} +The mesh limit is taken first at every fixed $r$. + +Here is the coupling argument, including the absolute exterior +heights. Choose a fixed disk $B(y_0,R_0)\Subset D$ disjoint from +the spectators. In the spin representation of the true problem, +$W$ is fixed on the one connected boundary path. Imposing constancy +there and then its plus label leaves the $B$ marginal unchanged. +The double-cut stack estimate used in \cref{prop:plane-mixing} +therefore applies in this pin-free interior disk. Search from the +outside inward for a double $B$ circuit between radii of order +$r^{1/2}$ and $R_0$. It fails with probability at most a positive +power of $r$. On success the chosen circuit surrounds a disk of +radius comparable to $r^{1/2}$, and the stopping exploration has +not examined its interior. + +The absolute heights at all spectator sites can be read in this +exterior. Choose the anchor on the prescribed boundary, with its +known height, and join it to the spectator balls by paths avoiding +$B(y_0,R_0)$. Such paths exist after reducing $R_0$ if needed: +paths in $D$ can be detoured around this interior disk. A finite +family of positive-width tubes and the spectator balls supplies +the same paths in sufficiently fine lattice approximations. The +edge increment formula, summed from the fixed anchor, gives every +height occurring in $F_\delta$ using only exterior spins. Affine +interpolation uses only the adjacent exterior sites. Thus revealing +these observations adds no interior information. + +Conditional on the stopping circuit and all exterior spins, +including $W$, its interior is the free-$W$ double-cut law. Indeed +both $B$ values across every cut edge agree, so there is no constraint +on $W$ across it; the stopping rule has imposed no further interior +condition. The common worst-boundary coupling in the proof of +\cref{prop:plane-mixing}, applied inside this circuit, now matches +the spins in $B(y_0,Cr)$ to those of a plane copy with failure +probability at most a positive power of $r/r^{1/2}$. Its bound is +uniform over the exposed exterior. The conditional coupling can +be chosen with the plane law as its second marginal for every +exterior value. That marginal is consequently independent of the +exterior observations. On failure of the first search, choose +the plane copy independently as well. Altogether the matching +failure probability is at most $C r^\gamma$ for some $\gamma>0$, +in the limiting mesh regime. + +On the matching event the two zero-total height smearings agree +with their plane versions. Equality of the local increments +determines heights only up to one additive constant, and the zero +integrals remove exactly that constant. The interpolation weights +have the same zero sum. All comparison statements can first be +implemented in finite free spin volumes and then passed to the +plane law. + +Finally this coupling controls unbounded products. The true local +smearings have $L^q$ norms at most +$C_q(1+|\log r|)^{1/2}$ by \cref{prop:smearing-moments}; the plane +zero-total smearings have uniformly bounded $L^q$ norms by +\cref{prop:plane-moments}. The fixed spectator product has bounded +moments of every finite order. Applying H\"older with exponent +four to the two insertions, the spectator product, and the failure +indicator bounds the expectation of the product discrepancy by +\begin{equation} + C r^{\gamma/4}(1+|\log r|)=o(1). + \label{eq:mixing-error-log} +\end{equation} +For the plane term the same bound holds with no logarithmic loss. +This proves \eqref{eq:local-product-mixing}. In particular we have +not used an arbitrary conditional spin law after revealing absolute +heights: those heights were first made measurable in the exterior +of an actual stopping cut. + +\emph{Extracting the logarithmic coefficient.} +Choose $\alpha,\beta$ so that +\begin{equation} + J=\iint\alpha(u)\beta(w)\log\frac1{|u-w|}\,du\,dw\ne0. + \label{eq:nonzero-log-pairing} +\end{equation} +Such tests exist even in disjoint disks. For example, take the +first-coordinate derivatives of radial unit bumps about two points +on a horizontal line, with sufficiently small disjoint supports. +Integration by parts reduces their pairing to the corresponding +mixed derivative of the log kernel averaged over the two bumps. +That derivative is nonzero at their centers and keeps its sign +when the supports are small. Each derivative test has integral +zero. + +Use fixed disjoint radial unit mollifiers at the points of +$\mathbf z$, and let $F$ be the product of the resulting height +averages; when $j=2$, take $F=1$. Separate harmonicity gives +$\EE F=T_{j-2}(\mathbf z)$. By \cref{thm:plane-covariance}, the +mesh limit of the plane pairing in +\eqref{eq:local-product-mixing} equals $vJ/(2\pi)$. The log +constant introduced by the rescaling vanishes since both tests +have integral zero. Taking the mesh limit and then $r\downarrow0$ +in \eqref{eq:local-product-mixing} therefore yields +\begin{equation} + \lim_{r\downarrow0}\EE[H(\alpha_r)H(\beta_r)F] + =\frac{vJ}{2\pi}T_{j-2}(\mathbf z). + \label{eq:mixing-coefficient-limit} +\end{equation} + +We compute the same limit from \cref{lem:log-singularity}. The two +shrinking supports are disjoint and avoid the spectators. Averaging +the spectator variables radially thus evaluates the moment function +at $\mathbf z$ exactly. The expression on the left of +\eqref{eq:mixing-coefficient-limit} is +\begin{align*} + \iint\alpha(u)\beta(w)\bigg[ + &L(y_0+rw,\mathbf z) + \left(\log\frac1r+\log\frac1{|u-w|}\right)\\ + &\hspace{17mm}+R(y_0+ru;y_0+rw,\mathbf z)\bigg]\,du\,dw. +\end{align*} +The term containing $\log(1/r)$ is exactly zero: for each fixed +$w$ its coefficient is independent of $u$, and $\int\alpha=0$. +This cancellation occurs before estimating the variation of $L$; +no modulus of continuity multiplied by $\log(1/r)$ is required. +Continuity of $L$ and the disjoint supports give convergence of +the remaining logarithmic term to $L(y_0,\mathbf z)J$. +For the remainder, subtract +$R(y_0;y_0+rw,\mathbf z)$ inside the $u$ integral. The subtracted +quantity again integrates to zero, and the uniform first-variable +derivative bound in \cref{lem:log-singularity} makes the remaining +integral $O(r)$. The limit is therefore $L(y_0,\mathbf z)J$. +Comparison with \eqref{eq:mixing-coefficient-limit} and $J\ne0$ +proves \eqref{eq:collision-coefficient}. +\end{proof} + +\begin{theorem}[Gaussian moment recursion] +\label{thm:gaussian-moments} +For distinct points $(x,y_1,\ldots,y_{j-1})$, +\begin{equation} + T_j(x,\mathbf y) + =m(x)T_{j-1}(\mathbf y) + +v\sum_{i=1}^{j-1}G_D(x,y_i) + T_{j-2}(\mathbf y\setminus y_i). + \label{eq:gaussian-recursion} +\end{equation} +For $j=1$ the assertion is $T_1=m$. These functions, as locally +integrable distributions, are the moment distributions of +$m+\sqrt v\,\Phi_D$, where $\Phi_D$ is the zero-boundary GFF with +covariance $G_D$. The limiting field $H$ has this law. +\end{theorem} + +\begin{proof} +Fix the distinct spectator points. Subtract the right side of +\eqref{eq:gaussian-recursion} from its left side, and call the +result $U(x)$. Away from the spectator points it is harmonic in +$x$. The Green function convention is +\[ + G_D(x,y)=\frac1{2\pi}\log\frac1{|x-y|} + +\text{a function harmonic near }y. +\] +By \cref{prop:collision-coefficient}, the logarithmic coefficient +at each $y_i$ cancels. Lemma~\ref{lem:log-singularity} then shows +that $U$ extends harmonically across every $y_i$. Thus it is +harmonic on all of $D$. + +The boundary estimate in \cref{lem:no-contact} bounds the moment +function as $x$ approaches any boundary point, including a mark. +The subtracted mean is bounded, and the Green terms tend to zero +at the boundary. Together with removability at the finitely many +interior singularities, this makes $U$ bounded in $D$. On each +open boundary arc, \eqref{eq:moment-boundary-trace} and the trace +of $m$ give $U\to0$. Bounded harmonic uniqueness with the two +exceptional points, proved in the boundary argument above, gives +$U=0$. More explicitly, compare $\pm U$ with +$\norm{U}_\infty$ times a harmonic extension of a boundary function +equal to one in a small neighborhood of each mark and zero outside +a slightly larger neighborhood, and let those neighborhoods shrink. +This proves the recursion. + +Starting from $T_0=1$, the recursion uniquely gives the usual partial +pairing formula +\begin{equation} + T_j(x_1,\ldots,x_j) + =\sum_{\mathcal P} + \prod_{\{a,b\}\in\mathcal P}vG_D(x_a,x_b) + \prod_{c\notin\bigcup\mathcal P}m(x_c), + \label{eq:partial-pairing-formula} +\end{equation} +where $\mathcal P$ ranges over collections of disjoint unordered +pairs in $\{1,\ldots,j\}$, including the empty collection. +Indeed the distinguished index is either a singleton, producing +the mean term, or is paired to exactly one other index, producing +one term of the sum in \eqref{eq:gaussian-recursion}. This is +also the uncentered Gaussian moment formula. Each displayed +product is locally integrable: the logarithmic Green singularities +are locally integrable, and its pairs have disjoint sets of +variables. By \cref{lem:no-contact}, agreement off diagonals is +agreement of the full moment distributions. It follows that all +joint smeared moments of $H$ equal those of $m+\sqrt v\,\Phi_D$. + +We include the determinacy step. For a real test $f$, let +$Z=H(f)-\int mf$ and put +$s^2=v\iint f(x)G_D(x,y)f(y)\,dx\,dy$. The moment formula gives +$\EE Z^{2n}=(2n-1)!!\,s^{2n}$ and all odd moments zero. If +$s=0$ then $Z=0$ almost surely. Otherwise Cauchy--Schwarz gives +\[ + \EE|Z|^n\le (\EE Z^{2n})^{1/2} + \le s^n(2n)^{n/2}. +\] +Consequently $\sum_n |t|^n\EE|Z|^n/n!<\infty$ for every real +$t$. The exponential and characteristic-function series may be +integrated term by term, and the latter is +$\exp(-s^2t^2/2)$. Thus $Z$ is Gaussian. Applying this argument +to every real linear combination of a finite list of tests and +using the Cram\'er--Wold criterion proves the required joint +Gaussian law. Finally a countable dense collection of tests +determines the Borel law in the local Sobolev space of +\cref{prop:tightness}. Hence the random distribution itself has +the asserted law. +\end{proof} + +\begin{corollary}[Full convergence and the odd-height normalization] +\label{cor:field-limit} +For every $t>1$, +\begin{equation} + H_\delta\ \Longrightarrow\ m+\sqrt v\,\Phi_D, + \qquad + H_\delta-\EE H_\delta\ \Longrightarrow\ \sqrt v\,\Phi_D + \quad\text{in }H^{-t}_{\mathrm{loc}}(D). + \label{eq:integer-field-limit} +\end{equation} +All finite joint test moments converge. In particular +\begin{equation} + \frac{h_\delta-\EE h_\delta}{\sigma} + \ \Longrightarrow\ \Phi_D, + \qquad + \sigma=2\sqrt v=4\pi\sqrt{c_*}>0. + \label{eq:odd-field-limit} +\end{equation} +The constant has the absolutely convergent finite-volume expression +of \cref{prop:normalization-series}; it is independent of $D,a,b$. +The uncentered odd-height limit has mean $2m+1$, the harmonic +extension of its prescribed values $+1,-1$. +\end{corollary} + +\begin{proof} +Every subsequence admits a further limit by \cref{prop:tightness}, +and \cref{thm:gaussian-moments} identifies every such limit with +the same law. Tightness and uniqueness therefore give full +convergence, with convergence of joint moments supplied by +uniform integrability. + +In particular $\EE H_\delta(f)\to\int mf$ for each test $f$. +There is also deterministic local Sobolev convergence of the +means, which justifies subtracting the actual discrete expectation +in the stated topology. With a cutoff and Fourier basis as in +\eqref{eq:sobolev-bound}, each Fourier coefficient of +$\chi(\EE H_\delta-m)$ tends to zero and is bounded uniformly +in its index and in $\delta$. For $t>1$, the summable weights +$(1+|n|^2)^{-t}$ and dominated convergence show that the +$H^{-t}$ norm tends to zero. Apply this to the local exhaustion +and subtract this deterministic limit in the first convergence +of \eqref{eq:integer-field-limit}. Finally affine interpolation +preserves $h_\delta=2H_\delta+1$ exactly. Centering removes its +constant term and multiplies fluctuations by two, giving +\eqref{eq:odd-field-limit} with the stated normalization. +\end{proof} diff --git a/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/paper.pdf b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..bfd4fbee985d02c7ab66c36b678abb8504efcc83 --- /dev/null +++ b/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f0047faf78711628ea4ee59901c37478c00840e166a4ac43504106ca1b385abe +size 632285 diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/README.md b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7cd912dc228fedaad1f5504b2f9d942d34e90350 --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/README.md @@ -0,0 +1,20 @@ +# [The joint scaling limit of critical Ashkin–Teller currents](main.pdf) + +OpenAI +October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026, + author = {{OpenAI}}, + title = {{The joint scaling limit of critical Ashkin--Teller currents}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/main.pdf}{OAI:The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version corrects the transmission and boundary-collar arguments, replaces excursion convergence with a signed-loop-soup/GMC argument tied to the same limiting field, and updates the companion-paper citation; see the [previous version](../The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-September-25-2026/main.pdf). diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/main.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..2163cc3c9a747b2fcb8506fd1d13cf29856074f6 --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/main.tex @@ -0,0 +1,84 @@ +\documentclass[11pt]{article} +\ifdefined\pdfinfoomitdate\pdfinfoomitdate=1\fi +\ifdefined\pdftrailerid\pdftrailerid{}\fi +\ifdefined\pdfsuppressptexinfo\pdfsuppressptexinfo=15\fi +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage[margin=1.08in]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools,mathrsfs} +\usepackage{microtype,graphicx,booktabs,enumitem,flafter} +\usepackage{xcolor,tikz} +\usetikzlibrary{arrows.meta,positioning,calc,patterns} +\usepackage[numbers,sort&compress]{natbib} +\usepackage[colorlinks=true,linkcolor=teal!60!black,citecolor=teal!60!black,urlcolor=teal!60!black]{hyperref} +\usepackage[capitalize,nameinlink,noabbrev]{cleveref} +\hypersetup{pdftitle={The joint scaling limit of critical Ashkin-Teller currents},pdfauthor={OpenAI}} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{remark}[theorem]{Remark} +\newtheorem{convention}[theorem]{Convention} +\crefname{equation}{Equation}{Equations} +\crefname{section}{Section}{Sections} +\newcommand{\R}{\mathbb R} +\newcommand{\Z}{\mathbb Z} +\newcommand{\N}{\mathbb N} +\newcommand{\E}{\mathbb E} +\renewcommand{\P}{\mathbb P} +\newcommand{\dd}{\,\mathrm d} +\newcommand{\eps}{\varepsilon} +\newcommand{\ind}{\mathbf 1} +\newcommand{\GFF}{\mathrm{GFF}} +\newcommand{\CLE}{\mathrm{CLE}} +\newcommand{\FPS}{\mathrm{FPS}} +\DeclareMathOperator{\Var}{Var} +\DeclareMathOperator{\Cov}{Cov} +\DeclareMathOperator{\diam}{diam} +\DeclareMathOperator{\dist}{dist} +\DeclareMathOperator{\supp}{supp} +\DeclareMathOperator{\Law}{Law} +\DeclareMathOperator{\sgn}{sgn} +\newcommand{\cA}{\mathcal A} +\newcommand{\cC}{\mathcal C} +\newcommand{\cF}{\mathcal F} +\newcommand{\cH}{\mathcal H} +\newcommand{\TVS}[2]{A_{-#1,#2}} +\numberwithin{equation}{section} +\setlist{itemsep=3pt,topsep=5pt} +\setlength{\emergencystretch}{2em} +\title{The joint scaling limit of critical Ashkin--Teller currents} +\author{OpenAI} +\date{October 6, 2026} +\begin{document} +\maketitle +\begin{abstract} +For each fixed point on the critical Ashkin--Teller line, including the +four-state Potts endpoint, we prove the conjectured joint scaling limit +of the height and both current-cluster collections in every bounded +Jordan domain, for every admissible polygonal approximation. The height +converges to a Gaussian free field with the predicted coupling constant, +and the clusters converge to canonical recursive two-valued local sets +of that same field. The joint limit includes all nesting depths and the +distinguished wired boundary cluster. +\end{abstract} +\tableofcontents +\input{sections/01-introduction} +\input{sections/02-model} +\input{sections/03-spatial} +\input{sections/04-spectral} +\input{sections/05-screening} +\input{sections/06-gaussian} +\input{sections/07-local-sets} +\input{sections/08-local-kernel} +\input{sections/09-identification} +\appendix +\input{sections/10-input-conventions} +\begingroup +\small +\bibliographystyle{plainnat} +\bibliography{references} +\endgroup +\end{document} diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/references.bib b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..7a6103d000f3e706bd05efcfdb58964238b9f42a --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/references.bib @@ -0,0 +1,330 @@ +@article{AshkinTeller1943, + author = {Ashkin, J. and Teller, E.}, + title = {Statistics of Two-Dimensional Lattices with Four Components}, + journal = {Physical Review}, + volume = {64}, + number = {5--6}, + pages = {178--184}, + year = {1943}, + doi = {10.1103/PhysRev.64.178}, + url = {https://journals.aps.org/pr/abstract/10.1103/PhysRev.64.178} +} + +@article{DRC2025, + author = {Duminil-Copin, Hugo and Lis, Marcin and Qian, Wei}, + title = {Conformal invariance of double random currents {I}: + Identification of the limit}, + journal = {Proceedings of the London Mathematical Society}, + volume = {130}, + number = {1}, + pages = {e70022}, + year = {2025}, + doi = {10.1112/plms.70022}, + note = {Versioned source: arXiv:2107.12985v3, 6 January 2025}, + url = {https://arxiv.org/abs/2107.12985v3} +} + +@misc{DKLM2026, + author = {Duminil-Copin, Hugo and Kozlowski, Karol Kajetan and + Lammers, Piet and Manolescu, Ioan}, + title = {{Gaussian} free field convergence of the six-vertex model with + {$-1\leq\Delta\leq-\frac12$}}, + year = {2026}, + howpublished = {arXiv:2603.06268v1}, + note = {Version of 6 March 2026}, + url = {https://arxiv.org/abs/2603.06268v1} +} + +@article{ASW2017, + author = {Aru, Juhan and Sep{\'u}lveda, Avelio and Werner, Wendelin}, + title = {On bounded-type thin local sets of the two-dimensional {Gaussian} free field}, + journal = {Journal of the Institute of Mathematics of Jussieu}, + volume = {18}, + number = {3}, + pages = {591--618}, + year = {2019}, + doi = {10.1017/S1474748017000160}, + note = {Versioned source: arXiv:1603.03362v3, 12 April 2017}, + url = {https://arxiv.org/abs/1603.03362v3} +} + +@article{AS2018, + author = {Aru, Juhan and Sep{\'u}lveda, Avelio}, + title = {Two-valued local sets of the {2D} continuum {Gaussian} free field: + connectivity, labels, and induced metrics}, + journal = {Electronic Journal of Probability}, + volume = {23}, + pages = {Paper No. 61, 35 pp.}, + year = {2018}, + doi = {10.1214/18-EJP182}, + note = {Versioned source: arXiv:1801.03828v2, 1 May 2018}, + url = {https://arxiv.org/abs/1801.03828v2} +} + +@article{ALS2017, + author = {Aru, Juhan and Lupu, Titus and Sep{\'u}lveda, Avelio}, + title = {First passage sets of the {2D} continuum {Gaussian} free field}, + journal = {Probability Theory and Related Fields}, + volume = {176}, + number = {3--4}, + pages = {1303--1355}, + year = {2020}, + doi = {10.1007/s00440-019-00941-1}, + note = {Versioned source: arXiv:1706.07737v3, 26 August 2019}, + url = {https://arxiv.org/abs/1706.07737v3} +} + +@article{ALS2018, + author = {Aru, Juhan and Lupu, Titus and Sep{\'u}lveda, Avelio}, + title = {The first passage sets of the {2D} {Gaussian} free field: + convergence and isomorphisms}, + journal = {Communications in Mathematical Physics}, + volume = {375}, + number = {3}, + pages = {1885--1929}, + year = {2020}, + doi = {10.1007/s00220-020-03718-z}, + note = {Versioned source: arXiv:1805.09204v1, 23 May 2018}, + url = {https://arxiv.org/abs/1805.09204v1} +} + +@misc{ALS2023, + author = {Aru, Juhan and Lupu, Titus and Sep{\'u}lveda, Avelio}, + title = {Excursion decomposition of the {2D} continuum {GFF}}, + year = {2023}, + howpublished = {arXiv:2304.03150v2}, + note = {Version of 3 October 2023}, + doi = {10.48550/arXiv.2304.03150}, + url = {https://arxiv.org/abs/2304.03150v2} +} + +@misc{Triangular, + author = {{OpenAI}}, + title = {{The Gaussian free field limit of integer Lipschitz heights with two-arc boundary data}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026/paper.pdf}{OAI:The-Gaussian-free-field-limit-of-integer-Lipschitz-heights-with-two-arc-boundary-data-October-6-2026}}, + year = {2026} +} + +@article{Sierpinski1918, + author = {Sierpi{\'n}ski, Wac{\l}aw}, + title = {Un th{\'e}or{\`e}me sur les continus}, + journal = {T{\^o}hoku Mathematical Journal, First Series}, + volume = {13}, + pages = {300--303}, + year = {1918}, + url = {https://www.jstage.jst.go.jp/article/tmj1911/13/0/13_0_300/_article/-char/en} +} + +@article{Lis2022Spins, + author = {Lis, Marcin}, title = {Spins, percolation and height functions}, + journal = {Electronic Journal of Probability}, volume = {27}, number = {35}, + pages = {1--21}, year = {2022}, doi = {10.1214/22-EJP761}, + eprint = {1909.07351}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/1909.07351v3}, + note = {Proof locators refer to arXiv:1909.07351v3} +} + +@article{Lis2022Boundary, + author = {Lis, Marcin}, + title = {On Boundary Correlations in Planar {Ashkin--Teller} Models}, + journal = {International Mathematics Research Notices}, + volume = {2022}, number = {13}, pages = {9909--9940}, year = {2022}, + doi = {10.1093/imrn/rnaa380}, eprint = {2009.12131}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/2009.12131v2}, + note = {Proof locators refer to arXiv:2009.12131v2} +} + +@article{Rys1963, + author = {Rys, Franz}, + title = {{\"U}ber ein zweidimensionales klassisches Konfigurationsmodell}, + journal = {Helvetica Physica Acta}, volume = {36}, number = {5}, + pages = {537--559}, year = {1963}, doi = {10.5169/seals-113387} +} + +@article{DuminilCopinLis2019, + author = {Duminil-Copin, Hugo and Lis, Marcin}, + title = {On the double random current nesting field}, + journal = {Probability Theory and Related Fields}, volume = {175}, number = {3-4}, + pages = {937--955}, year = {2019}, doi = {10.1007/s00440-019-00899-0}, + eprint = {1712.02305}, archivePrefix = {arXiv}, + url = {https://arxiv.org/abs/1712.02305v2}, + note = {Versioned source: arXiv:1712.02305v2} +} + +@misc{AlcaldeLopezHeeneyLis2026, + author = {Alcalde L{\'o}pez, Tom{\'a}s and Heeney, Lorca and Lis, Marcin}, + title = {The {Ising} magnetisation field and the {Gaussian} free field}, + year = {2026}, eprint = {2602.05886}, archivePrefix = {arXiv}, + primaryClass = {math.PR}, url = {https://arxiv.org/abs/2602.05886v1}, + note = {arXiv:2602.05886v1, 5 February 2026} +} + +@misc{AlcaldeLopezSepulveda2026, + author = {Alcalde L{\'o}pez, Tom{\'a}s and Sep{\'u}lveda, Avelio}, + title = {Excursion decomposition of the {XOR-Ising} model}, + year = {2026}, eprint = {2602.06011}, archivePrefix = {arXiv}, + primaryClass = {math.PR}, url = {https://arxiv.org/abs/2602.06011v2}, + note = {arXiv:2602.06011v2, 25 March 2026} +} + +@article{Griffiths1967I, + author = {Griffiths, Robert B.}, + title = {Correlations in {Ising} Ferromagnets. {I}}, + journal = {Journal of Mathematical Physics}, volume = {8}, number = {3}, + pages = {478--483}, year = {1967}, doi = {10.1063/1.1705219} +} + +@article{FortuinKasteleynGinibre1971, + author = {Fortuin, C. M. and Kasteleyn, P. W. and Ginibre, J.}, + title = {Correlation inequalities on some partially ordered sets}, + journal = {Communications in Mathematical Physics}, volume = {22}, number = {2}, + pages = {89--103}, year = {1971}, doi = {10.1007/BF01651330} +} + +@article{Holley1974, + author = {Holley, Richard}, title = {Remarks on the {FKG} inequalities}, + journal = {Communications in Mathematical Physics}, volume = {36}, number = {3}, + pages = {227--231}, year = {1974}, doi = {10.1007/BF01645980} +} + +@article{FrohlichIsraelLiebSimon1978, + author = {Fr{\"o}hlich, J. and Israel, R. and Lieb, E. H. and Simon, B.}, + title = {Phase transitions and reflection positivity. {I}. General theory and long range lattice models}, + journal = {Communications in Mathematical Physics}, volume = {62}, number = {1}, + pages = {1--34}, year = {1978}, doi = {10.1007/BF01940327} +} + +@article{FrohlichIsraelLiebSimon1980, + author = {Fr{\"o}hlich, J. and Israel, R. and Lieb, E. H. and Simon, B.}, + title = {Phase transitions and reflection positivity. {II}. Lattice systems with short-range and {Coulomb} interactions}, + journal = {Journal of Statistical Physics}, volume = {22}, number = {3}, + pages = {297--347}, year = {1980}, doi = {10.1007/BF01014646} +} + +@misc{Usui2012, + author = {Usui, Kouta}, + title = {A Note on Reflection Positivity and the {Umezawa--Kamefuchi--K{\"a}ll{\'e}n--Lehmann} Representation of Two Point Correlation Functions}, + year = {2012}, + howpublished = {arXiv:1201.3415v3}, + note = {Version of 2 March 2012}, + url = {https://arxiv.org/abs/1201.3415v3} +} + +@misc{WilliamsSpectral2018, + author = {Williams, Dana P.}, + title = {Lecture Notes on the Spectral Theorem}, + year = {2018}, + note = {Lecture notes dated 10 August 2018}, + url = {https://www.math.dartmouth.edu/~dana/bookspapers/ln-spec-thm.pdf} +} + +@book{Freiwald2014, + author = {Freiwald, Ronald C.}, + title = {An Introduction to Set Theory and Topology}, + publisher = {Washington University in St. Louis}, + year = {2014}, + doi = {10.7936/K7D798QH}, + url = {https://www.math.wustl.edu/~freiwald/topology/Ch5.pdf} +} + +@book{Ahlfors1979, + author = {Ahlfors, Lars V.}, + title = {Complex Analysis: An Introduction to the Theory of Analytic Functions of One Complex Variable}, + edition = {3}, + publisher = {McGraw-Hill}, + address = {New York}, + year = {1979} +} + +@book{AstalaIwaniecMartin2009, + author = {Astala, Kari and Iwaniec, Tadeusz and Martin, Gaven}, + title = {Elliptic Partial Differential Equations and Quasiconformal Mappings in the Plane}, + series = {Princeton Mathematical Series}, + volume = {48}, + publisher = {Princeton University Press}, + year = {2009} +} + +@book{FriedliVelenik2017, + author = {Friedli, Sacha and Velenik, Yvan}, + title = {Statistical Mechanics of Lattice Systems: A Concrete Mathematical Introduction}, + publisher = {Cambridge University Press}, + year = {2017}, + doi = {10.1017/9781316882603}, + note = {Proof locator in the author version dated 22 August 2017}, + url = {https://www.unige.ch/math/folks/velenik/smbook/Ising_Model.pdf} +} + +@article{SixVertexFreeEnergy2022, + author = {Duminil-Copin, Hugo and Kozlowski, Karol Kajetan and Krachun, Dmitry and Manolescu, Ioan and Tikhonovskaia, Tatiana}, + title = {On the {Six-Vertex} Model's Free Energy}, + journal = {Communications in Mathematical Physics}, + volume = {395}, pages = {1383--1430}, year = {2022}, + doi = {10.1007/s00220-022-04459-x} +} + +@book{GarnettMarshall2005, + author = {Garnett, John B. and Marshall, Donald E.}, + title = {Harmonic Measure}, + series = {New Mathematical Monographs}, + volume = {2}, + publisher = {Cambridge University Press}, + year = {2005}, + doi = {10.1017/CBO9780511546617} +} + +@misc{BalancedSixVertex2026, + author = {{OpenAI}}, + title = {{The Gaussian free field limit of the balanced six-vertex model with variance multiplier $1/\arcsin(c/2)$}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026/The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026.pdf}{OAI:The-Gaussian-free-field-limit-of-the-balanced-six-vertex-model-with-variance-multiplier-1-over-arcsin-c-over-2-September-23-2026}}, + year = {2026} +} + +@misc{JLQ2023Fields, + author = {Jego, Antoine and Lupu, Titus and Qian, Wei}, + title = {Conformally invariant fields out of {Brownian} loop soups}, + year = {2023}, + howpublished = {arXiv:2307.10740v2}, + note = {Version of 5 October 2023}, + doi = {10.48550/arXiv.2307.10740}, + url = {https://arxiv.org/abs/2307.10740v2} +} + +@article{ABJL2023, + author = {A{\"i}d{\'e}kon, {\'E}lie and Berestycki, Nathana{\"e}l + and Jego, Antoine and Lupu, Titus}, + title = {Multiplicative chaos of the {Brownian} loop soup}, + journal = {Proceedings of the London Mathematical Society}, + volume = {126}, + number = {4}, + pages = {1254--1393}, + year = {2023}, + doi = {10.1112/plms.12511}, + note = {Versioned source: arXiv:2107.13340v2, 20 October 2022}, + url = {https://arxiv.org/abs/2107.13340v2} +} + +@misc{BSS2020, + author = {Berestycki, Nathana{\"e}l and Sheffield, Scott and Sun, Xin}, + title = {Equivalence of {Liouville} measure and {Gaussian} free field}, + year = {2020}, + howpublished = {arXiv:1410.5407v4}, + note = {Version of 7 September 2020}, + doi = {10.48550/arXiv.1410.5407}, + url = {https://arxiv.org/abs/1410.5407v4} +} + +@article{Lupu2016, + author = {Lupu, Titus}, + title = {From loop clusters and random interlacement to the free field}, + journal = {The Annals of Probability}, + volume = {44}, + number = {3}, + pages = {2117--2146}, + year = {2016}, + doi = {10.1214/15-AOP1019}, + note = {Versioned source: arXiv:1402.0298v7, 9 July 2020}, + url = {https://arxiv.org/abs/1402.0298v7} +} diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/01-introduction.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/01-introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..769d2e0269431295e3e23c1a26753bb6fea9463e --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/01-introduction.tex @@ -0,0 +1,103 @@ +\section{Introduction}\label{sec:introduction} + +The Ashkin--Teller model originates in the four-component lattice model +of Ashkin and Teller \cite{AshkinTeller1943}. Its current representation +raises a geometric question beyond convergence of the associated height: +what is the joint continuum law of all primal and dual current clusters, +and how are these collections coupled to the field? We prove the joint +limit in \cref{thm:main} for every fixed point on the critical line, +including the four-state Potts endpoint. This is the height and +current-cluster assertion formulated by Alcalde L\'opez, Heeney, and Lis +\cite[Conjecture~1.2]{AlcaldeLopezHeeneyLis2026}. + +Fix $J>0$ and $U\le J$ with $\sinh(2J)=e^{-2U}$. Our zero-boundary +Gaussian free field has covariance $2\pi(-\Delta_D)^{-1}$, with +logarithmic singularity $-\log|z-w|$. In this normalization put +\[ + \lambda=\frac\pi2,\qquad a=\lambda\sqrt g,\qquad + g=\frac8\pi\arcsin\!\left(\frac{\sqrt{1+e^{4U}}}{2}\right). +\] +Thus $4/30\) and \(U\leq J\) satisfying +\[ + \sinh(2J)=e^{-2U}. +\] +Throughout the proof these parameters remain fixed. Put +\begin{equation}\label{eq:parameters} + t=(1+e^{4U})^{-1/2},\qquad c=t^{-1},\qquad + \theta=\arcsin(c/2),\qquad g=\frac{8\theta}{\pi}. +\end{equation} +Then \(1/2\leq t<1\), \(10\) and \(\alpha+\beta\geq2\lambda\). It includes the domain boundary. +The conditional harmonic function on each complementary component is +either \(-\alpha\) or \(\beta\); after subtracting that value, the field in the +component is an independent zero-boundary GFF. These sets are measurable +functions of the field. We use their uniqueness, monotonicity, and +Jordan-hole properties with the hypotheses stated in +\cref{sec:local-sets}; see \cite{ASW2017,AS2018,ALS2017}. +In particular the complementary loops of +\(\TVS{2\lambda}{2\lambda}\) have law \(\CLE_4\). + +\begin{definition}[Free cluster procedure]\label{def:free-procedure} +For a zero-boundary GFF \(f\) in a Jordan domain \(O\), define +\(\mathcal F_a(f,O)\) recursively as follows. +\begin{enumerate} +\item Expose \(\TVS{2\lambda}{2\lambda}(f)\). In every complementary +component \(V\), write its label as \(\xi\,2\lambda\), +\(\xi\in\{-1,1\}\), and let \(f_V\) be the zero-boundary remainder. +\item If \(\xi=1\), retain +\(\TVS{2\lambda}{2a-2\lambda}(f_V)\) as one cluster. If \(\xi=-1\), +retain \(\TVS{(2a-2\lambda)}{2\lambda}(f_V)\). +The retained set includes its outer boundary \(\partial V\). +\item In each complementary component of the retained set, subtract its +conditional harmonic value and repeat the procedure with the +zero-boundary remainder. +\end{enumerate} +Keep all retained clusters from all recursive generations. The +\(\CLE_4\) set exposed in the first step is not itself retained. +\end{definition} + +If this procedure is invoked above an incoming flat value \(b\) of the +original field, the CLE component has absolute label \(b+\xi2\lambda\) +and the retained split has absolute labels \(b\) and \(b+\xi2a\). +We call the holes with the nonzero jump relative to this incoming value +\(b\) \emph{odd holes}. +The use of this term in lattice explorations is consistent with the +jump decomposition proved below. + +Define +\[ + \cC^{\rm f}=\mathcal F_a(h,D). +\] +For the wired collection, first retain +\[ + C_\partial=\TVS{a}{a}(h), +\] +and apply \(\mathcal F_a\) to the zero-boundary remainder in every +complementary component of \(C_\partial\), retaining all resulting +clusters together with \(C_\partial\). Denote that collection by +\(\cC^{\rm w}\). Both constructions use the \emph{same} \(h\), including +the canonical choices of all its local sets. This defines their joint +coupling. The all-generation local finiteness needed below is proved +in \cref{cor:canonical-local-finiteness}, rather than assumed as part of the +definition. + +\begin{figure}[!htbp] +\centering +\begin{tikzpicture}[font=\small,>=Latex] + \node[draw,rounded corners=2pt,align=center,minimum width=30mm, + minimum height=12mm] (f) at (0,0) {zero-boundary field\\\(f\) in \(O\)}; + \node[draw,rounded corners=2pt,align=center,minimum width=38mm, + minimum height=12mm] (cle) at (4,0) + {\(\TVS{2\lambda}{2\lambda}\)\\CLE holes: \(\xi\,2\lambda+f_V\)}; + \node[draw,rounded corners=2pt,align=center,minimum width=38mm, + minimum height=12mm] (split) at (9,0) + {retain the split in \(V\)\\relative labels \(0,\xi\,2a\)}; + \draw[->] (f)--(cle); + \draw[->] (cle)--(split); + \draw[->] (split.south)--++(0,-.65)-| + node[pos=.3,below,align=center] + {subtract the label in each hole; restart independently} (f.south); +\end{tikzpicture} +\caption{One recursive step of the free construction. Only the split +inside a CLE hole is retained as a current cluster. For the wired +construction, the boundary set \(\TVS{a}{a}\) is retained first.} +\label{fig:free-procedure} +\end{figure} + +\subsection{Topology and the theorem} +Fix a compact square \(X\) containing \(\overline D\) and all sufficiently +fine polygonal approximations. Such a square exists by admissibility. +Let \(\mathscr H=\mathcal K(X)\) be the space of nonempty compact subsets +of \(X\), with Hausdorff metric \(d_H\), and let +\(Z=\{\{x\}:x\in X\}\subset\mathscr H\) be its singleton subspace. +A collection \(\mathcal K\subset\mathscr H\) is locally finite above +positive diameter if +\[ + \#\{C\in\mathcal K:\diam(C)>\eps\}<\infty + \qquad\text{for every \(\eps>0\)}. +\] +For such a collection put +\[ + F(\mathcal K)=Z\cup\{C\in\mathcal K:\diam(C)>0\},\qquad + d_{\rm match}(\mathcal K,\mathcal K') + =d_H^{\mathscr H}\bigl(F(\mathcal K),F(\mathcal K')\bigr), +\] +where \(d_H^{\mathscr H}\) is Hausdorff distance between compact subsets +of \(\mathscr H\). Local finiteness makes \(F(\mathcal K)\) closed: +any convergent sequence of distinct members has diameters tending to +zero and therefore has a singleton limit. Thus \(d_{\rm match}\) is a +metric after singleton members and multiplicities are ignored. + +This metric gives precisely the positive-diameter matching topology. +To make the relation with the usual description explicit, write +\(R_\eps(\mathcal K,\mathcal K')\) for the following two requirements: +\begin{align*} + &\text{every \(C\in\mathcal K\) with \(\diam(C)>\eps\) has some + \(C'\in\mathcal K'\) with \(d_H(C,C')<\eps\),}\\ + &\text{and the same statement holds with \(\mathcal K,\mathcal K'\) + interchanged.} +\end{align*} +The matching need not be one-to-one. We retain the distinguished boundary +component separately, with ordinary Hausdorff topology. + +\begin{lemma}[Matching topology and compact containment] +\label{lem:matching-topology} +As relations on locally finite collections, +\[ + \{d_{\rm match}\le\eps/2\}\subset R_\eps + \subset\{d_{\rm match}\le\eps\}. +\] +Let \(\mathfrak X\) be the compact space of closed subsets +\(F\subset\mathscr H\) containing \(Z\), and write +\(N_t(F)=\#\{C\in F:\diam(C)>t\}\). If \(t_j\downarrow0\) and every +\(M_j\) is finite, then +\[ + \{F\in\mathfrak X:N_{t_j}(F)\le M_j\text{ for every }j\} +\] +is compact and consists of locally finite collections after singleton +members are removed. Consequently, uniform tails for \(N_t\) at each +fixed \(t>0\) imply compact containment in the matching topology. +\end{lemma} + +\begin{proof} +For every \(C\in\mathscr H\), +\[ + \frac12\diam(C)\le \dist_{\mathscr H}(C,Z)\le\diam(C). +\] +The lower bound is the triangle inequality, and the upper bound follows +by choosing a singleton in \(C\). If \(d_{\rm match}\le\eps/2\), a member +of diameter greater than \(\eps\) must therefore match a positive-diameter +member of the other family within \(\eps/2\). Conversely, under \(R_\eps\) +each member of diameter at most \(\eps\) is within \(\eps\) of \(Z\), and +each larger member has the required match. This proves the inclusions. + +The hyperspace of nonempty compact subsets of a compact metric space is +compact, and the condition \(Z\subset F\) is closed. For each \(t>0\), +\(N_t\) is lower semicontinuous: any finitely many distinct members of +diameter greater than \(t\) persist in disjoint small hyperspace +neighborhoods under Hausdorff convergence. Hence each constraint +\(N_{t_j}\le M_j\) is closed. Their intersection is compact, and choosing +\(j\) with \(t_j0\). Finally, choose +the \(M_j\) so that the respective tail probabilities are at most +\(\eta2^{-j}\), and use the union bound. This proves compact containment. +\end{proof} + +\begin{theorem}[Joint critical-line limit]\label{thm:main} +For every fixed pair $J>0$, $U\le J$ with $\sinh(2J)=e^{-2U}$, +every bounded Jordan domain $D$, and every admissible polygonal +approximation as defined in \cref{sec:lattice-domains}, +\[ + \bigl(H_\delta,\cC_\delta^{\rm w},\cC_\delta^{\rm f}, + C_{\partial,\delta}\bigr) + \ \xrightarrow[\delta\downarrow0]{\mathrm{law}}\ + \left(\frac{h}{\pi\sqrt g},\cC^{\rm w},\cC^{\rm f}, + \TVS{a}{a}(h)\right). +\] +The height converges in \(H^s_{\rm loc}(D)\) for every \(s<-1\). +Each cluster collection converges in the matching topology just +defined, and the distinguished component converges in Hausdorff +topology. The continuum collections are locally finite above every +positive diameter. All convergences are joint, and the same GFF +determines both continuum collections. +\end{theorem} + +The height topology may equivalently be handled on a countable +exhaustion of \(D\) and a countable sequence of exponents increasing +to \(-1\). Our proof first obtains joint tightness, then identifies +every subsequential limit as the canonical construction of +\cref{thm:main}. This yields the full mesh limit without selecting a +preferred approximation sequence. No claim about cluster area measures, +magnetization fields, all spin-domain-wall curves, or an exact metric +exponent is part of the theorem. + +\subsection{Stopping and limiting conventions}\label{subsec:conventions} +All lattice explorations reveal endpoint spins before prescribing an +edge. An accessible chamber keeps the actual boundary connections +created by the explored configuration. At a pinch, its boundary is the +perimeter walk on the side of that chamber; unrelated interiors are +not identified merely because their closures touch. + +A \emph{pointed limiting component} is specified by a fixed interior +test point and compact subsets eventually contained in its discrete +component. Several such open components may arise from a single +discrete precursor. Statements about conditional fields in distinct +limiting components therefore include their joint independence after +the appropriate constants are removed. The needed uniform estimates +are established before local-set identification. + +Geometric scales, buffers, and diameter thresholds are fixed before +letting \(\delta\downarrow0\). Subsequently a collar width or test scale +may tend to zero, and a finite-count truncation may be removed. Rational +polygons, rational balls, and a fixed countable dense family of interior +points make all uses of these limits simultaneous. Whenever a random +domain is used, its exact cut law specifies the residual boundary class. +An estimate for the residual fields may be invoked conditionally on the +stopping data when it is uniform over that class. Estimates controlling +the production of the cut itself are instead averaged over the exploration, +conditional only on the permitted initial flat data; they are not asserted +after conditioning on a completed stopping history. + +\subsection{Proof strategy}\label{subsec:proof-strategy} +The proof first identifies the height field and then recovers the complete +current supports from the geometry coupled to that field. + +\Cref{sec:spatial} fixes one current \(N\) and its complementary spin +percolation \(W\). The exact edge factor makes an open monochromatic +\(W\) perimeter a cut with a flat residual law. Ferromagnetic comparison +then supplies circuit estimates in the permitted residual states. The +collar argument controls long passages near a rough explored boundary by +summing bridge failures over the gaps between ordered crossings. It yields +macroscopic count tails and a no-shadowing estimate after a frozen indexed +stop. For a complete prescription of every \(s\) spin and \(W\) edge in a +small region, the pattern comparison compares its probability under allowed +exterior conditions with its plane probability, with a ratio bounded +independently of the number of microscopic prescriptions. A mixed-sign +witness argument then shows that full-spin events with vanishing plane +probability also have vanishing probability uniformly under the allowed flat +laws. This is the one-way contiguity used to transfer screening. + +\Cref{sec:spectral} gives Cauchy-mixture representations of the plane +covariance in the four axial and diagonal reflection frames. At nonzero tangential +frequency \(k\), the normal Cauchy width \(s\) has defect +\(D(k,s)=((|k|-s)/(|k|+s))^2\). Fourth angular harmonics in frames differing +by \(45\) degrees cancel pointwise, making this defect integrable against +the mixing measure. For fixed \(00$. After division by the constant $t^{|E|}$, an open +monochromatic $W$ edge has weight $2$, a closed monochromatic edge has +weight $r$, and a disagreeing edge is closed with weight $1$. +Represent $2^{k(W)}$ by auxiliary colors $\rho\in\{-1,1\}$. +Summing the $W$ state on a monochromatic edge gives +\begin{equation}\label{eq:spatial-ferro-factor} + r+2\ind_{\{\rho_i=\rho_j\}} + =r+1+\rho_i\rho_j. +\end{equation} +Consequently the $s$ marginal is the product of a positive factor +$(1+r)^{|E_{\rm mono}|}$ and the even-subgraph partition functions on +the two monochromatic induced graphs, with edge parameter +$q=(1+r)^{-1}\in(0,1)$. + +For completeness, let $Z_F(A)$ denote such an even-subgraph partition +function on an available edge set $A$, with ferromagnetic +identifications $F$ retained. It is increasing and log-supermodular in +$A$. One way to see both facts is to write it as +the zero-field ferromagnetic Ising partition function divided by its +single-edge $\cosh$ factors. Adding an edge multiplies the normalized +partition function by $1+q\E[\rho_i\rho_j]$. The expectation is +nonnegative and increases when other nonnegative couplings are added, +by the two Griffiths inequalities \cite{Griffiths1967I}; a complete +proof for nonnegative couplings is given in +\cite[Section~3.8.1, Theorem~3.49]{FriedliVelenik2017}. +Indeed differentiating an expectation with respect to a coupling gives +the corresponding nonnegative covariance. Identifications are limits +of positive bonds: after dividing by the common maximal exponential, +the finite-state factor is $e^{-2K D_F}$, where $D_F$ counts violated +identifications. As $K\to\infty$ it tends to their joint indicator. +Thus the same inequalities survive the finite-state limit. The +single-edge factors cancel from the mixed inequality, proving +\[ + Z_F(A\cup B)Z_F(A\cap B)\ge Z_F(A)Z_F(B). +\] +The same incremental-edge formula gives the boundary comparison that +will be needed below: if $A\subseteq B$ and $F\subseteq F'$, then +\begin{equation}\label{eq:spatial-mixed-gks} + Z_{F'}(B)Z_F(A)\ge Z_{F'}(A)Z_F(B). +\end{equation} +Indeed each multiplier $1+q\E[\rho_i\rho_j]$ increases when the bonds +implementing $F'$ are added. Integrating the Griffiths covariance +inequality and then taking their infinite-bond limits proves +\eqref{eq:spatial-mixed-gks}. +For plus vertex sets $S,T$, +$E(S\cap T)=E(S)\cap E(T)$ and +$E(S\cup T)\supseteq E(S)\cup E(T)$. +Apply the preceding inequality and monotonicity to both the plus and +minus induced graphs. The factor $(1+r)^{|E_{\rm mono}|}$ is itself +ferromagnetic. This proves the spin lattice condition, to which the +finite association and comparison theorems +\cite{FortuinKasteleynGinibre1971,Holley1974} apply. + +Conditional on $s$, the open edges on each monochromatic graph have +the ordinary random-cluster law with cluster weight $2$ and edge +weight $v=2/r$. Given the other edges, its opening probability is +$v/(v+2)$ if the endpoints are disconnected and $v/(v+1)$ if they +are already connected. The probabilities increase with the available +connections, so common-uniform edge updates give the edge comparison. +Together with the spin lattice +condition, this gives positive association and the order +\eqref{eq:spatial-order}. Fixed closed edges with prescribed endpoints +give constants; fixed open edges give ferromagnetic identifications. +Thus the same argument applies after all the allowed prescriptions. +The ordered-wiring comparison follows from +\eqref{eq:spatial-mixed-gks} for plus identifications and its reflected +version for minus identifications. In particular, +arbitrarily shaped exterior connections cannot be silently discarded. + +Use these conditional comparisons at each step of a simultaneous +exploration, always preserving each configuration's residual +conditional law. A plus circuit in the lower configuration is also +open plus in the upper. By \cref{lem:finite-cuts}, the laws on the +sealed side then have the same constant boundary spin and no +transverse interaction across the circuit. Couple those laws +identically. No $N$ component crosses the cut, so its free colors may +also be coupled identically. The minus case is the reflected argument. +\end{proof} + +There is also a useful bounded comparison when monotonicity is not the +issue. Suppose two local conditional weights have exactly the same +available edges, pins, and local edge factors, and differ only in the +partition of $k$ prescribed same-color source labels. Each label may +have many boundary contacts, which are kept identified in both laws. +For every configuration the two component counts differ by at most +$k-1$. After normalization, \eqref{eq:spatial-euler} therefore gives +\begin{equation}\label{eq:spatial-wire-density} + 2^{-2(k-1)}\le \frac{\dd\mu_\xi}{\dd\mu_{\xi'}} + \le 2^{2(k-1)} \qquad (k\ge1). +\end{equation} +This statement does not permit a single source to be split into its +many visible entrances, nor a change of local edge factors. A wire in +this calculation is an identification in a probability law, not a +geometric edge along which a circuit may travel. + +At fixed mesh these conclusions also apply to bounded searches in the +plane. Apply them first in finite flat exhaustions and take a joint +subsequential limit of the configurations and of the finite search +transcripts. The limit is the common plane law obtained from flat +exhaustions in \cite[Theorem~17.1]{DKLM2026}. Equality on the sealed side +of a common +cut holds on every finite subset and hence on the whole countable +lattice in the limit, including the complementary colors. That theorem +also gives no unbounded complementary component and the fair color law +there. A failed circuit search stops at its prescribed buffer boundary; +it never conditions the residual law on a future success. + +\subsection{Buffered circuits and rough walls} + +We specify the geometric completion used when a test window meets a +removed region. A face of the $W$ lattice is centered at a vertex of +the dual $N$ lattice. For a revealed set of $N$ vertices and seed edges, +take the union of these closed faces and the faces along the seed. We +call this its \emph{source cell region}. It is within $O(\delta)$ +of the drawn revealed graph. Holes occupied by unsearched chambers are +retained; this operation does not fill the hull of a cluster. Its +resolved complementary chambers and the medial perimeters above differ +by $O(\delta)$, including at pinches. + +Let $F$ be such a removed cell region and $U$ an accessible component. +Suppose every frontier edge between $U$ and $F$ is a prescribed open +$W$ edge of one color $\sigma$. Define the \emph{augmented matching +graph} in a test window to consist of the actual $W^\sigma$ edges on the +accessible side and artificial matching $W$ edges contained in $F$. +The artificial edges are the lattice one-skeleton of the cell region; +the frontier edges themselves retain their actual prescribed states. +A circuit in this graph is an ordinary geometric circuit in the +window. It may use the artificial edges inside $F$. An underlying dual +path disjoint from $F$ cannot cross it without crossing an actual +$W^\sigma$ edge. In particular, an abstract remote wire is never used +as a geometric edge of this circuit. + +There are two exact uses of this construction. For one component $U$, +complete each removed source on its other side by matching spins and +open edges. Keep the original conditions on any other boundary of $U$. +The frontier factors in \eqref{eq:spatial-edge-weight} are constants +$t$ with no transverse interaction. Integrating the removed variables +therefore shows that the $U$ marginal of this completion is exactly its +original conditional marginal. This remains true when $U$ has several +boundary components, provided all the completed frontiers have the +stated color and the test windows avoid any other prescribed pieces. + +For the second use, suppose the residual chambers are the disjoint +complementary components of one common connected source cell region +$F$ attached to the exterior. Conditional on an exact cut history they +have a product of flat laws. Reflect $s$ in each chamber, if needed, so +that all its frontier spins have one color $\sigma$, and put matching +spins and open edges in $F$. The same factorization realizes exactly +this product as the accessible marginal of a single completed graph: +every factor on the removed side cancels on normalization. There is no +factor +depending on the number of chambers. We call this the +\emph{product class with a common fill}. It includes the chambers behind +an exposed wired layer +and subsequent composite seed explorations. An arbitrary collection of +independent chamber copies is not asserted to have such a realization. +Finally, when a completion changes only a partition of $k$ indivisible +source labels while preserving all local factors and pins, the comparison +\eqref{eq:spatial-wire-density} gives the stated bounded substitute for +exact equality. These are the only completion rules used below. + +\begin{proposition}[Buffered circuits and attached-wall bounds] +\label{prop:circuits} +Fix positive aspect and buffer ratios. There are $p>0$ and a fixed +lattice cutoff $c_*>0$ with the following properties, uniformly for +every physical test radius $r\ge c_*\delta$ and every mesh. Test +neighborhoods must lie in the ambient domain, apart from matching +cell regions to which one of the preceding completion rules applies. +\begin{enumerate} +\item In a buffer containing no pins, a circuit of either prescribed +$W$ color in a fixed-aspect annulus has probability at least $p$, +conditional on arbitrary admissible $(s,W)$ data outside the buffer. +Compatible pins of the requested color inside the buffer only improve +the bound. Finite chains of overlapping circuit tests give a positive +lower bound for a fixed-aspect tube connection. +\item After any admissible $(s,W)$ stopping exploration, failure of +matching circuits on $m$ separated available scales has probability +at most $(1-p)^m$, when each scale is chosen from the current history +before its interior is examined. In particular, suppose a prescribed +connected +matching wall reaches from $B(z,r)$ to outside $B(z,R)$, with a fixed +buffer around $B(z,R)$. A path avoiding that wall and all attached +matching circuits, and joining $B(z,r)$ to outside $B(z,R)$, has +probability at most +\begin{equation}\label{eq:spatial-attached-arm} + C\left(\frac{r+\delta}{R}\right)^\alpha +\end{equation} +for some $C,\alpha>0$. +\item When a test buffer meets $F$, the circuit and tube events mean +circuits and connections in the augmented matching graph just defined. +They have the same lower bounds under the exact completion of one +component or the exact completion with a common fill. A circuit +attached to $F$ blocks an accessible dual path by its actual part +together with the forbidden region $F$. +If only the $k$-label comparison is available, the probability bounds +lose at most $2^{O(k)}$ in total. The number of local entrances of one +label does not enter this cost. +\end{enumerate} +The bulk assertion in item~1 also holds before removing the model's +single wired $N$ component. Conditioning in a search concerns $(s,W)$; +an exact cut history with exterior colors is allowed because its +accessible marginal is already a fresh flat kernel. +\end{proposition} + +\begin{proof} +The imported input is \cite[Theorem~16.4]{DKLM2026}: for +$\mathbf c=1/t\in[1,2]$, an opposite-color spin-percolation circuit in +a lattice annulus of radius at least $4$ has a positive lower bound, +uniform in its radius, under the worst constant wired boundary +condition. The decoration in that theorem opens an ambiguous edge +with probability $1/\mathbf c=t$, so it is precisely $W$. Its +exterior-conditioning version, \cite[Corollary~16.6]{DKLM2026}, +allows arbitrary data of the same spin parity and its edges outside +the buffered ball. We only use this statement for one parity. Its +conditional FKG hypotheses agree with \cref{prop:comparison}. + +After the fixed change from source lattice units to physical units, +the lower bound holds for $r\ge c_*\delta$. Comparison with the worst +constant boundary condition gives item~1 for squares; a fixed finite +cover gives the other stated aspect ratios and the tube version. +Intersect its matching circuit events by positive association. +Matching pins are favorable in \eqref{eq:spatial-order}. In the +wired $N$ law before removal, fixing the single wired $d$ color removed +the geometry-independent factor $2$ in the proof of +\cref{prop:comparison}. Its $(s,W)$ comparison is therefore the same. +For the unpinned bulk test, choose a deterministic circuit in the +unused part of the buffer between the annulus and the buffer boundary. +Compare to the law with that circuit pinned to the worst $W$ color. +Its sealed side is a $W$-flat kernel by \cref{lem:finite-cuts}, so +the same lower bound applies there despite the arbitrary data beyond +the buffer. Requested-color pins are then handled by monotonicity. +This proves the claimed wired bulk case. + +For separated scales, reveal earlier trial neighborhoods before +testing the next one. The conditional failure probability remains +at most $1-p$, so multiplying conditional bounds proves item~2 +without an independence assumption. Take a geometric sequence of +scales between $r+\delta$ and $R$, separated enough to have disjoint +buffers. A circuit at one such scale meets the wall because the wall +crosses the annulus. It separates the inner from the outer scale. +This gives \eqref{eq:spatial-attached-arm}; the $\delta$ term absorbs +the finitely many scales below the lattice cutoff. + +For item~3, apply item~1 in the completed graph. All additional pins +in a test buffer have the requested matching color. The exact +accessible marginal or \eqref{eq:spatial-wire-density} transfers the +event to the original law. In this transfer an edge of the circuit +inside $F$ is explicitly artificial; every other edge of it is an +actual matching edge. Thus a full circuit is available even when an +accessible side is slit and has no full circuit by itself. The +geometric blocking assertion follows from the definition of the +augmented graph. For a connected source the boundary incident to one +fixed complementary component is one boundary walk. It can enter the +window arbitrarily often, but these entrances form one retained label. +This verifies exactly the premise on labels when that bounded +comparison is used. +\end{proof} + +A useful consequence concerns a stopping set selected using revealed +colors. Under the preceding flat kernel, if a cluster meeting a seed +at distance at least $R$ from $B(z,r)$ reaches that ball, there is an +$N$ arm from $B(z,r)$ to outside $B(z,R)$. Testing the $W$ annuli in +that preceding $(s,W)$ marginal bounds this event by +\eqref{eq:spatial-attached-arm}, regardless of the later rule selecting +the cluster. Similarly, before revealing discovered colors, reaching a +ball before a fixed number of odd rims entails failure to find that +many alternating pairs of $W$ circuits on the intervening scales. +Conditional iteration gives a bound of the same polynomial form, with +an exponent depending on the fixed number of rims. These are averaged +bounds under the prior kernel. They are not bounds conditional on each +completed stopping history containing colors. The same observation after +exposing a wired layer uses its fresh product of flat kernels, and the +bulk wired assertion handles the initial layer itself. + +We next turn the circuit bound into an estimate for a whole collar. +A \emph{window} consists of a working rectangle $R$, a fixed intermediate +enlargement $R^+$, and a larger rectangular buffer, with positive gaps +between them. A traversal test is a path in $R$ from left to right, +staying a fixed distance from its top and bottom, or a rotated copy of +this test. A local wall piece is a component of the cell region +restricted to $R$; pieces joined only outside $R$ remain distinct +locally. We say the region is \emph{anchored} if every component in +the buffer meeting $R^+$ reaches the buffer boundary inside the cell +region. This holds when the region is connected to an exterior seed +outside the buffer. Pieces that touch are treated as one; otherwise the +medial +lattice convention separates their representative paths by lattice +order. Write $F^\eta=\{z:\dist(z,F)\le\eta\}$. + +\begin{lemma}[Uniform collar exclusion]\label{lem:collar} +Fix a finite family of such windows and traversal tests. Let +$F_\delta$ be a prescribed matching cell region of color +$\sigma$, anchored in each test. Use one of the following conditional +laws: one actual flat chamber; one selected accessible component facing +at most $k$ connected prescribed sources, with all completed frontiers +of color $\sigma$; or the product class with a common fill. In the second +case +$k$ is fixed and any partition change must satisfy the premise of +\eqref{eq:spatial-wire-density}. Test buffers contain no other pins. +There is no bound on the number of local pieces of one source. + +Consider paths in the full underlying dual graph, whether or not their +edges are $N$-open. Let $\mathcal X_\delta(\eta)$ be the event that such +a path makes one of the prescribed traversals, lies in +$F_\delta^\eta$, and is disjoint from $F_\delta$ and from every +augmented matching circuit in the buffer which is attached to +$F_\delta$. Then, uniformly over the stated walls and positive +probability allowed histories, +\begin{equation}\label{eq:spatial-collar-limit} + \lim_{\eta\downarrow0}\limsup_{\delta\downarrow0} + \sup \P[\mathcal X_\delta(\eta)]=0. +\end{equation} +An exact cut history may contain colors on its removed side; the +residual search law has the meaning specified above. It is never +conditioned on arbitrary interior $d$ colors. + +The same estimate applies simultaneously to paths constrained to lie +in any closed disk bounded by an actual opposite-color $W$ loop, if +that disk is disjoint from $F_\delta$. Such a path automatically avoids +every matching circuit attached to $F_\delta$. The windows and their +buffers may all be chosen inside an open annular band. In particular, +\eqref{eq:spatial-collar-limit} holds along every deterministic +sequence $\eta_\delta\downarrow0$. +\end{lemma} + +\begin{proof} +These tests detect every connected passage of a fixed positive +diameter $b$ in a fixed box. Choose an inner square of side a small +fixed multiple of $b$ from a fixed grid around one endpoint, and +stop the connecting path on its first exit from a larger square +of diameter less than $b/2$. The exit side fixes an orientation, and +a fixed enlargement of the vertical extent gives a traversal with +the required margin. There are finitely many grid squares and +orientations. Their working rectangles, intermediate enlargements, +and buffers are all chosen before applying the lemma; anchoring is +required on those intermediate enlargements. The same construction +inside an open band detects a full traversal of the band. + +It suffices to prove one left-to-right test. Use the crossing segment +from the last left-side hit before its first right-side hit, and then +erase loops. The result is a simple proper crosscut: its interior +misses both vertical sides. +This trimming is needed because a simple path that returns to its +starting side can leave a third pocket. A proper crosscut has just a +lower and an upper side. Every local obstacle piece disjoint from it is +assigned to one of those sides. Include the top and bottom as virtual +barriers, which the traversal margin already forbids. +Here the pieces are components after restriction to this working +rectangle. Connections outside it retain their wire labels in the +law but do not identify pieces on opposite sides of an endpoint. + +We first reduce these assignments, except for a uniformly small event, +to a fixed finite number of possibilities. An anchored piece meeting +a narrower central rectangle contains a path to the boundary of the +working rectangle: take the part of an anchored path up to its first +exit. A piece reaching the top or bottom is already assigned to that +barrier. For a piece reaching the left, in the fixed-width left end strip, +retain a segment from its last hit of the outer vertical to its first +hit of the inner vertical and erase loops. It is a proper crosscut of +that strip. Make a deterministic choice if a piece has +several such paths. Representatives of distinct pieces are disjoint +and can be ordered from bottom to top. The analogous construction is +used at the right side and in the rotated windows. Connections of a +piece between different +sides later impose consistency; they add no choices. + +Here is the quantitative reduction in one end strip. Choose a middle +horizontal interval $I$ of length $\ell>0$ and take $\rho>0$ below +both its horizontal clearance from the vertical ends and the fixed +clearance of $R$ inside the larger window buffer. For consecutive +representative arms, let $g_j(x)$ be the difference of their topmost +intersection heights with the vertical at $x$, and put +$d_j=\ell^{-1}\int_I g_j(x)\,\dd x$. These heights have the same +order as the arms: the upper crosscut separates the lower one from the +top of the strip, so a vertical ray from the top to the topmost point +of the lower one first meets the upper one. The arms need not be +graphs. In particular, +\begin{equation}\label{eq:spatial-gap-sum} + \sum_j d_j\le H, +\end{equation} +where $H$ is the fixed strip height. The set +$E_j=\{x\in I:g_j(x)\le2d_j\}$ has length at least $\ell/2$. + +At lattice scale the separation convention gives $d_j\ge a_0\delta$ +for a fixed $a_0>0$. Put $h_j=d_j+\delta\le\beta d_j$, and choose a +fixed large $K$ so that $2Kh_j$ exceeds the cutoff in +\cref{prop:circuits}. If $4K\beta d_j<\rho/2$, a maximal selection of +points in $E_j$ at horizontal separation greater than $16Kh_j$ has +at least $\ell/(64K\beta d_j)$ points, up to a fixed endpoint loss. +Center a disk at the midpoint of the two arm intersections at each +selected point. Both arms meet its radius-$2Kh_j$ disk and leave its +radius-$4Kh_j$ disk, since they continue to the strip ends. The +radius-$8Kh_j$ buffers are disjoint by construction. Since +$8Kh_j<\rho$, they stay inside the allowed window buffer and lie +between the end strip's vertical sides. Every augmented matching +circuit in the intervening annulus meets both proper arms. Orient such +a circuit, stop at its first upper-arm hit after a chosen lower-arm hit, +and retain the arc from +its last preceding lower-arm hit. Its interior misses both arms. +The two proper arms divide the infinite vertical strip into lower, +middle, and upper components. Only the closure of the middle component +meets both arms, so the arc's connected interior lies in that component. +Its closure is contained in the finite end strip. The retained arc +therefore joins the arms geometrically inside the end strip, even if +the rest of the circuit extends beyond its horizontal sides. In +particular, a remote wire alone is not counted as the joining connection. + +Successive conditional circuit tests in the completed graph, followed +when needed by the single density comparison +\eqref{eq:spatial-wire-density}, now give +\begin{equation}\label{eq:spatial-gap-failure} + \P[\text{the two arms have no such local joining circuit}] + \le C_k\exp(-c/d_j). +\end{equation} +Here and below $C_k$ is the fixed density factor for the allowed +completion; it is an absolute constant for either exact completion, +including the product class with any number of chambers. +Gaps too large for the preceding packing are simply retained. The +locations of all tests depend only on the prescribed obstacles, not +on the sought traversal. If a matching circuit joins two arms, an +avoiding crosscut cannot assign them to opposite sides. + +For any $u>0$, the total probability lost by discarding the gaps +$d_j\le u$ is at most +\begin{equation}\label{eq:spatial-gap-union} + \sum_{d_j\le u} C_k e^{-c/d_j} + \le C_k\left(\sum_jd_j\right) + \sup_{0=Latex] + \draw[gray] (0,0) rectangle (6,4); + \draw[densely dashed,gray] (1,0)--(1,4) (5,0)--(5,4); + \draw[very thick,teal!70!black] plot[smooth] coordinates + {(0,0.8) (1,1.15) (2,0.9) (3,1.35) (4,1.0) (5,1.2) (6,0.9)}; + \draw[very thick,teal!70!black] plot[smooth] coordinates + {(0,2.7) (1,2.35) (2,2.55) (3,2.1) (4,2.45) (5,2.3) (6,2.7)}; + \draw[teal!60!black,densely dashed] (2,1.72) circle (0.65); + \draw[teal!60!black,densely dashed] (4.1,1.73) circle (0.65); + \draw[<->] (3,1.38)--node[right,fill=white,inner sep=1pt] {$g_j(x)$} + (3,2.08); + \node at (3,-0.35) {local annuli join ordered arms}; + \begin{scope}[xshift=7.5cm] + \draw[gray] (0,0) rectangle (6,4); + \draw[very thick,teal!70!black] plot[smooth] coordinates + {(0,0.6) (1,0.9) (2,0.75) (3,1.05) (4,0.8) (6,0.65)}; + \draw[very thick,teal!70!black] plot[smooth] coordinates + {(0,3.45) (1,3.1) (2,3.3) (3,3.0) (4,3.25) (6,3.4)}; + \draw[very thick,orange!80!black] (3,1.42)--(3,2.63); + \draw[teal!60!black,densely dashed] (3,1.05) circle (0.5); + \draw[teal!60!black,densely dashed] (3,3.0) circle (0.5); + \draw[blue!65!black,thick,->] (0,2.0).. controls (1.0,1.7) and + (1.7,2.25)..(2.45,2.05); + \draw[blue!65!black,thick] (3.55,2.05).. controls (4.3,1.85) and + (5,2.2)..(6,2.0); + \node[anchor=south west,inner sep=1pt] at (3.5,2.18) {$K_m$}; + \node at (3,-0.35) {a lower--upper connector blocks a crosscut}; + \end{scope} +\end{tikzpicture} +\caption{The two geometric steps in collar exclusion, drawn +schematically. Representative arms can double back; their topmost +vertical encounters remain ordered. The dashed matching circuits are +local geometric circuits, with any artificial part contained in the +forbidden cell region. In the right panel the compact gap segment +$K_m$ is forbidden to a sufficiently thin collar.} +\label{fig:spatial-collar} +\end{figure} + +We finish by a compactness argument, keeping its choices deterministic. +If \eqref{eq:spatial-collar-limit} failed, there would be deterministic +allowed histories and walls at meshes $\delta_n\downarrow0$, widths +$\eta_n\downarrow0$, and a fixed positive lower bound for the traversal +probability. First fix $u$ so that \eqref{eq:spatial-gap-union}, summed +over the sides, is less than one quarter of that bound. One of the +finitely many surviving rank choices then has a fixed positive event +mass along a subsequence. We do not condition the law on that event. +Take Hausdorff limits, in the central buffered rectangle, of the +unions assigned below and above, including the virtual barriers. + +Suppose first that the two limits touch there. Unless a virtual +barrier is involved, there are deterministic points on two +oppositely assigned pieces at distance $r_n\downarrow0$. Anchoring +makes both pieces cross the annuli from scale $r_n+O(\delta_n)$ to +a fixed outer scale. Any augmented matching circuit in such an +annulus joins them. By \eqref{eq:spatial-attached-arm}, the probability +of a traversal with this assignment tends to zero. If one limiting +piece is a virtual barrier, the fixed traversal margin rules out +the opposite assignment: a connected piece reaching that margin +lies on the barrier's side of the proper crosscut. + +It remains that the two closed limits are disjoint in the central +rectangle. On a central vertical line choose a consecutive lower +encounter $a$ and upper encounter $b$. Such a transition exists +because the virtual bottom and top have those assignments. The open +segment $(a,b)$ misses both limiting unions. Fix an integer $m$. +At each actual endpoint choose $m$ separated circuit radii, all less +than $|a-b|/8$ and the available buffer clearance; call their smallest +radius $r_m>0$. If both endpoints are virtual, take any fixed +sufficiently small $r_m$ in their traversal margins instead. +Only after this choice, trim the gap by less than $r_m/2$ at its +ends and call the remaining compact segment $K_m$. +It has positive distance from the whole limiting obstacle union, not +just from its intersections with the vertical. This clearance holds +for the discrete obstacles for all large $n$, and then +$K_m\cap F_{\delta_n}^{\eta_n}=\varnothing$. + +Center the endpoint tests at discrete points converging to $a$ and +$b$. An attached circuit at any of the chosen radii meets $K_m$: +it surrounds its center, and the ray into the gap crosses the circuit +between that radius and twice that radius. Its other intersection is +with the endpoint's anchored piece. For a virtual endpoint the short +segment in the fixed traversal margin supplies the connection instead. +Consequently a successful endpoint circuit at each actual endpoint, +together with $K_m$, is a connected set from a lower-assigned piece +or barrier to an upper-assigned one, wholly in the rectangle. Every +proper left-to-right crosscut with that assignment meets this set. +It cannot do so: it avoids the pieces and the attached circuits, and +the collar condition excludes $K_m$. + +For fixed $m$, the probability that either required endpoint +connection fails has limit superior at most +$2C_k(1-p)^m$, by the separated-scale estimate and, if needed, one +density comparison. Letting $m$ increase contradicts the retained +positive event mass. The order of choices here matters: the finite +endpoint radii precede the trimmed segment, so every requested +circuit really reaches that segment. This proves uniformity in +\eqref{eq:spatial-collar-limit}. + +Finally let a closed disk be bounded by an actual $W^{-\sigma}$ loop +and disjoint from $F_\delta$. A connected augmented matching circuit +attached to $F_\delta$ cannot enter this disk. Its artificial edges +are in $F_\delta$, outside the disk, and its actual $W^\sigma$ edges +cannot cross or share a vertex with the opposite-color boundary. +A dual path inside the disk therefore automatically avoids all those +circuits. The existence event already ranges over every underlying +dual path, so the bound holds simultaneously over the possible disks, +without conditioning on a future choice of one. Choosing all the +windows with fixed margin inside an open band gives the last +localization assertion. Monotonicity in $\eta$ gives the conclusion +for $\eta_\delta\downarrow0$. +\end{proof} + +\subsection{Counts and comparison of complete patterns} + +\begin{proposition}[Cluster and transmission counts] +\label{prop:cluster-counts} +The following bounds hold in fixed buffered boxes, uniformly in the +mesh and in allowed conditional histories. A joint count of actual +clusters across chambers in items~1 and~3 requires the product class +with a common fill. Item~2 has the interior scope stated there. +\begin{enumerate} +\item For fixed $b>0$, the number of unsearched free $N$ clusters +having a connected passage of diameter at least $b$ in a fixed box +has an exponential tail. Its constants depend on $b$ and the fixed +box geometry, not on the roughness of the surrounding walls or on +the number of chambers in the realization with a common fill. +\item For one chamber, let a lattice-aligned rectangle and its joining buffer lie +wholly in the unprescribed accessible interior. Use the relative dual +restriction with separate side ports defined in the proof. The number of distinct +components of the restricted $N$ graph crossing between two specified +opposite sides has a geometric tail. Consequently, if +$Q_0\Subset Q_1$, the number of restricted components in $Q_1$ +which meet $Q_0$ and a vertex incident to an edge outside the +restriction has a geometric tail, provided the fixed covering +rectangles in $Q_1\setminus Q_0$ and every joining buffer have the +same unprescribed interior clearance. Arbitrary admissible $(s,W)$ +prescriptions outside a larger buffer are allowed. The same interior +assertion holds in the original wired law before removal of its +boundary cluster. +\item Counts of distinct free $N$ clusters of the residual kernels +enclosing or passing through a fixed +aspect-ratio annular shell have moments of every fixed order, uniformly +after rescaling the shell down to lattice order. Under a stopping +history these are the unsearched clusters. A distinguished wired +cluster adds at most one. For arbitrary +independent chambers with pairwise disjoint interiors this last +statement is available separately in each chamber; it asserts no +bound for their total count without a common fill. The precise +no-shadowing consequence at indexed discoveries is stated in +\cref{cor:indexed-no-shadowing} below. +\end{enumerate} +\end{proposition} + +\begin{proof} +For item~1, start with the connected cell region of the given +exact cut history; for a single flat chamber use its exterior side. +Explore with a deterministic connected seed attached to that region. +Add one seed vertex at a time and immediately reveal the entire +previously undiscovered $N$ cluster it meets. The seed eventually +visits every vertex of the box. Record only discoveries with the +specified passage, choosing one such passage by a deterministic rule. +At every recorded stop, the initial region, seed, and all clusters +already discovered form one connected cell region. By +\cref{lem:finite-cuts}, the residual laws are exactly the flat +kernels, jointly in the class with a common fill when there are several +chambers. + +A finite family of smaller collar windows detects every passage +of diameter at least $b$. Freeze the cell region $F_i$ at the +$i$th recorded stop, with $F_0$ the initial region, before continuing +the search. An actual unsearched $N$ path is disjoint from $F_i$ and +cannot cross the actual part of an augmented matching circuit. +Thus \cref{lem:collar} gives an $\eta>0$ such that, conditionally on +any such frozen history, the probability that \emph{some} still +unsearched qualifying passage lies wholly in $F_i^\eta$ is at most +a fixed $p<1$. This event is existential over future passages; no +future location or visibility is conditioned upon. It also bounds +the event that the next recorded cluster exists and its selected +passage lies wholly in $F_i^\eta$. + +On the complementary event, the next passage contains a point at +distance greater than $\eta$ from $F_i$. Such points from successive +records are mutually $\eta$-separated, because each earlier cluster +is included in every later frozen region. A bounded box contains +at most $M=M(\eta)$ such points. There is no cost for the number +of intervening microscopic discoveries: they only enlarge the same +connected region. In the product case reflect the residual chamber +spins to one matching color and use the exact realization with a common fill +for this single existential collar event. In particular, no union +bound over the number of holes is taken. A test buffer meeting the +initial wall is covered by the same augmented graph. + +If at least $n$ records occur, at most $M$ of the first $n$ can be +of the separated-point kind. Conditional iteration for the other +indices, including the initial stop, gives +\begin{equation}\label{eq:spatial-count-tail} + \P[\text{at least }n\text{ recorded discoveries}] + \le \sum_{j=0}^{M}\binom{n}{j}p^{\,n-j} + \le C e^{-c n}. +\end{equation} +The same proof starting from a later allowed stop bounds its +unsearched count. It does not bound the number already fixed +by that history. Meshes above the small threshold used by the collar +lemma are absorbed by the deterministic number of vertices in the +fixed box. + +For item~2 we use a crossing exploration followed by a finite-domain +boundary comparison. +First fix the relative planar dual of the given restricted $N$ +lattice quadrilateral. Its medial boundary follows the four sides +of the rectangle. In the auxiliary $W$ graph, truncate a dual edge +at that boundary when it exits, and give each boundary incidence +its own degree-one port. There are no edges in an exterior side +column and no identifications between distinct ports. Every retained +edge or half-edge inherits the state of its actual $W$ edge. This is the matched dual +restriction used for every $W$ connectivity test below; its +placement differs from the geometric rectangle by $O(\delta)$, +which is absorbed by the joining buffer. + +If $J_N$ distinct restricted $N$ components cross the quadrilateral, +choose one simple crossing in each, ordered from bottom to top. +Between each two successive crossings, relative planar duality gives +a parallel open crossing of this matched $W$ graph. The separators +in two successive gaps belong to different components of that graph: +a connection inside it would cross the intervening $N$ path, and +the separate ports give no route around an endpoint. Consequently +\[ + J_N\le J_W+1, +\] +where $J_W$ counts crossing components in precisely the matched +$W$ graph. The probabilistic search uses only these $W$ crossings; +it never certifies a separator against an unrevealed upper $N$ crossing. + +Distinct $W$ crossing components have a consistent vertical order: +one component cannot have crossing paths on both sides of another, +because its joining path would cross the latter. In each component +choose a lowest simple proper crossing, with a deterministic tie +rule; the lower boundary of the union of its crossing paths supplies +such an open crossing. Enumerate these representatives from below, +with all connectivity restricted to the matched graph. +For a candidate $\gamma$, the event that it is the next distinct +crossing is determined by the $(s,W)$ configuration in its closed +below envelope. All lower candidate crossings lie there, and any +connection from a lower component to $\gamma$ first meets $\gamma$ +from below. A proposed connection between lower pieces through the +region above $\gamma$ would first join $\gamma$ as well. This is +the stopping-line property for the enumeration. + +After selecting $\gamma$, reveal its whole closed below envelope, +with endpoint spins before edge states. Reflect the colors if necessary +so that $\gamma$ is plus. We use test rectangles with sides parallel to +the coordinate axes of the $W$ lattice; the primal and dual square +lattices have the same axes. Complete only the two endpoint half-edges +of $\gamma$ to their actual $W$ edges. Their states are already known: +each half-edge inherited the state of that actual edge, and its being +open forces the additional endpoint to have the same spin. Thus this +operation assumes no unexamined connection. The actual endpoints of all +left-exiting half-edges lie on one $W$-lattice column, and the analogous +statement holds on the right. Let $B$ have these two columns as its +lateral boundary and extend its top and bottom a fixed distance into +the unprescribed joining buffer. The completed $\gamma$ is a proper +crosscut of $B$: its only vertices on the lateral boundary are its two +endpoints, because the matched graph contains no exterior side-column +edges. Write $U_\gamma$ for the component above this crosscut and +$F_\gamma$ for the closed region below it. All the earlier crossing-search +transcripts in $B$ are below $\gamma$. + +Analytically disintegrate the conditional law over the entire +configuration outside $U_\gamma$, including the unused parts of the +buffer, and over its boundary contact spins before interface edge +states. This extra disintegration is used only for the estimate; it is +not added to the next search transcript. On every positive exterior +fiber the finite weight on $U_\gamma$ is the weight of +\cref{prop:comparison}, with the exterior same-color connections +retained. All contacts on $\gamma$ are plus and belong to a single +class, since $\gamma$ itself is open. The other contacts lie on the +upper boundary arc of $B$. + +Replace this fiber's boundary condition by the following adverse one. +Keep $\gamma$, including its endpoints, plus and open. Make all other +contacts on the upper boundary arc minus and wire them together; retain +only the one plus class supplied by $\gamma$. The two boundary edges +at a change of spin are closed. This is an ordered decrease for the +plus order: it retains every required lower plus connection, removes +only additional plus connections, and merges all remaining minus +connections. Changes of contact spins and their compatible incident +edge states use the same order. Therefore the original fiber dominates +this fixed adverse law on $U_\gamma$, by \cref{prop:comparison}. +In particular, no event belonging to the original history has been +removed from a conditional probability. + +Realize the adverse law on the full box $B$ by filling $F_\gamma$ +with plus spins and open $W$ edges, including the lower outer boundary +arc, while keeping the upper outer boundary arc minus and wired as +above. Every edge of the separating crosscut remains an actual open +plus edge. The finite edge factors in \eqref{eq:spatial-edge-weight}, +or equivalently the component-count formula in +\eqref{eq:spatial-euler}, show that this completion has exactly the +adverse law as its $U_\gamma$ marginal: factors on the filled side +cancel, the plus contacts form one class, and the other boundary +contacts form the one minus class. There is no factor depending on +the length or roughness of $\gamma$. + +The completed law is obtained from the law in $B$ with the worst +constant minus wired boundary by increasing the lower boundary data +and imposing compatible plus pins in $F_\gamma$. +\Cref{prop:comparison} therefore makes it dominate that constant-boundary +law for every increasing plus-circuit event. The ordinary buffered +circuit estimate used in \cref{prop:circuits}, namely +\cite[Theorem~16.4]{DKLM2026}, now gives a uniform positive lower +bound for each circuit test in a fixed central strip of $B$. +In transferring a circuit to $U_\gamma$, edges in $F_\gamma$ are +artificial matching edges; all its other edges are actual plus edges. +The estimate holds on every original exterior fiber, so averaging +over those fibers preserves the same lower bound. This argument uses +only the ordinary full-circuit estimate, not the arbitrary-history +partial-circuit assertion of \cite[Lemma~19.4]{DKLM2026}. + +Choose a fixed chain of buffered circuit tests in this central strip, +starting below the counted rectangle and ending above it. All test +buffers stay away from the lateral sides of $B$, and their number +depends only on the fixed aspect and buffer ratios. The usual tube +gluing from \cref{prop:circuits}, followed by positive association in +the completed law, gives a uniform positive probability $p$ that +the augmented matching graph joins the filled lower part to above +the rectangle. This tube event is increasing, so the same boundary +comparison and fiberwise averaging give probability at least $p$ +under the original search history. Its last exit from $F_\gamma$ +is on $\gamma$ in the central strip. From there until its first exit +through the top of the counted rectangle the connection is actual +and lies in the matched graph. A later parallel crossing of the +same color would meet this connection and hence join $\gamma$ +inside that graph, whereas a crossing of the opposite color cannot +cross it. The tube therefore rules out another distinct $W$ +crossing. + +These tube tests are used to bound the conditional probability; +their upper data are not added to the next search transcript. +For every transcript at the $i$th representative, +the conditional chance of a further one is at most $1-p$. +Iteration gives a geometric tail for $J_W$ and hence for $J_N$. +Connections outside the rectangle play no role because both counts +use restricted components. The original wired law has the same +interior $(s,W)$ comparison by \cref{prop:circuits}. + +A fixed finite rectangle cover of the shell between $Q_0$ and $Q_1$ +assigns each transmitting restricted component to a crossing of one +of these rectangles. The small lattice layer in the incidence +definition is absorbed by the fixed clearance. This proves the +transmission assertion. + +For the shell assertion, the clusters counted are unsearched global +free clusters of the residual law, rather than distinct restricted +components. At shell +radius $r$, a fixed finite cover assigns every enclosing or passing +cluster a connected passage of diameter at least $c_2r$ in one +of its boxes. Apply item~1 after rescaling by $r$. Its collar proof +is uniform when $\delta/r$ is small, including boxes met by matching +walls in the realization with a common fill. When $\delta/r$ is bounded +below there are only a bounded number of vertices in the rescaled +boxes. The resulting exponential tail gives every fixed moment, +uniformly down to lattice order. For disjoint independent chambers +apply this assertion separately in each one. A pair of vertices in +different chambers shares no cluster, which is the only +cross-chamber fact needed for the later moment estimates. +\end{proof} + +\begin{corollary}[Counts in an enclosing box] +\label{cor:global-cluster-counts} +Fix a bounded box $L$ and $b>0$. Suppose the finite lattice domain +and the supports under consideration lie in $L$, and place $L$ in +a fixed larger regular ambient box. For one free flat $N$ law, or +the residual product law with a common fill conditional on its initial +exact cut data, let +\[ + \mathcal N_\delta(b) + =\#\{\,\text{free }N\text{ clusters }C:\diam C\ge b\,\}. +\] +There are constants $C,c>0$, depending on $L,b,t$ but not on the +initial walls or the mesh, such that +\begin{equation}\label{eq:spatial-global-count-tail} + \P[\mathcal N_\delta(b)\ge n\mid\text{initial cut data}] + \le C e^{-cn}. +\end{equation} +The unconditioned free dual current is included. For the original +wired current, expose its boundary cluster first; its free +descendants satisfy this estimate conditionally, and adding the +distinguished boundary cluster increases the count by at most one. +The boxes and all cover buffers are fixed before the mesh limit. + +There is also a pathwise consequence for a seed exploration. Suppose +a compact set $Q$ is at distance at least $r>0$ from the seed and +initial removed support. List the discovered free clusters whose +support meets $Q$, or whose union of odd holes meets $Q$. If +$\mathcal L_\delta(\tau;Q,r)$ is the number listed up to any stop, +then, for all sufficiently small $\delta$, +\begin{equation}\label{eq:spatial-contributor-domination} + \mathcal L_\delta(\tau;Q,r) + \le \mathcal N_{\delta,\mathrm{initial}}(r/3). +\end{equation} +Add one on the right if the distinguished wired cluster is listed. +This is domination by the initial count, not a tail conditional on +the completed stop. +\end{corollary} + +\begin{proof} +Cover $L$ by finitely many inner squares of side a small fixed +multiple of $b$. Around each choose a passage square and a larger +buffer, with fixed ratios, in the regular ambient box. If a +connected cluster has diameter at least $b$, choose two of its +points at that separation and an inner square containing the first. +The path to the second has a first exit from the passage square; +its initial portion is a connected passage of diameter at least +$c_1b$ there, for a fixed $c_1>0$. Let +$\mathcal N_{\delta,i}^{\rm passage}(c_1b)$ be the item~1 count +of unsearched global free clusters of the initial residual law +having such a passage in the $i$th square. +Every global cluster is counted in at least one of these counts. +Consequently +\[ + \mathcal N_\delta(b) + \le \sum_{\text{cover squares }i} + \mathcal N_{\delta,i}^{\rm passage}(c_1b). +\] +The cover is fixed before $\delta$. Its passage buffers may cross +the original boundary or the revealed wired layer: extend the +initial cell region to the ambient box and use the augmented +matching completion of \cref{prop:circuits}. Item~1 of +\cref{prop:cluster-counts} and a finite union bound give +\eqref{eq:spatial-global-count-tail}. For the original free dual +law the matching primal boundary is the initial fill. Behind the +wired $N$ boundary cluster, \cref{lem:finite-cuts} gives precisely +the product law whose common initial fill is that connected cluster +joined to the exterior. + +For \eqref{eq:spatial-contributor-domination}, every discovered +cluster meets the seed. If its support meets $Q$, it has diameter +at least $r-O(\delta)$. If instead one of its odd holes meets $Q$, +that hole lies in the convex hull of the cluster's cell region: +a bounded complementary component is contained in that convex +hull. A point of the hole is therefore at distance at most +$\diam C+O(\delta)$ from the seed contact on $C$. This again gives +$\diam C\ge r-O(\delta)$. The listed clusters are distinct members +of the initial free collection, proving the pathwise inequality. +This argument covers a cluster which surrounds $Q$ without meeting it. +\end{proof} + +\begin{lemma}[Distance to a chamber-side rim]\label{lem:chamber-rim-distance} +Let $U_\delta$ be a resolved residual chamber of an exact cut +exploration, let $S_\delta$ be the revealed support including the +initial boundary and seed as needed, and let $\Gamma_\delta$ be its +own chamber-side +$W$ perimeter. For any subset $C_\delta$ of that chamber, +\begin{equation}\label{eq:spatial-own-rim-distance} + \sup_{x\in C_\delta}\dist(x,\Gamma_\delta) + \le \sup_{x\in C_\delta}\dist(x,S_\delta)+O(\delta). +\end{equation} +The constant is the lattice resolution constant. In particular, if +$C_\delta\to C_*$ and $S_\delta\to S_*$ in Hausdorff distance with +$C_*\subset S_*$, the left side tends to zero. +\end{lemma} + +\begin{proof} +For $x\in U_\delta$, take a segment to a nearest point of +$S_\delta$. Its first exit from the resolved chamber meets that +chamber's own medial perimeter, within $O(\delta)$ of the +corresponding $W$ edge. The distance to this first exit is at most +the length of the segment. Taking suprema proves the inequality. +This uses the own perimeter even if the nearest support point +belongs to another nearby part of a pinched wired layer. For the +original free chamber the same argument uses its polygonal boundary +as $S_\delta$. The Hausdorff conclusion follows from the one-sided +inclusion $C_*\subset S_*$. +\end{proof} + +\begin{corollary}[No shadowing at recorded stops] +\label{cor:indexed-no-shadowing} +Fix a buffered box $Q$ and $b>0$. At a stop $\tau$ of an +exterior-attached seed exploration, let $F_\tau$ be its frozen +connected cell region, including the initial walls, all visited seed +vertices, and all clusters already revealed. Let +\[ + \Xi_\delta(\tau;b,\eta) + =\left\{\begin{array}{c} + \text{some unsearched }N\text{ cluster has a connected}\\[-2pt] + \text{passage }\gamma\subset Q,\quad \diam\gamma\ge b,\quad + \gamma\subset F_\tau^\eta + \end{array}\right\}. +\] +For allowed exact cut or $(s,W)$ stopping histories $\mathcal H_\tau$ +with the supported residual product class, +\begin{equation}\label{eq:spatial-frozen-shadow} + \P[\Xi_\delta(\tau;b,\eta)\mid\mathcal H_\tau] + \le\omega_{Q,b}(\eta,\delta),\qquad + \lim_{\eta\downarrow0}\limsup_{\delta\downarrow0} + \omega_{Q,b}(\eta,\delta)=0, +\end{equation} +uniformly over positive probability histories. Exterior colors +rendered irrelevant by a completed cut are allowed. Arbitrary +interior $d$ pins, or conditioning on a later visibility event, +are not part of this statement. + +For an exploration in the enclosing box of +\cref{cor:global-cluster-counts}, index stops by their rank among +discoveries of clusters of diameter at least $b$, and let +$\tau_0$ be the initial stop. All intervening smaller discoveries +are included in each frozen $F_{\tau_i}$. If $D_\delta(b)$ is the +number of these records, then, for every integer $K$, +\begin{equation}\label{eq:spatial-indexed-shadow} + \P[\exists\,0\le i\le D_\delta(b): + \Xi_\delta(\tau_i;b,\eta) + \mid\text{initial cut data}] + \le C e^{-cK}+(K+1)\omega_{Q,b}(\eta,\delta). +\end{equation} +The indices here are recorded macroscopic ranks, not raw discovery +numbers. + +If a random width $\eta_\delta$ tends to zero only on a limiting +event $E$, the usable deterministic inclusion is, for fixed $\eta$, +\begin{equation}\label{eq:spatial-random-width} + E\cap\Xi_\delta(\tau;b,\eta_\delta) + \subseteq + \Xi_\delta(\tau;b,\eta)\ \cup\ + \bigl(E\cap\{\eta_\delta>\eta\}\bigr). +\end{equation} +Thus one first fixes $\eta$, takes the mesh limit (and Fatou's +inequality when passing to a limit event), and then sends $\eta$ to +zero. No estimate is asserted after conditioning on $E$. +\end{corollary} + +\begin{proof} +An actual unsearched $N$ passage avoids $F_\tau$ and the actual +edges of every attached augmented matching circuit. A finite +collar-window cover of $Q$ therefore gives +\eqref{eq:spatial-frozen-shadow} from \cref{lem:collar}, including +windows met by the initial wall. The exact cut factorization +identifies the residual marginal for every permitted history. +The bound is for the existential future event under that marginal; +it does not reveal a particular future passage. + +On $D_\delta(b)\le K$, there are at most $K+1$ frozen indexed +stops. Apply \eqref{eq:spatial-frozen-shadow} at each one and use +a union bound. The complementary event is bounded by +\eqref{eq:spatial-global-count-tail}, which yields +\eqref{eq:spatial-indexed-shadow}. Finally, +\eqref{eq:spatial-random-width} follows from monotonicity of +neighborhoods. It gives the stated order of limits even when the +width was chosen from a future Hausdorff containment. +\end{proof} + +For subsequent analytic arguments an additive mixing estimate is +not sufficient: the prescribed microscopic patterns may themselves +have very small probability. We therefore record a multiplicative +comparison. A \emph{complete pattern} in a finite vertex-and-edge +set specifies all its $s$ spins and all its $W$ edge states. Every +specified edge includes its endpoints. + +\begin{proposition}[Pattern comparison] +\label{prop:pattern-comparison} +Fix regular compact sets $Q_i$ and filled buffered neighborhoods +$B_i$, $1\le i\le m$, with the $B_i$ pairwise disjoint and a fixed +positive separation between $Q_i$ and $\partial B_i$. Assume each +$B_i$ is contained in the domain, with no prescribed data there +other than the pattern being tested in $Q_i$. Exterior data may be +arbitrary admissible $(s,W)$ data and their retained connections. +There is a constant $C$ such that, for complete patterns $p_i$, +\begin{equation}\label{eq:spatial-product-patterns} + C^{-m}\prod_{i=1}^m\pi_i(p_i) + \le \mu[p_i\text{ on every }Q_i] + \le C^m\prod_{i=1}^m\pi_i(p_i). +\end{equation} +Here $\mu$ is any such conditional flat law, and $\pi_i$ is the +plane pattern law in $Q_i$. The constant depends on the fixed +buffer geometry and $t$, not on the patterns or on their number +of microscopic prescriptions. Copies under parity-preserving lattice +translations and reflections satisfy the same assertion. + +In particular, the single-box pattern laws have uniformly bounded +Radon--Nikodym density ratios, and the same remains true locally +after conditioning on any collection of separated patterns in the +other boxes. +\end{proposition} + +\begin{proof} +Consider first a single $Q$ inside its buffer $B$. Prescribe a +complete admissible pattern in four batches: its plus vertices, +its minus vertices, its increasing compatible edge prescriptions, +and its decreasing compatible edge prescriptions. After the first +two batches every edge endpoint is fixed. A disagreeing edge is +already determined closed. On monochromatic edges the two remaining +batches mean open plus or closed minus, and closed plus or open +minus, respectively. Each batch is monotone in one of the two +orders of \cref{prop:comparison}. The number of batches is four, +independently of the pattern size. + +Fix the preceding batches and consider an increasing current batch +$E$. Choose two deterministic annular buffers between $Q$ and +$\partial B$, and fix a plus circuit on the farther one. Let $\lambda$ +be the law inside that deterministic circuit with the preceding +prescriptions retained. Comparison gives +\begin{equation}\label{eq:spatial-batch-upper} + \mu(E)\le\lambda(E). +\end{equation} +In the nearer annulus, conditional on the preceding prescriptions, +a random plus circuit has probability at least $p>0$. To see this +even if those prescriptions contain both signs, cover that annulus +by buffered test boxes missing $Q$; the exterior bound for one parity +and FKG supply its circuit with the same positive constant. +Search outside-in, inspecting nothing on the sealed side, and stop +at the first such circuit in a fixed exploration. Its interior +law is plus wired by \cref{lem:finite-cuts}, and hence dominates +the restriction of $\lambda$, with the same preceding prescriptions. +Consequently +\begin{equation}\label{eq:spatial-batch-lower} + \mu(E)\ge p\lambda(E). +\end{equation} +The decreasing batch uses minus circuits and the reversed order. + +The law $\lambda$ is common to any two exterior conditions under +comparison. Applying \eqref{eq:spatial-batch-upper}-- +\eqref{eq:spatial-batch-lower} to each of the four conditional batch +probabilities yields bounded ratios for the complete pattern +probabilities. Zero-probability patterns are exactly the common +local incompatibilities and are harmless. These constants remain +valid when the comparison law is a flat exhaustion of the plane. +The common plane spin/percolation law obtained from flat exhaustions in +\cite[Theorem~17.1]{DKLM2026} therefore gives the comparison with +$\pi_i$ by taking that exhaustion limit. For fixed $W$ parity this +law is invariant under parity-preserving lattice translations and +reflections, with the compatible global residue action. An +automorphism exchanging the lattices acts also by exchanging which +parity is called $W$; it is not invariance of the same fixed edge +decoration under that automorphism. The height-gradient marginal +has the full corner-grid symmetries used later. + +For several boxes, condition successively on the patterns in the +other boxes. These constraints lie outside the current filled +buffer, so the single-box estimate applies with unchanged constants. +The chain rule gives \eqref{eq:spatial-product-patterns}. Conditioning +on separated patterns and repeating the same argument proves the +last assertion. Notice that the proof is multiplicative at every +stage; it is not an inference about rare events from a total +variation error. +\end{proof} + +\subsection{Extending separation witnesses} + +The preceding proposition concerns one spin parity and its edge +decoration. The other spins color complementary components, so their +admissible assignments can depend on connections outside a tested +pattern. We now localize that dependence. In this subsection choose +$W$ on the parity carrying the flat wall. The complementary $N$ +components in the chamber are all free. This restriction is needed +only for the color statement here and below; the wired bulk circuit +case of \cref{prop:circuits} remains available. + +Fix regular boxes $Q\Subset Q'\Subset B$ with fixed positive gaps. +For a geometric closed set, its complete pattern includes every $W$ +edge meeting the set and both endpoint spins; the resulting one-mesh +boundary layer is part of the pattern. Form the restricted $N$ graph +using precisely the dual edges whose $W$ states that pattern +determines. A restricted component is a \emph{terminal} if it meets +$Q$ and contains a vertex incident to an unprescribed $N$ edge. +Every component meeting $Q$ that is not a terminal is sealed by the +pattern, so its color is independent of the exterior. This incidence +definition avoids losing an edge in the lattice boundary layer. +Select one marked vertex of each terminal by a deterministic rule. +A vector of signs on these marks is \emph{compatible} with an +exterior configuration if no two oppositely assigned marks become +connected in the full $N$ graph. + +\begin{lemma}[Buffered separation witnesses] +\label{lem:buffered-witnesses} +Fix $p>0$ and an integer $k$. Conditional on any complete pattern +in $Q'$ with at most $k$ terminals, suppose a specified terminal +assignment has compatibility probability at least $p$ in a +$W$-flat domain containing $B$. There is +$c=c(p,k,Q,Q',B,t)>0$ such that, for every sufficiently small mesh, +with conditional probability at least $c$, every opposite pair +of marks is separated by an actual open monochromatic $W$ loop +contained in $B$. Thus compatibility is witnessed without using +the configuration beyond $B$. The estimate is uniform in the +microscopic pattern and in the enclosing domain. + +Admissible $(s,W)$ exterior data beyond a fixed larger buffer are +allowed. No transverse $d$ colors are conditioned upon in this +statement. +\end{lemma} + +\begin{proof} +In a finite $W$-flat domain, planar cut-cycle duality says that two +marks disconnected in $N$ are separated by a simple monochromatic +$W$ loop, allowing portions of the matching outer perimeter. We +will replace possibly long loops by loops in successively enlarged +cores. Write $\mathcal O$ for the set of required opposite pairs +and $m=|\mathcal O|\le k(k-1)/2$. If $m=0$ there is nothing to prove. +Choose regular closed cores +\[ + Q'=K_0\Subset K_1\Subset\cdots\Subset K_m\Subset B. +\] +In each gap fix a middle annular band and a wider band compactly +inside the gap, with further positive margins. At lattice scale +the core includes every $W$ edge meeting the closed core and its +endpoints. This convention counts a crossing on its boundary; all +such edges of $K_m$ lie in $B$ for small mesh. + +For a complete pattern $g$ on $K_j$, let $\mathcal S(g)\subseteq +\mathcal O$ be the pairs separated by some actual monochromatic +loop in that lattice core. This set is determined by $g$ and can +only increase when the core pattern is enlarged in the same +configuration. A pair outside $\mathcal S(g)$ is called missing. +We prove the following one-step statement. If, under the original +law conditional only on $g$, compatibility has probability at +least $a>0$ and some pair is missing, then +\begin{equation}\label{eq:spatial-witness-step} + \P[\text{compatibility and }|\mathcal S(P_{j+1})| + >|\mathcal S(g)|\mid P_j=g]\ge r(a,k)>0. +\end{equation} +The constants use the fixed bands of this step and are uniform in +$g$ and the mesh. Here $P_j$ denotes the complete core pattern. + +First choose a finite type of witness configuration. On compatibility, +among simple loops separating a missing pair choose one whose enclosed +set $I$ of marks is inclusion-minimal, with a deterministic rule for +ties. It contains a nonempty proper subset of the marks. No missing +pair is wholly inside its disk. To prove this, let $C$ be the selected +loop and suppose a missing pair $a,b$ lies inside. Choose a witness +loop $D$ for that pair. If it meets $C$, their colors agree, since +opposite-color open $W$ paths cannot meet. Consider the finite planar +graph +\[ + H=(C\cup D)\cap\overline{\operatorname{int}C}. +\] +Every underlying dual path from $a$ to $b$ leaving +$\operatorname{int}C$ crosses $C$, and every such path staying +inside crosses $D$. Thus $H$ separates $a$ from $b$ in the full +plane. Planar cut-cycle duality extracts a simple cycle of $H$ +separating them. Its disk lies in +$\overline{\operatorname{int}C}$ and contains one of $a,b$ but not +the other, so its marked set is a nonempty proper subset of $I$. +All its edges have the common color. If $C$ and $D$ are disjoint, +the disk of $D$ must lie inside that of $C$ and gives the same +contradiction. This proves the claim, including shared-edge and +tangency cases. + +Call $C$ the target. For every missing pair wholly outside $I$, +choose a witness loop and record its color. Record also the target +color and $I$. Reflect the colors for the description so that the +target is plus. A chosen minus witness is disjoint from the target; +its disk is either disjoint from the target disk or contains that +disk. Of its two marked endpoints record the one on the side away +from the target disk. The whole type consists of these data, +including the ordered away-endpoint vector and the fixed mark +$i_0=\min I$. There are at most $L(k)<\infty$ types, independently +of the shapes of all loops. If the compatibility probability is at +least $a$, one type event $\mathcal T$ has probability at least +$a_0=a/L(k)$. Fix that type now. The sampling law remains the +original law conditional on $g$; it is not conditioned on +$\mathcal T$. + +From its fixed away marks perform a deterministic exploration of +the full components of the underlying dual graph whose edges do +not cross an open $W^-$ edge. These are components of the +complement of $W^-$, not components of $N$. Explore through already +known core edges as well as new ones, revealing endpoint spins +before each new edge state, until each component is exhausted. +There are at most $k$ distinct source components. The transcript +$h$ is the cylinder of the queried values, so its residual law +$\mu_h$ is an allowed pin law in \cref{prop:comparison}. In +particular it remains positively associated. The interior frontier +of a full source component consists of actual $W^-$ edges; it is +not a frontier artificially stopped at the old core. Original +outer-boundary conditions are retained, and the middle-band test +windows are away from the old core and the outer boundary. + +Let $F_h^0$ be the union of the source cell regions of these +full components, without filling any complementary pocket. On +$\mathcal T$, each chosen minus witness prevents the source on its +away side from reaching the target disk. Thus the entire $F_h^0$, +including its frontier, misses that disk. The transcript also +certifies the selected minus separations: the other endpoint of +each such pair is outside its explored complement-of-$W^-$ +component. Every $N$ edge belongs to that complement graph, so these +certificates imply the corresponding $N$ disconnections. Denote them by +$\mathcal C(h)$. + +In the residual law, let $\mathcal U_h$ be the event that there +exists an actual plus target loop enclosing exactly $I$, whose +closed disk misses $F_h^0$, together with actual plus witnesses +for the specified missing outside pairs of plus type. This event +is increasing in \eqref{eq:spatial-order}. The minimality rule and +the identities of the previously selected loops have been dropped; +they would not be increasing. If $\nu_g$ is the law of the +transcript under the original law conditioned on the core, the implication +from $\mathcal T$ gives +\[ + a_0\le\int \ind_{\mathcal C(h)}\, + \mu_h(\mathcal U_h)\,\nu_g(\dd h). +\] +It follows that the histories satisfying $\mathcal C(h)$ and +$\mu_h(\mathcal U_h)\ge a_0/2$ have $\nu_g$ mass at least $a_0/2$. +We work separately under each such $\mu_h$. There is no FKG or +circuit estimate under the mixture conditioned on this choice of +histories. + +For this fixed history choose the accessible component $U_h$ of +the complement of the raw region $F_h^0$ containing the already +fixed mark $i_0$. Histories with $i_0\in F_h^0$ have +$\mu_h(\mathcal U_h)=0$ and do not occur in the retained family. +Every target disk in $\mathcal U_h$ is connected, contains $i_0$, +and misses $F_h^0$, so it lies in this one component $U_h$. +Only after choosing $U_h$, add the other complementary pockets +to the forbidden cell region and call the resulting region $F_h$. +This addition is for the marginal collar test alone. It does not +discard any actual residual variable from $\mu_h$; plus witnesses +for other pairs may still lie in those pockets. + +For each individual connected source, the connected set $U_h$ +lies in one component of its complement and hence faces one +incident boundary walk of that source. It may face that walk at +many entrances, but there are at most $k$ source labels in total. +Against $U_h$ the frontier is actual minus in the middle band. +The exact completion of one component of \cref{prop:circuits} therefore +applies there; any use of a partition comparison has the same +$k$ indivisible labels. The added pockets attach to these sources, +so every local piece in the band is anchored back to a source mark +in the old core or to the outer boundary. A target disk remains +disjoint from $F_h$. + +Put $b_0=a_0/2$. Choose a collar width $\eta>0$, uniformly in the +retained histories, so that \cref{lem:collar} bounds by $b_0/2$ +the existence of a full underlying dual traversal of the middle +band which lies in $F_h^\eta$ and avoids $F_h$ and its attached +minus circuits. Use the selected $U_h$ marginal for this estimate. +The full residual law $\mu_h$ is retained for all other events. +The virtual-disk clause makes this a simultaneous bound for +traversals inside any target disk in $\mathcal U_h$. In particular, +we subtract this error from $\mu_h(\mathcal U_h)$; we do not +condition the law on absence of the collar event. + +We spell out the increasing event supplied by this subtraction. +Write $K$ for the enlarged lattice core, $A$ for its fixed middle +band, and $A^+$ for the wider band. Choose a fixed regular outer +dual graph $R$ inside $B$, containing $K$ with a complete connected +annular +shell outside $K$. In the path tests below every underlying dual +edge of $R$ is available, regardless of its $N$ state or whether +it crosses a minus edge or the forbidden region. For each required +pair across $I$, orient paths from its $I$ mark, and require every +simple underlying path $\gamma$ between the two marks to satisfy +\begin{equation}\label{eq:spatial-temporary-alternative} + \begin{array}{c} + \gamma\text{ crosses an actual }W^+\text{ edge in }K,\\ + \text{or}\\ + \gamma\text{ has a subpath }\beta\subset A + \text{ from the inner to the outer boundary of }A\\ + \text{which visits a point }z\text{ with }\dist(z,F_h)>\eta . + \end{array} +\end{equation} +Intersect this requirement with the actual plus separations for +the specified outside pairs, and call the event $\mathcal V_h$. +The path family is finite and fixed by $R$; $F_h$ is fixed by $h$. +Only the first alternative changes with $W^+$. Thus +$\mathcal V_h$ is increasing. Neither $F_h$ nor any minus edge is +a real barrier in this definition. + +On $\mathcal U_h$ outside the collar event, \eqref{eq:spatial-temporary-alternative} +holds. Indeed a path avoiding the actual $W^+$ edges in $K$ must +exit $K$ before its first crossing of the target loop. An edge +meeting the closed core is counted in $K$, so a first crossing +on its boundary cannot be lost. The path prefix before that +target crossing lies in the target disk. Before its first exit +from $K$, take the segment from its last hit of the inner band +boundary to its first subsequent hit of the outer one. This is +a full subpath $\beta\subset A$, even if the original path made +earlier excursions. It lies in the target disk and therefore +avoids $F_h$ and all attached minus circuits. Absence of the +collar event forces it to visit a point at distance greater than +$\eta$. Hence +\begin{equation}\label{eq:spatial-temporary-probability} + \mu_h(\mathcal V_h)\ge b_0/2. +\end{equation} + +We replace the second alternative by actual plus circuits. Choose +a deterministic grid in $A$ of mesh much smaller than $\eta$ and +than the separation of its two boundary curves. For each cell +whose filled buffer is disjoint from $F_h$ and contained in $A^+$, +request an actual plus circuit surrounding the cell in that buffer. +Choose the grid and buffers so that every point of $A$ at distance +greater than $\eta$ from $F_h$ lies in an inner cell surrounded by +one requested circuit, and the disk of every such circuit has diameter +smaller +than the distance between the two boundary curves of $A$. This +is possible by taking the cell size a sufficiently small fixed +multiple of $\eta$ and of the band width. There are at most +$M=M(\eta)$ cells. Their buffers miss all source queries and the +old core; for small mesh they exceed the lattice cutoff. + +Under the full residual pin law $\mu_h$, each requested actual +plus circuit has probability at least $p_1>0$ by +\cref{prop:circuits}. Positive association intersects all these +increasing events with $\mathcal V_h$, giving probability at least +$(b_0/2)p_1^M$. On their intersection, no across-$I$ path can +avoid the actual plus edges in $K$. Otherwise +\eqref{eq:spatial-temporary-alternative} supplies a full band +subpath visiting the interior of one requested circuit. A connected +path avoiding that circuit and visiting its interior must stay +inside its disk. Its two band-boundary endpoints cannot both lie +there, by the diameter choice. This contradiction realizes the +temporary alternative using actual plus edges only. + +For completeness, separation in the graph $R$ gives actual closed +witness loops in $K$. Any path using a more distant exterior can +have each exterior excursion replaced in the complete connected +shell of $R$ outside $K$. Thus separation in $R$ is separation in +the full underlying dual graph by $W^+\cap K$. Planar cut-cycle +duality yields a simple plus loop in $K$ for each across pair; +a boundary-to-boundary cut is impossible because these blocking +edges lie strictly inside $R$. Artificial fill and minus edges +play no role in this final separation. + +The history certificates protect the outside minus pairs. The +outside plus pairs are protected by $\mathcal V_h$, the across +pairs by the new local plus loops, and there was no missing pair +wholly inside $I$. Previously short loops are fixed in $g$. +Therefore compatibility holds and at least one missing pair has +joined $\mathcal S(P_{j+1})$. The retained histories have +$\nu_g$ mass at least $b_0$, so the construction proves +\eqref{eq:spatial-witness-step} with, for example, +\[ + r(a,k)=\frac{b_0^2}{2}\,p_1^{M(\eta)}>0, + \qquad b_0=\frac{a}{2L(k)}. +\] +The collar width, grid, and mesh threshold were chosen from +$a,k$ and the fixed bands, not from the particular core pattern. +Replace $r(a,k)$ by its minimum over the finitely many band groups. + +We finally iterate without retaining the long source histories. +Let $\mu$ be the original law conditional on the initial pattern, +and set +\[ + \mathcal G_j=\{\text{compatibility and }|\mathcal S(P_j)|\ge j\}. +\] +Initially $\mu(\mathcal G_0)\ge p$. If +$\mu(\mathcal G_j)\ge q_j>0$, disintegrate \emph{this original law} +only by the complete pattern $P_j$. Patterns with +$|\mathcal S(P_j)|\ge j$ and posterior compatibility at least +$q_j/2$ have total mass at least $q_j/2$: the other patterns +contribute at most $q_j/2$ to $\mu(\mathcal G_j)$. If such a +pattern already has $j+1$ short pairs, its conditional contribution +is at least $q_j/2$; otherwise apply +\eqref{eq:spatial-witness-step}. Hence +\[ + \mu(\mathcal G_{j+1})\ge + \frac{q_j}{2}\min\left\{\frac{q_j}{2}, + r(q_j/2,k)\right\} + =:q_{j+1}>0. +\] +At the next step all source transcripts and selected type events +have been integrated out. The new conditional law is again the +original law given only its complete core pattern, so its unused +buffers have the pin/FKG law required above. After $m$ steps all +pairs have short witnesses in $K_m\Subset B$, with probability +at least $q_m$. All widths and the finitely many mesh thresholds +are chosen before taking the mesh limit. This proves the lemma. +\end{proof} + +\begin{proposition}[Full-spin contiguity] +\label{prop:full-contiguity} +Fix compactly nested regular boxes $Q\Subset B$ in the interior +of a $W$-flat domain, with fixed positive buffer ratios. Thus the +complementary $N$ components are free. Let $\mu_\delta$ +be its law and $\pi_\delta$ the plane law, restricted to the full +spin pair in $Q$. The domains and any allowed exterior $(s,W)$ +data may depend on $\delta$, but their walls and prescriptions stay +outside $B$. There is a uniform contiguity modulus: for every +$\eps>0$ there is $\zeta>0$ such that, for every sufficiently small +mesh and every event $E$ determined by the full spin pair in $Q$, +\begin{equation}\label{eq:spatial-contiguity} + \pi_\delta(E)<\zeta + \quad\Longrightarrow\quad + \mu_\delta(E)<\eps. +\end{equation} +The conclusion also holds if the tested data include $W$ in $Q$. +In particular it applies to mesh-dependent tests. Either flat +parity can be used by assigning $W$ to the parity carrying that +flat wall. This statement does not include a fixed-color wired +$N$ component before its removal. +\end{proposition} + +\begin{proof} +Choose $Q\Subset Q'\Subset B'$ with +$B'\Subset B$, leaving the fixed buffers of +\cref{lem:buffered-witnesses}. Let $P$ be the complete $(s,W)$ pattern +in $Q'$, and let $T(P)$ be its number of terminals. By +\cref{prop:cluster-counts}, uniformly in both domain and plane laws, +\begin{equation}\label{eq:spatial-terminal-tail} + \P[T(P)>M]\le C e^{-cM}. +\end{equation} +Choose $M$ so that the right side is less than $\eps/4$ for the +domain law. + +On $T(P)\le M$, write $b$ for an assignment of signs to its +terminals, and let $v_\mu(b\mid P)$ be its conditional exterior +compatibility probability. By \cref{lem:finite-cuts}, the actual +terminal-color probability $q_\mu(b\mid P)$ satisfies +\begin{equation}\label{eq:spatial-color-cost} + 2^{-M}v_\mu(b\mid P) + \le q_\mu(b\mid P)\le v_\mu(b\mid P). +\end{equation} +Indeed, given a compatible exterior partition, specifying these +terminal signs costs $2^{-j}$ for some $j\le M$ distinct free global +components. The same calculation applies in the plane because +\cite[Theorem~17.1]{DKLM2026} gives no unbounded complementary +component and independent fair transverse colors. Components of +the restricted pattern not incident to an unprescribed edge carry +independent fair colors. Their distribution is the same under the +two laws once $P$ and the terminal signs are given. The lower +bound in \eqref{eq:spatial-color-cost} uses freeness; a terminal +wired to a prescribed incompatible color would not satisfy it. + +Choose $p>0$ with $2^M p<\eps/4$. The total domain probability of +assignments with $v_\mu(b\mid P)0$. +Fix a realized pattern $g$ for $P$, and let $\mathcal W_b$ be this +short-witness event, determined by a +complete pattern in $B'$. If $C_{B'}$ and $C_{Q'}$ are the +unconditioned pattern density constants in +\cref{prop:pattern-comparison}, summing over the larger patterns +and then dividing gives +\[ + \pi_\delta(\mathcal W_b\mid P=g) + =\frac{\pi_\delta(\mathcal W_b\cap\{P=g\})}{\pi_\delta(P=g)} + \ge (C_{B'}C_{Q'})^{-1} + \mu_\delta(\mathcal W_b\mid P=g). +\] +This uses only the original laws on one parity on the two pattern +sets, not a comparison after conditioning on $d$ or on the +witness event. Hence there is $c_0=c_0(p,M)>0$ such that +\begin{equation}\label{eq:spatial-plane-viability} + v_\pi(b\mid P)\ge c_0, + \qquad q_\pi(b\mid P)\ge 2^{-M}c_0 +\end{equation} +whenever $v_\mu(b\mid P)\ge p$ and $T(P)\le M$. +There is no conditioning on $d$ in this comparison: the short +witness event concerns only $W$ and $s$. + +Let $C_0$ be the uniform density-ratio constant for $P$ in +\cref{prop:pattern-comparison}. Conditional on $P$ and a terminal +assignment, integrate the identical independent internal colors. +On the retained assignments, +\eqref{eq:spatial-plane-viability} bounds the ratio of terminal-color +probabilities by $2^M/c_0$. Therefore every tested event satisfies +\begin{equation}\label{eq:spatial-contiguity-modulus} + \mu_\delta(E) + \le \frac{\eps}{2} + + C_0\frac{2^M}{c_0}\,\pi_\delta(E). +\end{equation} +Choosing $\zeta<\eps c_0/(2C_0 2^M)$ proves +\eqref{eq:spatial-contiguity}. All constants were chosen from +$\eps$, the fixed geometry, and $t$ before the mesh limit, so the +modulus is uniform in the stated domain laws. Enlarging the tested +data by $W$ does not change the conditioning argument. +\end{proof} + +The distinction between \cref{prop:pattern-comparison} and +\cref{prop:full-contiguity} is useful later. The former supplies +uniform multiplicative estimates even for extremely rare +patterns on one parity. The latter supplies domination in probability +for both spin parities, without asserting a bounded density ratio +for every possible microscopic color assignment. diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/04-spectral.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/04-spectral.tex new file mode 100644 index 0000000000000000000000000000000000000000..3386dded8fbb522a35703d2e1dc564235c09c8a2 --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/04-spectral.tex @@ -0,0 +1,462 @@ +\section{Reflection positivity and the plane covariance} +\label{sec:spectral} + +This section identifies every subsequential plane covariance, without assuming +either Gaussianity or rotation invariance of a scaling limit. The positive +transfer method of \cite[Section~5]{Triangular} suggests the argument, but its +sixfold rotational cancellation is unavailable here. Two square-lattice +reflection frames at angle $\pi/4$ provide the required replacement. + +We temporarily choose Euclidean units in which the corner grid is $\Z^2$. +This is a fixed rotation and dilation of the original embedding. The local +plaquette calculation above identifies its height weights with the +six-vertex weights $(1,1,c)$. The spin and decoration law obtained from flat +exhaustions is the measure of \cite[Theorem~17.1]{DKLM2026}; +\cite[Lemma~18.7(iii)]{DKLM2026} identifies its height-gradient marginal +with the slope-zero six-vertex plane measure. By +\cite[Theorem~2.2]{DKLM2026}, that marginal is stationary under all +corner-grid translations and invariant under the lattice reflections. +The geometric height reflection used below sends $K$ to its composition +with the spatial reflection, up to an additive constant. In arrow variables +this combines spatial reflection with global arrow reversal; it also +preserves the finite plaquette weights directly. +These statements apply for every $1\le c\le2$. A uniform simultaneous +choice of the two spin signs is understood when residues rather than +increments are observed. In particular an odd corner-grid translation $T$ +exchanges the parities with gauge +$(\tau',\tau^{\dagger\prime})=(\tau^\dagger\circ T,-\tau\circ T)$: +its height is $K'(x)=K(Tx)-K(T0)$. This preserves the incident-corner rule +and accounts for the change of reference parity. +The additive constant of $K$ is immaterial. For a smooth compactly supported +function $f$ of integral zero, use bilinear nodal interpolation on each +corner-grid square to define $K_\delta(f)$. This interpolation commutes with +all four row reflections and with grid translations. +Write its finite array of coefficients as $b_{\delta,x}$; their sum is +exactly zero. For a $2m$th moment, choose smooth mass-one reference +densities in $2m$ disjoint fixed disks outside the common support of the +tests. Let $r_{\delta,j,y}$ be nonnegative discretizations of these +densities, normalized so that $\sum_y r_{\delta,j,y}=1$. For each occurrence +$j$ the exact finite-sum identity is +\[ + K_\delta(f) + =\sum_{x,y}b_{\delta,x}r_{\delta,j,y}\bigl(K(x)-K(y)\bigr). +\] +Use a separate reference index $j$ in each factor of the moment. The +regularity estimate \cite[Theorem~4.5]{DKLM2026} then applies to increment +correlations with separately summed reference variables. Its collision +singularities are products of logarithms, which are locally integrable; +the lattice cells of exact coincidence contribute at most a lattice area +times a fixed power of $1+|\log\delta|$. Integrating the estimate gives +\begin{equation} + \sup_{0<\delta<\delta_0}\E|K_\delta(f)|^{2m}<\infty, + \qquad m\in\N. + \label{eq:plane-neutral-moments} +\end{equation} +The bounds are uniform for tests in a bounded smooth family with common +compact support. The estimate holds throughout $1\le c\le2$, not just the +range of the convergence theorem in that paper. +The elementary path-factor correction in its proof is supplied in +\cref{sec:input-path}. + +\subsection{Four positive reflection frames} + +\begin{lemma}[Positive normal transfer] +\label{lem:positive-transfer} +The plane law is reflection positive across a row of corner-grid sites in +each of the directions $0,\pi/4,\pi/2,3\pi/4$. In its reflection Hilbert +space, translation by two successive row spacings in the inward normal +direction is a positive self-adjoint contraction. For the height-increment +law, tangential translation by one row period is a commuting unitary. +Reflection positivity and positive normal transfer remain valid for local +spin and edge decorations strictly on one side of the row, and for +independent uniform phase lifts of the height. With a fixed one-parity edge +decoration, the tangential unitary assertion is restricted to +parity-preserving translations. +\end{lemma} + +\begin{proof} +First use a finite reflection-symmetric flat exhaustion. Across an axial row, +plaquette interactions on the two sides factor after conditioning on the row +heights. Across a diagonal row, a straddling plaquette has the following +conditional weight matrix. If its two row heights are equal, the other +heights are independently one unit above or below that value. Equal +transverse heights have weight $c$, and unequal ones have weight one. +Consequently the matrix, after multiplication by $t$, is +\[ + \begin{pmatrix}1&t\\t&1\end{pmatrix}. +\] +It is positive semidefinite because $00$. +\end{lemma} + +\begin{proof} +Let $V_x$ be ordinary translation on the plane probability space, $E(\dd p)$ +its spectral resolution \cite[Theorem~5.6]{WilliamsSpectral2018}, +and $\xi_x=K(x)-K(0)$. The cocycle identity gives +\[ + (V_y-I)\xi_x=(V_x-I)\xi_y. +\] +On any spectral neighborhood where $e^{ip\cdot y}-1\ne0$, define +\[ + C(\dd p)= + \frac{\langle\xi_y,E(\dd p)\xi_y\rangle_{L^2}} + {|e^{ip\cdot y}-1|^2}. +\] +The identity makes the definitions agree on overlaps; two grid directions +cover the punctured torus. The invariant part is additive and has the form +$A\cdot x$ for a random vector $A\in L^2$. Smearing at scale $L$ against a +neutral test of first moment $m$ gives invariant part $LA\cdot m$. +Its norm is uniformly bounded by \cref{eq:plane-neutral-moments}, since +orthogonal projection cannot increase norm. Two independent choices of $m$ +give $A=0$. + +Choose two real neutral smooth tests whose Fourier transforms have no common +zero on $1\le|p|\le2$; derivatives in the two coordinate directions of a +sufficiently narrow smooth bump suffice. Their scale-$r^{-1}$ interpolation +transforms converge uniformly on this annulus to those transforms. The sum +of their squared absolute values is therefore bounded below on +$r\le|p|\le2r$. Apply \cref{eq:increment-spectral} and the uniform second +moment bound. Summing over dyadic annuli proves the last assertion. +\end{proof} + +Project $C$ to the reciprocal rectangle +$[-\pi/\ell,\pi/\ell)\times[-\pi/d,\pi/d)$ of $\Lambda_0$, and call the +result $C'$. Besides the physical origin, the preimages of its origin are +finitely many nonzero reciprocal points, called aliases. Their neighborhoods +have finite mass; atoms at aliases are allowed. +Put $P=2\pi/d$. For $00$. +\end{proposition} + +\begin{proof} +Integrate \cref{eq:angular-poisson} over $\eps<|k|<\kappa$. +Its error is bounded independently of $\eps$ by +\cref{eq:weighted-mixture}. Replacing $C'$ outside the small physical disk +by the original measure costs bounded outer and alias mass. In the radial +annulus $\eps<|p|<\kappa$, the omitted endcap $|k|\le\eps$ has negative +fourth harmonic only where $|p|\le C\eps$: negativity implies +$|l/k|<1+\sqrt2$. Its negative part is bounded by a fixed number of the +annuli in \cref{eq:spectral-annulus}. Thus, in a frame of angle $\theta$, +\begin{equation} + \int_{\eps<|k|<\kappa}D\,\dd\nu + \le \int_{\eps<|p|<\kappa} + \cos(4(\arg p-\theta))\,C(\dd p)+C_2. + \label{eq:frame-defect-bound} +\end{equation} +Choose the same physical inner and outer radii for frames $\theta$ and +$\theta+\pi/4$, making the fixed outer radius smaller if necessary. +Their radial integrands are negatives pointwise. Adding the inequalities +therefore bounds the sum of the two nonnegative defect integrals. Monotone +convergence proves finiteness for each. Apply the same argument to the other +frame pair. No rotation of the measure $C$ through $\pi/4$ has been used. + +On $r\le|k|\le2r$, the part with $s\notin[r/2,4r]$ has $D\ge1/9$, so +its mass is bounded. For $s\in[r/2,4r]$, a fixed fraction of $Q_s$ lies in +$|l|\le2r$. The remaining mixing mass is bounded by a constant times +$C'\{r\le|k|\le2r,\ |l|\le2r\}$, which is bounded by the annular estimate +and finite alias mass. This proves the horizontal-band bound for sufficiently +small $r$. For the remaining $r$, the bands lie in a fixed horizontal region +bounded away from zero, whose $\nu$ mass is finite by +\cref{lem:cauchy-mixture}; bands beyond the reciprocal interval are empty. +Increasing $C_1$ gives the bound for every $r>0$. +\end{proof} + +\begin{lemma}[Spectral endcaps] +\label{lem:spectral-endcap} +For every frame, sufficiently small $r$, and $0<\eps0$. + +\begin{lemma}[Neutral insertion moments under patterns] +\label{lem:screen-pattern-moments} +Suppose a smooth neutral insertion $Y_\delta=K_\delta(f)$ has a filled +pin-free neighborhood with positive clearance from finitely many pattern +neighborhoods. For every finite $p$, +\begin{equation} + \E\bigl[|Y_\delta|^p\mid P_1\cap\cdots\cap P_m\bigr] + \le C_p. + \label{eq:screen-pattern-moment} +\end{equation} +The estimate is uniform over admissible patterns, over a compact family +of positively separated placements, and under the flat laws of +\cref{prop:screened-orthogonality}. It remains true after adjoining +reflected copies of the patterns when their neighborhoods have the same +positive separations. +\end{lemma} + +\begin{proof} +We give the count argument, so that this estimate does not depend on the +Gaussian limit proved later. Write the coefficients of the insertion as +$b_v$, where $\sum_v b_v=0$, $|b_v|\le C\delta^2$, and +$\sum_v|b_v|\le C$. If both corner parities occur, transfer the +coefficients on the other parity to nearest $s$ sites. Each corner +increment has absolute value one, so this changes the insertion by a +uniformly bounded remainder $R_\delta$ and preserves exact neutrality. +Conditional on the complete $(N,s)$ data, the finite cut identity gives +\begin{equation} + Y_\delta=R_\delta+2\sum_C \epsilon_C q_C, + \qquad q_C=\sum_{v\in O_C}b_v. + \label{eq:screen-signed-mass} +\end{equation} +Here $O_C$ is the union of the odd holes of $C$, and the signs +$\epsilon_C$ are independent and fair. An additive constant disappears +because the coefficients sum to zero. If a fixed wired color is present, +its single contribution is bounded by $2\sum_v|b_v|$ and is treated +separately. The same argument can first be made in finite exhaustions; +the estimates below are uniform in the exhaustion. + +Fix a connected neighborhood of the support with positive clearance inside +a pin-free buffer. For a cluster of diameter $r$ contained in that buffer, +its filled hull lies in a disk of radius $r+O(\delta)$, so +$|q_C|\le C(r+\delta)^2$. A cluster with $q_C\ne0$ must meet the connected +neighborhood: otherwise its odd-hole indicator is constant there and +neutrality gives $q_C=0$. + +We localize the count of such clusters before applying pattern comparison. +Fix a sufficiently large constant $L$. For $L\delta\le r$ below a fixed +buffer scale, cover the one-mesh enlargement of the insertion neighborhood +by $O(r^{-2})$ inner squares of side $r/20$. Assign each relevant cluster +of diameter in $[r,2r)$ to one such square containing a deterministically +chosen vertex of the cluster. Some other vertex is at distance at least +$r/2$ from that vertex, so a path in the cluster exits the concentric square +of side $r/2$. Its first exiting segment gives a component of the relative +restricted $N$ graph meeting the inner square and a vertex incident to an +edge outside the restriction. Distinct global clusters give distinct +restricted components. The fixed rectangle cover in item~2 of +\cref{prop:cluster-counts} therefore gives +\[ + A_{r,j}\le\sum_{\ell=1}^{L_0}T_{r,j,\ell}, +\] +where $A_{r,j}$ is the assigned global count in square $j$, and each +$T_{r,j,\ell}$ counts restricted crossings of one rectangle, using the +separate side ports of that proposition. The number $L_0$ is fixed. +Each $T_{r,j,\ell}$ is determined by a complete local pattern in an +enlarged box of size $O(r)$. Choose the buffer scale so that these boxes +and all their joining buffers lie inside the pin-free neighborhood. + +The transmission bound gives moments of every fixed order for these local +counts. Since they are local-pattern measurable, the density comparison +in \cref{prop:pattern-comparison} transfers their moments under all the +remote patterns, with constants uniform in $r$. It follows that the +conditional $L^q$ norm of each $A_{r,j}$ is bounded by $C_q$. For +$\delta\le r0$ smaller than the projection gap. Back the high group up +by $\eta_\delta=N_\delta\tau_\delta\to\eta$, where $\tau_\delta$ +is the positive normal step in \cref{lem:positive-transfer}. Choose a +reflection row inside the remaining gap. Reflect and conjugate the +normalized low-side factor, obtaining a positive-side vector $A_\delta$; +call the backed-up high-side factor $B_\delta$. By +\cref{lem:screen-reflection-bound}, both reflection norms are at most a +constant independent of the patterns. If $T_\delta$ is the positive +normal contraction, define +\[ + F_\delta(z)= + \langle A_\delta, + T_\delta^{(z+\eta_\delta)/\tau_\delta}B_\delta\rangle_\Theta, + \qquad \mathop{\rm Re}z>-\eta_\delta. +\] +For $\mathop{\rm Re}w>0$, the spectral power is +$T_\delta^w=\int_{(0,1]}e^{w\log\lambda}\,\dd E_\delta(\lambda)$, +with value zero on the zero spectral subspace. This is a holomorphic +contraction by bounded spectral calculus +\cite[Proposition~5.3 and Corollary~5.7]{WilliamsSpectral2018}: on +$\mathop{\rm Re}w\ge b>0$, each derivative is bounded by +$\sup_{0<\lambda\le1}\lambda^b|\log\lambda|^m<\infty$. Hence $F_\delta$ is bounded on the common half-plane +$\mathop{\rm Re}z>-\eta/2$ for all sufficiently small $\delta$. +At nonnegative lattice-step arguments it equals $M_\delta$ exactly. +Cauchy's estimate makes lattice rounding negligible on compact sets. +Every subsequence has a locally uniformly convergent further subsequence; +its holomorphic limit vanishes on the given interval and hence everywhere +by the identity theorem. In particular it vanishes at zero. The norm +bounds and the common backoff remain valid for all the sequences in the +statement. Moving the low group in direction $-n$ is equivalent. +\end{proof} + +Arrange thick blocks in a square annulus inside $Q$, leaving narrow gaps +where two horizontal lines, one above and one below $B$, cross its two +side strips. The top and bottom blocks are denoted by $T$ and $D$, and +the middle left and right blocks by $L$ and $R$. The middle band is so +narrow that $L$ and $R$ are strictly below and above $B$, respectively, +in projection on $u=(1,1)/\sqrt2$. The blocks may subsequently acquire +small predetermined indentations at their gap-facing boundaries; none +of these changes the strict projection inequalities. They have disjoint +filled isolating neighborhoods avoiding $B$. + +\begin{lemma}[Gapped pattern identity] +\label{lem:screen-gapped-identity} +For this fixed arrangement, for arbitrary patterns $P_i$ in the blocks +and arbitrary factors $F_i$ of absolute value at most one supported in +their respective blocks, +\begin{equation} + e_\delta:= + \sup_{(P_i),(F_i)} + \frac{|\E[X_\delta\prod_i\ind_{P_i}F_i]|}{\prod_i p_i} + \longrightarrow0. + \label{eq:screen-gapped-identity} +\end{equation} +The factors may involve both spins. Their choices and their supports +inside the fixed blocks may depend on the specified patterns. +\end{lemma} + +\begin{proof} +Use the normals $e_y=(0,1)$, $u=(1,1)/\sqrt2$, $e_x=(1,0)$, and +$v=(-1,1)/\sqrt2$. First translate $T$ upward and $D$ downward until +$T\cup R$ and $D\cup L$ are strictly above and below the insertion in +$u$-projection. Next translate $T\cup R$ in direction $u$ and $D\cup L$ +in direction $-u$. Choose these distances large enough that the first +group is above the insertion and wholly to its right, and the second +group wholly to its left. Move the latter farther left until it is +strictly above every other support in $v$-projection. This additional +horizontal move is needed because $u\cdot v=0$. Finally move that group +in direction $v$ until all factors are above the insertion. + +Every move is rigid on a complete side of a strict projection gap. +Within-group clearances are preserved, and between-group gaps increase. +The distances can be chosen in open intervals with positive margins. +At the final arrangement, reflection Cauchy--Schwarz in a horizontal +row gives the bound $C\|X_\delta\|_\Theta$, which tends to zero by +\cref{cor:reflection-null}. Undo the moves in reverse order using +\cref{lem:screen-analytic-translation}, each time first varying the last +distance over an open interval. There is no motion through overlapping +supports. This proves convergence along every sequence of patterns and +factors. If the displayed supremum did not tend to zero, a sequence +within half its positive limsup would contradict precisely this +conclusion. +\end{proof} + +\begin{lemma}[Adding core colors] +\label{lem:screen-core-colors} +Let $S_\delta$ be the complete patterns in the blocks, and observe the +$d$ spins on arbitrary pattern-measurable subsets of their compact cores. +Write $C_\delta$ for those observations and +$Y_\delta=(S_\delta,C_\delta)$. Then +\begin{equation} + \|\E[X_\delta\mid Y_\delta]\|_1\longrightarrow0. + \label{eq:screen-core-orthogonality} +\end{equation} +\end{lemma} + +\begin{proof} +For each block pattern, form the restricted $N$ graph from precisely the +dual edges whose $W$ states that pattern specifies, as in \cref{sec:spatial}. +An observed restricted component with no vertex incident to an unprescribed +$N$ edge is sealed. Its $d$ color is independent and fair by the color law +there; its filled hull lies in the block's filled isolating neighborhood, +so that color cannot affect $X_\delta$. Integrate these colors out. Every +remaining observed component meets the core and contains a vertex incident +to an unprescribed edge; call these components terminals. + +Under $\P_\delta$, before fixing a realization of $S_\delta$, the fixed +core and block clearances meet the unprescribed-interior hypotheses of +item~2 of \cref{prop:cluster-counts}. A finite union of its transmission +bounds gives a geometric tail for the total number of terminals. + +Truncate this number at $M$. For each pattern, choose one representative +in each terminal, in a deterministic order. An assignment +of their at most $M$ signs is the product of bounded local indicators, +one factor in each block. It need not have a positive probability bounded +below: global joining outside the blocks can forbid assignments. The +quantity in \eqref{eq:screen-core-orthogonality} is the sum of absolute +\emph{unnormalized} expectations over the data. Thus +\cref{lem:screen-gapped-identity} bounds its retained part by +\[ + 2^M e_\delta + \sum_{P_1,\ldots,P_m}\prod_i\P_\delta(P_i) + =2^M e_\delta. +\] +Integrating the independent internal colors contributes a factor one. +On the discarded event, Cauchy--Schwarz and +\cref{lem:screen-pattern-moments} bound the contribution by a constant +times the square root of the count-tail probability. First let +$\delta\downarrow0$ at fixed $M$, then let $M\to\infty$. +\end{proof} + +\subsection{Joining the gaps without revealing their colors} + +We next construct an actual separator. The following details distinguish +an averaged shielding estimate from a generally false estimate uniform +over every fully specified pattern. + +For each of the four horizontal gaps, place $M$ disjoint buffered trial +squares of side comparable to $R$. In the center of each trial leave a +square hole of side comparable to $w=qR$, straddling the gap line; the +horizontal gap itself has width much smaller than $w$. The holes produce +the predetermined indentations in the adjoining blocks. Within each +trial ask for two open plus $W$ arms, one on each side of the gap, running +from the middle portions of the two facing hole edges, with fixed corner +clearance, to distance comparable to $R$ inside the adjoining blocks. +Choose their outer ends in compact cores. All cores, +arms and holes have fixed positive mutual clearances where required. +In particular the outer ends and core paths avoid disks of radius $R/10$ +about every hole. + +The choices are made in the order +\begin{equation} + \begin{gathered} + q>0,\qquad M<\infty,\qquad + R>0\text{ small enough to fit the trials},\\ + w=qR,\qquad\text{gap width},\qquad\delta\downarrow0. + \end{gathered} + \label{eq:screen-scale-order} +\end{equation} +Thus an arbitrarily large finite number of trials fits in a fixed +annulus. Shrinking $R$ changes the fixed core geometry, which is allowed +before applying \cref{lem:screen-core-colors}. + +\begin{figure}[t] +\centering +\begin{tikzpicture}[scale=1.05,line cap=round,line join=round] + \filldraw[fill=gray!13,draw=gray!55] + (-2,2)--(2,2)--(2,.54)--(1.2,.54)--(1.2,1.2) + --(-1.2,1.2)--(-1.2,.54)--(-2,.54)--cycle; + \filldraw[fill=gray!13,draw=gray!55] + (-2,-2)--(2,-2)--(2,-.54)--(1.2,-.54)--(1.2,-1.2) + --(-1.2,-1.2)--(-1.2,-.54)--(-2,-.54)--cycle; + \filldraw[fill=gray!13,draw=gray!55] (-2,-.46) rectangle (-1.2,.46); + \filldraw[fill=gray!13,draw=gray!55] (1.2,-.46) rectangle (2,.46); + \foreach \x in {-1.6,1.6}{ + \foreach \y in {-.5,.5}{ + \fill[white] (\x-.1,\y-.1) rectangle (\x+.1,\y+.1); + } + } + \draw[teal!75!black,very thick] + (-1.6,.1)--(-1.6,.9) (1.6,.1)--(1.6,.9) + (-1.6,-.1)--(-1.6,-.9) (1.6,-.1)--(1.6,-.9); + \draw[black,dashed,thick] + (-1.6,.9)--(-1.6,1.6)--(1.6,1.6)--(1.6,.9) + (-1.6,-.9)--(-1.6,-1.6)--(1.6,-1.6)--(1.6,-.9) + (-1.6,-.1)--(-1.6,.1) (1.6,-.1)--(1.6,.1); + \draw[orange!75!black,densely dotted,thick] (-1.6,.5) circle (.29); + \node at (0,1.83) {$T$}; + \node at (0,-1.83) {$D$}; + \node at (-1.88,0) {$L$}; + \node at (1.88,0) {$R$}; + \draw (0,0) circle (.16); + \node[below=5pt] at (0,-.16) {$\supp\phi$}; + \draw[teal!75!black,very thick] (2.45,1.1)--(3.05,1.1); + \node[right,align=left] at (3.15,1.1) {open $W$ arms\\and bridge}; + \draw[black,dashed,thick] (2.45,0)--(3.05,0); + \node[right,align=left] at (3.15,0) {core path with both\\incident $d$ spins fixed}; + \draw[orange!75!black,densely dotted,thick] (2.45,-1.1)--(3.05,-1.1); + \node[right,align=left] at (3.15,-1.1) {one shielding circuit}; +\end{tikzpicture} +\caption{The separator after successful trial selection. Gray regions carry +complete $(s,W)$ patterns. Short bridges join the selected open arms across +the gaps; their transverse colors need not be observed. On the dashed core +portions both incident transverse spins are fixed. A surrounding circuit +protects the outside data during each bridge insertion. Only one shielding +circuit and one selected trial per gap are shown.} +\label{fig:screen-separator} +\end{figure} + +\begin{lemma}[Selected-arm shielding] +\label{lem:screen-shielding} +For fixed $q$, each trial has conditional two-arm success probability +at least $p(q)>0$, given all earlier trial data. If the first successful +trial is selected, the probability that no trial succeeds is at most +$(1-p(q))^M$. The probability that the selected hole has no surrounding +plus $W$ circuit between scales $Cw$ and $R/10$ is at most $\eta(q)$, +where $\eta(q)\to0$ as $q\downarrow0$. These bounds hold after +averaging over the complete block patterns. +\end{lemma} + +\begin{proof} +Reveal previous trials completely before testing the next. Their buffered +neighborhoods are disjoint, so this is exterior $(s,W)$ data for the +current trial. The tube version of \cref{prop:circuits} gives $p(q)$; +the aspect ratios are fixed once $q$ is fixed. A stack of separated +annuli between $Cw$ and $R/10$ gives circuit failure probability at most +$\eta(q)\le Cq^\alpha$ for some $\alpha>0$. + +Write $A_j$ for the increasing two-arm event, $G_j$ for the surrounding +plus-circuit event, and $\mathscr H_j$ for the full previous trial +history. Positive association in the remaining law gives +\begin{equation} + \P(A_j\cap G_j^c\mid\mathscr H_j) + \le \eta(q)\P(A_j\mid\mathscr H_j). + \label{eq:screen-relative-shielding} +\end{equation} +If $J$ is the first successful trial, sum this inequality over the +disjoint events $\{J=j\}$. Their total probability is at most one; +there is no factor $M$ in the resulting shielding error. Iterating the +conditional arm bound gives the failure probability. Revealing all +remaining block patterns afterward does not change either averaged +estimate. We do not assert \eqref{eq:screen-relative-shielding} after +conditioning on each individual complete pattern. +\end{proof} + +Retain the original marginal law of $S_\delta$. Given this pattern, +select the first successful trial at every gap using a fixed order, +and select its two arms by a deterministic rule. For each selected pair +of arms, choose by a fixed deterministic rule a $W$-lattice path inside +the hole joining their endpoints and meeting the prescribed pattern only +at those plus endpoints. The fixed hole geometry provides such a path for +all sufficiently small meshes. On success, replace the conditional law +by the upper law obtained by pinning these paths open and plus. The new +conditional law is therefore well defined, and its bridge pins are +functions of $S_\delta$. +On unsuccessful patterns leave the conditional law unchanged, couple it +identically to the original law, and take no core-color observations. +Call the resulting law $\mathbb Q_\delta$. + +\begin{lemma}[Bridge coupling and exact separation] +\label{lem:screen-bridge-coupling} +The laws $\P_\delta$ and $\mathbb Q_\delta$ can be coupled with their +block patterns identical. Except on probability at most $4\eta(q)$, +their insertion, full exterior data, and all $d$ colors at core sites +outside the shielding disks agree, on the event that all four gaps +have successful trials. Under $\mathbb Q_\delta$, on that success +event one can choose pattern-measurable core paths and condition on +their incident $d$ sites so that the insertion and the full exterior +are conditionally independent given $Y_\delta=(S_\delta,C_\delta)$. +\end{lemma} + +\begin{proof} +Fix a block pattern $S$, and write $H(S)$ for success at all four gaps. +On this event let $G_i(S)$ be the plus-circuit event around the selected +hole at gap $i$, and let $\mu_i^S$ be the conditional law after the first +$i$ selected bridges have been pinned, with $\mu_0^S$ the original +conditional law. On unsuccessful patterns put $\mu_i^S=\mu_0^S$ and +$G_i(S)=\Omega$. For two successive laws use the monotone stopping +coupling of \cref{prop:comparison}, searching outward from the newly +pinned hole inside its shielding disk. Stop at the disk's outer boundary +and declare this adjacent coupling unsuccessful if no surrounding plus +circuit has been found. All previously inserted pins are identical in +these two laws. +In the lower law the first plus circuit surrounding that hole is also +open in the upper law. All changed data are inside this common cut. By +\cref{lem:finite-cuts}, the configurations outside it can be sampled +identically, including complementary-component colors. In particular +their exterior color connections are unchanged. The exact neutrality of +the insertion removes any change in the chosen additive height anchor. +If $G_i(S)$ occurs in the lower law, this cut is found inside the +shielding disk, so the required insertion, exterior data, and core colors +outside that disk agree. + +To realize these adjacent couplings in the plane, first run each disk-stopped +search in finite flat exhaustions at fixed $\delta$ and $S$, retaining a +binary failure marker. Each conditioning event involves finitely many +prescriptions and has positive plane probability. To verify positivity, +place $S$ and the compatible bridge pins in a larger buffered flat box +with an open plus $W$ perimeter. Keep every prescribed state, put plus +on all remaining $s$ sites, close all remaining interior $W$ edges, and +take all $d$ spins equal. Every factor in \cref{eq:spatial-edge-weight} +is positive because $t\in[1/2,1)$. Let $\mu_{\mathrm{box}}$ denote the +flat law in this box. The restriction $p$ of this filling to a regular +inner core containing the prescriptions is a complete pattern with +$\mu_{\mathrm{box}}(p)>0$. The upper bound +$\mu_{\mathrm{box}}(p)\le C\pi(p)$ in \cref{prop:pattern-comparison} +gives $\pi(p)>0$, and hence positive plane probability for the conditioning +event containing it. + +The conditional marginals therefore converge on cylinder events. Extract +a joint limit on the countable product of spin and edge coordinates, +together with the failure marker. Its probability bound passes to the limit, +as does equality of each fixed exterior coordinate on success. Taking their +countable intersection gives equality of the full exterior configuration; +its computable height increments agree as well. Thus this limit has the +plane marginals and the coupling properties just proved in finite volume. + +For fixed $S$, the event $G_i(S)$ is now fixed and increasing. The previous +plus pins can only increase its probability. With $\E_S$ denoting +expectation over the original pattern marginal, this gives +\[ + \E_S\!\left[\ind_{H(S)} + \mu_{i-1}^S\bigl(G_i(S)^c\bigr)\right] + \le + \E_S\!\left[\ind_{H(S)} + \mu_0^S\bigl(G_i(S)^c\bigr)\right] + \le \eta(q). +\] +The first inequality is the comparison at each fixed pattern; the second +is \cref{lem:screen-shielding} after averaging over the selected trial. +At a fixed mesh the pattern space is finite, so choose these adjacent +conditional couplings measurably in $S$. Apply the displayed estimate to +each of their marginal failure probabilities, then glue the four couplings +and use a union bound. Their searches stay in disjoint buffers, and every +intermediate law retains the original pattern marginal. This proves the +asserted joint coupling. + +On a successful pattern, join the outer arm ends through compact cores +of the blocks. The core portions together with the open arms and the +new bridges give a closed walk winding once around $B$ and lying inside +$Q$. Extract a simple winding cycle, with its lattice-width incident +sites, by deterministic loop erasure. On every non-open core edge, +condition on both incident $d$ sites; include the incident sites at the +transitions. Along the arms and bridges no $d$ observation is needed. +Indeed the local factor there is $t\ind_{s_i=s_j}$, independent of +transverse colors. Along a remaining core edge all its $s,W$ data and +the two incident $d$ values are fixed. Every local factor crossing the +cycle is consequently either fixed or independent of the transverse +variables. The Gibbs weight factors into an inside weight and an +outside weight after these observations. This proves conditional +independence. This factorization is made with colors as actual spin +variables, before summing them into cluster-count factors; no hidden +connectivity weight remains across the separator. All observed $d$ +sites lie in the compact cores and outside the shielding disks. +\end{proof} + +\begin{proof}[Proof of \cref{prop:screened-orthogonality} in the plane] +Truncate the insertion to $[-T,T]$, writing the result as +$X_\delta^{(T)}$, and set +\[ + r(T)=\sup_\delta\E_{\P_\delta} + |X_\delta-X_\delta^{(T)}|. +\] +The moment bound gives $r(T)\to0$. Suppose the coupling mismatch +probability is $\varepsilon$, and the unsuccessful-pattern probability +is $\zeta$. Duality against bounded functions gives +\begin{align} + \|\E_{\P_\delta}[X_\delta^{(T)}\mid\mathscr E_\delta]\|_1 + &\le + \|\E_{\mathbb Q_\delta} + [X_\delta^{(T)}\mid\mathscr E_\delta]\|_1 + +2T\varepsilon\notag\\ + &\le + \|\E_{\mathbb Q_\delta}[X_\delta^{(T)}\mid Y_\delta]\|_1 + +2T\varepsilon+2T\zeta\notag\\ + &\le + \|\E_{\P_\delta}[X_\delta^{(T)}\mid Y_\delta]\|_1 + +4T\varepsilon+2T\zeta. + \label{eq:screen-bounded-coupling} +\end{align} +For the middle inequality use conditional independence on success and +bound the unsuccessful histories by their probability times $2T$. +The outer inequalities use agreement of the joint insertion and +conditioning data. They do not require equal laws of $Y_\delta$. + +By \cref{lem:screen-core-colors}, at each fixed layout the final +conditional norm has limsup at most $r(T)$. The coupling and trial +lemmas give $\varepsilon\le4\eta(q)$ and +$\zeta\le4(1-p(q))^M$. Returning from $X_\delta^{(T)}$ to $X_\delta$ +therefore gives +\[ + \limsup_{\delta\downarrow0} + \|\E[X_\delta\mid\mathscr E_\delta]\|_1 + \le 2r(T)+16T\eta(q)+8T(1-p(q))^M. +\] +Given an error tolerance, first fix $T$ large, then $q$ small, then +$M$ large, and finally fix a layout as in \eqref{eq:screen-scale-order}. +Taking its mesh limit proves \eqref{eq:plane-exterior-orthogonality}. +Only original-law moments have been used; there is no moment assumption +for the artificially pinned law. +\end{proof} + +\subsection{Transfer to flat domains} + +\begin{proof}[Completion of the proof of +\cref{prop:screened-orthogonality}] +Choose a regular, fixed-width spin ring $A$ between the insertion and +$\partial Q$, with positive clearance from both. Let $R_\delta$ denote +both spins on a lattice-width enlargement of this ring. For a ring +assignment $r$ admitting an interior filling, let $\mathsf K_\delta^r$ +be the finite interior spin Gibbs kernel obtained from +\cref{eq:spin-constraint,eq:spin-weight}, with $r$ fixed on the ring and +all factors meeting the interior retained. Define +\[ + g_\delta(r)=\int X_\delta\,\dd\mathsf K_\delta^r, +\] +and put $g_\delta(r)=0$ when no interior filling is admissible. +The neutral insertion is determined by the interior height increments, +so its value in this formula is independent of an additive height anchor. +The finite product weights give this same conditional interior kernel in +every flat domain; the identity also passes from flat exhaustions to the +plane on cylinder events. Thus $g_\delta(R_\delta)$ is a version of the +conditional mean of $X_\delta$ under each of these laws, including on +admissible ring assignments that may have zero plane probability. All +these expectations are finite at each mesh. + +Apply the separated-block proof to a slightly smaller surrounding square, +whose exterior contains the ring. All its strict projection clearances +persist under this small change of the surrounding square. Since the ring +data belong to that exterior sigma-field, conditional Jensen gives +$\E_{\P_\delta}|g_\delta(R_\delta)|\to0$, hence convergence in plane +probability. The uniform full-spin +contiguity of \cref{prop:full-contiguity}, on a fixed larger box, +transfers this convergence in probability to the flat laws, even for +mesh-dependent tests of the ring data. The neutral moment estimate in +\cref{lem:screen-pattern-moments}, with no patterns, gives uniform +integrability of these conditional means by conditional Jensen. +Consequently their absolute means tend to zero uniformly over the +flat laws. Finally the Markov property across the ring gives +\[ + \E[X_\delta\mid\mathscr E_\delta(Q)] + =\E[g_\delta(R_\delta)\mid\mathscr E_\delta(Q)], +\] +and conditional Jensen proves the asserted exterior estimate. Uniformity +can equivalently be checked by taking an arbitrary contradicting +sequence of flat domains; all buffers remain fixed and the same argument +applies. At a random exact cut, the statement is used for the realized +conditional flat law. Subsequent conditioning is not included in this +claim. +\end{proof} + +In particular, if finitely many spectator height differences or heights +anchored on an exterior wall are evaluated along paths outside $Q$, +their bounded functions are legitimate exterior observables. Unbounded +products are handled by the moment estimates of the next section. This +is the conditional harmonicity input, with no box shrinking at the +lattice scale. diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/06-gaussian.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/06-gaussian.tex new file mode 100644 index 0000000000000000000000000000000000000000..d860d713d9dd8a4752b2241ecf575625100405ab --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/06-gaussian.tex @@ -0,0 +1,1140 @@ +\section{Flat-domain Gaussian limits} +\label{sec:gaussian} + +We prove the Gaussian limit for the unit-increment height +\(K_\delta=2H_\delta\), first in deterministic flat chambers and then +conditionally in chambers produced by a stopping exploration. The uniformity +in the chamber is what permits the second use. + +Every chamber in this section is an accessible component behind a connected +matching \(W\) perimeter, with the medial resolution at pinches from +\cref{lem:finite-cuts}. Its open face domain is simply connected. The +perimeter carries its actual wire, and incident faces are not joined across a +pinch. We subtract its constant height. For the moment arguments choose \(N\) +to be the free current complementary to this wall percolation \(W\); all its +interior components then have fair colors. The initial flat domain is +included by taking \(N\) to be the free dual current. Either corner parity +may carry the wall. + +A collection of chambers will always have pairwise disjoint open interiors; +their closures may touch. Sample their centered flat laws independently, +patch the fields on these disjoint cell interiors, and set the field to zero +on the exposed complement. Let \(U_\delta\) denote their open union. Fix an +open disk \(B_0\) containing all chamber closures with a fixed outer margin, +and put +\[ + F_\delta=\overline B_0\setminus U_\delta. +\] +Thus \(F_\delta\) is the closed complement in a common compact ambient set. +Hausdorff convergence of these \(F_\delta\) is equivalent here to local +Hausdorff convergence of the closed complements in the plane. Constants may +depend on \(B_0\), the fixed parameter, and the moment order, but not on the +shapes or the number of chambers. + +\begin{theorem}[Flat-domain limit]\label{thm:flat-gff} +Let \(U_\delta\) be a single deterministic flat chamber, or a finite +mesh-dependent union of independent chambers with pairwise disjoint +interiors, as above. Suppose \(F_\delta\) converges in Hausdorff distance to +\(F\), and set \(U=B_0\setminus F\). Then +\[ + K_\delta\ \Longrightarrow\ h_U/a + \quad\text{in }H^s_{\mathrm{loc}}(U),\qquad s<-1, +\] +where the restrictions of \(h_U\) to the components of \(U\) are independent +zero-Dirichlet GFFs with logarithmic singularity \(-\log|x-y|\). All finite +joint smooth-test moments with supports in \(U\) converge. Different limiting +components are independent even if their discrete precursors were the same +chamber. Either wall parity and either atomic or interpolated smearing gives +the same limit. The fields extended by zero off \(U_\delta\) are uniformly +tight in \(H^s_{\mathrm{loc}}(B_0)\) for every \(s<-1\). +\end{theorem} + +The proof first bounds all moments and their boundary traces. Screened +orthogonality then makes the limiting moments harmonic away from collisions; +a local neutral-pair comparison identifies their logarithmic poles and hence +their Wick recursion. We determine its coefficient from the plane limit +before completing the theorem. The last proposition turns the deterministic +result into the conditional statement needed for stopped explorations. + +\subsection{Limiting chambers and their Green kernels} + +For an open set \(V\) whose components are simply connected, write \(G_V\) +for the Dirichlet kernel with logarithmic singularity \(-\log|x-y|\) in +each component, extended by zero between different components and when +either argument lies outside \(V\). For tests put +\[ + G_V(f,g)=\iint f(x)G_V(x,y)g(y)\,\dd x\,\dd y. +\] +The planar connected-complement criterion shows that \(F_\delta\) above is +connected: an open subset of the sphere has simply connected components +exactly when its complement is connected. This uses disjoint interiors, not +disjoint closures. The next lemma supplies the boundary facts used twice +below, first in Wick's rule and then in the conditional limit. + +\begin{lemma}[Connected complements and Green convergence] +\label{lem:flat-green-geometry} +Let \(F_n\) be connected compact subsets of \(\overline B_0\) containing +\(\partial B_0\), and suppose \(F_n\to F\) in Hausdorff distance. Put +\(V_n=B_0\setminus F_n\) and \(V=B_0\setminus F\). Every component of +\(V_n\) and \(V\) is simply connected, every compact subset of \(V\) is +eventually contained in \(V_n\), and +\[ + G_{V_n}(x,y)\longrightarrow G_V(x,y) +\] +locally uniformly for distinct \(x,y\in V\), including when they lie in +different components of \(V\). +The zero-extended kernels satisfy \(0\le G_{V_n},G_V\le G_{B_0}\). +As a function of the closed complement and its two arguments, this +zero-extended Green kernel is Borel measurable. + +For any proper simply connected domain \(W\), with +\(d_W(x)=\dist(x,\partial W)\), one has +\begin{equation} + 0\le G_W(x,y)\le + 4\sqrt{\frac{d_W(x)}{|x-y|}} + \quad\text{if }d_W(x)\le\frac{|x-y|}{16}. + \label{eq:flat-green-boundary} +\end{equation} +In particular these Green kernels have zero boundary trace without a +boundary smoothness assumption. +\end{lemma} + +\begin{proof} +Adjoin the exterior of \(B_0\) in the sphere. The complements remain +connected, and so does their Hausdorff limit. The planar criterion just +stated gives simple connectivity of every open component. Hausdorff +convergence of compact sets gives uniform convergence of their distance +functions, which proves compact containment. + +For the estimate, choose a conformal map \(f:\mathbb D\to W\) with +\(f(0)=x\), and write \(f(z)=y\). The growth bound and the quarter theorem +recalled in \cref{sec:conformal-growth} give +\[ + |x-y|\le |f'(0)|\frac{|z|}{(1-|z|)^2} + \le \frac{4d_W(x)}{(1-|z|)^2}. +\] +Under the stated hypothesis this implies \(|z|\ge1/2\). The conformal +Green identity and \(-\log t\le2(1-t)\) for \(1/2\le t\le1\) now give +\cref{eq:flat-green-boundary}. + +For convergence, domain monotonicity gives the common bound +\(0\le G_{V_n}\le G_{B_0}\), with zero understood between components. +The upper kernel is bounded on compact sets away from the diagonal and +has only an integrable logarithmic singularity on the diagonal. Fix \(y\in V\) and a +component \(C\) of \(V\). On compact subsets of \(C\setminus\{y\}\), +harmonic compactness gives subsequential limits in the first variable. +If \(y\in C\), a fixed disk about \(y\) is eventually contained in one +component of \(V_n\). On that disk subtract \(\log(1/|x-y|)\). +The difference is harmonic and uniformly bounded on a fixed interior +circle by the common upper bound; the Poisson formula therefore preserves +the unit logarithmic pole in the limit. If \(y\notin C\), there is no pole. + +For \(x\in V_n\), its distance to the boundary of its component equals +\(\dist(x,F_n)\). Passing \cref{eq:flat-green-boundary} to a subsequential +limit shows that this limit has zero trace on \(\partial C\), since +\(\dist(x,F_n)\to\dist(x,F)\). The maximum principle now identifies it +as \(G_C(\,\cdot\,,y)\) when \(y\in C\), and as zero when \(y\notin C\). +The removable difference is bounded near its pole and near the boundary, +so the maximum principle applies on the whole component. Every +subsequential limit is the same. Interior harmonic estimates in both +variables give the asserted local uniform convergence. The common +logarithmic upper bound also gives convergence of \(G_{V_n}(f,g)\) for +fixed smooth tests with supports compactly contained in \(V\). +On the space of connected complements, the local uniform assertion gives +continuity of \(G_{B_0\setminus F}(x,y)\) where \(x,y\notin F\) and \(x\ne y\). +These positive-clearance sets form a countable cover of the interior +off-diagonal pairs. Extension by zero off the open set and the usual +diagonal value therefore give a Borel kernel, and hence Borel smeared +covariances. +\end{proof} + +\subsection{Moments and boundary traces} + +Choose once \(R_0>2\diam(B_0)\). + +\begin{proposition}[Logarithmic moments] +\label{prop:log-moments} +Let $z_1,\ldots,z_{2m}$ be corner-grid sites in a flat chamber of +diameter at most $R_0/2$. They may lie on either parity. Then +\begin{equation} + \left|\E\prod_{i=1}^{2m}K(z_i)\right| + \le C_m\sum_{\mathcal P}\prod_{\{i,j\}\in\mathcal P} + \left(1+\log^+\frac{R_0}{|z_i-z_j|\vee\delta}\right), + \label{eq:flat-log-moments} +\end{equation} +where the sum is over pairings. Odd moments vanish. The same bound holds for +independent flat chambers after setting the field to zero off those chambers. +For a compactly supported bounded test $f$, uniformly over all such chambers, +\begin{equation} + \E|K_\delta(f)|^{2m}\le C_m\|f\|_\infty^{2m}. + \label{eq:flat-smearing-moments} +\end{equation} +For any fixed smooth compactly supported profile $f$, put +$f_{r,z}(x)=r^{-2}f((x-z)/r)$. If $0<\delta\le r$, then +\begin{equation} + \E|K_\delta(f_{r,z})|^{2m} + \le C_{m,f}\left(1+\log^+\frac{R_0}{r}\right)^m. + \label{eq:flat-scaled-moments} +\end{equation} +This includes a mass-one smooth average of radius $r$ for a fixed profile. +\end{proposition} + +\begin{proof} +Condition on the current $N$ and the $s$ spins. By \cref{lem:finite-cuts}, +the centered height at a wall-parity site is a sum of jumps of size two with +independent fair signs, one sign per contributing cluster. A cluster's +coefficient at a site is zero or has absolute value two. Its sign is shared +by all its odd holes. + +The same signed expansion controls opposite-parity sites. For such a site +$x$, choose an incident wall-parity site $v$, and let $C_x$ be the free +$N$ component containing $x$. The corner rule gives +\[ + K(x)=K(v)+\varepsilon_W s(v)d(C_x), +\] +where the fixed sign $\varepsilon_W$ records which parity carries $W$. +Absorb this term into the coefficient of $d(C_x)$. Conditional on $(N,s)$, +every height is still a sum of the independent fair component colors, +now with coefficients of absolute value at most three. If a component has +a nonzero coefficient at a site, that site lies in the component or its +filled hull up to distance $O(\delta)$: wall-parity contributions come from +odd holes, and the extra contribution is incident to the component. +Consequently a component shared by two sites has diameter at least their +separation minus $O(\delta)$. + +Expanding an even product and summing the independent signs leaves only +terms in which every sign appears an even number of times. +Pair the occurrences of each such sign. Overcounting by all pairings gives +an upper bound by $C_m$ times sums of products of shared-cluster counts +$M(z_i,z_j)$. This argument does not assert independence of the counts. + +A contributing cluster surrounds or is incident to the relevant site. +The preceding support observation gives the required diameter lower bound +for a shared cluster. At a fixed site only boundedly many components of +diameter at most $C\delta$ can contribute, including isolated vertices; +put all of these contributions in the lattice cutoff. Above that cutoff, +a fixed number of boxes at a cluster's diameter scale detect its passage +or enclosure. By +\cref{prop:cluster-counts}, the count in each such dyadic shell has uniformly +bounded moments of every fixed order. Minkowski's inequality therefore gives +\[ + \|M(z_i,z_j)\|_{L^m} + \le C_m\left(1+\log^+\frac{R_0}{|z_i-z_j|\vee\delta}\right). +\] +Holder's inequality for the product of the $m$ counts proves +\cref{eq:flat-log-moments}. Height reflection about the flat value proves +vanishing of odd moments. The argument is unchanged in several independent +chambers; shared-cluster counts between different chambers are zero. + +Integrate the estimate against the interpolation weights, or the atomic +Riemann weights, of the tests. Each logarithmic factor is uniformly +integrable in its two variables, including its lattice diagonal: the latter +contributes $O(\delta^2\log(1/\delta))$. Since the pairs have disjoint sets +of variables, this proves \cref{eq:flat-smearing-moments}. Rescaling a +fixed profile by $x=z+ru$ gives \cref{eq:flat-scaled-moments}. Here +$\delta/r\le1$ is essential for an atomic smearing: after the rescaling +the diagonal part has the additional uniformly bounded factor +$(\delta/r)^2\log(r/\delta)$, while the common scale contributes +$1+\log^+(R_0/r)$. +\end{proof} + +\begin{proposition}[Boundary decay] +\label{prop:boundary-decay} +Consider deterministic flat chambers in a fixed bounded region, with +connected accessible walls, and a Hausdorff limit of their complements. +For any limiting open component, moment kernels obtained from +\cref{eq:flat-log-moments} have zero boundary trace in a distinguished +variable when the other variables remain at distinct interior points. +The bounds and the trace conclusion are uniform for the discrete chambers. +More precisely, a shared cluster joining the height contribution at a site +within distance $r$ of a matching connected wall to one at distance at least +$R$ from that site has probability at most $C(r/R)^\eta$, with fixed +positive outer clearance and $\delta\le r\ll R$. +\end{proposition} + +\begin{proof} +The relevant wall component reaches from the small scale to the outside of +the fixed testing window. A shared cluster either is incident to the +distinguished site or encloses it. In the incident case its connected +passage reaches the outer scale forced by the distant spectator. In both cases it must +avoid matching circuits attached to this wall at every scale between +$r$ and $R$: such a circuit separates the distinguished contribution +from the distant one. The conditional circuit estimate in \cref{prop:circuits} +gives a uniformly positive success probability at a fixed fraction of these +separated scales. An attached circuit blocks the cluster, so iteration gives +$C(r/R)^\eta$. The argument is within the accessible chamber with its wire +retained; no regularity of the geometric wall is used. + +In every pairing contributing to a mixed even moment, the distinguished +site is paired with one spectator. The corresponding shared cluster has +a fixed positive minimum diameter. Its count, restricted to surviving the +attached-circuit trials, tends to zero in every smaller $L^p$ norm: apply +Holder to the survival indicator and the higher count-moment bound from +\cref{prop:cluster-counts}. The remaining counts are bounded by +\cref{eq:flat-log-moments}. This proves vanishing of the mixed moment as +the distinguished site approaches the wall. For fixed distinct spectators +the pairing bound itself is uniformly bounded near the wall. Smearing first +at a radius smaller than the site's wall distance gives the same result +for distributional moment limits. Once harmonicity is established below, +the mean-value property identifies these smearing limits with the pointwise +boundary trace. The proof also applies when the wall develops a pinch: +only the actual connected wall crossing the testing scales is used. +\end{proof} + +\begin{lemma}[Parity and interpolation] +\label{lem:parity-interpolation} +On compact subsets with positive clearance from the wall, the two parity +smearings of $K$, and their smooth nodal interpolation, have the same +subsequential distributional limits and the same joint test moments. +Here each original parity has Riemann weight $\delta^2$; the combined +corner grid has weight $\delta^2/2$ per site. Thus its interpolation is +compared to the average of the two parity smearings, not their sum. +\end{lemma} + +\begin{proof} +Pair each site of one parity with an incident site of the other parity by a +fixed lattice translation. The paired height difference is $Z_e\in\{-1,1\}$. +Conditional on $(N,s)$ it is, up to a deterministic orientation, a fixed +$s$ spin times the fair color of the adjacent $N$ component. Thus for two +well-separated paired edges, +\[ + |\E[Z_eZ_{e'}]|\le + \P(\text{their adjacent sites belong to the same }N\text{ component}). +\] +A matching $W$ circuit around the first edge separates these components. +Bulk circuit trials between the lattice scale and their separation imply +that, for separation at least $r$ and fixed wall clearance, +$|\E[Z_eZ_{e'}]|\le C(\delta/r)^\eta$. This is equivalently the conditional +fair-color coupling in disjoint pin-free buffers. In particular it does not +infer smallness merely from the deterministic bound $|Z_e|=1$. + +For a smooth test, the variance of its averaged paired differences is bounded +by $C r^2+C(\delta/r)^\eta$: separate pairs at distance below $r$ from all +other pairs. First let $\delta$ decrease to zero and then let $r$ decrease +to zero. Changing the test's evaluation point within a paired cell gives an +$O(\delta)$ smooth-test error in $L^2$ by +\cref{eq:flat-smearing-moments}. This proves convergence of the difference +to zero in $L^2$. Uniform higher moments and interpolation give convergence +in every finite $L^p$. Nodal interpolation is an average of the same local +pairings with smooth weight errors, so the argument includes it. +\end{proof} + +\begin{lemma}[Tightness and absence of collision measures] +\label{lem:flat-tightness} +Centered flat heights are tight in $H^s_{\mathrm{loc}}$, for every $s<-1$, +uniformly over the chambers above. Every finite joint test moment converges +along distributional convergence. Once the limiting moment distributions +are harmonic off their collision diagonals, their smooth representatives +there represent the full distributions: there are no additional measures +or distributions supported on those diagonals. +\end{lemma} + +\begin{proof} +Put a cutoff $\chi$ in a fixed square regarded as a torus, with normalized +Fourier basis $e_n$. The uniform second-moment bound for +$K_\delta(\chi e_n)$ is independent of $n$. Hence, for $q>1$, +\[ + \sup_\delta\E\|\chi K_\delta\|_{H^{-q}}^2 + \le C\sum_{n\in\Z^2}(1+|n|^2)^{-q}<\infty. +\] +For $10$ for the coefficient denoted by $\beta$ in +\cref{prop:plane-green}: +for smooth compactly supported tests $\alpha,\beta$ of integral zero, +\begin{equation} + \lim_{\delta\downarrow0} + \E[K^{\mathrm{pl}}_\delta(\alpha) + K^{\mathrm{pl}}_\delta(\beta)] + =\kappa\iint\alpha(x)\beta(y)\log\frac1{|x-y|}\,\dd x\,\dd y. + \label{eq:subsequential-kappa} +\end{equation} +At this stage $\kappa$ may depend on the subsequence. In particular, +neither Gaussianity nor the final normalization is being assumed. + +The complementary open limit \(U\) may have several components even when +their discrete precursors belong to one component. Let \(T_j\) denote a +subsequential \(j\)th moment distribution on \(U^j\), with \(T_0=1\). +Their existence and convergence against test products follow from +\cref{lem:flat-tightness}. + +We explain why separated spectator heights are legitimate exterior +observations in the first application of screening. Localize the Laplace +test to a disk \(B\), and choose \(B,Q,Q^+\) concentric, with squares +\(Q\Subset Q^+\), so that the radius of \(B\) is less than one thousandth +of the side of \(Q\). +Choose \(Q^+\) compactly inside the limiting component containing \(B\), +disjoint from the spectator disks. An arbitrary local harmonicity test can be +partitioned into tests with such small supports. Fix a simple curve surrounding \(Q\) +inside \(Q^+\setminus\overline Q\), at positive distance from both +boundaries. For all sufficiently fine meshes, choose a simple corner-grid +approximation \(\Gamma_\delta\) of this curve in the discrete chamber and +outside \(Q\). + +A spectator in that chamber is read by summing corner increments from +its flat wall. Start with any such path. If it enters \(Q\), replace the +portion between its first and last encounters with \(\Gamma_\delta\) by +an arc of \(\Gamma_\delta\). The resulting path stays outside \(Q\). This +also works for spectators in a different limiting component of the same +discrete precursor. Spectators in other independently sampled chambers +may be adjoined to the exterior sigma-field: independence preserves the +screened conditional-mean bound. Thus a bounded function of all these +wall-anchored spectators is an allowed exterior observable. + +On a product of disjoint interior disks, truncate the spectator product, +apply \cref{prop:screened-orthogonality}, and remove the truncation by +Holder's inequality and the higher moment bounds. This gives +\[ + \Delta_{x_i}T_j=0\qquad(1\leq i\leq j). +\] +Summing these equations gives an elliptic equation on the product space. +Thus $T_j$ has a smooth, +separately harmonic representative off the diagonals. +\cref{lem:flat-tightness} now excludes any additional distribution on the +diagonals. Flat height +reflection gives $T_1=0$. The logarithmic moment bound and +\cref{prop:boundary-decay} apply to these representatives, by averaging +on disjoint circles. They give, respectively, polylogarithmic growth +at a collision and zero boundary trace in each variable away from the +other insertions. + +\begin{lemma}[Uniform logarithmic expansion] +\label{lem:log-singularity} +If $(y,\mathbf z)$ is a collision-free list of interior points, then, +near $x=y$, +\begin{equation} + T_j(x,y,\mathbf z) + =L_j(y,\mathbf z)\log\frac1{|x-y|} + +R_j(x;y,\mathbf z), + \label{eq:logarithmic-expansion} +\end{equation} +where $R_j$ extends harmonically in $x$ across $y$. The coefficient +$L_j$ is smooth in all its arguments. On a compact set of allowed +$(y,\mathbf z)$, the expansion holds on a common radius, and the +remainder and each fixed order of its $x$-derivatives are uniformly +bounded on a smaller common radius. +\end{lemma} + +\begin{proof} +A harmonic function on a punctured disk has constant angular mode +$a+b\log r$ and nonconstant modes $a_n r^n+b_n r^{-n}$, $n\geq1$. +Polylogarithmic growth forces every $b_n$ to vanish. This proves the +expansion and removability of its remainder. To obtain parameter +uniformity, choose a fixed radius $q$ avoiding all other insertions. +The coefficient is the outward flux +\begin{equation} + L_j(y,\mathbf z) + =-\frac1{2\pi}\int_{|w-y|=q} + \partial_{n_w}T_j(w,y,\mathbf z)\,\dd s_w. + \label{eq:collision-flux} +\end{equation} +After writing $w=y+q\exp(i\vartheta)$, the integrand varies smoothly +on a collision-free compact set. This proves smoothness of $L_j$. +Subtract its logarithm from the boundary values on the circle and +apply the Poisson formula. Interior derivative estimates give the +claimed uniform bounds on $R_j$. This obtains uniformity from a +fixed circle, not from a potentially nonuniform singular limit. +\end{proof} + +We next state the precise local independence needed to read this flux. +For a smooth test $\alpha$, put +$\alpha_r(x)=r^{-2}\alpha((x-y_0)/r)$. For the neutral insertions below, +use the bilinear nodal smearing of \cref{sec:spectral} in both the flat and +plane laws. Its coefficient array has exactly zero sum, and this is +precisely the discretization in \cref{eq:subsequential-kappa}. +In flat chambers \cref{lem:parity-interpolation} identifies this choice +with either parity smearing. + +\begin{lemma}[A neutral pair and distant observations] +\label{lem:neutral-pair-mixing} +Fix an interior disk $B(y_0,4R)$ and a finite family of spectator +tests supported outside it. Let $Y_\delta$ be a product of the +corresponding flat height averages, or of smoothed plane increments. +If $\alpha,\beta$ are smooth zero-integral tests in disjoint bounded +disks, then +\begin{align} + \lim_{r\downarrow0}\limsup_{\delta\downarrow0} + \big|&\E[K_\delta(\alpha_r)K_\delta(\beta_r)Y_\delta] + \notag\\[-1mm] + &-\E[K^{\mathrm{pl}}_\delta(\alpha_r) + K^{\mathrm{pl}}_\delta(\beta_r)]\, + \E Y_\delta\big|=0. + \label{eq:neutral-factorization} +\end{align} +For flat fields, the assertion is uniform over patched collections in a +common bounded region for which the local chamber contains this disk and +every spectator buffer lies in its assigned chamber. All boundary constants have been +subtracted. Spectators in other independently sampled pieces are allowed. +\end{lemma} + +\begin{proof} +Here are the stopping and coloring details of the coupling. Rescale +$R$ to one and take $\rho=r^{1/2}$; all sufficiently small $r$ have +both local supports in $B(y_0,Cr)\subset B(y_0,\rho)$. +Search inward using only $(s,W)$ for a monochromatic open $W$ circuit +in the stack of annuli between radii $\rho$ and $R$. The search stops +on the first complete circuit and does not inspect its interior. +By \cref{prop:circuits,prop:comparison}, the probability of exhausting +the stack without finding a circuit is at most $C\rho^\eta$, for +some $\eta>0$. The exponent and constants depend on the fixed model +parameter and the buffered shapes, not on the flat domain. + +On success reveal the entire exterior of the stopped circuit, +including its transverse colors. No $N$-cluster crosses an open +$W$ circuit, so this revelation determines the outside color +identifications without imposing an interior color constraint. +By \cref{lem:finite-cuts}, the unexplored interior is a flat law, +with its constant $s$ boundary value and independent fair colors on +its free $N$-clusters. The sign of the wall causes no change to the +law of neutral height increments: reflect a spin sign if necessary. + +The spectator heights are measurable in the revealed exterior. +For a bounded flat piece, read each of them by summing corner +increments from its prescribed wall along paths avoiding +$B(y_0,R)$. Such paths exist: any path entering this interior disk +can be detoured through an annulus contained in the domain. The +same detour works in all sufficiently fine approximations, and +averaging uses only nearby exterior sites. For plane increments, +choose the integration paths between their two spectator buffers +outside the disk. Thus we have not conditioned on absolute heights +before obtaining a genuine stopping cut. + +Inside the circuit apply the common-cut monotone coupling from +\cref{prop:comparison,prop:circuits} to the flat law and the plane +law. Between scales $Cr$ and $\rho$ there are order +$\log(\rho/r)$ buffered trials. Each successful common signed +$W$ circuit makes the two unexplored interiors identical in law. +After this cut, couple their $(s,W)$ configurations identically +and assign the same fair colors to the corresponding interior +$N$-clusters. Failure has probability at most $C(r/\rho)^\eta$. +This construction is valid for every exposed exterior history; +in each conditional coupling its second marginal is the same +unconditioned plane law. Consequently that marginal is independent +of the spectator observations. On a failed initial search choose +the plane copy independently. If necessary, first perform the +construction in finite flat exhaustions and then pass to the +plane law. +More explicitly, a completed $W$ cut removes every transverse interaction, +so fixing exterior colors leaves a kernel determined only by its signed +wall, with no interior color pins. For each history, bracket this kernel +and a plane exhaustion by the same ordered extreme boundary laws on an +interior buffered region. The common-cut coupling preserves both marginals; +after its cut use the identical free interior colors. Its plane marginal +does not depend on the history. Thus the circuit trials use only $(s,W)$ +conditioning, never a residual law with arbitrary transverse-color pins. + +The coupled local increments therefore agree outside an event +$\mathcal B_{\delta,r}$ satisfying +\begin{equation} + \limsup_{\delta\downarrow0}\P(\mathcal B_{\delta,r}) + \leq C\{\rho^\eta+(r/\rho)^\eta\} + \leq C r^{\eta/2}. + \label{eq:local-coupling-error} +\end{equation} +Agreement determines local heights up to a constant, which the +exactly neutral weights remove. In particular both local smeared +variables agree on the successful event. + +For completeness, the unbounded factors cost only logarithms. +For each fixed \(r\), the exactly neutral lattice coefficients are +discretizations of fixed scaled smooth profiles, with the same bounds +once \(\delta/r\) is sufficiently small. Thus +\cref{eq:flat-scaled-moments} gives, for every fixed finite $p$, +\begin{equation} + \limsup_{\delta\downarrow0} + \|K_\delta(\alpha_r)\|_{L^p} + +\limsup_{\delta\downarrow0} + \|K_\delta(\beta_r)\|_{L^p} + \leq C_p(1+|\log r|)^{1/2}. + \label{eq:shrinking-smearing-moment} +\end{equation} +The logarithmic diagonals are integrable, including their lattice +cells. The corresponding plane bounds are uniform in $r$, by +the scale-invariant regularity estimate +\cite[Theorem~4.5]{DKLM2026}. The fixed, smoothed spectator product +has bounded moments of every finite order. H\"older's inequality +with four factors, namely the two insertions, the spectator product, +and the failure indicator, now bounds the discrepancy by +\[ + C r^{\eta/8}(1+|\log r|)=o(1). +\] +Only original-law and plane-law moments were used. No uniform +pointwise height moments or moment bounds under an artificially +conditioned law are required. The mesh limit is always first, +with the two continuum radii fixed. +\end{proof} + +\begin{proposition}[Collision coefficient] +\label{prop:collision-coefficient} +For $j\geq2$ and distinct $(y,\mathbf z)$ in $U$, +\begin{equation} + L_j(y,\mathbf z)=\kappa T_{j-2}(\mathbf z). + \label{eq:collision-coefficient} +\end{equation} +\end{proposition} + +\begin{proof} +Choose two smooth zero-mass tests $\alpha,\beta$ with disjoint +supports and +\[ + J=\iint\alpha(u)\beta(v)\log\frac1{|u-v|}\,\dd u\,\dd v\ne0. +\] +For an explicit choice let $\varrho_b$ be a smooth radial unit +bump supported within distance $1/10$ of $(b,0)$ and obtained by +translating one fixed bump. Take +$\alpha=\varrho_0-\varrho_1$ and +$\beta=\varrho_3-\varrho_4$. Radial harmonic averaging gives +$J=\log(8/9)\ne0$ exactly. + +Take fixed radial unit mollifiers in disjoint disks around the +spectator points $\mathbf z$. By separate harmonicity, averaging +$T_{j-2}$ in those disks gives exactly $T_{j-2}(\mathbf z)$. +The same is true of $T_j$ when its first two points lie in a +small disk around $y_0$ disjoint from the spectator disks. +Apply \cref{lem:neutral-pair-mixing} and +\eqref{eq:subsequential-kappa}. For each fixed $r$, the latter +plane pairing is $\kappa J$: the added constant $\log(1/r)$ +vanishes against neutral tests. Thus +\begin{equation} + \lim_{r\downarrow0} + \iint\alpha(u)\beta(v) + T_j(y_0+ru,y_0+rv,\mathbf z)\,\dd u\,\dd v + =\kappa J T_{j-2}(\mathbf z). + \label{eq:collision-local-limit} +\end{equation} +There is no additional large-$L$ limit in this choice of tests. + +On the other hand insert \cref{lem:log-singularity} in the left +side. The term +$L_j(y_0+rv,\mathbf z)\log(1/r)$ integrates to zero in $u$ +\emph{exactly}, before any continuity estimate. The remaining +logarithmic term tends to $L_j(y_0,\mathbf z)J$, uniformly for +spectator configurations in compact sets. For the remainder, +subtract $R_j(y_0;y_0+rv,\mathbf z)$ inside the $u$ integral. +The subtracted term again integrates to zero, and the uniform +first-variable derivative bound gives an $O(r)$ error. +Comparison with \eqref{eq:collision-local-limit} proves the formula. + +\end{proof} + +\subsection{Wick's rule in the limiting chambers} + +The following argument is local at +collisions and uses boundary decay, not a parametrization of the +rough boundary. It is the collision method of +\cite[Sections~9--10]{Triangular}, with the present cut and +coupling estimates supplied above. + +\begin{proposition}[Gaussian moment recursion] +\label{prop:gaussian-moments} +For every $j\geq2$ and distinct points in $U$, +\begin{equation} + T_j(x_1,\ldots,x_j) + =\kappa\sum_{i=2}^j G_U(x_1,x_i) + T_{j-2}(x_2,\ldots,\widehat{x_i},\ldots,x_j). + \label{eq:bounded-wick-recursion} +\end{equation} +Consequently the limiting centered field in $U$ is a Gaussian +field with covariance $\kappa G_U$. In particular its restrictions +to different components are independent. + +\end{proposition} + +\begin{proof} +Fix $x_2,\ldots,x_j$ and subtract the right side of +\eqref{eq:bounded-wick-recursion}. As a function of $x_1$ the +difference is harmonic away from these points. +\cref{prop:collision-coefficient} cancels every logarithmic pole +in its component; \cref{lem:log-singularity} removes the remaining +punctures. Points in other components do not produce a pole. +The resulting harmonic function has zero boundary trace by +\cref{prop:boundary-decay}. The Dirichlet Green functions have +the same zero trace by \cref{lem:flat-green-geometry}. The difference is +bounded, since it is bounded near the boundary and its finitely +many interior punctures are removable. The maximum principle +therefore makes it zero on each component. This proves the +recursion, including mixed moments when discrete components +have separated only in the limit. + +Starting with $T_0=1$ and $T_1=0$, the recursion gives zero odd +moments and the sum over perfect pairings of products +$\kappa G_U(x_i,x_j)$ for even moments. The products are locally +integrable. Since \cref{lem:flat-tightness} excludes diagonal mass, +the identity holds for the full smeared moment distributions. +These moments determine the law: if a real linear combination +$Z$ of smeared fields has variance $s^2$, then +\[ + \E Z^{2n}=(2n-1)!!s^{2n},\qquad + \E Z^{2n+1}=0,\qquad + \E|Z|^n\leq s^n(2n)^{n/2}. +\] +The exponential series is integrable for every real argument, +so the characteristic function is $\exp(-s^2u^2/2)$. +Apply this to all finite linear combinations and then to a +countable determining family of tests in the local Sobolev space. +The zero cross-component covariance proves independence. +\end{proof} + +\subsection{Plane increment kernels and their collisions} + +The free-energy correspondence used below asks for compact-uniform +convergence of all plane increment correlations. We now obtain that +conclusion from the same screened identity and neutral-pair comparison, +keeping the point correlations distinct from the smeared fields. + +Use the unit corner-grid coordinates of \cref{sec:spectral}. Let +\(\widetilde K_\delta^{\mathrm{pl}}(x)\) be the piecewise constant extension +of the plane unit height used in \cite[Definition~2.4]{DKLM2026}. For an +increment \(d_i=(x_i,y_i)\), define +\[ + \Phi_{m,\delta}(d_1,\ldots,d_m) + =\E\prod_{i=1}^m + \bigl(\widetilde K_\delta^{\mathrm{pl}}(x_i) + -\widetilde K_\delta^{\mathrm{pl}}(y_i)\bigr). +\] +After the fixed rotation and dilation of the grid, this is the source +correlation \(\Phi_m^{(\delta)}\) with endpoint convention +\(u_i=y_i,\ u_i'=x_i\), at the corresponding mesh. Its configuration space is +\[ + \mathcal D_m= + \bigl\{(d_1,\ldots,d_m)\in(\R^2\times\R^2)^m: + \{x_i,y_i\}\cap\{x_j,y_j\}=\varnothing\text{ for }i\ne j\bigr\}. +\] +The two endpoints of one increment may coincide. Put \(Q_0=1\). +Height-flip symmetry gives \(\Phi_{m,\delta}=0\) for odd \(m\), so their +limits \(Q_m\) are zero. For even \(m\), the regularity estimate and +precompactness result \cite[Theorem~4.5 and Corollary~4.6]{DKLM2026} give, +after a diagonal extraction on the chosen subsequence, +\[ + \Phi_{m,\delta}\longrightarrow Q_m + \quad\text{uniformly on compact subsets of }\mathcal D_m +\] +at every order. Each \(Q_m\) is continuous there. These are correlation +kernels, not products of point values of a continuum field. + +We first relate these kernels to the nodal smooth insertions used above. +For each neutral smooth test \(\alpha_i\), choose a smooth mass-one density +\(\rho_i\) in a separate remote disk, with all these disks disjoint from +the test supports and from each other. Let \(b_{\delta,v}^{(i)}\) be the +nodal interpolation coefficients for \(\alpha_i\), and let +\(r_{\delta,w}^{(i)}\) be discrete weights approximating \(\rho_i\) with +sum one. The corresponding signed measures converge to +\(\alpha_i(x)\dd x\) and \(\rho_i(y)\dd y\), and their atoms have absolute +weights \(O(\delta^2)\). Exact neutrality gives the finite identity +\[ + \sum_v b_{\delta,v}^{(i)}K(v) + =\sum_{v,w} b_{\delta,v}^{(i)}r_{\delta,w}^{(i)} + \bigl(K(v)-K(w)\bigr). +\] +Thus products of nodal insertions test \(\Phi_{m,\delta}\) with +independently integrated reference variables, rather than coincident +fixed anchors. Away from collisions between endpoints of different +increments, use compact-uniform convergence. The regularity estimate +bounds the omitted neighborhoods by integrable powers of logarithms, +uniformly after the lattice cutoff; their exact coincidence cells +contribute at most \(C\delta^2(1+|\log\delta|)^q\) for a fixed \(q\). +These integrals vanish as the neighborhoods shrink. Coincidence of an +increment's own endpoints has the vanishing increment-collapse bound, +not a singular term. This identifies the full smeared moment distributions +with the integrals of \(Q_m\), without losing a contribution at an anchor +or a collision. + +For \(m=2\), this identification and \cref{eq:subsequential-kappa} give +the covariance kernel +\begin{equation} + C_\kappa(d_i,d_j) + =\kappa\log + \frac{|x_i-y_j|\,|y_i-x_j|} + {|x_i-x_j|\,|y_i-y_j|}. + \label{eq:increment-covariance} +\end{equation} +as \(Q_2\). Indeed one may approximate each endpoint by a smooth mass-one +bump in a disjoint disk; the finite increment additivity and continuity of +\(Q_2\) then recover the displayed point kernel from the neutral pairings. + +Screening gives separate harmonicity of \(Q_m\) in every endpoint away +from the endpoints of other increments. To see the required exterior +measurability, localize a Laplace test in \(B\Subset Q\Subset Q^+\) as +before, with \(Q^+\) disjoint from the other endpoint buffers. In the +differentiated increment the remote endpoint cancels against the exactly +neutral Laplace coefficients. Each remaining increment is read along a +path between its two buffers outside \(Q\), using a fixed annular detour +when necessary. Smooth the remote endpoints in their buffers, apply +\cref{prop:screened-orthogonality} to the truncated spectator product, and +remove the truncation by the regularity moment bounds. The smearing +identification just proved gives distributional harmonicity of \(Q_m\). +Elliptic regularity gives its smooth separately harmonic representative +where endpoints of different increments are distinct. The argument also +allows the two endpoints of the differentiated increment to coincide, +since its reference term has canceled. + +Near a collision between different increments, the source regularity +estimate bounds \(Q_m\) by a power of the logarithm of the separation. +The analytic proof of \cref{lem:log-singularity} therefore applies to +each such endpoint collision: there is one logarithmic term, its coefficient +is given by a flux on a fixed circle, and the harmonic remainder and its +derivatives are uniformly bounded on compact sets of the other endpoints. +We can now identify that coefficient. + +\begin{lemma}[Signed plane collision coefficients] +\label{lem:plane-collision-coefficient} +Fix \(m\ge2\), and keep all endpoints other than \(x_1\) distinct. For +\(i\ge2\), the coefficient of \(\log(1/|x_1-z|)\) in \(Q_m\) is +\[ + \begin{cases} + \kappa Q_{m-2}(d_2,\ldots,\widehat{d_i},\ldots,d_m),&z=x_i,\\ + -\kappa Q_{m-2}(d_2,\ldots,\widehat{d_i},\ldots,d_m),&z=y_i. + \end{cases} +\] +After subtracting this logarithm, the remainder extends harmonically +through the collision. Swapping \(x_1\) and \(y_1\) gives the corresponding +rule with the opposite sign for the negative endpoint. +\end{lemma} + +\begin{proof} +First consider two positive endpoints. Use the neutral tests +\(\alpha,\beta\) from the proof of \cref{prop:collision-coefficient}, whose +logarithmic pairing is \(J=\log(8/9)\). Smooth every remote endpoint in a +small fixed radial disk. Integrating the two colliding endpoints against +\(\alpha_r,\beta_r\) cancels their two remote reference terms exactly. +By the smearing identification, the resulting expression is the limit +of the two neutral lattice insertions times a product of smoothed plane +increments. These spectators have the bounded moments required by +\cref{lem:neutral-pair-mixing}. That lemma and +\cref{eq:subsequential-kappa} give the limit +\[ + \kappa J\,Q_{m-2}(d_2,\ldots,\widehat{d_i},\ldots,d_m) + \qquad(r\downarrow0). +\] +Separate harmonicity removes the spectator mollifiers. In the uniform +logarithmic expansion, the term containing \(\log(1/r)\) integrates to +zero against \(\alpha\) before any limit; smoothness of the coefficient +and the uniform first-variable derivative bound for the remainder leave +the coefficient times \(J\). Comparing the two expressions proves the +positive sign. Antisymmetry under reversal of either increment gives the +negative signs. This calculation uses only smoothed spectator moments. +\end{proof} + +\begin{proposition}[Plane Gaussian correlations] +\label{prop:plane-gaussian-moments} +Along the chosen subsequence, all plane increment correlation functions +satisfy Wick's rule with covariance \(C_\kappa\). More precisely, +\(\Phi_{m,\delta}\to Q_m\) uniformly on compact subsets of \(\mathcal D_m\) +at every order, and \(Q_m\) is zero for odd \(m\), while for even \(m\) +it is the sum over pairings of products of \(C_\kappa(d_i,d_j)\). +\end{proposition} + +\begin{proof} +The cases \(m=0,1,2\) have been established. For even \(m\ge4\), induct +on \(m\) and subtract +\begin{equation} + \sum_{i=2}^m C_\kappa(d_1,d_i) + Q_{m-2}(d_2,\ldots,\widehat{d_i},\ldots,d_m) + \label{eq:plane-wick-recursion} +\end{equation} +from $Q_m$. In the variable $x_1$, +\cref{lem:plane-collision-coefficient} cancels all logarithmic poles at +$x_i$ and $y_i$, $i\geq2$, and its harmonic remainders remove the +punctures. The regularity estimate gives continuous extension through +$x_1=y_1$, with +value zero there; this is the collapse of the first increment, +not an additional collision between different factors. The +remainder is consequently entire harmonic. With all other +endpoints fixed, the same estimate bounds its growth by a fixed +power of $1+\log(2+|x_1|)$, in particular by $o(|x_1|)$. +An entire harmonic function of sublinear growth is constant: +the interior gradient bound on disks of radius $M$, followed +by $M\to\infty$, makes its gradient zero. At $x_1=y_1$ both +$Q_m$ and \eqref{eq:plane-wick-recursion} vanish. The constant +is therefore zero. This proves the plane Wick recursion. + +The argument initially identifies the kernels where all the +endpoints are distinct. The quoted equicontinuity and the +increment-collapse estimate extend the identity locally +uniformly to the full configuration spaces allowing the two +endpoints of one increment to coincide. Thus all orders, not +only covariance or smooth-test laws, have been identified on +one common subsequence. +\end{proof} + +\subsection{Identifying the coefficient without circularity} + +\begin{proposition}[Plane normalization] +\label{prop:plane-normalization} +For every subsequence considered above, +\begin{equation} + \kappa=\frac1{2\pi\arcsin(c/2)}=\frac1{a^2}. + \label{eq:identified-kappa} +\end{equation} +\end{proposition} + +\begin{proof} +The coefficient is strictly positive by \cref{prop:plane-green}. + +Set $\sigma^2=2\pi\kappa$. The plane Wick kernels just proved +are precisely those of $\sigma$ times a plane GFF in the +normalization with singularity $-(2\pi)^{-1}\log|x-y|$. +The fixed rotation and dilation used above leave the increment +cross-ratio in \cref{eq:increment-covariance} unchanged. +Their compact-uniform convergence at every order is the exact +hypothesis of \cite[Theorem~8.1]{DKLM2026}. That convergence +criterion, whose input is the regularity estimate, supplies +the full-plane subsequential scaling limit in the sense required +by its Definition~2.7. We may therefore apply +\cite[Theorems~4.3 and~4.4]{DKLM2026}: their free-energy correspondence +and explicit computation give +\[ + \sigma^2=\frac1{\arcsin(c/2)}. +\] +The source uses the column slope $I_{\rm col}/L$ and per-site free +energy, as reconciled in \cref{sec:input-amplitude}; that appendix +also records the finite-error factors before their final limits. +All three cited inputs apply for $1\leq c\leq2$; the present +fixed parameter satisfies $10$. Put +\[ + A_{\delta,d_0} + =\left\{\dist\left(\bigcup_i\supp f_i,F_\delta\right)\ge d_0\right\}. +\] +Then +\begin{equation} +\begin{split} + \E\Bigg[\ind_{A_{\delta,d_0}} + \Bigg|& + \E\left[\exp\left(i\sum_i u_iR_\delta(f_i)\right) + \,\middle|\,\mathcal E_\delta\right]\\ + &-\exp\left(-\frac1{2a^2} + \sum_{i,j}u_i u_jG_{U_\delta}(f_i,f_j)\right) + \Bigg|\Bigg]\longrightarrow0. +\end{split} +\label{eq:conditional-flat-characteristic} +\end{equation} +Here \(G_{U_\delta}\) is the continuum Dirichlet kernel of the resolved +open chamber union, with zero covariance between its components. + +Multiplying the displayed difference by any uniformly bounded +\(\mathcal E_\delta\)-measurable variable preserves the same estimate with +its clearance indicator. To state the limiting consequence, let +\(\mathsf E\) be a Polish space and let \(e_\delta\) be an +\(\mathcal E_\delta\)-measurable \(\mathsf E\)-valued variable. Suppose, +for one fixed \(s<-1\), that along a subsequence +\[ + (e_\delta,F_\delta,R_\delta)\Longrightarrow(e,F,R) + \quad\text{in }\mathsf E\times\mathcal K(\overline B_0) + \times H^s_{\mathrm{loc}}(B_0), +\] +where \(\mathcal K(\overline B_0)\) is the space of nonempty compact sets +with the Hausdorff metric. The limit \(F\) is almost surely connected and +contains \(\partial B_0\). Put \(U=B_0\setminus F\) and +\[ + A_F=\left\{\dist\left(\bigcup_i\supp f_i,F\right)>0\right\}. +\] +Then, almost surely, +\begin{equation} +\begin{split} + &\ind_{A_F}\, + \E\left[\exp\left(i\sum_i u_iR(f_i)\right) + \,\middle|\,\sigma(e,F)\right]\\ + &\qquad=\ind_{A_F}\, + \exp\left(-\frac1{2a^2} + \sum_{i,j}u_i u_jG_U(f_i,f_j)\right). +\end{split} +\label{eq:conditional-flat-limit} +\end{equation} +Thus, conditional on \(\sigma(e,F)\), the restrictions of \(R\) to the +component interiors of \(U\) are independent zero-boundary GFFs divided by +\(a\), including components born from a pinched single precursor. This is +first tested on deterministic compact buffers with positive limiting +clearance and then extended by a countable exhaustion. The retained variable +\(e_\delta\) may encode any exact-cut coordinates and flat constants for +which this joint convergence holds; the constants are added after the +centered assertion. Its \(\mathcal E_\delta\)-measurability excludes data +from any later revelation. +\end{proposition} + +\begin{proof} +For a deterministic realized chamber configuration, let its flat product +law supply the characteristic function in the first line of +\cref{eq:conditional-flat-characteristic}. The error from the displayed +Gaussian characteristic function tends to zero uniformly over all such +configurations with the stated clearance. Otherwise choose a sequence with +error bounded away from zero. Compactness of the closed complements in +\(\overline B_0\) gives a Hausdorff-convergent further subsequence, and the +clearance persists in its limit. The deterministic theorem gives convergence +of the flat characteristic function to the Gaussian one for that limit. +\Cref{lem:flat-green-geometry} gives +\(G_{U_\delta}(f_i,f_j)\to G_U(f_i,f_j)\) on the same subsequence. +The two characteristic functions therefore have the same limit, a +contradiction. + +Condition now on the stopped data. By \cref{lem:finite-cuts}, the +conditional kernel is exactly the deterministic product kernel just +considered, with its constants subtracted. The uniform error proves +\cref{eq:conditional-flat-characteristic}. Multiplication by any bounded +stopped-measurable variable preserves convergence to zero. + +Assume the displayed joint convergence and write +\(d(F)=\dist(\bigcup_i\supp f_i,F)\). Choose a bounded continuous function +\(\chi\) of the clearance whose support is contained in \([d_0,\infty)\) +for some \(d_0>0\), and a bounded continuous function +\(v\) on \(\mathsf E\times\mathcal K(\overline B_0)\). +Multiply the conditional difference by +\(\chi(d(F_\delta))v(e_\delta,F_\delta)\), and use the tower property for +the term involving \(R_\delta\). The estimate just proved makes the +resulting expectation tend to zero. Evaluation of \(R\) on a smooth test +and the clearance \(d(F)\) are continuous in the displayed state space. +The connected complements containing \(\partial B_0\) form a closed +subspace supporting every \(F_\delta\) and \(F\). On that subspace, +\cref{lem:flat-green-geometry} makes the Gaussian expression continuous +where \(\chi\) is supported. Joint convergence therefore gives +\begin{align*} + &\E\left[\chi(d(F))v(e,F) + \exp\left(i\sum_i u_iR(f_i)\right)\right]\\ + &\qquad=\E\left[\chi(d(F))v(e,F) + \exp\left(-\frac1{2a^2} + \sum_{i,j}u_i u_jG_U(f_i,f_j)\right)\right]. +\end{align*} +The monotone class theorem on the Polish space +\(\mathsf E\times\mathcal K(\overline B_0)\) extends this identity to +bounded measurable \(v\). A countable family of cutoffs \(\chi\) whose +positive sets cover \(d(F)>0\) now gives +\cref{eq:conditional-flat-limit}. A countable determining family of +smooth tests then identifies the regular conditional law on the component +interiors. The zero cross-component Green kernel gives their independence, +including when one precursor separates into several limiting components. +Increasing the list of buffers and decreasing their required clearance +gives the full interior statement. Jointly retained constants can then be +added. +\end{proof} diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/07-local-sets.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/07-local-sets.tex new file mode 100644 index 0000000000000000000000000000000000000000..ae0d3101cb614203dd880396f000cda0cfd7bd17 --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/07-local-sets.tex @@ -0,0 +1,888 @@ +\section{Stopped local sets and canonical clusters} +\label{sec:local-sets} + +We now identify the field left by a stopped current exploration. The +discrete field in this section is \(h_\delta=aK_\delta\), whose limit has +the normalization of \(h\). Two kinds of stops are needed. Stopping at a +fixed number of odd rims gives the two-valued carpets. A seed exploration +instead reveals whole current clusters; its limiting conditional field +will be used to decide which odd rims belong to one cluster. For both +stops we prove the conditional law on tests that cross the limiting cut. +This is stronger than identifying the field only in its open components. + +A closed set \(A\), together with information \(\mathscr E\), is a local +set of \(h\) when, conditionally on \(\mathscr E\), +\(h=h_A+h^{D\setminus A}\), where \(h_A\) is +\(\mathscr E\)-measurable and harmonic off \(A\), and +\(h^{D\setminus A}\) is the zero-extended GFF with independent +zero-boundary restrictions to the components of \(D\setminus A\). +Conditioning down to \(\sigma(A,h_A)\) gives the usual local-set definition. +It is \emph{thin} when \(h_A\) is integration against that harmonic +function, with no further distribution supported on \(A\). We include +the domain boundary in every closed local set. Thus statements about +zero area below concern its intersection with the open domain; a Jordan +boundary itself need not have zero area. + +For \(p,q>0\) with \(p+q\ge2\lambda\), a boundary-connected thin local +set with complementary values in \(\{-p,q\}\) is the canonical +\(\TVS{p}{q}\), by \cite[Proposition~2]{ASW2017}. Here +boundary-connected means that the closed set, with the boundary adjoined, +is connected; it supplies the topological condition in the bounded-type +thin-local-set theorem. This uniqueness does not assume that the candidate +was already measurable in the field. The resulting canonical set is +field-measurable. We use the Jordan-hole property in Jordan parents. When +a first odd carpet is constructed in a rough simply connected parent, its +two label magnitudes are \(2a>2\lambda\); its loops avoid the parent +boundary and hence remain Jordan under the interior conformal map. +These geometric facts and the nested constructions are in +\cite[Sections~3--4]{AS2018}. In particular +\(\TVS{2\lambda}{2\lambda}\) has \(\CLE_4\) holes with independent fair +signs and conditionally independent zero-boundary remainders. + +\subsection{Stops and their cut neighborhoods} + +We first specify the finite stops. In a free-current chamber of flat value +\(b\), descend through surrounding current clusters, continue through even +holes, and stop on the first odd rim along each branch. The closed complement +of the unsearched holes is the \emph{first odd carpet}; its hole values are +\(b-2a\) and \(b+2a\). Repeating this operation in the holes defines the +odd depth. This counts odd rims, not all clusters inspected: any number of +even holes may be passed before the next odd rim. All holes are the sealed +component faces of \cref{lem:finite-cuts}, with its medial resolution at +pinches. + +For a seed stop, use a fixed predictable growth rule: from the current +revealed data choose the next vertex and an attachment to the revealed +region, reveal the entire current cluster first met there, and stop using +the revealed data. Apart from the new vertex, the attachment uses only +already revealed vertices or known seed edges, with no unsearched free +vertex in between. The rule may follow a preassigned column sweep or choose +the lexicographically first unvisited vertex adjacent to the revealed +region. It may use discovery indices, observed diameters, or the first +observed odd jump around specified points. The seed trace may therefore +be adaptive; its union with the revealed clusters remains connected to +the exterior. +The terminal sigma-field \(\mathcal E_\delta\) includes the revealed +spins, edges, colors, heights, and the seed. The initial sigma-field +\(\mathcal E_{0,\delta}\) records only the exact flat cut from which this +exploration starts. Conditional on it, the initial unsearched chambers +have the independent flat laws of \cref{lem:finite-cuts}. + +We also use a composite seed stop for the wired current. Expose its +boundary cluster first, and then run one fixed global seed rule through +the remaining free chambers, attaching each newly visited seed piece +through the already revealed region containing that layer. A half-column sweep can be ordered +this way. Seed edges are edges of the underlying graph and need not be +current-open. After every added vertex, reveal the whole cluster met +there. The revealed union remains connected to the original boundary, +and the finite cut law applies simultaneously to all its residual +chambers. This is one exploration of the original field, even when one +discrete wired hole will later separate into several limiting holes. + +Write \(A_\delta\) for the revealed closed set with its one-cell +thickening, \(S_\delta\) for the seed at the stop, and \(W_{0,\delta}\) +for the initial revealed wall. For a carpet the seed is empty. Let +\(U_{0,\delta}\) be the union of the initial open chamber faces and let +\(F_{0,\delta}\) be its closed complement in the fixed enclosing disk +\(\overline B_0\) of \cref{sec:gaussian}. Define \(U_\delta,F_\delta\) +in the same way for the residual faces at the terminal stop. On compact +subsets of the initial domain, \(F_\delta\) and \(A_\delta\) differ only +by the \(O(\delta)\) medial displacement described immediately before +\cref{prop:conditional-flat-gff}. + +Use the same atomic smearing for all three finite distributions +\[ + M_\delta(\phi)=\E[h_\delta(\phi)\mid\mathcal E_\delta], + \qquad R_\delta=h_\delta-M_\delta,\qquad h_\delta=M_\delta+R_\delta. +\] +Thus \(R_\delta\) is \(a\) times the centered flat remainders of +\cref{prop:conditional-flat-gff}, patched by zero on exposed sites. +For bounded nonsmooth tests, a set denotes the union of its lattice +cells and the pairing is the corresponding atomic sum. This convention +also identifies it with piecewise constant integration up to the +smooth-test cell error. + +For a discovered cluster \(C\), let \(\mathcal O_\delta(C)\) be the union +of its odd holes. A contributor to a compact set \(Q\) is a discovered +\(C\) for which \(C\) or \(\mathcal O_\delta(C)\) meets \(Q\); write +\(N_\delta(Q)\) for their number. On the event +\[ + d_\delta(Q):=\dist(Q,F_{0,\delta}\cup S_\delta)\ge\rho>0, +\] +each contributor either reaches \(Q\) from the seed or surrounds a point +of \(Q\), and has diameter at least a fixed multiple of \(\rho\). +Consequently \(N_\delta(Q)\) is pathwise bounded by the initial +whole-box count of free clusters of that diameter. The domination and +tail in \cref{cor:global-cluster-counts}, conditional only on +\(\mathcal E_{0,\delta}\), make these counts uniformly tight over the +stopping rules. A completed terminal history can already record many +contributors, so no count tail conditional on that history is used. + +\begin{lemma}[Negligible cut neighborhoods] +\label{lem:cut-neighborhoods} +Let \(Q\) be a compact subset of the initial domain and fix \(\rho>0\). +Consider a seed stop just described, a carpet of fixed odd depth, or the +first wired layer. For the last two cases omit \(S_\delta\) in +\(d_\delta(Q)\). There are \(C,\alpha>0\), depending on \(Q,\rho\) and +the fixed depth when applicable, such that for \(0<\eta<\rho/20\), +\begin{equation} + \E\!\left[ + \ind_{\{d_\delta(Q)\ge\rho\}}\,|Q\cap A_\delta^\eta| + \,\middle|\,\mathcal E_{0,\delta}\right] + \le C(\eta+\delta)^\alpha . + \label{eq:cut-area} +\end{equation} +The bound is averaged over the production of the stop and is uniform +over the allowed initial flat data and stopping rules. + +Let \(\zeta_\rho\) be a continuous function on \([0,\infty)\), with +values in \([0,1]\), equal to zero on \([0,\rho]\) and to one on +\([2\rho,\infty)\). For every bounded \(\phi\) supported in \(Q\), +\begin{equation} + \lim_{\eta\downarrow0}\limsup_{\delta\downarrow0} + \E\!\left[\zeta_\rho(d_\delta(Q)) + |R_\delta(\phi\ind_{A_\delta^\eta})|^2\right]=0. + \label{eq:remainder-neighborhood} +\end{equation} +For a fixed-depth carpet the analogous first-moment statement holds for +\(M_\delta\). For a seed stop it holds after restricting to +\(N_\delta(Q)\le M\) and to a fixed bound on the initial flat labels +of the chambers meeting \(Q\): +\begin{equation} + \lim_{\eta\downarrow0}\limsup_{\delta\downarrow0} + \E\!\left[\zeta_\rho(d_\delta(Q))\ind_{\{N_\delta(Q)\le M\}} + |M_\delta(\phi\ind_{A_\delta^\eta})|\right]=0. + \label{eq:mean-neighborhood} +\end{equation} +The restriction on the initial labels is understood in this display. +For the initial free and wired constructions their magnitudes are +respectively \(0\) and \(a\). The contributor restriction can be +removed in probability using the initial count tail. +\end{lemma} + +\begin{proof} +Fix the initial exact-cut data. Suppose a seed stop satisfies +\(d_\delta(Q)\ge\rho\) and its revealed set comes within \(\eta\) of +\(z\in Q\). Up to one lattice cell, a newly revealed cluster then meets +\(B(z,O(\eta+\delta))\) and contains a current path from there to its +seed vertex at distance at least \(\rho\). Thus this event is contained +in the event of an \(N\)-arm from the small disk to radius \(\rho\). +This inclusion holds for every terminal rule, including rules using +the transverse colors. + +Test this arm in the \((s,W)\) marginal of the initial flat kernel. +In a stack of separated buffered annuli between these radii, every +prescribed-color \(W\) circuit blocks the arm. Reveal only \((s,W)\) +in successive annuli, with endpoints before edges. The conditional +bound of \cref{prop:circuits} gives probability at least \(p>0\) for +each blocking circuit. The arm probability is therefore at most +\((1-p)^{c\log(\rho/(\eta+\delta))}\). This calculation never +conditions that circuit estimate on the full terminal history. +Integrating the event inclusion over \(z\in Q\) proves +\eqref{eq:cut-area} for seed stops, including the product of initial +flat chambers in the composite construction. + +For a carpet of odd depth \(r\), use successive pairs of annuli with +opposite prescribed \(W\) signs. Between the two circuits in each +successful pair, the jump rule of \cref{lem:finite-cuts} forces an odd +rim. Nested successful pairs force distinct odd layers. Reaching the +inner disk before depth \(r\) therefore implies fewer than \(r\) +successes among logarithmically many one-parity trials. Their +conditional lower bounds give a binomial tail; its polynomial factor +is absorbed by decreasing the exponent. For the first wired layer, +a \(W\) circuit blocks the boundary current's arm, using the bulk +pre-removal clause of \cref{prop:circuits}. These arguments take place +in the original or fresh exact-cut kernel before any future color +revelations. + +Condition now on the terminal data, only to estimate the remainder. +The residual fields are independent flat fields by +\cref{lem:finite-cuts}. For every terminal-measurable union \(E\) of +cells in \(Q\), the logarithmic covariance bound gives +\begin{equation} + \E[|R_\delta(\phi\ind_E)|^2\mid\mathcal E_\delta] + \le C\|\phi\|_\infty^2 + \iint_{E\times E}\left(1+\log^+ + \frac{R_0}{|z-w|\vee\delta}\right)\dd z\,\dd w + \le C'\|\phi\|_\infty^2|E|. + \label{eq:random-neighborhood-green} +\end{equation} +The final bound follows from the uniform integral of the logarithmic +kernel on a bounded set; its atomic version includes the diagonal +cell cutoff. Multiplying by \(\zeta_\rho(d_\delta(Q))\), averaging, and +using \eqref{eq:cut-area} proves +\eqref{eq:remainder-neighborhood}. + +The revealed values and wall labels at fixed odd depth are bounded +by a deterministic depth-dependent constant. At a seed stop, on the +stated truncation the exact jump rule instead gives +\[ + |M_\delta|\le B+2aM+a\quad\hbox{on }Q, +\] +where \(B\) bounds the initial labels. Each contributor gives either +zero or one jump of size \(2a\); on its own sites the extra parity +discrepancy is at most \(a\). The area estimate proves +\eqref{eq:mean-neighborhood}. The pathwise contributor bound above +and the initial whole-box tail remove its truncation in probability. +\end{proof} + +\subsection{The conditional field across a stopped cut} + +We specify what is retained when a finite stop has a limit. Let +\(\mathbf e_\delta\) be a random element of a countable product of +Polish spaces, measurable at that same terminal stop. It +contains \(A_\delta,F_\delta,F_{0,\delta},W_{0,\delta},S_\delta\) as +closed-set coordinates. For each rational closed ball \(B\) and each +positive rational \(c\), it also records the terminal chamber label +when \(\dist(B,F_\delta)>c\), and the initial chamber label when +\(\dist(B,F_{0,\delta})>c\), with a cemetery value for either coordinate +when its clearance fails. Rational polygonal paths with positive clearance encode +connection between such buffers. One may include specified terminal-measurable +contributor coordinates whose chosen encodings are tight, such as the +localized finite lists used in \cref{sec:identification}. This retained +state excludes future clusters and canonical data that may appear +elsewhere in a larger joint representation. + +For a fixed \(s<-1\), pass to a joint subsequence in the product of +\(H^s_{\mathrm{loc}}(B_0)^3\) and this retained state space: +\begin{equation} + (h_\delta,M_\delta,R_\delta,\mathbf e_\delta) + \ \Longrightarrow\ (h,M,R,\mathbf e), + \qquad h=M+R. + \label{eq:stopped-joint-extraction} +\end{equation} +The field tightness and the zero-extension tightness of the remainders +give this extraction for the first three coordinates. For a fixed +protected ball choose a smooth unit-mass test supported inside it and +divide its atomic pairing by the deterministic atomic mass of that test. +The mass tends to one, and on the clearance event the normalized +\(M_\delta\) pairing is exactly the chamber label. The full pairing is +tight and the remainder pairing has uniformly bounded second moment, so +the label on that event, with the cemetery value off it, is tight as well. +The same argument at the initial cut uses its centered flat remainder +and proves tightness of the protected initial-label coordinates. +This makes a diagonal extraction possible for the countable state; +unprotected labels in chambers collapsing onto the cut are not retained. +Write +\(\mathscr E=\sigma(\mathbf e)\), completed under the limiting law. +This is the limiting stopped sigma-field used below. + +Let \(A,F,F_0,W_0,S\) be the closed-set limits. The one-cell comparison +between \(A_\delta\) and \(F_\delta\) gives \(A\cap D=F\cap D\); +similarly \(W_0\cap D=F_0\cap D\). Put \(U=D\setminus A\). +Its components are defined geometrically from \(F\): two rational +points belong to the same one exactly when some rational polygonal +path between small neighborhoods of them has positive clearance. +They are not defined by a limiting discrete equivalence relation. +At a rational point outside \(F\), choose a small ball and a rational +threshold strictly below its limiting clearance. Its protected coordinate +reads the limiting label; the point receives the cemetery value +on \(F\). The labels agree within each component, since a compact +connecting path is eventually inside one discrete chamber. Denote this +label by \(m_O\) on a component \(O\). + +\begin{lemma}[Full conditional field at a stopped cut] +\label{lem:stopped-full-field} +In \eqref{eq:stopped-joint-extraction}, let \(Q\Subset D\) be compact. +On the stopped-measurable event +\(\Lambda_Q=\{\dist(Q,F_0\cup S)>0\}\), the set \(A\cap Q\) has zero +area, \(M\) is the distribution given on \(Q\) by the locally +integrable function \(m_O\) on each component of \(U\), and, for every +real \(\phi\in C_c^\infty(D)\) supported in \(Q\), +\begin{equation} + \ind_{\Lambda_Q} + \E[\exp(i(h-M)(\phi))\mid\mathscr E] + =\ind_{\Lambda_Q} + \exp\!\left(-\tfrac12G_U(\phi,\phi)\right). + \label{eq:stopped-full-characteristic} +\end{equation} +The identity holds for every real linear combination of any finite +family of such tests. Thus, on tests crossing \(A\) in this region, +\(h-M\) is conditionally the zero-extended GFF on \(U\), with zero +covariance between its components. The mean is the limit of the +finite jump contributions after the contributor and initial-label +truncations of \cref{lem:cut-neighborhoods}, followed by their removal. + +For a carpet explored in a single initial parent, take \(D\) to denote +that parent; then \(\Lambda_Q\) holds for every \(Q\Subset D\), and hence +\(|A\cap D|=0\). For a global wired carpet whose initial wall already +contains \(W_0\), the conclusion is used on compact subsets of each +pointed wired hole and combined with the previously identified layer. +For seed and composite stops the conclusions hold locally away from +\(W_0\cup S\). Each stop in a countable family has +this conclusion conditional on its own retained state; adjoining the +other stops to a joint representation does not enlarge that conditioning +sigma-field. +\end{lemma} + +\begin{proof} +Use a Skorokhod representation of the joint subsequence for this proof. +We first derive zero area before using any continuum neighborhood bound. +Let \(d_\delta=d_\delta(Q)\) and \(d=\dist(Q,F_0\cup S)\). +Their convergence follows from Hausdorff convergence. For fixed \(\eta\), +every point of \(A\cap Q\) eventually lies in \(A_\delta^\eta\). +Fatou's lemma and \eqref{eq:cut-area} therefore give +\[ + \E[\zeta_\rho(d)|A\cap Q|] + \le \liminf_{\delta\downarrow0} + \E[\zeta_\rho(d_\delta)|Q\cap A_\delta^\eta|] + \le C\eta^\alpha. +\] +Letting \(\eta\downarrow0\) proves zero area where \(d\ge2\rho\). +Exhausting positive rational \(\rho\) proves it on \(\Lambda_Q\). +The same holds for \(F\cap Q\), because \(A\) and \(F\) agree in \(D\). + +We next prove the conditional characteristic function across the cut. +Fix a small \(\eta>0\). Choose a finite nonnegative smooth partition +\((\psi_i)_{i\le n_\eta}\) equal to one in sum on \(Q\), with each +\(\psi_i\) supported in a rational ball and with a fixed larger rational +closed ball \(B_i\Subset D\) of diameter at most \(4\eta\). Choose a continuous +\(\chi:[0,\infty)\to[0,1]\) equal to zero on \([0,1/4]\) and to one on +\([1,\infty)\), and put +\begin{equation} + w_{i,\delta}=\chi\!\left(\frac{\dist(B_i,F_\delta)}{\eta}\right), + \qquad + \phi_\delta^\eta=\sum_i w_{i,\delta}\phi\psi_i. + \label{eq:stopped-partition} +\end{equation} +Use the corresponding \(w_i,\phi^\eta\) with \(F\) in the limit. +These weights are continuous functions of the closed-set coordinate. +If \(w_{i,\delta}>0\), the whole buffer \(B_i\) has clearance at least +\(\eta/4\). If \(1-w_{i,\delta}>0\), every point in +\(\supp(\phi\psi_i)\) is within \(5\eta\) of \(F_\delta\). Consequently +\(\phi-\phi_\delta^\eta\) is bounded by \(\|\phi\|_\infty\) and +supported in \(Q\cap F_\delta^{5\eta}\). + +Stratify the finitely many possible active index sets +\(\{i:w_{i,\delta}>0\}\). On each stratum, +\cref{eq:conditional-flat-characteristic}, multiplied by \(a\) in the +field normalization, applies to the fixed tests \(\phi\psi_i\). +Its fixed real coefficients may be replaced by the stopped-measurable +vector \((w_{i,\delta})\): approximate the compact coefficient cube +by a finite rational net. The conditional second-moment bound makes +the characteristic function uniformly Lipschitz in those coefficients, +and \(G_{U_\delta}\le G_{B_0}\) gives the same uniform continuity for +the Gaussian expression. Summing over the active strata yields +\begin{equation} + \E\left| + \E[e^{\,iR_\delta(\phi_\delta^\eta)}\mid\mathcal E_\delta] + -e^{-\frac12G_{U_\delta}(\phi_\delta^\eta,\phi_\delta^\eta)} + \right|\longrightarrow0. + \label{eq:stopped-buffer-characteristic} +\end{equation} +This used only terminal-measurable coefficients and ancillaries, never +information from a later interior revelation. + +For indices with positive limiting weight, their buffers retain positive +clearance. Green convergence in \cref{lem:flat-green-geometry} applies +to every pair of their fixed tests. Indices whose weights vanish are +harmless by the uniform bound from \(G_{B_0}\). Hence the Gaussian +exponent in \eqref{eq:stopped-buffer-characteristic} converges to +\(G_U(\phi^\eta,\phi^\eta)\). The left test converges jointly by +\eqref{eq:stopped-joint-extraction} and the finite continuous weights. +Multiplying by a bounded continuous function of \(\mathbf e_\delta\) +and by \(\zeta_\rho(d_\delta)\) is therefore legitimate. + +There are two neighborhood errors to remove. The one-cell relation +between \(F_\delta\) and \(A_\delta\), \eqref{eq:random-neighborhood-green}, +and \eqref{eq:cut-area} imply +\[ + \lim_{\eta\downarrow0}\limsup_{\delta\downarrow0} + \E[\zeta_\rho(d_\delta) + |R_\delta(\phi-\phi_\delta^\eta)|^2]=0. +\] +For the limiting kernel, positivity and domain monotonicity give +\begin{equation} + \|\phi-\phi^\eta\|_{G_U}^{\,2} + :=G_U(\phi-\phi^\eta,\phi-\phi^\eta) + \le C\|\phi\|_\infty^2|Q\cap F^{5\eta}|. + \label{eq:stopped-green-removal} +\end{equation} +Indeed \(0\le G_U\le G_{B_0}\), whose logarithmic singularity has a +uniformly bounded integral. The right side tends to zero on +\(\Lambda_Q\) by the zero-area result. Energy Cauchy--Schwarz now shows +that \(G_U(\phi^\eta,\phi^\eta)\to G_U(\phi,\phi)\) there; the other +energy factors are bounded by the same outer kernel. + +The inequality \(|e^{ix}-e^{iy}|\le|x-y|\) removes the lattice error +in the tested conditional identity. Then +\eqref{eq:stopped-green-removal} and bounded convergence remove the +continuum error. We obtain, for every bounded continuous \(Z\) of the +retained state, +\[ + \E[\zeta_\rho(d)Z(\mathbf e)e^{\,iR(\phi)}] + =\E[\zeta_\rho(d)Z(\mathbf e)e^{-\frac12G_U(\phi,\phi)}]. +\] +Bounded continuous functions determine the law on the retained metric +state. A monotone-class argument gives the same equality for all bounded +\(\mathscr E\)-measurable \(Z\). Exhausting positive clearances proves +\eqref{eq:stopped-full-characteristic}, because \(R=h-M\) in the joint +limit. A countable determining family fixes one conditional version; +continuity then gives every real linear combination in the finite-vector +assertion, including independence across components that shared a +discrete precursor. + +It remains to identify \(M\). On an active buffer in +\eqref{eq:stopped-partition}, \(M_\delta\) is exactly its flat chamber +label. The protected rational-label coordinates and their agreement along +compact connecting paths show that +\(M_\delta(\phi_\delta^\eta)\) converges to +\(\int_U m_O\phi^\eta\). Terms of zero limiting weight vanish by +tightness of the fixed \(M_\delta(\phi\psi_i)\) pairings. The joint extraction also identifies this +limit with \(M(\phi^\eta)\). We spell out the bound on the limiting +labels. A finite deterministic cover of \(Q\) by rational balls of +radius at most \(\rho/8\) can be chosen so that every point lies in one +of them. On \(d_\delta(Q)\ge\rho\), any initial chamber meeting \(Q\) +contains such a ball with clearance at least \(\rho/2\) from +\(F_{0,\delta}\). Thus the maximum of its initial labels is bounded by +the maximum of finitely many protected initial-label coordinates and +is tight. On this clearance event, a contributor bound \(N_\delta(Q)\le M\) +and an initial-label bound \(B\) bound every terminal chamber label meeting +\(Q\) by \(B+2aM+a\). Transfer this bound first to any finite family +of protected limiting buffers, using their joint convergence and a +slightly smaller clearance. The probability of its failure is at most +the initial count or label tail. Exhaust the countable rational buffers; +the same tail bound holds for the supremum of the limiting labels on +\(Q\setminus A\). Sending \(M,B\) to infinity proves that this supremum +is finite almost surely on each positive-clearance localization. + +On these truncations the omitted finite contribution vanishes by +\eqref{eq:mean-neighborhood}; the omitted limiting integral vanishes +by the local label bound and \(|Q\cap F^{5\eta}|\to0\). Joint convergence +of the two \(M_\delta\) pairings transfers the finite omission bound +to \(M(\phi)-M(\phi^\eta)\) in probability. Letting \(\eta\downarrow0\) +therefore gives +\[ + M(\phi)=\int_U m_O(z)\phi(z)\,\dd z + \quad\hbox{on }\Lambda_Q. +\] +The initial whole-box tail of \cref{cor:global-cluster-counts} and label tightness remove the truncations +in probability. This also proves local \(\mathscr E\)-measurability of +\(M\). No mean or centered distribution remains on the cut in the +tested region. Countable rational localizations and a separate retained +state for each stop give the simultaneous assertion. +\end{proof} + +\subsection{The stopped two-valued sets} + +\begin{proposition}[Convergence of stopped carpets] +\label{prop:stopped-tvs} +The wired boundary cluster converges jointly with \(h_\delta\), with its +labels, to \(\TVS{a}{a}(h)\). In a free flat parent, after subtracting +its label and writing \(f\) for the zero-boundary limiting remainder, +the first odd carpet converges to \(\TVS{2a}{2a}(f)\). At depth \(r\), +define the global closed carpet as the closed complement of the holes +still unsearched after every branch has met \(r\) odd rims; it includes +all earlier layers and, in the wired case, the first wired layer. For each fixed +finite \(r\), this global carpet converges in ordinary Hausdorff distance +to the corresponding canonical nested carpet. Its labels and restarted +zero-boundary fields converge on every finite family of pointed compact +buffers in the limiting holes. These pointed conclusions include distinct +limiting components with the same discrete precursor; they do not assign +one whole precursor carpet to several separate Hausdorff limits. +\end{proposition} + +\begin{proof} +Take a joint subsequence as in \eqref{eq:stopped-joint-extraction}, +also retaining the raw closed carpets. Compactness of closed subsets, +field tightness, and the finite label sets permit this extraction. +The exact cuts give residual labels \(\pm a\) for the wired layer and +\(\pm2a\), relative to the parent, for the first free odd carpet. +Their closed limits are boundary-connected. Every open component is +represented by rational interior buffers: if a disk lay outside the +closed limit but in no pointed component, its compact containment in +the discrete complement would give a contradiction. + +\Cref{lem:stopped-full-field} gives the full local-set decomposition +and its bounded label mean on tests throughout the parent. It also +gives zero area inside that parent. Hence the limit is a +boundary-connected bounded thin local set, including across its cut. +The uniqueness theorem of \cite[Proposition~2]{ASW2017} identifies +the two limits as \(\TVS{a}{a}\) and \(\TVS{2a}{2a}\), since +\(2a>2\lambda\) and \(4a>2\lambda\). + +The original wired domain is Jordan. Its limiting holes are Jordan by the +two-valued-set geometry recalled above. The first odd holes have +label magnitudes \(2a>2\lambda\), so their loops avoid even a rough +parent boundary and are Jordan as well. Restart in such a hole after +subtracting its observed label. The conditional characteristic-function +estimate is uniform on deterministic interior buffers; a countable +exhaustion handles the random hole. Induction gives every fixed finite +odd depth, with a single global closed carpet at that depth and pointed +compact restrictions inside its holes. In the wired case, the local +applications are on compact subsets of pointed wired holes, and the +already identified \(W_0\) is supplied by the preceding layer. +Write \(K_r\) for the connected global limit at depth \(r\). If \(V\) +is a pointed Jordan hole of \(K_{r-1}\), then +\(\partial V\subset K_{r-1}\subset K_r\), and +\(K_r\cap\overline V\) is connected. Indeed, a separation of this +compact intersection would put the connected \(\partial V\) on one +side and leave the other side compactly inside \(V\). Adjoining +\(K_r\setminus V\) to the first side would then separate \(K_r\). +Thus the child restriction is boundary-connected. Inside each pointed +parent, uniqueness identifies that restriction; outside the union of +those parents the global closed set is the preceding layer. This identifies +the whole global closed limit even when one precursor splits. The sets +are canonical functions of the same limiting field, so every subsequential +law is the stated one. +\end{proof} + +\subsection{Fields at seed stops} + +\begin{proposition}[Conditional fields at a cluster stop] +\label{prop:exploration-thin} +Consider a seed stop in an initial free parent of label \(b_0\), or +the composite wired stop defined above. Let \(A,S,W_0,\mathscr E\) +be its limiting explored set, seed trace, initial wall, and retained +stopped sigma-field. The set \(A\) is connected to the original +boundary, and every component \(O\) of \(D\setminus A\) is simply +connected. Conditionally on \(\mathscr E\), +\begin{equation} + h|_O=m_O+h^O,\qquad m_O-b_0(O)\in2a\Z, + \label{eq:stopped-component-law} +\end{equation} +where the \(h^O\) are independent zero-boundary GFFs. Here \(b_0(O)\) +is the label of its initial parent chamber; it is \(0\) in the +initial free domain and \(\pm a\) in a wired hole. The labels are +tight on every finite family of pointed components. + +On every compact subset of \(D\) away from \(W_0\cup S\), \(A\) has +zero area and the full conditional mean \(M\) is the locally +integrable piecewise constant function \(m_O\). On the same region, +\cref{eq:stopped-full-characteristic} gives the full zero-extended +conditional GFF law of \(h-M\), also for tests whose supports meet +\(A\). Locally \(M\) is the limit of the finite signed odd-hole +contributions of the discovered clusters, with the initial parent +label added. These statements hold for every member of a specified +countable family of sweeps and observable indexed stops, each +conditional only on its own retained state. + +For a composite wired stop, every \(O\) is contained in one pointed +limiting wired hole. The conclusions use the global exploration of +the original \(h\); they do not require a separate lattice sweep +selected from that limiting hole. +\end{proposition} + +\begin{proof} +The initial wall, the attached seed, and all clusters met by it form +one boundary-connected revealed union. Each residual face has one +sealed monochromatic \(W\) perimeter with its actual connections, by +\cref{lem:finite-cuts}. Its flat label differs from that of its initial +parent by an element of \(2a\Z\). Hausdorff limits preserve the +connected revealed union. The planar connected-complement criterion +then makes every open component simply connected. In the wired +composite case \(A\) contains \(W_0\), so each open component lies in +one component of \(D\setminus W_0\). + +Before the limit, reflection of a centered flat law makes its mean +zero. Thus on an unsearched site the exact jump rule gives +\begin{equation} + M_\delta(z)=b_{0,\delta}(z)+ + 2a\sum_{C\ \mathrm{discovered}} + \epsilon_C\ind_{\mathcal O_\delta(C)}(z), + \qquad z\notin A_\delta, + \label{eq:discrete-discovered-mean} +\end{equation} +where \(b_{0,\delta}(z)\) is its initial chamber label and +\(\epsilon_C\in\{-1,1\}\) is the cluster's relative jump sign. +The contributor bound and \cref{lem:cut-neighborhoods} give the +finite local truncation of this formula. On a connected compact +ball away from \(W_0\), the initial label is one constant. On exposed +sites the parity discrepancy from an incident wall is bounded and is +removed with the cut neighborhood. + +\Cref{lem:stopped-full-field} now proves both the full mean identity +and the full residual law. Its interior restriction is +\eqref{eq:stopped-component-law}; the block Green kernel gives +independence even when one discrete chamber pinches into several +limiting components. The label tightness was proved in the joint +extraction. For the composite wired stop, all inputs are those of +the single global finite exploration, so the same argument covers +such a pinch without a future choice of lattice chamber. +\end{proof} + +\subsection{Geometry of the candidate clusters} + +The incoming label must be kept when a canonical cluster is restarted. +If its parent field is \(b+f\), the construction in +\cref{def:free-procedure} has the following values: +\[ +\begin{array}{c|c|c|c} +\text{incoming label}&\text{CLE sign}&\text{field in the CLE hole} + &\text{labels after the split}\\ \hline +b&+1&b+2\lambda+f_V&\{b,b+2a\}\\ +b&-1&b-2\lambda+f_V&\{b-2a,b\}. +\end{array} +\] +Equivalently, \(b\) becomes \(b+\xi\,2\lambda\) and then one of +\(\{b,b+\xi\,2a\}\). A hole of a retained cluster is \emph{odd} +when its label is \(b+\xi\,2a\), and is even when its label is \(b\). +Thus every descendant baseline lies in \(b_0+2a\Z\). Here +\(b_0=0\) in the free domain and \(b_0=\pm a\) behind the wired layer. + +We first justify the nested continuation that will be used twice. + +\begin{lemma}[Completion between fixed labels] +\label{lem:nested-completion} +Let \(f\) be a zero-boundary GFF in a bounded simply connected parent +\(P\). Let \(E\) be a field-measurable boundary-connected bounded thin +local set whose value \(c_H\) is constant on each component \(H\) of +\(P\setminus E\). Suppose +\[ + -p\le c_H\le q,\qquad p,q>0,\qquad p+q\ge2\lambda. +\] +For these fixed \(p,q\), suppose also that all \(c_H\) lie in one fixed +deterministic countable subset \(\mathcal L\subset[-p,q]\). +In each component with \(-p2\lambda\). +All but \(2a\) lie strictly between \(-R\) and \(2a\), since +\(a>\lambda\). By \cref{lem:nested-completion}, completing these +holes to \(-R,2a\) yields \(\TVS{R}{2a}(f)\), containing the split. +As \(R\uparrow\infty\) through a deterministic sequence, reflection of +the FPS construction +\cite[Remark~4.2 and Proposition~4.4]{ALS2017} identifies the closed +increasing union as the upper FPS of \(f\) at \(2a\). This last set +is generally nonthin; the preceding bounded-density argument is not +used as the barrier grows. Its metric approximants connect points to +the parent boundary by sublevel paths, with coupled FPS convergence +given by \cite[Proposition~4.7]{ALS2018}. +For excursions, \cref{lem:soup-forcing} below proves directly the +one-sided same-field approximation needed for connected paths between +strict interior hits. In the total field the two path levels are +\(b\) and \(b+2a\). +Reflection gives levels \(b\) and \(b-2a\) for a negative cluster. + +For the sign assertion, let $\xi$ be the fair outer $\CLE_4$ sign. +The zero-boundary remainder $f_V$ is independent of it. The field +$\xi f_V$ has the same law and is still independent of $\xi$. +Reflection carries the negative split into the positive split, +preserving its unlabelled geometry and the distinction between odd +and even holes. Conditional remainders in the holes can be +reflected in the same way before restarting. This proves the +independent-fair-sign assertion against every finite recursive geometry +cylinder. A monotone-class argument gives the assertion conditional on +the entire countable unlabelled geometry. It does not assert independent +labels on arbitrary two-valued-set loops. + +Finally, fix the incoming \(b\), subtract it, and put +\(T=\TVS{2a}{2a}(f)\). At a completed first-odd stage, holes labelled +\(\pm2a\) are terminal and holes labelled zero are active. In every +active hole insert its complete outer CLE set, then the appropriate +complete split in each CLE hole. Define each layer by enumerating its +holes and taking the closed limit of finite insertions. Every finite +partial layer is a field-measurable boundary-connected BTLS by finite +gluing. Its labels lie among \(0,\pm2\lambda,\pm2a\), hence inside +\([-2a,2a]\). Its completion under \cref{lem:nested-completion} is +the same \(T\), so the partial layer lies in \(T\). For a full layer, +the increasing-local-set and bounded-density proof of that lemma applies +with \(Z=T\) and \(K=2a\). It remains a BTLS contained in \(T\). + +Let \(B_0=\partial P\), let \(B_n\) be the completed stage after \(n\) +rounds of even continuation, and +let \(B_\infty=\overline{\bigcup_n B_n}\). The same increasing-local-set +result makes \(B_\infty\) local and gives convergence of the mean +distributions. Their absolute values on a test \(\varphi\) are bounded +by \(2a\|\varphi\|_1\), so the limiting mean has an \(L^\infty\) +density bounded by \(2a\). Since \(B_\infty\subset T\) and +\(|T\cap P|=0\), that density agrees with the harmonic mean as a full +distribution. This proves thinness of the increasing limit. + +The active region has vanishing area. Conditional on a positive CLE +hole, thinness and mean zero for \(f_V\) give, for Lebesgue-a.e. \(z\), +\[ + 0=-2\lambda(1-p(z))+(2a-2\lambda)p(z), + \qquad p(z)=\lambda/a, +\] +where \(p(z)\) is the conditional probability that the split assigns +the odd value. Reflection gives the same probability in a negative +hole. Fubini therefore bounds the expected area still active after +\(n\) rounds by \((1-\lambda/a)^n|P|\). Monotone convergence makes +the area surviving all rounds zero almost surely. +Terminal labels persist, so the limiting harmonic mean takes values +\(\pm2a\) almost everywhere off \(B_\infty\). Harmonic continuity and +connectedness make it one of these constants throughout each open +component. BTLS uniqueness gives \(B_\infty=T\). At the next odd +depth the observed \(b\pm2a\) becomes the new incoming label before +the argument is restarted. + +At \(a=2\lambda\) the split has width \(4\lambda\) and both relative +barriers remain positive. The FPS support proof +\eqref{eq:fps-odd-support}, the sign argument, and the containments +still apply, and the odd probability is \(1/2\). Thus the endpoint is +included. +\end{proof} diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/08-local-kernel.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/08-local-kernel.tex new file mode 100644 index 0000000000000000000000000000000000000000..b504f58db96da0f5b7a85dc9ca5d46ee03caf947 --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/08-local-kernel.tex @@ -0,0 +1,1154 @@ +\section{Local cable tests and the no-crossing principle} +\label{sec:local-kernel} + +A canonical cluster is a function of the limiting field, whereas the +stopped law in \cref{prop:exploration-thin} is conditioned on retained +exploration data. To compare them, we turn a local cable path test into +a bounded function of the continuum field on a slightly larger buffer. +Calibration in the canonical parent makes this function equal to one +on a crossing event. Its expectation in the stopped component tends to +zero under that component's conditional GFF law. + +\subsection{Auxiliary cables and the tests} + +All cable fields in this section are auxiliary Gaussian approximations; +their index \(n\) and dyadic mesh \(\varepsilon_n=2^{-n}\) are separate from +the current mesh \(\delta\) in \cref{sec:local-sets}. They have the +normalization of \(h\), with Cameron--Martin norm +\begin{equation} + \|u\|_{\nabla}^{2}=\frac1{2\pi}\int |\nabla u|^{2}\,\dd z, + \qquad u\in H^1_0. + \label{eq:kernel-energy} +\end{equation} +Fix the corresponding square cable grids \(\Gamma_n\) in one bounded +box \(\mathcal B\). All later subsequences are drawn from this dyadic +sequence. A cable GFF +\(\widetilde\Phi_n\) has discrete GFF values at vertices and independent +Brownian bridges on the metric edges conditional on those values. Edge +resistances and the field scaling are fixed once for this normalization. +For the metric-domain approximations below, planar pairings use the ALS harmonic extension of the +\emph{whole cable function} to the box, with zero data at the box boundary +\cite[Sections~2.1 and~4.1]{ALS2018}; denote it by +\(\widehat\Phi_n\). Thus +\(\widehat\Phi_n(f)=\int f(z)\widehat\Phi_n(z)\,\dd z\). +It is not a vertex-only pairing. +Full-field convergence and full-field functionals below use +\(H^s(\mathcal B)\) for one fixed \(s<-1\), the distribution topology +of the cited cable convergence. + +For every test polygon \(B\), fix once a connected closed union +\(B_n^\square\) of complete primal mesh cells approximating +\(\overline B\) from inside and exhausting its compact subsets. Put +\(C_{B,n}=\Gamma_n\cap B_n^\square\). It includes the contained and +perimeter edges, but not the open part of an outward edge. The same +convention defines \(C_{K,n}\) for a smaller test polygon. + +The reference polygon \(P\) uses a distinct approximation so that it +is literally a metric domain of \cite[Section~4.1]{ALS2018}. Let +\(P_n^\diamond\) be the interior of a fixed simply connected union of dual +mesh cells centered at grid vertices, exhausting compact subsets of +\(P\) with complement-Hausdorff convergence. Its boundary crosses +primal cables at their midpoints. Subdivide there and write +\(\mathsf P_n=\Gamma_n\cap P_n^\diamond\), including the cut points +as Dirichlet boundary vertices. The inherited half-edge resistances +preserve the cable law. In every compared ambient approximation, +this same subdivided \(\mathsf P_n\) must occur unchanged for fine +mesh, with no missing cable, altered resistance, or extra pin there. +The cut points are unpinned in the ambient field; they become Dirichlet +vertices only in the reference residual after the exterior is conditioned. +The reference is the zero-boundary cable GFF in \(\mathsf P_n\). +An admissible ambient graph is the source metric domain +\(\Gamma_n\cap D_n\) for a Euclidean open \(D_n\subset\mathcal B\), +with its boundary intersection points adjoined as Dirichlet endpoints. +The regular inner approximations used below exhaust compact subsets +and contain the prescribed \(\mathsf P_n\) for all sufficiently large +\(n\). Their complements converge in Hausdorff distance, and their +numbers of complementary components are uniformly bounded. These are +the primary admissible approximations in this section. +\Cref{lem:killed-graph-transfer} adds a second auxiliary class, with an +explicit whole-cable embedding and the same local kernel. + +Here are the tests used later. A collar choice consists of a compact +rational polygon \(Q\) and regular rational polygons +\[ + Q\Subset V\Subset K\Subset B\Subset P. +\] +For \(t\in a\Z\), let \(T_{n,t}^{+}\) be the indicator that, on the +cables in \(C_{K,n}\), a path in \(\{\widetilde\Phi_n\ge t\}\) joins +\(Q\) to \(K\setminus\overline V\). Define \(T_{n,t}^{-}\) with +\(\widetilde\Phi_n\le t\). A canonical inner hit will be in +\(\operatorname{int}Q\), and its outer hit will have positive distance +from \(\overline V\) and from \(\partial K\). These strict hits persist +under Hausdorff convergence. The tests are measurable functions of the +same cables in every domain. More generally, the next two lemmas allow +any \([0,1]\)-valued measurable test supported in \(C_{K,n}\); no +continuity of that test as a function of a limiting distribution is +assumed. + +\subsection{The reverse buffer estimate} + +For a fixed polygon \(B\), put +\[ + \mathcal G_n(B)= + \sigma\bigl(\widetilde\Phi_n(x):x\in C_{B,n}\bigr),\qquad + \mathcal G(B)=\sigma\bigl(\Phi(f):f\in C_c^\infty(B)\bigr). +\] +The first sigma-field contains the full cable restriction, including +the perimeter bridges. By the cable Markov property, the residual after +conditioning is zero on \(C_{B,n}\) and is an independent killed cable +GFF on its complement. Extend this residual by zero on \(C_{B,n}\) +\emph{before applying the original ambient harmonic extension operator}. +Write \(\mathsf K_n^B(f,g)\) for the covariance of the resulting planar +pairings. In particular, the conditioned perimeter cables remain zero +traces in this extension. We do not replace this form by the extension +from a graph in which those cables were deleted. + +\begin{lemma}[Reverse buffer estimate] +\label{lem:reverse-buffer} +Let \(K\Subset B\Subset D\), with \(B\) a regular polygon, and let +\(\widetilde\Phi_n\) be zero-boundary cable GFFs in the admissible +approximations of \(D\). Suppose the full extended Green forms converge +to \(G_D\) on smooth tests. Then +\[ + \mathsf K_n^B(f,g) + \longrightarrow G_{D\setminus\overline B}(f,g). +\] +If \(T_n\in[0,1]\) is supported in \(C_{K,n}\) and +\((\widehat\Phi_n,T_n)\) converges jointly along a subsequence to +\((\Phi,T)\), then +\begin{equation} + \E[T\mid\Phi]=\E[T\mid\mathcal G(B)]. + \label{eq:kernel-localization} +\end{equation} +The same conclusion holds for a bounded vector of local tests and after +adding deterministic harmonic means whose extended functions converge +in the full-field topology of the joint convergence and converge smoothly +on the buffer neighborhoods, in the interior finite-difference sense +used below. +\end{lemma} + +\begin{proof} +The covariance limit is for the precise clamped form just defined. +The deterministic set \(C_{B,n}\) is optional for the cable field, +connected and nontrivial, and converges in Hausdorff distance to +\(\overline B\). The metric-local-set convergence theorem +\cite[Lemma~4.9]{ALS2018} therefore applies under the stated domain +hypotheses. It uses the ambient harmonic extensions of the revealed +and residual fields. Every limit is the deterministic local-set +decomposition at \(\overline B\), so the residual limit is the +zero-extended GFF on \(D\setminus\overline B\). Its finite pairing +vectors and their prelimit vectors are centered Gaussian. Convergence +of their characteristic functions forces convergence of their covariance +matrices, proving the displayed limit. This argument retains the whole +zero cable trace; it makes no assertion that deleting perimeter edges +commutes with harmonic extension. + +Let \(\mathbf f=(f_i)_{i\le\ell}\) be a tuple of smooth tests, put +\(F_n=(\widehat\Phi_n(f_i))_{i\le\ell}\) and +\(F=(\Phi(f_i))_{i\le\ell}\), and let +\(Q_n=\E[F_n\mid\mathcal G_n(B)]\). +Linearity of the ambient extension and the cable Markov decomposition +give the exact identities +\begin{equation} + \Cov(F_n-Q_n)=\mathsf K_n^B(\mathbf f,\mathbf f),\qquad + \Cov(Q_n)=\widehat G_n^D(\mathbf f,\mathbf f) + -\mathsf K_n^B(\mathbf f,\mathbf f), + \label{eq:projection-variance} +\end{equation} +where \(\widehat G_n^D\) is the covariance form of +\(\widehat\Phi_n\). The residual is independent of +\(\mathcal G_n(B)\), hence of \(T_n\). Both matrices in +\eqref{eq:projection-variance} converge. In the continuum, conditioning +on \(\mathcal G(B)\) has the corresponding killed covariance: +the functions in \(H^1_0(D)\) that vanish on \(B\) are the zero +extensions of \(H^1_0(D\setminus\overline B)\). Polygonal regularity +makes this the usual domain Markov decomposition. + +Choose a countable dense family \((f_i^B)\) of interior smooth pairings +for the Gaussian Hilbert space \(\mathcal G(B)\), discarding dependent +coordinates in each finite list. Every cell meeting the support of a +fixed \(f_i^B\) belongs to \(B_n^\square\) for all sufficiently +large \(n\). Thus its ALS face pairing is exactly +\(\mathcal G_n(B)\)-measurable. Let \(Q_n^{(r)}\) be the Gaussian +projection of \(F_n\) onto the first \(r\) such pairings. For fixed \(r\), +convergence of the covariance matrices gives joint convergence with the +field to the corresponding finite projection \(Q^{(r)}\). If +\(Q=\E[F\mid\mathcal G(B)]\), density gives \(Q^{(r)}\to Q\) in +\(L^2\). Orthogonality and \eqref{eq:projection-variance} yield +\begin{equation} + \lim_{r\to\infty}\limsup_{n\to\infty} + \E|Q_n-Q_n^{(r)}|^2 + =\lim_{r\to\infty}\E|Q-Q^{(r)}|^2=0. + \label{eq:projection-strong} +\end{equation} +This convergence of projection norms is the information needed for +an arbitrary local test. + +For a bounded Lipschitz function \(v\) of \(F_n\), Gaussian conditioning +writes +\(\E[v(F_n)\mid\mathcal G_n(B)]=\Psi_n(Q_n)\), where \(\Psi_n\) +convolves \(v\) with the residual Gaussian law. Its covariance limit +and \eqref{eq:projection-strong} approximate this expression in \(L^1\), +uniformly for fine mesh, by bounded continuous functions of finitely +many interior pairings. The limit is +\(\E[v(F)\mid\mathcal G(B)]\). Multiply this identity by \(T_n\) and +by a bounded continuous function of finitely many interior pairings. +The \(L^1\) error remains valid because \(T_n\) is bounded. Passing to +the two limits proves the conditional factorization with \(T\) for every +full-field Gaussian cylinder given \(\mathcal G(B)\). A monotone-class +argument proves \eqref{eq:kernel-localization}. The vector and harmonic +mean versions follow by the same argument. +\end{proof} + +\subsection{A domain-independent local kernel} + +\begin{lemma}[Common local kernel] +\label{lem:local-kernel} +Fix \(K\Subset B\Subset P\) as above and a sequence of +\([0,1]\)-valued cable tests \(T_n\) supported in \(C_{K,n}\). +There are a subsequence and a measurable \(k\), with \(0\le k\le1\), +on continuum field restrictions to \(B\), such that: +\begin{enumerate} +\item In the zero-boundary reference field in \(P\), every joint limit +along this subsequence satisfies +\(\E[T\mid\Phi]=k(\Phi|_B)\). +\item The same \(k\) is the conditional kernel in every deterministic +domain \(D\) with \(\overline P\subset D\), for the same cable tests +in admissible approximations containing the identical subdivided +\(\mathsf P_n\). For a prescribed harmonic mean, including a constant +boundary value, require its ALS extended means to converge in +\(H^s(\mathcal B)\) to the chosen full continuum ALS extension, and to converge +smoothly on buffer neighborhoods in the interior finite-difference +sense used below. +Equivalently, for every bounded continuous field functional \(v\), +\[ + \E[T_n v(\widehat\Phi_n)] + \longrightarrow \E[k(\Phi|_B)v(\Phi)] +\] +along the selected subsequence. This convergence of mixed expectations +does not require convergence of the tests as field functions. +\item Let a fixed random parameter \(\Theta\) select \(D\) and its mean, +and suppose that conditionally on \(\Theta\) the original total parent field +\(\Phi_D\) has that GFF law. Sample auxiliary cable fields conditionally +on \(\Theta\) in admissible approximations for almost every realization, +with the mean convergence required in item 2 for almost every realization. +For every joint limit +\[ + (\Theta,\widehat\Phi_n,T_n) + \ \Longrightarrow\ (\Theta,\Phi_D^{\mathrm{aux}},T) +\] +along the selected subsequence, the auxiliary field marginal satisfies +\((\Theta,\Phi_D^{\mathrm{aux}})\stackrel{\mathrm d}= + (\Theta,\Phi_D)\), and +\[ + \ind_{\{\overline P\subset D\}} + \bigl(\E[T\mid\Theta,\Phi_D^{\mathrm{aux}}] + -k(\Phi_D^{\mathrm{aux}}|_B)\bigr)=0. +\] +\end{enumerate} +One subsequence works for any countable collection of tests, polygons, +and thresholds. For the collar tests at \(t\in a\Z\), write the selected +kernels as \(k_t^\pm\). In the restriction to \(B\) of every admissible +zero-boundary field \(g^D\), +\begin{equation} + k_t^\pm(t+g^D|_B)=k_0^\pm(g^D|_B) + \quad\hbox{almost surely}. + \label{eq:kernel-threshold} +\end{equation} +The same identity holds under the conditional zero-boundary law of a +random selected domain. It is an identity under these Gaussian laws, +with the countable thresholds fixed in advance. +\end{lemma} + +\begin{proof} +For the reference field, take a joint subsequential limit of +\((\widehat g_n^P,T_n)\). The reverse buffer lemma makes its conditional +mean a function \(k(g^P|_B)\). We show that this selected function also +governs the mixed expectations in other domains. + +First translate the reference cable field by the linear cable +interpolation \(u_n\) of a fixed \(u\in C_c^\infty(P)\). Write +\(X_n=(\widetilde g_n^P,u_n)_{\nabla,n}\) for the Gaussian +Cameron--Martin coordinate; this is the isonormal pairing, not a +Dirichlet integral of a rough cable sample. The likelihood is +\begin{equation} + L_{n,u_n} + =\exp\left\{X_n-\tfrac12\|u_n\|_{\nabla,n}^2\right\}. + \label{eq:kernel-cm} +\end{equation} +We need strong identification of \(X_n\), since \(T_n\) is arbitrary. +Let \(f=-\Delta u/(2\pi)\), and let \(\widehat u_n\) be the same +harmonic face extension of \(u_n\). The Gaussian reproducing identity +and linearity of the extension give +\[ + \Var X_n=\|u_n\|_{\nabla,n}^2,\qquad + \Cov(X_n,\widehat g_n^P(f))=\int \widehat u_n f,\qquad + \Var(\widehat g_n^P(f))=\widehat G_n^P(f,f). +\] +The three expressions tend respectively to +\(\|u\|_\nabla^2,\int uf=\|u\|_\nabla^2\), and +\(G_P(f,f)=\|u\|_\nabla^2\). Here the energy is a Riemann sum, +\(\widehat u_n\to u\) uniformly on compact subsets, and the last +limit is Green convergence. Hence +\begin{equation} + \E|X_n-\widehat g_n^P(-\Delta u/(2\pi))|^2\longrightarrow0. + \label{eq:kernel-cm-coordinate} +\end{equation} +The likelihood coordinate therefore converges jointly with every +bounded \(T_n\), not only marginally. For \(r>1\), +\begin{equation} + \E[L_{n,u_n}^{\,r}] + =\exp\left\{\tfrac12r(r-1)\|u_n\|_{\nabla,n}^2\right\}. + \label{eq:kernel-cm-ui} +\end{equation} +These bounds give uniform integrability on bounded energy sets. +Tilting the reference joint law by \eqref{eq:kernel-cm} is exactly +the law of the translated total field and the test evaluated on that +translated cable field. The limiting likelihood is a function of the +continuum field. Such a tilt preserves its conditional kernel \(k\), +evaluated at the total restriction. + +For two shifts in one reference law, the Gaussian relative entropy +bound and Pinsker's inequality give +\begin{equation} + \|L_u-L_v\|_{L^1} + \le \min\{2,\|u-v\|_\nabla\}. + \label{eq:kernel-cm-continuity} +\end{equation} +The same inequality holds on the cables. Finite smooth nets in the +Dirichlet norm, together with \eqref{eq:kernel-cm-ui}, therefore make +the translated mixed-expectation limit uniform on compact families of +smooth shifts. This is equality of limiting measures tested first on +bounded continuous field functions. It does not require evaluating +a possibly discontinuous \(k\) on the discrete fields. + +Now take a compared ambient graph containing the identical subdivided +\(\mathsf P_n\). Split at its boundary cut points and condition on +the outside cables and those boundary vertex values. The Markov +decomposition on \(\mathsf P_n\) is exactly +\[ + \widetilde\Phi_n=\widetilde g_n^P+H_n, +\] +where \(\widetilde g_n^P\) has the reference cable law +and is independent of \(H_n\). The mean \(H_n\) is discrete harmonic +at the interior vertices and linear on inside cables. Choose a smooth +cutoff \(\chi\) supported in \(P\) and equal to one near \(\overline B\). +At vertices set \(u_n=\chi H_n\) and interpolate linearly on cables. +It equals \(H_n\) on all cables needed for the pairings and tests in +\(B\). The reference and ambient harmonic extensions also agree on +those complete cells. + +Interior discrete harmonic estimates and Green convergence make the +values and scaled finite differences of \(H_n\) converge in law on the +support of \(\chi\) to those of a smooth harmonic limit. They also +give convergence of the cutoff energies. This is a statement about +interior finite differences; the piecewise harmonic face extension +need not have a global classical smooth norm. Uniformly over the +domains, the covariance of \(H_n\) on a smaller buffer is bounded +in quadratic-form order by the harmonic covariance obtained from the +fixed outer box. Interior estimates consequently bound fixed smooth +norms of the limiting harmonic parts and their discrete analogues in +moments. Truncate such a bound, approximate the resulting family by a +finite smooth net in a weaker norm controlling the cutoff energy, and +apply \eqref{eq:kernel-cm-continuity}. Removing the truncation proves +the mixed-expectation limit on the restriction to \(B\). A prescribed +harmonic mean is treated by the same cutoff. + +For completeness, the mean premise is automatic for the constant labels +used below in the regular inner class. For a constant \(t\), the full +continuum ALS extension \(u_t\) equals \(t\) on \(\overline D\cap\mathcal B\), is +harmonic on \(\mathcal B\setminus\overline D\), and has value zero on +\(\partial\mathcal B\). The prelimit mean equals \(t\) on +\(\Gamma_n\cap D_n\); its ambient extension is \(t\) times the planar +probability of hitting that cable domain before \(\partial\mathcal B\). +The maximum principle bounds its absolute value by \(|t|\). +For \(z\in\partial D\cap\mathcal B\), fix a radius \(r>0\) below its +distance to the box boundary and to a fixed interior point. For every +small \(\eta>0\), connectedness of \(D\) gives a compact path in \(D\) +from \(B(z,\eta)\) to outside \(B(z,r)\). Inner exhaustion supplies a +connected cable path with the same property, up to a vanishing mesh +error, for all sufficiently large \(n\). The planar Beurling estimate +\cite[Lemma~4.1]{ALS2018} bounds the probability of avoiding that path +until leaving \(B(z,r)\) by \(C(\eta/r)^\beta\). First let \(n\) tend to +infinity and then \(\eta\) to zero. The extended mean thus tends to \(t\) +at every such boundary point. Away from \(\partial D\), convergence is +\cite[Lemma~4.2(1)]{ALS2018}. Bounded convergence now gives convergence +to \(u_t\) in \(L^2(\mathcal B)\), hence in \(H^s(\mathcal B)\), even +when \(\partial D\) has positive area. On the buffer cells the mean is +exactly constant, so the interior finite-difference requirement also holds. + +Thus the conditional kernel on that restriction is \(k\). Applying +\cref{lem:reverse-buffer} in the actual ambient domain promotes it to +conditioning on the full ambient field. The restricted Gaussian laws +are mutually absolutely continuous: conditional on \(H\), each is a +Cameron--Martin translate of the reference restriction with a strictly +positive likelihood, and integrating such translates preserves +equivalence. The representative of \(k\) is therefore unambiguous +under all these restrictions. The subsequence principle gives the +mixed-expectation convergence in item 2 even if a general bounded +test has several joint subsequential laws with the same conditional +mean. + +For item 3, apply that deterministic mixed-expectation conclusion +for almost every fixed \(\Theta=\theta\). The full-field convergence +of the centered fields and the extended means identifies the limiting +conditional field marginal with the selected parent GFF law. Integrating +against bounded functions of \(\Theta\) gives +\((\Theta,\Phi_D^{\mathrm{aux}})\stackrel{\mathrm d}= +(\Theta,\Phi_D)\). The cutoff comparison identifies the conditional +mean given \((\Theta,\Phi_D^{\mathrm{aux}}|_B)\); then the reverse buffer +argument, applied conditionally after centering the selected mean, +identifies it given \((\Theta,\Phi_D^{\mathrm{aux}})\). +Integrate the bounded mixed expectations against bounded functions +of \(\Theta\), and use equality of measures and a monotone class. +This proves the displayed conditional identity on the auxiliary limit; +the displayed equality of marginals relates it to the separately given +original field. A countable choice of polygons is handled by partitioning +according to that choice. +The reference subsequence is never reselected for a realized domain. + +Finally use a diagonal extraction for the countable tests and +thresholds. On \(C_{K,n}\) the exact identity +\(T_{n,t}^{\pm}(\widetilde g_n+t)=T_{n,0}^{\pm}(\widetilde g_n)\) +holds. The corresponding extensions differ by \(t\) on the complete +cells near \(B\), though they need not do so outside the selected +domain. Apply the two selected kernel statements to these identical +joint restricted laws. Their conditional means give +\eqref{eq:kernel-threshold}. The same mixed-expectation argument +conditional on \(\Theta\) gives its random-domain version. +\end{proof} + +The cutoff estimate also gives the following fixed-buffer fact. + +\begin{lemma}[Interior exhaustion] +\label{lem:kernel-exhaustion} +Let \(D_r\uparrow D\) be regular inner domains and \(B\Subset D_1\). +The laws of the zero-boundary continuum GFFs restricted to \(B\) +converge in total variation to the restriction of the GFF in \(D\). +This holds for simply connected \(D\) without a Jordan-boundary +assumption. +\end{lemma} + +\begin{proof} +Choose a fixed polygon \(P\) with \(\overline B\subset P\Subset D_r\) +for all large \(r\). In the Markov coupling, the field in \(D\) +restricted to \(D_r\) is an independent zero-boundary field in \(D_r\) +plus a harmonic Gaussian \(H_r\), with covariance \(G_D-G_{D_r}\). +Interior Green convergence and harmonic estimates make \(H_r\to0\) +in mean square in each fixed smooth norm near \(\overline B\). +Cut it off inside \(P\). The cutoff Dirichlet norm tends to zero +in mean, and \eqref{eq:kernel-cm-continuity}, conditional on \(H_r\), +bounds the total variation distance by +\(\tfrac12\E[\min\{2,\|\chi H_r\|_\nabla\}]\). This tends to zero. +\end{proof} + +\subsection{Calibration on killed lattice graphs} + +\begin{lemma}[The source killed graphs and the common kernel] +\label{lem:killed-graph-transfer} +The conclusions of \cref{lem:reverse-buffer,lem:local-kernel}, with +the same reference kernel \(k\), also hold for the following auxiliary +approximations of a bounded simply connected domain \(D\). +Choose a fixed dyadic point \(r\in D\) and put +\[ + V_n=\bigl\{v\in\varepsilon_n\mathbb Z^2\cap D: + \text{a lattice path from \(v\) to \(r\) stays at distance + at least \(\varepsilon_n\) from \(D^c\)}\bigr\}. +\] +For sufficiently large \(n\) this is the approximation of +\cite[(2.6)]{JLQ2023Fields}, translated to \(r\). +Use the cable realization of the vertex GFF killed on leaving \(V_n\): +every edge incident to \(V_n\), including a full exit edge ending at an +outside Dirichlet vertex, has its original resistance and its usual +conditional Brownian bridge. Complete this cable function to the full +grid in \(\mathcal B\) by setting missing vertices and missing edges +identically to zero, and harmonically extend it into each grid face. +Denote this extension by \(\widehat X_n\). The missing edges have +deterministic zero traces, not additional Brownian bridges. + +For a simply connected regular polygon \(B\Subset D\), use the +connected, hole-free complete-cell approximations \(B_n^\square\) +and reveal all of \(C_{B,n}\), including its perimeter cables. +Extend the residual, zero on \(C_{B,n}\), by the same completed-grid +operator. Its covariance form \(\mathsf K_n^B\) and the full covariance +form satisfy, for smooth tests \(f,g\) on the box, +\begin{equation} + \operatorname{Cov}(\widehat X_n(f),\widehat X_n(g)) + \longrightarrow G_D(f,g),\qquad + \mathsf K_n^B(f,g) + \longrightarrow G_{D\setminus\overline B}(f,g), + \label{eq:killed-graph-green} +\end{equation} +where the limiting kernels are zero-extended to \(\mathcal B\). +The corresponding fields are tight in the fixed \(H^s(\mathcal B)\), +\(s<-1\). For a constant parent label \(t\), add directly to +\(\widehat X_n\) the chosen continuum ALS extension \(u_t\): it equals +\(t\) on \(\overline D\), is harmonic on \(\mathcal B\setminus\overline D\), and is zero on +\(\partial\mathcal B\). +\end{lemma} + +\begin{proof} +This is a second, explicit planar embedding convention for auxiliary +fields. It preserves the entire source cable field, including its +exit-edge bridges. On every fixed compact subset of \(D\), its face +extension agrees with the earlier whole-cable convention for fine mesh. +In particular every test on \(C_{K,n}\) is unchanged. + +Let \(F_n\) be the set of vertices in \(C_{B,n}\). +The full vertex covariance is the killed random-walk Green kernel on +\(V_n\); the residual vertex covariance after the revelation is the +killed kernel on \(V_n\setminus F_n\). Conditional on endpoint values, +revealing the bridges in \(C_{B,n}\) supplies no further information +about vertices outside it. All unrevealed edge bridges remain present. +In particular an unrevealed edge with two pinned endpoints still +contributes its independent zero-endpoint bridge. + +The two killed vertex kernels converge off the diagonal to \(G_D\) +and \(G_{D\setminus\overline B}\), respectively. We recall the +boundary argument to specify its applicability to these full exit +stubs. The active vertex sets exhaust compact subsets of the indicated +open sets. Stop the walk in a compact inner domain; the invariance +principle identifies its limiting interior walk and harmonic functions. +The discrete Beurling estimate then bounds the probability that a walk +which has entered a thin neighborhood of a killing boundary returns a +fixed distance into the domain before being killed. This bound tends to +zero uniformly in fine mesh. The outer complement is connected and +nondegenerate; clamping \(B_n^\square\) adds the disjoint nondegenerate +polygonal obstacle. Apply the estimate at the component approached by +the walk. This identifies killing at the limiting boundary, and the +potential-kernel representation gives Green convergence. This is the +Green-convergence proof of \cite[Lemmas~4.1--4.2]{ALS2018}, applied to +the killed vertex walk. Realizing its killing transition by a full +cable stub does not change its vertex transition matrix. + +All these kernels are bounded by the killed Green kernel of one fixed +containing square. The square-lattice potential-kernel estimate gives +\begin{equation} + 0\le G_n(v,w)\le + C\left(1+\log_+\frac{R}{|v-w|\vee\varepsilon_n}\right), + \label{eq:killed-graph-log-bound} +\end{equation} +with fixed \(R,C\); see also the potential-kernel references in +\cite[Appendix~B]{ABJL2023}. If \(v_n\) tends to a boundary point +and \(w_n\) to a distinct point, Beurling applied before reaching a +fixed neighborhood of \(w_n\), followed by +\eqref{eq:killed-graph-log-bound}, gives \(G_n(v_n,w_n)\to0\). +Thus the piecewise constant vertex kernels converge off the diagonal +to the zero-extended continuum kernel even when the outer boundary has +positive area. The logarithmic bound is integrable, and the integrated +contribution of a shrinking neighborhood of the diagonal vanishes +uniformly. Dominated convergence proves convergence of the paired +vertex Green forms for smooth box tests. + +We next retain, rather than discard, the cable bridges. Split the +completed cable field into the piecewise linear interpolation of its +vertex values and its centered edge bridges, and extend both parts +harmonically into the square faces. The harmonic basis function of a +vertex is nonnegative, supported on its four incident faces, and has +integral \(\varepsilon_n^2\). Hence its coefficient against \(f\) +differs from \(\varepsilon_n^2 f(v)\) by +\(O_f(\varepsilon_n^3)\), and the total absolute coefficient error is +\(O_f(\varepsilon_n)\). The containing-square diagonal Green bound +therefore bounds the variance of this error by +\(O_f(\varepsilon_n^2\log(1/\varepsilon_n))\). +A centered edge bridge contributes through at most two faces. Its +paired variance is \(O_f(\varepsilon_n^4)\), since its covariance is +bounded at the fixed resistance normalization and those faces have +area \(O(\varepsilon_n^2)\). There are +\(O(\varepsilon_n^{-2})\) independent retained bridges, independent +also of the vertex field. Consequently, for the full field and for +the clamped residual, +\begin{equation} + \E\left|\widehat X_n(f) + -\varepsilon_n^2\sum_v f(v)X_{n,v}\right|^2 + \le C_f\varepsilon_n^2 + \bigl(1+\log(1/\varepsilon_n)\bigr)\longrightarrow0. + \label{eq:killed-graph-embedding} +\end{equation} +For the residual use its pinned vertex values in this display. +Unrevealed bridges between two pinned endpoints are included in the +bridge estimate. Thus no perimeter cable has been deleted or replaced. +The use of the completed grid makes this estimate valid for global +box tests, including boundary-adjacent faces. Together with the vertex +Green convergence it proves \eqref{eq:killed-graph-green}. + +The nonnegative face basis also carries +\eqref{eq:killed-graph-log-bound} to the planar covariance, with the +logarithm truncated at mesh distance. The bridge covariance is bounded +and supported on pairs of adjacent faces. Integrating against the +logarithmic kernel for the \(H^{-1}\) norm gives a uniform bound on +the expected squared \(H^{-1}\) norm. Compact inclusion into +\(H^s\), \(s<-1\), proves the asserted tightness. + +Finally \(\overline P\subset D\) implies that a whole neighborhood +of \(\overline P\) lies in \(V_n\) for all sufficiently fine mesh: +its compact pieces have lattice connections to \(r\) with a fixed +positive clearance. Subdivide the prescribed cables at +\(\partial P_n^\diamond\). The reference \(\mathsf P_n\) is then +literally the same graph, with the same inherited half-edge +resistances and unpinned cut points in the ambient field. Conditioning +on its exterior gives exactly the original reference residual. + +After covariance convergence, the proof of +\cref{lem:reverse-buffer} uses Gaussian projection, the cable Markov +decomposition, and measurability of compact interior face pairings. +All these statements hold for the present extension, so that proof +applies unchanged. The comparison proof of \cref{lem:local-kernel} +uses the same reference \(\mathsf P_n\) and harmonic estimates on +fixed interior buffers, where the operators and cables agree exactly. +It therefore gives the same \(k\), including the conditional-parent +conclusion by integrating the bounded mixed expectations. +For a constant label the added deterministic function \(u_t\) is +bounded, agrees exactly at every mesh with the prescribed full +continuum mean, and is identically \(t\) near the buffers. Thus it +has the required full-field and interior mean convergence, without +altering any local threshold test. +\end{proof} + +\subsection{Forcing in the canonical parent} + +We first establish the one-sided excursion approximation needed for +calibration. All fields in this argument have the normalization +\eqref{eq:kernel-energy}. Fix a bounded simply connected domain \(D\) +and a dyadic rational point \(z_0\in D\). For all sufficiently large +\(n\), let \(D_n^{\mathrm{tr}}\) be the component of \(z_0\) in the +\(\varepsilon_n\)-grid whose connecting paths stay at distance at least +\(\varepsilon_n\) from \(\partial D\), as in +\cite[(2.6)]{JLQ2023Fields}. Use its killed cable graph, retaining +full-resistance edges to outside Dirichlet vertices. These auxiliary +graphs contain every fixed interior reference \(\mathsf P_n\) for +large \(n\); \cref{lem:killed-graph-transfer} makes +\cref{lem:local-kernel} applicable to them. + +\begin{lemma}[One-sided forcing by an outermost excursion] +\label{lem:soup-forcing} +Let \(\widehat\Phi_n\) be the completed-grid whole-cable extensions of +zero-boundary GFFs on these graphs. Fix a collar +\(Q\Subset V\Subset K\Subset B\Subset P\Subset D\). +In every joint subsequential limit +\[ + (\widehat\Phi_n,T_{n,0}^{+},T_{n,0}^{-}) + \longrightarrow (\Phi,T^+,T^-), +\] +the following holds almost surely. If an outermost canonical positive +excursion of \(\Phi\) meets both +\(\operatorname{int}Q\) and +\(\operatorname{int}K\setminus\overline V\), then \(T^+=1\). +The analogous negative excursion forces \(T^-=1\). +\end{lemma} + +\begin{proof} +Fix one \(\gamma\in(0,2)\). Couple the cable GFF to a critical +cable loop soup \(\widetilde{\mathcal L}_n\) by the signed isomorphism +\cite{Lupu2016}. Write \(\mathcal L_n\) for the random-walk soup +obtained by taking its vertex trace. Vertex occupation times are +preserved by this trace construction; see also +\cite[Section~2.2]{ALS2018}. Write +\(\mathcal M_{\gamma,n}\) for the normalized unsigned thick-point +measure at vertices and \(\mathcal M_{\gamma,n}^{\pm}\) for its +restrictions to vertices with the indicated cable-field sign. +Thus \(\mathcal M_{\gamma,n} +=\mathcal M_{\gamma,n}^{+}+\mathcal M_{\gamma,n}^{-}\). +We use exactly the source normalization +\cite[(2.5), (2.10), Theorem~2.1]{JLQ2023Fields}, whose limiting expectations are +\(\E\mathcal M_\gamma(\dd z)=2\dd z\) and +\(\E\mathcal M_\gamma^+(\dd z)=\dd z\). +All measure limits below may be read in the local weak topology on +\(D\). The deterministic conformal-radius factor in this +normalization is continuous, positive and bounded with bounded inverse +on each compact subset of \(D\), so that changing the GMC convention +there causes no boundary reweighting issue. + +The cable version of \cite[Corollary~8.4 and the paragraph following +it]{JLQ2023Fields}, in the vertex-trace coupling, gives +\begin{equation} + (\widetilde{\mathcal L}_n,\mathcal M_{\gamma,n}^{+}) + \longrightarrow(\widetilde{\mathcal L}, + \widetilde{\mathcal M}_\gamma^{+}), + \label{eq:soup-positive-chaos} +\end{equation} +where \(\widetilde{\mathcal L}\) is a Brownian loop soup and +\(\widetilde{\mathcal M}_\gamma^{+}\) is its chaos restricted to +independently positively marked clusters. Retain separately the +projected random-walk soup coordinate \(\mathcal L_n\), whose +joint limits with unsigned and cluster-restricted chaos are given by +\cite[Theorem~8.3]{JLQ2023Fields}. Call its limiting soup +\(\mathcal L\). We will not need to identify the two limiting +time parametrizations. + +Their multisets of individual loop ranges do agree. Indeed, drawing +each vertex-trace jump along its edge changes the range of a cable +loop visiting vertices by at most \(2\varepsilon_n\) in Hausdorff +distance. Erased excursions stay on edges incident to visited +vertices, and loops with no vertex have diameter at most +\(\varepsilon_n\). At every positive diameter cutoff which is +not the diameter of a limiting loop, the limiting soups have finitely +many loops. The finite point-process matching in the loop-soup +topology, followed by the range map, therefore passes this trace +matching to the limit; compare \cite[Section~4.1.2]{ALS2018}. +Exhausting such cutoffs gives equal multisets of individual ranges, +and hence identical cluster closures. This uses equality of the +limiting range families, not continuity of a cluster-formation map. + +The positive and negative thick-point calculations in +\cite[Section~9, proof of Theorem~1.5]{ABJL2023} also give convergence +of each signed measure jointly with its underlying vertex GFF to +the corresponding GMC of that same GFF. Since both limiting GMCs +are measurable functions of the field, this also identifies their +joint limit. In the source occupation-time normalization the vertex +field is \(X_n(v)=\sigma_v\sqrt{4\pi\ell_v}\), so its logarithmic +covariance coefficient is one, as required by +\eqref{eq:kernel-energy}. +The whole-cable estimate \eqref{eq:killed-graph-embedding} +identifies this vertex-field limit with the completed-grid extension +in \cref{lem:killed-graph-transfer}. + +In particular, every joint limit has +\(\mathcal M_\gamma^{\pm}=\operatorname{GMC}_{\pm\gamma}(\Phi)\), +where the GMC notation includes the stated deterministic normalization. +The reconstruction theorem +\cite[Theorem~1.1]{BSS2020} supplies a measurable map \(R_\gamma\) +such that +\[ + \Phi=R_\gamma(\mathcal M_\gamma^{+}) + \quad\hbox{almost surely}. +\] +The deterministic conformal-radius factor between the GMC conventions +is included in \(R_\gamma\). +Thus \eqref{eq:soup-positive-chaos} and the same-field GMC limit +identify the entire joint law +\((\Phi,\widetilde{\mathcal L},\mathcal M_\gamma^+)\). +This step uses measurability after passage to the limit, not continuity +of the reconstruction map. + +There is also one common unsigned measure in the two soup coordinates. +The exact prelimit identity and the two same-field limits give +\[ + \mathcal M_\gamma + =\operatorname{GMC}_{\gamma}(\Phi) + +\operatorname{GMC}_{-\gamma}(\Phi). +\] +In the just identified cable-soup coupling this is its unsigned chaos +\(\widetilde{\mathcal M}_\gamma\), by +\cite[Theorem~1.4]{JLQ2023Fields}; in the projected-soup coordinate it +is the unsigned chaos supplied by \cite[Theorem~8.3]{JLQ2023Fields}. +Thus the two limiting soups have both the same cluster geometry and +the same unsigned measure. Equality of the latter follows from +their common vertex observable and the two GMC identities, without +assuming that chaos is determined by unparametrized ranges. + +We next identify the cluster marks in this joint law as the canonical +excursion signs. The continuum results +\cite[Theorems~1 and~2]{ALS2023} describe the joint law of the closed +cluster supports, their Minkowski measures, their independent symmetric +signs, and their signed sum. The Minkowski construction in +\cite[Theorems~1.9 and~1.10]{JLQ2023Fields} normalizes the same +Euclidean neighborhood measures. Since both normalizations have +finite nonzero limits, their deterministic ratio converges to one +positive constant, common to every cluster. For example, compare +the total masses for one cluster: the ratio can have neither zero +nor infinite subsequential limits, and two distinct finite limits +would give two different multiples of a nonzero limiting measure. +The signed sums therefore differ by that same constant; their GFF +covariance normalizations fix it. The order of summation can be +changed to a common sign-independent enumeration: Hilbert-space +\(L^2\) convergence and independent-sign orthogonality give +\(\E\sum_i\|\mu_i\|_{H^{-q}}^2<\infty\) for a sufficiently large +\(q>1\), hence conditional square summability and unconditional +convergence of the signed series. Consequently the joint law just +identified has precisely the canonical excursion supports and signs +of \(\Phi\). Only the continuum parts of \cite{ALS2023} are used here. + +For the fixed \(\gamma\), every soup cluster \(C\) selected by a +rational-point label satisfies +\begin{equation} + \mathcal M_\gamma(C)>0 + \quad\hbox{almost surely}. + \label{eq:soup-cluster-chaos-positive} +\end{equation} +Here is a useful argument that does not presume positivity of a +restriction to a random thin set. Flip only the independent sign of +\(C\), keeping the soup and all other signs fixed. This transformation +preserves the signed-soup law. Hence the original and flipped samples +both satisfy the same reconstruction identity with \(R_\gamma\), on +the intersection of two full-probability events. On +\(\{\mathcal M_\gamma(C)=0\}\) the positive-chaos measure is unchanged, +so the reconstructed field is unchanged. Its signed-Minkowski +representation, however, changes by a nonzero multiple of the +nonzero positive measure of \(C\), by +\cite[Theorems~1.4, 1.9 and~1.10]{JLQ2023Fields}. This contradiction +proves \eqref{eq:soup-cluster-chaos-positive}. + +Fix a rational \(x\in D\), and let \(C_n(x)\) be the outermost +ordinary random-walk loop cluster surrounding \(x\), with projected +loops drawn along the grid edges. Its trace is contained in a cable +sign cluster; call that sign \(\sigma_n(x)\). If no such cluster +exists, use the empty set and assign sign \(+1\); its restricted +measure below is then zero. When nonempty, it is a connected +one-sign path witness. Retain also +\[ + \mu_n(x)=\mathcal M_{\gamma,n}|_{C_n(x)}. +\] +The printed random-walk statement +\cite[Theorem~8.3]{JLQ2023Fields} gives, jointly with the soup, +\[ + C_n(x)\longrightarrow C(x),\qquad + \mu_n(x)\longrightarrow\mathcal M_\gamma|_{C(x)}, +\] +in the Hausdorff and weak-measure topologies, respectively. +Take an arbitrary further joint limit including \(\sigma_n(x)\). +At every mesh, +\[ + \begin{split} + \sigma_n(x)=+1&\ \Longrightarrow\ + \mathcal M_{\gamma,n}^{+}\ge\mu_n(x),\\ + \sigma_n(x)=-1&\ \Longrightarrow\ + \mathcal M_{\gamma,n}-\mathcal M_{\gamma,n}^{+}\ge\mu_n(x). + \end{split} +\] +These inequalities pass to the limit because the positive-measure cone +is closed. In the identified continuum coupling, the positive chaos +restricted to \(C(x)\) is either its entire unsigned chaos or zero, +according to the canonical sign \(\tau(x)\). By +\eqref{eq:soup-cluster-chaos-positive}, the limiting inherited sign +must therefore equal \(\tau(x)\). No independence of the signs of +different random-walk clusters is asserted: they may share a cable +cluster. + +The rational labels cover every outermost continuum cluster. +For each fixed label, strict hits in the two open target sets persist +under Hausdorff convergence, and the inherited sign has just been +identified. A path in the projected cluster from its inner hit to +its outer hit is a cable sign path. Since +\(\overline V\subset\operatorname{int}K\), an initial portion +reaches a point outside \(\overline V\) before any exit from \(K\). +This portion forces the corresponding test. Applying Skorokhod +representation to any further joint +subsequence proves the assertion, first for each rational label and +then simultaneously for all labels by countability. +\end{proof} + +We now apply this deterministic-domain calibration to the canonical +parent before revealing its remainder field. Let \(\Theta\) be the +local-set data of the canonical ancestors, let \(\Phi_D\) be the +total field in the selected parent, and fix a collar with +\(\overline P\subset D\). Conditionally on \(\Theta\), choose the +killed auxiliary graphs above for excursion calibration and subtract +the constant parent label. A retained cluster is treated in its own +recursive parent, where its containing excursion is outermost. +\Cref{lem:soup-forcing,lem:killed-graph-transfer} and the threshold +identity in \cref{lem:local-kernel} apply along the already selected +mesh subsequence. For an FPS, use instead the admissible metric-domain +approximations and \cite[Proposition~4.7]{ALS2018}. Its inner hit is +connected to the artificial parent boundary by the prescribed one-sign +path. Since the parent contains \(\mathsf P_n\), this path exits +\(V\) while still inside \(K\). Thus in either case the canonical +strict-hit event forces \(T=1\) in every auxiliary joint limit. + +This conditional calibration does not require a measurable family of +Skorokhod representations over all possible parents. For each fixed +parent, augment an arbitrary subsequence as in the proof above. +The continuous hit-depth function +\[ + J_U(C)=\sup_{x\in C}\min\{1,\dist(x,U^c)\}, + \qquad J_U(\varnothing)=0, +\] +shows that the product of the two required hit depths with \(1-T\) +vanishes in every limit. The resulting bounded mixed-expectation +conclusion holds along the selected subsequence. Apply it pointwise +to the conditional auxiliary kernels for \(\Theta=\theta\), and +integrate by dominated convergence. Together with item~3 of +\cref{lem:local-kernel}, this gives +\[ + \E[T\mid\Theta,\Phi_D^{\mathrm{aux}}] + =k(\Phi_D^{\mathrm{aux}}|_B). +\] +If \(E^{\mathrm{aux}}\) is the corresponding canonical strict-hit +event, then it belongs to +\(\sigma(\Theta,\Phi_D^{\mathrm{aux}})\), and \(T=1\) on that event. +Positivity gives +\(\ind_{E^{\mathrm{aux}}}(1-k(\Phi_D^{\mathrm{aux}}|_B))=0\). +Equality of the \((\Theta,\Phi_D^{\mathrm{aux}})\) and +\((\Theta,\Phi_D)\) marginals transfers this identity to the original +parent: +\begin{equation} + \ind_E\bigl(1-k(\Phi_D|_B)\bigr)=0 + \quad\hbox{almost surely}. + \label{eq:kernel-forcing} +\end{equation} +Canonical ancestor data are functions of the original field, so this +identity remains true in any extension carrying the stopped exploration. +The later upper bound conditions only on that stop; it does not assert +a formula for \(\E[T\mid\Phi_D,\mathrm{stop}]\). + +\begin{figure}[t] +\centering +\begin{tikzpicture}[font=\small,>=Latex] + \draw[rounded corners,fill=gray!8] (0,0) rectangle (3.6,2.6); + \draw[rounded corners,fill=teal!9] (.25,.25) rectangle (3.35,2.35); + \draw[rounded corners,fill=white] (.55,.55) rectangle (3.05,2.05); + \draw[dashed,rounded corners] (.85,.8) rectangle (2.25,1.8); + \draw[fill=teal!20] (1.02,1.08) rectangle (1.38,1.48); + \draw[thick,red,->] (1.2,1.28) .. controls (1.65,1.65) and (2.05,1.1) .. (2.7,1.35); + \node at (1.2,.94) {\(Q\)}; + \node at (2.05,1.65) {\(V\)}; + \node[anchor=east] at (3.0,1.87) {\(K\)}; + \node[anchor=east] at (3.3,2.17) {\(B\)}; + \node[anchor=east] at (3.55,2.43) {\(P\)}; + \draw[->,thick] (3.85,1.3)--(4.55,1.3); + \node[draw,rounded corners,align=center,text width=4.8cm] (ker) at (7.15,1.3) + {one local function \(k(\Phi|_B)\)}; + \node[draw,rounded corners,align=center,text width=4.8cm] (force) at (2.5,-1.25) + {Canonical parent and strict hits \(E\)\\\(\ind_E(1-k)=0\)}; + \node[draw,rounded corners,align=center,text width=4.8cm] (bound) at (8,-1.25) + {Condition on the retained stop\\\(\Phi|_O=m+g^O\), collar means \(\to0\)}; + \draw[->] (ker.south west)--(force.north); + \draw[->] (ker.south east)--(bound.north); +\end{tikzpicture} +\caption{The path test crosses \(V\) inside \(K\), and the separated +buffers \(B\) and \(P\) make its kernel common to different Gaussian +domains. Calibration in the canonical parent gives an identity on the +field space. The upper bound uses the conditional GFF law of the stopped +component.} +\label{fig:kernel-conditioning} +\end{figure} + +\subsection{The zero-boundary collar bound} + +Fix a bounded simply connected \(O\), a compact rational polygon +\(Q\Subset O\), and a regular inner exhaustion +\(Q\Subset O_1\Subset O_2\Subset\cdots\uparrow O\). +For the \(j\)-th collar take +\[ + V=O_j,\qquad K=O_{j+2},\qquad B=O_{j+3},\qquad P=O_{j+4}. +\] +Use regular inner cable approximations of \(O\) on the common grid. +They have complement-Hausdorff convergence, uniformly bounded +connectivity, and contain every fixed \(\mathsf P_n\) for fine mesh. +Write \(T_{j,n}^{\pm}\) for the zero-threshold tests. We claim +\begin{equation} + \lim_{j\to\infty}\limsup_{n\to\infty} + \P(T_{j,n}^{\pm}=1)=0. + \label{eq:zero-boundary-collar} +\end{equation} + +We prove this estimate directly on the auxiliary metric graphs. +Choose the inner approximating domains \(D_n\subset O\) to be simply +connected unions of dual mesh cells, with their boundary cable +intersection points adjoined as Dirichlet endpoints, as for the +reference polygons above. The approximations exhaust compact subsets +of \(O\) and eventually contain every prescribed reference subgraph. +Such a choice follows by first exhausting the simply connected \(O\) +by regular simply connected polygons and then taking sufficiently fine +inner cell approximations, along a diagonal sequence. Their complements +converge in Hausdorff distance, their connectivity is one, and they +converge in the pointed Carath\'eodory sense. Write +\(\mathsf O_n=\Gamma_n\cap D_n\) for the resulting zero-boundary metric +domains. All distances below are ambient Euclidean distances. In the +metric-graph coupling +\cite[Section~2.3 and Proposition~2.4, with zero boundary data]{ALS2018}, +the nonzero sign components of the cable GFF are the clusters of a +metric-graph Brownian loop soup of intensity \(1/2\). The constant +field rescaling used for our normalization does not change these +components. + +Set +\[ + d=\tfrac12\dist(Q,\partial O)>0,\qquad + \eta_j=\sup_{z\in O\setminus O_j}\dist(z,\partial O). +\] +Because \(O\) is bounded and the nested \(O_j\) exhaust every compact +subset of \(O\), we have \(\eta_j\to0\). A zero-threshold crossing +has a supporting sign component whose closure meets \(Q\) and +\(O\setminus O_j\). Indeed, after erasing loops, the path uses finitely +many cable intervals. Interior vertex values are nonzero almost surely, +and a Brownian bridge almost surely has no interior local minimum or +maximum at the deterministic level zero. Thus allowing zero endpoints +does not concatenate distinct sign components. In the loop-soup +coupling, it supplies a cluster \(C\) with +\[ + \dist(C,\partial\mathsf O_n)\le 3\eta_j, + \qquad \sup_{z\in C}\dist(z,\partial O)\ge d. +\] +Here distances to a cluster may equivalently be taken to its closure. +For each fixed \(j\), these bounds hold for all sufficiently fine +meshes. The first uses the inner approximation property: distance +to the Euclidean boundary of \(D_n\) is at most distance to +\(\partial O\), and every point of \(\partial D_n\) is within +\(\varepsilon_n/2\) of a metric boundary cut point. The extra margin also +allows replacing an endpoint in the closure by a point of the cluster. +The second bound follows from the hit on \(Q\). + +The boundary-avoidance estimate +\cite[Lemma~4.13]{ALS2018}, at intensity \(1/2\), applies to the +chosen complement-Hausdorff approximations, which also converge in +the pointed Carath\'eodory sense and have the required bounded +connectivity. For the fixed \(d\), it bounds the probability of the +last displayed event by a quantity tending to zero as +\(\eta_j\to0\), uniformly in the mesh. Therefore +\[ + \lim_{j\to\infty}\limsup_{n\to\infty} + \P(T_{j,n}^{\pm}=1)=0. +\] +This proof uses metric loop-soup boundary avoidance, without requiring +convergence of diameter-ranked excursion clusters. + +Let \(k_{j,0}^{\pm}\) be the common kernels selected for these +countably many collar choices. For fixed \(j\), the mixed-expectation +conclusion of \cref{lem:local-kernel} in \(O\) identifies its integral +with the mesh limit of the bounded test. Thus +\begin{equation} + \lim_{j\to\infty} + \E[k_{j,0}^{\pm}(g^O|_{B_j})]=0, + \qquad g^O\text{ a zero-boundary GFF in }O. + \label{eq:zero-boundary-kernel} +\end{equation} +This proof applies directly to rough \(O\). The total variation statement +in \cref{lem:kernel-exhaustion} concerns a fixed buffer and supplies no +estimate with a collar moving toward the boundary. + +\subsection{No crossing of a stopped component} + +\begin{proposition}[No crossing] +\label{prop:no-crossing} +Let \(O\) be a component of a stopped exploration from +\cref{prop:exploration-thin}, with retained sigma-field \(\mathscr E\). +Suppose \(O\) lies in an initial free parent \(P_0\) of label \(b_0\in a\Z\), or in +one pointed wired parent \(P_0\) of label \(b_0=\pm a\). As provided there, +\(O\) is simply connected and, conditionally on \(\mathscr E\), +\[ + h|_O=m+g^O,\qquad m-b_0\in2a\Z. +\] +No canonical free cluster descended from that parent meets both \(O\) +and \(\partial O\). The conclusion holds simultaneously for all +pointed components and all recursive generations, and after a restart +in a captured odd layer with its new incoming label. + +In the wired case \(O\) may be a residual component of the global +composite exploration of the original \(h\). The proof uses +\(O\subset P_0\), simple connectedness, and the +displayed conditional law. It requires no connectedness of the +explored set relative to that parent and no separately selected +lattice sweep inside a limiting wired hole. +\end{proposition} + +\begin{proof} +First work in an indexed canonical parent \(D_{\mathrm{par}}\) whose +total field is \(b+f\). +For a positive first-generation cluster \(C\), +\cref{lem:canonical-geometry} supplies a containing positive excursion +at total level \(b\) and a containing upper FPS with sublevel paths at +total level \(b+2a\). For a negative cluster the containing paths are +below \(b\) and above \(b-2a\). The parent is the initial domain or a +canonical Jordan hole; its auxiliary approximations are the source killed graphs for the +excursion test and the regular metric domains for the FPS test. + +Suppose \(C\) meets both \(O\) and \(\partial O\), and choose a rational +\(Q\Subset O\) whose interior it meets. In a regular inner exhaustion +as above, connectedness of \(C\) makes it meet \(\partial O_{j+1}\) +for every large \(j\). This gives the two strict neighborhoods for the +excursion test: the second lies in +\(O_{j+2}\setminus\overline O_j\). The FPS test needs only the strict +inner hit, because its boundary-connected path must exit the fixed +collar. On the relevant-parent event \(O\subset D_{\mathrm{par}}\), +all buffers are contained in this canonical parent. + +The stopped label and this parent label belong to the same affine +lattice \(b_0+2a\Z\). For a positive cluster, either \(m\le b\), so +the excursion forces the above-\(m\) test, or \(m\ge b+2a\), so the +upper FPS forces the below-\(m\) test. For a negative cluster, either +\(m\ge b\), using the below-\(m\) excursion, or \(m\le b-2a\), using +the above-\(m\) FPS. These alternatives exhaust the lattice. The +absolute threshold \(m\) belongs to \(a\Z\). + +Calibrate both tests at every fixed threshold in \(a\Z\) in the +canonical parent, conditional on its ancestor data. For the excursion, +use \cref{lem:soup-forcing} for each rational-point label and take +the countable union; for the FPS use the whole-set identity. The path +implications and \eqref{eq:kernel-forcing} then hold simultaneously +for the countable choices of parent index, rational-point label, +threshold, and collar. +They are identities on the original field space and survive adjoining +the stop. To state the bound globally, fix an indexed candidate \(C\) +and a rational \(Q\), and select the collar from the stopped state by +the rule described below. Let \(\mathsf H_j\in\mathscr E\) record that +the selected pointed component and its \(j\)th collar are defined with +the required clearances inside \(O\). Let \(\mathsf L_j\) record that +the indexed candidate and its parent \(D_{\mathrm{par}}\) exist and that +\(\overline P_j\subset D_{\mathrm{par}}\). This latter event may depend +on canonical data. Declare it false when \(\mathsf H_j\) fails, use the +empty set for an absent candidate or component, and put +\[ + \mathsf C_Q=\{C\cap\operatorname{int}Q\ne\varnothing,\, + C\cap\partial O\ne\varnothing\}. +\] +The right side below is defined to be zero outside \(\mathsf H_j\). +Substituting the stopped-measurable \(m\) in the simultaneous forcing +identities gives the global pointwise bound +\begin{equation} + \ind_{\mathsf H_j\cap\mathsf L_j\cap\mathsf C_Q} + \le \ind_{\mathsf H_j} + \bigl(k_{j,m}^{+}(h|_{B_j})+k_{j,m}^{-}(h|_{B_j})\bigr). + \label{eq:crossing-kernel-bound} +\end{equation} +The direction selected by the unknown parent label \(b\) has disappeared +from this inequality. In particular \(b\) need not be measurable in +\(\mathscr E\). + +Condition now only on \(\mathscr E\). The event \(\mathsf H_j\), the +collar, and \(m\) are stopped-measurable. The component law gives +\begin{align*} + \Pr(\mathsf H_j\cap\mathsf L_j\cap\mathsf C_Q\mid\mathscr E) + &\le \ind_{\mathsf H_j}\E\!\left[ + k_{j,m}^{+}(m+g^O|_{B_j})+ + k_{j,m}^{-}(m+g^O|_{B_j})\,\middle|\,\mathscr E\right] + \\&= + \ind_{\mathsf H_j}\E\!\left[ + k_{j,0}^{+}(g^O|_{B_j})+ + k_{j,0}^{-}(g^O|_{B_j})\,\middle|\,\mathscr E\right], +\end{align*} +where \eqref{eq:kernel-threshold} is applied under that conditional +Gaussian law. For each realized \(O\), \eqref{eq:zero-boundary-kernel} +makes the right side tend to zero as \(j\to\infty\). On the branch where +this parent is relevant, a crossing with witness \(Q\) belongs to +\(\mathsf H_j\cap\mathsf L_j\) for every sufficiently large \(j\). +Conditional Fatou applied to the left indicators therefore gives zero +conditional probability for that relevant crossing. No conditioning +on \(\mathsf L_j\) is used. + +All random choices can be made within the countable families already +selected. An open hit has a rational polygon \(Q\) as witness. The +closed-set coordinate of the stop determines whether a rational polygon +has positive clearance inside \(O\). Choose successively the first +regular rational polygon containing the preceding one and the next +finite list of rational compact buffers. Simple connectedness ensures +such a nested exhaustion exists, and the clearance tests make the choice +\(\mathscr E\)-measurable. Partition by each finite collar and threshold +choice before conditioning. The random-domain clause of +\cref{lem:local-kernel} and bounded convergence justify the displayed +conditional integrals. There are countably many components and +canonical clusters. + +It remains to justify that the same argument reaches every recursive +parent. Assume it for the ancestors of a candidate cluster. If an +ancestor lies wholly in \(O\), its filled disk lies in \(O\): its +outer Jordan loop is inside the simply connected \(O\), so the +connected complement of \(O\) cannot enter that loop without crossing +it. All descendants then stay in \(O\). Otherwise, an ancestor that +does not cross \(O\) and does not lie inside it is disjoint from \(O\). +Connectedness puts \(O\) in one complementary canonical hole, unless +the candidate descendant is outside \(O\) already. In the relevant +hole the incoming label is some \(b\in b_0+2a\Z\). The same absolute +threshold argument applies there. On this branch \(O\subset D_{\mathrm{par}}\), +so \(\mathsf L_j\) holds for every sufficiently large collar and the +global bound applies. Calibration conditions on that +parent's canonical data, while the upper bound continues to condition +only on the original retained stop. Induction proves the claim. + +For a global composite wired stop, \(A\) contains the wired layer, so +\(O\) lies in one pointed wired hole. Its label satisfies +\(m-b_0\in2a\Z\) with \(b_0=\pm a\), and all canonical descendants +have baselines in the same affine lattice. The preceding proof applies +in the original field using those absolute labels. No further +exploration is introduced inside the selected limiting hole. +\end{proof} diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/09-identification.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/09-identification.tex new file mode 100644 index 0000000000000000000000000000000000000000..a994e0bd4c4256c3e1cdbe1e71d45405c8d43748 --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/09-identification.tex @@ -0,0 +1,1066 @@ +\section{Identification of the complete cluster collections} +\label{sec:identification} + +The stopped carpets determine the odd holes and their relative height +jumps. They do not determine which holes belong to one current cluster. +We identify that partition first. Finite families of visible holes then +transfer the lattice count bounds to all generations of the canonical +construction. The remaining task is to recover every point of a cluster, +including points that are not detected by an odd hole. + +\subsection{Marked odd holes and their supplying clusters} + +Fix a countable dense set \(\mathcal Q\subset D\). For each \(q\in\mathcal Q\) +choose a nearest lattice representative on the relevant \(W\) lattice, +using one deterministic rule to break ties. We record odd holes by a +family label \(\iota\in\{\mathrm f,\mathrm w\}\), a mark \(q\), and an +odd depth \(r\geq1\). The label \(\mathrm f\) refers to the original free +dual current; \(\mathrm w\) refers only to the free primal descendants +after the wired boundary cluster has been exposed. + +At depth zero, \(V_{\delta,0}^{\mathrm f}(q)\) is the original free +chamber, with wall value \(b_{\delta,0}^{\mathrm f}(q)=0\). +For \(\iota=\mathrm w\), it is the component face left by the wired +layer that contains the representative of \(q\), with its observed +value \(b_{\delta,0}^{\mathrm w}(q)\in\{-a,a\}\). +Given a valid \(V_{\delta,r-1}^{\iota}(q)\), expose its first odd +carpet and let \(V_{\delta,r}^{\iota}(q)\) be the unsearched hole +containing the representative, with observed wall value +\(b_{\delta,r}^{\iota}(q)\). Write \(C_{\delta,r}^{\iota}(q)\) +for the current cluster supplying that odd rim, and put +\[ + \epsilon_{\delta,r}^{\iota}(q) + =\frac{b_{\delta,r}^{\iota}(q) + -b_{\delta,r-1}^{\iota}(q)}{2a}\in\{-1,1\}. +\] +If the representative is outside the chamber, lies on the revealed +carpet, or no such hole remains, give this observation and all its +descendants the cemetery value \(\dagger\), and set its sign to zero. +Validity, odd depth, and the supplying cluster depend only on the +unsigned data \((N,s)\), not on the free transverse colors \(d\). + +The continuum observations \(V_r^\iota(q)\), \(b_r^\iota(q)\), and +\(\epsilon_r^\iota(q)\) are defined in the same way from the canonical +odd carpets of \cref{lem:canonical-geometry}. At depth zero the free +parent is \(D\), while the wired parent is the component of +\(D\setminus C_\partial\) containing \(q\), with its label \(\pm a\). +Use the same cemetery convention if a mark lies on a continuum carpet. +For a valid observation, \(C_r^\iota(q)\) denotes the retained canonical +cluster whose odd hole is \(V_r^\iota(q)\). The one-arm estimates in +the proof of \cref{lem:cut-neighborhoods} make every fixed mark miss +the limiting carpets almost surely. Every canonical odd hole contains a mark, so +these countably many observations see all odd holes at every finite +depth. + +Here and below convergence of a marked hole is \emph{pointed}: +the closed carpet and its complement determine the limiting component +containing the mark, and every compact subset of that component is +eventually inside the discrete component. We do not assert Hausdorff +convergence of the closures of individual holes. In particular, one +discrete component may split into several pointed limiting components. + +Abbreviate an address \((\iota,q,r)\) by \(i\), and write \(V_\delta(i)\), +\(C_\delta(i)\), and \(\epsilon_\delta(i)\), with the analogous notation +in the limit. For two addresses in the same family, define +\(i\sim_\delta j\) when both are valid and +\(C_\delta(i)=C_\delta(j)\); otherwise the relation is false. +Define \(i\sim j\) by the same rule for the supplying canonical +clusters, with a false relation whenever either address is invalid. + +Fix any mesh subsequence. The whole-domain bound +\cref{cor:global-cluster-counts} and \cref{lem:matching-topology} +give compact containment of the two encoded collection factors +\(F(\cC_\delta^{\rm f})\) and \(F(\cC_\delta^{\rm w})\) in the +locally finite part of \(\mathfrak X\), the compact hyperspace over +the fixed enclosing square \(X\). +The height is tight by \cref{thm:flat-gff}. We pass to a joint further +subsequence retaining the closed carpets, their marked pointed +components and labels, the marked supplier supports in +\(\mathscr H\cup\{\dagger\}\) with an isolated cemetery value, and +the bits \(i\sim_\delta j\) for every fixed pair of addresses. +These supplier coordinates are compact; +they are separate from the contributor lists introduced later. +Write \(F_*^\iota\) for the locally finite outer Hausdorff limits of +the encoded collections. The relation coordinates are finite-valued; +on a joint representation they are eventually constant, with limiting +relation denoted by \(\sim_*\). This retains the finite identity +relations needed below, not numerical cluster identifiers across meshes. +By \cref{prop:stopped-tvs} and the one-arm estimate, for every finite +family of addresses the validity indicators and the signs in +\(\{-1,0,1\}\) converge jointly to their canonical counterparts. +In particular all bounded products of these signs converge in +expectation. + +The use of \(X\) is necessary because an admissible polygon may +protrude outside \(D\). For each compact set disjoint from \(\partial D\), +uniform convergence of the boundary parametrizations preserves its +winding number for all sufficiently small mesh. Hence the polygonal +closures eventually lie in every fixed neighborhood of \(\overline D\), +and every Hausdorff limit of lattice supports lies in \(\overline D\). + +We will use one elementary property of pointed convergence. If a sealed +discrete hole has pointed limit \(V\), every point of \(\partial V\) +is approached by its sealing boundary. Otherwise a ball around such a +point would avoid the discrete boundaries along a subsequence. Since +it meets a compact subset of \(V\), that connected ball would then lie +in the discrete hole, enlarging its pointed limit across the boundary. +The sealing boundary lies within \(O(\delta)\) of its supplying current +cluster. Consequently any Hausdorff limit of those suppliers contains +\(\partial V\); if the supplier has been revealed at a stop, the limiting +explored set contains \(\partial V\) as well. + +\begin{lemma}[The restricted field determines its flat label] +\label{lem:recover-flat-label} +Let \(O\) be a random bounded simply connected domain with a marked +point \(q\in O\), and let \(f\) be a distribution on \(O\). +Suppose \(O,q,m\) are measurable in a sigma-field \(\mathcal E\) and, +conditionally on \(\mathcal E\), one has \(f=m+h^O\), where \(m\in\R\) +and \(h^O\) is a zero-boundary GFF. There is a measurable function of +\((O,q,f)\) alone that equals \(m\) almost surely. Thus two such conditional descriptions +of the same pointed domain and restricted field have the same label. +\end{lemma} + +\begin{proof} +Let \(\phi_O:\mathbb D\to O\) be normalized by +\(\phi_O(0)=q\) and \(\phi'_O(0)>0\). Rational polygonal inner +exhaustions, normal-family compactness, and uniqueness of the normalized +limit make \(\phi_O\) measurable in \((O,q)\). +Push uniform angular probability measure \(\dd\vartheta/(2\pi)\) on +\(|z|=r\) forward by \(\phi_O\). Conformal invariance of the Green +kernel gives covariance \(-\log\max(r,s)\) for the zero-boundary +averages at radii \(r,s\). The radius-\(r\) average of \(f\) thus has +mean \(m\) and variance \(-\log r\). + +For \(r_j=1-2^{-j}\), approximate the angular measure by a smooth +radial probability test \(\nu_j\) compactly supported in the disk, +with squared Green-energy error at most \(2^{-j}\). +Such choices are deterministic: the covariance +\(-\log\max(r,s)\) is continuous near each positive \(r_j\), so +radial smoothing converges in energy. Push \(\nu_j\) forward by +\(\phi_O\) to obtain a smooth compactly supported test \(\psi_j(O,q)\). +This test is measurable in the pointed domain, and evaluation +\(f(\psi_j(O,q))\) is measurable in \((O,q,f)\). Its conditional +mean is \(m\), and its conditional variance is at most +\[ + 2(-\log r_j)+2^{1-j}. +\] +The sum of these variances is finite. Chebyshev's inequality and +Borel--Cantelli therefore give \(f(\psi_j(O,q))\to m\) almost surely. +Define the function in the statement by this limit when it exists, +and by zero otherwise. The construction uses conformal maps only on +compact subsets of the disk, so no boundary extension of \(O\) is +needed. The conformal identities are recalled in +\cite[Chapter~6, Sections~1.1 and~5.2]{Ahlfors1979}. +\end{proof} + +\begin{proposition}[The visible partition] +\label{prop:partition} +Almost surely, \(i\sim_*j\) if and only if \(i\sim j\), simultaneously +for every pair of marked addresses in either current family. Their +relative signs also agree. Each retained canonical cluster \(C\) has +a marked address \(i\) such that every Hausdorff limit of +\(C_\delta(i)\) contains \(C\). For every finite family of distinct +canonical clusters, their chosen supplying lattice clusters are +eventually distinct. +\end{proposition} + +\begin{proof} +We first show \(i\sim j\Rightarrow i\sim_*j\). All odd holes of one +retained canonical cluster have the same odd depth \(r\) and the same +parent at depth \(r-1\): entering any odd hole increases the depth, and +later clusters lie inside it. Let \(V_1,V_2\) be two marked odd holes +of such a cluster \(C\), and suppose that their lattice suppliers are +distinct along the retained subsequence. +If \(V_1=V_2\), a compact path inside that hole already puts both +marks in the same discrete hole for all sufficiently small mesh. +We may therefore assume that \(V_1\) and \(V_2\) are distinct. + +Use the following fixed connected search. Starting from the exterior, +repeatedly add the lexicographically first unvisited current-lattice +vertex adjacent in the underlying graph to the explored region, and +reveal its entire current cluster. For the wired family start from the +completely exposed wired layer; the same rule interleaves its residual +chambers. The explored union remains connected to the original boundary. +For the two fixed marks count the surrounding odd rims already revealed, +and stop when either counter first reaches \(r\). This rule uses only the +revealed history; it never asks for the identity of a future hole. +If neither counter reaches \(r\), give the stop a cemetery value; +on the event under consideration it is eventually active. +Adjoin the retained stopped states for all these countably many fixed +rules to the joint subsequence. By \cref{prop:exploration-thin}, each +has the stated component laws conditional on its own limiting stopped +state. The future supplier relation is not included in that state. + +The two marks lie in one pointed parent at depth \(r-1\). A compact +path inside that parent joining them is eventually inside the same +discrete parent, by pointed convergence. This implication does not +assert the converse through a pinch. The exterior seed must cross +all of their shared enclosing odd rims before it can reach either +\(r\)th rim. Suppose the stop discovers the rim of \(V_1\) first. +The other mark has then seen exactly the common \(r-1\) odd jumps; +any intervening even holes contribute zero. Its stopped value is the +common parent label \(b\). + +The newly revealed supplier and its sealing boundary put +\(\partial V_1\) in the limiting explored set \(A\). Hence \(C\) +meets \(A\). If a connected cluster meeting \(A\) entered any component +of the complement, it would also meet that component's boundary. +\Cref{prop:no-crossing}, applied at the appropriate canonical +generation and after subtracting the parent label, forbids this. +Therefore \(C\subset A\), in particular \(\partial V_2\subset A\). + +The entire discrete interior of the second odd hole is still +unsearched. A seed vertex could enter it only after meeting its +enclosing supplier, which would have raised the second counter to +\(r\). A different current cluster inside that hole is trapped there +by the supplier and its sealing rim, so it could have been discovered +only from a seed vertex in the same interior. Thus the whole explored +set, not only the seed, misses the second discrete hole. Every compact +subset of \(V_2\), with a slightly larger compact neighborhood, +eventually lies in that untouched hole. It follows that \(A\) misses +\(V_2\). Since \(\partial V_2\subset A\), the domain \(V_2\) is +itself a stopped complementary component. + +Its stopped conditional law has flat label \(b\). The labelled odd +carpet gives the same \(V_2\) the label \(b+2a\epsilon(i)\), which +differs from \(b\). Both are conditional descriptions of the same +restricted field on the same pointed domain, so +\cref{lem:recover-flat-label} makes this impossible. The conditional +laws were used at the fixed observable stop, not after conditioning +on the hypothesis of distinct suppliers. This proves the inclusion +at every finite odd depth, including clusters reached after any +number of even restarts. + +\begin{figure}[t] +\centering +\begin{tikzpicture}[font=\small,>=Latex] + \draw[black!45] (0,0) rectangle (6,3.2); + \node[anchor=north west] at (.1,3.1) {limiting explored set \(A\) (gray)}; + \draw[gray!55,line width=5pt] (0,1.45)--(1.25,1.45); + \draw[gray!55,line width=5pt] (1.9,1.45) circle (.65); + \draw[gray!55,line width=5pt] (4.3,1.45) circle (.65); + \draw[gray!55,line width=5pt] (2.55,1.45)--(3.65,1.45); + \draw[teal!70!black,line width=1.3pt] (1.9,1.45) circle (.65); + \draw[teal!70!black,line width=1.3pt] (4.3,1.45) circle (.65); + \draw[teal!70!black,line width=1.3pt] (2.55,1.45)--(3.65,1.45); + \draw[->,thick] (.45,1.9)--(.85,1.5); + \node[anchor=west] at (.15,2.1) {seed}; + \node at (1.9,1.45) {\(V_1\)}; + \node at (1.9,.45) {observed rim}; + \node at (4.3,1.45) {\(V_2\)}; + \node at (4.3,.45) {untouched}; + \node[teal!70!black] at (3.1,2.35) {canonical \(C\subset A\)}; + \node[draw,rounded corners,align=center,text width=4.7cm] + (same) at (9.1,2.55) {same pointed pair \((V_2,h|_{V_2})\)}; + \node[draw,rounded corners,align=center,text width=2.05cm] + (stop) at (7.7,1.35) {stopped label\\\(b\)}; + \node[draw,rounded corners,align=center,text width=2.05cm] + (carpet) at (10.5,1.35) {odd-carpet label\\\(b+2a\epsilon(i)\)}; + \draw[->] (same.south west)--(stop.north); + \draw[->] (same.south east)--(carpet.north); + \node[align=center,text width=5cm] at (9.1,.25) + {circle averages recover one label}; +\end{tikzpicture} +\caption{The hypothetical distinct-supplier case at the fixed marked +stop. The first rim puts \(\partial V_1\) in \(A\); no crossing then +puts the whole canonical cluster \(C\), including \(\partial V_2\), +in \(A\), while the discrete interior of \(V_2\) remains untouched. +Its two proposed labels contradict \cref{lem:recover-flat-label}. +The strokes depict inclusion and connectedness, not area or distances.} +\label{fig:visible-partition} +\end{figure} + +To exclude extra identifications, use the relative signs. Conditional +on the unsigned lattice data \((N,s)\), the signs of different free +current clusters are independent and fair, and one cluster has the +same sign at all its odd holes. The validity of a marked address is +also unsigned. With our zero sign and false relation at \(\dagger\), +\cref{lem:finite-cuts} therefore gives, for every fixed pair of +addresses in the same current family, +\begin{equation} + \E[\epsilon_\delta(i)\epsilon_\delta(j)] + =\P(i\sim_\delta j). + \label{eq:partition-sign-discrete} +\end{equation} +The canonical fair-sign statement in \cref{lem:canonical-geometry} +gives the same identity with \(\epsilon\) and \(\sim\) for each fixed +pair in that same family. Joint +labelled-carpet convergence passes the bounded sign product to the +limit, while the retained relation bits pass the right side to +\(\P(i\sim_*j)\). Hence +\[ + \P(i\sim_*j)=\E[\epsilon(i)\epsilon(j)]=\P(i\sim j). +\] +The inclusion already proved makes +\(\ind_{\{i\sim_*j\}}-\ind_{\{i\sim j\}}\) nonnegative. Its +expectation is zero, so it vanishes almost surely. This argument +uses global fixed addresses and does not require equality of +discrete parent components to be continuous through a pinch. +The countable intersection over all pairs proves the asserted +partition equality; the relative signs are already the limits +of the marked labels. + +Finally choose, for each canonical cluster, one address \(i\) +supplying one of its odd holes. Every other marked odd hole of +that cluster has the same lattice supplier as \(i\) for all +sufficiently small mesh. The pointed-boundary observation above +therefore puts all its odd-hole boundaries in every Hausdorff +limit of \(C_\delta(i)\). Their union is dense in the canonical +cluster by \cref{lem:canonical-geometry}. This proves containment. +For finitely many distinct canonical clusters, the corresponding +relation bits are eventually false, so their suppliers are +eventually distinct. +\end{proof} + +Fix an enumeration of the marked addresses. For each canonical cluster, +choose its first supplying address in this enumeration and call the +associated sequence \(C_\delta(i)\) its \emph{visible precursor}. +This is auxiliary information retained for the proof; the matching +topology itself forgets multiplicity. + +\begin{corollary}[All-generation local finiteness] +\label{cor:canonical-local-finiteness} +Almost surely, the entire canonical free cluster family has only +finitely many members of diameter greater than any given +$\eps>0$. The same holds for the wired family, including all +descendants. These bounds are compatible with the uniform tight +macroscopic lattice counts. +\end{corollary} + +\begin{proof} +Consider any finite family of $M$ canonical clusters of diameter +greater than $\eps$. In each cluster choose two points more than +$\eps$ apart. Density of +odd rims gives two nearly as separated rim points, witnessed by +finitely many nearby odd holes and dense interior test points. +The individual holes need not have diameter comparable to +$\eps$. By \cref{prop:partition}, the two witnesses in each +cluster have one precursor, and the $M$ precursors are distinct. +For sufficiently small mesh each has diameter greater than +$\eps/2$. This finite choice involves only finitely many odd +depths and marks. + +Thus, on the joint representation, the event of at least $M$ +canonical clusters of diameter greater than $\eps$ implies at +least $M$ lattice clusters of diameter greater than $\eps/2$ +eventually. Finite choices from the countable canonical family +and the dense test list suffice; no measurable choice from an +uncountable family is needed. Fatou's lemma and +\cref{cor:global-cluster-counts} make the probability of this event +tend to zero as $M\to\infty$. Countably many rational $\eps$ +give the result. The same finite-witness argument can be performed +in the wired descendants, with the boundary cluster counted once. +This proof does not assume nested all-generation local finiteness +in advance. +\end{proof} + +\subsection{A flat region cannot contain a revealed crossing} + +We give the analytic observation that detects cluster pieces with +no visible jump. It concerns a distributional conditional mean, +not merely a harmonic function on the open complement. + +\begin{lemma}[Flat patches] +\label{lem:flat-patch} +Let $h$ be a zero-boundary GFF in a bounded simply connected domain +$O$. Suppose an exploration with information $\cF_A$ describes a +boundary-connected closed set $A$ and a $\cF_A$-measurable distribution $h_A$ such that, +conditionally on $\cF_A$, the residual $h^A=h-h_A$ is the GFF on +$O\setminus A$ extended by zero through $A$, as a distribution on $O$. +The complementary components are assumed simply connected. Extra +randomness may be included in the exploration. For every +deterministic ball $B\Subset O$, almost surely on the event that +$h_A$ is one constant distribution throughout $B$, one has +$A\cap B=\varnothing$. If the conditional decomposition is given +only for tests supported in a neighborhood of $B$ and on a +$\cF_A$-measurable event $\Lambda$, the conclusion holds on $\Lambda$. +\end{lemma} + +\begin{proof} +Fix a nonnegative smooth unit-mass mollifier $\rho$ supported in +the unit disk, and put $h_u=h*\rho_u$. For a nonnegative +$b\in C_c^\infty(B)$ set +\begin{equation} + X_u=u^{-1}\int b(x)\exp(i\beta h_u(x))\,\dd x, + \qquad \beta^2>2. + \label{eq:flat-oscillatory} +\end{equation} +On the compact support of $b$, the normalized Green kernel gives +\[ + \E\exp\bigl(i\beta(h_u(x)-h_u(y))\bigr) + \leq C\left(\frac{u}{|x-y|\vee u}\right)^{\beta^2}. +\] +Consequently +\begin{equation} + \E|X_u|^2 + \leq C u^{-2}\int_0^{O(1)} + \left(\frac{u}{r\vee u}\right)^{\beta^2}r\,\dd r + \leq C. + \label{eq:oscillatory-L2} +\end{equation} +For a smooth Gaussian exponential cylinder $Y=\exp(ih(\phi))$, +the Gaussian characteristic function and the bounds +$\Var(h_u(x))=\log(1/u)+O(1)$ and +$|\Cov(h_u(x),h(\phi))|\leq C_\phi$ imply +\[ + |\E[X_uY]|\leq C_\phi u^{\beta^2/2-1}\longrightarrow0. +\] +The linear span of these cylinders is dense in $L^2$ of the field. +Together with \eqref{eq:oscillatory-L2}, this proves +$X_u\rightharpoonup0$ weakly in $L^2$. It also proves weak +convergence on the full probability space with extra randomness: +replace any $L^2$ test variable by its conditional expectation +given $h$. + +We next bound the conditional \emph{mollified} variance near $A$. +Let $U$ be a simply connected component of $O\setminus A$ and +write $r=|f^{-1}(w)|$, where $f:\mathbb D\to U$ maps zero to $z$. +The conformal Green formula and the growth and quarter estimates +proved or cited in \cref{sec:conformal-growth} give +\[ + G_U(z,w)=-\log r, + \qquad |z-w|\leq\operatorname{cr}_U(z)\frac{r}{(1-r)^2}. +\] +For $r\geq1/2$ the Green function is at most $\log2$; for +$r<1/2$ the second inequality gives +\[ + G_U(z,w)\leq\log2+ + \log^+\frac{4\operatorname{cr}_U(z)}{|z-w|}. +\] +Koebe's quarter theorem gives +$\operatorname{cr}_U(z)\leq4\dist(z,\partial U)$. If +$\dist(x,A)\leq u$ and $z$ belongs to the mollifier at $x$, then +$\dist(z,\partial U)\leq2u$. Different components have zero +covariance, so the killed Green kernel satisfies on the mollifier +supports +\begin{equation} + G_{O\setminus A}(z,w) + \leq\log2+\log^+\frac{32u}{|z-w|}. + \label{eq:cut-green-bound} +\end{equation} +Rescaling $z=x+u\zeta$, $w=x+u\omega$ and integrating the +locally integrable logarithm against the two mollifiers yields +\begin{equation} + \Var(h_u^A(x)\mid\cF_A)\leq C_\rho + \quad\text{if }\dist(x,A)\leq u. + \label{eq:cut-mollified-variance} +\end{equation} +This is uniform in the exploration. It does not assert a finite +pointwise variance for the GFF itself. + +Choose $B_0\Subset B_1\Subset B$ and take $b=1$ on $B_1$. +Let $E$ be the event that $h_A=m$ throughout $B$ and +$A\cap\overline B_0\ne\varnothing$. This is an exploration- +measurable event: obtain $m$ by testing against one fixed smooth +unit-mass function, and check equality of distributions on a +countable dense test family. In the localized version replace $E$ +by $E\cap\Lambda$. On $E$, for small $u$, +\begin{equation} + e^{-i\beta m}\E[X_u\mid\cF_A] + =u^{-1}\int b(x) + \exp\left(-\frac{\beta^2}{2} + \Var(h_u^A(x)\mid\cF_A)\right)\,\dd x. + \label{eq:flat-positive-integrand} +\end{equation} +All integrands are nonnegative. Since $A$ is connected to +$\partial O$ and meets $B_0$, its $u$-neighborhood in $B_1$ has +area at least $cu$, with deterministic $c>0$. To verify this +without assuming path connectedness, use the distance from a +point in $A\cap\overline B_0$: its image on the connected set +$A\cup\partial O$ is an interval. Choose points at radial spacings +$3u$ up to a fixed positive radius small enough that they lie in $B_1$. +Since $B_1\Subset O$, these points cannot lie on $\partial O$ and +therefore belong to $A$. Their disks of radius $u/2$ are +disjoint, lie in $B_1$, and are within distance $u$ of $A$. +There are at least $c/u$ of them. + +Using \eqref{eq:cut-mollified-variance} in +\eqref{eq:flat-positive-integrand} therefore gives +\[ + \E[\ind_E e^{-i\beta m}X_u]\geq c'\P(E). +\] +The left side tends to zero by weak $L^2$ convergence, since +$\ind_Ee^{-i\beta m}$ is a fixed bounded random variable. +Thus $\P(E)=0$. A countable exhaustion of $B$ proves the lemma. +For a random initial component one first conditions on it and +subtracts its initial constant, then uses rational balls with +positive clearance. The conclusion is still a probability-zero +statement, so no bound uniform over all such domains is needed. +\end{proof} + +\subsection{Open hole witnesses and the discovered mean} + +A cluster with no limiting odd hole might still have many small discrete +holes. The next observation shows that those holes cannot retain positive +area away from the limiting cluster. + +\begin{lemma}[Open witnesses for hole contributions] +\label{lem:hole-witnesses} +Let \(O\) be open. Suppose compact sets \(C_n\subset X\) converge in +Hausdorff distance to \(C\), and \(C\cap O\) has zero area. Let +\(U_n\subset O\) be open, with actual relative topological boundary +contained in \(C_n^{\eta_n}\), where \(\eta_n\to0\). +If the indicators of \(U_n\) converge on a dense subset of +\(O\setminus C\) to those of a union \(U\) of components of +\(O\setminus C\), then +\[ + \ind_{U_n}\longrightarrow\ind_U\quad\text{in }L^1_{\rm loc}(O). +\] +In particular, if every nonempty pointed open witness is absent, +the area of \(U_n\) on each compact subset of \(O\) tends to zero. +\end{lemma} + +\begin{proof} +For \(x\notin C\), choose a small ball \(B_x\Subset O\setminus C\). +Its closure misses \(C_n^{\eta_n}\) for all large \(n\). Membership +in \(U_n\) is then constant throughout \(B_x\); otherwise the connected +ball would meet its actual relative boundary. A dense test point in +\(B_x\) determines this constant eventually. The indicator of \(U\) +is also constant there, since \(B_x\) lies in one component of +\(O\setminus C\). Thus the indicators converge at every point outside +\(C\). Dominated convergence and the zero area of \(C\) prove the claim. +\end{proof} + +We now specify the sweeps used for complete support identification. +They are performed for each current family; the family label is +suppressed in the sweep notation. +For \(e\in\{\pm e_1,\pm e_2\}\), visit current-lattice vertices in +increasing order of \(e\cdot v\), completing every earlier lattice +column before beginning the next one. Within a column use a fixed +lexicographic order. The virtual exterior of the free graph is the +initial connected attachment. In the wired case first reveal the +boundary cluster completely and use it, together with the exterior, +as the attachment for all residual free chambers. When a vertex is +visited, add the edge to its neighbor in the preceding column and +reveal its entire current cluster. That neighbor has already been +visited or belongs to the initial filled region; it is never an +unsearched vertex farther ahead. The seed edges need not be current +edges. Thus the initial region, the added seed, and all revealed +clusters stay connected to the original boundary, and the exact cuts +in \cref{lem:finite-cuts} apply throughout. + +We use two countable families of observable stops. A \emph{column stop} +ends after all vertices with \(e\cdot v\leq t\) have been visited, for +a rational \(t\). For rational \(b>0\), a \emph{recorded stop} ends just +after the \(k\)th newly discovered free cluster of diameter at least +\(b\), for a fixed \(k\geq1\). If that discovery never occurs, give +the stop a cemetery value. The rank \(k\) counts only these recorded +discoveries; arbitrarily many smaller clusters may precede them and +remain part of the explored set. + +Write \(W_{0,\delta}\) for the initial revealed region: the boundary +perimeter in the free case and the wired current support in the wired +case. Its limit is respectively \(W_0=\partial D\) or +\(W_0=C_\partial\). Write \(S_\delta\) for the added moving seed and +\(A_{\delta,\tau}\) for the full explored set at a fixed stop \(\tau\). +For the wired family this is one composite exploration of the original +field, across all initial chambers. It does not choose a new lattice +exploration from a limiting hole that might have separated from a +shared discrete precursor. + +Fix rational compact rectangles +\(Q\subset\operatorname{int}Q^+\Subset D\) and a rational \(r>0\). +On the event +\[ + \dist(Q^+,W_{0,\delta}\cup S_\delta)\geq r, +\] +call a discovered free cluster a \emph{contributor to \(Q^+\)} if +its support meets \(Q^+\) or its union \(\mathcal O_\delta(C)\) of +odd component faces meets \(Q^+\). List these clusters in their +relative discovery order, as +\(C_{\delta,1},\ldots,C_{\delta,L_\delta}\). +A listed cluster contains a seed contact. If its support meets \(Q^+\), +it has diameter at least \(r-O(\delta)\). If an odd hole meets \(Q^+\), +choose a point of that hole there. The cluster surrounds that point +and contains a seed contact at distance at least \(r\). +A point in a bounded complementary component lies in the convex hull +of the surrounding compact set, so the latter's diameter is at least +that distance, again up to the lattice boundary convention. +Therefore, for all sufficiently fine meshes, +\begin{equation} + L_\delta\leq N_{\delta,0}(r/3), + \label{eq:contributor-domination} +\end{equation} +where \(N_{\delta,0}(b)=\mathcal N_{\delta,\mathrm{initial}}(b)\) +counts all free clusters of diameter at least \(b\) in the initial +chamber family, as in \cref{eq:spatial-contributor-domination}. +\Cref{cor:global-cluster-counts} gives a uniform tail for this right +side conditional on the initial cut data. This is a pathwise bound +valid at every observable stop; it is not a tail bound after fixing +the completed history at that stop. + +For these countably many fixed stops, retain the stopped states of +\cref{prop:exploration-thin}. For each fixed choice of sweep, stop, +\(Q,Q^+\), and \(r\), retain also the active clearance flag and, +when active, the integer \(L_\delta\), +the ordered supports, their relative signs, and the membership bits +of their odd-hole unions at all dense marks. Give the list a +cemetery value when inactive. The integer is tight by +\cref{eq:contributor-domination}, and a fixed-length list has compact +support coordinates in \(\mathscr H\). A further diagonal extraction +therefore makes \(L_\delta\) eventually equal to a finite \(L\) on +the joint representation, with limits \(C_{*,1},\ldots,C_{*,L}\). +The order is reindexed by \(1,\ldots,L_\delta\); raw discovery indices +are not asserted to be tight. Retain also, on the global representation, +the equality bits between each list entry and each marked supplier. +A missing list entry or invalid address has equality bit zero. +A list entry is \emph{visible} if it eventually equals a supplier at +some fixed valid marked address, and \emph{invisible} otherwise. +By \cref{prop:partition}, a visible entry has one associated canonical +cluster, denoted \(C_j^{\rm can}\). + +We retain one further kind of auxiliary list on the global +representation. For each fixed \((e,b)\), let \(D_\delta(e,b)\) be +the number of recorded discoveries during the complete sweep, and +write their ordered supports as +\(\widehat C_{\delta,1}^{e,b},\ldots, +\widehat C_{\delta,D_\delta(e,b)}^{e,b}\). +The bound \(D_\delta(e,b)\leq N_{\delta,0}(b)\) makes the integer +length tight. A further diagonal extraction makes it eventually +equal to a finite \(D(e,b)\), and makes each recorded support converge +in \(\mathscr H\); missing ranks have the cemetery value. Retain also +the equality bits between every record and every marked supplier, +set to zero for a missing rank or invalid address. +They are eventually constant on the joint representation. +Call a stabilized record visible if one such bit is eventually one +for a fixed valid address, and invisible otherwise. These lists keep +their order and multiplicity even if several supports have the same +limit. Their lengths are auxiliary coordinates and are not identified +with counts obtained by cutting off the limiting encoded family at +diameter \(b\). + +Only coordinates measurable at the fixed stop generate its limiting +sigma-field \(\mathscr E_\tau\): the explored set, seed, observed labels, +and discovered list data. The global representation also carries +future marked suppliers, complete recorded lists, and the canonical +field. They are not added to \(\mathscr E_\tau\) when applying the +stopped conditional laws. In later uses \(r\) is chosen below a +positive limiting clearance, so the discrete clearance flag is +eventually active. + +\begin{proposition}[The discovered mean] +\label{prop:discovered-mean} +Let \(\tau\) be one of the fixed stopped sweeps above, with limiting +explored set \(A_\tau\), and write +\(M_\tau=\E[h\mid\mathscr E_\tau]\) as a distribution on tests. +On each connected compact localization \(Q\subset\operatorname{int}Q^+\) +above at positive distance from \(W_0\) and the moving seed, +\(M_\tau\) is the finite signed sum +\begin{equation} + M_\tau=b_0+2a\sum_{\substack{j\text{ visible}\\ + \text{in the localized list}}} + \epsilon_j\ind_{\mathcal O(C_j^{\rm can})}. + \label{eq:canonical-discovered-mean} +\end{equation} +Here \(b_0=0\) for the original free family. For the wired composite +exploration, \(b_0\in\{-a,a\}\) is the label of the initial pointed +wired hole containing the region. The sum is finite on each such +localization because its contributor list is finite. An invisible +entry has zero contribution. Consequently \(M_\tau\) is a constant +distribution on every ball missing \(W_0\), the moving seed, and the +canonical supports associated with its local contributors. +\end{proposition} + +\begin{proof} +Work first with \(Q\subset\operatorname{int}Q^+\) and a positive +clearance as above, on an outcome where the list length has stabilized. +Every \(C_{*,j}\) is contained in \(A_\tau\). By +\cref{prop:exploration-thin}, it has zero area in +\(\operatorname{int}Q^+\), and the actual relative boundary of +\(\mathcal O_\delta(C_{\delta,j})\) lies within \(O(\delta)\) of +\(C_{\delta,j}\). + +We identify membership at a dense mark \(q\in\mathcal Q\cap +(\operatorname{int}Q^+\setminus C_{*,j})\). If \(q\) belongs to the +odd-hole union along infinitely many meshes, its positive distance +from \(C_{*,j}\) gives a fixed disk about \(q\) inside that union +on those meshes. The relevant odd depth is bounded by \(L\). +Indeed every enclosing odd ancestor is a distinct cluster: after +entering its odd hole, later clusters lie strictly inside that hole. +The exterior-connected seed must discover each such ancestor before +\(C_{\delta,j}\), and its odd-hole union contains \(q\). It is +therefore another entry of the same list for \(Q^+\). +After passing to a further subsequence, the depth is one fixed +\(r\leq L\), and the representative of \(q\) lies in the fixed disk. +Thus \(C_{\delta,j}\) supplies the marked address +\((\iota,q,r)\). The stabilized equality bit makes the entry visible, +and \cref{prop:partition} identifies its canonical cluster and odd +hole. + +Conversely, suppose the entry is visible and \(q\notin C_{*,j}\) +lies in an odd hole of \(C_j^{\rm can}\). That hole has the marked +address \((\iota,q,r)\) at a finite depth. The partition equality +makes its supplier equal to the list entry for all sufficiently +small mesh, so \(q\) eventually belongs to +\(\mathcal O_\delta(C_{\delta,j})\). These two implications show +that the membership indicators converge at every dense mark off +\(C_{*,j}\). In the visible case their limit is +\[ + \ind_{\mathcal O(C_j^{\rm can})\setminus C_{*,j}}, +\] +and in the invisible case it is zero. This also rules out +oscillation between membership and nonmembership: any infinite +membership subsequence supplies a fixed visible address, after +which the converse gives eventual membership. + +The displayed visible set is a union of components of +\(\operatorname{int}Q^+\setminus C_{*,j}\). In fact +\cref{prop:partition} gives \(C_j^{\rm can}\subset C_{*,j}\), and +the boundary of every canonical odd hole is contained in +\(C_j^{\rm can}\); a component of the smaller complement cannot +cross such a boundary. Removing \(C_{*,j}\) changes no area on this +region. We may therefore apply \cref{lem:hole-witnesses} to each +list entry. Its odd-hole indicators converge in \(L^1(Q)\) to the +canonical odd-hole indicator, or to zero for an invisible entry. +Thus even a collection of long or numerous collapsing holes has +vanishing area unless it supplies an open marked witness. + +The signs have stabilized and the list is finite, so the discrete +signed sum in \cref{eq:discrete-discovered-mean} converges in +\(L^1(Q)\) to the sum in the statement. For a visible entry its sign +is the canonical sign because it eventually supplies a fixed marked +address. In the wired case the connected +rectangle \(Q^+\), being disjoint from \(W_0\), lies in one pointed +initial wired hole. Compact containment puts it in one discrete +initial hole for fine mesh, even if that hole pinches elsewhere. +Its initial label is therefore one constant \(b_0\in\{-a,a\}\) +on \(Q^+\). This supplies the additional baseline term. +Remove a deterministic truncation \(L\leq M\) using +\cref{eq:contributor-domination} and the initial count tail. +The uniform higher logarithmic moments in \cref{prop:log-moments} +give uniform integrability when passing tested conditional means. + +Finally, \cref{prop:exploration-thin} identifies the full conditional +mean on these tests, including across \(A_\tau\), by its neighborhood +removal argument. Hence the ordinary function just obtained is +\(M_\tau\), with no extra distribution on the explored set. +On a connected ball avoiding \(C_j^{\rm can}\), its odd-hole indicator +is constant. The baseline is also constant on a ball avoiding \(W_0\). +The localized list contains only finitely many entries, regardless +of the diameters of their associated canonical clusters. This proves +the last assertion. +\end{proof} + +\subsection{Complete matching, including invisible clusters} + +\begin{proposition}[Matching of all positive-diameter clusters] +\label{prop:complete-matching} +Every positive-diameter Hausdorff limit of lattice free-current clusters +is one retained canonical cluster, and every retained canonical cluster +is the limit of its visible precursor. No distinct invisible precursor +has a positive-diameter limit. The same assertions hold for the free +primal descendants after the wired layer, jointly with that layer and +the height. Consequently +\[ + F_*^{\mathrm f}=F(\cC^{\rm f}),\qquad + F_*^{\mathrm w}=F(\cC^{\rm w}), +\] +and both collections converge in the matching topology of +\cref{thm:main}. +\end{proposition} + +\begin{proof} +\emph{Every point is on a canonical support or the initial wall.} +Let \(C_\delta\) be lattice free clusters with a positive-diameter +Hausdorff limit \(C_*\). The limit is compact and connected. +Take \(x\in C_*\setminus W_0\) and a distinct point \(y\in C_*\). +Choose an axial direction \(e\) and a rational \(t\) with +\(e\cdot y0\}\), the +stopped-measurable clearance event for this localization. In the +present initial domains it is the event in +\cref{eq:stopped-full-characteristic}. That identity gives, for every +real smooth test \(\varphi\) supported in \(Q^+\), +\begin{equation} + \ind_{\Lambda_{Q^+}} + \E\!\left[e^{i(h-M_\tau)(\varphi)}\mid\mathscr E_\tau\right] + =\ind_{\Lambda_{Q^+}}\exp\!\left\{-\tfrac12 + G_{D\setminus A_\tau}(\varphi,\varphi)\right\}. + \label{eq:full-residual-use} +\end{equation} +It holds for all linear combinations of finitely many tests, with the +killed GFF extended by zero across \(A_\tau\). It therefore supplies +the local residual law required by \cref{lem:flat-patch}, including +the mollifiers whose supports cross the explored set. Since \(A_\tau\) is +boundary-connected and the complementary components are simply connected, that lemma +says \(A_\tau\cap B=\varnothing\). But \(C_\delta\) was revealed at +this stop, so \(C_*\subset A_\tau\), a contradiction. + +The choice of \(B\) may depend on the later canonical data. Its +existence implies one of the countably many +\(\mathscr E_\tau\)-measurable zero events that \(M_\tau\) is constant +on a fixed rational ball and \(A_\tau\) meets it. The conditional law +used in each of these events is the one at the fixed stopped state. +All directions, column thresholds, balls, and localizations come from +countable families, and each localized list has finitely many entries. +The preceding conclusion therefore holds simultaneously for every +possible subsequential \(C_*\) and every \(x\in C_*\setminus W_0\). +We have proved +\begin{equation} + C_*\subset W_0\ \cup\!\bigcup_{C\in\cC_{\rm can}}C, + \label{eq:countable-cover} +\end{equation} +where \(\cC_{\rm can}\) is the complete canonical free family under +consideration. For wired descendants the argument used the single +composite exploration of the original \(h\). A ball away from \(W_0\) +lies in one pointed wired hole and has a constant initial label, even +when its discrete initial chamber pinches into several limiting holes. + +The sets in the cover are compact and pairwise disjoint, including +\(W_0\): this follows from \cref{lem:canonical-geometry} and the fact +that each retained cluster lies strictly inside its parent. They form +a countable family. Their intersections with \(C_*\) are therefore +a disjoint closed cover of the compact connected set \(C_*\). +Sierpi\'nski's continuum partition theorem \cite{Sierpinski1918}, +with a complete proof in \cite[Chapter~V, Theorem~5.10]{Freiwald2014}, +says that at most one member of such a cover is nonempty. +Consequently \(C_*\) is contained in one canonical cluster or entirely +in \(W_0\). + +We exclude the latter case using the actual chamber wall. +Let \(\Gamma_\delta\) be the component-side open \(W\) perimeter of +the initial chamber containing \(C_\delta\), with the medial resolution +at pinches. In the wired case \(W_{0,\delta}\) is a current support, +whereas the spatial estimate uses the attached matching wall. +\Cref{lem:chamber-rim-distance} gives +\[ + \sup_{z\in C_\delta}\dist(z,\Gamma_\delta) + \leq \sup_{z\in C_\delta}\dist(z,W_{0,\delta})+O(\delta). +\] +Its first-exit proof uses the resolved chamber face: a segment from +an adjacent chamber point toward the revealed support first meets +this chamber's own medial rim, including at a pinch. The free case +uses the polygonal boundary. +If \(C_*\subset W_0\), Hausdorff convergence of \(C_\delta\) and +\(W_{0,\delta}\) makes the right side tend to zero. + +Choose one fixed buffered square \(Q_{\rm all}\) containing \(X\) +inside a larger regular ambient box, +and use the event \(\Xi_\delta(\tau_0;b,\eta)\) of +\cref{cor:indexed-no-shadowing} in this square, at the initial stop +\(\tau_0\). Its connected cell region contains the initial revealed +support up to \(O(\delta)\). If the limit above has diameter greater +than \(2b\), then for every fixed \(\eta>0\), at all sufficiently fine +meshes \(C_\delta\) has a connected passage of diameter at least \(b\) +in \(Q_{\rm all}\) inside that \(\eta\)-collar. It is still unsearched +at \(\tau_0\). Thus the existence of such a limit forces membership in +\(\liminf_n\Xi_{\delta_n}(\tau_0;b,\eta)\) for every fixed \(\eta\). +For any deterministic \(\eta_m\downarrow0\), Fatou's inequality and +the bound in \cref{eq:spatial-frozen-shadow}, integrated over the +initial cut data, give +\[ + \P\!\left[\bigcap_m\liminf_n + \Xi_{\delta_n}(\tau_0;b,\eta_m)\right] + \leq \inf_m\limsup_{\delta\downarrow0} + \omega_{Q_{\rm all},b}(\eta_m,\delta)=0. +\] +The collar width is fixed before each mesh limit; its possible +dependence on the future Hausdorff limit is used only for the +eventual inclusion. Countably many rational \(b>0\) exclude every +positive-diameter limit contained in \(W_0\). We conclude that +\(C_*\) is contained in one canonical cluster. + +\emph{Visible precursors.} +For the visible precursor of a canonical cluster \(C\), +\cref{prop:partition} puts \(C\) in every Hausdorff limit. +The preceding containment puts that limit in a single canonical +cluster. Pairwise disjointness forces it to be \(C\) itself. +Compactness of \(\mathscr H\) then shows that the entire visible +precursor sequence converges to \(C\). In particular every canonical +cluster is obtained. + +\emph{Invisible precursors.} +Return to any lattice sequence with positive-diameter limit +\(C_*\subset C\). Choose an axial direction \(e\) in which +\[ + w=\max_{z\in C_*}e\cdot z-\min_{z\in C_*}e\cdot z>0, +\] +and fix a rational \(b\in(0,w/4)\). This sequence is eventually among +the \((e,b)\) records. Their length has stabilized to a finite number, +so one fixed rank \(k\) supplies it along infinitely many meshes. +The full sequence \(\widehat C_{\delta,k}^{e,b}\) already has a +Hausdorff limit, which must equal \(C_*\) on that subsequence. Replace +the possibly alternating original sequence by this fixed recorded +sequence. This replacement classifies its support limit; it makes no +assertion that visibility transfers from the original choices. + +If this record is visible, \cref{prop:partition} puts its associated +canonical cluster inside \(C_*\subset C\). Pairwise disjointness makes +that cluster \(C\), and the stabilized supplier bits identify the +record with the visible precursor of \(C\) for all fine meshes. +It was already treated. Suppose therefore that the record is invisible. +Write \(C_\delta^{\rm vis}\) for the visible precursor of \(C\). +It too is eventually a record because it converges to \(C\) and +\(\diam C\ge w>4b\). Among the finitely many stabilized ranks, exactly +one has its supplier bit equal to one for the fixed chosen address of +\(C\). Thus \(C_\delta^{\rm vis}\) +has one fixed rank \(j\), and \(j\ne k\). The two ranks give one +eventual discovery order. These complete-list coordinates remain +outside the conditioning sigma-field of every fixed recorded stop. +Smaller discoveries remain in each explored set; their local +contributions are controlled by \cref{eq:contributor-domination}. + +Suppose first that the visible precursor is discovered earlier, at +the fixed recorded stop \(\tau\). Its limit is \(C\). +For each fixed \(\eta>0\), the convergences +\(\widehat C_{\delta,k}^{e,b}\to C_*\subset C\) and +\(C_\delta^{\rm vis}\to C\) +imply that eventually the later cluster lies inside the +\(\eta\)-neighborhood of the frozen cell region at \(\tau\), using +the \(O(\delta)\) displacement from \(A_{\delta,\tau}\). It is still unsearched +at \(\tau\) and has a passage of diameter at least \(b\) inside +\(Q_{\rm all}\). Let +\[ + \mathcal X_\delta(b,\eta)= + \{\exists\,0\le i\le D_\delta(e,b): + \Xi_\delta(\tau_i;b,\eta)\} +\] +for the fixed \((e,b)\) sweep in that square. The event under +consideration is contained in \(\liminf_n\mathcal X_{\delta_n}(b,\eta)\) +for every fixed \(\eta\). For every integer \(K\), +\cref{eq:spatial-indexed-shadow} and Fatou's inequality yield +\[ + \P\!\left[\bigcap_m\liminf_n + \mathcal X_{\delta_n}(b,\eta_m)\right] + \le Ce^{-cK}+(K+1)\inf_m\limsup_{\delta\downarrow0} + \omega_{Q_{\rm all},b}(\eta_m,\delta) + =Ce^{-cK}. +\] +Letting \(K\to\infty\) gives probability zero. The spatial bound is +applied to the existential future passage under its allowed history +\(\mathcal H_\tau\), for finitely many fixed indices before the count tail is +removed. Later visibility and limiting containment only give the +eventual inclusion in the fixed-\(\eta\) events; they are not added +to that conditioning. + +Suppose instead that the invisible cluster is discovered first, and +stop immediately after that recorded discovery. Let \(t_\delta\) be +the projection of its discovery column. Every earlier column has +already been visited, so the first occupied column of this cluster +satisfies +\[ + \left|t_\delta- + \min_{z\in\widehat C_{\delta,k}^{e,b}}e\cdot z\right|=O(\delta). +\] +Hausdorff convergence preserves the minimum and maximum of the +projection. Choose a point \(x\in C_*\) whose projection is more +than \(w/2\) above the minimum. A rational ball about \(x\) lies +a fixed positive distance ahead of the moving seed for all fine +meshes. It also has positive clearance from \(W_0\), since +\(C_*\subset C\) and \(C\) is compactly inside its initial parent. +The stopped explored set meets that ball. + +Use its localized contributor list at this fixed recorded stop. +The newly discovered record meets the ball, so it is the last entry +of that list and has the fixed index \(L\) after the length stabilizes. +That entry is invisible: a stabilized marked supplier bit equal to +one would also make the record visible. It has zero mean contribution +by \cref{prop:discovered-mean}. Every earlier relevant contributor, +whether its support meets the ball or its odd hole surrounds a point +there, is included in the same finite list. Its associated canonical +support cannot be \(C\): by \cref{prop:partition} that would make +it the already chosen visible precursor of \(C\), contrary to the +discovery order. The earlier visible supports are therefore a finite +family of compact sets disjoint from \(C\). Shrink to a rational ball +around \(x\) missing this union. Its baseline and all remaining +odd-hole indicators are constant, so \(M_\tau\) is constant there. +The full residual law \cref{eq:full-residual-use} applies at this +stop, and \cref{lem:flat-patch} contradicts the hit of the explored +set. As before, the later choice of a rational ball only implies +a stopped-data zero event and adds no conditioning. +This excludes the second order and hence every distinct invisible +record with a positive-diameter limit. Since every positive limit +of an arbitrary lattice sequence was also the limit of a recurrent +fixed record, the classification is exhaustive. There is only one +visible rank for a given canonical cluster. A sequence distinct from +that precursor along infinitely many meshes has a recurrent rank +\(k\ne j\) on those meshes, by finiteness of the record list. If that +rank were visible, its limiting support inside \(C\) would make it +the same chosen supplier and hence rank \(j\) eventually. Thus it is +an invisible recurrent rank, which has just been excluded. + +\emph{The collection topology.} +For clarity, outer Hausdorff convergence has the following direct +link with the individual limits just classified. If \(C\in F_*^\iota\) +has positive diameter, then +\(\dist_{\mathscr H}(C,Z)>0\). A nearest member of +\(F(\cC_\delta^\iota)\) approaching \(C\) therefore cannot be a +singleton for fine mesh; it is an actual lattice cluster. +Conversely, every positive-diameter Hausdorff limit of lattice +members belongs to \(F_*^\iota\), because these encoded families +converge and \(F_*^\iota\) is closed. The fixed sweeps and their +finite localized lists made the preceding classification simultaneous, +so it applies to these members even when they are selected from the +outer limit. + +It follows that the positive members of \(F_*^{\mathrm f}\) are +exactly \(\cC^{\rm f}\). For \(F_*^{\mathrm w}\), a selected lattice +member has a subsequence of one recurrent type: either the distinguished boundary cluster, whose limit is +\(W_0=C_\partial\), or a free descendant, which has just been classified. +The visible precursors give the reverse inclusion in both cases. +Thus the two encoded limits equal those in the statement. +\Cref{lem:matching-topology} converts this outer Hausdorff convergence +to the stated matching topology. The exclusion of duplicate invisible +precursors is a stronger conclusion retained in the auxiliary lists; +the set-valued metric itself forgets multiplicity. +\end{proof} + +\subsection{Completion of the joint limit} + +\begin{proof}[Proof of \cref{thm:main}] +By \cref{thm:flat-gff}, $K_\delta$ converges to $h/a$ in every +local Sobolev space $H^s_{\rm loc}$, $s<-1$. The arguments above +can be performed on any simultaneous subsequence of the field, +the wired current, and the free dual current. By +\cref{prop:stopped-tvs}, the distinguished wired boundary +cluster converges in ordinary Hausdorff distance to +$\TVS{a}{a}(h)$. Its remaining pointed domains have the +conditional zero-boundary GFF remainders of that same field. + +Apply \cref{prop:complete-matching} to the free dual family in +the original domain and to the free primal descendants in the +composite wired exploration. The positive outer $\CLE_4$ label is $2\lambda$, +and its retained split has absolute values $0,2a$; the negative +one is its reflection. The identified recursion is therefore +exactly \cref{def:free-procedure}, with its sign-sensitive +choice of split, and with every generation retained. Both +families have been identified as canonical functions of the +same limiting $h$. + +For completeness, these are measurable collection-valued functions. +Enumerate the recursive clusters by generation and by the first mark +of \(\mathcal Q\) in each generating hole, using a cemetery value for +missing entries. The cluster coordinates in this countable enumeration +are measurable by \cref{lem:canonical-geometry}. +Append \(C_\partial\) as one additional slot for the wired family. +\Cref{cor:canonical-local-finiteness} makes their singleton-augmented +families closed. For every open set \(\mathcal V\subset\mathscr H\), +the event that \(F(\cC^\iota)\) meets \(\mathcal V\) is the union of +the corresponding countably many cluster hit events, together with +the deterministic alternative \(Z\cap\mathcal V\ne\varnothing\). +These hyperspace hit events prove measurability of both encoded factors. +The boundary marker \(\TVS{a}{a}(h)\) is measurable in the same field. + +The height and collection tightness give simultaneous joint +subsequences, and every one has the pushforward of the GFF law by +this single measurable construction. +Hence the full mesh limit exists in the product topology, +including the distinguished boundary set. Finally +$H_\delta=K_\delta/2$ and $2a=\pi\sqrt g$, giving precisely +$h/(\pi\sqrt g)$. The parameter inequalities used throughout +include $a=2\lambda$, so the Potts endpoint is part of the +conclusion. +\end{proof} diff --git a/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/10-input-conventions.tex b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/10-input-conventions.tex new file mode 100644 index 0000000000000000000000000000000000000000..fb743df6331eaec03971c4f7d005e92406a367f0 --- /dev/null +++ b/preprints/The-joint-scaling-limit-of-critical-Ashkin-Teller-currents-October-6-2026/build/sections/10-input-conventions.tex @@ -0,0 +1,172 @@ +\section{Conventions and elementary corrections in the inputs} +\label{sec:input-conventions} + +The proof uses the versioned statements of \cite{DKLM2026} specified +in the text. We record elementary corrections needed when reading their +proofs literally, and give the conformal estimate used in +\cref{lem:flat-patch}. These are our reconciliations of the indicated +formulas, not an author-issued erratum. They do not replace the +substantive regularity, convergence, or free-energy theorems. + +\subsection{The path decomposition in the increment estimate} +\label{sec:input-path} + +In \cite[Lemma~21.3]{DKLM2026}, the printed path-length factor $S'$ +must be $\max\{1,-S'\}$, as used in its subsequent Equation~(367). +Indeed $S'$ may be negative, whereas a nonconstant path has positive +length. Here is a direct construction of the required path. + +Order the increments so that $|a-a'|\le|b-b'|$. If $a=a'$, use +the empty path. Otherwise put $R=|a-a'|>0$, $B=\{b,b'\}$, +$d=\dist(\{a,a'\},B)$, and +$D=\max\{1,d\}$. Fix an order $k$ and write +$A=\exp(20k^2)$ and $M=1600A$. We construct a path from $a$ to $a'$ +with at most +\begin{equation} + 20000A\max\{1,\log(R/D)\} + \label{eq:input-path-bound} +\end{equation} +steps. Every step is either a nearest-neighbor step or an increment +whose endpoint-set distance from $B$, divided by its length, is +at least $A$. This is the alternative needed for the source's +increment decomposition. + +In the disk of radius $R$ centered at $(a+a')/2$, choose $z$ outside +the at most four cones of half-angle $0.1$ starting at $x\in\{a,a'\}$ and +pointing toward $y\in B\setminus\{x\}$. The total area of those cones within the +disk is at most $4(0.1)(3R/2)^2=0.9R^2$, so such a point exists. +The segment from $x$ to $z$ has length $L\le3R/2$. At arclength $s$ +along it, elementary triangle geometry gives distance at least +$(d_x+s)/100$ from $B$, where $d_x=\dist(x,B)$: the excluded angle +bounds the distance to each $y\ne x$ by a fixed fraction of $|x-y|+s$. +If $y=x$, the distance is exactly $s$, so the same bound holds. +Round all segment points by one fixed nearest-lattice rule, with error +at most one, using the same rounded endpoint $z$ on both segments. + +If $d_x0\) such that +for every fixed \(\kappa>0\), +\[ + \frac1{2Y}\sum_{\substack{v\in\Z\\0<|v|\le Y}} + \exp\!\bigl(\kappa\,\operatorname{rank}_{\Z}E^{(v)}(\Q)\bigr) + \le \exp\!\bigl(\exp(C_E\kappa)\bigr) +\] +for all sufficiently large \(Y\), with the threshold allowed to depend +on \(\kappa\). Their integer box already includes both signs, and +\(P(v)\ne0\) excludes exactly \(v=0\). Restricting this nonnegative +sum to \(\mathcal D(Y)\), and using +\(N(Y)\sim2Y/\zeta(2)\), gives for each fixed \(\kappa>0\) +\begin{equation}\label{eq:algebraic-exp-bound} + \limsup_{Y\to\infty}\frac1{N(Y)} + \sum_{d\in\mathcal D(Y)}e^{\kappa r_d} + \le \zeta(2)\exp\!\bigl(\exp(C_E\kappa)\bigr)<\infty. +\end{equation} + +For fixed \(t>0\), Cauchy--Schwarz and +\eqref{eq:algebraic-exp-bound} at \(\kappa=2t\) give +\[ + \frac1{N(Y)}\sum_{d\in\mathcal B(Y)}e^{t r_d} + \le + \left(\frac{\#\mathcal B(Y)}{N(Y)}\right)^{1/2} + \left(\frac1{N(Y)} + \sum_{d\in\mathcal D(Y)}e^{2t r_d}\right)^{1/2} + \longrightarrow0. +\] +For fixed \(t<0\), the same exceptional average is at most +\(\#\mathcal B(Y)/N(Y)\), since \(r_d\ge0\); for \(t=0\) the full +average is identically one. The contributions from ranks zero and one +are \(N_0^{\mathrm{alg}}(Y)/N(Y)\) and +\(e^tN_1^{\mathrm{alg}}(Y)/N(Y)\), proving the exponential limit. + +Finally, for each fixed positive integer \(m\), one has +\(x^{2m}\ll_m e^x\) for \(x\ge0\). A second Cauchy--Schwarz application +and \eqref{eq:algebraic-exp-bound} at \(\kappa=1\) therefore give +\[ + \frac1{N(Y)}\sum_{d\in\mathcal B(Y)}r_d^m + \le + \left(\frac{\#\mathcal B(Y)}{N(Y)}\right)^{1/2} + \left(\frac1{N(Y)}\sum_{d\in\mathcal D(Y)}r_d^{2m}\right)^{1/2} + \longrightarrow0. +\] +The rank-zero contribution is zero and the rank-one contribution is +\(N_1^{\mathrm{alg}}(Y)/N(Y)\), proving the power-moment limit without +differentiating a limiting exponential-moment formula. +\end{proof} diff --git a/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/analytic.tex b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/analytic.tex new file mode 100644 index 0000000000000000000000000000000000000000..b3f5eaa112baa7adbe66cc59875596fb5d518a8c --- /dev/null +++ b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/analytic.tex @@ -0,0 +1,967 @@ +\section{Poisson summation and logarithmic second moments} +\label{analytic:section} +\label{sec:analytic} + +We retain the finite family $\mathcal F$, the fixed set $S$, and the +unitary normalization from Lemmas~\ref{setup:reduction} and +\ref{setup:local-factors}. In particular, $|\lambda_F(n)|\leq\tau(n)$, +all local parameters have modulus at most one, and reduction of a +squarefree twisting parameter to an admissible one does not increase its +absolute value. All constants in this section are uniform in +$F\in\mathcal F$. + +Our first aim is to bound the second moments of the twist functions and +their localized Dirichlet polynomials with only logarithmic losses. +For a compactly supported smooth function $G$ on $(0,\infty)$, write +\[ + P_d(N,t;G)=\sum_{n\geq1} + \lambda_F(n)\chi_d(n)n^{-1/2-it}G(n/N). +\] +All dyadic parameters below belong to $\{1,2,4,\ldots\}$. + +\begin{proposition}[Logarithmic second moments]\label{analytic:moment} +There are fixed positive integers $A,B$ such that, for every dyadic +$M\geq1$, every $F\in\mathcal F$, every $t\in\mathbb R$, and +$1/2\leq\sigma\leq2$, +\begin{equation}\label{analytic:L-moment} + \frac1M\sum_{\substack{d\ \mathrm{admissible}\\M\leq|d|<2M}} + |L_{F^{(d)}}(\sigma+it)|^2 + \ll_{\mathcal F}\log^B(3M)(1+|t|)^A. +\end{equation} +For arbitrary signed squarefree twisting parameters and $H\geq1$, +\begin{equation}\label{analytic:prefix-moment} + \sum_{\substack{0<|h|\leq H\\h\ \mathrm{squarefree}}} + |L_{F^{(h)}}(\sigma+it)|^2 + \ll_{\mathcal F}H\log^B(3H)(1+|t|)^A. +\end{equation} +\end{proposition} + +\begin{proposition}[Dirichlet-polynomial second moments] +\label{analytic:polynomial-moment} +With the same fixed integers $A,B$, every fixed smooth $G$ of compact +support in $(0,\infty)$ satisfies +\begin{equation}\label{analytic:polynomial-bound} + \frac1M\sum_{\substack{d\ \mathrm{admissible}\\M\leq|d|<2M}} + |P_d(N,t;G)|^2 + \ll_{\mathcal F,G} + \log^B(3M)(1+|t|)^A(1+N/M)^A + \qquad(N>0). +\end{equation} +The bound is uniform for fixed uniformly smooth families of weights +with common compact support. +\end{proposition} + +We prove these estimates by induction on the twisting height $M$. +Poisson summation turns a polynomial mean square into a sum of products +of twist $L$-functions at dual squarefree parameters. To put those +parameters below the current height, we first enlarge the family by +replacing $d$ with $dp^2$, where $p\asymp P$. The new averaging height is +$U=MP^2$. A weight with compact Fourier support then restricts the dual +parameters to size $O(N^2/(MP^2))$, which is at most $M/2$ for a +sufficiently large $P$. Recovering the original squarefree average costs +$O(P\log(2P))$. The nonzero-frequency estimate gains $P^{-2}$, so after +recovery its recursive coefficient contains $N\log(2P)/(MP)$. +We choose $P$ as a sufficiently large fixed power of +$\log(3M)(1+N/M)(1+|t|)$, with a large fixed leading constant, to make +this coefficient small. The approximate functional equation and a strip +estimate then close the induction for the $L$-functions themselves. +The compact Fourier support construction and prime-square inflation +are related to Li's treatment of quadratic twists \cite{Li2022}. + +The arithmetic preparation below keeps its arithmetic exponents independent of the +number of weight derivatives. Once the induction is closed, we sum all +dual frequencies to compare short polynomial averages with the integer +model. The polynomial moment bound will also control the unmollified +terminal series in Section~\ref{sec:weights}. + +\subsection{The normalized Gauss sums} + +Put $e(x)=\exp(2\pi i x)$. For an odd positive integer $l$, set +\[ + \tau_h(l)=\sum_{a\bmod l}\left(\frac a l\right)e(ah/l),\qquad + \epsilon_l=\begin{cases}1&l\equiv1\pmod4,\\i&l\equiv3\pmod4,\end{cases} + \qquad B_h(l)=\frac{\tau_h(l)}{\epsilon_l\sqrt l}. +\] +We use $B_h(1)=1$. The square root is positive. +These are the normalized quadratic Gauss sums of +\cite[Section~2.2, Lemma~2.3]{Soundararajan2000}: in that notation, +$B_h(l)=G_h(l)/\sqrt l$. We give the formulas and their proof in the +present normalization. + +\begin{lemma}[Exact Gauss-sum formulas]\label{analytic:gauss} +For fixed $h$, the function $l\mapsto B_h(l)$ is multiplicative on odd +positive integers, and +\begin{equation}\label{analytic:phase} + B_{-h}(l)=\left(\frac{-1}{l}\right)B_h(l),\qquad + \epsilon_l B_h(l)=\frac{1+i}{2}B_h(l)+\frac{1-i}{2}B_{-h}(l). +\end{equation} +If $h\ne0$, $p$ is odd, $t=v_p(h)$, and $v\geq1$, then +\begin{equation}\label{analytic:prime-powers} + B_h(p^v)= + \begin{cases} + p^{v/2}(1-p^{-1}),&v\text{ even},\ v\leq t,\\ + -p^{v/2-1},&v\text{ even},\ v=t+1,\\ + p^{(v-1)/2}\left(\dfrac{h/p^{v-1}}p\right), + &v\text{ odd},\ v=t+1,\\ + 0,&\text{otherwise}. + \end{cases} +\end{equation} +Consequently $B_h(p^v)=0$ for $v>t+1$ and +$|B_h(p^v)|\leq p^{v/2}$. If $t=0$, only $v=1$ can survive and +$B_h(p)=(h/p)$. If $t=1$, only $v=2$ can survive and +$B_h(p^2)=-1$. +\end{lemma} + +\begin{proof} +For coprime odd $l_1,l_2$, the Chinese remainder theorem, followed by a +change of variable in each Gauss sum, gives +\[ + \tau_h(l_1l_2)= + \left(\frac{l_1}{l_2}\right)\left(\frac{l_2}{l_1}\right) + \tau_h(l_1)\tau_h(l_2). +\] +Quadratic reciprocity says that the displayed product of symbols is +$\epsilon_{l_1l_2}/(\epsilon_{l_1}\epsilon_{l_2})$. This proves +multiplicativity. Substituting $a\mapsto-a$ proves the first identity +in \eqref{analytic:phase}; the second follows by considering the two +residue classes of $l$ modulo four. + +For even $v$, the Jacobi symbol modulo $p^v$ is the indicator of the +units. Thus +\[ + \tau_h(p^v)=\sum_{a\bmod p^v}e(ah/p^v) + -\sum_{b\bmod p^{v-1}}e(bh/p^{v-1}), +\] +which equals $p^v-p^{v-1}$ when $p^v\mid h$, equals $-p^{v-1}$ when +$p^{v-1}\Vert h$, and otherwise vanishes. Here $\epsilon_{p^v}=1$. +For odd $v$, write $a=y+pz$ with $y$ modulo $p$ and $z$ modulo +$p^{v-1}$. The $z$-sum vanishes unless $p^{v-1}\mid h$; in that case +\[ + \tau_h(p^v)=p^{v-1}\sum_{y\bmod p} + \left(\frac yp\right)e\big(y(h/p^{v-1})/p\big). +\] +This is zero if $p^v\mid h$. Otherwise the quadratic Gauss-sum formula +makes it +$p^{v-1}\epsilon_p\sqrt p\,\bigl(\frac{h/p^{v-1}}p\bigr)$. +Since $\epsilon_{p^v}=\epsilon_p$ for odd $v$, division by +$\epsilon_{p^v}p^{v/2}$ gives \eqref{analytic:prime-powers}. +\end{proof} + +For later use, fix once and for all the arithmetic exponent +\begin{equation}\label{analytic:arithmetic-exponent} + C_{\rm ar}=256. +\end{equation} +This exponent will not change when we require more derivatives of a +weight or more decay in an imaginary direction. + +\begin{lemma}[Two-variable Euler factorization]\label{analytic:euler} +Let $r$ be positive and odd, and write $h=h_1h_2^2\ne0$, where $h_1$ is +signed squarefree and $h_2\geq1$. For $\nu\in\{1,-1\}$, the series +\[ + \mathcal G_{h,r}^{\nu}(s_1,s_2)= + \sum_{\substack{n_1,n_2\geq1\\n_1,n_2\ \mathrm{odd}}} + \frac{\lambda_F(n_1)\lambda_F(n_2)B_{\nu h}(rn_1n_2)} + {n_1^{s_1}n_2^{s_2}} +\] +initially converges in a right half-plane and continues to +$\Re s_1,\Re s_2>1/2$ as +\begin{equation}\label{analytic:euler-factorization} + \mathcal G_{h,r}^{\nu}(s_1,s_2)= + L_{F^{(\nu h_1)}}(s_1)L_{F^{(\nu h_1)}}(s_2) + \mathcal Q_{h,r}^{\nu}(s_1,s_2). +\end{equation} +For $01/2$; all exceptional factors +are polynomials. Multiplication by the entire twist $L$-functions +therefore gives the claimed continuation. This argument never divides +by a global $L$-value. +\end{proof} + +\subsection{A weighted Poisson estimate} + +The Euler factorization identifies the twist functions that occur at +nonzero frequencies. We now turn it into a weighted comparison formula: +the zero frequency gives the integer residue average, and the remaining +frequencies are bounded by those twist functions. This is a quadratic +Poisson method used in \cite[Section~2.4, Lemma~2.6]{Soundararajan2000}, +with the weights and normalization specified below. + +Fix a compact interval $[a_0,a_1]\subset(0,\infty)$ for the first two +scaled variables. The third variable ranges over $\mathbb R$. For an +integer $D\geq0$, a convenient finite seminorm is +\[ + \|W\|_{D,*}=\max_{\alpha+\beta+\gamma\leq D} + \sup_{y_1,y_2,x}(1+|x|)^D + \left|\partial_{y_1}^{\alpha}\partial_{y_2}^{\beta} + \partial_x^\gamma W(y_1,y_2,x)\right|. +\] +The functions under consideration vanish outside $[a_0,a_1]^2$ in the +first two variables and have the indicated finite decay and smoothness +in the third. Requiring a larger fixed $D$ below causes no change to +$C_{\rm ar}$. + +\begin{lemma}[Poisson estimate]\label{analytic:poisson} +Let $U>0$, let $r$ be odd and positive, and let $N_i$ be bounded below +by a fixed positive constant. Fix $00$, a sufficiently large fixed seminorm order $D$ +bounds the absolute contribution of frequency $h=h_1h_2^2\ne0$ by +\begin{align} + &C_{J_1,\mathcal F}\|W\|_{D,*} + (N_1N_2)^{-1/2+b}b^{-C_{\rm ar}}r^{C_{\rm ar}} + \tau(h_2)^{C_{\rm ar}} + \left(1+\frac{|h|U}{rN_1N_2}\right)^{-J_1} + \nonumber\\[-2pt] + &\hspace{8mm}\cdot + \sum_{\nu=\pm1}\int_{\mathbb R^2} + \frac{\prod_{i=1}^2 + |L_{F^{(\nu h_1)}}(1/2+b+i(t_i+v_i))|} + {(1+|v_1|+|v_2|)^{J_1}}\,dv_1\,dv_2. + \label{analytic:nonzero-mode} +\end{align} +If the Fourier transform of $W$ in $x$ is supported in a fixed interval +$[-C_W,C_W]$, all modes with +$|h|>C_Wa_1^2rN_1N_2/U$ vanish exactly. +\end{lemma} + +\begin{proof} +Our Fourier convention is +$\widehat W(y_1,y_2,\xi)=\int_{\mathbb R}W(y_1,y_2,x)e(-x\xi)\,dx$. +Applying Poisson summation in each residue class modulo $l=rn_1n_2$ +gives exactly +\[ + \frac1U\sum_m\left(\frac ml\right)W(y_1,y_2,m/U) + =\sum_{h\in\mathbb Z}\frac{\tau_h(l)}l + \widehat W(y_1,y_2,hU/l). +\] +Thus the normalized frequency factor is +\[ + \frac{1}{\sqrt{n_1n_2}}\frac{\tau_h(rn_1n_2)}{rn_1n_2} + =\frac{\epsilon_{rn_1n_2}B_h(rn_1n_2)} + {\sqrt r\,n_1n_2}. +\] +Use \eqref{analytic:phase} to replace the numerator by a fixed linear +combination of $B_h$ and $B_{-h}$. + +Put $\rho=hU/(rN_1N_2)$ and +\[ + V_h(y_1,y_2)=\widehat W(y_1,y_2,\rho/(y_1y_2)),\qquad + \widetilde V_h(z_1,z_2)= + \int_0^\infty\!\int_0^\infty + V_h(y_1,y_2)y_1^{z_1}y_2^{z_2} + \frac{dy_1dy_2}{y_1y_2}. +\] +On any fixed bounded range of real parts, Fourier integration by parts +in $x$, followed by Mellin integration by parts in $y_1,y_2$, yields +\begin{equation}\label{analytic:mellin-kernel} + |\widetilde V_h(z_1,z_2)| + \ll_{J_1}\|W\|_{D,*}(1+|\rho|)^{-J_1} + (1+|\Im z_1|+|\Im z_2|)^{-J_1}. +\end{equation} +To see why differentiation causes no arithmetic loss, each derivative +of $\rho/(y_1y_2)$ contributes a bounded multiple of $\rho$ on the +fixed compact support. For any fixed number of such derivatives, take +that many additional integrations by parts in $x$. The powers of +$\rho$ are then absorbed by its Fourier decay. All other factors are +bounded functions of $y_1,y_2$. + +Mellin inversion first on right lines expresses the $\nu$ part of the +mode as +\[ + \frac1{\sqrt r(2\pi i)^2} + \int\!\int \widetilde V_h(z_1,z_2)N_1^{z_1}N_2^{z_2} + \mathcal G_{h,r}^{\nu}(1+it_1+z_1,1+it_2+z_2) + \,dz_1\,dz_2. +\] +Move both lines to $\Re z_i=-1/2+b$. Lemma~\ref{analytic:euler} +and the entire continuation of the twist functions show that no pole +is crossed. Polynomial growth in fixed strips, together with a larger +fixed order in \eqref{analytic:mellin-kernel}, makes the horizontal +segments tend to zero. The scale factor is +$(N_1N_2)^{-1/2+b}$. Applying +\eqref{analytic:euler-bound} and \eqref{analytic:mellin-kernel}, and +discarding $r^{-1/2}\leq1$, proves +\eqref{analytic:nonzero-mode}. The final assertion follows directly +from the support of $\widehat W$ before Mellin inversion. +\end{proof} + +Whenever unrestricted positive indices occur, write $n=2^a n'$ with +$n'$ odd. For $z_m(2)=c$ the factor taken outside an odd-index sum is +$\lambda_F(2^a)c^a2^{-a(1/2+it)}$. Its absolute values have the +uniformly convergent majorant +\begin{equation}\label{analytic:two-sum} + \sum_{a\geq0}(a+1)2^{-a/2}<\infty. +\end{equation} +The new length is $N/2^a$; a nonempty localized sum has this length +bounded below by a constant depending only on $[a_0,a_1]$. + +\subsection{Closing a logarithmic second-moment induction} + +\begin{proof}[Proof of Propositions~\ref{analytic:moment} and~\ref{analytic:polynomial-moment}] +We give a simultaneous induction for all $F\in\mathcal F$. +The induction hypothesis at smaller dyadic heights is +\begin{equation}\label{analytic:induction-hypothesis} + \frac1{M'}\sum_{\substack{d\ \mathrm{admissible}\\M'\leq|d|<2M'}} + |L_{F^{(d)}}(\sigma+it)|^2 + \leq K\log^B(3M')(1+|t|)^A \qquad(M'0$. +Choose $P$ sufficiently large, with +\begin{equation}\label{analytic:inflation-condition} + P\geq C_{\mathcal F,G}(1+N/M). +\end{equation} +Let $\mathcal P$ consist of the primes $p\in[P,2P]$ outside $S$. +For a sufficiently large fixed lower threshold on $P$, the elementary +dyadic prime estimate of Erd\H{o}s \cite[\S6, equation~(10)]{Erdos1932} +gives $|\mathcal P|\gg P/\log(2P)$. + +Choose a fixed nonnegative Schwartz function $\Phi$ that is at least +one on $[-8,8]$ and has compactly supported Fourier transform. For +completeness, take a nonzero even real smooth bump $g$ in frequency +space with $\int g>0$. Its inverse Fourier transform $f$ is real, +Schwartz, and nonzero near zero. A sufficiently small dilation makes +$f(\alpha x)$ nonzero throughout $[-8,8]$; a fixed multiple of +$f(\alpha x)^2$ then has the required properties. Its Fourier +transform is a compactly supported convolution. + +Put $U=MP^2$. For $c=\pm1$ use the formal character $z_m$ with +$z_m(2)=c$, and let $P_m^c(N',t;G)$ be the corresponding polynomial. +We claim, uniformly for $0A+4$. Since +$1+|\pm t+v|\leq T(1+|v|)$, the integral in $v_1,v_2$ is +$O_A(T^A)$. Also +\begin{equation}\label{analytic:square-factor-sum} + \sum_{h_2\geq1}\frac{\tau(h_2)^{C_{\rm ar}}}{h_2^2}<\infty. +\end{equation} +One proof of this convergence is its Euler product: its local factor +is $1+O_{C_{\rm ar}}(p^{-2})$, since +$\sum_{a\geq1}(a+1)^{C_{\rm ar}}p^{-2a} +\ll_{C_{\rm ar}}p^{-2}$ uniformly for $p\geq2$. +Consequently the nonzero contribution is bounded by +\[ + \ll_{A,B,\mathcal F,G}b^{-C_{\rm ar}}KL^BT^A + (N_1N_2)^{-1/2+b}H_0 + \ll_{A,B,\mathcal F,G} + \log^{C_0}(3M+3N)K\frac{N}{MP^2}L^BT^A. +\] +Here $(N_1N_2)^b\ll_G1$ and +$\sqrt{N_1N_2}\ll_GN$. The sums of the factors from two converge by +\eqref{analytic:two-sum}. This proves +\eqref{analytic:inflated-moment}. If the Fourier support contains no +nonzero frequency, the same proof uses only its zero-mode part. + +\smallskip +\noindent\emph{Recovering the squarefree average.} +Now inflate an admissible parameter by setting $m=dp^2$. If +$c=\chi_d(2)$, multiplicativity gives the exact identity +\begin{equation}\label{analytic:inflation-identity} + P_d(N,t;G)=\sum_{a\geq0} + \lambda_F(p^a)\chi_d(p)^a p^{-a(1/2+it)} + P_{dp^2}^c(N/p^a,t;G). +\end{equation} +Indeed $z_{dp^2}(n)$ deletes all positive powers of $p$ and agrees +with $\chi_d(n)$ on integers prime to $p$; reinstating their Euler +coefficients gives the original sum. If $p\mid d$, the terms with +$a\geq1$ vanish, so the identity also covers that case. + +Equip pairs $(d,p)$, with $M\leq|d|<2M$, $\chi_d(2)=c$, and +$p\in\mathcal P$, with squared norm +$(M|\mathcal P|)^{-1}\sum_{d,p}|\cdot|^2$. +The map $(d,p)\mapsto dp^2$ is injective: in the prime factorization +of its absolute value the only exponent exceeding one occurs at +$p$, and is either two or three. Moreover $|dp^2|<8U$. +Thus the $a=0$ term has norm at most +\[ + \left(\frac{U}{M|\mathcal P|}\right)^{1/2} + \sup_{00$, choose +\begin{equation}\label{analytic:choice-P} + P=P_0[L(1+N/M)T]^{C_1}. +\end{equation} +Once $A,B$ and the fixed weight family have been selected, a sufficiently +large $P_0$ ensures \eqref{analytic:inflation-condition} and gives +\begin{align} + \frac1M\sum_d|P_d(N,t;G)|^2 + &\leq C_*[L(1+N/M)T]^{C_2} + \nonumber\\ + &\quad+\varepsilon K L^{B-10}T^{A-4}(1+N/M)^{-4}. + \label{analytic:small-recursion} +\end{align} +The constant $C_*$ can depend on $P_0$ and the chosen fixed data, but +not on $K,M,N,t$. +For explicit verification, put $q=1+N/M$ and $D_0=LqT$. +Then $\log(3M+3N)\ll Lq$ and +\[ + \frac{\log(2P)}P + \leq\frac{\log(2P_0)+C_1}{P_0}D_0^{-C_1+1}. +\] +The recursive coefficient in \eqref{analytic:deinflated-moment} is +therefore at most a fixed multiple of +\[ + \frac{\log(2P_0)+C_1}{P_0} + K L^{B+C_0-C_1+1}T^{A-C_1+1}q^{C_0-C_1+2}. +\] +Our value of $C_1$ leaves at least the losses $10,4,4$ displayed in +\eqref{analytic:small-recursion}. Its prefactor can be made smaller +than $\varepsilon$. The nonrecursive term is bounded by +$C_*D_0^{C_0+C_1+1}$ and hence by the stated $C_2$ power. In +particular $C_2$ was fixed before $A,B,\varepsilon,P_0,K$. + +\smallskip +\noindent\emph{Reconstructing the central-line values.} +We next reconstruct $L$ on the central line. Choose a fixed \mbox{smooth} +dyadic partition $G_0$ with common compact support in $(0,\infty)$, +so that +$\sum_{N=1,2,4,\ldots}G_0(n/N)=1$ for every integer $n\geq1$. +Let $C_d=\sqrt{q_F}|d|/(2\pi)$ and define +\[ + I_d(t)=\frac1{2\pi i}\int_{(R)} + L_{F^{(d)}}(1/2+it+w)C_d^w + \frac{\Gamma(1+it+w)}{\Gamma(1+it)}\frac{e^{w^2}}w\,dw. +\] +Moving the contour to $\Re w=-R$ crosses only the residue +$L_{F^{(d)}}(1/2+it)$, because the completed function is entire. +Apply its functional equation on the new line and replace $w$ by +$-w$. One obtains the exact approximate functional equation +\begin{equation}\label{analytic:afe-identity} + L_{F^{(d)}}(1/2+it)=I_d(t)+\omega_d(t)I_d(-t),\qquad + \omega_d(t)=\epsilon_d C_d^{-2it} + \frac{\Gamma(1-it)}{\Gamma(1+it)}, + \quad |\omega_d(t)|=1. +\end{equation} +The Gaussian makes the contour displacement legitimate. Initially, +on $\Re w=R$, the Dirichlet series is absolutely convergent, so we +may insert the dyadic partition. + +For $0\leq c\leq R$, Stirling's formula uniformly gives +\begin{equation}\label{analytic:gamma-quotient} + \left|\frac{\Gamma(1+c+i(t+v))}{\Gamma(1+it)}\right| + \ll_R T^c(1+|v|)^{R+1/2}e^{\pi|v|/2}. +\end{equation} +Indeed the quotient of the exponential factors is at most +$e^{\pi|v|/2}$, and +\[ + \frac{(1+|t+v|)^{c+1/2}}{(1+|t|)^{1/2}} + \leq T^c(1+|v|)^{c+1/2}. +\] +The same estimates with $1+|t+v|$ also cover bounded ordinates, including +$v$ near $-t$. Thus the bound is uniform as $c$ tends to zero. +For a fixed dyadic piece the polynomial is finite, so its contour can +be moved to any $01/2$. Finitely many shorter pieces can +then be moved separately. The moment estimates below also show +convergence after taking the family norm. + +Use +\[ + c_N=\frac1{\log(3MT)}\quad(N\leq MT^2),\qquad + c_N=R\quad(N>MT^2). +\] +Apply \eqref{analytic:small-recursion} uniformly to the fixed smooth +family $G_0(y)y^{-c}$, $0\leq c\leq R$, and use Minkowski in +\eqref{analytic:afe-pieces}. We spell out the two contributions. +For the nonrecursive square-root term and $N\leq MT^2$, +\[ + [L(1+N/M)(1+|\nu t+v|)]^{C_2/2} + \ll L^{C_2/2}T^{3C_2/2}(1+|v|)^{C_2/2}. +\] +There are $O(\log(3MT^2))$ such dyadic pieces, +$(MT/N)^{c_N}\leq e$ for $N\geq1$, and +$1/|c_N+iv|\leq\log(3MT)$. +Since both logarithms are $O(LT)$, their squared total cost gives +at most $C_{**}(LT)^{3C_2+4}$ in the mean square. +For the long pieces put $q'=N/M>T^2$. Then +\[ + \sum_{q'>T^2}\left(\frac T{q'}\right)^R(q')^{C_2/2} + \ll_R T^{-R+C_2}, +\] +where $q'$ runs over a dyadic progression. Including the outside +factor $L^{C_2/2}T^{C_2/2}$ again fits within +$C_{**}(LT)^{C_3}$ by \eqref{analytic:exponent-choices}. + +For the recursive square-root term, the short dyadic sum satisfies +\[ + \sum_{N\leq MT^2}(1+N/M)^{-2}\ll\log(3M)=L. +\] +The Gaussian absorbs $(1+|v|)^{(A-4)/2}$, so the resulting norm is +at most +\[ + C_{A,R,\mathcal F}\sqrt{\varepsilon K}\, + L^{B/2-5}T^{A/2-2}\,L\log(3MT) + \ll C_{A,R,\mathcal F}\sqrt{\varepsilon K}\, + L^{B/2}T^{A/2}. +\] +For the long pieces we have the stronger estimate +\begin{equation}\label{analytic:long-recursive-sum} + \sum_{q'>T^2}\left(\frac T{q'}\right)^R(1+q')^{-2} + \ll_R T^{-R-4}, +\end{equation} +which gives the same bound. Squaring the total norm now proves +\begin{equation}\label{analytic:central-recursion} + \frac1M\sum_d|L_{F^{(d)}}(1/2+it)|^2 + \leq C_{**}(LT)^{C_3} + +C_{\dagger}\varepsilon K L^BT^A. +\end{equation} +Here $C_{\dagger}$ depends on $A,R,\mathcal F$ but not on $P_0,K,M,t$; +$C_{**}$ may depend on $P_0$. This independence is essential when +choosing the constants. + +\smallskip +\noindent\emph{Closing the induction in the strip.} +It remains to extend the estimate to the strip without a factor for +the number of twists. Form the vector +\[ + \mathbf V_F(s)=\big(M^{-1/2}L_{F^{(d)}}(s)\big)_d +\] +in the finite-dimensional Euclidean space indexed by the current +admissible block. On $\Re s=2$ its squared norm is bounded by an +absolute constant: each $L$-value has modulus at most +$\sum_n\tau(n)n^{-2}=\zeta(2)^2$, and the number of parameters is +$O(M)$. On $\Re s=1/2$, \eqref{analytic:central-recursion} gives the +stated vector norm bound. + +For each constant unit vector $u$ apply the scalar strip principle to +\[ + f_u(s)=\frac{\langle\mathbf V_F(s),u\rangle}{(1+s)^{A/2}}. +\] +Here $A$ is even by \eqref{analytic:exponent-choices}. On both +boundaries $|1+s|\asymp1+|\Im s|$, with constants independent of the +number of twists. The scalar boundary bound is therefore at most +\[ + C_A\big(C_{**}L^{C_3}+C_{\dagger}\varepsilon K L^B+1\big)^{1/2}. +\] +For clarity, finite-order growth suffices for the strip principle: +multiply $f_u(s)$ by +$\exp\{-\rho\cos(s-5/4)\}$, with $\rho>0$. Its modulus is at most +one on the strip boundaries and it decays faster than every +finite-order growth bound on horizontal sides, since +$\cos(\Re s-5/4)>0$ for $1/2\leq\Re s\leq2$. Apply the maximum +principle on rectangles and then let their heights tend to infinity +and $\rho$ decrease to zero. Taking the supremum over unit vectors +at the desired point gives +\begin{equation}\label{analytic:strip-recursion} + \|\mathbf V_F(\sigma+it)\|_2^2 + \leq C_{\rm st} + \big(C_{**}L^{C_3}+C_{\dagger}\varepsilon K L^B+1\big)T^A, + \qquad 1/2\leq\sigma\leq2. +\end{equation} +This argument has no dimension-dependent loss. + +The choice order is now explicit. Fix the family, the elementary +arithmetic exponent, $C_0,C_1,C_2,R,C_3,A,B$ as above, and then all +needed fixed kernel orders. Next choose +$0<\varepsilon<(4C_{\rm st}C_{\dagger})^{-1}$, choose $P_0$ to obtain +\eqref{analytic:small-recursion} for the entire weight family, and +finally choose $K$ so large that +$C_{\rm st}(C_{**}L^{C_3}+1)\leq K L^B/2$ for every $L\geq\log3$. +This is possible because $B>C_3$ and $C_{**}$ is independent of $K$. +Equation~\eqref{analytic:strip-recursion} proves +\eqref{analytic:induction-hypothesis} at height $M$. At $M=1$, all +dual sums used above are empty, so this also establishes the initial +step. The simultaneous induction is complete. + +The induction just completed uses the fixed weight family +$G_0(y)y^{-c}$, $0\leq c\leq R$. For any other fixed smooth compactly +supported $G$, repeat the polynomial argument through +\eqref{analytic:small-recursion}, using the established $L$-function +bound at smaller heights. The constants $P_0$ and $C_*$ may now depend +on $G$, while $K,A,B$ remain fixed. Since $A,B>C_2$, this proves +\eqref{analytic:polynomial-bound}, with the asserted uniformity for +fixed uniformly smooth weight families. +Finally use Lemma~\ref{setup:reduction}, bounded multiplicity, and a +sum over admissible dyadic blocks of total length $O(H)$ to obtain +\eqref{analytic:prefix-moment}. No analytic-density input has entered +the argument. +\end{proof} + +\subsection{Short polynomials and auxiliary multipliers} + +The second moments are now available at every height. We use them to +bound the complete sum of nonzero Poisson frequencies, retaining the +zero frequency as an exact independent-model average. The resulting +comparison permits a short polynomial multiplier, as required for the +mollifiers below. + +Fix a nonnegative smooth function $\Psi$ compactly supported in +$\{x:0<|x|<\infty\}$, with $\Psi(x)\geq1$ when $1\leq|x|\leq2$. +Fix $c\in\{1,-1\}$. The formal character $z_m$ and the independent +variables $Z$ always have value $c$ at two. At odd primes their model +law is +\[ + \mathbb P(Z(p)=0)=\frac1p,\qquad + \mathbb P(Z(p)=1)=\mathbb P(Z(p)=-1)=\frac{1-1/p}{2}. +\] +They are extended completely multiplicatively. This is a model for +complete integer residue averages. + +\begin{lemma}[Summation of all dual frequencies]\label{analytic:frequency-sum} +For fixed $B\geq0$, $J_1>1$, and $Q>0$, +\begin{equation}\label{analytic:dyadic-frequency-bound} + \sum_{T=1,2,4,\ldots}T\log^B(3T)(1+T/Q)^{-J_1} + \ll_{B,J_1} + \begin{cases} + Q^{J_1},&0Q$, so +$Q0$. There are fixed constants $\eta,c_2>0$ for which +the following holds. Let +\[ + S_V(x)=\sum_{n\geq1}\frac{\lambda_F(n)V(n)}{\sqrt n}\, + w_x(\ell^{-1}\log n),\qquad + H_V=\sum_{r'\leq R_0}h(r')V(r'), +\] +where $V=z_m$ or $Z$. Suppose that $S_V$ has length at most +$X^{1-\Delta}$, that +\begin{equation}\label{analytic:multiplier-conditions} + 1\leq R_0\leq X^{\eta\Delta},\qquad + \sum_{r'\leq R_0}|h(r')|\leq C_H R_0^2, +\end{equation} +and that $w_x$ and a function $A(x)$ have bounds by a fixed power of +$\ell$ for all derivatives up to a sufficiently large fixed order. +For $w_x$ these bounds are required after smooth dyadic localization +in $n$, on the scaled variables $n/N$ and $x$ in a fixed neighborhood +of $\operatorname{supp}\Psi$. They may in particular follow from +bounds in $u=\ell^{-1}\log n\geq0$ and $x$, with a smooth extension +at $n=1$. Then +\begin{align} + &\frac1X\sum_{m\in\mathbb Z}\Psi(m/X) + |H_{z_m}S_{z_m}(m/X)-A(m/X)|^2 + \nonumber\\ + &\hspace{8mm}= + \int_{\mathbb R}\Psi(x)\, + \mathbb E|H_ZS_Z(x)-A(x)|^2\,dx + +O\big(\exp(-c_2\Delta\ell)\big). + \label{analytic:model-comparison} +\end{align} +The constants and the sufficiently large $X$ threshold are uniform +when the stated support, coefficient, and derivative bounds are +uniform. They do not depend on $\Delta$ or on an index parametrizing +such weights. One may take +\begin{equation}\label{analytic:comparison-constants} + C'=C_{\rm ar}+1=257,\qquad + \eta=\frac1{4(4+2C')},\qquad c_2=\frac12. +\end{equation} +\end{proposition} + +\begin{proof} +Put $L=X^{1-\Delta}$. If the length hypothesis specifies only that +the integer coefficients vanish for $n>L$, multiply the interpolating +weight by $\rho_+(n/L)$, where $\rho_+$ is a fixed smooth function equal +to one on $(-\infty,1]$ and zero on $[2,\infty)$. This preserves every +integer coefficient and gives real support in $n\leq2L$. On a dyadic +scale meeting the transition, $N/L$ is bounded, so derivatives of +$\rho_+(Ny/L)$ add only fixed constants to the assumed scaled seminorm +bounds. Thus all nonempty localized lengths satisfy $N_i\ll L$. + +Expand the square on the left of \eqref{analytic:model-comparison}. +A term involving two multiplier indices $r_1',r_2'$ has character +factor $z_m(r_1'r_2'n_1n_2)$. Its odd multiplier part is an integer +$r\leq R_0^2$. Powers of two contribute only fixed signs. Split +powers of two out of $n_1,n_2$, and insert smooth dyadic partitions +in their odd parts. Each resulting term has exactly the form +\eqref{analytic:poisson-average} with $U=X$, $t_1=t_2=0$, and a +weight $W$ whose required seminorm is $O(\ell^{D_1})$ for a fixed +$D_1$. The independent factors coming from the powers of two satisfy +\eqref{analytic:two-sum}. Cross terms with $A(x)$ are covered by +using an index supported just at one: choose a fixed smooth function +supported in $(1/2,3/2)$ and equal to one at one. The identity +$\lambda_F(1)=1$ then puts them in the same form. The term $|A|^2$ +is covered by two such indices. Its derivatives obey the same +fixed polynomial bounds. + +The zero frequency is exactly the model expression. In fact, for +an odd prime and $v\geq1$, +\[ + \frac1{p^v}\sum_{a\bmod p^v}\left(\frac a{p^v}\right) + =\begin{cases}0&v\text{ odd},\\1-p^{-1}&v\text{ even},\end{cases} + =\mathbb E Z(p)^v. +\] +For $v=0$ both sides are one. Chinese remaindering gives independence +at distinct odd primes, and the value at two is already fixed. +The integral of the zero-frequency smooth amplitude is thus the +corresponding term on the right of +\eqref{analytic:model-comparison}. + +It remains to estimate the nonzero frequencies. Fix an odd multiplier +$r$ and localized odd lengths $N_1,N_2$, and set +\[ + b=\frac1{10\ell},\qquad Q=\frac{rN_1N_2}{X}. +\] +Only nonempty lengths need be considered, so $N_i$ is bounded below +by a fixed positive constant. Also $N_i\ll X^{1-\Delta}$, whence +$(N_1N_2)^b\ll1$. Proposition~\ref{analytic:moment} is available +at every height. For a dyadic frequency range $T\leq|h|<2T$, +write $h=h_1h_2^2$. For fixed $h_2$, the parameter $h_1$ lies in +$0<|h_1|<2T/h_2^2$. Cauchy--Schwarz and +\eqref{analytic:prefix-moment} imply +\begin{align*} + &\sum_{\substack{T\leq|h|<2T\\h=h_1h_2^2}} + \tau(h_2)^{C_{\rm ar}} + \prod_{i=1}^2 + |L_{F^{(\nu h_1)}}(1/2+b+iv_i)|\\ + &\quad\ll + T\log^B(3T)(1+|v_1|)^{A/2}(1+|v_2|)^{A/2} + \sum_{h_2\leq\sqrt{2T}}\frac{\tau(h_2)^{C_{\rm ar}}}{h_2^2}\\ + &\quad\ll T\log^B(3T) + (1+|v_1|)^{A/2}(1+|v_2|)^{A/2}. +\end{align*} +This inequality applies separately to each $\nu$; it includes both +signs of $h$. Choose $J_1>A+4$ in +\eqref{analytic:nonzero-mode}, and then fix the corresponding +smoothness order. Its vertical integral is convergent. The remaining +sum is bounded, by Lemma~\ref{analytic:frequency-sum}, by +\[ + \ll \ell^{D_2}r^{C_{\rm ar}}(N_1N_2)^{-1/2} + \begin{cases}Q^{J_1}&Q<1,\\Q\log^B(3Q)&Q\geq1. + \end{cases} +\] +When $Q\geq1$ we have $Q\ll X$ using $r\leq R_0^2$, +\eqref{analytic:multiplier-conditions}, and $\eta<1$; hence +$\log(3Q)\ll\ell$. When $Q<1$ use $Q^{J_1}\leq Q$. +In both regimes the error for this localized pair is therefore +\begin{equation}\label{analytic:localized-comparison-error} + \ll\ell^{D_3}r^{C'}\frac{\sqrt{N_1N_2}}X, + \qquad C'=C_{\rm ar}+1. +\end{equation} +The increase from $C_{\rm ar}$ to $C'$ is only the factor $r$ +in $Q$, not a smoothness loss. Notice that this argument controls +arbitrarily large dual frequencies as well as the case $Q<1$. + +There are $O(\ell)$ possible nonempty dyadic pieces for each main +index. Their cost is a fixed logarithmic power. Summing the +coefficients from powers of two by \eqref{analytic:two-sum} costs +only a constant. The two multiplier coefficient sums and the +bound $r\leq R_0^2$ cost at most +\[ + (1+\textstyle\sum|h(r')|)^2R_0^{2C'}\ll_{C_H}R_0^{4+2C'}. +\] +Since $\sqrt{N_1N_2}/X\ll X^{-\Delta}$, including the terms with an +index at one, the full error is +\begin{equation}\label{analytic:total-comparison-error} + \ll\ell^{D_4}X^{-\Delta}R_0^{4+2C'} + \leq\ell^{D_4}\exp(-3\Delta\ell/4). +\end{equation} +Our choices in \eqref{analytic:comparison-constants} give the last +inequality. The power $D_4$ is fixed before choosing $X$. +Because $\Delta\ell\geq c_1\ell^{9/10}$, for one sufficiently large +$X$ the factor $\ell^{D_4}$ is at most +$\exp(\Delta\ell/4)$. This proves +\eqref{analytic:model-comparison} with $c_2=1/2$. +\end{proof} + +The endpoint at $n=1$ in this proposition needs no extension to a fixed +negative interval in $u$. +Extend a dyadically localized weight only to, say, $n\geq1/2$. +In the coordinate $\log n=\ell u$ this is a fixed interval, and +smooth cutoffs there introduce at most fixed powers of $\ell$ in +$u$ derivatives. On a dyadic scale, repeated differentiation of +$w_x(\log(Ny)/\ell)$ instead introduces powers of $1/\ell$ and +bounded powers of $1/y$. Thus the required finite seminorm bounds +are precisely those in the proposition, even at the first piece. diff --git a/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/introduction.tex b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/introduction.tex new file mode 100644 index 0000000000000000000000000000000000000000..68b64af9d7c42ed6f6ebf0e5c6b48e5c68a4a0f4 --- /dev/null +++ b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/introduction.tex @@ -0,0 +1,275 @@ +\section{Introduction}\label{sec:introduction} + +Goldfeld's mean-rank conjecture predicts that the average central order +of vanishing in a quadratic-twist family is \(1/2\) +\cite[p.~113, Conjecture~(B)]{Goldfeld1979}. +The issue addressed here is the contribution of rare twists of large +analytic rank: knowing the densities of ranks zero and one does not +determine the mean without control of this contribution. + +Let \(E/\Q\) be an elliptic curve. For a nonzero squarefree integer \(d\), +write \(E^{(d)}\) for its quadratic twist, and put +\[ + \mathcal D(Y)=\{d\in\Z:0<|d|\le Y,\ d\text{ squarefree}\}, + \qquad + a(E^{(d)})=\ord_{s=1}L(E^{(d)},s). +\] +Both signs of \(d\) are included. We call \(a\) the analytic rank and +write \(r(E^{(d)})=\operatorname{rank}_{\Z}E^{(d)}(\Q)\) for the +algebraic or Mordell--Weil rank. Outside the explicitly algebraic +statements below, rank means analytic order of vanishing. + +\begin{theorem}\label{thm:mean} +For every elliptic curve \(E/\Q\), +\[ + \lim_{Y\to\infty}\frac{1}{\#\mathcal D(Y)} + \sum_{d\in\mathcal D(Y)}a(E^{(d)})=\frac12. +\] +\end{theorem} + +Theorem~\ref{thm:mean} resolves positively Goldfeld's mean analytic-rank +conjecture in this signed squarefree counting convention. It applies +without restrictions on complex multiplication, rational torsion, +rational isogenies, or reduction type. + +The analytic density theorem +\cite[Theorem~1.2]{OpenAIAnalyticDensityV2} +states that, for this same family and every \(E/\Q\), +\begin{equation}\label{eq:density-input} + \frac{\#\{d\in\mathcal D(Y):a(E^{(d)})=j\}}{\#\mathcal D(Y)} + \longrightarrow\frac12 + \qquad(j=0,1). +\end{equation} +For the analytic mean theorem, \eqref{eq:density-input} is the only input +from the companion manuscript identified in the bibliography. +A zero-density exceptional family can still contribute +to a rank-weighted average. The new assertion needed for the mean is the +following tail estimate, whose proof is independent of +\eqref{eq:density-input}. + +\begin{theorem}\label{thm:tail} +For every elliptic curve \(E/\Q\), there are constants \(C_E>0\) and +an integer \(R_E\ge1\) such that, for every integer \(R\ge R_E\), +\[ + \limsup_{Y\to\infty}\frac1Y + \sum_{\substack{d\in\mathcal D(Y)\\a(E^{(d)})>R}}a(E^{(d)}) + \le \frac{C_E}{R}. +\] +\end{theorem} + +Together, \eqref{eq:density-input} and Theorem~\ref{thm:tail} show that +\[ + \sum_{\substack{d\in\mathcal D(Y)\\a(E^{(d)})\ge2}}a(E^{(d)})=o_E(Y). +\] +For each fixed sufficiently large integer \(R\), \eqref{eq:density-input} +makes the complement of ranks zero and one have density zero, so ranks +\(2\) through \(R\) contribute \(o_{E,R}(Y)\). +For the remaining ranks, use the height limsup in Theorem~\ref{thm:tail} +and then let \(R\) tend to infinity. This order of limits will be +made explicit in Section~\ref{sec:tail}. + +\subsection{Algebraic-rank moments} + +The same signed squarefree family has the following algebraic-rank +moment limits. This consequence uses the companion's density conclusions +and its density-one equality of analytic and algebraic ranks, together +with the exponential-moment bound of Koymans and Smith. It does not use +the analytic tail estimate of Theorem~\ref{thm:tail}. + +\begin{corollary}[Fixed algebraic-rank moments]\label{cor:algebraic-moments} +Fix an elliptic curve \(E/\Q\). For every fixed real \(t\), +\[ + \lim_{Y\to\infty}\frac1{\#\mathcal D(Y)} + \sum_{d\in\mathcal D(Y)}\exp\!\bigl(t\,r(E^{(d)})\bigr) + =\frac{1+e^t}{2}. +\] +For every fixed positive integer \(m\), +\[ + \lim_{Y\to\infty}\frac1{\#\mathcal D(Y)} + \sum_{d\in\mathcal D(Y)}r(E^{(d)})^m=\frac12. +\] +\end{corollary} + +The proof appears in Section~\ref{sec:algebraic}. + +All parameters \(t\) and moment orders \(m\) in +Corollary~\ref{cor:algebraic-moments} are fixed before \(Y\to\infty\). +The corollary concerns algebraic ranks only: it gives no higher +analytic-rank moments, no uniformity for parameters varying with \(Y\), +and no moment limit for thin polynomial subfamilies. + +\subsection{History and significance} + +Goldfeld's original question concerns the change of rank when a fixed +elliptic curve is viewed over quadratic fields. Under +Birch--Swinnerton-Dyer, that change is the central order of the associated +quadratic twist. His Conjecture~(B) formulates the average directly in +terms of this analytic order, using quadratic-field discriminants +ordered by absolute value \cite[pp.~113--114]{Goldfeld1979}. +Here the counting parameter is instead the signed squarefree integer +\(d\) in \(\mathcal D(Y)\). +The rank-zero/rank-one density prediction describes the smallest orders +allowed by the two functional-equation signs. The mean prediction also +requires the larger orders, however sparse, to have negligible total +contribution. + +Conditional analytic estimates illustrate both aspects of the problem. +Heath-Brown proved an upper bound \(3/2+o(1)\) for smooth averages over +fundamental discriminants coprime to the conductor, separately for each +functional-equation sign \cite[Theorem~3]{HeathBrown2003}. +His nonnegative compactly supported weight selects one sign of the +discriminant, and his Riemann-hypothesis assumption concerns every +quadratic twist, including those not coprime to the conductor. +Under the same twistwise Riemann-hypothesis assumption, Miller and Wong +bounded higher analytic-rank moments and obtained exponentially +decreasing large-rank counting tails +\cite[Theorem~1.1 and Corollary~1.2]{MillerWong2012}. +Their weighted sums run over integer parameters, with possible repeated +squareclasses; the weight selects one parameter sign without fixing the +functional-equation sign. Their tail estimate fixes the rank threshold +before taking the height limit. Fiorilli obtained the exact mean \(1/2\) over +signed squarefree parameters coprime to the conductor, assuming the +Riemann hypothesis for elliptic-curve \(L\)-functions and an additional +averaged cancellation hypothesis for nonreal zeros +\cite[Theorem~1.1 and Hypothesis~M]{Fiorilli2016}. +Thus this exact conditional mean uses more than the Riemann hypothesis. + +A different route to densities comes from Selmer groups. +Smith proved that, for every rational elliptic curve, the full +\(2\)-power Selmer corank is zero or one with density \(1/2\) each, +using signed integer twist parameters +\cite[Theorem~1.1]{Smith2025}. His analytic density corollary assumes +Birch--Swinnerton-Dyer \cite[Corollary~1.2]{Smith2025}. +The companion's \(2\)-converse supplies the analytic implication needed +for \eqref{eq:density-input} in the signed squarefree convention. +Theorem~\ref{thm:tail} addresses the additional rank-mass question +independently of that density argument. + +Koymans and Smith prove exponential moment bounds for Mordell--Weil rank +in polynomial quadratic-twist families +\cite[Theorem~1.4]{KoymansSmith2026}. The specialization in the proof of +Corollary~\ref{cor:algebraic-moments} supplies the needed algebraic +tail control. Such bounds do not supply an analytic-rank identity or +higher analytic-rank moments. + +Hanners claims the full Birch--Swinnerton-Dyer conjecture for every +rational elliptic curve \cite[Theorems~28.1, 39.4 and~39.5]{Hanners2026}. We do not use +this claim. The unresolved point is how the bridge conditions supported +by tests on eighteen curves in Section~39.1 are established for every +rational elliptic curve, as required by the transfer in Section~39.2. +This is not a refutation of the claimed theorem. + +Modularity provides the analytic continuation and functional equation +for every curve in the argument +\cite[Theorem~A]{BreuilConradDiamondTaylor2001}. Our estimates use these analytic properties +and the local coefficient bounds. The proof invokes neither the +Birch--Swinnerton-Dyer conjecture nor the generalized Riemann hypothesis. + +Earlier work on a fixed elliptic curve already connected derivative +moments to nonvanishing and analytic-rank averages. Perelli and +Pomyka\l a proved first-derivative nonvanishing results and bounds for +the sum of analytic ranks \cite{PerelliPomykala1997}; +Pomyka\l a extended this nonvanishing approach to higher derivatives of +fixed order in a congruence-restricted twisting family \cite{Pomykala1997}. +In the family of weight-two newforms of varying prime level, +Kowalski, Michel, and VanderKam combined high completed derivatives, +mollification, and consecutive derivative orders to control both +functional-equation signs. Their passage from these nonvanishing counts +to rank-weighted tails also uses a separate bound for the second moment +of analytic rank +\cite[Sections~2, 4, and~8]{KowalskiMichelVanderKam2000}. +In the present quadratic-twist argument the derivative order grows with +height. This uniformity, together with a pointwise rank bound, controls +the rank mass beyond the available counting range without requiring a +bounded second analytic-rank moment. + +Second moments of the twist \(L\)-functions themselves supply the +analytic comparison used below. For full-level holomorphic Hecke forms +of weight divisible by four, Soundararajan and Young obtained the +second-moment asymptotic over positive discriminants \(8d\), with \(d\) +odd and squarefree, under GRH for the twists, the Riemann zeta function, +and the symmetric-square \(L\)-function +\cite[Theorem~1.2]{SoundararajanYoung2010}. +Li proved the asymptotic unconditionally in this full-level setting +\cite[Theorem~1.1]{Li2022}. We adapt the Fourier-cutoff and prime-square +inflation mechanism in Li's proof, establishing the needed logarithmic +bounds for our finite family of arbitrary elliptic curves with its +conductor and bad-prime factors retained. Neither asymptotic is an input +to the argument. + +\subsection{The analytic argument} + +The starting point is the exact identity of Lemma~\ref{weights:vanishing}, +forced by the vanishing of a derivative of order \(k\) of the completed \(L\)-function. +Its Dirichlet-series weight is obtained by exponentially smoothing +a \(k\)-th power of a truncated logarithm. +Near the square root of the conductor, at lengths of order \(X\) for +twists of height \(X\), this weight suppresses the late terms. +The approximation \((1-u)^k\approx e^{-ku}\) for \(u=O(1/k)\) +motivates mollification: at \(u=\log n/\log X\), the exponential +corresponds to a small positive shift from the center of the +\(L\)-function. A short approximation to its inverse Euler product +then makes the first weighted piece close to a positive main term. +We split the weighted series using smooth cutoffs into finite pieces +and a terminal series, use progressively shorter mollifiers as the +lengths of the finite pieces increase, and estimate the terminal series +without mollification. + +Two features make the resulting estimates uniform for +\(k\) as large as a fixed power of \(\log X\). +First, a Poisson argument and inflation give unmollified second moments +with only powers of logarithms +(Propositions~\ref{analytic:moment} and~\ref{analytic:polynomial-moment}). +The inflation mechanism is related +to Li's work on quadratic twists +\cite[Lemmas~2.7 and~3.1, Proposition~3.2]{Li2022}; we prove the estimate +needed here for the entire fixed finite family of curves, including its +local factors at bad primes. +Second, Proposition~\ref{model:main-model-estimates} gives mean-square +bounds for the mollified finite pieces in a model that replaces +odd-prime character values by independent variables with their +complete-residue distributions. The mean-square estimates use the whole +probability space, without discarding exceptional outcomes. +Proposition~\ref{analytic:comparison} transfers these bounds to integer averages. +Separately, Proposition~\ref{model:good-event} compares the mollifiers +with positive reciprocal Euler products on most integer parameters +and relates these products to one another. We can then remove the +mollifiers and compare every piece with the same positive product: +the first piece dominates the later pieces and +the terminal series. The resulting nonzero sum contradicts the +completed-derivative identity whenever the rank exceeds the derivative +order of matching parity. Consecutive orders cover both signs. + +For admissible twists of height \(X\), Proposition~\ref{tail:count} proves a bound +\(O_E(X/k^2)\) for the number of ranks exceeding \(k\), uniformly up to +\(k=(\log X)^{3/5}\). +A conductor-uniform Jensen bound (Lemma~\ref{tail:jensen}) gives the pointwise estimate +\(a(E^{(d)})=O_E(\log X)\). +The count at the largest permissible \(k\) then controls the remaining +rank mass, and summation of the integer tails proves +Theorem~\ref{thm:tail}. +The numerical exponents used in the length partition leave ample +room between the comparison error and the later thresholds; their +optimization is not needed. + +The sections follow the inputs required by this argument. +Section~\ref{sec:setup} fixes the finite auxiliary family and the integer +residue model. Section~\ref{sec:analytic} proves the moments and the +comparison with that model. Section~\ref{sec:weights} constructs the +completed-derivative weights and bounds their terminal series. +Section~\ref{sec:model} constructs the short mollifiers and proves the +model estimates. Section~\ref{sec:tail} combines them into the counting +and rank-weighted tail bounds, and uses the companion density theorem +only in the final deduction of the mean. Section~\ref{sec:algebraic} +proves the separate algebraic-rank moment corollary. + +\subsection{Conventions} + +Implied constants may depend on the original curve \(E\), on fixed +smooth functions, and on a specified fixed order of differentiation. +They do not depend on the varying height, derivative order, or scale +index unless this is explicitly stated. +We write \(\tau(n)\) for the divisor function and use the Fourier kernel +\(e^{-2\pi ixy}\) when applying Poisson summation. +All sufficiently large lower thresholds for the integer \(k\) are +chosen after the fixed analytic exponents and smoothness orders. diff --git a/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/model.tex b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/model.tex new file mode 100644 index 0000000000000000000000000000000000000000..5dc960c2b8b0e06867ad38fe93ecd0a8766387cd --- /dev/null +++ b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/model.tex @@ -0,0 +1,824 @@ +\section{Block mollifiers and independent-model mean squares} +\label{sec:model} +\label{model:section} + +We seek polynomial multipliers that make the first short piece close +to the positive quantity $A_x$ from \eqref{weights:Ax}, while keeping +the later pieces small. The construction has two separate tasks: +control the multipliers on most integers, and prove mean-square bounds +on the entire independent model. Their combination will allow the +first piece to dominate the weighted-series identity. + +Fix a member $F$ of the finite family $\mathcal F$ and a value +$c\in\{-1,1\}$ at the prime $2$, and write $\lambda=\lambda_F$ and $\xi_p=\xi_{F,p}$. +The constants in this section are uniform in these two choices. We use +the integer characters $z_m$ and the independent variables $Z$ defined +above; in particular, at an odd prime +\[ + \mathbb P(Z(p)=0)=p^{-1},\qquad + \mathbb P(Z(p)=1)=\mathbb P(Z(p)=-1)=(1-p^{-1})/2, + \qquad Z(2)=c. +\] +All model norms below are norms on this entire probability space. +We use the parameters and weights of Section~\ref{sec:weights}: +\[ + \ell=\log X,\qquad k_0\le k\le\ell^{3/5},\qquad + J=\left\lfloor\frac{\log\ell}{10\log2}\right\rfloor, + \qquad \delta_j=2^{-j},\qquad s=k/\ell. +\] +Here $k$ is an integer. We always take $X$ sufficiently large that +$J\ge1$ and $0Y}p^{-1-2a} + &\ll\int_{2a\log Y}^{\infty}\frac{e^{-v}}v\,dv + \ll 1+\log^+\frac1{a\log Y}\qquad(01$, discard the minimum and use the same estimates to obtain +$O(1+\log(1/a))$, which is bounded by the right side of +\eqref{model:prime-transition}. + +For any real character value $V(p)\in\{-1,0,1\}$ define +\begin{equation} + D_p(b,V)=1-\lambda(p)V(p)p^{-1/2-b} + +\xi_p V(p)^2p^{-1-2b},\qquad \Re b\ge0. + \label{model:inverse-local} +\end{equation} +The local parameter bound gives a factorization +$D_p(b,V)=\prod_{\nu=1}^2(1-\alpha_{p,\nu}V(p)p^{-1/2-b})$, +where $|\alpha_{p,\nu}|\le1$ and zero parameters are permitted. +Consequently +\begin{equation} + (1-p^{-1/2})^2\le |D_p(b,V)|\le(1+p^{-1/2})^2. + \label{model:local-bounds} +\end{equation} +For real $b\ge0$, the value of $D_p(b,V)$ is positive: at a good +prime its two factors are complex conjugates (or both positive real), +and at a bad prime its nontrivial factor is positive. These facts apply +equally to $V=Z$ and $V=z_m$. + +\subsection{Construction, length, and the simultaneous product event} + +Radziwi\l\l{} and Soundararajan use disjoint prime blocks, truncated +exponential polynomials, and relative truncation estimates in their +study of central values of quadratic twists +\cite[Sections~3, 8, and~9]{RadziwillSoundararajan2015}. +Here we truncate products of inverse local Euler factors by total +degree and estimate shifted norms over the full integer model defined +in Section~\ref{sec:setup}. + +Put +\[ + Y_j=X^{\delta_j^2/\sqrt k},\qquad + P_j^{\mathrm{eu}}(V)=\prod_{p\le Y_j}D_p(s,V)^{-1} + \quad(0\le j\le J). +\] +Since $s\log Y_0=\sqrt k$, the prime-tail estimate +\eqref{model:prime-tail} makes $\sum_{p>Y_0}p^{-1-2s}$ exponentially +small. This sum will control the residual Euler product in mean square. +For the later pieces, the available +multiplier length decreases as their lengths approach $X$. +The smaller cutoffs $Y_j$ will keep the truncated products within +the comparison allowance $X^{\eta\delta_j/4}$. +In the estimates for these later pieces, the weight factor $\delta_j^k$ +will absorb fixed polynomial losses in $k$ and $2^j$. +In the stated range $\log Y_J\ge\ell^{1/2}$, so every $Y_j$ exceeds +$2$ for a single sufficiently large $X$ threshold. For $i\ge0$ let +\[ + I_{ji}=\{p:Y_j^{2^{-i-1}}0$, one may take +\begin{equation} + R_j=\exp\left(C_{\rm len}(k^{1/4}+j+1) + \ell\delta_j^2/\sqrt k\right). + \label{model:length-bound} +\end{equation} +For every fixed $\eta>0$, a sufficiently large fixed $k_0$ ensures +$R_j\le X^{\eta\delta_j/4}$ for all $0\le j\le J$ and all $k$ in +the stated range. Thus $H_j$ satisfies the multiplier hypotheses of +Proposition~\ref{analytic:comparison}, with $\Delta=\delta_j/4$. +\end{lemma} + +\begin{proof} +In a block, a chosen monomial has prime exponents $e_p\in\{0,1,2\}$ +whose sum is at most $m_{ji}$. Its integer index is therefore at most +$\exp(m_{ji}2^{-i}\log Y_j)$. Since +\[ + \sum_{i\ge0}m_{ji}2^{-i} + \le\sum_{i\ge0}(k^{1/4}+j+i+1)2^{-i} + =2k^{1/4}+2j+4, +\] +we obtain \eqref{model:length-bound}. +Unique factorization shows that each index occurs in exactly one +prime-exponent pattern. The truncations only delete patterns. A +surviving coefficient is a product of local coefficients $1$, +$-\lambda(p)p^{-1/2-s}$, or $\xi_pp^{-1-2s}$, and hence is bounded by +$\tau(r)r^{-1/2-s}\le\tau(r)r^{-1/2}$. For example, +\[ + \sum_{r\le R}\tau(r)r^{-1/2} + =\sum_{ab\le R}(ab)^{-1/2} + \le2\sqrt R\sum_{a\le R}\frac1a + \ll\sqrt R\log(2R)\ll R^2\qquad(R\ge1). +\] +Finally, +\[ + \frac{\log R_j}{\ell\delta_j/4} + \le4C_{\rm len}\bigl(k^{-1/4}+(j+1)2^{-j}k^{-1/2}\bigr) + \le8C_{\rm len}k^{-1/4}. +\] +Here $(j+1)2^{-j}\le1$. Thus the fixed choice +$k_0\ge(8C_{\rm len}/\eta)^4$ suffices simultaneously for all $j$. +The coefficient estimate and this length bound verify both multiplier +conditions of Proposition~\ref{analytic:comparison}. +\end{proof} + +\begin{lemma}[Prime-sum moments for the integer model] +\label{model:integer-moments} +Let $\mathcal I$ be any set of primes at most $Y_0$, and put +\[ + B_{\mathcal I}(V)=\sum_{p\in\mathcal I} + \lambda(p)V(p)p^{-1/2-s}. +\] +If $k_0$ is a sufficiently large absolute constant, then +\begin{equation} + \frac1X\sum_{X\le|m|<2X}|B_{\mathcal I}(z_m)|^{64} + \ll\left(1+\sum_{p\in\mathcal I}\frac1p\right)^{32} + \label{model:64th-moment} +\end{equation} +uniformly in $\mathcal I,k,X$. +\end{lemma} + +\begin{proof} +First omit the deterministic prime $2$ and write +$a_p=\lambda(p)p^{-1/2-s}$. On expanding the model moment, any odd +prime that occurs just once has zero expectation. Group the remaining +terms by their partition of the $64$ positions into $q\le32$ parts of +sizes at least two. Since $|a_p|\le2$, for every part of size $r\ge2$ +we have $|a_p|^r\le2^{r-2}|a_p|^2$. Summing the distinct-prime choices +and then discarding distinctness bounds the moment by +\[ + C\sum_{q=1}^{32}\left(\sum_{p\in\mathcal I}|a_p|^2\right)^q + \ll\left(1+\sum_{p\in\mathcal I}\frac1p\right)^{32}. +\] +Restoring the prime $2$ changes only the constant, by +$|u+v|^{64}\le2^{63}(|u|^{64}+|v|^{64})$ and $|a_2c|\le\sqrt2$. + +For completeness the passage to integers needs no estimate for primes +in progressions. For each ordered $64$-tuple of primes, the product +of its character values is periodic modulo the product of its odd +primes, which is at most $Y_0^{64}$. Its absolute value is at most one. +The arithmetic mean over the two integer intervals $X\le|m|<2X$ differs from its +complete-residue mean by $O(Y_0^{64}/X)$. The complete-residue mean is +exactly the independent-model mean, by the Chinese remainder theorem +and the counts of $0,1,-1$ for the Legendre symbol. There are at most +$Y_0^{64}$ tuples and each coefficient has absolute value at most +$2^{64}$. Thus the discrepancy between that arithmetic mean and the +model moment is +\[ + O(Y_0^{128}/X)=O(X^{-1+128/\sqrt k})=O(X^{-1/2}) +\] +after requiring $\sqrt{k_0}\ge256$. Since the number of integers in +these intervals is $O(X)$, this proves \eqref{model:64th-moment} with +its normalization by $X$. If endpoints are not integers, the same +period-counting argument changes only its absolute constant. +\end{proof} + +\begin{proposition}[Simultaneous product event]\label{model:good-event} +Except for $O(Xk^{-2})$ integers in $X\le|m|<2X$, the following +inequalities hold simultaneously: +\begin{align} + \frac12\le H_j(z_m)P_j^{\mathrm{eu}}(z_m)&\le2 + &&(0\le j\le J), + \label{model:good-mollifier}\\ + \frac{P_0^{\mathrm{eu}}(z_m)}{P_j^{\mathrm{eu}}(z_m)} + &\ge2^{-jk/8} &&(1\le j\le J), + \label{model:good-ratio}\\ + P_0^{\mathrm{eu}}(z_m)&\ge2^{-Jk/8}. + \label{model:good-full-product} +\end{align} +The implied constant and the lower threshold $k_0$ do not depend on +$k,j,X$. +\end{proposition} + +\begin{proof} +For a block $I=I_{ji}$ write $B=B_I(z_m)$. The elementary expansion +$\log(1+w)=w+O(|w|^2)$ at all sufficiently large primes, together with +\eqref{model:block-mass}, gives +\begin{equation} + \sup_{|z|=2}|K_{ji}(z_m,z)|\le e^{2|B|+C}, + \qquad K_{ji}(z_m,1)\ge e^{-|B|-C}. + \label{model:pointwise-block} +\end{equation} +The finitely many smaller primes are included using +\eqref{model:local-bounds} at $z=1$ and the direct upper bound +$\prod_{\nu}(1+2p^{-1/2})$ on $|z|=2$; they change $C$ by an absolute +amount. Thus no nonvanishing assertion on the radius-two circle is +required. Cauchy's coefficient estimate now gives, with $m=m_{ji}$, +\[ + \frac{|T_{ji}(z_m)-K_{ji}(z_m,1)|}{K_{ji}(z_m,1)} + \le C2^{-m}e^{3|B|}. +\] +If every block satisfies $|B_{I_{ji}}(z_m)|\le m_{ji}/100$, the last +quantity is at most $Ce^{-c m_{ji}}$ for a fixed $c>0$. The sum over +$i$ is $O(e^{-c(k^{1/4}+j)})$. By enlarging $k_0$, the product over +blocks of the ratios $T_{ji}(z_m)/K_{ji}(z_m,1)$ lies between $1/2$ +and $2$. +Since $\prod_iK_{ji}(z_m,1)=(P_j^{\mathrm{eu}}(z_m))^{-1}$, +this proves \eqref{model:good-mollifier} on the specified event. +The number excluded, divided by $X$, is at most +\[ + C\sum_{j=0}^J\sum_{i\ge0}(k^{1/4}+j+i)^{-64} + \ll (k^{1/4})^{-62}=k^{-31/2}\ll k^{-2}, +\] +by Lemma~\ref{model:integer-moments} and +\eqref{model:block-mass}. The sum may be extended to all $i$ because +only nonempty blocks impose an event. + +The real logarithm is available by positivity, and the same local +expansion, including the finitely many small primes separately, gives +for every prime set $\mathcal I$ +\begin{equation} + \log\prod_{p\in\mathcal I}D_p(s,z_m)^{-1} + =B_{\mathcal I}(z_m)+O\left(\sum_{p\in\mathcal I}p^{-1}\right). + \label{model:log-product} +\end{equation} +For $Y_j0. + \label{model:finite-Euler} +\end{equation} +All bounds in this subsection are independent of $Q$. At fixed $Q$ +the product has the absolutely convergent expansion +\begin{equation} + \mathcal L_Q(b)= + \sum_{\substack{n\ge1\\p\mid n\Rightarrow p\le Q}} + \lambda(n)Z(n)n^{-1/2-b}. + \label{model:finite-expansion} +\end{equation} +Absolute convergence follows by multiplying the finitely many local +geometric series; their absolute sums are bounded by +$\prod_{p\le Q}(1-p^{-1/2-\Re b})^{-2}$. + +\begin{lemma}[Exact shifted products]\label{model:exact-shifts} +Let $0Y_0}p^{-1-2s}. +\] +This is a positive real random variable. The same expansion gives +\[ + \mathbb E D_p(s,Z)^{-1}=1+O(p^{-1-2s}),\qquad + \mathbb E D_p(s,Z)^{-2}=1+O(p^{-1-2s}). +\] +The first error may have either sign. Nevertheless, the elementary +product bound $|\prod(1+e_p)-1|\le\exp(\sum|e_p|)-1$ and +independence show that +\begin{equation} + \mathbb EU=1+O(\Xi),\qquad \mathbb EU^2=1+O(\Xi). + \label{model:residual-moments} +\end{equation} +Indeed \eqref{model:prime-tail} and $s\log Y_0=\sqrt k$ give +\[ + \Xi\ll\int_{2\sqrt k}^{\infty}e^{-v}\frac{dv}v + \ll e^{-2\sqrt k}/\sqrt k, +\] +so $\Xi$ is uniformly small after choosing $k_0$. Finally, +\[ + \|U-1\|_2^2=\mathbb EU^2-2\mathbb EU+1\ll\Xi. +\] +This uses both moment estimates in \eqref{model:residual-moments} and +proves \eqref{model:exact-distance}. +\end{proof} + +\begin{lemma}[Relative truncation in mean square] +\label{model:relative-truncation} +For every $b$ with $\Re b>0$, uniformly in $Q\ge Y_0$, +\begin{equation} + \|(H_j-(P_j^{\mathrm{eu}})^{-1})\mathcal L_Q(b)\|_2 + \le \left(\exp\left(C\sum_i2^{-m_{ji}}\right)-1\right) + \|(P_j^{\mathrm{eu}})^{-1}\mathcal L_Q(b)\|_2. + \label{model:relative-error} +\end{equation} +In particular the relative factor is +$O(2^{-k^{1/4}-j})$. +\end{lemma} + +\begin{proof} +For a block $I=I_{ji}$ let +$\mathcal L_I(b)=\prod_{p\in I}D_p(b,Z)^{-1}$. We claim there are +fixed positive constants $c_*,C_*$ such that +\begin{equation} + \|K_{ji}(Z,1)\mathcal L_I(b)\|_2\ge c_*,\qquad + \sup_{|z|=2}\|K_{ji}(Z,z)\mathcal L_I(b)\|_2\le C_*. + \label{model:block-two-norms} +\end{equation} +For the first assertion, at a large odd prime the exact local ratio is +\[ + \frac{D_p(s,Z)}{D_p(b,Z)} + =1+\lambda(p)Z(p)p^{-1/2}(p^{-b}-p^{-s})+O(p^{-1}). +\] +The centered linear term shows that its local second moment is +$1+O(p^{-1})$; for all sufficiently large primes it is at least +$1-C/p\ge1/2$. Their product is bounded below by +$\exp(-2C\sum_{p\in I}1/p)$, which is a fixed positive constant by +\eqref{model:block-mass}. At each of the finitely many smaller primes, +including $2$, \eqref{model:local-bounds} gives the pointwise lower bound +\[ + \left|\frac{D_p(s,Z)}{D_p(b,Z)}\right| + \ge\frac{(1-p^{-1/2})^2}{(1+p^{-1/2})^2}>0. +\] +Their finite product is also bounded below. This proves the first +assertion of \eqref{model:block-two-norms}. + +For the second, on $|z|=2$ the local quotient is +\[ + \frac{1-\lambda(p)Z(p)p^{-1/2-s}z + +\xi_p Z(p)^2p^{-1-2s}z^2}{D_p(b,Z)} + =1+\lambda(p)Z(p)p^{-1/2}(p^{-b}-zp^{-s})+O(p^{-1}) +\] +at large odd primes, uniformly in $z$ and $b$. Its second moment is +$1+O(p^{-1})$, and therefore its product is bounded above, again by +\eqref{model:block-mass}. At small primes use the direct numerator +upper bound and \eqref{model:local-bounds}. The numerator is permitted +to vanish; only an upper bound has been used on this circle. + +Apply Cauchy's coefficient formula to the polynomial +$z\mapsto K_{ji}(Z,z)\mathcal L_I(b)$ with values in $L^2$. +For $m=m_{ji}$, Minkowski's inequality and +\eqref{model:block-two-norms} give +\[ + \|(T_{ji}(Z)-K_{ji}(Z,1))\mathcal L_I(b)\|_2 + \le C_*\sum_{h>m}2^{-h}\le C_*2^{-m}. +\] +Dividing by the positive lower bound in +\eqref{model:block-two-norms} makes this a relative error +$\varepsilon_i=C2^{-m_{ji}}$. + +To see explicitly how relative errors combine, put +$A_i=K_{ji}(Z,1)\mathcal L_I(b)$ and +$B_i=T_{ji}(Z)\mathcal L_I(b)$. Then +$\|B_i-A_i\|_2\le\varepsilon_i\|A_i\|_2$ and +$\|B_i\|_2\le(1+\varepsilon_i)\|A_i\|_2$. +Variables belonging to distinct blocks and to the residual primes +$Y_j0$ such that, uniformly for every real $\theta$ +and every cutoff $Q\ge Y_0$, +\begin{align} + \|H_0(Z)\mathcal L_Q(s/2+i\theta s)\|_2 + &\ll(1+|\theta|)^C, + \label{model:half-shift}\\ + \|H_0(Z)\mathcal L_Q(s)-1\|_2 + &\ll e^{-c_0 k^{1/4}}, + \label{model:mollified-distance}\\ + \|H_j(Z)\mathcal L_Q((1+i\theta)/\ell)\|_2 + &\ll (1+|\theta|)^C(k2^j)^C + \qquad(0\le j\le J). + \label{model:unit-shift} +\end{align} +\end{proposition} + +\begin{proof} +In \eqref{model:general-exact-norm}, first take +$\alpha=s/2$, $t=\theta s$, and $j=0$. +Then $h/\min(\alpha,s)=3+2|\theta|$ and +$\alpha\log Y_0=\sqrt k/2$. This proves +\eqref{model:half-shift} with the exact multiplier; use +Lemma~\ref{model:relative-truncation} to replace it by $H_0$. +For \eqref{model:unit-shift}, take $\alpha=1/\ell$ and +$t=\theta/\ell$. Since $k\ge1$, +\[ + h/\min(\alpha,s)=1+k+|\theta|, + \qquad \alpha\log Y_j=\delta_j^2/\sqrt k. +\] +The bound follows from \eqref{model:general-exact-norm} after increasing +the fixed exponent $C$, and then from relative truncation. +Finally, \eqref{model:exact-distance} bounds the distance from one for +the exact multiplier and also bounds its norm. The triangle inequality +and \eqref{model:relative-error} give +\[ + \|H_0\mathcal L_Q(s)-1\|_2 + \ll 2^{-k^{1/4}}+e^{-\sqrt k}k^{-1/4} + \ll e^{-c_0k^{1/4}}. +\] +\end{proof} + +\subsection{Fourier representations and the first weight} + +We have obtained bounds for the mollified finite Euler products at the +three shifts needed below. Fourier inversion now converts these bounds +into estimates for the actual weights. For the first piece, the main +term is $A_x$. Its estimate combines the power-to-exponential comparison +with the cutoff tail and the exponentially small mollifier error. + +We use the Fourier convention +\[ + \widehat g(\theta)=\int_{\mathbb R}g(y)e^{i\theta y}\,dy, + \qquad + g(y)=\frac1{2\pi}\int_{\mathbb R}\widehat g(\theta)e^{-i\theta y} + \,d\theta. +\] +The following elementary bound includes negative real arguments, which +occur inside the gamma integral. + +\begin{lemma}[Global approximation of the truncated power] +\label{model:global-power-approximation} +For each fixed nonnegative integer $r$, if $k\ge2r+4$, then for every +$z\in\mathbb R$, +\begin{equation} + \left|\frac{d^r}{dz^r} + \left((1-z/k)_+^k-e^{-z}\right)\right| + \le\frac{C_r}{k}(1+|z|)^2e^{-z}. + \label{model:global-power-bound} +\end{equation} +\end{lemma} + +\begin{proof} +For $zC+2$. Their integral +is $O((k/\delta_j)^{C_r}(k2^j)^C\delta_j^k)$, which proves +\eqref{model:later-piece-norm} after fixing $C_5$. + +For the first piece, Lemma~\ref{model:first-Fourier-error} and the +same finite-product expansion give +\begin{equation} + S_{0,Z}(x)-A_x\mathcal L_Q(s) + =\frac1{2\pi}\int_{\mathbb R}\widehat g_x(\theta) + \mathcal L_Q(s/2+i\theta s)\,d\theta. + \label{model:first-Fourier-representation} +\end{equation} +To check the scaling, at an integer index $n$ put +$y=k\log n/\ell=s\log n\ge0$. Fourier inversion for $g_x$ then +reads +\[ + w_{0,x}(\log n/\ell)-A_x n^{-s} + =\frac1{2\pi}\int\widehat g_x(\theta) + n^{-s/2-i\theta s}\,d\theta, +\] +which is exactly the coefficient identity needed in +\eqref{model:first-Fourier-representation}. +Use \eqref{model:half-shift} and +\eqref{model:first-Fourier-decay} with $r>C+2$ to bound the norm of +\eqref{model:first-Fourier-representation} after multiplication by +$H_0$ by $O(k^{-1})$. By \eqref{model:mollified-distance}, +\[ + \|H_0S_{0,Z}-A_x\|_2 + \le \|H_0(S_{0,Z}-A_x\mathcal L_Q(s))\|_2 + +A_x\|H_0\mathcal L_Q(s)-1\|_2 + \ll k^{-1}+e^{-c_0k^{1/4}}\ll k^{-1}. +\] +This proves \eqref{model:first-piece-norm}. + +All smoothness orders used here are fixed after the absolute exponent +in Proposition~\ref{model:shifted-norms}, and before choosing $k_0$. +The derivative estimates for the weights, the inequality +$s\le\ell^{-2/5}$, and the lower bound +$\delta_J\ge\ell^{-1/10}$ then give a single $X$ threshold for the +whole parameter range. We have not used the event of +Proposition~\ref{model:good-event} anywhere in these model norm +arguments. Nor is a passage to an infinite Euler cutoff required: +the coefficient identities hold for every sufficiently large finite +$Q$, and all norm estimates are uniform in that cutoff. +\end{proof} diff --git a/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/setup.tex b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/setup.tex new file mode 100644 index 0000000000000000000000000000000000000000..194b9add94783fe1c86a7471585e3e7d9c2d59e4 --- /dev/null +++ b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/setup.tex @@ -0,0 +1,181 @@ +\section{Twist families and the integer model}\label{sec:setup} + +We first reduce upper bounds for arbitrary twists to a fixed finite +family of curves with coprime twisting parameters. This gives exact +conductor formulas while preserving the bounds for nonnegative sums +needed later. We then define the probability model for complete integer +residue averages. + +We use unitary normalization: +\[ + L_F(s)=L(F,s+1/2)=\sum_{n\ge1}\lambda_F(n)n^{-s}, + \qquad q_F=\operatorname{cond}(F), + \qquad C_F=\frac{\sqrt{q_F}}{2\pi}. +\] +The series converges absolutely in \(\Re s>1\). +Modularity and the local rules for the Hasse--Weil \(L\)-function give +real multiplicative coefficients and inverse Euler factors +\begin{equation}\label{eq:setup-euler} + 1-\lambda_F(p)p^{-s}+\xi_{F,p}p^{-2s}, + \qquad \xi_{F,p}=\mathbf 1_{p\nmid q_F}. +\end{equation} +At a good prime the two factor parameters have modulus one by Hasse's +bound \cite[Chapter~V, Theorem~2.3.1(a)]{Silverman2009}. +At a multiplicative prime there is one parameter, of modulus +\(p^{-1/2}\), and at an additive prime the factor is one +\cite[Definitions~17--18 and Theorem~19]{DokchitserAnni2014}. +In particular, +\begin{equation}\label{eq:setup-coefficients} + |\lambda_F(n)|\le\tau(n). +\end{equation} +The completed function +\[ + \Lambda_F(s)=C_F^s\Gamma(s+1/2)L_F(s) +\] +is entire of finite order and satisfies +\begin{equation}\label{eq:setup-fe} + \Lambda_F(s)=\epsilon_F\Lambda_F(1-s),\qquad \epsilon_F\in\{1,-1\}. +\end{equation} +Analytic continuation and the functional equation follow from +modularity \cite[Theorem~A]{BreuilConradDiamondTaylor2001} +and the standard completion +\cite[Appendix~C, Theorems~16.3--16.4]{Silverman2009}. +The standard finite-order bounds follow, for example, from the split +Mellin integral of the modular cusp form and its Fricke transform. +They also give polynomial growth in every fixed vertical strip for each +fixed curve \(F\), independently of the averaged estimates proved below. +Indeed, enclose the strip in \(a\le\Re s\le b\), with \(a\le-1\) and +\(b\ge2\). Absolute convergence bounds \(L_F\) on the right boundary; +\eqref{eq:setup-fe} and Stirling's formula give +\(L_F(a+it)\ll_{F,a}(1+|t|)^{1-2a}\) on the left boundary. +Take \(A=1-a\) and an integer \(N>1-2a\), so that +\(L_F(s)/(s+A)^N\) is bounded on both boundaries. For \(\varepsilon>0\) and \(0<\kappa<\pi/(b-a)\), multiply +this quotient by +\[ + \exp\left\{-\varepsilon\cos\left(\kappa + \left(s-\frac{a+b}{2}\right)\right)\right\}. +\] +The multiplier has modulus at most one on the vertical boundaries and +at most \(\exp(-c\varepsilon\cosh(\kappa\Im s))\) on the horizontal +sides, for a fixed \(c>0\). +This dominates the finite-order growth. The maximum principle on +expanding rectangles, followed by \(\varepsilon\downarrow0\), therefore +gives \(L_F(\sigma+it)\ll_{F,a,b}(1+|t|)^N\) on the strip. +These individual bounds justify contour displacements. Their constants +may depend on the fixed curve; estimates uniform in the varying twist +parameters will be proved separately. + +\subsection{A finite family closed under reduction} + +Fix the primes +\[ + S=\{p:p\mid 2q_E\},\qquad Q_S=\prod_{p\in S}p. +\] +Let \(\mathcal F\) be the finite set, up to \(\Q\)-isomorphism, of curves +obtained from \(E\) by twisting by signed squarefree products of primes +in \(S\). The curve \(E\) is included. Every \(F\in\mathcal F\) has good +reduction outside \(S\). + +Call a signed squarefree integer \(d\) \emph{admissible} if +\[ + d\equiv1\pmod4,\qquad (d,Q_S)=1. +\] +For a dyadic \(X\), put +\[ + \mathcal A(X)=\{d:d\text{ admissible},\ X\le|d|<2X\}. +\] + +\begin{lemma}\label{setup:reduction} +For every \(F\in\mathcal F\) and signed squarefree \(b\), there are +\(F'\in\mathcal F\) and an admissible \(d\) such that +\[ + F^{(b)}\simeq (F')^{(d)},\qquad |d|\le |b|. +\] +The correspondence can be chosen to have bounded multiplicity, uniformly +in \(b\). Every sum of nonnegative functions of these twists can +therefore be bounded by a fixed multiple of the corresponding sums over +\(\mathcal F\) and admissible parameters of no greater height. +\end{lemma} + +\begin{proof} +Write \(b=b_S b_0\), where \(b_S>0\) is the product of the primes of \(S\) +dividing \(b\). Then \(b_0\) is odd and prime to \(Q_S\). +Choose \(\varepsilon\in\{1,-1\}\) so that +\(d=\varepsilon b_0\equiv1\pmod4\), and put +\(F'=F^{(\varepsilon b_S)}\). +Quadratic twisting depends only on the square class and composes by +multiplication of square classes. Thus \(F'\) is in \(\mathcal F\) and +\((F')^{(d)}\simeq F^{(b)}\). +Moreover \(|d|=|b|/b_S\le |b|\). +There are at most \(2^{|S|+1}\) choices of the signed \(S\)-part. +Possible coincidences among the finitely many curves only change this +fixed multiplicity. +\end{proof} + +\begin{lemma}\label{setup:local-factors} +For \(F\in\mathcal F\) and admissible \(d\), +\begin{equation}\label{eq:setup-twist} + L_{F^{(d)}}(s)=\sum_{n\ge1}\lambda_F(n)\chi_d(n)n^{-s}, + \qquad q_{F^{(d)}}=q_F|d|^2, + \qquad \chi_d(n)=\left(\frac dn\right). +\end{equation} +Here the symbol is the Kronecker symbol and \(d=1\) has the untwisted +convention. For an arbitrary signed squarefree \(b\), the same good-prime +twisting rule holds at primes outside \(S\): the local trace is multiplied +by \((b/p)\) when \(p\nmid b\), and the local factor is one when \(p\mid b\). +\end{lemma} + +\begin{proof} +We compute the inverse local Euler factors using geometric Frobenius +on the inertia invariants of the dual of the rational Tate module, +and the conductor as the Artin conductor +\cite[Definitions~17--18 and Theorem~19]{DokchitserAnni2014}. +The rational Tate-module representation of a quadratic twist is the +original representation tensored with the corresponding quadratic +character. This follows from the isomorphism over the twisting extension, +whose conjugate differs by the scalar automorphism \([-1]\). + +An unramified scalar twist preserves the conductor and multiplies +Frobenius eigenvalues on inertia invariants by the character value. +Since an admissible \(d\) is an odd fundamental discriminant, its character +is unramified at every prime of \(S\). +At a prime \(p\mid d\), the representation of \(F\) is unramified and the +quadratic character is tamely ramified. The tensor product has no inertia +invariants, Swan conductor zero, and Artin conductor exponent two. +At all other primes the scalar twist is unramified. +Computing the inertia-invariant Euler factors and the conductor gives +\eqref{eq:setup-twist}. +For an arbitrary squarefree \(b\), these same computations apply at odd +primes outside \(S\), regardless of the character's behavior at two. +\end{proof} + +The constants in what follows are chosen uniformly over the finite set +\(\mathcal F\). +The nonincreasing height in Lemma~\ref{setup:reduction} is useful in the +second-moment induction: a dual squarefree parameter of absolute value +at most \(M/2\) remains in a smaller dyadic block after reduction. + +\subsection{Complete integer averages} + +Fix \(c\in\{1,-1\}\). For \(m\in\Z\), define a completely multiplicative +formal character on positive integers by +\[ + z_m(2)=c,\qquad z_m(p)=\left(\frac mp\right) + \quad(p\text{ odd}). +\] +Let \(Z\) be the completely multiplicative random model with \(Z(2)=c\) +and independent odd-prime values distributed by +\begin{equation}\label{eq:setup-model} + \Prob(Z(p)=0)=\frac1p,\qquad + \Prob(Z(p)=1)=\Prob(Z(p)=-1)=\frac{1-1/p}{2}. +\end{equation} +For every polynomial involving only finitely many prime values, +its expectation is the average over a complete residue system for the +corresponding odd-prime periods. This follows from the Chinese remainder +theorem and the equal numbers of nonzero quadratic residues and +nonresidues modulo each odd prime. + +We use this model for averages over all integers \(m\). +Nonnegative estimates can subsequently be restricted to admissible +squarefree \(d\), separated into the two classes \(\chi_d(2)=c\); +on either class, \(z_d(n)=\chi_d(n)\) for every \(n\). diff --git a/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/tail.tex b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/tail.tex new file mode 100644 index 0000000000000000000000000000000000000000..c06da630933340a594e94d9f656b61df193b798d --- /dev/null +++ b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/tail.tex @@ -0,0 +1,247 @@ +\section{Nonvanishing and the rank-weighted tail}\label{sec:tail} + +We now combine the transferred model estimates, the integer product +event, and the terminal mean square to count large orders of vanishing. +A separate bound for each individual rank then converts this count into +the rank-weighted tail. The companion density theorem enters only in +the final subsection, after the tail theorem is proved. +The constants and the fixed +lower threshold \(k_0\) are increased finitely many times in this section. +All choices depend only on the fixed family and the already fixed +smoothness orders. + +\Needspace{11\baselineskip} +\subsection{Counting large orders of vanishing} + +\begin{proposition}\label{tail:count} +There are \(k_0\), \(X_0\), and \(C\), depending on \(E\), such that for +every \(F\in\mathcal F\), every dyadic \(X\ge X_0\), and every integer +\[ + k_0+1\le k\le(\log X)^{3/5}, +\] +one has +\[ + \#\{d\in\mathcal A(X):a(F^{(d)})>k\}\le C Xk^{-2}. +\] +\end{proposition} + +\begin{proof} +Write \(\ell=\log X\), and first consider the functional-equation sign +\((-1)^k\), with \(k_0\le k\le\ell^{3/5}\). +Fix \(c=\pm1\), and use the weights and partition of +Section~\ref{sec:weights}. We write \(P_j^{\rm eu}\) for the positive +Euler products of Section~\ref{sec:model}. + +Corollary~\ref{weights:comparison-interface} and +Lemma~\ref{model:mollifier-length} permit +Proposition~\ref{analytic:comparison} to be applied to \(H_jS_j\), +for \(0\le j\le J\), with \(\Delta=\delta_j/4\). +By the first assertion of Proposition~\ref{model:main-model-estimates}, +outside \(O(X/k^2)\) integers in \(X\le|m|<2X\), +\begin{equation}\label{eq:tail-main-good} + |H_0(z_m)S_{0,z_m}(m/X)-A_{m/X}|<\frac12 A_{m/X}. +\end{equation} +Indeed \(A_x=(C_F|x|)^s\Gamma(1+s)\) is bounded above and below by positive +constants on the fixed \(x\)-range, uniformly for \(s=k/\ell\le\ell^{-2/5}\). +Chebyshev's inequality applies to the transferred \(O(k^{-2})\) +mean-square error. The exponentially small comparison error is absorbed +uniformly. + +For \(1\le j\le J\), the second model estimate gives +\[ + \frac1X\sum_m\Psi(m/X)|H_j(z_m)S_{j,z_m}(m/X)|^2 + \ll (k2^j)^{2C_5}2^{-2jk}+e^{-c\delta_j\ell} + \ll 2^{-3jk/2}. +\] +The last inequality follows first by increasing fixed \(k_0\) to absorb +the polynomial factor. For the comparison error, use +\[ + \delta_j\ell\ge\ell^{9/10},\qquad + jk\ll\ell^{3/5}\log\ell, +\] +and then increase one \(X_0\) for all the permitted \(k,j\). +The terminal estimate of Lemma~\ref{weights:terminal-small} gives +\[ + \frac1X\sum_{d\in\mathcal A(X)} + |S_{*,\chi_d}(d/X)|^2\ll 2^{-3Jk/2}. +\] +Chebyshev and summation of the resulting geometric probabilities imply, +outside \(O(X/k^2)\) further admissible parameters, +\begin{equation}\label{eq:tail-other-good} + |H_j(\chi_d)S_{j,\chi_d}(d/X)|\le2^{-jk/2}\quad(1\le j\le J), + \qquad + |S_{*,\chi_d}(d/X)|\le2^{-Jk/2}. +\end{equation} +Here \(\sum_{j\ge1}2^{-jk/2}\ll k^{-2}\) after fixing \(k_0\), and \(J\ge1\) +for sufficiently large \(X\). + +Intersect these events with the event in +Proposition~\ref{model:good-event}. Its additional exceptional set is +also \(O(X/k^2)\). On the intersection, +\[ + \frac12\le H_jP_j^{\rm eu}\le2,\qquad + P_j^{\rm eu}\le 2^{jk/8}P_0^{\rm eu},\qquad + 1\le 2^{Jk/8}P_0^{\rm eu}. +\] +Choose a fixed \(a_*>0\) with \(A_x\ge a_*\) for all the parameters. +Equation~\eqref{eq:tail-main-good} yields +\[ + |S_{0,\chi_d}(d/X)|\ge\frac{a_*}{4}P_0^{\rm eu}. +\] +Equation~\eqref{eq:tail-other-good} yields +\[ + \sum_{j=1}^J|S_{j,\chi_d}(d/X)|+|S_{*,\chi_d}(d/X)| + \le P_0^{\rm eu} + \left(2\sum_{j=1}^J2^{-3jk/8}+2^{-3Jk/8}\right). +\] +For a sufficiently large fixed \(k_0\), the last parenthesis is less +than \(a_*/4\). The entire weighted sum is therefore nonzero. +Lemma~\ref{weights:vanishing} excludes the simultaneous conditions +\(a(F^{(d)})>k\) and \(\epsilon_{F^{(d)}}=(-1)^k\). +Including both values of \(c\), we have proved +\begin{equation}\label{eq:tail-parity-count} + \#\{d\in\mathcal A(X): + a(F^{(d)})>k,\ \epsilon_{F^{(d)}}=(-1)^k\} + \ll Xk^{-2}. +\end{equation} +For the other functional-equation sign, apply +\eqref{eq:tail-parity-count} at \(k-1\). A rank exceeding \(k\) also exceeds +\(k-1\), and \((k-1)^{-2}\ll k^{-2}\). +This proves the proposition. +\end{proof} + +\subsection{A uniform bound for an individual rank} + +\begin{lemma}\label{tail:jensen} +Uniformly for \(F\in\mathcal F\) and \(d\in\mathcal A(X)\), +\[ + a(F^{(d)})\ll_E\log(3X). +\] +\end{lemma} + +\begin{proof} +Put \(L=L_{F^{(d)}}\) and \(C_d=C_F|d|\). +On \(\Re s=5\), absolute convergence and +\eqref{eq:setup-coefficients} give a uniform bound. +On \(\Re s=-1\), the functional equation is +\[ + L(s)=\epsilon_{F^{(d)}} C_d^{\,1-2s} + \frac{\Gamma(3/2-s)}{\Gamma(1/2+s)}L(1-s). +\] +At \(s=-1+it\), the modulus of the gamma quotient equals +\[ + |(-1/2+it)(1/2+it)(3/2+it)|. +\] +Since \(L(2-it)\) is uniformly bounded, +\[ + |L(-1+it)|\ll_E X^3(1+|t|)^3. +\] +Apply the strip principle to \(L(s)/(s+2)^4\) on +\(-1\le\Re s\le5\). To see that the possibly conductor-dependent +finite-order growth in the strip introduces no new constant, first +multiply by +\[ + \exp\!\left(-\varepsilon + \cos\frac{\pi(s-2)}{12}\right),\qquad \varepsilon>0. +\] +Its modulus is at most one on this strip and decays faster than any +finite-order growth as \(|\Im s|\to\infty\). +The maximum principle on expanding rectangles gives the bound from +the two vertical sides. Letting \(\varepsilon\) decrease to zero shows +that \(L(s)/(s+2)^4\ll_E X^3\) throughout the strip. +In particular, the maximum of \(|L|\) on the closed disk +\(|s-2|\le5/2\) is \(O_E(X^3)\). + +At the center, the Euler factors and their parameter bounds give +\[ + |L(2)|\ge \prod_p(1+p^{-2})^{-2} + =\left(\frac{\zeta(4)}{\zeta(2)}\right)^2>0. +\] +Jensen's formula, with inner radius \(2\) and outer radius \(5/2\), +therefore bounds the number of zeros in the inner disk, counted with +multiplicity, by \(O_E(\log(3X))\). +The point \(1/2\) lies in that inner disk. This proves the result. +\end{proof} + +\subsection{Summing the integer tails} + +\begin{proof}[Proof of Theorem~\ref{thm:tail}] +We first work in \(\mathcal A(X)\) for a fixed \(F\in\mathcal F\). +Let +\[ + T_{F,X}(k)=\#\{d\in\mathcal A(X):a(F^{(d)})>k\}, + \qquad K=\lfloor(\log X)^{3/5}\rfloor. +\] +For an integer \(R\ge k_0+1\) and \(X\) large enough that \(K>R\), +the elementary integer-tail bound gives +\begin{align} + \sum_{\substack{d\in\mathcal A(X)\\a(F^{(d)})>R}}a(F^{(d)}) + &\le R T_{F,X}(R) + +\sum_{k=R}^{K-1}T_{F,X}(k) + +C_E\log X\,T_{F,X}(K) \notag\\ + &\ll_E \frac X R+X(\log X)^{-1/5}. + \label{eq:tail-dyadic-mass} +\end{align} +For ranks between \(R+1\) and \(K\), the first two terms count the rank +exactly. For ranks exceeding \(K\), the last term bounds the remaining +mass by Lemma~\ref{tail:jensen}. +Proposition~\ref{tail:count} supplies every counting estimate used here. +In particular the last term is +\(O_E(X\log X/K^2)=O_E(X(\log X)^{-1/5})\). +The constant in \eqref{eq:tail-dyadic-mass} is independent of \(R\). + +For completeness, fix \(R\) and cover \(0<|d|\le Y\) by dyadic blocks. +Enlarge the last partial block to a full block, using nonnegativity. +The sum of their left endpoints is less than \(2Y\). +The finitely many blocks below the threshold for +\eqref{eq:tail-dyadic-mass} contribute a finite number \(B_{E,R}\). +For the error term in the remaining blocks, split at \(X=\sqrt Y\). +The smaller blocks contribute \(O_E(\sqrt Y)\), and in the larger ones +\(\log X\ge\frac12\log Y\). +Consequently +\[ + \sum_{\substack{d\ {\rm admissible}\\0<|d|\le Y\\a(F^{(d)})>R}} + a(F^{(d)}) + \le B_{E,R}+\frac{C_EY}{R} + +O_E\bigl(\sqrt Y+Y(\log Y)^{-1/5}\bigr). +\] +After division by \(Y\) and passage to the limsup, the desired +\(C_E/R\) bound holds for each \(F\in\mathcal F\). +Lemma~\ref{setup:reduction}, its bounded multiplicity, and the finite +maximum of these constants prove the same bound for every original +signed squarefree parameter of \(E\). +\end{proof} + +\subsection{The mean} + +\begin{proof}[Proof of Theorem~\ref{thm:mean}] +Write \(N(Y)=\#\mathcal D(Y)\) and let \(N_j(Y)\) count the parameters +of analytic rank \(j\). +The elementary squarefree sieve gives +\[ + N(Y)=2\sum_{n\le Y}\mu(n)^2 + =\frac{2Y}{\zeta(2)}+O(\sqrt Y). +\] +Indeed, expand \(\mu(n)^2=\sum_{r^2\mid n}\mu(r)\), interchange the +finite sums, and bound the omitted tail of +\(\sum_r\mu(r)/r^2=1/\zeta(2)\). + +By the analytic density theorem \eqref{eq:density-input}, +\(N_0(Y)/N(Y)\to1/2\) and \(N_1(Y)/N(Y)\to1/2\). +Thus \(N(Y)-N_0(Y)-N_1(Y)=o(Y)\). +For every fixed integer \(R\ge R_E\), +\[ + \sum_{\substack{d\in\mathcal D(Y)\\2\le a(E^{(d)})\le R}} + a(E^{(d)}) + \le R\bigl(N(Y)-N_0(Y)-N_1(Y)\bigr)=o_{E,R}(Y). +\] +Theorem~\ref{thm:tail} now implies +\[ + \limsup_{Y\to\infty}\frac1Y + \sum_{\substack{d\in\mathcal D(Y)\\a(E^{(d)})\ge2}}a(E^{(d)}) + \le\frac{C_E}{R}. +\] +Let \(R\to\infty\). The left side is zero by nonnegativity. +The total rank sum is consequently \(N_1(Y)+o_E(Y)\). +Dividing by \(N(Y)\) proves the limit \(1/2\). +\end{proof} diff --git a/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/weights.tex b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/weights.tex new file mode 100644 index 0000000000000000000000000000000000000000..2e9b011923fa5bbd729db1b0b74e7e38233b5baf --- /dev/null +++ b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/build/sections/weights.tex @@ -0,0 +1,503 @@ +\section{Completed derivatives and their weights} +\label{sec:weights} + +A large analytic rank forces a completed derivative to vanish. For the +matching functional-equation sign, we express that vanishing as an exact +weighted-series identity, partition the series into short pieces, and +bound the remaining infinite piece using the second moments of +Section~\ref{sec:analytic}. +The short pieces will be treated by mollification in +Section~\ref{sec:model}. + +Fix a curve \(F\) in the finite family \(\mathcal F\), write +\(\lambda=\lambda_F\), and put \(C_F=\sqrt{q_F}/(2\pi)\). +The variable \(x\) will range over a fixed compact subset +\(\mathcal K\) of \(\mathbb R\setminus\{0\}\), chosen large enough to +contain the support of the averaging weight in +Proposition~\ref{analytic:comparison}. Derivative bounds in \(x\) are +understood on a fixed compact neighborhood of \(\mathcal K\) disjoint +from zero. All constants below may depend on this compact set and on +the fixed finite family. + +The order of choices is as follows. First fix the exponents in +Proposition~\ref{analytic:polynomial-moment}, and all the finite orders of +differentiation needed for Proposition~\ref{analytic:comparison}, the +Mellin inversion below, and the subsequent Fourier estimates. Next +choose a sufficiently large fixed integer \(k_0\). Finally choose one +lower bound for \(X\), valid simultaneously for all the integers +\begin{equation} + \ell=\log X,\qquad + k_0\le k\le \lfloor\ell^{3/5}\rfloor . + \label{weights:range} +\end{equation} +The estimates in this section respect this order. In particular, the +number of derivatives is never allowed to increase with \(k\) or \(X\). + +\subsection{The exact completed derivative identity} + +For \(k\ge1\), \(x\ne0\), and real \(u\), define +\begin{equation} + W_{k,x}(u)= + \int_0^\infty e^{-v} + \left(1-u+\frac{\log(C_F|x|v)}{\ell}\right)_+^k\,dv, + \qquad y_+=\max(y,0). + \label{weights:W} +\end{equation} +For every fixed choice of the parameters the integral is finite. +The weighted sum below is an infinite, absolutely convergent smoothed +Dirichlet series; its individual short pieces will be finite sums. + +\begin{lemma}[Completed derivative identity] +\label{weights:vanishing} +Let \(d\) be admissible, \(X\le |d|<2X\), and \(x=d/X\). Set +\[ + g_d(z)=L_{F^{(d)}}(1/2+z)(C_F|d|)^z\Gamma(1+z), + \qquad \epsilon_d=\operatorname{sign}(F^{(d)}). +\] +Then \(g_d\) is entire, \(g_d(-z)=\epsilon_d g_d(z)\), and +\begin{equation} + \begin{split} + \mathcal S_d + &:= + \sum_{n\ge1}\frac{\lambda(n)\chi_d(n)}{\sqrt n} + W_{k,x}(\ell^{-1}\log n)\\ + &=\frac{k!}{\ell^k}\frac{1}{2\pi i} + \int_{(2)}g_d(z)\frac{dz}{z^{k+1}}. + \end{split} + \label{weights:completed-integral} +\end{equation} +More precisely, +\begin{equation} + \bigl(1+\epsilon_d(-1)^k\bigr)\mathcal S_d + =\ell^{-k}g_d^{(k)}(0). + \label{weights:exact-derivative} +\end{equation} +Consequently, if \(a(F^{(d)})>k\) and +\(\epsilon_d=(-1)^k\), then +\begin{equation} + \sum_{n\ge1}\frac{\lambda(n)\chi_d(n)}{\sqrt n} + W_{k,d/X}(\ell^{-1}\log n)=0. + \label{weights:zero} +\end{equation} +\end{lemma} + +\begin{proof} +The completed function is +\[ + \Lambda_d(s)=(C_F|d|)^s\Gamma(s+1/2)L_{F^{(d)}}(s). +\] +Thus \(g_d(z)=(C_F|d|)^{-1/2}\Lambda_d(1/2+z)\). +Its entireness and reflection law follow from those of \(\Lambda_d\). + +For \(T>0\), Mellin inversion gives +\[ + \frac{1}{2\pi i}\int_{(2)}\frac{T^z}{z^{k+1}}\,dz + =\frac{(\log T)_+^k}{k!}. +\] +Insert the absolutely convergent Dirichlet series for +\(L_{F^{(d)}}(1/2+z)\), and use +\(\Gamma(1+z)=\int_0^\infty e^{-v}v^z\,dv\). +On this line all exchanges are absolutely convergent: the series is +dominated by \(\sum_n\tau(n)n^{-5/2}\), and the other two factors to be +integrated are dominated by +\(e^{-v}v^2\) and \(|2+it|^{-k-1}\). +The result is \eqref{weights:completed-integral}, because +\[ + \ell^{-1}\log(C_F|d|v/n) + =1-\ell^{-1}\log n+\ell^{-1}\log(C_F|x|v). +\] +This argument, or the same computation with absolute coefficient +values, also proves absolute convergence of the series. + +Let \(I_+\) and \(I_-\) denote the integrals of +\(g_d(z)z^{-k-1}/(2\pi i)\) on the upward oriented lines +\(\operatorname{Re}z=2\) and \(\operatorname{Re}z=-2\). +Shifting between these lines crosses only the pole at zero, and gives +\[ + I_+-I_-=\frac{g_d^{(k)}(0)}{k!}. +\] +The horizontal integrals tend to zero: in this fixed strip the +uncompleted \(L\)-function has polynomial growth, while the gamma +factor has exponential decay on horizontal segments tending to +infinity. Apparent gamma poles on the real axis are removable in +\(g_d\). Changing \(z\) to \(-z\), with orientations included, gives +\[ + I_-=(-1)^{k+1}\epsilon_d I_+. +\] +Multiplication by \(k!/\ell^k\) proves +\eqref{weights:exact-derivative}. Finally, the completing factor is +holomorphic and nonzero at zero. Hence \(a(F^{(d)})>k\) implies +\(g_d^{(k)}(0)=0\), and the stipulated sign makes the coefficient on +the left of \eqref{weights:exact-derivative} equal to two. +\end{proof} + +\subsection{Partition and derivative estimates} + +Fix a \(C^\infty\), nondecreasing function \(f_*\colon\mathbb R\to[0,1]\) +which is zero on \((-\infty,1/4]\) and one on \([1/2,\infty)\). +Define +\begin{equation} + J=\left\lfloor\frac{\log\ell}{10\log2}\right\rfloor,\qquad + \delta_j=2^{-j},\qquad + F_j(u)=f_*((1-u)/\delta_j)\quad(0\le j\le J). + \label{weights:scales} +\end{equation} +In particular, for sufficiently large \(X\), +\begin{equation} + J\ge1,\qquad + \ell^{-1/10}\le\delta_J<2\ell^{-1/10},\qquad + \frac{k}{\ell\delta_j}\le\ell^{-3/10} + \quad(0\le j\le J). + \label{weights:scale-bounds} +\end{equation} +Set +\begin{equation} + \begin{aligned} + w_{0,x}(u)&=F_0(u)W_{k,x}(u),\\ + w_{j,x}(u)&=(F_j(u)-F_{j-1}(u))W_{k,x}(u) + &&(1\le j\le J),\\ + w_{*,x}(u)&=(1-F_J(u))W_{k,x}(u). + \end{aligned} + \label{weights:partition} +\end{equation} +These weights sum exactly to \(W_{k,x}\). For \(V=\chi_d,z_m\), or \(Z\), +write +\begin{equation} + \begin{aligned} + S_{j,V}(x)&=\sum_{n\ge1} + \frac{\lambda(n)V(n)}{\sqrt n}w_{j,x}(\ell^{-1}\log n),\\ + S_{*,V}(x)&=\sum_{n\ge1} + \frac{\lambda(n)V(n)}{\sqrt n}w_{*,x}(\ell^{-1}\log n). + \end{aligned} + \label{weights:S} +\end{equation} +The first definition includes \(j=0\). All the formal character +values in these definitions have modulus at most one. The sums +through \(j=J\) have length at most \(X^{1-\delta_j/4}\), and +\begin{equation} + \operatorname{supp} w_{j,x} + \subset[1-\delta_j,1-\delta_j/4]\quad(1\le j\le J). + \label{weights:short-support} +\end{equation} +Indeed \(F_j-F_{j-1}\) vanishes when \(1-u\le\delta_j/4\) or +\(1-u\ge\delta_j\). The terminal weight is supported in +\(u\ge1-\delta_J/2\). + +\begin{lemma}[Fixed-order weight bounds] +\label{weights:derivatives} +Fix an integer \(r\ge0\), and then take \(k_0\ge r+2\). +For \(a,b\ge0\), \(a+b\le r\), uniformly in \eqref{weights:range}, +\(x\in\mathcal K\), and the indicated arguments, one has +\begin{align} + |\partial_u^a\partial_x^b w_{j,x}(u)| + &\le C_r(k/\delta_j)^r\delta_j^k + &&(1\le j\le J,\ u\in\mathbb R), \label{weights:short-derivatives}\\ + |\partial_u^a\partial_x^b w_{0,x}(u)| + &\le C_r k^r + &&(u\ge-\log2/\ell). \label{weights:main-derivatives} +\end{align} +There is also \(c>0\), independent of \(r,k,X\), such that, with +\(\delta=\delta_J\) and \(n=e^{\ell u}>0\), +\begin{equation} + |\partial_u^a\partial_x^b w_{*,x}(u)| + \le C_r(k/\delta)^r\delta^k e^{-cn/X}. + \label{weights:terminal-derivatives} +\end{equation} +Changing the fixed compact neighborhood of \(\mathcal K\) changes +only the constants. +\end{lemma} + +\begin{proof} +It is convenient first to differentiate using +\(D_x=x\partial_x\). For +\[ + h=1-u+\ell^{-1}\log(C_F|x|v) +\] +and \(a+b\le r\), differentiation under the integral gives +\begin{equation} + \partial_u^aD_x^b h_+^k + =(-1)^a\ell^{-b}(k)_{a+b}h_+^{k-a-b}, + \label{weights:power-derivative} +\end{equation} +where \((k)_t=k(k-1)\cdots(k-t+1)\). +The choice \(k\ge r+2\) ensures enough continuous derivatives at +\(h=0\); domination for differentiating follows from the estimates +below. Ordinary \(x\)-derivatives are fixed linear combinations of +\(x^{-b}D_x^i\), \(i\le b\), and therefore satisfy the same bounds on +our compact set. + +Suppose \(1-u\le\delta'\), where \(\delta'>0\). For \(0\le t\le r\), +write \(m=k-t>0\) and \(a_t=m/(\ell\delta')\). The elementary +inequality \((1+q)_+^m\le e^{mq}\), valid for every real \(q\), gives +\begin{equation} + h_+^m + \le(\delta')^m(C_F|x|v)^{a_t}. + \label{weights:gamma-majorant} +\end{equation} +If \(\delta'=\delta_j\), then \(00\) implies +\[ + v>\frac{n}{C_F|x|X}. +\] +Retain half the exponential in the integral. Uniformly on our +compact set, +\begin{equation} + \begin{split} + \int_{\{h>0\}}e^{-v}(C_F|x|v)^{a_t}\,dv + &\le e^{-n/(2C_F|x|X)} + (C_F|x|)^{a_t} + \int_0^\infty e^{-v/2}v^{a_t}\,dv\\ + &=e^{-n/(2C_F|x|X)} + (C_F|x|)^{a_t}2^{1+a_t}\Gamma(1+a_t) + \le C e^{-cn/X}. + \end{split} + \label{weights:retained-exponential} +\end{equation} +Here \(a_t=(k-t)/(\ell\delta_J)\le\ell^{-3/10}\), so +\(2^{1+a_t}\Gamma(1+a_t)\) is bounded independently of \(k\). +The same Leibniz calculation now proves +\eqref{weights:terminal-derivatives}. All integrands used for +differentiation are dominated on compact sets by the displayed +integrable majorants, which also justifies +\eqref{weights:power-derivative} under the integral. +\end{proof} + +\begin{corollary}[Comparison interface] +\label{weights:comparison-interface} +For every fixed derivative order \(r\), the short weights satisfy +the smoothness assumptions of Proposition~\ref{analytic:comparison} +with derivative bounds \(\ell^{C_r}\), uniformly in \(j,k,X\). +They have length \(X^{1-\Delta_j}\), with +\[ + \Delta_j=\delta_j/4,\qquad + \tfrac14\ell^{-1/10}\le\Delta_j\le\tfrac14 . +\] +The deterministic term +\begin{equation} + s=k/\ell,\qquad A_x=(C_F|x|)^s\Gamma(1+s) + \label{weights:Ax} +\end{equation} +has uniformly bounded derivatives of each fixed order on +\(\mathcal K\), and is bounded above and below by positive constants. +The endpoint enlargement at \(n=1\) can be made inside the fixed +range \(n\ge1/2\). +\end{corollary} + +\begin{proof} +The bounds \(k\le\ell^{3/5}\) and +\(\delta_j^{-1}\le\ell^{1/10}\) make +\eqref{weights:short-derivatives} polynomial in \(\ell\). +Choose a fixed smooth function \(\chi\) equal to zero on +\((-\infty,-\log2]\) and equal to one on \([0,\infty)\). +For the comparison alone, replace \(w_{0,x}(u)\) on the real line +by +\[ + \widetilde w_{0,x}(u)=\chi(\ell u)w_{0,x}(u). +\] +It agrees with the original weight at every positive integer +\(n=e^{\ell u}\), and its extra derivatives cost only fixed powers +of \(\ell\), by \eqref{weights:main-derivatives}. Its left support +is \(u\ge-\log2/\ell\), exactly the enlargement \(n\ge1/2\). +For \(j\ge1\), the weights already vanish on a neighborhood of +\(u\le0\). After a fixed smooth dyadic localization \(n=Ny\), +the operator \(y\partial_y\) acts as \(\ell^{-1}\partial_u\), so +the same bounds give all the required seminorms in the scaled +variables. The endpoint extension has therefore taken place in +\(\log n\); no extension to a fixed negative value of \(u\) is used. + +Finally \(0A/2+2\) and \(D>A/2+2\), +and then choose \(k_0\ge r+2\). If derivatives required elsewhere +are of higher order, increase this fixed \(r\) first. +By Lemma~\ref{weights:derivatives}, differentiation on the +\(y\)-scale through order \(r\) gives +\[ + \left|(y\partial_y)^a T_N(y,x)\right| + \ll_r \ell^{C_r}\delta_J^k e^{-c'N/X} + \qquad(0\le a\le r), +\] +uniformly in \(x\in\mathcal K\). +There is no boundary term when integrating by parts in \(\log y\). +Consequently, +\begin{equation} + \sup_{x\in\mathcal K}|\widehat T_N(t,x)| + \ll_{r,D}\ell^{C_r}\delta_J^k + (1+N/X)^{-D}(1+|t|)^{-r}. + \label{weights:terminal-kernel} +\end{equation} +In passing from the exponential to \((1+N/X)^{-D}\), the constant +depends on the fixed \(D\), not on \(k\). + +Mellin inversion now expresses the \(N\)-piece of the terminal sum as +\[ + \frac1{2\pi}\int_{\mathbb R} + \widehat T_N(t,d/X)N^{it} + P_d(N,t)\,dt,\qquad + P_d(N,t)=\sum_{n\ge1}\frac{\lambda(n)\chi_d(n)}{\sqrt n}\, + n^{-it}G(n/N). +\] +Indeed \(G(n/N)T_N(n/N,x)=T_N(n/N,x)\). +Define the normalized family norm by +\[ + \|B_d\|_{2,X} + =\left(\frac1X\sum_{\substack{d\ {\rm admissible}\\X\le|d|<2X}} + |B_d|^2\right)^{1/2}. +\] +We bound the kernel uniformly before applying the family moment. +For each fixed \(t\), +\[ + \|\widehat T_N(t,d/X)P_d(N,t)\|_{2,X} + \le \sup_{x\in\mathcal K}|\widehat T_N(t,x)| + \|P_d(N,t)\|_{2,X}. +\] +Minkowski's inequality, followed by +\eqref{weights:moment-interface} and +\eqref{weights:terminal-kernel}, therefore yields +\[ + \begin{split} + \|S_{*,\chi_d}(d/X)\|_{2,X} + &\ll \ell^{C_r+B/2}\delta_J^k + \sum_{N=1,2,4,\ldots}(1+N/X)^{-D+A/2} + \int_{\mathbb R}(1+|t|)^{-r+A/2}\,dt\\ + &\ll \ell^{C_r+B/2+1}\delta_J^k. + \end{split} +\] +The integral converges by the fixed choice of \(r\). +There are \(O(\ell)\) dyadic terms with \(N\le X\), and those +with \(N>X\) form a convergent geometric tail by the choice of +\(D\). All sums and integrals can first be truncated; the displayed +integrable majorants justify passage to the limit. Squaring proves +\eqref{weights:terminal-square}, for example with +\(C_T=2C_r+B+2\). This exponent depends only on choices made before +\(k_0\). Restricting the family can only decrease the nonnegative +sum. +\end{proof} + +\begin{lemma}[Uniform absorption of the terminal loss] +\label{weights:terminal-small} +After increasing the fixed \(k_0\), one sufficiently large lower +bound on \(X\) makes +\begin{equation} + \frac1X\sum_{\substack{d\ {\rm admissible}\\X\le|d|<2X}} + |S_{*,\chi_d}(d/X)|^2 + \ll 2^{-3Jk/2} + \label{weights:terminal-small-square} +\end{equation} +simultaneously for all \(k\) in \eqref{weights:range}. +Moreover, for any fixed \(c,L>0\), the comparison errors obey +\begin{equation} + e^{-c\Delta_j\ell} + \le k^{-L}2^{-Ljk}\qquad(0\le j\le J) + \label{weights:comparison-absorption} +\end{equation} +for one sufficiently large lower bound on \(X\). +\end{lemma} + +\begin{proof} +The ratio of the right side of +\eqref{weights:terminal-square} to \(2^{-3Jk/2}\), apart from its +fixed implied constant, is +\[ + \ell^{C_T}2^{-Jk/2}. +\] +For \(J\ge1\) this decreases with \(k\), so throughout the permitted +range it is at most its value at the fixed integer \(k_0\). +The floor in the definition of \(J\) gives +\[ + \ell^{C_T}2^{-Jk/2} + \le \ell^{C_T}2^{-Jk_0/2} + \le 2^{k_0/2}\ell^{C_T-k_0/20}. +\] +Choose \(k_0>20C_T\) after \(C_T\) is fixed. The last expression +then tends to zero with \(X\). In particular the choice of a +single \(X\)-threshold works for the entire \(k\)-range. + +For the second assertion, +\(\Delta_j\ell\ge\ell^{9/10}/4\), whereas uniformly in the same +range +\[ + L\log k+Ljk\log2 + =O_L(\ell^{3/5}\log\ell)=o(\ell^{9/10}). +\] +Taking logarithms proves \eqref{weights:comparison-absorption}. +\end{proof} diff --git a/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/paper.pdf b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/paper.pdf new file mode 100644 index 0000000000000000000000000000000000000000..690ce77fa0fccf98925da106d4d76f9668d16556 --- /dev/null +++ b/preprints/The-mean-analytic-rank-of-quadratic-twists-of-elliptic-curves-October-6-2026/paper.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:718fcfce4014a878685365edfb8a285a611512dea362dc5a9e1dc93d023cd7b1 +size 549633 diff --git a/preprints/The-p-adic-section-conjecture-October-6-2026/README.md b/preprints/The-p-adic-section-conjecture-October-6-2026/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a654f9565ce9e482fe47d9425c0f2916dc5e9afb --- /dev/null +++ b/preprints/The-p-adic-section-conjecture-October-6-2026/README.md @@ -0,0 +1,21 @@ +# [The p-adic section conjecture](main.pdf) + +**Author:** OpenAI + +**Date:** October 6, 2026 + +## Citation + +```bibtex +@misc{OAI:The-p-adic-section-conjecture-October-6-2026, + author = {{OpenAI}}, + title = {{The p-adic section conjecture}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/The-p-adic-section-conjecture-October-6-2026/main.pdf}{OAI:The-p-adic-section-conjecture-October-6-2026}}, + year = {2026} +} +``` + +## Version note + +This version updates citations to revised manuscripts in this collection; see the [previous version](../The-p-adic-section-conjecture-September-24-2026/main.pdf). diff --git a/preprints/The-p-adic-section-conjecture-October-6-2026/build/main.tex b/preprints/The-p-adic-section-conjecture-October-6-2026/build/main.tex new file mode 100644 index 0000000000000000000000000000000000000000..8e31ff71e66424804d695144b7520b2e4d39efd5 --- /dev/null +++ b/preprints/The-p-adic-section-conjecture-October-6-2026/build/main.tex @@ -0,0 +1,55 @@ +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{lmodern} +\usepackage[a4paper,margin=1in]{geometry} +\usepackage{amsmath,amssymb,amsthm,amscd,mathtools} +\usepackage{microtype} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,decorations.markings} +\PassOptionsToPackage{hyphens}{url} +\usepackage[hidelinks]{hyperref} +\hypersetup{pdftitle={The p-adic section conjecture},pdfauthor={OpenAI}} +\usepackage{enumitem} +\numberwithin{equation}{section} +\newtheorem{theorem}{Theorem}[section] +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{remark} +\newtheorem{remark}[theorem]{Remark} +\newtheorem{definition}[theorem]{Definition} +\DeclareMathOperator{\Gal}{Gal} +\title{The p-adic section conjecture} +\author{OpenAI} +\date{October 6, 2026} +\pdfinfoomitdate=1 +\pdftrailerid{} +\pdfsuppressptexinfo=15 +\begin{document} +\maketitle +\begin{abstract} +We prove the local $p$-adic section conjecture for smooth proper +geometrically connected curves of genus at least two, over every finite +extension of $\mathbb Q_p$. +Combined with established finite-descent theorems, this also yields the +global section conjecture for smooth proper geometrically connected +curves of genus at least two over number fields when their finite-cover +descent locus equals their rational points; this includes $X_0(N)$ and +$X_1(N)$ of genus at least two over $\mathbb Q$. +\end{abstract} +\tableofcontents +\input{sections/01-introduction} +\input{sections/02-preliminaries} +\input{sections/03-patching} +\input{sections/04-tame-roots} +\input{sections/05-arbitrary-roots} +\input{sections/06-realization} +\input{sections/07-sections} +\input{sections/08-global-sections} +\begingroup +\raggedright +\bibliographystyle{plain} +\bibliography{references} +\endgroup +\end{document} diff --git a/preprints/The-p-adic-section-conjecture-October-6-2026/main.pdf b/preprints/The-p-adic-section-conjecture-October-6-2026/main.pdf new file mode 100644 index 0000000000000000000000000000000000000000..7d0da6f929be9fe3f8fedfc211b7c7bc497a7b3d --- /dev/null +++ b/preprints/The-p-adic-section-conjecture-October-6-2026/main.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3c8d6f784d6bae48305f6959c44c7cc337f9c2b6078d93a5595d317b3a82f40 +size 491950